From 6b8310ccc48824b57999db58cb93209e57bdf8d8 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Fri, 24 Jan 2025 23:59:46 -0800 Subject: [PATCH 01/50] adjusted risp max timestep. now b bins failing on gdc. --- src/hisp/model.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/hisp/model.py b/src/hisp/model.py index 32fd6c17..9e40f558 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -164,6 +164,8 @@ def max_stepsize(self, t: float) -> float: value = None # s elif relative_time_within_sub_pulse < time_real_risp_starts + 1: value = 0.01 # s + elif relative_time_within_sub_pulse < time_real_risp_starts + 50: + value = 0.1 # s else: # NOTE this seems to have an influence on the accuracy of the calculation value = 1 # s From 7b8fbcfad270422602c0f7eeace1973ca185fd24 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 26 Jan 2025 16:55:27 -0800 Subject: [PATCH 02/50] custom settings class to make rtol a callable --- src/hisp/festim_models/mb_model.py | 3 +- src/hisp/settings.py | 94 ++++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+), 1 deletion(-) create mode 100644 src/hisp/settings.py diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 02524892..57192c5d 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -2,6 +2,7 @@ from hisp.helpers import PulsedSource, gaussian_distribution, Stepsize from hisp.scenario import Scenario from hisp.plamsa_data_handling import PlasmaDataHandling +from hisp.settings import CustomSettings import hisp.bin import numpy as np @@ -539,7 +540,7 @@ def make_B_mb_model( quantities[species.name] = quantity ############# Settings ############# - my_model.settings = F.Settings( + my_model.settings = CustomSettings( atol=1e8, rtol=1e-10, max_iterations=30, diff --git a/src/hisp/settings.py b/src/hisp/settings.py new file mode 100644 index 00000000..13f3ba4a --- /dev/null +++ b/src/hisp/settings.py @@ -0,0 +1,94 @@ +import festim as F +from collections.abc import Callable +import dolfinx +import numpy.typing as npt + + +class CustomSettings(F.Settings): + """Custom Settings for a festim Boron simulation. + + Args: + atol (float): Absolute tolerance for the solver. + rtol (float, Callable): Relative tolerance for the solver. + max_iterations (int, optional): Maximum number of iterations for the + solver. Defaults to 30. + transient (bool, optional): Whether the simulation is transient or not. + final_time (float, optional): Final time for a transient simulation. + Defaults to None + stepsize (festim.Stepsize, optional): stepsize for a transient + simulation. Defaults to None + + Attributes: + atol (float): Absolute tolerance for the solver. + rtol (float): Relative tolerance for the solver. + max_iterations (int): Maximum number of iterations for the solver. + transient (bool): Whether the simulation is transient or not. + final_time (float): Final time for a transient simulation. + stepsize (festim.Stepsize): stepsize for a transient + simulation. + """ + + def __init__( + self, + atol, + rtol: ( + float + | Callable[ + [npt.NDArray[dolfinx.default_scalar_type]], + npt.NDArray[dolfinx.default_scalar_type], + ] + | None + ) = None, + max_iterations=30, + transient=True, + final_time=None, + stepsize=None, + ) -> None: + self.atol = atol + self.rtol = rtol + self.max_iterations = max_iterations + self.transient = transient + self.final_time = final_time + self.stepsize = stepsize + + @property + def stepsize(self): + return self._stepsize + + @stepsize.setter + def stepsize(self, value): + if value is None: + self._stepsize = None + elif isinstance(value, (float, int)): + self._stepsize = F.Stepsize(initial_value=value) + elif isinstance(value, F.Stepsize): + self._stepsize = value + else: + raise TypeError("stepsize must be an of type int, float or festim.Stepsize") + + @property + def rtol(self): + return self._rtol + + @rtol.setter + def rtol(self, value): + if value is None: + self._rtol = value + elif isinstance(value, float): + self._rtol = value + elif callable(value): + self._rtol = value + else: + raise TypeError( + "Value must be a float, or callable" + ) + + @property + def rtol_time_dependent(self): + if self.rtol is None: + return False + if callable(self.rtol): + arguments = self.rtol.__code__.co_varnames + return "t" in arguments + else: + return False \ No newline at end of file From 1624e441c3fb4376280e9cb6ae734dd898d0411e Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 26 Jan 2025 17:23:08 -0800 Subject: [PATCH 03/50] allow b model to accept custom rtol, add test for float and callable rtol options --- src/hisp/festim_models/mb_model.py | 5 +++-- test/test_mb_model_festim.py | 23 ++++++++++++++++++++++- 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 57192c5d..14ee88ed 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -9,7 +9,7 @@ import festim as F import h_transport_materials as htm -from typing import Callable, Tuple, Dict +from typing import Callable, Tuple, Dict, Union from numpy.typing import NDArray # TODO this is hard coded and show depend on incident energy? @@ -296,6 +296,7 @@ def make_B_mb_model( final_time: float, folder: str, L: float, + custom_rtol: Union[float, Callable] = 1e-10, # default rtol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter exports=False, ) -> Tuple[CustomProblem, Dict[str, F.TotalVolume]]: """Create a FESTIM model for the B MB scenario. @@ -542,7 +543,7 @@ def make_B_mb_model( ############# Settings ############# my_model.settings = CustomSettings( atol=1e8, - rtol=1e-10, + rtol=custom_rtol, max_iterations=30, final_time=final_time, ) diff --git a/test/test_mb_model_festim.py b/test/test_mb_model_festim.py index 27810954..d52543c8 100644 --- a/test/test_mb_model_festim.py +++ b/test/test_mb_model_festim.py @@ -4,8 +4,8 @@ make_DFW_mb_model, ) +from hisp.settings import CustomSettings import festim as F - import pytest @@ -153,3 +153,24 @@ def fun(t): my_model.dt.value = 20 my_model.iterate() + + + +@pytest.mark.parametrize( + "rtol", [1e-10, lambda t: 1e-8 + 1e-7] + ) +def test_callable_rtol(rtol): + """Builds B model to test custom rtol.""" + (my_model, quantities) = make_B_mb_model( + temperature=500, + deuterium_ion_flux=lambda _: 1e22, + deuterium_atom_flux=lambda _: 1e22, + tritium_ion_flux=lambda _: 1e22, + tritium_atom_flux=lambda _: 1e22, + final_time=50, + L=6e-3, + custom_rtol=rtol, + folder=".", + ) + + assert my_model.settings.rtol == rtol From 1fb318ac4b63bbe3ab0e6b8839b07f4b7e26a77b Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 26 Jan 2025 18:44:18 -0800 Subject: [PATCH 04/50] adjust rtol test --- test/test_mb_model_festim.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/test_mb_model_festim.py b/test/test_mb_model_festim.py index d52543c8..a125469d 100644 --- a/test/test_mb_model_festim.py +++ b/test/test_mb_model_festim.py @@ -157,7 +157,7 @@ def fun(t): @pytest.mark.parametrize( - "rtol", [1e-10, lambda t: 1e-8 + 1e-7] + "rtol", [1e-10, lambda t: 1e-8 if t<10 else 1e-10] ) def test_callable_rtol(rtol): """Builds B model to test custom rtol.""" @@ -173,4 +173,7 @@ def test_callable_rtol(rtol): folder=".", ) + # initialise the model + my_model.initialise() + assert my_model.settings.rtol == rtol From fb0daf4c77da4dbbace37eb1b2e2fb38cc237cba Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 26 Jan 2025 18:50:09 -0800 Subject: [PATCH 05/50] update festim version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 05c0a801..ce7add12 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ requires-python = ">=3.9" license = { file = "LICENSE" } dependencies = [ "h_transport_materials~=0.17", - "festim@git+https://github.com/festim-dev/FESTIM@effcbac86ba0620da1388dcee4e8424ce33939db"] + "festim@git+https://github.com/kaelyndunnell/FESTIM@4e3874cca399ef3521b00243fc309088c483f03d"] classifiers = [ "Natural Language :: English", From 6927f7a02e093de869cc3ce72893605e4e440636 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 26 Jan 2025 19:28:08 -0800 Subject: [PATCH 06/50] custom rtol for gdc --- src/hisp/model.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/hisp/model.py b/src/hisp/model.py index 9e40f558..88b5cc3f 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -141,6 +141,7 @@ def which_model(self, bin: SubBin | DivBin): elif bin.material == "B": return make_B_mb_model( **common_args, + custom_rtol=self.make_custom_rtol, folder=f"mb{parent_bin_index+1}_{bin.mode}_results", ) elif bin.material == "SS": @@ -245,3 +246,11 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: current_time = start_of_pulse + pulse.total_duration * pulse.nb_pulses return sorted(np.unique(milestones)) + + def make_custom_rtol(self, t:float) -> float: + pulse = self.scenario.get_pulse(t) + if pulse.pulse_type == "GDC": + rtol = 1e-11 + else: + rtol = 1e-10 + return rtol \ No newline at end of file From 388ed4d7ed896a3a97700ffa232290f53cca1a6c Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 28 Jan 2025 15:54:49 -0800 Subject: [PATCH 07/50] different rtols for gdc and icwc --- src/hisp/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 88b5cc3f..8366cb3d 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -249,7 +249,7 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: def make_custom_rtol(self, t:float) -> float: pulse = self.scenario.get_pulse(t) - if pulse.pulse_type == "GDC": + if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-11 else: rtol = 1e-10 From ae9c771eabc2fabf22aa6dabc0cfd38b2f4c0773 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 28 Jan 2025 20:11:25 -0800 Subject: [PATCH 08/50] custom rtol for bake, but not solving. needs further adjusting --- src/hisp/model.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/hisp/model.py b/src/hisp/model.py index 8366cb3d..8868bdce 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -251,6 +251,8 @@ def make_custom_rtol(self, t:float) -> float: pulse = self.scenario.get_pulse(t) if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-11 + elif pulse.pulse_type == "BAKE": + rtol = 1e-9 else: rtol = 1e-10 return rtol \ No newline at end of file From bbc05eb83b1a493dded91bd8f62d0372352033fd Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 29 Jan 2025 16:35:29 -0800 Subject: [PATCH 09/50] adjusted W mesh --- src/hisp/festim_models/mb_model.py | 66 +++++++++++++++--------------- 1 file changed, 32 insertions(+), 34 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 14ee88ed..e8a7c513 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -49,10 +49,8 @@ def make_W_mb_model( vertices = np.concatenate( # 1D mesh with extra refinement [ - np.linspace(0, 30e-9, num=300), - np.linspace(30e-9, 3e-6, num=400), - np.linspace(3e-6, 30e-6, num=400), - np.linspace(30e-6, 1e-4, num=400), + np.linspace(0, 1e-5, num=100), + np.linspace(1e-5, 1e-4, num=300), np.linspace(1e-4, L, num=300), ] ) @@ -89,8 +87,8 @@ def make_W_mb_model( trap1_T = F.Species("trap1_T", mobile=False) trap2_D = F.Species("trap2_D", mobile=False) trap2_T = F.Species("trap2_T", mobile=False) - trap3_D = F.Species("trap3_D", mobile=False) - trap3_T = F.Species("trap3_T", mobile=False) + # trap3_D = F.Species("trap3_D", mobile=False) + # trap3_T = F.Species("trap3_T", mobile=False) # traps empty_trap1 = F.ImplicitSpecies( # implicit trap 1 @@ -105,13 +103,13 @@ def make_W_mb_model( name="empty_trap2", ) - # TODO: make trap space dependent (existing in only first 10nm) + # TODO: make trap space dependent (existing in only first 10nm). commenting out until implemented # density_func = lambda x: ufl.conditional(ufl.gt(x[0],10), 6.338e27, 0.0) # small damanged zone in first 10nm, 1e-1 at.fr. - empty_trap3 = F.ImplicitSpecies( - n=6.338e27, - others=[trap3_T, trap3_D], - name="empty_trap3", - ) + # empty_trap3 = F.ImplicitSpecies( + # n=6.338e27, + # others=[trap3_T, trap3_D], + # name="empty_trap3", + # ) my_model.species = [ mobile_D, @@ -120,8 +118,8 @@ def make_W_mb_model( trap1_T, trap2_D, trap2_T, - trap3_D, - trap3_T, + # trap3_D, + # trap3_T, ] interstitial_distance = 1.117e-10 # m @@ -165,24 +163,24 @@ def make_W_mb_model( reactant=[mobile_T, empty_trap2], product=trap2_T, ), - F.Reaction( - k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), - E_k=E_D, - p_0=1e13, - E_p=1.5, - volume=w_subdomain, - reactant=[mobile_D, empty_trap3], - product=trap3_D, - ), - F.Reaction( - k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), - E_k=E_D, - p_0=1e13, - E_p=1.5, - volume=w_subdomain, - reactant=[mobile_T, empty_trap3], - product=trap3_T, - ), + # F.Reaction( + # k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), + # E_k=E_D, + # p_0=1e13, + # E_p=1.5, + # volume=w_subdomain, + # reactant=[mobile_D, empty_trap3], + # product=trap3_D, + # ), + # F.Reaction( + # k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), + # E_k=E_D, + # p_0=1e13, + # E_p=1.5, + # volume=w_subdomain, + # reactant=[mobile_T, empty_trap3], + # product=trap3_T, + # ), ] ############# Temperature Parameters (K) ############# @@ -264,8 +262,8 @@ def make_W_mb_model( F.VTXSpeciesExport(f"{folder}/trapped_concentration_t1.bp", field=trap1_T), F.VTXSpeciesExport(f"{folder}/trapped_concentration_d2.bp", field=trap2_D), F.VTXSpeciesExport(f"{folder}/trapped_concentration_t2.bp", field=trap2_T), - F.VTXSpeciesExport(f"{folder}/trapped_concentration_d3.bp", field=trap3_D), - F.VTXSpeciesExport(f"{folder}/trapped_concentration_t3.bp", field=trap3_T), + # F.VTXSpeciesExport(f"{folder}/trapped_concentration_d3.bp", field=trap3_D), + # F.VTXSpeciesExport(f"{folder}/trapped_concentration_t3.bp", field=trap3_T), ] quantities = {} From 50fdc925d93c5da94554d75f48a4521efc95f499 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 29 Jan 2025 16:36:27 -0800 Subject: [PATCH 10/50] additional milestones at end of ramp up and beginning of ramp down --- src/hisp/model.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/hisp/model.py b/src/hisp/model.py index 8868bdce..47c2ae88 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -209,6 +209,20 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: # hack: a milestone right after to ensure the stepsize is small enough milestones.append(start_of_pulse + pulse.total_duration * i + initial_stepsize_value) + if i == 0: + # end of ramp up + milestones.append(start_of_pulse + pulse.ramp_up) + + # start of ramp down + milestones.append(start_of_pulse + pulse.ramp_up + pulse.steady_state) + + else: + # end of ramp up + milestones.append(start_of_pulse + pulse.total_duration * (i - 1) + pulse.ramp_up) + + # start of ramp down + milestones.append(start_of_pulse + pulse.total_duration * (i - 1) + pulse.ramp_up + pulse.steady_state) + # start of the next pulse milestones.append(start_of_pulse + pulse.total_duration * (i + 1)) From 8fe882039193b19329e70c0e0cfa535ebd349ea6 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 2 Feb 2025 11:59:10 -0600 Subject: [PATCH 11/50] bake temp adjustment --- src/hisp/festim_models/mb_model.py | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index e8a7c513..816139e1 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -1,5 +1,5 @@ from hisp.h_transport_class import CustomProblem -from hisp.helpers import PulsedSource, gaussian_distribution, Stepsize +from hisp.helpers import PulsedSource, gaussian_distribution, Stepsize, periodic_step_function from hisp.scenario import Scenario from hisp.plamsa_data_handling import PlasmaDataHandling from hisp.settings import CustomSettings @@ -852,10 +852,21 @@ def T_function(x: NDArray, t: float) -> NDArray: # get the pulse and time relative to the start of the pulse pulse = scenario.get_pulse(t) t_rel = t - scenario.get_time_start_current_pulse(t) - + if pulse.pulse_type == "BAKE": - T_bake = 483.15 # K - value = np.full_like(x[0], T_bake) + total_time_on = pulse.duration_no_waiting + total_time_pulse = pulse.total_duration + + return periodic_step_function( + t_rel, + period_on=total_time_on, + period_total=total_time_pulse, + value=483.15, # K + value_off=0, + ) + # if pulse.pulse_type == "BAKE": + # T_bake = 483.15 # K + # value = np.full_like(x[0], T_bake) else: heat_flux = plasma_data_handling.get_heat(pulse, bin, t_rel) if ( From 2e7947cb6c8c7aef55f0ba1f563c6d0d1a304dfe Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 22:37:29 -0500 Subject: [PATCH 12/50] testing something --- src/hisp/festim_models/mb_model.py | 7 +++---- src/hisp/helpers.py | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 816139e1..ed6b872a 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -1,5 +1,5 @@ from hisp.h_transport_class import CustomProblem -from hisp.helpers import PulsedSource, gaussian_distribution, Stepsize, periodic_step_function +from hisp.helpers import PulsedSource, gaussian_distribution, Stepsize, periodic_pulse_function from hisp.scenario import Scenario from hisp.plamsa_data_handling import PlasmaDataHandling from hisp.settings import CustomSettings @@ -857,10 +857,9 @@ def T_function(x: NDArray, t: float) -> NDArray: total_time_on = pulse.duration_no_waiting total_time_pulse = pulse.total_duration - return periodic_step_function( + return periodic_pulse_function( t_rel, - period_on=total_time_on, - period_total=total_time_pulse, + pulse=pulse, value=483.15, # K value_off=0, ) diff --git a/src/hisp/helpers.py b/src/hisp/helpers.py index 18ca0ab6..e2a14c2c 100644 --- a/src/hisp/helpers.py +++ b/src/hisp/helpers.py @@ -97,3 +97,22 @@ def periodic_step_function(x, period_on, period_total, value, value_off=0.0): return value else: return value_off + +def periodic_pulse_function(current_time, pulse: Pulse, value, value_off=343.0): + """Creates bake function with ramp up rate and ramp down rate. + + Args: + FILL IN + """ + if current_time < 100: + return 343 + else: + return 400 + + # if current_time % pulse.total_duration < pulse.ramp_up: # ramp up + # return (value - value_off) / (pulse.ramp_up) * current_time + value_off # y = mx + b, slope is temp/ramp up time + # elif current_time % pulse.total_duration < pulse.ramp_up + pulse.steady_state: # steady state + # return value + # else: # ramp down, waiting + # return (value_off - value) / (pulse.ramp_down) * current_time + value_off # y = mx + b, slope is temp/ramp down time + From b120dfc87bc67e40a941dd5baff2391907f20104 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 22:39:21 -0500 Subject: [PATCH 13/50] test --- src/hisp/helpers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/helpers.py b/src/hisp/helpers.py index e2a14c2c..23bb0349 100644 --- a/src/hisp/helpers.py +++ b/src/hisp/helpers.py @@ -104,7 +104,7 @@ def periodic_pulse_function(current_time, pulse: Pulse, value, value_off=343.0): Args: FILL IN """ - if current_time < 100: + if current_time < 300000: return 343 else: return 400 From 1ac4467af8dc02748ec881968b593402d5be7c0c Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 22:41:29 -0500 Subject: [PATCH 14/50] testing plotting function for bake --- src/hisp/festim_models/mb_model.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index ed6b872a..1b4ea682 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -856,13 +856,13 @@ def T_function(x: NDArray, t: float) -> NDArray: if pulse.pulse_type == "BAKE": total_time_on = pulse.duration_no_waiting total_time_pulse = pulse.total_duration - - return periodic_pulse_function( - t_rel, - pulse=pulse, - value=483.15, # K - value_off=0, - ) + return np.full_like(x[0], 300) + # return periodic_pulse_function( + # t_rel, + # pulse=pulse, + # value=483.15, # K + # value_off=0, + # ) # if pulse.pulse_type == "BAKE": # T_bake = 483.15 # K # value = np.full_like(x[0], T_bake) From e70be9e65b1e3bfc2e263fe34600dd5655996a0c Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 23:12:50 -0500 Subject: [PATCH 15/50] actual ramp up and ramp down for bake --- src/hisp/festim_models/mb_model.py | 20 ++++++++------------ src/hisp/helpers.py | 29 ++++++++++++++++------------- 2 files changed, 24 insertions(+), 25 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 1b4ea682..8d91c2f5 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -854,18 +854,14 @@ def T_function(x: NDArray, t: float) -> NDArray: t_rel = t - scenario.get_time_start_current_pulse(t) if pulse.pulse_type == "BAKE": - total_time_on = pulse.duration_no_waiting - total_time_pulse = pulse.total_duration - return np.full_like(x[0], 300) - # return periodic_pulse_function( - # t_rel, - # pulse=pulse, - # value=483.15, # K - # value_off=0, - # ) - # if pulse.pulse_type == "BAKE": - # T_bake = 483.15 # K - # value = np.full_like(x[0], T_bake) + T_value = periodic_pulse_function( + t_rel, + pulse=pulse, + value=483.15, # K + value_off=343.0, + ) + value = np.full_like(x[0], T_value) + else: heat_flux = plasma_data_handling.get_heat(pulse, bin, t_rel) if ( diff --git a/src/hisp/helpers.py b/src/hisp/helpers.py index 23bb0349..03e969b2 100644 --- a/src/hisp/helpers.py +++ b/src/hisp/helpers.py @@ -98,21 +98,24 @@ def periodic_step_function(x, period_on, period_total, value, value_off=0.0): else: return value_off -def periodic_pulse_function(current_time, pulse: Pulse, value, value_off=343.0): +def periodic_pulse_function(current_time: float, pulse: Pulse, value, value_off=343.0): """Creates bake function with ramp up rate and ramp down rate. Args: - FILL IN + current_time (float): time within the pulse + pulse (Pulse): pulse of HISP Pulse class + value (float): steady-state value + value_off (float): value at t=0 and t=final time. """ - if current_time < 300000: - return 343 - else: - return 400 - # if current_time % pulse.total_duration < pulse.ramp_up: # ramp up - # return (value - value_off) / (pulse.ramp_up) * current_time + value_off # y = mx + b, slope is temp/ramp up time - # elif current_time % pulse.total_duration < pulse.ramp_up + pulse.steady_state: # steady state - # return value - # else: # ramp down, waiting - # return (value_off - value) / (pulse.ramp_down) * current_time + value_off # y = mx + b, slope is temp/ramp down time - + if current_time % pulse.total_duration < pulse.ramp_up: # ramp up + return (value - value_off) / (pulse.ramp_up) * current_time + value_off # y = mx + b, slope is temp/ramp up time + elif current_time % pulse.total_duration < pulse.ramp_up + pulse.steady_state: # steady state + return value + else: # ramp down, waiting + current_temp = value - (value - value_off)/pulse.ramp_down * (current_time - (pulse.ramp_up + pulse.steady_state)) # y = mx + b, slope is temp/ramp down time + + if current_temp >= value_off: + return current_temp + else: + return value_off \ No newline at end of file From cce4d8d55d5cc9f1d33182b2901930b168367987 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 23:23:11 -0500 Subject: [PATCH 16/50] fix bake rtol --- src/hisp/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 47c2ae88..b7bec460 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -265,8 +265,8 @@ def make_custom_rtol(self, t:float) -> float: pulse = self.scenario.get_pulse(t) if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-11 - elif pulse.pulse_type == "BAKE": - rtol = 1e-9 + elif pulse.pulse_type == "BAKE": + rtol = 1e-14 else: rtol = 1e-10 return rtol \ No newline at end of file From 63a257d1da0c6d3a568ce74b2380114f1467280a Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 23:26:24 -0500 Subject: [PATCH 17/50] add import line in helpers --- src/hisp/helpers.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/hisp/helpers.py b/src/hisp/helpers.py index 03e969b2..cb46d54d 100644 --- a/src/hisp/helpers.py +++ b/src/hisp/helpers.py @@ -3,6 +3,7 @@ import ufl import numpy as np import numpy.typing as npt +from hisp.scenario import Pulse class PulsedSource(F.ParticleSource): From 56dffcc9271ff4c909d10782f22dfc0dce6fca6b Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 23:26:50 -0500 Subject: [PATCH 18/50] add units --- src/hisp/festim_models/mb_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 8d91c2f5..94f38331 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -858,10 +858,10 @@ def T_function(x: NDArray, t: float) -> NDArray: t_rel, pulse=pulse, value=483.15, # K - value_off=343.0, + value_off=343.0, # K ) value = np.full_like(x[0], T_value) - + else: heat_flux = plasma_data_handling.get_heat(pulse, bin, t_rel) if ( From 2f1da570196da79d696a413cc075f04f41300f81 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 3 Feb 2025 23:47:10 -0500 Subject: [PATCH 19/50] add lower rtols for waiting time of FP --- src/hisp/model.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/hisp/model.py b/src/hisp/model.py index b7bec460..0f63d8f6 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -263,10 +263,13 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: def make_custom_rtol(self, t:float) -> float: pulse = self.scenario.get_pulse(t) + relative_time = t - self.scenario.get_time_start_current_pulse(t) if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-11 elif pulse.pulse_type == "BAKE": rtol = 1e-14 + elif pulse.pulse_type == "FP" and relative_time % pulse.total_duration > pulse.duration_no_waiting: + rtol = 1e-15 else: rtol = 1e-10 return rtol \ No newline at end of file From ba6eab3d03ffd988a7568b48c2311b8e314359f3 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 4 Feb 2025 21:33:55 -0500 Subject: [PATCH 20/50] adjust bake rtol --- src/hisp/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 0f63d8f6..bcfba88d 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -267,7 +267,7 @@ def make_custom_rtol(self, t:float) -> float: if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-11 elif pulse.pulse_type == "BAKE": - rtol = 1e-14 + rtol = 1e-13 elif pulse.pulse_type == "FP" and relative_time % pulse.total_duration > pulse.duration_no_waiting: rtol = 1e-15 else: From bbbbe95d7a0cda377a8c18cd77dc24d9e55bc4c0 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 5 Feb 2025 23:08:18 -0500 Subject: [PATCH 21/50] updated rtol for W bake --- src/hisp/festim_models/mb_model.py | 3 ++- src/hisp/model.py | 10 ++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 94f38331..e9f4f118 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -26,6 +26,7 @@ def make_W_mb_model( final_time: float, folder: str, L: float, + custom_rtol: Union[float, Callable] = 1e-10, # default rtol unless otherwise specified, used for everything but BAKE exports=False, ) -> Tuple[CustomProblem, Dict[str, F.TotalVolume]]: """Create a FESTIM model for the W MB scenario. @@ -275,7 +276,7 @@ def make_W_mb_model( ############# Settings ############# my_model.settings = F.Settings( atol=1e10, - rtol=1e-10, + rtol=custom_rtol, max_iterations=100, # the first timestep needs about 66 iterations.... final_time=final_time, ) diff --git a/src/hisp/model.py b/src/hisp/model.py index bcfba88d..c55ca84f 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -136,6 +136,7 @@ def which_model(self, bin: SubBin | DivBin): if bin.material == "W": return make_W_mb_model( **common_args, + custom_rtol=self.bake_rtol, folder=f"mb{parent_bin_index+1}_{bin.mode}_results", ) elif bin.material == "B": @@ -272,4 +273,13 @@ def make_custom_rtol(self, t:float) -> float: rtol = 1e-15 else: rtol = 1e-10 + return rtol + + def bake_rtol(self, t:float) -> float: + pulse = self.scenario.get_pulse(t) + relative_time = t - self.scenario.get_time_start_current_pulse(t) + if pulse.pulse_type == "BAKE": + rtol = 1e-12 + else: + rtol = 1e-10 return rtol \ No newline at end of file From 1d3d54b5f83b58e0244e1fe48c914f2fc171a377 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 10 Feb 2025 17:01:30 -0500 Subject: [PATCH 22/50] change festim install --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index ce7add12..a97fcf52 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ requires-python = ">=3.9" license = { file = "LICENSE" } dependencies = [ "h_transport_materials~=0.17", - "festim@git+https://github.com/kaelyndunnell/FESTIM@4e3874cca399ef3521b00243fc309088c483f03d"] + "festim@git+https://github.com/kaelyndunnell/FESTIM@9ac79df299171f12a57406755e441d8deb35c186"] classifiers = [ "Natural Language :: English", From 5b274e6f9fca9f6896e59ffa00f6158223d2aa63 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 10 Feb 2025 17:01:45 -0500 Subject: [PATCH 23/50] make atol callable, add test --- src/hisp/festim_models/mb_model.py | 5 ++-- src/hisp/settings.py | 42 +++++++++++++++++++++++++++--- test/test_mb_model_festim.py | 23 ++++++++++++++++ 3 files changed, 64 insertions(+), 6 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index e9f4f118..76575a6d 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -274,7 +274,7 @@ def make_W_mb_model( quantities[species.name] = quantity ############# Settings ############# - my_model.settings = F.Settings( + my_model.settings = CustomSettings( atol=1e10, rtol=custom_rtol, max_iterations=100, # the first timestep needs about 66 iterations.... @@ -295,6 +295,7 @@ def make_B_mb_model( final_time: float, folder: str, L: float, + custom_atol: Union[float, Callable] = 1e8, # default atol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter custom_rtol: Union[float, Callable] = 1e-10, # default rtol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter exports=False, ) -> Tuple[CustomProblem, Dict[str, F.TotalVolume]]: @@ -541,7 +542,7 @@ def make_B_mb_model( ############# Settings ############# my_model.settings = CustomSettings( - atol=1e8, + atol=custom_atol, rtol=custom_rtol, max_iterations=30, final_time=final_time, diff --git a/src/hisp/settings.py b/src/hisp/settings.py index 13f3ba4a..6e81d1f4 100644 --- a/src/hisp/settings.py +++ b/src/hisp/settings.py @@ -8,7 +8,7 @@ class CustomSettings(F.Settings): """Custom Settings for a festim Boron simulation. Args: - atol (float): Absolute tolerance for the solver. + atol (float, Callable): Absolute tolerance for the solver. rtol (float, Callable): Relative tolerance for the solver. max_iterations (int, optional): Maximum number of iterations for the solver. Defaults to 30. @@ -19,8 +19,8 @@ class CustomSettings(F.Settings): simulation. Defaults to None Attributes: - atol (float): Absolute tolerance for the solver. - rtol (float): Relative tolerance for the solver. + atol (float, Callable): Absolute tolerance for the solver. + rtol (float, Callable): Relative tolerance for the solver. max_iterations (int): Maximum number of iterations for the solver. transient (bool): Whether the simulation is transient or not. final_time (float): Final time for a transient simulation. @@ -30,7 +30,14 @@ class CustomSettings(F.Settings): def __init__( self, - atol, + atol: ( + float + | Callable[ + [npt.NDArray[dolfinx.default_scalar_type]], + npt.NDArray[dolfinx.default_scalar_type], + ] + | None + ) = None, rtol: ( float | Callable[ @@ -90,5 +97,32 @@ def rtol_time_dependent(self): if callable(self.rtol): arguments = self.rtol.__code__.co_varnames return "t" in arguments + else: + return False + + @property + def atol(self): + return self._atol + + @atol.setter + def atol(self, value): + if value is None: + self._atol = value + elif isinstance(value, float): + self._atol = value + elif callable(value): + self._atol = value + else: + raise TypeError( + "Value must be a float, or callable" + ) + + @property + def atol_time_dependent(self): + if self.atol is None: + return False + if callable(self.atol): + arguments = self.atol.__code__.co_varnames + return "t" in arguments else: return False \ No newline at end of file diff --git a/test/test_mb_model_festim.py b/test/test_mb_model_festim.py index a125469d..41e62b62 100644 --- a/test/test_mb_model_festim.py +++ b/test/test_mb_model_festim.py @@ -177,3 +177,26 @@ def test_callable_rtol(rtol): my_model.initialise() assert my_model.settings.rtol == rtol + +@pytest.mark.parametrize( + "atol", [1e10, lambda t: 1e12 if t<10 else 1e10] + ) +def test_callable_atol(atol): + """Builds B model to test custom rtol.""" + (my_model, quantities) = make_B_mb_model( + temperature=500, + deuterium_ion_flux=lambda _: 1e22, + deuterium_atom_flux=lambda _: 1e22, + tritium_ion_flux=lambda _: 1e22, + tritium_atom_flux=lambda _: 1e22, + final_time=50, + L=6e-3, + custom_atol=atol, + custom_rtol=1e-10, + folder=".", + ) + + # initialise the model + my_model.initialise() + + assert my_model.settings.atol == atol From 3b86213c225f52c5cde4effd854dea208d8c7a00 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 11 Feb 2025 22:14:21 -0500 Subject: [PATCH 24/50] make fp and other cleaning pulses actually ramp up and ramp down --- src/hisp/plamsa_data_handling/main.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/hisp/plamsa_data_handling/main.py b/src/hisp/plamsa_data_handling/main.py index e766e4e6..a7e084ec 100644 --- a/src/hisp/plamsa_data_handling/main.py +++ b/src/hisp/plamsa_data_handling/main.py @@ -1,7 +1,7 @@ import numpy as np from numpy.typing import NDArray from hisp.bin import SubBin, DivBin, FWBin -from hisp.helpers import periodic_step_function +from hisp.helpers import periodic_step_function, periodic_pulse_function from hisp.scenario import Pulse import pandas as pd @@ -100,10 +100,9 @@ def get_particle_flux( total_time_on = pulse.duration_no_waiting total_time_pulse = pulse.total_duration - return periodic_step_function( + return periodic_pulse_function( t_rel, - period_on=total_time_on, - period_total=total_time_pulse, + pulse=pulse, value=value, value_off=0, ) @@ -261,10 +260,9 @@ def get_heat(self, pulse: Pulse, bin: SubBin | DivBin, t_rel: float) -> float: total_time_on = pulse.duration_no_waiting total_time_pulse = pulse.total_duration - return periodic_step_function( + return periodic_pulse_function( t_rel, - period_on=total_time_on, - period_total=total_time_pulse, + pulse=pulse, value=heat_val, value_off=0, ) From a0ae53a9d63e7083be41ba1a28ee59729f1fdb81 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 11 Feb 2025 22:55:23 -0500 Subject: [PATCH 25/50] update plotting example --- examples/plotting.ipynb | 84 +++++++++++++++++++---------------------- 1 file changed, 38 insertions(+), 46 deletions(-) diff --git a/examples/plotting.ipynb b/examples/plotting.ipynb index 3d5be327..5364b51f 100644 --- a/examples/plotting.ipynb +++ b/examples/plotting.ipynb @@ -5,17 +5,9 @@ "execution_count": 1, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[lap-mathurin-01:825338] shmem: mmap: an error occurred while determining whether or not /tmp/ompi.lap-mathurin-01.1000/jf.0/3038838784/shared_mem_cuda_pool.lap-mathurin-01 could be created.\n", - "[lap-mathurin-01:825338] create_and_attach: unable to create shared memory BTL coordinating structure :: size 134217728 \n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -64,7 +56,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -129,7 +121,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -161,12 +153,12 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAGwCAYAAADrIxwOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkLUlEQVR4nO3deVxU5f4H8M+ZYd9BdsENTUQRFBExM1Ruil4X1DItt8yWq22Ypt1+mWXXLFNLudrVTHMps9RM01TcyiUVwxVJEQVRUGQfYICZ8/sDmSRAYBYOw3zer9d5NXPmnGe+MyF+fZ7v8zyCKIoiiIiIiPRIJnUARERE1PwwwSAiIiK9Y4JBREREescEg4iIiPSOCQYRERHpHRMMIiIi0jsmGERERKR3ZlIH0NSp1WrcunUL9vb2EARB6nCIiJo9URRRUFAAb29vyGSG+3dwSUkJSktLdW7HwsICVlZWeoioeWGCUYdbt27B19dX6jCIiExOWloafHx8DNJ2SUkJ2ra2Q8Ydlc5tOTg4wMvLCzKZDNOmTcO0adP0EKHxY4JRB3t7ewAVP+gODg4SR0NE1Pzl5+fD19dX8/vXEEpLS5FxR4Ub8W3gYK99L0l+gRqtQ67z74gaMMGoQ+WwiIODA394iIgaUWMMS9vZC7Cz1/591ODQeW2YYBARkclSiWqodNiRSyWq9RdMM8NZJEREZLLUEHU+ACA0NBQBAQGIjY2V+BM1HezBICIi0tGpU6c4jP43TDCIiMhkqaGGLoMcut3dvDHBICIik6USRahE7YswdLm3uWMNBhERkY5Yg1EdezCIiMhkPVioqe39AGswasIEg4iITJYaIlR6SDCoOqMYIrl+/TqmTJmCtm3bwtraGn5+fpg7d26da8hHRERAEIQqx0svvdRIURMREZkuo+jBuHz5MtRqNb744gu0b98eFy5cwNSpU6FQKLBo0aKH3jt16lS8//77muc2NjaGDpeIiIyEvoZIqDqjSDAGDRqEQYMGaZ63a9cOSUlJWLFiRZ0Jho2NDTw9PQ0dIhERGSF9zSIJDQ2FXC7nZmcPMIoEoyZ5eXlwcXGp87qNGzdiw4YN8PT0xNChQ/F///d/D+3FUCqVUCqVmuf5+fl6iZeIiJovFnlWZ5QJxtWrV7Fs2bI6ey/GjRuH1q1bw9vbG+fOncNbb72FpKQkbN26tdZ7FixYgHnz5ukt1sN/pqBP+9aQy4yi3IWIyKSo7x+63E81E0RRulVCZs+ejYULFz70msTERPj7+2uep6en4/HHH0dERARWr17doPc7cOAABgwYgKtXr8LPz6/Ga2rqwfD19UVeXl6Ds9PDf6bgpQ3b0dXHEx+OeALt3Vs06H4iIlOUn58PR0dHrX7vNvQ9Lia6w16H7doLCtTo3OmOQWM1VpL2YMyYMQOTJk166DXt2rXTPL516xb69euH3r1743//+1+D3y8sLAwAHppgWFpawtLSssFt16RQWQo7Swucu5mBkSs24l8RYZjSpwfM5XK9tE9ERLpRidBxN1X9xdLcSJpguLm5wc3NrV7Xpqeno1+/fggJCcFXX30FmRZDDgkJCQAALy+vBt+rjSGBHRHSyhvv/RSHw3+m4LO4Y9h78QrmRz+BAC/3RomBiIhICkZRGJCeno6IiAi0atUKixYtwt27d5GRkYGMjIwq1/j7++PkyZMAgOTkZHzwwQeIj4/H9evXsWPHDkyYMAF9+/ZF165dGy12T0d7rHhmOD4eNQiO1lZIzLiLp77YhKX7j6K0vLzR4iAiourUejgALhVeE6Mo8ty3bx+uXr2Kq1evwsfHp8prlSUkZWVlSEpKQlFREQDAwsIC+/fvx9KlS6FQKODr64tRo0bhnXfeafT4BUHA0KBOCPdrhQ93HcSei1fwxZGT2J94FfNHPIFg38bpUSEioqrUEKCCoNP9AGeR1ETSIk9jYIhio72XruCDnQeQVVgEQQAmhnfHq/17w9rCXC/tExEZs8Ys8jxzyQN2OhR5Fhao0T0gk0WeNTCKIZLm5omADvhp+kQMD+4EUQTWHjuDEf9dj5MpaVKHRkRkUtSi7gfVjAmGRJxsrPDRyEH44tkR8HSwQ2p2HiZ+9T3e+ykOhSXKuhsgIiKdqe4PkehyUM2YYEis7yNt8dP0CRjTIxAAsPnUOQyLXY9fr1yXNjAiIiIdMMFoAuysLPHesEisnTQavs6OuJ1XgBfWb8Ocrb8gt6hE6vCIiJot9mAYDhOMJiSsnS+2TxuPieHdIQjA9oRLGLp8HfZduip1aEREzZJaFHQ+qGZMMJoYGwtzzI56HBunjEE7VxdkFRbh1W9/whvf7cK9wiKpwyMiohpwHYzqjGIdDFPUrZU3tr78DFYc/h2rfzuFPRf+xIlrqfj34H4YEtgRgsCsmYhIV7oOc1Tey3UwqmMPRhNmaW6G1yMfxeYXxsLf0w25RSWY+f1uTNu0A5n5hVKHR0Rk9FSQ6XxQzfjNGIHO3h747sWxeLV/b5jLZTiYdA1Dl3+NLfHnwXXSiIi0J+pYfyGyBqNWTDCMhLlcjpcjwvDDy8+ga0tPFJQo8e6P+zFl3VbczMmTOjwiIqIqmGAYmQ7urtg0dQxmDewLSzM5jl9LxfDY9dhw4g+ouaQcEVGDcJqq4TDBMEJymQyTHw3B9mnj0aN1SxSVluHDnw9hwprvkJKVI3V4RERGQyXKdD6oZvxmjFibFs5YN/lJ/N8/+8PGwhzxqbcw4r/rsfrXUyhXqetugIiIyECYYBg5mUzAuJ5B2DF9Ah71a43SchU+3fcbxq76Fn9mZkkdHhFRk6aGADVkOhwcIqkNE4xmoqWTA1ZNiMZ/op+Ag5UlLtzKxOiVGxF78DhKy1VSh0dE1CSxBsNwmGA0I4IgILpbZ/z0ygQM8PdDmUqN5QdP4MkvNuFCeobU4RERkQlhgtEMudvbYdnYofj0ycFwtrHGn5lZGPO/b/Hp3l9RUlYudXhERE2Gvoo8uVR4dVwqvJkSBAGDAzuiVztf/OfnQ9h1PgmrfzuN/YnJ+HDEP9C9dUupQyQiklxFDYb2wxyV93Kp8OrYg9HMudjaYNGTgxE7bhjc7G1x/V4Onl3zHf7z80EolKVSh0dERM0UEwwT0d/fDzunT8DI7p0hisD6EwkYHrsex5NTudw4EZkstY77kKj512it+M2YEAdrK3w44gmsnjAS3k4OSM/Nx3PrfkDEstXIKSqWOjwiokbHhbYMh9+MCXq0fWvsmDYew7t1AgDcySrEjF0/syeDiEyObmtgsAfjYfjNmChbSwt8FD0IrwwKR7m1iIOZ17H23B9Sh0VERM0EZ5GYuH/17gW5lRwfHTuC+b8dQmtHJ/Rv007qsIiIGoVKFKDSYct1Xe5t7tiDQXihWw88FdAFalHEq7/sRGLWXalDIiJqFLoUeFYeVDN+MwRBEPDB45EIb+kLRVkZnt+5DXcVCqnDIiIiI8YEgwAAFnI5VkQNQ1snZ9wqLMDUn7ejpLxM6rCIiAxKLcp0Pqhm/GZIw9HKCl/+MxpOllY4m5mBGfv3QM2ZJUTUjHGIxHD4zVAVbZ2csWLwMJjLZPj56p9Y8vsxqUMiIiIjxASDqunV0hf/6fcPAMDy0yew9fIliSMiIjIMNf6aSaLNoZYg5rS0NERERCAgIABdu3bFli1bAAC5ubno0aMHgoOD0aVLF6xatUqC6P7CaapUo9GduuBaTg5WnDmJOQf2wtfBAaHePlKHRUSkV7ouliXFQltmZmZYunQpgoODkZGRgZCQEAwePBj29vY4cuQIbGxsoFAo0KVLF4wcORItWrRo9BgB9mDQQ7wZ3geD/DqgVK3Ciz//iBt5uVKHRERk8ry8vBAcHAwA8PT0hKurK7KzsyGXy2FjYwMAUCqVEEVR0hWamWBQrWSCgMWRUQh080BOSQmm7NyGfGWJ1GEREemNFHuRHDlyBEOHDoW3tzcEQcD27durXRMbG4s2bdrAysoKYWFhOHnyZI1txcfHQ6VSwdfXF0DFMElQUBB8fHwwc+ZMuLq6Njg+fWGCQQ9lbW6OVUNGwMvODsk52fjXnp9QplJJHRYRkV6oIeh8NJRCoUBQUBBiY2NrfH3z5s2IiYnB3LlzcebMGQQFBWHgwIG4c+dOleuys7MxYcIE/O9//9Occ3JywtmzZ5GSkoJNmzYhMzOzwfHpCxMMqpOHnR1WD4mGjbk5jqal4r0jB7gxGhE1C/rqwcjPz69yKJXKWt8zKioK8+fPR3R0dI2vL168GFOnTsXkyZMREBCAlStXwsbGBmvWrNFco1QqMWLECMyePRu9e/eu1oaHhweCgoLw66+/6vgNaY8JBtVLgJs7PntiCAQAmy6ew5qzZ6QOiYioyfD19YWjo6PmWLBggVbtlJaWIj4+HpGRkZpzMpkMkZGROH78OABAFEVMmjQJ/fv3x/jx4zXXZWZmoqCgAACQl5eHI0eOoGPHjjp8Kt1wFgnVW2RbP7z96OP48OhhfHh/Y7TItn5Sh0VEpDVdF8uqvDctLQ0ODg6a85aWllq1l5WVBZVKBQ8PjyrnPTw8cPnyZQDA0aNHsXnzZnTt2lVTv7F+/XoUFxfjhRde0BR3vvLKKwgMDNQqDn1ggkENMiU4BNdyc/DNxXN4be8ubBn5NALc3KUOi4hIK2pRgFqHHVEr73VwcKiSYBhSnz59oFbXvAJHQkJCo8RQHxwioQYRBAHz+vbHoz6tUFRWhugfNuHk7TSpwyIiklRoaCgCAgJqLdysL1dXV8jl8mrFmZmZmfD09NSp7cbGBIMazFwuR+ygobCxMENpuQpzDu2TOiQiIq2oddyHpHKhrVOnTuHSpUuYNm2aTvFYWFggJCQEcXFxf8WoViMuLg7h4eE6td3YOERCWnG0ssK8iP5488AeZKhzUVimhJ25dmOORERS0XVHVG3uLSwsxNWrVzXPU1JSkJCQABcXF7Rq1QoxMTGYOHEievTogZ49e2Lp0qVQKBSYPHmy1nFKgT0YpLVRHbrAz8sJClUZfki+IHU4RESSacgQyenTp9GtWzd069YNABATE4Nu3brh3XffBQCMGTMGixYtwrvvvovg4GAkJCRgz5491Qo/mzpB5IIGD5Wfnw9HR0fk5eU1WgGPMfn68hm8e3If2jm4YP/w5yETtC+WIiICGuf3buV7fHCyP6zstO/MLyksx//1PMC/I2rAHgzSyUi/zrAzt8C1/Gz8eitF6nCIiBqkcohEl4Nqxm+GdGJnbonRfhXzrNdd5uJbRGSa9DWLpDlhkSfpbKJ/d6y9HI+D6cm4UZCD1vbOUodERFQvKgAqLfYTefB+oGIWCYdIqmIPBumsrYMLIlq2g4iKmgwiImPBIRLD4TdDejHRvzsA4Lur56EoK5U4GiKi+pFiu3ZTwW+G9OJx73Zoa++MgjIltl67KHU4REQkMSYYpBcyQcD4+70YX1+O53buRGQURAhQ63CI9+s3WORZHYs8SW9G+wXi0z9+xZW8eziWcQOPerWROiQioofSdZij8l4WeVbHHgzSGwcLS4zy6wIAWMtiTyIik8YEg/Rqwv1hkv1pV5BWkCttMEREdajcrl2Xg2rGBIP0qr1jCzzm1QYigPVJf0gdDhHRQ+myk2rlQTXjN0N6N9E/BACw+eo5FJeXSRwNEZHhscizOhZ5kt71a9kOvnaOSCvMw/ZrFzH2kWCpQyIiqpGuwxyV97LIszr2YJDeyWUyzcJbazlllYiaMDVkOh9UM34zZBBPtu8KazNzJOVm4URmmtThEBFRI2OCQQbhaGGF6HadAQDrLsdLHA0RUc1UoqDzQTVjgkEGM7FjxTDJ3rQrSC/MlzgaIqLqOE3VcJhgkMF0dHZDuGcrqEURG/7klFUianpEHXdSFe+v5MlZJNVxFgkZ1ET/EBzPSMXay/F4sn0XtHNoIXVIRER6x1kk1bEHgwwq0qc9LORyFJeXYdWlk1KHQ0RUhQqCzgfVjAkGGZSZTIaAFq6AoEa5WC51OEREVahFXeswpP4ETRcTDDK4qNaPQG6hRimYYBARmQrWYJDB+Tm4AgBSCrIljoSIqKrKYk1d7qeaMcEgg2tr7wIAuF6QDVEUIQgcsySipkENAWod6ih0ube5Y+pFBudr6wy5IEBRXoo7JYVSh0NEpHecplodezDI4CzkcvjYOuFGYQ6u5d+Dh7W91CEREQGAzqtxVt7LaarVsQeDGkU7+4r1L1IK7kkcCRHRX3RZZEvX+o3mjt8MNYrKOgwWehIRmQajSTCGDRuGVq1awcrKCl5eXhg/fjxu3br10HtKSkowbdo0tGjRAnZ2dhg1ahQyMzMbKWJ6UNv7PRjX2INBRE2IGjruRcIiz1oZTYLRr18/fPfdd0hKSsIPP/yA5ORkjB49+qH3vPHGG/jpp5+wZcsWHD58GLdu3cLIkSMbKWJ6EHswiKgpEu/PItH2EJlg1MpoijzfeOMNzePWrVtj9uzZGDFiBMrKymBubl7t+ry8PHz55ZfYtGkT+vfvDwD46quv0KlTJ5w4cQK9evWq8X2USiWUSqXmeX4+dwHVh8o9SG4qclGqUsFCLpc4IiKiv1bx1OV+qpnR9GA8KDs7Gxs3bkTv3r1rTC4AID4+HmVlZYiMjNSc8/f3R6tWrXD8+PFa216wYAEcHR01h6+vr97jN0XuVnawNbOAShSRpsiROhwiIjIwo0ow3nrrLdja2qJFixZITU3Fjz/+WOu1GRkZsLCwgJOTU5XzHh4eyMjIqPW+OXPmIC8vT3OkpaXpK3yTJggC2twfJmEdBhE1FZxFYjiSfjOzZ8+GIAgPPS5fvqy5fubMmfjjjz+wd+9eyOVyTJgwAaKo351mLC0t4eDgUOUg/WAdBhE1NbptdKbb8EpzJ2kNxowZMzBp0qSHXtOuXTvNY1dXV7i6uuKRRx5Bp06d4OvrixMnTiA8PLzafZ6enigtLUVubm6VXozMzEx4enrq6yNQA2jWwshnDwYRUXMnaYLh5uYGNzc3re5Vq9UAUKUg80EhISEwNzdHXFwcRo0aBQBISkpCampqjQkJGZ6mB6OQPRhE1DRwLxLDMYrBo99//x3Lly9HQkICbty4gQMHDmDs2LHw8/PTJAvp6enw9/fHyZMnAQCOjo6YMmUKYmJicPDgQcTHx2Py5MkIDw+vdQYJGZZmLQz2YBBRE6GvIRLuRVKdUUxTtbGxwdatWzF37lwoFAp4eXlh0KBBeOedd2BpaQkAKCsrQ1JSEoqKijT3LVmyBDKZDKNGjYJSqcTAgQPx3//+V6qPYfIqizzvKYtw7t4tdG3hLXFERET6wb1IqjOKBCMwMBAHDhx46DVt2rSpVvBpZWWF2NhYZpRNhJ2Zxf1HIvLKiiWNhYgI4DoYhmQUCQY1D4XlpQAqksBQ11bSBkNEBCYYhsQEgxpNQWkJBAEwl8lhKeePHhFRc8bf8tRo8stKAACOFlYQBGb9RCQ99mAYDhMMajR5pRUJhoO5lcSREBFVEKHbVFP9LvXYvDDBoEZT2YNhzwSDiJoI9mAYjlGsg0HNQ37pX0MkRETUvLEHgxpNZQ+Gg7mlxJEQEVVgD4bhMMGgRlPZg+HAHgwiaiKYYBgOh0io0fzVg8EEg4iouWMPBjUa9mAQUVPDHgzDYQ8GNZr8soqdb9mDQURNhSgKOh+NLS0tDREREQgICEDXrl2xZcuWh56XCnswqNHkl1bsP8IeDCIi7ZmZmWHp0qUIDg5GRkYGQkJCMHjw4FrP29raShOnJO9KJok9GETU1Kgh6LTQli73asvLywteXl4AAE9PT7i6uiI7Oxu+vr41npcqweAQCTWa6wXZAIDcUu6kSkRNQ2UNhi5HQx05cgRDhw6Ft7c3BEHA9u3bq10TGxuLNm3awMrKCmFhYTh58mSNbcXHx0OlUsHX17de5xsTEwxqFEXlpVCqygEAzhY2EkdDRKRf+fn5VQ6lUlnrtQqFAkFBQYiNja3x9c2bNyMmJgZz587FmTNnEBQUhIEDB+LOnTtVrsvOzsaECRPwv//9r17nGxsTDGoU8XdvQq0W4GBmjeAW3lKHQ0QEQH9Fnr6+vnB0dNQcCxYsqPU9o6KiMH/+fERHR9f4+uLFizF16lRMnjwZAQEBWLlyJWxsbLBmzRrNNUqlEiNGjMDs2bPRu3fvOs8/TGJiIubOnYv+/fvDz88PXl5e6Nq1KyZOnIhNmzY9NFl6GNZgUKM4lnkDgIAB3h1hy5U8iaiJ0Nc01bS0NDg4OGjOW1pq93uutLQU8fHxmDNnjuacTCZDZGQkjh8/DgAQRRGTJk1C//79MX78eM11tZ2vzZkzZzBr1iz89ttvePTRRxEWFobo6GhYW1sjOzsbFy5cwL///W+88sormDVrFl5//fUGfS4mGNQojmdeBwD09mgtbSBERA/Qdapp5b0ODg5VEgxtZWVlQaVSwcPDo8p5Dw8PXL58GQBw9OhRbN68GV27dtXUb6xfvx55eXk1ng8MDKzxvUaNGoWZM2fi+++/h5OTU60xHT9+HJ999hk+/fRTvP322/X+LEwwyODyS0twIScDANCLCQYRNUOhoaGQy+WYNm0apk2bZtD36tOnD9RqdY2v1Xa+Jn/++SfMzc3rvC48PBzh4eEoKyurd9sAEwxqBCfvpEItimhr7wIvG90zfCIifRF1HCKp7ME4deqUXnowXF1dIZfLkZmZWeV8ZmYmPD09dW7/QXUlF7m5uVV6NuqTjDyIRZ5kcBX1F0A4ey+IqIkRAYiiDoee47GwsEBISAji4uI059RqNeLi4hAeHq7nd/vLwoULsXnzZs3zp556Ci1atEDLli1x9uxZrdpkgkEGd+JORYLR26ONtIEQERlIaGgoAgICap16+qDCwkIkJCQgISEBAJCSkoKEhASkpqYCAGJiYrBq1SqsW7cOiYmJePnll6FQKDB58mSDxb9y5UrNmhn79u3Dvn37sHv3bkRFRWHmzJlatckhEjKoeyUKXM6tmLsd5t5K4miIiKpSQ4Cgh5U8GzJEcvr0afTr10/zPCYmBgAwceJErF27FmPGjMHdu3fx7rvvIiMjA8HBwdizZ0+1wk99ysjI0CQYO3fuxFNPPYUnnngCbdq0QVhYmFZtMsEgg/r9TkVG3tHRDS2spFmuloioNvqaRdIQEREREMWHD65Mnz4d06dP1zasBnN2dkZaWhp8fX2xZ88ezJ8/H0DF1FeVSqVVm0wwyKCO3Z+eGs7hESKiJmvkyJEYN24cOnTogHv37iEqKgoA8Mcff6B9+/ZatckaDDKo45mV9Rcs8CSipkdfe5E0pAajKVqyZAmmT5+OgIAA7Nu3D3Z2dgCA27dv41//+pdWbbIHgwzmdlE+UgqyIRME9GT9BRE1QZWzQXS5H9DfNNXG9u6772L48OEICQnBm2++We31N954Q+u22YNBBnPifu9FF2dPOFhwi3Yioqbm5s2biIqKgo+PD15++WXs2bMHpaWlemmbCQYZzF/rX7SRNhAiolroa7MzY7VmzRpkZGTgm2++gb29PV577TW4urpi1KhR+Prrr5Gdna1120wwyCBEUcT+9CQArL8goqZLXwmGMddgyGQyPPbYY/j444+RlJSE33//HWFhYfjiiy/g7e2Nvn37YtGiRUhPT29Qu6zBIIP4LTMZeaVKACLa2DtJHQ4RUY3UogBBD7upGmsNRk06deqETp06YdasWbh79y527NiBHTt2AECNdRq1YYJBBvH9jTOQy1VwtbSDr52L1OEQUSPKU5YgV1mM1g7OUodCOnJzc8OUKVMwZcqUBt/LIRLSuxylAkfvJsHKqhzL+kRLHQ4RNZLU/Fy8dzwOvb5dgbeP7pU6nHrRaR8SHWegNBVnz57F/Pnz8d///hdZWVlVXsvPz8dzzz2nVbtMMEjvttw4DaW6HJ0cvRDiwvoLoubudGY6Xorbjse/X4WvLsWjqLwMWcVFUJTpZzaCIVUkCbrUYEj9CXSzd+9e9OzZE99++y0WLlwIf39/HDx4UPN6cXEx1q1bp1XbTDBIr8rU5fg25RQAYHy7cAiCcVdYE1HNytVq7Eq5jBE7NmDUzo3Yff1PqEURj7dsiw2DnsKe6EmwNbeQOsxGY6xFnu+99x7efPNNXLhwAdevX8esWbMwbNgw7NmzR+e2WYNBerUn/SLuKgvgZmmPQS07Sx0OEelZYakSm/88jzUX43GzMA8AYCGTY0T7ADzfuQc6urhJHGHD6GsvEmMt8rx48SLWr18PABAEAbNmzYKPjw9Gjx6Nb7/9FqGhoVq3zQSD9EYURay/dhwA8HTbUJjL+ONF1FykF+Zj7aV4fHP5LAruD304W1pjfKdgTAjoDjdr49zMULx/6HK/MbO0tERubm6Vc+PGjYNMJsOYMWPw6aefat02/wYgvTmTnYrEvNuwlJnhydY9pA6HiPTg3N3bWHXhNHalXIbqfsGBn6MLnu/SAyPbd4aVmbnEEZIugoODcfDgQYSEhFQ5//TTT0MURUycOFHrtplgkN6sT67ovfinbxCcLY3zXzNEBKjUasSlJWPV+VM4mXlTcz7cqxWmdglFP992kDWT+ioptmtvSl5++WUcOXKkxtfGjh0LURSxatUqrdpmgkF6kabIxoGMywCA8e16SRwNEWmjqKwUW65cwJqLp3E9PxcAYCbIMMyvE6Z07oEurh7SBmgIJj5GEh0djejo2pcTGDduHMaNG6dV20wwSC82pfwOESIedWsPP3t3qcMhogbIVBRgXeIf2JCYgLzSEgCAg4UlnvUPxsSA7vC0tZc4QgPSdT+RB5YKl8vlmDZtGqZNm6an4KRRWFgItVpd5Zw2BaxMMEhnd4sL8P2NeADAs37svSAyFpfu3cHqC6ew41oiyu7/hdLa3gnPdemBJzt0Malpproy1lkklVJSUjB9+nQcOnQIJSUlmvOiKEIQBKhUqga3yQSDdPbB+Z9QoiqDrZklHnVrL3U4RPQQalHEoZvXsPrCaRy9dUNzPtTDB8936YF/tGoPucx0lkjSdTVOY19oq9Kzzz4LURSxZs0aeHh46GUNIyYYpJMSVRl+v5sCAOjn2ZELaxE1USXlZdh29RJWXzyNq7n3AAByQcDgNh3xfGAogt28JI5QGqZe5Fnp7NmziI+PR8eOHfXWJhMM0snW1DMoUpXC3coebwcOljocIvqbrGIF1if+gfWJCbhXUgQAsDO3wNiOQZgU0B0+9o4SR0hNQWhoKNLS0phgUNNQqirHl1d+AwC80KEv7M2tJY6IiCr9mZOF1RdOYXvyJSjvj5/72DlgcucQjHmkK+wtLCWOsIkQBU2hptb3NwOrV6/GSy+9hPT0dHTp0gXm5lXXN+natWuD22SCQVrbnvYH7pTkw93KAdGtuksdDpHJE0URR2/dwP8unMLhmyma88FuXpjaJRSD2jwCMxOqr6gP1mBUuHv3LpKTkzF58mTNOUEQWORJja9MXY7VV34FADzX/lFYyPmjRCQFURRRoirHrpQkrL5wConZdwEAAoCBbR7B8116oId7S9ZH0UM999xz6NatG7755hsWeZK0dqSdxe3iPLha2mFU65C6byAivSssVeLFIz/gzN2bKCoSAQiwMTPHU48E4rnOIWjt4Cx1iE2fnhbaMvZ1MG7cuIEdO3agfXv9zQRkgkENVqZWYdX93ovJ7R+FlZx7ERBJYd2V0zhxLwWQAc42tngxIBzj/IPgaGkldWhGw9R3U63Uv39/nD17lgkGSWvXzXNIL8qBi4UtNzUjksjm5D+w+MIhAMAT3v74rPcIWMjl0gZFRmvo0KF44403cP78eQQGBlYr8hw2bFiD22SCQQ1SUl6GL/48DACY1L43rM240h9RY/sp9SL+ffpnAMDzHXthdlB/1ljoopkUauripZdeAgC8//771V5jkSc1iiWJu3CzKAfWcjOMaRMqdThEJicu/U+8eWIHRABj/boxudARF9qq8Pe9R/SB85Wo3tSiGj/fOg8ACHXzhY0Z59ETNaZjmdcx/dhWlItqDG/dBe+HRDG50JWoh8OITZgwAT/88AMUCoXe22aCQfV25O4FQJ4PVxsRcwNr396XiPTvTNZNvPjbdyhVqxDZ8hEs7PlPyJhckI7at2+P//znP3B1dUVUVBRWrFiB9PR0vbTNBIPqRRRFrL9+AIIAPNv2Ubhbc3lhosZyKScDU45sRlF5GR71aIvPw6NhLmNBp34IejiM17vvvov4+HhcuXIFQ4cOxfbt2+Hn54eQkBC8//77SEhI0LptJhhULyfuXcaVgnRYyy0wulUfqcMhMhnX8u9h4uFvkF9Wgu4tfLCyz2hYcmE7/THxIZJKPj4++Ne//oVffvkFd+/exVtvvYWkpCT0798frVu3xvTp03Hx4sUGtckEg+pU0XsRBwAY3jIcjua2EkdEZBpuKnIx/tBGZCuL0NnJA1/2HQMbztwiA7O3t8dTTz2FjRs34u7du/jqq68gl8tx/PjxBrXDNJjqlJB7DRfybsBCZoanWvWVOhwik5BZXIDxBzcio7gA7R1c8dXjY+FgwQW09E5PK3kau/79+2Pr1q1wcnKqcl6hUGD+/Pk4cOBAg9tkDwbVqbL3YrBXKFwtjXelOiJjka0swsRDm5CqyIWvrRPWPT4WLazYc2gQlbup6nKgYqnwgIAAxMbGSvyBtHPo0CGUlpZWO19SUoJff/1VqzbZg0EPdfhOAk5nX4FckGFc635Sh0PU7BWUKTH58De4kp8FD2s7fB0xDp42TOybOmNdKvzcuXOax5cuXUJGRobmuUqlwp49e9CyZUut2maCQQ+1/Mo2AEAXx5bwtObGSUSGVFxehqm/bsaFnAy4WNrg64hn0MqOf+4MydS3aw8ODoYgCBAEAf3796/2urW1NZYtW6ZV20wwqFZ/5l9Dblk+ADkmtv2H1OEQNWtKVTlePvo9Tt1Ng725JdY+PhbtHVylDqv5M/EajJSUFIiiiHbt2uHkyZNwc3PTvGZhYQF3d3fItdzjhgkG1Wr7rT1wsSxGd6du6OHSSepwiJqtcrUab5zYjl8zrsFabo7Vj41BZ2dPqcMiE9C6dWuUlZVh4sSJaNGiBVq3bq23tnUq8lQqlfqKg5qYa4U3EJ9zDgIEjG8zQupwiJottSjirZM78cvNJFjI5Piiz5Po4eYrdVimQ09FnsbM3Nwc27Zt03u7DUowdu/ejYkTJ6Jdu3YwNzeHjY0NHBwc8Pjjj+PDDz/ErVu39B4gSeP7m7sAAH1ce8Lb2kPiaIiaJ1EUMe/ML9h+4zzkgoDPe0fjUc+2UodlUgRR96M5GD58OLZv367XNus1RLJt2za89dZbKCgowODBg/HWW2/B29sb1tbWyM7OxoULF7B//3588MEHmDRpEj744IMq4zhkXB7svRjpM1jqcIiarUXnD2HD1XgIAD7pOQz/aNlR6pBMj4nXYFTq0KED3n//fRw9ehQhISGwta06LfrVV19tcJv1SjA+/vhjLFmyBFFRUZDJqnd6PPXUUwCA9PR0LFu2DBs2bMAbb7zR4GCoaWDvBZHh/ffSUaxMPAYA+KBHFIa36SJxRGTKvvzySzg5OSE+Ph7x8fFVXhMEwXAJRn2XB23ZsiU++uijBgdBTQd7L4gMb92fp/Dp+UMAgDlBAzDWr7uk8Zg0XesomkENBlAxm0TfOIuEqliRvAYAey+IDOX7lLN4/4+9AIBXOvfB8/69JI7IxHGIxGAanGCIoojvv/8eBw8exJ07d6BWq6u8vnXrVr0F96Bhw4YhISEBd+7cgbOzMyIjI7Fw4UJ4e3vXek9ERAQOHz5c5dyLL76IlStXGiRGY3cs6zhSizIBiHjC81GpwyFqdnanJWLOqYohyMmP9MRrnbm3DzUdN2/exI4dO5Camlpt2fDFixc3uL0GJxivv/46vvjiC/Tr1w8eHh4QhMbpHurXrx/efvtteHl5IT09HW+++SZGjx6NY8eOPfS+qVOn4v3339c8t7GxMXSoRuv3e0dgISuDq4U7HrF/ROpwiJqVg7eu4o0T26EWRTzVLhj/Do5stN+f9BDswQAAxMXFYdiwYWjXrh0uX76MLl264Pr16xBFEd27azeE1+AEY/369di6dSsGD27c8fkHi0Zbt26N2bNnY8SIESgrK4O5uXmt99nY2MDTs/4L1iiVyirre+Tn52sXsJG5WZSKK4rzcDAX8GbHf0kdDlGz8vudG5h27AeUqdUY4huA+SFRTC6aCiYYAIA5c+bgzTffxLx582Bvb48ffvgB7u7ueOaZZzBo0CCt2mzwQluOjo5o166dVm+mL9nZ2di4cSN69+790OQCADZu3AhXV1d06dIFc+bMQVFR0UOvX7BgARwdHTWHr69pLHizJ2M7AKC7cxha2pjGZyZqDGfvpWPqr99BqSpHf+/2+LTXMMhrmI1HVF9paWmIiIhAQEAAunbtii1btmhei46OhrOzM0aPHt2gNhMTEzFhwgQAgJmZGYqLi2FnZ4f3338fCxcu1CrOBv+Uv/fee5g3bx6Ki4u1ekNdvPXWW7C1tUWLFi2QmpqKH3/88aHXjxs3Dhs2bMDBgwcxZ84crF+/Hs8+++xD75kzZw7y8vI0R1pamj4/QpN0q/gm/sg9BQAY5Dlc4miImo+k3DuYfORbKMpLEe7eBst7j4K5TLt9HchAjHAlTzMzMyxduhSXLl3C3r178frrr0OhUAAAXnvtNXz99dcNbtPW1lZTd+Hl5YXk5GTNa1lZWdrF2dAbnnrqKXzzzTdwd3dHmzZtqvUgnDlzpt5tzZ49u87MKDExEf7+/gCAmTNnYsqUKbhx4wbmzZuHCRMmYOfOnbV2Nb7wwguax4GBgfDy8sKAAQOQnJwMPz+/Gu+xtLSEpaVlvT9Dc7An40eIEBHsFIqW1uy9INKHlIJsTDi8CXmlJejWoiW+6PMkLOWcuNfU6LoapxQreXp5ecHLywsA4OnpCVdXV2RnZ8PW1hYRERE4dOhQg9vs1asXfvvtN3Tq1AmDBw/GjBkzcP78eWzduhW9emk306nBP+0TJ05EfHw8nn32WZ2LPGfMmIFJkyY99JoHh2NcXV3h6uqKRx55BJ06dYKvry9OnDiB8PDwer1fWFgYAODq1au1JhimJrPkFuJzTgAAojxHSBsMUTNxS5GHCYc2IqtEgU5O7viy7xjYmltIHRY1EUeOHMEnn3yC+Ph43L59G9u2bcOIESOqXBMbG4tPPvkEGRkZCAoKwrJly9CzZ89qbcXHx0OlUuk8nL948WIUFhYCAObNm4fCwkJs3rwZHTp00GoGCaBFgrFr1y788ssv6NOnj1Zv+CA3NzetlxSvnB7bkA3XEhISAECT+RGw+37vRaBjN/ja6G8XPSJTlVVSiPGHNuFWUT7a2bfA2sfHwdHCWuqwqDZ6KvL8+4SAh/WGKxQKBAUF4bnnnsPIkSOrvb5582bExMRg5cqVCAsLw9KlSzFw4EAkJSXB3d1dc112djYmTJiAVatW6fABKjz4j3lbW1u9LOfQ4BoMX19fODg46PzGDfH7779j+fLlSEhIwI0bN3DgwAGMHTsWfn5+mt6L9PR0+Pv74+TJkwCA5ORkfPDBB4iPj8f169exY8cOTJgwAX379kXXrl0bNf6mKrngPE5m/wYAiPIYIW0wRM3AiTspePLAV7heeA8tbRyxLmIcXK1s676RjJ6vr2+VCQILFiyo9dqoqCjMnz8f0dHRNb6+ePFiTJ06FZMnT0ZAQABWrlwJGxsbrFmzRnONUqnEiBEjMHv2bPTu3Vtvn+P06dNYv3491q9fX23J8IZqcA/Gp59+ilmzZmHlypVo06aNTm9eXzY2Nti6dSvmzp0LhUIBLy8vDBo0CO+8844mQywrK0NSUpJmloiFhQX279+PpUuXQqFQwNfXF6NGjcI777zTKDEbgx9vrQUgoIW5NdrYcciISBdlahVeO7kFhaoiOFhZ4uuIcfC2adx/jFHDCdCxBuP+f9PS0qr841vbWr7S0lLEx8djzpw5mnMymQyRkZGabTtEUcSkSZPQv39/jB8/XuvYH3Tz5k2MHTsWR48ehZOTEwAgNzcXvXv3xrfffgsfH58Gt9ngBOPZZ59FUVER/Pz8YGNjU63IMzs7u8FB1CUwMBAHDhx46DVt2rSBKP71U+Lr61ttFU/6S37ZHYiqy3A1N8NQ70lSh0Nk9ArLSlCkqphd93GPaLSxd5E4ImpMDg4Oeundz8rKgkqlgodH1a0aPDw8cPnyZQDA0aNHsXnzZnTt2lWzxfr69esRGBiIyMhInD17FgqFAj4+PtiyZUu96hSff/55lJWVITExER07Vuzqm5SUhMmTJ+P555/Hnj17GvxZGpxgLF26tMFvQk3P6Xs/QBTK0dkhAKEtIqUOh8jo7bx5HmqI6OjgiX+09Jc6HKovPW12FhoaCrlcjmnTpmHatGl6Cq5mffr0qbZNR6X9+/dr1ebhw4dx7NgxTXIBAB07dsSyZcvw2GOPadWmVrNIyLgpynNxLnc3AKCX61iJoyFqHral/gEAGN2aO6MaFT0VeZ46dUovPRiurq6Qy+XIzMyscj4zM7NBq1I3lK+vL8rKyqqdV6lUD93z62HqVeRZuYBHfTX0empc8dlbUS4q4WnVEa1sukkdDpHRS8y9jaT8TJjL5Bjs00XqcMiIWVhYICQkBHFxcZpzarUacXFx9V6SQRuffPIJXnnlFZw+fVpz7vTp03jttdewaNEirdqsV4LRvn17fPTRR7h9+3at14iiiH379iEqKgqff/65VsGQ4ZWoCpCQ8xOAit4L7odApLvK3otIL384WXBDRaMi6uFAxRBJQEAAYmNj63zLwsJCJCQkaJZOSElJQUJCAlJTUwEAMTExWLVqFdatW4fExES8/PLLUCgUmDx5sr4+dTWTJk1CQkICwsLCNFNsw8LCcObMGTz33HNwcXHRHPVVryGSQ4cO4e2338Z7772HoKAg9OjRA97e3rCyskJOTg4uXbqE48ePw8zMDHPmzMGLL76o9YckwzqT/SNK1UVws2wLP7swqcMhMnqlqnLsvHkeADCiFXsEjY2+VvJsyBDJ6dOn0a9fP83zmJgYABUlCGvXrsWYMWNw9+5dvPvuu8jIyEBwcDD27NlTrfBTnwxRX1mvBKNjx4744YcfkJqaii1btuDXX3/FsWPHUFxcDFdXV3Tr1g2rVq1CVFQU5HKus99UFZXnID57GwAgzPVpCAI3XCLS1cGMJOSVFcPTygHhbtJuBEnGISIiosqsx5pMnz4d06dPb6SIDFNf2aAiz1atWmHGjBmYMWOG3gMhwzuY8TGU6kLYyu3xiL12VcFEVFXl8Mgw3yDImbQbHxPerl2hUMDWtv4LwTX0ev5pMBHl6mKkKio2ovO3D4VMYE8Tka4yi/Nx9E7FrpMjWgVLGwxpR4IajKbC0PWV3NrPRFzN+wHOsmy4mHmij8drUodD1CzsSDsLNUR0d2mF1nYtpA6HJKSvaaqNydD1lUwwTEC5uhiXc9dDEIBQt6kwl1lJHRKR0RNFEdtTEwAA0ey9MFrGuF27vhi6vpIJhgm4mvcDlKps2Jq1RBv7wVKHQ9QsJOSk4briHqzl5hjo3VnqcEhbelrJ05gZqr6SNRjNXGXvBQAEuDwHmcCckkgftt3vvXjCOwC25tptbEVNgAnXYBhavROMAQMGYOvWrbW+npWVVWU/eWoa2HtBpH9F5aXYk34BABDNtS8IFTUYly5dMvg+JMak3gnGwYMH8dRTT2Hu3Lk1vq5SqXDjxg29BUa6Y+8FkWHsu3UJivJS+No4o0eL1lKHQzqorMHQ5aCaNWiIZMWKFVi6dCmio6O534gRuJj1CXsviAxgW1oCgIqpqVxu38jpaYiEqmtQgjF8+HCcOHECFy9eRK9evXDt2jVDxUU6Ki3PxpX8HQAAP/sB7L0g0pM0RTZOZV2HAGA4Z48Q1arBRZ6dOnXCqVOn4Ovri9DQUK33nifDyijcAAuhFOYC8IjzVKnDIWo2fkw7CwAId2sHL2tHiaMhnek6PNJMijzfe+89qNXqaufz8vIwduxYrdrUahaJo6Mjdu3ahalTp2Lw4MFYsmSJVm9OhqEWS5Gn2AQf81z0cp0KOde9INILtajGj/dnj3Bjs2ZCT0Mkxl7k+eWXX6JPnz5VRiYOHTqEwMBAJCcna9VmvROMv48zCoKAjz76CF9//TX+7//+D88//7xWAZD+5Sh+RJnqFsxkbvB0mCB1OETNxsms67hVnAd7M0sM8PKXOhwivTl37hx8fHwQHByMVatWYebMmXjiiScwfvx4HDt2TKs26z0wX9vOb08//TT8/f0xYsQIrQIg/RJFFTLy/wsA8HB4ATKBvRdE+lK5sdlgn0BYyc0ljob0woQ3O3uQs7MzvvvuO7z99tt48cUXYWZmht27d2PAgAFat9mgaaouLi41vhYcHIz4+Hh89dVXWgdC+pFbvAfK8mTIZY5wtXtG6nCImo2CshLsu5UIgBubNSecpvqXZcuW4bPPPsPYsWPRrl07vPrqqzh79qzW7dU7wXj88cdhZlZ7h0eLFi0wYQK746UkiiIy8ioKjNzsJkMus5M4IqLmY3f6BSjV5fCzd0OgU0upwyHSq0GDBmHevHlYt24dNm7ciD/++AN9+/ZFr1698PHHH2vVJpcKb0bySw6juOwCZIIN3O0nSx0OUbNSOTwSzbUvqAbGPotEpVLh3LlzGD16NADA2toaK1aswPfff6/1RA4ujtCMZOYvBwC42j0LM7mzxNEQNR/JBXdxLicdckHAP326Sh0O6ZOeajCMcbv2B+3bt6/G80OGDMH58+e1apMJRjORX7QHhcqTEGABd3vO6CHSp8rei8c8OsDNyl7iaEifTHm79vpydXXV6j4mGM3ErZzZAABn6z6wMPOUOJrmrUihhMxCDitz/vExBeVqFX5KOwcAGMm1L6iZkslkDx36U6lUDW6TvyGbAWXJr1Cq7gEQ2Huhg9JyFbIVRcgqUCCr8IH/FhYhq1BR8bxAgbQ7uRBlQMRtO3h5O8PL2xmeLZ3h6e0EL29nuHs6wtxcLvXHIT357c5VZCkL4WJhg74ej0gdDhmCCfRC1GXbtm1VnpeVleGPP/7AunXrMG/ePK3aZILRDJQpVqOVHCi36Asbqz5Sh9PkKcvKceTPFCze+xtyFMVws7dFVkER8opL6teAWUWWn5SciauXM6q9LJMJcHV3gJe3Ezxb3k9AvJ3g1dIZnt7OcHK2YZGgEdl2f+XOf/p2hbmMiWOzw3UwAFTsNfZ3o0ePRufOnbF582ZMmTKlwW0ywTBy5aV/oFx5AIIgh4vzB1KH02TdLVDgSFIKDiVdw7HkVBSXlmleyy9Wah6byWRoYWcDVzsbuNrbwtXOFq72NvfPVTy2N7NAeWEZ8p4oQGZGHm6n5+B2eg4ybuciIz0HSmU57mTk4U5GHs6euVEtFitrc3h6O8PW2Rp3y0swcEAgnh0dzqSjCcpWKnAoIwkAEM3hETJBvXr1wgsvvKDVvUwwjFxJwVIAgIX1SMjN2kobTBMiiiIuZ9zFocvXcCgpBedvVu1pcLe3hbezA4J9vBDm1wreTvZws7eFg5UVZLJ6/kVfw0rRoigiJ1uBjFs5uJ2ei9u3cpB5K7ciCbmVg6w7+SgpLsP15Duae1ZmZmPz1SRE9+yC4aEBcHWw1eWjkx7tvHkO5aIanR298IiDh9ThkAGwyLN2xcXF+Pzzz9GypXbrvjDBMGKVvReAHJb2r0gdjuRKysrx+7VUHEpKweHL15CRX1jl9S4tPRDRsR0i/Nuik5e7QXoMBEGASws7uLSwQ0Cgb7XXS0vLcTcjD7dv5eDMhVQc++MarpTl48bdXCzd9RuW7T6KvgHtMDKsM/r4t4WZnEvVSEUURc3wCDc2a8b0NEQSGhoKuVyOadOmGeWGZ87OzlV+J4qiiIKCAtjY2GDDhg1atckEw4ix9wK4k1+Iw/eHPo4np6KkrFzzmrW5GcLbt0ZEx7Z4vGNbuNlLv7KphYUZWrZqgZatWqBHr/Z4Af1RpCzFLwl/4offL+Ds9ds4eCEZBy8kw83BFsNDAxDdswtauTlJHbrJScy7jT/zM2Euk2OwTxepw6EmztjXwViyZEmVBEMmk8HNzQ1hYWFwdtZuXSUmGEbK1HsvRFHEhNVbEH8jvcp5T0d7RHRsiwj/dujZ1tcoppLaWFogOqwLosO6IDnjHrb+fgE/nU7E3XwFVsedwuq4Uwj188HIXl0QGdgBVhZN/zM1B5W9FwM8/eFkYSNtMGQwHCKpMGnSJL23yd9URqow920Aptt7IQgC7KwsIAhAYEvP+0Mf7dDR09WoiyX9PFtg5vDH8fqQPjh4MRlbf7+IY0nXcSr5Jk4l38R/rA9iSHd/jOrVBf4t3aUOt9kqVZVj182K1Qu5sVkzZ8KzSM6dO1fva7t2bfgKtkwwjFCRYjNQfgEiAAvbqVKHI5lZg/rig+h/wNWu+RVFmpvJ8UTQI3gi6BHczsnH9pOXsP3kRdzKyce3R8/i26Nn0cnHHaPCuiCyawe42FkbdWLV1BzMSEJeWTE8rOzR291P6nCIDCI4uGJfHVF8eJYkCAIX2jIV+YoNMBdFiGZtYGbRSepwJNPWzUXqEBqFl7MDXh7YCy/+IwwnrqRi6+8XcOB8MhJv3sH8mwfwn20H4e5ih+WTh6Ojl5vU4TYLSy7vhlymwkDvAMgFFto2aybcg5GSkmLQ9plgGBllWSIKSuMBCGjltEzqcKgRyWQCendsjd4dWyOnsBg74xPxzdEEpGXl4XZWAaZ98xNinxmGjh7a7RtAFW4pcnFHmQszORDF4s5mz5RrMFq3bm3Q9pmaG5ns/M8BAHbW/4SlJafOmSpnO2uMf7w7ds2ZjLlPR8LW0QI38/IwZtU32JZwUerwjNqDI00Bjt7SBUKNQ9TDYcT69u2L3NxczfMdO3aguLhYL20zwTAipWXXUFj8EwDAxf5ViaOhpkAQBIzuGYg9bz6HPu1bo6SsHHO27cU7P+6rMmWX6q9crBhrtpFbwIxLg1Mz99tvv6G0tFTz/Nlnn8Xt27f10jYTDCOSU7AcgBq2VpGwtOgsdTjUhDjbWuN/z0Tj1X7hEATg+zMX8PTqb3HjXq7UoRmdgvKKPWnsza0kjoQahYn3YPxdXQWfDcEEw0iUld9EftH3AABn+9ckjoaaIplMwL8ieuHL8SPhYmuNyxl3MeqLjdh76YrUoRmVgrL7CYaZtcSRUGOorMHQ5aCascjTSOQU/BdAOawt+8DaMkTqcKgJ6+3XGtteehYxW3YhPvUWXt28ExPDu+PNf/SBuZxd/nUpvJ9g2LEHgxrAmJcK/+WXX+Do6AgAUKvViIuLw4ULF6pcM2zYsAa3ywTDCOSUXEGOYgNkAFzYe0H14OFgh7WTRmPJ/qNYcywe646fwbmbt7HkySHwdLSXOrwmraC8osCNQyQmQk/TVI15qfCJEydWef7iiy9Wea7tOhgcIjECl7PmQoZy5Kg8YG3ZW+pwyEiYy+WYNbAvYscOg72VJf5Iu43olRvx29XqW8jTX/I1QyRMMEyBqQ+RqNXqOg9tkguACUaTpygvwPE8BdJLHWFn9zJXa6QGG+Dvh60vjkOAlztyiooxdcNWLDt4HCq1WurQmqSCssoeDNZgEOmCCUYTd+jOL0hR2uF35Uj4Oz8vdThkpHxdnPDNlDEY0yMQogjEHjqBqeu3IVtRJHVoTQ5nkZgYziIxGCYYTVixqgiH7/4CAHjCcxhkMv7vIu1Zmpth3tBIfDxyEKzNzXDsWiqiV27EmdT0um82IQUcIjEtTDAMhn9jNWG/3t2PYlURPCy9EeQUKnU41EwMC+qE714Yi3auLsjML8T4r7ZgzdF4vc5/N2aaBIM9GEQ6YYLRRJWqlTh4ZzcA4B+ewyDjhkukRx3cXbHlhbEYEtgRKrWIj/cewaubdyK/uETq0CRXWM4aDFMi6OGgmnGaahN1LOsgCsvz4WLhhh4u4VKHQ82QraUFFo2KQo9WLfGfPYexL/Eqfr1yHe/9cwBGdAuQOjzJcIjExJjwbqo1KS0txZ07d6D+WxF4q1atGtwWE4wmqExdhrjMnQCAf3gMhVzg/yYyDEEQMLZnELq09MDEtd+jqLQMc3/aj0GdO8DKwlzq8CTxV5EnezBMgSnvpvqgK1eu4LnnnsOxY8eqnBdFUet1MPg3VxO0MmEzcpEDW5kjwlr0lTocMgGBLT2x/eXxGLp8HUpLVfjvwROIGfiY1GFJIr+MC22R6Zk0aRLMzMywc+dOeHl56WVJBCYYTYyyvAwXig/BwhpwLu0Gc5lp/iuSGl8rF0cseXIIpm/cgTW/xWNAQHsE+XpJHVajKlOXo0RVBoBDJCaDQyQAgISEBMTHx8Pf319vbbJysIn5+cKfOH2iHe6me+KloLFSh0Mmpn8nPwwN8odaFPHvrXuhNLEt3wvLlJrHtmaWEkZCjYpTVBEQEICsrCy9tskEowlRqdVY+etJKAqtEenyNBwt7aq8Looi7hYXShQdmYo5Q/rB1c4G1+5mI/bAcanDaVSV+5DYmlnCTMaN4ahpSktLQ0REBAICAtC1a1ds2bJF89rOnTvRsWNHdOjQAatXr653mwsXLsSsWbNw6NAh3Lt3D/n5+VUObXCIpAn5+eKfuJGdCydrK4wNDary2rGM65h48FtAADrZe6KFtS1cLK3RwsoGLlY2cLG0qXhc+V8ra9iaWXBpcWowJxsrvDc80iSHSjiDxPQYY5GnmZkZli5diuDgYGRkZCAkJASDBw+GpaUlYmJicPDgQTg6OiIkJATR0dFo0aJFnW1GRkYCAAYMGFDlPIs8mwGVWo2VR34HAEzq1R22FhYAgDNZN/HpucM4nlmxQZWoBs5l30a9Zl+LgBwydJB7wNnaGk5WVnCysoKzlTUcrazgbGUFJ0srOFn99ZqTlTUsuKW3yascKvnp7GX8e+te/PCvZ2Bp3vx/XRRwq3bTY4Q1GF5eXvDyqkj6PT094erqiuzsbKSlpaFz585o2bIlACAqKgp79+7F2LF1D7cfPHhQ73E2/98YRmJv4hUkZ2XDwcoSz/QMxsXsDHx6/jAO3UoGAJjLZBjiG4DBrTpBFIHskiLcUxYhu6QI2coi3Cspxr0SBbJLinFPWQSlqhwQKhKXpOyGjavZmJtXJBuWVnjUtzXe7vO4IT4yNXFzhvTD8eRUzVCJKcwq0UxRZQ8GGdCRI0fwySefID4+Hrdv38a2bdswYsSIKtfExsbik08+QUZGBoKCgrBs2TL07NmzWlvx8fFQqVTw9fXF77//rkkuAKBly5ZIT6/fVgCPP67/3/NMMJoAtShixZGTAIAhwR3x1umd2JOWBACQCwJGtwvC9M6PoqWtY73aE0URucoS/JmdhTtFhXC0sEZuSTFyS0r+dhQjV1mCnJIS5JUUI0+phFoUUVRWhqKyMtwqKEAbJ2eDfW5q2kxxqIQ7qZoeKYZIFAoFgoKC8Nxzz2HkyJHVXt+8eTNiYmKwcuVKhIWFYenSpRg4cCCSkpLg7u6uuS47OxsTJkzAqlWrtP8AD8jNzcWXX36JxMREAEDnzp3x3HPPwdGxfn/3/B0TjCYg7nIy/ryTBblcwNd3f4eYXTEAMqx1Z7wa+Bja2rs0qD1BEOBsZY0wb98G3acWRRQolRVJR3Ex8pQlcLTkv+RMmakNlXAnVROkpyGSvxdCWlpawtKy5plIUVFRiIqKqrXJxYsXY+rUqZg8eTIAYOXKldi1axfWrFmD2bNnAwCUSiVGjBiB2bNno3fv3gAAb2/vKj0W6enpNfZ61OT06dMYOHAgrK2tNfcsXrwYH374Ifbu3Yvu3bvXq50HcRaJxDIU+Xhnz14AQKljKUQ5MMi3I3YPnoolvYc3OLnQhUwQ4GhlhdaOTgj29MLjrdsi2LN5/4uV6mYqs0pEUUS2shCAyCESajBfX184OjpqjgULFmjVTmlpKeLj4zVFlwAgk8kQGRmJ48cr/vyJoohJkyahf//+GD9+vOa6nj174sKFC0hPT0dhYSF2796NgQMH1ut933jjDQwbNgzXr1/H1q1bsXXrVqSkpOCf//wnXn/9da0+S/P9p4iROJaSirx8JURBRK9Ovnirez90cfGUOiwiDVMZKilRlWFz6hFYyAEruYXU4VAj0dcQSVpaGhwcHDTna+u9qEtWVhZUKhU8PDyqnPfw8MDly5cBAEePHsXmzZvRtWtXbN++HQCwfv16BAYG4tNPP0W/fv2gVqsxa9ases0gASp6MFatWgUzs7/SAjMzM8yaNQs9evTQ6rMwwZBYdOfOiL97E04yG8x8nMuCU9NkakMl9uZcZMtk6GmIZMCAAZDL5Zg2bRqmTZumj8hq1adPn2qbkVUaNmwYhg0b1uA2HRwckJqaWm0lz7S0NNjb22sVZ/P9DWEkBEHAh/0GSR0GUZ1MaVZJWIv2UodAjUVPCcapU6eq9GBoy9XVFXK5HJmZmVXOZ2ZmwtPTcL3bY8aMwZQpU7Bo0SJNTcfRo0cxc+bMek1zrQlrMIioXiqHSgBgzW/xOJt2W+KIDKetnZvUIZCJsrCwQEhICOLi4jTn1Go14uLiEB4ebrD3XbRoEUaOHIkJEyagTZs2aNOmDSZNmoTRo0dj4cKFWrXJBIOI6s3U9yqh5qeyBkOXo6EKCwuRkJCAhIQEAEBKSgoSEhKQmpoKAIiJicGqVauwbt06JCYm4uWXX4ZCodDMKjEECwsLfPbZZ8jJydHElp2djSVLlmhdT8IhEiJqEFMaKiEToKchktDQ0HrXYJw+fRr9+vXTPI+JiQEATJw4EWvXrsWYMWNw9+5dvPvuu8jIyEBwcDD27NlTrfDTEGxsbBAYGKiXtphgEFGDmMqsEqKGaEgNRkREBETx4VnN9OnTMX36dH2E9lA1LfRVk61btza4bSYYRNRgpjarhJovQRQh1PGXfV33GzNtV+msD/5GICKtcKiEmgUJhkiakq+++spgbRtdkadSqURwcDAEQdAUyNSmpKQE06ZNQ4sWLWBnZ4dRo0ZVm/pDRNoxpVklRHU5deoULl26ZFTJhaEZXYIxa9YseHt71+vaN954Az/99BO2bNmCw4cP49atW/UebyKiunFWCRk7KWaRmAqjSjB2796NvXv3YtGiRXVem5eXhy+//BKLFy9G//79ERISgq+++grHjh3DiRMnGiFaItNQuVeJu70tCpWlUodD1DCiHg6qkdHUYGRmZmLq1KnYvn07bGxs6rw+Pj4eZWVlVTaM8ff3R6tWrXD8+HH06tWrxvuUSiWUSqXm+d93yCOiqpxsrPDNi0/D28kBgiBIHY7WRFGEALXmMVFDGGsNhiEZRYJRuXPcSy+9hB49euD69et13pORkQELCws4OTlVOe/h4YGMjIxa71uwYAHmzZunY8REpqWls+Eq0RtLqboU/i53NI9twP1ITIG+NjvT11LhzYmkQySzZ8+GIAgPPS5fvoxly5ahoKAAc+bMMXhMc+bMQV5enuZIS0sz+HsSEZFEOERiMJL2YMyYMQOTJk166DXt2rXDgQMHcPz48WrLlfbo0QPPPPMM1q1bV+0+T09PlJaWIjc3t0ovRl0bxlhaWmq9LCoRGS8ruXmNj6l501cPBlUnaYLh5uYGN7e6NxX6/PPPMX/+fM3zW7duYeDAgdi8eTPCwsJqvCckJATm5uaIi4vDqFGjAABJSUlITU016IYxRGScHqwfMeZaEqKmwihqMFq1alXluZ2dHQDAz88PPj4+AID09HQMGDAAX3/9NXr27AlHR0dMmTIFMTExcHFxgYODA1555RWEh4fXWuBJREQmxsQX2jIko0gw6qOsrAxJSUkoKirSnFuyZAlkMhlGjRoFpVKJgQMH4r///a+EURIRUVOjj2EOFnlWZ5QJRps2bapNI6vpnJWVFWJjYxEbG9uY4REREZk8o0wwiIiI9EIUKw5d7qcaMcEgIiKTxVkkhmNUS4UTERGRcWCCQUREpktPC22FhoYiICCANX8P4BAJEREq9x8RH3hMpkBQVxy63A9wFklNmGAQEaFi/xE7eZnmsRWsJI6IyLgxwSAiItOlp4W2qDomGEREACxk5jU+puaNs0gMhwkGERG4F4nJ4joYBsNZJERERKR37MEgIiKTxSESw2EPBhERmS6ug2Ew7MEgIiLSEdfBqI4JBhERmSwOkRgOEwwiIlSs3ilwJU/Tw1kkBsMEg4gIQLmoRCvre5rHgLW0AREZOSYYRERksjhEYjhMMIiIAFjILGt8TM0clwo3GE5TJSICgAdX7+RKnkQ6Yw8GERGZLA6RGA4TDCIiMl1qseLQ5X6qERMMIiIyXazBMBjWYBAREemIS4VXxx4MIiJULq7FhbZMjQAdazDu/5dLhVfHBIOICIBKLIGHWb7mMRfaMhFcydNgOERCREREesceDCIiAOaCZY2PqXnjNFXDYYJBRARwoS1TxVkkBsMhEiIiItI79mAQEZHJEkQRgg6Fmrrc29wxwSAiItOlvn/ocj/ViEMkREREpHfswSAiIpPFIRLDYYJBRISK1TsFruRpejiLxGCYYBARAVCLxWhtfk/zGLCRNiBqHFzJ02BYg0FERER6xwSDiAiAmWBV42Nq3ipX8tTlkEJ0dDScnZ0xevToKucXLVqEzp07o0uXLtiwYYM0wd3HBIOICIDwwOqdAlfyNB2VQyS6HBJ47bXX8PXXX1c5d/78eWzatAnx8fE4deoUli9fjtzcXEniA5hgEBERGZ2IiAjY29tXOZeYmIjw8HBYWVnB2toaQUFB2LNnj0QRMsEgIiITJqh1PxrqyJEjGDp0KLy9vSEIArZv317tmtjYWLRp0wZWVlYICwvDyZMn62y3S5cuOHToEHJzc5GTk4NDhw4hPT294QHqCRMMIiIyXXoaIsnPz69yKJXKWt9SoVAgKCgIsbGxNb6+efNmxMTEYO7cuThz5gyCgoIwcOBA3Llz56EfJSAgAK+++ir69++PkSNHolevXpDL5dp/NzpigkFERKQjX19fODo6ao4FCxbUem1UVBTmz5+P6OjoGl9fvHgxpk6dismTJyMgIAArV66EjY0N1qxZU2ccL774Is6cOYODBw/C3NwcHTp00Poz6YrrYBARkenS00JbaWlpcHBw0Jy2tLTUqrnS0lLEx8djzpw5mnMymQyRkZE4fvx4nfffuXMH7u7uSEpKwsmTJ7Fy5Uqt4tAHJhhERAAgin916XLxJJOhr6XCHRwcqiQY2srKyoJKpYKHh0eV8x4eHrh8+bLmeWRkJM6ePQuFQgEfHx9s2bIF4eHhGD58OPLy8mBra4uvvvoKZmbS/TXPBIOICABQgnCrihRDRAkAW2nDIaMSGhoKuVyOadOmYdq0aQZ/v/3799d4vj69HI2FCQYREZkuPS0VfurUKb30YLi6ukIulyMzM7PK+czMTHh6eurcfmNikScREQDhgdU7Ba7kaTpEAGodDj2PpllYWCAkJARxcXGac2q1GnFxcQgPD9fvmxkYezCIiAAImr1UKx6TadBXDUZDhkgKCwtx9epVzfOUlBQkJCTAxcUFrVq1QkxMDCZOnIgePXqgZ8+eWLp0KRQKBSZPnqx1nFJggkFERKSjhgyRnD59Gv369dM8j4mJAQBMnDgRa9euxZgxY3D37l28++67yMjIQHBwMPbs2VOt8LOpY4JBRESmS4SONRgNvyUiIgJiHe85ffp0TJ8+XcugmgYmGEREZLr0VORJ1bHIk4iISEehoaEICAiodflvU8QeDCIiAKIoQnX/H6NyUWSZp6lQAzr9z76/2Zm+pqk2J0wwiIgAqMQSHCip+JXYXyyBjAttmQR9zSKh6jhEQkRERHrHBIOICAAeXFyLC22ZDj1t184ajOo4REJEBEAQhBofUzPXxJYKb07Yg0FERER6xwSDiIxKZmEhLmfdlToMai70NERC1XGIhIiMxrXsbIzf+j3Uoogfnh4Hb3t7qUMiY6enaapUHXswiMhouNrYwM7CEpkKBab8uA0FSqXUIZGRq5ymqssBsMizJkwwiMhoOFhZYc2IaLjZ2CIpKwvTd+1EmUoldVhEOHXqFC5dulTnTqqmhAkGERmVlg4OWD18BKzNzPBr6g28ezCuzo2j6kMURZSq5ShVy/XSHhkJ1mAYDBMMIjI6gR4e+HzwEMgEAZsvXMCKU6d0brNEXYaFKVFYmBKFEnWZHqIko6AWdT+oRkwwiMgoDWjnh3cj+gEAFh37DTsuX5Y4IiJ6EBMMIjJaE4KCMaV7CABg1r5fcDL9ptZtyQXrGh9TM8chEoNhgkFERm3OY30xsH17lKpUeOmnHbiWna1VO1zJ01TpmlxwFkltmGAQkVGTCQIWD4xCsKcncktK8NyP23CvqEjqsMjEcBZJdUwwiMjoWZub43/DRsDXwRGpeXl4YcePKClnoSbVA4dIDIYJBhE1C642NlgzIhqOlpb4I+M2YvbsgZq//KkunEViMEaXYCiVSgQHB0MQBCQkJDz02oiICAiCUOV46aWXGidQImp0fi4u+GLocFjI5dhz9Qo++vWI1CERmSyjSzBmzZoFb2/vel8/depU3L59W3N8/PHHBoyOiKTW08cHC//xBABg9Zl4fH02QdqAqGkT1bofVCOjSjB2796NvXv3YtGiRfW+x8bGBp6enprDwcHBgBESUVMw3L8TZvR+FADw/qGDiLt2rc57RFGEWg2o1eBKnqaENRgGYzQJRmZmJqZOnYr169fDxsam3vdt3LgRrq6u6NKlC+bMmYOiOqrLlUol8vPzqxxEZHz+FdoTT3XuArUo4tWfd+J8ZuZDry9WleNWRgvcymiBYlV5I0VJkmMNhsEYRYIhiiImTZqEl156CT169Kj3fePGjcOGDRtw8OBBzJkzB+vXr8ezzz770HsWLFgAR0dHzeHr66tr+EQkAUEQ8EH/AejTqjWKy8vx/I/bkc5/MJCBcB2M6sykfPPZs2dj4cKFD70mMTERe/fuRUFBAebMmdOg9l944QXN48DAQHh5eWHAgAFITk6Gn59fjffMmTMHMTExmuf5+flMMoiMlLlcjuVD/okxWzYjKSsLU37chu+eehoOlpbVrrUSzGp8TM2crsMc9+89deoUh+D/RtI/RTNmzMCkSZMeek27du1w4MABHD9+HJZ/+6XQo0cPPPPMM1i3bl293i8sLAwAcPXq1VoTDEtLy2rvQ0TGy8HSEl8Oj8bIbzfhz3v38K+dP2HNiGhYyOVVruNKniZKhI4Jht4iaXYkTTDc3Nzg5uZW53Wff/455s+fr3l+69YtDBw4EJs3b9YkDfVROa3Vy8urwbESkfHytrfHl8OjMWbLZhxLS8U7cfux8B9PMJEgMiCjqMFo1aoVunTpojkeeeQRAICfnx98fHwAAOnp6fD398fJkycBAMnJyfjggw8QHx+P69evY8eOHZgwYQL69u2Lrl27SvZZiEgand3dsez+Fu/fX7qI2JO/Sx0SNQWcRWIwRpFg1EdZWRmSkpI0s0QsLCywf/9+PPHEE/D398eMGTMwatQo/PTTTxJHSkRS6de2Heb16w8AWHz8GLYnXpI4IpJc5dxkXQ6qkVFWMrVp06baPPW/n/P19cXhw4cbOzQiauKe6RqEtLw8/C/+NN7atxde9vYI82EhN5G+NZseDCKi+prV5zFEdeiAMrUaL/60A1ez70kdEkmFQyQGwwSDiEyOTBDw6cBB6O7lhXylEs9t34YsbvFumphgGAwTDCIySVZm5vhi6HC0dnTEzfx8vLJrF6ccEukREwwiMlktbGzw5YiRcLKywvk7mRAK5UwyTA2XCjcYJhhEZNLaOTtrtngXymQQivhr0ZSIolrnA+BS4TXhnyQiMnmhLVviwwGRAABBKcfGc2cljogajahj78UDS4VfunQJ06ZNk/gDNR1MMIiIAER16AC1tQoiRNhzuwAinRnlOhhERPpmbWaOi5NfRUpuLjq7uUsdDjUWUYROhTecRVIrJhhERKjY4MzWwhJd3D2kDoUak1oNCDqsxilyJc/acIiEiIiI9I49GEREZLo4RGIwTDCIiMhkiWo1RB2GSEQOkdSKQyRERESkd+zBICIi08UhEoNhgkFERKZLLQICEwxD4BAJERER6R17MIiIyHSJIgBd1sFgD0Zt2INBREQmS1SLOh9SiI6OhrOzM0aPHl3l/JIlS9C5c2cEBATg1VdfhShhAsQEg4iITJeo1v2QwGuvvYavv/66yrm7d+9i+fLliI+Px/nz5xEfH48TJ05IEh/ABIOIiMjoREREwN7evtr58vJylJSUoKysDGVlZXB3l25fHSYYRERksqQYIjly5AiGDh0Kb29vCIKA7du3V7smNjYWbdq0gZWVFcLCwnDy5Mk623Vzc8Obb76JVq1awdvbG5GRkfDz82twfPrCBIOIiEyXBEMkCoUCQUFBiI2NrfH1zZs3IyYmBnPnzsWZM2cQFBSEgQMH4s6dOw9tNycnBzt37sT169eRnp6OY8eO4ciRIw2OT184i6QOlQUy+fn5EkdCRGQaKn/fNkaBYjnKdFpnqxxlAKr/HWFpaQlLS8sa74mKikJUVFStbS5evBhTp07F5MmTAQArV67Erl27sGbNGsyePbvW+/bv34/27dvDxcUFADBkyBCcOHECffv2bdBn0hcmGHUoKCgAAPj6+kocCRGRaSkoKICjo6NB2rawsICnpyd+y/hZ57bs7Oyq/R0xd+5cvPfeew1uq7S0FPHx8ZgzZ47mnEwmQ2RkJI4fP/7Qe319fXHs2DGUlJTA3Nwchw4dwgsvvNDgGPSFCUYdvL29kZaWBnt7ewiCIHU4Rik/Px++vr5IS0uDg4OD1OEYJX6HuuN3qLvG+g5FUURBQQG8vb0N9h5WVlZISUlBaWmpzm2Joljt74faei/qkpWVBZVKBQ8PjyrnPTw8cPnyZc3zyMhInD17FgqFAj4+PtiyZQvCw8MxePBgdOvWDTKZDAMGDMCwYcO0ikMfmGDUQSaTwcfHR+owmgUHBwf+YtcRv0Pd8TvUXWN8h4bquXiQlZUVrKysDP4+hrB///4az3/44Yf48MMPGzmamrHIk4iIqIlwdXWFXC5HZmZmlfOZmZnw9PSUKCrtMMEgIiJqIiwsLBASEoK4uDjNObVajbi4OISHh0sYWcNxiIQMztLSEnPnztV6TJL4HeoDv0Pd8TvUj8LCQly9elXzPCUlBQkJCXBxcUGrVq0QExODiRMnokePHujZsyeWLl0KhUKhmVViLARRyoXKiYiITMyhQ4fQr1+/aucnTpyItWvXAgCWL1+OTz75BBkZGQgODsbnn3+OsLCwRo5UN0wwiIiISO9Yg0FERER6xwSDiIiI9I4JBhEREekdEwzSm48++giCIOD111+v9Zq1a9dCEIQqh7EudKMv7733XrXvxN/f/6H3bNmyBf7+/rCyskJgYCB+/ln35Y6NWUO/Q/4c1iw9PR3PPvssWrRoAWtrawQGBuL06dMPvefQoUPo3r07LC0t0b59e02RIhGnqZJenDp1Cl988QW6du1a57UODg5ISkrSPOcS7EDnzp2rrMxnZlb7H81jx45h7NixWLBgAf75z39i06ZNGDFiBM6cOYMuXbo0RrhNUkO+Q4A/h3+Xk5ODRx99FP369cPu3bvh5uaGK1euwNnZudZ7UlJSMGTIELz00kvYuHEj4uLi8Pzzz8PLywsDBw5sxOipKWKCQTorLCzEM888g1WrVmH+/Pl1Xi8IgtGtSGdoZmZm9f5OPvvsMwwaNAgzZ84EAHzwwQfYt28fli9fjpUrVxoyzCatId8hwJ/Dv1u4cCF8fX3x1Vdfac61bdv2ofesXLkSbdu2xaeffgoA6NSpE3777TcsWbKECQZxiIR0N23aNAwZMgSRkZH1ur6wsBCtW7eGr68vhg8fjosXLxo4wqbvypUr8Pb2Rrt27fDMM88gNTW11muPHz9e7bseOHBgnTstNncN+Q4B/hz+3Y4dO9CjRw88+eSTcHd3R7du3bBq1aqH3sOfRXoYJhikk2+//RZnzpzBggUL6nV9x44dsWbNGvz444/YsGED1Go1evfujZs3bxo40qYrLCwMa9euxZ49e7BixQqkpKTgscceQ0FBQY3XZ2Rk1LjTYkZGRmOE2yQ19Dvkz2F1165dw4oVK9ChQwf88ssvePnll/Hqq69i3bp1td5T289ifn4+iouLDR0yNXUikZZSU1NFd3d38ezZs5pzjz/+uPjaa6/Vu43S0lLRz89PfOeddwwQoXHKyckRHRwcxNWrV9f4urm5ubhp06Yq52JjY0V3d/fGCM8o1PUd/h1/Dit+rsLDw6uce+WVV8RevXrVek+HDh3E//znP1XO7dq1SwQgFhUVGSROMh7swSCtxcfH486dO+jevTvMzMxgZmaGw4cP4/PPP4eZmRlUKlWdbZibm6Nbt25V1uU3dU5OTnjkkUdq/U48PT2bxU6LhlTXd/h3/DkEvLy8EBAQUOVcp06dHjrUVNvPooODA6ytrQ0SJxkPJhiktQEDBuD8+fNISEjQHD169MAzzzyDhIQEyOXyOttQqVQ4f/48vLy8GiFi41BYWIjk5ORav5Pw8PAqOy0CwL59+4xup0VDqus7/Dv+HAKPPvpolVk1APDnn3+idevWtd7Dn0V6KKm7UKh5+fsQyfjx48XZs2drns+bN0/85ZdfxOTkZDE+Pl58+umnRSsrK/HixYsSRNs0zJgxQzx06JCYkpIiHj16VIyMjBRdXV3FO3fuiKJY/Ts8evSoaGZmJi5atEhMTEwU586dK5qbm4vnz5+X6iNIrqHfIX8Oqzt58qRoZmYmfvjhh+KVK1fEjRs3ijY2NuKGDRs018yePVscP3685vm1a9dEGxsbcebMmWJiYqIYGxsryuVycc+ePVJ8BGpiOE2VDCo1NRUy2V8dZTk5OZg6dSoyMjLg7OyMkJAQHDt2rFrXrCm5efMmxo4di3v37sHNzQ19+vTBiRMn4ObmBqD6d9i7d29s2rQJ77zzDt5++2106NAB27dvN+k1MBr6HfLnsLrQ0FBs27YNc+bMwfvvv4+2bdti6dKleOaZZzTX3L59u8qQSdu2bbFr1y688cYb+Oyzz+Dj44PVq1dziioB4G6qREREZACswSAiIiK9Y4JBREREescEg4iIiPSOCQYRERHpHRMMIiIi0jsmGERERKR3TDCIiIhI75hgEBERkd4xwSBqZu7duwd3d3dcv35dp3aefvppfPrpp/oJiohMDhMMoiZo0qRJEAQBgiDA3Nwcbdu2xaxZs1BSUlLnvR9++CGGDx+ONm3a6BTDO++8gw8//BB5eXk6tUNEpokJBlETNWjQINy+fRvXrl3DkiVL8MUXX2Du3LkPvaeoqAhffvklpkyZovP7d+nSBX5+ftiwYYPObRGR6WGCQdREWVpawtPTE76+vhgxYgQiIyOxb9++h97z888/w9LSEr169dKcO3ToEARBwC+//IJu3brB2toa/fv3x507d7B792506tQJDg4OGDduHIqKiqq0N3ToUHz77bcG+XxE1LwxwSAyAhcuXMCxY8dgYWHx0Ot+/fVXhISE1Pjae++9h+XLl+PYsWNIS0vDU089haVLl2LTpk3YtWsX9u7di2XLllW5p2fPnjh58iSUSqXePgsRmQZu107URO3cuRN2dnYoLy+HUqmETCbD8uXLH3rPjRs34O3tXeNr8+fPx6OPPgoAmDJlCubMmYPk5GS0a9cOADB69GgcPHgQb731luYeb29vlJaWIiMjA61bt9bTJyMiU8AEg6iJ6tevH1asWAGFQoElS5bAzMwMo0aNeug9xcXFsLKyqvG1rl27ah57eHjAxsZGk1xUnjt58mSVe6ytrQGg2tAJEVFdOERC1ETZ2tqiffv2CAoKwpo1a/D777/jyy+/fOg9rq6uyMnJqfE1c3NzzePK2SkPEgQBarW6yrns7GwAgJubmzYfgYhMGBMMIiMgk8nw9ttv45133kFxcXGt13Xr1g2XLl3S2/teuHABPj4+cHV11VubRGQamGAQGYknn3wScrkcsbGxtV4zcOBAXLx4sdZejIb69ddf8cQTT+ilLSIyLUwwiIyEmZkZpk+fjo8//hgKhaLGawIDA9G9e3d89913Or9fSUkJtm/fjqlTp+rcFhGZHkEURVHqIIhIf3bt2oWZM2fiwoULkMm0/zfEihUrsG3bNuzdu1eP0RGRqeAsEqJmZsiQIbhy5QrS09Ph6+urdTvm5ubV1sUgIqov9mAQERGR3rEGg4iIiPSOCQYRERHpHRMMIiIi0jsmGERERKR3TDCIiIhI75hgEBERkd4xwSAiIiK9Y4JBREREescEg4iIiPTu/wEKdh9snzmbmAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -185,7 +177,7 @@ "\n", "for bin in my_reactor.divertor.bins:\n", " ion_fluxes.append(\n", - " float(plasma_data_handling.get_particle_flux(FP_pulse, bin=bin, t_rel=0, ion=True))\n", + " float(plasma_data_handling.get_particle_flux(FP_pulse, bin=bin, t_rel=FP_pulse.ramp_up+1, ion=True))\n", " )\n", " start_points.append(bin.start_point)\n", " end_points.append(bin.end_point)\n", @@ -209,12 +201,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -224,7 +216,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -234,7 +226,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -254,7 +246,7 @@ " for bin in my_reactor.first_wall.bins:\n", " for sub_bin in bin.sub_bins:\n", " if sub_bin.mode == mode:\n", - " ion_flux = plasma_data_handling.get_particle_flux(FP_pulse, bin=sub_bin, t_rel=0, ion=True)\n", + " ion_flux = plasma_data_handling.get_particle_flux(FP_pulse, bin=sub_bin, t_rel=FP_pulse.ramp_up+1, ion=True)\n", " ion_fluxes.append(ion_flux)\n", "\n", " start_points.append(bin.start_point)\n", @@ -281,12 +273,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -296,7 +288,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -306,7 +298,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -326,7 +318,7 @@ " for bin in my_reactor.first_wall.bins:\n", " for sub_bin in bin.sub_bins:\n", " if sub_bin.mode == mode:\n", - " atom_flux = plasma_data_handling.get_particle_flux(FP_pulse, bin=sub_bin, t_rel=0, ion=False)\n", + " atom_flux = plasma_data_handling.get_particle_flux(FP_pulse, bin=sub_bin, t_rel=FP_pulse.ramp_up+1, ion=False)\n", " atom_fluxes.append(atom_flux)\n", "\n", " start_points.append(bin.start_point)\n", @@ -353,12 +345,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAHACAYAAADQjQDuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABhTElEQVR4nO3dd1hTZxsG8DtsAUGWAoIoVMUtSt0LtSp1i9a6EFdrq9bVqlhb9bOKtnXV3bpXHXWLW8Fq3VgcVXGhUBRQUfbO+f5AUlFRSEJOTnL/er1Xk3DOyZM0DQ/veF6ZIAgCiIiISC8ZiB0AERERiYeJABERkR5jIkBERKTHmAgQERHpMSYCREREeoyJABERkR5jIkBERKTHmAgQERHpMSYCREREeoyJABERkR5jIkBERDrrzz//ROfOneHs7AyZTIbdu3cX6/xp06ZBJpO90SwsLEomYBEwESAiIp2VmpqKOnXqYMmSJUqd//XXX+Px48cFWvXq1dGrVy81RyoeJgJERKSzfH198cMPP6B79+5v/XlmZia+/vprlC9fHhYWFmjYsCFCQ0MVP7e0tISjo6OixcXF4caNGxgyZIiGXkHJYyJARER6a+TIkTh79iy2bNmCq1evolevXujQoQPu3Lnz1uNXrlyJKlWqoHnz5hqOtOQwESAiIr0UFRWFNWvWYPv27WjevDk8PDzw9ddfo1mzZlizZs0bx2dkZGDTpk061RsAAEZiB0BERCSGa9euITc3F1WqVCnweGZmJuzs7N44fteuXUhOTsbAgQM1FaJGMBEgIiK9lJKSAkNDQ4SFhcHQ0LDAzywtLd84fuXKlejUqRPKlSunqRA1gokAERHpJS8vL+Tm5iI+Pv69Y/6RkZEICQnB3r17NRSd5jARICIinZWSkoK7d+8q7kdGRiI8PBy2traoUqUK+vXrB39/f8ydOxdeXl548uQJjh8/jtq1a6Njx46K81avXg0nJyf4+vqK8TJKlEwQBEHsIIiIiEpCaGgofHx83nh84MCBWLt2LbKzs/HDDz9g/fr1iImJgb29PRo1aoTp06ejVq1aAAC5XA43Nzf4+/tj5syZmn4JJY6JABERkR7j8kEiIiI9xkSAiIhIj3Gy4HvI5XI8evQIpUuXhkwmEzscIiKdJwgCkpOT4ezsDAODkvt7NSMjA1lZWSpfx8TEBGZmZmqISBxMBN7j0aNHcHV1FTsMIiK9Ex0dDRcXlxK5dkZGBipVckRsbKLK13J0dERkZKRkkwEmAu9RunRpAHkfSCsrK5GjISLSfUlJSXB1dVV8/5aErKwsxMYm4kH0QlhZlVL6OklJ6ajoOhpZWVlMBHRV/nCAlZUVEwEiIg3SxHCspaUpLC1NlT5fLperMRpxMBEgIiK9JQg5EIQclc6XOiYCRESktwQhF4KQq9L5Usflg0RERHqMPQJERKS35EIO5Cp076tyrrZgIkBERHqLcwQ4NEBERKTX2CNARER6K2+yoCo9AtKfLMhEgIiI9JYgz4EgVyERUOFcbSGJoYEHDx5gyJAhqFSpEkqVKgUPDw9MnTr1vTWiW7VqBZlMVqANHz5cQ1ETERFpP0n0CNy6dQtyuRwrVqzABx98gOvXr2PYsGFITU3Fzz///M5zhw0bhv/973+K++bm5iUdLhERSYWQk9dUOV/iJJEIdOjQAR06dFDcd3d3R0REBJYtW/beRMDc3ByOjo4lHSIREUkQVw1IZGjgbRITE2Fra/ve4zZt2gR7e3vUrFkTgYGBSEtLe+fxmZmZSEpKKtCIiIh0lSR6BF539+5dLFq06L29AX379oWbmxucnZ1x9epVTJw4EREREdi5c2eh5wQFBWH69Olqi/XAgYNo374dDA0N1XZNIiJSE3kOIM9W7XyJE7VHYNKkSW9M5nu93bp1q8A5MTEx6NChA3r16oVhw4a98/qfffYZ2rdvj1q1aqFfv35Yv349du3ahXv37hV6TmBgIBITExUtOjpa6dd34MBBdOrYFc2atsSNGzeUvg4REZWM/KEBVZrUidojMH78eAQEBLzzGHd3d8XtR48ewcfHB02aNMGvv/5a7Odr2LAhgLweBQ8Pj7ceY2pqClNT5bekfFVSUhKsrKxw/vwF1PNqgO++/xYTJnwNY2NjtVyfiIhUJM8B5Cr02OpAj4CoiYCDgwMcHByKdGxMTAx8fHxQv359rFmzBgYGxe/MCA8PBwA4OTkV+1xlfPppbzRr1hRfDB+J4OAD+G7KVOz4YydWrf4VXl5eGomBiIjoXSQxWTAmJgatWrVChQoV8PPPP+PJkyeIjY1FbGxsgWM8PT1x4cIFAMC9e/cwY8YMhIWF4cGDB9i7dy/8/f3RokUL1K5dW2Oxu7i4YO++XdiwcS1sbW0RHn4FDT5sgilTvkdmZqbG4iAioreQ56jeJE4SicDRo0dx9+5dHD9+HC4uLnByclK0fNnZ2YiIiFCsCjAxMcGxY8fQrl07eHp6Yvz48fDz88O+ffs0Hr9MJkO/fn3xz40r6NXLD7m5uZg1czbqeX2Ic+fOazweIiLKl/tfLQFlGqRfYlgmCIIgdhDaLCkpCdbW1khMTISVlZVarrlz5y6M+PIrxMXFQSaTYczY0ZgxYxqLHRERoWS+dwt7jujIz2FV2kT56yRnwbXSihKNtaRJokdA1/To0R3/3LgCf//+EAQB8+ctQJ3a9REaelLs0IiI9IpMnqNykzomAiKxtbXF2nWrEXxgL1xcXHDv3j209vkIX3wxkkWMiIg0hXMEmAiIzde3A67/E47PPs+ribBi+a+oVdMLhw4dFjkyIiJSt4oVK761Zs6IESNEi4mJgBawsrLC8uVLcPzEEbi7uyM6Ohof+3bGoIAhSEhIEDs8IiLdpeEegYsXL+Lx48eKdvToUQBAr169SuLVFQkTAS3i49MKV66GYczY0ZDJZFi3bgNq1qiLXbt2ixwZEZFukgk5KrficHBwgKOjo6Lt378fHh4eaNmyZQm9wvdjIqBlLCwsMG/eTzj910l4elZFbGws/Hp8gk9790V8fLzY4RERkZpkZWVh48aNGDx4MGQymWhxMBHQUo0bN8Llvy8icPJEGBoaYtu2P1Cjeh1s3vw7uOKTiEhN5HJAnqtCkwPAG7vWFqVg3O7du/HixYv3ltovaUwEtJiZmRlmzpyB8xfOoE6d2nj27Bn69xuIbl17ICYmRuzwiIgkT13LB11dXWFtba1oQUFB733uVatWwdfXF87OziX9Mt+JiYAE1KvnhQsXz+J/M6bB2NgY+/YFo2aNuli5cjV7B4iIVKFSb8DLBiA6OrrAzrWBgYHvfNqHDx/i2LFjGDp0qCZe5TsxEZAIY2NjTJkyGZf/voAGDT5EYmIiPhs2HO3bfYzIyEixwyMi0mtWVlYF2vt2sV2zZg3Kli2Ljh07aijCwjERkJgaNWrgrzN/4qef58DMzAzHjh1H7Vr1sGjREshfjlUREVERiVBQSC6XY82aNRg4cCCMjETdBBgAEwFJMjQ0xPjxY3HlahhatGiO1NRUjP5qLFq1bIPbt2+LHR4RkWTI5Lkqt+I6duwYoqKiMHjw4BJ4RcXHREDCKleujBMhR7F4yS+wtLTE6dN/oU7t+vjxx5+RkyP9spdERLqoXbt2EAQBVapUETsUAEwEJM/AwABffjkc167/jXbtPkJmZiYmTZyMJo2b49q1a2KHR0Sk3QQVJwoK0t+GmImAjnBzc8PBQ/uxes1KlClTBpcuhcG7fiNMnz4DWVlZYodHRKSVZHK5ikMD0p+bxURAh8hkMgQE+OOfG1fQtWtnZGdnY/q0GfjQuxEuXQoTOzwiItJCTAR0kJOTE3bu+gO/b9kIe3t7XLt2HY0aNsWkSZORnp4udnhERNpDTXUEpIyJgI6SyWTo3fsT/HPjCvr06Q25XI4f5/wMr7re+OuvM2KHR0SkFcRYNaBtmAjoOAcHB2zavAG79+yAk5MTbt++gxbNfTB69DikpKSIHR4REYmMiYCe6NKlM/65cQWDBgdAEAQs+mUxateqh+PHT7BMMRHpLw4NMBHQJ2XKlMGqVb/i0OFguLm54cGDB/iobQe4VfDAs2fPxA6PiEjjODTAREAvtWv3Ea5euwz/gQMAAP/++y/69x/IngEi0j/sEWAioK9Kly6NtWtXYcYP0wEAhw8dwaJFS0SOioiINI2JgJ779ttAzPkxb9/scWO/RnDwAZEjIiLSHJlceFlUSNkm/Z5UJgKEr78eh8FDBkEul6PPp/1x9epVsUMiItIMDg0wEaC8mgNLly6Cj08rpKSkoHOn7oiNjRU7LCIi0gAmAgQAMDExwR87tqJKlcqIjo5Gt65+rEJIRLqPmw4xEaD/2NjYYN/+3bC1tcWFCxcRMHAw5DqwoQYRUWFkglzlJnVMBKiAypUrY8fObTA2Nsb27Tswdep0sUMiIqISxESA3tCyZQus+HUZAGDmD0HYsGGjyBEREZUQThZkIkBvFxDgj4mTvgEADBs6HKdP/yVyREREJUAuV71JHBMBKtTMmTPg59cdWVlZ6N6tJ+7duyd2SEREpGZMBKhQBgYGWLd+DerXr4dnz56hc6duePHihdhhERGpD3sEmAjQu5mbm2PP3p1wcXHBrVsR+KRXH2RnZ4sdFhGRWuRVB1Rl0yEmAqQHnJ2dsXffTlhYWODYseMYNWoMNygiIt3AHgEmAlQ0devWxebfN0Amk+HXFb9hwYJfxA6JiIjUgIkAFVnnzp3w089zAABfj5+Affv2ixwREZGK2CPARICKZ+zY0Rj22VAIgoC+fQYgPDxc7JCIiJTHRICJABWPTCbD4sUL0aZNa6SmpqJxo+Y4deq02GEREZGSmAhQsRkbG2Pb9t9hYWGBzMxMfDZsuNghEREph5sOMREg5djY2GDxkrwJgzExj5CcnCxyRERExZe3fFC1JnVMBEhp/v794elZFSkpKVi3boPY4RARkRKYCJDSZDIZRoz8EgCwZPFSbllMRNLDyYJMBEg1/v79Ubp0aURE3MbRo8fEDoeIqHiYCDARINWULl0aAYMGAgAWL1oqcjRERFRcTARIZSNHfgEAOHDgIHcoJCJpkQsq9ghIv9w6EwFSWeXKleHr2wGCIGDJkuVih0NEVHRyQfUmcUwESC1GjsqbNLhm9VqkpKSIHA0RURFxjgATAVKP9u3boXLlD5CYmIgNGzaJHQ4RERUREwFSCwMDA3w5Im+uwJLFS7lNMRFJA3sEmAiQ+gQE+MPS0hI3btzEiRMhYodDRPR+nCPARIDUx9raGv4DBwAAFi9aInI0RETaKSYmBv3794ednR1KlSqFWrVq4dKlS6LFw0SA1Cp/KeHevfsRGRkpcjRERO8hyFVvxfD8+XM0bdoUxsbGOHjwIG7cuIG5c+fCxsamhF7g+zERILXy9PTERx+1hSAIWLp0hdjhEBG9m6DisEAx50PNmTMHrq6uWLNmDRo0aIBKlSqhXbt28PDwKKEX+H5MBEjt8pcSrl61BmlpaSJHQ0RU8pKSkgq0zMzMtx63d+9eeHt7o1evXihbtiy8vLzw22+/aTjagpgIkNp9/LEvKlWqhOfPn2PTpt/FDoeIqHBqmizo6uoKa2trRQsKCnrr092/fx/Lli1D5cqVcfjwYXzxxRf46quvsG7dOk2+6gKMRHtm0lmGhoYYMfILfD1+Ahb9shhDhw6GTCYTOywiojfJBUCVFYAvE4Ho6GhYWVkpHjY1NX374XI5vL29MWvWLACAl5cXrl+/juXLl2PgwIEqBKI89ghQiRg8OADm5ua4fv0fnDz5p9jhEBGVKCsrqwKtsETAyckJ1atXL/BYtWrVEBUVpYkw34qJAJWIMmXKoP+AfgC4lJCItJeGFw2gadOmiIiIKPDY7du34ebmpsZXVTxMBKjE5C8l3L17r6jZLhFRoTRcUGjs2LE4d+4cZs2ahbt372Lz5s349ddfMWLEiBJ6ge/HRIBKTM2aNeHj0wpyuRzLlnEpIRFpIbkaWjF8+OGH2LVrF37//XfUrFkTM2bMwIIFC9CvXz/1vB4lMBGgEpW/lHDxoiVvdIcREemjTp064dq1a8jIyMDNmzcxbNgwUeNhIkAlqnPnTjA1NUVqahrmzV0gdjhERAVpuEdAGzERoBJlZGSE2nVqAwAys7JEjoaI6DWCGprEMRGgEufn1x0AkFVIpS0iIhIPCwpRifP0rAoAuH37jsiREBEVJMhlEOTKFzwr7vJBbcREgEpclSqVAeQlAoIgsMogEWkPVcf5dSAR4NAAlTh3d3cYGhoiJSUFjx8/FjscIiJ6BRMBKnEmJiaoVKkSACAi4rbI0RARvUKQAXIVmiD9Hk4mAqQRVatWAcBEgIi0S/4cAVWa1EkmEejSpQsqVKgAMzMzODk5YcCAAXj06NE7z8nIyMCIESNgZ2cHS0tL+Pn5IS4uTkMR06sqvzJPgIiItIdkEgEfHx9s27YNERER2LFjB+7du4eePXu+85yxY8di37592L59O06ePIlHjx6hR48eGoqYXpXfI3CbPQJEpE1UGRbIbxInmVUDY8eOVdx2c3PDpEmT0K1bN2RnZ8PY2PiN4xMTE7Fq1Sps3rwZrVu3BgCsWbMG1apVw7lz59CoUSONxU4FVw4QEWkNQcVxfhYUEkdCQgI2bdqEJk2avDUJAICwsDBkZ2ejbdu2isc8PT1RoUIFnD17ttBrZ2ZmIikpqUAj1eX3CERGRiKLFQaJSEtwjoDEEoGJEyfCwsICdnZ2iIqKwp49ewo9NjY2FiYmJihTpkyBx8uVK4fY2NhCzwsKCoK1tbWiubq6qit8vebk5ARLS0vk5ubi/v37YodDREQviZoITJo0CTKZ7J3t1q1biuO/+eYb/P333zhy5AgMDQ3h7+8PQVBvv0xgYCASExMVLTo6Wq3X11cymUwxPMCVA0SkNeQGqjeJE3WOwPjx4xEQEPDOY9zd3RW37e3tYW9vjypVqqBatWpwdXXFuXPn0Lhx4zfOc3R0RFZWFl68eFGgVyAuLg6Ojo6FPp+pqSlMTU2L/Vro/apUqYzLl//mPAEi0h6qTvjTgcqCoiYCDg4OcHBwUOpcuTzv3c8sZCOb+vXrw9jYGMePH4efnx8AICIiAlFRUW9NHKjkVWEtASIirSOJVQPnz5/HxYsX0axZM9jY2ODevXv47rvv4OHhofilHhMTgzZt2mD9+vVo0KABrK2tMWTIEIwbNw62trawsrLCqFGj0LhxY64YEEn+0MAd9ggQkZYQBBkEFVYNqHl0WhSSSATMzc2xc+dOTJ06FampqXByckKHDh0wZcoURTd+dnY2IiIikJaWpjhv/vz5MDAwgJ+fHzIzM9G+fXssXbpUrJeh96pWzduFkD0CRKQ15AYqDg1IPxOQCeqebadjkpKSYG1tjcTERFhZWYkdjqQlJSWhjLU9AOD8hb/w4YcfihwREWkjTXzv5j9H3GQbWJkpnwgkZQgoN+u5pH9HSKJHgHRD6dKlFbdfPH8hXiBERC8JcqhUC0DQgR4BJgKkMcnJyYrbzZo3EzESIqKXBBVXDXD3QaKie/HiBYC8bYnNzMzEDYaIiACwR4A0KD8RsLGxgUwm/SyaiKRP9VUD0v8uYyJAGvP85byAMmWsxQ2EiCifqtUBWVCIqOjyewRe3/+BiEgsqm4cxE2HiIohv0fAxsZG3ECIiEiBPQKkMf/1CHBogIi0A+cIMBEgDcpPBKw5NEBE2oJzBDg0QJrz39BAGVHjICKi/7BHgDQmkZMFiUjLcLIgEwHSIK4aICJtwzkCHBogDeLQABGR9mGPAGkMewSISOtwsiATAdKcu3fvAgASEhJEjoSIKA/nCHBogDQkNTUV6ekZAAB7ezuRoyEionzsESCN+OuvMwAAW1tbNGzYUORoiIjycLIgEwHSkBMnQgAAXbp0gqWlpcjREBG9JKg4R0BQXyhiYSJAGhFyIhQA4NO6lahxEBG9inMEOEeANODFixcIC7sMAPDxaSVmKEREopo2bRpkMlmB5unpKWpM7BGgEvfnn6cgl8tRpUpluLi4iB0OEZGCIKg2zi8oMTRQo0YNHDt2THHfyEjcX8VMBKjEnVAMC/iIGwgR0etUHBqAEucaGRnB0dFR+edUMw4NUIkLDQkFALTm/AAi0lFJSUkFWmZmZqHH3rlzB87OznB3d0e/fv0QFRWlwUjfxESAStSTJ09w9eo1AECrVi1FjoaIqCBBMFC5AYCrqyusra0VLSgo6K3P17BhQ6xduxaHDh3CsmXLEBkZiebNmyM5Ofm9sd68eRNTp05F69at4eHhAScnJ9SuXRsDBw7E5s2b35l8vAuHBqhEhYaeBADUqlUTDg4OIkdDRPQauUyp7v0C5wOIjo6GlZWV4mFTU9O3Hu7r66u4Xbt2bTRs2BBubm7Ytm0bhgwZ8tZzLl++jAkTJuD06dNo2rQpGjZsiO7du6NUqVJISEjA9evX8e2332LUqFGYMGECxowZU+jzvw0TASpRnB9ARPrAysqqQCJQVGXKlEGVKlUUJdjfxs/PD9988w3++OOPd+7VcvbsWSxcuBBz587F5MmTixwDEwEqUSEvCwlxfgARaSOxKwumpKTg3r17GDBgQKHH3L59G8bGxu+9VuPGjdG4cWNkZ2cXKwbOEaAS8++//+L27TswMDBAixbNxQ6HiOgN+QWFVGnF8fXXX+PkyZN48OABzpw5g+7du8PQ0BB9+vQp9JyiJAGqHM9EgEpMyMvVAvXr1+PWw0REyPsDqU+fPqhatSo++eQT2NnZ4dy5c0WaQ5Weno7Tp0/jxo0bb/wsIyMD69evVyomDg1QiWFZYSLSdq/O/Ffu/OJVFNqyZYtSz3P79m20a9cOUVFRkMlkaNasGbZs2QInJycAQGJiIgYNGgR/f/9iX5s9AlQiBEHAnj37AACtOVGQiLSUpocGlDVx4kTUrFkT8fHxiIiIQOnSpdG0aVO11CBgjwCViMOHj+D58+cAgA8+8BA5GiKitxN7smBRnTlzBseOHYO9vT3s7e2xb98+fPnll2jevDlCQkJgYWGh9LXZI0AlYuXK1QCAcuXKwd3dXeRoiEiTXrx4gXv37okdhk5JT08vsCeBTCbDsmXL0LlzZ7Rs2RK3b99W+tpMBEjtnj59igPBBwEAW7dtFjkaItKU+/fvY/TocXB1qYQvho8UO5wiye8RUKVpgqenJy5duvTG44sXL0bXrl3RpUsXpa/NRIDUbsWK35CRkYF69bzQvHkzscMhohJ25sxZ9OrZG1UqV8eiXxYjNTUVcXFxSElJETu09xIEFecIaCgR6N69O37//fe3/mzx4sXo06dPsScu5mMiQGqVlZWFpUuWAwDGjP0KMplm/ichIs3KycnB9u1/oEnj5mjWtCV27NgFuVyO9u3b4fCRAwi/EgZLS0uxw9QZgYGBOHDgQKE/X7p0KeRyuVLX5mRBUqtt27bj8ePHcHJywief9BI7HCJSs+TkZKxatQa/LFyMBw8eAABMTEzQr39fjB37FWrWrClugMWk6eWD2oiJAKmNIAhYMP8XAMCXI4bDxMRE5IiISF2ioqKwaNFS/PbrSiQlJQEA7Ozs8MWXn2PEiC9Qrlw5kSNUjqpLADW1fDBfRkYGFi1ahJCQEMTHx7/RC3D58uViX5OJAKnN6dN/4fLlv2FmZobPPx8mdjhEpAaXLoVh/rwF2LbtD+Tm5gIAqlatgrHjxmDAgH4oVaqUyBHqlyFDhuDIkSPo2bMnGjRooJbhVyYCpDYL5i8EAPQf0A/29vYiR0NEysrNzcX+/cGYN3cBTp06rXjcx6cVxo0fA1/fDjAw0I0pZlKpI5Bv//79OHDgAJo2baq2azIRILW4f/8+du/eCwAYM2aUyNEQkTJSU1Oxdu16LFywSLEtrpGREfr06Y0xY7+Cl5eXyBGqn9QSgfLly6N06dJqvSYTAVKLRYuWQhAEtG/fDtWrVxc7HCIqhkePHmHx4qVYsfw3RUXQMmXK4PPhwzBy5JcoX768yBGWHEGu2ji/oNxEfaXNnTsXEydOxPLly+Hm5qaWazIRIJXFxsbit19/AwCMZm8AkWRcuXIF8+ctxO+/b1XsYe/h4YHRY0YhIMCfy/+0kLe3NzIyMuDu7g5zc/M3thxOSEgo9jWZCJDKvhg+Emlp6bCyskL79u3EDoeI3kEul+PQocOYP28hjh8/oXi8WbOmGDtuNLp06QxDQ0MRI9QsqQ0N9OnTBzExMZg1axbKlSvHyYIkvvT0dMWXSecunVhAiEhLpaenY+PGzVgwfyFu3rwFADA0NETPnj0wdtwYNGjwocgRikP1OgKanTR55swZnD17FnXq1FHbNZkIkEpWrVqDlNRUOJcvj8WLF4odDhG9Jj4+HkuXLseypSvw5MkTAEDp0qUx7LOhGDXqS7WNM5NmeHp6Ij09Xa3XZCJASsvMzMScOT8DAL79dhKsra1FjoiI8t24cQPz5i3Epo2bkZmZCQBwc3PDV6NHYsiQQbCyshI5Qu0gF2SQq9C9r8q5ypg9ezbGjx+PmTNnolatWm/MEVDmvysTAVLamjXrEBMTg/Lly2Pw4ACxwyHSe4Ig4PjxE5g3dwEOHTqseLxBgw8xbvwY9OjRvcBWtgRAxcqC0HBlwQ4dOgAA2rRpU+BxQRAgk8kURZ+Kg58IUkpWVhZmz/4JADBhwniYmpqKHBGRfhIEARkZGdi2bTvmz1uIq1evAcjbr757964YO24MmjRpzPk7OuLEiRNq/2/JRICUsn79RkRFRcHR0RFDhw4WOxwivZScnIzu3XrizJmzyMjIAABYWFhg0OAAjB49Eh4eHiJHqP2ksmpg9erV6NKlC1q1aqX2a+tGjUjSqOzsbAQFzQEAfPPNONYaJxLJokVLcOJECDIyMmBra4ug2TMRFX0fv/wyn0lAEeUnAqo0Tdi4cSNcXFzQpEkTzJkzBzdv3lTbtZkIULFt2vQ7IiMfoGzZstxciEgkK1euxpRvvwcA9PDrjkePozBx4jewsbEROTIqCSdOnMDjx4/x5ZdfIiwsDA0bNkTlypUxfvx4/Pnnn2/sQlgcTASoWDIyMvDDD7MAAOPHj4G5ubnIERHpny1btuLzz74AAIz/ehy2b9/Cbb+VJJUeAQCwsbFB//79sW3bNjx9+hSLFi1Ceno6+vXrh7Jly8Lf3x9//PEHUlNTi3VdJgJULGPHfo379yNhbm6OL774XOxwiPTOvn374T9gEARBwGefD8OPPwZxIqAK5IKByk0MJiYm6NChA5YuXYro6GgcOnQIFStWxIwZMzBv3rxiXYuTBanI5HI5Nm/eAiCvHCnrkBNp1okTIfikVx/k5OSgX78+WLp0EZMAFQmCassHNdUjEBISgqZNmxba8+Pt7Q1vb2/873//U+wbUVRMBKjIdu3ag+TkZFhYWGDlyhVih0OkV86ePYeuXXogMzMTXbt2xuo1K2FgwE5dfdGmTRuYmZmhUaNG8PHxgY+PDxo1avTWuhCvFxl6H36KqEgEQcCsWbMBAGPHjoaLi+5uS0qkbcLDw9Hx4y5ITU1F27Zt8PuWTcX+sqe3k8ocgcjISCxZsgQVKlTAqlWr0KJFC5QpUwbt27fH7Nmzcf78eaUnDMoEQRDUHK9OSUpKgrW1NRITE/W6JOeBAwfRqVM3WFhY4MGDO7CzsxM7JCK9EBERgRbNW+PJkydo0qQxDh85AAsLC7HDKlGa+N7Nf44zrVvBUoVqiyk5OWhyIlTjvyPu37+P0NBQhIaG4uTJk/j3339RunRpvHjxotjX4tAAvVdeb0Be3YDhwz9jEkCkIQ8ePMBHbX3x5MkTeHnVxf7gPTqfBFDRuLu7w9DQEDKZDDKZDLt370ZWVpZS12IiQO918uSfOHPmLExNTTFu3GixwyHSC48ePULbNh3w77//olo1Txw6HIwyZcqIHZbOkdKmQ1FRUQgNDUVISAhCQ0Px9OlTNGnSBM2bN8f+/fvRsGFDpa7LRIDeK39uwODBAXBychI5GiLd9/TpU7T7yBf3799HpUqVcOToQTg4OIgdlk6SSolhd3d3PH/+HE2bNkWLFi3w+eefw9vbWy2bSHGyIL3T9u1/4NixEzAyMsKECePFDodI5yUlJcG3QyfcuHETzs7OOHrsIMqX5+RcfZeeng4AMDAwgJGREYyNjWFoaKiWa7NHgN7pq6/GAgA+/NAbbm5uIkdDpNvS0tLQuVM3hIVdhr29PY4eOwh3d3exw9JpUukRePz4MW7duqUYGvjxxx+RkZGBZs2aoVWrVmjZsiXq16+v1JJSJgJUqHPnziMuLh4A8P3334ocDZFuy8zMRI/uvXDq1GlYW1vj8JFgVKtWTeywdJ6U5gh4enrC09MTw4cPBwDcvHlTMV/ghx9+AAClVg2oNDSQmZmpyumk5fJ3GOzevSvat28ncjREuisnJwf9+g7AkSNHYW5ujv3Be+Dl5SV2WKTF4uLicPXqVVy9ehVXrlxBUlKS0r+Ti9UjcPDgQWzZsgWnTp1CdHQ05HI5LCws4OXlhXbt2mHQoEFwdnZWKhDSLmFhl7FvXzAMDAwQFPSD2OEQ6Sy5XI4hg4dh587dMDExwe49O9C0aROxw9IbgqBa976mKvHEx8cr6gaEhITg9u3bMDY2RoMGDfDpp5/Cx8cHjRs3VuraRUoEdu3ahYkTJyI5ORkff/wxJk6cCGdnZ5QqVQoJCQm4fv06jh07hhkzZiAgIAAzZszgDFeJ+9//8n759+vXB1WqVBE5GiLdJAgCRo0agw0bNsHQ0BBbt21G27ZtxA5Lr0hljoCjoyOMjY3h7e0NPz8/+Pj4oEmTJihVqpTK1y5SIvDjjz9i/vz58PX1fetEhE8++QQAEBMTg0WLFmHjxo0YO3asysGROF7tDfj220lih0OksyZPnoJlS5dDJpNh7bpV6Nq1i9gh6R1BxTkCqiQCs2fPRmBgIEaPHo0FCxa889iDBw+iWbNmJVJQqkiJwNmzZ4t0sfLly2P27NkqBUTiY28AUcmbNWs25sz+CQCwbPkS9OvXV+SISJMuXryIFStWoHbt2kU6vn379iUWC+sIUAHsDSAqeYsWLcGUb78HAPz08xx89tlQkSPSX2JsOpSSkoJ+/frht99+g42NzXuP79ChA86dO/fe45KTkzFnzhwsWbKkWPEUe/mgIAj4448/EBISgvj4+Dd2O9q5c2dxL1kkXbp0QXh4OOLj42FjY4O2bdtizpw575yc2KpVK5w8ebLAY59//jmWL19eIjHqAn//QQDYG0BUUtauXY/RL+tzfPf9txg/nsOoYhJjjsCIESPQsWNHtG3bVrHs71169eoFPz8/WFtbo3PnzvD29oazszPMzMzw/Plz3LhxA6dPn8aBAwfQsWNH/PTTT8WKp9iJwJgxY7BixQr4+PigXLlykMk0M1HCx8cHkydPhpOTE2JiYvD111+jZ8+eOHPmzDvPGzZsGP73v/8p7pubm5d0qJK1adPvuHnzFgBg2LAhIkdDpHv++GMHhg75DAAwesxXmDbte5EjInVJSkoqcN/U1BSmpqZvHLdlyxZcvnwZFy9eLPK1hwwZgv79+2P79u3YunUrfv31VyQmJgIAZDIZqlevjvbt2+PixYtK1Z4odiKwYcMG7Ny5Ex9//HGxn0wVr04+dHNzw6RJk9CtWzdkZ2e/c19uc3NzODo6aiJEyVu3bj0AwN29Epo1aypyNES65cCBg+jX1z9vueDQwZg37yeN/SFFhVNXQSFXV9cCj0+dOhXTpk0r8Fh0dDRGjx6No0ePwszMrFjPY2pqiv79+6N///4AgMTERKSnp8POzu6dvwOLotiJgLW1teglLxMSErBp0yY0adLkvW/Apk2bsHHjRjg6OqJz58747rvv3tkrkJmZWaAow+tZnq66evUajh078XI7yz/EDodIp5w8+Sd6+vVGdnY2evfuheXLlzAJ0BLqGhqIjo6GlZWV4vG39QaEhYUhPj4e9erVUzyWm5uLP//8E4sXL0ZmZmaR9w+wtraGtbW10nG/qtiTBadNm4bp06crNkDQpIkTJ8LCwgJ2dnaIiorCnj173nl83759sXHjRoSEhCAwMBAbNmxQZFOFCQoKUrzB1tbWb2R5umrmzCAAwCef9ETNmjVFjoZId1y4cBGdO3VDRkYGOnX6GOs3rFXbZjGkPaysrAq0tyUCbdq0wbVr1xAeHq5o3t7e6NevH8LDw0X7XMgEoXh1kdLT09G9e3f89ddfqFix4ht/kV++fLnI15o0aRLmzJnzzmNu3rwJT09PAHlbcyYkJODhw4eYPn06rK2tsX///iJn1idOnECbNm1w9+5deHh4vPWYt/UIuLq6IjExsUC2p0v++ecGateuB0EQcOVKGGrVYiJApA7Xrl1Dq5Zt8fz5c7Ru7YP9wXuK3SWsj5KSkmBtbV2i37v5z3GgQUdYGCnftZ6ak42PLwQrHWurVq1Qt27d99YRKEnFHhoYOHAgwsLC0L9/f5UnC44fPx4BAQHvPObVYQh7e3vY29ujSpUqqFatGlxdXXHu3Lkil1Vs2LAhALwzEShsgocumzVrNgRBQI8e3ZgEEKnJnTt30O6jj/H8+XM0atQQu/fsYBKghQTIIECFoQEVztUWxU4EgoODcfjwYTRr1kzlJ3dwcFC6FHH+ssXibLIQHh4OAHByclLqOXVRREQEtm7dDgCYMmWyyNEQ6YaoqCh81NYXcXFxqFOnNoIP7IWlpaXYYZEWCg0NFTuE4s8RcHV11XgX+fnz57F48WKEh4fj4cOHOHHiBPr06QMPDw9Fb0BMTAw8PT1x4cIFAMC9e/cwY8YMhIWF4cGDB9i7dy/8/f3RokWLIldy0gczZ86BXC5H584dUbduHbHDIZK8uLg4fNS2A6KiolC1ahUcPnKgSEVjSBxiFBRSRUhISKE/W7FihVLXLHYiMHfuXEyYMAEPHjxQ6gmVYW5ujp07d6JNmzaoWrUqhgwZgtq1a+PkyZOKbvzs7GxEREQgLS0NAGBiYoJjx46hXbt28PT0xPjx4+Hn54d9+/ZpLG5td+JEKDZu3AQA+PbbQJGjIZK+EydC0LhRc9y5cxdubm44cvQgypYtK3ZY9A75ywdVaZrUoUMHfPPNN8jOzlY89vTpU3Tu3BmTJilXDbbYkwVtbGyQlpaGnJwcmJubvzFZMCEhQalAtJUmJq2IpU4db1y7dg0ODg6Ii/tX7HCIJC07OxuO5Vzw/PlzWFhY4O/wi/jggw/EDkuSNDlZcE/9ripPFuwatkdjvyPOnDkDf39/WFpaYvPmzYiMjMSQIUNQtWpVrF+/Hm5ubsW+ZrHnCIg5s5HUJzo6GjdvRgCQYdasGWKHQyR5iYmJiroj6zesYRJAJaJJkyYIDw/H8OHDUa9ePcjlcsyYMQMTJkxQevK+UqsGSPp+/nkBcnJy0KpVSwwZMkjscIgkb9Om35Gbm4s6dWqje/duYodDRSSHipUFRVg1cPv2bVy6dAkuLi549OiRYlhc2S2KizRHIDU1tVgXLe7xpFnx8fFYuXINAGDy5IkiR0OkG9auWQcAGMp9OiRFapMFZ8+ejcaNG+Ojjz7C9evXceHCBfz999+oXbs2zp49q9Q1i5QIfPDBB5g9ezYeP35c6DGCIODo0aPw9fXFL7/8olQwpBnz5y9Ceno6GjTwRps2PmKHQyR5f//9N65cuQoTExP06dNb7HBIhy1cuBC7d+/GokWLYGZmhpo1a+LChQvo0aMHWrVqpdQ1izQ0EBoaismTJ2PatGmoU6fOW7dAPHv2LIyMjBAYGIjPP/9cqWCo5D1//hxLl+YtMZk8eSLrnROpwZo1eRt2de/eFba2tiJHQ8Uhh0yl7n1NDw1cu3YN9vb2BR4zNjbGTz/9hE6dOil1zSIlAlWrVsWOHTsQFRWF7du349SpUzhz5gzS09Nhb28PLy8v/Pbbb/D19WUNbS23aNEyJCcno3btWujUSbM7SBLposzMTGze9DsAIGAQ51BJjqrd+xoeGng9CXhVy5YtlbpmsSYLVqhQAePHj8f48eOVejIS19P4BCxcsBgAEBj4DQwMil1Ggohes3fvPiQkJMDFxQVt27YROxzScT4+Pu/syT1x4kSxr1nsVQMkXeM+m4LnL57DycEZPXv2EDscIp2w9uWwwAD/fuwRlSBViwJpuqBQ3bp1C9zPzs5GeHg4rl+/rvSqPiYCeiI9NRPHj4YCAD7twi8sInWIiYnB4cNHAAABAf4iR0PKUHXmv6ZXDcyfP/+tj0+bNg0pKSlKXZN9w3pi/8pTqCa0QFu3T/DDQm4uRKQOGzZsglwuR7NmTVG5cmWxwyE91r9/f6xevVqpc9kjoAfSUzOxbf4RyGQyjJv+OUqZcytUIlUJgqCoHcBJgtIlf9lUOV8bnD17VultrpkI6IH9K0/hxZNkOFWyR9s+DcUOh0gnnD17Drdv34G5uTl69fITOxxSktSGBnr0KDi/SxAEPH78GJcuXcJ3332n1DWLPDTQpk0b7Ny5s9CfP336FO7u7koFQSUnvzcAAPpO8IWRMecGEKnDmpe9Ab16+aF06dIiR0PKkguq7kCo2Xitra0LNFtbW7Rq1QoHDhzA1KlTlbpmkXsEQkJCcPLkSXz77beYPn36Gz/Pzc3Fw4cPlQqCSg57A4jULzU1Fdu2bgfAYQHSrDVr1qj9msWaLLhs2TIsWLAA3bt3534CEsDeAKKSsWPHTiQnJ8Pd3R0tWjQXOxxSgQCZyk3qijVHoGvXrmjWrBm6du2KRo0aYc+ePRwO0GIbvv2DvQFEJSC/dkDAIH+W6ZY4KdQRsLGxKfLnLCEhodjXL/ZkwWrVquHixYvo06cPPvzwQ2zduhVt27Yt9hNTyUp+moy9q/8CAHzc25u9AURqcv/+fYSGnoRMJsPAgQPEDof0wIIFC0r0+kqtGrC2tkZwcDACAwPx8ccfY86cOejbt6+6YyMVXNhwEhaGAoyMDNDja1+xwyHSGevWbQAAtG3bBq6uriJHQ6rKmyyo2vklTdmKgUVV5DkCr3dLyGQyzJ49G+vXr8d3332HoUOHqj04Uk5uVg7u7TyLBnYyTJjdDSalTMQOiUgnyOVyrF+3EUDesABJn1TmCHz//fdIS0tT3H/+/Lnarl3kREAQ3p72fPrppzh9+jSuXbumtqBINTf3XUTy4+ewcLBCg4GtxA6HSGeEhITi4cOHsLa2RrduXcUOh/TIzJkzC5QQdnNzw/3799Vy7WItHyxsn+26desiLCwMwcHBagmKlCfPlePCiryVAvWHtIGRqbHIERHpjvxKgp/26Y1SpUqJHA2pgxQmCwJv/jFe2B/nyihyIvC+fY7t7Ozg78+uMrHdPRKO5/fjYGZtjjqfclkTkbokJiZix45dAIBBrB2gMwQhr6lyvtSxxLAOEQQB55cdBgB4+beCiSX3FCBSly1btiEjIwPVq1fDhx96ix0O6RmZTIbk5GSYmZlBEATIZDKkpKQgKSmpwHFWVlbFvjYTAR3y4M8biL8RDWNzU3j5txI7HCKd8uoGQ6wdoDsEyCBXYcKfpiYLCoKAKlWqFLjv5eVV4L5MJkNubm6xr81EQIecX57XG1C7TzOUsrEUORoi3XHz5k2cP38BhoaG6N+fS6V1iVQ2HQoJCSmxazMR0BHRp84j5uJdGBobwXtwG7HDIdIp+RsMffxxBzg6OoocDamTVCYLvm+eniqKtdcAaa/zc1YAAKq3d4VluTLiBqPjkpOTkZ6eLnYYpCE5OTnYuGEzAGDQ4ABxgyEqAewR0AFpd07j6b+5kMnk+HBoa7HDkaysrCzEx8cjNjYOsbGxin/HxcUj7pX7d+/eAwDUq+cFd/dKqOReCe7u7qhUqSLc3SuhQoUKMDFhESddcejQYcTGxsLBwQEdO34sdjikZsLLpsr5UsdEQAeY3PwZAwceQaxxf9jUrC92OFovIyMDBw4cROCkb/H06TM4OTkiNjau2Jt1XL78Ny5f/vuNxw0MDODi4vJKklDpZZLgDnf3SnBwcOBkMwnJnyTYr39fGBuzLoeukcrQQEliIiBx8tiLEB4egpGxISr2nyh2OForNjYWwcEHEbw/GEePHi+wjfarpTqNjIxQrlw5ODqWg6OjI8o55t1+9bHSpUsjMzMDsbFxePDgIe7fj0Tk/fuIjHyA+/cjkZ6ejqioKERFRSE09OQbsVhYWKBSpYqwsbHBkydP4O8/ABMnfcPkQAs9efIE+/blFUobxJLCpKOYCEic/MJMAIDMsy9kZTxEjkZ7CIKAK1euYN++YATvP4ALFy4W+LmzszMqVnRDo8YN0bq1D9zcKsDR0RE2NjYwMFB+6owgCIiLi3uZFNzPSxIiHyDyfiTu34/Ev//+i9TUVFy//o/inMmTp2DNmrUYPGQQBg4cwMloWmTTpt+RnZ2N+vXroVatWmKHQyVA/rKpcr4mDR48GAsXLkTp0qULPJ6amopRo0Zh9erVxb6mTFBnnUIdlJSUBGtrayQmJipVqKEkyWMvInd7c0BmCKP+V/U+EUhPT8eJEyHYv/8AgvcfwL///lvg597e9dGpc0d06tQRXl51RfkLPDMzE1FRUbh/PxKhISdx4MAh3LlzBxkZGQAAQ0NDdOr0MQYPGQRf3w4wMmKuLhZBEOBV1xtXr17DosULMWLEF2KHpDc08b2b/xwLKw9EKUPl5/Sk52Zh9J11GvsdYWhoiMePH6Ns2bIFHn/69CkcHR2Rk5NT7GvyW0bC9L03IDs7G2fPnkNExG3s37cfx46dKDCb39zcHB991AYdO3VEx46+cHJyEjHaPKampqhcuTIqV66M9u3bIWh23kYi27b9gVUrV+Ps2XPYs2cf9uzZBycnJwwMGIDBgwPwwQcfiB263vn773BcvXoNJiYm6NOnt9jhkJ5LSkqCIAgQBEFRYTBfbm4uDhw48EZyUFRMBCQqf24AZIYw9J4kdjgal5ubCxeXioiPjwcAyF5W93J1dUXHTh+jc+eOaNWqpSQ2hrG0tMTgwQEYPDgAN27cwKpVa7Fh/UY8fvwYs4N+xOygH9GqVUsMGToIPXp0l8Rr0gX5tQO6detS6IZrJH1SmSxYpkwZyGQyyGSyAhUG88lkMkyfPl2pazMRkKjE/RNhCf3sDRAEAV99NUaRBFStUgX9B/RD584dUbt2bUlPuqtevTrmzv0RQUE/YO/efVi9ai0OHz6C0NCTCA09iVFlxqBvvz4YOnQQ6tatK3a4OiszMxO/b94CIK+kMOkuqSwfDAkJgSAIaN26NXbs2FEgOTUxMYGbmxucnZ2VujbnCLyHNs4RiD21D3bhvSCXyyDrfRkmjtXEDkmjvv32O8yaNRsymQxLly7C8OGfix1SiYqKisLateuxZvU6PHz4UPF4vXpeGDJ0MPz8unNJoppt3/4Hen/SF+XLl8eDh3dhaGgodkh6RZNzBOZ9EKDyHIFxd9cWOdZly5Zh2bJlePDgAQCgRo0a+P777+Hr61uk53v48CFcXV1VmtT8OlYWlKDrf4Qg4UVp/JvaWO+SgB9//BmzZs0GACxbtljnkwAAqFChAr7/fgru3Y/A4SMH8MknPWFiYoLLl//GiC9HobyzG9wrVcbVq9fEDlVnTPgmb7itVy8/JgE6Ln9oQJVWHC4uLpg9ezbCwsJw6dIltG7dGl27dsU///zz/pMBuLm5wcDAAGlpabh16xauXr1aoCmDQwMSE3vrEU7uysFpw94YefArscPRqBUrfsXEiYEAgDlzgvD555+JHJFmGRgY4KOP2uKjj9ri6dOn2LhxM5YuWYa7d+/h4cModO/mh917dnCZm4oePnyIhw+jAAC9e/cSORoqaZpePti5c+cC92fOnIlly5bh3LlzqFGjxnvPf/LkCQYNGoSDBw++9efK7D7IHgGJ+XPxEQCAZ4d6sPd8c8KIrvr99y344ouRAIDAwImYMOFrkSMSl729PcaM+QoRt2/g19+Ww9raGpGRD9CoYTOsW7de7PAkTSb772uxvjcrdeq6/N0HVWlA3lDDqy0zM/O9z52bm4stW7YgNTUVjRs3LlK8Y8aMwYsXL3D+/HmUKlUKhw4dwrp161C5cmXs3btXqfeAiYCEPIuMx/X9eSVtW45qL3I0mrN/fzD8/QdBEAR8+eVwzJw5Q+yQtIZMJsPQoYNx5+5NtG/fDunp6RgUMBRDh37OjZGUlJ2dBSBvNQfrOFBRubq6wtraWtGCgoIKPfbatWuwtLSEqakphg8fjl27dqF69epFep4TJ05g3rx58Pb2hoGBAdzc3NC/f3/8+OOP73zOd2EiICF/Lj0GQS6gapsacKpeXuxwNCI09CR69foUOTk56N+/LxYtWshJcW9hb2+P4AN7Mf1/UyGTybB61Ro0adwcd+/eFTs0yXnxIhFA3nIt0n0C/hseUKblz7aPjo5GYmKiogUGBhb6nFWrVkV4eDjOnz+PL774AgMHDsSNGzeKFG9qaqqiXkB+mXIAqFWrFi5fvlys156PiYBEvPg3AeE7LgAAWo5qJ3I0mnHx4kV07twNGRkZ6NKlM1avXqnWmbK6xsDAAN999y0OHzkABwcHXLlyFd71G2Hnzl1ihyYpL168AACUKWMtbiCkEQJUHBp4WcPEysqqQDM1NS30OU1MTPDBBx+gfv36CAoKQp06dbBw4cIixVu1alVEREQAAOrUqYMVK1YgJiYGy5cvV7poGr9VJeL0iuOQ58jh3qQKXOtVEjucEvfPP/+gQ4dOSElJgY9PK2zdupk7vxVR27ZtcPnvC2jWrCmSkpLQ0683xo37BtnZ2WKHJgn/JQJlRI2D9IdcLi/SnAIAGD16NB4/fgwAmDp1Kg4ePIgKFSrgl19+waxZs5R6fg6AScC963dxbsMpyAC0/Er3ewPu37+Pjz7yRUJCAho2bIA9e3YWKKdJ71e+fHkcP3EEkyd/h7k/z8OC+Qtx4fwFbNm6CS4uLmKHp9X+Gxpgj4A+kAt5TZXziyMwMBC+vr6oUKECkpOTsXnzZoSGhuLw4cNFOr9///6K2/Xr18fDhw9x69YtVKhQAfb29sUL5iX2CEjAynHLIJMDSaZpqNS4stjhlKiYmBi0bdsBjx8/Rs2aNXDgwL43dtmiojE2NsZPP83Grt1/wNraGmfOnEU9rwY4cuSo2KFptfxtqdkjoB8ENbTiiI+Ph7+/P6pWrYo2bdrg4sWLOHz4MD766KNiXScrKwsREREwMTFBvXr1lE4CACYCWu/Zs2fYc/EgojIfo8HQ5jo9Ue7p06do1+5jREZGwsPDA0eOHGSNdzXo2rULwi6fh5dXXTx9+hS+HTph2rT/KbXeWB/kDw1YMxGgErBq1So8ePAAmZmZiI+Px7Fjx4qVBKSlpWHIkCEwNzdHjRo1EBWVV/Ni1KhRmD17tlIxMRHQcr/8sgS3Eu/huksU+nwzQOxwSkxSUhJ8fTvhxo0bKF++PI4dO6QVuwXqCnd3d/x15k989vkwCIKA/03/Ab4dOilmHNN/ODSgXzRdWVBVgYGBuHLlCkJDQwsMmbZt2xZbt25V6ppMBLRYUlISFi1aAiCviI6uzphPT09Hly7dcelSGOzt7XH06EFUrFhR7LB0jpmZGZYvX4L1G9bA3Nwcx44dRz2vBvjrrzNih6ZVEjlZUK+osnRQ1aqEyti9ezcWL16MZs2aFeghrlGjBu7du6fUNXXzN4uOWLp0BV68eAFPz6ro0aOb2OGUiKysLPTq9SlOnvwTVlZWOHw4GNWq6df+CZrWv38/nL/wFzw9qyImJgatWrbB3Lnzwf3H8rCOAGmzJ0+eKOoIvCo1NVXpoWMmAloqLS0N8+fnrSudNGmCTvYG5Obmwt9/EIKDD8DMzAz79+9BvXr1xA5LL9SoUQMXLp5Fnz69kZubi2++noiefp8oxsf1Wf57YGNTRtQ4SDPUVWJYU7y9vREcHKy4n//Lf+XKlUUuU/w6Lh/UUitXrsaTJ09QsaIb+vTpLXY4apdXLngktm7dBmNjY+zcuR3NmzcTOyy9YmlpiY2b1qNZ82YYO2Y8du3ag0OHjmDZ8iXw9+///gvoKNYR0C+a3nRIVbNmzYKvry9u3LiBnJwcLFy4EDdu3MCZM2dw8uRJpa6pe39m6oDMzEz89NM8AMDEid/oXCEdQRAwcWIgfv01r1Lgpk3r4evbQeyw9JJMJsMXX3yO03+dhKWlJdLT0zH88y/1ep8CDg3oF0FQvWlSs2bNEB4ejpycHNSqVQtHjhxB2bJlcfbsWdSvr9wmWewR0EKff/4lYmJi4ODggIAAf7HDUbugoDn46ae5AIBff12GXr16ihwReXvXR/iVS6hZoy4yMjIwffoMzJ6tXJUyqfuvjgBXDZB28vDwwG+//aa267FHQMtkZmZi8+YtAIDGjRu+s161FC1ZshTffvsdAGDu3B8xZMhgkSOifO7u7tiydRMA4Oef5uH8+QsiR6R5WVlZSEtLA8AeAX0hh0zlpgmvb3NcWFMGewS0zJYtW5GTnQ2zUqXw22/LxQ5HrTZu3ISRI0cDAL7/fgrGjRsrckT0ui5dOqN//77YuHEzBgUMweW/L+pVeefExETFbSsrKxEjIU3RdIlhZZUpU+adqwIEQYBMJlOqUBgTAS2Sm5uLWTPzKkNNm/YdHBwcCvxcEATEx8ejXLlyYoSnkt279yAgYAgA4KuvRmLatO9FjogKs2DhPBw7dgK3bkVg2rT/6dUQQf5EwdKlS8PIiF+PpD1CQkIUtwVBwMcff4yVK1eifHnVt6TnJ12LbN26DXfu3IWdnR2+/HJ4gZ+dOBGCDu07AjKgbt26KFvWAQ4ODrC3t4eDgz0cHBze+LelpaVWlCQ+fvwEevfui9zcXAwcOADz58/Virjo7WxtbbF8xRJ06+qHn3+ah+7du6FhwwZih6URnCioh1Sd8KehHoGWLVsWuG9oaIhGjRrB3d1d5WszEdASubm5mPlDEABgzNivYGlpCQA4e/YcvpsyFSdO/JcNXrp4CSjiL1JDQ0NUr+YJOzs72NnZwsbWFnZ2trC1tYWdnR1sbW0U/85/zMTERG2v69y5c+jatQeysrLQo0d3rFz5q07WRNA1+jpE8N/SQU4U1BeqjvNrao5ASWIioCV27NiJmzdvoUyZMhg58kv8/fff+G7KNBw4cBBA3k5yvT/thV69ekIQBDx58vRle4KnT/P+HR//RPFYRkYGACA3JwfXrl0vViwWFhYwNy+FlJQUlC1bDk2bNob9y56GsmXLvtHzUNjY1dWrV+Hr2xmpqan46KO22Lx5A7tbJUQfhwhYQ4D0Eb+VtYBcLlf0BvTt+ymGDvkMO3bsApD3F33AoIGYMiUQbm5uRbqeIAh4/vw5rl//B48fP4aNjQ2ePXuGhITnSEhIwLNnCXj+8t959/N+9vz5c8jlcqSmpiI1NRUA8PDhQzx8+PCdz2dkZPTGEIWxsTF27dqDlNQUNGnSGLt2/aFzKyB0nT4OEXDDIf2jai0AMStzq2uIlYmAFtizZy+uXbsOIyMjLF2at1JAJpOhb99P8f3UKahcuXKxrieTyWBra4sWLZoX6zy5XI7ExEQkJCTg5o1b+Ds8HLk5OShtZYUnT/J6G56+1vOQnJyMnJwcxMbGIjY29o1rOjs5ITh4LywsLIoVC2kHfRsiYI+A/pFKZcEePXoUuJ+RkYHhw4e/8d26c+fOYl+biYDIYmJi8NmwLwAAOTk5AAA/v+6YNv171KhRQ6OxGBgYwMbGBjY2NvDw8ECnzh3fe05GRoZiaOLJk6eIj4/HkydPce3aNRw4cAiLFi/kl6rE6csQgSAIiIuLAwBY8zNLWsbaumAvVf/+6isDzkRAZEePHsOzZ88AAG3btsHsObNQr56XyFEVnZmZGVxcXODi4vLGz/LXtZK06csQQVpaGubNWwjIZLCwMBc7HNIQqdQRWLNmTYldm4mAyAYO9Mdff52FnZ2tzv2lxSRAd+jbEIG1dRmxQyANEaDaCkBd2Lyb67hEJpPJ8Ntvy3UuCSDds2DhPDg6OiqGCHRZ27atxQ6BNCSvR0CmQhP7FaiOiQARFUn+EAGg+3sRVKvmKXYIRBrDRICIiix/iEAul2NQwBBFvQoiqZLaNsQlgYkAERWLPg0RkO6Tq6FJHRMBIioWfRoiINIHTASIqNg4REC6gkMDEkwEMjMzUbduXchkMoSHh7/z2IyMDIwYMQJ2dnawtLSEn5+fomAIEamGQwSkCzg0IMFEYMKECXB2di7SsWPHjsW+ffuwfft2nDx5Eo8ePXqjTCMRKef1IYKtW7aKHBERKUNSicDBgwdx5MgR/Pzzz+89NjExEatWrcK8efPQunVr1K9fH2vWrMGZM2dw7tw5DURLpPu6dOmMjz/uALlcjv4DAjhEQJIjCP9VF1SmcWhAg+Li4jBs2DBs2LAB5ubvL/8ZFhaG7OxstG3bVvGYp6cnKlSogLNnz5ZkqER6ZeasGRAgQC6XIykpSexwiIpFUEOTOkmUGBYEAQEBARg+fDi8vb3x4MGD954TGxsLExOTNza8KVeu3Ft3ycuXmZmJzMxMxX1+sRG9m4eHB4C83SstLS1FjkZ5wit/2gm68GceURGJ2iMwadIkyGSyd7Zbt25h0aJFSE5ORmBgYInHFBQUBGtra0VzdXUt8eckkjILCwsYGxsDABISEkSORnlpaWlvvU26TZVhAVU3LNIWovYIjB8/HgEBAe88xt3dHSdOnMDZs2dhampa4Gfe3t7o168f1q1b98Z5jo6OyMrKwosXLwr0CsTFxcHR0bHQ5wsMDMS4ceMU95OSkpgMEL2DTCaDra0t4uLi8OzZs7fuREmkrVRdAqgLnUeiJgIODg5wcHB473G//PILfvjhB8X9R48eoX379ti6dSsaNmz41nPq168PY2NjHD9+HH5+fgCAiIgIREVFoXHjxoU+l6mp6RsJBxG9m52dHeLi4pCQ8FzsUJT26tyjosxDIt2g6hJAXVg+KIk5AhUqVChwP38c0sPDQ/HXR0xMDNq0aYP169ejQYMGsLa2xpAhQzBu3DjY2trCysoKo0aNQuPGjdGoUSONvwYiXWZrawMAePbsmciRKO/VbbO5hTbpE0kkAkWRnZ2NiIiIAmN78+fPh4GBAfz8/JCZmYn27dtj6dKlIkZJpJvs7OwASHuOAOknVcf5OUdAJBUrVnxjVu/bHjMzM8OSJUuwZMkSTYZHpHfyewSkPDRA+knVJYA6kAdIp44AEWkvW1tbANIeGiDSV5LsESAi7cKhAZIqDg0wESAiNfhvsiATAZIWLh/k0AARqQF7BIiKJigoCB9++CFKly6NsmXLolu3boiIiBA1JiYCRKSy/+YIMBEgadH0NsQnT57EiBEjcO7cORw9ehTZ2dlo164dUlNT1fJ6lMGhASJSmZ1dXiIg5R4B7jWgn+RQcY5AMY8/dOhQgftr165F2bJlERYWhhYtWigfiAqYCBCRyvJ7BBISEiAIgiQL8ry+14CUN1AizXt9g7qiVqlNTEwE8N//Q2Lg0AARqSz/SywrK0vULk6i4lLXNsSurq4FNqwLCgp673PL5XKMGTMGTZs2Rc2aNdX7woqBPQJEpDJzc3OYmpoiMzMTCQkJkvxrmnsN6CdBUG2/gPxRpOjoaFhZWSkeL0pvwIgRI3D9+nWcPn1ahQhUxx4BIlJZ/g6EgHSLCnGvAf2Uv3xQlQYAVlZWBdr7EoGRI0di//79CAkJEX3HTiYCRKQW/00YZJlhosIIgoCRI0di165dOHHiBCpVqiR2SBwaICL1kHqPAOknTW9DPGLECGzevBl79uxB6dKlERsbCwCwtrZGqVKlVIhEeUwEiEgtXl05QCQVcgGQq7B1UHGXHi5btgwA0KpVqwKPr1mzBgEBAUrHoQomAkSkFhwaIHo/baxRwUSAiNSCQwMkRdyGmIkAEamJ1PcbYGVB/SRXcfmgLuw+yFUDRKQWUt+BMK+yoAEAgwJVBol0HXsEiEgtOFmQpEh4+Y8q50sdEwEiUov8oQGp9giwsqB+4tAAhwaISE3yhwak2iPAyoKkr9gjQERq8epkQanuQEj6R9MFhbQREwEiUov8OQI5OTlITk4usAELkbYSBBXnCOjAChMODRCRWpQqVUpRIlWqwwOkf+RqaFLHRICI1IZFhYikh4kAEanNfxMGpVdmWBAEyGAIGQx1oruXikYQBJWb1HGOABGpzX9LCKXXI5CRloUa5l0Uty0tRQ6INEKAat370k8D2CNARGrEokJE0sMeASJSm/wdCKVYVKiUeam33ibdJhcEFbchln6fABMBIlIbKfcIsKCQfmKJYQ4NEJEaSTkRINJX7BEgIrWR8tAA6SdWFmQiQERqxB4Bkho5VJwjwKEBIqL/SH0HQiJ9xB4BIlIbqe9ASPqHqwaYCBCRGr26A6FcLoeBgXQ6HfMqC/53m/QDVw0wESAiNbKxyesRkMvlSEpKQpkyZcQNqBgy07PhZmCnuG1hyVoC+oBzBDhHgIjU6NVegLCwyyJHQ0RFwUSAiNQmNTUVhoaGAIA+fQbgzp07IkdUdKVKmbz1Num2/B4BVZrUMREgIrVxcHDAmTOn4OnpiSdPnsDHp51kkgFWFtRPghr+kTomAkSkVt7e9XHy5HHUrFkDjx49klQyQKSPmAgQkdqVLVsWx48fRo0a1ZkMkFYTVBwWYI8AEVEhmAyQFMhlcpWb1DERIKISw2SASPsxESCiEsVkgLQZVw0wESAiDZBGMiDA1NwApuYGgA58uVPRqJ4GcGiAiKhItD8ZyMWW2AbYEtsAQK7YwRBpDBMBItIY7U8GSN/IoerwgPQxESAijdLWZMDE3OStt0m3cdUAEwEiEoE2JgOsLKif5Gr4R+qYCBCRKLQxGSDSR0wEiEg0TAZIbOwRYCJARCJjMkBi4vJBJgJEpAWYDJC++PPPP9G5c2c4OztDJpNh9+7dYofERICItIPYyYAgCEhPzUV6ai4EgQWF9IWmVw2kpqaiTp06WLJkSQm9ouIzEjsAIqJ8+clAmzbt8c8/N+Dj0w4hIUdQuXLlEn/ujLQsdHA4BQA48sQP5hbGJf6cJD5BxXH+4g4N+Pr6wtfXV+nnKwnsESAirSJ2zwCRMpKSkgq0zMxMsUMqMiYCRKR1xEkGDAu5TbpMQK7KDQBcXV1hbW2taEFBQSK/sqLj0AARaSVNDxPIIHvrbdJt8pdFhlU7H4iOjoaVlZXicVNTU1VD0xj2CBCR1uIwAUmFlZVVgcZEgIhITV5PBlq0aIP9+w+IHRbpCLliuqCy/0h/hQkTASLSevnJwAcfeCAuLg7duvnhzz9PiR0W6QB1zREoqpSUFISHhyM8PBwAEBkZifDwcERFRZXAqysaJgJEJAlly5ZFcPAemJqaQi6XY/jwEUhKShI7LJI4TZcYvnTpEry8vODl5QUAGDduHLy8vPD999+XxMsrEiYCRCQZlStXxunToXBwcMCtWxH45JM+yM7OFjssoiJr1aoVBEF4o61du1a0mJgIEJGk1K9fDwcO7IW5uTmOHDmGL7/8Si2VAAVBQK6QjVwhm5UF9Qj3GmAiQEQSVL9+Pfz++wYYGBhg1arVmD37J5WvmZaWhvMZm3E+YzPS0tLUECVJgRy5KjepYyJARJLUuXMnLFw4DwDw7bff4ffft4ocEZE0MREgIskaMeILjB07GgAwaNBQnDp1WulrmZmbvPU26TYODTARICKJ++mn2ejRoxuysrLQvXsvREREKHUdmUz21tuk2+RCrspN6pgIEJGkGRgYYP36NWjYsAESEhLQsWNXPHnyROywiCSDiQARSZ65uTn27NmBSpUq4v79SHTt6of09HSxwyIJ4NCABBOBzMxM1K1bFzKZTFGZqTCtWrWCTCYr0IYPH66ZQIlIo/ILDtnY2ODcufPw9x8EuVz6X9JUsvJ+matSWVD6nzHJJQITJkyAs7NzkY8fNmwYHj9+rGg//vhjCUZHRGLy9PTErl3bYWJigh07dmHChECxQyLSepJKBA4ePIgjR47g559/LvI55ubmcHR0VLRXt4kkIt3TokVzrF79GwBg3rwFWLJkmcgRkTYTBDnkKjRBYI+AxsTFxWHYsGHYsGEDzM3Ni3zepk2bYG9vj5o1ayIwMJCFQoj0QN++n2LGjOkAgNGjx2H//uD3nvNqNUFWFtQfnCMAGIkdQFEIgoCAgAAMHz4c3t7eePDgQZHO69u3L9zc3ODs7IyrV69i4sSJiIiIwM6dOws9JzMzE5mZmYr73NSESJomT56IyMgHWL16DT79tD9OnjyO+vXrFXr8q38kpKWlwdLSUhNhksgEFZf/qXq+NhA1EZg0aRLmzJnzzmNu3ryJI0eOIDk5GYGBxRvv++yzzxS3a9WqBScnJ7Rp0wb37t2Dh4fHW88JCgrC9OnTi/U8RKR9ZDIZli1bhOjoKBw9ehydO3fHuXOnUKFCBbFDI9IqMkHEPrAnT57g2bNn7zzG3d0dn3zyCfbt21egyEdubi4MDQ3Rr18/rFu3rkjPl5qaCktLSxw6dAjt27d/6zFv6xFwdXVFYmIi5xcQSVBiYiJatGiNa9euo0aN6jh9OhTW1tZvHJeSkgKr0rYAgKTkBPYIiCgpKQnW1tYl+r2b/xylzTwhkxkqfR1ByEVyxi1J/44QtUfAwcEBDg4O7z3ul19+wQ8//KC4/+jRI7Rv3x5bt25Fw4YNi/x8+csNnZycCj3G1NQUpqamRb4mEWk3a2tr7N+/G40aNcc//9xAz569ERy8FyYmBcsIs7Kgfsqb7Kf8f29OFtSQChUqoGbNmopWpUoVAICHhwdcXFwAADExMfD09MSFCxcAAPfu3cOMGTMQFhaGBw8eYO/evfD390eLFi1Qu3Zt0V4LEWmeq6sr9u/fDQsLCxw/HoLhw0dyQiDRS5JIBIoiOzsbERERigk/JiYmOHbsGNq1awdPT0+MHz8efn5+2Ldvn8iREpEYvLzqYuvWTTAwMMDateswc+ZssUMiLaBaMaG8JnWizhGQAk2MVRGR5ixf/iu+/HIUAGD9+jXo378vgLw5RKUtbQAAySnPYWFhIVqM+k6TcwTMTdwhkyn/N7EgyJGWdV/SvyN0pkeAiKgohg//DF9/PQ4AMGTIZzh58k+RIyISFxMBItI7s2fPRM+ePZCdnY3u3Xvh5s2bYodEImFBISYCRKSHDAwMsG7dajRu3AgvXrxAx45dER8fL3ZYJAJByFW5SR0TASLSS6VKlcLu3X/Aw8MdDx48RO/efcUOiUgUTASISG85ODggOHgPbG1tcenSZbHDIREILzcOUqVJHRMBItJrVapUwe7df+QVEmMhIb3DOQJMBIiI0KxZU6xYsSTvjkyG5ct/FTcg0hj2CDARICICAPj59QAEARCEt+5FQKSrJLENMRFRSTM3N0dScgJu374DL6+6YodDGqJq174uDA0wESAiQt5GQ5aWlqhXz0vsUEiD8pb/KV9gl0MDREREJGnsESAiIj0mACp170t/ux4mAkREpLfyuvaVXzaqC/v2cWiAiIhIj7FHgIiI9FberH8VegQ4NEBERCRlqiUCujBHgEMDREREeow9AkREpL9UnCwIHZgsyESAiIj0FucIcGiAiIj0mlwNrfiWLFmCihUrwszMDA0bNsSFCxdUfB3KYyJARESkQVu3bsW4ceMwdepUXL58GXXq1EH79u0RHx8vSjxMBIiISI8Jil0nlWpKDA3MmzcPw4YNw6BBg1C9enUsX74c5ubmWL16tfpfXhEwESAiIj0mqPRPcROBrKwshIWFoW3btorHDAwM0LZtW5w9e1bNr61oOFnwPfLLRyYlJYkcCRGRfsj/vtVc+V7Vn+f13xGmpqYwNTV947inT58iNzcX5cqVK/B4uXLlcOvWLZXjUAYTgfdITk4GALi6uoocCRGRfklOToa1tXWJXNvExASOjo6IjY1V+VqWlpZv/I6YOnUqpk2bpvK1NYGJwHs4OzsjOjoapUuXhkymSvUp/ZWUlARXV1dER0fDyspK7HAkie+h6vgeqk5T76EgCEhOToazs3OJPYeZmRkiIyORlZWl8rUEQXjj98PbegMAwN7eHoaGhoiLiyvweFxcHBwdHVWORRlMBN7DwMAALi4uYoehE6ysrPgFrCK+h6rje6g6TbyHJdUT8CozMzOYmZmV+PO8ysTEBPXr18fx48fRrVs3AIBcLsfx48cxcuRIjcaSj4kAERGRBo0bNw4DBw6Et7c3GjRogAULFiA1NRWDBg0SJR4mAkRERBrUu3dvPHnyBN9//z1iY2NRt25dHDp06I0JhJrCRIBKnKmpKaZOnVromBm9H99D1fE9VB3fQ/UZOXKkaEMBr5MJmlufQURERFqGBYWIiIj0GBMBIiIiPcZEgIiISI8xESC1mT17NmQyGcaMGVPoMWvXroVMJivQNL2OV9tMmzbtjffE09Pzneds374dnp6eMDMzQ61atXDgwAENRaudivse8nP4djExMejfvz/s7OxQqlQp1KpVC5cuXXrnOaGhoahXrx5MTU3xwQcfYO3atZoJltSGqwZILS5evIgVK1agdu3a7z3WysoKERERivus2AjUqFEDx44dU9w3Mir8f80zZ86gT58+CAoKQqdOnbB582Z069YNly9fRs2aNTURrlYqznsI8HP4uufPn6Np06bw8fHBwYMH4eDggDt37sDGxqbQcyIjI9GxY0cMHz4cmzZtwvHjxzF06FA4OTmhffv2GoyeVMFEgFSWkpKCfv364bfffsMPP/zw3uNlMplopTS1lZGRUZHfk4ULF6JDhw745ptvAAAzZszA0aNHsXjxYixfvrwkw9RqxXkPAX4OXzdnzhy4urpizZo1iscqVar0znOWL1+OSpUqYe7cuQCAatWq4fTp05g/fz4TAQnh0ACpbMSIEejYsWOBbTXfJSUlBW5ubnB1dUXXrl3xzz//lHCE2u/OnTtwdnaGu7s7+vXrh6ioqEKPPXv27Bvvdfv27UXbwlRbFOc9BPg5fN3evXvh7e2NXr16oWzZsvDy8sJvv/32znP4WdQNTARIJVu2bMHly5cRFBRUpOOrVq2K1atXY8+ePdi4cSPkcjmaNGmCf//9t4Qj1V4NGzbE2rVrcejQISxbtgyRkZFo3ry5YufL18XGxr51C1N17KImVcV9D/k5fNP9+/exbNkyVK5cGYcPH8YXX3yBr776CuvWrSv0nMI+i0lJSUhPTy/pkEldBCIlRUVFCWXLlhWuXLmieKxly5bC6NGji3yNrKwswcPDQ5gyZUoJRChNz58/F6ysrISVK1e+9efGxsbC5s2bCzy2ZMkSoWzZspoITxLe9x6+jp/DvM9V48aNCzw2atQooVGjRoWeU7lyZWHWrFkFHgsODhYACGlpaSUSJ6kfewRIaWFhYYiPj0e9evVgZGQEIyMjnDx5Er/88guMjIyQm5v73msYGxvDy8sLd+/e1UDE0lCmTBlUqVKl0PfE0dFRq7Yw1Ubvew9fx88h4OTkhOrVqxd4rFq1au8cYinss2hlZYVSpUqVSJykfkwESGlt2rTBtWvXEB4ermje3t7o168fwsPDYWho+N5r5Obm4tq1a3ByctJAxNKQkpKCe/fuFfqeNG7cGMePHy/w2NGjR9G4cWNNhCcJ73sPX8fPIdC0adMCqygA4Pbt23Bzcyv0HH4WdYTYXRKkW14fGhgwYIAwadIkxf3p06cLhw8fFu7duyeEhYUJn376qWBmZib8888/IkSrHcaPHy+EhoYKkZGRwl9//SW0bdtWsLe3F+Lj4wVBePM9/OuvvwQjIyPh559/Fm7evClMnTpVMDY2Fq5duybWSxBdcd9Dfg7fdOHCBcHIyEiYOXOmcOfOHWHTpk2Cubm5sHHjRsUxkyZNEgYMGKC4f//+fcHc3Fz45ptvhJs3bwpLliwRDA0NhUOHDonxEkhJXD5IJSoqKgoGBv91PD1//hzDhg1DbGwsbGxsUL9+fZw5c+aNLkl98u+//6JPnz549uwZHBwc0KxZM5w7dw4ODg4A3nwPmzRpgs2bN2PKlCmYPHkyKleujN27d+t1DYHivof8HL7pww8/xK5duxAYGIj//e9/qFSpEhYsWIB+/fopjnn8+HGBoYJKlSohODgYY8eOxcKFC+Hi4oKVK1dy6aDEcPdBIiIiPcY5AkRERHqMiQAREZEeYyJARESkx5gIEBER6TEmAkRERHqMiQAREZEeYyJARESkx5gIEBER6TEmAkRERHqMiQCRjnn27BnKli2LBw8eqHSdTz/9FHPnzlVPUESktZgIEGmhgIAAyGQyyGQyGBsbo1KlSpgwYQIyMjLee+7MmTPRtWtXVKxYUaUYpkyZgpkzZyIxMVGl6xCRdmMiQKSlOnTogMePH+P+/fuYP38+VqxYgalTp77znLS0NKxatQpDhgxR+flr1qwJDw8PbNy4UeVrEZH2YiJApKVMTU3h6OgIV1dXdOvWDW3btsXRo0ffec6BAwdgamqKRo0aKR4LDQ2FTCbD4cOH4eXlhVKlSqF169aIj4/HwYMHUa1aNVhZWaFv375IS0srcL3OnTtjy5YtJfL6iEg7MBEgkoDr16/jzJkzMDExeedxp06dQv369d/6s2nTpmHx4sU4c+YMoqOj8cknn2DBggXYvHkzgoODceTIESxatKjAOQ0aNMCFCxeQmZmpttdCRNrFSOwAiOjt9u/fD0tLS+Tk5CAzMxMGBgZYvHjxO895+PAhnJ2d3/qzH374AU2bNgUADBkyBIGBgbh37x7c3d0BAD179kRISAgmTpyoOMfZ2RlZWVmIjY2Fm5ubml4ZEWkTJgJEWsrHxwfLli1Damoq5s+fDyMjI/j5+b3znPT0dJiZmb31Z7Vr11bcLleuHMzNzRVJQP5jFy5cKHBOqVKlAOCNIQMi0h0cGiDSUhYWFvjggw9Qp04drF69GufPn8eqVaveeY69vT2eP3/+1p8ZGxsrbuevRniVTCaDXC4v8FhCQgIAwMHBQZmXQEQSwESASAIMDAwwefJkTJkyBenp6YUe5+XlhRs3bqjtea9fvw4XFxfY29ur7ZpEpF2YCBBJRK9evWBoaIglS5YUekz79u3xzz//FNorUFynTp1Cu3bt1HItItJOTASIJMLIyAgjR47Ejz/+iNTU1LceU6tWLdSrVw/btm1T+fkyMjKwe/duDBs2TOVrEZH2kgmCIIgdBBGpT3BwML755htcv34dBgbK5/rLli3Drl27cOTIETVGR0TahqsGiHRMx44dcefOHcTExMDV1VXp6xgbG79RV4CIdA97BIiIiPQY5wgQERHpMSYCREREeoyJABERkR5jIkBERKTHmAgQERHpMSYCREREeoyJABERkR5jIkBERKTHmAgQERHpsf8DSGzZFl2TzJwAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -368,7 +360,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -378,7 +370,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -392,7 +384,7 @@ "start_points = []\n", "end_points = []\n", "for bin in my_reactor.divertor.bins:\n", - " heat_flux = plasma_data_handling.get_heat(FP_pulse, bin=bin, t_rel=0)\n", + " heat_flux = plasma_data_handling.get_heat(FP_pulse, bin=bin, t_rel=FP_pulse.ramp_up+1)\n", " heat_fluxes.append(heat_flux)\n", "\n", " start_points.append(bin.start_point)\n", @@ -430,12 +422,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg8AAAHHCAYAAAA4drvmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABirUlEQVR4nO3dd1yV1R8H8M9lyxQFGYooZmJOFEUcKYnhTBPNXKipZak/EzOlzJHlXuVMc28tR+6BYAPKHKSmYk4MBTWRveSe3x/EzSvzDnju+Lx7Pa/g4ZzzfO+N4MuZMiGEABEREVEZmUgdABEREekXJg9ERESkEiYPREREpBImD0RERKQSJg9ERESkEiYPREREpBImD0RERKQSJg9ERESkEiYPREREpBImD0RERKQSJg9k8KKiojB9+nQ8ffpUkuc/ffoU7777LpydnWFjY4OAgACcP3++zPWvXr2Kzp07w9bWFlWqVMHgwYPx6NGjQuXkcjnmzZuH2rVrw8rKCo0bN8b27du1+VLKLD4+Hm+99RYqV64Me3t79OzZE7du3Sqy7Nq1a1G/fn1YWVmhbt26WLp0aQVHS0QqE0QGbv78+QKAuH37doU/Oy8vT7Ru3VrY2NiI6dOni2XLlolXXnlF2NnZievXr5da/969e8LJyUnUqVNHfPXVV+LLL78Ujo6OokmTJiI7O1up7OTJkwUAMXLkSLF69WrRrVs3AUBs3769vF5ekVJTU0XdunVFtWrVxNy5c8WiRYuEh4eHqFGjhnj8+LFS2VWrVgkAIjg4WKxevVoMHjxYABBz5syp0JiJSDVMHsjgSZk87Ny5UwAQu3fvVtx7+PChqFy5sujfv3+p9d9//31RqVIlcffuXcW9EydOCADim2++Udz7+++/hbm5uRg9erTinlwuF+3atRM1atQQz54908rr8fT0FNOmTSuxzNy5cwUAcebMGcW9q1evClNTUxEWFqa4l5GRIapWrSq6deumVH/gwIHCxsZGPHnyRCsxE5H2cdiCDNr06dMxceJEAEDt2rUhk8kgk8lw586dCnn+d999BxcXF/Tu3Vtxz9nZGW+99Rb279+P7OzsEut///336N69O2rWrKm4FxgYiJdffhm7du1S3Nu/fz9yc3PxwQcfKO7JZDK8//77+PvvvxEdHa3U7pEjR9CuXTvY2NjAzs4O3bp1w59//qnpywWQ/5pbtGiBFi1aKO55e3ujY8eOSjFHRETgn3/+UYoZAEaPHo309HQcOnSoxOekpqbiww8/RK1atWBpaYlq1aqhU6dOKg0JEZF6mDyQQevduzf69+8PAFi8eDE2b96MzZs3w9nZudg6GRkZePz4calXUlJSqc+/cOECmjVrBhMT5f/VWrZsiYyMDFy/fr3YuvHx8Xj48CF8fX0Lfa1ly5a4cOGC0nNsbGxQv379QuUKvl5g8+bN6NatG2xtbTF37lx89tlnuHLlCtq2batxUiWXy3Hx4sViY7558yZSU1OVYnqxbPPmzWFiYqIUc1FGjRqFlStXIjg4GCtWrMBHH32ESpUq4erVqxq9BiIqnZnUARCVp8aNG6NZs2bYvn07evXqhVq1apVaZ968eZgxY0ap5Tw9PUv9ZfvgwQO8+uqrhe67ubkBAO7fv49GjRoVW/f5si/Wf/LkCbKzs2FpaYkHDx7AxcUFMpms2OcAQFpaGv73v/9hxIgRWL16taLckCFDUK9ePcyaNUvpvqoKYiou5oJY6tWrhwcPHsDU1BTVqlVTKmdhYYGqVasqYi7OoUOHMHLkSCxcuFBx7+OPP1Y7diIqOyYPRC8ICQlB27ZtSy1XqVKlUstkZmbC0tKy0H0rKyvF10uqC6DU+paWlmV+zokTJ/D06VP0798fjx8/VpQzNTWFn58fIiIiFPeys7MVvQQF5HK5omfmeU5OTirFXPBvCwuLIl+7lZVVie8NAFSuXBm//fYb7t+/D3d39xLLEpF2MXkgeoGXlxe8vLy00lalSpWKnNeQlZWl+HpJdQGUqX5Zn/PXX38BAF577bUin2lvb6/4ePv27Rg2bFihMvPnz8f8+fOV7gkh1Io5JyenyDiysrJKTc7mzZuHIUOGwMPDA82bN0fXrl0REhKitf92ZBh+/PFHzJ8/H+fOncODBw+wd+9e9OrVS6U2hBBYuHAhVq9ejbt378LJyQkffPABPv300/IJWg8weSB6QVpaGtLS0kotZ2pqWuLcCSC/q75g+OF5BfdK+ou5oJu/uPpVqlRR/IXv5uaGiIgICCGUhi5efI5cLgeQP+/B1dW1ULtmZv/9SAgKCsKJEyeUvj5o0CC8/vrrCAkJKTLmgpjK8prd3NyQl5eHhw8fKg1d5OTk4J9//im1N+Gtt95Cu3btsHfvXhw/fhzz58/H3LlzsWfPHnTp0qXEumQ80tPT0aRJE7zzzjtKE5dVMW7cOBw/fhwLFixAo0aN8OTJEzx58kTLkeoZiVd7EJW7BQsWqLRUc9q0aQJAqZenp2epbfXp00e4uLiIvLw8pfsjR44U1tbWIisrq8T6zs7Oom/fvoXuv/zyy+K1115TfL5s2TIBQPz5559K5bZu3SoAiB9//FEIIcSuXbsEAHHs2LFSYy9KWZZq+vr6ihYtWhS636lTJ+Hl5aX4/ODBgwKAOHTokFK5X375RQAQmzZtUim2xMREUb16ddGmTRuV6pHxACD27t2rdC8rK0tMmDBBuLu7C2tra9GyZUsRERGh+PqVK1eEmZmZuHbtWsUGq+O42oIMno2NDQCUeYfJkJAQnDhxotRr69atpbbVp08fJCYmYs+ePYp7jx8/xu7du9GjRw+luQE3b97EzZs3leoHBwfj4MGDuHfvnuJeeHg4rl+/jr59+yru9ezZE+bm5lixYoXinhACq1atQvXq1dG6dWsA+b0J9vb2mDVrFnJzcwvFW9TOlarq06cPfv/9d5w9e1ZxLzY2FqdOnVKK+bXXXkOVKlWwcuVKpforV66EtbU1unXrVuwz8vLykJycrHSvWrVqcHd3L3X5K9HzxowZg+joaOzYsQMXL15E37590blzZ8UQ34EDB+Dl5YWDBw+idu3aqFWrFkaMGMGeB6mzF6LydubMGQFAdO3aVWzatEls375dpKWlVciznz17Jlq1aiVsbW3FjBkzxPLly0WDBg2EnZ1dob9kPD09C/VmxMXFiapVq4o6deqIr7/+WsyaNUs4OjqKRo0aFeq1mDhxogAg3n33XbFmzRrFDpNbt25VKrd161ZhYmIiGjZsKL744gvxzTffiE8//VQ0bdpUaZOpopSl5yElJUXUqVNHVKtWTcybN08sXrxYeHh4CHd3d/Hw4UOlssuXLxcARJ8+fcSaNWtESEiIACC+/PLLEp+RlJQkbGxsxJAhQ8SiRYvE6tWrxVtvvSUAiIULF5ZYl4wXXuh5uHv3rjA1NRXx8fFK5Tp27KjY0Oy9994TlpaWws/PT/z4448iIiJCNG3aVAQEBFRk6DqHyQMZhZkzZ4rq1asLExOTCt9t8smTJ2L48OGiatWqwtraWrRv3178/vvvhcoVlTwIIcTly5fF66+/LqytrUXlypXFwIEDRUJCQqFyeXl5YtasWcLT01NYWFiIBg0aiC1bthQZU0REhAgKChIODg7CyspK1KlTRwwdOlScPXu2xNdSluRBiPxttfv06SPs7e2Fra2t6N69u/jrr7+KLLt69WpRr149YWFhIerUqSMWL14s5HJ5ie1nZ2eLiRMniiZNmgg7OzthY2MjmjRpIlasWFFqbGS8XkweCobObGxslC4zMzPx1ltvCSHyhxgBiNjYWEW9c+fOCQBGPZQhE+LfadJEREQGTCaTKa222LlzJwYOHIg///wTpqamSmVtbW3h6uqKadOmFRrmy8zMhLW1NY4fP45OnTpV5EvQGVxtQURERsnHx0ex4qddu3ZFlmnTpg2ePXuGmzdvok6dOgCg2BnW09OzwmLVNex5ICIig5WWloYbN24AyE8WFi1ahICAAFSpUgU1a9bEoEGD8Msvv2DhwoXw8fHBo0ePEB4ejsaNG6Nbt26Qy+Vo0aIFbG1tsWTJEsjlcowePRr29vY4fvy4xK9OOkweiIjIYEVGRiIgIKDQ/SFDhmDDhg3Izc3FF198gU2bNiE+Ph5OTk5o1aoVZsyYodg6/v79+xg7diyOHz8OGxsbdOnSBQsXLkSVKlUq+uXoDCYPREREpBLu80BEREQqYfJAREREKuFqi1LI5XLcv38fdnZ2hY47JiIi7RNCIDU1Fe7u7jAxKb+/cbOysoo9nE0VFhYWilNjjQWTh1Lcv38fHh4eUodBRGR07t27hxo1apRL21lZWahd2xUJCcmlFy6Fq6srbt++bVQJBJOHUtjZ2QHI/yZ+/rhiIiIqHykpKfDw8FD8/C0POTk5SEhIxp17X8HevuTj30uSkpKJWh7jkJOTw+SB/lMwVGFvb8/kgYioAlXEULGtrSVsbS1LL1iMgmPujQ2TByIiMlpCPIMQzzSqb4yYPBARkdESIg9C5GlU3xhxqSYRERGphD0PRERktOTiGeQaDD1oUlefMXkgIiKjxTkP6uGwBREREamEPQ9ERGS08idMatLzYJwTJpk8EBGR0RLyZxByDZIHDerqM70Ytrhz5w6GDx+O2rVro1KlSqhTpw6mTZtW6p7kHTp0gEwmU7pGjRpVQVETEREZJr3oebh27Rrkcjm++eYbvPTSS7h8+TJGjhyJ9PR0LFiwoMS6I0eOxOeff6743NraurzDJSIifSGe5V+a1DdCepE8dO7cGZ07d1Z87uXlhdjYWKxcubLU5MHa2hqurq7lHSIREekhrrZQj14MWxQlOTkZVapUKbXc1q1b4eTkhIYNGyIsLAwZGRklls/OzkZKSorSRURERP/Ri56HF924cQNLly4ttddhwIAB8PT0hLu7Oy5evIhJkyYhNjYWe/bsKbbO7NmzMWPGDK3FevjwEQQFvQ5TU1OttUlERFoifwbIczWrb4Qk7XmYPHlyoQmNL17Xrl1TqhMfH4/OnTujb9++GDlyZIntv/vuuwgKCkKjRo0wcOBAbNq0CXv37sXNmzeLrRMWFobk5GTFde/ePbVf3+HDR9Ct2xto0+ZVXLlyRe12iIiofBQMW2hyGSNJex4mTJiAoUOHlljGy8tL8fH9+/cREBCA1q1bY/Xq1So/z8/PD0B+z0WdOnWKLGNpaQlLS/WPZ31eSkoK7O3t8dtvZ+Dj0wJTp07Bxx9/BHNzc620T0REGpI/A+Qa9Awbac+DpMmDs7MznJ2dy1Q2Pj4eAQEBaN68OdavXw8TE9U7TWJiYgAAbm5uKtdVx9tv90Pbtm0watRoHDp0GFOmTMV3332PdevWwMfHp0JiICIi0ja9mDAZHx+PDh06oGbNmliwYAEePXqEhIQEJCQkKJXx9vbGmTNnAAA3b97EzJkzce7cOdy5cwc//PADQkJC8Oqrr6Jx48YVFnuNGjVw4MA+bNmyEVWqVEFMzB9o0cIfU6ZMRXZ2doXFQURERZA/0/wyQnqRPJw4cQI3btxAeHg4atSoATc3N8VVIDc3F7GxsYrVFBYWFjh58iRef/11eHt7Y8KECQgODsaBAwcqPH6ZTIaBAwfgypWL6Nu3D/Ly8vDll7Ph49MCv/76a4XHQ0REBfL+2+tBnQvGuT21TAghpA5Cl6WkpMDBwQHJycmwt7fXSpt79uzFBx+MRWJiImQyGcaPH4eZM2dwAysiIpTPz93innHv9nuwt7NQv53UHHjU/qZcY9VFetHzYGh6934TV65cREjIIAghsGjREjRu3AyRkaelDo2IyKjI5M80vowRkweJVKlSBRs3rsfhwwdQo0YN3Lx5EwEBgXj//dHcmIqIqKJwzoNamDxIrEuXzvjzzz/w3nv5e1asWrUaDRs2xdGjxySOjIiItO3HH39Ejx494O7uDplMhn379pVYfs+ePejUqROcnZ1hb28Pf39/HDsm/e8HJg86wN7eHqtWrcCpUyfg5eWFe/fuoUuX7hg69B08efJE6vCIiAxXBfc8pKeno0mTJli+fHmZyv/444/o1KkTDh8+jHPnziEgIAA9evTAhQsX1Hm1WsMJk6WoiIk7z0tPT8dnn03DkiVfQwgBV1dXrFixFG++2avcn01EpAsqcsJk/LV+Gk+YrO69U61YZTIZ9u7di169eqlUr0GDBujXrx+mTp2qUj1tYs+DjrGxscGiRQvwyy+n4e3tjYSEBPTu3Rf9+g3Aw4cPpQ6PiIgkJJfLkZqaWqaDIcsTkwcd5e/vjwsXfscnn0yGqakpdu3ajVdeaYxt27aDnUVERFoilwPyPA0uOQAUOo25vDYBXLBgAdLS0vDWW2+VS/tlxeRBh1lZWeHLL2fizJkoNGnSGP/88w8GDgxBz569ER8fL3V4RER6T1tLNT08PODg4KC4Zs+erfVYt23bhhkzZmDXrl2oVq2a1ttXBZMHPdCsWTP8/vuvmDlzBszNzXHgwEE0aNAE3367lr0QRESa0KjX4d8LwL1795ROZA4LC9NqmDt27MCIESOwa9cuBAYGarVtdTB50BPm5uaYMuUTXLjwO1q2bIHk5GSMHDkKr7/eBbdv35Y6PCIio2Zvb690aet0ZgDYvn07hg0bhu3bt6Nbt25aa1cTTB70TIMGDRAV9RMWLJgHKysrnDwZjkaNfLB06TLI/x17IyKiMqrgpZppaWmIiYlRnPJ8+/ZtxMTEIC4uDgAQFhaGkJAQRflt27YhJCQECxcuhJ+fn+JQyOTkZK29Bepg8qCHTE1NMWHCeFy8eB6vvtoO6enp+N//xqN9+9dw/fp1qcMjItIbMnmexpcqzp49Cx8fH/j4+AAAQkND4ePjo1h2+eDBA0UiAQCrV6/Gs2fPMHr0aKVDIceNG6e9N0EN3OehFBW9z4Oq5HI5Vq36BpMmfYK0tDRYWlri88+nIzT0Q5iZmUkdHhGRyipyn4cH54Ngb2eufjupuXBrdkxnf0eUF/Y86DkTExN88MH7uHw5Bq+/3gnZ2dmYNCkM/v5tcenSJanDIyLSbULDyZLCOI/kZvJgIDw9PXH06CGsX/8tKleujLNnz6F5cz/MmDETOTk5UodHRKSTZHK5hsMWxjnXjMmDAZHJZBg6dAiuXLmInj3fQG5uLqZP/xy+vn44e/as1OEREZGBYPJggNzc3LB373fYsWMrnJyccOnSZfj5tcHkyZ8gMzNT6vCIiHSHlvZ5MDZMHgyUTCZDv35v4cqVi+jf/23I5XLMnTsfTZv64pdffpE6PCIinVDRqy0MBZMHA+fs7Ixt2zZj//49cHNzw/Xr19GuXQDGjRuPtLQ0qcMjIiI9xOTBSLzxRg9cuXIR77wzFEIIfP31MjRq5IPw8FPc4pqIjBeHLdTC5MGIVK5cGWvXrsGxY4fh6emJO3fuIDAwCDVreuGff/6ROjwiogrHYQv1MHkwQq+/3gmXLl3AkCGDAQB///03Bg0KYQ8EERkf9jyohcmDkbKzs8OGDevwxRefAwCOHj2OpUuXSRwVERHpAyYPRu7TT8Mwb94cAMD48R/h0KHDEkdERFRxZHLx70ZR6l7G2WPL5IHw0UehGD58GORyOd5+eyAuXrwodUhERBWDwxZqYfJAkMlkWLFiGQICOiAtLQ3du/dCQkKC1GEREZGOYvJAAAALCwt8//0uvPzyy7h37x569uzN3SiJyPDxYCy1MHkgBUdHRxw8uA9VqlTBmTO/Y8iQdyA30kNfiMg4yIRc48sYMXkgJXXr1sWePbthbm6O3bu/w7RpM6QOiYiIdAyTByqkfftXsXr1SgDAF1/MwubNWySOiIionHDCpFqYPFCRhg4dgsmTPwYAjBjxHn7++WeJIyIiKgdyueaXEWLyQMX68suZCA7ujZycHPTq1Qc3b96UOiQiItIBTB6oWCYmJti0aT2aN2+Gf/75B92798LTp0+lDouISHvY86AWJg9UImtra/zww17UqFED165dQ9++byM3N1fqsIiItCJ/l0hNDsZi8kBUJHd3dxw4sBc2NjY4eTIcY8eO4yFaRGQY2POgFiYPVCZNmzbF9u1bIJPJ8M03a7BkyVdSh0RERBJh8kBl1qNHdyxYMBcAMGHCxzhw4KDEERERaYg9D2ph8kAqGT/+Q7z77ggIIdC//yDExMRIHRIRkfqYPKiFyQOpRCaTYdmyr9Gx42tIT09Hq1Zt8dNP3AOCiMiYMHkgleVvXb0DNjY2yM7OxsiR70kdEhGRengwllqYPJBaHB0dsXz51wCA+Pj7SE1NlTgiIiLV5S/V1OwyRkweSG0hIYPh7e2NtLQ0bNy4SepwiIiogjB5ILXJZDKMGfM+AGDZspU8vpuI9A8nTKqFyQNpJCRkMOzs7BAbG4sTJ05KHQ4RkWqYPKiFyQNpxM7ODsOGDQEALF26XOJoiIioIjB5II2NGfMBAODw4SM8eZOI9ItcaNjzYJxb9TN5II3VrVsXXbp0hhACy5evlDocIqKykwvNLyPE5IG0YuzY0QCAdes2IC0tTeJoiIjKiHMe1MLkgbQiKOh11K1bF8nJydi8eYvU4RARUTli8kBaYWJigtGjRwHIX7bJI7uJSC+w50EtTB5Ia4YOHQJbW1tcuXIFp05FSB0OEVHpOOdBLUweSGscHBwwZMhgAFy2SURkyJg8kFYVLNv84YcDuH37tsTREBGVQsg1v4wQkwfSKm9vb3TqFAghBFasWCV1OEREJRMaDlkY6fwuJg+kdQXLNteuXY+MjAyJoyEiIm1j8kBa17VrF9SuXRtJSUnYunWb1OEQERWPEybVwuSBtM7U1FRx2ubXXy/jsk0i0l1MHtTC5IHKxTvvDIO1tTUuX/4Tp0//KHU4RESkRUweqFxUrlwZgwcPBMBlm0Sku7jYQj1MHqjcFCzb3LdvP+Li4iSOhoioCBU8bPHjjz+iR48ecHd3h0wmw759+0qtExkZiWbNmsHS0hIvvfQSNmzYoN5r1SImD1RuGjZsiICADpDL5Vi58hupwyEiKkyuhUsF6enpaNKkCZYvL1uP7O3bt9GtWzcEBAQgJiYGH374IUaMGIFjx46p9mAtM5P06WTwxo4djYiISCxdugxDh4agXr16UodERCSZLl26oEuXLmUuv2rVKtSuXRsLFy4EANSvXx8///wzFi9ejKCgoPIKs1TseaBy1aNHd1haWiI9PQMLFy6WOhwiImVa6nlISUlRurKzs7USXnR0NAIDA5XuBQUFITo6Wivtq4vJA5UrMzMzNGnSGACQk5MrcTRERC8QWrgAeHh4wMHBQXHNnj1bK+ElJCTAxcVF6Z6LiwtSUlKQmZmplWeog8MWVO6Cg3vjzJnftZaJExHpmnv37sHe3l7xuaWlpYTRlD8mD1TuvL3z5zlcv35d4kiIiJQJuQxCLtOgfv6/7e3tlZIHbXF1dUViYqLSvcTERNjb26NSpUpaf15ZMXmgcvfyy3UBANev/wUhBGQy9f9HJSLSKjVWTBSqX478/f1x+PBhpXsnTpyAv79/+T64FJzzQOXOy8sLpqamSEtLw4MHD6QOh4hIMmlpaYiJiUFMTAyA/KWYMTExir1wwsLCEBISoig/atQo3Lp1Cx9//DGuXbuGFStWYNeuXRg/frwU4SsweaByZ2Fhgdq1awMAYmM5dEFEOkTIALkGl1CtJ/Xs2bPw8fGBj48PACA0NBQ+Pj6YOnUqAODBgwdKm+rVrl0bhw4dwokTJ9CkSRMsXLgQ3377raTLNAEOW1AFqVfvZdy4cQOxsbEICOggcTRERPm0NeehrDp06FDiYYFF7R7ZoUMHXLhwQcXIypfe9Dy88cYbqFmzJqysrODm5obBgwfj/v37JdbJysrC6NGjUbVqVdja2iI4OLjQxBOqGM/PeyAiIv2mN8lDQEAAdu3ahdjYWHz//fe4efMm+vTpU2Kd8ePH48CBA9i9ezdOnz6N+/fvo3fv3hUUMT2vXr2XAXDYgoh0jCZDFgWXEdKbYYvnJ4d4enpi8uTJ6NWrF3Jzc2Fubl6ofHJyMtauXYtt27bhtddeAwCsX78e9evXx6+//opWrVpVWOwEvPxyfvLAngci0ilC9XkLyvW1F4o+0Zueh+c9efIEW7duRevWrYtMHADg3LlzyM3NVdrW09vbGzVr1ixxW8/s7OxC24yS5gp6Hm7fvo2cnByJoyEiylcw50GTyxjpVfIwadIk2NjYoGrVqoiLi8P+/fuLLZuQkAALCwtUrlxZ6b6LiwsSEhKKrTd79mylLUY9PDy0Fb5Rc3Nzg62tLfLy8nDr1i2pwyEiIg1ImjxMnjwZMpmsxOvatWuK8hMnTsSFCxdw/PhxmJqaIiQkpMRZq+oICwtDcnKy4rp3755W2zdWMplMMWmS8x6ISGfITTS/jJCkcx4mTJiAoUOHlljGy8tL8bGTkxOcnJzw8ssvo379+vDw8MCvv/5a5E5brq6uyMnJwdOnT5V6HxITE+Hq6lrs8ywtLQ1+T3KpvPzyyzh//gLnPRCR7tB00mM57zCpqyRNHpydneHs7KxWXbk8/79YcYctNW/eHObm5ggPD0dwcDAAIDY2FnFxcZJv62ms/ltxEStxJEREpAm9WG3x22+/4ffff0fbtm3h6OiImzdv4rPPPkOdOnUUiUB8fDw6duyITZs2oWXLlnBwcMDw4cMRGhqKKlWqwN7eHmPHjoW/vz9XWkiEez0Qka4RQgahwWoLLY+c6w29SB6sra2xZ88eTJs2Denp6XBzc0Pnzp0xZcoUxRBDbm4uYmNjkZGRoai3ePFimJiYIDg4GNnZ2QgKCsKKFSukehlGj3s9EJHOkZtoOGxhnNmDTGh7xqGBSUlJgYODA5KTk8vluFVjkv9eVgUA/H7mDHxb+EgcERHpoor4uVvwjMRPHGFvpX7ykJIl4DIryeh+R+hFzwMZBjs7O8hgAgE5niQ9kTocIiIIOTQ828I4//5m8kAVJjU1DeZmVSGDKdq1ayN1OERE/52qqUl9I8TkgSrM06cpMJGZwcLCAlZWXA5LRKSvmDxQhUl+mr/Vt6OjA2Qy48zWiUi3aL7awjh/ljF5oArz9GkyAMDBwXgmFRGRjtN0l0huEkVUvp7+2/PgUJnJAxHpBk0Pt+LBWETlrKDnwdHRQeJIiIhIE+x5oArDYQsi0jWc86AeJg9UYQomTFbmsAUR6QrOeVALhy2owiT92/NQuTKHLYiI9Bl7HqjCJHPCJBHpGE6YVA+TB6owHLYgIl3DOQ/q4bAFVRgOWxARGQb2PFCFYc8DEekcTphUC5MHqjA3bt4BACQlJUsbCBHRvzjnQT0ctqAKkZ6egazMLABA1SqOEkdDRESaYM8DVYjoqHOQyUxRpUpltPDzkTocIiIAnDCpLiYPVCFOn46GTGaCbt07wdbWRupwiIjyCQ3nPAjthaJPmDxQhTgdGQ0AaN/BX+JIiIj+wzkP6uGcByp3T5+m4ML5ywCA9u1bSRwNERFpij0PVO5++fkM5HI56tatjeo13KQOh4hIQQjN5i0IDlsQlY9IDlkQka7ScNgCHLYgKh8/nv4VAJMHIiJDwZ4HKlePHv2Dy5euAQDaveoncTRERMqEMIEQ6v8dLXR83OLq1avYsWMHfvrpJ9y9excZGRlwdnaGj48PgoKCEBwcDEtLS5XbZc8DlauffvwNANCgYT04O1eVOBoiohfIZZpfOuj8+fMIDAyEj48Pfv75Z/j5+eHDDz/EzJkzMWjQIAgh8Omnn8Ld3R1z585Fdna2Su2z54HKFZdoEhFVvODgYEycOBHfffcdKleuXGy56OhofPXVV1i4cCE++eSTMrfP5IHKVUHy0IHJAxHpIEPdYfL69eswNzcvtZy/vz/8/f2Rm5urUvtMHqjcxP/9AH/9dRsmJiZo07al1OEQERViqJtElSVx0KQ85zxQuTn97yoLn2YNeQw3EZEEMjMz8fPPP+PKlSuFvpaVlYVNmzap1S6TByo3nO9ARLquYLWFJpeuun79OurXr49XX30VjRo1Qvv27fHgwQPF15OTkzFs2DC12tbdV016TQiBgwdPAgDat2fyQES6qWDYQpNLV02aNAkNGzbEw4cPERsbCzs7O7Rp0wZxcXEat805D1QuTp74CU+TkgEAdep4ShwNEVHRDHXCJABERUXh5MmTcHJygpOTEw4cOIAPPvgA7dq1Q0REBGxs1D/hmD0PVC42rt8NQAYXF2fU9qopdThEVIGePn2KmzdvSh2G0cvMzISZ2X99BDKZDCtXrkSPHj3Qvn17XL9+Xe22mTyQ1j1+/ATHjp6GicwUm7YulTocIqogt27dwrhx41GjRi2MGjVa6nDKpKDnQZNLV3l7e+Ps2bOF7i9btgw9e/bEG2+8oXbbTB5I69av3YmsrGw09WmANm18pQ6HiMpZVFQU+vTph7p16+Prr5chPT0diYmJSEtLkzq0Ugmh4ZwHHU4e3nzzTWzfvr3Iry1btgz9+/dXe3ttJg+kVTk5OVi9aisAYPTYIZDJdPd/LCJS37Nnz7B793fw92+LNm3a4/vv90AulyMo6HUcP34Ef/xxHra2tlKHqbOWL1+OWrVqwcrKCn5+fjhz5kyJ5ZcsWYJ69eqhUqVK8PDwwPjx45GVlVVinbCwMBw+fLjYr69YsQJyuVyt+DlhkrRqz/dHkJDwCK6uzugd3EXqcIhIy1JTU7F27Tp89dUy3LlzBwBgYWGBQYMGYPz4cWjYsKG0AapIioOxdu7cidDQUKxatQp+fn5YsmQJgoKCEBsbi2rVqhUqv23bNkyePBnr1q1D69atcf36dQwdOhQymQyLFi1SO3ZNMHkgrRFCYPnSjQCAd0cNhIWFhcQREZG2xMXFYenS5Vi9+lukpKQAAKpWrYoPPhiF0aPfh4uLi8QRqkeKHSYXLVqEkSNHKvZYWLVqFQ4dOoR169Zh8uTJhcpHRUWhTZs2GDBgAACgVq1a6N+/P3777bcyPS8rKwtLly5FREQEHj58WKi34fz58yq/BiYPpDVRv5xDzIU/YWVliWHD+0kdDhFpwdmzZ7Fo0VfYtWs38vLyAAD16tVDaOg4DB48CJUqVZI4Qt1QkFAVsLS0LPKo65ycHJw7dw5hYWGKeyYmJggMDER0dHSRbbdu3RpbtmzBmTNn0LJlS9y6dQuHDx/G4MGDyxTb8OHDcfz4cfTp0wctW7bUynAykwfSmuVLNwAA3h7QE05OVaQNhojUlpeXh4MHD2HhwsX46aefFfcDAjpgwoTx6NKlM0xMDGPKnLb2efDw8FC6P23aNEyfPr1Q+cePHyMvL69QT42LiwuuXbtW5DMGDBiAx48fo23bthBC4NmzZxg1alSZT8E8ePAgDh8+jDZt2pSpfFkweSCtuH37Hg4eyN9RcvSYIRJHQ0TqSE9Px4YNG7FkyVLcuHEDAGBmZob+/fth/Phx8PHxkThC7dNW8nDv3j3Y2/93hk9RvQ7qioyMxKxZs7BixQr4+fnhxo0bGDduHGbOnInPPvus1PrVq1eHnZ2d1uIBmDyQlnyzYjOEEAjs1Bbe9V+SOhwiUsH9+/exbNkKrFq1GklJSQCAypUrY9SodzFmzAeoXr26xBGWHyHX7GRM8e/0AXt7e6XkoThOTk4wNTVFYmKi0v3ExES4uroWWeezzz7D4MGDMWLECABAo0aNkJ6ejnfffReffvppqb1ACxcuxKRJk7Bq1Sp4empnx18mD6SxxIRHWLd2JwDgA/Y6EOmNP/74A4sWLcH27TuRm5sLAKhTpw4+/HAshg4dwqWW5cDCwgLNmzdHeHg4evXqBQCQy+UIDw/HmDFjiqyTkZFRKEEwNTUFULbVHr6+vsjKyoKXlxesra0LHb/95MkTlV8HkwfS2If/+xyZmVmwt7dDYKd2UodDRCWQy+U4evQYFi1agvDwU4r7bdu2QWjoh3jjjR6KX0zGQIqzLUJDQzFkyBD4+vqiZcuWWLJkCdLT0xWrL0JCQlC9enXMnj0bANCjRw8sWrQIPj4+imGLzz77DD16lO2/Vf/+/REfH49Zs2bBxcWFEyZJepmZWfgxIn+5UNfugdwUikhHZWZmYsuWrVi8+GtcvXoVQP5fr336BCM0dBxatmwpcYTS0HyfB9Xr9uvXD48ePcLUqVORkJCApk2b4ujRo4pJlHFxcUo9DVOmTIFMJsOUKVMQHx8PZ2dn9OjRA19++WWZnhcVFYXo6Gg0adJE5ViLw+SBNLJl4z5kZuTCo7onFiz6VOpwiOgFDx8+xIoVq7BixSo8evQIAGBnZ4d33x2BsWNHa20MnFQzZsyYYocpIiMjlT43MzPDtGnTMG3aNLWe5e3tjczMTLXqFofJA6ktOzsHSxauBwB8NGkEHBy0O5uXiNR35coVLFq0BFu2bEN2djYAwNPTE+PGjcHw4e+UaXKfMZALGeQaDFtoUreizJkzBxMmTMCXX36JRo0aFZrzoM73ApMHUtu2zfvx4P5DuLlXw8CQXlKHQ2T0hBAIDz+FhQsX4+jRY4r7LVu2wIQJ49G795tKRzQTAA13mIQmdStI586dAQAdO3ZUui+EgEwmU2z+pQp+F5FacnJysXjBOgDAuNChsLTkVtREUhBCICsrC7t27caiRUtw8eIlAIBMJsObb/ZCaOg4tG7dmvORjNipU6e0/t+fyQOpZce2A/j7XgJcXJwweOibUodDZJRSU1PRq1cwoqKiFScs2tjY4J13hmLcuLGoU6eOxBHqPilWW1SUdevW4Y033kCHDh203rZh7C9KFSo3NxeL5+f3OowdPwSVKllJHBGRcVq6dDlOnYpAVlYWqlSpgjlzZuHevdv4+uslTBzKqCB50OTSVVu2bEGNGjXQunVrzJ07V7HKRhuYPJDKdu84grt34uHsXAVDhwdLHQ6RUfr227X49NP8rYmDg9/Egwf3MGnSRDg6OkocGemKU6dO4cGDB/jggw9w7tw5+Pn5oW7dupgwYQJ+/PHHQqdrqoLJA6kkKysL8+esBgCMHhcCa2ueqEdU0Xbs2Il3330fAPDRR6HYvXsnLCw470gdhtzzAACOjo4YNGgQdu3ahcePH2Pp0qXIzMzEwIEDUa1aNYSEhOC7775Denq6Su0yeSCVTJm0GHfvxMPa2grvjOwrdThERufAgYMYPHgohBB4772RmDdvDidDakAuTDS+9IWFhQU6d+6MFStW4N69ezh69Chq1aqFmTNnYtGiRSq1xQmTVGZyuRzf7TwCAPBv3Ry2ttYSR0RkXE6dikDfvm/j2bNnGDiwP1asWMbEQUNCaLZUU5d7HiIiItCmTZtie6V8fX3h6+uLzz//XHG2SVkxeaAyO/zDaWSk5sLOxgFfrZgqdThERiU6OhpvvPEmsrOz0bPnG1i/fm2ppymScevYsSOsrKzQqlUrBAQEICAgAK1atSpyr48XN44qDb/zqEyEEFgyfyNkMhk+GDsQ7tWrSR0SkdGIiYlB165vID09HYGBHbFjx1aVf9hT0Qx5zsPt27exfPly1KxZE2vXrsWrr76KypUrIygoCHPmzMFvv/2m9qRJmSjLeZ5GLCUlBQ4ODkhOTjbq7VxPHovCwOCPYG1TCeeu7EGVqg5Sh0RkFGJjY9GuXQAePXqE1q39cfz4EdjY2EgdVrmqiJ+7Bc+Ieq0DbDXYdTPt2TO0PhWpF78jbt26hcjISERGRuL06dP4+++/YWdnh6dPn6rcFoctqFQFvQ4AMHTEm0wciCrInTt3EBjYGY8ePYKPT1McOvSDwScOVH68vLxgamoKmUwGmUyGffv2IScnR622mDxQqaJ+uoDff70ES0sLjBr7ttThEBmF+/fvo2PHIPz999+oX78+jh07jMqVK0sdlsEx9IOx4uLiEBkZiYiICERGRuLx48do3bo12rVrh4MHD8LPz0+tdpk8UKkKeh0GhHSHi6uTxNEQGb7Hjx+jU6cuuHXrFmrXro0TJ47A2dlZ6rAMkiFvT+3l5YWkpCS0adMGr776Kt577z34+vpq5XA0TpikEh3YE4EfI36HmZkpRo8fKHU4RAYvJSUFnTt3w5UrV+Du7o6TJ4+ievXqUodFeigzMxMAYGJiAjMzM5ibm8PU1FQrbbPngUr0yUeLAQA+zRvAo6abxNEQGbaMjAx0794T586dh5OTE06ePAovLy+pwzJohtzz8ODBA1y7dk0xbDFv3jxkZWWhbdu26NChA9q3b4/mzZurteSXyQMV69yZK3j0MAkA8FHYOxJHQ2TYsrOz8eabffDTTz/DwcEBx48fRv369aUOy+AZ+pwHb29veHt7Y9SoUQCAq1evKuY/fPHFFwCg1moLjYYtsrOzNalOOm7Zgu0wl1nijZ6B6BDYUupwiAzWs2fPMGDAYBw/fgLW1tY4dGg/fHx8pA6LDExiYiIuXryIixcv4o8//kBKSorav8dV6nk4cuQIduzYgZ9++gn37t2DXC6HjY0NfHx88Prrr2PYsGFwd3dXKxDSLRcvXMfJI9EwMTFB2PR3pQ6HyGDJ5XK8884I7NmzFxYWFti/fw/atGkjdVhGQwjNhh50eaekhw8fKvZ1iIiIwPXr12Fubo6WLVvi7bffRkBAAPz9/dVqu0zJw969ezFp0iSkpqaia9eumDRpEtzd3VGpUiU8efIEly9fxsmTJzFz5kwMHToUM2fO5MxgPbd49mYAwJv9XoNX3RoSR0NkmIQQGDt2HDZv3gpTU1Ps2rUdgYEdpQ7LqBjynAdXV1eYm5vD19cXwcHBCAgIQOvWrVGpkuanIZcpeZg3bx4WL16MLl26FDmx4q233gIAxMfHY+nSpdiyZQvGjx+vcXAkjed7Hf43cZDU4RAZrE8+mYIVK1ZBJpNh48Z16NnzDalDMjpCwzkPupw8HDlyBG3bti2XjcXKlDxER0eXqbHq1atjzpw5GgVE0mOvA1H5mzVrDubMmQcAWLVqOQYOHCBxRGRogoKCyq1t7vNAStjrQFT+li5dhk8//QwAsGDBPLz77kiJIzJehnowVufOnfHrr7+WWi41NRVz587F8uXLVWpf5aWaQgh89913iIiIwMOHDwudyLVnzx5VmyyTN954AzExMXj48CEcHR0RGBiIuXPnljhBs0OHDjh9+rTSvffeew+rVq0qlxgNQejI+QDY60BUXjZs2Ij//S9/WHfq1CmYMIFDvFIy1DkPffv2RXBwMBwcHNCjRw/4+vrC3d0dVlZWSEpKwpUrV/Dzzz/j8OHD6NatG+bPn69S+yonDx9++CG++eYbBAQEwMXFBTJZxbxxAQEB+OSTT+Dm5ob4+Hh89NFH6NOnD6KiokqsN3LkSHz++eeKz62trcs7VL21f2ckYmNvAwAGDeshcTREhue7777H8OH5q5c+/PB/mD59qsQRkaEaPnw4Bg0ahN27d2Pnzp1YvXo1kpOTAQAymQyvvPIKgoKC8Pvvv6u1n4jKycPmzZuxZ88edO3aVeWHaeL5CZienp6YPHkyevXqhdzc3BLPtbe2toarq2tFhKj3Dmz5CebCEh61XeDr30DqcIgMyuHDRzBgwGDI5XKMGPEOFi1aUGF/fFHxDHmTKEtLSwwaNAiDBuUPQScnJyMzMxNVq1Yt8fdmWag858HBwUHy7VKfPHmCrVu3onXr1qW+AVu3boWTkxMaNmyIsLAwZGRklFg+OzsbKSkpSpcxuH45DmcirsJOVhnf7pghdThEBuX06R8RHPwWcnNz0a/fW1i1agUTBx1hqHMeiuLg4KBYvqkplZOH6dOnY8aMGYoDNyrSpEmTYGNjg6pVqyIuLg779+8vsfyAAQOwZcsWREREICwsDJs3b1ZkYMWZPXs2HBwcFJeHh4c2X4LOWj13LwAgqLcf6jYwjtdMVBHOnDmD7t17IisrC927d8PmzRu0djgRkVRkQqi2P1ZmZibefPNN/PLLL6hVq1ahDOb8+fNlbmvy5MmYO3duiWWuXr0Kb29vAPnH1D558gR3797FjBkz4ODggIMHD5Y5gz916hQ6duyIGzduoE6dOkWWyc7OVtquMyUlBR4eHkhOToa9vX0ZX5l+uXHlbwT7TcqfDPvrHLzcsKbUIREZhEuXLqF9+45ISkrCa68F4NChH2BlZSV1WDovJSUFDg4O5fpzt+AZh1t2g42Z+n+Jpz/LRdczhwz6d0RRVJ7zMGTIEJw7dw6DBg3SeMLkhAkTMHTo0BLLPD9E4uTkBCcnJ7z88suoX78+PDw88Ouvv5Z5e00/Pz8AKDF5sLS0hKWlZdlegIFYM38fhBDo+EYLJg5EWvLXX3+hU6cuSEpKQqtWfti/fw8TBx0kIIOABqstNKirz1ROHg4dOoRjx46hbdu2Gj/c2dlZ7W2sC5aIqnKoR0xMDADAzY1HSxe4ff0+jn2fvwnYe5PflDgaIsMQFxeHwMDOSExMRJMmjXH48AHY2tpKHRaR1qg858HDw6PCu2Z+++03LFu2DDExMbh79y5OnTqF/v37o06dOopeh/j4eHh7e+PMmTMAgJs3b2LmzJk4d+4c7ty5gx9++AEhISF49dVX0bhx4wqNX5etmb8PcrlA+67N4N24ltThEOm9xMREBAZ2RlxcHOrVq4fjx4/A0dFR6rCoGMYwYTIiIqLYr33zzTdqtaly8rBw4UJ8/PHHuHPnjloPVIe1tTX27NmDjh07ol69ehg+fDgaN26M06dPK4YYcnNzERsbq1hNYWFhgZMnT+L111+Ht7c3JkyYgODgYBw4cKDC4tZ1Z09fxcHtPwMA3v24l7TBEBmAU6ci0KpVW/z111/w9PTEiRNHUK1aNanDohIULNXU5NJ1nTt3xsSJE5Gbm6u49/jxY/To0QOTJ09Wq02VJ0w6OjoiIyMDz549g7W1daEJk0+ePFErEF1VERN3pNLf71P8+edtOFetjPC7K6QOh0iv5ebmwsWlOpKSkmBjY4OYmLN46aWXpA5LL1XkhMn9zXtqPGGy57n9Ov07IioqCiEhIbC1tcW2bdtw+/ZtDB8+HPXq1cOmTZvg6empcpsqz3lYsmSJyg8h3fPw7ydIuvYU9qISxs14W+pwiPRecnKyYl+YzZs3MHEgndG6dWvExMRg1KhRaNasGeRyOWbOnImPP/5Y7UUPaq22IP23e8lJ5D2To9WrDfHG0FelDodI723dug15eXlo0qQJ3nyzl9ThUBnJoeEOk3qy2uL69es4e/YsatSogfv37yuG+dU9rrtMcx7S09NValTV8lSxkh6m4MiG/LkOAyZ2ljgaIsOwfv1GAMDIke9IHAmpwhgmTM6ZMwf+/v7o1KkTLl++jDNnzuDChQto3LgxoqOj1WqzTMnDSy+9hDlz5uDBgwfFlhFC4MSJE+jSpQu+/vprtYKhirFn2SlkZ+bC27cWfAK8pQ6HSO9duHABf/xxERYWFujfn8OApFu++uor7Nu3D0uXLoWVlRUaNmyIM2fOoHfv3ujQoYNabZZp2CIyMhKffPIJpk+fjiZNmhR5tGd0dDTMzMwQFhaG9957T61gqPylJqXjh9X5x5T3/7gz99cn0oKCXoc33+yFKlWqSBwNqUIOmUZDD/owbHHp0iU4OTkp3TM3N8f8+fPRvXt3tdosU/JQr149fP/994iLi8Pu3bvx008/ISoqCpmZmXBycoKPjw/WrFmDLl26cM92HbdvVSQyUrPg1bA6WnVpJHU4RHovOzsbW7duBwAMG8Y5YXpH06EHPRi2eDFxeF779u3ValOlCZM1a9bEhAkTMGHCBLUeRtJKepiCPcvCAQD9J3aGiYnK23wQ0Qt++OEAnjx5gho1aiAwsKPU4RAVEhAQUGIv86lTp1RuU+XVFqS/5n2wCWlPM2Ff1Qbt3mwmdThEBqFgyCIkZBB7XvWQphs96cMmUU2bNlX6PDc3FzExMbh8+bLaKyiZPBiJzPRsnAu/CgDw69YIpqbsdSDSVHx8PI4dOw4AGDo0ROJoSB2arpjQh9UWixcvLvL+9OnTkZaWplab/A1iJPZ+G4nU7CzYuNjgfws5G5xIGzZv3gq5XI62bdugbt26UodDpJJBgwZh3bp1atVlz4MRyEzPxpbFRwEAI6b3gpW1cR05TlQehBCKIQtOlNRf8n8vTerrq+joaLWPiWfyYAT2fhuJpIcpqF7bGZ37t5I6HCKDEB0djevXr8Pa2hp9+/aROhxSk1TDFsuXL8f8+fORkJCAJk2aYOnSpWjZsmWx5Z8+fYpPP/0Ue/bswZMnT+Dp6YklS5aga9eupT6rd+/eL8Qs8ODBA5w9exafffaZWvGXediiY8eO2LNnT7Fff/z4Mby8vNQKgsrP870OQyd1h5k580UibSjodejbNxh2dnYSR0PqkgtNT9ZU/Zk7d+5EaGgopk2bhvPnz6NJkyYICgrCw4cPiyyfk5ODTp064c6dO/juu+8QGxuLNWvWoHr16mV6noODg9JVpUoVdOjQAYcPH8a0adNUfwFQoechIiICp0+fxqeffooZM2YU+npeXh7u3r2rVhBUftjrQKR96enp2LlzNwBg2LCh0gZDemfRokUYOXIkhg0bBgBYtWoVDh06hHXr1hV5RPa6devw5MkTREVFKU6yrlWrVpmft379eq3E/TyVJkyuXLkSS5YswZtvvsnzK/QAex2Iysf33+9BamoqvLy88Oqr7aQOhzQgINP4AvKP+H7+ys7OLvJ5OTk5OHfuHAIDAxX3TExMEBgYWOw5Ez/88AP8/f0xevRouLi4oGHDhpg1axby8vK0/4aUkUrJQ8+ePfHrr7/izz//RKtWrXDr1q3yiou0YPmkXex1ICoHz0+U5Bbv+k2zIYv/9ojw8PBQGhqYPXt2kc97/Pgx8vLy4OLionTfxcUFCQkJRda5desWvvvuO+Tl5eHw4cP47LPPsHDhQnzxxRfFvi5HR0dUqVKlTJc6VP5TtH79+vj999/Rv39/tGjRAjt37lTKoEg3PH2Uin0b8s+wCOrrx14HIi25desWIiNPQyaTYciQwVKHQzri3r17sLe3V3xuaam9VW1yuRzVqlXD6tWrYWpqiubNmyM+Ph7z588vds7CkiVLtPb8oqj1G8XBwQGHDh1CWFgYunbtirlz52LAgAHajo00cGjNjzAVMpiamSBkUumzcYmobDZu3AwACAzsCA8PD4mjIU3lT5jUrD4A2NvbKyUPxXFycoKpqSkSExOV7icmJsLV1bXIOm5ubjA3N1fawbR+/fpISEhATk4OLCwsCtVRd+fIsirzsMWLXXMymQxz5szBpk2b8Nlnn2HEiBFaD47Uk5vzDBFbfoOjqRXGffEWLCtxXwcibZDL5YrkgXs7GAZtzXkoKwsLCzRv3hzh4eGKe3K5HOHh4fD39y+yTps2bXDjxg3I5f/tKnH9+nW4ubkVmTgUmDp1KjIyMhSfJyUlqRRrScqcPAhRdGr29ttv4+eff8alS5e0FhRp5sfdZ/H47yQ4utij+7vqnZhGRIVFRETi7t27cHBwQK9ePaUOh/RUaGgo1qxZg40bN+Lq1at4//33kZ6erlh9ERISgrCwMEX5999/H0+ePMG4ceNw/fp1HDp0CLNmzcLo0aNLfM6XX36ptP20p6en1uYqqrRUs7iJFU2bNsW5c+dw6NAhrQRF6svLk2PPohMAgJ5jX4OFlbnEEREZjvXrNwAA+vfvh0qVKkkbDGmFFAdj9evXD48ePcLUqVORkJCApk2b4ujRo4pJlHFxcUqnHnt4eODYsWMYP348GjdujOrVq2PcuHGYNGlSic958Y/+4joB1CET2mzNAKWkpMDBwQHJycllGs+SWtS+C5gXsg62la2x5s8ZqGSn3tajRKQsOTkZrq41kJWVhd9++6XE3QBJMxXxc7fgGWvqD4C1afFd/6XJyMvByKvbdPJ3hImJCRISElCtWjUAgJ2dHf744w+tbOjIKfgGRAiB7xbmn/DXbVR7Jg5EWrRjx05kZWXhlVdeQYsWLaQOh6hUMpkMqampsLKyghACMpkMaWlpSElJUSqnTtLD5MGAXDh5Fbf++BtWNhbo9h7nOhBpE/d2MEwCMshVnPT4Yn1dJYTAyy+/rPS5j4+P0ucymUytzaaYPBiQgl6HoHfawr6qjcTREBmOq1ev4rffzsDU1BSDBnFZuiGR6mCsihAREVFubTN5MBAXDsfgStRNmFmYoeeY16QOh8igFPQ6dO3apdi1+KSfpJgwWVHaty+/HmiVtqcm3bUxdBsAwD+wLqq4OUgcDZHhePbsGTZv3goAeOedodIGQ6Qj2PNgAO5FXUFiYjpkkKHnmACpwyEyKEePHkNCQgKcnZ3RrRt3azU04t9Lk/rGiMmDAbi19Ri61ciAWfMmeKltfanDITIoBUMWgwYNUByHTIbDkIctyhOHLfTcP5du4f5PF2FmZoJun/eXOhwig/Lo0SMcOHAQALejJnoekwc9d3nVfgBAre6tYVfTpZTSRKSKrVu3ITc3F82bN0OjRo2kDofKgVwLl6575513kJqaWuh+eno63nnnHbXaZPKgxwp6HWSmJmgwsrvU4RAZFCGE0t4OZJgKlmpqcum6jRs3IjMzs9D9zMxMbNq0Sa02OedBj7HXgaj8XLhwARcvXoKFhQX6939b6nCIVJaSkgIhBIQQip0mC+Tl5eHw4cOKratVxeRBT7HXgah8FfQ69OrVs9hDAUn/GfKEycqVK0Mmk0EmkyntNFlAJpNhxowZarXN5EFP/TFnLQD2OhCVh+zsbGzbtgMAhywMnSEv1YyIiIAQAq+99hq+//57pSTYwsICnp6ecHd3V6ttJg96KOHICSReug9AoP6QTlKHQ2RwfvjhAJ48eYLq1aujU6dAqcMhUkvBDpO3b9+Gh4eH0jHfmmLyoIeST/4AK/NsVKlTBQ4v1ZQ6HCKDM3HiJABA3759YGpqKnE0VJ4MediigKenJwAgIyMDcXFxyMnJUfp648aNVW6TyYOeyY27AZsH0WheT4aq09SbJUtExbt79y7u3o0DAPTr11fiaKi8abrcUh+Waj569AjDhg3DkSNHivy6OqdqcqmmnknZvw4AYOPXETb1uJskkbbJZP/9WPT1bS5hJFQRjGGp5ocffoinT5/it99+Q6VKlXD06FFs3LgRdevWxQ8//KBWm+x50CO5D+KQ+etJAIBdL/U29iCikuXm5nfp2trawsyMPyJJ/506dQr79++Hr68vTExM4OnpiU6dOsHe3h6zZ89Gt27dVG6TPQ96JPXABkDIYeXTDhaehZfdEJHmnj59CiB/mRsZPgHNdpfU5dUWBdLT0xX7OTg6OuLRo0cAgEaNGuH8+fNqtcnkQU88e/QAGT8dAsBeB6Ly9PRpMgCgcmUebW8MBDQctoDuD1vUq1cPsbGxAIAmTZrgm2++QXx8PFatWgU3Nze12mSfnJ5IPbgJyMuDZYMWsKzLPfaJygt7HsjQjBs3Dg8ePAAATJs2DZ07d8bWrVthYWGBDRs2qNUmkwc9kHHrFtJO7oEMgF2v4VKHQ2TQmDwYF7nIvzSpr+sGDRqk+Lh58+a4e/curl27hpo1a8LJyUmtNjlsoQfil82HTOQh06QKLF/h7G+i8pSU9BQAhy2MhdDCpS9ycnIQGxsLCwsLNGvWTO3EAWDyoPOyn6bh7oUkpKRbw6bzIMhkuj++RqTP2PNAhiYjIwPDhw+HtbU1GjRogLi4/H1Mxo4dizlz5qjVJpMHHXdj23E8TbLE/Uod4DpgUOkViEgjTB6MS8EOk5pcui4sLAx//PEHIiMjlU7WDAwMxM6dO9Vqk3MedFhuWiZubD8BAPAe3kOr+5ITUdGYPBgXY9hhct++fdi5cydatWql1HvdoEED3Lx5U602+dtIh93cFY7c1AzY1XZD9Y6c60BUEbhUkwzNo0ePFPs8PC89PV3toXAmDzrqWWY2/tp8FADg/U53yNjrQFQhCnoeHB0dpQ2EKoQxbE/t6+uLQ4cOKT4vSBi+/fZb+Pv7q9Umhy101O29p5GdlAprdyd4dG4ldThERuO/nofK0gZCFcIYhi1mzZqFLl264MqVK3j27Bm++uorXLlyBVFRUTh9+rRabfLPWR2Ul5OL6xsOA8jvdTAxZ45HVFH+m/PAYQtjIITml65r27YtYmJi8OzZMzRq1AjHjx9HtWrVEB0djebN1RsS528lHbQj7CtYPkyCmaMtPN9oK3U4REYlKSkJAHseyLDUqVMHa9as0Vp7TB50TE52NtJOnIeliTme1HWBqYW51CERGY2cnBxkZGQAYPJgLOSQQa7B+RSa1C1vKSkpZSpnb2+vcttMHnTM7l2HsPDOZfRwr4Vps/8ndThERiU5OVnxsTo/UEn/GPL21JUrVy5xNYUQAjKZDHl5eSq3zeRBh+Tl5WH+3JW4n5OJGiO7w75qZaWvCyHw8OEjuLgUXnJDRJormO9gZ2cHMzP+eCT9FhERofhYCIGuXbvi22+/RfXq1TVum/936JDvdx/CjRt3UKWqI0a+N1DpaxERP2Lq1C/w+PE/uHTpN/5gIyoH3CDKCGk66VGHex7at2+v9LmpqSlatWoFLy8vjdvmagsdkZeXh7lzVgAAxowdCltbGwBAdPQZdOrUA4GBPRAV9Rvi4v7GhQt/SBkqkcHiBlHGp2DOgyaXMWLyoCP27T2G2Gs3UbmyPd57fzAuXPgD3bv3Rdu2nXDq1I8wNzfH6NHv4saNP9CiBXebJCoP7HkgKhv2fesAuVyOef/2OvTt1w0jRnyAPXt+AJDfzTR06EB8+ulEeHrWlDJMIoPH5MH4aLpXgz7s8/A8bZ3MzORBBxw8cBJ/Xo6FmZkpli5fCiHkkMlk6N+/L6ZOnYy6detIHSKRUeCwhfEx5B0me/furfR5VlYWRo0aBRsbG6X7e/bsUbltJg8Si4+/j9HvhwEAMrNTIIQcvXu/genTP0GDBvUljo7IeAghkJiYCIA9D2QYHByUk+BBgwZprW0mDxI7Ff4Lkp7kJw0dAvwwe840NGvWVOqwiIxORkYGFi5cDACF/jIjw2XI+zysX7++3Npm8iCxQYP7ICrqV1St4owvZk2WOhwiQuG/2MhwCWi22lKHc4dyxeRBYjKZDCtXLZQ6DCJ6TmDga1KHQBUkv+dBg+2pjTR74FJNIqIX1K/P+UZEJWHPAxERGS1jW6qpLUweiIjIaBnyUs3yxGELIiKiCrZ8+XLUqlULVlZW8PPzw5kzZ8pUb8eOHZDJZOjVq1f5BlgKJg9ERGS0CoYtNLlUtXPnToSGhmLatGk4f/48mjRpgqCgIDx8+LDEenfu3MFHH32Edu3aqflqtUfvkofs7Gw0bdoUMpkMMTExJZbNysrC6NGjUbVqVdja2iI4OFixCQwREZFcC5eqFi1ahJEjR2LYsGF45ZVXsGrVKlhbW2PdunXF1snLy8PAgQMxY8YMrZyKqSm9Sx4+/vhjuLu7l6ns+PHjceDAAezevRunT5/G/fv3C23XSUREpKmUlBSlKzs7u8hyOTk5OHfuHAIDAxX3TExMEBgYiOjo6GLb//zzz1GtWjUMHz5c67GrQ6+ShyNHjuD48eNYsGBBqWWTk5Oxdu1aLFq0CK+99hqaN2+O9evXIyoqCr/++msFREtERLpOiP92mVTnKhi28PDwgIODg+KaPXt2kc97/Pgx8vLy4OLionTfxcUFCQkJRdb5+eefsXbtWqxZs0arr10TerPaIjExESNHjsS+fftgbW1davlz584hNzdXKbvz9vZGzZo1ER0djVatWpVnuEREpAe0tcPkvXv3YG9vr7hvaWmpSVgKqampGDx4MNasWQMnJyettKkNepE8CCEwdOhQjBo1Cr6+vrhz506pdRISEmBhYVHogJuSsjsgf07F891NKSkp6oZNRHpEPDfzTRjr4n1Sm729vVLyUBwnJyeYmpoWmn+XmJgIV1fXQuVv3ryJO3fuoEePHop7cnn+TAszMzPExsaiTp2KP3lZ0mGLyZMnQyaTlXhdu3YNS5cuRWpqKsLCwso9ptmzZyt1PXl4eJT7M4lIehkZmTAxsYaJiTUyMjKlDocqiCZDFuocqmVhYYHmzZsjPDz8vxjkcoSHh8Pf379QeW9vb1y6dAkxMTGK64033kBAQABiYmIk+x0lac/DhAkTMHTo0BLLeHl54dSpU4iOji7UDeTr64uBAwdi48aNheq5uroiJycHT58+Vep9KC67KxAWFobQ0FDF5ykpKUwgiIgMlBQ7TIaGhmLIkCHw9fVFy5YtsWTJEqSnp2PYsGEAgJCQEFSvXh2zZ8+GlZUVGjZsqFS/4Hfai/crkqTJg7OzM5ydnUst9/XXX+OLL75QfH7//n0EBQVh586d8PPzK7JO8+bNYW5ujvDwcAQHBwMAYmNjERcXV2R2V8DS0lJrY1VEpD+srSsV+TEZNil2mOzXrx8ePXqEqVOnIiEhAU2bNsXRo0cVkyjj4uJgYqLb6xn0Ys5DzZo1lT63tbUFANSpUwc1atQAAMTHx6Njx47YtGkTWrZsCQcHBwwfPhyhoaGoUqUK7O3tMXbsWPj7+3OyJBEVIpPJivyYqDyMGTMGY8aMKfJrkZGRJdbdsGGD9gNSkV4kD2WRm5uL2NhYZGRkKO4tXrwYJiYmCA4ORnZ2NoKCgrBixQoJoyQiIl2izryFF+sbI71MHmrVqlVoNnRR96ysrLB8+XIsX768IsMjIiI9oa2lmsZGtwdViIiISOfoZc8DERGRNnDYQj1MHoiIyGhJsVTTEHDYgoiIiFTCngciIjJaUuzzYAiYPBARgWdbGCs5NJzzoLVI9AuHLYiIkH+2haWZIyzNHHm2BVEp2PNARERGi/s8qIfJAxERAGtr6yI/JsMmhGZDD8Y6wsXkgYgIPNvCWAmhYc+DkSYPnPNAREREKmHPAxERGS0u1VQPkwciIjJacgHINRi4MNbtqTlsQURERCphzwMRERktLtVUD5MHIiJwh0ljJddwqSaHLYiIjFhGRiZkMlPIZKbcYZKoFOx5ICIioyX+/UeT+saIyQMREQBr60pFfkyGjcMW6uGwBRERuMMkkSrY80BEREaLm0Sph8kDEREZLSE0nPNgpCtzmDwQEZHRYs+DejjngYiIiFTCngciIvzbff1vF7SxdkUbIw5bqIfJAxER8jeJypNnKT62tbWROCKqCAKaDT0YZ+rAYQsiIiJSEXseiIjATaKMlVwIDY/kNs6+ByYPRETgJlHGittTq4fDFkRERKQS9jwQEZHR4j4P6mHyQERERksODec8cNiCiIiIqHTseSAiIqPF1RbqYfJARATlnQKNdddAY8TVFuph8kBEhPxdJU1NLBQfc4dJ48A5D+rhnAciIiJSCXseiIjAHSaNFXse1MPkgYgI3GHSWHHOg3o4bEFEREQqYc8DEREZLaHhsIWx9jwweSAiIqMll8khk6m/ybTcSDeo5rAFERERqYQ9D0REZLTkEJBxtYXK2PNARATuMGmshGKxpvqXOpYvX45atWrBysoKfn5+OHPmTLFl16xZg3bt2sHR0RGOjo4IDAwssXxFYPJARIT8XSWL+phI23bu3InQ0FBMmzYN58+fR5MmTRAUFISHDx8WWT4yMhL9+/dHREQEoqOj4eHhgddffx3x8fEVHPl/mDwQEZHRkgMV3u+waNEijBw5EsOGDcMrr7yCVatWwdraGuvWrSuy/NatW/HBBx+gadOm8Pb2xrfffgu5XI7w8HCNXrsmOOeBiAjcYdJYaWu1RUpKitJ9S0tLWFpaFiqfk5ODc+fOISwsTHHPxMQEgYGBiI6OLtMzMzIykJubiypVqqgdt6bY80BEBO4waazkWvgHADw8PODg4KC4Zs+eXeTzHj9+jLy8PLi4uCjdd3FxQUJCQplinjRpEtzd3REYGKjZi9cAex6IiIg0dO/ePdjb2ys+L6rXQRvmzJmDHTt2IDIyElZWVuXyjLJg8kBEREZLDjlkGmz0VNDzYG9vr5Q8FMfJyQmmpqZITExUup+YmAhXV9cS6y5YsABz5szByZMn0bhxY7Vj1gYOWxARkdGq6KWaFhYWaN68udJkx4LJj/7+/sXWmzdvHmbOnImjR4/C19dX7derLex5ICIiqkChoaEYMmQIfH190bJlSyxZsgTp6ekYNmwYACAkJATVq1dXzJuYO3cupk6dim3btqFWrVqKuRG2trawtbWV5DUweSAiAjeJMlZSnG3Rr18/PHr0CFOnTkVCQgKaNm2Ko0ePKiZRxsXFwcTkv4GBlStXIicnB3369FFqZ9q0aZg+fbrasWuCyQMREfI3hpLJTBUf29raSBwRVQTx3IoJdeurY8yYMRgzZkyRX4uMjFT6/M6dO2o9ozxxzgMRERGphD0PRETgJlHGSiAPQoO/owXytBiN/mDyQEQEbhJlrOT/blCtWX3jw2ELIiIiUgl7HoiIyGjJIaBZz4Nxrsxh8kBEREYrf86D+sNUnPNARERkZDjnQT2c80BEREQqYc8DERHyd5WU/fv3FHeYNB7qnE/xYn1jxOSBiAhAVkYOPMyaKD7mDpPGQY48QIM5D3IjnfPAYQsiIiJSCXseiIgAVLK2KvJjMmwctlAPkwciInCHSWMlFxoOWwgOWxARERGVij0PRERktDhsoR4mD0REZLTykwf1hx6MNXnQu2GL7OxsNG3aFDKZDDExMSWW7dChA2QymdI1atSoigmUiIjIQOldz8PHH38Md3d3/PHHH2UqP3LkSHz++eeKz62trcsrNCIi0jNCyCHX5GwLYZw9D3qVPBw5cgTHjx/H999/jyNHjpSpjrW1NVxdXcs5MiLSd0IIWJnKFR+TccgfdtDkYCwmDzotMTERI0eOxL59+1TqPdi6dSu2bNkCV1dX9OjRA5999lmJ9bOzs5Gdna34PCUlRaO4iUhP5GThWPB1xcdAJUnDoYohNFxqqWl9faUXyYMQAkOHDsWoUaPg6+uLO3fulKnegAED4OnpCXd3d1y8eBGTJk1CbGws9uzZU2yd2bNnY8aMGVqKnIiIyPBImjxMnjwZc+fOLbHM1atXcfz4caSmpiIsLEyl9t99913Fx40aNYKbmxs6duyImzdvok6dOkXWCQsLQ2hoqOLzlJQUeHh4qPRcItI/lawtkP7cx2Qc8mc8cNhCVZImDxMmTMDQoUNLLOPl5YVTp04hOjoalpaWSl/z9fXFwIEDsXHjxjI9z8/PDwBw48aNYpMHS0vLQs8hIsPHHSaNU/6ER06YVJWkyYOzszOcnZ1LLff111/jiy++UHx+//59BAUFYefOnYqEoCwKlna6ubmpHCsRERHl04s5DzVr1lT63NbWFgBQp04d1KhRAwAQHx+Pjh07YtOmTWjZsiVu3ryJbdu2oWvXrqhatSouXryI8ePH49VXX0Xjxo0r/DUQEZHu0WSDKG3U11d6kTyURW5uLmJjY5GRkQEAsLCwwMmTJ7FkyRKkp6fDw8MDwcHBmDJlisSREhGRrshflqvB9tRGuqxXL5OHWrVqFfoP9uI9Dw8PnD59uqJDIyIiMnh6mTwQERFpg6arJbjagoiIyMjkb/Kk/tCDsa620LuDsYiIiEha7HkgIiKjpWnPgbH2PDB5ICIio8U5D+ph8kBEREaLPQ/q4ZwHIiIiUgl7HoiIAMCiEpxXnlF8TMaBwxbqYfJARIR/D8OytJY6DKpgXKqpHg5bEBERkUrY80BEREZMs7MtNOm10GdMHoiIyGjlDzvINKhvnMkDhy2IiIhIJex5ICIio5W/WkKDngcOWxARERkbzZIHY53zwGELIiIiUgl7HoiIyHhpOGESRjphkskDEREZLc55UA+HLYiIyIjJtXCpbvny5ahVqxasrKzg5+eHM2fOlFh+9+7d8Pb2hpWVFRo1aoTDhw+r9VxtYfJARERUgXbu3InQ0FBMmzYN58+fR5MmTRAUFISHDx8WWT4qKgr9+/fH8OHDceHCBfTq1Qu9evXC5cuXKzjy/8iEse5wUUYpKSlwcHBAcnIy7O3tpQ6HiMjgVcTP3YJnAGaQaTxs8UylWP38/NCiRQssW7YMACCXy+Hh4YGxY8di8uTJhcr369cP6enpOHjwoOJeq1at0LRpU6xatUrt2DXBngciIjJiQqN/VF2qmZOTg3PnziEwMFBxz8TEBIGBgYiOji6yTnR0tFJ5AAgKCiq2fEXghMlSFHTMpKSkSBwJEZFxKPh5W3Ed45o/58XfEZaWlrC0tCxU7vHjx8jLy4OLi4vSfRcXF1y7dq3IthMSEoosn5CQoGHU6mPyUIrU1FQAgIeHh8SREBEZl9TU1H+HFrTPwsICrq6uWvkFbGtrW+h3xLRp0zB9+nSN29ZVTB5K4e7ujnv37sHOzg4ymSa7kBmvlJQUeHh44N69e5w3oia+h5rje6i5inoPhRBITU2Fu7t7uT3DysoKt2/fRk5OjsZtCSEK/X4oqtcBAJycnGBqaorExESl+4mJiXB1dS2yjqurq0rlKwKTh1KYmJigRo0aUodhEOzt7flDW0N8DzXH91BzFfEellePw/OsrKxgZWVV7s95noWFBZo3b47w8HD06tULQP6EyfDwcIwZM6bIOv7+/ggPD8eHH36ouHfixAn4+/tXQMRFY/JARERUgUJDQzFkyBD4+vqiZcuWWLJkCdLT0zFs2DAAQEhICKpXr47Zs2cDAMaNG4f27dtj4cKF6NatG3bs2IGzZ89i9erVkr0GJg9EREQVqF+/fnj06BGmTp2KhIQENG3aFEePHlVMioyLi4OJyX+LIVu3bo1t27ZhypQp+OSTT1C3bl3s27cPDRs2lOolMHmg8mdpaYlp06YVOwZIpeN7qDm+h5rje6g9Y8aMKXaYIjIystC9vn37om/fvuUcVdlxkygiIiJSCTeJIiIiIpUweSAiIiKVMHkgIiIilTB5ICIiIpUweSCtmTNnDmQymdJGJi/asGEDZDKZ0lXRm7TomunTpxd6T7y9vUuss3v3bnh7e8PKygqNGjXC4cOHKyha3aTqe8jvw6LFx8dj0KBBqFq1KipVqoRGjRrh7NmzJdaJjIxEs2bNYGlpiZdeegkbNmyomGBJUlyqSVrx+++/45tvvkHjxo1LLWtvb4/Y2FjF59z2G2jQoAFOnjyp+NzMrPj/NaOiotC/f3/Mnj0b3bt3x7Zt29CrVy+cP39e0nXfUlPlPQT4ffiipKQktGnTBgEBAThy5AicnZ3x119/wdHRsdg6t2/fRrdu3TBq1Chs3boV4eHhGDFiBNzc3BAUFFSB0VNFY/JAGktLS8PAgQOxZs0afPHFF6WWl8lkku7JrovMzMzK/J589dVX6Ny5MyZOnAgAmDlzJk6cOIFly5Zh1apV5RmmTlPlPQT4ffiiuXPnwsPDA+vXr1fcq127dol1Vq1ahdq1a2PhwoUAgPr16+Pnn3/G4sWLmTwYOA5bkMZGjx6Nbt26FTpvvjhpaWnw9PSEh4cHevbsiT///LOcI9R9f/31F9zd3eHl5YWBAwciLi6u2LLR0dGF3uugoCBER0eXd5g6TZX3EOD34Yt++OEH+Pr6om/fvqhWrRp8fHywZs2aEuvwe9F4MXkgjezYsQPnz59X7MFemnr16mHdunXYv38/tmzZArlcjtatW+Pvv/8u50h1l5+fHzZs2ICjR49i5cqVuH37Ntq1a6c4Dv5FCQkJim1sC7i4uGjlaGF9pep7yO/Dwm7duoWVK1eibt26OHbsGN5//33873//w8aNG4utU9z3YkpKCjIzM8s7ZJKSIFJTXFycqFatmvjjjz8U99q3by/GjRtX5jZycnJEnTp1xJQpU8ohQv2UlJQk7O3txbffflvk183NzcW2bduU7i1fvlxUq1atIsLTC6W9hy/i92H+95W/v7/SvbFjx4pWrVoVW6du3bpi1qxZSvcOHTokAIiMjIxyiZN0A3seSG3nzp3Dw4cP0axZM5iZmcHMzAynT5/G119/DTMzM+Tl5ZXahrm5OXx8fHDjxo0KiFg/VK5cGS+//HKx74mrqysSExOV7iUmJnL8/jmlvYcv4vch4ObmhldeeUXpXv369Usc/inue9He3h6VKlUqlzhJNzB5ILV17NgRly5dQkxMjOLy9fXFwIEDERMTA1NT01LbyMvLw6VLl+Dm5lYBEeuHtLQ03Lx5s9j3xN/fH+Hh4Ur3Tpw4AX9//4oITy+U9h6+iN+HQJs2bZRWnwDA9evX4enpWWwdfi8aMam7PsiwvDhsMXjwYDF58mTF5zNmzBDHjh0TN2/eFOfOnRNvv/22sLKyEn/++acE0eqGCRMmiMjISHH79m3xyy+/iMDAQOHk5CQePnwohCj8Hv7yyy/CzMxMLFiwQFy9elVMmzZNmJubi0uXLkn1EiSn6nvI78PCzpw5I8zMzMSXX34p/vrrL7F161ZhbW0ttmzZoigzefJkMXjwYMXnt27dEtbW1mLixIni6tWrYvny5cLU1FQcPXpUipdAFYhLNalcvXgufVJSEkaOHImEhAQ4OjqiefPmiIqKKtRdakz+/vtv9O/fH//88w+cnZ3Rtm1b/Prrr3B2dgZQ+D1s3bo1tm3bhilTpuCTTz5B3bp1sW/fPqPe40HV95Dfh4W1aNECe/fuRVhYGD7//HPUrl0bS5YswcCBAxVlHjx4oDSMUbt2bRw6dAjjx4/HV199hRo1auDbb7/lMk0jwCO5iYiISCWc80BEREQqYfJAREREKmHyQERERCph8kBEREQqYfJAREREKmHyQERERCph8kBEREQqYfJAREREKmHyQGRg/vnnH1SrVg137tzRqJ23334bCxcu1E5QRGRQmDwQ6aChQ4dCJpNBJpPB3NwctWvXxscff4ysrKxS63755Zfo2bMnatWqpVEMU6ZMwZdffonk5GSN2iEiw8PkgUhHde7cGQ8ePMCtW7ewePFifPPNN5g2bVqJdTIyMrB27VoMHz5c4+c3bNgQderUwZYtWzRui4gMC5MHIh1laWkJV1dXeHh4oFevXggMDMSJEydKrHP48GFYWlqiVatWinuRkZGQyWQ4duwYfHx8UKlSJbz22mt4+PAhjhw5gvr168Pe3h4DBgxARkaGUns9evTAjh07yuX1EZH+YvJApAcuX76MqKgoWFhYlFjup59+QvPmzYv82vTp07Fs2TJERUXh3r17eOutt7BkyRJs27YNhw4dwvHjx7F06VKlOi1btsSZM2eQnZ2ttddCRPqPR3IT6aiDBw/C1tYWz549Q3Z2NkxMTLBs2bIS69y9exfu7u5Ffu2LL75AmzZtAADDhw9HWFgYbt68CS8vLwBAnz59EBERgUmTJinquLu7IycnBwkJCfD09NTSKyMifcfkgUhHBQQEYOXKlUhPT8fixYthZmaG4ODgEutkZmbCysqqyK81btxY8bGLiwusra0ViUPBvTNnzijVqVSpEgAUGs4gIuPGYQsiHWVjY4OXXnoJTZo0wbp16/Dbb79h7dq1JdZxcnJCUlJSkV8zNzdXfFywiuN5MpkMcrlc6d6TJ08AAM7Ozuq8BCIyUEweiPSAiYkJPvnkE0yZMgWZmZnFlvPx8cGVK1e09tzLly+jRo0acHJy0lqbRKT/mDwQ6Ym+ffvC1NQUy5cvL7ZMUFAQ/vzzz2J7H1T1008/4fXXX9dKW0RkOJg8EOkJMzMzjBkzBvPmzUN6enqRZRo1aoRmzZph165dGj8vKysL+/btw8iRIzVui4gMi0wIIaQOgoi059ChQ5g4cSIuX74MExP1/z5YuXIl9u7di+PHj2sxOiIyBFxtQWRgunXrhr/++gvx8fHw8PBQux1zc/NC+z4QEQHseSAiIiIVcc4DERERqYTJAxEREamEyQMRERGphMkDERERqYTJAxEREamEyQMRERGphMkDERERqYTJAxEREamEyQMRERGp5P9LB+m1m4/4uQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -445,7 +437,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -455,7 +447,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -465,7 +457,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -475,7 +467,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -485,7 +477,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg8AAAHHCAYAAAA4drvmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABi1UlEQVR4nO3dd1xVdR8H8M9lCwgOkKGIYirmAkURN4niyJFmblxZlprrScVMXDlylotybyln7oGgKZg5SE3FVBRCASd73/P8Qdy6Mu+Ac8fn/bzO67n33PP7ne+9gffLb0oEQRBAREREVEoGYgdARERE2oXJAxERESmEyQMREREphMkDERERKYTJAxERESmEyQMREREphMkDERERKYTJAxERESmEyQMREREphMkDERERKYTJA+m8sLAwzJkzB2/evCn3ewcHB2PUqFGoV68ezM3N4eLigo8//hjPnj0rVfkDBw5gwIABcHFxgbm5OerXr4+pU6cWeC8vX77E0qVL0b59e9ja2qJSpUpo1aoVgoKCyuBdlUwqleLbb79F7dq1YWZmhiZNmmDPnj0Frtm6dSt69eoFJycnWFhYoFGjRliwYAEyMjJEiZuISkfCvS1I1y1btgxffvkloqKiUKtWrXK9t4eHB169eoX+/fujbt26ePToEdasWQNzc3NERETA3t6+2PI2NjZwdHREnz59ULNmTdy6dQuBgYFwcXHB9evXUaFCBQDA0aNH0bdvX3Tv3h3e3t4wMjLC/v37ERISgtmzZ2Pu3Lnl8XZl/P39sXjxYowZMwYtWrTA4cOHcezYMezZswcDBw4EAKSkpKBixYpo1aoV3n//fVSrVg3h4eHYtm0b2rdvj3PnzkEikZRr3ERUSgKRjlu6dKkAQIiKiir3e58/f17Izc0tcA6A8NVXX5VYPiQkpMC5bdu2CQCEDRs2yM49evRIePz4sdx1UqlUeO+99wRTU1MhJSVFuTfwloCAAMHZ2bnYa/7++2/B2NhYGDdunFws7dq1E2rUqCHk5OQIgiAImZmZwqVLlwqUnzt3rgBAOHPmjFpiJiL1Y7cF6bQ5c+bgyy+/BADUrl0bEokEEokEjx8/Lpf7t2/fHgYGBgXOValSBXfv3i2xfMeOHQuc++CDDwBArnzt2rXh7Owsd51EIkGfPn2QmZmJR48eyb0WGxuLUaNGwc7ODqampmjYsCE2b95c2rdVrMOHDyM7Oxuff/65XCyfffYZ/v77b4SHhwMATExM0Lp161K9v6KcOXMGbdu2RaVKlWBpaYn69etj5syZankfRFQ0I7EDICpLffv2xf3797Fnzx6sXLkSNjY2AABbW9siy6SlpSEtLa3Eug0NDVG5cmWFY0pJSUFKSoosFkXFxcUBQKnKF3ZtfHw8WrVqBYlEgvHjx8PW1hYnTpzA6NGjkZSUhEmTJikVV74bN27AwsICDRo0kDvfsmVL2ett27ZVKObC/Pnnn3j//ffRpEkTzJs3D6ampnjw4AEuXbqkUvxEVApiN30QlTVFuy0CAgIEACUeJTXfF2X+/PkCACE4OFip8qNHjxYMDQ2F+/fvF3vdy5cvhWrVqgnt2rUrUN7BwUF48eKF3PmBAwcK1tbWQlpaWpF1lqbbokePHoKLi0uB86mpqQIAYcaMGcWW9/HxEaysrITXr18Xe93KlSsFAMLz58+LvY6I1I8tD0Rv8fPzK/Yv43z5gxUVceHCBcydOxcfffQR3nvvPYXL7969G5s2bcK0adNQt27dIq+TSqUYMmQI3rx5g9WrV8vOC4KA/fv346OPPoIgCHjx4oXsNV9fX+zduxfXr19HmzZtAEDudSCvVUYqlRY4X7FiRZiamgIA0tPTZY//y8zMTPZ6URYuXIizZ89i3bp1qFSpUpHXAZC9fvjwYYwcObJA9xARlSGxsxeisibmgMn/unv3rlClShXBzc1NSEpKUrj8hQsXBDMzM8HX11fIzs4u9trPP/9cACBs375d7nx8fHyJLSoHDhyQXV/StfnHli1bZGWUbXnYu3evIJFIhNGjR5fq80hLSxPatGkjABBsbGyEAQMGCEFBQQUGqJJ+O3/+vPD+++8LDg4OAgDh4MGDCtchlUqFpUuXCnXr1hVMTEwER0dHYcGCBeoPVouw5YHoLfljEkpiaGhY7NiJ/4qJiUGXLl1gbW2N48ePo2LFigrF9Mcff6BXr15o1KgR9u3bByOjon91586di3Xr1mHx4sUYNmyY3GtSqRQAMHToUAwfPrzQ8k2aNJE9PnPmjNxr27dvx+nTp7Fz50658w0bNpQ9dnBwQEhICARBkJtqmb+2haOjY4F7njlzBn5+fujRowcCAwOLfG//VaFCBVy4cAEhISE4duwYTp48iaCgILz33ns4ffo0DA0NS1UP6bbU1FQ0bdoUo0aNQt++fZWqY+LEiTh9+jSWLVuGxo0b49WrV3j16pWaI9UyYmcvRGVt2bJloo55ePHiheDq6ipUq1atxHEKhXnw4IFgb28v1KtXT0hISCj22jVr1ggAhEmTJhX6ek5OjlCxYkVh0KBBCschCKUb85Afw59//il3fteuXQIA4cKFC3LnL1++LFhYWAitW7cudrxFaXzzzTec5klFQiEtDxkZGcLUqVMFR0dHwdzcXGjZsqXcFOk7d+4IRkZGwr1798o3WA3HlgfSeRYWFgBQ6hUm1TnmITU1Fd27d0dsbCxCQkKKHacQHR2NtLQ0uLq6ys7FxcWhS5cuMDAwwKlTp4pt6QgKCsIXX3yBIUOGYMWKFYVeY2hoiH79+mH37t24ffs2GjVqJPf68+fPS92aUpTevXtj8uTJWLduHdasWQMgb6xFYGAgqlevLjc98+7du+jRowdq1aqFo0ePKjSO5NWrV6hSpYrcOTc3NwBAZmamSu+B9Mf48eNx584d7N27F46Ojjh48CC6du2KW7duoW7dujhy5AhcXFxw9OhRdO3aFYIgwMfHB99++22Bnz99whUmSef9/vvvaNmyJbp3746BAwfC2NgYPXv2lCUVZalPnz44fPgwRo0aBW9vb7nXLC0t0adPH9nzjh074vz58/jvr6Sbmxv++OMPTJs2DY0bN5Yrb2dnh86dOwMArly5gnbt2sHa2hpLliyBsbGx3LWtW7eGi4sLgLypmp6ennj+/DnGjBmDd999F69evcL169dx9uzZYptj58yZg61bt5a4Tsa0adOwdOlSfPLJJ2jRogUOHTqEY8eOYdeuXRg8eDAAIDk5GQ0bNkRsbCwWLlyI6tWry9VRp04deHl5FXmPSZMm4cKFC+jRowecnZ2RkJCAdevWQSKR4Pbt27C2ti42RtI/EokEBw8elP3eRUdHw8XFBdHR0XLdaT4+PmjZsiUWLlyIsWPHYuvWrXBzc8PSpUuRm5uLyZMno3Llyjh37pxI70QDiNruQVRO5s+fL1SvXl0wMDAo18GTzs7Ope726NChg/D2r2RRZQEIHTp0kF23ZcuWUg9oFIS8gZPjxo0TnJycBGNjY8He3l7o1KmT8OOPPxb7fkrTbSEIgpCbmyssXLhQcHZ2FkxMTISGDRsKO3fulLsmKiqq2JiHDx9e7D2Cg4OF3r17C46OjrJBbIMGDVKqa4j0A97qtjh69KgAQLCwsJA7jIyMhI8++kgQBEEYM2aMAECIjIyUlbt27ZoAQK+7MtjyQEREeuHtloegoCAMGTIEf/75Z4EBtpaWlrC3t0dAQAAWLlyI7Oxs2Wvp6ekwNzfH6dOnZa1/+oZjHoiISC+5u7sjNzcXCQkJaNeuXaHXtGnTBjk5OXj48CHq1KkDALh//z4AFFgSXp+w5YGIiHRWSkoKHjx4ACAvWVixYgW8vb1RpUoV1KxZE0OHDsWlS5ewfPlyuLu74/nz5wgODkaTJk3Qo0cPSKVStGjRApaWlli1ahWkUinGjRsHKysrnD59WuR3Jx4mD0REpLNCQ0MLDFYGgOHDh2Pr1q3Izs7GggULsH37dsTGxsLGxgatWrXC3LlzZYOUnz59igkTJuD06dOwsLBAt27dsHz5cs62EDsIIiIi0h5cDJ6IiIgUwuSBiIiIFMLZFiWQSqV4+vQpKlasKLdOPxERlQ1BEJCcnAxHR8cy3S01IyMDWVlZKtdjYmIi2zVWXzB5KMHTp0/h5OQkdhhERHonJiYGNWrUKJO6MzIyULu2PeLiElWuy97eHlFRUXqVQDB5KEH+7ocxMTGwsrISORoiIt2XlJQEJycnhXefVURWVhbi4hLxOOY7WFmVfk+VtyUlpaOW00RkZWUxeaB/5XdVWFlZMXkgIipH5dFVbGlpCktLU6XL529zr2+YPBARkd4ShBwIQo5K5fURkwciItJbgpALQchVqbw+4lRNIiIiUghbHoiISG9JhRxIVeh6UKWsNmPyQEREeotjHpTDbgsiIiJSCFseiIhIb+UNmFSl5UE/B0wyeSAiIr0lSHMgSFVIHlQoq820otvi8ePHGD16NGrXro0KFSqgTp06CAgIKHFN8o4dO0IikcgdY8eOLaeoiYiIdJNWtDzcu3cPUqkUP/zwA9555x3cvn0bY8aMQWpqKpYtW1Zs2TFjxmDevHmy5+bm5mUdLhERaQshJ+9Qpbwe0orkoWvXrujatavsuYuLCyIjI7F+/foSkwdzc3PY29uXdYhERKSFONtCOVrRbVGYxMREVKlSpcTrdu3aBRsbGzRq1Aj+/v5IS0sr9vrMzEwkJSXJHURERPQvrWh5eNuDBw+wevXqElsdBg8eDGdnZzg6OuLmzZuYPn06IiMjceDAgSLLLFq0CHPnzlVbrMePn4CvbxcYGhqqrU4iIlITaQ4gzVatvB4SteVhxowZBQY0vn3cu3dPrkxsbCy6du2K/v37Y8yYMcXW/8knn8DX1xeNGzfGkCFDsH37dhw8eBAPHz4ssoy/vz8SExNlR0xMjNLv7/jxE+jRoxfatGmPO3fuKF0PERGVjfxuC1UOfSRqy8PUqVMxYsSIYq9xcXGRPX769Cm8vb3RunVr/Pjjjwrfz9PTE0Bey0WdOnUKvcbU1BSmpspvz/pfSUlJsLKywm+/XYG7ewvMnj0L06b9D8bGxmqpn4iIVCTNAaQqtAzracuDqMmDra0tbG1tS3VtbGwsvL290bx5c2zZsgUGBoo3mkRERAAAHBwcFC6rjIEDB6Bt2zYYO3Ycjh07jlmzZmPfvv3YvHkD3N3dyyUGIiIiddOKAZOxsbHo2LEjatasiWXLluH58+eIi4tDXFyc3DWurq64cuUKAODhw4eYP38+rl27hsePH+OXX36Bn58f2rdvjyZNmpRb7DVq1MCRI4ewc+c2VKlSBRERf6BFCy/MmjUbmZmZ5RYHEREVQpqj+qGHtCJ5OHPmDB48eIDg4GDUqFEDDg4OsiNfdnY2IiMjZbMpTExMcPbsWXTp0gWurq6YOnUq+vXrhyNHjpR7/BKJBEOGDMadOzfRv/+HyM3NxTffLIK7ewtcvny53OMhIqJ8uf+u9aDMAf1cnloiCIIgdhCaLCkpCdbW1khMTISVlZVa6jxw4CA+/3wC4uPjIZFIMHnyRMyfP5cLWBERoWz+3S3qHjFRn8Kqoony9SRnwan2D2UaqybSipYHXdO37we4c+cm/PyGQhAErFixCk2aNENo6HmxQyMi0isSaY7Khz5i8iCSKlWqYNu2LTh+/Ahq1KiBhw8fwtvbB599No4LUxERlReOeVAKkweRdevWFX/++Qc+/TRvzYrAwB/RqJEbTp48JXJkRESkbhcuXEDPnj3h6OgIiUSCQ4cOFXv9gQMH0LlzZ9ja2sLKygpeXl44dUr87wcmDxrAysoKgYHrcO7cGbi4uCAmJgbdur2PESNG4dWrV2KHR0Sku8q55SE1NRVNmzbF2rVrS3X9hQsX0LlzZxw/fhzXrl2Dt7c3evbsiRs3bijzbtWGAyZLUB4Dd/4rNTUVX38dgFWrvocgCLC3t8e6davxwQd9yvzeRESaoDwHTMbeG6DygMnqrkFKxSqRSHDw4EH06dNHoXINGzbEgAEDMHv2bIXKqRNbHjSMhYUFVqxYhkuXzsPV1RVxcXHo27c/BgwYjISEBLHDIyIiEUmlUiQnJ5dqY8iyxORBQ3l5eeHGjd8xc+YMGBoa4qeffsa77zbB7t17wMYiIiI1kUoBaa4KhxQACuzGXFaLAC5btgwpKSn46KOPyqT+0mLyoMHMzMzwzTfzceVKGJo2bYKXL19iyBA/9O7dF7GxsWKHR0Sk9dQ1VdPJyQnW1tayY9GiRWqPdffu3Zg7dy5++uknVKtWTe31K4LJgxZo1qwZfv/9MubPnwtjY2McOXIUDRs2xcaNm9gKQUSkCpVaHf45AMTExMjtyOzv76/WMPfu3YuPP/4YP/30E3x8fNRatzKYPGgJY2NjzJo1Ezdu/I6WLVsgMTERY8aMRZcu3RAVFSV2eEREes3KykruUNfuzACwZ88ejBw5Env27EGPHj3UVq8qmDxomYYNGyIs7FcsW/YtzMzMcPZsMBo3dsfq1Wsg/afvjYiISqmcp2qmpKQgIiJCtstzVFQUIiIiEB0dDQDw9/eHn5+f7Prdu3fDz88Py5cvh6enp2xTyMTERLV9BMpg8qCFDA0NMXXqZNy8eR3t27dDamoqvvhiMjp0eA/3798XOzwiIq0hkeaqfCji6tWrcHd3h7u7OwBgypQpcHd3l027fPbsmSyRAIAff/wROTk5GDdunNymkBMnTlTfh6AErvNQgvJe50FRUqkUgYE/YPr0mUhJSYGpqSnmzZuDKVMmwcjISOzwiIgUVp7rPDy77gurisbK15OcDYdmpzT2O6KssOVByxkYGODzzz/D7dsR6NKlMzIzMzF9uj+8vNri1q1bYodHRKTZBBUHSwr6uSU3kwcd4ezsjJMnj2HLlo2oVKkSrl69hubNPTF37nxkZWWJHR4RkUaSSKUqdlvo51gzJg86RCKRYMSI4bhz5yZ69+6F7OxszJkzDx4enrh69arY4RERkY5g8qCDHBwccPDgPuzduws2Nja4des2PD3bYMaMmUhPTxc7PCIizaGmdR70DZMHHSWRSDBgwEe4c+cmBg0aCKlUiiVLlsLNzQOXLl0SOzwiIo1Q3rMtdAWTBx1na2uL3bt34PDhA3BwcMD9+/fRrp03Jk6cjJSUFLHDIyIiLcTkQU/06tUTd+7cxKhRIyAIAr7/fg0aN3ZHcPA5LnFNRPqL3RZKYfKgRypVqoRNmzbg1KnjcHZ2xuPHj+Hj44tazvXx8uVLscMjIip37LZQDpMHPdSlS2fcunUDw4fnLYEaHRMFv2GfsAWCiPQPWx6UwuRBT1WsWBFbt27CN98shIFBBZw5cwlr12wSOywiItICTB703MyZX+Lbb/P2nf/f/2bj+PEzIkdERFR+JFLhn4WilD30s8WWyQNhypTPMXLkYEilUgwdMhY3b94ROyQiovLBbgulMHkgSCQSrF6zGB07tkFKSio+6DMMcXEJYodFREQaiskDAQBMTEwQ9NMm1K1XBzExsejXdzhXoyQi3ceNsZTC5IFkKleuhEOHdqBKlcr4/fcbGDXqC0j1dNMXItIPEkGq8qGPmDyQnLp1XfDTz5tgbGyM/fuOYO7cpWKHREREGobJAxXQvn1rrF+flzQsWrgSO3f+LHJERERlhAMmlcLkgQrlN3wgvpw2AQAw9tOpuHTxN5EjIiIqA1Kp6oceYvJARZo/3x8f9O2BrKwsfPjhSDx8+FjskIiISAMweaAiGRgYYMuW1WjWrAlevnyFPn2G4c2bRLHDIiJSH7Y8KIXJAxXL3NwcBw5uR40ajoi89xcGDRyD7OxsscMiIlKLvFUiVdkYi8kDUaEcHe1x4OB2WFiYIzj4AiZN/IqbaBGRbmDLg1KYPFCpuLk1wo6dgZBIJNiwYTu+/+5HsUMiIiKRMHmgUnv//S5YsiQAADBt2hwcPXpa5IiIiFTElgelMHkghUyc9Ck+/ngYBEHAsKFjERFxW+yQiIiUx+RBKUweSCESiQTffb8Q773XDqmpaWjXthsuXgwTOywiIipHTB5IYcbGxtizdwMsLMyQmZmNTz+dLHZIRETK4cZYSmHyQEqpXLkSvvv+G0ilmYiO/gvJyclih0REpLC8qZqqHfqIyQMpbdiwwahbrwZSUpKxbdt2scMhIqJywuSBlCaRSDB+/GcAgDVr1nP7biLSPhwwqRQmD6QSP79hqFixIiIjI3HmzFmxwyEiUgyTB6UweSCVVKxYESNHDgcArF69VuRoiIioPDB5IJWNH/85AOD48RN4+PChyNEQESlAKqjY8qCfS/UzeSCV1a1bF926dYUgCFi7dr3Y4RARlZ5UUP3QQ0weSC0mTBgHANi8eStSUlJEjoaIqJQ45kEpTB5ILXx9u6Bu3bpITEzEjh07xQ6HiIjKEJMHUgsDAwOMGzcWQN60TW7ZTURagS0PSmHyQGozYsRwWFpa4s6dOzh3LkTscIiISsYxD0ph8kBqY21tjeHDhwHgtE0iIl3G5IHUKn/a5i+/HEFUVJTI0RARlUCQqn7oISYPpFaurq7o3NkHgiBg3bpAscMhIiqeoGKXhZ6O72LyQGqXP21z06YtSEtLEzkaIiJSNyYPpHbdu3dD7dq18fr1a+zatVvscIiIisYBk0ph8kBqZ2hoKNtt8/vv13DaJhFpLiYPSmHyQGVi1KiRMDc3x+3bf+L8+Qtih0NERGrE5IHKRKVKlTBs2BAAnLZJRJqLky2Uw+SBykz+tM1Dhw4jOjpa5GiIiApRzt0WFy5cQM+ePeHo6AiJRIJDhw6VWCY0NBTNmjWDqakp3nnnHWzdulW596pGTB6ozDRq1Aje3h0hlUqxfv0PYodDRFSQVA2HAlJTU9G0aVOsXVu6FtmoqCj06NED3t7eiIiIwKRJk/Dxxx/j1KlTit1YzYxEvTvpvAkTxiEkJBSrV6/FiBEjUL9+XbFDIiISTbdu3dCtW7dSXx8YGIjatWtj+fLlAIAGDRrg4sWLWLlyJXx9fcsqzBKx5YHKVM+e78PMtAJSU1OxYsX3YodDRCRPTS0PSUlJckdmZqZawgsPD4ePj4/cOV9fX4SHh6ulfmUxeaAyZWRkhKZuzSCRGCM7O0fscIiI5AlqOAA4OTnB2tpadixatEgt4cXFxcHOzk7unJ2dHZKSkpCenq6WeyiD3RZU5j788ENcv3YPWVn6OR+aiHRfTEwMrKysZM9NTU1FjKbsMXmgMpc/zuGv+49EjoSISJ4glUCQSlQon/f/VlZWcsmDutjb2yM+Pl7uXHx8PKysrFChQgW136+0mDxQmatb1wUA8NdfDyEIAiQS5X9RiYjUSokZEwXKlyEvLy8cP35c7tyZM2fg5eVVtjcuAcc8UJlzcXGGoaEhUlJS8exZfMkFiIh0VEpKCiIiIhAREQEgbypmRESEbC0cf39/+Pn5ya4fO3YsHj16hGnTpuHevXtYt24dfvrpJ0yePFmM8GWYPFCZMzExQe3aNQEA9+8/EDkaIqL/ECSAVIVDUKwl9erVq3B3d4e7uzsAYMqUKXB3d8fs2bMBAM+ePZNbVK927do4duwYzpw5g6ZNm2L58uXYuHGjqNM0AXZbUDmpV68OHjyIwv3Ih+jYsa3Y4RARAVDfmIfS6tixY7GbBRa2emTHjh1x48YNBSMrW1rT8tCrVy/UrFkTZmZmcHBwwLBhw/D06dNiy2RkZGDcuHGoWrUqLC0t0a9fvwIDT6h81K1bBwDw118cNElEpO20Jnnw9vbGTz/9hMjISOzfvx8PHz7Ehx9+WGyZyZMn48iRI/j5559x/vx5PH36FH379i2niOm/6tXLSx7YbUFEGkWVLov8Qw9pTbfFfweHODs7Y8aMGejTpw+ys7NhbGxc4PrExERs2rQJu3fvxnvvvQcA2LJlCxo0aIDLly+jVatW5RY7AXXr5c+4YMsDEWkQQfFxC/Ll1ReKNtGalof/evXqFXbt2oXWrVsXmjgAwLVr15CdnS23rKerqytq1qxZ7LKemZmZBZYZJdXVq/cOACAqKhpZWVkiR0NElCd/zIMqhz7SquRh+vTpsLCwQNWqVREdHY3Dhw8XeW1cXBxMTExQqVIlufN2dnaIi4srstyiRYvklhh1cnJSV/h6zcHBDpaWFsjNzcWjR0/EDoeIiFQgavIwY8YMSCSSYo979+7Jrv/yyy9x48YNnD59GoaGhvDz8yt21Koy/P39kZiYKDtiYmLUWr++kkgkskGT9+8/FDkaIqJ/SA1UP/SQqGMepk6dihEjRhR7jYuLi+yxjY0NbGxsUK9ePTRo0ABOTk64fPlyoStt2dvbIysrC2/evJFrfYiPj4e9vX2R9zM1NdX5NcnFUreeC27cuIm//mLyQEQaQtVBj2W8wqSmEjV5sLW1ha2trVJlpdK8/2JFbXvavHlzGBsbIzg4GP369QMAREZGIjo6WvRlPfWVbMZFJJMHIiJtphWzLX777Tf8/vvvaNu2LSpXroyHDx/i66+/Rp06dWSJQGxsLDp16oTt27ejZcuWsLa2xujRozFlyhRUqVIFVlZWmDBhAry8vDjTQiRc64GINI0gSCCoMNtCzT3nWkMrkgdzc3McOHAAAQEBSE1NhYODA7p27YpZs2bJuhiys7MRGRmJtLQ0WbmVK1fCwMAA/fr1Q2ZmJnx9fbFu3Tqx3obeq8+1HohI00gNVOy20M/sQSKoe8ShjklKSoK1tTUSExPLZLtVfZKUlAybqnnbc18KO4EWLdxFjoiINFF5/Lubf4/4mZVhZaZ88pCUIcBu4Wu9+47QipYH0g0VK1rKHr95kyhiJEREeQQpVNzbQj///mbyQOUmOTkFQN4vadu2nuIGQ0QE/Lurpirl9RCTByo3b94kQgIJTExMYGZmJnY4RESkJCYPVG4S3+Qt9V25sjUkEv3M1olIs6g+20I//y1j8kDl5vU/4xysK+nPoCIi0nCqrhLJRaKIylb+IMlK1tYiR0JElEfVza24MRZRGXvz+p/koTKTByIibcaWByo3b/4Z81CJ3RZEpCE45kE5TB6o3CQm/jPmgd0WRKQpOOZBKey2oHLz+p9ui8rstiAi0mpseaBykz9Vk7MtiEhTcMCkcpg8ULl5k8jZFkSkWTjmQTnstqBy84bdFkREOoEtD1Ru3rDbgog0DQdMKoXJA5Wbhw+jAPw7cJKISGwc86AcdltQuUhNTUN6egYAoGqVKiJHQ0REqmDLA5WL8LCrMJAYoXKVSmjp6S52OEREADhgUllMHqhcnA8Ng0RigPd7doGlpYXY4RAR5RFUHPMgqC8UbcLkgcpFaGg4AKBjx9YiR0JE9C+OeVAOxzxQmXvzJhE3rt8CALTv4CVyNEREpCq2PFCZu/jrFUilUtSt64IaNRzEDoeISEYQVBu3ILDbgqhsnA8NAwB06MhWByLSMCp2W4DdFkRl48L5f8Y7eHO8AxGRLmDLA5Wp589f4tatewCAdu1biRwNEZE8QTCAICj/d7Sg4f0Wd+/exd69e/Hrr7/iyZMnSEtLg62tLdzd3eHr64t+/frB1NRU4XrZ8kBl6tcLlwEAjRq5wta2qsjREBG9RSpR/dBA169fh4+PD9zd3XHx4kV4enpi0qRJmD9/PoYOHQpBEPDVV1/B0dERS5YsQWZmpkL1s+WBylRoCMc7EBGVt379+uHLL7/Evn37UKlSpSKvCw8Px3fffYfly5dj5syZpa6fyQOVqfP/rO/Qges7EJEG0tUVJu/fvw9jY+MSr/Py8oKXlxeys7MVqp/JA5WZv/9+hr/+egQDAwO0bddS7HCIiArQ1UWiSpM4qHI9xzxQmcmfZeHerDEqVbIWORoiIv2Tnp6Oixcv4s6dOwVey8jIwPbt25Wql8kDlZnQf9Z36MjxDkSkofJnW6hyaKr79++jQYMGaN++PRo3bowOHTrg2bNnstcTExMxcuRIperW3HdNWk0QBBw9cgYAxzsQkebK77ZQ5dBU06dPR6NGjZCQkIDIyEhUrFgRbdq0QXR0tMp1c8wDlYkzZy7gzetEAIBLnVriBkNEVARdHTAJAGFhYTh79ixsbGxgY2ODI0eO4PPPP0e7du0QEhICCwvldzhmywOViW2bgwAAdna2cHGpKXI0RFSe3rxJxKOHT8QOQ++lp6fDyOjfNgKJRIL169ejZ8+e6NChA+7fv6903UweSO1evHiFkydDIZEYYseutWKHQ0TlJOpRNP43ZQ7qunjhi/FfiR1OqeS3PKhyaCpXV1dcvXq1wPk1a9agd+/e6NWrl9J1M3kgtdu8cQ8yMjLh5t4Qbdq2EDscIipjl8OvYfDAz9C4YUesW7sVqalpSEh4gZSUVLFDK5EgqDjmQYOThw8++AB79uwp9LU1a9Zg0KBBSi+vzeSB1CorKws//LATADB+wihIJJr7i0VEysvJycGB/cfQsf0HeK9jPxw6eAJSqRQ+ndvjyLEd+O3qCVhaKt+nruvWrl2LWrVqwczMDJ6enrhy5Uqx169atQr169dHhQoV4OTkhMmTJyMjI6PYMv7+/jh+/HiRr69btw5SqVSp+DlgktRq/77jiHuWAHuHauj3YXexwyEiNUtOTsG2LUFYu2YLnjz5GwBgYmKCgYP7YMIXo9GwYX2RI1SMGBtjBQUFYcqUKQgMDISnpydWrVoFX19fREZGolq1agWu3717N2bMmIHNmzejdevWuH//PkaMGAGJRIIVK1YoHbsqmDyQ2giCgDWrNwMAPv10KExMTESOiIjUJSY6FuvXbcPmTXuQlJQMAKhatTLGfDoMn44dBjs7W5EjVI4YK0yuWLECY8aMka2xEBgYiGPHjmHz5s2YMWNGgevDwsLQpk0bDB48GABQq1YtDBo0CL/99lup7peRkYHVq1cjJCQECQkJBVobrl+/rvB7YPJAahN26SoibvwJMzNTjPp4kNjhEJEaXLt2E6u/24j9+44hNzcXAFCvngsmTPwYg4f0RYUKZiJHqBmSkpLknpuamha61XVWVhauXbsGf39/2TkDAwP4+PggPDy80Lpbt26NnTt34sqVK2jZsiUePXqE48ePY9iwYaWKbfTo0Th9+jQ+/PBDtGzZUi3dyUweSG3yWx0GDe4DG5sqIkdDRMrKzc3F8WPB+P67jbh08d+++A4dvfDFxDHw7doRBga6MWROXes8ODk5yZ0PCAjAnDlzClz/4sUL5Obmws7OTu68nZ0d7t27V+g9Bg8ejBcvXqBt27YQBAE5OTkYO3ZsqXfBPHr0KI4fP442bdqU6vrSYPJAahH1KBpHfslbUXLcBOWWOyUicaWmpmHH9n1Yu3ozHj58DAAwMjLCRwN6YfwXo+Dm1kjcAMuAupKHmJgYWFlZyc4X1uqgrNDQUCxcuBDr1q2Dp6cnHjx4gIkTJ2L+/Pn4+uuvSyxfvXp1VKxYUW3xAEweSE3Wr98OQRDg07kdGjSoK3Y4RKSAp0/jEbh+GzZt2IXX/6wMW6mSFT4eMwSffjYc1avbixxh2RGkqu2MKfwzfMDKykoueSiKjY0NDA0NER8fL3c+Pj4e9vaFf85ff/01hg0bho8//hgA0LhxY6SmpuKTTz7BV199VWIr0PLlyzF9+nQEBgbC2dm5FO+qZEweSGXxcS+weeNeAGx1INImN2/ewervNuKnoCPIzs4GALi4OGPchFEY5vchp1qWARMTEzRv3hzBwcHo06cPAEAqlSI4OBjjx48vtExaWlqBBMHQ0BBA6WZ7eHh4ICMjAy4uLjA3Ny+w/farV68Ufh9MHkhlk7+Yi/T0dFhZWaFz5/Zih0NExZBKpTh96jxWf7cRISGXZOdbt2mBCRNH4/33O8u+mPSBGHtbTJkyBcOHD4eHhwdatmyJVatWITU1VTb7ws/PD9WrV8eiRYsAAD179sSKFSvg7u4u67b4+uuv0bNnz1L9txo0aBBiY2OxcOFC2NnZccAkiS89PRMXQn4HAPR835eLQhFpqPT0DOzZfRBrvt+Ee/ceAMj76/WDvt0wYeLHaNHCTdwARaL6Og+Klx0wYACeP3+O2bNnIy4uDm5ubjh58qRsEGV0dLRcS8OsWbMgkUgwa9YsxMbGwtbWFj179sQ333xTqvuFhYUhPDwcTZs2VTjWojB5IJXs3nYE2ekGeMfpXSxdqR1r2RPpk4SEF/jxhx3Y8MNOPH/+EgBQsaIlRo0ehM8+H46azjVEjlA/jR8/vshuitDQULnnRkZGCAgIQEBAgFL3cnV1RXp6ulJli8LkgZSWmZmF1St2AAAmTxsJa2v1juYlIuXdvfsXvv9uI/buPojMzCwAQE3n6hg3biSGjxwAKyv+vgKAVJBAqkK3hSply8vixYsxdepUfPPNN2jcuHGBMQ+lGej5NiYPpLS9O47h2dPncHC0xSC/98UOh0jvCYKAkHOX8N2qDThz+rzsvEeLppg4aQx69+kqt0UzAVBxhUmoUracdO3aFQDQqVMnufOCIEAikcgW/1IEf4pIKVlZ2fh++XYAwPjJQ2FqyqWoicQgCAIyMjKwf98xrP5uI27dyltoSCKRoFdvX3wx8WO08mrO8Uh67Ny5c2r/78/kgZTy0+4T+DsmHtXsqmLICOX3hCci5SUnp2DkQH/8fvkmnqc8AQBYWJjDb/hHGDd+JFzqqGdOvy4TY7ZFedm8eTN69eqFjh07qr1uJg+ksOzsHHy3LK/VYdzkIahQQX0rqRFR6W0NPIzfL0QCMIVd1eoYP2UoRo0ejMqVrcUOTWvocvKwc+dOfP7552jWrBl69+6NXr16oUGDBmqpWzcWJ6dytT/oFKIfP4WNbWX4jeojdjhEemnP1hNYNm8bAKBzrxaIfByCqf/7jIkDyZw7dw7Pnj3D559/jmvXrsHT0xN169bF1KlTceHChQK7ayqCyQMpJCMjEysWbwEAfD5xMMzNuaMeUXn7ZV8I/L9YBQD45IsPsWHnApiYcNyRMvJbHlQ5NFnlypUxdOhQ/PTTT3jx4gVWr16N9PR0DBkyBNWqVYOfnx/27duH1NRUhepl8kAKmTN9HZ48fgpzczOM+PgDscMh0jtnj4dj8phvIQgChozqgZkLxnAwpAqkgoHKh7YwMTFB165dsW7dOsTExODkyZOoVasW5s+fjxUrVihUF8c8UKlJpVIc/Clv50wvr+awsDQXOSIi/XLp/A187rcAOTm56DPgPSxYOYGJg4oEQbWpmprc8hASEoI2bdoU2Srl4eEBDw8PzJs3T7a3SWkxeaBSO30kHDnJBqhiYYNl66aJHQ6RXrn22x18PCAAmZnZ6NLDC8vW/6/E3RRJv3Xq1AlmZmZo1aoVvL294e3tjVatWhW61sfbC0eVhD95VCqCIGDd0p8gkUjw6YSP4FjdVuyQiPTGnzcfYsSHs5CWmoG23u5YvfUrGBvzbz910OUxD1FRUVi7di1q1qyJTZs2oX379qhUqRJ8fX2xePFi/Pbbb0oPmmTyQKVy/vQ13PnjEcwtzDD8M67rQFReHt6PwbDeM5D0JgXNPd/Fhj1zYGbGwZHqosvJg7OzM0aOHImtW7fi8ePHePDgAb7//nvY2dlh/fr1aN26NapUqaJU3UxdqUT5rQ4AMHh0N1Suqvg66ESkuJgncRjSazpevkhEw6bvYMu+BTC3qCB2WKSlXFxcYGhoCIlEAolEgkOHDiErK0upupg8UIl+u3gb13+7CxNTY4ya0EfscIj0Qvyzlxjcczqexb7AO/VrYsfBhbCuZCl2WDpH1zfGio6ORmhoKEJCQhAaGooXL16gdevWaNeuHY4ePQpPT0+l6mXyQCVa/0+rQ3+/zqhmr1wTFxGV3qsXiRjSawaio57BqZY9dv2yGFVtK4kdlk7S5RUmXVxc8Pr1a7Rp0wbt27fHp59+Cg8PD7VsjsYxD1SskwfCcCkkAkZGhvhkUj+xwyHSeclJqfDrOxN/3XsCO4eq2P3LEtg72ogdFmmh9PR0AICBgQGMjIxgbGwMQ0NDtdTNlgcq1vz/bQAAuDVzRfWa1USOhki3padlYFT/r3Hrxl+oUtUau35Zgpq1HcQOS6fpcsvDs2fPcO/ePVm3xbfffouMjAy0bdsWHTt2RIcOHdC8eXOlpvwyeaAi3bzyAK8SEgEJMN5/oNjhEOm0zMwsfDJ4Lq6E3YaVtQV2HF6Euq41xQ5L5+n6mAdXV1e4urpi7NixAIC7d+/Kxj8sWLAAAPDmzRuF61UpecjMzISpKXdU1FVblx6FpWCF9j3d0NbHTexwiHRWTk4uvhi1GBeCr6GCuSk2/7wAjZq+I3ZYpGPi4+Nx8+ZN3Lx5E3/88QeSkpKU/g5XKHk4ceIE9u7di19//RUxMTGQSqWwsLCAu7s7unTpgpEjR8LR0VGpQEiz3L3xGL8ej4CBgQRfzGOrA1FZkUql+PLz5Tj5y0WYmBhj4965aOHVUOyw9IYgqNb1IAhqDEbNEhISEBoaKuu2uH//PoyNjdGyZUsMHDgQ3t7e8PLyUqruUiUPBw8exPTp05GcnIzu3btj+vTpcHR0RIUKFfDq1Svcvn0bZ8+exfz58zFixAjMnz8ftrZcgVCbbVh4CADQdYAXnOvaixsMkY4SBAGz/7cWB/achaGhAdZu+wptvZuJHZZe0eUxD/b29jA2NoaHhwf69esHb29vtG7dGhUqqL5WSKmSh2+//RYrV65Et27dCh1Y8dFHHwEAYmNjsXr1auzcuROTJ09WOTgSx39bHUZN52qSRGXl2zmbsWPDEUgkEiz/4Ut0eb+12CHpHUHFMQ+anDycOHECbdu2hYWFhdrrLlXyEB4eXqrKqlevjsWLF6sUEImPrQ5EZW/N0j1YtyIIALBw1Rf4YEAnkSMiXePr61tmdXOdB5LDVgeisrcl8BCWztsCAPjqm08weFQPkSPSX7q6t0XXrl1x+fLlEq9LTk7GkiVLsHbtWoXqV3i2hSAI2LdvH0JCQpCQkFBgR64DBw4oWmWp9OrVCxEREUhISEDlypXh4+ODJUuWFDtAs2PHjjh//rzcuU8//RSBgYFlEqMuCBj9IwC2OhCVlZ93nsacL9cBACbOGIpPvvhQ5Ij0m66Oeejfvz/69esHa2tr9OzZEx4eHnB0dISZmRlev36NO3fu4OLFizh+/Dh69OiBpUuXKlS/wsnDpEmT8MMPP8Db2xt2dnaQSMrng/P29sbMmTPh4OCA2NhY/O9//8OHH36IsLCwYsuNGTMG8+bNkz03Nzcv61C11sk94YiKfAoA+GBUR3GDIdJBxw5dwLRxKwAAo8d9gMkzh4kcEemq0aNHY+jQofj5558RFBSEH3/8EYmJiQAAiUSCd999F76+vvj999/RoEEDhetXOHnYsWMHDhw4gO7duyt8M1X8dwCms7MzZsyYgT59+iA7OxvGxsZFljM3N4e9Pf+CLo1juy5BIkhQvbYt3FrXEzscIp1y7tQVTBy1GFKpFAOHd8PXi8aW2x9fVDRdXiTK1NQUQ4cOxdChQwEAiYmJSE9PR9WqVYv93iwNhcc8WFtbw8XFRaWbqurVq1fYtWsXWrduXeIHsGvXLtjY2KBRo0bw9/dHWlpasddnZmYiKSlJ7tAHD27F4Oq5uzCSGGLZT1+IHQ6RTrl88SbGDp2H7Owc9OzXAQu/+4KJg4bQ1TEPhbG2tpZN31SVwsnDnDlzMHfuXNmGG+Vp+vTpsLCwQNWqVREdHY3Dhw8Xe/3gwYOxc+dOhISEwN/fHzt27JBlYEVZtGgRrK2tZYeTk5M634LG2rLkKACgUz8P1GlYQ+RoiHRHxNV7GNX/a2RmZKFTV0+s3DBdbZsTEYlFIgiKrY+Vnp6ODz74AJcuXUKtWrUKZDDXr18vdV0zZszAkiVLir3m7t27cHV1BQC8ePECr169wpMnTzB37lxYW1vj6NGjpc7gz507h06dOuHBgweoU6dOoddkZmYiMzNT9jwpKQlOTk5ITEyElZVVKd+Zdnl0JxZDWwRAEATsuDIX7zRi8kCkDvf+jMJH3f6HxNfJaN3BDVv2LYCZmYnYYWm8pKQkWFtbl+m/u/n3ON6yByyMlP9LPDUnG92vHNPp74jCKDzmYfjw4bh27RqGDh2q8oDJqVOnYsSIEcVe898uEhsbG9jY2KBevXpo0KABnJyccPny5VIvr+np6QkAxSYPpqamerdfx9Zvj0EQBHTs3YyJA5GaRD2IxdBeM5D4OhnuLRpg4965TBw0kAAJBKgw20KFstpM4eTh2LFjOHXqFNq2bavyzW1tbZVexjp/iuh/WwlKEhERAQBwcOAWt/me3I9D8L4rAICRM3qKHA2RboiNScCQXtPxPOE13m3sgm37F8DCUvUlgYk0hcJjHpycnMq9aea3337DmjVrEBERgSdPnuDcuXMYNGgQ6tSpI2t1iI2NhaurK65cyfsifPjwIebPn49r167h8ePH+OWXX+Dn54f27dujSZMm5Rq/Jtu65CikUgFtuzdFvabc/pdIVc8TXmNIz+mIjUlAnbo1sOPwIlhXrih2WFQEfRgwGRISUuRrP/zwg1J1Kpw8LF++HNOmTcPjx4+VuqEyzM3NceDAAXTq1An169fH6NGj0aRJE5w/f17WxZCdnY3IyEjZbAoTExOcPXsWXbp0gaurK6ZOnYp+/frhyJEj5Ra3pvvjfCRO7slbenzEjPdFjoZI+4Weu4BuHYbh0YO/UaOmHXb+shg2tpXFDouKkT9VU5VD03Xt2hVffvklsrOzZedevHiBnj17YsaMGUrVqfCAycqVKyMtLQ05OTkwNzcvMGDy1atXSgWiqcpj4I5YPm01DzdvPoF9NWscfLxC7HCItFp2dg6cHd/FsxdRcKjsirDfT6JWnepih6WVynPA5OHmvVUeMNn72mGN/o4ICwuDn58fLC0tsXv3bkRFRWH06NGoX78+tm/fDmdnZ4XrVHjMw6pVqxS+CWmel7Gvkf34NexNTDF2Xl+xwyHSeomJb5DwOhoA8MOWZUwcSGO0bt0aERERGDt2LJo1awapVIr58+dj2rRpSk96UGq2BWm/k2vPQZojhWeHBvD1U33wK5G+27VrN3Jzc+HWtCl69i673QxJvaRQcYVJLZltcf/+fVy9ehU1atTA06dPZd38ym7XXaoxD6mpqQpVquj1VL6Snifj/I68sQ49p3QRORoi3bBlyzYAwMdjRokcCSlCHwZMLl68GF5eXujcuTNu376NK1eu4MaNG2jSpAnCw8OVqrNUycM777yDxYsX49mzZ0VeIwgCzpw5g27duuH7779XKhgqH6cCQ5GVng2XZs54tz33sCBS1Y0bN/DHHzdhYmKCQYMGih0OkZzvvvsOhw4dwurVq2FmZoZGjRrhypUr6Nu3Lzp27KhUnaXqtggNDcXMmTMxZ84cNG3atNCtPcPDw2FkZAR/f398+umnSgVDZS/1TRqCN/0KAOg5uTPX1ydSg/xWhw8+6IMqVaqIHA0pQgqJSl0P2tBtcevWLdjY2MidMzY2xtKlS/H++8rNtCtV8lC/fn3s378f0dHR+Pnnn/Hrr78iLCwM6enpsLGxgbu7OzZs2IBu3bpxzXYNd3bDBWSkZMKpoSOa+jYUOxwirZeZmYldu/YAAEaO5JgwraNq14MWdFu8nTj8V4cOHZSqU6EBkzVr1sTUqVMxdepUpW5G4kp+kYzTgaEAgPcndYaBgcLLfBDRW3755QhevXqFGjVqwMenk9jhEBXg7e1dbCvzuXPnFK5T4dkWpL2Cpu5CamI6KtlYoEUvN7HDIdIJ+V0Wfn5D2fKqhVRd6EkbFolyc3OTe56dnY2IiAjcvn1b6RmUTB70RHZaJu6G3gMAePVoCANDtjoQqSo2NhanTp0GAIwY4SdyNKQMVWdMaMNsi5UrVxZ6fs6cOUhJSVGqTn6D6Inbey+glmkG3OtUQJ/5/cUOh0gn7NixC1KpFG3btkHdunXFDodIIUOHDsXmzZuVKsuWBz2QnZaJ6xtPQyIBOk/rBVNzbgtMpCpBEGRdFhwoqb2k/xyqlNdW4eHhMDMzU6oskwc9cHvvBaS/TIaVkw3q9/IUOxwinRAeHo779+/D3Nwc/ft/KHY4pCSxui3Wrl2LpUuXIi4uDk2bNsXq1avRsmXLIq9/8+YNvvrqKxw4cACvXr2Cs7MzVq1ahe7du5d4r7595bcgEAQBz549w9WrV/H1118rFX+puy06deqEAwcOFPn6ixcv4OLiolQQVHbyWx0AwOOz7jA05oAuInXIb3Xo378fKlbkltvaSiqourOm4vcMCgrClClTEBAQgOvXr6Np06bw9fVFQkJCoddnZWWhc+fOePz4Mfbt24fIyEhs2LAB1auXbv8Ua2truaNKlSro2LEjjh8/joCAAMXfABRoeQgJCcH58+fx1VdfYe7cuQVez83NxZMnT5QKgsoOWx2I1C81NRVBQT8DAEaOHCFuMKR1VqxYgTFjxmDkyJEAgMDAQBw7dgybN28udIvszZs349WrVwgLC5PtZF2rVq1S32/Lli1qifu/FBowuX79eqxatQoffPAB96/QAmx1ICob+/cfQHJyMlxcXNC+fTuxwyEVCJCofAB5W3z/98jMzCz0fllZWbh27Rp8fHxk5wwMDODj41PkPhO//PILvLy8MG7cONjZ2aFRo0ZYuHAhcnNz1f+BlJJCyUPv3r1x+fJl/Pnnn2jVqhUePXpUVnGRGtxYuYOtDkRl4L8DJbnEu3ZTrcvi3zUinJyc5LoGFi1aVOj9Xrx4gdzcXNjZ2cmdt7OzQ1xcXKFlHj16hH379iE3NxfHjx/H119/jeXLl2PBggVFvq/KlSujSpUqpTqUofCAyQYNGuD333/HoEGD0KJFCwQFBcllUKQZMl+/wR97LgMwgnvfxmx1IFKTR48eITT0PCQSCYYPHyZ2OKQhYmJiYGVlJXtuamqqtrqlUimqVauGH3/8EYaGhmjevDliY2OxdOnSIscsrFq1Sm33L4xSsy2sra1x7Ngx+Pv7o3v37liyZAkGDx6s7thIBa9PHYRVhVSkGVugwag+YodDpDO2bdsBAPDx6QQnJyeRoyFV5Q2YVK08AFhZWcklD0WxsbGBoaEh4uPj5c7Hx8fD3t6+0DIODg4wNjaWW8G0QYMGiIuLQ1ZWFkxMCk6/V3blyNIqdbfF201zEokEixcvxvbt2/H111/j448/VntwpBwhJxuSyz+hnes99JrzHozM1JcBE+kzqVQqSx64toNuUNeYh9IyMTFB8+bNERwcLDsnlUoRHBwMLy+vQsu0adMGDx48gFT676oS9+/fh4ODQ6GJQ77Zs2cjLS1N9vz169cKxVqcUicPglB4ajZw4EBcvHgRt27dUltQpJr0sBPIfRkHA2sbVOnWT+xwiHRGSEgonjx5Amtra/Tp01vscEhLTZkyBRs2bMC2bdtw9+5dfPbZZ0hNTZXNvvDz84O/v7/s+s8++wyvXr3CxIkTcf/+fRw7dgwLFy7EuHHjir3PN998I7f8tLOzs9rGKio0VbOogRVubm64du0ajh07ppagSHmCNBcpR/Om5Vh2GwaJCVsdiNRly5atAIBBgwagQoUK4gZDaiHGxlgDBgzA8+fPMXv2bMTFxcHNzQ0nT56UDaKMjo6W2/XYyckJp06dwuTJk9GkSRNUr14dEydOxPTp04u9z9t/9BfVCKAMiaDO2nRQUlISrK2tkZiYWKr+LLGlXzmD16unQWJhBbuVx2FQwULskIh0QmJiIuztayAjIwO//Xap2NUASTXl8e9u/j02NBgMc0Pll+xPy83CmLu7NfI7wsDAAHFxcahWrRoAoGLFivjjjz/UsqAjl6fWIYIgIOWXvE1OLLoMYuJApEZ79wYhIyMD7777Llq0aCF2OEQlkkgkSE5OhpmZGQRBgEQiQUpKCpKSkuSuUybpYfKgQzJvhSH7yT1ITCvAsvNAscMh0ilc20E3CZBAquCgx7fLaypBEFCvXj255+7u7nLPJRKJUotNMXnQISm/bAIAmL/3IQwqVhI3GCIdcvfuXfz22xUYGhpi6FBOS9clYm2MVR5CQkLKrG4mDzoi6fIFZEXeAIyMYdltqNjhEOmU/FaH7t27FTkXn7STGAMmy0uHDh3KrG6FlqcmzfV0/bcAAKFeOxhWriZyNES6IycnBzt27AIAjBo1QtxgiDQEWx50QPyV2zDOSIBgDJj7crlcInU6efIU4uLiYGtrix49uosdDqmZ8M+hSnl9xORBB9zYdA6xt5qgcVdntGzmJnY4RDolv8ti6NDBsu2QSXfocrdFWWK3hZZLuBmFmAu3IRgYof7ET8UOh0inPH/+HEeOHAXA5aiJ/ovJg5a7vvYIAKBur1awduZYByJ12rVrN7Kzs9G8eTM0btxY7HCoDEjVcGi6UaNGITk5ucD51NRUjBo1Sqk6mTxosfxWB4mhAdw+ZV8skToJgiC3tgPppvypmqocmm7btm1IT08vcD49PR3bt29Xqk6OedBibHUgKjs3btzAzZu3YGJigkGDuOgaaZ+kpCQIggBBEGQrTebLzc3F8ePHZUtXK4rJg5ZiqwNR2cpvdejTp3eRmwKS9tPlAZOVKlWCRCKBRCKRW2kyn0Qiwdy5c5Wqm8mDljr+dd4eFmx1IFK/zMxM7N69FwC7LHSdLk/VDAkJgSAIeO+997B//365JNjExATOzs5wdHRUqm4mD1oodO8pZN+Ph1QQ4Dr8PbHDIdI5v/xyBK9evUL16tXRubOP2OEQKSV/hcmoqCg4OTnJbfOtKiYPWmjPlp9RKzsDQnUr2NWvKXY4RDoncOZB1DbywIcfecPQ0FDscKgM6XK3RT5nZ2cAQFpaGqKjo5GVlSX3epMmTRSuk8mDlrl9+x52hJ6FocQAl4OOiB0Okc6JfhKDnFhLOBk3wYABH4kdDpUxVadbasNUzefPn2PkyJE4ceJEoa8rs6smp2pqmaVL1gIAevfthobNG4ocDZHuMTYwlT1u2pxrO+g6fZiqOWnSJLx58wa//fYbKlSogJMnT2Lbtm2oW7cufvnlF6XqZMuDFnnwVxT27zsGAJg2Y5zI0RDpJml23pdBBUtTGBmxy4K037lz53D48GF4eHjAwMAAzs7O6Ny5M6ysrLBo0SL06NFD4TrZ8qBFli1bD6lUim7dO6FJk3fFDodIJ6W8SQMAWFqbixwJlQcBqq0uqcmzLfKlpqbK1nOoXLkynj9/DgBo3Lgxrl+/rlSdTB60RPSTv7F75wEAwHS2OhCVmZTEf5KHShVEjoTKgwAVuy2g+d0W9evXR2RkJACgadOm+OGHHxAbG4vAwEA4ODgoVSe7LbTEyhU/IicnBx07tkZLz2Zih0Oks1IS85bxZcsD6YqJEyfi2bNnAICAgAB07doVu3btgomJCbZu3apUnUwetMCtm3ewccNOAMB0//EiR0Ok2/7ttmDLgz6QCnmHKuU13dChQ2WPmzdvjidPnuDevXuoWbMmbGxslKqTyYMW+Gzs/5CbK4VlxQpo38FL7HCIdFpyfvJQiS0P+kCXV5h8W1ZWFqKiolCnTh00a6ZaCzbHPGi4ly9fIeLmH5AK2ZjwxWhIJJrfv0akzdjyQLomLS0No0ePhrm5ORo2bIjo6GgAwIQJE7B48WKl6mTyoOFWrw5EenoKGjVxwVezpogdDpHOyx/zUJFjHvRC/gqTqhyazt/fH3/88QdCQ0Pldtb08fFBUFCQUnWy20KDJSUlYfXqQADAjBlT1bouOREV7t/ZFkwe9IE+rDB56NAhBAUFoVWrVnKt1w0bNsTDhw+VqpPfRhps/fqNePMmEa6u9dC3by+xwyHSCylv8mdbsNuCdMPz589l6zz8V2pqqtJd4UweNFRaWhpWrsxbinr69ClsdSAqJ/ktDxXZ8qAX9GF5ag8PDxw7dkz2PD9h2LhxI7y8lBuEz24LDbVp03Y8f/4CtWrVxKBBH4odDpHekK3zwORBL+hDt8XChQvRrVs33LlzBzk5Ofjuu+9w584dhIWF4fz580rVyT9nNVBmZiaWLv0OADBt2mQYGxuLHBGR/uDy1PpFEFQ/NF3btm0RERGBnJwcNG7cGKdPn0a1atUQHh6O5s2bK1UnWx400KeffoHY2KewtbXBiBFDxA6HSK/8u84DxzyQ7qhTpw42bNigtvqYPGiYzMxM7NmzDwDg5dUSpqamJZQgInXJzspBRloWALY86AspJJCqsD+FKmXLWlJSUqmus7KyUrhuJg8aZu/efcjJyYKZWQX8+ONqscMh0iup/4x3AABzK7NiriRdocvLU1eqVKnY2RSCIEAikSA3N1fhupk8aJDc3FwsWrQUADBnjj9sbeXXHBcEAQkJCbCzsxMjPCKdlz/TwryiGYyMDEWOhkg1ISEhsseCIKB79+7YuHEjqlevrnLdTB40SFDQfvz110NUrVoFn302Ru61kJDzmP31PLx48RK3bl+FkRH/0xGpWzLXeNA/qg561OCWhw4dOsg9NzQ0RKtWreDi4qJy3ZxtoSFyc3OxcOG3AIBJk8bD0tISABAe/hs6+3SHT6fuCAu7jOjoGNy48YeYoRLpLK4uqX/yxzyocugjJg8aYv/+w7h7NxKVKlXCuHGf4MaNCLz/fl+0bfMezp07D2NjY4wbNxYPHt5GixbKTa0houLJ1nhgywNRsdj2rQGkUqms1WHQoP74+OPPcWD/IQB5zUwjRgzDV7Omw9m5pohREuk+rvGgf1Rdq0Eb1nn4L3XtzMzkQQMcPnwUt279CSMjI6xf/yPwzwjYQYM/wuzZM1G37jtih0ikF9htoX90eYXJvn37yj3PyMjA2LFjYWFhIXf+wIEDCtfN5EFksbFP8emnEwAAOdnZAAT07dcHc+Z8hYYN3xU3OCI9IggC3iQkQwJ2W5BusLa2lns+dOhQtdXN5EFkZ8+ew8uXrwBBQCefjli8eD6aNXMXOywivZOVloUbm35FPUszmFtwcTZ9ocvrPGzZsqXM6mbyIDI/vyG4dDEcVapWxeLF88QOh4jAlgd9IkC12ZYanDuUKSYPIpNIJPhxw1qxwyCi/2ju7Sp2CFRO8loeVFieWk+zB07VJCJ6i3N9B7FDINJobHkgIiK9pW9TNdWFyQMREektXZ6qWZbYbUFERFTO1q5di1q1asHMzAyenp64cuVKqcrt3bsXEokEffr0KdsAS8DkgYiI9FZ+t4Uqh6KCgoIwZcoUBAQE4Pr162jatCl8fX2RkJBQbLnHjx/jf//7H9q1a6fku1UfrUseMjMz4ebmBolEgoiIiGKvzcjIwLhx41C1alVYWlqiX79+iI+PL59AiYhI40nVcChqxYoVGDNmDEaOHIl3330XgYGBMDc3x+bNm4ssk5ubiyFDhmDu3Llq2RVTVVqXPEybNg2Ojo6lunby5Mk4cuQIfv75Z5w/fx5Pnz4tsFwnERGRqpKSkuSOzMzMQq/LysrCtWvX4OPjIztnYGAAHx8fhIeHF1n/vHnzUK1aNYwePVrtsStDq5KHEydO4PTp01i2bFmJ1yYmJmLTpk1YsWIF3nvvPTRv3hxbtmxBWFgYLl++XA7REhGRphOEf1eZVObI77ZwcnKCtbW17Fi0aFGh93vx4gVyc3NhZ2cnd97Ozg5xcXGFlrl48SI2bdqEDRs2qPW9q0JrZlvEx8djzJgxOHToEMzNS9605tq1a8jOzpbL7lxdXVGzZk2Eh4ejVatWZRkuERFpAXWtMBkTEwMrKyvZeVNT9SxxnpycjGHDhmHDhg2wsbFRS53qoBXJgyAIGDFiBMaOHQsPDw88fvy4xDJxcXEwMTFBpUqV5M4Xl90BeWMq/tvclJSUpGzYRKRFBEGAsWGu7DGRIqysrOSSh6LY2NjA0NCwwPi7+Ph42NvbF7j+4cOHePz4MXr27Ck7J5XmjbQwMjJCZGQk6tSpo2L0ihO122LGjBmQSCTFHvfu3cPq1auRnJwMf3//Mo9p0aJFck1PTk5OZX5PItIAWRmY1fkiZnW+CGRliB0NlRNVuiyU2VTLxMQEzZs3R3Bw8L8xSKUIDg6Gl5dXgetdXV1x69YtREREyI5evXrB29sbERERon1HidryMHXqVIwYMaLYa1xcXHDu3DmEh4cXaAby8PDAkCFDsG3btgLl7O3tkZWVhTdv3si1PhSV3eXz9/fHlClTZM+TkpKYQBAR6SgxVpicMmUKhg8fDg8PD7Rs2RKrVq1CamoqRo4cCQDw8/ND9erVsWjRIpiZmaFRo0Zy5fO/094+X55ETR5sbW1ha2tb4nXff/89FixYIHv+9OlT+Pr6IigoCJ6enoWWad68OYyNjREcHIx+/foBACIjIxEdHV1odpfP1NRUbX1VRKQ9jM1NCn1Muk2MFSYHDBiA58+fY/bs2YiLi4ObmxtOnjwpG0QZHR0NAwPNns+gFWMeatasKffc0tISAFCnTh3UqFEDABAbG4tOnTph+/btaNmyJaytrTF69GhMmTIFVapUgZWVFSZMmAAvLy8OliSiAiQSSaGPicrC+PHjMX78+EJfCw0NLbbs1q1b1R+QgrQieSiN7OxsREZGIi0tTXZu5cqVMDAwQL9+/ZCZmQlfX1+sW7dOxCiJiEiTKDNu4e3y+kgrk4datWoVGA1d2DkzMzOsXbsWa9euLc/wiIhIS6hrqqa+0exOFSIiItI4WtnyQEREpA7stlAOkwciItJbYkzV1AXstiAiIiKFsOWBiIj0lhjrPOgCJg9ERPhnPwtjyb+PSS9IoeKYB7VFol2YPBARAQCyYBVQT/YYKHn3XiJ9xeSBiIj0Ftd5UA6TByIiABJj00Ifk24TBNW6HvS1h4vJAxERuLeFvhIEFVse9DR54FRNIiIiUghbHoiISG9xqqZymDwQEZHekgqAVIWOC31dnprdFkRERKQQtjwQEZHe4lRN5TB5ICICIEAAJIayx5xvoR+kKk7V1NduCyYPREQAgFyYOfXIeyjNFTcUIg3H5IGIiPSW8M//VCmvj5g8EBEBgMS08Mek09htoRzOtiAiAleYJFIEWx6IiEhvcZEo5TB5ICIivSUIKo550NPNLZg8EBGR3mLLg3I45oGIiIgUwpYHIiL803ydlZX32EQAx0zqB3ZbKIfJAxERAGSlI2nyIgBApZX9AFNjkQOi8iBAta4H/Uwd2G1BRERECmLLAxERAMCwiMeky6SCoOKW3PrZ9sDkgYgIgOQ/W2FJuC2W3uDy1MphtwUREREphC0PRESkt7jOg3KYPBARkd6SQsUxD+y2ICIiIioZWx6IiEhvcbaFcpg8EBEhb6XAnFwD2WPOt9APnG2hHCYPREQAcjOycDqsNQBgQEYWDMwsRI6IygPHPCiHYx6IiIhIIWx5ICICAOMKhT8mncaWB+UweSAiAiD5zzaaEm6pqTc45kE57LYgIiIihbDlgYiI9JagYreFvrY8MHkgIiK9JZVIIZEov8i0VE8XqGa3BRERESmELQ9ERKS3pBAg4WwLhbHlgYgIeatKZkpzkSnNhaCnSw7rI0E2WVP5Qxlr165FrVq1YGZmBk9PT1y5cqXIazds2IB27dqhcuXKqFy5Mnx8fIq9vjwweSAiApCWlo4JD85jwoPzSEtLFzsc0mFBQUGYMmUKAgICcP36dTRt2hS+vr5ISEgo9PrQ0FAMGjQIISEhCA8Ph5OTE7p06YLY2NhyjvxfTB6IiEhvSYFyb3dYsWIFxowZg5EjR+Ldd99FYGAgzM3NsXnz5kKv37VrFz7//HO4ubnB1dUVGzduhFQqRXBwsErvXRUc80BEBMCwgkmhj0m3qWu2RVJSktx5U1NTmJqaFrg+KysL165dg7+/v+ycgYEBfHx8EB4eXqp7pqWlITs7G1WqVFE6blWx5YGICFxhUl9J1fA/AHBycoK1tbXsWLRoUaH3e/HiBXJzc2FnZyd33s7ODnFxcaWKefr06XB0dISPj49qb14FbHkgIiJSUUxMDKysrGTPC2t1UIfFixdj7969CA0NhZmZWZncozSYPBARkd6SQgqJCgs95bc8WFlZySUPRbGxsYGhoSHi4+PlzsfHx8Pe3r7YssuWLcPixYtx9uxZNGnSROmY1YHdFkREpLfKe6qmiYkJmjdvLjfYMX/wo5eXV5Hlvv32W8yfPx8nT56Eh4eH0u9XXdjyQEREVI6mTJmC4cOHw8PDAy1btsSqVauQmpqKkSNHAgD8/PxQvXp12biJJUuWYPbs2di9ezdq1aolGxthaWkJS0tLUd4DkwciIuQtEiUIUtlj0g9i7G0xYMAAPH/+HLNnz0ZcXBzc3Nxw8uRJ2SDK6OhoGBj82zGwfv16ZGVl4cMPP5SrJyAgAHPmzFE6dlVIBP6WFCspKQnW1tZITEwsVX8WEWmnhITnsLerDgCIi49FtWq2Ikekv8rj3938e7hYdIeBxFjpeqRCNh6lHte77wiOeSAiIiKFsNuCiAiAuXmFQh+TbhOQC0GFv6MF5KoxGu3B5IGICFwkSl9J/1mgWrXy+ofdFkRERKQQtjwQEZHekkKAai0P+jnngMkDERHprbwxD8p3U3HMAxERkZ7hmAflcMwDERERKYQtD0REkF9Vkmvn6Q9l9qd4u7w+YvJARAQgLS1N7rFYewZQ+ZIiF1BhzINUT8c8sNuCiIiIFMKWByIiAObm5oU+Jt3GbgvlMHkgIgJXmNRXUkHFbguB3RZEREREJWLLAxER6S12WyiHyQMREemtvORB+a4HfU0etK7bIjMzE25ubpBIJIiIiCj22o4dO0IikcgdY8eOLZ9AiYiIdJTWtTxMmzYNjo6O+OOPP0p1/ZgxYzBv3jzZc46iJiKifIIghVSVvS0E/Wx50Krk4cSJEzh9+jT279+PEydOlKqMubk57O3tyzgyItJ2giBA+GeHRK4wqT/yuh1U2RhLP5MHrem2iI+Px5gxY7Bjxw6FWg927doFGxsbNGrUCP7+/nKryBUmMzMTSUlJcgcR6b63V5gk/SAIuSof+kgrWh4EQcCIESMwduxYeHh44PHjx6UqN3jwYDg7O8PR0RE3b97E9OnTERkZiQMHDhRZZtGiRZg7d66aIiciItI9oiYPM2bMwJIlS4q95u7duzh9+jSSk5Ph7++vUP2ffPKJ7HHjxo3h4OCATp064eHDh6hTp06hZfz9/TFlyhTZ86SkJDg5OSl0XyLSPlxhUj/ljXhgt4WiRE0epk6dihEjRhR7jYuLC86dO4fw8HCYmprKvebh4YEhQ4Zg27Ztpbqfp6cnAODBgwdFJg+mpqYF7kNEuo8rTOqnvAGPHDCpKFGTB1tbW9ja2pZ43ffff48FCxbInj99+hS+vr4ICgqSJQSlkT+108HBQeFYiYiIKI9WjHmoWbOm3PP8rXLr1KmDGjVqAABiY2PRqVMnbN++HS1btsTDhw+xe/dudO/eHVWrVsXNmzcxefJktG/fHk2aNCn390BERJpHlQWi1FFeW2lF8lAa2dnZiIyMlI2SNjExwdmzZ7Fq1SqkpqbCyckJ/fr1w6xZs0SOlIiINEXetFwVlqfW02m9Wpk81KpVq8B/sLfPOTk54fz58+UdGhERkc7TyuSBiIhIHVSdLcHZFkRERHomb5En5bse9HW2hdasMElERESagS0PRESkt1RtOdDXlgcmD0REpLc45kE5TB6IiEhvseVBORzzQERERAphywMREfI2w0pJeSN7TPqB3RbKYfJARIS8zbAsLCzEDoPKGadqKofdFkRERKQQtjwQEZEeU21vC1VaLbQZkwciItJbed0OEhXK62fywG4LIiIiUghbHoiISG/lzZZQoeWB3RZERET6RrXkQV/HPLDbgoiIiBTClgciItJfKg6YhJ4OmGTyQEREeotjHpTDbgsiItJjUjUcilu7di1q1aoFMzMzeHp64sqVK8Ve//PPP8PV1RVmZmZo3Lgxjh8/rtR91YXJAxERUTkKCgrClClTEBAQgOvXr6Np06bw9fVFQkJCodeHhYVh0KBBGD16NG7cuIE+ffqgT58+uH37djlH/i+JoK8rXJRSUlISrK2tkZiYCCsrK7HDISLSeeXx727+PQAjSFTutshRKFZPT0+0aNECa9asAQBIpVI4OTlhwoQJmDFjRoHrBwwYgNTUVBw9elR2rlWrVnBzc0NgYKDSsauCLQ9ERKTHBJX+p+hUzaysLFy7dg0+Pj6ycwYGBvDx8UF4eHihZcLDw+WuBwBfX98iry8PHDBZgvyGmaSkJJEjISLSD/n/3pZfw7jq93n7O8LU1BSmpqYFrnvx4gVyc3NhZ2cnd97Ozg737t0rtO64uLhCr4+Li1MxauUxeShBcnIyAMDJyUnkSIiI9EtycvI/XQvqZ2JiAnt7e7V8AVtaWhb4jggICMCcOXNUrltTMXkogaOjI2JiYlCxYkVIJKqsQqa/kpKS4OTkhJiYGI4bURI/Q9XxM1RdeX2GgiAgOTkZjo6OZXYPMzMzREVFISsrS+W6BEEo8P1QWKsDANjY2MDQ0BDx8fFy5+Pj42Fvb19oGXt7e4WuLw9MHkpgYGCAGjVqiB2GTrCysuI/2iriZ6g6foaqK4/PsKxaHP7LzMwMZmZmZX6f/zIxMUHz5s0RHByMPn36AMgbMBkcHIzx48cXWsbLywvBwcGYNGmS7NyZM2fg5eVVDhEXjskDERFROZoyZQqGDx8ODw8PtGzZEqtWrUJqaipGjhwJAPDz80P16tWxaNEiAMDEiRPRoUMHLF++HD169MDevXtx9epV/Pjjj6K9ByYPRERE5WjAgAF4/vw5Zs+ejbi4OLi5ueHkyZOyQZHR0dEwMPh3MmTr1q2xe/duzJo1CzNnzkTdunVx6NAhNGrUSKy3wOSByp6pqSkCAgKK7AOkkvEzVB0/Q9XxM1Sf8ePHF9lNERoaWuBc//790b9//zKOqvS4SBQREREphItEERERkUKYPBAREZFCmDwQERGRQpg8EBERkUKYPJDaLF68GBKJRG4hk7dt3boVEolE7ijvRVo0zZw5cwp8Jq6ursWW+fnnn+Hq6gozMzM0btwYx48fL6doNZOinyF/DgsXGxuLoUOHomrVqqhQoQIaN26Mq1evFlsmNDQUzZo1g6mpKd555x1s3bq1fIIlUXGqJqnF77//jh9++AFNmjQp8VorKytERkbKnnPZb6Bhw4Y4e/as7LmRUdG/mmFhYRg0aBAWLVqE999/H7t370afPn1w/fp1Ued9i02RzxDgz+HbXr9+jTZt2sDb2xsnTpyAra0t/vrrL1SuXLnIMlFRUejRowfGjh2LXbt2ITg4GB9//DEcHBzg6+tbjtFTeWPyQCpLSUnBkCFDsGHDBixYsKDE6yUSiahrsmsiIyOjUn8m3333Hbp27Yovv/wSADB//nycOXMGa9asQWBgYFmGqdEU+QwB/hy+bcmSJXBycsKWLVtk52rXrl1smcDAQNSuXRvLly8HADRo0AAXL17EypUrmTzoOHZbkMrGjRuHHj16FNhvvigpKSlwdnaGk5MTevfujT///LOMI9R8f/31FxwdHeHi4oIhQ4YgOjq6yGvDw8MLfNa+vr4IDw8v6zA1miKfIcCfw7f98ssv8PDwQP/+/VGtWjW4u7tjw4YNxZbhz6L+YvJAKtm7dy+uX78uW4O9JPXr18fmzZtx+PBh7Ny5E1KpFK1bt8bff/9dxpFqLk9PT2zduhUnT57E+vXrERUVhXbt2sm2g39bXFycbBnbfHZ2dmrZWlhbKfoZ8uewoEePHmH9+vWoW7cuTp06hc8++wxffPEFtm3bVmSZon4Wk5KSkJ6eXtYhk5gEIiVFR0cL1apVE/744w/ZuQ4dOggTJ04sdR1ZWVlCnTp1hFmzZpVBhNrp9evXgpWVlbBx48ZCXzc2NhZ2794td27t2rVCtWrVyiM8rVDSZ/g2/hzm/Vx5eXnJnZswYYLQqlWrIsvUrVtXWLhwody5Y8eOCQCEtLS0MomTNANbHkhp165dQ0JCApo1awYjIyMYGRnh/Pnz+P7772FkZITc3NwS6zA2Noa7uzsePHhQDhFrh0qVKqFevXpFfib29vaIj4+XOxcfH8/++/8o6TN8G38OAQcHB7z77rty5xo0aFBs909RP4tWVlaoUKFCmcRJmoHJAymtU6dOuHXrFiIiImSHh4cHhgwZgoiICBgaGpZYR25uLm7dugUHB4dyiFg7pKSk4OHDh0V+Jl5eXggODpY7d+bMGXh5eZVHeFqhpM/wbfw5BNq0aSM3+wQA7t+/D2dn5yLL8GdRj4nd9EG65e1ui2HDhgkzZsyQPZ87d65w6tQp4eHDh8K1a9eEgQMHCmZmZsKff/4pQrSaYerUqUJoaKgQFRUlXLp0SfDx8RFsbGyEhIQEQRAKfoaXLl0SjIyMhGXLlgl3794VAgICBGNjY+HWrVtivQXRKfoZ8uewoCtXrghGRkbCN998I/z111/Crl27BHNzc2Hnzp2ya2bMmCEMGzZM9vzRo0eCubm58OWXXwp3794V1q5dKxgaGgonT54U4y1QOeJUTSpTb+9L//r1a4wZMwZxcXGoXLkymjdvjrCwsALNpfrk77//xqBBg/Dy5UvY2tqibdu2uHz5MmxtbQEU/Axbt26N3bt3Y9asWZg5cybq1q2LQ4cO6fUaD4p+hvw5LKhFixY4ePAg/P39MW/ePNSuXRurVq3CkCFDZNc8e/ZMrhujdu3aOHbsGCZPnozvvvsONWrUwMaNGzlNUw9wS24iIiJSCMc8EBERkUKYPBAREZFCmDwQERGRQpg8EBERkUKYPBAREZFCmDwQERGRQpg8EBERkUKYPBAREZFCmDwQ6ZiXL1+iWrVqePz4sUr1DBw4EMuXL1dPUESkU5g8EGmgESNGQCKRQCKRwNjYGLVr18a0adOQkZFRYtlvvvkGvXv3Rq1atVSKYdasWfjmm2+QmJioUj1EpHuYPBBpqK5du+LZs2d49OgRVq5ciR9++AEBAQHFlklLS8OmTZswevRole/fqFEj1KlTBzt37lS5LiLSLUweiDSUqakp7O3t4eTkhD59+sDHxwdnzpwptszx48dhamqKVq1ayc6FhoZCIpHg1KlTcHd3R4UKFfDee+8hISEBJ06cQIMGDWBlZYXBgwcjLS1Nrr6ePXti7969ZfL+iEh7MXkg0gK3b99GWFgYTExMir3u119/RfPmzQt9bc6cOVizZg3CwsIQExODjz76CKtWrcLu3btx7NgxnD59GqtXr5Yr07JlS1y5cgWZmZlqey9EpP24JTeRhjp69CgsLS2Rk5ODzMxMGBgYYM2aNcWWefLkCRwdHQt9bcGCBWjTpg0AYPTo0fD398fDhw/h4uICAPjwww8REhKC6dOny8o4OjoiKysLcXFxcHZ2VtM7IyJtx+SBSEN5e3tj/fr1SE1NxcqVK2FkZIR+/foVWyY9PR1mZmaFvtakSRPZYzs7O5ibm8sSh/xzV65ckStToUIFACjQnUFE+o3dFkQaysLCAu+88w6aNm2KzZs347fffsOmTZuKLWNjY4PXr18X+pqxsbHscf4sjv+SSCSQSqVy5169egUAsLW1VeYtEJGOYvJApAUMDAwwc+ZMzJo1C+np6UVe5+7ujjt37qjtvrdv30aNGjVgY2OjtjqJSPsxeSDSEv3794ehoSHWrl1b5DW+vr74888/i2x9UNSvv/6KLl26qKUuItIdTB6ItISRkRHGjx+Pb7/9FqmpqYVe07hxYzRr1gw//fSTyvfLyMjAoUOHMGbMGJXrIiLdIhEEQRA7CCJSn2PHjuHLL7/E7du3YWCg/N8H69evx8GDB3H69Gk1RkdEuoCzLYh0TI8ePfDXX38hNjYWTk5OStdjbGxcYN0HIiKALQ9ERESkII55ICIiIoUweSAiIiKFMHkgIiIihTB5ICIiIoUweSAiIiKFMHkgIiIihTB5ICIiIoUweSAiIiKFMHkgIiIihfwfejDIrRNVvTcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -495,7 +487,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -505,7 +497,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -515,7 +507,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -525,7 +517,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -578,12 +570,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -593,7 +585,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAHFCAYAAADL3j9BAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABl1UlEQVR4nO3de1xUdf748deZAUZEmFAEREkt01S0Wi1FK7zi3S67WVGslMtuq2kuWv2s3dX6pratWn11c8ta7WLZd9ds29UINC+RokhSoqVWEpggpgiKOMCcz+8PZHIAkcsww4H3cx/nscw5n/nMeyaZN5/L+Xw0pZRCCCGEaCImTwcghBCiZZNEI4QQoklJohFCCNGkJNEIIYRoUpJohBBCNClJNEIIIZqUJBohhBBNShKNEEKIJiWJRgghRJOSRNMKrFmzBk3TyMrK8nQobvHuu+/y0ksvVTt//vx5FixYwLZt21z+mtu2bUPTtCapWwijk0QjWpzaEs0zzzwjyUAIN5NEI4QQoklJomml/vGPf3DDDTfQpk0b2rdvz1133cXXX3/tuL5x40Y0TSMtLc1xbv369WiaxoQJE5zq6t+/P7/85S/r9LqNqVcpxSuvvMKNN96Ir68vgYGB/OpXv+L77793lBk2bBgbN27khx9+QNM0x5GVlUXHjh0BeOaZZxzn4+LiHM89cuQIMTExBAcHY7FY6N27N3/729+qvYdvvvmGsWPH0rZtW4KCgnjkkUc4e/Zsnd6/EK2RJJpWaPHixUybNo2+ffvywQcf8PLLL/PVV18RGRnJkSNHAIiKisLb25vNmzc7nrd582Z8fX3Zvn07ZWVlAOTn55OZmcmoUaPq9NqNqfd3v/sds2fPZtSoUXz44Ye88sorHDhwgCFDhnDixAkAXnnlFYYOHUpoaCi7du1yHJ06dSIxMRGAadOmOc7/6U9/AuDgwYPcfPPNZGZmsnTpUv773/8yYcIEZs2axTPPPOOI4cSJE0RFRZGZmckrr7zC22+/zblz53j00Ufr/d9BiFZDiRZv9erVClBHjx5VBQUFytfXV40fP96pTHZ2trJYLComJsZx7tZbb1UjRoxwPO7Ro4d6/PHHlclkUtu3b1dKKbV27VoFqMOHD9c5nobUu2vXLgWopUuXOtWVk5OjfH191RNPPOE4N2HCBNW1a9dqr3vy5EkFqPnz51e7NmbMGNWlSxdVWFjodP7RRx9Vbdq0UadPn1ZKKfXkk08qTdNURkaGU7nRo0crQG3durXOn4MQrYW0aFqZXbt2UVJS4tRlBBAeHs6IESPYsmWL49zIkSP5/PPPKSkp4YcffuDbb7/lvvvu48YbbyQ5ORmoaI1cffXVXHfddXWOoSH1/ve//0XTNB588EHKy8sdR2hoKDfccEOjBvgvXLjAli1buOuuu2jbtq1T/ePHj+fChQukpqYCsHXrVvr27csNN9zgVEdMTEyDX1+Ilk4STStz6tQpADp16lTtWlhYmOM6wKhRo7DZbKSkpJCcnExQUBA33XQTo0aNcnR9bdmypc7dZo2p98SJEyilCAkJwdvb2+lITU3lp59+qvdnUenUqVOUl5ezfPnyanWPHz8ewFH/qVOnCA0NrVZHTeeEEBW8PB2AcK8OHToAkJubW+3a8ePHCQoKcjweNGgQ7dq1Y/PmzWRlZTFy5Eg0TWPkyJEsXbqUtLQ0srOz651oGlJvUFAQmqbx2WefYbFYqtVZ07m6CgwMxGw2Exsby4wZM2os0717d6Di88vLy6t2vaZzQoiLPN13J5peTWM0kydPdiqTk5OjLBaLeuCBB5zOjx8/Xt10000qKChIvf7660oppc6fP68sFouKjo5WmqapEydO1Dum+tabkpKiAPX+++9fse67775bBQcHVztfVFSkAKfxnEqjRo1SN9xwg7LZbLXWLWM0QtSfJJpW4NJEo5RSixYtUoCKjY1VmzZtUm+//bbq0aOHslqt1Qb1ly5dqgAFqKysLMf54cOHK0D179+/QTE1pN7f/va3qm3bturxxx9X//nPf9Snn36q1q5dq37/+9+rV155xVFu/vz5ClCvvPKK2r17t0pLS3Nc69q1q+rVq5f65JNPVFpamuMzOXDggAoMDFS33HKLWr16tdq6dav66KOP1LJly9Tw4cMdz8/NzVUdO3ZUnTt3VqtXr1abNm1SDzzwgAoPD5dEI8RlSKJpBaomGqWUev3111X//v2Vj4+Pslqt6o477lAHDhyo9twvv/xSAeq6665zOr9w4UIFqISEhAbF1NB6//GPf6hBgwYpPz8/5evrq6699lr161//Wu3du9dR5vTp0+pXv/qVuuqqq5SmaerShvvmzZvVTTfdpCwWiwLU1KlTHdeOHj2qHn74YdW5c2fl7e2tOnbsqIYMGaKee+45pxgOHjyoRo8erdq0aaPat2+vpk2bpv79739LohHiMjSllHJnV50QQojWRWadCSGEaFIy60y4jK7r6LpeaxkvL/knJ0RrIy0a4TIPP/xwtftQqh5CiNZHxmiEy2RlZV3xxsmBAwe6KRohRHMhiUYIIUSTkq4zIYQQTcowI7MLFixwWq4dICQkpF5Lf+i6zvHjx/H390fTNFeHKESrpZTi7NmzhIWFYTI1zd+vFy5coLS01CV1+fj40KZNG5fUJa7MMIkGoG/fvk77mJjN5no9//jx44SHh7s6LCHERTk5OXTp0sXl9V64cIHu3UPJyyt0SX2hoaEcPXpUko2bGCrReHl5NWqVXH9/f6DilyEgIMBVYQnR6hUVFREeHu74HXO10tJS8vIKycp5mYAA30bVVVRUQrfwxygtLZVE4yaGSjRHjhwhLCwMi8XCoEGDWLRoEddcc81ly9tsNmw2m+Nx5Xa7AQEBkmiEaAJN3SXdrp2Fdu0avlI3cMV7vYTrGWYywKBBg3jrrbf45JNPWLVqFXl5eQwZMsRp/5SqFi9ejNVqdRzSbSaEsSlV7pKjPlauXEn//v0df6BGRkby8ccfO67HxcWhaZrTMXjwYKc6bDYbM2fOJCgoCD8/PyZPnsyxY8ecyhQUFBAbG+v4voqNjeXMmTNOZbKzs5k0aRJ+fn4EBQUxa9asauNW+/fvJyoqCl9fXzp37syzzz6LpycXGybRjBs3jl/+8pf069ePUaNGsXHjRgDefPPNyz5n3rx5FBYWOo6cnBx3hSuEaAJK2V1y1EeXLl14/vnn2bt3L3v37mXEiBHccccdHDhwwFFm7Nix5ObmOo5NmzY51TF79mw2bNjAunXrSElJ4dy5c0ycOBG7/edYYmJiyMjIIDExkcTERDIyMoiNjXVct9vtTJgwgeLiYlJSUli3bh3r169nzpw5jjJFRUWMHj2asLAw0tLSWL58OUuWLGHZsmX1/ahdylBdZ5fy8/OjX79+HDly5LJlLBZLozbEEkKISZMmOT1euHAhK1euJDU1lb59+wIV3zWXGz8uLCzkjTfe4O2333Zs5vfOO+8QHh7O5s2bGTNmDF9//TWJiYmkpqYyaNAgAFatWkVkZCSHDh2iV69eJCUlcfDgQXJycggLCwNg6dKlxMXFsXDhQgICAli7di0XLlxgzZo1WCwWIiIiOHz4MMuWLSMhIcFjs20N06Kpymaz8fXXX9e4JbEQomXSVblLjoay2+2sW7eO4uJiIiMjHee3bdtGcHAwPXv2JD4+nvz8fMe19PR0ysrKiI6OdpwLCwsjIiKCnTt3ArBr1y6sVqsjyQAMHjwYq9XqVCYiIsKRZADGjBmDzWYjPT3dUSYqKsrpD+wxY8Zw/PhxsrKyGvy+G8swLZq5c+cyadIkrr76avLz83nuuecoKipi6tSpng5NCOEmDRljqakOqOhmulRtPSD79+8nMjKSCxcu0K5dOzZs2ECfPn2Aim79e+65h65du3L06FH+9Kc/MWLECNLT07FYLOTl5eHj40NgYKBTnZfeB5iXl0dwcHC11w0ODnYqExIS4nQ9MDAQHx8fpzLdunWr9jqV1yq3JHc3wySaY8eOcf/99/PTTz/RsWNHBg8eTGpqKl27dvV0aEIIA6o6OWj+/PksWLCgxrK9evUiIyODM2fOsH79eqZOncr27dvp06cP9957r6NcREQEAwcOpGvXrmzcuJG77777sq+vlHLqyqqpW8sVZSonAnjyJnXDJJp169Z5OgQhhIdVDOY3tkVTMQBf9X662sZzfXx86NGjB1CxMGxaWhovv/wyr776arWynTp1omvXro7x49DQUEpLSykoKHBq1eTn5zNkyBBHmRMnTlSr6+TJk44WSWhoKLt373a6XlBQQFlZmVOZqqulVHbjVW0NuZNhx2iEEK2P0stdcsDP99NVHvWZOKSUcrpH71KnTp0iJyfHMX48YMAAvL29SU5OdpTJzc0lMzPTkWgiIyMpLCxkz549jjK7d++msLDQqUxmZia5ubmOMklJSVgsFgYMGOAos2PHDqcpz0lJSYSFhVXrUnMnSTRCCFGLp556is8++4ysrCz279/P008/zbZt23jggQc4d+4cc+fOZdeuXWRlZbFt2zYmTZpEUFAQd911FwBWq5Vp06YxZ84ctmzZwr59+3jwwQcdt2oA9O7dm7FjxxIfH09qaiqpqanEx8czceJEevXqBUB0dDR9+vQhNjaWffv2sWXLFubOnUt8fLyjZRYTE4PFYiEuLo7MzEw2bNjAokWLPDrjDAzUdSaEEKjyiqOxddTDiRMniI2NJTc3F6vVSv/+/UlMTGT06NGUlJSwf/9+3nrrLc6cOUOnTp0YPnw477//vtNyPC+++CJeXl5MmTKFkpISRo4cyZo1a5zWa1y7di2zZs1yzE6bPHkyK1ascFw3m81s3LiR6dOnM3ToUHx9fYmJiWHJkiWOMlarleTkZGbMmMHAgQMJDAwkISGBhISEhn5aLtGq9qMpKirCarVSWFgoS9AI4UJN/btVWf+x408RENC49cmKii7QJWyRfA+4kXSdCSGEaFLSdWYgul6Ero5j0no22Z4fQjRrejnoZY2vQ7iVJBqD0NUZSu3/QXEO+ByT3hmTFnLx6IimeXs6RCGaXMUNm/Xbh6qmOoR7SaJp5pQqx65nYFdfoqj8S64UXR1FV0cvPjahaR0uSTyhaMguoqIF0stBb1yikRaN+0miacZ0/Rhl+udAxVIZXqZumLVbUNjQ1Ql0lYeuTgDnUeokdnUSO5kXn+17SeIJwaQFS6tHCOERkmiaIaXOU66noqvvLp5pi5dpCCatm6OVYqbTxbIKxTmnxKPUT0AJuspCV1kX69DQ6IDJdGmrJ0BaPcJYpEVjSJJomhGldHT1DeX6HqAM0DBrfTGbBqBpPjU+R9M0NPwxaf5Aj4v1lKOrn6q0eopR/IRd/wk7lftotHHqbpNWj2j+7I2/j4b67UcjGk8STTOhq58ot6egOAmARhBe5tswaUH1rkvTvDBroZgJBW4AQKmKVo9d5aHUCXR1EriArn5AVz9UPhON9lVaPVZp9QghGkUSjYcpVYpdT8euDgAK8MbLdDMmrTea5ropzJrWDrPWDjPXXnxdO0qdvNjqqTgU51Ccwq6fws7Bi8+0XNLiqRzrqbl1JURT0/RyNL1xvxeadJ25nSQaD1FKoassyvVdQDEAJu0avEyD0TS/Jn99TTOjaaGY+HlXwMpWz8/HScCGrrLRVfbPz6U9JlOoo9tN46qLdUrLRzQxvRwamWhkjMb9JNF4gFJnKdc/R1c5F8/4420aiskUXuvzmlrNrZ6fqrR6zqI4jV0/fUmrxwfQMWt98PEa6rH4hRDNkyQaN1JKx66+wq5/QcWApAmzdgNm041oWvP7T1HR6gnBxM/7WChVfEniybvY6qlYktyuvqLM7ouX6SZp3YimIS0aQ2p+324tlK7yLg72FwCg0Qkv81BMWuAVntm8aJofZu0azFwDVLR6dP0EZfouFPmU67vRVR4+5pFoWt339xCiLjRVjqYaOUYjKwO4nSSaJqbUBcr1Pejq0MUzbfAyDcKkXdci/urXNDNmcxgm093Y1deU2VPQ1Q/Yyv+Jj9cYTFpHT4cohPAwSTRNpGKw/wjl+m7gAgAmrRdeplvQtMYtc94caZqGl9YHk9aR0vIkFEXYyj/A23wbZq13i0iqohnQddAbeR+MrrsmFlFnkmiagK4KKLd/jqJiy1WNQLzMt2LSQq/wTOMzaR2xeP2KUvun6CqLMvt2dC0Xb/PtcjOoaLSK6c2N+6NFpje7nyQaF6pYAHMfdvUVoANmzKYBmLV+Lr0nprnTNAs+5rGU6xmU67uxq8Po5T/h4xVtuDEp0czodhdMBpCVAdxNEo2L6HrOxQUwzwJg0sLxMg1F0/xrf2ILpWka3uabMGkhlNqTUJzGVr4eH/NwzKZrPR2eEMKNJNE0klLFFxfA/P7iGT+8TJFOC2C2ZmZTGG20eyi1J6OrXErtSZhVf7xNg9G0Ri6OKFofvRwa2XUm05vdTxJNAymlU6Z/jFJ5VHSTXXkBzNZK0/zwMU+mXN9NuZ6BXf8KpfLxMY9G09p5OjxhIJpud8ESNNJ15m6tZ+DAxZQqQ6njgI7GVXib78TLHClJ5jI0zYS3ORIf81jAB13lcaH8n9j1Y54OTQjRxCTRNJR2loqPzwsv010NWmW5NTKbumPx+hUaQcAFSu3/ocy+F6WUp0MTRqDsFycENOJQ0qJxN+k6ayCljl3cCyYck0k+xvowaVYsXndRZk/Brr6mXE9DVycuribQ8u4xEq6j6Xqju740uY/G7aRF00C6Og6ASevs4UiMSdO88PEahrd5OGBGV9nYyv+Jrp/wdGhCCBeTP8UbQKlSFBVfiJJoGsfLdP3F1QQ+QVGIzf4h3mooZlNfmbUnqtPtLph1Jl1n7iYtmgZQ5FGxSZk/mhbg6XAMz6R1wOL1S0xad0CnTP+MMvsWlCrzdGiimamYddb4Q7iXJJoG0FXFTClpzbhOxWoCY/AyDQE07OoItvL16KrA06EJIRpJus4a4OfxmS4ejqRlqVhN4AZMWjCl9mQUBdjK/4W3eRhepus8HZ5oDqTrzJCkRVNPShUBRYCGRstfJNMTzKZOtPH61cUWYzll9s2U2j9DybTUVk+6zoxJWjT1VNma0QiRmzObkKa1xcc8kXI9jXL9C+x6JrrKx8ccjamVrh8nkBaNQUmLpp5+Hp8J83AkLV/FagKD8DGPBywolY+t/F/Y9WxPhyaEqAfDJprFixejaRqzZ89222sqpf+8x4yMz7iN2dS1YjUBrSMVqwlspMy+B6XkxrvWRtPVxZs2G3PIKhTuZshEk5aWxmuvvUb//v3d+rqKfKAMsKDR3q2v3dqZtAAs5jsxm/oAUK6nU2rfhFIlHo5MuFVjl5+pPIRbGS7RnDt3jgceeIBVq1YRGOjeTbR09SNQ0W3WmjYyay40zQsfcxTe5hGAF7rKubiaQJ6nQxNC1MJw35YzZsxgwoQJjBo1yu2vrS4mGg25f8aTvEy9sHjdjcZVKIqx2f9Nuf0rWZizNZBFNQ3JULPO1q1bxxdffEFaWlqdyttsNmw2m+NxUVFRg19bqQsofgLkRs3moHI1gTL7NuzqO8r0z9FVHt7mYTIbsAXTlI6mGjfrTJOxPbczTIsmJyeHxx57jHfeeYc2beq2wu/ixYuxWq2OIzw8vMGv//O05qvQNL8G1yNcR9N88DaPxts0FDBhV99dXE3gtKdDE0JcQlMG6W/48MMPueuuuzCbf97+1263o2kaJpMJm83mdA1qbtGEh4dTWFhIQED91igr1z9DV0cwaX3xMg1q3JsRLmfX8yizJ6EopmK30974eEV5OqxWo6ioCKvV2qDfrfrU/9MnvQjwa9wW4EXFdoLGHGqyWEV1huk6GzlyJPv373c699BDD3H99dfz5JNPVksyABaLBYvF0ujXVkpdMhFAus2aI7MpFJN2D7byj1Ccxq4OUmr3xtsUKatAtyS67oIbNqXrzN0Mk2j8/f2JiIhwOufn50eHDh2qnXe9M8B5wCzLzjRjmuaLj/lXlNo/QpGHXf8SKMPbdJvMEhTCgwyTaDxJd8w2C0XT5CNrzkwmM21Md1Fu30+ZnoJdP4hSxfiYR6Np3p4OTzSWtGgMydB/5m3bto2XXnqpyV/n0vtnhDF4mfvhYx5Dxe6dP2Cz/xulzns6LNFIlVs5N+6oX6JZuXIl/fv3JyAggICAACIjI/n4448d15VSLFiwgLCwMHx9fRk2bBgHDhxwqsNmszFz5kyCgoLw8/Nj8uTJHDt2zKlMQUEBsbGxjslLsbGxnDlzxqlMdnY2kyZNws/Pj6CgIGbNmkVpaalTmf379xMVFYWvry+dO3fm2Wef9fjUf0MnGndQqvziRmey7IzRmE3X4GOeDLRBqZPYyjegqzOeDks0hq675qiHLl268Pzzz7N371727t3LiBEjuOOOOxzJ5IUXXmDZsmWsWLGCtLQ0QkNDGT16NGfPnnXUMXv2bDZs2MC6detISUnh3LlzTJw4Ebv953t6YmJiyMjIIDExkcTERDIyMoiNjXVct9vtTJgwgeLiYlJSUli3bh3r169nzpw5jjJFRUWMHj2asLAw0tLSWL58OUuWLGHZsmUN/cRdQ7UihYWFClCFhYV1fo5dP6Zs5W8oW/l7Stf1JoxONBW7XqBKSt9R50tfUedL/6HK7bmeDqnFacjvVkPqP/Xvrqpsc/dGHaf+3bXRsQYGBqrXX39d6bquQkND1fPPP++4duHCBWW1WtXf//53pZRSZ86cUd7e3mrdunWOMj/++KMymUwqMTFRKaXUwYMHFaBSU1MdZXbt2qUA9c033yillNq0aZMymUzqxx9/dJR57733lMVicbyXV155RVmtVnXhwgVHmcWLF6uwsDCPfn9Ji+YKLp1tJrOXjMmkXYXF6y40LZiKRTk/wq4f9XRYoiFc2KIpKipyOi69FeJy7HY769ato7i4mMjISI4ePUpeXh7R0dGOMhaLhaioKHbu3AlAeno6ZWVlTmXCwsKIiIhwlNm1axdWq5VBg36+dWLw4MFYrVanMhEREYSF/dyFP2bMGGw2G+np6Y4yUVFRTrNtx4wZw/Hjx8nKyqrvp+0ykmiu4OdlZ2R8xsg0rS0W82RMWlfATqk9kXL7/is+TzQzLkw04eHhTjd0L168+LIvu3//ftq1a4fFYuGRRx5hw4YN9OnTh7y8im71kJAQp/IhISGOa3l5efj4+FRbm7FqmeDg4GqvGxwc7FSm6usEBgbi4+NTa5nKx5VlPEGmUNVCqfMoKvasl/tnjE/TvPExj6VM/wy7fpAyPQXFObxMg6W12grl5OQ43bBZ2z13vXr1IiMjgzNnzrB+/XqmTp3K9u3bHder/vtRSl3x31TVMjWVd0UZdXEigCf/jUuLphY/T2vugKbVbdkb0bxpmglv0+2O1R3K9QzK7Jtlm2ijcOGimpWzyCqP2hKNj48PPXr0YODAgSxevJgbbriBl19+mdDQivvqqrYW8vPzHS2J0NBQSktLKSgoqLXMiRMnqr3uyZMnncpUfZ2CggLKyspqLZOfnw9Ub3W5kySaWiguJhppzbQomqbhbf7Fxe0GTNjVt5Ta/4tSV+6jF57V+E3P9HpPb66JUgqbzUb37t0JDQ0lOTnZca20tJTt27czZMgQAAYMGIC3t7dTmdzcXDIzMx1lIiMjKSwsZM+ePY4yu3fvprCw0KlMZmYmubm5jjJJSUlYLBYGDBjgKLNjxw6nKc9JSUmEhYXRrVu3Rr/vhpJEcxlKKcdCmtJt1jJ5mXrhY54AeKOr4xenP5+94vNE6/LUU0/x2WefkZWVxf79+3n66afZtm0bDzzwgGOX30WLFrFhwwYyMzOJi4ujbdu2xMTEAGC1Wpk2bRpz5sxhy5Yt7Nu3jwcffJB+/fo5tjvp3bs3Y8eOJT4+ntTUVFJTU4mPj2fixIn06tULgOjoaPr06UNsbCz79u1jy5YtzJ07l/j4eEcXYExMDBaLhbi4ODIzM9mwYQOLFi0iISHBo11nMkZzGYpTwAXAC43qg3SiZTCbumDR7sRWvglFAbbyDVi8xmPSgjwdmqiJrkNjGyT1bNGcOHGC2NhYcnNzsVqt9O/fn8TEREaPHg3AE088QUlJCdOnT6egoIBBgwaRlJSEv7+/o44XX3wRLy8vpkyZQklJCSNHjmTNmjVOazSuXbuWWbNmOWanTZ48mRUrVjium81mNm7cyPTp0xk6dCi+vr7ExMSwZMkSRxmr1UpycjIzZsxg4MCBBAYGkpCQQEJCQoM+KlcxzOrNrlCfFWbt+pfYVToa4XibR7spQuEpujpHafl/L07+8MbHPAazqeHbSrQ27lq9+fS77Qlo27iOmKLzOu1jTsvqzW4kXWeXIas1ty4mrR0Wr7suLjNURql9E+X6IU+HJUSLIImmBkqVoaiYqWGSZWdaDU2z4GOeiFnrAeiU2T+lzJ7u8XWixCV05YL7aOS/p7vJGE0NdL6hoiO4LeB/hdKiJdE0M97mUWi6P+X6Psr1PSjOyVYDzYWuXDBGI4nG3STR1EBX3wMVd5PLjXytT8X058FotHPc3ClbDTQTLtkmQBKNu8mfaDXQsAAamhZ4xbKi5fIyR+BjHotsNSBE40iiqYHJdBVmsw8mSTStntnUHYvTVgMfyFYDnuSBbQJE40miqVHlP0T5eASYTKEVqz8TgOIstvIN2HXPLVDYqunKNYdwK/kmrZEkGuGs5q0Gvvd0WEIYgnyT1kBJohE1qL7VwCey1YC7Kd01h3Ar+SatUWXTWj4e4axyqwGzqQ8AZXoKZfZdcq+NuygXdJvJfyu3k2/SGlX+xSNTm0V1stWAEPUj99HUSLrORO0qtxrQtHaU2bdiV9+i7OfxMY9F0y6/r4loJLlh05Dkm7RGkmhE3XiZel7casBHthpwB5l1ZkjyTVqjikSjyccj6sBs6oLF607A7+JWAx+gq588HZYQzYZ8k9ao8i8eGaMRdWPSOmDxuhuN9sB5bOUfYtdzPB1WiyOTzoxJEk2NpOtM1F/FVgN3Vtlq4BtPh9WySNeZIck3aY0k0YiG+Xmrgeuo2Gpgq2w14Eq6iw7hVvJNWiNJNKLhKrYaGImX6SYAyvU9lNm3o6TPRrRSMr25RnLDpmgc560GUrCrr1H2YnzM0bLVQGO4okUi+d7t5Ju0RpU33slkANE4FVsNjAG80FW2bDXQWMpFh3ArSTQ1khaNcJ2KrQYmIVsNiNZKvklrJGM0wrWqbzXwAWX2Lz0dluEoXXPJIdxLvklrJIlGuF7lVgMQBNgo13dSJqs/14/MOjMk+SatkSQa0TQqthq4A/AFwK7vR6lyzwYlRBOTb9IayRiNaDomkw8W8z1AGxSFlOmpng7JOJQGeiMPJV1n7ibfpFUop2kp8g9SNA2TyQ8f8wigolUjy9XUjYzRGJNhEs3KlSvp378/AQEBBAQEEBkZyccff9wEr3RpB65hPh5hQGZTV8ymCABK7Z+i1AUPRyRE0zDMN2mXLl14/vnn2bt3L3v37mXEiBHccccdHDhwwMWvJIlGuI+3aTAaVwHnKbVvl6VqrqSx3WaVh3Arw3yTTpo0ifHjx9OzZ0969uzJwoULadeuHampru7flkQj3EfTvPHxGgWY0NX32NUhT4fUvCnNNYdwK0MuQWO32/nnP/9JcXExkZGRly1ns9mw2WyOx0VFRXWo/dK/KOUfpGh6Jq0jXqabKdd3U2ZPwaSFYdICPB1Ws+SKMRZZcs79DPUn+/79+2nXrh0Wi4VHHnmEDRs20KdPn8uWX7x4MVar1XGEh4fX4VUq/xVqaJJohJt4mW7EpHUCyiizb5EFOEWLYqhE06tXLzIyMkhNTeX3v/89U6dO5eDBg5ctP2/ePAoLCx1HTk5dZvbIPTTC/TTNhLd5BOCNrvIo1/d5OqTmSTe55hBuZaiuMx8fH3r06AHAwIEDSUtL4+WXX+bVV1+tsbzFYsFisdTzVSTRCM8waQF4m2+jzP4p5fpezFo4JlOwp8NqXlwxmC+NRbcz9LepUsppDMZFtV78f0N/NMKgzFpPzNq1gE6pfTNKlXk6JCEazTAtmqeeeopx48YRHh7O2bNnWbduHdu2bSMxMdHFr/TzGI0Q7laxj83t2MvzLq4asBMfc5Snw2o2lNJQjZw1JjPI3c8wiebEiRPExsaSm5uL1Wqlf//+JCYmMnr0aBe/knSdCc/StDb4mEdQav8Pdv0gdq0rZlM3T4fVPOgmF3SdSaZxN8MkmjfeeMNNrySJRnie2dQFL3UD5fqXlNq30Uabgqa19XRYQjSIfJtWI4lGNA9eplvQaA+UUGrfJqsGUHEPTOPXOvP0u2h95Nu0GhmjEc2DpnldsmrAD9jV154OyfNk9WZDkkRTTWWiMXs0CiEATFoHvEyDASizfy5bQAtDkkRTjWwRIJoXL1N/TFpnoJxS+xaUsns6JI+pnHXW2EO4lySaamSMRjQvmqZd3LvGB6XyKdfTPR2S53hgZYDFixdz88034+/vT3BwMHfeeSeHDjkvfhoXF4emaU7H4MGDncrYbDZmzpxJUFAQfn5+TJ48mWPHjjmVKSgoIDY21rFsVmxsLGfOnHEqk52dzaRJk/Dz8yMoKIhZs2ZRWlrqVGb//v1ERUXh6+tL586defbZZz06xiffplUoSTSiGdK0dnhfvJ+mXP8Cu57n4Yg8wxMbn23fvp0ZM2aQmppKcnIy5eXlREdHU1xc7FRu7Nix5ObmOo5NmzY5XZ89ezYbNmxg3bp1pKSkcO7cOSZOnIjd/nMLNSYmhoyMDBITE0lMTCQjI4PY2FjHdbvdzoQJEyguLiYlJYV169axfv165syZ4yhTVFTE6NGjCQsLIy0tjeXLl7NkyRKWLVtWr/ftSoaZ3uw+kmhE8+Rl6oGu/4BdHabMvhmTNgVN8/F0WC1e1ZvCV69eTXBwMOnp6dx+++2O8xaLhdDQ0BrrKCws5I033uDtt99m1KhRALzzzjuEh4ezefNmxowZw9dff01iYiKpqakMGjQIgFWrVhEZGcmhQ4fo1asXSUlJHDx4kJycHMLCwgBYunQpcXFxLFy4kICAANauXcuFCxdYs2YNFouFiIgIDh8+zLJly0hISEDT3N91KN+m1cgYjWi+vM23ouGP4ixl9s89HY7buXKMpqioyOmo63JWhYWFALRv397p/LZt2wgODqZnz57Ex8eTn5/vuJaenk5ZWRnR0dGOc2FhYURERLBz504Adu3ahdVqdSQZgMGDB2O1Wp3KREREOJIMwJgxY7DZbKSnpzvKREVFOa3zOGbMGI4fP05WVlad3qOrSaKpRlo0ovnSNMvFVZ7Brr7Brn/v4YjczIVjNOHh4U7biCxevPiKL6+UIiEhgVtvvZWIiAjH+XHjxrF27Vo+/fRTli5dSlpaGiNGjHAkr7y8PHx8fAgMDHSqLyQkhLy8PEeZ4ODqi6gGBwc7lQkJCXG6HhgYiI+PT61lKh9XlnE36TqrpiLRaJJoRDNlNoXhpW6iXN93cdWAEDTNz9NhGU5OTg4BAT9vMFeXld4fffRRvvrqK1JSUpzO33vvvY6fIyIiGDhwIF27dmXjxo3cfffdl61PKeXUlVVTt5YrylROBPBEtxnIn+01kBaNaP68TDejEQTYKLVvbTWrBrhyMkBAQIDTcaVEM3PmTD766CO2bt1Kly5dai3bqVMnunbtypEjRwAIDQ2ltLSUgoICp3L5+fmO1kZoaCgnTpyoVtfJkyedylRtlRQUFFBWVlZrmcpuvKotHXeRb9NqJNGI5k/TzBdXDTCjqxzseqanQ3ILT9xHo5Ti0Ucf5YMPPuDTTz+le/fuV3zOqVOnyMnJoVOnTgAMGDAAb29vkpOTHWVyc3PJzMxkyJAhAERGRlJYWMiePXscZXbv3k1hYaFTmczMTHJzcx1lkpKSsFgsDBgwwFFmx44dTlOek5KSCAsLo1u3bvV6764i36ZVXVwISSnVav5KFMZk0gLxNlV8AZXpu9DVaQ9H1DLNmDGDd955h3fffRd/f3/y8vLIy8ujpKQEgHPnzjF37lx27dpFVlYW27ZtY9KkSQQFBXHXXXcBYLVamTZtGnPmzGHLli3s27ePBx98kH79+jlmofXu3ZuxY8cSHx9PamoqqampxMfHM3HiRHr16gVAdHQ0ffr0ITY2ln379rFlyxbmzp1LfHy8oxswJiYGi8VCXFwcmZmZbNiwgUWLFnlsxhlIoqlGUQ6AXT8EF38Workym/pi0sIBO6XlrWDVAA/csLly5UoKCwsZNmwYnTp1chzvv/8+AGazmf3793PHHXfQs2dPpk6dSs+ePdm1axf+/v6Oel588UXuvPNOpkyZwtChQ2nbti3/+c9/MJt/Xu5q7dq19OvXj+joaKKjo+nfvz9vv/2247rZbGbjxo20adOGoUOHMmXKFO68806WLFniKGO1WklOTubYsWMMHDiQ6dOnk5CQQEJCQkM/9UbTVCv6s72oqAir1UphYaHTIOCldHUQO3vR9TJ8TL9G07zdHKUQ9aPUeS6Uvw9cwMt0I97mSLfHUJffLVfUn/3I1QRYGvf3cZFN5+q/ZzdZrKI6adFUoXEd5eXF6HrplQsL0QxoWlt8zMMAKNczsOs/ejYgIaqQRCNEC2A2dces9QagzP4pStXt5kOjkUU1jUkSjRAthLd5KBoBKM5RWr6jZY7XKBeMzyj52nM3+cSFaCE0zRsf80iUUtjVN5Tat3s6JJfzxKKaovEk0QjRgphMoZi0ipsJ7fohdF32LRaeJ4lGiBbGxxxNxepS5egc9XQ4LqWUK8ZpPP0uWh9JNEK0MCZTG7xMNwJQbk9vWTceu6LbTLrO3E4SjRAtkLe5PxXL05xAV8c9HY4wqLpunXAlkmiEaIE0zQ8v0/UAlNm/8HA0rqOUySWHqNknn3xCXFwc1157Ld7e3rRt2xZ/f3+ioqJYuHAhx4837I8W+cSFaKG8zL8AQFdZ6PopD0fjIpVdX409hJMPP/yQXr16MXXqVEwmE48//jgffPABn3zyCW+88QZRUVFs3ryZa665hkceeYSTJ0/Wq37Zj0aIFsqkXYVZuxa7+o4yfR8W0yhPhySaqUWLFrFkyRImTJiAyVS9/TFlyhQAfvzxR15++WXeeust5syZU+f6JdEI0YJ5mX+Bvfy7iqnOajAmrZ2nQ2oUV9zZLysDVHfp1gS16dy5My+88EK965euMyFaMLMpFJPWGdApt2d4OpxGkxs2jUkSjRAtnPfFsZpyPbPFroEmXKOkpISUlBQOHjxY7dqFCxd46623GlSvJBohWjiT1hVN6wCUUW7wnThl1lnTOXz4ML179+b222+nX79+DBs2zGknz8LCQh566KEG1S2fuBAtnKZpeJtuAqDMnmHoxTal66zpPPnkk/Tr14/8/HwOHTpEQEAAQ4cOJTs7u9F1S6IRohUwm3qi0Q44j13/xtPhNJhsE9B0du7cyaJFiwgKCqJHjx589NFHjBs3jttuu43vv/++UXVLohGiFdA0M17mG4GKGzhb1LI0wiVKSkrw8nKeiPy3v/2NyZMnExUVxeHDhxtct0xvFqKV8DL1pcy+B8UZ7Op7vLRrPR1Svcn05qZz/fXXs3fvXnr37u10fvny5SilmDx5coPrlhaNEK2EpvngZeoHQLlBWzVKuWCMRhJNje666y7ee++9Gq+tWLGC+++/v8H/ZgyTaBYvXszNN9+Mv78/wcHB3HnnnRw6dMjTYQlhKN7mG6hYbDMPXeVesbxoPebNm8emTZsue/2VV15p8P5Ghkk027dvZ8aMGaSmppKcnEx5eTnR0dEUFxd7OjQhDOPSxTbLDbjYpkxvNibDjNEkJiY6PV69ejXBwcGkp6dz++23eygqIYzHy3wT5foB7OooujqNSWvv6ZDqzBXTk2V6c+0uXLjA8uXL2bp1K/n5+dVaMV98Uf8/UAyTaKoqLCwEoH174/ySCNEcmLTAnxfbtH+BxUsW2xQ/e/jhh0lOTuZXv/oVt9xyC5rW+MRsyESjlCIhIYFbb72ViIiIy5az2WxOG/cUFRW5Izwhmj2jLrYps86a3saNG9m0aRNDhw51WZ2G7Kx89NFH+eqrry47Q6LS4sWLsVqtjiM8PNxNEQrRvFUsthlGxWKbX3o6nDqTGzabXufOnfH393dpnYZLNDNnzuSjjz5i69atdOnSpday8+bNo7Cw0HHk5OS4KUohmr+fF9vcb5jFNpXuimVoPP0umrelS5fy5JNP8sMPP7isTsN0nSmlmDlzJhs2bGDbtm107979is+xWCxYLBY3RCeE8Zi0bmhae5Q6Tbmeibd5gKdDEs3AwIEDuXDhAtdccw1t27bF29vb6frp06frXadhEs2MGTN49913+fe//42/vz95eXkAWK1WfH19PRydEMZTsdjmLyi1b6bc/iVephvRNLOnw6qVjNE0vfvvv58ff/yRRYsWERIS0romA6xcuRKAYcOGOZ1fvXo1cXFx7g9IiBbAbOqJZt+Fohi7fggvcx9Ph1QrV9wHI/fR1G7nzp3s2rWLG264wWV1GibRGHG5DCGau8rFNsvsn1Nm/wKzqbdL/oIVxnX99ddTUlLi0joltQvRynmZIgAfFAXY1VFPh1MrXWkuOcTlPf/888yZM4dt27Zx6tQpioqKnI6GMEyLRgjRNCoX2yzX0ym3f4GX6RpPh3R5rti4TFYGqNXYsWMBGDlypNN5pRSapmG313/jPEk0Qgi8zTdQru9DV7nY9eOYTWGeDkl4yKeffury7lNJNEIINM0Ps6k3dv0A5fYvmm2ikVlnTee1115j8uTJ1SZcuYKM0QghAPA23wTgWGyzOZKVAZrOe++9R7du3Rg0aBCLFi3iwIEDLqtbEo0QAqhcbLNifKbMvs/D0Qh327p1K7m5ucycOZOMjAyGDBnCtddeS0JCAtu2bWvwXjQgiUYIcQmvi6sD2PVv0NU5D0dTnbRomlZgYCAPPvgg//d//8fJkyf529/+xoULF4iNjaVjx478+te/5l//+le99wGTRCOEcGjui23qyuSSQ1yZj48PY8eO5ZVXXiEnJ4dPPvmEbt268T//8z8sW7asXnXJZAAhhBNv8y+wlR+vWP9MDUTTms96gUq5YOMzadHUaPPmzQwdOvSyS3oNHDiQgQMH8uyzz1JWVlavuiW1CyGcVC62CaWU664bEBbNW3R0NIGBgdx+++3Mnz+fbdu2UVpaWmPZqgttXokkGiGEk4rFNgdgNvXCrHX1dDhOPDFGs3jxYm6++Wb8/f0JDg7mzjvv5NChQ1XiUixYsICwsDB8fX0ZNmxYtVlbNpuNmTNnEhQUhJ+fH5MnT+bYsWNOZQoKCoiNjXXsoRUbG8uZM2ecymRnZzNp0iT8/PwICgpi1qxZ1RLC/v37iYqKwtfXl86dO/Pss89ecRmvnJwcVq1aRc+ePXnnnXcYMWIEV111FSNHjuS5557j888/p7y8vF6fXSVJNEKIarzM12PxisZk6uDpUJx4ItFs376dGTNmkJqaSnJyMuXl5URHRzsNiL/wwgssW7aMFStWkJaWRmhoKKNHj+bs2bOOMrNnz2bDhg2sW7eOlJQUzp07x8SJE53utI+JiSEjI4PExEQSExPJyMggNjbWcd1utzNhwgSKi4tJSUlh3bp1rF+/njlz5jjKFBUVMXr0aMLCwkhLS2P58uUsWbLkiuMqnTt3JjY2ltdff53vvvuOH374gb///e907dqVf/zjH9x+++0EBgbW67OrpKlWtFplUVERVquVwsJCAgICaiyjVBkXyl8HoI3Xb9C0+jURhWiN6vK75Yr6d44YRjuvxg0tnysvZ8in2xoc68mTJwkODmb79u3cfvvtKKUICwtj9uzZPPnkk0BF6yUkJIS//OUv/O53v6OwsJCOHTvy9ttvc++99wJw/PhxwsPD2bRpE2PGjOHrr7+mT58+pKamMmjQIABSU1OJjIzkm2++oVevXnz88cdMnDiRnJwcwsIqbqpdt24dcXFx5OfnExAQwMqVK5k3bx4nTpxw7Mf1/PPPs3z5co4dO1avu/6/++47Pv30U7Zt28Z///tf7HY7587VfzaitGiquDTvtqIcLIQhuHJRzaqLRdpsddtltLCwEID27dsDcPToUfLy8oiOjnaUsVgsREVFsXPnTgDS09MpKytzKhMWFkZERISjzK5du7BarY4kAzB48OCKBHtJmYiICEeSARgzZgw2m4309HRHmaioKKdNH8eMGcPx48fJysqq9b19//33/OMf/yA2NpYuXbrwi1/8gg8++ICIiAg+/vhjCgoK6vQZVSWzzqopr/Kzj6cCEUJU4colaMLDw53Oz58/nwULFlzhuYqEhARuvfVWIiIiABybMIaEhDiVDQkJcWyHnJeXh4+PT7Wup5CQEMfz8/LyCA4OrvaawcHBTmWqvk5gYCA+Pj5OZbp161btdSqvXW534q5du1JUVMStt97K7bffzsyZMxkwYABmc+M3w5NEI4RolXJycpy6zuqy7fujjz7KV199RUpKSrVrVbukKlc7rk3VMjWVd0WZyt6Z2uKpbNFpmobZbMZsNmMyuabTS7rOqvFCw4yGGcnDQjQvrpwMEBAQ4HRcKdHMnDmTjz76iK1bt9KlSxfH+dDQUODnlk2l/Px8R0siNDSU0tLSal1PVcucOHGi2uuePHnSqUzV1ykoKKCsrKzWMvn5+UD1Vtel8vLy2LVrF+PHj2f37t1MmDCBwMBAJk6cyJIlS0hLS2vwMjSSaKrQNM3pEEI0H57Y+EwpxaOPPsoHH3zAp59+Wq3rqXv37oSGhpKcnOw4V1payvbt2xkyZAgAAwYMwNvb26lMbm4umZmZjjKRkZEUFhayZ88eR5ndu3dTWFjoVCYzM5Pc3FxHmaSkJCwWCwMGDHCU2bFjh9OU56SkJMLCwqp1qVV1/fXX88gjj/D+++87JZ49e/YwatQox7hUfTU60dR1AE0IIYxoxowZvPPOO7z77rv4+/uTl5dHXl6eY7tjTdOYPXs2ixYtYsOGDWRmZhIXF0fbtm2JiYkBwGq1Mm3aNObMmcOWLVvYt28fDz74IP369WPUqFEA9O7dm7FjxxIfH09qaiqpqanEx8czceJEevXqBVTcVNmnTx9iY2PZt28fW7ZsYe7cucTHxzu6AWNiYrBYLMTFxZGZmcmGDRtYtGgRCQkJ9frj+cSJE3z11Vd89dVXfPnll5w9e7bB3/f17hv65JNPeO+99/jss8/Izs5G13Xatm3LL37xC6Kjo3nooYecZkQIIYSrKNX4JWTqO5l05cqVANX2aVm9ejVxcXEAPPHEE5SUlDB9+nQKCgoYNGgQSUlJ+Pv7O8q/+OKLeHl5MWXKFEpKShg5ciRr1qxxGmxfu3Yts2bNcsxOmzx5MitWrHBcN5vNbNy4kenTpzuWi4mJiWHJkiWOMlarleTkZGbMmMHAgQMJDAwkISGBhISEWt9nfn4+27ZtY9u2bWzdupXDhw/j7e3NLbfcwn333cfw4cOJjIys34d3UZ3vo/nwww958sknKSwsZPz48dxyyy107twZX19fTp8+TWZmJp999hm7du0iLi6O//mf/6Fjx44NCqqp1PU+mlL7GgB8zHFyH40QdeCu+2g+vXU07bwa9zt5rryMESnJTRarUZlMJry9vRk4cCDDhw9n2LBhta59Vh91btEsWrSIJUuWMGHChBpnIkyZMgWAH3/8kZdffpm33nrL6W5VIYRoLNWAMZaa6hDVffzxx9x66634+fm5vO46J5pLB6hq07lzZ1544YUGBySEEML9xowZ02R1y6wzIYRhyMZnTWPs2LGO1Qdqc/bsWf7yl7/wt7/9rV71N+hGEaUU//rXv9i6dSv5+fnV5lZ/8MEHDalWCCFq5cqVAcTP7rnnHqZMmYK/vz+TJ09m4MCBhIWF0aZNGwoKCjh48CApKSls2rSJiRMn8te//rVe9Tco0Tz22GO89tprDB8+nJCQELnfRAghDGzatGnExsbyr3/9i/fff59Vq1Y5tifQNI0+ffowZswY0tPTHVOt66NBieadd97hgw8+YPz48Q15uhBCNEhDbrisqQ5RnY+PDzExMY57fwoLCykpKaFDhw713uisqgYlGqvVyjXXXNOoFxZCiPqSrjP3qdx8zRUaNBlgwYIFPPPMM447Y4UQQojLaVCL5p577uG9994jODiYbt26VWtWffHFFy4JTgghLiVdZ8bUoEQTFxdHeno6Dz74oEwGEEK4jUJD0cius0Y+X9RfgxLNxo0b+eSTT7j11ltdHY8QQogWpkFjNOHh4bJGkBDC7eSGzaa3efPmy1579dVXG1RngxLN0qVLeeKJJ664/7QQQriSJ/ajaW0mTJjAnDlznPazOXnyJJMmTWLevHkNqrNBXWcPPvgg58+f59prr6Vt27bVJgOcPn26QcEIIURtZHpz09uxYwexsbFs3ryZd999l6ysLB5++GH69OnDl19+2aA6G5RoXnrppQa9mBBCiOZt0KBB7Nu3j0ceeYQBAwag6zrPPfccjz/+eIMnfjUo0UydOrVBL9ZYO3bs4K9//Svp6enk5uayYcMG7rzzTo/EIoRwPx0XTG+WWWdXdOjQIdLS0ujSpQvHjx/nm2++4fz58w3eQqDOYzTFxcX1qri+5eta5w033OC045wQovWQyQBN7/nnnycyMpLRo0eTmZlJWloa+/bto3///uzatatBddY50fTo0YNFixZx/Pjxy5ZRSpGcnMy4ceP43//93wYFVJtx48bx3HPPcffdd7u8biGEEPDyyy/z4Ycfsnz5ctq0aUPfvn3Zs2cPd999d7XtrOuqzl1n27Zt449//CPPPPMMN954Y43LSO/atQtvb2/mzZvHb3/72wYF5Eo2mw2bzeZ4XFRU5MFohBCNpaM1uutLus5qt3//foKCgpzOeXt789e//pWJEyc2qM46J5pevXrxz3/+k2PHjvHPf/6THTt2sHPnTkpKSggKCuKmm25i1apVjB8/vsatnj1h8eLFPPPMM54OQwjhKq7o+pKus1pVTTKXioqKalCd9Z4M0KVLF/7whz/whz/8oUEv6E7z5s0jISHB8bioqIjw8HAPRiSEEM3b8OHDa51d9umnn9a7zgbNOjMKi8WCxWLxdBhCCBeRRTWb3o033uj0uKysjIyMDDIzMxs847hFJxohRMsiN2w2vRdffLHG8wsWLODcuXMNqrN5DKbU0blz58jIyCAjIwOAo0ePkpGRQXZ2tmcDE0KIFu7BBx/kH//4R4Oea6gWzd69exk+fLjjceX4y9SpU1mzZo2HohJCuIt+8WhsHaL+du3aRZs2bRr0XEMlmmHDhqGU8nQYQggPka6zplf1PkWlFLm5uezdu5c//elPDaqzXl1nI0eO5IMPPrjs9Z9++olrrrmmQYEIIcSV6MoVKzh7+l00b1ar1elo3749w4YNY9OmTcyfP79BddarRbN161a2b9/O008/XeP9KXa7nR9++KFBgQghhPC81atXu7zOek8GWLlyJS+//DJ33XVXg2cgCCFEQ1Ru5dzYQ7hXvcdo7rjjDm699VbuvPNOIiMj+fe//y3dZUIIt5D7aJpGYGBgnbcAaMh+Yw2aDNC7d2/27NnD/fffz80338z777/PqFGjGlKVEEIID2vqPcYaPOvMarWyceNG5s2bx/jx4/nLX/5CTEyMK2MTQggnFZMBGl+HcNbUe4zVa4ymatNK0zSef/553n77bf70pz/xm9/8xqXBCSHEpWSMpun8+c9/5vz5847HBQUFLqu7Xonmcvew3HvvvaSkpLB//36XBCWEEMK9Fi5c6DTBq2vXrnz//fcuqbve05vbt29f47Ubb7yR9PR0Nm7c6JLAhBCiKpkM0HSqNiRceXN8vRLNlfYi6NChA7/+9a8bFZAQQlyOUhVHY+sQ7mWoJWiEEEI0DU3TOHv2LG3atEEphaZpnDt3rtrOxAEBAfWuWxKNEMIwlAu2cpbJADVTStGzZ0+nxzfddJPTY03TsNvt9a5bEo0QwjBkUc2ms3Xr1iarWxJNFZcOgFVkcA8GI4RwIpMBms6VxuAbw1Abn7lH+WV+FkK0Rjt27GDSpEmEhYWhaRoffvih0/W4uDg0TXM6Bg8e7FTGZrMxc+ZMgoKC8PPzY/LkyRw7dsypTEFBAbGxsY5Vk2NjYzlz5oxTmezsbCZNmoSfnx9BQUHMmjWL0tJSpzL79+8nKioKX19fOnfuzLPPPuvx7VUk0QghDEO56KiP4uJibrjhBlasWHHZMmPHjiU3N9dxbNq0yen67Nmz2bBhA+vWrSMlJYVz584xceJEp/GOmJgYMjIySExMJDExkYyMDGJjYx3X7XY7EyZMoLi4mJSUFNatW8f69euZM2eOo0xRURGjR48mLCyMtLQ0li9fzpIlS1i2bFk937VrSddZNV6X+VkI4Wme6DobN24c48aNq7WMxWIhNDS0xmuFhYW88cYbvP322441Id955x3Cw8PZvHkzY8aM4euvvyYxMZHU1FQGDRoEwKpVq4iMjOTQoUP06tWLpKQkDh48SE5ODmFhYQAsXbqUuLg4Fi5cSEBAAGvXruXChQusWbMGi8VCREQEhw8fZtmyZSQkJNR54UxXkxZNFZf+h/DUfxQhhLFs27aN4OBgevbsSXx8PPn5+Y5r6enplJWVER0d7TgXFhZGREQEO3fuBCq2SbZarY4kAzB48GCsVqtTmYiICEeSARgzZgw2m4309HRHmaioKCwWi1OZ48ePk5WV1STvvS4k0QghDEN30QEV3UyXHjabrUExjRs3jrVr1/Lpp5+ydOlS0tLSGDFihKO+vLw8fHx8CAwMdHpeSEgIeXl5jjLBwcHV6g4ODnYqExIS4nQ9MDAQHx+fWstUPq4scyUPP/wwZ8+erXa+uLiYhx9+uE51VCWJRghhGJXTmxt7AISHhzttWbx48eIGxXTvvfcyYcIEIiIimDRpEh9//DGHDx++4nJclfelVKqpB8UVZSonAtS1h+bNN9+kpKSk2vmSkhLeeuutOtVRlQxCCCFapZycHKe73C/tbmqMTp060bVrV44cOQJAaGgopaWlFBQUOLVq8vPzGTJkiKPMiRMnqtV18uRJR4skNDSU3bt3O10vKCigrKzMqUzVlktlN17Vlk5VRUVFKKVQSjlWCKhkt9vZtGlTja2uupAWjRDCMConAzT2gIqlVC49XJVoTp06RU5ODp06dQJgwIABeHt7k5yc7CiTm5tLZmamI9FERkZSWFjInj17HGV2795NYWGhU5nMzExyc3MdZZKSkrBYLAwYMMBRZseOHU5TnpOSkggLC6Nbt261xn3VVVfRvn17NE2jZ8+eBAYGOo6goCAefvhhZsyY0aDPRFo0QgjDaMj05JrqqI9z587x7bffOh4fPXqUjIwM2rdvT/v27VmwYAG//OUv6dSpE1lZWTz11FMEBQVx1113ARWbRE6bNo05c+bQoUMH2rdvz9y5c+nXr59jFlrv3r0ZO3Ys8fHxvPrqqwD89re/ZeLEifTq1QuA6Oho+vTpQ2xsLH/96185ffo0c+fOJT4+3tEyi4mJ4ZlnniEuLo6nnnqKI0eOsGjRIv785z9fsets69atKKUYMWIE69evd1qp38fHh65duzpNRKgPSTRCCFGLvXv3Mnz4cMfjhIQEoGJXypUrV7J//37eeustzpw5Q6dOnRg+fDjvv/8+/v7+jue8+OKLeHl5MWXKFEpKShg5ciRr1qzBbDY7yqxdu5ZZs2Y5ZqdNnjzZ6d4ds9nMxo0bmT59OkOHDsXX15eYmBiWLFniKGO1WklOTmbGjBkMHDiQwMBAEhISHDHXpnJlgKNHjxIeHo7J5LoOL015+pZRNyoqKsJqtVJYWHjZFUiVKqPUvgYAH3McmubtxgiFMKa6/G65ov4l1z6Er9mnUXWV2EuZ+93qJou1pTh//jzZ2dnVVh7o379/veuSFo0QwjAunZ7cmDrE5Z08eZKHHnqIjz/+uMbrDVm9WSYDCCEMw5XTm0XNZs+eTUFBAampqfj6+pKYmMibb77Jddddx0cffdSgOqVFI4QQwuHTTz/l3//+NzfffDMmk4muXbsyevRoAgICWLx4MRMmTKh3ndKiEUIYhqLxqwK0mkHpBiouLnbcL9O+fXtOnjwJQL9+/fjiiy8aVKckGiGEYShc0HUmO2zWqlevXhw6dAiAG2+8kVdffZUff/yRv//97457g+pLus6EEEI4zJ4923FT6Pz58xkzZgxr167Fx8eHNWvWNKhOSTRCCMPQVcXR2DrE5T3wwAOOn2+66SaysrL45ptvuPrqqwkKCmpQnZJohBCG4YmVAVqr0tJSjh49yrXXXssvfvGLRtUlYzRCCCEczp8/z7Rp02jbti19+/YlOzsbgFmzZvH88883qE5JNEIIw3DlopqiZvPmzePLL79k27ZtTis4jxo1ivfff79BdUrXmRDCMGRlgKb34Ycf8v777zN48GCnhTj79OnDd99916A6DdeieeWVV+jevTtt2rRhwIABfPbZZ54OSQghWoyTJ0/WuO9McXFxg7e3N1Sief/995k9ezZPP/00+/bt47bbbmPcuHGOPkQhRMsmS9A0vZtvvtlpd9DK5LJq1SoiIyMbVKehus6WLVvGtGnT+M1vfgPASy+9xCeffMLKlSsbvA2rEMI4pOus6S1evJixY8dy8OBBysvLefnllzlw4AC7du1i+/btDarTMC2a0tJS0tPTHXs1VIqOjmbnzp01Psdms1FUVOR0CCGMSynXHOLyhgwZwueff8758+e59tprSUpKIiQkhF27djl28qwvw7RofvrpJ+x2e7V9r0NCQqrtkV1p8eLFPPPMM+4ITwghWox+/frx5ptvuqw+wySaSlUHo5RSlx2gmjdvntPOckVFRYSHhzdpfEKIpqOjoTdyrbLGPr+lqmuPT0M2izNMogkKCsJsNldrveTn51dr5VSyWCxYLBZ3hCeEcANZgqbpXHXVVbXOKqv8o74hG58ZJtH4+PgwYMAAkpOTueuuuxznk5OTueOOOzwYmRBCGN/WrVsdPyulGD9+PK+//jqdO3dudN2GSTQACQkJxMbGMnDgQCIjI3nttdfIzs7mkUce8XRoQgh3cMVgvrRoahQVFeX02Gw2M3jwYK655ppG122oRHPvvfdy6tQpnn32WXJzc4mIiGDTpk107drV06EJIdxAxmiMyVCJBmD69OlMnz7d02EIIYSoI8MlGiFE6+WK+2DkPpq6a+iSM1VJohFCGIasDNB07r77bqfHFy5c4JFHHsHPz8/p/AcffFDvuiXRCCGEwGq1Oj1+8MEHXVa3JBohhGHIfTRNZ/Xq1U1WtyQaIYRhyFbOxiSJRghhGBUtmkZOb5ZM43aGWb1ZCCGEMUmLRghhGDK92Zgk0QghDEOmNxuTdJ0JIYRoUtKiEUIYhnSdGZMkGiGEYUjXmTFJ15kQokZKlWEr/zfl+jcoJV/PouGkRSOEqJFdP4SujqPsxZi9enk6HKCi26ux98FI15n7SaKpQl3yr7Bi61IPBiOEhyilKNf3A+BlinDZKr6NJSsDGJN0nVVTfpmfhWg9dJWD4gzgjdl0vafDEQYnLRohRDWVrRmz6Xo0zcfD0fxMFtU0Jkk01Xihq3LHz0K0NroqQFfZAHiZ+nk4GmcyvdmY5Ju0ikv7optLv7QQ7lSuZwJg0rpi0qxXKO1eMr3ZmGSMRgjhoJQNu/4NAF6m/h6OpnnYsWMHkyZNIiwsDE3T+PDDD52uK6VYsGABYWFh+Pr6MmzYMA4cOOBUxmazMXPmTIKCgvDz82Py5MkcO3bMqUxBQQGxsbFYrVasViuxsbGcOXPGqUx2djaTJk3Cz8+PoKAgZs2aRWlpqVOZ/fv3ExUVha+vL507d+bZZ591muTkCZJohBAOFUmmHI32mLTOng6nmsoxmsYe9VFcXMwNN9zAihUrarz+wgsvsGzZMlasWEFaWhqhoaGMHj2as2fPOsrMnj2bDRs2sG7dOlJSUjh37hwTJ07Ebrc7ysTExJCRkUFiYiKJiYlkZGQQGxvruG6325kwYQLFxcWkpKSwbt061q9fz5w5cxxlioqKGD16NGFhYaSlpbF8+XKWLFnCsmXL6vemXUy6zoQQACil/zyl2dyvWXYde2J687hx4xg3blzNdSnFSy+9xNNPP83dd98NwJtvvklISAjvvvsuv/vd7ygsLOSNN97g7bffZtSoUQC88847hIeHs3nzZsaMGcPXX39NYmIiqampDBo0CIBVq1YRGRnJoUOH6NWrF0lJSRw8eJCcnBzCwsIAWLp0KXFxcSxcuJCAgADWrl3LhQsXWLNmDRaLhYiICA4fPsyyZctISEjw2H9TadEIIQDQ1Q8ozgIWzNp1ng6nyRUVFTkdNput3nUcPXqUvLw8oqOjHecsFgtRUVHs3LkTgPT0dMrKypzKhIWFERER4Siza9curFarI8kADB48GKvV6lQmIiLCkWQAxowZg81mIz093VEmKioKi8XiVOb48eNkZWXV+/25iiQaIQQA5fpXAHiZ+qBp3h6Opmau7DoLDw93jIdYrVYWL15c73jy8vIACAkJcTofEhLiuJaXl4ePjw+BgYG1lgkODq5Wf3BwsFOZqq8TGBiIj49PrWUqH1eW8QTpOhNCoKtT6Oo4oGE2RXg6nMty5fTmnJwcAgICHOcvbQXUV9UuqYpVRWrvpqpapqbyrihTORHAk12h0qIRQlBur2jNmLVrMGntPByNewQEBDgdDUk0oaGhQPXWQn5+vqMlERoaSmlpKQUFBbWWOXHiRLX6T5486VSm6usUFBRQVlZWa5n8/HygeqvLnSTRCNHKKVWCXR0BwNzMbtCsSnfR4Srdu3cnNDSU5ORkx7nS0lK2b9/OkCFDABgwYADe3t5OZXJzc8nMzHSUiYyMpLCwkD179jjK7N69m8LCQqcymZmZ5ObmOsokJSVhsVgYMGCAo8yOHTucpjwnJSURFhZGt27dXPjO60cSjRCtXLl+ELCjaR0xaaGeDqdWOi4Yo6nna547d46MjAwyMjKAigkAGRkZZGdno2kas2fPZtGiRWzYsIHMzEzi4uJo27YtMTExAFitVqZNm8acOXPYsmUL+/bt48EHH6Rfv36OWWi9e/dm7NixxMfHk5qaSmpqKvHx8UycOJFevSpWzo6OjqZPnz7Exsayb98+tmzZwty5c4mPj3d0AcbExGCxWIiLiyMzM5MNGzawaNEij844AxmjEaJVU8pOuV5xc6GXqXlOafa0vXv3Mnz4cMfjhIQEAKZOncqaNWt44oknKCkpYfr06RQUFDBo0CCSkpLw9/d3POfFF1/Ey8uLKVOmUFJSwsiRI1mzZg1ms9lRZu3atcyaNcsxO23y5MlO9+6YzWY2btzI9OnTGTp0KL6+vsTExLBkyRJHGavVSnJyMjNmzGDgwIEEBgaSkJDgiNlTNOXpW0bdqKioCKvVSmFhodMg4KWUKuNC+esAtPH6TbOdfSOEK5TrRyizbwZ8aeMVi6aZr/icmtTld6sxKuufEvg7fLSGD9oDlCob/1fwapPFKqqTFo0QrdjPe870bXCScSfVgK6vmuoQ7iWJRohWStdPoNQJwISXqa+nw6kTpVywMoAkGreTyQBCtFKOPWe0HmhaWw9HI1oyadEI0QopVYxdfQeAl9k4qzTLNgHGJIlGiFaoYqaZjkkLxaR19HQ4dVYxPblxfV+yw6b7GabrbOHChQwZMoS2bdty1VVXeTocIQxLqfJLpjQbpzUjjMswiaa0tJR77rmH3//+954ORQhDs6tvgQtotMOkdfd0OPWiXHQI9zJM19kzzzwDwJo1azwbiBAGppSi3H5xEoApAk0zzN+aQMPu7K+pDuFehkk0DWGz2Zz2mCgqKvJgNEJ4nq5yUfwEeOFl6u3pcEQrYaw/Z+pp8eLFTvtNhIeHezokITyqcs8Zs6knmtbGw9HUn3LR/4R7eTTRLFiwAE3Taj327t3b4PrnzZtHYWGh48jJyXFh9EIYi66K0FUWULGumRG5cuMz4T4e7Tp79NFHue+++2ot05ilrS0WS6M2MxKiJbHrmYDCpHXBpLX3dDiiFfFoogkKCiIoKMiTIQjRKihVRrn+NWDc1gzIDZtGZZjJANnZ2Zw+fZrs7Gzsdrtjb4gePXrQrl3r2BFQiIay64eBUjQCMGldPR1OgynV+DGWVrRgfbNhmETz5z//mTfffNPx+KabbgJg69atDBs2zENRCdH8KaUuWaXZ2HvOSIvGmAwz62zNmjUVf81UOSTJCFE7XR1DUQB4YzZd7+lwRCtkmBaNEKJhfp7SfD2a5uPhaBpHus6MSRKNEC2Yrs6gq2zA2JMAKilcsPGZKwIR9WKYrjMhRP1Vjs2YtK6YNKuHoxGtlbRohGihlLJh1w8BLWeVZl0pF2wTIG0ad5NEI0QLZde/AcrQCMSkdfZ0OC7hiiVkZAka95OuMyFaIKX0n6c0m/sbekqzMD5p0QjRAunqBxRnAQtm7TpPh+Mych+NMUmiEaIF+vkGzT5omreHo3EdHReM0UjXmdtJ15kQLYyuTqGrHwENs6mvp8MRQlo0QrQ0lTtomrTumDR/D0fjWjLrzJgk0QjRgiilo6uTQMuZ0nwpmXVmTJJohGhBNM2ExetX6CoXkxbq6XBcTsZojEkSjRAtjKZpmLUwT4chhIMkGiGEYUiLxpgk0QghDEPGaIxJpjdXcekS4rKcuBBCNJ60aKopr/KzsffvEKIlUS7oOpMWjftJohFCGIau6Wha4xaR0WURGreTRFONFxpmx89CCCEaR75Jq9A0zbHSrax4K0TzoqPQZNaZ4UiiEUIYhro4wbmxdQj3kllnQgghmpS0aIQQhqGDC7rOhLtJohFCGIbMOjMmSTRCCMPQ0dEamSgk0bifjNEIIUQtFixY4JiNWnmEhv68MrZSigULFhAWFoavry/Dhg3jwIEDTnXYbDZmzpxJUFAQfn5+TJ48mWPHjjmVKSgoIDY2FqvVitVqJTY2ljNnzjiVyc7OZtKkSfj5+REUFMSsWbMoLS1tsvfuKpJohBCGobvof/XVt29fcnNzHcf+/fsd11544QWWLVvGihUrSEtLIzQ0lNGjR3P27FlHmdmzZ7NhwwbWrVtHSkoK586dY+LEidjtdkeZmJgYMjIySExMJDExkYyMDGJjYx3X7XY7EyZMoLi4mJSUFNatW8f69euZM2dOAz9N95GuMyGEYXhqerOXl5dTK8ZRl1K89NJLPP3009x9990AvPnmm4SEhPDuu+/yu9/9jsLCQt544w3efvttRo0aBcA777xDeHg4mzdvZsyYMXz99dckJiaSmprKoEGDAFi1ahWRkZEcOnSIXr16kZSUxMGDB8nJySEsrGIbiKVLlxIXF8fChQsJCAho6EfS5KRFI4RolYqKipwOm8122bJHjhwhLCyM7t27c9999/H9998DcPToUfLy8oiOjnaUtVgsREVFsXPnTgDS09MpKytzKhMWFkZERISjzK5du7BarY4kAzB48GCsVqtTmYiICEeSARgzZgw2m4309HQXfCJNRxKNEMIwdE13yQEQHh7uGA+xWq0sXry4xtccNGgQb731Fp988gmrVq0iLy+PIUOGcOrUKfLy8gAICQlxek5ISIjjWl5eHj4+PgQGBtZaJjg4uNprBwcHO5Wp+jqBgYH4+Pg4yjRX0nUmhDAM1cAxlqp1AOTk5Dh1N1kslhrLjxs3zvFzv379iIyM5Nprr+XNN99k8ODBQPXlqpRSV1zCqmqZmso3pExzJC0aIUSrFBAQ4HRcLtFU5efnR79+/Thy5Ihj3KZqiyI/P9/R+ggNDaW0tJSCgoJay5w4caLaa508edKpTNXXKSgooKysrFpLp7mRRCOEMAyF3SVHY9hsNr7++ms6depE9+7dCQ0NJTk52XG9tLSU7du3M2TIEAAGDBiAt7e3U5nc3FwyMzMdZSIjIyksLGTPnj2OMrt376awsNCpTGZmJrm5uY4ySUlJWCwWBgwY0Kj31NSk60wIYRgV3WbuvWFz7ty5TJo0iauvvpr8/Hyee+45ioqKmDp1KpqmMXv2bBYtWsR1113Hddddx6JFi2jbti0xMTEAWK1Wpk2bxpw5c+jQoQPt27dn7ty59OvXzzELrXfv3owdO5b4+HheffVVAH77298yceJEevXqBUB0dDR9+vQhNjaWv/71r5w+fZq5c+cSHx/frGecgSQaIYSo1bFjx7j//vv56aef6NixI4MHDyY1NZWuXbsC8MQTT1BSUsL06dMpKChg0KBBJCUl4e/v76jjxRdfxMvLiylTplBSUsLIkSNZs2YNZrPZUWbt2rXMmjXLMTtt8uTJrFixwnHdbDazceNGpk+fztChQ/H19SUmJoYlS5a46ZNoOE0p1Wo2ZygqKsJqtVJYWHjZvwCUKqPUvgYAH3McmubtxgiFMKa6/G65ov5wv1GYtMb9fayrcnKKNzdZrKI6Q4zRZGVlMW3aNLp3746vry/XXnst8+fPN8TSC0II12kOYzSi/gzRdfbNN9+g6zqvvvoqPXr0IDMzk/j4eIqLiw3RbBRCuIYnxmhE4xki0YwdO5axY8c6Hl9zzTUcOnSIlStXSqIRQohmzhCJpiaFhYW0b9++1jI2m81pWYmioqKmDksI0YRkK2djMsQYTVXfffcdy5cv55FHHqm13OLFi52WmAgPD3dThEKIpqBjd8kh3MujiaamfR6qHnv37nV6zvHjxxk7diz33HMPv/nNb2qtf968eRQWFjqOnJycpnw7QgghauDRrrNHH32U++67r9Yy3bp1c/x8/Phxhg8fTmRkJK+99toV67dYLHVeVkII0fxJ15kxeTTRBAUFERQUVKeyP/74I8OHD2fAgAGsXr0ak8mQvX5CiEbQlR1o3AKSFXUIdzLEZIDjx48zbNgwrr76apYsWcLJkycd12rajEgIIUTzYYhEk5SUxLfffsu3335Lly5dnK61ooUNhGj1pOvMmAzR/xQXF4dSqsZDCNF6VCSaxq4MIInG3QyRaIQQQhiXIbrOhBACQCkdvZGTAZSSFo27SaIRQhhGRbdXIxONdJ25nSQaIYRhKBdMTXZFHaJ+ZIxGCCFEk5IWjRDCMCpGaKTrzGgk0QghDKNiIF8mAxiNdJ0JIYRoUtKiEUIYhiu2YZatnN1PEo0QwjAqVgNp5BI0sqKI20nXmRBCiCYlLRohhGG4YsaYzDpzP0k0QgjDqLjZsnFdXzLrzP2k60wIIUSTkhaNEMIwXNEakRaN+0miEUIYhozRGJMkGiGEYUiLxphkjEYIIUSTkhZNNV74mOMcPwshmg/pOjMm+SatQtM0wNvTYQghaiDTm41Jus6EEEI0KWnRCCEMpPFrnTW2RSTqTxKNEMIwXLMfjSQad5OuMyGEEE1KWjRCCMOomDHW2K2cpUXjbpJohBAG0vhEI2M07iddZ0IIIZqUtGiEEMbhgskAyGQAt5NEI4QwDBmjMSbpOhNCGIjuoqN+XnnlFbp3706bNm0YMGAAn332WePfSisiiUYIIWrx/vvvM3v2bJ5++mn27dvHbbfdxrhx48jOzvZ0aIYhiUYIYSCqYoylMUc9u86WLVvGtGnT+M1vfkPv3r156aWXCA8PZ+XKlU3zFlsgSTRCCANRjf5ffRJNaWkp6enpREdHO52Pjo5m586dLn5vLVermgxQufREUVGRhyMRomWp/J1yz/IurnmNqt8DFosFi8XidO6nn37CbrcTEhLidD4kJIS8vDyXxNEatKpEc/bsWQDCw8M9HIkQLdPZs2exWq0ur9fHx4fQ0FCXfbm3a9eu2vfA/PnzWbBgQY3lK7YP+ZlSqto5cXmtKtGEhYWRk5ODv7+/4x9JUVER4eHh5OTkEBAQ4OEI686ocYPE7glNHbdSirNnzxIWFubyugHatGnD0aNHKS0tdUl9NSWKqq0ZgKCgIMxmc7UEl5+fX62VIy6vVSUak8lEly5darwWEBBgqC+OSkaNGyR2T2jKuJuiJXOpNm3a0KZNmyZ9jap8fHwYMGAAycnJ3HXXXY7zycnJ3HHHHW6NxchaVaIRQoj6SkhIIDY2loEDBxIZGclrr71GdnY2jzzyiKdDMwxJNEIIUYt7772XU6dO8eyzz5Kbm0tERASbNm2ia9eung7NMFp9orFYLMyfP7/G/tnmzKhxg8TuCUaNu7mYPn0606dP93QYhqUp2W5OCCFEE5IbNoUQQjQpSTRCCCGalCQaIYQQTUoSjRBCiCYliQZYvHgxmqYxe/ZsT4dyRQsWLEDTNKcjNDTU02HV2Y8//siDDz5Ihw4daNu2LTfeeCPp6emeDqtW3bp1q/aZa5rGjBkzPB3aFZWXl/PHP/6R7t274+vryzXXXMOzzz6Lrtd/TxYhGqrVT29OS0vjtddeo3///p4Opc769u3L5s2bHY/NZrMHo6m7goIChg4dyvDhw/n4448JDg7mu+++46qrrvJ0aLVKS0vDbrc7HmdmZjJ69GjuueceD0ZVN3/5y1/4+9//zptvvknfvn3Zu3cvDz30EFarlccee8zT4YlWolUnmnPnzvHAAw+watUqnnvuOU+HU2deXl6GasVU+stf/kJ4eDirV692nOvWrZvnAqqjjh07Oj1+/vnnufbaa4mKivJQRHW3a9cu7rjjDiZMmABUfN7vvfcee/fu9XBkojVp1V1nM2bMYMKECYwaNcrTodTLkSNHCAsLo3v37tx33318//33ng6pTj766CMGDhzIPffcQ3BwMDfddBOrVq3ydFj1UlpayjvvvMPDDz9siNV7b731VrZs2cLhw4cB+PLLL0lJSWH8+PEejky0Jq22RbNu3Tq++OIL0tLSPB1KvQwaNIi33nqLnj17cuLECZ577jmGDBnCgQMH6NChg6fDq9X333/PypUrSUhI4KmnnmLPnj3MmjULi8XCr3/9a0+HVycffvghZ86cIS4uztOh1MmTTz5JYWEh119/PWazGbvdzsKFC7n//vs9HZpoTVQrlJ2drYKDg1VGRobjXFRUlHrsscc8F1QDnTt3ToWEhKilS5d6OpQr8vb2VpGRkU7nZs6cqQYPHuyhiOovOjpaTZw40dNh1Nl7772nunTpot577z311Vdfqbfeeku1b99erVmzxtOhiVakVbZo0tPTyc/PZ8CAAY5zdrudHTt2sGLFCmw2m2EG2P38/OjXrx9HjhzxdChX1KlTJ/r06eN0rnfv3qxfv95DEdXPDz/8wObNm/nggw88HUqdPf744/y///f/uO+++wDo168fP/zwA4sXL2bq1Kkejk60Fq0y0YwcOZL9+/c7nXvooYe4/vrrefLJJw2TZABsNhtff/01t912m6dDuaKhQ4dy6NAhp3OHDx82zCq4q1evJjg42DGwbgTnz5/HZHIeijWbzTK9WbhVq0w0/v7+REREOJ3z8/OjQ4cO1c43N3PnzmXSpElcffXV5Ofn89xzz1FUVGSIv07/8Ic/MGTIEBYtWsSUKVPYs2cPr732Gq+99pqnQ7siXddZvXo1U6dOxcvLOL82kyZNYuHChVx99dX07duXffv2sWzZMh5++GFPhyZaE0/33TUXRhmjuffee1WnTp2Ut7e3CgsLU3fffbc6cOCAp8Oqs//85z8qIiJCWSwWdf3116vXXnvN0yHVySeffKIAdejQIU+HUi9FRUXqscceU1dffbVq06aNuuaaa9TTTz+tbDabp0MTrYhsEyCEEKJJter7aIQQQjQ9STRCCCGalCQaIYQQTUoSjRBCiCYliUYIIUSTkkQjhBCiSUmiEUII0aQk0QghhGhSkmhEs1JaWkqPHj34/PPPG1XP3LlzmTVrlouiEkI0hiQa4XJxcXFomoamaXh5eXH11Vfz+9//noKCgis+97XXXqNr164MHTq0UTE88cQTrF69mqNHjzaqHiFE40miEU1i7Nix5ObmkpWVxeuvv85//vMfpk+ffsXnLV++nN/85jeNfv3g4GCio6P5+9//3ui6hBCNI4lGNAmLxUJoaChdunQhOjqae++9l6SkpFqf88UXX/Dtt986LcOflZWFpmn83//9H7fddhu+vr7cfPPNHD58mLS0NAYOHEi7du0YO3YsJ0+edKpv8uTJvPfee03y/oQQdSeJRjS577//nsTERLy9vWstt2PHDnr27ElAQEC1a/Pnz+ePf/wjX3zxBV5eXtx///088cQTvPzyy3z22Wd89913/PnPf3Z6zi233EJOTg4//PCDS9+PEKJ+jLOxhjCU//73v7Rr1w673c6FCxcAWLZsWa3PycrKIiwsrMZrc+fOZcyYMQA89thj3H///WzZssUxljNt2jTWrFnj9JzOnTs76jXK5mpCtESSaESTGD58OCtXruT8+fO8/vrrHD58mJkzZ9b6nJKSEtq0aVPjtf79+zt+DgkJASq2Jb70XH5+vtNzfH19gYpdJoUQniNdZ6JJ+Pn50aNHD/r378///u//YrPZeOaZZ2p9TlBQ0GVnpl3a7aZpWo3nqm5PfPr0aQA6duzYoPcghHANSTTCLebPn8+SJUs4fvz4ZcvcdNNNfPPNN7hqL77MzEy8vb3p27evS+oTQjSMJBrhFsOGDaNv374sWrTosmWGDx9OcXExBw4ccMlrfvbZZ46ZakIIz5FEI9wmISGBVatWkZOTU+P1Dh06cPfdd7N27VqXvN57771HfHy8S+oSQjScplzVTyGEC+zfv59Ro0bx7bff4u/v3+B6Nm7cyOOPP85XX32Fl5fMeRHCk6RFI5qVfv368cILL5CVldWoeoqLi1m9erUkGSGaAWnRCCGEaFLSohFCCNGkJNEIIYRoUpJohBBCNClJNEIIIZqUJBohhBBNShKNEEKIJiWJRgghRJOSRCOEEKJJSaIRQgjRpP4/xceExvF9hS0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -603,7 +595,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAHFCAYAAADv63LEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZsElEQVR4nO3de1xUdf748dcZLiMiTCgBjuKlm6tibQulaIWkIual26YbX0l2XaqfpuuiXaxdU3eTLmbbVze7ftXKonbNtlYjMG+5iheSVrTs5gUFxBJBCQGZz++PkaMjqMAMc2bg/exxHuuc8zmf+TALbz68z+eiKaUUQgghvJbJ6AYIIYRwjgRyIYTwchLIhRDCy0kgF0IILyeBXAghvJwEciGE8HISyIUQwstJIBdCCC8ngVwIIbycBHLRbKtXr2b27NkNXps3bx4ffvihy99z//79aJrG0qVLXV63EN5KArlottWrVzNnzpwGr7VUIBdC1CeBXAghvJwE8lZs9+7daJrGP/7xD/1cbm4umqbRt29fh7JjxowhOjpaf/3ee+8RGxtLYGAgHTp0YPjw4ezcuVO/npKSwt///ncANE3Tj7rUR0VFBcuWLdPPDx48WL+3uLiYBx54gK5du+Lv70/Pnj2ZM2cOp0+fdmhTYWEhY8eOJSgoCIvFwrhx4yguLnblRyREqyCBvBXr27cvnTt3Zs2aNfq5NWvWEBAQwJ49eygsLATg9OnTbNiwgaFDhwL2tMi9995Lnz59eP/993nrrbc4ceIEN998M3v27AHgz3/+M7/+9a8B2LJli3507tyZLVu2EBAQwG233aaff+mllwB7EL/xxhv59NNPmTVrFp988gkTJ04kPT2d1NRUvZ2VlZUMHTqUrKws0tPT+cc//kFERATjxo1zy2cnhFdRolUbP368uuKKK/TXQ4cOVampqSokJEQtW7ZMKaXUf/7zHwWorKwsdfDgQeXr66umTJniUM+JEydURESEGjt2rH5u8uTJ6kLfQoGBgWrChAn1zj/wwAOqQ4cO6sCBAw7n58+frwC1e/dupZRSixcvVoD617/+5VAuNTVVAWrJkiWN/gyEaO2kR97KDRkyhB9++IF9+/Zx6tQpNm3aRGJiIvHx8WRnZwP2XrrZbOamm27i008/5fTp09x3332cPn1aP9q1a0dcXBzr1693qj3//ve/iY+Px2q1OtQ/YsQIADZs2ADAunXrCAoKYsyYMQ73JyUlOfX+QrRGvkY3QLSsunTJmjVr6NmzJzU1Ndx6660cOXKEv/zlL/q1QYMGERAQwJEjRwC44YYbGqzPZHLud/+RI0f4+OOP8fPza/D6jz/+CMBPP/1EeHh4vesRERFOvb8QrZEE8laua9euXHPNNaxZs4YePXoQExPDZZddxpAhQ5g0aRJbt24lJydHH0YYGhoKwD//+U+6d+/u8vaEhoZy7bXX8tRTTzV43Wq1AtCpUye2bdtW77o87BSiPgnkbcDQoUN5//33iYyMZOTIkQBcc801dOvWjVmzZlFTU6P33IcPH46vry/ff/89d99990XrNZvNgP3BZEBAQL1rlZWV9e4ZNWoUq1ev5sorryQkJOSCdcfHx/P+++/z0UcfOaRX3nnnncZ90UK0IRLI24AhQ4bw0ksv8eOPP/K3v/3N4fySJUsICQnRhx726NGDuXPn8sQTT/DDDz+QmJhISEgIR44cYdu2bQQGBuq99379+gHwzDPPMGLECHx8fLj22mvx9/enX79+rF+/no8//pjOnTsTFBREr169mDt3LtnZ2QwcOJCpU6fSq1cvTp06xf79+1m9ejUvv/wyXbt25b777uOFF17gvvvu46mnnuLqq69m9erVfPrpp27//ITweEY/bRUtr7S0VJlMJhUYGKiqq6v188uXL1eAuuuuu+rd8+GHH6r4+HgVHByszGaz6t69u/r1r3+t1qxZo5epqqpSv//979Xll1+uNE1TgNq3b59SSqm8vDw1aNAg1b59ewWouLg4/b6jR4+qqVOnqp49eyo/Pz/VsWNHFR0drZ544gl18uRJvdyhQ4fU3XffrTp06KCCgoLU3XffrTZv3iyjVoQ4j6aUUsb+KhFCCOEMGX4ohBBeTgK5EEJ4OQnkQgjh5SSQCyGEl5NALoQQXk4CuRBCeLk2NSHIZrNRWFhIUFAQmqYZ3RwhGk0pxYkTJ7BarU6vd3Mhp06dorq62iV1+fv7065dO5fUJS6tTQXywsJCIiMjjW6GEM1WUFBA165dXV7vqVOn6NkzguLiMpfUFxERwb59+ySYu0mbCuRBQUGA/YchODjY4NYI0Xjl5eVERkbq38OuVl1dTXFxGfsLXiQ4OODSN1xEeXklPSL/QHV1daMC+eLFi1m8eDH79+8H7BuizJo1S1/aOCUlhWXLljnc079/f3JycvTXVVVVzJgxg3fffZfKykp9WYpzf+mVlpYydepUPvroI8C+K9bChQu57LLL9DIHDx5k8uTJrF27loCAAJKSkpg/fz7+/v56mV27dvHQQw+xbds2OnbsyAMPPMCf//xnQ//Kb1OBvO6DDg4OlkAuvFJLB4sOHcx06GB2qg6bzdak8l27duXpp5/mqquuAmDZsmXcfvvt7Ny5U9+SMDExkSVLluj3nBtYAaZNm8bHH39MRkYGnTp1Yvr06YwaNYrc3Fx8fHwA+1r2hw4dIjMzE4D777+f5ORkPv74YwBqa2sZOXIkl19+OZs2beKnn35iwoQJKKVYuHAhYP+FOmzYMOLj49m+fTvffPMNKSkpBAYGMn369GZ8Wi5i7AoB7lVWVqYAVVZWZnRThGiSlv7erav/6LFFqur0G04dR48tcrqtISEh6vXXX1dKKTVhwgR1++23X7Ds8ePHlZ+fn8rIyNDPHT58WJlMJpWZmamUUmrPnj0KUDk5OXqZLVu2KEB9/fXXSimlVq9erUwmkzp8+LBe5t1331Vms1n/Wl566SVlsVjUqVOn9DLp6enKarUqm83W7K/XWTJqRQihU6rWJQfYe6/nHlVVVZd8/9raWjIyMqioqCA2NlY/v379esLCwrjmmmtITU2lpKREv5abm0tNTQ0JCQn6OavVSlRUFJs3bwbs+8paLBb69++vlxkwYAAWi8WhTFRUlL4mPtiXda6qqiI3N1cvExcXpy/hXFemsLBQTw0ZQQK5EKJFREZGYrFY9CM9Pf2CZXft2kWHDh0wm808+OCDrFy5kj59+gAwYsQIli9fztq1a3n++efZvn07t956q/6Lobi4GH9//3rr24eHh+sbkRQXFxMWFlbvfcPCwhzKnL8rVUhICP7+/hctU/fayE1P2lSOXAhxcTZ1Gps67XQdUH9Qwbm92PP16tWLvLw8jh8/zooVK5gwYQIbNmygT58+jBs3Ti8XFRVFTEwM3bt3Z9WqVdx1110XrFMp5fBMoaHnC64oo84sIGvkw07pkQshdEqddskBZwcV1B0XC+T+/v5cddVVxMTEkJ6eznXXXceLL77YYNnOnTvTvXt3vv32W8A+1LG6uprS0lKHciUlJXpvOSIiQt+P9lxHjx51KHN+r7q0tJSampqLlqlL8zS0x6y7SCAXQngcpdQFc+o//fQTBQUFdO7cGYDo6Gj8/PzIzs7WyxQVFZGfn8/AgQMBiI2NpayszGEf2K1bt1JWVuZQJj8/n6KiIr1MVlYWZrNZ30ErNjaWjRs3OkycysrKwmq10qNHD9d88c0ggVwIobM/rHS2R17bpPd8/PHH+fzzz9m/fz+7du3iiSeeYP369fzP//wPJ0+eZMaMGWzZsoX9+/ezfv16Ro8eTWhoKHfeeScAFouFiRMnMn36dD777DN27tzJ+PHj6devn74Xbe/evUlMTCQ1NZWcnBxycnJITU1l1KhR9OrVC4CEhAT69OlDcnIyO3fu5LPPPmPGjBmkpqbqKaKkpCTMZjMpKSnk5+ezcuVK5s2bR1pamowjF0J4BmU7jbI5lyNv6v1HjhwhOTmZoqIiLBYL1157LZmZmQwbNozKykp27drFm2++yfHjx+ncuTPx8fG89957DpOjXnjhBXx9fRk7dqw+IWjp0qX6GHKA5cuXM3XqVH10y5gxY1i0aJF+3cfHh1WrVjFp0iQGDRrkMCGojsViITs7m8mTJxMTE0NISAhpaWmkpaU19+NyiTa11Vt5eTkWi4WysjKZECS8Skt/79bVf7h4LsHBzk2rLy8/RZeIWfJz5kbSIxdCnKVO2w9n6xBuJYFcCKE7d9SJM3UI95KHnUII4eWkRy5EC7P3UCsAM5rm4cu62k6Drcb5OoRbSSAXooWdtq3BpgrwNd2Mj/YLo5tzUfbUis+lC16iDuFeEsiFaHEdAFDqpMHtaATbabA5F8ilR+5+kiMXooVp2plAjhcEcuGVpEcuRAvTCAS8JJBLj9wrSSAXooXpPXJVYXBLGqPWBePAmzZFXzhPUitCtDDtTI4cKmhDE6mFG0mPXIgWF3jmf2uBSqC9gW25OM12Gs3mXP9Ok9SK20kgF6KFaZoJe/D+GUUFmgcHcnuO3Mk/1CWQu52kVoRwA82bhiAKryM9ciHcQNM6oFSJ549ckR65V5JALoQb6A88PbxHrqnTaMrJHLnM7HQ7Sa0I4Q5a3VhybxiCKLyN9MiFcAOvyZHbbGBzchy4zeaatohGk0AuhBt4yzR9+/BD5/aelOGH7ieBXAg3ODspqBKlatE0J6fBtxRbrQsedsrMTneTHLkQbmEG6oK35MmFa0mPXAg30DQNjQ4oylDqJJrmoZsS206Dk6kVGX7ofhLIhXAXrQOoMo/Ok2u2WhdM0ZfUirtJakUIN/Gq5WyFV5EeuRBuomkdQHn4crbKBQ87lfTI3U0CuRBuoo8l9+AeuWazOZ0a0WQcudtJakUIN/GWafrC+0iPXAh3OWeavlIKTXNydEhLsNW6YNSKpFbcTQK5EG5ydlJQDVCNfWy5Z7GPWnF2ZqcEcneT1IoQbqJpvkA7wLPz5ML7SI9cCDeyTwo6ZV88S+tkdHPqk9SKV5JALoQbaVogSv2Ip07Tl9SKd5JALoQbefxyttIj90qSIxfCnbxkOVvhXaRHLoQb6dP0PbRHrtmU0xN6NJtyUWtEY0kgF8KNzm4w4Zk5cntqxQV1CLeS1IoQbnR2LHkFSslUduEa0iMXwq0CAA1QwM+gB3YPoVzQI5dFs9xOArkQbqRpJiAQOIni5Dk9dM+gKRuacnL4ofyl4XaSWhHCzc4OQfTQPLnwOtIjF8LNNK0DSnnoEER52OmVJJAL4WYePSnIZnPBhCBJrbibpFaEcDPtzHK2eGKP3ACLFy/m2muvJTg4mODgYGJjY/nkk0/060opZs+ejdVqJSAggMGDB7N7926HOqqqqpgyZQqhoaEEBgYyZswYDh065FCmtLSU5ORkLBYLFouF5ORkjh8/7lDm4MGDjB49msDAQEJDQ5k6dSrV1dUOZXbt2kVcXBwBAQF06dKFuXPnopSxY+clkAvhdp7eI3fB0QRdu3bl6aefZseOHezYsYNbb72V22+/XQ/Wzz77LAsWLGDRokVs376diIgIhg0bxokTJ/Q6pk2bxsqVK8nIyGDTpk2cPHmSUaNGUVt7Ns2TlJREXl4emZmZZGZmkpeXR3Jysn69traWkSNHUlFRwaZNm8jIyGDFihVMnz5dL1NeXs6wYcOwWq1s376dhQsXMn/+fBYsWNDcT9w1VBtSVlamAFVWVmZ0U0QbVmv7SZ2qeVWdqlnW6Hta+nu3rv6fPu6patZe6dTx08c9nW5rSEiIev3115XNZlMRERHq6aef1q+dOnVKWSwW9fLLLyullDp+/Ljy8/NTGRkZepnDhw8rk8mkMjMzlVJK7dmzRwEqJydHL7NlyxYFqK+//loppdTq1auVyWRShw8f1su8++67ymw261/LSy+9pCwWizp16pReJj09XVmtVmWz2Zr99TpLeuRCuNnZIYdVKFVjaFvqcWGPvLy83OGoqqq65NvX1taSkZFBRUUFsbGx7Nu3j+LiYhISEvQyZrOZuLg4Nm/eDEBubi41NTUOZaxWK1FRUXqZLVu2YLFY6N+/v15mwIABWCwWhzJRUVFYrVa9zPDhw6mqqiI3N1cvExcXh9lsdihTWFjI/v37m/ppu4wEciHcTNP8AT/AQ0euuEhkZKSej7ZYLKSnp1+w7K5du+jQoQNms5kHH3yQlStX0qdPH4qLiwEIDw93KB8eHq5fKy4uxt/fn5CQkIuWCQsLq/e+YWFhDmXOf5+QkBD8/f0vWqbudV0ZI3jVqJWNGzfy3HPPkZubS1FREStXruSOO+4wullCNJl9g4lS+0bMWsilb3AXm80Fww/tFRQUFBAcHKyfPrcXe75evXqRl5fH8ePHWbFiBRMmTGDDhg369fP3N1WN2PP0/DINlXdFGXXmQaeRe7B6VY+8oqKC6667jkWLFhndFCGc4rGLZ7kwtVI3CqXuuFgg9/f356qrriImJob09HSuu+46XnzxRSIiIoD6vd2SkhK9JxwREUF1dTWlpaUXLXPkyJF673v06FGHMue/T2lpKTU1NRctU1JSAtT/q8GdvCqQjxgxgr/+9a/cddddRjdFCCd58MgVD6CUoqqqip49exIREUF2drZ+rbq6mg0bNjBw4EAAoqOj8fPzcyhTVFREfn6+XiY2NpaysjK2bduml9m6dStlZWUOZfLz8ykqKtLLZGVlYTabiY6O1sts3LjRYUhiVlYWVquVHj16uP6DaCSvSq00VVVVlcMDlvLycgNbI8RZmhYInji7U9WCs+uJN3Gtlccff5wRI0YQGRnJiRMnyMjIYP369WRmZqJpGtOmTWPevHlcffXVXH311cybN4/27duTlJQEgMViYeLEiUyfPp1OnTrRsWNHZsyYQb9+/Rg6dCgAvXv3JjExkdTUVF555RUA7r//fkaNGkWvXr0ASEhIoE+fPiQnJ/Pcc89x7NgxZsyYQWpqqp4iSkpKYs6cOaSkpPD444/z7bffMm/ePGbNmmVoaqVVB/L09HTmzJljdDOEqEef3elhgVyz2dCczJE3dWOKI0eOkJycTFFRERaLhWuvvZbMzEyGDRsGwCOPPEJlZSWTJk2itLSU/v37k5WVRVBQkF7HCy+8gK+vL2PHjqWyspIhQ4awdOlSfHx89DLLly9n6tSp+uiWMWPGOKRpfXx8WLVqFZMmTWLQoEEEBASQlJTE/Pnz9TIWi4Xs7GwmT55MTEwMISEhpKWlkZaW1qzPylU0pQyektRMmqZd8mFnQz3yyMhIysrKHB7CCOFuNlVETe2/0QjG33fcJcuXl5djsVha7Hu3rv5j74cR3N65jGv5zzY6ji2RnzM3atU9crPZfNEHLEIY5WyPvKJRIzDcxoWjVoT7tOpALoTnqltvpRaoBNob2JZzSCD3Sl4VyE+ePMl3332nv963bx95eXl07NiRbt26GdgyIZrGvsFEe+BnFBVonhLIhVfyqkC+Y8cO4uPj9dd1DxgmTJjA0qVLDWqVEM1jnxT0s30Iona50c2xsynne9TOjnoRTeZVgXzw4MGGLxcphKvYN5go8ayRKzblgtSK/Iy6m1cFciFaE33xLE+aFOSSjSUkkLubV83sFKJVObPBhMdN0xdeR3rkQhjEI7d8kx65V5JALoRBzi6c5UmBXHLk3khSK0IY5OwGE5UoJTvPi+aTHrkQhjEDPtgnBVUAHjCdXdlAOZlakZFlbieBXAiDaJp2Zix5GUqdRNM8IZC7ILUigdztJLUihJE8MU8uvI70yIUwkEYgCg8K5PKw0ytJIBfCQGeHIHrIWHIJ5F5JUitCGMgjhyAKryM9ciEM5GnT9JWtyTu1NViHcC8J5EIY6Zxp+h6xwYSkVrySBHIhDHR2UlANUI19bLmBbLggkLuiIaIpJEcuhIE0zRdoB0ieXDSf9MiFMJh9UtCpMxtMdDK2MdIj90rSIxfCYJpWt3+nBwxBVC46hFtJIBfCYB65nK3wKpJaEcJg6syPoU0VG9wSUDYN5eR65DL80P0kkAthOHvkUxwzuB1IjtxLSWpFCINpen+qvaHtEN5LeuRCGE0zgQKTFmF0S+xrkTu71Zs87HQ7CeRCGE2dAkAjwOCGSI7cW0lqRQiDKSrt/9CMD+TCO0mPXAiD1QVy7cwMT0PZXJBakR6520kgF8Joqi6Qe0CPXGku2LPTNU0RjSeBXAiDKew5ck9IrUiO3DtJjlwIAyllAzznYafwTtIjF8JQZ3rjaBi+hC2AzeSCHLnkVtxNArkQBtJHrNAOTfOAP5DlYadX8oDvHCHaMH0MuQeMWBFeS3rkQhjI08aQK6WhnBy1oiSz4nYSyIUw0Nkx5J4RyCVH7p0ktSKEkTxpDLnwWtIjF8JAZ1MrnpEjVzZcMI5ceuTuJoFcCEN52Bhyl6x+6OT9oskktSKEgZSqG37oIYHcAOnp6dxwww0EBQURFhbGHXfcwd69ex3KpKSkoGmawzFgwACHMlVVVUyZMoXQ0FACAwMZM2YMhw4dcihTWlpKcnIyFosFi8VCcnIyx48fdyhz8OBBRo8eTWBgIKGhoUydOpXq6mqHMrt27SIuLo6AgAC6dOnC3LlzUQY+5ZVALoSB9IedHjZqxdmjKTZs2MDkyZPJyckhOzub06dPk5CQQEWF42bUiYmJFBUV6cfq1asdrk+bNo2VK1eSkZHBpk2bOHnyJKNGjaK2tlYvk5SURF5eHpmZmWRmZpKXl0dycrJ+vba2lpEjR1JRUcGmTZvIyMhgxYoVTJ8+XS9TXl7OsGHDsFqtbN++nYULFzJ//nwWLFjQpK/blSS1IoRB7D04D1r5EM6MWnGyf9fECUGZmZkOr5csWUJYWBi5ubnccsst+nmz2UxERMObb5SVlfHGG2/w1ltvMXToUADefvttIiMjWbNmDcOHD+err74iMzOTnJwc+vfvD8Brr71GbGwse/fupVevXmRlZbFnzx4KCgqwWq0APP/886SkpPDUU08RHBzM8uXLOXXqFEuXLsVsNhMVFcU333zDggULSEtLQ9Pcn1qSHrkQhjkN1PUWPaRHfmbRLGcPsPdczz2qqqoa1YaysjIAOnbs6HB+/fr1hIWFcc0115CamkpJSYl+LTc3l5qaGhISEvRzVquVqKgoNm/eDMCWLVuwWCx6EAcYMGAAFovFoUxUVJQexAGGDx9OVVUVubm5epm4uDjMZrNDmcLCQvbv39+or9HVJJALYZi6/LgvmuZnaEtaQmRkpJ6LtlgspKenX/IepRRpaWncdNNNREVF6edHjBjB8uXLWbt2Lc8//zzbt2/n1ltv1X85FBcX4+/vT0hIiEN94eHhFBcX62XCwsLqvWdYWJhDmfDwcIfrISEh+Pv7X7RM3eu6Mu4mqRUhDHLuOiuewjUzO+33FxQUEBwcrJ8/twd7IQ899BD//e9/2bRpk8P5cePG6f+OiooiJiaG7t27s2rVKu66666LtEU5pDoaSnu4okzdg04j0iogPXIhDKP0yUDtDW7JOepy5M4eQHBwsMNxqUA+ZcoUPvroI9atW0fXrl0vWrZz5850796db7/9FoCIiAiqq6spLS11KFdSUqL3liMiIjhy5Ei9uo4ePepQ5vxedWlpKTU1NRctU5fmOb+n7i4SyIUwzJkx5B4yGcgoSikeeughPvjgA9auXUvPnj0vec9PP/1EQUEBnTt3BiA6Oho/Pz+ys7P1MkVFReTn5zNw4EAAYmNjKSsrY9u2bXqZrVu3UlZW5lAmPz+foqIivUxWVhZms5no6Gi9zMaNGx2GJGZlZWG1WunRo0fzPwgnSCAXwiBnUyue8aATXPuws7EmT57M22+/zTvvvENQUBDFxcUUFxdTWWn/fE6ePMmMGTPYsmUL+/fvZ/369YwePZrQ0FDuvPNOACwWCxMnTmT69Ol89tln7Ny5k/Hjx9OvXz99FEvv3r1JTEwkNTWVnJwccnJySE1NZdSoUfTq1QuAhIQE+vTpQ3JyMjt37uSzzz5jxowZpKam6mmipKQkzGYzKSkp5Ofns3LlSubNm2fYiBWQHLkQxvHAdVZcmSNvrMWLFwMwePBgh/NLliwhJSUFHx8fdu3axZtvvsnx48fp3Lkz8fHxvPfeewQFBenlX3jhBXx9fRk7diyVlZUMGTKEpUuX4uPjo5dZvnw5U6dO1Ue3jBkzhkWLFunXfXx8WLVqFZMmTWLQoEEEBASQlJTE/Pnz9TIWi4Xs7GwmT55MTEwMISEhpKWlkZaW1qSv25U0ZeR0JDcrLy/HYrFQVlbm8BBGCCPU1H6GTf2AjykWX1PURcu29PduXf0FD3Uh2OzcH+rlVTYiFx2WnzM3kh65EAZRnjYZCAyZECScJ4FcCKMoD1swC5qV426oDuFe8rBTCIN42u5AwntJj1wIAyhlw+OWsMWYh53CeRLIhTDEqXP+fekZj26jXJAjbzPDJzyHBHIhDKD0QN4OTfOcDKfkyL2T53wHCdGWeOAYcuG9pEcuhAE89UGnUs7nuNvOzBTPIYFcCAOcHUPuWYEcF6RWnN7zUzSZpFaEMII+htyDJgMJt2vsZhuX4nWB/KWXXqJnz560a9eO6OhoPv/8c6ObJESTKX62/8PjUismlxyiYZ9++ikpKSlceeWV+Pn50b59e4KCgoiLi+Opp56isLCwWfV61Sf+3nvvMW3aNJ544gl27tzJzTffzIgRIzh48KDRTROiiTxvDDlgT4u44hAOPvzwQ3r16sWECRMwmUw8/PDDfPDBB3z66ae88cYbxMXFsWbNGq644goefPBBjh492qT6vWrRrP79+/OrX/1KXy0N7EtT3nHHHY3aRkoWzRKeovr0hyiO4mtKwMfU/ZLl3bVo1g/3XUOQv8+lb7iIE9W1XPHmN/Jzdo4bb7yRP//5z4wcORKT6cL958OHD/Piiy8SHh7O9OnTG12/1zzsrK6uJjc3l8cee8zhfEJCgr5xqhDeQn/Y6WGbSsjMzpZx7mYWF9OlSxeeffbZJtfvNYH8xx9/pLa2tsFNTy+04WlVVZXDw4Ty8vIWbaMQjWH/I9gzR63IhCDv5FU5cmh409ML7cqRnp7usIt3ZGSkO5ooxCWcBmrP/NuzArloWZWVlWzatIk9e/bUu3bq1CnefPPNZtXrNYE8NDQUHx+fBjc9vdCGpzNnzqSsrEw/CgoK3NFUIS6hbos3XzTNz9CWnE9GrbScb775ht69e3PLLbfQr18/Bg8e7LA3aFlZGb/97W+bVbfXfOL+/v5ER0c7bK4KkJ2drW+cej6z2VxvJ28hjHZ2r07Pyo+DMXt2thWPPvoo/fr1o6SkhL179xIcHMygQYNcMurOa3LkAGlpaSQnJxMTE0NsbCyvvvoqBw8e5MEHHzS6aUI0mvLADSXqyMPOlrN582bWrFlDaGgooaGhfPTRR0yePJmbb76ZdevWERgY2Oy6vSqQjxs3jp9++om5c+dSVFREVFQUq1evpnv3Sw/fEsJz1I1Y8bxALlpOZWUlvr6OIffvf/87JpOJuLg43nnnnWbX7VWBHGDSpElMmjTJ6GYI0WxnUyueF8ilR95yfvGLX7Bjxw569+7tcH7hwoUopRgzZkyz6/aaHLkQrYYHL2GrlAty5BLIG3TnnXfy7rvvNnht0aJF3HvvvTR3fqYEciHcTN9UwsMmA4mWNXPmTFavXn3B6y+99BI2m61ZdXtdakUIb1e3YJZn9sidHz7oRat+tBoSyIVwN08etSIzO1vcqVOnWLhwIevWraOkpKReL/yLL75ocp0SyIVwM0/dHUi4x+9+9zuys7P59a9/zY033njBmelNIYFcCDdSysbZJWw9L0cuo1Za3qpVq1i9ejWDBg1yWZ0SyIVwq1Pn/FsCeVvUpUsXgoKCXFqnjFoRwo30ESu0Q9M878dP2VwxTd/or8KzPf/88zz66KMcOHDAZXVKj1wId/LgMeTCPWJiYjh16hRXXHEF7du3x8/PceG0Y8eONblOCeRCuNHZB52el1YBSa24w7333svhw4eZN28e4eHh8rBTCG+jPHRDiTquGUfueSkjT7J582a2bNnCdddd57I65RMXwp08eAy5cI9f/OIXVFZWXrpgE0ggF8KNPH0MuU1pLjnEhT399NNMnz6d9evX89NPP1FeXu5wNIekVoRwK89OreCKjSFkZudFJSYmAjBkyBCH83XbVtbW1jZ020VJIBfCjZTy3N2BhHusXbvWJQ84zyWBXAg3Uh6+qYSMWmk5r776KmPGjGHw4MEur1ty5EK4lWc/7KwL5M4eor53332XHj160L9/f+bNm8fu3btdVrcEciHcRKka4PSZV54ZyEXLWbduHUVFRUyZMoW8vDwGDhzIlVdeSVpaGuvXr2/2WuQggVwIN6rLj/vgqVlN6ZG3rJCQEMaPH8/777/P0aNH+fvf/86pU6dITk7m8ssv57777uOf//wnFRUVTapXArkQbnLuXp2uftjlKjZlcskhLs3f35/ExEReeuklCgoK+PTTT+nRowd/+ctfWLBgQZPqkk9cCDdRXjAZyIg9O9PT07nhhhsICgoiLCyMO+64g717957XLsXs2bOxWq0EBAQwePDgejnmqqoqpkyZQmhoKIGBgYwZM4ZDhw45lCktLSU5ORmLxYLFYiE5OZnjx487lDl48CCjR48mMDCQ0NBQpk6dSnV1tUOZXbt2ERcXR0BAAF26dGHu3LmX3BlpzZo1F50IFBMTw9y5c/nyyy957LHHLlrX+SSQC+E2nj1ixSgbNmxg8uTJ5OTkkJ2dzenTp0lISHBILzz77LMsWLCARYsWsX37diIiIhg2bBgnTpzQy0ybNo2VK1eSkZHBpk2bOHnyJKNGjXIYl52UlEReXh6ZmZlkZmaSl5dHcnKyfr22tpaRI0dSUVHBpk2byMjIYMWKFUyfPl0vU15ezrBhw7BarWzfvp2FCxcyf/78S/aiExISCAkJ4ZZbbuHJJ59k/fr19X5B1Dl/Ia1L0VQb2mCvvLwci8VCWVkZwcHBRjdHtDGnbTupte3ApF2Dn09ck+5t6e/duvq3DImjg69z+fuTp08T+9mGZrf16NGjhIWFsWHDBm655RaUUlitVqZNm8ajjz4K2Hvf4eHhPPPMMzzwwAOUlZVx+eWX89ZbbzFu3DgACgsLiYyMZPXq1QwfPpyvvvqKPn36kJOTQ//+/QHIyckhNjaWr7/+ml69evHJJ58watQoCgoKsFqtAGRkZJCSkkJJSQnBwcEsXryYmTNncuTIEcxmM2Cfrblw4UIOHTp0wbTZ4cOHWbt2LRs2bGDdunXs27ePdu3aERsbS3x8PPHx8fTv3x/fZnz+0iMXwl28YAlbVz7sPH/qeVVVVaPaUFZWBkDHjh0B2LdvH8XFxSQkJOhlzGYzcXFxbN68GYDc3FxqamocylitVqKiovQyW7ZswWKx6EEcYMCAAVgsFocyUVFRehAHGD58OFVVVeTm5upl4uLi9CBeV6awsJD9+/df8Ovq0qULycnJvP7663z//fccOHCAl19+me7du/N///d/3HLLLYSEhDTqMzqfBHIh3ETTLkPTuqJpHY1uiltERkbquWiLxUJ6evol71FKkZaWxk033URUVBQAxcXFAISHhzuUDQ8P168VFxfj7+9fLxCeXyYsLKzee4aFhTmUOf99QkJC8Pf3v2iZutd1ZRojMjKSQYMGERsbS2xsLB06dLhknv1CPHMMlBCtkI+pDz70MboZF+WKRa/q7i8oKHBIrZzbg72Qhx56iP/+979s2rSp3rXzUxZ1a5NczPllGirvijJ1AfhS7fnhhx9Yv34969atY926dZw4cYKBAwdyyy23MHnyZG644YaL3n8hEsiFEDpXTtEPDg5uUo58ypQpfPTRR2zcuJGuXbvq5yMiIgB7b7dz5876+ZKSEr0nHBERQXV1NaWlpQ698pKSEgYOHKiXOXLkSL33PXr0qEM9W7dudbheWlpKTU2NQ5nze94lJSVA/b8aztW9e3fKy8u56aabuOWWW5gyZQrR0dH4+Phc4pO5NEmtCCEMpZTioYce4oMPPmDt2rX07NnT4XrPnj2JiIggOztbP1ddXc2GDRv0IB0dHY2fn59DmaKiIvLz8/UysbGxlJWVsW3bNr3M1q1bKSsrcyiTn59PUVGRXiYrKwuz2Ux0dLReZuPGjQ4jTrKysrBarfTo0eOCX2fdMwJN0/Dx8cHHxweTyTUhWAK5EEJnxMzOyZMn8/bbb/POO+8QFBREcXExxcXF+phrTdOYNm0a8+bNY+XKleTn55OSkkL79u1JSkoCwGKxMHHiRKZPn85nn33Gzp07GT9+PP369WPo0KEA9O7dm8TERFJTU8nJySEnJ4fU1FRGjRpFr169APsQwT59+pCcnMzOnTv57LPPmDFjBqmpqfpfF0lJSZjNZlJSUsjPz2flypXMmzePtLS0i6ZWiouL2bJlC7fddhtbt25l5MiRhISEMGrUKObPn8/27dubPU1fhh8K4QXcNfxw/S1DXTL8cPDGNY1u64WC35IlS0hJSQHsvfY5c+bwyiuvUFpaSv/+/fn73/+uPxAFOHXqFA8//DDvvPMOlZWVDBkyhJdeeonIyEi9zLFjx5g6dSofffQRAGPGjGHRokVcdtllepmDBw8yadIk1q5dS0BAAElJScyfP98hx79r1y4mT57Mtm3bCAkJ4cEHH2TWrFlNnrH71VdfsW7dOtavX8+nn36Kpmn1Jig1hlOBvKqqqlEPMDyFBHLhrVpzIG+rjhw54vDg89tvv8VsNjdrG7gm/T/26aef8u677/L5559z8OBBbDYb7du351e/+hUJCQn89re/dRh/KYTwLko5v5542/kbv2lKSkpYv369Hry/+eYb/Pz8uPHGG/nNb35DfHw8sbGxzaq7UYH8ww8/5NFHH6WsrIzbbruNhx9+mC5duhAQEMCxY8fIz89nzZo1/OUvfyElJYW//OUvXH755c1qkBDCOLKxRMuJiIjAz8+PmJgY7r77bgYPHsygQYMICHB+glijAvm8efOYP38+I0eObPAp69ixYwH7FNQXX3yRN99802FtAiGEd1AuGEcugbxhn3zyCTfddBOBgYEur7tRgfzc4ToX06VLF5599lmnGiSEEK3R8OHDW6xuGX4ohNDJxhItIzExUV/P5WJOnDjBM888w9///vcm1d/kx9NKKf75z3+ybt06SkpK6o17/OCDD5papRDCQ0iOvGXcc889jB07lqCgIMaMGUNMTAxWq5V27dpRWlrKnj172LRpE6tXr2bUqFE899xzTaq/yYH8D3/4A6+++irx8fGEh4d77E4nQgjhKSZOnEhycjL//Oc/ee+993jttdf08eKaptGnTx+GDx9Obm6uPjmpKZocyN9++20++OADbrvttia/mRDCs7ly0SzhyN/fn6SkJH02allZGZWVlXTq1KnJG0mcr8mB3GKxcMUVVzj1pkIIzySpFfepW97XFZr8sHP27NnMmTOnWbOPhBBCuF6Te+T33HMP7777LmFhYfTo0aPenwRffPGFyxonhHAvSa14pyYH8pSUFHJzcxk/frw87BSilVFoKJxMrTh5v2i6JgfyVatW8emnn3LTTTe1RHuEEEI0UZNz5JGRkbKimRCtlEwIanlr1qy54LVXXnmlWXU2OZA///zzPPLIIxfdLVoI4Z3qcuTOHuLCRo4cyfTp0x12GDp69CijR49m5syZzaqzyamV8ePH8/PPP3PllVfSvn37eg87jx071qyGCCGMJ8MPW97GjRtJTk5mzZo1vPPOO+zfv5/f/e539OnThy+//LJZdTY5kP/tb39r1hsJIYSA/v37s3PnTh588EGio6Ox2Wz89a9/5eGHH2724JEmB/IJEyY0642EEJ7PhguGH8qolUvau3cv27dvp2vXrhQWFvL111/z888/N3uJ20blyCsqKppUaVPLCyE8gzzsbHlPP/00sbGxDBs2jPz8fLZv387OnTu59tpr2bJlS7PqbFQgv+qqq5g3bx6FhYUXLKOUIjs7mxEjRvC///u/zWqMEEK0di+++CIffvghCxcupF27dvTt25dt27Zx1113MXjw4GbV2ajUyvr16/nTn/7EnDlz+OUvf9ngEoxbtmzBz8+PmTNncv/99zerMUIIY9nQnE6NSGrl4nbt2kVoaKjDOT8/P5577jlGjRrVrDobFch79erFP/7xDw4dOsQ//vEPNm7cyObNm6msrCQ0NJTrr7+e1157jdtuu63BreCEEF7CFakRSa1c1PlB/FxxcXHNqrNJDzu7du3KH//4R/74xz82682EEKKti4+Pv+jolLVr1za5ziaPWhFCtF6yaFbL++Uvf+nwuqamhry8PPLz85s9KlACuRBCJxOCWt4LL7zQ4PnZs2dz8uTJZtUpCW0hhPAA48eP5//+7/+ada/0yIUQOtuZw9k6RNNt2bKFdu3aNeterwnkTz31FKtWrSIvLw9/f39941IhhOtIaqXl3XXXXQ6vlVIUFRWxY8cO/vznPzerzkanVoYMGcIHH3xwwes//vhji+7lWV1dzT333MP/+3//r8XeQ4i2zqZcsQKi0V+FZ6vbq7Pu6NixI4MHD2b16tU8+eSTzaqz0T3ydevWsWHDBp544gnmzJlT73ptbS0HDhxoViMao+49ly5d2mLvIYQQLW3JkiUur7NJDzsXL17Miy++yJ133tnsp6vuVFVVRXl5ucMhhLiwuq3enD2EezUpR3777bdz0003cccddxAbG8u//vWvFk2nOCs9Pb3Bvx6EEA2TceQtIyQkpNFL1DZnT4cmP+zs3bs327Zt49577+WGG27gvffeY+jQoU1+Y7CPm7xUoN2+fTsxMTHNqn/mzJmkpaXpr8vLy4mMjGxWXUII0VwtvY9Ds0atWCwWVq1axcyZM7ntttt45plnSEpKanI9Dz30EL/5zW8uWqZHjx7NaSIAZrMZs9nc7PuFaGvsDzudr0M4aul9HBodyM//s0DTNJ5++mmuv/56Jk6c2Kz1AUJDQy+6gIwQwr1ckeOWHHnDZs2axWOPPUb79u0BKC0tJSQkxCV1N/php1IN/5odN24cmzZtYteuXS5p0IUcPHiQvLw8Dh48SG1tLXl5eeTl5XnFQ1chhHjqqacc4lX37t354YcfXFJ3k4YfduzYscFrv/zlL8nNzWXVqlUuaVRDZs2axbJly/TX119/vd6u5i7GLoRwJA87W875neELdY6bo9E98ri4OHx9Lxz3O3XqxH333eeSRjVk6dKlKKXqHRLEhXAdpVxzCPfymin6QgjhzTRN48SJE7Rr1w6lFJqmcfLkyXrzW4KDg5tctwRyIYROuWCrN3nY2TClFNdcc43D67oUcd1rTdOora1tct0SyIUQOlk0q+WsW7euxeqW9ciFEDrnF8xq+sPSjRs3Mnr0aKxWK5qm8eGHHzpcT0lJQdM0h2PAgAEOZaqqqpgyZQqhoaEEBgYyZswYDh065FCmtLSU5ORkfbGq5OTkequoHjx4kNGjRxMYGEhoaChTp06lurraocyuXbuIi4sjICCALl26MHfu3EY9uIyLi2vU0RwSyIUQhqqoqOC6665j0aJFFyyTmJhIUVGRfqxevdrh+rRp01i5ciUZGRls2rSJkydPMmrUKIc0RVJSEnl5eWRmZpKZmUleXh7Jycn69draWkaOHElFRQWbNm0iIyODFStWMH36dL1MeXk5w4YNw2q1sn37dhYuXMj8+fNZsGCBCz+RppPUihBCp84cztbRFCNGjGDEiBEXLWM2m4mIiGjwWllZGW+88QZvvfWWvlzI22+/TWRkJGvWrGH48OF89dVXZGZmkpOTQ//+/QF47bXXiI2NZe/evfTq1YusrCz27NlDQUEBVqsVgOeff56UlBSeeuopgoODWb58OadOnWLp0qWYzWaioqL45ptvWLBgAWlpaY1eT8XVpEcuhNC5MrVy/sqjVVVVzW7X+vXrCQsL45prriE1NZWSkhL9Wm5uLjU1NSQkJOjnrFYrUVFRbN68GbDvvmOxWPQgDjBgwAAsFotDmaioKD2IAwwfPpyqqipyc3P1MnFxcQ5LfwwfPpzCwkL279/f7K/PWRLIhRAtIjIy0mEDhfT09GbVM2LECJYvX87atWt5/vnn2b59O7feeqv+i6G4uBh/f/96093Dw8MpLi7Wy4SFhdWrOywszKFMeHi4w/WQkBD8/f0vWqbudV0ZI0hqRQihc+WenQUFBQ5jopu7gN24ceP0f0dFRRETE0P37t1ZtWpVvW3TzlU3nK9OQ2kPV5Spe9DZ2LTK7373O1588UWCgoIczldUVDBlypRmbcAsPXIhhK5u+KGzB9gntpx7uGol0s6dO9O9e3e+/fZbACIiIqiurqa0tNShXElJid5bjoiI4MiRI/XqOnr0qEOZ83vVpaWl1NTUXLRMXZrn/J76hSxbtozKysp65ysrK3nzzTcbVcf5JJALIbzKTz/9REFBAZ07dwYgOjoaPz8/srOz9TJFRUXk5+czcOBAAGJjYykrK2Pbtm16ma1bt1JWVuZQJj8/n6KiIr1MVlYWZrOZ6OhovczGjRsdhiRmZWVhtVovueR2eXk5ZWVlKKU4ceKEw/OD0tJSVq9e3WD6pzEktSKE0BmxaNbJkyf57rvv9Nf79u0jLy+Pjh070rFjR2bPns3dd99N586d2b9/P48//jihoaHceeedgH1/hIkTJzJ9+nQ6depEx44dmTFjBv369dNHsfTu3ZvExERSU1N55ZVXALj//vsZNWoUvXr1AiAhIYE+ffqQnJzMc889x7Fjx5gxYwapqal6iigpKYk5c+aQkpLC448/zrfffsu8efOYNWvWJVMrl112mT4O/twZnnU0TWv2jmYSyIUQOiOGH+7YsYP4+Hj9dd2uXhMmTGDx4sXs2rWLN998k+PHj9O5c2fi4+N57733HHLML7zwAr6+vowdO5bKykqGDBnC0qVL8fHx0cssX76cqVOn6qNbxowZ4zB23cfHh1WrVjFp0iQGDRpEQEAASUlJzJ8/Xy9jsVjIzs5m8uTJxMTEEBISQlpamsNOZBeybt06lFLceuutrFixwmE1WX9/f7p37+4wYqYpNOXKtRQ9XHl5ORaLhbKysmYtTCOEUVr6e7eu/gVXpRDg4+9UXZW11aR9t1R+zi7gwIEDREZGYjK5LrMtPXIhhE7WI2953bt3B+Dnn3/m4MGD9ZYAuPbaa5tcpwRy0abZ/yCtRdPkRwFcO/xQNOzo0aP89re/5ZNPPmnwenNWP5RRK6JNs6m9VNf+E5sybjKHJ3Hl8EPRsGnTplFaWkpOTg4BAQFkZmaybNkyrr76aj766KNm1SndENFmKVXOadsW4DQ2VYJJa3gtDyFcae3atfzrX//ihhtuwGQy0b17d4YNG0ZwcDDp6emMHDmyyXVKj1y0SUrZqKldD5xGIwIfLcroJnkExdn0SnOPNjN6opkqKir08eIdO3bk6NGjAPTr148vvviiWXVKIBdtUq36L4ojgB9+PoPRNPlRAPvuPk6nVmSHoIvq1asXe/fuBewb17/yyiscPnyYl19+WZ/k1FSSWhFtjk39RK3Nvpqdr2kgmhZ0iTuEcJ1p06bps0effPJJhg8fzvLly/H392fp0qXNqlMCuWhTlDrN6dp1gA2T1gOTdrXRTfIoNmU/nK1DXNj//M//6P++/vrr2b9/P19//TXdunUjNDS0WXVKIBdtSq1tB4pSIABf002GbQTgqYyY2dlWVVdXs2/fPq688kp+9atfOVWXJAZFm2GzFVKrdgHga7oZTQswuEWiLfr555+ZOHEi7du3p2/fvhw8eBCAqVOn8vTTTzerTgnkok1Qqpoa23oATNov8DF1N7ZBHsqIzZfbmpkzZ/Lll1+yfv162rVrp58fOnQo7733XrPqlNSKaBNO2zYDFUAQvqYBlyreZsnMzpb34Ycf8t577zFgwACH1F6fPn34/vvvm1Wn9MhFq1dr24dNfQto+PnEo2l+RjdJtGFHjx5tcN3xioqKZj+zkUAuWjWlfua07XMAfLTrMGmN28WlrZIp+i3vhhtuYNWqVfrruuD92muvERsb26w6JbUiWi2lFKdtG4EqNDrhY3JuZEBbIKmVlpeenk5iYiJ79uzh9OnTvPjii+zevZstW7awYcOGZtUpPXLRatnU19hUAeCDr088muZzyXvaOqVcc4gLGzhwIP/5z3/4+eefufLKK8nKyiI8PJwtW7boW8o1lfTIRatkU2WctuUA4GO6AZMWYnCLhDirX79+LFu2zGX1SSAXrY5SNk7XLYilWWVBrCawoWFzcq0UZ+9vrcrLyxtVrjm7KkkgF61OrcpDUQL442eKk9mbTSBT9FtO3ebLF6KUQtO0Zm0sIYFctCo2dZRam30pUPuCWB0MbpEQduvWrdP/rZTitttu4/XXX6dLly5O1y2BXLQa9gWx1gMKk9YTk3aV0U3yPq54WCk98gbFxcU5vPbx8WHAgAFcccUVTtctgVy0GrW2bSiOA+1lQaxmkhy5d5Lhh6JVsNkOU6t2A+BnugVNa3eJO4RoPaRHLryeUlXU2OwTKUxab0ymSINb5L1cMQ5cxpE3nqv+apRALrzeadt/gAo0gvE19Te6OV5NZna2nLvuusvh9alTp3jwwQcJDAx0OP/BBx80uW4J5MKr1dq+x6a+B7QzszdlQSzhmSwWi8Pr8ePHu6xuCeTCaylVcaY3Dj7a9Zi0+ivKiaaRceQtZ8mSJS1WtwRy4ZWUUmfy4lVohOJjut7oJrUKstWbd5JALrySTe1BqcOcXRBLBmC5gr1H7uTwQ4nkbiff/cLr2NRxTtu2AuBruhGTdpmxDRLCYNIjF17l7IJYtWhaF0xaX6Ob1KrI8EPvJIFceJVa204URwGzLIjVAmT4oXeS1IrwGjZVQq3aCYCvaRCaFniJO4RoG6RHLryCUjWcrl2HfUGsK/ExXWl0k1olSa14Jwnkwiuctm1DUQ4E4msaZHRzWi1JrXgnSa0Ij2ezFWBTe4C6BbHMBrdICM8iPXLh0ZQ6RY1tIwA+Wl9Mpq4Gt6h1Uy6Y2SmpFfeTQC48llKK07ZNwM9oXIaP6Uajm9TqycxO7ySpFeGxbOp7bGof9gWxBqNp0u8QoiHykyE8klInzy6IZfoVJu1yg1vUNsiiWd5JArnwOGcXxKpGIwwf7ZdGN6nNkOGH3klSK8Lj1KrdKFUI+OLrEycLYrmRzUVHU2zcuJHRo0djtVrRNI0PP/zQ4bpSitmzZ2O1WgkICGDw4MHs3r3boUxVVRVTpkwhNDSUwMBAxowZw6FDhxzKlJaWkpycjMViwWKxkJyczPHjxx3KHDx4kNGjRxMYGEhoaChTp06lurraocyuXbuIi4sjICCALl26MHfuXJTBv73kJ0R4FJsqpda2DQBfU39ZEKsNqKio4LrrrmPRokUNXn/22WdZsGABixYtYvv27URERDBs2DBOnDihl5k2bRorV64kIyODTZs2cfLkSUaNGkVtba1eJikpiby8PDIzM8nMzCQvL4/k5GT9em1tLSNHjqSiooJNmzaRkZHBihUrmD59ul6mvLycYcOGYbVa2b59OwsXLmT+/PksWLCgBT6ZxtOU0b9KGmH//v385S9/Ye3atRQXF2O1Whk/fjxPPPEE/v7+ja6nvLwci8VCWVkZwcHBLdhi0RxK1VJT+xGKH9G0rviZEmUtlTNa+nu3rv4JnR7A3+TcOP1qWxXLfnqlWW3VNI2VK1dyxx13APbeuNVqZdq0aTz66KOAvfcdHh7OM888wwMPPEBZWRmXX345b731FuPGjQOgsLCQyMhIVq9ezfDhw/nqq6/o06cPOTk59O9v3w4wJyeH2NhYvv76a3r16sUnn3zCqFGjKCgowGq1ApCRkUFKSgolJSUEBwezePFiZs6cyZEjRzCb7Z/T008/zcKFCzl06JBh369e0SP/+uuvsdlsvPLKK+zevZsXXniBl19+mccff9zopgkXqrV9geJHZEEs4ygXHa6yb98+iouLSUhI0M+ZzWbi4uLYvHkzALm5udTU1DiUsVqtREVF6WW2bNmCxWLRgzjAgAEDsFgsDmWioqL0IA4wfPhwqqqqyM3N1cvExcXpQbyuTGFhIfv373fhV940XvGwMzExkcTERP31FVdcwd69e1m8eDHz5883sGXCVWzqCLXqSwB8TTehae0NbpFwVnl5ucNrs9nsEAAbo7i4GIDw8HCH8+Hh4Rw4cEAv4+/vT0hISL0ydfcXFxcTFlZ/K8CwsDCHMue/T0hICP7+/g5levToUe996q717NmzSV+fq3hFj7whZWVldOzY8aJlqqqqKC8vdziE51Gqhpra9dgXxLoKH9MVRjepzaobfujsARAZGak/WLRYLKSnpze7Xef/daaUuuRfbOeXaai8K8rUZaeN/AvSKwP5999/z8KFC3nwwQcvWi49Pd3hGykyMtJNLRRNcdqWA/qCWAONbk6bVjf80NkDoKCggLKyMv2YOXNmk9sTEREBnO2Z1ykpKdF7whEREVRXV1NaWnrRMkeOHKlX/9GjRx3KnP8+paWl1NTUXLRMSUkJUP+vBncyNJDPnj0bTdMueuzYscPhnsLCQhITE7nnnnv4/e9/f9H6Z86c6fCNVFBQ0JJfjmiGWttBbOprAPxMg2VBrFYkODjY4WhqWgWgZ8+eREREkJ2drZ+rrq5mw4YNDBxo/6UfHR2Nn5+fQ5mioiLy8/P1MrGxsZSVlbFt2za9zNatWykrK3Mok5+fT1FRkV4mKysLs9lMdHS0Xmbjxo0OQxKzsrKwWq31Ui7uZGiO/KGHHuI3v/nNRcuc++EUFhYSHx9PbGwsr7766iXrb05OTriPUpWc1hfEisJksl7iDtHSjFjG9uTJk3z33Xf663379pGXl0fHjh3p1q0b06ZNY968eVx99dVcffXVzJs3j/bt25OUlASAxWJh4sSJTJ8+nU6dOtGxY0dmzJhBv379GDp0KAC9e/cmMTGR1NRUXnnlFQDuv/9+Ro0aRa9evQBISEigT58+JCcn89xzz3Hs2DFmzJhBamqqPvomKSmJOXPmkJKSwuOPP863337LvHnzmDVrlqGpFUMDeWhoKKGhoY0qe/jwYeLj44mOjmbJkiWYTF6ZFRJnnF0Qq/LMglg3GN0kwZlA7uwU/SaW37FjB/Hx8frrtLQ0ACZMmMDSpUt55JFHqKysZNKkSZSWltK/f3+ysrIICgrS73nhhRfw9fVl7NixVFZWMmTIEJYuXYqPj49eZvny5UydOlUf3TJmzBiHses+Pj6sWrWKSZMmMWjQIAICAkhKSnIYUGGxWMjOzmby5MnExMQQEhJCWlqa3majeMU48sLCQuLi4ujWrRtvvvmmw/85dTm0xpBx5J6j1vYNp20bABN+Prdj0hr3C72tctc48nEhD+DvZHqrWlXxXmnzxpGL5vGK4YdZWVl89913fPfdd3Tt6rgetRf8HhLnUeoEp232sbs+pmgJ4h5ElrH1Tl6Rn0hJSUEp1eAhvItSipraDUANGuH4aNca3SRxDtXAUMKmHvJj6X5e0SMXrUet2oWiCPDFz2ewLIjlYZRyQY9cArnbyU+RcBubOkatbTsAvqZYNE3yp0K4gvTIhVsoVcvp2nWADZPWDZPWy+gmiQYYMfxQOE8CuXCLWlsuimNAO3xNN8uCWB7KpsDmZHJFdghyP0mtiBZnU8WyIJYQLUh65KJFKVV9ZkEsMGnX4GMyZnU40Tgy/NA7SSAXLcq+INYJoAO+plijmyMuwZ5acb4O4V6SWhEtpta2H5vaC3BmqGHjd3MSQjSe9MhFi7AviPU5AD7atZi0zga3SDSGOvOfs3UI95JALlzOviDWRuAUGh3xMcUY3STRSJJa8U6SWhEuZ1Ob0UwlgAlfn8Foms8l7xFCNJ/0yIXLKGzY1E4w7UfDhI9PJCatk9HNEk0gE4K8kwRy4RKKamz8B7RC+2tbCCZtiMGtEk2llAty5LLYittJIBdOU5RjYwP2fTd90BiAj6mHwa0SzSE9cu8kgVw4RVGIjU1ADdAeE3FodDS6WUK0KRLIRbPY/wD/GsVO7HP5QjFxCxoBRjdNOEFSK95JArloMkUtiq0o9gGgcSUaN6Aho1O8ncL51IiEcfeTQC6aRFF5Jh/+E6Ch8Ss0eqEhqxkKYRQJ5KLRFD+dCeKVgD8mbkJDZmy2JjalXLCMrfTJ3U0CuWgUG/tQ5GD/wzsYE4PRCDK6WcLFZIq+d5JALi7K3j/7EsWeM2e6YGIQGn6GtksIcZYEcnFB+iQf7JN8NPqicS2arOzQask4cu8kgVw0qKFJPiZ6GNwq0dJsuCBHLqkVt5NALupRFJ2Z5FONfZLPLWjImilCeCoJ5EInk3yEjFrxThLIBVA3yWcbih8A0LgCjRtlkk8bI6NWvJMEcnFmks9G4Edkkk/bJjly7ySBvI2TST5CeD8J5G2YfZLPVqAWmeQjQHrk3koCeRtUf5KP9UxPXCb5tHWSI/dOEsjbmPqTfPqgcZ1M8hHCi0kgb0Nkko+4FOWC1Ir0yN1PAnkb4TjJJ+DMTj4yyUc4smk2NM25SfY2maTvdhLIWzmZ5CNE6yeBvBWTST6iqWwoNBm14nUkkLdSMslHNIc6MwDR2TqEe0kgb4Vkko8QbYsE8lam/iSfODSCjW6W8BI2cEFqRbibBPJWouFJPoPQ8De0XcK7yKgV7ySzQFoBRQ02NuhBXKPPmZ64BHHRNDYX/dcUs2fPRtM0hyMiIkK/rpRi9uzZWK1WAgICGDx4MLt373aoo6qqiilTphAaGkpgYCBjxozh0KFDDmVKS0tJTk7GYrFgsVhITk7m+PHjDmUOHjzI6NGjCQwMJDQ0lKlTp1JdXd20D9EAEsi9nH2STyb2mZo+aAzExPUyU1N4lb59+1JUVKQfu3bt0q89++yzLFiwgEWLFrF9+3YiIiIYNmwYJ06c0MtMmzaNlStXkpGRwaZNmzh58iSjRo2itrZWL5OUlEReXh6ZmZlkZmaSl5dHcnKyfr22tpaRI0dSUVHBpk2byMjIYMWKFUyfPt09H4ITJLXixWSSj3A1GzY0J1MjzUmt+Pr6OvTC6yil+Nvf/sYTTzzBXXfdBcCyZcsIDw/nnXfe4YEHHqCsrIw33niDt956i6FDhwLw9ttvExkZyZo1axg+fDhfffUVmZmZ5OTk0L9/fwBee+01YmNj2bt3L7169SIrK4s9e/ZQUFCA1WoF4PnnnyclJYWnnnqK4GDPfdYk3TYvZJ9G/TU21mEP4qGYGCFBXDitbvihs0dTffvtt1itVnr27MlvfvMbfvjBPvdh3759FBcXk5CQoJc1m83ExcWxefNmAHJzc6mpqXEoY7VaiYqK0sts2bIFi8WiB3GAAQMGYLFYHMpERUXpQRxg+PDhVFVVkZub2+SvyZ2kR+5lZJKP8Bbl5eUOr81mM2azuV65/v378+abb3LNNddw5MgR/vrXvzJw4EB2795NcXExAOHh4Q73hIeHc+DAAQCKi4vx9/cnJCSkXpm6+4uLiwkLC6v33mFhYQ5lzn+fkJAQ/P399TKeSgK5F6k/yed6NH4hk3yEy7hy1EpkZKTD+SeffJLZs2fXKz9ixAj93/369SM2NpYrr7ySZcuWMWDAAAA0zfF7XClV79z5zi/TUPnmlPFEEsi9hH2Sz0bgZ2SSj2gpqhmjThqqA6CgoMAhr9xQb7whgYGB9OvXj2+//ZY77rgDsPeWO3c++/1eUlKi954jIiKorq6mtLTUoVdeUlLCwIED9TJHjhyp915Hjx51qGfr1q0O10tLS6mpqanXU/c0kiP3Ajb2YyMbexAPxsRwCeLC4wUHBzscjQ3kVVVVfPXVV3Tu3JmePXsSERFBdna2fr26upoNGzboQTo6Oho/Pz+HMkVFReTn5+tlYmNjKSsrY9u2bXqZrVu3UlZW5lAmPz+foqIivUxWVhZms5no6OjmfxBuID1yD2ZfufBLFHVjZmWSj2hZ9mcwzvXvFLWXLnSOGTNmMHr0aLp160ZJSQl//etfKS8vZ8KECWiaxrRp05g3bx5XX301V199NfPmzaN9+/YkJSUBYLFYmDhxItOnT6dTp0507NiRGTNm0K9fP30US+/evUlMTCQ1NZVXXnkFgPvvv59Ro0bRq1cvABISEujTpw/Jyck899xzHDt2jBkzZpCamurRI1ZAArnHsk/y+Q9wGJCdfIR72NMq7h1+eOjQIe69915+/PFHLr/8cgYMGEBOTg7du3cH4JFHHqGyspJJkyZRWlpK//79ycrKIijo7P6yL7zwAr6+vowdO5bKykqGDBnC0qVL8fE5Owhg+fLlTJ06VR/dMmbMGBYtWqRf9/HxYdWqVUyaNIlBgwYREBBAUlIS8+fPd+bjcAtNKdVm1pwsLy/HYrFQVlbm0b9hFSewsZ6zO/n0x0RPg1sljNTS37t19XcPHIZJc27vVpuq4UBFtsf/nLUm0iP3MDLJRxjJvpa4sz3yNtM39BgSyD2EPR++F8UXyE4+wij2HLlzQ+2amiMXzpNA7gHsPzzbUXwPyCQfYRwjcuTCeRLIDSaTfIQQzpJAbqD6k3wGoWG91G1CtBjZ6s07SSA3iI39KHKQnXyEJ7FRC07+NWiTHLnbSSB3M5nkI4RwNa+ZXTJmzBi6detGu3bt6Ny5M8nJyRQWFhrdrCY5u5OPPYjLTj7C0xi1jK1wjtcE8vj4eN5//3327t3LihUr+P777/n1r39tdLMazT7J51PsMzVNspOP8Eg2VeuSQ7iX16RW/vjHP+r/7t69O4899hh33HEHNTU1+Pk5NxOtpckkHyFES/KaQH6uY8eOsXz5cgYOHOjRQbz+JJ9OZ4K4TPIRnklGrXgnr/q7/tFHHyUwMJBOnTpx8OBB/vWvf120fFVVFeXl5Q6Hu9gn+WxFkQsoNHpiYpgEceHR7IG81slDArm7GRrIZ8+ejaZpFz127Nihl3/44YfZuXMnWVlZ+Pj4cN9993GxNb/S09OxWCz6cf6OJS3FPslnzZmZmhoav0IjVmZqCiFahKGrH/7444/8+OOPFy3To0cP2rVrV+/8oUOHiIyMZPPmzcTGxjZ4b1VVFVVVVfrr8vJyIiMjW3RVNsUxbGzAPsnH78xOPjLJRzjHXasfhgRch6Y51+FQqpbSyi9l9UM3MjRHHhoaSmhoaLPurfv9c26gPt+FNnttKTLJR3g7e1rE2UWzJLXibl7xsHPbtm1s27aNm266iZCQEH744QdmzZrFlVdeecHeuDvJJB/RWigXDB10RR2iabwikAcEBPDBBx/w5JNPUlFRQefOnUlMTCQjI8OtPe6G2Cf5bAYOAbKTjxDC/bwikPfr14+1a9ca3Yx67JN8NgBl2Cf5DJCdfIRXs2FzeuVNSa24n1cEck+kKMbG55yd5HMLGs3L9wvhKZRyQY5cSSB3NwnkTWTPh3+jjw+3T/K5BY32RjdNCNFGSSBvgvo7+fREo7+MDxethiu2aZOt3txPAnkj2Sf5fA4cRXbyEa2VfVivk1P0jZua0mZJIG8EmeQjhPBkEsgvwcYBFFuQST6iLXDFiBMZteJ+EsgvoP4kn85neuIyyUe0XvbJPM6lRmTUivtJIG9A/Uk+vdH4pUzyEUJ4JAnk56k/yac/Jq4wullCuIUretPSI3c/CeTnkEk+oq2THLl3kkB+ho0fzqxcKJN8RNslPXLvJIH8DI3LUJjQ6CaTfIQQXkUC+RkaHTFxGxAkk3xEmyWpFe8kgfwcMj5ctHUy/NA7yXg6IYTwctIjF0Kcw/m1Vpzt0Yumk0AuhNC5Zj1yCeTuJqkVIYTwctIjF0Lo7CNOnN3qTXrk7iaBXAhxDucDueTI3U9SK0II4eWkRy6EOMsFDzuRh51uJ4FcCKGTHLl3ktSKEOIcNhcdTffSSy/Rs2dP2rVrR3R0NJ9//rlzX0obIoFcCGG49957j2nTpvHEE0+wc+dObr75ZkaMGMHBgweNbppXkEAuhDiHsue4nTmakVpZsGABEydO5Pe//z29e/fmb3/7G5GRkSxevNj1X2IrJIFcCHEO5fR/TQ3k1dXV5ObmkpCQ4HA+ISGBzZs3u/Bra73a1MPOuqnD5eXlBrdEiKap+551z/R317zH+T9nZrMZs9lcr9yPP/5IbW0t4eHhDufDw8MpLi52SVtauzYVyE+cOAFAZGSkwS0RonlOnDiBxWJxeb3+/v5ERES4LHB26NCh3s/Zk08+yezZsy94j6Y5jpZRStU7JxrWpgK51WqloKCAoKAgNE2jvLycyMhICgoKCA6Wtcjl86jPUz4TpRQnTpzAarW2SP3t2rVj3759VFdXu6S+hoJwQ71xgNDQUHx8fOr9EikpKanXSxcNa1OB3GQy0bVr13rng4ODJXCdQz6P+jzhM2mJnvi52rVrR7t27Vr0PRri7+9PdHQ02dnZ3Hnnnfr57Oxsbr/9dre3xxu1qUAuhPBMaWlpJCcnExMTQ2xsLK+++ioHDx7kwQcfNLppXkECuRDCcOPGjeOnn35i7ty5FBUVERUVxerVq+nevbvRTfMKbTqQm81mnnzyyQvm7toa+Tzqk8/EfSZNmsSkSZOMboZX0pRs5yGEEF5NJgQJIYSXk0AuhBBeTgK5EEJ4OQnkQgjh5dpkID98+DDjx4+nU6dOtG/fnl/+8pfk5uYa3SzD9OjRA03T6h2TJ082ummGOH36NH/605/o2bMnAQEBXHHFFcydOxebrXnrbAvR0trc8MPS0lIGDRpEfHw8n3zyCWFhYXz//fdcdtllRjfNMNu3b6e2tlZ/nZ+fz7Bhw7jnnnsMbJVxnnnmGV5++WWWLVtG37592bFjB7/97W+xWCz84Q9/MLp5QtTT5oYfPvbYY/znP/+R3UcuYtq0afz73//m22+/bZOLFo0aNYrw8HDeeOMN/dzdd99N+/bteeuttwxsmRANa3OplY8++oiYmBjuuecewsLCuP7663nttdeMbpbHqK6u5u233+Z3v/tdmwziADfddBOfffYZ33zzDQBffvklmzZt4rbbbjO4ZUI0rM2lVn744QcWL15MWloajz/+ONu2bWPq1KmYzWbuu+8+o5tnuA8//JDjx4+TkpJidFMM8+ijj1JWVsYvfvELfHx8qK2t5amnnuLee+81umlCNKjNpVb8/f2JiYlx2Hlk6tSpbN++nS1bthjYMs8wfPhw/P39+fjjj41uimEyMjJ4+OGHee655+jbty95eXlMmzaNBQsWMGHCBKObJ0Q9ba5H3rlzZ/r06eNwrnfv3qxYscKgFnmOAwcOsGbNGj744AOjm2Kohx9+mMcee4zf/OY3APTr148DBw6Qnp4ugVx4pDaXIx80aBB79+51OPfNN9/IKmvAkiVLCAsLY+TIkUY3xVA///wzJpPjj4aPj48MPxQeq831yP/4xz8ycOBA5s2bx9ixY9m2bRuvvvoqr776qtFNM5TNZmPJkiVMmDABX982923hYPTo0Tz11FN069aNvn37snPnThYsWMDvfvc7o5smRMNUG/Txxx+rqKgoZTab1S9+8Qv16quvGt0kw3366acKUHv37jW6KYYrLy9Xf/jDH1S3bt1Uu3bt1BVXXKGeeOIJVVVVZXTThGhQm3vYKYQQrU2by5ELIURrI4FcCCG8nARyIYTwchLIhRDCy0kgF0IILyeBXAghvJwEciGE8HISyIUQwstJIBdOqa6u5qqrruI///mPU/XMmDGDqVOnuqhVQrQtEsgFKSkp+j6dvr6+dOvWjf/3//4fpaWll7z31VdfpXv37gwaNMipNjzyyCMsWbKEffv2OVWPEG2RBHIBQGJiIkVFRezfv5/XX3+djz/+mEmTJl3yvoULF/L73//e6fcPCwsjISGBl19+2em6hGhrJJALAMxmMxEREXTt2pWEhATGjRtHVlbWRe/54osv+O677xyWvd2/fz+apvH+++9z8803ExAQwA033MA333zD9u3biYmJoUOHDiQmJnL06FGH+saMGcO7777bIl+fEK2ZBHJRzw8//EBmZiZ+fn4XLbdx40auueYagoOD61178skn+dOf/sQXX3yBr68v9957L4888ggvvvgin3/+Od9//z2zZs1yuOfGG2+koKCAAwcOuPTrEaK1a9sLTwvdv//9bzp06EBtbS2nTp0CYMGCBRe9Z//+/Vit1gavzZgxg+HDhwPwhz/8gXvvvZfPPvtMz6VPnDiRpUuXOtzTpUsXvV7Z6EOIxpNALgCIj49n8eLF/Pzzz7z++ut88803TJky5aL3VFZW0q5duwavXXvttfq/w8PDAfuWaeeeKykpcbgnICAAsO/QI4RoPEmtCAACAwO56qqruPbaa/nf//1fqqqqmDNnzkXvCQ0NveDIlnPTMpqmNXju/K3Tjh07BsDll1/erK9BiLZKArlo0JNPPsn8+fMpLCy8YJnrr7+er7/+GlftTZKfn4+fnx99+/Z1SX1CtBUSyEWDBg8eTN++fZk3b94Fy8THx1NRUcHu3btd8p6ff/65PtJFCNF4EsjFBaWlpfHaa69RUFDQ4PVOnTpx1113sXz5cpe837vvvktqaqpL6hKiLZE9O4VTdu3axdChQ/nuu+8ICgpqdj2rVq3i4Ycf5r///S++vvIMXoimkB65cEq/fv149tln2b9/v1P1VFRUsGTJEgniQjSD9MiFEMLLSY9cCCG8nARyIYTwchLIhRDCy0kgF0IILyeBXAghvJwEciGE8HISyIUQwstJIBdCCC8ngVwIIbzc/wfNAXTnn9cbLgAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAAHHCAYAAABJFGjMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIn0lEQVR4nO3deVxU5f4H8M+ZkV0HN5ZQ3EvFXUjEnaRQafFqi900NPOmV7sp/txa1G4LWrddU1v1Vt7UFivXvO5eyAXF3LNCMRXQFEaRReY8vz+GOTKCyqxnDvN59zqvF8w888wXgq8P3/MskhBCgIiINEmndgBERGQ/JnEiIg1jEici0jAmcSIiDWMSJyLSMCZxIiINYxInItIwJnEiIg1jEici0jAmcdKUxYsXQ5IknDhxQu1QiDwCkzjZbc2aNZg9e3alx69cuYLZs2djy5Ytbo+JyNswiZPd1qxZgxdffLHS41euXMGLL77IJE7kBkziREQaxiReg/3888+QJAnff/+98lhGRgYkSULXrl2t2g4cOBCxsbHK52vXrkXv3r0RFBSEOnXqICkpCYcOHVKeHzlyJObPnw8AkCRJuU6cOIGQkBAAwIsvvqg8XrHscvToUTz44IOoX78+/P39ERMTYxWjxaFDh3DXXXchICAAjRs3xssvvwxZlp3yvSGqKWqpHQC5Tvv27VG3bl1s27YN999/PwBg+/bt0Ol02L9/P4xGIwwGA2RZRlpaGv72t78BAD777DMkJycjMTERc+fOxZUrV7BgwQL06tUL+/btQ7NmzfDUU0/hzJkz2LBhAz777DPlPUNCQrBgwQKMGzcOf/nLXzBkyBAAQMeOHQGYE3PPnj3RqFEjTJ8+HUFBQVi+fDkGDx6Mr7/+Gn/5y18AADk5OYiPj0dZWZnS7oMPPkBAQIA7v4VEnk9QjZaUlCS6deumfD5kyBAxZMgQodfrxdq1a4UQQuzdu1cAEN999524dOmSqFu3rhgzZoxVPzk5OSI4ONjq8fHjx4uqfoTOnTsnAIhZs2ZVeq5///6iQ4cOori4WHlMlmXRo0cPcfvttyuPTZw4UQAQO3fuVB7Ly8sTwcHBAoDIysqy+XtBVBOxnFLD9e7dG3v37kVhYSEAYMeOHRg0aBA6d+6M7du3AzCPziVJQq9evbBhwwbk5+fj0Ucfxfnz55VLr9cjNjYWmzdvtjuWCxcuYNOmTXj44Ydx6dIlpe8///wTiYmJOH78OE6fPg3AfNO0e/fu6Natm/L6kJAQPPbYYw58N4hqHpZTarjevXujrKwM6enpiIyMRF5eHnr37o1Dhw5ZJfGoqCjUr18fx48fBwDcddddVfZnMBjsjuXXX3+FEAIvvPACXnjhhSrb5OXloVGjRjh58qRVjd6idevWdr8/UU3EJF7DxcTEwN/fH9u2bUOTJk0QGhqKO+64A71798b777+PkpISbN++XalFW24cfvbZZwgPD6/UX61a9v/IWPr+v//7PyQmJlbZplWrVnb3T+SNmMRrOF9fX3Tr1g3bt29HkyZN0Lt3bwDmEXpJSQm++OIL5Obmok+fPgCAli1bAgBCQ0ORkJBw074lSbLp8RYtWgAAfHx8btl306ZNlb8KKjp27NhNX0fkbVgT9wK9e/fGzp07sXnzZiWJN2zYEG3btsXcuXOVNgCQmJgIg8GAV199FVevXq3U17lz55SPg4KCAAD5+flWbQIDA6t8PDQ0FP369cOiRYtw9uzZm/Y9aNAg/PTTT9i1a5fV81988UV1v2wiryAJwdPua7r169djwIABAMzzxC1zxMeOHYtFixahWbNmyMrKUtovXboUI0aMQFRUFIYNG4aQkBBkZ2dj9erV6NmzJ+bNmwcAWLFiBR5++GGMGDECiYmJ0Ov1GDZsGACgXbt2uHDhAl544QXUr18f7du3R/v27XH48GH06tULOp0OY8aMQYsWLZCbm4v09HT88ccf2L9/PwDg7Nmz6NChA2RZxjPPPGM1xfDnn39GVlYWmjVr5sbvIpGHUnl2DLmB0WgUer1e1KlTR5SVlSmPf/755wKAGDFiRKXXbN68WSQmJorg4GDh7+8vWrZsKUaOHCn27NmjtCkrKxNPP/20CAkJEZIkWU03TEtLE9HR0cLX17fSdMPffvtNPP744yI8PFz4+PiIRo0aiXvvvVd89dVXVjH8/PPPom/fvsLf3180atRIvPTSS+Ljjz/mFEOiCjgSJyLSMNbEiYg0jEmciEjDmMSJiDSMSZyISMOYxImINIxJnIhIw7xq2b0syzhz5gzq1Klzw6XhRJ5ICIFLly4hIiICOp1rxl7FxcUoLS11Sl++vr7w9/d3Sl90c16VxM+cOYPIyEi1wyCy26lTp9C4cWOn91tcXIzmzcORk1PglP7Cw8ORlZXFRO4GXpXE69SpA8D8i+DIlqpE7mY0GhEZGan8DDtbaWkpcnIKcOLUOzAYHDs9yWgsQrPIZ1BaWsok7gZelcQtJRSDwcAkTprk6jJg7dp+qF3bz6E+eA6qe3lVEieimxOiDEKUOdwHuQ+TOBEphDBBCJPDfZD7cIohEZGGcSRORApZlEF2sBzi6OvJNkziRKRgTVx7WE4hItIwjsSJSGG+senoSJw3Nt2JSZyIFEIug5AdTOIOvp5sw3IKEZGGcSRORNeIMvPlaB/kNkziRKTg7BTtYTmFiEjDOBIncjHzyPQKAD9IkmObS7mcXAbIVx3vg9yGSZzIxcrkTRD4A3qpJ/RSa7XDuSlzOUXvcB/kPkziRC4mSbUhBCBQqHYotyaXAbJjSZwjcfdiTZzIxSQElX90WdU4qGbiSJzI5cxJXAiOxMn5mMSJXEySagMCEJoYiZucMM+by+7dieUUIhe7Vk65AiGEqrFQzcOROJHLWZK4CUAxAMcOInYlSS6DJDs2tpNYTnErJnEiF5MkHYBAAFcgcBmSBydxc03cwT/QmcTdiuUUIje4VlLRwM1N0hSOxIncwDxX/Jx5hoqkdjQ3wZG45jCJE7lF+TRDD5+hIokySMLBmjhXbLoVyylEbiBpaa44aQpH4kRuYJkr7vGrNmUZkB2c5y3LzomFqoVJnMgtLOUUzx6Jm6cYOla05xRD92ISJ3IDCbXLPyqCECZIkoNL211FNjnhxiZXbLoTa+JEbuEHwJK4PXs0TtrCkTiRG0iSBHNJxQiBQkgwqB1S1eQywMFyCqcYuheTOJGbSKgNASOEuOyxc8Ul2eSEZfcsp7gTyylEbiJJXLVJzseROJGbWG5uevSCH+GEG5uCI3F3YhInchvPX/AjybLD5RCJ88TdiuUUIjexlFM8fa44aQtH4kRucm2u+GUIIcpnrHgY2eSE2Sksp7gTkziR21hubJYBKIV57rhnMc9OcXTFJpO4O7GcQuQmklQLgD8AD7+5SZrCkTiRG0kIgkAxzNMMG6gdTmUsp2gOkziRWwUB+NNjD4dgOUV7mMSJ3Mh8wo8Hl1M4Etcc1sSJ3IhnbZKzcSRO5FaWBT+eORKXZOHwYh1JFk6KhqqDSZzIjSwn/Hjsgh/ZBDi64JLlFLdiOYXIja4t+LkCIbg8/Xpz5syBJEmYOHGi8lhxcTHGjx+PBg0aoHbt2hg6dChyc3OtXpednY2kpCQEBgYiNDQUU6ZMQVmZ9Za4W7ZsQdeuXeHn54dWrVph8eLFld5//vz5aNasGfz9/REbG4tdu3ZZPV+dWNyNSZzIrfxhnpYiAFxROZYqCFP5aNyBy84NsHbv3o1FixahY8eOVo9PmjQJP/zwA1asWIGtW7fizJkzGDJkiPK8yWRCUlISSktLkZaWhiVLlmDx4sWYOXOm0iYrKwtJSUmIj49HZmYmJk6ciCeffBLr169X2ixbtgwpKSmYNWsW9u7di06dOiExMRF5eXnVjkUVwosUFBQIAKKgoEDtUMiLlZQtEyVlHwuTnFPt17j6Z9fS//kNUaI0rYND1/kNUTbHeunSJXH77beLDRs2iL59+4pnnnlGCCFEfn6+8PHxEStWrFDaHjlyRAAQ6enpQggh1qxZI3Q6ncjJufb9XLBggTAYDKKkpEQIIcTUqVNFu3btrN7zkUceEYmJicrn3bp1E+PHj1c+N5lMIiIiQqSmplY7FjVwJE7kZsqWtB68m6G7jR8/HklJSUhISLB6PCMjA1evXrV6vE2bNmjSpAnS09MBAOnp6ejQoQPCwsKUNomJiTAajTh06JDS5vq+ExMTlT5KS0uRkZFh1Uan0yEhIUFpU51Y1MAbm0RuJklBEAKAJ84Vd+KNTaPRaPWwn58f/Pwq7xfz5ZdfYu/evdi9e3el53JycuDr64u6detaPR4WFoacnBylTcUEbnne8tzN2hiNRhQVFeHixYswmUxVtjl69Gi1Y1EDR+JEbufBW9LKsnMuAJGRkQgODlau1NTUSm936tQpPPPMM/jiiy/g7+/v7q+2RuBInMjNrpVTPHAk7kSnTp2CwXDtQOiqRuEZGRnIy8tD165dlcdMJhO2bduGefPmYf369SgtLUV+fr7VCDg3Nxfh4eEAgPDw8EqzSCwzRiq2uX4WSW5uLgwGAwICAqDX66HX66tsU7GPW8WiBo7EidzMo8/adOJI3GAwWF1VJfH+/fvjwIEDyMzMVK6YmBg89thjysc+Pj7YuHGj8ppjx44hOzsbcXFxAIC4uDgcOHDAahbJhg0bYDAYEBUVpbSp2IeljaUPX19fREdHW7WRZRkbN25U2kRHR98yFjVwJE7kdpazNj0viZuPZ3O8j+qqU6cO2rdvb/VYUFAQGjRooDw+evRopKSkoH79+jAYDHj66acRFxeH7t27AwDuueceREVFYcSIEXjttdeQk5OD559/HuPHj1f+4Rg7dizmzZuHqVOn4oknnsCmTZuwfPlyrF69WnnflJQUJCcnIyYmBt26dcPbb7+NwsJCjBo1CgAQHBx8y1jUwCRO5GbX9k8pgRBXIUk+qsZjRZadcGPTuYuY3nrrLeh0OgwdOhQlJSVITEzE+++/rzyv1+uxatUqjBs3DnFxcQgKCkJycjL++c9/Km2aN2+O1atXY9KkSXjnnXfQuHFjfPTRR0hMTFTaPPLIIzh37hxmzpyJnJwcdO7cGevWrbO62XmrWNQgCSG8ZqMDo9GI4OBgFBQUWNXqiNyt1PQZgKvw0Q2BJNW9ZXtX/+xa+v/zu6YwBDlWZTUWymjwwEn+nrmJpmri27Ztw3333YeIiAhIkoSVK1eqHRKRXZSbm542zdCJNXFyD00l8cLCQnTq1Anz589XOxQiB1l2M/SwujiTuOZoqiY+cOBADBw4UO0wiBx27XAID0vipDmaSuK2KikpQUlJifL59SvIiNRy7eamh5VThAlwdD9w7s7oVpoqp9gqNTXVasVYZGSk2iERlfPMcop5iqHjF7lPjU7iM2bMQEFBgXKdOnVK7ZCIAJQfDgGWU8hxNbqccqMNd4jUVvGsTSEEJMnBw4mdxQPnidPN1egkTuS5LEncBKAYQICKsVTAJK45mkrily9fxq+//qp8npWVhczMTNSvXx9NmjRRMTIi20iSDkAggCsQuAzJU5I4aY6mkviePXsQHx+vfJ6SkgIASE5OrvK8PCJPJiEIAldg3ggrRO1wzGTh+Eiap927laaSeL9+/eBFuwRQDWeeK37OPEPFQ0ri5iTuhD7IbTSVxIlqFsvhEB40V1yWAdnBf1GYxN2qRk8xJPJkkofOFSdt4UicSCWSVBvwtLM2ORLXHCZxItV44FmbrIlrDsspRCqxbEcLFEEIk6qxkHZxJE6kGj8AepgX/BQC8IADFIQMCAfLKZxB5lZM4kQqMS+1DwJghEAhJI9I4k4opzCJuxXLKUQqUk74ER50c5M0hSNxIhVJUlD5wNVDbm7yxqbmMIkTqcrDFvwwiWsOyylEKrpWTvGQkThpDkfiRCqSpKDyBT+ekcSF7Pjpajydzb2YxIlUpIzEcdkzDodgOUVzmMSJVGU5HKIMQCnMc8dVJMMJSdwZgVB1sSZOpCJJqgXAH4AH3dwkTeFInEhl5sMhimGuizdQNxiOxDWHI3Ei1XnQlrTCSRe5DZM4kcok6drNTSJbsZxCpDZh/jUUIlflQAAhSxAO7ifOKYbuxSROpDpz1hO4oHIcYE1cg1hOIVKbZBlLBd20GVFVOBInUplUPpbSSWEqRwLzXuKOHs/GG5tuxSROpDLz9ELAMl9cTayJaw/LKUSqKwIASAhQOQ7SIo7EiVQmRFH5R+qPxCE7oZzCkbhbMYkTqc5cTpEkDxiJC8kJZ2w6JxSqHiZxIpVdq4mrn8RZE9ce1sSJVCSEDGUk7gnlFNIcjsSJVGUZhUtQfRtaAJB1TqiJs57iTkziRCq6VkrxgyR5wB/GvLGpOR7wU0PkzTi9kBzDkTiRioTwnIU+ACCEBOHg7BTBaopbMYkTqap8JC55RhJnTVx7WE4hUpEnTS8kbeJInEhVnlUTFzKcME+cI3F3YhInUpGn1cSds4uhg68nm7CcQqQqS03cM0bipD0ciROpyJO2oQWcNTuFI3F3YhInUokQAp5WEzfPTnHwD3Qu9nErJnEi1ZQBMJV/7CEjcadsgMWRuDuxJk6kGss+4rUgST6qRkLaxZE4kUo8rR4OsCauRUziRKrxsHo4wJq4BrGcQqQSj5sjTprEkTiRajxvjjhvbGoPkziRSlgTJ2dgOYVINR5YEyfN4UicSCUeWRPnjU3NYRInUg1r4uQ4llOIVOKJNXHSHo7EiVQghAzLSfeeVBPnjU3tYRInUkVJhY/9VIuiEuGEmjjPhHArJnEiFQhl3xR/SJLnVDVZE9cez/npIfIqlumFrIeTYzgSJ1LBtemFnlMPBwAhHK9pC5ZT3IpJnEgV5Tc1JQ8biTuhnOLwGZ1kE5ZTiFRwrSbuWSNx0h7NJfH58+ejWbNm8Pf3R2xsLHbt2qV2SER28MyauBA6p1xU2ZEjRzBr1izcddddaNmyJW677TZ07NgRycnJWLp0KUpKSm7dSRU09d1etmwZUlJSMGvWLOzduxedOnVCYmIi8vLy1A6NyCaeWhOHLDnnssGCBQvQsWNHGAwGGAwGxMXFYe3atcrzxcXFGD9+PBo0aIDatWtj6NChyM3NteojOzsbSUlJCAwMRGhoKKZMmYKysjKrNlu2bEHXrl3h5+eHVq1aYfHixZViudUgsTqxXG/v3r1ISEhAly5dsGPHDsTGxmLixIl46aWXMHz4cAgh8NxzzyEiIgJz5861OZlrKom/+eabGDNmDEaNGoWoqCgsXLgQgYGB+OSTT9QOjchGnrfkXi2NGzfGnDlzkJGRgT179uCuu+7CAw88gEOHDgEAJk2ahB9++AErVqzA1q1bcebMGQwZMkR5vclkQlJSEkpLS5GWloYlS5Zg8eLFmDlzptImKysLSUlJiI+PR2ZmJiZOnIgnn3wS69evV9pUZ5B4q1iqMnToUAwZMgQ5OTnYuHEjUlNT8fTTT+PJJ5/E1KlT8e9//xtZWVlYtWoV9u3bhzfeeMOm758khDbuJZeWliIwMBBfffUVBg8erDyenJyM/Px8fPfdd7fsw2g0Ijg4GAUFBTAYDC6MlujmSk3LAVxGLd290Emht2zv6p9dS/+/jWiNOr56h/q6VGpCy8+OORRr/fr18frrr+PBBx9ESEgIli5digcffBAAcPToUbRt2xbp6eno3r071q5di3vvvRdnzpxBWFgYAGDhwoWYNm0azp07B19fX0ybNg2rV6/GwYMHlfcYNmwY8vPzsW7dOgBAbGws7rzzTsybNw8AIMsyIiMj8fTTT2P69OkoKCi4ZSxVuXr1Knx8qn+Gqq3tNTMSP3/+PEwmk/I/ySIsLAw5OTlVvqakpARGo9HqIlKbedzkoTXx8tkpjl4AKv3uVadMYDKZ8OWXX6KwsBBxcXHIyMjA1atXkZCQoLRp06YNmjRpgvT0dABAeno6OnToYJUbEhMTYTQaldF8enq6VR+WNpY+SktLkZGRYdVGp9MhISFBaVOdWKpiS0K2p71mkrg9UlNTERwcrFyRkZFqh0QEoAyAqfzjmltOiYyMtPr9S01NvWHbAwcOoHbt2vDz88PYsWPx7bffIioqCjk5OfD19UXdunWt2lccvOXk5FQ5uLM8d7M2RqMRRUVF1RokVieWmykqKsKOHTtw+PDhSs8VFxfj3//+9y37qIpmknjDhg2h1+sr3UTIzc1FeHh4la+ZMWMGCgoKlOvUqVPuCJXoFizTC2tBkmwbdbmaM2ennDp1yur3b8aMGTd839atWyMzMxM7d+7EuHHjkJycXGWy06pffvkFbdu2RZ8+fdChQwf07dsXZ8+eVZ4vKCjAqFGj7OpbM0nc19cX0dHR2Lhxo/KYLMvYuHEj4uLiqnyNn5+fcsfbchGpzZO3oHVmOeX63z0/vxtv9OXr64tWrVohOjoaqamp6NSpE9555x2Eh4ejtLQU+fn5Vu0rDt7Cw8OrHNxZnrtZG4PBgICAgGoNEqsTy41MmzYN7du3R15eHo4dO4Y6deqgZ8+eyM7OvunrqkMzSRwAUlJS8OGHH2LJkiU4cuQIxo0bh8LCQrv/BSNSh2ULWg9M4uVb0Tp6OUqWZZSUlCA6Oho+Pj5Wg7djx44hOztbGbzFxcXhwIEDVrNINmzYAIPBgKioKKVNxT4sbSx9VGeQWJ1YbiQtLQ2pqalo2LAhWrVqhR9++AGJiYno3bs3fv/9d3u+RQpNLbt/5JFHcO7cOcycORM5OTno3Lkz1q1bV6mOReTJhOBqzYpmzJiBgQMHokmTJrh06RKWLl2KLVu2YP369QgODsbo0aORkpKC+vXrw2Aw4Omnn0ZcXJwyG+See+5BVFQURowYgddeew05OTl4/vnnMX78eGX0P3bsWMybNw9Tp07FE088gU2bNmH58uVYvXq1EkdKSgqSk5MRExODbt264e2337YaJFYnlhspKipCrVrX0q0kSViwYAEmTJiAvn37YunSpXZ//zSVxAFgwoQJmDBhgtphEDnAc+eIq3EoRF5eHh5//HGcPXsWwcHB6NixI9avX4+7774bAPDWW29Bp9Nh6NChKCkpQWJiIt5//33l9Xq9HqtWrcK4ceMQFxeHoKAgJCcn45///KfSpnnz5li9ejUmTZqEd955B40bN8ZHH32ExMREpU11Bom3iuVG2rRpgz179qBt27ZWj1umM95///02fc8q0sw8cWfgPHHyBGXyT5DFYeikjqili6nWa9w1T/zIQx1Rx8fBeeJXTWi74mf+nlWQmpqK7du3Y82aNVU+//e//x0LFy6ELNt+yrSmauJENYNljrjnjcTJNWbMmHHDBA4A77//vl0JHNBgOYVI667tm+KJNzYd38DKi/649whM4kRu58E1cR7P5lLFxcV47733sHnzZuTl5VUafe/du9fmPpnEidzMk+eJk2uNHj0aP/74Ix588EF069YNkuT4P3hM4kRuJISMa/PEPXAkrsLsFG+yatUqrFmzBj179nRan0ziRG5VcROoG69gVAuTuGs1atQIderUcWqfnJ1C5EbXjmXzhyR53q+fkJ2x9F7tr8JzvfHGG5g2bRpOnjzptD45EidyK89dck+uFxMTg+LiYrRo0QKBgYGVtp29cOGCzX0yiRO5kacvuWc5xbUeffRRnD59Gq+++irCwsJ4Y5NIe8pH4pJnjsSdM0/c88pEniItLQ3p6eno1KmT0/rkd5vIja7VxD1zJE6u1aZNGxQVFd26oQ2YxIncyrNr4rKQnHJR1ebMmYPJkydjy5Yt+PPPP51yfCTLKURu5Ok1cThhxSa4YvOGBgwYAADo37+/1eNCCEiSBJPJVNXLbopJnMitLEvuPXMkTq61adMmp9zMrIhJnMiNri2598yROGenuMYnn3yC+++/H/369XN636yJE7mVZ9fEPeV4tprm888/R+PGjdGjRw/MnTsXR44ccVrfTOJEbiLEVQBl5Z955kicXGPTpk04e/Ys/v73vyMjIwOxsbG4/fbbMXnyZGzbts3uvcQBJnEiN7KUUvTw1EomR+KuU69ePQwfPhzLly/H+fPn8d5776GoqAiPPfYYQkND8fjjj+Orr75CYWGhTf0yiRO5ScU54s6+ueUsstA55aKb8/X1xYABA/D+++/j1KlTWLduHZo1a4aXXnoJb775pk19eeZwgKhG8ux6OFA+Enf0UAiOxCvZvHkzevbsCV9f3yqfj4mJQUxMDP75z3/i6tWrNvXNJE7kJh4/R5xcpn///vD390f37t0RHx+P+Ph4dO/eHbVqVU7B12+KdSv8u4fIbTx73xSANXFXycrKwvz589GkSRN8/PHH6NOnD+rWrYvExETMmTMHO3futPvmJpM4kZtoYd8UJnHXaNq0KUaNGoXFixfjxIkT+PXXX/Huu+8iLCwMCxYsQI8ePVC/fn27+mY5hchNJARDQiNIqKd2KKSyFi1aQK/XQ5IkSJKElStXorS01K6+mMSJ3ESvaws92qodxk05YwMrboBVtezsbGzZsgWbN2/Gli1bcP78efTo0QO9e/fGqlWrEBsba1e/TOJEpOCye9do0aIFLl68iJ49e6JPnz546qmnEBMTU+WNTVuxJk5E5GKWPcR1Oh1q1aoFHx8f6PV6p/TNkTgRKTgSd42zZ8/i6NGjSjnltddeQ3FxMXr16oV+/fqhb9++iI6Ohk5n+7iaSZyIFKyJu06bNm3Qpk0bjB07FgBw5MgRpT7+8ssvAwDy8/Nt7tehckpJSYkjLyci8kq5ubn4+eef8fPPP2P//v0wGo1251ObRuJr167Fl19+ie3bt+PUqVOQZRlBQUHo0qUL7rnnHowaNQoRERF2BUJE6hPC8XKIEE4KpgbJy8vDli1blHLKL7/8Ah8fH3Tr1g3Dhg1DfHw84uLi7Oq7Wkn822+/xbRp03Dp0iUMGjQI06ZNQ0REBAICAnDhwgUcPHgQ//3vf/HSSy9h5MiReOmllxASEmJXQESkHtbEXSM8PBw+Pj6IiYnB0KFDER8fjx49eiAgwPGFX9VK4q+99hreeustDBw4sMrC+8MPPwwAOH36NN577z18/vnnmDRpksPBEZF7CSfUxJnEK1u7di169eqFoKAgp/ddrSSenp5erc4aNWqEOXPmOBQQEVFNk5iY6LK+OU+ciBTcO8X5BgwYgJ9++umW7S5duoS5c+di/vz5NvVv8xRDIQS++uorbN68GXl5eZV23vrmm29s7ZKIPARr4s730EMPYejQoQgODsZ9992HmJgYREREwN/fHxcvXsThw4exY8cOrFmzBklJSXj99ddt6t/mJD5x4kQsWrQI8fHxCAsL89gTSoiIPMHo0aMxfPhwrFixAsuWLcMHH3yAgoICAIAkSYiKikJiYiJ2796Ntm1t31vH5iT+2Wef4ZtvvsGgQYNsfjMi8mxc7OMafn5+GD58OIYPHw4AKCgoQFFRERo0aGDzIRDXszmJBwcHo0WLFg69KRF5JpZT3CM4OBjBwcFO6cvmG5uzZ8/Giy++qGzoQkRE6rF5JP7www/jP//5D0JDQ9GsWbNKfwrs3bvXacERkXuxnKI9Nifx5ORkZGRkYPjw4byxSVTDCEgQcLCc4uDryTY2J/HVq1dj/fr16NWrlyviISIiG9hcE4+MjITBYHBFLESkMi72ca3Nmzff8LlFixbZ1afNSfyNN97A1KlTceLECbvekIg8l6Um7uhFVRswYACmTJmCq1evKo+dP38e9913H6ZPn25XnzaXU4YPH44rV66gZcuWCAwMrHRj88KFC3YFQkTq4xRD19q8eTMef/xxbNiwAUuXLkVWVhZGjx6N1q1bIzMz064+bU7ib7/9tl1vRETk7Xr06IHMzEyMHTsWXbt2hSzLeOmllzB16lS7J4nYNTuFiGomGU6YYsjZKTf1yy+/YM+ePWjcuDHOnDmDY8eO4cqVK3ZvU1utmnhhYaFNndranog8A29sutacOXMQFxeHu+++GwcPHsSuXbuwb98+dOzYsdpbfl+vWkm8VatWmDNnDs6ePXvDNkIIbNiwAQMHDsS7775rVzBERDXZO++8g5UrV+K9996Dv78/2rdvj127dmHIkCHo16+fXX1Wq5yyZcsWPPvss5g9ezY6depU5VaK6enpqFWrFmbMmIGnnnrKrmCISF0yJIfLISyn3NiBAwfQsGFDq8d8fHzw+uuv495777Wrz2ol8datW+Prr79GdnY2VqxYge3btyMtLQ1FRUVo2LAhunTpgg8//BADBw6EXq+3KxAi8gDOKIewnHJD1yfwivr27WtXnzbd2GzSpAkmT56MyZMn2/VmRETeLD4+/qazUDZt2mRznzbPTiGimosbYLlW586drT6/evUqMjMzcfDgQbtn/jGJE5GCi31c66233qry8dmzZ+Py5ct29cmDkomIVDZ8+HB88skndr2WI3EiUsjll6N9kG3S09Ph7+9v12s1k8RfeeUVrF69GpmZmfD19UV+fr7aIRHVOCynuNaQIUOsPhdC4OzZs9izZw9eeOEFu/qsdjmlf//++Oabb274/Pnz51169mZpaSkeeughjBs3zmXvQeTtZOGMnQzV/io8l+VsTctVv3599OvXD2vWrMGsWbPs6rPaI/HNmzdj69ateO655/Diiy9Wet5kMuHkyZN2BVEdlvdcvHixy96DiMiVPv30U6f3adONzQULFuDtt9/GX/7yF03sj1JSUgKj0Wh1EdGNWY5nc/Qi97GpJv7AAw+gV69eeOCBB9C9e3d89913Li2hOCo1NbXKvxqIqGqcJ+589erVq/Y2s/acx2Dzjc22bdti9+7dePTRR3HnnXdi2bJlSEhIsPmNAWD69OmYO3fuTdscOXIEbdq0sav/GTNmICUlRfncaDQiMjLSrr6IiOzh6jMY7JqdEhwcjNWrV2PGjBkYNGgQ5s6di7/+9a829zN58mSMHDnypm0cGen7+fnBz8/P7tcTeRvzjU3H+6BrXH0GQ7WT+PV/DkiShDlz5qBz58548skn7VrzHxISgpCQEJtfR0Su4YyaNmvilc2cORPTp09HYGAgAODixYuoV6+eU/qu9o1NIar+53XYsGHYsWMHDhw44JSAbiQ7OxuZmZnIzs6GyWRCZmYmMjMz7V6qSkTkLq+88opVrmratCl+//13p/Rt0xTD+vXrV/lc586dkZGRgdWrVzslqKrMnDkTS5YsUT7v0qWLEpe9m6kTkTXe2HSN6wfBNxoU26PaI/G+ffuiVq0b5/wGDRrg8ccfd0pQVVm8eDGEEJUuJnAi5xHCORe5DzfAIiJVpaam4s4770SdOnUQGhqKwYMH49ixY1ZtiouLMX78eDRo0AC1a9fG0KFDkZuba9UmOzsbSUlJCAwMRGhoKKZMmYKysjKrNlu2bEHXrl3h5+eHVq1aVbl4cP78+WjWrBn8/f0RGxuLXbt22RzL9SRJwqVLl2A0GlFQUABJknD58mWnrGNhEicihSg/ns2Ry9Ybm1u3bsX48ePx008/YcOGDbh69SruueceqwWFkyZNwg8//IAVK1Zg69atOHPmjNU+JCaTCUlJSSgtLUVaWhqWLFmCxYsXY+bMmUqbrKwsJCUlIT4+HpmZmZg4cSKefPJJrF+/XmmzbNkypKSkYNasWdi7dy86deqExMRE5OXlVTuWKr+vQuCOO+5AvXr1UL9+fVy+fBldunRBvXr1UK9ePdStW9fuG52ScGZxxsMZjUYEBwejoKAABoNB7XCIqs3VP7uW/he1GY4Ava9DfRWZSvHU0c/tjvXcuXMIDQ3F1q1b0adPHxQUFCAkJARLly7Fgw8+CAA4evQo2rZti/T0dHTv3h1r167FvffeizNnziAsLAwAsHDhQkybNg3nzp2Dr68vpk2bhtWrV+PgwYPKew0bNgz5+flYt24dACA2NhZ33nkn5s2bBwCQZRmRkZF4+umnMX369GrFUpWtW7dW62u354g2zexiSESu5wk3NgsKCgBAmUiRkZGBq1evWi0qbNOmDZo0aaIkzvT0dHTo0EFJ4ACQmJiIcePG4dChQ+jSpQvS09MrLUxMTEzExIkTAZg32cvIyMCMGTOU53U6HRISEpCenl7tWKpi7/mZ1cEkTkQucX2NtzqL72RZxsSJE9GzZ0+0b98eAJCTkwNfX1/UrVvXqm1YWBhycnKUNhUTuOV5y3M3a2M0GlFUVISLFy/CZDJV2ebo0aPVjsXdWBMnIoVw0gUAkZGRVtuupqam3vL9x48fj4MHD+LLL7906tdVk3EkTkQKZ5ZTTp06ZVUTv9UofMKECVi1ahW2bduGxo0bK4+Hh4ejtLQU+fn5ViPg3NxchIeHK22un0VimTFSsc31s0hyc3NhMBgQEBAAvV4PvV5fZZuKfdwqFnfjSJyIXMJgMFhdN0riQghMmDAB3377LTZt2oTmzZtbPR8dHQ0fHx9s3LhReezYsWPIzs5GXFwcACAuLg4HDhywmkWyYcMGGAwGREVFKW0q9mFpY+nD19cX0dHRVm1kWcbGjRuVNtWJxd2YxIlIITvpssX48ePx+eefY+nSpahTpw5ycnKQk5ODoqIiAOYN90aPHo2UlBRs3rwZGRkZGDVqFOLi4pQbiffccw+ioqIwYsQI7N+/H+vXr8fzzz+P8ePHK/94jB07Fr///jumTp2Ko0eP4v3338fy5csxadIkJZaUlBR8+OGHWLJkCY4cOYJx48ahsLAQo0aNqnYsN/PEE0/g0qVLlR4vLCzEE088YeN3zoxTDIk0wF1TDN+5PdkpUwyfOb6k2rHeaK/tTz/9VNnltLi4GJMnT8Z//vMflJSUIDExEe+//75VCePkyZMYN24ctmzZgqCgICQnJ2POnDlWK823bNmCSZMm4fDhw2jcuDFeeOGFSjupzps3D6+//jpycnLQuXNnvPvuu4iNjVWer04sN6LX63H27FmEhoZaPX7+/HmEh4dXWpxUHUziRBpQk5O4NzAajRBCoF69ejh+/LjV7q0mkwk//PADpk+fjjNnztjcN29sEpHCE+aJ10R169aFJEmQJAl33HFHpeclSbL7FDImcSJSVJwi6EgfZG3z5s0QQuCuu+7C119/bbUjrK+vL5o2bYqIiAi7+mYSJyJyMcuKzaysLERGRkKnc96cEiZxIlKwnOJaTZs2BQBcuXIF2dnZKC0ttXq+Y8eONvfJJE5ezXxf3wRJ4q8CYN8Uwar6oKqdO3cOo0aNwtq1a6t83mQy2dwn54mTV5PFcVyVv4Usbr4ftLcQQnLKRVWbOHEi8vPzsXPnTgQEBGDdunVYsmQJbr/9dnz//fd29cnhB3ktIYwwiZ8AlEGIPEAKu+VriByxadMmfPfdd4iJiYFOp0PTpk1x9913w2AwIDU1FUlJSTb3yZE4eSUhZJTJ2wCUQUI4dFI7tUPyCAKOr9bk7JQbKywsVBb61KtXD+fOnQMAdOjQAXv37rWrTyZx8kqyOACBPAA+qKXrDUnirwJgPtnH4XKKjSf7eJPWrVsrR8916tQJixYtwunTp7Fw4ULcdtttdvXJcgp5HVn8CZPYBwDQS90hSXVUjoi8xTPPPIOzZ88CAGbNmoUBAwbgiy++gK+vb5XnfVYHkzh5FSHKYJK3ApAhoSl0Uiu1Q/IosjBfjvZBVRs+fLjycXR0NE6ePImjR4+iSZMmaNiwoV19MomTVzGJDAjkAwhALV2PG26+5K24YtM9SktLkZWVhZYtW6Jr164O9cVCIHkNWZyFLA4BAGrpekKSAlSOiLzNlStXMHr0aAQGBqJdu3bIzs4GADz99NOYM2eOXX0yiZNXEKK0fDYKoJPugE5qonJEnsmyYtPRi6o2Y8YM7N+/H1u2bIG/v7/yeEJCApYtW2ZXnyynkFcwzwcvBFAHein2Vs29FldsutbKlSuxbNkydO/e3aqU165dO/z222929cmRONV4sjgBWfwKQEItXR9Iko/aIZGXOnfuXKUDIQDz/HF7788wiVONJsQVlMn/AwDopA7QcVXmTXHZvWvFxMRg9erVyueWxP3RRx/ZfUYnyylUYwkhUCbvAFACCQ2gl7qoHZLHYznFtV599VUMHDgQhw8fRllZGd555x0cPnwYaWlp2Lp1q119ciRONZYsjkHgDwD68jKKXu2QPJ4Qzrmoar169UJmZibKysrQoUMH/PjjjwgNDUV6ejqio6Pt6pMjcaqRhCiASewCAOilGEhSPZUjIjJr2bIlPvzwQ6f1xyRONY715la3QSdFqR2SZsiQIDu494mjr6+JjEZjtdrZc7A0kzjVOLL4GQLnAPiWb27FpFJdXHbvGpaDkm9ECAFJkuw6FIJJnGoUWZy/bnOr2ipHRGQ+KNlCCIFBgwbho48+QqNGjRzum0mcagwhylAmbwUgoJOaQSe1VDsk7XHGjUmOxCuxHJRsodfr0b17d7Ro0cLhvpnEqcYwiT0ACgAEQC9xcyt7sCauPZxiSDWCLE5DFocBoLwO7n+LVxDVDByJk+YJUYIyeTsAQCe1gU5qrHJE2uWMed6cJ149zvpLkUmcNM8k0gFcAWCAXrpT7XA0jSs2XWPIkCFWnxcXF2Ps2LEICgqyevybb76xuW8mcdI0k/w7ZPE7uLkVebLg4GCrzyue8OMoJnHSLCEKYRJpAACd1Ak6qfLucGQbzhN3jU8//dRlfTOJkyZd29yqFBIaQi91VjukGoHHs2kPkzhpkiyOQOA0rm1uxYlWzmAeiTs4xZBZ3K34k0+aY97cajcAQC/dCUmqq25ARCriSJw0xby51VYAJkiIgE5qq3ZINQqnGGoPkzhpiklkQuA8uLmVa3CKofawnEKaIYtzkMV+AChfVh90i1cQ1XwciZMmCHG1wuZWLaDXOb5xEFXGcor2MImTJphvZBoBBEIv2XegLN0ayynaw3IKeTxZ/AFZHAVg2dzKT+WIiDwHR+Lk0YQorrC5VRR0kuOb6NONCSes2GQ5xb2YxMljCSHKl9UXAQiGXopRO6Qajys2tYflFPJYsvgdsjgB8+ZWfSFJHHMQXY+/FeSRhLhcvsUsoJe6QCc1VDki78ANsLSHSZw8jnlzq+0wb24VAp3UUe2QvAanGGoPkzh5HFkchsBZALW4uZWbcYqh9vC3gzyKEBfLDzy2bG4VfItXEHk3TSTxEydOYPTo0WjevDkCAgLQsmVLzJo1C6WlpWqHRk4khAll8jaYN7dqBJ3URu2QvI6lJu7oRe6jiXLK0aNHIcsyFi1ahFatWuHgwYMYM2YMCgsL8a9//Uvt8MhJzJtb/QnAj5tbqYRTDLVHE0l8wIABGDBggPJ5ixYtcOzYMSxYsIBJvIaQRR5k8TMAoJauByQpUOWIiLRBE0m8KgUFBahfv/5N25SUlKCkpET53Gg0ujossoP15lYtoZOaqx2S1+IUQ+3RRE38er/++ivee+89PPXUUzdtl5qaiuDgYOWKjIx0U4RkC5PYBeASgCDope5qh+PVLFMMHb3IfVRN4tOnT4ckSTe9jh49avWa06dPY8CAAXjooYcwZsyYm/Y/Y8YMFBQUKNepU6dc+eWQHWRxCrI4BgDl0wm5uRWRLVQtp0yePBkjR468aZsWLa7tG33mzBnEx8ejR48e+OCDD27Zv5+fH/z8mBQ8lRBF5SfWAzqpHXTSbSpHRJwnrj2qJvGQkBCEhIRUq+3p06cRHx+P6OhofPrpp9DpNFkJonLmVZnmza0k1IVeilY7JEJ5Ene0Ju6USKi6NHFj8/Tp0+jXrx+aNm2Kf/3rXzh37pzyXHh4uIqRkb1k8SsETgLQQc/NrYjsponfnA0bNuDXX3/Fr7/+isaNG1s9J3gXRXOEuAST+AmAZXOrBipHRBacJ649mqhJjBw5EkKIKi/SlmubW12FhFDopA5qh0QVWA6FcOTir6V7aWIkTjWHLA5CIAfc3MozCeGEkTiTuFvxN4jcRhYXYBIZAAC9FAtJMqgcEZH2cSRObiGECSZ5GwAZEiKhk+5QOySqAqcYag+TOLmFSeyFwAUA/qil68XNrTyULADZwYIKl927F8sp5HKyyIEsDgCwbG4VoHJERDUHR+LkUubNrbYBAHTS7dBJzdQNiG6KUwy1h0mcXMokdgK4DKA29FKs2uHQLZjLKY73Qe7Dcgq5jCxOQha/ALBsbuWrckRENQ9H4uQS5s2t/gcA0EkdoJO4PYIWiPL/HO2D3IdJnJzOvCpzB4BiSKgHvdRV7ZComlhO0R6WU8jpZJEOSZeDa5tb6dUOiajG4kicnEZAhiz2AbosSNBBrwuDTrr5EXrkWbjYR3s4EienECiFjK2AZD6JSYj6kNBf5ajIVjfaaM7Wyxbbtm3Dfffdh4iICEiShJUrV1aKaebMmbjtttsQEBCAhIQEHD9+3KrNhQsX8Nhjj8FgMKBu3boYPXo0Ll++bNXm559/Ru/eveHv74/IyEi89tprlWJZsWIF2rRpA39/f3To0AFr1qyxORZ3YxInhwkYIWM9gDMA9JDQE7WkgdCxjKI5spMuWxQWFqJTp06YP39+lc+/9tprePfdd7Fw4ULs3LkTQUFBSExMRHFxsdLmsccew6FDh7BhwwasWrUK27Ztw9/+9jfleaPRiHvuuQdNmzZFRkYGXn/9dcyePdvqhLC0tDQ8+uijGD16NPbt24fBgwdj8ODBOHjwoE2xuJskvGg/V6PRiODgYBQUFMBg4OZLziBwBjJ2ALgKIBA69IUEllCczdU/u5b+7w4aAx8Hp4JeFaXYUPihXbFKkoRvv/0WgwcPBmAe+UZERGDy5Mn4v//7PwBAQUEBwsLCsHjxYgwbNgxHjhxBVFQUdu/ejZiYGADAunXrMGjQIPzxxx+IiIjAggUL8NxzzyEnJwe+vuavb/r06Vi5cqVyju8jjzyCwsJCrFq1Somne/fu6Ny5MxYuXFitWNTAkTjZRUBAxhHI2AJzAm8IHQYwgWucM8spRqPR6iopKbE5nqysLOTk5CAhIUF5LDg4GLGxsUhPTwcApKeno27dukoCB4CEhATodDrs3LlTadOnTx8lgQNAYmIijh07hosXLyptKr6PpY3lfaoTixqYxMlmAiYIpENgLwABCS2hQwIkcE8UrRNwvJRi+dM+MjISwcHBypWammpzPDk5OQCAsLAwq8fDwsKU53JychAaGmr1fK1atVC/fn2rNlX1UfE9btSm4vO3ikUNnJ1CNhEoMt/AxJ8AJEjoCgmtIYG7EpK1U6dOWZVT/Pz8VIym5uJInKpN4E/IWAtzAveFDvHQoQ0TeA0iC+GUCwAMBoPVZU8StxyEnpuba/V4bm6u8lx4eDjy8vKsni8rK8OFCxes2lTVR8X3uFGbis/fKhY1MIlTtcjIgowfARQBMJTXv29TOyxyMuGk/5ylefPmCA8Px8aNG5XHjEYjdu7cibi4OABAXFwc8vPzkZGRobTZtGkTZFlGbGys0mbbtm24evWq0mbDhg1o3bo16tWrp7Sp+D6WNpb3qU4samASp5sSkCFjHwTSYK54NipP4HXUDo1qiMuXLyMzMxOZmZkAzDcQMzMzkZ2dDUmSMHHiRLz88sv4/vvvceDAATz++OOIiIhQZrC0bdsWAwYMwJgxY7Br1y7873//w4QJEzBs2DBEREQAAP7617/C19cXo0ePxqFDh7Bs2TK88847SElJUeJ45plnsG7dOrzxxhs4evQoZs+ejT179mDChAkAUK1Y1MCaON2QeQHP/2Ce/w1IaAcJHSHx3/4aS40Vm3v27EF8fLzyuSWxJicnY/HixZg6dSoKCwvxt7/9Dfn5+ejVqxfWrVsHf39/5TVffPEFJkyYgP79+0On02Ho0KF49913leeDg4Px448/Yvz48YiOjkbDhg0xc+ZMq7nkPXr0wNKlS/H888/j2Wefxe23346VK1eiffv2SpvqxOJunCdOVTIv4NkKwAjzAp7u0KGZylF5L3fNE+8VMAq1HJwnXiZKsaPoU/6euQlH4lSJwNnyBTylMC/g6QMJDdQOi4iqwCROCvMtqaMQ2AfzbN+G5Qmc87+9hSyEEw5K9po/7j0CkzgBsCzg2QWB3wEAElpAQjdI4P4n3oSHQmgPkziVL+DZBuA8uIDHu8lwwkicSdytmMS9nHkBz1aY53/7QodenP9NpCFM4l5MRhYEdgIwwbyApx/nf3s5jsS1h0ncC5l/TfdD4HD5IxHlI3AfVeMi9bEmrj1M4l6m8gKeKEjoxAU8RBrFJO5FuICHbkU4oZzCkbh7MYl7CesFPAHlJ/BwAQ9ZkyUZkuTYwnuZRyW7FZN4DccFPEQ1G5N4DcYFPGQrGQISZ6doCpN4DcUFPGQPUT7J0NE+yH2YxGsgLuAh8h5M4jVM5QU8fSGB24FS9ciAE8op5E5M4jVE1Qt4ekKCY3tDk3fh7BTtYRKvAQSulk8f5AIecowMGZKDSZhJ3L2YxDWu8gKeWOjQXO2wiMhNmMQ1jAt4yNk4EtceJnENMi/gOQaBveACHnImTjHUHiZxjeECHiKqiElcQyov4OkCCW24gIechrNTtIdJXCPMC3i2AbgCLuAhVxGQHU7CLKe4F5O4Bsg4AYGfwAU8RHQ9JnEPZr6BuR8Ch8of4QIeci3zPRfH1hcImJwUDVUHk7iHMi/g+R+A0wC4gIfcw1xKYU1cS5jEPZDAJcjYAi7gIaJbYRL3MFzAQ2oy7wXu6Eic+4m7E5O4h+ACHvIE5pq4Y1NWWRN3LyZxD2D+xdkNgd8AcAEPqYc1ce1hElcZF/AQkSOYxFVUeQFPT0iIUDss8mLcO0V7mMRVwgU85IlkmAAH/wqUWRN3KyZxN+MCHiJyJs2sHLn//vvRpEkT+Pv747bbbsOIESNw5swZtcOyiXkBz1YlgUuIKh+BM4GTZ7CUUxy9yH00k8Tj4+OxfPlyHDt2DF9//TV+++03PPjgg2qHVW3mBTzrYV6BqYOEHtChC1dgkkeRhckpF7mPZsopkyZNUj5u2rQppk+fjsGDB+Pq1avw8fFRMbJb4wIeInIVzSTxii5cuIAvvvgCPXr08OgEXnkBT4PyBM4FPOSZODtFezT1t/y0adMQFBSEBg0aIDs7G999991N25eUlMBoNFpd7mJewLMTAhkABCQ0hw53M4GTRzMncZODF5O4O6maxKdPnw5Jkm56HT16VGk/ZcoU7Nu3Dz/++CP0ej0ef/xxCHHjfRpSU1MRHBysXJGRke74ssoX8Py3fAWmBAldISGOKzCJyOkkcbMs6GLnzp3Dn3/+edM2LVq0gK9v5dkbf/zxByIjI5GWloa4uLgqX1tSUoKSkhLlc6PRiMjISBQUFMBgcM2cbIELkLEV5gU8PuUn8HABDznGaDQiODjYZT+7lv7rBXSCJDk22BDChItF+136e0bXqFoTDwkJQUhIiF2vlWXzn2wVk/T1/Pz84OfnZ1f/9uACHtI6cynE0Q2wWE5xJ03c2Ny5cyd2796NXr16oV69evjtt9/wwgsvoGXLljcchbsTF/BQTSGcMD3QGX1Q9WnixmZgYCC++eYb9O/fH61bt8bo0aPRsWNHbN261a0j7aqYF/Bs4wIeIlKFJkbiHTp0wKZNm9QOoxLzAp6tAApgXsDTnSfwkKbJkB3eQZPlFPfSRBL3RAI5kLEd1xbw9IGEhmqHReQQIZxQExdM4u7EJG4jc/37F2X+t3kBTx9ICFQ7NCLyQkziNqh8Ak9zSIjl/G+qMZxxtBqPZ3MvJvFqMi/g2Q7gHHgCD9VU5mUjDi67V2/piVdiEq8GLuAhIk/FJH4LMk5CIB1cwEPewBkzSzg7xb2YxG+g8gKe28pH4Jz/TTWXeaGOY+UQzk5xLybxKpgX8KQB+AMAIKEtJHTmAQ5E5HGYxK9TeQFPLHRooXZYRG7hjFE0R+LuxSReARfwkLdjTVx7mMTLyfi9fAdCLuAh78WRuPYwiZeTUBcCOkhowgU8RKQZTOLlJNSHDoMA1OECHvJaLKdoD5N4BZz/Td6OUwy1h3PmiIg0jCNxIqrA8b1THB3Jk22YxIlI4Zz9xJnE3YnlFCIiDeNInIgUzjntniNxd2ISJ6IKHE/irIm7F8spREQaxpE4EV3jhBub4I1Nt2ISJyIFa+Law3IKEVUgO+my3fz589GsWTP4+/sjNjYWu3btcuxL8RJM4kSkumXLliElJQWzZs3C3r170alTJyQmJiIvL0/t0DwekzgRVSDMNW1HLjvKKW+++SbGjBmDUaNGISoqCgsXLkRgYCA++eQT53+JNQyTOBFVIBz+z9YkXlpaioyMDCQkJCiP6XQ6JCQkID093clfX83jVTc2LcuBjUajypEQ2cbyM+ueJe3OeY/rf8/8/Pzg5+dXqd358+dhMpkQFhZm9XhYWBiOHj3qlFhqMq9K4pcuXQIAREZGqhwJkX0uXbqE4OBgp/fr6+uL8PBw5OTkOKW/2rVrV/o9mzVrFmbPnu2U/ukar0riEREROHXqFOrUqQNJkmA0GhEZGYlTp07BYOBe4vx+VOYp3xMhBC5duoSIiAiX9O/v74+srCyUlpY6pT8hBCTJeqpiVaNwAGjYsCH0ej1yc3OtHs/NzUV4eLhT4qnJvCqJ63Q6NG7cuNLjBoOBSasCfj8q84TviStG4BX5+/vD39/fpe9RFV9fX0RHR2Pjxo0YPHgwAECWZWzcuBETJkxwezxa41VJnIg8U0pKCpKTkxETE4Nu3brh7bffRmFhIUaNGqV2aB6PSZyIVPfII4/g3LlzmDlzJnJyctC5c2esW7eu0s1Oqsyrk7ifnx9mzZp1w1qdt+H3ozJ+T9xnwoQJLJ/YQRI8hoOISLO42IeISMOYxImINIxJnIhIw5jEiYg0zCuT+OnTpzF8+HA0aNAAAQEB6NChA/bs2aN2WKpp1qwZJEmqdI0fP17t0FRhMpnwwgsvoHnz5ggICEDLli3x0ksvuWnfEiLbeN0Uw4sXL6Jnz56Ij4/H2rVrERISguPHj6NevXpqh6aa3bt3w2QyKZ8fPHgQd999Nx566CEVo1LP3LlzsWDBAixZsgTt2rXDnj17MGrUKAQHB+Mf//iH2uERWfG6KYbTp0/H//73P2zfvl3tUDzWxIkTsWrVKhw/frzS/hfe4N5770VYWBg+/vhj5bGhQ4ciICAAn3/+uYqREVXmdeWU77//HjExMXjooYcQGhqKLl264MMPP1Q7LI9RWlqKzz//HE888YRXJnAA6NGjBzZu3IhffvkFALB//37s2LEDAwcOVDkyosq8rpzy+++/Y8GCBUhJScGzzz6L3bt34x//+Ad8fX2RnJysdniqW7lyJfLz8zFy5Ei1Q1HN9OnTYTQa0aZNG+j1ephMJrzyyit47LHH1A6NqBKvK6f4+voiJiYGaWlpymP/+Mc/sHv3bp4iAiAxMRG+vr744Ycf1A5FNV9++SWmTJmC119/He3atUNmZiYmTpyIN998k//Qk8fxupH4bbfdhqioKKvH2rZti6+//lqliDzHyZMn8d///hfffPON2qGoasqUKZg+fTqGDRsGAOjQoQNOnjyJ1NRUJnHyOF5XE+/ZsyeOHTtm9dgvv/yCpk2bqhSR5/j0008RGhqKpKQktUNR1ZUrV6DTWf9q6PV6yLKsUkREN+Z1I/FJkyahR48eePXVV/Hwww9j165d+OCDD/DBBx+oHZqqZFnGp59+iuTkZNSq5XU/Flbuu+8+vPLKK2jSpAnatWuHffv24c0338QTTzyhdmhElQkv9MMPP4j27dsLPz8/0aZNG/HBBx+oHZLq1q9fLwCIY8eOqR2K6oxGo3jmmWdEkyZNhL+/v2jRooV47rnnRElJidqhEVXidTc2iYhqEq+riRMR1SRM4kREGsYkTkSkYUziREQaxiRORKRhTOJERBrGJE5EpGFM4kREGsYkTg75888/ERoaihMnTjjUz7Bhw/DGG284JygiL8IkThg5cqRyrqaPjw+aN2+OqVOnori4+JavfeWVV/DAAw+gWbNmDsXw/PPP45VXXkFBQYFD/RB5GyZxAgAMGDAAZ8+exe+//4633noLixYtwqxZs276mitXruDjjz/G6NGjHX7/9u3bo2XLljz+jMhGTOIEAPDz80N4eDgiIyMxePBgJCQkYMOGDTd9zZo1a+Dn54fu3bsrj23ZsgWSJGH9+vXo0qULAgICcNdddyEvLw9r165F27ZtYTAY8Ne//hVXrlyx6u++++7Dl19+6ZKvj6imYhKnSg4ePIi0tDT4+vretN327dsRHR1d5XOzZ8/GvHnzkJaWhlOnTuHhhx/G22+/jaVLl2L16tX48ccf8d5771m9plu3bti1axdKSkqc9rUQ1XTevXE0KVatWoXatWujrKwMJSUl0Ol0mDdv3k1fc/LkSURERFT53Msvv4yePXsCAEaPHo0ZM2bgt99+Q4sWLQAADz74IDZv3oxp06Ypr4mIiEBpaSlycnJ4SAdRNTGJEwAgPj4eCxYsQGFhId566y3UqlULQ4cOvelrioqK4O/vX+VzHTt2VD4OCwtDYGCgksAtj+3atcvqNQEBAQBQqcxCRDfGcgoBAIKCgtCqVSt06tQJn3zyCXbu3ImPP/74pq9p2LAhLl68WOVzPj4+yseWWS8VSZJU6bizCxcuAABCQkLs+RKIvBKTOFWi0+nw7LPP4vnnn0dRUdEN23Xp0gWHDx922vsePHgQjRs3RsOGDZ3WJ1FNxyROVXrooYeg1+sxf/78G7ZJTEzEoUOHbjgat9X27dtxzz33OKUvIm/BJE5VqlWrFiZMmIDXXnsNhYWFVbbp0KEDunbtiuXLlzv8fsXFxVi5ciXGjBnjcF9E3oRnbJJDVq9ejSlTpuDgwYPQ6ewfEyxYsADffvstfvzxRydGR1TzcXYKOSQpKQnHjx/H6dOnERkZaXc/Pj4+leaNE9GtcSRORKRhrIkTEWkYkzgRkYYxiRMRaRiTOBGRhjGJExFpGJM4EZGGMYkTEWkYkzgRkYYxiRMRadj/A8kSsBZd3c+gAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -620,7 +612,7 @@ " for bin in my_reactor.first_wall.bins:\n", " for sub_bin in bin.sub_bins:\n", " if sub_bin.mode == mode:\n", - " heat_flux = plasma_data_handling.get_heat(FP_pulse, bin=sub_bin, t_rel=0)\n", + " heat_flux = plasma_data_handling.get_heat(FP_pulse, bin=sub_bin, t_rel=FP_pulse.ramp_up+1)\n", " heat_fluxes.append(heat_flux)\n", "\n", " start_points.append(bin.start_point)\n", @@ -662,7 +654,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.12.6" } }, "nbformat": 4, From c443daafaecb8633365eaa8edc79a38f667b6fcf Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 16 Feb 2025 22:46:23 -0500 Subject: [PATCH 26/50] updated tungsten rtol for new pulse profiles --- src/hisp/model.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index c55ca84f..4d90809d 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -277,9 +277,8 @@ def make_custom_rtol(self, t:float) -> float: def bake_rtol(self, t:float) -> float: pulse = self.scenario.get_pulse(t) - relative_time = t - self.scenario.get_time_start_current_pulse(t) if pulse.pulse_type == "BAKE": rtol = 1e-12 else: - rtol = 1e-10 + rtol = 1e-8 return rtol \ No newline at end of file From bdd2c1c9cb1befa03c3c32952287c65fc0bfdea6 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 18 Feb 2025 23:02:26 -0500 Subject: [PATCH 27/50] updated risp timestep and tungsten rtol --- src/hisp/model.py | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 4d90809d..5c79f200 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -164,16 +164,25 @@ def max_stepsize(self, t: float) -> float: ) if relative_time_within_sub_pulse < time_real_risp_starts - 11: value = None # s - elif relative_time_within_sub_pulse < time_real_risp_starts + 1: - value = 0.01 # s - elif relative_time_within_sub_pulse < time_real_risp_starts + 50: - value = 0.1 # s + elif relative_time_within_sub_pulse < time_real_risp_starts + 160: + value = 1e-3 # s + # elif relative_time_within_sub_pulse < time_real_risp_starts + 1: + # value = 0.01 # s + # elif relative_time_within_sub_pulse < time_real_risp_starts + 50: + # value = 0.1 # s else: # NOTE this seems to have an influence on the accuracy of the calculation value = 1 # s else: + relative_time_within_sub_pulse = relative_time % pulse.total_duration # the stepsize is 1/10 of the duration of the pulse - value = pulse.duration_no_waiting / 10 # s + if pulse.pulse_type == "FP": + if relative_time_within_sub_pulse < pulse.duration_no_waiting: + value = 0.1 # s + else: + value = pulse.duration_no_waiting / 10 + else: + value = pulse.duration_no_waiting / 10 return periodic_step_function( relative_time, period_on=pulse.duration_no_waiting, @@ -269,8 +278,12 @@ def make_custom_rtol(self, t:float) -> float: rtol = 1e-11 elif pulse.pulse_type == "BAKE": rtol = 1e-13 - elif pulse.pulse_type == "FP" and relative_time % pulse.total_duration > pulse.duration_no_waiting: - rtol = 1e-15 + elif pulse.pulse_type == "FP": + # rtol = 1e-10 + if relative_time % pulse.total_duration > pulse.duration_no_waiting: + rtol = 1e-14 + else: + rtol = 1e-5 else: rtol = 1e-10 return rtol From cf1aa57636e278d6069867a36abd7ac8f4a53307 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 18 Feb 2025 23:04:10 -0500 Subject: [PATCH 28/50] add B fifth trap --- src/hisp/festim_models/mb_model.py | 32 +++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 76575a6d..9149f672 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -356,6 +356,8 @@ def make_B_mb_model( trap3_T = F.Species("trap3_T", mobile=False) trap4_D = F.Species("trap4_D", mobile=False) trap4_T = F.Species("trap4_T", mobile=False) + trap5_D = F.Species("trap5_D", mobile=False) + trap5_T = F.Species("trap5_T", mobile=False) # traps empty_trap1 = F.ImplicitSpecies( # implicit trap 1 @@ -386,6 +388,12 @@ def make_B_mb_model( name="empty_trap4", ) + empty_trap5 = F.ImplicitSpecies( + n=1.800e-1*b_density, # from Johnathan Dufour's unpublished TDS study for boron + others=[trap5_T, trap5_D], + name="empty_trap5", + ) + my_model.species = [ mobile_D, mobile_T, @@ -397,6 +405,8 @@ def make_B_mb_model( trap3_T, trap4_D, trap4_T, + trap5_D, + trap5_T, ] # hydrogen reactions - 1 per trap per species @@ -476,6 +486,24 @@ def make_B_mb_model( reactant=[mobile_T, empty_trap4], product=trap4_T, ), + F.Reaction( + k_0=1e13 / b_density, + E_k=E_D, + p_0=1e13, # from Johnathan Dufour's unpublished TDS study for boron + E_p=1.776, + volume=b_subdomain, + reactant=[mobile_D, empty_trap5], + product=trap5_D, + ), + F.Reaction( + k_0=1e13 / b_density, + E_k=E_D, + p_0=1e13, # from Johnathan Dufour's unpublished TDS study for boron + E_p=1.776, + volume=b_subdomain, + reactant=[mobile_T, empty_trap5], + product=trap5_T, + ), ] ############# Temperature Parameters (K) ############# @@ -532,6 +560,8 @@ def make_B_mb_model( F.VTXSpeciesExport(f"{folder}/trapped_concentration_t3.bp", field=trap3_T), F.VTXSpeciesExport(f"{folder}/trapped_concentration_d4.bp", field=trap4_D), F.VTXSpeciesExport(f"{folder}/trapped_concentration_t4.bp", field=trap4_T), + F.VTXSpeciesExport(f"{folder}/trapped_concentration_d5.bp", field=trap5_D), + F.VTXSpeciesExport(f"{folder}/trapped_concentration_t5.bp", field=trap5_T), ] quantities = {} @@ -544,7 +574,7 @@ def make_B_mb_model( my_model.settings = CustomSettings( atol=custom_atol, rtol=custom_rtol, - max_iterations=30, + max_iterations=100, final_time=final_time, ) From 503e2571ce1a7b6a3263e5c593704666f9636607 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 19 Feb 2025 10:02:19 -0500 Subject: [PATCH 29/50] adjust dfw rtol --- src/hisp/festim_models/mb_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 9149f672..93e06d36 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -779,7 +779,7 @@ def make_DFW_mb_model( ############# Settings ############# my_model.settings = F.Settings( atol=1e10, - rtol=1e-10, + rtol=1e-8, max_iterations=30, final_time=final_time, ) From 0a13e57f7877fb80b6c4afab16b710aeafaf7f81 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Thu, 20 Feb 2025 09:29:40 -0500 Subject: [PATCH 30/50] dfw rtol adjustment --- src/hisp/festim_models/mb_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 93e06d36..2004f408 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -779,7 +779,7 @@ def make_DFW_mb_model( ############# Settings ############# my_model.settings = F.Settings( atol=1e10, - rtol=1e-8, + rtol=1e-6, max_iterations=30, final_time=final_time, ) From c077be3df047e2c9b6852c12401a8fc8c1308af7 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Fri, 21 Feb 2025 15:56:33 -0500 Subject: [PATCH 31/50] adjust perodic pulse function --- src/hisp/helpers.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/hisp/helpers.py b/src/hisp/helpers.py index cb46d54d..1332f0af 100644 --- a/src/hisp/helpers.py +++ b/src/hisp/helpers.py @@ -109,14 +109,15 @@ def periodic_pulse_function(current_time: float, pulse: Pulse, value, value_off= value_off (float): value at t=0 and t=final time. """ - if current_time % pulse.total_duration < pulse.ramp_up: # ramp up + if current_time == pulse.total_duration: + return value_off + elif current_time % pulse.total_duration < pulse.ramp_up: # ramp up return (value - value_off) / (pulse.ramp_up) * current_time + value_off # y = mx + b, slope is temp/ramp up time elif current_time % pulse.total_duration < pulse.ramp_up + pulse.steady_state: # steady state return value else: # ramp down, waiting - current_temp = value - (value - value_off)/pulse.ramp_down * (current_time - (pulse.ramp_up + pulse.steady_state)) # y = mx + b, slope is temp/ramp down time - - if current_temp >= value_off: - return current_temp + lower_value = value - (value - value_off)/pulse.ramp_down * (current_time - (pulse.ramp_up + pulse.steady_state)) # y = mx + b, slope is temp/ramp down time + if lower_value >= value_off: + return lower_value else: return value_off \ No newline at end of file From 789007b0f574aad1010b820dcbb1c4daa1679889 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sat, 22 Feb 2025 20:05:04 -0500 Subject: [PATCH 32/50] fix flux and temp functions --- src/hisp/festim_models/mb_model.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 2004f408..f5bbab1d 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -884,10 +884,11 @@ def T_function(x: NDArray, t: float) -> NDArray: # get the pulse and time relative to the start of the pulse pulse = scenario.get_pulse(t) t_rel = t - scenario.get_time_start_current_pulse(t) + relative_time_within_pulse = t_rel % pulse.total_duration if pulse.pulse_type == "BAKE": T_value = periodic_pulse_function( - t_rel, + relative_time_within_pulse, pulse=pulse, value=483.15, # K value_off=343.0, # K @@ -895,7 +896,7 @@ def T_function(x: NDArray, t: float) -> NDArray: value = np.full_like(x[0], T_value) else: - heat_flux = plasma_data_handling.get_heat(pulse, bin, t_rel) + heat_flux = plasma_data_handling.get_heat(pulse, bin, relative_time_within_pulse) if ( bin.material == "W" or bin.material == "SS" ): # FIXME: update ss temp when gven data: @@ -939,12 +940,13 @@ def particle_flux_function(t: float) -> float: # get the pulse and time relative to the start of the pulse pulse = scenario.get_pulse(t) relative_time = t - scenario.get_time_start_current_pulse(t) + relative_time_within_pulse = relative_time % pulse.total_duration # get the incident particle flux incident_hydrogen_particle_flux = plasma_data_handling.get_particle_flux( pulse=pulse, bin=bin, - t_rel=relative_time, + t_rel=relative_time_within_pulse, ion=ion, ) From d88344ce1bf4bd417b7fe7e941e18fd8df3fbc7d Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 23 Feb 2025 15:48:59 -0500 Subject: [PATCH 33/50] update quantities outputs --- src/hisp/festim_models/mb_model.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index f5bbab1d..b2e118db 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -272,6 +272,14 @@ def make_W_mb_model( quantity = F.TotalVolume(field=species, volume=w_subdomain) my_model.exports.append(quantity) quantities[species.name] = quantity + if species.mobile: + flux = F.SurfaceFlux(field=species, surface=inlet) + my_model.exports.append(flux) + quantities[species.name+"_surface_flux"] = flux + + surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) + my_model.exports.append(surface_temperature) + quantities["surface_temperature"] = surface_temperature ############# Settings ############# my_model.settings = CustomSettings( @@ -569,6 +577,14 @@ def make_B_mb_model( quantity = F.TotalVolume(field=species, volume=b_subdomain) my_model.exports.append(quantity) quantities[species.name] = quantity + if species.mobile: + flux = F.SurfaceFlux(field=species, surface=inlet) + my_model.exports.append(flux) + quantities[species.name+"_surface_flux"] = flux + + surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) + my_model.exports.append(surface_temperature) + quantities["surface_temperature"] = surface_temperature ############# Settings ############# my_model.settings = CustomSettings( @@ -775,6 +791,14 @@ def make_DFW_mb_model( quantity = F.TotalVolume(field=species, volume=ss_subdomain) my_model.exports.append(quantity) quantities[species.name] = quantity + if species.mobile: + flux = F.SurfaceFlux(field=species, surface=inlet) + my_model.exports.append(flux) + quantities[species.name+"_surface_flux"] = flux + + surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) + my_model.exports.append(surface_temperature) + quantities["surface_temperature"] = surface_temperature ############# Settings ############# my_model.settings = F.Settings( From 45b21c7d94b7026b6790fc6cfe57bd3614dbe0c3 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Mon, 24 Feb 2025 11:32:37 -0500 Subject: [PATCH 34/50] update festim version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index a97fcf52..9583808c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ requires-python = ">=3.9" license = { file = "LICENSE" } dependencies = [ "h_transport_materials~=0.17", - "festim@git+https://github.com/kaelyndunnell/FESTIM@9ac79df299171f12a57406755e441d8deb35c186"] + "festim@git+https://github.com/kaelyndunnell/FESTIM@d1b71deed2d0998159b99591951493bffa1f5ca8"] classifiers = [ "Natural Language :: English", From 535b51328507612c43b0b34ce110b1a07dad61b2 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 26 Feb 2025 11:05:11 -0500 Subject: [PATCH 35/50] match folder name to bin index --- src/hisp/model.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 5c79f200..dc00e613 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -137,18 +137,18 @@ def which_model(self, bin: SubBin | DivBin): return make_W_mb_model( **common_args, custom_rtol=self.bake_rtol, - folder=f"mb{parent_bin_index+1}_{bin.mode}_results", + folder=f"mb{parent_bin_index}_{bin.mode}_results", ) elif bin.material == "B": return make_B_mb_model( **common_args, custom_rtol=self.make_custom_rtol, - folder=f"mb{parent_bin_index+1}_{bin.mode}_results", + folder=f"mb{parent_bin_index}_{bin.mode}_results", ) elif bin.material == "SS": return make_DFW_mb_model( **common_args, - folder=f"mb{parent_bin_index+1}_dfw_results", + folder=f"mb{parent_bin_index}_dfw_results", ) else: raise ValueError(f"Unknown material: {bin.material} for bin {bin.index}") From a11af9a38dd180b97309ef803d7a747c468d82eb Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 4 Mar 2025 20:51:00 -0500 Subject: [PATCH 36/50] add special B max stepsize function --- src/hisp/festim_models/mb_model.py | 4 +++ src/hisp/model.py | 39 +++++++++++++++++++++++++++++- 2 files changed, 42 insertions(+), 1 deletion(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index b2e118db..3989efc1 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -572,6 +572,10 @@ def make_B_mb_model( F.VTXSpeciesExport(f"{folder}/trapped_concentration_t5.bp", field=trap5_T), ] + surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) + my_model.exports.append(surface_temperature) + quantities["surface_temperature"] = surface_temperature + quantities = {} for species in my_model.species: quantity = F.TotalVolume(field=species, volume=b_subdomain) diff --git a/src/hisp/model.py b/src/hisp/model.py index dc00e613..1e13bc52 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -63,7 +63,10 @@ def run_bin(self, bin: SubBin | DivBin): my_model.settings.stepsize.target_nb_iterations = 4 # add the stepsize cap function - my_model.settings.stepsize.max_stepsize = self.max_stepsize + if bin.material == "B": + my_model.settings.stepsize.max_stepsize = self.B_stepsize + else: + my_model.settings.stepsize.max_stepsize = self.max_stepsize # run the model my_model.initialise() @@ -191,6 +194,40 @@ def max_stepsize(self, t: float) -> float: value_off=None, ) + def B_stepsize(self, t: float) -> float: + pulse = self.scenario.get_pulse(t) + relative_time = t - self.scenario.get_time_start_current_pulse(t) # Pulse() + if pulse.pulse_type == "RISP": + relative_time_within_sub_pulse = relative_time % pulse.total_duration + # RISP has a special treatment + time_real_risp_starts = ( + 100 # (s) relative time at which the real RISP starts + ) + if relative_time_within_sub_pulse < time_real_risp_starts - 5: + value = None # s + elif relative_time_within_sub_pulse < time_real_risp_starts + 160: + value = 1e-4 # s + else: + # NOTE this seems to have an influence on the accuracy of the calculation + value = 1 # s + else: + relative_time_within_sub_pulse = relative_time % pulse.total_duration + # the stepsize is 1/10 of the duration of the pulse + if pulse.pulse_type == "FP": + if relative_time_within_sub_pulse < pulse.duration_no_waiting: + value = 0.01 # s + else: + value = pulse.duration_no_waiting / 10 + else: + value = pulse.duration_no_waiting / 100 + return periodic_step_function( + relative_time, + period_on=pulse.duration_no_waiting, + period_total=pulse.total_duration, + value=value, + value_off=None, + ) + def make_milestones(self, initial_stepsize_value: float) -> List[float]: """ Returns the milestones for the stepsize. From a57b5ec8b27ef0f8aede450cd01a1a77fc6357e4 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 5 Mar 2025 09:34:36 -0500 Subject: [PATCH 37/50] fix mb model --- src/hisp/festim_models/mb_model.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index 3989efc1..b2e118db 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -572,10 +572,6 @@ def make_B_mb_model( F.VTXSpeciesExport(f"{folder}/trapped_concentration_t5.bp", field=trap5_T), ] - surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) - my_model.exports.append(surface_temperature) - quantities["surface_temperature"] = surface_temperature - quantities = {} for species in my_model.species: quantity = F.TotalVolume(field=species, volume=b_subdomain) From 78f148d9081b6e6f0a8f2f5f651c308f9f37ee46 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 5 Mar 2025 12:17:52 -0500 Subject: [PATCH 38/50] update mb tests --- test/test_mb_model_festim.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/test_mb_model_festim.py b/test/test_mb_model_festim.py index 41e62b62..a1566ee1 100644 --- a/test/test_mb_model_festim.py +++ b/test/test_mb_model_festim.py @@ -33,7 +33,7 @@ def test_mb_W_model(temp): assert isinstance(quantities, dict) for key, value in quantities.items(): assert isinstance(key, str) - assert isinstance(value, F.TotalVolume) + assert isinstance(value, (F.TotalVolume, F.SurfaceQuantity, F.SurfaceTemperature)) # to change with SurfaceTemp PR merged assert len(value.data) > 0 @@ -61,7 +61,7 @@ def test_mb_model_B(temp): assert isinstance(quantities, dict) for key, value in quantities.items(): assert isinstance(key, str) - assert isinstance(value, F.TotalVolume) + assert isinstance(value, (F.TotalVolume, F.SurfaceQuantity, F.SurfaceTemperature)) # to change with SurfaceTemp PR merged assert len(value.data) > 0 @@ -90,7 +90,7 @@ def test_mb_model_DFW(temp): assert isinstance(quantities, dict) for key, value in quantities.items(): assert isinstance(key, str) - assert isinstance(value, F.TotalVolume) + assert isinstance(value, (F.TotalVolume, F.SurfaceQuantity, F.SurfaceTemperature)) # to change with SurfaceTemp PR merged assert len(value.data) > 0 From 6d7b56fa7fac80a3aa49a4267d422e2739668f42 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 5 Mar 2025 12:29:45 -0500 Subject: [PATCH 39/50] update B rtol --- src/hisp/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 1e13bc52..275d3829 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -320,7 +320,7 @@ def make_custom_rtol(self, t:float) -> float: if relative_time % pulse.total_duration > pulse.duration_no_waiting: rtol = 1e-14 else: - rtol = 1e-5 + rtol = 1e-8 else: rtol = 1e-10 return rtol From 71eeb24d900848608b58195d4fa69075a2acd052 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Wed, 5 Mar 2025 12:32:10 -0500 Subject: [PATCH 40/50] take out B trap five to simplify --- src/hisp/festim_models/mb_model.py | 58 +++++++++++++++--------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index b2e118db..a52f7aca 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -364,8 +364,8 @@ def make_B_mb_model( trap3_T = F.Species("trap3_T", mobile=False) trap4_D = F.Species("trap4_D", mobile=False) trap4_T = F.Species("trap4_T", mobile=False) - trap5_D = F.Species("trap5_D", mobile=False) - trap5_T = F.Species("trap5_T", mobile=False) + # trap5_D = F.Species("trap5_D", mobile=False) + # trap5_T = F.Species("trap5_T", mobile=False) # traps empty_trap1 = F.ImplicitSpecies( # implicit trap 1 @@ -396,11 +396,11 @@ def make_B_mb_model( name="empty_trap4", ) - empty_trap5 = F.ImplicitSpecies( - n=1.800e-1*b_density, # from Johnathan Dufour's unpublished TDS study for boron - others=[trap5_T, trap5_D], - name="empty_trap5", - ) + # empty_trap5 = F.ImplicitSpecies( + # n=1.800e-1*b_density, # from Johnathan Dufour's unpublished TDS study for boron + # others=[trap5_T, trap5_D], + # name="empty_trap5", + # ) my_model.species = [ mobile_D, @@ -413,8 +413,8 @@ def make_B_mb_model( trap3_T, trap4_D, trap4_T, - trap5_D, - trap5_T, + # trap5_D, + # trap5_T, ] # hydrogen reactions - 1 per trap per species @@ -494,24 +494,24 @@ def make_B_mb_model( reactant=[mobile_T, empty_trap4], product=trap4_T, ), - F.Reaction( - k_0=1e13 / b_density, - E_k=E_D, - p_0=1e13, # from Johnathan Dufour's unpublished TDS study for boron - E_p=1.776, - volume=b_subdomain, - reactant=[mobile_D, empty_trap5], - product=trap5_D, - ), - F.Reaction( - k_0=1e13 / b_density, - E_k=E_D, - p_0=1e13, # from Johnathan Dufour's unpublished TDS study for boron - E_p=1.776, - volume=b_subdomain, - reactant=[mobile_T, empty_trap5], - product=trap5_T, - ), + # F.Reaction( + # k_0=1e13 / b_density, + # E_k=E_D, + # p_0=1e13, # from Johnathan Dufour's unpublished TDS study for boron + # E_p=1.776, + # volume=b_subdomain, + # reactant=[mobile_D, empty_trap5], + # product=trap5_D, + # ), + # F.Reaction( + # k_0=1e13 / b_density, + # E_k=E_D, + # p_0=1e13, # from Johnathan Dufour's unpublished TDS study for boron + # E_p=1.776, + # volume=b_subdomain, + # reactant=[mobile_T, empty_trap5], + # product=trap5_T, + # ), ] ############# Temperature Parameters (K) ############# @@ -568,8 +568,8 @@ def make_B_mb_model( F.VTXSpeciesExport(f"{folder}/trapped_concentration_t3.bp", field=trap3_T), F.VTXSpeciesExport(f"{folder}/trapped_concentration_d4.bp", field=trap4_D), F.VTXSpeciesExport(f"{folder}/trapped_concentration_t4.bp", field=trap4_T), - F.VTXSpeciesExport(f"{folder}/trapped_concentration_d5.bp", field=trap5_D), - F.VTXSpeciesExport(f"{folder}/trapped_concentration_t5.bp", field=trap5_T), + # F.VTXSpeciesExport(f"{folder}/trapped_concentration_d5.bp", field=trap5_D), + # F.VTXSpeciesExport(f"{folder}/trapped_concentration_t5.bp", field=trap5_T), ] quantities = {} From a058c36c53e646b3bd955ca9aba3e19dbb3048fb Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Thu, 20 Mar 2025 13:21:47 -0400 Subject: [PATCH 41/50] update W temp function --- src/hisp/bin.py | 3 + src/hisp/festim_models/mb_model.py | 115 ++++++++++++++++++++++------- 2 files changed, 92 insertions(+), 26 deletions(-) diff --git a/src/hisp/bin.py b/src/hisp/bin.py index c09f9d0e..4e9c363f 100644 --- a/src/hisp/bin.py +++ b/src/hisp/bin.py @@ -5,6 +5,7 @@ class SubBin: thickness: float + copper_thickness: float material: str mode: str dfw: bool @@ -31,6 +32,7 @@ def __init__( Attributes: thickness: The thickness of the subbin (in m). + copper_thickness: The thickness of the copper layer behind W bins (m). material: The material of the subbin. mode: The mode of the subbin (shadowed, wetted, low_wetted, high_wetted). dfw: A boolean indicating if the subbin is a Divertor First Wall (DFW) subbin. @@ -45,6 +47,7 @@ def __init__( self.material = material self.mode = mode self.dfw = False + self.copper_thickness = None self.parent_bin_index = None self.low_wetted_area = None self.high_wetted_area = None diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index a52f7aca..f8abbcec 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -1,5 +1,10 @@ from hisp.h_transport_class import CustomProblem -from hisp.helpers import PulsedSource, gaussian_distribution, Stepsize, periodic_pulse_function +from hisp.helpers import ( + PulsedSource, + gaussian_distribution, + Stepsize, + periodic_pulse_function, +) from hisp.scenario import Scenario from hisp.plamsa_data_handling import PlasmaDataHandling from hisp.settings import CustomSettings @@ -26,7 +31,9 @@ def make_W_mb_model( final_time: float, folder: str, L: float, - custom_rtol: Union[float, Callable] = 1e-10, # default rtol unless otherwise specified, used for everything but BAKE + custom_rtol: Union[ + float, Callable + ] = 1e-10, # default rtol unless otherwise specified, used for everything but BAKE exports=False, ) -> Tuple[CustomProblem, Dict[str, F.TotalVolume]]: """Create a FESTIM model for the W MB scenario. @@ -129,7 +136,8 @@ def make_W_mb_model( # hydrogen reactions - 1 per trap per species my_model.reactions = [ F.Reaction( - k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), + k_0=D_0 + / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), E_k=E_D, p_0=1e13, E_p=0.85, @@ -138,7 +146,8 @@ def make_W_mb_model( product=trap1_D, ), F.Reaction( - k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), + k_0=D_0 + / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), E_k=E_D, p_0=1e13, E_p=0.85, @@ -147,7 +156,8 @@ def make_W_mb_model( product=trap1_T, ), F.Reaction( - k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), + k_0=D_0 + / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), E_k=E_D, p_0=1e13, E_p=1, @@ -156,7 +166,8 @@ def make_W_mb_model( product=trap2_D, ), F.Reaction( - k_0=D_0 / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), + k_0=D_0 + / (interstitial_distance**2 * interstitial_sites_per_atom * w_density), E_k=E_D, p_0=1e13, E_p=1, @@ -272,10 +283,10 @@ def make_W_mb_model( quantity = F.TotalVolume(field=species, volume=w_subdomain) my_model.exports.append(quantity) quantities[species.name] = quantity - if species.mobile: + if species.mobile: flux = F.SurfaceFlux(field=species, surface=inlet) my_model.exports.append(flux) - quantities[species.name+"_surface_flux"] = flux + quantities[species.name + "_surface_flux"] = flux surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) my_model.exports.append(surface_temperature) @@ -303,8 +314,12 @@ def make_B_mb_model( final_time: float, folder: str, L: float, - custom_atol: Union[float, Callable] = 1e8, # default atol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter - custom_rtol: Union[float, Callable] = 1e-10, # default rtol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter + custom_atol: Union[ + float, Callable + ] = 1e8, # default atol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter + custom_rtol: Union[ + float, Callable + ] = 1e-10, # default rtol unless otherwise specified, used for FP, ICWC, RISP in hisp-for-iter exports=False, ) -> Tuple[CustomProblem, Dict[str, F.TotalVolume]]: """Create a FESTIM model for the B MB scenario. @@ -398,7 +413,7 @@ def make_B_mb_model( # empty_trap5 = F.ImplicitSpecies( # n=1.800e-1*b_density, # from Johnathan Dufour's unpublished TDS study for boron - # others=[trap5_T, trap5_D], + # others=[trap5_T, trap5_D], # name="empty_trap5", # ) @@ -577,10 +592,10 @@ def make_B_mb_model( quantity = F.TotalVolume(field=species, volume=b_subdomain) my_model.exports.append(quantity) quantities[species.name] = quantity - if species.mobile: + if species.mobile: flux = F.SurfaceFlux(field=species, surface=inlet) my_model.exports.append(flux) - quantities[species.name+"_surface_flux"] = flux + quantities[species.name + "_surface_flux"] = flux surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) my_model.exports.append(surface_temperature) @@ -791,10 +806,10 @@ def make_DFW_mb_model( quantity = F.TotalVolume(field=species, volume=ss_subdomain) my_model.exports.append(quantity) quantities[species.name] = quantity - if species.mobile: + if species.mobile: flux = F.SurfaceFlux(field=species, surface=inlet) my_model.exports.append(flux) - quantities[species.name+"_surface_flux"] = flux + quantities[species.name + "_surface_flux"] = flux surface_temperature = F.SurfaceTemperature(my_model.temperature, surface=inlet) my_model.exports.append(surface_temperature) @@ -825,8 +840,49 @@ def make_DFW_mb_model( ) +def tungsten_slab_temperature(q_front, D_W, D_Cu, T_cool): + """ + Calculate the temperature of the front and back surfaces of a tungsten slab + with heat flux applied to the front surface and cooling via a copper slab. + From T. Wauters + + Parameters: + q_front (float): Heat flux at the front surface of the tungsten slab (W/m^2). + D_W (float): Thickness of the tungsten slab (m). + D_Cu (float): Thickness of the copper slab (m). + T_cool (float): Cooling water temperature (K). + + Returns: + tuple: (T_w_surf, T_w_interface) where: + - T_w_surf is the front surface temperature of tungsten (K). + - T_w_interface is the tungsten-copper interface temperature (K). + """ + # Thermal conductivities (W/m·K) + k_W = 170 # Tungsten thermal conductivity + k_Cu = 400 # Copper thermal conductivity + # Heat transfer coefficient from copper to water (W/m^2·K) + h_Cu_water = 10_000 # Typical value for water cooling + + # Temperature drop across tungsten slab + delta_T_W = (q_front * D_W) / k_W + # Temperature drop across copper slab + delta_T_Cu = (q_front * D_Cu) / k_Cu + # Temperature drop at the copper-water interface + delta_T_interface = q_front / h_Cu_water + + # Compute temperatures + T_w_interface = T_cool + delta_T_interface + delta_T_Cu + T_w_surf = T_w_interface + delta_T_W + + return T_w_surf, T_w_interface + + def calculate_temperature_W( - x: float | NDArray, heat_flux: float, coolant_temp: float, thickness: float + x: float | NDArray, + heat_flux: float, + coolant_temp: float, + thickness: float, + copper_thickness: float, ) -> float | NDArray: """Calculates the temperature in the W layer based on coolant temperature and heat flux @@ -845,9 +901,14 @@ def calculate_temperature_W( """ # the evolution of T surface is taken from Delaporte-Mathurin et al. Sci Rep 10, 17798 (2020). # https://doi.org/10.1038/s41598-020-74844-w - T_surface = 1.1e-4 * heat_flux + coolant_temp + # T_surface = 1.1e-4 * heat_flux + coolant_temp + # T_rear = slope_T_rear * heat_flux + coolant_temp - T_rear = slope_T_rear * heat_flux + coolant_temp + # T_surface and T_rear calculations taken from tungsten/copper calculations + # provided by T. Wauters + T_surface, T_rear = tungsten_slab_temperature( + q_front=heat_flux, D_W=thickness, D_Cu=copper_thickness, T_cool=coolant_temp + ) a = (T_rear - T_surface) / thickness b = T_surface return a * x + b @@ -909,23 +970,25 @@ def T_function(x: NDArray, t: float) -> NDArray: pulse = scenario.get_pulse(t) t_rel = t - scenario.get_time_start_current_pulse(t) relative_time_within_pulse = t_rel % pulse.total_duration - + if pulse.pulse_type == "BAKE": T_value = periodic_pulse_function( - relative_time_within_pulse, - pulse=pulse, - value=483.15, # K - value_off=343.0, # K - ) + relative_time_within_pulse, + pulse=pulse, + value=483.15, # K + value_off=343.0, # K + ) value = np.full_like(x[0], T_value) else: - heat_flux = plasma_data_handling.get_heat(pulse, bin, relative_time_within_pulse) + heat_flux = plasma_data_handling.get_heat( + pulse, bin, relative_time_within_pulse + ) if ( bin.material == "W" or bin.material == "SS" ): # FIXME: update ss temp when gven data: value = calculate_temperature_W( - x[0], heat_flux, coolant_temp, bin.thickness + x[0], heat_flux, coolant_temp, bin.thickness, bin.copper_thickness ) elif bin.material == "B": T_value = calculate_temperature_B(heat_flux, coolant_temp) From 8d732201f294a7b95783bca8990ff9f42514e93c Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Thu, 20 Mar 2025 13:28:13 -0400 Subject: [PATCH 42/50] update comments --- src/hisp/festim_models/mb_model.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index f8abbcec..a31c5db7 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -857,12 +857,18 @@ def tungsten_slab_temperature(q_front, D_W, D_Cu, T_cool): - T_w_surf is the front surface temperature of tungsten (K). - T_w_interface is the tungsten-copper interface temperature (K). """ - # Thermal conductivities (W/m·K) + # Thermal conductivities (W/m·K) #TODO: add citations k_W = 170 # Tungsten thermal conductivity k_Cu = 400 # Copper thermal conductivity # Heat transfer coefficient from copper to water (W/m^2·K) h_Cu_water = 10_000 # Typical value for water cooling + w_diffusivity = ( + htm.diffusivities.filter(material="tungsten") + .filter(isotope="h") + .filter(author="holzner") + ) + # Temperature drop across tungsten slab delta_T_W = (q_front * D_W) / k_W # Temperature drop across copper slab From cc605aca9ab2ecb3011d3ddd8a8dedab30c54c41 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Thu, 20 Mar 2025 14:33:05 -0400 Subject: [PATCH 43/50] update bake stepsize for B --- src/hisp/model.py | 68 ++++++++++++++++++++++++++++------------------- 1 file changed, 41 insertions(+), 27 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 275d3829..e1756ee2 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -53,7 +53,9 @@ def run_bin(self, bin: SubBin | DivBin): my_model, quantities = self.which_model(bin) # add milestones for stepsize and adaptivity - milestones = self.make_milestones(initial_stepsize_value=my_model.settings.stepsize.initial_value) + milestones = self.make_milestones( + initial_stepsize_value=my_model.settings.stepsize.initial_value + ) milestones.append(my_model.settings.final_time) my_model.settings.stepsize.milestones = milestones @@ -167,7 +169,7 @@ def max_stepsize(self, t: float) -> float: ) if relative_time_within_sub_pulse < time_real_risp_starts - 11: value = None # s - elif relative_time_within_sub_pulse < time_real_risp_starts + 160: + elif relative_time_within_sub_pulse < time_real_risp_starts + 160: value = 1e-3 # s # elif relative_time_within_sub_pulse < time_real_risp_starts + 1: # value = 0.01 # s @@ -179,10 +181,10 @@ def max_stepsize(self, t: float) -> float: else: relative_time_within_sub_pulse = relative_time % pulse.total_duration # the stepsize is 1/10 of the duration of the pulse - if pulse.pulse_type == "FP": + if pulse.pulse_type == "FP": if relative_time_within_sub_pulse < pulse.duration_no_waiting: - value = 0.1 # s - else: + value = 0.1 # s + else: value = pulse.duration_no_waiting / 10 else: value = pulse.duration_no_waiting / 10 @@ -205,7 +207,7 @@ def B_stepsize(self, t: float) -> float: ) if relative_time_within_sub_pulse < time_real_risp_starts - 5: value = None # s - elif relative_time_within_sub_pulse < time_real_risp_starts + 160: + elif relative_time_within_sub_pulse < time_real_risp_starts + 160: value = 1e-4 # s else: # NOTE this seems to have an influence on the accuracy of the calculation @@ -213,11 +215,13 @@ def B_stepsize(self, t: float) -> float: else: relative_time_within_sub_pulse = relative_time % pulse.total_duration # the stepsize is 1/10 of the duration of the pulse - if pulse.pulse_type == "FP": + if pulse.pulse_type == "FP": if relative_time_within_sub_pulse < pulse.duration_no_waiting: - value = 0.01 # s - else: + value = 0.01 # s + else: value = pulse.duration_no_waiting / 10 + elif pulse.pulse_type == "BAKE": + value = pulse.duration_no_waiting / 10 else: value = pulse.duration_no_waiting / 100 return periodic_step_function( @@ -227,7 +231,7 @@ def B_stepsize(self, t: float) -> float: value=value, value_off=None, ) - + def make_milestones(self, initial_stepsize_value: float) -> List[float]: """ Returns the milestones for the stepsize. @@ -254,21 +258,32 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: for i in range(pulse.nb_pulses): # hack: a milestone right after to ensure the stepsize is small enough - milestones.append(start_of_pulse + pulse.total_duration * i + initial_stepsize_value) + milestones.append( + start_of_pulse + pulse.total_duration * i + initial_stepsize_value + ) - if i == 0: + if i == 0: # end of ramp up milestones.append(start_of_pulse + pulse.ramp_up) - # start of ramp down - milestones.append(start_of_pulse + pulse.ramp_up + pulse.steady_state) + # start of ramp down + milestones.append( + start_of_pulse + pulse.ramp_up + pulse.steady_state + ) else: # end of ramp up - milestones.append(start_of_pulse + pulse.total_duration * (i - 1) + pulse.ramp_up) + milestones.append( + start_of_pulse + pulse.total_duration * (i - 1) + pulse.ramp_up + ) - # start of ramp down - milestones.append(start_of_pulse + pulse.total_duration * (i - 1) + pulse.ramp_up + pulse.steady_state) + # start of ramp down + milestones.append( + start_of_pulse + + pulse.total_duration * (i - 1) + + pulse.ramp_up + + pulse.steady_state + ) # start of the next pulse milestones.append(start_of_pulse + pulse.total_duration * (i + 1)) @@ -296,7 +311,6 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: # a milestone for when the real RISP starts milestones.append(t_begin_real_pulse + pulse.total_duration * i) - # NOTE do we need this? # hack: a milestone right after to ensure the stepsize is small enough milestones.append( @@ -308,27 +322,27 @@ def make_milestones(self, initial_stepsize_value: float) -> List[float]: return sorted(np.unique(milestones)) - def make_custom_rtol(self, t:float) -> float: + def make_custom_rtol(self, t: float) -> float: pulse = self.scenario.get_pulse(t) relative_time = t - self.scenario.get_time_start_current_pulse(t) if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-11 - elif pulse.pulse_type == "BAKE": + elif pulse.pulse_type == "BAKE": rtol = 1e-13 elif pulse.pulse_type == "FP": - # rtol = 1e-10 + # rtol = 1e-10 if relative_time % pulse.total_duration > pulse.duration_no_waiting: rtol = 1e-14 else: rtol = 1e-8 - else: + else: rtol = 1e-10 return rtol - - def bake_rtol(self, t:float) -> float: + + def bake_rtol(self, t: float) -> float: pulse = self.scenario.get_pulse(t) - if pulse.pulse_type == "BAKE": + if pulse.pulse_type == "BAKE": rtol = 1e-12 - else: + else: rtol = 1e-8 - return rtol \ No newline at end of file + return rtol From 57f58e5730b95cd1ddc47f2e6e399ce9f5b2dbdd Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Thu, 20 Mar 2025 17:55:34 -0400 Subject: [PATCH 44/50] update W temp function --- src/hisp/festim_models/mb_model.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/hisp/festim_models/mb_model.py b/src/hisp/festim_models/mb_model.py index a31c5db7..943d6b42 100644 --- a/src/hisp/festim_models/mb_model.py +++ b/src/hisp/festim_models/mb_model.py @@ -905,16 +905,19 @@ def calculate_temperature_W( Returns: temperature in K """ - # the evolution of T surface is taken from Delaporte-Mathurin et al. Sci Rep 10, 17798 (2020). - # https://doi.org/10.1038/s41598-020-74844-w - # T_surface = 1.1e-4 * heat_flux + coolant_temp - # T_rear = slope_T_rear * heat_flux + coolant_temp # T_surface and T_rear calculations taken from tungsten/copper calculations # provided by T. Wauters - T_surface, T_rear = tungsten_slab_temperature( - q_front=heat_flux, D_W=thickness, D_Cu=copper_thickness, T_cool=coolant_temp - ) + if copper_thickness is not None: + T_surface, T_rear = tungsten_slab_temperature( + q_front=heat_flux, D_W=thickness, D_Cu=copper_thickness, T_cool=coolant_temp + ) + else: + # the evolution of T surface is taken from Delaporte-Mathurin et al. Sci Rep 10, 17798 (2020). + # https://doi.org/10.1038/s41598-020-74844-w + T_surface = 1.1e-4 * heat_flux + coolant_temp + T_rear = slope_T_rear * heat_flux + coolant_temp + a = (T_rear - T_surface) / thickness b = T_surface return a * x + b From 0989766148a1a84fdf2fff0ae1a97bcf4552d40b Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sun, 23 Mar 2025 21:03:20 -0700 Subject: [PATCH 45/50] adjust fp timstep --- src/hisp/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index e1756ee2..a77244bf 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -217,9 +217,9 @@ def B_stepsize(self, t: float) -> float: # the stepsize is 1/10 of the duration of the pulse if pulse.pulse_type == "FP": if relative_time_within_sub_pulse < pulse.duration_no_waiting: - value = 0.01 # s + value = 0.001 # s else: - value = pulse.duration_no_waiting / 10 + value = pulse.duration_no_waiting / 100 elif pulse.pulse_type == "BAKE": value = pulse.duration_no_waiting / 10 else: From 03157a312d08704e0a35671a3eb27947f4dc0e02 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Fri, 28 Mar 2025 13:53:53 -0700 Subject: [PATCH 46/50] adjust B tolerances --- src/hisp/model.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index a77244bf..1bc699ce 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -217,9 +217,9 @@ def B_stepsize(self, t: float) -> float: # the stepsize is 1/10 of the duration of the pulse if pulse.pulse_type == "FP": if relative_time_within_sub_pulse < pulse.duration_no_waiting: - value = 0.001 # s + value = 0.01 # s else: - value = pulse.duration_no_waiting / 100 + value = pulse.duration_no_waiting / 10 elif pulse.pulse_type == "BAKE": value = pulse.duration_no_waiting / 10 else: @@ -334,7 +334,7 @@ def make_custom_rtol(self, t: float) -> float: if relative_time % pulse.total_duration > pulse.duration_no_waiting: rtol = 1e-14 else: - rtol = 1e-8 + rtol = 1e-5 else: rtol = 1e-10 return rtol From 0960ee686e79f766eafe0a2bfe402431aee77bf5 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sat, 29 Mar 2025 01:26:35 -0700 Subject: [PATCH 47/50] tolerance adjustments --- src/hisp/model.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 1bc699ce..814a274f 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -326,15 +326,15 @@ def make_custom_rtol(self, t: float) -> float: pulse = self.scenario.get_pulse(t) relative_time = t - self.scenario.get_time_start_current_pulse(t) if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": - rtol = 1e-11 + rtol = 1e-9 elif pulse.pulse_type == "BAKE": - rtol = 1e-13 + rtol = 1e-10 elif pulse.pulse_type == "FP": # rtol = 1e-10 if relative_time % pulse.total_duration > pulse.duration_no_waiting: rtol = 1e-14 else: - rtol = 1e-5 + rtol = 1e-7 else: rtol = 1e-10 return rtol From b74993d7116c477f52004199868c5c342ac209d9 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Sat, 29 Mar 2025 01:28:30 -0700 Subject: [PATCH 48/50] tolernace adjustments --- src/hisp/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 814a274f..28f4c5bd 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -328,13 +328,13 @@ def make_custom_rtol(self, t: float) -> float: if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-9 elif pulse.pulse_type == "BAKE": - rtol = 1e-10 + rtol = 1e-11 elif pulse.pulse_type == "FP": # rtol = 1e-10 if relative_time % pulse.total_duration > pulse.duration_no_waiting: rtol = 1e-14 else: - rtol = 1e-7 + rtol = 1e-8 else: rtol = 1e-10 return rtol From 6acf731a43f3fe8bba5cd06d6a2db6db1a4dae94 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 1 Apr 2025 11:18:09 -0400 Subject: [PATCH 49/50] rtol --- src/hisp/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index 28f4c5bd..f4675ebf 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -328,7 +328,7 @@ def make_custom_rtol(self, t: float) -> float: if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": rtol = 1e-9 elif pulse.pulse_type == "BAKE": - rtol = 1e-11 + rtol = 1e-10 elif pulse.pulse_type == "FP": # rtol = 1e-10 if relative_time % pulse.total_duration > pulse.duration_no_waiting: From f17087b4c3555062fc97104fb38c3d294b054561 Mon Sep 17 00:00:00 2001 From: kaelyndunnell Date: Tue, 1 Apr 2025 11:19:09 -0400 Subject: [PATCH 50/50] rtol --- src/hisp/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hisp/model.py b/src/hisp/model.py index f4675ebf..2cde2fb1 100644 --- a/src/hisp/model.py +++ b/src/hisp/model.py @@ -326,9 +326,9 @@ def make_custom_rtol(self, t: float) -> float: pulse = self.scenario.get_pulse(t) relative_time = t - self.scenario.get_time_start_current_pulse(t) if pulse.pulse_type == "GDC" or pulse.pulse_type == "ICWC": - rtol = 1e-9 + rtol = 1e-8 elif pulse.pulse_type == "BAKE": - rtol = 1e-10 + rtol = 1e-13 elif pulse.pulse_type == "FP": # rtol = 1e-10 if relative_time % pulse.total_duration > pulse.duration_no_waiting: