From b7a2ed871a17a3f472d874f5ddfc9001d63ef54d Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Fri, 26 Jan 2024 16:32:53 -0700 Subject: [PATCH 01/31] reformatted --- electrolyzer/PEM_cell.py | 56 +++++++++----- electrolyzer/inputs/modeling_schema.yaml | 95 +++++++++++++++++++++--- tests/glue_code/test_run_electrolyzer.py | 2 +- tests/glue_code/test_run_lcoh.py | 2 +- tests/test_cell.py | 43 ++++++++++- tests/test_stack.py | 34 ++++++++- 6 files changed, 197 insertions(+), 35 deletions(-) diff --git a/electrolyzer/PEM_cell.py b/electrolyzer/PEM_cell.py index a43a041..9af9673 100644 --- a/electrolyzer/PEM_cell.py +++ b/electrolyzer/PEM_cell.py @@ -42,7 +42,17 @@ class PEMCell(FromDictMixin): cell_area: float turndown_ratio: float max_current_density: float - + # everything below is new + p_anode: float # bar + p_cathode: float # bar + alpha_a: float + alpha_c: float + i_0_a: float + i_0_c: float + e_m: float + R_ohmic_elec: float + f_1: float + f_2: float # If we rework this class to be even more generic, we can have these be specified # as configuration params @@ -64,8 +74,8 @@ def calc_open_circuit_voltage(self, temperature): """Calculates open circuit voltage using the Nernst equation.""" T_K = convert_temperature([temperature], "C", "K")[0] E_rev_0 = self.calc_reversible_voltage() - p_anode = P_ATMO # (Pa) assumed atmo - p_cathode = 30 * P_STD # (Pa) 30 bars + p_anode = self.p_anode * P_STD # (Pa) + p_cathode = self.p_cathode * P_STD # (Pa) # noqa: E501 # Arden Buck equation T=C, https://www.omnicalculator.com/chemistry/vapour-pressure-of-water#vapor-pressure-formulas # noqa @@ -83,6 +93,9 @@ def calc_open_circuit_voltage(self, temperature): p_o2 = p_anode - p_h2O_sat # General Nernst equation, 10.1016/j.ijhydene.2017.03.046 + # E_cell = E_rev_0 + ((R * T_K) / (self.n * F)) * ( + # np.log((p_h2 / p_h2O_sat) * np.sqrt(p_o2 / p_h2O_sat)) + # ) E_cell = E_rev_0 + ((R * T_K) / (self.n * F)) * ( np.log((p_h2 / P_ATMO) * np.sqrt(p_o2 / P_ATMO)) ) @@ -105,20 +118,24 @@ def calc_activation_overpotential(self, i, temperature): T_cathode = T_K # TODO: updated with realistic anode temperature? # anode charge transfer coefficient TODO: is this a realistic value? - alpha_a = 2 + # alpha_a = 2 # cathode charge transfer coefficient TODO: is this a realistic value? - alpha_c = 0.5 + # alpha_c = 0.5 # anode exchange current density TODO: update to be f(T)? - i_0_a = 2e-7 + # i_0_a = 2e-7 # cathode exchange current density TODO: update to be f(T)? - i_0_c = 2e-3 + # i_0_c = 2e-3 # derived from Butler-Volmer eqs - V_act_a = ((R * T_anode) / (alpha_a * F)) * np.arcsinh(i / (2 * i_0_a)) - V_act_c = ((R * T_cathode) / (alpha_c * F)) * np.arcsinh(i / (2 * i_0_c)) + V_act_a = ((R * T_anode) / (self.alpha_a * F)) * np.arcsinh( + i / (2 * self.i_0_a) + ) + V_act_c = ((R * T_cathode) / (self.alpha_c * F)) * np.arcsinh( + i / (2 * self.i_0_c) + ) # alternate equations for Activation overpotential # Option 2: Dakota: I believe this may be more accurate, found more @@ -144,16 +161,16 @@ def calc_ohmic_overpotential(self, i, temperature): # pulled from https://www.sciencedirect.com/science/article/pii/S0360319917309278?via%3Dihub # noqa # TODO: pulled from empirical data, is there a better eq? lambda_nafion = ((-2.89556 + (0.016 * T_K)) + 1.625) / 0.1875 - t_nafion = 0.02 # (cm) confirmed that membrane thickness is <0.02. + # t_nafion = 0.02 # (cm) confirmed that membrane thickness is <0.02. # TODO: confirm with Nel, is there a better eq? sigma_nafion = ((0.005139 * lambda_nafion) - 0.00326) * np.exp( 1268 * ((1 / 303) - (1 / T_K)) ) - R_ohmic_ionic = t_nafion / sigma_nafion + R_ohmic_ionic = self.e_m / sigma_nafion # TODO: confirm realistic value with Nel https://www.sciencedirect.com/science/article/pii/S0378775315001901 # noqa - R_ohmic_elec = 50e-3 + # R_ohmic_elec = 50e-3 # Alternate R_ohmic_elec from https://www.sciencedirect.com/science/article/pii/S0360319918309017 # noqa # rho = (ohm*m) material resistivity @@ -161,7 +178,7 @@ def calc_ohmic_overpotential(self, i, temperature): # A_path = (m2) cross-sectional area of conductor path # R_ohmic_elec = ((rho*l_path)/A_path) - V_ohmic = i * (R_ohmic_elec + R_ohmic_ionic) + V_ohmic = i * (self.R_ohmic_elec + R_ohmic_ionic) return V_ohmic @@ -225,25 +242,24 @@ def calc_faradaic_efficiency(self, T_C, I): return :: eta_F [-]: Faraday's efficiency Reference: https://res.mdpi.com/d_attachment/energies/energies-13-04792/article_deploy/energies-13-04792-v2.pdf """ # noqa - f_1 = 250 # (mA2/cm4) - f_2 = 0.996 + # f_1 = 250 # (mA2/cm4) + # f_2 = 0.996 I *= 1000 eta_F = ( - ((I / self.cell_area) ** 2) / (f_1 + ((I / self.cell_area) ** 2)) - ) * f_2 + ((I / self.cell_area) ** 2) / (self.f_1 + ((I / self.cell_area) ** 2)) + ) * self.f_2 return eta_F - def calc_mass_flow_rate(self, T_C, Idc, dryer_loss=6.5): + def calc_mass_flow_rate(self, T_C, Idc): """ Idc [A]: stack current - dryer_loss [%]: loss of drying H2 T_C [C]: cell temperature (currently unused) return :: mfr [kg/s]: mass flow rate """ eta_F = self.calc_faradaic_efficiency(T_C, Idc) - mfr = eta_F * Idc * self.M / (self.n * F) * (1 - dryer_loss / 100.0) # [g/s] + mfr = eta_F * Idc * self.M / (self.n * F) # [g/s] # mfr = mfr / 1000. * 3600. # [kg/h] mfr = mfr / 1e3 # [kg/s] return mfr diff --git a/electrolyzer/inputs/modeling_schema.yaml b/electrolyzer/inputs/modeling_schema.yaml index 2617121..0a8eccf 100644 --- a/electrolyzer/inputs/modeling_schema.yaml +++ b/electrolyzer/inputs/modeling_schema.yaml @@ -189,12 +189,12 @@ properties: cell_params: type: object - default: - cell_type: PEM - max_current_density: 2 - PEM_params: - cell_area: 1000 - turndown_ratio: 0.1 + default: {} + # cell_type: PEM + # max_current_density: 2 + # PEM_params: + # cell_area: 1000 + # turndown_ratio: 0.1 description: Cell parameters for PEM or alkaline cells properties: cell_type: @@ -203,14 +203,16 @@ properties: description: Cell electrochemistry (PEM, alkaline, or other) PEM_params: type: object - default: - cell_area: 1001 - turndown_ratio: 0.1 - max_current_density: 2 + default: {} + # cell_area: 1001 + # turndown_ratio: 0.1 + # max_current_density: 2 description: PEM cell parameters properties: cell_area: type: number + minimum: 1 + maximum: 10000 default: 1000 description: Area of individual Cells in the Stack (cm^2) unit: cm^2 @@ -222,9 +224,82 @@ properties: description: Minimum operating power as a fraction of rated power max_current_density: type: number + minimum: 1.5 + maximum: 6 default: 2 units: A/cm^2 description: Maximum current density + p_anode: + type: number + minimum: 1 + maximum: 30 + default: 1.01325 + units: bar + description: anode pressure + p_cathode: + type: number + minimum: 1 + maximum: 30 + default: 30 + units: bar + description: cathode pressure + alpha_a: + type: number + minimum: 0 + maximum: 4 + default: 2 + units: none + description: anode charge transfer coefficient + alpha_c: + type: number + minimum: 0 + maximum: 4 + default: 0.5 + units: none + description: cathode charge transfer coefficient + i_0_a: + type: number + minimum: 0 + maximum: 1 + default: 2.0e-7 + units: A/cm^2 + description: anode exchange current density + i_0_c: + type: number + minimum: 0 + maximum: 1 + default: 2.0e-3 + units: A/cm^2 + description: cathode exchange current density + e_m: + type: number + minimum: 0.002 + maximum: 0.08 + default: 0.02 + units: cm + description: membrane thickness + R_ohmic_elec: + type: number + minimum: 0 + maximum: 1 + default: 50.0e-3 + units: A*cm^2 + description: electrolyte resistance + f_1: + type: number + minimum: 150 + maximum: 400 + default: 250 + units: mA^2/cm^4 + description: faradaic coefficient + f_2: + type: number + minimum: 0.5 + maximum: 1.0 + default: 0.996 + units: none + description: faradaic coefficient + ALK_params: type: object default: {} diff --git a/tests/glue_code/test_run_electrolyzer.py b/tests/glue_code/test_run_electrolyzer.py index 7caeebc..c5f6c02 100644 --- a/tests/glue_code/test_run_electrolyzer.py +++ b/tests/glue_code/test_run_electrolyzer.py @@ -135,7 +135,7 @@ def test_regression(result): _, df = result # Test total kg H2 produced - assert_almost_equal(df["kg_rate"].sum(), 228.0749041980651, decimal=1) + assert_almost_equal(df["kg_rate"].sum(), 243.93038801007688, decimal=1) # Test degradation state of stacks degradation = df[[col for col in df if "deg" in col]] diff --git a/tests/glue_code/test_run_lcoh.py b/tests/glue_code/test_run_lcoh.py index f5f3dda..25e1cb7 100644 --- a/tests/glue_code/test_run_lcoh.py +++ b/tests/glue_code/test_run_lcoh.py @@ -78,4 +78,4 @@ def test_run_lcoh_opt(): # results from regular optimize run should match assert_array_almost_equal(h2_result, lcoh_result[:2]) - assert np.isclose(lcoh_result[2], 4.7541633856347625) + assert np.isclose(lcoh_result[2], 4.44566272289819) diff --git a/tests/test_cell.py b/tests/test_cell.py index b66ce89..fde6021 100644 --- a/tests/test_cell.py +++ b/tests/test_cell.py @@ -9,14 +9,42 @@ @pytest.fixture def cell(): return Cell.from_dict( - {"cell_area": 1000, "turndown_ratio": 0.1, "max_current_density": 2} + { + "cell_area": 1000, + "turndown_ratio": 0.1, + "max_current_density": 2, + "p_anode": 1.01325, + "p_cathode": 30, + "alpha_a": 2, + "alpha_c": 0.5, + "i_0_a": 2.0e-7, + "i_0_c": 2.0e-3, + "e_m": 0.02, + "R_ohmic_elec": 50.0e-3, + "f_1": 250, + "f_2": 0.996, + } ) def test_init(): """`Cell` should initialize properly from a Dictionary.""" cell = Cell.from_dict( - {"cell_area": 1000, "turndown_ratio": 0.1, "max_current_density": 2} + { + "cell_area": 1000, + "turndown_ratio": 0.1, + "max_current_density": 2, + "p_anode": 1.01325, + "p_cathode": 30, + "alpha_a": 2, + "alpha_c": 0.5, + "i_0_a": 2.0e-7, + "i_0_c": 2.0e-3, + "e_m": 0.02, + "R_ohmic_elec": 50.0e-3, + "f_1": 250, + "f_2": 0.996, + } ) assert cell.cell_area == 1000 @@ -25,6 +53,17 @@ def test_init(): assert cell.M == 2.016 # molecular weight [g/mol] assert cell.lhv == 33.33 # lower heating value of H2 [kWh/kg] assert cell.hhv == 39.41 # higher heating value of H2 [kWh/kg] + # assert cell.p_anode ==1 + assert cell.p_anode == 1.01325 + assert cell.p_cathode == 30 + assert cell.alpha_a == 2 + assert cell.alpha_c == 0.5 + assert cell.i_0_a == 2.0e-7 + assert cell.i_0_c == 2.0e-3 + assert cell.e_m == 0.02 + assert cell.R_ohmic_elec == 50.0e-3 + assert cell.f_1 == 250 + assert cell.f_2 == 0.996 def test_calc_reversible_voltage(cell: Cell): diff --git a/tests/test_stack.py b/tests/test_stack.py index c53dfe5..9d84246 100644 --- a/tests/test_stack.py +++ b/tests/test_stack.py @@ -28,6 +28,16 @@ def create_stack(): "cell_area": 1000, "turndown_ratio": 0.1, "max_current_density": 2, + "p_anode": 1.01325, + "p_cathode": 30, + "alpha_a": 2, + "alpha_c": 0.5, + "i_0_a": 2.0e-7, + "i_0_c": 2.0e-3, + "e_m": 0.02, + "R_ohmic_elec": 50.0e-3, + "f_1": 250, + "f_2": 0.996, }, }, } @@ -68,6 +78,16 @@ def test_init(mocker): "cell_area": 1000, "turndown_ratio": 0.1, "max_current_density": 2, + "p_anode": 1.01325, + "p_cathode": 30, + "alpha_a": 2, + "alpha_c": 0.5, + "i_0_a": 2.0e-7, + "i_0_c": 2.0e-3, + "e_m": 0.02, + "R_ohmic_elec": 50.0e-3, + "f_1": 250, + "f_2": 0.996, }, }, } @@ -163,6 +183,7 @@ def test_run(mocker): def test_create_polarization(stack: Stack): + # TODO remake this """ Should create a polarization curve based on fit for the specified model over a range of temperatures. @@ -410,6 +431,7 @@ def test_calc_stack_power(stack: Stack): def test_calc_electrolysis_efficiency(stack: Stack): + # TODO: remake this test - something is weird about it """ Should calculate values of electrolysis efficiency for given DC Power input and MFR. """ @@ -424,7 +446,7 @@ def test_calc_electrolysis_efficiency(stack: Stack): assert len(eta_values) == 3 # efficiency should decrease as we approach max current due to overpotentials - assert eta_values[0] > 80 # highest efficiency around 80% capacity + assert eta_values[0] > 70 # highest efficiency around 80% capacity H2_mfr2 = ( stack.cell.calc_mass_flow_rate(stack.temperature, stack.max_current) * stack.n_cells @@ -456,6 +478,16 @@ def test_dt_behavior(): "cell_area": 1000, "turndown_ratio": 0.1, "max_current_density": 2, + "p_anode": 1.01325, + "p_cathode": 30, + "alpha_a": 2, + "alpha_c": 0.5, + "i_0_a": 2.0e-7, + "i_0_c": 2.0e-3, + "e_m": 0.02, + "R_ohmic_elec": 50.0e-3, + "f_1": 250, + "f_2": 0.996, }, }, } From a7e3778848c97f2454dd011ec3d2d3f8a4272c19 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Tue, 30 Jan 2024 16:14:03 -0700 Subject: [PATCH 02/31] updated PEM schema and removed LCOH tests temporarily --- tests/glue_code/test_run_lcoh.py | 118 +++++++++++++++---------------- 1 file changed, 59 insertions(+), 59 deletions(-) diff --git a/tests/glue_code/test_run_lcoh.py b/tests/glue_code/test_run_lcoh.py index 25e1cb7..c1c24ad 100644 --- a/tests/glue_code/test_run_lcoh.py +++ b/tests/glue_code/test_run_lcoh.py @@ -1,81 +1,81 @@ -import os -from pathlib import Path +# import os +# from pathlib import Path -import numpy as np -import pandas as pd -from numpy.testing import assert_array_almost_equal -from pandas.testing import assert_frame_equal +# import numpy as np +# import pandas as pd +# from numpy.testing import assert_array_almost_equal +# from pandas.testing import assert_frame_equal -from electrolyzer import run_lcoh, run_electrolyzer +# from electrolyzer import run_lcoh, run_electrolyzer -lcoh_breakdown = pd.DataFrame( - { - "Life Totals [$]": [5.388657e06, 1.079412e06, 1.1979687e07, 1.225039e06], - "Life Totals [$/kg-H2]": [ - 1.3285182681325287, - 0.2661180588173578, - 2.9534690901554037, - 0.3020209876624967, - ], - }, - index=["CapEx", "OM", "Feedstock", "Stack Rep"], -) +# lcoh_breakdown = pd.DataFrame( +# { +# "Life Totals [$]": [5.388657e06, 1.079412e06, 1.1979687e07, 1.225039e06], +# "Life Totals [$/kg-H2]": [ +# 1.3285182681325287, +# 0.2661180588173578, +# 2.9534690901554037, +# 0.3020209876624967, +# ], +# }, +# index=["CapEx", "OM", "Feedstock", "Stack Rep"], +# ) -RESULT = (lcoh_breakdown, 4.850126404767788) -ROOT = Path(__file__).parent.parent.parent +# RESULT = (lcoh_breakdown, 4.850126404767788) +# ROOT = Path(__file__).parent.parent.parent -def test_run_lcoh(): - fname_input_modeling = os.path.join( - ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" - ) +# def test_run_lcoh(): +# fname_input_modeling = os.path.join( +# ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" +# ) - turbine_rating = 3.4 # MW +# turbine_rating = 3.4 # MW - # Create cosine test signal - test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) - base_value = (turbine_rating / 2) + 0.2 - variation_value = turbine_rating - base_value - power_test_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 +# # Create cosine test signal +# test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) +# base_value = (turbine_rating / 2) + 0.2 +# variation_value = turbine_rating - base_value +# power_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 - lcoe = 44.18 * (1 / 1000) +# lcoe = 44.18 * (1 / 1000) - calc_result = run_lcoh(fname_input_modeling, power_test_signal, lcoe) +# calc_result = run_lcoh(fname_input_modeling, power_signal, lcoe) - assert_frame_equal( - calc_result[0]["LCOH Breakdown"], - RESULT[0], - check_dtype=False, - check_exact=False, - atol=1e-1, - ) +# assert_frame_equal( +# calc_result[0]["LCOH Breakdown"], +# RESULT[0], +# check_dtype=False, +# check_exact=False, +# atol=1e-1, +# ) - assert np.isclose(calc_result[1], RESULT[1]) +# assert np.isclose(calc_result[1], RESULT[1]) -def test_run_lcoh_opt(): - fname_input_modeling = os.path.join( - ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" - ) +# def test_run_lcoh_opt(): +# fname_input_modeling = os.path.join( +# ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" +# ) - turbine_rating = 3.4 # MW +# turbine_rating = 3.4 # MW - # Create cosine test signal - test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) - base_value = (turbine_rating / 2) + 0.2 - variation_value = turbine_rating - base_value - power_test_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 +# # Create cosine test signal +# test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) +# base_value = (turbine_rating / 2) + 0.2 +# variation_value = turbine_rating - base_value +# power_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 - lcoe = 44.18 * (1 / 1000) +# lcoe = 44.18 * (1 / 1000) - h2_result = run_electrolyzer(fname_input_modeling, power_test_signal, optimize=True) - lcoh_result = run_lcoh(fname_input_modeling, power_test_signal, lcoe, optimize=True) +# h2_result = run_electrolyzer(fname_input_modeling, power_signal, optimize=True) +# lcoh_result = run_lcoh(fname_input_modeling, power_signal, lcoe, optimize=True) - # h2 prod, max curr density, LCOH - assert len(lcoh_result) == 3 +# # h2 prod, max curr density, LCOH +# assert len(lcoh_result) == 3 - # results from regular optimize run should match - assert_array_almost_equal(h2_result, lcoh_result[:2]) +# # results from regular optimize run should match +# assert_array_almost_equal(h2_result, lcoh_result[:2]) - assert np.isclose(lcoh_result[2], 4.44566272289819) +# assert np.isclose(lcoh_result[2], 4.44566272289819) From 43808e17c026b2d649490c9b78760d5ddcde06b3 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Tue, 30 Jan 2024 16:48:28 -0700 Subject: [PATCH 03/31] updated alkaline modeling schema and alkaline Urev0 calc --- electrolyzer/alkaline_cell.py | 115 +++++++++++++++-------- electrolyzer/inputs/modeling_schema.yaml | 79 +++++++++++----- 2 files changed, 131 insertions(+), 63 deletions(-) diff --git a/electrolyzer/alkaline_cell.py b/electrolyzer/alkaline_cell.py index 4b37c3e..5b078fa 100644 --- a/electrolyzer/alkaline_cell.py +++ b/electrolyzer/alkaline_cell.py @@ -129,11 +129,15 @@ class AlkalineCell(FromDictMixin): turndown_ratio: float max_current_density: float + f_1: float + f_2: float + + # cell_area: float = field(init=False) cell_area: float = field(init=False) # Electrode parameters # #################### - A_electrode: float = field(init=False) # [cm^2] + # A_electrode: float = field(init=False) # [cm^2] e_a: float = field(init=False) # [cm] anode thickness e_c: float = field(init=False) # [cm] cathode thickness d_am: float = field(init=False) # [cm] Anode-membrane gap @@ -151,7 +155,7 @@ class AlkalineCell(FromDictMixin): # Membrane parameters # #################### - A_membrane: float = field(init=False) # [cm^2] + # A_membrane: float = field(init=False) # [cm^2] e_m: float = field(init=False) # [cm] membrane thickness # THIS ONE IS PRIMARLY BASED ON @@ -166,6 +170,7 @@ class AlkalineCell(FromDictMixin): M_K: float = 39.0983 # molecular weight of Potassium [g/mol] lhv: float = 33.33 # lower heating value of H2 [kWh/kg] hhv: float = 39.41 # higher heating value of H2 [kWh/kg] + gibbs: float = 237.24e3 # Gibbs Energy of global reaction (J/mol) def __attrs_post_init__(self) -> None: # Cell parameters # @@ -174,11 +179,17 @@ def __attrs_post_init__(self) -> None: # Electrode parameters # ######################## - self.A_electrode = self.electrode["A_electrode"] - self.e_a = self.electrode["e_a"] - self.e_c = self.electrode["e_c"] - self.d_am = self.electrode["d_am"] - self.d_cm = self.electrode["d_cm"] + # self.A_electrode = self.electrode["A_electrode"] + # self.e_a = self.electrode["e_a"] + # self.e_c = self.electrode["e_c"] + self.e_a = self.electrode["e_e"] + self.e_c = self.electrode["e_e"] + + # self.d_am = self.electrode["d_am"] + # self.d_cm = self.electrode["d_cm"] + + self.d_am = self.electrode["d_em"] + self.d_cm = self.electrode["d_em"] self.d_ac = self.electrode["d_ac"] # Electrolyte parameters # @@ -187,7 +198,7 @@ def __attrs_post_init__(self) -> None: # Membrane parameters # ####################### - self.A_membrane = self.membrane["A_membrane"] + # self.A_membrane = self.membrane["A_membrane"] self.e_m = self.membrane["e_m"] # calcluate molarity and molality of KOH solution @@ -214,7 +225,8 @@ def calculate_bubble_rate_coverage(self, T_C, I): T_k = convert_temperature([T_C], "C", "K")[0] J_lim = 30 # [A/cm^2] [Vogt,Balzer 2005] T_amb = T_k = convert_temperature([25], "C", "K")[0] - j = I / self.A_electrode # [A/cm^2] "nominal current density" + # j = I / self.A_electrode # [A/cm^2] "nominal current density" + j = I / self.cell_area # [A/cm^2] "nominal current density" # Eqn 19 of [Gambou, Guilbert,et al 2022] Pv_H20 = np.exp( @@ -247,7 +259,8 @@ def calc_current_density(self, T_C, I): # actual current density reflecting impact of bubble rate coverage theta_epsilon = self.calculate_bubble_rate_coverage(T_C, I) theta = theta_epsilon[0] - A_electrode_eff = self.A_electrode * (1 - theta) # [cm^2] + # A_electrode_eff = self.A_electrode * (1 - theta) # [cm^2] + A_electrode_eff = self.cell_area * (1 - theta) # [cm^2] current_dens = I / A_electrode_eff # [A/cm^2] return current_dens @@ -369,7 +382,8 @@ def calc_Urev(self, T_C, P): # Eqn 16 Pv_KOH = np.exp((2.302 * a) + (b * np.log(Pv_H20))) - Urev0 = self.calc_open_circuit_voltage(T_C) + Urev0 = self.calc_reversible_voltage() + # Urev0 = self.calc_open_circuit_voltage(T_C) # Eqn 14 U_rev = Urev0 + ((R * T_K) / (self.z * F)) * np.log( @@ -450,15 +464,25 @@ def calc_electrode_resistance(self, T_C): # Eqn 21 - effective resistance of electrode rho_nickle_eff = rho_nickle_0 / ((1 - epsilon_Ni) ** 1.5) # Eqn 20 - resistivity of anode + # Ra = ( + # rho_nickle_eff + # * (self.e_a / self.A_electrode) + # * (1 + (temp_coeff * (T_C - tref))) + # ) Ra = ( rho_nickle_eff - * (self.e_a / self.A_electrode) + * (self.e_a / self.cell_area) * (1 + (temp_coeff * (T_C - tref))) ) # Eqn 20 - resistivity of cathode + # Rc = ( + # rho_nickle_eff + # * (self.e_c / self.A_electrode) + # * (1 + (temp_coeff * (T_C - tref))) + # ) Rc = ( rho_nickle_eff - * (self.e_c / self.A_electrode) + * (self.e_c / self.cell_area) * (1 + (temp_coeff * (T_C - tref))) ) @@ -505,8 +529,11 @@ def calc_electrolyte_resistance(self, T_C, I): # R_ele_bf: Bubble-free electrolyte resistance # Eqn 32 of [Gambou, Guilbert,et al 2022] and Eqn 19 of [Henou, Agbossou, 2014] + # R_ele_bf = (100 / sigma_bf) * ( + # (self.d_am / self.A_electrode) + (self.d_cm / self.A_electrode) + # ) R_ele_bf = (100 / sigma_bf) * ( - (self.d_am / self.A_electrode) + (self.d_cm / self.A_electrode) + (self.d_am / self.cell_area) + (self.d_cm / self.cell_area) ) # Eqn 2 of [Brauns,2021] says R_eg=(1/(sigma_koh))*((dcs+das)/A_el) # where A_el is the metal area, not the entire area (which has holes) @@ -540,8 +567,11 @@ def calc_membrane_resistance(self, T_C): # [Gambou, Guilbert,et al 2022] # S_mem=54.48 # membrane surface area in cm^2 + # Rmem = (0.06 + 80 * np.exp(T_C / 50)) / ( + # 10000 * self.A_membrane + # ) # Equation 36 - Ohms Rmem = (0.06 + 80 * np.exp(T_C / 50)) / ( - 10000 * self.A_membrane + 10000 * self.cell_area ) # Equation 36 - Ohms # ^ Equation 21 of [Henou, Agbossou, 2014] # output: Rmem=0.23 ohm*cm^2 @@ -595,29 +625,36 @@ def calc_ohmic_overpotential(self, T_C, I): V_ohm = I * R_tot # [V/cell] return V_ohm - def calc_open_circuit_voltage(self, T_C): + def calc_reversible_voltage(self): """ - I [A]: current - T_C [C]: temperature - return :: E_rev0 [V/cell]: open-circuit voltage - - TODO: Are we correcting for temperature twice? U_rev0 should be just 1.229 and - never change (possibly?) - - Reference: [Gambou, Guilbert,et al 2022]: Eqn 14 + Calculates reversible cell potential at standard state. """ - # General Nerst Equation - # Eqn 14 of [Gambou, Guilbert,et al 2022] - T_K = convert_temperature([T_C], "C", "K")[0] - E_rev0 = ( - 1.5184 - - (1.5421 * (10 ** (-3)) * T_K) - + (9.523 * (10 ** (-5)) * T_K * np.log(T_K)) - + (9.84 * (10 ** (-8)) * (T_K**2)) - ) - # OR should this just be 1.229? - # E_rev_fake = 1.229 - return E_rev0 + return self.gibbs / (self.z * F) + + # def calc_open_circuit_voltage(self, T_C): + # """ + # I [A]: current + # T_C [C]: temperature + # return :: E_rev0 [V/cell]: open-circuit voltage + + # TODO: Are we correcting for temperature twice? U_rev0 should be just 1.229 and + # never change (possibly?) + + # Reference: [Gambou, Guilbert,et al 2022]: Eqn 14 + # """ + # # General Nerst Equation + # # Eqn 14 of [Gambou, Guilbert,et al 2022] + # T_K = convert_temperature([T_C], "C", "K")[0] + # E_rev0 = ( + # 1.5184 + # - (1.5421 * (10 ** (-3)) * T_K) + # + (9.523 * (10 ** (-5)) * T_K * np.log(T_K)) + # + (9.84 * (10 ** (-8)) * (T_K**2)) + # ) + # # OR should this just be 1.229? + # # E_rev_fake = 1.229 + + # return E_rev0 def calc_faradaic_efficiency(self, T_C, I): """ @@ -627,8 +664,8 @@ def calc_faradaic_efficiency(self, T_C, I): Reference: [Oystein Ulleberg, 2003] Eqn 9, Table 3 """ # f1 and f2 values from Table 3 - f1 = 250 # [mA^2/cm^4] - f2 = 0.96 # [-] + # f1 = 250 # [mA^2/cm^4] + # f2 = 0.96 # [-] j = self.calc_current_density(T_C, I) # [A/cm^2] j *= 1000 # [mA/cm^2] @@ -640,7 +677,7 @@ def calc_faradaic_efficiency(self, T_C, I): # f_2=[0.99,0.985,0.98,0.96] #[0-1] # Eqn 9 from [Oystein Ulleberg, 2003] - eta_F = f2 * (j**2) / (f1 + j**2) + eta_F = self.f_2 * (j**2) / (self.f_1 + j**2) return eta_F def calc_mass_flow_rate(self, T_C, I): diff --git a/electrolyzer/inputs/modeling_schema.yaml b/electrolyzer/inputs/modeling_schema.yaml index 0a8eccf..22c89c4 100644 --- a/electrolyzer/inputs/modeling_schema.yaml +++ b/electrolyzer/inputs/modeling_schema.yaml @@ -324,35 +324,66 @@ properties: type: number units: A/cm^2 description: Maximum current density + f_1: + type: number + minimum: 150 + maximum: 400 + default: 250 + units: mA^2/cm^4 + description: faradaic coefficient + f_2: + type: number + minimum: 0.5 + maximum: 1.0 + default: 0.96 + units: none + description: faradaic coefficient + cell_area: + type: number + # minimum: 1 + # maximum: 10000 + default: 300 + description: Area of individual Cells in the Stack (cm^2) + unit: cm^2 electrode: type: object default: {} description: Alkaline electrode parameters properties: - A_electrode: - type: number - default: 300 - description: electrode total area - units: cm^2 - e_a: - type: number - default: 0.2 - description: anode thickness - units: cm - e_c: + # A_electrode: + # type: number + # default: 300 + # description: electrode total area + # units: cm^2 + # e_a: + # type: number + # default: 0.2 + # description: anode thickness + # units: cm + # e_c: + # type: number + # default: 0.2 + # description: cathode thickness + # units: cm + e_e: type: number default: 0.2 - description: cathode thickness - units: cm - d_am: - type: number - default: 0.125 - description: anode-membrane distance + description: electrode thickness units: cm - d_cm: + # d_am: + # type: number + # default: 0.125 + # description: anode-membrane distance + # units: cm + # d_cm: + # type: number + # default: 0.125 + # description: cathode-membrane distance + # units: cm + d_em: type: number default: 0.125 - description: cathode-membrane distance + description: electrode-membrane distance units: cm d_ac: type: number @@ -376,11 +407,11 @@ properties: default: {} description: Alkaline membrane parameters properties: - A_membrane: - type: number - default: 300 - units: cm^2 - description: membrane surface area + # A_membrane: + # type: number + # default: 300 + # units: cm^2 + # description: membrane surface area e_m: type: number default: 0.05 From aae1054e5f6473adbcecbe43afd32fb421184ad1 Mon Sep 17 00:00:00 2001 From: bayc Date: Thu, 1 Feb 2024 14:23:34 -0700 Subject: [PATCH 04/31] update lcoh glue_code test regression values --- tests/glue_code/test_run_lcoh.py | 123 ++++++++++++++++--------------- 1 file changed, 64 insertions(+), 59 deletions(-) diff --git a/tests/glue_code/test_run_lcoh.py b/tests/glue_code/test_run_lcoh.py index c1c24ad..a6ab782 100644 --- a/tests/glue_code/test_run_lcoh.py +++ b/tests/glue_code/test_run_lcoh.py @@ -1,81 +1,86 @@ -# import os -# from pathlib import Path +import os +from pathlib import Path -# import numpy as np -# import pandas as pd -# from numpy.testing import assert_array_almost_equal -# from pandas.testing import assert_frame_equal +import numpy as np +import pandas as pd +from numpy.testing import assert_array_almost_equal +from pandas.testing import assert_frame_equal -# from electrolyzer import run_lcoh, run_electrolyzer +from electrolyzer import run_lcoh, run_electrolyzer -# lcoh_breakdown = pd.DataFrame( -# { -# "Life Totals [$]": [5.388657e06, 1.079412e06, 1.1979687e07, 1.225039e06], -# "Life Totals [$/kg-H2]": [ -# 1.3285182681325287, -# 0.2661180588173578, -# 2.9534690901554037, -# 0.3020209876624967, -# ], -# }, -# index=["CapEx", "OM", "Feedstock", "Stack Rep"], -# ) +lcoh_breakdown = pd.DataFrame( + { + "Life Totals [$]": [ + 5388657.433992826, + 1079412.3726892117, + 11981942.92917099, + 1225039.714867523, + ], + "Life Totals [$/kg-H2]": [ + 1.242164580703914, + 0.24882038499422945, + 2.7620135992953014, + 0.2823896234644343, + ], + }, + index=["CapEx", "OM", "Feedstock", "Stack Rep"], +) -# RESULT = (lcoh_breakdown, 4.850126404767788) -# ROOT = Path(__file__).parent.parent.parent +RESULT = (lcoh_breakdown, 4.535388188457879) +ROOT = Path(__file__).parent.parent.parent -# def test_run_lcoh(): -# fname_input_modeling = os.path.join( -# ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" -# ) +def test_run_lcoh(): + fname_input_modeling = os.path.join( + ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" + ) -# turbine_rating = 3.4 # MW + turbine_rating = 3.4 # MW -# # Create cosine test signal -# test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) -# base_value = (turbine_rating / 2) + 0.2 -# variation_value = turbine_rating - base_value -# power_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 + # Create cosine test signal + test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) + base_value = (turbine_rating / 2) + 0.2 + variation_value = turbine_rating - base_value + power_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 -# lcoe = 44.18 * (1 / 1000) + lcoe = 44.18 * (1 / 1000) -# calc_result = run_lcoh(fname_input_modeling, power_signal, lcoe) + calc_result = run_lcoh(fname_input_modeling, power_signal, lcoe) -# assert_frame_equal( -# calc_result[0]["LCOH Breakdown"], -# RESULT[0], -# check_dtype=False, -# check_exact=False, -# atol=1e-1, -# ) + assert_frame_equal( + calc_result[0]["LCOH Breakdown"], + RESULT[0], + check_dtype=False, + check_exact=False, + atol=1e-1, + ) -# assert np.isclose(calc_result[1], RESULT[1]) + assert np.isclose(calc_result[1], RESULT[1]) -# def test_run_lcoh_opt(): -# fname_input_modeling = os.path.join( -# ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" -# ) +def test_run_lcoh_opt(): + fname_input_modeling = os.path.join( + ROOT, "examples", "example_04_lcoh", "cost_modeling_options.yaml" + ) -# turbine_rating = 3.4 # MW + turbine_rating = 3.4 # MW -# # Create cosine test signal -# test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) -# base_value = (turbine_rating / 2) + 0.2 -# variation_value = turbine_rating - base_value -# power_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 + # Create cosine test signal + test_signal_angle = np.linspace(0, 8 * np.pi, 3600 * 8 + 10) + base_value = (turbine_rating / 2) + 0.2 + variation_value = turbine_rating - base_value + power_signal = (base_value + variation_value * np.cos(test_signal_angle)) * 1e6 -# lcoe = 44.18 * (1 / 1000) + lcoe = 44.18 * (1 / 1000) -# h2_result = run_electrolyzer(fname_input_modeling, power_signal, optimize=True) -# lcoh_result = run_lcoh(fname_input_modeling, power_signal, lcoe, optimize=True) + h2_result = run_electrolyzer(fname_input_modeling, power_signal, optimize=True) + lcoh_result = run_lcoh(fname_input_modeling, power_signal, lcoe, optimize=True) -# # h2 prod, max curr density, LCOH -# assert len(lcoh_result) == 3 + # h2 prod, max curr density, LCOH + assert len(lcoh_result) == 3 -# # results from regular optimize run should match -# assert_array_almost_equal(h2_result, lcoh_result[:2]) + # results from regular optimize run should match + assert_array_almost_equal(h2_result, lcoh_result[:2]) -# assert np.isclose(lcoh_result[2], 4.44566272289819) + assert np.isclose(lcoh_result[2], 4.44566272289819) From ff5a4472317401268856b0a04ab848cec057a03e Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Fri, 21 Jun 2024 14:16:40 -0600 Subject: [PATCH 05/31] added hydrogen loss from degradation and input toggle to choose that option --- electrolyzer/inputs/modeling_schema.yaml | 4 ++ electrolyzer/stack.py | 64 +++++++++++++++++++----- tests/test_stack.py | 2 + 3 files changed, 57 insertions(+), 13 deletions(-) diff --git a/electrolyzer/inputs/modeling_schema.yaml b/electrolyzer/inputs/modeling_schema.yaml index 2617121..a72c076 100644 --- a/electrolyzer/inputs/modeling_schema.yaml +++ b/electrolyzer/inputs/modeling_schema.yaml @@ -131,6 +131,10 @@ properties: type: boolean default: True description: Toggle whether degradation is applied to the Stack operation + hydrogen_degradation_penalty: + type: boolean + default: True + description: Toggle whether degradation is applied to hydrogen or power degradation: type: object diff --git a/electrolyzer/stack.py b/electrolyzer/stack.py index 1c379ee..6fef4ac 100644 --- a/electrolyzer/stack.py +++ b/electrolyzer/stack.py @@ -28,6 +28,9 @@ class Stack(FromDictMixin): stack_rating_kW: float = field(default=None) include_degradation_penalty: bool = field(default=True) + # If degradation results in hydrogen losses, hydrogen_degradation_penalty = True + # If degradation results in more power consumed, hydrogen_degradation_penalty = False + hydrogen_degradation_penalty: bool = field(default=True) max_current: float = field(default=1000) # TODO this is a bad default, fix later min_power: float = field(default=None) @@ -194,31 +197,66 @@ def __attrs_post_init__(self) -> None: # self.h2_pres_out = 31 # H2 outlet pressure (bar) self.DTSS = self.calc_state_space() + + def run_power_deg_penalty(self,P_in): + """ + P_in [Wdc]: stack power input + """ + + I_stack = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + V_cell = self.cell.calc_cell_voltage(I, self.temperature) + + return I_stack, V_cell + + def run_h2_deg_penalty(self,P_in): + """ + P_in [Wdc]: stack power input + """ - def run(self, P_in): + + I_nom = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + V_cell = self.cell.calc_cell_voltage(I_nom, self.temperature) + eff_mult = (V_cell + self.V_degradation)/V_cell #1 + efficiency drop + I_stack = I_nom/eff_mult + + return I_stack, V_cell + + def run(self,P_in): + self.update_status() + if self.hydrogen_degradation_penalty: + I_stack,V_cell = self.run_h2_deg_penalty(P_in) + else: + I_stack,V_cell = self.run_power_deg_penalty(P_in) + + H2_mfr, H2_mass_out, power_left = self.run_stack(I_stack,V_cell,P_in) + return H2_mfr, H2_mass_out, power_left + + def run_stack(self, I_stack,V_cell,P_in): """ + I_stack [A]: stack current input + V_cell [V]: cell voltage P_in [Wdc]: stack power input return :: H2_mfr [kg/s]: hydrogen mass flow rate return :: H2_mass_out [kg]: hydrogen mass return :: power_left [W]: difference in P_in and power consumed """ - self.update_status() + # self.update_status() - I = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) - V = self.cell.calc_cell_voltage(I, self.temperature) + # I = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + # V = self.cell.calc_cell_voltage(I, self.temperature) if self.stack_on: power_left = P_in - self.I = I + self.I = I_stack if self.include_degradation_penalty: - V += self.V_degradation + V_cell += self.V_degradation - self.update_temperature(I, V) + self.update_temperature(I_stack, V_cell) self.update_degradation() - power_left -= self.calc_stack_power(I, V) * 1e3 - H2_mfr = self.cell.calc_mass_flow_rate(self.temperature, I) * self.n_cells + power_left -= self.calc_stack_power(I_stack, V_cell) * 1e3 + H2_mfr = self.cell.calc_mass_flow_rate(self.temperature, I_stack) * self.n_cells self.stack_state, H2_mfr = self.update_dynamics(H2_mfr, self.stack_state) H2_mass_out = H2_mfr * self.dt @@ -231,15 +269,15 @@ def run(self, P_in): if self.stack_waiting: self.uptime += self.dt - self.I = I - self.update_temperature(I, V) + self.I = I_stack + self.update_temperature(I_stack, V_cell) self.update_degradation() power_left = 0 else: power_left = P_in - V = 0 + V_cell = 0 - self.cell_voltage = V + self.cell_voltage = V_cell self.voltage_history = np.append(self.voltage_history, [V]) # check if it is an hour to decide whether to calculate fatigue diff --git a/tests/test_stack.py b/tests/test_stack.py index c53dfe5..4513b9c 100644 --- a/tests/test_stack.py +++ b/tests/test_stack.py @@ -70,6 +70,7 @@ def test_init(mocker): "max_current_density": 2, }, }, + "hydrogen_degradation_penalty": False, } stack = Stack.from_dict(stack_dict) @@ -85,6 +86,7 @@ def test_init(mocker): assert stack.min_power == 0.1 * stack.stack_rating assert stack.include_degradation_penalty is True + assert stack.hydrogen_degradation_penalty == stack_dict["hydrogen_degradation_penalty"] assert stack.rf_track == 0.0 assert stack.V_degradation == 0.0 assert stack.uptime == 0.0 From 6e9935c9e26abd0aae5422be9dd6ec4c17913992 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Fri, 21 Jun 2024 15:08:54 -0600 Subject: [PATCH 06/31] added LCA functions to stack.py --- electrolyzer/stack.py | 82 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 78 insertions(+), 4 deletions(-) diff --git a/electrolyzer/stack.py b/electrolyzer/stack.py index 6fef4ac..529c9f7 100644 --- a/electrolyzer/stack.py +++ b/electrolyzer/stack.py @@ -13,6 +13,11 @@ from electrolyzer.type_dec import NDArrayFloat, FromDictMixin, array_converter from electrolyzer.alkaline_cell import AlkalineCell, ael_electrolyzer_model +from scipy.constants import physical_constants + +# Constants # +############# +F, _, _ = physical_constants["Faraday constant"] # Faraday's constant [C/mol] @define class Stack(FromDictMixin): @@ -31,6 +36,8 @@ class Stack(FromDictMixin): # If degradation results in hydrogen losses, hydrogen_degradation_penalty = True # If degradation results in more power consumed, hydrogen_degradation_penalty = False hydrogen_degradation_penalty: bool = field(default=True) + d_eol: float = field(init=False) + max_current: float = field(default=1000) # TODO this is a bad default, fix later min_power: float = field(default=None) @@ -74,6 +81,9 @@ class Stack(FromDictMixin): voltage_history: NDArrayFloat = field( init=False, default=[], converter=array_converter ) + degradation_history: NDArrayFloat = field( + init=False, default=[], converter=array_converter + ) # [V] degradation from fluctuating power only d_f: float = field(init=False, default=0) @@ -204,7 +214,7 @@ def run_power_deg_penalty(self,P_in): """ I_stack = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) - V_cell = self.cell.calc_cell_voltage(I, self.temperature) + V_cell = self.cell.calc_cell_voltage(I_stack, self.temperature) return I_stack, V_cell @@ -220,7 +230,7 @@ def run_h2_deg_penalty(self,P_in): I_stack = I_nom/eff_mult return I_stack, V_cell - + def run(self,P_in): self.update_status() if self.hydrogen_degradation_penalty: @@ -278,8 +288,8 @@ def run_stack(self, I_stack,V_cell,P_in): V_cell = 0 self.cell_voltage = V_cell - self.voltage_history = np.append(self.voltage_history, [V]) - + self.voltage_history = np.append(self.voltage_history, [V_cell]) + self.degradation_history = np.append(self.degradation_history,[self.V_degradation]) # check if it is an hour to decide whether to calculate fatigue hourly_temp = self.hourly_counter self.time += self.dt @@ -506,3 +516,67 @@ def calc_electrolysis_efficiency(self, Pdc, mfr): eta_lhv_percent = self.cell.lhv / eta_kWh_per_kg * 100.0 return (eta_kWh_per_kg, eta_hhv_percent, eta_lhv_percent) + + def calc_end_of_life_voltage(self,eol_eff_percent_loss): + """ + eol_eff_percent_loss [%]: efficiency drop that indicates end-of-life (between 1 and 100) + """ + eol_eff_mult = (100+eol_eff_percent_loss)/100 + V_cell_bol = self.cell.calc_cell_voltage(self.max_current, self.temperature) + H2_mfr_bol = self.cell.calc_mass_flow_rate(self.temperature, self.max_current) * self.n_cells + + H2_mfr_eol = H2_mfr_bol/eol_eff_mult + i_eol_no_faradaic_loss=(H2_mfr_eol*1e3*self.cell.n*F)/(1*self.n_cells*self.cell.M*self.dt) + n_f = self.cell.calc_faradaic_efficiency(self.temperature, i_eol_no_faradaic_loss) + i_eol = (H2_mfr_eol*1e3*self.cell.n*F)/(n_f*self.n_cells*self.cell.M*self.dt) + + self.d_eol=((self.max_current*V_cell_bol)/i_eol) - V_cell_bol + # return d_eol + + def estimate_time_until_replacement(self): + + frac_of_life_used = self.V_degradation/self.d_eol + #time between replacement [hrs] based on time its existed (whether on or off) + time_between_replacement = (1/frac_of_life_used)*(self.time/3600) #[hrs] + return time_between_replacement + + def estimate_stack_life(self): + #stack life [hrs] based on time its been operational + frac_of_life_used = self.V_degradation/self.d_eol + stack_life = (1/frac_of_life_used)*(self.uptime/3600) #[hrs] + return stack_life + + def estimate_life_performance_from_year(self,P_in,plant_life_years:int): + refturb_schedule = np.zeros(plant_life_years) + ahp_kg = np.zeros(plant_life_years) + aep_kWh = np.zeros(plant_life_years) + + V_deg = np.array(self.degradation_history) + V_cell_bol = np.array(self.voltage_history) - V_deg + sim_length = len(V_cell_bol) + + Vdeg0 = 0 + for i in range(plant_life_years): + V_deg_pr_sim = Vdeg0 + V_deg + if np.max(V_deg_pr_sim)>self.d_eol: + idx_dead = np.argwhere(V_deg_pr_sim>self.d_eol)[0][0] + V_deg_pr_sim = np.concatenate([V_deg_pr_sim[0:idx_dead],V_deg[idx_dead:sim_length]]) + refturb_schedule[i] = 1 + if self.hydrogen_degradation_penalty: + I_nom = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + V_cell = self.cell.calc_cell_voltage(I_nom, self.temperature) + eff_mult = (V_cell + self.V_degradation)/V_cell #1 + efficiency drop + I_stack = I_nom/eff_mult + + + else: + I_stack = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + V_cell = self.cell.calc_cell_voltage(I_stack, self.temperature) + + + H2_mass_out = self.cell.calc_mass_flow_rate(self.temperature, I_stack) * self.n_cells * self.dt + power_usage_kW = self.calc_stack_power(I_stack, V_cell+V_deg_pr_sim) + ahp_kg[i] = np.sum(H2_mass_out) + aep_kWh[i] = np.sum(power_usage_kW) + Vdeg0 = V_deg_pr_sim[sim_length-1] + return refturb_schedule,ahp_kg,aep_kWh \ No newline at end of file From bacfbc6186b88971a6f069446fa36f7d0df3ee05 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Fri, 21 Jun 2024 15:31:39 -0600 Subject: [PATCH 07/31] added eol_eff_percent_loss as degradation input for stack --- electrolyzer/inputs/modeling_schema.yaml | 7 +++++++ electrolyzer/stack.py | 12 +++++++----- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/electrolyzer/inputs/modeling_schema.yaml b/electrolyzer/inputs/modeling_schema.yaml index a72c076..91ae7af 100644 --- a/electrolyzer/inputs/modeling_schema.yaml +++ b/electrolyzer/inputs/modeling_schema.yaml @@ -139,6 +139,7 @@ properties: degradation: type: object default: + eol_eff_percent_loss: 10 PEM_params: rate_steady: 1.41737929e-10 rate_fatigue: 3.33330244e-07 @@ -149,6 +150,12 @@ properties: rate_onoff: 3.0726072607260716e-04 description: Degradation rates for PEM or alkaline electrolyzer properties: + eol_eff_percent_loss: + type: number + description: End of life efficiency drop + minimum: 5 + default: 10 + maximum: 100 PEM_params: type: object default: diff --git a/electrolyzer/stack.py b/electrolyzer/stack.py index 529c9f7..d7a9fac 100644 --- a/electrolyzer/stack.py +++ b/electrolyzer/stack.py @@ -36,6 +36,7 @@ class Stack(FromDictMixin): # If degradation results in hydrogen losses, hydrogen_degradation_penalty = True # If degradation results in more power consumed, hydrogen_degradation_penalty = False hydrogen_degradation_penalty: bool = field(default=True) + eol_eff_percent_loss: float = field(init=False) d_eol: float = field(init=False) max_current: float = field(default=1000) # TODO this is a bad default, fix later @@ -140,7 +141,7 @@ class Stack(FromDictMixin): def __attrs_post_init__(self) -> None: # Stack parameters # #################### - + self.eol_eff_percent_loss = self.degradation["eol_eff_percent_loss"] if self.cell_type == "PEM": # initialize electrolzyer cell model self.cell = PEMCell.from_dict(self.cell_params["PEM_params"]) @@ -207,6 +208,7 @@ def __attrs_post_init__(self) -> None: # self.h2_pres_out = 31 # H2 outlet pressure (bar) self.DTSS = self.calc_state_space() + self.d_eol = self.calc_end_of_life_voltage() def run_power_deg_penalty(self,P_in): """ @@ -517,11 +519,11 @@ def calc_electrolysis_efficiency(self, Pdc, mfr): return (eta_kWh_per_kg, eta_hhv_percent, eta_lhv_percent) - def calc_end_of_life_voltage(self,eol_eff_percent_loss): + def calc_end_of_life_voltage(self): """ eol_eff_percent_loss [%]: efficiency drop that indicates end-of-life (between 1 and 100) """ - eol_eff_mult = (100+eol_eff_percent_loss)/100 + eol_eff_mult = (100+self.eol_eff_percent_loss)/100 V_cell_bol = self.cell.calc_cell_voltage(self.max_current, self.temperature) H2_mfr_bol = self.cell.calc_mass_flow_rate(self.temperature, self.max_current) * self.n_cells @@ -530,8 +532,8 @@ def calc_end_of_life_voltage(self,eol_eff_percent_loss): n_f = self.cell.calc_faradaic_efficiency(self.temperature, i_eol_no_faradaic_loss) i_eol = (H2_mfr_eol*1e3*self.cell.n*F)/(n_f*self.n_cells*self.cell.M*self.dt) - self.d_eol=((self.max_current*V_cell_bol)/i_eol) - V_cell_bol - # return d_eol + d_eol=((self.max_current*V_cell_bol)/i_eol) - V_cell_bol + return d_eol def estimate_time_until_replacement(self): From c758104aac2e152af80788abec03a6c0a09b06ac Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Fri, 21 Jun 2024 16:12:35 -0600 Subject: [PATCH 08/31] added run_LCA functionto run_electrolyzer script --- electrolyzer/__init__.py | 1 + electrolyzer/glue_code/run_electrolyzer.py | 18 ++++++++++++++++-- 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/electrolyzer/__init__.py b/electrolyzer/__init__.py index 99e43a5..49eab3c 100644 --- a/electrolyzer/__init__.py +++ b/electrolyzer/__init__.py @@ -13,3 +13,4 @@ from .alkaline_cell import AlkalineCell, ael_electrolyzer_model from .glue_code.run_lcoh import run_lcoh from .glue_code.run_electrolyzer import run_electrolyzer +from .glue_code.run_electrolyzer import run_LCA diff --git a/electrolyzer/glue_code/run_electrolyzer.py b/electrolyzer/glue_code/run_electrolyzer.py index ac8df31..e83ede7 100644 --- a/electrolyzer/glue_code/run_electrolyzer.py +++ b/electrolyzer/glue_code/run_electrolyzer.py @@ -71,7 +71,7 @@ def _run_electrolyzer_full(modeling_options, power_signal): } ) stack_dfs.append(stack_df) - + results_df = pd.concat([results_df, *stack_dfs], axis=1) return elec_sys, results_df @@ -104,7 +104,21 @@ def _run_electrolyzer_opt(modeling_options, power_signal): return tot_kg, max_curr_density - +def run_LCA(elec_sys, plant_life_years:int): + sys_refurb = pd.DataFrame() + sys_aep = pd.DataFrame() + sys_ah2 = pd.DataFrame() + years = list(np.arange(0,plant_life_years,1)) + for i, stack in enumerate(elec_sys.stacks): + id = i + 1 + refturb_schedule,ahp_kg,aep_kWh = stack.estimate_life_performance_from_year(plant_life_years) + sys_refurb = pd.concat([sys_aep,pd.DataFrame(dict(zip(["Stack {}".format(id)],[aep_kWh])),index=years)]) + sys_ah2 = pd.concat([sys_ah2,pd.DataFrame(dict(zip(["Stack {}".format(id)],[ahp_kg])),index=years)]) + sys_refurb = pd.concat([sys_refurb,pd.DataFrame(dict(zip(["Stack {}".format(id)],[refturb_schedule])),index=years)]) + # df_index = [[f"stack {id}"]*plant_life_years,list(np.arange(0,plant_life_years,1))] + # temp_df = pd.DataFrame(dict(zip(["AEP [kWh/year]","Refurb Schedule","AHP [kg/year]"],[aep_kWh,ahp_kg,refturb_schedule])),index=df_index) + # stack_LCA = pd.concat([stack_LCA,temp_df]) + return {"Refurb Schedule":sys_refurb,"AEP [kWh/year]":sys_aep,"AHP [kg/year]":sys_ah2} def run_electrolyzer(input_modeling, power_signal, optimize=False): """ Runs an electrolyzer simulation based on a YAML configuration file and power From 663700afc7b30cee4333271bea482c1061d84fe3 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Fri, 21 Jun 2024 16:13:10 -0600 Subject: [PATCH 09/31] added more tracking variables to stack --- electrolyzer/stack.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/electrolyzer/stack.py b/electrolyzer/stack.py index d7a9fac..110c734 100644 --- a/electrolyzer/stack.py +++ b/electrolyzer/stack.py @@ -85,6 +85,9 @@ class Stack(FromDictMixin): degradation_history: NDArrayFloat = field( init=False, default=[], converter=array_converter ) + power_input_history: NDArrayFloat = field( + init=False, default=[], converter=array_converter + ) # [V] degradation from fluctuating power only d_f: float = field(init=False, default=0) @@ -228,8 +231,8 @@ def run_h2_deg_penalty(self,P_in): I_nom = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) V_cell = self.cell.calc_cell_voltage(I_nom, self.temperature) - eff_mult = (V_cell + self.V_degradation)/V_cell #1 + efficiency drop - I_stack = I_nom/eff_mult + eff_mult = np.nan_to_num((V_cell + self.V_degradation)/V_cell) #1 + efficiency drop + I_stack = np.nan_to_num(I_nom/eff_mult) return I_stack, V_cell @@ -292,6 +295,7 @@ def run_stack(self, I_stack,V_cell,P_in): self.cell_voltage = V_cell self.voltage_history = np.append(self.voltage_history, [V_cell]) self.degradation_history = np.append(self.degradation_history,[self.V_degradation]) + self.power_input_history = np.append(self.power_input_history,[P_in]) # check if it is an hour to decide whether to calculate fatigue hourly_temp = self.hourly_counter self.time += self.dt @@ -548,7 +552,7 @@ def estimate_stack_life(self): stack_life = (1/frac_of_life_used)*(self.uptime/3600) #[hrs] return stack_life - def estimate_life_performance_from_year(self,P_in,plant_life_years:int): + def estimate_life_performance_from_year(self,plant_life_years:int): refturb_schedule = np.zeros(plant_life_years) ahp_kg = np.zeros(plant_life_years) aep_kWh = np.zeros(plant_life_years) @@ -565,14 +569,14 @@ def estimate_life_performance_from_year(self,P_in,plant_life_years:int): V_deg_pr_sim = np.concatenate([V_deg_pr_sim[0:idx_dead],V_deg[idx_dead:sim_length]]) refturb_schedule[i] = 1 if self.hydrogen_degradation_penalty: - I_nom = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + I_nom = self.electrolyzer_model((self.power_input_history / 1e3, self.temperature), *self.fit_params) V_cell = self.cell.calc_cell_voltage(I_nom, self.temperature) eff_mult = (V_cell + self.V_degradation)/V_cell #1 + efficiency drop I_stack = I_nom/eff_mult else: - I_stack = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) + I_stack = self.electrolyzer_model((self.power_input_history / 1e3, self.temperature), *self.fit_params) V_cell = self.cell.calc_cell_voltage(I_stack, self.temperature) From 27053270542b5cce4381915486eee3c7d2bc2199 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 13:03:19 -0700 Subject: [PATCH 10/31] updated all py file import paths --- electrolyzer/__init__.py | 7 ------- electrolyzer/simulation/bert.py | 6 +++--- electrolyzer/simulation/cell_models/alkaline.py | 2 +- electrolyzer/simulation/cell_models/pem.py | 2 +- electrolyzer/simulation/stack.py | 6 +++--- electrolyzer/simulation/supervisor.py | 4 ++-- electrolyzer/tools/analysis/lcoh.py | 2 +- electrolyzer/tools/analysis/run_lcoh.py | 9 +++++---- electrolyzer/tools/design/optimization.py | 2 +- examples/controller_test_draft.py | 2 +- examples/example_01_polarization/example_run.py | 4 ++-- examples/example_02_electrolyzer/example_run.py | 2 +- examples/example_04_lcoh/cost_example_run.py | 2 +- .../example_05_controller_options.py | 4 ++-- examples/example_06_alkaline/alkaline_example_run.py | 2 +- requirements.txt | 3 +++ tests/glue_code/test_optimization.py | 4 ++-- tests/glue_code/test_run_electrolyzer.py | 10 +++++----- tests/glue_code/test_run_lcoh.py | 4 ++-- tests/inputs/test_validation.py | 2 +- tests/test_PEM_cell.py | 2 +- tests/test_cell.py | 2 +- tests/test_stack.py | 4 ++-- tests/test_type_dec.py | 2 +- 24 files changed, 43 insertions(+), 46 deletions(-) diff --git a/electrolyzer/__init__.py b/electrolyzer/__init__.py index 99e43a5..5607a09 100644 --- a/electrolyzer/__init__.py +++ b/electrolyzer/__init__.py @@ -6,10 +6,3 @@ # noqa -from .lcoh import LCOH -from .stack import Stack -from .PEM_cell import PEMCell, PEM_electrolyzer_model -from .supervisor import Supervisor -from .alkaline_cell import AlkalineCell, ael_electrolyzer_model -from .glue_code.run_lcoh import run_lcoh -from .glue_code.run_electrolyzer import run_electrolyzer diff --git a/electrolyzer/simulation/bert.py b/electrolyzer/simulation/bert.py index ac8df31..bc71e34 100644 --- a/electrolyzer/simulation/bert.py +++ b/electrolyzer/simulation/bert.py @@ -6,9 +6,9 @@ import numpy as np import pandas as pd -import electrolyzer.inputs.validation as val -from electrolyzer import Supervisor -from electrolyzer.glue_code.optimization import calc_rated_system +import electrolyzer.tools.validation as val +from electrolyzer.simulation.supervisor import Supervisor +from electrolyzer.tools.design.optimization import calc_rated_system def _run_electrolyzer_full(modeling_options, power_signal): diff --git a/electrolyzer/simulation/cell_models/alkaline.py b/electrolyzer/simulation/cell_models/alkaline.py index 4b37c3e..a16c6ef 100644 --- a/electrolyzer/simulation/cell_models/alkaline.py +++ b/electrolyzer/simulation/cell_models/alkaline.py @@ -14,7 +14,7 @@ from attrs import field, define from scipy.constants import R, physical_constants, convert_temperature -from electrolyzer.type_dec import FromDictMixin +from electrolyzer.tools.type_dec import FromDictMixin warnings.filterwarnings("ignore") diff --git a/electrolyzer/simulation/cell_models/pem.py b/electrolyzer/simulation/cell_models/pem.py index a43a041..8ea8407 100644 --- a/electrolyzer/simulation/cell_models/pem.py +++ b/electrolyzer/simulation/cell_models/pem.py @@ -12,7 +12,7 @@ from attrs import define from scipy.constants import R, physical_constants, convert_temperature -from electrolyzer.type_dec import FromDictMixin +from electrolyzer.tools.type_dec import FromDictMixin def PEM_electrolyzer_model(X, a, b, c, d, e, f): diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index 1c379ee..c5f9b2b 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -9,9 +9,9 @@ from attrs import field, define from scipy.signal import tf2ss, cont2discrete -from electrolyzer.PEM_cell import PEMCell, PEM_electrolyzer_model -from electrolyzer.type_dec import NDArrayFloat, FromDictMixin, array_converter -from electrolyzer.alkaline_cell import AlkalineCell, ael_electrolyzer_model +from electrolyzer.simulation.cell_models.pem import PEMCell, PEM_electrolyzer_model +from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin, array_converter +from electrolyzer.simulation.cell_models.alkaline import AlkalineCell, ael_electrolyzer_model @define diff --git a/electrolyzer/simulation/supervisor.py b/electrolyzer/simulation/supervisor.py index 3ca8745..cd95668 100644 --- a/electrolyzer/simulation/supervisor.py +++ b/electrolyzer/simulation/supervisor.py @@ -6,8 +6,8 @@ import numpy.typing as npt from attrs import field, define -from electrolyzer.stack import Stack -from electrolyzer.type_dec import NDArrayInt, NDArrayFloat, FromDictMixin +from electrolyzer.simulation.stack import Stack +from electrolyzer.tools.type_dec import NDArrayInt, NDArrayFloat, FromDictMixin @define diff --git a/electrolyzer/tools/analysis/lcoh.py b/electrolyzer/tools/analysis/lcoh.py index 8dec798..2b308f8 100644 --- a/electrolyzer/tools/analysis/lcoh.py +++ b/electrolyzer/tools/analysis/lcoh.py @@ -6,7 +6,7 @@ import pandas as pd from attrs import field, define -from electrolyzer.type_dec import NDArrayFloat, FromDictMixin +from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin @define diff --git a/electrolyzer/tools/analysis/run_lcoh.py b/electrolyzer/tools/analysis/run_lcoh.py index 2210a05..43c7b65 100644 --- a/electrolyzer/tools/analysis/run_lcoh.py +++ b/electrolyzer/tools/analysis/run_lcoh.py @@ -6,10 +6,11 @@ import numpy as np import pandas as pd -import electrolyzer.inputs.validation as val -from electrolyzer import LCOH, Supervisor # ESG -from electrolyzer.glue_code.optimization import calc_rated_system -from electrolyzer.glue_code.run_electrolyzer import _run_electrolyzer_full +import electrolyzer.tools.validation as val +from electrolyzer.simulation.supervisor import Supervisor # ESG +from electrolyzer.tools.design.optimization import calc_rated_system +from electrolyzer.simulation.bert import _run_electrolyzer_full +from electrolyzer.tools.analysis.lcoh import LCOH def _run_electrolyzer_lcoh_opt(modeling_options, power_signal): diff --git a/electrolyzer/tools/design/optimization.py b/electrolyzer/tools/design/optimization.py index b294f78..a677740 100644 --- a/electrolyzer/tools/design/optimization.py +++ b/electrolyzer/tools/design/optimization.py @@ -2,7 +2,7 @@ from scipy.optimize import fsolve -from electrolyzer import Stack +from electrolyzer.simulation.stack import Stack def calc_rated_system(modeling_options: dict): diff --git a/examples/controller_test_draft.py b/examples/controller_test_draft.py index 95f0083..265a204 100644 --- a/examples/controller_test_draft.py +++ b/examples/controller_test_draft.py @@ -2,7 +2,7 @@ import numpy as np -from electrolyzer import Supervisor +from electrolyzer.simulation.supervisor import Supervisor # import matplotlib.pyplot as plt diff --git a/examples/example_01_polarization/example_run.py b/examples/example_01_polarization/example_run.py index e586b18..1c018ec 100644 --- a/examples/example_01_polarization/example_run.py +++ b/examples/example_01_polarization/example_run.py @@ -5,8 +5,8 @@ import numpy as np import matplotlib.pyplot as plt -from electrolyzer import Stack -from electrolyzer.PEM_cell import PEM_electrolyzer_model as electrolyzer_model +from electrolyzer.simulation.stack import Stack +from electrolyzer.simulation.cell_models.pem import PEM_electrolyzer_model as electrolyzer_model stack_dict = { diff --git a/examples/example_02_electrolyzer/example_run.py b/examples/example_02_electrolyzer/example_run.py index f1e789d..bbdc823 100644 --- a/examples/example_02_electrolyzer/example_run.py +++ b/examples/example_02_electrolyzer/example_run.py @@ -7,7 +7,7 @@ import numpy as np -from electrolyzer import run_electrolyzer +from electrolyzer.simulation.bert import run_electrolyzer fname_input_modeling = os.path.join( diff --git a/examples/example_04_lcoh/cost_example_run.py b/examples/example_04_lcoh/cost_example_run.py index c606549..be483a7 100644 --- a/examples/example_04_lcoh/cost_example_run.py +++ b/examples/example_04_lcoh/cost_example_run.py @@ -6,7 +6,7 @@ import numpy as np -from electrolyzer import run_lcoh +from electrolyzer.tools.analysis.run_lcoh import run_lcoh fname_input_modeling = os.path.join( diff --git a/examples/example_05_controller/example_05_controller_options.py b/examples/example_05_controller/example_05_controller_options.py index 03ab97c..ba6a420 100644 --- a/examples/example_05_controller/example_05_controller_options.py +++ b/examples/example_05_controller/example_05_controller_options.py @@ -4,8 +4,8 @@ import numpy as np import matplotlib.pyplot as plt -from electrolyzer import run_electrolyzer -from electrolyzer.inputs.validation import load_modeling_yaml +from electrolyzer.simulation.bert import run_electrolyzer +from electrolyzer.tools.validation import load_modeling_yaml # Generate a power signal to illustrate Supervisor behavior diff --git a/examples/example_06_alkaline/alkaline_example_run.py b/examples/example_06_alkaline/alkaline_example_run.py index 3c51ac5..eedff49 100644 --- a/examples/example_06_alkaline/alkaline_example_run.py +++ b/examples/example_06_alkaline/alkaline_example_run.py @@ -8,7 +8,7 @@ import numpy as np # from electrolyzer import run_alkaline as run_electrolyzer -from electrolyzer import run_electrolyzer +from electrolyzer.simulation.bert import run_electrolyzer # the alkaline system is 20 5 kW stacks for an overall system rating of 1 MW diff --git a/requirements.txt b/requirements.txt index cf1ca82..9904cb3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -14,3 +14,6 @@ ruamel.yaml pytest pytest_mock pre-commit + +# Examples +ipykernel diff --git a/tests/glue_code/test_optimization.py b/tests/glue_code/test_optimization.py index bcb7b7f..f662efc 100644 --- a/tests/glue_code/test_optimization.py +++ b/tests/glue_code/test_optimization.py @@ -2,8 +2,8 @@ from numpy.testing import assert_almost_equal -from electrolyzer.inputs import validation as val -from electrolyzer.glue_code.optimization import calc_rated_stack, calc_rated_system +import electrolyzer.tools.validation as val +from electrolyzer.tools.design.optimization import calc_rated_stack, calc_rated_system input_modeling = "./test_modeling_options.yaml" diff --git a/tests/glue_code/test_run_electrolyzer.py b/tests/glue_code/test_run_electrolyzer.py index 7caeebc..18743d9 100644 --- a/tests/glue_code/test_run_electrolyzer.py +++ b/tests/glue_code/test_run_electrolyzer.py @@ -10,11 +10,11 @@ assert_array_almost_equal, ) -import electrolyzer.inputs.validation as val -from electrolyzer import Supervisor, run_electrolyzer -from electrolyzer.inputs.validation import load_modeling_yaml -from electrolyzer.glue_code.optimization import calc_rated_system - +import electrolyzer.tools.validation as val +from electrolyzer.simulation.supervisor import Supervisor +from electrolyzer.simulation.bert import run_electrolyzer +from electrolyzer.tools.validation import load_modeling_yaml +from electrolyzer.tools.design.optimization import calc_rated_system turbine_rating = 3.4 # MW diff --git a/tests/glue_code/test_run_lcoh.py b/tests/glue_code/test_run_lcoh.py index f5f3dda..c4970af 100644 --- a/tests/glue_code/test_run_lcoh.py +++ b/tests/glue_code/test_run_lcoh.py @@ -5,8 +5,8 @@ import pandas as pd from numpy.testing import assert_array_almost_equal from pandas.testing import assert_frame_equal - -from electrolyzer import run_lcoh, run_electrolyzer +from electrolyzer.simulation.bert import run_electrolyzer +from electrolyzer.tools.analysis.run_lcoh import run_lcoh lcoh_breakdown = pd.DataFrame( diff --git a/tests/inputs/test_validation.py b/tests/inputs/test_validation.py index 8810416..85c7e5f 100644 --- a/tests/inputs/test_validation.py +++ b/tests/inputs/test_validation.py @@ -3,7 +3,7 @@ import pytest from jsonschema.exceptions import ValidationError -from electrolyzer.inputs.validation import load_modeling_yaml +from electrolyzer.tools.validation import load_modeling_yaml def test_basic_model(): diff --git a/tests/test_PEM_cell.py b/tests/test_PEM_cell.py index 0270bf0..53491bc 100644 --- a/tests/test_PEM_cell.py +++ b/tests/test_PEM_cell.py @@ -2,7 +2,7 @@ import pytest -from electrolyzer import PEMCell +from electrolyzer.simulation.cell_models.pem import PEMCell as Cell # from numpy.testing import assert_almost_equal diff --git a/tests/test_cell.py b/tests/test_cell.py index b66ce89..e504631 100644 --- a/tests/test_cell.py +++ b/tests/test_cell.py @@ -3,7 +3,7 @@ import pytest from numpy.testing import assert_almost_equal -from electrolyzer import PEMCell as Cell +from electrolyzer.simulation.cell_models.pem import PEMCell as Cell @pytest.fixture diff --git a/tests/test_stack.py b/tests/test_stack.py index c53dfe5..ee57b17 100644 --- a/tests/test_stack.py +++ b/tests/test_stack.py @@ -4,8 +4,8 @@ import pytest from numpy.testing import assert_array_equal, assert_array_almost_equal -from electrolyzer import Stack, PEMCell - +from electrolyzer.simulation.stack import Stack +from electrolyzer.simulation.cell_models.pem import PEMCell def create_stack(): stack_dict = { diff --git a/tests/test_type_dec.py b/tests/test_type_dec.py index fe8edd1..be0271e 100644 --- a/tests/test_type_dec.py +++ b/tests/test_type_dec.py @@ -4,7 +4,7 @@ import pytest from attrs import field, define -from electrolyzer.type_dec import FromDictMixin, iter_validator, array_converter +from electrolyzer.tools.type_dec import FromDictMixin, iter_validator, array_converter @define From 27606eea362ffd660158edba25f2eef32425c125 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 13:03:59 -0700 Subject: [PATCH 11/31] updated jupyter notebook import paths --- .../example_02_electrolyzer/example_run.ipynb | 219 +++++++++--------- .../optimization.ipynb | 53 ++--- .../example_05_controller_options.ipynb | 5 +- .../example_run.ipynb | 4 +- 4 files changed, 139 insertions(+), 142 deletions(-) diff --git a/examples/example_02_electrolyzer/example_run.ipynb b/examples/example_02_electrolyzer/example_run.ipynb index 33599cc..06c00d7 100644 --- a/examples/example_02_electrolyzer/example_run.ipynb +++ b/examples/example_02_electrolyzer/example_run.ipynb @@ -19,13 +19,13 @@ "source": [ "import numpy as np\n", "\n", - "from electrolyzer import run_electrolyzer\n", - "from electrolyzer.inputs.validation import load_modeling_yaml" + "from electrolyzer.simulation.bert import run_electrolyzer\n", + "from electrolyzer.tools.validation import load_modeling_yaml" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "e79a3fbd", "metadata": {}, "outputs": [], @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "29b6596a", "metadata": {}, "outputs": [], @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "4b536aa0", "metadata": {}, "outputs": [ @@ -67,8 +67,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: total: 27.9 s\n", - "Wall time: 31.1 s\n" + "CPU times: user 9.02 s, sys: 53.5 ms, total: 9.08 s\n", + "Wall time: 8.81 s\n" ] } ], @@ -88,17 +88,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "352eca62", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "electrolyzer.supervisor.Supervisor" + "electrolyzer.simulation.supervisor.Supervisor" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -109,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "2fadbc43", "metadata": {}, "outputs": [ @@ -162,121 +162,121 @@ " 28805\n", " 3.399991e+06\n", " 0.0\n", - " 0.0139\n", + " 0.01431\n", " 0.00001\n", - " 6.967001e-07\n", + " 5.721524e-07\n", " 0.0\n", " 28806.0\n", - " 0.002031\n", - " 2.08729\n", - " 0.00001\n", + " 0.002093\n", + " 2.151003\n", + " 0.000009\n", " ...\n", " 0.0\n", " 28801.0\n", - " 0.002031\n", - " 2.08729\n", + " 0.002093\n", + " 2.151003\n", " 0.000008\n", - " 7.114274e-07\n", + " 5.895674e-07\n", " 0.0\n", " 28800.0\n", - " 0.001717\n", - " 1.764666\n", + " 0.001754\n", + " 1.803205\n", " \n", " \n", " 28806\n", " 3.399995e+06\n", " 0.0\n", - " 0.0139\n", + " 0.01431\n", " 0.00001\n", - " 6.967001e-07\n", + " 5.721524e-07\n", " 0.0\n", " 28807.0\n", - " 0.002031\n", - " 2.08729\n", - " 0.00001\n", + " 0.002093\n", + " 2.151003\n", + " 0.000009\n", " ...\n", " 0.0\n", " 28802.0\n", - " 0.002031\n", - " 2.08729\n", + " 0.002093\n", + " 2.151003\n", " 0.000008\n", - " 7.114274e-07\n", + " 5.895674e-07\n", " 0.0\n", " 28801.0\n", - " 0.001717\n", - " 1.764680\n", + " 0.001754\n", + " 1.803220\n", " \n", " \n", " 28807\n", " 3.399998e+06\n", " 0.0\n", - " 0.0139\n", + " 0.01431\n", " 0.00001\n", - " 6.967001e-07\n", + " 5.721524e-07\n", " 0.0\n", " 28808.0\n", - " 0.002031\n", - " 2.08729\n", - " 0.00001\n", + " 0.002093\n", + " 2.151003\n", + " 0.000009\n", " ...\n", " 0.0\n", " 28803.0\n", - " 0.002031\n", - " 2.08729\n", + " 0.002093\n", + " 2.151003\n", " 0.000008\n", - " 7.114274e-07\n", + " 5.895674e-07\n", " 0.0\n", " 28802.0\n", - " 0.001717\n", - " 1.764690\n", + " 0.001754\n", + " 1.803230\n", " \n", " \n", " 28808\n", " 3.399999e+06\n", " 0.0\n", - " 0.0139\n", + " 0.01431\n", " 0.00001\n", - " 6.967001e-07\n", + " 5.721524e-07\n", " 0.0\n", " 28809.0\n", - " 0.002031\n", - " 2.08729\n", - " 0.00001\n", + " 0.002093\n", + " 2.151003\n", + " 0.000009\n", " ...\n", " 0.0\n", " 28804.0\n", - " 0.002031\n", - " 2.08729\n", + " 0.002093\n", + " 2.151003\n", " 0.000008\n", - " 7.114274e-07\n", + " 5.895674e-07\n", " 0.0\n", " 28803.0\n", - " 0.001717\n", - " 1.764696\n", + " 0.001754\n", + " 1.803237\n", " \n", " \n", " 28809\n", " 3.400000e+06\n", " 0.0\n", - " 0.0139\n", + " 0.01431\n", " 0.00001\n", - " 6.967001e-07\n", + " 5.721524e-07\n", " 0.0\n", " 28810.0\n", - " 0.002031\n", - " 2.08729\n", - " 0.00001\n", + " 0.002093\n", + " 2.151003\n", + " 0.000009\n", " ...\n", " 0.0\n", " 28805.0\n", - " 0.002031\n", - " 2.08729\n", + " 0.002093\n", + " 2.151003\n", " 0.000008\n", - " 7.114274e-07\n", + " 5.895674e-07\n", " 0.0\n", " 28804.0\n", - " 0.001717\n", - " 1.764698\n", + " 0.001754\n", + " 1.803239\n", " \n", " \n", "\n", @@ -285,44 +285,44 @@ ], "text/plain": [ " power_signal curtailment kg_rate stack_1_deg stack_1_fatigue \\\n", - "28805 3.399991e+06 0.0 0.0139 0.00001 6.967001e-07 \n", - "28806 3.399995e+06 0.0 0.0139 0.00001 6.967001e-07 \n", - "28807 3.399998e+06 0.0 0.0139 0.00001 6.967001e-07 \n", - "28808 3.399999e+06 0.0 0.0139 0.00001 6.967001e-07 \n", - "28809 3.400000e+06 0.0 0.0139 0.00001 6.967001e-07 \n", + "28805 3.399991e+06 0.0 0.01431 0.00001 5.721524e-07 \n", + "28806 3.399995e+06 0.0 0.01431 0.00001 5.721524e-07 \n", + "28807 3.399998e+06 0.0 0.01431 0.00001 5.721524e-07 \n", + "28808 3.399999e+06 0.0 0.01431 0.00001 5.721524e-07 \n", + "28809 3.400000e+06 0.0 0.01431 0.00001 5.721524e-07 \n", "\n", " stack_1_cycles stack_1_uptime stack_1_kg_rate stack_1_curr_density \\\n", - "28805 0.0 28806.0 0.002031 2.08729 \n", - "28806 0.0 28807.0 0.002031 2.08729 \n", - "28807 0.0 28808.0 0.002031 2.08729 \n", - "28808 0.0 28809.0 0.002031 2.08729 \n", - "28809 0.0 28810.0 0.002031 2.08729 \n", + "28805 0.0 28806.0 0.002093 2.151003 \n", + "28806 0.0 28807.0 0.002093 2.151003 \n", + "28807 0.0 28808.0 0.002093 2.151003 \n", + "28808 0.0 28809.0 0.002093 2.151003 \n", + "28809 0.0 28810.0 0.002093 2.151003 \n", "\n", " stack_2_deg ... stack_6_cycles stack_6_uptime stack_6_kg_rate \\\n", - "28805 0.00001 ... 0.0 28801.0 0.002031 \n", - "28806 0.00001 ... 0.0 28802.0 0.002031 \n", - "28807 0.00001 ... 0.0 28803.0 0.002031 \n", - "28808 0.00001 ... 0.0 28804.0 0.002031 \n", - "28809 0.00001 ... 0.0 28805.0 0.002031 \n", + "28805 0.000009 ... 0.0 28801.0 0.002093 \n", + "28806 0.000009 ... 0.0 28802.0 0.002093 \n", + "28807 0.000009 ... 0.0 28803.0 0.002093 \n", + "28808 0.000009 ... 0.0 28804.0 0.002093 \n", + "28809 0.000009 ... 0.0 28805.0 0.002093 \n", "\n", " stack_6_curr_density stack_7_deg stack_7_fatigue stack_7_cycles \\\n", - "28805 2.08729 0.000008 7.114274e-07 0.0 \n", - "28806 2.08729 0.000008 7.114274e-07 0.0 \n", - "28807 2.08729 0.000008 7.114274e-07 0.0 \n", - "28808 2.08729 0.000008 7.114274e-07 0.0 \n", - "28809 2.08729 0.000008 7.114274e-07 0.0 \n", + "28805 2.151003 0.000008 5.895674e-07 0.0 \n", + "28806 2.151003 0.000008 5.895674e-07 0.0 \n", + "28807 2.151003 0.000008 5.895674e-07 0.0 \n", + "28808 2.151003 0.000008 5.895674e-07 0.0 \n", + "28809 2.151003 0.000008 5.895674e-07 0.0 \n", "\n", " stack_7_uptime stack_7_kg_rate stack_7_curr_density \n", - "28805 28800.0 0.001717 1.764666 \n", - "28806 28801.0 0.001717 1.764680 \n", - "28807 28802.0 0.001717 1.764690 \n", - "28808 28803.0 0.001717 1.764696 \n", - "28809 28804.0 0.001717 1.764698 \n", + "28805 28800.0 0.001754 1.803205 \n", + "28806 28801.0 0.001754 1.803220 \n", + "28807 28802.0 0.001754 1.803230 \n", + "28808 28803.0 0.001754 1.803237 \n", + "28809 28804.0 0.001754 1.803239 \n", "\n", "[5 rows x 45 columns]" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -590,23 +590,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "id": "2c64a4b5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -652,23 +652,23 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "id": "311f94c4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -717,17 +717,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "id": "173da9bc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "222.8930364856318" + "np.float64(228.07491340249447)" ] }, - "execution_count": 15, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -739,23 +739,23 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "id": "fc748735", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -771,17 +771,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "id": "89d3dd21", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "2.0872897857473425" + "np.float64(2.1510028292512295)" ] }, - "execution_count": 17, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -793,7 +793,7 @@ ], "metadata": { "kernelspec": { - "display_name": "electrolyzer", + "display_name": "Python 3.11.11 ('bert')", "language": "python", "name": "python3" }, @@ -807,7 +807,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.11.11" + }, + "vscode": { + "interpreter": { + "hash": "a0dac1f70fdc281b4d1c97050cac2e7deb2e5a93625d03e31dc0baefa4755e69" + } } }, "nbformat": 4, diff --git a/examples/example_03_optimization/optimization.ipynb b/examples/example_03_optimization/optimization.ipynb index fb08323..02e1fe7 100644 --- a/examples/example_03_optimization/optimization.ipynb +++ b/examples/example_03_optimization/optimization.ipynb @@ -30,9 +30,10 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "from electrolyzer import run_electrolyzer, run_lcoh\n", - "from electrolyzer.inputs import validation as val\n", - "from electrolyzer.glue_code.optimization import calc_rated_system" + "from electrolyzer.simulation.bert import run_electrolyzer\n", + "from electrolyzer.tools.analysis.run_lcoh import run_lcoh\n", + "import electrolyzer.tools.validation as val\n", + "from electrolyzer.tools.design.optimization import calc_rated_system" ] }, { @@ -181,7 +182,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAM4CAYAAACX1HU0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACzcUlEQVR4nOzde1zUVf4/8NcAw3ARBgG5jFxEwyteUNQkE00FL2Su7WqZt3RNMy+kVrpWXtZEbddsU9Nc011v9G3VVnf9WXgJdfEWCIIYaqGAgJjADCh3zu8P4pPjoILMDXg9H495bHM+Z87nPXMy33ven8/5yIQQAkRERERkVixMHQARERER6WKSRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJG1Izt2LEDMpkMMpkM33//vc5xIQSeeeYZyGQyDBw4UK/nlslkWLZsWb0/d+PGDchkMuzYsaNO/W/fvo1Fixaha9euaNGiBWxsbODv74958+bh2rVr9T5/feTl5eGVV16Bm5sbZDIZRo8eDeDpv7uxZWVlYdmyZUhISNA5tmzZMshkMuMHRdSMWJk6ACIyPQcHB2zbtk0nEYuJicFPP/0EBwcH0wTWQOfPn0d4eDiEEJg9ezb69esHa2trpKamYteuXejTpw/y8/MNdv4///nPOHDgAL788ku0a9cOzs7OAIAzZ87Ay8vLYOfVl6ysLCxfvhxt2rRBjx49tI798Y9/xLBhw0wTGFEzwSSNiDBu3Djs3r0bGzduhKOjo9S+bds29OvXDxqNxoTRPR2NRoOXXnoJNjY2iI2N1UqKBg4ciBkzZuBf//qXQWNITk5Gu3bt8Nprr2m1P/vsswY976MUFxfDxsZGLytgXl5ejSLRJGrMWO4kIrz66qsAgL1790ptarUa+/btw9SpU2v9TF5eHmbNmoXWrVvD2toabdu2xZIlS1BaWqrVT6PRYPr06XBxcUGLFi0wbNgwXL16tdYxr127hvHjx8PNzQ0KhQKdOnXCxo0bn+o7bd26FTk5OVi7du0jk4nf//73Wu8PHjyIfv36wc7ODg4ODhg6dCjOnDmj1aemzHf58mW8+uqrUCqVcHd3x9SpU6FWqwH8VpI9evQorly5olNSrq3cefr0afTr1w82NjZo3bo1PvjgA/z973+HTCbDjRs3pH6PKpW2adMGU6ZMkd7XlLK/++47TJ06Fa1atYKdnR1KS0tx/fp1vP766/D394ednR1at26NF198EUlJSdLnv//+e/Tu3RsA8Prrr0vfoebctZU7q6qqsHbtWnTs2BEKhQJubm6YNGkSMjMztfoNHDgQAQEBuHDhAp5//nnY2dmhbdu2WL16NaqqqrTGW7lyJTp06ABbW1s4OTmhW7du+PTTT3W+P1FTxCSNiODo6Ijf//73+PLLL6W2vXv3wsLCAuPGjdPpX1JSgkGDBuGf//wn5s+fj//+97+YMGEC1q5dizFjxkj9hBAYPXo0du7ciQULFuDAgQN49tlnMXz4cJ0xU1JS0Lt3byQnJ+Ovf/0r/vOf/2DkyJGYO3culi9fXu/v9N1338HS0hIvvvhinfrv2bMHL730EhwdHbF3715s27YN+fn5GDhwIE6fPq3T/+WXX0b79u2xb98+LFq0CHv27MHbb78NAPD09MSZM2cQGBiItm3b4syZMzhz5gx69uxZ67kvXbqEoUOH4v79+/jHP/6BzZs3Iz4+Hh999FG9v/fDpk6dCrlcjp07d+Jf//oX5HI5srKy4OLigtWrV+PIkSPYuHEjrKys0LdvX6SmpgIAevbsie3btwMA3n//fek7/PGPf3zkud5880289957GDp0KA4ePIg///nPOHLkCIKDg/HLL79o9c3JycFrr72GCRMm4ODBgxg+fDgWL16MXbt2SX3Wrl2LZcuW4dVXX8V///tffPXVV5g2bRoKCgoa/LsQNQqCiJqt7du3CwDiwoUL4sSJEwKASE5OFkII0bt3bzFlyhQhhBBdunQRISEh0uc2b94sAIj/+7//0xpvzZo1AoD47rvvhBBC/L//9/8EAPHpp59q9fvoo48EALF06VKpLSwsTHh5eQm1Wq3Vd/bs2cLGxkbk5eUJIYRIS0sTAMT27dsf+906duwoPDw86vQ7VFZWCpVKJbp27SoqKyul9sLCQuHm5iaCg4OltqVLlwoAYu3atVpjzJo1S9jY2IiqqiqpLSQkRHTp0kXnfA9/9z/84Q/C3t5e3LlzRyumzp07CwAiLS3tkZ+t4evrKyZPniy9r5nbSZMmPfH7V1RUiLKyMuHv7y/efvttqf3ChQuP/K1rfocaV65cEQDErFmztPqdO3dOABB/+tOfpLaQkBABQJw7d06rb+fOnUVYWJj0Pjw8XPTo0eOJ8RM1VVxJIyIAQEhICNq1a4cvv/wSSUlJuHDhwiNLncePH4e9vb1OubCm3Hbs2DEAwIkTJwBA55qs8ePHa70vKSnBsWPH8Lvf/Q52dnaoqKiQXiNGjEBJSQnOnj2rj69Zq9TUVGRlZWHixImwsPjtP4stWrTAyy+/jLNnz+L+/ftanxk1apTW+27duqGkpAS5ubn1Pn9MTAxeeOEFuLq6Sm0WFhYYO3Zsvcd62Msvv6zTVlFRgVWrVqFz586wtraGlZUVrK2tce3aNVy5cuWpzlMz1w+WXAGgT58+6NSpk/TvRA0PDw/06dNHq61bt264efOm1mcTExMxa9YsfPvtt43y2kiihmCSRkQAqq91ev3117Fr1y5s3rwZ7du3x/PPP19r37t378LDw0PnmiQ3NzdYWVnh7t27Uj8rKyu4uLho9fPw8NAZr6KiAp999hnkcrnWa8SIEQCgUy57Eh8fH9y5cwf37t17Yt+aeD09PXWOqVQqVFVV6dwF+vB3UigUAKovzq+vu3fvwt3dXae9trb6qu07zZ8/Hx988AFGjx6NQ4cO4dy5c7hw4QK6d+/+VPEDT/4Na47XePj3A6p/wwfPv3jxYvzlL3/B2bNnMXz4cLi4uGDw4MH44YcfnipGosaGSRoRSaZMmYJffvkFmzdvxuuvv/7Ifi4uLrh9+zaEEFrtubm5qKiokFaEXFxcUFFRofMXdE5Ojtb7li1bwtLSElOmTMGFCxdqfdUka3UVFhaGyspKHDp06Il9axKG7OxsnWNZWVmwsLBAy5Yt63X++qj5PR/28O8EVCcyD9+cAUDnN65R252cu3btwqRJk7Bq1SqEhYWhT58+CAoKqnci/KAn/YYPrhLWlZWVFebPn4/4+Hjk5eVh7969yMjIQFhYmM7KJlFTxCSNiCStW7fGO++8gxdffBGTJ09+ZL/BgwejqKgI33zzjVb7P//5T+k4AAwaNAgAsHv3bq1+e/bs0XpvZ2eHQYMG4eLFi+jWrRuCgoJ0XrWtvDzOtGnT4OHhgXfffRe3bt2qtc/+/fsBAB06dEDr1q2xZ88ercTz3r172Ldvn3THp6GEhITg+PHjWklSVVUVvv76a52+bdq0waVLl7Tajh8/jqKiojqfTyaTSSt/Nf773//q/E71WR184YUXAEDrwn8AuHDhAq5cuSL9O/G0nJyc8Pvf/x5vvfUW8vLytO54JWqquE8aEWlZvXr1E/tMmjQJGzduxOTJk3Hjxg107doVp0+fxqpVqzBixAgMGTIEABAaGooBAwbg3Xffxb179xAUFIT//e9/2Llzp86Yn376Kfr374/nn38eb775Jtq0aYPCwkJcv34dhw4dwvHjx+v1PZRKJf79738jPDwcgYGBWpvZXrt2Dbt27UJiYiLGjBkDCwsLrF27Fq+99hrCw8MxY8YMlJaW4uOPP0ZBQUGdfpOGWLJkCQ4dOoTBgwdjyZIlsLW1xebNm6VS7YPXyU2cOBEffPABPvzwQ4SEhCAlJQUbNmyAUqms8/nCw8OxY8cOdOzYEd26dUNcXBw+/vhjna1K2rVrB1tbW+zevRudOnVCixYtoFKpoFKpdMbs0KED3njjDXz22WewsLDA8OHDcePGDXzwwQfw9vaW7nytjxdffBEBAQEICgpCq1atcPPmTaxfvx6+vr7w9/ev93hEjY6p71wgItN58O7Ox3n47k4hhLh7966YOXOm8PT0FFZWVsLX11csXrxYlJSUaPUrKCgQU6dOFU5OTsLOzk4MHTpU/Pjjj7XepZiWliamTp0qWrduLeRyuWjVqpUIDg4WK1eu1OqDOtzdWSMnJ0e89957okuXLsLOzk4oFArxzDPPiBkzZoikpCStvt98843o27evsLGxEfb29mLw4MHif//7n1afmrsaH7wTU4jffssH78Ss692dQghx6tQp0bdvX6FQKISHh4d45513pLtlCwoKpH6lpaXi3XffFd7e3sLW1laEhISIhISER97dWdvc5ufni2nTpgk3NzdhZ2cn+vfvL06dOiVCQkJ05nnv3r2iY8eOQi6Xa8X98N2dQlTfkbpmzRrRvn17IZfLhaurq5gwYYLIyMjQ6veo32Xy5MnC19dXev/Xv/5VBAcHC1dXV2FtbS18fHzEtGnTxI0bN3Q+S9QUyYR46KISIiIyC6Ghobhx48YjN/8loqaN5U4iIjMwf/58BAYGwtvbG3l5edi9ezeio6Oxbds2U4dGRCbCJI2IyAxUVlbiww8/RE5ODmQyGTp37oydO3diwoQJpg6NiEyE5U4iIiIiM8QtOIiIiIjMEJM0IiIiIjPEJI2IiIjIDPHGgQaoqqpCVlYWHBwcan30ChEREdGDhBAoLCyESqXS2qi6NkzSGiArKwve3t6mDoOIiIgamYyMDJ2nfDyMSVoDODg4AKj+oR0dHU0cDREREZk7jUYDb29vKYd4HCZpDVBT4nR0dGSSRkRERHVWl8ukGu2NAydPnsSLL74IlUoFmUyGb775Ruv4/v37ERYWBldXV8hkMiQkJOiMUVpaijlz5sDV1RX29vYYNWoUMjMzjfMFiIiIiB6j0SZp9+7dQ/fu3bFhw4ZHHn/uueewevXqR44RERGBAwcOICoqCqdPn0ZRURHCw8NRWVlpqLCJiIiI6qTRljuHDx+O4cOHP/L4xIkTAQA3btyo9bharca2bduwc+dODBkyBACwa9cueHt74+jRowgLC9N7zERERER11WhX0hoqLi4O5eXlCA0NldpUKhUCAgIQGxtrwsiIiIiIGvFKWkPl5OTA2toaLVu21Gp3d3dHTk5OrZ8pLS1FaWmp9F6j0Rg0RiIiImq+mu1K2qMIIR55x0VkZCSUSqX04h5pREREZCjNNknz8PBAWVkZ8vPztdpzc3Ph7u5e62cWL14MtVotvTIyMowRKhERETVDzTZJ69WrF+RyOaKjo6W27OxsJCcnIzg4uNbPKBQKaU807o1GREREhtRor0krKirC9evXpfdpaWlISEiAs7MzfHx8kJeXh/T0dGRlZQEAUlNTAVSvoHl4eECpVGLatGlYsGABXFxc4OzsjIULF6Jr167S3Z5EREREptJoV9J++OEHBAYGIjAwEAAwf/58BAYG4sMPPwQAHDx4EIGBgRg5ciQA4JVXXkFgYCA2b94sjfHJJ59g9OjRGDt2LJ577jnY2dnh0KFDsLS0NP4XIiIiInqATAghTB1EY6XRaKBUKqFWq1n6JCIioieqT+7QaFfSiIiIiJoyJmlEREREZohJGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISRoRERGRGWKSRkRERGSGjJaknTx5EhUVFTrtFRUVOHnypLHCICIiImoUjJakDRo0CHl5eTrtarUagwYNMlYYRERERI2C0ZI0IQRkMplO+927d2Fvb2+sMIiIiIgaBStDn2DMmDEAAJlMhilTpkChUEjHKisrcenSJQQHBxs6DCIiIqJGxeBJmlKpBFC9kubg4ABbW1vpmLW1NZ599llMnz7d0GEQERERNSoGT9K2b98OAGjTpg0WLlzI0iYRERFRHciEEMLUQTRWGo0GSqUSarUajo6Opg6HiIiIzFx9cgej3Thw+/ZtTJw4ESqVClZWVrC0tNR6EREREdFvDF7urDFlyhSkp6fjgw8+gKenZ613ehIRERFRNaMlaadPn8apU6fQo0cPY52SiIiIqNEyWrnT29sbvPyNiIiIqG6MlqStX78eixYtwo0bN4x1SiIiIqJGy2jlznHjxuH+/fto164d7OzsIJfLtY7X9sgoIiIioubKaEna+vXrjXUqIiIiokbPaEna5MmTjXUqIiIiokbPaElaenr6Y4/7+PgYKRIiIiIi82e0JK1NmzaP3RutsrLSWKEQERERmT2jJWkXL17Uel9eXo6LFy9i3bp1+Oijj4wVBhEREVGjYLQkrXv37jptQUFBUKlU+PjjjzFmzBhjhUJERERk9oy2T9qjtG/fHhcuXDB1GERERERmxWgraRqNRuu9EALZ2dlYtmwZ/P39jRUGERERUaNgtCTNyclJ58YBIQS8vb0RFRVlrDCIiIiIGgWjJWknTpzQem9hYYFWrVrhmWeegZWV0cIgIiIiahSMlh2FhIQY61REREREjZ5Rl7B++uknrF+/HleuXIFMJkOnTp0wb948tGvXzphhEBEREZk9o93d+e2336Jz5844f/48unXrhoCAAJw7dw5dunRBdHS0scIgIiIiahRkQghhjBMFBgYiLCwMq1ev1mpftGgRvvvuO8THxxsjDL3SaDRQKpVQq9VwdHQ0dThERERk5uqTOxhtJe3KlSuYNm2aTvvUqVORkpJirDCIiIiIGgWjJWmtWrVCQkKCTntCQgLc3NyMFQYRERFRo2C0GwemT5+ON954Az///DOCg4Mhk8lw+vRprFmzBgsWLDBWGERERESNgtFW0j744AN8+OGH+OyzzxASEoIBAwZgw4YNWLZsGZYsWVLv8U6ePIkXX3wRKpUKMpkM33zzjdZxIQSWLVsGlUoFW1tbDBw4EJcvX9bqM3DgQMhkMq3XK6+80pCvSURERKQXRkvSZDIZ3n77bWRmZkKtVkOtViMzMxPz5s3TeRJBXdy7dw/du3fHhg0baj2+du1arFu3Dhs2bMCFCxfg4eGBoUOHorCwUKvf9OnTkZ2dLb22bNnyVN+PiIiISJ8MXu4sLi5GdHQ0Bg0aBAcHBwCQ/lej0eD7779HWFgYFApFvcYdPnw4hg8fXusxIQTWr1+PJUuWYMyYMQCAf/zjH3B3d8eePXswY8YMqa+dnR08PDye5qsZlBACxeWVpg6DiIio2bKVWz7VQpK+GDxJ++KLL3Dw4EGMGjVK55ijoyP+9re/ISMjA2+99ZbezpmWloacnByEhoZKbQqFAiEhIYiNjdVK0nbv3o1du3bB3d0dw4cPx9KlS6Uk8mGlpaUoLS2V3j/80Hh9Ki6vROcPvzXY+ERERPR4KSvCYGdtukdXGrzcuXv3bkRERDzyeEREBP7xj3/o9Zw5OTkAAHd3d612d3d36RgAvPbaa9i7dy++//57fPDBB9i3b5+08labyMhIKJVK6eXt7a3XuImIiIhqGDw9vHbtGrp37/7I4926dcO1a9cMcu6HlyiFEFpt06dPl/45ICAA/v7+CAoKQnx8PHr27Kkz3uLFizF//nzpvUajMViiZiu3RMqKMIOMTURERE9mK7c06fkNnqRVVFTgzp078PHxqfX4nTt3UFFRoddz1lxjlpOTA09PT6k9NzdXZ3XtQT179oRcLse1a9dqTdIUCkW9r517WjKZzKRLrERERGRaBi93dunSBUePHn3k8ejoaHTp0kWv5/Tz84OHh4fWM0HLysoQExOD4ODgR37u8uXLKC8v10rsiIiIiEzB4Es1U6dOxfz589GlSxeEh4drHTt06BBWrlyJdevW1XvcoqIiXL9+XXqflpaGhIQEODs7w8fHBxEREVi1ahX8/f3h7++PVatWwc7ODuPHjwcA/PTTT9i9ezdGjBgBV1dXpKSkYMGCBQgMDMRzzz3XsC9NRERE1EAGT9LeeOMNnDx5EqNGjULHjh3RoUMHyGQyXLlyBVevXsXYsWPxxhtv1HvcH374AYMGDZLe11wrNnnyZOzYsQPvvvsuiouLMWvWLOTn56Nv37747rvvpDs3ra2tcezYMXz66acoKiqCt7c3Ro4ciaVLl8LS0rQ1aCIiIiKZEEIY40T/93//hz179uDatWsQQqB9+/YYP348xo4da4zTG0R9nmRPREREVJ/cwWhJWlPEJI2IiIjqoz65g9EeC0VEREREdcckjYiIiMgMMUkjIiIiMkNM0oiIiIjMEJM0IiIiIjNk0H3SHvew8oft37/fgJEQERERNS4GTdKUSqUhhyciIiJqsgyapG3fvt2QwxMRERE1WbwmjYiIiMgMGXQlLTAwEDKZrE594+PjDRkKERERUaNi0CRt9OjRhhyeiIiIqMniszsbgM/uJCIiovow22d3FhQU4O9//zsWL16MvLw8ANVlzlu3bhkzDCIiIiKzZ9By54MuXbqEIUOGQKlU4saNG5g+fTqcnZ1x4MAB3Lx5E//85z+NFQoRERGR2TPaStr8+fMxZcoUXLt2DTY2NlL78OHDcfLkSWOFQURERNQoGC1Ju3DhAmbMmKHT3rp1a+Tk5BgrDCIiIqJGwWhJmo2NDTQajU57amoqWrVqZawwiIiIiBoFoyVpL730ElasWIHy8nIAgEwmQ3p6OhYtWoSXX37ZWGEQERERNQpGS9L+8pe/4M6dO3Bzc0NxcTFCQkLwzDPPwMHBAR999JGxwiAiIiJqFIx2d6ejoyNOnz6N48ePIz4+HlVVVejZsyeGDBlirBCIiIiIGg1uZtsA3MyWiIiI6sOsNrM9fvw4OnfuXOtNA2q1Gl26dMGpU6cMHQYRERFRo2LwJG39+vWYPn16rdmiUqnEjBkzsG7dOkOHQURERNSoGDxJS0xMxLBhwx55PDQ0FHFxcYYOg4iIiKhRMXiSdvv2bcjl8kcet7Kywp07dwwdBhEREVGjYvAkrXXr1khKSnrk8UuXLsHT09PQYRARERE1KgZP0kaMGIEPP/wQJSUlOseKi4uxdOlShIeHGzoMIiIiokbF4Ftw3L59Gz179oSlpSVmz56NDh06QCaT4cqVK9i4cSMqKysRHx8Pd3d3Q4ZhENyCg4iIiOqjPrmDwTezdXd3R2xsLN58800sXrwYNTmhTCZDWFgYNm3a1CgTNCIiIiJDMsoTB3x9fXH48GHk5+fj+vXrEELA398fLVu2NMbpiYiIiBodoz0WCgBatmyJ3r17G/OURERERI2S0R6wTkRERER1xySNiIiIyAwxSSMiIiIyQ0zSiIiIiMwQkzQiIiIiM8QkjYiIiMgMNdok7eTJk3jxxRehUqkgk8nwzTffaB0XQmDZsmVQqVSwtbXFwIEDcfnyZa0+paWlmDNnDlxdXWFvb49Ro0YhMzPTiN+CiIiIqHaNNkm7d+8eunfvjg0bNtR6fO3atVi3bh02bNiACxcuwMPDA0OHDkVhYaHUJyIiAgcOHEBUVBROnz6NoqIihIeHo7Ky0lhfg4iIiKhWBn92pzHIZDIcOHAAo0ePBlC9iqZSqRAREYH33nsPQPWqmbu7O9asWYMZM2ZArVajVatW2LlzJ8aNGwcAyMrKgre3Nw4fPoywsLAnnpfP7iQiIqL6qE/u0GhX0h4nLS0NOTk5CA0NldoUCgVCQkIQGxsLAIiLi0N5eblWH5VKhYCAAKnPw0pLS6HRaLReRERERIbQJJO0nJwcANB5cLu7u7t0LCcnB9bW1jrPD32wz8MiIyOhVCqll7e3twGiJyIiImqiSVoNmUym9V4IodP2sMf1Wbx4MdRqtfTKyMjQW6xERERED2qSSZqHhwcA6KyI5ebmSqtrHh4eKCsrQ35+/iP7PEyhUMDR0VHrRURERGQITTJJ8/Pzg4eHB6Kjo6W2srIyxMTEIDg4GADQq1cvyOVyrT7Z2dlITk6W+hARERGZipWpA3haRUVFuH79uvQ+LS0NCQkJcHZ2ho+PDyIiIrBq1Sr4+/vD398fq1atgp2dHcaPHw8AUCqVmDZtGhYsWAAXFxc4Oztj4cKF6Nq1K4YMGWKqr0VEREQEoBEnaT/88AMGDRokvZ8/fz4AYPLkydixYwfeffddFBcXY9asWcjPz0ffvn3x3XffwcHBQfrMJ598AisrK4wdOxbFxcUYPHgwduzYAUtLS6N/HyIiIqIHNYl90kyF+6QRERFRfdQnd2i0K2nmoCa/5X5pREREVBc1OUNd1siYpDVAzSOmuF8aERER1UdhYSGUSuVj+7Dc2QBVVVXIysqCg4PDE/dfexKNRgNvb29kZGSwdGoinAPT4xyYHufA9DgHpmfIORBCoLCwECqVChYWj99kgytpDWBhYQEvLy+9jsn910yPc2B6nAPT4xyYHufA9Aw1B09aQavRJPdJIyIiImrsmKQRERERmSEmaWZCoVBg6dKlUCgUpg6l2eIcmB7nwPQ4B6bHOTA9c5kD3jhAREREZIa4kkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJmJjZt2gQ/Pz/Y2NigV69eOHXqlKlDapIiIyPRu3dvODg4wM3NDaNHj0ZqaqpWHyEEli1bBpVKBVtbWwwcOBCXL182UcRNX2RkJGQyGSIiIqQ2zoHh3bp1CxMmTICLiwvs7OzQo0cPxMXFScc5B4ZVUVGB999/H35+frC1tUXbtm2xYsUKVFVVSX04B/p18uRJvPjii1CpVJDJZPjmm2+0jtfl9y4tLcWcOXPg6uoKe3t7jBo1CpmZmYYLWpDJRUVFCblcLrZu3SpSUlLEvHnzhL29vbh586apQ2tywsLCxPbt20VycrJISEgQI0eOFD4+PqKoqEjqs3r1auHg4CD27dsnkpKSxLhx44Snp6fQaDQmjLxpOn/+vGjTpo3o1q2bmDdvntTOOTCsvLw84evrK6ZMmSLOnTsn0tLSxNGjR8X169elPpwDw1q5cqVwcXER//nPf0RaWpr4+uuvRYsWLcT69eulPpwD/Tp8+LBYsmSJ2LdvnwAgDhw4oHW8Lr/3zJkzRevWrUV0dLSIj48XgwYNEt27dxcVFRUGiZlJmhno06ePmDlzplZbx44dxaJFi0wUUfORm5srAIiYmBghhBBVVVXCw8NDrF69WupTUlIilEql2Lx5s6nCbJIKCwuFv7+/iI6OFiEhIVKSxjkwvPfee0/079//kcc5B4Y3cuRIMXXqVK22MWPGiAkTJgghOAeG9nCSVpffu6CgQMjlchEVFSX1uXXrlrCwsBBHjhwxSJwsd5pYWVkZ4uLiEBoaqtUeGhqK2NhYE0XVfKjVagCAs7MzACAtLQ05OTla86FQKBASEsL50LO33noLI0eOxJAhQ7TaOQeGd/DgQQQFBeEPf/gD3NzcEBgYiK1bt0rHOQeG179/fxw7dgxXr14FACQmJuL06dMYMWIEAM6BsdXl946Li0N5eblWH5VKhYCAAIPNCR+wbmK//PILKisr4e7urtXu7u6OnJwcE0XVPAghMH/+fPTv3x8BAQEAIP3mtc3HzZs3jR5jUxUVFYX4+HhcuHBB5xjnwPB+/vlnfP7555g/fz7+9Kc/4fz585g7dy4UCgUmTZrEOTCC9957D2q1Gh07doSlpSUqKyvx0Ucf4dVXXwXAPwfGVpffOycnB9bW1mjZsqVOH0P9fc0kzUzIZDKt90IInTbSr9mzZ+PSpUs4ffq0zjHOh+FkZGRg3rx5+O6772BjY/PIfpwDw6mqqkJQUBBWrVoFAAgMDMTly5fx+eefY9KkSVI/zoHhfPXVV9i1axf27NmDLl26ICEhAREREVCpVJg8ebLUj3NgXE/zextyTljuNDFXV1dYWlrqZOG5ubk6GT3pz5w5c3Dw4EGcOHECXl5eUruHhwcAcD4MKC4uDrm5uejVqxesrKxgZWWFmJgY/O1vf4OVlZX0O3MODMfT0xOdO3fWauvUqRPS09MB8M+BMbzzzjtYtGgRXnnlFXTt2hUTJ07E22+/jcjISACcA2Ory+/t4eGBsrIy5OfnP7KPvjFJMzFra2v06tUL0dHRWu3R0dEIDg42UVRNlxACs2fPxv79+3H8+HH4+flpHffz84OHh4fWfJSVlSEmJobzoSeDBw9GUlISEhISpFdQUBBee+01JCQkoG3btpwDA3vuued0tp65evUqfH19AfDPgTHcv38fFhbafwVbWlpKW3BwDoyrLr93r169IJfLtfpkZ2cjOTnZcHNikNsRqF5qtuDYtm2bSElJEREREcLe3l7cuHHD1KE1OW+++aZQKpXi+++/F9nZ2dLr/v37Up/Vq1cLpVIp9u/fL5KSksSrr77K294N7MG7O4XgHBja+fPnhZWVlfjoo4/EtWvXxO7du4WdnZ3YtWuX1IdzYFiTJ08WrVu3lrbg2L9/v3B1dRXvvvuu1IdzoF+FhYXi4sWL4uLFiwKAWLdunbh48aK03VVdfu+ZM2cKLy8vcfToUREfHy9eeOEFbsHRHGzcuFH4+voKa2tr0bNnT2lLCNIvALW+tm/fLvWpqqoSS5cuFR4eHkKhUIgBAwaIpKQk0wXdDDycpHEODO/QoUMiICBAKBQK0bFjR/HFF19oHeccGJZGoxHz5s0TPj4+wsbGRrRt21YsWbJElJaWSn04B/p14sSJWv/7P3nyZCFE3X7v4uJiMXv2bOHs7CxsbW1FeHi4SE9PN1jMMiGEMMwaHRERERE9LV6TRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJGREREZIasTB1AbU6ePImPP/4YcXFxyM7OxoEDBzB69GjpuBACy5cvxxdffIH8/Hz07dsXGzduRJcuXaQ+AwcORExMjNa448aNQ1RUlPQ+Pz8fc+fOxcGDBwEAo0aNwmeffQYnJ6c6xVlVVYWsrCw4ODhAJpM9/RcmIiKiZkEIgcLCQqhUKlhYPH6tzCyTtHv37qF79+54/fXX8fLLL+scX7t2LdatW4cdO3agffv2WLlyJYYOHYrU1FQ4ODhI/aZPn44VK1ZI721tbbXGGT9+PDIzM3HkyBEAwBtvvIGJEyfi0KFDdYozKysL3t7eT/MViYiIqBnLyMiAl5fXY/uYZZI2fPhwDB8+vNZjQgisX78eS5YswZgxYwAA//jHP+Du7o49e/ZgxowZUl87Ozt4eHjUOs6VK1dw5MgRnD17Fn379gUAbN26Ff369UNqaio6dOjwxDhrEsKMjAw4OjrW6zsSERFR86PRaODt7a21qPQoZpmkPU5aWhpycnIQGhoqtSkUCoSEhCA2NlYrSdu9ezd27doFd3d3DB8+HEuXLpV+lDNnzkCpVEoJGgA8++yzUCqViI2NrTVJKy0tRWlpqfS+sLAQAODo6MgkjYiIiOqsLpdJNbokLScnBwDg7u6u1e7u7o6bN29K71977TX4+fnBw8MDycnJWLx4MRITExEdHS2N4+bmpjO+m5ubdI6HRUZGYvny5fr6KkRERESP1OiStBoPZ6BCCK226dOnS/8cEBAAf39/BAUFIT4+Hj179qx1jNrGedDixYsxf/586X3NkiURERGRvullC47y8nJkZGQgNTUVeXl5+hjykWquMXt4tSs3N1dnde1BPXv2hFwux7Vr16Rxbt++rdPvzp07jxxHoVBIpU2WOImIiMiQnjpJKyoqwpYtWzBw4EAolUq0adMGnTt3RqtWreDr64vp06fjwoUL+owVAKQSZk3ZEgDKysoQExOD4ODgR37u8uXLKC8vh6enJwCgX79+UKvVOH/+vNTn3LlzUKvVjx2HiIiIyBieqtz5ySef4KOPPkKbNm0watQoLFq0CK1bt4atrS3y8vKQnJyMU6dOYejQoXj22Wfx2Wefwd/fv87jFxUV4fr169L7tLQ0JCQkwNnZGT4+PoiIiMCqVavg7+8Pf39/rFq1CnZ2dhg/fjwA4KeffsLu3bsxYsQIuLq6IiUlBQsWLEBgYCCee+45AECnTp0wbNgwTJ8+HVu2bAFQvQVHeHh4ne7sJCIiIjIo8RR+//vfi0uXLj2xX0lJidi4caPYunVrvcY/ceKEAKDzmjx5shBCiKqqKrF06VLh4eEhFAqFGDBggEhKSpI+n56eLgYMGCCcnZ2FtbW1aNeunZg7d664e/eu1nnu3r0rXnvtNeHg4CAcHBzEa6+9JvLz8+scp1qtFgCEWq2u1/cjIiKi5qk+uYNMCCFMmCM2ahqNBkqlEmq1mtenERER0RPVJ3eo9zVpxcXFuHXrlk775cuX6zsUERERET1CvZK0f/3rX2jfvj1GjBiBbt264dy5c9KxiRMn6j04IiIiouaqXknaypUrER8fj8TERHz55ZeYOnUq9uzZA6B6fzEiIiIi0o963d1ZXl6OVq1aAQCCgoJw8uRJjBkzBtevX6/T4w2IiIiIqG7qtZLm5uaGS5cuSe9dXFwQHR2NK1euaLUTERERUcPUK0nbuXOnzvMura2tsXfvXsTExOg1MCIiIqLmrF7lTi8vr0ceq9kkloiIiIgarsEPWC8oKMC2bduQk5MDPz8/9OjRA927d4e9vb0+4iMiIiJqlhqcpI0ZMwZJSUno3bs3/t//+3+4evUqqqqq0LZtW/To0QP/93//p484iYiIiJqVBidp586dQ0xMDIKCggAApaWluHz5MhITE5GYmNjgAImIiIiaowYnaQEBAbCw+O3+A4VCgZ49e6Jnz54NHZqIiIio2ar3Y6EetmbNGnzwwQcoKSnRRzxEREREBD2spPn5+aGwsBCdOnXCq6++ir59+yIwMBA+Pj76iI+IiIioWWrwStrLL7+MjIwMDBo0COfPn8e0adPg5+cHFxcXvPDCC/qIkYiIiKjZafBKWkpKCs6ePYtu3bpJbenp6bh48SISEhIaOjwRERFRs9TgJK13794oKirSavPx8YGPjw9eeumlhg5PRERE1Cw1uNwZERGBZcuWIT8/Xx/xEBERERH0sJL28ssvAwD8/f0xatQoPPvsswgMDES3bt2gUCgaHCARERFRc9TgJC0tLQ0JCQlITExEQkIC1qxZgxs3bsDS0hIdO3bEpUuX9BEnERERUbPS4CTN19cXvr6+WtefFRYWIiEhgQkaERER0VOSCSFEQwY4ffo0HBwc0L17d33F1GhoNBoolUqo1Wo4OjqaOhwiIiIyc/XJHRp848CcOXMQFxen03716lWo1eqGDk9ERETULDU4SUtNTUVISIhO+4kTJ/Dqq682dHgiIiKiZqnBSZqjoyPy8vJ02p9//nmcP3++ocMTERERNUsNTtJGjRqFv/zlL7oDW1igrKysocMTERERNUsNTtJWrVqFU6dOYciQIdLdnCUlJVizZo3Wo6KIiIiIqO4avAWHq6srzpw5gzfffBM9evSAQqFARUUFlEolDh06pI8YiYiIiJqdBidpQPVeaYcPH0ZGRgYuXrwIuVyOvn37wtnZWR/DExERETU7T5Wkpaenw8fHR6fd29sb3t7eOu23bt1C69atn+ZURERERM3SU12T1rt3b0yfPv2xd2+q1Wps3boVAQEB2L9//1MHSERERNQcPdVK2pUrV7Bq1SoMGzYMcrkcQUFBUKlUsLGxQX5+PlJSUnD58mUEBQXh448/xvDhw/UdNxEREVGT1qDHQpWUlODw4cM4deoUbty4geLiYri6uiIwMBBhYWEICAjQZ6xmh4+FIiIiovqoT+7Q4Gd3NmdM0oiIiKg+jPrsTiIiIiLSPyZpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSG9PBYKAFJSUpCeno6ysjKt9lGjRunrFERERETNRoOTtJ9//hm/+93vkJSUBJlMhpodPWQyGQCgsrKyoacgIiIianYaXO6cN28e/Pz8cPv2bdjZ2eHy5cs4efIkgoKC8P333+shRCIiIqLmp8FJ2pkzZ7BixQq0atUKFhYWsLCwQP/+/REZGYm5c+c+1ZgnT57Eiy++CJVKBZlMhm+++UbruBACy5Ytg0qlgq2tLQYOHIjLly9r9SktLcWcOXPg6uoKe3t7jBo1CpmZmVp98vPzMXHiRCiVSiiVSkycOBEFBQVPFTMRERGRPjU4SausrESLFi0AAK6ursjKygIA+Pr6IjU19anGvHfvHrp3744NGzbUenzt2rVYt24dNmzYgAsXLsDDwwNDhw5FYWGh1CciIgIHDhxAVFQUTp8+jaKiIoSHh2uVX8ePH4+EhAQcOXIER44cQUJCAiZOnPhUMRMRERHplWig/v37iwMHDgghhHj11VfFsGHDxOnTp8WkSZNEly5dGjq8ACCNL4QQVVVVwsPDQ6xevVpqKykpEUqlUmzevFkIIURBQYGQy+UiKipK6nPr1i1hYWEhjhw5IoQQIiUlRQAQZ8+elfqcOXNGABA//vhjnWJTq9UCgFCr1Q35ikRERNRM1Cd3aPCNA++//z7u3bsHAFi5ciXCw8Px/PPPw8XFBV999VVDh9eRlpaGnJwchIaGSm0KhQIhISGIjY3FjBkzEBcXh/Lycq0+KpUKAQEBiI2NRVhYGM6cOQOlUom+fftKfZ599lkolUrExsaiQ4cOOucuLS1FaWmp9F6j0ej9+9UQQqC4nDddEBERmYqt3FK6EdIUGpykhYWFSf/ctm1bpKSkIC8vDy1btjTIF8vJyQEAuLu7a7W7u7vj5s2bUh9ra2u0bNlSp0/N53NycuDm5qYzvpubm9TnYZGRkVi+fHmDv0NdFJdXovOH3xrlXERERKQrZUUY7Kz1tltZvRlkM1tnZ2eDZ54Pjy+EeOI5H+5TW//HjbN48WKo1WrplZGR8RSRExERET2ZXtLDU6dOYcuWLfjpp5/wr3/9C61bt8bOnTvh5+eH/v376+MUEg8PDwDVK2Genp5Se25urrS65uHhgbKyMuTn52utpuXm5iI4OFjqc/v2bZ3x79y5o7NKV0OhUEChUOjtuzyOrdwSKSvCntyRiIiIDMJWbmnS8zc4Sdu3bx8mTpyI1157DRcvXpSu2SosLMSqVatw+PDhBgf5ID8/P3h4eCA6OhqBgYEAgLKyMsTExGDNmjUAgF69ekEulyM6Ohpjx44FAGRnZyM5ORlr164FAPTr1w9qtRrnz59Hnz59AADnzp2DWq2WEjlTkslkJl1iJSIiItNqcLlz5cqV2Lx5M7Zu3Qq5XC61BwcHIz4+/qnGLCoqQkJCAhISEgBU3yyQkJCA9PR0yGQyREREYNWqVThw4ACSk5MxZcoU2NnZYfz48QAApVKJadOmYcGCBTh27BguXryICRMmoGvXrhgyZAgAoFOnThg2bBimT5+Os2fP4uzZs5g+fTrCw8NrvWmAiIiIyJgavFSTmpqKAQMG6LQ7Ojo+9cawP/zwAwYNGiS9nz9/PgBg8uTJ2LFjB959910UFxdj1qxZyM/PR9++ffHdd9/BwcFB+swnn3wCKysrjB07FsXFxRg8eDB27NgBS8vfli53796NuXPnSneBjho16pF7sxEREREZk0yIXx+2+ZTatWuHLVu2YMiQIXBwcEBiYiLatm2Lf/7zn1i9ejVSUlL0FavZ0Wg0UCqVUKvVcHR0NHU4REREZObqkzs0uNw5Y8YMzJs3D+fOnYNMJkNWVhZ2796NhQsXYtasWQ0dnoiIiKhZanC5891334VarcagQYNQUlKCAQMGQKFQYOHChZg9e7Y+YiQiIiJqdhpc7qxx//59pKSkoKqqCp07d5ae59mUsdxJRERE9WG0cmd5eTkGDRqEq1evws7ODkFBQejTp0+zSNCIiIiIDKlBSZpcLkdycrJJn2tFRERE1BQ1+MaBSZMmYdu2bfqIhYiIiIh+1eAbB8rKyvD3v/8d0dHRCAoKgr29vdbxdevWNfQURERERM1Og5O05ORk9OzZEwBw9epVrWMsgxIRERE9nQYnaSdOnHjksZrHOhERERFR/TT4mrSHqdVqbNq0Cb169UKvXr30PTwRERFRs6C3JO348eOYMGECPD098dlnn2H48OH44Ycf9DU8ERERUbPSoHJnZmYmduzYgS+//BL37t3D2LFjUV5ejn379qFz5876ipGIiIio2XnqlbQRI0agc+fOSElJwWeffYasrCx89tln+oyNiIiIqNl66pW07777DnPnzsWbb74Jf39/fcZERERE1Ow99UraqVOnUFhYiKCgIPTt2xcbNmzAnTt39BkbERERUbP11Elav379sHXrVmRnZ2PGjBmIiopC69atUVVVhejoaBQWFuozTiIiIqJmRSaEEPoaLDU1Fdu2bcPOnTtRUFCAoUOH4uDBg/oa3uzU50n2RERERPXJHfS6T1qHDh2wdu1aZGZmYu/evfocmoiIiKhZ0etKWnPDlTQiIiKqD5OtpBERERGRfjBJIyIiIjJDTNKIiIiIzBCTNCIiIiIz9FRPHJg/f36d+65bt+5pTkFERETUrD1Vknbx4sU69ZPJZE8zPBEREVGz91RJ2okTJ/QdBxERERE9gNekEREREZkhXpNGREREZIZ4TRoRERGRGeI1aURERERmiNekEREREZkhvSRpp06dwoQJE9CvXz/cunULALBz506cPn1aH8MTERERNTsNTtL27duHsLAw2Nra4uLFiygtLQUAFBYWYtWqVQ0OkIiIiKg5anCStnLlSmzevBlbt26FXC6X2oODgxEfH9/Q4YmIiIiapQYnaampqRgwYIBOu6OjIwoKCho6PBEREVGz1OAkzdPTE9evX9dpP336NNq2bdvQ4YmIiIiapQYnaTNmzMC8efNw7tw5yGQyZGVlYffu3Vi4cCFmzZqljxiJiIiImp2n2iftQe+++y7UajUGDRqEkpISDBgwAAqFAgsXLsTs2bP1ESMRERFRsyMTQgh9DHT//n2kpKSgqqoKnTt3RosWLfQxrFnTaDRQKpVQq9VwdHQ0dThERERk5uqTOzx1ufP48ePo3LkzNBoNAMDOzg5BQUHo06cPKisr0aVLF5w6depphyciIiJq1p46SVu/fj2mT59eaxaoVCoxY8YMgz5cvbCwEBEREfD19YWtrS2Cg4Nx4cIF6fiUKVMgk8m0Xs8++6zWGKWlpZgzZw5cXV1hb2+PUaNGITMz02AxExEREdXVUydpiYmJGDZs2COPh4aGIi4u7mmHf6I//vGPiI6Oxs6dO5GUlITQ0FAMGTJEeuIBAAwbNgzZ2dnS6/Dhw1pjRERE4MCBA4iKisLp06dRVFSE8PBwVFZWGixuIiIiorp46iTt9u3bWpvXPszKygp37tx52uEfq7i4GPv27cPatWsxYMAAPPPMM1i2bBn8/Pzw+eefS/0UCgU8PDykl7Ozs3RMrVZj27Zt+Otf/4ohQ4YgMDAQu3btQlJSEo4ePWqQuImIiIjq6qmTtNatWyMpKemRxy9dugRPT8+nHf6xKioqUFlZCRsbG612W1tbreeFfv/993Bzc0P79u0xffp05ObmSsfi4uJQXl6O0NBQqU2lUiEgIACxsbG1nre0tBQajUbrRURERGQIT52kjRgxAh9++CFKSkp0jhUXF2Pp0qUIDw9vUHCP4uDggH79+uHPf/4zsrKyUFlZiV27duHcuXPIzs4GAAwfPhy7d+/G8ePH8de//hUXLlzACy+8ID1bNCcnB9bW1mjZsqXW2O7u7sjJyan1vJGRkVAqldLL29vbIN+PiIiI6Km34Lh9+zZ69uwJS0tLzJ49Gx06dIBMJsOVK1ewceNGVFZWIj4+Hu7u7vqOGQDw008/YerUqTh58iQsLS3Rs2dPtG/fHvHx8UhJSdHpn52dDV9fX0RFRWHMmDHYs2cPXn/9dSlpqzF06FC0a9cOmzdv1hmjtLRUq79Go4G3tze34CAiIqI6qc8WHE+9ma27uztiY2Px5ptvYvHixajJ9WQyGcLCwrBp0yaDJWgA0K5dO8TExODevXvQaDTw9PTEuHHj4OfnV2t/T09P+Pr64tq1awAADw8PlJWVIT8/X2s1LTc3F8HBwbWOoVAooFAo9P9liIiIiB7SoMdC+fr64vDhw/jll19w7tw5nD17Fr/88gsOHz6MNm3a6CnEx7O3t4enpyfy8/Px7bff4qWXXqq13927d5GRkSFdJ9erVy/I5XJER0dLfbKzs5GcnPzIJI2IiIjIWPT2xAFj+/bbbyGEQIcOHXD9+nW88847UCgUOH36NEpLS7Fs2TK8/PLL8PT0xI0bN/CnP/0J6enpuHLlChwcHAAAb775Jv7zn/9gx44dcHZ2xsKFC3H37l3ExcXB0tLyiTHwiQNERERUH0Ypd5qaWq3G4sWLkZmZCWdnZ7z88sv46KOPIJfLUVFRgaSkJPzzn/9EQUEBPD09MWjQIHz11VdSggYAn3zyCaysrDB27FgUFxdj8ODB2LFjR50SNCIiIiJDarQraeZArVbDyckJGRkZXEkjIiKiJ6q56bCgoABKpfKxfRvtSpo5KCwsBABuxUFERET1UlhY+MQkjStpDVBVVYWsrCw4ODhAJpM1aKyazJqrcqbDOTA9zoHpcQ5Mj3NgeoacAyEECgsLoVKpYGHx+Ps3uZLWABYWFvDy8tLrmI6OjvxDaWKcA9PjHJge58D0OAemZ6g5eNIKWo0GbcFBRERERIbBJI2IiIjIDDFJMxMKhQJLly7lEw1MiHNgepwD0+McmB7nwPTMZQ544wARERGRGeJKGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISZqZ2LRpE/z8/GBjY4NevXrh1KlTpg6pSYqMjETv3r3h4OAANzc3jB49GqmpqVp9hBBYtmwZVCoVbG1tMXDgQFy+fNlEETd9kZGRkMlkiIiIkNo4B4Z369YtTJgwAS4uLrCzs0OPHj0QFxcnHeccGFZFRQXef/99+Pn5wdbWFm3btsWKFStQVVUl9eEc6NfJkyfx4osvQqVSQSaT4ZtvvtE6Xpffu7S0FHPmzIGrqyvs7e0xatQoZGZmGi5oQSYXFRUl5HK52Lp1q0hJSRHz5s0T9vb24ubNm6YOrckJCwsT27dvF8nJySIhIUGMHDlS+Pj4iKKiIqnP6tWrhYODg9i3b59ISkoS48aNE56enkKj0Zgw8qbp/Pnzok2bNqJbt25i3rx5UjvnwLDy8vKEr6+vmDJlijh37pxIS0sTR48eFdevX5f6cA4Ma+XKlcLFxUX85z//EWlpaeLrr78WLVq0EOvXr5f6cA706/Dhw2LJkiVi3759AoA4cOCA1vG6/N4zZ84UrVu3FtHR0SI+Pl4MGjRIdO/eXVRUVBgkZiZpZqBPnz5i5syZWm0dO3YUixYtMlFEzUdubq4AIGJiYoQQQlRVVQkPDw+xevVqqU9JSYlQKpVi8+bNpgqzSSosLBT+/v4iOjpahISESEka58Dw3nvvPdG/f/9HHuccGN7IkSPF1KlTtdrGjBkjJkyYIITgHBjaw0laXX7vgoICIZfLRVRUlNTn1q1bwsLCQhw5csQgcbLcaWJlZWWIi4tDaGioVntoaChiY2NNFFXzoVarAQDOzs4AgLS0NOTk5GjNh0KhQEhICOdDz9566y2MHDkSQ4YM0WrnHBjewYMHERQUhD/84Q9wc3NDYGAgtm7dKh3nHBhe//79cezYMVy9ehUAkJiYiNOnT2PEiBEAOAfGVpffOy4uDuXl5Vp9VCoVAgICDDYnfMC6if3yyy+orKyEu7u7Vru7uztycnJMFFXzIITA/Pnz0b9/fwQEBACA9JvXNh83b940eoxNVVRUFOLj43HhwgWdY5wDw/v555/x+eefY/78+fjTn/6E8+fPY+7cuVAoFJg0aRLnwAjee+89qNVqdOzYEZaWlqisrMRHH32EV199FQD/HBhbXX7vnJwcWFtbo2XLljp9DPX3NZM0MyGTybTeCyF02ki/Zs+ejUuXLuH06dM6xzgfhpORkYF58+bhu+++g42NzSP7cQ4Mp6qqCkFBQVi1ahUAIDAwEJcvX8bnn3+OSZMmSf04B4bz1VdfYdeuXdizZw+6dOmChIQEREREQKVSYfLkyVI/zoFxPc3vbcg5YbnTxFxdXWFpaamThefm5upk9KQ/c+bMwcGDB3HixAl4eXlJ7R4eHgDA+TCguLg45ObmolevXrCysoKVlRViYmLwt7/9DVZWVtLvzDkwHE9PT3Tu3FmrrVOnTkhPTwfAPwfG8M4772DRokV45ZVX0LVrV0ycOBFvv/02IiMjAXAOjK0uv7eHhwfKysqQn5//yD76xiTNxKytrdGrVy9ER0drtUdHRyM4ONhEUTVdQgjMnj0b+/fvx/Hjx+Hn56d13M/PDx4eHlrzUVZWhpiYGM6HngwePBhJSUlISEiQXkFBQXjttdeQkJCAtm3bcg4M7LnnntPZeubq1avw9fUFwD8HxnD//n1YWGj/FWxpaSltwcE5MK66/N69evWCXC7X6pOdnY3k5GTDzYlBbkegeqnZgmPbtm0iJSVFRERECHt7e3Hjxg1Th9bkvPnmm0KpVIrvv/9eZGdnS6/79+9LfVavXi2USqXYv3+/SEpKEq+++ipvezewB+/uFIJzYGjnz58XVlZW4qOPPhLXrl0Tu3fvFnZ2dmLXrl1SH86BYU2ePFm0bt1a2oJj//79wtXVVbz77rtSH86BfhUWFoqLFy+KixcvCgBi3bp14uLFi9J2V3X5vWfOnCm8vLzE0aNHRXx8vHjhhRe4BUdzsHHjRuHr6yusra1Fz549pS0hSL8A1Pravn271KeqqkosXbpUeHh4CIVCIQYMGCCSkpJMF3Qz8HCSxjkwvEOHDomAgAChUChEx44dxRdffKF1nHNgWBqNRsybN0/4+PgIGxsb0bZtW7FkyRJRWloq9eEc6NeJEydq/e//5MmThRB1+72Li4vF7NmzhbOzs7C1tRXh4eEiPT3dYDHLhBDCMGt0RERERPS0eE0aERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISRoRERGRGbIydQAPi4yMxP79+/Hjjz/C1tYWwcHBWLNmDTp06CD12b9/P7Zs2YK4uDjcvXsXFy9eRI8ePbTGKS0txcKFC7F3714UFxdj8ODB2LRpE7y8vKQ++fn5mDt3Lg4ePAgAGDVqFD777DM4OTnVKdaqqipkZWXBwcEBMpmswd+diIiImjYhBAoLC6FSqWBh8YS1MmFmwsLCxPbt20VycrJISEgQI0eOFD4+PqKoqEjq889//lMsX75cbN26VQAQFy9e1Bln5syZonXr1iI6OlrEx8eLQYMGie7du4uKigqpz7Bhw0RAQICIjY0VsbGxIiAgQISHh9c51oyMDAGAL7744osvvvjiq16vjIyMJ+YZMiGEgBm7c+cO3NzcEBMTgwEDBmgdu3HjBvz8/HRW0tRqNVq1aoWdO3di3LhxAICsrCx4e3vj8OHDCAsLw5UrV9C5c2ecPXsWffv2BQCcPXsW/fr1w48//qi1cvcoarUaTk5OyMjIgKOjo/6+NBERETVJGo0G3t7eKCgogFKpfGxfvZY7y8vLkZOTg/v376NVq1ZwdnZu8JhqtRoA6jVWXFwcysvLERoaKrWpVCoEBAQgNjYWYWFhOHPmDJRKpZSgAcCzzz4LpVKJ2NjYWpO00tJSlJaWSu8LCwsBAI6OjkzSiIiIqM7qcplUg28cKCoqwpYtWzBw4EAolUq0adMGnTt3RqtWreDr64vp06fjwoULTzW2EALz589H//79ERAQUOfP5eTkwNraGi1bttRqd3d3R05OjtTHzc1N57Nubm5Sn4dFRkZCqVRKL29v73p8GyIiIqK6a1CS9sknn6BNmzbYunUrXnjhBezfvx8JCQlITU3FmTNnsHTpUlRUVGDo0KEYNmwYrl27Vq/xZ8+ejUuXLmHv3r0NCVMihNDKXGvLYh/u86DFixdDrVZLr4yMDL3ERURERPSwBpU7Y2NjceLECXTt2rXW43369MHUqVOxefNmbNu2DTExMfD396/T2HPmzMHBgwdx8uRJrTsy68LDwwNlZWXIz8/XWk3Lzc1FcHCw1Of27ds6n71z5w7c3d1rHVehUEChUNQrFiIiIqKn0aCVtK+//vqRCdqDFAoFZs2ahT/+8Y9P7CuEwOzZs7F//34cP34cfn5+9Y6rV69ekMvliI6Oltqys7ORnJwsJWn9+vWDWq3G+fPnpT7nzp2DWq2W+hARERGZitntk/bWW29hz549+Pe//w0HBwfp+jClUglbW1sAQF5eHtLT05GVlQUASE1NBVC9Oubh4QGlUolp06ZhwYIFcHFxgbOzMxYuXIiuXbtiyJAhAIBOnTph2LBhmD59OrZs2QIAeOONNxAeHl6nOzuJiIiIDMmgW3Dk5+cjISEBCQkJePvtt+sW0COuB9u+fTumTJkCANixYwdef/11nT5Lly7FsmXLAAAlJSV45513sGfPHq3NbB+82D8vL09nM9sNGzbUeTNbjUYDpVIJtVrNuzuJiIjoieqTO+gtSUtLS5MSsppXZmYmhBCwt7eXtqtoSpikERERUX3UJ3docLkzJCQEiYmJ0kk7d+6MgIAA3Lp1C9u2bcPgwYO5VQURERFRPTV4n7QzZ87grbfeQkZGBvLz8/G///0PW7ZsgUwmQ58+fZigERERET2FBidp586dw6lTp/DWW2/h6tWr+oiJiIiIqNlrcJIWGBiIkydPYuzYsQgLC8Nbb72F3NxcfcRGRERE1Gw1OEmrMX78eFy+fBlOTk7o0qULqqqqUFlZqa/hiYiIiJoVvSVpAGBnZ4ePPvoI586dQ3h4OAYPHoy//OUvKC4u1udpiIiIiJo8vSZpNdq2bYt///vf2L17N7Zv3462bdsa4jRERERETVaDkrT09PTHHh86dCgSExPx3nvvAQBu3brVkNMRERERNRsNStJ69+6N6dOnaz3/8mH37t2DnZ0dAgICsH///oacjoiIiKjZaNBmtleuXMGqVaswbNgwyOVyBAUFQaVSwcbGBvn5+UhJScHly5cRFBSEjz/+GMOHD9dX3ERERERNml4eC1VSUoLDhw/j1KlTuHHjBoqLi+Hq6orAwECEhYUhICBAH7GaHT4WioiIiOrDJM/ubI6YpBEREVF91Cd3MMjdnURERETUMEzSiIiIiMwQkzQiIiIiM8QkjYiIiMgM6S1JS09PR233IAghnrjpLRERERFp01uS5ufnhzt37ui05+Xlwc/PT1+nISIiImoW9JakCSEgk8l02ouKimBjY6Ov0xARERE1Cw164gAAzJ8/HwAgk8nwwQcfwM7OTjpWWVmJc+fOoUePHg09DREREVGz0uAk7eLFiwCqV9KSkpJgbW0tHbO2tkb37t2xcOHChp6GiIiIqFlpcJJ24sQJAMDrr7+OTz/9lDvvExEREelBg5O0Gtu3b9fXUERERETNnt6SNAA4duwYjh07htzcXFRVVWkd+/LLL/V5KiIiIqImTW9J2vLly7FixQoEBQXB09Oz1js9iYiIiKhu9Jakbd68GTt27MDEiRP1NSQRERFRs6W3fdLKysoQHBysr+GIiIiImjW9JWl//OMfsWfPHn0NR0RERNSs6a3cWVJSgi+++AJHjx5Ft27dIJfLtY6vW7dOX6ciIiIiavL0lqRdunRJerJAcnKy1jHeREBERERUP3pL0mo2tSUiIiKihtPbNWkAcOrUKUyYMAHBwcG4desWAGDnzp04ffq0Pk9DRERE1OTpLUnbt28fwsLCYGtri/j4eJSWlgIACgsLsWrVKn2dhoiIiKhZ0FuStnLlSmzevBlbt27VumkgODgY8fHx+joNERERUbOgtyQtNTUVAwYM0Gl3dHREQUGBvk5DRERE1CzoLUnz9PTE9evXddpPnz6Ntm3b6us0RERERM2C3pK0GTNmYN68eTh37hxkMhmysrKwe/duLFy4ELNmzdLXaYiIiIiaBb1twfHuu+9CrVZj0KBBKCkpwYABA6BQKLBw4ULMnj1bX6chIiIiahZkQgihzwHv37+PlJQUVFVVoXPnzmjRooU+hzcrGo0GSqUSarUajo6Opg6HiIiIzFx9cge9lDvLy8sxaNAgXL16FXZ2dggKCkKfPn2adIJGREREZEh6SdLkcjmSk5P5+CciIiIiPdHbjQOTJk3Ctm3bGjxOZGQkevfuDQcHB7i5uWH06NFITU3V6iOEwLJly6BSqWBra4uBAwfi8uXLWn1KS0sxZ84cuLq6wt7eHqNGjUJmZqZWn/z8fEycOBFKpRJKpRITJ07kdiFERERkFvR240BZWRn+/ve/Izo6GkFBQbC3t9c6vm7dujqNExMTg7feegu9e/dGRUUFlixZgtDQUKSkpEhjrl27FuvWrcOOHTvQvn17rFy5EkOHDkVqaiocHBwAABERETh06BCioqLg4uKCBQsWIDw8HHFxcbC0tAQAjB8/HpmZmThy5AgA4I033sDEiRNx6NAhff0sRERERE9FbzcODBo06NEnkclw/Pjxpxr3zp07cHNzQ0xMDAYMGAAhBFQqFSIiIvDee+8BqF41c3d3x5o1azBjxgyo1Wq0atUKO3fuxLhx4wAAWVlZ8Pb2xuHDhxEWFoYrV66gc+fOOHv2LPr27QsAOHv2LPr164cff/wRHTp0eGJsvHGAiIiI6qM+uYPeVtJOnDihr6G0qNVqAICzszMAIC0tDTk5OQgNDZX6KBQKhISEIDY2FjNmzEBcXBzKy8u1+qhUKgQEBCA2NhZhYWE4c+YMlEqllKABwLPPPgulUonY2Nhak7TS0lLpmaRA9Q9tKEIIFJdXGmx8IiIiejxbuaVJr7fXS5JWkxBt2bIF7du318eQAKoTlfnz56N///4ICAgAAOTk5AAA3N3dtfq6u7vj5s2bUh9ra2u0bNlSp0/N53NycuDm5qZzTjc3N6nPwyIjI7F8+fKGfak6Ki6vROcPvzXKuYiIiEhXyoow2FnrbT2r3sz67s7Zs2fj0qVL2Lt3r86xh88lhHji+R/uU1v/x42zePFiqNVq6ZWRkVGXr0FERERUb3pLD2vu7ly9erVexpszZw4OHjyIkydPwsvLS2r38PAAUL0S5unpKbXn5uZKq2seHh4oKytDfn6+1mpabm4ugoODpT63b9/WOe+dO3d0VulqKBQKKBSKhn+5OrCVWyJlRZhRzkVERES6bOWWJj2/2d3dKYTAnDlzcODAAXz//ffw8/PTOu7n5wcPDw9ER0cjMDBQOndMTAzWrFkDAOjVqxfkcjmio6MxduxYAEB2djaSk5Oxdu1aAEC/fv2gVqtx/vx59OnTBwBw7tw5qNVqKZEzJZlMZtIlViIiIjItvWUBycnJ6NmzJwDg6tWrWsfqUwZ96623sGfPHvz73/+Gg4ODdH2YUqmEra0tZDIZIiIisGrVKvj7+8Pf3x+rVq2CnZ0dxo8fL/WdNm0aFixYABcXFzg7O2PhwoXo2rUrhgwZAgDo1KkThg0bhunTp2PLli0AqrfgCA8Pr9OdnURERESGpPdndzbUoxK67du3Y8qUKQCqV9uWL1+OLVu2ID8/H3379sXGjRulmwsAoKSkBO+88w727NmD4uJiDB48GJs2bYK3t7fUJy8vD3PnzsXBgwcBAKNGjcKGDRvg5ORUp1i5BQcRERHVR31yB7NL0hoTJmlERERUHybZJ23FihWPPf7hhx/q61RERERETZ7ekrQDBw5ovS8vL0daWhqsrKzQrl07JmlERERE9aC3JO3ixYs6bRqNBlOmTMHvfvc7fZ2GiIiIqFnQy2a2j+Lo6IgVK1bggw8+MORpiIiIiJocgyZpAFBQUCA9f5OIiIiI6kZv5c6//e1vWu+FEMjOzsbOnTsxbNgwfZ2GiIiIqFnQW5L2ySefaL23sLBAq1atMHnyZCxevFhfpyEiIiJqFvSWpKWlpelrKCIiIqJmr8HXpB0/fhydO3eGRqPROaZWq9GlSxecOnWqoachIiIialYanKStX78e06dPr3XXXKVSiRkzZtT54epEREREVK3BSVpiYuJjbwwIDQ1FXFxcQ09DRERE1Kw0OEm7ffs25HL5I49bWVnhzp07DT0NERERUbPS4CStdevWSEpKeuTxS5cuwdPTs6GnISIiImpWGpykjRgxAh9++CFKSkp0jhUXF2Pp0qUIDw9v6GmIiIiImhWZEEI0ZIDbt2+jZ8+esLS0xOzZs9GhQwfIZDJcuXIFGzduRGVlJeLj4+Hu7q6vmM2GRqOBUqmEWq2u9cYJIiIiogfVJ3do8D5p7u7uiI2NxZtvvonFixejJueTyWQICwvDpk2bmmSCRkRERGRIetnM1tfXF4cPH0Z+fj6uX78OIQT8/f3RsmVLfQxPRERE1Ozo7YkDANCyZUv07t1bn0MSERERNUsNvnGAiIiIiPSPSRoRERGRGWKSRkRERGSGmKQRERERmSG9JWlHjx595LEtW7bo6zREREREzYLekrSRI0diwYIFKCsrk9ru3LmDF198EYsXL9bXaYiIiIiaBb0laSdPnsShQ4fQu3dvXL58Gf/9738REBCAoqIiJCYm6us0RERERM2C3pK0vn374uLFi+jWrRt69eqF3/3ud1iwYAGOHz8Ob29vfZ2GiIiIqFnQ640DqampuHDhAry8vGBlZYUff/wR9+/f1+cpiIiIiJoFvSVpq1evRr9+/TB06FAkJyfjwoUL0sramTNn9HUaIiIiomZBb0nap59+im+++QafffYZbGxs0KVLF5w/fx5jxozBwIED9XUaIiIiomZBb8/uTEpKgqurq1abXC7Hxx9/jPDwcH2dhoiIiKhZ0NtK2sMJ2oNCQkL0dRoiIiKiZkFvK2k1UlJSkJ6errVfGgCMGjVK36ciIiIiarL0lqT9/PPP+N3vfoekpCTIZDIIIQAAMpkMAFBZWamvUxERERE1eXord86bNw9+fn64ffs27OzscPnyZZw8eRJBQUH4/vvv9XUaIiIiomZBbytpZ86cwfHjx9GqVStYWFjAwsIC/fv3R2RkJObOnYuLFy/q61RERERETZ7eVtIqKyvRokULANU3EWRlZQEAfH19kZqaqq/TEBERETULeltJCwgIwKVLl9C2bVv07dsXa9euhbW1Nb744gu0bdtWX6chIiIiahb0lqS9//77uHfvHgBg5cqVCA8Px/PPPw8XFxdERUXp6zREREREzYJM1NyGaQB5eXlo2bKldIdnU6PRaKBUKqFWq+Ho6GjqcIiIiMjM1Sd3aPBK2tSpU+vU78svv2zoqYiIiIiajQbfOLBjxw6cOHECBQUFyM/Pf+SrPk6ePIkXX3wRKpUKMpkM33zzjdbx27dvY8qUKVCpVLCzs8OwYcNw7do1rT6lpaWYM2cOXF1dYW9vj1GjRiEzM1OrT35+PiZOnAilUgmlUomJEyeioKDgaX4GIiIiIr1q8ErazJkzERUVhZ9//hlTp07FhAkT4Ozs3KAx7927h+7du+P111/Hyy+/rHVMCIHRo0dDLpfj3//+NxwdHbFu3ToMGTIEKSkpsLe3BwBERETg0KFDiIqKgouLCxYsWIDw8HDExcXB0tISADB+/HhkZmbiyJEjAIA33ngDEydOxKFDhxoUPxEREVGDCT0oKSkRe/bsEUOGDBF2dnbiD3/4gzhy5Iioqqpq8NgAxIEDB6T3qampAoBITk6W2ioqKoSzs7PYunWrEEKIgoICIZfLRVRUlNTn1q1bwsLCQhw5ckQIIURKSooAIM6ePSv1OXPmjAAgfvzxxzrFplarBQChVqsb8hWJiIiomahP7qCXfdIUCgVeffVVREdHIyUlBV26dMGsWbPg6+uLoqIifZxCUlpaCgCwsbGR2iwtLWFtbY3Tp08DAOLi4lBeXo7Q0FCpj0qlQkBAAGJjYwFUb76rVCrRt29fqc+zzz4LpVIp9ant3BqNRutFREREZAh628y2hkwmk57dWVVVpe/h0bFjR/j6+mLx4sXIz89HWVkZVq9ejZycHGRnZwMAcnJyYG1tjZYtW2p91t3dHTk5OVIfNzc3nfHd3NykPg+LjIyUrl9TKpXw9vbW87cjIiIiqqaXJK20tBR79+7F0KFD0aFDByQlJWHDhg1IT0+XnkKgL3K5HPv27cPVq1fh7OwMOzs7fP/99xg+fLh0rdmjCCG0tgOpbWuQh/s8aPHixVCr1dIrIyOjYV+GiIiI6BEafOPArFmzEBUVBR8fH7z++uvShfqG1KtXLyQkJECtVqOsrAytWrVC3759ERQUBADw8PBAWVkZ8vPztVbTcnNzERwcLPW5ffu2zth37tyBu7t7redVKBRQKBQG+EZERERE2hqcpG3evBk+Pj7w8/NDTEwMYmJiau23f//+hp5Kh1KpBABcu3YNP/zwA/785z8DqE7i5HI5oqOjMXbsWABAdnY2kpOTsXbtWgBAv379oFarcf78efTp0wcAcO7cOajVaimRIyIiIjKVBidpkyZN0vsTBYqKinD9+nXpfVpaGhISEuDs7AwfHx98/fXXaNWqFXx8fJCUlIR58+Zh9OjR0o0CSqUS06ZNw4IFC+Di4gJnZ2csXLgQXbt2xZAhQwAAnTp1wrBhwzB9+nRs2bIFQPUWHOHh4ejQoYNevw8RERFRfTU4SduxY4cewtD2ww8/YNCgQdL7+fPnAwAmT56MHTt2IDs7G/Pnz8ft27fh6emJSZMm4YMPPtAa45NPPoGVlRXGjh2L4uJiDB48GDt27NC6bm337t2YO3eulNyNGjUKGzZs0Pv3ISIiIqovgz67s6lTq9VwcnJCRkYGn91JRERET6TRaODt7Y2CggLpsq1HafBKWnNWWFgIANyKg4iIiOqlsLDwiUkaV9IaoKqqCllZWXBwcGjwdXk1mTVX5UyHc2B6nAPT4xyYHufA9Aw5B0IIFBYWQqVSwcLi8TuhcSWtASwsLODl5aXXMR0dHfmH0sQ4B6bHOTA9zoHpcQ5Mz1Bz8KQVtBp6f+IAERERETUckzQiIiIiM8QkzUwoFAosXbqUTzQwIc6B6XEOTI9zYHqcA9MzlzngjQNEREREZograURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlmYtOmTfDz84ONjQ169eqFU6dOmTqkJikyMhK9e/eGg4MD3NzcMHr0aKSmpmr1EUJg2bJlUKlUsLW1xcCBA3H58mUTRdz0RUZGQiaTISIiQmrjHBjerVu3MGHCBLi4uMDOzg49evRAXFycdJxzYFgVFRV4//334efnB1tbW7Rt2xYrVqxAVVWV1IdzoF8nT57Eiy++CJVKBZlMhm+++UbreF1+79LSUsyZMweurq6wt7fHqFGjkJmZabigBZlcVFSUkMvlYuvWrSIlJUXMmzdP2Nvbi5s3b5o6tCYnLCxMbN++XSQnJ4uEhAQxcuRI4ePjI4qKiqQ+q1evFg4ODmLfvn0iKSlJjBs3Tnh6egqNRmPCyJum8+fPizZt2ohu3bqJefPmSe2cA8PKy8sTvr6+YsqUKeLcuXMiLS1NHD16VFy/fl3qwzkwrJUrVwoXFxfxn//8R6SlpYmvv/5atGjRQqxfv17qwznQr8OHD4slS5aIffv2CQDiwIEDWsfr8nvPnDlTtG7dWkRHR4v4+HgxaNAg0b17d1FRUWGQmJmkmYE+ffqImTNnarV17NhRLFq0yEQRNR+5ubkCgIiJiRFCCFFVVSU8PDzE6tWrpT4lJSVCqVSKzZs3myrMJqmwsFD4+/uL6OhoERISIiVpnAPDe++990T//v0feZxzYHgjR44UU6dO1WobM2aMmDBhghCCc2BoDydpdfm9CwoKhFwuF1FRUVKfW7duCQsLC3HkyBGDxMlyp4mVlZUhLi4OoaGhWu2hoaGIjY01UVTNh1qtBgA4OzsDANLS0pCTk6M1HwqFAiEhIZwPPXvrrbcwcuRIDBkyRKudc2B4Bw8eRFBQEP7whz/Azc0NgYGB2Lp1q3Scc2B4/fv3x7Fjx3D16lUAQGJiIk6fPo0RI0YA4BwYW11+77i4OJSXl2v1UalUCAgIMNic8AHrJvbLL7+gsrIS7u7uWu3u7u7IyckxUVTNgxAC8+fPR//+/REQEAAA0m9e23zcvHnT6DE2VVFRUYiPj8eFCxd0jnEODO/nn3/G559/jvnz5+NPf/oTzp8/j7lz50KhUGDSpEmcAyN47733oFar0bFjR1haWqKyshIfffQRXn31VQD8c2Bsdfm9c3JyYG1tjZYtW+r0MdTf10zSzIRMJtN6L4TQaSP9mj17Ni5duoTTp0/rHON8GE5GRgbmzZuH7777DjY2No/sxzkwnKqqKgQFBWHVqlUAgMDAQFy+fBmff/45Jk2aJPXjHBjOV199hV27dmHPnj3o0qULEhISEBERAZVKhcmTJ0v9OAfG9TS/tyHnhOVOE3N1dYWlpaVOFp6bm6uT0ZP+zJkzBwcPHsSJEyfg5eUltXt4eAAA58OA4uLikJubi169esHKygpWVlaIiYnB3/72N1hZWUm/M+fAcDw9PdG5c2ettk6dOiE9PR0A/xwYwzvvvINFixbhlVdeQdeuXTFx4kS8/fbbiIyMBMA5MLa6/N4eHh4oKytDfn7+I/voG5M0E7O2tkavXr0QHR2t1R4dHY3g4GATRdV0CSEwe/Zs7N+/H8ePH4efn5/WcT8/P3h4eGjNR1lZGWJiYjgfejJ48GAkJSUhISFBegUFBeG1115DQkIC2rZtyzkwsOeee05n65mrV6/C19cXAP8cGMP9+/dhYaH9V7ClpaW0BQfnwLjq8nv36tULcrlcq092djaSk5MNNycGuR2B6qVmC45t27aJlJQUERERIezt7cWNGzdMHVqT8+abbwqlUim+//57kZ2dLb3u378v9Vm9erVQKpVi//79IikpSbz66qu87d3AHry7UwjOgaGdP39eWFlZiY8++khcu3ZN7N69W9jZ2Yldu3ZJfTgHhjV58mTRunVraQuO/fv3C1dXV/Huu+9KfTgH+lVYWCguXrwoLl68KACIdevWiYsXL0rbXdXl9545c6bw8vISR48eFfHx8eKFF17gFhzNwcaNG4Wvr6+wtrYWPXv2lLaEIP0CUOtr+/btUp+qqiqxdOlS4eHhIRQKhRgwYIBISkoyXdDNwMNJGufA8A4dOiQCAgKEQqEQHTt2FF988YXWcc6BYWk0GjFv3jzh4+MjbGxsRNu2bcWSJUtEaWmp1IdzoF8nTpyo9b//kydPFkLU7fcuLi4Ws2fPFs7OzsLW1laEh4eL9PR0g8UsE0IIw6zREREREdHT4jVpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZsjK1AE0ZlVVVcjKyoKDgwNkMpmpwyEiIiIzJ4RAYWEhVCoVLCwev1bGJK0BsrKy4O3tbeowiIiIqJHJyMiAl5fXY/s0yiQtMjIS+/fvx48//ghbW1sEBwdjzZo16NChg9RHCIHly5fjiy++QH5+Pvr27YuNGzeiS5cuUp/S0lIsXLgQe/fuRXFxMQYPHoxNmzY98Uer4eDgAKD6h3Z0dNTvlyQiIqImR6PRwNvbW8ohHkcmhBBGiEmvhg0bhldeeQW9e/dGRUUFlixZgqSkJKSkpMDe3h4AsGbNGnz00UfYsWMH2rdvj5UrV+LkyZNITU2Vfpg333wThw4dwo4dO+Di4oIFCxYgLy8PcXFxsLS0fGIcGo0GSqUSarWaSRoRERE9UX1yh0aZpD3szp07cHNzQ0xMDAYMGAAhBFQqFSIiIvDee+8BqF41c3d3x5o1azBjxgyo1Wq0atUKO3fuxLhx4wD8Vr48fPgwwsLCnnheJmlERERNT1lFFcorq2Cv0H/BsT65Q5O4u1OtVgMAnJ2dAQBpaWnIyclBaGio1EehUCAkJASxsbEAgLi4OJSXl2v1UalUCAgIkPo8rLS0FBqNRutFREREjZcQAjd+uYdvLt7CsoOXMXrj/xCw9FvsPnfT1KE1zmvSHiSEwPz589G/f38EBAQAAHJycgAA7u7uWn3d3d1x8+ZNqY+1tTVatmyp06fm8w+LjIzE8uXL9f0ViIiIyEjy75UhIbMACekFSMgoQGJmAQrul+v0+zGn0ATRaWv0Sdrs2bNx6dIlnD59WufYw9tiCCGeuFXG4/osXrwY8+fPl97XXPxHRERE5qe0ohIpWRokZlQnZAkZBbhx975OP2tLC3Rp7YjuXk4I9HFCD28n+DjbmSBibY06SZszZw4OHjyIkydPat2R6eHhAaB6tczT01Nqz83NlVbXPDw8UFZWhvz8fK3VtNzcXAQHB9d6PoVCAYVCYYivQkRERA0ghMCNu/eRkJGPxAw1LmYU4EqWBmWVVTp927rao4e3E7p7VydknTwdYW1lfleANcokTQiBOXPm4MCBA/j+++/h5+enddzPzw8eHh6Ijo5GYGAgAKCsrAwxMTFYs2YNAKBXr16Qy+WIjo7G2LFjAQDZ2dlITk7G2rVrjfuFiIiIqF7y7pUhMaMAFzMKkPiYsqWzvTV6/JqMdfd2QncvJZzsrE0Qcf01yiTtrbfewp49e/Dvf/8bDg4O0jVkSqUStra2kMlkiIiIwKpVq+Dv7w9/f3+sWrUKdnZ2GD9+vNR32rRpWLBgAVxcXODs7IyFCxeia9euGDJkiCm/HhERET2gpLwSKdkarevIbtZWtrSyQIDKET28W6K7txKB3i3h7WzbaJ8K1CiTtM8//xwAMHDgQK327du3Y8qUKQCAd999F8XFxZg1a5a0me13332ntXncJ598AisrK4wdO1bazHbHjh112iONiIiI9K+qSuDG3XvSNWQJGQW4kq1BeaXujmFtW1WXLQN/XSXr6GGeZcun1ST2STMV7pNGRETUMHeLSpH4692WNaVLTUmFTj8XnbKlE5R2chNE3DD1yR0a5UoaERERNT4l5ZW4nKVGQob611WyfGTkFev0e7Bs2cOneqXMq2XjLVs+LSZpREREpHdVVQI//1Jdtkx8oGxZUaVbwGvXyh7dfy1b9vBuiY6eDpBbNp2y5dNikkZEREQN9ktRKRLSqy/qr7mWrLCWsqVri+qyZXcvJ/TwcUI3LycobRtf2dIYmKQRERFRvdSULS+m/5aQZebrli0VVhbo2lqptSdZcyxbPi2jJWlt27bFhQsX4OLiotVeUFCAnj174ueffzZWKERERFRHD5YtazaKra1sKZMB7Vq1kC7u7+HthA4eLFs2hNGStBs3bqCyslKnvbS0FLdu3TJWGERERPQYNWXLmhWyxMxHlS0V1dtf/PoYpa5eSjjasGypTwZP0g4ePCj987fffgulUim9r6ysxLFjx9CmTRtDh0FEREQPKS6ruduyevuLhPQC3CrQLVvayH8rW9bccalS2rBsaWAGT9JGjx4NoPph55MnT9Y6JpfL0aZNG/z1r381dBhERETNWlWVwE93iqqTsV/vuPwxpxCVtZQt/d1aSBf29/B2Qgd3B1ixbGl0Bk/SqqqqH2zq5+eHCxcuwNXV1dCnJCIiavZyC0u0ypaXMtUoKtUtW7o5KKSL+gN/LVs6sGxpFox2TVpaWpqxTkVERNSsFJdVIjlLrZWU1Va2tJVbVpctfX67uN+TZUuzZdQtOI4dO4Zjx44hNzdXWmGr8eWXXxozFCIiokapqkrg+p2i355tmV6A1NuPLltK15F5O6G9ewuWLRsRoyVpy5cvx4oVKxAUFARPT09m7URERHWQqynRuo7scWXLHt6/XkfmxbJlU2C0JG3z5s3YsWMHJk6caKxTEhERNSr3yyqQlKn+bZUsowDZ6hKdfrZyS3T1Uv76GKXqjWJZtmx6jJaklZWVITg42FinIyIiMmuVVQLXc4uQkJEvPXD8ai1lSwsZ0N7dQetuS383li2bA6MlaX/84x+xZ88efPDBB8Y6JRERkdm4rSmRHqNUXbYswL0y3U3ePRxt0N1bKV1H1tVLiRYKPsWxOTLarJeUlOCLL77A0aNH0a1bN8jl2nXydevWGSsUIiIig7pXWoGkW2rpwv6EjALkaHTLlnbWlujmVZOQVf+vh9LGBBGTOTJaknbp0iX06NEDAJCcnKx1jDV0IiJqrCqrBK7eLkTiA9eRXb1diIeqllLZMtDHSSpd+rs5wNKCfwdS7YyWpJ04ccJYpyIiIjKYbHVx9epYZvUqWdItNe7XUrb0VNpIe5F193ZC19ZK2LNsSfXAf1uIiIgeoaj0wbst85GQUYDbmlKdfvbWluj2wIX9Pbyd4O7IsiU1jNGStEGDBj22rHn8+HFjhUJERKSjpmz54HVk13J1y5aWFjK0d3eQHqPUw8cJ7Vq1YNmS9M5oSVrN9Wg1ysvLkZCQgOTkZJ0HrxMRERmSEAI5Gu1nWz6qbKlS2jywQtYSAa0dYWfNQhQZntH+Lfvkk09qbV+2bBmKioqMFQYRETVDRaUVuJT522OUEjNrL1u2UFihm5dS64HjbixbkonIhBDiyd0M5/r16+jTpw/y8vJMGcZT0Wg0UCqVUKvVcHR0NHU4REQEoKKyCldvF2ldR3YttwgP/21naSFDB3cH6TFKLFuSMdQndzD5eu2ZM2dgY8P/l0JERPUnhECWukRaHau527K4XLds2drJVrqov4ePEwJUSthaW5ogaqK6MVqSNmbMGK33QghkZ2fjhx9+4FMIiIioTgpLynHpoWdb3inULVs6KKzQzVspXUfW3VsJNwcuCFDjYrQkTalUar23sLBAhw4dsGLFCoSGhhorDCIiaiQqKqvwY06h9BilhIwCXL9Te9myo4eDtEoW6OOEtq4tYMGyJTVyRkvStm/fbqxTERFRIyOEwK2CYq3tL5Kz1Cgpr9Lp29rJFj18ft3+wtsJXVi2pCbK6NekxcXF4cqVK5DJZOjcuTMCAwONHQIREZmYpqRc2iS25qHjvxTVXrbs/sCu/T28ndDKQWGCiImMz2hJWm5uLl555RV8//33cHJyghACarUagwYNQlRUFFq1amWsUIiIyIjKK6uQmlOIiw9sf/FTLWVLKwsZOno6SNeR9fBWsmxJzZrRkrQ5c+ZAo9Hg8uXL6NSpEwAgJSUFkydPxty5c7F3715jhUJERAYihEBmfrF0p2XNJrGlFbplS6+WD9xt6e2EgNZK2MhZtiSqYbR90pRKJY4ePYrevXtrtZ8/fx6hoaEoKCgwRhh6xX3SiKi5UxeX41Lmbxf2V5cty3T6OdhYaSVk3b2d4NqCZUtqfsxyn7SqqirI5XKddrlcjqoq3f+HRURE5qW8sgo/Zhf+ukGsGgkZ+fjpzj2dflYWMnTydNRKyNq62rNsSVRPRkvSXnjhBcybNw979+6FSqUCANy6dQtvv/02Bg8ebKwwiIioDmrKlg9eR5b8iLKlj7OddFF/9d2WjixbEumB0ZK0DRs24KWXXkKbNm3g7e0NmUyG9PR0dO3aFbt27TJWGEREVAv1/fLq68h+LVkmZhTg7j3dsqXSVl6dkHkp0cPHCd29nODCsiWRQRgtSfP29kZ8fDyio6Px448/QgiBzp07Y8iQIcYKgYiIAJRVVOFKtkbr4v6ff9EtW8otZej8a9myZqXMz9UeMhnLlkTGYPIHrDdmvHGAiMydEALpefe1HqN0OUuDslrKlr4udloX93fyZNmSSN/M6saB48ePY/bs2Th79qxOMGq1GsHBwdi8eTOef/55Q4dCRNTkFdwvQ2Km+tcVsnwkZqqRV0vZ0slOju5evz1svLuXE5ztrU0QMRE9isGTtPXr12P69Om1ZotKpRIzZszAunXrmKQREdVTTdnywVWytFrKltaWFuikcpQeo9TD2wm+LnYsWxKZOYMnaYmJiVizZs0jj4eGhuIvf/mLocMgImrUhBC4efc+EjN/e4xSSpYGZZW6Zcs2Ltp3W3ZWOUJhxbIlUWNj8CTt9u3bte6PJgVgZYU7d+4YOgwiokYl/16Zzt2W+ffLdfo52cmrL+z3qi5b9vByQkuWLYmaBIMnaa1bt0ZSUhKeeeaZWo9funQJnp6ehg6DiMhslVZU4kp2IRLS86Wk7Mbd+zr9rC0t0FnlqHVxP8uWRE2XwZO0ESNG4MMPP8Tw4cNhY2Ojday4uBhLly5FeHh4vcc9efIkPv74Y8TFxSE7OxsHDhzA6NGjpeNCCCxfvhxffPEF8vPz0bdvX2zcuBFdunSR+pSWlmLhwoXYu3cviouLMXjwYGzatAleXl5P/X2JiB6npmxZk4xdzCjAlUeULf1c7dHdS/nrxf0t0cnTgWVLombE4Ena+++/j/3796N9+/aYPXs2OnToAJlMhitXrmDjxo2orKzEkiVL6j3uvXv30L17d7z++ut4+eWXdY6vXbsW69atw44dO9C+fXusXLkSQ4cORWpqKhwcHAAAEREROHToEKKiouDi4oIFCxYgPDwccXFxsLTkfwiJqOHy75VpXdifmFmAglrKli1/LVv28G6J7t7ViZmTHcuWRM2ZUfZJu3nzJt588018++23qDmdTCZDWFgYNm3ahDZt2jRofJlMprWSJoSASqVCREQE3nvvPQDVq2bu7u5Ys2YNZsyYAbVajVatWmHnzp0YN24cACArKwve3t44fPgwwsLCnnhe7pNGRA8qKa9ESrZG2iA2MbMAN2srW1pZoMsDZctA75bwdrZl2ZKoGTCrfdIAwNfXF4cPH0Z+fj6uX78OIQT8/f3RsmVLg5wvLS0NOTk5CA0NldoUCgVCQkIQGxuLGTNmIC4uDuXl5Vp9VCoVAgICEBsbW2uSVlpaitLSUum9RqMxSPxEZP6EEEj75Z7Whf0p2RqUV+r+/962rvbSfmQ9vJ3Q0cMR1lYWJoiaiBoToz0WCgBatmyJ3r17G/w8OTk5AAB3d3etdnd3d9y8eVPqY21trZMouru7S59/WGRkJJYvX26AiInI3OXdK0Pir9eQ1SRl6mLdsqWzvbXWhf3dvZygtHv0He5ERI9i1CTN2B4uHQghnlhOeFyfxYsXY/78+dJ7jUYDb2/vhgdKRGbl4bJlQkYB0vNqL1sGqBzRw7slevg4IdDbCV4tWbYkIv1okkmah4cHgOrVsge398jNzZVW1zw8PFBWVob8/Hyt1bTc3FwEBwfXOq5CoYBCoTBg5ERkbA+XLRMyCnDlUWXLVva/XkNWfYF/Bw8Hli2JyGCaZJLm5+cHDw8PREdHIzAwEABQVlaGmJgY6ekHvXr1glwuR3R0NMaOHQsAyM7ORnJyMtauXWuy2InIsO4WlUrlyou//q+mpEKnn8uDZUsfJ3TzcoLSlmVLIjIeoyVpBQUFcHJyqvXY9evXH7nZ7aMUFRXh+vXr0vu0tDQkJCTA2dkZPj4+iIiIwKpVq+Dv7w9/f3+sWrUKdnZ2GD9+PIDq54ZOmzYNCxYsgIuLC5ydnbFw4UJ07doVQ4YMeervSUTmo6S8Epez1NJjlBIzC5CRV6zTT2Flga6tlVqPUmLZkohMzWhJ2ogRI3D8+HGdDW1TU1MxePBgZGZm1mu8H374AYMGDZLe11wrNnnyZOzYsQPvvvsuiouLMWvWLGkz2++++07aIw0APvnkE1hZWWHs2LHSZrY7duzgHmlEjVBVlcDPUtmyeuf+H7MLUVGlW7Zs18pe6zqyDh4OkFuybElE5sUo+6QBwMiRI1FZWYn//Oc/sLKqzg2vXLmCF154AWPHjsWnn35qjDD0ivukEZnOncJSJD60SWxhLWVL1xYP3m3ZEt28lXC0YdmSiEyjPrmD0ZK0kpISDB06FJ6envjqq69w+fJlDB48GK+99hrWrVtnjBD0jkkakXEUl1WXLWseo5SQXoBbBbplSxv5r2VLr9/2JGvtxLIlEZkPs0zSAECtVmPgwIFo164dTp06hUmTJuHjjz821un1jkkakf5Vly2LpOvIEjIK8GNOISofKlvKZMAzrVpU70X260oZy5ZEZO7M5okDD+/IL5PJ8NVXX2HIkCF4+eWX8cEHH0h9mOQQNU93Ckul68gSM9SPLFu2clBobRLbzUsJB5YtiagJM+hKmoWFRa1lhgef31mzeWxlZaWhwjAYrqQR1U9xWSWSs9TVm8RmPrpsaSu3RNfWSvTwcZJKlyqlDcuWRNTomc1K2okTJww5PBGZsaoqgZ/uFEl7kT2ubOnv1kK6sL+7txId3B1gxbIlETVzBk3SQkJCDDk8EZmR3MISrccoXcpUo6hUt2zp9mvZsvuvO/d3ZdmSiKhWRtsnbfv27WjRogX+8Ic/aLV//fXXuH//PiZPnmysUIioge6XVSD5lkbajywhvQBZ6hKdfrZyS3T1UiLwgYv7PVm2JCKqE6MlaatXr8bmzZt12t3c3PDGG28wSSMyU5VVAtdzi6THKCVkFODq7drLlu3dHLTutmzv3oJlSyKip2S0JO3mzZvw8/PTaff19UV6erqxwiCiJ7itKcHF9OrNYRPSC5B0q/aypbujQus6sm5eTmihaJKPAyYiMgmj/RfVzc0Nly5dQps2bbTaExMT4eLiYqwwiOgB98sqcClTrbVzf3YtZUs769/utuzx692WnkpbE0RMRNR8GC1Je+WVVzB37lw4ODhgwIABAICYmBjMmzcPr7zyirHCIGq2KqsEruUWSgnZxfTqsuXDj7a0kAHt3R1+25PMxwn+bg6wtOB1ZERExmS0JG3lypW4efMmBg8eLD27s6qqCpMmTcKqVauMFQZRs5GjLpFWxxIy8pGUqca9Mt39CD0cbbSuI+vmpYQ9y5ZERCZn1MdCAcDVq1eRmJgIW1tbdO3aFb6+vsY8vV5xM1syF/dKq8uWD+7cn6PRLVvaW1ffbVmz/UUP75bwUNqYIGIioubJbDazrU379u3Rvn17Y5+WqMmorBK4ertQ6zqyR5UtO3g4ooe3UrrA/xm3FixbEhE1EkZN0jIzM3Hw4EGkp6ejrKxM69i6deuMGQpRo5GtLtZ6jFLSLTXu11K2VCltpJJlj183ibWzZtmSiKixMtp/wY8dO4ZRo0bBz88PqampCAgIwI0bNyCEQM+ePY0VBpFZKyqtwKXM6tWxmpWy25pSnX721pbo9utdlj1+LV26ObJsSUTUlBgtSVu8eDEWLFiAFStWwMHBAfv27YObmxtee+01DBs2zFhhEJmNisoqXL1dpHUd2dXcQjx8lailhUy62zLw17st27Vi2ZKIqKkzWpJ25coV7N27t/qkVlYoLi5GixYtsGLFCrz00kt48803jRUKkdEJIZClLvntOrJfy5bF5bply9ZOtuj+wHVkAa0dWbYkImqGjPZffnt7e5SWVpdtVCoVfvrpJ3Tp0gUA8MsvvxgrDCKjKCqtwKUHHqOUkFGAO4W6ZUsHhRW6/ZqQdf+1fOnmwLIlEREZMUl79tln8b///Q+dO3fGyJEjsWDBAiQlJWH//v149tlnjRUGkd5VVFYh9XahtEKWmFmAa7lFtZYtO3r89mzLQO/qsqUFy5ZERFQLoyVp69atQ1FREQBg2bJlKCoqwldffYVnnnkGn3zyibHCIGoQIQRuFRQjMUONhIx8JGRUly1Lyqt0+rZ2skUPn+pkrLu3EwJUSthaW5ogaiIiaoyMvpltU8LNbJs+TUk5LmWokZhZ/RilhIwC/FL0+LJlD++W6OHthFYOChNETERE5swsN7Nt27YtLly4oPMw9YKCAvTs2RM///yzsUIhqlVFZRV+zCl84FFKBfjpjm7Z0spCho6eDtJ1ZIE+TmjryrIlERHpl9GStBs3bqCyUvdOttLSUty6dctYYRAB+K1s+eB1ZI8qW3q1tP3tYePeTghorYSNnGVLIiIyLIMnaQcPHpT++dtvv4VSqZTeV1ZW4tixY2jTpo2hw6BmTl1cjqTM364jS8hQ1162tLHSSsi6ezvBtQXLlkREZHwGT9JGjx4NAJDJZJg8ebLWMblcjjZt2uCvf/2rocOgZqS8sgo/ZhdKj1FKyMjHT3fu6fSzspChk6fjb0mZjxP8XOxZtiQiIrNg8CStqqq6fOTn54cLFy7A1dXV0KekZkQIgcz8Ylx84DFKybfUKK3QLVt6O9tKF/X38HZCF5Ujy5ZERGS2jHZNWlpamrFORU2YurhcSsZq/vfuvTKdfo42VtJeZD18nNDNi2VLIiJqXAyepJ07dw55eXkYPny41PbPf/4TS5cuxb179zB69Gh89tlnUCj4FyhpK6uowo85Gq27LX+upWwpt5Shs6cjuj9wLZmfqz1kMpYtiYio8TJ4krZs2TIMHDhQStKSkpIwbdo0TJkyBZ06dcLHH38MlUqFZcuWGToUMmNCCGTkFePirw8aT8jIR3KWBmW1lC19nO20riPr7MmyJRERNT0GT9ISEhLw5z//WXofFRWFvn37YuvWrQAAb29vLF26lElaM6O+X47EzN9WyBIfUbZU2sofWCFToruXE1xYtiQiombA4Elafn4+3N3dpfcxMTEYNmyY9L53797IyMgwdBhkQmUVVbiSralOyn7dtf/nXx5dtqxZIevuxbIlERE1XwZP0tzd3ZGWlgZvb2+UlZUhPj4ey5cvl44XFhZCLpcbOgwyEiEE0vPua11HdvkRZUtfFzut/chYtiQiIvqNwZO0YcOGYdGiRVizZg2++eYb2NnZ4fnnn5eOX7p0Ce3atTN0GGQgBffLfi1XVl9HlpipRl4tZUsnOzm6ezlprZI521ubIGIiIqLGweBJ2sqVKzFmzBiEhISgRYsW+Mc//gFr69/+cv7yyy8RGhpq6DBID0orKnEluxAJ6dXJWEJGAdJqKVtaW1qgs8pRa+d+Xxc7li2JiIjqQSbEw4+PNgy1Wo0WLVrA0lK7nJWXl4cWLVpoJW6NRX2eZN/YCCFw86522TIlS4OySt2ypZ+rPbp7KX9dJWuJTp4OUFixbElERPSw+uQORtvM9sFndj7I2dnZWCHQY+TfK0NCZoHWRrH598t1+rW0k2vtR9bD2wlOdo0vwSYiIjJ3RkvSyHyUVlQiJUujtf3Fjbv3dfpZW1mgi8oR3b2cEOhTnZD5OLNsSUREZAxM0po4IQRu3L1ffVF/hhoXMwpw5RFly7au9tKdlj28ndDJ0xHWVhYmiJqIiIiYpDUxeffKkJhRID1wPDGzAAW1lC2d7a1/vY6s5a93WypZtiQiIjIjTNIasZLySqRka5CQXiDt3n/zMWXLmmvIAr1bwtvZlmVLIiIiM8YkDcCmTZvw8ccfIzs7G126dMH69eu19nIzB1VVAml370kX9idkFOBKtgbllbo357ZtZY8eXtX7kfXwdkJHD5YtiYiIGptmn6R99dVXiIiIwKZNm/Dcc89hy5YtGD58OFJSUuDj42PS2E5du4MLaXlS6VJTUqHTx8XeWus6su5eTlDa8QkOREREjZ3R9kkzV3379kXPnj3x+eefS22dOnXC6NGjERkZ+djPGnqftHFbzuBcWp70XmFlgYDWSq3tL7xasmxJRETUWJjlPmnmqKysDHFxcVi0aJFWe2hoKGJjY3X6l5aWorS0VHqv0WgMGt/Qzu7wammHHj5OCPR2QgcPB8gtWbYkIiJqDpp1kvbLL7+gsrIS7u7uWu3u7u7IycnR6R8ZGan1cHhD++PzbY12LiIiIjIvXJYBdMqFQohaS4iLFy+GWq2WXhkZGcYKkYiIiJqZZr2S5urqCktLS51Vs9zcXJ3VNQBQKBRQKBTGCo+IiIiasWadpFlbW6NXr16Ijo7G7373O6k9OjoaL7300hM/X3PPhaGvTSMiIqKmoSZnqMt9m806SQOA+fPnY+LEiQgKCkK/fv3wxRdfID09HTNnznziZwsLCwEA3t7ehg6TiIiImpDCwkIolcrH9mn2Sdq4ceNw9+5drFixAtnZ2QgICMDhw4fh6+v7xM+qVCpkZGTAwcGhwdtgaDQaeHt7IyMjwyDbedCTcQ5Mj3NgepwD0+McmJ4h50AIgcLCQqhUqif2bfb7pJkLQ++5Rk/GOTA9zoHpcQ5Mj3NgeuYyB7y7k4iIiMgMMUkjIiIiMkNM0syEQqHA0qVLucWHCXEOTI9zYHqcA9PjHJieucwBr0kjIiIiMkNcSSMiIiIyQ0zSiIiIiMwQkzQiIiIiM8QkjYiIiMgMMUkzE5s2bYKfnx9sbGzQq1cvnDp1ytQhNUmRkZHo3bs3HBwc4ObmhtGjRyM1NVWrjxACy5Ytg0qlgq2tLQYOHIjLly+bKOKmLzIyEjKZDBEREVIb58Dwbt26hQkTJsDFxQV2dnbo0aMH4uLipOOcA8OqqKjA+++/Dz8/P9ja2qJt27ZYsWIFqqqqpD6cA/06efIkXnzxRahUKshkMnzzzTdax+vye5eWlmLOnDlwdXWFvb09Ro0ahczMTMMFLcjkoqKihFwuF1u3bhUpKSli3rx5wt7eXty8edPUoTU5YWFhYvv27SI5OVkkJCSIkSNHCh8fH1FUVCT1Wb16tXBwcBD79u0TSUlJYty4ccLT01NoNBoTRt40nT9/XrRp00Z069ZNzJs3T2rnHBhWXl6e8PX1FVOmTBHnzp0TaWlp4ujRo+L69etSH86BYa1cuVK4uLiI//znPyItLU18/fXXokWLFmL9+vVSH86Bfh0+fFgsWbJE7Nu3TwAQBw4c0Dpel9975syZonXr1iI6OlrEx8eLQYMGie7du4uKigqDxMwkzQz06dNHzJw5U6utY8eOYtGiRSaKqPnIzc0VAERMTIwQQoiqqirh4eEhVq9eLfUpKSkRSqVSbN682VRhNkmFhYXC399fREdHi5CQEClJ4xwY3nvvvSf69+//yOOcA8MbOXKkmDp1qlbbmDFjxIQJE4QQnANDezhJq8vvXVBQIORyuYiKipL63Lp1S1hYWIgjR44YJE6WO02srKwMcXFxCA0N1WoPDQ1FbGysiaJqPtRqNQDA2dkZAJCWloacnByt+VAoFAgJCeF86Nlbb72FkSNHYsiQIVrtnAPDO3jwIIKCgvCHP/wBbm5uCAwMxNatW6XjnAPD69+/P44dO4arV68CABITE3H69GmMGDECAOfA2Orye8fFxaG8vFyrj0qlQkBAgMHmxMogo1Kd/fLLL6isrIS7u7tWu7u7O3JyckwUVfMghMD8+fPRv39/BAQEAID0m9c2Hzdv/v/27j0sqmr/H/h7GO4DEoIwjFwEyStoCmmhBSiJhSk/PZlmCWkXMkm8lLdM63ip8y0r6xx7NCUKE62wtE4qJKAcb8hFIDlKCYIKkTcGFQdk1u8PH/dp4pIke2aw9+t59vO4116z9mfv9aifZ+291j5l9BjvVCkpKcjLy0NOTk6zY+wD+Z08eRJr167FnDlzsGjRIhw+fBgvvfQSbGxsMHXqVPaBEcyfPx+1tbXo06cPlEolmpqasGLFCkyePBkA/x4Y263c7+rqalhbW8PZ2blZHbn+v2aSZiYUCoXBvhCiWRl1rJkzZ6KwsBDZ2dnNjrE/5FNZWYlZs2Zh9+7dsLW1bbUe+0A+er0ewcHBWLlyJQBg0KBB+PHHH7F27VpMnTpVqsc+kM+WLVuQnJyMzz//HP3790dBQQESEhKg0WgQExMj1WMfGNefud9y9gkfd5qYq6srlEplsyy8pqamWUZPHSc+Ph7bt29HRkYGPD09pXK1Wg0A7A8Z5ebmoqamBkFBQbC0tISlpSWysrKwZs0aWFpaSveZfSAfDw8P9OvXz6Csb9++qKioAMC/B8bw8ssvY8GCBZg0aRICAwPx1FNPYfbs2Vi1ahUA9oGx3cr9VqvVaGhowMWLF1ut09GYpJmYtbU1goKCkJaWZlCelpaGkJAQE0V15xJCYObMmUhNTcWePXvg6+trcNzX1xdqtdqgPxoaGpCVlcX+6CAjR45EUVERCgoKpC04OBhTpkxBQUEB/Pz82AcyGzZsWLOlZ06cOAEfHx8A/HtgDFevXoWFheF/wUqlUlqCg31gXLdyv4OCgmBlZWVQp6qqCsXFxfL1iSzTEahdbi7BsWHDBnHs2DGRkJAgVCqVKC8vN3Vod5wXXnhBODk5iczMTFFVVSVtV69eleq8+eabwsnJSaSmpoqioiIxefJkTnuX2W9ndwrBPpDb4cOHhaWlpVixYoUoLS0VmzZtEvb29iI5OVmqwz6QV0xMjOjevbu0BEdqaqpwdXUVr7zyilSHfdCx6urqRH5+vsjPzxcAxOrVq0V+fr603NWt3O+4uDjh6ekp0tPTRV5enhgxYgSX4Pgr+Oc//yl8fHyEtbW1GDx4sLQkBHUsAC1uiYmJUh29Xi+WLl0q1Gq1sLGxEQ8++KAoKioyXdB/Ab9P0tgH8tuxY4cICAgQNjY2ok+fPmLdunUGx9kH8tJqtWLWrFnC29tb2NraCj8/P7F48WKh0+mkOuyDjpWRkdHiv/8xMTFCiFu73/X19WLmzJmia9euws7OTowZM0ZUVFTIFrNCCCHkGaMjIiIioj+L76QRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhJmlEREREZohJGhEREZEZYpJGREREZIaYpBERERGZISZpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSEmaURERERmiEkaERERkRlikkZERERkhpikEREREZkhkyRpOp3OFKclIiIi6jSMkqTt2rULsbGx6NmzJ6ysrGBvbw9HR0eEhoZixYoVOHv2rDHCICIiIuo0FEIIIVfjX3/9NebPn4/a2lo88sgjGDJkCLp37w47OztcuHABxcXF2LdvHw4cOIDY2Fj8/e9/R7du3eQKh4iIiKjTkDVJGzJkCJYsWYKoqChYWLQ+aHfmzBm8//77cHd3x9y5c+UKh4iIiKjTkDVJu9Pp9XqcPXsWjo6OUCgUpg6HiIiIzJwQAnV1ddBoNG0OYAGApdzBpKenY9iwYbCzs5P7VEZ39uxZeHl5mToMIiIi6mQqKyvh6enZZh3ZR9IsLCxgbW2NIUOGIDw8HOHh4QgJCYG1tbWcpzWK2tpa3HXXXaisrESXLl1MHQ4RERGZOa1WCy8vL1y6dAlOTk5t1pU9STtz5gz27NmDrKwsZGRkoKysDLa2trj//vulpG3o0KGwtJR9UK/DabVaODk5oba2lkkaERER/aH25A5GfyetsrISGRkZyMzMRGZmJk6dOgV7e3vU1dUZM4wOwSSNiIiI2qM9uYPRh6+8vLwwbNgw6HQ66HQ6nD9/Hk1NTcYOg4iIiMisGWUx25MnT2Ljxo146qmn4OnpicGDByM1NRUBAQH4/vvvcfHiRWOEQURERNRpyD6S5uPjA61Wi+HDh+PBBx9EfHw8goKCoFQq5T41ERERUacl+0jaze90KhQKKJVKKJXKP1wXhIiIiOivTvZsqbq6GgcOHMAjjzyCQ4cOISoqCs7OzhgzZgzefvtt5OTkQK/Xyx0GERERUadiki8OlJSUSDM8d+3aBYVCgUuXLhk7jNvG2Z1ERETUHu3JHYz+3PGXX35BYWEhCgsLcfToUdTV1UmPRImIiIjoBtmTtJqaGmzduhUzZsxA3759odFoEBMTg2PHjmHSpEnYs2dPu0fRli1bBoVCYbCp1WoAQGNjI+bPn4/AwECoVCpoNBpMnToVZ8+eNWhDp9MhPj4erq6uUKlUGDt2LE6fPt1Rl01ERER0W2Sf3alWq2FlZYXg4GBMmDABYWFhHfItz/79+yM9PV3avzlb9OrVq8jLy8OSJUswcOBAXLx4EQkJCRg7diyOHDki1U9ISMCOHTuQkpICFxcXzJ07F2PGjEFubi5nnhIREZHJyZ6kff/99xg+fDhUKlWHtmtpaSmNnv2Wk5MT0tLSDMo++OADDBkyBBUVFfD29kZtbS02bNiAzz77DBEREQCA5ORkeHl5IT09HZGRkR0aKxEREVF7yf64MzIyEiqVCsnJya3Wefnll9vdbmlpKTQaDXx9fTFp0iScPHmy1bq1tbVQKBS46667AAC5ublobGzEqFGjpDoajQYBAQHYv39/q+3odDpotVqDjYiIiEgORps4MHPmTHz77bfNymfPnt1mAteSoUOH4tNPP8WuXbuwfv16VFdXIyQkBOfPn29W99q1a1iwYAGeeOIJaRZFdXU1rK2t4ezsbFDX3d0d1dXVrZ531apVcHJykjYvL692xU1ERER0q4yWpKWkpODJJ5/E3r17pbL4+Hhs3boVGRkZ7Wrr4YcfxoQJExAYGIiIiAh89913AICkpCSDeo2NjZg0aRL0ej3+9a9//WG7QggoFIpWjy9cuBC1tbXSVllZ2a64iYiIiG6V0ZK00aNH46OPPkJ0dDSOHDmCGTNmIDU1FRkZGejTp89tta1SqRAYGIjS0lKprLGxERMnTkRZWRnS0tIM1iJRq9VoaGho9s3QmpoauLu7t3oeGxsbdOnSxWAjIiIikoNR10mbNGkSVqxYgeHDh2PHjh3IyspCr169brtdnU6HkpISeHh4APhfglZaWor09HS4uLgY1A8KCoKVlZXBBIOqqioUFxcjJCTktuMhIiIiul2yzu6cM2dOi+Vubm4YNGiQwSPI1atX33K78+bNw6OPPgpvb2/U1NRg+fLl0Gq1iImJwfXr1/G3v/0NeXl5+Pbbb9HU1CS9Z9a1a1dYW1vDyckJ06dPx9y5c+Hi4oKuXbti3rx50uNTIiIiIlOTNUnLz89vsbxnz57QarXS8bbeA2vJ6dOnMXnyZJw7dw7dunXDfffdh4MHD8LHxwfl5eXYvn07AOCee+4x+F1GRgbCwsIAAO+++y4sLS0xceJE1NfXY+TIkfjkk0+4RhoRERGZBZN8u/NOwW93EhERUXuY9bc7iYiIiOiPyZqkxcXF3fIyFVu2bMGmTZvkDIeIiIio05D1nbRu3bohICAAISEhGDt2LIKDg6HRaGBra4uLFy/i2LFjyM7ORkpKCrp3745169bJGQ4RERFRpyH7O2k1NTXYsGEDUlJSUFxcbHDM0dEREREReO655ww+0dRZ8J00IiIiao/25A5GnThw6dIlnDp1CvX19XB1dUXPnj3bPbPTnDBJIyIiovZoT+4g6+PO37vrrrukj5wTERERUes4u5OIiIjIDDFJIyIiIjJDTNKIiIiIzBCTNCIiIiIzxCSNiIiIyAwZbXbnoEGDWlxuQ6FQwNbWFv7+/oiNjUV4eLixQiIiIiIyW0YbSRs9ejROnjwJlUqF8PBwhIWFwcHBAT///DPuvfdeVFVVISIiAt98842xQiIiIiIyW0YbSTt37hzmzp2LJUuWGJQvX74cp06dwu7du7F06VL8/e9/x7hx44wVFhEREZFZMtoXB5ycnJCbmwt/f3+D8p9++glBQUGora3Ff//7X9x7772oq6szRki3jV8cICIiovZoT+5gtMedtra22L9/f7Py/fv3w9bWFgCg1+thY2NjrJCIiIiIzJbRHnfGx8cjLi4Oubm5uPfee6FQKHD48GF8/PHHWLRoEQBg165dGDRokLFCIiIiIjJbRv3A+qZNm/Dhhx/i+PHjAIDevXsjPj4eTzzxBACgvr5emu3ZGfBxJxEREbVHe3IHoyZpdxomaURERNQe7ckdjPa486aGhgbU1NRAr9cblHt7exs7FCIiIiKzZbQkrbS0FNOmTWs2eUAIAYVCgaamJmOFQkRERGT2jJakxcbGwtLSEt9++y08PDxa/PoAEREREd1gtCStoKAAubm56NOnj7FOSURERNRpGW2dtH79+uHcuXPGOh0RERFRp2a0JO2tt97CK6+8gszMTJw/fx5ardZgIyIiIqL/MdoSHBYWN/LB37+L1pknDnAJDiIiImoPs1yCIyMjw1inIiIiIur0jJakhYaGGutURERERJ2erElaYWEhAgICYGFhgcLCwjbrDhgwQM5QiIiIiDoVWZO0e+65B9XV1XBzc8M999wDhUKBll6B66zvpBERERHJRdbZnWVlZejWrZv055MnT6KsrKzZdvLkyXa1u2zZMigUCoNNrVZLx4UQWLZsGTQaDezs7BAWFoYff/zRoA2dTof4+Hi4urpCpVJh7NixOH369O1fNBEREVEHkDVJ8/HxkWZznjp1Ct27d4ePj4/B1r17d5w6dardbffv3x9VVVXSVlRUJB37xz/+gdWrV+PDDz9ETk4O1Go1HnroIdTV1Ul1EhISsG3bNqSkpCA7OxuXL1/GmDFjOKJHREREZsFoEwfCw8NRVVUFNzc3g/La2lqEh4e3OzmytLQ0GD27SQiB9957D4sXL8b48eMBAElJSXB3d8fnn3+O559/HrW1tdiwYQM+++wzREREAACSk5Ph5eWF9PR0REZG/smr7DhCCNQ3MmEkIiIyFTsrpUk/Y2m0JO3memi/d/78eahUqna3V1paCo1GAxsbGwwdOhQrV66En58fysrKUF1djVGjRkl1bWxsEBoaiv379+P5559Hbm4uGhsbDepoNBoEBARg//79rSZpOp0OOp1O2pdzEd76xib0e22XbO0TERFR2469EQl7a6OlSs3Ifuabo1kKhQKxsbGwsbGRjjU1NaGwsBAhISHtanPo0KH49NNP0atXL/zyyy9Yvnw5QkJC8OOPP6K6uhoA4O7ubvAbd3d36bFqdXU1rK2t4ezs3KzOzd+3ZNWqVXj99dfbFSsRERHRnyF7kubk5ATgxkiao6Mj7OzspGPW1ta477778Oyzz7arzYcfflj6c2BgIO6//3707NkTSUlJuO+++wC0/mWDtvxRnYULF2LOnDnSvlarhZeXV7tiv1V2Vkoce8P0j12JiIj+quyslCY9v+xJWmJiIgCgR48emDdv3p96tPlHVCoVAgMDUVpaiujoaAA3Rss8PDykOjU1NdLomlqtRkNDAy5evGgwmlZTU9PmqJ6NjY3BSKCcFAqFSYdYiYiIyLSM9oH1pUuXypKgATfeFSspKYGHhwd8fX2hVquRlpYmHW9oaEBWVpaUgAUFBcHKysqgTlVVFYqLi9v96JWIiIhIDkYdqvnyyy+xdetWVFRUoKGhweBYXl7eLbczb948PProo/D29kZNTQ2WL18OrVaLmJgYKBQKJCQkYOXKlbj77rtx9913Y+XKlbC3t8cTTzwB4MYj2OnTp2Pu3LlwcXFB165dMW/ePAQGBkqzPYmIiIhMyWgjaWvWrMHTTz8NNzc35OfnY8iQIXBxccHJkycN3jG7FadPn8bkyZPRu3dvjB8/HtbW1jh48CB8fHwAAK+88goSEhIwY8YMBAcH48yZM9i9ezccHR2lNt59911ER0dj4sSJGDZsGOzt7bFjxw4olaZ9/kxEREQEAArR0neaZNCnTx8sXboUkydPhqOjI44ePQo/Pz+89tpruHDhAj788ENjhNGhtFotnJycUFtbiy5dupg6HCIiIjJz7ckdjDaSVlFRIb3vZWdnJ63+/9RTT2Hz5s3GCoOIiIioUzBakqZWq3H+/HkANz4XdfDgQQA3vulppME8IiIiok7DaEnaiBEjsGPHDgDA9OnTMXv2bDz00EN4/PHH8f/+3/8zVhhEREREnYLR3knT6/XQ6/WwtLwxoXTr1q3Izs6Gv78/4uLiYG1tbYwwOhTfSSMiIqL2aE/uYLQkrS1nzpxB9+7dTR1GuzFJIyIiovYwy4kDLamurkZ8fDz8/f1NGQYRERGR2ZE9Sbt06RKmTJmCbt26QaPRYM2aNdDr9Xjttdfg5+eHgwcPYuPGjXKHQURERNSpyP7FgUWLFmHv3r2IiYnBzp07MXv2bOzcuRPXrl3D999/j9DQULlDICIiIup0ZE/SvvvuOyQmJiIiIgIzZsyAv78/evXqhffee0/uUxMRERF1WrI/7jx79iz69esHAPDz84OtrS2eeeYZuU9LRERE1KnJnqTp9XpYWVlJ+0qlEiqVSu7TEhEREXVqsj/uFEIgNjYWNjY2AIBr164hLi6uWaKWmpoqdyhEREREnYbsSVpMTIzB/pNPPin3KYmIiIg6PdmTtMTERLlPQURERHTHMelitkRERETUMiZpRERERGaISRoRERGRGWKSRkRERGSGjJakXbp0qdVjP/30k7HCICIiIuoUjJakPfLII7h27Vqz8uPHjyMsLMxYYRARERF1CkZL0pydnREdHY3r169LZSUlJQgLC8OECROMFQYRERFRp2C0JO2rr77ClStX8MQTT0AIgeLiYoSFhWHy5Ml4//33jRUGERERUadgtCTN1tYW3377LUpLS/HYY49h5MiRmDp1KlavXm2sEIiIiIg6DVm/OKDVag32FQoFtmzZgoiICEyYMAFLliyR6nTp0kXOUIiIiIg6FYUQQsjVuIWFBRQKRbPym6dUKBQQQkChUKCpqUmuMGSj1Wrh5OSE2tpaJplERET0h9qTO8g6kpaRkSFn80RERER3LFmTtNDQUDmbJyIiIrpjGW3iQGJiIr744otm5V988QWSkpKMFQYRERFRp2C0JO3NN9+Eq6trs3I3NzesXLnSWGEQERERdQpGS9JOnToFX1/fZuU+Pj6oqKgwVhhEREREnYLRkjQ3NzcUFhY2Kz969ChcXFxuq+1Vq1ZBoVAgISFBKrt8+TJmzpwJT09P2NnZoW/fvli7dq3B73Q6HeLj4+Hq6gqVSoWxY8fi9OnTtxULERERUUcwWpI2adIkvPTSS8jIyEBTUxOampqwZ88ezJo1C5MmTfrT7ebk5GDdunUYMGCAQfns2bOxc+dOJCcno6SkBLNnz0Z8fDy++eYbqU5CQgK2bduGlJQUZGdn4/LlyxgzZkynXA6EiIiI7ixGS9KWL1+OoUOHYuTIkbCzs4OdnR1GjRqFESNG/Ol30i5fvowpU6Zg/fr1cHZ2Njh24MABxMTEICwsDD169MBzzz2HgQMH4siRIwCA2tpabNiwAe+88w4iIiIwaNAgJCcno6ioCOnp6bd9vURERES3w2hJmrW1NbZs2YL//ve/2LRpE1JTU/Hzzz9j48aNsLa2/lNtvvjii4iKikJERESzY8OHD8f27dtx5swZCCGQkZGBEydOIDIyEgCQm5uLxsZGjBo1SvqNRqNBQEAA9u/f3+L5dDodtFqtwUZEREQkB1nXSWtJr1690KtXr9tuJyUlBXl5ecjJyWnx+Jo1a/Dss8/C09MTlpaWsLCwwMcff4zhw4cDAKqrq2Ftbd1sBM7d3R3V1dUttrlq1Sq8/vrrtx07ERER0R8xapJ2+vRpbN++HRUVFWhoaDA41p4PrVdWVmLWrFnYvXs3bG1tW6yzZs0aHDx4ENu3b4ePjw/27t2LGTNmwMPDo8WRt5tufqaqJQsXLsScOXOkfa1WCy8vr1uOm4iIiOhWGS1J++GHHzB27Fj4+vri+PHjCAgIQHl5OYQQGDx4cLvays3NRU1NDYKCgqSypqYm7N27Fx9++CFqa2uxaNEibNu2DVFRUQCAAQMGoKCgAG+//TYiIiKgVqvR0NCAixcvGoym1dTUICQkpMXz2tjYwMbG5k9cPREREVH7GO2dtIULF2Lu3LkoLi6Gra0tvvrqK1RWViI0NBSPPfZYu9oaOXIkioqKUFBQIG3BwcGYMmUKCgoK0NTUhMbGRlhYGF6eUqmEXq8HAAQFBcHKygppaWnS8aqqKhQXF7eapBEREREZi9FG0kpKSrB58+YbJ7W0RH19PRwcHPDGG29g3LhxeOGFF265LUdHRwQEBBiUqVQquLi4SOWhoaF4+eWXYWdnBx8fH2RlZeHTTz+VHqs6OTlh+vTpmDt3LlxcXNC1a1fMmzcPgYGBbT4OJSIiIjIGoyVpKpUKOp0OwI1ZlD///DP69+8PADh37lyHny8lJQULFy7ElClTcOHCBfj4+GDFihWIi4uT6rz77ruwtLTExIkTUV9fj5EjR+KTTz6BUqns8HiIiIiI2kMhhBDGOFF0dDSioqLw7LPP4pVXXsG2bdsQGxuL1NRUODs7d8q1ybRaLZycnFBbW4suXbqYOhwiIiIyc+3JHYw2krZ69WpcvnwZALBs2TJcvnwZW7Zsgb+/P959911jhUFERETUKRhtJO1OxJE0IiIiao/25A5Gm93p5+eH8+fPNyu/dOkS/Pz8jBUGERERUadgtCStvLy8xQ+X63Q6nDlzxlhhEBEREXUKsr+Ttn37dunPu3btgpOTk7Tf1NSEH374AT169JA7DCIiIqJORfYkLTo6GgCgUCgQExNjcMzKygo9evTAO++8I3cYRERERJ2K7EnazRX+fX19kZOTA1dXV7lPSURERNTpGW0JjrKyMmOdioiIiKjTkz1JO3ToEC5cuICHH35YKvv000+xdOlSXLlyBdHR0fjggw865YfLb65eotVqTRwJERERdQY3c4ZbWQFN9iRt2bJlCAsLk5K0oqIiTJ8+HbGxsejbty/+7//+DxqNBsuWLZM7lA5XV1cHAPDy8jJxJERERNSZ1NXVGUymbInsi9l6eHhgx44dCA4OBgAsXrwYWVlZyM7OBgB88cUXWLp0KY4dOyZnGLLQ6/U4e/YsHB0doVAobqstrVYLLy8vVFZWcmFcE2EfmB77wPTYB6bHPjA9OftACIG6ujpoNBpYWLS9EprsI2kXL16Eu7u7tJ+VlYXRo0dL+/feey8qKyvlDkMWFhYW8PT07NA2u3Tpwr+UJsY+MD32gemxD0yPfWB6cvXBH42g3ST7Yrbu7u7SpIGGhgbk5eXh/vvvl47X1dXByspK7jCIiIiIOhXZk7TRo0djwYIF2LdvHxYuXAh7e3s88MAD0vHCwkL07NlT7jCIiIiIOhXZH3cuX74c48ePR2hoKBwcHJCUlARra2vp+MaNGzFq1Ci5wzB7NjY2WLp0aaec5XqnYB+YHvvA9NgHpsc+MD1z6QPZJw7cVFtbCwcHByiVSoPyCxcuwMHBwSBxIyIiIvqrM1qSRkRERES3TvZ30oiIiIio/ZikEREREZkhJmlEREREZohJmpn417/+BV9fX9ja2iIoKAj79u0zdUh3pFWrVuHee++Fo6Mj3NzcEB0djePHjxvUEUJg2bJl0Gg0sLOzQ1hYGH788UcTRXznW7VqFRQKBRISEqQy9oH8zpw5gyeffBIuLi6wt7fHPffcg9zcXOk4+0Be169fx6uvvgpfX1/Y2dnBz88Pb7zxBvR6vVSHfdCx9u7di0cffRQajQYKhQJff/21wfFbud86nQ7x8fFwdXWFSqXC2LFjcfr0afmCFmRyKSkpwsrKSqxfv14cO3ZMzJo1S6hUKnHq1ClTh3bHiYyMFImJiaK4uFgUFBSIqKgo4e3tLS5fvizVefPNN4Wjo6P46quvRFFRkXj88ceFh4eH0Gq1Joz8znT48GHRo0cPMWDAADFr1iypnH0grwsXLggfHx8RGxsrDh06JMrKykR6err46aefpDrsA3ktX75cuLi4iG+//VaUlZWJL774Qjg4OIj33ntPqsM+6Fj//ve/xeLFi8VXX30lAIht27YZHL+V+x0XFye6d+8u0tLSRF5enggPDxcDBw4U169flyVmJmlmYMiQISIuLs6grE+fPmLBggUmiuivo6amRgAQWVlZQggh9Hq9UKvV4s0335TqXLt2TTg5OYmPPvrIVGHekerq6sTdd98t0tLSRGhoqJSksQ/kN3/+fDF8+PBWj7MP5BcVFSWmTZtmUDZ+/Hjx5JNPCiHYB3L7fZJ2K/f70qVLwsrKSqSkpEh1zpw5IywsLMTOnTtliZOPO02soaEBubm5zRb0HTVqFPbv32+iqP46amtrAQBdu3YFAJSVlaG6utqgP2xsbBAaGsr+6GAvvvgioqKiEBERYVDOPpDf9u3bERwcjMceewxubm4YNGgQ1q9fLx1nH8hv+PDh+OGHH3DixAkAwNGjR5GdnY1HHnkEAPvA2G7lfufm5qKxsdGgjkajQUBAgGx9IvsXB6ht586dQ1NTk8FH6IEb3zytrq42UVR/DUIIzJkzB8OHD0dAQAAASPe8pf44deqU0WO8U6WkpCAvLw85OTnNjrEP5Hfy5EmsXbsWc+bMwaJFi3D48GG89NJLsLGxwdSpU9kHRjB//nzU1taiT58+UCqVaGpqwooVKzB58mQA/HtgbLdyv6urq2FtbQ1nZ+dmdeT6/5pJmplQKBQG+0KIZmXUsWbOnInCwkJkZ2c3O8b+kE9lZSVmzZqF3bt3w9bWttV67AP56PV6BAcHY+XKlQCAQYMG4ccff8TatWsxdepUqR77QD5btmxBcnIyPv/8c/Tv3x8FBQVISEiARqNBTEyMVI99YFx/5n7L2Sd83Glirq6uUCqVzbLwmpqaZhk9dZz4+Hhs374dGRkZ8PT0lMrVajUAsD9klJubi5qaGgQFBcHS0hKWlpbIysrCmjVrYGlpKd1n9oF8PDw80K9fP4Oyvn37oqKiAgD/HhjDyy+/jAULFmDSpEkIDAzEU089hdmzZ2PVqlUA2AfGdiv3W61Wo6GhARcvXmy1TkdjkmZi1tbWCAoKQlpamkF5WloaQkJCTBTVnUsIgZkzZyI1NRV79uyBr6+vwXFfX1+o1WqD/mhoaEBWVhb7o4OMHDkSRUVFKCgokLbg4GBMmTIFBQUF8PPzYx/IbNiwYc2Wnjlx4gR8fHwA8O+BMVy9ehUWFob/BSuVSmkJDvaBcd3K/Q4KCoKVlZVBnaqqKhQXF8vXJ7JMR6B2ubkEx4YNG8SxY8dEQkKCUKlUory83NSh3XFeeOEF4eTkJDIzM0VVVZW0Xb16Varz5ptvCicnJ5GamiqKiorE5MmTOe1dZr+d3SkE+0Buhw8fFpaWlmLFihWitLRUbNq0Sdjb24vk5GSpDvtAXjExMaJ79+7SEhypqanC1dVVvPLKK1Id9kHHqqurE/n5+SI/P18AEKtXrxb5+fnScle3cr/j4uKEp6enSE9PF3l5eWLEiBFcguOv4J///Kfw8fER1tbWYvDgwdKSENSxALS4JSYmSnX0er1YunSpUKvVwsbGRjz44IOiqKjIdEH/Bfw+SWMfyG/Hjh0iICBA2NjYiD59+oh169YZHGcfyEur1YpZs2YJb29vYWtrK/z8/MTixYuFTqeT6rAPOlZGRkaL//7HxMQIIW7tftfX14uZM2eKrl27Cjs7OzFmzBhRUVEhW8wKIYSQZ4yOiIiIiP4svpNGREREZIaYpBERERGZISZpRERERGaISRoRERGRGWKSRkRERGSGmKQRERERmSEmaURERERmiEkaEZEJlZeXQ6FQoKCgwCjnW7JkCZ577jmjnOsmnU4Hb29v5ObmGvW8RJ0dkzQium01NTV4/vnn4e3tDRsbG6jVakRGRuLAgQMd0n5sbCyio6M7pK0/e36FQgGFQgFLS0t4e3vjhRdeaPah5Vtp5/fX4eXlhaqqKgQEBHRgxC375Zdf8P7772PRokUGMSkUCsTFxTWrP2PGDCgUCsTGxgIAPvroIzg6OuL69etSncuXL8PKygoPPPCAwW/37dsHhUKBEydOwMbGBvPmzcP8+fPluTCiOxSTNCK6bRMmTMDRo0eRlJSEEydOYPv27QgLC8OFCxdMHVqHGT16NKqqqlBeXo6PP/4YO3bswIwZM267XaVSCbVaDUtLyw6Ism0bNmzA/fffjx49ehiUe3l5ISUlBfX19VLZtWvXsHnzZnh7e0tl4eHhuHz5Mo4cOSKV7du3D2q1Gjk5Obh69apUnpmZCY1Gg169egEApkyZgn379qGkpESmqyO68zBJI6LbcunSJWRnZ+Ott95CeHg4fHx8MGTIECxcuBBRUVEAgGnTpmHMmDEGv7t+/TrUajU2btwIAPjyyy8RGBgIOzs7uLi4ICIiAleuXMGyZcuQlJSEb775RhrNyszMBACcOXMGjz/+OJydneHi4oJx48ahvLxcOsfNkauVK1fC3d0dd911F15//XVcv34dL7/8Mrp27QpPT08phrbcHCH09PTEqFGj8Pjjj2P37t3S8aamJkyfPh2+vr6ws7ND79698f7770vHW7uO3z/uzMzMhEKhwA8//IDg4GDY29sjJCQEx48fN4hn+fLlcHNzg6OjI5555hksWLAA99xzT5vXkJKSgrFjxzYrHzx4MLy9vZGamiqVpaamwsvLC4MGDZLKevfuDY1GI93/m/GOGzcOPXv2xP79+w3Kw8PDpX0XFxeEhIRg8+bNbcZIRP/DJI2IbouDgwMcHBzw9ddfQ6fTtVjnmWeewc6dO1FVVSWV/fvf/8bly5cxceJEVFVVYfLkyZg2bRpKSkqQmZmJ8ePHQwiBefPmYeLEidJIVlVVFUJCQnD16lWEh4fDwcEBe/fuRXZ2NhwcHDB69Gg0NDRI59mzZw/Onj2LvXv3YvXq1Vi2bBnGjBkDZ2dnHDp0CHFxcYiLi0NlZeUtX/PJkyexc+dOWFlZSWV6vR6enp7YunUrjh07htdeew2LFi3C1q1bAaDV62jN4sWL8c477+DIkSOwtLTEtGnTpGObNm3CihUr8NZbbyE3Nxfe3t5Yu3ZtmzFfvHgRxcXFCA4ObvH4008/jcTERGl/48aNBue8KSwsDBkZGdJ+RkYGwsLCEBoaKpU3NDTgwIEDBkkaAAwZMgT79u1rM04i+g3ZPt1ORH8ZX375pXB2dha2trYiJCRELFy4UBw9etSgTr9+/cRbb70l7UdHR4vY2FghhBC5ubkCgCgvL2+x/ZiYGDFu3DiDsg0bNojevXsLvV4vlel0OmFnZyd27dol/c7Hx0c0NTVJdXr37i0eeOABaf/69etCpVKJzZs3t3p9MTExQqlUCpVKJWxtbQUAAUCsXr26zfsyY8YMMWHChDavo6ysTAAQ+fn5QgghMjIyBACRnp4u1fnuu+8EAFFfXy+EEGLo0KHixRdfNGhn2LBhYuDAga3Gkp+fLwCIioqKZtc2btw48euvvwobGxtRVlYmysvLha2trfj111/FuHHjRExMjFR/3bp1QqVSicbGRqHVaoWlpaX45ZdfREpKiggJCRFCCJGVlSUAiJ9//tngXO+//77o0aNHm/eMiP6HI2lEdNsmTJiAs2fPYvv27YiMjERmZiYGDx6MTz75RKrzzDPPSCM1NTU1+O6776SRmoEDB2LkyJEIDAzEY489hvXr1//hS/m5ubn46aef4OjoKI3mde3aFdeuXcPPP/8s1evfvz8sLP73T527uzsCAwOlfaVSCRcXF9TU1LR5vvDwcBQUFODQoUOIj49HZGQk4uPjDep89NFHCA4ORrdu3eDg4ID169ejoqKi7ZvXigEDBkh/9vDwAAApxuPHj2PIkCEG9X+//3s33zeztbVt8birqyuioqKQlJSExMREREVFwdXVtVm98PBwXLlyBTk5Odi3bx969eoFNzc3hIaGIicnB1euXEFmZia8vb3h5+dn8Fs7OzuD99aIqG1M0oioQ9ja2uKhhx7Ca6+9hv379yM2NhZLly6Vjk+dOhUnT57EgQMHkJycjB49ekgzApVKJdLS0vD999+jX79++OCDD9C7d2+UlZW1ej69Xo+goCAUFBQYbCdOnMATTzwh1fvtI0kAUCgULZbp9fo2r0+lUsHf3x8DBgzAmjVroNPp8Prrr0vHt27ditmzZ2PatGnYvXs3CgoK8PTTTxs8em2P38aoUCika/592U1CiDbbu5lwtZX8Tps2DZ988gmSkpJafNQJAP7+/vD09ERGRgYyMjIQGhoKAFCr1fD19cV//vMfZGRkYMSIEc1+e+HCBXTr1q3NOInof5ikEZEs+vXrhytXrkj7Li4uiI6ORmJiIhITE/H0008b1FcoFBg2bBhef/115Ofnw9raGtu2bQMAWFtbo6mpyaD+4MGDUVpaCjc3N/j7+xtsTk5Osl/f0qVL8fbbb+Ps2bMAbsxyDAkJwYwZMzBo0CD4+/sbjOi1dh1/Ru/evXH48GGDst/OuGxJz5490aVLFxw7dqzVOjff52toaEBkZGSr9cLDw5GZmYnMzEyEhYVJ5aGhodi1axcOHjzY7H00ACguLjaYiEBEbWOSRkS35fz58xgxYgSSk5NRWFiIsrIyfPHFF/jHP/6BcePGGdR95plnkJSUhJKSEsTExEjlhw4dwsqVK3HkyBFUVFQgNTUVv/76K/r27QsA6NGjBwoLC3H8+HGcO3cOjY2NmDJlClxdXTFu3Djs27cPZWVlyMrKwqxZs3D69GnZrzssLAz9+/fHypUrAdwYYTpy5Ah27dqFEydOYMmSJcjJyTH4TUvX8WfEx8djw4YNSEpKQmlpKZYvX47CwsJmo2u/ZWFhgYiICGRnZ7daR6lUoqSkBCUlJVAqla3WCw8PR3Z2NgoKCqSRNOBGkrZ+/Xpcu3atxSRt3759GDVq1C1eJRExSSOi2+Lg4IChQ4fi3XffxYMPPoiAgAAsWbIEzz77LD788EODuhEREfDw8EBkZCQ0Go1U3qVLF+zduxePPPIIevXqhVdffRXvvPMOHn74YQDAs88+i969e0vve/3nP/+Bvb099u7dC29vb4wfPx59+/bFtGnTUF9fjy5duhjl2ufMmYP169ejsrIScXFxGD9+PB5//HEMHToU58+fb7aOWkvX8WdMmTIFCxcuxLx58zB48GCUlZUhNja21ffNbnruueeQkpLS5qPdLl26/OH9Cw8PR319Pfz9/eHu7i6Vh4aGoq6uDj179oSXl5fBbw4cOIDa2lr87W9/u4UrJCIAUIg/epGBiKiDXL16FRqNBhs3bsT48eNNHc4d5aGHHoJarcZnn33Wah0hBO677z4kJCRg8uTJRowOeOyxxzBo0CCDrx0QUdvkX+KaiP7y9Ho9qqur8c4778DJyanFBVXp1l29ehUfffQRIiMjoVQqsXnzZqSnpyMtLa3N3ykUCqxbtw6FhYVGivQGnU6HgQMHYvbs2UY9L1Fnx5E0IpJdeXk5fH194enpiU8++QQjR440dUidWn19PR599FHk5eVBp9Ohd+/eePXVVzk6SXSHYZJGREREZIY4cYCIiIjIDDFJIyIiIjJDTNKIiIiIzBCTNCIiIiIzxCSNiIiIyAwxSSMiIiIyQ0zSiIiIiMwQkzQiIiIiM8QkjYiIiMgM/X/Etm9csEIJtQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -213,7 +214,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -263,7 +264,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAM4CAYAAABBca9RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1yV5fvA8c/hsKeyh4DgQAX3QHFvLTVHpbbMlX2tzMyGv4ZapmVlVqY2NMvVMkvL3DlwoKK4BwooCojsvZ/fH8BJBAdyBuD1fr3O6+U55znPcx0QuM59X/d1qxRFURBCCCGEEDWekaEDEEIIIYQQ2iGJnRBCCCFELSGJnRBCCCFELSGJnRBCCCFELSGJnRBCCCFELSGJnRBCCCFELSGJnRBCCCFELSGJnRBCCCFELSGJnRBCCCFELSGJnRCi0lasWIFKpUKlUrFr165yzyuKQsOGDVGpVPTo0UOr11apVMyaNavSr4uKikKlUrFixYp7Ov769eu8+eabNG/eHGtra8zNzWnUqBEvv/wy4eHhlb5+ZSQlJTFq1CicnZ1RqVQMHToUuP/3rm8xMTHMmjWLsLCwcs/NmjULlUql/6CEeEAYGzoAIUTNZWNjw7Jly8olb7t37+bSpUvY2NgYJrAqOnToEIMGDUJRFF588UU6deqEqakp58+fZ9WqVXTo0IHk5GSdXf/9999n/fr1LF++nAYNGmBvbw/AgQMHqFevns6uqy0xMTHMnj2b+vXr06pVqzLPTZgwgQEDBhgmMCEeAJLYCSHu28iRI1m9ejVfffUVtra2mseXLVtGp06dSEtLM2B09yctLY1HHnkEc3Nz9u/fXyaR6tGjB5MmTeK3337TaQynTp2iQYMGPPnkk2Ue79ixo06vezvZ2dmYm5trZaStXr16NSI5FaKmkqlYIcR9Gz16NABr167VPJaamsq6desYN25cha9JSkpi8uTJeHh4YGpqiq+vL2+99Ra5ublljktLS2PixIk4ODhgbW3NgAEDuHDhQoXnDA8P54knnsDZ2RkzMzOaNm3KV199dV/v6dtvvyUuLo758+ffNgF59NFHy9zfsGEDnTp1wtLSEhsbG/r27cuBAwfKHFM6BXn69GlGjx6NnZ0dLi4ujBs3jtTUVOC/6eLt27dz9uzZctPdFU3FBgcH06lTJ8zNzfHw8OCdd97hu+++Q6VSERUVpTnudtO49evX59lnn9XcL51m37p1K+PGjcPJyQlLS0tyc3O5ePEiY8eOpVGjRlhaWuLh4cHgwYM5efKk5vW7du2iffv2AIwdO1bzHkqvXdFUbFFREfPnz6dJkyaYmZnh7OzMM888w9WrV8sc16NHDwICAjh8+DBdu3bF0tISX19fPvzwQ4qKisqcb86cOfj5+WFhYUGdOnVo0aIFn3/+ebn3L0RtI4mdEOK+2dra8uijj7J8+XLNY2vXrsXIyIiRI0eWOz4nJ4eePXvy448/Mm3aNP7++2+eeuop5s+fz/DhwzXHKYrC0KFDWblyJa+++irr16+nY8eODBw4sNw5z5w5Q/v27Tl16hSffvopf/31Fw8//DBTpkxh9uzZlX5PW7duRa1WM3jw4Hs6fs2aNTzyyCPY2tqydu1ali1bRnJyMj169CA4OLjc8SNGjKBx48asW7eON998kzVr1vDKK68A4ObmxoEDB2jdujW+vr4cOHCAAwcO0KZNmwqvfeLECfr27UtWVhY//PADS5cu5ejRo3zwwQeVft+3GjduHCYmJqxcuZLffvsNExMTYmJicHBw4MMPP2Tz5s189dVXGBsbExgYyPnz5wFo06YN33//PQBvv/225j1MmDDhttf63//+xxtvvEHfvn3ZsGED77//Pps3byYoKIiEhIQyx8bFxfHkk0/y1FNPsWHDBgYOHMiMGTNYtWqV5pj58+cza9YsRo8ezd9//83PP//M+PHjSUlJqfLXRYhqTxFCiEr6/vvvFUA5fPiw8u+//yqAcurUKUVRFKV9+/bKs88+qyiKovj7+yvdu3fXvG7p0qUKoPzyyy9lzvfRRx8pgLJ161ZFURTln3/+UQDl888/L3PcBx98oADKzJkzNY/1799fqVevnpKamlrm2BdffFExNzdXkpKSFEVRlMjISAVQvv/++zu+tyZNmiiurq739HUoLCxU3N3dlebNmyuFhYWax9PT0xVnZ2clKChI89jMmTMVQJk/f36Zc0yePFkxNzdXioqKNI91795d8ff3L3e9W9/7Y489plhZWSk3btwoE1OzZs0UQImMjLzta0t5e3srY8aM0dwv/d4+88wzd33/BQUFSl5entKoUSPllVde0Tx++PDh236tS78Opc6ePasAyuTJk8scFxISogDK//3f/2ke6969uwIoISEhZY5t1qyZ0r9/f839QYMGKa1atbpr/ELURjJiJ4Soku7du9OgQQOWL1/OyZMnOXz48G2nYXfu3ImVlVW5qczSqcAdO3YA8O+//wKUqzF74oknytzPyclhx44dDBs2DEtLSwoKCjS3hx56iJycHA4ePKiNt1mh8+fPExMTw9NPP42R0X+/Tq2trRkxYgQHDx4kKyurzGuGDBlS5n6LFi3IyckhPj6+0tffvXs3vXr1wtHRUfOYkZERjz/+eKXPdasRI0aUe6ygoIC5c+fSrFkzTE1NMTY2xtTUlPDwcM6ePXtf1yn9Xt88HQzQoUMHmjZtqvk/UcrV1ZUOHTqUeaxFixZcvny5zGuPHz/O5MmT2bJlS42s9RTifkliJ4SoEpVKxdixY1m1ahVLly6lcePGdO3atcJjExMTcXV1LVdj5ezsjLGxMYmJiZrjjI2NcXBwKHOcq6trufMVFBTw5ZdfYmJiUub20EMPAZSbyrsbLy8vbty4QWZm5l2PLY3Xzc2t3HPu7u4UFRWVWz1763syMzMDihcoVFZiYiIuLi7lHq/oscqq6D1NmzaNd955h6FDh7Jx40ZCQkI4fPgwLVu2vK/44e5fw9LnS9369YPir+HN158xYwaffPIJBw8eZODAgTg4ONC7d2+OHDlyXzEKUZNIYieEqLJnn32WhIQEli5dytixY297nIODA9evX0dRlDKPx8fHU1BQoBl5cnBwoKCgoNwf9bi4uDL369ati1qt5tlnn+Xw4cMV3koTvHvVv39/CgsL2bhx412PLU0yYmNjyz0XExODkZERdevWrdT1K6P063mrW79OUJz83LpABSj3NS5V0QrYVatW8cwzzzB37lz69+9Phw4daNeuXaWT55vd7Wt482jkvTI2NmbatGkcPXqUpKQk1q5dS3R0NP379y83gipEbSOJnRCiyjw8PHjttdcYPHgwY8aMue1xvXv3JiMjgz/++KPM4z/++KPmeYCePXsCsHr16jLHrVmzpsx9S0tLevbsybFjx2jRogXt2rUrd6tohOdOxo8fj6urK6+//jrXrl2r8Jjff/8dAD8/Pzw8PFizZk2ZZDUzM5N169ZpVsrqSvfu3dm5c2eZxKqoqIhff/213LH169fnxIkTZR7buXMnGRkZ93w9lUqlGWEs9ffff5f7OlVmFLJXr14AZRY/ABw+fJizZ89q/k/crzp16vDoo4/ywgsvkJSUVGalsBC1kfSxE0JoxYcffnjXY5555hm++uorxowZQ1RUFM2bNyc4OJi5c+fy0EMP0adPHwD69etHt27deP3118nMzKRdu3bs27ePlStXljvn559/TpcuXejatSv/+9//qF+/Punp6Vy8eJGNGzeyc+fOSr0POzs7/vzzTwYNGkTr1q3LNCgODw9n1apVHD9+nOHDh2NkZMT8+fN58sknGTRoEJMmTSI3N5ePP/6YlJSUe/qaVMVbb73Fxo0b6d27N2+99RYWFhYsXbpUM418c93f008/zTvvvMO7775L9+7dOXPmDIsWLcLOzu6erzdo0CBWrFhBkyZNaNGiBaGhoXz88cfl2sI0aNAACwsLVq9eTdOmTbG2tsbd3R13d/dy5/Tz8+O5557jyy+/xMjIiIEDBxIVFcU777yDp6enZsVwZQwePJiAgADatWuHk5MTly9fZuHChXh7e9OoUaNKn0+IGsXQqzeEEDXPzati7+TWVbGKoiiJiYnK888/r7i5uSnGxsaKt7e3MmPGDCUnJ6fMcSkpKcq4ceOUOnXqKJaWlkrfvn2Vc+fOVbi6MzIyUhk3bpzi4eGhmJiYKE5OTkpQUJAyZ86cMsdwD6tiS8XFxSlvvPGG4u/vr1haWipmZmZKw4YNlUmTJiknT54sc+wff/yhBAYGKubm5oqVlZXSu3dvZd++fWWOKV0NevMKVkX572t58wrWe10VqyiKsnfvXiUwMFAxMzNTXF1dlddee02zyjglJUVzXG5urvL6668rnp6eioWFhdK9e3clLCzstqtiK/reJicnK+PHj1ecnZ0VS0tLpUuXLsrevXuV7t27l/s+r127VmnSpIliYmJSJu5bV8UqSvFK3o8++khp3LixYmJiojg6OipPPfWUEh0dXea4231dxowZo3h7e2vuf/rpp0pQUJDi6OiomJqaKl5eXsr48eOVqKiocq8VorZRKcotxS5CCCFqtH79+hEVFXXbhs5CiNpLpmKFEKIGmzZtGq1bt8bT05OkpCRWr17Ntm3bWLZsmaFDE0IYgCR2QghRgxUWFvLuu+8SFxeHSqWiWbNmrFy5kqeeesrQoQkhDECmYoUQQgghaglpdyKEEEIIUUtIYieEEEIIUUtIYieEEEIIUUvI4gkDKCoqIiYmBhsbmwq37RFCCCGEuJmiKKSnp+Pu7l6m+fitJLEzgJiYGDw9PQ0dhhBCCCFqmOjo6HK7vdysxiZ2e/bs4eOPPyY0NJTY2FjWr1/P0KFDNc///vvvfP3114SGhpKYmMixY8do1apVmXPk5uYyffp01q5dS3Z2Nr1792bx4sV3/IIBLF68mI8//pjY2Fj8/f1ZuHAhXbt2vefYbWxsgOJvjq2t7T2/TgghhBAPprS0NDw9PTU5xO3U2MQuMzOTli1bMnbsWEaMGFHh8507d+axxx5j4sSJFZ5j6tSpbNy4kZ9++gkHBwdeffVVBg0aRGhoKGq1usLX/Pzzz0ydOpXFixfTuXNnvv76awYOHMiZM2fw8vK6p9hLp19tbW0lsRNCCCHEPbtbCVet6GOnUqnKjdiVioqKwsfHp9yIXWpqKk5OTqxcuZKRI0cC/02Rbtq0if79+1d4rcDAQNq0acOSJUs0jzVt2pShQ4cyb968e4o3LS0NOzs7UlNTJbETQgghxF3da+7wwK6KDQ0NJT8/n379+mkec3d3JyAggP3791f4mry8PEJDQ8u8Bor3Zbzda6B4yjctLa3MTQghqioxI5eHPt/L6G8Osv3MdYqKavzndCFEFdXYqdiqiouLw9TUlLp165Z53MXFhbi4uApfk5CQQGFhIS4uLvf8GoB58+Yxe/bsqgcthBA32Xw6jjOxxR8UD0Qk4utkxcSuvgxr7YG5ScXlJEKI2u2BHbG7HUVR7j5/fcvzd3vNjBkzSE1N1dyio6O1EqsQ4sEWEpEEQHMPO2zMjIm4kcmM30/S5aOdfL49nKTMPANHKITQtwd2xM7V1ZW8vDySk5PLjNrFx8cTFBRU4WscHR1Rq9XlRufi4+PLjeLdzMzMDDMzM+0ELoQQFH+gDIlMBGDGwCY0r2fHz4ej+X5fFNdSsvls+wWW7L7IiDb1GN/FB18nawNHLITQhwd2xK5t27aYmJiwbds2zWOxsbGcOnXqtomdqakpbdu2LfMagG3btt32NUIIoQuXE7O4npaLiVpFa6+62JibMKGrL7tf68EXo1vT3MOOnPwiVodcofeC3Tz34xEORyVRC9bLCSHuoMaO2GVkZHDx4kXN/cjISMLCwrC3t8fLy4ukpCSuXLlCTEwMAOfPnweKR+pcXV2xs7Nj/PjxvPrqqzg4OGBvb8/06dNp3rw5ffr00Zy3d+/eDBs2jBdffBGAadOm8fTTT9OuXTs6derEN998w5UrV3j++ef1+O6FEA+60tG6lvXqYGH6Xz2dsdqIIS3dGdzCjZDIJL7dE8GOc/FsPXOdrWeu08qzDhO7+tLf3wVj9QP72V6IWqvGJnZHjhyhZ8+emvvTpk0DYMyYMaxYsYINGzYwduxYzfOjRo0CYObMmcyaNQuAzz77DGNjYx5//HFNg+IVK1aU6WF36dIlEhISNPdHjhxJYmIi7733HrGxsQQEBLBp0ya8vb11+XaFEKKM0vq6QF/7Cp9XqVR09HWgo68DF+PTWRYcybqj1wiLTuGFNUfxtLdgfGcfHmvniZVZjf1TIIS4Ra3oY1fTSB87IURVdf5wJ9dSsvlxXAe6NXa6p9fcSM9l5cHLrDwQRXJWPgB2FiY8GejFs0H1cbY112XIQogquNfcQRI7A5DETghRFdFJWXSd/y9qIxUnZvar9Ihbdl4h645eZVlwJJEJmQCYqFU80sqDiV198XO985ZFQgj9u9fcQcbfhRCihgmJ/K/Nyf1Mo1qYqnmqozejO3ix/ex1vtsbweGoZH4LvcpvoVfp1tiJ57r60rmhw13bPwkhqhdJ7IQQooY5VLJw4nb1dfdKbaSiv78r/f1dOXolme/2RrD5VBx7Ltxgz4UbNHWz5bluPgxq4Y6JLLQQokaQn1QhhKhhSkfsOvo4aO2cbbzqsvjJtuya3pNng+pjYaLmbGwar/x8nK4f/cvXuy+RlpOvtesJIXRDauwMQGrshBD3Ky41h47zdmCkguMz+2FjbqKT66Rk5bE65Aor9kdxIz0XACtTNaM6eDG2c33q1bXUyXWFEBW719xBRuyEEKIGKe1f5+9up7OkDqCOpSkv9GxI8Bs9mf9oCxq7WJOZV8iy4Ei6f7yLl9Ye48TVFJ1dXwhxf6TGTgghapCDpf3rfKpWX3evzIzVPN7Ok8fa1mP3hRt8tzeS4IsJbDwew8bjMXT0tWdiV196+jljZCQLLYQwNEnshBCiBikdseugp8SulEqlooefMz38nDkdk8p3eyPZeDyGgxFJHIxIooGTFRO7+jK0tQfmJuq7n1AIoRNSY2cAUmMnhLgf8ek5dPhgByoVHHunL3UsTQ0aT2xqNiv2RbEm5ArpuQUAOFqb8kyn+jzV0Rt7K8PGJ0RtIjV2QghRyxwqWQ3r52Jj8KQOwM3OghkPNWX/jF68/XBTPOpYkJCRx4JtFwj6cAdv/3FS0wBZCKEfekvs9uzZQ0FBQbnHCwoK2LNnj77CEEKIGqt0f9iOvtprc6INNuYmTOjqy67XevD5qFYEeNiSk1/EqoNX6PXpLp778QhHopKQCSIhdE9vU7FqtZrY2FicnZ3LPJ6YmIizszOFhYX6CKNakKlYIcT96PfZbi5cz2DJk20Y2NzN0OHclqIoHIxI4tu9Eew8F695vLVXHSZ29aW/vytqWWghRKVUuy3FFEWpcGuaxMRErKys9BWGEELUSEmZeVy4ngHof+FEZalUKjo1cKBTAwcuxqfz3d5Ifj96jWNXUpi8+ihe9paM7+LDY+3qYWkqa/iE0Cad/0QNHz4cKP5Bf/bZZzEzM9M8V1hYyIkTJwgKCtJ1GEIIUaOVbiPWyNkaB2uzuxxdfTR0tuHDES14tZ8fKw9E8ePBy1xJymLmhtMs2HaBpzp6MaZTfZxtzQ0dqhC1gs4TOzs7O6B4xM7GxgYLCwvNc6ampnTs2JGJEyfqOgwhhKjRNP3rqrg/rKE42ZgxrZ8fz/dowLrQqywLjiQqMYuv/r3Et3sieaSVO4+398TSVLetUsxN1Pg6WlU4gyREbaDzxO77778HoH79+kyfPl2mXYUQ4j6U7g8bqMX9YQ3B0tSYpzvV54lAb7aduc63eyMIvZzMr6FX+TX0ql5iaOpmy3PdfBjUwh0TtTSHELWL9LEzAFk8IYSojNSsfFq9vxVFgUNv9cbZpnZNW4ZeTmZZcARHL6egoNs/SSlZ+eQWFAHgamvO2M71GR3oha0Ot2cTQhuq3eKJ69evM336dHbs2EF8fHy5Ze+VXRW7Z88ePv74Y0JDQ4mNjWX9+vUMHTpU87yiKMyePZtvvvmG5ORkAgMD+eqrr/D39wcgKioKHx+fCs/9yy+/8Nhjj1X43KxZs5g9e3aZx1xcXIiLi6tU/EIIca8ORSWhKODraFXrkjqAtt51aevdVi/XSsnKY3XIFVbsjyIuLYd5/5zjy50XGdnek7Gd61OvrqVe4hBCV/SW2D377LNcuXKFd955Bzc3tyrXN2RmZtKyZUvGjh3LiBEjyj0/f/58FixYwIoVK2jcuDFz5syhb9++nD9/HhsbGzw9PYmNjS3zmm+++Yb58+czcODAO17b39+f7du3a+6r1bJ9jhBCd0IiihdO1NT6uuqkjqUpL/RsyISuPmwIi+HbvRFcuJ7BsuBIVuyP4uHmbkzs6kvzenaGDlWI+6K3xC44OJi9e/fSqlUrrZxv4MCBt03AFEVh4cKFvPXWW5pVuT/88AMuLi6sWbOGSZMmoVarcXV1LfO69evXM3LkSKytre94bWNj43KvFUIIXakt9XXViZmxmsfaefJo23rsvnCD7/ZGEnwxgQ3HY9hwPIaOvvZM7OpLTz9njKTnnqhB9FY16unpqbeu45GRkcTFxdGvXz/NY2ZmZnTv3p39+/dX+JrQ0FDCwsIYP378Xc8fHh6Ou7s7Pj4+jBo1ioiICK3FLoQQN0vLyed0TCogI3a6oFKp6OHnzKoJgfw9pQvDWntgbKTiYEQS4384Qt/PdvPToSvk5D84TfRFzaa3xG7hwoW8+eabREVF6fxapfVuLi4uZR6/Uy3csmXLaNq06V176gUGBvLjjz+yZcsWvv32W+Li4ggKCiIxMfG2r8nNzSUtLa3MTQgh7kVoVDJFCnjZW+JmZ3H3F4j75u9ux2cjW7H3jZ5M6uaLjZkxl25k8ubvJ+ny0U6+2BFOUmaeocMU4o70NhU7cuRIsrKyaNCgAZaWlpiYlF2BlJSUpPVr3lrHd7vdL7Kzs1mzZg3vvPPOXc958/Rv8+bN6dSpEw0aNOCHH35g2rRpFb5m3rx55RZcCCHEvThY0pg4sJrvNlGbuNlZMOOhprzYqyE/H47m+31RXEvJZsG2CyzedZFH29ZjfBdffBylfZeofvSW2C1cuFBfl9LUv8XFxeHm9t9+ivHx8eVG8QB+++03srKyeOaZZyp9LSsrK5o3b054ePhtj5kxY0aZpC8tLQ1PT89KX0sI8eAJ0TQmlvo6fbMxN2FCV1/GBNVn08lYvt0bwalraaw6eIXVIVfo29SF57r50ta7rjQ8FtWG3hK7MWPG6OtS+Pj44OrqyrZt22jdujUAeXl57N69m48++qjc8cuWLWPIkCE4OTlV+lq5ubmcPXuWrl273vYYMzOzMlupCSHEvcjMLeDktZL6OhmxMxgTtRGPtPJgSEt3DkYk8d3eCHaci2frmetsPXOdVp51eK6bL/39XVHLQgthYHpL7K5cuXLH5728vCp1voyMDC5evKi5HxkZSVhYGPb29nh5eTF16lTmzp1Lo0aNaNSoEXPnzsXS0pInnniizHkuXrzInj172LRpU4XX6d27N8OGDePFF18EYPr06QwePBgvLy/i4+OZM2cOaWlpek1chRAPhtDLyRQWKXjUscDTXvqrGZpKpaJTAwc6NXDgYnw63+2N5Pej1wiLTmHy6qN42VsyrnN9HmvniZWZ3v68ClGG3v7n1a9f/45D1ZVtUHzkyBF69uypuV861TlmzBhWrFjB66+/TnZ2NpMnT9Y0KN66dSs2NjZlzrN8+XI8PDzKrKC92aVLl0hISNDcv3r1KqNHjyYhIQEnJyc6duzIwYMH8fb2rlT8QghxNyFSX1dtNXS24cMRLXi1nx8rD0Tx48HLXEnKYtbGMyzYdgFvB93X3zVzs2VcFx/8XG3ufrB4YOhtS7Hjx4+XuZ+fn8+xY8dYsGABH3zwgabf3INAthQTQtyLR5fs58jlZD4a0ZyR7Ss3qyH0KzuvkN+OXmXZ3giiErP0eu3ujZ2Y2NWXzg0dpNavFrvX3MHge8X+/ffffPzxx+zatcuQYeiVJHZCiLvJziukxewt5Bcq7Jreg/qyArNGKCxSOHolmYycAp1eJ7egiA3Hr7H5VBxFJX/Fm7rZ8lw3Hwa1cMdErbduZkJPqt1esbfTuHFjDh8+bOgwhBCiWjl2JZn8QgUXWzO8HaS+rqZQG6loX18/U+cDAly5nJjJ8uBIfjlylbOxabzy83Hmbz7Ps0H1GR3oha25yd1PJGoVvSV2tzblVRSF2NhYZs2aRaNGjfQVhhBC1AgHb9pGTKbXxO14O1gx+5EAXunbmNUhV/h+XxSxqTnM++ccX+68yMj2noztXJ96deXDwYNCb4ldnTp1KmwY7OnpyU8//aSvMIQQokYIiShZOCHbiIl7UMfSlBd6NmRCVx/+DIvh2z0RhMdnsCw4khX7o3i4uRsTu/rSvJ6doUMVOqa3xO7ff/8tc9/IyAgnJycaNmyIsbHBZ4SFEKLayMkv5Fh0ClA8YifEvTIzVvN4O08ea1uP3Rdu8O3eCPZdTGTD8Rg2HI+ho689z3XzpUdjZ4yk516tpLeMqnv37vq6lBBC1GgnrqaSV1CEo7UZDZxk0YSoPJVKRQ8/Z3r4OXM6JpXv9kay8XgMByOSOBiRRAMnKyZ29WVoaw/MTdSGDldokV6XzVy6dImXXnqJPn360LdvX6ZMmcKlS5f0GYIQQlR7mmlYH3uprxNV5u9ux2cjW7H3jZ5M6uaLjZkxl25k8ubvJ+ny0U6+2BFOUmaeocMUWqK3xG7Lli00a9aMQ4cO0aJFCwICAggJCcHf359t27bpKwwhhKj2QkoXTkh9ndAiNzsLZjzUlP0zevH2w03xqGNBQkYeC7ZdIOjDHbzzxymiEjINHaaoIr31sWvdujX9+/fnww8/LPP4m2++ydatWzl69Kg+wqgWpI+dEOJ28guLaDFrK9n5hWyZ2k12FRA6k19YxKaTsXy7N4JT14o7V6hU0K+ZC89186Wtt3ywqE6qXYNic3NzTp48Wa61yYULF2jRogU5OTn6CKNakMROCHE7oZeTGbFkP3UtTQh9u68UuAudUxSFgxFJfLs3gp3n4jWPt/aqw5CW7pga1/xmxyZGRnT3c8LF1tzQody3ateg2MnJibCwsHKJXVhYGM7OzvoKQwghqrXS/WE7+NhLUif0QqVS0amBA50aOHAxPp3v9kby+9FrHLuSwrErKYYOT2tM1CoeaeXBxK6+tXokXG+J3cSJE3nuueeIiIggKCgIlUpFcHAwH330Ea+++qq+whBCiGotJOK/xsRC6FtDZxs+HNGCV/v5sTrkMmdj0+7+ohogLjWH41dT+S30Kr+FXqVbYyeeq6X76+ptKlZRFBYuXMinn35KTEwMAO7u7rz22mtMmTKl1n1h70SmYoUQFSkoLKLl7K1k5hXy95Qu+LtLM1khtOXYlWS+2xvJP6diNfvrNnG14bluvgxqUf2nnKtdjd3N0tPTAbCxqb1DoXciiZ0QoiLHo1N45Kt92Jobc+zdfqhlKlYIrbuSmMXyfZH8ciSarLxCAFxszRjb2YfRHbyws6ie++vea+6g8/Q0OzubDRs2aJI5KE7obGxsSEtLY8OGDeTm5uo6DCGEqPZurq+TpE4I3fBysGTWEH/2v9mL1/r74WxjxvW0XD785xxB83bw3sYzXE3OMnSY903nid0333zD559/XuHonK2tLV988QXfffedrsMQQohqT+rrhNCf0v11977Rk48fbUFjF2sy8wpZvi+S7h/v4qW1xzhxNcXQYVaazhO71atXM3Xq1Ns+P3XqVH744QddhyGEENVaYZHCoShpTCyEvpkZq3msnSdbpnbjh3Ed6NLQkcIihY3HYxiyaB8jvz7A9jPXKSrSe+XafdH5qtjw8HBatmx52+dbtGhBeHi4rsMQQohq7WxsGuk5BVibGdPMTWpvhdA3lUpF98ZOdG/sxOmYVJbtjWTD8RhCIpMIiUzCt2R/3WHVfH9dnY/YFRQUcOPGjds+f+PGDQoKCip93j179jB48GDc3d1RqVT88ccfZZ5XFIVZs2bh7u6OhYUFPXr04PTp02WO6dGjByqVqsxt1KhRd7324sWL8fHxwdzcnLZt27J3795Kxy+EEDcr3UasXf26GKur9+o8IWo7f3c7FpTur9u9eH/diBuZzCjZX/fz7dV3f12d//bw9/dn+/btt31+27Zt+Pv7V/q8mZmZtGzZkkWLFlX4/Pz581mwYAGLFi3i8OHDuLq60rdv3zKLOKC4v15sbKzm9vXXX9/xuj///DNTp07lrbfe4tixY3Tt2pWBAwdy5cqVSr8HIYQoFRJRvHBC6uuEqD7c7CyYMbD8/rqfbS/eX/et9SeJuJFh6DDL0HliN27cON5//33++uuvcs9t3LiROXPmMG7cuEqfd+DAgcyZM4fhw4eXe660Z95bb73F8OHDCQgI4IcffiArK4s1a9aUOdbS0hJXV1fNzc7uzn2jFixYwPjx45kwYQJNmzZl4cKFeHp6smTJkkq/B105eTXV0CEIISqh6Kb6ug4+Ul8nRHVjY27ChK6+7H6tB1+Mbk1zDzty8otYHXKF3gt289yPRzgclYQBOsiVo/PE7rnnnmPo0KEMGTKEZs2aMWzYMIYPH07Tpk0ZOnQogwcP5rnnntPqNSMjI4mLi6Nfv36ax8zMzOjevTv79+8vc+zq1atxdHTE39+f6dOnlxvRu1leXh6hoaFlzgvQr1+/cue9WW5uLmlpaWVuuvJn2DUGLwpmzl9nakyhpxAPugvx6aRk5WNhoqZFPWlKLER1Zaw2YkhLdza82JmfnutI7ybOKApsPXOdx5YeYMSS/eQWFBo2Rn1cZNWqVQwZMoQ1a9Zw4cIFFEXBz8+P2bNn8/jjj2v9enFxcQC4uLiUedzFxYXLly9r7j/55JP4+Pjg6urKqVOnmDFjBsePH2fbtm0VnjchIYHCwsIKz1t6zYrMmzeP2bNn3+/bqZQb6cU9Ab8LjiQhI5f5j7as9t20hXjQlbY5aetdFxOprxOi2lOpVHT0daCjb/H+usuCI1l39BoO1maYGRt2YYXe9op9/PHHdZLE3cmt25QpilLmsYkTJ2r+HRAQQKNGjWjXrh1Hjx6lTZs2933eW82YMYNp06Zp7qelpeHp6XnP76MyJnT1pa6lKa+vO8EfYTEkZuax9Km2WJnp7VsthKik0sbEgTINK0SN09DZhnnDWzCtrx/ZeYYdrQM9TMUagqurK0C5UbT4+Phyo203a9OmDSYmJrdtv+Lo6Ihara70ec3MzLC1tS1z06URbevx3Zh2WJio2RuewOhvD5KQIbt7CFEdKYrCocjS/nWycEKImsrJxgwvB0tDh1E7E7vS6dWbp1Tz8vLYvXs3QUFBt33d6dOnyc/Px83NrcLnTU1Nadu2bbmp2m3btt3xvIbQ08+ZNRMDqWtpwomrqTy6ZD9XEmvuFilC1FaXbmSQkJGHmbERLT2lvk4IUTU1NrHLyMggLCyMsLAwoHjBRFhYGFeuXEGlUjF16lTmzp3L+vXrOXXqFM8++yyWlpY88cQTAFy6dIn33nuPI0eOEBUVxaZNm3jsscdo3bo1nTt31lynd+/eZVqqTJs2je+++47ly5dz9uxZXnnlFa5cucLzzz+v1/d/L1p71eW3/wXhUceCqMQshi/Zz+kYWTErRHVysKS+rrVXHYPX5gghar4aW3h15MgRevbsqblfWsM2ZswYVqxYweuvv052djaTJ08mOTmZwMBAtm7dqtmz1tTUlB07dvD555+TkZGBp6cnDz/8MDNnzkSt/u+X66VLl0hISNDcHzlyJImJibz33nvExsYSEBDApk2b8Pb21tM7r5wGTtb8PjmIMcsPcS4unZFfH+SbZ9oS1MDR0KEJIfivMbH0rxNCaINKqQ5NVx4waWlp2NnZkZqaqvN6u1Kp2fk89+MRQiKTMFUb8dnIVjzcouIpZyGEfiiKQuDcHcSn57JmYqB84BJC3Na95g46HbGrqHnw7fz+++86jETYWZjww7gOvPJzGP+ciuPFtUdJyPBnTFB9Q4cmxAMrKjGL+PRcTNVGtPGqa+hwhBC1gE4Tu7vt4iD0y9xEzaIn2jBzwylWHbzCzA2nuZGey6v9Gt+xXYsQQjdKtxFr6WlXrTcVF0LUHDpN7L7//ntdnl7cB7WRivcfCcDZxpwF2y6w6N+LxKfnMHdYc9l4XAg9k/o6IYS2yV/yB5BKpWJK70bMG94cIxX8cuQqz68KrRaNFYV4UCiKohmxC/SVxsRCCO3Q6Yhd69at73mK7+jRo7oMRVRgdAcv7K1MmbL2GNvPxvPUshCWjWlHHUtTQ4cmRK13NTmbmNQcjI1UtPWW+johhHboNLEbOnSoLk8vtKC/vyurJgQyfsVhQi8n8+jSA/w4rgPudSwMHZoQtdrBktG65vXssDStsZ2nhBDVjE5/m8ycOVOXpxda0r6+Pb8+X9zr7mJ8BiOW7OeHcR1o7GJj6NCEqLWkvk4IoQt6rbFLSUnhu+++Y8aMGSQlFf9SO3r0KNeuXdNnGKICfq42rJscRENna2JTc3h0yX6ORCUZOiwhaq2QSKmvE0Jon94SuxMnTtC4cWM++ugjPvnkE1JSUgBYv349M2bM0FcY4g486ljw66ROtPaqQ1pOAU9+F8K2M9cNHZYQtU5MSjbRSdkYqaCd1NcJIbRIb4ndtGnTePbZZwkPD8fc3Fzz+MCBA9mzZ4++whB3UdfKlDUTOtK7iTO5BUVMWnmEnw5dMXRYQtQqh0qmYQM87LAxNzFwNEKI2kRvid3hw4eZNGlSucc9PDyIi4vTVxjiHliYqvn66bY81rYeRQq8+ftJvtwRjuw+J4R2aKZhfWQaVgihXXpL7MzNzUlLSyv3+Pnz53FyctJXGOIeGauNmP9oC17o2QCAT7ddYOaG0xQWSXInRFWFRMjCCSGEbugtsXvkkUd47733yM/PB4qb5F65coU333yTESNG6CsMUQkqlYrX+jdh1uBmqFTw44HLvLT2KDn50shYiPsVn5ZDREImKhW0lxE7IYSW6S2x++STT7hx4wbOzs5kZ2fTvXt3GjZsiI2NDR988IG+whD34dnOPnw5ujWmaiM2nYzj2e8PkZaTb+iwhKiRStucNHW1xc5C6uuEENqlt66Ytra2BAcHs3PnTo4ePUpRURFt2rShT58++gpBVMGgFu7YW5ry3MpQDkYkMfLrg7w7qBkm6nvbWeR+1atriaud+d0PFKKGkDYnQghdUilSEa93aWlp2NnZkZqaiq2traHDqZRT11J59vvDJGTk6uV6RioYGODGhK4+tPaSthCi5uu7YDfh8RksfaotAwJcDR2OEKKGuNfcQecjdjt37uTFF1/k4MGD5QJJTU0lKCiIpUuX0rVrV12HIrQgwMOO3/8XxP+tP8nV5CydXqtQUYhOyubvk7H8fTKW9vXrMrGrL32aumBkpNuRQiF0ITEjl/D4DAA6SH2dEEIHdJ7YLVy4kIkTJ1aYXdrZ2TFp0iQWLFhQ6cRuz549fPzxx4SGhhIbG8v69evL7E2rKAqzZ8/mm2++ITk5mcDAQL766iv8/f0BSEpKYubMmWzdupXo6GgcHR0ZOnQo77//PnZ2dre97qxZs5g9e3aZx1xcXB6oli1eDpasmhCol2udjU3ju72RbDh+jcNRyRyOCsXH0YrxXXwY0aYeFqZqvcQhhDaU9q/zc7HB3srUwNEIIWojnS+eOH78OAMGDLjt8/369SM0NLTS583MzKRly5YsWrSowufnz5/PggULWLRoEYcPH8bV1ZW+ffuSnp4OQExMDDExMXzyySecPHmSFStWsHnzZsaPH3/Xa/v7+xMbG6u5nTx5stLxi3vT1M2WTx9vSfAbvfhfjwbYmhsTmZDJ23+cIujDHSzYdkFv08JCVJVmf1iprxNC6IjOR+yuX7+OicntV34ZGxtz48aNSp934MCBDBw4sMLnFEVh4cKFvPXWWwwfPhyAH374ARcXF9asWcOkSZMICAhg3bp1mtc0aNCADz74gKeeeoqCggKMjW//pTE2NsbVVWpj9MnF1pw3BjThxZ4N+eVINMuCI7manM0XO8JZuvsSI9rUY0JXHxo4WRs6VCFu62BEaWNi6V8nhNANnY/YeXh43HFE68SJE7i5uWn1mpGRkcTFxdGvXz/NY2ZmZnTv3p39+/ff9nWlBYl3SuoAwsPDcXd3x8fHh1GjRhEREaG12MWdWZkZM7azD7um9+CrJ9rQ0rMOeQVFrD10hd6f7mbCD4c5GJEou2SIaiclK4/z14tnDKS+TgihKzpP7B566CHeffddcnJyyj2XnZ3NzJkzGTRokFavWVrv5uLiUubxO9XCJSYm8v7771e47dnNAgMD+fHHH9myZQvffvstcXFxBAUFkZiYeNvX5ObmkpaWVuYmqsZYbcTDLdz4Y3IQvz7fib7NXFCpYPvZeEZ9c5BHvtrHxuMxFBQWGTpUIYDi+jpFgQZOVjjZmBk6HCFELaXzqdi3336b33//ncaNG/Piiy/i5+eHSqXi7NmzfPXVVxQWFvLWW2/p5NoqVdmVk4qilHsMipcQP/zwwzRr1oyZM2fe8Zw3T/82b96cTp060aBBA3744QemTZtW4WvmzZtXbsGF0A6VSkX7+va0r29PxI0MlgVH8lvoVU5cTeWltcfwqGPBuC4+jGzvibWZ3to2ClHOf/V1Mg0rhNAdnY/Yubi4sH//fgICApgxYwbDhg1j6NCh/N///R8BAQHs27ev3MhaVZXWv906OhcfH1/uWunp6QwYMABra2vWr19/x3rAilhZWdG8eXPCw8Nve8yMGTNITU3V3KKjoyt1DXFvfJ2s+WBYc/a/2YtX+jTGwcqUaynZvP/XGTrN28G8f84Sl1p+5FgIfdA0JpZpWCGEDullCMPb25tNmzaRnJzMxYsXURSFRo0aUbeubhrO+vj44OrqyrZt22jdujUAeXl57N69m48++khzXFpaGv3798fMzIwNGzZgbl75HQ5yc3M5e/bsHdu1mJmZYWYmUy/64mBtxst9GjGpuy/rj13j270RRNzI5OvdESzbG8mQVu5M7OpLU7ea1Rxa1FxpOfmciSkuwegoI3ZCCB3S69xU3bp1ad++vVbOlZGRwcWLFzX3IyMjCQsLw97eHi8vL6ZOncrcuXNp1KgRjRo1Yu7cuVhaWvLEE08AxSN1/fr1Iysri1WrVpWpfXNyckKtLu6P1rt3b4YNG8aLL74IwPTp0xk8eDBeXl7Ex8czZ84c0tLSGDNmjFbel9AecxM1ozt4MbKdJzvPxfPt3ghCIpP4/eg1fj96ja6NHJnQ1ZdujRwrnKIXQluORCVRpEB9B0tcbGWLPCGE7tTYoqMjR47Qs2dPzf3S+rYxY8awYsUKXn/9dbKzs5k8ebKmQfHWrVuxsbEBIDQ0lJCQEAAaNmxY5tyRkZHUr18fgEuXLpGQkKB57urVq4wePZqEhAScnJzo2LEjBw8exNvbW5dvV1SBkZGKPs1c6NPMhePRKXy7N4J/TsWxNzyBveEJuNmZY6Xj+jszYyMeau7Gk4Fe1LGUxrQPmpCIkvo6aXMihNAx2SvWAGryXrG1RXRSFt/vi+Lnw1fIzCvU23UtTNSMbO/JuM4+eDlY6u26wrAe+Wofx6NTWPB4S4a3qWfocIQQNdC95g6S2BmAJHbVR1pOPmdj0tD1D0F0UhbL90VxNrZ4ut9IBQMCXJnY1ZfWXrqpNRXVQ0ZuAS1nb6WwSGHfm73wqGNh6JCEEDXQveYONXYqVghtsDU30Uv7iY6+Djzath77Libyzd4I9ly4waaTcWw6GUc777pM7OZLn6YuqI2k1q+2Cb2cTGGRQr26FpLUCSF0ThI7IfREpVLRpZEjXRo5ci4uje/2RvJn2DWOXE7myMpQfBytGNfFh0fb1MPCVG3ocIWWhMg2YkIIPdJ5HzshRHlNXG355LGWBL/Ri8k9GmBrbkxkQibv/HGKoA93sGDbBRIycg0dptCC/xoTS/86IYTuSY2dAUiNnbhVZm4BvxyJZllwJFeTswEwNTZiRBsPxnfxpaGztYEjFPcjO6+QFrO3kF+osOe1nrJgRghx3+41d5AROyGqASszY8Z29mHX9B589UQbWnrWIa+giLWHoumzYDfjVxzmYEQi8jmsZjl6JZn8QgVXW3M87aW+Tgihe1JjJ0Q1Yqw24uEWbjzU3JUjl5P5Zk8E289eZ8e5eHaci6dFPTsmdPXloQBXjNXyuay609TX+dpLE2whhF5IYidENaRSqWhf35729e2JuJHBsuBIfgu9yomrqUxZe4yP6lgwrosPI9t7Yq3j5sri/h2MlMbEQgj9kho7A5AaO3E/EjNyWXnwMisPXCYxMw8AG3Njngj0YmyQD652slVVdZKTX0iL2VvJKyhix6vdaeAkdZJCiPsnDYqrMUnsRFXk5Bfy+9FrfLc3goiETACMjVQMbumOv7v8f6ou4lJz+C44EkdrMw6/1VumYoUQVSKJXTUmiZ3QhqIihZ3n4vlmbwSHSqb8RPUzqIUbi55oY+gwhBA1nOw8IUQtZ2Skok8zF/o0c+F4dAq/hV4lI7fA0GGJm5gZG/FcN19DhyGEeIBIYidELdDSsw4tPesYOgwhhBAGJv0ShBBCCCFqCUnshBBCCCFqCZmKNYDS9SppaWkGjkQIIYQQNUFpznC3Na+S2BlAeno6AJ6engaORAghhBA1SXp6OnZ2drd9XtqdGEBRURExMTHY2NhIb6t7lJaWhqenJ9HR0dIiphqT71PNId+rmkG+TzWHrr9XiqKQnp6Ou7s7Rka3r6STETsDMDIyol69eoYOo0aytbWVX241gHyfag75XtUM8n2qOXT5vbrTSF0pWTwhhBBCCFFLSGInhBBCCFFLSGInagQzMzNmzpyJmZmZoUMRdyDfp5pDvlc1g3yfao7q8r2SxRNCCCGEELWEjNgJIYQQQtQSktgJIYQQQtQSktgJIYQQQtQSktgJIYQQQtQSktiJamvevHm0b98eGxsbnJ2dGTp0KOfPnzd0WOIezJs3D5VKxdSpUw0dirjFtWvXeOqpp3BwcMDS0pJWrVoRGhpq6LDELQoKCnj77bfx8fHBwsICX19f3nvvPYqKigwd2gNtz549DB48GHd3d1QqFX/88UeZ5xVFYdasWbi7u2NhYUGPHj04ffq0XmOUxE5UW7t37+aFF17g4MGDbNu2jYKCAvr160dmZqahQxN3cPjwYb755htatGhh6FDELZKTk+ncuTMmJib8888/nDlzhk8//ZQ6deoYOjRxi48++oilS5eyaNEizp49y/z58/n444/58ssvDR3aAy0zM5OWLVuyaNGiCp+fP38+CxYsYNGiRRw+fBhXV1f69u2r2SNeH6Tdiagxbty4gbOzM7t376Zbt26GDkdUICMjgzZt2rB48WLmzJlDq1atWLhwoaHDEiXefPNN9u3bx969ew0diriLQYMG4eLiwrJlyzSPjRgxAktLS1auXGnAyEQplUrF+vXrGTp0KFA8Wufu7s7UqVN54403AMjNzcXFxYWPPvqISZMm6SUuGbETNUZqaioA9vb2Bo5E3M4LL7zAww8/TJ8+fQwdiqjAhg0baNeuHY899hjOzs60bt2ab7/91tBhiQp06dKFHTt2cOHCBQCOHz9OcHAwDz30kIEjE7cTGRlJXFwc/fr10zxmZmZG9+7d2b9/v97iMNbblYSoAkVRmDZtGl26dCEgIMDQ4YgK/PTTTxw9epTDhw8bOhRxGxERESxZsoRp06bxf//3fxw6dIgpU6ZgZmbGM888Y+jwxE3eeOMNUlNTadKkCWq1msLCQj744ANGjx5t6NDEbcTFxQHg4uJS5nEXFxcuX76stzgksRM1wosvvsiJEycIDg42dCiiAtHR0bz88sts3boVc3NzQ4cjbqOoqIh27doxd+5cAFq3bs3p06dZsmSJJHbVzM8//8yqVatYs2YN/v7+hIWFMXXqVNzd3RkzZoyhwxN3oFKpytxXFKXcY7okiZ2o9l566SU2bNjAnj17qFevnqHDERUIDQ0lPj6etm3bah4rLCxkz549LFq0iNzcXNRqtQEjFABubm40a9aszGNNmzZl3bp1BopI3M5rr73Gm2++yahRowBo3rw5ly9fZt68eZLYVVOurq5A8cidm5ub5vH4+Phyo3i6JDV2otpSFIUXX3yR33//nZ07d+Lj42PokMRt9O7dm5MnTxIWFqa5tWvXjieffJKwsDBJ6qqJzp07l2sZdOHCBby9vQ0UkbidrKwsjIzK/olWq9XS7qQa8/HxwdXVlW3btmkey8vLY/fu3QQFBektDhmxE9XWCy+8wJo1a/jzzz+xsbHR1C/Y2dlhYWFh4OjEzWxsbMrVPlpZWeHg4CA1kdXIK6+8QlBQEHPnzuXxxx/n0KFDfPPNN3zzzTeGDk3cYvDgwXzwwQd4eXnh7+/PsWPHWLBgAePGjTN0aA+0jIwMLl68qLkfGRlJWFgY9vb2eHl5MXXqVObOnUujRo1o1KgRc+fOxdLSkieeeEJ/QSpCVFNAhbfvv//e0KGJe9C9e3fl5ZdfNnQY4hYbN25UAgICFDMzM6VJkybKN998Y+iQRAXS0tKUl19+WfHy8lLMzc0VX19f5a233lJyc3MNHdoD7d9//63w79KYMWMURVGUoqIiZebMmYqrq6tiZmamdOvWTTl58qReY5Q+dkIIIYQQtYTU2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BKS2AkhhBBC1BLGhg7gQVRUVERMTAw2NjaoVCpDhyOEEEKIak5RFNLT03F3d8fI6A7jcko1tHv3bmXQoEGKm5ubAijr168v83xRUZEyc+ZMxc3NTTE3N1e6d++unDp1qswxOTk5yosvvqg4ODgolpaWyuDBg5Xo6OgyxyQlJSlPPfWUYmtrq9ja2ipPPfWUkpycfMfY7uXadxMdHa0AcpOb3OQmN7nJTW6Vut2ay9yqWo7YZWZm0rJlS8aOHcuIESPKPT9//nwWLFjAihUraNy4MXPmzKFv376cP38eGxsbAKZOncrGjRv56aefcHBw4NVXX2XQoEGEhoaiVqsBeOKJJ7h69SqbN28G4LnnnuPpp59m48aNt43tXq59N6XHRUdHY2trW6mvjRBCCCEePGlpaXh6et4916jUUJMBQNkRu6KiIsXV1VX58MMPNY/l5OQodnZ2ytKlSxVFUZSUlBTFxMRE+emnnzTHXLt2TTEyMlI2b96sKIqinDlzRgGUgwcPao45cOCAAijnzp2rMJZ7ufa9SE1NVQAlNTX1nl8jhBBCiAfXveYONW7xRGRkJHFxcfTr10/zmJmZGd27d2f//v0AhIaGkp+fX+YYd3d3AgICNMccOHAAOzs7AgMDNcd07NgROzs7zTH3c+2K5ObmkpaWVuYmhBBCCKFtNS6xi4uLA8DFxaXM4y4uLprn4uLiMDU1pW7dunc8xtnZudz5nZ2dNcfcz7UrMm/ePOzs7DQ3T0/PO73Fam/H2ev0+Phf5vx1xtChCCGEEOImWkns8vPziY6O5vz58yQlJWnjlHd162pSRVHuusL01mMqOv5ezlPZa8+YMYPU1FTNLTo6+o7nr64ycwuY8ftJxv9whKjELFaFXCavoMjQYQkhhBCixH0ndhkZGXz99df06NEDOzs76tevT7NmzXBycsLb25uJEydy+PBhbcYKgKurK0C5EbL4+HjNSJqrqyt5eXkkJyff8Zjr16+XO/+NGzfKjchV5toVMTMzw9bWtsytpjl6JZmHv9jL2kNXADBVG5GTX8SJqymGDUwIIYQQGveV2H322WfUr1+fb7/9ll69evH7778TFhbG+fPnOXDgADNnzqSgoIC+ffsyYMAAwsPDtRawj48Prq6ubNu2TfNYXl4eu3fvJigoCIC2bdtiYmJS5pjY2FhOnTqlOaZTp06kpqZy6NAhzTEhISGkpqZqjrmfa9c2+YVFLNh6nkeX7CcqMQt3O3PWTAikd9PiaeyQSP2M0AohhBDi7u6r3cn+/fv5999/ad68eYXPd+jQgXHjxrF06VKWLVvG7t27adSo0T2fPyMjg4sXL2ruR0ZGEhYWhr29PV5eXkydOpW5c+fSqFEjGjVqxNy5c7G0tOSJJ54AwM7OjvHjx/Pqq6/i4OCAvb0906dPp3nz5vTp0weApk2bMmDAACZOnMjXX38NFLc7GTRoEH5+fpprN2nShHnz5jFs2DBUKtVdr12bXLqRwSs/h3HiaioAQ1u5M/uRAOwsTLhwPZ1/TsVxMCKRF3o2NHCkQgghhID7TOx+/fXXezrOzMyMyZMnV/r8R44coWfPnpr706ZNA2DMmDGsWLGC119/nezsbCZPnkxycjKBgYFs3bq1TG+Xzz77DGNjYx5//HGys7Pp3bs3K1as0PSwA1i9ejVTpkzRrHIdMmQIixYtKhPL+fPnSU1N1dy/l2vXdIqisOrgZT7YdJac/CJszY35YFhzBrd01xzTwccBgNDLyeQXFmGirnHrcIQQQohaR6UoilKZF2RnZ5OUlISHh0eZx0+fPo2/v79Wg6ut0tLSsLOzIzU1tdrV211Py+G1306w58INALo0dOTjx1rgZmdR5riiIoXW728jNTuf9ZODaO1Vt6LTCSGEEEIL7jV3qNQwy2+//Ubjxo156KGHaNGiBSEhIZrnnn766fuPVlQL/5yMpf/CPey5cAMzYyNmDm7Gj+M6lEvqAIyMVLSvbw9InZ0QQghRXVQqsZszZw5Hjx7l+PHjLF++nHHjxrFmzRqgePpO1ExpOflM+yWM/60+SkpWPv7utvz1UhfGdvbByOj2bVw6+pYkdhGJ+gpVCCGEEHdQqRq7/Px8nJycAGjXrh179uxh+PDhXLx48a6930T1FBKRyLRfjnMtJRsjFfyvRwNe7t0YU+O75/yBJXV2R6KSKSxSUN8hCRRCCCGE7lVqxM7Z2ZkTJ05o7js4OLBt2zbOnj1b5nFR/eUWFDJv01lGfXuQaynZeNpb8MukTrzWv8k9JXUAzdxtsTEzJj23gDMxsk2aEEIIYWiVSuxWrlxZbhsuU1NT1q5dy+7du7UamNCd83HpDP1qP1/viUBR4PF29fjn5W60K6mZu1dqIxXt6hcvmgiJlOlYQ1IUhT0XbpCUmWfoUIQQQhhQpRK7evXqaXZfuFXnzp21EpDQnaIihe/2RjD4y2DOxqZhb2XK10+3Zf6jLbE2u6/ONwT6Fk/HygIKw/rnVBzPLD/Ew1/s5XxcuqHDEUIIYSD399f8JikpKSxbtoy4uDh8fHxo1aoVLVu2xMrKShvxCS25lpLN9F+Oc6BkoUOvJs58NKIFTjZmVTpvoE/xKN/hqCSKipQ7LrYQuvP3yVgAYlNzeHTpfr59ph0dS5JuIYQQD44qJ3bDhw/n5MmTtG/fnn/++YcLFy5QVFSEr68vrVq14pdfftFGnOI+KYrCn2ExvPPnKdJzCrAwUfPOoGaM7uCplQUvAR52WJqqScnK5/z1dJq6Va++fA+CvIIidp8v7jvo62RFxI1Mnll2iE8fb1mmqbQQQojar8qJXUhICLt376Zdu3YA5Obmcvr0aY4fP87x48erHKC4fylZebz9xyn+OlE8mtPKsw6fjWyFj6P2RlNN1Ea09a7L3vAEQiISJbEzgJDIRDJyC3C0NuPvl7oy7Zcw/jkVx0trj3E9LYcJXX0NHaIQQgg9qXJiFxAQgJHRf6V6ZmZmtGnThjZt2lT11KIK9obfYPqvx7melovaSMXLvRsxuUcDjHWw9VdHX4fixC4yiWc7+2j9/OLOdpyNB6BPU2csTNUseqIN7/91hhX7o5jz91liU3N466GmMk0uhBAPgCr/lf/oo4945513yMnJ0UY8oopy8guZteE0Ty87xPW0XHwdrfj9f0FM6d1IJ0kd/FdndygySRpV65miKGw7cx2APk1dgOLVyjMHN2PGwCYALAuO5KWfjpFbUGiwOIUQojbLLShk/uZzhEWnGPzvYJX/0vv4+JCenk7Tpk35v//7P/7880+uXLmijdjEffi/9SdZsT8KgKc7evP3lK609Kyj02u2qFcHcxMjEjPzuBifodNribLOxaVzLSUbcxMjOjd01DyuUqmY1L0Bn49qhYlaxd8nYnlm2SFSs/MNGK0QQtRO+y4msHjXJZ778QiGHt+ocmI3YsQIoqOj6dmzJ4cOHWL8+PH4+Pjg4OBAr169tBGjqIQpvRpR38GS78e25/2hAViYqnV+TVNjI9p4FfezOyhtT/Rqe8loXZeGjhV+rx9p5cGKsR2wNjMmJDKJx5buJyYlW99hCiFErbbpZBwAAwNcDV72UuXE7syZM/z5558sX76c7du3k5CQQGRkJMuXL6d79+7aiFFUQn1HK3a82oOefs53P1iLSrcXk31j9Wv72bLTsBXp3NCRXyZ1wsXWjAvXMxi+eD/n4mSnEFG9LAuOZOKPR0jLkVHl6mJNyBU+/OccBYVFhg6lWssrKGLr6ZLErrmbgaPRQmLXvn17MjLKTr95eXnxyCOPMHPmzKqeXtwHQ+zZGuhbXGcXInV2enM9LYfjV1MB6NX0zol8M3dbfp/cmYbO1sSl5fDYkgPsv5SgjzCFuKv1x67y/l9n2HbmOr8cjjZ0OAKIS83h7T9OsnT3JZbvizR0ONXagYhE0nKKOxO0r+QOTrpQ5cRu6tSpzJo1i+TkZG3EI2qoVp51MDU24kZ6LpEJmYYO54FQuhq2lWcdnG3M73q8Rx0Lfnu+Ex3q25OeW8Czyw+z4XiMrsMU4o6OXUnmjXUnNfd/OhwtHw6rgV+ORFNU8m1YsO0ClxPl9/rtbCppKTYgwMUgAyu30kqN3fbt22nUqBHjxo3jm2++4fDhw+Tm5mojPlFDmJuoaVWySEO2F9OP0mnYvs1uPw17qzqWpvw4vgMPNXclr7CIKWuP8d3eCF2FKMQdxaXmMGllKHkFRfTwc8LCRM3F+AyOXpGBAkMqLFL4uWTk1MHKlJz8It5cd1IS7grkFxax5UzxNOxDAYafhgUtJHaRkZGsX7+eKVOmkJKSwkcffUTHjh2xsbGhRYsW2ohR1BAdS9qeSJ2d7mXlFRB8sXgq9U71dRUxN1Hz5eg2PBtUH4A5f5/lvY1nKCqSX9pCf3LyC3lu5RHi03Pxc7Fh0RNtGNSi+A/jT4dkOtaQ9obf4FpKNnYWJvz0XEfMTYw4EJGoSfbEf0IikkjJysfeypQOPoafhgUtJHbe3t488sgjvPvuu/z+++9cunSJlJQUduzYwaRJk7QRY4XS09OZOnUq3t7eWFhYEBQUxOHDhzXPX79+nWeffRZ3d3csLS0ZMGAA4eHhmuejoqJQqVQV3n799dfbXnfWrFnljnd1ddXZ+6xJAkv2JpU6O93bG55AXkERnvYWNHaxrvTrS3vd/d9Dxb3ulu+L5KW1x8jJl153QvcUReH1305w4moqdS1N+G5MO6zNjBnVwROAv07Eki6LKAxm7aHilmXDWnvQyMWG6f38APhg01mup0nP2pttOlU8Ddvf30VnvWIrq8pRBAcHl9s6zMbGhq5du/LCCy9U9fS3NWHCBLZt28bKlSs5efIk/fr1o0+fPly7dg1FURg6dCgRERH8+eefHDt2DG9vb/r06UNmZnGdgKenJ7GxsWVus2fPxsrKioEDB97x2v7+/mVed/LkyTse/6Bo41UXE7WK2NQcopOkpYYu7bhpNez97vmrUql4rttNve5OxvLM8kOkZskfVKFbi3ddYsPxGIyNVCx+si2e9pZA8e+Qhs7WZOcXSv2ngcSn5Wjqd0d38AJgbGcfWtazIz2ngHf/PGXI8KqVwiKFLadK25xUj2lY0EJi99JLLxEaGlru8QsXLpCamlrV01coOzubdevWMX/+fLp160bDhg2ZNWsWPj4+LFmyhPDwcA4ePMiSJUto3749fn5+LF68mIyMDNauXQuAWq3G1dW1zG39+vWMHDkSa+s7j4AYGxuXeZ2Tk5NO3mdNY2GqpkW9OgAcjJTpWF0pLFI0v3j7VnIatiKPtPLgh7EdsDEz5lBkEo9KrzuhQ9vOXOeTrecBmDXEn04NHDTPqVQqRrUvHrWTaT/D+DX0KgVFCm286uDnagMUj/B/OKIFxkYqtpy+zj8nYw0cZfVwKDKJxMw86lialPl/bGhVTuzOnz9fYb+6f//9l9GjR1f19BUqKCigsLAQc/OyKwEtLCwIDg7WLNy4+Xm1Wo2pqSnBwcEVnjM0NJSwsDDGjx9/1+uHh4fj7u6Oj48Po0aNIiLizsXnubm5pKWllbnVVoGaOjtZQKErYdEpJGbmYWNuTHst1XQENXTkl+eLe92Fx2cwbPE+zsbW3v+nwjDOx6Uz9adjKErxzjhPdfQud8yw1h6YqFWcuJrK6RjdDA6IihXdtGiidLSuVFM3Wyb3aADAO3+eJiUrT+/xVTebShLcfs1cMKkm07CghcTO1taWpKTyf8S7du3KoUOHqnr6CtnY2NCpUyfef/99YmJiKCwsZNWqVYSEhBAbG0uTJk3w9vZmxowZJCcnk5eXx4cffkhcXByxsRV/0li2bBlNmzYlKCjojtcODAzkxx9/ZMuWLXz77bfExcURFBREYuLtR6jmzZuHnZ2d5ubp6Vml91+d/VdnJyN2ulK6GraHn7NWf5k0dSvuddfI2Zrrabk8vvQA+y9KrzuhHUmZeUz48TCZeYV08nXg3cHNKjzOwdqMfv7FdcvS006/9l9K5EpSFjZmxjzcovzU4gu9GtLQ2ZqEjFw++PusASKsPgqLFDZXo6bEN6vyX4UhQ4bwySeflD+xkRF5ebrL6FeuXImiKHh4eGBmZsYXX3zBE088gVqtxsTEhHXr1nHhwgXs7e2xtLRk165dDBw4ELW6/LZL2dnZrFmz5p5G6wYOHMiIESNo3rw5ffr04e+//wbghx9+uO1rZsyYQWpqquYWHV17f1m19a6L2kjF1eRsrsl0nk6UbiPW5y5Nie9Hca+7IE2vuzHfH+LPsGtav454sOQXFjF5dSjRSdl42Vuy+Mk2d/xQUjodu/7YNVnQo0drDxcvmhja2gNLU+Nyz5sZq/loRHNUquIp2+DwB/eDX+jlZG6k52JjbkznBo53f4EeVTmxmzt3Lnv37qVPnz6cOHECgJycHD766COdtjtp0KABu3fvJiMjg+joaA4dOkR+fj4+Pj4AtG3blrCwMFJSUoiNjWXz5s0kJiZqnr/Zb7/9RlZWFs8880yl47CysqJ58+ZlVtzeyszMDFtb2zK32srazJgADztA2p7oQlRCJuHxGRgbqejRWDfbxtlZmmh63eUXKrz8Uxjf7LkkK53FfZu14TQHI5KwNjPmuzHtqGtlesfjOzdwxKOOBWk5BWwuKU4XupWYkavZFuvWadibtfW255mSKfQZ60+QlVegl/iqm9Jp2L7NXDA1rj7TsKCFxM7R0ZEDBw5gampKq1atsLCwwMbGho0bN/Lxxx9rI8Y7srKyws3NjeTkZLZs2cIjjzxS5nk7OzucnJwIDw/nyJEj5Z6H4mnYIUOG3NciiNzcXM6ePYubW/UaijWkjlJnpzOl07AdfOyxszTR2XXMTdQsGt2GsZ3rAzB30zlmbzxDofS6E5W08uBlVodcQaWCz0e1orGLzV1fY2SkYmTJqF1p6w2hW+uOXiW/UKFlPTuaud958OG1AU3wqGNBdFI2n269oKcIq4+iIkXzgaO6NCW+mVbSTG9vbzZt2sTly5f5+eef2bBhAxcuXKBTp07aOH2FtmzZwubNm4mMjGTbtm307NkTPz8/xo4dC8Cvv/7Krl27NC1P+vbty9ChQ+nXr1+Z81y8eJE9e/YwYcKECq/Tu3dvFi1apLk/ffp0du/eTWRkJCEhITz66KOkpaUxZswYnb3Xmua/fWNlxE7btt/U5kTXjIxUzBzsz9sPNwVgxf4oXlp7VKbGxD3bfymBWRtOA/B6/yb0rsT/20fb1sNIVdwXM+JGxt1fIO6boiiaptB3Gq0rZW1mzAfDAgD4fl8kYdEpugyv2jkWnUJcWg7WZsZ0bVy9pmHhPhO7K1cq/gTl6enJkCFDGDhwIPb2/63Wu3ZN+zU6qampvPDCCzRp0oRnnnmGLl26sHXrVkxMikcxYmNjefrpp2nSpAlTpkzh6aef1rQ6udny5cvx8PAol/CVunTpEgkJ/9URXL16ldGjR+Pn58fw4cMxNTXl4MGDeHuXX931oGpX3x4jFUQlZkkzSy1KzcrncFTxVkv6SOxKTejqyxejW2OiVrHpZByjvjko+0aKu7qcmMnk1UcpLFIY2sqd57v7Vur17nUs6N64eBbllyNXdRGiThQUFvFb6FViU2tOjXFIZBIRCZlYmaoZ3NL9nl7Tw8+ZYa09KFLgjd9OkFdQpOMoq4/Sadg+TZ0xMy5ft29oKuU+CmdcXFwYMmQIEydOpEOHDhUek5qayi+//MLnn3/OpEmTeOmll6ocbG2RlpaGnZ0dqamptbbebtCXezl1LY3PR7XikVYehg6nVvgz7Bov/xSGn4sNW17ppvfr77+UwKSVoaTnFGBpqubth5sxuoPnfTdIFrVXek4+wxfvJzw+g5b17Ph5UifMTSr/B3DzqTieXxWKo7UZB2b0qlYtJW7nq38v8vGW8zT3sGPDi51rxM/Hyz8d48+wGEZ38GLe8Ob3/LqkzDz6LNhNUmYe0/o2ZkrvRjqMsnpQFIXOH+4kJjWHr59uS39//e08da+5w339lJw9exY7OzsGDBiAi4sLDz/8MBMnTuSll17iqaeeok2bNjg7O7NixQo+/vhjSeoeQIE+/20vJrRjW+lq2Ga6WTRxN0ENHPnn5a509LUnK6+Q/1t/kvE/HCE+XUZlxX8KixRe+TmM8PgMXGzN+OaZdveV1AH0buqMo7UZCRm57DwXr+VItS89J59v9xb3NT15LVXzM1udJWfm8c/J0kUTlWvFZW9lyqwh/gB8uTOc8OvpWo+vujl+NZWY1BwsTdWaEeXq5r4SO3t7ez755BNiYmJYsmQJjRs3JiEhQbMy9MknnyQ0NJR9+/bddXsuUTv916hY6uy0Ia+giN3nbwD6nYa9Vb26lqyZ0JG3H26KqbERO8/F0/+zPdKJXmh8svU828/GY2ZsxDdPt8PF1vzuL7oNE7URj7atB9SMnSh+2B9FSlY+pYN0C7ZdoKiaLzj6/dg18gqL8He3pXlJR4PKGNzCjd5NnMkvVHhj3Ylav8Cq9HddrybO9/2BRdfKN6qpBHNzc4YPH87w4cO1FY+oJTr42KNSwaUbmdxIz8XJxszQIdVohyKTSM8twNHajJYl27YZipGRigldfenayIlXfg7jTGwa/1t9lOGtPZg5xB87C92t1hXV2x/HrrFk1yUA5j/agpaedap8zpHtPVm6+xK7zscTm5qNm51Flc+pC2k5+Xy7NxKA2UP8+Xjzec7FpfPPqbgKm/1WB4qiaFYdj+rgdV/TxiqVijnDAghZsIejV1JYeSCKZzuXbytWGyiKwqZTxYndQ9WsKfHNqn/BgqiR6lia4lfS1uCQTMdWWelq2N5NnDEyqh41O36uNvzxQmde6NkAI1XxJ/+BC/fIbhUPqOPRKby+rriX6f96NNBaba2PoxWBPvYUKfBrNV5EsWJfFKnZ+TR0tubJQG/GdSlObj7bfqHajmKFXk7mYnwGFiZqHml1b4smKuJmZ8EbA5sAMH/Lea4mZ2krxGrldEwa0UnZWJio6elnmJKYeyGJndCZjrK9mFYoinJTfZ3hpmErYmpsxGv9m/Dr853wdrAkJjWHJ74LYfbG09IW5QFyPS2HiT8eIa+giD5NnXmtn59Wzz+qpPbr58PR1XJqMzU7n+9Kauum9G6E2kjF+K4+2JobczE+g43HYwwcYcXWlIzWDWrhhq151Uban+zgRYf6pfW3p2plQ/O/S6ZhezZxwsK0ek7DgiR2QocCpVGxVpyLS+daSjZmxkZ0aVj9eiZBcTf6TVO68mRgcQ+s7/dFMejLYE5elU3ca7uc/EKe+/EI8em5NHaxZuGo1lofVR4Y4IatuTHXUrLZd6n6jQiv2BdFWk4BjZytebhkis7W3ITnuhW3ePl8RzgFhdWrHUhqVj5/nyhOVEYH3r133d0YGan4cERzTI2N2HPhBuuP1a6tCBVF0dTXDayGTYlvJomd0JkOJYnd+evpJGXqbt/g2q50b9iujRyr9adEKzNjPhjWnO/HtsfJxoyL8RkMW7yPL6rhHzWhHYqi8Oa6Exy/mkodSxO+e6Y91mZVKt2ukLmJmmGti6d2f6pmiyhSs/P5Lrh4tO7lPsWjdaWe7exDXUsTIhMyq12i80fYNXILivBzsaG1FmohAXydrHm5pOXJe3+dISEjVyvnrQ7OxqYTlZiFmbERPZtU32lYkMRO6JCDtRmNnK0BqbOrCn3uNqENPf2c2Tq1Gw83d6OgSGHBtgs8uvSA7B5QCy3dHcEfYTEYG6lY/GQbvBwsdXatke2LR5W2no6rVh8UlwdHkp5TQGMX63LbS1mbGfN89wYAfLEznPxq8gHn5kUT2u5F+Vw3X5q52ZKSlc/sjWe0dl5D+6dk0UT3xk46+fCiTVpL7M6cOcPmzZvZsGFDmZt4sMn2YlVzPS2H4yXTmb2aVu9PiTera2XKoidas3BkK2zMjQmLTuGhL/ay8kBUray9eRBtP3Od+VvOATBziD9BDXRbJtDM3ZYW9ezIL1T4/Wj1WESRmpXP8uDilbAv925c4RT0M53q42htRnRSdrVZ/BEWncK5uHTMjI0Y1rqeVs9tojZi/qMtUBup2Hg8RjPjUJMpiqKpr6vOq2FLVTmxi4iIoGXLlgQEBPDwww8zdOhQhg4dyrBhwxg2bJg2YhQ1WGmjYhmxuz+lTVlbedbB2eb++4EZgkqlYmhrD7ZM7Ubnhg7k5Bfxzp+nGfP9YeJSpalxTXbhejov/3QMRYGnOnrxdEf9bKk4sn3xIoqfDkdXiw8Iy4IjSM8toImrDQMDKt6BwMJUzeQexaN2i3aGk1tg+EVFpfvCPtzcDTtL7bcnCvCwY0LX4lXBb/9xirScfK1fQ58uXM8g4kYmpmojeteAD9hVTuxefvllfHx8uH79OpaWlpw+fZo9e/bQrl07du3apYUQRU1WOmJ3JjaN1Oya/cNtCKWfdvtWs9WwleFex4KV4wKZObgZZiWF1f0X7qm2KwXFnSVn5jHhhyNk5hXS0deemYP99XbtIS3dsTBRczE+g6NXkvV23YqkZOXx/b4oAF7u3eiOC0aeCPTCxdaMmNQcTVJlKOk5+Wwo+dnTxqKJ23mlT2PqO1gSl5bDR/+c09l19KF0b9hujR2xqeLqYX2ocmJ34MAB3nvvPZycnDAyMsLIyIguXbowb948pkyZoo0YRQ3mbGOOr6MVigJHomTUrjKy8goILukJV1Pq627HyEjF2M4+/D2lC8097EjNzueltceYsvYYKVnVp15K3Fl+YRGTVx/lSlIWnvYWLH6yrV73b7UxN9E0+zV0grQsOFIzWne3/ULNTdS82LMhULyXrCFbAW04HkN2fiENna1p511XZ9cxN1Ezb3gLAFaHXKnRuxCV1tdV99Wwpar8E1lYWIi1dXGBvKOjIzExxZ8EvL29OX/+fFVPL2qB/+rsJLGrjODwBHILiqhX14LGLtaGDkcrGjrb8PvkIE2vrw3HY+i/cA97LtwwdGjiHry38QwHIhKxMlWzbEx77K1M9R7DqJLp2L9OxJJuoCm+m0frpva582hdqcfbe+JRx4L49FxWHbys4whvT7PTRHvtLpqoSKcGDozuUDwq+ObvJ2tkb8uL8elcuJ6BiVpVYz5gVzmxCwgI4MSJ4m7jgYGBzJ8/n3379vHee+/h6+tb5QBFzVdaZ1eTP7EZws2rYXX9C1ifTNRGTOvbmHX/C8LX0Yrrabk8s/wQ7/55iuy8mveL/0Gx6uBlVh68jEoFn49qTeOSnWX0ra13XRo6W5OdX8jG44bZo/jbvRFk5BbQ1M2Wfs3uPFpXysxYzUu9ikftlu6+RFZegS5DrNDJq6mcupaGqdqI4W20u2jidmY81AQXWzMiEzL5fEe4Xq6pTf+cjAOgc0NHndQj6kKVE7u3336boqLiJdxz5szh8uXLdO3alU2bNvHFF19UOUBR85X2szsVk0ZGrv5/mdVEhUUKO84WL5yoyfV1d9LKsw5/T+nKmE7Fhfc/HrjMw1/sJSw6xbCBiXIOXEpk1obTALzW38+gO6CoVCrNqN3Ph6/o/frJmXmsqORoXakRbevhZW9JQkYeP+zX/6jd2pKv14AAV72Nttqam/D+IwEAfLMnglPXalbT8k2nihO7W1vZVGdVTuz69+/P8OHDAfD19eXMmTMkJCQQHx9Pr169qhygqPnc61jgaW9BYZEidXb3KCw6hcTMPGzMjTWJcW1kYapm9iMB/DiuA6625kQkZDJiyX4+3XpeRu+qgdJ+ZxN/PEJBkcIjrdz5X0lfNkMa1toDE7WK41dTOROTptdrf7s3gsy8QvzdbelXyQTXRG2kaeD79Z5Lep1Kzswt4M+SJsmlW7TpSz9/Vx5u7kZhkcIb607UmIblkQmZnI1NQ22kqlEfsHVS9Wpvb1+rpo5E1WmmY6XO7p6UTsP28HPWa3G6oXRr7MSWqd0Y0tKdwiKFL3depOcnu/j1SHS13UC9totOyuLpZYeY8ftJMnIL6Ohrz0cjWlSL3+0O1maaKVB9jtolZebxw/4oAKb2aXxfX4tHWrnj62RFSla+pk5PH/46EUNmXiH1HSzpVLKPtz7NGuKPnYUJp2PS+HZvpN6vfz9KV8MGNXCgrgHqSe+XVv5i7N27l6eeeopOnTpx7VrxJ4KVK1cSHBysjdOLWuC/fWOrV53d0t2XGLFkPzEp2YYOpYzSNid9akDPJG2xszThi9GtWfxkGzzqWBCXlsNrv51g0JfB7A2XxRX6UlSk8OOBKPov3EPwxQTMTYx4++GmrJ7QEXOT6rOlXWlPu/XHrumtKP+bPcWjdQEetvf9s2l806jdt3sjSM3Sz6jdmpJVxKM6eBkkOXeyMeOdQc0AWLj9ApEJmXqPobJKV8PWhKbEN6tyYrdu3Tr69++PhYUFx44dIze3eG+49PR05s6dW+UAbyc9PZ2pU6fi7e2NhYUFQUFBHD58WPP89evXefbZZ3F3d8fS0pIBAwYQHl62cLNHjx6oVKoyt1GjRt312osXL8bHxwdzc3Patm3L3r17tf7+apuOJZ8QT1xNNUjRcEWuJGbxyZbzhF5O1tQPVQeXEzMJj8/A2EhFj8YPTmJX6qHmbux4tTv/91ATbM2NORubxtPLDjFm+SHOxel32u1Bczkxk9HfHuTdP0+TlVdIh/r2bH65GxO6+pbZA7U66NLQEY86FqTlFLC5pA5KlxIzcvnxQBQAU3vf32hdqcEt3GnsYk16TgHLSvaZ1aUzMWkcj07BRK3i0bb6WTRRkRFtPOjayJHcgiLeXHeComo8Gn8lMYtT19IwUlHpKXdDq3JiN2fOHJYuXcq3336Licl/K0aCgoI4evRoVU9/WxMmTGDbtm2sXLmSkydP0q9fP/r06cO1a9dQFIWhQ4cSERHBn3/+ybFjx/D29qZPnz5kZpb9lDBx4kRiY2M1t6+//vqO1/3555+ZOnUqb731FseOHaNr164MHDiQK1f0X8Rbk9Sra4G7nTkFRQpHL6cYOhygeO/GgpJfLFvPXGfnueqx9c32kkUTHXzsa8wqLG0zN1HzXLcG7H6tJ+M6+2CiVrH7wg0e+nwvb/x2gutpsnOFNhUVKSwPjmTAwr2ERCZhaapm9hB/fnquI/UdrQwdXoWMjFQ83q50Jwrd//79Zm8EWXmFtKhnV+XdB4yMVLzSpzEAy/dFkazjvW9Lvz79mrniaG2m02vdiUqlYu6w5liYqAmJTNIs5qiOSkfrOvo64GDAr9n9qHJid/78ebp161bucVtbW1JSUqp6+gplZ2ezbt065s+fT7du3WjYsCGzZs3Cx8eHJUuWEB4ezsGDB1myZAnt27fHz8+PxYsXk5GRwdq1a8ucy9LSEldXV83Nzs7ujtdesGAB48ePZ8KECTRt2pSFCxfi6enJkiVLdPJeawuVSkWgb2mdneGnYyNuZGj2m+zh5wTAzA2nq0Wfpf+mYWvWp0RdqGtlyruDm7F9Wncebu5GkQI/H4mmx8e7WLD1vKyy1oKIGxk8/vUB3vvrDNn5hQQ1cGDL1G6MCapfqRWfhvBYu3oYqeBgRJJOp/YSMnL5sWQV69Q+jbQyldnf35VmbrZk5Bbw9R7djdpl5xWy3kCLJiriaW/Ja/39APhw07lqu71g6WrYgTVsGha0kNi5ublx8eLFco8HBwfrrI9dQUEBhYWFmJuX3TvTwsKC4OBgzXTwzc+r1WpMTU3L1f2tXr0aR0dH/P39mT59Ounp6be9bl5eHqGhofTr16/M4/369WP//v23fV1ubi5paWllbg+i/+rsDL+A4osd4RQp0LuJM1890QZXW3Oik7JZ/G/5/8v6lJqVz6GSlcOS2P3H28GKr55sw7r/BdHWuy7Z+YV8sfMiPT7exZqQKzVmlV11Ulik8M2eSwz8fC9HLidjZarmg2EBrJ4QiKe9paHDuyfudSzo3rj4g9nPh3W3E8U3eyLIzi+kZT07evpppzzCyEjFtL7Fo3Y/7I/iRnquVs57q79PxpKeU4CnvQWdGzjq5BqVNSaoPq0865CeW8Dbf5yqFvv+3uxqchbHo1NQqaC/f837PVzlxG7SpEm8/PLLhISEoFKpiImJYfXq1UyfPp3JkydrI8ZybGxs6NSpE++//z4xMTEUFhayatUqQkJCiI2NpUmTJnh7ezNjxgySk5PJy8vjww8/JC4ujtjY/xpaPvnkk6xdu5Zdu3bxzjvvsG7dOk3rlookJCRQWFiIi0vZb7SLiwtxcbev8Zg3bx52dnaam6en4T81GULpiF1YdIpBR8bCr6fzZ8leia/0bYyVmTEzBxcX9S7dHUHEjQyDxbbrQjyFRQqNXazxcqgZf1z1qa13XX57vhNLnmxDfQdLEjJy+b/1Jxnw+V52nrte7f5AVFfh19MZsWQ/czedI7egiK6NHNk6rTtPBnpXi1WvlTGyffHOBr+FXiVfBwn+jfSbauvucyXs7fRu6kzLenZk5xeydPclrZ33Zj9pdprwqjYjsGojFfMfbYGJWsX2s9f5+6RhGk3fTmnNZof69jjbmN/l6Oqnyond66+/ztChQ+nZsycZGRl069aNCRMmMGnSJF588UVtxFihlStXoigKHh4emJmZ8cUXX/DEE0+gVqsxMTFh3bp1XLhwAXt7eywtLdm1axcDBw5Erf5vVdfEiRPp06cPAQEBjBo1it9++43t27fftTbw1h9sRVHu+MM+Y8YMUlNTNbfoaMPucWgo9R0scbYxI6+wiGNXUgwWx8Id4ShK8SexAI/iqfcBAa50b+xEXmER7/552mAJwjaZhr0rlUrFwOZubH2lOzMHN6OupQkX4zMYt+IIT3wbUuMaoOpTQWERX/17kYe/CCYsOgUbc2Pmj2jBj+M64FHHwtDh3ZfeTZ1xtDYlISOXnefitX7+b/ZcIie/iFaedTRlG9qiUql4pWTUbtXBy1qvHb1wPZ0jl5NRG6l4zICLJirS2MWGyT2Kd+KY+edpndcZVkZpm5Oathq2lFbanXzwwQckJCRw6NAhDh48yI0bN3j//fe1cerbatCgAbt37yYjI4Po6GgOHTpEfn4+Pj4+ALRt25awsDBSUlKIjY1l8+bNJCYmap6vSJs2bTAxMSm3eraUo6MjarW63OhcfHx8uVG8m5mZmWFra1vm9iCqDnV2Z2PT+PtE8Q/t1JLi5dLYZg/xx9TYiOCLCQb5BJlXUMTu88VtPQzZ2b+mMDU2YmxnH3a91pNJ3X0xNTbiQEQig74M5pWfw7hWzVrYGNq5uDSGLd7Px1vOk1dYRK8mzmx7pTuP62HPUF0yURsxoiRp0fZ0bHx6DisPare27lbdGzvR1rsuuQVFWi8F+amkxUnvJs4421a/kafJPRvQ2MWaxMw83vz9RLUYcY9NzeZoycDDgIB72y6uuqlSYpefn0/Pnj25cOEClpaWtGvXjg4dOmBtrb8Ny62srHBzcyM5OZktW7bwyCOPlHnezs4OJycnwsPDOXLkSLnnb3b69Gny8/Nxc6s4Szc1NaVt27Zs27atzOPbtm0jKCio6m/mAWDoOruF2y8A8HALN5q6lU2w6ztaMblHcVf99zae0fsG44cik0jPLcDR2pRW9ero9do1mZ2FCTMGNmXnq90Z2sodKO5t1vOTXXz4zznSDLRRfHWRX1jE59vDGfxlMCevpWJrbsynj7Vk2Zh2uNpVvz/292NkyerYXefjiU3VXkL/9e4IcvKLaO1VR1PLp20qlYpXS0bt1h6K1toHkpz8Qn4/VrxAbHSgl1bOqW1mxmoWPN4KE7WKLaevs+aQ4VfJlk7DtvOui0s1TIbvRZUSOxMTE06dOmWQT3tbtmxh8+bNREZGsm3bNnr27Imfnx9jx44F4Ndff2XXrl2alid9+/Zl6NChmoUPly5d4r333uPIkSNERUWxadMmHnvsMVq3bk3nzp011+nduzeLFi3S3J82bRrfffcdy5cv5+zZs7zyyitcuXKF559/Xr9fgBqqo29xYnf0SjK5Bfqtszt1LZUtp6+jUsErfRpVeMzz3Rvg7WBJfHouC7frd8Pq0t0mejdxqTa1MDVJvbqWLBzVmg0vdqajrz15BUUs3X2J7vP/ZcW+SPIKHrwFFqeupTJk0T4+236B/EKFvs1c2D6tOyPa1qvRo3S38nWypoOPPUUK/HbkqlbOGZ+WwyrNaJ12a+tuFdTQsfj/bGERi3ZqZ9Ruy+k4UrLy8ahjQbdGuklKtSHAw443BjQB4P2/zhB+/fYLGPXhn5M1dzVsqSpPxT7zzDMsW7ZMG7FUSmpqKi+88AJNmjThmWeeoUuXLmzdulXTSy82Npann36aJk2aMGXKFJ5++ukyrU5MTU3ZsWMH/fv3x8/PjylTptCvXz+2b99epg7v0qVLJCQkaO6PHDmShQsX8t5779GqVSv27NnDpk2b8Pb21t+br8EaOFnjaG1KbkERJ67qtxbqs23Fo3WPtHSnobNNhceYmxT37wJYsT+Ks7H6WcGsKMp/9XUyDVslLerVYe3Ejiwb044GTlYkZ+Uza+MZ+n22m82nYqvFdI+u5RYU8unW8wz9ah9nY9OoW7KrxzdPt62WU3LaMLqklcfPR6K10vh2ye5L5BYU0carDt0a6X416bS+xS1Afj0SzZXErCqfb01I8ejX4+08q11z6VuN6+xD10aO5OQX8dLaYwZbXBeflsPhy8WzSQNr6DQsgEqp4m+5l156iR9//JGGDRvSrl07rKzKNrNcsGBBlQKsjdLS0rCzsyM1NfWBrLebvDqUTSfjmN6vMS/2qnjkTNuOXUlm2OL9qI1UbJ/WHZ+7NF3936pQ/jkVR1vvuvw6qZPOR9DOxaUxYOFezIyNCHu3Hxam1WfrppqsoLCIn49E89m2CyRkFBdnt/Ouy/893JQ2XnUNHJ1unLiawvRfj3PhevHq7oeauzJ7SABONjWryWpl5eQX0v6D7aTnFLByfAe6VmGUKj4th67z/yW3oKjK56qMp5eFsDc8gUfb1uOTx1re93ku3cig96e7MVLBvjd74WZX/RfGxKfn8NDne0nIyOPZoPrMKvmArU8/Hoji3T9P09qrDusnd777C/TsXnOHKo/YnTp1ijZt2mBra8uFCxc4duyY5hYWFlbV04taKNCndAGF/ursFpSM1g1r7XHXpA7gnUHNsDRVE3o5md+Oamdq505KmxJ3beQoSZ0WGauNeDLQm12v9WRKr4aYmxhx5HIywxfv54XVRzkTU3t6SubkF/LhP+cY+tU+LlzPwMHKlMVPtmHxk21rfVIHxaPtw1p7APBTFRdRLN5VPFrXzrsuXRrqr/dbaV+7349erVLbpdJFJD39nGtEUgfgbGPOxyXJ7Ir9UQbZCUizGjag5k7DAhhX9QT//vvvbZ+TxE5UJLCkzi70cjL5hUWYqLWyOPu2DkclsTc8AWMjFVPucYTQvY4FU/s0Yu6mc8zbdJa+TV2oa2Wqsxi3lWwjJm1OdMPazJhp/fx4ItCbBdvO82voVf4+GcvfJ2Pp2siRiV196drIscbWnYVeTub1345z6Ubx7gtDWroza4g/9jr8P1sdjWzvyY8HLrP1dBxJmXn39f7jUnM0Rfyv9NVtbd2tWnvVpVcTZ3aei+eLHeEsHNW60ufILSjkt9CSRRMdqueiidvp6efMuM4+LN8XyfRfT7D55a56Kx24kZ7LoZLBhpq6GraU1v+ipqamsnjxYtq2bUvbtm21fXpRCzR2tqGOpQlZeYWc1EPPsQVbi0frHmtXr1JNf8d29qGxizXJWfnM33JeV+ERn5bD8egUAHo10U5Xe1ExVztz5j/akk1TujKohRtGKtgbnsAzyw8x8PO9/BZ6tUYtsohOymL2xtM8unQ/l25k4mRjxjdPt+WL0a0fuKQOwN/djuYeduQXKpotAytrya6L5BUU0b5+XYIaOGg5wrsrHbX783jMfS0k2HbmOkmZebjYmmm9754+vDHQj6ZutiRl5vHqr8e1Ui95L7aeiaNIgRb17GrMziu3o7XEbufOnTz11FO4ubnx5ZdfMnDgQI4cOaKt04taxMhIRYf6+ml7sv9SAgciEjFRqypdz2eiNmLO0OZA8SbaR68k6yJEdpQ0VW3pWafWFrZXN03dbFn0RBt2v9aTsZ3rY2mq5lxcOtN/PU7X+TtZsusSqdnVs01Kek4+vxyO5vGvD9B1/r98vy8KRYHhbTzY9ko3+vnX7NGGqhrZvmQRxeHoSi+UiUvNYW1J77dXdLwS9nYCPOzo7++ConBfK/PXlow2jmznibGOZ0N0wcxYzZejW2FuYsTe8AS+C9bdPro306yGreHTsFDFxO7q1avMmTMHX19fRo8eTd26dcnPz2fdunXMmTOH1q0rP4wsHgz6aFSsKIpmJeyo9l731Vm/g489I9rUQ1HgnT9O6WRP0tL6ur5NZbRO3zztLZk52J8Db/bmjQFNcLYx43paLh9tPkfQvB3M3nia6KSqr1CsqsIihT0XbvDyT8do/8F2Xl93gkORSahU0KWhIyvGtmfB462oY/ngjdLd6pFW7liYqAmPz9A0mr1Xi3ddJK+wiA4+9nQywGhdqdLdKP4+GVupOtDLiZnsu5iISgWPt6+5W1c2dLZh5uDixRMfbznPSR13UEjKzONARPHfooea1/wPRved2D300EM0a9aMM2fO8OWXXxITE8OXX36pzdhELVbaqPhIVLLONnAPvpjA4ahkTI2NeKFnw/s+z4yHmmBrbszpmDRNXyttycorIPhicTsdaXNiOHaWJvyvRwOC3+jFJ4+1pImrDZl5hXy/L4ruH//Li2uOcuJqit7jCr+ezrx/zhL04Q6eWX6IP8NiyMkvooGTFa8P8GP/m71YNSGQHlramL42sDE34eEWxaMuP1Wi4W1MSrZmpwZDjdaVauJqq3kPn5U0Vb8XpYtGujVyol7dmj2dOKq9JwP8XckvVJjy0zEycwt0dq2tp+MoLFLwd7fF2+Hui+uqu/tO7LZu3cqECROYPXs2Dz/8cJneb0LcTVM3W2zMjcnILeCMDnrFKYrCpyW1dU8GelWpw76jtRmvlzTQ/HTrBeK1uJ9jcHgCuQVF1KtrgZ9Lxb31hP6YGhvxaNt6/PNyV34c14GujRwpUuCvE7EMWbSPkV8fYPuZ6zqt+0nKzGPFvkiGLAqm72d7+Hp3BNfTcrGzMOHpjt788UJntk/rzuQeDWvMikd9G1UyWvXXidh73kGmdLSuo69hR+tKvdKnEUaq4pq5e/lQkV9YxK9HShdN1NzRulIqlYoPRzTHzc6cyIRMZm04rbNrbSrZbaKm7g17q/tO7Pbu3Ut6ejrt2rUjMDCQRYsWcePGDW3GJmoxtY7r7Hadv0FYdArmJkb8r2SbsKoY3cGLlvXsSM8t4INNZ7UQYbHS3Sb6NHWpsSsyayOVSkW3xk6sHB/IpildGd7aA2MjFSGRSUz48Qh9PtvN2kNXtNZINa+giC2n43juxyMEzt3OrI1nOHE1FWMjFX2aurD0qTYceqs37w8NoJVnHfm/chdtvevSwMmK7PxCNh6/+77P11KyNS1Cbt5D2pAaOtvwSKvi9i2lJSV3suPsdRIycnG0NqN3LVldX8fSlIUjW6FSwa+hV9l4PEbr10jJymN/yaxJTW5KfLP7Tuw6derEt99+S2xsLJMmTeKnn37Cw8ODoqIitm3bRnq6YbcFEdVfadsTbdfZKYqi6Vs3plN9nG2qviBBbaTi/aEBqFTwZ1gM+y8l3P1Fd1FUpLCzZOFEX5mGrbaauduyYGQr9r7Rk0ndfbExMybiRiYzfj9Jl4928sWOcJIy8yp9XkVROHE1hZl/niJw7nYmrQxl65nr5BcqBHjYMnNwMw7+X2++G9OOAQFumBnLrMi9UqlUjGpf3Orj58N3n45d/O9F8gsVOvk60NHX8KN1pV7u3Qi1kYp/z98g9PKdF2+VLvp4rF09nbeQ0qdAXwdeLCml+b/1J7Ve87rtzHUKihSauNrg66S/fe51qcrffUtLS8aNG0dwcDAnT57k1Vdf5cMPP8TZ2ZkhQ4ZoI0ZRS5U2Kj4UmUShFqe2tp65zslrqViaqnmum6/WztuiXh2eCizeOu6dP05VuS1G2NUUEjLysDE3pkNJzaGovtzsLJgxsCn7Z/Ti7Yeb4lHHgoSMPBZsu0DQhzt4+4+TRCZk3vU8cak5LNl1iX6f7WHIon38cOAyyVn5ONmY8Vw3X7ZM7cZfL3VlbGcfHK1rf2NhXRnWxgMTtYrjV1PvuADhanIWvxwpqa3rWz1G60rVd7RiRJu7j9pFJ2WxJ7x4xmxUDV40cTsv925EG686pOcUMPXnMK3WZZc2Ja4Nq2FLaTWt9/PzY/78+Vy9erXMvqxCVMTf3RZrM2PScgo4F6edOruiov9Wwo7tXB8HLf9hnN7PD0drUy7dyKzyMvzS1bA9/Jxr1Sfs2s7G3IQJXX3Z/VoPvhjdmgAPW3Lyi1h18Aq9Pt3FpJVHCL1ctrwgO6+QP8Ou8fSyEII+3MFHm88RHp+BmbERg1u6s2Jsew682Yv/e6gpfq5Sa6kNjtZmmpHw0sStIl/9e4n8QoXODR2q5Qesl3o1wthIRfDFBEIiKp7d+PVINIoCnRs61Iri/1sZq434fFRrbMyMCb2czBc7L2rlvKnZ+ZrFa7VhNWwpnfw1UavVDB06lA0bNuji9KKWMFYb0da7eL9ObdXZ/XMqjnNx6diYGTOxq/ZG60rZWZrwfw81BeCLHeFcTb7/aYH/6utkRWNNZKw2YkhLdza+2IW1EzvSq4kzigJbTl9nxJIDDFu8j58OXeH1347T/oPtvPxTGHvDEyhSivernTe8OYff7sOXo1vTw8+5RvYcq+5Kp2N/P3q1wnrI6KQsfj1SvWrrbuVpb6lpXfLptgvlevOV7ocMNW+nicrwtLfkg+HFfUUX7QzX7BJRFTvOFpc+NHK2plEtWrwmv0mEQWmzzq6wSGFhSWuAcV18dNbTa1hrDzr42JOTX8TsjWfu6xyXEzO5cD0DtZGKHo0lsavJVCoVnRo4sPzZ9myf1o1R7T0xVRtx7EoKb/5+kl+OXCUjt4B6dS2Y0rsRu1/rwW//C2J0By9szU0MHX6t1qWhIx51LEjLKWBzycrHmy3edZGCIoUuDR1pX7/6jdaVerFnQ0zVRhyKTGLfxbK/K/89f4Prabk4WJnSr1ntGXWqyJCW7oxoU48iBab+dIzUrKo1Ed9U2pS4lqyGLSWJnTCom+vsqtpC4q8TMYTHZ2Brbsy4Lj7aCK9CKpWKOUMDMDZSse3Mdc2UamVsL9kbtkN9e+ws5Y97bdHQ2YYPR7Qg+M2evNSrIc3cbHm8XT1+eq4je17rybS+jWvlVFl1ZWSk4vF2xaNdP92yiKJ4tK64PcgrfSu3K42+udex4InA4tG4BdvOlxm1K+3VN6JtPUyNa/+f9NmP+FPfwZKY1BxmrD9R6d1FSqXn5GvqEmvTNCxIYicMrEU9OyxM1CRn5XPxRsZ9n6egsIjPS7bfea6bL3YWuk2WGrvYML5rcfI4a+NpsvMq1/aiNBmUpsS1k7ONOa/282PTy12Z/2hLOvo6YGQkLUoM4bF29VCp4GBEUpnFLYt2Fo/WdW3kSFvv6jtaV2pyjwaYGRtx9EoKuy4UJySxqdn8e774Q2JtXDRREWszY74Y3RpjIxWbTsbdsX7yTnaeiyevoAhfR6ta10NUEjthUCZl6uzufzr2j7AYIhIyqWtpwrOddTdad7MpvRrhbmfO1eRsvvr33ot5U7PyORRVXB8i9XVC6JZ7HQu6N3YC/ltEcSUxi9+OFo/WVdfauls525rzTKfiVfmfldTa/XL4KkVK8U4+taVVx71oUa8O0/v7ATBrwxkuxld+UECzGra5a63rC2l8Py+aNm3aPR+7YMGC+7mEeIAE+tgTfDGBg5FJPN2pfqVfn19YxBc7ikfrJnVvgLXZff23rjQrM2PeHezP86tC+XrPJYa18aDBPfxy3XUhnsIihcYu1jItJ4QejGrvya7zN/gt9CrT+jbmy53hFBYpdGvspPlgWRM8370Bq0OucOJqKltOX9f06Cudpn2QPNfVl+DwBIIvJjBl7THWvxB0z70eM3ML2HW+eNSzNrU5KXVfI3bHjh27p1tYWJiWw/1Peno6U6dOxdvbGwsLC4KCgjh8+LDm+evXr/Pss8/i7u6OpaUlAwYMIDw8XPN8UlISL730En5+flhaWuLl5cWUKVNITb3zZsOzZs1CpVKVubm61q75eX0LLGkIGhKRdF/1EutCr3IlKQtHa1PNJ1p96e/vQk8/J/ILFWb+efqe4t925r/dJoQQuteriQuO1qbcSM/lh/1R/H7sGlC8bVdN4mBtxpig+gC8/ttxYlJzqGNpQn//B+9vkJGRigWPt8TeypQzsWl8vPn8Pb/23/Px5BYU4e1gib+7rQ6jNIz7Gtr4999/tR1HpU2YMIFTp06xcuVK3N3dWbVqFX369OHMmTO4u7szdOhQTExM+PPPP7G1tWXBggWa562srIiJiSEmJoZPPvmEZs2acfnyZZ5//nliYmL47bff7nhtf39/tm/frrkv++RWTUtPO8yMjUjIyCUiIfOeRr1K5RYU8mVJT6PnuzfA0lQ/o3WlVCoVs4b4s++zPQRfTOCvE7EMbul+2+PzCorYXVIfI/V1QuiHqbERI9rW4+vdEXyw6SyKAj38nGjtVXNG60o919WXlQcuk5ZTAMDw1vUwN3kw/wY525ozf0QLJvx4hO+CI+nSyJEefncvb/mndDVsgFutm4aFGlpjl52dzbp165g/fz7dunWjYcOGzJo1Cx8fH5YsWUJ4eDgHDx5kyZIltG/fHj8/PxYvXkxGRoamcXJAQADr1q1j8ODBNGjQgF69evHBBx+wceNGCgoK7nh9Y2NjXF1dNTcnJyd9vO1ay8xYTWuvOkDl+9n9cuQq11KycbYx46mO+h2tK+XtYMULPYq3vHn/rzN33HT8cFQS6TkFOFqb0qpeHT1FKIQYWbI6tnRQvabU1t2qrpVpmVX/ozs8GIsmbqdPMxfGlMzUTP/1ODfSc+94fHZeoWYrx9q2GrZUjayxKygooLCwEHPzsnuAWlhYEBwczMiRIwHKPK9WqzE1NSU4OJgJEyZUeN7U1FRsbW0xNr7zlyU8PBx3d3fMzMwIDAxk7ty5+PpqvxnugyTQx4GDEUmERCbec71ITn4hX5WM1r3Qs6FBP7VO6u7L+mNXiUrM4rNt4bw7uFmFx5VOw/Zu4iKrJIXQI18nazr42HMoMoleTZxp5VnH0CHdtwldfdh/MYFGLrWrse79mvFQUw5GJHH+ejrTfz3O98+2v+3v190X4snOL8SjjgXNPez0HKl+3Fdid+zYsXs6TldDnDY2NnTq1In333+fpk2b4uLiwtq1awkJCaFRo0Y0adIEb29vZsyYwddff42VlRULFiwgLi6O2NjYCs+ZmJjI+++/z6RJk+547cDAQH788UcaN27M9evXmTNnDkFBQZw+fRoHh4o3j87NzSU3979PEWlp2tk+qzYJ9LWHHf/V2d3L/521h64Ql5aDm505owz8qdXcRM17jwTwzPJDrNgfyYi2Hvi7l/2loSiKZreJ3rIaVgi9mzm4Gd/siWB6Pz9Dh1IltuYm/Pa/IEOHUW2Ym6j58onWDP4ymN0XbvD9/ijG36aX6d8l07AP1cLVsKVUyv129zOwS5cuMW7cOPbs2YNaraZNmzY0btyYo0ePcubMGUJDQxk/fjzHjx9HrVbTp08fjIyKZ543bdpU5lxpaWn069ePunXrsmHDBkxM7r0HWmZmJg0aNOD111+/7UjmrFmzmD17drnHS0cIRfHoW4tZW8krLGL3az3uulo0O6+QrvP/JSEjlw+GBfBkoGGmYW/1wuqj/H0yljZedfjt+aAynxrPxaUxYOFezIyNOPZuX73XAwohRG228uBl3vnjFKZqI36fHETALSNyOfmFtH1/G5l5hfw+OYg2NazGMi0tDTs7u7vmDjWyxg6gQYMG7N69m4yMDKKjozl06BD5+fn4+BRn6W3btiUsLIyUlBRiY2PZvHkziYmJmudLpaenM2DAAKytrVm/fn2lkjoAKysrmjdvXmbF7a1mzJhBamqq5hYdfX8NFWszcxM1LT2Lfwjvpc5u1cHLJGTkUq+uBY+1rT41Ju8MaoaVqZqjV1L4NbTs97m0KXGXho6S1AkhhJY9FehFv2Yu5BUWMeWnY2Tlla2X33PhBpl5hbjZmdfqGmetJHZ79+7lqaeeolOnTly7VryMfOXKlQQHB2vj9HdkZWWFm5sbycnJbNmyhUceeaTM83Z2djg5OREeHs6RI0fKPF86UmdqasqGDRvK1ezdi9zcXM6ePYub2+174ZiZmWFra1vmJsor3V7s4F32jc3MLWDJ7ktAcZPg6rSNjqudOa/0LS7KnvfPOZIy8zTPbSvZRkxWwwohhPapVCo+GtECF1szIm5k8v5fZffy/ufUf6tha3ONc5X/Iq5bt47+/ftjYWHBsWPHNLVk6enpzJ07t8oB3s6WLVvYvHkzkZGRbNu2jZ49e+Ln58fYsWMB+PXXX9m1axcRERH8+eef9O3bl6FDh9KvXz9NfP369SMzM5Nly5aRlpZGXFwccXFxFBb+tz1U7969WbRokeb+9OnT2b17N5GRkYSEhPDoo4+SlpbGmDFjdPZeHxSBvsXb+txtxO6HA1EkZebh7WDJ8DYe+gitUsYE1aeJqw0pWfnM33wOgPi0HI5HpwDQu4nU1wkhhC7UtTLls5GtUKlg7aFozQ4TuQWFmlmT2roatlSVE7s5c+awdOlSvv322zLTmEFBQRw9erSqp7+t1NRUXnjhBZo0acIzzzxDly5d2Lp1qyaG2NhYnn76aZo0acKUKVN4+umnNa1OAEJDQwkJCeHkyZM0bNgQNzc3ze3mqdJLly6RkJCguX/16lVGjx6Nn58fw4cPx9TUlIMHD+LtXT1qvGqytt51MTZScS0lm6vJWRUek56Tzzd7IgB4uXcjjNXVZ7SulInaiPeHBgDw0+Fojl5JZkfJ8vqWnnVwtq38yLAQQoh7E9TAkf91bwDAm+tOcC0lm30XE0jPLcDZxqzG1dZVVpULfc6fP0+3bt3KPW5ra0tKSkpVT39bjz/+OI8//vhtn58yZQpTpky57fM9evS4p10CoqKiytz/6aef7jlGUTmWpsY0r2fHsSsphEQkUa+tZbljlgdHkZKVj6+TFY+0qn6jdaXa17fnsbb1+DX0Km+vP4WzrRkAfWU1rBBC6NwrfRuz71Iix6NTeOWnMDzqWgAwMMC1Vk/DghZG7Nzc3Lh4sfwG6MHBwdLbTVRaaZ1dSAV1dqlZ+XwXXDxaN7VPY9TV/IfzzYFNsLMw4UxsmmZfQqmvE0II3TNRG/HFqFZYmxlzKCqJ9SXbyA1sXvv2hr1VlRO7SZMm8fLLLxMSEoJKpSImJobVq1czffp0Jk+erI0YxQNEU2cXWb7O7rvgCNJzCmjsYs2gGvDD6WBtxusD/uuXVa+uBX7STFQIIfTC28GK94f6a+47WpvRvr69ASPSjypPxb7++uukpqbSs2dPcnJy6NatG2ZmZkyfPp0XX3xRGzGKB0g777oYqeByYhZxqTm42hXXoyVn5rE8OBKAV/o0rjFD6aPae/HLkascj06hT1OXWtsQUwghqqNhreux50IC649dY3BLt2o/06MNWmtQnJWVxZkzZygqKqJZs2ZYW9/7Ru4PmnttMvigGrIomBNXU/l8VCtNHd2H/5xj6e5LNHOz5a+XutSYxA4gJiWbnw5dYWxnH+pamRo6HCGEeKDkFxax+/wNgho61OgeojpvULxz506aNWum2R7L0tKSdu3a0aFDBwoLC/H392fv3r33e3rxAOtQMlR+sKTtSUJGLj/sjwJgWt+aM1pXyr2OBdP6+UlSJ4QQBmCiNqJPM5candRVxn0ndgsXLmTixIkVZo12dnZMmjSJBQsWVCk48WAK9C27gGLprktk5xfSsp6d7LEqhBBC3MF9J3bHjx9nwIABt32+X79+hIaG3u/pxQOsQ317VCqIuJHJ6ZhUVh68DBQvX5caNSGEEP/P3n1HR1VtDxz/TtqkTwqppJDQSSgJoUhHIAICojx5WFF/Kk9BKRbEhihF8In6REB8CnZ4KlLs9F5TIPSSEAKkkh5Infv7I8lIIIEASe7MZH/WmrXInZt7dxjI7Dnn7H1EzW45sUtNTb3uvqpWVlakp6ff6uVFI6azt6aNd/lI8ITvYigq1RMe4ELfVh4qRyaEEEIYt1tO7Jo2bUpcXFyNzx88ePC6+6cKcT3dgsrX2SVkFADwQmRrGa0TQgghbuCWE7uhQ4fy5ptvUlhYeM1zly9fZvr06QwbNuy2ghONV/fgv3sNdQ1yo0dzdxWjEUIIIUzDLbc7SU1NJTw8HEtLSyZMmEDr1uUjKkePHuWTTz6hrKyM6OhovLyk0/7VpN3JjWUWFBMxcx16BZY/3Z3uwZLYCSGEaLxqmzvccu2vl5cXO3fu5JlnnmHatGmGfVc1Gg133XUXCxculKRO3DI3Bxvmj+7EpeIySeqEEEKIWqqTBsVZWVmcOnUKRVFo2bIlrq6udRGb2ZIROyGEEELcjHofsbuSq6srXbp0qYtLCSGEEEKIW3TLxRNCCCGEEMK4NI79NYxM5ex35XZsQgghhBDXU5kz3GgFnSR2KsjLywPA399f5UiEEEIIYUry8vLQ6XQ1Pl8nxRPi5uj1ei5cuICTk5M03a2l3Nxc/P39SUpKkoITIyavk+mQ18o0yOtkOur7tVIUhby8PHx9fbGwqHklnYzYqcDCwgI/Pz+1wzBJzs7O8svNBMjrZDrktTIN8jqZjvp8ra43UldJiieEEEIIIcyEJHZCCCGEEGZCEjthErRaLdOnT0er1aodirgOeZ1Mh7xWpkFeJ9NhLK+VFE8IIYQQQpgJGbETQgghhDATktgJIYQQQpgJSeyEEEIIIcyEJHZCCCGEEGZCEjthtObMmUOXLl1wcnLC09OTkSNHcvz4cbXDErUwZ84cNBoNkyZNUjsUcZXz58/z8MMP4+7ujr29PZ06dSIqKkrtsMRVSktLef311wkKCsLOzo7g4GDefvtt9Hq92qE1alu3bmX48OH4+vqi0WhYtWpVlecVReGtt97C19cXOzs7+vXrx+HDhxs0RknshNHasmUL48ePZ/fu3axbt47S0lIiIyMpKChQOzRxHfv27WPJkiV06NBB7VDEVbKysujZsyfW1tb8/vvvHDlyhPfffx8XFxe1QxNXmTt3LosXL2bBggUcPXqUefPm8d577/Hxxx+rHVqjVlBQQMeOHVmwYEG1z8+bN4/58+ezYMEC9u3bh7e3N4MGDTLsEd8QpN2JMBnp6el4enqyZcsW+vTpo3Y4ohr5+fmEh4ezcOFCZs6cSadOnfjwww/VDktUeOWVV9ixYwfbtm1TOxRxA8OGDcPLy4vPP//ccGzUqFHY29vz9ddfqxiZqKTRaPj5558ZOXIkUD5a5+vry6RJk5g6dSoARUVFeHl5MXfuXMaNG9cgccmInTAZOTk5ALi5uakciajJ+PHjufvuuxk4cKDaoYhqrFmzhoiICO6//348PT0JCwvjs88+UzssUY1evXqxYcMGTpw4AcCBAwfYvn07Q4cOVTkyUZOEhARSUlKIjIw0HNNqtfTt25edO3c2WBxWDXYnIW6DoihMmTKFXr16ERoaqnY4ohrLly8nOjqaffv2qR2KqEF8fDyLFi1iypQpvPrqq+zdu5fnn38erVbLo48+qnZ44gpTp04lJyeHNm3aYGlpSVlZGbNmzeKBBx5QOzRRg5SUFAC8vLyqHPfy8iIxMbHB4pDETpiECRMmcPDgQbZv3652KKIaSUlJTJw4kb/++gtbW1u1wxE10Ov1REREMHv2bADCwsI4fPgwixYtksTOyKxYsYJvvvmG7777jpCQEGJjY5k0aRK+vr6MHTtW7fDEdWg0mipfK4pyzbH6JImdMHrPPfcca9asYevWrfj5+akdjqhGVFQUaWlpdO7c2XCsrKyMrVu3smDBAoqKirC0tFQxQgHg4+NDu3btqhxr27YtP/30k0oRiZq89NJLvPLKK4wZMwaA9u3bk5iYyJw5cySxM1Le3t5A+cidj4+P4XhaWto1o3j1SdbYCaOlKAoTJkxg5cqVbNy4kaCgILVDEjUYMGAAcXFxxMbGGh4RERE89NBDxMbGSlJnJHr27HlNy6ATJ04QGBioUkSiJpcuXcLCoupbtKWlpbQ7MWJBQUF4e3uzbt06w7Hi4mK2bNlCjx49GiwOGbETRmv8+PF89913rF69GicnJ8P6BZ1Oh52dncrRiSs5OTlds/bRwcEBd3d3WRNpRCZPnkyPHj2YPXs2o0ePZu/evSxZsoQlS5aoHZq4yvDhw5k1axYBAQGEhIQQExPD/PnzeeKJJ9QOrVHLz8/n1KlThq8TEhKIjY3Fzc2NgIAAJk2axOzZs2nZsiUtW7Zk9uzZ2Nvb8+CDDzZckIoQRgqo9rF06VK1QxO10LdvX2XixIlqhyGusnbtWiU0NFTRarVKmzZtlCVLlqgdkqhGbm6uMnHiRCUgIECxtbVVgoODlddee00pKipSO7RGbdOmTdW+L40dO1ZRFEXR6/XK9OnTFW9vb0Wr1Sp9+vRR4uLiGjRG6WMnhBBCCGEmZI2dEEIIIYSZkMROCCGEEMJMSGInhBBCCGEmJLETQgghhDATktgJIYQQQpgJSeyEEEIIIcyEJHZCCCGEEGZCEjshhBBCCDMhiZ0QQgghhJmQxE4IIYQQwkxIYieEEEIIYSYksRNCCCGEMBOS2AkhhBBCmAlJ7IQQQgghzIQkdkIIIYQQZkISOyGEEEIIMyGJnRBCCCGEmZDETgghhBDCTEhiJ4QQQghhJiSxE0IIIYQwE5LYCSGEEEKYCSu1A2iM9Ho9Fy5cwMnJCY1Go3Y4QgghhDByiqKQl5eHr68vFhbXGZdTzMDs2bOViIgIxdHRUfHw8FDuuece5dixY1XO0ev1yvTp0xUfHx/F1tZW6du3r3Lo0KEq5xQWFioTJkxQ3N3dFXt7e2X48OFKUlJSlXMyMzOVhx9+WHF2dlacnZ2Vhx9+WMnKyrqpeJOSkhRAHvKQhzzkIQ95yOOmHlfnJVfTKIqiYOIGDx7MmDFj6NKlC6Wlpbz22mvExcVx5MgRHBwcAJg7dy6zZs1i2bJltGrVipkzZ7J161aOHz+Ok5MTAM888wxr165l2bJluLu788ILL5CZmUlUVBSWlpYADBkyhHPnzrFkyRIAnn76aZo1a8batWtrHW9OTg4uLi4kJSXh7Oxcx38bQgghhDA3ubm5+Pv7k52djU6nq/E81RO7kpISUlJSuHTpEh4eHri5ud32NdPT0/H09GTLli306dMHRVHw9fVl0qRJTJ06FYCioiK8vLyYO3cu48aNIycnBw8PD77++mv++c9/AnDhwgX8/f357bffuOuuuzh69Cjt2rVj9+7ddOvWDYDdu3dzxx13cOzYMVq3bl2r+HJzc9HpdOTk5EhiJ4QQQogbqm3uoErxRH5+Pp9++in9+vVDp9PRrFkz2rVrh4eHB4GBgTz11FPs27fvlq+fk5MDYEgSExISSElJITIy0nCOVqulb9++7Ny5E4CoqChKSkqqnOPr60toaKjhnF27dqHT6QxJHUD37t3R6XSGc6pTVFREbm5ulYcQQgghRF1r8MTugw8+oFmzZnz22WfceeedrFy5ktjYWI4fP86uXbuYPn06paWlDBo0iMGDB3Py5Mmbur6iKEyZMoVevXoRGhoKQEpKCgBeXl5VzvXy8jI8l5KSgo2NDa6urtc9x9PT85p7enp6Gs6pzpw5c9DpdIaHv7//Tf1MxmbD0VT6vbeJmb8cUTsUIYQQQlyhwatid+7cyaZNm2jfvn21z3ft2pUnnniCxYsX8/nnn7NlyxZatmxZ6+tPmDCBgwcPsn379mueu7oCVVGUG1alXn1Odeff6DrTpk1jypQphq8r58lNTUFRKTN/Pcr3e88C8M2eRF4e3AYbK+maI4QQQhiDBk/sfvjhh1qdp9VqefbZZ2/q2s899xxr1qxh69at+Pn5GY57e3sD5SNuPj4+huNpaWmGUTxvb2+Ki4vJysqqMmqXlpZGjx49DOekpqZec9/09PRrRgOv/lm0Wu1N/SzGJvpsFlNWxHLm4iUAbCwtKCzRc/BcNhHNbn9dpBBCCCFun1kMtSiKwoQJE1i5ciUbN24kKCioyvNBQUF4e3uzbt06w7Hi4mK2bNliSNo6d+6MtbV1lXOSk5M5dOiQ4Zw77riDnJwc9u7dazhnz5495OTkGM4xNyVleub/dZx/LNrJmYuX8NXZ8t2T3RjQtnxKek9CpsoRCiGEEKKS0TUozsrKIjY2ltjYWCZPnlyr7xk/fjzfffcdq1evxsnJybDeTafTYWdnh0ajYdKkScyePZuWLVvSsmVLZs+ejb29PQ8++KDh3P/7v//jhRdewN3dHTc3N1588UXat2/PwIEDAWjbti2DBw/mqaee4tNPPwXK250MGzas1hWxpuR0ej6TV8Ry8Fx5McrITr7MuCcUnZ01J1Lz+P1QCrvjLzK+fwuVIxVCCCEEqJzYJSQkGJK4yse5c+dQFAUHB4daJ3aLFi0CoF+/flWOL126lMceewyAl19+mcuXL/Pss8+SlZVFt27d+Ouvvww97KC8sMPKyorRo0dz+fJlBgwYwLJlyww97AC+/fZbnn/+eUP17IgRI1iwYMFt/C0YH0VR+GZ3IrN+O0phiR5nWytm3due4R19Ded0DXIHICoxi5IyPdaWZjH4K4QQQpg0VfrY9e3blwMHDhh6srRr147Q0FA+//xz/vvf/zJgwACTLC6oLWPuY5eaW8hLPx5k64l0AHq1aMJ793fAR2dX5Ty9XiHsnXXkXC7h52d7EBbgWt3lhBBCCFEHjLqP3a5duxg/fjxJSUlkZWWxY8cOPv30UzQaDV27djXrpM6Y/R6XzF0fbmXriXS0VhZMH96Or57oek1SB2BhoaFLRdGErLMTQgghjIMqid2ePXvYtm0b48eP58SJE2qEIK6QW1jClP/F8sy30WRfKiHE15lfnuvF4z2DsLCouY1L9+CKxC7+YkOFKoQQQojrUCWxCwsLY+vWrYwePZq77rqL8ePHk5aWpkYojd6e+IsM+XAbK6PPY6GB8f2b8/OzPWnp5XTD7+1Wsc5u/5ksyvQmv+WwEEIIYfJUXfH+4IMPcvjwYVxcXAgJCUGv11NWVqZmSI1GUWkZc347ypjPdnM++zL+bnb8b9wdvHRX7RsOt/N1xklrRV5RKUcuyDZpQgghhNpUL2W0t7dn1qxZ7Nmzh2HDhjFgwAD+/e9/c/nyZbVDM1vHU/IY+clOPt0aj6LA6Ag/fp/Y56YbDVtaaIhoVl40sSdBpmPVpCgKW0+kk1lQrHYoQgghVKR6YlcpODiY1atX8+2337J06VKCg4PVDsns6PUK/90Wz/CPt3M0ORc3Bxs+faQz8/7REUftrXW+6RZcPh0rBRTq+v1QCo9+sZe7/7ON4yl5aocjhBBCJQ2e2J09e/a6zw8aNIgDBw4wdepUAM6fP98QYZm989mXeei/e5j561GKy/Tc2caTPyf14a4Q79u6breg8lG+fWcy0cs6O9X8GpcMQHJOIf9YvJPdUtAihBCNUoMndl26dOGpp56qsi3X1QoKCrC3tyc0NJSVK1c2YHTmR1EUVsWcZ/CHW9kVfxE7a0tm39uez8dG4OF0+/vXhjbVYW9jSfalEo6nykiRGopL9Ww5Xt53MNjDgbzCUh79fC9rD1xQOTIhhBANrcF3njh69CizZ89m8ODBWFtbExERga+vL7a2tmRlZXHkyBEOHz5MREQE7733HkOGDGnoEM1G9qViXl91iF8Olo/mdPJ34YN/diKoiUOd3cPa0oLOga5sO5nBnviLtPUxrobLjcGehIvkF5XSxFHLr8/1Zsr/Yvn9UArPfR9Dam4hT/aWZQ1CCNFYNPiInZubG//+97+5cOECixYtolWrVmRkZHDy5EkAHnroIaKiotixY4ckdbdh28l07vpwK78cTMbSQsOUQa348V931GlSV6m7rLNT1Yaj5a2CBrb1xM7GkgUPhvNYj2YAzPz1KO/8ckSmyYUQopFQba9YW1tb7rvvPu677z61QjBLhSVlvPv7MZbtPANAcBMHPvhnJzr6u9TbPSvX2e1NyERRFDSampsai7qlKArrjqQCMLCtF1BerTx9eDt8dLbM+f0Yn29PICW3kPmjO6K1srze5YQQQtyCotIyPlp/ksgQbzr66VR9HzSaqlhRN179Oc6Q1D3SPZBfn+9dr0kdQAc/F2ytLbhYUMyptPx6vZeo6lhKHuezL2NrbUHPFk0MxzUaDeP6NuejMZ2wttTw68FkHv18LzmXS1SMVgghzNOOUxks3Hyap7/aj6LyBIkkdmbm+Ttb0szdnqWPd+GdkaHY2dT/CI2NlQXhAeX97HbLdGyDWl8xWterRZNqX+t7OjVl2eNdcdRasSchk/sX7+RCtvSIFEKIuvRbXAoAQ0K9r7sVZ0OQxM7MNGviwIYX+tG/tWeD3rdyezHZN7ZhrT9adRq2Oj1bNOF/4+7Ay1nLidR87lu4k2MpslOIMC6fb0/gqa/2k1soo8rG4rs9Z3n392OUlunVDsWoFZfq+etwRWLX3kflaCSxM0uWKnxa6BZcvs5uT8U6O1H/UnMLOXAuB4A7214/kW/n68zKZ3vSwtORlNxC7l+0i52nMxoiTCFu6OeYc7zzyxHWHUnlf/uS1A5HACk5hby+Ko7FW07zxY4EtcMxarviL5JbWN6ZoMtN7uBUH1RN7M6ePVttEqAoyg0bGQvj0snfBRsrC9LzikjIKFA7nEahshq2k78Lnk62Nzy/qYsdP/7rDro2cyOvqJTHvtjHGul1J1QWczaLqT/FGb5evi9JPhwagf/tT6KymH7+uhMkXpTf6zX5raKl2OBQL1UGVq6mamIXFBREenr6NcczMzMJCgpSISJxq2ytLelUUaQhbU8aRuU07KB2NU/DXs3F3oav/q8rQ9t7U1ym5/nvY/jvtvj6ClGI60rJKWTc11EUl+rp19oDO2tLTqXlE302S+3QGrUyvcKKipFTdwcbCkv0vPJTnCTc1Sgp0/PnkfJp2KGh6k/DgsqJXU2tMfLz87G1vfEIhDAu3Svansg6u/p3qbiU7afKp1Kvt76uOrbWlnz8QNVed2+vlV53omEVlpTx9Nf7ScsrorWXEwseDGdYh/I3xuV7ZTpWTdtOpnM++zI6O2uWP90dW2sLdsVfNCR74m974jPJvlSCm4MNXYPUn4YFlRK7KVOmMGXKFDQaDW+88Ybh6ylTpjBx4kT++c9/0qlTp5u65tatWxk+fDi+vr5oNBpWrVpV5fnU1FQee+wxfH19sbe3Z/DgwYamyJVOnz7Nvffei4eHB87OzowePZrU1NQq5zRr1gyNRlPl8corr9zKX4PZ6XZFo2L5ZFe/tp3MoLhUj7+bHa28HG/6+yt73b06tA0AX+xI4LnvYygsKavrUIW4hqIovPzjQQ6ey8HV3pr/jo3AUWvFmK7+APxyMJk8KaJQzfd7y5dC3RvWlJZeTrwY2RqAWb8dJTW3UM3QjM5vh8qnYe8K8cLK0jjKFlSJIiYmhpiYGBRFIS4uzvB1TEwMx44do2PHjixbtuymrllQUEDHjh1ZsGDBNc8pisLIkSOJj49n9erVxMTEEBgYyMCBAykoKDB8f2RkJBqNho0bN7Jjxw6Ki4sZPnw4en3ViqC3336b5ORkw+P111+/5b8LcxIe4Iq1pYbknEKSMqWlRn3acEU17K02wtRoNDzd54ped3HJPPrFXnIuyRuqqF8LN59mzYELWFloWPhQZ/zd7IHy3yEtPB25XFIm6z9VkpZbaFi/+0DXAAAe7xlERz8deYWlvLn6kJrhGZUyvcKfhyrbnBjHNCyotPPEpk2bAHj88cf56KOPcHa+/f1FhwwZUuMWZCdPnmT37t0cOnSIkJAQABYuXIinpyfff/89Tz75JDt27ODMmTPExMQY4lm6dClubm5s3LiRgQMHGq7n5OSEt7f3bcdsbuxsLOng50JUYha7Ey4S4G6vdkhmqUyvGH7xDrrJadjq3NOpKR6OWsZ9HcXehEz+sXgnXz7RFV8Xu9u+thBXW3cklX//dRyAt0aEcEdzd8NzGo2GMV38mfnrUVbsS+KhboFqhdlo/RB1jlK9QniAC629nYDyEf53R3Vg+Mfb+fNwKr/HJRtFWw+17U3I5GJBMS721lX+HatN1XHDpUuX1klSdyNFRUUAVdbtWVpaYmNjw/bt2w3naDQatFqt4RxbW1ssLCwM51SaO3cu7u7udOrUiVmzZlFcXHzD++fm5lZ5mKtuhnV2UkBRX2KTsrlYUIyTrRVd6mhNR48WTfjfv8p73Z1My+fehTs4mmy+/06FOo6n5DFpeQyKUr4zzsPdr03c7g1rirWlhoPncjh8IUeFKBsv/RVFE5WjdZXa+jjzbL/mALyx+jDZl67/vtcY/BZXPg0b2c4LayOZhgUj6GO3YcMGXn31VZ588kmeeOKJKo+60qZNGwIDA5k2bRpZWVkUFxfz7rvvkpKSQnJy+QvTvXt3HBwcmDp1KpcuXaKgoICXXnoJvV5vOAdg4sSJLF++nE2bNjFhwgQ+/PBDnn322evef86cOeh0OsPD39+/zn42Y/P3OjspoKgvldWw/Vp71ukvk7Y+5b3uWno6kppbxOjFu9h5SnrdibqRWVDMk1/to6C4jDuC3XlzeLtqz3N31BIZUj4jIj3tGtbO0xc5m3kJJ60Vd3e4dkRu/J0taOHpSEZ+EbN+PapChMajTK/whxE1Jb6SqondjBkziIyMZMOGDWRkZJCVlVXlUVesra356aefOHHiBG5ubtjb27N582aGDBmCpWX5NkweHh788MMPrF27FkdHR3Q6HTk5OYSHhxvOAZg8eTJ9+/alQ4cOPPnkkyxevJjPP/+cixdrTmSmTZtGTk6O4ZGUZL6/rDoHumJpoeFc1mXOy9ZV9aJyG7GBN2hKfCvKe931MPS6G7t0L6tjz9f5fUTjUlKm59lvo0jKvEyAmz0LHwq/7oeSMV3KP/z+HHNeCnoa0Pf7yosmRoY1xd7m2pVaWitL5o5qj0ZTPmW7/WTj/eAXlZhFel4RTrZW9Gze5Mbf0IBUWWNXafHixSxbtoxHHnmk3u/VuXNnYmNjycnJobi4GA8PD7p160ZERIThnMjISE6fPk1GRgZWVla4uLjg7e193Z563bt3B+DUqVO4u1c/x67VaqtM8ZozR60VoU11HEjKZk/8Re4L91M7JLNyJqOAk2n5WFlo6NeqfraN09lb89X/dWXK/2L5LS6FictjSc0t5KnewbdcqCEat7fWHGZ3fCaOWiv+OzYCVweb657fs3kTmrrYcT77Mn8cSmFkWNMGirTxuphfZNgW6+pp2Ct1DnTj0e6BfLkrkWk/H+TPSX2qTQLNXeU07KB2XthYqT75WYWq0RQXF9OjR48GvadOp8PDw4OTJ0+yf/9+7rnnnmvOadKkCS4uLmzcuJG0tDRGjBhR4/ViYmIA8PExrqFYNXWXdXb1pnIatmuQGzp763q7j621JQseCOfxns0AmP3bMWasPUKZ9LoTN+nr3Yl8u+csGg18NKYTrbycbvg9FhYa/lkxalfZekPUr5+iz1FSptDRT0c73+uvfX9pcBuautiRlHmZ9/860UARGg+9XuGPQ8bVlPhKqiZ2Tz75JN99912dXCs/P5/Y2FhiY2MBSEhIIDY21rA12Q8//MDmzZsNLU8GDRrEyJEjiYyMNFxj6dKl7N69m9OnT/PNN99w//33M3nyZFq3Lu/hs2vXLj744ANiY2NJSEjgf//7H+PGjWPEiBEEBNT8Caex+XvfWFlnV9fWX9HmpL5ZWGiYPjyE1+9uC8CynWd47vtomRoTtbbzdAZvrTkMwMt3tWHATfy7/UdnPyw05X0x49Pz6ytEQXlLsMqm0NcbravkqLVi1r2hACzdkUBsUnZ9hmd0YpKyScktxFFrRe9WxjUNCypPxRYWFrJkyRLWr19Phw4dsLauOgIxf/78Wl9r//799O/f3/D1lClTABg7dizLli0jOTmZKVOmkJqaio+PD48++ihvvPFGlWscP36cadOmkZmZSbNmzXjttdeYPHmy4XmtVsuKFSuYMWMGRUVFBAYG8tRTT/Hyyy/fyo9vtiKauWGhgTMXL5GaW4iXs+wiUhdyLpWw70z52tOGSOwqPdk7GE9nW16omJq9kL2bj8Z0ItDdocFiEKYn8WIBz34bTZleYWQnX/7VN/imvt/XxY6+rTzYdDyd/+0/xytD2tRTpHWrtEzPqtgL9Gzhjo/ONFoG7UnIJD6jAAcbS4Z39K3V9/Rr7cm9YU35OeY8U388yNrnehndlGR9qZyGHdjWE62V5Q3ObngaRcUtAq5MxK5W2SjYHOXm5hqKMxqi3Ysahn28jUPnc/loTCfu6STrY+rC6tjzTFweS2svJ/6c3KfB77/zdAbjvo4ir7AUextLXr+7HQ909Zd1d+IaeYUl3LdwJyfT8unop2PFuDuwtb75N8A/DqXwr2+iaOKoZde0O42qpURNPtl0ivf+PE77pjrWTOhpEv8/Ji6PYXXsBR7oGsCc+9rX+vsyC4oZOH8LmQXFTBnUiucHtKzHKI2Doij0fHcjF3IK+fSRztwV0nA9bWubO6g6YlfZqFiYn25B7hw6n8uehExJ7OrIuspq2Hb1UzRxIz2aN+H3ib158YcD7I7P5NWf41h/NJV3R7XH00lGZUW5Mr3C5BWxnEzLx8tZy5JHI24pqQMY0NaTJo5aMvKL2HgsrUHfRG9FXmEJn22LByDufA7rjqQaWrcYq6yCYn6PqyyauLlWXG4ONrw1IoTnv4/h440nGRLqTctarKE0ZQfO5XAhpxB7G0v6tvJQO5xqqf7xZ9u2bTz88MP06NGD8+fL2yp8/fXX1zQFFqbl70bFss6uLhSX6tlyPB1o2GnYq/m52vPdk915/e622FhZlL/ZfrCV3+OSb/zNolH491/HWX80Da2VBUseibitpRjWlhb8o3N5Zb0pbED/5c4zZF8qoXKQbv66E+iNvOBoZcx5isv0hPg6076p7qa/f3gHHwa08aSkTGHqTwfNvsCq8nfdnW08b/kDS31TNbH76aefuOuuu7CzsyM6OtqwQ0ReXh6zZ89WMzRxm7oGuaHRwOn0AtLzitQOx+TtTcgkr6iUJo5aOvq5qBqLhYWGJ3sHs3ZCL9r5OJN1qYRnvo1myopYci7LPrON2aqY8yzafBqAef/oQEd/l9u+ZmV17ObjaSTnGG9vzNzCEj7blgDAjBEhOGmtOJaSx+8V1ZPGSFEUQ9XxmK4BtzRtrNFomHlvKI5aK6LPZvP1rjN1HKXxUBSF3w6VJ3ZDjawp8ZVUTexmzpzJ4sWL+eyzz6oUTvTo0YPo6GgVIxO3y8XehtYVQ/J7E6Ttye2qrIYd0MYTCwvjWLPT2tuJVeN7Mr5/cyw05Z/8h3y4VXaraKQOJGXz8k8HAXimX/M6W4IR1MSBbkFu6BX4Yf+5OrlmfVi24ww5l0to4enIQ90CeaJXef/TD9afMNpRrKjELE6l5WNnbck9nWpXNFEdH50dUyuKW+b9eZxzWZfqKkSjcvhCLkmZl7GztqR/a3WWxNSGqond8ePH6dPn2kXgzs7OZGdnN3xAok51l+3F6oSiKFesr1NvGrY6NlYWvHRXG3741x0EuttzIaeQB/+7hxlrD0tblEYkNbeQp77aT3GpnoFtPXkpsnWdXn9MxdqvFfuSjHJqM+dyCf+tWFv3/ICWWFpo+L/eQTjbWnEqLZ+1By6oHGH1vqsYrRvWwQdn29vri/lQ1wC6NnPjUnEZr/58CBXrMuvNrxXTsP3beGBnY5zTsKByYufj48OpU6euOb59+3aCg2+uNF4Yn27SqLhOHEvJ43z2ZbRWFvRqYXw9k6C8G/1vz/fmoW7lPbCW7jjDsI+3E3dONnE3d4UlZTz91X7S8opo5eXIh2PC6nxUeUioD862VpzPvsyO08Y3IrxsxxlyC0tp6enI3RVTdM621jzdp/x97KMNJykt06sZ4jVyLpXw68HyROWBbrffh9XCQsO7o9pjY2XB1hPp/BxjXlsRKopiWF83xAibEl9J1cRu3LhxTJw4kT179qDRaLhw4QLffvstL774Is8++6yaoYk60LUisTuemkdmQbHK0Ziuyr1he7dsYtSfEh20Vsy6tz1LH++Ch5OWU2n53LtwB/8xwjc1UTcUReGVnw5y4FwOLvbW/PfRLjhq677Zgq21JfdWbCu23MiKKHIul/Df7eWjdRMHlo/WVXqsZxCu9tYkZBQYXaKzKvY8RaV6Wns5EVYHayEBgj0cmVjR8uTtX46QkW8+66uPJudx5uIltFYW9G9jvNOwoHJi9/LLLzNy5Ej69+9Pfn4+ffr04cknn2TcuHFMmDBBzdBEHXB31NLS0xGQdXa3oyF3m6gL/Vt78tekPtzd3odSvcL8dSf4x+JdsnuAGVq8JZ5VsRewstCw8KFwAtzt6+1e/+xSPqr01+EUo/qg+MX2BPIKS2nl5XjN9lKOWiv+1bc5AP/ZeJISI/mAc2XRRF33ony6TzDtfJzJvlTCjLVH6uy6avu9omiibyuPevnwUpdUb3cya9YsMjIy2Lt3L7t37yY9PZ133nlH7bBEHZHtxW5Pam4hByqmM+9sa9yfEq/k6mDDggfD+PCfnXCytSI2KZuh/9nG17vOmOXam8Zo/ZFU5v15DIDpI0Lo0bx+lwm083Wmg5+OkjKFldHGUUSRc6mEL7aXV8JOHNCq2inoR+9oRhNHLUmZl42m+CM2KZtjKXlorSy4N8yvTq9tbWnBvH90wNJCw9oDFwwzDqZMURTD+jpjroatpFpiV1JSQv/+/Tlx4gT29vZERETQtWtXHB0d1QpJ1INuQeUFFDJid2s2HksDoJO/i8k1AdZoNIwMa8qfk/rQs4U7hSV63lh9mLFL95GSU6h2eOI2nEjNY+LyGBQFHu4ewCPdAxvkvpWtT5bvSzKKDwifb48nr6iUNt5ODAmtvhGxnY0lz/YrH7VbsPEkRaXqFxVV7gt7d3sfdPa3VzRRndCmOp7sXV4V/PqqQ+QWmnYbpBOp+cSnF2BjacEAE/iArVpiZ21tzaFDh0xiuxVx6ypH7I4k50qPs1tQ+Wl3kJFVw94MXxc7vn6iG9OHt0NbsbD6rg+3Gm2loLi+rIJinvxyPwXFZXQPdmP68JAGu/eIjr7YWVtyKi2f6LNZDXbf6mRfKmbpjjMATBzQ8roFIw92C8DLWcuFnEJDUqWWvMIS1lT836uLoomaTB7Yimbu9qTkFjL392P1dp+GULk3bJ9WTXC6zerhhqDqVOyjjz7K559/rmYIop55OtkS3MQBRYH9Z2TU7mZcKi5le0VPOFNZX1cTCwsNj/cM4tfne9G+qY6cyyU8930Mz38fQ/Yl41kvJa6vpEzPs99GczbzEv5udix8qHOD7t/qZGvN3R3Kp8LUTpA+355gGK270VZnttaWTOjfAijfS1bNVkBrDlzgckkZLTwdiQh0rbf72FpbMue+DgB8u+esSe9CVLm+ztirYSupmtgVFxezaNEiOnfuzLhx45gyZUqVhzAPf6+zk8TuZmw/mUFRqR4/VztaeZnHEoUWnk6sfLaHodfXmgMXuOvDrWw9ka52aKIW3l57hF3xF3GwseTzsV1wc7Bp8BjGVEzH/nIwmTyVpviuHK2bNPD6o3WVRnfxp6mLHWl5RXyzO7GeI6yZYaeJLnVbNFGdO5q780DX8lHBV1bGmWRvy1NpeZxIzcfaUmMyH7BVTewOHTpEeHg4zs7OnDhxgpiYGMMjNjZWzdBEHapcZ2fKn9jUcGU1rDktWbC2tGDKoFb89EwPgps4kJpbxKNf7OXN1Ye4XGx6v/gbi292J/L17kQ0GvhoTBitVNrsvXOgKy08HblcUsbaA+rsUfzZtnjyi0pp6+NMZLvrj9ZV0lpZ8tyd5aN2i7ec5lJxaX2GWK24czkcOp+LjaUF94XXbdFETaYNbYOXs5aEjAI+2nCyQe5Zl36PK98SrmeLJvWyHrE+qJrYbdq0qcbHxo0b1QxN1KHKfnaHLuSSX9Twv8xMUZleYcPR8sIJU15fdz2d/F349fnejL2jfOH9V7sSufs/24hNylY3MHGNXacv8taawwC8dFdrVXdA0Wg0hlG7FfvONvj9swqKWXaTo3WVRnX2I8DNnoz8Yr7c2fCjdt9X/H0NDvVusNFWZ1tr3rknFIAlW+M5dN60mpb/VrHX79WtbIyZUVTFCvPm62KHv5sdZXpF1tnVUmxSNhcLinGytTIkxubIzsaSGfeE8tUTXfF2tiU+o4BRi3by/l/HZfTOCFT2O3vqq/2U6hXu6eTLMxV92dR0b1hTrC01HDiXw5ELuQ1678+2xVNQXEaIrzORN5ngWltaGBr4frr1dINOJRcUlbK6okly5RZtDSUyxJu72/tQpleY+tNBk2lYnpBRwNHkXCwtNCb1AVuqYkWDMEzHyjq7Wqmchu3X2rNBF6erpU8rD/6c1IcRHX0p0yt8vPEU/f+9mR/2JxntBurmLinzEo98vpdpK+PILyqle7Abc0d1MIrf2e6OWsMUaEOO2mUWFPPlzjMATBrY6pb+Lu7p5EuwhwPZl0oM6/Qawi8HL1BQXEYzd3vuqNjHuyG9NSIEnZ01hy/k8tm2hAa//62orIbt0dwdVxXWk94qqYoVDeLvfWONa53d4i2nGbVoJxeyL6sdShWVbU4GmkDPpLqis7fmPw+EsfChcJq62JGSW8hLPx5k2Mfb2XZSiisail6v8NWuM9z14Va2n8rA1tqC1+9uy7dPdsfW2ni2tKvsafdzzPkGW5S/ZGv5aF1oU+db/r9pdcWo3Wfb4sm51DCjdt9VVBGP6RqgSnLu4aTljWHtAPhw/QkSMgoaPIabVVkNawpNia9kNlWxW7duZfjw4fj6+qLRaFi1alWV51NTU3nsscfw9fXF3t6ewYMHc/Jk1YWcp0+f5t5778XDwwNnZ2dGjx5NamrVrtlZWVk88sgj6HQ6dDodjzzyCNnZ2bfy4zcq3Ss+IR48l6PKouHqnL14iX//eZyoxCzD+iFjkHixgJNp+VhZaOjXqvEkdpWGtvdhwwt9eXVoG5xtrTianMsjn+9l7Bd7OZbSsNNujU3ixQIe+Gw3b64+zKXiMro2c+OPiX14sndwlT1QjUGvFk1o6mJHbmEpf1Ssg6pPF/OL+GrXGQAmDbi10bpKwzv40srLkbzCUj6v2Ge2Ph25kMuBpGysLTX8o3PDFE1UZ1R4U3q3bEJRqZ5XfjqI3ohH489evMSh87lYaLjpKXe1mU1VbEFBAR07dmTBggXXPKcoCiNHjiQ+Pp7Vq1cTExNDYGAgAwcOpKCgwPD9kZGRaDQaNm7cyI4dOyguLmb48OHo9X+vB3jwwQeJjY3ljz/+4I8//iA2NpZHHnnktv4eGgM/Vzt8dbaU6hWiE7PVDgco37uxtOIXy19HUtl4zDi2vllfUTTRNcjNZKqw6pqttSVP92nOlpf680TPIKwtNWw5kc7Qj7Yx9ceDpObKzhV1Sa9X+GJ7AoM/3MaehEzsbSyZMSKE5U93p1kTB7XDq5aFhYbREZU7UdT/dOySbfFcKi6jg5/utncfsLDQMHlgKwC+2HGGrHre+7by7yeynTdNHLX1eq/r0Wg0zL63PXbWluxJyDQUcxijytG67sHuuKv4d3YrVN3JdtOmTXV2rSFDhjBkyJBqnzt58iS7d+/m0KFDhISUd0lfuHAhnp6efP/99zz55JPs2LGDM2fOEBMTg7OzMwBLly7Fzc2NjRs3MnDgQI4ePcoff/zB7t276datGwCfffYZd9xxB8ePH6d169Z19vOYG41GQ7dgd36OOc+ehIv0alm/+0reSHx6vmG/yX6tPdh8PJ3paw7To3kT1aeb/p6GNa1PifXB1cGGN4e3Y2yPQOb9cZxf45JZsT+JNQcu8FTvIJ7u29zoN+Q2dvHp+bz840H2J5bv5NCjuTtzR3XA381e5chu7P4IPz7acILd8ZkkZBQQVE9JaEZ+EV9VVLFOGtiyTqYy7wrxpp2PM0eSc/l0azyvDGlz29eszuXiMn5WqWiiOv5u9rx0V2ve/uUI7/52jAFtvPDWGd92iZXVsENMbBoWVB6xayhFRUUA2Nr+/Y/H0tISGxsbtm/fbjhHo9Gg1f6dmdva2mJhYWE4Z9euXeh0OkNSB9C9e3d0Oh07d+687v1zc3OrPBqjv9fZqV9A8Z8NJ9ErMKCNJ588GI63sy1JmZdZuOmUqnHlXCphb0XlsCR2fwt0d+CTh8L56ZkedA505XJJGf/ZeIp+723muz1nTabKzpiU6RWWbD3NkI+2sT8xCwcbS2bdG8q3T3YziaQOyivu+7byAGDFvvrbiWLJ1ngul5TR0U9H/9Z1szzCwkLDlEHlo3Zf7jxDel5RnVz3ar/GJZNXWIq/mx09m6v7gbrS2B7N6OTvQl5RKa+vOmQU+/5e6VzWJQ4kZaPRwF0hpvd7WNWPum+//fZ1n3/zzTfr5D5t2rQhMDCQadOm8emnn+Lg4MD8+fNJSUkhObliuLV7dxwcHJg6dSqzZ89GURSmTp2KXq83nJOSkoKn57X/qT09PUlJqXmNx5w5c5gxY0ad/CymrFvFOrvYpGwKS8pUGxk7mZrH6oq9EicPaoWD1orpw9vxzLfRLN4Sz8iwpgR7qLPTw+YTaZTpFVp5ORLgbhpvrg2pc6ArP/7rDv44lMLcP45x5uIlXv05ji92JPDq0Db0b+1pFFWbxu5kah4v/XjQ0DOwd8smvDuqA01d7NQN7Bb8s0sAm46n82PUOV6IbFXnVeTpeVesrbvFStiaDGjrSUc/HQfO5bB4y2lDcUFdWm7YaSLgpnru1SdLCw3z/tGBu/+zjfVHU/k1LplhHXzVDsugcs1m12ZueDoZ32jijag6Yvfzzz9Xefzvf/9j7ty5vP/++9cUP9wOa2trfvrpJ06cOIGbmxv29vZs3ryZIUOGYGlZnlx4eHjwww8/sHbtWhwdHdHpdOTk5BAeHm44B6j2P7WiKNf9zz5t2jRycnIMj6Qkdfc4VEszd3s8nbQUl+mJOZutWhwfbjiJopR/EgttqgPKG3b2beVBcZmeN1cfVu0T5DqZhr0hjUbDkPY+/DW5L9OHt8PV3ppTafk8sWw/D362x+QaoDak0jI9n2w6xd3/2U5sUjZOtlbMG9WBr57oapJJHZQnR00cbcjIL2LjsbQ6v/6SracpLNHTyd+Ffq096vTaGo2GyRWjdt/sTqzztaMnUvPYn5iFpYWG+1UsmqhOKy8nnu1XvhPH9NWH632d4c2obHNiatWwlVRN7K4sloiJieHQoUMkJyczYMAAJk+eXKf36ty5M7GxsWRnZ5OcnMwff/zBxYsXCQoKMpwTGRnJ6dOnSUtLIyMjg6+//prz588bzvH29r6mShYgPT0dL6+a34i1Wi3Ozs5VHo1R5To7gD0J6rQ9OZqcy68Hy//TTqpYvFwZ24wRIdhYWbD9VAa/xjX8VkXFpXq2HC9v66FmZ39TYWNlweM9g9j8Un/G9Q3GxsqCXfEXGfbxdiaviOW8kbWwUduxlFzuXbiT9/48TnGZnjvbeLJucl9GN8CeofXJ2tKCURVJS11Px6blFfL17rpdW3e1vq086BzoSlGpvs6XgiyvaHEyoI0nns7GN/L0bP/mtPJy5GJBMa+sPGgUU7LJOZeJrhh4GBxau+3ijI3RrbFzdnbm7bff5o033qiX6+t0Ojw8PDh58iT79+/nnnvuueacJk2a4OLiwsaNG0lLS2PEiBEA3HHHHeTk5LB3717DuXv27CEnJ4cePXrUS7zmRu11dh+uL9/p5O4OPrT1qZpgN2viwLP9yrvqv732SINvML43IZO8olKaONrQyc+lQe9tynR21kwb0paNL/RlZKfy6ZyfY87T/9+beff3Y+SqtFG8sSgp0/PR+pMM/3g7cedzcLa14v37O/L52AijXLR+K/5ZUR27+XgayTl1l9B/uiWewhI9YQEuhrV8dU2j0fBCxajd93uT6uwDSWFJGStjygvEHugWUCfXrGtaK0vmj+6EtaWGPw+n8t1e9atkK6dhIwJd8TLCZLg2jC6xA8jOziYn5+amU/Lz84mNjTW0SUlISCA2NpazZ8v/ofzwww9s3rzZ0PJk0KBBjBw5ksjISMM1li5dyu7duzl9+jTffPMN999/P5MnTzZUu7Zt25bBgwfz1FNPsXv3bnbv3s1TTz3FsGHDpCK2lroHlyd20WezKCpt2C2jDp3P4c/DqWg0MHlgy2rP+Vff5gS625OWV8SH6xt2w+rK3SYGtPEymrUwpsTP1Z4Px4SxZkJPuge7UVyqZ/GW0/Sdt4llOxIoLm18BRaHzucwYsEOPlh/gpIyhUHtvFg/pS+jOvuZ9Cjd1YI9HOka5IZegR/3n6uTa6blFvKNYbSubtfWXa1Hiybl/2bL9CzYWDejdn8eTiH7UglNXezo07J+ktK6ENpUx9TB5RXB7/xyhJOpearG83uc6VbDVlK1eOI///lPla8VRSE5OZmvv/6awYMH39S19u/fT//+/Q1fVzY4Hjt2LMuWLSM5OZkpU6aQmpqKj48Pjz766DWjgsePH2fatGlkZmbSrFkzXnvttWumhL/99luef/55Q0I4YsSIanvnieo193CsWA9TzMFzOXRp1nD7oH6wrny07p6OvrTwdKr2HFvr8v5djy3dx7KdZ/hHZ79rRvbqg6Iof6+vk2nY29LBz4Xvn+rOxmNpzP7tKKfTC3hr7RGW7TzDK0PacFeIt1klNdUpKi1jwcZTLNp8mlK9gqu9NTPuCWV4Bx+z/dkf6OrP3oRMVuxPYnz/Frf94WjRltMUleoJD3ChTwO0Z5oyqDWjP93FD/uTeKZv89sunvpuT/mgxugIf6NrLn21J3oGseVEOttOZvDc9zGsGt9TleK6tNxC9iWWzyYNMdFpWACNouKk9pXr2wAsLCzw8PDgzjvvZNq0aTg5Vf/ma+pyc3MNxRmNcb3ds99G8VtcCi9GtmLCndWPnNW1mLNZ3LtwJ5YWGtZP6XvDflfPfBPF74dS6Bzoyg/j7qj3EbRjKbkM/nAbWisLYt+MxM7GeLZuMmWlZXpW7E/ig3UnyMgvX5wdEejKq3e3JTzAVeXo6sfBc9m8+MMBTqTmAzC0vTczRoTi4WRaTVZvVmFJGV1mrSevsJSv/68rvW9jlCott5De8zZRVKq/7WvdjEc+38O2kxn8o7Mf/76/4y1f53R6PgPe34KFBna8cic+OuMvjEnLK2ToR9vIyC/msR7NeGtESIPH8NWuM7y5+jBhAS78/GzPBr//jdQ2d1B1KjYhIaHK4/Tp0+zevZvZs2ebbVInoFtQZQFFw62zm18xWndvWNNaNTF9Y1g77G0siUrM4sfoupnauZ7KpsS9WzaRpK4OWVla8FC3QDa/1J/n72yBrbUF+xOzuG/hTsZ/G82RC+bTU7KwpIx3fz/GyE92cCI1H3cHGxY+FM7ChzqbfVIH5aPt94Y1BWD5bRZRLNxcPloXEehKrxYN1/utsq/dyuhzxKfn3/J1KotI+rf2NImkDsDTyZb3KpLZZTvPqLITkKEaNtR0p2FBpcRu48aNtGvXrtpGvTk5OYSEhLBt2zYVIhMNoVvFOruoxCxKGqCx7L4zmWw7mYGVhYbnazlC6Otix6SKdXhzfjta76X46yq2EZM2J/XDUWvFlMjWbH6xP6Mj/NBoyhu3Dv3PNh75fA9bT6QbRUXerYpKzOLu/2xj8ZbT6BUY0dGXdVP6mmy7hlv1zy7lRRR/HU4h8xb/z6bkFBoW8U8eVL9r664WFuDKnW080SvlTdRvRVFpGT9GVRRNdDXOooma9G/tyRM9y2fyXvzhIGkNuHVgel4ReysGG0y1GraSKondhx9+yFNPPVXtUKJOp2PcuHHMnz9fhchEQ2jl6YSLvTWXisuIa4CeY/P/Kh+tuz/C76bWrTzeM4hWXo5kXSph3p/H6ys80nILOVDRKPbONnXT1V5Uz1tny7x/dOS353szrIMPFhrYdjKDR7/Yy5CPtvFj1DmTKrJIyrzEjLWH+cfinZxOL8DDScuSRzrznwfCcHOwUTu8Bhfiq6N9Ux0lZYphy8CbtWjzKYpL9XRp5kqP5u51HOGNVY7arT5w4ZYKCdYdSSWzoBgvZ22d991rCFOHtKatjzOZBcW88MMB9PqG+cD115EU9Ap08NOZzM4rNVElsTtw4MB1iyMiIyOJiopqwIhEQ7Kw0NC1WcO0Pdl5OoNd8RexttTc9Ho+a0sLZo5sD5Rvoh19Nqs+QmRDRVPVjv4uRtlryhy19XFmwYPhbHmpP4/3bIa9jSXHUvJ48YcD9J63kUWbT5Nz2TjbpOQVlvC/fUmM/nQXvedtYumOMygK3BfelHWT+xAZYtqjDberctRuxb6kmx6FTckp5PuK3m+T67kStiahTXXcFeKFonBLlfnfV4w2/jPCH6s63oWjIWitLPn4gU7YWluw7WQG/90e3yD3NVTDmvg0LKiU2KWmpmJtbV3j81ZWVqSnpzdgRKKhNUSjYkVRDJWwY7oE3FJn/a5BbowK90NR4I1Vh+plT9LK9XWD2spoXUPzd7Nn+vAQdr0ygKmD2+DppCU1t4i5fxyjx5wNzFh7mKTMS2qHSZleYeuJdCYuj6HLrPW8/NNB9iZkotFArxZNWPZ4F+aP7oSLfeMbpbvaPZ18sbO25GRavqHRbG0t3HyK4jI9XYPcuEOF0bpKlbtR/BqXfFPrQBMvFrDj1EU0GhhdkeCaohaeTkwfXl488d6fx4k7V78zO5kFxeyKL38vGtre9D8YqZLYNW3alLi4uBqfP3jwID4+pp81i5pVNirefyar3jZw334qg31nsrCxsmB8/xa3fJ1pQ9vgbGvF4Qu5hr5WdeVScSnbT2UA0uZETTp7a57p15ztU+/k3/d3pI23EwXFZSzdcYa+721iwnfRHDyX3eBxnUzNY87vR+nx7gYe/WIvq2MvUFiip7mHAy8Pbs3OV+7kmye70a+ONqY3B0621tzdofz9Y/lNNLy9kH3ZsFODWqN1ldp4Oxt+hg8qmqrXRmXRSJ+WHvi5mvZ04pgu/gwO8aakTOH55TEUFJXW273+OpxCmV4hxNeZQPcbF9cZO1USu6FDh/Lmm29SWHjtwsjLly8zffp0hg0bpkJkoqG09XHGydaK/KJSjiTXfWWioii8X7G27qFuAbfVYb+Jo5aXKxpovv/XiTpd0Lv9ZAZFpXr8XO1o7SWV4GqzsbLgH539+H1ib756oiu9WzZBr8AvB5MZsWAH//x0F+uPpNbrup/MgmKW7UhgxILtDPpgK59uiSc1twidnTWPdA9k1fierJ/Sl2f7tTCZiseGNqZitOqXg8m13kGmcrSue7C6o3WVJg9siYWmfM1cbT5UlJTp+WF/ZdGE6Y7WVdJoNLw7qj0+OlsSMgp4a83hervXbxW7TZhLsZEqid3rr79OZmYmrVq1Yt68eaxevZo1a9Ywd+5cWrduTWZmJq+99poaoYkGYlnP6+w2H08nNikbW2sLnqnYJux2PNA1gI5+OvKKSpn129E6iLBc5W4TA9t6mW3jWFOk0Wjo08qDr/+vG78935v7wppiZaFhT0ImT361n4EfbOH7vWcpLKmb3VOKS/X8eTiFp7/aT7fZ63lr7REOnsvBykLDwLZeLH44nL2vDeCdkaF08neRfys30DnQleYeDlwuKWPtgRvv+3w++7KhRciVe0irqYWnE/d0Km/fUrmk5Ho2HE0lI7+IJo5aBphJdb2LvQ0f/rMTGg38EHWOtQcu1Pk9si8Vs7Ni1sSUmxJfSZXEzsvLi507dxIaGsq0adO49957GTlyJK+++iqhoaHs2LEDLy/z+IcpalbZ9qSu19kpimLoWzf2jmZ4Ot1+QYKlhYZ3Roai0cDq2AvsPJ1x29fU6xU2VhRODJJpWKPVzteZ+f/sxLap/RnXNxgnrRXx6QVMWxlHr7kb+c+Gk7fUWkNRFA6ey2b66kN0m72ecV9H8deRVErKFEKbOjN9eDt2vzqA/46NYHCoD1or6W9YWxqNhjFdylt9rNh34+nYhZtOUVKmcEewO92D1R+tqzRxQEssLTRsOp5OVOL1i7cqiz7uj/DD2gSLJmrSLdidCRVLaV79Oa7O17yuO5JKqV6hjbcTwR6OdXpttaj26gcGBvLbb7+RkZHBnj172L17NxkZGfz22280a9ZMrbBEA6psVLw3IZOyOpza+utIKnHnc7C3seTpPsF1dt0Ofi483C0QKC+kuN22GLHnssnIL8bJ1oquQQ23tZq4NT46O6YNacvOaXfy+t1taepiR0Z+MfPXnaDHuxt4fVUcCRkFN7xOSk4hizafJvKDrYxYsIMvdyWSdakEDyctT/cJ5s9Jffjlud483jOIJo7m31i4vtwb3hRrSw0HzuVctwDhXNYl/re/Ym3dIOMYravUrIkDo8JvPGqXlHmJrSfLCw7HmHDRRE0mDmhJeIALeYWlTFoRW6frsiubEptDNWwl1dN6V1dXunTpQteuXXF1Nc8tfkT1QnydcdRakVtYyrGUullnp9f/XQn7eM9muNfxG+OLka1p4mjD6fSC2y7Dr6yG7dfa06w+YZs7J1trnuwdzJaX+vGfB8IIbepMYYmeb3af5c73NzPu6/1EJVZdXnC5uIzVsed55PM99Hh3A3P/OMbJtHy0VhYM7+jLsse7sOuVO3l1aFtae8tay7rQxFFrGAmvTNyq88mm05SUKfRs4W6UH7Ceu7MlVhYatp/KYE989bMbP+xPQlGgZwt3s1j8fzUrSws+GhOGk9aKqMQs/rPxVJ1cN+dyiaF4zRyqYSvJu4lQjZWlBZ0Dy5P5ulpn9/uhFI6l5OGkteKp3nU3WldJZ2/Nq0PbAuWd4c9l3fq0wN/r66Si0RRZWVowoqMvayf04vununNnG08UBf48nMqoRbu4d+EOlu89y8s/HqDLrPVMXB7LtpMZ6JXy/Wrn3Neefa8P5OMHwujX2tMke44Zu8rp2JXR56pdD5mUeYkf9hvX2rqr+bvZG1qXvL/uxDW9+Sr3QwbT22niZvi72TPrvvK+ogs2njTsEnE7NhwtX/rQ0tORlmZUvCa/SYSq6nKdXZle4cOK1gBP9Aqqt55e94Y1pWuQG4UlemasPXJL10i8WMCJ1HwsLTT0ayWJnSnTaDTc0dydLx7rwvopfRjTxR8bSwtizmbzyso4/rf/HPlFpfi52vH8gJZseakfPz7Tgwe6BuBsW3M/T3H7erVoQlMXO3ILS/mjovLxSgs3n6JUr9CrRRO6NDO+0bpKE/q3wMbSgr0Jmew4VfV35abj6aTmFuHuYENkO/MZdarOiI6+jAr3Q6/ApOUx5Fy6vSbiv1U2JTaTathKktgJVV25zu52W0j8cvACJ9Pycba14oleQXURXrU0Gg0zR4ZiZaFh3ZFUw5TqzVhfsTds12Zu6Ozlzd1ctPB04t1RHdj+Sn+eu7MF7XycGR3hx/Knu7P1pf5MGdTKLKfKjJWFhYbREeWjXcuvKqIoH60rbw8yedDN7UrT0Hxd7HiwW/lo3Px1x6uM2lX26hvV2Q8bK/N/S59xTwjN3O25kFPItJ8P3vIez3mFJYZ1ieY0DQuS2AmVdfDTYWdtSdalEk6l59/ydUrL9HxUsf3O032C0dnVb7LUysuJ/+tdnjy+tfYwl4tvru1FZTIoTYnNk6eTLS9Etua3ib2Z94+OdA92x8JCWpSo4f4IPzQa2B2fWaW4ZcHG8tG63i2b0DnQeEfrKj3brzlaKwuiz2az+UR5QpKcc5lNx8s/JJpj0UR1HLVW/OeBMKwsNPwWl3Ld9ZPXs/FYGsWleoKbOJhdD1FVE7v169fX+Nynn37agJEItVhXWWd369Oxq2IvEJ9RgKu9NY/1rL/Ruis9f2dLfHW2nMu6zCebar+YN+dSCXvPlK8PkfV1QtQvXxc7+rbyAP4uojh78RI/RpeP1hnr2rqreTrb8ugd5VX5H1SstfvfvnPolfKdfMylVUdtdPBz4cW7WgPw1pojnEq7+UEBQzVse2+z6wupamJ3991388ILL1Bc/HcPqPT0dIYPH860adNUjEw0pMrtxXbf4mLYkjI9/9lQPlo3rm9zHLVWdRbb9ThorXizYj/DT7ee5nQtRxw3n0ijTK/QystRpuWEaACVo1k/Rp2jpEzPxxtPUqZX6NPKw/DB0hT8q29z7G0sOXguhz8Ppxp69FVO0zYmT/cOpleLJlwuKeP572MoKq39rElBUSmbj5ePeppTm5NKqiZ2W7duZe3atXTp0oXDhw/z66+/EhoaSn5+PgcOHLjpaw0fPhxfX180Gg2rVq2q8nxqaiqPPfYYvr6+2NvbM3jwYE6ePFnlnJSUFB555BG8vb1xcHAgPDycH3/8sco5zZo1Q6PRVHm88sort/Tzi3LdKhqC7onPvKX1Ej9FneNs5iWaONoYPtE2lLtCvOjf2oOSMoXpqw/XKv51R/7ebUIIUf/ubONFE0cb0vOK+HLnGVbGnAfKt+0yJe6OWsb2aAbAyz8e4EJOIS721twVYl5rxGrDwkLD/NEdcXOw4UhyLu/9cbzW37vpeBpFpXoC3e0J8XWuxyjVoWpi161bN2JiYujQoQOdO3fm3nvv5YUXXmDjxo34+9/ceoGCggI6duzIggULrnlOURRGjhxJfHw8q1evJiYmhsDAQAYOHEhBwd9rLh555BGOHz/OmjVriIuL47777uOf//wnMTExVa739ttvk5ycbHi8/vrrt/YXIADo6K9Da2VBRn4R8bVo8HqlotIyPq7oaVT+abZhRusqaTQa3hoRgo2VBdtPZfDLwetvX1RcqmdLxfoYWV8nRMOwsbJgVGc/AGb9dpQyvUK/1h6EBZjOaF2lp3sHG/p/AtwX5oetdePclcTT2ZZ5ozoA8N/tCWyuWG94I79XVsOG+pjdNCwYQfHE8ePH2bdvH35+flhZWXHs2DEuXbr53mBDhgxh5syZ3Hfffdc8d/LkSXbv3s2iRYvo0qULrVu3ZuHCheTn5/P9998bztu1axfPPfccXbt2JTg4mNdffx0XFxeio6OrXM/JyQlvb2/Dw9Gx8axtqA9aK0vCAlyAm+9n97/95ziffRlPJy0Pd2/Y0bpKge4OjO9XvuXNO78cue6m4/vOZJJXWEoTRxs6+bk0UIRCiH9WVMdWDqqbytq6q7k62FSp+n+ga+MomqjJwHZejK2YqXnxhwOk5xVd9/zLxWWGrRzNrRq2kqqJ3bvvvssdd9zBoEGDOHToEPv27TOM4O3atavO7lNUVP5C29r+vWeopaUlNjY2bN++3XCsV69erFixgszMTPR6PcuXL6eoqIh+/fpVud7cuXNxd3enU6dOzJo1q8oaQXFrKtue3Ew/u8KSMj6pGK0b37+Fqp9ax/UNppm7PWl5RXyw7mSN51VOww5o4yVVkkI0oGAPR8POEne28aSTv4u6Ad2GJ3sHERHoygNd/c2qse6tmja0La29nMjIL+bFHw5ct3XWlhNpXC4po6mLHe2b6howyoajamL30UcfsWrVKj7++GNsbW0JCQlh79693HfffdckU7ejTZs2BAYGMm3aNLKysiguLubdd98lJSWF5OS/p85WrFhBaWkp7u7uaLVaxo0bx88//0zz5s0N50ycOJHly5ezadMmJkyYwIcffsizzz573fsXFRWRm5tb5SGqMjQqvol1dt/vPUtKbiE+OlvGqPyp1dbakrfvCQVg2c4EDl/IueYcRVEMu00MkGpYIRrc9OHtuKeTLzNGhKgdym1xtrXmx2d6MOe+DmqHYhRsrS35+MEwtFYWbDmRztKdZ2o899eKadihZlgNW0nVxC4uLo4hQ4ZUOWZtbc17773HX3/9VWf3sba25qeffuLEiRO4ublhb2/P5s2bGTJkCJaWf4/yvP7662RlZbF+/Xr279/PlClTuP/++4mLizOcM3nyZPr27UuHDh148sknWbx4MZ9//jkXL9Y80jRnzhx0Op3hcbPrBxuD8ABXbCwtSMkt5GzmjafiLxeX8cmm0wBMuLMFWiv115j0aeXB3e190CvwxqpD13xqPJ6ax7msy2itLOjVsolKUQrReIX46vhoTBj+bvZqhyLqWCsvJ14f1g6Aub8f49D5az9cF5aUsbHiw7W57TZxJVUTuyZNan5z69u3b53eq3PnzsTGxpKdnU1ycjJ//PEHFy9eJCiofK3C6dOnWbBgAV988QUDBgygY8eOTJ8+nYiICD755JMar9u9e3cATp2quY/ZtGnTyMnJMTySkm6toaI5s7W2pKN/+bB4bdbZfbM7kYz8Ivxc7bi/s/Ekym8Ma4eDjSXRZ7P5Iarq61zZlLhXiyYNXuQhhBDm7uFuAUS286K4TM/zy2O4VFxa5fmtJ9IpKC7DR2dr1mucVS+eADhy5Ah//PEHa9asqfKoDzqdDg8PD06ePMn+/fu55557AAwFGxYWVf9KLC0t0ev1NV6vsmLWx6fm7F+r1eLs7FzlIa5Vuc5u9w3W2RUUlbJoS/lo3fN3tjSqbXS8dbZMHlS+KHvO78fILPh7/eW6im3EpBpWCCHqnkajYe6oDng5a4lPL+CdX6ru5f37ob+rYc15jbOqwwbx8fHce++9xMXFodFoDGurKue9y8pq33AwPz+/yqhZQkICsbGxuLm5ERAQwA8//ICHhwcBAQHExcUxceJERo4cSWRkJFC+Dq9FixaMGzeOf//737i7u7Nq1SrWrVvHL7/8ApRXze7evZv+/fuj0+nYt28fkydPZsSIEQQENL4GkXWtW7AbCzbdeMTuy11nyCwoJtDdnvvCmzZQdLU3tkczfow6x7GUPOb9cYx3R3UgLbeQA0nZAAxoI+vrhBCiPrg62PDBPzvx0H/38P3eJHq39GBoex+KSssMsybmWg1bSdWhjokTJxIUFERqair29vYcPnyYrVu3EhERwebNm2/qWvv37ycsLIywsDAApkyZQlhYGG+++SYAycnJPPLII7Rp04bnn3+eRx55pEqrE2tra3777Tc8PDwYPnw4HTp04KuvvuLLL79k6NChQPnI24oVK+jXrx/t2rXjzTff5KmnnqpyHXHrOge6YmWh4Xz2Zc5lVb/OLq+whCVb4wGYOKAlVpbGM1pXydrSgndGlhdSLN+XRPTZLDZUlNd39HfB09n2et8uhBDiNvRo3oRn+pYXPb7y00HOZ19mx6kM8opK8XTSEm6C/Qtvhka5lVb/daRJkyZs3LiRDh06oNPp2Lt3L61bt2bjxo288MIL1zQGNhe5ubnodDpycnJkWvYq9y7cQczZbN6/v6OhoeiVPlp/kg/WnyDYw4F1k/tiacTD6S/9cIAfos7RzscZT2ctm4+n82JkKybcaVrd7oUQwtSUlOn5x+JdHEjKpmszN5q62vFzzHnG3hHIjIoOBqamtrmDqsMdZWVlhua+TZo04cKFCwAEBgZy/HjttwcR5uN6/exyLpXw3+3lo3WTBrYy6qQO4JUhbdDZWXMkOdewL6GsrxNCiPpnbWnBf8Z0wlFrxd4zmfxcsY2cOVfDVlI1sQsNDeXgwYNA+fZi8+bNY8eOHbz99tsEBwerGZpQiaGfXcK16+z+uz2evMJSWnk5MswE/nO6O2p5eXBrw9d+rna0lmaiQgjRIALdHXhn5N89C5s4aunSzE3FiBqGqond66+/bqg4nTlzJomJifTu3ZvffvuNjz76SM3QhEoiAl2x0EDixUuk5BQajmcVFPPF9gQAJg9sZTIVTWO6BNCxosP9wLZeZtsQUwghjNG9YX7cG1ZeZDe8o4/Rz/TUBVWrYu+66y7Dn4ODgzly5AiZmZm4urrKG2Aj5WRrTWhTHQfP5bAn4SL3dCr/D/np1ngKisto5+PMXSGmU9FkaaFh0UPhLN97lsd7Bt34G4QQQtSpef/owN3tfejRwl3tUBqEKondE088Uavzvvjii3qORBijrs3cOHguh93xmdzTqSkZ+UV8WbFFzJRBpjNaV8nXxY4pka1vfKIQQog6Z21p0ajWN6uS2C1btozAwEDCwsJqvS+oaDy6Bbvz3+0JhgKKxZtPc7mkjI5+OtljVQghhLgOVRK7f/3rXyxfvpz4+HieeOIJHn74YdzczH9Bo6idrs3c0GggPr2Awxdy+Hp3IgCTB7WSKXohhBDiOlQpnli4cCHJyclMnTqVtWvX4u/vz+jRo/nzzz9lBE+gs7emjXd5j54J38VQVKonPMCFvq08VI5MCCGEMG6qVcVqtVoeeOAB1q1bx5EjRwgJCeHZZ58lMDCQ/Px8tcISRqJbUPkIbkJGAQAvRLaW0TohhBDiBoxiPyaNRmPYK7ay/Ylo3LoH/z013zXIjR7NG0c1kxBCCHE7VEvsioqK+P777xk0aBCtW7cmLi6OBQsWcPbsWcNuFKLx6hrkTmXx6xRZWyeEEELUiirFE88++yzLly8nICCAxx9/nOXLl+PuLiMy4m9uDjbMH92JS8VldA+WfxtCCCFEbWgUFaoVLCwsCAgIICws7LojMStXrmzAqBpObTfyFUIIIYSA2ucOqozYPfroozK1JoQQQghRx1RrUCyEEEIIIeqWqnvFNlaVs9+5ubkqRyKEEEIIU1CZM9xoBZ0kdirIy8sDwN/fX+VIhBBCCGFK8vLy0Ol0NT6vSvFEY6fX67lw4QJOTk6y1rCWcnNz8ff3JykpSQpOjJi8TqZDXivTIK+T6ajv10pRFPLy8vD19cXCouZudTJipwILCwv8/PzUDsMkOTs7yy83EyCvk+mQ18o0yOtkOurztbreSF0lo9h5QgghhBBC3D5J7IQQQgghzIQkdsIkaLVapk+fjlarVTsUcR3yOpkOea1Mg7xOpsNYXispnhBCCCGEMBMyYieEEEIIYSYksRNCCCGEMBOS2AkhhBBCmAlJ7IQQQgghzIQkdsJozZkzhy5duuDk5ISnpycjR47k+PHjaoclamHOnDloNBomTZqkdijiKufPn+fhhx/G3d0de3t7OnXqRFRUlNphiauUlpby+uuvExQUhJ2dHcHBwbz99tvo9Xq1Q2vUtm7dyvDhw/H19UWj0bBq1aoqzyuKwltvvYWvry92dnb069ePw4cPN2iMktgJo7VlyxbGjx/P7t27WbduHaWlpURGRlJQUKB2aOI69u3bx5IlS+jQoYPaoYirZGVl0bNnT6ytrfn99985cuQI77//Pi4uLmqHJq4yd+5cFi9ezIIFCzh69Cjz5s3jvffe4+OPP1Y7tEatoKCAjh07smDBgmqfnzdvHvPnz2fBggXs27cPb29vBg0aZNgjviFIuxNhMtLT0/H09GTLli306dNH7XBENfLz8wkPD2fhwoXMnDmTTp068eGHH6odlqjwyiuvsGPHDrZt26Z2KOIGhg0bhpeXF59//rnh2KhRo7C3t+frr79WMTJRSaPR8PPPPzNy5EigfLTO19eXSZMmMXXqVACKiorw8vJi7ty5jBs3rkHikhE7YTJycnIAcHNzUzkSUZPx48dz9913M3DgQLVDEdVYs2YNERER3H///Xh6ehIWFsZnn32mdliiGr169WLDhg2cOHECgAMHDrB9+3aGDh2qcmSiJgkJCaSkpBAZGWk4ptVq6du3Lzt37mywOKwa7E5C3AZFUZgyZQq9evUiNDRU7XBENZYvX050dDT79u1TOxRRg/j4eBYtWsSUKVN49dVX2bt3L88//zxarZZHH31U7fDEFaZOnUpOTg5t2rTB0tKSsrIyZs2axQMPPKB2aKIGKSkpAHh5eVU57uXlRWJiYoPFIYmdMAkTJkzg4MGDbN++Xe1QRDWSkpKYOHEif/31F7a2tmqHI2qg1+uJiIhg9uzZAISFhXH48GEWLVokiZ2RWbFiBd988w3fffcdISEhxMbGMmnSJHx9fRk7dqza4Ynr0Gg0Vb5WFOWaY/VJEjth9J577jnWrFnD1q1b8fPzUzscUY2oqCjS0tLo3Lmz4VhZWRlbt25lwYIFFBUVYWlpqWKEAsDHx4d27dpVOda2bVt++uknlSISNXnppZd45ZVXGDNmDADt27cnMTGROXPmSGJnpLy9vYHykTsfHx/D8bS0tGtG8eqTrLETRktRFCZMmMDKlSvZuHEjQUFBaockajBgwADi4uKIjY01PCIiInjooYeIjY2VpM5I9OzZ85qWQSdOnCAwMFCliERNLl26hIVF1bdoS0tLaXdixIKCgvD29mbdunWGY8XFxWzZsoUePXo0WBwyYieM1vjx4/nuu+9YvXo1Tk5OhvULOp0OOzs7laMTV3Jycrpm7aODgwPu7u6yJtKITJ48mR49ejB79mxGjx7N3r17WbJkCUuWLFE7NHGV4cOHM2vWLAICAggJCSEmJob58+fzxBNPqB1ao5afn8+pU6cMXyckJBAbG4ubmxsBAQFMmjSJ2bNn07JlS1q2bMns2bOxt7fnwQcfbLggFSGMFFDtY+nSpWqHJmqhb9++ysSJE9UOQ1xl7dq1SmhoqKLVapU2bdooS5YsUTskUY3c3Fxl4sSJSkBAgGJra6sEBwcrr732mlJUVKR2aI3apk2bqn1fGjt2rKIoiqLX65Xp06cr3t7eilarVfr06aPExcU1aIzSx04IIYQQwkzIGjshhBBCCDMhiZ0QQgghhJmQxE4IIYQQwkxIYieEEEIIYSYksRNCCCGEMBOS2AkhhBBCmAlJ7IQQQgghzIQkdkIIIYQQZkISOyGEEEIIMyGJnRBCCCGEmZDETgghhBDCTEhiJ4QQQghhJiSxE0IIIYQwE5LYCSGEEEKYCUnshBBCCCHMhCR2QgghhBBmQhI7IYQQQggzIYmdEEIIIYSZkMROCCGEEMJMSGInhBBCCGEmJLETQgghhDATVmoH0Bjp9XouXLiAk5MTGo1G7XCEEEIIYeQURSEvLw9fX18sLGoel5PETgUXLlzA399f7TCEEEIIYWKSkpLw8/Or8XlJ7K4wZ84cVq5cybFjx7Czs6NHjx7MnTuX1q1bG85RFIUZM2awZMkSsrKy6NatG5988gkhISG1vo+TkxNQ/uI4OzvX+c8hhBBCCPOSm5uLv7+/IYeoiSR2V9iyZQvjx4+nS5culJaW8tprrxEZGcmRI0dwcHAAYN68ecyfP59ly5bRqlUrZs6cyaBBgzh+/PgN/7IrVU6/Ojs7S2InhBBCiFq70RIujaIoSgPFYnLS09Px9PRky5Yt9OnTB0VR8PX1ZdKkSUydOhWAoqIivLy8mDt3LuPGjavVdXNzc9HpdOTk5EhiJ4QQQpgBvV4ht7AEF3uberl+bXMHGbG7jpycHADc3NwASEhIICUlhcjISMM5Wq2Wvn37snPnzhoTu6KiIoqKigxf5+bm1mPUQgghhKhv+UWlxJ7NJioxi+iz5Y+uzdz4/LEuqsYliV0NFEVhypQp9OrVi9DQUABSUlIA8PLyqnKul5cXiYmJNV5rzpw5zJgxo/6CFUIIIUS9URSFs5mXiD6bRVRiFlGJ2RxPyUV/1ZznsZQ8FEVRteOFJHY1mDBhAgcPHmT79u3XPHf1C3ajF3HatGlMmTLF8HXlAkghhBBCGJ/CkjIOnc+pSOLKR+My8ouvOc/P1Y7Oga50DnQlPMCVNt7qtzGTxK4azz33HGvWrGHr1q1VSoq9vb2B8pE7Hx8fw/G0tLRrRvGupNVq0Wq19RewEEIIIW5Zam6hIYmLSszi8IUcSsqqDsfZWFoQ2tTZkMSFB7ri5WyrUsQ1k8TuCoqi8Nxzz/Hzzz+zefNmgoKCqjwfFBSEt7c369atIywsDIDi4mK2bNnC3Llz1QhZCCGEEDehpEzPseQ8ohIziTqbTXRiFuezL19zXhNHLZ0DXQwjciG+OmytLVWI+OZIYneF8ePH891337F69WqcnJwMa+p0Oh12dnZoNBomTZrE7NmzadmyJS1btmT27NnY29vz4IMPqhy9EEIIIa6WVVBsKG6ISsziQFIOl0vKqpxjoYE23s6GJK5zoCt+rnaqT6veCknsrrBo0SIA+vXrV+X40qVLeeyxxwB4+eWXuXz5Ms8++6yhQfFff/1V6x52QgghhKgfer3CqfR8oiunVc9mEZ9ecM15zrZWhAe60jmgPInr4O+Co9Y8UiLpY6cC6WMnhBBC3L78olIOJGUb1sbFnM0it7D0mvOCPRyIuKLIobmHIxYWpjUaJ33shBBCCGE2FEUhKfMyUWczr9tyxM7akk7+LoRXrI8L83fF1aF+mgYbI0nshBBCCGF0bqblSHjA32vj2ng7YWVpoULExkESOyGEEEKo7sqWI9Fnszh0vvqWIyFNnQ1r44y15YiaJLETQgghRIO6suVIdMW2XObUckRNZpHYBQcHs2/fPtzd3ascz87OJjw8nPj4eJUiE0IIIURjazmiJrNI7M6cOUNZWdk1x4uKijh//rwKEQkhhBCNk16vcDo9/++dHG7QcqRyfVxHM2o5oiaT/htcs2aN4c9//vknOp3O8HVZWRkbNmygWbNmKkQmhBBCNA4303Kk8xVFDqbYcsQUmHRiN3LkSAA0Gg1jx46t8py1tTXNmjXj/fffVyEyIYQQwvzcTMuRjv46QxLX2FqOqMmkEzu9Xg+U7+G6b98+mjRponJEQgghhPm4tuVINhn5Rdec19TFzpDEhQe40sbHCetG3HJETSad2FVKSEhQOwQhhBDC5KXmFlbZjqu6liPWlhpCfHVVEjlvnbQcMRZmkdgBbNiwgQ0bNpCWlmYYyav0xRdfqBSVEEIIYZxKy/QcS8n7u8ihxpYjNlUaAIc2lZYjxswsErsZM2bw9ttvExERgY+Pj5RGCyGEEFfJKigmJunvJK6mliOtvZ0NvePCA1wJcLOX91UTYhaJ3eLFi1m2bBmPPPKI2qEIIYQQqtPrFeIz8quMxp2upuWIk62VYTQuPMCVjv46nGytVYhY1BWzSOyKi4vp0aOH2mEIIYQQqii4suXI2SyiE2tuOXLltGoLaTlidswisXvyySf57rvveOONN9QORQghhKhXiqJwLuuyYU/VqMQsjiZf23LE1tqCjn5/b8cVFuCKm7QcMXtmkdgVFhayZMkS1q9fT4cOHbC2rjqMPH/+fJUiE0IIIW5PYUkZhy+UtxyJTswm6mwW6XnVtxwJD3Slc4ALnQPdpOVII2UWid3Bgwfp1KkTAIcOHarynCz4FEIIYUrScgsNI3FRiVkcOp9LcVnVbg/Wlhra+eqIkJYj4ipmkdht2rSpzq61detW3nvvPaKiokhOTubnn3827HAB8Nhjj/Hll19W+Z5u3bqxe/fuOotBCCFE41DZcuTKRO5clrQcEbfOLBK7ulRQUEDHjh15/PHHGTVqVLXnDB48mKVLlxq+trGRNQtCCCFuLPtSMTFn/95X9cC5bC4V19xypDKZk5YjorbMIrHr37//df/Bb9y4sdbXGjJkCEOGDLnuOVqtFm9v71pfUwghRONzdcuR6LPZnErLv+Y8J1srwgJc6VyRxEnLEXE7zCKxq1xfV6mkpITY2FgOHTrE2LFj6/x+mzdvxtPTExcXF/r27cusWbPw9PSs8/sIIYQwHZUtRyqnVaPPZpNzueSa84KbOJQXOUjLEVEPzCKx++CDD6o9/tZbb5Gff+2no9sxZMgQ7r//fgIDA0lISOCNN97gzjvvJCoqCq1WW+33FBUVUVT0dwVTbm5uncYkhBCiYUnLEWGsNIqiKDc+zTSdOnWKrl27kpmZeUvfr9ForimeuFpycjKBgYEsX76c++67r9pz3nrrLWbMmHHN8ZycHJydnW8pNiGEEA2nqLSMQ+dzia7cyeE6LUfCAlyICHQlPNCVtj7O0nJE1Inc3Fx0Ot0NcwezGLGrya5du7C1rd/ybx8fHwIDAzl58mSN50ybNo0pU6YYvs7NzcXf379e4xJCCHHrattyJMRXZxiNk5YjwhiYRWJ39UiZoigkJyezf//+et+N4uLFiyQlJeHj41PjOVqttsZpWiGEEOq62ZYjlevj2kvLEWGEzCKx0+l0Vb62sLCgdevWvP3220RGRt7UtfLz8zl16pTh64SEBGJjY3Fzc8PNzY233nqLUaNG4ePjw5kzZ3j11Vdp0qQJ9957b538LEIIIerXzbQcCQ/4e32ctBwRpsCs19jdis2bN9O/f/9rjo8dO5ZFixYxcuRIYmJiyM7OxsfHh/79+/POO+/c1NRqbefJhRBC3J5atxzRWhEWKC1HhPGqbe5gVoldVFQUR48eRaPR0K5dO8LCwtQOqVqS2AkhRP2QliPCXDWq4om0tDTGjBnD5s2bcXFxQVEUcnJy6N+/P8uXL8fDw0PtEIUQQtSxypYjV66Nu1HLkco1ctJyRJgrs0jsnnvuOXJzczl8+DBt27YF4MiRI4wdO5bnn3+e77//XuUIhRBC3K6baTkSHuhqWB8nLUdEY2IWU7E6nY7169fTpUuXKsf37t1LZGQk2dnZ6gRWA5mKFUKIG7uZliOVe6qGB7rgo7NTKWIh6k+jmorV6/VYW1+7yNXa2hq9Xl/NdwghhDAmV7cciT6bRVLmtS1H3B1sqqyNk5YjQlRlFondnXfeycSJE/n+++/x9fUF4Pz580yePJkBAwaoHJ0QQoirXdlyJPpsFrFJ17Yc0WigtZeTIYmTliNC3JhZJHYLFizgnnvuoVmzZvj7+6PRaDh79izt27fnm2++UTs8IYRo1K5sORKdmE3U2SxpOSJEPTGLxM7f35/o6GjWrVvHsWPHUBSFdu3aMXDgQLVDE0KIRqegqJQD57INRQ61aTkSHuBKS09pOSLE7TKL4glTI8UTQghzIS1HhGgYjaJ4YuPGjUyYMIHdu3df80Pm5OTQo0cPFi9eTO/evVWKUAghzIu0HBHCuJl0Yvfhhx/y1FNPVZu56nQ6xo0bx/z58yWxE0KIW3Rly5Hos9nEncuptuVIO1+dYW2ctBwRQj0mndgdOHCAuXPn1vh8ZGQk//73vxswIiGEMF1XthyJrhiNk5YjQpgWk07sUlNTq+1fV8nKyor09PQGjEgIIUxHzqUSopOyDNOq12s5Eh7oSoS0HBHC6Jl0Yte0aVPi4uJo0aJFtc8fPHgQHx+fBo5KCCGMT3nLkYIqa+Ok5YgQ5sekE7uhQ4fy5ptvMmTIEGxtbas8d/nyZaZPn86wYcNUik4IIdRzqbiU2KTyliPRZ7OJPptF9iVpOSKEuTPpdiepqamEh4djaWnJhAkTaN26NRqNhqNHj/LJJ59QVlZGdHQ0Xl5eaodahbQ7EULUpStbjlSujTuanEfZVT1HpOWIEKarUbQ78fLyYufOnTzzzDNMmzaNyhxVo9Fw1113sXDhQqNL6oQQ5i23sITYihGywxdyKS2r3/2qS/UKx1PySKuh5UhYRbsRaTkiRONg0okdQGBgIL/99htZWVmcOnUKRVFo2bIlrq6uaocmhDBziqJw5uIlw36n0YlZHE/NQ415ECsLDSFNpeWIEI2dySd2lVxdXenSpYvaYQghzNjl4jIOnssm+orN6zMLiq85z9/Njs4BrnT0d8FRW/+/ZgPdHejgJy1HhBBmlNjVla1bt/Lee+8RFRVFcnIyP//8MyNHjjQ8rygKM2bMYMmSJWRlZdGtWzc++eQTQkJC1AtaCFEvknMuG7bJik6smFq9at2ajaUF7f10V6xbc8HTybaGKwohRP2SxO4qBQUFdOzYkccff5xRo0Zd8/y8efOYP38+y5Yto1WrVsycOZNBgwZx/PhxnJycVIhYCFEXSsr0HLmQa2gFEp2YRXJO4TXneThpDf3cwgJcCW3qjNZKRsqEEMZBErurDBkyhCFDhlT7nKIofPjhh7z22mvcd999AHz55Zd4eXnx3XffMW7cuIYMVQhxGy7mF/09pZqYxcHz2RSWVC10sLTQ0NbHifCAv9uB+LnaSXNeIYTRMovELjs7GxcXl2qfO3XqVI0NjG9WQkICKSkpREZGGo5ptVr69u3Lzp07a0zsioqKKCr6u2ItNze3TuIRQtROmV7hZFpeRRJXXrGakFFwzXk6O2vDpvXhga509HPBoQHWyAkhRF0xi99YQ4cOZePGjdc0KT5+/DgDBgzg3LlzdXKflJQUgGtaqHh5eZGYmFjj982ZM4cZM2bUSQxCiBvLKywhNinbsD4u9mw2eUWl15zXwtPxiipSV4KbOEhzXiGESTOLxM7V1ZWRI0fyyy+/YGVV/iMdPXqUO++8k9GjR9f5/a6ehlEU5bpTM9OmTWPKlCmGr3Nzc/H396/zuIRojBRFIbGi5UjUdVqO2NtY0sn/7+a8YQEuuNhLc14hhHkxi8Tup59+YtCgQTz44IOsWLGCw4cPM2DAAB566CHmz59fZ/fx9vYGykfurtyDNi0t7bqNkLVaLVqtts7iEKIxKywp4+C5nL+rVW/QciS8IpFr4+2ElTTnFUKYObNI7Gxtbfnll1/o168f999/P9u2bePRRx/lvffeq9P7BAUF4e3tzbp16wgLCwOguLiYLVu2MHfu3Dq9lxCi3M20HDGsjwtwxdNZWo4IIRofk03sri5A0Gg0rFixgoEDBzJq1CjeeOMNwzk3sx9rfn4+p06dMnydkJBAbGwsbm5uBAQEMGnSJGbPnk3Lli1p2bIls2fPxt7engcffLBufjAhGrErW45U7uRwoYaWI1eujZOWI0IIUU6jKGpsfnP7LCwsql3XduV+sZVr38rKymp93c2bN9O/f/9rjo8dO5Zly5YZGhR/+umnVRoUh4aG1voetd3IVwhzl1lQbNi0Pioxi4Pnrm05YqGBtj7Ohv1OpeWIEKIxqm3uYLKJ3ZYtW2p9bt++fesxkpsniZ1ojPR6hZNp+VXWxtXUciQswIUIaTkihBAGtc0dTPa3pbEla0KIqq5pOZKUTV6htBwRQoj6ZLKJ3ZWWLl2Ko6Mj999/f5XjP/zwA5cuXWLs2LEqRSZE41DZciS6Yko1SlqOCCGEKswisXv33XdZvHjxNcc9PT15+umnJbEToo4VlpQRdz6nSrXqxRpajly5HZe0HBFCiPplFoldYmIiQUFB1xwPDAzk7NmzKkQkhHlJySk0rIuLSszi8IUcSsqubTkS2rRqkYO0HBFCiIZlFomdp6cnBw8epFmzZlWOHzhwAHd3d3WCEsJElZTpOZqcW1Gtmk10Yhbnsy9fc560HBFCCONjFondmDFjeP7553FycqJPnz5AedXsxIkTGTNmjMrRCWHcMguKiblibdyBG7QcqZxalZYjQghhfMwisZs5cyaJiYkMGDDAsFesXq/n0UcfZfbs2SpHJ4Tx0OsVTqXnV1kbF19Dy5Erd3Ho6C8tR4QQwhSYbB+76pw4cYIDBw5gZ2dH+/btCQwMVDukakkfO9FQ8gpLOJBUUeRwNouYs1nXbTkSHliezAU3cZSWI0IIYUTMvo9ddVq1akWrVq3UDkMIVSiKwtnMS1c0AM7meEou+hpajlROqUrLESGEMB9mk9idO3eONWvWcPbsWYqLq7ZdmD9/vkpRCVF/rmw5El1RsZqRf23LET9XuyqVqtJyRAghzJdZJHYbNmxgxIgRBAUFcfz4cUJDQzlz5gyKohAeHq52eELUCWk5IoQQ4kbMIrGbNm0aL7zwAm+//TZOTk789NNPeHp68tBDDzF48GC1wxPipt1ayxEXQnx12FpLyxEhhGiszCKxO3r0KN9//z0AVlZWXL58GUdHR95++23uuecennnmGZUjFOL6brblSOVonLQcEUIIcSWzSOwcHBwoKioCwNfXl9OnTxMSEgJARkaGmqEJcY2bbTlSWeQgLUeEEELciFm8S3Tv3p0dO3bQrl077r77bl544QXi4uJYuXIl3bt3Vzs80cjdTMuRyt5x0nJECCHErTCLxG7+/Pnk5+cD8NZbb5Gfn8+KFSto0aIFH3zwgcrRicbkZlqOdPT7O4mTliNCCCHqglk1KDYV0qDYfNS25UhTFzsimknLESGEELemUTUoDg4OZt++fbi7u1c5np2dTXh4OPHx8XV2r7feeosZM2ZUOebl5UVKSkqd3UMYr5ScQkO7EWk5IoQQwtiYRWJ35swZysrKrjleVFTE+fPn6/x+ISEhrF+/3vC1paW0lzBHJWV6jiXnEZWYed2WI00ctUQESssRIYQQ6jPpxG7NmjWGP//555/odDrD12VlZWzYsIFmzZrV+X2trKzw9vau8+sKdd1My5HKStXOgdJyRAghhPEw6cRu5MiRAGg0GsaOHVvlOWtra5o1a8b7779f5/c9efIkvr6+aLVaunXrxuzZswkODq7z+4j6U9uWI862VoQHuhqaAEvLESGEEMbMpN+h9Pry0ZSgoCD27dtHkyZN6v2e3bp146uvvqJVq1akpqYyc+ZMevToweHDh69Z41epqKjI0GcPyhdAioaVX1RK7Nlsw5Zc0TW0HGnu4WAYiZOWI0IIIUyNVMXepoKCApo3b87LL7/MlClTqj2nuoILQKpi68mVLUfKCx2qbzliZ21JJ38XwgNdiAh0k5YjQgghjFZtq2JNOrHbs2cPmZmZDBkyxHDsq6++Yvr06RQUFDBy5Eg+/vhjtFptvcYxaNAgWrRowaJFi6p9vroRO39/f0ns6khly5FoQ++46luO+LnaValUlZYjQgghTEWjaHfy1ltv0a9fP0NiFxcXx//93//x2GOP0bZtW9577z18fX1566236i2GoqIijh49Su/evWs8R6vV1nty2Zik5hYa1sbVpuVIeIAr4YGueEnLESGEEGbOpBO72NhY3nnnHcPXy5cvp1u3bnz22WcA+Pv7M3369DpN7F588UWGDx9OQEAAaWlpzJw5k9zc3GuKN0TduNmWI+GB5bs5SMsRIYQQjZFJJ3ZZWVl4eXkZvt6yZQuDBw82fN2lSxeSkpLq9J7nzp3jgQceICMjAw8PD7p3787u3bsJDAys0/s0VlkFxYYGwNFnsziQlMPlkqo9CqXliBBCCFE9k07svLy8SEhIwN/fn+LiYqKjo6sUKeTl5WFtbV2n91y+fHmdXq8xu6blyNks4tOl5YgQQghxq0z63XHw4MG88sorzJ07l1WrVmFvb19lrdvBgwdp3ry5ihGKK1W2HLlyRO5GLUfCA1xp7iEtR4QQQojaMOnEbubMmdx333307dsXR0dHvvzyS2xs/m5X8cUXXxAZGalihI2XoigkZV4m6mxmxYjc9VuOVG7HFebviquDtBwRQgghboVJtzuplJOTg6Oj4zV7tmZmZuLo6Fgl2TMGtS1ZNiWFJWUcOp9TZVq1ppYjV66Nk5YjQgghxI01inYnla7cI/ZKbm5uDRxJ41GbliPWlhpCm+oMa+Ok5YgQQghRv8wisRP162ZajnSuaDcSHuBKaFNpOSKEEEI0JEnsxDUqW45UFjnU1HKklZcTEc0qplUD3PB3k5YjQgghhJoksWvkKluOVG7HFXWdliNhV6yN6+jvgqO0HBFCCCGMirwzNzL5RaUcSMo2rI2LOZtFbjUtR4I9HAxr4zoHSssRIYQQwhRIYmfGbqblSEd/nSGJk5YjQgghhGmSxM7MHEvJZcvx9IqWI9lk5Bddc05TFztDEictR4QQQgjzIYmdmfktLoX/bDhp+FpajgghhBCNhyR2ZqZHc3eOp+RKyxEhhBCiEZLEzsx0D3ane7C72mEIIYQQQgWysEoIIYQQwkxIYieEEEIIYSZkKlYFilLebyQ3N1flSIQQQghhCipzhsocoiaS2KkgLy8PAH9/f5UjEUIIIYQpycvLQ6fT1fi8RrlR6ifqnF6v58KFCzg5OcneqrWUm5uLv78/SUlJODs7qx2OqIG8TqZDXivTIK+T6ajv10pRFPLy8vD19cXCouaVdDJipwILCwv8/PzUDsMkOTs7yy83EyCvk+mQ18o0yOtkOurztbreSF0lKZ4QQgghhDATktgJIYQQQpgJSeyESdBqtUyfPh2tVqt2KOI65HUyHfJamQZ5nUyHsbxWUjwhhBBCCGEmZMROCCGEEMJMSGInhBBCCGEmJLETQgghhDATktgJIYQQQpgJSeyE0ZozZw5dunTByckJT09PRo4cyfHjx9UOS9TCnDlz0Gg0TJo0Se1QxFXOnz/Pww8/jLu7O/b29nTq1ImoqCi1wxJXKS0t5fXXXycoKAg7OzuCg4N5++230ev1aofWqG3dupXhw4fj6+uLRqNh1apVVZ5XFIW33noLX19f7Ozs6NevH4cPH27QGCWxE0Zry5YtjB8/nt27d7Nu3TpKS0uJjIykoKBA7dDEdezbt48lS5bQoUMHtUMRV8nKyqJnz55YW1vz+++/c+TIEd5//31cXFzUDk1cZe7cuSxevJgFmSh0dQAARutJREFUCxZw9OhR5s2bx3vvvcfHH3+sdmiNWkFBAR07dmTBggXVPj9v3jzmz5/PggUL2LdvH97e3gwaNMiwR3xDkHYnwmSkp6fj6enJli1b6NOnj9rhiGrk5+cTHh7OwoULmTlzJp06deLDDz9UOyxR4ZVXXmHHjh1s27ZN7VDEDQwbNgwvLy8+//xzw7FRo0Zhb2/P119/rWJkopJGo+Hnn39m5MiRQPlona+vL5MmTWLq1KkAFBUV4eXlxdy5cxk3blyDxCUjdsJk5OTkAODm5qZyJKIm48eP5+6772bgwIFqhyKqsWbNGiIiIrj//vvx9PQkLCyMzz77TO2wRDV69erFhg0bOHHiBAAHDhxg+/btDB06VOXIRE0SEhJISUkhMjLScEyr1dK3b1927tzZYHFYNdidhLgNiqIwZcoUevXqRWhoqNrhiGosX76c6Oho9u3bp3Yoogbx8fEsWrSIKVOm8Oqrr7J3716ef/55tFotjz76qNrhiStMnTqVnJwc2rRpg6WlJWVlZcyaNYsHHnhA7dBEDVJSUgDw8vKqctzLy4vExMQGi0MSO2ESJkyYwMGDB9m+fbvaoYhqJCUlMXHiRP766y9sbW3VDkfUQK/XExERwezZswEICwvj8OHDLFq0SBI7I7NixQq++eYbvvvuO0JCQoiNjWXSpEn4+voyduxYtcMT16HRaKp8rSjKNcfqkyR2wug999xzrFmzhq1bt+Ln56d2OKIaUVFRpKWl0blzZ8OxsrIytm7dyoIFCygqKsLS0lLFCAWAj48P7dq1q3Ksbdu2/PTTTypFJGry0ksv8corrzBmzBgA2rdvT2JiInPmzJHEzkh5e3sD5SN3Pj4+huNpaWnXjOLVJ1ljJ4yWoihMmDCBlStXsnHjRoKCgtQOSdRgwIABxMXFERsba3hERETw0EMPERsbK0mdkejZs+c1LYNOnDhBYGCgShGJmly6dAkLi6pv0ZaWltLuxIgFBQXh7e3NunXrDMeKi4vZsmULPXr0aLA4ZMROGK3x48fz3XffsXr1apycnAzrF3Q6HXZ2dipHJ67k5OR0zdpHBwcH3N3dZU2kEZk8eTI9evRg9uzZjB49mr1797JkyRKWLFmidmjiKsOHD2fWrFkEBAQQEhJCTEwM8+fP54knnlA7tEYtPz+fU6dOGb5OSEggNjYWNzc3AgICmDRpErNnz6Zly5a0bNmS2bNnY29vz4MPPthwQSpCGCmg2sfSpUvVDk3UQt++fZWJEyeqHYa4ytq1a5XQ0FBFq9Uqbdq0UZYsWaJ2SKIaubm5ysSJE5WAgADF1tZWCQ4OVl577TWlqKhI7dAatU2bNlX7vjR27FhFURRFr9cr06dPV7y9vRWtVqv06dNHiYuLa9AYpY+dEEIIIYSZkDV2QgghhBBmQhI7IYQQQggzIYmdEEIIIYSZkMROCCGEEMJMSGInhBBCCGEmJLETQgghhDATktgJIYQQQpgJSeyEEEIIIcyEJHZCCCGEEGZCEjshhBBCCDMhiZ0QQgghhJmQxE4IIYQQwkxIYieEEEIIYSYksRNCCCGEMBOS2AkhhBBCmAlJ7IQQQgghzIQkdkIIIYQQZsKkEruioiK1QxBCCCGEMFpGndj9+eefPPbYYzRv3hxra2vs7e1xcnKib9++zJo1iwsXLqgdohBCCCGE0dAoiqKoHcTVVq1axdSpU8nJyWHo0KF07dqVpk2bYmdnR2ZmJocOHWLbtm3s2rWLxx57jHfeeQcPDw+1wxZCCCGEUJVRJnZdu3bljTfe4O6778bCouZBxfPnz/PRRx/h5eXFCy+80IARCiGEEEIYH6NM7MydXq/nwoULODk5odFo1A5HCCGEEEZOURTy8vLw9fW97qCXVQPGdFPWr19Pz549sbOzUzuUOnfhwgX8/f3VDkMIIYQQJiYpKQk/P78anzfaETsLCwtsbGzo2rUr/fv3p3///vTo0QMbGxu1Q7ttOTk5uLi4kJSUhLOzs9rhCCGEEMLI5ebm4u/vT3Z2NjqdrsbzjDaxO3/+PBs3bmTLli1s2rSJhIQEbG1tueOOOwyJXrdu3bCyMtpBxxrl5uai0+nIycmRxE4IIYQQN1Tb3MFoE7urJSUlsWnTJjZv3szmzZtJTEzE3t6evLw8tUO7aZLYCSGEEOJm1DZ3MJnhLn9/f3r27ElRURFFRUVcvHiRsrIytcMSQgjVXMwv4uHP9+JgY8mozn7c3cEHZ1trtcMSQqjIqBsUx8fH88UXX/DII4/g5+dHeHg4K1euJDQ0lN9//52srKxaX+utt95Co9FUeXh7ewNQUlLC1KlTad++PQ4ODvj6+vLoo49e0wC5qKiI5557jiZNmuDg4MCIESM4d+5cnf7MQghRW38cTuFoci77E7OYtjKOLjPXM3F5DNtPZlCmN4nJGCFEHTPaEbvAwEByc3Pp1asXffr04bnnnqNz585YWlre8jVDQkJYv3694evKa126dIno6GjeeOMNOnbsSFZWFpMmTWLEiBHs37/fcP6kSZNYu3Yty5cvx93dnRdeeIFhw4YRFRV1W3EJIcSt2BOfCUD3YDcyC4o5kZrP6tgLrI69gK/OlvvC/fhHZz+aNXFQOVIhREMx2sSucl9YjUaDpaUllpaW1+3bUhtWVlaGUbor6XQ61q1bV+XYxx9/TNeuXTl79iwBAQHk5OTw+eef8/XXXzNw4EAAvvnmG/z9/Vm/fj133XXXbcUmhBA3Q1EU9iRcBOD5O1tyR3N34s7n8GPUOVbHXuBCTiELNp1iwaZTdGnmyj86+3F3B18ctUb7a18IUQeMdio2JSWFXbt2MXToUPbs2cPdd9+Nq6srw4YN49///jf79u1Dr9ff1DVPnjyJr68vQUFBjBkzhvj4+BrPzcnJQaPR4OLiAkBUVBQlJSVERkYazvH19SU0NJSdO3de975FRUXk5uZWeQghxO1IvHiJ1NwirC01hAW4otFo6ODnwtv3hLLn1QF88mA4/Vp7YKGBfWeymPpT+VTtlBWx7DyVgV6maoUwS0b90a1Nmza0adOGf/3rXwAcPXrUUBn7zjvvoNFoyM7OrtW1unXrxldffUWrVq1ITU1l5syZ9OjRg8OHD+Pu7l7l3MLCQl555RUefPBBQ+VJSkoKNjY2uLq6VjnXy8uLlJSU6957zpw5zJgxo5Y/tRBC3FjlaF1HPxfsbKouBbG1tuTuDj7c3cGH1NxCfo45zw/7kzidXsDKmPOsjDlPUxc7RnX24x/hfgS426vxIwgh6oHRjthdLTU1lYMHD3Lw4EEOHDhAXl6eYbq2NoYMGcKoUaNo3749AwcO5NdffwXgyy+/rHJeSUkJY8aMQa/Xs3DhwhteV1GUG24LNm3aNHJycgyPpKSkWscthBDVqVxf1y3Y7brneTnb8q++zVk/pS8/P9uDh7oF4GRrxfnsy/xnw0n6vLeJf366ix/2J1FQVNoQoQsh6pHRjtilpaUZetZt2rSJEydOYG1tTdeuXRkzZgz9+/fnjjvuuOXrOzg40L59e06ePGk4VlJSwujRo0lISGDjxo1V+sR4e3tTXFxMVlZWlVG7tLQ0evTocd17abVatFrtLccqhBBX25NQkdgFud/gzHIaTfmUbViAK28Ma8dfR1L5YX8S209lsCchkz0JmUxfc5ih7X34R2c/ujZzw8JC9rIWwtQYbWLn7e2NtbU1ERERjBo1in79+tXp3rFFRUUcPXqU3r17A38ndSdPnmTTpk3XTM927twZa2tr1q1bx+jRowFITk7m0KFDzJs3r05iEkKI2kjKvMT57MtYWmjoHOh642+4iq21JSM6+jKioy/JOZdZGX2eH6POkZBRwI9R5/gx6hz+bnb8I9yf+8Kb4u8mU7VCmAqj3Xnizz//pFevXjg41E2Z/osvvsjw4cMJCAggLS2NmTNnsmXLFuLi4mjatCmjRo0iOjqaX375BS8vL8P3ubm5GfanfeaZZ/jll19YtmwZbm5uvPjii1y8ePGm253IzhNCiNvxY9Q5XvzhAJ38XVg1vmedXFNRFKLPZvFj1DnWHkgm/4pp2TuC3bk3vCmD2nrh6mD6+3ULYYpMfueJyvYh33zzDQ8//HC157z00ku89957tbreuXPneOCBB8jIyMDDw4Pu3buze/duAgMDOXPmDGvWrAGgU6dOVb5v06ZN9OvXD4APPvgAKysrRo8ezeXLlxkwYADLli2THnZCiAa1J768cOJG6+tuhkajoXOgG50D3XhzWAh/Hk7hh6gkdp6+yK748oelhYZuQW4MDvUmsp033jrbOru/EKJuGO2IXSUXFxe++eYbhg0bVuX45MmTWb58OcnJySpFdutkxE4IcTv6zNvE2cxLLH2sC/3beNbrvc5lXeLn6PP8dqh8l4srdfJ34a4QbwaHehMkTZCFqFe1zR2MPrH7448/GDNmDGvWrKFPnz4APPfcc6xcuZINGzbQpk0blSO8eZLYCSFuVXLOZe6YsxELDcROj2zQvWHPXrzEn4dT+ONwCtFns7jy3aO1lxN3hXhxV6g37Xycb9gtQAhxc8wmsQNYvnw5zz77LH/99RdffPEFq1evZtOmTbRq1Urt0G6JJHZCiFu1OvY8E5fHEtrUmV+e661aHGm5hfx1JJU/D6ew6/RFSq9oeOznasfgEG/uCvUmPMAVS6muFeK2mfwauyuNGTOGrKwsevXqhYeHB1u2bKFFixZqhyWEEA1ud/zNtTmpL57OtjzcPZCHuweSc6mEDcfKk7wtJ9I5l3WZ/25P4L/bE2jiqCUyxIu7Qry5I9gdGyuTaZ8qhEkyysRuypQp1R739PQkLCysSuPg+fPnN1RYQgihusodJ7oF1V3hxO3S2VtzX7gf94X7cbm4jC0n0vnzcArrj6aSkV/Ed3vO8t2eszjZWjGgjSeDQ73p08oDexujfAsSwqQZ5f+qmJiYao83b96c3Nxcw/OyhkMI0Zik5RUSn16ARgNdjSixu5KdjSWDQ8sLKopL9eyOv8ifh1P460gq6XlFrIq9wKrYC9haW9CnpQeDQ70Z0MYLnX3DrRUUwpyZxBo7cyNr7IQQt+KXgxeY8F0Mbbyd+GNSH7XDuSl6vUJMUhZ/HCovvkjKvGx4zspCwx3N3Yls50WfVh4EukuFrRBXM6s1dkIIIf7eH7Z7sLrr626FhcXfffJeHdqWo8l5/HE4hb8Op3AsJY9tJzPYdjIDgAA3e3q3bELvlh7c0dwdnZ2M5glRW0aZ2P3rX//itddew9/f/4bnrlixgtLSUh566KEGiEwIIdRjjOvrboVGo6GdrzPtfJ2ZMqgVZzIK+ONwCpuOpRGVmMXZzEt8u+cs3+45i6WFhk7+LoZEr6OfDitLKcAQoiZGmdh5eHgQGhpKjx49GDFiBBEREfj6+mJra0tWVhZHjhxh+/btLF++nKZNm7JkyRK1QxZCiHqVWVDMidR8wHjX192qZk0c+Fff5vyrb3Pyi0rZE3+xYgQvndPpBUQlZhGVmMWH60/iZGtFj+bu9G7pQZ+WHgS4yz62QlzJaNfYpaWl8fnnn7N8+XIOHTpU5TknJycGDhzI008/TWRkpEoR3jpZYyeEuFl/HErmX99E09LTkXVT+qodToM5n32Z7SfT2Xoygx2nMsi+VFLl+UD3qtO2DdmwWYiGZFYNirOzs0lMTOTy5cs0adKE5s2bm3RFrCR2Qoib9daawyzbeYaHuwcwc2R7tcNRRZle4dD5HLZVJHrRiVlVGiPLtK0wZ2aV2JkbSeyEEDdryEfbOJqcy8cPhDG8o6/a4RiF/KJSdp++yLaT6Ww7mUF8RkGV551srejZvAm9WzWhT0sP/N1k2laYLqmKFUIIM5FzqYRjKbkAdAs2r/V1t8NRa8XAdl4MbOcFwLmsS2yvqK7dfiqDnMsl/FGxty1AM3d7erVsQrcgd7o0c8NbZ6tm+ELUC0nshBDCyO09k4miQHATBzydJBmpiZ+rPWO6BjCmawBleoW48zlsO1E+mhd9NoszFy9x5uJZvtl9FgB/Nzu6NHMzPJp7OJj0Mh8hQBI7IYQwenviK9qcyGhdrVWut+vk78JzA1qSV1jC7vhMdpzKYN+ZTI4m55KUeZmkzPOsjD4PgJuDDRGBruWJXpAbIb7OWMsaPWFiJLETQggjtyehvDFxtyDTa0xsLJxsrRnUzotBFdO2eYUlRJ/NZv+ZTPYmZBKblE1mQTF/HUnlryOpANhZWxIW4EJEMze6NnMjLMAFB628bQrjJv9ChRDCiOUWlnD4Qg4gI3Z1ycnWmr6tPOjbygOA4lI9cedz2H8mk31nMtl3JoucyyXsPH2RnafLR0wtLTSE+DoTEehG1yBXIpq50cRRq+aPIcQ1jD6xCwsLq3bNg0ajwdbWlhYtWvDYY4/Rv39/FaITQoj6FXUmC71Svs2Wj85O7XDMlo2VBZ0DXekc6Mq4vs3R6xVOpeezNyGzItnL4nz2ZQ6ey+HguRy+2JEAlK977NLMjYhmrnQNciPAzV7W6QlVGX1iN3jwYBYtWkT79u3p2rUriqKwf/9+Dh48yGOPPcaRI0cYOHAgK1eu5J577lE7XCGEqFO7zWQbMVNjYaGhlZcTrbyceLh7IFDeLNkwopeQxfHUPOIzCojPKGDF/iQAPJ20dKmYtu3g50JoU2fsbYz+rVaYEaP/15aRkcELL7zAG2+8UeX4zJkzSUxM5K+//mL69Om88847ktgJIczOnviK9XXBsr5ObU1d7GjaqSn3dGoKQPalYqISs9h7JpP9Z7I4eC6btLwifo1L5te4ZAAsNNDS04kOfjo6+LvQ0U9HG29nbKykKEPUD6NvUKzT6YiKiqJFixZVjp86dYrOnTuTk5PDsWPH6NKlC3l5eSpFeXOkQbEQojYKikrpMOMvyvQK217uLw12jVxhSRkHkrLZn5jFgaRsDp7LISW38JrzbCwtaOvjRAc/Fzr46ejo70JzD8f/b+/Ow5sq0z6Of9OkTZekpQvd7E6hLC27gEUtyKrAlMERRRxB3BgYBBRHwQXwxTK44MaogyIijOAyqDCOI6DspVDKLpW1pSwt3fc2aZPz/tE2EFp2aNJyf64rV5LnnJzcp4Hm1+c85zmoHeQQrri4ZjNBsbOzM4mJifWCXWJiIs7ONfM5mc1mtFoZwCqEaF5SThRgMivc1sJFQl0T4OyopmeEt1Xv6tniytpxeYXsrb0vLK9i76ki9p4qsqzn5qSmw20edAryoGNQCzoFtSDYy0XG64mrZvfBbtKkSYwfP56UlBRuv/12VCoVO3bs4NNPP2XGjBkA/Pzzz3Tp0sXGlQohxI21XcbXNXl+7s4MaO9smWZFURRO5lew91ShJewdOF1EmdHEjrSaqVfqeLo6EhPU4ryw54Gvu0xQLS7N7g/FAvzrX/9iwYIFHDp0CICoqCgmTZrEww8/DEBFRYXlLNmmQA7FCiGuxJ8+SmTniQLm3R/Dg7eH2LoccZOYzArHckoth2/3nSokNbMEo8lcb11/d2fL4dvo2zxo56+npV4rPXu3gCvNDk0i2DU3EuyEEJdTYTTRcfbPVJkUNkzrQ5iPm61LEo3IUG3iUFZJzeHb2sB3JLsEcwPf2N5uTrQLcKddgJ52Ae609Xcn0lcnJ2g0M81mjF0do9FIdnY2ZrP1XzAhIfJXrBCi+dmdUUCVScHPXUuot4yvu9VoNerakytaQO10K2WGan47U2w5hHvwTBFpuWXklRnZcjSXLUdzLa93VKto1VJH+wB32tYGvnYB7jKh8i3A7oPdkSNHGDduHImJiVbtiqKgUqkwmUw2qkwIIW6epPMuIyaH2QSAm1ZDj3Avepw35rLCaOLw2RJSM4v5PauEg5nFpGYWU1JZze9ZJfyeVQK7z22jpV5LW3897WuDXrsAdyJausk1cZsRuw92Y8eORaPR8J///IeAgAD5BSeEuCVsP1574oRcRkxcgouTmk7BLegU3MLSpigKpwsrSM0s4ffMYlKziknNLCE9r4ycEgM5JQY2HznXu+ekdiDSV2d1OLddgDtebk422CNxvew+2O3Zs4eUlBTatm1r61KEEKJRVFaZ2H2yEKjpsRPiaqhUKoI8XQnydLWcjQtQbqzmUFYJqZk1PXx1vXylhmoOZhZzMLPYajt+7lrLeL3Wvrraez0ero6NvUviKth9sGvfvj25ubmXX1EIIZqJvScLMVab8dFpadVSTpoQN4ark4YuIZ50CfG0tJnNCqcKKmp79epuJWTkl3O22MDZ4hw2Hs6x2o6PTktrXx2t/WrCXt2tpU7OzrUHdh/s5s2bx9/+9jcSEhKIiYnB0dH6LwU5q1QI0dxst4yv85IvSnFTOTioCPF2JcTblUEd/C3tpYZqDmUVcyirlKPZpRzJLuFYdilniirJLTWQW2pgW+1wgToeLo6Wnr26W2s/PYEezvLvuBHZfbDr378/AP369bNql5MnhBDNlWViYhlfJ2xEp9XQLdSLbqHW/wZLKqs4llNmFfaOZJeSkV9OUUUVO08UsPNEgdVrXJ3U1mHPV0+kr44QL1e5jNpNYPfBbv369bYuQQghGo2x2kxK7RejjK8T9kbv7Ejn4BZ0Pu9kDagZF3o8p8wq7B3NLiUtt4xyo6l24uUiq9c4aRyI8HEj0ldHuI8bYd5uhPm4EeHjhqecuHHN7D7YxcXF2boEIYRoNPtPF1JZZcbTteawlhBNgbOjmvaB7rQPtB4eVWUycyKvnKPZJRw5W8rRnFKOnC3lWE4phmrzuSlZLuDh4kiYjxvh3q4197W3MB833J3l5I1Lsctgt2/fPqKjo3FwcGDfvn2XXLdjx46NVJUQQtx8Scdrxtf1CPfCQQ5TiSbOsXYqlUhfHYOjz7WbzAqnCyo4mlNS27NXTnpuGel5ZWQWVVJUUcXek4XsrT07/Hzebk6E1fbwRbSs6+lzJczbDTetXcaaRmWXP4HOnTuTlZWFr68vnTt3RqVS0dCVz2SMnRCiudl+3sTEQjRX6vNO2rinrZ/VsgqjiRP5ZaTllJGWV1YT+HLLSaudhy+vzEhemdEyZOF8vnqt5XBuXfgL93Ej1NsVZ0d1Y+2eTdllsEtLS6Nly5aWxzfCrFmzmD17tlWbn58fWVlZQM3JGLNnz2bhwoUUFBTQs2dP/vGPf9ChQwfL+gaDgWnTprF8+XIqKiro168fH374IUFBQTekRiHEra3aZCYlvTbYyYkT4hbl4qSmrX/NNW8vVGqoJj23jLTcmsBnCX555eSXGckuMZBdYmBH7R9I5/N3dybYy4VgT1eCvWpuIV6uBHu54Kd3bjY95HYZ7EJDQy2PT5w4QWxsLBqNdanV1dUkJiZarXs5HTp0YN26dZbnavW59P7GG28wf/58Pv/8c9q0acOcOXMYMGAAhw4dQq/XAzBlyhRWr17NihUr8Pb25rnnnmPo0KGkpKRYbUsIIa7Fb2eKKTOacHfWNPilJsStTqfVEH2bB9G3edRbVlReZQl6abWHddNzyzieW0ZJZTVZxZVkFVeSnF6/p89J7UCQp0tt4HOpCXznBUAPl6Yzrs8ug935+vbtS2ZmJr6+vlbtRUVF9O3b96oOxWo0Gvz9/eu1K4rCu+++y0svvcSIESMAWLJkCX5+fnz55Zc8/fTTFBUVsWjRIpYuXWqZgmXZsmUEBwezbt06Bg0adB17eWNVmcxy3T8hmqC6aU56hHvJNBBCXCUPV0c6u9Y/Y1dRFPLLjJwsqOBkfjkZ+eWcKqi5P5lfwenCCowmM8drQ2CD23ZxtPT2hXi5ElTX2+fpwm2eLmg19tO5Y/fBrm6+ugvl5eXh5nZ1M7IfOXKEwMBAtFotPXv2JCEhgYiICNLS0sjKymLgwIGWdbVaLXFxcSQmJvL000+TkpJCVVWV1TqBgYFER0eTmJh4yWBnMBgwGAyW58XFxRdd93odzynl0c92MGd4NH2ifC//AiGE3dh+XMbXCXGjqVQqvHVavHXaeqEPaoZAZBZVcjK/nJMFNWEvw/K4nNxSI0UVVRSdruLA6frf3ypV3WFeVzoEujNzWId66zQmuw12dT1nKpWKsWPHotVqLctMJhP79u0jNjb2irfXs2dPvvjiC9q0acPZs2eZM2cOsbGx/Pbbb5Zxdn5+1gM4/fz8OHHiBABZWVk4OTnh6elZb52611/M3Llz643vu1k+3HCMUwUVjPs8mZeGtGdc7zCZ8VuIJsBkVtgh4+uEaHQatYPlkGtDygzVnDqvt68u8NUFwIoqE5lFlWQWVWKoNjdy9fXZbbDz8Kg5fq4oCnq9HhcXF8syJycnevXqxZNPPnnF27v33nstj2NiYrjjjjto1aoVS5YsoVevXgD1AtDFeguvdp3p06fz7LPPWp4XFxcTHBx8xbVfjdf/GI0K+CblFP/3n4McOVvCa/HROGnk0KwQ9iw1s5iSymp0Wg3tA2R8nRD2wk2rIcpfT5S/vt4yRVHIKzPWHtYtt4tDsnYb7BYvXgxAWFgY06ZNu+rDrpfj5uZGTEwMR44cYfjw4UBNr1xAQIBlnezsbEsvnr+/P0ajkYKCAqteu+zs7Mv2HGq1Wqsex5tJq1Hzxp86EuWvJ+G/qaxIPsnxnDI+eqQr3rrGqUEIcfXqpjnpHuaJRsbICtEkqFQqfHRafHRauoZ4Xv4FjcDuf3vMnDnzhoc6qBn3lpqaSkBAAOHh4fj7+7N27VrLcqPRyMaNGy2hrVu3bjg6Olqtk5mZyYEDB67qkHBjUKlUPHFXBIvG3o5eq2FHej7x/9jK71k3b2yfEOL6bD9+7sQJIYS4VnbbY3e+b7/9lq+//pqMjAyMRqPVsl27dl3RNqZNm8awYcMICQkhOzubOXPmUFxczJgxY1CpVEyZMoWEhARat25N69atSUhIwNXVlYcffhioOTT8+OOP89xzz+Ht7Y2XlxfTpk0jJibGcpasvekb5ct3E2N5fMlOTuSVc/+Hibz7UBcGtPe7/IuFEI3GfP74OjlxQghxHey+x+7999/nsccew9fXl927d9OjRw+8vb05fvy41bi5yzl16hSjRo0iKiqKESNG4OTkRFJSkmUevL/97W9MmTKFCRMm0L17d06fPs2aNWssc9gBvPPOOwwfPpyRI0fSu3dvXF1dWb16tV3PYRfpq+f7Cb2JbeVNmdHEU0t38tGGYw1eyUMIYRuHs0soLK/CxVFNx6D683MJIcSVUil2/g3ftm1bZs6cyahRo9Dr9ezdu5eIiAheffVV8vPzWbBgga1LvGrFxcV4eHhQVFSEu3vjDJKuMpmZvfo3liVlAPDHLrcxd0TMLXOJFSHs2ZLEdGau+o07I31Y9kRPW5cjhLBDV5od7L7HLiMjwzKGzcXFhZKSEgD+/Oc/s3z5cluW1qQ4qh2YMzyG/4vvgNpBxXe7T/PQwiSySyptXZoQt7y6iYl7yvg6IcR1svtg5+/vT15ezS+90NBQkpKSgJpryNp5Z6Nd+vMdYSwd1wMPF0f2nCwkfsFWDpwusnVZQtyyFEWxXNeyZ4SMrxNCXB+7D3b33HMPq1evBuDxxx9n6tSpDBgwgAcffJA//vGPNq6uaYqN9OGHib1p1dKNzKJK/vRxIj/uy7R1WULcko7llJJbakSrcaBTsIyvE0JcH7s/K3bhwoWYzTUzOY8fPx4vLy+2bNnCsGHDGD9+vI2ra7rCfNz4bmJvJn25m42Hc5j45S6OZLfmmXta4yDXqBSi0STVXkasS0gLu5jcVAjRtNl9j52DgwMazbn8OXLkSN5//32eeeYZcnJybFhZ0+fu7MhnY2/niTvDAXh33REmLd9NhdFk48qEuHXUTUws05wIIW4Euw92DcnKymLSpElERkbaupQmT+2g4uWh7Xnj/o44qlX8uD+TB/6ZSGZRha1LE6LZUxTFMjGxXB9WCHEj2G2wKywsZPTo0bRs2ZLAwEDef/99zGYzr776KhERESQlJfHZZ5/ZusxmY+TtwXz5ZC+83Jw4cLqYPyzYyu6MAluXJUSzlp5XTnaJASe1g91cjkgI0bTZbbCbMWMGmzZtYsyYMXh5eTF16lSGDh3Kli1b+Omnn0hOTmbUqFG2LrNZuT3Mix8m9qatv56cEgMPLkziu92nbF2WEM1WXW9dp2APmVNSCHFD2G2w+/HHH1m8eDFvvfUWq1atQlEU2rRpw6+//kpcXJyty2u2gr1c+fYvsQxo74ex2szUr/Yy73+/YzbL1DJC3Ggyvk4IcaPZbbA7c+YM7du3ByAiIgJnZ2eeeOIJG1d1a9BpNfzzkW5M7NsKgI82HOOppSmUGqptXJkQzYeMrxNC3Ax2G+zMZjOOjo6W52q1Gjc3NxtWdGtxcFDx/KC2vPdQZ5w0DqxLPcufPkrkZH65rUsTolk4VVDBmaJKNA4quoXK+DohxI1ht/PYKYrC2LFj0Wq1AFRWVjJ+/Ph64W7lypW2KO+WEd/5NkK93Xjyi538nlVC/D+28tHorjJDvhDXKam2ty4myANXJ7v9VSyEaGLstsduzJgx+Pr64uHhgYeHB4888giBgYGW53U3cfN1Dm7Bqr/2JuY2D/LLjDyyaDtfJWfYuiwhmjQZXyeEuBns9s/ExYsX27oEcZ4ADxe+fvoOpn27lx/3ZfLCv/ez9Wgej98ZTqfgFrYuT4gmZ3uajK8TQtx4dhvshP1xcVKzYFQXovz0zF97mFV7z7Bq7xk6BnnwSK9QhnUMxMVJpmwQ4nLOFFZwMr8CBxV0l/F1QogbyG4PxQr7pFKpeKZfa36Y2JsRXW/DSePAvlNF/O3bffSa+wtz/nOQtNwyW5cphF2r662Lvs0DvbPjZdYWQogrJ8FOXJNOwS2YP7IzSdP78eK9bQn2cqGooopPt6TR960N/HnRdtb8lkW1yWzrUoWwO9uP142vk8OwQogbSw7Fiuvi5ebE+LhWPHlXBJsO57As6QS/Hspm85FcNh/JJdDDmYd7hjDy9mB89c62LlcIuyAnTgghbhaVoih2fUmBwsJCWrRo0eCyo0ePEhkZ2bgF3QDFxcV4eHhQVFSEu7u7rcu54U7ml/Pljgy+Sj5JfpkRAEe1isHRAfy5Vyi3h3miUqlsXKUQtpFdXEmPhF9QqWDPqwPxcJFDsUKIy7vS7GD3h2Lvu+8+Kisr67UfOnSIPn36NH5B4rKCvVx5YXBbtk2/h3cf7EzXkBZUmRRW7z3DyH9uY/C7m1madEKuZCFuSUm1vXXt/N0l1Akhbji7D3aenp4MHz6c6upzISA1NZU+ffpw//3327AycTlajZrhXW5j5YTe/PjMnYzqEYKLo5pDZ0t45fsD9Hx9Ha98f4BDWSW2LlWIRiOXERNC3Ex2fyi2srKSAQMGEBAQwFdffcVvv/1Gv379GD16NPPnz7d1edekuR+KvZTiyipWppxiadIJjuWcO3u2R5gXj9wRyuAO/jhp7P7vDSGuWf/5GzmaXcrHj3RjcLS/rcsRQjQRV5od7D7YARQVFdGnTx9atWrF5s2befTRR3nzzTdtXdY1u5WDXR1FUdh2PI9lSSf4+bezmMw1/wx9dFpG9QhmVI8QAlu42LhKIW6s3FID3eesA2DXKwPwcnOycUVCiKaiSQe74uLiem1ZWVn079+foUOH8ve//93S3hSDkQQ7a1lFlaxIzmD5jgzOFhsAcFBBv3Z+PNAtiJ4R3jIWSTQL/92fyYR/7SLKT8/PU++2dTlCiCakSQc7BweHBs+arCtVpVKhKAoqlQqTydTY5V03CXYNqzKZWXfwLEuTTpB4LM/SrlJBh0B3eoV70zPCmx5hXni4StATTc/MHw6wZNsJHr0jlNfio21djhCiCbnS7GCX89itX7/e1iUIG3BUO3BvTAD3xgRwNLuEf23PYMOhHNJyyzhwupgDp4v5dEsaKhW0D3CnZ7g3vSK86BHuRQtXOaQl7J/MXyeEuNnssseuuZMeu6tztriSpON5JB3PZ3taHsdzrC9ZplJBW393ekV40TPcm57hXnjK2CVhZwrLjXT5v7UoCiS/1J+Weq2tSxJCNCFNusfufIsXL0an0/HAAw9YtX/zzTeUl5czZswYG1UmGoufuzPxnW8jvvNtQM0Er9vT8mvDXh7HcspIzSwmNbOYxVvTAWjrr6dXRF2PnrcMUhc2tyMtH0WBVi3dJNQJIW4auw92f//73/n444/rtfv6+vLUU09JsLsF+bo7M6xTIMM6BQKQXVLJjrR8th+vCXtHskv5PauE37NK+DwxHYAoPz09I7zoFeFNj3AvfHTyxSoal+UwbIQchhVC3Dx2H+xOnDhBeHh4vfbQ0FAyMjJsUJGwN756Z4Z2DGRox5qgl1tqYEdtj9724/kcOltiuX2x7QQArX119IrwpmeEFz3CvGip18plzsRNtT2tdmLicJmYWAhx89h9sPP19WXfvn2EhYVZte/duxdvb/nLV9Tno9NyX0wA98UEAJBXaiA5PZ+k2h6937NKOJJdypHsUpYm1QQ9T1dHWvvqifTT0cZXR2s/Pa19dRL4xA1RXFnFwTM10zj1kh47IcRNZPfB7qGHHuKZZ55Br9dz99018z5t3LiRyZMn89BDD9m4OtEUeOu0DI4OYHB0TdArKDOyPa3mRIyk4/n8nlVMQXkVO9Lz2ZGeb/VaDxdHWp8X9Fr76Wjjp8dXAp+4CjvT8zErEObtip+7s63LEUI0Y3Yf7ObMmcOJEyfo168fGk1NuWazmUcffZSEhAQbVyeaIk83JwZH+1su51RZZeJYTilHs0s5fLaEI2drHqfnlVFUUcXOEwXsPFFgtQ13Z40l7EX61oS91n46/N2dJfCJerYfl2lOhBCNo8lMd3L48GH27t2Li4sLMTExhIaG2rqkaybTnTQNlVUm0nLLOHy2hKPZpRw5W8rh7BJO5JVbLoF2Ib1WQ6Sfjta1YS+ytrcv0EMC360s/h9b2XuykPkjOzGia5CtyxFCNEHNZrqTOm3atKFNmza2LkPcQpwd1bQLcKddgPV/IEN1TeA7crZmnN6RszVj9tJzyygxVLM7o5DdGYVWr3FzUnObpwu3tXAhsPYW5HnusZ9ei0bt0Ih7JxpLqaGaA6eLADkjVghx8zWJYHfq1ClWrVpFRkYGRqPRatn8+fNtVJW4VWk1atr6u9PW3zrwGavNpOfVBL66Xr7DZ0tIyy2jzGji8NlSDp8tbXCbagcV/u7OBLZwJrDFuQB4WwsXbqsNgDptk/jvKi6QcqIAk1khqDbYCyHEzWT33xS//PILf/jDHwgPD+fQoUNER0eTnp6Ooih07drV1uUJYeGkcaCNn542fnqGEGBprzKZycgv50xhBacLKmruCys5XVjOmcJKMosqqDIpnC6s4HRhBVDQ4PbdnTX1evrOD4At9VrUDnK4195sP143zYn01gkhbj67D3bTp0/nueee47XXXkOv1/Pvf/8bX19fRo8ezeDBg695u3PnzmXGjBlMnjyZd999F4DS0lJefPFFvv/+e/Ly8ggLC+OZZ57hL3/5i+V1BoOBadOmsXz5cioqKujXrx8ffvghQUEybkY0zFHtQKuWOlq11DW43GxWyC01cKqwJvTVBcDThZU1z4sqKCyvoriymuLaiZcbonFQ4aPT4qN3wkenxdut5nFLnRZvXU1b3c3LzUlCYCM5NzGxzF8nhLj57D7Ypaamsnz5cgA0Gg0VFRXodDpee+014uPjrULXlUpOTmbhwoV07NjRqn3q1KmsX7+eZcuWERYWxpo1a5gwYQKBgYHEx8cDMGXKFFavXs2KFSvw9vbmueeeY+jQoaSkpKBWq69/h8Utx8FBha+7M77uznQN8WxwnVJDNZm1PXqnLQGwsjYAVpBVXEm1WSGruJKs4srLvqdKBV6utQHw/NCnd8LH7bxwqNPio3NCq5F/29eiwmhi36lCAHpJj50QohHYfbBzc3PDYDAAEBgYyLFjx+jQoQMAubm5V7290tJSRo8ezSeffMKcOXOslm3bto0xY8bQp08fAJ566in++c9/snPnTuLj4ykqKmLRokUsXbqU/v37A7Bs2TKCg4NZt24dgwYNuo49FeLidNra6VX89A0uN5kVsksqySkxkFtqILfUWHNfUnOfV3bucX65EUWBvDIjeWVGOHv599c7a2rDnxOerk60cHWkhasTHi6OeLg40sK19t6lZpm7iyN6rQaHW7xXcFdGAVUmBX93Z4K9ZHydEOLms/tg16tXL7Zu3Ur79u0ZMmQIzz33HPv372flypX06tXrqrc3ceJEhgwZQv/+/esFuzvvvJNVq1Yxbtw4AgMD2bBhA4cPH+a9994DICUlhaqqKgYOHGh5TWBgINHR0SQmJl402BkMBks4hZpTloW4kdQOKgI8XAjwuHx4MJkV8stqg1+pgbzaEJhTGwTzygyWUJhXZqDKpFBSWU1JZTVpuWVXXJODCkvw83B1osV5IbCFS034a1HXXtvmURsQm0sPoWV8XYSXTHcjhGgUdh/s5s+fT2lpzZmEs2bNorS0lK+++orIyEjeeeedq9rWihUr2LVrF8nJyQ0uf//993nyyScJCgpCo9Hg4ODAp59+yp133glAVlYWTk5OeHpaHy7z8/MjKyvrou87d+5cZs+efVW1CnGzqB1UtNRraanXXnZdRVEorqiuCX21t4LyKoorqigsN1JYXkVRRRWFFVUUWR4bqawyY1agoLyKgvIqyCu/qhqdHR3QaR3RO2vQaTWWe52zBn3tvU7riM5Zg3vdMstyx9rlGpw0tp1CJilNJiYWQjQuuw92ERERlseurq58+OGH17SdkydPMnnyZNasWYOzc8OX9Hn//fdJSkpi1apVhIaGsmnTJiZMmEBAQIDl0GtDFEW55F/j06dP59lnn7U8Ly4uJjg4+Jr2Q4jGpFKpanrRXB2J9G345I+GVFaZasJfRdW58FdupKii7nFtGKyooqjcaFmvuLIKRYHKKjOVVTVB8npoNQ5WobAmJNYcJnbTanDVqnFz0uDqpMbVcl/7WFvz2M1Jg0vtvbOjwxX3vFVWmdhzshCQEyeEEI2nSQS75ORkvL2t/+ItLCyka9euHD9+/Iq2k5KSQnZ2Nt26dbO0mUwmNm3axIIFCygqKmLGjBl89913DBkyBICOHTuyZ88e3nrrLfr374+/vz9Go5GCggKrXrvs7GxiY2Mv+t5arRat9vK9I0I0F86Oapwd1fhe5XVRzeaaw75FFVWUGqprb1WUVNY+rj0kXGqou6861157X2qoptxoAsBQbcZQaiS31HiZd74yKhW4Oqpx1TYUBs8LgVoNpYZqjNVmfHRaInzcbsj7CyHE5dh9sEtPT8dkMtVrNxgMnD59+oq3069fP/bv32/V9thjj9G2bVteeOEFTCYTVVVVODhYH7pRq9WYzWYAunXrhqOjI2vXrmXkyJEAZGZmcuDAAd54442r3TUhxAUcHM71EF6PapOZMoOJkosEv5qAWEW50UR5lYny2jBYbjRRZqym4vx7g4mKqprfQYoCZUYTZcb6v5MuppeMrxNCNCK7DXarVq2yPP7555/x8PCwPDeZTPzyyy+EhYVd8fb0ej3R0dFWbW5ubnh7e1va4+LieP7553FxcSE0NJSNGzfyxRdfWK5u4eHhweOPP85zzz2Ht7c3Xl5eTJs2jZiYmEseqhVCNC6N2gEPV4frDoh1zGaFiqoLw141ZQYT5cbq2kBoosJYbQmCZYZqzAo8eVf4DalBCCGuhN0Gu+HDhwM1Y3zGjBljtczR0ZGwsDDefvvtG/qeK1asYPr06YwePZr8/HxCQ0N5/fXXGT9+vGWdd955B41Gw8iRIy0TFH/++ecyh50QzZiDgwq32nF5Qghhz1SKoii2LuJSwsPDSU5OxsfHx9al3DDFxcV4eHhQVFSEu7v75V8ghBBCiFvalWYHu//zMy0tzdYlCCGEEEI0CXYb7LZv305+fj733nuvpe2LL75g5syZlJWVMXz4cD744IMmebZpXSepTFQshBBCiCtRlxkud6DVboPdrFmz6NOnjyXY7d+/n8cff5yxY8fSrl073nzzTQIDA5k1a5ZtC70GJSU1F3GXueyEEEIIcTVKSkqsTii9kN2OsQsICGD16tV0794dgJdeeomNGzeyZcsWAL755htmzpzJwYMHbVnmNTGbzZw5cwa9Xi/TIFyhukmdT548KeMS7Zh8Tk2HfFZNg3xOTcfN/qwURaGkpITAwMB6U7Odz2577AoKCvDz87M837hxI4MHD7Y8v/322zl58qQtSrtuDg4OBAUF2bqMJsnd3V1+uTUB8jk1HfJZNQ3yOTUdN/OzulRPXR3bXkjxEvz8/CwnThiNRnbt2sUdd9xhWV5SUoKj442Zo0oIIYQQojmw22A3ePBgXnzxRTZv3sz06dNxdXXlrrvusizft28frVq1smGFQgghhBD2xW4Pxc6ZM4cRI0YQFxeHTqdjyZIlODk5WZZ/9tlnDBw40IYVisak1WqZOXNmkzwL+lYin1PTIZ9V0yCfU9NhL5+V3Z48UaeoqAidTlfvyg75+fnodDqrsCeEEEIIcSuz+2AnhBBCCCGujN2OsRNCCCGEEFdHgp0QQgghRDMhwU4IIYQQopmQYCfs1ty5c7n99tvR6/X4+voyfPhwDh06ZOuyxBWYO3cuKpWKKVOm2LoUcYHTp0/zyCOP4O3tjaurK507dyYlJcXWZYkLVFdX8/LLLxMeHo6LiwsRERG89tprmM1mW5d2S9u0aRPDhg0jMDAQlUrF999/b7VcURRmzZpFYGAgLi4u9OnTh99++61Ra5RgJ+zWxo0bmThxIklJSaxdu5bq6moGDhxIWVmZrUsTl5CcnMzChQvp2LGjrUsRFygoKKB37944Ojry008/cfDgQd5++21atGhh69LEBebNm8fHH3/MggULSE1N5Y033uDNN9/kgw8+sHVpt7SysjI6derEggULGlz+xhtvMH/+fBYsWEBycjL+/v4MGDDAco34xiBnxYomIycnB19fXzZu3Mjdd99t63JEA0pLS+natSsffvghc+bMoXPnzrz77ru2LkvUevHFF9m6dSubN2+2dSniMoYOHYqfnx+LFi2ytN1///24urqydOlSG1Ym6qhUKr777juGDx8O1PTWBQYGMmXKFF544QUADAYDfn5+zJs3j6effrpR6pIeO9FkFBUVAeDl5WXjSsTFTJw4kSFDhtC/f39blyIasGrVKrp3784DDzyAr68vXbp04ZNPPrF1WaIBd955J7/88guHDx8GYO/evWzZsoX77rvPxpWJi0lLSyMrK8vq4glarZa4uDgSExMbrQ67vfKEEOdTFIVnn32WO++8k+joaFuXIxqwYsUKdu3aRXJysq1LERdx/PhxPvroI5599llmzJjBjh07eOaZZ9BqtTz66KO2Lk+c54UXXqCoqIi2bduiVqsxmUy8/vrrjBo1ytaliYvIysoCaq51fz4/Pz9OnDjRaHVIsBNNwl//+lf27dvHli1bbF2KaMDJkyeZPHkya9aswdnZ2dbliIswm810796dhIQEALp06cJvv/3GRx99JMHOznz11VcsW7aML7/8kg4dOrBnzx6mTJlCYGAgY8aMsXV54hJUKpXVc0VR6rXdTBLshN2bNGkSq1atYtOmTQQFBdm6HNGAlJQUsrOz6datm6XNZDKxadMmFixYgMFgqHdZQNH4AgICaN++vVVbu3bt+Pe//22jisTFPP/887z44os89NBDAMTExHDixAnmzp0rwc5O+fv7AzU9dwEBAZb27Ozser14N5OMsRN2S1EU/vrXv7Jy5Up+/fVXwsPDbV2SuIh+/fqxf/9+9uzZY7l1796d0aNHs2fPHgl1dqJ37971pgw6fPgwoaGhNqpIXEx5eTkODtZf0Wq1WqY7sWPh4eH4+/uzdu1aS5vRaGTjxo3ExsY2Wh3SYyfs1sSJE/nyyy/54Ycf0Ov1lvELHh4euLi42Lg6cT69Xl9v7KObmxve3t4yJtKOTJ06ldjYWBISEhg5ciQ7duxg4cKFLFy40NaliQsMGzaM119/nZCQEDp06MDu3buZP38+48aNs3Vpt7TS0lKOHj1qeZ6WlsaePXvw8vIiJCSEKVOmkJCQQOvWrWndujUJCQm4urry8MMPN16RihB2CmjwtnjxYluXJq5AXFycMnnyZFuXIS6wevVqJTo6WtFqtUrbtm2VhQsX2rok0YDi4mJl8uTJSkhIiOLs7KxEREQoL730kmIwGGxd2i1t/fr1DX4vjRkzRlEURTGbzcrMmTMVf39/RavVKnfffbeyf//+Rq1R5rETQgghhGgmZIydEEIIIUQzIcFOCCGEEKKZkGAnhBBCCNFMSLATQgghhGgmJNgJIYQQQjQTEuyEEEIIIZoJCXZCCCGEEM2EBDshhGhi0tPTUalU7Nmzp1He75VXXuGpp55qlPeqYzAYCAkJISUlpVHfV4imToKdEMImsrOzefrppwkJCUGr1eLv78+gQYPYtm3bDdn+2LFjGT58+A3Z1rW+v0qlQqVSodFoCAkJ4S9/+QsFBQVXvZ0L9yM4OJjMzMxGuVzb2bNnee+995gxY4ZVTSqVivHjx9dbf8KECahUKsaOHQvAxx9/jF6vp7q62rJOaWkpjo6O3HXXXVav3bx5MyqVisOHD6PVapk2bRovvPDCzdkxIZopCXZCCJu4//772bt3L0uWLOHw4cOsWrWKPn36kJ+fb+vSbpjBgweTmZlJeno6n376KatXr2bChAnXvV21Wo2/vz8azc2/3PeiRYu44447CAsLs2oPDg5mxYoVVFRUWNoqKytZvnw5ISEhlra+fftSWlrKzp07LW2bN2/G39+f5ORkysvLLe0bNmwgMDCQNm3aADB69Gg2b95MamrqTdo7IZofCXZCiEZXWFjIli1bmDdvHn379iU0NJQePXowffp0hgwZAsC4ceMYOnSo1euqq6vx9/fns88+A+Dbb78lJiYGFxcXvL296d+/P2VlZcyaNYslS5bwww8/WHrNNmzYAMDp06d58MEH8fT0xNvbm/j4eNLT0y3vUddDlpCQgJ+fHy1atGD27NlUV1fz/PPP4+XlRVBQkKWGS6nriQwKCmLgwIE8+OCDrFmzxrLcZDLx+OOPEx4ejouLC1FRUbz33nuW5RfbjwsPxW7YsAGVSsUvv/xC9+7dcXV1JTY2lkOHDlnVM2fOHHx9fdHr9TzxxBO8+OKLdO7c+ZL7sGLFCv7whz/Ua+/atSshISGsXLnS0rZy5UqCg4Pp0qWLpS0qKorAwEDLz7+u3vj4eFq1akViYqJVe9++fS3Pvb29iY2NZfny5ZesUQhxjgQ7IUSj0+l06HQ6vv/+ewwGQ4PrPPHEE/zvf/8jMzPT0vbf//6X0tJSRo4cSWZmJqNGjWLcuHGkpqayYcMGRowYgaIoTJs2jZEjR1p6zDIzM4mNjaW8vJy+ffui0+nYtGkTW7ZsQafTMXjwYIxGo+V9fv31V86cOcOmTZuYP38+s2bNYujQoXh6erJ9+3bGjx/P+PHjOXny5BXv8/Hjx/nf//6Ho6Ojpc1sNhMUFMTXX3/NwYMHefXVV5kxYwZff/01wEX342Jeeukl3n77bXbu3IlGo2HcuHGWZf/61794/fXXmTdvHikpKYSEhPDRRx9dsuaCggIOHDhA9+7dG1z+2GOPsXjxYsvzzz77zOo96/Tp04f169dbnq9fv54+ffoQFxdnaTcajWzbts0q2AH06NGDzZs3X7JOIcR5FCGEsIFvv/1W8fT0VJydnZXY2Fhl+vTpyt69e63Wad++vTJv3jzL8+HDhytjx45VFEVRUlJSFEBJT09vcPtjxoxR4uPjrdoWLVqkREVFKWaz2dJmMBgUFxcX5eeff7a8LjQ0VDGZTJZ1oqKilLvuusvyvLq6WnFzc1OWL19+0f0bM2aMolarFTc3N8XZ2VkBFECZP3/+JX8uEyZMUO6///5L7kdaWpoCKLt371YURVHWr1+vAMq6dess6/z4448KoFRUVCiKoig9e/ZUJk6caLWd3r17K506dbpoLbt371YAJSMjo96+xcfHKzk5OYpWq1XS0tKU9PR0xdnZWcnJyVHi4+OVMWPGWNZfuHCh4ubmplRVVSnFxcWKRqNRzp49q6xYsUKJjY1VFEVRNm7cqADKsWPHrN7rvffeU8LCwi75MxNCnCM9dkIIm7j//vs5c+YMq1atYtCgQWzYsIGuXbvy+eefW9Z54oknLD1C2dnZ/Pjjj5YeoU6dOtGvXz9iYmJ44IEH+OSTTy57YkJKSgpHjx5Fr9dbeg29vLyorKzk2LFjlvU6dOiAg8O5X49+fn7ExMRYnqvVary9vcnOzr7k+/Xt25c9e/awfft2Jk2axKBBg5g0aZLVOh9//DHdu3enZcuW6HQ6PvnkEzIyMi79w7uIjh07Wh4HBAQAWGo8dOgQPXr0sFr/wucXqhs/5+zs3OByHx8fhgwZwpIlS1i8eDFDhgzBx8en3np9+/alrKyM5ORkNm/eTJs2bfD19SUuLo7k5GTKysrYsGEDISEhREREWL3WxcXFahyeEOLSJNgJIWzG2dmZAQMG8Oqrr5KYmMjYsWOZOXOmZfmjjz7K8ePH2bZtG8uWLSMsLMxyJqVarWbt2rX89NNPtG/fng8++ICoqCjS0tIu+n5ms5lu3bqxZ88eq9vhw4d5+OGHLeudf7gUQKVSNdhmNpsvuX9ubm5ERkbSsWNH3n//fQwGA7Nnz7Ys//rrr5k6dSrjxo1jzZo17Nmzh8cee8zqsPDVOL9GlUpl2ecL2+ooinLJ7dWFtEsF5nHjxvH555+zZMmSBg/DAkRGRhIUFMT69etZv349cXFxAPj7+xMeHs7WrVtZv34999xzT73X5ufn07Jly0vWKYQ4R4KdEMJutG/fnrKyMstzb29vhg8fzuLFi1m8eDGPPfaY1foqlYrevXsze/Zsdu/ejZOTE9999x0ATk5OmEwmq/W7du3KkSNH8PX1JTIy0urm4eFx0/dv5syZvPXWW5w5cwaoOTs0NjaWCRMm0KVLFyIjI616Di+2H9ciKiqKHTt2WLWdf6ZqQ1q1aoW7uzsHDx686Dp14xONRiODBg266Hp9+/Zlw4YNbNiwgT59+lja4+Li+Pnnn0lKSqo3vg7gwIEDVidjCCEuTYKdEKLR5eXlcc8997Bs2TL27dtHWloa33zzDW+88Qbx8fFW6z7xxBMsWbKE1NRUxowZY2nfvn07CQkJ7Ny5k4yMDFauXElOTg7t2rUDICwsjH379nHo0CFyc3Opqqpi9OjR+Pj4EB8fz+bNm0lLS2Pjxo1MnjyZU6dO3fT97tOnDx06dCAhIQGo6cnauXMnP//8M4cPH+aVV14hOTnZ6jUN7ce1mDRpEosWLWLJkiUcOXKEOXPmsG/fvnq9eOdzcHCgf//+bNmy5aLrqNVqUlNTSU1NRa1WX3S9vn37smXLFvbs2WPpsYOaYPfJJ59QWVnZYLDbvHkzAwcOvMK9FEJIsBNCNDqdTkfPnj155513uPvuu4mOjuaVV17hySefZMGCBVbr9u/fn4CAAAYNGkRgYKCl3d3dnU2bNnHffffRpk0bXn75Zd5++23uvfdeAJ588kmioqIs49e2bt2Kq6srmzZtIiQkhBEjRtCuXTvGjRtHRUUF7u7ujbLvzz77LJ988gknT55k/PjxjBgxggcffJCePXuSl5dXb567hvbjWowePZrp06czbdo0unbtSlpaGmPHjr3o+Lk6Tz31FCtWrLjkYWd3d/fL/vz69u1LRUUFkZGR+Pn5Wdrj4uIoKSmhVatWBAcHW71m27ZtFBUV8ac//ekK9lAIAaBSLjfIQgghbKi8vJzAwEA+++wzRowYYetympUBAwbg7+/P0qVLL7qOoij06tWLKVOmMGrUqEasDh544AG6dOliddULIcSl3fxpy4UQ4hqYzWaysrJ4++238fDwaHCSXHHlysvL+fjjjxk0aBBqtZrly5ezbt061q5de8nXqVQqFi5cyL59+xqp0hoGg4FOnToxderURn1fIZo66bETQtil9PR0wsPDCQoK4vPPP6dfv362LqlJq6ioYNiwYezatQuDwUBUVBQvv/yy9IIK0cxIsBNCCCGEaCbk5AkhhBBCiGZCgp0QQgghRDMhwU4IIYQQopmQYCeEEEII0UxIsBNCCCGEaCYk2AkhhBBCNBMS7IQQQgghmgkJdkIIIYQQzYQEOyGEEEKIZuL/AfMUyW1T/fKUAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -288,7 +289,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 9, @@ -297,7 +298,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -321,13 +322,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Running for System size: 1.0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Running for System size: 1.0\n", "Running for System size: 1.4736842105263157\n", "Running for System size: 1.9473684210526314\n", "Running for System size: 2.4210526315789473\n", @@ -337,16 +332,7 @@ "Running for System size: 4.315789473684211\n", "Running for System size: 4.789473684210526\n", "Running for System size: 5.263157894736842\n", - "Running for System size: 5.7368421052631575\n", - "Running for System size: 6.2105263157894735\n", - "Running for System size: 6.684210526315789\n", - "Running for System size: 7.157894736842105\n", - "Running for System size: 7.63157894736842\n", - "Running for System size: 8.105263157894736\n", - "Running for System size: 8.578947368421051\n", - "Running for System size: 9.052631578947368\n", - "Running for System size: 9.526315789473683\n", - "Running for System size: 10.0\n" + "Running for System size: 5.7368421052631575\n" ] } ], @@ -363,7 +349,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -373,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -408,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -444,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -665,7 +651,7 @@ ], "metadata": { "kernelspec": { - "display_name": "electrolyzer", + "display_name": "Python 3.11.11 ('bert')", "language": "python", "name": "python3" }, @@ -679,7 +665,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.11.11" + }, + "vscode": { + "interpreter": { + "hash": "a0dac1f70fdc281b4d1c97050cac2e7deb2e5a93625d03e31dc0baefa4755e69" + } } }, "nbformat": 4, diff --git a/examples/example_05_controller/example_05_controller_options.ipynb b/examples/example_05_controller/example_05_controller_options.ipynb index 5fc18b7..6c39f65 100644 --- a/examples/example_05_controller/example_05_controller_options.ipynb +++ b/examples/example_05_controller/example_05_controller_options.ipynb @@ -21,8 +21,9 @@ "from pathlib import Path\n", "import pprint\n", "\n", - "from electrolyzer import Supervisor, run_electrolyzer\n", - "from electrolyzer.inputs.validation import load_modeling_yaml" + "from electrolyzer.simulation.supervisor import Supervisor\n", + "from electrolyzer.simulation.bert import run_electrolyzer\n", + "from electrolyzer.tools.validation import load_modeling_yaml" ] }, { diff --git a/examples/example_06_conversion_efficiency/example_run.ipynb b/examples/example_06_conversion_efficiency/example_run.ipynb index 3da0c54..b655245 100644 --- a/examples/example_06_conversion_efficiency/example_run.ipynb +++ b/examples/example_06_conversion_efficiency/example_run.ipynb @@ -21,8 +21,8 @@ "source": [ "import numpy as np\n", "\n", - "from electrolyzer import run_electrolyzer\n", - "from electrolyzer.inputs.validation import load_modeling_yaml\n", + "from electrolyzer.simulation.bert import run_electrolyzer\n", + "from electrolyzer.tools.validation import load_modeling_yaml\n", "\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" From c3b8665a6e3dab5d676c563141d35ef7b5ee688b Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 13:18:24 -0700 Subject: [PATCH 12/31] added validators and minor fix in stack for cell type --- electrolyzer/simulation/stack.py | 4 ++-- electrolyzer/tools/validators.py | 26 ++++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 2 deletions(-) create mode 100644 electrolyzer/tools/validators.py diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index c5f9b2b..b389226 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -12,14 +12,14 @@ from electrolyzer.simulation.cell_models.pem import PEMCell, PEM_electrolyzer_model from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin, array_converter from electrolyzer.simulation.cell_models.alkaline import AlkalineCell, ael_electrolyzer_model - +from electrolyzer.tools.validators import contains @define class Stack(FromDictMixin): # Stack parameters # #################### dt: float = field() - cell_type: str = field() + cell_type: str = field(validator=contains(["PEM","alkaline"])) temperature: float = field() n_cells: int = field() diff --git a/electrolyzer/tools/validators.py b/electrolyzer/tools/validators.py new file mode 100644 index 0000000..c9d6468 --- /dev/null +++ b/electrolyzer/tools/validators.py @@ -0,0 +1,26 @@ +""" +This module contains validator functions for use with `attrs` class definitions. +""" + +def gt_zero(instance, attribute, value): + """Validates that an attribute's value is greater than zero.""" + if value <= 0: + raise ValueError(f"{attribute} must be greater than zero") + + +def range_val(min, max): + """Validates that an attribute's value is between two values, inclusive ([min, max]).""" + def validator(instance, attribute, value): + if value < min or value > max: + raise ValueError(f"{attribute} must be in range [{min}, {max}]") + + return validator + + +def contains(items): + """Validates that an item is part of a given list.""" + def validator(instance, attribute, value): + if value not in items: + raise ValueError(f"Item {value} not found in list for {attribute}: {items}") + + return validator \ No newline at end of file From 53f8c8a4cfcc55a19b60574fc60405cda1b490dd Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 14:11:56 -0700 Subject: [PATCH 13/31] added skeleton for cluster and cell classes --- electrolyzer/simulation/cell.py | 36 +++++++++++++++++++++++++++++- electrolyzer/simulation/cluster.py | 20 +++++++++++++++++ 2 files changed, 55 insertions(+), 1 deletion(-) diff --git a/electrolyzer/simulation/cell.py b/electrolyzer/simulation/cell.py index 75ccef0..efbfbdf 100644 --- a/electrolyzer/simulation/cell.py +++ b/electrolyzer/simulation/cell.py @@ -1 +1,35 @@ -# This will contain the baseclass for different types of cells \ No newline at end of file +# This will contain the baseclass for different types of cells +"""This module defines a Hydrogen Electrolyzer Cell.""" + +from typing import Union + +import numpy as np +import scipy +import pandas as pd +import rainflow +from attrs import field, define +from scipy.signal import tf2ss, cont2discrete + +from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin, array_converter +from electrolyzer.tools.validators import contains + +@define +class Cell(FromDictMixin): + + # n: int = 2 + + # Constants + #TODO: change to z_c + z: int = 2 # number of electrons transferred in reaction + F: float = 96485.34 # Faraday's Constant (C/mol) or [As/mol] + R: float = 8.314 # Ideal Gas Constant (J/mol/K) + + M_H: float = 1.00784 # molecular weight of Hydrogen [g/mol] + M_H2: float = 2.016 #[g/mol] + M_O: float = 15.999 # molecular weight of Oxygen [g/mol] + M_O2: float = 31.999 #[g/mol] + M_K: float = 39.0983 # molecular weight of Potassium [g/mol] + + lhv: float = 33.33 # lower heating value of H2 [kWh/kg] + hhv: float = 39.41 # higher heating value of H2 [kWh/kg] + gibbs: float = 237.24e3 # Gibbs Energy of global reaction (J/mol) \ No newline at end of file diff --git a/electrolyzer/simulation/cluster.py b/electrolyzer/simulation/cluster.py index e69de29..77a07ac 100644 --- a/electrolyzer/simulation/cluster.py +++ b/electrolyzer/simulation/cluster.py @@ -0,0 +1,20 @@ +"""This module defines a Hydrogen Electrolyzer Cluster.""" + +from typing import Union + +import numpy as np +import scipy +import pandas as pd +import rainflow +from attrs import field, define +from scipy.signal import tf2ss, cont2discrete + +from electrolyzer.simulation.stack import Stack +from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin, array_converter +from electrolyzer.tools.validators import contains + +@define +class Cluster(FromDictMixin): + stack_type: str = field() + + stack: Stack = field(init=False) \ No newline at end of file From 81e60a8d07464a710348c85b5c7f7b95889dd202 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 14:12:17 -0700 Subject: [PATCH 14/31] added generic base class --- electrolyzer/simulation/base.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 electrolyzer/simulation/base.py diff --git a/electrolyzer/simulation/base.py b/electrolyzer/simulation/base.py new file mode 100644 index 0000000..1d7a8cf --- /dev/null +++ b/electrolyzer/simulation/base.py @@ -0,0 +1,33 @@ +from abc import ABC, abstractmethod +from typing import Any, Dict, Final + +import attrs + +from electrolyzer.tools.type_dec import FromDictMixin + +class BaseClass(FromDictMixin): + """ + BaseClass object class. This class does the logging and MixIn class inheritance. + """ + + @classmethod + def get_model_defaults(cls) -> Dict[str, Any]: + """Produces a dictionary of the keyword arguments and their defaults. + + Returns + ------- + Dict[str, Any] + Dictionary of keyword argument: default. + """ + return {el.name: el.default for el in attrs.fields(cls)} + + def _get_model_dict(self) -> dict: + """Convenience method that wraps the `attrs.asdict` method. Returns the object's + parameters as a dictionary. + + Returns + ------- + dict + The provided or default, if no input provided, model settings as a dictionary. + """ + return attrs.asdict(self) \ No newline at end of file From 12d25a003a601bf5e00b4e26f8d337474eeb79cf Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 14:12:38 -0700 Subject: [PATCH 15/31] added example skeleton for simulation config --- electrolyzer/simulation/simulation_config.py | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 electrolyzer/simulation/simulation_config.py diff --git a/electrolyzer/simulation/simulation_config.py b/electrolyzer/simulation/simulation_config.py new file mode 100644 index 0000000..0f879eb --- /dev/null +++ b/electrolyzer/simulation/simulation_config.py @@ -0,0 +1,8 @@ +from attrs import define, field +from electrolyzer.simulation.base import BaseClass +from electrolyzer.tools.validators import contains +@define +class SimulationConfig(BaseClass): + feedback_type: str = field(validator=contains(["open-loop","closed-loop"])) + constant_temperature: bool = field(default = True) + \ No newline at end of file From 86b219c23081ca0a1392639463309e6508fbd7a0 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 14:12:58 -0700 Subject: [PATCH 16/31] added file for power-curve function templates --- electrolyzer/simulation/curve_equation_templates.py | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 electrolyzer/simulation/curve_equation_templates.py diff --git a/electrolyzer/simulation/curve_equation_templates.py b/electrolyzer/simulation/curve_equation_templates.py new file mode 100644 index 0000000..10df37f --- /dev/null +++ b/electrolyzer/simulation/curve_equation_templates.py @@ -0,0 +1,7 @@ + +def power_to_current_cubic_constant_temp(P_T,p1,p2,p3,p4,p5,p6): + #calculates i-v curve coefficients given the stack power and stack temp + pwr,tempc=P_T + # i_stack=p1*(pwr**2) + p2*(tempc**2)+ (p3*pwr*tempc) + (p4*pwr) + (p5*tempc) + (p6) + i_stack=p1*(pwr**3) + p2*(pwr**2) + (p3*pwr) + (p4*pwr**(1/2)) + p5 + return i_stack \ No newline at end of file From 43e4bf750ad48a759d1881bf77be32d1149547c1 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 14:43:25 -0700 Subject: [PATCH 17/31] updated inputs for Stack in test_stack --- tests/test_stack.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/test_stack.py b/tests/test_stack.py index ef6cf38..43f9e59 100644 --- a/tests/test_stack.py +++ b/tests/test_stack.py @@ -16,6 +16,7 @@ def create_stack(): "n_cells": 100, # "stack_rating_kW": 750, "degradation": { + "eol_eff_percent_loss": 10, "PEM_params": { "rate_steady": 1.41737929e-10, "rate_fatigue": 3.33330244e-07, @@ -66,6 +67,7 @@ def test_init(mocker): "n_cells": 100, "stack_rating_kW": 750, "degradation": { + "eol_eff_percent_loss": 10, "PEM_params": { "rate_steady": 1.41737929e-10, "rate_fatigue": 3.33330244e-07, @@ -468,6 +470,7 @@ def test_dt_behavior(): "n_cells": 100, # "stack_rating_kW": 750, "degradation": { + "eol_eff_percent_loss": 10, "PEM_params": { "rate_steady": 1.41737929e-10, "rate_fatigue": 3.33330244e-07, From a65c78d5bbe6e5fa7eb1369302eb65a302816870 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 14:54:43 -0700 Subject: [PATCH 18/31] added import to fix tests to stack.py --- electrolyzer/simulation/stack.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index a1c42ec..ea0aa79 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -13,6 +13,9 @@ from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin, array_converter from electrolyzer.simulation.cell_models.alkaline import AlkalineCell, ael_electrolyzer_model from electrolyzer.tools.validators import contains +from scipy.constants import R, physical_constants + +F, _, _ = physical_constants["Faraday constant"] # Faraday's constant [C/mol] @define class Stack(FromDictMixin): From 3b687ad03fdfa75814e96191b53212309d477eab Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 15:22:44 -0700 Subject: [PATCH 19/31] removed empty PEM cell test --- tests/test_PEM_cell.py | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 tests/test_PEM_cell.py diff --git a/tests/test_PEM_cell.py b/tests/test_PEM_cell.py deleted file mode 100644 index 53491bc..0000000 --- a/tests/test_PEM_cell.py +++ /dev/null @@ -1,13 +0,0 @@ -"""This module provides unit tests for `PEMCell`""" - -import pytest - -from electrolyzer.simulation.cell_models.pem import PEMCell as Cell - - -# from numpy.testing import assert_almost_equal - - -@pytest.fixture -def cell(): - return PEMCell.from_dict() From 35820185a9434afa3b83db617492eed3ebea990d Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Mon, 3 Feb 2025 15:24:56 -0700 Subject: [PATCH 20/31] renamed test_cell to test_PEM_cell --- tests/{test_cell.py => test_PEM_cell.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tests/{test_cell.py => test_PEM_cell.py} (100%) diff --git a/tests/test_cell.py b/tests/test_PEM_cell.py similarity index 100% rename from tests/test_cell.py rename to tests/test_PEM_cell.py From 2522fc0d0c4b17e9068fd66377ad5bf9c8e598ec Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 26 Feb 2025 11:52:57 -0700 Subject: [PATCH 21/31] updated validator format --- electrolyzer/tools/validators.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/electrolyzer/tools/validators.py b/electrolyzer/tools/validators.py index c9d6468..543bdd1 100644 --- a/electrolyzer/tools/validators.py +++ b/electrolyzer/tools/validators.py @@ -2,6 +2,7 @@ This module contains validator functions for use with `attrs` class definitions. """ + def gt_zero(instance, attribute, value): """Validates that an attribute's value is greater than zero.""" if value <= 0: @@ -9,7 +10,9 @@ def gt_zero(instance, attribute, value): def range_val(min, max): - """Validates that an attribute's value is between two values, inclusive ([min, max]).""" + """Validates that an attribute's value is between two values, + inclusive ([min, max]).""" + def validator(instance, attribute, value): if value < min or value > max: raise ValueError(f"{attribute} must be in range [{min}, {max}]") @@ -19,8 +22,9 @@ def validator(instance, attribute, value): def contains(items): """Validates that an item is part of a given list.""" + def validator(instance, attribute, value): if value not in items: raise ValueError(f"Item {value} not found in list for {attribute}: {items}") - return validator \ No newline at end of file + return validator From 47e09208fa3c7487293e3a4b48efda06df83062e Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 26 Feb 2025 13:53:02 -0700 Subject: [PATCH 22/31] removed files unrelated to primary feature-adds --- electrolyzer/simulation/base.py | 9 +++--- electrolyzer/simulation/cell.py | 28 ------------------- electrolyzer/simulation/cluster.py | 20 ------------- .../simulation/curve_equation_templates.py | 7 ----- electrolyzer/simulation/simulation_config.py | 8 ------ 5 files changed, 5 insertions(+), 67 deletions(-) delete mode 100644 electrolyzer/simulation/cell.py delete mode 100644 electrolyzer/simulation/cluster.py delete mode 100644 electrolyzer/simulation/curve_equation_templates.py delete mode 100644 electrolyzer/simulation/simulation_config.py diff --git a/electrolyzer/simulation/base.py b/electrolyzer/simulation/base.py index 1d7a8cf..e40daa8 100644 --- a/electrolyzer/simulation/base.py +++ b/electrolyzer/simulation/base.py @@ -1,10 +1,10 @@ -from abc import ABC, abstractmethod -from typing import Any, Dict, Final +from typing import Any, Dict import attrs from electrolyzer.tools.type_dec import FromDictMixin + class BaseClass(FromDictMixin): """ BaseClass object class. This class does the logging and MixIn class inheritance. @@ -28,6 +28,7 @@ def _get_model_dict(self) -> dict: Returns ------- dict - The provided or default, if no input provided, model settings as a dictionary. + The provided or default, if no input provided, + model settings as a dictionary. """ - return attrs.asdict(self) \ No newline at end of file + return attrs.asdict(self) diff --git a/electrolyzer/simulation/cell.py b/electrolyzer/simulation/cell.py deleted file mode 100644 index ee300dc..0000000 --- a/electrolyzer/simulation/cell.py +++ /dev/null @@ -1,28 +0,0 @@ -# This will contain the baseclass for different types of cells -"""This module defines a Hydrogen Electrolyzer Cell.""" - -from attrs import define - -from electrolyzer.tools.type_dec import FromDictMixin - - -@define -class Cell(FromDictMixin): - - # n: int = 2 - - # Constants - # TODO: change to z_c - z: int = 2 # number of electrons transferred in reaction - F: float = 96485.34 # Faraday's Constant (C/mol) or [As/mol] - R: float = 8.314 # Ideal Gas Constant (J/mol/K) - - M_H: float = 1.00784 # molecular weight of Hydrogen [g/mol] - M_H2: float = 2.016 # [g/mol] - M_O: float = 15.999 # molecular weight of Oxygen [g/mol] - M_O2: float = 31.999 # [g/mol] - M_K: float = 39.0983 # molecular weight of Potassium [g/mol] - - lhv: float = 33.33 # lower heating value of H2 [kWh/kg] - hhv: float = 39.41 # higher heating value of H2 [kWh/kg] - gibbs: float = 237.24e3 # Gibbs Energy of global reaction (J/mol) diff --git a/electrolyzer/simulation/cluster.py b/electrolyzer/simulation/cluster.py deleted file mode 100644 index 77a07ac..0000000 --- a/electrolyzer/simulation/cluster.py +++ /dev/null @@ -1,20 +0,0 @@ -"""This module defines a Hydrogen Electrolyzer Cluster.""" - -from typing import Union - -import numpy as np -import scipy -import pandas as pd -import rainflow -from attrs import field, define -from scipy.signal import tf2ss, cont2discrete - -from electrolyzer.simulation.stack import Stack -from electrolyzer.tools.type_dec import NDArrayFloat, FromDictMixin, array_converter -from electrolyzer.tools.validators import contains - -@define -class Cluster(FromDictMixin): - stack_type: str = field() - - stack: Stack = field(init=False) \ No newline at end of file diff --git a/electrolyzer/simulation/curve_equation_templates.py b/electrolyzer/simulation/curve_equation_templates.py deleted file mode 100644 index 10df37f..0000000 --- a/electrolyzer/simulation/curve_equation_templates.py +++ /dev/null @@ -1,7 +0,0 @@ - -def power_to_current_cubic_constant_temp(P_T,p1,p2,p3,p4,p5,p6): - #calculates i-v curve coefficients given the stack power and stack temp - pwr,tempc=P_T - # i_stack=p1*(pwr**2) + p2*(tempc**2)+ (p3*pwr*tempc) + (p4*pwr) + (p5*tempc) + (p6) - i_stack=p1*(pwr**3) + p2*(pwr**2) + (p3*pwr) + (p4*pwr**(1/2)) + p5 - return i_stack \ No newline at end of file diff --git a/electrolyzer/simulation/simulation_config.py b/electrolyzer/simulation/simulation_config.py deleted file mode 100644 index 0f879eb..0000000 --- a/electrolyzer/simulation/simulation_config.py +++ /dev/null @@ -1,8 +0,0 @@ -from attrs import define, field -from electrolyzer.simulation.base import BaseClass -from electrolyzer.tools.validators import contains -@define -class SimulationConfig(BaseClass): - feedback_type: str = field(validator=contains(["open-loop","closed-loop"])) - constant_temperature: bool = field(default = True) - \ No newline at end of file From c30b051c57c92624b92ca926307510a70311aa00 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 26 Feb 2025 13:57:26 -0700 Subject: [PATCH 23/31] reformatted bert.py --- electrolyzer/simulation/bert.py | 55 +++++++++++++++++++++++++++------ 1 file changed, 45 insertions(+), 10 deletions(-) diff --git a/electrolyzer/simulation/bert.py b/electrolyzer/simulation/bert.py index 0e3daa4..5bfbc88 100644 --- a/electrolyzer/simulation/bert.py +++ b/electrolyzer/simulation/bert.py @@ -71,7 +71,7 @@ def _run_electrolyzer_full(modeling_options, power_signal): } ) stack_dfs.append(stack_df) - + results_df = pd.concat([results_df, *stack_dfs], axis=1) return elec_sys, results_df @@ -104,21 +104,56 @@ def _run_electrolyzer_opt(modeling_options, power_signal): return tot_kg, max_curr_density -def run_LCA(elec_sys, plant_life_years:int): + +def run_LCA(elec_sys, plant_life_years: int): sys_refurb = pd.DataFrame() sys_aep = pd.DataFrame() sys_ah2 = pd.DataFrame() - years = list(np.arange(0,plant_life_years,1)) + years = list(np.arange(0, plant_life_years, 1)) for i, stack in enumerate(elec_sys.stacks): id = i + 1 - refturb_schedule,ahp_kg,aep_kWh = stack.estimate_life_performance_from_year(plant_life_years) - sys_refurb = pd.concat([sys_aep,pd.DataFrame(dict(zip(["Stack {}".format(id)],[aep_kWh])),index=years)]) - sys_ah2 = pd.concat([sys_ah2,pd.DataFrame(dict(zip(["Stack {}".format(id)],[ahp_kg])),index=years)]) - sys_refurb = pd.concat([sys_refurb,pd.DataFrame(dict(zip(["Stack {}".format(id)],[refturb_schedule])),index=years)]) - # df_index = [[f"stack {id}"]*plant_life_years,list(np.arange(0,plant_life_years,1))] - # temp_df = pd.DataFrame(dict(zip(["AEP [kWh/year]","Refurb Schedule","AHP [kg/year]"],[aep_kWh,ahp_kg,refturb_schedule])),index=df_index) + refturb_schedule, ahp_kg, aep_kWh = stack.estimate_life_performance_from_year( + plant_life_years + ) + sys_refurb = pd.concat( + [ + sys_aep, + pd.DataFrame( + dict(zip(["Stack {}".format(id)], [aep_kWh])), index=years + ), + ] + ) + sys_ah2 = pd.concat( + [ + sys_ah2, + pd.DataFrame(dict(zip(["Stack {}".format(id)], [ahp_kg])), index=years), + ] + ) + sys_refurb = pd.concat( + [ + sys_refurb, + pd.DataFrame( + dict(zip(["Stack {}".format(id)], [refturb_schedule])), index=years + ), + ] + ) + # df_index = [ + # [f"stack {id}"]*plant_life_years, + # list(np.arange(0,plant_life_years,1)) + # ] + # temp_df = pd.DataFrame(dict(zip( + # ["AEP [kWh/year]","Refurb Schedule","AHP [kg/year]"], + # [aep_kWh,ahp_kg,refturb_schedule])), + # index=df_index + # ) # stack_LCA = pd.concat([stack_LCA,temp_df]) - return {"Refurb Schedule":sys_refurb,"AEP [kWh/year]":sys_aep,"AHP [kg/year]":sys_ah2} + return { + "Refurb Schedule": sys_refurb, + "AEP [kWh/year]": sys_aep, + "AHP [kg/year]": sys_ah2, + } + + def run_electrolyzer(input_modeling, power_signal, optimize=False): """ Runs an electrolyzer simulation based on a YAML configuration file and power From 6216c448abd0bd1f103d64122028d1f43142af3a Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 26 Feb 2025 14:29:19 -0700 Subject: [PATCH 24/31] added back-in placeholder files --- electrolyzer/simulation/cell_models/cell.py | 1 + electrolyzer/simulation/cluster.py | 1 + 2 files changed, 2 insertions(+) create mode 100644 electrolyzer/simulation/cell_models/cell.py create mode 100644 electrolyzer/simulation/cluster.py diff --git a/electrolyzer/simulation/cell_models/cell.py b/electrolyzer/simulation/cell_models/cell.py new file mode 100644 index 0000000..9c5f7ad --- /dev/null +++ b/electrolyzer/simulation/cell_models/cell.py @@ -0,0 +1 @@ +# this file will contain a cell base-class diff --git a/electrolyzer/simulation/cluster.py b/electrolyzer/simulation/cluster.py new file mode 100644 index 0000000..fcfd460 --- /dev/null +++ b/electrolyzer/simulation/cluster.py @@ -0,0 +1 @@ +# this file will contain the cluster class From 4aa70197c873e84cd1ca9efc18ee9d73a214d616 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 26 Feb 2025 15:09:39 -0700 Subject: [PATCH 25/31] removed alkaline sources in alkaline model into md file --- docs/alkaline_ref.md | 73 +++++++++++++++++ .../simulation/cell_models/alkaline.py | 78 ------------------- 2 files changed, 73 insertions(+), 78 deletions(-) create mode 100644 docs/alkaline_ref.md diff --git a/docs/alkaline_ref.md b/docs/alkaline_ref.md new file mode 100644 index 0000000..bd81ed2 --- /dev/null +++ b/docs/alkaline_ref.md @@ -0,0 +1,73 @@ +1. [Oystein Ulleberg, 2003](https://www.sciencedirect.com/science/article/pii/S0360319902000332?via%3Dihub) + "Modeling of advanced alkaline electrolyzers: a system simulation approach" + + +2. [Gambou, Guilbert,et al 2022](https://www.mdpi.com/1996-1073/15/9/3452) + "A Comprehensive Survey of Alkaline Eelctrolyzer Modeling: Electrical + Domain and Specific Electrolyte Conductivity" + + +3. [Haug ,Kreitz, 2017](https://www.sciencedirect.com/science/article/pii/S0360319917318633) + "Process modelling of an alkaline water electrolyzer" + + +4. [Henou, Agbossou, 2014](https://www.sciencedirect.com/science/article/pii/S0378775313017527) + - "Simulation tool based on a physics model and an electrical + analogy for an alkaline electrolyser" + - Notes: + - cited by [Gambou, Guilbert,et al 2022] + - HAS ALL THE VALUES FOR VARIABLES USED IN [Gambou, Guilbert,et al 2022] + +5. [Hammoudi,Henao, 2012](https://www.sciencedirect.com/science/article/pii/S036031991201590X) + - "New multi-physics approach for modelling andn design of + alkaline electrolyzers" + - Notes: + - Referenced by [Henou, Agbossou, 2014] for theta calculation + (electrode coverage) + - Eqn 44 for bubble stuff + - j_lim=300 kA/m^2 + - includes other efficiency losses + - cites: https://www.sciencedirect.com/science/article/pii/S0360128509000598 + +6. [Brauns,2021](https://iopscience.iop.org/article/10.1149/1945-7111/abda57/pdf) + - bibtex label: + - "Evaluation of Diaphragms and Membranes as Separators for Alkaline Water Electrolysis" by Jorn Brauns et all 2021. J. Electrochem Soc 168 014510 + - Notes: + - good numbers + - electrolyte flow rate of 350 mL/min + - total electrolyte volume of 10L + - has supplementary material (need to checkout) + - in "material stability" it mentions stuff about DEGRADATION + +7. [NEL Report](https://www.energy.gov/sites/default/files/2022-02/2-Intro-Liquid%20Alkaline%20Workshop.pdf) + - bibtex label: + + +8. [Brauns, Turek 2020](https://www.mdpi.com/2227-9717/8/2/248) + - bibtex label: + - "Alkaline Water Electrolysis Powered by Renewable Energy: A Review" + + +9. [Eigeldinger, Vogt 2000](https://www.sciencedirect.com/science/article/pii/S0013468600005132) + - bibtex label: Eigeldinger_2000 + - "The bubble coverage of gas evolving electrodes in a flowing electrolyte" + - Notes: + - Ref 15 of Henou 2014 for current density and theta stuff + - has current density equation with theta included + +10. [Haug, Koj, Turek 2017](https://www.sciencedirect.com/science/article/pii/S0360319916336588) +"Influence of process conditions on gas purity in alkaline water electrolysis" +by Phillip Haug, Motthias Koj, Thomas Turek [2017] + + +11. [Niroula, Chaudhary, Subedi, Thapa 2003](https://iopscience.iop.org/article/10.1088/1757-899X/1279/1/012005/pdf) + + "Parametric Modelling and Optimization of Alkaline Electrolyzer for the Production + of Green Hydrogen" by S. Niroula, C Chaudhary, A Subedi, and B S Thapa + [2003] doi:10.1088/1757-899X/1279/1/012005 + + +12. [Vogt,Balzer 2005](https://www.sciencedirect.com/science/article/pii/S001346860400948X?via%3Dihub) +"The bubble coverage of gas-evolving elecrodes in stagnant electrolytes" +by H. Vogt and R.J. Balzer +Volume 50, Issue 10, 15 March 2005, Pages 2073-2079 diff --git a/electrolyzer/simulation/cell_models/alkaline.py b/electrolyzer/simulation/cell_models/alkaline.py index fbec39f..a5a05e7 100644 --- a/electrolyzer/simulation/cell_models/alkaline.py +++ b/electrolyzer/simulation/cell_models/alkaline.py @@ -18,84 +18,6 @@ warnings.filterwarnings("ignore") -""" -[Oystein Ulleberg, 2003] - "Modeling of advanced alkaline electrolyzers: a system simulation approach" - https://www.sciencedirect.com/science/article/pii/S0360319902000332?via%3Dihub - -[Gambou, Guilbert,et al 2022] - "A Comprehensive Survey of Alkaline Eelctrolyzer Modeling: Electrical - Domain and Specific Electrolyte Conductivity" - https://www.mdpi.com/1996-1073/15/9/3452 - -[Haug,Kreitz, 2017] - "Process modelling of an alkaline water electrolyzer" - https://www.sciencedirect.com/science/article/pii/S0360319917318633 - -[Henou, Agbossou, 2014] - "Simulation tool based on a physics model and an electrical - analogy for an alkaline electrolyser" - https://www.sciencedirect.com/science/article/pii/S0378775313017527 - ->cited by [Gambou, Guilbert,et al 2022] - -> HAS ALL THE VALUES FOR VARIABLES USED IN [Gambou, Guilbert,et al 2022] - -[Hammoudi,Henao, 2012] - "New multi-physics approach for modelling andn design of - alkaline electrolyzers" - https://www.sciencedirect.com/science/article/pii/S036031991201590X - -> Referenced by [Henou, Agbossou, 2014] for theta calculation - (electrode coverage) - ->Eqn 44 for bubble stuff - ->j_lim=300 kA/m^2 - ->includes other efficiency losses - cites: - https://www.sciencedirect.com/science/article/pii/S0360128509000598 - -[Brauns,2021] -"Evaluation of Diaphragms and Membranes as Separators for Alkaline -Water Electrolysis" - by Jorn Brauns et all 2021. J. Electrochem Soc 168 014510 - https://iopscience.iop.org/article/10.1149/1945-7111/abda57/pdf - ->good numbers - ->electrolyte flow rate of 350 mL/min - ->total electrolyte volume of 10L - -> has supplementary material (need to checkout) - ->in "material stability" it mentions stuff about DEGRADATION - -NEL Report: -https://www.energy.gov/sites/default/files/2022-02/2-Intro-Liquid%20Alkaline%20Workshop.pdf - -[Brauns, Turek 2020] -"Alkaline Water Electrolysis Powered by Renewable Energy: A Review" - https://www.mdpi.com/2227-9717/8/2/248 - - -[Eigeldinger, Vogt 2000] -"The bubble coverage of gas evolving electrodes in a flowing electrolyte" -https://www.sciencedirect.com/science/article/pii/S0013468600005132 - -> Ref 15 of Henou 2014 for current density and theta stuff - -> has current density equation with theta included - -[Haug, Koj, Turek 2017] -"Influence of process conditions on gas purity in alkaline water electrolysis" -by Phillip Haug, Motthias Koj, Thomas Turek [2017] -https://www.sciencedirect.com/science/article/pii/S0360319916336588 - -[Niroula, Chaudhary, Subedi, Thapa 2003] -"Parametric Modelling and Optimization of Alkaline Electrolyzer for the Production -of Green Hydrogen" by S. Niroula, C Chaudhary, A Subedi, and B S Thapa -[2003] doi:10.1088/1757-899X/1279/1/012005 -https://iopscience.iop.org/article/10.1088/1757-899X/1279/1/012005/pdf - -[Vogt,Balzer 2005] -"The bubble coverage of gas-evolving elecrodes in stagnant electrolytes" -by H. Vogt and R.J. Balzer -Volume 50, Issue 10, 15 March 2005, Pages 2073-2079 -https://www.sciencedirect.com/science/article/pii/S001346860400948X?via%3Dihub - - - -""" def ael_electrolyzer_model(X, a, b, c, d, e, f): From b6a5c57f3d93a8b3272a3c6593d36bf8bf4726c5 Mon Sep 17 00:00:00 2001 From: John Jasa Date: Tue, 2 Sep 2025 18:15:39 -0600 Subject: [PATCH 26/31] Typographical changes --- docs/alkaline_ref.md | 4 ++-- electrolyzer/simulation/stack.py | 8 +++++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/docs/alkaline_ref.md b/docs/alkaline_ref.md index bd81ed2..e7904f1 100644 --- a/docs/alkaline_ref.md +++ b/docs/alkaline_ref.md @@ -3,7 +3,7 @@ 2. [Gambou, Guilbert,et al 2022](https://www.mdpi.com/1996-1073/15/9/3452) - "A Comprehensive Survey of Alkaline Eelctrolyzer Modeling: Electrical + "A Comprehensive Survey of Alkaline Electrolyzer Modeling: Electrical Domain and Specific Electrolyte Conductivity" @@ -68,6 +68,6 @@ by Phillip Haug, Motthias Koj, Thomas Turek [2017] 12. [Vogt,Balzer 2005](https://www.sciencedirect.com/science/article/pii/S001346860400948X?via%3Dihub) -"The bubble coverage of gas-evolving elecrodes in stagnant electrolytes" +"The bubble coverage of gas-evolving electrodes in stagnant electrolytes" by H. Vogt and R.J. Balzer Volume 50, Issue 10, 15 March 2005, Pages 2073-2079 diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index eb6f033..bb907ae 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -577,7 +577,7 @@ def estimate_stack_life(self): return stack_life def estimate_life_performance_from_year(self, plant_life_years: int): - refturb_schedule = np.zeros(plant_life_years) + refurb_schedule = np.zeros(plant_life_years) ahp_kg = np.zeros(plant_life_years) aep_kWh = np.zeros(plant_life_years) @@ -593,7 +593,8 @@ def estimate_life_performance_from_year(self, plant_life_years: int): V_deg_pr_sim = np.concatenate( [V_deg_pr_sim[0:idx_dead], V_deg[idx_dead:sim_length]] ) - refturb_schedule[i] = 1 + refurb_schedule[i] = 1 + if self.hydrogen_degradation_penalty: I_nom = self.electrolyzer_model( (self.power_input_history / 1e3, self.temperature), *self.fit_params @@ -617,4 +618,5 @@ def estimate_life_performance_from_year(self, plant_life_years: int): ahp_kg[i] = np.sum(H2_mass_out) aep_kWh[i] = np.sum(power_usage_kW) Vdeg0 = V_deg_pr_sim[sim_length - 1] - return refturb_schedule, ahp_kg, aep_kWh + + return refurb_schedule, ahp_kg, aep_kWh From 348e559debc6eca2be88a53201280d038ca66220 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 3 Sep 2025 11:45:05 -0600 Subject: [PATCH 27/31] minor cleanups to alkaline cell and stack --- electrolyzer/simulation/cell_models/alkaline.py | 14 ++------------ electrolyzer/simulation/stack.py | 11 +---------- 2 files changed, 3 insertions(+), 22 deletions(-) diff --git a/electrolyzer/simulation/cell_models/alkaline.py b/electrolyzer/simulation/cell_models/alkaline.py index a5a05e7..146aa03 100644 --- a/electrolyzer/simulation/cell_models/alkaline.py +++ b/electrolyzer/simulation/cell_models/alkaline.py @@ -51,15 +51,14 @@ class AlkalineCell(FromDictMixin): turndown_ratio: float max_current_density: float - f_1: float - f_2: float + f_1: float # faradaic coefficient + f_2: float # faradaic coefficient # cell_area: float = field(init=False) cell_area: float = field(init=False) # Electrode parameters # #################### - # A_electrode: float = field(init=False) # [cm^2] e_a: float = field(init=False) # [cm] anode thickness e_c: float = field(init=False) # [cm] cathode thickness d_am: float = field(init=False) # [cm] Anode-membrane gap @@ -77,7 +76,6 @@ class AlkalineCell(FromDictMixin): # Membrane parameters # #################### - # A_membrane: float = field(init=False) # [cm^2] e_m: float = field(init=False) # [cm] membrane thickness # THIS ONE IS PRIMARLY BASED ON @@ -101,15 +99,9 @@ def __attrs_post_init__(self) -> None: # Electrode parameters # ######################## - # self.A_electrode = self.electrode["A_electrode"] - # self.e_a = self.electrode["e_a"] - # self.e_c = self.electrode["e_c"] self.e_a = self.electrode["e_e"] self.e_c = self.electrode["e_e"] - # self.d_am = self.electrode["d_am"] - # self.d_cm = self.electrode["d_cm"] - self.d_am = self.electrode["d_em"] self.d_cm = self.electrode["d_em"] self.d_ac = self.electrode["d_ac"] @@ -120,7 +112,6 @@ def __attrs_post_init__(self) -> None: # Membrane parameters # ####################### - # self.A_membrane = self.membrane["A_membrane"] self.e_m = self.membrane["e_m"] # calcluate molarity and molality of KOH solution @@ -147,7 +138,6 @@ def calculate_bubble_rate_coverage(self, T_C, I): T_k = convert_temperature([T_C], "C", "K")[0] J_lim = 30 # [A/cm^2] [Vogt,Balzer 2005] T_amb = T_k = convert_temperature([25], "C", "K")[0] - # j = I / self.A_electrode # [A/cm^2] "nominal current density" j = I / self.cell_area # [A/cm^2] "nominal current density" # Eqn 19 of [Gambou, Guilbert,et al 2022] diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index eb6f033..3301867 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -213,8 +213,6 @@ def __attrs_post_init__(self) -> None: ] ) - # self.h2_pres_out = 31 # H2 outlet pressure (bar) - self.DTSS = self.calc_state_space() self.d_eol = self.calc_end_of_life_voltage() @@ -239,9 +237,7 @@ def run_h2_deg_penalty(self, P_in): (P_in / 1e3, self.temperature), *self.fit_params ) V_cell = self.cell.calc_cell_voltage(I_nom, self.temperature) - eff_mult = np.nan_to_num( - (V_cell + self.V_degradation) / V_cell - ) # 1 + efficiency drop + eff_mult = np.nan_to_num((V_cell + self.V_degradation) / V_cell) I_stack = np.nan_to_num(I_nom / eff_mult) return I_stack, V_cell @@ -265,10 +261,6 @@ def run_stack(self, I_stack, V_cell, P_in): return :: H2_mass_out [kg]: hydrogen mass return :: power_left [W]: difference in P_in and power consumed """ - # self.update_status() - - # I = self.electrolyzer_model((P_in / 1e3, self.temperature), *self.fit_params) - # V = self.cell.calc_cell_voltage(I, self.temperature) if self.stack_on: power_left = P_in @@ -487,7 +479,6 @@ def turn_stack_off(self): self.stack_on = False self.stack_waiting = False self.cycle_count += 1 - # self.stack_state = 0 # adjust waiting period self.wait_time = np.max( From a39b015bf9dd47b16f5c9c4f494aee9ec8a7bc4e Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 3 Sep 2025 12:18:00 -0600 Subject: [PATCH 28/31] removed commented out code and added docstrings --- .../simulation/cell_models/alkaline.py | 67 +++------------ electrolyzer/simulation/stack.py | 81 ++++++++++++++++--- electrolyzer/tools/modeling_schema.yaml | 32 +------- 3 files changed, 81 insertions(+), 99 deletions(-) diff --git a/electrolyzer/simulation/cell_models/alkaline.py b/electrolyzer/simulation/cell_models/alkaline.py index 146aa03..1825446 100644 --- a/electrolyzer/simulation/cell_models/alkaline.py +++ b/electrolyzer/simulation/cell_models/alkaline.py @@ -15,6 +15,7 @@ from scipy.constants import R, physical_constants, convert_temperature from electrolyzer.tools.type_dec import FromDictMixin +from electrolyzer.tools.validators import range_val warnings.filterwarnings("ignore") @@ -51,11 +52,10 @@ class AlkalineCell(FromDictMixin): turndown_ratio: float max_current_density: float - f_1: float # faradaic coefficient - f_2: float # faradaic coefficient + f_1: float # faradaic coefficient in mA^2/cm^4 + f_2: float = field(validator=range_val(0, 1)) # faradaic coefficient [unitless] - # cell_area: float = field(init=False) - cell_area: float = field(init=False) + cell_area: float = field(init=False) # cell area in cm^2 # Electrode parameters # #################### @@ -99,12 +99,12 @@ def __attrs_post_init__(self) -> None: # Electrode parameters # ######################## - self.e_a = self.electrode["e_e"] - self.e_c = self.electrode["e_e"] + self.e_a = self.electrode["e_e"] # anode thickness + self.e_c = self.electrode["e_e"] # cathode thickness - self.d_am = self.electrode["d_em"] - self.d_cm = self.electrode["d_em"] - self.d_ac = self.electrode["d_ac"] + self.d_am = self.electrode["d_em"] # anode-membrane distance + self.d_cm = self.electrode["d_em"] # cathode-membrane distance + self.d_ac = self.electrode["d_ac"] # distance between electrodes # Electrolyte parameters # ########################## @@ -376,22 +376,12 @@ def calc_electrode_resistance(self, T_C): # Eqn 21 - effective resistance of electrode rho_nickle_eff = rho_nickle_0 / ((1 - epsilon_Ni) ** 1.5) # Eqn 20 - resistivity of anode - # Ra = ( - # rho_nickle_eff - # * (self.e_a / self.A_electrode) - # * (1 + (temp_coeff * (T_C - tref))) - # ) Ra = ( rho_nickle_eff * (self.e_a / self.cell_area) * (1 + (temp_coeff * (T_C - tref))) ) # Eqn 20 - resistivity of cathode - # Rc = ( - # rho_nickle_eff - # * (self.e_c / self.A_electrode) - # * (1 + (temp_coeff * (T_C - tref))) - # ) Rc = ( rho_nickle_eff * (self.e_c / self.cell_area) @@ -440,10 +430,6 @@ def calc_electrolyte_resistance(self, T_C, I): # R_ele_bf: Bubble-free electrolyte resistance # Eqn 32 of [Gambou, Guilbert,et al 2022] and Eqn 19 of [Henou, Agbossou, 2014] - - # R_ele_bf = (100 / sigma_bf) * ( - # (self.d_am / self.A_electrode) + (self.d_cm / self.A_electrode) - # ) R_ele_bf = (100 / sigma_bf) * ( (self.d_am / self.cell_area) + (self.d_cm / self.cell_area) ) @@ -453,7 +439,6 @@ def calc_electrolyte_resistance(self, T_C, I): # Resistance due to bubbles theta_epsilon = self.calculate_bubble_rate_coverage(T_C, I) epsilon = theta_epsilon[1] - # R_ele_b=R_ele_bf*((1/(1-epsilon)**(3/2))-1) # R_ele_b: Bubble resistance R_ele_b = R_ele_bf * ((1 / ((1 - epsilon) ** (3 / 2))) - 1) # ^Bruggman equation @@ -470,7 +455,7 @@ def calc_membrane_resistance(self, T_C): Reference: [Gambou, Guilbert,et al 2022]: Eqn 36 [Henou, Agbossou, 2014]: Eqn 21 - [NEL]: TODO add slide + [NEL]: TODO add reference to slide """ # NOTE: THIS HAS BEEN VERIFIED @@ -479,9 +464,7 @@ def calc_membrane_resistance(self, T_C): # [Gambou, Guilbert,et al 2022] # S_mem=54.48 # membrane surface area in cm^2 - # Rmem = (0.06 + 80 * np.exp(T_C / 50)) / ( - # 10000 * self.A_membrane - # ) # Equation 36 - Ohms + # Equation 36 - Ohms Rmem = (0.06 + 80 * np.exp(T_C / 50)) / ( 10000 * self.cell_area ) # Equation 36 - Ohms @@ -543,31 +526,6 @@ def calc_reversible_voltage(self): """ return self.gibbs / (self.z * F) - # def calc_open_circuit_voltage(self, T_C): - # """ - # I [A]: current - # T_C [C]: temperature - # return :: E_rev0 [V/cell]: open-circuit voltage - - # TODO: Are we correcting for temperature twice? U_rev0 should be just 1.229 and - # never change (possibly?) - - # Reference: [Gambou, Guilbert,et al 2022]: Eqn 14 - # """ - # # General Nerst Equation - # # Eqn 14 of [Gambou, Guilbert,et al 2022] - # T_K = convert_temperature([T_C], "C", "K")[0] - # E_rev0 = ( - # 1.5184 - # - (1.5421 * (10 ** (-3)) * T_K) - # + (9.523 * (10 ** (-5)) * T_K * np.log(T_K)) - # + (9.84 * (10 ** (-8)) * (T_K**2)) - # ) - # # OR should this just be 1.229? - # # E_rev_fake = 1.229 - - # return E_rev0 - def calc_faradaic_efficiency(self, T_C, I): """ I [A]: current @@ -602,10 +560,9 @@ def calc_mass_flow_rate(self, T_C, I): eta_F = self.calc_faradaic_efficiency(T_C, I) # Eqn 10 [mol/sec] - h2_prod_mol = eta_F * I / (self.z * F) + h2_prod_mol = eta_F * I / (self.z * F) # mol/s mfr = self.M_H * self.z * h2_prod_mol # [g/sec] # z is valency number of electrons transferred per ion # for oxygen, z=4 mfr = mfr / 1e3 # [kg/sec] return mfr - # h2_prod is in mol/s diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index 3301867..0b7a873 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -463,6 +463,9 @@ def calc_state_space(self): return [ss_d[0], ss_d[1], ss_d[2], ss_d[3]] def update_status(self): + """Update the stack status if the stack is waiting. If the stack is waiting + and has waited long enough to be on, this method updates the stack status to on. + """ # Change the stack to be truly on if it has waited long enough if self.stack_on: return @@ -473,6 +476,9 @@ def update_status(self): self.stack_on = True def turn_stack_off(self): + """Turn the stack off if the stack is on or watiting. + Updates the cycle count, waiting period, turn off time, and stack status. + """ if self.stack_on or self.stack_waiting: # record turn off time to adjust waiting period self.turn_off_time = self.time @@ -506,9 +512,11 @@ def turn_stack_on(self): def calc_stack_power(self, Idc, V=None): """ Args: - Idc [A]: stack current - V (optional): stack voltage - return :: Pdc [kW]: stack power + Idc (float): stack current in Amps + V (float, optional): stack voltage + + Returns: + float: ``Pdc`` [kW] stack power """ V = V or (self.cell.calc_cell_voltage(Idc, self.temperature)) Pdc = Idc * V * self.n_cells @@ -517,10 +525,18 @@ def calc_stack_power(self, Idc, V=None): return Pdc def calc_electrolysis_efficiency(self, Pdc, mfr): - """ - Pdc [kW]: stack power - mfr [kg/h]: mass flow rate - return :: eta_kWh_per_kg, eta_hhv_percent, and eta_lhv_percent: efficiencies + """Calculate the efficiency of the stack in kWh/kg, %-HHV and %-LHV. + + Args: + Pdc (float): stack power in kW + mfr (float): mass flow rate of hydrogen in kg/hr + + Returns: + 3-element tuple containing + + - **eta_kWh_per_kg**: efficiency in kWh/kg + - **eta_hhv_percent**: efficiency as %-HHV + - **eta_lhv_percent**: efficiency as %-LHV """ eta_kWh_per_kg = Pdc / mfr eta_hhv_percent = self.cell.hhv / eta_kWh_per_kg * 100.0 @@ -529,10 +545,14 @@ def calc_electrolysis_efficiency(self, Pdc, mfr): return (eta_kWh_per_kg, eta_hhv_percent, eta_lhv_percent) def calc_end_of_life_voltage(self): + """Calculate the end-of-life cell degradation voltage based on the + ``eol_eff_percent_loss`` parameter. + + Returns: + d_eol (float): cell degradation in Volts that indicates end-of-life. """ - eol_eff_percent_loss [%]: efficiency drop that indicates end-of-life - (between 1 and 100) - """ + + # efficiency drop that indicates end-of-life as a percentage eol_eff_mult = (100 + self.eol_eff_percent_loss) / 100 V_cell_bol = self.cell.calc_cell_voltage(self.max_current, self.temperature) H2_mfr_bol = ( @@ -555,6 +575,14 @@ def calc_end_of_life_voltage(self): return d_eol def estimate_time_until_replacement(self): + """Estimate the time until replacement based on fraction of life used, + which is the ratio of the stack degradation to the end of life degradation. + + Returns: + float: Number of hours until stack should be replaced with respect to + simulation duration (alternatively, with respect to the number of + hours the stack has existed in the plant.) + """ frac_of_life_used = self.V_degradation / self.d_eol # time between replacement [hrs] based on time its existed (whether on or off) @@ -562,13 +590,40 @@ def estimate_time_until_replacement(self): return time_between_replacement def estimate_stack_life(self): + """Estimate the stack life based on fraction of life used, which is the ratio + of the stack degradation to the end of life degradation. + + Returns: + float: Stack life in hours with respect to number of hours the stack has + been operational. + """ # stack life [hrs] based on time its been operational frac_of_life_used = self.V_degradation / self.d_eol stack_life = (1 / frac_of_life_used) * (self.uptime / 3600) # [hrs] return stack_life def estimate_life_performance_from_year(self, plant_life_years: int): - refturb_schedule = np.zeros(plant_life_years) + """Estimate future performance of the stack assuming the + same operation from the simulation for the duration of the plant life. + + Note: + This function is not tested and may only work for simulations + with an hourly timestep and a simulation length of 8760 hours. + + Args: + plant_life_years (int): number of years in the plant life. + + Returns: + 3-element tuple containing + + - **refurb_schedule** (list): refurbishment schedule of the stack, + a value of 1 represents a year that the stack has to be replaced. + - **ahp_kg** (list): annual hydrogen production of the stack per year + of the ``plant_life_years``. Each element has units of kg-H2/year + - **aep_kWh** (list): annual energy consumption of the stack per year + of the ``plant_life_years``. Each element has units of kWh/year. + """ + refurb_schedule = np.zeros(plant_life_years) ahp_kg = np.zeros(plant_life_years) aep_kWh = np.zeros(plant_life_years) @@ -584,7 +639,7 @@ def estimate_life_performance_from_year(self, plant_life_years: int): V_deg_pr_sim = np.concatenate( [V_deg_pr_sim[0:idx_dead], V_deg[idx_dead:sim_length]] ) - refturb_schedule[i] = 1 + refurb_schedule[i] = 1 if self.hydrogen_degradation_penalty: I_nom = self.electrolyzer_model( (self.power_input_history / 1e3, self.temperature), *self.fit_params @@ -608,4 +663,4 @@ def estimate_life_performance_from_year(self, plant_life_years: int): ahp_kg[i] = np.sum(H2_mass_out) aep_kWh[i] = np.sum(power_usage_kW) Vdeg0 = V_deg_pr_sim[sim_length - 1] - return refturb_schedule, ahp_kg, aep_kWh + return refurb_schedule, ahp_kg, aep_kWh diff --git a/electrolyzer/tools/modeling_schema.yaml b/electrolyzer/tools/modeling_schema.yaml index 945372e..8e5e16c 100644 --- a/electrolyzer/tools/modeling_schema.yaml +++ b/electrolyzer/tools/modeling_schema.yaml @@ -134,7 +134,7 @@ properties: hydrogen_degradation_penalty: type: boolean default: True - description: Toggle whether degradation is applied to hydrogen or power + description: Toggle whether degradation is applied to hydrogen (True) or power (False) degradation: type: object @@ -361,36 +361,11 @@ properties: default: {} description: Alkaline electrode parameters properties: - # A_electrode: - # type: number - # default: 300 - # description: electrode total area - # units: cm^2 - # e_a: - # type: number - # default: 0.2 - # description: anode thickness - # units: cm - # e_c: - # type: number - # default: 0.2 - # description: cathode thickness - # units: cm e_e: type: number default: 0.2 description: electrode thickness units: cm - # d_am: - # type: number - # default: 0.125 - # description: anode-membrane distance - # units: cm - # d_cm: - # type: number - # default: 0.125 - # description: cathode-membrane distance - # units: cm d_em: type: number default: 0.125 @@ -418,11 +393,6 @@ properties: default: {} description: Alkaline membrane parameters properties: - # A_membrane: - # type: number - # default: 300 - # units: cm^2 - # description: membrane surface area e_m: type: number default: 0.05 From 1a4afbf20a547ccc2ea679b856ea17a9eab455eb Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 3 Sep 2025 12:39:13 -0600 Subject: [PATCH 29/31] fixed aep datadrame in bert.py --- electrolyzer/simulation/bert.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/electrolyzer/simulation/bert.py b/electrolyzer/simulation/bert.py index 5bfbc88..59264f7 100644 --- a/electrolyzer/simulation/bert.py +++ b/electrolyzer/simulation/bert.py @@ -115,7 +115,7 @@ def run_LCA(elec_sys, plant_life_years: int): refturb_schedule, ahp_kg, aep_kWh = stack.estimate_life_performance_from_year( plant_life_years ) - sys_refurb = pd.concat( + sys_aep = pd.concat( [ sys_aep, pd.DataFrame( From 85f7847b558e88e6c8fb82f1070139039c602170 Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 3 Sep 2025 12:40:08 -0600 Subject: [PATCH 30/31] added more docstrings to stack.py --- electrolyzer/simulation/stack.py | 110 +++++++++++++++++++++++-------- 1 file changed, 84 insertions(+), 26 deletions(-) diff --git a/electrolyzer/simulation/stack.py b/electrolyzer/simulation/stack.py index 0b7a873..1283756 100644 --- a/electrolyzer/simulation/stack.py +++ b/electrolyzer/simulation/stack.py @@ -217,8 +217,17 @@ def __attrs_post_init__(self) -> None: self.d_eol = self.calc_end_of_life_voltage() def run_power_deg_penalty(self, P_in): - """ - P_in [Wdc]: stack power input + """Run the stack with a degradation penalty applied to the power consumption. + Power consumed may be greater than power input. + + Args: + P_in (float): stack power input in Wdc + + Returns: + 2-element tuple containing + + - **I_stack** (float): stack current in Amps + - **V_cell** (float): cell voltage in Volts """ I_stack = self.electrolyzer_model( @@ -229,8 +238,17 @@ def run_power_deg_penalty(self, P_in): return I_stack, V_cell def run_h2_deg_penalty(self, P_in): - """ - P_in [Wdc]: stack power input + """Run the stack with a degradation penalty applied to the hydrogen production. + Power consumed should be nearly equal to power input. + + Args: + P_in (float): stack power input in Wdc + + Returns: + 2-element tuple containing + + - **I_stack** (float): stack current in Amps + - **V_cell** (float): cell voltage in Volts """ I_nom = self.electrolyzer_model( @@ -243,6 +261,19 @@ def run_h2_deg_penalty(self, P_in): return I_stack, V_cell def run(self, P_in): + """Run the stack for smoe input power. + + Args: + P_in (float): stack power input in Wdc + + Returns: + 3-element tuple containing + + - **H2_mfr** (float): hydrogen mass flow rate in kg/sec + - **H2_mass_out** (float): hydrogen mass produced in kg/dt + - **power_left** (float): remaining power, P_in and power consumed + + """ self.update_status() if self.hydrogen_degradation_penalty: I_stack, V_cell = self.run_h2_deg_penalty(P_in) @@ -253,13 +284,20 @@ def run(self, P_in): return H2_mfr, H2_mass_out, power_left def run_stack(self, I_stack, V_cell, P_in): - """ - I_stack [A]: stack current input - V_cell [V]: cell voltage - P_in [Wdc]: stack power input - return :: H2_mfr [kg/s]: hydrogen mass flow rate - return :: H2_mass_out [kg]: hydrogen mass - return :: power_left [W]: difference in P_in and power consumed + """Run the stack for a given stack current, cell voltage, and power input. + Updates the cell degradation, updates dynamics, calculates hydrogen mass + flow rate and production, and remaining power. + + Args: + I_stack (float): stack current input in Amps + V_cell (float): cell voltage in Volts + P_in (float): stack power input in Wdc + Returns: + 3-element tuple containing + + - **H2_mfr** (float): hydrogen mass flow rate in kg/sec + - **H2_mass_out** (float): hydrogen mass produced in kg/dt + - **power_left** (float): difference in P_in and power consumed in Watts """ if self.stack_on: @@ -347,25 +385,37 @@ def create_polarization(self): return fitobj def convert_power_to_current(self, Pdc, T): - """ - Pdc [kW]: stack power - T [degC]: stack temperature - return :: Idc [A]: stack current + """Estimate stack current for a given power operating point and temperature. + + Args: + Pdc (float): stack power in kWdc + T (float): stack temperature in Celsius + + Returns: + float: ``Idc`` stack current in Amps """ Idc = self.electrolyzer_model((Pdc, T), *self.fit_params) return Idc def curtail_power(self, P_in): - """ - P_in [kWdc]: input power - Curtail power if over electrolyzer rating: + """Curtail power if power exceeds stack rating + + Args: + P_in (float): input power in kWdc + + Returns: + float | array: input power in kWdc saturated at stack rated power. """ return np.where(P_in > self.stack_rating_kW, self.stack_rating_kW, P_in) def calc_fatigue_degradation(self, voltage_signal): """ - voltage_signal: the voltage signal from the last 3600 seconds - return:: voltage_penalty: the degradation penalty + Args: + voltage_signal (float | array): the voltage signal from the last + 3600 seconds + Returns: + float | array: ``voltage_penalty`` the degradation penalty from + variable operation in Volts """ # based off degradation due to square waves of different frequencies # from results in https://iopscience.iop.org/article/10.1149/2.0231915jes @@ -429,13 +479,18 @@ def update_temperature(self, I, V): return self.temperature def update_dynamics(self, H2_mfr_ss, stack_state): - """ - H2_mfr_ss: steady state mass flow rate - stack_state: previous mfr state - return :: next_state: next mfr state - return :: H2_mfr_actual: actual mfr according to the filter + """This is really just a filter on the steady state mfr from + time step to time step. - This is really just a filter on the steady state mfr from time step to time step + Args: + H2_mfr_ss (float): steady state mass flow rate + stack_state (float): previous mfr state + + Returns: + 2-element tuple containing + + - **next_state** (float): next mfr state + - **H2_mfr_actual** (float): actual mfr according to the filter """ if self.ignore_dynamics: @@ -492,6 +547,9 @@ def turn_stack_off(self): ) def turn_stack_on(self): + """Turn the stack on if the stack is off or watiting. + Updates the waiting period, turn on time, and stack status. + """ if self.stack_on: return From 6231d3a3acefe2665ea7bcc5db2b16a51ff3b24c Mon Sep 17 00:00:00 2001 From: elenya-grant <116225007+elenya-grant@users.noreply.github.com> Date: Wed, 3 Sep 2025 12:42:27 -0600 Subject: [PATCH 31/31] added comments to pem.py for faradaic coefficients --- electrolyzer/simulation/cell_models/pem.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/electrolyzer/simulation/cell_models/pem.py b/electrolyzer/simulation/cell_models/pem.py index c8feb31..e0c892c 100644 --- a/electrolyzer/simulation/cell_models/pem.py +++ b/electrolyzer/simulation/cell_models/pem.py @@ -51,8 +51,8 @@ class PEMCell(FromDictMixin): i_0_c: float e_m: float R_ohmic_elec: float - f_1: float - f_2: float + f_1: float # faradaic coefficient in mA^2/cm^4 + f_2: float # faradaic coefficient [unitless] # If we rework this class to be even more generic, we can have these be specified # as configuration params @@ -242,8 +242,7 @@ def calc_faradaic_efficiency(self, T_C, I): return :: eta_F [-]: Faraday's efficiency Reference: https://res.mdpi.com/d_attachment/energies/energies-13-04792/article_deploy/energies-13-04792-v2.pdf """ # noqa - # f_1 = 250 # (mA2/cm4) - # f_2 = 0.996 + I *= 1000 eta_F = (