From 2d5f77547ca723a3c72ac077f39a7ca6249daf1b Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 16:10:07 -0700 Subject: [PATCH 01/26] add failing energy-consistency tests for the HXN problem table Co-Authored-By: Claude Fable 5 --- tests/test_hxn.py | 140 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) diff --git a/tests/test_hxn.py b/tests/test_hxn.py index 758a22e9..eb1cc28e 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -10,6 +10,7 @@ Tests for the heat exchanger network facility. """ import warnings +import pytest import biosteam as bst import numpy as np from numpy.testing import assert_allclose @@ -90,8 +91,147 @@ def test_energy_balance_error_contributions_ignored_none(): assert len(errors) == N assert HXN.ignored is None +# --------------------------------------------------------------------------- +# Problem-table (pinch) analysis +# --------------------------------------------------------------------------- + +from biosteam.facilities.hxn.hxn_synthesis import ( + temperature_interval_pinch_analysis, problem_table, +) + +def utility_hx(ID, T, P, phase, T_out, **flow): + """A simulated HXutility acting as one process stream (kmol/hr flows).""" + s = bst.Stream(ID + '_in', T=T, P=P, phase=phase, units='kmol/hr', **flow) + hx = bst.HXutility(ID, ins=s, T=T_out, + rigorous=(phase == 'g')) # liquid streams stay liquid (report's case) + hx.simulate() + return hx + +def synthetic_units(): + """Report's 4-stream case: two cold, one condensing hot, one hot liquid.""" + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + bst.main_flowsheet.set_flowsheet('test_hxn_synthetic') + return [utility_hx('C1', 300., 101325., 'l', 390., Water=2000.), + utility_hx('C2', 310., 101325., 'l', 345., Water=500., Ethanol=500.), + utility_hx('H1', 352., 101325., 'g', 340., Ethanol=300.), + utility_hx('H2', 420., 5e5, 'l', 320., Water=800.)] + +def heat_utilities(units): + hus = [hx.heat_utilities[0] for hx in units] + hus.sort(key=lambda hu: hu.duty) + return hus + +def pinch_streams(hus): + """Inlet/quenched-outlet stream copies exactly as the synthesizer prepares them.""" + streams_inlet = [hu.unit.ins[0].copy() for hu in hus] + streams_quenched = [hu.unit.outs[0].copy() for hu in hus] + for s in streams_quenched: s.vle(H=s.H, P=s.P) + is_hot = [hu.duty < 0 for hu in hus] + return streams_inlet, streams_quenched, is_hot + +def assert_energy_consistent(hus, T_min_app): + """Invariants of a correct problem table, independent of the synthesizer.""" + unit_duties = np.array([hu.unit_duty for hu in hus]) + table = problem_table(*pinch_streams(hus), T_min_app) + # (a) each stream's grid contributions telescope to its real duty + # (hot: +|dH|, cold: -dH) + per_stream = table.interval_H.sum(axis=1) + table.point_H.sum(axis=1) + assert_allclose(per_stream, -unit_duties, rtol=1e-9) + # (b) targets are non-negative and hot - cold is the net demand + assert table.hot_util_load >= 0. and table.cold_util_load >= 0. + assert_allclose(table.hot_util_load - table.cold_util_load, + unit_duties.sum(), rtol=1e-9) + # (c) a target can never exceed the un-integrated load + assert table.hot_util_load <= unit_duties[unit_duties > 0].sum() * (1 + 1e-9) + assert table.cold_util_load <= -unit_duties[unit_duties < 0].sum() * (1 + 1e-9) + # (d) the public wrapper reports the same targets + pinch_T_arr, hot, cold, *_ = temperature_interval_pinch_analysis(hus, T_min_app) + assert_allclose([hot, cold], [table.hot_util_load, table.cold_util_load], rtol=1e-12) + return table + +def test_problem_table_energy_consistency_doctest_system(): + sys, HXN, feed = build_system() + sys.simulate() + hus = HXN._get_original_heat_utilties() + hus.sort(key=lambda hu: hu.duty) + assert_energy_consistent(hus, 5.) + +@pytest.mark.parametrize('T_min_app', [5., 10., 20.]) +def test_problem_table_energy_consistency_synthetic(T_min_app): + hus = heat_utilities(synthetic_units()) + table = assert_energy_consistent(hus, T_min_app) + # the condensing ethanol stream (352 K in, ~351.4 K dew point) must keep + # its latent heat: hot target well below the un-integrated heating load + heating = sum(hu.unit_duty for hu in hus if hu.unit_duty > 0) + assert table.hot_util_load < 0.5 * heating + +def test_problem_table_two_streams_closed_form(): + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + bst.main_flowsheet.set_flowsheet('test_hxn_two_streams') + hot = utility_hx('Hw', 400., 5e5, 'l', 300., Water=1000.) + # Case 1 (threshold problem): the hot stream covers every interval of the + # smaller cold stream -> no hot utility, cold utility = net surplus. + cold = utility_hx('Cs', 300., 5e5, 'l', 390., Water=900.) + hus = heat_utilities([hot, cold]) + table = problem_table(*pinch_streams(hus), 5.) + Q_hot = -hot.heat_utilities[0].unit_duty + Q_cold = cold.heat_utilities[0].unit_duty + assert table.hot_util_load == 0. + assert_allclose(table.cold_util_load, Q_hot - Q_cold, rtol=1e-9) + assert table.pinch_T == table.Ts[0] # no pinch: everything sits below it + # Case 2: the larger cold stream is short of heat everywhere; the cascade + # minimum is at the cold inlet (300 K on the shifted scale) and the hot + # utility is the cold duty minus what the hot stream gives down to 305 K. + cold = utility_hx('Cb', 300., 5e5, 'l', 390., Water=1200.) + hus = heat_utilities([hot, cold]) + table = problem_table(*pinch_streams(hus), 5.) + s = hot.ins[0].copy(); s.vle(T=305., P=s.P) + Q_hot_above_pinch = hot.ins[0].H - s.H + Q_cold = cold.heat_utilities[0].unit_duty + assert_allclose(table.hot_util_load, Q_cold - Q_hot_above_pinch, rtol=1e-9) + assert table.pinch_T == 300. + # remaining hot-stream heat below the pinch leaves as cold utility + assert_allclose(table.cold_util_load, s.H - hot.outs[0].H, rtol=1e-9) + +def test_problem_table_non_monotone_stream_is_point_load(): + # A heated stream whose outlet is colder than its inlet (e.g. a column + # reboiler outlet at VLE): treated as an isothermal load at T_out. + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + a = bst.Stream('a', Water=100., T=372., P=101325., phase='l', units='kmol/hr') + b = bst.Stream('b', Water=100., T=371., P=101325., phase='g', units='kmol/hr') + dH = b.H - a.H + assert dH > 0 + table = problem_table([a], [b], [False], 5.) + assert_allclose(table.point_H, [[-dH]]) + assert table.interval_H.shape == (1, 0) + assert_allclose([table.hot_util_load, table.cold_util_load, table.pinch_T], + [dH, 0., 371.]) + table = problem_table([b], [a], [True], 5.) + assert_allclose([table.hot_util_load, table.cold_util_load, table.pinch_T], + [0., dH, 372. - 5.]) # outlet T 372 K, shifted by T_min_app + +def test_synthetic_network_reaches_MER(): + units = synthetic_units() + HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) + sys = bst.System.from_units('sys_synthetic', units=[*units, HXN]) + sys.simulate() + hus = heat_utilities(units) + table = problem_table(*pinch_streams(hus), 5.) + actual_heat = sum(hu.unit_duty for hx in HXN.new_HX_utils + for hu in hx.heat_utilities if hu.unit_duty > 0) + # the greedy heuristic reaches the (corrected) MER on this case; it can + # never legitimately beat it + assert_allclose(actual_heat, table.hot_util_load, rtol=1e-2) + assert actual_heat >= table.hot_util_load * (1 - 1e-3) + if __name__ == '__main__': test_cache_network_matches_fresh_synthesis() test_cache_network_perturbed_feed() test_cache_network_duplicate_IDs() test_energy_balance_error_contributions_ignored_none() + test_problem_table_energy_consistency_doctest_system() + for T_min_app in (5., 10., 20.): + test_problem_table_energy_consistency_synthetic(T_min_app) + test_problem_table_two_streams_closed_form() + test_problem_table_non_monotone_stream_is_point_load() + test_synthetic_network_reaches_MER() From 08e873c57a710be85540a613ae56837bb7b3b188 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 16:17:02 -0700 Subject: [PATCH 02/26] fix HXN problem table: evaluate streams at real T, clip to [H_in, H_out], point loads for isothermal streams temperature_interval_pinch_analysis built the heat cascade from interval enthalpies that were (1) evaluated by flashing hot streams at the *shifted* temperature T - T_min_app, so a stream entering within T_min_app of its dew point was already liquid and lost its latent heat, (2) never clipped to the stream's actual [H_in, H_out], so non-equilibrium column outlets inflated interval duties, and (3) assigned with the wrong sign to streams whose outlet temperature moves against their duty. Targets were impossible (hot target above the un-integrated heating load on the class doctest; hot - cold != net demand on sugarcane). The cascade is now built by problem_table(): each monotone stream is walked once down the shifted grid with a warm-started copy flashed at the real temperature, exact at its own end points and clipped in between, so its contributions telescope exactly to its duty; isothermal and non-monotone streams are point loads at their outlet temperature. Hence hot_util_load - cold_util_load == sum(unit_duty) and both targets are non-negative by construction. Signature and return value of temperature_interval_pinch_analysis are unchanged. Validated by tests/test_hxn.py: per-stream and net energy identities on the doctest system and a 4-stream case at dT = 5/10/20 K, two-stream closed forms, point-load handling, and the synthetic network reaching MER. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 188 ++++++++++++++++------- 1 file changed, 133 insertions(+), 55 deletions(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 5d5ff658..f2d4bb56 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -10,6 +10,7 @@ @author: sarangbhagwat """ +from collections import namedtuple import numpy as np import biosteam as bst from warnings import warn @@ -124,8 +125,124 @@ def get_sorted_life_cycle(self): return self.life_cycle -def temperature_interval_pinch_analysis(hus, - T_min_app=10, +ProblemTable = namedtuple( + 'ProblemTable', + ['Ts', 'interval_H', 'point_H', 'residual', + 'hot_util_load', 'cold_util_load', 'pinch_T'] +) + +def _stream_H_at_boundaries(stream_in, H_in, H_out, T_lo, T_hi, Ts, shift): + """ + Enthalpies [kJ/hr] of one monotone stream at the grid boundaries + `Ts` (shifted scale, descending, all within [T_lo, T_hi]). + + Exact at the stream's own end points (H_in/H_out as given); in between, + the inlet copy is flashed at the *real* temperature `T + shift` and the + result is clipped to [min(H_in, H_out), max(H_in, H_out)] so that a + non-equilibrium outlet (e.g. a column reboiler/condenser product) can + never inflate an interval. A single copy is walked down the grid so + each VLE is warm-started from the previous boundary. + """ + H_lo, H_hi = sorted((H_in, H_out)) + H_top, H_bottom = (H_in, H_out) if H_in > H_out else (H_out, H_in) + Hs = np.empty(Ts.size) + stream = stream_in.copy() + for k, T in enumerate(Ts): + if T == T_hi: + Hs[k] = H_top + elif T == T_lo: + Hs[k] = H_bottom + else: + T_real = T + shift + try: + stream.vle(T=T_real, P=stream.P) + H = stream.H + except Exception as error: + warn(f"could not solve VLE for {stream!r} at {T_real:.2f} K " + f"({error!r}); interpolating enthalpy linearly in " + "temperature for the problem table", RuntimeWarning) + H = H_lo + (H_hi - H_lo) * (T - T_lo) / (T_hi - T_lo) + Hs[k] = min(max(H, H_lo), H_hi) + return Hs + +def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): + """ + Energy-consistent problem table (temperature-interval heat cascade). + + Parameters + ---------- + streams_inlet : list[Stream] + Inlet stream of each utility heat exchanger. + streams_quenched : list[Stream] + Corresponding outlet streams, re-flashed at their enthalpy. + is_hot : Sequence[bool] + True where the stream is cooled. + T_min_app : float + Minimum approach temperature [K]. + + Returns + ------- + ProblemTable + Grid temperatures `Ts` (shifted scale, descending), per-stream + `interval_H` (N x n-1) and `point_H` (N x n) contributions (+ for + hot, - for cold), the cascade `residual` (n), `hot_util_load`, + `cold_util_load` and the shifted-scale `pinch_T`. + + Notes + ----- + Hot streams are shifted down by `T_min_app`; cold streams are not. For + monotone streams the contribution to interval (Ts[k], Ts[k+1]) is + sign * (H(Ts[k]) - H(Ts[k+1])) with H evaluated at the real temperature + and clipped to [H_in, H_out], so every stream's contributions telescope + exactly to sign * |H_out - H_in|. Isothermal streams, and streams whose + outlet temperature moves against their duty (a heated stream that exits + colder than it entered, e.g. a reboiler outlet at VLE), are point loads + at their outlet temperature. The cascade starting from zero hot utility + is residual[k] = sum(point_H[:, :k+1]) + sum(interval_H[:, :k]); the + minimum fixes the hot utility target, `residual[-1] + hot_util_load` + the cold one, and its location the pinch. With the per-stream identity + above, hot_util_load - cold_util_load equals the net heating demand. + """ + N = len(streams_inlet) + is_hot = np.asarray(is_hot, dtype=bool) + sign = np.where(is_hot, 1., -1.) + shift = np.where(is_hot, T_min_app, 0.) + T_in = np.array([s.T for s in streams_inlet]) + T_out = np.array([s.T for s in streams_quenched]) + H_in = np.array([s.H for s in streams_inlet]) + H_out = np.array([s.H for s in streams_quenched]) + monotone = (sign * (T_in - T_out)) > 0. + T_hi = np.where(monotone, np.maximum(T_in, T_out), T_out) - shift + T_lo = np.where(monotone, np.minimum(T_in, T_out), T_out) - shift + Ts = np.unique(np.concatenate([T_hi, T_lo]))[::-1] + n = Ts.size + interval_H = np.zeros((N, n - 1)) + point_H = np.zeros((N, n)) + for j in range(N): + if monotone[j]: + idx = np.flatnonzero((Ts <= T_hi[j]) & (Ts >= T_lo[j])) + Hs = _stream_H_at_boundaries(streams_inlet[j], H_in[j], H_out[j], + T_lo[j], T_hi[j], Ts[idx], shift[j]) + interval_H[j, idx[:-1]] = sign[j] * (Hs[:-1] - Hs[1:]) + else: + k = np.searchsorted(-Ts, -T_hi[j]) + point_H[j, k] = sign[j] * abs(H_out[j] - H_in[j]) + residual = np.cumsum( + point_H.sum(axis=0) + np.concatenate([[0.], interval_H.sum(axis=0)]) + ) + k_pinch = int(np.argmin(residual)) + scale = np.abs(H_out - H_in).sum() + if -residual[k_pinch] <= 1e-9 * scale: # threshold problem: no hot utility + hot_util_load = 0. + k_pinch = 0 + else: + hot_util_load = -residual[k_pinch] + cold_util_load = residual[-1] + hot_util_load + return ProblemTable(Ts, interval_H, point_H, residual, + hot_util_load, cold_util_load, Ts[k_pinch]) + +def temperature_interval_pinch_analysis(hus, + T_min_app=10, force_ideal_thermo=False, sort_hus_by_T=False): hx_utils = hus @@ -150,77 +267,38 @@ def temperature_interval_pinch_analysis(hus, ID = 'Util_%s'%i stream.ID = 's_%s__%s'%(i,ID) N_heating = len(hus_heating) - is_cold_stream_index = lambda x: x < N_heating - T_in_arr = np.array([stream.T for stream in streams_inlet]) - T_out_arr = np.array([i.T for i in streams_quenched]) - adj_T_in_arr = T_in_arr.copy() - # adj_T_in_arr[:N_heating] -= T_min_app - adj_T_in_arr[N_heating:] -= T_min_app - adj_T_out_arr = T_out_arr.copy() - # adj_T_out_arr[:N_heating] -= T_min_app - adj_T_out_arr[N_heating:] -= T_min_app - T_changes_tuples = list(zip(adj_T_in_arr, adj_T_out_arr)) - all_Ts_descending = [*adj_T_in_arr, *adj_T_out_arr] - all_Ts_descending.sort(reverse=True) - stream_indices_for_T_intervals =\ - {(all_Ts_descending[i], all_Ts_descending[i+1]):[]\ - for i in range(len(all_Ts_descending)-1)} - H_for_T_intervals = dict.fromkeys(stream_indices_for_T_intervals, 0) cold_indices = list(range(N_heating)) hot_indices = list(range(N_heating, len(hxs))) indices = cold_indices + hot_indices - for i in range(len(all_Ts_descending)-1): - T_start = all_Ts_descending[i] - T_end = all_Ts_descending[i+1] - for stream_index in indices: - T1, T2 = T_changes_tuples[stream_index] - if (T1 >= T_start and T2 <= T_end) or (T2 >= T_start and T1 <= T_end): - multiplier = -1 if is_cold_stream_index(stream_index) else 1 - stream = streams_inlet[stream_index].copy() - if stream.T != T_start: stream.vle(T = T_start, P = stream.P) - H1 = stream.H - try: - stream.vle(T = T_end, P = stream.P) - except: - warn(f"could not solve VLE for {repr(stream)} at {repr(hxs[stream_index].owner)}", RuntimeWarning) - H2 = stream.H - H = multiplier*(H1 - H2) - H_for_T_intervals[(T_start, T_end)] += H - - res_H_vector = [] - prev_res_H = 0 - for interval, H in H_for_T_intervals.items(): - res_H_vector.append(prev_res_H + H) - prev_res_H = res_H_vector[len(res_H_vector)-1] - hot_util_load = - min(res_H_vector) - # assert hot_util_load>= 0, 'Hot utility load is negative' - if not hot_util_load>=0: - warn(f"Hot utility load is negative: {hot_util_load}", RuntimeWarning) - # print(hot_util_load) - # the lower temperature of the temperature interval for which the res_H is minimum - pinch_cold_stream_T = all_Ts_descending[res_H_vector.index(-hot_util_load)+1] + T_in_arr = np.array([stream.T for stream in streams_inlet]) + T_out_arr = np.array([i.T for i in streams_quenched]) + is_hot = np.zeros(len(hxs), dtype=bool) + is_hot[hot_indices] = True + table = problem_table(streams_inlet, streams_quenched, is_hot, T_min_app) + hot_util_load = table.hot_util_load + cold_util_load = table.cold_util_load + pinch_cold_stream_T = table.pinch_T pinch_hot_stream_T = pinch_cold_stream_T + T_min_app - cold_util_load = res_H_vector[len(res_H_vector)-1] + hot_util_load - # assert cold_util_load>=0, 'Cold utility load is negative' - if not cold_util_load>=0: - warn(f"Cold utility load is positive: {cold_util_load}", RuntimeWarning) + # Per-stream pinch temperature: where the stream is split between the + # hot-side and cold-side designs. Non-monotone streams (T_out against + # the duty) are not split: their pinch is the inlet T, so load_duties + # puts the whole duty on the hot side, as before this fix. pinch_T_arr = [] for i in cold_indices: - if T_in_arr[i] > pinch_cold_stream_T: + if T_in_arr[i] > pinch_cold_stream_T or T_in_arr[i] > T_out_arr[i]: pinch_T_arr.append(T_in_arr[i]) elif T_out_arr[i] < pinch_cold_stream_T: pinch_T_arr.append(T_out_arr[i]) else: pinch_T_arr.append(pinch_cold_stream_T) for i in hot_indices: - if T_in_arr[i] < pinch_hot_stream_T: + if T_in_arr[i] < pinch_hot_stream_T or T_in_arr[i] < T_out_arr[i]: pinch_T_arr.append(T_in_arr[i]) elif T_out_arr[i] > pinch_hot_stream_T: pinch_T_arr.append(T_out_arr[i]) else: pinch_T_arr.append(pinch_hot_stream_T) pinch_T_arr = np.array(pinch_T_arr) - # print(pinch_T_arr, hot_util_load, cold_util_load,) return pinch_T_arr, hot_util_load, cold_util_load, T_in_arr, T_out_arr,\ hxs, hot_indices, cold_indices, indices, streams_inlet, hx_utils_rearranged, \ streams_quenched From bcc56277ea5db0377c2cbada390538102d1219b2 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 16:25:50 -0700 Subject: [PATCH 03/26] harden HXN problem table: endpoint enthalpies by index, traceable VLE warning, clean restart after failed flash Three review fixes to the problem_table helpers added on this branch: 1. _stream_H_at_boundaries compared grid temperatures to T_hi/T_lo with float equality to detect a stream's own end points; this only worked because Ts was built from the same floats. Assign Hs[0]/Hs[-1] by position instead (the caller always passes T_hi first, T_lo last, and monotone streams have T_hi > T_lo strictly so the slice has >= 2 entries, asserted), and loop only over the interior boundaries. 2. The VLE-failure warning printed {stream!r} for an anonymous inlet copy, giving no way to trace which stream failed. Pass the inlet stream's own ID (set by the wrapper to s___Util_) into the helper and name it in the warning. 3. On a failed flash, the warm-started copy was left in whatever state the failed VLE call put it in and reused for the next boundary. Re-copy stream_in in the except branch so the next boundary restarts clean. Also rewrote the comment above the pinch_T_arr loop in temperature_interval_pinch_analysis, which claimed non-monotone streams get pinch = T_in "as before this fix" -- not true in general (e.g. T_out < T_in <= pinch_cold_stream_T for a cold stream gave T_out/pinch under the old rule). The comment now states the actual rule (streams already on one side of the pinch, including non-monotone ones, are not split; load_duties assigns their whole duty to one side) without claiming equivalence with prior behavior. Covering tests unchanged (tests/test_hxn.py + hxn doctests): 12 passed in 13.36s. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 76 +++++++++++++++--------- 1 file changed, 48 insertions(+), 28 deletions(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index f2d4bb56..6df32c10 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -131,38 +131,50 @@ def get_sorted_life_cycle(self): 'hot_util_load', 'cold_util_load', 'pinch_T'] ) -def _stream_H_at_boundaries(stream_in, H_in, H_out, T_lo, T_hi, Ts, shift): +def _stream_H_at_boundaries(stream_in, H_in, H_out, T_lo, T_hi, Ts, shift, + stream_label): """ Enthalpies [kJ/hr] of one monotone stream at the grid boundaries `Ts` (shifted scale, descending, all within [T_lo, T_hi]). - Exact at the stream's own end points (H_in/H_out as given); in between, - the inlet copy is flashed at the *real* temperature `T + shift` and the - result is clipped to [min(H_in, H_out), max(H_in, H_out)] so that a - non-equilibrium outlet (e.g. a column reboiler/condenser product) can - never inflate an interval. A single copy is walked down the grid so - each VLE is warm-started from the previous boundary. + Exact at the stream's own end points (H_in/H_out as given) by + *position*: `Ts[0]` and `Ts[-1]` are the stream's own T_hi/T_lo (every + monotone stream has `T_hi > T_lo` strictly, so `Ts` always has at least + these two entries) and are assigned H_in/H_out directly, without a float + comparison. In between, the inlet copy is flashed at the *real* + temperature `T + shift` and the result is clipped to + [min(H_in, H_out), max(H_in, H_out)] so that a non-equilibrium outlet + (e.g. a column reboiler/condenser product) can never inflate an + interval. A single copy is walked down the grid so each VLE is + warm-started from the previous boundary; `stream_label` (the inlet + stream's own ID) identifies the stream in the VLE-failure warning. """ + assert Ts.size >= 2, ( + "boundary grid for a monotone stream must include both its own " + "end points" + ) H_lo, H_hi = sorted((H_in, H_out)) H_top, H_bottom = (H_in, H_out) if H_in > H_out else (H_out, H_in) Hs = np.empty(Ts.size) + Hs[0] = H_top + Hs[-1] = H_bottom stream = stream_in.copy() - for k, T in enumerate(Ts): - if T == T_hi: - Hs[k] = H_top - elif T == T_lo: - Hs[k] = H_bottom - else: - T_real = T + shift - try: - stream.vle(T=T_real, P=stream.P) - H = stream.H - except Exception as error: - warn(f"could not solve VLE for {stream!r} at {T_real:.2f} K " - f"({error!r}); interpolating enthalpy linearly in " - "temperature for the problem table", RuntimeWarning) - H = H_lo + (H_hi - H_lo) * (T - T_lo) / (T_hi - T_lo) - Hs[k] = min(max(H, H_lo), H_hi) + for k in range(1, Ts.size - 1): + T = Ts[k] + T_real = T + shift + try: + stream.vle(T=T_real, P=stream.P) + H = stream.H + except Exception as error: + warn(f"could not solve VLE for stream {stream_label!r} at " + f"{T_real:.2f} K ({error!r}); interpolating enthalpy " + "linearly in temperature for the problem table", + RuntimeWarning) + # restart the warm start from a clean copy so the failed flash + # does not leave `stream` in a bad state for the next boundary + stream = stream_in.copy() + H = H_lo + (H_hi - H_lo) * (T - T_lo) / (T_hi - T_lo) + Hs[k] = min(max(H, H_lo), H_hi) return Hs def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): @@ -222,7 +234,8 @@ def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): if monotone[j]: idx = np.flatnonzero((Ts <= T_hi[j]) & (Ts >= T_lo[j])) Hs = _stream_H_at_boundaries(streams_inlet[j], H_in[j], H_out[j], - T_lo[j], T_hi[j], Ts[idx], shift[j]) + T_lo[j], T_hi[j], Ts[idx], shift[j], + streams_inlet[j].ID) interval_H[j, idx[:-1]] = sign[j] * (Hs[:-1] - Hs[1:]) else: k = np.searchsorted(-Ts, -T_hi[j]) @@ -279,10 +292,17 @@ def temperature_interval_pinch_analysis(hus, cold_util_load = table.cold_util_load pinch_cold_stream_T = table.pinch_T pinch_hot_stream_T = pinch_cold_stream_T + T_min_app - # Per-stream pinch temperature: where the stream is split between the - # hot-side and cold-side designs. Non-monotone streams (T_out against - # the duty) are not split: their pinch is the inlet T, so load_duties - # puts the whole duty on the hot side, as before this fix. + # Per-stream pinch temperature: where each stream is split between the + # hot-side and cold-side network designs. A stream already entirely on + # one side of the process pinch (T_in past pinch_cold_stream_T for a + # cold stream, or past pinch_hot_stream_T for a hot stream) is not + # split; its pinch_T is its own T_in. This clause also catches + # non-monotone streams (T_out on the wrong side of T_in for their duty, + # e.g. a cold stream whose VLE outlet ends up cooler than it entered): + # rather than split their problem_table point-load duty across the + # cascade, they get pinch_T = T_in too, so load_duties assigns their + # whole duty to a single side (Q_hot_side for a cold stream, + # Q_cold_side for a hot one). pinch_T_arr = [] for i in cold_indices: if T_in_arr[i] > pinch_cold_stream_T or T_in_arr[i] > T_out_arr[i]: From 446e7e1dbb3167601d982cd45a638818d7919919 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 18:05:04 -0700 Subject: [PATCH 04/26] fix HXN problem table cascade: check heat arriving at a boundary before its point loads The cascade residual[k] = sum(point_H[:, :k+1]) + sum(interval_H[:, :k]) is the heat *leaving* boundary Ts[k], after that boundary's point loads. Testing only this for non-negativity lets a hot point load at Ts[k] (an isothermal condenser, a phase-changing HXutility) mask a deficit in the cold interval (Ts[k-1], Ts[k]) directly above it - but a source at Ts[k] cannot serve a sink above Ts[k]. Example: a condensing stream at 400 K (shifted 395 K) against a cold stream heated 392 -> 398 K returned a hot utility target of zero; the correct target is the cold 395-398 K segment. The target is now the minimum over both the arriving flow (residual - point_total) and the leaving flow at every boundary, which is the standard problem-table treatment of point loads. Also: cold_util_load is clamped at zero in the threshold branch (residual[-1] could be negative by a rounding-level amount, and the tests assert non-negativity); problem_table/ProblemTable are exported in __all__ with an Examples doctest (two-stream threshold case). Note on synthesis behaviour (unchanged by this commit, introduced with the wrapper rewrite): non-monotone streams (outlet temperature moving against the duty) get pinch_T = T_in in pinch_T_arr, so load_duties places their whole duty on the hot side. The old code gave a meaningless negative dH2 for such streams when T_in was on the wrong side of the pinch. The table counts them as point loads at T_out; reconciling that with the synthesis heuristic is a separate item. Validation: regression test test_problem_table_point_load_cannot_heat_above_itself; tests/test_hxn.py + hxn doctests 14 passed (class doctest unchanged); canonical suite 71 failed / 476 passed / 62 skipped with the same pre-existing failure set as the baseline; tests/test_biorefineries.py 1 failed (test_cornstover, baseline) / 4 passed. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 61 +++++++++++++++++++----- tests/test_hxn.py | 30 ++++++++++++ 2 files changed, 80 insertions(+), 11 deletions(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 6df32c10..b2770f33 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -15,7 +15,8 @@ import biosteam as bst from warnings import warn -__all__ = ('StreamLifeCycle', 'synthesize_network') +__all__ = ('StreamLifeCycle', 'ProblemTable', 'problem_table', + 'synthesize_network') class LifeStage: @@ -197,7 +198,8 @@ def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): ProblemTable Grid temperatures `Ts` (shifted scale, descending), per-stream `interval_H` (N x n-1) and `point_H` (N x n) contributions (+ for - hot, - for cold), the cascade `residual` (n), `hot_util_load`, + hot, - for cold), the cascade `residual` (n) *leaving* each + boundary (i.e. after its point loads), `hot_util_load`, `cold_util_load` and the shifted-scale `pinch_T`. Notes @@ -210,10 +212,39 @@ def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): outlet temperature moves against their duty (a heated stream that exits colder than it entered, e.g. a reboiler outlet at VLE), are point loads at their outlet temperature. The cascade starting from zero hot utility - is residual[k] = sum(point_H[:, :k+1]) + sum(interval_H[:, :k]); the - minimum fixes the hot utility target, `residual[-1] + hot_util_load` - the cold one, and its location the pinch. With the per-stream identity - above, hot_util_load - cold_util_load equals the net heating demand. + is residual[k] = sum(point_H[:, :k+1]) + sum(interval_H[:, :k]), the + heat *leaving* boundary Ts[k]. Feasibility must also hold for the heat + *arriving* at Ts[k] before its point loads are applied, + arriving[k] = residual[k] - sum(point_H[:, k]), because a source at + Ts[k] cannot serve a sink above Ts[k]. The minimum over both flows, + min(residual, arriving), fixes the hot utility target, + `residual[-1] + hot_util_load` the cold one, and its location the + pinch. With the per-stream identity above, hot_util_load - + cold_util_load equals the net heating demand. + + Examples + -------- + A threshold problem: 1000 kmol/hr of water cooled 400 -> 300 K supplies + every interval of 900 kmol/hr of water heated 300 -> 390 K, so no hot + utility is needed and the surplus leaves as cold utility. + + >>> import biosteam as bst + >>> from biosteam.facilities.hxn.hxn_synthesis import problem_table + >>> bst.settings.set_thermo(['Water']) + >>> hot_in = bst.Stream(Water=1000., T=400., P=5e5, phase='l', units='kmol/hr') + >>> hot_out = hot_in.copy(); hot_out.vle(T=300., P=5e5) + >>> cold_in = bst.Stream(Water=900., T=300., P=5e5, phase='l', units='kmol/hr') + >>> cold_out = cold_in.copy(); cold_out.vle(T=390., P=5e5) + >>> table = problem_table([hot_in, cold_in], [hot_out, cold_out], + ... [True, False], 5.) + >>> table.Ts + array([395., 390., 300., 295.]) + >>> round(table.hot_util_load, 3) + 0.0 + >>> round(table.cold_util_load, 3) + 1445547.086 + >>> table.pinch_T + 395.0 """ N = len(streams_inlet) is_hot = np.asarray(is_hot, dtype=bool) @@ -240,17 +271,25 @@ def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): else: k = np.searchsorted(-Ts, -T_hi[j]) point_H[j, k] = sign[j] * abs(H_out[j] - H_in[j]) + point_total = point_H.sum(axis=0) residual = np.cumsum( - point_H.sum(axis=0) + np.concatenate([[0.], interval_H.sum(axis=0)]) + point_total + np.concatenate([[0.], interval_H.sum(axis=0)]) ) - k_pinch = int(np.argmin(residual)) + # heat arriving at each boundary, before that boundary's point loads: + # a point source at Ts[k] cannot serve sinks above Ts[k], so the cascade + # must be non-negative both before and after the point loads + arriving = residual - point_total + flow = np.minimum(residual, arriving) + k_pinch = int(np.argmin(flow)) scale = np.abs(H_out - H_in).sum() - if -residual[k_pinch] <= 1e-9 * scale: # threshold problem: no hot utility + if -flow[k_pinch] <= 1e-9 * scale: # threshold problem: no hot utility hot_util_load = 0. k_pinch = 0 else: - hot_util_load = -residual[k_pinch] - cold_util_load = residual[-1] + hot_util_load + hot_util_load = -flow[k_pinch] + # clamp: in the threshold branch residual[-1] may be negative by a + # rounding-level amount, and a negative cold utility is meaningless + cold_util_load = max(0., residual[-1] + hot_util_load) return ProblemTable(Ts, interval_H, point_H, residual, hot_util_load, cold_util_load, Ts[k_pinch]) diff --git a/tests/test_hxn.py b/tests/test_hxn.py index eb1cc28e..5520b6fe 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -210,6 +210,32 @@ def test_problem_table_non_monotone_stream_is_point_load(): assert_allclose([table.hot_util_load, table.cold_util_load, table.pinch_T], [0., dH, 372. - 5.]) # outlet T 372 K, shifted by T_min_app +def test_problem_table_point_load_cannot_heat_above_itself(): + # A source at shifted temperature T cannot serve sinks above T: an + # isothermal condensing hot stream at 400 K (shifted to 395 K) must not + # cover the 395-398 K segment of a cold stream that runs 392 -> 398 K. + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + hot_in = bst.Stream('hv', Water=100., T=400., P=101325., phase='g', + units='kmol/hr') + hot_out = bst.Stream('hl', Water=100., T=400., P=101325., phase='l', + units='kmol/hr') + P_hot = hot_in.H - hot_out.H + assert P_hot > 0 + cold_in = bst.Stream('cl', Water=1000., T=392., P=5e5, phase='l', + units='kmol/hr') + cold_out = cold_in.copy('cl_out'); cold_out.vle(T=398., P=5e5) + s = cold_in.copy(); s.vle(T=395., P=5e5) + H_392, H_395, H_398 = cold_in.H, s.H, cold_out.H + assert P_hot > H_398 - H_392 # more than enough heat overall + table = problem_table([hot_in, cold_in], [hot_out, cold_out], + [True, False], 5.) + assert_allclose(table.Ts, [398., 395., 392.]) + # heat arriving at 395 K, before the point load there, is short by the + # 395-398 K segment of the cold stream + assert_allclose(table.hot_util_load, H_398 - H_395, rtol=1e-9) + assert table.pinch_T == 395. + assert_allclose(table.cold_util_load, P_hot - (H_395 - H_392), rtol=1e-9) + def test_synthetic_network_reaches_MER(): units = synthetic_units() HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) @@ -222,6 +248,9 @@ def test_synthetic_network_reaches_MER(): # the greedy heuristic reaches the (corrected) MER on this case; it can # never legitimately beat it assert_allclose(actual_heat, table.hot_util_load, rtol=1e-2) + # the lower bound is exact here only because every synthetic inlet is an + # equilibrium state (so the clipped table is exact) and the synthesizer + # respects T_min_app; with non-equilibrium inlets the table is conservative assert actual_heat >= table.hot_util_load * (1 - 1e-3) if __name__ == '__main__': @@ -234,4 +263,5 @@ def test_synthetic_network_reaches_MER(): test_problem_table_energy_consistency_synthetic(T_min_app) test_problem_table_two_streams_closed_form() test_problem_table_non_monotone_stream_is_point_load() + test_problem_table_point_load_cannot_heat_above_itself() test_synthetic_network_reaches_MER() From bbea7059803161da2b505d017d64efbc6d077d96 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 18:12:34 -0700 Subject: [PATCH 05/26] keep HXN problem-table energy identity exact when rounding makes cold utility negative The threshold branch could leave cold_util_load = residual[-1] negative by up to 1e-9 * scale; clamping it to zero alone would break hot_util_load - cold_util_load == sum(unit_duty) in relative terms (the identity the tests assert with rtol=1e-9). Absorb the rounding into hot_util_load instead, so both loads are non-negative and the identity is exact. Also round the problem_table doctest's cold utility to 10 kJ/hr so it does not demand ten significant digits from a VLE enthalpy across Python versions. tests/test_hxn.py + hxn doctests: 14 passed. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index b2770f33..216485d8 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -241,8 +241,8 @@ def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): array([395., 390., 300., 295.]) >>> round(table.hot_util_load, 3) 0.0 - >>> round(table.cold_util_load, 3) - 1445547.086 + >>> round(table.cold_util_load, -1) + 1445550.0 >>> table.pinch_T 395.0 """ @@ -287,9 +287,13 @@ def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): k_pinch = 0 else: hot_util_load = -flow[k_pinch] - # clamp: in the threshold branch residual[-1] may be negative by a - # rounding-level amount, and a negative cold utility is meaningless - cold_util_load = max(0., residual[-1] + hot_util_load) + cold_util_load = residual[-1] + hot_util_load + if cold_util_load < 0.: + # only reachable in the threshold branch, by at most 1e-9 * scale: + # absorb the rounding into the hot utility so that + # hot_util_load - cold_util_load == sum(unit_duty) stays exact + hot_util_load -= cold_util_load + cold_util_load = 0. return ProblemTable(Ts, interval_H, point_H, residual, hot_util_load, cold_util_load, Ts[k_pinch]) From 51a38fbac009548788ef4ae4a75ba4c658ff2fc7 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 19:41:56 -0700 Subject: [PATCH 06/26] add pinch diagram plot for HeatExchangerNetwork HeatExchangerNetwork had no way to visualize the synthesized network. Add hxn_synthesis.plot_pinch_diagram (pure function, returns fig/ax) and a HeatExchangerNetwork.plot_pinch_diagram wrapper that draw the standard diagram: cold streams (blue, left to right) above hot streams (red, right to left) with inlet/outlet T [degC] and H [kJ/hr], one vertical connector with its duty per HXprocess, a dashed pinch line separating cold-side from hot-side exchangers, and circles marking utility exchangers whose duty exceeds Qmin. Design notes: - The hot and cold stream of each exchanger are found from the stream life cycles by identity, not by parsing HX___ IDs. - Which side of the pinch an exchanger belongs to comes from the new attributes new_HXs_hot_side / new_HXs_cold_side stored in _cost (only their concatenation new_HXs was kept before). - Columns on each side are ordered by a topological sort of the exchangers under the constraint that every stream meets them in its flow direction (hot streams reversed); contradictory constraints fall back to synthesis order. This keeps the diagram readable and deterministic. - Artists carry gids (HX:, Util:) so tests can check the drawing structurally. Validation: tests/test_hxn.py gains an ordering unit test (including the hot-stream reversal and the cyclic fallback) and a structural test on the class doctest system; docstring example added. tests/test_hxn.py + hxn doctests: 17 passed. Rendered the doctest system and the full sugarcane network (HXN.units=None) and checked them against the reference figure. Canonical suite: 74 failed / 476 passed / 62 skipped; the 3 failures beyond the previous run (test_oilcane_O6/O8/O9, test_tire_modeling) also fail on the parent commit bbea7059 with this change stashed - they come from the sibling biorefineries/thermosteam clone state, not from biosteam. Co-Authored-By: Claude Fable 5 --- .../facilities/hxn/_heat_exchanger_network.py | 17 +- biosteam/facilities/hxn/hxn_synthesis.py | 214 +++++++++++++++++- tests/test_hxn.py | 56 +++++ 3 files changed, 285 insertions(+), 2 deletions(-) diff --git a/biosteam/facilities/hxn/_heat_exchanger_network.py b/biosteam/facilities/hxn/_heat_exchanger_network.py index 5edeaece..b828fd65 100644 --- a/biosteam/facilities/hxn/_heat_exchanger_network.py +++ b/biosteam/facilities/hxn/_heat_exchanger_network.py @@ -11,7 +11,7 @@ """ import biosteam as bst import numpy as np -from .hxn_synthesis import synthesize_network, StreamLifeCycle +from .hxn_synthesis import synthesize_network, StreamLifeCycle, plot_pinch_diagram from warnings import warn __all__ = ('HeatExchangerNetwork',) @@ -199,6 +199,8 @@ def _cost(self): self.force_ideal_thermo, self.avoid_recycle, self.sort_hus_by_T) new_HXs = HXs_hot_side + HXs_cold_side + self.new_HXs_hot_side = HXs_hot_side + self.new_HXs_cold_side = HXs_cold_side self.cold_indices = cold_indices self.original_heat_exchangers = hxs self.new_HXs = new_HXs @@ -370,6 +372,19 @@ def _get_stream_life_cycles(self): self.stream_life_cycles = stream_life_cycles return stream_life_cycles + def plot_pinch_diagram(self, file=None, **kwargs): + """ + Draw the pinch diagram of the synthesized network; see + :func:`~biosteam.facilities.hxn.hxn_synthesis.plot_pinch_diagram` + for the keyword arguments. Returns the matplotlib figure and axes. + """ + if not hasattr(self, 'stream_life_cycles'): self._get_stream_life_cycles() + return plot_pinch_diagram( + self.stream_life_cycles, self.inlet_Ts, self.outlet_Ts, + self.new_HXs_hot_side, self.new_HXs_cold_side, + Qmin=self.Qmin, file=file, **kwargs, + ) + def get_original_hxs_associated_with_streams(self): # pragma: no cover original_units = self.system.units original_heat_utils = self.original_heat_utils diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 216485d8..37e2559a 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -11,12 +11,13 @@ @author: sarangbhagwat """ from collections import namedtuple +import heapq import numpy as np import biosteam as bst from warnings import warn __all__ = ('StreamLifeCycle', 'ProblemTable', 'problem_table', - 'synthesize_network') + 'synthesize_network', 'plot_pinch_diagram') class LifeStage: @@ -671,3 +672,214 @@ def get_T_transient_hot_side(index): T_out_arr, pinch_T_arr, C_flow_vector, hx_utils_rearranged, streams_inlet, stream_HXs_dict,\ hot_indices, cold_indices + + +# Pinch diagram + +def _order_exchanger_columns(hxs, stream_life_cycles): + """ + Order heat exchangers left to right so that every stream meets its + exchangers in flow direction (cold streams flow left to right, hot streams + right to left). The per-stream stage orders define a precedence graph; + a topological sort (Kahn's algorithm, ties broken by the given order) + yields a consistent layout. Contradictory constraints, which would need a + stream to flow backwards, fall back to the given order. + """ + hxs = list(hxs) + position = {hx: i for i, hx in enumerate(hxs)} + successors = {hx: [] for hx in hxs} + N_predecessors = {hx: 0 for hx in hxs} + for life_cycle in stream_life_cycles: + stages = [i.unit for i in life_cycle.life_cycle if i.unit in position] + if not life_cycle.cold: stages.reverse() + for a, b in zip(stages, stages[1:]): + if b not in successors[a]: + successors[a].append(b) + N_predecessors[b] += 1 + ready = [position[hx] for hx in hxs if not N_predecessors[hx]] + heapq.heapify(ready) + ordered = [] + while ready: + hx = hxs[heapq.heappop(ready)] + ordered.append(hx) + for other in successors[hx]: + N_predecessors[other] -= 1 + if not N_predecessors[other]: heapq.heappush(ready, position[other]) + return ordered if len(ordered) == len(hxs) else hxs + +def _format_H(H): + mantissa, exponent = f'{H:.2e}'.split('e') + return f'{mantissa}E{int(exponent)}' + +def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, + hot_side_HXs, cold_side_HXs, Qmin=1e-3, + ax=None, file=None, dpi=300): + """ + Draw a pinch diagram of a synthesized heat exchanger network: cold + streams (blue, flowing left to right) above hot streams (red, flowing + right to left), one vertical connector per process heat exchanger with + its duty, a dashed pinch line separating the cold-side from the + hot-side exchangers, and circles marking the utility exchangers that + bring each stream to its outlet temperature. + + Parameters + ---------- + stream_life_cycles : list[StreamLifeCycle] + One per stream, as built by HeatExchangerNetwork. + inlet_Ts, outlet_Ts : array-like + Stream inlet and outlet temperatures [K], indexed like the life cycles. + hot_side_HXs, cold_side_HXs : list[HXprocess] + Process exchangers above and below the pinch. + Qmin : float, optional + Utility exchangers with a duty at or below this [kJ/hr] are not marked. + ax : matplotlib.axes.Axes, optional + Axes to draw on; a new figure is created if not given. + file : str, optional + If given, the figure is saved to this path. + dpi : int, optional + Resolution used when saving. + + Returns + ------- + fig, ax : The matplotlib figure and axes. + + Notes + ----- + Temperatures are shown in degC and heat flows in kJ/hr at the inlet and + outlet of each stream. Exchanger columns on each side of the pinch are + ordered so that each stream meets them in flow direction whenever the + network allows it. + + Examples + -------- + >>> import biosteam as bst + >>> bst.settings.set_thermo(['Water', 'Methanol', 'Glycerol']) + >>> feed1 = bst.Stream('feed1', flow=(8000, 100, 25)) + >>> feed2 = bst.Stream('feed2', flow=(10000, 1000, 10)) + >>> D1 = bst.ShortcutColumn('D1', ins=feed1, + ... outs=('distillate', 'bottoms_product'), + ... LHK=('Methanol', 'Water'), + ... y_top=0.99, x_bot=0.01, k=2, + ... is_divided=True) + >>> D1_H1 = bst.HXutility('D1_H1', ins = D1.outs[1], T = 300) + >>> D1_H2 = bst.HXutility('D1_H2', ins = D1.outs[0], T = 300) + >>> F1 = bst.Flash('F1', ins=feed2, + ... outs=('vapor', 'liquid'), V = 0.9, P = 101325) + >>> HXN = bst.HeatExchangerNetwork('HXN', T_min_app = 5.) + >>> sys = bst.System.from_units('sys', units=[D1, D1_H1, D1_H2, F1, HXN]) + >>> sys.simulate() + >>> fig, ax = HXN.plot_pinch_diagram() + >>> connectors = [i for i in ax.findobj() if (i.get_gid() or '').startswith('HX:')] + >>> len(connectors) == len(HXN.new_HXs) + True + + """ + import matplotlib.pyplot as plt + cold_color, hot_color = '#2e6db4', '#d62728' + cold_bg, hot_bg = '#e6f0fa', '#fbe9e7' + process_hxs = set(hot_side_HXs) | set(cold_side_HXs) + # Stream index and stage of each side of every process exchanger, by identity + hx_streams = {hx: {} for hx in process_hxs} + for index, life_cycle in enumerate(stream_life_cycles): + for stage in life_cycle.life_cycle: + if stage.unit in hx_streams: + hx_streams[stage.unit][life_cycle.cold] = (index, stage) + cold_side_HXs = _order_exchanger_columns(cold_side_HXs, stream_life_cycles) + hot_side_HXs = _order_exchanger_columns(hot_side_HXs, stream_life_cycles) + columns = cold_side_HXs + hot_side_HXs + N_cs = len(cold_side_HXs) + N_columns = len(columns) + # x layout: 0 stream ends | 1 cold utilities | 2..N_cs+1 cold side | + # pinch | N_cs+2..N+1 hot side | N+2 hot utilities | N+3 stream ends + x_start, x_cold_util = 0., 1. + x_columns = {hx: 2. + i for i, hx in enumerate(columns)} + x_pinch = N_cs + 1.5 + x_hot_util = N_columns + 2. + x_end = N_columns + 3. + # y layout: cold streams on top, hot streams below, duty labels in between + cold_streams = [i for i, lc in enumerate(stream_life_cycles) if lc.cold] + hot_streams = [i for i, lc in enumerate(stream_life_cycles) if not lc.cold] + N_hot = len(hot_streams) + N_cold = len(cold_streams) + gap = 2.5 + y = {} + for k, i in enumerate(hot_streams): y[i] = N_hot - k + for k, i in enumerate(cold_streams): y[i] = N_hot + gap + N_cold - k + y_label = N_hot + (gap + 1.) / 2. + y_top = N_hot + gap + N_cold + 1. + y_bottom = 0. + if ax is None: + fig, ax = plt.subplots( + figsize=(max(6., 0.75 * (N_columns + 4) + 3.), 0.4 * y_top + 1.) + ) + else: + fig = ax.figure + # Background and pinch line + x_min, x_max = x_start - 1.8, x_end + 1.8 + ax.axvspan(x_min, x_pinch, color=cold_bg, lw=0, zorder=0) + ax.axvspan(x_pinch, x_max, color=hot_bg, lw=0, zorder=0) + ax.axvline(x_pinch, color='k', ls='--', lw=1, zorder=1) + ax.text(x_min + 0.2, y_bottom + 0.1, 'Cold side', color=cold_color, + weight='bold', ha='left', va='bottom') + ax.text(x_max - 0.2, y_bottom + 0.1, 'Hot side', color=hot_color, + weight='bold', ha='right', va='bottom') + # Column headers + header_kwargs = dict(ha='center', va='bottom', weight='bold', fontsize=8) + for x_T, x_H in ((x_start - 1.3, x_start - 0.6), (x_end + 0.6, x_end + 1.3)): + ax.text(x_T, y_top, 'T\n[°C]', **header_kwargs) + ax.text(x_H, y_top, 'H\n[kJ·h$^{-1}$]', **header_kwargs) + ax.text(x_start - 0.3, y_label, 'ΔH\n[kJ·h$^{-1}$]', + ha='right', va='center', weight='bold', fontsize=8) + # Streams + value_kwargs = dict(ha='center', va='center', fontsize=8) + for index, life_cycle in enumerate(stream_life_cycles): + cold = life_cycle.cold + color = cold_color if cold else hot_color + yi = y[index] + stages = life_cycle.life_cycle + H_in = stages[0].H_in if stages else float('nan') + H_out = stages[-1].H_out if stages else float('nan') + T_in = inlet_Ts[index] - 273.15 + T_out = outlet_Ts[index] - 273.15 + # T is the outer column on the left and the inner column on the right + T_left, H_left, T_right, H_right = ( + (T_in, H_in, T_out, H_out) if cold else (T_out, H_out, T_in, H_in) + ) + x_in, x_out, sign = (x_start, x_end, 1) if cold else (x_end, x_start, -1) + ax.annotate('', xy=(x_out, yi), xytext=(x_in, yi), + arrowprops=dict(arrowstyle='-|>', color=color, lw=1.2, + shrinkA=0, shrinkB=0), zorder=2) + ax.text(x_start - 1.3, yi, f'{T_left:.1f}', color=color, **value_kwargs) + ax.text(x_start - 0.6, yi, _format_H(H_left), color=color, **value_kwargs) + ax.text(x_end + 0.6, yi, f'{T_right:.1f}', color=color, **value_kwargs) + ax.text(x_end + 1.3, yi, _format_H(H_right), color=color, **value_kwargs) + ax.text(x_in + sign * 0.3, yi + 0.12, str(index), color=color, + ha='center', va='bottom', weight='bold', fontsize=9) + # Utility exchangers + x_util = x_hot_util if cold else x_cold_util + for stage in stages: + unit = stage.unit + if unit in process_hxs: continue + if abs(stage.H_out - stage.H_in) <= Qmin: continue + ax.plot([x_util], [yi], 'o', mfc='w', mec=color, mew=1.2, ms=6, + zorder=4, gid='Util:' + unit.ID) + # Process exchangers + for hx in columns: + streams = hx_streams[hx] + if len(streams) != 2: + warn(f'{hx.ID} is not in exactly one hot and one cold stream ' + 'life cycle; it is not drawn', RuntimeWarning) + continue + (i_cold, stage_cold), (i_hot, stage_hot) = streams[True], streams[False] + x = x_columns[hx] + Q = abs(stage_hot.H_in - stage_hot.H_out) + ax.plot([x, x], [y[i_hot], y[i_cold]], '-o', color='k', mfc='w', + mew=1.2, ms=6, lw=1.2, zorder=3, gid='HX:' + hx.ID) + ax.text(x, y_label, _format_H(Q), rotation=90, ha='center', + va='center', fontsize=8, zorder=5, + bbox=dict(boxstyle='square,pad=0.25', fc='w', ec='k', lw=0.8)) + ax.set_xlim(x_min, x_max) + ax.set_ylim(y_bottom, y_top + 1.2) + ax.set_axis_off() + if file: fig.savefig(file, dpi=dpi, bbox_inches='tight') + return fig, ax diff --git a/tests/test_hxn.py b/tests/test_hxn.py index 5520b6fe..28fdb5df 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -253,6 +253,60 @@ def test_synthetic_network_reaches_MER(): # respects T_min_app; with non-equilibrium inlets the table is conservative assert actual_heat >= table.hot_util_load * (1 - 1e-3) +# --- pinch diagram ----------------------------------------------------------- + +class _FakeStage: + def __init__(self, unit): self.unit = unit + +class _FakeLifeCycle: + def __init__(self, units, cold=True): + self.cold = cold + self.life_cycle = [_FakeStage(u) for u in units] + +def test_pinch_diagram_column_order_follows_stream_direction(): + from biosteam.facilities.hxn.hxn_synthesis import _order_exchanger_columns + h1, h2, h3 = 'h1', 'h2', 'h3' + # stream A visits h2 then h1; stream B visits h1 then h3 -> h2, h1, h3 + cycles = [_FakeLifeCycle([h2, h1]), _FakeLifeCycle([h1, h3])] + assert _order_exchanger_columns([h1, h2, h3], cycles) == [h2, h1, h3] + # exchangers not in the requested subset are ignored, order is stable + assert _order_exchanger_columns([h3, h1], cycles) == [h1, h3] + # a hot stream flows right to left, so its stage order is reversed: + # hot stream visits h1 then h3 -> h3 left of h1 + cycles = [_FakeLifeCycle([h2, h1]), _FakeLifeCycle([h1, h3], cold=False)] + assert _order_exchanger_columns([h1, h2, h3], cycles) == [h2, h3, h1] + # contradictory constraints (a cycle) fall back to the given order + cycles = [_FakeLifeCycle([h1, h2]), _FakeLifeCycle([h2, h1])] + assert _order_exchanger_columns([h2, h1], cycles) == [h2, h1] + +def _gid_artists(ax, prefix): + return [a for a in ax.findobj() if (a.get_gid() or '').startswith(prefix)] + +def test_pinch_diagram_doctest_system(): + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt + sys, HXN, feed = build_system() + sys.simulate() + assert HXN.new_HXs_hot_side + HXN.new_HXs_cold_side == HXN.new_HXs + fig, ax = HXN.plot_pinch_diagram() + try: + # one connector per process exchanger + connectors = _gid_artists(ax, 'HX:') + assert {a.get_gid() for a in connectors} == {'HX:' + hx.ID for hx in HXN.new_HXs} + # one utility marker per utility exchanger with a duty above Qmin + utils = _gid_artists(ax, 'Util:') + expected = {'Util:' + hx.ID for hx in HXN.new_HX_utils + if abs(hx.outs[0].H - hx.ins[0].H) > HXN.Qmin} + assert {a.get_gid() for a in utils} == expected + # one row per stream, with inlet temperatures in degC + texts = {t.get_text() for t in ax.texts} + for T in HXN.inlet_Ts: assert f'{T - 273.15:.1f}' in texts + for T in HXN.outlet_Ts: assert f'{T - 273.15:.1f}' in texts + for i in range(len(HXN.inlet_Ts)): assert str(i) in texts + finally: + plt.close(fig) + if __name__ == '__main__': test_cache_network_matches_fresh_synthesis() test_cache_network_perturbed_feed() @@ -265,3 +319,5 @@ def test_synthetic_network_reaches_MER(): test_problem_table_non_monotone_stream_is_point_load() test_problem_table_point_load_cannot_heat_above_itself() test_synthetic_network_reaches_MER() + test_pinch_diagram_column_order_follows_stream_direction() + test_pinch_diagram_doctest_system() From bd508d76cbb1631587f86c17dcb3812b14ece650 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 19:54:36 -0700 Subject: [PATCH 07/26] label pinch diagram streams with their unit, auxiliary unit, and stream ID Stream indices alone do not say which process stream a row of the pinch diagram is. Add a label next to each index, ' - ()', with one toggle per part on plot_pinch_diagram: show_units (the unit that owns the stream's original heat exchanger, i.e. the main unit for auxiliary exchangers), show_auxiliary_units (the exchanger's name within that unit, e.g. 'condenser' or a dotted path for nested auxiliaries), and show_stream_IDs (the original exchanger's inlet stream ID; unnamed inlets add nothing). All default to True. The owner comes from Unit.owner and the auxiliary name from a recursive search of get_auxiliary_units_with_names(), so no unit or stream IDs are parsed (unlike get_original_hxs_associated_with_streams, which scans for '.' in IDs and special-cases unit classes). plot_pinch_diagram takes the per-stream original exchangers as a new original_hxs argument (required when any label part is on); HeatExchangerNetwork.plot_pinch_diagram passes original_heat_exchangers. Labels carry gid 'Label:'. Validation: new test_pinch_diagram_stream_labels (helper composition, figure labels, toggles off -> no labels); tests/test_hxn.py + hxn doctests 18 passed. Rendered the full sugarcane network to check nested auxiliary names. Canonical suite 74 failed / 477 passed / 62 skipped, same pre-existing failure set as the previous commit. Co-Authored-By: Claude Fable 5 --- .../facilities/hxn/_heat_exchanger_network.py | 3 +- biosteam/facilities/hxn/hxn_synthesis.py | 59 ++++++++++++++++++- tests/test_hxn.py | 41 +++++++++++++ 3 files changed, 101 insertions(+), 2 deletions(-) diff --git a/biosteam/facilities/hxn/_heat_exchanger_network.py b/biosteam/facilities/hxn/_heat_exchanger_network.py index b828fd65..01ca5023 100644 --- a/biosteam/facilities/hxn/_heat_exchanger_network.py +++ b/biosteam/facilities/hxn/_heat_exchanger_network.py @@ -382,7 +382,8 @@ def plot_pinch_diagram(self, file=None, **kwargs): return plot_pinch_diagram( self.stream_life_cycles, self.inlet_Ts, self.outlet_Ts, self.new_HXs_hot_side, self.new_HXs_cold_side, - Qmin=self.Qmin, file=file, **kwargs, + Qmin=self.Qmin, original_hxs=self.original_heat_exchangers, + file=file, **kwargs, ) def get_original_hxs_associated_with_streams(self): # pragma: no cover diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 37e2559a..d705b638 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -711,8 +711,43 @@ def _format_H(H): mantissa, exponent = f'{H:.2e}'.split('e') return f'{mantissa}E{int(exponent)}' +def _auxiliary_name(unit): + """ + Return the (dotted) name of an auxiliary unit within its owner, e.g. + 'condenser' or 'evaporators[0].heat_exchanger', or None if the unit is + not auxiliary. + """ + owner = unit.owner + if owner is unit: return None + def search(parent, prefix): + for name, aux in parent.get_auxiliary_units_with_names(): + if aux is unit: return prefix + name + if hasattr(aux, 'get_auxiliary_units_with_names'): + found = search(aux, prefix + name + '.') + if found: return found + return search(owner, '') or unit.ID.lstrip('.') + +def _stream_label(hx, show_units, show_auxiliary_units, show_stream_IDs): + """ + Label of a stream from its original heat exchanger `hx`: + ' - ()', with each part + optional. + """ + parts = [] + if show_units: parts.append(hx.owner.ID) + if show_auxiliary_units: + auxname = _auxiliary_name(hx) + if auxname: parts.append(auxname) + label = ' - '.join(parts) + if show_stream_IDs: + ID = hx.ins[0].ID + if ID: label = f'{label} ({ID})' if label else ID + return label + def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, hot_side_HXs, cold_side_HXs, Qmin=1e-3, + original_hxs=None, show_units=True, + show_auxiliary_units=True, show_stream_IDs=True, ax=None, file=None, dpi=300): """ Draw a pinch diagram of a synthesized heat exchanger network: cold @@ -732,6 +767,17 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, Process exchangers above and below the pinch. Qmin : float, optional Utility exchangers with a duty at or below this [kJ/hr] are not marked. + original_hxs : list[Unit], optional + The original heat exchanger of each stream (indexed like the life + cycles). Required for the stream labels below. + show_units : bool, optional + Label each stream with the unit operation that owns its original heat + exchanger (the main unit for auxiliary exchangers). + show_auxiliary_units : bool, optional + Label each stream with the name of its original heat exchanger within + the main unit (e.g. 'condenser'), if it is an auxiliary unit. + show_stream_IDs : bool, optional + Label each stream with the ID of the original heat exchanger's inlet. ax : matplotlib.axes.Axes, optional Axes to draw on; a new figure is created if not given. file : str, optional @@ -748,7 +794,8 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, Temperatures are shown in degC and heat flows in kJ/hr at the inlet and outlet of each stream. Exchanger columns on each side of the pinch are ordered so that each stream meets them in flow direction whenever the - network allows it. + network allows it. Stream labels read ' - ()' + next to the stream index at the inlet. Examples -------- @@ -775,6 +822,10 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, """ import matplotlib.pyplot as plt + show_labels = show_units or show_auxiliary_units or show_stream_IDs + if show_labels and original_hxs is None: + raise ValueError('original_hxs is required to label streams with ' + 'units, auxiliary units, or stream IDs') cold_color, hot_color = '#2e6db4', '#d62728' cold_bg, hot_bg = '#e6f0fa', '#fbe9e7' process_hxs = set(hot_side_HXs) | set(cold_side_HXs) @@ -855,6 +906,12 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, ax.text(x_end + 1.3, yi, _format_H(H_right), color=color, **value_kwargs) ax.text(x_in + sign * 0.3, yi + 0.12, str(index), color=color, ha='center', va='bottom', weight='bold', fontsize=9) + if show_labels: + label = _stream_label(original_hxs[index], show_units, + show_auxiliary_units, show_stream_IDs) + ax.text(x_in + sign * 0.6, yi + 0.12, label, color=color, + ha='left' if cold else 'right', va='bottom', fontsize=7, + gid=f'Label:{index}') # Utility exchangers x_util = x_hot_util if cold else x_cold_util for stage in stages: diff --git a/tests/test_hxn.py b/tests/test_hxn.py index 28fdb5df..3efe5601 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -307,6 +307,46 @@ def test_pinch_diagram_doctest_system(): finally: plt.close(fig) +def test_pinch_diagram_stream_labels(): + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt + from biosteam.facilities.hxn.hxn_synthesis import _auxiliary_name, _stream_label + sys, HXN, feed = build_system() + sys.simulate() + D1 = bst.main_flowsheet.unit.D0 + D1_H1 = bst.main_flowsheet.unit.D0_H1 + assert _auxiliary_name(D1.condenser) == 'condenser' + assert _auxiliary_name(D1_H1) is None + # label composition + assert _stream_label(D1.condenser, True, True, False) == 'D0 - condenser' + assert _stream_label(D1.condenser, True, False, False) == 'D0' + assert _stream_label(D1.condenser, False, True, False) == 'condenser' + assert _stream_label(D1_H1, True, True, True) == 'D0_H1 (' + D1_H1.ins[0].ID + ')' + assert _stream_label(D1_H1, False, False, True) == D1_H1.ins[0].ID + assert _stream_label(D1_H1, False, False, False) == '' + # an unnamed inlet adds nothing + assert _stream_label(D1.reboiler, True, True, True) == 'D0 - reboiler' + # every stream gets a label on the figure; toggles remove them + fig, ax = HXN.plot_pinch_diagram() + try: + labels = {a.get_gid(): a.get_text() for a in _gid_artists(ax, 'Label:')} + hxs = HXN.original_heat_exchangers + assert labels == { + f'Label:{i}': _stream_label(hx, True, True, True) + for i, hx in enumerate(hxs) + } + assert any(text.startswith('D0 - condenser') for text in labels.values()) + assert any(text == 'F1 - heat_exchanger (feed_flash)' for text in labels.values()) + finally: + plt.close(fig) + fig, ax = HXN.plot_pinch_diagram(show_units=False, show_auxiliary_units=False, + show_stream_IDs=False) + try: + assert not _gid_artists(ax, 'Label:') + finally: + plt.close(fig) + if __name__ == '__main__': test_cache_network_matches_fresh_synthesis() test_cache_network_perturbed_feed() @@ -321,3 +361,4 @@ def test_pinch_diagram_doctest_system(): test_synthetic_network_reaches_MER() test_pinch_diagram_column_order_follows_stream_direction() test_pinch_diagram_doctest_system() + test_pinch_diagram_stream_labels() From 60fd3303dbd1c6674f7db84f0ab5a47c49f2f29e Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 19:56:14 -0700 Subject: [PATCH 08/26] add legend to the HXN pinch diagram New show_legend toggle (default True) on plot_pinch_diagram draws a three-column legend below the axes with proxy handles for the six symbols: cold stream, hot stream, process heat exchange, hot utility, cold utility, and the pinch line. Placed with bbox_to_anchor below the axes so it never overlaps the stream rows; savefig already uses bbox_inches='tight'. Validation: new test_pinch_diagram_legend (entries and order; toggle off -> no legend); tests/test_hxn.py + hxn doctests 19 passed; sugarcane network re-rendered. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 22 +++++++++++++++++++++- tests/test_hxn.py | 22 ++++++++++++++++++++++ 2 files changed, 43 insertions(+), 1 deletion(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index d705b638..26be6b33 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -748,7 +748,7 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, hot_side_HXs, cold_side_HXs, Qmin=1e-3, original_hxs=None, show_units=True, show_auxiliary_units=True, show_stream_IDs=True, - ax=None, file=None, dpi=300): + show_legend=True, ax=None, file=None, dpi=300): """ Draw a pinch diagram of a synthesized heat exchanger network: cold streams (blue, flowing left to right) above hot streams (red, flowing @@ -778,6 +778,8 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, the main unit (e.g. 'condenser'), if it is an auxiliary unit. show_stream_IDs : bool, optional Label each stream with the ID of the original heat exchanger's inlet. + show_legend : bool, optional + Add a legend of the symbols below the diagram. ax : matplotlib.axes.Axes, optional Axes to draw on; a new figure is created if not given. file : str, optional @@ -935,6 +937,24 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, ax.text(x, y_label, _format_H(Q), rotation=90, ha='center', va='center', fontsize=8, zorder=5, bbox=dict(boxstyle='square,pad=0.25', fc='w', ec='k', lw=0.8)) + if show_legend: + from matplotlib.lines import Line2D + handles = [ + Line2D([], [], color=cold_color, lw=1.2, marker='>', markevery=[-1], + ms=5, label='Cold stream'), + Line2D([], [], color=hot_color, lw=1.2, marker='<', markevery=[0], + ms=5, label='Hot stream'), + Line2D([], [], color='k', lw=1.2, marker='o', mfc='w', mew=1.2, + ms=6, label='Process heat exchange'), + Line2D([], [], ls='', marker='o', mfc='w', mec=hot_color, mew=1.2, + ms=6, label='Hot utility'), + Line2D([], [], ls='', marker='o', mfc='w', mec=cold_color, mew=1.2, + ms=6, label='Cold utility'), + Line2D([], [], color='k', ls='--', lw=1, label='Pinch'), + ] + ax.legend(handles=handles, loc='upper center', bbox_to_anchor=(0.5, 0.), + ncol=3, fontsize=7, frameon=False, handlelength=2.5, + columnspacing=1.5) ax.set_xlim(x_min, x_max) ax.set_ylim(y_bottom, y_top + 1.2) ax.set_axis_off() diff --git a/tests/test_hxn.py b/tests/test_hxn.py index 3efe5601..d5da3392 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -347,6 +347,27 @@ def test_pinch_diagram_stream_labels(): finally: plt.close(fig) +def test_pinch_diagram_legend(): + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt + sys, HXN, feed = build_system() + sys.simulate() + fig, ax = HXN.plot_pinch_diagram() + try: + legend = ax.get_legend() + assert legend is not None + labels = [t.get_text() for t in legend.get_texts()] + assert labels == ['Cold stream', 'Hot stream', 'Process heat exchange', + 'Hot utility', 'Cold utility', 'Pinch'] + finally: + plt.close(fig) + fig, ax = HXN.plot_pinch_diagram(show_legend=False) + try: + assert ax.get_legend() is None + finally: + plt.close(fig) + if __name__ == '__main__': test_cache_network_matches_fresh_synthesis() test_cache_network_perturbed_feed() @@ -362,3 +383,4 @@ def test_pinch_diagram_stream_labels(): test_pinch_diagram_column_order_follows_stream_direction() test_pinch_diagram_doctest_system() test_pinch_diagram_stream_labels() + test_pinch_diagram_legend() From ba7eb6b378a7cffc0b5aa7a4e52a054e53de53b0 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 20:15:18 -0700 Subject: [PATCH 09/26] fix pinch diagram utility colors; review fixes Code-review fixes for the pinch diagram: - Utility markers were colored by the stream they sit on, so hot utilities (on cold streams) were blue and cold utilities red - the opposite of the reference figure and of the diagram's own legend. Color them by utility type. test_pinch_diagram_legend now checks every Util marker's edge color against the legend handle for its type, so the legend and drawing cannot drift apart again. - Stream labels were drawn at the same zorder as the connectors and ran through the hot-side columns; draw them above with a white box. - Remove the dead empty-life-cycle branch (H = nan), which _format_H could not format anyway: every stream always has its utility stage. - HeatExchangerNetwork.plot_pinch_diagram raises a clear RuntimeError when called before simulation instead of an AttributeError from _get_stream_life_cycles; regression test added. - Close the figure in the docstring example; NumPy-style Returns section; comment documenting the gid contract used by the tests. tests/test_hxn.py + hxn doctests: 20 passed; sugarcane network re-rendered. Co-Authored-By: Claude Fable 5 --- .../facilities/hxn/_heat_exchanger_network.py | 4 ++- biosteam/facilities/hxn/hxn_synthesis.py | 25 ++++++++++++------- tests/test_hxn.py | 16 ++++++++++++ 3 files changed, 35 insertions(+), 10 deletions(-) diff --git a/biosteam/facilities/hxn/_heat_exchanger_network.py b/biosteam/facilities/hxn/_heat_exchanger_network.py index 01ca5023..8e732a45 100644 --- a/biosteam/facilities/hxn/_heat_exchanger_network.py +++ b/biosteam/facilities/hxn/_heat_exchanger_network.py @@ -378,7 +378,9 @@ def plot_pinch_diagram(self, file=None, **kwargs): :func:`~biosteam.facilities.hxn.hxn_synthesis.plot_pinch_diagram` for the keyword arguments. Returns the matplotlib figure and axes. """ - if not hasattr(self, 'stream_life_cycles'): self._get_stream_life_cycles() + if not hasattr(self, 'new_HXs_hot_side'): + raise RuntimeError('simulate the heat exchanger network before ' + 'plotting its pinch diagram') return plot_pinch_diagram( self.stream_life_cycles, self.inlet_Ts, self.outlet_Ts, self.new_HXs_hot_side, self.new_HXs_cold_side, diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 26be6b33..7eeb618b 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -789,7 +789,8 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, Returns ------- - fig, ax : The matplotlib figure and axes. + fig : matplotlib.figure.Figure + ax : matplotlib.axes.Axes Notes ----- @@ -821,9 +822,13 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, >>> connectors = [i for i in ax.findobj() if (i.get_gid() or '').startswith('HX:')] >>> len(connectors) == len(HXN.new_HXs) True + >>> import matplotlib.pyplot as plt + >>> plt.close(fig) """ import matplotlib.pyplot as plt + # Artists carry stable gids ('HX:', 'Util:', 'Label:') + # so the drawing can be checked structurally in tests. show_labels = show_units or show_auxiliary_units or show_stream_IDs if show_labels and original_hxs is None: raise ValueError('original_hxs is required to label streams with ' @@ -889,9 +894,9 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, cold = life_cycle.cold color = cold_color if cold else hot_color yi = y[index] - stages = life_cycle.life_cycle - H_in = stages[0].H_in if stages else float('nan') - H_out = stages[-1].H_out if stages else float('nan') + stages = life_cycle.life_cycle # never empty: each stream has a utility stage + H_in = stages[0].H_in + H_out = stages[-1].H_out T_in = inlet_Ts[index] - 273.15 T_out = outlet_Ts[index] - 273.15 # T is the outer column on the left and the inner column on the right @@ -913,15 +918,17 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, show_auxiliary_units, show_stream_IDs) ax.text(x_in + sign * 0.6, yi + 0.12, label, color=color, ha='left' if cold else 'right', va='bottom', fontsize=7, - gid=f'Label:{index}') - # Utility exchangers - x_util = x_hot_util if cold else x_cold_util + zorder=6, gid=f'Label:{index}', + bbox=dict(boxstyle='square,pad=0.15', fc='w', ec='none')) + # Utility exchangers: a cold stream ends in a hot utility (red), a + # hot stream in a cold utility (blue) + x_util, util_color = (x_hot_util, hot_color) if cold else (x_cold_util, cold_color) for stage in stages: unit = stage.unit if unit in process_hxs: continue if abs(stage.H_out - stage.H_in) <= Qmin: continue - ax.plot([x_util], [yi], 'o', mfc='w', mec=color, mew=1.2, ms=6, - zorder=4, gid='Util:' + unit.ID) + ax.plot([x_util], [yi], 'o', mfc='w', mec=util_color, mew=1.2, + ms=6, zorder=4, gid='Util:' + unit.ID) # Process exchangers for hx in columns: streams = hx_streams[hx] diff --git a/tests/test_hxn.py b/tests/test_hxn.py index d5da3392..214372d5 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -347,6 +347,11 @@ def test_pinch_diagram_stream_labels(): finally: plt.close(fig) +def test_pinch_diagram_requires_simulation(): + sys, HXN, feed = build_system() + with pytest.raises(RuntimeError, match='simulate'): + HXN.plot_pinch_diagram() + def test_pinch_diagram_legend(): import matplotlib matplotlib.use('Agg') @@ -360,6 +365,16 @@ def test_pinch_diagram_legend(): labels = [t.get_text() for t in legend.get_texts()] assert labels == ['Cold stream', 'Hot stream', 'Process heat exchange', 'Hot utility', 'Cold utility', 'Pinch'] + # utility markers are colored by utility type, consistent with the legend + handles = dict(zip(labels, legend.legend_handles)) + hot_util_color = handles['Hot utility'].get_markeredgecolor() + cold_util_color = handles['Cold utility'].get_markeredgecolor() + assert hot_util_color != cold_util_color + heaters = {hx.ID for hx in HXN.new_HX_utils if hx.outs[0].H > hx.ins[0].H} + for artist in _gid_artists(ax, 'Util:'): + heater = artist.get_gid()[len('Util:'):] in heaters + expected = hot_util_color if heater else cold_util_color + assert artist.get_markeredgecolor() == expected, artist.get_gid() finally: plt.close(fig) fig, ax = HXN.plot_pinch_diagram(show_legend=False) @@ -384,3 +399,4 @@ def test_pinch_diagram_legend(): test_pinch_diagram_doctest_system() test_pinch_diagram_stream_labels() test_pinch_diagram_legend() + test_pinch_diagram_requires_simulation() From 59864f4dc0d1889de194aaa7b73d56b9357de42c Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 20:43:01 -0700 Subject: [PATCH 10/26] align pinch diagram stream labels with the indices, above the exchanger circles The unit/stream label sat lower than the bold index (both were anchored with va='bottom' at different font sizes) and its white box could cover exchanger and utility circles on the stream line. Put index and label on a shared baseline (va='baseline') raised to yi + 0.25 so both sit in line and clear of the circles. tests/test_hxn.py + hxn doctests: 20 passed; sugarcane network re-rendered. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 7eeb618b..86086e7f 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -911,13 +911,16 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, ax.text(x_start - 0.6, yi, _format_H(H_left), color=color, **value_kwargs) ax.text(x_end + 0.6, yi, f'{T_right:.1f}', color=color, **value_kwargs) ax.text(x_end + 1.3, yi, _format_H(H_right), color=color, **value_kwargs) - ax.text(x_in + sign * 0.3, yi + 0.12, str(index), color=color, - ha='center', va='bottom', weight='bold', fontsize=9) + # Index and label share a baseline above the stream, clear of the + # exchanger circles + y_text = yi + 0.25 + ax.text(x_in + sign * 0.3, y_text, str(index), color=color, + ha='center', va='baseline', weight='bold', fontsize=9) if show_labels: label = _stream_label(original_hxs[index], show_units, show_auxiliary_units, show_stream_IDs) - ax.text(x_in + sign * 0.6, yi + 0.12, label, color=color, - ha='left' if cold else 'right', va='bottom', fontsize=7, + ax.text(x_in + sign * 0.6, y_text, label, color=color, + ha='left' if cold else 'right', va='baseline', fontsize=7, zorder=6, gid=f'Label:{index}', bbox=dict(boxstyle='square,pad=0.15', fc='w', ec='none')) # Utility exchangers: a cold stream ends in a hot utility (red), a From 1ab689ff209c89130da1df803fc71e4389ce569c Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sat, 22 Aug 2026 20:46:14 -0700 Subject: [PATCH 11/26] nudge pinch diagram stream labels up to read in line with the indices With a shared baseline the smaller label still reads slightly low next to the larger bold index; raise its baseline by 0.08 so the two appear vertically centered on each other. Co-Authored-By: Claude Fable 5 --- biosteam/facilities/hxn/hxn_synthesis.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 86086e7f..1041c205 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -919,7 +919,9 @@ def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, if show_labels: label = _stream_label(original_hxs[index], show_units, show_auxiliary_units, show_stream_IDs) - ax.text(x_in + sign * 0.6, y_text, label, color=color, + # the smaller label reads as centered with the index when its + # baseline is slightly higher + ax.text(x_in + sign * 0.6, y_text + 0.08, label, color=color, ha='left' if cold else 'right', va='baseline', fontsize=7, zorder=6, gid=f'Label:{index}', bbox=dict(boxstyle='square,pad=0.15', fc='w', ec='none')) From 38152bf4443fae3f161f77003fbb3c24136f08d0 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sun, 23 Aug 2026 00:00:12 -0700 Subject: [PATCH 12/26] add synthetic HXN regression tests guarding energy balance, MER targets, and documented heat recovery Ten synthetic systems of increasing complexity (2 to 10 process streams, built from simulated HXutility units; every case from the third on has phase-changing streams: total and partial condensers, boiling and partially boiling cold streams, mixed pressures, a threshold problem and a near-degenerate cascade). For each, the synthesized network must (i) close its energy balance to |error| < 0.1 % with no numerical RuntimeWarning escaping simulate(); (ii) never beat the problem-table MER targets computed on the same streams (a network below MER is a bookkeeping error), and satisfy actual_heat - actual_cool == net process duty; (iii) use no more hot or cold utility than documented in CASES (recorded at 1ab689ff by running the file directly), so a future change to hxn cannot silently make the synthesizer recover less heat. The recorded baselines also document where the greedy heuristic currently falls short of MER: cases 1-4 and 7 hit the target exactly; cases 8 and 9 are within 1 %; case 5 (boiling cold stream) uses 5.8e6 kJ/hr of hot utility where MER is 0, and case 6 uses 7.1e6 against an MER of 2.1e6. Case 10 is a strict xfail: synthesis emits a zero-duty exchanger (HX_8_2_cs, hot 355 K against cold 365 K, Q = 0) whose cold inlet is hotter than its hot inlet, and compute_LMTD then raises FloatingPointError on the log of a negative ratio. Fixing that flips the xfail into a failure that prompts recording the case's baseline. Validation: tests/test_hxn_regression.py -> 9 passed, 1 xfailed (5.7 s, not marked slow). Full CI-style suite -> 74 failed, 488 passed, 62 skipped, 1 xfailed; the 4 failures beyond the documented 70 (test_oilcane_O6/O8/O9: AttributeError inside the sibling biorefineries clone; test_tire: value drift, fails identically on unmodified master) are pre-existing stack drift since the baseline was measured against the pip thermosteam wheel. Co-Authored-By: Claude Fable 5 --- tests/test_hxn_regression.py | 239 +++++++++++++++++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 tests/test_hxn_regression.py diff --git a/tests/test_hxn_regression.py b/tests/test_hxn_regression.py new file mode 100644 index 00000000..de0fb93f --- /dev/null +++ b/tests/test_hxn_regression.py @@ -0,0 +1,239 @@ +# -*- coding: utf-8 -*- +# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules +# Copyright (C) 2020-, Yoel Cortes-Pena +# Copyright (C) 2026-, Sarang Bhagwat +# +# This module is under the UIUC open-source license. See +# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt +# for license details. +""" +Regression tests for heat exchanger network synthesis on synthetic systems. + +Ten synthetic systems of increasing complexity (all with phase-changing +streams from case 3 on). For each, the synthesized network must + +(i) close its energy balance (|error| < 0.1 %) without RuntimeWarnings, +(ii) never beat the minimum-energy-requirement (MER) targets of the problem + table computed on the same streams, and +(iii) recover at least as much heat as documented in ``CASES`` below, so that + no future change to ``hxn`` silently makes the synthesizer perform worse. + +The documented utility loads were recorded by running this file directly +(``python tests/test_hxn_regression.py`` prints them) at commit +``1ab689ff`` (branch ``hxn-pinch-diagram``). Improvements leave slack; a +maintainer lowers the numbers deliberately when a better network is +intended. Never raise them to make a failing test pass. +""" +import warnings +import pytest +import biosteam as bst +from numpy.testing import assert_allclose +from biosteam.facilities.hxn.hxn_synthesis import problem_table + +EB_TOLERANCE = 0.1 # percent +MER_RTOL = 1e-3 # network may not beat the MER target by more than this +DOC_RTOL = 1e-3 # network may not be worse than documented by more than this + +def utility_hx(ID, T, P, phase, T_out, rigorous=None, **flow): + """A simulated HXutility acting as one process stream (kmol/hr flows).""" + s = bst.Stream(ID + '_in', T=T, P=P, phase=phase, units='kmol/hr', **flow) + if rigorous is None: rigorous = phase == 'g' + hx = bst.HXutility(ID, ins=s, T=T_out, rigorous=rigorous) + hx.simulate() + return hx + +def boiling_hx(ID, T, P, T_out, **flow): + """A cold liquid stream heated past its bubble point (rigorous VLE).""" + return utility_hx(ID, T, P, 'l', T_out, rigorous=True, **flow) + +def setup(name, chemicals=('Water', 'Ethanol')): + bst.settings.set_thermo(list(chemicals), cache=True) + bst.main_flowsheet.set_flowsheet('test_hxn_regression_' + name) + +# --------------------------------------------------------------------------- +# Cases +# --------------------------------------------------------------------------- + +def case_01_two_liquids(): + """Hot liquid, cold liquid; trivial counter-current match.""" + setup('01') + return [utility_hx('H1', 400., 5e5, 'l', 320., Water=1000.), + utility_hx('C1', 300., 101325., 'l', 360., Water=1000.)], 5. + +def case_02_pinch_limited(): + """Cold target above the hot inlet: part of the heating must be utility.""" + setup('02') + return [utility_hx('H1', 360., 5e5, 'l', 320., Water=1000.), + utility_hx('C1', 300., 5e5, 'l', 380., Water=800.)], 5. + +def case_03_condenser_two_colds(): + """Condensing ethanol vapor against two cold liquids.""" + setup('03') + return [utility_hx('H1', 355., 101325., 'g', 340., Ethanol=400.), + utility_hx('C1', 300., 101325., 'l', 345., Water=1500.), + utility_hx('C2', 310., 101325., 'l', 340., Water=300., Ethanol=300.)], 5. + +def case_04_report_case(): + """The 4-stream report case: 2 colds, condensing hot, hot liquid.""" + setup('04') + return [utility_hx('C1', 300., 101325., 'l', 390., Water=2000.), + utility_hx('C2', 310., 101325., 'l', 345., Water=500., Ethanol=500.), + utility_hx('H1', 352., 101325., 'g', 340., Ethanol=300.), + utility_hx('H2', 420., 5e5, 'l', 320., Water=800.)], 5. + +def case_05_boiling_cold(): + """A cold stream that boils (water -> steam) and a condensing hot stream.""" + setup('05') + return [boiling_hx('C1', 330., 101325., 380., Water=300.), + utility_hx('C2', 300., 101325., 'l', 350., Water=1000.), + utility_hx('H1', 420., 5e5, 'g', 330., Water=250.), + utility_hx('H2', 400., 5e5, 'l', 310., Water=1500.)], 5. + +def case_06_mixed_pressures(): + """5-bar condensing hot against 1-atm boiling cold; T_min_app = 10.""" + setup('06') + return [utility_hx('H1', 430., 5e5, 'g', 400., Water=200.), + utility_hx('H2', 380., 5e5, 'l', 320., Water=1200.), + boiling_hx('C1', 340., 101325., 375., Water=150.), + utility_hx('C2', 300., 101325., 'l', 360., Ethanol=800.), + utility_hx('C3', 320., 101325., 'l', 390., Water=600.)], 10. + +def case_07_threshold(): + """Threshold problem: heating dominates so the cold target is ~0; + one hot stream condenses and subcools.""" + setup('07') + return [utility_hx('H1', 375., 101325., 'g', 310., Water=80.), + utility_hx('H2', 360., 101325., 'l', 330., Water=200.), + utility_hx('C1', 300., 101325., 'l', 370., Water=1500.), + utility_hx('C2', 305., 101325., 'l', 350., Ethanol=800.), + boiling_hx('C3', 340., 101325., 355., Ethanol=200.), + utility_hx('C4', 320., 101325., 'l', 360., Water=700.)], 5. + +def case_08_two_condensers(): + """Two condensers at different temperatures (ethanol 1 atm, water 2 bar) + against three colds, one of which boils.""" + setup('08') + return [utility_hx('H1', 355., 101325., 'g', 335., Ethanol=300.), + utility_hx('H2', 400., 2e5, 'g', 360., Water=150.), + utility_hx('H3', 390., 5e5, 'l', 330., Water=900.), + utility_hx('C1', 300., 101325., 'l', 345., Water=1200.), + boiling_hx('C2', 330., 101325., 370., Ethanol=250.), + utility_hx('C3', 310., 101325., 'l', 380., Water=700.)], 5. + +def case_09_near_degenerate(): + """Eight streams with two near-equal pinch candidates, a partially + condensing hot stream (wet outlet) and a partially boiling cold stream.""" + setup('09') + return [utility_hx('H1', 380., 101325., 'g', 372., Water=120.), # partial condensation + utility_hx('H2', 365., 101325., 'g', 330., Ethanol=250.), + utility_hx('H3', 410., 5e5, 'l', 340., Water=700.), + utility_hx('H4', 345., 101325., 'l', 305., Ethanol=900.), + boiling_hx('C1', 350., 101325., 373.5, Water=200.), # partial boiling + utility_hx('C2', 300., 101325., 'l', 340., Water=1500.), + boiling_hx('C3', 320., 101325., 352., Ethanol=300.), + utility_hx('C4', 335., 101325., 'l', 395., Water=500.)], 5. + +def case_10_ten_streams(): + """Ten streams mixing liquids, condensers, boilers, and pressures.""" + setup('10') + return [utility_hx('H1', 355., 101325., 'g', 320., Ethanol=300.), + utility_hx('H2', 420., 5e5, 'g', 340., Water=150.), + utility_hx('H3', 395., 5e5, 'l', 330., Water=1000.), + utility_hx('H4', 370., 101325., 'l', 310., Ethanol=700.), + utility_hx('H5', 380., 2e5, 'g', 375., Water=100.), # partial condensation + utility_hx('C1', 300., 101325., 'l', 360., Water=2000.), + boiling_hx('C2', 330., 101325., 380., Water=200.), + boiling_hx('C3', 320., 101325., 352., Ethanol=400.), + utility_hx('C4', 310., 101325., 'l', 345., Water=400., Ethanol=400.), + utility_hx('C5', 340., 101325., 'l', 390., Water=600.)], 5. + +# name -> (builder, documented hot utility load [kJ/hr], documented cold utility load [kJ/hr]) +# Documented values recorded at 1ab689ff (see module docstring). +CASES = { + 'case_01_two_liquids': (case_01_two_liquids, 0, 1.53912e+06), + 'case_02_pinch_limited': (case_02_pinch_limited, 1.81522e+06, 0), + 'case_03_condenser_two_colds': (case_03_condenser_two_colds, 0, 9.49905e+06), + 'case_04_report_case': (case_04_report_case, 2.37319e+06, 3.56871e+06), + 'case_05_boiling_cold': (case_05_boiling_cold, 5.8433e+06, 1.04356e+07), + 'case_06_mixed_pressures': (case_06_mixed_pressures, 7.05541e+06, 4.93079e+06), + 'case_07_threshold': (case_07_threshold, 1.85977e+07, 0), + 'case_08_two_condensers': (case_08_two_condensers, 3.02237e+06, 7.36431e+06), + 'case_09_near_degenerate': (case_09_near_degenerate, 1.40965e+07, 9.66427e+06), + 'case_10_ten_streams': (case_10_ten_streams, None, None), +} + +# --------------------------------------------------------------------------- +# Harness +# --------------------------------------------------------------------------- + +def synthesize(builder): + units, T_min_app = builder() + HXN = bst.HeatExchangerNetwork('HXN', T_min_app=T_min_app) + sys = bst.System.from_units('sys', units=[*units, HXN]) + with warnings.catch_warnings(): + warnings.simplefilter('error', RuntimeWarning) + # thermosteam registry bookkeeping on temporary stream copies; not numerical + warnings.filterwarnings('ignore', message='.*has been replaced in registry', + category=RuntimeWarning) + sys.simulate() + return units, HXN, T_min_app + +def mer_targets(units, T_min_app): + hus = [hx.heat_utilities[0] for hx in units] + hus.sort(key=lambda hu: hu.duty) + streams_inlet = [hu.unit.ins[0].copy() for hu in hus] + streams_quenched = [hu.unit.outs[0].copy() for hu in hus] + for s in streams_quenched: s.vle(H=s.H, P=s.P) + is_hot = [hu.duty < 0 for hu in hus] + table = problem_table(streams_inlet, streams_quenched, is_hot, T_min_app) + return table.hot_util_load, table.cold_util_load + +def actual_loads(HXN): + hus = [hu for hx in HXN.new_HX_utils for hu in hx.heat_utilities] + heat = sum(hu.unit_duty for hu in hus if hu.unit_duty > 0) + cool = -sum(hu.unit_duty for hu in hus if hu.unit_duty < 0) + return heat, cool + +# Cases that currently crash inside synthesis. Strict xfail: once the bug is +# fixed the test fails, prompting the maintainer to record the case's baseline. +KNOWN_FAILURES = { + # The synthesizer emits a zero-duty exchanger (HX_8_2_cs: H1 at 355 K + # against C3 at 365 K, Q = 0) whose cold inlet is hotter than its hot + # inlet; compute_LMTD then takes log of a negative ratio. + 'case_10_ten_streams': FloatingPointError, +} + +@pytest.mark.parametrize('name', [ + pytest.param(name, marks=pytest.mark.xfail(raises=KNOWN_FAILURES[name], strict=True, + reason='synthesizer emits a zero-duty exchanger with crossed temperatures')) + if name in KNOWN_FAILURES else name + for name in CASES +]) +def test_hxn_regression(name): + builder, doc_heat, doc_cool = CASES[name] + units, HXN, T_min_app = synthesize(builder) + # (i) energy balance + assert abs(HXN.energy_balance_percent_error) < EB_TOLERANCE, name + # (ii) MER targets are a lower bound; energy identity holds + heat, cool = actual_loads(HXN) + hot_target, cold_target = mer_targets(units, T_min_app) + net_duty = sum(hx.heat_utilities[0].unit_duty for hx in units) + assert heat >= hot_target * (1 - MER_RTOL), (name, heat, hot_target) + assert cool >= cold_target * (1 - MER_RTOL), (name, cool, cold_target) + assert_allclose(heat - cool, net_duty, rtol=1e-3, err_msg=name) + # (iii) never worse than documented + assert doc_heat is not None and doc_cool is not None, f'{name}: baseline not recorded' + assert heat <= doc_heat * (1 + DOC_RTOL) + 1e-9, (name, heat, doc_heat) + assert cool <= doc_cool * (1 + DOC_RTOL) + 1e-9, (name, cool, doc_cool) + +if __name__ == '__main__': + for name, (builder, *_) in CASES.items(): + if name in KNOWN_FAILURES: + print(f"{name}: known failure ({KNOWN_FAILURES[name].__name__})") + continue + units, HXN, T_min_app = synthesize(builder) + heat, cool = actual_loads(HXN) + hot_target, cold_target = mer_targets(units, T_min_app) + print(f"{name}: heat={heat:.6g} cool={cool:.6g} " + f"(MER hot={hot_target:.6g} cold={cold_target:.6g}; " + f"EB error={HXN.energy_balance_percent_error:.4f}%)") From 75f1402ac280f444fd60dea7661c1b971c6a729f Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sun, 23 Aug 2026 00:37:19 -0700 Subject: [PATCH 13/26] fix HXN synthesis for non-equilibrium inlets, stale network ordering, and H_lim at the bubble point Regression case 10 (tests/test_hxn_regression.py) crashed in compute_LMTD with a zero-duty exchanger whose cold inlet was hotter than its hot inlet. Tracing it back exposed three independent defects, each fixed at its cause: 1. Phantom pinch loads for non-equilibrium inlets (hxn_synthesis.py). load_duties() and the transient pinch-state setup in synthesize_network() flashed each stream at its pinch temperature and took that equilibrium enthalpy at face value. A non-rigorous HXutility can carry a superheated liquid (ethanol at 370 K, 1 atm, H = 6.4e6 kJ/hr); flashing it at the 355 K pinch yields vapor with H = 32.0e6, and abs(H_pinch - H_in) turned that into a 25.6e6 kJ/hr "cooling load" above the pinch for a stream whose whole duty is 5.45e6. Exchangers were then synthesized against a transient stream carrying latent heat the real stream does not have; rewired with the real inlet they behaved differently, overheating a cold stream and leaving a downstream match with crossed, zero-duty inlets. New pinch_state() flashes at the pinch T and, when the result lies outside [min(H_in, H_out), max(H_in, H_out)], re-flashes at the clipped enthalpy, so the hot-side and cold-side loads split |H_in - H_out| exactly by construction (the abs() is gone). This is the synthesizer's counterpart of the clipping the problem table got in 08e873c5. 2. HXN_sys path in synthesis order (_heat_exchanger_network.py). _cost built bst.System(path=new_HXs + new_HX_utils). Hot-side exchangers are synthesized before the cold-side exchangers that feed them after the life-cycle rewiring, and with no recycle declared the system ran the path once, leaving those exchangers with stale inlets (an energy-balance residual equal to the upstream duty change). The path is now built with tmo.Network.from_units(all_units, interaction=False) and System._from_network, which orders units by their connections and detects the genuine loops in larger networks for the fixed-point convergence that was already configured. interaction=False is required: HXprocess is an interaction unit and the default strips those out and disconnects them. 3. heat_exchange_to_condition ignored H_lim at the bubble point (heat_transfer.py). When the temperature limit lands within 1e-3 K of the stream's bubble point (e.g. T_hot_in - dT = 373.124 K for water at 1 atm) the outlet was set to the saturated phase and the enthalpy limit was never applied, so a cold stream's apparent capacity became its full vaporization and it overshot its enthalpy target; its "heating" utility then had to cool it back. The limit is now applied in that branch too, by VLE since the clipped state is two-phase. Also in counter_current_heat_exchange, both no-exchange early exits did s1_in.copy_like(s1_out), overwriting an inlet with the already modified outlet (observed rewriting a superheated-liquid inlet to vapor); corrected to s1_out.copy_like(s1_in). Tests: tests/test_heat_exchange.py (new) covers H_lim at the bubble point for heat_exchange_to_condition and HXprocess, and inlet immutability; tests/test_hxn.py gains a load_duties/pinch_state energy-conservation test for a non-equilibrium inlet. Case 10 loses its xfail and records its baseline (hot 1.40742e7, cold 8.06488e6 kJ/hr, both above MER, energy balance error 0.0000 %); the H5 input is corrected to 1 atm (it was a subcooled vapor at 2 bar). Cases 1-9 are bit-identical to their baselines. Validation: targeted HX/HXN tests and doctests -> 37 passed. Full CI-style suite -> 74 failed, 493 passed, 62 skipped: exactly the same 74 pre-existing failures as the previous run, +5 passed. Co-Authored-By: Claude Fable 5 --- .../facilities/hxn/_heat_exchanger_network.py | 11 ++- biosteam/facilities/hxn/hxn_synthesis.py | 42 ++++++++-- biosteam/units/design_tools/heat_transfer.py | 13 ++- tests/test_heat_exchange.py | 82 +++++++++++++++++++ tests/test_hxn.py | 30 ++++++- tests/test_hxn_regression.py | 32 ++------ 6 files changed, 175 insertions(+), 35 deletions(-) create mode 100644 tests/test_heat_exchange.py diff --git a/biosteam/facilities/hxn/_heat_exchanger_network.py b/biosteam/facilities/hxn/_heat_exchanger_network.py index 8e732a45..55be67ff 100644 --- a/biosteam/facilities/hxn/_heat_exchanger_network.py +++ b/biosteam/facilities/hxn/_heat_exchanger_network.py @@ -10,6 +10,7 @@ @author: sarangbhagwat and yoelcp """ import biosteam as bst +import thermosteam as tmo import numpy as np from .hxn_synthesis import synthesize_network, StreamLifeCycle, plot_pinch_diagram from warnings import warn @@ -225,7 +226,15 @@ def _cost(self): unit = i.unit if s_out: unit.ins[i.index] = s_out s_out = unit.outs[i.index] - self.HXN_sys = sys = bst.System(ID=None, path=all_units) + # Order the path by the rewired stream connections (and + # detect recycle loops) rather than using synthesis order: a + # hot-side exchanger is synthesized before the cold-side + # exchangers that feed it, and a single pass in synthesis + # order would leave it with stale inlets. HXprocess units are + # interaction units, which Network.from_units strips out (and + # disconnects) by default; keep them with interaction=False. + network = tmo.Network.from_units(all_units, interaction=False) + self.HXN_sys = sys = bst.System._from_network(None, network) sys.set_tolerance(method='fixedpoint', subsystems=True) original_purchase_costs = [hx.purchase_cost for hx in hxs] diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 1041c205..8e633449 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -368,16 +368,39 @@ def temperature_interval_pinch_analysis(hus, streams_quenched +def pinch_state(stream_in, H_in, H_out, T_pinch): + """ + Return a copy of `stream_in` in the state it has when it crosses the + pinch, with enthalpy guaranteed to lie within [min(H_in, H_out), + max(H_in, H_out)]. + + The copy is first flashed at `T_pinch`. If the resulting equilibrium + enthalpy lies outside the stream's own enthalpy range the stream never + actually passes through that state: a non-equilibrium inlet (e.g. a + superheated liquid from a non-rigorous HXutility) or outlet has less + (or more) enthalpy than the equilibrium fluid at the pinch. The copy is + then flashed at the nearer end of the range instead, so the hot-side + and cold-side loads split `|H_in - H_out|` exactly and the transient + stream used for matching never carries heat the real stream does not + have. This is the synthesizer's counterpart of the clipping done by + `_stream_H_at_boundaries` for the problem table. + """ + stream = stream_in.copy() + stream.vle(T=T_pinch, P=stream.P) + H_lo, H_hi = sorted((H_in, H_out)) + H = stream.H + if H < H_lo or H > H_hi: + stream.vle(H=min(max(H, H_lo), H_hi), P=stream.P) + return stream + def load_duties(streams, streams_quenched, pinch_T_arr, T_out_arr, indices, is_cold, Q_hot_side, Q_cold_side): for index in indices: - stream = streams[index].copy() - H_in = stream.H - stream.vle(T = pinch_T_arr[index], P = stream.P) - H_pinch = stream.H + H_in = streams[index].H H_out = streams_quenched[index].H + H_pinch = pinch_state(streams[index], H_in, H_out, pinch_T_arr[index]).H if not is_cold(index): - dH1 = abs(H_pinch - H_in) - dH2 = abs(H_out - H_pinch) + dH1 = H_in - H_pinch + dH2 = H_pinch - H_out if abs(dH1)<0.01: dH1 = 0 if abs(dH2)<0.01: dH2 = 0 Q_hot_side[index] = ['cool', dH1] @@ -418,14 +441,17 @@ def synthesize_network(hus, T_min_app=5., Qmin=1e-3, force_ideal_thermo=False, HXs_cold_side = [] streams_transient_cold_side = streams_inlet streams_transient_hot_side = [i.copy() for i in streams_inlet] + # Hot streams enter the cold-side design at their pinch state and cold + # streams enter the hot-side design at theirs; the enthalpy of that + # state is clipped to the stream's real range (see `pinch_state`). for i in hot_indices: s = streams_transient_cold_side[i] if s.T != pinch_T_arr[i]: - s.vle(T=pinch_T_arr[i], P=s.P) + streams_transient_cold_side[i] = pinch_state(s, s.H, H_out_arr[i], pinch_T_arr[i]) for i in cold_indices: s = streams_transient_hot_side[i] if s.T != pinch_T_arr[i]: - s.vle(T=pinch_T_arr[i], P=s.P) + streams_transient_hot_side[i] = pinch_state(s, s.H, H_out_arr[i], pinch_T_arr[i]) def get_stream_at_H_max(cold): s_cs = streams_transient_cold_side[cold] diff --git a/biosteam/units/design_tools/heat_transfer.py b/biosteam/units/design_tools/heat_transfer.py index 8ade3361..af53ebe9 100644 --- a/biosteam/units/design_tools/heat_transfer.py +++ b/biosteam/units/design_tools/heat_transfer.py @@ -77,7 +77,16 @@ def heat_exchange_to_condition(s_in, s_out, T=None, phase=None, else: if s_out.H < H_lim: s_out.H = H_lim else: + # At the bubble point: the most the stream can absorb (release) + # without leaving T is full vaporization (condensation). The + # enthalpy limit still applies; a limit short of the full phase + # change lands in the two-phase region, so solve it by VLE. s_out.phase = 'g' if heating else 'l' + if H_lim_given: + if heating: + if s_out.H > H_lim: s_out.vle(H=H_lim, P=s_out.P) + else: + if s_out.H < H_lim: s_out.vle(H=H_lim, P=s_out.P) else: s_out.vle(T=T, P=s_out.P) if H_lim_given: @@ -168,14 +177,14 @@ def counter_current_heat_exchange(s0_in, s1_in, s0_out, s1_out, if Q_hot_stream == Q_cold_stream == 0.: s0_out.copy_like(s0_in) - s1_in.copy_like(s1_out) + s1_out.copy_like(s1_in) return 0. if Q_hot_stream > 0 or Q_cold_stream < 0: # Sanity check if Q_hot_stream / s_hot_in.C < 0.1 or Q_cold_stream / s_cold_in.C > -0.1: s0_out.copy_like(s0_in) - s1_in.copy_like(s1_out) + s1_out.copy_like(s1_in) return 0. raise RuntimeError('inlet stream not in vapor-liquid equilibrium') diff --git a/tests/test_heat_exchange.py b/tests/test_heat_exchange.py new file mode 100644 index 00000000..5843498c --- /dev/null +++ b/tests/test_heat_exchange.py @@ -0,0 +1,82 @@ +# -*- coding: utf-8 -*- +# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules +# Copyright (C) 2020-, Yoel Cortes-Pena +# Copyright (C) 2026-, Sarang Bhagwat +# +# This module is under the UIUC open-source license. See +# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt +# for license details. +""" +Tests for heat exchanger units and the counter-current heat exchange solver. +""" +import biosteam as bst +from numpy.testing import assert_allclose +from biosteam.units.design_tools.heat_transfer import heat_exchange_to_condition + +def test_heat_exchange_to_condition_respects_H_lim_at_bubble_point(): + # When the temperature limit coincides with the stream's bubble point + # (within the solver's 1e-3 K tolerance), the outlet is set to the + # saturated phase; the enthalpy limit must still be honored. + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + s_in = bst.Stream('w_in', Water=2000., T=350., P=101325., phase='l', + units='kmol/hr') + T_bp = s_in.bubble_point_at_P().T + s_lim = s_in.copy(); s_lim.T = 360. + H_lim = s_lim.H + # heating: limit below full vaporization at the bubble point + s_out = s_in.copy() + Q = heat_exchange_to_condition(s_in, s_out, T=T_bp, H_lim=H_lim, heating=True) + assert_allclose(s_out.H, H_lim, rtol=1e-9) + assert_allclose(Q, H_lim - s_in.H, rtol=1e-9) + assert s_out.phase == 'l' and s_out.T < T_bp + # cooling: a saturated vapor whose limit is above full condensation + v_in = s_in.copy('w_vap'); v_in.phase = 'g'; v_in.T = T_bp + s_out = v_in.copy() + H_lim = v_in.H - 0.5 * (v_in.H - s_in.H) # half-way to liquid at 350 K + Q = heat_exchange_to_condition(v_in, s_out, T=T_bp, H_lim=H_lim, heating=False) + assert_allclose(s_out.H, H_lim, rtol=1e-9) + assert_allclose(Q, H_lim - v_in.H, rtol=1e-9) + +def test_HXprocess_H_lim_when_pinch_is_at_bubble_point(): + # Hot liquid water at exactly T_bp + dT against cold liquid water with an + # enthalpy limit below vaporization: the cold outlet may not exceed its + # enthalpy limit just because its temperature limit lands on the + # bubble point. + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + cold = bst.Stream('cold', Water=2000., T=350., P=101325., phase='l', + units='kmol/hr') + T_bp = cold.bubble_point_at_P().T + hot = bst.Stream('hot', Water=1000., T=T_bp + 5., P=5e5, phase='l', + units='kmol/hr') + s_lim = cold.copy(); s_lim.T = 360. + H_lim = s_lim.H + hx = bst.HXprocess('hx', ins=(cold, hot), H_lim0=H_lim, T_lim1=355., dT=5.) + hx.simulate() + cold_out, hot_out = hx.outs + assert_allclose(cold_out.H, H_lim, rtol=1e-9) + assert_allclose(hx.Q, H_lim - cold.H, rtol=1e-9) + assert_allclose(hot_out.H, hot.H - hx.Q, rtol=1e-9) + assert hot_out.T > 355. # the hot stream was not the limiting side + +def test_HXprocess_never_modifies_inlets(): + # A superheated-liquid hot inlet (ethanol at 370 K, 1 atm; bp 351.4 K) + # against a two-phase cold inlet of the same fluid: the solver finds no + # feasible exchange. It must leave both inlet streams untouched rather + # than overwrite one with its (already modified) outlet. + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + hot = bst.Stream('hot', Ethanol=700., T=370., P=101325., phase='l', + units='kmol/hr') + cold = bst.Stream('cold', Ethanol=400., T=348.6, P=101325., phase='l', + units='kmol/hr') + cold.vle(H=cold.H + 4e6, P=101325.) # two-phase at the bubble point + H_hot, H_cold = hot.H, cold.H + hx = bst.HXprocess('hx', ins=(cold, hot), dT=5.) + hx._run() + assert hx.Q == 0. + assert_allclose([hot.H, cold.H], [H_hot, H_cold], rtol=1e-12) + assert hot.phase == 'l' and hot.T == 370. + +if __name__ == '__main__': + test_heat_exchange_to_condition_respects_H_lim_at_bubble_point() + test_HXprocess_H_lim_when_pinch_is_at_bubble_point() + test_HXprocess_never_modifies_inlets() diff --git a/tests/test_hxn.py b/tests/test_hxn.py index 214372d5..151db4b3 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -96,7 +96,7 @@ def test_energy_balance_error_contributions_ignored_none(): # --------------------------------------------------------------------------- from biosteam.facilities.hxn.hxn_synthesis import ( - temperature_interval_pinch_analysis, problem_table, + temperature_interval_pinch_analysis, problem_table, load_duties, pinch_state, ) def utility_hx(ID, T, P, phase, T_out, **flow): @@ -236,6 +236,34 @@ def test_problem_table_point_load_cannot_heat_above_itself(): assert table.pinch_T == 395. assert_allclose(table.cold_util_load, P_hot - (H_395 - H_392), rtol=1e-9) +def test_load_duties_non_equilibrium_inlet_conserves_energy(): + # A non-rigorous HXutility can carry a superheated liquid (ethanol at + # 370 K, 1 atm; bp 351.4 K). Flashing it at the 355 K pinch gives vapor + # with far more enthalpy than the inlet has; the pinch split must clip + # to the stream's real enthalpy range so that the hot-side and cold-side + # loads sum to the stream's duty (and are not phantom latent heat). + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + s_in = bst.Stream('ne_in', Ethanol=700., T=370., P=101325., phase='l', + units='kmol/hr') + s_out = bst.Stream('ne_out', Ethanol=700., T=310., P=101325., phase='l', + units='kmol/hr') + duty = s_in.H - s_out.H + flashed = s_in.copy(); flashed.vle(T=355., P=101325.) + assert flashed.H > s_in.H # the trap: equilibrium enthalpy above H_in + Q_hot_side, Q_cold_side = {}, {} + load_duties([s_in], [s_out], np.array([355.]), np.array([310.]), [0], + lambda i: False, Q_hot_side, Q_cold_side) + assert Q_hot_side[0][0] == Q_cold_side[0][0] == 'cool' + assert_allclose(Q_hot_side[0][1] + Q_cold_side[0][1], duty, rtol=1e-9) + # the stream cannot give any heat above the pinch: its whole enthalpy + # range lies below the equilibrium state at 355 K + assert_allclose(Q_hot_side[0][1], 0., atol=1e-6) + assert_allclose(Q_cold_side[0][1], duty, rtol=1e-9) + # and the transient state used for matching carries the clipped enthalpy + s = pinch_state(s_in, s_in.H, s_out.H, 355.) + assert_allclose(s.H, s_in.H, rtol=1e-9) + assert s.T < 355. + def test_synthetic_network_reaches_MER(): units = synthetic_units() HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) diff --git a/tests/test_hxn_regression.py b/tests/test_hxn_regression.py index de0fb93f..173321e3 100644 --- a/tests/test_hxn_regression.py +++ b/tests/test_hxn_regression.py @@ -19,8 +19,11 @@ no future change to ``hxn`` silently makes the synthesizer perform worse. The documented utility loads were recorded by running this file directly -(``python tests/test_hxn_regression.py`` prints them) at commit -``1ab689ff`` (branch ``hxn-pinch-diagram``). Improvements leave slack; a +(``python tests/test_hxn_regression.py`` prints them): cases 1-9 at commit +``1ab689ff`` (branch ``hxn-pinch-diagram``), case 10 after the synthesizer +fixes on ``hxn-regression-tests`` (non-equilibrium inlets clipped to the +stream's enthalpy range; network path ordered by its connections; H_lim +honored at the bubble point). Improvements leave slack; a maintainer lowers the numbers deliberately when a better network is intended. Never raise them to make a failing test pass. """ @@ -140,7 +143,7 @@ def case_10_ten_streams(): utility_hx('H2', 420., 5e5, 'g', 340., Water=150.), utility_hx('H3', 395., 5e5, 'l', 330., Water=1000.), utility_hx('H4', 370., 101325., 'l', 310., Ethanol=700.), - utility_hx('H5', 380., 2e5, 'g', 375., Water=100.), # partial condensation + utility_hx('H5', 380., 101325., 'g', 372.5, Water=100.), # partial condensation utility_hx('C1', 300., 101325., 'l', 360., Water=2000.), boiling_hx('C2', 330., 101325., 380., Water=200.), boiling_hx('C3', 320., 101325., 352., Ethanol=400.), @@ -148,7 +151,7 @@ def case_10_ten_streams(): utility_hx('C5', 340., 101325., 'l', 390., Water=600.)], 5. # name -> (builder, documented hot utility load [kJ/hr], documented cold utility load [kJ/hr]) -# Documented values recorded at 1ab689ff (see module docstring). +# Documented values: see module docstring for provenance. CASES = { 'case_01_two_liquids': (case_01_two_liquids, 0, 1.53912e+06), 'case_02_pinch_limited': (case_02_pinch_limited, 1.81522e+06, 0), @@ -159,7 +162,7 @@ def case_10_ten_streams(): 'case_07_threshold': (case_07_threshold, 1.85977e+07, 0), 'case_08_two_condensers': (case_08_two_condensers, 3.02237e+06, 7.36431e+06), 'case_09_near_degenerate': (case_09_near_degenerate, 1.40965e+07, 9.66427e+06), - 'case_10_ten_streams': (case_10_ten_streams, None, None), + 'case_10_ten_streams': (case_10_ten_streams, 1.40742e+07, 8.06488e+06), } # --------------------------------------------------------------------------- @@ -194,21 +197,7 @@ def actual_loads(HXN): cool = -sum(hu.unit_duty for hu in hus if hu.unit_duty < 0) return heat, cool -# Cases that currently crash inside synthesis. Strict xfail: once the bug is -# fixed the test fails, prompting the maintainer to record the case's baseline. -KNOWN_FAILURES = { - # The synthesizer emits a zero-duty exchanger (HX_8_2_cs: H1 at 355 K - # against C3 at 365 K, Q = 0) whose cold inlet is hotter than its hot - # inlet; compute_LMTD then takes log of a negative ratio. - 'case_10_ten_streams': FloatingPointError, -} - -@pytest.mark.parametrize('name', [ - pytest.param(name, marks=pytest.mark.xfail(raises=KNOWN_FAILURES[name], strict=True, - reason='synthesizer emits a zero-duty exchanger with crossed temperatures')) - if name in KNOWN_FAILURES else name - for name in CASES -]) +@pytest.mark.parametrize('name', list(CASES)) def test_hxn_regression(name): builder, doc_heat, doc_cool = CASES[name] units, HXN, T_min_app = synthesize(builder) @@ -228,9 +217,6 @@ def test_hxn_regression(name): if __name__ == '__main__': for name, (builder, *_) in CASES.items(): - if name in KNOWN_FAILURES: - print(f"{name}: known failure ({KNOWN_FAILURES[name].__name__})") - continue units, HXN, T_min_app = synthesize(builder) heat, cool = actual_loads(HXN) hot_target, cold_target = mer_targets(units, T_min_app) From 1d882c4b3040bbbc9049273ca9318abe968a27e3 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sun, 23 Aug 2026 03:27:24 -0700 Subject: [PATCH 14/26] address review: exact pinch states at end temperatures, HXN-specific path warning, tighter regression tolerances Follow-up to 75f1402a from a code review of the branch. pinch_state (hxn_synthesis.py) now takes the stream's real end states and, when the pinch temperature coincides with an end temperature or the flash at the pinch leaves the stream's enthalpy range, returns the *equilibrium state at that end enthalpy* (new helper _end_state). Two defects closed: - A non-equilibrium inlet with pinch_T == T_in still had its duty split across the pinch: flashing a superheated liquid at its own temperature does not reproduce H_in, and the result can lie inside the range so the clip never fired (superheated liquid water 380 -> 400 K put 98 % of the duty on the side the stream is "unavailable" on). Now H_pinch == H_in exactly, so the whole duty lands on one side as the pinch analysis promises. - A phase-mislabelled non-condensable (N2 as 'l' at 400 K) re-flashed at the clipped enthalpy came back as gas at ~2500 K and drove matching. _end_state falls back to the stream as given when the equilibrium state leaves the stream's own [T_out, T_in] range. The review suggested returning the stream as given at end points; that was tried and rejected: it lets the synthesizer offer a non-equilibrium inlet's heat at its fictitious temperature (liquid ethanol "at 370 K") and case 10 then beat the problem-table MER by 0.3 %. The equilibrium state at the end enthalpy keeps synthesis consistent with the table, which is the invariant the regression suite enforces. _heat_exchanger_network.py: thermosteam's Network.sort can warn 'network path could not be determined' when its ordering heuristic does not settle; since 75f1402a that could surface from HXN with no context. It is caught and re-issued as an HXN-specific RuntimeWarning (tested by monkeypatching Network.from_units). tests/test_hxn_regression.py: converged networks close their energy balance to ~1e-10 %, so the 0.1 % tolerance could not catch the stale-ordering defect (ablating it gives 0.049 %). EB_TOLERANCE is now 1e-6 % and the heat - cool == net duty identity uses rtol 1e-8. Case 5's documented baseline is lowered (hot 5.8433e6 -> 3.2224e6, cold 1.04356e7 -> 7.81466e6): its 420 K, 5 bar vapor feed is below water's boiling point there, a non-equilibrium inlet now handled consistently. Cases 1-4 and 6-10 are unchanged. Validation: HX/HXN tests and doctests -> 37 passed. Full CI-style suite -> 74 failed, 495 passed, 62 skipped; the same 74 pre-existing failures as the previous two runs, +2 passed. Co-Authored-By: Claude Fable 5 --- .../facilities/hxn/_heat_exchanger_network.py | 13 +++- biosteam/facilities/hxn/hxn_synthesis.py | 68 ++++++++++++++----- tests/test_hxn.py | 59 +++++++++++++++- tests/test_hxn_regression.py | 21 +++--- 4 files changed, 130 insertions(+), 31 deletions(-) diff --git a/biosteam/facilities/hxn/_heat_exchanger_network.py b/biosteam/facilities/hxn/_heat_exchanger_network.py index 55be67ff..fbb3c447 100644 --- a/biosteam/facilities/hxn/_heat_exchanger_network.py +++ b/biosteam/facilities/hxn/_heat_exchanger_network.py @@ -14,6 +14,7 @@ import numpy as np from .hxn_synthesis import synthesize_network, StreamLifeCycle, plot_pinch_diagram from warnings import warn +import warnings __all__ = ('HeatExchangerNetwork',) @@ -233,7 +234,17 @@ def _cost(self): # order would leave it with stale inlets. HXprocess units are # interaction units, which Network.from_units strips out (and # disconnects) by default; keep them with interaction=False. - network = tmo.Network.from_units(all_units, interaction=False) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter('always', RuntimeWarning) + network = tmo.Network.from_units(all_units, interaction=False) + for w in caught: + if 'network path could not be determined' in str(w.message): + warn('heat exchanger network path could not be fully ' + 'ordered from its stream connections; exchangers ' + 'fed by later ones in the path may be simulated ' + 'with stale inlets until convergence', RuntimeWarning) + else: + warn(w.message, w.category) self.HXN_sys = sys = bst.System._from_network(None, network) sys.set_tolerance(method='fixedpoint', subsystems=True) diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py index 8e633449..c47dde15 100644 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ b/biosteam/facilities/hxn/hxn_synthesis.py @@ -368,36 +368,68 @@ def temperature_interval_pinch_analysis(hus, streams_quenched -def pinch_state(stream_in, H_in, H_out, T_pinch): +def _end_state(stream_end, T_lo, T_hi): """ - Return a copy of `stream_in` in the state it has when it crosses the + Return a copy of `stream_end` at equilibrium at its own enthalpy, or the + stream as given if that equilibrium state lies outside the stream's own + temperature range [T_lo, T_hi] (e.g. a non-condensable mislabelled as a + liquid, whose equilibrium state at the same enthalpy is a gas at an + absurd temperature). Either way the enthalpy is exactly `stream_end.H`. + """ + stream = stream_end.copy() + try: + stream.vle(H=stream_end.H, P=stream.P) + except Exception: + return stream_end.copy() + if T_lo <= stream.T <= T_hi: return stream + return stream_end.copy() + +def pinch_state(stream_in, stream_out, T_pinch): + """ + Return a copy of the stream in the state it has when it crosses the pinch, with enthalpy guaranteed to lie within [min(H_in, H_out), max(H_in, H_out)]. - The copy is first flashed at `T_pinch`. If the resulting equilibrium - enthalpy lies outside the stream's own enthalpy range the stream never - actually passes through that state: a non-equilibrium inlet (e.g. a - superheated liquid from a non-rigorous HXutility) or outlet has less - (or more) enthalpy than the equilibrium fluid at the pinch. The copy is - then flashed at the nearer end of the range instead, so the hot-side - and cold-side loads split `|H_in - H_out|` exactly and the transient - stream used for matching never carries heat the real stream does not - have. This is the synthesizer's counterpart of the clipping done by - `_stream_H_at_boundaries` for the problem table. + `stream_in` and `stream_out` are the stream's real end states (the + outlet quenched to equilibrium at its own enthalpy). For an interior + pinch the inlet copy is flashed at `T_pinch`; the result is used as is + when its enthalpy lies within the stream's own range. Otherwise the + stream never passes through that equilibrium state: a non-equilibrium + inlet (e.g. a superheated liquid from a non-rigorous HXutility) has + less enthalpy than the equilibrium fluid at the pinch, and the state + returned is instead the equilibrium state at the nearer end enthalpy. + The same end state is returned when `T_pinch` coincides with an end + temperature, because flashing a non-equilibrium inlet at its own + temperature does not reproduce `H_in` (and the result may even lie + inside the range). Using the *equilibrium* state at the end enthalpy, + rather than the stream as given, keeps the synthesizer consistent with + the problem table: the heat is offered at the temperature the + equilibrium model says it is available, not at a fictitious one; see + `_end_state` for the fallback when that state is unphysical. + + Either way the hot-side and cold-side loads split `|H_in - H_out|` + exactly and the transient stream used for matching never carries heat + the real stream does not have. This is the synthesizer's counterpart of + the clipping done by `_stream_H_at_boundaries` for the problem table. """ + T_lo, T_hi = sorted((stream_in.T, stream_out.T)) + if T_pinch == stream_in.T: return _end_state(stream_in, T_lo, T_hi) + if T_pinch == stream_out.T: return _end_state(stream_out, T_lo, T_hi) stream = stream_in.copy() stream.vle(T=T_pinch, P=stream.P) + H_in = stream_in.H + H_out = stream_out.H H_lo, H_hi = sorted((H_in, H_out)) H = stream.H - if H < H_lo or H > H_hi: - stream.vle(H=min(max(H, H_lo), H_hi), P=stream.P) - return stream + if H_lo <= H <= H_hi: return stream + H_clipped = H_lo if H < H_lo else H_hi + return _end_state(stream_in if H_clipped == H_in else stream_out, T_lo, T_hi) def load_duties(streams, streams_quenched, pinch_T_arr, T_out_arr, indices, is_cold, Q_hot_side, Q_cold_side): for index in indices: H_in = streams[index].H H_out = streams_quenched[index].H - H_pinch = pinch_state(streams[index], H_in, H_out, pinch_T_arr[index]).H + H_pinch = pinch_state(streams[index], streams_quenched[index], pinch_T_arr[index]).H if not is_cold(index): dH1 = H_in - H_pinch dH2 = H_pinch - H_out @@ -447,11 +479,11 @@ def synthesize_network(hus, T_min_app=5., Qmin=1e-3, force_ideal_thermo=False, for i in hot_indices: s = streams_transient_cold_side[i] if s.T != pinch_T_arr[i]: - streams_transient_cold_side[i] = pinch_state(s, s.H, H_out_arr[i], pinch_T_arr[i]) + streams_transient_cold_side[i] = pinch_state(s, streams_quenched[i], pinch_T_arr[i]) for i in cold_indices: s = streams_transient_hot_side[i] if s.T != pinch_T_arr[i]: - streams_transient_hot_side[i] = pinch_state(s, s.H, H_out_arr[i], pinch_T_arr[i]) + streams_transient_hot_side[i] = pinch_state(s, streams_quenched[i], pinch_T_arr[i]) def get_stream_at_H_max(cold): s_cs = streams_transient_cold_side[cold] diff --git a/tests/test_hxn.py b/tests/test_hxn.py index 151db4b3..4e7a147b 100644 --- a/tests/test_hxn.py +++ b/tests/test_hxn.py @@ -259,10 +259,63 @@ def test_load_duties_non_equilibrium_inlet_conserves_energy(): # range lies below the equilibrium state at 355 K assert_allclose(Q_hot_side[0][1], 0., atol=1e-6) assert_allclose(Q_cold_side[0][1], duty, rtol=1e-9) - # and the transient state used for matching carries the clipped enthalpy - s = pinch_state(s_in, s_in.H, s_out.H, 355.) + # and the transient state used for matching carries exactly H_in, at + # equilibrium (two-phase at the bubble point), not at the fictitious + # 370 K of the superheated liquid, so matching is consistent with the + # problem table + s = pinch_state(s_in, s_out, 355.) assert_allclose(s.H, s_in.H, rtol=1e-9) - assert s.T < 355. + assert s.T < 355. and 'g' in s.phase and 'l' in s.phase + +def test_pinch_state_at_endpoints_uses_real_states(): + # pinch_T == T_in must put the whole duty on one side even when the + # inlet is not at equilibrium: flashing a superheated liquid at its own + # T does not reproduce H_in, and the resulting enthalpy can lie inside + # the stream's range so that clipping alone would not catch it. + bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) + s_in = bst.Stream('sh_in', Water=100., T=380., P=101325., phase='l', + units='kmol/hr') + s_out = bst.Stream('sh_out', Water=100., T=400., P=101325., phase='g', + units='kmol/hr') + duty = s_out.H - s_in.H + flashed = s_in.copy(); flashed.vle(T=380., P=101325.) + assert s_in.H < flashed.H < s_out.H # the trap: in range, but not H_in + Q_hot_side, Q_cold_side = {}, {} + load_duties([s_in], [s_out], np.array([380.]), np.array([400.]), [0], + lambda i: True, Q_hot_side, Q_cold_side) + assert_allclose(Q_hot_side[0][1], duty, rtol=1e-9) + assert_allclose(Q_cold_side[0][1], 0., atol=1e-6) + assert_allclose(pinch_state(s_in, s_out, 380.).H, s_in.H, rtol=1e-9) + assert_allclose(pinch_state(s_in, s_out, 400.).H, s_out.H, rtol=1e-9) + # a phase-mislabelled non-condensable: clipping must return the real + # end state, never an equilibrium re-flash (N2 "liquid" at 400 K would + # otherwise come back as gas at thousands of K) + bst.settings.set_thermo(['Water', 'N2'], cache=True) + h_in = bst.Stream('n2_in', N2=100., T=400., P=101325., phase='l', + units='kmol/hr') + h_out = bst.Stream('n2_out', N2=100., T=320., P=101325., phase='l', + units='kmol/hr') + s = pinch_state(h_in, h_out, 355.) + assert h_out.H <= s.H <= h_in.H + assert 320. <= s.T <= 400. + +def test_unordered_network_path_warns_with_context(monkeypatch): + # thermosteam's Network.sort warns 'network path could not be determined' + # when its ordering heuristic does not settle; HXN re-raises that as its + # own warning so the user knows which facility it concerns. + import thermosteam as tmo + original = tmo.Network.from_units + def from_units_with_warning(*args, **kwargs): + network = original(*args, **kwargs) + warnings.warn('network path could not be determined', RuntimeWarning) + return network + monkeypatch.setattr(tmo.Network, 'from_units', from_units_with_warning) + units = synthetic_units() + HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) + sys = bst.System.from_units('sys_unordered', units=[*units, HXN]) + with pytest.warns(RuntimeWarning, match='heat exchanger network path could not be fully ordered'): + sys.simulate() + assert abs(HXN.energy_balance_percent_error) < 1e-6 def test_synthetic_network_reaches_MER(): units = synthetic_units() diff --git a/tests/test_hxn_regression.py b/tests/test_hxn_regression.py index 173321e3..7c2d1864 100644 --- a/tests/test_hxn_regression.py +++ b/tests/test_hxn_regression.py @@ -12,18 +12,21 @@ Ten synthetic systems of increasing complexity (all with phase-changing streams from case 3 on). For each, the synthesized network must -(i) close its energy balance (|error| < 0.1 %) without RuntimeWarnings, +(i) close its energy balance (|error| < 1e-6 %) without RuntimeWarnings, (ii) never beat the minimum-energy-requirement (MER) targets of the problem table computed on the same streams, and (iii) recover at least as much heat as documented in ``CASES`` below, so that no future change to ``hxn`` silently makes the synthesizer perform worse. The documented utility loads were recorded by running this file directly -(``python tests/test_hxn_regression.py`` prints them): cases 1-9 at commit -``1ab689ff`` (branch ``hxn-pinch-diagram``), case 10 after the synthesizer -fixes on ``hxn-regression-tests`` (non-equilibrium inlets clipped to the -stream's enthalpy range; network path ordered by its connections; H_lim -honored at the bubble point). Improvements leave slack; a +(``python tests/test_hxn_regression.py`` prints them): cases 1-4 and 6-9 +at commit ``1ab689ff`` (branch ``hxn-pinch-diagram``); case 10 after the +synthesizer fixes on ``hxn-regression-tests`` (non-equilibrium inlets +clipped to the stream's enthalpy range; network path ordered by its +connections; H_lim honored at the bubble point); case 5 lowered after the +pinch state at an end temperature became the equilibrium state at that +end enthalpy (its 420 K, 5 bar vapor feed is below water's boiling point +there, a non-equilibrium inlet). Improvements leave slack; a maintainer lowers the numbers deliberately when a better network is intended. Never raise them to make a failing test pass. """ @@ -33,7 +36,7 @@ from numpy.testing import assert_allclose from biosteam.facilities.hxn.hxn_synthesis import problem_table -EB_TOLERANCE = 0.1 # percent +EB_TOLERANCE = 1e-6 # percent; converged networks close to ~1e-10 % MER_RTOL = 1e-3 # network may not beat the MER target by more than this DOC_RTOL = 1e-3 # network may not be worse than documented by more than this @@ -157,7 +160,7 @@ def case_10_ten_streams(): 'case_02_pinch_limited': (case_02_pinch_limited, 1.81522e+06, 0), 'case_03_condenser_two_colds': (case_03_condenser_two_colds, 0, 9.49905e+06), 'case_04_report_case': (case_04_report_case, 2.37319e+06, 3.56871e+06), - 'case_05_boiling_cold': (case_05_boiling_cold, 5.8433e+06, 1.04356e+07), + 'case_05_boiling_cold': (case_05_boiling_cold, 3.2224e+06, 7.81466e+06), 'case_06_mixed_pressures': (case_06_mixed_pressures, 7.05541e+06, 4.93079e+06), 'case_07_threshold': (case_07_threshold, 1.85977e+07, 0), 'case_08_two_condensers': (case_08_two_condensers, 3.02237e+06, 7.36431e+06), @@ -209,7 +212,7 @@ def test_hxn_regression(name): net_duty = sum(hx.heat_utilities[0].unit_duty for hx in units) assert heat >= hot_target * (1 - MER_RTOL), (name, heat, hot_target) assert cool >= cold_target * (1 - MER_RTOL), (name, cool, cold_target) - assert_allclose(heat - cool, net_duty, rtol=1e-3, err_msg=name) + assert_allclose(heat - cool, net_duty, rtol=1e-8, err_msg=name) # (iii) never worse than documented assert doc_heat is not None and doc_cool is not None, f'{name}: baseline not recorded' assert heat <= doc_heat * (1 + DOC_RTOL) + 1e-9, (name, heat, doc_heat) From ac40594b85e2c6e4b37b9e515239e765fab10be3 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Sun, 23 Aug 2026 23:12:51 -0700 Subject: [PATCH 15/26] migrate heat exchanger network to the hensmith package biosteam/facilities/hxn and its tests now live in github.com/BioSTEAMDevelopmentGroup/hensmith, extracted with full git history (including the pre-March-2023 biosteam/units/facilities/hxn paths) at this branch state (1d882c4b). biosteam gains hensmith as an install dependency and re-exports HeatExchangerNetwork lazily via PEP 562 module __getattr__ in both biosteam/__init__ and biosteam.facilities, so bst.HeatExchangerNetwork, biosteam.facilities.HeatExchangerNetwork, from-imports, and star-imports keep working. The laziness makes the biosteam <-> hensmith circular dependency import-safe in both orders: importing biosteam never initializes hensmith mid-import, and hensmith imports biosteam eagerly to subclass bst.Facility. The name is intentionally absent from facilities.__all__ because biosteam/__init__ star-imports facilities during initialization, which would resolve it eagerly and re-create the cycle. Covered by tests/test_hensmith_integration.py (subprocess tests of both import orders); biosteam also imports cleanly with hensmith absent. The synthesis helpers (synthesize_network, problem_table, plot_pinch_diagram, StreamLifeCycle, ProblemTable) are no longer exported from biosteam; no downstream biorefinery references them via biosteam (verified across Bioindustrial-Park). Docs page for HeatExchangerNetwork now documents hensmith.HeatExchangerNetwork and notes the move. Co-Authored-By: Claude Fable 5 --- biosteam/__init__.py | 10 + biosteam/facilities/__init__.py | 17 +- biosteam/facilities/hxn/__init__.py | 20 - .../facilities/hxn/_heat_exchanger_network.py | 488 -------- biosteam/facilities/hxn/hxn_synthesis.py | 1032 ----------------- docs/API/facilities/HeatExchangerNetwork.txt | 15 +- setup.py | 4 +- tests/test_hensmith_integration.py | 52 + tests/test_hxn.py | 483 -------- tests/test_hxn_regression.py | 228 ---- 10 files changed, 91 insertions(+), 2258 deletions(-) delete mode 100644 biosteam/facilities/hxn/__init__.py delete mode 100644 biosteam/facilities/hxn/_heat_exchanger_network.py delete mode 100644 biosteam/facilities/hxn/hxn_synthesis.py create mode 100644 tests/test_hensmith_integration.py delete mode 100644 tests/test_hxn.py delete mode 100644 tests/test_hxn_regression.py diff --git a/biosteam/__init__.py b/biosteam/__init__.py index e057ca06..7b58318d 100644 --- a/biosteam/__init__.py +++ b/biosteam/__init__.py @@ -81,6 +81,7 @@ def njit(*args, **kwargs): __all__ = ( 'Unit', 'PowerUtility', 'UtilityAgent', 'HeatUtility', 'Facility', + 'HeatExchangerNetwork', 'utils', 'units', 'facilities', 'wastewater', 'evaluation', 'Chemical', 'Chemicals', 'Stream', 'MultiStream', 'settings', 'exceptions', 'report', 'units_of_measure', 'process_tools', 'preferences', *_system.__all__, *_flowsheet.__all__, @@ -88,6 +89,15 @@ def njit(*args, **kwargs): *evaluation.__all__, *process_tools.__all__, *_module.__all__, ) +def __getattr__(name): + # HeatExchangerNetwork now lives in the hensmith package + # (github.com/BioSTEAMDevelopmentGroup/hensmith); see + # biosteam/facilities/__init__.py for why the re-export is lazy. + if name == 'HeatExchangerNetwork': + from hensmith import HeatExchangerNetwork + return HeatExchangerNetwork + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") + def nbtutorial(dark=False): global print_error diff --git a/biosteam/facilities/__init__.py b/biosteam/facilities/__init__.py index 24d3fbfe..a0ddd7b5 100644 --- a/biosteam/facilities/__init__.py +++ b/biosteam/facilities/__init__.py @@ -17,7 +17,6 @@ from ._cleaning_in_place import * from ._refrigeration_package import * from ._fire_water_tank import * -from .hxn import * from .systems import * from . import _chemical_capital_investment @@ -30,7 +29,6 @@ from . import _cleaning_in_place from . import _refrigeration_package from . import _fire_water_tank -from . import hxn from . import systems __all__ = ( @@ -44,6 +42,19 @@ *_cleaning_in_place.__all__, *_refrigeration_package.__all__, *_fire_water_tank.__all__, - *hxn.__all__, *systems.__all__, ) + +def __getattr__(name): + # HeatExchangerNetwork now lives in the hensmith package + # (github.com/BioSTEAMDevelopmentGroup/hensmith). It is re-exported + # lazily (PEP 562) so that the biosteam <-> hensmith circular dependency + # is import-safe: importing biosteam never initializes hensmith, and + # hensmith can import biosteam eagerly while defining its classes. The + # name must stay out of __all__ because biosteam/__init__ star-imports + # this module during initialization, which would resolve it eagerly and + # re-create the import cycle. + if name == 'HeatExchangerNetwork': + from hensmith import HeatExchangerNetwork + return HeatExchangerNetwork + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/biosteam/facilities/hxn/__init__.py b/biosteam/facilities/hxn/__init__.py deleted file mode 100644 index d630e623..00000000 --- a/biosteam/facilities/hxn/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -# -*- coding: utf-8 -*- -# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules -# Copyright (C) 2020-2023, Yoel Cortes-Pena -# -# This module is under the UIUC open-source license. See -# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt -# for license details. -""" -""" - -from ._heat_exchanger_network import * -from .hxn_synthesis import * - -from . import _heat_exchanger_network -from . import hxn_synthesis - -__all__ = ( - *_heat_exchanger_network.__all__, - *hxn_synthesis.__all__ -) diff --git a/biosteam/facilities/hxn/_heat_exchanger_network.py b/biosteam/facilities/hxn/_heat_exchanger_network.py deleted file mode 100644 index fbb3c447..00000000 --- a/biosteam/facilities/hxn/_heat_exchanger_network.py +++ /dev/null @@ -1,488 +0,0 @@ -# -*- coding: utf-8 -*- -# This module will be moved to a new reporsitory called "HXN: The automated Heat Exchanger Network design package." -# Copyright (C) 2020-, Sarang Bhagwat , Yoel Cortes-Pena -# -# This module is under the UIUC open-source license. See -# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt -# for license details. -""" -Created on Sat Aug 22 21:58:19 2020 -@author: sarangbhagwat and yoelcp -""" -import biosteam as bst -import thermosteam as tmo -import numpy as np -from .hxn_synthesis import synthesize_network, StreamLifeCycle, plot_pinch_diagram -from warnings import warn -import warnings - -__all__ = ('HeatExchangerNetwork',) - - -class HeatExchangerNetwork(bst.Facility): - """ - Create a HeatExchangerNetwork object that will perform a pinch analysis - on the entire system's heating and cooling utility objects. The heat - exchanger network reduces the heating and cooling utility requirements - of the system and may add additional capital cost. - - Parameters - ---------- - ID : str - Unique name for the facility. - T_min_app : float - Minimum approach temperature observed during synthesis of heat exchanger network. - units : Iterable[Unit], optional - All unit operations available to the heat exchanger network. Defaults - to all unit operations in the system. - - Notes - ----- - Original system stream and heat exchanger objects are preserved. All stream - copies and new HX objects can be found in a newly created flowsheet - '_HXN' where is the name of the system associated to the - HeatExchangerNetwork object. - - References - ---------- - .. [1] Seider, W. D., Lewin, D. R., Seader, J. D., Widagdo, S., Gani, R., - & Ng, M. K. (2017). Product and Process Design Principles. Wiley. - Heat Exchanger Networks (Chapter 9) - - Examples - -------- - >>> import biosteam as bst - >>> bst.settings.set_thermo(['Water', 'Methanol', 'Glycerol']) - >>> feed1 = bst.Stream('feed1', flow=(8000, 100, 25)) - >>> feed2 = bst.Stream('feed2', flow=(10000, 1000, 10)) - >>> D1 = bst.ShortcutColumn('D1', ins=feed1, - ... outs=('distillate', 'bottoms_product'), - ... LHK=('Methanol', 'Water'), - ... y_top=0.99, x_bot=0.01, k=2, - ... is_divided=True) - >>> D1_H1 = bst.HXutility('D1_H1', ins = D1.outs[1], T = 300) - >>> D1_H2 = bst.HXutility('D1_H2', ins = D1.outs[0], T = 300) - >>> F1 = bst.Flash('F1', ins=feed2, - ... outs=('vapor', 'liquid'), V = 0.9, P = 101325) - >>> HXN = bst.HeatExchangerNetwork('HXN', T_min_app = 5.) - >>> sys = bst.System.from_units('sys', units=[D1, D1_H1, D1_H2, F1, HXN]) - >>> sys.simulate() - >>> # See all results - >>> round(HXN.actual_heat_util_load/HXN.original_heat_util_load, 2) - 0.82 - >>> abs(HXN.energy_balance_percent_error) < 0.01 - True - >>> HXN.stream_life_cycles - [, H_in = 5.38e+06 kJ, H_out = 4.24e+07 kJ> - , H_in = 4.24e+07 kJ, H_out = 6.92e+07 kJ> - ]>, , H_in = 0 kJ, H_out = 3.34e+04 kJ> - , H_in = 3.34e+04 kJ, H_out = 5.06e+06 kJ> - , H_in = 5.06e+06 kJ, H_out = 2.3e+07 kJ> - , H_in = 2.3e+07 kJ, H_out = 2.79e+08 kJ> - ]>, , H_in = 4.52e+07 kJ, H_out = 8.12e+06 kJ> - , H_in = 8.12e+06 kJ, H_out = 3.1e+06 kJ> - , H_in = 3.1e+06 kJ, H_out = 1.14e+06 kJ> - ]>, , H_in = 2.04e+07 kJ, H_out = 2.47e+06 kJ> - , H_in = 2.47e+06 kJ, H_out = 2.47e+06 kJ> - ]>, , H_in = 7.51e+05 kJ, H_out = 7.18e+05 kJ> - , H_in = 7.18e+05 kJ, H_out = 7.18e+05 kJ> - ]>] - - """ - ticket_name = 'HXN' - acceptable_energy_balance_error = 0.02 - raise_energy_balance_error = False - network_priority = -2 - _N_ins = 0 - _N_outs = 0 - _units= {'Flow rate': 'kg/hr', - 'Work': 'kW'} - - def __init__(self, ID='', T_min_app=5., units=None, ignored=None, Qmin=1e-3, - force_ideal_thermo=False, cache_network=False, avoid_recycle=False, - acceptable_energy_balance_error=None, replace_unit_heat_utilities=False, - sort_hus_by_T=False): - bst.Facility.__init__(self, ID, None, None) - self.T_min_app = T_min_app - self.units = units - self.ignored = ignored - self.Qmin = Qmin - self.force_ideal_thermo = force_ideal_thermo - self.cache_network = cache_network - self.avoid_recycle = avoid_recycle - self.replace_unit_heat_utilities = replace_unit_heat_utilities - self.sort_hus_by_T = sort_hus_by_T - if acceptable_energy_balance_error is not None: - self.acceptable_energy_balance_error = acceptable_energy_balance_error - - def _get_original_heat_utilties(self): - sys = self.system - if self.units: - units = self.units - if callable(units): units = units() - else: - units = sys.units - ignored = self.ignored - if ignored: - if callable(ignored): ignored = ignored() - ignored_hx_utils = sum([i.heat_utilities for i in ignored], []) - else: - ignored_hx_utils = () - hx_utils = bst.process_tools.heat_exchanger_utilities_from_units(units) - return [i for i in hx_utils if i.duty and i not in ignored_hx_utils] - - def _run(self): pass - def _design(self): pass - def _load_capital_costs(self): pass # Do not replace installed costs - - def _cost(self): - sys = self.system - hx_utils = self._get_original_heat_utilties() - flowsheet = bst.Flowsheet(sys.ID + '_HXN') - use_cached_network = False - if self.cache_network and hasattr(self, 'original_heat_utils'): - # Units are the stable key: HeatUtility objects are recreated each - # simulation, and IDs may be duplicated (e.g., several - # 'condenser'/'reboiler' auxiliaries). Compare as identity sets. - hu_by_unit = {hu.unit: hu for hu in hx_utils} - use_cached_network = ( - hu_by_unit.keys() == set(self.original_heat_exchangers) - ) - with flowsheet.temporary(), bst.IgnoreDockingWarnings(): - if use_cached_network: - # Keep the stored synthesis (duty-sorted) order, which is - # aligned index-by-index with stream_life_cycles. - hxs = self.original_heat_exchangers - hx_heat_utils_rearranged = [hu_by_unit[hx] for hx in hxs] - stream_life_cycles = self.stream_life_cycles - new_HXs = self.new_HXs - new_HX_utils = self.new_HX_utils - for i, life_cycle in enumerate(stream_life_cycles): - hx = hxs[i] - s_util_in = hx.ins[0] - stage = life_cycle.life_cycle[0] - s_lc = stage.unit.ins[stage.index] - s_lc.copy_like(s_util_in) - s_util_out = hx.outs[0] - H = s_util_out.H - for lc in life_cycle.life_cycle: - if isinstance(lc.unit, bst.HXutility): - lc.unit.H = H - else: - setattr(lc.unit, f'H_lim{lc.index}', s_util_out.H) - sys = self.HXN_sys - for unit in sys.units: - for s_in, s_out in zip(unit.ins, unit.outs): - if isinstance(s_out, bst.MultiStream): - s_out.F_mol = s_in.F_mol - if not s_out.mol.sparse_equal(s_in.mol): - s_out.copy_flow(s_in) - s_out.vle(T=s_out.T, P=s_out.P) - else: - s_out.mol[:] = s_in.mol - else: - hx_utils.sort(key = lambda x: x.duty) - self.HXN_flowsheet = HXN_F = bst.main_flowsheet - for i in HXN_F.registries: i.clear() - HXs_hot_side, HXs_cold_side, new_HX_utils, hxs, T_in_arr,\ - T_out_arr, pinch_T_arr, C_flow_vector, hx_heat_utils_rearranged, streams_inlet, stream_HXs_dict,\ - hot_indices, cold_indices = \ - synthesize_network(hx_utils, self.T_min_app, self.Qmin, - self.force_ideal_thermo, self.avoid_recycle, - self.sort_hus_by_T) - new_HXs = HXs_hot_side + HXs_cold_side - self.new_HXs_hot_side = HXs_hot_side - self.new_HXs_cold_side = HXs_cold_side - self.cold_indices = cold_indices - self.original_heat_exchangers = hxs - self.new_HXs = new_HXs - self.new_HX_utils = new_HX_utils - self.streams_inlet = streams_inlet - stream_life_cycles = self._get_stream_life_cycles() - self.stream_HXs_dict = stream_HXs_dict - self.pinch_Ts = pinch_T_arr - self.inlet_Ts = T_in_arr - self.outlet_Ts = T_out_arr - all_units = new_HXs + new_HX_utils - IDs = set([i.ID for i in all_units]) - assert len(all_units) == len(IDs) - for i, life_cycle in enumerate(stream_life_cycles): - stage = life_cycle.life_cycle[0] - s_util = hx_heat_utils_rearranged[i].unit.ins[0] - s_lc = stage.unit.ins[stage.index] - s_lc.copy_like(s_util) - for life_cycle in stream_life_cycles: - s_out = None - for i in life_cycle.life_cycle: - unit = i.unit - if s_out: unit.ins[i.index] = s_out - s_out = unit.outs[i.index] - # Order the path by the rewired stream connections (and - # detect recycle loops) rather than using synthesis order: a - # hot-side exchanger is synthesized before the cold-side - # exchangers that feed it, and a single pass in synthesis - # order would leave it with stale inlets. HXprocess units are - # interaction units, which Network.from_units strips out (and - # disconnects) by default; keep them with interaction=False. - with warnings.catch_warnings(record=True) as caught: - warnings.simplefilter('always', RuntimeWarning) - network = tmo.Network.from_units(all_units, interaction=False) - for w in caught: - if 'network path could not be determined' in str(w.message): - warn('heat exchanger network path could not be fully ' - 'ordered from its stream connections; exchangers ' - 'fed by later ones in the path may be simulated ' - 'with stale inlets until convergence', RuntimeWarning) - else: - warn(w.message, w.category) - self.HXN_sys = sys = bst.System._from_network(None, network) - sys.set_tolerance(method='fixedpoint', subsystems=True) - - original_purchase_costs = [hx.purchase_cost for hx in hxs] - original_installed_costs = [hx.installed_cost for hx in hxs] - # # Handle special case for heat exchanger crossing the pinch - # for hx in new_HXs: - # if all([isinstance(i.sink, bst.HXutility) for i in hx.outs]): - # hx.Tlim1 = None - # hx.Hlim1 = hx.outs[1].sink.H - sys._setup() - try: - sys.converge() - except: - for i in sys.units: i._run() - warn('heat exchanger network was not able to converge', RuntimeWarning) - for i in sys.units: i._summary() - for i in range(len(stream_life_cycles)): - hx = hx_heat_utils_rearranged[i].unit - P = hx.ins[0].P - s_util = hx.outs[0] - lc = stream_life_cycles[i].life_cycle[-1] - s_lc = lc.unit.outs[lc.index] - IDs = tuple([i.ID for i in s_util.available_chemicals]) - if use_cached_network: - try: - assert np.isfinite(hx.installed_cost) - np.testing.assert_allclose(s_util.imol[IDs], s_lc.imol[IDs]) - np.testing.assert_allclose(P, s_lc.P, rtol=1e-3, atol=0.1) - np.testing.assert_allclose(s_util.H, s_lc.H, rtol=1e-3, atol=1.) - except AssertionError as e: - msg = ("heat exchanger network cache algorithm failed, " - f"cached network ignored: {e}") - warn(msg, RuntimeWarning, stacklevel=2) - del self.original_heat_utils - self._cost() - return - else: - np.testing.assert_allclose(s_util.imol[IDs], s_lc.imol[IDs], rtol=1e-3, atol=0.1) - np.testing.assert_allclose(P, s_lc.P, rtol=1e-3, atol=0.1) - np.testing.assert_allclose(s_util.H, s_lc.H, rtol=1e-3, atol=1.) - new_purchase_costs_HXp = [] - new_purchase_costs_HXu = [] - new_installed_costs_HXp = [] - new_installed_costs_HXu = [] - new_utility_costs = [] - for hx in new_HX_utils: - new_installed_costs_HXu.append(hx.installed_cost) - new_purchase_costs_HXu.append(hx.purchase_cost) - new_utility_costs.append(hx.utility_cost) - for new_HX in new_HXs: - new_purchase_costs_HXp.append(new_HX.purchase_cost) - new_installed_costs_HXp.append(new_HX.installed_cost) - hu_sums1 = bst.HeatUtility.sum_by_agent(hx_heat_utils_rearranged) - new_heat_utils = sum([hx.heat_utilities for hx in new_HX_utils], []) - hu_sums2 = bst.HeatUtility.sum_by_agent(new_heat_utils) - # to change sign on duty without switching heat/cool (i.e. negative costs): - for hu in hu_sums1: hu.reverse() - hus_final = bst.HeatUtility.sum_by_agent(hu_sums1 + hu_sums2) - Q_bal = ( - (2.*sum([abs(i.Q) for i in new_HXs]) - + sum([abs(i.duty * i.agent.heat_transfer_efficiency) for i in hu_sums2])) - / sum([abs(i.duty * i.agent.heat_transfer_efficiency) for i in hu_sums1]) - ) - energy_balance_error = Q_bal - 1 - self.energy_balance_percent_error = 100 * energy_balance_error - - if new_HXs: - self.installed_costs['Heat exchangers'] = max(0, ( - sum(new_installed_costs_HXp) - + sum(new_installed_costs_HXu) - - sum(original_installed_costs) - )) - self.purchase_costs['Heat exchangers'] = self.baseline_purchase_costs['Heat exchangers'] = max(0, ( - sum(new_purchase_costs_HXp) - + sum(new_purchase_costs_HXu) - - sum(original_purchase_costs) - )) - if self.replace_unit_heat_utilities: - self.heat_utilities = [] - for hx_heat_util, new_hx_util in zip(hx_heat_utils_rearranged, new_HX_utils): - hx_heat_util.copy_like(new_hx_util.heat_utilities[0]) - hx_heat_util.unit.owner._load_utility_cost() # Update new utility cost - else: - self.heat_utilities = hus_final - else: # if no matches were made, retain all original HXutilities (i.e., don't add the -- relatively minor -- differences between new and original HXutilities) - self.installed_costs['Heat exchangers'] = 0. - self.baseline_purchase_costs['Heat exchangers'] = self.purchase_costs['Heat exchangers'] = 0. - self.heat_utilities = [] - self.original_heat_utils = hx_heat_utils_rearranged - self.original_purchase_costs = original_purchase_costs - self.original_utility_costs = hu_sums1 - self.new_purchase_costs_HXp = new_purchase_costs_HXp - self.new_purchase_costs_HXu = new_purchase_costs_HXu - self.new_utility_costs = hu_sums2 - new_hus = bst.process_tools.heat_exchanger_utilities_from_units(new_HX_utils) - hus_heating = [hu for hu in hx_utils if hu.duty > 0] - hus_cooling = [hu for hu in hx_utils if hu.duty < 0] - self.original_heat_util_load = sum([hu.duty for hu in hus_heating]) - self.original_cool_util_load = sum([abs(hu.duty) for hu in hus_cooling]) - self.actual_heat_util_load = sum([hu.duty for hu in new_hus if hu.duty>0]) - self.actual_cool_util_load = sum([abs(hu.duty) for hu in new_hus if hu.duty<0]) - if abs(energy_balance_error) > self.acceptable_energy_balance_error: - if use_cached_network: - del self.original_heat_utils - self._cost() - return - msg = ("heat exchanger network energy balance is off by " - f"{energy_balance_error:.2%} (an absolute error greater " - f"than {self.acceptable_energy_balance_error:.2%})") - if self.raise_energy_balance_error: - raise RuntimeError(msg) - else: - warn(msg, RuntimeWarning, stacklevel=2) - - def _energy_balance_error_contributions(self): - original_ignored = ignored = self.ignored - if ignored and callable(ignored): ignored = ignored() - energy_balance_errors = {} - for hu in self._get_original_heat_utilties(): - self.ignored = list(ignored or ()) + [hu.unit] - if hasattr(hu.unit, 'owner'): - ID = hu.unit.owner.ID, hu.unit.ID - else: - ID = hu.unit.ID - try: - self.simulate() - except: - energy_balance_errors[ID] = (hu, None) - else: - energy_balance_errors[ID] = (hu, self.energy_balance_percent_error) - self.ignored = original_ignored - return energy_balance_errors - - def _get_stream_life_cycles(self): - cold_indices = self.cold_indices - new_HXs = self.new_HXs - new_HX_utils = self.new_HX_utils - streams = self.streams_inlet - indices = [i for i in range(len(streams))] - SLCs = [StreamLifeCycle(index, index in cold_indices) for index in indices] - for SLC in SLCs: - SLC.get_life_cycle(new_HXs, new_HX_utils) - stream_life_cycles = SLCs - self.stream_life_cycles = stream_life_cycles - return stream_life_cycles - - def plot_pinch_diagram(self, file=None, **kwargs): - """ - Draw the pinch diagram of the synthesized network; see - :func:`~biosteam.facilities.hxn.hxn_synthesis.plot_pinch_diagram` - for the keyword arguments. Returns the matplotlib figure and axes. - """ - if not hasattr(self, 'new_HXs_hot_side'): - raise RuntimeError('simulate the heat exchanger network before ' - 'plotting its pinch diagram') - return plot_pinch_diagram( - self.stream_life_cycles, self.inlet_Ts, self.outlet_Ts, - self.new_HXs_hot_side, self.new_HXs_cold_side, - Qmin=self.Qmin, original_hxs=self.original_heat_exchangers, - file=file, **kwargs, - ) - - def get_original_hxs_associated_with_streams(self): # pragma: no cover - original_units = self.system.units - original_heat_utils = self.original_heat_utils - original_hx_utils = [i.unit for i in original_heat_utils] - original_hxs = {} - stream_index = 0 - for hx in original_hx_utils: - if '.' in hx.ID: # Names like 'U.1', i.e. non-explicitly named unit (e.g. auxillary HX) - for unit in original_units: - if isinstance(unit, bst.units.MultiEffectEvaporator): - for key, component in unit.components.items(): - if isinstance(component, list): - for subcomponent in component: - if subcomponent is hx: - original_hxs[stream_index] = (unit, key) - elif component is hx: - original_hxs[stream_index] = (unit, key) - elif isinstance(unit, bst.units.BinaryDistillation)\ - or isinstance(unit, bst.units.ShortcutColumn): - if unit.boiler is hx: - original_hxs[stream_index] = (unit, 'boiler') - elif unit.condenser is hx: - original_hxs[stream_index] = (unit, 'condenser') - elif hasattr(unit, 'heat_exchanger'): - if unit.heat_exchanger is hx: - original_hxs[stream_index] = (unit, 'heat exchanger') - else: # Explicitly named unit - original_hxs[stream_index] = (hx, '') - stream_index += 1 - self.original_hxs = original_hxs - return original_hxs - - def save_stream_life_cycles_as_csv(self): # pragma: no cover - if not hasattr(self, 'stream_life_cycles'): - self.stream_life_cycles = self._get_stream_life_cycles() - stream_life_cycles = self.stream_life_cycles - if not hasattr(self, 'original_hxs'): - self.original_hxs = self.get_original_hxs_associated_with_streams() - original_hxs = self.original_hxs - import csv - from datetime import datetime - dateTimeObj = datetime.now() - filename = 'HXN-%s_%s.%s.%s.%s.%s.csv'%(self.system.ID, dateTimeObj.year, - dateTimeObj.month, dateTimeObj.day, - dateTimeObj.hour, dateTimeObj.minute) - csvWriter = csv.writer(open(filename, 'w'), delimiter=',') - csvWriter.writerow(['Stream', 'Type', 'Original unit', 'HXN unit', 'H_in (kJ)', - 'H_out (kJ)', 'T_in (C)', 'T_out (C)']) - stream, streamtype, original_unit, hxn_unit, H_in, H_out, T_in, T_out =\ - 0, 0, 0, 0, 0, 0, 0, 0 - - inlet_Ts = self.inlet_Ts - outlet_Ts = self.outlet_Ts - for life_cycle in stream_life_cycles: - stream = life_cycle.index - streamtype = 'Cold' if life_cycle.cold else 'Hot' - stage_no = 0 - stages = life_cycle.life_cycle - len_stages = len(stages) - for stage in stages: - original_unit = original_hxs[stream][0].ID - if original_hxs[stream][1]: - original_unit+= ' - ' + original_hxs[stream][1] - - hxn_unit = stage.unit - hxn_unit_ID = hxn_unit.ID - H_in = stage.H_in - H_out = stage.H_out - T_in, T_out = None, None - if stage_no == 0: - T_in = inlet_Ts[stream] - 273.15 - if stage_no == len_stages - 1: - T_out = outlet_Ts[stream] - 273.15 - - row = [stream, streamtype, original_unit, hxn_unit_ID, - H_in, H_out, T_in, T_out] - csvWriter.writerow(row) - stage_no += 1 diff --git a/biosteam/facilities/hxn/hxn_synthesis.py b/biosteam/facilities/hxn/hxn_synthesis.py deleted file mode 100644 index c47dde15..00000000 --- a/biosteam/facilities/hxn/hxn_synthesis.py +++ /dev/null @@ -1,1032 +0,0 @@ -# -*- coding: utf-8 -*- -# HXN: The automated Heat Exchanger Network design package. -# Copyright (C) 2020-, Sarang Bhagwat -# -# This module is under the UIUC open-source license. See -# github.com/sarangbhagwat/hxn/blob/master/LICENSE.txt -# for license details. -""" -Created on Sat May 2 16:44:24 2020 - -@author: sarangbhagwat -""" -from collections import namedtuple -import heapq -import numpy as np -import biosteam as bst -from warnings import warn - -__all__ = ('StreamLifeCycle', 'ProblemTable', 'problem_table', - 'synthesize_network', 'plot_pinch_diagram') - -class LifeStage: - - def __init__(self, unit, index): - self.unit = unit - self.index = index - - @property - def s_in(self): return self.unit.ins[self.index] - - @property - def s_out(self): return self.unit.outs[self.index] - - @property - def H_in(self): return self.s_in.H - - @property - def H_out(self): return self.s_out.H - - def _info(self, N_tabs=1): - tabs = N_tabs*'\t' - return (f"{type(self).__name__}: {self.unit.ID}\n" - + tabs + f"H_in = {self.H_in:.3g} kJ\n" - + tabs + f"H_out = {self.H_out:.3g} kJ") - - def __repr__(self): - return (f"<{type(self).__name__}: {repr(self.unit)}, H_in = {round(self.H_in, 4):.3g} kJ, H_out = {round(self.H_out, 4):.3g} kJ>") - - def show(self): - print(self._info()) - _ipython_display_ = show - - -class StreamLifeCycle: - - def __init__(self, index, cold): - self.index = index - self.name = 's_%s'%index - self.cold = cold - self.life_cycle = None - - def get_relevant_units(self, index, new_HXs, new_HX_utils): - new_HXs_relevant = [hx for hx in new_HXs if '_%s_'%index in hx.ID] - new_HX_utils_relevant = [hx for hx in new_HX_utils if '_%s_'%index in hx.ID] - return new_HXs_relevant, new_HX_utils_relevant - - def get_life_cycle(self, new_HXs, new_HX_utils): - index = self.index - name = self.name - cold = self.cold - new_HXs_relevant, new_HX_utils_relevant =\ - self.get_relevant_units(index, new_HXs, new_HX_utils) - life_cycle = ( - [LifeStage(unit, 0) for unit in new_HXs_relevant if name + '_' in unit.ins[0].ID] - + [LifeStage(unit, 1) for unit in new_HXs_relevant if name + '_' in unit.ins[1].ID] - + [LifeStage(unit, 0) for unit in new_HX_utils_relevant if name + '_' in unit.ins[0].ID] - ) - life_cycle.sort(key = lambda pt: pt.H_in, reverse = not cold) - self.life_cycle = life_cycle - return life_cycle - - def __repr__(self): - life_cycle = self.life_cycle - cold = self.cold - if not self.life_cycle: - return 'Not initialized; run StreamLifeCycle.get_life_cycle or\ - HX_Network.get_stream_life_cycles first.' - else: - index = self.index - name = 'Stream_%s'%index - strtype = 'cold' if cold else 'hot' - rep = '' - for LifeStage in life_cycle: - line = '\t\t' + repr(LifeStage) + '\n' - rep += line - rep = '' - return rep - - def show(self): - info = repr(self).replace('[', '').replace(']', '').replace('life_cycle =', 'life_cycle:') - print(info[1:-1]) - - _ipython_display_ = show - - -class Working_Life_Cycle: - - def __init__(self, index, cold): - self.index = index - self.name = 's_%s'%index - self.cold = cold - self.life_cycle = life_cycle = {} - life_cycle['cold_side'] = [] - life_cycle['hot_side'] = [] - - def add_stage(self, s_in, s_out, side): - self.life_cycle[side].append(LifeStage(s_in, s_out)) - - def sort_stages(self): - life_cycle = self.life_cycle - reverse = not self.cold - life_cycle['cold_side'].sort(key = lambda stage: stage.H, reverse = reverse) - life_cycle['cold_side'].sort(key = lambda stage: stage.H, reverse = reverse) - - def get_sorted_life_cycle(self): - self.sort_stages() - return self.life_cycle - - -ProblemTable = namedtuple( - 'ProblemTable', - ['Ts', 'interval_H', 'point_H', 'residual', - 'hot_util_load', 'cold_util_load', 'pinch_T'] -) - -def _stream_H_at_boundaries(stream_in, H_in, H_out, T_lo, T_hi, Ts, shift, - stream_label): - """ - Enthalpies [kJ/hr] of one monotone stream at the grid boundaries - `Ts` (shifted scale, descending, all within [T_lo, T_hi]). - - Exact at the stream's own end points (H_in/H_out as given) by - *position*: `Ts[0]` and `Ts[-1]` are the stream's own T_hi/T_lo (every - monotone stream has `T_hi > T_lo` strictly, so `Ts` always has at least - these two entries) and are assigned H_in/H_out directly, without a float - comparison. In between, the inlet copy is flashed at the *real* - temperature `T + shift` and the result is clipped to - [min(H_in, H_out), max(H_in, H_out)] so that a non-equilibrium outlet - (e.g. a column reboiler/condenser product) can never inflate an - interval. A single copy is walked down the grid so each VLE is - warm-started from the previous boundary; `stream_label` (the inlet - stream's own ID) identifies the stream in the VLE-failure warning. - """ - assert Ts.size >= 2, ( - "boundary grid for a monotone stream must include both its own " - "end points" - ) - H_lo, H_hi = sorted((H_in, H_out)) - H_top, H_bottom = (H_in, H_out) if H_in > H_out else (H_out, H_in) - Hs = np.empty(Ts.size) - Hs[0] = H_top - Hs[-1] = H_bottom - stream = stream_in.copy() - for k in range(1, Ts.size - 1): - T = Ts[k] - T_real = T + shift - try: - stream.vle(T=T_real, P=stream.P) - H = stream.H - except Exception as error: - warn(f"could not solve VLE for stream {stream_label!r} at " - f"{T_real:.2f} K ({error!r}); interpolating enthalpy " - "linearly in temperature for the problem table", - RuntimeWarning) - # restart the warm start from a clean copy so the failed flash - # does not leave `stream` in a bad state for the next boundary - stream = stream_in.copy() - H = H_lo + (H_hi - H_lo) * (T - T_lo) / (T_hi - T_lo) - Hs[k] = min(max(H, H_lo), H_hi) - return Hs - -def problem_table(streams_inlet, streams_quenched, is_hot, T_min_app): - """ - Energy-consistent problem table (temperature-interval heat cascade). - - Parameters - ---------- - streams_inlet : list[Stream] - Inlet stream of each utility heat exchanger. - streams_quenched : list[Stream] - Corresponding outlet streams, re-flashed at their enthalpy. - is_hot : Sequence[bool] - True where the stream is cooled. - T_min_app : float - Minimum approach temperature [K]. - - Returns - ------- - ProblemTable - Grid temperatures `Ts` (shifted scale, descending), per-stream - `interval_H` (N x n-1) and `point_H` (N x n) contributions (+ for - hot, - for cold), the cascade `residual` (n) *leaving* each - boundary (i.e. after its point loads), `hot_util_load`, - `cold_util_load` and the shifted-scale `pinch_T`. - - Notes - ----- - Hot streams are shifted down by `T_min_app`; cold streams are not. For - monotone streams the contribution to interval (Ts[k], Ts[k+1]) is - sign * (H(Ts[k]) - H(Ts[k+1])) with H evaluated at the real temperature - and clipped to [H_in, H_out], so every stream's contributions telescope - exactly to sign * |H_out - H_in|. Isothermal streams, and streams whose - outlet temperature moves against their duty (a heated stream that exits - colder than it entered, e.g. a reboiler outlet at VLE), are point loads - at their outlet temperature. The cascade starting from zero hot utility - is residual[k] = sum(point_H[:, :k+1]) + sum(interval_H[:, :k]), the - heat *leaving* boundary Ts[k]. Feasibility must also hold for the heat - *arriving* at Ts[k] before its point loads are applied, - arriving[k] = residual[k] - sum(point_H[:, k]), because a source at - Ts[k] cannot serve a sink above Ts[k]. The minimum over both flows, - min(residual, arriving), fixes the hot utility target, - `residual[-1] + hot_util_load` the cold one, and its location the - pinch. With the per-stream identity above, hot_util_load - - cold_util_load equals the net heating demand. - - Examples - -------- - A threshold problem: 1000 kmol/hr of water cooled 400 -> 300 K supplies - every interval of 900 kmol/hr of water heated 300 -> 390 K, so no hot - utility is needed and the surplus leaves as cold utility. - - >>> import biosteam as bst - >>> from biosteam.facilities.hxn.hxn_synthesis import problem_table - >>> bst.settings.set_thermo(['Water']) - >>> hot_in = bst.Stream(Water=1000., T=400., P=5e5, phase='l', units='kmol/hr') - >>> hot_out = hot_in.copy(); hot_out.vle(T=300., P=5e5) - >>> cold_in = bst.Stream(Water=900., T=300., P=5e5, phase='l', units='kmol/hr') - >>> cold_out = cold_in.copy(); cold_out.vle(T=390., P=5e5) - >>> table = problem_table([hot_in, cold_in], [hot_out, cold_out], - ... [True, False], 5.) - >>> table.Ts - array([395., 390., 300., 295.]) - >>> round(table.hot_util_load, 3) - 0.0 - >>> round(table.cold_util_load, -1) - 1445550.0 - >>> table.pinch_T - 395.0 - """ - N = len(streams_inlet) - is_hot = np.asarray(is_hot, dtype=bool) - sign = np.where(is_hot, 1., -1.) - shift = np.where(is_hot, T_min_app, 0.) - T_in = np.array([s.T for s in streams_inlet]) - T_out = np.array([s.T for s in streams_quenched]) - H_in = np.array([s.H for s in streams_inlet]) - H_out = np.array([s.H for s in streams_quenched]) - monotone = (sign * (T_in - T_out)) > 0. - T_hi = np.where(monotone, np.maximum(T_in, T_out), T_out) - shift - T_lo = np.where(monotone, np.minimum(T_in, T_out), T_out) - shift - Ts = np.unique(np.concatenate([T_hi, T_lo]))[::-1] - n = Ts.size - interval_H = np.zeros((N, n - 1)) - point_H = np.zeros((N, n)) - for j in range(N): - if monotone[j]: - idx = np.flatnonzero((Ts <= T_hi[j]) & (Ts >= T_lo[j])) - Hs = _stream_H_at_boundaries(streams_inlet[j], H_in[j], H_out[j], - T_lo[j], T_hi[j], Ts[idx], shift[j], - streams_inlet[j].ID) - interval_H[j, idx[:-1]] = sign[j] * (Hs[:-1] - Hs[1:]) - else: - k = np.searchsorted(-Ts, -T_hi[j]) - point_H[j, k] = sign[j] * abs(H_out[j] - H_in[j]) - point_total = point_H.sum(axis=0) - residual = np.cumsum( - point_total + np.concatenate([[0.], interval_H.sum(axis=0)]) - ) - # heat arriving at each boundary, before that boundary's point loads: - # a point source at Ts[k] cannot serve sinks above Ts[k], so the cascade - # must be non-negative both before and after the point loads - arriving = residual - point_total - flow = np.minimum(residual, arriving) - k_pinch = int(np.argmin(flow)) - scale = np.abs(H_out - H_in).sum() - if -flow[k_pinch] <= 1e-9 * scale: # threshold problem: no hot utility - hot_util_load = 0. - k_pinch = 0 - else: - hot_util_load = -flow[k_pinch] - cold_util_load = residual[-1] + hot_util_load - if cold_util_load < 0.: - # only reachable in the threshold branch, by at most 1e-9 * scale: - # absorb the rounding into the hot utility so that - # hot_util_load - cold_util_load == sum(unit_duty) stays exact - hot_util_load -= cold_util_load - cold_util_load = 0. - return ProblemTable(Ts, interval_H, point_H, residual, - hot_util_load, cold_util_load, Ts[k_pinch]) - -def temperature_interval_pinch_analysis(hus, - T_min_app=10, - force_ideal_thermo=False, - sort_hus_by_T=False): - hx_utils = hus - hus_heating = [hu for hu in hx_utils if hu.duty > 0] - hus_cooling = [hu for hu in hx_utils if hu.duty < 0] - if sort_hus_by_T: - hus_heating.sort(key=lambda i: i.unit.ins[0].T, reverse=True) - hus_cooling.sort(key=lambda i: i.unit.ins[0].T) - hx_utils_rearranged = hus_heating + hus_cooling - hxs = [hu.unit for hu in hx_utils_rearranged] - if force_ideal_thermo: - streams_inlet = [hx.ins[0] for hx in hxs] - streams_quenched = [i.outs[0] for i in hxs] - streams_inlet = [i.copy(thermo=i.thermo.ideal()) for i in streams_inlet] - streams_quenched = [i.copy(thermo=i.thermo.ideal()) for i in streams_quenched] - else: - streams_inlet = [hx.ins[0].copy() for hx in hxs] - streams_quenched = [i.outs[0].copy() for i in hxs] - for i in streams_quenched: i.vle(H=i.H, P=i.P) - for i in range(len(streams_inlet)): - stream = streams_inlet[i] - ID = 'Util_%s'%i - stream.ID = 's_%s__%s'%(i,ID) - N_heating = len(hus_heating) - cold_indices = list(range(N_heating)) - hot_indices = list(range(N_heating, len(hxs))) - indices = cold_indices + hot_indices - T_in_arr = np.array([stream.T for stream in streams_inlet]) - T_out_arr = np.array([i.T for i in streams_quenched]) - is_hot = np.zeros(len(hxs), dtype=bool) - is_hot[hot_indices] = True - table = problem_table(streams_inlet, streams_quenched, is_hot, T_min_app) - hot_util_load = table.hot_util_load - cold_util_load = table.cold_util_load - pinch_cold_stream_T = table.pinch_T - pinch_hot_stream_T = pinch_cold_stream_T + T_min_app - # Per-stream pinch temperature: where each stream is split between the - # hot-side and cold-side network designs. A stream already entirely on - # one side of the process pinch (T_in past pinch_cold_stream_T for a - # cold stream, or past pinch_hot_stream_T for a hot stream) is not - # split; its pinch_T is its own T_in. This clause also catches - # non-monotone streams (T_out on the wrong side of T_in for their duty, - # e.g. a cold stream whose VLE outlet ends up cooler than it entered): - # rather than split their problem_table point-load duty across the - # cascade, they get pinch_T = T_in too, so load_duties assigns their - # whole duty to a single side (Q_hot_side for a cold stream, - # Q_cold_side for a hot one). - pinch_T_arr = [] - for i in cold_indices: - if T_in_arr[i] > pinch_cold_stream_T or T_in_arr[i] > T_out_arr[i]: - pinch_T_arr.append(T_in_arr[i]) - elif T_out_arr[i] < pinch_cold_stream_T: - pinch_T_arr.append(T_out_arr[i]) - else: - pinch_T_arr.append(pinch_cold_stream_T) - for i in hot_indices: - if T_in_arr[i] < pinch_hot_stream_T or T_in_arr[i] < T_out_arr[i]: - pinch_T_arr.append(T_in_arr[i]) - elif T_out_arr[i] > pinch_hot_stream_T: - pinch_T_arr.append(T_out_arr[i]) - else: - pinch_T_arr.append(pinch_hot_stream_T) - pinch_T_arr = np.array(pinch_T_arr) - return pinch_T_arr, hot_util_load, cold_util_load, T_in_arr, T_out_arr,\ - hxs, hot_indices, cold_indices, indices, streams_inlet, hx_utils_rearranged, \ - streams_quenched - - -def _end_state(stream_end, T_lo, T_hi): - """ - Return a copy of `stream_end` at equilibrium at its own enthalpy, or the - stream as given if that equilibrium state lies outside the stream's own - temperature range [T_lo, T_hi] (e.g. a non-condensable mislabelled as a - liquid, whose equilibrium state at the same enthalpy is a gas at an - absurd temperature). Either way the enthalpy is exactly `stream_end.H`. - """ - stream = stream_end.copy() - try: - stream.vle(H=stream_end.H, P=stream.P) - except Exception: - return stream_end.copy() - if T_lo <= stream.T <= T_hi: return stream - return stream_end.copy() - -def pinch_state(stream_in, stream_out, T_pinch): - """ - Return a copy of the stream in the state it has when it crosses the - pinch, with enthalpy guaranteed to lie within [min(H_in, H_out), - max(H_in, H_out)]. - - `stream_in` and `stream_out` are the stream's real end states (the - outlet quenched to equilibrium at its own enthalpy). For an interior - pinch the inlet copy is flashed at `T_pinch`; the result is used as is - when its enthalpy lies within the stream's own range. Otherwise the - stream never passes through that equilibrium state: a non-equilibrium - inlet (e.g. a superheated liquid from a non-rigorous HXutility) has - less enthalpy than the equilibrium fluid at the pinch, and the state - returned is instead the equilibrium state at the nearer end enthalpy. - The same end state is returned when `T_pinch` coincides with an end - temperature, because flashing a non-equilibrium inlet at its own - temperature does not reproduce `H_in` (and the result may even lie - inside the range). Using the *equilibrium* state at the end enthalpy, - rather than the stream as given, keeps the synthesizer consistent with - the problem table: the heat is offered at the temperature the - equilibrium model says it is available, not at a fictitious one; see - `_end_state` for the fallback when that state is unphysical. - - Either way the hot-side and cold-side loads split `|H_in - H_out|` - exactly and the transient stream used for matching never carries heat - the real stream does not have. This is the synthesizer's counterpart of - the clipping done by `_stream_H_at_boundaries` for the problem table. - """ - T_lo, T_hi = sorted((stream_in.T, stream_out.T)) - if T_pinch == stream_in.T: return _end_state(stream_in, T_lo, T_hi) - if T_pinch == stream_out.T: return _end_state(stream_out, T_lo, T_hi) - stream = stream_in.copy() - stream.vle(T=T_pinch, P=stream.P) - H_in = stream_in.H - H_out = stream_out.H - H_lo, H_hi = sorted((H_in, H_out)) - H = stream.H - if H_lo <= H <= H_hi: return stream - H_clipped = H_lo if H < H_lo else H_hi - return _end_state(stream_in if H_clipped == H_in else stream_out, T_lo, T_hi) - -def load_duties(streams, streams_quenched, pinch_T_arr, T_out_arr, indices, is_cold, Q_hot_side, Q_cold_side): - for index in indices: - H_in = streams[index].H - H_out = streams_quenched[index].H - H_pinch = pinch_state(streams[index], streams_quenched[index], pinch_T_arr[index]).H - if not is_cold(index): - dH1 = H_in - H_pinch - dH2 = H_pinch - H_out - if abs(dH1)<0.01: dH1 = 0 - if abs(dH2)<0.01: dH2 = 0 - Q_hot_side[index] = ['cool', dH1] - Q_cold_side[index] = ['cool', dH2] - else: - dH1 = H_out - H_pinch - dH2 = H_pinch - H_in - if abs(dH1)<0.01: dH1 = 0 - if abs(dH2)<0.01: dH2 = 0 - Q_hot_side[index] = ['heat', dH1] - Q_cold_side[index] = ['heat', dH2] - - -def get_T_transient(pinch_T_arr, indices, T_in_arr): - T_transient = pinch_T_arr.copy() - T_transient[indices] = T_in_arr[indices] - return T_transient - -def synthesize_network(hus, T_min_app=5., Qmin=1e-3, force_ideal_thermo=False, - avoid_recycle=False, sort_hus_by_T=False): - pinch_T_arr, hot_util_load, cold_util_load, T_in_arr, T_out_arr,\ - hxs, hot_indices, cold_indices, indices, streams_inlet, hx_utils_rearranged, \ - streams_quenched = temperature_interval_pinch_analysis(hus, T_min_app, force_ideal_thermo, - sort_hus_by_T) - H_out_arr = [i.H for i in streams_quenched] - duties = np.array([abs(hx.Q) for hx in hxs]) - dTs = np.abs(T_in_arr - T_out_arr) - dTs[dTs == 0.] = 1e-12 - C_flow_vector = duties/dTs - Q_hot_side = {} - Q_cold_side = {} - stream_HXs_dict = {i:[] for i in indices} - is_cold = lambda x: x in cold_indices - load_duties(streams_inlet, streams_quenched, pinch_T_arr, T_out_arr, indices, is_cold, Q_hot_side, Q_cold_side) - matches_hs = {i: [] for i in cold_indices} - matches_cs = {i: [] for i in hot_indices} - HXs_hot_side = [] - HXs_cold_side = [] - streams_transient_cold_side = streams_inlet - streams_transient_hot_side = [i.copy() for i in streams_inlet] - # Hot streams enter the cold-side design at their pinch state and cold - # streams enter the hot-side design at theirs; the enthalpy of that - # state is clipped to the stream's real range (see `pinch_state`). - for i in hot_indices: - s = streams_transient_cold_side[i] - if s.T != pinch_T_arr[i]: - streams_transient_cold_side[i] = pinch_state(s, streams_quenched[i], pinch_T_arr[i]) - for i in cold_indices: - s = streams_transient_hot_side[i] - if s.T != pinch_T_arr[i]: - streams_transient_hot_side[i] = pinch_state(s, streams_quenched[i], pinch_T_arr[i]) - - def get_stream_at_H_max(cold): - s_cs = streams_transient_cold_side[cold] - s_hs = streams_transient_hot_side[cold] - return s_cs if s_cs.H > s_hs.H else s_hs - - def get_stream_at_H_min(hot): - s_cs = streams_transient_cold_side[hot] - s_hs = streams_transient_hot_side[hot] - return s_cs if s_cs.H < s_hs.H else s_hs - - def get_T_transient_cold_side(index): - return streams_transient_cold_side[index].T - - def get_T_transient_hot_side(index): - return streams_transient_hot_side[index].T - - attempts = set() - success = set() - # ------------- Cold side design ------------- # - unavailables = set([i for i in hot_indices if T_out_arr[i] >= pinch_T_arr[i]]) - unavailables.update([i for i in cold_indices if T_in_arr[i] >= pinch_T_arr[i]]) - for hot in hot_indices: - stream_quenched = False - potential_matches = [] - for cold in cold_indices: - if (C_flow_vector[hot]>= C_flow_vector[cold] and - get_T_transient_cold_side(hot) > get_T_transient_cold_side(cold) + T_min_app and - (hot not in unavailables) and (cold not in unavailables) and - (cold not in matches_cs[hot]) and (cold in cold_indices)): - potential_matches.append(cold) - potential_matches = sorted( - potential_matches, - key = lambda pot_cold: min(C_flow_vector[hot], C_flow_vector[pot_cold]) - * (get_T_transient_cold_side(hot) - - get_T_transient_cold_side(pot_cold) - - T_min_app), - reverse = True - ) - for cold in potential_matches: - match = (hot, cold) - ID = 'HX_%s_%s_cs' % match - if ID in attempts or (avoid_recycle and match in success): continue - attempts.add(ID) - hot_stream = streams_transient_cold_side[hot].copy() - cold_stream = streams_transient_cold_side[cold].copy() - - hot_stream.ID = 's_%s__%s'%(hot,ID) - cold_stream.ID = 's_%s__%s'%(cold,ID) - hot_out = hot_stream.copy('%s__s_%s'%(ID,hot)) - cold_out = cold_stream.copy('%s__s_%s'%(ID,cold)) - H_lim = H_out_arr[hot] - new_HX = bst.units.HXprocess(ID = ID, ins = (hot_stream, cold_stream), - outs = (hot_out, cold_out), H_lim0 = H_lim, - T_lim1 = pinch_T_arr[cold], dT = T_min_app, - thermo = hot_stream.thermo) - try: new_HX._run() - except: continue - if abs(new_HX.Q )< Qmin: continue - success.add(match) - HXs_cold_side.append(new_HX) - stream_HXs_dict[hot].append(new_HX) - stream_HXs_dict[cold].append(new_HX) - Q_cold_side[hot][1] -= new_HX.Q - Q_cold_side[cold][1] -= new_HX.Q - streams_transient_cold_side[hot] = new_HX.outs[0] - streams_transient_cold_side[cold] = new_HX.outs[1] - H_out = new_HX.outs[0].H - assert H_out - new_HX.ins[0].H <= 0. - stream_quenched = H_out < H_lim or np.allclose(H_out, H_lim) - matches_cs[hot].append(cold) - if stream_quenched: - break - - # ------------- Hot side design ------------- # - unavailables = set([i for i in hot_indices if T_in_arr[i] <= pinch_T_arr[i]]) - unavailables.update([i for i in cold_indices if T_out_arr[i] <= pinch_T_arr[i]]) - - for cold in cold_indices: - potential_matches = [] - for hot in hot_indices: - if ((cold in matches_cs and hot in matches_cs[cold]) - or (cold in matches_hs and hot in matches_hs[cold])): - break - if (C_flow_vector[cold]>= C_flow_vector[hot] and - get_T_transient_hot_side(hot) > get_T_transient_hot_side(cold) + T_min_app and - (hot not in unavailables) and (cold not in unavailables) and - (hot not in matches_hs[cold]) and (hot in hot_indices)): - potential_matches.append(hot) - - potential_matches = sorted(potential_matches, key = lambda x: - (min(C_flow_vector[cold], C_flow_vector[x]) - * ( get_T_transient_hot_side(x) - - get_T_transient_hot_side(cold) - T_min_app)), - reverse = True) - stream_quenched = False - for hot in potential_matches: - match = (hot, cold) - ID = 'HX_%s_%s_hs' % (cold, hot) - if ID in attempts or (avoid_recycle and match in success): continue - attempts.add(ID) - hot_stream = streams_transient_hot_side[hot].copy() - cold_stream = streams_transient_hot_side[cold].copy() - cold_stream.ID = 's_%s__%s'%(cold,ID) - hot_stream.ID = 's_%s__%s'%(hot,ID) - hot_out = hot_stream.copy('%s__s_%s'%(ID,hot)) - cold_out = cold_stream.copy('%s__s_%s'%(ID,cold)) - H_lim = H_out_arr[cold] - new_HX = bst.units.HXprocess(ID = ID, ins = (cold_stream, hot_stream), - outs = (cold_out, hot_out), H_lim0 = H_lim, - T_lim1 = pinch_T_arr[hot], dT = T_min_app, - thermo = hot_stream.thermo) - try: new_HX._run() - except: continue - if abs(new_HX.Q)< Qmin: continue - success.add(match) - HXs_hot_side.append(new_HX) - stream_HXs_dict[hot].append(new_HX) - stream_HXs_dict[cold].append(new_HX) - Q_hot_side[hot][1] -= new_HX.Q - Q_hot_side[cold][1] -= new_HX.Q - streams_transient_hot_side[cold] = new_HX.outs[0] - streams_transient_hot_side[hot] = new_HX.outs[1] - H_out = new_HX.outs[0].H - assert H_out - new_HX.ins[0].H >= 0. - stream_quenched = H_out > H_lim or np.allclose(H_out, H_lim) - matches_hs[cold].append(hot) - if stream_quenched: - break - - # Offset heating requirement on cold side - for cold in cold_indices: - if Q_cold_side[cold][0]=='heat' and Q_cold_side[cold][1]>0: - for hot in hot_indices: - match = (hot, cold) - ID = 'HX_%s_%s_cs' % match - if ID in attempts or (avoid_recycle and match in success): continue - attempts.add(ID) - T_cold_in = get_T_transient_cold_side(cold) - T_hot_in = get_T_transient_cold_side(hot) - if (Q_cold_side[hot][0]=='cool' and Q_cold_side[hot][1]>0 and - T_hot_in - T_cold_in >= T_min_app): - hot_stream = streams_transient_cold_side[hot].copy() - cold_stream = streams_transient_cold_side[cold].copy() - hot_stream.ID = 's_%s__%s'%(hot,ID) - cold_stream.ID = 's_%s__%s'%(cold,ID) - hot_out = hot_stream.copy('%s__s_%s'%(ID,hot)) - cold_out = cold_stream.copy('%s__s_%s'%(ID,cold)) - new_HX = bst.units.HXprocess(ID = ID, ins = (hot_stream, cold_stream), - outs = (hot_out, cold_out), H_lim0 = H_out_arr[hot], - T_lim1 = T_out_arr[cold], dT = T_min_app, - thermo = hot_stream.thermo) - try: new_HX._run() - except: continue - if abs(new_HX.Q )< Qmin: continue - success.add(match) - HXs_cold_side.append(new_HX) - stream_HXs_dict[hot].append(new_HX) - stream_HXs_dict[cold].append(new_HX) - Q_cold_side[hot][1] -= new_HX.Q - Q_cold_side[cold][1] -= new_HX.Q - streams_transient_cold_side[hot] = new_HX.outs[0] - streams_transient_cold_side[cold] = new_HX.outs[1] - matches_cs[hot].append(cold) - - # Offset cooling requirement on hot side - for hot in hot_indices: - stream_quenched = False - if Q_hot_side[hot][0]=='cool' and Q_hot_side[hot][1]>0: - for cold in cold_indices: - match = (hot, cold) - ID = 'HX_%s_%s_hs' % (cold, hot) - if ID in attempts or (avoid_recycle and match in success): continue - attempts.add(ID) - original_cold_stream = get_stream_at_H_max(cold) - T_cold_in = original_cold_stream.T - T_hot_in = get_T_transient_hot_side(hot) - if (Q_hot_side[cold][0]=='heat' and Q_hot_side[cold][1]>0 and - T_hot_in - T_cold_in>= T_min_app): - cold_stream = original_cold_stream - hot_stream = streams_transient_hot_side[hot].copy() - cold_stream.ID = 's_%s__%s'%(cold,ID) - hot_stream.ID = 's_%s__%s'%(hot,ID) - hot_out = hot_stream.copy('%s__s_%s'%(ID,hot)) - cold_out = cold_stream.copy('%s__s_%s'%(ID,cold)) - H_lim = H_out_arr[cold] - new_HX = bst.units.HXprocess(ID = ID, ins = (cold_stream, hot_stream), - outs = (cold_out, hot_out), H_lim0 = H_lim, - T_lim1 = T_out_arr[hot], dT = T_min_app, - thermo = hot_stream.thermo) - try: new_HX._run() - except: continue - if abs(new_HX.Q )< Qmin: continue - success.add(match) - HXs_hot_side.append(new_HX) - stream_HXs_dict[hot].append(new_HX) - stream_HXs_dict[cold].append(new_HX) - Q_hot_side[hot][1] -= new_HX.Q - Q_hot_side[cold][1] -= new_HX.Q - streams_transient_hot_side[cold] = new_HX.outs[0] - streams_transient_hot_side[hot] = new_HX.outs[1] - H_out = new_HX.outs[0].H - assert H_out - new_HX.ins[0].H >= 0. - stream_quenched = H_out > H_lim or np.allclose(H_out, H_lim) - matches_hs[cold].append(hot) - if stream_quenched: - break - - # Add final utility HXs - new_HX_utils = [] - for hot in hot_indices: - hot_stream = get_stream_at_H_min(hot) - ID = 'Util_%s_cs'%(hot) - hot_stream.ID = 's_%s__%s'%(hot,ID) - outlet = hot_stream.copy('%s__s_%s'%(ID,hot)) - new_HX_util = bst.units.HXutility(ID = ID, ins = hot_stream, outs = outlet, - H = H_out_arr[hot], rigorous = True, - thermo = hot_stream.thermo) - new_HX_util._run() - s_out = new_HX_util-0 - np.testing.assert_allclose(s_out.H, H_out_arr[hot], rtol=5e-3, atol=1.) - atol_T = 5. if 's' in hxs[hot].outs[0].phases else 0.001 - np.testing.assert_allclose(s_out.T, T_out_arr[hot], rtol=5e-3, atol=atol_T) - new_HX_utils.append(new_HX_util) - stream_HXs_dict[hot].append(new_HX_util) - - for cold in cold_indices: - cold_stream = get_stream_at_H_max(cold) - ID = 'Util_%s_hs'%(cold) - cold_stream.ID = 's_%s__%s'%(cold,ID) - outlet = cold_stream.copy('%s__s_%s'%(ID,cold)) - new_HX_util = bst.units.HXutility(ID = ID, ins = cold_stream, outs = outlet, - H = H_out_arr[cold], rigorous = True, - thermo = cold_stream.thermo) - new_HX_util._run() - s_out = new_HX_util.outs[0] - np.testing.assert_allclose(s_out.H, H_out_arr[cold], rtol=1e-2, atol=1.) - atol_T = 5. if 's' in hxs[cold].outs[0].phases else 0.001 - np.testing.assert_allclose(s_out.T, T_out_arr[cold], rtol=5e-2, atol=atol_T) - new_HX_utils.append(new_HX_util) - stream_HXs_dict[cold].append(new_HX_util) - - return HXs_hot_side, HXs_cold_side, new_HX_utils, hxs, T_in_arr,\ - T_out_arr, pinch_T_arr, C_flow_vector, hx_utils_rearranged, streams_inlet, stream_HXs_dict,\ - hot_indices, cold_indices - - - -# Pinch diagram - -def _order_exchanger_columns(hxs, stream_life_cycles): - """ - Order heat exchangers left to right so that every stream meets its - exchangers in flow direction (cold streams flow left to right, hot streams - right to left). The per-stream stage orders define a precedence graph; - a topological sort (Kahn's algorithm, ties broken by the given order) - yields a consistent layout. Contradictory constraints, which would need a - stream to flow backwards, fall back to the given order. - """ - hxs = list(hxs) - position = {hx: i for i, hx in enumerate(hxs)} - successors = {hx: [] for hx in hxs} - N_predecessors = {hx: 0 for hx in hxs} - for life_cycle in stream_life_cycles: - stages = [i.unit for i in life_cycle.life_cycle if i.unit in position] - if not life_cycle.cold: stages.reverse() - for a, b in zip(stages, stages[1:]): - if b not in successors[a]: - successors[a].append(b) - N_predecessors[b] += 1 - ready = [position[hx] for hx in hxs if not N_predecessors[hx]] - heapq.heapify(ready) - ordered = [] - while ready: - hx = hxs[heapq.heappop(ready)] - ordered.append(hx) - for other in successors[hx]: - N_predecessors[other] -= 1 - if not N_predecessors[other]: heapq.heappush(ready, position[other]) - return ordered if len(ordered) == len(hxs) else hxs - -def _format_H(H): - mantissa, exponent = f'{H:.2e}'.split('e') - return f'{mantissa}E{int(exponent)}' - -def _auxiliary_name(unit): - """ - Return the (dotted) name of an auxiliary unit within its owner, e.g. - 'condenser' or 'evaporators[0].heat_exchanger', or None if the unit is - not auxiliary. - """ - owner = unit.owner - if owner is unit: return None - def search(parent, prefix): - for name, aux in parent.get_auxiliary_units_with_names(): - if aux is unit: return prefix + name - if hasattr(aux, 'get_auxiliary_units_with_names'): - found = search(aux, prefix + name + '.') - if found: return found - return search(owner, '') or unit.ID.lstrip('.') - -def _stream_label(hx, show_units, show_auxiliary_units, show_stream_IDs): - """ - Label of a stream from its original heat exchanger `hx`: - ' - ()', with each part - optional. - """ - parts = [] - if show_units: parts.append(hx.owner.ID) - if show_auxiliary_units: - auxname = _auxiliary_name(hx) - if auxname: parts.append(auxname) - label = ' - '.join(parts) - if show_stream_IDs: - ID = hx.ins[0].ID - if ID: label = f'{label} ({ID})' if label else ID - return label - -def plot_pinch_diagram(stream_life_cycles, inlet_Ts, outlet_Ts, - hot_side_HXs, cold_side_HXs, Qmin=1e-3, - original_hxs=None, show_units=True, - show_auxiliary_units=True, show_stream_IDs=True, - show_legend=True, ax=None, file=None, dpi=300): - """ - Draw a pinch diagram of a synthesized heat exchanger network: cold - streams (blue, flowing left to right) above hot streams (red, flowing - right to left), one vertical connector per process heat exchanger with - its duty, a dashed pinch line separating the cold-side from the - hot-side exchangers, and circles marking the utility exchangers that - bring each stream to its outlet temperature. - - Parameters - ---------- - stream_life_cycles : list[StreamLifeCycle] - One per stream, as built by HeatExchangerNetwork. - inlet_Ts, outlet_Ts : array-like - Stream inlet and outlet temperatures [K], indexed like the life cycles. - hot_side_HXs, cold_side_HXs : list[HXprocess] - Process exchangers above and below the pinch. - Qmin : float, optional - Utility exchangers with a duty at or below this [kJ/hr] are not marked. - original_hxs : list[Unit], optional - The original heat exchanger of each stream (indexed like the life - cycles). Required for the stream labels below. - show_units : bool, optional - Label each stream with the unit operation that owns its original heat - exchanger (the main unit for auxiliary exchangers). - show_auxiliary_units : bool, optional - Label each stream with the name of its original heat exchanger within - the main unit (e.g. 'condenser'), if it is an auxiliary unit. - show_stream_IDs : bool, optional - Label each stream with the ID of the original heat exchanger's inlet. - show_legend : bool, optional - Add a legend of the symbols below the diagram. - ax : matplotlib.axes.Axes, optional - Axes to draw on; a new figure is created if not given. - file : str, optional - If given, the figure is saved to this path. - dpi : int, optional - Resolution used when saving. - - Returns - ------- - fig : matplotlib.figure.Figure - ax : matplotlib.axes.Axes - - Notes - ----- - Temperatures are shown in degC and heat flows in kJ/hr at the inlet and - outlet of each stream. Exchanger columns on each side of the pinch are - ordered so that each stream meets them in flow direction whenever the - network allows it. Stream labels read ' - ()' - next to the stream index at the inlet. - - Examples - -------- - >>> import biosteam as bst - >>> bst.settings.set_thermo(['Water', 'Methanol', 'Glycerol']) - >>> feed1 = bst.Stream('feed1', flow=(8000, 100, 25)) - >>> feed2 = bst.Stream('feed2', flow=(10000, 1000, 10)) - >>> D1 = bst.ShortcutColumn('D1', ins=feed1, - ... outs=('distillate', 'bottoms_product'), - ... LHK=('Methanol', 'Water'), - ... y_top=0.99, x_bot=0.01, k=2, - ... is_divided=True) - >>> D1_H1 = bst.HXutility('D1_H1', ins = D1.outs[1], T = 300) - >>> D1_H2 = bst.HXutility('D1_H2', ins = D1.outs[0], T = 300) - >>> F1 = bst.Flash('F1', ins=feed2, - ... outs=('vapor', 'liquid'), V = 0.9, P = 101325) - >>> HXN = bst.HeatExchangerNetwork('HXN', T_min_app = 5.) - >>> sys = bst.System.from_units('sys', units=[D1, D1_H1, D1_H2, F1, HXN]) - >>> sys.simulate() - >>> fig, ax = HXN.plot_pinch_diagram() - >>> connectors = [i for i in ax.findobj() if (i.get_gid() or '').startswith('HX:')] - >>> len(connectors) == len(HXN.new_HXs) - True - >>> import matplotlib.pyplot as plt - >>> plt.close(fig) - - """ - import matplotlib.pyplot as plt - # Artists carry stable gids ('HX:', 'Util:', 'Label:') - # so the drawing can be checked structurally in tests. - show_labels = show_units or show_auxiliary_units or show_stream_IDs - if show_labels and original_hxs is None: - raise ValueError('original_hxs is required to label streams with ' - 'units, auxiliary units, or stream IDs') - cold_color, hot_color = '#2e6db4', '#d62728' - cold_bg, hot_bg = '#e6f0fa', '#fbe9e7' - process_hxs = set(hot_side_HXs) | set(cold_side_HXs) - # Stream index and stage of each side of every process exchanger, by identity - hx_streams = {hx: {} for hx in process_hxs} - for index, life_cycle in enumerate(stream_life_cycles): - for stage in life_cycle.life_cycle: - if stage.unit in hx_streams: - hx_streams[stage.unit][life_cycle.cold] = (index, stage) - cold_side_HXs = _order_exchanger_columns(cold_side_HXs, stream_life_cycles) - hot_side_HXs = _order_exchanger_columns(hot_side_HXs, stream_life_cycles) - columns = cold_side_HXs + hot_side_HXs - N_cs = len(cold_side_HXs) - N_columns = len(columns) - # x layout: 0 stream ends | 1 cold utilities | 2..N_cs+1 cold side | - # pinch | N_cs+2..N+1 hot side | N+2 hot utilities | N+3 stream ends - x_start, x_cold_util = 0., 1. - x_columns = {hx: 2. + i for i, hx in enumerate(columns)} - x_pinch = N_cs + 1.5 - x_hot_util = N_columns + 2. - x_end = N_columns + 3. - # y layout: cold streams on top, hot streams below, duty labels in between - cold_streams = [i for i, lc in enumerate(stream_life_cycles) if lc.cold] - hot_streams = [i for i, lc in enumerate(stream_life_cycles) if not lc.cold] - N_hot = len(hot_streams) - N_cold = len(cold_streams) - gap = 2.5 - y = {} - for k, i in enumerate(hot_streams): y[i] = N_hot - k - for k, i in enumerate(cold_streams): y[i] = N_hot + gap + N_cold - k - y_label = N_hot + (gap + 1.) / 2. - y_top = N_hot + gap + N_cold + 1. - y_bottom = 0. - if ax is None: - fig, ax = plt.subplots( - figsize=(max(6., 0.75 * (N_columns + 4) + 3.), 0.4 * y_top + 1.) - ) - else: - fig = ax.figure - # Background and pinch line - x_min, x_max = x_start - 1.8, x_end + 1.8 - ax.axvspan(x_min, x_pinch, color=cold_bg, lw=0, zorder=0) - ax.axvspan(x_pinch, x_max, color=hot_bg, lw=0, zorder=0) - ax.axvline(x_pinch, color='k', ls='--', lw=1, zorder=1) - ax.text(x_min + 0.2, y_bottom + 0.1, 'Cold side', color=cold_color, - weight='bold', ha='left', va='bottom') - ax.text(x_max - 0.2, y_bottom + 0.1, 'Hot side', color=hot_color, - weight='bold', ha='right', va='bottom') - # Column headers - header_kwargs = dict(ha='center', va='bottom', weight='bold', fontsize=8) - for x_T, x_H in ((x_start - 1.3, x_start - 0.6), (x_end + 0.6, x_end + 1.3)): - ax.text(x_T, y_top, 'T\n[°C]', **header_kwargs) - ax.text(x_H, y_top, 'H\n[kJ·h$^{-1}$]', **header_kwargs) - ax.text(x_start - 0.3, y_label, 'ΔH\n[kJ·h$^{-1}$]', - ha='right', va='center', weight='bold', fontsize=8) - # Streams - value_kwargs = dict(ha='center', va='center', fontsize=8) - for index, life_cycle in enumerate(stream_life_cycles): - cold = life_cycle.cold - color = cold_color if cold else hot_color - yi = y[index] - stages = life_cycle.life_cycle # never empty: each stream has a utility stage - H_in = stages[0].H_in - H_out = stages[-1].H_out - T_in = inlet_Ts[index] - 273.15 - T_out = outlet_Ts[index] - 273.15 - # T is the outer column on the left and the inner column on the right - T_left, H_left, T_right, H_right = ( - (T_in, H_in, T_out, H_out) if cold else (T_out, H_out, T_in, H_in) - ) - x_in, x_out, sign = (x_start, x_end, 1) if cold else (x_end, x_start, -1) - ax.annotate('', xy=(x_out, yi), xytext=(x_in, yi), - arrowprops=dict(arrowstyle='-|>', color=color, lw=1.2, - shrinkA=0, shrinkB=0), zorder=2) - ax.text(x_start - 1.3, yi, f'{T_left:.1f}', color=color, **value_kwargs) - ax.text(x_start - 0.6, yi, _format_H(H_left), color=color, **value_kwargs) - ax.text(x_end + 0.6, yi, f'{T_right:.1f}', color=color, **value_kwargs) - ax.text(x_end + 1.3, yi, _format_H(H_right), color=color, **value_kwargs) - # Index and label share a baseline above the stream, clear of the - # exchanger circles - y_text = yi + 0.25 - ax.text(x_in + sign * 0.3, y_text, str(index), color=color, - ha='center', va='baseline', weight='bold', fontsize=9) - if show_labels: - label = _stream_label(original_hxs[index], show_units, - show_auxiliary_units, show_stream_IDs) - # the smaller label reads as centered with the index when its - # baseline is slightly higher - ax.text(x_in + sign * 0.6, y_text + 0.08, label, color=color, - ha='left' if cold else 'right', va='baseline', fontsize=7, - zorder=6, gid=f'Label:{index}', - bbox=dict(boxstyle='square,pad=0.15', fc='w', ec='none')) - # Utility exchangers: a cold stream ends in a hot utility (red), a - # hot stream in a cold utility (blue) - x_util, util_color = (x_hot_util, hot_color) if cold else (x_cold_util, cold_color) - for stage in stages: - unit = stage.unit - if unit in process_hxs: continue - if abs(stage.H_out - stage.H_in) <= Qmin: continue - ax.plot([x_util], [yi], 'o', mfc='w', mec=util_color, mew=1.2, - ms=6, zorder=4, gid='Util:' + unit.ID) - # Process exchangers - for hx in columns: - streams = hx_streams[hx] - if len(streams) != 2: - warn(f'{hx.ID} is not in exactly one hot and one cold stream ' - 'life cycle; it is not drawn', RuntimeWarning) - continue - (i_cold, stage_cold), (i_hot, stage_hot) = streams[True], streams[False] - x = x_columns[hx] - Q = abs(stage_hot.H_in - stage_hot.H_out) - ax.plot([x, x], [y[i_hot], y[i_cold]], '-o', color='k', mfc='w', - mew=1.2, ms=6, lw=1.2, zorder=3, gid='HX:' + hx.ID) - ax.text(x, y_label, _format_H(Q), rotation=90, ha='center', - va='center', fontsize=8, zorder=5, - bbox=dict(boxstyle='square,pad=0.25', fc='w', ec='k', lw=0.8)) - if show_legend: - from matplotlib.lines import Line2D - handles = [ - Line2D([], [], color=cold_color, lw=1.2, marker='>', markevery=[-1], - ms=5, label='Cold stream'), - Line2D([], [], color=hot_color, lw=1.2, marker='<', markevery=[0], - ms=5, label='Hot stream'), - Line2D([], [], color='k', lw=1.2, marker='o', mfc='w', mew=1.2, - ms=6, label='Process heat exchange'), - Line2D([], [], ls='', marker='o', mfc='w', mec=hot_color, mew=1.2, - ms=6, label='Hot utility'), - Line2D([], [], ls='', marker='o', mfc='w', mec=cold_color, mew=1.2, - ms=6, label='Cold utility'), - Line2D([], [], color='k', ls='--', lw=1, label='Pinch'), - ] - ax.legend(handles=handles, loc='upper center', bbox_to_anchor=(0.5, 0.), - ncol=3, fontsize=7, frameon=False, handlelength=2.5, - columnspacing=1.5) - ax.set_xlim(x_min, x_max) - ax.set_ylim(y_bottom, y_top + 1.2) - ax.set_axis_off() - if file: fig.savefig(file, dpi=dpi, bbox_inches='tight') - return fig, ax diff --git a/docs/API/facilities/HeatExchangerNetwork.txt b/docs/API/facilities/HeatExchangerNetwork.txt index d7558e93..6c771de4 100644 --- a/docs/API/facilities/HeatExchangerNetwork.txt +++ b/docs/API/facilities/HeatExchangerNetwork.txt @@ -1,5 +1,16 @@ HeatExchangerNetwork ==================== -.. autoclass:: biosteam.facilities.HeatExchangerNetwork - :members: \ No newline at end of file +.. note:: + :class:`~hensmith.HeatExchangerNetwork` has moved to the + `hensmith `_ package + (Heat Exchanger Network Synthesis, Modeling, Integration, Thermodynamics, + and Heuristics), which is a dependency of BioSTEAM. It remains available + as ``biosteam.HeatExchangerNetwork`` and + ``biosteam.facilities.HeatExchangerNetwork``. The network synthesis + helpers (``synthesize_network``, ``problem_table``, + ``plot_pinch_diagram``, ``StreamLifeCycle``) are now importable only from + ``hensmith``. + +.. autoclass:: hensmith.HeatExchangerNetwork + :members: diff --git a/setup.py b/setup.py index 7ae410cc..05fd8ced 100644 --- a/setup.py +++ b/setup.py @@ -16,7 +16,8 @@ long_description=open('README.rst', encoding='utf-8').read(), author='Yoel Cortes-Pena', install_requires=['IPython>=7.9.0', - 'thermosteam>=0.53.5', + 'thermosteam>=0.53.5', + 'hensmith>=0.1.0', 'graphviz>=0.17', 'chaospy>=4.3.21', 'pyyaml'], @@ -46,7 +47,6 @@ 'units/*', 'units/design_tools/*', 'facilities/*', - 'facilities/hxn/*', 'wastewater/*', 'wastewater/high_rate/*', 'units/decorators/*'] diff --git a/tests/test_hensmith_integration.py b/tests/test_hensmith_integration.py new file mode 100644 index 00000000..979f2601 --- /dev/null +++ b/tests/test_hensmith_integration.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules +# Copyright (C) 2020-, Yoel Cortes-Pena +# Copyright (C) 2026-, Sarang Bhagwat +# +# This module is under the UIUC open-source license. See +# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt +# for license details. +""" +Tests that the biosteam <-> hensmith circular dependency is import-safe in +both directions and that biosteam lazily re-exports HeatExchangerNetwork +from hensmith (PEP 562), so that `import biosteam` never requires hensmith +to be initialized first and vice versa. +""" +import subprocess +import sys + +def _run(code): + subprocess.run([sys.executable, '-c', code], check=True) + +def test_biosteam_first_import_order(): + _run( + "import biosteam as bst\n" + "import hensmith\n" + "assert bst.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + "assert bst.facilities.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + ) + +def test_hensmith_first_import_order(): + _run( + "import hensmith\n" + "import biosteam as bst\n" + "assert bst.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + "assert bst.facilities.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + ) + +def test_from_imports_and_star_import(): + _run( + "from biosteam import HeatExchangerNetwork\n" + "from biosteam.facilities import HeatExchangerNetwork as HXN2\n" + "ns = {}\n" + "exec('from biosteam import *', ns)\n" + "import hensmith\n" + "assert HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + "assert HXN2 is hensmith.HeatExchangerNetwork\n" + "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" + ) + +if __name__ == '__main__': + test_biosteam_first_import_order() + test_hensmith_first_import_order() + test_from_imports_and_star_import() diff --git a/tests/test_hxn.py b/tests/test_hxn.py deleted file mode 100644 index 4e7a147b..00000000 --- a/tests/test_hxn.py +++ /dev/null @@ -1,483 +0,0 @@ -# -*- coding: utf-8 -*- -# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules -# Copyright (C) 2020-, Yoel Cortes-Pena -# Copyright (C) 2026-, Sarang Bhagwat -# -# This module is under the UIUC open-source license. See -# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt -# for license details. -""" -Tests for the heat exchanger network facility. -""" -import warnings -import pytest -import biosteam as bst -import numpy as np -from numpy.testing import assert_allclose - -def build_system(N_columns=1): - """Doctest system of HeatExchangerNetwork; `N_columns > 1` adds more - ShortcutColumns so auxiliary heat exchangers have duplicate IDs.""" - bst.settings.set_thermo(['Water', 'Methanol', 'Glycerol'], cache=True) - bst.main_flowsheet.set_flowsheet('test_hxn') - units = [] - feeds = [] - for i in range(N_columns): - feed = bst.Stream(f'feed{i}', flow=(8000, 100 * (i + 1), 25)) - D = bst.ShortcutColumn(f'D{i}', ins=feed, LHK=('Methanol', 'Water'), - y_top=0.99, x_bot=0.01, k=2, is_divided=True) - H1 = bst.HXutility(f'D{i}_H1', ins=D.outs[1], T=300) - H2 = bst.HXutility(f'D{i}_H2', ins=D.outs[0], T=300) - units.extend([D, H1, H2]) - feeds.append(feed) - feed2 = bst.Stream('feed_flash', flow=(10000, 1000, 10)) - F1 = bst.Flash('F1', ins=feed2, V=0.9, P=101325) - HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) - sys = bst.System.from_units('sys', units=[*units, F1, HXN]) - return sys, HXN, feeds[0] - -def network_results(HXN): - return dict( - heat=HXN.actual_heat_util_load, - cool=HXN.actual_cool_util_load, - Q=np.array([hx.Q for hx in HXN.new_HXs]), - installed=HXN.installed_costs['Heat exchangers'], - ) - -def assert_same_results(a, b, rtol=1e-6): - for key in a: - assert_allclose(a[key], b[key], rtol=rtol, err_msg=key) - -def simulate_cached(sys, HXN): - HXN.cache_network = True - HXN_sys = HXN.HXN_sys - with warnings.catch_warnings(): - warnings.simplefilter('error', RuntimeWarning) - sys.simulate() - assert HXN.HXN_sys is HXN_sys, 'cached network was not used' - -def test_cache_network_matches_fresh_synthesis(): - sys, HXN, feed = build_system() - sys.simulate() - fresh = network_results(HXN) - assert HXN.actual_heat_util_load < 0.9 * HXN.original_heat_util_load - simulate_cached(sys, HXN) - assert_same_results(network_results(HXN), fresh) - -def test_cache_network_perturbed_feed(): - sys, HXN, feed = build_system() - sys.simulate() - feed.F_mass *= 1.01 - simulate_cached(sys, HXN) - cached = network_results(HXN) - HXN.cache_network = False - sys.simulate() - assert_same_results(cached, network_results(HXN), rtol=1e-3) - -def test_cache_network_duplicate_IDs(): - sys, HXN, feed = build_system(N_columns=2) - sys.simulate() - IDs = [hx.ID for hx in HXN.original_heat_exchangers] - assert len(IDs) != len(set(IDs)), 'test needs duplicate auxiliary IDs' - fresh = network_results(HXN) - simulate_cached(sys, HXN) - assert_same_results(network_results(HXN), fresh) - -def test_energy_balance_error_contributions_ignored_none(): - sys, HXN, feed = build_system() - sys.simulate() - N = len(HXN.original_heat_utils) - errors = HXN._energy_balance_error_contributions() - assert len(errors) == N - assert HXN.ignored is None - -# --------------------------------------------------------------------------- -# Problem-table (pinch) analysis -# --------------------------------------------------------------------------- - -from biosteam.facilities.hxn.hxn_synthesis import ( - temperature_interval_pinch_analysis, problem_table, load_duties, pinch_state, -) - -def utility_hx(ID, T, P, phase, T_out, **flow): - """A simulated HXutility acting as one process stream (kmol/hr flows).""" - s = bst.Stream(ID + '_in', T=T, P=P, phase=phase, units='kmol/hr', **flow) - hx = bst.HXutility(ID, ins=s, T=T_out, - rigorous=(phase == 'g')) # liquid streams stay liquid (report's case) - hx.simulate() - return hx - -def synthetic_units(): - """Report's 4-stream case: two cold, one condensing hot, one hot liquid.""" - bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) - bst.main_flowsheet.set_flowsheet('test_hxn_synthetic') - return [utility_hx('C1', 300., 101325., 'l', 390., Water=2000.), - utility_hx('C2', 310., 101325., 'l', 345., Water=500., Ethanol=500.), - utility_hx('H1', 352., 101325., 'g', 340., Ethanol=300.), - utility_hx('H2', 420., 5e5, 'l', 320., Water=800.)] - -def heat_utilities(units): - hus = [hx.heat_utilities[0] for hx in units] - hus.sort(key=lambda hu: hu.duty) - return hus - -def pinch_streams(hus): - """Inlet/quenched-outlet stream copies exactly as the synthesizer prepares them.""" - streams_inlet = [hu.unit.ins[0].copy() for hu in hus] - streams_quenched = [hu.unit.outs[0].copy() for hu in hus] - for s in streams_quenched: s.vle(H=s.H, P=s.P) - is_hot = [hu.duty < 0 for hu in hus] - return streams_inlet, streams_quenched, is_hot - -def assert_energy_consistent(hus, T_min_app): - """Invariants of a correct problem table, independent of the synthesizer.""" - unit_duties = np.array([hu.unit_duty for hu in hus]) - table = problem_table(*pinch_streams(hus), T_min_app) - # (a) each stream's grid contributions telescope to its real duty - # (hot: +|dH|, cold: -dH) - per_stream = table.interval_H.sum(axis=1) + table.point_H.sum(axis=1) - assert_allclose(per_stream, -unit_duties, rtol=1e-9) - # (b) targets are non-negative and hot - cold is the net demand - assert table.hot_util_load >= 0. and table.cold_util_load >= 0. - assert_allclose(table.hot_util_load - table.cold_util_load, - unit_duties.sum(), rtol=1e-9) - # (c) a target can never exceed the un-integrated load - assert table.hot_util_load <= unit_duties[unit_duties > 0].sum() * (1 + 1e-9) - assert table.cold_util_load <= -unit_duties[unit_duties < 0].sum() * (1 + 1e-9) - # (d) the public wrapper reports the same targets - pinch_T_arr, hot, cold, *_ = temperature_interval_pinch_analysis(hus, T_min_app) - assert_allclose([hot, cold], [table.hot_util_load, table.cold_util_load], rtol=1e-12) - return table - -def test_problem_table_energy_consistency_doctest_system(): - sys, HXN, feed = build_system() - sys.simulate() - hus = HXN._get_original_heat_utilties() - hus.sort(key=lambda hu: hu.duty) - assert_energy_consistent(hus, 5.) - -@pytest.mark.parametrize('T_min_app', [5., 10., 20.]) -def test_problem_table_energy_consistency_synthetic(T_min_app): - hus = heat_utilities(synthetic_units()) - table = assert_energy_consistent(hus, T_min_app) - # the condensing ethanol stream (352 K in, ~351.4 K dew point) must keep - # its latent heat: hot target well below the un-integrated heating load - heating = sum(hu.unit_duty for hu in hus if hu.unit_duty > 0) - assert table.hot_util_load < 0.5 * heating - -def test_problem_table_two_streams_closed_form(): - bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) - bst.main_flowsheet.set_flowsheet('test_hxn_two_streams') - hot = utility_hx('Hw', 400., 5e5, 'l', 300., Water=1000.) - # Case 1 (threshold problem): the hot stream covers every interval of the - # smaller cold stream -> no hot utility, cold utility = net surplus. - cold = utility_hx('Cs', 300., 5e5, 'l', 390., Water=900.) - hus = heat_utilities([hot, cold]) - table = problem_table(*pinch_streams(hus), 5.) - Q_hot = -hot.heat_utilities[0].unit_duty - Q_cold = cold.heat_utilities[0].unit_duty - assert table.hot_util_load == 0. - assert_allclose(table.cold_util_load, Q_hot - Q_cold, rtol=1e-9) - assert table.pinch_T == table.Ts[0] # no pinch: everything sits below it - # Case 2: the larger cold stream is short of heat everywhere; the cascade - # minimum is at the cold inlet (300 K on the shifted scale) and the hot - # utility is the cold duty minus what the hot stream gives down to 305 K. - cold = utility_hx('Cb', 300., 5e5, 'l', 390., Water=1200.) - hus = heat_utilities([hot, cold]) - table = problem_table(*pinch_streams(hus), 5.) - s = hot.ins[0].copy(); s.vle(T=305., P=s.P) - Q_hot_above_pinch = hot.ins[0].H - s.H - Q_cold = cold.heat_utilities[0].unit_duty - assert_allclose(table.hot_util_load, Q_cold - Q_hot_above_pinch, rtol=1e-9) - assert table.pinch_T == 300. - # remaining hot-stream heat below the pinch leaves as cold utility - assert_allclose(table.cold_util_load, s.H - hot.outs[0].H, rtol=1e-9) - -def test_problem_table_non_monotone_stream_is_point_load(): - # A heated stream whose outlet is colder than its inlet (e.g. a column - # reboiler outlet at VLE): treated as an isothermal load at T_out. - bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) - a = bst.Stream('a', Water=100., T=372., P=101325., phase='l', units='kmol/hr') - b = bst.Stream('b', Water=100., T=371., P=101325., phase='g', units='kmol/hr') - dH = b.H - a.H - assert dH > 0 - table = problem_table([a], [b], [False], 5.) - assert_allclose(table.point_H, [[-dH]]) - assert table.interval_H.shape == (1, 0) - assert_allclose([table.hot_util_load, table.cold_util_load, table.pinch_T], - [dH, 0., 371.]) - table = problem_table([b], [a], [True], 5.) - assert_allclose([table.hot_util_load, table.cold_util_load, table.pinch_T], - [0., dH, 372. - 5.]) # outlet T 372 K, shifted by T_min_app - -def test_problem_table_point_load_cannot_heat_above_itself(): - # A source at shifted temperature T cannot serve sinks above T: an - # isothermal condensing hot stream at 400 K (shifted to 395 K) must not - # cover the 395-398 K segment of a cold stream that runs 392 -> 398 K. - bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) - hot_in = bst.Stream('hv', Water=100., T=400., P=101325., phase='g', - units='kmol/hr') - hot_out = bst.Stream('hl', Water=100., T=400., P=101325., phase='l', - units='kmol/hr') - P_hot = hot_in.H - hot_out.H - assert P_hot > 0 - cold_in = bst.Stream('cl', Water=1000., T=392., P=5e5, phase='l', - units='kmol/hr') - cold_out = cold_in.copy('cl_out'); cold_out.vle(T=398., P=5e5) - s = cold_in.copy(); s.vle(T=395., P=5e5) - H_392, H_395, H_398 = cold_in.H, s.H, cold_out.H - assert P_hot > H_398 - H_392 # more than enough heat overall - table = problem_table([hot_in, cold_in], [hot_out, cold_out], - [True, False], 5.) - assert_allclose(table.Ts, [398., 395., 392.]) - # heat arriving at 395 K, before the point load there, is short by the - # 395-398 K segment of the cold stream - assert_allclose(table.hot_util_load, H_398 - H_395, rtol=1e-9) - assert table.pinch_T == 395. - assert_allclose(table.cold_util_load, P_hot - (H_395 - H_392), rtol=1e-9) - -def test_load_duties_non_equilibrium_inlet_conserves_energy(): - # A non-rigorous HXutility can carry a superheated liquid (ethanol at - # 370 K, 1 atm; bp 351.4 K). Flashing it at the 355 K pinch gives vapor - # with far more enthalpy than the inlet has; the pinch split must clip - # to the stream's real enthalpy range so that the hot-side and cold-side - # loads sum to the stream's duty (and are not phantom latent heat). - bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) - s_in = bst.Stream('ne_in', Ethanol=700., T=370., P=101325., phase='l', - units='kmol/hr') - s_out = bst.Stream('ne_out', Ethanol=700., T=310., P=101325., phase='l', - units='kmol/hr') - duty = s_in.H - s_out.H - flashed = s_in.copy(); flashed.vle(T=355., P=101325.) - assert flashed.H > s_in.H # the trap: equilibrium enthalpy above H_in - Q_hot_side, Q_cold_side = {}, {} - load_duties([s_in], [s_out], np.array([355.]), np.array([310.]), [0], - lambda i: False, Q_hot_side, Q_cold_side) - assert Q_hot_side[0][0] == Q_cold_side[0][0] == 'cool' - assert_allclose(Q_hot_side[0][1] + Q_cold_side[0][1], duty, rtol=1e-9) - # the stream cannot give any heat above the pinch: its whole enthalpy - # range lies below the equilibrium state at 355 K - assert_allclose(Q_hot_side[0][1], 0., atol=1e-6) - assert_allclose(Q_cold_side[0][1], duty, rtol=1e-9) - # and the transient state used for matching carries exactly H_in, at - # equilibrium (two-phase at the bubble point), not at the fictitious - # 370 K of the superheated liquid, so matching is consistent with the - # problem table - s = pinch_state(s_in, s_out, 355.) - assert_allclose(s.H, s_in.H, rtol=1e-9) - assert s.T < 355. and 'g' in s.phase and 'l' in s.phase - -def test_pinch_state_at_endpoints_uses_real_states(): - # pinch_T == T_in must put the whole duty on one side even when the - # inlet is not at equilibrium: flashing a superheated liquid at its own - # T does not reproduce H_in, and the resulting enthalpy can lie inside - # the stream's range so that clipping alone would not catch it. - bst.settings.set_thermo(['Water', 'Ethanol'], cache=True) - s_in = bst.Stream('sh_in', Water=100., T=380., P=101325., phase='l', - units='kmol/hr') - s_out = bst.Stream('sh_out', Water=100., T=400., P=101325., phase='g', - units='kmol/hr') - duty = s_out.H - s_in.H - flashed = s_in.copy(); flashed.vle(T=380., P=101325.) - assert s_in.H < flashed.H < s_out.H # the trap: in range, but not H_in - Q_hot_side, Q_cold_side = {}, {} - load_duties([s_in], [s_out], np.array([380.]), np.array([400.]), [0], - lambda i: True, Q_hot_side, Q_cold_side) - assert_allclose(Q_hot_side[0][1], duty, rtol=1e-9) - assert_allclose(Q_cold_side[0][1], 0., atol=1e-6) - assert_allclose(pinch_state(s_in, s_out, 380.).H, s_in.H, rtol=1e-9) - assert_allclose(pinch_state(s_in, s_out, 400.).H, s_out.H, rtol=1e-9) - # a phase-mislabelled non-condensable: clipping must return the real - # end state, never an equilibrium re-flash (N2 "liquid" at 400 K would - # otherwise come back as gas at thousands of K) - bst.settings.set_thermo(['Water', 'N2'], cache=True) - h_in = bst.Stream('n2_in', N2=100., T=400., P=101325., phase='l', - units='kmol/hr') - h_out = bst.Stream('n2_out', N2=100., T=320., P=101325., phase='l', - units='kmol/hr') - s = pinch_state(h_in, h_out, 355.) - assert h_out.H <= s.H <= h_in.H - assert 320. <= s.T <= 400. - -def test_unordered_network_path_warns_with_context(monkeypatch): - # thermosteam's Network.sort warns 'network path could not be determined' - # when its ordering heuristic does not settle; HXN re-raises that as its - # own warning so the user knows which facility it concerns. - import thermosteam as tmo - original = tmo.Network.from_units - def from_units_with_warning(*args, **kwargs): - network = original(*args, **kwargs) - warnings.warn('network path could not be determined', RuntimeWarning) - return network - monkeypatch.setattr(tmo.Network, 'from_units', from_units_with_warning) - units = synthetic_units() - HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) - sys = bst.System.from_units('sys_unordered', units=[*units, HXN]) - with pytest.warns(RuntimeWarning, match='heat exchanger network path could not be fully ordered'): - sys.simulate() - assert abs(HXN.energy_balance_percent_error) < 1e-6 - -def test_synthetic_network_reaches_MER(): - units = synthetic_units() - HXN = bst.HeatExchangerNetwork('HXN', T_min_app=5.) - sys = bst.System.from_units('sys_synthetic', units=[*units, HXN]) - sys.simulate() - hus = heat_utilities(units) - table = problem_table(*pinch_streams(hus), 5.) - actual_heat = sum(hu.unit_duty for hx in HXN.new_HX_utils - for hu in hx.heat_utilities if hu.unit_duty > 0) - # the greedy heuristic reaches the (corrected) MER on this case; it can - # never legitimately beat it - assert_allclose(actual_heat, table.hot_util_load, rtol=1e-2) - # the lower bound is exact here only because every synthetic inlet is an - # equilibrium state (so the clipped table is exact) and the synthesizer - # respects T_min_app; with non-equilibrium inlets the table is conservative - assert actual_heat >= table.hot_util_load * (1 - 1e-3) - -# --- pinch diagram ----------------------------------------------------------- - -class _FakeStage: - def __init__(self, unit): self.unit = unit - -class _FakeLifeCycle: - def __init__(self, units, cold=True): - self.cold = cold - self.life_cycle = [_FakeStage(u) for u in units] - -def test_pinch_diagram_column_order_follows_stream_direction(): - from biosteam.facilities.hxn.hxn_synthesis import _order_exchanger_columns - h1, h2, h3 = 'h1', 'h2', 'h3' - # stream A visits h2 then h1; stream B visits h1 then h3 -> h2, h1, h3 - cycles = [_FakeLifeCycle([h2, h1]), _FakeLifeCycle([h1, h3])] - assert _order_exchanger_columns([h1, h2, h3], cycles) == [h2, h1, h3] - # exchangers not in the requested subset are ignored, order is stable - assert _order_exchanger_columns([h3, h1], cycles) == [h1, h3] - # a hot stream flows right to left, so its stage order is reversed: - # hot stream visits h1 then h3 -> h3 left of h1 - cycles = [_FakeLifeCycle([h2, h1]), _FakeLifeCycle([h1, h3], cold=False)] - assert _order_exchanger_columns([h1, h2, h3], cycles) == [h2, h3, h1] - # contradictory constraints (a cycle) fall back to the given order - cycles = [_FakeLifeCycle([h1, h2]), _FakeLifeCycle([h2, h1])] - assert _order_exchanger_columns([h2, h1], cycles) == [h2, h1] - -def _gid_artists(ax, prefix): - return [a for a in ax.findobj() if (a.get_gid() or '').startswith(prefix)] - -def test_pinch_diagram_doctest_system(): - import matplotlib - matplotlib.use('Agg') - import matplotlib.pyplot as plt - sys, HXN, feed = build_system() - sys.simulate() - assert HXN.new_HXs_hot_side + HXN.new_HXs_cold_side == HXN.new_HXs - fig, ax = HXN.plot_pinch_diagram() - try: - # one connector per process exchanger - connectors = _gid_artists(ax, 'HX:') - assert {a.get_gid() for a in connectors} == {'HX:' + hx.ID for hx in HXN.new_HXs} - # one utility marker per utility exchanger with a duty above Qmin - utils = _gid_artists(ax, 'Util:') - expected = {'Util:' + hx.ID for hx in HXN.new_HX_utils - if abs(hx.outs[0].H - hx.ins[0].H) > HXN.Qmin} - assert {a.get_gid() for a in utils} == expected - # one row per stream, with inlet temperatures in degC - texts = {t.get_text() for t in ax.texts} - for T in HXN.inlet_Ts: assert f'{T - 273.15:.1f}' in texts - for T in HXN.outlet_Ts: assert f'{T - 273.15:.1f}' in texts - for i in range(len(HXN.inlet_Ts)): assert str(i) in texts - finally: - plt.close(fig) - -def test_pinch_diagram_stream_labels(): - import matplotlib - matplotlib.use('Agg') - import matplotlib.pyplot as plt - from biosteam.facilities.hxn.hxn_synthesis import _auxiliary_name, _stream_label - sys, HXN, feed = build_system() - sys.simulate() - D1 = bst.main_flowsheet.unit.D0 - D1_H1 = bst.main_flowsheet.unit.D0_H1 - assert _auxiliary_name(D1.condenser) == 'condenser' - assert _auxiliary_name(D1_H1) is None - # label composition - assert _stream_label(D1.condenser, True, True, False) == 'D0 - condenser' - assert _stream_label(D1.condenser, True, False, False) == 'D0' - assert _stream_label(D1.condenser, False, True, False) == 'condenser' - assert _stream_label(D1_H1, True, True, True) == 'D0_H1 (' + D1_H1.ins[0].ID + ')' - assert _stream_label(D1_H1, False, False, True) == D1_H1.ins[0].ID - assert _stream_label(D1_H1, False, False, False) == '' - # an unnamed inlet adds nothing - assert _stream_label(D1.reboiler, True, True, True) == 'D0 - reboiler' - # every stream gets a label on the figure; toggles remove them - fig, ax = HXN.plot_pinch_diagram() - try: - labels = {a.get_gid(): a.get_text() for a in _gid_artists(ax, 'Label:')} - hxs = HXN.original_heat_exchangers - assert labels == { - f'Label:{i}': _stream_label(hx, True, True, True) - for i, hx in enumerate(hxs) - } - assert any(text.startswith('D0 - condenser') for text in labels.values()) - assert any(text == 'F1 - heat_exchanger (feed_flash)' for text in labels.values()) - finally: - plt.close(fig) - fig, ax = HXN.plot_pinch_diagram(show_units=False, show_auxiliary_units=False, - show_stream_IDs=False) - try: - assert not _gid_artists(ax, 'Label:') - finally: - plt.close(fig) - -def test_pinch_diagram_requires_simulation(): - sys, HXN, feed = build_system() - with pytest.raises(RuntimeError, match='simulate'): - HXN.plot_pinch_diagram() - -def test_pinch_diagram_legend(): - import matplotlib - matplotlib.use('Agg') - import matplotlib.pyplot as plt - sys, HXN, feed = build_system() - sys.simulate() - fig, ax = HXN.plot_pinch_diagram() - try: - legend = ax.get_legend() - assert legend is not None - labels = [t.get_text() for t in legend.get_texts()] - assert labels == ['Cold stream', 'Hot stream', 'Process heat exchange', - 'Hot utility', 'Cold utility', 'Pinch'] - # utility markers are colored by utility type, consistent with the legend - handles = dict(zip(labels, legend.legend_handles)) - hot_util_color = handles['Hot utility'].get_markeredgecolor() - cold_util_color = handles['Cold utility'].get_markeredgecolor() - assert hot_util_color != cold_util_color - heaters = {hx.ID for hx in HXN.new_HX_utils if hx.outs[0].H > hx.ins[0].H} - for artist in _gid_artists(ax, 'Util:'): - heater = artist.get_gid()[len('Util:'):] in heaters - expected = hot_util_color if heater else cold_util_color - assert artist.get_markeredgecolor() == expected, artist.get_gid() - finally: - plt.close(fig) - fig, ax = HXN.plot_pinch_diagram(show_legend=False) - try: - assert ax.get_legend() is None - finally: - plt.close(fig) - -if __name__ == '__main__': - test_cache_network_matches_fresh_synthesis() - test_cache_network_perturbed_feed() - test_cache_network_duplicate_IDs() - test_energy_balance_error_contributions_ignored_none() - test_problem_table_energy_consistency_doctest_system() - for T_min_app in (5., 10., 20.): - test_problem_table_energy_consistency_synthetic(T_min_app) - test_problem_table_two_streams_closed_form() - test_problem_table_non_monotone_stream_is_point_load() - test_problem_table_point_load_cannot_heat_above_itself() - test_synthetic_network_reaches_MER() - test_pinch_diagram_column_order_follows_stream_direction() - test_pinch_diagram_doctest_system() - test_pinch_diagram_stream_labels() - test_pinch_diagram_legend() - test_pinch_diagram_requires_simulation() diff --git a/tests/test_hxn_regression.py b/tests/test_hxn_regression.py deleted file mode 100644 index 7c2d1864..00000000 --- a/tests/test_hxn_regression.py +++ /dev/null @@ -1,228 +0,0 @@ -# -*- coding: utf-8 -*- -# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules -# Copyright (C) 2020-, Yoel Cortes-Pena -# Copyright (C) 2026-, Sarang Bhagwat -# -# This module is under the UIUC open-source license. See -# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt -# for license details. -""" -Regression tests for heat exchanger network synthesis on synthetic systems. - -Ten synthetic systems of increasing complexity (all with phase-changing -streams from case 3 on). For each, the synthesized network must - -(i) close its energy balance (|error| < 1e-6 %) without RuntimeWarnings, -(ii) never beat the minimum-energy-requirement (MER) targets of the problem - table computed on the same streams, and -(iii) recover at least as much heat as documented in ``CASES`` below, so that - no future change to ``hxn`` silently makes the synthesizer perform worse. - -The documented utility loads were recorded by running this file directly -(``python tests/test_hxn_regression.py`` prints them): cases 1-4 and 6-9 -at commit ``1ab689ff`` (branch ``hxn-pinch-diagram``); case 10 after the -synthesizer fixes on ``hxn-regression-tests`` (non-equilibrium inlets -clipped to the stream's enthalpy range; network path ordered by its -connections; H_lim honored at the bubble point); case 5 lowered after the -pinch state at an end temperature became the equilibrium state at that -end enthalpy (its 420 K, 5 bar vapor feed is below water's boiling point -there, a non-equilibrium inlet). Improvements leave slack; a -maintainer lowers the numbers deliberately when a better network is -intended. Never raise them to make a failing test pass. -""" -import warnings -import pytest -import biosteam as bst -from numpy.testing import assert_allclose -from biosteam.facilities.hxn.hxn_synthesis import problem_table - -EB_TOLERANCE = 1e-6 # percent; converged networks close to ~1e-10 % -MER_RTOL = 1e-3 # network may not beat the MER target by more than this -DOC_RTOL = 1e-3 # network may not be worse than documented by more than this - -def utility_hx(ID, T, P, phase, T_out, rigorous=None, **flow): - """A simulated HXutility acting as one process stream (kmol/hr flows).""" - s = bst.Stream(ID + '_in', T=T, P=P, phase=phase, units='kmol/hr', **flow) - if rigorous is None: rigorous = phase == 'g' - hx = bst.HXutility(ID, ins=s, T=T_out, rigorous=rigorous) - hx.simulate() - return hx - -def boiling_hx(ID, T, P, T_out, **flow): - """A cold liquid stream heated past its bubble point (rigorous VLE).""" - return utility_hx(ID, T, P, 'l', T_out, rigorous=True, **flow) - -def setup(name, chemicals=('Water', 'Ethanol')): - bst.settings.set_thermo(list(chemicals), cache=True) - bst.main_flowsheet.set_flowsheet('test_hxn_regression_' + name) - -# --------------------------------------------------------------------------- -# Cases -# --------------------------------------------------------------------------- - -def case_01_two_liquids(): - """Hot liquid, cold liquid; trivial counter-current match.""" - setup('01') - return [utility_hx('H1', 400., 5e5, 'l', 320., Water=1000.), - utility_hx('C1', 300., 101325., 'l', 360., Water=1000.)], 5. - -def case_02_pinch_limited(): - """Cold target above the hot inlet: part of the heating must be utility.""" - setup('02') - return [utility_hx('H1', 360., 5e5, 'l', 320., Water=1000.), - utility_hx('C1', 300., 5e5, 'l', 380., Water=800.)], 5. - -def case_03_condenser_two_colds(): - """Condensing ethanol vapor against two cold liquids.""" - setup('03') - return [utility_hx('H1', 355., 101325., 'g', 340., Ethanol=400.), - utility_hx('C1', 300., 101325., 'l', 345., Water=1500.), - utility_hx('C2', 310., 101325., 'l', 340., Water=300., Ethanol=300.)], 5. - -def case_04_report_case(): - """The 4-stream report case: 2 colds, condensing hot, hot liquid.""" - setup('04') - return [utility_hx('C1', 300., 101325., 'l', 390., Water=2000.), - utility_hx('C2', 310., 101325., 'l', 345., Water=500., Ethanol=500.), - utility_hx('H1', 352., 101325., 'g', 340., Ethanol=300.), - utility_hx('H2', 420., 5e5, 'l', 320., Water=800.)], 5. - -def case_05_boiling_cold(): - """A cold stream that boils (water -> steam) and a condensing hot stream.""" - setup('05') - return [boiling_hx('C1', 330., 101325., 380., Water=300.), - utility_hx('C2', 300., 101325., 'l', 350., Water=1000.), - utility_hx('H1', 420., 5e5, 'g', 330., Water=250.), - utility_hx('H2', 400., 5e5, 'l', 310., Water=1500.)], 5. - -def case_06_mixed_pressures(): - """5-bar condensing hot against 1-atm boiling cold; T_min_app = 10.""" - setup('06') - return [utility_hx('H1', 430., 5e5, 'g', 400., Water=200.), - utility_hx('H2', 380., 5e5, 'l', 320., Water=1200.), - boiling_hx('C1', 340., 101325., 375., Water=150.), - utility_hx('C2', 300., 101325., 'l', 360., Ethanol=800.), - utility_hx('C3', 320., 101325., 'l', 390., Water=600.)], 10. - -def case_07_threshold(): - """Threshold problem: heating dominates so the cold target is ~0; - one hot stream condenses and subcools.""" - setup('07') - return [utility_hx('H1', 375., 101325., 'g', 310., Water=80.), - utility_hx('H2', 360., 101325., 'l', 330., Water=200.), - utility_hx('C1', 300., 101325., 'l', 370., Water=1500.), - utility_hx('C2', 305., 101325., 'l', 350., Ethanol=800.), - boiling_hx('C3', 340., 101325., 355., Ethanol=200.), - utility_hx('C4', 320., 101325., 'l', 360., Water=700.)], 5. - -def case_08_two_condensers(): - """Two condensers at different temperatures (ethanol 1 atm, water 2 bar) - against three colds, one of which boils.""" - setup('08') - return [utility_hx('H1', 355., 101325., 'g', 335., Ethanol=300.), - utility_hx('H2', 400., 2e5, 'g', 360., Water=150.), - utility_hx('H3', 390., 5e5, 'l', 330., Water=900.), - utility_hx('C1', 300., 101325., 'l', 345., Water=1200.), - boiling_hx('C2', 330., 101325., 370., Ethanol=250.), - utility_hx('C3', 310., 101325., 'l', 380., Water=700.)], 5. - -def case_09_near_degenerate(): - """Eight streams with two near-equal pinch candidates, a partially - condensing hot stream (wet outlet) and a partially boiling cold stream.""" - setup('09') - return [utility_hx('H1', 380., 101325., 'g', 372., Water=120.), # partial condensation - utility_hx('H2', 365., 101325., 'g', 330., Ethanol=250.), - utility_hx('H3', 410., 5e5, 'l', 340., Water=700.), - utility_hx('H4', 345., 101325., 'l', 305., Ethanol=900.), - boiling_hx('C1', 350., 101325., 373.5, Water=200.), # partial boiling - utility_hx('C2', 300., 101325., 'l', 340., Water=1500.), - boiling_hx('C3', 320., 101325., 352., Ethanol=300.), - utility_hx('C4', 335., 101325., 'l', 395., Water=500.)], 5. - -def case_10_ten_streams(): - """Ten streams mixing liquids, condensers, boilers, and pressures.""" - setup('10') - return [utility_hx('H1', 355., 101325., 'g', 320., Ethanol=300.), - utility_hx('H2', 420., 5e5, 'g', 340., Water=150.), - utility_hx('H3', 395., 5e5, 'l', 330., Water=1000.), - utility_hx('H4', 370., 101325., 'l', 310., Ethanol=700.), - utility_hx('H5', 380., 101325., 'g', 372.5, Water=100.), # partial condensation - utility_hx('C1', 300., 101325., 'l', 360., Water=2000.), - boiling_hx('C2', 330., 101325., 380., Water=200.), - boiling_hx('C3', 320., 101325., 352., Ethanol=400.), - utility_hx('C4', 310., 101325., 'l', 345., Water=400., Ethanol=400.), - utility_hx('C5', 340., 101325., 'l', 390., Water=600.)], 5. - -# name -> (builder, documented hot utility load [kJ/hr], documented cold utility load [kJ/hr]) -# Documented values: see module docstring for provenance. -CASES = { - 'case_01_two_liquids': (case_01_two_liquids, 0, 1.53912e+06), - 'case_02_pinch_limited': (case_02_pinch_limited, 1.81522e+06, 0), - 'case_03_condenser_two_colds': (case_03_condenser_two_colds, 0, 9.49905e+06), - 'case_04_report_case': (case_04_report_case, 2.37319e+06, 3.56871e+06), - 'case_05_boiling_cold': (case_05_boiling_cold, 3.2224e+06, 7.81466e+06), - 'case_06_mixed_pressures': (case_06_mixed_pressures, 7.05541e+06, 4.93079e+06), - 'case_07_threshold': (case_07_threshold, 1.85977e+07, 0), - 'case_08_two_condensers': (case_08_two_condensers, 3.02237e+06, 7.36431e+06), - 'case_09_near_degenerate': (case_09_near_degenerate, 1.40965e+07, 9.66427e+06), - 'case_10_ten_streams': (case_10_ten_streams, 1.40742e+07, 8.06488e+06), -} - -# --------------------------------------------------------------------------- -# Harness -# --------------------------------------------------------------------------- - -def synthesize(builder): - units, T_min_app = builder() - HXN = bst.HeatExchangerNetwork('HXN', T_min_app=T_min_app) - sys = bst.System.from_units('sys', units=[*units, HXN]) - with warnings.catch_warnings(): - warnings.simplefilter('error', RuntimeWarning) - # thermosteam registry bookkeeping on temporary stream copies; not numerical - warnings.filterwarnings('ignore', message='.*has been replaced in registry', - category=RuntimeWarning) - sys.simulate() - return units, HXN, T_min_app - -def mer_targets(units, T_min_app): - hus = [hx.heat_utilities[0] for hx in units] - hus.sort(key=lambda hu: hu.duty) - streams_inlet = [hu.unit.ins[0].copy() for hu in hus] - streams_quenched = [hu.unit.outs[0].copy() for hu in hus] - for s in streams_quenched: s.vle(H=s.H, P=s.P) - is_hot = [hu.duty < 0 for hu in hus] - table = problem_table(streams_inlet, streams_quenched, is_hot, T_min_app) - return table.hot_util_load, table.cold_util_load - -def actual_loads(HXN): - hus = [hu for hx in HXN.new_HX_utils for hu in hx.heat_utilities] - heat = sum(hu.unit_duty for hu in hus if hu.unit_duty > 0) - cool = -sum(hu.unit_duty for hu in hus if hu.unit_duty < 0) - return heat, cool - -@pytest.mark.parametrize('name', list(CASES)) -def test_hxn_regression(name): - builder, doc_heat, doc_cool = CASES[name] - units, HXN, T_min_app = synthesize(builder) - # (i) energy balance - assert abs(HXN.energy_balance_percent_error) < EB_TOLERANCE, name - # (ii) MER targets are a lower bound; energy identity holds - heat, cool = actual_loads(HXN) - hot_target, cold_target = mer_targets(units, T_min_app) - net_duty = sum(hx.heat_utilities[0].unit_duty for hx in units) - assert heat >= hot_target * (1 - MER_RTOL), (name, heat, hot_target) - assert cool >= cold_target * (1 - MER_RTOL), (name, cool, cold_target) - assert_allclose(heat - cool, net_duty, rtol=1e-8, err_msg=name) - # (iii) never worse than documented - assert doc_heat is not None and doc_cool is not None, f'{name}: baseline not recorded' - assert heat <= doc_heat * (1 + DOC_RTOL) + 1e-9, (name, heat, doc_heat) - assert cool <= doc_cool * (1 + DOC_RTOL) + 1e-9, (name, cool, doc_cool) - -if __name__ == '__main__': - for name, (builder, *_) in CASES.items(): - units, HXN, T_min_app = synthesize(builder) - heat, cool = actual_loads(HXN) - hot_target, cold_target = mer_targets(units, T_min_app) - print(f"{name}: heat={heat:.6g} cool={cool:.6g} " - f"(MER hot={hot_target:.6g} cold={cold_target:.6g}; " - f"EB error={HXN.energy_balance_percent_error:.4f}%)") From 62d3955198bb4376ca369cd859ab04b6048a79c7 Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Mon, 24 Aug 2026 01:39:31 -0700 Subject: [PATCH 16/26] address PR #257 review: harden lazy hensmith re-export, bump to 2.54.0, wire CI/docs Implements the ten findings from the PR #257 code review of the HXN -> hensmith migration. Version (finding 1): bump biosteam 2.53.11 -> 2.54.0 and the setup.py install_requires so hensmith can pin a floor (biosteam>=2.54.0) that the pre-migration PyPI wheel does not satisfy. Otherwise `pip install hensmith` onto released biosteam 2.53.11 leaves two distinct HeatExchangerNetwork classes (the bundled biosteam.facilities.hxn copy winning bst.HeatExchangerNetwork), silently breaking downstream isinstance checks. Lazy re-export shim (findings 4, 8, 10): replace the two hand-copied single-name __getattr__ shims with one shared helper in facilities/__init__.py, delegated to from biosteam/__init__. It now - catches ImportError and re-raises AttributeError with a hensmith pointer, so hasattr()/getattr(default) no longer leak ModuleNotFoundError and create_all_facilities fails with a message that names the move; - caches resolved supported names into module globals (PEP 562 memoization) so bst.HeatExchangerNetwork stops re-entering the import machinery on every access, and adds the companion __dir__; - forwards the five moved synthesis helpers (StreamLifeCycle, ProblemTable, problem_table, synthesize_network, plot_pinch_diagram) with a DeprecationWarning for one release cycle, rather than a bare AttributeError. CI / docs (findings 2, 7): git-install hensmith from HEAD in build.yml (--no-deps, since the biosteam<->hensmith pins are circular by design) so CI validates the sibling repo instead of the frozen PyPI wheel; add ../hensmith to docs/conf.py's sys.path so autoclass resolves from a source checkout; qualify the docs note (star-import of biosteam.facilities no longer provides the name; all five helpers listed and marked deprecated). Tests (findings 5, 6, 9): rework tests/test_hensmith_integration.py to capture subprocess stderr, assert HeatExchangerNetwork stays out of facilities.__all__ (the cycle guard), exercise the hensmith-first and from-scratch star-import orderings, assert missing-hensmith degrades to AttributeError, assert the deprecated helpers warn, and add a create_all_facilities smoke test that constructs the network through the lazy re-export. Validation: full suite (CI invocation, local thermosteam+hensmith clones) 74 failed / 469 passed / 62 skipped -- identical documented pre-existing failure set, passed up by the 4 new integration tests. hensmith suite 33 passed. Co-Authored-By: Claude Fable 5 --- .github/workflows/build.yml | 1 + biosteam/__init__.py | 23 ++-- biosteam/facilities/__init__.py | 71 +++++++++-- docs/API/facilities/HeatExchangerNetwork.txt | 13 +- docs/conf.py | 2 +- setup.py | 2 +- tests/test_hensmith_integration.py | 123 +++++++++++++++++-- 7 files changed, 202 insertions(+), 33 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index b8cac04a..9e5b0572 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -58,6 +58,7 @@ jobs: pip install --no-cache-dir git+https://github.com/CalebBell/thermo.git pip install --no-cache-dir git+https://github.com/BioSTEAMDevelopmentGroup/thermosteam.git pip install --no-cache-dir git+https://github.com/BioSTEAMDevelopmentGroup/Bioindustrial-Park.git + pip install --no-cache-dir --no-deps git+https://github.com/BioSTEAMDevelopmentGroup/hensmith.git pip install -r requirements_test.txt pip install --no-cache-dir git+https://github.com/QSD-Group/QSDsan.git pip install --no-cache-dir git+https://github.com/QSD-Group/EXPOsan.git diff --git a/biosteam/__init__.py b/biosteam/__init__.py index 7b58318d..27500143 100644 --- a/biosteam/__init__.py +++ b/biosteam/__init__.py @@ -13,7 +13,7 @@ """ from __future__ import annotations -__version__ = '2.53.11' +__version__ = '2.54.0' #: Chemical engineering plant cost index (defaults to 567.5 at 2017). CE: float = 567.5 @@ -81,6 +81,11 @@ def njit(*args, **kwargs): __all__ = ( 'Unit', 'PowerUtility', 'UtilityAgent', 'HeatUtility', 'Facility', + # Lazily re-exported from hensmith (PEP 562, see facilities/__init__.py). + # Listing it here makes `from biosteam import *` import hensmith eagerly, + # which is safe only while no module executed during hensmith's own + # initialization star-imports biosteam at module scope + # (guarded by tests/test_hensmith_integration.py). 'HeatExchangerNetwork', 'utils', 'units', 'facilities', 'wastewater', 'evaluation', 'Chemical', 'Chemicals', 'Stream', 'MultiStream', 'settings', 'exceptions', 'report', 'units_of_measure', @@ -90,14 +95,18 @@ def njit(*args, **kwargs): ) def __getattr__(name): - # HeatExchangerNetwork now lives in the hensmith package - # (github.com/BioSTEAMDevelopmentGroup/hensmith); see - # biosteam/facilities/__init__.py for why the re-export is lazy. - if name == 'HeatExchangerNetwork': - from hensmith import HeatExchangerNetwork - return HeatExchangerNetwork + # HeatExchangerNetwork and the network synthesis helpers now live in the + # hensmith package (github.com/BioSTEAMDevelopmentGroup/hensmith); the + # shared lazy re-export machinery — and why it must be lazy — lives in + # biosteam/facilities/__init__.py. + if (name in facilities._HENSMITH_LAZY_NAMES + or name in facilities._HENSMITH_DEPRECATED_NAMES): + return facilities._import_from_hensmith(name, globals()) raise AttributeError(f"module {__name__!r} has no attribute {name!r}") +def __dir__(): + return sorted({*globals(), *facilities._HENSMITH_LAZY_NAMES}) + def nbtutorial(dark=False): global print_error diff --git a/biosteam/facilities/__init__.py b/biosteam/facilities/__init__.py index a0ddd7b5..95ed2b7a 100644 --- a/biosteam/facilities/__init__.py +++ b/biosteam/facilities/__init__.py @@ -45,16 +45,65 @@ *systems.__all__, ) +# %% Lazy re-exports from the hensmith package (PEP 562) +# +# HeatExchangerNetwork and the network synthesis helpers now live in the +# hensmith package (github.com/BioSTEAMDevelopmentGroup/hensmith). They are +# re-exported lazily so that the biosteam <-> hensmith circular dependency +# is import-safe: importing biosteam never initializes hensmith, and +# hensmith can import biosteam eagerly while defining its classes. The +# names must stay out of __all__ because biosteam/__init__ star-imports +# this module during initialization, which would resolve them eagerly and +# re-create the import cycle (guarded by tests/test_hensmith_integration.py). +# biosteam/__init__ delegates its own __getattr__/__dir__ here so the two +# shims cannot drift apart. + +#: Names re-exported lazily from hensmith and still fully supported +#: under the biosteam namespace. +_HENSMITH_LAZY_NAMES = ('HeatExchangerNetwork',) + +#: Names re-exported lazily from hensmith as deprecated aliases, kept for +#: one release cycle after the 2026-08 migration. +_HENSMITH_DEPRECATED_NAMES = ( + 'StreamLifeCycle', 'ProblemTable', 'problem_table', + 'synthesize_network', 'plot_pinch_diagram', +) + +def _import_from_hensmith(name, module_globals): + """ + Resolve `name` from hensmith on behalf of the module owning + `module_globals`, raising AttributeError (not ImportError, which would + leak through `hasattr` and default-valued `getattr`) when hensmith is + unavailable. Supported names are cached into the requesting module so + later accesses bypass __getattr__; deprecated names are not cached so + each access warns. + """ + try: + import hensmith + except ImportError as e: + raise AttributeError( + f"module {module_globals['__name__']!r} has no attribute {name!r}: " + f"{name!r} moved to the hensmith package " + "(https://github.com/BioSTEAMDevelopmentGroup/hensmith); " + "install it with `pip install hensmith`" + ) from e + value = getattr(hensmith, name) + if name in _HENSMITH_DEPRECATED_NAMES: + import warnings + warnings.warn( + f"{module_globals['__name__']}.{name} is deprecated and will be " + f"removed in a future release; import it from hensmith instead " + f"(`from hensmith import {name}`)", + DeprecationWarning, stacklevel=3, + ) + else: + module_globals[name] = value + return value + def __getattr__(name): - # HeatExchangerNetwork now lives in the hensmith package - # (github.com/BioSTEAMDevelopmentGroup/hensmith). It is re-exported - # lazily (PEP 562) so that the biosteam <-> hensmith circular dependency - # is import-safe: importing biosteam never initializes hensmith, and - # hensmith can import biosteam eagerly while defining its classes. The - # name must stay out of __all__ because biosteam/__init__ star-imports - # this module during initialization, which would resolve it eagerly and - # re-create the import cycle. - if name == 'HeatExchangerNetwork': - from hensmith import HeatExchangerNetwork - return HeatExchangerNetwork + if name in _HENSMITH_LAZY_NAMES or name in _HENSMITH_DEPRECATED_NAMES: + return _import_from_hensmith(name, globals()) raise AttributeError(f"module {__name__!r} has no attribute {name!r}") + +def __dir__(): + return sorted({*globals(), *_HENSMITH_LAZY_NAMES}) diff --git a/docs/API/facilities/HeatExchangerNetwork.txt b/docs/API/facilities/HeatExchangerNetwork.txt index 6c771de4..c92577ae 100644 --- a/docs/API/facilities/HeatExchangerNetwork.txt +++ b/docs/API/facilities/HeatExchangerNetwork.txt @@ -7,10 +7,15 @@ HeatExchangerNetwork (Heat Exchanger Network Synthesis, Modeling, Integration, Thermodynamics, and Heuristics), which is a dependency of BioSTEAM. It remains available as ``biosteam.HeatExchangerNetwork`` and - ``biosteam.facilities.HeatExchangerNetwork``. The network synthesis - helpers (``synthesize_network``, ``problem_table``, - ``plot_pinch_diagram``, ``StreamLifeCycle``) are now importable only from - ``hensmith``. + ``biosteam.facilities.HeatExchangerNetwork`` through lazy (PEP 562) + re-exports. Because the re-export is lazy, ``from biosteam.facilities + import *`` no longer provides the name — import it explicitly + (``from biosteam import *`` still provides it). The network synthesis + helpers (``StreamLifeCycle``, ``ProblemTable``, ``problem_table``, + ``synthesize_network``, ``plot_pinch_diagram``) now live in ``hensmith``; + accessing them through ``biosteam`` or ``biosteam.facilities`` still + works but emits a ``DeprecationWarning`` and will stop working in a + future release. .. autoclass:: hensmith.HeatExchangerNetwork :members: diff --git a/docs/conf.py b/docs/conf.py index 32118ceb..17af3268 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -20,7 +20,7 @@ except: pass # docutils may not be installed for test suit -new_path = ['..\\', '..\\thermosteam\\', '..\\Bioindustrial-Park\\', '..\\How2STEAM\\'] +new_path = ['..\\', '..\\thermosteam\\', '..\\Bioindustrial-Park\\', '..\\How2STEAM\\', '..\\hensmith\\'] for p in new_path: sys.path.insert(0, os.path.abspath(p)) diff --git a/setup.py b/setup.py index 05fd8ced..e47aa264 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,7 @@ name='biosteam', packages=['biosteam'], license='MIT', - version='2.53.11', + version='2.54.0', description='The Biorefinery Simulation and Techno-Economic Analysis Modules', long_description=open('README.rst', encoding='utf-8').read(), author='Yoel Cortes-Pena', diff --git a/tests/test_hensmith_integration.py b/tests/test_hensmith_integration.py index 979f2601..3056b9e2 100644 --- a/tests/test_hensmith_integration.py +++ b/tests/test_hensmith_integration.py @@ -9,14 +9,27 @@ """ Tests that the biosteam <-> hensmith circular dependency is import-safe in both directions and that biosteam lazily re-exports HeatExchangerNetwork -from hensmith (PEP 562), so that `import biosteam` never requires hensmith -to be initialized first and vice versa. +(and, with a DeprecationWarning, the network synthesis helpers) from +hensmith via PEP 562, so that `import biosteam` never requires hensmith to +be initialized first and vice versa. """ import subprocess import sys +import pytest def _run(code): - subprocess.run([sys.executable, '-c', code], check=True) + # Import-ordering semantics can only be tested in a cold interpreter; + # capture output so a child failure surfaces its traceback instead of + # an opaque "returned non-zero exit status 1". + result = subprocess.run( + [sys.executable, '-c', code], capture_output=True, text=True, + ) + if result.returncode: + raise AssertionError( + f"subprocess failed with exit code {result.returncode}\n" + f"--- stdout ---\n{result.stdout}\n" + f"--- stderr ---\n{result.stderr}" + ) def test_biosteam_first_import_order(): _run( @@ -24,6 +37,27 @@ def test_biosteam_first_import_order(): "import hensmith\n" "assert bst.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" "assert bst.facilities.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + # Supported lazy names are cached on first access (PEP 562 shim + # memoization) and reported by the companion __dir__. + "assert 'HeatExchangerNetwork' in vars(bst)\n" + "assert 'HeatExchangerNetwork' in dir(bst)\n" + "assert 'HeatExchangerNetwork' in dir(bst.facilities)\n" + # The from-import and star-import forms (folded from a separate + # subprocess; they add no ordering coverage of their own). + "from biosteam import HeatExchangerNetwork\n" + "from biosteam.facilities import HeatExchangerNetwork as HXN2\n" + "assert HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + "assert HXN2 is hensmith.HeatExchangerNetwork\n" + "ns = {}\n" + "exec('from biosteam import *', ns)\n" + "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" + # Star-importing the facilities subpackage must NOT provide the name: + # keeping it out of facilities.__all__ is the guard that stops + # biosteam/__init__'s star-import of facilities from re-creating the + # biosteam <-> hensmith import cycle. + "ns = {}\n" + "exec('from biosteam.facilities import *', ns)\n" + "assert 'HeatExchangerNetwork' not in ns\n" ) def test_hensmith_first_import_order(): @@ -32,21 +66,92 @@ def test_hensmith_first_import_order(): "import biosteam as bst\n" "assert bst.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" "assert bst.facilities.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" + # `from biosteam import *` resolves HeatExchangerNetwork eagerly + # (it is in biosteam.__all__), which is safe only while no module + # executed during hensmith's initialization star-imports biosteam + # at module scope — exercise it under hensmith-first ordering too. + "ns = {}\n" + "exec('from biosteam import *', ns)\n" + "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" ) -def test_from_imports_and_star_import(): +def test_star_import_initializes_hensmith_from_scratch(): + # `from biosteam import *` in a fresh interpreter, hensmith never + # imported: the star-import itself must initialize hensmith through the + # lazy re-export — hensmith's own `import biosteam` then finds the + # already-completed module. This is the common real-world consumer path. _run( - "from biosteam import HeatExchangerNetwork\n" - "from biosteam.facilities import HeatExchangerNetwork as HXN2\n" "ns = {}\n" "exec('from biosteam import *', ns)\n" "import hensmith\n" - "assert HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" - "assert HXN2 is hensmith.HeatExchangerNetwork\n" "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" ) +def test_missing_hensmith_degrades_to_AttributeError(): + # With hensmith unavailable, biosteam must still import, and attribute + # access must fail with AttributeError — not leak ModuleNotFoundError + # through hasattr/getattr — with a message pointing at hensmith. + _run( + "import sys\n" + "sys.modules['hensmith'] = None\n" # makes `import hensmith` raise ImportError + "import biosteam as bst\n" + "assert not hasattr(bst, 'HeatExchangerNetwork')\n" + "assert not hasattr(bst.facilities, 'HeatExchangerNetwork')\n" + "assert getattr(bst, 'HeatExchangerNetwork', None) is None\n" + "for module in (bst, bst.facilities):\n" + " try:\n" + " module.HeatExchangerNetwork\n" + " except AttributeError as e:\n" + " assert 'hensmith' in str(e)\n" + " else:\n" + " raise AssertionError('AttributeError not raised')\n" + ) + +def test_HeatExchangerNetwork_not_in_facilities_all(): + # Negative guard: re-adding the name to facilities.__all__ would make + # biosteam/__init__'s star-import of facilities resolve it eagerly and + # re-create the biosteam <-> hensmith import cycle. Fail loudly if a + # future "fix" tries. + import biosteam as bst + assert 'HeatExchangerNetwork' not in bst.facilities.__all__ + for name in bst.facilities._HENSMITH_DEPRECATED_NAMES: + assert name not in bst.facilities.__all__ + assert name not in bst.__all__ + +def test_deprecated_helpers_forward_with_warning(): + import biosteam as bst + import hensmith + for module in (bst, bst.facilities): + for name in bst.facilities._HENSMITH_DEPRECATED_NAMES: + with pytest.warns(DeprecationWarning, match='hensmith'): + value = getattr(module, name) + assert value is getattr(hensmith, name) + # Deprecated aliases are not cached, so every access warns. + assert name not in vars(module) + +def test_create_all_facilities_constructs_hensmith_network(): + # The real downstream seam: create_facilities instantiates + # bst.HeatExchangerNetwork (HXN=True by default) through the lazy + # re-export inside a MockSystem context. + import biosteam as bst + import hensmith + bst.settings.set_thermo(['Water'], cache=True) + bst.main_flowsheet.set_flowsheet('hensmith_integration_HXN_smoke') + try: + units = bst.create_all_facilities( + CT=False, CWP=False, CIP=False, FWT=False, ADP=False, + WWT=False, CHP=False, PWC=False, # HXN=True by default + ) + hxns = [i for i in units if isinstance(i, hensmith.HeatExchangerNetwork)] + assert len(hxns) == 1 + finally: + bst.main_flowsheet.clear() + if __name__ == '__main__': test_biosteam_first_import_order() test_hensmith_first_import_order() - test_from_imports_and_star_import() + test_star_import_initializes_hensmith_from_scratch() + test_missing_hensmith_degrades_to_AttributeError() + test_HeatExchangerNetwork_not_in_facilities_all() + test_deprecated_helpers_forward_with_warning() + test_create_all_facilities_constructs_hensmith_network() From 7ff69657be82dbda3399d0d5258df3943e02554e Mon Sep 17 00:00:00 2001 From: sarangbhagwat Date: Thu, 3 Sep 2026 19:28:22 -0700 Subject: [PATCH 17/26] replace the lazy hensmith re-export with an eager import, per PR #257 review The PR #257 review asked to drop the PEP 562 module __getattr__ shims that re-exported HeatExchangerNetwork from hensmith: they add a layer of indirection that is unnecessary because hensmith is quick to import. biosteam/__init__.py now ends with a plain `import hensmith`, after every biosteam subpackage hensmith needs (it subclasses Facility) is initialized, and lists 'HeatExchangerNetwork' in __all__ only when that import succeeds. Only a missing hensmith (ModuleNotFoundError naming hensmith) is tolerated, so biosteam still imports in environments without it; an error raised while hensmith itself initializes propagates instead of being masked. The binding of the name is done by hensmith, not here: in the hensmith-first import order biosteam's __init__ runs from hensmith's own `import biosteam` while hensmith is still initializing and HeatExchangerNetwork does not exist yet, so a `from hensmith import HeatExchangerNetwork` in biosteam would raise ImportError in that order. hensmith 0.1.2 therefore binds HeatExchangerNetwork into biosteam and biosteam.facilities at the end of its own __init__ -- whichever package finishes initializing second does the binding -- and setup.py pins hensmith>=0.1.2 since 0.1.1 (on PyPI) would leave the name unbound. The name stays out of facilities.__all__, which biosteam star-imports before hensmith can bind it. The __getattr__/__dir__ shims and the deprecated aliases for the synthesis helpers (StreamLifeCycle, ProblemTable, problem_table, synthesize_network, plot_pinch_diagram) are removed; those live in hensmith only (no downstream user in biorefineries). create_all_facilities already used bst.HeatExchangerNetwork with a module-scope import. tests/test_hensmith_integration.py is rewritten for the eager contract: both import orders, star-import from scratch, missing hensmith (name absent from the namespace and from __all__), broken hensmith propagating, the facilities.__all__ guard, and the create_all_facilities smoke test (7 passed). hensmith suite: 33 passed. Full suite (CI invocation, with thermosteam at f768d38 as master's submodule pointer requires): 82 failed, 462 passed, 62 skipped -- versus the recorded 74-failure baseline, 15 fewer notebook failures and 23 new doctest failures that are stack drift in the merged master (21 single-component Stream.show representation from thermosteam 68e89dc; BinaryDistillation and ShortcutColumn platform-and-ladders labels not regenerated after #252), none involving hensmith. Co-Authored-By: Claude Fable 5.1 --- biosteam/__init__.py | 45 ++++---- biosteam/facilities/__init__.py | 66 +---------- docs/API/facilities/HeatExchangerNetwork.txt | 15 +-- setup.py | 2 +- tests/test_hensmith_integration.py | 115 ++++++++++--------- 5 files changed, 94 insertions(+), 149 deletions(-) diff --git a/biosteam/__init__.py b/biosteam/__init__.py index 27500143..a40337a6 100644 --- a/biosteam/__init__.py +++ b/biosteam/__init__.py @@ -79,33 +79,38 @@ def njit(*args, **kwargs): from . import report from . import _settings +# %% Heat exchanger network synthesis (hensmith) +# +# HeatExchangerNetwork lives in the hensmith package +# (github.com/BioSTEAMDevelopmentGroup/hensmith). hensmith subclasses Facility, +# so it imports biosteam eagerly and can only be imported once biosteam is +# fully initialized -- here, last. hensmith binds HeatExchangerNetwork into +# biosteam and biosteam.facilities at the end of its own __init__, which makes +# either import order work: importing biosteam first initializes hensmith right +# here; importing hensmith first makes this `import hensmith` return the +# still-initializing module, and hensmith binds the name when it finishes. The +# name must stay out of facilities.__all__, which is star-imported above before +# hensmith can bind it. Without hensmith installed, biosteam imports and simply +# lacks the name (guarded by tests/test_hensmith_integration.py). +try: + import hensmith +except ModuleNotFoundError as error: + if error.name != 'hensmith': raise + _hensmith_all = () +else: + del hensmith + _hensmith_all = ('HeatExchangerNetwork',) + __all__ = ( 'Unit', 'PowerUtility', 'UtilityAgent', 'HeatUtility', 'Facility', - # Lazily re-exported from hensmith (PEP 562, see facilities/__init__.py). - # Listing it here makes `from biosteam import *` import hensmith eagerly, - # which is safe only while no module executed during hensmith's own - # initialization star-imports biosteam at module scope - # (guarded by tests/test_hensmith_integration.py). - 'HeatExchangerNetwork', + *_hensmith_all, 'utils', 'units', 'facilities', 'wastewater', 'evaluation', 'Chemical', 'Chemicals', 'Stream', 'MultiStream', 'settings', 'exceptions', 'report', 'units_of_measure', - 'process_tools', 'preferences', *_system.__all__, *_flowsheet.__all__, + 'process_tools', 'preferences', *_system.__all__, *_flowsheet.__all__, *_tea.__all__, *units.__all__, *facilities.__all__, *wastewater.__all__, *evaluation.__all__, *process_tools.__all__, *_module.__all__, ) - -def __getattr__(name): - # HeatExchangerNetwork and the network synthesis helpers now live in the - # hensmith package (github.com/BioSTEAMDevelopmentGroup/hensmith); the - # shared lazy re-export machinery — and why it must be lazy — lives in - # biosteam/facilities/__init__.py. - if (name in facilities._HENSMITH_LAZY_NAMES - or name in facilities._HENSMITH_DEPRECATED_NAMES): - return facilities._import_from_hensmith(name, globals()) - raise AttributeError(f"module {__name__!r} has no attribute {name!r}") - -def __dir__(): - return sorted({*globals(), *facilities._HENSMITH_LAZY_NAMES}) +del _hensmith_all def nbtutorial(dark=False): global print_error diff --git a/biosteam/facilities/__init__.py b/biosteam/facilities/__init__.py index 95ed2b7a..4b6303bf 100644 --- a/biosteam/facilities/__init__.py +++ b/biosteam/facilities/__init__.py @@ -45,65 +45,7 @@ *systems.__all__, ) -# %% Lazy re-exports from the hensmith package (PEP 562) -# -# HeatExchangerNetwork and the network synthesis helpers now live in the -# hensmith package (github.com/BioSTEAMDevelopmentGroup/hensmith). They are -# re-exported lazily so that the biosteam <-> hensmith circular dependency -# is import-safe: importing biosteam never initializes hensmith, and -# hensmith can import biosteam eagerly while defining its classes. The -# names must stay out of __all__ because biosteam/__init__ star-imports -# this module during initialization, which would resolve them eagerly and -# re-create the import cycle (guarded by tests/test_hensmith_integration.py). -# biosteam/__init__ delegates its own __getattr__/__dir__ here so the two -# shims cannot drift apart. - -#: Names re-exported lazily from hensmith and still fully supported -#: under the biosteam namespace. -_HENSMITH_LAZY_NAMES = ('HeatExchangerNetwork',) - -#: Names re-exported lazily from hensmith as deprecated aliases, kept for -#: one release cycle after the 2026-08 migration. -_HENSMITH_DEPRECATED_NAMES = ( - 'StreamLifeCycle', 'ProblemTable', 'problem_table', - 'synthesize_network', 'plot_pinch_diagram', -) - -def _import_from_hensmith(name, module_globals): - """ - Resolve `name` from hensmith on behalf of the module owning - `module_globals`, raising AttributeError (not ImportError, which would - leak through `hasattr` and default-valued `getattr`) when hensmith is - unavailable. Supported names are cached into the requesting module so - later accesses bypass __getattr__; deprecated names are not cached so - each access warns. - """ - try: - import hensmith - except ImportError as e: - raise AttributeError( - f"module {module_globals['__name__']!r} has no attribute {name!r}: " - f"{name!r} moved to the hensmith package " - "(https://github.com/BioSTEAMDevelopmentGroup/hensmith); " - "install it with `pip install hensmith`" - ) from e - value = getattr(hensmith, name) - if name in _HENSMITH_DEPRECATED_NAMES: - import warnings - warnings.warn( - f"{module_globals['__name__']}.{name} is deprecated and will be " - f"removed in a future release; import it from hensmith instead " - f"(`from hensmith import {name}`)", - DeprecationWarning, stacklevel=3, - ) - else: - module_globals[name] = value - return value - -def __getattr__(name): - if name in _HENSMITH_LAZY_NAMES or name in _HENSMITH_DEPRECATED_NAMES: - return _import_from_hensmith(name, globals()) - raise AttributeError(f"module {__name__!r} has no attribute {name!r}") - -def __dir__(): - return sorted({*globals(), *_HENSMITH_LAZY_NAMES}) +# HeatExchangerNetwork lives in the hensmith package and is bound into this +# namespace by hensmith/__init__.py once biosteam has finished initializing +# (see the end of biosteam/__init__.py). It must stay out of __all__: biosteam +# star-imports this module before hensmith can bind it. diff --git a/docs/API/facilities/HeatExchangerNetwork.txt b/docs/API/facilities/HeatExchangerNetwork.txt index c92577ae..fadd6765 100644 --- a/docs/API/facilities/HeatExchangerNetwork.txt +++ b/docs/API/facilities/HeatExchangerNetwork.txt @@ -7,15 +7,12 @@ HeatExchangerNetwork (Heat Exchanger Network Synthesis, Modeling, Integration, Thermodynamics, and Heuristics), which is a dependency of BioSTEAM. It remains available as ``biosteam.HeatExchangerNetwork`` and - ``biosteam.facilities.HeatExchangerNetwork`` through lazy (PEP 562) - re-exports. Because the re-export is lazy, ``from biosteam.facilities - import *`` no longer provides the name — import it explicitly - (``from biosteam import *`` still provides it). The network synthesis - helpers (``StreamLifeCycle``, ``ProblemTable``, ``problem_table``, - ``synthesize_network``, ``plot_pinch_diagram``) now live in ``hensmith``; - accessing them through ``biosteam`` or ``biosteam.facilities`` still - works but emits a ``DeprecationWarning`` and will stop working in a - future release. + ``biosteam.facilities.HeatExchangerNetwork`` (bound when BioSTEAM is + imported), but ``from biosteam.facilities import *`` no longer provides + the name — import it explicitly (``from biosteam import *`` still + provides it). The network synthesis helpers (``StreamLifeCycle``, + ``ProblemTable``, ``problem_table``, ``synthesize_network``, + ``plot_pinch_diagram``) now live in ``hensmith`` only. .. autoclass:: hensmith.HeatExchangerNetwork :members: diff --git a/setup.py b/setup.py index e47aa264..9474e9d4 100644 --- a/setup.py +++ b/setup.py @@ -17,7 +17,7 @@ author='Yoel Cortes-Pena', install_requires=['IPython>=7.9.0', 'thermosteam>=0.53.5', - 'hensmith>=0.1.0', + 'hensmith>=0.1.2', 'graphviz>=0.17', 'chaospy>=4.3.21', 'pyyaml'], diff --git a/tests/test_hensmith_integration.py b/tests/test_hensmith_integration.py index 3056b9e2..b6b2fa43 100644 --- a/tests/test_hensmith_integration.py +++ b/tests/test_hensmith_integration.py @@ -8,14 +8,13 @@ # for license details. """ Tests that the biosteam <-> hensmith circular dependency is import-safe in -both directions and that biosteam lazily re-exports HeatExchangerNetwork -(and, with a DeprecationWarning, the network synthesis helpers) from -hensmith via PEP 562, so that `import biosteam` never requires hensmith to -be initialized first and vice versa. +both directions: biosteam imports hensmith at the very end of its own +initialization, and hensmith binds HeatExchangerNetwork into biosteam and +biosteam.facilities when it finishes initializing, so the name is available +eagerly whichever package is imported first. """ import subprocess import sys -import pytest def _run(code): # Import-ordering semantics can only be tested in a cold interpreter; @@ -33,17 +32,17 @@ def _run(code): def test_biosteam_first_import_order(): _run( + "import sys\n" "import biosteam as bst\n" + # Eager: importing biosteam initializes hensmith and binds the name + # without any further import on the user's part. + "assert 'hensmith' in sys.modules\n" + "assert 'HeatExchangerNetwork' in vars(bst)\n" + "assert 'HeatExchangerNetwork' in vars(bst.facilities)\n" "import hensmith\n" "assert bst.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" "assert bst.facilities.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" - # Supported lazy names are cached on first access (PEP 562 shim - # memoization) and reported by the companion __dir__. - "assert 'HeatExchangerNetwork' in vars(bst)\n" - "assert 'HeatExchangerNetwork' in dir(bst)\n" - "assert 'HeatExchangerNetwork' in dir(bst.facilities)\n" - # The from-import and star-import forms (folded from a separate - # subprocess; they add no ordering coverage of their own). + # The from-import and star-import forms. "from biosteam import HeatExchangerNetwork\n" "from biosteam.facilities import HeatExchangerNetwork as HXN2\n" "assert HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" @@ -52,24 +51,22 @@ def test_biosteam_first_import_order(): "exec('from biosteam import *', ns)\n" "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" # Star-importing the facilities subpackage must NOT provide the name: - # keeping it out of facilities.__all__ is the guard that stops - # biosteam/__init__'s star-import of facilities from re-creating the - # biosteam <-> hensmith import cycle. + # biosteam/__init__ star-imports facilities before hensmith can bind + # it, so listing it in facilities.__all__ would break `import biosteam`. "ns = {}\n" "exec('from biosteam.facilities import *', ns)\n" "assert 'HeatExchangerNetwork' not in ns\n" ) def test_hensmith_first_import_order(): + # biosteam's `import hensmith` runs while hensmith is still initializing + # (HeatExchangerNetwork not yet defined); hensmith must bind the name + # itself once it finishes. _run( "import hensmith\n" "import biosteam as bst\n" "assert bst.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" "assert bst.facilities.HeatExchangerNetwork is hensmith.HeatExchangerNetwork\n" - # `from biosteam import *` resolves HeatExchangerNetwork eagerly - # (it is in biosteam.__all__), which is safe only while no module - # executed during hensmith's initialization star-imports biosteam - # at module scope — exercise it under hensmith-first ordering too. "ns = {}\n" "exec('from biosteam import *', ns)\n" "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" @@ -77,9 +74,7 @@ def test_hensmith_first_import_order(): def test_star_import_initializes_hensmith_from_scratch(): # `from biosteam import *` in a fresh interpreter, hensmith never - # imported: the star-import itself must initialize hensmith through the - # lazy re-export — hensmith's own `import biosteam` then finds the - # already-completed module. This is the common real-world consumer path. + # imported by the user: the common real-world consumer path. _run( "ns = {}\n" "exec('from biosteam import *', ns)\n" @@ -87,52 +82,58 @@ def test_star_import_initializes_hensmith_from_scratch(): "assert ns['HeatExchangerNetwork'] is hensmith.HeatExchangerNetwork\n" ) -def test_missing_hensmith_degrades_to_AttributeError(): - # With hensmith unavailable, biosteam must still import, and attribute - # access must fail with AttributeError — not leak ModuleNotFoundError - # through hasattr/getattr — with a message pointing at hensmith. +def test_missing_hensmith_degrades_gracefully(): + # With hensmith unavailable, biosteam must still import (with the name + # absent from the namespace and from __all__, so star-imports keep + # working) rather than fail at import time. _run( "import sys\n" - "sys.modules['hensmith'] = None\n" # makes `import hensmith` raise ImportError + "sys.modules['hensmith'] = None\n" # makes `import hensmith` raise ModuleNotFoundError "import biosteam as bst\n" "assert not hasattr(bst, 'HeatExchangerNetwork')\n" "assert not hasattr(bst.facilities, 'HeatExchangerNetwork')\n" - "assert getattr(bst, 'HeatExchangerNetwork', None) is None\n" - "for module in (bst, bst.facilities):\n" - " try:\n" - " module.HeatExchangerNetwork\n" - " except AttributeError as e:\n" - " assert 'hensmith' in str(e)\n" - " else:\n" - " raise AssertionError('AttributeError not raised')\n" + "assert 'HeatExchangerNetwork' not in bst.__all__\n" + "ns = {}\n" + "exec('from biosteam import *', ns)\n" + "assert 'HeatExchangerNetwork' not in ns\n" + ) + +def test_broken_hensmith_is_not_swallowed(): + # Only a missing hensmith is tolerated; an error raised while hensmith + # itself initializes must propagate out of `import biosteam`. + _run( + "import sys, types\n" + "class BrokenFinder:\n" + " @staticmethod\n" + " def find_spec(name, path=None, target=None):\n" + " if name == 'hensmith':\n" + " import importlib.util\n" + " loader = types.SimpleNamespace(\n" + " create_module=lambda spec: None,\n" + " exec_module=lambda module: exec('raise RuntimeError(\"hensmith is broken\")'),\n" + " )\n" + " return importlib.util.spec_from_loader(name, loader)\n" + "sys.meta_path.insert(0, BrokenFinder)\n" + "try:\n" + " import biosteam\n" + "except RuntimeError as e:\n" + " assert 'hensmith is broken' in str(e)\n" + "else:\n" + " raise AssertionError('error inside hensmith was swallowed')\n" ) def test_HeatExchangerNetwork_not_in_facilities_all(): - # Negative guard: re-adding the name to facilities.__all__ would make - # biosteam/__init__'s star-import of facilities resolve it eagerly and - # re-create the biosteam <-> hensmith import cycle. Fail loudly if a - # future "fix" tries. + # Negative guard: biosteam/__init__ star-imports facilities before + # hensmith binds the name, so re-adding it to facilities.__all__ would + # break `import biosteam`. Fail loudly if a future "fix" tries. import biosteam as bst assert 'HeatExchangerNetwork' not in bst.facilities.__all__ - for name in bst.facilities._HENSMITH_DEPRECATED_NAMES: - assert name not in bst.facilities.__all__ - assert name not in bst.__all__ - -def test_deprecated_helpers_forward_with_warning(): - import biosteam as bst - import hensmith - for module in (bst, bst.facilities): - for name in bst.facilities._HENSMITH_DEPRECATED_NAMES: - with pytest.warns(DeprecationWarning, match='hensmith'): - value = getattr(module, name) - assert value is getattr(hensmith, name) - # Deprecated aliases are not cached, so every access warns. - assert name not in vars(module) + assert 'HeatExchangerNetwork' in bst.__all__ def test_create_all_facilities_constructs_hensmith_network(): # The real downstream seam: create_facilities instantiates - # bst.HeatExchangerNetwork (HXN=True by default) through the lazy - # re-export inside a MockSystem context. + # bst.HeatExchangerNetwork (HXN=True by default) inside a MockSystem + # context. import biosteam as bst import hensmith bst.settings.set_thermo(['Water'], cache=True) @@ -151,7 +152,7 @@ def test_create_all_facilities_constructs_hensmith_network(): test_biosteam_first_import_order() test_hensmith_first_import_order() test_star_import_initializes_hensmith_from_scratch() - test_missing_hensmith_degrades_to_AttributeError() + test_missing_hensmith_degrades_gracefully() + test_broken_hensmith_is_not_swallowed() test_HeatExchangerNetwork_not_in_facilities_all() - test_deprecated_helpers_forward_with_warning() test_create_all_facilities_constructs_hensmith_network() From 18154d7ff1bfca3c35c49c7cfccadbdeb835f0d4 Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 01:52:48 +0800 Subject: [PATCH 18/26] update submodule --- thermosteam | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/thermosteam b/thermosteam index f768d381..cb5d7bc4 160000 --- a/thermosteam +++ b/thermosteam @@ -1 +1 @@ -Subproject commit f768d38117a1444e46d2107f58d995efe4fd90fb +Subproject commit cb5d7bc45b20edaf0d0c8fcac9d2ae968095c571 From 2df79652356a1759389e5cd0f7d298a9163c023e Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 01:55:28 +0800 Subject: [PATCH 19/26] update Phi thermosteam --- biosteam/units/stage.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/biosteam/units/stage.py b/biosteam/units/stage.py index 197f0cdc..080b4a60 100644 --- a/biosteam/units/stage.py +++ b/biosteam/units/stage.py @@ -3213,7 +3213,7 @@ def hot_start(self): else: use_cache = True self._gamma = self._eq_thermo.Gamma(self._eq_thermo.chemicals) - self._phi = self._eq_thermo.Phi(self._eq_thermo.chemicals) + self._phi = self._eq_thermo.Phi(self._eq_thermo.chemicals, 'g') self._H_magnitude = 100 * sum([i.mixture.Cn('l', i.mol, i.T, i.P) for i in self.ins]) self.attempt = 0 self._mean_residual = inf From bb57bce09cd86df8d34c063ed4e7a09fe409d289 Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 13:35:06 +0800 Subject: [PATCH 20/26] remove unused code --- biosteam/units/stage.py | 2 -- thermosteam | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/biosteam/units/stage.py b/biosteam/units/stage.py index 080b4a60..eecb6959 100644 --- a/biosteam/units/stage.py +++ b/biosteam/units/stage.py @@ -3212,8 +3212,6 @@ def hot_start(self): use_cache = False else: use_cache = True - self._gamma = self._eq_thermo.Gamma(self._eq_thermo.chemicals) - self._phi = self._eq_thermo.Phi(self._eq_thermo.chemicals, 'g') self._H_magnitude = 100 * sum([i.mixture.Cn('l', i.mol, i.T, i.P) for i in self.ins]) self.attempt = 0 self._mean_residual = inf diff --git a/thermosteam b/thermosteam index cb5d7bc4..8911fb2f 160000 --- a/thermosteam +++ b/thermosteam @@ -1 +1 @@ -Subproject commit cb5d7bc45b20edaf0d0c8fcac9d2ae968095c571 +Subproject commit 8911fb2fa271942412c98b3c50349f56cace03dc From ef43e03baa48e6adc84c681a77822e05e24d0a43 Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 13:42:53 +0800 Subject: [PATCH 21/26] update thermo doc --- docs/tutorial/Thermodynamics.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/tutorial/Thermodynamics.ipynb b/docs/tutorial/Thermodynamics.ipynb index 25e3594a..80eb5c7e 100644 --- a/docs/tutorial/Thermodynamics.ipynb +++ b/docs/tutorial/Thermodynamics.ipynb @@ -125,7 +125,7 @@ "Thermo(\n", " chemicals=CompiledChemicals([Methane, Ethane, Propane, n-Butane]),\n", " mixture=PR78Mixture(...),\n", - " Gamma=IdealActivityCoefficients,\n", + " Gamma=None,\n", " Phi=PR78FugacityCoefficients,\n", " PCF=MockPoyintingCorrectionFactors\n", ")\n" @@ -226,7 +226,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABrEAAAUhCAYAAAAswq9iAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAuIwAALiMBeKU/dgABAABJREFUeJzs3Xd8VFX+//H3nUkjvRN6UaQLUhQUJAgi1vUrZbEBa/utu67rirhWmqIooOtadu1dwM6iqAtKFRUERCkqLhBKID2kt5n7+2OSIZM6A0lmBl7PxyOP5Nycc8/nBowJ7znnGKZp5gkAAAAAAAAAAADwIRZvFwAAAAAAAAAAAADURIgFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ8T4O0CTnWlpaXatWuXZe/evZaDBw8a+fn5Rnl5uSIjI834+HizX79+9l69etkDAvzvj+rAgQPGhg0brPv27bMUFxcrMjJS3bt3t51//vm2iIgIb5cHAAAAAAAAAAB8mP8lIyeBJUuWBKxcuTJgw4YN1l9//dVSUVHRYP+oqChNnDix/I477ijr1auX3d15OnXqFL5//37jeOtcuXJl0ahRo2yejvvqq6+ss2fPDl67dq21rs8HBQVp/Pjx5Q899FBp165dzeOtDwAAAAAAAAAAnLwM0zTzvF3EqaZdu3bhqampHodLgYGBuvvuu8vmzJlTarE0vhNkS4dYdrtdd911V/CTTz4Z5E7/sLAwvfLKK8UTJ05sOMUDAAAAAAAAAACnHFZi+YiQkBB16NDBHhkZKbvdrqysLOPAgQOGaR5bqFReXq65c+cGHTx40HjttddKvFhunW677baQf/3rX4HVrxmGoXbt2pnx8fHmgQMHjKysLGeoVlhYqGuuuaaVxWIpHj9+PEEWAAAAAAAAAABwYiWWF7Rr1y7cNE1dfPHFFeeff77t3HPPrejatatptbruvpedna0lS5YEzp07N/jQoUMuK6peeOGFkptvvrm8oXmqr8RKTEw033jjjWJP6hw8eLAtNjbWrb6LFi0KuOaaa1pVv3bllVdWzJs3r7R79+7OLRD/+9//WqdNmxayfft251KyiIgI/fDDDwVsLQgAAAAAAAAAAKoQYnnBDz/8YDnzzDPt7mwJKDnCrFGjRoX98MMPzgFJSUnmwYMHC2oGX9VVD7E6duxopqSkFJxo7XUpLS1V9+7dw1NSUpxB280331z+73//u6SuZ8zNzdWoUaPCtmzZ4vzktddeW/7WW2/53OoyAAAAAAAAAADgHe6lKGhS/fv3dzvAkqTY2Fi99dZbxYZxbDHWkSNHjHXr1tWfYLWgF154IbB6gHX66afbn3rqqToDLEmKjo7W66+/XhwUdOzorMWLFwfu3LmTv48AAAAAAAAAAEASIZbf6N27t/2ss86yV7/mK6HPK6+8ElS9fffdd5e1atWqvu6SpD59+tjHjx/v3A7RZrPp5ZdfDmxoDAAAAAAAAAAAOHX4RAgC93Tt2tUlxMrMzDTq69tS9u/fb1Tf5jA8PFxXX311g2d1Vbnxxhtd+i1btiygqesDAAAAAAAAAAD+iRDLj5SUuB4ZFR0dbXqpFKeawdOQIUNs4eHhbo0dPny4LTQ01NnevXu35ZdffuHvJAAAAAAAAAAAIMTyF3a7XZs3b3Y5A2vQoEH2+vq3lG3btrnUNHTo0Ap3xwYGBmrQoEG26te2bt3K30kAAAAAAAAAACC2b/MTL774YuDhw4ed2weeccYZ9iFDhtgaGlOXjIwMY//+/UZeXp4RGRlpxsfHmx06dDAtluPLjn7++WeXgb179/YoWOvZs6d97dq1ziDMV875AgAAAAAAAAAA3kWI5QdeeeWVwNtvvz2kqm2xWPT000+XeBI8ZWRkGD169Aira7u+mJgY87zzzrNdc8015RMmTKgICHD/r8Wvv/7qcr8OHTp4tMVh+/btXUKvX3/91VpfXwAAAAAAAAAAcOogxPIBP//8syUlJcW5yqq8vFw5OTnGTz/9ZF22bFlA9dVOQUFB+te//lUyZswYj1ZhFRcXq77zpnJycoxPPvkk4JNPPgl44IEHzBdffLH4ggsucOv+mZmZRvV2hw4dPFqJ1b59e5fQKz093aivr6eOHDliZGRkNHq/n3/+Wf/617+Cq9o9evRw+1yvsLAwMzIy8gSqBAAAAAAAAADg+OXn56ugoKDJ/m29uoKCAv3888/W4OBgMzg4WDNmzCgZMGBAc0xVJ0IsH/Dss88GPvPMM0EN9TEMQxdeeGHFo48+WjpgwIBmOwtrz549xpgxY0Ife+yx0mnTppU11LeoqEg2m2vWFR4e7tFKrLCwMJf+hYWFngxv0DPPPBM0d+7cBr+udVm1ahX/XQAAAAAAAAAAUIePP/64pKXm4h/r/cRVV11Vcfvtt5d5GmBFRkbqwgsvrBgzZkxF//79baeddpo9MjJSRUVFOnTokGX9+vXW119/PXDDhg3ObfxsNpumT58enJSUZL/22msr6rt3fn5+rWQ3JCSkrq71atWqlUuI1VxpMQAAAAAAAAAA8C/uH6oEr/rggw8CRowYETps2LDQX3/91a2g57HHHis5ePBg/vvvv198yy23lJ999tn2uLg4BQYGKioqSr169bLfcsst5V9//XXRe++9VxwdHe0ca5qmbrnlllapqan1zlVSUjtsDQrybOFTcHCwS7ukpIQQCwAAAAAAAAAAyDBNM8/bRcBVUVGRMjMzjR9++MH60UcfBSxZsiSwuLjY+fno6Gh9/vnnheecc06Tbiv49ddfWy+88MLQ6nPdeuut5c8991ydSwPT0tKMpKQkl8OjioqK8lu1auX2nJ988on18ssvD61q9+zZ075z584m2VPQ3TOx5s6dG7hkyRJn+jZ06FAlJye7NUd4eLgiIiKOv0gA8BOHDx/Wo48+6mzfe++9atOmjRcrAgDfw/dKAGgY3ycBoHF8r8TxqDwTq1nu/f3332vFihXO9qxZs0pmzpxZ3iyT1YEQyw/8+uuvxoQJE0J//PFH58q5tm3bmtu3by+IiYlp0rkeeOCB4OrnSMXExJgZGRkFVqu1Vt+ioiKFhYW5JDjZ2dn5ntT03nvvBUycONGZeg0ePNi2cePGouOr/vjcfffdQfPnz3cuCbv33nv1yCOPtGQJAODzduzYoT59+jjb27dvV+/evb1YEQD4Hr5XAkDD+D4JAI3jeyV8zdNPP63bb7/d2X7iiSdK/va3v7VYiMV2gn7gjDPOMFeuXFnUvn175/lRqampxrx584IbGnc87rzzztLqgVVOTo6xcePGOv+ehIaGqma45emZVoWFhS79w8LCPBkOAAAAAAAAAABOUoRYfiIhIcGcMWNGafVrb775ZmBTzxMbG6v+/fu7bFP4yy+/1F6GVSk+Pt6s3j5w4IBHf6cOHjzoEmIlJiaa9fUFAAAAAAAAAACnDkIsPzJ+/PhywziW+Rw+fNjYu3evRyuf3NG+fXuXECs9Pb3eOc444wyXvvv37/eonpqhV/fu3W2ejAcAAAAAAAAAACcnQiw/EhMTo5iYGJeVSocPH27yP8PAQNcFXuXl9W9v2b17d5cQa8eOHR7V8/PPP7v079mzp72+vgAAAAAAAAAA4NRBiOXnAgMDm3z7vbS0NJfVVAkJCfXO0a9fP5eVU998802Au/OUl5fr+++/d9mq8KyzziLEAgAAAAAAAAAAhFj+JC8vTzk5OS4BU1JSUpOGWCUlJdq8ebNLsNSxY8d6g6XLL7+8onr7u+++sxYUFLg117p166xFRUXOdrdu3ew9evQgxAIAAAAAAAAAAIRY/mTZsmUBpnkss4qPjzfbtm3bpCHWO++8E1g9WAoODtbw4cPrPaeqU6dOZr9+/ZzBU0FBgRYtWhRYX//qXn75ZZd+l112WUV9fQEAAAAAAAAAwKmFEMtPFBUVafbs2cHVr11yySUVVqu1viEeS01NNR588EGXOUaNGlURFhbW4Lg//OEPZdXb8+fPDyouLm5wzI4dOyzvv/++M8SyWCy64YYb6j98CwAAAAAAAAAAnFIIsVrYnXfeGfztt9969HXPysrSZZddFrp7927nOKvVqjvvvLOsrv6HDh0y7r///uDs7Gy359izZ48xduzY0NTUVOd2hYZhaNasWaWNjf3jH/9Y3qFDB+eKsN27d1v++te/htjtde8MePToUU2ePLlVWdmx8n//+9+X9+nTh60EAQAAAAAAAACAJEKsFrdy5cqAoUOHhg0ePDj08ccfD9q8ebOlephTxW63a+fOnZaZM2cGde/ePXzVqlUuS67+8pe/lFXfxq+60tJSPfLII0GdOnWKmDRpUqv33nsv4ODBg0ZdfX/99VfjnnvuCR4wYED4Tz/95PL34bbbbisbPHhwo8FScHCwHnnkkZLq11588cXA8ePHt/rll19c7rlixQrrsGHDwrZs2eK8Hh4eroceeqjRsAwAAAAAAAAAAJw6ArxdwKnq+++/t37//fdWScFBQUFq27atGRUVZQYFBZn5+fnGoUOHLPn5+XWOve6668oXLFjQaOhTUFCgJUuWBCxZsiRAkmJjY82EhAQzMjLSLC4uNo4cOWJkZmbWGW5dddVVFU8++aTbwdJ1111XsW7duvIXXnjBuUXgRx99FPDxxx8HtG/f3oyPjzf3799vZGVlucxnsVj00ksvFZ922mlNerYXAAAAAAAAAADwb4RYPqCsrEz79u0zJNUZKFWJjIzUww8/XPLnP/+53GLxfBFddna2kZ2d3eAcwcHBmjNnTuldd91V5ukczz33XElISIj5z3/+M6jqmmmaOnDggHHgwIFa84aGhuqll14q/v3vf1/h0UQAAAAAAAAAAOCkx3aCLWzRokXFc+fOLR05cqQtMjKy0f6GYahPnz72Rx99tPTXX38t+Mtf/tJogJWUlGQuXLiw9PLLL69ITEx0a4VTx44dzXvuuafst99+K7j77rs9DrAkxzldTz31VOmKFSuKzjvvPFt9/YKCgjRp0qTyH3/8seDqq68mwAIAAAAAAAAAALWwEquF9e7d2967d++y++67r8xms+nXX3+17N6925KSkmLk5eUZ5eXlioiIUFRUlNmlSxf7oEGDbFFRUR7NERoaqjvvvLPszjvvlCQdOnTI+Pnnny379++3ZGRkGEVFRQoKClJMTIzZunVr8+yzz7a1b9++ybbzGz16tG306NFF+/fvN77++mtrSkqKpaSkRBERETrjjDPs559/foWnzwQAAAAAAAAAAE4thFheZLVa1bNnT3vPnj3tzTlPu3btzHbt2tkk1bs6qjl07NjR7NixIyut6mGapux2u0yT48AA+L6Kiopa7ZrXWoJhGLJYLDKMBnfHBQAAAAAAwEmAEAtoIaZpqqioSHl5eSooKPDKP/4CwPFKSUmp1Q4KCqqnd/MyDEOBgYGKiopSVFSUAgMDvVIHAAAAAAAAmhchFtDMTNNUenq6jh49KputRRfDAcBJyTRNlZWVKSMjQxkZGQoLC1Pr1q0VHBzs7dIAAAAAAADQhCzeLgA4mZmmqdTUVGVnZxNgAUAzKSws1P79+1VeXu7tUgAAAAAAANCECLGAZlIVYOXl5Xm7FAA46VVUVOjAgQO8YAAAAAAAAOAkwnaCQDNJT0+vM8AKCQlRRESEwsLCFBAQIMMwvFAdAHimrKzMpd2pUyd169atxeuw2+0qLy9XXl6e8vLyZLfbnZ8rLS3V4cOH1b59+xavCwAAAAAAAE2PEAtoBqZp6ujRoy7XDMNQ+/btFR4e7qWqAOD4BQQE1GrXvNZSgoKCFBYWpoSEBKWkpLgEbPn5+bLZbLJarV6pDQAAAAAAAE2HEAunvPDwcLNG+4TvWVRUVGtLKwIsAP4sISFBM2fOdGl7W0BAgDp06KA9e/bINI99Ky8sLFRkZKQXKwNwqvLF75UA4Ev4PgkAjeN7JeCKEAunvIiIiAbbx6PmNoIhISEEWAD8WmJiombNmuXtMmoJCgpSaGioCgsLndcKCgoIsQB4ha9+rwQAX8H3SQBoHN8rAVcWbxcAnIwKCgpc2k0RjAEA6lbzRQI1vwcDAAAAAADAPxFiAU3MNE1VVFS4XAsLC/NSNQBw8gsNDXVp22w2l+0FAQAAAAAA4J8IsYAmZrfba10LCGDnTgBoLlartda1ur4XAwAAAAAAwL8QYgFNrK5X/xuG4YVKAODUUNf3WFZiAQAAAAAA+D9CLAAAAAAAAAAAAPgcQiwAAAAAAAAAAAD4HEIsAAAAAAAAAAAA+BxCLAAAAAAAAAAAAPgcQiwAAAAAAAAAAAD4HEIsAAAAAAAAAAAA+BxCLAAAAAAAAAAAAPgcQiwAAAAAAAAAAAD4nABvFwAAaHolJSXatm2b9uzZoyNHjqioqEiBgYGKjo5WdHS0evTooZ49eyowMNDbpQIAAAAAAABAnQixAMDLOnfurJSUFGd71apVSk5O9vg+hYWFeuutt7RkyRKtX79e5eXlDfYPDg5W//79NW7cOE2cOFGdOnXyeE4AAAAAAAAAaC5sJwgAfs5ms+npp59Wx44d9cc//lGrVq1qNMCSpNLSUn333Xe6++671blzZ1166aXasmVLC1QMAAAAAAAAAI0jxAIAP3bkyBGNGjVKt99+u7Kzs2t9PiAgQElJSerTp48GDRqkjh07Kjg4uM57LV++XIMGDdIbb7zR3GUDAAAAAAAAQKPYThAA/NSBAwc0cuRI/e9//3O5Hh4erptvvlljx47V8OHD1apVq1pjf/75Zy1fvlzLli3T6tWrnddN01R6enpzlw4AAAAAAAAAjWIlFgD4obKyMo0bN65WgHXLLbdoz549euKJJzRmzJg6AyxJ6tGjh+68806tWrVKGzdu1CWXXNISZQMAAAAAAACA2wixAMAPTZs2TZs2bXK2DcPQk08+qeeff14JCQke3Wvw4MH69NNPtXTpUsXGxjZ1qQAAAAAAAABwXNhOEAD8zJYtW/TMM8+4XJs2bZruuOOOE7rvFVdcoa1bt2r37t0ndB8AAAAAAAAAaAqEWADgZx5//HGXdvfu3fXQQw81yb07duyojh07Nsm9/FF5ebl++eUX7dy5U0eOHFF+fr7CwsIUGxurHj16aMCAAQoIaPr/dW7fvl3ff/+9jhw5osDAQLVr105DhgxR586dm+T+v/zyi7Zu3ar09HQVFhYqPj5ebdu21bBhwxQVFdUkc1S3fft27dq1S4cPH1ZBQYFat26tyZMnKzAwsMnnAgAAAAAAwMmLEAsA/EhKSoref/99l2vTpk1TSEiIlypqegsWLND06dOd7QceeOC4Qro//OEPeu2115zt9957T+PHj6/VLzMzU++++64++eQTrVu3TgUFBfXeMywsTJMmTdI999yj008/3e1aDMNwfjxixAitXr1akvThhx/qwQcf1M6dO+scc+6552r+/PkaOnSo23NVKS0t1dNPP61///vftc5OqxIQEKARI0Zo1qxZGjZsmFv3Xb16tUaOHOlsz5w5U7NmzVJFRYX+9a9/6fnnn9eOHTtqjRs3bpyio6M9fg4AAAAAAACcujgTCwD8yCeffCKbzeZsh4eH6+qrr/ZiRU3v2muvldVqdbbfeustmabp0T0KCwtdwr6YmBhdfvnltfrl5OSoTZs2+vOf/6zPPvuswQCr6r4vv/yy+vTp4xKQeco0Tf3lL3/RuHHj6gywqvp8/fXXGjZsmMch3o4dO9SrVy9Nnz693gBLkioqKvTll19q+PDhuuGGG1ReXu7RPFVycnI0cuRI3X777XUGWAAAAAAAAMDxIMQCAD+ybt06l/b555+v8PBwL1XTPNq0aaMxY8Y42/v27dPatWs9useHH37oEkhNmjRJwcHBtfrZbDZVVFS4XLNarerSpYv69++vc845Rz169Kg1trS0VH/4wx/0xhtveFRXlYcfftjlXLPQ0FD17t1b/fv3r7VayW63a8aMGZo3b55b9/7+++81fPhw7dmzx+V6YGCgunXrpkGDBqlt27a1xr366qu64oorVFZW5tGzVFRU6IorrtD69eud12JiYnTmmWfqzDPPbJbtCgEAAAAAAHBqIMQCAD9SM8QaNGiQlyppXlOmTHFpexoW1exf8341DRo0SI888og2b96swsJC7dmzR1u3btW3336rXbt2qaCgQCtXrtRFF13kMu7Pf/6zDhw44FFtv/32m+bMmSNJat26td544w1lZWVp+/bt2rp1qzIzM/X555+rZ8+eLuPuv/9+ffPNNw3eOz8/XxMmTFBOTo7zWmhoqB5//HEdOXJEv/76qzZt2qRDhw5p27ZtuvLKK13Gf/7555oxY4ZHz/PSSy85A6zRo0fr66+/VmZmprZt26Zt27YpJydHK1asUKtWrTy6LwAAAAAAAMCZWICPMW02mUfzvF3GSc+IipRRbcs6f1BYWKjU1FSXa/369fNSNc3rd7/7naKionT06FFJjvOsnnnmGbeCkIMHD+qrr75ytrt3765zzjmnzr5hYWH65ptvNGTIkAbvGRAQoFGjRmnUqFF66KGHnEFPQUGBnnnmGT322GPuPpoOHTokSerUqZO+/vprtWvXzuXzVqtVF110kb7//nuNGTNGX3/9tSTHiqxbbrlFP/74o8sZW9Xdd9992rdvn7MdFRWlVatW6ayzzqrV98wzz9RHH32kBx54QHPnznVenz9/viZOnKgBAwa49TxpaWmSpDvuuENPPvlkrc8bhqHRo0e7dS8AAAAAAACgOkIswMeYR/NU8PhT3i7jpBd+919lxMZ4uwyPZGdn17qWkJDghUqaX0hIiH7/+9/rhRdekORYYfTRRx/pmmuuaXTsW2+9Jbvd7mw3tAqrVatWjQZYNT344INasWKFc1Xca6+95lGIJTmCnffee69WgFVdaGioPvzwQ51xxhnOMG/79u1asWKFy3aLVXJzc/XKK6+4XHv55ZfrDLCqe/jhh7VlyxZ99tlnkhxh2ZNPPqk333zT7ec599xz9cQTT7jdHwAAAAAAAHAH2wkCgJ+oK8Ty5Lyh3bt3a+XKlW69Vd+OzluOd0vB6v0sFouuv/76Jq1Lkq699lrnx+np6frtt988Gj9+/HgNHjy40X6JiYmaNm2ay7WaQVWVd955R0VFRc72eeedp3HjxrlVT80A6t1333UGZ+6YM2dOvavDAAAAAAAAgOPFSiwA8BP5+fm1roWFhbk9/vnnn9fChQvd6rtq1SolJye7fe/mcO6556pbt27avXu3JGnlypU6fPiw2rRpU++YTZs2adeuXc72BRdcoPbt2zd5bV26dHFpb926Vaeffrrb4ydPnuxR35kzZ8o0TUnSmjVr6uxX8/oNN9zg9hw9evTQueeeqw0bNkiSysrK9O2339Y6A6wurVu31gUXXOD2XAAAAAAAAIC7WIkFAH4iIiKi1rXCwkIvVNJyqq/Gstlseuuttxrs//rrr9c7vjHl5eVatmyZ/vKXv+j8889X+/btFRkZKYvFIsMwXN5qhjuZmZluz2MYhkaMGOF2/06dOqlz587O9pEjR7R///5a/b777juXtqfB0qhRo1za3377rVvjBg0axCosAAAAAAAANAtCLADwE7GxsbWuebLlmz+6/vrrXQKShrYULCsr0+LFi53tiIgIXXXVVY3OYZqmXn75ZbVv315XXHGFnnnmGa1bt06HDh1Sfn6+cwVUQ3JzcxvtU6Vjx451BpIN6dOnj0t77969Lm3TNHXgwAFnOzIy0iX4cke/fv1c2nUFZXWpuSoNAAAAAAAAaCqEWADgJ+oKsbKystwev2DBApmmWedbp06dmrLUJtOxY0eNHDnS2d6+fbu2bNlSZ99PP/3U5esxfvx4hYaGNnh/u92uyZMn66abblJ6evpx11laWup237i4OI/vX3NMzdDs6NGjstvtJzRHfHy8S9vdc9EiIyM9ngsAAAAAAABwB2diAT7GiIpU+N1/9XYZJz0jyv/+4T0sLExt27ZVamqq89oPP/ygK6+80ntFtYApU6boq6++crbfeOMNDRgwoFa/mqu03NlK8KGHHqq1RWFkZKSSk5M1cOBAdejQQdHR0QoJCVFgYKCzz7Zt23TXXXd5+iiS1GiwVpeaZ58VFBQ02PbkrLT6xtR1Bltdqn9dAAAAAAAAgKZEiAX4GMNqlREb4+0y4KOGDx+uJUuWONvff/+9F6tpGePGjdOf//xnZ1CzaNEiLViwQAEBx/4XlpWVpU8//dTZ7ty5s84///wG75uWlqbHHnvM5dq9996r++67T+Hh4Q2Otdlsnj6GU1FRkcdjap59VrO+mu3jOSut5hhPtzwEAAAAAAAAmhrbCQKAHxk+fLhLe+3atccVWPiTsLAwjRs3ztlOT0/XZ5995tJn0aJFKi8vd7YnT57scpZWXZYuXari4mJn+5ZbbtEjjzzSaIAlSdnZ2e6WX0tmZqbHY2puGxkdHe3SjoqKksViqbf/8dQVE0OYDgAAAAAAAO8ixAIAP3LppZfKarU62/n5+Vq8eLEXK2oZNbcGrLl14Ouvv+7Snjx5cqP3/Pbbb13af/rTn9yuZ8eOHW73renAgQPKy8vzaMxPP/3k0u7SpYtL2zAMdejQwdnOy8vTvn37PJpj27ZtLm1fPScNAAAAAAAApw5CLADwI507d3ZZlSRJCxcuVGlpqZcqahnJyckuocqyZcuUk5MjSdq1a5fLtorDhg3Taaed1ug909LSXNrdu3d3u57qZ3R5yjRNrV271u3+KSkpLoFUUlKSOnbsWKvfkCFDTqjGmv1r3g8AAAAAAABoaYRYAOBnpk+f7tLetWuXZs6c6aVqWoZhGC6rq0pLS51ng9VchVVz1VZ9TNN0aZeVlbk17ocfftA333zjVt/61FxJ5knf+s76GjFihEv7tddec3uOX375RV9//bWzHRwcrHPOOcft8QAAAAAAAEBzIMQCAD8zaNCgWlvfzZ8/X88++6yXKmoZNbcIfOONN2S32/X22287r7Vq1UoTJ050635JSUku7fXr1zc6xmazebTtYH3ef/99bdq0qdF+6enpWrhwocu1G264oc6+V199tcLCwpztdevW6eOPP3arnmnTprm0J06cqKioKLfGAgAAAAAAAM2FEAsA/NATTzyhgQMHOtt2u1233XabbrvtNmVnZ3t0r9TUVBUWFno0ZtasWTIMw/mWnJzs0fjjcfrpp+u8885ztr/55hv9+9//1sGDB53XrrzySkVGRrp1v3PPPdel/eCDD6q4uLje/jabTTfccMMJr8KSHKvAJk6cqNTU1Hr7FBcX66qrrtLRo0ed13r16qUxY8bU2T86OrpWwHXDDTfoxx9/bLCWmTNn6tNPP3W2LRaL/va3v7nzGAAAAAAAAECzIsQCAD8UHBysDz74QF26dHG5/uyzz6pLly6aPn26vvzyS5WUlNQ5Pjc3V8uXL9dNN92k0047TZmZmS1R9gmruVVgzRVE7m4lKEn/93//p4iICGd7y5YtGjlypL777juXfhUVFfriiy90zjnnOLf269mzp6elO7Vr104BAQHat2+fBgwYoLfeesvlz8lut+uLL77QoEGDXLb4MwxDL7zwggzDqPfec+fOVefOnZ3tnJwcnXvuuVq4cKHzDLEq27dv17hx4zRnzhyX69OnT9dZZ5113M8HAAAAAAAANBVCLADwU506ddL69etdVidJUl5enhYsWKDRo0crMjJS7dq1U79+/TR06FD17dtXbdq0UUxMjC699FK9/PLLLgGKYRiaOnWq+vfv38JP456JEycqJCTE2a5ee9u2bTV69Gi37xUXF6cHH3zQ5dp3332nIUOGKCkpSWeffbbOPPNMxcXFaezYsdq8ebMkqUePHpo3b95xP8Ppp5/uPMMsLS1N119/veLj49W3b18NGDBA8fHxGjt2rHbu3Okybs6cObX+rGuKiIjQe++9p5iYGOe1wsJC3XXXXWrdurW6d++uwYMHq3379urbt68+/PBDl/Fjx46tFWoBAAAAAAAA3kKIBQB+rG3btlq9erWeeOIJl+CiSnl5uVJTU/Xjjz/q22+/1fbt23XkyJFa/SwWi8aOHauNGzfq1VdfVXR0dIPz1lzhVdfczSEqKkpXXnllnZ+77rrrZLVaPbrf9OnT9f/+3/+rdT0tLU2bNm3STz/9pLy8POf1vn37asWKFW5vWVifBx54QLfffruzXVhYqO3bt2vr1q21VkxZLBbNnDlTDzzwgFv3HjRokNauXauuXbu6XC8vL9evv/6q77//XocOHao1burUqfrPf/6joKCg43giAAAAAAAAoOkRYgGAnwsICNDf/vY3HThwQM8995xGjBihgICARseFhIRoyJAhevjhh5WSkqLPPvtMgwYNcmvODRs2uLRb8gyl+rYMnDx58nHd79///rfeeOONWqFPdYmJiXrooYe0adMmtW/f/rjmqempp57SBx980ODWhOeee67WrVunWbNmeXTvPn36aOfOnZo/f36DzxUQEKBRo0Zp3bp1evXVVxUYGOjRPAAAAAAAAEBzavxfOQEAzWrfvn1Ncp+wsDDdeuutuvXWW1VcXKwffvhBe/bsUVpamoqKihQUFKSYmBjFxMSoa9eu6tu373GFFkVFRS7nRo0aNUrnn39+kzyDO8aOHSvTNJv0ntdff72uu+46/fDDD9q8ebMyMzNlmqYSExPVp08fDRo0yGWVV3JycpPUcNVVV+mqq67STz/9pO+//15HjhxRUFCQ2rRpo6FDh9Y688wTwcHBuuuuu3TXXXfp559/1tatW5Wenq6ioiLFxcWpXbt2GjZsmKKiojy6b1M9OwAAAAAAANAYQiwAOAm1atVKQ4cO1dChQ5v83uvXr1dZWZmzfbKcoWQYhs466yydddZZLT5337591bdv32a7f48ePdSjR49muz8AAAAAAADQHNhOEADgka+++sr58UUXXaRzzz3Xi9UAAAAAAAAAOFkRYgEAPFI9xDpZVmEBAAAAAAAA8D2EWAAAt+Xl5WnLli2SpEsvvVRnn322lysCAAAAAAAAcLLiTCwAgNsiIyNVUVHh7TIAAAAAAAAAnAJYiQUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ/DmVgAADQz0zS9XQIAAAAAAADgd1iJBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAAAAAAAAAAAAn0OIBQAAAAAAAAAAAJ9DiAUAAAAAAAAAAACfQ4gFAPBZhmE435KTkxvsO2vWLJf+q1evbpEafcXq1atdnn/WrFnNNldycrLLXAAAAAAAAEBzCPB2AQCApldSUqJt27Zpz549OnLkiIqKihQYGKjo6GhFR0erR48e6tmzpwIDA71dKgAAAAAAAADUiRALALysc+fOSklJcbZXrVrV6KqjuhQWFuqtt97SkiVLtH79epWXlzfYPzg4WP3799e4ceM0ceJEderUyeM5AQAAAAAAAKC5sJ0gAPg5m82mp59+Wh07dtQf//hHrVq1qtEAS5JKS0v13Xff6e6771bnzp116aWXasuWLS1QMQAAAAAAAAA0jhALAPzYkSNHNGrUKN1+++3Kzs6u9fmAgAAlJSWpT58+GjRokDp27Kjg4OA677V8+XINGjRIb7zxRnOXDQAAAAAAAACNYjtBAPBTBw4c0MiRI/W///3P5Xp4eLhuvvlmjR07VsOHD1erVq1qjf3555+1fPlyLVu2TKtXr3ZeN01T6enpzV16s5g1a5ZmzZrl7TK8Jjk5WaZpersMAAAAAAAAoMmwEgsA/FBZWZnGjRtXK8C65ZZbtGfPHj3xxBMaM2ZMnQGWJPXo0UN33nmnVq1apY0bN+qSSy5pibIBAAAAAAAAwG2EWADgh6ZNm6ZNmzY524Zh6Mknn9Tzzz+vhIQEj+41ePBgffrpp1q6dKliY2ObulQAAAAAAAAAOC5sJwgAfmbLli165plnXK5NmzZNd9xxxwnd94orrtDWrVu1e/fuE7oPAAAAAAAAADQFQiwA8DOPP/64S7t79+566KGHmuTeHTt2VMeOHZvkXv7o+++/144dO3T48GEFBASoU6dOOvfcc9WuXTtvl9Yi9u7dq++++06HDh1SeXm5kpKSNGjQIPXp08fbpQEAAAAAAOAUxHaCAOBHUlJS9P7777tcmzZtmkJCQrxUke+YNWuWDMNwvq1evdrtsa+++qpOP/10DR48WFOnTtW9996r6dOna+LEierQoYMuuugi/fjjj87+1edJTk5u8N6e9K1p6tSpLuP37dtXb9/Vq1e79J01a5bb83zzzTc677zz1LVrV1199dW66667dO+99+oPf/iD+vbtqz59+ujDDz/0qHYAAAAAAADgRBFiAYAf+eSTT2Sz2Zzt8PBwXX311V6syL+VlJTo8ssv1w033KD//e9/dfYxTVP//e9/NXjwYC1atKiFK2x+c+bM0bBhw7Rhw4Z6++zYsUPjxo3T7bffLtM0W7A6AAAAAAAAnMrYThAA/Mi6detc2ueff77Cw8O9VI1/q6io0Lhx47R8+fJan2vfvr2SkpKUk5OjvXv3ym63q6ysTJMnT1abNm28UG3zeOSRRzRz5sxa12NjY9WpUyeVlpZq7969Ki4uliQ9/fTTSkxMbOkyAQAAAAAAcIpiJRYA+JGaIdagQYO8VIn/W7BgQa0Aa9KkSdq1a5cOHDigTZs26bffftOhQ4d03333KSAgQBUVFfrDH/7gpYqb1oYNG/TAAw+4XBswYIBWrVqlzMxMbdmyRTt27FBmZqZefvllxcXFSZJmz56t3377zRslAwAAAAAA4BTDSizAx9hMU9mlZd4u46QXGxwkq2F4uwyPFBYWKjU11eVav379vFSNf0tJSdHs2bNdrj388MO6//77a/VNSkrS3LlzNWzYMP3ud79r8Fwqf2G323XLLbe4bA14ySWX6OOPP1ZgYKBL39DQUN1www0aNWqUzjvvPB06dEiHDh1q6ZIBAAAAAABwCiLEAnxMdmmZpm/c5e0yTnrzz+6phJBgb5fhkezs7FrXEhISvFCJ//v3v/+tkpISZ/uyyy6rM8Cq7uKLL9bMmTNrrV7yRytWrNCOHTuc7TZt2mjx4sW1AqzqOnXqpMWLF2v48OEtUSIAAAAAAABAiAUA/qKuECsqKsrt8bt371ZKSopbfQcOHKiYmBi37+1PTNPUa6+95nLtsccec2vsXXfdpWeeeUZHjhxphspaziuvvOLSfuCBBxQREdHouGHDhunKK6/Uxx9/3EyVAQAAAAAAAMcQYgGAn8jPz691LSwszO3xzz//vBYuXOhW31WrVik5Odnte/uTn3/+2SWEGjhwoHr16uXW2ODgYE2aNEn/+Mc/mqm6lrF69Wrnx4GBgZo0aZLbY6dOnUqIBQAAAAAAgBZh8XYBAAD31LVSprCw0AuV+LeNGze6tD0N6/w93EtJSVF6erqzfeaZZyo2Ntbt8SNGjGiOsgAAAAAAAIBaCLEAwE/UFTQcPXrUC5X4t71797q0+/Tp49H4vn37NmU5Le5Enz86OlodOnRoypIAAAAAAACAOhFiAYCfqCvEysrKcnv8ggULZJpmnW+dOnVqylJ9Wm5urks7Li7Oo/Ge9vc1J/r8xzsGAAAAAAAA8BRnYgE+JjY4SPPP7untMk56scFB3i7BY2FhYWrbtq1SU1Od13744QddeeWV3ivKDxUUFLi0Q0NDPRrvyTlkvuhEn1/y/68BAAAAAAAA/AMhFuBjrIahhJBgb5cBHzV8+HAtWbLE2f7++++9WI1/qhnAFBUVeTTe388hO9Hnl/z/awAAAAAAAAD/wHaCAOBHhg8f7tJeu3YtgYKHoqOjXdqZmZkejfdkC8cTdTwBU2NO9Pmllv0aAAAAAAAA4NRFiAUAfuTSSy+V1Wp1tvPz87V48WIvVuR/unbt6tLevn27R+N//PFHj/qHhIQ4Py4uLvZobEZGhkf93XGiz5+bm6sDBw40ZUkAAAAAAABAnQixAMCPdO7cWePGjXO5tnDhQpWWlnqpIv8zePBgl/aaNWs8Gu9p/8jISOfHaWlpbo+z2+3asmWLR3O5o1OnTkpMTHS2f/rpJ2VnZ7s93tPnBwAAAAAAAI4XIRYA+Jnp06e7tHft2qWZM2d6qRr/07NnT7Vu3drZ3rx5s3bu3OnW2NLSUi1atMij+Tp16uT8eP/+/W4HRp999pny8vI8mstdI0aMcH5cXl7u0Wq+1157rRkqAgAAAAAAAGojxAIAPzNo0CD96U9/crk2f/58Pfvss16qyL8YhqGpU6e6XPv73//u1tgFCxZ4tJpKkgYMGOD82DRNvffee42OKS8vb9Zg8oYbbnBpP/zww8rPz2903Pr16/Xxxx83U1UAAAAAAACAK0IsAPBDTzzxhAYOHOhs2+123Xbbbbrttts82hpOklJTU1VYWOjRmFmzZskwDOdbcnKyR+O97Y9//KOCg4Od7U8++USPPPJIg2M+//xzzZ492+O5LrnkEpf2nDlzGjzrqqKiQrfccos2b97s8VzuGjNmjHr27OlsHz58WJMmTVJ5eXm9Y1JSUjRp0qRmqwkAAAAAAACoiRALAPxQcHCwPvjgA3Xp0sXl+rPPPqsuXbpo+vTp+vLLL1VSUlLn+NzcXC1fvlw33XSTTjvtNGVmZrZE2T6jc+fOevDBB12u3X///brmmmv0888/u1xPS0vTAw88oMsvv1zl5eXq3LmzR3NdcsklateunbOdmpqqESNGaPXq1TJN03m9oqJCK1as0LBhw5xb9tX8820qFotFzz//vAzDcF5bvny5hg4dWquuoqIivfrqqxo0aJAOHTqkgIAAl+cBAAAAAAAAmkuAtwsAAByfTp06af369Zo4caK+/vpr5/W8vDwtWLBACxYsUGBgoBISEhQfH6/Q0FAVFBQoMzNTR44cqfOehmFoypQp6t+/fws9hffcfffdWrdunb744gvntUWLFmnRokXq0KGDkpKSlJOTo71798pms0mSAgIC9Oqrr2rkyJFuzxMQEKCnnnpK48ePd17btWuXRo4cqcTERHXs2FGlpaXat2+fy5Z+99xzjw4fPqy9e/c2wdPWNnz4cM2ePVszZsxwXtu8ebNGjhypuLg4derUSaWlpdqzZ4+Ki4udfWbNmqUVK1bo0KFDzVIXAAAAAAAAUIWVWADgx9q2bavVq1friSeeUExMTK3Pl5eXKzU1VT/++KO+/fZbbd++vc4Ay2KxaOzYsdq4caNeffVVRUdHNzhvzRVedc3t6wIDA/XRRx/p4osvrvW5AwcOaNOmTfrtt9+cAVZQUJDefPPN49o6cdy4cZozZ06t6+np6fr+++/1008/uQRYd911V6PbGzaFBx98UDNmzHBZkSVJWVlZ2rJli3bs2OESYN1+++26//77m70uAAAAAAAAQCLEAgC/FxAQoL/97W86cOCAnnvuOY0YMUIBAY0vtA0JCdGQIUP08MMPKyUlRZ999pkGDRrk1pwbNmxwaf/tb387rtq9rVWrVlq+fLleeuklde3atd5+F154oTZt2nRCZ0I9+OCDWrZsmXr37l1vn379+mn58uWaP39+rWCpucyePVvr1q3T0KFD6+3Ts2dPffDBB3rqqadapCYAAAAAAABAkgzTNPO8XQTgTU8++WTgnXfeGVLV/uc//6m//OUvx32/iooK7d692+Vat27d3AoVgKZSXFysH374QXv27FFaWpqKiooUFBSkmJgYxcTEqGvXrurbt68CAwM9vndRUZFiYmJUVlYmSRo1apRWrlzZ1I/gFZs2bXKuVgsICFDHjh01bNiwWmdAVQ+Yqs638sSuXbu0ceNGpaenq6KiQm3atNHZZ5+tXr16NcVjHLc9e/bo22+/VWpqqsrLy5WUlKRBgwapb9++Xq2rMXzfBQAAAAAAaB5PP/20br/9dmf7iSeeKPnb3/5W3lLz8687AHASatWqlYYOHdrg6prjtX79emeAJanObfL81eDBgzV48OBmn6dnz57q2bNns8/jqa5duza4Ig0AAAAAAABoSWwnCADwyFdffeX8+KKLLtK5557rxWoAAAAAAAAAnKwIsQAAHqkeYp1Mq7AAAAAAAAAA+BZCLACA2/Ly8rRlyxZJ0qWXXqqzzz7byxUBAAAAAAAAOFlxJhYAwG2RkZGqqKjwdhkAAAAAAAAATgGsxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM/hTCwAADxkmqa3SwAAAAAAAABOeqzEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8J8HYBAHCq69y5s1JSUhrsY7FYFBUVpZiYGPXs2VODBw/WhAkT1KtXL7fmSE5O1po1axrsYxiGIiIiFBUVpa5du2rAgAEaO3asRo8eLYuF1zwAAAAAAAAAaFn8qyQA+AG73a6cnBzt2bNHn376qWbNmqXevXtr9OjR2r17d5PMYZqm8vLydODAAa1Zs0ZPPvmkLrroIp122mlaunRpk8wBAAAAAAAAAO4ixAIAP/bll1+qf//++uyzz5ptjn379unKK6/UPffc02xzAAAAAAAAAEBNbCcIAD5mwYIF6tevn8s1m82mrKwsbdmyRYsXL9ahQ4ecnysqKtKECRO0YcMGnXnmmW7NMX36dI0ZM8blmt1u19GjR7Vr1y4tXbpUW7Zscfn8Y489ptNOO00333zzcT4ZAAAAAAAAALiPEAsAfMzAgQOVnJxc5+euueYaPfLII7r77rv11FNPOa8XFhZq2rRpWrFihVtz9OrVS6NHj6738zNmzNDbb7+tG2+8UaWlpc7r999/v66++mqFh4e79zAAAAAAAAAAcJzYThAA/ExQUJD+8Y9/6Nprr3W5vnLlSm3fvr3J5rn22mv1xBNPuFzLyMjQxx9/3GRzAAAAAAAAAEB9CLEAwE/NmzdPFovrt/H//ve/TTrHLbfcorZt27pc+/LLL5t0DgAAAAAAAACoC9sJAoCfat++vfr166etW7c6r/30009NOkdAQICSk5P1zjvvOK/99ttvTTqHP0pPT9f27dv1v//9T7m5uaqoqFBsbKySkpJ0zjnnKCkpqcnnzM/P17p167R7924VFhYqISFBXbt21fnnn6/AwMATvn9RUZHWr1+vAwcOKCMjQyEhIUpMTFTv3r1rndHWFAoKCvT1118rNTVVR44cUUhIiEaMGKEBAwY0+VwAAAAAAADwT4RYAODHunbt6hJiZWZmNvkc7du3d2k3xxyeKisrU5s2bZSdnS1JCg0N1ZEjRxQREeHRffbt26euXbvKNE1JUu/evevcktE0Ta1fv17vvvuuVqxYoV9++aXB+/bt21fTpk3Ttddeq4AA9/5XO2vWLM2ePdvZXrVqlZKTk5WRkaH7779fb7zxhsv5ZFViY2P1//7f/9OMGTMUEhLi1lzVbdu2TTNnztQXX3yhkpKSOvu0a9dON9xwg+6++263z0NLTk7WmjVrnO2qr/HOnTv18MMPa+nSpSoqKnIZ89e//pUQCwAAAAAAAE5sJwgAfqzmCpyKioomn6MqfKhiGEaTz+GpoKAgTZo0ydkuKirS+++/7/F93njjDZfnmzJlSp39pk+frvPPP1/PPPNMowGW5FgRN3XqVI0cOVLp6eke11X9Pv369dOLL75YZ4AlSdnZ2Xr00UfVr18/7du3z+17m6apv//97xowYICWLl1ab4AlSYcOHdJDDz2kbt26af369Z4+htPbb7+ts846S4sWLaoVYAEAAAAAAAA1EWIBgB9LTU11acfFxTX5HAcPHnRpt27dusnnOB41A6c33njD43tUH2O1WnXdddfV2a+ugCcmJkY9e/bUOeeco/79+6tNmza1+qxfv14XXHCBiouLPa4tLS1NY8eO1eHDh53X2rdvr0GDBqlr1661zkP79ddfdcEFF9T6O1EX0zQ1depUPf7447Lb7S6fi4+P14ABA9SzZ89aK7uOHDmiMWPG6IsvvvD4eZYvX67JkyerrKxMkmSxWHTaaadp8ODB6tSpk6xWq8f3BAAAAAAAwMmNEAsA/FRRUZE2bdrkcq1Lly5NOkdFRYVWr17tcm3gwIFNOsfxOvvss9WjRw9ne82aNUpJSXF7/Ndff63//e9/zvaFF15YZxBVJSIiQn/4wx/0/vvvKzU1VdnZ2dq5c6e+/fZbbd26VampqTp48KDmzZun6Oho57gdO3bonnvu8ezhJP397393BlKTJk3Srl27dODAAW3atEn/+9//dODAAU2fPt0l/Nm7d69uvPHGRu/9zDPP1Ar9hg8frq+//lrp6enavHmzdu7cqYyMDL344ouKjY119isuLtY111zjVlhW3Q033CC73a6oqCgtXLhQaWlp+u2337Rx40bt27dPhw4d0jXXXOPRPQEAAAAAAHBy40wswMfZs3O8XUKDLLExbvWr7zmMiHAZNbbEq3N8fr5UfmJb5blbq794+umna63wueCCC5p0jueff95lJZAkTZw4sUnnOBFTpkzRvffeK8mxuujNN9/UAw884NbY119/vda96vOHP/xBjzzyiCIjIxu8Z7t27fT3v/9dkyZN0siRI7V3715J0osvvqiZM2e6hEGNqQrkHn74Yd1///21Pt+2bVs9/vjjGjJkiCZOnCibzSZJ+vzzz/Xee+9pwoQJdd734MGD+vvf/+5ybcqUKXr11VdrbRUZHh6um266SaNHj9awYcN06NAhSY4tDP/0pz/p448/dvt50tLSlJSUpFWrVrmEj1Vat27tM6v8AAAAAAAA4BsIsQAfV/D4U94uoUGR82a51a++5wi9eYoCTmt89VDxO+/Lttf9VTZ1cbdWf7Bs2TI9+OCDLte6dOmiYcOGNdkcb7/9tqZNm+Zy7dJLL9XZZ5/dZHOcqOuuu07333+/c0s8d0OskpISvffee852VFSUrrzyynr7e7r6rFOnTnrxxRc1evRoSY7VS4sXL9af/vQnj+5z2WWX1RlgVXfVVVdp+vTpmjdvnvPak08+WW+I9dxzz7mEn/369dNLL73U4FlnnTt31nvvvafzzjvPeYbYf/7zH+3evVvdunVz+3lee+21OgMsAAAAAAAA+Caz4sQWFpwoQiwA8AM2m005OTnavHmzXn/9dS1evNgZJlR5+OGHFejGqjZJ2rlzp1auXOlyzTRNHT16VLt27dLSpUu1efNml89369ZNr7766ok9SBNr3769Ro0apRUrVkhynAv17bffasiQIQ2OW7p0qXJzc53tiRMn1jr/6USNGjVKbdq0ca5k27Bhg8ch1mOPPeZWv/vvv1/PPfec8vLyJEnffPONdu3apZ49e7r0M01TL7/8ssu1BQsWKCCg8R8Hhg4dqt///vdavHix814vvfSS2zUOGzZMF110kVt9AQAAAAAA0DJMm03m0TzZs3OOveXkyp6dIzM7R6VrVnm1PkIsAPAxI0eO9HjMnXfe6dF5QvPnz9f8+fPd7j9p0iQ9++yzHm2H11KmTJniDLEkxzaBjYVYNc+DamgrwRPRuXNnZ4i1detWj8YOHDhQvXr1cqtveHi4xo0b5xIyrlmzplaI9fPPPys9Pd3Z7tixo0aNGuV2TTfccIMzxJKktWvXuj326quvdrsvAAAAAAAAmoZpmjILixyhVE5VUJVbGVblyMw9KtnNxm/kJYRYAODHwsLCNH/+fN16663Ndv/Fixfrsssua5b7N4WrrrpKkZGRzlVIS5Ys0VNPPaWgoKA6+6elpemLL75wtk8//XSdd955bs+3b98+vfvuu9q0aZO2b9+uzMxM5eXlqaysrMFxmZmZbs8hScnJyR73rx5ibdy4UX/84x9d+nz33Xcu7ZEjRza4jWBN559/vgICAlRRuYx869atKisrq/drXZ0vbUMJAAAAAABwMjHLypyrpxwrqI6FVPbsHKms3NslHjdCLADwMyEhITrrrLN01VVXaerUqYqPj2+2uQoLCzV+/Hi99NJLuu6665ptnhPRqlUrTZgwwblNXk5OjpYtW6Zx48bV2f/tt9+WzWZztidPnuzWPCkpKfrrX/+q//znP7W2cnRH9e0L3dGnT58T6r93795afVJSXM+VO/PMMz2aIzg4WD169ND27dslSaWlpUpLS1OHDh0aHdulS+Nn3wEAAAAAAKA202533fKv2nZ/9uwcmQWF3i6x2RBiAYCPWbBggfr16+dyzWq1KiIiQtHR0ercubNbZxg15NVXX9XUqVNdrhUVFWn//v368ssvtXDhQmcIUlpaqilTpigyMlJXXHHFCc3bXKZMmeJy1tPrr79eb4j1+uuvOz82DEPXX399o/ffuHGjxowZo6NHjx53jY2t1KopLi7uhPrXFZrl5OS4tI8nAK05Jicnx60QKzIy0uO5AAAAAAAATgWmacosKq5zuz97duWWfza7t8v0CkIswMeF3/1Xb5fQJOp7DiMi3K3xra4ZL5VXNGVJPmvgwIEebyXXFEJDQ9WjRw/16NFDU6dO1ZVXXqmVK1dKkux2u6ZMmaIdO3aobdu2LV5bY4YNG6auXbtqz549kqTPP/9cGRkZSkhIcOm3bds2/fjjj872iBEj1Llz5wbvnZWVpUsuuaRWgHXmmWdq+PDhOv3009W2bVu1atVKISEhLtvzTZs2zWU+T4SGhnrUPywszKVdUFBQq0/NazXHHM88+fn5bo0LDAz0eC4AAAAAAICThVlefmwFVU6u7FnHQip7dq5UWurtEn0SIRbg4yyxMd4uoUmc6HNYIiKaqBK4IywsTB988IEGDhyo3377TZJjZc9f//pXvffee16urjbDMDR58mTNmjVLklReXq5Fixbp9ttvd+lXfRWW5FjB1Zi5c+cqKyvL2e7WrZveeustt8548jSIqq6oqMij/oWFrsvGw8NrB8Q1r9UcczzzRPDfJgAAAAAAgGPLv/z8Y6uoqrb7qwqu8tx7IbA3GWGhMmJjZImNkSUmWpbYGAUGmdKXn3utJkIsAECdIiMj9fzzz2vUqFHOa++//742bNigc88914uV1W3y5MmaPXu287yq119/3SXEqqio0DvvvONsh4WFafz48Y3ed8mSJc6PQ0JC9Pnnn6tr165u1ZSdne1u+bVkZmZ61L960CZJ0dHRtfrExLiGyTXHHE9dNe8JAAAAAABwsjKLi2tt9WfPznWGVap2DrtPCgyQJaYypIqNdgRWMTGyxDlCKyM4uNYQ63cbvFDoMYRYAIB6XXDBBbrsssv0ySefOK89+OCD+vLLL71YVd26dOmi4cOHa+3atZKkLVu2aMeOHerdu7ck6YsvvlBaWpqz/1VXXVXnaqXq9u/fr9TUVGd77NixbgdYxcXFznPFjsf27ds96v/TTz+5tLt06VKrT6dOnVza27Zt82iO0tJS/fLLL852cHCwWrdu7dE9AAAAAAAAfJVZUSF7Tq5ju7/K1VT2ah+ruMTbJTbMMGRERbqspLLExlSuroqWER7uchSGPyDEAgA06KGHHnIJsb766iufXY01ZcoUZ4glSW+88YYee+wx58c1+zameuglSd27d3e7lnXr1qm8vNzt/jWtWbPmhPrXtd3hkCFDXNqrV6+WaZpu//BS85kGDBigoKAgj+oEAAAAAADwFtM0ZeYXOFdSmVmuQZWZlyeZ3q6yYUZoq8oVVMdCqqrQyoiOkhFwcsU+J9fTAACaXP/+/XX55Zdr2bJlzmuzZ8/WF1984cWq6jZhwgT95S9/cZ4n9dZbb+nRRx9VXl6e/vOf/zj7dejQQSNHjmz0flVbE1YpKytzu5bnnnvO7b512bx5s3bu3KlevXo12regoEAffPCBy7URI0bU6te9e3e1bt3aGc6lpKRo1apVuuCCC9yq6ZVXXml0DgAAAAAAAG+qWk1lz8quDKmyHUFVZWCligpvl9iwAGvlln/VtvurXElliY2RERLi7QpbFCEWAKBRM2bMcAmx/vvf/+q7777TOeec48WqaouIiNBVV12lt956S5KUmpqqlStXat++fSopObbc+/rrr5fFYmn0fklJSS7t9evXu1XH8uXLtXTpUg8qr9vf//53l697febOnau8vDxne8iQIerZs2etfoZh6MYbb9QjjzzivDZ9+nRt3LhRVqu1wTk2btyoxYsXu9zrpptucucxAAAAAAAAmpRZVOwaTmVVfZzt+6upDMmIjKxzuz9LbIxjyz83/t3qVEGIBQBo1KBBg3TxxRfrs88+c16bM2eOPv300wbH1dymbtWqVUpOTm6OEp2mTJniDLEkxzaCNc+mcmcrQUnq2LGj2rVrp0OHDkmSNm3apCVLluj3v/99vWM2btyo66677jgqr+2TTz7RI488ovvuu6/ePh999JHmz5/vcu2OO+6ot/+tt96qJ598UsXFxZIcZ4f98Y9/1AsvvFDvtoL79+/X+PHjXVam/e53v9Npp53mwdMAAAAAAAC4x7TbZeblu4RTzjOqsrJ9/2yqkGDXrf6qtvuren+SbfnXnPhKAQDcMmPGDJcQa/ny5dq8ebMGDhzoxapqu+CCC9S+fXsdPHhQkvT++++rtLTU+fkhQ4bojDPOcPt+kydP1qOPPurS3rNnj/785z8rMjLSef3gwYP697//rQULFqi0tFQhISFKSkrSvn37jus5OnXqpJSUFN1///3avn27Zs6c6XIm1+HDh/WPf/xDCxculM1mc14fM2ZMgyFb+/bt9fjjj+svf/mL89pLL72k3377TY8++qjLuVmFhYVavHix7rnnHmVmZjqvx8bG6tlnnz2u5wIAAAAAAJAks7zcZZs/Mzu78uNs2bNzpWr/3uFzrJZqoZTrdn+WmBgZoa28XeFJgxALAOCWIUOGaPTo0Vq5cqXz2pw5c5pk27ymZLFYdP311zuDp+oBluT+Kqwqd911l958801nKFZWVqb77rtPM2bMUPfu3RUWFqaMjAzt27fPZaXSP//5T7399tvHHWI99thjuvPOO5WamqpFixZp0aJF6tixo1q3bq2cnBzt2bNHdrvdZUynTp308ssvN3rvP//5z9q4caPefPNN57XVq1dr6NChSkhIUIcOHVRSUqK9e/c6V2xVadWqld555x21bdv2uJ4LAAAAAACcGkzTlFlUJLOOLf/s2Tky8/K9XWKDjIhw1+3+qm//FxnBln8thBALAOC2GTNmuIRYy5Yt07Zt29SvX79afaufQVUlJiamWeurMmXKFJfVU1WCg4MbXKVUl9jYWP3nP//RxRdfrLS0NOf1iooK7dixo1Z/i8WiBQsW6Oabb9bbb7/tefGVWrdurS+++EIXXXSRUlNTJTm29du/f3+d/U8//XR98cUXat++faP3NgxDr7/+upKSkrRw4UKXMCwjI0MZGRl1jktKStJ7772nYcOGHccTAQAAAACAk41pt8vMPVrnln/2rBypxouLfUpwkHPlVNVKKqP61n+Bgd6uECLEAgB4YPjw4UpOTtbq1aslOV5RM2fOHH3wwQe1+m7YsMGlPXLkyDrDrubQvXt3nXPOOfruu+9crl9++eXHFaSdddZZ2rx5s+655x4tWrTIZfu+KoZhaPTo0Zo7d64GDx583LVX16dPH/3www+677779Oabb9ZaVSY5gsFbbrlFM2fOVKtW7i9VNwxDjz/+uK699lrNmDFDX3zxRZ33l6S2bdvqxhtv1N13363w8PDjfh4AAAAAAOB/zLKyatv+Hdvyz8zOkT0nV7LZG72HVxiSERnpCKXiYmWJi6m2sipWRmires8Hh2TabDKP5smWkdl452ZEiAUAXna82815oip0agqrVq1yq99XX33l0p4zZ06T1eCOb7/9tknv165dO7355pt66qmntHbtWqWkpCg/P19hYWHq0qWLzj33XCUmJrqMaYqve0JCgl588UUtXLhQ69at0+7du1VYWKj4+Hh17dpVycnJCjyBVwb169dPS5cuVVFRkdavX6/9+/crMzNTwcHBSkxMVO/evdW/f3+P79uUf+cAAAAAAEDzMU1TZmHhsXAqK8d127/8Am+XWL8AqzOYssTGyoirDKxYTdUos6xM9tyjjpV0ObmyV743Kz828/Il01T59xu9WichFgCgWVQPsS688MKTZgu62NhYXXnllS0+b2RkpC699NJmu39oaKjGjBnTbPcHAAAAAADeY9psjrCiji3/7Nk5UlmZt0uslxHayrHNX1U45XwfIyOCs6kaYj96VLZDh2XmHJU91zWoMguLvF2eWwixAABNrqCgQJs2bXK2W3oVFgAAAAAAwKnGLC2tteVf1TaAZm6uZDe9XWLdDENGVKRLOGWJPbb9n+HB8QlwVf7jDpV++l9vl3FCCLEAAE1u7dq1qqiokCRdfPHFGjJkiJcrAgAAAAAA8G/Htv3Llj2zcqu/qpVVWdm+vbImMMC55Z+lcss/o2obwJhoGQFEFXWxpaXLnnrEsYoqJ1f2nKMyc3MV0O00hVxxSaPjLdHRzV9kM+NvBgCgyVU/N2v27NlerAQAAAAAAMB/mKYpM7+gcqu/yrfMLOfHKvXhbf/CQp2rqZzb/1WuqjIiwmUYhrdL9Bmmabr19Sj79nuVf1P7TCpbdJRb81hi3OvnywixAABNbv78+Zo/f763ywAAAAAAAPA5pt3uCKqqhVPV31RW7u0S62YxZERHVdvq79iWf5bYGBkhId6u0GeYZWWOlVO5R2Xm5Lp+nHtUQUPPVvDI4Y3ep74Qysw56lYdBiuxAAAAAAAAAABAdabdLjMvz7Htn3NFVeX77GypvMLbJdYtKNBly7+qgMoSFysjOkqG1ertCr3ONE2puFj2nKOV2/w5tvirHlSZRcUN3sOek+PWXPVtB2jPPerWai4jLFQKDJTKGw5GjYhwx7aOMdGyREc5Pq58H/xOlPTl527V2xwIsQAAAAAAAAAA8JBpt8vMPVo7pMrKkj07R6qwebvEOhkR4a7hVNWqqtgYGeFhp/y2f6ZpyiwocIRTObk1gqqjsufkSmUntq2j3c2VVJaY6Lo/UVEhs6BARkREg+MNw5AlLlZmaWmtcMpSGVgZ0VENnknm7fPKCLEAAAAAAAAAAKiDabM5gqq6tv7LzpFsdm+XWJvF4ggrqoVT1VdWGUFB3q7Qq0ybTWZeft3b/eU63jd3AGnm5rrVz2jgTCt7zlFZGgmxJCnsr3/062CSEAsAAB8wa9YszZo1y9tlAAAAAABwyjErKhwhRo0VVWZWtmPVjd0Hg6rgoNrb/lWFVFGRp/y2f2ZpqWyHDsuek3sspMrOcbTz8iS76dX63N8OMExGRLiMsFBZoqNlxETJEh0tS0yULHExbs3lzwGWRIgFAAAAAAAAADjJmRUVjhAjs8ZqqqwsmTlHJdO7oUadQoJliY9zhFNVb/GO90YY2/41xHYkXUUvvObtMupXXiGzsFBGeHiD3QzDUMT9d7VQUb6JEAsAAAAAAAAA4PfM8vJqQVWWy8oq8+hRyQdzKiO0lTOgMqqFVJa4OBmhrU7ZoMosKZEtPaPaKirHe8NqVejUaxodX+9ZUi3NkIyICMf2jpVnUDnPogoO9nZ1foEQCwAAAAAAAADgF8yyMteVVNVWVplH87xdXp2MsNBqK6mqr6yKkREa6u3yfFLFz7tVvPiD2p8ICnRvG76IcCkgQKqoaKYKK1ktMqKijoVTMdEyqgdVUZEyAohhTgRfPQAAAAAAAACAzzBLS+vY9i9b9swsmfkF3i6vTkZEuOu2f9W3/gsJ8XZ5Lc4sLnaunnKcS+U4j8oSE62QKy5pdLxR30qqsnKZRUUywsIaHm8YssREyZ6RdRzVVxMYKEtMlIyqc6gq3ztWVUU7zquyWE5sDjSIEAsAAAAAAAAA0KLMkpJjQVVmlktYZRYUeru8OhmREbUCKudWgKfY1nBmaWnlNn85lSFVbrXQKkcqKa1znKV1olv3t8RG1z93Tq7USIglSUZMjNRYiBUSUrmCyhFQGTWCKiM09JTd0tFXEGIBAAAAAAAAAJrcsTOqshxvGVm+v6IqKrJaSBV37OPYGBlBQd4ur8WYZWXVVlEdW1Flz86RmZMrs6j4uO5rz8lxbzvA8Pq3A7Rn58ravl2jc1liomULCZElNroyqIo5djZVbOV2f6fgKjl/Q4gFAAAAAAAAADgupt3uCDkys2TLzHKsrqoMrczcXMn0doU1GHJsDVfX1n+xMTICA71dYYswy8tlzz1aZ0Blz8ltvtVwTbAdoD0n162pQq64WK3+77LjqRI+hBALAAAAAAAAAFAv0zRl5uc7VlJVbf1X9XF2tmSze7tEV4bhWG1Tx7Z/ltgYGQEn/z+LmzabzNyjtbf8qwqp8vK9V5sn2wHm5jlXUhmVq6kCTuvi1jyG1XqClcIXnPz/tQIAAAAAAAAAGmUWFdVaTeXYAjBLKiv3dnmuLBZHuFF1JlVcrCzxldv/RUedEkFVXUzTVMGCf8rMzpVMX1sG5+DudoCh102UAgM5k+oUd2r+lwwAAAAAAAAApyCzrKwyoKoWVFVt/3ec5xw1G6tFltgY17OpqkKr6KiTeqWNaZpScbFjFVV2juzZuQo69+xGz+UyDMOxhaOvBFhWiyzRVauoKs+iap3g1tBT6Qwy1I8QCwAAAAAAAABOImZFhWPbuIys2kGVF7eRq1OAVZbYGmdTVQ+qLBZvV9ii7AWFKnr5Tdmzc6TSUpfPBfToJmtS60bvYYmNli07p7lKrDGZISMqyhFQVb4ZsTHOwMqIiDjl/gzRtAixAAAAAAAAAMDPmHa7zKN5tUIqW2aW48whu4+sxJEcZ1TFRssaH+dYVZUQ59j6Lz5ORlTkSRtymKYps6BQ9uwcmUePKvDMPo2OMVqFyJ6WVuefnz0rx70QKzpatuOquK6CJCMysnZAVdWOijypV8TB+wixAAAAAAAAAMAHOUOQzNorquxZ2VJFk0UVTcKIjHCGU8feYmWJjTlpz6gyy8ocq96ycmTPyZHp3P7PsQWgyo+dJRbQvZuM4OAG72dYrTKioxxnWtVgz3FvdZUlNsaTR5AREe74M6oWTjlWUsU4QqqT9M8O/oG/fQAAAAAAAADgRWZxsfOMKptLWJVda0s5bzNCW9UdVMXFNhrQ+CPTbpeZn+8IqSrDKTMn99jH+QVu38uenSNrm6RG+1liY2SrI8Qy3dwi0BIT7dI2wsPqDqhiomWJjpIRGOjWfQFvIMQCAAAAAAAAgGZmlpfLnpV9LKDKOLaiyiwo9HZ5roICXbf9i4t1fBwXJ0tYqLera3JmSYlz5ZS92koqMztH9pxcydY0K948CrG0t87x7rCe1lmtpl5zbMu/oCCPawV8BSEWAAAAAAAAADQB02aTmZNbazWVPTNL5tGjkg8dUyWrRZbYWEdIlVAZVFV+bEREyDAMb1fYZEybzXF+mMtWf8eCKrOouEXqsNexuqoulpga2wEGBMgSGy0jOsq98ZGRskRGelgd4JsIsQAAAAAAAADATaZpyiwskj0js9pbZWCVnSPZ7d4u8RhDMqKjXbb9s1Z+bERHybBavV1hk7KlZ8h+JK1GUJUrMzdXsns/QXR3JVVAzzNkREXKElu57V94uAyLpZmrA3wTIRYAAAAAAAAA1GBWVDhCkOpBVUambBmZUnGJt8tzYUSEu55PVfVxbMwpdd5R2VdrVf7DT94uo25BgZLpXsBpTWota1LrZi4I8A+EWAAAAAAAAABOSc5VVZmZsqdnOlZTpWc62tk5PrF6xykkWJaEeFmrbftXdV6VERLi7eqahL2gQPasHJk5ObJnHVtNFXTOQAX2P7PR8UZsTKN9mo1hVK6einF5M6reh4WeVFs0Ai2FEAsA4NdmzZql2bNnO9urVq1ScnJyvf2r/8A4YsQIrV69uhmr8z3Jyclas2aNs22azfML2erVqzVy5Ehne+bMmZo1a1azzAUAAAAAjTFtNtmzsl1WVNkzHKFVS52H5JbAAFniaqymSoiTJS7ulAhBit9cIlvKgVrXbR3auRViWZo7xAoJkSXONaSyxFRu+RcdJSOAf24Hmhr/VQEAAAAAAAA4KdgLC2sHVRlZsmdn+86qKovFEX5UD6qqzqmKjPD7s4/MsjJHYJiVI3t2tuxZ2Qo6e6Cs7do2OtYSG1NniOXuWVInHGJZLLLERFeunoquEVbFyAhtdWL3B+AxQiwA8LLOnTsrJSWlwT4Wi0VRUVGKiYlRz549NXjwYE2YMEG9evVya46aq2/qYhiGIiIiFBUVpa5du2rAgAEaO3asRo8eLYuf/wANAAAAADh5HFtVleW6DWBGpk+tqjKiIo9t+Vf9LSZahtXq7fKOm2maMouKZc/KlpldGVZlOcIqe3aOzPyCWmOsbdu4FWLVtx2gPSfXrdoscY2HWEZ4WLWgqsbWf1GRfh8iAicbQiwA8AN2u105OTnKycnRnj179Omnn2rWrFkaNWqU/vWvf6lbt24nPIdpmsrLy1NeXp4OHDigNWvW6Mknn1Tnzp31j3/8Q7/73e+a4EkAAAAAAHCPY1VVjRVVGVVnVdm9XZ5DSIisCXGyJMQ73qq2/4uNkREU5O3qjptpt8vMz68VUFV9rJJSj+5nz8p2q199K6nsWe6txDIiIhxnh0VGHAumYipDqjjH1n9GcLDbdQPwPkIsAPBjX375pfr376/3339fF198cbPMsW/fPl155ZX6+9//rnnz5jXLHAAAAACAU5NpsznCkZpBlS+tqjIMGbHRsibEyxIfL0tiVVgVLyM8zG/PqTJtNtlzcmVWBVSZ2ZXb/+U4gsKKiiab60RDLJWUyCwqbnQ7P8NiUcTMe/z2zwRAbYRYAOBjFixYoH79+rlcs9lsysrK0pYtW7R48WIdOnTI+bmioiJNmDBBGzZs0JlnNn7IqSRNnz5dY8aMcblmt9t19OhR7dq1S0uXLtWWLVtcPv/YY4/ptNNO080333ycT+YbTNNH9kD3ktWrV3u7BAAAAACnIHthkevWf+mZjnaWL62qCnYEVc63yhVWcbEyAvzzn1HNsrLaAVWW42Mz92iLnRPm7koqS2y044OgwFrnUcniXjBFgAWcXPzzuy8AnMQGDhyo5OTkOj93zTXX6JFHHtHdd9+tp556ynm9sLBQ06ZN04oVK9yao1evXho9enS9n58xY4befvtt3XjjjSotPbZFwP3336+rr75a4eHh7j0MAAAAAOCU4bqqqvo2gD64qiq+WkhV+ebPq6rs+fmy/W9fra3/6jqfyhvs2dkyTbPRr68REaHwB6bLCAv12z8LAE2LEAsA/ExQUJD+8Y9/KDMzU2+//bbz+sqVK7V9+3b16dOnSea59tprdfToUf35z392XsvIyNDHH3+s6667rknmAAAAAAD4H7OoSLY6giqfWlUVHCxLYrys8XGV2/9VbgPox6uqGmI7dFjFiz/wdhmuLBbHGVRxMbLExjq2JwwMbHCIYbHICA9roQIB+IOT7zs2AJwi5s2bp0WLFsle7ReE//73v00WYknSLbfcorlz5yo1NdV57csvvyTEAgAAAICT3LFVVdWCqkzHx2ZhkbfLczAkIyZG1horqiwJcTLCw/1qJY9ps8nMyXWuoHK85cgIbaVWE65sdLwlLrb5i6xLYIAssbGyxMXKEhdT+T5WltgYGdFRMqxW79QF4KRBiAUAfqp9+/bq16+ftm7d6rz2008/NekcAQEBSk5O1jvvvOO89ttvvzXpHP4mNzdXq1ev1sGDB5WXl6fY2Fj16dNHQ4YMUcBJ+Gq+msrLy7VmzRrt2bNHmZmZCgsLU7du3TR8+HBFRER4uzwAAAAAHjJLS2XPyJQtPVP29AzHWVUZmbJnZ0s2H1pVlRBX+7yquFgZjazs8RflGzerZOnyWteNSPd+z7LEREuGpGY44soIbSUj1jWgqvrYiPCvsBCA/zn5/7UNAE5iXbt2dQmxMjMzm3yO9u3bu7SbY46WVP2H6xEjRmj16tVujTt48KDuuusuffTRRyorK6v1+YSEBE2bNk3Tpk1TQECAZs2apdmzZzs/v2rVqnrPOvOkb0379u1Tly5dnO0pU6botddeq7d/cnKy1qxZ42ybpnu/4RQXF2vOnDl64YUXlJ2dXevzwcHBmjx5sh555BHFx8e7dU8AAAAALcdeWCR7RmVIlZ4hW2VgZeYe9XZpDoZkxEQ7gqoa51X5U1BiFhVXnkmVLXtmtoyIcAWdPbDRcZbYmLrvl5cvs6xMRlBQg+ONgAAZUVHH/edpREbUCqgsldsAGqGtjuueANAUCLEAwI8F1njFWUVFRZPPUTPk8JdfHJrS8uXLdfXVVysvL6/ePhkZGbrnnnv0ySef6JNPPmnB6prf3r17ddFFF2n37t319iktLdWLL76oTz/9VJ9//nkLVgcAAACgimmaMvPynSuqbBkZsqdlOLYALCj0dnkOwUGyJMRXhlWV51UlxPvVqiqzqEi2zGzZs7Jkz8x2bLNYuQWgiktc+lo7dXAvxGpgO0B7do6sSa3duoetvhDLYsiIiXbd+i82Vpb4WMe5VY2EZADgLYRYAODHqp9VJUlxcXFNPsfBgwdd2q1bN/6D88nkq6++0rhx41RS4vqLSGhoqLp06aLAwEClpKQoJydHkrR+/XpNmDBBQ4cO9Ua5TS41NVUXXHCB9u3b53LdarWqS5cuio6OVmpqqvPvYmpqqsaOHasnnnjCC9UCAAAApwbTbpeZk+tcTeUIrTJkS8+USku9XZ5jVVV0dGVY5Xpelb+sqjJLShzhVPWQqvK9WVTs9n3s2Tlu9TNioiWLIdlr75Zhz3IvxLImJcosKHQNqCpXVnE+FQB/RYgFAH6qqKhImzZtcrlWfVu5plBRUVFru72BAxt/BdnJIjc3V9dee61LgJWYmKj58+drwoQJatXKsaWC3W7XV199pTvvvFM//fSTVqxY0eCqJX9y4403ugRYQUFBuu+++3TrrbcqMTHReX3Hjh2aMWOGPvzwQ6Wmpuqee+7xQrUAAADAycWsqHCEJ1UrqyrDKntGltQMO3F4LChIlsR4WePjXM+qio/zi1VVZmmpI6SquaIqM0tmYVHTzJFfILO0VEZwcIP9DKtVRnSUzOzcWp+z17Gle11CLr/4eEoEAJ9GiAUAfurpp59WcbHrq78uuOCCJp3j+eef1+HDh12uTZw4sUnn8GX33Xefjhw54mx36tRJX3/9tdq1a+fSz2KxaPTo0dq0aZMuueQSffXVV7VWLvmjd99912VrwODgYC1fvrzOv2e9e/fWBx98oAceeEBz5849KZ4fAAAAaClmWdmx7f/SMyu3AMxwbE9Xx8qcFuVcVRXn2AKw2jaARkSEz6+qMsvKKoOp2mGVmV/QIjXYs3NkbZPUaD9LXKxs2bmO86mqnU0V0KVTC1QJAL6JEAvwcRklPrANQAMSQhp+JVGV+p4jKihQQRZLo+Nzy8pVbrd7VFtN7tbqD5YtW6YHH3zQ5VqXLl00bNiwJpvj7bff1rRp01yuXXrppTr77LObbA5flpubq9dee83ZNgxD7733Xq0Aq7rg4GB98MEHOuOMM5SRkdECVTavJ5980qU9d+7cRoPShx9+WBs3btSKFSuaszQAAADAL5lFxcfOqaq2ssqs7xyjlhQQ4AioEivPq0o8Flj5+qoqs7xc9uycY9v/VQurzLx8b5fn2A7QjRCr1YT/kxESzPlUAFANIRbg46Zv3OXtEhr02vn93epX33P8/czT1DM6otHx/9q1T78cPbFDaN2t1RfZbDbl5ORo8+bNev3117V48WKZpuur8R5++GEFuvmLxc6dO7Vy5UqXa6Zp6ujRo9q1a5eWLl2qzZs3u3y+W7duevXVV0/sQfzIokWLXFa6jR8/XoMHD250XHR0tO6//37dcccdzVhd89u1a5e+/fZbZ7tdu3a6/fbb3Ro7f/589e/fv5kqAwAAAHybaZoy8wtczqmq+tgsOLHfa5tEcLCsrRMqA6sEWVonyJoQLyMmWoYbLzL1NaZpKn/uQqnGOcZeFxDgPJvKaBXi1hBLZOP/PgIApxpCLADwMSNHjvR4zJ133qlrrrnG7f7z58/X/Pnz3e4/adIkPfvss4qNjfW4Nn9V8yywyZMnuz322muv1V133aUKX9ij/jjVfP5Jkya5HZL269dP/fv31w8//ND0hQEAAAA+wrTbZeYePXZOVWVYZUvPkHxgVxUjPMwRUiXGy5rgCKt8fQtA02aTmZMrW+W5VEFnnSkjNLTBMYZhyBIXI/uhww32axaBgY4t/+JjHVssVm7/Z4mLlRER7pehIAD4GkIsAPBjYWFhmj9/vm699dZmu//ixYt12WWXNcv9fdnGjRudHxuGoREjRrg9Nj4+Xn369PHrEKf680tScnKyR+OTk5P9+vkBAACAKqbN5jhTKa1yZVVG5cqqjEyp3PsvXDOio2RJTJA1sXJlVeXHjYU/vsKsqFDxm0scWwBm50rVjhKwtklSQNfOjd7DEh/XfCFWgLUymIpzDavi42RE+m4gCAAnC0IsAPAzISEhOuuss3TVVVdp6tSpio+Pb7a5CgsLNX78eL300ku67rrrmm0eX2O325WSkuJsd+zYURERnm3r0LdvX78Ocfbu3evS7tOnj0fj+/bt25TlAAAAAM3OLCuTPSPLuZqqamWVPSvbJVjxCoshS2ysc2WVI6hKkCUhTkaw753/bNrtMvPyZERGNroayQgIUMX+A1Jx7e0A7VnZkjshVtwJ7hpitTi+vvE1wqr4WLeeAQDQfAixAMDHLFiwQP369XO5ZrVaFRERoejoaHXu3FkBASf27fvVV1/V1KlTXa4VFRVp//79+vLLL7Vw4UJniFFaWqopU6YoMjJSV1xxxQnN6y/y8vJczhyLi4vz+B7HM8aX5ObmurQ9fR5/f34AAACcvMziYpdzquzpmbKlZ8jMzZXMRoc3rwCrLPHxznOqqs6sssTFyjjB3wObmmmaMvPyZc/McqxUy8ySPTPbsaIqK0eqqFD4PX+TER3V6L0s8XGyHzhU67o9M8utWizxbvz+YbHIEhtd94qq6CiCKgDwUb71fz8AgAYOHOjx1m1NITQ0VD169FCPHj00depUXXnllVq5cqUkx8qkKVOmaMeOHWrbtm2L19bSCgoKXNqhx7ENR1hYWFOV4xUn+jXw9+cHAACAfzNNU2ZBgcs5VVUfm/kFjd+guQUHHVtNlRgvS0KCrK0TZMRE+1SY4vg6FjqCqczsWoGVyssbHG/PzJLFjRDLGhd7giFW5Uosw5ARE11rRZU1LtbxtbVa3bofAMB3EGIBPm7+2T29XUKTqO85ooIC3Rp/a8/OKvf29g2nkLCwMH3wwQcaOHCgfvvtN0mOlTl//etf9d5773m5uuZXM4ApKiry+B6FhYVNVY5X1PU18GRLRX9/fgAAAPgPe2Gh7EfSHWHVkXTZ0xwfm0XF3i5NRlio85wqS2J8ZWiV4HNnKZklJbJnZMqWmeXYUrFaWKXSsuO+rz0rWzq9a6P96ltJZc/Mdmsea5skhU27TZaYaJ9bsQYAODF8Vwd8XEKI7+1tfTxO9Dmi3Qy70HQiIyP1/PPPa9SoUc5r77//vjZs2KBzzz3Xi5U1v6ioKBmG4dxSMDMz0+N7ZGW594pBSSf0y+vxBGzuiI6OdmlnZmZ6FGJ58vwAAACAO8ziYtnSMhwhVVq682OzwPsvoDKiIl1XVlW996EdCkybTfacXNkzMiuDqsr3GZnN9jU8ke0AjahIt1ZxSZIRGChrQvOdFw0A8B5CLABAvS644AJddtll+uSTT5zXHnzwQX355ZderKr5WSwWderUSfv27ZMkHThwQHl5eYqMjHT7Hj/++KPbfUNCQlzaxcXuv2I0IyPD7b6e6Nq1q9auXetsb9++XV26dHF7vCfPDwAAAFRnlpZWW1WVIVtlaGXm5Xu3MMOQJS5GloTKc6oS4p2hlRHsGy9ANU1TZmGRS0DlDKyycqQW3uHE7ZVUHdsreOzoY2dVxcbICApq5uoAAP6AEAsA0KCHHnrIJcT66quvTonVWIMHD3aGWKZpau3atbrsssvcGpuZmakdO3a4PVfNcCwtLc3tsZs2bXK7rycGDx6s1157zdles2aNLr/8crfHr1mzphmqAgAAwMnELC+XPT3TGVJVra4yc3K9W5jVKktCXO2VVXGxMgJ9a5cQ26FUVfz6m3MLQFtGplRc4u2ynOxu7tBgiY1RcPKwZq4GAOCPCLEAAA3q37+/Lr/8ci1btsx5bfbs2friiy+8WFXzS05Odjn/64033nA7xHr77bdVUVHh9lydOnVyaW/dulVTp051a+ySJUvcnscTycnJLu3Fixfr0UcfVaAbv7Rv27ZNP/zwQ7PUBQAAAP9jVlQ4zlhKS3eurrKnpcuenSNVbuHtFUFBLudUOcOqmGgZVqv36vJAxf/2qvSLr7xdhozQVrLEVa6iqnofHytLXKy3SwMA+DlCLABAo2bMmOESYv33v//Vd999p3POOceLVTWvq6++WtOmTVNJieNVjO+//742bdqkwYMHNzguNzdXc+fO9WiuAQMGuLQ/+ugjLVy4UAGNHEj84Ycf6vvvv/doLnf16tVL55xzjr777jtJ0qFDh/TPf/5T06ZNa3Ts9OnTm6UmAAAA+DbTZpM9K7tyVdWxbQDtmdktvo1ddUZoq8qQKqFydZUjrDKiIk/ofNqmYpaWOrf8s1WuqLK2aa3g5OGNjrXEt+A5UCHBdYRUcbLGx8oIDW25OgAApxRCLABAowYNGqSLL75Yn332mfPanDlz9OmnnzY4ruYvhKtWraq1wsdXxcTEaMqUKXr++eclObYUnDhxor7++mu1bdu2zjGlpaUaP368x+dUJSUl6ayzztLWrVslOc7gevzxx3XffffVO2bTpk266aabPJrHU3fccYeuvvpqZ/v+++/XgAEDNHLkyHrHPPjgg1qxYkWz1gUAAADvMu12mTm5jlVV6dVWV2VkSjab1+oyQlvJ0jpRltYJsrZOdIRWrRNlCQ/zWk2NKflshcrWfF3ruplf4F6IlRDXtAUFBjoCqoTaYZURFuoToR8A4NRCiAUAcMuMGTNcQqzly5dr8+bNGjhwoBeral6PPPKIPvroI6Wnp0uS9u3bpwEDBmj+/PmaMGGCQkJCJEl2u12rVq3SnXfeqR9//FGS1LlzZ+eZWu64+eab9ac//cnZfuCBB5Sfn6+7775bMTExzuupqal6/vnnNX/+fBUXF+u0007T//73vyZ42tomTZqkl19+WStXrpTkCOnGjh2r++67T3/605+UkJDg7Ltz507NmDFDH3zwgSTPnx8AAAC+xzRNmblHq51ZVbm6Kj1DKnd/++wmFxzkCKkq36ytE2RJSpQRHu71kMUsKpItI0tGcJCsSa0b7W9ERNR53Z7p/llSslg8W+lmSEZ0tCwJcbLGx8mSEF8ZXMXLiIyQYbG4fy8AAJoZIRYAwC1DhgzR6NGjnYGG5FiNtXTpUi9W1bxiY2P19ttv67LLLlNpaakkKS0tTZMnT9Yf//hHde3aVYGBgUpJSVF2drZz3JgxYzRkyBDNmTPH7bluvvlmvfjii87VWKZpat68eVqwYIHOOOMMhYeHKyMjQ3v37nWOSUpK0ssvv9ysq9teffVVDRs2TCkpKZKksrIyzZo1Sw8//LC6dOmi6OhoHT58WAcPHnSOadeunebNm6dJkyY1W10AAABoOqZpyszPd4RUR6oCq3TZ0jOk0jLvFRYYeGxVlfN9ote3ATQrKmTPzpE9I7NyG8Asx8eZWTILixylDzpLrcb/rtF7WetZSWXm5cssLZURHNzgeMNqlSUuRvaMOkKvkGBZEuKPBVUJle/jYmW4cdYtAAC+gBALAOC2GTNmuIRYy5Yt07Zt29SvX79afavOkqqu+ooifzF69Gi9//77uuaaa5Sfn++8XlRUpO3bt9fqP2zYML377rt68sknPZonICBAH374oUaPHu2ysqqiokI7d+6s1b9jx45avny5wsKad2uU9u3b68svv9RFF11Uq67du3fX6t+2bVt9/vnnyszMbNa6AAAAcHzsBYXHQqqq1VVH0qU6fn5vMQFWWRISnCuqLImO1VVGTLTXVgU5gr0CZzhVdWaVPSNL9pwcyW42ON7tlVQJ9Z9pZc/MkrVd3VuZV2c9vatzJZWlWmBlhIV5fWUaAAAnihALAOC24cOHKzk5WatXr5bk+MVuzpw5zi3kqtuwYYNLe+TIkXWGXf7gsssu044dOzRt2jQtXbpUZWW1X40aHx+vadOm6a677lJAwPH977Vz58767rvvNGPGDL388svO1V/VtWrVSjfddJPmzJmj6OjoFtmy77TTTtOPP/6oOXPm6IUXXlBOTk6tPsHBwZo8ebIeeeQRxcfHO/+OAAAAwDvMomLZ0tNrra6qWinkFRaLYzVQ60Tn6ipL60RZYmNkWK1eKcksK5M9M/tYQJWRKVtlaKU6fh53l7shlhEdJQVYpYraZ4nZM9wLsVr97lKP6wMAwF8QYgGAl7VECNGUgcKqVavc6vfVV1+5tD3ZWs8Ts2bN0qxZs9zub5oNv2KyPh06dNC7776rnJwcrV69WgcOHFB+fr5iY2PVp08fDR069LjDq+ri4uL07LPP6vHHH9eaNWu0d+9e5ebmKjQ0VD169ND555/vsvqqc+fOHj3T8f5dCA0N1bx58zRnzhytWbNGe/bsUWZmpsLCwtStWzedf/75iqi2n39ycvJxf60BAADgPrO0VLa0jFqrq8y8/MYHNxfDkCUutvLMqgRZkyrPr4qLldEEPzN7yrTbZR7Nc27/Z6sWWJlH85pnzoJCmcXFMlq1arCfYbHIEhcne1q6Y0VaXNyxbf8S61+lBQDAqYIQCwDQLKqHWBdeeKGGDRvmxWqaTkxMjP7v//6v2ecJCwvTJZdc0uzzeCooKEgXXniht8sAAAA45ZhlZbKnZ1aGVJUrrNLSZeYe9WpdRmyMYxtA5+qqRMdWdl44c8ksK6sMpzJkS888dmZVVpZUXtHi9dgyshTQsX2j/Vr9/v9khITIiI7y2vaJAAD4KkIsLystLdWuXbsse/futRw8eNDIz883ysvLFRkZacbHx5v9+vWz9+rVy94Ur+6XpPLycn3zzTfWn376yZKVlWVYrVa1bdvWHDRokK1v3772Jpmk0oEDB4wNGzZY9+3bZykuLlZkZKS6d+9uO//8823VX60P4ORTUFCgTZs2OdvNtQoLAAAAONmYdrvsWdmyH0mT7XCa431auszsHMmLC92NqMhjK6oSK1dXJSbICArySj2mzabyzT/Inp7pDK3M3Fyvfo1cBAXJLCh0q6u1bZtmLgYAAP9FiOUFS5YsCVi5cmXAhg0brL/++quloqLhVwNFRUVp4sSJ5XfccUdZr169jitoys/P19y5c4NfeOGFwJycnDpP9ezWrZt9+vTpZTfeeGO55QRe+fPVV19ZZ8+eHbx27do6N7QOCgrS+PHjyx966KHSrl27+sqPlwCa0Nq1a1X1ve3iiy/WkCFDvFwRAAAA4HvshYWyH0k/FlYdSXNsK+eFVUNVjIjwylVVledVVX5shIR4raY6GYZKln0ulZd7tQYjJlrWhDhZ4uOPbQOYECcjIkKGUec/vwAAAA8QYnnBnXfeGZKamur2TzJHjx7Viy++GPjaa68F3n333WVz5swp9SRk2rZtm+XKK68M3bdvX4Nz7t6923LLLbeEvPvuu4HvvfdeUXR0tNtzSJLdbtddd90V/OSTTzb4MqyysjK98847gUuXLg185ZVXiidOnOi9n84BNIvq52bNnj3bi5UAAAAA3mdWVMiekekIqQ6nOd+b+QVeq8kIbeUIqZIqtwFMrAytwkJbtA7TZpM9O8e5osqenqmQyy6SEdpwHYbFIktivOyHDjd7jUZoK1nijwVUzsDKS2d8AQBwKuH/tD4iJCREHTp0sEdGRsputysrK8s4cOCAYZrHFiqVl5dr7ty5QQcPHjRee+21Enfuu2vXLsuoUaNCs7KyXAKs8PBwde7c2V5SUqKUlBRLebVXLq1cudI6duzY0FWrVhW1auQA0upuu+22kH/9618um14bhqF27dqZ8fHx5oEDB4zqdRQWFuqaa65pZbFYisePH0+QBZxE5s+fr/nz53u7DAAAAKBFmaYpMy9PtiPpLmGVPSNTsjfpDv7uCwk+dlZV6wTnx0Z4mFdXCpklJSr818uyZ2ZLNpvL5wLPHqCAzp0avYcloQlDLKtFlrjYYwFV9dAqLKxp5gAAAB4jxPKSNm3amBdffHHF+eefbzv33HMrunbtalqtrrvvZWdna8mSJYFz584NPnTokPMny9dffz3wvPPOs918880NrpkvLy/XhAkTWlUPjmJiYsyFCxeWXnvtteVBlftWZ2Vlaf78+cHz588Pslf+UP3dd99Z77rrruBnn3221J3nWbRoUUDNAOvKK6+smDdvXmn37t2dP6n/97//tU6bNi1k+/btFkmy2Wy64YYbWg0YMKCArQUBAAAAAP7CLCtzhFVH0pznV9mOpEnFbr3mtOkFBTq2/ktMOLa6qnWijMiW3dbOLCqWWoU0PmdwsOy5ebUCLEmyp2dKboRY1oR4efqKWCMi3DWgSoiXNT5ORky0DGudpyIAAAAvIsTygk8//bTozDPPtDe2JWBsbKxuvfXW8t///vflo0aNCvvhhx+cA2bMmBF8ww03lNcMvqp78cUXA3fs2OEcExMTo7Vr1xb16dPH5eVfcXFxmjdvXmnv3r1tkydPdi69euGFF4Juv/328uohVF1KS0t17733umyOffPNN5f/+9//Lqn5jGPGjLGtW7eucNSoUWFbtmyxSI7zumbMmBH81ltveeknfQAAAAAA6mba7TKzcxyrqqqdX2XPzpa88VLMgABZEuOPra5KcgRXRnSUjBM439oTVSvO7OmZsqU7tgC0p2fInpEps6BQ4fdNkxEZ0eA9DMOQNTFetgOHan3Onp7hVh2WxIS6P2G1OoKqxHhHSJVwbHWVz53tBQAAGkSI5QX9+/f3aA+B2NhYvfXWW8V9+/YNq9pe8MiRI8a6deusycnJtV+yJEew9OijjwZXvzZv3rySmgFWdddff33FZ599Vr5o0aJASaqoqNDMmTODFy9eXNxQfS+88EJgSkqK8yVWp59+uv2pp56qFWBViY6O1uuvv148cODAsLKyMknS4sWLA++7776yXr16eWl/BQAAAADAqc4sKnKurnKeX5WWLpU1uBFK8zAMWeJjZUlqLWtSa1mSKkOr2JiWC6vqOK/KVhlWqbSs3nH29AxZGgmxJEcIVVeIZUvPdKs+S1KirB3aOVZVJSY4QqvEBFlYVQUAwEmDEMtP9O7d237WWWfZq1YvSdLOnTst9YVYn332WcDBgwedwVKnTp3Mm266qdGfumfPnl26ePHiwKqw7MMPPwzIzc1VdHR0vWNeeeWVoOrtu+++u6yxs7T69OljHz9+fPk777wTKDm2FXz55ZcDFy5c6Nb2hQDg62bNmqVZs2Z5uwwAAADUwbTZZM/IrAyrjp1fZR7N80o9RljosbCqTeX71gkyAgMbH9wEzPJyx9ejWkhlT8+o87wqd9gzMqXTuzbaz5IYX/d4N1diWRPiFfbnmz2qDQAA+BdCLD/StWtXlxArMzOz3g2mly5d6vJnO3ny5LLGti+UpG7dupnDhw+3rV271io5ztX65JNPAq677ro6t5nev3+/UX2bw/DwcF199dVuvUTtxhtvdIZYkrRs2bIAQiwAAAAAQFMxTVNmfoHzzCrnCqv0DMnmhY1ArFZZEhNkTUo8Fla1aS0jPLxFzq0yi4ply6i2/V96pmwZGTJzcpt0a0Sbu9sBJlTbDtCQjJhoWRMSZGmdINM0W/QsLwAA4JsIsfxISYnrkVHR0dH1/oj52WefufzZXnTRRW6/dGrUqFEVVSGWJH3yySeB9YVYy5Ytc5lnyJAhtvDwcLfmGT58uC00NFRFRUWSpN27d1t++eUXS2NncAEAAAAAUJNZViZ7eka1sMqxLaBZWOSVeoyoSNeVVW1aO85kauZt7hznVeW7hFRVoZVZUNisc1exu7kdoLVje7WaNM55dlVLrTwDAAD+gxDLT9jtdm3evNnlJ91BgwbVGfYcPnzYSEtLc75cKTg4WIMGDXI7xBo2bJhL323bttW7hGvbtm0uNQ0dOrTOsKsugYGBGjRokK16YLZ161ZCLAAAAABAvUy7XWbuUdeVVUfSHFvfmU24nMhdQYHOM6sc7x2hlRHa8Db7J8q02WTPyXWGVfb0DNkqtwRUqXc3OXF3O0BLeJgs/fs2czUAAMCfEWL5iRdffDHw8OHDzmDqjDPOsA8ZMqTOYGrnzp0uoVPXrl3twcHBbs/Vu3dvlxBpz549lvLycgXW8Yqon3/+2WWummMb07NnT3v1EKtm7QAAAACAU5dZUuIIqQ5XhVXpsh1Jk0rLWr4YQ7LExcrSurWsbSrDqjatZcREy3Bj+/6mVLZpi0o+/vS4zqtqakZ4mCyJCbIkxju2AkyMlyUxofGBAAAAbiDE8gOvvPJK4O233x5S1bZYLHr66adL6jvjqmaw1L59e49eita6dWszJCTEuX1hWVmZ9uzZU+cKqV9//dVlrg4dOng0V/v27V3u+euvvzbvvgoAAAAAAJ9j2myyZ2UfC6sq35u5R71TUKsQWdskOc6uqgyrLK0TZQQFNduUZkWFzOISWSIa36LfCA9r2QCr+nlVlSFVVWjV3CvOAADAqY0Qywf8/PPPlpSUFOcqq/LycuXk5Bg//fSTddmyZQHVQ6mgoCD961//KhkzZky9P62mp6e7nHxaMyhyR5s2bcy9e/c675OWlmZ07969Vr/MzEyXuTp06ODRXDUDtpq1AwAAAABOLvaCglphlT09Q6rwwqoii8URxlRuA1h1fpURGSHDaL5fT+1Hj8qWclC2tHTHdoBH0mXPypL19K4Ku+H6Rsdbm2ulk9UqS3yc84wqa2VYxXlVAADAWwixfMCzzz4b+MwzzzT4ci7DMHThhRdWPProo6UDBgxoMCgqKChw+Uk7LCzM403BQ0NDTUnO+xQUFNTqU1RUJFuNV36Fh4d7NFfN2goLm+6Q2SNHjhgZGRmN/tZRfZvGyrZ27Njh1hwJCQlKTEw8zgoBAAAA4ORl2u2yZ2TKfviIbKmON/uRNJkFTfd7nyeMyIjK86oSnWGVJSFeRkDL/9NI+bbtKl2+otZ1e5p7Z0kZMdFSgPX4g7/gIFkSE2RNOLaqypKYIEtMtAwrG6QAAOBv0tPTlZHh3s8Rnjp8+HCz3NddhFh+4qqrrqq4/fbbyxoLsCSpsLDQJZTx5DysKq1atXIJl2oGY5KUn59f61pISEjNSyc8z/F65plngubOnevxXg+PPvqoHn30Ubf6zpw5U7NmzfJ0CgAAAAA4qZhlZbIdSZc99bBsh48FViqvaPliAgNkaZ3oXF3lOL8qUZawsGaZzrTbZeYelS0tXUZAgAK6ndboGGvrul8MaR7Nk1lSIqOR360Ni0WW+HjH17ihfvWcV9XcK80AAEDLeu655zR79mxvl9EsCLH8xAcffBDwwQcfBJx33nm2V155pfiMM86od8VT1VlWVYKOY8/umsFXcXFxrZ9ua85zPHPVnKekpMTvf4qu6xcBu93jHR0BAG6q63ss/ygDAEDzsRcWyp5atbrqsOyHj8iekSWZHm8CcsKM2JjKsCqxMqxqLUtcrIx6zpA+EaZpyjyaJ3taumxpGZXvHdsBqqxckmTt2tmtEMtST4glSba0dAV06tj4PRIrQ6x6z6uKlxEa6v4DAgAA+CBCLB/w9NNPlz799NOlVe2ioiJlZmYaP/zwg/Wjjz4KWLJkSWBxcbEk6euvv7aec8454Z9//nnhOeecU2cyUnM1VFlZmcc1lZaWurRDQkJq/TZS16qrsrIytWrl/qGuNecJDg5u+d96mpiljl+WysvLjytMBAA0rqKi9iu86/peDAAAPGOapszsnGMrqypDKzMvv+WLCQmusbLKsS2gcRw7jzTGNE2Z+QUuYVXVx6rxO2xN9rR0t+YwoiKl4OA672dPy5DcCLGCLzhfwcnDZImPk8HvmwAA4CRFiOWDQkND1bFjR7Njx44VV1xxRcW9995bOmHChNAff/zRIkm5ubm66qqrQrdv314QExNTa3zNc6ZqBkXuqLnyqq6zriIiImpdKykp8SjEcmee43XbbbeV/f73vy9vrN+bb74ZMH/+fOdvPvfee6+uvfZat+ZISKh9mK5hGAoKCnIJD/Py8hTWTFtXAMCprua5jUFBQazEAgDAQ2ZFhezpmc6VVVVnWDUW2jQ5iyFLfHzlmVWJztDKiIpqlv+/2wsKHSFVeoZjO8TKj82i4uO6n1lYJHtBgSzh4Q32MwxD1tYJsu0/WLsmN4Mwa1Lr46oRAACcfP70pz9pwoQJzXLvt99+2+3jd5oDIZYfOOOMM8yVK1cWDRgwIOzgwYOGJKWmphrz5s0Lfuyxx2r9RlEzCKp5RpY7ioqKaoZLtfqEhobKarXKZjt2kGxBQYERExPjdhBVs7amDHqSkpLMpKSkRmtp06aNWaOt3r17n9DcUVFRLgfp5eXlKSEhQQFeODAYAE5mpvn/2bvz+DrLOu/j3+u+z5a1S9JmaZM03aEUEMoiImtBEFEU1BlAXMZBceVhRHFQQUGdEXHG9fFBFGcAFVcQQXaEAgoUaOm+Z1+6pG2a7Sz3fT1/nCRt2rTZTnJOms/79apNzrnv6/qdtpbkfPv7XVatra19HsvLy0tTNQAAjA+2q0teY3NvZ5XX2JTs/jnge7uxYHJzusOqns6qIjnTC2WCwZTvZTs65W3fLr/5oLCqrT3le/nNOwYMsSTJKSmW7eyUUzQ9eYZX0bTkx4UFKa8JAAAc3aZPn67p0w8/rngkSkpKRmXdweId9XFi2rRp9mtf+1r02muv7Z3hd++99wb7C7GmT5/eJ5Spq6sb8kylxsbGPuFSUVFRv2FQYWGhbW5u7r22trbWKSsrG/R3Pj2hXI+Dax+vDg6xfN9XdXW1ysrKGCsIAClirVV9fb3i8b5Nt/n5+WmqCACAzNIzFu/A7iq/oUn+rpaxLcQxcqZPk1tSLKekeP/ZVXkDBz1DZbu65G3fIb95h/ym7b3B1ViOQPSbtktzKge8LnLZJXSPAwAADIAQaxy54oor4p/4xCcitvuw3MbGRrNt2zZTWVnZJ/hZuHBhn7Oyamtrh/RVcVNTk+nq6ur9PBQKac6cOf2evzV//ny/ubnZ7fm8pqbGnHHGGYPeq7a2tk/AtmDBgrH9p3+jJBgMKicnR+3t+/9VXywW09atW5Wdna3c3NzeTja+aQGAwfN9X4lEQm1tbWptbT0kwAoGgwqPwtkYAABkOuv78ne19O2uamgalU6jIwoF94dVpcVyS0vkFE1LeXeVjcWSIwAPPLOqabvs3taBbx5FZvIkaZDf4vG9IAAAwMAIscaRKVOmaMqUKbalpaX3K93GxkansrKyT/BzzDHH9Amctm3b5kSj0UG/qbd27do+wVJlZaUfPMw3HAsWLPCXLVvWG2KtWbNmSF1f69ev73P9wbWPZ0VFRaqpqVEikeh9zFqr9vb2PuEWACA1jDEqLS3lDSEAwFHPxuPJ0Kahp7uqUV5TsxQb8EjglDK5OXK6gyq3pFhOabGcgqkyzpCHgQxJxy9/pcSGjVIa53iY/Dw5xdPlTp8up2ha8vyu6dNk+Mc0AAAAKUWINc4Fg8FDvmwvLS21RUVFvWP+otGoXn31VffMM88cVJfTCy+84B74+QknnHDYYOmEE07wJPUmXH//+98DkmKD2Scej2v58uV99nrLW95y1IRY4XBYs2bNUm1traJjfRgyAEwwxhiVl5crOzs73aUAAJBStqMjGVZ1d1Z5DU3yd+yQ/LFNcJyCqd2BVbGcntAqP3XnUNpEQrJ2UB1bJhIeswDL5Ob0CauSH0+TycoamwIAAAAmOEKscaS1tVW7d+/u88/Li4uL+/3S/eKLL0788pe/7P3q/4knnhh0iPX000/3+XNx6aWXHvaf81166aWJz372s72fv/zyy25bW5tyB3GI7bJly9yOjo7ez+fNm+cfPApxvAsGg6qoqFBjY6P27Ru7GewAMJEEg0GVlpYSYAEAxjVrreyevd3dVfvPsLJ79o5tIa6bDGpKegKrYrklxSntMPJ27JTf1Cy/eYe87lGA/s4WRd77LoVOOWnA+52i1B9abrKz5BRNl1M0XW7RtN6PnRy+vgAAAEgnQqxx5OGHHw70nIclSYWFhba0tLTfEOvd7353nxDrf//3f0O33nprzBlgrMOmTZvMgeMBg8Gg3vWudyUOd31FRYU94YQT/JUrVzqS1NbWpl//+tfBf/3Xfx1wjsXPf/7zPv/E7kj7jGeu62rmzJnyPE/t7e1qa2tTW1ubPO+oOP4LANIiFAopLy9P+fn5CofDjBAEAIwr1vPk79jZPQpw/xlW6uwa+OZUioS7w6qS/V1W0wplAqP7VkHXb/8kr7b+kMf9pu2Dut8pmjb8zSNhuT0BVdG03o9Nbg5fTwAAAGQgQqxxoqOjQ1//+tf7/NO3d77znQnXdfu9/uKLL07MmDHD1tfXG0mqrq42d999d/Daa689Yrh0yy23hA8Myi677LLE5MmTj1jbRz/60dj1118f6fn8jjvuCF199dXxrCOMV1izZo3z+9//vjfEchxHH/vYx8Z2gPsYc11X+fn5ys/Pl5T8l5a+7+vAX28AwJEZY+Q4Dm8yAQDGDRuNymvanjy3qmcsYFOzlBjbf9RmJuUnQ6ru0MotLZaZMjkl/01NntG1Q2ZyvpxBTOVwiqb3G2J52wcXYrmD6cQKhQ4IqQ4Iq/Lz+DoCAABgHCHEGmM33HBD+AMf+ED89NNPH/TYvF27dun9739/9qZNm3rbqFzX1Q033HDYs6cikYhuuumm6Gc/+9necOmmm26KnHHGGd5xxx3X79733ntv4Ne//nVvsOS6rr7xjW8MeJjTJz/5yfidd94Zrq2tNZK0adMm5/Of/3zkpz/9aVd/nV979+7VNddckxWL7S//gx/8YPxwdR2tjDE6XAgJAAAAYPzx29p6z63qGQno79w1Zuc3SZKMkTOtsLezyi1JjgR0cnJGvHTvyMPGZvlNzfKamuU3Nne/RqvI+y5V6NSTB1zncJ1UfvOOQdVhpkyWggEpnpCCATnTp8mdnjyvKjkOcLrMpHyZASaRAAAAIPMRYo2xp556KvBf//VfoSVLlnjvf//7E+eff35i8eLFfigU6nOd7/tav36988ADDwR+/OMfh3bt2tXnn4p99rOfjZ1wwglHDH2uvfba+E9+8pPQunXrHEnavXu3zjrrrOw777wzevXVV8eD3Qfm7tq1S9/97nfD3/nOd/oU8fGPfzw+mDOqwuGwvvWtb3V96EMf6m29+tnPfhbcuXOn+fa3vx1dsGBB7xpPPvmke8MNN0RWr17d+91Ebm6ubrvttgHDMgAAAADIBNb3ZVt2y+s+t6pnJKDd1za2hQQDcouL5HR3Vrmlxcluo4O+vxyO3g6ypub9oVVjsxQ9/LduflPzoNY+XCeVbd0n29Epk334qR6SZBxH2R+5Ss6kfJmpUwirAAAAjmKEWGmyfPlyd/ny5a6kcCgUUmlpqZ00aZINhUJ23759pr6+3tm3b1+/91599dXx7373uwOGPqFQSL/73e863/72t2fv3r3bSNLu3bvNxz72scjnPve5SGVlpd/V1aWqqionHu87yW/JkiXe9773vUEPZL/66qsTy5Yti9911129nVx/+tOfAg8++GBg5syZtrCw0NbU1JiDwzjHcXT33Xd3zpkzh5l6AAAAADKO9X35u1rk1zfIq2uQV98or6FRih52MMaoMDnZye6qA86wcgoLRhzgWN+X37JbfuP+ziqvqVm2ZfeQ1/IaBxdiOUcYB+ht367ArIoB1wjMqRx0XQAAABi/CLEyQCwWU1VVlZF0xMHc+fn5uv3227s+/elPx/sb09efRYsW+U899VTHe9/73uyampre9dva2rRq1ap+Fzn33HO9P/zhDx3Z2dlDeRn6yU9+0hWJROwPfvCD3n/2Z61VbW2t6Rk1eKDs7GzdfffdnR/84AcTQ9oIAAAAAEZBb6BzYGBV3zD2gdXUKd1hVXH3WMCSlJzlZDs6kt1V3UGV19Qsv2m7FE/N8cReU7OstQPWafLzZLKzZLKz5RRN6x0B6BRNkzOtMCW1AAAA4OhAiDXGfv3rX3c+9NBDgaeeeirw2muvua2trUe83hijRYsW+VdddVX8ox/9aLyoqGjIHUsnnXSSv2rVqrbbb789fPfdd4d27+7/X9TNnTvX/7d/+7fYtddeO+iQ7ECu6+r73/9+9NJLL03ceuut4RdffLHfA59CoZDe9773xW+//fYoHVgAAAAA0sFamxwJeHBg1TWGk84dR07RtGRnVXdo5ZYWy0QiA997BNbz5O/cdWh31d4jf/85Yp1dsq2tMpMmHfEyY4xyb/6CDGcEAwAAYACEWGNs0aJF/qJFi2L//u//HvM8Txs3bnQ2bdrkVFdXm9bWVhOPx5WXl6dJkybZyspKf8mSJd6kAb4BGIz8/Hx95zvfid5+++3Rv//97+6qVaucXbt2Gdd1VVpaak8++WRvoDO2Bmvp0qXe0qVLO2pqasyLL77oVldXO11dXcrLy9P8+fP9s846K5GK1wQAAAAAg2Gtld2959DAqnPQE9RHLhw6oLuqRG5JsZyiaTKBkX1b7re19Q2rGpvlb98heV6KCh+CYEB+yx45g/h+jwALAAAAg0GIlUau6+qYY47xjznmmJSER4MRCoV09tlne2efffaof0dTXl5uy8vLGRUIAAAAYMxYa2X37D0gsGqQX98o29E5ZjWY/LxkSFXa011VIjNl8sjPr4rHFX9zjfym/aGVbWtPUdVDY6ZMlltcJKekqPdnp2DqiF8jAAAAcCBCLAAAAADAuGStld3bemhg1d4xNgUYySks6O2s6jnDysnNHZ39HEddf/yz5I3Zv4OUQiG5JUVyiov2/1w8fcQjDwEAAIDBIMQCAAAAAGQ8a61s677ewMqvT44FHLNOJGOS51fNKJU7s7Q7uCqSCYWGvaSNxeQ375DX1KzgCccNuJZxXTnTp8lvbB72nodfXHIKCvZ3VnWHVmbyJLqrAAAAkDaEWAAAAACAjOP3CaySZ1jZfW1js7kxcqYXJgOrGaVyZiY7rUYSWEnJcYCx51/qHQXo79ol2eRzbnGR3LIZA67hFheNPMTKiiQ7xw4cB1g0bcSvDwAAAEg1QiwAAAAAQFr5+9qSowDrkt1VXn2DbOu+sdncSM60ZGDlzCiV2xNYhcOp38t1Ff3bC1I8fshTXlPzoEIsp6RIemOQ+zmOnGmFfc6tcouLZPLzZIwZYvEAAADA2CPEAgAAAACMGb+tPTkK8MDAam/rmO3vTCtIhlUzSuXOKJE7o2RYgZX1ffm7WuQ3Nstralb4rDMGPCfKOI7c4unyausPeW6w3VVucVH/a+flHnRuVZGc6YUyAb7tBwAAwPjFV7MAAAAAgFHht3d0n13VIK+uO7Das3fM9ncKpx4aWA0QNPXHxmLyGpvkNzQlg7emZvlN26VEoveawPw5CsyqGLimkqJ+QyyvaXAhllNSJKf0gFGAJcVyiqfLyc0d/AsCAAAAxglCLAAAAADAiNmOjt7Oqp4uK7t7z5jtbwqm9J5h1RtYZWUNeR2/vUN+Q6O8hkZ5DU3yGxrl79x/dtVh72tslgYRYrnFRTp0mKDkNTbJWjvgmD8nL0+5n/vkgPsAAAAARwNCLAAAAADAkNjOzkMDq5bdY7a/mTr50MAqO3tIa1hrZffulVffJK+hMdll1dA47NGGg+6k6m8cYDAot7BAikalYXSKAQAAAEcrQiwAAAAAwGHZrq4+gZVf3yh/V8uY7W8mT0qGVTOTgZUzo1ROzhADK9+Xv3NXb1DV02FlOzpTVudQzrQKLFrYe36VW1wkM3WKjOOkrBYAAADgaEGIBQAAAACQJNlo9NDAaueuMdvfTMo/NLDKzRnSGjaRkN+8XV73+VV+Q/IMK8X6G+KXOl5Ts6zvDxhGmewsZX/on0a1FgAAAOBoQYgFAAAAABOQjUblNTYlw6rukYD+zp0Dnv2UKiY/rzewcmaUyJ1RKicvd0hr9L6G+v3jAP3mHZLvj1LV/TBGTmGBnJIiKRZjHCAAAACQQoRYAAAAAHCUs74vf/sOebX18mrr5NXUy2/eLtmxSaxMXu7+wKqnyyovb0hr2FhMXlVNn3GA/q6WMQvdJEmhkNzSYrmlxXJKiuWWFMspmiYTDI5hEQAAAMDEQYgFAAAAAEcZf98+eTXdgVVtvby6eikaG5O9TW5OsquqO6xyZ5bKyc8f8bp+y251/OK+FFQ4OCYnO9khVlqSDK1KS+RwdhUAAAAwpgixAAAAAGAcs/F48hyrnsCqpk52z94x2TsZ9Ow/w8qdWSqTny9jzKDut74v27JbTmHBgNc60wqlgCslvJGWfQgzZXJ3h1WJnO6fTX7eoF8HAAAAgNFBiAUAAAAA44T1ffm7WuTV1PWOBvQbm8fkDCiTnXVoYDVp0uADq0RCfmNzn3GAXlOzlPCU9/Uvy4RCR97fdeUUF8mvaxjBizByphX2dla5M0rklhTLZGcNf00AAAAAo4YQCwAAAAAylN/e3h1W1fcGV+rqGv2NsyK9Z1i5M0rkziiVmTJ5RJ1J/p69av/xz/p9zmtqVqC8bMA13NKSwYdYgWTodeA4QLd4+oBhGQAAAIDMQYgFAAAAABkg2anUJK+mXonaOnm1dbK7do/+xpHwoYHV1CmDDqz8tnY5uTkDXudMnSKFQ/2ezeU3NEmDCrGKFe/viUhYbskB4wBnlMiZVijjuoN4BQAAAAAyFSEWAAAAAIwxa61sy+4DOqzq5DU0SV7qz3vqw3GSIU/ZDLllM+WWzZBTMFXGcQZfc0OTvIbG5DjAhibZfW3Ku+VLMllHHslnHEduSbG8qppDnvPqGwdXfmmJTF7u/s6q7i6roYRuAAAAAMYPQiwAAAAAGGW2s1NeXcP+wKq2Xra9Y9T3NVMm7w+symcmA59gcOB6PU/+jp3y6hvld4dWXmOT1BXt93qvoUmBOZUDruuWHibEahhciOWWzVDezV8Y1LUAAAAAxj9CLAAAAABIIet58pu2J8Oq7nOs/B07R3/jcKhPh5VbNlNOXu7A9cZi8pq293ZWeQ2N8puapcTgu8IGG2I5pSX9Pu7v2CnreQOO/6PbCgAAAJhYCLEAAAAAYJistbJ7W/sEVl59gxRPjO7Gxsgpnr4/sCqfmTwDaoCxgDYWk9fYJK+2QX59Q7LTasdOydoRleMPtpOqtFgKBuQWF8mZsX8coFM0nfOrAAAAAByCEAsAAAAABslGo8mxgLV18mrq5dXWye5rG/V9TX5e90jA7k6rmaUyodCRa/U8+U3N3fUmwzW/ebvkjyyw6s9gxwE6xUXKu/XLBFYAAAAABoUQCwAAAAD6YX1f/vYdyQCo+ywrv3nHiLuWBhQMyp1ZmjzDqmcs4KT8gWvdsTMZWNXVy6trkN/YNKSRgCPh79gpG48PeN7WQJ1iAAAAAHAgQiwAAAAAkOTv29fbXeXV1Mmra5BisdHd1EjOtGm9IwHdsplyiqYdsVPJWivbsrtPYOXVN45+rQfWXFAgp7R4/zjA0pIBAywAAAAAGCpCLAAAAAATjo3H5dU39nZYebX1snv2jvq+JjenT2DlziyViUQGvM/fs0exl19LdljVN8h2dI56rZIk15Ezfbrc7sDKmVEit6RIJhwem/0BAAAATGiEWAAAAACOatb35e9q6RNY+Y3Nku+P7sYBN9mp1BNYlc2QmTJZxpghL2W7ooo9u2wUijxAKCi3JNlV1RtaFU2TCfBtIwAAAID04LsRAAAAAEcVv739gHOs6uXV1ktdXaO+r1M4NRlWdZ9l5RQXHTEAstGovOYdCpTPHHjt6dOkUFCKxVNTbDgkd0Zp8uytGSVySkvkFEzlzCoAAAAAGYUQCwAAAMC4ZRMJ+Y1NSvQGVnWyu3aP+r4mO0vOzBkKdAdWbtkMmezsI9bp1TfK7znHqr5B/o6dkozybr1pwPF8xnHklpbIq6oZerGBQLKzamapnJkzkj8XFhBYAQAAAMh4hFgAAAAAxg3b2alEda286lp5VTXJLqtEYnQ3dR05JcXdXVYz5JbNTHYtDWEsoN2zVx3/9+f9PSOvvlGB2bMGLmPmjIFDLMeRUzw92WHVE1gVTZdx3UHXCgAAAACZghALAAAAQEay1sru3qNEdY28qmRo5W/fLtnR3ddMmdw7EtAtmym3tFgmGOy/Rt8fVEeTKZgqRSL9jjX06hoGF2KVlR60qORMK0yGVTNK5ZSVyi05fK0AAAAAMN4QYgEAAADICNbz5Dc2d4dWNfKqa2Vb943upuGw3LLSZFhV1n2WVV5u//V1h2peXb28uobkj/pG5X3pepnsrCNuY4yRO7NU3uathzzn1TcMqlS3bKYCxy/qc5aViUQGdS8AAAAAjEeEWAAAAADSwkaj8mrqlKiqkVddI6+mTorFR29DY+QUF/WOBHTLZsiZVnjYTiq/dd8BgVW9/LoG2Y7OQ67z6hsUmDdnwO0PG2LV1Q+qfGfqFGVf+f5BXQsAAAAARwNCLAAAAABjwt+7NzkWsLpGiaoa+Y3Nkh292YBmUv7+kYBlyfOhTCjUf23tHfLrG3oDK6+uYdBdYF5d/SBDrBn9P9HZJRuLHbY2AAAAAJioCLEAAAAApJz1ffnN2+VV1yY7rapqZPfsHb0Ng8HkiL0DzrJyJuX3X1s0Kq++sc9YQNuye9hbe3WDHQdYKoVCcmeUJGud2R2sTZ0iY8yw9wcAAACAoxUhFgAAAIARs7GYvNr6/aFVTa3UFR21/UxertxZ5XIryhWYVS6npEjGdQ+tKx6X19gs/4DAyt+xQ0phA9hgQyyTn6+8W2867PhCAAAAAEBfhFgAAAAAhszf15Y8x6qqVonqGvn1jZLvj9p+TtG0PqGVmTL5kO4l63nJ7q+6/WMB/abto1qXJNm9rfL37ZOTl3fE64wxEh1XAAAAADBohFgAAAAAjshaK3/HTnndYwG96lr5u1pGb8NAIDlub1a53FnlCpTPlMnOPrSmlt3yauqSP+rq5TU0SYnE6NV1AGdaodyZpXK6xwKarKwx2RcAAAAAJhJCLAAAAAB92EQi2clUvT+0sh2do7afycmWW1Eud1ZZMrgqLZEJ9P1Wxcbj8uob5FXXyauplVdTJ7uvbdRq6lPflMndZ1h1n2M1o0QmEhmTvQEAAABgIiPEAgAAACY4v71DXnXt/tCqvkFKeKO2n1NY0D0aMBlaOYUFh4wG7FPfzl1q+68fS97ojgWUus/amlkqd0apnLIZyZ9zc0Z9XwAAAADAoQixAAAAgAnEWiu7q0WJ6truLqsa+dt3jt6GriN3Run+0KqiTE5u7pCWMFOnSIGA5MVSW1tW5IDuqlK5ZaUy+flHDNQAAAAAAGOHEAsAAAA4ilnPk9/QqETV/tDKtrWP3oaRiAKzypLjASvK5JbNkAkG99djrfw9e3rHAoYvPE8mHD7iksZx5JbNlLd56/DrCgXllpYkA6uyZKeVKZhKYAUAAAAAGYwQCwAAADiK2K4uedW1+zutauukeGLU9jNTJytQUZ7stJpVLmdaoYzj9K0pkVDspVf2n2XVuq/3ucCxCxWYUzngPm75EEIs15VTUpQMrGaWyi2b0W9dAAAAAIDMRogFAAAAjFPWWtk9e+VV1yhRVSOvqlZ+c7NkR2lDx8gpKVZgVnmy02pWmZz8/EHc5yj67PNSZ9chT3k1dYMLsSrKDr/89EK5ZTPlls2QO3OGnOLpMgG+1QEAAACA8Y7v7AAAAIBxwvq+/Mbm/aFVda3s3tbR2zAUklsxc3+nVdmMPqP/bCIh63kyrnvEZYzjKFA+U4kNmw95zqupHVQpgbKZyQ/CYbnlM+SWlylQPlNu2UyZ7KzBvyYAAAAAwLhBiAUAAABkKBuNyqutl1dVo0R1jbyaOikaG7X9TH6e3FnlvZ1WTvH0PgGVv7dViY2be8+z8uoblf2RKxWYN2fAtd3yssOEWHWy1g54NpXJzlLOv31GTsFUxgICAAAAwARBiAUAAABkCL+1VV5VbW9o5Tc2Sf4ozQY0klNUJHdWWW9oZSZP6g2TbCIhr76x9xyrw3V9edW1gwyxZvb7uG3vkN3VIlNYMPAa0woHvAYAAAAAcPQgxAIAAADSxN/bKm9rlRJbtimxrUp21+7R2ywYSJ4bNatcgYoyueUzZbL2j+HzW1uVWL1uf2hV3yAlvAGXTdTUKTzgVZJbNkMy6nNelzOtQG552agd4QUAAAAAGN8IsQAAAIAx4rfuS4ZWW6vkbd0mf2fLqO1lcnPkdp9lFZhVJqe0pHc0oE0k5Dc2KdEzFrCmTnbP3mHt49XUyfr+gCP+TCSi4JKTuusqk1s2U05O9rD2BAAAAABMDIRYAAAAwCjx97XJ21alxJbu0GrHrlHby5leuD+0qiiTKZjaOxrQb92nxLoNvWMBvfpGKZFIzcZdXfJ37pI7fdqAl2Zd/u7U7AkAAAAAmBAIsQAAAIAU8dvaDwitquRv3zE6G7mu3JmlcrvPsnIrynq7mqznyW9oUvyll/efZTXMLqvB8qprBxViAQAAAAAwFIRYAAAAwDD57R3ytlXL27pNiS1V8pu3j8o+JjsrOYKvu9PKnVEiEwwma9i3T962asV6zrKqa0hdl9VhOIVT5ZYnz9Vyy8vkFE8f1f0AAAAAABMTIRYAAAAwSLajU4me0GprlfymZsmmfh9TMEWBnsBqVrmcwgIZx0l2WTU2Kf7K60r0nGW1e0/qCzhQMCi3bEYyRCufKbd8ppycnNHdEwAAAAAAEWIBAAAAh2W7upTYWi1va5USW7fJb2waldDKmVYgd3alArNnyZ1dIScvr8/z0WefV2LDZnn1DVJ8dLusTMEUBQ7qsjKuO6p7AgAAAADQH0IsAAAAoJvt6lKiqqY7tKqSX98o2dSnVk7hVLmzZykwuzIZWuXnH/F6r6pGXlVNyutQMJg8W+vALqvc3NTvAwAAAADAMBBiAQAAYMKy0ai8qholekOrBslPfWhlpk5RYPYsBeZ0h1aTJsnG45Lvy4TDA97vlpcpsWFzauoon9kbWjnFRXRZAQAAAAAyFiEWAAAAJgwbi8mrrlViyzZ5W6vk1TVIvp/yfcyUyd2jAWcpMGeWnMmTe/eOvfyavG3V8mrrFH7H+Qq//YwB13MryoZeRDAgd+aM3rGAbvlMOXl0WQEAAAAAxg9CLAAAABy1bDyeDK22Vsnbsk1eXb3kjUJoNSm/u8tqlgKzZ8mZOqXP850PPaL4y68dEph526qlwYRYZTMkY4442tBMnSy3vCzZaVVeJqeELisAAAAAwPhGiAUAAICjho3H5dXU7Q+tauslz0v5PiY/r09oZaZOkTHm8NdnZ/fb8eVV1cj6vozjHHm/cFhO0XT5Tc3JBwKBQ8+yyssb0WsCAAAAACDTEGIBAABg3LKJhLyaOnndZ1p5NbVSYhRCq7zc7tGAlcnQqmCqbGurbDQmp2DqgPcHKisU66/+jk7523fILS4acI3Q206TjcUU6OmyCvClPAAAAADg6MZ3vgAAABg3bCIhr65e3pbu0Kq6VkokUr6Pyc3pDa3c7tBKu/cosa1a0WeeV6KqWrZljwLHzFf2h68ccD23fKbkOv2OMvS2VQ8uxDrlpGG9FgAAAAAAxitCLAAAAGQs63ny6hrkbd2WDK2qaqV4POX7mJzs3tGA7pxKmcIC2R075W2rVvSpv8nbVi3buu+Q+xLbBjkOMBSSO3NGMnQ7iFdTJ7311JS9FgAAAAAAjhaEWAAAAMgY1vPk1Td2jwfcJq+qRoqNQmiVnSW3cpYCc2YlO62mFco2NSc7rR5/OnlWVXvHwAt1dclv2i63tHjAS93KCnnVtd17V8itrFCgskJOycD3AgAAAAAwERFiAQAAIG2s78tvaFRiS1Wy22pbjRTr7/SoEcqKKFA5q3tE4CyZggL5jU3JTqu/PqlEVa0UjQ5raW9b9aBCrNBpSxR8y/FyphUO2LkFAAAAAAAIsQAAADCGrO/Lb2xKjgbcUqXEtuphh0dHFAkrUFkhd3Zld2g1VX5dg7xt1er6y+PyamqleGrO0kpUVSv0ttMGvM6ZMjkl+wEAAAAAMFEQYgEAAGDUWN+X37Q9ORqwJ7Tq6kr9RuHQ/tBq9iyZqVPk19Ypsa1aXQ89Kq+uXvL81O8ryba1j8q6AAAAAABMdIRYAAAASBlrrfzm7Ups2SZva5W8bdWyHZ2p3ygUlDurQoE5sxSYXSkzOV9eTb28bdXqfPAv8usbJWtTv6+RnOLiZGBWWSG3slxObm7q9wEAAAAAAIRYAAAAGBm/vV3epq1KbNqixKYtsq37Ur9JMCh3VrkCc5LnWpm8vGSn1dZqdf7+IfnN21O/pyQ5Ru6M0u7AqkKBWeUyWVmjsxcAAAAAAOiDEAsAAABDYj1PXk2dEhs3K7Fpi/z6BinVTU/BgNyKcgVmz5I7Z5ZMdra8mjp526oVX/6G/J0tKd6wW8CVWzYzGVhVVsgtnykTDo/OXgAAAAAA4IgIsQAAADAgv2V3MrTauEWJLdukaDS1GwRcueVlCsyplDt7ltyyGTKB5JeqiU1b1P5/f5Ta/XqEgsmwrGc84MxSmWBwdPYCAAAAAABDQogFAACAQ9hoVImtVUps3CJv0+bUdz65rtzymXJnz0oGV2UzDhseuWUzJGNSc8ZVJKJAZXlvp5VTWiLjuiNfFwAAAAAApBwhFgAAAGR9X35Tc7LTauNmedU1kuenbgPXSY7pmz1LbmWFTCAgr6FRoTNOkzHmiLeaSEROabH8+sYhb2tyc7rPsqqQO7tCTtF0GccZ7qsAAAAAAABjiBALAABggvLb2pTYtEXexi1KbNoi29aeusUdsz+0mlUuOY78unoltlYr9sI/pFhMkhSYN0fu9GkDLheorFBsECGWmZSfHA3YHZY5hQUDhmQAAAAAACAzEWIBAABMEDaRkFddq8SmZLeV39CU0vXN1MkKzJurwPw5CsyplIlEkvtGo9r39f+Q/EPHAXrbqgcVYrmVs6QX/nHI407B1ORZVt3jAc2UyYRWAAAAAAAcJQixAAAAjmL+zl29oVViS1VvB1RKhIIKzK5UYP4cufPnyimY2m+AZMJhOaUl8usaDnkusa1aodOWDLiVO6tcMkbO9Gm9gZVbWS4nPz8lLwUAAAAAAGQeQiwAAICjiO3qUmJLlRKbNiuxcYtsy+6Uru+UFMudN1tu0XTZri4FTzhOTm7ugPcFKisU6yfE8rZWyVo7YPeUk5OtvK99USYra9i1AwAAAACA8YUQCwAAYByzvi+/oVGJjcluK6+mTvL9lK1vcnMUmDdHTtnM/edavblG8T0vJZ/PzlLoLScMuI5bWSEt+/uh9bfuk929R2bqlIFrIcACAAAAAGBCIcQCAAAYZ/zWfb0jAr3NW2XbO1K3uOvIrSiXO2eWTFa2/N275W3eqvgbb/Z7ubdpqzSIECswq/zQB4MBueVlsl3RkVYNAAAAAACOQoRYAAAAGc4mEvKqapLnWm3cIr+pOaXrOwVT5cybLXfqVNloVN62asWeWSZ53oD3JjZvHdQ4QJOdLXdWuUw4LLeyIvljRolMgC9HAQAAAABA/3jXAAAAIMNYa+Xv3JXstNq4RYmtVVI8nroNwiEF5lTKmVEqI8lrapb35holOjqHXmvrPvnbd8gtmj7gtTmf/NgwigUAAAAAABMVIRYAAEAGsF1dSmze2nu2ld2zN3WLG8kpLZFbWSETicjubVViy1Yl1m5IyfKJzVsHFWIBAAAAAAAMBSEWAABAGljfl1fXIG/jZiU2bZFXWyf5NmXrm7xcuXMq5UyeLBuLyauuUfzFf0ip20IyRs7MUpnsrBQuCgAAAAAAkESIBQAAMEb8va3Jc602bZG3eavsMMb3HZbryplVJreoSHKM/KbtSqxeJyUSqdtDyfOz3LmzFZg3W4HZlQRYAAAAAABg1BBiAQAAjBIbj8vbVp0cEbhps/zmHSld35lWILesTIqEZVtb5W2rVnxLVUr3MNlZydCq+4czdUpK1wcAAAAAADgcQiwAAIAUsdbK376jN7TytlanthMqEpY7q0JOfp5sPC6/tk7x11ekbn1JCrhyZ1UkQ6t5s+WUFMs4Tmr3AAAAAAAAGARCLAAAgBGwHR1KbN7aHVxtkd3bmrrFjeTOnCFTWiLF4/K375C3YZM8m8KDrYzklJb0dlq5s8plgsHUrQ8AAAAAADBMhFgAAABDYD1PXl29Ehu3yNu4WV5dg5TCUMnk5ykwf64C8+coMHe2THa2YsvfUNfvH0rdHpMnKTBvjgLzZsudUyknJydlawMAAAAAAKQKIRYAAMAA/D17kp1WGzcrsXmb1NWVusUDAbmVFcnQav5cOdOnyRjT95J5s0e2RySiwJxKBeYlu61MwdRD9gAAAAAAAMg0hFgAAAAHsYmEvG3VSqzfqMTGLfJ37Ezp+qawQO60ApnsbEUuu2TA8X3OpElyphUOvg7XkVtR3htaOTNKOdcKAAAAAACMO4RYAAAAkmxXlxIbNim+doMSGzZJXdHULR4Jyy0tkcIh2X1t8hsaldi5S5IUvnjpoM6gCsybrdgRQiynuCh5rtW82XIrK2RCoZSVDwAAAAAAkA6EWAAAYMLy9+xVYt0Gxdeul7e1SvL81CxsjNzymQrMmyN3/lyZnGy13/GDfi/1Nm+Tc+LiAZd0586WXnpl/xb5eQecazVbTl5uamoHAAAAAADIEIRYAABgwrDWym9sVmLtesXXbZBf35iytc3kSclzrebNVWBupUxWVp/nnYKp8ne1HHJfYvNWBQcRYgVmz1Lg2AUKzJ0td+5sOdMKOdcKAAAAAAAc1QixAADAUc16XvJ8q7XJjiu7Z29qFg64coqmK3DcsQouWjhgqOTOnd1/iLVpi6y1AwZSJhJR9jX/POKyAQAAAAAAxgtCLAAAcNSxXV1KbNyS7Lhav0nq6krJumbqFDl5ubLRmPwdO+TXN8o950y506cNeG9g3mzFX15+aK17W+Xv3CV3WmFKagQAAAAAADhaEGIBAICjgr+3df/5VluqJM8b+aLBoJxpBZKM/F0tsi275bXs7nNJYtNWBRcvGnCpwOxKyRjJ2t7HTF6uAnNn93kMAAAAAAAASYRYAABgXLLWym/ersSa7vOt6hpSs3B2lpz8PNn2Dtl9bfIbmo54eWLz1kEta7Kz5M6eJRMIyJ07W4F5s+UUTedcKwAAAAAAgMNIS4hVVVWVke/WlJSU2HA4nO4yAADAYVjPk1dVkzzfat162ZY9KVnXTMqTCUfk79kjdXTK7+gcfE0tu+XvapFTMHXAa7M/fg2hFQAAAAAAwCClJcSaPXt2bia+gfPYY491XHDBBSmYPQQAAFLFRqO951slNmySHULAdFhGMlOmSNbK7tkru3efrPYNe7nE5q0KDSLEysSvfwAAAAAAADJV2sYJ2gw7+4E3lQAAyBx+6z4l1m1QYu0GJbZslRIp+DcmgYDMpHypqys5KvCgs62Gy+Rky8YTKVkLAAAAAAAA+6UtxOoJjdIdZhlj0l4DAAATnbVW/vYdSqxdr/jaDfJr61OzcCQsk5Ul29YmxROyu1pGvmYgILeyQoGec62Ki2QcZ+TrAgAAAAAAoI+0hVg9zj//fK+kpMRP1/733XdfMF17AwAwkVnf73u+1a4UdUbl5kiOI9u6T+qKynZFR7ig5MwoTYZWc2fLrSiTCfLlAwAAAAAAwGhLe4j1xS9+MZrOc6juu+++IKMEAQAYGzYW23++1fqNqTnfSpLJy5NNxKXOLtm29pEvGA4pMH+uAgvnK7BgnpzcnJGvCQAAAAAAgCFJe4gFAACObv6+tv3nW23eKiVScH6U68pkZyVDMM+T3bdvxEuaqZMVXLhAgWPmy62skAnwZRIAAAAAAEA68e4MAABIOW/7jmRotXa9vNo6KRXHT4aCMsGgbHtHd3DVNrL1jJFbUabAMfMVWDhfzvRpojsbAAAAAAAgc6QtxLLWZswbRZlUCwAA45H1fXk1dckxgWs3yN+5KyXrOtMLFTh2oZzCAnX9/iHZWHxkC0bCyTGBx8xXYP48OTnZKakTAAAAAAAAqZeWEOvmm2/uPWF9zpw5fjpqyMRaAAAYT2wspsTmrcmOq3Ubkh1SI9XTHXXsAgWOXSi3sCC5l7WKPvGMbOvQxwY6BVN7u63cygoZ1x15nQAAAAAAABh1aQmxbrvttlg69u1PJtUCAECm89vak+dbrdugxKYtUjwF51sF3GR31LELk2P9cnMOucQYo8DC+Yq/8trA6zlGbkV5Mrg6ZoGcwgI6rgEAAAAAAMYhzsQCAABH5O3Yuf98q5ra1JxvFQhIxkjxuLKu+oCCxywY+JYjhViRiAIL5ip4zHwF5s+VyWZMIAAAAAAAwHg3IUOsvXv3atKkSekuAwCAjGR9X15t/f7zrXbsTM3C4VCyc8v3pcT+Di5v09bBhVhzK5PhV/e9zrQCBRYmu63cijLGBAIAAAAAABxl0hpidXV1KRKJjOmeu3bt0gUXXJDz+uuvt4/pxgAAZDAbj/c936otBf+ZNJJbvv98q+iTzyrx5ppDLouv36DwpRcNOPLPhEIKnXWGTFYkGVx1n5cFAAAAAACAo1NaQ6x3v/vd2X/5y186QqHQmOy3c+dOc95552WvWbPGGZMNAQDIYH57uxLrNyU7rjZukeLxkS8aCCgwb/b+863ycvc/tXB+vyGWbdkjf/sOuUXTB1w+cuF5I68RAAAAAAAA40JaQ6ynnnrK/cAHPpD1hz/8odMd5RFAjY2NZunSpdnr1q1zONwdADBR+btaFO8eE+hV1Ug2BQdchUMKHndssuNq3hyZw/zjlMCCuclzsPrZM7F+46BCLAAAAAAAAEwcaT8T6+GHHw5cffXVkV//+tddo7VHXV2dOf/887M3b95MBxYAYEKx1sqvb1B8zXol1q6X37wjNQu7ruR5kiSnoEBZ779swFucnBy55TPlVdce9IQju68tNXUBAAAAAADgqJH2EEuSfvvb3wazsrL0i1/8IuVBVnV1tVm6dGn2li1b6MACAEwY3vYdiq9YpcTK1fJ3taRmUceRfL97A6/3Yb+hUf7eVjmT8gdcInDMAnnVtTLZWQosmKfAMQsUmD9HZozPyAQAAAAAAEDmy4gQy1qr//mf/wlmZWXZH//4x9FUrbt161azdOnSnKqqKnNggHXDDTfEUrUHAACZwt+zV/GVqxVfsUp+Y9PIFzTd/9Mz/q8nwOpHYv1GhU5bMuCSwbccL3dWudzymTIODdIAAAAAAAA4vLSGWDfeeGPsjjvuCBljZK3VT3/601AkEtGdd9454iBr06ZNZunSpTm1tbW9AZa1VjfddFPsW9/6VsqCMgAA0slvb1di1VrFV6xKnnE1UgeeWWV7/2dAiXWDC7GcSfmD6tgCAAAAAAAA0hpi/ed//me0s7NTP/rRj3qDrP/+7/8OZWdn29tuu23Y3VLr1q1zLrjgguyGhoY+AdZXv/rV6Ne//nW6sAAA45qNRhVfu16JFauU2LT1iB1Sg9InuBpcaHWwxOatsrGYTCg0sloAAAAAAACAbmkfJ/iDH/wg2tXVZe6+++5gT5D1rW99K5yTk6ObbrppyIHT6tWrnQsuuCC7ubnZ9KwnSbfddlv05ptvJsACAIxLNpFQYsMmxVeuVmLdBimeSOHiwwuuejjF0xU4ZoGU8CQyLAAAAAAAAKRI2kMsSbrrrru6Ojs7df/99/cGWTfffHM4Ozvbfu5zn4sPdp0VK1Y4F154YfbOnTv7BFj/+Z//Gb3xxhsJsAAA44r1fXlbqxRfsUrx1WulrgyZhuu6cudUKnjMfAUWzpczZXK6KwIAAAAAAMBRKCNCLEn65S9/2dXZ2Wn++Mc/BnoCqBtuuCGSnZ2tj3/84wMGWa+++qpz8cUXZ7e0tPQGWMYYfe973+v6/Oc/P+ggDACAdLLWyqutV2LlKsXfXCO7ry3dJUmSTG6OAguToVVg3myZcDjdJQEAAAAAAOAolzEhluu6+s1vftP53ve+N+uRRx4JGGPk+76uu+66SHZ2tr3yyisPOzfp73//u3PJJZfk7NmzRwcGWD/84Q+7PvWpTxFgAQAynte8PdlxtXK1bMvudJcjSXJKihQ4ZoECC+fLnVkq4zjpLgkAAAAAAAATSMaEWJIUCAT0hz/8ofOSSy7Jfvrpp11jjDzP00c/+tGsSCTS+b73ve+QIGvZsmXupZdemt3a2tobYDmOo5/+9Kddg+ngAgAgXfzdexRfuVrxFavkNzWnuxwp4CowZ7YCPWMCJ09Kd0UAAAAAAACYwDIqxJKkUCikP//5zx0XXXRR9rJly1xjjOLxuK666qqsP/7xjx0XX3yx13PtM88841522WXZbW1tvQGW67r6+c9/3nnNNdek8MR7AABSw29rU2LVWsVXrJJXXZvucmTycpMjAo+Zr8Dc2TKhULpLAgAAAAAAACRlYIglSVlZWXrkkUc6li5dmv3KK6+4xhhFo1FdccUV2X/5y186zj33XO/xxx93L7/88uyOjo7eACsQCOiXv/xl55FGDwIAMNZsV5fia9YrvnKVvM1bJd+mtR5nRokCC+creMx8OaUljAkEAAAAAABARsrIEEuScnNz9fjjj3ece+65OStWrHCMMers7NR73vOe7Jtuuin6zW9+M9zZ2dkbYAWDQd13332d73//+wmwAABpZ+NxJTZsUnzlaiXWbZQSI/jPUyCgwLELZEJhxZe/PvT7jeRWzlLw+EUKHLNAzqT84dcCAAAAAAAAjJGMDbEkadKkSXryySfbzz777Jy1a9c6xhi1tbXpq1/9atha2xtghUIh/eY3v+m87LLLCLAAAGljPU/e1irFV6xSfPU6KRod/mKOUWDeHAVOXKzgsQtlwmH5ra2Kv/a6NMhGLreiTMHjj1Ng8bFy8vOGXwsAAAAAAACQBhkdYklSQUGBnnrqqY6zzjore/PmzU5PcNXzcyQS0e9+97uOSy65xBt4NQAAUstaK6+mTomVqxR/c41sW/uI1nNnlSt44mIFjjtWTm5On+ec/Hy5lbPkba067P1O2QwFj1+k4OJFciZPGlEtAAAAAAAAQDplfIglScXFxfaZZ57pOPvss3OqqqpMT4CVnZ2tP/7xjx0XXnghARYAYEx5Tc3Jjqs3V8u27BnxeqGl5yi05EQ5kycf8brg8YsOCbGckmIFT+gOrgqmjrgWAAAAAAAAIBOkNcS65557gkO5/sorr4x961vfCkuSMUaXX355vL6+3rnnnnuGfCL9Rz/60fhQ7wEATGx+y27FV65WfMUq+c3bU7q2M2XygAGWJAWOO1b686NyphUmRwUev0jutMKU1gIAAAAAAABkgrSGWP/yL/8SMcYM+T5rk4eB3HfffcH77rtvSEFYD0IsAMBg+PvalHhzjeIrV8mrqRvZYnm5UjQmxWKHPJV4c7VCJ5844BJObo5yv/A5OVOnjKwWAAAAAAAAIMNlxDjBnlBqMIwx6gm+hnLfwWsAAHA4tqtL8dXrksHV5m3SMP97I0nKiii4+FgFT1gst7JC0UefVOyFvx9yWWLTVvntHXJysgdckgALAAAAAAAAE0FGhFhDMdzgCgCAI7HxuBLrNyq+YrUSGzZKiREctxgMKnDsAgVPWKzA/Dkygf3/uQ2esKjfEEu+r8SadQqdevLw9wUAAAAAAACOImkNsc4880yPrigAQLpYz5O3ZZviK1YpvmZdctTfCAQWzlfwxOMUOGaBTDjc7zXOzBkyUyfLtuzp87jJzZG8EQRnAAAAAAAAwFEmrSHW888/35HO/QEAE4/1fXk1dYqvWKXEqjWy7an5T5HJzVHWNf8k4zhHvs4YBRcvUuy5F2WysxQ47lgFj18kd/asAe8FAAAAAAAAJpJxN04QAIChstbKb2xWfOUqxVeult2zN/V7tLXL21atwJzKAa8NnXqyAnMq5c6plHHdlNcCAAAAAAAAHA0IsQAARy1/V4viK1crvmKV/O07Rn2/+JtrBhViOQVT5RRMHfV6AAAAAAAAgPGMEAsAcFTxW/cp/uYaJVaukldbP6Z7J1avlX33xXRXAQAAAAAAAClAiAUAGPdsR6fia9YpvnKVvC1VkrXpqSMald+8XW5pSVr2BwAAAAAAAI4mhFgAgHHJxmJKrN+o+IpVSmzYLHleegpxHAXmz1Hg+OMUPHaBTCSSnjoAAAAAAACAowwhFgBg3LCep8TmrUqsWKX4mvVSLJaeQhwjd06lgscfp+CihTLZ2empAwAAAAAAADiKpSXEqqqqMj0fl5SU2HA4nI4yMq4WAED/vJ27FH95ueKvr5Rt70hPEUZyK2cpePwiBY47Vk5uTnrqAAAAAAAAACaItIRYs2fPzjUmmR099thjHRdccEGaZkBlVi0AgP2s5ymxdr1iLy+Xt3lb2upwK8oUOH6RgouPlZOfn7Y6AAAAAAAAgIkmbeMErbXqCY/SLZNqAYCJzt+zR7FXXlf81ddl97WlpQZnZmlyVODxx8qZPDktNQAAAAAAAAATXdpCrEwKjTKpFgCYiKzvK7Fxs+L/WK7Ehk2StWNeg1NS1B1cLZJTMHXM9wcAAAAAAADQV9pCLAAA/H37FH/1DcVeeU12z94x39+ZXqjg8ccpcPwiudOnjfn+AAAAAAAAAA4v7SHWihUr3EAgvWUwThAAxo71fXlbqxR7ebkSa9ZLvj+m+zsFU5NnXJ1wnJyi6fz9DwAAAAAAAGSotKZH1lrddNNN4XTWYIyRTcPYKgCYaPz2DsVfW6H4K8vl72wZ1hrOzFIFTzlJsSeekW3vGPR9ZvIkBU/oHhVYWkJwBQAAAAAAAIwDaQ2xMiFA4o1MABg91lp5NbWK/2O54qvWSAlv6IsEgwqeuFih006WO3OGJMlvbFb8H68e8TaTn6fg4kUKnLBIbtlM/r4HAAAAAAAAxpm0hVjpDq96ZEodAHA0sV1dir/xpmIvL5fftH1YazhF0xQ6/RQF33K8TCTS57ng8Yv6DbFMbo4Cxx2r4PGL5M4ql3GcYe0NAAAAAAAAIP3SEmLdfPPN0XTsO5A5c+aM7cEsAHCU8eobFHt5ueIrVkmx+NAXMCY59u/0U+RWlB22e8qdVS6Tnyfbuk8mO0uB445R8Pjj5FZWyLjuCF8FAAAAAAAAgEyQlhDrtttui6VjXwBA6tlYTPE31yj2j1fl1zWMaC0zdYoiH3zfgKP/jOMo8s4LZbIicufOJrgCAAAAAAAAjkJpPRMLADB+ec3bFX/5NcVeXyF1pabB1u5qkVdVo0BlxYDXBk9cnJI9AQAAAAAAAGQmQiwAwKDZREKJ1esUe3m5vG3Vw1rDTMpX8PjjFHvh71I/5xLGX3ltUCEWAAAAAAAAgKMbIRYAYED+rhbFXnlN8eVvyLZ3DH0BIwXmz1PwtCUKLJwn4zjyd+5SYt2GQy6Nr1qjyKUXyWRnp6ByAAAAAAAAAOMVIRYAoF/W85RYv1GxfyyXt2nLsNYwuTkKnnKSQqecJGfqlD7PBU87+ZAQy+RkK3jyibK+1ZFPxQIAAAAAAABwtCPEAgD04e/dq9grryv+6uuyrfuGtYY7p1Kh05YocOwCmUD//6kJzJ8rMylfdm+r3LmzFTr15CNeDwAAAAAAAGBi4Z1CAICs78vbtEWxl5crsW5jv2dVDZZTNkM5//rhAa8zjqOs918mZ8pkOQVTh70fAAAAAAAAgKMTIRYATGB+W5viy99Q7JXXZFv2pGbN2np5O3fJLSwY8NrA3Nkp2RMAAAAAAADA0YcQCwAmGGutvG3Viv3jVSXWrJM8P+V7xF99Xe7FF6R8XQAAAAAAAAATByEWAEwQtqNTsddXKv7ycvk7do7qXvHlbyh8wbmcbwUAAAAAAABg2Hh3EQCOYtZaebX1ir+8XPGVq6VEYtT3NPl5Ci55i+R5EiEWAAAAAAAAgGHi3UUAOArZaFTxFasU+8dy+Y1No7+hMQosmKfgqScpsGCejOuO/p4AAAAAAAAAjmqEWABwFPEamhR7Zbnib7wpRWOjvp+ZlK/QKScpuOQtciZPGvX9AAAAAAAAAEwchFgAMM7ZeFzxN9co/vJyeTV1o7+hMQosnK/gaScrMH+ujOOM/p4AAAAAAAAAJhxCLAAYp7wdOxV/eblir62QOrtGfT8zedL+rqtJ+aO+HwAAAAAAAICJjRALAMYRm0gosXa9Yv9YLm9r1ehv6BgFjlmg0Kkny503h64rAAAAAAAAAGOGEAsAxgG/Zbdir7ym+PI3ZNvaR30/M2WyQqeepODJb5GTnzfq+wEAAAAAAADAwQixACBDWd9XYv0mxV9ersTGTZId5Q0dR4Fju7uu5s6m6woAAAAAAABAWo3bEGvXrl1as2aN29LSYvbu3Wt839dFF12UKCkpGe23eQFgVPmtrYq/+oZir7wmu7d11PczU6codOrJCp58opy83FHfDwAAAAAAAAAGY1yFWE1NTeYHP/hB6E9/+lNg48aNh7QIPPbYYx0lJSXewY//7Gc/C9bW1hpJKi0ttZ/85CfjY1EvAAyW9X15W7Yp9o/lSqxbL/mjnMe7jgKLjkl2Xc2eRdcVAAAAAAAAgIwzbkKsb3/726FvfOMb4VgsJmsPfXPXGHPYe9va2nT77beHjTFyXVfvec976NgCkBH89nbFl69Q7JXlsrt2j/p+TsFUBU89WcGTT5CTS9cVAAAAAAAAgMyV8SFWIpHQ5ZdfnvWXv/wlYK09JKwyxvQbah3o2muvjX/961+PtLa2yvM83XfffcEbb7wxNpp1A8DhWGvlVdco/o/liq9aK3mHNJAOLBRU8MTj5UyZrOjjTx/5WtdV4LgDuq6OEPoDAAAAAAAAQKbI+BDruuuuizz88MMBaX9gdcIJJ/hLly5NlJeX+5///OcjA62Rk5Ojd77znfHf/OY3QUn661//GiDEAjDWrO8rsXaDos88J7+haVhrOMXTFTptiYJvOV4mEpFNJBRb9pJsR+eh104rSHZdnXSCnJyckZYPAAAAAAAAAGMqo0Os5557zv35z38e7OkaKCgosL/4xS863/Wud/W2LXz+85+PDKar4LLLLkv85je/CVpr9Y9//MONRqMKh8OjVzwAdLO+r8TqtYo+87z8pu1DXyDgKrh4kYKnL5FbXtank8oEAgqefKJiy/6+/9rjjlXw1JPlVlbQdQUAAAAAAABg3MroEOuWW24JS8nRW/n5+frb3/7Wceyxx/rDWev000/vDb6i0ajWr1/vnHDCCcNaCwAGw/q+Em+uToZX23cO+X4zZbJCZ5yq4EknysnJPux1wVNPVmLDZgVPPVmhk46XyT78tQAAAAAAAAAwXmRsiNXS0qIXX3zR7ekiuOmmm6LDDbAkqby83E6ePNnu2bPHSNK6desIsQCMCut5iq9Ypdizy+Tv3DXsdYInn6jw288Y8Dp3WqFy/s+n6LoCAAAAAAAAcFTJ2BDr+eefD3hesnnKdV194hOfGPEZVtOmTesNsZqbm3m3F0BKWc9T/PWVij67TLZl94jXiy9/Q+HzzpJxnAGvJcACAAAAAAAAcLTJ2BCrvr7eSMk3ZisrK/0pU6aMeM1JkybZno/37dvHO74AUsImEoq/tkLRv70gu3vPkO4NLJgn5ecq8eobh667Z68Sm7YouGBeiioFAAAAAAAAgPEjY0OslpaW3pBpypQp9kjXDlY0Gu1dMxgMpmJJABOYjccVX/5GMrza2zr4G40UOO5Yhc87S25Jsfz2drW9/qbkeYdc6m0kxAIAAAAAAAAwMWVsiDUaXVM7duzoXWfatGkpCcYATDw2Hlfs5dcUe/5F2dZ9g7/RSIHjj0uGV0XTex92cnIUOO4YJVauTj4QCip4wmKFTj1ZzszSFFcPAAAAAAAAAONDxoZY06dPt5JkrVVtba3jeZ5c1x32etXV1aapqak3xCotLfVTUCaACcTGYor9Y3kyvGprH/yNxih44mKFzn273OnT+r0kdOrJ8nfsVOi0JQqecJxMJJKiqgEAAAAAAABgfMrYEOvEE0/sDZk6Ojq0bNky95xzzjl01tYgPfDAA73zA13X1RlnnDHstQBMLDYaVezvryq27CXZ9o4h3etWVijr8nfLKSw48nWzZyn3c58cSZkAAAAAAAAAcFRx0l3A4SxcuNCfNWuWNSbZPPW9730vNNy19u7dqx/84AchY4yMMTr55JO9/Pz8lNUK4Ohku7oUfeZ5tf3nfyv62FNDDrAkyXZ0ykydMuB1PX/XAQAAAAAAAACSMjbEkqSrrroqZq2VtVaPPPJI4Be/+EVw4Lv6SiQSuvrqq7MaGhqMtcljsK677rpYyosFcNSwHZ2KPvU37fuP/1b0iWdkOzqHvZbfvF2JdRtTWB0AAAAAAAAATAwZHWJ96Utfik2bNs0aY2St1Sc+8YnIt7/97VAikRjU/WvXrnXOPffc7EcffTTQ04U1d+5c/+qrrx7cAgAmFL+9Q11PPKN9//nfij71N6mrKyXrRp99Xj0hOgAAAAAAAABgcDL2TCxJys3N1V133dV1xRVXZPm+L8/z9JWvfCX8//7f/wt94AMfiC9ZssSTJGutjDFavny529LSYjZt2uQ8++yzgeeee87t6eSSpKysLN1///2djpPR2R2AMea3tSu27CXF/v6qFEtto6YzvVCht50mWSsxMhAAAAAAAAAABi2jQyxJes973pP4/ve/3/W5z30uIiUDq5qaGnPnnXf2OSPLWquvfOUr4YMf6zlnJhgM6u677+5csmSJP2bFA8ho/r59ij3/kmL/WC7F4yld2ykpVvi8sxRYtFCG4BwAAAAAAAAAhizjQyxJ+tSnPhWfO3eu/+EPfzirubnZ9ARTB4ZUPZ/36BkfaK3V9OnT7QMPPNB59tlne2NePICM47e2Kvbci4q9/Jo0yPGkg+WWz1TovLMUWDCvz99PAAAAAAAAAIChGRchliRdeOGF3rp169p+9KMfhf7v//2/ocbGRiPpsOfMWGs1efJk+9nPfjZ2ww03xCZNmjSm9QLIPP6evYo+94Lir74uJVKbabuzZyl83lly51QSXgEAAAAAAABACoybEEuSJk+erK985SuxL3/5y7E33njDef755wPr1693du3aZfbs2WOys7NtYWGhnTVrln/eeed5p59+uhcMBtNdNoA081t2J8Or5W9IXmonigYWzFXo3LMUmFWe0nUBAAAAAAAAYKIbVyFWD9d1tWTJEn/JkiWxdNcCIHP5u1oUfXaZ4q+vlPwUh1eLFip87llyZ5amdF0AAAAAAAAAQFLGhlh//vOfA1/72tfCPZ/fcccdXRdccAFnWgEYkLdjp2LPLlN8xZuS3//I0WExRoETjlP4nDPlFhelbl0AAAAAAAAAwCEyNsRavXq18+abbzqSlJWVpbe//e0EWACOyGveruizy5RYuVo6zHl5w+I4Cp50gkLnnCm3sCB16wIAAAAAAAAADitjQyzXdSVJxhjNnDnTj0Qiaa4IQKbympoVfeZ5JVatkVKYXSngKrjkJIXPfpucKZNTuDAAAAAAAAAAYCAZG2KVlpb2HmCTl5eXzlIAZCivoVHRp59XYs261C4cDCp0+hKF3n6GnHz+/gEAAAAAAACAdMjYEGvWrFm9/RTNzc0mnbUAyCxeXX0yvFq3IbULh8MKnXGqQmeeLicnJ7VrAwAAAAAAAACGJGNDrDPOOMMrKiqyzc3NpqGhwWzevNnMnTs3lYPCAIwziZpaxZ5+TokNm1O6rsnOUujMtyr01lNksrJSujYAAAAAAAAAYHicdBdwOK7r6p/+6Z/iPZ9/73vfC6ezHgDpk6iqVvvP/1cdP/l5SgMsk5uj8DsvVO6Xrlf4vLMIsAAAAAAAAAAgg2RsJ5YkffWrX40+8MADwaamJnP33XcHzzvvvMQVV1yRSHddAEaftVbe1ipFn35O3taqlK5tJuUrfM6ZCi55i0wwmNK1AQAAAAAAAACpkdEh1tSpU/Xwww93vPOd78zesWOHueqqq7KWL18eu/nmm6N5eXnpLg/AKLDWytu8NRleVdUM6V6npEhuRZni/1je7/OmYIrC57xdwbccLxPI6L/+AAAAAAAAAGDCy+h3cZ999llXkr7zne9Ev/SlL4W3b99u7rjjjtCPf/zj0EUXXZQ45ZRTvNmzZ/v5+fk2OMRuinPPPdcblaIBDIu1Vt7GzcnwqqZuSPc6M0oUPv9sBY5ZIHmeEus2yu5t3f/89GkKn/d2BRYvknHdVJcOAAAAAAAAABgFGR1inX/++dnGmN7PjTGy1qq9vV1//OMfA3/84x+HVb8xRolEYl/KCgUwbNZaJdZtVPSZ5+TXNQzpXrdshkLnn63Agnnq/bsiEFD4nDPV9dCjckqLFT7vLAWOXSjjZOwRgAAAAAAAAACAfmR0iNXDWtv7BvWBoZa1Nl0lARgh6/tKrN2QDK8amoZ0r1tRpvD5Z8udN6fP3wk9gkveIjN1igLz5/b7PAAAAAAAAAAg82V8iNUTVBFYAUcH6/tKrF6XDK+atg/pXjN1irIuf7fc2bOOGE6ZYFDBBfNGWioAAAAAAAAAII0yOsS6+eabo+muAUBqWN9X4s01ij7zvPztO4a3SCIht3wm3VUAAAAAAAAAMAFkdIh12223xdJdA4CRsZ6n+MrVij3zvPydu0a2Vus+xV9bodDpp6SoOgAAAAAAAABApsroEAvA+GU9T/E33lT02edld+0e0r3u3NnytlVLnnfIc9FlLyl46skyjpOqUgEAAAAAAAAAGYgQC0BK2URC8ddWKPq3F2R37xnSvYFjFyp8/llyZ5Sq68+PKvbSK/ufdB0FTzpR4bPfRoAFAAAAAAAAABMAIRaAlLDxuOLL30iGV3tbB3+jkQLHHavwuWfJLS3ufTh01tsUe3m5ZBwFTzlJ4bPPkDN5cuoLBwAAAAAAAABkJEIsACNi43HFXnlNsedelG3dN/gbjRQ4/jiFzztLbtH0Q552Jk9S1j9dLndWuZy8vBRWDAAAAAAAAAAYDwixAAyLTSQU+/urij33gmxb+5DuDZy4OBleTZ92xOuCixeNpEQAAAAAAAAAwDhGiAVgyBJVNer645/lb985rPtDS94yYIAFAAAAAAAAAJjYMjrEcl13VGaIGWOUSCSGMPcMgCTZri51/fUpxV9ePqJ1os88r8Dc2SmqCgAAAAAAAABwNMroEMtam+4SAHSLr16nrj8/OrRzrw7D21qlRHWtAhVlKagMAAAAAAAAAHA0yugQS0p2TQ0lzDLG9Ps4gRgwPP7eVnU99KgSa9enZD2ncKpC57xd7szSlKwHAAAAAAAAADg6ZXSIdeaZZ3qHC6UOp6OjQzt37nSqq6uNtD/Umjlzpq2srPRTXyVwdLK+r/grr6nrr09J0eiI13OKpit83tsVWLxIxnFSUCEAAAAAAAAA4GiW0SHW888/3zHce3fu3Gnuv//+wJ133hmuq6szO3bsMF/+8pfj1113XTyVNQJHI695u7r++LC86toRr+XMLFX43LMUOGY+4RUAAAAAAAAAYNAyOsQaicLCQvv5z38+/pGPfCR+xRVXZD/99NPuZz7zmUg0GtX1119PkAX0wyYSij67TLG/LZO8kTUuurPKFT7vLLnz5hx2zCcAAAAAAAAAAIdz1IZYPSZNmqQHH3ywY8mSJTkbNmxwbrzxxshb3/pW77TTTmO0IHCAxLZqdf3xz/J37BrROu682cnOq9mzUlMYAAAAAAAAAGBCmhCzvXJycvSNb3wjKkm+7+uLX/xiJN01AZnCdnaq848Pq+P/3TOiACuwcJ6yP/Vx5fzLNQRYAAAAAAAAAIARO+o7sXpceumliaysLHV2duqFF15wt23bZiorK2266wLSxVqrxOp16vrzo7L72oa9jpkyWZHLLlFwwbwUVgcAAAAAAAAAmOgmTIgViURUUVHhr1+/3pGkF1980a2srEykuy4gHfy9e9X14KNKrNsw/EUco9CZb1V46TkyoVDqigMAAAAAAAAAQBMoxJKknJyc3s6rmpqaCTFKETiQ9X3FX16urseekqKxYa/jzCxV1vsulVtaksLqAAAAAAAAAADYb0KFWI2Njb3BlTEmnaUAY85ralbXHx+WV1M3/EVCIUXecb6Cbz1FxiEHBgAAAAAAAACMngkTYr322mtOQ0OD6QmvCgsLOQ8LE4KNxxV9dpliz70gef6w1wkcu1CR91wsZ9KkFFYHAAAAAAAAAED/JkSI1dnZqc985jMRSbLWyhijk046yUt3XcBoS2ytUtcfH5a/c9ew1zD5eYq8550KLjomhZUBAAAAAAAAAHBkR32I9dhjj7k33XRTZNWqVY4xRtZalZWV2ZNPPnn4LSlAhrMdner665OKv/r68BcxUuitpyl84bkykUjqigMAAAAAAAAAYBAyOsT68Ic/PKx3zjs7O8327dvNqlWrnD179pie7quen2+99dZoqmsFMoG1VolVa9X150dl29qHvY5TUqSs971bbtmMFFYHAAAAAAAAAMDgZXSIde+99wZ7zrAaDmuTx14duMbHPvax+Ec+8pH4iIsDMoy/Z6+6HnxEifUbh79IMKjwBeco9LbTZVw3dcUBAAAAAAAAADBEGR1ijVRP95W1VtnZ2fra174W/cIXvhBLd11AKlnfV/zvr6rr8ael2PD/eAcWzFXkPZfImTolhdUBAAAAAAAAADA8GR9i9XRTDUdhYaE98cQT/Ysvvjh+zTXXxAsKClJYGZB+XlOzuv7wZ3m19cNew+TmKHLpxQocv0gj6XwEAAAAAAAAACCVMjrE2rJlS9tQ7zHGKBKJaNKkSTYrK2s0ygLSzsbjij7zvGLPvSj5/oDXm6lTFDr1ZEUfe6rP48FTT1bkoqUy2fx/BQAAAAAAAACQWTI6xKqsrBx+GxZwlEps2aauPz0sf2fLwBc7RqG3n6Hw+WfLhELym7cr/sabcqZPU+R971JgVsXoFwwAAAAAAAAAwDBkdIgFYD/b0aGuR59UfPkbg7remVmqrPddKre0pPex8CXvkFM0XaEzT5cJ8H9/AAAAAAAAAEDm4l1sIMNZa5V4c7W6Hn5Mtq194BtCQYUvPE+hM06TcZw+Tzm5OQqfc+YoVQoAAAAAAAAAQOpkdIh1zz33BHs+vuiiixIlJSXDHi/Y0NBgHn/88d7X+9GPfjQ+0vqA0ebv2aOuPz2ixIZNg7o+sGCuIpe9S86UyaNbGAAAAAAAAAAAoyyjQ6x/+Zd/iRhjJEmPPfZYR0lJiTfctVavXu0cuB4hFjKZ9X3FXnpF0SeelmKD+6MavvSiZPdV959xAAAAAAAAAADGs4wOsaTkKLVUvimf6vWAVPMamtT5xz/Lr2sY2n2btkpnnDZKVQEAAAAAAAAAMLYyPsQicMJEYeNxRZ9+TrHnX5T8oU/OTKzfqMTqtQouXjQK1QEAAAAAAAAAMLYyPsRKFWv3hwIEY8g0ic1b1fmnh2V37R74YmMke2jI5c4qlzN92ihUBwAAAAAAAADA2JswIVZbW1tvcpWTk5POUoBefnuHoo8+ofhrKwZ1vTOzVJH3vktdf/rL/nGDkYgi77xAwSVvkXGc0SsWAAAAAAAAAIAxNGFCrJUrV/a+uz958uShz2oDUshaq8TKVep6+DHZ9o6BbwgFFX7H+Qq99VQZx1HW+y5V+4/uUmDxIkXedZGcvNzRLxoAAAAAAAAAgDE0IUKsLVu2mJ///OehnjGCCxcu9NJcEiYwv2W3Oh98RN7GzYO6PrBwniKXXSJn8uTex9zSEuXc8Bm5hQWjVCUAAAAAAAAAAOmV9hDrwx/+cGQw191xxx3h++67zx/sutZadXR0mKqqKufNN990PM+TtVbGGJ1zzjkZE2L5vq9t27aZN998062trTV79uwx4XBYU6ZMsfPnz/dPO+00LysrK91lDtuqVauc5cuXuw0NDcbzPBUUFNjFixf7b33rW71gMJju8saU9TzFXnpZ0SeeleLxAa83uTmKvPtiBRYv6vccNwIsAAAAAAAAAMDRLO0h1r333hvs7w36HtYmJ/89/fTTriR3qOv33N+zR25urj7ykY8MnCCMopaWFv3hD38IPv7444G//e1v7q5duw77CxAMBnXRRRclrr/++th55503pPBt69atZs6cOSOaM2et3TfUe3zf19133x387ne/G9q0aVO/hzRNnTrVXnvttfGbb745mpt79I/C8xoa1fmHP8uvbxzU9cElb1HknRfKZI/fABMAAAAAAAAAgJFIe4g12nrCK2utIpGI7r777s6SkpK0nYn1yU9+MnLPPfcEY7HYoK6Px+N6+OGHAw8//HDgqquuiv/4xz/umjRp0ihXOXy7d+/WFVdckf3MM88cMXBsaWkx//Ef/xF64IEHgg899FDH4sWLB91lN57YWEzRp59TbNlLkj+4P3aB449T1hXvGeXKAAAAAAAAAADIbBkRYvV0S430mv64rqu5c+f6F1xwQeLTn/50fMGCBWkNS1555RW3vwDLdV0VFxfb6dOn23g8rtraWmfv3r19rrn//vuDGzZscJ555pmOvLy8sSp50Do6OnThhRdmL1++vE+AFQqFVFFR4YdCIVVVVTnt7e29z23bts2cd9552S+++GL7/Pnz0xYujobEpi3q/NNfZFt2D+2+1WvkNZwpt7R4lCoDAAAAAAAAACDzpT3E2rJlS1t/j1trNXfu3NyeTqr/+Z//6Xzb29426HF6juMoNzfX5ufnK1PPXpo8ebI++MEPxi+55JLE2WefncjPz+99LpFI6LnnnnNvueWW8IsvvtgbCi1fvty95pprsv70pz91DnW/888/37vxxhujKSr/ENdff33kwADLcRx96Utfin3hC1+ITp06VZIUjUZ17733Br/4xS9Gdu9Ohjs7d+40H/jAB7KXL1/eHgik/Y/kiPnt7Yo+8oTir68c5gJW0af/puwP/VNqCwMAAAAAAAAAYBxJe2JQWVk5qO6boqIiO9hrM11FRYX98pe/HP3Qhz4Uz87O7veaQCCg888/3zv77LM7PvnJT0Z+/vOf9yZxDz74YOCpp55yly5dOqQzskpKSvx3vOMdQ7pnsNauXev84he/6JMW/s///E/n1VdfnTjwsXA4rI9//OPx0047zTvrrLNy9uzZI0lauXKlc8899wT/9V//Na3nlY2EtVbxFW8q+pfHZds7hreIMQqdcarCF56X2uIAAAAAAAAAABhnnHQXcCRlZWW250dWVla6y0mJW2+9Nbphw4a2T3ziE4cNsA4UCAT005/+tOukk07qMwbx7rvvDo1akcPwta99Lex5+/OxK6+8Mn5wgHWgxYsX+//xH//RdeBjt99+e3iwZ4VlGr9ltzruuU9dD/xp2AGWU1qsnE9/XJFLL5YJh1NcIQAAAAAAAAAA40tGh1jV1dVtVVVVbVVVVW1nnnnmqHQQjbV3v/vdifAQA4pAIKCDxwA++eST7uGuH2stLS166KGHerv6jDH6+te/PuDYwo9//OPx8vLy3u66mpoa88QTT2TM6xoM63mKPv+i2v7rx/I2bhneIsGgwpdcqJxP/6vcmTNSWyAAAAAAAAAAAONURodY2O+ss87qE+K1tLSY9vb2dJXTx8MPPxxMJPY3XZ111lne3LlzBxz96Lqurrnmmj6tVw8++GBmHmDWD6++Qe0/uVvRR5+U4odtOjuiwIJ5yv0/n1L47WfIuOMqvwMAAAAAAAAAYFQRYo0TU6dOPSQU2rNnj0lHLQd75JFH+pyttnTp0kEnOhdeeGGfcO7RRx9N+zltA7GxmLoefULtP/6Z/PrGYa1h8nKVdeX7lfWRK+VMnZLiCgEAAAAAAAAAGP8yPjBAUl1d3SGBVWFh4YDdTmNh5cqVfcLQt73tbYMe/XjKKad44XBY0Why+mBjY6Npbm42RUVFGfHaDpbYuFmdD/5FtmXPsNcInrZEkYvOlzlKznkDAAAAAAAAAGA0jNsQa+fOnWbHjh1m9+7dpicAGYpzzz13XJ2x9fzzz/f5vSovL7dDPVurR3V1tWlsbDRdXV2moKDATp8+3Q43NIrFYtq6dWufEOu4447zB3t/JBJRZWWlv379+t411q5d6xQVFWXU74/f1q7oI48r/sabw17DKZqmyPsuVaCiPIWVAQAAAAAAAABwdBpXIdajjz7q3nPPPaF//OMfbkNDw7BH6RljlEgk9qWyttF2zz339Dkr6qKLLhryIUxPPfVUoKSkJLepqemQX7uKigp71llnJa699tr4mWeeOegAacuWLc6B52FlZWVp2rRpQwrEZs6cadevX9/7+fr1651MCRmttYq/vlLRRx6X7egc3iKBgMLnn6XQ28+QCYyr/8sBAAAAAAAAAJA24+Id9XXr1jlXXnll1ptvvulIyWBhInn44YcDL7zwgnvgYx/5yEdiQ12nv/CqR3V1tbn33nuD9957b/Ccc87x7rnnns5Zs2YN+Avd3NzcZ83S0tJBd2H1mDFjhi+p9/Vt3749I8768ne1qPPBv8jbtHXYa7hzZyvrskvkFBaksDIAAAAAAAAAAI5+GR9ivfzyy87SpUtzOjo6ZK2VMfvzjQM/PjjYOvC5/p4fL3bt2qXrrrsucuBjl156aeKtb33rkMOiwfrb3/7mnnTSSTl/+MMfOgfqiGpra+vzeXZ29pD3y8nJ6fOb09bWlpIQq6mpyezYsWPAtRobG/tc01hfr5rf/kH5K9fK8YbXEGZyshV+1zsUPPH4Q/4sAgAAAAAAAACQKtu3b9eOHTtGZe3GxsZRWXewMjrE2r17ty6//PLs9vb23iAgPz9fF154YWLWrFn+HXfcEZKSgdWVV14ZLy0ttbt37zZr16513njjDberq6v3voULF/qXX355PH2vZug8z9OVV16ZVV9f35uCTJo0ST/84Q+7hrLOjBkz7CWXXJI477zzEosXL/ZLS0v9nJwc7d2712zZssU888wzgZ/97Gehbdu29e6ze/du8773vS/7xRdfbD/22GMPG5gdHDhFIpEhp4WRSJ+MTu3t7SlJfX70ox+FvvnNb4aGel/Hs89rsiIDX3gYwZNPVPidF8rJGXqgBwAAAAAAAADAUPzkJz/R17/+9XSXMSoyOsT67//+71BDQ4PpCaLe8Y53JO6///7OqVOnSpLuuOOOUM9zH/7wh+MXXHBBb9tMa2ur7rrrrtC3vvWt8J49e7RhwwZn69atzi9/+cuuYDDYz26Z59/+7d/CTzzxRJ/fo5/85CedFRUVgwqKJk+ebP/0pz91XnrppQnXdQ95vrCw0BYWFtrTTjstduONN8ZuvfXW8Le//e2Q7yczqz179ujqq6/OWr58ebvjOP3u0dXV1SdwCoWGnBkpHA73+byzc5hnT6XIjLxJw7rPKSxQ5L3vUmBOZYorAgAAAAAAAABg4uk/mcgQd911V8gYI2ut5s6d6z/44IO9AdZA8vPz9YUvfCG2cuXKtsWLF/vWWv3mN78JXnPNNcNvsRlD3/ve90Lf//73+yRCN9xwQ+zKK69MDHaNqVOn6rLLLus3wDpYIBDQ7bffHv3Od74TPfDxN954w/n9739/2LDz4M6rWGzIR3UpGu2z5SGdWRnPdRQ6/2zlfP6TBFgAAAAAAAAAAKRIxnZibdiwwWlubjbGGBlj9NWvfjV6cMfOYJSVldknnnii48QTT8xpbm42v/3tb4Pvfve7E//8z/886DBorN17772BL3zhC31e7Ic+9KH4HXfcET3cPanyb//2b7GHHnoosGzZst7k69577w1+4AMf6PfXKzc3t0+IdXBn1mB0dfWdjnjwGVnD9ZnPfCb2wQ9+cMARkvfee2/gjjvuGPofLkn+jBLlffB9cqdPG87tAAAAAAAAAACMyKc+9Sm9//3vH5W177//fn37298elbUHI2NDrNdee82RJGutXNfVZZdddsTQqWcEXn+KiorsrbfeGr3uuusikvTNb34znKkh1kMPPRT42Mc+lmXt/hznPe95T+IXv/hF1+FG+qXaDTfcEFu2bFlWz+fPPfdcIB6Pq78xjLm5uX0+7+joGPJ+B5+BdXAwNlzFxcW2uLh4wLVKSkqGvl9WRJF3XqjgySfKjNHvCwAAAAAAAAAAB5s+fbqmT58+KmuXlJSMyrqDlbHvvu/YscNIkjFG5eXl9uCw5GCdnZ1H7AC68sor46FQSNZarVu3ztm4ceOQO4ZG21NPPeX+0z/9U1YisT9fO++887wHHnigMxAYu7xx6dKliZ6zxiRp3759amho6PfXq6ioqE8A1NDQMOQ/U/X19X3umT59ekpCrNESOHGxcm/4jEKnnESABQAAAAAAAADAKMnYd+D37t3bG5pMnTq13zar7Oxs9XQstbW1HXG9vLw8VVRU9K7zyiuvDHxQ1Bh66aWX3Pe+973ZB47WO/30072HHnqoYzhjFEciNzdXkydP7hMkbd++vd8Qa86cOf6BAVtnZ6eam5uHFBDW1tb2uf6YY445fFtdGpmpk5X9sauV/U+Xy8k7cqgKAAAAAAAAAABGJmNDrKys3ml2stb2G4rk5eX1Bi21tbUDvpYDg5mDu3/SacWKFc673vWu7AODuBNOOMH/61//2jFQB9poOXh0YDwe7/f3IBQKqbKysk/otGbNmkH/2nZ1damqqqrP9RkXYjlGobPfptzrP6XA/LnprgYAAAAAAAAAgAkhY4KcgxUWFvYGTvv27ev3mgPPO1q3bt2Ar2Xnzp2918RisRFWmBrr1q1zLrzwwuzdu3f3PrZgwQL/8ccf75g8eXJaaorH42ppaekTWk2fPv2wwdIJJ5zQ57kXX3xx0F1ur776qhuNRns/H+w5VmPFLZuhnM9+QpGLL5AJhdJdDgAAAAAAAAAAE0bGhlgLFy70JMlae9iuqeOPP773mueee+6Ih0ZVVVWZbdu2mZ6znqZMmZL2oGTbtm3mggsuyO45/0uSZs2aZZ988smOg8+aGksvvfSSe+C5XIFAQCUlJYet513velfiwM+ffvrpQR/g9cQTT/QJvC655JLE4a4dU+GQIu95p7Kv+xe5JcXprgYAAAAAAAAAgAknY0OsxYsX95611NnZqc2bNx8yzu5tb3ub1/NxXV2duf/++w8bnnz1q18NS+o9Q+vYY49N68i6+vp6s3Tp0pz6+vre11VaWmqfeuqp9rKysrQGbD//+c/7zBI87bTTvJycnMNe/653vSt+4LlYzz//vNvf79fBfN/Xvffe26e96T3veU/aQyxTUqTcGz6j0FtPlXEy9v8iAAAAAAAAAAAc1TL2Hfrc3FyddNJJvSHVU089dUhA9YEPfCAeDodljJG1Vp/+9Kezfv3rXwd8f38+tXfvXn3yk5+M3H///cGeLqxJkyb1CcDG2q5du3TBBRdkb926tTfoKSwstE888UTHnDlz0hpgPf300+6vfvWrPiHWu9/97iMGSwUFBbr00kt7r7HW6pZbbgkPtNfPfvazYHV1de+vQXl5ub3wwgvTHmKFTz1ZzqT8dJcBAAAAAAAAAMCElrEhliQdGGj85S9/OSTEmjx5sq677rqYtVbGGLW2turqq6/OKioqyj399NOzTzrppJzi4uK8n/3sZ0EpGa4YY/SpT30qFg4PmLGMitbWVr3jHe/IOfAMr8mTJ+uxxx7rWLRoUcq6wx577DH3Zz/7WTAejw/6nieffNJ9//vfn+15+/O94uJi++lPf3rAA8S+8Y1vRJ0DupZ+9atfBe+7777DdsatXr3auemmmyIHPvbv//7v0XT9vgAAAAAAAAAAgMwy6LOL0uGqq65K3H777WFrrZ544olAdXW1qaio6NOpdNttt0WfeOKJwNq1a52ejqxdu3aZlpYWt2d0oKTebq0lS5Z4X/va16Jj/mK6XXrppdmvvfZan/Dwc5/7XHTnzp3m8ccfdw93X39OOeUUb+rUqf0+V1dX51x77bWRW2+9NXz55ZfH3/3udyeWLFniTZ48uc91iURCr7zyivuTn/wk+Otf/zp4YBeb4zj64Q9/2HWkUYI9jjvuOP+jH/1o/MBRhB/+8Iez1q5dG/vCF74Q7akzFovpf//3f4Nf/OIXI3v27Olz/8c+9rHBJ24AAAAAAAAAAOColtEh1oIFC/wHH3yws6urS1LyDKWD5eTk6G9/+1vH5ZdfnrVs2TJXSgZWB/5srZW1Vu94xzsSv/71rztDodAh64yV559//pCg6hvf+Maw2o+eeuqpjvPPP/+IYxEbGhrMD3/4w9APf/jDkJQ8d2vKlCk2JyfHtra2mrq6Oqetre2Q+4wx+u53v9t1xRVXDHq83/e///2uN954w3399dcdKfn79e1vfzt05513hioqKvxwOKyqqqpD9isoKLC/+93vOoPBYL/rAgAAAAAAAACAiSejQyxp4POYpOR5Us8991zHgw8+GPjNb34TfOWVV9zt27cba62Kiors6aefnrjmmmviF110UdrOwcoUDQ0NpqGhwRzpmuLiYnvPPfd0DvXXKycnR0888UT7FVdckf23v/2tN6yLxWLatGlTv6MrKyoq7EMPPdSxcOHClI1SBAAAAAAAAAAA41/Gh1hDcdlllyUuu+yyQXcOHc2WLl2a+OpXvxp97rnnAm+88Ya7b9++I17vOI6OP/54/+Mf/3jsIx/5SHwwIwT7U1BQoKeeeqrjrrvuCt55552hLVu29BteTZkyxf7rv/5r/Ctf+Uo0Ly9vWHsBAAAAAAAAAICj11EVYo0H1tojp0kpMmvWLPuNb3wjJinm+742b95sNm3a5NTU1Dh79uwxXV1dysnJ0ZQpU2x5ebl/+umne5MmTUrJ3q7r6rrrrotfd9118ZUrVzqvvfaa29DQYDzPU0FBgV28eLH/1re+1UvnWEcAAAAAAAAAAJDZMjbE2rBhg/PII4/01nfhhRcmjjvuOEbODYPjOJo/f76dP3++J2lMRyqecMIJ/gknnMDvGwAAAAAAAAAAGJKMDbEeffRR98YbbwxLkjFG733ve+PprgkAAAAAAAAAAABjo9/zijJBW1ubsdbKWquSkhJbWVlp010TAAAAAAAAAAAAxkbGhljTpk2zUrILq6SkhHF0AAAAAAAAAAAAE0jGhlgzZszo7bzau3evSWctAAAAAAAAAAAAGFsZG2KdccYZiWAwKGutampqnLa2tnSXBAAAAAAAAAAAgDGSsSFWQUGBli5dmpCkWCym3/72t8F01wQAAAAAAAAAAICxkbEhliR9+ctfjhmTnCT41a9+Ndzc3MxYQQAAAAAAAAAAgAkgo0OsM88807vtttui1lo1NTWZ8847L3vNmjUZXTMAAAAAAAAAAABGLuMDoX//93+P/ehHP+qKRCJat26dc/LJJ+d86EMfijzyyCPurl270l0eAAAAAAAAAAAARkEg3QUcSWVlZW7Px4FAstRYLKZf/epXwV/96ldBScrNzVVeXp4NBgd/ZJYxRlu3bm1Ldb0AAAAAAAAAAABIjYwOsaqrq40xRtZaGWPUcz6Wtbb3mn379mnfvn1DOiurZx0AAAAAAAAAAABkpowOsXocHDqNJIQ6MAADAAAAAAAAAABAZsroEKusrMzSNQUAAAAAAAAAADDxZHSIVV1dzblVAAAAAAAAAAAAE5CT7gIAAAAAAAAAAACAgxFiAQAAAAAAAAAAIOMQYgEAAAAAAAAAACDjEGIBAAAAAAAAAAAg4wTSXcBItba2as+ePcb3fZWUlNhwOJzukgAAAAAAAAAAADBC4y7EevLJJ90//OEPwRdeeMHduHGj43le73OPPfZYxwUXXOAdfM8rr7zitLe3G0maMmWKPfHEE/0xLBkAAAAAAAAAAABDNG5CrBdffNH91Kc+FVm9erUjSdbaPs8bYw57729+85vg97///ZAk5efnq6GhYV9WVtZolgsAAAAAAAAAAIARGBdnYt15552h8847L3v16tXOUMKrHtdff33MdV1Za9Xa2qrf/e534ya8AwAAAAAAAAAAmIgyPsS66667gjfeeGM4Ho/3Pua6rk455RTvfe97X+LgUKs/5eXl9uyzz+4dM/jnP/85ODrVAgAAAAAAAAAAIBUyOsTaunWr+dznPhcxxqjnx//5P/8n1tjYuO/ll1/u+P3vf98pDa4b633ve19cSo4hfPbZZ91RLh0AAAAAAAAAAAAjkNFj9b761a+GY7GYJMlxHN17772d//zP/5wYzloHdmLt2bPHbNq0ycybN2/gNi4AAAAAAAAAAACMuYztxIpGo3rooYeCPR1Y//Iv/xIfboAlSQsWLPCzs7N7P1+7di3dWAAAAAAAAAAAABkqY0OsZcuWuR0dHeo58+qLX/xidCTrua6r4uJiv+fzurq6gWcQAgAAAAAAAAAAIC0yNsTaunVrb22lpaV2zpw5Ix79N2nSpN6PW1tbCbEAAAAAAAAAAAAyVMaGWDt27DCSZIzp00GVKr6f8iUBAAAAAAAAAACQIhkbYoXD4d6PY7FYSrqmWlpaetcpKCgYcWcXAAAAAAAAAAAARkfGhlhFRUW+JFlr1dDQMOIQa/fu3aqtrTXGmJ71CbEAAAAAAAAAAAAyVMaGWHPnzu2d99fS0mLWrl07olr/+te/Bnzfl7XJ7OrUU0/1RlgiAAAAAAAAAAAARknGhlinnnqqP2XKFNvTOXXXXXcFR7LenXfe2TufcO7cuf6MGTPoxAIAAAAAAAAAAMhQGRtiua6rSy+9NGGtlbVWP/3pT0PLly8fVr233HJL6I033nAkyRijq666Kp7aagEAAAAAAAAAAJBKGRtiSdItt9wSDYVCMsYoFovpne98Z/ZLL73kDvb+RCKhG2+8MXz77beHezq6Jk2aZK+//vrYqBUNAAAAAAAAAACAEcvoEKuystLedNNNUWutjDHauXOnOfvss7OvvPLKyF//+ld3586dRlLvOVee52nHjh3mxRdfdL/xjW+E5syZk/u9730v1NPNZYzRf/3Xf0Xz8/PT+roAAAAAAAAAAABwZIF0FzCQW2+9NbZlyxbn/vvvDxpj5HmeHnjggeADDzzQ54wsa60uueSS7IMfk5IjBK21+tznPhf78Ic/zChBAAAAAAAAAACADJfRnVg9fvnLX3Z9+ctfjvWMBJSSAVVPd1XPj57HDnxOSoZYt912W/S//uu/oul6DQAAAAAAAAAAABi8cRFiua6rb37zm9Fnn3224/zzz/d6OqwO1hNm9bDW6uyzz/aeffbZjptvvplzsAAAAAAAAAAAAMaJjB8neKC3v/3t3pNPPtmxdu1a55FHHgm88MIL7vr1652Wlhazd+9ek52drYKCAltRUeGfc845iYsvvjhxyimn+OmuGwAAAAAAAAAAAEMzrkKsHscee6x/7LHHxm688cZ0lwIAAAAAAAAAAIBRMC7GCQIAAAAAAAAAAGBiIcQCAAAAAAAAAABAxiHEAgAAAAAAAAAAQMYZl2diSVJHR4deffVVd9u2bc7u3bvV1tZmcnNz7ZQpU1RZWemfcsopXnZ2drrLBAAAAAAAAAAAwDCMqxCrvb1d9957b/CXv/xl8PXXX3c9zzvsta7r6i1veYv30Y9+NH711VfHc3Nzx7BSAAAAAAAAAAAAjMS4GSf4m9/8JjB37tzcT3/605FXX33VTSQSstYe9kcikdDy5cvdT3/605G5c+fm/vrXvx5XgR0AAAAAAAAAAMBENi5CrGuvvTZy1VVXZTU3NxtrrSTJGHPEe3qet9Zq+/bt5uqrr876+Mc/Hhn1YgEAAAAAAAAAADBiGd+d9IlPfCJy9913B6W+wVRubq5OPvlkb9GiRd7UqVNtTk6O2tvb1dLSYlavXu2+/vrrbltbW5977rnnnqAk3X333V3pej0AAAAAAAAAAAAYWEaHWA8//HDgZz/7WfDAIKqiosLeeuut0fe///3x7Ozsw97b0dGh3/72t8FvfOMb4aqqKmOM6Q2y3vOe9yQuvfTSxFi9DgAAAAAAAAAAAAxNRo8T/MpXvhKWkuGVJF122WWJdevWtX34wx8+YoAlSdnZ2frIRz4SX7t2bdtll12WsNaqJ8jqWRcAAAAAAAAAAACZKWNDrLVr1zqrVq1yjDEyxui0007zfv/733dGIkM71ioSiej3v/9952mnneb1hGGrV6921qxZk7GvHQAAAAAAAAAAYKLL2CDntddec6T9XVh33HFH1HGGV67jOLrjjjui/a0PAAAAAAAAAACAzJOxQU5dXV1vbYWFhfZtb3ubN5L1zjzzTG/atGm25/OGhoaMfe0AAAAAAAAAAAATXcYHOcYYzZw50w585cAOXKenwwsAAAAAAAAAAACZJ2NDrJkzZ/o9H7e3t6dkzY6Ojn7XBwAAAAAAAAAAQGbJ2BDr9NNP96Rkx1RNTY2zb9++Ea3X2tqqqqqq3tf71re+dUTjCQEAAAAAAAAAADB6MjbEmjdvnj3llFM8SYpGo/rFL34RHMl6v/jFL4LRaFTGGC1ZssSbO3cu8wQBAAAAAAAAAAAyVMaGWJL0rW99K2qMkSTdcsstkTVr1gyr3lWrVjm33HJLxBgjY4z+8z//M5rSQgEAAAAAAAAAAJBSGR1inX/++d7tt98etdaqtbVVZ511VvYf/vCHwFDW+P3vfx8455xzsvft2ydrrb75zW9GzznnHEYJAgAAAAAAAAAAZLAhBULp8OUvfzlWWlpqr7/++sju3bvNBz7wgayTTz7Zu/rqq+PnnXeed8wxx/iu6/Zen0gktG7dOufZZ59177vvvuBrr73mWms1adIkff/73++85pprEml8OQAAAAAAAAAAABiEjA6xKisrc3s+7hkraK3V8uXL3ddee82VJNd1lZ+fb7Ozs9XR0aHW1lbjeV7vtT33GmPsLbfcErnlllsGtbcxRlu3bm1L7SsCAAAAAAAAAADAYGR0iFVdXW2MMbLW9gRRvc/1BFSJREItLS2mpaXlkPsPvH7v3r1mz549g977wHsBAAAAAAAAAAAwtjI6xOrRX6A0nJBpsPf0BGQAAAAAAAAAAABIj4wOscrKyiwdUQAAAAAAAAAAABNPRodY1dXVnEkFAAAAAAAAAAAwATnpLgAAAAAAAAAAAAA4GCEWAAAAAAAAAAAAMg4hFgAAAAAAAAAAADIOIRYAAAAAAAAAAAAyDiEWAAAAAAAAAAAAMg4hFgAAAAAAAAAAwAQW831t74ymu4xDBNJdwFCsWLHCeeSRRwIrVqxwa2trTWtrq+nq6jLW2iGtY4zR1q1b20apTAAAAAAAAAAAgIxjrdXuWFy17V2qbetUbXvyR1NHVFPCQd152qJ0l9jHuAixli1b5l5//fWRFStW9OkcG2p41cMYk5K6AAAAAAAAAAAAMlHM81Xf0ZUMqto6k8FVe6faE16/1++KxtWeSCgnkDnRUeZUchjf+973Ql/84hfD1tre0KonhBpOGDXc4AsAAAAAAAAAACDTWGvVEo13d1XtD62aOqMaaiJS196lBZNyR6XO4cjoEOtPf/pT4Atf+EJYSgZWxhj1hFnBYFCTJk2y2dnZ6S4TAAAAAAAAAABg1MU8X3UdfUcB1rV3Hba7aqhq2zoJsQbrhhtuiEjqDa8KCwvt5z73udh73/vexMKFC33XddNdIgAAAAAAAAAAQEod2F1V0x1U1bR1qnkY3VVDUdveNYqrD13GhlgvvfSSW11dbXoCrEWLFvnPPPNMx7Rp05gHCAAAAAAAAAAAjgpRz1d99yjAZGCV/LgjRd1VQ9HQQYg1KCtXrnSkZNpojNHdd9/dSYAFAAAAAAAAAADGqz3RuLa1dXSPA0yeXzXa3VWHMzUcVFlOlspyIsmfc7NUlBVOQyWHl7Eh1s6dO03PxzNmzLCnnXaan856AAAAAAAAAAAARuKZxp36c03zmO4ZcoxmHBhW5WRpZk5EucGMjYh6ZWyF2dnZkpLnYRUXFxNgAQAAAAAAAACAjGKt1c5oTHHfqjQ7MuD1ZTlZo1pPQTiomTlZKs/JUlluMrQqygrLMWbgmzNQxoZYCxYs6B32uHfv3vH5qwsAAAAAAAAAAI4aTR1dWr+3TTVtXd1nV3Wq0/P1loJ8fX7R7AHvL8tNTYgVcoxmdndUlfd0V+VGlBPI2NhnWDL21Zx11lleJBLR/2fvz8MjPcs77/t3174v2ntf3W233XjDuNt4wQvb2CQwExJCSAhLMiGZNw+TB5KQDZKBkAzbQZjJZDIsSRgyybAkfmwgNrYBA7YB7+7F7nav6pZaUkm171X3/f5RUrXUUneVpCqpJH0/x9GHVMt9XRe4F1X96jzPQqGgEydO2BKJhCKRyHIfCwAAAAAAAAAArFE/jSX19ZPDs+4/nck3dX2fxyWXzaaS2XwDutcdOoAAAMhqSURBVG63U5sD3vMVVn6P+lZwddV8dGyIFQqF9Iu/+IvlL33pS85qtaovfelLzv/8n/9zebnPBQAAAAAAAAAAVod8paqzuYIkaWfI3/D5m/xztwwcL5aVq1Tlc9gveb3NMLTR79HxdG7WYy6brV5ZtTEw+dXvbbjmataxIZYkfexjHyt+85vfdIyNjRn/5b/8F/cb3/jG6uWXX858LAAAAAAAAAAA0DTLsjRWKGkwm9dgtqDBTK0V4GihJEm6KhrUB/buaLjOpWZancnmtSscaLjGZr9X6XLlfGDl92pTwKs+j2tNVFfNR0eHWAMDA9a//uu/5t74xjf6E4mEcccdd/j+7u/+Lv+6172u2vhqAAAAAAAAAACw1pRNU2ezBZ3O5nU6U/s1NbvqYgazzbUD7HI75XPYlavMjilONxli/cplGwmrmtTRIZYk7du3z/zRj36Ufetb3+o9fPiw7Y1vfKPvpptuqv77f//vy9dff73Z19dneTwea77rbt26dd7XAAAAAAAAAACAzpEpV2pB1VRglc1rOFdQdZ4JQLJUUapUVsjlvOTzDMPQJr9HLyWzsx6LF5ubiESA1byOD7Ekac+ePeYDDzyQe+1rX+t76aWXbI899pj9scceW3ATSMMwVKlU0q08IwAAAAAAAAAAaA/TshQrlHRqWmA1mMlrotRccNSMwWxBVzYIsaTa7KyqZWmT31v/tdHvkXcNz65qlxURYn30ox91/eVf/qU7l8vJMAxZFkVUAAAAAAAAAACsRiXT1FC2UA+sBie/Fi7RDrAVBrN5XRkNNnzeW7etb+s5cF5Hh1imaeptb3ub9+tf/7rDsiwZkyV2BFkAAAAAAAAAAKx86XJFg5m8Tk2rrhrKFdTeuGo2j92mYptDMsxfR4dYf/mXf+n62te+5pBmBld9fX3WFVdcYXZ3d1s+n480CwAAAAAAAACADjdWKOpkun3tAJthSOrzuLQx4NXmyTaAm/1edXtczKrqQB0bYuXzeX3iE59wT4VXlmXp9ttvr370ox8t7N+/nzgUAAAAAAAAAIAV5J+ODemp8eSS7ee0Gdrkr4VVmwO1Xxv9HnnszK5aKTo2xHrkkUfsiURChmHIMAy9+c1vrnz1q1/N22y25T4aAAAAAAAAAABQrR2gZVkKuZwNn7s54G1biBV0OrQlMDOw6ve6Zae6akXr2BDr8OHDdkmyLEs2m02f/exnCwRYAAAAAAAAAAAsj1ihpBPp3Kx2gPds6tPPbVvf8PrNAe+iz2BI6ve6a0HVVGDl9yrscsggsFp1OjbEKhaLkmqzsLZv325u3LiR2VcAAAAAAAAAACyTr50Y0hNjiVn3n87km7p+s39+IRbtANGxIdaGDRvqoVUkEiHAAgAAAAAAAACgxdLliqqWpUiT7QDnDLGyzYVYXW6n/A67spXqrMdoB4i5dGyItX37dnPq+7GxMfoIAgAAAAAAAACwQKZlaaxQ0ulMrRXgVEvAeKms12/o1S/u2NBwjYtVUiVKFSVLZYUbBGGGYWhLwKuJYpl2gGhKx4ZYr371q6vr16+3hoaGjNOnTxunTp0ytmzZQkUWAAAAAAAAAACXUDJNnc0WZoRVg9m8ClVzzuc3W0m16RIzrQYzeYW7GldzfWDvDtkIq9Ckjg2x7Ha73vWud5U+9rGPuSXpk5/8pOtzn/tccbnPBQAAAAAAAABAp0iXK7Oqq4ZzBc0dV83tdCYvy7IaVkKFXU5FXA4lSpVZj53NFXRVV6jhXgRYmI+ODbEk6Q//8A9L9913n/P555+3/c3f/I3r1ltvrb71rW+d/acDAAAAAAAAAIBVzLIsxQolnZyjHeBiZStVTRTL6va4Gj53S8AnT744sx1gwNvUTC1gvjo6xPJ4PPq3f/u33N133+175plnbG9/+9u9Tz75ZOkP/uAPiuFweLmPBwAAAAAAAABAy5mWpXP5ok6mczo1GVqdyuaVq1TbtufpbL6pEOv/uXIb1VRYMh0dYn3pS19yStK73/3u0ic/+Un3qVOnjE9+8pOu//E//ofr9ttvr1x33XXV3t5ey+u9eB/Oi3nXu961+HgaAAAAAAAAAIBFqJimzuYKOpmuVVedyuR0OlNQyZxPQ8DFG8oVdG134+IRAiwspY4Osd7znvd4pvfgNAxDlmUpk8no/vvvd9x///0LPj8hFgAAAAAAAABgKRWrVQ1mCzqVqYVVpzJ5nckWVLWsJTuDIanf657ZDtDvVdjV0XEB1qgV8bty+kC5CwfLWfP4wz0VgjUaTgcAAAAAAAAAQCt95sBxPT+R0tLFVZLLZmjjtKBqc8CrTX6P3Hb7Ep4CWLiOD7GmQqr5hFWN1gIAAAAAAAAAYCm57ba2Blghp6MWVk0LrAa8btr/YUXr6BDr85//fGG5zwAAAAAAAAAAgFQrlJgolnUyk9PpTF4nM3m9Zl13U7Oktga8+slYoiXn6Pe6tWV6O8CAVxGXsyVrA52ko0Osd7/73cytAgAAAAAAAAAsu78/OqifjCWUrVRn3L/O524qxNoc8M17T5uk9X6PtgS82hLw1YMrr4N2gFgbOjrEAgAAAAAAAACgE5RMc1aAJUmnMvmmrt8S8F7ycYdhaFPAqy1+by20Cvq00eeRy25b0HmB1YAQCwAAAAAAAACwZpRMU2eyBZ1K53Qqm9fVXaGmKqm2BHz60Uh81v2nMnlZliWjweypoNOhbrdT48WyPHabNk+FVQGftgS9Wuf1yGFjfhUwHSEWAAAAAAAAAGBVyleqOp3NT86vyulUJq+hbEHmtOfYDaPJEGvuSqpcpapYoaRer7vhGr9++RaFnQ71ed2yNQi9ABBiAQAAAAAAAABWgXS5olOZvE5ncjqZqQVXI/mirAbXNdsOcLP/4u0AT2XzTYVYu8OBpvYCULMiQ6yRkRHj0UcftR86dMgWj8eNZDJpmKap3/u93yvt2bPHbLwCAAAAAAAAAGAlsixLiVJZpzJ5nZqssDqdyWu8WF7QeqczeZmW1bAyyuuwq9/r1ki+KEnq9bjq7QA3+DwL2hvApa2oEOsb3/iG49Of/rTr8ccft8/1+Dve8Y7ynj17Zt3/gQ98wP3kk0/aJWnz5s3mP/zDPxTafFQAAAAAAAAAwCJZlqWxQmkysMrVg6tUudKyPUqmqXP5otY3EUT94vb1cttt2hzwyu9YUW+vAyvSivhTFovFjF/5lV/xPPDAAw6p9heXJBmGMeP7i9m/f3/105/+tGvyefYPfvCDpb1791KxBQAAAAAAAAAdwrQsDeeKM8KqU5mc8tX2v5V7KpNvKsS6ponZWQBap+NDrLGxMeOmm27yHT9+3GZZ1oywaur2VJB1MW95y1sqGzdutM6cOWNI0v/+3//b+Zd/+ZfF9p4cAAAAAAAAADCXimnqbK6gk+nzYdVgNq+S2WiCVeu4bIY2T7YD7PO4lmxfAM3r6BDLNE296U1v8h47dsw2FV4FAgG9613vKr3uda+rbN682XrFK17hb7SOzWbTW97ylvLnPvc5lyR95zvfcRBiAQAAAAAAAMDSGMzkdTyd08lMTiczeQ1m8qo0KE5oJa/dpq0B32Ro5dXWoE8DXnfDOVgAlldHh1h/93d/5/zJT35inwqw9u3bV/3617+eX7du3Yy/3S7VSnDK3XffXfnc5z7nsixLzz//vC2VSikUCrXn4AAAAAAAAACAur958ZTO5gpLslfI6dCWyQqrLZOhVa/H1dT7yAA6S0eHWJ/4xCdcUq1t4I4dO8xvf/vbuXB4YT1Hb7jhhurU95Zl6cCBA/abbrqpeqlrAAAAAAAAAABzq1qWTMuS02Zr+NytAW9bQqxut3NGWLUl4FPE5SCwAlaJjg2xjh8/brz00kv1NoIf/ehHiwsNsCQpGo1qYGDAOnfunCFJR44csRFiAQAAAAAAAEBjVcvS8OQMqxOZnE5lcjqdyeuXd27ULQPdDa/fGvTpR6PxRZ1hwOueEVZtCXgVcHbsW9wAWqBj/4T/+Mc/tku1qimv16s3v/nNlcWuGY1G6yHWxMQEUTwAAAAAAAAANOHjzx3Vy6ncrPtPZvK6pYnrtwZ8Te9lk7TB75lRYbXJ75XXYW/+wABWhY4NsUZGRgypNu9q69atptvtXvSagUCgPksrm80uej0AAAAAAAAAWAs2+Lxzh1jp2ffNZXPAK0OSdcH9DsPQpsmgautkhdUGv0euJloUAlj9OjbEymQy9Uqp6eHTYqTT6fqafr+/FUsCAAAAAAAAwIpgWpZG8kWdSOd0KpPXiXROt63r1qv7uxpeuy3o1ffPzb5/MJtX1bJkbzCDym23aUvAWytaCHi1NeDT1qBXG3xeOWw0zQIwt44Nsbq7u+vBVTweb8nfYsPDw/X4vre312zFmgAAAAAAAADQaUzL0mi+qJOTYdXJTC24KlRnvi26zudpKsS6WDvAkmlpKFfQJr+34RofvnaXjAZhFwBM17Eh1rp16yypNhPr5MmTtmw2u6jqqWeffdaWTCbrt7dt29aS6i4AAAAAAAAAWE6mZWm0UNLJybDqZDqvU5mc8tXGn+M/mWmuHeAGv0cOw1DFmv226sl0rqkQiwALwHx1bIi1f//+6tRfatVqVffdd5/jbW97W2Wh633xi190Tn3v9/u1b9++aguOCQAAAAAAAABLxrIsjRVKk9VV+Xpw1UxgNZcz2YJKptlwBpXTZtNGv0eD2bw2+qdmWPm0LejTRr9nQXsDQCMdG2L19/db1157rfn000/bDMPQxz/+cffP/dzPVRyO+R/58OHDti9+8YuuqVDstttuW9A6AAAAAAAAALBUpgKr6WHVyUxeuUrrPp9ftSydyRa0PTh3u8Dp/n97tinocjQMvACgVZY1yfmTP/kT19T3v/qrv1revn37jFrU3/qt3yq95z3v8UjSgQMHbL/1W7/l+Z//838W5rPH6dOnjTe/+c3eXK5WFmsYhj74wQ+WWnB8AAAAAAAAAGgJy7IUK5Z0Mp2fbAlYC6yyLQysLuZkOtdUiNXtcTV8DgC00rKGWB/96EfdU9VRt9xyS3X79u0z/kZ+5zvfWf7MZz7jOnjwoM2yLH3+8593Dg4OGp/5zGeKu3fvvmR9bLFY1Oc//3nnn/3Zn7ljsZgxtc9dd91VufXWW2klCAAAAAAAAGBZWJal8WJ5Rlh1Mp1TZgkCK0kyJG3webQ16NPWgFd7osEl2RcA5mvZe+pZlnXRgX42m01f/epX8zfffLNvYmLCkKQHHnjAsWfPHscrX/nK6vXXX29OX+OLX/yi8xvf+Ibz5Zdftv34xz+2Z7PZ+mOWZWnTpk3WV77ylXlVcgEAAAAAAADAYowXSpOBVV4nMjmdyuSULi9dYLXe59HWgHcytPJpc8Art52WgAA637KHWBcLsKbs3r3bvPfee/NvectbvGNjY8ZUIPXkk0/an3zySfvU8yzL0v/9v//XOf321PqWZWnjxo3Wfffdl+vp6bHm2AYAAAAAAAAA2uK/HTqhE5l82/cxJK3zubU14NPWoE/bAt7JwMre8FoA6ETLHmI146abbqo+++yz2Xe+853ehx56aMbfuBcLwabCK8uydNddd1W//OUv5/v7+wmwAAAAAAAAALTEpbpMTbcl6Gt5iGVIGvC66y0BtwVrFVYeAisAq8iKCLEkad26ddaDDz6Ye+yxx+yf+cxnXA899JAjmUxe9Pk+n0+33XZb5YMf/GDpNa95DTOwAAAAAAAAACxYvlLVyUxOJ9I5HU/Xvr5p84Bes6674bXbAj59T+OL2n/AW6uw2hb01lsCeh0EVgBWtxUTYk256aabqjfddFPeNE09//zztkOHDtlisZiRSCQMn8+n3t5ea9u2bea+ffuqLpdruY8LAAAAAAAAYIX7m8Mn9eOxhC5s83QinWsqxNoa9M5rv36vW9sCXm2ZrLLaEvDJR2AFYA1acSHWFJvNpmuuuca85pprzOU+CwAAAAAAAIDVy+90zAqwpFqI1YwNPo8chqGKNXuVfo9LW4I+bQv4tDVIYAUA063YEAsAAAAAAAAA5sOyLE0Uy/V2gDtDfl3XE2543fagTw/Pcf+ZbF7Fqim33XbJ6x02mzYHvEqXK9o2WV21NeDTlqBXfgdv0QLAxfA3JAAAAAAAAIBVKVOu1AOrqa+pcqX++Kv7ok2FWNuCvjnvNyWdzuR1WdjfcI0PXb1TTtulwy4AwEyEWAAAAAAAAABWvGK1qpOZ/IzAaqxQuuQ1JzLNtQMc8LrlsdtUqM6ebHI8nW0qxCLAAoD565gQ6wMf+IAnGo3O1Vq25QzD0He/+93m/oUCAAAAAAAA0FEqpqWzubyOp3I6kamFVmezhTnnVl3KcK6ofKUqb4MZVDbD0LaAT4eTGfkddm0L+rQt6NP2oE87Q40DLADAwnREiGVZlg4cOLAkH0WwLEuGYSzFVgAAAAAAAAAWybQsjeaL9eqqE5mcTmXyKpuL/zy8JelkJqcrIsGGz/3FHRvksdvU63Hx/iIALJGOCLEAAAAAAAAAQJLixbKOp7M6kc7rRDqrE5m8cpVq2/Y7nm4uxNoc8LbtDACAuXVMiGVZS9JJEAAAAAAAAECHyFYqOpmeOccqXiovyd79Xre2B33a6CecAoBO1REhlmEYev/731+68sorZ09GBAAAAAAAALDilUxTpzMzA6tz+eKS7B1xOSZnWPlr86wCXvmdHfHWKADgEjrmb+o3vOENlde+9rXtqwsGAAAAAAAAsOS+PTiqJ8biOpPNq7oEzZi8dpu2B321sCro0/agT1G3q/0bAwBarmNCLAAAAAAAAACrz3ixpFOZfFvWdhiGtgS89dBqe9CnPq9bNsNoy34AgKVFiAUAAAAAAACgaclSWSfSOQWcDu0M+Rs+f3vQ15J9DUkb/B5tC/jqodVGv0cOm60l6wMAOg8hFgAAAAAAAICLOpXJ6WA8o+PprE6kcxovliVJ+/uiTYVY2xYYYvV6XDNaAm4JeOWx2xe0FgBgZSLEAgAAAAAAAHBRj4/G9W9nxmbdfyKda+r6fq9bXrtN+ap50ecEnQ5tD/pmzLIKOnnrEgDWOv4lAAAAAAAAANYYy7JUNi257I1b8V2sHeC5fFG5SlU+x6Wro2yGoW1Bnw4lMpIkj92mrYHzFVbbgj51u50ymGMFALgAIRYAAAAAAACwyhWqVZ1I53QsldOxdFbHUjldGQ3qP16+peG1l2oHeDKd055osOEad63v1f6+qLYH/Vrnc8tGYAUAaAIhFgAAAAAAALCKmJal4VxRx9JZHZ8Mrc5kC7IueN6xVLap9XrcLgWddqXL1VmPHW8yxLquJ9zUXgAATEeIBQAAAAAAAKxg6XJFx1JZHUvndDyV1fF07pLzp6aMFkpKlSoKuS79FqFhGNoW9Ov5idSM+7vcTiqqAABttewhlmVd+BkQAAAAAAAAAHOpmKZOZws6NhlWHUtlNVooLXi94+msruluXCW1JxKQaVkz5lhFXM4F7wsAQDOWNcQ6duxYZur7devWkWYBAAAAAAAAkyzL0kSxXJ9hdSyd08l0TpUWfij8WDrXVIj1ho19esPGvpbtCwBAM5Y1xNq2bRvBFQAAAAAAACCpUK3qRDo3WWFVm2WVLFXauufxJudiAQCwHJa9nSAAAAAAAACw1piWpXP5Yn2W1bFUVmeyBbX7E99+h107gj5tD/lrX4O+Nu8IAMDCEWIBAAAAAAAAbZYpV+ph1bFUTsfTWeWrZlv3tEnaFPBqR9CvHSGfdgR96ve6ZRhGW/cFAKBVCLEAAAAAAACANnlsZEL3njqnkUKp7Xt1uZzaHvLVQ6stAZ/cdlvb9wUAoF0IsQAAAAAAAIA2cdiMtgRYLpuhrQGfdoT82h70aUfIpy63q+X7AACwnAixAAAAAAAAgCYVq1WdTOeVr1Z1TXe44fO3B/0t2XfA69aOYC202hHyaYPPK4eNtoAAgNWNEAsAAAAAAAC4iESxrAPxtI6lszqezmkwk5cpqdfjairE6nY7FXY5lCxVmt7T57BrR9A3WWFVq7QKOHkbDwCw9vCvHwAAAAAAAHARx9JZff7I6Vn3jxVKSpUqCrku/faaYRjaHvTpmfHUnI/bJG0KeOtVVtuDPvV73bIZVFkBAECIBQAAAAAAgDXHsiwZTQRFl2oHeDydbaoaa0fQXw+xIi6ndoR82hGstQXcGvDJbbc1f3AAANYQQiwAAAAAAACsehPFko6lcrW2gKmcUuWK/uKGKxpeF3U71eV2aqJYnvXYsVSuqRDrlb0R9Xvd2hHyqcvtWtD5AQBYiwixAAAAAAAAsKoUq6ZOZnI6PhlaHUvlFC/NDqEmiqWmQqUdQb8miolZ9x9LZ5s6z4DXrQGvu6nnAgCA8wixAAAAAAAAsKJNFEt6OZXV0VRWL6dyOp3JqWo1vu5YKqeu3iZCrJBPP40lZtznc9jlc9gXeGIAANAMQiwAAAAAAACsGBXT0plsfjKwqv0an6PVXzOOp3O6oTfS8Hk7Q35t9nvrs6y2h3wa8Lpla2KmFgAAWDhCLAAAAAAAAHSsTLkyGVbl9HIqq+PpnEqm2ZK1j6Waawe4M+TXn12/uyV7AgCA5hFiAQAAAAAAoCNYlqXhfLFeYfVyKquhXLFt+53M5FQxLTlsVFQBANaeYrWqZKmiVLmiVKmiVLmsVKmi5LTbj5w8t6xnJMQCAAAAAADAsihWTZ1I56bNs8oqW6m2dc9+j0vbQ37tCPq0I+QX+RUAYLUwLUu5SlWpckXJUnkyiKqc/1ouK1mqKF2uKFmqNFXZnKxUluDkF0eIBQAAAAAAgCUxXijNqLI6nc2rarVvP6/dpu1Bf22WVciv7UGfgk7eDgMArBwV01J6jgBqqmpqehVVulxp67+ry4F/tQEAAAAAANAWmXJFj4/G61VWE8VyW/cb8Lq1M+TXzpBfl4V8WufzyGZQagUA6Cyz2/hVlCqVlSxPhVTnA6p2Vyh3OkIsAAAAAAAAtEWxauorx862ZW2nzdC2gE87w35dFvJrR9CvkIu3ugAAS8+yLGWntfE7Xy01c9bU1O1iE238UMO/7AAAAAAAAJgXy7JkNFHh1O1xqcvl1ERp8RVYEZdTl4X82hny6bKQX5sDXjlstkWvCwDAXKa38ZseQCXLZaVLFSWnVVGly+VV18avUxBiAQAAAAAA4JKK1aqOp3N6OZWrz7P62CsvV8TlbHjtzrBfPxlLzGs/m6RNAe9kW8Dary63s6ngDACAiylWzQva9tXa+KXKM6umkqW118bPYRgKuxwKuZwKOR0KOR0Kuxzydof10+U81zLuDQAAAAAAgA5WrFb1F8+9rFOZvC5sfHQsldX1PZGGa1wWahxi+Rz2yVlWtSqrbUGfPHb7gs8NAFg7ahVTteApUap9TU7enpotlZxs81eorq02fl67TeGpUMrlUMjpnPxaux12ng+tPHbbnB8WGY4Gl+Hk5xFiAQAAAAAAYE5uu13pcnVWgCVJR5sMsXaG/LPuG/C6J1sD1n6t87llo8oKADDJtCxlytUZYVRyWpXU1O1kqazMGqqYMiQFpwVQQadzsnpqKpg6X0UVcjnkXAVtdwmxAAAAAAAA1pBMuaKXU1ntDPkVcDZ+a+iysF+x0dKs+19O5Zrab5PfqysjAW0L+rQz5NeOkF/BJvYFAKwulmUpXzUvGUhNVUylSpU5P0CxGs3Vxm8qlJpZReVQwOlYcx/64CcGAAAAAACAVcq0LJ3LF3U0ma3PshrOFyVJv3nFVr2qN9JwjZ0hvx4fjc+6/2Q6p7JpNvyUt8Nm6IOv2Lmg8wMAOl+pas6qmLowkJpq8Vc2reU+7pLw2m0KuZyT7fouqJKaqqKafPxibfxQQ4gFAAAAAACwShSrVR1P5/RyKlcPrS42mP7lVLbJEMs35/0Vy9KpTH7OdoEAgJWtalmT4dOFYdT521NhVX4NzJma3savVi1Va+MXdDqmfa2FVEGXQ65V0MavUxBiAQAAAAAArFDjhZKOps5XWZ3O5Jtuv/RyKtvU8zb6vfLYbSpUTfkddu0I+SfnWfm02e9d+OEBAEvKtCxlK9V6IJW4IJBKTQVT5Yoy5YpWe81UvY3fBVVSU7fDk4FUeI228esUhFgAAAAAAAArQMW0dDqbrwdWLyezmiiVF7zeqUxOpaopl/3Snxa3G4Z+4/It6vO6NeB18yYeAHQQy7JUqJqzqqOmvqamh1TlsqqrPJmyG1LY6ay17HPVqqXCk1VTYZez3sov5HLKSxu/FYEQCwAAAAAAoANlypV6YHU0ldWJdE6lFs4SqVrSiUxOu8OBhs+9pjvcsn0BAI2ZlqVMuaLEVMVUqaz4ZBg1dXsqqGrlvw2dyJAUmGzbN1cgFXGdv8/nsPNhi1WGEAsAAAAAAKADTBRLOpLM6kgyoyPJrM7kCm3dL+pyKlOutHUPAMBM5uSsqUSpPPmrFkTNuF0sK7kGqqa8dtv5aqnJ9n0zbk+GVkGXQ3aCqTWLEAsAAAAAAGCJWZal4XxRR5IZvTQZXI0XF94asBGbpC0Br3aG/PVf3R5X2/YDgLWmYlqT1VHlevXU1K/ktNup0uqeNeW0GTOqpS4MqGpt/mrhVKN2toBEiAUAAAAAANB2FdPS6UxOL6WyOprM6mgqo3S52rb9/A77tMDKp+1Bn9x2e9v2A4DVqmSatWCqeL6N3/SQaup2ehVXttokhS5aMTWzxZ+HOVNoMUIsAAAAAACANvnO2TE9M57UsVRORdNs2z7rvG7tDPl1WbgWXA143cwEAYBLKFar58Oo4syKqdr8qVqbv2ylfR84WG5Bp70eQIWmte+bXkUVcjoVcDJnCsuHEAsAAAAAAKBNXkpmdCiRaemaLpuh7cHzVVY7Q34FnLzFAwCWZalQNRW/sGKqOLuCqlBt3wcLlpPXbqsFUnPNl6rf71DQ6ZTDRjCFzsdPOAAAAAAAAPNUMa2m3vzbHQ7oyVhyUXtFXU5dFvbrssn2gJv8Xt54BLCmWJalbKU6o0KqPnOqOP12RaU2Vr0uF0NSyOVQxOVUZDKQqn11KjItnAq5nHIzZwqrDCEWAAAAAADAJZiWpeFcQS8lszqSzOpIKqN9vVH9/Pb1Da/dFfbPe791Xrd2hQPaFfZrV9ivHreL+SIAViXTspQpV+oVUrWQ6oK2fsXa7YplLfdxW85uqNa+z10Lo86HVDNvh1wO2vlhzSLEAgAAAAAAuIhvD47q/sGRWTNRjqSaaxG4ye+V125T/iJtq2yStgS89dDqslBAIRdv1wBY+YqTbf3ixZLixVqVVLw09X25fl91FYZTDsNQ2OVQ1D0VSE39csy4zawpoDF+KgIAAAAAALgIp92YFWBJ0ol0XqWqKVeDtk02w9DOkF8vxNOSzs+zqlVZBbQz5JPHbm/L2QGgHUzLUqpUmQyozgdS8WlfE6WycnP83bnSuWy28xVS7vNt/aaqp6KTIZXfYaeCFmgRQiwAAAAAALCmpMsVpUplbfB7Gz53dygw5/1Vy9LxdE6XR+Z+fLpbB7p1RSSoXWG/tga8ctiYVwKgM+Ur1VoIdWEoNe1rolTWaps65bHbZldLuWfejrqc8ththFPAEiPEAgAAAAAAq1qsUNKRZKY+z2ooV9T2oE9/cu2uhtdu8Hsu2g7wSDLTVIh1Q29kIccGgJapWpaSc4RTF4ZUhYu0Pl2p/A77rPlS06unIpOzqNxUxAIdixALAAAAAACsGqZlaShXqAVWyYyOpLKaKJZnPe9UJqditdrwjUubYeiycEDPT6RmPXYklW3ZuQFgISzLUq5aVaJYOT9/6oLKqXiprGSpotU0eSrotNdb+EWmhVThC6qpGrV8BdD5CLEAAAAAAMCKVTFNnczk66HV0VR2zhlWF6pa0rFUTnuiwYbP3RXy6/mJlOyGtCXgq82zCgV0Wdjfiv8JADCnimkqOW321MVmUJXM1VE9ZUgKzQijZlZPRSfvD7sctGUF1hBCLAAAAAAAsGIUqlW9nMrV2wMeT2dVMhdWX3AklW0qxLqxL6LtQZ92hHy0nAKwaJZlKTs5eypenBZMXRBSpcurp3rK57Ar6nIqOjlnaur7aH3ulFMhl0N25k0BuAAhFgAAAAAA6FipUkVHU5l6pdWpTF6tqjk4ksw09bxej1u9HneLdgWwmpVNc8bcqenhVH3+VKms8gLD905jNwxFXA5F3a7Jr05FXa7Jr7WZU1FmTgFYBEIsAAAAAADQESzLUqxQ0pFUth5aDeeLbdsvWarIsiwZfPIfQBNKVVPxUlkTxZImiuXJX6X610SprHS5cTvTlSLgsE+GUM56KFWvpJq8HXA6ZOPvUABtRIgFAAAAAACWhWlZOpsr1AOrI8ms4qVy2/bb4PPU5lmFA9oV8qvb42rbXgBWlrJpKl4sa7xYUrweUJ0PqeKl0qoJqByGcUGl1OxwKuJ2ysXcKQAdgBALAAAAAAAsiYpp6kQ6r6OpjF5KZvVyKqtspT1vCtsNaWvAVwuswn5dFvIr4ORtEGAtmgqo6iFV6cIqqtr8qdUg6HTMqJyaq5LK77BTgQpgxeCnNwAAAAAA0BYl09SxVFYvJjJ6MZnR8XSubXNg3DabdobOh1bbg3657VQRAKtdxTTroVR8Mpgan/b9RLGs1CoIqFw2Y1oo5VLEPRVWuerhVNjlkJPqKQCrDCEWAAAAAABoi9OZvP7y+WNtWTvotGtXKKDLJtsDbvZ75bBRWQCsJhXTUuKCGVTxaTOoJkplpUoVtScaXxqGpJCrFkhFLqiYmt7mz0f1FIA1ihALAAAAAAC0xdaATy6bTSXTXPRaPW7X+XlWYb/Wed28oQusYFXLUmL63KlpYdVUFVVyhQdUHrutFkxNVVBdOH/K5VTY5SSAB4BLIMQCAAAAAABNKVVNHUtn9VIyq3s29Td849VhM3RZyK+DifS899ro88wIrbrcroUeG8ASq1qWkvW5U9Mrqc6HVIlSeUUHVH6HXV1up7rcLkXdztr3rtr3U2GV12Ff7mMCwIpHiAUAAAAAAOZUtSwdSWbqM62OpXKqWLW3na+KBrUz5G+4xuWRQMMQy24Y2hb0aleoFlhdFvLL7+QtC6ATmZMB1YVzpyaKZcVLJU0UagHV4usvl49vWkDV5aoFVFG3U91uV/17t52ACgCWAj8RAgAAAACAOVmW9JkDJ+ZsB/hiItNciBUOzLrPY7dpR9A/WWnl1/agX267rSVnBrBwpmUpVapooliqhVQXzKOaKJaUKK7sgMprt6m7Xj3lmgyrZlZUeQioAKBjEGIBAAAAAIA5Xaod4IvJjO5Rf8M1tgW96nI5tSXo1eXhgHaHA9oU8MrOPCtgyZVMsxZGFUqKFUsaL9TCqvHJ2xPFsqrWym3y57XbFL0gmKq1+XOqy+OixR8ArECEWAAAAAAArBHFqqljqaxeTGb0qt6INvq9Da+5WDvAo8msKqbVxFwsmz514x4ZhFZAW1mWpVylWg+jYoWSxosljRfKGi+WFCuUlCpXlvuYC+ax22qt/FxzhFST3xNQAcDqQ4gFAAAAAMAqNRVaHU5m9FIio2PpXL3KwmWzNRdizdEOUJKKpqmTmVxTLQUJsIDFMy1LiVK5Xj1VD6mKU/eVVKiuzEZ/LlstoOqe0dbvgoDKbuPvEgBYgwixAAAAAABYJS4VWl1oPu0AXTbbjLlYfoddu8J+2XhDGWiZYtWszaIqlBQrlierqM5XU8VLJVVXYKc/l82oB1L1cGqyvd9Uqz+fw05ABQCYEyEWAAAAAAAr1HxCqwvNpx3gNd0hlU1Tl4cDujwS0Ca/lwALmAfLspSpVOuhVKww2fKvWJqcT1VWegW2+nNOBVQu52RINbvVn5+ACgCwCIRYAAAAAACsEIsJrWatNY92gL95xdYF7QGsFVXLUnxa9VQtnJoMqYolxQrlGdWMK4HDMOphVHRWq7/a9wECKgBAmxFiAQAAAADQoVoZWs3lxUSmqRALWOuK1apihQta/E2bRRUvlrWyIiop6LSr2+1St8dV++p2qmfy+y63S0EnARUAYPkRYgEAAAAA0CHaHVpN8Tvs2h0OaL3P0/K1gZXGsiyly5XaHKr6DKrJkGry+0ylutzHnBebpOi0UGoqrOpx12ZRdbtdcttty31MAAAaIsQCAAAAAGCZFKumXk5l9WIioxeTGR1vY2g1Nc/q8nBAG/weZlphzaiYpuJT86eKZcXqQdVkSFUsqWy2/s9dO3nstnr1VL2Saiqkmmz5x59xAMBqQIgFAAAAAMASIbQCWq9iWpNzp0oaK0z7OllFlSiVtbIiKinkdKjH41LXrGoqp7rdLvmZRQUAWCMIsQAAAAAAaBNCK2DxTMtSslRRrFDU2AVB1VihuOLmUdkNoxZOuV3q8tS+Tq+m6nI75bLR6g8AAIkQCwAAAACAtrn/9IjuGxxp+bqEVlhNLMtStlKdFkyVZgRWK63dn9duOx9KuV3qmayemrov7HLw5xUAgCYRYgEAAAAA0CaXRwItCbEIrbDSFasXhlTnK6lihZLy1ZVRS2VICrucF8yimqymmgyqfA77ch8TAIBVgxALAAAAAIAmTbUHTJbKuqm/q+Hzd4Z8shvGvFsIElphpZmaSzVXJVWsUFKqXFnuIzbFYRiT4ZRzsopq5lyqqNspJ63+AABYMoRYAAAAAABcRNWydCKd08F4WocSaR1L5VSxLPkddu3rizYMltx2u7YHfTqayl7yeQGHXbsnA6vLIwFt8BFaobPU5lKVL1pJNVEsayU0/PM77PXqqekt/nrcTnV5XAo5afUHAEAnIcQCAAAAAOAinp9I6bMHT8y6P1up6my2oE0Bb8M1Lg8HZoVYhFboNFNzqS5WSRUrlFSZZ0Xhcgg67erxuNXrqVVR9UwGVT1up7rcLnlp9QcAwIpCiAUAAAAAwEVcHg7IJmmuaT0vJjPNhViRgL47HCO0wrIrTJtLdWEl1VihpMIKmEvlsdvU43HVQ6reCwIrQioAAFYXQiwAAAAAwJqSKVd0JJnVtd0hGQ2CJK/Dru0hn15O5WY99mIyo9du6G243xWRgP5q/1WEVmi7imkqViwrlq9VUcWKMwOr9AqYSzU1k+p8SDX1fS2sCjjsDf/cAgCA1YMQCwAAAACwqhWrpo4mMzqUyOhgIq3TmbwsSR9/5eVa5/M0vH5PJDhniPVSIiPTshqGU4RXaBXTshQvluesoooVSoqXOn8ulSEp6nbOWUnV63Ep4nLyZwYAANQRYgEAAAAAVpWqZelEOqdDibQOxTN6OZWdc5bPoUSmqRDrykhQ/9/pkRn3+SdnWuWrVfkdvLRG6xSrpkYLRY3mixrNlzRSKGosX5tRFSuWVV0Bc6lCTsecVVQ9Hpe63U45bLblPiIAAFgh+EkbAAAAALCiWZaloVyxFlol0noxkVG+idk+h+Jp3bm+p+HzdoR8Cjod2hrwak8kqD3RgDb5vVSLYMFylWotpCoUNZIvzfg+USov9/Ea8tbnUrnnaPvnktvOXCoAANAahFgAAAAAgBVnvFCaDK0yOpxIK1Ga/6yfw8nm2gE6bDZ9dt+VhFZommVZSper9YqqkXxRo4WSRvJFjRWKSpery33ES3IYxpyVVFMhlZ+5VAAAYIkQYgEAAAAAOl62XNHhZEaH4hkdSqR1Ll9c9Jq5SlUnM3ltD/oaPpcACxcyLUvJUrlWSVUPq85/30w14HIxJHW5nReppHIr7HLwex4AAHQEQiwAAAAAQMcpVU0dTWV1MJHW4XhaJzN5tXoSULfbqXR5/hVcWDuqlqWJQkkjhekt/2qzqsYKRZXMzp1PFXI6LlpJ1eV2yWEjpAIAAJ2PEAsAAAAAsOxMy9LJdE4HE7VKq6PJrCpWawMCv8Nem2kVCWhPNKg+j4uWaFDZNBWrt/orTYZURY0USooVSqq2+Pdhq3jttlmVVFNzqmpzqWzLfUQAAIBFI8QCAAAAACw5y7I0nC/qUPz8XKtWt19z2QztCge0JxLUldGANvm9tEhbo4rVqkYnq6lmtv8raqJYbnmVXyvYJPV4XOrzutU3R9s/v5O3dAAAwOrHTzwAAAAAgCURL5Z0KJHRwcngKlEqt3R9m6TtIZ+uiAR1ZSSoHSGfnDaqUdaKbKWisXytkmqkUKx/P1ooKlHqzLaRDsNQn9elPo9b/V63er0u9U9+T8s/AAAAQiwAAAAAQBsdiqf11HhSh+JpDeeLLV9/g8+jPdFatdXl4YC8DnvL90BnsCxL6XJ12lyqokantf/LVKrLfcQ5uW029Xld6ve661VV/ZPBVdTtpDoQAADgEgixAAAAAABt82QsqUeGYy1br8vt1JWRoK6I1IKriNvZsrWx/EzLUrJU1si0KqrRyfZ/I/miCi1uOdkqfoddfV63+j0u9Xrdk9VUtVaAIaeD2WsAAAALRIgFAAAAAGibK6OBRYVYfoe9HljtiQbV73ERCKxwVcvSRKGkkfqMqplhVdnsxAlVUsjpmKymOt/+r1ZZ5VKA+VQAAABtwU9ZAAAAAICmWJalc/miDiUyMiTdsb6n4TWXhwMyJDUbSzhthnaFArpyskXg5oCXdmsrkGVZSpTKGs4VdS5f1HC+oJFcUSOFkmKFoqodmFMZkqJup/o9k+HU9FlVHhetKgEAAJYBIRYAAAAA4KLS5YpemEjpYCKtw/GMJkplSVK326nb13U3rIryOx3aGvTpRDo35+OGpG1Bn66MBLUnGtCOkF8um63V/zPQJsVqtRZSTYZV53IFDec7t/WfTVKPp9bmr3+yimrq+x6Pi997AAAAHYYQCwAAAABwUYcTGf3tS6dn3T9eLGusUFKf191wjT2RwIwQa73Poz2TLQJ3R/zyO3hp2slMy9J4saRzU1VVuaLO5Qs6lyvWQ81O4jCMmVVUXtfkjCq3utwuOWxU9gEAAKwUvFIAAAAAAFzUFZGLtwM8lEg3FWJd0xVWolTWlZGgrogEFXU7W35OLF62UpkzqDqXL6pidVb/P7fNpj6va9pcKrf6J4OrqNtJC0oAAIBVghALAAAAANYQy7J0OpvXsVSuqZlWQadDmwNencrkZz12MJ7Ra9Y1XuOysF+Xhf0LOi9aq2JaihWKGs4XdS5Xm1U1FVSlypXlPt4Mfoe91upvsuVfPajyuhVyOhq2sgQAAMDKR4gFAAAAAKtculzRwXhaL0ykdCCRVrJUCyte0RVSj8fV8PorIoE5Q6zDibRMy6LqpcNYlqV0uapz+cL5WVWT348Viqp2UFFVyOmYrKaqtfzrq1dWuRRw8pYFAADAWsdPhMvMNE2dOHHCeP755+2Dg4NGIpEw3G63otGotWvXLvPGG2+ser3elu6ZSqX0gx/8wP7SSy/ZU6mUvF6vtm7dar761a+ubty4saUvZ1544QXbk08+aR8aGjKq1aq6u7utvXv3mvv37686nbQQAQAAANqhalk6nsrq+XhaB+JpnUznLtoO8NaB7obrXRkJ6t/OjNVvG5K2Bn3aEwmobJpy2+2tOzyaVjZNjebnrqrKVqrLfby6oNOuAa9HA163Bnzu87OqPC55HfzeAQAAwMURYi2DiYkJff3rX3c+8MADju9973v28fHxi35s0el06g1veEPl/e9/f+mOO+5Y1KuQY8eOGX/8x3/s/vrXv+4slUqzHjcMQ7fcckv1Ix/5SPH2229f8F6maerzn/+885Of/KTr6NGjtrme09XVZf36r/96+Q//8A+LgUBgoVsBAAAAmDReKOmFeFoH4ikdjKeVr5oNrzkUby7E2hX2a6Pfo93hgPZEAro8HJCfKpklYVmWEqXKzKqqXEHD+aJihdKc4eRycBiG+rxurZsMqga8bq3z1YIrKqoAAACwUPwkucR+4zd+w/OlL31pzhBpLuVyWffdd5/jvvvuc/zSL/1S+b//9/9eCIfD8973//yf/+N473vf683lchd9jmVZevTRR+133nmn73d+53dK//W//teizTZnBnVR8XhcP/dzP+d75JFHLvlxuomJCeMv/uIvXP/8z//svPfee3N79+5t/AobAAAAQF2pauqlZKYeXA3livNe41AiI8uyGs4Wctvt+uj1ly/0qGhCsVqdDKhqQVUtsCroXL6oQhOB5FKJuBy1qirfVGDl0TqvWz0eF20lAQAA0HKEWEvsJz/5iX2uAMtut2tgYMDq6+uzyuWyBgcHbclkcsZzvvKVrzhfeukl2yOPPJILBoNN7/lP//RPjne84x1e05z5wqenp8fauHGjNTY2ZgwNDRmWVfsMn2VZ+tSnPuUqlUr6q7/6q6ZfCedyOb3uda/zPfnkkzMCLJfLpS1btpgul0snT560ZbPZ+mMnTpww7rjjDt+PfvSj7K5duzrlQ4QAAABAx7EsS8P5ol6YSOmFeFovJTMqm4v7ETpVruhMrqBN/ta2MMfcTMvSeLE0O6jKFTVRKi/38epcNlu99d+Ad2ZVFe3/AAAAsJQIsZZRJBLRL/zCL5Tvvvvuym233VYJhUL1xyqVir7//e/bP/zhD7t/9KMf1V8lPPnkk/Zf+ZVf8f7Lv/zL7KnKczh69Kjx3ve+d0aAtXfvXvPTn/504a677qq3DDx8+LDtQx/6kPvee++t/5743Oc+57rllluqb33rWyvN7PX+97/fMz3Astls+r3f+73SBz7wgWJXV5ckqVgs6stf/rLzd3/3dz3xeFySFIvFjJ//+Z/3Pfnkk1mHg9+SAAAAwJRspaJD8YwOxNN6IZ7SRLF1QYfdkHaG/Cp3UJXPapGrVOst/+qzqvJFjeSLiw4eW8WQ1OV21sOpWmVV7fuo20lVFQAAADoCicEy2LJli/WhD32o+Mu//Mtln88353McDofuvPPO6m233Zb7jd/4Dc8XvvAF59Rj//qv/+p46KGH7NNDqIv5oz/6I8/0yqfrr7/efPjhh7MXtiS84oorzG984xv5X//1X5+x1+///u973vzmN2ecTqcu5dChQ7YvfvGLM57093//9/l3vOMdMwIwt9ut9773veUbb7yxeuutt/oTiYQk6bnnnrN96Utfcv7ar/1a53z8EAAAAFhipmXpZCavA5PVVsdSWbUyYur1uLQ3GtRV0ZCuiASoqlmEqmVprFCaEVZNza1KlZv6HOCS8NptGpgMqqa3/+v3uuWyz699PAAAALDUCLGW2Ec+8pHi61//+orb7W7q+Q6HQ3/zN39TeOaZZ+xPP/10/RXG5z//edddd911yWqsF154wfa1r32t/t/Y5XLp7//+7/MXm6lls9n0uc99rvD973/f/vLLL9sk6fjx48bnP/955/ve975Lhkt/8id/4q5Wz2dqb3/728sXBljT7d271/yLv/iLwm/8xm94pu776Ec/6n7nO99Zdrlcl9oKAAAAWFUSpbIOxtN6YSKlg4m00uWGn1Vrmstm0xWRgK6KBrW3K6R+j6vh/CvMVDZNncsXdTZb0NlcQUPZgoZyBY0WSqpanVFVZVMtoKyHVT53fW5V2OngvzkAAABWLEKsJfYzP/Mz8/5InsPh0Ac/+MHiL/7iL9Yb1X/nO99p+JHJL3zhC87pbQTf+ta3lq+88spLfpDT6/Xqgx/8YOk//sf/WA+XvvjFL14yxJqYmND0NoSGYehP//RPG87Seu9731v+8z//c/fp06cNSTp9+rTx4IMP2u+5557WvWoHAAAAOkzFNHU0ldUL8bQOTKR1OttUp/CmbfR7tDca0t5oUJeF/XLaqLZpRuWCsOpsrqCz2YJG88WWVsMtRtBpr4VT0+ZVrfN51OdxycF/ZwAAAKxChFgrxK233joj2JmYmDCy2az8fv9Fr7n//vtn/Pd9z3ve01Srvre//e3l3/md36m3IXzqqafsZ86cMTZu3Djnxwzvu+8+Z6VyPpu79dZbqzt37mz4kUS73a5f+ZVfKX30ox+tl6X967/+q5MQCwAAAKvNaL5YC63iKR1OZFRo4Rwqv8OuK6PByTaBQUXddDa4lIppaiRfrIdUZ3O1yqqRfFHVDiischiG+uqt/84HVQNetwJOXsIDAABgbeEn4BWiq6tr1supRCJh+P3+OV9mHT582Hbs2LH6R/H8fr9uvvnmpsKhQCCgG2+8sfrII4/YJcmyLN13332Oi1VjffOb35zx++iuu+5qutrsda97XfWjH/1o/fa3vvUtfk8CAABgVfnKsTP6ztlYy9YzJO0I+XTVZLXVtqBPNtrFzVIxrWlhVV5Dudr3I/lCR4RVEZej3vJv+qyqbo9Ldv57AgAAAJIIsVaMM2fOzHoV09PTc9GXXs8888yMXhKvfOUrq06ns+n9brrppspUiCVJzz33nF3SnCHWc889N2OvV7/61U1XUt1www1Vt9utYrHWfXB4eNgYGRkx+vv7O+BlJQAAALB4W/y+Ra8RdTm1tyuoq6IhXRkJyE9FTl3FtDRaqLUBHJrWBvBcvrjsM6tcNkP90yqppldVeR0NO8QDAAAAax6vfFaIRx99dMZ/q82bN1tut/tiT9ehQ4dmvCK64oor5tWv5MLZWS+++OKcDdZLpZKOHz8+47Grrrqq6b08Ho+2bdtmTl//0KFDtv7+floKAgAAoKNVTEsOW+OKmauiwXmv7TAM7Q4HdFVXUK+IBrXe55Gxxqtzqpal0QvbAGYLGu6AsKrb7ZyzqirqdlIlBwAAACwCIdYK8aUvfWlGGdUb3vCGS7bsO3LkyIxgaePGjfMKsTZt2jTjVeCF6005duyYbfo8LK/Xq97e3nm9gty4caP14osv1m+/+OKLtttvv50QCwAAAB2lalk6nsrpQDylF+JpmZalj1y3u+F1EbdTm/weDWYLl3zegNetvdGg9naFtDsckNs+54/gq545R1h1NlfQuVxRlWUMq+yGNOD1aIPfo/U+j9b73BrwetTvda/Z/1YAAABAuxFirQD33Xef44c//OGMyqpf/dVfLV3qmrGxsRkf99u0adO8QqwLQ69YLDbnxwdHRkZm3L9+/fp5T6jesGGDKan+v290dJSPKgIAAKBjDOUK+sbJYR1KZJSrzPysVbJUVtjVuG333q7QrBDLY7fpykhQV0WDuqorqF7PxTstrEamZWm0UNLZbL5eVXU2V9BwB4RV/d5aSLXB59EGv1cbfLWwqpnKOwAAAACtQ4jV4cbHx/W+973PM/2+N73pTZX9+/dfMizKZDIzbvv9/nntGwgEZrxqLJfLKhQK8nhmHGXWPj7f/Pv9+/3+GXtlMpmWvDI8d+6ccWGYN5fh4WHjgts6ePBgU3v09vaqr69vgScEAADASuA0DD0ZS8752IF4Wq/u72q4xt5oUN8aHNXWgFdXRUPa2xXUjqB/TYQipmVprFA6X1U1ObtqOF9Q2Vy+sMomqd/r1ga/ZzKs8kwLq6isAgAAwMoxOjqqsbGxtqw9PDzclnWbRYjVwarVqt7+9rd7z549W39lGw6H9bnPfe7SfUg0OwjyeDzzenXo9XrnXPPCdRa7z+Q1M25ns9mWvJL/b//tv7k+9rGPueZ73cc//nF9/OMfb+q5H/7wh/WRj3xkvlsAAABgBen1ujXgdetcvjjrsRcmmguxLgsF9Ff7rlSoiaqtlcq0LMUKpZkzqyZ/LXdY1Tc9rJoMrAYIqwAAALBK/PVf/7X+9E//dLmP0RaEWB3s//1//1/3gw8+OOO/0V//9V/nt2zZ0vAVYLFYnBEEuVzzy3Lc7tmtTHK53Kz7CoXCovaZa698Pj/vNQAAAIBm5SpVHU6k9cJEWm/dtk5+Z+OXRXujwTlDrIOJlEzLks249OewHDZj1QRYU2HVUK4wI7AazhVUWsawytBkZZXPo/X+mWGVk7AKAAAAWJEIsTrUpz/9addnP/vZGYnQ7/zO75Te/va3V5q53u12W6q9jpMklUqXHKE1S7E4+wX6XNVZF1ZezXefufa6sDILAAAAWAzTsnQqk9cL8ZQOTKT1ciqrqd7ce6JBvao30nCNq7pC+s5QbNb96XJVg9m8tgTm31a705mWpfFiqd7+73x1VVElc96jcFvG0GRl1WRV1VRgNeBzy0VYBQAAAKwqhFgd6Mtf/rLjAx/4wIzypF/+5V8uf+ITn5idLF3EhTOtLqyYamSuaqgL12zFPpPXzLh94YyshfpP/+k/lX7hF36h3Oh5X/7ylx2f+MQn6v9/f+hDH9Iv/dIvNbVHb2/vIk4IAACAdkmWyjoQr1VbHUyklS7P/VmwA/FUUyHW5WG/HIahimXJZTN0eSSovdHar37v7C4GK4llWRovlqdVVeU1lK2FVcXlDqs8rnpItX6ysmqd1yOXnbAKAAAAmPKbv/mbeutb39qWtb/yla80PX6nHQixOsy9997rePe73+21rPM5zs/+7M9WvvjFLxZs8/hUYSAQmHE7m83O6xwXzrpyOBxzVmJduM9cLQcbuXAG1lxh2UIMDAxYAwMDDddat26ddcFtXXnlla04AgAAAJZIxTT1cipXq7aKp3Uq01yL6hcm0rIsS0aDdoBuu12/tGOD+rxuXRb2r9iKn1ylqsFMXqezeZ3O5OtzqwrV5Q2rejyuevu/DYRVAAAAwLz09fWpr6+vLWuvW7euLes2ixCrgzz00EP2t73tbd5K5fynRO+4447qP//zP+cdjvn9p+rt7Z0RzAwODs7r1d+ZM2dmPL+np2fOMKi/v3/G/UNDQ/N+lXn27NkZ1/T19S1fI30AAACsGPFiSc9NpPTcREqHE5kFBTHxUllDuYI2+Gd/YOtCt6/vWcgxl4VlWYoVSzqdyWswW9DpTC20ihXn3/67lXo9rnpF1VQ7wHU+j9yEVQAAAADmQIjVIR577DH7W97yFt/01nr79u2r3nvvvTm3e/7tSXbt2jXjFfx8Q6zTp0/P+Cjq7t2753xHYMeOHabD4dBU8JbP5zUyMmJcGG5dyuDg4Iy9rrjiiuX7GCgAAAA6lmlZOpnJ69nxpJ6bSDVdbdXIC/F0UyFWpyqbps5mCxqcrK6aqrLKL2N1VY/bNaOqqhZWueW225ftTAAAAABWHkKsDvDss8/a7rnnHl8mk6nfd/XVV5vf/va3cxe262vWFVdcUZ1++/Dhw/MKsQ4dOjTj+RcLsVwul7Zt22YePXq0/vyDBw/a+vv7q3M9/0KFQkEnT56csRchFgAAAKYUqlUdjKf17Hit4ip1kdlWCxFxObU3GtTWgK9la7ZbulzRYCavU5NB1WA2r+FcQdVl6mXQ7XZqg987ObPKrQ1+r9b73PIQVgEAAABoAUKsZXb48GHb6173Ol88Hq/ft3v3bvOBBx7IRSKRBa977bXXzgiCnnrqKXu5XJbT6Wzq+scee2zG742rr776oqHU1VdfPSPE+tGPfmS/4447mgqxfvrTn9qLxWL9drNzrAAAALB6jeWLem4ipWcnUnoxkVHFas2Phw7D0O6wX1dFQ9rbFdQGn6fhLKzlYlqWRgulehvAqSqreKm8LOfpdjvnbAPodRBWAQAAAGgfQqxldOLECeO1r32tb2xsrP7KeevWrdZ3vvOd3Hza8c1lz5495vbt263jx48bkpTNZvXDH/7QfvvttzcMlzKZjH7yk5/UX40ahqGf+ZmfuehHXu+5557K1772tfrvpYcfftjxx3/8x00123/wwQdnvOq9++67W/fRWgAAAKwIVcvSsVRWz06k9Nx4SmdzhcYXNWnA69beaFBXdYV0edjfke3silVTZ6ZVVp3O5jWYKahoLn2Dgi6XU+svaAO4nrAKAAAAwDIhxFomZ8+eNe666y7/2bNn6wHW+vXrrYceeii7adOmlnzU9J577in/1V/9lWvq9he+8AVnMyHWP/7jPzqntza87rrrzI0bN170TPfcc0/Z4XB4puZiPfroo/aXX37Z2Llz5yX/d5imqS9/+cuu6ff97M/+LCEWAADAGpCtVPTCRFrPTaT0/ERK2UpThfwNeew27YkEdVU0qL3RoHq9858v2y6WZSlZqtRnVk19HckXtdStCPwOuzb5vdoU8Gijz6sN/lpY5SOsAgAAANBBCLGWwfj4uF772tf6pqqkJKmnp8d68MEHczt27GjZ69f3vOc95c997nMua7L9yle/+lXnhz70odKVV1550Y905vN5feITn5gRLL3rXe+6ZFVVd3e33vSmN1X+5V/+xSHVXpx/+MMfdn/lK1+55Edo/9f/+l/OU6dO1f8/2Lx5s/W6172OEAsAAGAVsixL5/LFerXVkWRGraoz2ujz6BXdIV0dDWlHyC+HbflbBFYtS+dyxXpQNdUOsJUzvZrV63Fpc8CrzX5v/WuX29mxrRQBAAAAYAoh1hJLpVJ6/etf7z98+HB9hlQkEtG//du/5S4VLi3EK17xCvM//If/UG/1VyqV9M53vtP78MMPZ8Ph8Kznm6ap3/7t3/a8/PLL9bNt27bN+rVf+7WGjff/7M/+rHjvvfc6zMmWJ//4j//ofOMb31h5xzveMeer9AMHDth+//d/3zP9vj/4gz8out2d80lZAAAAtMbhRFp/d2RQI4WmOk435DAMXREJ6OrukK7uCqnXs7w/Q+Yr1XpIVWsFmNeZXEFlc2nrqxyGoU1+jzZNC6w2+b20AgQAAACwYhFiLbE3velNvqeeeso2/b7f/u3fLsZiMeOBBx6Y16vLG264odrV1XXJ53zsYx8rfOtb3wrkcjlJ0lNPPWW75ZZb/J/5zGcKd955Z71ny4svvmj7/d//ffe999474/fEn//5nxdcLpcaueqqq8x3vetd5S984QvOqfve+c53eg8dOlT6wAc+UJw6Z6lU0j/8wz84f/d3f9eTSCRmXP/ud797eaZUAwAAoK3CLueiA6ywy6Gru2qh1ZXRoDzLMNvKsixNFMuz2gGOtSicm4+g06EtkyHVVHXVgM8tO9VVAAAAAFYRQqwl9uijj856tf1nf/ZnC/ro6EMPPZSbHkTNZdeuXdbf/u3f5n/5l3/ZO9VW8IUXXrDdddddvp6eHmvTpk3W2NiYcfbsWWPq8Sm/+Zu/WXrb297WdL+Tz372s4VnnnnG/vTTT9ukWmXXxz/+cdenPvUp15YtW0y3262TJ0/aps/bkqTu7m7rq1/9at7pdM65LgAAAFa2dV63ej2ueYc9WwJeXdMV0jXdYW0JeGVbwoCmYpo6mytoMFOY0RKwVbO7mmVIGvC6Z1RXbfZ7FXY5aAcIAAAAYNUjxFoDfumXfqliWVb+13/91735fL5+fywWM2Kx2JyvfN///veXPvWpTxXns4/f79eDDz6Y/bmf+znf9773vXpYVyqVdPToUdtc12zZssW69957c5dffnlLWykCAACgfUqmqRcTGT03kdLPb1snd4OqKMMwdE13SN85G7vk81w2Q1dGg7q6K6yru4KKuht3BGiFTLlyvh3gZIXVUK6oqrW07QDdNps2BTwzWgFu9Hsa/v8LAAAAAKsVIdYa8Y53vKOyb9++zB/90R95vvGNbzjK5bk79918883VP/3TPy3ecccdC/qIaXd3tx566KHc3/7t3zo/9alPuY4dOzZneBWNRq1f+7VfK//RH/1RMRgMLmQrAAAALKF4saznJlJ6biKpg/GMSpOzUK+KBnVt9+x5qxe6pis8Z4jV5Xbqmq6Qru4O64pwQC77nD8+toRpWYoVSjo1WVU1FVhNFJe+q3XU5axXVW0K1EKrPo9rSavNAAAAAKDTEWItMcuy0su1986dO61/+qd/yieTST366KOOI0eO2NLptDwej7Zs2WLefPPN1U2bNi3646Z2u13ve9/7yu973/vKzz33nO2pp56yDw0NGdVqVd3d3dbevXvN/fv3V5uZtQUAAIDlZ1qW/uTpl5Quz+40/dx4qqkQa3fYL4/dpmLV1I6QT1d3hXVNV0gb/Z62tMUrVU2dyRU0OG121WA2r0J1aRsA2A1pnc9TD6u2TH4NOnkpBgAAAACN8MppDQqHw3rTm97U9Kyrxbj66qvNq6++mlaBAAAAK5jNMPSKaFA/Go3PeuzZiZQsy2oYRDlsNv0/V27TBp9HIVdrZ6GmSuV6VVXta0HDuYKWthmg5LXb6tVVmyerq9b7PHLa2lddBgAAAACrGSEWAAAAsIaZltVUC7uru8NzhliJUlmns3ltCfgarnFFZPFtpPOVqk5mcjqezulEuvZ1OdoB9npc2jQVVvm92hTwqMftaktVGQAAAACsVYRYAAAAwBpiWpaOpbJ6diKl58ZTekVXSD+/fX3D666KBmU3pOoc5U3PjqeaCrHmq2KaGswWdDyd0/F0VifSOQ3niktaYeUwDG3we85XV/m92hjwyO/gpRQAAAAAtBuvvAAAAIBVLlep6kA8pWfGU3phIqVMpVp/zJSaCrF8Drt2hwM6lMjU7/M77HpFV0g7Qv5Fn9G0LJ3LF+vVVSfSOZ3O5FWxli6yCjrt9dlVU6HVgNcjh43qKgAAAABYDoRYAAAAwCp0LleoV1sdSWXmrKCSpKFcQaP5ovq87oZrXt0VUqJU0TVdIV3TXQuv7AtsnxcvliYrrGqB1Yl0Tvnq0oxSNST1e93aHPDOaAkYcTloBwgAAAAAHYQQCwAAAFgFKqalo6mMnh1P6dmJlEbyxaavfW4ipddu6G34vNdu6NXrN/bN+2zZSkUn0/kZbQETpcq811kIl82mTX7PjOqqTX6P3Hb7kuwPAAAAAFg4QiwAAABghUqXK3p+IqXnJmptAhdayfTseHMhlq2JKqWSaep0Jj+jLeC5eQRqixFxObXZ76lVVk1WWfV73U2dGwAAAADQeQixAAAAgBXCsiydyRX03GS11bFUVq2YGPVSMqNitTrv6iTTsjScK8xoCziYzV+0dWErBRx2bQ/6tG3ar7DL2f6NAQAAAABLhhALAAAA6GAl09SLiYyem0jp2fGkxovllqzrshnaEwnqmu6Qru4KNQywLMvSeLFcr7A6ns7qVCavwhLMsXLZDG0N1IKqqeCq1+NifhUAAAAArHKEWAAAAECHSRTLtdBqIqmD8YxKZmuCoi6XU1d3h3RNd1hXhANy2W0XfW6mXKlXV019TZXbP8fKJmmj31sPrLYHfVrv98hOYAUAAAAAaw4hFgAAALDMLMvSqUxez05WW53M5FuyriFpe9BXC666wtrk98xZvVSsmjqdyc1oCzhaKLXkDI30eVz16qrtQZ82B3xyXyJcAwAAAACsHYRYAAAAwDIwLUtHU1k9FUvqqViiZW0CPXabrooGdU1XWK/oCip0wZyoqmXpbLYwoy3g2WxB7W8KKIWcjhkVVtuCPgWcvCQBAAAAAMyNV4wAAADAEqmYpg4lMno6ltTT48mWtefr9bh0zWS11e6wXw5brZLJsiyN5ov16qoT6ZxOZnIqmVZL9r0Uj902Y47V9qBPXW4nc6wAAAAAAE0jxAIAAACWwN8dHdSPR+PKVxdf82STdFnYr2u6wrq6O6R1XrcMw1CqVNaBeHrGHKtMpbr4wzdgN6RNfu+MtoDrfB7ZCKwAAAAAAItAiAUAAAAsgUy5sqgAy++wa280pGu6Q7oqGpTDZuhkOq/nxlP6l8m2gK1qSdjIgNc9o8JqU8Arl405VgAAAACA1iLEAgAAAJbA9T0RPRlLzuua9T63rukK66poUG67TacyeR2Mp3X/6RGdzRXU/qaAUsQ1NcfKr+1Bn7YGvfI7eBkBAAAAAGg/Xn0CAAAACzSaLypdrmhHyN/wuVd3hWQ3DFWti0dPdkPaFQ5oZ9Anv8Ou8WJZLyUzevDsmCqXuK5VvHabtgVnzrGKul1t3xcAAAAAgLkQYgEAAABNsixLZ3IFPRVL6qlYQoPZgrYFvPrwdbsbXutz2HVlJKDn4+kZ9ztthrYEfAo57cqVTZ3K5HU4kWnX/4Q6h2Foc8BbD6y2BX0a8LqZYwUAAAAA6BiEWAAAAEATXkpk9MUjpzVSKM24/0Qmr/FCSd2exhVL1/VE9Hw8LZfNULfHpappKVYo6eVUtl3HliQZktb5PNoW9NbbAm70e+RkjhUAAAAAoIMRYgEAAABNiLqdswKsKU+PJ/XaDb1zPhYvlnUkmdFLyawOJ2tVWCXT0nCu2Lazdrmd9eqq7UGftgZ88jrsbdsPAAAAAIB2IMQCAAAAmtDndWuT36PBbGHWY0/GEnrthl5ZlqWxQkkvJTM6kszqpWRGoxcJvlrF57DPCKy2BX2KuJxt3RMAAAAAgKVAiAUAAIA1K1+p6rmJlK7pDsljb1yp9MqeiAaz52bdfySZ1WcPHteJdE6JUqUdR5U0NT9rao5VrS1gn8clgzlWAAAAAIBViBALAAAAa0qqVNYz4yk9FUvoUCKjimXpN6/Yqlf1Rhpee01XSP9yanaIZUl6ZjzV0nMakjb4PbXqqoBP20M+bfB55bARWAEAAAAA1gZCLAAAAKx644WSnhpP6qlYQkeSWVkXPP5ULDFniFWqmjqWzupIMqsjky0C2yXgsGtXOKDLQrUKqy1Bb1PVYQAAAAAArFaEWAAAAFiVhnIFPRVL6ulYQicy+Us+97mJlMqmqbJp6WgqW59pdSKdU9W6MPJqjajLqd3hgHaF/dodDmidzy0bbQEBAAAAAKgjxAIAAMCqYFmWTmXyejJWq7gazhebvrZQNfUHP31RsWJpVpVWqwx43fXAalfIrx5mWQEAAAAAcEmEWAAAAFixTMvS0WRWT44n9HQsqfFiecFrjRVLLTuXIWmj36Pd4YB2hwO6LOxXxOVs2foAAAAAAKwFhFgAAABYUcqmqcOJjJ6MJfTMeErpcmW5jyS7YWhb0Ktdk1VWl4X98jv4URsAAAAAgMXglTUAAAA6XqFa1QsTaT0VS+i5iZTyVXNZz+Oy2bQz5NOucEC7w35tD/rlttuW9UwAAAAAAKw2hFgAAADoSJlyRc+Op/TUeEIH4mmVzXZNq2rM57BrV8hfD622BHxy2JhnBQAAAABAOxFiAQAAoGPEi2U9PZ7UU7GEXkxktFz1VhGXo9YaMOzX7lBAG/we2QxCKwAAAAAAlhIhFgAAAJbVSL6op2K14OpYOrcsZ+j1uLR7sspqVzigPo9LBqEVAAAAAADLihALAAAAS8qyLJ3JFvRkLKGnx5MazBaW/AwbfZ7zlVZhv6Ju15KfAQAAAAAAXBohFgAAAJZExbT09ZPDeiqW0GihtGT72iRtDfomA6uALgv5FXDyYzAAAAAAAJ2OV+8AAABoO9OydDaX12MjE0qWK23dy2kztCPor4dWO0I+eez2tu4JAAAAAABajxALAAAALVcxTZ3M5PVSMqOXklkdTWaUr5pt2ctrt+myUG2W1e5wQFuDXjlttrbsBQAAAAAAlg4hFgAAABalYloqVKuKFUo6EE/rYCKtY6msSqbVlv1CTke9ympX2K9Nfq9shtGWvQAAAAAAwPIhxAIAAMC8mZalp2NJPTwU09FUVoYhldsUWnW7nZOBVUC7w34NeN0yCK0AAAAAAFj1CLEAAADQlFLV1OOjE/ru8LgGs3lVp2dWLcyv1vvc2hUOaFeoVm3V7XG1bnEAAAAAALBiEGIBAABgTpZl6UyuUGsRGE/rpWSm5dVWhqQtAW+9yuqyUEAhFz+iAgAAAAAAQiwAAABMkyqVdTCR0YF4SgfjaSVKlZau7zAMbQ/66qHVzpBfXoe9pXsAAAAAAIDVgRALAABgDauYpo6msjoQT+tAPK1TmXxL1/fYbdoZ8mtX2K/doYC2hXxy2Wwt3QMAAAAAAKxOhFgAAABriGVZGs4XdXAytDocT6tkta5FoF3S7khAV0WDujwS1JaAV3bDaNn6AAAAAABg7SDEAgAAWOUy5YoOTWsROF4st3R9j92mXSG/blvXrauiQbnttAcEAAAAAACLR4gFAACwylRMS8fT51sEnkjn1LpaK8nvsKvb7dSWgE+v39CrjQFvC1cHAAAAAACoIcQCAABYBUbzxXpodTiRVr5qtmxtuyHtCPp1VVdQV0VD2hrwykaLQAAAAAAA0GaEWAAAACtQvlLVoUS6PttqtFBq6fr9HpeujIa0tyuoy8MBeR20CAQAAAAAAEuLEAsAAGAFMC1LJ9M5vRCvBVcvp7JqXa3VeWGnQ39w9U71+zxtWB0AAAAAAKB5hFgAAAAdarxQqrcIPJRIK1uptm2vPo9LN/ZGdWNfhAALAAAAAAB0BEIsAACADlGsVnU4kam3CBzOF9u6X9Tl1Kt6I9rXF9XWgFcGc64AAAAAAEAHIcQCAABYJqZlaTCb1wsTtRaBR1JZVS2rrXsGnXbd0BPRjb1RXRb2y0ZwBQAAAAAAOhQhFgAAwBJKFMv1FoEHE2mly5W27+m123R9T0Q39ka0JxqUneAKAAAAAACsAIRYAAAAbVSqmjqSyupAPKUD8bTOZAtLsq/LZuia7rBu7I1ob1dILpttSfYFAAAAAABoFUIsAACAFrIsS2dzBb0Qr7UIfCmZUdlsb4vAKXbD0Cu6grqxN6prukPy2O1Lsi8AAAAAAEA7EGIBAAAsUqpU0cFEWgfiKR2Mp5Uotb9F4BRD0p5IUDf2RXR9d1h+Jz/eAQAAAACA1YF3OQAAAOapYpo6msrWZ1udyuSX/Ay7Qn69qi+iG3oiCrucS74/AAAAAABAuxFiAQAANGBZls7li/XQ6sVERkXTXPJzbAl4ta83qlf1RtTtcS35/gAAAAAAAEuJEAsAAGAOuUpVB+NpvTDZInC8WF6Wc6z3uXVjb1Q39kY04PMsyxkAAAAAAACWAyEWAADApIliSU+PJ/VMLKUXkxlVLatla/sddl0ZDerKSFBXRYP6yrGzeno8Oedze9wu7euL6MbeqDb6PTIMo2XnAAAAAAAAWCkIsQAAwJplWZbO5Ap6JpbU0+NJnWzhbCu7Ie0I+nVVtBZabQ36ZJsWRu3ri8wIsSIuh27ojWhfb1Tbgz6CKwAAAAAAsOYRYgEAgDWlalk6mszqmfFacDVWKLV0/ctCfr1xY5+uiATkddgv+ryru0Lqdju1NxrSjX0R7Q4HZoRcAAAAAAAAax0hFgAAWPWK1aoOxNN6OpbUcxMpZSrVtu1lydJ1PeGGz3Pb7frkq/ZQcQUAAAAAAHARhFgAAGBVSpXKemY8pafHkzqUSKtsLn6+lSFpW9CnvdGgJopl/WBkYtZzXk7lNFYoqtfjbrweARYAAAAAAMBFEWIBAIBV41yuoKcng6tjqawWH1tJUZdTe7uC2hsN6YpIQAFn7cen4VxhzhBLkn4yltDdm/pbsDsAAAAAAMDaRYgFAABWLNOydDydq823iiU1nC+2ZN2Nfo+u7Q7r+u6wtgS8c1ZMrfN5tCXg1alMvn6fIenycEAD3sZVWAAAAAAAALg0QiwAALCilExThxMZPRNL6pmJpJKlSkvXDzjs+si1u+WwNW71d2NvVKcyee0I+rSvL6obeiKKuJ0tPQ8AAAAAAMBaRYgFAAA6XrZc0XMTtTaBB+JpFapm2/bKVKp6IZ7Std3hhs+9daBLN/SE1UvlFQAAAAAAQMsRYgEAgI4UK5RqbQLHk3opkVErYitDampO1g/PTTQVYgWcjvqMLAAAAAAAALQW77oAAICOYFmWTmfzejpWC64Gs4WWrOuyGSqZteiqmQBLkp6dSCpVqijk4kclAAAAAACA5cI7MwAAYNlUTEtHkhk9PZ7UM+NJjRfLLVk36LQrXzFVsax6gDUfhgwdT2d1TRPVWAAAAAAAAGgPQiwAALCk8pWqXoin9cx4Us9NpJSrVBe9pl1Sr9etXKWqVLmidHlha24P+nRzf5du7I3IT5tAAAAAAACAZcW7MwAAoO0SxbKemay2OpTIqGLNvzrqQl67TRv9XhWqVZ3JFnQuX1zQOiGnQzf1R3VLf5c2+L2LPhcAAAAAAABagxALAAC0nGVZGsoV9cx4bb7V8XSuJet2uRzaGfKrZFo6kszqaCq7oHXshqFrukO6pb9Le7tCshtGS84HAAAAAACA1iHEAgAALWFall5OZSfnW6U0ssDKqAttCXh1RSSgqmXpYDytn8SSC15rs9+rWwa6tK8vqiDtAgEAAAAAADoa794AAIAFK1VNHUyk9XQsqWcnUkqXK4te0ybp8khAr+gKyWWz6bmJlB48MyZzgesFHHbt74/q5v4ubQn4Fn0+AAAAAAAALA1CLAAAMC/pckXPTlZbHYinVTIXGi+d57HbtDca0rXdIXW5nXoqltT9p0eUqVQXtJ5N0iu6Qrp5oEvXdIXksNkWfUYAAAAAAAAsLUIsAADQ0Gi+ONkmMKkjyaysFqwZdjl0bXdY13WHtdHv0ZOxpL59ZlSD2cKC11zv8+iW/i7t748q4nK24JQAAAAAAABYLoRYAABgFsuydCKT1zOxWnB1JrfwYGm69T63rusO69rusLYEvHohntb3h8f17ERKVWth0ZjPYde+3ohuHujWtoBXhmG05KwAAAAAAABYXoRYAABAklQxTR1OZPTMZKvAeKm86DUNSTtD/lpw1RPWgNc9bT9LXzoyqNQC5mgZkq6MBnVLf5eu7QnLRbtAAAAAAACAVYcQCwCANSxXqer5iZSeHk/qhYmU8tXFz7dy2gxdGQnqup6wrukKKXSRtn4Om6Gb+qP6tzNjTa/d73Xrlv4u3dQfVZfbteizAgAAAAAAoHMRYgEAsMZMFEu1+VaxlF5MZhbcxm+6gMOua7rDurY7pKuiQbnt9qauu6W/q2GI5bHb9KreiG7p79LOkJ92gQAAAAAAAGsEIRYAAKucZVk6kyvomVhST48ndTKTb8m6vR6XrusO67rusHaG/bJPhkvncgXFClld1RVquMYGv1fbgj6dSOdmPXZFJKCb+7v0yp5w06EYAAAAAAAAVg9CLAAAVqnhXEFPjMb1xGhcI4VSS9bcFvDq2p5acLXB56lXReUrVf1kLKEfjkzoaCqrqMupT924R7YmqqZu7u+qh1g9bpduHujSq/uj6vW4G1wJAAAAAACA1YwQCwCAVSReLOvHY7XgqhUVV3bD0BWRgK6dbBV44RyqiWJJXzsxrCdjCZXM820J46WyDsbT2ttENda+3ohOpHN6dX9Uu8OBpoIvAAAAAAAArH6EWAAArHC5SlVPxhJ6YjSuw4mMFjvhymu36RVdIV3XHdberpB8jou38nPbbfppLKGyOXvXH4xMNBVi+Z0OvXf35kWdGQAAAAAAAKsPIRYAACtQyTT1/ERKj4/G9dx4ShVrcdFV1OXUtd1hXdcT1uVhvxw2W1PX+R0OXd8d1hNjiVmPPR1LKluuyO/kxw0AAAAAAADMH+8qAQCwQpiWpRcTGT0+GteTsYTyVXNR6230e3Rtd1jXd4e1JeCtz7ear5v7u+YMsSqWpR+PJXTH+p5FnRMAAAAAAABrEyEWAAAdzLIsncrk9fhoXD8eSyhRKi94LUPSrrBf13WHdW13WH1e95zPGy+U9NhoXL0el/b1RRuuuycaVJfLqYkLzrY96FPYxY8aAAAAAAAAWBjeWQIAoAON5ot6fDSuJ0bjGs4XF7XWzpBP+/qielVPRCGXc87nlKqmnh5P6ocjEzoYT8uStDXgbSrEshmGXt3fpfsGRxR2OXRTX5du7u/SBr9nUecGAAAAAADA2kaIBQBAh0iVyvrxWEJPjMZ1LJ1b1FrrfW7t64tqX2/0ohVXlmXpRDqnH4xM6InR+Kz2hCczeQ1m89rk9zbc7zXrurUj5NPerpDsC2xLCAAAAAAAAExHiAUAwDLKV6p6ejypx0fjOhRPazFTrqIup27si2h/X1Sb/RefcZUolfXYSFw/HJnQUK5wyTV/eG5Cv7hjQ8O9uz0udXtcCzo3AAAAAAAAMBdCLAAAlljFNPVCPK3HR+N6djypkmkteC2fw65X9oS1vy+q3eGAbBcJriqmqWfGU/rhyIRemEg1HZY9PhrXW7etl8NGdRUAAAAAAACWFiEWAABLwLQsHU1l9fhoXD8dSyhbqS54LYdh6JrukPb3RfWKrpCcNttFnzuUK+i7wzE9PhJXZgF7psoVvRBP6dru8ILPCwAAAAAAACwEIRYAAG00mM3r8dG4fjwa13ixvOB1DEl7IkHt64vo+p6IfA77RZ9btSw9O57UI0MxHUxkFrznRp9HNw90aUfQt+A1AAAAAAAAgIUixAIAoMVihZKeGI3ridG4zjSYOdXItqBP+3ojurE3qojbecnnpkoVPXpuXI8MxzSxwMDM77BrX19UN/d3aWvg4nO1AAAAAAAAgHYjxAIAoAUy5Yp+MpbQE6NxHUllF7VWv8elfX1R7e+LasDnueRzLcvS8XRODw/F9JOxhCrW/OdrGZL2RoO6eaBL13SH5bpEe0IAAAAAAABgqRBiAQCwQMWqqWfGk3p8NK4D8ZSq88+P6kJOh27si2h/X5e2NVEBVaqa+vFYXA8PxXQyk1/QngNet27u79Kr+6OKul0LWgMAAAAAAABoF0IsAADmoWpZOhhP6/HRuJ6OJVU0zQWv5bHbdH1PWPv7unRFJCB7E637xvJFPTI8rkfPjStbqc57T6/dplf1RnXL5Kwr2gUCAAAAAACgUxFiAQDQgGVZOpbO6fHRuH4yllC6XFnwWnbD0NVdIe3ri+qarpBc9sat+8zJ4OyhoZien0hpIQVf24M+3bGuRzf0RuRuYk8AAAAAAABguRFiAQBwEUO5gh4fjeuJ0bjGCqUFr2NI2h0OaF9fVDf0hOV3NvfPb7ZS0Q/PTeiRoZhGFrC/wzB0Y19Ed67v1fagb97XAwAAAAAAAMuJEAsAgGnixZKeGEvoidG4Ti1w1tSUzX6v9vdF9areiLo9zc+cOp3J6+GhmB4fjau0gHaF3W6n7ljfo1sHuhVsMjADAAAAAAAAOg3vbAEA1rxspaInx5J6YjSuF5OZBbXrm9LrcWlfb1T7+qLa4Pc0fV3FNPVkLKlHhmI6ksouaO+rokHdub5HV3eFZGPWFQAAAAAAAFY4QiwAwJpUMk09N57SE6NxPTeRUsVaeHQVdNr1qt6o9vVGtTPkk7GAAOm/Hz6pZ8ZT877Oa7fp5oEu3bmuRwO+5kMzAAAAAAAAoNMRYgEA1gzTsnQ4kdETo3E9GUsoX51/q74pbptN1/WEtb8vqj2RoBy2xVU+vao3Oq8Qa6PfozvX9Wh/f1Qeu31RewMAAAAAAACdiBALALCqWZalk5m8nhiN68djcSVKlQWvZTekq6Ih7e+L6trukNwtDI9u6Anr/zgdSpUvfj67IV3fE9Gd63u0K+RfUMUXAAAAAAAAsFIQYgEAVqWRfFGPj8b1xGhc5/LFRa11Wciv/X1R3dAbUdDZnn86HTabblvXrftOj8x6LOJy6DXrenTbQLeibmdb9gcAAAAAAAA6DSEWAGDVSJTK+slYQk+MxnU8nVvUWht8Hu3vi+rGvoh6Pe55X1+1LD07ntT3hsf1nt2bFXE1Dp9uX9etb54e0VSTw10hv+7a0KPruiOLblcIAAAAAAAArDSEWACAFS1fqeqpWFJPjMV1MJ6WtYi1utxO7euNan9fVBv9ngW160uVKnr03Li+OxzTeLEsSfr+8Lh+dstAE/u7tL8vKqfNpjvX92hTwDvv/QEAAAAAAIDVghALALDiVExTz0+k9cRYXM+MJ1U2Fx5d+R123dAT0f6+qC4L+2VbxJypr54Y0gNnxlSxZp7ne8Pjumdzv+xNrP1rl29Z8P4AAAAAAADAakKIBQBYESzL0pFkVo+PxvXTWELZSnXBazlthq7tDmt/X1R7o0E5bLaWnNHvcMwKsCQpXirr6VhSN/RGWrIPAAAAAAAAsBYQYgEAOlq2UtGPRuJ6ZCimc/nigtcxJF0ZDWp/X1TXdYflddhbd8hJtw506V9ODc9ZGfbwUIwQCwAAAAAAAJgHQiwAQEc6mc7pkeGYnhiNq7SIdoHbgz7t74vqVb0RhV3OFp5wtoDToX29Uf1gZGLWYy8mMzqXL2rA627rGQAAAAAAAIDVghALANAxSqapn44l9PBQTMfTuQWvM+B1a39fVPv6oupfZGiUrVT02Ehctw10y2Vv3HbwzvU9M0Ish2Hoxt6I7lzfQ4AFAAAAAAAAzAMhFgBg2Y3mi/ru8Lh+cG5cmQXOuoq4HLqxN6r9fVFtCXhlGMaiznQ6k9fDQzE9PhpXyTTlsdt0y0B3w+u2Bn3aEfQpUSrr9nU9unWgWyEX/9wCAAAAAAAA88W7agCAZWFalp6bSOmRoZgOxNNaSMNAr92mV/ZEtL8vqssjAdkWGVxVTFNPxpJ6ZCimI6nsjMceGorp5v6upsKx/7Rnq8Iu56LPAwAAAAAAAKxlhFgAgCWVKpX16LkJfXc4pvFied7X2yRd0x3W/r6oru4OyWVr3OKvkXixpO8Nj+t758aVLFXmfM6pTF7H0jntDPkbrhd1uxZ9JgAAAAAAAGCtI8QCALSdZVl6OZXVw0Pj+mksoao1/7qriMuh2wa69Zp13S0JiSzL0kvJrB4eiumpWEJmE9c8PBRrKsQCAAAAAAAAsHiEWACAtslXqnp8NK5HhmM6ky0saI0rIgHdsa5H13aH5bAtvj1foVrVYyNxPTIU05nc/M7007GEfnH7eoVczkWfAwAAAAAAAMClEWIBAFrubDavR4bH9aORCRWqzdQ4zeS123Rzf5duX9+j9T5PS840nCvo4aGYfjQyofwCzhR2OfSagW7mXAEAAAAAAABLhBALANASFdPUU7GkHhmO6aVkdkFrbPZ7dcf6Hu3vi8htty/6TKZl6dnxlB4eGtPBRGZBa+wK+XXn+h5d3xOWowXztwAAAAAAAAA0hxALALAo44WSvnduXN8fHleqXJn39Q7D0A29Ed25vkc7gj4ZLah0SpUqevTcuL47HNN4sTzv6102m27qi+rO9T3aFPAu+jwAAAAAAAAA5o8QCwAwb6Zl6VAio0eGYnpmPClrAWv0uF26Y323bu7vVsjVmn+Ojqeyemgopp+MJVSx5n+qfq9bd67v0av7o/I7+CcSAAAAAAAAWE68QwcAaFq2XNEPRyb0yPC4RvLFeV9vSHpFV0h3rO/R3miwJfOlSlVTPx6L65GhmE5k8gs609VdId21vkd7WnQmAAAAAAAAAItHiAUAaOhEOqdHhmJ6Yiyusjn/Cqeg065bBrp1+0C3er3ulpxprFDUd4fG9f1z48pWqvO+PuCw69Z13bp9Xbd6Pa05EwAAAAAAAIDWIcQCAMypXuE0PK4T6dyC1tgZ8umOdT16ZW9ELptt0WcyLUsH42k9PBTTcxOpBbUx3Bbw6s71vXpVX2vOBAAAAAAAAKA9CLEAADOM5Iv67nBMPzg3saAKJ5fNppv6orp9fbe2BHwtOVPJNPXDcxN64OzYgtoYOgxDN/ZGdOf6Hm0P+VtyJgAAAAAAAADtRYgFAFDVsvTceEqPDMd0IJ5e0BrrvG7dsb5Hr+7vks9hb8m58pWqvjs8rgfOjipZqsz7+m63U7ev69GtA90KufgnDwAAAAAAAFhJeEcPANawZKms758b1/eGxzVRLM/7epuk63rCunN9jy4PB2QYRkvOlSlX9J2zY3poKLagarArI0Hdub5H13SHZGvRmQAAAAAAAAAsLUIsAFhjLMvSkVRWjwzF9GQsqao1/8lSEZdTr1nXrdsGuhV1O1t+xk8dOD7vOVxeu00393fpjvU9WufztPxMAAAAAAAAAJYWIRYArBH5SlWPjcb13aGYzuQKC1pjTySgO9b36JqusBy29lU43bW+R//rpdNNPXejz6M71/dof39UHntr2hgCAAAAAAAAWH6EWACwyg1m8/ruUEyPjcZVqJrzvt5rt+nmgS7dvq5H65eowunG3qi+cXJY4xdpcWiTdH1PRHet79GusL9lbQwBAAAAAAAAdA5CLABYhSqmqSdjST0yFNORVHZBa2wJeHXHuh7t64vIvcQVTg6boX+3qV9ffvnMjPtdNkO3revWGzb0qdvjWtIzAQAAAAAAAFhahFgAsIqMF0r63vC4vn9uXKlyZd7XOwxDN/ZGdMf6Hm0P+lpa4WRZlg4mMtoe9MnnaByK3dLfpXtPnVOqXJHXbtNd63v12g29Crn4pwsAAAAAAABYC3gnEABWONOydDCe1iPDMT07npK1gDV6PS7dvq5Htwx0Kehs7T8NpmXpmfGk7j89ohOZvN66bZ3u3tTf8DqX3aa3bBlQtlLVHet7mgq+AAAAAAAAAKwehFgAsEJlyhX9YGRC3x2KabRQmvf1hqRXdIV05/oeXRUNytbiuVIV09KPx+L65uCIhnLF+v0PnBnTa9f3ymW3NVzj9vU9LT0TAAAAAAAAgJWDEAsAVpjj6ZweGYrpx2Nxlc35110FnQ7dNtCl29Z1q9fjbsMJax48O6r/e2J41v2pckWPjozrrvW9bdsbAAAAAAAAwMpHiAUAK0CxaurHY3E9MhTTyUx+QWtcFvLrjvU9emVPWE5b4yqoxbp1oFv3nhpR0TRnPfbtwVG9ZqBHDltrq78AAAAAAAAArB6EWADQwc7lCvru8Lh+MDKhXKU67+vdNpv290d1x7oebQ5423DCiws4HXrNum49cHZs1mPjxbKeGI3r5oGuJT0TAAAAAAAAgJWDEAsAOkzVsvTseFKPDMV0MJFZ0BrrfR7dsa5bN/V3yeewt/iEzXvDxl49NBRT1ZrZ9vDqrpA2+j3LdCoAAAAAAAAAKwEhFgB0iESxrO+fG9f3hscVL5Xnfb3dkK7vieiOdT3aHfbLMNrTqu9cvqhcpartQV/D50bdLt3c36XvnxuXIenG3oju3tSvTUtcFQYAAAAAAABg5SHEAoBlZFmWXkpm9chwTE/FEqpaja+5UNTl1GvWdeu2gW5F3M7WH3LSqUxO3xwc1U/HEtoc8Ooj1+5qKij7d5v6ZMnS3Zv61e91t+18AAAAAAAAAFYXQiwAWAa5SlWPjUzokeFxDeUKC1rjykhQd6zv1jXdYdnbVHUlSUeTGd03OKrnJ1L1+05l8joQT2tvV6jh9f1et969a3PbzgcAAAAAAABgdSLEAoAlFC+W9M3BUf3g3ISKpjnv630Ou27p79Lt67o14GvfTCnLsnQgntb9gyN6KZmd8zn3D440FWIBAAAAAAAAwEIQYgHAEogXS7p/cFTfHx5XxZp/z8AtAa/uXN+jG3ujctttbThhjWlZeiqW1P2DIzqVyV/yuS8lszqazOiycKBt5wEAAAAAAACwdhFiAUAbLSa8chiGbuyL6M51PdoW9DU1f2qhKqapx0fj+ubgqM7li01fd//gqP4zIRYAAAAAAACANiDEAoA2mGob+L0FhFd9HpduX9+jW/q7FHC296/pYtXUo+fG9e0zo5oolud17XqfW6/qjciyrLYGbAAAAAAAAADWJkIsAGihhYZXhqRrukO6Y12ProwGZWtzKJSrVPXIUEwPnB1TulyZ17XbAl7ds7lf13aH235OAAAAAAAAAGsXIRYAtMBCw6uQ06FbB7r1mnXd6vG42njCmlSprAfPjunhoZjyVXNe114RDuiezf3aEwlQeQUAAAAAAACg7QixAGAR4sWyvjk4Mu/wKupy6u7Nfbp1oFsum62NJ6wZL5T07TOj+v65cZXN+bU3vLY7pLs39WtnyN+m0wEAAAAAAADAbIRYALAA8WJZ3xoc0Xc7PLwayhX0rcFRPT46oeo8sitD0o29Ud29uU+b/N62nQ8AAAAAAAAALoYQCwDmYaWEVyfTOd0/OKKnYknNp+7KYRi6eaBL/25jn/q87radDwAAAAAAAAAaIcQCgCashPDKsiwdSWZ13+CIDsTT87rWbbPp9vXdev2GPkXdzjadEAAAAAAAAACaR4gFAJew0PAq4nLqniUMr56Pp3X/6REdTWXnda3fYddd63v02g29Cjj5JwEAAAAAAABA5+AdSwCYQ6JY1jfPjOh7w+Mqm/MMrzb16dZ17Q+vTMvST8cSun9wRIPZwryujbgcev3GPr1moFteh71NJwQAAAAAAACAhSPEAoBpVkJ4VTFN/Wgkrm+dGdVIvjiva3s9Lv27jX169UDXkszmAgAAAAAAAICFIsQCAK2M8KpYrer75yb0b4OjmiiV53XtRp9Hd2/u16t6I7IbRptOCAAAAAAAAACtQ4gFYE1bCeGVJH13KKavnxxWplKd13Xbgz69aXO/ru4KyUZ4BQAAAAAAAGAFIcQCsCYlimV968yovjsc6+jwaoolzSvAujIS0D2b+3V5OCCD8AoAAAAAAADACkSIBWBNWXh45dDdm/p12xKHV1NuHujSv546p1S5csnnXdcd1j2b+rQ95F+ikwEAAAAAAABAexBiAVgTVmp4NcVls+kNG/v0f08MzXrMJmlfX1R3b+rTBr936Q8HAAAAAAAAAG1AiAVgVUuUyvr24Kge6eDwyrKsplr+3b6uW/cPjig32VbQYRi6daBLb9zYp16vu61nBAAAAAAAAIClRogFYFXq9PDKsiy9lMzq/sERXdMV0l0behte43XY9dr1PXrg7JhuX9ej12/oVcTtbNsZAQAAAAAAAGA5EWIBWFUWHV4NdMtlb2949UI8rf/v9IheTmUlSUO5gl6zrluOJkKz12/s0+s29Mrv5K9vAAAAAAAAAKsb74ICWBU6PbySpLPZvL5y7KwOJTIz7p8olvX4aFy3DHQ3XMPnsLfreAAAAAAAAADQUQixAKxoU+HVd4djKnVoeDUlU67OCrCmfHNwVK/u75KtidlYAAAAAAAAALAWEGIBWJFWUng1ZXckoOu6w3p6PDnrsXP5op6KJXVDb2RJzwQAAAAAAAAAnYoQC8CKstDwKuxy6J5lCq+m+/lt6/TcRFLVOY5+IJ4mxAIAAAAAAACASYRYAFaEZKmsby0wvLp7U79es8zh1ZQBn0d3rOvRd4Zi9fuuigZ1z6Z+7Q77l/FkAAAAAAAAANBZCLEAdLRkqaxvnxnVI0OdHV6lyxUFnc39lfozWwb0w5EJbQ549Qvb1mt7iPAKAAAAAAAAAC5EiAWgI62U8CpRKutfTp7T46MT+tj1l6vX6254TdDp0J9dt1s9HpcMw2j7GQEAAAAAAABgJSLEAtBRVkp4VayaeuDMqL51ZlSFqilJ+urJYf3mFVubur6ZsAsAAAAAAAAA1jJCLAAdYTHh1b/b2Kfb1/UsSXhlWpYeG4nr6yeHFS+VZzz2k7GEXrchq520BwQAAAAAAACARSPEArCsUqWyvrUCwitJOpxI65+OD+lUJn/R5/zT8bP6w6svo00gAAAAAAAAACwSIRaAZbHQ8CrkdOjuTUsbXg3lCvrn40N6biLV8Lkvp3L6aSypV/VG2n8wAAAAAAAAAFjFCLEALKnz4dW4SqbZ9HVT4dVr1vXIvUThVapU0b+eOqfvDcfU7El7PS55luh8AAAAAAAAALCaEWIBWBIrKbwqmaYePDOm+wdHVKg2d1a/w66f2dyvO9b3yGkjxAIAAAAAAACAxSLEAtBWqVJZ3z4zpoeHYh0fXpmWpR+PJfS1E0MaL5abusZuGLpzfc//v737jo+qTPs/fp1pySSTkJCEEFIglFAloDyCWBBDE7GuCCjdtrZdy6I/LCgIqz6sz6rguiuKICCKoqAuAoIiglKUDkICqSQhJCQhbTL1/P5wmc2kzQRIMiSf9+vlH+fkPmeuzAzHmfPNdd9yS1ykmPRcUgEAAAAAAADgYuGOK4BGcSmFVyIix86WycepOZJWWuH1MQPC28jY+A4SafRrxMoAAAAAAAAAoHUixAJwUV1q4dUps0U+Tc2RX8+c9fqYzkEBMqFzB+nWxtSIlQEAAAAAAABA60aIBeCiuNTCqzKbXdZmnpLvcgrEoXp3TJifXsbGd5CBESGiKErjFggAAAAAAAAArRwhFoALUmK1y/qTp2XTJRJe2ZxO2ZRTIF9l5kmF3eHVMUatRm6Oi5Rh0RFi0DRdrQAAAAAAAADQmhFiATgvZrtDvsrKk03ZDQ+vRse2k6FNHF6pqiq7C4rl07Rcya+0enWMRkSGdgiX2zq2lyA9l0sAAAAAAAAAaErclQXQYHvPnJUPU05KkdXm9THNFV6JiBwvKZePU7PleEmF18f0DwuWu+I7SFSAfyNWBgAAAAAAAACoCyEWAK+VWG2y/ES27Mov9vqY5gyvTpst8ll6boPq7WgyyvjOHaRnSFDjFQYAAAAAAAAA8IgQC4BHqqrK9rwiWZmaLeVeriPVnOFVuc3umurQrqpeHdPWoJc/xEfJVe1CRaMojVwhAAAAAAAAAMATQiwA9co3W2Tp8ZNyqKjUq/HBep3cGNtObogKEz+ttpGrc2d3OuX73DOyJuOU12Gbv1Yjo2Pbycjodk0etgEAAAAAAAAA6kaIBaBWTlWVb7PzZXX6KbE6nR7HN2d4paqq7DlzVlal5Uqe2eLVMYqIDIkKk9s7tpc2Bn3jFggAAAAAAAAAaDBCLAA1ZJWb5YPkLEktrfA4VhGREdERcnun9uLfxOGViEhaaYV8nJotx86We31M39AgGde5g0QHGhuxMgAAAAAAAADAhSDEAuBiczrly8w8WZeVJw4vlpKKCfCX6Qmx0jk4sPGLq0WpzS7z9qV4ve5VbKC/jOscLX1Cgxq5MgAAAAAAAADAhSLEAiAiIilny2RxcpbkejEdn05R5Ja4SBkd2050muZbRypIr5OkDuGyITu/3nEhBp3c0SlKrolsKxpFaaLqAAAAAAAAAAAXghALaOXMdod8lp4r3+UUiDf9TN2CA2VaQqx0CPBv9Nq8cUtcpGzLK5Ryu6PGzwwajYyObSejYiKaZapDAAAAAAAAAMD5I8QCWrF9Z87KhyknpdBq8zjWX6uRO+Oj5IaocJ/qZgrU6+TWju3loxPZrn2KiFwT2Vbu6BQloX765isOAAAAAAAAAHDeCLGAVqjEapePTpyUHfnFXo1PbBssk7vGSJi/oXELO083RIXJ5ux8yau0Su+QIBnfuYPEmozNXRYAAAAAAAAA4AIQYgGtiKqq8tPpIll5IlvKapl+r7ogvVbu6RIjAyNCRGnC7qsii1U+S8+V6yLDpHuIyeN4nUYjk7vFikNV5bLQoCatFQAAAAAAAADQOAixgFaioNIqS1Ky5FBRqVfjB7cLlQldoiVI33SXiUqHQ9ZlnZb1J0+L1alKToVFXujXzavpC3uHBjVBhQAAAAAAAACApkKIBbRwTlWVTTkFsjotVyxOp8fxYX56mdItVvq2DW6C6n7nVFXZeqpQPk/PlRKb3bU/rbRCduYXy1XtQpusFgAAAAAAAACAbyDEAlqw7HKzLE7OkhOlFR7HKiIyrEO4/CE+Svy12sYvrooTJeWyJCWr1p99lpYjV4S1EYNW06Q1AQAAAAAAAACaFyEW0ALZnE75OjNPvs46LQ5V9Tg+OsBfpiXEStfgwCaorqZubUzSr22w7CssqfGzMxabfJuTLzfFRjZDZQAAAAAAAACA5kKIBbQwx0vKZXFyluRUVHocq1UUuTkuUsbEthOdpnk7ne7q3EEOFJZIbRMe/lJwVkbHtBPFi7WxAAAAAAAAAAAtAyEW0EKY7Q5ZnZ4rm3MKxHPvlUjX4ACZ1i1OogP9G702b3QI8JehHcJlc06Ba1+QXiu3dmwv17cPJ8ACAAAAAAAAgFaGEAtoAQ4UlsjSlCw5Y7F5HOun0cid8VGS1CFcND4WDN0a115+yisUm1OVEdERMiYuUgJ0Tbs+FwAAAAAAAADANxBiAZewEqtdVqZmy8+ni7waf1lokEzpFivh/oZGrux3R4pKZXV6rvyxZ0eJ8PfzOD7YoJMHe3SU6EB/r8YDAAAAAAAAAFouQizgEqSqqvx8ukhWpmZLqc3hcbxJp5W7u0TLVe1Cm2RavuzySlmVliP7C0tERGR1Wq78sWcnr47tF9amESsDAAAAAAAAAFwqCLGAS8yZSqssPX5SDvwnIPLkqnahMqFztAQbGv+fe4nVJl9knJIfcs+Is8r+HfnFMiK6XDoHBzZ6DQAAAAAAAACAloEQC7hEOFVVvsspkM/Sc6XS4fQ4vq2fXqZ0i5XEtsGNXpvV4ZSN2fnydVZenbV9nJojMxO7NkknGAAAAAAAAADg0keIBVwCsssr5YOUTDleUuFxrCIiSR3C5Q+dosSo0zZqXU5VlR2ni2R1eq6csdjqHZtcUi6/njkrA8JDGrUmAAAAAAAAAEDLQIgF+DC70yn/zjotX2XmiV1VPY7vEOAn07rFSbc2jT9tX0ZZhSxJzpK0MrPXxxwvKSfEAgAAAAAAAAB4hRAL8FHHS8rlg+Qsya6o9DhWqygyJradjImLFL1G06h1OVRV/p2VJ2szTonDc64mIiKdgwJkQucO0q2NqVFrAwAAAAAAAAC0HIRYgI+pdDhkdXqubMouEG8yos5BATI9IVZiAo2NXlue2SLvHs2QE6WepzUUEQn3M8jY+Ci5MiKEtbAAAAAAAAAAAA1CiAX4kIOFJbIkJcvj+lIiIgaNRu6Mj5JhHcJF08gBkaqq8n3uGfk4NUesTqfH8UatRm6Jay9J0eFiaOTOMAAAAAAAAABAy0SIBfiAMptdPjqRLT+dLvJqfJ/QIJnSLUYi/P0auTKRYotNFidnyoGiUo9jtYrI0KhwubVjewnSc3kBAAAAAAAAAJw/7jIDzUhVVdmZXywrTmRLqc3ucXygTit3d4mWwe1Cm2R6vl35xbI0JUvK7Q6PY/u1DZbxnTtI+wD/Rq8LAAAAAAAAANDyEWIBzeRMpVU+PH5S9heWeDV+YESI3NMlWoIN+kauTKTcbpflx7PlZy86w4xajUzqGiNXNVGwBgAAAAAAAABoHQixgCbm/M/6Up+m5Uilw/P6Um0NepncLUb6hbVpgupEjhSVynvHMqXQ6nldrl4hJrk3IU7C/A1NUBkAAAAAAAAAoDUhxAKaUE5FpXyQnCUpJeVejb8hKlzGxkeJUadt5MpErA6nfJqWI9/mFHgcq9cocld8B0nqEC4auq8AAAAAAAAAAI2AEAtoAnanU9ZlnZYvM/PErqoex7c3+sn0hFhJaGNqgupE0kor5N2jGZJrtngc28lklAd6dJQOrH0FAAAAAAAAAGhEhFhAI0strZDFyZlysrzS41itIjI6NlJujosUg0bT6LU5VFW+zsyTLzNPicNDtqYRkZvjIuXmuPai09B9BQAAAAAAAABoXIRYQCOxOBzyefop2ZidL557r0TigwJkerdYiTUZG702EZHcikpZdCxTUksrPI5tb/STB7rHSefgwCaoDAAAAAAAAAAAQiygURwqKpWlKVmSX2n1ONagUeQPnaJkeHREk6wvpaqqbM4tkFWpOWJ1eo7XkjqEy13xHcRP2/idYQAAAAAAAAAAnEOIBVxEZTa7rEzNlu15RV6N7x1ikindYqWd0a+RK/tdkcUq7ydnyaGiUo9jQwx6uS8hVvq0DW6CygAAAAAAAAAAcEeIBVwEqqrK7oJiWX48W0psdo/jA3VaGd+5g1wT2VaUJui+EhHZcbpIlh0/KeV2h8exgyJCZFLXGAnUc4kAAAAAAAAAADQP7lADF6jQYpUPU07KvsISr8ZfGREi93SJljYGfSNX9rsym10+PH5SduUXexwbqNPK5K4xMrBdaOMXBgAAAAAAAABAPQixgPPkVFXZkntGPk3LEbPD6XF8iEEvU7rFSP+wNk1Q3e8OFpbI+8lZUmy1eRzbJzRI7k2IlVA/QxNUBgAAAAAAAABA/QixgPOQW1EpS1Ky5NjZcq/GD40Kk7HxHSRAp23kytwdKCzxGGAZNIqM6xwtN0SFNdnUhgAAAAAAAAAAeEKIBTSA3anKNydPy9qMU2JXVY/j2xv9ZFq3WOkeYmqC6mq6M76DHCwqlVNmS60/7xwUIA90j5P2Af5NXBkAAAAAAAAAAPUjxAK8lFZaIYuTMyWrvNLjWI2IjI5tJ7d0bC8Gjabxi6uDn1YjD/ToKHP3JkvVCQ+1isgtce1lTFykaOm+AgAAAAAAAAD4IEIswAOLwylfZOTKhpP54rn3SqSTySjTE+IkzmRs9Nq80TkoQG7p2F7WZJwSEZEoo5880KOjxAcFNHNlAAAAAAAAAADUjRALqMeRolL5ICVL8iutHscaNIrc3jFKRsRE+Fx305jYSDlQWCJdggNkbKcOYtA2X3cYAAAAAAAAAADeIMQCalFus8vHqTnyY16hV+N7hphkWrdYaWf0a+TK/qvYYpNgg040XgRmOo0iMxO7ir4ZpzYEAAAAAAAAAKAhCLGAatJLK2TmL0elxGb3ODZAp5XxnTvItZFtRWmi7itVVeWn00Wy/PhJuaNTlAyPjvDqOAIsAAAAAAAAAMClhBALqObHvELp5UWANSC8jUzsEiMhfvomqOp3pTa7LE3Jkl8KzoqIyKq0HOkdGiQdAvybrAYAAAAAAAAAAJoCIRbQQCEGnUzqGiNXhIc06ePuLyyRxcmZctb634DN5lRl0dEMea5fgug0vrUOFwAAAAAAAAAAF4IQC2iAIe3D5K7OURKoa9p/OqU2u/zjSLpYnM4aP0srM8tXmafk9k5RTVoTAAAAAAAAAACNiUVyAC9E+hvkmb5dZFpCbJMHWCIiQXqdjOvcoc6ff5WZJ5ll5iasCAAAAAAAAACAxkUnFlAPjYiMim0nt8W1F4O2eTPfoVFhsvfMWTlYVOq2X6socnvH9hIdyLpYAAAAAAAAAICWgxALqENHk1GmJ8RKR1NAc5ciIiKKosj0hDh5/tejUm53iIhIdIC/PNAjzmdqBAAAAAAAAADgYiHEAqrRKSJ3xUfJyJh2olWU5i7HTaifXqZ0i5F3fsuQkTERckenKDFomBUUAAAAAAAAANDyEGIB1dwU215Gx0Y26WM6VVU0XgZmV0aESnSAkekDAQAAAAAAAAAtGi0cQDXBhqbLdlVVlR9PnZE5e5PF4nB4fRwBFgAAAAAAAACgpSPEAppJidUuC4+ky/vJWZJeZpZPUnObuyQAAAAAAAAAAHwG0wkCzWDvmbPyQXKWlNjsrn3f5RZI/7BguaxtcDNWBgAAAAAAAACAb6ATC2hCZrtDFidnypuH09wCrHPeT86Uslr2AwAAAAAAAADQ2hBiAU3k2NkymbXnmGw9VVjnmGKrXT48frIJqwIAAAAAAAAAwDcxnSAaTUpKirJz505tVlaWxmq1SmhoqNqzZ0/nNddc4zAajc1dXpOxOZ3yRfop+ebkaVE9jNUpinQyGUVVVVEUpUnqAwAAAAAAAADAFxFiNbOsrCxl586d2h07dmh/+eUX7Z49e7SlpaWun8fFxakZGRll53NuRVGCLqS2EydOlHXu3NlT7lLD6tWrdXPnzvXbt29frZ1+JpNJJk2aZJs9e7YlIiKiwee/lGSVmeXdYxmSVV7pcWxMoL882L2jxJpaT8AHAAAAAAAAAEBdCLGawdatW7Wvv/66Yffu3drc3NwW025TWVkp06ZN8//444/19Y0rKyuTd955R//pp5/qVq1aZR46dKijqWpsKk5VlfUnT8vn6afErtaf0ykicmNsO7m9Y3vRa5jhEwAAAAAAAAAAEUKsZrFr1y7tl19+2aKee4fDIWPHjjV+/fXXbr+XVquV2NhYNTg4WM3IyNCcPXvW9bOCggJlzJgxARs2bKi45pprWkyQlW+2yKJjmZJcUu5xbIS/Qe7vHicJbUxNUBkAAAAAAAAAAJeOFhWktAQmk0nKys5r9sB69enTx/m3v/3N85x2VURFRXk91d+rr75qqB5g3X///bZZs2ZZYmJiVJHfg64vvvhC9+STT/pnZWUpIiIVFRUyfvx446FDh8pCQkIaUp7PUVVVtp4qlJWp2VLpcHocf137tjKhc7QYddomqA4AAAAAAAAAgEsLIVYzCgoKkv79+zuuuOIKx8CBAx1XXnmlIzU1VTNs2LCAi/1YoaGh6siRIxul26mgoEB57bXX/Krue/nlly3PP/+8teo+rVYrd955p33gwIHl1157bWBGRoYiIpKdna3Mnz/fb968eZbGqK8pnLXa5IPkLNlXWOJxbLBeJ9MSYqV/WJsmqAwAAAAAAAAAgEsTIVYzuPXWW22jRo2y9+zZ06nVunfhpKamNlNV5++VV14xlJaWuravueYax7PPPmuta3xsbKz67rvvmkeOHOkK6xYsWGB44oknrOHh4V53f/mKXwuKZUlKlpTaPGeEV4S1kSndYiXYwD89AAAAAAAAAADqo2nuAlqjbt26qX369KkRYF2KHA6HfPjhh/qq+1588UWLRlP/W2vEiBGOq6++2pX6lJaWysqVKy+pZKfC7pBFxzJkwZF0jwGWv1Yj9yXEyaO9OhFgAQAAAAAAAADgBe6m44Js27ZNW1BQoJzbjo+PV2+44Qavpi2cPn26bfv27a4kb+3atfrHHnvM1hh11qekxH0KwKpdZXX5rbhU3juWKWcsnsvt0cYk93WPk3B/w3nXCADN7fTp0/KPf/zDtf3www9Lu3btmrEiAPA9XCsBoH5cJwHAM66VgDtCLFyQr7/+2u09lJSUZPfUhXXOiBEj7FW3f/zxR21ZWZmYTKaLWKFn5eXlStXtsrKyOsdanU5ZnZYrG7PzxdO8hzpFkTvjo2REdIRoFMXDaADwbfn5+TJ79mzX9tixY/kQDQDVcK0EgPpxnQQAz7hWAu6YThAXZP/+/W5zIg4ePNirLiwRkZiYGLVjx46uLMhqtcqhQ4d89j2ZUVYhs/ckywYvAqy4QKO8dHmCjIppR4AFAAAAAAAAAMB5oBOrlcnOzlays7OV8vJypW3btmp4eLgaHR3tKZOp07Fjx9xCp169enkdYomI9OjRw5GRkeF6H/7222/aQYMGOc+3nsbgUFVZl3Va1mScEoda/1OliMhNsZFyW8dI0XnZkQYAAAAAAAAAAGoixGolDh06pImPjzelp6fXaAuKjIxUr732WsfUqVOtN910k9chVEVFhWRlZbmdLy4urkGBWGxsrNv4o0eP+lTyk2e2yKJjGXK8pMLj2Hb+Brm/e0fp1iawCSoDAAAAAAAAAKBl86nAAI2nqKhIqS3AEhHJy8tTPvvsM92YMWMC+vXrF7h//36v3hf5+fmKWqUzSa/XS2RkZINCrA4dOrh1XeXn5/vE3Huqqsr3OQXywq/HvAqwro8KkzlXdCfAAgAAAAAAAADgIqETC27279+vueqqqwIXL15sHj9+vL2+sWVlZW6BU0BAgGgaOIVeYKB76FP9nBfi1KlTijehWPUxOQVnZM6OA5Jm85zHBWk1cl/PTpLYNvgCKgUAAAAAAAAA4PycPn1a8vPzG+Xcubm5jXJebxFitXBhYWHq6NGj7cOGDbMnJiY6Y2NjnUFBQVJWViYZGRmaH374Qfv+++8bDh486EqfzGazTJkyxRgZGVkxdOjQOqcXLC0tddv28/Nr8NpaRqPR7ZiysrKGnqJOCxcuNMybN8/Q0OMOKAYRLwKs9C3fyrVamyRe/ex51QcAAAAAAAAAwIX6xz/+IbNnz27uMhoFIVYLtnTpUvO4cePsfn5+NX4WGhoqoaGhzn79+jn//Oc/295++239U0895W+xWERExGq1ysSJE43Hjx8vMxqNtZ6/srLSrYPJYGhwXiTVazObzc0+naDOP6Den1tLS2Xnm69K6rfr5PoXX2yiqgAAAAAAAAAAaF1YE6sFmzx5cq0BVm0eeeQR27Jly8xVpwPMyclR3nrrrTqTKX9/f7d2JavV2uAaz4VmdZ3T1+T+ulPWThsrqd+ua+5SAAAAAAAAAABo0ejEgsvYsWPtX375pW358uX6c/tWrFihf+aZZ2pNp4KCgty2LRZLg7uoqndemUymhp6iTo8++qh13LhxNk/j5s2bp//kk09cYd2pfb/WGKMVkS56kcv1Grnivumu/QaDQRYsWHCRKgYA31V9/uMVK1ZIVFRUM1UDAL6JayUA1I/rJAB4xrUS58NgMMjMmTMb5dy//PKLfPvtt67tkpKSRnmcuhBiwc1f/vIXa9UQ69ChQ5rc3FwlKiqqRoeUyWRy21dRUSFOp1OqdnN5Ul5eXu85L0T79u3V9u3bezzf6dOn3QrO2rpZsrZurjFux8UqDABagFdeeaW5SwAAn8e1EgDqx3USADzjWglfs3fvXq2IeGweuViYThBuEhMTnREREa7gR1VVOXbsWK3vk4iICFVR/ttIZbPZJC8vr0HdWDk5OW7nrvrYAAAAAAAAAACg9SLEQg3R0dFuQVJ+fn6twVRAQIDExsa6jc3IyGhQiJWZmek2vmfPns6GHA8AAAAAAAAAAFomphNEDXq93i2Ystnq7gxMSEhwZmZmas9tHzlyRDto0CCvg6hjx45pq2736NHD0YBSL4qHHnrI8v333+uqbnfr1o2OMACoIjc3V5k/f77fue0ZM2ZYaptqFgBaM66VAFA/rpMA4BnXSvias2fPyr59+1z38WfNmlXZlI9PiIUa8vLyvJ7iLzEx0bFp0ybXG/inn37STp8+3av5MLOzs5WqnVt6vV769OnT5J1YPXr0cNt+6KGH7JdddhkdYQBQxcGDBzVVP0RPmjSJayUAVMO1EgDqx3USADzjWgkf1WRrYFXHdIJwk5mZqVSf4i8uLq7OEOvmm2+2V93+7rvvdE6nd9fUDRs2uIWo1113nSMoKKgB1QIAAAAAAAAAgJaKEAtuFi1apK+6HRMTo3bv3r3OVOqaa65xhIWFuUKutLQ05bvvvtPWNb6qxYsXuz3WLbfc0mxpLgAAAAAAAAAA8C2EWHA5fPiw5s033/Srus9TsKTVamXSpEluY+bMmePnqRtr48aN2u3bt7vCrqCgIJkwYYK9vmMAAAAAAAAAAEDrQYjVAv3666+a+fPnG8rLyxt0zI033hhQWlrq2mc0GmXmzJlWT8c+++yzVpPJ5Nr+8ccftX/9618NdY3PyspSHnjgAWPVfY888oi1vrW3AAAAAAAAAABA66LzPASNYevWrVqz2Vxj/759+9ym4qusrJQNGzbUOj1fdHS02qdPnxotT8XFxcrTTz/t9+qrrxpuu+02++23324bOHCgs3pI5HQ65eDBg5p3331X//777xssFovbeV5++WVLTEyMx2ApIiJCffrppy2zZs1ydXG98MILfllZWZoXXnjBdQ6HwyFr1qzRPfHEE/5ZWVmudbeioqLUp59+2lLbuQEAAAAAAAAAQOtEiNVMJk2aZMzMzFQ8jTt9+rQyatSogNp+NnHiRNuyZcsq6zq2sLBQWbx4sf7c2lPt2rVTw8LC1KCgILWsrEzJzc3VFBUV1Xrs448/bn3qqac8dmGd8+yzz1p//vln7TfffON6T/0nHNPHxcWpwcHBakZGhqa4uNjtOKPRKB9//LE5NDTU24cCAAAAAAAAAACtACFWK3L69Gnl9OnT9QZnwcHBsmDBAvPkyZMbtD6VVquV1atXm6dMmWL89NNPXe8rh8MhaWlpiojUeNy2bduqq1atMl933XWOhjwWAAAAAAAAAABo+VgTqwVKTEx0zps3zzJ8+HBHaGioV+tMJSQkOP/6179a0tLSShsaYJ1jNBpl1apV5k8++cTct2/fGtMcnhMYGCgPPvig7fDhw+VJSUkEWAAAAAAAAAAAoAY6sZpJRkZGWWOdOzw8XH322Wetzz77rFVEJC0tTUlOTtZkZGRoioqKFLPZLP7+/hIaGqp26NBBveqqqxzh4eFehV3euOuuu+x33XWXPTk5WdmxY4f25MmTGqvVKiEhIWqvXr2c1157rcNoNF6shwMAAAAAAAAAAC0QIVYrEB8fr8bHxztEpEm7nhISEtSEhITz6upqShEREepzzz1nrbrdnPUAgC/iWgkAnnGtBID6cZ0EAM+4VgLuFFVVS5q7CAAAAAAAAAAAAKAq1sQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAzyHEAgAAAAAAAAAAgM8hxAIAAAAAAAAAAIDPIcQCAAAAAAAAAACAz9E1dwEAAMD3WCwW+e233zRpaWmakydPKqWlpYrNZpPg4GA1PDxcTUxMdPbq1cup0/FRAgAAAACAC1VSUiJbt27VZmVlaQoKChSdTiexsbHO//mf/3F2797d2dz1Ac2FO09olbKyspSdO3dqd+zYof3ll1+0e/bs0ZaWlrp+HhcXp2ZkZJQ1Y4kA0OQ++eQT3aZNm3Q//fSTNjk5WWO32+sd36ZNG7nrrrtsjz/+uLVXr158oAYAAIBMmjTJf/ny5fqLcS6+mwNoDbZt26adPXu235YtW7R1fQ/v1auX8y9/+Yt1ypQpNo2GydXQuiiqqpY0dxFAU9i6dav29ddfN+zevVubm5ur1DeWD8oAWqPo6GhTTk5OvdfH2uj1enn66aetc+bMsfBhGkBL9/zzz/vNmzfPcL7HT5w40bZs2bLKi1kTAPiSixlide3a1ZmSklJ+Mc4FAL7GZrPJo48+6v/uu+96fc1MSkpyrFq1qqJt27aNWRrgU+jEQquxa9cu7Zdffsl7HgAawN/fX2JjY53BwcHidDrlzJkzSlZWlqKqqmuMzWaTefPmGU6ePKksWbKEG7MAAAC4KEaPHl3/1AAAcImy2+1y8803Gzds2FDjXmVUVJQaFRWllpWVSVpamsZms7l+tnnzZu2wYcMCt27dWm4ymZq0ZqC5cEMfEBGTySRlZTReAUBUVJR644032q+77jrH4MGD7Z07d1a1Wq3bmMLCQvnkk0/08+bN88vOznZ1bi1dulR/9dVXO+6//35bjRMDAACgVXjmmWesEydObPDnweTkZM2f/vQn/6r7pk2bxudKAC3SzJkz/aoHWKNHj7b/9a9/tSQmJrqm6y8uLpb33nvPMGfOHL9zS6Hs3btX88c//tF/+fLl/BEpWgWmE0Sr8be//c0wY8YMv6CgIOnfv7/jiiuucAwcONBx5ZVXOlJTUzXDhg0LODeW6QQBtEb79u3T9O3b1+ntlICFhYWSlJQUuG/fPtcB7du3V0+ePFlWPfgCgJai+nSCr776qqVfv34Ob4+Pjo5W+/TpwzqCAFDN008/7Td//nzX9TUxMdG5b98+phIE0OIkJycrvXr1Mjkc//0I+cgjj1gXLlxoqeuY3bt3a4YPHx549uxZ174dO3aUDxw4kM+VaPHoxEKrceutt9pGjRpl79mzp7P6zdXU1NRmqgoAfEe/fv0a9OG3bdu2snz5cvNll10WeG56wVOnTik//vij9vrrr/f6hi4AXMoGDBjgSEpK4poHABfA4XDIRx995LYmzOTJk+nCAtAi/e///q9f1QCrf//+zjfeeKPOAEtE5H/+53+c8+fPr3zggQdcHaszZ870/+677yoasVTAJ7D6OlqNbt26qX369KkRYAEAzl/v3r2d/fv3dwu/jhw5wucLAAAAeG3jxo3aqtNU6/V6mTRpEiEWgBbp66+/dmssefrppy06nedek2nTptliYmJcC1R///332hMnTij1HQO0BNxkAgAAF6Rz585uIVZBQQEfogEAAOC1pUuXGqpu33jjjfaIiAi1rvEAcKn67bffNHl5ea7vzFqtVm6++Wa7N8fqdDoZNWqU29jPPvtMX9d4oKUgxAIAABekstJ9LdmQkBBuOAAAAMArZ8+elS+//NKtBWHq1Kl0YQFokTIyMtz+6LNz587OwMBAr4/v27ev2zTW1bu6gJaIEAsAAJw3p9Mpv/76q9s8rQMGDGBhWQAAAHhl5cqVerPZ7NqOiIhQx4wZ41VXAgBcas6cOeMWYrVt27ZBfwQaHh7uNv7AgQOsm4IWjxALAACct0WLFulzc3NdH8ITEhKcgwYNctR3DAAAAHDOhx9+6DYV1oQJE2x6PbNjAWiZNBr32/EOR8O+Ptts7o2qJSUlkpWVxZT+aNFoNwQAAOdl8eLF+j/96U/+57Y1Go0sWLCgsvqHcgBo6SorK+XEiROagoICRa/XS3h4uDM6OlptyNQwANAaJScnKz///LNbF8H06dOZShBAi1W98yo/P79BX6Dz8vJqjD9y5IgmNjaWPyZFi0WIBQAAanX06FFN1fm6bTabFBUVKQcPHtR+9dVXuqNHj7o+PBsMBnnnnXcqR4wYwQdnAK3Ko48+6p+enq6pvj6gTqeT/v37O0aOHGl/9NFHbZGRkawXCADVfPDBB4aq2/369XMmJiYyNTWAFqtLly5u17iMjAwlLy9P8fazYvXp/EVE8vLy6MRCi0aIBQAAavX222/rFy5caKhvjKIoMnz4cPsrr7xiufzyy7nhAKDVqRroV2W322X37t3a3bt3a19//XW/xx9/3DpnzhyLTsdXMAAQ+X1t1RUrVrjNGzh58mRrc9UDAE2ha9eualRUlFp1Wv6VK1fqHn/8cY9dqKWlpfLNN9/U+DBZWlpKiIUWjfl+AADAebvjjjvszz33nJUACwDqZjab5ZVXXjEkJSUFlJaWNnc5AOATNm3apK26jovBYJBJkybZm7MmAGgKt9xyi9u1bv78+X5FRUUej5s7d65fSUlJjf1lZWWEWGjRCLEAAMB5W716tW7IkCEB11xzTUBycjIfnAG0CoqiyKBBgxyzZ8+2rF+/viIzM7OsvLy81Gw2l2ZlZZWtWbPGfN9999n8/f3djtu6dav2rrvuMtrt3KMFgKVLl7p1Yd1444328PBwpl4F0OI9+eSTlqprSefk5Ch33HFHQFlZWZ3HLFmyRP/666/XOlOK2Wy++EUCPoQQCwAA1GrBggUWVVVLz/1XXl5empGRUbZ27Vrz1KlTbUaj0TV2+/bt2oEDB5p27tzJZwsALdrIkSPtR44cKf/5558rZs2aZR05cqQjNjZWDQgIEH9/f4mJiVFvvfVW+6JFiyqPHTtWdtVVV7mtFbh+/XrdggUL9HWdHwBag9LSUlm7dq3btXDq1Kkep9ICgJYgISFB/ctf/uI2feqWLVu0vXv3Ni1cuFCfmpqqWCwWKSwslI0bN2r/8Ic/GKdNm+bvcDhEURRp06aN2/lMJlOT1g80NUVV1Zo9iEArs3nzZu2wYcMCzm3HxcWpGRkZdf/5AwBAkpOTlbFjxwYcOHDAFVx16NBBPXToUFloaGhzlgYAPsNsNsvQoUMDdu7c6VqEOyIiQk1LSysLDAxsztIAoNksWrRI/8ADD7jaVdu1a6eePHmyTK8n4wfQOtjtdrn11luN69ata9CCqbNmzbJ89dVX+r1797q+hy9atKjyvvvu4w8B0GLx19IAAOC8JCQkqJs2baqIiYlxTfuSk5OjvPrqq37NWRcA+BKj0SgffvihWaf77/2J/Px8Zf369Q26YQEALcmHH37ollZNmDDBRoAFoDXR6XSydu1a85/+9CerVqv1OF6v18ucOXMss2fPtlafdjA0NJSpWNGiEWIBAIDzFhERoc6aNctSdd+yZcu4AwEAVSQkJKg33XST20JYGzduJMQC0CodP35c2b59u9sd22nTptFBAKDV0el08uabb1oOHDhQPnXqVFtUVFSNMCowMFDuuece288//1z+wgsvWEVECgsL3daj7tatm7OpagaaA1+cAADABbnzzjttDz74oL+q/v55Ozc3V0lLS1Pi4+P5azAA+I8bbrjBvnbtWtf3r+TkZP6gEECrtGTJEsO5z40iIv369XMmJiZyAxZAq9WrVy/nBx98UCkikpmZqeTl5SkVFRVKhw4dnHFxcaqf338nO8nLy1POnDnjCrECAwOlV69eXEPRohFiAQCACxIaGiqhoaFq1b8Gy83N1cTHxzuasy4A8CVxcXFuwX5+fr5S11gAaKmcTqesWLHCrWt/ypQp1uaqBwB8TVxcnFr9c2NVVdekFhHp27evo+q01UBLxF//AQCAi06v19OFBQBVVL8u2mzMnAWg9fn++++16enprhDfYDDIpEmTuCACgJf+/e9/uyVWI0eOtNc1FmgpCLEAAMAFKSkpkaKiIreOgvbt2xNiAUAVubm5bt+9IiIiuE4CaHWWLl3q1oU1evRoe1hYWHOVAwCXFLvdLqtXr3ZdR7Vardx77738IQBaPEIsAABwQb766itd1XUNwsPD1Q4dOnBzFgCq2L59u7bqdkxMDNdJAK1KWVmZfPHFF24h1tSpU7n5CgBeeuedd/QnT550/QHpyJEj7XymRGtAiAUAAM5bRUWFzJ4926/qvtGjR9u1Wm1dhwBAq1NUVCRr1qxxu3F7ww03MPULgFbl008/1ZeVlbm2IyMj1dGjR3MtBAAvpKSkKC+99JLru7der5fXXnvN0pw1AU2FEAsAAMiTTz7pt2PHjgZ9Ljhz5oyMGTMmICUlxXWcVquVJ598ksW5AaCKJ5980r+4uNi1bTAY5KabbuLGLYBWpfpUghMmTLDp9fq6hgNAi5aenq6Ul5d7Nfbw4cOaYcOGBRYWFrq6sJ544glrnz59nI1WIOBDdJ6HAC3H1q1btWazucb+ffv2ubUMVFZWyoYNG2ptI4iOjlb5nwSAlmbTpk26v//974YBAwY4xo4da09KSrJfdtllToPB4DbO6XTK0aNHNZ988onu7bffNpw5c8ZtLazHHnvMmpiYyDUSQIs0d+5cw4gRI+xXXnmlV9c5m80mM2bM8FuyZInbXdr777/fGh0dzdQvAFqNtLQ0ZevWrW7fsadNm8ZUggBarTVr1uhefvllv7vvvtt2++232wcNGuQICAhwG7N//37N0qVL9W+//bbBav3v34oOHDjQ8dJLL9GFhVZDUVW1pLmLAJpKx44dTZmZmYrnkXWbOHGibdmyZZUXqyYA8AV9+/YNPHjwoFsnlsFgkA4dOqht2rRRDQaDWlpaqmRnZ2tKS0trPcfEiRNtS5YsqWQqQQAt1XXXXRfw448/agcNGuS488477cOHD7f37NnTWb2ToLi4WL7++mvd/Pnz/Q4cOOB2be3cubO6c+fO8vDwcEIsAK3Giy++aJgzZ45rGqz+/fs79+zZ410LAgC0QG+88Yb+iSee8D+3rdVqpVOnTs6QkBAxm81y6tQppWrn1TlXXHGFc/369RV8lkRrQicWAAColdVqlfT0dEVE6g3/g4ODZe7cuZWPPPKITaNhpmIALd+OHTu0O3bs0IqIn5+fn0RHR6vBwcGqVquVwsJCJSMjQ3E6azZrRUZGquvWreOmA4BWZ/ny5W7t/ZMnT2b6aQCowuFwyIkTJ+r8Qq0oikydOtX21ltvVZpMpqYsDWh2hFgAAEBWrlxpXrt2rW7Tpk26X3/9VVtSUn+jtqIo0rt3b+c999xjmzZtmi0yMpIbsgBaJYvFIqmpqR4D/5EjR9qXLFlS2b59e66XAFqVH374Qfuf66SI/N7tP2nSJKYSBNCq3XDDDY6JEyfavv32W11eXl6dnyP9/PzkxhtvtD/99NOWq666iqn70SoxnSAAAHDjcDgkOTlZk5KSosnIyFBKSkoUm80mQUFB0qZNGzU+Pt45YMAAR5s2bZq7VABoUuvXr9d+/vnn+m3btmmTk5M1Doej3vEmk0lGjBhhf/TRR61Dhw6tfzAAAABapePHjysHDx7Unvv+LSLStm1btUePHs6rrrrKERgY2NwlAs2KEAsAAAAAGqi8vFwOHTqkSU9P1+Tk5ChlZWWK0+mUkJAQtW3btmqvXr2ciYmJTp2OyS8AAAAA4HwRYgEAAAAAAAAAAMDnsPo6AAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAAAAAAB8DiEWAAAAAAAAAAAAfA4hFgAAAAAAAAAAAHwOIRYAAAAAAOchNTVVURQlqL7/nn/+eb/mrrM14LUAAABomQixAAAAAAAAAAAA4HN0zV0AAAAAgEtfx44dTZmZmUp9YzQajbRp00ZCQkLU7t27OwYMGOAYN26cvU+fPs6mqhMAAAAAcOkgxAIAAADQJJxOpxQVFUlRUZGSlpamW79+vW7u3Ll+119/veOf//xnZffu3QmzcElLSkpyzJgxw1J1X5cuXZr9fZ2amqp06dLFdG574sSJtmXLllU2Z00XW1RUlLp+/fqKqvv27dun/X//7/8xhSAAAMAljBALAAAAQLPasmWL9vLLLw/85JNPKsaMGeNo7nqA8xUVFeUcOXIk7+FmYDQapfpzr9NxywMAAOBSxyc6AAAAABfdq6++aunXr5/bDWWHwyFnzpxR9uzZo121apU+JyfHNf1gRUWFjB8/PmDbtm3l/fr1a/bOFQAAAABA8yPEAgAAAHDRDRgwwJGUlFRrR8qkSZPsr776quUvf/mL38KFCw3n9peXl8uTTz7p/91331XUdhwAAAAAoHXRNHcBAAAAAFofPz8/WbBggWX8+PG2qvu///577YEDB/ieAgAAAAAgxAIAAADQfF577TWLRuP+tWT9+vXMGAEAAAAAYDpBAAAAAM0nLi5Oveyyy5z79+93JVmHDh1q8B/bFRQUKD/99JM2Oztbyc/PV0wmk4wePdreo0ePetfXslgs8tNPP2nT09M1p0+fVpxOp0RERKgJCQnOwYMHO3S68//KZLVaZf/+/ZpDhw5pCwoKlPLycvHz85OgoCC1U6dOzu7duzu7deumNvS8JSUl8uuvv2qPHj2qKS4uViwWiwQEBEhoaKgaHx/v7N27tzMqKqrB521OKSkpyv79+7XZ2dlKcXGxEh4ert5zzz22kJCQeo8rKiqSbdu26XJycpT8/HzF399f2rVr57z88sudffr0uSTXVistLZWDBw9qjx49qikoKFDMZrO0adNGjYiIUK+44gqnp/d0c8nKylJ27dqlzcrKUkpLS5XIyEj12muvdfTs2dNjvQcOHNDs3LlTm5eXpxgMBomLi3MOGzbMER4efkm9jwEAAHDxEWIBAAAAaFbx8fFuIVZBQYFSfUzHjh1NmZmZisjvwVdGRkaZiMi2bdu0r7zyiuHbb7/V2WxuMxOK0+mUHj16WGt7zAMHDmhmz57tt3HjRl1ZWVmtdYWEhMiECRNss2bNsrRv397rm+k5OTnKyy+/7PfJJ5/oi4qK6h0bFhamXn/99Y7p06dbR48eXesaYufs3r1bM3fuXL/169frrNZafy2XTp06qTfeeKP94YcfttYV5lx33XUBP/74o/bctqqqpfWetIr33ntPf//99/uf2160aFHlfffdZ6ttbGpqqtKlSxfTue2JEyfali1bVikisnTpUv3ChQv1v/zyi7b6cYMGDXJcccUVtda+Zs0a3euvv27YsWOH1m6311pjbGys+thjj1kfe+wxq7+/f61jfMXRo0c1K1as0G3cuFG3Z8+eOn8nEZHIyEj1gQcesD7++OPWtm3b1nveqv9uqlq+fLl++fLl+rqOq+31rOvf4Pbt27Vz5swxbN68Wedw1HwLDxkyxPH2229X9u7du8ZruWrVKt2LL77od/To0RrBtVarlbvvvtv2f//3fxbCLAAAgNaL6QQBAAAANCu93v1eut1ur3HTvTZ//etfDdddd13AunXragRYdbHZbPLwww/79+/fP/Dzzz+vM8ASESkuLpZ33nlHn5CQYPryyy+9+gPA9evXa3v16mX65z//6THAEhE5c+aMsnr1at3cuXP96hs3d+5cw6BBgwK//PJLjwGWiEh6erryzjvv1BtUNKfKykq57bbbjFOnTvWvLcCqy6lTp5QhQ4YE3H777cZt27bVG/ZkZWUpTz/9tF/fvn0DU1JSvHpPNYe1a9fqevbsGTh37ly/Xbt21fs7iYjk5eUpL7/8st9ll11m2rFjR7N+p1+wYIF+yJAhARs3bqw1wBIR+eGHH7SDBw8OrBqYOhwOuffee/3HjRtnrC3AOjdm2bJl+sGDBwfk5ub67OsHAACAxkUnFgAAAIBmVf0GdVhYmMfpx95++239c8895wp+DAaDdOzY0RkcHCy5ublKbTe9y8vL5bbbbgvYtGlTjdAkMjJSjYyMVDUajZybkvDcz0pLS+WOO+4wLl++3Dx+/Pg6E4aDBw9qbrvttgCLxeK238/PT+Li4pxt2rRRHQ6HUlJSIpmZmRpvg7d//etf+hdeeKFGyBUUFCRxcXHOwMBA1Ww2K0VFRUp2draiqr7ftDJ58mTj2rVrXd9Hg4KCJCYmxmkwGOTkyZPKmTNnarx+x44d04waNSogPT3d7WeKokhcXJwaFhamWiwWycjI0FQNJ1NSUjT/CVEqfHEqvsrKyhr7jEajxMTEOE0mkyiKIoWFhUpmZqbidP63/JycHCUpKSlw165d5bV1OTW2lStX6v785z/7n3u/mUwmiYuLcxoMBklPT9cUFxe7xpaUlMidd95pPHLkSFlYWJj88Y9/9F+8eLErYA0LC1NjYmJUu90uJ06c0FR9TlJSUjT33HOP8bvvvqtout8OAAAAvoIQCwAAAECzKS8vl19//dUtVOrUqVO9KUxRUZEyY8YMfxGR9u3bq7Nnz7aMHz/eFhwc7Bpz4sQJpby83C3sePDBB/2rBlgmk0kee+wx67333mvt0qWL22Pu2bNHM3fuXL8vvvhCJ/J7V8gDDzxgvPzyy8sSEhJqrW/GjBl+VQOsvn37Ol9++WXLyJEj7X5+7hmU1WqVAwcOaNatW6dbtWpVnd1SlZWVMnPmTLeDb7vtNvvMmTMtAwYMcGo07k0sJSUlsnPnTu26det0H330kU92YW3cuFF3+vRpRUTk8ssvd86dO7dy2LBhjqodedu3b9fGxMS4nufy8nK59dZbjVUDrE6dOqkzZsywjB8/3lZ1Wj2bzSYbN27UPv/88/779u3TiPw+ReW4ceOMO3fuLPfFqQW1Wq0MHz7cfvPNN9uHDRtm79Kli6rVumetJSUlsmbNGt3cuXP9UlJSNCIiFRUVcvfddxv37t1bXv29ICKybNkys9lslry8PGXKlCnGc/uTkpIcM2bMsNQ44D88rSdWUlKiPPTQQ0ZVVaVbt27OV155xTJmzBjX+9xut8unn36qe+SRR4znOhJPnz6tzJ0712/AgAGO9957T3+ujjlz5lgGDRrkOFd/WVmZvPbaa4Z58+b5nQvIvv/+e+2aNWt0t912W/1tagAAAGhxCLEAAAAANJs33njDYDab3fYlJSXVe6O6tPT3pZu6d+/u/O677yo6dOhQI1T6Tyjl2v/RRx/pVqxY4UpJOnfurK5fv768W7dutQZSl19+ufPzzz83v/LKK4Znn33W79zjPvnkk/5ff/21ufr44uJi2bx5s+v7VUJCgvPnn38uDwgIqPV3MBgMMmDAAOeAAQOss2bNsh45cqTWKdW+/fZbXVFRkSu4ueeee2zLly+v2brzH8HBwTJ8+HDH8OHDHa+++qolKyvL56ZhOxdg3XHHHfaPP/7YXH06SRGRq6++2m1uuieeeML/2LFjrudo9OjR9o8//tgcFBRU41i9Xi833XSTIykpqXzcuHHGc1NBHjhwQLNgwQLDjBkzPM/H2IQGDBjgSElJKYuPj683vA0ODpbJkyfbx44da7/99tuNGzZscP1e69at044ZM6bGfH7XXXedQ+T3dcmq7o+KinKOHDmy3jXY6nOuy+qqq65yfPPNNxVt2rRx+7lOp5MJEybYIyMjK5KSklz/CJYsWWJYuXKlKiLy2GOPWd944w1L9fDNZDLJyy+/bFVVVZk3b57h3P73339fT4gFAADQ+rAmFgAAAIBmsWbNGt3s2bPduow6deqknrvxXh+9Xi+rVq0y1xZgVed0OqXq4wQEBEh9AVZVM2fOtN5xxx2uG+fr1q3T1baGz4kTJzRV1zKaPHmyra4Aqza9evWqtfOlanAjIvLwww97Nweh/D6NYdeuXX1ybsH4+Hh12bJltQZY1WVkZCgffPCBa2CfPn2cq1evrjXAqsrf318++ugjc8eOHV3PwcKFCw2e1pxqal26dFE9BVhVGY1GWbFihblqcPTBBx8Y6jmkUYSGhsqqVavM1QOsqm644QbH8OHDXf+ei4uLJS8vTxk8eLDj73//e40Aq6rnnnvOUvXcmzdv1vnaawcAAIDGR4gFAAAAoEnY7XbJz89X1q1bpx03bpzxjjvuMFZfF2rOnDmVBoPn+/F33nmnrW/fvl6tA/TNN99ok5OTXd99HnnkEas3AdY5L7zwgmvaNVVVZfXq1TVmtDCbzW6dLt6EM96o3qWm1+t9MpRqqGeeecbibci3YMECt+Dpf//3fyu9nRIwMDBQ/vSnP7k6rzIzM5Vdu3bVWBPtUhMWFiYjRoxwPSk7duxo8t/p/vvvt1ad8rEuN998c43g9cUXX7RUny6xOqPR6NaVaTabpbYAGQAAAC0bHwABAAAAXHTDhg0LUBQlqOp/er0+qF27dqabbropYNWqVbpz692c8+c//9k6adIkr1otJkyY4HVLxrp169xCpylTpnjdzSQi0q9fP2dkZKSr2G3bttW4+x4dHe0WqH322Wc6q/XCZ62Ljo52e5KWL1/uk+tcNYRWq5UJEyZ4/RqsX7/e9fpFRkaqI0aMaNA0eKNGjXJ7r2zduvWSD7FERDp16uR6z+Xk5Ch5eXlNOnXkXXfd5dVreNlll7n92wgNDZVhw4Z59Rr26dPHbVxGRobPTY8JAACAxkWIBQAAAKBZBQYGyltvvVX5xhtvWDyP/t2gQYO8DjK2bdvmCkECAwOlZ8+eXnVwVVW14+TYsWM1QpD4+Hi1a9eurvPu3r1bO3LkyIAff/zxggKTpKQke9WOlbfeesvw4IMP+h8/fvySvZmfkJDgDA4O9mpsYWGhVF0vrF+/fg5PHTzVdezY0e319uVunqKiIvnXv/6lnzx5sn+/fv0C27dvbwoMDAyqHggrihI0f/58t5bFgoKCJntP6PV6SUxM9OrfUXh4uFsQm5iY6KhvGsGqwsLC3I4tKSm5ZN/3AAAAOD81psEAAAAAgMbm7+8viYmJjttuu81+77332iIiIryeJs9kMklDxlddV6q8vFy0Wm39iyl5UFRUVOuN9FmzZlkmT55sPLe9ZcsW7XXXXRfQsWNHdfjw4fYhQ4bYr776akdD1j/q2LGjOmXKFNvixYtdHVjvvvuu/t1339X379/fecMNN9iHDBniGDx4sD0sLOxCfq0mU7WDyJPffvtNW7Vjb8OGDTpFUS7o9SssLPS5IKSsrExmzZrl949//MNgsXid5bqp633ZGEJDQ1WdzrvbCQEBAW7v9+qhlodj3barT9sJAACAlo8QCwAAAMBF9+qrr1r69evn1i2l1WolKChIDQ0NVePj49XzXTcqKCjI65vgZWVlcr6hQF3Onj1b6/5JkybZT5w4YZkzZ45f1eAlIyNDee+99/TvvfeeXkQkLi5OHTZsmH38+PG2pKQkj10pCxcurDx16pRSfVrEvXv3avbu3Wt4/fXXRVEUueyyy5wjR460T5o0yVZ9Cjdf4m0XlojImTNnLnpo4WvdPPn5+crQoUMDDh8+fEEdYhf7fV4fb9ckq+PY817Xzen02bc1AAAAGgkhFgAAAICLbsCAAY6kpKQGrV3krYaEX43RnVJ9La+qXnrpJeuIESMcc+bMMWzatEnncNR8CjIzM5XFixfrFy9erO/Vq5fz9ddfrxw1alSdz5XRaJSvvvrK/NFHH+nmz5/vd+DAgRphh6qqcuDAAc2BAwcM8+fPN4waNcr+5ptvViYkJJx3YNBY9Hq91zUVFxdf9Mf3tSDkzjvvNFYPsGJiYtQhQ4bYe/bs6YyNjXWaTCYxGo1q1cDzww8/1H/00UeX/BppAAAAQH0IsQAAAAC0WIGBgW6BSWhoqLpy5UpzYz7m4MGDHevXrzdnZ2crGzZs0G3ZskW7bds2XVpaWo1A7ciRI5rRo0cHvPbaa5YZM2ZY6zqnRqORiRMn2idOnGg/dOiQZsOGDboffvhB+9NPP2lr61Zav369bsCAAaYvv/yy4vrrr2+UMLEpVJ9ObsiQIY6ZM2deUMtRaGiozwR7X3zxhW7r1q2uRb6CgoJk4cKF5nvuucfuae2vTZs28X0eAAAALR4fegEAAAC0WCEhIaLT6cRut4uISGVlpTJy5MgmCXWio6PV6dOn26ZPn24TETl58qSyefNm3Zo1a3T//ve/dTabTUR+76J65pln/AYPHuy4+uqrPdbWp08fZ58+faxPPfWUOJ1O+e233zTr16/Xff7557qffvrJlXyUlpbKXXfdZTxx4kRZUFDNZaQU5fyb1CoqKs772Iaovn6Sn5+f2lSvX1P4+OOP3Tqp/vGPf5gnTpxo9+bYplwDCwAAAGguFzTnNgAAAAD4Mo1GI3Fxca4gxGw2y8mTJ5vl5n9MTIw6ZcoU2xdffGE+duxY2RVXXOGa105VVfn73/9uaOg5NRqN9O7d2/nUU09Zt2/fXvH9999XhIWFuX7f/Px8ZcmSJbVOOefn5+e23ZBgKj8/v0mew86dO7vN/ZeamtqivsPu2rXLFTq2bdtWHT9+vFcBlsjvXXyNUxUAAADgO/jQCwAAAKBFGzJkiFswsHnz5mafkSI+Pl796KOP3FKjql1U5+v66693zJs3z226ve3bt9f6+wYHB7t1OZ06dcrrYOqXX3654Fq9ERcXp3bp0sUVZB0/flyTkZHRYjqQTp8+7fpdunTp4tTpvHtrnj17Vvbu3ev1a1B1LS2R+td1AwAAAHwJIRYAAACAFm3UqFFuIdbbb79da2dSU0tISFDbtWvnShNqW9vqfFx77bVu0+0VFBTUet64uDi3Lqc9e/Z4FYrk5+crP/zwQ5MFgSNGjHD7fd56660Gd6z5qqphktVq9fr1X7RokaGystLrxzGZTG7bFRUVLSYIBAAAQMtGiAUAAACgRbvjjjvsVbt5du/erV2wYEGzB1kWi0VKS0tdYUJISMhFaY+pPtVfaGhoree94oor3MKhVatWefWcvPTSSwaz2Xz+BTbQk08+aanaofTOO+8Ydu/e3SK+y0ZGRrpem99++01TVFTk8ZisrCxl3rx5fh4HVhEcHKxqtf/NKNPT01vE8wcAAICWjw+uAAAAAFo0nU4ns2fPdpti76mnnvJ/5513GhRkHT16VHPvvff6Z2Vl1ehiWbZsme7ll182FBYWen2+t956yy0M6t+/v6P6mJkzZ/otXbpUb7PZvDqn0+mU119/3a1T6fLLL69xXpHfO5z0+v8+BatXr9b98MMP9XZj/fOf/9S/8847TdoJ1bVrV3Xq1KmuJ8BsNsstt9wSsG3btgZNafjtt99q7733Xv+LX+H5GzRokKtL0Gq1yjPPPFNvfXl5ecqYMWMCiouLG/Q4BoNBunbt6gpyDxw4oElJSaEbCwAAAD6PEAsAAABAi3fPPffY77vvPlcQYrPZ5OGHH/YfOnRowNq1a3VlZWU1jrFarbJnzx7N3/72N8PVV18d0KtXr8DFixfXGijl5eVpZs2a5RcbGxt0++23G5cvX65LS0urNSQ4evSo5qGHHvJ/5pln3Lpp7r///honPnTokGbq1Kn+0dHRpgceeMD/3//+t7a26QEdDof88MMP2mHDhgV89dVXrralgIAAmThxYq0JWEREhHrLLbe4QhSn0ym33nprwHvvvae3WNwyP9m/f79mwoQJ/g899JC/qqrSuXPnJl1U6c0336xMTEx0hTCnTp1Shg4dGjB58mT/7du3a2t7TUpLS+WHH37QPvPMM34JCQmBI0aMCNi0aVOzr4dW1eTJk90KX7RokX7ixIn+1d87JSUl8q9//UufmJgYeODAAY2ISPfu3d2mg/Rk+PDhrtfa4XDIkCFDAl944QXDZ599plu/fr12w4YNrv+ys7MJuAAAAOATfOoDPAAAAAA0lrfffruyqKhIWb16tet70JYtW7Rbtmwx6nQ6iYuLU0NDQ1W73S5nz55VcnJyFKvV2qDHqKiokDVr1ujWrFmjExEJCQmRdu3aOUNCQlSr1aqcPHlSqS2EGjt2rP0Pf/iDveYZf5efn68sWrRIv2jRIr2ISPv27dWwsDA1MDBQLS8vVzIyMjS1BXGvvfZaZWxsbJ2B0/z58ys3bNhgOnfs2bNn5f777/d/4okn/OPj451arVays7OVqlMUXnPNNY67777b9vDDDzdZV1NAQIB8+eWXFaNHjw44fPiwRkTEbrfLsmXL9MuWLdMHBgZKdHS0s02bNmpFRYVSXFys5OTkKFXXnPJFN954o2PkyJH2DRs2uN6TK1as0K9YsUIfHx+vhoeHO4uLi5WMjAxN1ffiuHHj7F27dnXOmzfP6664Rx55xPbee++51tLKzc1V5s6dW+u0hIsWLaqsGvoCAAAAzYVOLAAAAACtgsFgkM8++8w8b948i9FodPuZ3W6X1NRU5ddff9Xs379fk56eXmuAFRYWplY/tj7FxcWSnJys2bVrl3bfvn2a2gKs6dOn21asWNGgRaZOnTqlHD58WLNr1y7t4cOHawRYRqNRFi5cWPnoo4/WG0TEx8ern3zySUVAQIDb/rKyMjl48KBm3759mqoB1vXXX+/46quvKqpOQ9hU4uLi1B07dpRPmDDBpijuT2N5ebkkJydrdu/erT18+LAmOzu71gArNja2Qd1LTWHlypXmAQMG1JjyMS0tTdm9e7c2JSXFLcAaO3asfenSpQ1elKxHjx7OJUuWmE0m0wVWDAAAADQdQiwAAAAArcqzzz5rPXHiRNnjjz9ura9L6ZzIyEh1woQJtk8//dSck5NTFhUVVeOYhx9+2Pr555+bp02bZuvSpYvHoMTPz09uueUW+5YtWyref//9yrpCoffee6/y3Xffrbztttvs7dq181hraGioev/999sOHz5c9sgjj3jVSTN69GjHjh07yocPH+6oHg6dExkZqf7tb3+zfPvttxUhISHenLZRmEwm+eijjyr37NlTftddd9m9qSUhIcH56KOPWn/88ceKbdu2VTR+lQ0TGhoqP/74Y8XMmTOtbdq0qXNcz549ncuWLTOvWrXK7OdXawOVR+PGjbMfPXq0bO7cuZZhw4Y5YmJiVJPJJHW97gAAAEBzU1RVLWnuIgAAAACguSQnJyt79+7Vnj59WikqKlJ0Op20adNG7dixo7NXr17O81n/KS8vTzl8+LDmxIkTmsLCQqWiokICAgIkNDRU7dmzp7N///6O8+mIOXHihHL06FFNenq65uzZs4rVahWTySTt2rVz9u3b19m7d2/nhXRJ5ebmKlu2bNFmZ2drysvLpW3btmpiYqJz8ODBDp3O92ajdzgc8ssvv2iSk5M1+fn5mpKSEgkICJCQkBC1a9euzt69ezsjIyMbbU7B1NRUpUuXLq4XcuLEibZly5ZVnu/5zGazbN++XXvkyBFNUVGRYjAYJDo62nnllVc6e/To4XNdZL5u8+bN2mHDhrnaDJ977jnr3LlzLfUdAwAAAN/ie99CAAAAAKAJJSQkqAkJCXWuR3U+IiMj1cjISMcNN9xQY5q4C9GlSxe1S5cuDhG5qOc9JyoqSp0wYcJFfS4ak1arlYEDBzoHDhzYIgIeo9Eow4YNcwwbNqxRXl8AAADgUsN0ggAAAAAAXATLly/XK4oSVPW/559//vzm/kODpKamKtWf+6pdWAAAALg0EWIBAAAAAAAAAADA5xBiAQAAAAAAAAAAwOewJhYAAAAAAOchKipKXb9+fUV9Y7p06dIi1uvydbwWAAAALZOiqmpJcxcBAAAAAAAAAAAAVMV0ggAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOYRYAAAAAAAAAAAA8DmEWAAAAAAAAAAAAPA5hFgAAAAAAAAAAADwOf8fBsc0TCzeTTcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -239,8 +239,8 @@ "bst.plot_vle_phase_envelope(\n", " IDs=hydrocarbon_chemicals,\n", " zs=hydrocarbons_PR.z_mol,\n", - " P_range=[1, 20],\n", - " xticks=[1, 5, 10, 15, 20],\n", + " P_range=[1, 10],\n", + " xticks=[1, 3, 5, 7, 9],\n", " yticks=[150, 200, 250, 300, 350],\n", " thermo=[IG_thermo, PR_thermo],\n", " labels=['IG', 'PR'],\n", From 4371b348557d819f6efe0eb10b23f4d1f6a098e6 Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 14:21:10 +0800 Subject: [PATCH 22/26] update docs --- biosteam/units/stage.py | 2 +- docs/tutorial/Distillation.ipynb | 110 ++++++++++++++--------------- docs/tutorial/Thermodynamics.ipynb | 8 +-- thermosteam | 2 +- 4 files changed, 58 insertions(+), 64 deletions(-) diff --git a/biosteam/units/stage.py b/biosteam/units/stage.py index eecb6959..c31f1758 100644 --- a/biosteam/units/stage.py +++ b/biosteam/units/stage.py @@ -219,7 +219,7 @@ def surrogate_residuals( else: Sb = np.exp(logSb1) - 1 Sb[Sb < 0] *= -1 - Sb[Sb < 1e-9] = 1e-9 + Sb[Sb < 1e-12] = 1e-12 S = alpha * np.expand_dims(Sb, -1) xL = MESH.bottom_flow_rates( S, diff --git a/docs/tutorial/Distillation.ipynb b/docs/tutorial/Distillation.ipynb index f193ea4f..5b17640e 100644 --- a/docs/tutorial/Distillation.ipynb +++ b/docs/tutorial/Distillation.ipynb @@ -47,7 +47,7 @@ " " + "" ] }, "metadata": {}, @@ -469,29 +469,30 @@ " ------------ 243 kmol/hr\n", "outs...\n", "[0] distillate \n", - " phase: 'g', T: 401.48 K, P: 366463 Pa\n", - " flow (%): n-Pentane 21.4\n", - " n-Hexane 35.5\n", - " n-Heptane 0.294\n", - " Cyclohexane 4.51\n", - " Cycloheptane 3.31e-08\n", + " phase: 'g', T: 401.04 K, P: 366463 Pa\n", + " flow (%): n-Butane 0.612\n", + " n-Pentane 21.2\n", + " n-Hexane 35.1\n", + " n-Heptane 0.291\n", + " Cyclohexane 4.46\n", + " Cycloheptane 5.08e-07\n", " Benzene 38.3\n", - " Toluene 2.47e-07\n", - " ------------ 210 kmol/hr\n", + " Toluene 4.01e-06\n", + " ------------ 212 kmol/hr\n", "[1] bottoms_product \n", - " phase: 'l', T: 402.88 K, P: 366463 Pa\n", - " flow (%): Ethane 5.56e-07\n", - " Propane 0.00189\n", - " n-Butane 3.94\n", - " n-Pentane 1.43e-09\n", - " n-Hexane 0.00763\n", - " n-Heptane 91.9\n", - " Cyclohexane 0.586\n", - " Cycloheptane 0.513\n", - " Benzene 2.97\n", - " Toluene 0.0667\n", - " Hydrogen 7.37e-16\n", - " ------------ 32.9 kmol/hr\n" + " phase: 'l', T: 422.07 K, P: 366463 Pa\n", + " flow (%): Ethane 5.93e-07\n", + " Propane 0.00201\n", + " n-Butane 8.94e-13\n", + " n-Pentane 3.11e-08\n", + " n-Hexane 0.0584\n", + " n-Heptane 98.1\n", + " Cyclohexane 0.626\n", + " Cycloheptane 0.548\n", + " Benzene 0.591\n", + " Toluene 0.0711\n", + " Hydrogen 7.87e-16\n", + " ------------ 30.8 kmol/hr\n" ] } ], @@ -623,32 +624,33 @@ " ------------ 243 kmol/hr\n", "outs...\n", "[0] distillate \n", - " phase: 'g', T: 401.19 K, P: 366463 Pa\n", - " flow (%): Ethane 8.72e-08\n", - " Propane 0.000296\n", - " n-Butane 0.618\n", - " n-Pentane 21.4\n", - " n-Hexane 35.5\n", - " n-Heptane 0.311\n", - " Cyclohexane 4.36\n", - " Cycloheptane 5.2e-08\n", - " Benzene 37.8\n", - " Toluene 3.85e-07\n", - " Hydrogen 1.16e-16\n", - " ------------ 210 kmol/hr\n", + " phase: 'g', T: 401.13 K, P: 366463 Pa\n", + " flow (%): Ethane 0.00208\n", + " Propane 0.00189\n", + " n-Butane 0.612\n", + " n-Pentane 21.2\n", + " n-Hexane 35\n", + " n-Heptane 0.432\n", + " Cyclohexane 4.48\n", + " Cycloheptane 0.00262\n", + " Benzene 38.3\n", + " Toluene 0.00259\n", + " Hydrogen 0.00208\n", + " ------------ 212 kmol/hr\n", "[1] bottoms_product \n", - " phase: 'l', T: 554.64 K, P: 394753 Pa\n", - " flow (%): Ethane 1.01e-59\n", - " Propane 4.42e-37\n", - " n-Butane 1.07e-21\n", - " n-Pentane 1.96e-11\n", - " n-Hexane 0.0035\n", - " n-Heptane 91.8\n", - " Cyclohexane 1.51\n", - " Cycloheptane 0.513\n", - " Benzene 6.09\n", - " Toluene 0.0667\n", - " ------------ 32.9 kmol/hr\n" + " phase: 'l', T: 557.38 K, P: 394753 Pa\n", + " flow (%): Ethane 0.000825\n", + " Propane 0.00189\n", + " n-Butane 0.00304\n", + " n-Pentane 0.004\n", + " n-Hexane 0.00458\n", + " n-Heptane 98.4\n", + " Cyclohexane 0.509\n", + " Cycloheptane 0.541\n", + " Benzene 0.512\n", + " Toluene 0.0595\n", + " Hydrogen 0.000251\n", + " ------------ 30.5 kmol/hr\n" ] } ], @@ -698,7 +700,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABrsAAAUjCAYAAAB2KJ6gAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAuIwAALiMBeKU/dgABAABJREFUeJzs3Xd8VFX+//H3THqFhARDSaEXaVIEBAQUsIEoFgQBcVXQte6yInZEsWPZRb8qChZWsKCCigKKgKC00JsQJCHUFALpde7vD3/M5qbOJJmEIa/n45HHg3PnnHs/U43zzjnHYhhGugAAAAAAAAAAAAA3ZK3rAgAAAAAAAAAAAICqIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2yLsAgAAAAAAAAAAgNsi7AIAAAAAAAAAAIDbIuwCAAAAAAAAAACA2/Ks6wJw7rDZbDp06JBlx44dHomJiZbTp09bfHx8FBISYrRt29bWu3fvIj8/vxq9Znp6un799VePP/74wyM9PV1+fn6KiYmx9evXr6h58+ZGjV4MAAAAAAAAAACcdwi76rlTp05p0aJFXsuWLfNctWqVR2pqqqW8vl5eXrryyisLH3roofzLLrusqDrXPXjwoOXJJ5/0WbRokVd+fn6p2y0WiwYMGFA0ffr0vMGDB1frWgAAAAAAAAAA4PxlMQwjva6LQN24++67fefNm1dm2FSZW2+9teCtt97KbdCggdNjFyxY4HnnnXf6ZWdnV9rXYrHon//8Z/7LL7+cZ7Wy6iYAAAAAAAAAADAj7KrHunfvHrB169ZSCZKHh4ciIiKMxo0bGwUFBUpMTLSeOXOm1PiePXsWrVy5MjsoKMjhay5cuNDz1ltv9bPZbKbjYWFhRvPmzY3k5GTLsWPHLIZhXsHw/vvvz//3v/+d5/CFAAAAAAAAAABAvcBUGUiSGjZsqMmTJxcsWbIk59SpUxlHjhzJ3LJlS9bOnTuzUlJSMn766afsfv36mZYT3Lx5s8eECRMc3sTrwIEDljvvvNMUdHXu3Nm2YsWK7OTk5MytW7dmHTlyJHP37t1ZI0eOLCw+9j//+Y/3F198wbKbAAAAAAAAAADAhJld9Vj37t0DTp06ZXn00Ufzxo8fX+Dv719h/8LCQt19992+H3zwgVfx4ytWrMgeMmRIpftqjR492u/zzz+3B1Y9evSw/fzzz1llLYVos9k0adIk07Vatmxp7Nu3L9PLy6tUfwAAAAAAAAAAUD8RdtVjS5Ys8bziiisKfXx8HB5TWFio3r17B2zZssU+K3D06NGFCxcuzKlo3M6dO63dunULODury9vbW1u2bMm68MILbeWNycnJUZcuXQLi4uLs13r77bdz77nnngKHCwYAAAAAAAAAAOc1ljGsx6699lqngi5J8vT01MMPP2zaO2vFihUelY374IMPvIovX3jTTTcVVBR0SZKfn58efvjh/OLH5s6dy7QuAAAAAAAAAABgx8wuOO3YsWOWZs2aBRY/lpmZmREQEFDumNatWwccPHjQHq6uXLkye/DgwZUufZiZmamIiIigrKwsSZLFYtHhw4czmzdvblT9HgAAAAAAAAAAgPMFM7vgtNDQ0FJB0+nTpy3l9d+7d6+1eNAVEBCg/v37Vxp0SVJgYKB69+5t72sYhr799lvPisYAAAAAAAAAAID6g7ALTjty5EipYCssLKzcmVZbt241vc569uxZ5OXl+GqEl1xySWHx9vbt2ytdNhEAAAAAAAAAANQPhF1w2po1a0wzq6KiooyK9v7as2ePKZzq0KFDhXt1lVRyb699+/bxugUAAAAAAAAAAJIIu1AF8+bNM03LuvLKKwvL6ytJ+/fvN73Omjdv7lTYFRkZaZo1VvJ8AAAAAAAAAACg/iI0gFO+/fZbz7Vr15pmak2cODG/ojHJycmmZQ8jIyOdCrtKhmMpKSnl7g8GAAAAAAAAAADqF8/KuwB/SU1N1T333ONb/NiIESMK+/btW2F4lZmZaWoHBAQ4dd3AwEDTzK6CggLl5ubK19e3vCEOOXHihKVkEFeZ9PR0bdy40SM4ONgICQlRZGSkrbp1AAAAAAAAAADg7nJzc5WYmGifZDVo0KDC0NDQWrk2YRccUlRUpLFjx/odPXrUHg41aNBA//nPf3IrG5uZmWkKlHx9fY3y+pbFz8+vzHM6e56SZs+e7T1z5kzv6pwDAAAAAAAAAACUtmjRopxRo0ZVuA1STWEZQzhkypQpPsuXLzeFo2+//XZOdHR0pYFTXl6eKezy9nYuX/Lx8Sl1LDs726lzAAAAAAAAAACA8xNhFyr12muveb/55pumhOqf//xn/tixYx1KZH18fEyBWH5+hVt8lZKXl1fqWFmzvQAAAAAAAAAAQP3DMoao0CeffOL5r3/9yzS1avz48QWvvPJK6QSqHCX33MrNzXVqn6ycnJxKz1kV9913X/7o0aMLnBmze/du65gxY+xJ2zfffKPWrVtXtxQAAAAAAAAAANxaXFycrrvuOns7KirKVlvXJuxCuRYvXuz5t7/9zc8w/pcrjRw5snDu3Lm5VqvjkwIDAwNN7aysLKfqKLnnl6enZ43M7IqIiDAiIiKqFZq1bt1aF154YbVrAQAAAAAAAADgfFLWFkWuwjKGKNNPP/3kccstt/gVFv5vpcLLLrus6LPPPsvx9HQuIw0PDzcFSomJiU697o4cOWLqHxYWVu1ZXQAAAAAAAAAA4PxA2IVSfvvtN4/rr7/ePzc3136sT58+RYsXL86uShLbtm1b01RFZ8Ouw4cPm2Z2tWvXrtamPgIAAAAAAAAAgHMbYRdMtm3bZh0+fLh/Zmam/VjXrl1tP/zwQ3bJ5Qgd1aFDh6Li7b179zr1utuzZ4+pP2EXAAAAAAAAAAA4i7ALdnv37rUOGzbMPy0tzX6sXbt2tmXLlmU3bNiwyue96KKLTOFUbGysR0FBgcPjf/vtN9O6iV27di0qry8AAAAAAAAAAKhfCLsgSTp06JBl6NCh/snJyfYlA2NiYowVK1ZkX3DBBdXaI6tjx462li1b2s+RlZWltWvXejgyNjMzUxs3brT3tVgsuvbaawsrGgMAAAAAAAAAAOoPwi7o6NGjliFDhgQcPXrUHnQ1bdrU+Omnn7IiIyOrFXSdNXz4cNNUrg8++MDLkXGffvqpV/ElFbt3725r3rx5jdQEAAAAAAAAAADcH2FXPZeamqqhQ4f6//nnn/agKywszFi+fHl2q1ataixUuuOOOwosFvsl9MUXX3jt3r27wtdfTk6OXnnlFe/ix26//fb8mqoJAAAAAAAAAAC4P8Kueiw9PV1XXHFFwN69e+2vg4YNG+rHH3/MvvDCC20VjXVWly5dbDfccIN9+cH8/HzddtttfmfOnCmzv81m0wMPPOAbFxdnr61FixbGXXfd5fhmXwAAAAAAAAAA4LznWdcFoO6MGDHCPzY21hR4PvDAA3kpKSmWZcuWObSn1lm9evUqCg0NrbDPzJkzc5cuXRqYnZ0tSYqNjbUOGDAg4PXXX8+9/PLLi87227dvn3XatGk+ixcvNr0+n3/++Vxvb28BAAAAAAAAAACcRdhVj61Zs6ZUoDVjxgyfqpzrp59+yi4eWJWlbdu2xnvvvZczfvx4P8P4a4XEnTt3WocMGeIfFhZmREZGGsnJyZajR49azt5+1t///vf8W265pbCs8wIAAAAAAAAAgPqLsAu16tZbby00DCNn0qRJfjk5OfbjKSkplpSUFEtZYx566KH8WbNm5dVakQAAAAAAAAAAwG2wZxdq3bhx4wp37NiROXr06EIvL69y+/Xv37/o559/zn799dfzrFZeqgAAAAAAAAAAoDRmdtVjhmFk1NW1W7dubSxcuDDnzJkzWrNmjef+/futGRkZ8vX1VXR0tK1///5FkZGRRuVnAgAAAAAAAAAA9RlhF+pUgwYNNGLECPbiAgAAAAAAAAAAVULYBQAAAABAPWQYhmw2mwyDRTUAAADOVxaLRVarVRaLpa5LcSnCLgAAAAAA6omCggKdOXNGZ86cUUFBAUEXAABAPWCxWOTl5aUGDRqoQYMG8vLyquuSahxhFwAAAAAA57m8vDydPHlSWVlZdV0KAAAAaplhGMrPz1dycrKSk5MVEBCgCy64QD4+PnVdWo2x1nUBAAAAAADAdQoKCnT48GGCLgAAAEiSsrKydPjwYRUUFNR1KTWGsAsAAAAAgPNUUVGREhMTVVhYWNelAAAA4BxSWFioxMREFRUV1XUpNYJlDAEAAAAAOE8dP35ceXl5pmNWq1XBwcEKDg6Wl5eXrFb+DhYAAOB8ZbPZVFBQoPT0dKWnp8tms9lvy8vL0/Hjx9W8efM6rLBmEHYBAAAAAHAeKioqUkZGhumYt7e3oqOj5enJ1wEAAAD1hbe3twICAhQeHq6EhATl5+fbb8vIyFBRUZE8PDzqsMLq48+3AAAAAAA4D5Xco8tisSgyMpKgCwAAoJ7y9PRUZGSkLBaL6fj5sLcrYRcAAAAAAOehkrO6/P395e3tXUfVAAAA4Fzg7e0tf39/07HMzMw6qqbmEHYBAAAAAHAeKvkXukFBQXVUCQAAAM4lgYGBpjZhFwAAAAAAOOcYhqGioiLTMT8/vzqqBgAAAOeSkjO7ioqKZBhGHVVTMwi7AAAAAAA4z9hstlLH3H3TcQAAANSMsn4vLOv3R3dC2AUAAAAAwHmmrL/MLbkROQAAAOqnsn4vZGYXAAAAAAAAAAAAUEcIuwAAAAAAAAAAAOC2CLsAAAAAAAAAAADgtgi7AAAAAAAAAAAA4LYIuwAAAAAAAAAAAOC2CLsAAAAAAAAAAADgtgi7AAAAAAAAAAAA4LYIuwAAAAAAAAAAAOC2CLsAAAAAAADqqfj4eFksFvvPxIkT67okl5o+fbrp/q5atcpl1yp+nUGDBrnsOgAAgLALAAAAAAAAAAAAboywCwAAAAAAAAAAAG6LsAsAAAAAAABAvcDykgBwfiLsAgAAAAAAAAAAgNvyrOsCAAAAAAAAUDdiYmJkGEZdl1Frpk+frunTp9d1GQAAoIYxswsAAAAAAAAAAABui7ALAAAAAAAAAAAAbouwCwAAAAAAAAAAAG6LPbsAAAAAAABQI86cOaM1a9YoLi5OOTk5atSokVq3bq3+/fvLx8enyuc9deqUtmzZori4OJ05c0aFhYXy9/dXWFiYWrRooQsvvFAhISE1eE/Kt3nzZu3evVvHjx+Xp6enoqOjdckll6hZs2Y1fq3s7GytW7dOR48eVVJSkjw8PNS4cWN17NhR3bt3l8ViqfFrOsJms2njxo06cOCAkpKSVFRUpMaNG6tFixa65JJL5OXlVSd1AQDqL8IuAAAAAACAeio+Pl4tWrSwt2+77TZ9+OGH5fYfNGiQVq9ebW8bhiFJOn78uB5//HH997//VX5+fqlxAQEBeuihh/Too48qICDA4fp+/vlnvfTSS/r5559ls9nK7WexWNSuXTuNHDlS9957ryIjI8vsN336dD3zzDP29i+//KJBgwY5VMu8efM0c+ZMHTx4sMzrDx06VK+88oq6dOni0Pkqsm7dOs2cOVMrV65UXl5emX0aN26syZMn6+GHH1ZQUFC1r+mIpKQkzZgxQwsXLlRqamqZfYKCgnT99ddrxowZio6Odui85b2uHPHhhx/q9ttvt7fnzZuniRMnVnj+s1avXl1hYPj0009r+vTpDtcCAKg7LGMIAAAAAACAKvv111/VqVMnzZs3r8ygS5KysrI0c+ZMDR48WKdOnar0nIZh6P7779eQIUO0YsWKCoOus/337dunl156ScuWLavS/ShPbm6uRowYob/97W9lBl1nr798+XL16tVLCxYsqPK1srKydPPNN6t///764Ycfyg26pL+Cp2effVZt27bVpk2bqnxNR33++edq3bq13nrrrXKDLknKyMjQxx9/rHbt2umtt95yeV0AAEjM7AIAAAAAAEAVxcbG6qqrrlJWVpYkyWq1qkWLFmrUqJHS0tIUFxdnmqWzadMmTZw4UUuWLKnwvE899ZRmz55d6nhoaKgiIyPl5+enrKwspaSk6Pjx4zV7p4opLCzUDTfcoKVLl5a6rXnz5oqIiFBaWpoOHTokm82m/Px8TZgwQU2aNHH6WklJSbr66qsVGxtb5rUuuOACFRUVKSEhQWlpafbbTpw4oUGDBmnZsmXq37+/09d1xJw5c3T33XeXCh0DAwMVHR0tLy8vxcfH6/Tp0/bb8vLydN999yk1NVVPPfWUS+oCAOAswi4AAAAAAABUyc0336ysrCyFhobqiSee0IQJE9SoUSP77ceOHdPjjz9uWhrx22+/1Q8//KCrrrqqzHMePXpUL730kunY5MmT9eCDD6pDhw6l+qelpem3337Td999V61ZVWV59dVXSwVdt9xyi55++mm1b9/efuzEiRP6z3/+o5dfflmFhYWmZfUcYbPZdMstt5iCrvDwcE2dOlXjxo1TRESEqe/vv/+up556SitXrpT0195eY8aM0bZt20yPf03YsmWL7r33XlPQFRUVpVdffVXXXnutfS+2oqIi/fTTT5oyZYp2795t7/v000+rV69e5T7ftWHWrFn2gHDo0KH24126dNGsWbPKHdeyZUuX1wYAqBmEXQAAAAAAwG3ZDEPHs3OVXVgkf08PNfH3lbWCPXhQs/7880/FxMTop59+UqtWrUrd3rRpU82bN09eXl6aM2eO/fh7771XbvixePFiFRQU2NtPPfWUaZ+tkkJCQnTNNdfommuu0SuvvGKa9VQdCQkJpa773HPP6fHHHy/VNyIiQjNnzlT//v01cuRIxcfHO3WtV155Rb/88ou93bt3by1ZskSNGzcu1ddqtapfv35asWKFHnzwQfsMuCNHjmjGjBl68803nbp2RQzD0MSJE03PR9euXbVq1So1bNjQ1NfDw0NXXHGFBg0apKuvvtoexEnSHXfcoYMHD8rPz6/GanNGjx49yjweEhKiIUOG1HI1AABXYM8uAAAAAADgdrILi7Q44YT+uWGPHo/9QzO3x+nx2D/0zw17tDjhhLILi+q6xHrBw8NDX3zxRZlBV3EvvfSSfH197e3ly5eXuw/X/v37Te2///3vDtcTGBioyMhIh/tX5J133lFubq69PXz48DKDruKuuuoqPf30005dJzs7Wy+//LK93aRJEy1durTMoKs4q9WqN954Q3369LEfmzt3rmkpwepasWKFdu7caW/7+/tryZIlpYKu4nx8fPTVV1+ZZqMdP35cn376aY3VBQBASYRdAAAAAADArSTl5OnpLX/o64QTOp1fYLrtdH6Bvk44oae3/KGknLw6qrD+uOGGG9SzZ89K+4WEhGjYsGH2dnZ2tvbt21dm35ycHFPby8urekVWgWEYpqUXJZVaWrE8//rXv0xBT2U+/vhjnTp1yt6ePn26QkNDHRrr4eGhRx991N7OzMzUsmXLHL52Zd5//31T+x//+IeioqIqHdegQQNNnz7ddOy9996rsboAACiJsAsAAAAAALiN7MIivbLzoJJz8yvsl5ybr1d2HlQOM7xcavTo0Q737datm6mdmJhYZr+mTZua2vPnz3e6rurat2+fTpw4YW/36NFDHTt2dGisj4+PbrnlFoevVXxPME9PT6fGStLll18uq/V/X/H9+uuvTo2vyJo1a0xtZ/YiGzNmjGnZwtjYWGVnZ9dYbQAAFEfYBQAAAAAA3MaKo8mVBl1nJefma/nRZBdXVL85MqvrrJLL8p05c6bMfkOHDjW1p0yZoieeeMIUPrnaxo0bTe1BgwY5Nd7R/oZhaN26dfZ227ZtFRwc7NS1AgIC1KhRI3t77969To0vT3x8vE6ePGlvR0dHV7pcZXHBwcGm10dRUZE2bdpUI7UBAFASYRcAAAAAAHALNsPQL8dTnRqz6niqbIbhoopQ2b5SxQUEBJjaJZcrPOuSSy4xBV6FhYWaOXOmmjVrpgEDBmj69On6+eeflZGRUbWiHXDo0CFTu1OnTk6N79y5s0P9Tp48aVrCcM+ePbJYLE7/JCf/L9Qtfr7qSEhIMLW7dOni9Dm6du1qah8+fLhaNQEAUB7Pui4AAAAAAADAEcezc0vt0VWZtPwCHc/OU7MAXxdVVb/5+lb9cTUqCCE//fRTjRgxQuvXr7cfs9lsWrt2rdauXSvpryX/evbsqeHDh+vWW29VTExMlWsp6fTp06Z28ZlTjnC0f2qqc+GtI8qbMeestLQ0UzssLMzpc5QcU/KcAADUFGZ2AQAAAAAAt5Bdxf23sgsLa7gSuFpYWJjWrFmjt99+W61bty6zT2FhodavX68nnnhCrVq10vjx403L7lVHZmamqe3v7+/U+JKz2MpTMlSrCTabrUbOU/IxcPQ+VTTGlbPxAAD1GzO7AAAAAACAW/D39KjiOL7+cEdeXl665557dM8992jz5s36+eeftWrVKv32229KT0839bXZbJo/f75++uknrVq1Su3atavWtUuGNNnZ2U6Nz8rKcqhfyRCtY8eOevPNN526Vkl+fn7VGn9WYGCgqe3ofapoTFBQULVqAgCgPPy2BwAAAAAA3EITf1819PZyainDEG8vNfH3cWFVqA09e/ZUz5499cgjj8hms2n79u368ccf9dlnn2n79u32fidOnNCNN96o7du3y2qt+oJGDRs2NLVTUlKcGu/o8oQll/kzDENDhgxx6lquEhISYmpXZcnFko9byXOeZbFYnD73Wc4GkQCA8xPLGAIAAAAAALdgtVg0uIlzeycNatJI1mp8kY5zj9Vq1UUXXaRHH31U27Zt06JFi0yzmXbt2qVly5ZV6xotW7Y0tXft2uXU+B07djjULyIiwlR7QkKCCgqc25fOVaKjo03t4qGio0qOKXnOs0ru/ZaTk+PwNZKTk52uCwBw/iHsAgAAAAAAbmNos3CF+3o71Dfc11vDmoW7uCLUtVGjRmnKlCmmY2vXrq3WOXv16mVqr1692qnxjvb38vJSv3797O3s7Gxt2LDBqWu5SkxMjC644AJ7OyEhQX/++afD4zMyMrR582Z729PTUz179iyzb3BwsKntzN5rmzZtcrivZJ5FZhiGU2MBAOcuwi4AAAAAAOA2/D099HDnVpUGXuG+3nq4cyv5VXGfL7iX4oGR5PyygyV16NDBFPTExsZqz549Do3Ny8vTggULHL7WlVdeaWr/5z//cXisqw0cONDU/vDDDx0eu2DBAtMMrZ49e5bao+yskjO+tm7d6tA1UlJStHLlSodrksz7sbEEIgCcPwi7AAAAAACAW2ns56NnurfT9dERCvH2Mt0W4u2l66MjNKN7OzX2Y6+u+sLRvaEcZbFYNHHiRNOxRx55xKGxr776qlMzk+68807THmFffvmlvv/+e4fHu9Kdd95par/22ms6cuRIpePS09M1ffp007G77rqr3P7du3c3tT///HOH6psxY4ZTSx5KUmhoqP3f8fHxTo0FAJy7CLsAAAAAAIDb8ff00MjoCM3q3VEze7TX411ba2aP9prVu6NGRkcwo8uN3Xvvvfr2228dXmIuLy9P//73v03HevToUe067r77bvn4/C8w/e677/T8889XOObHH3/UM88849R1GjRoYArSbDabxowZoyVLljh1ntjYWI0ePdqpMZUZMmSIunTpYm9nZWVp5MiROnPmTLlj8vPzddNNN+n48eP2Y02aNNHYsWMrvI6X1/+C688//7zSpSjff/99zZ4925G7YXLhhRfa/52SkqJVq1Y5fQ4AwLmHsAsAAAAAALgtq8WiZgG+atMgUM0CfGUtth8P3NO6det07bXXqkWLFvrXv/6lVatWKT09vVS/goIC/fjjj+rXr59p36aIiAgNHz682nXExMToySefNB17/PHHNXbsWO3bt890/OTJk3riiSc0YsQIFRQUKCYmxqlrTZ06VVdffbW9nZGRoeuuu06jRo3SypUrlZeXV2pMbm6uNm7cqOeff149evRQz549HZ4R5SiLxaJ58+aZgqgtW7aoW7duWrRokfLz8+3HbTabVqxYoZ49e2r58uWm88ydO1e+vr7lXicsLEzXX3+96VzDhw/Xhx9+aLqGJO3cuVPjxo3TXXfdJcMw1KpVK6fu07Bhw0zt66+/XtOmTdMXX3yh5cuX66effrL/OLNHGQCgbnnWdQEAAAAAAABASQkJCZo1a5ZmzZoli8WiZs2aqVGjRvLz81N6err+/PNP5ebmmsZ4eHjo/fffl5+fX43UMHXqVP36669atmyZ/diCBQu0YMECRUZGKiIiQmlpaTp06JCKiookSZ6enpo3b54GDx7s8HWsVqs+/fRTXXfddfaZRoZh6Ouvv9bXX38tHx8fRUdHKyQkRLm5uTp9+rSOHDliv6Yrde/eXW+99Zbuvvtu2Ww2SX8t/3fjjTcqKChIMTEx8vDwUEJCgtLS0kqNf+aZZ0rtS1aWl19+WUuXLlVmZqYk6cyZM7r99tt1//33q1WrVvLw8NCRI0eUlJRkH3PppZdq3LhxmjRpksP3Z8KECZo5c6Z96cvTp0/rpZdeKrPv008/XWo5RgDAuYmZXQAAAAAAADinGYahI0eOaPv27Vq/fr327NlTKugKCQnRokWLdM0119TYdb28vPT111/rqquuKnVbYmKiNm3apLi4OHvo5O3trU8++USDBg1y+loNGjTQihUr9M9//lOenua/T8/Ly9P+/fu1YcMGbd++XQkJCWUGXZGRkU5f1xF33XWXFixYoKCgINPxjIwM7dy5U9u2bSsVdPn4+Gj27Nl66qmnHLpGdHS0vvzyS/n7+5uOZ2Zmavv27dqyZYsp6Lrsssu0ZMkS06wzR4SGhmrRokVq3LixU+MAAOc2wi4AAAAAAACcM7799lvNnj1b11xzjRo2bFhp/6ZNm+rhhx/W/v37NXLkyBqvx8/PT0uXLtX777+vli1blttv6NCh2rRpk2655ZYqX8vT01OzZs3SH3/8oUmTJjkUyMTExGjSpElavny54uPjq3ztytx8882Ki4vTvffeq9DQ0HL7BQUFacKECdq3b5/uvfdep65xxRVXaOPGjbryyitlKWdJ0oiICL3xxhtavny5GjRo4NT5z7r00ku1b98+zZ49WyNGjFCLFi0UFBQkq5WvSgHAXVkMwyi96DGAMu3cudPapUuXgLPtXbt2mTY2BQAAAIBzQWFhoQ4cOGA61qZNm1KzRYBznWEY2r9/vw4cOKDDhw8rPT1dRUVFCgoKUkREhLp06aK2bdvWakixadMm7dq1SydOnJCnp6eioqLUv39/NWvWrMavZRiGdu/erd27dyslJUWnT5+Wj4+PGjRooBYtWqhjx45q2rRpjV+3MkVFRdq4caMOHDigpKQk2Ww2hYeHq2XLlrrkkkucnm1VlpMnT2r16tU6duyYsrKyFBoaqi5duqhPnz7y8PCogXsBAPWXq35X3L17tzp16mRv79ixI6tz5862ap3UQfyWCwAAAAAAgHOSxWJRu3bt1K5du7ouxa5Xr17q1atXrVzLYrGoU6dOpi8OzwUeHh7q27ev+vbt67JrXHDBBbr55ptddn4AwPmFubkAAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW4RdAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAABwuZiYGFksFlksFsXExNR1OQAA4DxC2AUAAAAAAAAAAAC3RdgFAAAAAAAAAAAAt0XYBQAAAAAAAAAAALdF2AUAAAAAAAAAAAC3RdgFAAAAAAAAAAAAt0XYBQAAAAAAAAAAALdF2AUAAAAAAAAAAAC3RdgFAAAAAAAAAAAAt+VZ1wUAAAAAAADg3FVYWKj169dr165dOnXqlIKDgxUZGalBgwapQYMGNXadpKQk/frrrzp06JAKCgoUFhamjh07qk+fPvLw8Kj2+YuKirR582bFxcUpKSlJeXl5Cg8PV4sWLdSvXz/5+PjUwL34H1ffn8OHD2vjxo06efKkzpw5o9DQUEVERKhfv34KDw+vgXtgtmvXLu3evVtHjhxRUVGRYmJiNGjQIDVu3LjCcWdfPzt37lRaWpqCg4PVunVrDRo0SL6+vtWuKz8/X+vXr1d8fLySk5Nls9kUHh6uNm3a1NhjXdzhw4f122+/6fDhwzIMQ+Hh4erWrZsuuugiWSyWKp83NzdXe/bs0d69e5WcnKysrCwFBQWpUaNG6ty5szp16iSrlXkLAFAewi4AAAAAAIB6bNWqVRo8eLC9/fTTT2v69OkqKCjQa6+9plmzZik5ObnUOB8fH11//fV69dVX1axZsypff//+/Zo2bZoWL14sm81W6vZGjRrpscce0/333y8vLy+nzx8fH69nn31W33zzjU6dOlVmH39/f40aNUozZsxQixYtHDpvTEyMEhISJEnR0dGKj493+f2x2Wz68MMP9frrr2vXrl1l9rFarbr44ov12GOPacSIEQ6dNz4+3nS/b7vtNn344YeSpPnz52vWrFnatm1bqXFeXl6aMGGCXnnlFYWEhJhuKygo0KxZs/Taa6+V+foJCgrS448/rilTpsjT0/mvKHft2qUZM2bohx9+UGZmZpl9GjZsqHHjxunJJ5+sNJQ7q3hgNXDgQK1atUqStGnTJk2bNk0rV64sc1xkZKRmzJihiRMnOnwfjhw5ooULF+r777/X77//rry8vHL7hoSE6Pbbb9eUKVPUtGlTh68BAPUFfw4AAAAAAAAAk9OnT2vw4MGaNm1amUGFJOXl5WnhwoXq2LGjfvjhhypd58svv1S3bt309ddflxkMSVJqaqqmTJmi66+/Xrm5uU6d/7nnnlO7du00d+7ccoMuScrOztb8+fPVvn17ffDBB05dozhX3p+jR4+qV69euuOOO8oNuqS/ArH169fr2muv1dVXX62MjAyn74f010y4CRMmaPz48WUGXdJfgdYHH3ygfv36mV4nKSkp6t+/vx599NFyXz8ZGRmaNm2axowZo6KiIofrKiws1P3336+uXbvqiy++KDfokv56Hc+ePVutW7fW999/7/A1Svr3v/+tvn37lht0SVJiYqJuv/12TZo0qdznvrgdO3YoKipKDz/8sFatWlVh0CVJaWlpeu2116r1fgOA8xlhFwAAAAAAAOxsNptuuukmrVu3zn6sUaNGuuiii9ShQ4dSS8+lp6dr1KhR+uWXX5y6zvfff69bbrlFOTk5kv6aJdS2bVtdfPHFiomJKbP/1KlTHTp3UVGRJk6cqCeffFL5+fmm2xo1aqQuXbqoZ8+epWak5efn684779Trr7/u1H1x9f05dOiQLrnkEm3ZssV03Gq1qmXLlurZs6eio6NLjfvhhx80ePBgpaWlOX1/HnjgAX3yySf2dnh4uLp3767OnTuXWvJx7969uvXWWyVJOTk5GjZsmDZu3Gi/PSoqSr169VK7du1KLfX35Zdf6sUXX3SopuzsbA0fPlyzZ88uFShFRESoW7du6t69e6lZXBkZGRo5cqS++OILh65T3DvvvKMHH3zQHsj5+fmpQ4cO6tWrV5kzrObMmaM33nij0vPm5+fLMAzTMW9vb7Vq1UoXXXSRLr74YrVp06bUrLczZ85o+PDhTr/fAOB8R9gFAAAAAAAAu48//lg//fSTJKl79+765ZdflJycrC1btmjPnj1KTk7Wu+++q4YNG9rH5ObmauzYsTp9+rRD1zhz5ozGjx+voqIiNW/eXHPnzlVqaqr++OMPbdiwQYcOHdL+/ft1zTXXmMa99dZb2r17d6XnnzFjhj766CN728vLSw8++KB2796tlJQUbd++XZs2bdKRI0cUFxenyZMnm0KYqVOn6rfffnPovrj6/hQWFmrMmDE6fPiw/Zinp6emTZumxMREHTx4UJs2bVJ8fLzi4uJ05513msbHxsbqnnvucfi+SNLq1av19ttvS5I9uEpKSlJsbKx27NihlJQUPfPMM6bHbMWKFfr+++/1j3/8Q1u3bpXVatW9996rQ4cOKSEhQRs3btS+fft0+PBhjRo1ynS9mTNnKikpqdK67rnnHi1btszeDgwM1JNPPqk///xTx48f19atWxUbG6uTJ09q27ZtuvHGG+19i4qKdMcddyguLs7hxyEuLk4PPvigJKlDhw5atGiRTp06pT179mjjxo06evSoYmNj1bdvX9O4J598UqmpqQ5dY+DAgfZlKbOyshQXF6ctW7Zow4YN2r9/vzIyMvTNN9/o4osvto+x2WwaN25chbPaAKC+IewCAAAAAACA3dl9qK6++mqtX79egwYNMoUagYGBmjRpkjZu3GiaQXPixAk9/vjjDl3j9OnTSktLU/fu3bVlyxbdfvvtCgoKMvVp06aNFi9erCuvvNJ+zGaz6f3336/w3L/99puee+45ezssLEy//fab3njjDXXs2LFU/1atWumdd97RggULZLX+9VVZYWGhUwGRK+/Pm2++qQ0bNtjb3t7e+vbbb/XCCy+UmlnUqlUrzZkzR++9957p+GeffaZvvvnG4ftzdv+x+++/Xz/++KN69epluj0wMFBPPfWUpk+fbjo+ZcoUvffee/Lw8NBnn32m2bNnl5rV1rx5c33++ee67LLL7MdycnL06aefVljTZ599po8//tjebtWqlbZt21buPmtnlzl8+eWX7ccyMjI0ZcqUCq9T3NGjR5Wfn68rrrhCmzdv1qhRo0rNbOzevbt++uknde3a1X7s7LKYFYmKitKuXbu0atUqPfTQQ7rwwgvL3LvM19dXI0eO1O+//24KMo8dO2aaeQcA9R1hFwAAAAAAcFuGzaaik0kqjD+sopNJMhzYKweVa9KkiRYuXCgvL69y+7Rp08YUPkjSvHnzdObMGYeuERwcrK+++krh4eHl9vHw8Ci1pGBl+xXNmDHDvsSd1WrV4sWL1bNnz0rrGT16tCkI2bFjh32GmyNccX+Kior05ptvmo49//zzpsCsLHfddZfuvvtu07FZs2ZVOKakvn376o033ii17GBxU6dONc3w++OPP2QYhh555BHTrKqSPDw8TIGkVPHjYBiGKVjz9/fXsmXL1KpVq0rvx8MPP6ybbrrJ3v7222+1f//+SsedFRUVpc8++0z+/v7l9vH39y+1FGNlr9PGjRvrwgsvdLgOq9Wqt956y3Sf582b5/B4ADjfEXYBAAAAAAC3Y+TmKu+nVcp88XVlvf62st+Zq6zX31bmi68r76dVMnJz67pEt/bEE0+UmplUliuuuKLUDJ0FCxY4dI277767zH2mSmrfvr26dOlibx84cKDc5dv27t1rWuZu9OjRuuSSSxyqR5IeeeQR0+yaRYsWOTzWFfdn2bJlSkxMtLejo6Pty+pVZubMmaaAZu3atdq7d69DYyXpmWeesc90K4+vr6+GDRtmOhYQEODQXmR9+/Y1zQzcunVruX2XLVumffv22dsPPvigQ0HXWU888YT934Zh6Ouvv3Z47LRp09SgQYNK+w0dOlQhISH2dsn91WqCt7e3KbjbunWrfY84AKjvCLsAAAAAAIBbsaWeUua/3/0r1ErPMN1mpGf8FYL9+13ZUk/VUYXuzcvLS7fccovD/W+77TZTe9WqVQ6NGz16tMPX6Natm/3fNptNR48eLbNfydk048ePd/gaktSoUSP16NHD3v71118dHuuK+7N69WpTe8KECWUudVeW0NBQXXfddaZja9ascWhsw4YNNWTIEIf6durUydQeOnSoQ+FQybHJycnKLSekXrp0qant7PPapUsXRURE2NuOPq8Wi0U333yzQ309PDzUuXNnezs5OVl5eXlO1emI4ks2FhYWateuXTV+DQBwR4RdAAAAAADAbRi5ucr64BMZp9Iq7ncq7a9+zPByWpcuXRQaGupw/0GDBpnaGzdurHSMl5eXaY+jyhSfASSp3KUSS4YYjixfWFJUVJT93/v27ZNhGJWOcdX9Kb5XlyTTLDpHXH755ab2+vXrHRrXvXv3CpcvLK5Ro0alxjqq5Nj09PQy+xV/XgMCAtS+fXuHr3FWZGSk/d+OznCLiYkpVWNFHH1eS8rOztbChQs1efJk9enTR02bNlVQUJCsVqssFovpZ/LkyaaxKSkpDtcHAOczx/4UBAAAAAAA4ByQv3Z9pUHXWcapNOWv2yCfywe6uKrzS8mZOpWJiopScHCwPahISEiQYRgVhiWhoaHy8PBw+BoBAQGmdnlLt5UMMUqGD84qKipSenp6pTOVXHV/EhISTO3iyx86omQAd/jwYYfGVbTvWEkl97KqzlhHntesrKxKl1eszKlTjs36dPb14+jzelZBQYFee+01zZw5UxkZGRX2Lc/p06erNA4AzjfM7AIAAAAAAG7BsNmUvzHWqTH5GzbLsNlcVNH5yZmZLGcVnwlms9nKnaFzlq+vr9PXKK682VapqanVOm9ZHJmd46r7k5b2v2DXarU6NeNOksLCwso9X0Wqc3+qM7asxyErK6vGlwN0dMaVq55X6a8g7Morr9S0adOqHHRJcslSiQDgjpjZBQAAAAAA3IItOaXUHl2VMdIzZEtOkccF1ZvhU5+UnG3jiJIzWjIzMx3et6kmuWKWi60Ow9LMzEz7v2viealOqFJXXPGcOrI0pav9/e9/18qVK03HwsPDNWjQIHXt2lWRkZEKDg6Wn5+fadbg8uXL9corr9R2uQBwziPsQp3JycnR2rVrPfbu3WtNS0uzeHt7KzIy0tanT5+i1q1b1/1vHQAAAACAc4qRU7X9t6o6rr7Kzs52ekxWVpapHRgYWFPlOMXf3980q+yHH36Qp2f1vv6KiIiobllVFhgYaJ+FVBPPS1BQUI3UVZtKhnyhoaH67LPP6qiamrFt2zZ99NFH9raXl5defvll/f3vf5e3t3eFYw8ePOjq8gDALRF2wS4xMdGyYcMGj/Xr13ts3rzZY8uWLR7F/+InKirKSEhIyKzgFA45efKkZfr06T6ffPKJV8lfus666KKLbE888UTeqFGjCqt7PQAAAADA+cHiV7Ulxao6rr5KSUlxekzxPZCsVquCg4NrsiSHhYWFmcKu7t27V3vfrroUEhJiD7tsNpvS0tIUEhLi8PiSz6UzY88VDRs2lKenpwoL//qKKCcnR0OGDKnjqqrn888/N80ue+aZZ/TQQw85NNbR/cYAoL5hz656bs2aNR4jR470a9q0aWBUVFTgTTfd5Ddr1izv1atXe7hiavvPP//sceGFFwa888475QZdkrR161brDTfc4Ddu3Dhf1h4GAAAAAEiSNTxMlmDnZqZYgoNkDQ+rvCPsdu3a5VT/hIQEU8AUHR0ti8VS02U5pEWLFqZ2XFxcndRRU6Kjo03t7du3OzW+ZP+S53MHFovFVHdOTo6OHTtWhxVV3/r16+3/tlqtuvvuux0eu3v3bleUBABuj7Crntu4caPHkiVLPI8fP+7y30JXr17tMWLECP/U1FTTtRo2bKiuXbvaoqOjjeJrEEvSf//7X6/Ro0f71eX62AAAAACAc4PFapX3xT2cGuPdu6csVr7+cMbOnTudmj2yevVqU/viiy+u6ZIcNnjwYFO75J5I7qZPnz6mtrP3p2T/kudzF+fb83ry5En7v8PDwx2ecWez2Uq93wAAf+G3PZSrJtfXPnXqlMaMGeOXk5NjPxYVFWUsWrQoJzU1NWPbtm1Z8fHxmX/++WfmnXfeWVB87OLFiz1fffXVihcsBgAAAADUC979+8gS6tgXw5bQEHn36+3iis4/BQUFWrhwocP9i+89JEkDBw6s6ZIcduWVV5ra7733ngoKCsrpfe4r+VjOnz/fvpxfZdLS0vT111+bjl166aU1VlttKvm8zp49u44qqRnFlzDMz893eNySJUt05MgRV5QEAG6PsAuS/tqg9NJLLy36xz/+kb9w4cKcP//8M/Obb75xfufTcrz44os+xWePxcTEGOvWrcsaNWpUobXYX9hFRUUZc+bMyX3mmWdMaxc+//zzPqxJDAAAAACw+Poq4I7xlQZeltCQv/r5sl9XVTz33HNyZHuDZcuWmWbZ+Pn5acyYMa4srUI9evQwzQJKTEzUE088UWf1VNewYcMUFRVlbx86dMjhoOfJJ59Udvb/vtoZMGCA2rdvX+M11obrrrtOrVu3trc3bNig//u//6vDiqonIiLC/u+0tDTt2bOn0jGZmZmaMmWKK8sCALdG2FXPjRw5smDnzp1ZaWlpGatXr85+7bXX8kaPHl3YokULo/LRjjl58qTl//7v/0wzs959992c5s2bl3uNJ554Ir9///5FZ9tnzpzRSy+95FNTNQEAAAAA3Je1UagCH5gsn6GDS+3hZQkOks/QwQp8YLKsjULrqEL3d/z4cd1yyy0VzoqKi4vThAkTTMduu+02NWzY0MXVVezZZ59V8T+sffnllzVjxgzTbJrKHDlyRA8//LA2bdrkihId5uHhoQcffNB0bNq0afr5558rHDd37ly9/fbbpmPuHJR4eHjo2WefNR178MEHNWfOHKfOs3//fk2aNElHjx6tyfKcdskll5jaU6dOVUVbeGRnZ2vUqFH6888/XV0aALgtwq56rk2bNkanTp1sJffKqkmffvqpZ2Zmpr3dv3//omHDhhVVMERWq1VPPfWUaXbXRx995MXeXQAAAAAA6a8ZXj6XD1TgtH8o4B9/l//df1PAP/6uwGn/kM/lA5nRVQ3R0dGSpKVLl6pv375avXq1KSjKysrSnDlzdPHFFyspKcl+/IILLtDzzz9f6/WW1K9fP82cOdN07Omnn1avXr20cOFCpaWllRpTVFSkvXv36r333tMVV1yhFi1a6NVXX1VWVlZtlV2uBx98UL17/285zry8PF111VV6/PHHdfz4cVPfP//8U5MnT9add95pes5Gjx6tkSNH1lrNrnDLLbdo8uTJ9nZBQYEmTZqkyy+/XN99912Zz1VBQYG2b9+uN954wz6zbc6cOXW+tOW4ceNMgez333+vESNGlJrhlZubqy+//FJdu3bVihUrJEkdOnSo1VoBwF141nUBOP8tWbLEq3j7b3/7m0O/UVx++eVFMTExRnx8vEX6a4bYb7/95lF8xhcAAAAAoH6zWK3yuKBxXZdxXpkwYYLWr1+vFStWKDY2VoMGDVKjRo0UHR2t3NxcHTp0SMX35JYkHx8fzZ8/XyEhju2n5mrTpk1TUlKSXn/9dfux2NhYjRkzRlarVVFRUWrUqJEk6fTp0zp+/Lhpyb9ziYeHhz799FMNHjxYhw8flvRXiPP888/rxRdfVIsWLRQaGqrk5GTFx8eXGt+9e3e3XvKvuP/85z9KS0vT559/bj+2cuVKrVy5Up6enoqOjlZoaKgKCwt1+vRpHT161Kk9sWpL+/btdffdd5tm3y1dulRLly5VZGSkmjRposzMTMXHx5tel5deeqnGjx+vu+66qy7KBoBzGjO74FIZGRlat26dadrYFVdc4dBOqlarVZdddpmp77fffktACwAAAACAC1mtVn3xxRfq37+//Vhqaqq2bNmiPXv2lAq6goKC9OWXX2rIkCG1XWqFXnvtNX300UelllW02WyKj49XbGysYmNjdfDgwTKDrqCgoDpfkvGsli1bat26derevbvpuM1m08GDB7Vp06Yyg66rrrpKq1atOmdCyOry8vLSZ599ppdeekl+fn6m2woLC+2PxdatW3Xo0KEyg66wsLBSY+vC66+/ruHDh5c6npiYqI0bN2rPnj2m1+XgwYO1ePFieXry1RgAlIWwCy61c+dOj+JTw2NiYoymTZs6vEh2v379TLO4tm/fzmsWAAAAAAAXa9CggVauXKkXXnhBYWFhZfbx9vbWzTffrD179pT5pf25YMKECYqPj9ezzz6rtm3bVto/JCREN954oz7++GOdOHFC3bp1c32RDmrevLk2bdqk999/XxdeeGG5/SwWi3r37q3Fixdr6dKlCgoKKrevu5o6daoOHTqkf/3rX4qKiqq0f0REhMaNG6evvvpKx44d0wUXXFALVVbM29tbixcv1uuvv66IiIhy+8XExGj27Nn66aefzpnwFQDORRbDMNLrugicm37++WePIUOG+J9tR0VFGQkJCZkVjSnp/fff97rrrrvsC6VfeeWVhT/88ENORWOKW79+vbVv374BZ9sxMTHGoUOHnKqhJu3cudPapUsXez27du2q8BdMAAAAAKgLhYWFOnDggOlYmzZtmBGAMq1atUqDBw+2t59++mlNnz7d3i4sLNTvv/+unTt3Ki0tTcHBwWrevLkGDx7sdl++Hz16VJs2bVJSUpJSU1NltVoVHBysZs2aqUOHDmrVqpVpL6Vz2eHDh7VhwwadPHlS6enpCgkJUZMmTXTJJZeoceP6tbRnXFyctm3bpuTkZKWlpcnT01MNGjRQVFSUOnTooJiYmLousUKFhYXatGmTduzYodTUVHl4eCgiIkLdunVT165d67o8AOchV/2uuHv3bnXq1Mne3rFjR1bnzp1t1Tqpg/gtFy71xx9/mH5DjIyMdHhWl/RXwFa8ffjwYUtOTs45Md0cAAAAAID6wNPTUwMGDNCAAQPqupRqa9asmZo1a1bXZdSIqKgoh2Y11QetW7dW69at67qMKvP09FTfvn3Vt2/fui4FANyWe/ypCtxWcnKypXi7WbNmTqW4ERERRvE02WazKSUlxVLBEAAAAAAAAAAAUI8wswsulZmZaQqmAgICyutaJqvVKj8/P2VkZJQ8p1MzxMpy4sQJS8kwrjIHDhwgIAYAAAAAAAAA4BxC2AWXysw0b6/l6+vrdEjl6+trZGRk2EOp4sFXdcyePdt75syZ3jVyMgAAAAAAAAAAUCeYpQKXysvLM82c8vZ2Plvy8fExtXNycljGEAAAAAAAAAAASCLsgov5+PiYZnLl5+c7fY68vDxTuyqzwwAAAAAAAAAAwPmJZQzhUoGBgaZ2bm6u07OySo4JCgqqZlV/ue+++/JHjx5d4MyYAwcOWG+44Qa/GikAAAAAAAAAAABUG2EXXCowMNA0CysrK8up8TabTTk5ORWes6oiIiKMiIgIZokBAAAAAAAAAODGCLvgUuHh4aYw6ejRo04tnXnixAlLYWGhvW21WkudEwAAAAAAVN2gQYNkGPyvNgAAcF/s2QWXateuna14+/Dhw04tY5iQkGDqHxUVZfj5sYogAAAAAAAAAAD4C2EXXKpDhw6msGvfvn0ezozfu3evqX/btm2LaqIuAAAAAAAAAABwfiDsgkt17ty5yMvLy95OSEiwHD161OHZXevWrTOFXV27drWV1xcAAAAAAAAAANQ/hF1wqeDgYPXr1880G2v58uUO7RVns9m0cuVKU99rr722sLz+AAAAAAAAAACg/iHsgsuNGDHCFFDNnTvXq7y+xf38888e8fHx9llgjRs3Nvr27csyhgAAAAAAAAAAwI6wCy43duzYgoCAAHt77dq1HitWrKhw7y6bzaYZM2b4FD82YcKEAg8Pp7b8AgAAAAAAAAAA5znCLrhcRESEcffdd+cXPzZp0iS/I0eOlLt313PPPee9du1ae7LVoEEDTZs2Lc+VdQIAAAAAAAAAAPfj0N5JOL+tWbPGIycnp9Txbdu2maZR5ebmatmyZWVOrWrWrJnRqVMnW3nXePTRR/Pmz5/vdfLkSYskxcfHW/r16xfwxhtv5I4cObLQav0rdz18+LDl2Wef9Xn//fdNSx0+8sgjeY0aNXL+zgEAAAAAAAAAgPMaYRc0fvx4v8OHD5c7y+qspKQky5VXXulf1m3jxo0r+OSTT3LLG9uoUSMtWLAg5+qrr/bPzf2r2+HDhy2jRo3ya9iwoaKjo21nzpyxJCYmWoqKzNtyDR8+vPCRRx7JL+u8AAAAAAAAAACgfmMZQ9SawYMHFy1ZsiQ7JCTEKH789OnT2r59uzU+Pr5U0DV69OjCL774IufszC8AAAAAAAAAAIDiSBBQq4YOHVq0e/furEmTJhX4+5c5SUyS1LVrV9vnn3+es3DhwhxfX99arBAAAAAAAAAAALgTljGEEhISMmvzek2aNDHefffd3Ndffz137dq1Hnv27LGePn3a4u3trebNm9v69OlT1LZtW6PyMwEAAAAAAAAAgPqOsAt1xt/fX8OGDSsaNmxYUeW9AQAAAAAAAAAASmMZQwAAAAAAAAAAALgtwi4AAAAAAAAAAAC4LcIuAAAAAAAAAAAAuC3CLgAAAAAAAAAAALgtwi4AAAAAAAAAAAC4LcIuAAAAAAAAAAAAuC3CLgAAAAAAAAAAALgtwi4AAAAAAADUqA8//FAWi8X+8+GHH9Z1SW6j+OM2aNCgui4HANxKfHy86XN04sSJdV0SaglhFwAAAAAAAAAAANwWYRcAAAAAAAAAAADcFmEXAAAAAAAA4IamT59uWq5r1apVdV0SAFQLn2uoKsIuAAAAAAAAAAAAuC3Pui4AAAAAAAAA55eJEydq4sSJdV0GAKCeiYmJkWEYdV0G6gAzuwAAAAAAAAAAAOC2CLsAAAAAAAAAAADgtgi7AAAAAAAAAAAA4LbYswsAAAAAAACSpIyMDG3dulV//PGHTp8+rby8PPn7+yskJEQxMTHq2LGjLrjgglqv6+DBg9q6dauOHj2qnJwcNW/eXJdeeqmioqIqHGcYhjZv3qxt27YpOTlZAQEBiomJ0WWXXaagoKBaqt69HDp0SLt379bhw4d15swZeXp6KjQ0VNHR0erTp48CAwNr/JpnzpzRmjVrFBcXp5ycHDVq1EitW7dW//795ePjU+3zG4ahHTt2aO/evUpKSlJWVpbCwsLUvHlzDRgwoMbu07Zt27Rnzx4lJSUpNzdXjRs3VmRkpPr37y8/P78auYarFRQUaOfOndq1a5dSU1OVlZUlHx8fBQUFKTo6Wm3btlWrVq1qva7Tp0/r999/1/Hjx5WSkiKbzaaGDRuqVatW6tq1qxo3blyl82ZnZ2vt2rVKTExUcnKyfH191bhxY1144YXq2rVrDd8LKTMzU+vWrdOxY8d04sQJ+fr6auDAgerevbvD59i8ebPi4uJ0/Phx5ebmKjo6WmPHjq103OHDh7V582adPHlSaWlpatCggSIiItSvXz9FRERU527ZnX2v7du3T8nJyTpz5oz8/f0VERGhDh06qHPnzvLw8KiRa7labb6fbTabNm7cqO3btys1NVUBAQFq0qSJLr300hp7buoFwzDS+eGHH8d+duzYkSnJOPuza9cuAwAAAADONQUFBcaePXtMPwUFBXVdFs5hsbGxxvXXX294e3sbxf+/t6yfFi1aGPfdd5+xe/fucs83b94805h58+ZVeP3ifQcOHGg/vnTpUqN///5l1mGxWIzrr7/eSExMLHU+m81mvPvuu0Z0dHSZY318fIx//etfRlZWlkOPz8CBA03jnVFTj8VZv/zyS6XPUXk/ZcnJyTG+/PJLY+zYsUZERESF4z08PIxhw4YZv/zyi1OPQXmP37Fjx4zbb7+93NddQECA8fjjjxuZmZlOXe+spKQk4x//+IfRpEmTcu+Tt7e3ce211xrbt2+v0jXS09ONxx9/3GjatGm51/D19TWuu+46Y+fOnQ6f97bbbjOd49ChQw6PLfkaefrppysdc/z4cePee+81QkJCKn0dhYWFGTfffLPx448/OlxTVRQVFRmffvqp0adPH8PDw6PceiwWi9G9e3dj1qxZxqlTpxw697Zt24yRI0cavr6+5Z63WbNmxpNPPmlkZGQ4XHN5r/Xdu3cbY8aMMfz9/Utd58EHH7T3K+/zIjs725gxY4bRokWLUuMbNGhQbj15eXnGG2+8YXTs2LHCx69nz57G4sWLHb6fJSUkJBiTJ082GjduXOFrJyQkxLj11luNNWvWmMbX5OfaoUOHTLffdtttDt8PV72fy3tei4qKjNmzZxvNmzcv97m54oornLqWo1z1u+KuXbtM92HHjh2ZRi19d88yhgAAAAAAAPXYiy++qF69eunrr79Wfn5+pf0PHTqk2bNn69NPP3VpXY899piuvvpqrV27tszbDcPQ119/rYsvvlj79++3H8/JydGIESM0efJkJSQklDk2Ly9Pr776qq644gplZWW5pH530b9/f91444369NNPdeLEiQr7FhUVafny5Ro8eLDuu+8+FRYWVvm6v/76qzp16qR58+aV+7rLysrSzJkzNXjwYJ06dcqp83/wwQdq1aqVXn/9dR0/frzcfvn5+VqyZIkuuugizZgxw6lrrF69Wq1bt9bMmTN17Nixcvvl5ubqm2++Ubdu3fT44487dY3asGLFCrVv315vvfWW0tLSKu2fkpKizz//XM8++6zLatq3b5+6deumsWPHav369SoqKiq3r2EY2rJli6ZMmaI333yzwvMahqFHHnlE3bt31+LFi5Wbm1tu36NHj+rZZ59VmzZtyv0ccsR///tfXXTRRVqwYIGys7OdHp+QkKCePXvqqaee0qFDhxwet2HDBrVv314PPfSQ9uzZU24/4//PgB05cqSuvfZapz4TDcPQM888ozZt2ujdd99VUlJShf3T0tL03//+V5deeqnD16gttf1+Tk9P17Bhw3TffffpyJEjZfYxDEPLli1T7969tWzZsipfq75gGUMAAAAAAIB66oMPPtCjjz5a6nhQUJBiYmIUEBCgnJwcnTp1SkeOHJFhGLVS1yuvvKIXXnjB3m7YsKGio6MlSXFxcaYvY48fP67rr79e27Ztk4eHh2688UYtXbrUfnuTJk3UtGlT5ebm6o8//jAFNGvXrtVDDz2kOXPm1MK9OjeV9WV/06ZNFRoaqsDAQGVlZdmXNCzurbfeUnZ2tubOnev0NWNjY3XVVVfZn0er1aoWLVqoUaNGSktLU1xcnOm1tmnTJk2cOFFLlixx6PxPPvmknnvuuVLHg4ODFRkZqYCAACUlJSk+Pt5+m81m09NPP63U1NRKAxNJ+v7773XjjTeWevx8fX0VExMjf39/+9J4ZxUVFen555/XiRMn9MEHHzh0X1xt9+7dGjFihPLy8kzHfXx8FBMTowYNGqioqEhnzpxRQkKCCgoKXF7TL7/8olGjRun06dOlbgsPD1eTJk3k7e2tU6dOKT4+XjabzaHzGoahiRMn6uOPPy51W1hYmKKiopSTk6NDhw6ZntcTJ05o2LBh+vrrr3XFFVc4dV+WLl2qCRMm2Gs8+1oPDQ1VUlJSuSHHWWcDkeKBfuPGjdWsWTPl5eWVG+h/++23Gj16tHJyckzHvb291aJFCzVo0EDp6emKi4szfSZ+++23uuyyy7R69Wr5+vpWWFtBQYHGjh2rL7/8stRt3t7eioyMVKNGjZSVlaWjR4+W+XyeK2r7/VxQUKDhw4fr119/tR9r3LixmjdvrsLCQh08eND037ns7GzdeOON2rVrl/2/hSiNmV0AAAAAAAD1UF5enqZOnWo6dsMNN2jz5s06c+aMduzYod9//13btm2zhx0///yzpkyZ4tJ9u+Li4ux/Ld+rVy/9/PPPSklJ0bZt27Rt2zalpqbq7bffNu3ltGfPHr333nt6+eWX7UHXmDFjtGvXLh07dkybN2/Wrl27dPLkSd1zzz2m633wwQfasWOHy+5PTevatatWrFihFStWaPz48abbXn31VfttZf2UJyoqSlOmTNHPP/+sM2fO6OjRo9q5c6d+//137dixQ2lpadq+fbvuuece03478+bN09dff+30fbj55puVlZWl0NBQvfbaa0pKSlJcXJw2bNig/fv368iRI5o4caJpzLfffqsffvih0nPPmzfPFHRZLBZNmDBBmzZtUlpamnbt2qUNGzbo0KFDOnr0qB599FF5eXnZ+//73//W559/XuE1EhMTNW7cONMX440aNdKcOXOUnJysvXv3KjY2VklJSfrtt9/Uv39/0/i5c+fqnXfeqfS+1IapU6eagq5u3brpu+++U3p6uvbt26cNGzZo8+bNOnDggLKysrRlyxbNnDlTnTt3dkk98fHxuuGGG0zBiI+Pj6ZMmaLdu3crKSlJ27dv16ZNm3Tw4EGdOXNGy5cv16RJkyrde2327Nmlgq4BAwZo3bp1SkpKUmxsrPbs2aPk5GTNmTNHoaGh9n45OTkaO3ZshTN+yvK3v/1NNptNDRo00KxZs3Ty5EnFxcVp48aNio+P19GjRyvcb+v555+3B12jR4/W9u3bdfLkSW3ZskW7d+9WWlqaFixYYBqze/fuUkHXgAED9N133+nMmTP253Xv3r06deqU3nvvPdNn+saNG/WPf/yj0vs2derUUkFXt27dtGjRIp06dcr+nt61a5fS0tJ04MABvfHGG+rVq1epc7nic81RdfF+fvHFF+1B16233qodO3bo5MmTio2Nte/bNXfuXAUHB9vHZGZmlvpvNkqorfUS+eHnfPhhzy4AAAAA7oA9u+CI77//3rSvxoQJExwem5eXZxw8eLDc26uzT9XZn1GjRhn5+fnljvnoo49M/aOjow0/Pz9DkvH6669XeL2S+yEV3zOnLOfSnl3FPf3006b+zu6lZRiGsWbNGqOwsNDh/suXLzd8fHzs17z44osrHVPy8ZNkxMTEGHFxcRWOu+uuu0xjrrvuugr7Hzx40LQnkp+fn7F06dJK61u9erX9tSPJaNy4sZGTk1Nu/+HDh5vqioyMNOLj48vtX1RUZIwfP940xt/f3zh69Gi5Y2pjz67Tp08bnp6e9n7t27c3srOzHb7O3r17He7rqL59+5pqb9q0qbFjxw6Hxqamphpbt24t87bExETTc6z/v5eTzWYr93yHDh0ymjVrZhozcuTICmso67UeERHh8GNV8vPi7M8bb7zh0PiCggKjU6dOprHPPPNMhffTMAzjyJEjRps2bUzjtmzZUm7/H3/8sVSNDzzwgFFUVORQnT/99FO5t1X3c83ZPbtq4/1c1vNqsViMOXPmVFjbmjVrDKvVah/j5eVlJCUlVTjGUezZBQAAAAAAcA6x2QydTspU0uE0nU7KlM1WO8vsnQ+KL4slSX//+98dHuvt7a2WLVvWdEl2LVu21Mcff2yacVPShAkT1KFDB3s7ISHBPvvioYceqvD8M2fOlNX6v6/FHJkxdL4aMGCAabZWZYYOHaqHH37Y3t64cWOF+wGVxcPDQ1988YVatWpVYb+XXnrJtJTa8uXLK1yy7uWXXzbtiTR37lxdddVVldZz6aWX6tVXX7W3k5KSNH/+/DL7/vHHH/r+++/tbavVqi+//LLCpcWsVqvmzp1rmg2VnZ2t//u//6u0Nlc6dOiQaQm7iRMnys/Pz+Hx7du3r9F6li9frt9//93e9vHx0Y8//ujwLLLQ0FB169atzNvefvtt00ynrl276v3335fFYin3fDExMfriiy9MfZYsWaIDBw44VM9ZH374YbUeq1tuuUUPPvigQ32//PJL7dq1y96ePHmynnrqqQrvpyQ1a9ZMixYtMn0uzpo1q9z+zzzzjKk9duxYvfnmm6bxFbn88ssd6udqdfl+fuCBB3TnnXdW2GfAgAG66aab7O2CggL9/PPPTl2nPiHsAgAAAAAAbic/t0DbV8dp0RurteT/1unHeRu15P/WadEbq7V9dZzyc12/r4y7K7mXS0XBUm2bNm2aAgICKu03YsQIU9tisWj69OmVjmvWrJl69Ohhb8fFxSkzM9PpOuurcePGmdq//fabU+NvuOEG9ezZs9J+ISEhGjZsmL2dnZ2tffv2ldn31KlTpiXq+vbtq1tuucXhmu666y41btzY3l60aFGZ/T744APTfmJjxozRxRdfXOn5PT099corr5iOzZkzp9b2wSvLufYZ8MYbb5jaU6dOrZHlEg3DKLWn0quvvipPT89Kx/bt21ejR482nev99993+Nr9+/d3ep+vkp599lmH+xZ/DP39/U17H1amc+fOGjlypL29ePFiFRUVleq3ceNGUygZFBSkt956y+HrnEvq6v3s5+enJ5980qG+xV9/krRlyxaHxtVHhF0AAAAAAMCtZJzK1nfv/a7tqw4qJyPPdFtORp62rzqo7977XRmnsss5AySpadOmpnZ5M1lqm8Vi0Q033OBQ306dOpnaXbt2VZs2bRwaW/xLdJvNpiNHjjheZD3XokULU3vr1q1OjS/55W1FSs7USUxMLLPfqlWrTOFNyX1/KuPl5aXBgwfb27/99luZs8hWr15tav/tb39z+BpDhw5V8+bN7e2TJ0+WmmFZm0p+Bnz++ecqKKibPxQoKCjQqlWr7G1PT0+nZptWZN++fUpKSrK3o6KinJpZVPI5XrNmjcNjx4wZ43DfsvTq1UutW7d2qG9qaqo2btxobw8fPlwhISFOXa94uJyZmVnme3v58uWm9oQJE9SwYUOnrnOuqKv385AhQ9SoUSOH+jr6GQjCLgAAAAAA4Ebycwu0Yv5mZablVNgvMy1HK+ZvVn5eYYX96rPLLrvMtHzd66+/rr///e/6888/67Cqv4KU0NBQh/qW/LKwe/fuDl+n5Nj09HSHx56vNm7cqMcee0xXX321WrZsqdDQUHl5eclisZh+fHx8TONSUlKcuo4js7rOKj7bSpLOnDlTZr9ff/21ytc4Kyoqyv7v9PR0HT161HR7Xl6etm3bZm97eXmpf//+Dp/farWaAjVJWr9+vdN11pTo6GhTOLxhwwZdeeWVTs/UqwmbN282hZUXXXSRIiIiauTcGzZsMLUHDx5c6bJ+xV166aWmWWBbt25Vfn6+Q2MdmSVUU+PXrl1rmllU3feAJO3du7dUn5Lvtauvvtrp65wL6vL97IrPQBB2AQAAAAAAN7J3Q0KlQddZmWk52rc+wcUVua/IyMhSf8X+f//3f2rVqpV69uypadOmaenSpTp16lSt1hUeHu5wX39//xobW3JJt/rk119/VdeuXdW7d2+98MIL+uGHH3To0CGlpaWZ9nQqz+nTp526XskvbytScjnL8p6nkl/KX3zxxaVCusp+Si5LVvK1f+LECVPI0b59e3l7ezt8X6S/Zh8Wd/jwYafG17SSy36uXLlS/fr1U4sWLXT33XdrwYIFSkhw/efowYMHTe2qBDXlKVl/ly5dnBrv4+Nj2nMrLy9PJ0+edGhsyVmQznJmfMn3wNSpU51+D1xzzTWmc5T1+e/K56o21eX72RWfgSDsAgAAAAAAbsJmM7Q/1rml5vbHJspmq7s9cc51//73v0vteyVJsbGxeumll3TNNdcoLCxMF110kR577DHt3r3b5TX5+vrWydi63DupLr377rsaOHCgduzYUeVz5OXlVd6pGFc8T6mpqVU+Z3lKzqBIS0sztcPCwpw+Z8kxJc9Z28aOHatnn3221Eyn+Ph4vfvuuxo7dqxiYmIUExOjSZMmaeXKlS55r5QMVZwJAypTl89bcHCw09eq6vjaeA9I5ufKYrFU6fE8F9Tl64L/VrkGYRcAAAAAAHAL6SlZpfboqkx2Rp7SU7NcVJH78/X11eLFi/Xpp5+W2hfkLMMwtG3bNr3wwgvq1KmThg8frri4uNotFC7xyy+/6J577jF9eerp6alBgwbpkUce0dtvv60vv/xS3333nVasWGH6Odc4O7vMESX37MrMzDS1S864cETJMRkZGc4XVsOeeOIJ/f7777r66qtNS5sWl5CQoDlz5ujyyy9Xly5davw1UPJxCAwMrLFz1+Xz5uXl5fS1qjq+Nt4Dkvm++/v7y2p1z4jhfH0/12eelXcBAOD8ZrMZSk/JUn5ugbx9vRQcFiCr1fH1uwEAAFA78nMLqjYup2rj6guLxaIxY8ZozJgx2rNnj1asWKFVq1Zp7dq1Ze7F9P3332vNmjX6/vvvNWDAgDqoGDVlypQppqDrmmuu0TvvvKPmzZtXOM7ZmVy1oeSylPPmzav0flSm5BJlJQOYrCzng/SSY4KCgpwvzAV69+6t77//XsePH9fy5cu1atUqrVmzpsw9/Hbt2qUrrrhCs2bN0j/+8Y8auX7Jx6FkEFEd5/PzVlzJ98BDDz1UallCZ7Vs2bLUsaCgIPsMpuzsbNlsNrcMvOrL66I+IewCANRb+bkF2rshQftjj5j+QtgvyEdtezRXh97R8vat3l9hAQAAoOZU9Xczbz9+p3NUx44d1bFjRz344IMyDEP79u3T8uXL9eWXX2rt2rX2fhkZGbrxxht18ODBGp2Bca4qucSbM7Kzs2uwkpqzf/9+bd261d7u1KmTvvrqK4f2rKntfdwcUXI5sY4dO+riiy+u0WuEhISY2lVZNq5kgFzynGfV1WuuSZMmuu2223TbbbdJko4dO6aVK1fqm2++0ZIlS1RQ8NcfDxiGoSlTpqhv377q06dPla93VmhoqKmdlJRU7XOeVZvPW10q+R5o0qSJhgwZUuPXCQ0NtYddhmEoJSWlRpedrC315XVRn7hf5AoAQA3IOJWt7977XdtXHSy1FE5ORp62rzqo7977XRmnzs3/MQUAAKiPgsMC5Bfk49QY/yAfBTdyfmki/PVle4cOHfTggw/q119/1Zo1a0xfpiYlJemTTz6pwwprT8n9VXJychwem5ycXNPl1Ij169eb2nfeeadDQZekWtm7zVktWrQwtV2x1GaTJk1Mj9G+ffuUn5/v1Dm2b99uakdHR5fZ71x5zTVt2lTjxo3Tl19+qQMHDqhXr1722wzD0Ouvv14j12nTpo2pvXnz5ho5r1T6MS75HFQmLy9Pf/zxh73t4+OjCy64oEZqq0m18R6QXPtc1abafD+jdhB2AQDqnfzcAq2Yv1mZaRX/z0JmWo5WzN+s/LzCWqoMAAAAFbFaLWrbw7llydr2iGSJ6hoyYMAAvfjii6ZjxWd7nc+Cg4NN7ZMnTzo8dtOmTTVdjl3JpcOKL0lYmZL3oV27dg6PXblypcN9a8vgwYNNbVfU6O3trYsuusjezs/Pd+o9YBiGVq1aZTpW3qyoc/E1Fx0drU8//dR0rKY+A7p3725ahm/r1q06ceJEjZy75GO8atUqp94rv/76q31Gm/RXrY4Gw7WpNt4DkkotX7t06dIaPX91PtecUZvvZ9QOwi4AQL2zd0NCpUHXWZlpOdq3PsHFFQEAAMBRHXpHKzDEz6G+gSF+at+Hv7KuSf369TO1y9rT63xU8q/1iy//V5GUlBSXBkMBAeZZi84sX1fyC2RHZzTk5eVp7ty5Dl+ntgwZMkSenv/bsWXhwoVVWpasMgMHDjS1P/zwQ4fHrlixQomJifZ2kyZN1LZt2zL7VvU1V1BQoK+//trhmpzVunVr06ymmvoM8PLy0uWXX25vFxYW6u23366Rc7dr185Uc0JCgn755ReHx5d8vZd8DZwrmjVrpk6dOtnbBw8e1A8//FDj17nyyitN7U8++USnT5+usfNX53PNWbX1fkbtIOwCANQrNpuh/bFHnBqzPzZRNptr/pIIAAAAzvH29dLQcT0rDbwCQ/w0dFxPefuwXXlNqq/7k3Tv3t3U/vzzzx0aN2PGDKeWn3NWyX2ODh065PDYiIgIU9vRGQ1PPvmkU7OMassFF1yg8ePH29tZWVm69957a/w6d9xxh2k/rf/+97+KjY2tdFxRUZGmTp1qOnbnnXeW27+qr7n//Oc/OnbsmEN9qyI/P1/p6en2dk1+Bjz44IOm9ssvv6ydO3dW+7wWi0V33HGH6djDDz+soqKiSsdu3LhRCxcuNJ2rouetrj388MOm9kMPPaQzZ87U6DW6d++u/v3729vp6ek1+l6rzueas2rr/YzaQdgFAKhX0lOySu3RVZnsjDylp2a5qCIAAAA4KyjUX8Mn9VW3Qa3lX2IPL/8gH3Ub1FrDJ1+ioFD/cs4A6a/QYv78+SosdGzZbsMwNGvWLNOxHj16uKK0c86QIUPk5eVlb3/++eeVhkPvv/++Zs+e7dK6LrzwQlN70aJFDo+95JJLTO133nmn0j1+3n33Xb366quOF1jLnnjiCdNSeJ999pkmT57s1D48p06d0nPPPadvv/22zNvbtm2r4cOH29s2m0033HCDjhwp/48qDcPQnXfeadrfJyAgQHfffXe5Y3r06KHGjRvb2+vXry+1hGBJS5cu1WOPPVZhn+I+/fRTvfDCC0pLS3N4zFtvvWUKcGvyM+Dyyy83LZGXl5enK6+80uHA69SpU9q2bVuZt91zzz3y8/vfH0ls2bJFd999d4VL5B0+fFg33nijqc/IkSPVqlUrh+qpC7feeqvpc2H//v266qqrnApACwoK9NFHH+mll14qt8/TTz9tCok+/fRTPfTQQw4vOfjzzz+Xe1t1PtecVVvvZ9QOwi4AQL2Sn1tQeaeyxuVUbRwAAABcw9vXS10GttKohwbq2r/305W3X6xr/95Pox4aqC4DWzGjywE7d+7U+PHj1axZM91zzz368ccfy1z2zWazae3atRo2bJi++eYb+3F/f3+NHTu2FiuuO2FhYbr++uvtbZvNpuHDh+vDDz8sFaTs3LlT48aN01133SXDMFz6xfhFF12ksLAwe3vVqlW67LLL9M4772jp0qX66aefTD/FtW7dWn379rW3MzIydOmll+qLL74oFYBu375do0ePtocDHTp0cNl9qo6WLVvqgw8+MB1777331LlzZ82ZM6fMGWmGYejgwYP65JNPNGrUKDVv3lxPPvlkhUsgvv3222rYsKG9nZCQoIsuukhz585VVpb5DyXXr1+vQYMGlVoe7dVXX1XTpk3LvYaXl5cmTpxoOnb77bdr1qxZpa5x8OBBPfDAA7r22muVl5fn8GsuKSlJjz32mJo3b64bb7xRCxYsUEJC2cv479+/X/fdd5+mTJliOn7XXXc5dC1HzZ8/3zSz59ixY7r44ov18MMPa9++faX6Z2VlacWKFZo0aZKio6NNn1HFNW/eXC+//LLp2Pvvv6/LLrtM69evL3XODz74QD169DAtUxcaGqq33nqrGvfO9Tw8PLRo0SI1aNDAfuz3339Xp06d9PTTT2v//v1ljjt58qS+++47TZ48Wc2aNdPEiRO1d+/ecq8zZMgQ/fOf/zQde/PNN9WjRw999dVXpV6jkhQXF6c333xTPXv21JAhQ8o9d3U+16qiNt7PqB385gcAqFe8fb0q71TWOL+qjQMAAIBrWa0WNQwPrOsy3FpSUpLeeecdvfPOO5L+2nckLCxMAQEBysrK0qFDh5SZmVlq3KxZs9SsWbPaLrfOvPzyy1q6dKn9sThz5oxuv/123X///WrVqpU8PDx05MgRJSUl2cdceumlGjdunCZNmuSSmry8vPTAAw/oqaeesh/75Zdfyt2PqOSsi1dffVWDBg1SQcFff9x3/Phx3XzzzQoMDFSbNm1ktVp15MgRU0gUEBCg//73v6WW2TtX3HLLLTp27Jgefvhh2Ww2SX8FNZMmTdKkSZMUGRmpsLAweXp66vTp0zpx4oQyMjKcukbz5s01f/583XDDDcrL+2vlkJSUFN1xxx2677771KJFC/n5+SkxMdH0ejjrb3/7m0OzQB5//HH997//1dGjRyX9tYTgv/71Lz3++ONq06aNfH19deLECdMslPbt2+uFF14whbOVyc7O1qJFi+wzaBo2bKiIiAg1bNhQ+fn5SkxMVHJycqlxt9xyi6677jqHr+OIqKgoffXVV7ruuuvs+0Dl5ubq1Vdf1auvvqrGjRurSZMm8vb2VmpqquLj4+3Pc2Xuvfdebdy4UZ988on92KpVq9S3b1+Fh4crMjJSubm5OnToUKnlR/38/PTpp5+6RaDRrl07ff3117rhhhvss/bS0tI0Y8YMzZgxQ2FhYYqIiFBAQIDS09OVkpJS5vNbmRdffFGJiYmmJTa3bt2qG264Qd7e3oqOjlZoaKiysrJ05MgRh/f1qu7nmrNq6/0M1yPsAmqAzWYoPSVL+bkF8vb1UnBYgKxWS+UDHWTYbLIlp8jIyZXFz1fW8DBZrM5NzLQZho5n5yq7sEj+nh5q4u8rq6XmaqxJFT2ern6scf4LDPWXb4C3crMcX8bCP8hHwY0CKu8IAAAAnAeOHz+u48ePl3u7n5+fXn/9dU2ePLkWq6p70dHR+vLLLzVq1ChlZ2fbj2dmZpqWszrrsssu01dffaWvv/7apXU99thj2r9/v+bPn+/02EsuuURz5szRXXfdZQ+8pL/u09atW0v1DwkJ0VdffaWLLrqoWjW72j//+U9deOGFuv3220u9lhMTE02zdcri4+NjWkKwLNdcc42WLVumm2++2fQFeE5Ojvbs2VPmGA8PD02dOlXPP/+8Q/cjODhYS5Ys0RVXXGHaLy8vL0+7du0q1b9r1676/vvvdeDAAYfOX57Tp09XGkzcddddevvtt6t1nfIMHDhQ69at04033lhqdlFSUlKZgYMjLBaLPvroI0VERGjWrFmmkCw5ObncwCciIkJffPGFaZ+qc93gwYO1adMmjRkzRps2bTLdlpKSUmr/xZIsFosiIyMr7OPp6amFCxeqbdu2eumll0yfIfn5+dV6HVbnc60qauP9DNcj7AKqoSCvQNtXx2l/7BHTHkB+QT5q26O5OvSOrvIsEkkycnOVv3a98jfGykj/318ZWYKD5H1xD3n37yOLr2+F58guLNKKo8n65XiqTuf/7z86Db29NLhJIw1tFi5/T48q11iT8nMLtHdDQpmPZ6uuTSRZdHD7MZc81jj/FX99ORN0SVLbHpGEqgAAADjvzJkzRyNHjtT333+vtWvXlrnEW3GhoaG6+eabNW3aNEVHR9dSleeWK664Qhs3btS//vUvLVu2rMwZBREREZo2bZruu+8+eXi4/v+3PTw89Mknn+juu+/WggULtGnTJv3555/KyMiwz1KoyG233aZ27drpkUce0Zo1a8rs4+vrq7Fjx+q5555TkyZNavouuMQVV1yhP//8U3PmzNH777+vnTt3VjgDJDAwUAMHDtTw4cM1evRohYSEVHqNgQMHKi4uTi+++KI+/PDDcvdF8vX11ZVXXqkZM2aoc+fOTt2P7t27KzY2VtOmTdPnn3+uoqKiUn0aNmyoBx54QI8++qh8fX0dDhkmT56sli1b6ttvv9WqVasq3bPNx8dHV199tf75z3+6PPjp2LGjdu7cqY8++kizZ8/Wtm3byn3+PDw81Lt3b916660aP358hee1WCx6+eWXdeutt+qpp57SsmXLyn2fNG3aVHfccYemTp2qwED3m0HcqlUrbdy4Ud9++63eeOMNrV27tsL96zw8PHTxxRfrqquu0q233qqWLVtWeg2LxaJnn31WEydO1HPPPadvvvmmwqD0ggsu0IgRIyqd7Vrdz7WqqI33M1zLYhhGel0XAbiLnTt3Wrt06WKf3vH6tA8V6htRbv/AED8NHdezSpsi21JPKeuDT2ScKn+TUEtoiALuGC9ro9Ayb0/KydMrOw8qObf8/5CF+3rr4c6t1NjPp9w+tSHjVLZWzN+szLScyjuXoTqPNc5/1Xl9BYb4afjkS9jzAQAAuJXCwsJSX3a2adNGnp78ToPyHTp0SH/88YcSEhJ05swZ5efnKzAwUOHh4ercubM6duzIa6iYkydPavXq1Tp27JiysrIUGhqqLl26qE+fPrUScrlCfHy81q1bp+PHjysvL08NGzZUu3btdMkll8jf373/fzs5OVkbNmzQiRMnlJqaKpvNpuDgYEVERKhDhw5q06aNvLyq90e027Zt0+7du5WUlKS8vDz70nj9+/evkcfv9OnTWrVqlRITE3XmzBk1aNBAF154ofr16ycfn+p/r5OcnKw9e/bozz//1KlTp5SdnS1/f3+FhISoffv26tq1qwIC6mbVk5MnT+r333/XyZMnlZqaKk9PT4WEhKhNmzbq1q2bac8lZ2RnZ2vt2rU6fPiwUlJS7LP6LrzwQnXr1q1G70Ndy87O1vr165WYmKjU1FTl5OQoMDBQYWFhateunTp06FDt57eoqEgbN27UwYMHlZycrOzsbAUGBqpZs2a68MIL1b59e1nO0ZWmSnL1+7muuep3xd27d6tTp0729o4dO7I6d+7s2Fqj1UTYBTihZNg18+/vqHnjmArHVOWLciM3V5n/frfCoOssS2iIAh+YXGqGV3ZhkZ7e8keFQddZ4b7emtG9nfzqaIZXfm6Bvnvv9yoHXWcRSqAs1Xl9EaICAAB3RdgFAACA8pyPYZdzm/4AcFpmWo72rU9wakz+2vUOBV2SZJxKU/66DaWOrzia7FDQJUnJuflaftT5jShryt4NCdUOuqSqPdY4/1Xl9eUf5KNug1pr+ORLCLoAAAAAAACAcxxhF1AL9scmymYrf13o4gybTfkbY506f/6GzTKKbappMwz9cjzVqXOsOp4qWwVrV7uKzWZof+yRGjufM481zn9VeX35+nvpugcuVZeBrZglCAAAAAAAALgBwi6gFmRn5Ck9NcuhvrbkFBnpGU6d30jPkC05xd4+np2r0/kFTp0jLb9Ax7Nds8FjRdJTspSTUXPXdeaxxvmvKq+v3OwCZaZlu6giAAAAAAAAADWNsAuoJfk5joVPRk5ulc5ffFx2YVGVzpFdWFilcdWRn+tcKOfQOR18rHH+q+rri9cQAAAAAAAA4D4Iu4Ba4u3n5VA/i59vlc5ffJy/p0eVzuFfB5tVe/s69rg4dU4HH2uc/6r6+uI1BAAAAAAAALgPwi6gFvgH+Si4UYBDfa3hYbIEBzl1fktwkKzhYfZ2E39fNfR27sv6EG8vNfH3cWpMTQgOC5BfUM1d15nHGue/qry+eA0BAAAAAAAA7oWwC6gFbXtEymq1ONTXYrXK++IeTp3fu3dPWaz/eztbLRYNbtLIqXMMatJIVotjNdYkq9Witj2a19j5nHmscf6ryuuL1xAAAAAAAADgXgi7ABcLDPFT+z7RTo3x7t9HltAQh/paQkPk3a93qeNDm4Ur3NfboXOE+3prWLNwp2qsSR16RyswxK/a56nKY43znzOvL15DAAAAAAAAgPsh7AKqwT+44v21AkP8NHRcT3n7OLcXlsXXVwF3jK808LKEhvzVz7d0Hf6eHnq4c6tKA69wX2893LmV/Kq4z1dN8Pb10tBxPasVeFX1scb5z9HXF68hAAAAAAAAwD3xjR5QDYNu6iprRpD2xyYqOyPPftw/yEdte0SqfZ/oKn9xbm0UqsAHJit/3Qblb9gsIz3DfpslOEjevXvKu1/vMoOusxr7+eiZ7u204miyVh1PVVp+gf22EG8vDWrSSMOahddp0HVWUKi/hk/qq30bDpf5eLbq2lSGxaI/tx2t8cca57/KXl/lvYZsNkPpKVnKzy2Qt6+XgsMCWOIQAAAAAAAAOMfwzTBQDV4+Xrqweyt1GtBS6alZys8pkLefl4Ib1cwX4hZfX/lcPlDegwfIlpwiIydXFj9fWcPDTHt0VcTf00MjoyM0IuoCHc/OU3Zhofw9PdXE36dO9uiqiLevl7oMrPjx7DaotUsea5z/HHl9nZWfW6C9GxK0P/aIcooFY35BPmrbo7k69I6Wt69Xbd8FAAAAAAAAAGUg7AJqgNVqUcPwQJed32K1yuOCxtU6h9ViUbOAipddPFdU9Hi6+rHG+a+y11DGqWytmL9ZmWk5pW7LycjT9lUHdXD7MQ0d11NBof6uLBUAAAAAAACAA9izCwCA/y8/t6DcoKu4zLQcrZi/Wfl5hbVUGQAAAAAAAIDyEHYBAPD/7d2QUGnQdVZmWo72rU9wcUUAAAAAAAAAKkPYBQCAJJvN0P7YI06N2R+bKJvNcFFFAAAAAAAAABxB2AUAgKT0lCzlZOQ5NSY7I0/pqVkuqggAAKDqLBZLqWOGwR/pAAAAQLLZbKWOlfX7ozsh7AIAQH/t11WlcTlVGwcAAOBKVmvp/90vKOD3FgAAAEiFhaX3oS/r90d34t7VAwBQQ7x9vao2zq9q4wAAAFzJYrHI29vbdCwzM7OOqgEAAMC5pOTvhd7e3szsAgDgfBAcFiC/IB+nxvgH+Si4UYCLKgIAAKieoKAgUzs9PZ2lDAEAAOo5wzCUnp5uOlby90Z3RNgFAIAkq9Witj2aOzWmbY9IWa3u/VcvAADg/FXyS4uCggIdPXqUwAsAAKCeMgxDR48eLbW8dXBwcB1VVHM867oAAADOFR16R+vg9mPKTMuptG9giJ/a94muhaoAAACqxtfXV15eXqYvMzIyMnTw4EEFBwcrMDBQnp6ebr8/AwAAAMpns9lUWFiozMxMpaenlwq6vLy85OPj3GpH5yLCLgAA/j9vXy8NHddTK+ZvrjDwCgzx09BxPeXtw39GAQDAuctisahp06Y6fPiwaTZXQUGBUlNTlZqaWofVAQAAoK6d/X3R3ffrkljGEAAAk6BQfw2f1FfdBrWWf4k9vPyDfNRtUGsNn3yJgkL966hCAAAAx/n7+ysqKuq8+AIDAAAANcdisSgqKkr+/ufHd1z8SToAACV4+3qpy8BW6jSgpdJTs5SfUyBvPy8FNwpgjy4AAOB2zgZex44dK7VsDQAAAOofLy8vNW3a9LwJuiTCLgAAymW1WtQwPLCuywAAAKg2f39/tWrVSnl5eUpPT1dGRoby8/PruiwAAADUEm9vbwUFBSk4OFg+Pj7n3cx/wi4AAAAAAOoBi8UiX19f+fr6qnHjxjIMQzabzbSfFwAAAM4vFotFVqv1vAu3SiLsAgAAAACgHrJYLPLw8KjrMgAAAIBqs9Z1AQAAAAAAAAAAAEBVEXYBAAAAAAAAAADAbRF2AQAAAAAAAAAAwG0RdgEAAAAAAAAAAMBtEXYBAAAAAAAAAADAbRF2AQAAAAAAAAAAwG151nUBAAC4I5vNUHpKlvJzC+Tt66XgsABZrZa6LgsAAAAAAACodwi7AABwQn5ugfZuSND+2CPKycizH/cL8lHbHs3VoXe0vH296rBCAAAAAAAAoH4h7AIAwEEZp7K1Yv5mZabllLotJyNP21cd1MHtxzR0XE8FhfrXQYUAAAAAAABA/cOeXQAAOCA/t6DcoKu4zLQcrZi/Wfl5hbVUGQAAAAAAAFC/EXYBAOCAvRsSKg26zspMy9G+9QkurggAAAAAAACARNgFAEClbDZD+2OPODVmf2yibDbDRRUBAAAAAAAAOIuwCwCASqSnZCknI8+pMdkZeUpPzXJRRQAAAAAAAADOIuwCAKAS+bkFVRuXU7VxAAAAAAAAABxH2AUAQCW8fb2qNs6vauMAAAAAAAAAOI6wCwCASgSHBcgvyMepMf5BPgpuFOCiigAAAAAAAACcRdgFAEAlrFaL2vZo7tSYtj0iZbVaXFQRAAAAAAAAgLMIuwAAcECH3tEKDPFzqK9fkLeatGokm81wcVUAAAAAAAAACLsAAHCAt6+Xho7r6VDglZORrx8+2KBFb6zW9tVxys8tqIUKAQAAAAAAgPqJsAsAAAcFhfpr+KS+6jaotfwd2MMrJyNP21cd1Hfv/a6MU9m1UCEAAAAAAABQ/xB2AQDgBG9fL3UZ2EqjHhqoq+7oLT8HQq/MtBytmL9Z+XmFtVAhAAAAAAAAUL8QdgEAUAVWq0XHDqYoJyPPof6ZaTnatz7BxVUBAAAAAAAA9Q9hFwAAVWCzGdofe8SpMftjE2WzGS6qCAAAAAAAAKifCLsAAKiC9JQsh2d1nZWdkaf01CwXVQQAAAAAAADUT4RdAABUQX5uQdXG5VRtHAAAAAAAAICyEXYBAFAF3r5eVRvnV7VxAAAAAAAAAMpG2AUAQBUEhwXIL8jHqTH+QT4KbhTgoooAAAAAAACA+omwCwCAKrBaLWrbo7lTY9r2iJTVanFRRQAAAAAAAED9RNgFAEAVdegdrcAQP4f6Bob4qX2faBdXBAAAAAAAANQ/hF0AAFSRt6+Xho7rWWngFRjip6Hjesrbx7OWKgMAAAAAAADqD751AwCgGoJC/TV8Ul/t23BY+2MTlZ2RZ7/NP8hHbXtEqn2faIIuAAAAAAAAwEX45g0AgGry9vVSl4Gt1GlAS6WnZik/p0Defl4KbhTAHl0AAAAAAACAixF2AQBQQ6xWixqGB9Z1GQAAAAAAAEC9wp5dAAAAAAAAAAAAcFuEXQAAAAAAAAAAAHBbhF0AAAAAAAAAAABwW+zZhTp34MABy4YNGzwSExOt+fn5CgkJMTp06GDr379/kZ+fX12XBwAAAAAAAAAAzmGEXagzixYt8nzuued8tm3bVuYMw8DAQI0fP77gmWeeyQsPDzdquz4AAAAAAAAAAHDuYxlD1Lrc3FyNGTPG98Ybb/QrL+iSpMzMTP3f//2fV8eOHQN++eUXj9qsEQAAAAAAAAAAuAfCLtSqoqIi3XTTTX4LFy70Kn7cw8NDMTExRpcuXWwNGjQwjUlJSbEMHz7cf+3atQReAAAAAAAAAADAhLALterFF1/0/u6770zLZ951110F8fHxmYcOHcrcvn17VmpqasYXX3yRExkZaV+6MDs7W7fccovf6dOna71mAAAAAAAAAABw7iLsQq1JSUmxvPTSSz7Fjz377LN57733Xm7z5s3twZaHh4duvPHGwnXr1mVFR0fbjx89etTyyiuvmMYDAAAAAAAAAID6jbALteaFF17wzsjIsLf79+9f9Nhjj+WX1z8yMtJ47733coof+89//uOdkpJicWGZcIJhs6noZJIK4w+r6GSSDJutrksCAAAAAAAAANQznpV3AaqvqKhIH3/8sWmfrqeffjrPaq04bx02bFhRv379itatW+chSRkZGVqwYIHn/fffX+DCclEJIzdX+WvXK39jrIz0/wWYluAgeV/cQ979+8ji61uHFQIAAAAAAAAA6gtmdqFWrF271qP4jKwWLVoYl112WZEjY//2t7+Zgq3Fixd7ldcXrmdLPaXMf7+rvJ9WmYIuSTLSM5T30ypl/vtd2VJP1VGFAAAAAAAAAID6hLALteK7774zzSK8/PLLCyub1XXWsGHDCou3f/31V4/MzMwarA6OMnJzlfXBJzJOpVXc71TaX/1yc2upMgAAAAAAAABAfUXYhVqxfft2j+LtSy65xKFZXZLUvHlzIzo62jjbzs/P165du3jt1oH8tesrDbrOMk6lKX/dBhdXBAAAAAAAAACo7wgMUCv++OMP02utY8eODoddktS+fXtT/71793qU1xeuYdhsyt8Y69SY/A2bZdhsLqoIAAAAAAAAAADCLtSC7OxsJSYmWoofi4qKMsrrX5bIyEhT/3379vHarWW25JRSe3RVxkjPkC05xUUVAQAAAAAAAABA2IVakJycbDGM/2VVXl5euuCCC5wKu5o2bWqaHpScnGwpry9cw8ip2v5bVR0HAAAAAAAAAIAjPOu6AJz/MjMzTcGUv7+/rFbnctaAgIAKz1kVJ06csDgbmh04cKDeBsQWP99aHQcAAAAAAAAAgCMIu+ByGRnmpe98fHycmtUlSX5+fqYxmZmZ1axKmj17tvfMmTO9q32iesIaHiZLcJBTSxlagoNkDQ9zYVUAAAAAAAAAgPqu3s5SQe3Jzc01zZ7y9nY+X/Lx8TG1c3JyWMawllmsVnlf3MOpMd69e8ri5Cw+AAAAAAAAAACcwbfQcDlfX1/TrKz8/Hynz5GXl1fhOVE7vPv3kSU0xKG+ltAQeffr7eKKAAAAAAAAAAD1HcsYwuWCgoJM7by8PKdnZZWcyRUYGFjNqqT77rsvf/To0QXOjDlw4ID1hhtu8Kv2xd2UxddXAXeMV9YHn8g4lVZ+v9AQBdwxXhZf9usCAAAAAAAAALgWYRdcLjAw0DQLKzs7WzabTVYnlrfLysqq8JxVERERYURERDBDzEnWRqEKfGCy8tdtUP6GzaY9vCzBQfLu3VPe/XoTdAEAAAAAAAAAagVhF1wuPDzcsFgsMoy/cqWCggKdPHnS0qRJE4eDpmPHjpmSsfDwcEKqOmTx9ZXP5QPlPXiAbMkpMnJyZfHzlTU8jD26AAAAAAAAAAC1im+l4XL+/v6KjIw0hVMJCQlOLWV4+PBhU/8OHTrYaqI2VI/FapXHBY3lGRMljwsaE3QBAAAAAAAAAGod30yjVrRt29YUTu3Zs8fDmfF//PGHqX/79u2LaqIuAAAAAAAAAADg3gi7UCu6du1qCqd+++03h8Ouo0ePWorPBPPy8lKnTp2Y2QUAAAAAAAAAAAi7UDtGjBhRWLy9cuVKT5vNsbxq2bJlpr3lLr300qKgoKAarA4AAAAAAAAAALgrwi7Uiv79+xc1atTIvm/XoUOHLCtXrnRodtfcuXO9irevvfbagpquDwAAAAAAAAAAuCfCLtQKDw8PjR8/3hRSzZgxw6ey2V3Lly/3WLdunT0UCwoK0pgxYworGgMAAAAAAAAAAOoPwi7Umsceeyw/MDDQ3v711189nn/+ee/y+icmJlomTZrkV/zYvffemx8eHm6UNwYAAAAAAAAAANQvhF2oNeHh4cbUqVPzih978sknfSZPnux75MgRy9ljRUVFWrRokWe/fv0CEhIS7MebNGlSajwAAAAAAAAAAKjfPOu6ANQvjz32WP7vv//u8cMPP9hfe++9957XBx984BUVFWUEBwcbCQkJ1tOnT5vG+fn5aeHChTkhISG1XTIAAAAAAAAAADiHMbMLtcrDw0OLFi3Kuemmm0z7bhUVFenQoUOW7du3lwq6QkNDjW+//Tb70ksvLarNWgEAAAAAAAAAwLmPsAu1zs/PT59//nnOZ599ltOlSxdbef0CAgI0efLkgt27d2ddfvnlBF0AAAAAAAAAAKAUljFEnbn55psLb7755sL9+/db1q9f73HkyBFrfn6+GjZsaHTs2NE2YMCAIj8/v7ouEwAAAAAAAAAAnMMIu1Dn2rZta7Rt27aw8p4AAAAAAAAAAABmLGMIAAAAAAAAAAAAt8XMLgAAXMhmM5SekqX83AJ5+3opOCxAVqulrssCAAAAAAAAzhuEXQAAuEB+boH2bkjQ/tgjysnIsx/3DfRWdIcL1LxtuAKC/Qi/AAAAAAAAgGoi7AIAoIZlnMrWivmblZmWU+q23Mx8/bEpUX9sSpQk+QX5qG2P5urQO1revl61XSoAAAAAAADg9tizCwCAGpSfW1Bu0FWWnIw8bV91UN+997syTmW7uDoAAAAAAADg/EPYBQBADdq7IcHhoKu4zLQcrZi/Wfl5hS6oCgAAAAAAADh/EXYBAFBDbDZD+2OPVHl8ZlqO9q1PqMGKAAAAAAAAgPMfYRcAADUkPSVLORl51TrH/thE2WxGDVUEAAAAAAAAnP8IuwAAqCH5uQXVPkd2Rp7SU7NqoBoAAAAAAACgfiDsAgCghnj7etXIefJzqh+aAQAAAAAAAPUFYRcAADUkOCxAfkE+1T6Pt1/NhGYAAAAAAABAfUDYBQBADbFaLWrbo3m1zuEf5KPgRgE1VNH/Y+/e46Oq7/yPf86ZmTP3kCsQA0RBuSigJZGggEBpKG1Rq+6uvUBtxUq7rdR2S+22dLu2Xqp219+q3aorvQjrttuL3VZtFS1RQQkSWkAEgajhFmBygcz9zMw5vz9oYgLkMkPmlryej0ceZc58v2c+E/NoJud9vt8PAAAAAAAAMPQRdgEAMIim1FSKp8iZ8vyJVWNFVZVBrAgAAAAAAAAY2gi7AAAYRJrDJrVLq1MKvDxFTpk8qzINVQEAAAAAAABDF2EXAACDzFvskiW3XiGXzb9QXAPs4eUpckrt0mrR7NY0VwcAAAAAAAAMLVxRAwAgDTSHTabPmyBT546XjtagBE+G5dC+Fjm4+5iE/NGucS6vXSZWjZXJsyoJugAAAAAAAIAUcFUNAIA0UlVFCss8UljmkYoLy+TyD0+Wjtag6OGYaE6bFJS46dEFAAAAAAAAnAPCLgAAMqgz/AIAAAAAAAAwOAi7AAwbpmGI4WsRMxwRxekQtaxUFDW/WhcOhfcAAAAAAAAAAIOJsAtA3jJMU5pDEQnFE+KyWqTc5RBVOXM7ODMSEX3jZtG3NIjZ4e86rhR4RZtZJdqcWaI4HJksPWlD4T0AAAAAAAAAQDoQdgHIO6F4QtYf9smG5lY5oce6jhdqNllQXiK1FWXislpERMRobZPgmrVitrWfcR6zwy/RF+tE37Zd3MuXiVpSnLH3kIyh8B4AAAAAAAAAIF3Y+wpAXjkejsp3t70tTzcd7RF0iYic0GPydNNR+e62t+V4OCpmJNJrSNSd2dZ+alwkks7SUzIU3gMAAAAAAAAApBNhF4C8EYon5IGdjeKL6H2O80V0eWBnowRfeb3fkKiT2dYu+qb6wShzUOkbN+f9ewAAAAAAAACAdCLsApA31h/29Rt0dWoJRyVc/0ZS59frt4ppGKmUlhamYYi+pSGpObn2HgAAAAAAAAAg3Qi7AOQFwzRlQ3PrgMePCvjFHgwl9Rpmh18MX0uypaWN4WsRs8Of1Jxcew8AAAAAAAAAkG6EXQDyQnMockaPrr44YwMf250Zzp2eV6nWkkvvAQAAAAAAAADSjbALQF4IxRNJjQ/bbCm9juJ0pDQvHVKtJZfeAwAAAAAAAACkG2EXgLzgslqSGn/M45UT9uRCH6XAK2pZaVJz0kktKxWlwJvUnFx7DwAAAAAAAACQboRdAPJCucshhdrAV2uZiiLbLpiQ1GtoNdWiqLnzf4uKqoo2syqpObn2HgAAAAAAAAAg3bgiCiAvqIoiC8pLkppjvXKmKMVFAxqrFBeJNrsmldLSSpszK+/fAwAAAAAAAACkE2EXgLxRW1EmZQ5tQGPLHJosHD9G3MuX9RsWKcVFp8Y5cq/XleJw5P17AAAAAAAAAIB0IuwCkDdcVousmjah38CrzKHJqmkTxGm1iFpSLJ6VK8Reu+CM/ldKgVfstQvEs3KFqCXF6Sz9nAyF9wAAAAAAAAAA6WLNdgEAkIyRTrvcOWOSrD/sk7rmVmnXY13PFWk2mV9eIosqysRptXQdVxwOsS+cJ9qCuWL4WsQMR0RxOkQtK82b/lZD4T0AAAAAAAAAQDoQdgHIOy6rRa6tHC1XjxslzaGohOJxcVmtUu6yi6oovc5TVFUso0ZmsNLBNxTeAwAAAAAAAAAMJsIuAHlLVRSpcNOjCgAAAAAAAACGM/a+AgAAAAAAAAAAQN4i7AIAAAAAAAAAAEDeIuwCAAAAAAAAAABA3iLsAgAAAAAAAAAAQN6yZrsAAACGM8MwpaMlKHokJprDJgWlblFVJdtlAQAAAAAAAHmDsAsAgCzQIzHZXd8kexsOSdgf7Tru9NplYtUYmVJTKZrDlsUKAQAAAAAAgPxA2AUAQIb520Kyft1WCbSHz3gu7I/K9rpGadx+RGqXVou32JWFCgEAAAAAAID8Qc8uAAAySI/Eeg26ugu0h2X9uq2iR+MZqgwAAAAAAADIT4RdAABk0O76pn6Drk6B9rDs2dyU5ooAAAAAAACA/EbYBQBAhhiGKXsbDiU1Z2/DQTEMM00VAQAAAAAAAPmPsAsAgAzpaAlK2B9Nak7IH5WO1mCaKgIAAAAAAADyH2EXAAAZokdiqc0LpzYPAAAAAAAAGA4IuwAAyBDNYUttnjO1eQAAAAAAAMBwQNgFAECGFJS6xem1JzXH5bVLQYk7TRUBAAAAAAAA+Y+wCwCADFFVRSZWjUlqzsSqsaKqSpoqAgAAAAAAAPIfYRcAABk0paZSPEXOAY31FDll8qzKNFcEAAAAAAAA5DfCLgAAMkhz2KR2aXW/gZenyCm1S6tFs1szVBkAAAAAAACQn7iCBgBAhnmLXbLk1itkT/0B2dtwUEL+aNdzLq9dJlaNlcmzKgm6AAAAAAAAgAHgKhoAAFmgOWwyfd4EmTp3vHS0BkUPx0Rz2qSgxE2PLgAAAAAAACAJhF0AAGSRqipSWObJdhkAAAAAAABA3iLsAgCkhWkYYvhaxAxHRHE6RC0rFUWlVSQAAAAAAACAwUXYBQAYVGYkIvrGzaJvaRCzw991XCnwijazSrQ5s0RxOLJYYX4wDFM6WoKiR2KiOWxSUMr2hgAAAAAAAMDZEHYBAAaN0domwTVrxWxrP+M5s8Mv0RfrRN+2XdzLl4laUpyFCnOfHonJ7vom2dtwSML+aNdxp9cuE6vGyJSaStEctixWCAAAAAAAAOQW9pMCgBxgmKYcDoZl38mAHA6GxTDNbJeUNDMS6TXo6jGurf3UuEgkQ5XlD39bSJ55/HXZXtfYI+gSEQn7o7K9rlGeefx18beFslQhAAAAAAAAkHtY2QUAWRSKJ2T9YZ9saG6VE3qs63ihZpMF5SVSW1EmLqslixUOnL5xc79BVyezrV30TfViXzgvzVXlDz0Sk/XrtkqgPdznuEB7WNav2ypLVlwpmp1f4wAAAAAAAAAruwAgS46Ho/LdbW/L001HewRdIiIn9Jg83XRUvrvtbTkejvZyhtxhGoboWxqSmqPXbxXTMNJUUf7ZXd/Ub9DVKdAelj2bm9JcEQAAAAAAAJAfCLsAIAtC8YQ8sLNRfBG9z3G+iC4P7GyUcDyRocpSY/haxOzwJzXH7PCL4WtJU0X5xTBM2dtwKKk5exsOimHk33aXAAAAAAAAwGAj7AKALFh/2Ndv0NXJF9HlhcO+NFd0bsxwav23Up031HS0BM/o0dWfkD8qHa3BNFUEAAAAAAAA5A/CLgDIMMM0ZUNza1Jz6ppbxTBzdxWP4nRkdN5Qo0di/Q8627xwavMAAAAAAACAoYSwCwAyrDkUOaNHV3/a9Zg0h3K3d5daVipKgTepOUqBV9Sy0jRVlF80hy21ec7U5gEAAAAAAABDCWEXAGRYKMX+W6F4fJArGTyKqoo2syqpOVpNtSgqv4ZERApK3eL02pOa4/LapaDEnaaKAAAAAAAAgPzBVUYAyDCX1ZLiPOsgVzK4tDmzRCkuGtBYpbhItNk1aa4of6iqIhOrxiQ1Z2LVWFFVJU0VAQAAAAAAAPmDsAsAMqzc5ZBCLbnt54o0m5S7klv5k2mKwyHu5cv6DbyU4qJT4xz06+puSk2leIqcAxrrKXLK5FmVaa4IAAAAAAAAyA+EXQCQYaqiyILykqTmzC8vEVXJ/VU8kREj5OWPf1xemnyJnDgtzIq43aIunCeelStELSnOUoW5S3PYpHZpdb+Bl6fIKbVLq0Wz5/ZKPwAAAAAAACBTuFIGAFlQW1EmG4+1iS+i9zu2zKHJooqyDFR1bo6Ho/LAzsZT72n8RfL7Cy6UUQG/OGMxCdtscszjlVKnXVaZiozMdrE5ylvskiW3XiF76g/I3oaDEvJHu55zee0ysWqsTJ5VSdAFAAAAAAAAdMPVMgDIApfVIqumTXg/HOpFmUOTVdMmiDPFPl+ZEoonzngvpqLIUW9Bj3G+iC4P7GyU782YlPPvKVs0h02mz5sgU+eOl47WoOjhmGhOmxSUuOnRBQAAAAAAAJwFYRcAZMlIp13unDFJ1h/2SV1zq7Trsa7nijSbzC8vkUUVZXkRCq0/7BvQKjWRU4HXC4d9cm3l6DRXld9UVZHCMk+2ywAAAAAAAAByHmEXAGSRy2qRaytHy9XjRklzKCqheFxcVquUu+x50aNLRMQwTdnQ3JrUnLrmVrl63Ki8eY8AAAAAAAAAchdhFwDkAFVRpMLtyHYZKWkOReREt1VpA9Gux6Q5FM2J92wahhi+FjHDEVGcDlHLSkVR1WyXBQAAAAAAAGCACLsAAOckFE+kOC8+yJUkx4xERN+4WfQtDWJ2+LuOKwVe0WZWiTZnliiO7IdxAAAAAAAAAPpG2AUAOCeuFHuKuazZ+xVktLZJcM1aMdvaz3jO7PBL9MU60bdtF/fyZaKWFGehQgAAAAAAAAADxT5NAIBzUu5ySKFmS2pOkWaTcpc9TRX1zYxEeg26eoxraz81LhLJUGUDZximnDgekOMH2uXE8YAYhpntkgAAAAAAAICsYWUXAOCcqIoiC8pL5OmmowOeM7+8RFRFSWNVvdM3bu436OpktrWLvqle7AvnpbmqgdEjMdld3yR7Gw5J2B/tOu702mVi1RiZUlMpmiO54BEAAAAAAADId6zsAgCcs9qKMilzaAMaW+bQZFFFWZorOjvTMETf0pDUHL1+q5iGkaaKBs7fFpJnHn9dttc19gi6RETC/qhsr2uUZx5/XfxtoSxVCAAAAAAAAGQHYRcA4Jy5rBZZNW1Cv4FXmUOTVdMmiDPFPl/nyvC1iNnhT2qO2eEXw9eSpooGRo/EZP26rRJoD/c5LtAelvXrtooejWeoMgAAAAAAACD7CLsAAINipNMud86YJNdVjpai03p4FWk2ua5ytHxvxiQZ6cxOry4RETOcWv+tVOcNlt31Tf0GXZ0C7WHZs7kpzRUBAAAAAAAAuYOeXQCAQeOyWuTaytFy9bhR0hyKSigeF5fVKuUue9Z6dHWnOB0ZnTcYDMOUvQ2Hkpqzt+GgTJ07XlQ1+99zAAAAAAAAIN0IuwAAg05VFKlwZy8g6o1aVipKgTeprQyVAq+oZaVprKpvHS3BM3p09Sfkj0pHa1AKyzxpqgoAAAAAAADIHWxjCAAYNhRVFW1mVVJztJpqUdTs/brUI7HU5oVTmwcAAAAAAADkG8IuAMCwos2ZJUpx0YDGKsVFos2uSXNFfdMctv4HnW2eM7V5AAAAAAAAQL4h7AIADCuKwyHu5cv6DbyU4qJT4xzZ3Y6xoNQtTq89qTkur10KStxpqggAAAAAAADILYRdAIBhRy0pFs/KFWKvXSBKgbfHc0qBV+y1C8SzcoWoJcVZqvB9qqrIxKoxSc0ZO3lkmqoBAAAAAAAAco812wUAAJANisMh9oXzRFswVwxfi5jhiChOh6hlpVnt0XU2U2oqpXH7EQm0hwc0/u03DsqBPcdlYtUYmVJTmfJWiAAAAAAAAEA+yK2reQAAZJiiqmIZNVKs548Ty6iRORd0iZzq21W7tFo8Rc4Bzwn7o7K9rlGeefx18beF0lgdAAAAAAAAkF25d0UPAACcwVvskiW3XiGXzb9QXEn08Aq0h2X9uq2iR+NprA4AAAAAAADIHsIuAADyhOawyfR5E+T62+fJpMvHDnheoD0sezY3pbEyAAAAAAAAIHsIuwAAyEMH9hxPavzehoNiGGaaqgEAAAAAAACyh7ALAIA8YhqGtL99QML+aFLzQv6odLQG01QVAAAAAAAAkD3WbBcAAAD6Z0Yiom/cLPqWBukIiIh9atLn0MOxwS8MAAAAAAAAyDLCLgAAcpzR2ibBNWvFbGsXERGb4kzpPJrTNphlAQAAAAAAADmBsAsAgG4M05TmUERC8YS4rBYpdzlEVZSs1WNGIj2CLhERrxkWh6lLRNEGfB6X1y4FJe50lAgAAAAAAABkFWEXAAAiEoonZP1hn2xobpUT+vvb/RVqNllQXiK1FWXisloyXpe+cXOPoEtERBGR8+PHZI9t7IDPM7FqrKhq9kI7AAAAAAAAIF0IuwAAw97xcFQe2Nkovoh+xnMn9Jg83XRUNh5rk1XTJshIpz1jdZmGIfqWhrM+NyHeLAcsZRJSHf2ex1PklMmzKge7PAAAAAAAACAnqNkuAACAbArFE70GXd35Iro8sLNRwvFEhioTMXwtYnb4z/qcTRIyW39LXEakz3N4ipxSu7RaNDv3twAAAAAAAGBoIuwCAAxr6w/7+g26Ovkiurxw2Jfmit5nhvsOstxmVBZEd8jk2AFxmNEez7m8drls/oWyZMWV4i12pbNMAAAAAAAAIKu4zRsAMGwZpikbmluTmlPX3CpXjxslqpL+/leKs/8tCm2SkMnxwzIpflj8ilNiilVGLPs7KZw0jh5dAAAAAAAAGBZY2QUAGLaaQxE5oceSmtOux6Q5FO1/4CBQy0pFKfAOaKwiIgVmWEo9IkWTxhJ0AQAAAAAAYNgg7AIADFuhFPtvheLxQa7k7BRVFW1mVVJztJpqUVR+vQMAAAAAAGD44GoYAGDYclktKc7L3C7A2pxZohQXDWisUlwk2uyaNFcEAAAAAAAA5BZ6diFrOjo65NVXX7W8/fbblo6ODnE6nXL++ecbs2fPTowZM8bMdn0Ahr5yl0MKNVtSWxkWaTYpd9nTWFVPisMh7uXLJLhmrZht7b2PKy4S9/Jlojj67/MFAAAAAAAADCWEXRARkf379yv19fWW+vp6yxtvvGHZvn27JRwOdz0/d+7cxCuvvBIajNdqbGxUvvOd79h/85vf2HRdP+N5RVFk7ty5iX/913+NLliwILU9xgBgAFRFkQXlJfJ009EBz5lfXiKqktl+WGpJsXhWrhB9U73o9VvF7PB3PacUeEWrqRZtdg1BFwAAAAAAAIYlwq5h7Omnn7Y+9thjtq1bt1paW1szcuX2f/7nf6y33HKLMxTqPTczTVNeeeUVy8KFC11f+9rX9Pvvvz+q0n8GQJrUVpTJxmNt4oucGb6frsyhyaKKsgxUdSbF4RD7wnmiLZgrhq9FzHBEFKdD1LJSenQBAAAAAABgWOPq2DD25z//2fL8889bMxV0/eIXv7AuXbr0jKCrtLTUvOyyy4yKigpT6bZawjRN+bd/+zft9ttvz9x+YQCGHZfVIqumTZAyh9bnuDKHJqumTRBnin2+BouiqmIZNVKs548Ty6iRBF0AAAAAAAAY9rhChrNyu92Der59+/Ypt9xyi9MwjK5j06ZNM9avXx/y+XyBv/zlL8FDhw4Fdu3aFbz22mvj3ec+/PDD2q9+9StWIQJIm5FOu9w5Y5JcVzlaijRbj+eKNJtcVzlavjdjkox0kr0DAAAAAAAAuYYAAVJUVGRWVVUZ1dXViZkzZyZqamoSzz33nPXzn//8oDV/Wb16tSMYDHY9rqqqMl566aXgiBEjeoybMmWK8dvf/jZ86623OtasWdN1xfmb3/ym4+Mf/3jAZut5ERoABovLapFrK0fL1eNGSXMoKqF4XFxWq5S77Bnv0QUAAAAAAABg4Ai7hrFbb701tnLlSv2iiy4y0/k6O3fuVH/96193/axpmiY///nPw6cHXZ1UVZWHH3448vLLL1v279+vioi88847yhNPPGH74he/GEtnrQCgKopUuAct6wcAAAAAAACQZmxjOIxNmzbNSHfQJSKyZs0aW/ftC//+7/8+dskllxh9TBGn0ymrVq3Sux/7yU9+wrIuAAAAAAAAAADQA2EX0u6ZZ57psYJw+fLlA1qd9alPfSrWvXdYQ0OD5dChQ+wlBgAAAAAAAAAAuhB2Ia12796tNjY2dv2cud1umTNnTmIgcz0ej9TU1HSNNU1T/vCHP7D1JgAAAAAAAAAA6ELYhbT6y1/+0uNnrLq6OmGzDXw3wiuvvDLe/fH27dstg1QaAAAAAAAAAAAYAgi7kFZvvfVWj3BqypQpffbqOt3pvb327NnDzywAAAAAAAAAAOhCcIC02rt3b4+fsTFjxiQVdo0dO9bs63wAAAAAAAAAAGB4IzhAWvl8PqX747FjxyYVdp0ejrW0tCi9jQUAAAAAAAAAAMOPNdsFYGgLBAI9Hrvd7qTmezyeHiu7YrGYRCIRcTgc51zb0aNHldPDuP7s27ePgBgAAAAAAAAAgBxC2IW0CgQCPcIkh8Nh9jb2bJxO51nPmex5zuaRRx7R7r77bu1czwMAAAAAAAAAALKHVSpIq2g02iPs0rTksiW73X7GsVAodG5FAQAAAAAAAACAIYOwKwtuu+02u6Io3nR/rV69+sykKMPsdnuPFVi6ric1PxqNnnHsbKu9AAAAAAAAAADA8MQ2hkir03tuRSKRpHpkhcPhfs+Zqi9/+cv6jTfeGEtmzr59+9QbbriBtA1AXjAMUzpagqJHYqI5bFJQ6hZVTer/hgEAAAAAAICcR9iFtPJ4PD0eB4PBpOaf3vPLarUO2squ0aNHm6NHjx6U4AwAcokeicnu+ibZ23BIwv73V8g6vXaZWDVGptRUiuawZbFCAAAAAAAAYPAQdmXBxz72sXhJSUnaQ5Z58+Yl0v0a/SkrK+vxPg8ePJjU1pmHDh3qMb60tJRwCgD64G8Lyfp1WyXQfubK2LA/KtvrGqVx+xGpXVot3mJXFioEAAAAAAAABhdhVxYsXrw4sXjx4qwHUZkwceJEo/vjZMOuAwcO9FjZNWnSJKO3sQAw3OmRWK9BV3eB9rCsX7dVlqy4UjQ7HwUAAAAAAACQ35IKHoBkTZkypUeot3v37qR+5t56660e4wm7AKB3u+ub+g26OgXaw7Jnc1OaKwIAAAAAAADSj7ALafWBD3ygRzjV0NBgicViA57/2muv9VhycOmllw6LFXEAkCzDMGVvw6Gk5uxtOCiGwe6wAAAAAAAAyG+EXUiriy++2Bg/fnzXldRgMCgbN260DGRuIBCQLVu2dI1VFEWuueaaeDrqBIB819ESlLA/mtSckD8qHa3BNFUEAAAAAAAAZAZhF9JuyZIlPZZyrVmzxjaQeU899ZQtEAh0PZ4xY4YxZswYliAAwFnokYGvmu0xL5zaPAAAAAAAACBXEHYh7ZYvXx5TFKXr8a9+9Svbrl27+vzZC4fD8sADD2jdj33uc5/T01QiAOQ9zTGg+wjOnOdMbR4AAAAAAACQKwi7kHbTp083brjhhq7tB3Vdl5tuusl58uTJs443DENWrlzp2L9/f9fP5wUXXGB+/vOfZ/kBAPSioNQtTq89qTkur10KStxpqggAAAAAAADIDGu2C0B2Pf/882ftn/XWW2/1CELb29uV3sZOmDDBuPDCC/vcXvDuu++OPPfcc55QKCQiIg0NDercuXPdDz74YGThwoWJznF79uxRv/nNb9r/7//+r8fP5j333BPRNE0AAGenqopMrBoj2+saBzxnYtVYUVWl/4F9MA1DDF+LmOGIKE6HqGWloqjcSwMAAAAAAIDMIewa5hYvXuwayLg333xT7W3st7/9bf2uu+6K9jV/4sSJ5uOPPx5etmyZ0zRP5WI7d+5UP/ShD7lKS0vNsWPHmj6fTzl8+LDS+Xynf/zHf9Q/8YlPxM92XgDA+6bUVErj9iMSaA/3O9ZT5JTJsypTfi0zEhF942bRtzSI2eHvOq4UeEWbWSXanFmiOBwpnx8AAAAAAAAYKG69RsZ8+tOfjj/55JNhp9PZ43hLS4vyl7/8RT106NAZQdftt9+uP/zww30GaQCAUzSHTWb83XSJOs+6ELdL1GmRGX83XTR7ave8GK1tEnjoMYm+WNcj6BIRMTv8En2xTgIPPSZGa1tK5wcAAAAAAACSQdiFjFq6dGl8x44dgRtvvDFus9l6HTdnzpzESy+9FHrwwQejKtthAcCAhOIJ+dGhI7K5uljeucAtEXvP//+M2FV55wK3bK4ulh8dOiLheKKXM/XOjEQkuGatmG3tfY9raz81LhJJ+jUAAAAAAACAZLCN4TBnmqa//1GD68ILLzR/8YtfhE+ePCmvvPKKde/evarf7xeHwyGVlZXGnDlzEmPHju2zBxgA4EzrD/vEF9FFrKq8d75H3qt0iyuUEFvMkJhNlZDLIqKc6tHli+jywmGfXFs5OqnX0Ddu7jfo6mS2tYu+qV7sC+cl/V4AAAAAAACAgSLsQtaMGDFCrr76anpxAcAgMExTNjS39jyoKBJy9/6rvq65Va4eN0rUvwVg/TENQ/QtDUnVpddvFW3BXFEytErXNAwxfC1ihiOiOB2ilpVm7LUBAAAAAACQHYRdAAAMAc2hiJzQY0nNaddj0hyKSoXbMaDxhq/ljB5d/TE7/GL4WsQyamRS85JlRiKib9ws+paGHjUqBV7RZlaJNmeWKI6BvU8AAAAAAADkF8IuAACGgFAK/bdOzRv4AlsznFr/rVTnDZTR2tZrHzGzwy/RF+tE37Zd3MuXiVpSnNZaAAAAAAAAkHns6wMAwBDgslpSnDfw+14UZ2oro1KdNxBmJNJr0NVjXFv7qXGR9AZvAAAAAAAAyDzCLgAAhoByl0MKNdvABpumuINxGRM0xBmIiWGYA5qmlpWKUuBNqi6lwCtqWWlSc5Khb9zcb9DVyWxrF31TfdpqAQAAAAAAQHawjSEAAEOAqiiyoLxEnm462usYS9yQsQdDUnEkLHbdEBGRZ7b4xOm1y8SqMTKlplI0R++BmaKqos2skuiLdQOuS6upFkVNz701pmGIvqUhqTl6/VbRFsxNW00AAAAAAADIPK70AAAwRNRWlEmZQzvrc85wXGa+0Sbj3wt2BV2dwv6obK9rlGcef138baE+X0ObM0uU4qIB1aMUF4k2u2ZgxafA8LWI2eFPao7Z4RfD15KmigAAAAAAAJANhF0AAAwRLqtFVk2bcEbgZYkbctlfT4gzkuhzfqA9LOvXbRU9Gu91jOJwiHv5sn4DL6W46NQ4Rxr7dYVT67+V6jwAAAAAAADkJsIuAACGkJFOu9w5Y5JcVzlaiv7Ww2vswVC/QVenQHtY9mxu6nOMWlIsnpUrxF674IweXkqBV+y1C8SzcoWoJcWpvYkBUpypBWmpzgMAAAAAAEBuomcXAABDjMtqkWsrR8vV40bJkUBEXt2yWWJJzN/bcFCmzh0vqqr0OkZxOMS+cJ5oC+ae2k4wHBHF6RC1rDRj/bDUslJRCrxJbWWoFHhFLStNY1UAAAAAAADINFZ2AQAwRKmKIp5wQmJBPal5IX9UOlqDAxqrqKpYRo0U6/njxDJqZMaCrs7X1mZWJTVHq6nOaI0AAAAAAABIP672AAAwhOmRZNZ0dZsXTm1epmlzZvXbP6yTUlwk2uyaNFcEAAAAAACATCPsAgBgCNMcttTmOVObl2mKwyHu5cv6DbyU4qJT4xz06wIAAAAAABhq8rZn1/79+5W//vWvlnfffVc9dOiQcvLkSSUYDCoiIm632xwxYoQ5duxY84ILLjAuvfTSxIUXXmhmu2YAADKtoNQtTq9dwv7ogOe4vHYpKHGnsarBpZYUi2flCtE31Ytev7VHDy+lwCtaTbVos2sIugAAAAAAAIaovAm7mpqalD/84Q/W559/3rpp0ybLyZMnlWTmjxgxwpw9e3Zi0aJF8SVLlsQvuOACwi8AwJCnqopMrBoj2+saBzxnYtVYUdWkfs1mneJwiH3hPNEWzBXD1yJmOCKK0yFqWSk9ugAAAAAAAIa4nA67AoGAPPnkk7annnrKtnnzZotpnsqnOv+3k6Kc/YJc93EnTpxQnnvuOetzzz1nvf3226Wmpibx6U9/OvaZz3wm5vV60/cmAADIsik1ldK4/YgE2sP9jvUUOWXyrMoMVJUeiqqKZdTIbJcBAAAAAACADMrJW53fe+895Stf+Yp97Nix3ttuu83x+uuvWwzD6AqvTg+3TNM861d3nXM6n6uvr7esXLnSMXbsWO9XvvIV+7vvvptft7ADADBAmsMmtUurxVPk7HOcp8gptUurRbPn9L0wAAAAAAAAQA85dTXr4MGDyl133WX/+c9/bovFYmKa5lmDrTFjxpiXXHJJYvLkyUZ5ebl53nnnGR6PR1wul2mapoTDYSUQCMjhw4fV5uZmZc+ePequXbsshw8fPiPQ6ujokEceeUR77LHHtJtuuim2evXq6NixY9niEAAwpHiLXbLk1itkT/0B2dtwUELdeni5vHaZWDVWJs+qJOgCAAAAAABA3smJK1rhcFjuvvtu+4MPPqhFIpEeIZdpmlJRUWEuWbIkvmDBgvi8efMSo0aNSimMOnr0qPLyyy9b6urqrM8884y1e/il67o88cQTtnXr1tm++tWv6t/+9rejTmffd8ADAJBPNIdNps+bIFPnjpeO1qDo4ZhoTpsUlLjzrkcXAAAAAAAA0EkxTbMj20WMHTvWc+TIEaX71oOFhYXmJz/5ydhnPvOZWE1NjZGO162vr1effPJJ2y9+8Qtbe3t711U+RVFkzJgxZlNTUyAdr4v8tXPnTnX69OnuzsdvvvmmXHLJJdksCQAAAAAAAACArNu1a5dMnTq16/GOHTuC06ZNS0u+c7qc6NnVfYXVxRdfbKxZsyZy5MiRwI9+9KNouoIuEZGamhrjRz/6UfTIkSOBNWvWRC655BJD5NRqskOHDnGLOwAAAAAAAAAAQI7LibBLRGTatGnG7373u/Cbb74Z/NznPhdzOBwZe2273S6f+9znYjt37gz+7ne/C0+fPj0jSSMAAAAAAAAAAADOTU707Fq3bl34U5/6VDzbdYiIXHPNNfFrrrkm/tRTT+XE9wYAAAAAAAAAAAC9y4mVXbkSdHWXizUBAAAAAAAAAACgp5wIuwAAAAAAAAAAAIBUsFUfAADoYhimdLQERY/ERHPYpKDULaqqZLssAAAAAAAAoFeEXQAAQPRITHbXN8nehkMS9ke7jju9dplYNUam1FSK5rBlsUIAAAAAAADg7Ai7AAAY5vxtIVm/bqsE2sNnPBf2R2V7XaM0bj8itUurxVvsykKFAAAAAAAAQO/o2QUAwDCmR2K9Bl3dBdrDsn7dVtGj8QxVBgAAAAAAAAxMTqzseu+997LeDOT88883s10DAACZtru+qd+gq1OgPSx7NjfJ9HkT0lwVAAAAAAAAMHA5EXaNHz/eoyjZy7sURZF4PO7PWgEAAGSBYZiyt+FQUnP2NhyUqXPHi6pm/T4VAAAAAAAAQERyJOzqZJosrgIAIFM6WoIS9keTmhPyR6WjNSiFZZ40VQUAAAAAAAAkh55dAAAMU3okltq8cGrzAAAAAAAAgHTIiZVdS5cu5aoZAAAZpjlsqc1zpjYPAAAAAAAASIecCLuefPLJSLZrAABguCkodYvTa09qK0OX1y4FJe40VgUAAAAAAAAkh20MAQAYplRVkYlVY5KaM7FqrKiqkqaKejJMUw4Hw7LvZEAOB8Ni0NsTAAAAAAAAZ5ETK7sAAEB2TKmplMbtRyTQHu53rKfIKZNnVaa9plA8IesP+2RDc6uc0N/f6bhQs8mC8hKprSgTl9WS9joAAAAAAACQH1jZBQDAMKY5bFK7tFo8Rc4+x3mKnFK7tFo0e3rvkzkejsp3t70tTzcd7RF0iYic0GPydNNR+e62t+V4eOBbLwIAAAAAAGBoI+wCAGCY8xa7ZMmtV8hl8y8Ul9fe4zmX1y6Xzb9Qlqy4UrzFrrTWEYon5IGdjeKL6H2O80V0eWBno4TjibTWAwAAAAAAgPzANoYAAEA0h02mz5sgU+eOl47WoOjhmGhOmxSUuDPWo2v9YV+/QVcnX0SXFw775NrK0WmuCgAAAAAAALmOlV0AAKCLqipSWOaRkeOKpLDMk7GgyzBN2dDcmtScuuZWMUwzTRUBAAAAAAAgX+T9yq633npL3bhxo+Wvf/2rpaWlRTlx4oSi6wO7K7yToiiyYcOGUJpKBAAA/WgORc7o0dWfdj0mzaGoVLgdaaoKAAAAAAAA+SBvw67f/va31vvuu0/bunWr5VzOY5qmKEpm7loHACAfGYYpHS1B0SMx0Rw2KSgd/K0NQyn23wrF44NaBwAAAAAAAPJP3oVd8XhcPv/5zzuefPJJm0jPsMrstpXR2QKs/p4HAADv0yMx2V3fJHsbDknYH+067vTaZWLVGJlSUymawzYor+Wypnbvisuadx9lAAAAAAAAMMjy7grRypUrHT//+c9tInJGyNU9wDLP0sOjv+cBAMAp/raQrF+3VQLt4TOeC/ujsr2uURq3H5HapdXiLXad8+uVuxxSqNmS2sqwSLNJuct+zq8NAAAAAACA/KZmu4Bk/PnPf7Y8+uijNkVRRFEU0TRNvvnNb+pvvfVWMBwO+7sHWM8//3woHA77Dx06FPjTn/4UWrVqlV5WVmZ2jpk8ebKxdevWoGEY/kQi4c/WewIAINfokVivQVd3gfawrF+3VfTouW8lqCqKLCgvSWrO/PISUVmpDQAAAAAAMOzlVdh177332kVOrcqyWCzyu9/9LnTPPfdEJ0+ebNjtZ97Zbbfb5bzzzjMXLVqUuO+++6JNTU2B22+/XRcRefvtt9UFCxa46+rqzqnnFwAAQ83u+qZ+g65Ogfaw7NncNCivW1tRJmUObUBjyxyaLKooG5TXBQAAAAAAQH7Lm7ArEAhIXV2dpXNV1/Lly2Mf/vCHk+pmb7fb5d///d+jDz30UMQ0TfH7/XLDDTc4m5ubuS0cAAARMQxT9jYcSmrO3oaDYhjnvj2wy2qRVdMm9Bt4lTk0WTVtgjhT7PMFAAAAAACAoSVvwq7XXnvNkkgkunptffGLX9RTPdeXvvSl2PXXXx8XETlx4oSyevVqGn4AACAiHS1BCfujSc0J+aPS0RoclNcf6bTLnTMmyXWVo6VIs/V4rkizyXWVo+V7MybJSGf+/eo2DUMSx45L/L0Dkjh2XEzDyHZJAAAAAAAAQ4I12wUM1HvvvdcVzI0YMUKmT5/e5xWiaLTvC3WrV6+O/va3v7Wapim/+MUvbI888kjE6XQOUrUAAOQnPRJLbV44tXln47Ja5NrK0XL1uFHSHIpKKB4Xl9Uq5S57XvboMiMR0TduFn1Lg5gd77cJVQq8os2sEm3OLFEcjuzVZxhi+FrEDEdEcTpELSsVRc2b+6EAAAAAAADyJ+xqa2tTREQURZExY8acNeiyWq2SSJza2TASifR5Neyyyy4zRo4caR4/flyJRCKyceNGS21tbVLbIgIAMNRoDlv/g842z5navL6oiiIV7uyFQIPBaG2T4Jq1Yra1n/Gc2eGX6It1om/bLu7ly0QtKc5obbkewgEAAAAAAAxU3ty2G4/Hu/7tdrvP2hjE4/GYndscHjt2rN9bvysqKrrOs2fPnrz5XgAAkC4FpW5xepPbItDltUtBiTtNFeUvMxLpNejqMa6t/dS4SCRDlZ0K4QIPPSbRF+t6BF0i74dwgYceE6O1LWM1AQAAAAAApCpvAp4RI0Z0BVOBQOCsQVZhYWHXv5uamvp9b0a3XhknTpzIv32RAAAYZKqqyMSqMUnNmVg1VlSVX6On0zdu7jfo6mS2tYu+qT7NFf3ttXI4hAMAAAAAAEhF3oRdlZWVpoiIaZrS3t5+1itqEydO7NqG8I033rD0db54PC6NjY2q8rfeH3Z7/jW6BwAgHabUVIqnaGB9LD1FTpk8qzLNFeUf0zBE39KQ1By9fquYRp8tSQdFroZwAAAAAAAAqcqbsGvq1KldQVZzc7Pi9/vPGHPppZcaIqcCsddee81y6NChXm8z/81vfmMNBALSue3heeedl/6rSwAA5AHNYZPapdX9Bl7uQofUfGSKnDjmlxPHA2IYZ91leFgyfC1nbA/YH7PDL4avJU0V/e01cjiEAwAAAAAASFXehF3jx483R40a1XUVbcuWLWes3LruuutiIiKKokg8HpcvfOELjlgsdsa59u/fr3z1q191dK7qEhGZM2dO4oyBAAAMU95ilyy59Qq5bP6F4jqth5fTo8no84vFiJvy0lPb5E8/3SK///Em+c3/e1m2v7xf9MiZv3uHGzOc2tZ/qc4bqFwN4QAAAAAAAM6FNdsFJGP+/PnxX/7ylzYRkWeffda6cOHCHgHVrFmzjEsuucR46623VBGRP/7xj9YZM2a4b775Zn3y5MmGruvKq6++anniiSc0v98vpmmKoigyZ86cxPnnn8/t6AAAdKM5bDJ93gSZOne8dLQGRQ/HJKbHpf653XL0vbYzxof9Udle1yiN249I7dJq8Ra7slB1blCcjozOG6hcDeEAAAAAAADORd6s7BIRuf766+Od//7tb39rM86ypc7DDz/cdTXGNE3ZtWuX+vWvf92xZMkS1/XXX+988MEHtY6Ojq7xNptNfvCDH3AFBwCAXqiqIoVlHikc6ZH653ZLoD3c5/hAe1jWr9sqejTe57ihTC0rFaXAm9QcpcArallpmir622vkaAgHAAAAAABwLvIq7Lr66qvjl112mTF58mTD7XabGzduPGMrw/nz5yceeuihiMip7QwVRRHTNLu+Oo+bpik2m01+/OMfR6644goaUQAA0I/d9U39Bl2dAu1h2bO5Kc0V5S5FVUWbWZXUHK2mWhQ1vR/NcjWEAwAAAAAAOBd5FXY5HA7Ztm1bcNeuXcFdu3YFr7rqqrP22frSl74Ue/7550PTpk0zOgOuTp2hV01NTeKll14Kfe5zn6OxCAAA/TAMU/Y2HEpqzt6Gg2IYw3eXYG3OLFGKiwY0VikuEm12TZoryt0QDgAAAAAA4FzkVc+uZHzoQx9K/PWvfw2+/fbb6uuvv245evSoYpqmlJeXm7Nnz45fdNFFw/fqGwAASepoCUrYH01qTsgflY7WoBSWedJUVW5THA5xL18mwTVrxWxr731ccZG4ly8TxZGZrQK1ObNE37a9z5o6ZSqEAwAAAAAAOBdDNuzqNGnSJGPSpElsUwgAwDnQI6kthNbDw3sBtVpSLJ6VK0TfVC96/VYxO/xdzykFXtFqqkWbXZOxoEskd0M4AAAAAACAVA35sAsAAJw7zWFLbZ4ztXlDieJwiH3hPNEWzBXD1yJmOCKK03Gqf1aWtgfMxRAOAAAAAAAgVYRdAACgXwWlbnF67UltZejy2qWgxJ3GqvKLoqpiGTUy22V0ycUQDgAAAAAAIBVcyQAAAP1SVUUmVo1Jas7EqrGiqkqaKsJg6QzhrOePE8uokQRdAAAAAAAg73A1AwAADMiUmkrxFDkHNNZT5JTJsyrTXBEAAAAAAACQZ9sYbtiwwZKucy9YsCCRrnMDADAUaA6b1C6tlvXrtkqgPdzrOE+RU2qXVotmz6uPGQAAAAAAAMhTeXUVauHChS5FGfztkBRFkXg87u9/JAAAw5u32CVLbr1C9tQfkL0NByXUrYeXy2uXiVVjZfKsSoIuAAAAAAAAZExeXokyTTPbJQAAMGxpDptMnzdBps4dLx2tQdHDMdGcNikocdOjCwAAAAAAABmXd2FXqkHX6SvCCMwAADg3qqpIYZkn22UAAAAAAABgmMursOvb3/52tP9RPYVCIaWlpUXZunWrZffu3arIqeBrwoQJxic+8YnY4FcJAAAAAAAAAACATMmrsOv73/++fi7zd+zYoX7rW9+yP/fcc9Z33nlHbWxsVH/+859HbDbbYJUIAAAAAAAAAACADFKzXUAmTZ8+3XjmmWfCd9xxh26apvzyl7+03XTTTY5s1wUAAAAAAAAAAIDUDKuwq9O9994b/dCHPpToDLzWrVuXVyvcAAAAAAAAAAAAcMqwDLtERL773e9GRURM05Q777zTnu16AAAYSgzDlBPHA3L8QLucOB4QwzCzXRIAAAAAAACGqGG7omn27NmJoqIis729XXnnnXfUrVu3qtXV1Ua26wIAIJ/pkZjsrm+SvQ2HJOyPdh13eu0ysWqMTKmpFM1Br0wAAAAAAAAMnmG7sktEZOzYsV23mTc0NFiyWQsAAPnO3xaSZx5/XbbXNfYIukREwv6obK9rlGcef138baEsVZg9hmnK4WBY9p0MyOFgWAyTlW4AAAAAAACDZdiu7BIRUdX3s77jx48rWSwFAIC8pkdisn7dVgm0h/scF2gPy/p1W2XJiitFsw/9jyGheELWH/bJhuZWOaHHuo4XajZZUF4itRVl4rJyvw0AAAAAAMC5GLYruxKJhLz33ntd79/hcGSzHAAA8tru+qZ+g65OgfawbH1+z5Dv5XU8HJXvbntbnm462iPoEhE5ocfk6aaj8t1tb8vxcLSXMwAAAAAAAGAghv4t1b34/e9/bz1x4kTX4/Lycvp1AQCQAsMwZW/DoaTm7P/LYdn/l8NDtpdXKJ6QB3Y2ii+i9znOF9HlgZ2N8r0Zk8TJCi8AAAAAAICUDMuVXfv27VNuu+02h6K8v3Ph3LlzE1ksCQCAvNXREjyjR9dADdVeXusP+/oNujr5Irq8cNiX5ooAAAAAAACGrmETdsXjcdm2bZt6xx132KuqqjzNzc2KaZqiKIrU1NQkKisrh+4+SgAApJEeifU/qB+dvbz0aHwQKsouwzRlQ3NrUnPqmlvFMPkoAgAAAAAAkIq82sbwggsu8KQyLxwOy4kTJ5RY7NTFuM6QS0TEYrHIAw88QLMMAABSNFjbDwbaw7Jnc5NMnzdhUM6XLc2hyBk9uvrTrsekORSVCjc9RLszDUMMX4uY4YgoToeoZaWiqMPmXi0AAAAAADBAeRV2NTU1KYqiiHkOdz4riiKd57BYLPLoo49GZs+ezRaGAACkqKDULU6vPeWtDLvb23BQps4dL6qq9D84R4XiqX2sCMXzf1XbYDEjEdE3bhZ9S4OYHf6u40qBV7SZVaLNmSWKg2AQAAAAAACckpe3xnYGVsl8dTJNU0zTlOrq6sSrr74avPnmm8997yUAAIYxVVVkYtWYQTlXyB+Vk77AoJwrW1xWS4rz8uoepLQxWtsk8NBjEn2xrkfQJSJidvgl+mKdBB56TIzWtixVCAAAAAAAck1eXVUZO3as2T24GghFUcRut5sFBQXmuHHjzA984AOJJUuWxC+99FIjTWUCADDsTKmplMbtRyTQHj7nc73w5BsyeeY4mVJTOWhbJGZSucshhZotqa0MizSblLvsaawqP5iRiATXrBWzrb3vcW3tElyzVjwrV7DCCwAAAAAA5FfY1dTUlN+3egMAMERpDpvULq2W9eu2nnPgFQ3FZHtdozRuPyK1S6vFW+wapCozQ1UUWVBeIk83HR3wnPnlJaImeUPPUKRv3Nxv0NXJbGsXfVO92BfOS3NVAAAAAAAg1+XlNoYAACD3eItdsuTWK+Sy+ReKy3vuq5QC7WFZv26r6NH862VVW1EmZQ5tQGPLHJosqihLc0W5zzQM0bc0JDVHr98qpsFifQAAAAAAhjvCLgAAMGg0h02mz5sg198+T675x9ly4Qcqzul8gfaw7NncNEjVZY7LapFV0yb0G3iVOTRZNW2COFPs8zWUGL6WM3p09cfs8Ivha0lTRQAAAAAAIF8QdgEAgEGnqooUlnmketEk8RQ5z+lcexsOimGYg1RZ5ox02uXOGZPkusrRUqT17D1WpNnkusrR8r0Zk2Skk15dIiJmOJLReQAAAAAAYOjIq55dAAAgvwxGL6+QPyodrUEpLPMMcnXp57Ja5NrK0XL1uFHSHIpKKB4Xl9Uq5S47PbpOozgdGZ0HAAAAAACGDlZ2AQCAtOrey8vutPU/4Sz0cGyQq8osVVGkwu2Qi0Z4pMLtIOg6C7WsVJQCb1JzlAKvqGWlaaoIAAAAAADkC8IuAACQdp29vGo/c3lq81MMyZA/FFUVbWZVUnO0mmpRVD7OAgAAAAAw3OXENoYXXHBBVvclUhRF3nnnnUA2awAAYDgoHOkRp9cuYX90wHNcXrsUlLjTWBVyhTZnlujbtovZ1t7vWKW4SLTZNRmoCgAAAAAA5LqcCLuampoURVHENLPTfF5hKyEAADJCVRWZWDVGttc1DnjOxKqxoqr8rh4OFIdD3MuXSXDN2j4DL6W4SNzLl4nioF8XAAAAAADIkbCr00BDp85Q7FxCKtM0JZsBGwAAw9WUmkpp3H5EAu3hfsd6ipwyeVZlBqpCrlBLisWzcoXom+pFr98qZoe/6zmlwCtaTbVos2sIugAAAAAAQJecCLvGjh1rJhtcdXR0KCdOnDgjsLJYLOL1esXlcpmhUEjx+/2SSCS6nu98ncLCQrOgoGBw3gAAABgwzWGT2qXVsn7d1j4DL0+RU2qXVotmz4mPK8ggxeEQ+8J5oi2YK4avRcxwRBSnQ9SyUnp0AQAAAACAM+TE1aOmpqak+mU9+eST1q985SvOzqDr0ksvNZYtWxb74Ac/GL/kkksMm+39JvaxWEx27typ1tXVWZ988knbjh071L8FXsr3v//98LJly+KD/HYAAEA/vMUuWXLrFbKn/oDsbTgooW49vFxeu0ysGiuTZ1USdA1ziqqKZdTIbJcBAAAAAAByXN5dQbrvvvu0b33rW3YREY/HI4888kifgZXNZpMZM2YYM2bM0L/2ta/pTz75pHXlypXOkydPymc/+1nnsWPHol//+tf1zL0DAAAgcmqF1/R5E2Tq3PHS0RoUPRwTzWmTghI3PboAAAAAAAAwYHm1D8yGDRss3/rWt+ymaYrL5ZKXXnopmOzKrM985jPxF198MehyucQ0TfnmN79pf/nlly3pqhkAAPRNVRUpLPPIyHFFUljmIegCAAAAAABAUvIq7Prnf/5nu2maoiiKfPe7341WV1cbqZynurra+M53vhMVETEMQ775zW/aB7dSAAAAAAAAAAAAZELehF379+9XtmzZYhE5tTXh5z//+XPaevDWW2/VNU0TEZEtW7ZY9u/fz23kAAAAAAAAAAAAeSZvwq7XX3/dIiKiKIpUVlYaI0aMOKfzFRYWSmVlZdfKsM7zAwAAAAAAAAAAIH/kTdh16NChrlq9Xu+gnLP7ebqfHwAAAAAAAAAAAPnBmu0CkmWaphw+fHhQthwcrPMAAABg6DMNQwxfi5jhiChOh6hlpaKo3C8FAAAAAEC25U3YNWbMmK4tB48fP640NDSoVVVVRl9z+vLGG2+ox44dUxTlVN5VUVGR8rkAAAAwdJmRiOgbN4u+pUHMDn/XcaXAK9rMKtHmzBLF4chihQAAAAAADG95E3bNmDHDEDnVs0tE5I477nC8+OKLoVTP98///M8OkVMrxRRFkXMJzoaCRCIh+/btU3fs2KEeOXJE6ejoUJxOp5SUlJhTpkxJVFVVGZqmDeprtrS0KK+++qpl//79ajAYFLfbLRdeeKExd+7cRGlpqTmoLwYAAJACo7VNgmvWitnWfsZzZodfoi/Wib5tu7iXLxO1pDgLFQIAAAAAgLwJuy655BLjkksuMd566y3VNE3ZsGGD5dZbb3U8+uijETWJ7WMMw5AvfOELjj//+c+WzuCs89zpqj1XHTlyRPnVr35lXb9+vfXVV1+1dnR09DrW6XTKddddF/vqV7+qV1dXn9P3atu2beq//Mu/2P/4xz9aDePMU1ksFlm8eHH8rrvuil522WXD7r8LAADIDWYk0mvQ1WNcW7sE16wVz8oVrPACAAAAACAL8qrJwF133RXtXIllmqasWbPGVlVV5X7uuecsZwtNujMMQ5599lnLjBkz3GvWrLF1nkNE5Pvf/340E/XnkiVLljjHjh3ruf322x3PPvtsn0GXiEg4HJannnrKVlNT4/7qV79qj0ZT+5b927/9m1ZTU+N+9tlnzxp0iZxaZfbss89aL7/8cveDDz5oS+mFAAAAzpG+cXO/QVcns61d9E31aa4IAAAAAACcTd6s7BIRufbaa+M333xz7Cc/+UlXWLV9+3b16quvdo0cOdK88sorE5dcckmipKTEdLlcEgqFpKWlRdm1a5fltddes/h8PqUz4Opc1XXTTTfFrr322ng231c2vP7662cNCG02m5SXl5ulpaVmJBKR9957Tw2F3t8t0jAM+X//7/9p+/btU59++umwzTbwLOr+++/X7rjjDvvpx0ePHm2Wl5ebzc3NytGjR5XO4/F4XL72ta85TNNUvva1r+lJv0kAAIAUmYYh+paGpObo9VtFWzBXlCR2HQAAAAAAAOcur8IuEZHHH388IiLSGXiJnOq7dezYMeV3v/ud9Xe/+91Z39PpIZdpmvLZz3429sQTT0QyUngOGzlypPnpT3869pGPfCQ+Z86chNPp7HpO13V57rnnrKtXr7bv2rWr68rNs88+a/3GN75hf/DBBwe0xOvVV1+1fOtb3+oRdF111VWJH/7wh5HLL7+8K3Wrr69XV61a5Xj11VctncfuuOMO+xVXXBG/4oor2NIQAABkhOFrEbPDn9Qcs8Mvhq9FLKNGpqkqAAAAAABwNnl326mqqvLEE09E1q5dGy4tLTU7tzXsDLFETgVZnV+duodcJSUl5s9//vPwT37yk6T6fQ01F198sfGLX/wifOjQocC///u/R2tra3sEXSIimqbJxz/+8fgbb7wR/MhHPtJjBdyPfvQjbc+ePQP6Bn7jG9+wJxKJrscf/ehH4y+88EKoe9AlIlJTU2OsX78+tHjx4q7Xisfj8o1vfIMGGAAAIGPMcGr3Q6U6DwAAAAAApC5vk55Pf/rT8f379wcefvjhSFVVVaJzW8PuAZfI+8GXoihSVVWVePjhhyONjY2BZcuWDbutC7v7r//6r8iOHTuCN954Y3wgWxE6nU753//933BFRUXXNzgWi8lPf/rTfic/88wzls2bN3et1CouLjZ/8pOfROz2M3Y0FBERu90uP/3pTyPFxcVdr7Vx40bLn/70J8tZJwAAAAwyxZnafTapzgMAAAAAAKnLu20Mu/N6vfKlL30p9qUvfSkWCATkjTfesLz77rtqe3u7EggExO12S2FhoTlhwgTj8ssvT3g8nmyXnDOuv/76pMM+j8cjX/rSl/Tu2xGuX7/eet999/W5leETTzyhdX/8hS98ITZq1Cizt/Eip/p4rVixInbvvfd2zX3iiSe0xYsXh5OtGwAAIFlqWakoBd6ktjJUCryilpWmsSoAAAAAAHA2eR12defxeGTBggWJBQsWJPofjVRdddVVPb6/Bw8eVHobKyISiUTkxRdf7PFzdsstt+gDea1bbrlF7x52vfDCC9ZoNCq9rQgDAAAYLIqqijazSqIv1g14jlZTLcow3iIbAAAAAIBs4a9xJKX71oIiIh0dHX2GXX/+858twWCw6/FFF11kXHDBBX2u6uo0fvx488ILL+zq6eX3+2XDhg1sZQgAADJCmzNLlOKiAY1ViotEm12T5ooAAAAAAMDZEHYhKYcOHeoRbp0efp3uL3/5S49w6oorrkhq5d3p408/HwAAQLooDoe4ly/rN/BSiotOjXPQrwsAAAAAgGwYMtsYIjNeeeWVHmHTRRddZPQ2VkRkz549PQLVKVOm9Dn+dKePP/18AAAgMwzTlOZQRELxhLisFil3OURV+lzgPSSoJcXiWblC9E31otdv7dHDSynwilZTLdrsGoIuAAAAAACyiLALAxaPx+W///u/te7HFi9eHO9rzt69e3uEU+PGjUsq7Dp9/OnnAwAA6RWKJ2T9YZ9saG6VE3qs63ihZpMF5SVSW1EmLuvQXnitOBxiXzhPtAVzxfC1iBmOiOJ0iFpWSo8uAAAAAAByQE6EXT/96U9tpx/73Oc+FxvIuMFyttdDT//5n/9pe/fdd7tu4bbZbLJ06dI+v28+n6/HFaAxY8YMqF9Xp4qKih7jfT7f0L+FHACAHHE8HJUHdjaKL6Kf8dwJPSZPNx2VjcfaZNW0CTLSac9ChZmlqKpYRo3MdhkAAAAAAOA0ORF2LV++3KGctg3O2cKns40bLIRdfdu3b5+yevXqHvvzfOELX9DHjRvXZ3gVCAR6PHa73UmFXaePDwQCg/YDcPToUSXZ8Gzfvn3cvg0AGBZC8USvQVd3voguD+xslO/NmCTOIb7CCwAAAAAA5KacCLu6M01T+gu0TDOpvKRXiqIM6PWGu2AwKH/3d3/n8vvf71Exbtw486677ooOYG6Pb67T6UzqtV0uV5/nOxePPPKIdvfdd2v9jwQAYPhZf9jXb9DVyRfR5YXDPrm2cnSaq0JvTMNgi0UAAAAAwLCVM2HXQAOswQq6BvtcQ5VhGLJs2TLnjh07uq6WWK1WWbt2bbigoKDf+ZFIpMdjTdOS+qbb7fYe48PhcDLTAQBACgzTlA3NrUnNqWtulavHjRKVm4gyyoxERN+4WfQtDWJ2vH9jklLgFW1mlWhzZonicPRxBgAAAAAA8l9OhF1PPPFEpP9RAx+X62677Tb7I488kvYVRd/+9rf1gay+6stXv/pV+9NPP93j5+Tf/u3fIldddVViIPMdDoeEQqGux7quKyIy4MArGo32uGLm4GINAABp1xyKyAk9uR2e2/WYNIeiUuHmd3WmGK1tElyzVsy29jOeMzv8En2xTvRt28W9fJmoJcVZqBAAAAAAgMzIibDr5ptvHtDVlIGOw+C46667tIceeqhHKPftb39bX7ly5YD/O7jdbjMUCnUFVsmuzOoelHWeL6kT9OHLX/6yfuONNyb1M7Vv3z71hhtuSG4vRgAA8kwoPqB7Ws4yLz7IlaA3ZiTSa9DVY1xbuwTXrBXPyhWs8AIAAAAADFk5EXYh9/zoRz+yfec737F3P/alL30p6ZViHo9HfD5f1+Nke26dPt7j8SQzvU+jR482R48ezV6WAACcxmW1pDiPj5aZom/c3G/Q1clsaxd9U73YF85Lc1UAAAAAAGQHVySy4GMf+1i8pKQk7SHLvHnzUrote+3atdaVK1f2uPV36dKlsYceeijpLRHLysqMd999t+uK2aFDh5IKuw4fPtxjfFlZmZFsDQAAIDnlLocUaraktjIs0mxS7rL3PxDnzDQM0bc0JDVHr98q2oK5oqhq/4MBAAAAAMgzhF1ZsHjx4sTixYtT2x8ozX77299ab775ZqdhvJ8pffzjH4//9Kc/jagpXByZOHGisWXLlq6wq6mpKamTnD5+0qRJhF0AAKSZqiiyoLxEnm46OuA588tLRFWSuqcFKTJ8LWJ2+JOaY3b4xfC1iGXUyDRVBQAAAABA9nBrJ7o8//zzlk996lPOeLd+Gx/60IcSv/jFL8LWFLclOj2c2r17d1I/c3v27CHsAgAgC2oryqTMofU/UETKHJosqihLc0XoZIYjGZ0HAAAAAECuG/Iru4LBoPzsZz+zbdq0ydLS0qIWFRWZM2bMSCxdujRWUVFBv6a/eeWVVyzXX3+9Kxp9f6fC2bNnJ/7v//4vZLenviXRBz7wgR4r2DZv3pxUE5DXX3+9x/jTzwcAGJoMw5SOlqDokZhoDpsUlLpFVVk1lEkuq0VWTZsgD+xsFF9E73VcmUOTVdMmiDPFPl9InuJ09D9oEOcBAAAAAJDr8irs2rVrl/rf//3fts7Ht9xyiz5+/PheA6tXXnnF8g//8A9On8/X4+rYr3/9a+tdd91lv//++yNf/OIXB96MYoh644031GuuucYVCoW6js2YMcN49tlnQy6X65zO/cEPfjDhdrslGAyKiMi+ffvUd999V7ngggv6DRrfeecdZf/+/V0ru7xer3zwgx8k7AKAIUyPxGR3fZPsbTgkYf/7N2A4vXaZWDVGptRUiuaw9XEGDKaRTrvcOWOSrD/sk7rmVmnv1sOrSLPJ/PISWVRRRtCVYWpZqSgF3qS2MlQKvKKWlaaxKgAAAAAAsievwq7//M//tD366KOaiMjIkSPNO++8M9rb2H379ilXX321y+8/dRFA6dZDwjRNCQaD8uUvf9mhKIp84QtfGLaB15tvvql+5CMfcZ08ebLr2MUXX2w8//zzoREjRpzz+Z1OpyxcuDD++9//vutn7YknntDuvvvuXv/bdR/X/XFtbW38XFaZAQBym78tJOvXbZVAe/iM58L+qGyva5TG7Uekdmm1eIvP7WYMDJzLapFrK0fL1eNGSXMoKqF4XFxWq5S77PToyhJFVUWbWSXRF+sGPEerqRYlhf6rAAAAAADkg7z6i/ePf/yjzTRPLQj65Cc/GbPZer+z+ytf+YrD7/eLoiiiKIqYptn1JSJdx77+9a87mpqahuWVmsbGRmXRokWu1tbWrvc/YcIEY/369aHS0tJB2+Jx+fLlPcLERx991Hbs2LE+v+dHjx5VHnvssR7/gZcvX977HkoAgLymR2K9Bl3dBdrDsn7dVtGj8T7HYfCpiiIVbodcNMIjFW4HQVeWaXNmiVJcNKCxSnGRaLNr0lwRAAAAAADZkzdh19GjR5X33ntP6Vyh9bGPfazXq1xvvvmm+qc//cnaGWgVFxebjz76aGTXrl3Burq60JIlS+KmaYqiKBIOh+UHP/jBsFsudOjQIaW2ttbd3NzcdaVq7Nix5osvvhg677zzBrWX2TXXXBOfOXNm1/aDbW1tys033+zQ9bNnV9FoVG6++WZHW1tbV22zZ89OfPSjH2ULQwAYonbXN/UbdHUKtIdlz+amNFcE5DbF4RD38mX9Bl5KcdGpcQ76dQEAAAAAhq682cZw165dqsipLQhVVZWamppeg4+1a9faOscqiiK/+c1vwldddVVCRGTKlCly1VVXhT/4wQ+66urqLCIiv/rVr6yPPPKIWCzDo99EMBiURYsWud59992uMMlisciqVauib7/9tvr2228ndb6rrroq4XQ6+xxz//33Rz/4wQ+6DMMQEZHnnnvOWltb6/rhD38Yufzyy43OcVu2bFG//vWvO1599dWu/xgWi0Xuu+++frc9BADkJ8MwZW/DoaTm7G04KFPnjhdVZXURhi+1pFg8K1eIvqle9PqtPXp4KQVe0WqqRZtdQ9AFAAAAABjy8ibsevfdd7tWoVVUVJgej6fXsc8//7xV5NRWhVdeeWWiM+jq7rvf/W60rq7OJSLS3t6u7Nq1S50+fbpx+rih6NixY8ru3bt7rOpLJBKycuXKlK6ENDY2BsaPH9/narB58+Ylvv/970e//e1vd62ie+WVVywzZ850l5eXm6NHjzabm5uVo0ePnnHV8p577onOnj2bVV0AMER1tAQl7E/unoaQPyodrUEpLOv98wAwHCgOh9gXzhNtwVwxfC1ihiOiOB2ilpXSowsAAAAAMGzkTdjV3t6uiJwKsIqKinoNVtra2mTnzp1q53aH119/fexs4+bOnZvweDwSCARERGTHjh3DJuzKlm9961u6xWKRb3/72/ZE4v3sqrm5Wem+nWIni8UiP/jBD6Jf//rX6dUFAEOYHjnrr+r+54VTmwcMRYqqimXUyGyXAQAAAABAVuTN7Z6hUKjr306ns9ew67XXXrOYpimmeWrI4sWLz7oiSFVVqays7Aq3jh8/njffi3x2xx136PX19cHFixfH1V7uNlZVVT7ykY/Et2zZEiToAoChT3PYUpvnTG0eAAAAAAAAhpa8Wdllt3ftfifBYLDXBh0vv/xy13sqKSkxp0yZ0utqLbfb3RWada7wGg7Gjx9vmqbp739kelRVVRl//OMfwz6fT3nllVcsjY2NajAYFLfbLRdeeKExd+7cRFlZWZ/bIgIAho6CUrc4vfaktjJ0ee1SUOJOY1UAAAAAAADIF3kTdhUWFpoiIqZpyoEDB3pdhfXnP/+5R7+uvs7ZPTTTNG2wSsUAlZWVmTfccEM823UAALJLVRWZWDVGttc1DnjOxKqxoqq93vsCAAAAAACAYSRvtu6bPHly1wotv98vW7duPaP2xsZG5S9/+UtXv6558+b1GaS0trZ2XSUbMWIEK4kAAMiSKTWV4ilyDmisp8gpk2dVprkiAAAAAAAA5Iu8CbuqqqoSmqZJZ5D1gx/8wH76mAceeMAuIl39uj784Q/3urKrtbVVjh49qnSe7/zzz+91u0MAAJBemsMmtUur+w28PEVOqV1aLZo9bxanAwAAAAAAIM3yJuzyer3y4Q9/OG6appimKU8//bT1pptucmzevFltaGhQv/rVr9off/xxm6IooiiKTJ8+3bj44ot7DbDq6+stIu8HY91XjgEAgMzzFrtkya1XyGXzLxSXt+c9LS6vXS6bf6EsWXGluAudcuJ4QI4faJcTxwNiGCzOBgAAAAAAGM7y6rbo1atXR5999llrZ+C1bt0627p162zdx5imKYqiyKpVq/rscv9///d/XfNGjhxpXnDBBVwpAwAgyzSHTabPmyBT546Xjtag6OGYaE6bFJS4Ja7HZffm92RvwyEJ+9//Ne/02mVi1RiZdPk4iQR00SMx0Rw2KSh109cLAAAAAABgGMirsOvyyy83/vVf/zX6L//yL/bO7Qc7V2Z1rugyTVM++tGPxj/1qU/12q8rHo/L7373O2vnOa688spetzsEAACZp6qKFJZ5uh7720Kyft1WCbSHzxgb9kdle12j7Hi5Ucxut650hmBTaipFc9jOmAcAAAAAAIChIW+2Mey0evVq/cc//nGksLDQNLtd0TJNU1RVlZtvvjn2q1/96swrYd089dRTVp/Pp3TO/9jHPtZrMAYAALJLj8R6Dbq6M09bo90Zgj3z+OvibwulsUIAAAAAAABkU16t7Oq0YsWK2Gc/+9nY+vXrLW+//bYlHA5LRUWFuXDhwvi4ceP63Y5wz549liVLlnQFXNdccw1hFwAAOWp3fVO/QVdfAu1hWb9uqyxZcaVo9rz86AMAAAAAAIA+5O0VH7vdLkuWLEksWbIk6S0I77nnnj77eQEAgNxgGKbsbTh0zucJtIdlz+YmmT5vwiBUBQAAAAAAgFySd9sYAgCA4aOjJShh/+Dco7K34aAYRr8LwAEAAAAAAJBnCLsAAEDO0iOxQTtXyB+VjtbgoJ0PAAAAAAAAuYGwCwAA5CzNYRvU8+nhwQvPAAAAAAAAkBvytmdXJ8MwZMuWLeorr7xi3bNnj9rW1qacPHlSMU1TfvjDH0aqq6uNbNcIAABSU1DqFqfXPmhbGWrOwQ3PAAAAAAAAkH15G3bpui4PP/yw9sgjj2gHDhxQuj9nmqYoiiLt7e3K2ebecsstjpdeeskqIjJu3Djj5ZdfDmWiZgAAkBxVVWRi1RjZXtd4zudyee1SUOIehKoAAAAAAACQS/JyG8O9e/cqNTU17m984xv2pqYmxTTfbzbf/d+9ufHGG2NNTU1KU1OTsnHjRstrr71mSWe9AAAgdVNqKsVT5Dzn80ysGiuqetb7YAAAAAAAAJDH8i7s2r9/vzJ37lz3jh071M4VXCKnQq7uj/tSW1ubuOiii7q2N/zlL3+ZtyvcAAAY6jSHTWqXVp9T4OUpcsrkWZWDWBXykWGacjgYln0nA3I4GBZjADdJAQAAAACA3JdXIU80GpWPfvSjLp/Pp3SGWuPGjTNXrlwZXbx4cWLcuHGG1+v1DiTwuu666+L333+/JiLywgsvWEVkcJqBAACAQectdsmSW6+QPfUHZG/DQQl16+GlKCJ9ZRaeIqfULq0WzZ5XH3swiELxhKw/7JMNza1yQo91HS/UbLKgvERqK8rEZWWhPwAAAAAA+Sqvrvo8/PDD2v79+9XOMOuaa66JP/XUU2GXy5X0uT760Y/G77//fs00Tdm7d6/a0tKilJaWcnsvAAA5SnPYZPq8CTJ17njpaA2KHo6J5rSJw63J3jcOnhGCubx2mVg1VibPqiToGsaOh6PywM5G8UX0M547ocfk6aajsvFYm6yaNkFGOu1ZqBAAAAAAAJyrvLry8/DDD2udQddll11m/O///m9Y07SUzjVjxoyEoihdPb7efPNNdf78+YlBKxYAAKSFqipSWObpcexsIVhBiVtUVRHDMOXE8YDokZhoDpsUlLrp3TVMhOKJXoOu7nwRXR7Y2SjfmzFJnKzwAgAAAAAg7+RN2LVr1y714MGDioiIoihy1113RVINukREPB6PnHfeeebhw4cVEZH9+/cTdgEAkMdOD8H0SEx21zfJ3oZDEu624svptcvEqjEypaZSNIctG6UiQ9Yf9vUbdHXyRXR54bBPrq0cneaqAAAAAADAYFOzXcBAbdu2ratWj8cjixYtOudgqrCwsGvbwhMnTnCLNwAAQ4S/LSTPPP66bK9r7BF0iYiE/VHZXtcozzz+uvjbQlmqEOlmmKZsaG5Nak5dc6sYfTWAAwAAAAAAOSlvwq7jx4+rIqdWdVVWVhoWy7lvMeNyubquZoRCXOwCAGAo0CMxWb9uqwTaw32OC7SHZf26raJH4xmqDJnUHIrICT2W1Jx2PSbNoWj/AwEAAAAAQE7Jm7ArEol0/dtutw/KLbcnT57sWs1VUFDAbbwAAAwBu+ub+g26OgXaw7Jnc1OaK0I2hOKpbQIQihN+AgAAAACQb/Im7CorK+sKo1pbW8+57ng8LocPH+46T/fzAwCA/GQYpuxtOJTUnL0NB8Uw+Bgw1Lisqe0C4LLmTUtbAAAAAADwN3kTdp133nmGiIhpmnLgwAHlxIkT53S+LVu2WILBYNfjiRMnGud0QgAAkHUdLcEzenT1J+SPSkdrsP+ByCvlLocUarak5hRpNil32dNUEQAAAAAASJe8CbvmzJmTsFqtoiiKmKYpv/zlL5O7enGaxx57rGv+iBEjzMsvv5ywCwCAPKdHkuvR1DUvnNo85C5VUWRBeUlSc+aXl4iqKP0PBAAAAAAAOSVvwq7CwkKZNWtWwjRNMU1T7r//fnv3lVnJ2LRpk+V//ud/bIqiiKIo8uEPf5jmDAAADAGaI7V7YTTnOd1DgxxVW1EmZQ5tQGPLHJosqihLc0VDm2kYkjh2XOLvHZDEseNiGtxLBgAAAADIjLxqSvC1r31N37hxo1NRFHnvvfeUT37yk85f//rXYU0b2EUMEZGGhgb17//+752JREJM0xRVVeWf//mf9TSWDQAAMqSg1C1Orz2prQxdXrsUlLjTWBWyxWW1yKppE+SBnY3ii/T+ca/MocmqaRPEmWKfr+HOjERE37hZ9C0NYnb4u44rBV7RZlaJNmeWKA5HZmsyDDF8LWKGI6I4HaKWlYqi5s19fgAAAACAJOVV2PXxj388Pnfu3MSrr75qURRFnn32WevMmTPd999/f2TRokWJvuYePHhQeeihh7Qf//jHWigUEhERRVHkE5/4RGz69OncdgoAwBCgqopMrBoj2+saBzxnYtVYUVW2rhuqRjrtcueMSbL+sE/qmlulXX9/y8oizSbzy0tkUUUZQVeKjNY2Ca5ZK2Zb+xnPmR1+ib5YJ/q27eJevkzUkuK015OLwRsAAAAAIP0U0zQ7sl1EMo4dO6bMmjXLfeDAAUVExDRNURRFRo0aZV522WWJP/3pT1aRU0HWVVddlXA4HGZjY6Pa2Niodh9vmqZMnTrV2Lx5c9DlcmXzLSGP7Ny5U50+fXrX7f9vvvmmXHLJJdksCQBwGj0Sk2cef10C7eF+x3qKnLJkxZWi2fPq/h+kyDBNaQ5FJRSPi8tqlXKXnR5d58CMRCTw0GNnDbpOpxQXiWflirQGTX0Fb93ryFTwBgAAAADDza5du2Tq1Kldj3fs2BGcNm1aRhYb5d1eHqNGjTL/9Kc/hS666CKje3B19OhR5fnnn++6UmWaprzyyiuWF154wbp//361s9dX5/hLL73UePbZZ0MEXQAADC2awya1S6vFU+Tsc5ynyCm1S6sJuoYRVVGkwu2Qi0Z4pMLtIOg6R/rGzQMKukREzLZ20TfVp60WMxLpN+jqrCO4Zq2YkUjaagEAAAAAZF7ehV0iIpMmTTK2bdsWvOWWW2IWy6ktZ5S/XaxQFKXrq1P3xxaLRW655ZbYa6+9Fhw7dqyZ+eoBAEC6eYtdsuTWK+Sy+ReKy2vv8ZzLa5fL5l8oS1ZcKd5ibnoBUmEahuhbGpKao9dvFdNIzw19uRS8AQAAAAAyL29vZXa5XPL4449HVq9eHX3ooYe0559/3vrWW2+ppnn2/GrChAnGokWL4l/72tf0CRMmEHIBADDEaQ6bTJ83QabOHS8drUHRwzHRnDYpKHHTows4R4avpUdPrIEwO/xi+FrEMmrkoNaSavCmLZgripqX9/4BAAAAAE6Tt2FXp3Hjxpk//OEPoz/84Q+j7e3tsnv3bktra6ty4sQJcblcUlpaao4fP95gFRcAAMOTqipSWObJdhnAkGKGU9sGMNV5fcml4A0AAAAAkB15E3Z1dHTIO++803Xr5ZgxY8zS0tIeAVZRUZFceeWVicxXBwAAAAwfitOR0Xl9yaXgDQAAAACQHXmzb8e6detsVVVV7s6vffv2sf8QAAAAkAVqWakoBd6k5igFXlHLSge9llwK3gAAAAAA2ZE3YVdLS4timqaYpiklJSXmFVdckZ7u1gAAYMgzDFNOHA/I8QPtcuJ4QAyD3Y6BZCiqKtrMqqTmaDXVaemRlUvBGwAAAAAgO/JmG8PCwkJTRERRFBkzZgxXpAAAQNL0SEx21zfJ3oZDEvZHu447vXaZWDVGptRUiuawZbFCIH9oc2aJvm27mG3t/Y5ViotEm12Tljo6g7foi3UDnpOu4A0AAAAAkB158xdeRUVFV8Cl63o2SwEAAHnI3xaSZx5/XbbXNfYIukREwv6obK9rlGcef138baEsVQjkF8XhEPfyZaIUF/U9rrjo1DhH+rYN1ObM6reO7vWkK3gDAAAAAGRH3oRdl156aUJExDRNOXTokJpIJLJdEgAAyBN6JCbr122VQHu4z3GB9rCsX7dV9Gg8Q5UB+U0tKRbPyhVir11wxlaCSoFX7LULxLNyhaglxWmtI5eCNwAAAABA5uXNNoYXXnihWV1dndi6davF7/fLSy+9ZFm0aBGJFwAA6Nfu+qZ+g65Ogfaw7NncJNPnTUhzVcDQoDgcYl84T7QFc8XwtYgZjojidJzqpZXBrQI7gzd9U73o9VvF7PC/X2OBV7SaatFm1xB0AQAAAMAQlDdhl4jIl770pdjnPvc5i4jI6tWr7QsXLgxZLJZslwUAAHKYYZiyt+FQUnP2NhyUqXPHi6oqaaoKGHoUVRXLqJHZrSFHgjcAAAAAQGbl1V98N910U+yaa66Jm6YpDQ0Nlk9+8pPOSCSS7bIAAEAO62gJntGjqz8hf1Q6WoNpqghIL8M05XAwLPtOBuRwMCyGafY/aYjpDN6s548Ty6iRBF0AAAAAMMTl1couEZFf/vKX4c985jPOX/3qV9bf/OY31m3btrm/+c1v6p/4xCdiHo8n2+UBAIAco0diqc0LpzYPyJZQPCHrD/tkQ3OrnNDf//kt1GyyoLxEaivKxGVlVwQAAAAAwNCTV2HXTTfd5BARcTgc5siRI83jx48r77zzjrpixQrHP/7jPzomTpxonH/++UZBQYFps9kGfF5FUeRnP/sZS8QAABiCNMfAPxP0mOdMbR6QDcfDUXlgZ6P4IvoZz53QY/J001HZeKxNVk2bICOd9ixUCAAAAABA+uRV2LV27VqborzfO6Pz36ZpSjwel7feekvdvXt3UnuUmKZJ2AUAwBBWUOoWp9ee1FaGLq9dCkrcaawKGDyheKLXoKs7X0SXB3Y2yvdmTBInK7wAAAAAAEPIkNi8XlGUri8AAIDuVFWRiVVjkpozsWqsqCqfK5Af1h/29Rt0dfJFdHnhsC/NFQEAAAAAkFl5F3aZpjmoXwAAYOibUlMpniLngMZ6ipwyeVZlmisCBodhmrKhuTWpOXXNrWLwORgAAAAAMITk1TaGjY2NgWzXAAAA8o/msEnt0mpZv26rBNrDvY7zFDmldmm1aPa8+oiEYaw5FJETeiypOe16TJpDUalwO9JUFQAAAAAAmZVXV3IuuOACbkEFAAAp8Ra7ZMmtV8ie+gOyt+GghLr18HJ57TKxaqxMnlVJ0IW8EoonUpwXH+RKAAAAAADIHq7mAACAYUNz2GT6vAkyde546WgNih6Oiea0SUGJmx5dyEsuqyXFefwZAAAAAAAYOvgrFwAADDuqqkhhmSfbZQDnrNzlkELNltRWhkWaTcpd9jRWBQAAAABAZqnZLgAAAABAalRFkQXlJUnNmV9eIqrCSkYAAAAAwNBB2AUAAADksdqKMilzaAMaW+bQZFFFWZorAgAAAAAgswi7AAAAgDzmslpk1bQJ/QZeZQ5NVk2bIM4U+3wBAAAAAJCrciLs+qd/+id7e3t7tsvo0t7eLv/0T/9EIwMAAADkhZFOu9w5Y5JcVzlaijRbj+eKNJtcVzlavjdjkox08hEXAAAAADD0KKZpdmS7CFVVvYWFhXL77bdHb7vtNr2oqCgrdZw4cUL+4z/+Q/uP//gP+8mTJyWRSPizUghy1s6dO9Xp06e7Ox+/+eabcskll2SzJAAAgB4M05TmUFRC8bi4rFYpd9np0QUAAAAASLtdu3bJ1KlTux7v2LEjOG3aNCMTr50TK7tERE6ePCl33nmnvbKy0nv77bfb33777YzVtmfPHnXlypX2cePGeb/3ve/ZT5w4kamXBgAAAAaVqihS4XbIRSM8UuF2EHQBAAAAAIa8nAi75s+fnzBNU0zTlEAgIA8//LB28cUXu6+66irXY489ZvP5fIP+F7rP51MeffRR29y5c12XXHKJ+0c/+pEWCATENE0REVmwYEFisF8TAAAAAAAAAAAAg8ua7QJERP785z+HfvWrX1nvuOMOx3vvvaeIiJimKZs2bbJs2rTJ8uUvf1lqamoS8+bNS8yfPz8+c+bMxIgRI5J6jfb2dnnjjTcsL7/8svXll1+21NfXWwzj1Oq5zoBLROT8888377///sjf/d3fxQfxLQIAAAAAAAAAACANcqJnVydd1+XRRx+13X///fYjR44oIiKKoohpmqKctv3KeeedZ1500UXGmDFjjNGjR5sej8d0Op1imqZEIhHx+/3K0aNHlUOHDqn79u1Tm5ube5yg85ydQdd5551n3nHHHdEVK1bENE3L1FtGnqFnFwAAAAAAAAAAZ8pmz66cWNnVSdM0WblyZezWW2+N/exnP7P96Ec/0nbt2tVjq8XOcOrw4cPKkSNHLCJi6e+83VdudQ/NTNOUiy++2Ljtttv0z372szG73T5YbwUAAAAAAAAAAAAZkBM9u07ncDjkC1/4Qmznzp3BDRs2hG6++ebYiBEjzN5CK5FTwVX3r+5OD7hGjBhh3nzzzbENGzaE3nzzzeCKFSsIugAAAAAAAAAAAPJQTq3sOpt58+Yl5s2bl/jxj38sGzdutPzpT3+ybtq0ybJjxw5LIBDodV73wMvtdsull16amD17dmLx4sXxOXPmJGw2WybKBwAAAAAAAAAAQBrlfNjVyWazyYIFCxILFixIiIgYhiGNjY3KO++8ox44cEA9efKkEgqFRETE5XJJYWGhOW7cOOOCCy4wJkyYYKpqTi5iAwAAAAAAAAAAwDnIm7DrdKqqykUXXWRedNFFCRFJZLseAAAAAAAAAAAAZB7LnQAAAAAAAAAAAJC38nZlFwAAAIDhxTBNaQ5FJBRPiMtqkXKXQ1RFyXZZAAAAAIAsI+wCAAAAkNNC8YSsP+yTDc2tckKPdR0v1GyyoLxEaivKxGW1ZLFCAAAAAEA2EXYBAAAAyFnHw1F5YGej+CL6Gc+d0GPydNNR2XisTVZNmyAjnfYsVAgAAAAAyDZ6dgEAAADISaF4otegqztfRJcHdjZKOJ7IUGUAAAAAgFwyJFZ2vfXWW+qBAweUkydPKuFwWDFNM+lzfO5zn4v1PwoAAABApqw/7Os36Orki+jywmGfXFs5Os1VAQAAAAByTd6GXc8995zl8ccf11566SVrKBQ65/MRdgEAAAC5wzBN2dDcmtScuuZWuXrcKFEVJU1VAQAAAAByUd6FXe3t7fKZz3zG+dxzz1lFRFJZxdVJURQxTVMU/hgGAAAAckpzKCIn9OTuR2vXY9IcikqF25Gmqs6NaRhi+FrEDEdEcTpELSsVRWVneQAAAAA4V3kVdgWDQVm0aJFr27Ztls6QqjOwSsW5BGUAAAAA0ieUYv+tUDw+yJWcOzMSEX3jZtG3NIjZ4e86rhR4RZtZJdqcWaI4cjOgAwAAAIB8kFdh11133WVvaGiwdA+5HA6HLFy4MH7ppZcaI0eONDweT7bLBAAAAHCOXFZLivNy608co7VNgmvWitnWfsZzZodfoi/Wib5tu7iXLxO1pDgLFQIAAABA/sutvwT7EI1G5ZFHHtG6r+S6+eabYw888ECkqKgoy9UBAAAAGEzlLocUaraktjIs0mxS7rKnsarkmJFIr0FXj3Ft7RJcs1Y8K1ewwgsAAAAAUpA3G8S/8sorlmAwKCKnem195jOfiT3xxBMEXQAAAMAQpCqKLCgvSWrO/PISUXOoH6++cXO/QVcns61d9E31aa6oj9c3DEkcOy7x9w5I4thxMQ0ja7UAAAAAQLLyZmXXvn37VJFTfbZUVZV77rknmu2aAAAAAKRPbUWZbDzWJr6I3u/YMocmiyrKMlDVwJiGIfqWhqTm6PVbRVswVxQ1c/ck0k8MAAAAwFCQNyu7WltbFZFTq7rGjx9vnHfeeWa2awIAAACQPi6rRVZNmyBlDq3PcWUOTVZNmyDOFPt8pYPha+kRHg2E2eEXw9eSporOZLS2SeChxyT6Yt0ZtXb2Ews89JgYrW0ZqwkAAAAAUpE3YZfT6ez6d1FREUEXAAAAMAyMdNrlzhmT5LrK0VKk2Xo8V6TZ5LrK0fK9GZNkpDN3enWJiJjhSEbnJf06SfYTMyOZqQsAAAAAUpE32xhedNFFXZvGt7W15c5G/AAAAADSymW1yLWVo+XqcaOkORSVUDwuLqtVyl32nOrR1Z3iTG3rv1TnJSuVfmL2hfPSXBUAAAAApCZvVnbNnz8/rmmamKYp7733ntrWxlYaAAAAwHCiKopUuB1y0QiPVLgdORt0iYioZaWiFHiTmqMUeEUtK01TRe9LtZ+YaRj9DwQAAACALMibsGvEiBFy4403xkREDMOQn/3sZ31v3A8AAAAAWaKoqmgzq5Kao9VUi6Km/0+0fOgnBgAAAADJyJuwS0Tk3nvvjXb267rnnnu0d955J3dv5QQAAAAwrGlzZolSXDSgsUpxkWiza9Jc0Sm53k8MAAAAAJKVV2HXeeedZ/7mN78JO51OaWtrUz70oQ+5t27dmlfvAQAAAMDwoDgc4l6+rN/ASykuOjXOkZl+XbneTwwAAAAAkpV3QdH8+fMTGzZsCF5wwQXme++9p1x55ZXuG2+80fmb3/zGeuDAASUajWa7RAAAAAAQERG1pFg8K1eIvXbBGT28lAKv2GsXiGflClFLijNXUw73EwMAAACAVFizXUAyLBZLj7/IFEWReDwuv/71r62//vWvU34vfztPcpvWAwAAAMAAKA6H2BfOE23B3FP9ssIRUZyOU6FTBnp0nVHP3/qJRV+sG/CcTPUTAwAAAIBU5FXYZZpm178VRen63+7HAQAAACAXKaoqllEjs12GiJzqJ6Zv2y5mW3u/YzPZTwwAAAAAUpF3t+Z1hlymaXZ9neu5AAAAAGA4ydV+YgAAAACQirxa2TVnzpwEARUAAAAAnLvOfmL6pnrR67eK2fH+zu5KgVe0mmrRZtcQdAEAAADIeXkVdr3yyiuhbNcAAAAAAENFrvUTAwAAAIBU5FXYBQAAkE6GYUpHS1D0SEw0h00KSt2iqqwqBzD05VI/MQAAAABIFmEXAAAY9vRITHbXN8nehkMS9ke7jju9dplYNUam1FSK5rBlsUIAAAAAAAD0hrALAAAMa/62kKxft1UC7eEzngv7o7K9rlEatx+R2qXV4i12ZaFCAAAAAAAA9IVN2AEAwLClR2K9Bl3dBdrDsn7dVtGj8QxVBmC4M0xTDgfDsu9kQA4Hw2KYZrZLAgAAAICcxcouAAAwbO2ub+o36OoUaA/Lns1NMn3ehDRXBWA4C8UTsv6wTzY0t8oJPdZ1vFCzyYLyEqmtKBOX1ZLFCgEAAAAg9+RE2HXTTTc5svn6iqLIz372s0g2awAAAJllGKbsbTiU1Jy9DQdl6tzxoqpKmqoCMJwdD0flgZ2N4ovoZzx3Qo/J001HZeOxNlk1bYKMdNqzUCEAAAAA5KacCLvWrl1rU5TsXDQyTZOwCwCAYaijJShhfzSpOSF/VDpag1JY5klTVQCGq1A80WvQ1Z0vossDOxvlezMmiZMVXgAAAAAgIvTsAgAAw5QeifU/6GzzwqnNA4C+rD/s6zfo6uSL6PLCYV+aKwIAAACA/JEzYZdpmln5AgAAw5PmsKU2z5naPADojWGasqG5Nak5dc2tYvD3DAAAAACISI5sY9jY2BjIdg0AAGB4KSh1i9NrT2orQ5fXLgUl7jRWBWA4ag5F5ISe3KrRdj0mzaGoVLiz2v4YAAAAAHJCToRdF1xwAbckAgCAjFJVRSZWjZHtdY0DnjOxaqyoanb6jAIYukLxRIrz4oNcCQAAAADkp5zZxhAAACDTptRUiqfIOaCxniKnTJ5VmeaKAAxHLqslxXk5ce8iAAAAAGQdYRcAABi2NIdNapdW9xt4eYqcUru0WjQ7F5YBDL5yl0MKteT6ARZpNil32dNUEQAAAADkF67YQEREgsGgvPXWW2pTU5N6+PBhJRAIKIlEQkaMGGGOHDnS/MAHPmBMnDjRUNXBy0fD4bBs3LjRsnv3brW9vV3RNE3Gjh1rzJo1K3HhhReytSUAICO8xS5ZcusVsqf+gOxtOCihbj28XF67TKwaK5NnVRJ0AUgbVVFkQXmJPN10dMBz5peXiKqwrSoAAAAAiBB2DVuGYch//dd/2TZu3Gipr6+3NDY2qoZh9Dln5MiR5qc//enY7bffro8bNy7lMOrYsWPKv/7rv9rXrl1rCwaDZx3zgQ98wFi9enX0+uuvpxEBACDtNIdNps+bIFPnjpeO1qDo4ZhoTpsUlLjp0QUgI2orymTjsTbxRfR+x5Y5NFlUUZaBqgAAAAAgPyimaXZkuwhkXiwWE03TvKnM9Xg8cu+990a+/OUvx5Kd+9JLL1luvPFGZ2tr64CuHH7605+OrVmzJmK358YWLTt37lSnT5/u7nz85ptvyiWXXJLNkgAAADBEHA9H5YGdjX0GXmUOTVZNmyAjnbnx+TgdTMMQw9ciZjgiitMhalmpKIO4wwQAAACA9Ni1a5dMnTq16/GOHTuC06ZN63uVzSBhZRd68Hg8ct555xkFBQVmLBZTfD6fcuTIkR7BVCAQkNtuu83h8/mUO++8s/9bT//m5Zdftlx99dWucDjc43hhYaFUVlYaJ06cUA4dOqQkEomu5/77v//bFggElN/+9rfhwdxCEQAAAMg1I512uXPGJFl/2Cd1za3Srr9/b1mRZpP55SWyqKJMnFZLFqtMHzMSEX3jZtG3NIjZ4e86rhR4RZtZJdqcWaI4HFmsEAAAAECuYmXXMNW5smv8+PHm4sWLY1dddVVi1qxZicrKyjO2Jzxy5Iiydu1a23333Wdvb2/v8dwLL7wQqq2tTZw+53RtbW0ydepUT3Nzc1dwNm7cOPPBBx+MfPzjH493BlkHDhxQvv/979ufeOKJHh2677vvvug3vvGNAQdr6cLKLgAAAGSCYZrSHIpKKB4Xl9Uq5S77kO7RZbS2SXDNWjHb2nsdoxQXiXv5MlFLijNYGQAAAICByubKLsKuYcowDNmxY4d62WWXDfgH7b333lPmzZvnPnDgQNdf2dXV1Yk33ngj1N/cb3zjG/YHHnhA63x8/vnnm6+++mpwzJgxZ+399b3vfU/77ne/27U3y4gRI+Sdd97xFxdn9w9bwi4AAABgcJmRiAQeeqzPoKuTUlwknpUrWOEFAAAA5KBshl3sCzdMqaoqyQRdIqcCqh//+Mc99iDcunWrpampqc9bTI8dO6b8+Mc/1rofe+yxx8K9BV0iIqtXr9bnzJnTtWLs5MmTct999w3dxgQAgJxlGKacOB6Q4wfa5cTxgBhGr7++AAAp0DduHlDQJSJitrWLvqk+zRUBAAAAyDf07EJSFi9enCgrKzN9Pl9XwPXWW2+plZWVvW5l+NRTT1kDgUDX4zlz5iQWLVrU59aHqqrKv/zLv0QXLVrk6jz285//3HbvvfdG6d0FAMgEPRKT3fVNsrfhkIT90a7jTq9dJlaNkSk1laI5bH2cAQDQH9MwRN/SkNQcvX6raAvmisLfBQAAAAD+hr8OkBRVVeX888/vsSKspaWlz5Vdv//973tcCbz55ptjvY3tbuHChYnzzz+/6/b5Y8eOKa+99trQ7MYNAMgp/raQPPP467K9rrFH0CUiEvZHZXtdozzz+Ovib+t3J18AQB8MX4uYHf6k5pgdfjF8LWmqCAAAAEA+IuxC0iKRSI9wq7CwsNexfr9fNm3a1COg+vCHPxwfyOuoqiof/OAHe4z9wx/+wGpEAEBa6ZGYrF+3VQLt4T7HBdrDsn7dVtGjA/q1BgA4CzMcyeg8AAAAAEMTYReS0tHRIW+//XaPn5uqqqpetyTcuXOnJRZ7fyHX+eefb5533nkDbnYye/bsHufevn07P7MAgLTaXd/Ub9DVKdAelj2bm9JcEQAMXYrTkdF5AAAAAIYmggMk5d5777Xrut71+EMf+lCir/Dqrbfe6vEzNnny5D57dZ3u4osv7jH+7bffZhtDAEDaGIYpexsOJTVnb8NBMYwB38cBAOhGLSsVpcCb1BylwCtqWWmaKgIAAACQjwi7MCDxeFzuvvtu7b777tM6jzmdTnnwwQf73D/k9FVgY8eOTepq4Lhx43qMP3DggBIOD+xuewAAktXREjyjR1d/Qv6odLQG01QRAAxtiqqKNrMqqTlaTbUoKn/KAgAAAHgf/Y/Q5a9//at67Nixrn5cuq4rra2tyl//+lf16aefth04cKDrOa/XK7/85S9DU6dONfo6p8/n69Hfq6Kios/xpxs9erRptVolHj/VD8UwDGlpaVGSDc0AABgIPRLrf9DZ5oVTmwcAENHmzBJ923Yx29r7HasUF4k2uyYDVQEAAADIJ4Rd6PKd73zH/swzz/T5M2G1WuX666+P33PPPZEJEyb0GzgFAoEeYZfb7U6qJlVVxel0it/vP/2c5xx2HT16VDk9jOvPvn37uIUUAIYwzWFLbZ4ztXkAABHF4RD38mUSXLO2z8BLKS4S9/Jlojjo1wUAAACgJ8IuDJiqqnLTTTfF/vEf/1EfSNAlIhIIBHo8djgcSYdUDofD9Pv9XaFU9+DrXDzyyCPa3XffrfU/EgAwXBSUusXptSe1laHLa5eCkuRu5gAA9KSWFItn5QrRN9WLXr9VzI73P/MrBV7RaqpFm11D0AUAAADgrAi7MGCGYciaNWtsa9assS1ZsiT++OOPR8rLy/sMr6LRaI+VU5qWfLZkt9t7PA6Hw0mtxgIAYKBUVZGJVWNke13jgOdMrBorqsqvJgA4V4rDIfaF80RbMFcMX4uY4YgoToeoZaX06AIAAADQJ/5iyILbbrvNriiKN91fq1evtvdfzfv+8Ic/hE3T9Hd++f1+f2NjY+CXv/xl+IYbbohbre9no88884x15syZ7sbGxj6v7tnt9h5hmK7rSX2vRESi0Z5316eyOgwAgIGaUlMpniLngMZ6ipwyeVZlmisCgOFFUVWxjBop1vPHiWXUSIIuAAAAAP1iZRd65fF4xOPxmOPHj4//wz/8Q3zLli3qP/zDP7iampoUEZFDhw4p119/veuNN94I9rZiy+Px9HgciUSSvvX99DlerzfZU5zVl7/8Zf3GG2+MJTNn37596g033DCwK6AAgLykOWxSu7Ra1q/bKoH2cK/jPEVOqV1aLZqdj1MAAAAAAADZxNUZDNjMmTON9evXB2fMmOHp7MW1Y8cOdc2aNbYvfvGLZw2NPB5Pj1VYwWAwqdc0DEPC4Z4XGk8/Z6pGjx5tjh49mlViAIAzeItdsuTWK2RP/QHZ23BQQt16eLm8dplYNVYmz6ok6AKAc2SYpjSHIhKKJ8RltUi5yyGqwtawAAAAAJLDFZos+NjHPhYvKSlJe8gyb968xGCf86KLLjJXrlyp33PPPV1LuZ588v+zd+/RbZV3vv+/e0va2pItE1+UxCdOnCbgYHIpxW4cSPxLTDBl2gBtOQycEtrVCYRO18BhOpMWTtMB2tJpJ2XaQm8wpGdamMIqt2lLZ05rKA4kNE5jaAghwcGUxAkm8S2xZF227L1/f6Q2VnyTZF2t92utrlVJz7P31yBjaX/283x/NmHY5fV6o37O48ePx7UHyXvvvacMDg6OPFZVdcwxAQBIBU13yIq1i2VZ/SLp7xkQIxgRzeWQotICenQBwDQFBoek6XiXvNDZI6eM979KzNIc0lBeKo3zvOK22zJYIQAAAIBcQtiVAVdcccXQFVdckfQgKl2uueaayOiwq7W11RaJRMThcIwZu2TJEnP046NHj8Z1dXB4y8RhCxYssFwudhEEAKSPqioyy1s49UAAQExOBsOybX+7dIXG9vM9ZUTkmSPvyc4TvbJl+WKZ7YqrDTEAAACAPEWnX8TtvPPOiwqwIpGIdHd3jxtiVVdXR409dOhQXLdnHjx4MGp8VVVVzoaEAAAAQL4LDA5NGHSN1hUyZNv+dgkO8vEfAAAAwNQIu5AUmqaNu7Xg8uXLh0av+Dpy5Ihy/PjxmFd37dq1Kyrs+uAHP2hONBYAAABAdms63jVl0DWsK2TI7453pbgiAAAAADMBYRfi9s4770S9bxwOhxQXF487tqioSFavXh11O+bvfve7mLbPNE1Tfv/730eNveqqqwYnGg8AAAAge5mWJS909sQ1p7mzR0yLlr0AAAAAJkfYhbj98pe/jAqgli5daqrqxG+lK6+8Miqg+slPfjK2udc4nn/+eds777wzsgps9uzZ1sUXX8w+JgAAAEAO6gyE5JQRiWtOnxGRzkA4RRUBAAAAmCkIuxCXEydOKN/5zne00c9deeWVk35j/dSnPhUpKCgYebxz505bU1PTpL27TNOUr371q1HdqD/96U9HbLa4Wn4BAAAAyBKBBPtvBQbZ3AEAAADA5Ai78tTNN9+sv/HGG3H9+z9y5IjS2Njo7u3tHVltVVRUJJ/73OcmDbvmzp1rfe5zn4vamH/z5s2uY8eOTdi76+tf/7q2c+fOkWTrnHPOkTvuuINbOgEAAIAc5bYnduOa2x7TLugAAAAA8hhhV5564oknHMuXLy9Yt26d+wc/+IHjwIED6uA4d0wODg5Ka2ur+oUvfMG5dOnSwv3790e9Z7761a+G/sf/+B9TbqJ/5513hufMmTMy7p133lFWr15d8Mwzz9hN0xwZd/ToUeXmm2/W77rrrqhVXV/60pfCpaWlifyoAAAAALJAuVuXWVpMO5qPKNYcUu52Tj0QAAAAQF7jFrk8Zpqm7Nixw7Zjxw6biIjL5ZLy8nLrnHPOsWw2m9Xf3690dHSowWBw3Pl33nmn8b//9/+OadP90tJSeeyxx4If/ehH3aFQSETOBFuf/OQnXbNmzZLKykrz9OnTSkdHhzI0FL29yYYNGwa/9KUvGeMdFwAAAEBuUBVFGspL5Zkj78U8Z115qajKhBtCpI1lmmJ2dYsVDIni0kX1lokySd9iAAAAAOlF2IURwWBQ3n77bUVEJv02OWfOHOt73/te6Lrrrotr8/yGhoahX/3qV4HrrkAiNeoAAJinSURBVLvO1dfXN3KOU6dOyalTp8b9pnjdddcN/vu//3tQ5YskAAAAkPMa53ll54le6QpNfS+bV9fk8nneNFQ1MSsUEmPnbjH2tIrV7xt5XinyiLayRrQ1q0TR9QxWCAAAAECEbQzz1u9+97uBrVu3hlevXj3kcrmmHG+z2WTlypVD3//+90NtbW3+eIOuYY2NjUMHDhwY2Lx5c8Ttdk847oMf/KD5i1/8Ivj4448Hdb48AgAAADOC226TLcsXi1fXJh3n1TXZsnyxuBLs85UMZk+v+O9/UMLPNUcFXSIiVr9Pws81i//+B8Xs6c1QhQAAAACGKZZl9We6CGRWJBKRgwcPqm+99Zba0dGh+Hw+ZWhoSIqKiqxZs2bJueeea1500UVDBQUFST1vIBCQnTt32t544w311KlTiqZpUlFRYa5atWqoqqpqyj5gmbB//351xYoVI/8gXn/9dVm6dGkmSwIAAAByTmBwSJqOd0lzZ4/0Ge/vjF6sOWRdealcPs+b0aDLCoXEf/+DYvX2TTlWKSmWwttuYYUXAAAA8t6BAwdk2bJlI49fe+21geXLl5vpODfbGEIcDoesWLHCXLFiRVredMPcbrdcfvnlQ5dffvnQ1KMBAAAAzBRuu02urpwrVy6YI52BsAQGB8Vtt0u525kVPbqMnbtjCrpERKzePjF2tYhz/doUVwUAAABgImxjCAAAAADICFVRZF6BLuedUyjzCvSsCLos0xRjT2tcc4yWvWKZab13EAAAAMAohF0AAAAAAPyF2dU9pkfXVKx+n5hd3SmqCAAAAMBUCLsAAAAAAPgLKxhK6zwAAAAA00fYBQAAAADAXyguPa3zAAAAAEwfYRcAAAAAAH+hestEKfLENUcp8ojqLUtRRQAAAACmQtgFAAAAAMBfKKoq2sqauOZodbWiqHy9BgAAADKFT+MAAAAAAIyirVklSklxTGOVkmLRVteluCIAAAAAkyHsAgAAAABgFEXXpWDTjVMGXkpJ8ZlxOv26AAAAgEyyZ7oAAAAAAACyjVpaIoW33SLGrhYxWvaK1e8beU0p8ohWVyva6rq0BV2WaYrZ1S1WMCSKSz/TW4ytEwEAAAARIewCAAAAAGBciq6Lc/1a0RrqMxY0WaGQGDt3i7GndWzgtrLmzJaLrCwDAABAniPsAgAAAABgEoqqim3O7LSf1+zplYHtj4jV2zfmNavfJ+HnmsV4ZZ8UbLpR1NKStNcHAAAAZAv2PAAAAAAAIMtYodCEQVfUuN6+M+NCoTRVBgAAAGQfwi4AAAAAALKMsXP3lEHXMKu3T4xdLSmuCAAAAMhehF0AAAAAAGQRyzTF2NMa1xyjZa9YppmiigAAAIDsRtgFAAAAAEAWMbu6xer3xTXH6veJ2dWdoooAAACA7EbYBQAAAABAFrGCifXfSnQeAAAAkOvsmS4AAAAAAICZzrQs6QyEJDA4JG67TcrduqiKMu5YxaUndI5E5wEAAAC5jrALAAAAAIAUCQwOSdPxLnmhs0dOGZGR52dpDmkoL5XGeV5x221Rc1RvmShFnri2MlSKPKJ6y5JWNwAAAJBL2MYQAAAAAIAUOBkMy12vvCnPHHkvKugSETllROSZI+/JXa+8KSeD4ajXFFUVbWVNXOfS6mpFUfmKDwAAgPzEJ2EAAAAAAJIsMDgk2/a3S1fImHRcV8iQbfvbJTg4FPW8tmaVKCXFMZ1LKSkWbXVdwrUCAAAAuY6wCwAAAACAJGs63jVl0DWsK2TI7453RT2n6LoUbLpxysBLKSk+M06nXxcAAADyF2EXAAAAAABJZFqWvNDZE9ec5s4eMS0r6jm1tEQKb7tFnI0NohR5ol5TijzibGyQwttuEbW0ZNo1AwAAALnMnukCAAAAco1pWtLfPSBGKCKa7pCisgJRVSXTZQEAskRnIDSmR9dU+oyIdAbCMq8geoWWouviXL9WtIZ6Mbu6xQqGRHHponrL6NEFAAAA/AVhFwAAQIyMUEQOthyRttZjEvSFR553eZxSVVMh1XWVoumODFYIAMgGgbP6b8U+b3DC1xRVFduc2YmWBAAAAMxohF0AAAAx8PUGpOnRveLvC455LegLy77mdmnf9640bqwVT4k7AxUCALKF225LcB5f0QEAAIBEsOcBAADAFIxQZMKgazR/X1CaHt0rRnjiO/MBADNfuVuXWVp8K32LNYeUu50pqggAAACY2Qi7AAAApnCw5ciUQdcwf19QDu0+kuKKAADZTFUUaSgvjWvOuvJSURX6PwIAAACJIOwCAACYhGla0tZ6LK45ba0dYppWiioCAOSCxnle8epaTGO9uiaXz/OmuCIAAABg5iLsAgAAmER/94AEfeG45gR8YenvGUhRRQCAXOC222TL8sVTBl5eXZMtyxeLK8E+XwAAAABE6H4LAAAwCSMUSWxeMLF5AICZY7bLKfdctESajndJc2eP9Bnv/20o1hyyrrxULp/nJegCAAAApomwCwAAYBKa7khsniuxeQCAmcVtt8nVlXPlygVzpDMQlsDgoLjtdil3O+nRBQAAACQJYRcAAMAkisoKxOVxxrWVodvjlKLSghRWBQDINaqiyLwCPdNlAAAAADMSPbsAAAAmoaqKVNVUxDWnqma+qCp36wMAAAAAAKQDYRcAAMAUqusqpbDYFdPYwmKXnL+qMsUVAQAAAAAAYBhhFwAAwBQ03SGNG2unDLwKi13SuLFWNCc7RQMAAAAAAKQLV2IAAABi4Clxy4bNF8uhlqPS1tohgVE9vNwep1TVzJfzV1USdAEAAAAAAKQZV2MAAABipOkOWbF2sSyrXyT9PQNiBCOiuRxSVFpAjy4AAAAAAIAMIewCAACIk6oqMstbmOkyAAAAAAAAIPTsAgAAAAAAAAAAQA4j7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM6yZ7oAAACAmcI0LenvHhAjFBFNd0hRWYGoqpLpsgAAAAAAAGY0wi4AAIBpMkIROdhyRNpaj0nQFx553uVxSlVNhVTXVYqmOzJYIQAAAAAAwMxF2AUAADANvt6AND26V/x9wTGvBX1h2dfcLu373pXGjbXiKXFnoEIAAAAAAICZjZ5dAAAACTJCkQmDrtH8fUFpenSvGOHBNFUGAAAAAACQPwi7AAAAEnSw5ciUQdcwf19QDu0+kuKKAAAAAAAA8g9hFwAAQAJM05K21mNxzWlr7RDTtFJUEQAAAAAAQH4i7AIAAEhAf/eABH3huOYEfGHp7xlIUUUAAKSeaVlyfCAoh0/75fhAUEyLmzgAAACQefZMFwAAAJCLjFAksXnBxOYBAJBJgcEhaTreJS909sgp4/2/ZbM0hzSUl0rjPK+47bYMVggAAIB8RtgFAACQAE13JDbPldg8AAAy5WQwLNv2t0tXyBjz2ikjIs8ceU92nuiVLcsXy2yXMwMVAgAAIN+xjSEAAEACisoKxOWJ74Ke2+OUotKCFFUEAEDyBQaHJgy6RusKGbJtf7sEB4fSVBkAAADwPsIuAACABKiqIlU1FXHNqaqZL6qqpKgiAACSr+l415RB17CukCG/O96V4ooAAACAsQi7AAAAElRdVymFxa6YxhYWu+T8VZUprggAgOQxLUte6OyJa05zZ4+YlpWiigAAAIDxEXYBAAAkSNMd0rixdsrAq7DYJY0ba0Vz0i4VAJA7OgMhOWVE4prTZ0SkMxBOUUUAAADA+LjiAgAAMA2eErds2HyxHGo5Km2tHRLwvX+Bz+1xSlXNfDl/VSVBFwAg5wQS7L8VGBxMciWJsUxTzK5usYIhUVy6qN4yUVTu+QUAAJiJuOoCAAAwTZrukBVrF8uy+kXS3zMgRjAimsshRaUF9OgCAOQst9026euKZckcv09ckYgEHQ45UegRS1HEbc/spQYrFBJj524x9rSK1e8beV4p8oi2ska0NatE0fUMVggAAIBkI+wCAABIElVVZJa3MNNlAACQFOVuXWZpjjFbGeqRiKx7p10uOfqOzAqHRp4/5dTllQ8slrkfXpLuUkeYPb0ysP0RsXr7xrxm9fsk/FyzGK/sk4JNN4paWpKBCgEAAJAKrN8HAAAAAABjqIoiDeWlUc+VDQzIF3e9IB89fCgq6BIRmRUOyaWHDkjggYfE7OlNZ6kicmZF10RBV9S43r4z40KhSccBAAAgdxB2AQAAAACAcTXO84pX10TkzIquz/9xl5QFApPOyVSYZOzcPWXQNczq7RNjV0uKKwIAAEC6EHYBAAAAAIBxue022bJ8sXh1Tda90z5l0DUs3WGSZZpi7GmNa47Rslcs00xRRQAAAEgnwi4AAAAAADCh2S6n3H3hebL+3aNxzUtnmGR2dYvV74trjtXvE7OrO0UVAQAAIJ0IuwAAAFLMNC05ddIvJ4/2yamTfjFNK9MlAQAQF72vT5wDsa3qGpbOMMkKJrZlYqLzAAAAkF3smS4AAABgpjJCETnYckTaWo9J0Bceed7lcUpVTYVU11WKpjsyWCEAALHJ9jBJcelpnQcAAIDsQtgFAACQAr7egDQ9ulf8fcExrwV9YdnX3C7t+96Vxo214ilxZ6BCAABil+1hkuotE6XIE9dWhkqRR1RvWQqrAgAAQLqwjSEAAECSGaHIhEHXaP6+oDQ9uleM8GCaKgMAIDHDYVI80hkmKaoq2sqauOZodbWiqFwWAQAAmAn4VAcAAJBkB1uOTBl0DfP3BeXQ7iMprggAgOnJhTBJW7NKlJLimMYqJcWira5LcUUAAABIF8IuAACAJDJNS9paj8U1p621Q0zTSlFFAAAkR7aHSYquS8GmG6esUSkpPjNOp18XAADATEHYBQAAkET93QMS9IXjmhPwhaW/ZyBFFQEAkBy5ECappSVSeNst4mxsGLPtolLkEWdjgxTedouopSVprw0AAACpY890AQAAADOJEYokNi+Y2DwAANJpOEwydrWI0bJXrH7fyGtKkUe0ulrRVtdldNWUouviXL9WtIZ6Mbu6xQqGRHHpZ/qO0aMLAABgRiLsAgAASCJNdyQ2z5XYPAAA0i1XwiRFVcU2Z3amywAAAEAaEHYBAAAkUVFZgbg8zri2MnR7nFJUWpDCqgAASD7CJAAAAGSL7LnlCgAAYAZQVUWqairimlNVM19UVUlRRQAAAAAAADMbYRcAAECSVddVSmGxK6axhcUuOX9VZYorAgAAAAAAmLkIuwAAAJJM0x3SuLF2ysCrsNgljRtrRXOyszQAAAAAAECiuLICAACQAp4St2zYfLEcajkqba0dEhjVw8vtcUpVzXw5f1UlQRcAAAAAAMA0cXUFAAAgRTTdISvWLpZl9Yukv2dAjGBENJdDikoL6NEFAAAAAACQJIRdAAAAKaaqiszyFma6DAAAAAAAgBmJnl0AAAAAAAAAAADIWYRdAAAAAAAAAAAAyFmEXQAAAAAAAAAAAMhZhF0AAAAAAAAAAADIWfZMFwAAAAAAAJBupmVJZyAkgcEhcdttUu7WRVWUTJcFAACABBB2AQAAAACAvBEYHJKm413yQmePnDIiI8/P0hzSUF4qjfO84rbbMlghAAAA4kXYBQAAAAAA8sLJYFi27W+XrpAx5rVTRkSeOfKe7DzRK1uWL5bZLmcGKgQAAEAi6NkFAAAAAABmvMDg0IRB12hdIUO27W+X4OBQmioDAADAdBF2AQAAAACAGa/peNeUQdewrpAhvzveleKKAAAAkCyEXQAAAAAAYEYzLUte6OyJa05zZ4+YlpWiigAAAJBMhF0AAAAAAGBG6wyE5JQRiWtOnxGRzkA4RRUBAAAgmQi7AAAAAADAjBZIsP9WYHAwyZUAAAAgFQi7AAAAAADAjOa22xKcZ09yJQAAAEgFwi4AAAAAADCjlbt1maU54ppTrDmk3O1MUUUAAABIJsIuAAAAAAAwo6mKIg3lpXHNWVdeKqqipKgiAAAAJBNhFwAAAAAAmPEa53nFq2sxjfXqmlw+z5viigAAAJAshF0AAAAAAGDGc9ttsmX54ikDL6+uyZbli8WVYJ8vAAAApB+dVgEAAAAAQF6Y7XLKPRctkabjXdLc2SN9RmTktWLNIevKS+XyeV6CLgAAgBxD2AUAAAAAAPKG226TqyvnypUL5khnICyBwUFx2+1S7nbSowsAACBHEXYBAAAAAIC8oyqKzCvQ03Y+yzTF7OoWKxgSxaWL6i0TRaW7BAAAQDIQdgEAAAAAAKSIFQqJsXO3GHtaxer3jTyvFHlEW1kj2ppVoujpC90AAABmIsIuAAAAAACAFDB7emVg+yNi9faNec3q90n4uWYxXtknBZtuFLW0JAMVAgAAzAyslwcAAAAAAEgyKxSaMOiKGtfbd2ZcKJSmygAAAGYewi4AAAAAAIAkM3bunjLoGmb19omxqyXFFQEAAMxchF0AAAAAAABJZJmmGHta45pjtOwVyzRTVBEAAMDMRtgFAAAAAACQRGZXt1j9vrjmWP0+Mbu6U1QRAADAzEbYBQAAAAAAkERWMLH+W4nOAwAAyHf2TBeA/NXf3y8vvfSS7c0337T19/eLy+WShQsXmqtXrx6qqKiwMl0fAAAAAACJUFx6WucBAADkO8IuTGpoaEjWrFnj3r17t2308/X19UMvvvhiIJFjtre3K1/5ylecTz31lMMwjDGvK4oi9fX1Q3fffXe4oaFhKMHSAQAAAADICNVbJkqRJ66tDJUij6jeshRWNTHLNM9svRgMieLSz9SvshkQAADIHYRdmNT3vvc97eygazoee+wx+0033eQKBCbOySzLkhdffNG2fv169xe+8AXjX/7lX8IqH7IBAAAAADlCUVXRVtZI+LnmmOdodbVpD5isUEiMnbvF2NMaFcwpRR7RVtaItmaVKDqrzQAAQPYjQcCE/vznPyt33XWXM1nHe/zxx+0bN24cE3SVlZVZF154oTlv3jxLUZSR5y3Lkvvuu0+7/fbbk1YDAAAAAADpoK1ZJUpJcUxjlZJi0VbXpbiiaGZPr/jvf1DCzzWPWYFm9fsk/Fyz+O9/UMye3rTWBQAAkAjCLkzo5ptvdvn9fhERKSgomNaxDh8+rNx0000u0zRHnlu+fLnZ1NQU6Orq8r/66qsDx44d8x84cGDg6quvHhw994EHHtCeeOIJViECAAAAAHKGoutSsOnGKQMvpaT4zLg0rqCyQiEZ2P6IWL19k4/r7TszLhRKU2UAAACJIezCuB5++GHH888/bxMRKSwslC984Qvh6Rxv69at+sDAwMjjmpoa86WXXhq47LLLonpyVVdXm08//XRw06ZNkdHP33HHHXokEvUUAAAAAABZTS0tkcLbbhFnY4MoRZ6o15QijzgbG6TwtltELS1Ja13Gzt1TBl3DrN4+MXa1pLgiAACA6WG1DMbo7OxUvvjFL47cUnbXXXeFZ82aZSV6vP3796tPPvnkyHtN0zT56U9/GjznnHPGHa+qqjzwwAOhHTt22N566y1VROTtt99WHn74Ycff/u3fkngBAAAAAHKGouviXL9WtIZ6Mbu6xQqGRHHponrL0t6jS0TEMk0x9rTGNcdo2StaQ31G6gUAAIgFn1Iwxuc//3m9r+/MHV4XXXSR+fd///fGdI63fft2x+jtC6+99trI0qVLzUmmiMvlki1btkSd9yc/+YljOnUAAAAAAJApiqqKbc5ssS9cILY5szMWHJld3WN6dE3F6veJ2dWdoooAAACmj7ALUZ588kn7f/7nf9pFROx2uzz00ENBm802rWM+++yzUSsIz96icCKf+tSnIqN7hbW2ttqOHTumTKsYAAAAAADymBVMrP9WovMAAADSgbALI/r6+uTWW28d2b7w1ltvNWpqaiZdgTWVgwcPqu3t7SPvs4KCAlmzZs3QZHOGFRYWSl1d3chYy7Lk17/+NVtvAgAAAACQIMWlTz0oifMAAADSgbALI26//Xb9vffeU0REFi5caH3ta18LT/eYr776atR7rLa2dsjhiH03wksuuWRw9ON9+/ZNb5kZAAAAAAB5TPWWiVLkiWuOUuQR1VuWoooAAACmj7ALIiLy29/+1vazn/1sJIX64Q9/GBy9hWCi3njjjahwqrq6Oq6VYmf39jp06BDvWQAAAAAAEqSoqmgra+Kao9XVZqzHGAAAQCz4pALx+/3yuc99zjX8+Prrr4/81V/9VUxbDU6lra0t6j1WUVERV9g1f/58a7LjAQAAAACA+GhrVolSUhzTWKWkWLTVdSmuCAAAYHoIDiB33nmn85133lFEREpKSqzvfve7096+cFhXV5cy+vH8+fPjCrvODse6u7uVicYCAAAAAJBPTMuS4wNBOXzaL8cHgmJa1tSTRETRdSnYdOOUgZdSUnxmnE6/LgAAkN3smS4AmbVr1y7bD3/4Q2348be+9a3wnDlzYvt0HAO/3x/1ON6tEQsLC6NqiUQiEgqFRE/CB+333ntPOTuMm8rhw4cJiAEAAAAAGRUYHJKm413yQmePnDIiI8/P0hzSUF4qjfO84rZP3vJaLS2RwttuEWNXixgte8Xq9428phR5RKurFW11HUEXAADICYRdeSwcDstNN92km+aZxVPr1q0buummmyJTTIuL3++PCpN0XY8rSHO5XGOe8/v9SrzHGc/3v/997d5779WmHgkAAAAAQHY4GQzLtv3t0hUyxrx2yojIM0fek50nemXL8sUy2+Wc9FiKrotz/VrRGurF7OoWKxgSxaWL6i2jRxcAAMgpfHLJY3fffbfz0KFDqoiIruvy4IMPBpN9jnA4HBV2aVp82ZLTOfaDeSAQmF5RAAAAAADkoMDg0IRB12hdIUO27W+X4GBs7bgVVRXbnNliX7hAbHNmE3QBAICcw6eXDLj11ludiqJ4Uv2/rVu3TngL15/+9Cf1vvvuG0me7rzzznBVVVXSti8c5nQ6o45pGJN/ID9bODy2fdh4q70AAMhFpmnJqZN+OXm0T06d9ItpJv1PMQAAmEGajndNGXQN6woZ8rvjXSmuCAAAIDuwjWEeGhwclE2bNrkikTM7Fi5dutS844474kuhYnR2z61QKBRXj6xgcOxis7OPmai/+7u/M6677rq4tm08fPiwes0115C2AQCmxQhF5GDLEWlrPSZB3/s3drg8TqmqqZDqukrRdEcGKwQAANnGtCx5obMnrjnNnT1y5YI5oipxfRUHAADIOYRdeWjbtm3aK6+8ooqIqKoqDz74YCje7QVjVVhYGPV4YGAgrvln9/yy2+1JW9k1d+5ca+7cudxCDwBIK19vQJoe3Sv+vrE3dAR9YdnX3C7t+96Vxo214ilxZ6BCAACQjToDITllxNdmu8+ISGcgLPMK9BRVBQAAkB0IuzLgYx/72GBpaWnKQ5a1a9eO2Zw7EAjI1772tZHtDTdv3hxZvXp1bJt4J8Dr9Ub9nB0dHXFtnXns2LGo8WVlZYRTAICcZYQiEwZdo/n7gtL06F7ZcMslojn5uAYAAM7060ps3mCSKwEAAMg+XD3JgCuuuGLoiiuuSFnANJlwOBy1NeCPf/xjx49//OO490l66aWXbIqieEY/19vb6ysuLo4aV1VVZY5+HG/YdfTo0aiVXUuWLDEnGgsAQLY72HJkyqBrmL8vKId2H5EVaxenuCoAAJAL3HZbgvO49AMAAGa+uIIHIF7V1dVRod7Bgwfjes+98cYbUeMJuwAAuco0LWlrPRbXnLbWDjFNFjUDAACRcrcus7T47lUt1hxS7nZOPRAAACDHEXYhpT70oQ9FhVOtra22SCT2PcZffvnlqFvQPvjBD2ZkRRwAANPV3z0gQV84rjkBX1j6e+LrdwkAAGYmVVGkobw0rjnryktFVZSpBwIAAOQ41rLnmcLCQvl//+//BeKd99vf/tb+ne98Rxt+vGzZMvPb3/526Oxjn+2CCy4wFy1aZL399tuKiMjAwIDs3LnT1tDQMGVo5ff7Zc+ePSP7NCiKIldddRWbjQMAcpIRiq+h/Mi8YGLzAADAzNM4zys7T/RKV8iYcqxX1+Tyed40VAUAAJB5hF15xuFwyEc+8pG4V0ed3WuruLjYivU4GzZsiNx///0jQdn27dsdsYRdP//5zx1+v3/k8UUXXWRWVFSwlxMAICdpetwtMs/McyU2DwAAzDxuu022LF8s2/a3Txp4eXVNtixfLK4E+3wBAADkGrYxRMpt2rQpoozaNuGJJ55wHDhwYNL3XjAYlG3btmmjn/vsZz879a1rAABkqaKyAnF54uuZ4fY4pai0IEUVAQCAXDTb5ZR7Lloin6icK8Vn9fAq1hzyicq58tWLlshsF726AABA/mBlF1JuxYoV5jXXXDP45JNP2kVEDMOQz3zmM67nn39+4Jxzzhkz3jRNue222/S33nprJBD7wAc+YN18883s4wQAyFmqqkhVTYXsa26PeU5VzXxRVfpsAACAaG67Ta6unCtXLpgjnYGwBAYHxW23S7nbOSN7dFmmKWZXt1jBkCguXVRvmSgq928DAID3EXYhLe69997Qf/3XfxUGAmfahbW2tqr19fUF3/nOd0Lr168f2dLw0KFD6h133OH85S9/GfXe/MY3vhHSNE0AAMhl1XWV0r7vXfH3BaccW1jskvNXVaahKgAAkKtURZF5BXqmy0gZKxQSY+duMfa0itXvG3leKfKItrJGtDWrRNFn7s8PAABix20wSIuqqirroYceCo7eznD//v3qZZdd5vZ6vYUXXXRRwfz58wsvuOCCgrODrs9//vPG9ddfP5j2ogEASDJNd0jjxlopLHZNOq6w2CWNG2tFc3JfEgAAyE9mT6/4739Qws81RwVdIiJWv0/CzzWL//4HxezpzVCFAAAgmxB2IW1uuOGGwZ/97GdBlyv6Al93d7fy6quvqseOHVMsy4p67fbbbzceeOCBcDrrBAAglTwlbtmw+WK5cN254j6rh5fb45QL150rG265RDwl7gxVCAAAkFlWKCQD2x8Rq7dv8nG9fWfGhUJpqgwAAGQrbhdGWm3cuHFw1apV/q1bt+pPP/20PRIZvw3XmjVrhu65557wpZdeOjTuAAAAcpimO2TF2sWyrH6R9PcMiBGMiOZySFFpAT26AABA3jN27p4y6Bpm9faJsatFnOvXprgqAACQzQi7EJObbropctNNN42fTMXp3HPPtR5//PHg6dOn5cUXX7S3tbWpPp9PdF2XyspKc82aNUPz58+3pj4SAAC5TVUVmeUtzHQZAAAAWcMyTTH2tMY1x2jZK1pDvSgqGxgBAJCvCLuQMeecc45ceeWV9OICAAAAAAAiImJ2dY/p0TUVq98nZle32ObMTlFVAAAg23HLCwAAAAAAALKCFUys/1ai8wAAwMxA2AUAAAAAAICsoLj0tM4DAAAzA9sYAgAAIC6maUl/94AYoYhoukOKygpEVZVMlwUAAGYA1VsmSpEnrq0MlSKPqN6yFFYFAACyHWEXAAAAYmKEInKw5Yi0tR6ToC888rzL45SqmgqprqsUTXdksEIAAJDrFFUVbWWNhJ9rjnmOVlcrisrmRQAA5DM+CQAAAGBKvt6APPvQH2Rfc3tU0CUiEvSFZV9zuzz70B/E1xvIUIUAAGCm0NasEqWkOKaxSkmxaKvrUlwRAADIdoRdAAAAmJQRikjTo3vF3xecdJy/LyhNj+4VIzyYpsoAAMBMpOi6FGy6ccrASykpPjNOp18XAAD5jrALAAAAkzrYcmTKoGuYvy8oh3YfSXFFAABgplNLS6TwtlvE2dggSpEn6jWlyCPOxgYpvO0WUUtLMlQhAADIJvTsAgAAyDKmaUl/94AYoYhoukOKygpEVZWM1dLWeiyuOW2tHbKsflHGagYAADODouviXL9WtIZ6Mbu6xQqGRHHponrL6NEFAACiEHYBAABkCSMUkYMtR6St9VhUXyyXxylVNRVSXVcpmu5Ia0393QNjenRNJeALS3/PgMzyFqaoKgAAkE8UVRXbnNmZLgMAAGQxwi4AAIAs4OsNTNgXK+gLy77mdmnf9640bqwVT4k7bXUZoUhi84KJzQMAAAAAAIgXa74BAAAyzAhFJgy6RvP3BaXp0b1ihAfTVJkkvJJMc6V3BRoAAAAAAMhfhF0AAAAZdrDlyJRB1zB/X1AO7T6S4oreV1RWIC6PM645bo9TikoLUlQRAAAAAABANMIuAACADDJNS9paj8U1p621Q0zTSlFF0VRVkaqairjmVNXMF1VVUlQRAAAAAABANMIuAACADOrvHpCgLxzXnIAvLP09AymqaKzqukopLHbFNLaw2CXnr6pMcUUAAAAAAADvI+wCAADIICMUSWxeMLF5idB0hzRurJ0y8CosdknjxlrRnPY0VQYAAAAAACDClQgAAIAM0nRHYvNcic1LlKfELRs2XyyHWo5KW2uHBEatRnN7nFJVM1/OX1VJ0AUAAAAAANKOqxEAAAAZVFRWIC6PM66tDHW3Q0IBQ06d9EtRWUHa+mNpukNWrF0sy+oXSX/PgBjBiGguhxSVpq8GAACQP0zLks5ASAKDQ+K226TcrYuq8JkDAACMRdgFAACQQaqqSFVNhexrbo95TigQkd/9+x9FRMTlcUpVTYVU11UmvEosXqqqyCxvYVrOBQAA8k9gcEiajnfJC509csp4f+vmWZpDGspLpXGeV9x2WwYrBAAA2YaeXQAAABlWXVc5ZT+siQR9YdnX3C7PPvQH8fUGklwZAABAep0MhuWuV96UZ468FxV0iYicMiLyzJH35K5X3pSTwdhXxQMAgJmPsAsAACDDNN0hjRtrEw68RET8fUFpenSvGOHBJFYGAACQPoHBIdm2v126Qsak47pChmzb3y7BwaE0VQYAALIdYRcAAEAW8JS4ZcPmi+XCdeeK2+NM6Bj+vqAc2n0kyZUBAACkR9PxrimDrmFdIUN+d7wrxRUBAIBcQc8uAACALKHpDlmxdrEsq18k/T0DEh4wZMeT+yQ0ENtFHxGRttYOWVa/SFSV5u0AACB3mJYlL3T2xDWnubNHrlwwR1SFzz0AAOQ7VnYBAABkGVVVZJa3UJxuLa6gS0Qk4AvLscNdcvJon5w66RfTtFJUJQAAQPJ0BkJjenRNpc+ISGeA3l0AAICVXQAAAFnLCMV3wWdY8+Ovjvx/l8cpVTUVUl1XKZruSFZpAAAASRVIsP9WYJB+pQAAgJVdAAAAWSsZ4VTQF5Z9ze3y7EN/EF9vIAlVAQAAJJ/bbktwHvdxAwAAwi4AAICsVVRWIC6PMynH8vcFpenRvWKEufsZAABkn3K3LrO0+G70KdYcUu5OzmclAACQ2wi7AAAAspSqKlJVU5G04/n7gnJo95GkHQ8AACBZVEWRhvLSuOasKy8VVVFSVNHULNOUoRMnZfCdozJ04qRYppmxWgAAyHes9QYAAMhi1XWV0r7vXfH3BZNyvLbWDllWv0hUNXMXhgAAAMbTOM8rO0/0SlfImHKsV9fk8nneNFQ1lhUKibFztxh7WsXq9408rxR5RFtZI9qaVaLoekZqAwAgX7GyCwAAIItpukMaN9ZKYbErKccL+MLS3zOQlGMBAAAkk9tuky3LF4tX1yYd59U12bJ8sbgS7PM1HWZPr/jvf1DCzzVHBV0iIla/T8LPNYv//gfF7OlNe20AAOQzwi4AAIAs5ylxy4bNF8uF684VdxJ6eBnBSBKqAgAASL7ZLqfcc9ES+UTlXCk+q4dXseaQT1TOla9etERmu9Lfq8sKhWRg+yNi9fZNPq6378y4UChNlQEAALYxBAAAyAGa7pAVaxfLsvpF0t8zIEYwIqFgRJoffzXuY4WCETl5tE803SFFZQVsaQgAALKK226TqyvnypUL5khnICyBwUFx2+1S7nZmtEeXsXP3lEHXMKu3T4xdLeJcvzbFVQEAABHCLgAAgJyiqorM8haKiIhpWuLyOCXoC8c8X1EkKiBzeZxSVVMh1XWVoumOSWYCAACkl6ooMq8gO3pfWaYpxp7WuOYYLXtFa6gXRWVjJQAAUo2/tgAAADlKVRWpqqmIa45lRT8O+sKyr7ldnn3oD+LrDSSxOgAAgJnD7Ooe06NrKla/T8yu7hRVBAAARiPsAgAAyGHVdZVSWOya9nH8fUFpenSvGOHBJFQFAAAws1jBxPpvJToPAADEh7ALAAAgh2m6Qxo31iYt8Dq0+0gSqgIAAJhZFFdi2ykmOg8AAMSHsAsAACDHeUrcsmHzxXLhunPF7XFGvRZvD/e21g4xTWvqgQAAAHlE9ZaJUuSJa45S5BHVW5aiiqJZpilDJ07K4DtHZejESbFMMy3nBQAgW9gzXQAAAACmT9MdsmLtYllWv0j6ewbECEYkFIxI8+OvxnWcgC8s/T0DMstbmKJKAQAAco+iqqKtrJHwc80xz9HqakVRU3ufuRUKibFztxh7WqN6iilFHtFW1oi2ZpUoOqvLAAAzHyu7AAAAZhBVVWSWt1BmLygW3eVI6BhGMJLkqgAAAHKftmaVKCXFMY1VSopFW12X0nrMnl7x3/+ghJ9rjgq6RESsfp+En2sW//0PitnTm9I6AADIBoRdAAAAM5SmJxZ2hYIROXm0T06d9LOlIQAAwF8oui4Fm26cMvBSSorPjEvhiiorFJKB7Y+I1ds3+bjevjPjQqGU1QIAQDZgG0MAAIAZqqisQFwepwR94ZjnKIpEbX3o8jilqqZCqusqEw7PAAAAZgq1tEQKb7tFjF0tYrTsHbt1YF2taKvrUr51oLFz95RB1zCrt0+MXS3iXL82pTUBAJBJhF0AAAAzlKoqUlVTIfua22OeY521kCvoC8u+5nZp3/euNG6sFU+JO8lVAgAA5BZF18W5fq1oDfVidnWLFQyJ4tJF9ZalvEeXiIhlmmLsaY1rjtGyV7SG+rTUBwBAJvAXDgAAYAarrquUwmLXtI/j7wtK06N7xQgPJqEqAACA3KeoqtjmzBb7wgVimzM7bUGS2dU9pkfXVKx+n5hd3SmqCACAzCPsAgAAmME03SGNG2uTFngd2n0kCVUBAAAgUVYwsf5bic4DACAXEHYBAADMcJ4St2zYfLFcuO5ccXucUa8pSnzHamvtENO0ph4IAACAlFBcifUDS3QeAAC5gJ5dAAAAeUDTHbJi7WJZVr9I+nsGxAhGJBSMSPPjr8Z1nIAvLP09AzLLW5iiSgEAADAZ1VsmSpEnrq0MlSKPqN6yFFYFAEBmsbILAAAgj6iqIrO8hTJ7QbHoLkdCxzCCkSRXBQAAgFgpqiraypq45mh1tWnrKQYAQCbwVw4AACBPaXpiYZeWYEgGAACA5NDWrBKlpDimsUpJsWir61JcEQAAmUXYBQAAkKeKygrEdVYPr6m4PU4pKi1IUUUAAACIhaLrUrDpxikDL6Wk+Mw4nX5dAICZjbALAAAgT6mqIlU1FXHNqaqZL6qqpKgiAAAAxEotLZHC224RZ2ODKEWeqNeUIo84Gxuk8LZbRC0tyVCFAACkjz3TBQAAACBzqusqpX3fu+LvC045trDYJeevqkxDVQAAAIiFouviXL9WtIZ6Mbu6xQqGRHHponrL6NEFAMgr/NUDAADIY5rukMaNtVJY7Jp0XGGxSxo31orm5F4pAACAbKOoqtjmzBb7wgVimzOboAsAkHe4WgEAAJDnPCVu2bD5YjnUclTaWjsk4AuPvOb2OKWqZr6cv6qSoAsAAAAAAGQlrlgAAABANN0hK9YulmX1i6S/Z0CMYEQ0l0OKSgvo0QUAAAAAALIaYRcAAABGqKois7yFmS4DAAAAAAAgZmzgCwAAAAAAAAAAgJzFyi4AAAAAAAAgyUzLks5ASAKDQ+K226TcrYuqsD00AACpQNgFAAAAAAAAJElgcEiajnfJC509csqIjDw/S3NIQ3mpNM7zittuy2CFAADMPIRdAAAAAAAAQBKcDIZl2/526QoZY147ZUTkmSPvyc4TvbJl+WKZ7XJmoEIAAGYmenYBAAAAAAAA0xQYHJow6BqtK2TItv3tEhwcSlNlAADMfIRdAAAAAAAAwDQ1He+aMuga1hUy5HfHu1JcEQAA+YOwCwAAAAAAAJgG07Lkhc6euOY0d/aIaVkpqggAgPxC2AUAAAAAAABMQ2cgJKeMSFxz+oyIdAbCKaoIAID8QtgFAAAAAAAATEMgwf5bgcHBJFcCAEB+IuwCAAAAAAAApsFttyU4z57kSgAAyE+EXQAAAAAAAMA0lLt1maU54ppTrDmk3O1MUUUAAOQXwi4AAAAAAABgGlRFkYby0rjmrCsvFVVRUlQRAAD5hbALAAAAAAAAmKbGeV7x6lpMY726JpfP86a4IgAA8gdhFwAAAAAAADBNbrtNtixfPGXg5dU12bJ8sbgS7PMFAADGogsmAAAAAAAAkASzXU6556Il0nS8S5o7e6TPiIy8Vqw5ZF15qVw+z0vQBQBAkhF2AQAAAAAAAEnittvk6sq5cuWCOdIZCEtgcFDcdruUu5306AIAIEUIuwAAAAAAAIAkUxVF5hXomS4DAIC8QM8uAAAAAAAAAAAA5CzCLgAAAAAAAAAAAOQstjEEAABA0pimJf3dA2KEIqLpDikqKxBVpTcFAAAAAABIHcIuAAAATJsRisjBliPS1npMgr7wyPMuj1Oqaiqkuq5SNN2RwQoBAAAAAMBMRdgFAACAafH1BqTp0b3i7wuOeS3oC8u+5nZp3/euNG6sFU+JOwMVAgAAAACAmYyeXQAAAEiYEYpMGHSN5u8LStOje8UID6apMgAAAAAAkC8IuwAAAJCwgy1Hpgy6hvn7gnJo95EUVwQAAAAAAPINYRcAAAASYpqWtLUei2tOW2uHmKaVoooAAAAAAEA+IuwCAABAQvq7ByToC8c1J+ALS3/PQIoqAgAAAAAA+YiwCwAAAAkxQpHE5gUTmwcAAAAAADAewi4AAAAkRNMdic1zJTYPAAAAAABgPIRdAAAASEhRWYG4PM645rg9TikqLUhRRQAAAAAAIB8RdgEAACAhqqpIVU1FXHPmnz87RdUAAAAAY1mmKUMnTsrgO0dl6MRJsUwz0yUBAFLAnukCAAAAkLuq6yqlfd+74u8LxjT+zT92yNFDJ6WqpkKq6yoT3goRAAAAmIwVComxc7cYe1rF6veNPK8UeURbWSPamlWi6HoGKwQAJBMruwAAAJAwTXdI48ZaKSx2xTwn6AvLvuZ2efahP4ivN5DC6gAAAJBO2bKKyuzpFf/9D0r4ueaooEtExOr3Sfi5ZvHf/6CYPb0ZqQ8AkHys7AIAAMC0eErcsmHzxXKo5ai0tXZIwBeOaZ6/LyhNj+6VDbdcIpqTj6UAAAC5KptWUVmhkAxsf0Ss3r7Jx/X2ycD2R6TwtltY4QUAMwAruwAAADBtmu6QFWsXyydvXytLPjw/5nn+vqAc2n0khZUBAAAglbJtFZWxc/eUQdcwq7dPjF0tKa4IAJAOhF0AAABIqqOHTsY1vq21Q0zTSlE1AAAASJV4V1FZoVBq6zFNMfa0xjXHaNmbse0WAQDJQ9gFAACApOnvHpBgjNsYDgv4wtLfM5CiigAAAJAq2baKyuzqHrO6bCpWv0/Mru4UVQQASBfCLgAAACSNEYokNi+Y2DwAAABkRjauorKCia0cS3QeACB7EHYBAAAgaTTdkdg8V2LzAAAAkBnZuIpKcelpnQcAyB6EXQAAAEiaorICcXmccc1xe5xSVFqQoooAAACQCtm4ikr1lolS5IlrjlLkEdVblqKKAADpQtgFAACApFFVRapqKuKaU1UzX1RVSVFFAAAASIVsXEWlqKpoK2vimqPV1YqicokUAHId/yUHAABAUlXXVUphsSumsYXFLjl/VWWKKwIAAECyZesqKm3NKlFKimOrp6RYtNV1Ka0HAJAehF0AAABIKk13SOPG2ikDr8JilzRurBXNaU9TZQAAABiPaVlyfCAoh0/75fhAUEzLmnJOtq6iUnRdCjbdOGXgpZQUnxmn068LAGYCriwAAAAg6Twlbtmw+WI51HJU2lo7JOALj7zm9jilqma+nL+qkqALAAAggwKDQ9J0vEte6OyRU0Zk5PlZmkMaykulcZ5X3HbbhPO1NavEeGWfWL19U54rnauo1NISKbztFjF2tYjRslesft/7dRR5RKurFW11HUEXAMwgXF0AAABASmi6Q1asXSzL6hdJf8+AGMGIaC6HFJUW0KMLAAAgw04Gw7Jtf7t0hYwxr50yIvLMkfdk54le2bJ8scx2Occ9xvAqqoHtj0waeGViFZWi6+Jcv1a0hnoxu7rFCoZEcelntl+kRxcAzDiEXQAAAEgpVVVklrcw02UAAADgLwKDQxMGXaN1hQzZtr9dvnrREnFNsMIr21dRKaoqtjmzM3JuAED6EHYBAAAAAAAAeaTpeNeUQdewrpAhvzveJVdXzp1wDKuoAACZxl8bAAAAAAAAIE+YliUvdPbENae5s0dMy5py3PAqKvvCBWKbM5ugCwCQNvzFAQAAAAAAAPJEZyAkp4xIXHP6jIh0BsIpqggAgOkj7AIAAAAAAADyRGBwKMF5g0muBACA5CHsAgAAAAAAAPKE225LcJ49yZUAAJA8hF0AAAAAAABAnih36zJLc8Q1p1hzSLnbmaKKAACYPm7JQMb09/fLSy+9ZHvzzTdt/f394nK5ZOHChebq1auHKioqpu56CgAAAAAAgLioiiIN5aXyzJH3Yp6zrrxUVEVJYVUAAEwPYVceu/HGG/VHH300vlt5Rvnyl79sfP3rX4+7O2l7e7vyla98xfnUU085DMMY87qiKFJfXz909913hxsaGhLbSBoAAAAAAADjapznlZ0neqUrNPa6zNm8uiaXz/OmoSoAABLHNoZIq8cee8y+YsWKwscee2zcoEtExLIsefHFF23r1693/+M//qPTNM00VwkAAAAAADBzue022bJ8sXh1bdJxXl2TLcsXiyvBPl8AAKQLK7uQNo8//rh948aNrrPDq7KyMquiosLq6upS3n33XcWyzuxgaFmW3HfffZphGHL//ffHvYIMAAAAAAAA45vtcso9Fy2RpuNd0tzZI31GZOS1Ys0h68pL5fJ5XoIuAEBOIOzCiJ/+9KfBOXPmxNwra/HixTEvuTp8+LBy0003RQVdy5cvN//1X/81dNlll41sVXjw4EH1zjvvdP7yl78ceW8+8MADWn19/dC11147GOv5AAAAAAAAMDm33SZXV86VKxfMkc5AWAKDg+K226Xc7aRHFwAgpxB2YcSaNWuGFi1aFHPYFY+tW7fqAwMDI49ramrM559/fuCcc86JGlddXW0+/fTTwc2bN+vbt28f6Sd2xx136B//+Mf9DkfCLcYAAAAAAAAwDlVRZF6BnukyAABIGD27kHL79+9Xn3zyyZFgVdM0+elPfxo8O+gapqqqPPDAA6Fzzz13ZBnY22+/rTz88MMkXQAAAAAAAAAAIAphF1Ju+/btjtHbF1577bWRpUuXTroFosvlki1bthijn/vJT35C2AUAAAAAAAAAAKIQdiHlnn322ajtMjdt2hSZaOxon/rUpyIFBQUjj1tbW23Hjh1jw2gAAAAAAAAAADCCsAspdfDgQbW9vX3kfVZQUCBr1qwZimVuYWGh1NXVjYy1LEt+/etf02cOAAAAAAAAAACMIOxCSr366qtR77Ha2tohhyP23QgvueSSwdGP9+3bZ0tSaQAAAAAAAAAAYAZglQyi+P1++fOf/6z29PQoLpfLKi0ttSoqKixd1xM63htvvBEVTlVXV0/aq+tsZ/f2OnToEAEtAAAAAAAAAAAYQdiFEVdddZX7zTffVAcHoxZTia7r8uEPf3how4YNg5/73OeMoqKimI/Z1tYWFU5VVFTEFXbNnz/fmux4AABg5jFNS/q7B8QIRUTTHVJUViCqSttOAAAAAAAwPsIujDhw4MC4QVIoFJKXXnrJ9tJLL9m+8Y1vOO++++7Q7bffHonlmF1dXVFXpubPnx9X2HV2ONbd3c2VLgAAZigjFJGDLUekrfWYBH3hkeddHqdU1VRIdV2laHrs2yEDAAAAAID8QNiFuJw+fVr+/u//Xn/55Zft//Ef/xGcqv+W3++PelxQUBDX+QoLC6NWdkUiEQmFQpLotoqjvffee8rZYdxUDh8+zMoyAABSwNcbkKZH94q/LzjmtaAvLPua26V937vSuLFWPCXuDFQIAAAAAACyFWFXnrPb7VJfXz/0V3/1V4O1tbVD559/vllcXGyZpiknT55U9uzZY3v66acdTz31lH309oZPPPGEfdasWfpDDz0Umuz4fr8/KkzSdd2aaOx4XC7XuMeM9zjj+f73v6/de++92nSPAwAApscIRSYMukbz9wWl6dG9suGWS0Rz8jEWAAAAAACcwVWCPHbDDTdE7r333vCCBQvGDY4WLlxoLVy4cPCv//qvB/fv36/+9V//tevQoUMjK5v+7d/+zfHRj3508OMf//jgePNFRMLhcFTYpWnxZUtOp3PMc4FAIK5jAACA7Haw5ciUQdcwf19QDu0+IivWLk5xVcDMR388AAAAADMFYVcG3Hrrrc7vf//7KV9R9OUvf9n4+te/Hp7o9SuuuGIo1mMtX77cfPHFFwMXX3yxu729fSTw2rp1q/Oqq64aVNXxd/dzOp2WiIx8YzYMI9ZTiohIODy2/PFWewEAgNxkmpa0tR6La05ba4csq1/ERXkgQfTHAwAgcyzTFLOrW6xgSBSXLqq3TJQJrqsBAGJH2IWYeb1e68EHHwxddtllI40yDhw4oL766qtqTU2NOd6cs3tuhUKhuK5KBYNj7/I++5iJ+ru/+zvjuuuui8Qz5/Dhw+o111xD2gYAQJL0dw9EXWyPRcAXlv6eAZnlLUxRVcDMRX88AAAywwqFxNi5W4w9rWL1+0aeV4o8oq2sEW3NKlGS0KMeAPIVYRfisn79+qELL7zQ/NOf/jRyy8lvf/tbe01NzbhLtgoLoy9CDQwMxHW+s3t+2e32pK3smjt3rjV37tykBGcAACAxRiiu+07enxdMbB6Qz+iPBwBAZpg9vTKw/RGxevvGvGb1+yT8XLMYr+yTgk03ilpakoEKASD38c0lAz72sY8NlpaWpjxkWbt2bczbFMajoaFh8E9/+tPINoxtbW0TrrX2er1RP2dHR0dc67KPHTsWNb6srIxwCgCAGSTRrdI018zZYo2+SUgX+uMBAJB+Vig0YdAVNa63Twa2PyKFt93CCi8ASABhVwZcccUVQ/H0y8o28+fPj9qysKura8KrMVVVVVFj4w27jh49GnXsJUuWjLtdIgAAyE1FZQXi8jjj2srQ7XFKUWlBCqtKD/omIZ3ojwcAQGYYO3dPGXQNs3r7xNjVIs71a1NcFQDMPHQ/RNwcjuiLLpFIZMJvv9XV1VGh3sGDB+N6z73xxhtR4wm7AACYWVRVkaqairjmVNXMz/mL777egDz70B9kX3P7mKBvuG/Ssw/9QXy9gQxViJlmOv3xAABAYizTFGNPa1xzjJa9Yplc/gKAeBF2IW7vvfde1PvG6/VO+Bf4Qx/6UNRrra2ttkgk9h4bL7/8ctTqww9+8IM5uyIOAACMr7quUgqLY+vJWVjskvNXVaa4otSKt2+SER5MU2WYyeiPBwBA+pld3WL1++KaY/X7xOzqTlFFADBzEXYhbrt27bKNflxRUTFhH60LLrjAXLRo0cjrAwMDsnPnTttE40fz+/2yZ8+ekbGKoshVV13F1R4AAGYYTXdI48baKQOvwmKXNG6sFc2Z2ztxJ9I3CZgu+uMBAJB+VjCU1nkAkM8IuxCXtrY25eyw6rLLLps0gNqwYUPU7aDbt2+P6Rvzz3/+c4ff7x95fNFFF5mTBWsAACB3eUrcsmHzxXLhunPF7XFGveb2OOXCdefKhlsuEU+JO0MVJkeifZNMk49AmJ7h/njxmCn98QAAyBTFpad1HgDks9y+LRZpNTg4KJ///Oddg4PvZ1slJSXW//f//X+Tbi24adOmyAMPPKBZ1pmLNE888YTjzjvvNJYuXTrh9ofBYFC2bdumjX7us5/9rDG9nwAAAGQzTXfIirWLZVn9IunvGRAjGBHN5ZCi0oKc79E1bDp9k2Z5C1NUFfLBcH+8fc3tMc+ZCf3xAADIJNVbJkqRJ66tDJUij6jeshRWBQAzEyu78tSXvvQl56FDh2L+9z8wMCA33HCD6/nnn49a1XXHHXcYTufkd4iuWLHCvOaaa0YSMsMw5DOf+Yzr9OnT4443TVNuu+02/a233hqp7wMf+IB188030zAAAIA8oKqKzPIWyuwFxTLLWzijLrbTNwmZlG/98QAAyDRFVUVbWRPXHK2uVhSVS7YAEC/+y5mnHn/8ccfSpUsL1q9f7/7Rj37kOHTokDo0NHaB1okTJ5Qf/OAHjhUrVhT+4he/iFoJ+OEPf3jo1ltvjWm11b333htyu9/fdqi1tVWtr68vODs8O3TokPrJT37S9fDDD0dtdfiNb3wjpGlRC70AAAByDn2TkEn51h8PAIBsoK1ZJUpJcUxjlZJi0VbXpbgiAJiZ+PaSx0zTlN///ve23//+9zYRkYKCAikvLzeLiorEsizp6elRjh49Ou6t1FVVVeZvfvOboK7HtodwVVWV9dBDDwVvvPFG1/B2hvv371cvu+wyd1lZmTV//nyrq6tLOX78uDL8+rDPf/7zxvXXXz9pXzAAAIBcMNw3KZ6tDOmbhGQa7o93qOWotLV2SGDUe9HtcUpVzXw5f1UlQRcAAEmi6LoUbLpRBrY/IlZv38TjSoqlYNONosR4rQ0AEI1vMBgxMDAgo7cOnMjGjRsjP/zhD0Mejyeu499www2DlmUFN2/e7AoGgyPPd3d3K93d3eOGarfffrtx3333xdfYAgAAIEvRNwnZIB/64wEAkE3U0hIpvO0WMXa1iNGyN6qHl1LkEa2uVrTVdQRdADANhF156l/+5V9Cv/nNb+wvv/yy7e2331bPXk11tuLiYrnqqqsit956q1FTU2Mmet6NGzcOrlq1yr9161b96aeftkci4/efWLNmzdA999wTvvTSS8furQgAAJDDqusqpX3fu+LvC045lr5JSKXh/ngAAOQa07KkMxCSwOCQuO02KXfroirZfcOGouviXL9WtIZ6Mbu6xQqGRHHponrL6NEFAEmgWJbVn+kikFmnT5+W119/3XbkyBGls7NTHRgYEEVRZNasWVZpaan1wQ9+0KyurjbVJP/hPX36tLz44ov2trY21efzia7rUllZaa5Zs2Zo/vz5k6dvGbJ//351xYoVI/sIvf7667J06dJMlgQAQM4yTUv6uwfECEVE0x1SVJY/q0p8vQFpenTvpIHXcN8kT4l7wjEAAAD5JDA4JE3Hu+SFzh45Zbx/A/UszSEN5aXSOM8rbrttkiMAAFLpwIEDsmzZspHHr7322sDy5csTXjwTD8IuIA6EXQAATJ8RisjBliPS1nosqneVy+OUqpoKqa6rFE13ZLDC9DBCEfomAQAAxOhkMCzb9rdLV8iYcIxX12TL8sUy2+VMY2W5xzJNVpcBSIlMhl18ewYAAEDaTLaiKegLy77mdmnf925erGiibxIAAEBsAoNDUwZdIiJdIUO27W+Xr160RFys8BrDCoXE2LlbjD2tY/uGrawRbc0q+oYByFlE9gAAAEgLIxSZcus+ERF/X1CaHt0rRnhwzGumacmpk345ebRPTp30i2lm5c7HcRnumzR7QbHM8hYSdAEAAJyl6XjXlEHXsK6QIb873pXiinKP2dMr/vsflPBzzVFBl4iI1e+T8HPN4r//QTF7ejNUIQBMDyu7AAAAkBYHW45MGXQN8/cF5dDuI7Ji7WIRYetDAACAfGValrzQ2RPXnObOHrlywRxRFW4iEjmzomtg+yNi9fZNPq63Twa2PyKFt93CCi8AOYeVXQAAAEg507SkrfVYXHPaWjvENC3x9Qbk2Yf+IPua26OCLpH3tz589qE/iK83kMySAQAAkAU6AyE5ZUTimtNnRKQzEJ56YJ4wdu6eMugaZvX2ibGrJcUVAUDyEXYBAAAg5fq7B8YEVVMJ+MLS8+7paW99CAAAgNwVGBxKcB6fC0VELNMUY09rXHOMlr1imWaKKgKA1CDsAgAAQMoZofjuxh12+JVjcW99CAAAgJnDbbclOI/uLSIiZlf3mB5dU7H6fWJ2daeoIgBIDcIuAAAApFyi/bSOtcXXXHx460MAAADMDOVuXWZp8X2WLNYcUu52pqii3GIFQ2mdBwCZQtgFAACAlCsqKxCXJ74LDrrbIaEBI645AV9Y+nsG4poDAACA7KUqijSUl8Y1Z115qaiKkqKKcovi0tM6DwAyhbALAAAAKaeqilTVVMQ1p2LJ7ITOdeKdXjl10s8KLwAAgBmicZ5XvLoW01ivrsnl87wprih3qN4yUYo8cc1RijyiestSVBEApAZhFwAAANKiuq5SCotdMY0tLHbJeRfFF44Na/mvg/KrH+2Sp767Q/bteCvhfmEAAADIDm67TbYsXzxl4OXVNdmyfLG4EuzzNRMpqiraypq45mh1taKoXDYGkFv4rxYAAADSQtMd0rixdsrAq7DYJY0ba6X0f5wT99aHowV9YdnX3C7PPvQH8fUGEj4OAAAAMm+2yyn3XLREPlE5V4rP6uFVrDnkE5Vz5asXLZHZLnp1nU1bs0qUkuKYxiolxaKtrktxRQCQfPZMFwAAAID84Slxy4bNF8uhlqPS1tohAV945DW3xylVNfPl/FWVojnPfEytqqmQfc3t0zqnvy8oTY/ulQ23XDJyXAAAAOQet90mV1fOlSsXzJHOQFgCg4Pittul3O2kR9ckFF2Xgk03ysD2R8Tq7Zt4XEmxFGy6URSdfl0Acg/f9gEAAJBWmu6QFWsXy7L6RdLfMyBGMCKayyFFpQWiqtEXKarrKqV937vi7wtO65z+vqC8+nybfGBZuWi6Q4rKxp4LAAAAuUFVFJlXQCATD7W0RApvu0WMXS1itOwVq9838ppS5BGtrla01XUEXQByFmEXAAAAMkJVFZnlLZx0zPDWh02P7p124PXmHzvkzT92iIiIy+OUqpoKqa6rFE13TDETAAAAyH2Krotz/VrRGurF7OoWKxgSxaWL6i2jRxeAnMd/xQAAAJDVhrc+vHDdueKeRg+v0ejnBQAAgHylqKrY5swW+8IFYpszm6ALwIzAyi4AAABkvbO3PjzxTq+0/NfBaR+Xfl4AAAAAAOQ+YnsAAADkjOGtD+dUliTtmP6+oBzafSRpxwMAAAAAAOlF2AUAAICcU1RWIK4kbWkoItLW2iGmaSXteAAAAAAAIH0IuwAAAJBzVFWRqpqKpB0v4AtLf89A0o4HAAAAAADSh7ALAAAAOam6rlIKi11JO54RjCTtWAAAAABiY5mmDJ04KYPvHJWhEyfFMs1MlwQgB9GFGwAAADlJ0x3SuLFWmh7dK/6+4PSP53IkoSoAAAAAsbBCITF27hZjT6tY/b6R55Uij2gra0Rbs0oUXc9ghQByCSu7AAAAkLM8JW7ZsPliuXDdueKeRg8v3e2QUMCQUyf99O4CAAAAUszs6RX//Q9K+LnmqKBLRMTq90n4uWbx3/+gmD29GaoQQK5hZRcAAABymqY7ZMXaxbKsfpH09wyIEYzIn1/vlDf/2BHzMUKBiPzu3/8oIiIuj1Oqaiqkuq5SNJ3VXgAAAEAyWaGQDGx/RKzevsnH9fbJwPZHpPC2W1jhBWBKrOwCAADAjKCqiszyFsrsBcXyoUvPS7ifV9AXln3N7fLsQ38QX28gyVUCAAAA+c3YuXvKoGuY1dsnxq6WFFcEYCYg7AIAAMCMM9zPK9HAS0TE3xeUpkf3ihEeTGJlAAAAQP6yTFOMPa1xzTFa9oplmimqCMBMQdgFAACAGSkZ/bz8fUF59fk2OXm0j35eAAAAwDSZXd1jenRNxer3idnVnaKKAMwU9OwCAADAjHV2P6/wgCE7ntwnoQEj5mO8+ceOkf5f9PMCAABAqpiWJZ2BkAQGh8Rtt0m5WxdVUTJdVlJZwVBa5wHIH4RdAAAAmPGG+3mdsvxxBV1nG+7n1b7vXWncWCueEncSqwQAAEA+CgwOSdPxLnmhs0dOGZGR52dpDmkoL5XGeV5x220ZrDB5FJee1nkA8gfbGAIAACBvGKHI1INiQD8vAAAAJMPJYFjueuVNeebIe1FBl4jIKSMizxx5T+565U05GQxnqMLkUr1lohR54pqjFHlE9ZalqCIAMwVhFwAAAPJGMrce9PcF5dDuI0k7HgAAAPJLYHBItu1vl67Q5DsPdIUM2ba/XYKDQ2mqLHUUVRVtZU1cc7S6WlFULmMDmBz/lQAAAEDeKCorEJfHmbTjtbV2iGlaSTseAAAA8kfT8a4pg65hXSFDfne8K8UVpYe2ZpUoJcUxjVVKikVbXZfiigDMBIRdAAAAyBuqqkhVTUXSjhfwhaW/ZyBpxwMAAEB+MC1LXujsiWtOc2ePmFbu32il6LoUbLpxysBLKSk+M06nXxeAqRF2AQAAIK9U11VKYbEracczgsnpAwYAAID80RkIjenRNZU+IyKdgRnSu6u0RApvu0WcjQ1jengpRR5xNjZI4W23iFpakqEKgdxmWpYcHwjK4dN+OT4QnBFB+VTsmS4AAAAASCdNd0jjxlppenSv+PuC0z+eK3l9wAAAAJAfAgn23woMDia5ksxRdF2c69eK1lAvZle3WMGQKC5dVG9ZWnt0mZYlnYGQBAaHxG23SblbF1VR0nb+WORCjcNyqdbx5Hr9gcEhaTreJS909kQF6rM0hzSUl0rjPK+47bYMVpg6hF0AAADIO54St2zYfLEcajkqba0dEvAldoesq1ATc8iSk0f7RNMdUlRWIKqaO1+EAAAAkBmJXmx223Prcm4swYGiqmKbMzvtteVCKJALNQ7LpVrHk+v1i4icDIZl2/72cXsBnjIi8syR92TniV7ZsnyxzHYlr5d1tlAsy+rPdBFArti/f7+6YsWKguHHr7/+uixdujSTJQEAgGkyTUv6ewbECEbkz693ypt/7Ih5rkOzScR4/65cl8cpVTUVUl1XKZrOii8AAACMz7Qs+ULLG3FtZVisOeS+ugtyYpVJtgcHk4UCw7y6ltFQIBdqHJZLtY4n1+sXOfM7d9crb076Mwzz6pp89aIl4krB7+CBAwdk2bJlI49fe+21geXLl5tJP9E46NkFAACAvKaqiszyFsrsBcXyoUvPi6uf1+igS0Qk6AvLvuZ2efahP4ivN5DsUgEAADBDqIoiDeWlcc1ZV16aE0HXyWBY7nrlTXnmyHtjwrzh1SV3vfKmnAxmpv9YYHBoymBDRKQrZMi2/e0STHDLyenIhRqH5VKt48n1+oc1He+KKegSOfOz/O54V4orSj/CLgAAAOAvhvt5xRN4jcffF5SmR/eKEZ45PRUAAACQXI3zvOLVtZjGenVNLp/nTXFF05cLwUEuhAK5UOOwXKp1PLlev8iZlaIvdPbENae5s0dMy0pRRZlB2AUAAACMMtzP68J154rbE71FhUOLfZsHf19QDu0+kuzygLiZpiWnTvrl5NE+OXXSL6Y5s77UAgCQq9x2m2xZvnjKwGt4+7RUbDmWbNkeHORCKJALNQ7LpVrHk+v1D+sMhOLaElVEpM+ISGcgM6srUyW3OhoCAAAAaaDpDlmxdrEsq1800s/L4bTLc//ROmbrwsm0tXbIBas/IP7egBihiGi6Q4rKCkRVs3/7GeQ+IxSRgy1HpK31mAR973+RpbccAADZY7bLKfdctESajndJc2eP9I26YF2sOWRdealcPs+bE0FXosHBlQvmpG17xumEAvMK9BRVFS0XahyWS7WOJ9frHxZIcIVkYHBm7URC2AUAAABMYLifl4jIqZP+qMAgFgFfWJ7+7g4JDbx/dytBA9LB1xuQpkf3ir8vOOa14d5y7fvelcaNteIpcWegQgAAMMxtt8nVlXPlygVzpDMQlsDgoLjtdil3O3OiR9ewXAgOpgoFFMuSOX6fuCIRCToccqLQI5aipDUUCAwOTVjH5PPSH1zkesiS6/UPcycYhrvtMysemlk/DQAAAJAiRii+L+7DRgddIgQNSD0jFJkw6BptuLfchlsuEc3JV0MAADJNVZSsWi0Sr1wIDiYKBfRIRNa90y6XHH1HZoVDI8+fcury8oKF4l66MC31WaGQzHp5t9yze++4dTQvXCwhx/g3zGUiuMj1kCXX6x9W7tZlluaIK2wu1hxS7nZOPTCH0LMLAAAAiEGyV2ENBw1GOLvuCkTuO9hyZMqgaxi95QAAQLLkQnAwHAqMVjYwIF/c9YJ89PChqIBJRGRWOCQfPXxIirb/VMye3pTWZvb0iv/+B8W5Y+eEdXxx1wtSNjAwZm6mgovx/nlOJZtClkTqL3HYZbbvtAy+c1SGTpwUyzRTVF3sVEWRhvLSuOasKy/NqZWjsSDsAgAAAGJQVFYgLk9yv5QRNCDZTNOSttZjcc1pa+0Q04xusm2alpw66ZeTR/vk1En/mNcBAADOlgvBx9mhgB6JyOf/uEvKAoFJ51m9fTKw/RGxQqFJxyXKCoXOHL+3b9JxZYGAfP6Pu0SPRK/gyVRwkeshSzz165GIXHH4kNz53H9J8Ls/ksCPfyID3/mh+L/5HQk/15yy90asGud5xatrMY316ppcPs+b4orSj7ALAAAAiIGqKlJVU5H0444XNACJ6u8eSKi3XH/PmTuEjVBE9u14S5767g751Y92yf/7v3vkVz/aJU99d4fs2/FWwtt5AgCAmS9Xgo/RocC6d9qnDLqGWb19YuxqSUlNxs7dUwZdw8oCAVn7TvvI40wHF7kessRS/+jVf86B6PeL1e+T8HPN4r//wZSv/puM226TLcsXT/mzeHVNtixfLK4EV2JmM8IuAAAAIEbVdZVSWOxK6jFHBw3AdCUaRhnBiPh6A/LsQ3+Qfc3tYwKz4V5zzz70B/H1xnZBCAAA5J9cCD6GQ4HZTrtccvSduOYaLXuTvm2dZZpi7GmNa87qjndEsaysCC5yPWSZqv5sWf0Xi9kup9xz0RL5ROVcKT5rlWWx5pBPVM6Vr160RGa7smMbyWTLrk5qAAAAQBbTdIc0bqyVpkf3xtwTKRZGkNUySI5Ee8spqhLT+3q419yGWy4RzcnXSQAAEG04ONi2v126QsaE4zIdfMx2OeWuilIZCscXTFj9PjG7usU2Z3bSajG7usXq98U1Z1YoJJ8qcsqa5UuyIjwaDlmajndJc2eP9Bnvf78p1hyyrrxULp/nzYpaxzNZ/Vd0vBP36j/n+rWpKnVKbrtNrq6cK1cumCOdgbAEBgfFbbdLuduZNdtHpgrfTgAAAIA4eErcsmHzxXKo5ai0tXZIYNQKGN3tkFAg/uBKcyUWUABnG+4tF89Whm6PU46/1R1zgOvvC8re3x6SC1YtlKKyAlHVmf2lGQAAxCdXgg9nJCKJrFe3gslduZPo8RqKC8WeReFRrocs49avqlK083mJZ9N5o2WvaA31oqiZ3VRPVRSZV6BntIZ0I+wCAAAA4qTpDlmxdrEsq18k/T0DYgQjorkcUljslmfufzHuoKGotCCF1SKfDPeW29fcPvXgvzjvogppe+VYXOd569Xj8tarx8XlcUpVTYVU11UmvKoMAADMPLkQfCiuxIKAROdlex3JkuqQxTLNM6vhgiFRXLqo3rKkBkuj6x86cVIG4lx1l4rVf4gNYRcAAACQIFVVZJa3MOq5eIOGqpr5rIxBUlXXVUr7vndjWqlVWOyS/3FumezbEft7drThXl7t+96Vxo214ilxJ3QcAAAwM2Xz6hLVWyZKkSeuLQSVIo+o3rIZWcdkUh0wxVRDKCTGzt1i7GmN+melFHlEW1kj2ppVoujJfa8luuou2av/EBvCLgAAACCJ4g0azl9VmYaqkE9i7S1XWOySxo21EvTHvhJxIvTyAgAAuUZRVdFW1kj4ueaY52h1tUkPebKljvFkImAaj9nTKwPbHxGrt29sjf0+CT/XLMYr+6Rg042ilpYk7bzZvuouG0LI8WrKFL6FAAAAAEkUb9BAMIBUmKy3nNvjlKqa+XL+qkrRnHYZGkzOF1J/X1AO7T4iK9YuTsrxAAAAUk1bs0qMV/aNG6KcTSkpFm113YyuY7RMBUxjzhUKTVhH1LjePhnY/ogU3nZL0gK4bF11ly0h5Hg1BX79m7SedzS+WQMAAABJFk/QAKTKRL3likoLorbOLCorEJfHGVevuYkc2nNEZi8sFt2lSVFZAVt0AgCArKbouhRsunHKMEUpKZaCTTemLEDIljqGZTJgOpuxc3dMIeBwPcauFnGuX5uUc2fjqrtsCSEnqsnyD6TlnOPh2zUAAACQArEGDUCqjddb7uzX4+01N5FQICK/+/c/ioiIy+OUqpoKqa6rFE13TPvYAAAAqaCWlkjhbbeIsatFjJa9Y1fK1NWKtrou5QFTttQhktmAKerYpinGnta45hgte0VrqE9a4JRNq+6yKYSMt6Z0IOwCAAAAUmiqoAHIBvH0motV0BeWfc3t0r7vXWncWCueEnfSjg0AAJBMiq6Lc/1a0RrqM9oDKRvqyIaAaZjZ1R3XFoIiZ1Y3mV3dYpszOyk1ZNOqu2wJIROtKdUy260MAAAAAJBxw73mCotdST+2vy8oTY/uFSM8mPRjAwAAJJOiqmKbM1vsCxeIbc7stAZd2VLHdAKmZLOCobTOm8jwqjtnY4MoRZ6o15QijzgbG6TwtltS27sswRDSMpPTn3c8idSUSqzsAgAAAABM2mtuuvx9QTm0+4isWLs4accEAABA8mVLwCQiorgSWyWV6LxJj5nhVXfZsMotGTWlEmEXAAAAAEBExvaae+MP78hbrx5PyrEPthyRiiWzZdbsQvrWAQAAZKlsCphUb5koRZ64AhWlyCOqtyzptYwc/y+r7tItm0LIdBw7EWxjCAAAAACIMtxrrvbyJUnb2jAcjMizD74sT313h+zb8ZYYoUhSjgsAAIDkGQ6Y4pGqgElRVdFW1sQ1R6urzdj2k6mUTSFkOo6diJn3bx0AAAAAkBSp6OUV9IVlX3O7PPvQH8TXG0jacQEAADB92RYwaWtWiVJSHNNYpaRYtNV1Kakj07IphByWSE2pRNgFAAAAAJjQcC+vC9edK26PM2nH9fcFpenRvWKEB5N2TAAAAExfNgVMiq5LwaYbp6xHKSk+M07PrtVGyZJtIaRIYjWlEmEXAAAAAGBSw728Pnn7Wrnq86vlI5/5sOgF2rSP6+8LyqHdR5JQIQAAAJIl2wImtbRECm+7RZyNDWNWEilFHnE2NkjhbbeIWlqS0joyLZtCyGHx1JRq9kwXAAAAAADIDcO9vMQrsuTD82Vfc/u0j9nW2iHL6heJqipJqBAAAADJMBwwGbtaxGjZK1a/b+Q1pcgjWl2taKvr0raSStF1ca5fK1pDvZhd3WIFQ6K49DNb6c3AHl3jGQ4hB7Y/IlZv38Tj0rjKLdaa0oGwCwAAAAAQt+q6Smnf9674+4LTOk7AF5bTXX4pnpM9+/0DAAAgOwMmRVXFNmd2Rs6dDbIthDy7JuVXz6btvGdTLMvqz9jZgRyzf/9+dcWKFQXDj19//XVZunRpJksCAAAAMsbXG5CmR/dOO/Byuh1y/soFUl1XKZruSFJ1AAAAwMxlmWbWhJDDXt+/X5avWDHy+LXXXhtYvny5mY5z58f6PgAAAABA0nlK3LJh88Vy4bpzxe1xJnyccCAi+5rb5dmH/iC+3kASKwQAAABmpuFVbvaFC8Q2Z3bGg67hmjIl8z89AAAAACBnabpDVqxdLJ+8fa1c+blLxOlOfGWWvy8oTY/uFSM8mMQKAQAAAMx0hF0AAAAAgGlTVUWK53jk/JULpnUcf19QDu0+kqSqAAAAAOQDwi4AAAAAQNJU11VKYbFrWsdoa+0Q07SSVBEAAACAmY6wCwAAAACQNJrukMaNtdMKvAK+sPT3DCSxKgAAAAAzGWEXAAAAACCpPCVu2bD5Yrlw3bnidCXWw8sIRpJcFQAAAICZirALAAAAAJB0mu6QFWsXS+OnP5zY/ARDMgAAAAD5h7ALAAAAAJAys2YXisvjjGuO2+OUotKCFFUEAAAAYKYh7AIAAAAApIyqKlJVUxHXnKqa+aKqSooqAgAAADDTEHYBAAAAAFKquq5SCotdMY0tLHbJ+asqU1wRAAAAgJmEsAsAAAAAkFKa7pDGjbVTBl6FxS5p3FgrmtOepsoAAAAAzAR8gwAAAAAApJynxC0bNl8sh1qOSltrhwR84ZHX3B6nVNXMl/NXVRJ0AQAAAIgb3yIAAAAAAGmh6Q5ZsXaxLKtfJP09A2IEI6K5HFJUWkCPLgAAAAAJI+wCAAAAAKSVqioyy1uY6TIAAAAAzBD07AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOIuwCAAAAAAAAAABAziLsAgAAAAAAAAAAQM4i7AIAAAAAAAAAAEDOsme6AGQn0zTltddeU1977TX13XffVUOhkBQUFMi8efPMJUuWmCtWrDAdDse0ztHf3y8vvfSS7c0337T19/eLy+WShQsXmqtXrx6qqKiwkvSjAAAAAAAAAACAGYywC1Hee+895dvf/rb26KOPOk6cOKFMNM7tdsvFF1889OlPf9r49Kc/PRjPOdrb25WvfOUrzqeeesphGMaY1xVFkfr6+qG777473NDQMJTAjwEAAAAAAAAAAPIE2xhixEMPPeSoqqoqvO+++7TJgi4RkUAgIM8//7zt+9//vhbPOR577DH7ihUrCh977LFxgy4REcuy5MUXX7StX7/e/Y//+I9O0zTjOQUAAAAAAAAAAMgjrOyCiIjceuutzvGCq4KCAikvLzeLi4stv9+vvPvuu+rp06cTOsfjjz9u37hxo+vs8KqsrMyqqKiwurq6lHfffVexrDM7GFqWJffdd59mGIbcf//94YROCgAAAAAAAAAAZjRWdkHuvPPOMUHX9ddfH/n9738fOHXqlO/w4cMDe/bsCbzxxhsDp06d8rW3t/t/+MMfhi677LIhVY3tLXT48GHlpptuigq6li9fbjY1NQW6urr8r7766sCxY8f8Bw4cGLj66qujtkV84IEHtCeeeIJgFgAAAAAAAAAAjKFYltWf6SKQOc3NzbZLL73UPbyaqqioSJ588slAY2NjTL2yent7paSkZMpx1113nesXv/jFSGBVU1NjPv/88wPnnHPOmLGmacrmzZv17du3O4afW7RokXXo0CG/w+EYMz6d9u/fr65YsaJg+PHrr78uS5cuzWRJAAAAAAAAAABk3IEDB2TZsmUjj1977bWB5cuXp6VPESu78lgoFJJbbrlFHw667Ha7/OY3v4k56BKRmIKu/fv3q08++eRI0KVpmvz0pz8Njhd0iYioqioPPPBA6Nxzzx35JXj77beVhx9+OLNJFwAAAAAAAAAAyDqEXXnsBz/4gdbW1jbyHrj11luNNWvWxBx0xWr79u2O0dsXXnvttZGlS5dOmua6XC7ZsmWLMfq5n/zkJ4RdAAAAAAAAAAAgCmFXHhu9TaCmafLlL385nIrzPPvss1H9tjZt2hSJZd6nPvWpSEHByI6B0traajt27JiS5PIAAAAAAAAAAEAOI+zKU7t27bIdPHhw5N//Rz7ykcHS0tKkn+fgwYNqe3v7yHkKCgok1tVjhYWFUldXNzLWsiz59a9/bZ9sDgAAAAAAAAAAyC+EXXnq7NVW69atS/r2hSIir776atR7rLa2dsjhiH03wksuuWRw9ON9+/bZklQaAAAAAAAAAACYAQi78tTevXujQqMLL7xwJOxqbm62feYzn9Grq6sLioqKPB6Px7No0aLCj370o67vfe97jp6enpjP88Ybb0Sdp7q6etJeXWc7u7fXoUOHeM8CAAAAAAAAAIARbAmXp1555ZWo0Gjx4sXme++9p/zN3/yN/t///d9j3hd+v1/585//bP/v//5v+913363feeed4S9+8YvGVOdpa2uLOk9FRUVcYdf8+fOtyY4HAAAAAAAAAADyG8FBHurt7ZXe3l5l9HMDAwPKypUrC8YLus526tQp+dKXvuT81Kc+pRvG5HlXV1dX1Hnmz58fV9h1djjW3d2tTDQWAAAAAAAAAADkH1Z25aG+vr4xgdENN9zg6ujoUERE7Ha7fPKTnxxcv379YHl5uXX69Gl5+eWX7Y8//rijr69vZM5jjz3mmD17tvXd7343PNG5/H5/1OOCgoK4ai0sLIxa2RWJRCQUComu63EdZzzvvfeecnYYN5UDBw5EBcRvvfXWtOsAAAAAAAAAACDXnX29PByeMDpIOsKuPDRe2PWnP/1JFRFZuHCh9atf/SqwfPnyqBVVGzduHLzrrrvC119/vau5uXmkD9f999+vXXXVVYOXXnrp0NnHFDmz/eHox7quW+ONm4jL5Rr3mPEeZzzf//73tXvvvVebzjE+/vGPT7cMAAAAAAAAAABmnKNHj6q1tbVx7faWKLYxzENnB1DDPB6PPPfccwNnB13D5syZY/3mN78JXHDBBSOvW5Yl9957r3Oic4XD4ahzaVp82ZLTOfbQgUAgrmMAAAAAAAAAAICZi7ArA2699VanoiieVP9v69at44ZQE62K+uIXvxhevHjxpCum3G63PPDAA6HRz/3+97+3tbe3jxugOZ3OqONN1ePrbOMtcxxvtRcAAAAAAAAAAMhPbGOYhzwez5jnVFWVm2++ORLL/EsvvXTovPPOMw8fPjwSlu7YscO+ePHiMfPP7rkVCoXi6pEVDAbHPHf2MRP1d3/3d8Z1110X08887NVXX1U/85nPjKRtjz32WHDp0qVpWYYJIP0OHz6sXnPNNSO/80899VTwvPPO43cemIH4fQfyC7/zQH7hdx7IH/y+A5kVCoWko6NjJDdYt27dYLrOTdiVh8YLi5YsWWLOmTMn5hCpvr5+aHTYtXfvXtvf/M3fjBd2RT0eGBiIq9azt1y02+1JW9k1d+5ca+7cudMKzpYuXWpOtO0jgJnnvPPO43ceyBP8vgP5hd95IL/wOw/kD37fgfT78Ic/nJHfOcKuDPjYxz42WFpampTVSZNZu3bt0HjPz54921JVVUzz/fdcvHc4VFVVRY0/efLkuCu2vF5v1M85OtWNxbFjx6LGl5WVpfyfGwAAAAAAAAAAyB2EXRlwxRVXDF1xxRXjBlHp4HK5pLKy0vrzn/88ElAVFRXFFSKdPb6vr2/csOvsUCzesOvo0aNRx12yZAl3YgAAAAAAAAAAgBFxBQ+YOc4///yosC0cDsfVSysUCkU9drvd44Zl1dXVUec5ePBgXO+5N954I2o8YRcAAAAAAAAAABiNsCtPfehDH4ppG8KJnDx5Muq9M9G2jGefp7W11RaJjGntNaGXX345avXhBz/4wYytiAMAAAAAAAAAANmHsCtPXX311VGJ0759+2yje3hN5ZVXXol675y9XeGwCy64wFy0aNFIEDYwMCA7d+60xXIOv98ve/bsGRmrKIpcddVVgzEXCQAAAAAAAAAAZjzCrjy1cuVKc/78+SMh1KlTp6SpqSmmEKq7u1vZsWNH1IqrhoaGCUOoDRs2RAVr27dvd8Rynp///OcOv98/8viiiy4yKyoq4uotBgAAAAAAAAAAZjbCrjy2adMmY/Tje++91xnL6q5//ud/1sLh8MjjD3zgA9aHP/zhCSdu2rQpoijv75L4xBNPOA4cODDpey8YDMq2bdu00c999rOfNSYaDwAAAAAAAAAA8hNhVx77h3/4B2P27NkjK6Veeukl29atW52TzXnmmWfs3/ve96JCqH/4h38I2+32iabIihUrzGuuuWZk5ZdhGPKZz3zGdfr06XHHm6Ypt912m/7WW2+NvD8/8IEPWDfffHPszb4AAAAAAAAAAEBeIOzKY4WFhXLvvfeGRz/3z//8z9pf//Vfuw4ePBj13jhx4oRy5513Oq+77jrX0NDQyPOrV68e2rx585Qh1L333htyu90jj1tbW9X6+vqC559/PmrrxEOHDqmf/OQnXQ8//HDUVoff+MY3QpoWlbEBAAAAAAAAAADIxMtxkBduuummyJ49e2z/9m//NhIuPfHEE/YnnnjCPn/+fGv27NlWf3+/vP322+rokEtEpLKy0nr88ceDDsfULbiqqqqshx56KHjjjTe6LOvMYrL9+/erl112mbusrMyaP3++1dXVpRw/flwZfn3Y5z//eeP666+fsCcYAAAAAAAAAADIX4RdkB//+Mehc845x7rvvvu00UFTR0eH0tHRoYw3p66ubuiZZ54JlpeXW+O9Pp4bbrhh0LKs4ObNm13BYHDk+e7ubqW7u3vc89x+++3GfffdFx7vNQAAAAAAAAAAAMIuiKqqsm3btvAnPvGJwXvuuUd77rnn7KZpjjv2ggsuMLds2WLceOONEZvNNu6YyWzcuHFw1apV/q1bt+pPP/20PRIZfwfENWvWDN1zzz3hSy+9dGjcARni9XqtL3/5y8box5msB0Bq8TsP5A9+34H8wu88kF/4nQfyB7/vQP5SLMvqz3QRyC5dXV3Kzp07be3t7arf75dzzjnHmjt3rnXxxRcPLVy4MGl/IE6fPi0vvviiva2tTfX5fKLrulRWVppr1qwZmj9/Pn+IAAAAAAAAAADAlAi7AAAAAAAAAAAAkLPUTBcAAAAAAAAAAAAAJIqwCwAAAAAAAAAAADmLsAsAAAAAAAAAAAA5i7ALAAAAAAAAAAAAOYuwCwAAAAAAAAAAADmLsAsAAAAAAAAAAAA5i7ALAAAAAAAAAAAAOYuwCwAAAAAAAAAAADmLsAsAAAAAAAAAAAA5i7ALAAAAAAAAAAAAOYuwCwAAAAAAAAAAADmLsAsAAAAAAAAAAAA5y57pAoBccfjwYaWlpcXW0dGhGoYhxcXFVnV1tblmzZohl8uV6fIAAECaBINB2blzp+3gwYNqX1+fommazJ8/31y1atXQueeea2W6PgAAZgrTNOXPf/6z8tprr9k6OjqUU6dOKU6nU4qLi62qqiqzrq4u6d/H+/v75aWXXrK9+eabtv7+fnG5XLJw4UJz9erVQxUVFfydB1IoE7/zAGYOwi5gCk899ZT961//uvNPf/rTuCshCwsL5cYbb4zcc889Ya/XywdfAADSrKOjQ2lpabHt3r3btnfvXtsrr7xi8/l8I68vWLDAOnLkiH+65zlx4oRy9913Ox955BHHwMDAuGM+9KEPmVu3bg1/8pOfHJzu+QAAyEe9vb3y1FNPOX7729/am5ubbT09PcpEYx0Oh1xxxRWDt99+u3HppZcOTee87e3tyle+8hXnU0895TAMY8zriqJIfX390N133x1uaGiY1rkAvC9dv/Nvv/22snjx4sLp1GpZlm/qUQAyRbEsqz/TRQDZKBQKyWc/+1n98ccfd8QyvqyszPrFL34R5EMvkFu2bt3qvPfee7VE52/cuDHyyCOPhJJZE4Cpvfjii7b77rtP++Mf/2jr7Oyc8AuxSHLCrueff9523XXXuSb78j3aDTfcENm+fXvI6XRO57QAxpHKgFtRFM90amtvb/cvWrSIG+CABH3uc5/T/+///b/jhk1TueGGGyI/+MEPQuecc07ccx977DH7TTfd5AoEAlOOVRRFvvCFLxj/8i//ElZVuoMA05HO33nCLmDmY2UXMI6hoSG59tprXc8++2zU74jNZpP58+dbRUVF1pEjR9TTp0+PvNbd3a1s2LDB/dvf/jawZs0aAi8AAFJoz549tl/96ldp+Sy7Y8cO25VXXukOBoNRz8+aNUsqKyvNU6dOKceOHVOGht7/8/8f//EfDr/frzz99NNBLoQB0xdPwA0gd+3Zs8c23kVvm80mc+fOtWbPnm1FIhHp6OiI+j4ucuZv75tvvqn+/ve/D3g8sefWjz/+uH3jxo0u0zSjni8rK7MqKiqsrq4u5d1331Us60yObVmW3HfffZphGHL//feHE/gxAfxFJn7nAcxchF3AOL75zW9qZwddN998c+Sf/umfwsN7dA8NDckzzzxj/8IXvqB3dHQoIiKBQECuv/561+uvv+6fNWtWBioHAACFhYXi909710IRObOtyv/6X//LNTroWrBggfWd73wn9PGPf3xwOMg6evSo8rWvfc358MMPj6wI/+Uvf2n/9re/rX3xi1+M/1ZVAFHSGXADyA6zZs2S6667LvKxj31scO3atYNFRUUjrw0ODsqOHTtsd911l3PXrl224ef37t1r+/SnP+165plnguMe9CyHDx9Wbrrppqiga/ny5ea//uu/hi677LKRu1gOHjyo3nnnnc5f/vKXI/8deuCBB7T6+vqha6+9lq2LgSRIx+/8aOvXrx/asmULgTUwg/BlAThLd3e38q1vfStqz6Gvfe1r4a1bt0ZdqLLZbPI//+f/HKyrqxuor68vOHLkiCIicvz4cWXbtm3Oe++9lz+YQA765je/Gb7wwgtjXp05b948tioCMsjj8ciHPvShoZqamqG6urqhlStXDr399tvqZZdd5k7G8b/5zW86R68iWbhwofXSSy8NnN2gfsGCBda//du/hebPn2/eddddI58jvvGNbzhvuukmo6SkJBnlABhHMgPu0ZYtW2Z++9vfjmur4vLycj4XANNUWVlp3XnnneEbb7wx4naP/+fcbrfL+vXrh9auXRv43Oc+p2/fvn3kZpP//M//tD/33HO20WHVRLZu3aqP7sNZU1NjPv/88wNnb4tWXV1tPv3008HNmzdHneuOO+7QP/7xj/sdjpi6HwAYRzp/50crLy83P/KRj7AzEzCDEHYBZ/nnf/5nbfSe/2vWrBn6P//n/0x4R/b8+fOthx56KPiRj3xk5C/yAw88oP393/+9UVZWxpddIMfU1tYOrV+/ng+8QJa7+uqrI1dcccVgdXW1abPZol57++23k3KOEydOKD/60Y+ievo9+OCDwbODrtG2bt1qNDU12Xfu3GkTETl9+rR861vfcn7rW9/iJhggCVIdcI9WXFxscREMSK+77747/JGPfGQw1p6XdrtdfvzjH4deffVV2yuvvDKyb/DDDz+sXXbZZZOu9Ni/f7/65JNPjlwX0zRNfvrTnwYn6v+jqqo88MADoR07dtjeeustVeRMD6CHH37Y8bd/+7eRmAoGECWdv/MAZj4aCACjDA0Nyc9+9rOoW7LuuuuuKZvOXn755UOrV68e+SLs8/nkscceI0wGACBFzjvvPGvZsmVjgq5k+vnPf24fvVpkzZo1Q5dffvmkF75VVZV/+qd/igq2fvrTnzrO7gMCID5XX311ZP/+/QN9fX2+HTt2BP71X/81fN111w1+4AMf4OYyYAa56qqrYr7oPcxut8vZW5E1NTVN+QFh+/btUX+fr7322sjSpUsn/YPtcrlky5YtUTfD/uQnP2FZF5CgdP7OA5j5CLuAUXbu3Gnr7u4e2aroA/9/e3ceVWW18HF8P2cAzgGUSVABxysKmWjadWbliDmgZjZ4RUtTs7oNDlndq2/XTFe3wdtwXd0cGjBvOZSWtzDFDI1MwTQVlZyYNBQEZThwpuf9ozyd5wgIynAe/H7Wcq3O03MO+7DWZu9n//bQvr08ePDgGs3mnDZtmmIm15YtW+jwAgCgYl988YWiLXdt66syZMgQW7t27RwD8Hl5eVJKSgoP4MBNaIiAG4B6xcTEKJ7bL126JDlvT1gZ13O6p0+fXqN2ftKkSRZvb2/H67S0NG1OTo5UzVsA1LEbqfMAmj7CLsCJa2d3yJAh1uut6rpq+PDhikNpd+/era2PswMAAED9Ky4uFs6HXwshRGxsbI0OoNdoNGLw4MGKe7/88ktWfAMAUE8CAgKuWeVZVFRUZQB17NgxzalTpxwP+97e3mLAgAE1mujq4+Mjevfu7bhXlmXaeaCB1bbOA7g1EHYBTg4dOqQY1OrXr1+N9+gPCwuT27Zt62hszWazOHLkCHUMAAAVOnz4sNZi+WOCd7t27eTWrVvXeLs05+2NhRDi0KFD9AkAAKgnla2squ4M7Z9++knRLvfq1cum19d8c5Z+/fopJrW4jiUAqF+1rfMAbg3MPAGcnDhxQtHhjYqKqtWB1F26dLFlZmY66tWxY8e0ffr04ZAOAABUJj09XdEn6NKlS636BK59iBMnTjAIBgBAPUlOTlaMb7Vp00au7hyg9PR0RbscGRlZq+d217O9jh8/zqQWoAHVts5XJzMzUzp//rxUXl4uBQYGysHBwXJISAjBGaBChF3A78rKykR2drZiZkibNm1q1biFh4cr7qfDC6hTeXm5OHXqlCY/P1/S6/UiKCjIHhoaKjvvzQ+gaXOdAOPaxl+Pax8iKytLMplMwmAw1EXxADSg3NxcKTc3VyotLZUCAgLkoKAgOTQ0lEEwwI28//77imVZI0aMqHbr4YyMDEU7HxYWVquwy7Vf4Pp5AOpXbet8ZXbs2KFr1aqVz6+//nrNKrG2bdvKMTEx1pkzZ1pqusUpgMZH2AX87uLFi5Is/9Ff1ev1orYzOVq3bq3oIF+8eJH9ggGVeeKJJ7zOnj2rKS8vV1zX6XSiR48ettjYWOsTTzxhYaYX0LS5tuGhoaG1GgRr2bKlrNPphNX623O33W4X+fn5Um1DMwCN58iRI5r27dv7nD179po+fUhIiDxw4EDbQw89ZB41ahSDYEAj+vLLL3V79uxRrNR66KGHzNW9x7WdDw8Pr1U77xqO5efn8+wPNJAbqfOVqSzkuiozM1NKSEjQJyQk6O+66y7b+++/b2rXrh39eMDNMfME+F1JSYmikTMajUKjqV0VcV314fqZANzf8ePHrwm6hBDCarWK/fv3a5csWeLZvn17nxdeeMHz6iA2gKbHtQ2v7cpOjUZzzSou+gWAuhQWFkqVBV1CCJGXlydt3LhRN3r0aGP37t29OZcPaBwFBQVi9uzZXs7XxowZY+3bt2+14VVJSYnidW3beR8fH8Wgt8ViEZU9QwCoWzda52/Grl27tHfccYf3t99+y7bkgJujQw78rri4WPHa09Oz1jM2DAaD4j2uHWgATYPJZBLLli3zGDJkiNH1bweApsG1Dffy8qp1v8D1Pfy9AJqmQ4cOafr27ev9ySefsHMK0IBsNpuYNGmSITc31xFKN2/eXLz99tvXTZ1cJ6DUtp2vbFtiJrUA9etm6ryz0NBQeebMmZZPPvnEdPTo0dLCwsJis9lcfPHixZK9e/eWLl26tKJ9+/aKvwmFhYXSPffcY3Q91xeAe6EzDvyuvLxc0TH18PCo9We4HoZpMpno7AIqIEmS6N27t+3uu++29u7d2xYVFWUPDAyUNRqNyM/Pl9LS0rRbt27VrV27Vu88YzM5OVl73333Gb788kuTTkeTCjQlFRUV9AuAW1RgYKA8cuRI69ChQ63R0dH28PBwu6+vrygpKRGZmZma7777Trt69WqPw4cPOwa8TCaTmDp1qiEkJKRs0KBBbGsINIC5c+d6fvPNN4pO+IoVK0xt27a9bnB1s+28axsvxG/ngAOoPzdT54UQws/PT/78889NY8aMsWq11y7SCgoKkoOCguTevXub58+fb37xxRc9ly1b5mG3/7ZorKioSEyePNmQmppaWtudoAA0DGom8DvXmVxmc623+xUVFRXVfiYA9xMbG2tNT08v/eGHH8oWLVpkjo2NtYWHh8tGo1F4eXmJsLAweezYsdaVK1eWnzhxoqRv376KAazExETd22+/ra/q8wGok+sKb/oFwK3hww8/NOXm5pZ89NFH5VOmTLFGR0fbAwIChF6vF/7+/qJ79+72p556yvLzzz+XvvPOO+XOA95ms1lMnjzZYDKZGvEbALeGN954w+PNN99UJFRz5swxT5o0qUb7jN9sO+/axgtR+WovAHXjZuu8EEIEBASIcePGVRp0udLpdGLJkiUV//znPxWV/aefftJs3LiRma6AmyLsAn7n6+ureO0606smXGds+/j43GSpANS3gQMH2rp06VKj/b3btGkjJyUllfXu3VsReC1btsyztLS0fgoIoFG4tuGuK8BrwvU9rn0NAO5nypQp1spWbFTm8ccftyQkJJicZ3efO3dOeuutt2q/FBRAjSUkJOjmzZunqKjx8fGWV1999doEqgquZ27Vtp2vLNR2/UwAdaMu6vyNmjt3rnngwIGK5/+EhAQmuwJuirAL+J1rx7SsrExcXapcU66D3XR2gabHYDCIjz76SLFt4cWLF6XExERmdwFNiGsbXttA2263XzMQRr8AaHomTpxonTRpksX52scff8wgGFBPtmzZops2bZpBlv9oUseOHWtds2ZNeW22FXOd1FLbdt71fC6dTsfKLqAe1FWdvxlz5sxRLP387rvvdBaLparbATQiwi7gdy1atJAl6Y/+qsViEXl5ebWa3XXu3DlFnWrRogWDWkATFBERIY8aNUqxXYLr3uEA1M21Dc/Nza1Vv/nXX3+VrNY//kxoNBr6BUATNW/ePMUg2JEjRzTnz5/njD6gju3YsUP7wAMPGJzb18GDB9s+/fTTWp+f69omZ2dn16qdz8nJUdwfFBREGw/Usbqs8zdj6NChVufxwuLiYnHu3DnaecANEXYBvzMajSI8PFzRQc3MzKxV45WVlaW4PzIysnZLwwCoxuDBgxVhV0ZGBm0q0IR07txZ0Ya7tvHX49qHaNOmjcyMb6Bpio6OtjsPnMuyLE6cOEG/AKhDKSkp2vHjxxvLy8sd1/r06WPbsmVLWU23HnUWERGhaOdrG3a59gtc+w0Abk5d1/mb4ePjI/z8/BTjhRcuXCDsAtwQHXDAiWuHNz09/fqnVjo5ceKE4v4uXbrYqroXgLq1adNG0dm9ePEinV2gCXGdsHL8+PFa9QmOHTumuD8iIoI+AdCEhYaG0i8A6snBgwc1o0ePNpaUlDiuRUdH27/++uuyGz0nOzIyUtEuHzt2rFbjY+np6Yr7CbuAulMfdf5m6fXKHYotFgvtPOCGCLsAJ9HR0YoOb0pKSo0HtnJzcyXnWdx6vV507dqVDi/QROn1esWgFnt2A03L7bffbnN+qM3MzJRyc3Nr/FD7/fffK/oQ0dHR9AmAJox+AVA/jh07phk+fLixsLDQca1z5872bdu2lfn5+d3w5/bo0UPRLqelpWlrU29TUlIUe6i5jiUAuDH1VedvhsViEZcuXVI8BwQHB9O3B9wQYRfgZMyYMYptyXbu3Kmz22vWfm3btk3R2Y2JibH5+vrWYekAuJPz589zRh/QhDVr1kz0799fMXBV07P57Ha72Llzp+LeuLg4a1X3A1C/vLw8+gVAHTtz5ow0bNgwo/NKyXbt2snbt28vCwkJuak6FhUVZe/QoYPjM0pLS8WePXtqNNm1pKRE7Nu3z3GvJEm080AdqM86fzNSUlK0zueG6XQ60apVK9p5wA0RdgFOBgwYYAsMDHQ0WGfOnJF27txZow7vmjVrFGua4+LimM4JNGGuqzbCwsLo7AJNjOskGNe2vipJSUnas2fPOh7Sg4OD5b59+zLjG2iisrKyJNfze1y3OwZQO7m5udLQoUO9nVdVt27dWt6xY0ep61nbN2r06NGKZ/bVq1fXqJ1ft26d3nl7tTvuuMPOswBwcxqizt8o178NvXv3tnl7ezdWcQBUg7ALcKLVakV8fLyiw7t48WLP663u+uabb7TOA9++vr7iwQcfZGYX0EQVFhaKzZs3Kzq8gwcPps4DTcykSZMszg+ye/bs0W7fvr3aSTB2u10sXrxYcWr2lClTLFptrY78AqAiK1euVPQJwsLCZM7vAW5cQUGBGDZsmPH06dOOQe+goCD5m2++KevYsWOdDXpPnz7dIkl/5NQbNmzQHz16tNpxMpPJJF599VUP52sPP/ywua7KBNyKGqrO34ikpCTtunXrXCe38+wPuCnCLsDFCy+8YHY+8HL37t3apUuXelR1f3Z2tjRz5kyD87XHH3/czNYlQNM1Z84cr6KiIsdrDw8PMWrUKDq8QBPTsmVL+dFHH1UMYM2cOdOQk5NT5dldS5Ys8XDeBql58+biueeeq6jPcgJoPEePHtW8+eabioCbHR6AG3flyhURGxvrfezYMcd4lZ+fn0hMTCy77bbb6jRE7tatm33ChAmOPrzZbBZTp041XL58udL77Xa7ePLJJ71OnjzpKFv79u3lGTNmUOeBG9RQdT4xMVG7cuVKfW3O5tu+fbt24sSJRpvtjw0aWrZsKT/++OME3ICbqtG5A8CtpEWLFvKzzz5bsWjRIsdD68KFCz2zs7M1CxcurLi6PYHNZhObN2/WPfPMM17Z2dmOQa9WrVrJzz77LINagAosWbLEY/jw4dY///nPNepEWywWMX/+fM8PPvhAMbNrxowZ5tDQUAJuoIElJydrTSbTNdcPHjyoWEZVXl4utm3bVunSqtDQULlr165V/g14/vnnK9auXavPy8uThBDi7NmzUv/+/b3/9a9/lY8dO9aq0fz2XJ6VlSW99NJLnqtWrVL8fViwYEFFYGBg7b8cgAaVlpam2blzp+6xxx4z13RrorS0NM348eONxcXFjmsGg0E8//zzDIIBN2jMmDHGtLQ0xcTsJ598siI/P1+qqi2vyp133mkLCAio9p6XX365/KuvvvIpKysTQvxWrwcOHOi9fPny8iFDhjhGuI8fP6557rnnPLds2aIYR1u6dGm5h0eVc2MBXEdD1fmcnBzNzJkzvV588UXPCRMmWOLi4qy9evWy+fn5Ke6zWq1i37592hUrVuj/+9//6p13etJoNOLtt98uZwtDwH1JsixfaexCAO7GZrOJMWPGGL7++mtFR1ar1Yo2bdrIzZo1kzMzMzXOKzuE+O3hNjExsSwmJoZzOQAViImJMe7evVvbp08f27333msdNmyYNTIy0q7XK7frLyoqElu3btW9+uqrnj///LOiI96hQwf5xx9/LA0KCiLsAhpY27ZtfVzPyamtyZMnWxISEsqru+fbb7/Vjhw50lherrzNz89PtG3b1n758mUpOztbcp71KYQQo0ePtm7ZssV0NRADcHOqC7ife+45x0S14OBg+aOPPrr2RlF1wJ2UlKQdOnSoMSAgQB43bpx1/Pjxlt69e9tdd2uw2+3i8OHDmvfee0+/evVqj4oK5Ry31157rWLu3LmEXcANkiTJt64+a8eOHWXOgVVVPv74Y118fLxBlpXd+aCgIDk8PFy+ePGilJubK7n+/8cee8z873//m4muwE1oqDq/atUq/YwZM7xcr7du3Vr29/eXvb295StXrkg5OTka5zP5nMopXn/99fJnnnmGlZyAG2NlF1AJrVYrNm3aZJo6daphw4YNjnpis9nEmTNnJCHENQNrAQEB8vr1600EXYD67N27V7t3716tEMLT09NThIaGys2aNZO1Wq24dOmSlJmZKVV2dl9ISIj81VdflRF0AU3boEGDbF988UXZ/fffbygsLHT0AYqKikRRUVGlSdb9999v/eCDDwi6gDoUHx9vqEnAfeHCBWnEiBHGyv7f9QLuS5cuSWvWrNGvWbNGL8RvwVlgYKDs6+srl5SUSOfPn9cUFhZW+t6nn37aTNAFqM9f/vIXqyzLppkzZxqcA/X8/HwpPz+/0r85Tz/9tPn1118n6AJU7ty5c9K5c+eq7Vu0bNlSfv/9900jRoxgvA9wczx9A1UwGAxi/fr1pk8//dTUrVu3Krc38vb2FrNmzbIcPXq0tCazxgC4t4qKCnH69Gnp4MGDmrS0NM2ZM2cqDbpiY2OtBw8eLOUAeuDWMGzYMNvRo0dLZ86caTEaKx1DF0IIER0dbV+/fr3pk08+MXl5XTN5FIDKXLhwQTp27Jhm37592vT09EqDrmbNmokPP/zQtHz5cga+AZWaPHmy9eeffy65//77ra67PDgbMGCALSkpqWz58uUVTGgB1GPo0KHWhQsXVsTExNh8fa+/mEyj0Yju3bvb33nnnfKTJ0+WEHQB6sA2hkANZWRkSHv37tXm5ORozGaz8PPzk6OiouwDBw60GQyGxi4egBuQmJio/eyzz/R79uzRZmRkaFy3IHPl4+Mjhg8fbn3iiSfMgwYNorML3KLKysrEnj17tOnp6ZqioiLJw8NDhIWF2fv06WOLiIhgpSdQT+pz69L8/Hzpvffe0+/atUuXmpqqcV7FWZWIiAj7Qw89ZJk1a5b5eucCAVCPy5cvi+TkZF1GRoamuLhYeHl5ibZt29oHDBhgCw8Pp50HVM5ut4uTJ09Kv/zyiyYrK0tTVFQklZeXC29vb+Hv7y+3adPG3qdPH1vz5s0bu6gAaomwCwAAIURpaak4cuSI5uzZs5pz585JJSUlkt1uF35+fnJAQIAcFRVlj46Otut07AAMAEBTd+bMGSkjI0OTmZmpKSwslEwmk/Dy8hL+/v5y69at5b59+9rYxhgAAABwH4RdAAAAAAAAAAAAUC02GAYAAAAAAAAAAIBqEXYBAAAAAAAAAABAtQi7AAAAAAAAAAAAoFqEXQAAAAAAAAAAAFAtwi4AAAAAAAAAAACoFmEXAAAAAAAAAAAAVIuwCwAAAAAAAAAAAKpF2AUAAAAAAAAAAADVIuwCAAAAAAAAAACAahF2AQAAAAAAAAAAQLUIuwAAAAAAAAAAAKBahF0AAAAAAAAAAABQLcIuAAAAAAAAAAAAqBZhFwAAAAAAAAAAAFSLsAsAAAAAAAAAAACqRdgFAAAAAAAAAAAA1SLsAgAAAAAAAAAAgGoRdgEAAAAAAAAAAEC1CLsAAAAAAAAAAACgWoRdAAAAAAAAAAAAUC3CLgAAAAAAAAAAAKgWYRcAAAAAAAAAAABUi7ALAAAAAAAAAAAAqkXYBQAAAABNmCRJvlf/xcTEGBu7PE3VqlWr9M6/68r+JSUlaRujbNcrV3x8vFdjlAsAAACoK4RdAAAAAAAAAAAAUC3CLgAAAABoQKdPn5aut9KmLv79/e9/92zs7woAAAAADUHX2AUAAAAAAKCpeeaZZ8yxsbFW52s9evSwNUZZEhMTy5xf5+XlSVOnTjU0RlkAAACA+kDYBQAAAABAHYuKirLHxsY2SrjlyrUcp0+flhqrLAAAAEB9IOwCAAAAgAbUqlUr2XWlTVW2bdumW758ucfV1127drW/9tpr5TV5b8eOHe1CCCHLcvGNlRQAAAAA1IGwCwAAAAAakMFguGalTVWys7MV5yz7+/vL7rJaCAAAAADcheb6twAAAAAAAAAAAADuibALAAAAAAAAAAAAqsU2hgAAAACAGikuLhbJycnarKwszcWLF6XmzZvLPXv2tPfr18+m0VQ/lzIrK0v6/vvvtZmZmRqbzSZatWolDxgwwBoRESHXRdnOnj0r7d+/X/vrr79KhYWFUvPmzeXff4atdevWdfIzGpLZbBaHDh3SHDlyRJufny+VlpYKT09P4evrK7dr187euXNne6dOnVT3vQAAAID6QNgFAAAAAE2YJEm+V/974MCBtuTk5LKq7o2Pj/dau3at/urrU6dOlXTo0EHOzs6WFi5c6Llp0yZ9SUnJNe/r0KGD/MYbb5SPHTvW6vr/0tLSNAsWLPDauXOnVpavzWb69+9vW7FiRXm3bt3stf1uFRUV4p133vFYtWqV/vjx45WmbZIkiR49etj//ve/V4wfP/6a8rmbc+fOSS+99JLnp59+qi8sLKz23sDAQPmuu+6yTZs2zTxy5EjOcgMAAMAti20MAQAAAABV2rNnj7Z79+7eH374YaVBlxBCnD59Who/frxh+fLleufr//nPf/R9+/b1TkpKqjToEkKI77//Xtu/f3/v5ORkbW3KlZKSou3SpYvPvHnzPKsKuoQQQpZlceDAAc0999xjGDVqlKGq7+AOEhMTtVFRUT7vvvvudYMuIYQoKCiQNm3apFuyZIlnAxQPAAAAcFuEXQAAAACASmVkZGjGjBljvHTpkiSEEDqdTnTq1Mnes2dPu+vWgLIsi3nz5nnt2rVLK4QQa9eu1c2ePdvLYrEIIYTw9vYWkZGR9h49etj9/f0VP6ekpERMmDDBcOnSpRqVa/PmzbqhQ4caz549Kzlf9/DwEJ06dbL36tXLFhERYdfplJuZfPXVV7pBgwYZTSZT7X4RDeDw4cOacePGGS9fvqy47unp6fhOPXr0sHfs2NGu1+ur+BQAAADg1kTYBQAAAACo1KOPPmooKioSfn5+4rXXXqu4cOFCcUZGRmlqamppbm5uSUpKSultt93m2H7QbreLuXPnev3yyy/SrFmzDLIsi06dOtk3bNhgKigoKE5PTy89cOBA6YULF4rXrVtn8vPzc/ys/Px8afHixdddoXT48GHNpEmTDM6BVf/+/W1btmwxFRUVFWdkZJTu37+/7MSJE6UFBQXFK1asKA8ODnYEc6mpqdqnnnrKq85+SXVk/vz5nhUVFY7X3bp1s2/ZssV0+fJlx3c6cOBA6cmTJ0tLSkqK9+/fX/qPf/yjwvn3DwAAANyqCLsAAAAAAJXKzMyUgoOD5d27d5fOnTvX7Loiq2/fvvZvv/22rEWLFo4w6cCBA5oxY8YYy8rKRP/+/W2pqaml9957r9XT848cS6fTiQcffNC6YcMGxflhH3/8sd5sNldZHovFIh544AFF0LVw4cKK5OTksri4OKvBYFDc36xZMzF79mxLampq6Z/+9CdHKLRy5Up9amqq2zwPFxUViaSkJMcytIiICPsPP/xQGhcXp/i9XeXh4SF69eplX7RokfnIkSOlq1atKm/QAgMAAABuxm069wAAAAAA97NmzRpT165dq1w91KJFC/mpp55SJFQnTpzQ+Pv7y+vXrzc1a9asys8eOnSobciQIbarr/Pz86V9+/ZVeXbX+vXrdenp6Y7n2EceecSyePFis0ZT/aNteHi4vHHjRpPzfa+//rpHtW9qQKdOndJYrVbH6ylTpliMRmON3x8VFcXqLgAAANzSCLsAAAAAAJXq06ePbdSoUbbr3Tdu3Dir67VZs2ZZXM/1qkxcXJzF+fWBAweqfE598803HQGV0WgUr7zySo1XNEVHR9tHjx7tKOfWrVv1zgFTYzKZTIqzxziTCwAAAKgdwi4AAAAAQKUmTJhQozSoc+fOdg8P5UKpiRMnWqq4XaFbt26KVUlZWVmVPqfm5+dLqampjlVfd999tzUgIKAmP8Jh2LBhju9TUlIi0tLS3OKZODQ0VPE72Lhxo6667RwBAAAAKLlFxx4AAAAA4H569ep13VVdQvx2BlezZs0cq7j0ev01IVZVgoKCFKu/iouLpcruS05O1sryH7f27NmzRmVz1rZtW8XPOnbsWJVbJjak9u3by85niu3fv18bGxtr3L17t1uUDwAAAHB3hF0AAAAAgEoFBwdfdxvCq5zPmPL395d1Ol1N36f4GSaTqdL7nM/qEkKIF154wVOSJN/a/IuLizM4f0ZBQUGlwVpjWLRoUYXz6127dmljYmKM7dq185kxY4bX2rVrdWfOnHGb8gIAAADuhLALAAAAAFApLy+vGoddLu+74Z/pvHrLWX0EU5cvX67rj7xh8fHx1v/7v/+rkCTl18zMzJRWrVqlj4+PN3To0MGnbdu2PtOnT/favn271m6v0eI5AAAAoMkj7AIAAAAAuL3Lly/Xedhlt9vdaqXUiy++aN6zZ09ZbGysVautfAfDrKwsac2aNfrhw4cbb7/9du/ExES2OgQAAMAtr2b7SgAAAAAA0Ihctzv861//ah41apT1Zj6zY8eObrc0ql+/frbExERTbm6utG3bNt2uXbu0e/bsqXQLw/T0dM3IkSONr7zySsX8+fPNjVFeAAAAwB0QdgEAAAAA3F5gYKAi7GrZsqUcGxtra6zy1LfQ0FB52rRplmnTplmEECInJ0dKSkrSbd68Wfe///1PZ7FYhBC/bfu4YMECz379+tn69+/fZH8fAAAAQHXYxhAAAAAA4PY6dOigCLtOnTp1Sz3PhoWFyVOnTrV8/vnnphMnTpT07NnTsSpNlmWxfPlyj8YsHwAAANCYbqmHAwAAAACAOg0ePFixZeGuXbtu2Z1K2rdvL69bt67M+VpKSgpndwEAAOCWRdgFAAAAAHB74eHhclRUlGM10+nTp6WtW7fesgFPRESEHBwc7FjtVlBQcM2ZXgAAAMCtgrALAAAAAKAK8+bNMzu/njNnjldRUVEjlaZxVVRUiOLiYkfA5efnJ1d3PwAAANCUEXYBAAAAAFQhPj7eEhkZ6Vjd9csvv2hGjBhhzMnJqfGqJrPZLNasWaN/+eWX3eaMq4SEBN1LL73kcenSpRq/56233vIwmUyO1z169LDVR9kAAAAANSDsAgAAAACogk6nE5s2bTI1b97cce3HH3/UduvWzedvf/ub5/Hjxyt9xj1//ry0ZcsW3SOPPOIVGhrqM336dK+q7m0MeXl5mkWLFnmGh4f7jh8/3rB27VrdmTNnKg3wjh8/rpk9e7bXggULPJ2vz5gxw9IwpQUAAADczy17oC8AAAAAQH0iIyPtGzduLLvvvvuMhYWFQgghCgsLxdKlSz2WLl3qERgYKIeEhMje3t7ylStXpIKCAik/P18V51mVlZWJzZs36zZv3qwTQgg/Pz8RHBxs9/Pzk81ms5STk1Ppd5k4caJ1woQJ1oYvMQAAAOAeCLsAAAAAAKoydOhQ248//ljy4IMPGtPS0hQrtAoKCqSCgoJqwy1JkkRYWJjbn3FVVFQkioqKql2BNm3aNMu7775b3lBlAgAAANyR22zbAAAAAABATXXq1ElOTU0t/fzzz0133XWXzcOj+iO4tFqt6N27t23RokUVGRkZJcuWLatooKJe12OPPWb+7LPPTA8//LClY8eO9uvd7+npKeLi4qy7du0qW716dbler2+IYgIAAABuS5Jl+UpjFwIAAAAAgJtRWloqUlJStNnZ2Zr8/HzJZDIJHx8f0aJFC3vnzp3tt912m93Hx6fefv6qVav0M2bM8Lr6euXKleWPPPLIDZ2jlZeXJx09elRz6tQpzaVLl6SysjJhNBqFv7+/HBkZae/Ro4ftZr7L6dOnpY4dOzo+YPLkyZaEhARWhwEAAEC12MYQAAAAAKB63t7eYtiwYTYhhK2xy3KzQkJC5JCQENvgwYNV/10AAACAhsA2hgAAAAAA1LEZM2Z4SZLk6/wvKSlJ2xhlcS2H86ouAAAAoCkg7AIAAAAAAAAAAIBqEXYBAAAAAAAAAABAtSRZlq80diEAAAAAAFCz3Nxc6ciRI9VOKL3zzjttAQEBDVUkh23btlW7fWJoaKjctWtXe0OVBwAAAKhrhF0AAAAAAAAAAABQLbYxBAAAAAAAAAAAgGoRdgEAAAAAAAAAAEC1CLsAAAAAAAAAAACgWoRdAAAAAAAAAAAAUC3CLgAAAAAAAAAAAKgWYRcAAAAAAAAAAABUi7ALAAAAAAAAAAAAqkXYBQAAAAAAAAAAANUi7AIAAAAAAAAAAIBqEXYBAAAAAAAAAABAtQi7AAAAAAAAAAAAoFqEXQAAAAAAAAAAAFAtwi4AAAAAAAAAAACoFmEXAAAAAAAAAAAAVIuwCwAAAAAAAAAAAKpF2AUAAAAAAAAAAADVIuwCAAAAAAAAAACAahF2AQAAAAAAAAAAQLUIuwAAAAAAAAAAAKBahF0AAAAAAAAAAABQLcIuAAAAAAAAAAAAqBZhFwAAAAAAAAAAAFSLsAsAAAAAAAAAAACqRdgFAAAAAAAAAAAA1SLsAgAAAAAAAAAAgGoRdgEAAAAAAAAAAEC1CLsAAAAAAAAAAACgWoRdAAAAAAAAAAAAUC3CLgAAAAAAAAAAAKgWYRcAAAAAAAAAAABUi7ALAAAAAAAAAAAAqkXYBQAAAAAAAAAAANX6f2tBWyEMVESKAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -740,7 +742,7 @@ " 'simultaneous correction',\n", ")\n", "maxiter = 10000\n", - "maxtime = 20\n", + "maxtime = 30\n", "residual_profiles = [\n", " MESH.convergence_analysis(\n", " maxiter, maxtime, algorithm=alg, \n", @@ -771,14 +773,6 @@ "plt.show()" ] }, - { - "cell_type": "markdown", - "id": "4b401f96-5409-4217-8412-1418bc88960e", - "metadata": {}, - "source": [ - "The inside-out method is the most robust for this test case with many chemicals and stages. " - ] - }, { "cell_type": "markdown", "id": "42ae2416-0312-4eec-89ed-57d881408814", diff --git a/docs/tutorial/Thermodynamics.ipynb b/docs/tutorial/Thermodynamics.ipynb index 80eb5c7e..e780453c 100644 --- a/docs/tutorial/Thermodynamics.ipynb +++ b/docs/tutorial/Thermodynamics.ipynb @@ -48,7 +48,7 @@ "\n", "For vapor-liquid equilibrium, this is equivalent to the following equation:\n", "\n", - "$$ \\Phi_i y_i P = \\gamma_i x_i P_{\\mathrm{sat},i} F_i $$\n", + "$$ \\Phi^\\alpha_i y_i P = \\Phi^\\beta_i x_i P = \\gamma_i x_i P_{\\mathrm{sat},i} F_i $$\n", "\n", "- $P$ - Pressure [Pa].\n", "- $P_\\mathrm{sat}$ - Saturation vapor pressure [Pa].\n", @@ -135,9 +135,9 @@ "source": [ "PR_thermo = bst.Thermo(\n", " hydrocarbon_chemicals, \n", - " pkg='Peng Robinson',\n", - " # By default, activity coefficients are ignored, but can be added with the following:\n", - " # Gamma=bst.PR78ActivityCoefficients\n", + " pkg='Peng Robinson', \n", + " # Activity coefficients are not used, \n", + " # only the fugacity coefficient of liquid and vapor phases.\n", ")\n", "PR_thermo.chemicals.set_alias('n-Butane', 'Butane')\n", "PR_thermo" diff --git a/thermosteam b/thermosteam index 8911fb2f..9cf8b69a 160000 --- a/thermosteam +++ b/thermosteam @@ -1 +1 @@ -Subproject commit 8911fb2fa271942412c98b3c50349f56cace03dc +Subproject commit 9cf8b69a074662a3b6f990fda8a7ec7a749b0f79 From 8f3e22733ff5f454687e9543b5761d2df0c7892f Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 21:09:25 +0800 Subject: [PATCH 23/26] minor enhancements --- biosteam/_unit.py | 5 +- docs/tutorial/Distillation.ipynb | 118 +++++++++++++++++++++++-------- 2 files changed, 94 insertions(+), 29 deletions(-) diff --git a/biosteam/_unit.py b/biosteam/_unit.py index 1b8bd62e..c20bce9e 100644 --- a/biosteam/_unit.py +++ b/biosteam/_unit.py @@ -247,7 +247,10 @@ def __init_subclass__(cls, name = cls.__name__ if hasattr(bst, 'units') and hasattr(bst, 'wastewater') and hasattr(bst, 'facilities'): # Add 3rd party unit to biosteam module for convenience - if name not in bst.units.__dict__: + if isinstance(cls, bst.Facility): + if name not in bst.facilities.__dict__: + bst.facilities.__dict__[name] = cls + elif name not in bst.units.__dict__: bst.units.__dict__[name] = cls if name not in bst.__dict__: bst.__dict__[name] = cls diff --git a/docs/tutorial/Distillation.ipynb b/docs/tutorial/Distillation.ipynb index 5b17640e..b4331f37 100644 --- a/docs/tutorial/Distillation.ipynb +++ b/docs/tutorial/Distillation.ipynb @@ -47,7 +47,7 @@ " " + "" ] }, "metadata": {}, @@ -443,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 11, "id": "95363b2f-4752-4455-9f75-97cee18b5950", "metadata": {}, "outputs": [ @@ -462,37 +462,37 @@ " n-Hexane 30.6\n", " n-Heptane 12.7\n", " Cyclohexane 3.98\n", - " Cycloheptane 0.0696\n", + " Cyclopentane 0.0696\n", " Benzene 33.5\n", " Toluene 0.00904\n", " Hydrogen 1e-16\n", " ------------ 243 kmol/hr\n", "outs...\n", "[0] distillate \n", - " phase: 'g', T: 401.04 K, P: 366463 Pa\n", - " flow (%): n-Butane 0.612\n", + " phase: 'g', T: 401.02 K, P: 366463 Pa\n", + " flow (%): n-Butane 0.611\n", " n-Pentane 21.2\n", " n-Hexane 35.1\n", " n-Heptane 0.291\n", " Cyclohexane 4.46\n", - " Cycloheptane 5.08e-07\n", + " Cyclopentane 0.0797\n", " Benzene 38.3\n", - " Toluene 4.01e-06\n", + " Toluene 4.06e-06\n", " ------------ 212 kmol/hr\n", "[1] bottoms_product \n", - " phase: 'l', T: 422.07 K, P: 366463 Pa\n", - " flow (%): Ethane 5.93e-07\n", - " Propane 0.00201\n", - " n-Butane 8.94e-13\n", - " n-Pentane 3.11e-08\n", - " n-Hexane 0.0584\n", - " n-Heptane 98.1\n", - " Cyclohexane 0.626\n", - " Cycloheptane 0.548\n", - " Benzene 0.591\n", - " Toluene 0.0711\n", - " Hydrogen 7.87e-16\n", - " ------------ 30.8 kmol/hr\n" + " phase: 'l', T: 421.98 K, P: 366463 Pa\n", + " flow (%): Ethane 5.97e-07\n", + " Propane 0.00203\n", + " n-Butane 8.78e-13\n", + " n-Pentane 3.2e-08\n", + " n-Hexane 0.0595\n", + " n-Heptane 98.6\n", + " Cyclohexane 0.629\n", + " Cyclopentane 5.1e-08\n", + " Benzene 0.594\n", + " Toluene 0.0715\n", + " Hydrogen 7.91e-16\n", + " ------------ 30.7 kmol/hr\n" ] } ], @@ -500,7 +500,7 @@ "hydrocarbons = [\n", " 'Ethane', 'Propane', 'n-Butane', \n", " 'n-Pentane', 'n-Hexane', 'n-Heptane', \n", - " 'Cyclohexane', 'Cycloheptane', 'Benzene',\n", + " 'Cyclohexane', 'Cyclopentane', 'Benzene',\n", " 'Toluene', 'Hydrogen'\n", "]\n", "bst.settings.set_thermo(hydrocarbons, pkg='Peng Robinson')\n", @@ -667,7 +667,7 @@ "# P=[366463.0 + i*690.0 for i in range(42)]\n", "# )\n", "MESH.simulate()\n", - "MESH.show('cmol100')" + "MESH.show('cmol100')\t" ] }, { @@ -694,13 +694,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "id": "1bde2894-8f3d-4dba-b611-81c40647fda3", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -716,7 +716,7 @@ " Ethane=1.829e-07, Propane=0.0006211,\n", " **{'n-Butane': 1.296, 'n-Pentane': 44.89, \n", " 'n-Hexane': 74.35, 'n-Heptane': 30.86}, \n", - " Cyclohexane=9.647, Cycloheptane=0.1689, Benzene=81.36, \n", + " Cyclohexane=9.647, Cyclopentane=0.1689, Benzene=81.36, \n", " Toluene=0.02193, Hydrogen=2.426e-16,\n", " units='kmol/hr'\n", ")\n", @@ -727,8 +727,8 @@ " N_stages=N_stages, ins=[feed], feed_stages=[29],\n", " outs=['distillate', 'bottoms'],\n", " stage_specifications={\n", - " 0: ('Reflux', 0.857), \n", - " -1: ('Flow', 0.76) # Bottoms product flow rate as a fraction of column feed\n", + " 0: ('Reflux', 0.857148), \n", + " -1: ('Flow', 0.7795737913167857) # Bottoms product flow rate as a fraction of column feed\n", " },\n", " LHK=('Cyclohexane', 'n-Heptane'),\n", " P=[P_condenser + i*dP for i in range(N_stages)],\n", @@ -773,6 +773,68 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": 13, + "id": "40e35de7-0315-49f7-8583-f1e8e5b4af50", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MESHDistillation: D2\n", + "ins...\n", + "[0] feed \n", + " phase: 'l', T: 329.54 K, P: 372615 Pa\n", + " flow (%): Ethane 7.54e-08\n", + " Propane 0.000256\n", + " n-Butane 0.534\n", + " n-Pentane 18.5\n", + " n-Hexane 30.6\n", + " n-Heptane 12.7\n", + " Cyclohexane 3.98\n", + " Cyclopentane 0.0696\n", + " Benzene 33.5\n", + " Toluene 0.00904\n", + " Hydrogen 1e-16\n", + " ------------ 243 kmol/hr\n", + "outs...\n", + "[0] distillate \n", + " phase: 'g', T: 376.7 K, P: 351625 Pa\n", + " flow (%): Ethane 3.55e-07\n", + " Propane 0.00121\n", + " n-Butane 2.51\n", + " n-Pentane 60.3\n", + " n-Hexane 20.2\n", + " n-Heptane 0.00295\n", + " Cyclohexane 1.12\n", + " Cyclopentane 0.119\n", + " Benzene 15.8\n", + " Toluene 2.31e-09\n", + " Hydrogen 4.71e-16\n", + " ------------ 43.2 kmol/hr\n", + "[1] bottoms \n", + " phase: 'l', T: 383.69 K, P: 381300 Pa\n", + " flow (%): Ethane 2.13e-20\n", + " Propane 1.38e-12\n", + " n-Butane 0.000225\n", + " n-Pentane 7.24\n", + " n-Hexane 33.5\n", + " n-Heptane 16.2\n", + " Cyclohexane 4.75\n", + " Cyclopentane 0.0562\n", + " Benzene 38.3\n", + " Toluene 0.0115\n", + " Hydrogen 2.09e-41\n", + " ------------ 189 kmol/hr\n" + ] + } + ], + "source": [ + "MESH.show('cmol100')" + ] + }, { "cell_type": "markdown", "id": "42ae2416-0312-4eec-89ed-57d881408814", From 0ca849933b66719deb63cd0a47c0e1d7c77973e6 Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 21:53:15 +0800 Subject: [PATCH 24/26] add structure for future extensions --- biosteam/__init__.py | 41 ++++++++++++++++------------------------- 1 file changed, 16 insertions(+), 25 deletions(-) diff --git a/biosteam/__init__.py b/biosteam/__init__.py index a40337a6..1fdea6f1 100644 --- a/biosteam/__init__.py +++ b/biosteam/__init__.py @@ -79,38 +79,29 @@ def njit(*args, **kwargs): from . import report from . import _settings -# %% Heat exchanger network synthesis (hensmith) -# -# HeatExchangerNetwork lives in the hensmith package -# (github.com/BioSTEAMDevelopmentGroup/hensmith). hensmith subclasses Facility, -# so it imports biosteam eagerly and can only be imported once biosteam is -# fully initialized -- here, last. hensmith binds HeatExchangerNetwork into -# biosteam and biosteam.facilities at the end of its own __init__, which makes -# either import order work: importing biosteam first initializes hensmith right -# here; importing hensmith first makes this `import hensmith` return the -# still-initializing module, and hensmith binds the name when it finishes. The -# name must stay out of facilities.__all__, which is star-imported above before -# hensmith can bind it. Without hensmith installed, biosteam imports and simply -# lacks the name (guarded by tests/test_hensmith_integration.py). +__all__ = [ + 'Unit', 'PowerUtility', 'UtilityAgent', 'HeatUtility', 'Facility', + 'utils', 'units', 'facilities', 'wastewater', 'evaluation', 'Chemical', 'Chemicals', 'Stream', + 'MultiStream', 'settings', 'exceptions', 'report', 'units_of_measure', + 'process_tools', 'preferences', *_system.__all__, *_flowsheet.__all__, + *_tea.__all__, *units.__all__, *facilities.__all__, *wastewater.__all__, + *evaluation.__all__, *process_tools.__all__, *_module.__all__, +] + +# %% Load premire biosteam extensions which offer comprehensive simulation capabilities. + +# Add heat exchanger network synthesis capabilities from hensmith library. try: import hensmith except ModuleNotFoundError as error: if error.name != 'hensmith': raise - _hensmith_all = () else: del hensmith - _hensmith_all = ('HeatExchangerNetwork',) + __all__.append('HeatExchangerNetwork') -__all__ = ( - 'Unit', 'PowerUtility', 'UtilityAgent', 'HeatUtility', 'Facility', - *_hensmith_all, - 'utils', 'units', 'facilities', 'wastewater', 'evaluation', 'Chemical', 'Chemicals', 'Stream', - 'MultiStream', 'settings', 'exceptions', 'report', 'units_of_measure', - 'process_tools', 'preferences', *_system.__all__, *_flowsheet.__all__, - *_tea.__all__, *units.__all__, *facilities.__all__, *wastewater.__all__, - *evaluation.__all__, *process_tools.__all__, *_module.__all__, -) -del _hensmith_all +# Future extensions can be added here. + +# %% Non-essential representation features. def nbtutorial(dark=False): global print_error From 0267b02b4de0f269971f9870fb16d00e22c1ecbe Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 21:54:34 +0800 Subject: [PATCH 25/26] keep docs consice --- docs/API/facilities/HeatExchangerNetwork.txt | 14 ++++---------- docs/API/units/stirred_tank_reactor.txt | 4 ---- 2 files changed, 4 insertions(+), 14 deletions(-) delete mode 100644 docs/API/units/stirred_tank_reactor.txt diff --git a/docs/API/facilities/HeatExchangerNetwork.txt b/docs/API/facilities/HeatExchangerNetwork.txt index fadd6765..68da2f68 100644 --- a/docs/API/facilities/HeatExchangerNetwork.txt +++ b/docs/API/facilities/HeatExchangerNetwork.txt @@ -2,17 +2,11 @@ HeatExchangerNetwork ==================== .. note:: - :class:`~hensmith.HeatExchangerNetwork` has moved to the - `hensmith `_ package + :class:`~hensmith.HeatExchangerNetwork` originates from the + `HENSMITH `_ (Heat Exchanger Network Synthesis, Modeling, Integration, Thermodynamics, - and Heuristics), which is a dependency of BioSTEAM. It remains available - as ``biosteam.HeatExchangerNetwork`` and - ``biosteam.facilities.HeatExchangerNetwork`` (bound when BioSTEAM is - imported), but ``from biosteam.facilities import *`` no longer provides - the name — import it explicitly (``from biosteam import *`` still - provides it). The network synthesis helpers (``StreamLifeCycle``, - ``ProblemTable``, ``problem_table``, ``synthesize_network``, - ``plot_pinch_diagram``) now live in ``hensmith`` only. + and Heuristics) library, which provides comprehensive features for + heat exchanger network synthesis. .. autoclass:: hensmith.HeatExchangerNetwork :members: diff --git a/docs/API/units/stirred_tank_reactor.txt b/docs/API/units/stirred_tank_reactor.txt deleted file mode 100644 index 6b9ac8c7..00000000 --- a/docs/API/units/stirred_tank_reactor.txt +++ /dev/null @@ -1,4 +0,0 @@ -stirred_tank_reactor -==================== - -.. automodule:: biosteam.units.stirred_tank_reactor \ No newline at end of file From fa61c73aca8fd08dc5b48ec19bc101f25679aa7f Mon Sep 17 00:00:00 2001 From: Yoel Date: Sat, 5 Sep 2026 21:55:45 +0800 Subject: [PATCH 26/26] add hensmith as submodule for documentation --- .gitmodules | 3 +++ hensmith | 1 + 2 files changed, 4 insertions(+) create mode 160000 hensmith diff --git a/.gitmodules b/.gitmodules index ddab1b2b..d7bc486d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,3 +7,6 @@ [submodule "How2STEAM"] path = How2STEAM url = https://github.com/BioSTEAMDevelopmentGroup/How2STEAM.git +[submodule "hensmith"] + path = hensmith + url = https://github.com/BioSTEAMDevelopmentGroup/hensmith.git diff --git a/hensmith b/hensmith new file mode 160000 index 00000000..aa9041bb --- /dev/null +++ b/hensmith @@ -0,0 +1 @@ +Subproject commit aa9041bbcd12774229bc8fed8d69e67356f84733