From 95326b0f0bea204f91901a6fd9db2d2a8e9917cd Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Mon, 3 Jun 2024 22:58:25 -0700 Subject: [PATCH 01/12] initial pass at defining lists of systems for time responses --- control/nlsys.py | 15 ++++++++-- control/tests/timeplot_test.py | 8 +++++ control/timeresp.py | 53 +++++++++++++++++++++++++++------- 3 files changed, 63 insertions(+), 13 deletions(-) diff --git a/control/nlsys.py b/control/nlsys.py index 358c4b125..80b8aa73c 100644 --- a/control/nlsys.py +++ b/control/nlsys.py @@ -1317,7 +1317,7 @@ def nlsys( def input_output_response( - sys, T, U=0., X0=0, params=None, ignore_errors=False, + sysdata, T, U=0., X0=0, params=None, ignore_errors=False, transpose=False, return_x=False, squeeze=None, solve_ivp_kwargs=None, t_eval='T', **kwargs): """Compute the output response of a system to a given input. @@ -1327,8 +1327,8 @@ def input_output_response( Parameters ---------- - sys : InputOutputSystem - Input/output system to simulate. + sysdata : I/O system or list of I/O systems + I/O system(s) for which input/output response is simulated. T : array-like Time steps at which the input is defined; values must be evenly spaced. @@ -1448,6 +1448,15 @@ def input_output_response( if kwargs: raise TypeError("unrecognized keyword(s): ", str(kwargs)) + # Convert the first argument to a list + syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] + + # TODO: implement step responses for multiple systems + if len(syslist) > 1: + raise NotImplementedError( + "step responses for multiple systems not yet implemented") + sys = syslist[0] + # Sanity checking on the input if not isinstance(sys, NonlinearIOSystem): raise TypeError("System of type ", type(sys), " not valid") diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index 7cdde5c54..ff89d5fbe 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -313,6 +313,14 @@ def test_combine_time_responses(): combresp6 = ct.combine_time_responses([resp1, resp]) +def test_list_responses(): + sys1 = ct.rss(2, 2, 2) + sys2 = ct.rss(2, 2, 2) + + resp = ct.step_response([sys1, sys2]).plot() + assert resp.ntraces == 2 + + @slycotonly def test_linestyles(): # Check to make sure we can change line styles diff --git a/control/timeresp.py b/control/timeresp.py index 81b2030b3..137b94483 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -1280,8 +1280,9 @@ def _process_time_response( return tout, yout -def step_response(sys, T=None, X0=0, input=None, output=None, T_num=None, - transpose=False, return_x=False, squeeze=None, params=None): +def step_response( + sysdata, T=None, X0=0, input=None, output=None, T_num=None, + transpose=False, return_x=False, squeeze=None, params=None): # pylint: disable=W0622 """Compute the step response for a linear system. @@ -1296,8 +1297,8 @@ def step_response(sys, T=None, X0=0, input=None, output=None, T_num=None, Parameters ---------- - sys : StateSpace or TransferFunction - LTI system to simulate + sysdata : I/O system or list of I/O systems + I/O system(s) for which step response is computed. T : array_like or float, optional Time vector, or simulation time duration if a number. If T is not @@ -1391,6 +1392,15 @@ def step_response(sys, T=None, X0=0, input=None, output=None, T_num=None, from .statesp import _convert_to_statespace from .xferfcn import TransferFunction + # Convert the first argument to a list + syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] + + # TODO: implement step responses for multiple systems + if len(syslist) > 1: + raise NotImplementedError( + "step responses for multiple systems not yet implemented") + sys = syslist[0] + # Create the time and input vectors if T is None or np.asarray(T).size == 1: T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=True) @@ -1681,8 +1691,9 @@ def step_info(sysdata, T=None, T_num=None, yfinal=None, params=None, return ret[0][0] if retsiso else ret -def initial_response(sys, T=None, X0=0, output=None, T_num=None, params=None, - transpose=False, return_x=False, squeeze=None): +def initial_response( + sysdata, T=None, X0=0, output=None, T_num=None, params=None, + transpose=False, return_x=False, squeeze=None): # pylint: disable=W0622 """Compute the initial condition response for a linear system. @@ -1695,6 +1706,9 @@ def initial_response(sys, T=None, X0=0, output=None, T_num=None, params=None, Parameters ---------- + sysdata : I/O system or list of I/O systems + I/O system(s) for which initial response is computed. + sys : StateSpace or TransferFunction LTI system to simulate @@ -1773,6 +1787,15 @@ def initial_response(sys, T=None, X0=0, output=None, T_num=None, params=None, """ from .lti import LTI + # Convert the first argument to a list + syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] + + # TODO: implement step responses for multiple systems + if len(syslist) > 1: + raise NotImplementedError( + "step responses for multiple systems not yet implemented") + sys = syslist[0] + # Create the time and input vectors if T is None or np.asarray(T).size == 1: T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=False) @@ -1800,8 +1823,9 @@ def initial_response(sys, T=None, X0=0, output=None, T_num=None, params=None, transpose=transpose, return_x=return_x, squeeze=squeeze) -def impulse_response(sys, T=None, input=None, output=None, T_num=None, - transpose=False, return_x=False, squeeze=None): +def impulse_response( + sysdata, T=None, input=None, output=None, T_num=None, + transpose=False, return_x=False, squeeze=None): # pylint: disable=W0622 """Compute the impulse response for a linear system. @@ -1816,8 +1840,8 @@ def impulse_response(sys, T=None, input=None, output=None, T_num=None, Parameters ---------- - sys : StateSpace, TransferFunction - LTI system to simulate + sysdata : I/O system or list of I/O systems + I/O system(s) for which impluse response is computed. T : array_like or float, optional Time vector, or simulation time duration if a scalar (time vector is @@ -1896,6 +1920,15 @@ def impulse_response(sys, T=None, input=None, output=None, T_num=None, from .lti import LTI from .statesp import _convert_to_statespace + # Convert the first argument to a list + syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] + + # TODO: implement step responses for multiple systems + if len(syslist) > 1: + raise NotImplementedError( + "step responses for multiple systems not yet implemented") + sys = syslist[0] + # Make sure we have an LTI system if not isinstance(sys, LTI): raise ValueError("system must be LTI system for impulse response") From 373221787c9a27275069952b6f2c25367aae975a Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 16 Jun 2024 09:40:54 -0700 Subject: [PATCH 02/12] use _process_ax_keyword in time_response_plot --- control/tests/timeplot_test.py | 2 ++ control/timeplot.py | 37 ++++++---------------------------- 2 files changed, 8 insertions(+), 31 deletions(-) diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index ff89d5fbe..5957dcd35 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -313,6 +313,8 @@ def test_combine_time_responses(): combresp6 = ct.combine_time_responses([resp1, resp]) +@pytest.mark.xfail( + reason="step responses for multiple systems not yet implemented") def test_list_responses(): sys1 = ct.rss(2, 2, 2) sys2 = ct.rss(2, 2, 2) diff --git a/control/timeplot.py b/control/timeplot.py index 29691ec6a..24783d886 100644 --- a/control/timeplot.py +++ b/control/timeplot.py @@ -150,6 +150,7 @@ def time_response_plot( config.defaults[''timeplot.rcParams']. """ + from .freqplot import _process_ax_keyword from .iosys import InputOutputSystem from .timeresp import TimeResponseData @@ -160,7 +161,7 @@ def time_response_plot( # Set up defaults time_label = config._get_param( 'timeplot', 'time_label', kwargs, _timeplot_defaults, pop=True) - timeplot_rcParams = config._get_param( + rcParams = config._get_param( 'timeplot', 'rcParams', kwargs, _timeplot_defaults, pop=True) if kwargs.get('input_props', None) and len(fmt) > 0: @@ -275,33 +276,7 @@ def time_response_plot( nrows, ncols = ncols, nrows # See if we can use the current figure axes - fig = plt.gcf() # get current figure (or create new one) - if ax is None and plt.get_fignums(): - ax = fig.get_axes() - if len(ax) == nrows * ncols: - # Assume that the shape is right (no easy way to infer this) - ax = np.array(ax).reshape(nrows, ncols) - elif len(ax) != 0: - # Need to generate a new figure - fig, ax = plt.figure(), None - else: - # Blank figure, just need to recreate axes - ax = None - - # Create new axes, if needed, and customize them - if ax is None: - with plt.rc_context(timeplot_rcParams): - ax_array = fig.subplots(nrows, ncols, sharex=True, squeeze=False) - fig.set_layout_engine('tight') - fig.align_labels() - - else: - # Make sure the axes are the right shape - if ax.shape != (nrows, ncols): - raise ValueError( - "specified axes are not the right shape; " - f"got {ax.shape} but expecting ({nrows}, {ncols})") - ax_array = ax + fig, ax_array = _process_ax_keyword(ax, (nrows, ncols), rcParams=rcParams) # # Map inputs/outputs and traces to axes @@ -506,7 +481,7 @@ def _make_line_label(signal_index, signal_labels, trace_index): else: label = f"Trace {trace}" - with plt.rc_context(timeplot_rcParams): + with plt.rc_context(rcParams): ax_array[0, trace].set_title(label) # Label the outputs @@ -608,7 +583,7 @@ def _make_line_label(signal_index, signal_labels, trace_index): # Update the labels to remove common strings if len(labels) > 1 and legend_map[i, j] != None: - with plt.rc_context(timeplot_rcParams): + with plt.rc_context(rcParams): ax.legend(labels, loc=legend_map[i, j]) @@ -643,7 +618,7 @@ def _make_line_label(signal_index, signal_labels, trace_index): new_title = old_title + separator + new_title[common_len:] # Add the title - with plt.rc_context(timeplot_rcParams): + with plt.rc_context(rcParams): fig.suptitle(new_title) return out From 44123c9d969c1d6738986dd3ed29e909cbb6f3f5 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 16 Jun 2024 10:04:06 -0700 Subject: [PATCH 03/12] refactoring to put common functions in ctrlplot.py --- control/ctrlplot.py | 92 ++++++++++++++++++++++++++++++++- control/freqplot.py | 27 ++-------- control/tests/timeplot_test.py | 4 +- control/timeplot.py | 93 +++------------------------------- 4 files changed, 102 insertions(+), 114 deletions(-) diff --git a/control/ctrlplot.py b/control/ctrlplot.py index 51f1342b2..56f22efbf 100644 --- a/control/ctrlplot.py +++ b/control/ctrlplot.py @@ -3,12 +3,14 @@ # # Collection of functions that are used by various plotting functions. +from os.path import commonprefix + import matplotlib.pyplot as plt import numpy as np from . import config -__all__ = ['suptitle'] +__all__ = ['suptitle', 'get_plot_axes'] def suptitle( @@ -56,6 +58,94 @@ def suptitle( raise ValueError(f"unknown frame '{frame}'") +# Create vectorized function to find axes from lines +def get_plot_axes(line_array): + """Get a list of axes from an array of lines. + + This function can be used to return the set of axes corresponding to + the line array that is returned by `time_response_plot`. This is useful for + generating an axes array that can be passed to subsequent plotting + calls. + + Parameters + ---------- + line_array : array of list of Line2D + A 2D array with elements corresponding to a list of lines appearing + in an axes, matching the return type of a time response data plot. + + Returns + ------- + axes_array : array of list of Axes + A 2D array with elements corresponding to the Axes assocated with + the lines in `line_array`. + + Notes + ----- + Only the first element of each array entry is used to determine the axes. + + """ + _get_axes = np.vectorize(lambda lines: lines[0].axes) + return _get_axes(line_array) + +# +# Utility functions +# + + +# Utility function to make legend labels +def _make_legend_labels(labels, ignore_common=False): + + # Look for a common prefix (up to a space) + common_prefix = commonprefix(labels) + last_space = common_prefix.rfind(', ') + if last_space < 0 or ignore_common: + common_prefix = '' + elif last_space > 0: + common_prefix = common_prefix[:last_space] + prefix_len = len(common_prefix) + + # Look for a common suffice (up to a space) + common_suffix = commonprefix( + [label[::-1] for label in labels])[::-1] + suffix_len = len(common_suffix) + # Only chop things off after a comma or space + while suffix_len > 0 and common_suffix[-suffix_len] != ',': + suffix_len -= 1 + + # Strip the labels of common information + if suffix_len > 0 and not ignore_common: + labels = [label[prefix_len:-suffix_len] for label in labels] + else: + labels = [label[prefix_len:] for label in labels] + + return labels + + +def _update_suptitle(fig, title, rcParams=None, frame='axes'): + if fig is not None and isinstance(title, str): + # Get the current title, if it exists + old_title = None if fig._suptitle is None else fig._suptitle._text + new_title = title + + if old_title is not None: + # Find the common part of the titles + common_prefix = commonprefix([old_title, new_title]) + + # Back up to the last space + last_space = common_prefix.rfind(' ') + if last_space > 0: + common_prefix = common_prefix[:last_space] + common_len = len(common_prefix) + + # Add the new part of the title (usually the system name) + if old_title[common_len:] != new_title[common_len:]: + separator = ',' if len(common_prefix) > 0 else ';' + new_title = old_title + separator + new_title[common_len:] + + # Add the title + suptitle(title, fig=fig, rcParams=rcParams, frame=frame) + + def _find_axes_center(fig, axs): """Find the midpoint between axes in display coordinates. diff --git a/control/freqplot.py b/control/freqplot.py index a63ef20d3..1f4b8e448 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -19,14 +19,14 @@ from . import config from .bdalg import feedback -from .ctrlplot import suptitle, _find_axes_center +from .ctrlplot import suptitle, _find_axes_center, _make_legend_labels, \ + _update_suptitle from .ctrlutil import unwrap from .exception import ControlMIMONotImplemented from .frdata import FrequencyResponseData from .lti import LTI, _process_frequency_response, frequency_response from .margins import stability_margins from .statesp import StateSpace -from .timeplot import _make_legend_labels from .xferfcn import TransferFunction __all__ = ['bode_plot', 'NyquistResponseData', 'nyquist_response', @@ -954,28 +954,7 @@ def gen_zero_centered_series(val_min, val_max, period): else: title = data[0].title - if fig is not None and isinstance(title, str): - # Get the current title, if it exists - old_title = None if fig._suptitle is None else fig._suptitle._text - new_title = title - - if old_title is not None: - # Find the common part of the titles - common_prefix = commonprefix([old_title, new_title]) - - # Back up to the last space - last_space = common_prefix.rfind(' ') - if last_space > 0: - common_prefix = common_prefix[:last_space] - common_len = len(common_prefix) - - # Add the new part of the title (usually the system name) - if old_title[common_len:] != new_title[common_len:]: - separator = ',' if len(common_prefix) > 0 else ';' - new_title = old_title + separator + new_title[common_len:] - - # Add the title - suptitle(title, fig=fig, rcParams=rcParams, frame=suptitle_frame) + _update_suptitle(fig, title, rcParams=rcParams, frame=suptitle_frame) # # Create legends diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index 5957dcd35..127fcea87 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -191,7 +191,7 @@ def test_response_plots( def test_axes_setup(): - get_plot_axes = ct.timeplot.get_plot_axes + get_plot_axes = ct.get_plot_axes sys_2x3 = ct.rss(4, 2, 3) sys_2x3b = ct.rss(4, 2, 3) @@ -377,7 +377,7 @@ def test_rcParams(): assert ax.title.get_fontsize() == 10 assert ax.xaxis._get_tick_label_size('x') == 10 assert ax.yaxis._get_tick_label_size('y') == 10 - assert fig._suptitle.get_fontsize() == 12 + assert fig._suptitle.get_fontsize() == 10 def test_relabel(): sys1 = ct.rss(2, inputs='u', outputs='y') diff --git a/control/timeplot.py b/control/timeplot.py index 24783d886..3133410fe 100644 --- a/control/timeplot.py +++ b/control/timeplot.py @@ -8,15 +8,16 @@ # Note: It might eventually make sense to put the functions here # directly into timeresp.py. -import numpy as np +from warnings import warn + import matplotlib as mpl import matplotlib.pyplot as plt -from os.path import commonprefix -from warnings import warn +import numpy as np from . import config +from .ctrlplot import _make_legend_labels, _update_suptitle -__all__ = ['time_response_plot', 'combine_time_responses', 'get_plot_axes'] +__all__ = ['time_response_plot', 'combine_time_responses'] # Default font dictionary _timeplot_rcParams = mpl.rcParams.copy() @@ -157,7 +158,6 @@ def time_response_plot( # # Process keywords and set defaults # - # Set up defaults time_label = config._get_param( 'timeplot', 'time_label', kwargs, _timeplot_defaults, pop=True) @@ -597,29 +597,7 @@ def _make_line_label(signal_index, signal_labels, trace_index): # list of systems (e.g., "Step response for sys[1], sys[2]"). # - if fig is not None and title is not None: - # Get the current title, if it exists - old_title = None if fig._suptitle is None else fig._suptitle._text - new_title = title - - if old_title is not None: - # Find the common part of the titles - common_prefix = commonprefix([old_title, new_title]) - - # Back up to the last space - last_space = common_prefix.rfind(' ') - if last_space > 0: - common_prefix = common_prefix[:last_space] - common_len = len(common_prefix) - - # Add the new part of the title (usually the system name) - if old_title[common_len:] != new_title[common_len:]: - separator = ',' if len(common_prefix) > 0 else ';' - new_title = old_title + separator + new_title[common_len:] - - # Add the title - with plt.rc_context(rcParams): - fig.suptitle(new_title) + _update_suptitle(fig, title, rcParams=rcParams) return out @@ -730,62 +708,3 @@ def combine_time_responses(response_list, trace_labels=None, title=None): return_x=base.return_x, squeeze=base.squeeze, sysname=base.sysname, trace_labels=trace_labels, trace_types=trace_types, plot_inputs=base.plot_inputs) - - -# Create vectorized function to find axes from lines -def get_plot_axes(line_array): - """Get a list of axes from an array of lines. - - This function can be used to return the set of axes corresponding to - the line array that is returned by `time_response_plot`. This is useful for - generating an axes array that can be passed to subsequent plotting - calls. - - Parameters - ---------- - line_array : array of list of Line2D - A 2D array with elements corresponding to a list of lines appearing - in an axes, matching the return type of a time response data plot. - - Returns - ------- - axes_array : array of list of Axes - A 2D array with elements corresponding to the Axes assocated with - the lines in `line_array`. - - Notes - ----- - Only the first element of each array entry is used to determine the axes. - - """ - _get_axes = np.vectorize(lambda lines: lines[0].axes) - return _get_axes(line_array) - - -# Utility function to make legend labels -def _make_legend_labels(labels, ignore_common=False): - - # Look for a common prefix (up to a space) - common_prefix = commonprefix(labels) - last_space = common_prefix.rfind(', ') - if last_space < 0 or ignore_common: - common_prefix = '' - elif last_space > 0: - common_prefix = common_prefix[:last_space] - prefix_len = len(common_prefix) - - # Look for a common suffice (up to a space) - common_suffix = commonprefix( - [label[::-1] for label in labels])[::-1] - suffix_len = len(common_suffix) - # Only chop things off after a comma or space - while suffix_len > 0 and common_suffix[-suffix_len] != ',': - suffix_len -= 1 - - # Strip the labels of common information - if suffix_len > 0 and not ignore_common: - labels = [label[prefix_len:-suffix_len] for label in labels] - else: - labels = [label[prefix_len:] for label in labels] - - return labels From 8b416eb82c6bca1278351677c3740838dad2bcf3 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Mon, 17 Jun 2024 22:41:34 -0700 Subject: [PATCH 04/12] Add list of systems functionality to time response functions --- control/ctrlplot.py | 7 +- control/frdata.py | 8 ++ control/nlsys.py | 23 ++-- control/tests/kwargs_test.py | 1 + control/tests/timeplot_test.py | 83 +++++++++++- control/timeplot.py | 23 +++- control/timeresp.py | 237 ++++++++++++++++++--------------- doc/conventions.rst | 11 ++ doc/plotting.rst | 2 + 9 files changed, 268 insertions(+), 127 deletions(-) diff --git a/control/ctrlplot.py b/control/ctrlplot.py index 56f22efbf..bac6a5562 100644 --- a/control/ctrlplot.py +++ b/control/ctrlplot.py @@ -125,11 +125,10 @@ def _update_suptitle(fig, title, rcParams=None, frame='axes'): if fig is not None and isinstance(title, str): # Get the current title, if it exists old_title = None if fig._suptitle is None else fig._suptitle._text - new_title = title if old_title is not None: # Find the common part of the titles - common_prefix = commonprefix([old_title, new_title]) + common_prefix = commonprefix([old_title, title]) # Back up to the last space last_space = common_prefix.rfind(' ') @@ -138,9 +137,9 @@ def _update_suptitle(fig, title, rcParams=None, frame='axes'): common_len = len(common_prefix) # Add the new part of the title (usually the system name) - if old_title[common_len:] != new_title[common_len:]: + if old_title[common_len:] != title[common_len:]: separator = ',' if len(common_prefix) > 0 else ';' - new_title = old_title + separator + new_title[common_len:] + title = old_title + separator + title[common_len:] # Add the title suptitle(title, fig=fig, rcParams=rcParams, frame=frame) diff --git a/control/frdata.py b/control/frdata.py index b703a97a0..1b35c6b20 100644 --- a/control/frdata.py +++ b/control/frdata.py @@ -653,6 +653,14 @@ def plot(self, plot_type=None, *args, **kwargs): # Convert to pandas def to_pandas(self): + """Convert response data to pandas data frame. + + Creates a pandas data frame for the value of the frequency + response at each `omega`. The frequency response values are + labeled in the form "H_{, }" where "" and "" + are replaced with the output and input labels for the system. + + """ if not pandas_check(): ImportError('pandas not installed') import pandas diff --git a/control/nlsys.py b/control/nlsys.py index 80b8aa73c..976dfdc84 100644 --- a/control/nlsys.py +++ b/control/nlsys.py @@ -27,8 +27,8 @@ from . import config from .iosys import InputOutputSystem, _parse_spec, _process_iosys_keywords, \ _process_signal_list, common_timebase, isctime, isdtime -from .timeresp import TimeResponseData, _check_convert_array, \ - _process_time_response +from .timeresp import _check_convert_array, _process_time_response, \ + TimeResponseData, TimeResponseList __all__ = ['NonlinearIOSystem', 'InterconnectedSystem', 'nlsys', 'input_output_response', 'find_eqpt', 'linearize', @@ -1448,14 +1448,17 @@ def input_output_response( if kwargs: raise TypeError("unrecognized keyword(s): ", str(kwargs)) - # Convert the first argument to a list - syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] - - # TODO: implement step responses for multiple systems - if len(syslist) > 1: - raise NotImplementedError( - "step responses for multiple systems not yet implemented") - sys = syslist[0] + # If passed a list, recursively call individual responses with given T + if isinstance(sysdata, (list, tuple)): + responses = [] + for sys in sysdata: + responses.append(input_output_response( + sys, T, U=U, X0=X0, params=params, transpose=transpose, + return_x=return_x, squeeze=squeeze, t_eval=t_eval, + solve_ivp_kwargs=solve_ivp_kwargs, **kwargs)) + return TimeResponseList(responses) + else: + sys = sysdata # Sanity checking on the input if not isinstance(sys, NonlinearIOSystem): diff --git a/control/tests/kwargs_test.py b/control/tests/kwargs_test.py index d6bd06487..0e0abc0d0 100644 --- a/control/tests/kwargs_test.py +++ b/control/tests/kwargs_test.py @@ -308,6 +308,7 @@ def test_response_plot_kwargs(data_fcn, plot_fcn, mimo): 'StateSpace.sample': test_unrecognized_kwargs, 'TimeResponseData.__call__': trdata_test.test_response_copy, 'TimeResponseData.plot': timeplot_test.test_errors, + 'TimeResponseList.plot': timeplot_test.test_errors, 'TransferFunction.__init__': test_unrecognized_kwargs, 'TransferFunction.sample': test_unrecognized_kwargs, 'optimal.OptimalControlProblem.__init__': diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index 127fcea87..5ff8536d3 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -313,14 +313,52 @@ def test_combine_time_responses(): combresp6 = ct.combine_time_responses([resp1, resp]) -@pytest.mark.xfail( - reason="step responses for multiple systems not yet implemented") -def test_list_responses(): - sys1 = ct.rss(2, 2, 2) - sys2 = ct.rss(2, 2, 2) +@pytest.mark.parametrize("resp_fcn", [ + ct.step_response, ct.initial_response, ct.impulse_response, + ct.forced_response, ct.input_output_response]) +def test_list_responses(resp_fcn): + sys1 = ct.rss(2, 2, 2, strictly_proper=True) + sys2 = ct.rss(2, 2, 2, strictly_proper=True) + + # Figure out the expected shape of the system + match resp_fcn: + case ct.step_response | ct.impulse_response: + shape = (2, 2) + kwargs = {} + case ct.initial_response: + shape = (2, 1) + kwargs = {} + case ct.forced_response | ct.input_output_response: + shape = (4, 1) # outputs and inputs both plotted + T = np.linspace(0, 10) + U = [np.sin(T), np.cos(T)] + kwargs = {'T': T, 'U': U} + + resp1 = resp_fcn(sys1, **kwargs) + resp2 = resp_fcn(sys2, **kwargs) + + # Sequential plotting results in colors rotating + plt.figure() + out1 = resp1.plot() + out2 = resp2.plot() + assert out1.shape == shape + assert out2.shape == shape + for row in range(2): # just look at the outputs + for col in range(shape[1]): + assert out1[row, col][0].get_color() == 'tab:blue' + assert out2[row, col][0].get_color() == 'tab:orange' - resp = ct.step_response([sys1, sys2]).plot() - assert resp.ntraces == 2 + plt.figure() + resp_combined = resp_fcn([sys1, sys2], **kwargs) + assert isinstance(resp_combined, ct.timeresp.TimeResponseList) + assert resp_combined[0].time[-1] == max(resp1.time[-1], resp2.time[-1]) + assert resp_combined[1].time[-1] == max(resp1.time[-1], resp2.time[-1]) + out = resp_combined.plot() + assert out.shape == shape + for row in range(2): # just look at the outputs + for col in range(shape[1]): + assert out[row, col][0].get_color() == 'tab:blue' + assert out[row, col][1].get_color() == 'tab:orange' @slycotonly @@ -421,6 +459,12 @@ def test_errors(): out = stepresp.plot('k-', **propkw) assert out[0, 0][0].get_color() == 'k' + # Make sure TimeResponseLists also work + stepresp = ct.step_response([sys, sys]) + with pytest.raises(AttributeError, + match="(has no property|unexpected keyword)"): + stepresp.plot(unknown=None) + if __name__ == "__main__": # # Interactive mode: generate plots for manual viewing @@ -519,3 +563,28 @@ def test_errors(): input_props=[{'color': c} for c in ['red', 'green']], trace_props=[{'linestyle': s} for s in ['-', '--']]) plt.savefig('timeplot-mimo_step-linestyle.png') + + sys1 = ct.rss(4, 2, 2) + sys2 = ct.rss(4, 2, 2) + resp_list = ct.step_response([sys1, sys2]) + + fig = plt.figure() + ct.combine_time_responses( + [ct.step_response(sys1, resp_list[0].time), + ct.step_response(sys2, resp_list[1].time)] + ).plot(overlay_traces=True) + ct.suptitle("[Combine] " + fig._suptitle._text) + + fig = plt.figure() + ct.step_response(sys1).plot() + ct.step_response(sys2).plot() + ct.suptitle("[Sequential] " + fig._suptitle._text) + + fig = plt.figure() + ct.step_response(sys1).plot(color='b') + ct.step_response(sys2).plot(color='r') + ct.suptitle("[Seq w/color] " + fig._suptitle._text) + + fig = plt.figure() + ct.step_response([sys1, sys2]).plot() + ct.suptitle("[List] " + fig._suptitle._text) diff --git a/control/timeplot.py b/control/timeplot.py index 3133410fe..3ca9b54b8 100644 --- a/control/timeplot.py +++ b/control/timeplot.py @@ -44,6 +44,7 @@ 'timeplot.time_label': "Time [s]", } + # Plot the input/output response of a system def time_response_plot( data, *fmt, ax=None, plot_inputs=None, plot_outputs=True, @@ -364,6 +365,16 @@ def _make_line_label(signal_index, signal_labels, trace_index): return label + # + # Store the color offsets with the figure to allow color/style cycling + # + # To allow repeated calls to time_response_plot() to cycle through + # colors, we store an offset in the figure object that we can + # retrieve at a later date, if needed. + # + output_offset = fig._output_offset = getattr(fig, '_output_offset', 0) + input_offset = fig._input_offset = getattr(fig, '_input_offset', 0) + # Go through each trace and each input/output for trace in range(ntraces): # Plot the output @@ -373,7 +384,8 @@ def _make_line_label(signal_index, signal_labels, trace_index): # Set up line properties for this output, trace if len(fmt) == 0: line_props = output_props[ - i % oprop_len if overlay_signals else 0].copy() + (i + output_offset) % oprop_len if overlay_signals + else output_offset].copy() line_props.update( trace_props[trace % tprop_len if overlay_traces else 0]) line_props.update(kwargs) @@ -397,7 +409,8 @@ def _make_line_label(signal_index, signal_labels, trace_index): # Set up line properties for this output, trace if len(fmt) == 0: line_props = input_props[ - i % iprop_len if overlay_signals else 0].copy() + (i + input_offset) % iprop_len if overlay_signals + else input_offset].copy() line_props.update( trace_props[trace % tprop_len if overlay_traces else 0]) line_props.update(kwargs) @@ -407,6 +420,12 @@ def _make_line_label(signal_index, signal_labels, trace_index): out[input_map[i, trace]] += ax_array[input_map[i, trace]].plot( x, y, *fmt, label=label, **line_props) + # Update the offsets so that we start at a new color/style the next time + fig._output_offset = ( + output_offset + (noutputs if overlay_signals else 1)) % oprop_len + fig._input_offset = ( + input_offset + (ninputs if overlay_signals else 1)) % iprop_len + # Stop here if the user wants to control everything if not relabel: return out diff --git a/control/timeresp.py b/control/timeresp.py index 137b94483..8f10d8fd3 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -79,12 +79,14 @@ from scipy.linalg import eig, eigvals, matrix_balance, norm from . import config +from .ctrlplot import _update_suptitle from .exception import pandas_check from .iosys import isctime, isdtime from .timeplot import time_response_plot __all__ = ['forced_response', 'step_response', 'step_info', - 'initial_response', 'impulse_response', 'TimeResponseData'] + 'initial_response', 'impulse_response', 'TimeResponseData', + 'TimeResponseList'] class TimeResponseData: @@ -694,6 +696,12 @@ def __len__(self): # Convert to pandas def to_pandas(self): + """Convert response data to pandas data frame. + + Creates a pandas data frame using the input, output, and state + labels for the time response. + + """ if not pandas_check(): raise ImportError("pandas not installed") import pandas @@ -714,8 +722,41 @@ def to_pandas(self): # Plot data def plot(self, *args, **kwargs): + """Plot the time response data objects. + + This method calls :func:`time_response_plot`, passing all arguments + and keywords. + + """ return time_response_plot(self, *args, **kwargs) +# +# Time response data list class +# +# This class is a subclass of list that adds a plot() method, enabling +# direct plotting from routines returning a list of TimeResponseData +# objects. +# + +class TimeResponseList(list): + """This class consist of a list of :class:`TimeResponseData` objects. + It is a subclass of the Python `list` class, with a `plot` method that + plots the individual :class:`TimeResponseData` objects. + + """ + def plot(self, *args, **kwargs): + out_full = None + for response in self: + out = TimeResponseData.plot(response, *args, **kwargs) + if out_full is None: + out_full = out + else: + # Append the lines in the new plot to previous lines + for row in range(out.shape[0]): + for col in range(out.shape[1]): + out_full[row, col] += out[row, col] + return out_full + # Process signal labels def _process_labels(labels, signal, length): @@ -878,7 +919,7 @@ def shape_matches(s_legal, s_actual): # Forced response of a linear system -def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, +def forced_response(sysdata, T=None, U=0., X0=0., transpose=False, params=None, interpolate=False, return_x=None, squeeze=None): """Compute the output of a linear system given the input. @@ -891,8 +932,8 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, Parameters ---------- - sys : StateSpace or TransferFunction - LTI system to simulate + sysdata : I/O system or list of I/O systems + I/O system(s) for which forced response is computed. T : array_like, optional for discrete LTI `sys` Time steps at which the input is defined; values must be evenly spaced. @@ -947,9 +988,10 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, Returns ------- - results : TimeResponseData - Time response represented as a :class:`TimeResponseData` object - containing the following properties: + results : :class:`TimeResponseData` or :class:`TimeResponseList` + Time response represented as a :class:`TimeResponseData` object or + list of :class:`TimeResponseData` objects containing the following + properties: * time (array): Time values of the output. @@ -963,9 +1005,8 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, * inputs (array): Input(s) to the system, indexed by input and time. - The return value of the system can also be accessed by assigning the - function to a tuple of length 2 (time, output) or of length 3 (time, - output, state) if ``return_x`` is ``True``. + The `plot()` method can be used to create a plot of the time + response(s) (see :func:`time_response_plot` for more information). See Also -------- @@ -986,6 +1027,10 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, that `forced_response` is specialized (and optimized) for linear systems. + 4. (legacy) The return value of the system can also be accessed by + assigning the function to a tuple of length 2 (time, output) or of + length 3 (time, output, state) if ``return_x`` is ``True``. + Examples -------- >>> G = ct.rss(4) @@ -1000,6 +1045,17 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, from .statesp import StateSpace, _convert_to_statespace from .xferfcn import TransferFunction + # If passed a list, recursively call individual responses with given T + if isinstance(sysdata, (list, tuple)): + responses = [] + for sys in sysdata: + responses.append(forced_response( + sys, T, U=U, X0=X0, transpose=transpose, params=params, + interpolate=interpolate, return_x=return_x, squeeze=squeeze)) + return TimeResponseList(responses) + else: + sys = sysdata + if not isinstance(sys, (StateSpace, TransferFunction)): if isinstance(sys, NonlinearIOSystem): if interpolate: @@ -1351,27 +1407,10 @@ def step_response( Returns ------- - results : TimeResponseData - Time response represented as a :class:`TimeResponseData` object - containing the following properties: - - * time (array): Time values of the output. - - * outputs (array): Response of the system. If the system is SISO and - squeeze is not True, the array is 1D (indexed by time). If the - system is not SISO or ``squeeze`` is False, the array is 3D (indexed - by the output, trace, and time). - - * states (array): Time evolution of the state vector, represented as - either a 2D array indexed by state and time (if SISO) or a 3D array - indexed by state, trace, and time. Not affected by ``squeeze``. - - * inputs (array): Input(s) to the system, indexed in the same manner - as ``outputs``. - - The return value of the system can also be accessed by assigning the - function to a tuple of length 2 (time, output) or of length 3 (time, - output, state) if ``return_x`` is ``True``. + results : `TimeResponseData` or `TimeResponseList` + Time response represented as a :class:`TimeResponseData` object or + list of :class:`TimeResponseData` objects. See + :func:`forced_response` for additional information. See Also -------- @@ -1392,22 +1431,25 @@ def step_response( from .statesp import _convert_to_statespace from .xferfcn import TransferFunction - # Convert the first argument to a list - syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] - - # TODO: implement step responses for multiple systems - if len(syslist) > 1: - raise NotImplementedError( - "step responses for multiple systems not yet implemented") - sys = syslist[0] - # Create the time and input vectors if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=True) + T = _default_time_vector(sysdata, N=T_num, tfinal=T, is_step=True) T = np.atleast_1d(T).reshape(-1) if T.ndim != 1 and len(T) < 2: raise ValueError("invalid value of T for this type of system") + # If passed a list, recursively call individual responses with given T + if isinstance(sysdata, (list, tuple)): + responses = [] + for sys in sysdata: + responses.append(step_response( + sys, T, X0=X0, input=input, output=output, T_num=T_num, + transpose=transpose, return_x=return_x, squeeze=squeeze, + params=params)) + return TimeResponseList(responses) + else: + sys = sysdata + # If we are passed a transfer function and X0 is non-zero, warn the user if isinstance(sys, TransferFunction) and np.any(X0 != 0): warnings.warn( @@ -1751,24 +1793,10 @@ def initial_response( Returns ------- - results : TimeResponseData - Time response represented as a :class:`TimeResponseData` object - containing the following properties: - - * time (array): Time values of the output. - - * outputs (array): Response of the system. If the system is SISO and - squeeze is not True, the array is 1D (indexed by time). If the - system is not SISO or ``squeeze`` is False, the array is 2D (indexed - by the output and time). - - * states (array): Time evolution of the state vector, represented as - either a 2D array indexed by state and time (if SISO). Not affected - by ``squeeze``. - - The return value of the system can also be accessed by assigning the - function to a tuple of length 2 (time, output) or of length 3 (time, - output, state) if ``return_x`` is ``True``. + results : `TimeResponseData` or `TimeResponseList` + Time response represented as a :class:`TimeResponseData` object or + list of :class:`TimeResponseData` objects. See + :func:`forced_response` for additional information. See Also -------- @@ -1787,22 +1815,24 @@ def initial_response( """ from .lti import LTI - # Convert the first argument to a list - syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] - - # TODO: implement step responses for multiple systems - if len(syslist) > 1: - raise NotImplementedError( - "step responses for multiple systems not yet implemented") - sys = syslist[0] - # Create the time and input vectors if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=False) + T = _default_time_vector(sysdata, N=T_num, tfinal=T, is_step=False) T = np.atleast_1d(T).reshape(-1) if T.ndim != 1 and len(T) < 2: raise ValueError("invalid value of T for this type of system") + # If passed a list, recursively call individual responses with given T + if isinstance(sysdata, (list, tuple)): + responses = [] + for sys in sysdata: + responses.append(initial_response( + sys, T, X0=X0, output=output, T_num=T_num, transpose=transpose, + return_x=return_x, squeeze=squeeze, params=params)) + return TimeResponseList(responses) + else: + sys = sysdata + # Compute the forced response response = forced_response(sys, T, 0, X0, params=params) @@ -1880,24 +1910,10 @@ def impulse_response( Returns ------- - results : TimeResponseData - Impulse response represented as a :class:`TimeResponseData` object - containing the following properties: - - * time (array): Time values of the output. - - * outputs (array): Response of the system. If the system is SISO and - squeeze is not True, the array is 1D (indexed by time). If the - system is not SISO or ``squeeze`` is False, the array is 3D (indexed - by the output, trace, and time). - - * states (array): Time evolution of the state vector, represented as - either a 2D array indexed by state and time (if SISO) or a 3D array - indexed by state, trace, and time. Not affected by ``squeeze``. - - The return value of the system can also be accessed by assigning the - function to a tuple of length 2 (time, output) or of length 3 (time, - output, state) if ``return_x`` is ``True``. + results : `TimeResponseData` or `TimeResponseList` + Time response represented as a :class:`TimeResponseData` object or + list of :class:`TimeResponseData` objects. See + :func:`forced_response` for additional information. See Also -------- @@ -1908,8 +1924,8 @@ def impulse_response( This function uses the `forced_response` function to compute the time response. For continuous time systems, the initial condition is altered to account for the initial impulse. For discrete-time aystems, the - impulse is sized so that it has unit area. Response for nonlinear - systems is computed using `input_output_response`. + impulse is sized so that it has unit area. The impulse response for + nonlinear systems is not implemented. Examples -------- @@ -1920,26 +1936,28 @@ def impulse_response( from .lti import LTI from .statesp import _convert_to_statespace - # Convert the first argument to a list - syslist = sysdata if isinstance(sysdata, (list, tuple)) else [sysdata] - - # TODO: implement step responses for multiple systems - if len(syslist) > 1: - raise NotImplementedError( - "step responses for multiple systems not yet implemented") - sys = syslist[0] - - # Make sure we have an LTI system - if not isinstance(sys, LTI): - raise ValueError("system must be LTI system for impulse response") - # Create the time and input vectors if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=False) + T = _default_time_vector(sysdata, N=T_num, tfinal=T, is_step=False) T = np.atleast_1d(T).reshape(-1) if T.ndim != 1 and len(T) < 2: raise ValueError("invalid value of T for this type of system") + # If passed a list, recursively call individual responses with given T + if isinstance(sysdata, (list, tuple)): + responses = [] + for sys in sysdata: + responses.append(impulse_response( + sys, T, input=input, output=output, T_num=T_num, + transpose=transpose, return_x=return_x, squeeze=squeeze)) + return TimeResponseList(responses) + else: + sys = sysdata + + # Make sure we have an LTI system + if not isinstance(sys, LTI): + raise ValueError("system must be LTI system for impulse response") + # Convert to state space so that we can simulate if sys.nstates is None: sys = _convert_to_statespace(sys) @@ -2181,11 +2199,22 @@ def _ideal_tfinal_and_dt(sys, is_step=True): return tfinal, dt -def _default_time_vector(sys, N=None, tfinal=None, is_step=True): +def _default_time_vector(sysdata, N=None, tfinal=None, is_step=True): """Returns a time vector that has a reasonable number of points. if system is discrete-time, N is ignored """ from .lti import LTI + if isinstance(sysdata, (list, tuple)): + tfinal_max = N_max = 0 + for sys in sysdata: + timevec = _default_time_vector( + sys, N=N, tfinal=tfinal, is_step=is_step) + tfinal_max = max(tfinal_max, timevec[-1]) + N_max = max(N_max, timevec.size) + return np.linspace(0, tfinal_max, N_max, endpoint=True) + else: + sys = sysdata + # For non-LTI system, need tfinal if not isinstance(sys, LTI): if tfinal is None: diff --git a/doc/conventions.rst b/doc/conventions.rst index 680ba1ba8..ad56c0ccc 100644 --- a/doc/conventions.rst +++ b/doc/conventions.rst @@ -154,6 +154,17 @@ The :func:`forced_response` system is the most general and allows by the zero initial state response to be simulated as well as the response from a non-zero initial condition. +For linear time invariant (LTI) systems, the :func:`impulse_response`, +:func:`initial_response`, and :func:`step_response` functions will +automatically compute the time vector based on the poles and zeros of +system. If a list of systems is passed, a common time vector will be +computed and a list of responses will be returned in the form of a +:class:`TimeResponseList` object. The :func:`force_response` function can +also take a list of systems, to which a single common input is applied. +The :class:`TimeResponseList` object has a `plot()` method that will plot +each of the reponses in turn, using a sequence of different colors with +appropriate titles and legends. + In addition the :func:`input_output_response` function, which handles simulation of nonlinear systems and interconnected systems, can be used. For an LTI system, results are generally more accurate using diff --git a/doc/plotting.rst b/doc/plotting.rst index a3cbc1797..2450c576b 100644 --- a/doc/plotting.rst +++ b/doc/plotting.rst @@ -494,6 +494,8 @@ The following classes are used in generating response data. ~control.DescribingFunctionResponse ~control.FrequencyResponseData + ~control.FrequencyResponseList ~control.NyquistResponseData ~control.PoleZeroData ~control.TimeResponseData + ~control.TimeResponseList From 6be8f4811804d720dec0b61ebf98de61912139bc Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Thu, 20 Jun 2024 13:51:36 -0700 Subject: [PATCH 05/12] allow combining I/O time responses with different numbers of states --- control/timeplot.py | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/control/timeplot.py b/control/timeplot.py index 3ca9b54b8..30b73397e 100644 --- a/control/timeplot.py +++ b/control/timeplot.py @@ -653,6 +653,7 @@ def combine_time_responses(response_list, trace_labels=None, title=None): ntraces = max(1, base.ntraces) # Initial pass through trace list to count things up and do error checks + nstates = base.nstates for response in response_list[1:]: # Make sure the time vector is the same if not np.allclose(base.t, response.t): @@ -660,17 +661,20 @@ def combine_time_responses(response_list, trace_labels=None, title=None): # Make sure the dimensions are all the same if base.ninputs != response.ninputs or \ - base.noutputs != response.noutputs or \ - base.nstates != response.nstates: + base.noutputs != response.noutputs: raise ValueError("all responses must have the same number of " "inputs, outputs, and states") + if nstates != response.nstates: + warn("responses have different state dimensions; dropping states") + nstates = 0 + ntraces += max(1, response.ntraces) # Create data structures for the new time response data object inputs = np.empty((base.ninputs, ntraces, base.t.size)) outputs = np.empty((base.noutputs, ntraces, base.t.size)) - states = np.empty((base.nstates, ntraces, base.t.size)) + states = np.empty((nstates, ntraces, base.t.size)) # See whether we should create labels or not if trace_labels is None: @@ -689,7 +693,8 @@ def combine_time_responses(response_list, trace_labels=None, title=None): # Single trace inputs[:, offset, :] = response.u outputs[:, offset, :] = response.y - states[:, offset, :] = response.x + if nstates: + states[:, offset, :] = response.x offset += 1 # Add on trace label and trace type @@ -703,7 +708,8 @@ def combine_time_responses(response_list, trace_labels=None, title=None): for i in range(response.ntraces): inputs[:, offset, :] = response.u[:, i, :] outputs[:, offset, :] = response.y[:, i, :] - states[:, offset, :] = response.x[:, i, :] + if nstates: + states[:, offset, :] = response.x[:, i, :] # Save the trace labels if generate_trace_labels: @@ -721,9 +727,10 @@ def combine_time_responses(response_list, trace_labels=None, title=None): trace_types += [None] * response.ntraces return TimeResponseData( - base.t, outputs, states, inputs, issiso=base.issiso, + base.t, outputs, states if nstates else None, inputs, output_labels=base.output_labels, input_labels=base.input_labels, - state_labels=base.state_labels, title=title, transpose=base.transpose, - return_x=base.return_x, squeeze=base.squeeze, sysname=base.sysname, + state_labels=base.state_labels if nstates else None, + title=title, transpose=base.transpose, return_x=base.return_x, + issiso=base.issiso, squeeze=base.squeeze, sysname=base.sysname, trace_labels=trace_labels, trace_types=trace_types, plot_inputs=base.plot_inputs) From 8b269bfd5d92a1bf5705f40196c9043736a86c80 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Thu, 20 Jun 2024 13:52:41 -0700 Subject: [PATCH 06/12] add plot_gallery to compare plotting results between builds --- examples/plot_gallery.py | 161 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 examples/plot_gallery.py diff --git a/examples/plot_gallery.py b/examples/plot_gallery.py new file mode 100644 index 000000000..214e53289 --- /dev/null +++ b/examples/plot_gallery.py @@ -0,0 +1,161 @@ +# plot_gallery.py - different types of plots for comparing versions +# RMM, 19 Jun 2024 +# +# This file collects together some of the more interesting plots that can +# be generated by python-control and puts them into a PDF file that can be +# used to compare what things look like between different versions of the +# library. It is mainly intended for uses by developers to make sure there +# are no unexpected changes in plot formats, but also has some interest +# examples of htings you can plot. + +import os +import sys +from math import pi + +import matplotlib.pyplot as plt +import numpy as np + +import control as ct + +# Don't save figures if we are running CI tests +savefigs = 'PYCONTROL_TEST_EXAMPLES' not in os.environ +if savefigs: + # Create a pdf file for storing the results + from matplotlib.backends.backend_pdf import PdfPages + from datetime import date + git_info = os.popen('git describe').read().strip() + pdf = PdfPages( + f'plot_gallery-{git_info}-{date.today().isoformat()}.pdf') + +# Context manager to handle plotting +class create_figure(object): + def __init__(self, name): + self.name = name + def __enter__(self): + self.fig = plt.figure() + print(f"Generating {self.name} as Figure {self.fig.number}") + return self.fig + def __exit__(self, type, value, traceback): + if type is not None: + print(f"Exception: {type=}, {value=}, {traceback=}") + if savefigs: + pdf.savefig() + if hasattr(sys, 'ps1'): + # Show the figures on the screen + plt.show(block=False) + else: + plt.close() + +# Define systems to use throughout +sys1 = ct.tf([1], [1, 2, 1], name='sys1') +sys2 = ct.tf([1, 0.2], [1, 1, 3, 1, 1], name='sys2') +sys_mimo1 = ct.tf2ss( + [[[1], [0.1]], [[0.2], [1]]], + [[[1, 0.6, 1], [1, 1, 1]], [[1, 0.4, 1], [1, 2, 1]]], name="sys_mimo1") +sys_mimo2 = ct.tf2ss( + [[[1], [0.1]], [[0.2], [1]]], + [[[1, 0.2, 1], [1, 24, 22, 5]], [[1, 4, 16, 21], [1, 0.1]]], + name="sys_mimo2") +sys_frd = ct.frd( + [[np.array([10 + 0j, 5 - 5j, 1 - 1j, 0.5 - 1j, -.1j]), + np.array([1j, 0.5 - 0.5j, -0.5, 0.1 - 0.1j, -.05j]) * 0.1], + [np.array([10 + 0j, -20j, -10, 2j, 1]), + np.array([10 + 0j, 5 - 5j, 1 - 1j, 0.5 - 1j, -.1j]) * 0.01]], + np.logspace(-2, 2, 5)) +sys_frd.name = 'frd' # For backward compatibility + +# Close all existing figures +plt.close('all') + +# bode +with create_figure("Bode plot"): + try: + ct.bode_plot([sys_mimo1, sys_mimo2]) + except AttributeError: + print(" - falling back to earlier method") + plt.clf() + ct.bode_plot(sys_mimo1) + ct.bode_plot(sys_mimo2) + +# describing function +with create_figure("Describing function plot"): + H = ct.tf([1], [1, 2, 2, 1]) * 8 + F = ct.descfcn.saturation_nonlinearity(1) + amp = np.linspace(1, 4, 10) + ct.describing_function_response(H, F, amp).plot() + +# nichols +with create_figure("Nichols chart"): + response = ct.frequency_response([sys1, sys2]) + ct.nichols_plot(response) + +# nyquist +with create_figure("Nyquist plot"): + ct.nyquist_plot([sys1, sys2]) + +# phase plane +with create_figure("Phase plane plot"): + def invpend_update(t, x, u, params): + m, l, b, g = params['m'], params['l'], params['b'], params['g'] + return [x[1], -b/m * x[1] + (g * l / m) * np.sin(x[0]) + u[0]/m] + invpend = ct.nlsys(invpend_update, states=2, inputs=1, name='invpend') + ct.phase_plane_plot( + invpend, [-2*pi, 2*pi, -2, 2], 5, + gridtype='meshgrid', gridspec=[5, 8], arrows=3, + plot_separatrices={'gridspec': [12, 9]}, + params={'m': 1, 'l': 1, 'b': 0.2, 'g': 1}) + +# pole zero map +with create_figure("Pole/zero map"): + T = ct.tf( + [-9.0250000e-01, -4.7200750e+01, -8.6812900e+02, + +5.6261850e+03, +2.1258472e+05, +8.4724600e+05, + +1.0192000e+06, +2.3520000e+05], + [9.02500000e-03, 9.92862812e-01, 4.96974094e+01, + 1.35705659e+03, 2.09294163e+04, 1.64898435e+05, + 6.54572220e+05, 1.25274600e+06, 1.02420000e+06, + 2.35200000e+05], name='T') + ct.pole_zero_plot([T, sys2]) + +# root locus +with create_figure("Root locus plot") as fig: + ax1, ax2 = fig.subplots(2, 1) + sys1 = ct.tf([1, 2], [1, 2, 3], name='sys1') + sys2 = ct.tf([1, 0.2], [1, 1, 3, 1, 1], name='sys2') + ct.root_locus_plot([sys1, sys2], grid=True, ax=ax1) + ct.root_locus_plot([sys1, sys2], grid=False, ax=ax2) + print(" -- BUG: should have 2 x 1 array of plots") + +# sisotool +with create_figure("sisotool"): + s = ct.tf('s') + H = (s+0.3)/(s**4 + 4*s**3 + 6.25*s**2) + ct.sisotool(H) + +# step response +with create_figure("step response") as fig: + try: + ct.step_response([sys_mimo1, sys_mimo2]).plot() + except ValueError: + print(" - falling back to earlier method") + fig.clf() + ct.step_response(sys_mimo1).plot() + ct.step_response(sys_mimo2).plot() + +# time response +with create_figure("time response"): + timepts = np.linspace(0, 10) + + U = np.vstack([np.sin(timepts), np.cos(2*timepts)]) + resp1 = ct.input_output_response(sys_mimo1, timepts, U) + + U = np.vstack([np.cos(2*timepts), np.sin(timepts)]) + resp2 = ct.input_output_response(sys_mimo1, timepts, U) + + resp = ct.combine_time_responses( + [resp1, resp2], trace_labels=["resp1", "resp2"]) + resp.plot(transpose=True) + +# Show the figures if running in interactive mode +if savefigs: + pdf.close() From cc6aeb612c76dd8544589685c236e7ddfaf012ba Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Thu, 20 Jun 2024 13:50:33 -0700 Subject: [PATCH 07/12] improved unit tests for rcParams + small fix to suptitle rcParams --- control/ctrlplot.py | 1 - control/tests/timeplot_test.py | 43 ++++++++++++++++++++-------------- 2 files changed, 25 insertions(+), 19 deletions(-) diff --git a/control/ctrlplot.py b/control/ctrlplot.py index bac6a5562..de70f96cd 100644 --- a/control/ctrlplot.py +++ b/control/ctrlplot.py @@ -46,7 +46,6 @@ def suptitle( elif frame == 'axes': # TODO: move common plotting params to 'ctrlplot' - rcParams = config._get_param('freqplot', 'rcParams', rcParams) with plt.rc_context(rcParams): plt.tight_layout() # Put the figure into proper layout xc, _ = _find_axes_center(fig, fig.get_axes()) diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index 5ff8536d3..921b9e765 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -395,14 +395,19 @@ def test_rcParams(): sys = ct.rss(2, 2, 2) # Create new set of rcParams - my_rcParams = { - 'axes.labelsize': 10, - 'axes.titlesize': 10, - 'figure.titlesize': 12, - 'legend.fontsize': 10, - 'xtick.labelsize': 10, - 'ytick.labelsize': 10, - } + my_rcParams = {} + for key in [ + 'axes.labelsize', 'axes.titlesize', 'figure.titlesize', + 'legend.fontsize', 'xtick.labelsize', 'ytick.labelsize']: + match plt.rcParams[key]: + case 8 | 9 | 10: + my_rcParams[key] = plt.rcParams[key] + 1 + case 'medium': + my_rcParams[key] = 11.5 + case 'large': + my_rcParams[key] = 9.5 + case _: + raise ValueError(f"unknown rcParam type for {key}") # Generate a figure with the new rcParams out = ct.step_response(sys).plot(rcParams=my_rcParams) @@ -410,12 +415,14 @@ def test_rcParams(): fig = ax.figure # Check to make sure new settings were used - assert ax.xaxis.get_label().get_fontsize() == 10 - assert ax.yaxis.get_label().get_fontsize() == 10 - assert ax.title.get_fontsize() == 10 - assert ax.xaxis._get_tick_label_size('x') == 10 - assert ax.yaxis._get_tick_label_size('y') == 10 - assert fig._suptitle.get_fontsize() == 10 + assert ax.xaxis.get_label().get_fontsize() == my_rcParams['axes.labelsize'] + assert ax.yaxis.get_label().get_fontsize() == my_rcParams['axes.labelsize'] + assert ax.title.get_fontsize() == my_rcParams['axes.titlesize'] + assert ax.get_xticklabels()[0].get_fontsize() == \ + my_rcParams['xtick.labelsize'] + assert ax.get_yticklabels()[0].get_fontsize() == \ + my_rcParams['ytick.labelsize'] + assert fig._suptitle.get_fontsize() == my_rcParams['figure.titlesize'] def test_relabel(): sys1 = ct.rss(2, inputs='u', outputs='y') @@ -558,10 +565,10 @@ def test_errors(): plt.figure() out = ct.step_response(sys_mimo).plot( - plot_inputs='overlay', overlay_signals=True, overlay_traces=True, - output_props=[{'color': c} for c in ['blue', 'orange']], - input_props=[{'color': c} for c in ['red', 'green']], - trace_props=[{'linestyle': s} for s in ['-', '--']]) + plot_inputs='overlay', overlay_signals=True, overlay_traces=True, + output_props=[{'color': c} for c in ['blue', 'orange']], + input_props=[{'color': c} for c in ['red', 'green']], + trace_props=[{'linestyle': s} for s in ['-', '--']]) plt.savefig('timeplot-mimo_step-linestyle.png') sys1 = ct.rss(4, 2, 2) From ed8a1c18e112556978edeb508da114e9b5ce7321 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Tue, 25 Jun 2024 11:12:43 -0700 Subject: [PATCH 08/12] allow label keyword to override generated labels --- control/freqplot.py | 17 +++--- control/tests/timeplot_test.py | 107 +++++++++++++++++++++++++++++++++ control/timeplot.py | 33 +++++++--- control/timeresp.py | 6 +- 4 files changed, 147 insertions(+), 16 deletions(-) diff --git a/control/freqplot.py b/control/freqplot.py index 1f4b8e448..f6aeb1e62 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -2647,12 +2647,13 @@ def _get_line_labels(ax, use_color=True): # Turn label keyword into array indexed by trace, output, input -def _process_line_labels(label, nsys, ninputs=0, noutputs=0): +# TODO: move to ctrlutil.py and update parameter names to reflect general use +def _process_line_labels(label, ntraces, ninputs=0, noutputs=0): if label is None: return None if isinstance(label, str): - label = [label] + label = [label] * ntraces # single label for all traces # Convert to an ndarray, if not done aleady try: @@ -2664,12 +2665,14 @@ def _process_line_labels(label, nsys, ninputs=0, noutputs=0): # TODO: allow more sophisticated broadcasting (and error checking) try: if ninputs > 0 and noutputs > 0: - if line_labels.ndim == 1: - line_labels = line_labels.reshape(nsys, 1, 1) - line_labels = np.broadcast_to( - line_labels,(nsys, ninputs, noutputs)) + if line_labels.ndim == 1 and line_labels.size == ntraces: + line_labels = line_labels.reshape(ntraces, 1, 1) + line_labels = np.broadcast_to( + line_labels, (ntraces, ninputs, noutputs)) + else: + line_labels = line_labels.reshape(ntraces, ninputs, noutputs) except: - if line_labels.shape[0] != nsys: + if line_labels.shape[0] != ntraces: raise ValueError("number of labels must match number of traces") else: raise ValueError("labels must be given for each input/output pair") diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index 921b9e765..12e22ffd7 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -424,6 +424,113 @@ def test_rcParams(): my_rcParams['ytick.labelsize'] assert fig._suptitle.get_fontsize() == my_rcParams['figure.titlesize'] + +@pytest.mark.parametrize("resp_fcn", [ + ct.step_response, ct.initial_response, ct.impulse_response, + ct.forced_response, ct.input_output_response]) +@pytest.mark.usefixtures("editsdefaults") +def test_timeplot_trace_labels(resp_fcn): + plt.close('all') + sys1 = ct.rss(2, 2, 2, strictly_proper=True, name='sys1') + sys2 = ct.rss(2, 2, 2, strictly_proper=True, name='sys2') + + # Figure out the expected shape of the system + match resp_fcn: + case ct.step_response | ct.impulse_response: + shape = (2, 2) + kwargs = {} + case ct.initial_response: + shape = (2, 1) + kwargs = {} + case ct.forced_response | ct.input_output_response: + shape = (4, 1) # outputs and inputs both plotted + T = np.linspace(0, 10) + U = [np.sin(T), np.cos(T)] + kwargs = {'T': T, 'U': U} + + # Use figure frame for suptitle to speed things up + ct.set_defaults('freqplot', suptitle_frame='figure') + + # Make sure default labels are as expected + out = resp_fcn([sys1, sys2], **kwargs).plot() + axs = ct.get_plot_axes(out) + if axs.ndim == 1: + legend = axs[0].get_legend().get_texts() + else: + legend = axs[0, -1].get_legend().get_texts() + assert legend[0].get_text() == 'sys1' + assert legend[1].get_text() == 'sys2' + plt.close() + + # Override labels all at once + out = resp_fcn([sys1, sys2], **kwargs).plot(label=['line1', 'line2']) + axs = ct.get_plot_axes(out) + if axs.ndim == 1: + legend = axs[0].get_legend().get_texts() + else: + legend = axs[0, -1].get_legend().get_texts() + assert legend[0].get_text() == 'line1' + assert legend[1].get_text() == 'line2' + plt.close() + + # Override labels one at a time + out = resp_fcn(sys1, **kwargs).plot(label='line1') + out = resp_fcn(sys2, **kwargs).plot(label='line2') + axs = ct.get_plot_axes(out) + if axs.ndim == 1: + legend = axs[0].get_legend().get_texts() + else: + legend = axs[0, -1].get_legend().get_texts() + assert legend[0].get_text() == 'line1' + assert legend[1].get_text() == 'line2' + plt.close() + + +def test_full_label_override(): + sys1 = ct.rss(2, 2, 2, strictly_proper=True, name='sys1') + sys2 = ct.rss(2, 2, 2, strictly_proper=True, name='sys2') + + labels_2d = np.array([ + ["outsys1u1y1", "outsys1u1y2", "outsys1u2y1", "outsys1u2y2", + "outsys2u1y1", "outsys2u1y2", "outsys2u2y1", "outsys2u2y2"], + ["inpsys1u1y1", "inpsys1u1y2", "inpsys1u2y1", "inpsys1u2y2", + "inpsys2u1y1", "inpsys2u1y2", "inpsys2u2y1", "inpsys2u2y2"]]) + + + labels_4d = np.empty((2, 2, 2, 2), dtype=object) + for i, sys in enumerate(['sys1', 'sys2']): + for j, trace in enumerate(['u1', 'u2']): + for k, out in enumerate(['y1', 'y2']): + labels_4d[i, j, k, 0] = "out" + sys + trace + out + labels_4d[i, j, k, 1] = "inp" + sys + trace + out + + # Test 4D labels + out = ct.step_response([sys1, sys2]).plot( + overlay_signals=True, overlay_traces=True, plot_inputs=True, + label=labels_4d) + axs = ct.get_plot_axes(out) + assert axs.shape == (2, 1) + legend_text = axs[0, 0].get_legend().get_texts() + for i, label in enumerate(labels_2d[0]): + assert legend_text[i].get_text() == label + legend_text = axs[1, 0].get_legend().get_texts() + for i, label in enumerate(labels_2d[1]): + assert legend_text[i].get_text() == label + + # Test 2D labels + out = ct.step_response([sys1, sys2]).plot( + overlay_signals=True, overlay_traces=True, plot_inputs=True, + label=labels_2d) + axs = ct.get_plot_axes(out) + assert axs.shape == (2, 1) + legend_text = axs[0, 0].get_legend().get_texts() + for i, label in enumerate(labels_2d[0]): + assert legend_text[i].get_text() == label + legend_text = axs[1, 0].get_legend().get_texts() + for i, label in enumerate(labels_2d[1]): + assert legend_text[i].get_text() == label + + def test_relabel(): sys1 = ct.rss(2, inputs='u', outputs='y') sys2 = ct.rss(1, 1, 1) # uses default i/o labels diff --git a/control/timeplot.py b/control/timeplot.py index 30b73397e..6d27be58d 100644 --- a/control/timeplot.py +++ b/control/timeplot.py @@ -49,7 +49,7 @@ def time_response_plot( data, *fmt, ax=None, plot_inputs=None, plot_outputs=True, transpose=False, overlay_traces=False, overlay_signals=False, - legend_map=None, legend_loc=None, add_initial_zero=True, + legend_map=None, legend_loc=None, add_initial_zero=True, label=None, trace_labels=None, title=None, relabel=True, **kwargs): """Plot the time response of an input/output system. @@ -112,6 +112,11 @@ def time_response_plot( input_props : array of dicts List of line properties to use when plotting combined inputs. The default values are set by config.defaults['timeplot.input_props']. + label : str or array_like of str + If present, replace automatically generated label(s) with the given + label(s). If more than one line is being generated, an array of + labels should be provided with label[trace, :, 0] representing the + output labels and label[trace, :, 1] representing the input labels. legend_map : array of str, option Location of the legend for multi-trace plots. Specifies an array of legend location strings matching the shape of the subplots, with @@ -152,7 +157,7 @@ def time_response_plot( config.defaults[''timeplot.rcParams']. """ - from .freqplot import _process_ax_keyword + from .freqplot import _process_ax_keyword, _process_line_labels from .iosys import InputOutputSystem from .timeresp import TimeResponseData @@ -342,6 +347,7 @@ def time_response_plot( out[i, j] = [] # unique list in each element # Utility function for creating line label + # TODO: combine with freqplot version? def _make_line_label(signal_index, signal_labels, trace_index): label = "" # start with an empty label @@ -375,11 +381,22 @@ def _make_line_label(signal_index, signal_labels, trace_index): output_offset = fig._output_offset = getattr(fig, '_output_offset', 0) input_offset = fig._input_offset = getattr(fig, '_input_offset', 0) + # + # Plot the lines for the response + # + + # Process labels + line_labels = _process_line_labels( + label, ntraces, max(ninputs, noutputs), 2) + # Go through each trace and each input/output for trace in range(ntraces): # Plot the output for i in range(noutputs): - label = _make_line_label(i, data.output_labels, trace) + if line_labels is None: + label = _make_line_label(i, data.output_labels, trace) + else: + label = line_labels[trace, i, 0] # Set up line properties for this output, trace if len(fmt) == 0: @@ -397,7 +414,10 @@ def _make_line_label(signal_index, signal_labels, trace_index): # Plot the input for i in range(ninputs): - label = _make_line_label(i, data.input_labels, trace) + if line_labels is None: + label = _make_line_label(i, data.input_labels, trace) + else: + label = line_labels[trace, i, 1] if add_initial_zero and data.ntraces > i \ and data.trace_types[i] == 'step': @@ -596,16 +616,15 @@ def _make_line_label(signal_index, signal_labels, trace_index): for i in range(nrows): for j in range(ncols): ax = ax_array[i, j] - # Get the labels to use labels = [line.get_label() for line in ax.get_lines()] - labels = _make_legend_labels(labels, plot_inputs == 'overlay') + if line_labels is None: + labels = _make_legend_labels(labels, plot_inputs == 'overlay') # Update the labels to remove common strings if len(labels) > 1 and legend_map[i, j] != None: with plt.rc_context(rcParams): ax.legend(labels, loc=legend_map[i, j]) - # # Update the plot title (= figure suptitle) # diff --git a/control/timeresp.py b/control/timeresp.py index 8f10d8fd3..1ecb02348 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -746,8 +746,10 @@ class TimeResponseList(list): """ def plot(self, *args, **kwargs): out_full = None - for response in self: - out = TimeResponseData.plot(response, *args, **kwargs) + label = kwargs.pop('label', [None] * len(self)) + for i, response in enumerate(self): + out = TimeResponseData.plot( + response, *args, label=label[i], **kwargs) if out_full is None: out_full = out else: From 92d36cc80c9796ddd79dd9b9cbf9091b8ffed2ac Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Tue, 25 Jun 2024 20:18:55 -0700 Subject: [PATCH 09/12] cleanup after plotting in test functions --- control/tests/timeplot_test.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index 12e22ffd7..e351d02af 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -7,7 +7,7 @@ import matplotlib.pyplot as plt import numpy as np -from control.tests.conftest import slycotonly +from control.tests.conftest import slycotonly, mplcleanup # Detailed test of (almost) all functionality # @@ -67,6 +67,7 @@ True, True, False, False, False, False), ]) +@pytest.mark.usefixtures('mplcleanup') def test_response_plots( fcn, sys, pltinp, pltout, cmbsig, cmbtrc, trpose, secsys, clear=True): @@ -190,6 +191,7 @@ def test_response_plots( plt.clf() +@pytest.mark.usefixtures('mplcleanup') def test_axes_setup(): get_plot_axes = ct.get_plot_axes @@ -238,6 +240,7 @@ def test_axes_setup(): @slycotonly +@pytest.mark.usefixtures('mplcleanup') def test_legend_map(): sys_mimo = ct.tf2ss( [[[1], [0.1]], [[0.2], [1]]], @@ -250,6 +253,7 @@ def test_legend_map(): title='MIMO step response with custom legend placement') +@pytest.mark.usefixtures('mplcleanup') def test_combine_time_responses(): sys_mimo = ct.rss(4, 2, 2) timepts = np.linspace(0, 10, 100) @@ -316,6 +320,7 @@ def test_combine_time_responses(): @pytest.mark.parametrize("resp_fcn", [ ct.step_response, ct.initial_response, ct.impulse_response, ct.forced_response, ct.input_output_response]) +@pytest.mark.usefixtures('mplcleanup') def test_list_responses(resp_fcn): sys1 = ct.rss(2, 2, 2, strictly_proper=True) sys2 = ct.rss(2, 2, 2, strictly_proper=True) @@ -362,6 +367,7 @@ def test_list_responses(resp_fcn): @slycotonly +@pytest.mark.usefixtures('mplcleanup') def test_linestyles(): # Check to make sure we can change line styles sys_mimo = ct.tf2ss( @@ -391,6 +397,7 @@ def test_linestyles(): assert lines[7].get_color() == 'green' and lines[7].get_linestyle() == '--' +@pytest.mark.usefixtures('mplcleanup') def test_rcParams(): sys = ct.rss(2, 2, 2) @@ -428,7 +435,7 @@ def test_rcParams(): @pytest.mark.parametrize("resp_fcn", [ ct.step_response, ct.initial_response, ct.impulse_response, ct.forced_response, ct.input_output_response]) -@pytest.mark.usefixtures("editsdefaults") +@pytest.mark.usefixtures('editsdefaults', 'mplcleanup') def test_timeplot_trace_labels(resp_fcn): plt.close('all') sys1 = ct.rss(2, 2, 2, strictly_proper=True, name='sys1') @@ -486,6 +493,7 @@ def test_timeplot_trace_labels(resp_fcn): plt.close() +@pytest.mark.usefixtures('mplcleanup') def test_full_label_override(): sys1 = ct.rss(2, 2, 2, strictly_proper=True, name='sys1') sys2 = ct.rss(2, 2, 2, strictly_proper=True, name='sys2') @@ -531,6 +539,7 @@ def test_full_label_override(): assert legend_text[i].get_text() == label +@pytest.mark.usefixtures('mplcleanup') def test_relabel(): sys1 = ct.rss(2, inputs='u', outputs='y') sys2 = ct.rss(1, 1, 1) # uses default i/o labels From 8f0c2272a441c5b3300aa2b69eac514412456ce6 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Wed, 26 Jun 2024 09:06:51 -0700 Subject: [PATCH 10/12] add CDS 110 example notebook demonstrating features --- examples/cds110_lti-systems.ipynb | 828 ++++++++++++++++++++++++++++++ 1 file changed, 828 insertions(+) create mode 100644 examples/cds110_lti-systems.ipynb diff --git a/examples/cds110_lti-systems.ipynb b/examples/cds110_lti-systems.ipynb new file mode 100644 index 000000000..e9d5c2c95 --- /dev/null +++ b/examples/cds110_lti-systems.ipynb @@ -0,0 +1,828 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "gQZtf4ZqM8HL" + }, + "source": [ + "# Python Tools for Analyzing Linear Systems\n", + "\n", + "CDS 110, Winter 2024
\n", + "Richard M. Murray\n", + "\n", + "In this lecture we describe tools in the Python Control Systems Toolbox (python-control) that can be used to analyze linear systems, including some of the options available to present the information in different ways.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python-control version: 0.10.1.dev32+gdbc998de\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "try:\n", + " import control as ct\n", + " print(\"python-control version:\", ct.__version__)\n", + "except ImportError:\n", + " # Version 0.10.0 is enough for this notebook\n", + " !pip install control\n", + " import control as ct" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qMVGK15gNQw2" + }, + "source": [ + "## Coupled mass spring system\n", + "\n", + "Consider the spring mass system below:\n", + "\n", + "\n", + "\n", + "We wish to analyze the time and frequency response of this system using a variety of python-control functions for linear systems analysis.\n", + "\n", + "### System dynamics\n", + "\n", + "The dynamics of the system can be written as\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + " m \\ddot{q}_1 &= -2 k q_1 - c \\dot{q}_1 + k q_2, \\\\\n", + " m \\ddot{q}_2 &= k q_1 - 2 k q_2 - c \\dot{q}_2 + ku\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "or in state space form:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + " \\dfrac{dx}{dt} &= \\begin{bmatrix}\n", + " 0 & 0 & 1 & 0 \\\\\n", + " 0 & 0 & 0 & 1 \\\\[0.5ex]\n", + " -\\dfrac{2k}{m} & \\dfrac{k}{m} & -\\dfrac{c}{m} & 0 \\\\[0.5ex]\n", + " \\dfrac{k}{m} & -\\dfrac{2k}{m} & 0 & -\\dfrac{c}{m}\n", + " \\end{bmatrix} x\n", + " + \\begin{bmatrix}\n", + " 0 \\\\ 0 \\\\[0.5ex] 0 \\\\[1ex] \\dfrac{k}{m}\n", + " \\end{bmatrix} u.\n", + "\\end{aligned}\n", + "$$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": coupled spring mass\n", + "Inputs (1): ['u[0]']\n", + "Outputs (2): ['q1', 'q2']\n", + "States (4): ['x[0]', 'x[1]', 'x[2]', 'x[3]']\n", + "\n", + "A = [[ 0. 0. 1. 0. ]\n", + " [ 0. 0. 0. 1. ]\n", + " [-4. 2. -0.1 0. ]\n", + " [ 2. -4. 0. -0.1]]\n", + "\n", + "B = [[0.]\n", + " [0.]\n", + " [0.]\n", + " [2.]]\n", + "\n", + "C = [[1. 0. 0. 0.]\n", + " [0. 1. 0. 0.]]\n", + "\n", + "D = [[0.]\n", + " [0.]]\n", + "\n" + ] + } + ], + "source": [ + "# Define the parameters for the system\n", + "m, c, k = 1, 0.1, 2\n", + "# Create a linear system\n", + "A = np.array([\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1],\n", + " [-2*k/m, k/m, -c/m, 0],\n", + " [k/m, -2*k/m, 0, -c/m]\n", + "])\n", + "B = np.array([[0], [0], [0], [k/m]])\n", + "C = np.array([[1, 0, 0, 0], [0, 1, 0, 0]])\n", + "D = 0\n", + "\n", + "sys = ct.ss(A, B, C, D, outputs=['q1', 'q2'], name=\"coupled spring mass\")\n", + "print(sys)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kobxJ1yG4v_1" + }, + "source": [ + "Another way to get these same dynamics is to define and input/output system:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": sys[0]\n", + "Inputs (1): ['u[0]']\n", + "Outputs (2): ['y[0]', 'y[1]']\n", + "States (4): ['x[0]', 'x[1]', 'x[2]', 'x[3]']\n", + "\n", + "A = [[ 0. 0. 1. 0. ]\n", + " [ 0. 0. 0. 1. ]\n", + " [-4. 2. -0.1 0. ]\n", + " [ 2. -4. 0. -0.1]]\n", + "\n", + "B = [[0.]\n", + " [0.]\n", + " [0.]\n", + " [2.]]\n", + "\n", + "C = [[1. 0. 0. 0.]\n", + " [0. 1. 0. 0.]]\n", + "\n", + "D = [[0.]\n", + " [0.]]\n", + "\n" + ] + } + ], + "source": [ + "coupled_params = {'m': 1, 'c': 0.1, 'k': 2}\n", + "def coupled_update(t, x, u, params):\n", + " m, c, k = params['m'], params['c'], params['k']\n", + " return np.array([\n", + " x[2], x[3],\n", + " -2*k/m * x[0] + k/m * x[1] - c/m * x[2],\n", + " k/m * x[0] -2*k/m * x[1] - c/m * x[3] + k/m * u[0]\n", + " ])\n", + "def coupled_output(t, x, u, params):\n", + " return x[0:2]\n", + "coupled = ct.nlsys(\n", + " coupled_update, coupled_output, inputs=1, outputs=['q1', 'q2'],\n", + " states=['q1', 'q2', 'q1dot', 'q2dot'], name='coupled (nl)',\n", + " params=coupled_params\n", + ")\n", + "print(coupled.linearize([0, 0, 0, 0], [0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YmH87LEXWo1U" + }, + "source": [ + "### Initial response\n", + "\n", + "The `initial_response` function can be used to compute the response of the system with no input, but starting from a given initial condition. This function returns a response object, we can be used for plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "response = ct.initial_response(sys, X0=[1, 0, 0, 0])\n", + "out = response.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y4aAxYvZRBnD" + }, + "source": [ + "If you want to play around with the way the data are plotted, you can also use the response object to get direct access to the states and outputs." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the outputs of the system on the same graph, in different colors\n", + "t = response.time\n", + "x = response.states\n", + "plt.plot(t, x[0], 'b', t, x[1], 'r')\n", + "plt.legend(['$x_1$', '$x_2$'])\n", + "plt.xlim(0, 50)\n", + "plt.ylabel('States')\n", + "plt.xlabel('Time [s]')\n", + "plt.title(\"Initial response from $x_1 = 1$, $x_2 = 0$\");" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Cou0QVnkTou9" + }, + "source": [ + "There are also lots of options available in `initial_response` and `.plot()` for tuning the plots that you get." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAHbCAYAAAB7rLYyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd1QU19uAn9kGu8DSOwgoRVAUe+81xhKTmK4xRVNM7z2md9N78mmqaWoSE7ux94ag0qT33mHZNt8fAygCCgoR85vnHM4uM3fuvdN23nmrIIqiiIyMjIyMjIyMTJdDcbEnICMjIyMjIyMj0zKyoCYjIyMjIyMj00WRBTUZGRkZGRkZmS6KLKjJyMjIyMjIyHRRZEFNRkZGRkZGRqaLIgtqMjIyMjIyMjJdFFlQk5GRkZGRkZHposiCmoyMjIyMjIxMF0UW1GRkZGRkZGRkuiiyoCYjcwEIgsDvv/9+1jbz58/niiuuaHOfaWlpCIJAdHT0Bc3tf4nFixfj6enZpvNxKbJ161YEQaCsrOyC+gkMDOS9997rkDldCuPKyPwXUF3sCcjIdBXmz59PWVlZux70ubm5ODs7A5KAFRQUxJEjR4iKimps8/777yNXaus84uLieOGFF1i1ahVDhw5tPB8yXYcDBw5gZ2d3sachI3NJIgtqMjIXgJeX1znbODo6dvo8jEYjGo2m08fpiiQnJwMwa9YsBEE4735MJhNqtbqjpiXDqevS3d39Yk9FRuaSRTZ9ysi0wtixY7nvvvt47LHHcHFxwcvLi8WLFzdpc7qpLSgoCIB+/fohCAJjx44Fmps+161bx8iRI3FycsLV1ZXp06c3ChttJTAwkJdffpn58+fj6OjIggULANi9ezejR49Gq9Xi7+/PfffdR3V1deN2n3zyCSEhIdja2uLp6cnVV1/dZH/vuece7rnnnsa5PfPMM020gaWlpcybNw9nZ2d0Oh2XXXYZSUlJjeuXLVuGk5MT69evJzw8HHt7e6ZOnUpubm5jm61btzJ48GDs7OxwcnJixIgRpKenN65fvXo1AwYMwNbWlu7du/PCCy9gNptbPA6LFy9mxowZACgUikZBzWq18uKLL+Ln54eNjQ1RUVGsW7eucbsG8/Ivv/zC2LFjsbW15fvvv29xjLKyMhYuXIinpye2trb07t2bv/76q3H9ihUr6NWrFzY2NgQGBvLOO+802b4lc6yTkxPLli1rMpeffvqJ4cOHY2trS69evdi6dWuL82ngXOe6oKCAGTNmoNVqCQoK4ocffjhrf3D2c7N48WKioqL4/PPP8ff3R6fTMWfOnCbm2IZr/bXXXsPHx4fQ0FCguelTEAS++uorZs+ejU6nIyQkhD///LPJXP78809CQkLQarWMGzeOb7755pzmX0EQ+Pzzz5k+fTo6nY7w8HD27NnDyZMnGTt2LHZ2dgwbNqzJ/ZacnMysWbPw9PTE3t6eQYMGsWnTpib9nu2++e2334iMjESr1eLq6srEiRObnAcZmQtGlJGREUVRFG+++WZx1qxZjf+PGTNG1Ov14uLFi8XExETxm2++EQVBEDds2NDYBhBXrVoliqIo7t+/XwTETZs2ibm5uWJxcXGL/f7222/iihUrxMTERPHIkSPijBkzxMjISNFisYiiKIqpqakiIB45cqTVuQYEBIh6vV586623xKSkJDEpKUmMiYkR7e3txXfffVdMTEwUd+3aJfbr10+cP3++KIqieODAAVGpVIo//vijmJaWJh4+fFh8//33m+yvvb29eP/994vx8fHi999/L+p0OvGLL75obDNz5kwxPDxc3L59uxgdHS1OmTJFDA4OFo1GoyiKorh06VJRrVaLEydOFA8cOCAeOnRIDA8PF2+44QZRFEXRZDKJjo6O4iOPPCKePHlSPHHihLhs2TIxPT1dFEVRXLdunajX68Vly5aJycnJ4oYNG8TAwEBx8eLFLR6HyspKcenSpSIg5ubmirm5uaIoiuKSJUtEvV4vLl++XIyPjxcfe+wxUa1Wi4mJiU2OcWBgoLhixQoxJSVFzM7Obta/xWIRhw4dKvbq1UvcsGGDmJycLK5evVpcs2aNKIqiePDgQVGhUIgvvviimJCQIC5dulTUarXi0qVLW7xGGnB0dGxs0zAXPz8/8bfffhNPnDgh3n777aKDg4NYVFQkiqIobtmyRQTE0tJSURTFc55rURTFyy67TOzdu7e4e/du8eDBg+Lw4cNFrVYrvvvuuy0ey3Odm+eff160s7MTx48fLx45ckTctm2bGBwc3HhuRVG61u3t7cW5c+eKx44dE2NjY0VRlK7X08dt2N8ff/xRTEpKEu+77z7R3t6+8Z5JTU0V1Wq1+Mgjj4jx8fHi8uXLRV9f3ybHoCUA0dfXV/z555/FhIQE8YorrhADAwPF8ePHi+vWrRNPnDghDh06VJw6dWrjNtHR0eJnn30mxsTEiImJieLTTz8t2traNu732e6bnJwcUaVSiUuWLBFTU1PFmJgY8eOPPxYrKytbnaOMTHuRBTUZmXpaEtRGjhzZpM2gQYPExx9/vPH/0x/CrQlYZ/Z7JgUFBSLQ+FBrq6B2xRVXNFk2d+5cceHChU2W7dixQ1QoFGJtba24YsUKUa/XixUVFS32OWbMGDE8PFy0Wq2Nyx5//HExPDxcFEVRTExMFAFx165djeuLiopErVYr/vLLL6Ioio1C08mTJxvbfPzxx6Knp6coiqJYXFwsAuLWrVtbnMOoUaPEV199tcmy7777TvT29m71WKxatUo8853Tx8dHfOWVV5osGzRokHj33XeLonjqGL/33nut9iuKorh+/XpRoVCICQkJLa6/4YYbxEmTJjVZ9uijj4oRERGN/7dVUHv99dcb15tMJtHPz0984403RFFsLqid61wnJCSIgLh3797G9XFxcSLQqqB2rnPz/PPPi0qlUszMzGxctnbtWlGhUDQKyDfffLPo6ekp1tXVNdm2JUHtmWeeafy/qqpKFARBXLt2rSiK0nXXu3fvJn08/fTTbRLUTu93z549IiB+/fXXjcuWL18u2trattqHKIpiRESE+OGHH4qiKJ71vjl06JAIiGlpaWftT0bmQpBNnzIyZ6FPnz5N/vf29qagoOCC+kxOTuaGG26ge/fu6PX6RpNpRkZGu/oZOHBgk/8PHTrEsmXLsLe3b/ybMmUKVquV1NRUJk2aREBAAN27d2fu3Ln88MMP1NTUNOlj6NChTfy8hg0bRlJSEhaLhbi4OFQqFUOGDGlc7+rqSlhYGHFxcY3LdDodPXr0aPz/9GPm4uLC/PnzmTJlCjNmzOD9999vYhY9dOgQL774YpN9WLBgAbm5uc3m2hoVFRXk5OQwYsSIJstHjBjRZJ4tHcMziY6Oxs/Pr9GEdyZxcXEtjtNwzNrDsGHDGr+rVCoGDhzYbL4NnOtcN5yr0/evZ8+eODk5tTr+uc4NQLdu3fDz82syZ6vVSkJCQuOyyMjINvlLnn5v2dnZ4eDg0HidJCQkMGjQoCbtBw8efM4+z+zX09OzcU6nLzMYDFRUVABQXV3NY489RkREBE5OTtjb2xMfH994P57tvunbty8TJkwgMjKSOXPm8OWXX1JaWtqmecrItBVZUJOROQtnOpcLgoDVar2gPmfMmEFxcTFffvkl+/btY9++fYDkeN0ezoyis1qt3HHHHURHRzf+HT16lKSkJHr06IGDgwOHDx9m+fLleHt789xzz9G3b982p3wQW4lcFUWxiXDX0jE7fdulS5eyZ88ehg8fzs8//0xoaCh79+5t3IcXXnihyT7ExsaSlJSEra1tm+Z5+rhnmyc0P4ZnotVqz7q+pT7PPE5n7j9IgQttobXgiHOd64bx2htccbZzc7b5nT5OW6M7z3ZvteW4tqXfhj5aWtYw1qOPPsqKFSt45ZVX2LFjB9HR0URGRjbej2e7b5RKJRs3bmTt2rVERETw4YcfEhYWRmpqapvmKiPTFmRBTUamg2jQIpxNk1JcXExcXBzPPPMMEyZMIDw8vMPewPv378/x48cJDg5u9tcwN5VKxcSJE3nzzTeJiYkhLS2Nf/75p7GPMx/Ke/fuJSQkBKVSSUREBGazuVGwbNifxMREwsPD2zXXfv368eSTT7J792569+7Njz/+2LgPCQkJLe6DQtG2nyu9Xo+Pjw87d+5ssnz37t3tnmefPn3IysoiMTGxxfUREREtjhMaGopSqQTA3d29iWYqKSmpRe3g6cfebDZz6NAhevbs2eK45zrX4eHhmM1mDh482LhNQkJCm4Ty1s4NSFrfnJycxv/37NmDQqFoVeN4vvTs2ZMDBw40WXb6vnQkO3bsYP78+cyePZvIyEi8vLxIS0tr0uZs940gCIwYMYIXXniBI0eOoNFoWLVqVafMVeZ/Ezk9h4xMB+Hh4YFWq2XdunX4+flha2vbLDWHs7Mzrq6ufPHFF3h7e5ORkcETTzzRIeM//vjjDB06lEWLFrFgwQLs7OyIi4tj48aNfPjhh/z111+kpKQwevRonJ2dWbNmDVarlbCwsMY+MjMzeeihh7jjjjs4fPgwH374YWMUY0hICLNmzWLBggV8/vnnODg48MQTT+Dr68usWbPaNMfU1FS++OILZs6ciY+PDwkJCSQmJjJv3jwAnnvuOaZPn46/vz9z5sxBoVAQExNDbGwsL7/8cpuPxaOPPsrzzz9Pjx49iIqKYunSpURHR7cp8vF0xowZw+jRo7nqqqtYsmQJwcHBxMfHIwgCU6dO5eGHH2bQoEG89NJLXHvttezZs4ePPvqITz75pLGP8ePH89FHHzF06FCsViuPP/54i2lAPv74Y0JCQggPD+fdd9+ltLSUW2+9tcV5netch4WFMXXqVBYsWMAXX3yBSqXigQceOKuG8FznBsDW1pabb76Zt99+m4qKCu677z6uueaaNqWpaQ933HEHS5Ys4fHHH+e2224jOjq6MUr2QlKwtERwcDArV65kxowZCILAs88+20Rrfrb7Zt++fWzevJnJkyfj4eHBvn37KCwsbPcLgYzM2ZA1ajIyHYRKpeKDDz7g888/x8fHp0XhRaFQ8NNPP3Ho0CF69+7Ngw8+yFtvvdUh4/fp04dt27aRlJTEqFGj6NevH88++yze3t6AlBJi5cqVjB8/nvDwcD777DOWL19Or169GvuYN28etbW1DB48mEWLFnHvvfeycOHCxvVLly5lwIABTJ8+nWHDhiGKImvWrGlz/jGdTkd8fDxXXXUVoaGhLFy4kHvuuYc77rgDgClTpvDXX3+xceNGBg0axNChQ1myZAkBAQHtOhb33XcfDz/8MA8//DCRkZGsW7euMd1De1mxYgWDBg3i+uuvJyIigscee6xRa9q/f39++eUXfvrpJ3r37s1zzz3Hiy++yPz58xu3f+edd/D392f06NHccMMNPPLII+h0umbjvP7667zxxhv07duXHTt28Mcff+Dm5tbinM51rkE6V/7+/owZM4Yrr7yShQsX4uHh0ep+nuvcgCTUXHnllUybNo3JkyfTu3fvJkJpRxEUFMRvv/3GypUr6dOnD59++ilPP/00ADY2Nh061rvvvouzszPDhw9nxowZTJkyhf79+zeuP9t9o9fr2b59O9OmTSM0NJRnnnmGd955h8suu6xD5yjzv40gttXwLyMj859m7NixREVFyaV+/mVaq2jR1Vi8eDG///77RStt9sorr/DZZ5+RmZl5UcaXkblYyKZPGRkZGZkuxyeffMKgQYNwdXVl165dvPXWW9xzzz0Xe1oyMv86sqAmIyMjI9PlSEpK4uWXX6akpIRu3brx8MMP8+STT17sacnI/OvIpk8ZGRkZGRkZmS6KHEwgIyMjIyMjI9NFkQU1GRkZGRkZGZkuiiyoycjIyMjIyMh0UWRBTUZGRkZGRkamiyILajIyMjIyMjIyXRRZUJORkZGRkZGR6aLIgpqMjIyMjIyMTBdFFtRkZGRkZGRkZLoosqAmIyMjIyMjI9NFkQU1GRkZGRkZGZkuiiyoycjIyMjIyMh0UWRBTUZGRkZGRkamiyILajIyMjIyMjIyXRRZUJORkZGRkZGR6aLIgpqMjIyMjIyMTBdFFtRkZGRkZGRkZLoosqAmIyMjIyMjI9NFkQU1GRkZGRkZGZkuiiyoycjIyMjIyMh0UWRBTUZGRkZGRkami6K62BPoLKxWKzk5OTg4OCAIwsWejoyMjIyMjIxMI6IoUllZiY+PDwpF63qz/6yglpOTg7+//8WehoyMjIyMjIxMq2RmZuLn59fq+v+soObg4ABIB0Cv11/k2cjIyMjIyMjInKKiogJ/f/9GeaU1/rOCWoO5U6/Xy4KajIyMjIyMTJfkXO5ZcjCBjIyMjIyMjEwXRRbUZGRkZGRkZGS6KLKgJiMjIyMjIyPTRZEFNZn/DjUlsPklWLEASlIv9mxkZGRkZGQumP9sMIHM/xAWM+xcArs/hLoKAOKS17E4IJQsqwGjxYhOreP+/vczO3i2nFdPRkZGRuaSQRbUZC59tr4GO96Wvnv2ZoeNmkeEQmoMBY1NDBYDz+9+nv15+3l26LPYqe0u0mRlZGRkZGTajmz6lLm0KU2XNGkAl73FHxMf5V5VGTUKBUNqDazMymXdkJd5oP8DKAUlf6f8zc1rb8ZgNlzcecvIyMjIyLQBWVCTubTZ9DxY6iBoNDkRl/PSvpexiBZm9pjJp76XE2Iy4bv1bW7rNZ+lU5fiYutCQmkC7x1+72LPXEZGRkZG5pzIgprMpUv6Hji+CgQFTHmNdw+/R52ljoGeA3l5xMuoxz8DNo6QFwNHl9PPox+vjHwFgB/ifmB39u6LvAMyMjIyMjJnRxbUZC5NRBHWPyl9738zhwUj69LWISDw+ODHpYABOzcY86jUZvOLUFfJSN+RXBd2HQDP7HqGMkPZxZm/jIyMjIxMG5AFNZlLk9yjkHMEVLZYxz7J6/tfB+DKkCvp6dLzVLvBd4BLd6jKh8PfAvDQwIcIcgyisLaQD458cDFmL3OBWKwWNqSs5aafxjHj24G8+ttsdu56HUtd9cWemoyMjEyHIgtqMpcmx1dJn6FTWFd4iLiSOOzV9tzb796m7VQaGLZI+h79IwBalZbnhj4HwKqTq8ipyvm3Zi3TARwrOsbs32fx8I7HOFpXRJpYx/Lqk9x18gfu/XEMRkPFxZ6ijIyMTIchC2oylx6iCMdXSt97zebXxF8BmBcxD1eta/P2va8CpQbyj0FuDAADvQYyxHsIZquZr2K/+rdmLnOB5FXnsWjTXaRWpuNgsXJnRS3vuY/hahsfbK0iOxR1PP7bDMwW08WeqoyMjEyHIAtqMpce2YehLAPUOjK8IjiYfxABgdkhs1tur3WGsGnS93qtGsBdfe8CZK3apUKtuZb7/rmPkroywuqMrC+zsujqlUyY9hHPX7eeD/rcg1oU2WQp4dlVV2EVrRd7yjIyMjIXjCyoyVx6NGjTQqfye/p6AIb7DsfLzqv1baJulD5jf4V6bcsAzwGyVu0SQRRFFu9eTFxJHM4WC+8XluEwbzV492lsM2zAnbzT7QqUoshf1amsPiD7H8rIyFz6yIKazKWF1QrHfwfA0usK/kj+A4DZwa1o0xroMR7sPaGmCJI2Ni4+XauWX53fKVOWuXB2ZO9gTeoaVCK8U1CEb7+bwS24Wbtx41/mXpsAAD6I+4YaU82/PVUZGRmZDkUW1GQuLbIOQEUWaOzZbWdPQU0BTjZOjPMfd/btlCroc430PfqHxsUDPAfQ36M/ZquZlSdXduLEZc4XURT56MhHANxUXsEgqwbGPNZq+7nj38LXZKYAM0v3vflvTVNGRkamU5AFNZlLi7g/pc+waaxK/RuA6d2no1Fqzr1t3xukz8T1UFfZuPiaMEmA+y3xN8xWc4dOV+bC2ZSxibiSOOxEuLW8AkbcL+XIawWNZwQP6SRt27LkVeRV5/1bU5WRkZHpcGRBTebSInU7AFU9xrIlcwsAVwRf0bZtPSOknGpWEyRvaVw8KWASLrYuFNQUsC1rW0fPWOYCsFgtfHzkYwDmlpXjrHWFYXefc7tJoxfT32DAgJUP973e2dOUkZGR6TRkQU3m0qG2DPJiAdhtq8ZsNROoDyTMJaztfYRMkT6T1jcu0ig1jcLerwm/dtBkZTqCNalrSC5PRo+SeeUV0Pc60NidczvBbwCP2naX+sj8h4Kags6eqoyMjEynIAtqMpcOGXsBEVx6sKNYEthG+Y1qXx+hk6XPpI1SYEI9V4dejYDArpxdZFZkdtCEZS4EURRZenwpALeUluIgitD3+jZv33vk4/QzGDAjsiL+586apoyMjEyn0uUFteeff56IiAgUCgU//fTTxZ6OzMUkfScA1oDh7MjaAcBov9Ht6yNgBKjtpJJSeUcbF/s7+DPcdzhAYwJdmYvLsaJjJJUmYSMouaaiHDwjwbNX2zsIGsu1RhUAv8X/hMkqJ8GVkZG59OjyglpISAjvv/8+gwcPvthTkbnYpO0CIM6jB8WGYuzUdgzwGNC+PlQ20KM+QjRxQ5NV14RKQQWrU1bLQQVdgBVJKwCYbFGjt4qS2bM9KBRM6nE5LhYLBaYKtmRsOfc2MjIyMl2MLi+o3XTTTUyaNAlbW9uLPZVmnCzO5ot9W4kpOEZccRwJJQkkliZysvQkuVW5VJuqEUXxYk/zv0FdpVSIHdiuMAIwzHsYaqW6/X2F1Js/E9c1WTzKdxRONk4U1RaxL3ffBU1X5sKoMdWwNnUtAFfmp4OggMir292PpvccrqqsAuDn+OUdOkcZGRmZfwPVxZ5AR1FXV0ddXV3j/xUVnV+Y+e3d37Or5Hs+jG+9jY3Shu6O3QlxDmGA5wAmdJuAo41jq+2tVhFEEYWyy8vQ/y4Z+0C0gFMA2wujgfMwezbQIKjlHIaqArD3AECtVDM1cCo/JfzE6pTVjPAd0QETlzkf1qWto8ZcQ4DKgQGGDAieCA5nqTzRGn6DmCPa87Uosj//IMllyfRw6tHxE5aRkZHpJP4z0sBrr72Go6Nj45+/v3+nj2mj1IHZGavJEatJj2h2QK92xtHGEZVCkoHrLHXElcTxZ/KfPL/7ecb+Mpb7/rmPE8UnGvsxVJvYs+okK98+xJcPbueLB7azfXkCFcW1nb4PlwzpktmzqNtgjhUfA84jkKABvTd41ZceOq1KAcCMHjMA+CfjHzmr/UWkwex5ZbUBAaDPtefXkUKBd88rGF0j3UsNlSxkZGRkLhX+Mxq1J598koceeqjx/4qKik4X1t6fdi9G8yI2nMjjy+0pHM0qx8ZOw++LRuDnrKXWXEthbSEny06SUJLA5ozNJJYmsiVzC9uytnFt2LXcEriQLZ+epDSvqVAQuy2b4zty6D81gMEzghAEoVP3pctTL6jtdHSFSohwjcBN23rS03MSOgXyYiD5H+h3Y+PiSLdIAvQBpFeksyljEzN7zLzQmcu0k5OlJ4kpjEElKJmZnyqZPUMmnX+HvWZzeexSttrp2JC6jgf7PyjfTzIyMpcM/xmNmo2NDXq9vsnfv4FGpWB6Hx+WLxxKLx89xdVGbl12gMo6Mzq1jgB9ABO6TeDuqLtZMXMFK2eu5LLAy7CKVtYe/ofvX91JaV4Ndk42jJ8XzvXPDWHWA1H49XTGahU5uCaNw+vT/5V96bIYayD7MAB7xGpA8ie7IILGSJ+p2+E0P0JBEJjefToAq5NXX9gYMufF2jTJN22kXQBuFiv4DQat8/l36DeQ0SpXtFYr2dW5HCs61kEzlZGRkel8urygZjKZMBgMWK3WJt+7GjqNiq9vHoSn3oakgiqeXBnbYrsQ5xDeHPMmn476givi7kNXp6dCW0SfBXrCh3vj4mOHX08XZj3Qj5FzQgDY+3sKJ5b/AZX/o0XDc6PBakJ08OFgaRwAg70uMArYbxCobKG6AIoSm6xqENT25e6TC7VfBDalbwJgcq0UNHJB2jQAQUDXczpj6s2f69LWnWMDGRkZma5DlxfUFixYgFarZceOHcybNw+tVsv27dsv9rRaxMvRli/nDUQhwN8xuURnlrXa1rTHGVujPTV2ZazstYRF+xZytPBokzZ9B6kY0CMBgK3bdGS+fi2sXAgFZ4le+C+ScwSAbJ/eFNQUoFKoiHSPvLA+1bbgXy/spTa9nvwc/Ojv0R8RkfVp61vYWKazSC5LJqU8BZVCxZiMGGnhhQpqAMETmFotuResT1uPVex6L3syMjIyLdHlBbVly5YhimKTv7Fjx17sabVKHz8nruzvB8Aba+NbTM+Rm1zOiR05AMy+bSgRvmFUmap4aMtDlBhK6hsdhY8GMaTqCXra/oOIkm1lt2M+uhK+mgil/0Pm0JxoAA7pXQDo5doLrUp74f0G1UeNpjYX/C8LugygMUWEzL/DxnQpuGOYYyh6YxXYe50K/LgQAoYzss6CndVKfk1+s5ciGRkZma5KlxfULkUemBiCRqlgT0oxO08WNVlnsVjZ9qOkEes53JvgCB8+nfgp3R27U1BbwDM7n8FaVwm/3QbGSgSfKEYtuhydo4Zyiw+HhbvBWAl/LGpSAuk/TW40AIcEKQntAM92JrltjcB6QS1tR7NjOSlgEgpBwbHiY3JJqX+RBrPnJItGWhA8ETrC8V9jh023oYxrMH+myuZPGRmZSwNZUOsE/Jx13Di0GwBvrktoolU7tjWb4uxqbO3UDL9SyuekU+t4a8xbaBQadmTv4Lvfb4LiJHDwgbmr0IQMa/RXO1Q4ljKCJOHiwFf//s7929RVQlESAIdrs4EOFNR8+0vlpGpLIb+pg7mr1pUhXkOAjvdpMlSbOHmogLSYIvJSyjFUy6WNADIrMkkoTUApKBmXLfkiEjKx4wboMZ6pVVIwyob0DbL5U0ZG5pJAFtQ6iUXjgrHTKInNLmdTXAEgadOiN2UAMGRWd7T2msb2oc6hPD74cQDeq03mpFoNV34OOsncFzzAg24RLlgtsF3xsrTRpuehOPlf3KuLQF4sIFKo9yG9KhsBgX4e/Tqmb6UaAqT6nqTtaLa60fyZ1jHmT0O1iX1/pvDd07tZ/+Ux/v4khhVvHuKbJ3cRvSlDSnb8P8zGDMnsOcg1EqeiJBCU0H1cxw3QYwLDaw3YWa0U1RZxvOh4x/Ut0+GklqdyKP8Qe3L2EF0QjcVqudhTkpG5KMiCWifhZm/DTUMDAPhhn+RPlnKkkKrSOrQOanoOa55lfU7QdMbWWTALAu8G9z/lQ4WUNmL09aEoVAKZOTpyXK8HUw1se+Pf2aGLRYN/mkcQAGEuYThoHDqu/6D6NB8t+KlNCJiASqEiqTSJk6UnL2iYoqxKfnh+LwfXpGE0WHD00OLezQE7JxvMRiu7fjvJijcOUpb/v5tkt9HsqanPj+c/GLROHTeAZ2/Udu4MrzUAsC1rW8f1LdMhmCwm/kr5ixv/vpGZv89k/rr5LNy4kLlr53L5qstZtuc1yre9Dj/PhS/Gwra3JI24jMx/GFlQ60SuHyyZP7clFpJZUsPRzZKvU+/RvqjUymbthcPf8khBPioRthty2Z+7v8l6R3cd4cN9ADhQc4O08MQf/+0fqgb/NJ0UPNBhZs8GGoThtF1gaVqIXa/RM9J3JHBhWrWSnGr+eC8aQ5UJZy8dUxf25sbFQ7nmqUHc/Opwxt4YhsZWSUF6JX+8d4Tq8rpzd/ofo6i2iNgiKaXNuLL6gJrAC8yVdyYKBXQf15imY3tW14we/18lpTyFOavn8OSOJ4kpikGtUBOoDyTEOQQHjQPZVdm8k/gjs09+Q3zyWikafMvL8G4kbHntf8dnV+Z/DllQ60QC3ewYEeyKKMIv65PJT61AoRLoPcaveWOTAXa9R4DZzNWufQFYcmhJMz+a/pO7oVAIZKWaybOfCmYDxPzyb+zOxaFeo3bYUgl0gqDm1QdsHaUAjbzmkYCXBUrmz3Wp61qM4D0XZfk1/PHeEQxVJjwCHLjq8YH06O+BoJAc5AWFQK9Rvlz//FCcPHVUldax9rNYzKb/LTPPrmyp8kSEawTumQekhYGdUGu1x3hG1tQiiBBXEifnyesibEjbwPV/XU9yeTIuti7cE3UPG6/eyOrZq1l5+c9s1kXxQmExASYThSoV8/26sXvcQ+DRS7p3t70OW1+92LshI9MpyIJaJ9OgVcvdL/mphQ7yRKfXNG8Y/T1U5oLelzvHvYVOpeN48XE2pG1o0kzvpiV0qGQ2PWi4SVp4aFmT7Pr/GeqqoCiRcoVAUk0eQMf5pzWgUEK3YdL39D3NVo/1H4ut0paMygxOlJxotv5sWExW1n4eS02FEVdfe2bcF4WNtuWqbfbONlx+dx9sdCryUyvY8l3LqV3+q+zM3gnASJfeUJENCrVUkaCj6TEOV6uVyDpJa7k9W9aqXWy+Pf4tD297mBpzDYO8BrFi5gru6HsHrlpX6Xdt1Z1oj/zAldW1/Bh+J4M8B1EtmliU/jvbZ7wG096WOtr+FkT/eHF3RkamE5AFtU5mcoQX/loNAfX11ftOaKH+qNkIO9+Tvo94AFd7b27pfQsAH0d/3EyrNmBqAIIA6Vl2FFp7QsEJyDrYiXtxkagPJIh18kZEJEAfcGH1PVujIaAgfXezVTq1jjH+Urmp9qZ0OLg2jZKcarQOambeH4Wtnfqs7Z08dUxZ2BtBIZC4P5/E/f8b2h6z1cyuHEmjNspa/xLj2x80uo4fzMELXINPmT8zZUHtYrIyaSVvHXwLgHkR8/hi0hdN7/HoH+HYb6BQwXU/oh/xAJ9N+oypgVMxi2ae3PkUuRHTYWR9nec/75PcGGRk/kPIglono1EpuMLFGQUClfYK3PxacIQ/9huUZ0rJPfvPA2BuxFzs1fakVaSxO6epAOHkoSNkkCcARxR3SgsPL+vM3bg41PunxTp7A1LB9E6hW72glrG7RT+X05PftjWlQ2FmJYfXSUEko68La1mL2gL+PV0YPF0KnNi98iRGg/kcW1z6xBTGUGmsxNHGkciCVGlhQCeYPRsIGM6YWklQ25u7F4PZ0HljybTKurR1LN69GIBbet3CIwMfQaU4TeNcnAxrHpW+j3sKwqT7UKPU8OrIV4l0i6TCWMFj2x/DNPYJiLgCrCb4816wyClvZP47yILav4BnmeRvtM9ioLCyBUfxQ99In0MWSqWNADu1HVcEXwHAD3E/NNskaqJkUk0uCKDa4gzHVko5x/5L1PunHdNImqjebr07ZxzvvqDWSUEZRQnNVo/0HYm92p78mnyiC6LP2Z3FYuWfb+OwWkV69HMneIBHu6bTb1I39O5aasqNHPw7rV3bXorsyJZSo4zwGYEyo14b0hn+aQ0EjCDUaMJTVGCwGNift//c28h0KLGFsTy14ylERK4OvZoHBzyIcHpiY4sJVi4AUzUEjIQRDzTZXq1U88boN7BX2xNdGM0nMZ/BrI/Azh1KkiV3EBmZ/wiyoNbJlOXXUJ5djRWIV1tYdyy3aYPCRMjcK+WMirqxyarre16PgMDO7J2kVzQtGeXezQHvHo5YrXBMvFZK1ZHyH0s3kH8METhmrgA6UVBTaaQi7QDpzc0mNkobRniPBWDhyq8Y//ZWLnt/B4/8epScstpm7U/syKEoswobOxWjrw9r93SUagWjrpESHB/9J5PSvOp293EpsSNLEtRGOUdAWYZ0L/gP6bwBA4YjAGOqpBcbOfrz36XEUMKDWx/EZDUx3n88zwx5pqmQBnDw/yD7kBToc+Xnki/pGfg7+LN4+GIAvo79mriqLBgj5aJk2xv/vRdXmf9ZWvZslukwkg5KfkZKb1tqa2tZHZPL3GGBpxoc+Vb6DJks+c+cRjd9N0b6jmRH9g6Wxy/nicFPNFkfOc6P3ORyjleOZaDTVyhPboTw6Z25O/8eFhMUJZKrUlJirkIlqOjp0rPzxgsYDqnbJD+1Qbc3LjZZrLy7MZE1RzxR+kCt5ghF6VMBJXG5Ffwdk8s944NZMKo7GpUCk9HCwTVpAAyZ0b3NJs8zCYx0IyDSlfTYYnb9dpLp9/TtgJ3seuRX55NQmoCAwIi6ejOvTxTYdGCuvDNx6gZ6P4bXFPOLgx17c/d23lgyTbBYLTy2/THya/IJ1AfyyshXUJ4phBkqTuWHnLgYHFuIkq9nSuAUNqdvZm3aWt45+A5fTvgEYe+nklZt94eSyfR/BIvFgskkm3y7Kmq1GqWy+QtHW5AFtU5EFMVGh/B+I/1gYykH0krIrzDgqbeVhJGjP0mN+89tsY8bw29kR/YOfj/5O/f2uxc7tV3juu793LFz1FBdDsmGYYQmbZKipDqiNuLFpjgZLEZi9c4AhLqEYqO06bzxGgMK9jQeQ6PZyn3Lj7DueB7QHUcvO1BV8fwcG/y0UXyxPZkDaaW8tT6BIxmlfD53ILFbs6ipMOLgakvESJ8LmtLIq0PIOFZM+rFiCjMqce/WicLLRaIhiCDSLRLn7MPSws70T2sgYDiDj/2KEoH0inRyqnLwsb+w8yVzbj49+in7cvehVWl5d+y72Gvsmzfa/QHUFINrMPSbd84+7x9wP5szNrMvbx878vYyeuLz8Ms8SVAbdDvYt8/14FKkqqqKrKys/6lI8UsNQRDw8/PD3r6Fa/4cyIJaJ1KUWUVZfg1KtYIBw33on5DJ4Ywy1sbmMn9EECSug+pCsPOQNGotMMxnGIH6QNIq0vg75W+uCbumcZ1SqaDXaF/2r04lpmY6oRWPQ2ECeHSi5unfokBKhXHMyROo6bxAggZ8B0opISpzoDQNoz6ART8eZuOJfDRKBe9c048jNdP4NfFXUg27uGXAFCaGe/B7dDZPrIhlU1wBL6yMpdueMgAGXR6EUnVhngVOnjqCB3qSdCCfw+vTmbKgk0y/F5E9OVJKlBG+I2D7l9LCwJGdP3DAcBxif6G3qOaoYGRv7l6uDLmy88f9H+ZIwRG+jJXO8eJhiwl2Dm7eqDIP9nwsfZ/wPCjP/YjytfflxogbWXpsKUsOLmH4jF9R+fSHnMOSr9qYxzpwL7oeFouFrKwsdDod7u7uzc3IMhcdURQpLCwkKyuLkJCQdmvWZB+1TiTpgKRNC+ztikarYnof6Y39r5h6P7XD30mfUddLdSdbQCEoGh8ga1LXNFvfa5QvCpVAvimUQlN3OLmxg/fiIlEvqMXadHIgQQManZQSAhDTd/HIr0clIU2l4It5A5jR16cx+nNTxiaMFiOCIDC7nx/vXRuFIMDJnbnUVZtx8tQRNsSzQ6Y1YKpUhiz5cMF/rryUVbSyL3cfAEOdekJJirTCvxPyp51JvdZuWIVU1aNBYJTpHKqMVTy540msopWZPWYyrfu0lhtufV3yt/UbDOEz2tz/7ZG342TjRHJ5MquSf4ehd0krDi1rVnHkv4bJZEIURdzd3dFqtdja2sp/XexPq9Xi7u6OKIrnZZ6WBbVOQhRFko9ISW6DB0oP7WmR3ggCHEwvJT875ZRQ1a9ls2cDDQLCofxD5FXnNVmn02voEeUOwPGaSZD0XxHU4rAAJyySI32na9SgMfFt2qGN/Hk0B5VC4Mt5AxkbJplO+nv0x0PrQaWxsknKlMsivXlqUhgDDNLbv9tQdxTKjrm1XH3tCYyUqlsc2ZB+7g0uIZJKkyitK0Wr0hJZUyUtdAsDrXPnD+4WAjo3hlZL4+7L3dfm1Csy7ef1/a+TXZWNr70vTw5+suVG5dlw5Hvp+6QX2uXCodfoubOvlKro69ivMfe8HHSuUvLkxPblP7xUkTVpXZsLOT+yoNZJlObVUFFkQKES6NbLBQAvR1sGBUjfM//5GkSrJBy4hZy1Ly87L/p7SNqelpKuNvhCJRpGY0o7LGX0v9QpOEGKWk2taMZObUegPrDzx6zXsigyJefyhyeHMSbUvXG1UqFkcqBkol6b2rT252DRBlsEShRW3kvIxmzpuId+/6mBAMTvzaOq9L9TB7TBiX+g50DUOfX+af6D/p3BBQEChtOnrg6doKK0rpT4kvh/Z+z/Mf7J+Ic/kv9AISh4ZeQrLfulAez9RMqDFjDylM9oO7gq5CqcbZzJrspmU84O6FdfueXg1xcwexmZi48sqHUSabFFAPiFOqOxPeVnMbW3FwJW/NJWSAv6n9tZFuDy7pcDLZs/fUOd0btrMYk6TlYPgrQdFzj7i4yxGkpSOWYjRUxGuEY0jwzrjGF9BmFFIEDIY1oA3DG6e7M2DdrNLZlbqDVLqTmsVpGYLZkAHLcXicur5Lu9Haf98u7hiE+IE1aLyLFtWR3W78WmQVAb6j0UGup7dkbZqNYIGI4aGIRtk/nIdBzldeW8uOdFAG7udXPrtXprS0/lPhv5wHmNZauy5fqe1wPwzbFvEPvPBwRI/kcKTvpfRRQ7rcRgamoqPXv2pLY+gXRMTAyRkZGN5tg777yT4OBgBg4cSHJy287B1q1bcXZ25sYbpXRVGRkZjBgxAltbWz777LM29bF//3569+5NcHAwL7744jnbGwwGrrzySkJCQhg3bhxFRUXn3Oarr74iJCSEsLAw/vrrLwBycnKIiorCy8vrHFu3D1lQ6yTSYqQTHRDZtOTRhHAPhiri8LLkImrsIWIWdampFLz/PtmPPkb6zfNJnzuPgnfeoXLrVqz1N8CkgEmoBBVxJXGklqc26VNQCPSq16qdqP0PmD8LEwCRWDs98C/4p9Xz5YFi4qxSIuFXBlSgUDRXVUe6ReJr70utuZZtWVLeupQjhVQUGbC1UzN9luQgvWRDIgWVHZfxvs94KUXBid25WMyXvonOZDFxKP8QAEM8B0qO3/Dv+Kc1UD/WsHLpXpX91DqeN/a/QbGhmCDHIBZFLWq94YGvwVglFVkPnnje413b81pslDYcKz7GIVPJqb4O/t9593lJYrVIgRnFyZB/DHKPQlESVOaD+ZRW3mw1U1xbTFZlFinlKSSUJJBYmkhyWTLpFekU1BRQaazEYrW0OExQUBBXX301r7/+OgD33nsvS5YsQa1W89dff1FWVsbJkyd54YUXePzxx9s8/SlTpvDDD1Kid71ez5IlS3j44YfbvP0999zDzz//TEJCAmvWrOHYsWNnbf/ll18SGhpKUlJSk/1pjeLiYpYsWcKRI0fYsmULDz30EGazGR8fH6Kjo9s8z7YiC2qdgKHaRF5yOQCBka5N1gW42nGbnVSAOlUYReZDj5My7XKKP/2MitWrqdm3j5oDByj+8iuy7ryLk5MmU/rTzzipHBjmI/lQnWl2A+g5zBuFQiTP1JPi+KRO3sNOpiAOgOM6KRVJb9fOF9Ryy2v56J+T7LdKEbPOhS3XThUEoVGr1mCGPro5Q5rnGF+uHxZIHz9HKuvMvLmueZWD8yWwjxs6Rw21FUZSogs7rN+LRUxRDLXmWlxsXQipM0gO5DaOko/av4VXH1BpGVpRAsDh/MOdUk7KbLJQU2H8T6dOsFpFDqWX8NqaOKa9v4MZH+7kiqVfsDplNQIKXhrxUuvpdUwG2FevKRlx/wWlF3KxdWFWj1kAfHPiGxh0m7Ti6E//+aACURSpMZqpqaqkJieOmpJsaqrKqKkzUmOyUFNdQU1JFjU5JyguziKhKI2YvHjSSnPIryyltLqaKoORyto6ympqKKqqILMsn8SiNOJL4kmvSKfUUNpMaHvqqadYvnw5r776Kq6urkyaNAmA1atXM3eu5H89bdo09u7de173gJOTE0OGDEGtPnut5AZycnIQRZFevXqhVCq58cYbWb169Vm3OX2uc+fObdSQtcb69eu5/PLLsbe3x8fHh8jISA4cONC2HToP5PQcnUD6sWJEEVx87NC7aZuurC1jtGkvJYl21B6Joa7+wrUfOxbdoEGoPDwQjUZqDh+ietduzHl55C1eTMl333HF/dPZwQ7WpK7hrr53NXFO1Ok1BPZyIiW2nBM5IYyqKQGdy7+52x1HwQnMwEmkH9ZOTXRbz2tr4qk1WSjyHAjl66V8aq0wNXAqX8V+xY6sHaQk5JKXUoFCJdB7jC9KhcALM3sx+5PdrDqSzf0TQvB3ufDi4kqlgogRPhxck8bxHdmEDOyYqNKLRYOZcYjXEBTZkmYNvwGg+BffHZVq8O1P9/RdeKjsKTBXcaTgSOML0fliMVtJiS4kfk8eJTlVVJXVgQg2OhUuPnZ0i3Clzzg/NNr/xs/viZwKHvw5moT80yoBKGqw674MhQLqikfy9p8GHpxUSv9uLQSKxPwkpSly9IfeF54iZW7EXH5N/JWtmVtJjbqPIK0L1BRB2nboMf6C+++q1Jqs9H9hfRtb57Sr7xX3dQOqqDJWkSfkobfR42LjglatRafT8cQTT3DnnXeSmJh4aoScHHx9fQHpBdfV1ZXi4mKysrKYP39+szF69erVqEW7EE4fF8DPz4/Nmze3eRu9Xk9l5dmrWrQ0RnZ29gXM+uz8N34puhjp9f5pgX3cmq2zHl5O0T4t5ak6FIjYT5qExwP3Y9OjR5N2TlddiWg0UvrzLxR9/DHG5GS6PfoZYy5TsC08ndTyVLo7NfWhihgbSErsURJqxzAs7QCqiCmdt5OdScEJ0tUqjFjRqXT4ObSembwj2J9awp9HcxAEmD7jKvj+FSg4Dq0Iu6HOoXR37E5KeQrb1sUAakIHe2HnKGkM+nVzZlSIGzuSivh8ezIvX9ExEasRI304tDaN7IQySvOqcfayO/dGXZTGtBw+QyGmXkP8b/qnNeA/GCF9F0MFO/6kij25e85bULNYrBzdlEn05kxqK4zN1tfVmMk9WU7uyXKiN2fQb1I3+k7wR6XufP/LzsBqFfm/Xam8uS4Bo8WKg42K8eEeTAz35PesJewvqkSLF9VFk9hRUMTu5GKemhbOrSMCT71kiiLsrdemDb2r1TRF7SHQMZDRfqPZlrWNlSl/8nDELDi0VKqH/B8W1DoziKy7Uw/MVFNeV06dpY4yQxllhjJsVbY42zqzfv16XF1dOXnyJIGBgQAtas8EQSAqKqpF86AoipiNFupqTJiNVmoqjCgUAiobRbvukdbGbe82HT3GhSALah2MxWIl/bhkSgk8wz9NNJvJfuUzqlJ1iAJ8FTGd6x96Av8g15a6QtBocJl7E44zZ5D92GNUb9vOot/Bu0BgW/+tzQQ1/3AX7G2rqTI4kLw3gbCITtnFzqcgjgSNFEgQ6hyKQug8LYvVKrL4z+MAXD+4G+HBPcA1BIqTIGMv9Gye70kQBKYGTeXrA8uoSlCgAHqP9m3SZtG4YHYkFfHLwSzumxCCh4MttbGxVG3fTs3+Axji4xEUCgStLWofHxwmTMRh0iQ0fr7NxmvAwcWWgEg30mKKOL49h5HXnD1auKtSbaomtjAWgCHeQ2BNvbPvvxXxeTr1NUWHVZTwpxb25uyFVvzdz0Z+agVbvo+nOFt6WOr0GiJG+RDQyxW9mxYbrYrS/GoK0iqJ3pRBaV4Ne39PIS2miGl39UHrcH6lxi4WoijyzB/H+HGfZPafGO7BG1f1wdXehu1Z29kfvR4BgS8uewvXGaG8sS6ev2JyeemvE0RnlvHmVX3QapSQuh0K40BtdypKswO4OvRqtmVt48/kP7lv4POoDy2FuD/h8iVSbd//GhYT2ppcTtzlBVpXcPRtYkI2mOvIrMjAbDWjUqjwsnXBoTIPrGbp2LsEtVhPtQGtWokg6HDTulFjrqHUUEqFsQKD2cCf6//kZPpJPv9pKffe/QB79h9Er7PB19eX7OxsoqKiEEWR4uJiXFxciI6ObqZRs1pEQoLD+PS9r6ipMGI2WagqPeWGoNIoMdVZEK3nFqgaxm0gOzsbb2/vNm3j5OREZWUlDg5nrwLj6+vLkSNH2jXGhSD7qHUweSfLMdaasbVX4xmkb1wuiiJ5Tz1EVYoRQSHyz3X3sDJkLJviC87Zp9LREf9PPsF1wQIArtwtwqffN5PqFQqBiF6SufBE3CWqbakpgcpcEjTSm3WYS+f6LP0dm8uJ3AocbFQ8Mrl+rIbUABm7W93ussDLCCscjMKqxNlPi0dA0xt7SJALAwKcMZqtrPhxAxm3LyBtzjUUffgRNfv2YS0vx1Jaijknl9qDhyh44w2SJ04k6957MWa1rkJvEAjj9+ZiNrXs4NvVOZR/CLNoxt/BH180UFofHOM78N+fTL0Wb2iBNIe4kjhKDCVt3ly0ihxck8qKNw9SnF2FrZ2a8fN6Mu+14QyZ0R2v7o7o9BqUagVufg5EjPThuueGMHF+ODY6FXkpFfz2xkFKcqs7Zfc6i3c3JvLjvgwEAV6c1Ysv5w3E1d6GSmMlL+x5AZBMkFEeUfi76Pjw+n4snhGBSiGw+mgOC787SJ3ZAvs+lzqMukEqwN5BjPQdibvWnRJDCVsURrD3BEM5pGzpsDG6DMYaqClGEKzodPbo3Luhs1Gj06jQaVQIChMFhkxUKiuOOi0R7sF4Onmi8wpBp1GjoxZdVQY6taJxmzP/GrRFgiCgU+lwUHpgY/XDVGfPG8+8yROvPEGPXv5EDorgjfdf5URePsPGTuL776W8eGvXrmXIkCFNNGpHjhxhz479bFq9g01/7eDT975CEARUGgVKlQIbnRq1jSQ8mo0WjLVmqiuM1NWe8jXs2bO5W4yPjw+CIHDixAksFgs//vgjM2ZIyZOffPJJVq1a1Wyb6dOnN871u+++4/LLpSwL+/fvZ9685pkZJk+ezJo1a6iuriY3N5eYmBgGD+48i4AsqHUwGXHSj3y3CJcmUYPFX31F2Z8bARGfOSF0u2I2AP/EnVtQAxCUSjwefgjbJx4AYOg/uWS9+3azduFjQxGwkFPpR2lO+YXtzMWgPpAgwU760Q51Du20ocwWK+9uknwqbh/VHRe7+jfthlqT6a0LagH6AKKKxgJgCitspvYWBIFFw3x54PAvjH33cap37gSVCocpU/B6/jmCVq0k6M8/CPzlZzyffhrdoEGgUFC5cRMp06dT9NlniJbmgli3CBfsnW2oqzGTFlN84QfhItAQXTnEewhk1TvguoWB1unfn4ydK7gG42a1EqKT3oj35+5v06ZGg5m1n8ey789URBFCB3tyw+IhhA/3QXmWhMcKhUDYUG+uemwAejdbKooMrHzrEKV5l4aw9s3uND745yQAL83qzbxhp0yZr+9/nYKaAgL0AdzT757GbQRBYP6IIL6/fQg6jZIdSUW88O0axIT6dEODF7Y6ntUqUlZQQ2FGJTlJZZTkVmM9h2ZFpVBxRfAVAKw8+TtESN85tvK89rlLs/9zsBhBUEmasdMsECaLiYyKDCxWC1qVlkB9IOoG87JaB649QFBKEbfl5/axMlmspBfXkF5SQ3WdlZ/+72f69hvCoH7jUQt23Pfkffzw5TLKK5MZMKEXZpVAUPcePPvss00iKUWrSGWxgcoSA1ariFKlQO+mxc3fHgcXLWobJY7uWpy97NC6KOg3PILPvv6Yl197np7hoZQX1lJYWNSqyfKDDz5gzpw5hIWFMXnyZCIjJfeTY8eOtZg6Y8GCBcTFxRESEsIvv/zCE088AUBmZiZarbZZezc3N+6//36ioqIYM2YMb7/9NipV5xkoZdNnB5N5QhLU/CNO+TZV795N4TtLAPDsV4F+7gOM8XVHqRBIKqgio7iGbq5tczgPmn8Hb51YzvQ/86n64v8odnTF9bZbG9fb9wgnQLuetNooTmw8xoib/4UC1x1JoZR0NEGtBCydqlH7PTqHlMJqnHRqbh0ZeGpFg0YtJ1ry+7BpnqAzJ6kMXbUzRoWBHdq/uJmZTdbXpaQQ+OwDeGckYUWgcOg4hr/0BBp//2Z9afv0wWXuTRgSE8l/8SVqDh6k8L33qTlyBN93lqC0P6UdFRQCoUO8OLwunYR9eQQP6HoFpwsqDaw+msuJnArUSgGNSkEvHz2XRXqjt1WzL6/eP817KJysD9q4GGbPBvyHQPFJhikcSCKXPbl7mBo09aybVJUaWP3hUUpyqlGoBMZcH0bEiPYVdXf2suPqxwfy10dHKUiv5O+PY7j68YHY2l+4n1ZnsT+1hMWrJVeBhyaFctPQgMZ1G9M38mfynygEBS+PeBmtqvkDbmh3V76cN5Bblh0gMOUHBJWI2GM8gnvTFzJRFMmKL+XkoQJSjxZSW9m07I5Ko8Dd34EeAzwIG+KFrV3zYzY7eDZfxn7J7pzd5Ax7HZ/9n0P831KUqdq2Iw7HxackBY7+AsP7g94HlKfMulbRSmZVJmarGRuVDQH6gOb5KDV24Bwg9VNTJJXS07XsilNpMJFZUoPZKiIIAu72Gl588mE0qoY+XQly8uXAsQNSdKhoYfG7TwOgwg5vvRuiKGK1iJQX1mI2Si+i9s42aB00rfp4OTjYk52dhdUqUl1WR22lkboaE1t37uCuO+9ucZuhQ4dy/PjxZsstFgvDhjX3QdVqtfz+++/Nlh84cIBFi1pOK7Nw4UIWLmz9BaMjkTVqHYihykRhphQt4t9TEtQsZWXkPPkUAE7dq3EZ7ALdx+GoVTMoUIqA2hyf365xNNfN5rtx0qkrePttKjZsOLVSoSAiSKolGn+4GovpEsu5VZRIsUJBERYEBEKcOscPy2i28v5mSZt255geONie9kPv5C9FoIkWyNzX4vbHd0hRUyfdDrG/eC8FNac0o9W7d5N29RzqkpIwObrwxIg7WNzralS+Zw+KsA0Npdt33+L92msINjZUb9tO+g03YDojmihsiPRGmHGsmNrK5k7rF4vkwirmL93P0Fc389JfJ1hxOIufDmTy7Z50Hl8Ry6CXN7Hwhy0klUrpYwZ7Db44iW7PpCGfWmUZIGn8zuZcXJpXzYo3D1GSU43OUcPsh/q3W0hrQOug4fJFfXFwtaW8sJZ1X8R22Tx5lQYTD/0SjSjClf19uXf8qaLqhTWFjYltb+t9G1EeUa32MyLYjc/nhHGdUjJDrtPNarK+rKCG1R8e5c/3ozmxM4faShMqtQI7Rw2OHlpUGgVmo5Xc5HJ2/pLEssd3sfmbE1QU1Tbpx1/vzxDvIYiIrKpOke5pY+V/px4ywMbnQTSBStvshTKvOo9aUy0KQUE3h26tJw23dQSHei1TWaaUcPwMymqMpBVJQppWrSTY3R4vR+1pQpqEWqnG086TUJdQfO19USskgdhMNekV6SSXplCcV4nZaEFQCDh56NDpbZoIaRqNhn379jUmvG1AoRBwcLHFyVOHQiEwduQEbppzK6a6truArFnTPGH82Xj99dfp06dPm9s3JLz18OjYF2hZUOtAMuNLoD4th52TjeSX9uKLmPPz0Tir8exfAVE3NqYgmBgupVjY3EbzZwNj/MaweqiCzYNsQBTJeexxamNPJfQL6OOBnaIYQ52KlKOXWM6tosTGQIJu+m7o1Bee2qIlfj2USWZJLW72NswbFtC8QeBI6TNtZ7NVtVXGxjqu5p7FiIisT5PC4iu3bCHzzruw1tSgGzSIoFUrSPPrSVpxDbuTz22qFAQBp9lXEPD9dyjd3ahLTCTtprmYck6F07t42+ER4IDVKpJ0sH1Cfmex+mgOMz/cydaEQqwi9OvmxEOTQnlkcih3julBiIc9dWYr/9Sbk93U3bFX2l2cRLdnUh9Q0D/nBGqFmtzqXDIqM1psmp9awcq3DlNVWoeTp46rHhuAV/cL863S6TVcfncf1LZKshPL2PXbyQvqr7N4cfUJskpr8XfR8uKs3o0PV1EUeW73c5TVlRHuEs5dfe86Z1/jjFvQCzWkWT2556ArO5IKEUWRIxsz+OnF/WSeKEGhEogY5cPM+6O4/b3RzH9jJDe9OIwF743hhsVDGHVtKK5+9ljMVuL35PHD4r3s/C0JQ/Up7dtVIVcB8Efyn1jD67Xe8e17WHdZ0ndLARIomrkNlNeVU2ooBcDPwQ+N8hwBFPZeUh5DRChNk4IM6impriOjpAYRESedhh4e9lIgyFlQCAqcbJ0IdemBty4ALHYIohJdtSNYBCyCBZO+Cou6eYHy4cOHk5qa2mqqDo2tCmcvO1RqBVaLZBZvj7DWmTQkvI2JienQfmVBrQPJqvdP8w+XtGkVf/1NxZq1oFTgMzAHhQrod+otYXxPSerel1pMpaH5BdsakW6RONk48eV4M+bBfRANBjLvvgtTviQ8KAKGEq6V8sac2Nm+fDkXnaIkEusDCTrLP81gsvDhZulhuGhcD3SaFjwAAkdJn6nbm62K352H1SziEeDAmH6SgPHHyT+oWL+BrHvvQzQasZ84Af+vv8LBx4sr+0sBAD/sa3tZKW1kJEE//4wmKAhzbi4Zt9yK+bSyJmFDpTfghL15be6zMxBFkZf+OsG9y49QbbQwtLsLWx4Zy6q7R3DfhBDuGR/CE5f1ZMODo1l9z0h8vaUSWDl5fjzy0Q8XJ9HtmbiFgY0jOmMNUY6SlqilKgUZJ4r5/b0jGKpNeAQ4cOWj/dG7NjfvnQ+uvvZMvq0XALFbs6SXvi7E+uN5/HooC0GAJddEYW9z6p75NfFXdmbvRKPQ8Nqo1075QLWGKDYGERz1uQaLqODeH4+w5psT7F5xEovZin+4M9c/O4RxN/bEP9ylic+fQiHg7GVHn3F+XPv0IK56bAC+Yc5YzSJHN2Wy/MV9pNZXhhnnPw47tR251bkc8arXzieukzL3X8qIIqyXLDX0uqJJWhOz1UxutWRVcde546A5ewQjIEWIOneTTKcWI5RlgShSVmMkq1TSVLrYafB31qJoZxoKF509PZz9cKz1QWXVYBWslNsWUGoqIaUshdTyVCqNlW1PkSGKKFUCTl52qG2UiNauJax1BrKg1kGIokhmnPQG4x/ugqWsjPxXXwXAbVIoWlcTBE8Ap26N23R3t6e7mx0mi8iOpHPXFmtAqVAyyncUVoXAltv7YRMSjKWwiOz770c0GsG3P+G6LYCVrPhSygtrz9lnl6CuCsozSaiv8Rnm3DkP7x/3ZZBXYcDb0ZbrB3druVFQvaCWcwTqTiU/FEWR4zslU2TESB8u7345GoUG9ZE4sh5+GMxm9NOm4ffuuyjqNYM3DJE0dhtO5JNf0fbM92ofH7r939eofXwwpqeTcettWMqlAJGQgZ4oFAIF6ZWU5Fw8J/SPt5zk651SxOSicT34/rYhBLk1jzgWBIHevnpsHKR6f7bmMPRF0QBUuvX9dxPdnolC0egjN0wpacfOFNQSD+Tx98cxmOss+Ic7M+vBfmjtOzbNQ2CkG73HSEL9P9/GYaztGpn0a4xmnv9D8ve5Y3QPBgWe8r/NqMjg7YNSUNP9/e+nh1OPFvtoQspWKEoAjT1TbnyYKB89I4sgba+kHR45J4QZ90Xh5HlubbogCHh1d2TWA1FMv7cvTp46asqNrPkkhk1LT0CdkondpDJSf9ekg60T1JZAZtsCRrosyZul3ya1HQy+o8mq/Op8LFYLNiob3LTNc3m2ikIFzoHSd0MpdRWFZNYLaW72Nvg6ac87V5ip0oRaBCtQKoBa4YbeRo8gCNSYasioyCC1PJUqYyu54MwGqMyFopOQFwO5R1EUnsBRlYdaJTYKa5dqJPy5kAW1DqK8oJbKEgMKlYBPiBOFH3yApbQUmx7dcXOvL0c0pLlJoEGr1l7z53BfyeF9Z/lh/D76CIWDA7XR0eS99hpo7ND7eeGvOQpA3K5LRKtWLGm5EmwkLUVnVCSoMZr5ZKs0zr3jQ7BtLZGiUzfpR0u0NKlSkJ1QSnlBLWpbJSGDPHG0cWSOMJBHVlgRzGYcpk7F5603EU4rdxLm5cCgQGcsVpFfDmS2a75qb2+6Lf2/RjNo9oMPIZrNaB00dOstOf0m7Ls4WrU/orN5e4Pk5/fSrF48OqUnqrNEO2ZWZpJbnYtKoWLFLTcyVpcGwLJMd9Yfv7iawcZ8alWSIHwg7wAmi4lj2eW8/+lhNnx9AqtFJEVr5eWKIhb9Es13e9PJK+/YklPDZvdA72ZLVUkdu1Z2DRPop1uTyasw4Oes5YGJp3xGzVYzT+58klpzLYO9BnNTRBvzoO3/QvqMugEbeydutXUi3KTCgkh1f0f6TvBvt0AgCAIBvVy59ulB9JvUDUGQ7ovlL+xjhEkKDNmQsQlTQ+3PhEvc/LnnY+mz/zwpcrmeKmMVZXVlAPjY+bQ/B6XGDhyk6Gd1dQ4a0YijVo23o+15C2m1VUZqqySLkc7ZBotCoNqgRGlxI8QpBFetK4IgUGuuJb0inYyKDOos9fVILSbJb64gXqpdaqwE0QqIYDGiMFbgSBoqhRHRKlJeUIvF0jV9PC8EWVDrIDLrzZ7e3R2xJCdQ+tPPAHjO6YdgqpCSqLaQFXtCvZ/aloQCLG1I5tfAUO+hAMSXxFPj6YjPW2+CIFC2/CfKVqwEn35E6CSn2bjduZfGxVuUhBFIVUmXZWdEfH6zO52iKiPdXHTMGXiOigeN5s9tjYuO15uSQwd7obFVYczKZsYnR9EZIS5AhcurixGUzYW/hui45fszzpla4Ew0AQF0+/JLBK2W6t27KXj7HeBUUEHi/rw2JYLsSA6ll/Lor5Ifxu0jg5g7LPCc2zSUjYpyjyLY3ZVxdmkAHDAHc/cPh/kjuvNKsJyTeh+58JwT6DV6Kk2VTPtsOa+9uRfV0TIE4LDGzApNHQXVRjaeyOfZ348x+q0tLNmYiKH+TV40maiNiaHkhx/IefppMu64g7RrryPlitmk33IL2Y88StGnn1Jz+DCiqbm7g8ZWxfh54QCc2JFDdkLpv3YIWiKzpIbPt6cA8Mzl4U1ebL6I+YKYwhjs1fa8POLltgkFJamQUF+JYvBCDq9PJ/NwIQiwys7IJyl5bGlDbsnWUGmUDL8qmCsfHYCzl46aCiMpPxuZlrIAQ5WJnV71Gr+GOVyK5J+A5H+kNBxD72xcbBWtjSZPF63Lefv3Wuw8qEaLApFARSH+zucvpJmMFipLJKHLztEGvd6msaReUVUd1XUiXnZehDqH4qKVNLWVxkqSS5MpKs9ALDghRaMigsYBHP3AvSd4REjPVAdvFAoBJ0UOSkxYzFbKC2r/9d/DzkYW1DqIBkHNr6czeS++BFYr+mmXYVdR/+Y25I4WzTsDA51xsFVRUm0kOrOszeO5ad0IdgpGRGR/3n4cxo7F7R4pjDjvhReoNXgSZHMArbqGmgoj6bGXQM6togSSNWrMAug1ejx1HVvPssJg4rNtkuntgYkhqM+i/QEgaLT0mbYDQPrRPyIFZ/Qa5YO1poasRYtQlJST46nm9StFNuVua7GrKb280NuqyCk3sDe1/efCtmdPfF57DYCSZcso+/13Avu4YqNTUVVaR3biv/dArzVaeOiXaIwWK1N6efLUtPA2bddY39N7CFQVoihLA6Bbn9FYrCIP/BzNzwdaduLvdHwHgKBAWZ6JusYfhVVJcJqV4XWSZtRugCv3PjKI9Q+OZuXdw3lkcih9/Z0wmq18uiGOx+5/n5i77idx+AjSrrmW/JdepnzFSqq3baf26FHq4uOp2bOXir/+ovD9D0i/4UYShwwl97nnMZxWHxHAN9S5MbHxjl+T2i3YdySv/B2H0WxleA9XpvQ6lX9qd/ZuPjsqlX56eujTeNu3MSv7/i8BEYInkpLpxN7fJSFwzHWhjBkjuSE8/OvRdrkItIRXd0eueXoQ/SZL2rVu+b259uhTbElWgEItVR4p6hoay3bToE0Ln3HKVIkUQGC0GFEpVHhozy/qUBRFskprSbe6Y0aJDXUoKnNbbZ+amkrPnj2prZVMpDExMURGRmIymbBYrCy4bSFDRvdlyqyx5BZJ1gRHrRoPB6ncXnZpDYaKKsSiUlwK6+heoiZz9X5GdB/KPTfcRW2JEkOFhuff/pbgQZPoNWgM+w7HgMpGinJ18ALPXijsXXFU5SJgpSC/kLFjxhEREUGfPn1YufLcufMMBgNXXnklISEhjBs3jqKic7siffXVV4SEhBAWFtZYxL0h6rOlXG0XgiyodQBWi7Xxzde5+AS10dEodDo85gyFkmSw0UPf61vcVq1UMDaswfzZvgi+Id6SuabhAeh2113YjxuHaDSS9eHfiHVWemq3AqfSSXRpTov4DHMJ6/Daaf+3M5XyWhM93O2YFdV6qaZGGjRquTFQW0r8nlysFhGPQD1ufvbkPP00dQkJKF1dyXp+PrW2AisSV7TYla1ayeV9pBQOqw6fn+ZIP3UKbndL5vO8557HnHKyMY/avxlUsGRjAunFNXjpbXlrTt8miZ1bw2K1sD9P8gsa5jMMsup9hNx78uI1I7hpaDdEER5fEcuyXamdOf0WsartKbKTzHoe+fZMP3E3vSulh/yYG8KYv6AvUd2cCfNyoH83Z+4ZH8Iv03xYbtnPDxte5q5/vkS9ZQPWykqUjo7YjRqF29134f3Ky/h99CH+X36Bzxuv4/HIwzhMmYLSyQlrTQ1lv/xC6sxZZNx2exOBbfDMIGx0Koqzqi6a68K+lGLWHc9DqRB4fkavxvsxrzqPJ3Y8gYjI1aFXM7379LZ1WFsGh78BoCz0LjYuOwFA5Fg/eo/x44nLehLhraek2sgDP0VjsYpYKiupjY6mYu1ayv/4g7LffqP877+p3rcfY1pai0mhG1CplQy/MpirHhuIzkOJzuSA557B/GV4hRqLIyReglq1ynyI/UX6PuxUQmGraKW0tgTBVIu7yg6l2SCl2WjnX3FpKRUV5VhNRsy2rmCqhbIMqClrcTpBQUFcffXVjcls7733XpYsWYJarWbFT6soKyvjwM4YXnzxhcYksgAetkq8TZUElOUiZqRhLsjHWlUFRiMCMHHECJa+8QaCCLEnEtiwZSvRv//OspdfZtGCBZjy8rAa61MTKZTg6IvKyQtHVS4KhcBTjz7P/p2H2bx5Mw888AAGw9kF/y+//JLQ0FCSkpKa7E9rFBcXs2TJEo4cOcKWLVt46KGHMJvNjVGfHY2c8LYDKMyowmiwoNEqsS57DwDXhQtQJ3wrNeg3t8WkqQ1M6OnB6qM5/BNfwGNT2+6XNcRrCD/E/dBY4FpQKPB58w3Srp6DMT2d7D0uhI/4iyNMI+NEMWUFNTh5dE66iw6hKOlU6agODiQorTby9Q5JAHhoUhjKNggX6L0b636Kqbs4vlPyBek1yofir76icu06UKnwe/89pob7syTrGw4XHCalLKVZHVaQck8t35/B2mN5vDir9zlD3FvC7Z57qD1+nOpt28l+6GFC3vya4ztyOHmkkNHXWxpLrnQW0ZlljcEDr17ZG73tOSL86okviae8rhx7tT29XHtBdP1brt8gFAqBl2b1RqtW8uWOVBavPkGtycpdY9vgmN4BFFbW8cDPR5hS1o0pooWxxTMQTQ4YlbVcviCK0DOE+pojRyj5v/+jctNmnOoj1SodnNng2Yc9Pr25+bbpXDMk8KxjilYrNQcPUvr9D1Ru2kT1rl2kzr4Sl5tuxO2ee9A6ODBoehA7f0li7x8pBA/wwEb37yXCFUWRtzckAHDdIH/CvKTIQZPFxKPbHqW0rpRwl3CeGPzE2bppyuFvwFiF1b03m7c6Ya6rwCfEiZFzpEhbW7WSD+b05rnnl9HvaCxHlz2OtuTsZlBBp8O2Z0+0ffpgN2I4uoEDUZyRSd4zSM/cZ0by6HtvEJQ6iPSSEH4UPmTkzp2EDRUR2vJb0FU4+LUUlek3uElKmypTFXYmgd7/N+mCuner/2vGrRvAJ0rSZJ3BU089RVRUFDY2Nri6ujJp0iTqas2s/ns1c668Dr2rLdNnTOeuu+/CUleHpaAQS3kZDU9Eq6DAbKPFzlGHYChCbWdGqQFlgBd5dWX8/P02pl95OTjo6B0WhsVsJjMuDm93d5QODijd3FDa2YGdGxqlmm5iIU6OA6ipNGLv4oiTkxMlJSX4+LSe63D16tW8++67AMydO5fBgwfz9tvNK/80sH79ei6//HLs7e2xt7cnMjKSAwcOtJhMtyOQNWodQIPZyd22EnN2FioPD1xG+EkmM6VNEz+ClhgT6o5CgPi8SrLL2h6hOdBrIEpBSUZlBrlVknpa6eCA30cfIuh01ORrMJ6opluAGUQp7L/LYjFD8UkSTyvG3pF8sSOFyjoz4d56LuvdDrV0ffRn1oHjVBTWorFV4l2XROES6ab2euZpdAMH4mnnyVi/sQD8GP9ji10NDHDGz1lLVZ2Zje3UnjYgKBT4vPYaKnd3jMnJCMs/Qu9mi7nOQkp05+bMM1msPPbbUawizO7ny/iebTdN78mVAjIGeQ1CpVBBVn2ATf3DRhAEnpoWzn0TJK3WG+viWbIxse0h++fJgbQSpn+4g91JxWTUTmZl8WuIJgeqtaWs7P0ueW6SqVy0WqncvJm0G24k/fobqNy4CUQRuzGj8fvkE/rt3ErF/Ls47hLEY6uOs/ro2bVggkKB3eDB+H3wPj02rMdh0kSwWCj55ltSZ19JbWwsvcf44uylw1Bl4sCatE49DmeyLbGQA2ml2KgUjedEFEVe3vcy0YXROKgdeGfMO9gomz+4W8RshL2SqfSw7aPkpVSgsVUyYX44CqUCS3k5RZ9/gfXamTy74wump+5pFNJUHh5oBwzAbsQI7MeORTdoEJrAQARbW8SaGmoPH6Zk2TIyFywkcchQMhYupPTXXzEXn3IxUGmUhE52ZmXkO9Q6llAnOrA55TJ+fXUvWV0sFUqrWC1w+Dvp+2nPlJLaEqpNnRz5LVqk6gUtpDXR6XQ88cQTLF68mCVLlmC1WKksriUvP4/A7t3QaFVgteLi6EjOgQMc3reXIVdfzdBrrmHIddcz4JprGTprBvPuuBWl0ohCpQJbBzQObvi5dqeopByHAA/S9UbKu7ngHxhIXqUUiW+prMSYmkpdaiqW6mqwdcTWSY+dQjqnu7btadR0nY2cnBx8faUXMr1eT2VlZZvbA/j5+TUpBN/RyBq1DiCr3uxpH/sPAG6L7kax/WVp5ZA7mqTkaAlnOw39uzlzML2ULfEFTcqynA0HjQO93HoRUxjD3ty9zA6R6ofahITg8+orZD/wICXx9oREbSeD8cTtzmXIjO7SjdPVKEtHtBibmD47isLKOpbtSgPg4UmhbTLVNRI0Gg7+H8dPSBm2gyPsKHj8bhBFnObMwenaaxub3hh+I/9k/sOfyX9yb797cbRpmghVEARm9/Plw39OsupwFjP7nl82e5WLCz5vvUXGLbdQ/ttvBN4xkpgiNQn78hoDDDqD5fszSMyvwtVOw3PTI9q1bYN5fqj3UEkob0h0e1pFAkEQeGhSKFq1kjfWxfPB5iRqjWaemhbe4WZwURT5emcqr62Nx80It5i1OBuCsQI9bHezb7qFsqx8DqTuoPf2LEq/+x5jqqRJFNRq9DNn4Hrrrdj0OKX1e+OqPmjVSr7Zk84jvx4lwFVHHz+nc85F4+eH34cfUrVzF3nPP48pK4u0G27E85GHGXH15fz1UQyxW7PoO94fB5dzlD4qSZX8wI4uB3NdfRSfJ/S/GfrdBOpz530TRZF36qN55w0LwFMvjflD3A+sTFqJQlDwxug38Nc3L4fWKsdXQmUOheqBHDgkJVYddW0o9g5Kij77jOIvvsRaUwOA0s2NY4F9Wa4KpDioJysemYyzXfNUKKLFgjEtDcPx49QcOEDVrl2Yc3Kp3r6D6u07yHt+MboBA3CYNBGHiROZHDiZT45+wo8Rr/FR6jiO54+hMAv+eC8a7x6O9J3oT1Bf9/b9PvybJG+ByhzQOkPPU+bm35J+o5fQCxtbJ8Qns8/rXskqraW0xohGqaCHhx2q0/2pLUYp8tJskD6dA6S8a6exYcMGXF1dOXnyJC72nlgtIiCiddBgqaiQEnabzQhAv4EDiT5ypFHzWVxciJMhG6UgIqq0UgWJ+sAUhaBAp9LhZOMkta0roU6woPHxwSYkBHNRMZayUqzV1RhTU1HqHVF5eaKzq6EoO4P7Hrmbd177AJPRgvosFoz2vhC21L6jf6NOR9aoXSAWs5Xck2UAOOYeRdO9O07da6EwTsrZM+qhNvUzrj5NR3sjnoZ4SX5qDfUTG9BPnYrLNCk3lLhiJY4uKkwGC/F7W3cMvagUJZGvVFKuVKAUlG3Lx9RGPt5yklqThb7+TkwIb6eTbdAYqi3OpJZLDvPOaz7CWlmJNioKz2efaXJzDvIaRKhzKLXmWlYlrWqxu9n9pLew7UlFFFbWnd8OAXZDh+B6p5Q/yf5XqY5sVlwJVaXn3+fZqKoz8/4mqfTTAxNDWnxwtobBbOBI/hGg3j8t/5iU6NbWEdyaa07vGtuDxTMkQfDLHak8+8exDnWorzSYuPuHw3zyZzyTK1XMq7LF1QBqGyXjPb5hiuNbDK9TMnezhXH3/kj+iy9hTE1F4eCA64IF9Ni8CZ9XXmkipIH0Q/3cjF6MC3OnzmxlwbcH2+UUbz9yBEGrVuIwaRKYTOS/9jqqH9/FN8QRq1nk4N9n8d0zG+GPe+CDfrD3YylXmKkaqgsgLxbWPALv9pYSzZ7jobT+eB6x2eXYaZTcNVYyS+7M3slbB98C4OEBDzPKb1Sb9wtRhN0fYRUVbKl+EKtVpHuUO77mZFJmzKDwvfex1tRgExaGzxuvE/LPZqZ8/R5FvQeSUivw6G8xLT8YlUpsevTAceZMvF96ieDNm+n+12rcH3gA2169wGql5sAB8l99jZPjJ6C4/QluO+yEe3EdBVEF3OR+N5HdklAoBXKTy1n3+TG+e3o3O39NIje5/KIGcbTIkXptWp9rG02QxbXFbEiTSgi62Loi2NhLwnk7/srMakpMKlDr8PN0Q2Xr0LSN1hlcugMCGEqhqqk/7LZt28jOzmbt2rU8+OCDVJVLVqFuAX5kxBzFmJGB1WSiuLwcr759iSsro/+wYURFRRHVJ5IJo0cyYPK1XLPoOTIVvohnlLry8/OjsqgSH3vpxTYrOwvBUUDQaND4SgKb0lkqx2ipKKcuKYnaaiW33r2AexYsZGD/wVLajrOUZvP19W3UiFVWVuLgcPYkwae3B8jOzsbbu40BNeeBLKhdIPlpFZiNVtSmKuyqc/G4726EbVJ0HmMeky7yNtAgQOxKLmoM9W8LDWk69uXua/Zj5vHAPeg868Ak4pPwNwAxW7K6ZuhyUUJjRYIgx6C2m1TOQWpRNd/vlSoCPDr5PAIUdC7Ea+ZiRYWzJReb+H2oPDzw/eD9xoS2DQiCwI3hUuWJ5fHLMVubJyzt7m5PX38nLFbxnOaxVilOhvQ9uF87FW1UH2xLMnA25SKKUqqOzuCL7SkUVxsJcrPjutaSBLfC4YLDGK1GPHWeBOoDIau+vqfvwFYT3c4fEcQbV0UiCPD93gwWfHuQinZU72iNg/GFLHptJw57S7it0pbeJkm7HDbEi+uf6o+fspisnc74PfwjM/aLaA1WlP5+eD79NMFbtuDx8EOoz1LHT6kQ+OD6foR42JNfUcfdPxzG3I7UOEq9Ht8P3sfzqadAoaBi5UoCT0ipfuL25FGWX9N8I2MN/HR9/YNchOBJcONvcN8RuHMXXPaWpNWvKYK1j8Fvt7RYzxHAahVZslHSpt02MggXOw3Hi4/z8NaHsYpWZgfPZm7E3DbvDwBJGyE/luN1Mygs0aHRKgnPX0vWggWY0jNQurvh89abBP2+CsdZsxA0GuxsVHx4fT80SgWb4vL5ZnfaOYcRBAGb4GDc7ryDoBW/Ebx5E55PPYlu4EAQBAzHjjFlfRHvfWHBfUkMlcdEBpW/xdwXhzDgsgBs7KQI6qObM1n51iG+fHA7q945zM5fkji6OZOThwrIjC8h92QZ+WkV5KWUk3uyjOzEUjLjS8g4UUxabBGpRwtJiyki52QZxTlVGA0dkLi4ulgqKA+SZrSeH+J+wGgxolaqzysdh9FsaXS3cdfbYmfTirXFxh4c6019lXlQJSkULBYLDzzwAO+//z59+/RlQNRgln3/Nba2Ci4bNJDlv/wCCGyKiWHo8OGoHByIiooi+sgRonesJXrdt0Rv/ImD29fx3EffUWawUHnG8Zo+fTo//fQTerWe8oxyBEHA1tmWgpoCevbsiUKjQePri01wMAo7OxBFFj34IP169mbhleNRYsRqsVJeWMsTTzzBqlXNX6KnT5/O999/D8B3333H5ZdfDsD+/fuZN29es/aTJ09mzZo1VFdXk5ubS0xMDIMHd14ZvC5oA7u0aIz2LE1E2ycS+7IfpTcOpwAYdHub+wnzdMDH0ZaccgN7kosbNWznoq9HX2yUNhTVFpFSntJEEyV498F3RAVp651xj19PkttYygsg/VgxgX3akbH6HJgtVrYmFLL2WB6VBhNmq4idjYpxYe5M6OmJY1ucoIsSie8Es+fra+MwW0XGhrkzMqT9+yxaRU6USQ6iXkmbEDQa/D78oNWH9bSgabx76F1yqnPYmrmViQETm7W5sp8vRzPLWHUkm1tHBrV9MtmHYfvbUC90C4Cvv5KUBF88Uv6hNOxG4vfm1ack6Dg1fEGlga92SGkUHp0Sdu60JmdwutlTEIRTWeHPUd/z2kHd0GlUPPLrUTbHF3DFR7v4/Kb+eNtoqCw2YKyzYDZasFpEBEFAoRAQFEjO4aKUw8lUZ6G6rI6yghoSEkoQykxIOmglCBDQ05EIjyJsY38gZ+ZmrOXlgBYQSQ6x55eoGubMu4fQkFlnnevpONiq+frmQVz+wQ4OpZfy+fYUFo0LPveG9QiCgMu8uai7+ZP90MPY7FqN+7CeFNoEsv+v1MZSUwAYyuGHayBzL6h1cO13EHzGNefVGwbeCge+gg1Pw/FVUJgIN/zUzC1j/fE8EvOrcLBVcduo7mRUZHD3prupMdcwxHsIzw59tn3XlijCFinKcl+19BITnLeZ2rW/AuB80024P3A/SvvmwVa9fR15alpPFq8+watr4hkY6EJv37bXVVX7+uIybx4u8+ZhLiqi8p9/yF/7J6Z9h3ApqKO4wIHiE6DaM4Vuw0bQo38UxQ4hZOSrST9RhrHWTE5SGTlJZW3f31awd7bB1dcev57OBPR2xclT177jGPsLWE3gHQVekQBUGCtYHr8cB8EBB7VDu+95URTJKKnFYhXRaVR4Opzj5djOXfJRq8yFimwQlHzyfz8yaNAg+vfvT1WpgccfeoZpsycwd+IILhsxgrVbthA5ayaOTk789NNP9QNbJRNqbb1voJ0HKr0PHpV15FUYKK6qw3qa0qFPnz5MmDCBsLAwbGxsePcTyT/4ZPbJJi/DCltbNIGBxOzdy7IVK4gMDWXDjh0gwCcfLiM0JILowzHMnDmz2a4tWLCA66+/npCQEHx9ffn1V+n6zMzMRKtt7i7g5ubG/fffT1RUFIIg8Pbbb6NSdZ441eUFtcLCQubPn8+WLVvw9/fnk08+YcKECRd7Wo1kxkpO4c5lCbjP0iPE/yLVS5v9WYsRMq0hCALjenrww74M/okvaLOgZqO0oa97X/bn7edQ/qGmJkO1LSr/nviPjiNtuwM+mdvJ6DaJQ+vSCIh0veCHucUq8sX2FJbuSqWgBTPe6qM5qBQCl/fx5onLeuLteBb/mE6I+NyXUsz64/koBNqc6+tMMuJKqKi2RWWuwaPgEF4vPY+2b99W29uqbJkTOocvY7/km+PfMKHbhGbHeUZfH1766wSx2eWcLKgk2OMctfisVqmu375P6xcI9RqSEtRU4j2ggLq9R0gKuYbS3GqKMqtw79aG+n5t5KN/TlJjtBDl79S+QIx69uZIgtown/qIqIbUHH4Dz7nt9EhvXAzw3co43FLN/L34AGrO77pt3EqoJlidj1/GFhTboqmzWmm4elUuTujds3CK0LD2qus5cnwp/vn7mdEOQQ2gm6uOF2b14qFfjvLuxkTGhLq3S8gAcBg7loBvvyXzjjsIjF1O4cAnSTqYz4CpAbj62ktC0B/3SEKarSPc8Ct0G9JyZ0qV5IDu3Rd+vRkKjsOyy2H+GnCSfM1EUeSDf6TcYrcMD8QolnHnpjspMZQQ7hLOe2PfO3cdzzNJWAO50eypfpA6kxqH6mw8j/yG0tUVn9dexX706LNufvPwQHaeLGZTXD73Lj/C6ntHNqkz2lZUbm44X3MNztdcww0/X4H+UBK3JNrimFSFuaCI8j/+gD/+AMBfEAjy8aXOL4IK5+5UadypFW2ptdpgFpVYRQUWUYFCAEEQERBP+y59iqKAyaKgzqzAaBKoKq2jqrSO9GPF7PrtJM7edvQZ60voEClx9lkRxVNBBKdp036O/5kqUxW93Hph045nTQP5FXXUGM0oFQLdXNpYHsreUxLWqgugPIN7b74KHO7BZLRQU2HE1cWVmHUbUZlrUTo68tXy5U0TgJtqoTQdzPVBc47+YCe9QLs72FBpMGMFauosiKLYOKfFixezePHixm4KawrZsWkHc+bPoaKuAr2NHpCeo32HDcNqsWAuLsZcWAhWKxalhhpEzCYzkT37N9strVbL77//3mz5gQMHWLRoUYuHYuHChSxcuPDcx6wD6PKC2qJFi/Dx8aGoqIgNGzYwZ84ckpOTcXZum0mxMzEbLeSnVQEKvPQl2JVskp4Gsz6GgOHt7m9C+ClB7cXTLtJz0d+zP/vz9nO44DDXhF3TdKV3X2zyY/FbMILaL3aQ5TeWvJQKsuJLG4vHnw9FVXXc/9MRdp2UIqtc7DTM7udLd3c71AoFmaU1jW/nf0TnsPFEPveMD2bBqO7NNTKiCIUJJNYXuO4IQc1qFXn57zgArhvcjVDP8xNcjq6W+vDO3Yt7aClO/d3Puc31Pa/nm+PfEF0YzYG8Awz2bqo5crHTMDbMnU1xBaw8nH32lCxWK/z9IBxaBgiSf8qoh8G93rcrbRf63+/EI68It6KjFHgM5MQ/KYyZ37ow2R7yKwz8tF9KVPnY1PabjksNpcSVSMewIdEtpWnSSt/WBTWLxUrivjwO/3WSshIzkdIjUFopWtHUlaG21qESTSiwID0uBUQUSI9LEYXFiMJch21dGdraInS1BTiVnURjahrRpenRA/uRI7EfOwZd/74IbwaCpYJh9oEsRRI0xXbcjw3M7ufLprh81sTm8cDP0fx178jWS5a1grZ3LwK+WQbzb8Gj4DAFHv3ZvyqRy+7pD0e+h7g/pQSuc1dJSXvPRcAwWLAFvpkuRfF9M10S1hx92RRXQFxuBXYaJbMHOnL7htvJrMzE196XTyZ+gr2m9RRDLWK1wpZXyTOGEF8jCWShCT+iG9gfv3ffReV+7ntJEATeuroP0z7YQWpRNc/9fowl10a1bx5nMDZ8Gh8aPoQhPnxyZDs11khqva6hNjoaQ1w8ltJSzNlZKLOzcAYu9EljUumo1nlRoQ+gxC2SUscelOZWs215IntWJBI1KYB+UwJRtebsnhcjCdZKG4i8GpD8Pr87IQlvV4VehWBu37VZZTBTUCn5T/o6adGo2nhdCgLo64OgqgugKh/RWENlnRQBrjLVoLIYUHt7o3RxOXXPiFaoLoKKHEAEQSkl67XVn9a1gL+LFhuNhiOHD3D1tdez4pefWpyGm9aNmdNnUmooJbsqGxulTRNhVVAoULu7o3RywpyTCZU1aGuL+XHZb9RWGlEqBXSO5xZuz5VP7UxycnKYNm0aHmdxjzgfurSgVlVVxR9//EFaWho6nY4rrriCJUuWsHr16hbtxv82WRu3YUWBpq6MQO/tUiDMuKehzzXn3LYlhnV3w0alILusloT8Snp66c+9ETDAU/qBPpx/uPlKnyiI/h47hzyCXnic9C92k+U7ht2fbeea92adl1btWHY5t39zkLwKA1q1kudnRHBlfz80qqYC2MOTw4jNKmfx6uMcSi/lzXUJbI0v5KMb++HhcFr0WnURNXXlpKslYSrU5cJTc/x8MJPY7HLsbVQ8OPH8+itJzCYztQ4EgWDNUTwiKyR/m6CzawHcde5cFXoVy+OX81nMZ80ENYDZ/fzYFFfAH9E5PDI5rOVIM6sVVt8rPZAFBcz6BKLOSJwcOALu2o2H60L8v91NgcdAEvdkMeKGCFSaC8+79eX2FIwWKwMDnBnW3fXcG5xBQ5BLiHOIVCC6wc/GvSdonZq1t1RVkfjzNvYesFKDVNxdaa7FtSQO15LjOJYnY2soRiG2vySaYO+AJtgPjZ8fmh7d0UZGYts7ErXnGT+qPv0gcy/9airRKDQU1BaQWp7aYm68s44nCLxyRSQH0ko5WVDFB5uT2pUnsQGb4GACvv2GqoWPUeDRn5TYUgr27sdj8+NSg/FPt01Ia8DRF27+C5ZNk4Tmb6Yj3rKOD/+RgkWuGeLKIzsXkVKegofOgy8nf9m+4t4NxP2BNfcY2/LeAA145e6h2+QBeD/3HMIZ/p1nw9lOw/vX9eO6L/aw8kg2w4PduHrAOcq/nYXJAZP58MiH7KvOpEKjwMl6DPvb/wTdfQCYS0owpqRgys3DnJ+HuaQU0WDAWmegsryagqJyyitqqDFaqDFbsaJAFAQQBOy1apx0Nrjq1LjbAEYjlopytCWlOOXvpFvWFsxKW3K9hpLlO4ZaPNj/dzqxf59gYB+RXjeNRak/43f/WH0S7bCpjT7P69LWUVpXio+dD6N8R5GZ3vYawmaLlcxSydfRRafBSdf2cwFIwpqjrxRBXJZJdZUSsyAiiFa05go0gYFSXjNRlIJcDKXSC5q13sfUxkFyDWpBO6tRKZk2cSx9dh+V6n8azWg1zcUUQRDwsvOizlInFXWvzKC7Y3eUZwQiKNRqNAHdseQmoiirxlqnos7GiaqyOsQ6Azp3fYe6ifxPJrxNSkrC0dGxSTRF3759OX78eLO2dXV11NWdMr9VVFR0+vxOrtoNquG4G+Kw7+cPQ+9ql1/amWg1SkYGu7E5voBNJ/LbLKj1ceuDSlCRW51LTlVOY3QMIPk0AORE43jjrwwoM5K9w0xRnZ7jL31Gr2fvbNeFml5czfyl+ymqMtLD3Y7PbhpAyFm0VZF+jvx25zBWHs5m8Z/H2Z9WwvQPdvLJjf0ZGFiv0StK5KRGjSgIuNq6nt9D4TTyyg28Wq9Ne2BiCO7n8r1oAavRyL7XfgWbPrjVphL2xLUIa7dLgtrkl865/a29b+W3xN84kHeAg3kHGejVVHs0IdwDB1sV2WW17E8rYWhLQtDuD04JabO/gD5zWh7MxgHFtV/TN2MSscnlGDWOHH/nB/o+Ob/d+306JdVGftgnlXRaND74vH7QGsyeDUEvjf5pfoOatKuNjSV/6fccSXEgx0vSRmuMFXTL3U4P1zLsevujCRiF2nsOdVp7NmVUsyGxiLQSg6RJE0BEwCpID00rAk52NkyK8GTW8BC6B3khtNWHxH8wZO7FNvsw/T37szd3L3ty97RbUANJyHjlit4s/O4QX2xP4Yp+vuel3bXp3p1eX75F8tN/U6CPYOd725gZWIsqbCQMv6/d/TUR1kpSqPp6Fql5D2NrI3DU/CZJZYm4ad34evLX+Du0Iw1HAyYD4oYXOBwzhiKvUBQWI4Mv88f7jrnndR0NDnLhwYmhvLMxkadXxdLNRcfgoPOzCAQ6BhLmHEZCaQL/ePXgypwkqXZmvbZK5eKCyuVU3waThZWHs/l2Txrxlkpoo2LRxU7D1QP8mDcsAD9nHaLFgik3F2NqGt5xcfQ8upPUVAtJHhOptXVmRwwk3vIZA7xzcb9mNnYjR0rH6li983vvqxr7/jleCjCZEzZHykvYRhpKRJksVmxUSrydzp2updW+tM4YSw2NL1S2plJs7KtRlCdBtUZKwyOeFhinUEsln3SuzdJ7nI6zTk1FrZoKg4nM0lqC3e1bfJFVCAr8HPxIKUvBaDGSXZWNv4N/i9eX0tUPhTUBZV0pokmFUW1Pda2ANSULrYs9SkdHhFYCm7oCXVpQq6qqQn/G24Ver6esrKxZ29dee40XXnjhX5qZRMgVQzH9tofAiT3g1kNnvfjayuRenmyOL2DDiXzuGR/Spm10ah3hruHEFsVyKP9QU0HNMwIQ6tXUBfjNvYoeKX9xMldFzDErzo8/jvfLLzeLYGyJoqo65v2fJKT18tHz08KhOLQhM70gCFw1wI9+3Zy447tDJBVUccOX+3hrTh+plFNRwin/tAsMJBBFkWd+j6WyzkxffyduGdEOZ/2GPqxWsp59gQyFJFz0v2koykhvWKeQ0q6UZ0nFgc+Cl50Xs4Nn80viL3we83kzQc1WreTySG9+OpDJqsPZzQW1zAPwT71AePk7rQtpDWh0aO/6ju5PfEE8k0k4WEzIwYNSxNt5snRXKrUmC7199YwNPbeZ6kxEUWRPjpTodph3g39afcRnfSBB9d69FH74ESXH0zja525q6mvkhbgUMezKUOz7Xo6gbn6NXQ9cJ4rEZpcTk1VOVmkt+RUGnHUaurloCfF0YEiQC6p2Bj5Ic6v388rcz9BRt7M3dy97c/Y2RvS2l8m9vJgU4cnGE/k8vSqWnxcOO69cXTZBQYy8fxIrl2aT69iP47sj6bXgNVSK9plTG3Hyh7m/I/7fFBzK4nhH+xYv9XAlqSwLF1sXvpr8FYGOgefVtXXzG2SuriTWV8ozGB4i4n/nhVlB7h4XzNGsMjbFFXDbNwf49c5hbX6ZPZMpgVNIKE1gvd6RK3OQXsDqBbUGaoxmvt6Ryv/tSqW0RtIGqRQCw3q4MjHck3BvPYFuOhy1agwmKxW1Jo5mlXEwrZR1x/LIqzDwxfYUlu1O45YRgdw9NhhHP0mjaz9qJAD+Viv9j57gwMoTxBe4kO8+kH+qiun1yGu4uylwmT4ax+JMFDp7CJkMwLGiYxwrPoZaoebKkCvbtd8l1UYqDCYEQfJLa1OFlhawmkyYMjOpEu1BJaDCjL2zGcEouR1gblCaCKC2BZ076Jwb86OdDUEQ8HPWkphvwWCykFdhwKcVgVKtUOPv4E9aRRqVxkpKDCW4alt46dXoELTOqIRSHNU1VBi11JmV1KocEfOL0RQUoHR2RunsjKKF35uLTdcVIQF7e/tmmrGKigrsW4gQevLJJykvL2/8y8xsuyr4fAmYPpHLlj1N+G3XdYiQBjC+pyeCADFZ5eS0o0pBo/mz4Azzp8YOXOsDDPJiARi2aAKCIFLqEk7ajiQyb70Nc+nZi3obTBZuW3aA9OIa/F20LL1lUJuEtNPp7m7P74tGMLWXF0aLlft/iubTrcmIhafV+LxA/7S/YnLZFFeAWinw5lV92v1DJIoiBW+8SdK+XMxqO+ztoceECNC5nErOmri+TX3dFnkbKkHF3ty9LZqlG3KqrYnNbZqSpbYMVtwKVjP0uhIG3NK2ybt0p++8cQAUufYm7ZEnz3leW6PCYGJZfUqERWPPT5uWVZlFTnUOKoVKuj4tJilyFTDUeZCxYCEZ82+hIKGAQ/0foUbnhZ29glkPRDH51WtwGBjVopDWgCAI9PFz4qahATxxWU/evTaK52ZEMH9EECOC3c5PSINT0agFcQxz7Q3AgfwDmBpMN+fB4pm90GmUHEgr5ddD5//b5N0/gACbGBAUnHS5jPT7n2qSgb/duPYgevT/kayw4yOfCsosWbhr3Vg6Zel55zK0pBwi4+XvOCmOpcbOG40Ght3TPPq5vSgVAh9e35+BAc5UGszM+3o/6cXnl5F/cqAk9OyrK6JUoYCTmyRXA6QKHN/vTWfMW1t5Z2MipTUm/Jy1PHN5OIeemcR3tw3h5uGBDA5ywcPBFhuVEketGn8XHdP7+LB4Zi92Pj6OL+YOYEiQC0azlc+3pTD2rS2sOpLVJI2SoFDg0K8341+6hisfH4SDXonB1pXDUQ+SXu1G3gfLSPrTk4K0cEwl0rNwefxyAKYGTsXFtu1axVqjmdxyyS/NS2/bokmxLViqqjCeTKbOKGBRSS4seh9HBLcQKVjFIwJcekjuDd59pE871zYJaQ2olAr8nCXhrKiqjora1u89nVqHp07ykcuvycdgbiV3od4bEBBMlehdldjqpP03aF2pwxZzQQF1CQnUpaVhLi4+VUu0C9BhgprZbObWW2/tqO4ACAkJoby8nLy8U7mhjh49Sq9evZq1tbGxQa/XN/m7FHF3sGFAN8kPYVM7ygz195AiWQ7lH2q+0lN62JB/DAC9m5bIcZI5Iyn0GqoOHSZl5kwqt2xptf+31idwNKscZ52ab24Z3NTHrB3Y2aj45Mb+3FafluKNdfEknTjcIRUJUouqeXqVJIwuGhfcWJ+wPRR//jnF33xDVn05qMjJPU5pP3pOkz6Pt5zM9kx87H24IuQKAN4++DbWM/yqBgW64OukpbLOzOa40xId//2QVAjZKQBmvNeulwC3kVNw1RUhKtRkK4LIffKp8yrD9NP+DCoNZnq42zGl1/lVO2goG9XXva+U4yn/GNZaA/kx7qTe9jDVO3ZQ6hLGkUGPYtTocfW1Z84zw/Dref5BLh2CvQc4BwEiPavLcbJxotpUzbGiY+fdpa+TttFX8rW18ZRWn+dDYP8XDLaXCpvneQ6iLLuCjFtuPW+BXBRFXoiuYI53IKkaNV5mM8uUAXTXB55Xf6a8PNLn3UJViR0pQVL2/MGzQjqsTqlWo+TrmwcR5ulAQWUdV326m5issnb3E6APINwlHAtWNuudoaYIMecIa2Jzmfzudp75/RiFlXX4u2h5/7ootj4ylttHdW9bqiEkQWNyLy9+WjiU/5s/kGAPe0prTDz481EWfHuIghYSIXt1d+S6F0bQPcodUaEiLvxmUsNmYjEqKd6eTfLESaQ9/QSHDq8B4Nqe1zbrozVMFitpxTVYRRG9rRo3+3b6pSFdK6b8fIxpaVitVupspeeUnZMNqoYgGUGQsh3Y6iUftnYIZ2ei16pxs5fcVrJKazCeJWGti60L9hp7ybRbldXstxaQ5lUfYSpU5eHgpkXrIB2HOltnjPaS1cBaVYUpN5e6xETqUlI6vYxdW+gwQc1isfDNN990VHeApFGbOXMmzz//PLW1tfz5558cO3aMGTNmdOg4XY1JEdLbwcYTbRfU+nn0AyC1PJUSwxm167zqBbW8Uw+awdODsLVXU631JK/PbCyFRWTddTc5jz+B6YyaZTuSChsLcb9zTV+6u7cz+usMFAqBZ6dH8Nz0CAQBbCuSG5Pdnq9GrcJg4vZvDlBhMNO/mxN3j2173iqQfoSKvviSwvfep8Qlgip7P1Q2SiJGnGZG7lVvZkjbCRVtq/CwKGoROpWO2KJY1qSuabJOoRC4op/U/6oj9cc8cYPkPCwo4eqlUtqFdtJztKQJyfMaTNXWrRR//kW7tjdZrCytL7l1x+ge511Sp0nZKKDq719JXutOyQm1FDI/6RqODbwfs6jEN8yZ2Y/0x86pYxIdXzD15k9F1kEpWhUazbjnyy0jAunp5UBZjakxqWy7qC2FHe/goU4hoJsBBAUZobOoS0w8b2HtzxOxJCnewKSpxFvjzLK8IrrFroKNz56zgsGZ1KWmkn7VDOqKTGQHjcWoccTB1Zbeo33PuW17cNSp+e62wUR46ymqMnLt53v5J779tXMbtGobXKXf2+U/fs3dPxwmtagaVzsNL8zsxeaHxjIryve8tbOCIDC+pydr7x/FI5NDUSsFNsXlM/m97aw/3jw5tUarYurC3gy4TCojmOo9hYyx12EzYACiyUTtij94+1MDT623J6zcrk1zsIoiGcU1jX5p/m1NxXF6H3V1GFNTpXQXgNHBE1FQkJ2bwYAhfamtlaw/MTExREZGYjKZEEWRO++8k+DgYAYOHEhycnKbxtq6dSvOzs7ceOONeDnaUpqfw42zJuNgr+PTTz9tcRtBEPCx90GpUJJfkM+YcWOIiIigT58+rFy58lRDew9AAGM1grEKe2cb7JxsMBgM3HDn7fSecQWX3XEnJQZJkBZU6laP1VdffUVISAhhYWH89ddfgBT1GRUVhZdXx5bya9fVN23atFb/Wkoi1xF88sknZGZm4urqyiOPPMIvv/zSJVJzdCaT6zUYe5KLKT+Lyvd0nGydCHaShJOGcj2NeEoJEhs0agA2OjVDZ0nO0Sk+k7C7eSEIAuV//MHJ/2fvruOrqv8Hjr/OrXUn2xgDNjYWMLpbQEoxEBQLA2zUr/2zv9ZXEcVuMFBsFAQp6W7GNgYb6+7e3Y3z++Nsg7lggzWf5+OxB+Oec8/5nN1630+831OvJO3ZZ6mIjiavRM9jPx8H4Obhvk0uxG0uLaUi5jTF//xD3jffkPHaa6Q8/AjJ9z9A0qJFpDz4IFf+/SWrjHsxJlTgmyphW67GQm56oe9qJrPM4h+OEpddSjcHSz65ZVCdFaiNkWWZrLeWkL1UKcWUNvx2AEJGe2Fpc943aMfu0H04IDe5V83VypW7wpQFJu8efpdyY+3h7NnhyofYtpgs8gsKYN1/lA3D7wWfZqzkO0/AhFAkyUyRfS/KrNzJfvddirdsafL9/zqRTnphBa62Flw94OLqkZrMJvanKys+RzgPJP2ll0h++3eMZRq0rrbYv/0pByyvwFAp493HkZkP9MOiI9WgrR7+TN5fE2heaqCmUat4YZYyGrByfyJRac1c8LR7GVQUgHswg+cqc/7SnQdQ2c0f/alTJN15J6bCwiYfLqkoiRcPPoBKV4CNypNvrvoJ7xnvKRv3fgDrHq+3CHd9yk9Gkjh3DobcEmRHSxKretOGz+6FWtvyM2zc7S356Z4RjAlwpdxg4o4Vh3j6t4gmv1+CsvoTYJ+plDyVir4l+7HWqVk8KYDtT0zgtpF+zXofaYxWreKBiQGseXA0IV72FJQZWPTtYZ7+LYKyytqZ+CWVxPCrezMp/DgSJuIYzelxT+G14muiAyxRyxB+pID4WVeR8tBi9LFK7jtZlikzlNX6Ka0sJS47j9zyYgzmCtwdJPSmijr7NfRTqi+hKD2JijNnMJeVKRPuPXyolJX3xdABfbn++utr0lg8+OCDLF26FK1Wy9q1aykoKCA2NpaXXnqJJ598ssl/r6lTp7Jy5UpUkkSQrwdPPP8at959f6OPr1alxdvWG0klcf//3c+h44fYsmULDz/8MBVVgRdqnbKYAaA4A0mSsHGw4Ne139O7VwB7tx3hymnX8NY3K9H2CUTz7xXhVXJzc1m6dClHjx5l69atPProozXF39t91eeOHTt45plnalWNr1ZZWcnmzZtbrGHV3NzcWLdu3YV37EJ6utoQ4G7LmawStsVkKRPum2CQxyBiC2I5lHmIST3OSwpc3aOWHQOGCmVyJ9B3lBcnd6SSk1zCKfcpjP5+PNnvvUfZ3n0U/vIrhb/8SpGDK9c696HU24+HXZ3RnzkDag2SSsJUVIQpPx9DRiaGlBQMqSlUpqRiSEnBlJdXTwvrsgf02PPyfhNgImr51WSNGkafWVOwGTXqgoscyitN/OfnY2yNycZCo+KzWwY3a1jWXFFBxgsvKgkvAfV9z5IdZYNKJdF/Uj2r3UKvUxKMnvwVRtzXpHPcEnwLP5/+mfTSdFZEruDe/vfWbAvwsCPEy57ItCJS/3gJp4IksPeB8U83+Rr+zcbBAt8gBxKjiynoOwDrIxtIffwJ/H74HsvAxnssZVnm86oqBLeN6IFFU/Mr/Ut0XjRFlUWEZllic/cLFCQkAODUpwS755fx6+8ayosrcPO1Y/q9/c4NnXQU1QsKUg4x0vMDACJyIijUF+Jg0fxezmojerswo183/jqRzot/RvLjouFN692oKIQDXyi/T3wOz95O+AY7kxSVR/acZ/H97lH0UdEk3XEn3b/4HM0FvswmFiVyy1+3Y5TyMevd+fyqr/C08VTSv1SWKEHawc+VKivXflHznlGf0r17SbnvPszlFVg6VZI04z8YUtS4+doRMKj5X7yaytZCw1e3D+HlNVF8uy+RHw4ksTk6k3vH9ebqcC9cbOvvnS0oq2RLdBbf7EvGpPZGbZXKFhsrriuOY8e9/XD1uLgvJ00R5GnP7/eN4u2NMXy64yw/HEhif3wu780bUDshstlEUPFH6Bz92FD8FHFHssgqklh6jURwvj2vnx1E2ZatFG/cSGFEBOb/vkypsx0T/p7WKu3eHr4cGwdXNJ7dyM+pBGSs7XVoLdQ888wzhIeHY2FhgYuLC5MnTwZgzZo13HKLUm5s+vTpLFq06KLyEXq4uTB90hh2bN1Eid5IXqkeZ5v6H1s7nR09PHrg4OhAakkqvV174+joSF5eHl5eVY+rrQeU5SrPc30JWNiyfsM63npzCRqtmjmz53Ll1RN54rGX0NpXpVn5lw0bNjBjxgxsbW2xtbUlLCyMgwcPMmLEiGZdW1M1K1AbNGgQvXr1Yt68eXW2VVRUsGjRohZr2OVucrAHZ7JK2BCZ0eRAbaD7QH6M+ZGjWf/qUbP3VgrEVxRA9ikltxrK0Nu4GwP5bckRzhzMpHvfvvRdvpyyI0fJW/4VRdt3YF+Yw1WFORC/h8xd3zfrGlQODui8vdH6+Cg/np5IFhZIGjVmvR5zURHGmP3EntyFqUiDeyH4FqbDutWkrFuNZGOD3YQJ2E2dgu2YMagsa39YZBVXcPfXhzieUohOrWLZvHDCfJr+Iao/G0/qww+jP30aVCq6/fe/7M0JALLpM9QDO+d6PpxCZsPfT0LqIciLB+cLryq11Fjy6KBHeXzH43wV8RXTe06nh32Pmu3XDPDGkB5JUHzV1IHpbym19S5B4ChfEqMjSXEcTu/uWylPLiN50T30+O47dD4NP5/2ns0lMq0IS62Km4f3aHC/C9mXsofrdpmZs7sUg7kEjZsrXiGnsOoGf253pji3CAc3K2Y+0B9dR+pJq+beF3R2UFmMV2k+vR16E1cYx560PUzreWkfhv83vS9bojM5kJDHn8fTmvb6PrwCKouVidl9rgRg8IyeJEXlcSayjP7vfU7+g3dRERlJ4i234Pvll2g96g+SEosSuWPDHeRX5mDSuzPN5SXCPM/7UjL0bqXX4fdFEL0GvrgCZr4D3YfUOVbR+vWkPf44stGEtbseuxsnEBXRG5AZeW1vpZxXK9KqVfx3digz+nXjmd8iOJtTystro3htXTQj/V3p5WqDt6MVeqOyejAmo5jDiflUlzu2cusHVqn87ejOnOJ4XDN3gcfF5cFsKp1GxdPT+zK2jxuP/nSMs9mlXPPRbh6bEsjdY3opUw0SdkFpFr2cDMy4OYz1n0ZRHGtmuv1CnK4upcd//oP+zBlyPvucgiNHkPV6DGkXWTu4CbReXuhcu1GUU4HZJKPWqrCpShhrbW3NU089xT333MPp0+eG9NPS0mo6dSRJwsXFhdzcXFJSUrj99tvrnCMkJISVK1fWe34Ha11NHdLUggp0GnWDFSo8bDwoMZRQaapk8+7NmEymc0EagEanLA4ry1Xqllr4k5aWRg8/XxwcrJEsVJSUlqCRwVRowGRngfpfQ9/nXxsoheNT/zVlqCU16x3ylVdewdq6/sKvFhYWbG1kMrrQPFNDPPloWxxbT2VTVmnEugkrdKrnqcXkxVBuLMdKU7WkWZKU+nAJO5Xhz6pADZQJrENn9WT/H2fZsSoGj572OA8cgCrsXe5cshnn6GPMtchhoKpImURaVIxsMoHZjNreHrWjI2o3V3TeVcGYjze6qsCsTuLG+mzN47WAHWy10fBE7/so3aqlcM9eRqZH4lpaSNHatRStXYtkbY3tuLHYT5uGYdBwvj2awdd7EsgvM+BkreXTWwY3Oa+SXFlJ/g8/kLXsPeSyMtQuLni/9SaVvfpz9iVluG7AlAaCFFt3JeHt2W1Kr9rYx5p0zql+U/nlzC/sT9/PC3te4KupX6Gqmmg7q58n4Zu+RIOJsl5XYl29aOES9Oznis5SRUmFO6r+dujQUpmcQdIdd9Dj22/rJnmt8sVOZS7inEHdcbJp/oRjAP3Zs/R88nNGJSoTeu2nT8PzujDUmx5ml+kpUs8UobVQM/3efljbX9w5Wp1KrQQmcf9A0l7G+owlrjCOHSk7LjlQ83K04v7x/ry96TSvrzvFFX09Gi6GDUrS0H1Vc3NGPlRTyL5bbwd8gpxIOZVP1Gk1w7/9hqQ77qQyNo7EG2/C96sv0fn51TpUYlEid/x9B1nlWZj07lQmL+SROXVL6hB6rVLb8cebITMCvrxCKV8Ucg34DEE2Gcn76G2yvlSmANh1L8drbgibTA9iNufhG+LcpotChvdyYd3iMfx0KJlfDqdwIqWQHaez2XE6u979gzztmB7WjfEhQczfsJ5DGhO5KhUuZzZddMLy5hrl78rfi8fy1G8n2BCZyevrT7HjTDZvzwnHszrJbd9Z+Ia6M+yuArZ+Fot3UR8ct1tQEW7AMiAA77fexO7sWZIyM7HSWLE9fHnN8cs1FpRpLLFxtMPB0bbBPGGy2YxcWoqppKTq/b1qKFZSoXFxRu3qirXOBn2ZEX1VmhJ7F6taQfjGjRtxcXEhNjYWv6rnXH2T8CVJUoqyX8TwoI1OjYVWjSzLJOaW0svVpt6VqxqVhm423TiZfJIHFj7AZ/XN0bX1gLI85cuPvgRZlpFlmdzSStLLKzEDBrWEo33dIK2xa2stzQrUxowZA8BPP/3U4D7nb7vhhrZ5wndF/Xwc6OFiTWJuGZujs7iq/4W74z1tPHG3cierPIvInMjaubuqA7WMuivXBk3tQWpMPimn8tnw+Umue3wQn+2JJ6bQiFvgICb+Zxz2zUzF0WTZMZyuGt4M8h/MkNFD2H76al5dGwmnIhmdFsHo1BN4lOVTvP5vitf/TbnGAp1nMIHe/SkMGcTHd4zAz/XCE2vNej3FGzeR/f77GJKURK7WQ4fiteQttO7u7Pr8JMjg188VZ69Gjhd6/blAbcx/mrQqU5IkXhzxItf+eS2HMw/zY8yP3BikVBnwOPMjHqrTlMiW/Oz6AE1MxtEojU5NwNBuRO5IJco4lUnXHibxVw2GpCSS7ryDHl9/jcaldr6h2Kxi/jmVhSTRvGLxVWSzmbxvviH7nXfx0usptQCn/3sS7xtuhzWLOV0+huOFypDiFbcHN/437gj8RiuBWsJOxoxbzPLI5exK3YXJbKqTAb257h7bi58OJ5OcV86HW2Mbr1gQ8bNSCNuuG4TVzqc3ZIafEqjtSWPQtBH0+P57ku+8k8rEROLnzsN76dvYjhoF1A7SLGUvchIXMHdgX3yc6v/yTc8x8MAh2PwCHFupJF8++h1mo0T6QQeKEpX7OQaU4/nEYjK9bif2raMgwYhrmreYpyVYatXcOsKPW0f4EZNRzIH4XFIKykkrqMBSo6KbgyXeTlaM7O1Kd+dz1xziEkJkbiRbbKy5IXazMi/vEh/fpnKy0fHJzYNYdTCZl9dEsTs2l5nv/sMezWp0UJPkdothDX8Fb+HqmAcpSILV7xzlqofCsbbXofPyQq3XY+Hri7q8gorcPLQGPVYyOBv0kK2HnFwkrVb5UamUQMNsRq6sRDYqgZlyxRokCyvULs5onJxqkkQbDSaKc5V5XjYOFmgtzv19tm/fTmpqKuvXr+fWW2/lyJEjaDQavL29SU1NJTw8XAmCcnNxdnbm2LFjze5RA+U91NFah7VOQ1mlkbM5DQdrViorHr/rcW679zZ8wnwwy+aaL8bKZVqc61UrycDLy5vD0XG4+/pTWlKMnZ0d3bxtUTXw3u7t7c3Ro+dGrlJTU2sl5m9pFzXm8OGHH7J37148PT3x8fEhJSWFjIwMRo4cWRNVSpIkArVLIEkSs/p58cHWWP48ltakQE2SJPq792dT4iaOZR+rHaj9K0VHrfupJK5YEMyPrx4kL62Un5ce4bNSJTfTszP6tl6QBhTlnCbVRnka9nFS0heM6+PGqMVj+eVwL348FM5XSfn45yczJvU4Y1KP41FewISUo0xIOYp0fBVSdDg5w4Zh0acPuh490Hh4IEkSstmMISUF/ZkzlB44QPGGjZiLlTqPajdX3B56CMdrr0VSq8lMKCL2cBZIMOyqC2Sg7zsT/voPZEVB0j6lfmIT+Nj58PDAh3n9wOu8c/gdxniPwUfSKR+EwDvG69kSaeT2ac2fx1Gf0LHeRO5IJb5iGJVpX+K7ZAWJi1+kMjaOhLnz6P7Jx1j4n/tAre5NmxLsQc8mBL7nq0xKIu2ZZyg/pKSHOdZTYu1cX1becDsAhadj2Fb0IACDpvWg14DmJ9Btc37KF1MSdhF+3ZfYae0o0BcQkRNBuHv4JR3aUqvmuRnBLPz2MF/sjOeGwd3r/7JhNisVKkBZYKKp3QPpFeCEV4AjaWcKOLIxibFz+9Bj5Xck338/FcdPkHz3Qtwfe4yy66+oCdK8rf2IOXYzKtnuwqujbd1g9kcw4BY4vAL9ib2kbSmlIl8HEnjM6I3Tf14Hz1D2vK3kyAsa7omrz6UN3V+qQE+7Jqfnmeo3lcjcSDbY2XNDWhqkHQWfi08U3VySJHHjUF+G9nRm8aqjuKTvRCcXUiA5EkswocYKfo/9nULbQgJvsyTtRy25KSWsXnqEqxYPoHrgpLjSRK5Bi8HGDZ1swkdjQmeowFxaimwyKUFZA7nBJJ0Ota0dKjtbVDY2tXrfZLNMUXY5siyjtVBj7XDuOWgymXj44Yf58ssvCQ8PZ+TIkXz88cc8+OCDzJw5k5UrVzJjxgzWr1/PsGHDLqlHDZTpOj1drYnPKaOs0khIcDARkVF1eqTvu+8+Rg0bxXXzr0Nv1JNTnoO7tTtPP/00Q4cO5Zprrjk3V01fzOhx4/nh+5U8/NSL7Fj3O1fNmoFKkjhw4AAffPAB33zzTa3jT5kyhVdffZUXX3yRoqIiTpw4wdChdUsFtpSLCtT69u3LnDlzeOCBB2pu+/DDDzl58mSDy2eF5rsqXAnUtp/OorDM0KQcPuFu4WxK3MTx7OO1N9Sk6DihLLv/VyBg42DBrAf688eyoxQkl3CNWktiqE2TAsSGGCpNpJ0pIDuxmNy0EgqzyjFWmjBWmtFaqnFwtaQicSTduyVh8syvNUlbo1Yxb6gv84b6Ulhu4EB8HpXG2eisNahTYrHfu53iDRswZmRQtncfZXv3NalNGk9PHOdcj8vtt6OyUT4YZVlm7+/KyqnAYU34kLFygv7z4MjXyodoEwM1gHlB89iQsIEjWUd4cueTrCizRFtRiMmjHz+nT6cot4xDifkM8bv0YSNXH1u69XYgPa6QqPLJDEn4iR5fryBp4SIMSUkk3HgT3u++g+2oUWQVV/DbEWWOxcKxTS+VJBuN5P+wiqx33kEuK0Nlbc3e6wJ52/sEt4RMBMBUlMOmhKsxyFZ062XD0FnNL8XULrwGgNYGyvPR5pxhpPdINiRsYEfKjksO1ECZhzomwJWdZ3L479oovry97hww4v5R5pVa2MOg2+s9zpAZfvzx7jGidqYx6Moe2Li60uObb8h46WUKf/uNrDffJOa39zFPqaS3rz8WOfchmwxcM8gbX5cGetP+Re4+jPxtp8n6fT+yXofa0QHvd9/FZriyIjb+eDbpsYWotaoLf9HpYKb4TWHp4aUcstCQo1bhemZTmwZq1Xq72fLbvaOI+/xTyIQ/DUN4/rOD9OoZRaFlIZ7W3Zg8YCzFPnr+ePco+Rll/LrkME5XeuBooafSqgJJo0OnUdHD2Q6rqiLvsiwjGww1P5jNyvu/JKHS6ZR5w+qGexCL8yowGsyoVBL2rrVTe3z00UcMGTKEgQOV4fNXXnmF4cOHc9NNNzFz5kzWrl2Lv78/Dg4OrFpVf4H1CykrK6NPnz4UFRWhVqtZsmQJMadPc+R0MmZZ5mx2KZ4Olrja6pAkiZMnT/LFF1/Qr18/1v+9HoPJwJufvcmUoVM4efJkTYYKs1qHXuOAlbGQe+bN4KYH/o9rxg/Gx8ebn3/+GYDk5GSsrOpWRXB1dWXx4sWEh4cjSRJLlixB09QSdRfhoo68atUqcv+VDXvRokW4urqKQK0F9fGwI9DDjpjMYv6OTGfuEN8L3qf6A+R41vHaK2zcgkClUVaPFaYoqSb+xc3Xjl5zenH46xg8TSr8EkwkRuTi169ptTdlWaYgs4ykyDwSI3NJO12AqZEkhXlppcAMZhSCKdbA5oooBkz2xcW7dqDkYKWtyS0HgL8bjB+Bx1NPUhkXR+n+/ZQfPoI+IR5DYhLm0nPZylUODlgE+GMZGITd1ClYDx5cZ65GclQeqTEFqDQSQ2c1cchv5INw5BuIWQfZp8GtaYXfVZKKV0e/yg1rb+BE9gmWFhbxJBLqq97lyr0afjqUwk8Hk1skUAMIHedNelwhkWVTGHjiIXST/4vfj6tIuf8Byo8cIfmuu3G6cR4/9p9JpcnMQF9HBvW48LllWaZk+3ay3nyLyrPKKlHroUPxfO0VFu6+GSokxvooxesP/XKYTEMgFqpyJt818qLzsrU5tRZ8h0PcFkjYyVifsWxI2MDO1J08NPAi6mv+iyRJvDArhCvf3cGWU1lsisqs/TwHZeUlKPPDGsip5x3oVBOQH92YxOg5AagsLOj26itIQb3JfnMJgbHlLE2SKJo3nIV5pegsLFk86cIl6mRZpnT3HrLfeYeKqhrLNqNG0e3VV9BW5Yoym8zs/V3JkdV/UndsnS4uGXZ78bb1Jsw1jIicCDZbWzPvzEaYcPGrri+FDgN9C3YAUBZwFdrTEhnyP6iBxIT+jH1zO/7utkheEiElQG4FBX8lEnaVI5Ik4WFviZutRa3XmCRJSDodNKFM4L+VFempKK2al+Zqhfpf6UoefPDBWv93dXUltipdCMBnnzUvh2N9rK2tSUlJqXN7Zlwkt9+1EBmZ9MJySvVGPB0sCQ0NrZlDJssyycXJFFcWk1aShslkYvjw4RSWVZJZrEc22NFHKsTD2syG1T+isazdq33w4EHuv//+etu1cOFCFi5ceMnX1xQXFaj16NGDr7/+ulYlgm+//Zbu3S+ieK/QqKvCvXhrQwx/Hk9rUqDW17kvOpWOfH0+ScVJ51YXaizANRCyIpXhz3oCNZNZ5u0D8WTY6rnVYE1FYSV/fXSCnv1dCR7lhU+QExpd7W9e+nIj6WcKSIzMJSkyl6Kc2hm37Zwt6ebvgIuPLU6eNugs1ai1KvRlRooij7Dh6E7MJQOwMTgQsy+DmH0Z9OzvytBZvS7YsyVJEhb+/srw3XylDqMsy8h6/bl9LCwaHUY0mczs+U15Ywkb74O9SxOLFLsGQNAMOLVW6VW7+oOm3Q9lCPTVIU/z0O5n+M7BngE9JjLFexBzBufx06EU/opI58WrQhqfYN5EvQe4s8vuDKXFLiSU9aP38e/RjHwQ3+VfkfnKKxT8/Av53//A4N/XMSNgIrNmNz5DzlxRQdFff5H33Ur00Urhe7WTE26LH8LxhhuIzIsiryIPG60Ng9wHkXYmn8MHlOsY1z8SO+cZl3xNbcpvdFWgtovR4e8jIXEq7xSZpZl42Fx66gl/d1vuGtOLT7bH8cIfJxnZ2+Xc456fcK5c2ZC7GjyGJEkMnu7HmvePE7kjlQFTfLFxsMAoG3nBcx8Jd6h44G+JgCQjlt98zdc6G1ImXYVHaSg419+jZioupnjTZgp++7VmOFtlbY3744/hOG9erddU9J508jPKsLTRMnDqxa8Ubk9T/aYSkRPBRhtr5qUdhZJsZdi3rcX9A/pCsOvGPbfcTEjKUe7bmgKyBkPBYFJN5aRWlRY8aAU3mCzwkTXYyBK+DpY42rdckFxRaqAkX3kvtXG0aLPV2Tqdjv379zN//vxG56zNnDGdGdOnKQsACisoqjBQXGHA0VqHo7UWa50atUpFN5tulBpKKTeW8/H3yzmTVVJTsk+t0mHQOqAzFKIpywTL2r3B1fnhmiotLY3p06fj7l7/Yq2LdVF/+S+++ILrrruON954g+7du5OcnExFRQW//vprizZOgFn9lEBtb1wuWcUVF8wRplVrCXEN4WjWUY5lHauVBgLPUCVQyzgJgXVXrv16OIXItCLsrDXMe2gocdvTOLY5mfjjOcQfz0GjVeHoaY1WpwYJCrPLKSusPedBpZHw8nekR6gLviEuOHlaNxwoFZ7i1YJVROpW84r/EiyivIg7mkX88RwSInLpN9GHoTN7orNs+tNUkiQky6a/WR35O5Hc1FIsrDUMvtKvyfcDlBV4p9bCiR9h4rNg1/Rs1BMi/mJBQRHLHe15viSanvlnGNzDn56uNsTnlLIuIp05gy/9i49aq6LvKC+O/J1IRNk0eh9eASMeUHpc/vtf7GfM4PQT/4dzVhoPnPgd6d6/SZ0wAcvgvuh690bSaJSSKmlplO7fT9mhw8hlZYASBDvfcjMuixahtlPmA+1IUXoDRnqNxFQBm76KQkYiyGoLASP6X/L1tLmeSq8gCbtw1jkS5hrGiZwT7EjdwZw+cxq/bxM9NMmfNcfTSC0oZ9mWMzwzva+y4eCXgAy9J56r19uA7sHOePS0JzO+iEN/JTD2xj68sf8N9qbvxcrDmt7ffUnK13tQ//At3cpycVj/A3Hrf0Dbwxerfv1ROzqisrbGmJFBZVISFZGRNfOZJK0Wxxvn4bpoUZ0FKJUVRg6sUeY2Dp7h17GSFjfD5B6TWXJoCYcsLclRS7jGbVGmN7S16tWewbNBpeLvJCWr/qze03hy7rVEpRWRlFeKpVaNnaWGbpY6olefQZKhLK8SK52hRcp1VZYbKcpRAkIrO12brs4eOXIk8fHxTdpXkiRcbS2w0WnILFKCtfyySvLLlOeuTq1CBsySA2jyKTHmYjKqUau0uNha4GqjQ2O2gOxCZbTJUAbapk0HqE+HSHhbbciQIcTFxbF3717S09Pp1q0bI0aMQNsBq853dr4u1oR3d+RYcgF/HkvjrjEXnv8R7hbO0ayjHM8+ztX+V5/b4BEK/Kgst/+XEr2RtzbGAPDQpAA8XKzxuNafwGGenNyeSkJEDiX5enKSS+rc187FEt8QF3qEOOMd6NTkwMqYdYpYrRYkmfB+gfQY3YO89FL2/3mWs0ezOb45mbjDWYy/OYgeIS4XPmAz5aSUcGhdAgBj5/XB0raZz1/fYUqlguR9sHMpTH+zafeLXgvHf+BBSUWE3xAOFcRw35b7WDl9JdcP8uGtDTH8fDilRQI1gJAxXhzdmEhqZT+yMmTcE3bWBCCWQ4fx+LQnCD6yldtzj2KVlkTRunUUNZJkWuvlhdNNN+Jw3XV1EqtuT9kOwGivMWz/PoaSfD326nTG2H0Bvoda5HraVLf+oLNVchBmnmR89/GcyDnBlsQtLRaoWes0/Hd2CHesOMSXu+KZHe5NsJsWjn6r7DDk7gseQ5IkRlzTm9VLjxK5K434Hkf4KfYnJCT+N+Z/+Dn05Q5DJtlXPME7btmEH99G2bFjGBKTMCQm1XtMXe/e2M+YjuPs2Wi96p+renxLMmVFldi7tnypqLbkZetFP9d+nMg5wSZra248s6ntAzVDOcSsV34PvZb8inz+jv8bUOa2OlhpGdHbhRG9a78Xet3al9gzSk3KwuxybBzNWNvrLnpBUkWpgaJcJUizsNZi69T4qERHYKVT4+dqQ3mlkZySSkorjVQazVSaqqfeWKNSlSGp9FhZFdHT0Q9N9RQYteW5PKPFmU3KjdnWLvrrj1arZezYsS3ZFqEBNwzuzrHkAlbuT+KOUT0vOMenv3t/iIRj2cdqb6in5me1j7fFkl2sx8/FmttG+tXc7uJty7ibAhkr9yEvrZSSfD1GgwmzScbexQpHT+uL/hadlBuNXqPCSqWlu50SlDh3s2HaojAST+ayY1UMRTkVrH3/OCFjvBh5nX+zetcaYzKZ2fJ1FGaTTM/+rgQMuchhrHFPwHfXwoFPlV7K3hMa3z/jpJJIFNCOuJ93xz3OzetuJqEogQe2PMAbIz/m7Y1wID6P+JzSZq++rI+9ixUBQzw4vT+TwyXXMe3QVzWB2qaoDGILjWSHTuT1p/6LFHmS0n17qYyNQ1/1rVZtY4Pa2RnrQQOxHj4ci4CAenMyZZdlE5UbBUD39BAOHE5BpZKZ4vAOOie3eofbOzy1FnxHQOwmSNjFFcHTeO/oe+xP33/JVQrONzHIg2mhnqw/mcETvx5n9chENOX54NAd+kxt0jG8+zjRI8yFxIhcItalQx/4z+D/MMF3Ai+tiSSzSE93V1uufGQGFpo7MZWUULZ/P5UJiZgKCzGXlKBxd0PXo4eygrpXr0Y/oMuKKjmyUQnyhs/uXWf+UmczxW8KJ3JOsMHGmhvjtrRpmg4AzmxUsuU7dAefIfweuZxKcyV9nfsS5hrW4N0srLVY2WmxtNZiqoTSAj2VFSbsnS2bVb5LlmXKiiopLdBXHVeDvYtlhw/Szmel09DdWfmMMJjMVBrNqKSqHGeSFWcL46g0l1NcWYiT5XlfMu08lUCtokAJmLVNnALTRjpnP/Vl5upwL15fF018Til74nIZHdD45P7+bsoQU2x+LMWVxdjpqpapV9f8zDtbUzoDIDmvjM+rUjM8M71vvfXtJEnCxdu2zkT/SxFTkgyOlgTY9aid4wboEerCvOeHse/3OE5sTSFyZxrJ0XlMuq0vXgGXXut1769x5CSXYGGjYdxNgRf/ZuQ/CQbfAYe+gtX3wr17lPw89SnOgO/nKm/GPcfCpBdwUGv56IqPuHndzUTnRfO/I88wus+t7Igp4Lt9iTw3M/jiL/I8A6f24PT+TM7qh5F34iecpylzcD7boSwEuGV4D2wstDBwANYDB1zUOaqHPQdZjuDIb0rR+iFBcXjknYFeN7fIdbQLv9FVgdpOeo64D39Hf2ILYtmWvK12j/UlevGqEPaezeVkahE5/3yAJ8DgBc0KFnpNsSUhIpteueHc4HgbtwbfytGkfFbsSQDgldlhNWXB1La22E2a1MjRGrd3dRxGvQn3Hnb4D2rZOTntYUqPKSw5tIQjlhZkZefinnr4XM3XtnCyqnh4yGxMspmfYpScpDcG3XjB9ydJkrBxskA2qCjJ12OoMJKXXoqNow5LW90Fv9wbK00U51Vg0Ctzt6ztdNh0gp60xmjVKrS1ktWqcbd2J7M0k4zSDGy1tmjVVaMoWitlsU5FYVWvml97NLlBnfsr0GXCxkLDtQOVYYVv9yVccH9XK1d8bH2QkYnIPm+Y09ZNyR2DrOQAq/LG36eoNJoZ0cul7qqz1lKawymUb25Bbv3q3UWrUzNmbh+ufmQAds6WFOVU8PvSo+z65QzGyqYVi67P0U1JHP8nGYDxNwXVlEK5aFNeARd/JSnpmofqL2RdlKYEaUUp4BIAN3yj9NYA3e26897E97DSWLEnbQ+VzssBIz8dSq5TsPliuXjZ0rO/K6DiaPEsOPYdhxPzOJJUgE6t4taRlz4JfFPiJlRmFUMjZ2PUm/AKcGSgpir/UK8L9DR2ZD3P5VPDZKgp5r0pcVOLnsbD3pLXrgmjnxSHZ2k0ZpUOBt7W5PtXGCt44dRTxLgdBKBvzDgqDWae+jUCWYZrB3gzrk/LTJBPO5PPqT1KMD76hj6d+gO9WjfbbvR3648sSWyysYIzLfv4Nkpfcm7hSMi17ErdRWpJKvY6e67seWWTD2Nlp8OpmzVaCyWDf0m+ntzUEkoL9Bj0ploZ9WWzjL7MQFFOOXnppRj0JiRJws7ZElvnztWT1lQuli5Yaiwxy2YySjNqb6yeY1yRr/SqdSAiUOskqusubo7OIr3wwk+i6jQddYc/q3rVMpQA7mBCHn+dSEeS4LmZwW334sw5TUzVcvFA15BGd/UJdGLec0PpO6obyHB8czI/vXaQrMSiZp82Zn8Ge35VVnmOvNa/ZXoCdDZw3RdK+pPoNfDlZMg8Fwhz8lf4aASkH1NysN30o/Lvefq79efDSR9iqbYksmA/zr1+orhCz+9HW65+3KBpfgDEVIyjaO8ffLFdSalwzQDvZhWyr0+hvpD96fsZnDIdOcsSC2sNV9zgjiqr6otCr/GXdPx21S1cqX2pL4Lk/UzuoRSd3pO2h5LKunM2L8X0sG48674bgE3SCIrUTR9afWXfK5zKO8UZ/92odRKZZ4v55OsTxGQW42yj49kW6p01Gc1sW6nMZw0e40W33i0z/NsRTPVThpk32ljD6fVtd+LTf4OxHJx6gtcAfoj5AYDZ/rPPlQJsIo1WjaOHNXbOlqg1KmSzTGmhnvyMUnKSS8hNLSEnRfkpzC6vSb9hYa3B2csGK7umLxyIj48nKCiI8nLlM+nEiROEhYVhMBiQZZl77rkHf39/Bg8eTFxcXJOOuW3bNpycnJhftZIf4OWXX8bf35+QkBAOHDhwwWMcOHCA0NBQ/P39efnll2tulyQJb1tvJCSKKoso0iufIevXryds4DBUPoM4FRuvfLG+gC+++IKAgAACAwNZu3YtoKz6DA8Px9Oz6QvLmkIEap1EgIcdw3o6YzLL/HAg+YL7h7uFA9RNfHtehQKDycyzvyvz1eYN6U6wVxNqc7aUnNOc1ik9StUVCRqjs9Iw8Za+zLhPqQ+Zn1HGL/87zN7VcejLL9zrZDaZ2f/nWbasUAKo/pO6Ez65BedMeQ2Aaz5VEpOmHoZPx8J7A+CNHvDLHcrcB68BcOemBlfwDfEcwrKJy9CpdBgsTmDpvYoVe+LqrSt3MTz87Oke6ICMmgOpYyg9tRmAu8Zc+uTZf5L+wb2gJwNSrwBg/Pwg7PKUgINu/cGmabn4OiSVGvyV6+LMRno79sbP3g+D2VCzeKLFlOUxpHQbAJ+WTeD+lUcwmBrORVhtTdwa/oj7A5Wk4qUpzzH8KuU5ZjiSh5UZXpgVjPNF1m79t6ObksjPKMPKTsuI2Y2vRu1sqoPwI5aWZGZHKSlS2kKkUjOV0GtJLk5hd6ry2pkbOLfJh5BlGXNZGeayMuTycizURhwdJWxtZDQYQF+BubwMY0kpptJSzOVlSJV6LNQm7O3BzgakyoqaY5z/09B7UM+ePbn++utr0lg8+OCDLF26FK1Wy9q1aykoKCA2NpaXXnqJJ598ssnXMnXq1JrUHBEREWzYsIGYmBhWrVpVK9F+Qx544AF+/PFHYmJiWLduHSdPnpuXbamxxMVKWZCRVpqG0WwkICCAn376ibFjRis76YuUXs4G5ObmsnTpUo4ePcrWrVt59NFHMRqNHWvVp9A+bh7eg/3xeXy/P4n7xvfGUtvw3JX+7so8tRPZJ2rXJqzpUTvJ8t3xxGQW42St5YmpjdQabAV5mRFkazRINC1Qq+bXz5Ubnx/GjlUxnDmUxZG/E4nckUr4Fd3pO8qrzjCmLMtkJRSz6+fTZJxVvj0Fj/Fi1HX+Ld97GHY99BgJfz0GMX8pcwFB6Wkb85hSwF3d+MrSkV4jeXfCuyzeuhjsI0guXM7uuBBG+7fMkPSwawJIfuMQMRUTuNbya6xDphDg0bRSO43559QOrjhzGxISfUd2U3oqf9+qbOzMw57VAqYoaVjObEKa/DKTe0zm84jP2ZS4iRm9WjA33NHvkIwVlLuEcCo7iLIzOTy3+iSvXxvW4PM1qSiJV/a9AsA9/e5hWLdhnKaYnNUyrkaJBbaOXB3eMisy89JKa1ZKj7o+AEubrrXS39PGkwHuAziadZTNNlbMj14LIy8cGFyS8gJlIQFAyLX8GPMjAKO8R+Frf+HcmdXkigpiRoxshQZC4JHDSNb1p6145plnCA8Px8LCAhcXFyZPVoLdNWvWcMsttwAwffp0Fi1aVDsJexOtWbOGm266CbVaTVhYGCaTqSbbRH3S0tKQZZmQEGWkZv78+axZs4bQ0NCafdys3Sg2FKM36kkrSaN3795VCw5UUL3IoCgVXPvUW8t5w4YNzJgxA1tbW2xtbQkLC+PgwYOMGNH0KjXNIQK1TmRqiCfejlakFpTz9Z4EFo1r+Nusv6M/1hprSgwlxBXGnQuGqnrUzJkneTdRGb54enpfnFro23ZTxVSvDtQ5Yt3MvDWWtlqm3BWK/+Bs9v1xlvz0Uvb/Gc/+P+Nx7W6LZy8HVGoJk1EmOepcEl6dpZrx84MufoVnU9h7wbyVkH5cmedg7azMfWggq3x9xviM4e1xb7N46yNoHY7x/O7n2dTro0suBA5Kr5p3Xy2p0Qb0JaP4z/BLXxySX1aA484QrA122HlqGTOvj1KmLK4qULvQStjOoPdE5U08KwoKkpniN4XPIz5nV+ouSipLsNW1wCIbsxkOfQmA1chFvG89kLu/OcSqg8l0c7DioUl1v1wYTAae2PEEZcYyBnkMYmG/heSW6Lln5WHKLfXML7HEJk1PUmQuvpeY4sZYaWLDFycxGcz4BjvTZ2gbzWdtY1P9pnI06yh/2dgwP3pN6wdqUX+AqRLcgyl36cXvW5XetRsDb2zd87YQa2trnnrqKe655x5Onz5dc3taWhre3soXBEmScHFxITc3l5SUlGYVZU9LSyM4+NywvY+PT6NF0M8/b/X+W7ZsqbWPSlLhY+vD2cKzFFcWk6/Px9myahGYjStIZiWnWkVBnWkqDZ0jNbXlpqn8mwjUOhGdRsUjk/vw2M/H+WhbHPOG+uJgVf83Wo1KQ5hbGPvT93Ms69i5QM3FH1ltgcpQhrsxDTe/YK4f6NOGV6E4XZIC1hBof/HDbr3C3fDr50rc4SyObUkmK6GInOSSOrneNDoVPfu7MfzqXti7tsGya0kCr/BLOsQE3wk8Fv4ybx59jmxpDw9tfor3rnijRYK1jTYW9JOKyTH6Y9i5GwICL+l4f36/D8+iXhjVlVx173AlIXJWNJRkgMZSyTXX2Vk7g89QJWfemY0EDr6Dng49iS+MZ0PCBq7rc92lnyPuH2WozcIBwq5nks6G52cG8+KaKN7ZfJrUgjL+Ozu0ZtUmwPtH3ycyNxJ7nT1vjHmDuOwy7lhxkJT8crxcLAno50nsngw2LY9i7v8Nxdbp4hfO7P4llry0UqzsdUy6vQ3ns7axqX5TWXLwLSIsLYhNOYx/cUazklk32wlldSf9bmB9wt8UVRbhZePFaO/RzTqMZGlJ4JHDrdBAkOqpd3m+jRs34uLiQmxsLH5+fgD1DpdeTFH2ho5zqftbaixrrQK10VSlQlJrwcZBef8qSle+ZP8rK0Fz23SpxBy1TuaaAd708bClsNzAp9sbn5xZ7zw1tYZ8W6UnLlSVzCuzw9q+9qKhnBiTUo+zzyUWt1apJAKGeDDnqcEseHM0V9zel4FX9mDglT0YdGUPptwVwh1vjWHKnSFtE6S1oFv7X0Ww5l5kWcWO9L95bvdzmOpbUdoMESmFrIvNJsMqEYC9h1wpySu76OOd3JFKySGlN1Y7KRtHj6re0bh/lH97jARt56r92KAAZUiHM5uQJIlr/K8BYHXs6pY5/sEvlH/Db1IWqAC3j+rJ8zODUUnw06EU5n++n+h0ZQh/d+pulkcuB+DFES9zMNbMtR/tISW/nB4u1nx71zAm3RiIa3dbKkoMbPzyJKYmzHerT+zhLE7uUHoMrri9b5tmqm9rrlaujPUZB8DvdjZw6q/WO1lBMiTuAkAOvZ7vor8DlAS3zf1SJkkSKmvrVvlpLAjZvn07qamprF+/vmauFoC3t3dNL5Msy+Tm5uLs7MyxY8cIDw+v83P+4oHznX8coNHetObu72Lpgo3WpqYmqExVAGbrriS6tvcC6l57c9t0qUSg1smoVRKPV80n+2p3PFlFFQ3uW51P7fxALTarhH/ylSGL23oXE+h56fOTmi03llMWSk9goEd4ix3W2l5H4PBujJjdmxGzezN8dm8CBnugtWjDpJUt7NXJ86lIuxFZVrHm7Bqe3f3sRQdrsizz2jqlPmfpoAG46JKoMNvy9/t7MBma/wF+9lg2O35Qhs8P+axn6sTz5sfUDHtOvKi2dkgBSloO4reDoYJZvWehltQcyz7G2cKzl3bs/ERl5R/AkDtrbbpjdE+WLxiKnaWGQ4n5TFu2kzmfbeSRrcrk7L42V/LiKokHfzhKid7I0J7OrL5vFL3dbNFo1Uy9OxSdpZr02EL2/tr8xSkpp/LYvFyZqjBgii++wS1fJaSjuSZACcLX2tpgiPqz9U4U8bPyr98Y9pencib/DFYaK64NuLb1ztmCTCYTDz/8MMuWLSM8PJyRI0fy8ccfAzBz5syaocz169czbNiwWj1q//5pqK7nzJkzWbVqFSaTiZMnTyJJEl5VlTKCgurOrfby8kKSJKKiojCZTHz//ffMmjULgKeffprff/+9Zt/qVaAalQa9SU+lqVJ5fajU4BrAgYjT3Hpb3RQ5U6ZMYd26dZSWlpKens6JEycYOrT1cu6JQK0TuqKvOwN9HakwmHnuj5MNvvH2q8pPlliUSF5FHhUGEw/+cJQIkzJBdbBl642pN6YyK4r4qnJjQc5926UNnUWAhx0ze02lIvVGJNSsPbuWZ3Y9g9Hc/Pxqfx5PY+/ZXCw0Kh6a1o9p41KwkErITFex86fTFz7AeVJi8tn4ZSSyDFHueyjvn0xvx6o5kxWFSjAD4D+52e3ssDzDwK6bMnclcReuVq6M8VZyrF1yr9rh5YCspDFxDaizeVwfN/64fxQz+3VDrZI5afiUclMhpgoPDhweRWpBOY7WWh6Y4M93dw6rNefU0d2aibcpr7Pj/ySz57emB2sZZwv56+MITEYzPfu7MuzqC5ew6wpGe4/G1cKJPLWaHVmHoDy/5U8iy8oCFYB+N/BdlNKbdnXvq1us4kVr++ijjxgyZAgDBw4E4JVXXmHZsmXk5uYyc+ZMbG1t8ff357nnnmt2gfNq/fr1Y9KkSQQGBjJ37lzef/99QFl52dDz+L333mPOnDkEBgYyZcoUwsKURXQnT56skzpDq9YSezCWSf0mcfjAYcaNH1ezCCI5ORmreoZ9XV1dWbx4MeHh4YwbN44lS5ag0bTeTDIxR60TkiSJF68K4bqP97AhMpNPd5zlnnoWFjhYONDboTdxhXEczTzGmr1ORKcX4W3dG8wgZUa2Q+vhbPphjJKEnaTB06YV5350EQ9NCuDP42mUpUjYdv+BdfFKHc7XRr/W5OGRogoDr/yl9KY9MMGf7s7WMG4ukw8tZG3+/xG5Mw17NysGTPa94FyL6D3pbFt5CrNJJtvtLDt7/cyzff7v3A6nNyiTo10Dwb1tVxO3KklSetWOfA1Rf4L/FcwOmM22lG38GfsnDw54EK3qIlZBGvVwpCox8JC7Gtytl5stH9w0kPcOHeHzyNOo0DLA+iHsQn0YH+jGrP5eDa4E7z3AndE3BLDrpzMc25SEQW9i3Lw+SI1Mezh7LJt/vonGqDfRva8TU+8KRa2+PL7ba1Qargq4hq9OfsVvtlZMil4LA29p2ZNkRED2KVBbkOgzgO0RbwEwv2/9Q4Ad0YMPPljr/66ursTGxtb8/7PPPmuR87z44ou8+OKLtW47cOAA999/f737Dx8+nMjIup9vJpOp3pWZM6bOIPpsNGklSv60brbKMObBgwcbPMfChQtZuHBhcy7jol0er7ouqJ+PIy/MUpYfv/n3KfbE5tS7X3Xi23d2bmT1sTQ0Konbr52pbCxMhrK8tmhuLTF5SsAQaOHWZSckt6RebrZcN9AHY3Eo9kV3oJY0rItfx8v7XsYsN23I8p1Np8ku1tPT1YaF46p6RVwD6BFowzBbJbnm3t/i2PJ1dINVHwx6E3t+jeWfb6Ixm2RcQ3Ws7vkRFhod03pOO7dj1B/Kv8EtV16pwwitWjQQuRoMFYz1GYuzpTO5Fbk1ua+aLXI1lOWCvTf0mdb4rjmRLI/+EIBnRzzNN7dcxYfzBzJncPdG0/UA9J/YnQk3B4EEkTtS+fmNQ6SerttTVFFqYMuKKNZ/EoG+zEg3fwem3dOvWXUju4LZ/rMB2GVlSebxb1v+BMe+V/4NvJKV8WsAGOszFj8Hv5Y/Vyei0+nYv39/g3PWqk2bNo2HHnqoWcdet25dg9ucLJ1q8qull6STV5HHG2+8Qb9+9VfOqU91wlt395YtqXZ5vfK6mPnDfLl+kA9mGe77/gjrItLr7BPgoARzcUVRaFQSH9w0gNGhvcGhKj9PO/SqxZQq31oCHRtOLyLU9vT0vrja6khK6c0o+8WoJBW/nfmNtw6+dcFhrH1nc/m6qtbjy1eH1Fo1yOAFDLL5hVGuvyBJELMvg1/+d4iT21MoK6rEaDBRkFXGsc1JfPvsHo5uUopwD57uR/SAzZjUBqb4TTlXT1ZffK70TlcM1PxGg50X6AvhzEa0Ki2zeinzX1adWnVxxzz4ufLvoAWgbniQo9RQyhM7nsBoNjK5x2SuD7i+2acKHu3FlDtC0FqqyU4qZvXSo/z65iH++TaafX/EsfqdIyx/fBen9mWABAOn+nL14gGdep7nxerp0JOBLqGYJYmfC0+1bPJbQzkcVwK1/NBraobObwlu4V67TmjkyJHEx8c3OGetNXlYe9QJ1pqjOuHtiRMnWrRdIlDrxCRJ4pXZoYR3d6SgzMB9K49wz7eH+ftkOttPZ7Ns8xne+F1ZbKC2SmbZjf24MrRqZUp14tvMkw0cvZWYTZw2KekzAj0urvj35cjZRscrs5XHbP1+N+4KegqA76K/44NjHzR4v5T8Mu5beQSzDNcO9GZMwL9qPQbNQrJxJVyzkquuqcDSRktuainbfzjN8id38emD21n5/D52/xJLebEBe1dLpt4dStg0T9YnKCV2ak18Pr0BTHpw7g0ejZcG65RUaiWxMdTML5obNBeVpGJ32m6icqMauXM9EvdAykFQ62DgrY3u+tr+10gqTsLTxpMXRrxw0b3RAUM8uPnlEYSO9UZSSWScLSJ6dzqH1yeSGlOA2Szj7GXDNf8ZyIhr/C+7nrTzzQ9dAMCP9rZUHP2u5Q588jdlLqejL9+WJ1FuLKevc1+GeQ5ruXMIzSZJEh7WHjhbKTnVcspzmjxq0ZrEHLVOzlKr5sdFw/ngn1g+3hbH35EZ/B15frFZR+zNNqAqpUe3AqAqZ5pnqJI9P6NtAzU5P4GYqiGaPt6tk8W5q7oy1JOrw73441gav2735MHJT/D+8Tf57MRn2GhtuCP0jlr7l1eaWPTtYfJKKwn1tue1a8LqHlSjgwHzYfcyfNI+Yt7zv3J6fyaxR7LISlDSQGi0Khzcrek3wYfAEZ6o1UpvXpmxDD97Pwa6Dzx3vPOHPbvqsHa/ubDnPSWbfFke3e26c6XflayLX8eXEV/y9vi3m36snUuVf8NvAruGE8iuPbuWP+P+RCWp+N+Y/13yZHNrex3jbgokfLIvGXEFFOZUUJpfgYuPLb4hLji6Ny8JdVc10Xci3jpHUisLWHPqR+aMfwZULRC4HvoKgMLwm/i+qq7nov6LxFSQDkCSJDytPdFIGhwsHFBJ7f9FRQRqXYCFRs1/pgQyLbQbH2w9Q2aRnrJKEzY6NbeP8mNd1iB2pu7gWNYxQl2rymjU1PyMaNO2Zqbsp0CtRi2Dv3PTS0cJipeuCuFgfB4JuWWs3OTDgnEPsDz6A945/A7WGmvmBc0DIK+0ksWrjhKZVoSLjY5Pbxnc8BymIXfD3g8hYSc2JScZMGUQA6b4Ul5ciaSSsLDW1PoAMctmVkSuAOC6gOvObass7drDntU8Q8E9BLIilcB08ALuDLuTdfHr2JS4iYTChKbNM0o/DrGblGSaoxY3uFtyUfK5ElH972Ggx8AG920uBzcrHNw6V37BtqRRaZgfcjtvHn2Xb7UGrkvcjarnmEs7aPpxSD0EKi3fW2spNZQS4BTAhO5doIJHFyFJEm7WbhfesY20f6gotJhgL3s+mj+IX+8dyfrFY/jl3pHM7OdFuHvdfGp4VgVqWdFgMrRZG6PT9wPQS22Nhfris6Rfrhytdfy4aAS+ztYk5pbx8xZ/pnrdDMCr+19lTdwa9p/NZfqynew8k4OFRsVH8wfi7djIh7Fjdwi7Qfl917s1N1vZ6bC00db5lr85cTPxhfHY6ey4vs9586Ri1oOxHJz8lELsXVm/qr9XVVb5Pk59GOczDhmZr05+1bRjVPemhV4HzvWnvTCYDDy580lKDaVKiaiwtlllJpxzTdBcbFETr9Oy6/BHl37Aqt60kqDpfBv3GwAL+y3sED03QscknhmXgeoKBceyj5270dFPybxsqoScM23Wlug8JUFqX+vWy+Lc1XV3tubne0bg725LemEFv2wJQV08FoBndj7L/B++IKOogl5uNqy+fxTDejUhQWl1j070mkafD7Is80WEkkF/ft/5tWtc7v9E+bff3K477FktbA4gQdKemukDd4UpqTXWnF1DcnFy4/fPOXNumHj0o/XuIssyrx14jYiciJoSUS1RQkxoHludLdf5KImbv849cmkr5csL4ISS5PY7Dx+KK4vp6dCTyb6dM99gfHw8QUFBlJeXA3DixAnCwsIwGAzIssw999yDv78/gwcPJi6u8Uo61bZt24aTk1OtVZ8vv/wy/v7+hISEcODAgQse48CBA4SGhuLv78/LL798wf1ffPFFgoKCCAsL46677sJkunBS8S+++IKAgAACAwNZu3YtcG7V579ztV0qEahdBkJdQ1FLajJKM8gorZq/plKdm+zdhgsKosszAQh26YITzduQh70lPy0awR2jeuJsY0FBypUYCgaBZMbS6wfGh+ez5oHR9O1m37QDugdB4HRAVuZfNWBn6k6i86Kx0lgxP+i85fPJB89Nim8kF1iX4eANIUr2erb/D1BS4QzrNgyj2cir+19tfDXuP/8FZAicAR7B9e7yY8yP/HL6FyQkXh/zusg52I7mD30MjQwHLHXs2fbixR9o30dgKCXDI4ivUpRpAvf2v7dFAnBZljHoTa3y09BzuWfPnlx//fU1yWwffPBBli5dilarZe3atRQUFBAbG8tLL73Ek08+2eRrmTp1as2qz4iICDZs2EBMTAyrVq3igQceuOD9H3jgAX788UdiYmJYt24dJ082/hk3duxYIiIiiIiIwGAwXHDFaW5uLkuXLuXo0aNs3bq1pnRW9arPlibmqF0GrLXW9HHqQ3ReNMeyj3GlzZXKBs8wSN6vJF6sHsppTWYT0egBNX29R15wd6FxzjY6np8VzFPTgtgak0VGUQjb8pdyKHs7Uab3OF0YwgD3ZqysHfUwxKyDYz/A2CeUIdHzyLLM5yeUVBJzA+fiaOl4buM+JbcXYXOUOnmXg3FPQOTvEP2nkubGI4T/G/Z/XP/n9exO3c36+PVM7zW97v3i/lF60yQ1TPy/utuBgxkH+d8BJQB8eNDDjPUZ25pXIlxANzsv5nkM57usfbydtplh5YWorZq5oKM8H/Yp5ZXe8fGnPO8EA9wHcKXflS3SRmOlma+e3N4ix/q3hcvGNZii5ZlnniE8PBwLCwtcXFyYPFnpHVyzZk1Nhv/p06ezaNEiZFlu9oKJNWvWcNNNN6FWqwkLC8NkMpGent5gbc20tDRkWSYkROkMmD9/PmvWrCE0NLTBc0yceK7UXf/+/UlJSWm0TRs2bGDGjBnY2tpia2tLWFgYBw8erDeZbksQPWqXiZq6n1nnzVOrWVDQNj1quelHydSokWSZQF/xwdNSdBoVU0M8uW1ELz6b+g6jvEdRbizn/s33E50b3fQD+Q4DvzFgNsDGZ+ts3pi4kWPZx9CpdNwafF4qiYJkJVM/wPB7L/FqOhH3vucWTWx/E1Byby3sp8wj+9/B/1GoL6x9H6Me1j2u/D5sUb0pTCJzInnon4cwykam95zOgpAFrXYJQtMtGv8GdjKc1qpZs73u6+OC9n4I+iKOdgtiXd4JJCSeHPpkp1/paW1tzVNPPcWLL77I0qVLa25PS0vD29sbUCbnu7i4kJub2+yi7OcfB8DHx6dWQfRL3f981bVBJ0xofGHHpZzjYogetctEuHs4q2JW/WtBQVW6hoy2Wfl5Kkn5ttdDVmNj0Q7F4C8DWrWWd8a/wz2b7uFI1hHu2XwPX0z5ggCnuvUj63XlG/DpWIharRRW7628YRXqC3lt/2sA3Bl2Z+0VUQc+BdkEPceee05dLsY9ofytov6AzCjwCOaO0DtYH7+euMI4Xt77Mm+Ne+vcRPG9H0JuLNi4w/in6hzuVN4pFm5aSImhhIHuA3lx5Iud/oO8q3C0cuFuz7EszdzB+2lbmVpRiJVlE3vVyvJg3ycYgdedHaGsjGsCriGkBaeAaHQqFi4b12LH+/exG7Nx40ZcXFyIjY3Fz88PoN7h0vOLsjdVQ8dpqf3P99RTTzFy5MgL9oxdyjkuhuhRu0xUl5KKzo2mwqgkwcW9LyBBaTYUZ7Z6G6KzjgHQV+fc6ue6nFlprPhg0gcEuwSTV5HHHRvuaHoiVs9QGHq38vu6x8FYCcCSQ0vIq8ijl0OvmknzgJKt/dBy5ffh9dfE69I8QqDvVYAMax8Box6tWsuLI19ELanZmLiR/+77r/LGnnYUdij1HJnyCvzrQ/5Y1jEWblxIUWUR/dz68dEVH2GlEakzOpKbJryOl0kmSy3x4aYHL3yHarvegcpiPvIJILosDVutLQ8OaMb9m0CSJLQW6lb5aSwI2b59O6mpqaxfv75mrhaAt7d3TS+TLMvk5ubi7Ozc7B61848DkJqa2uCw58XsX+3LL7/k2LFjtXoFW/ocF0sEapcJLxsv3KzcMMpGInOrykbpbMClqoxTG+RTiypOBKCvfc9WP9flzk5nx2eTPyPMNYwCfQF3bbiLY1WB8gWNf1rp8ck9A3uWsTdtL6tjVyMh8dLIl9Cpdcp+JiP8tggqS8B3hFKw/HJ0xYtg4QDJ+5RgTZYJdw/n9TGvIyHxy+lfeHPnM5i/ux4MZdB7Yq05oWbZzPKTy1nw9wLy9fkEuwTz8RUfY6O1ab9rEuplYWHPEz2UWslf5x1la9QPF75T0j7Y+wE7rSz5XKsH4IURL+Bq5dqaTW0TJpOJhx9+mGXLlhEeHs7IkSP5+GNlHt7MmTNrJuWvX7+eYcOG1epR+/dPQxP4Z86cyapVqzCZTJw8eRJJkvDy8gIgKCiozv5eXl5IkkRUVFTNUOasWUqZt6effprff/+9zn22bt3KsmXL+Pnnn9Fozg00HjhwgFtvrVsxZMqUKaxbt47S0lLS09M5ceIEQ4cObeZfr+lEoHaZkCSpZp5arQ/s6nlqbVChINpQAEBfz5ZL2Ck0zMHCgc8mf8ZA94EUG4q5c8Od/Bn354XvaOUIk5Ul7TE73+Sxf5TCx3MD59b0zAKw+x0lONHZwTWftkzG9s7IpTfMWa4krj22Uuk9kWWm9ZzGSyNfAuC7+LXMc9SwwzsY+foVIEkYTAY2JGxgwd8LWHp4KUbZyJV+V/LllC+x1zVxta7Q5iZNeI2bZWXqxv8deJ2UwqSGd64ohF/vJkMl8Uw3JbiYFziPK3u2zAKC9vbRRx8xZMgQBg5U3tNfeeUVli1bRm5uLjNnzsTW1hZ/f3+ee+65mpWhzdWvXz8mTZpEYGAgc+fO5f333weUlZcNrUZ97733mDNnDoGBgUyZMoWwMGVKxsmTJ+tNnfH444+Tn5/P+PHjCQ8Pr2lrcnIyVlZ1e7VdXV1ZvHgx4eHhjBs3jiVLltQK8FqaJF+oonMnVVRUhIODA4WFhdjbizc9gK8jv2bJoSVM6D6B9yZWpWDYsURJFRA2B677otXOXVSex6iflPkTu6atwsFdpOdoK+XGcp7Y/gTbUrYBcHPfm3l00KNo1dqG7yTLnP3zXhbk7iBPraafjQ+fX/0r1lprkGVlpeMvd4DZqARp/ee1zcV0ZPs/hfVPKL+7BUHo9ZBxnN9TtvGGswNlVYGsndYOK40V5cZyig3FAOhUOp4c+iRz+swRc9I6AUPuGW7/7SpO6DQE6Vz46Oqf62ayl2X4bSEJ0b/xgJcXiWoIdgnm22nfnuuVbgEVFRXEx8fTs2dPLC0tW+y47WXbtm188sknrFq1qtH91q9fz5kzZ3jooYeafOzp06ezbt26Ju//1FNPcdNNN9GvX78m3wfA09OTjIyMWrfV9zg1NU65TL8CX55qVn5mHz/3TaRmQUHr9qjFJGwFwMtowsGt/rxRQuuw0lixbOIyFvVbBCiF3K/981p2pOyod39ZlvkneSt360+Tp1bTV1/Jx9EHsP7hRqW3aMUM+OlWJUgLuUZJcCvA0IUw7knQWEL2Kdj6CkSv4ZriYv6WvVjgfx2WakuKDcVklWdRbCjG3cqdhf0W8uc1f3JD4A0iSOsktC4BLAm9D0eTiVOVudzw23QOpx88t0NFEfx2NwfO/MF8L08S1cr0k7fHvd2iQVpXpNPp2L9/f4Nz1qpNmzatWUEa0KwgDeCNN95oVpBWnfDW3b1lUxSJHrXLSKWpkuHfD8dgNvDXNX/ha+8LhanwTrCS0+mZNNC2zjeyr7c8xpKUDUwy63h3weFWOYdwYVsSt/DyvpfJq1Cyqw9wH8BYn7EM9hiMwWwgozSD3878xqHMQwD4O/TmK7MbTlWlkmpoLGH4fcqqR62Y8F5LRaGSXy1mPTj2gEG31yS1LaksIassC71Jj4xMH6c+aFRi8X2nJMsk/LGIR7K3E6vToZZhjJ0f/S090CQfYLNUwXFLpUxef7f+LJuwDBerJlQJaabqnho/P796h+mEjqG8vJyEhISL6lET7xCXEZ1aR7BLMMezj3Ms+5gSqNl7gZWTkowxOxq8mpEgtRmi8k4BECRKR7WrST0mMbTbUD478RnfRX/H0ayjHM06Wmc/C7UFtwTfwp2hdyplosY8DrGbIX472HWDsY+Bg087XEEnYOmgBGeDbq+zyVZnW7vsltB5SRJ+sz9j5ZFveGn/K6yztmBbSQLbShLACkAJ0q7qfRXPj3i+1Woba7VKPd7s7Gzc3NxEr2wHJMsy2dnZyspcbSNTThogArXLTLhbOMezj3M86zhX9b5KqcnoEQoJO5Xhz1YK1CLK0wEIcxZz09qbnc6O/wz+DzcF3cS2lG3sTdvLiewT2Ops8bD2wN/Rn9tDbqeb7XlBtVsf5WfEfe3XcEHogKwH3sob3Ydzy85XOVyRxXFzKWUaLWODb2RS71l42Hi06vnVajU+Pj6kpKSQkJDQqucSLp4kSfj4+KBWN79cWIcN1IxGI3PnzmXfvn2kpaWRnp7e4oVOL0fh7uF8HfV17QLtnv2UQK2VKhTkV+STLCv5uEJ9x7fKOYTm62bbjRuDbuTGoBvbuymC0KlJbn0IvfZrGi5S1LpsbW0JCAjAYDC0UwuEC9FqtRcVpEEHDtRAKZT6+OOPt1r9rMtR9YKCM/lnKKksUYZhPFs3RUdE6l4A/CoNOHQf1irnEARBuJyp1eqLDgSEjq3DBmoajYbFixc3eX+9Xo9er6/5f1FRUWs0q9Nzs3bD29ab1JJUTuScYKTXyPNyqUUoS8pbeI7DiaRtAPSTtWAtqhIIgiAIQlN1mfQcr7/+Og4ODjU/3bt3b+8mdVh1CrS7BYJKA/pCKExu8fNF5ChVD/rZeF9gT0EQBEEQztdlArWnn36awsLCmp/k5JYPOLqK6uzyNQXaNRbgGqj83sLDn2bZTERZ1UIC1+YlDRQEQRCEy127BWpTpkzB0tKy3p9XXnml2cezsLDA3t6+1o9Qv/MT35rMJuXG6nlqLbygIKEogWJMWJjNBPiObdFjC4IgCEJX125z1DZu3Nhep77s9XHqg43WhhJDCafzT9PXpa9SoeDEj8o8tRYUkaEktw2prETbSqk/BEEQBKGr6tBDn3q9noqKijq/C5dGo9IwyGMQAAcyDig3erROj9qJ5J0AhJnUSnJdQRAEQRCarEMHaoGBgTUlMUR5jJY11HMoAPvT9ys3VNf8zDsL+uIWO09EbiQAYTY+Lb6aVBAEQRC6ug4dqCUkJCDLcq0foWUM66bkMzuceRiD2QA2rkppIGix4c9yYzmnK7IB6O8R3iLHFARBEITLSYcO1ITW08epDw4WDpQZy4jMUXq98FaGQ0ne3yLnOJlzEhMybkYjHl4i0a0gCIIgNJcI1C5TKklVM/xZM0/Nd7jyb1LLBGqH0pXjDqzQI3mFt8gxBUEQBOFyIgK1y1hNoFYVUNG9KlBL3q9UKLhEB1J2KOcxyODc+5KPJwiCIAiXGxGoXcaGdlMCtaNZR9Gb9NCtP6gtoDwPcmMv6dgVxgqO58cAMMTBH1TiqSYIgiAIzSU+PS9jPe174mblRqW5UiknpdGB90BlY9K+Szr28ezjGGQTbkYjft3HtEBrBUEQBOHyIwK1y5gkSTW9avvSqwKz7lWT/i9xQUH1vLchFXqkHiMv6ViCIAiCcLkSgdplbng3ZV7artRdyg2+581TuwQHU3cDMLRcD92HXNKxBEEQBOFyJQK1y9wY7zFISETnRZNZmgk+Sg8bOaehLO+ijllmKCMi7xQAQ219wdKhpZorCIIgCJcVEahd5lysXAhzU6oSbE/ZDjYu4BKgbEw+cFHHPJZ9DKNswtNoxMdHDHsKgiAIwsUSgZrAeJ/xQFWgBuBbPU/t4hYUHMw4CMDQ8gqkHiMutXmCIAiCcNkSgZrAuO7jANiXto8yQ9m5fGqJey/qePtT9wDKQgJ8RaAmCIIgCBdLBGoCAY4BeNt6U2muVFZ/9lICN1IOQnl+s46VWZpJRF4UACM1LuDg3dLNFQRBEITLhgjUBCRJYpyPEpxtT9kOjr7g1hdkE8Ruadax/kn+B4DwCj3u1T1zgiAIgiBcFBGoCcC54c/tydsxy2boM0XZcHpDs46zJVEJ7K4oLTuX6kMQBEEQhIsiAjUBgCEeQ7DR2pBbkcvx7OPQ50plQ+xmMJuadIz8inwOZR4CYGJZGfQc11rNFQRBEITLggjUBAC0ai2TfCcBsDp2tZJPzdJRqfuZcqhJx9iWvA2TbCJIX0l3pz7g6t9q7RUEQRCEy4EI1IQa1wZcC8Df8X9TZq4EfyVw4/TfTbr/liRl2HNSWRkEX9UqbRQEQRCEy4kI1IQaA90H4mvnS5mxjA0JGyBgqrLhzMYL3rfUUMqeNCUtxxWl5dB3Vms2VRAEQRAuCyJQE2pIksQ1AdcAVcOf/leApILMk1CY0uh9/0n6B4PZgF+lgd623uAR2gYtFgRBEISuTQRqQi2zes1CJak4knWEBGPxudqfEb80eB9Zlvk26lsAZpSWIvW9CiSpLZorCIIgCF2aCNSEWjxsPBjtPRqA32N/hwE3KxsOfAYmQ733OZBxgOi8aCzNMnOLSiD46rZqriAIgiB0aSJQE+q41l9ZVPBTzE/kBVwBNm5QlApRf9S7//LI5QDMLinBycYTvAa2WVsFQRAEoSsTgZpQxwTfCfR17kuJoYSPIr+EIXcrG/Z+ALJca98z+WfYnboblQy3FhZD/7mgEk8rQRAEQWgJ4hNVqEMlqXh8yOMA/Hz6Z2L7TASNJaQdhaTahdpXRK4AlJQc3TW2MGpxWzdXEARBELosEagJ9RriOYQrfK/ALJt5K/IL5H5zlQ07l4LZDCgrPdfErQFgQUERjHsSrJzaq8mCIAiC0OWIQE1o0KODHkWr0rInbQ9fuHVDllQQuwn+fJCYnCie2vkUMjJzi4oJs/GGIXe1d5MFQRAEoUsRgZrQoO723bmn/z0AvHf6e54aMJVErY5/Tv/KA3/dRLmxnOHl5TyZmw9XvAgaXfs2WBAEQRC6GE17N0Do2Bb2W4iDzoE3DrzBuvxI1vl4Vm0x4VdpYEl+Bdqxj4uUHIIgCILQCkSgJlzQ3KC59HToydO7niavIo9eVu4El5Vwb9DVOAxZBJYO7d1EQRAEQeiSRKAmNMnQbkPZfP1mjLIRrUrb3s0RBEEQhMuCCNSEJpMkCa0kgjRBEARBaCtiMYEgCIIgCEIHJQI1QRAEQRCEDkoEaoIgCIIgCB2UCNQEQRAEQRA6qC67mECuKh5eVFTUzi0RBEEQBEGorTo+qY5XGtJlA7Xi4mIAunfv3s4tEQRBEARBqF9xcTEODg3nI5XkC4VynZTZbCYtLQ07OzskSWq18xQVFdG9e3eSk5Oxt7dvtfN0NJfrdYO4dnHt4tovJ+LaxbW31rXLskxxcTFeXl6oVA3PROuyPWoqlQofH582O5+9vf1l90SGy/e6QVy7uPbLj7h2ce2Xm9a+9sZ60qqJxQSCIAiCIAgdlAjUBEEQBEEQOigRqF0iCwsLXnjhBSwsLNq7KW3qcr1uENcurl1c++VEXLu49vbWZRcTCIIgCIIgdHaiR00QBEEQBKGDEoGaIAiCIAhCByUCNUEQBEEQhA5KBGqCIAiCIAgdlAjUmiA7O5sZM2ZgbW1NYGAgW7ZsqXe/8vJybr75Zuzs7PD19eWHH35o45a2LL1ez4IFC/Dx8cHBwYHx48cTERFR77633347FhYW2NraYmtrS0hISBu3tuWNHz8eS0vLmmuaNm1avft1tce9+nqrfyRJ4tdff613387+uL/wwgsEBwejUqlYtWpVrW1vvPEGbm5uODs788QTTzRaj2/FihX4+Phgb2/PggULqKysbO2mX7KGrn3FihWEh4djZ2dHr169+OSTTxo8xrZt21CpVLWeLzt37myL5l+Sxq5do9HUup6kpKQGj9OVHvd77rmn1nVrtVpmzZpV7zE66+N+oc+0jvqaF4FaE9x///14eXmRk5PD//73P+bMmUN+fn6d/V544QXy8vJITU1l1apV3HvvvZw+fbodWtwyjEYjvXr1Yt++feTl5XHVVVcxe/bsBvd/6aWXKCkpoaSkhMjIyLZraCtasWJFzTWtX7++3n262uNefb0lJSXs2bMHKysrpkyZ0uD+nflxDwgIYNmyZQwdOrTW7evWrePjjz9m//79REZGsnbtWpYvX17vMSIiInj00UdZvXo1ycnJJCQk8Morr7RF8y9JQ9eu1+v55JNPyM/PZ82aNbzwwgvs2LGjweP06dOn1nNmzJgxrd30S9bQtQNcccUVta7H19e33mN0tcf9k08+qXXdYWFhjb7fd8bHvbHPtA79mpeFRhUXF8s6nU5OS0uruW3MmDHy119/XWdfT09Ped++fTX/v+WWW+SXXnqpTdrZFvR6vSxJkpyTk1Nn22233Sa//vrr7dCq1jNu3Dj5hx9+uOB+Xflxf+KJJ+R58+Y1uL2rPO7/fqznzZsnv/HGGzX///LLL+UJEybUe9+nnnpKvueee2r+v2XLFrlnz56t19gWdqHn+U033SQvWbKk3m1bt26VAwMDW6tpre7f1758+XJ56tSpTbpvV37co6KiZAsLC7mgoKDe7Z39ca92/mdaR37Nix61Czhz5gwODg5069at5rb+/fvX6TnIz88nIyODsLCwRvfrzPbu3YuHhwcuLi71bn/rrbdwcXFh5MiRjX4D70wefPBB3NzcmDx5MidOnKizvSs/7rIs88MPPzB//vxG9+uKj3tUVFSTH9P69o2Pj6e8vLzV29naTCYTBw4caHRIOyEhAXd3dwICAnj55ZcxmUxt2MKWt3v3blxcXAgODm502LcrP+4rV65k5syZjdah7AqP+/mfaR35NS8CtQsoKSmpU5DV3t6ekpKSOvup1Wqsra0b3a+zKiwsZNGiRbz66qv1bl+8eDGxsbGkp6dz//33M2vWLJKTk9u4lS3rzTffJD4+nqSkJCZPnsz06dMvq8d9x44dlJWVMXXq1Ab36YqPO9R93Tf2mNa3b/Xtnd2zzz6Lt7d3g8+BoKAgjh07RkZGBn/88Qc//fQT7733Xhu3suWMGzeOiIgIsrOzWb58OS+//DK///57vft25cf9+++/b/QLWld43P/9mdaRX/MiULsAW1tbioqKat1WVFSEra1tnf1MJhNlZWWN7tcZVVRUMHv2bGbMmMEdd9xR7z4DBgzAyckJnU7H/PnzGTFiBJs2bWrjlrasoUOHYmtri5WVFU888QS2trYcOHCg1j5d+XFfuXIlN9xwA1qttsF9uuLjDnVf9409pvXtW317Z/bJJ5/w22+/8csvvyBJUr37eHp6EhQUhEqlIjg4mGeffbbBwKYz6NmzJ35+fqhUKoYNG8ZDDz3U4PV01cd9z5495OfnM3369Ab36eyPe32faR35NS8CtQsICAigsLCQjIyMmtuOHz9eZyjAyckJT0/PWitI6tuvszEajcybNw8vLy+WLFnS5PupVF3vqVXfNXXVx72yspJffvnlgsOe/9ZVHvfg4OAmP6b17duzZ0+srKxavZ2t5ccff+TVV19lw4YNuLq6Nvl+XeXxr9bY9XTFxx2UL2jXX399s2pcdqbHvaHPtA79mm+12W9dyPXXXy8vXLhQLisrk//44w/ZyclJzsvLq7PfY489Js+YMUMuKiqS9+7dKzs4OMinTp1qhxa3nNtvv12eMmWKXFlZ2eh+v/zyi1xSUiIbDAZ51apVsp2dnRwfH982jWwF+fn58saNG+WKigpZr9fLS5culT08POTCwsI6+3bFx/3333+X/fz8ZLPZ3Oh+nf1xr6yslMvLy+UxY8bI33zzjVxeXi6bTCZ57dq1co8ePeSzZ8/K6enpckhIiPzll1/We4wTJ07Izs7O8uHDh+WCggJ54sSJ8nPPPdfGV9J8DV37hg0bZDc3N/n48eMXPMbWrVvlpKQkWZZl+fTp03JYWJj8v//9r7Wbfskauvb169fLWVlZsizL8uHDh2Vvb2/5xx9/rPcYXe1xl2VZNhgMsqurq7x169ZGj9FZH3dZbvgzrSO/5kWg1gRZWVnytGnTZCsrKzkgIEDetGmTLMuy/N1338nBwcE1+5WVlck33XSTbGNjI/v4+MgrV65srya3iISEBBmQLS0tZRsbm5qfHTt21Ln2UaNGyfb29rKDg4M8dOhQefPmze3Y8kuXlZUlDxo0SLaxsZGdnJzkCRMmyIcPH5Zlues/7rKsfDl55pln6tze1R732267TQZq/VR/SL322muyi4uL7OjoKD/++OO1gtbq10G15cuXy15eXrKtra182223yRUVFW19Kc3W0LWPHz9e1mg0tV7zixYtqrnf+de+ZMkS2cvLS7a2tpb9/Pzk5557TjYYDO11SU3W0LU/+uijspubm2xjYyP36dNHfu+992rdrys/7rKsBCs+Pj41gdv5usLj3thnmix33Ne8JMuNZHQTBEEQBEEQ2k3nGVgWBEEQBEG4zIhATRAEQRAEoYMSgZogCIIgCEIHJQI1QRAEQRCEDkoEaoIgCIIgCB2UCNQEQRAEQRA6KBGoCYIgCIIgdFAiUBMEQRAEQeigRKAmCIIgCILQQYlATRAEQRAEoYMSgZogCIIgCEIHJQI1QRAEQRCEDkoEaoIgCIIgCB2UCNQEQRAEQRA6KBGoCYIgCIIgdFCa9m5AazGbzaSlpWFnZ4ckSe3dHEEQBEEQhBqyLFNcXIyXlxcqVcP9Zl02UEtLS6N79+7t3QxBEARBEIQGJScn4+Pj0+D2Lhuo2dnZAcofwN7evp1bIwiCIAiCcE5RURHdu3eviVca0mUDterhTnt7exGoCYIgCILQIV1oepZYTCAIgiAIgtBBiUBNEARBEAShg+rQgZper2fBggX4+Pjg4ODA+PHjiYiIaO9mCYIgCIIgtIkOHagZjUZ69erFvn37yMvL46qrrmL27Nnt3axaykuz27sJgiAIgiB0UZIsy3J7N6KpKisrsbS0JDs7GxcXl1rb9Ho9er2+5v/VqykKCwtbbTHB0ZM/8ODBV1jkM4V5E99Eq9a2ynkEQRAEQehaioqKcHBwuGCc0qF71P5t7969eHh41AnSAF5//XUcHBxqftoih9ovJ76gUKXizbTNXLVyBFvi/mr1cwqCIAiCcPnoND1qhYWFDBs2jCeeeII77rijzvb26FEzGvWs/vsBPszcTY5GDcBn495lhN+kVjmfIAiCIAhdQ1N71DpFoFZRUcG0adMYOHAgb7/9dpPu09Q/QEsoi9vKy5vv5y9LNT209vw69x8s1Batek5BEARBEDqvLjP0aTQamTdvHl5eXixZsqS9m1Mv694T+L9B/8HNaCTRUMRXxz9r7yYJgiAIgtAFdPhA7e6776a8vJwVK1Z06OLqduG38ESZ0r4vTn5JYlFiO7dIEARBEITOrkMHaomJiaxYsYIdO3bg5OSEra0ttra27Ny5s72bVpdGx9SB9zCyrJxK2cTSQ00bohUEQRAEQWhIh6712aNHDzrBFLoa0qDbeWLPUmZbw7bkbWSVZeFu7d7ezRIEQRAEoZPq0D1qnY6lPb0HLCC8Qo8ZmTVxa9q7RYIgCIIgdGIiUGtpA2/hmuISAFaf+a1T9QgKgiAIgtCxiECtpTn3YqpFN6zMZhKKkziefby9WyQIgiAIQiclArVWYBMwlSmlZQD8Hvt7O7dGEARBEITOSgRqrSFgMrNLSgH4O/5vygxl7dwgQRAEQRA6IxGotYYeIxlk0uBrMFBmLGNb8rb2bpEgCIIgCJ2QCNRag8YCqfcErqga/tyZ2gHzvgmCIAiC0OGJQK21BExmdHkFALtTd2OWze3cIEEQBEEQOhsRqLUW/8mEV+ixNZvJ1+cTmRPZ3i0SBEEQBKGTEYFaa3HwRusRyoiqXrVdqbvauUGCIAiCIHQ2IlBrTT1GMbqsHBCBmiAIgiAIzScCtdbkM4RRVT1qETkR5FXktXODBEEQBEHoTESg1pp8BuNhMhFYaUBGZk/anvZukSAIgiAInYgI1FqTkx/YuDG6TEnTIYY/BUEQBEFoDhGotSZJAp8hNWk69qTuEUXaBUEQBEFoMhGotTafwfSv0GOJRL4+n/jC+PZukSAIgiAInYQI1FqbzxC0QJhBSXh7JOtI+7ZHEARBEIROQwRqrc1rAEgqBpQUAXAkUwRqgiAIgiA0jQjUWpuFHbgHM0ivB0SPmiAIgiAITScCtbbgM5h+FXpUQGpJKhmlGe3dIkEQBEEQOgERqLUFn6HYyjKBshaAo1lH27lBgiAIgiB0BiJQaws+gwEYVDVP7XDm4fZsjSAIgiAInYQI1NqCiz9orBhQVgKIHjVBEARBEJpG094NuCyo1OARzMAMJUA7k3+Gosoi7HX27dwwoT5Gs5GV0SvZnrIdg8mAWTYztNtQFvVbhKWhHFRa0NkoCY0FQRAEoRWJQK2teITimnoYX40tScYSjmUdY6zP2PZulfAvMXkxPL/neaJyo2rdfiLnBJsjV/JKSjz99ZUgqaHXOJizAiwd2qexgiAIQpcnhj7bimcYAANNakAMf3ZEO1J2MO+veUTlRmGns+PJIU/y7oR3eXnYs7ijIcFczq3dPNhgbQWyCeL+gR9uBEN5ezddEARB6KJEoNZWqgK1fkV5AJzMOdmerRH+5WzBWZ7Y8QRGs5Ex3mP44+o/uDn4ZiZ1G8k1u7/it8R4riyrwCxJvOjjR8qNK8HCHhJ3wy93gMnY3pcgCIIgdEEiUGsrHiEAhBZlARCZE4lZNrdni4QqhfpCHvznQUoNpQzyGMSyCctws3ZTNu77GJL34aCz5/VpXxPuFk6JoZSn4lZhnLcSNJYQsw62vd6+FyEIgiB0SSJQaysWduDkh3+lAQuVlmJDMUlFSe3dqsueLMs8ufNJkoqT8LLxYun4pWjVSr47SnNg51Ll92lvofEbyRtj38BOa8fx7ON8XHAcrv5Q2b7/EyjLa5+LEARBELosEai1Jc8wtECQzhmAiJyI9m2PwIaEDexO3Y2F2oL3Jr6Hs6XzuY3b3oDKYujWH8LmAOBt683zI54H4MuIL0nuMRQ8QqGyBA583h6XIAiCIHRhIlBrSx7KPLUws/JnF/PU2leZoYy3Dr0FwJ1hdxLoHHhuY84ZOLxc+X3KK6A691K5sueVjPIehUk28VXkchjzqLJh/8egL2mr5guCIAiXARGotSXPUABCiwsAOJkrArX29HnE52SVZeFt682CkAW1N/7zCpiN0OdK6Fk3jcrCsIUA/BH7B5l+I8C5N5Tnw+EVbdByQRAE4XIhArW2VLXyMzQnEYBTuacwmAzt2aLLVlJREl9Hfg3AE0OewFJjeW5jcQZEr1F+n/hcvfcf6DGQQR6DMJgNrIj6FkY/omzY8z4Y9a3ZdEEQBOEyIgK1tuTQHSwd8K2swE5jTaW5ktMFp9u7VZelD45+gMFsYJTXKCZ0n1B747HvlTxp3YfV9ILWp7pX7ZfTv5DXZwrYdYOSDDizqTWbLgiCIFxGRKDWliQJPEKRgDBLD0BJ0yG0rfjCeP5O+BuARwY9gnR+KSizGY58o/w+8NZGjzPCawTBLsFUmCr4/szPEHqdsiFqdSu0WhAEQbgcdfhA7YUXXiA4OBiVSsWqVavauzmXzkPpoQmRlepdYuVn2/sy4ktkZMb7jK+9gAAgcRfkx4PODkKuafQ4kiTVzG37M+5PzH1nKRti/gZDRWs0XRAEQbjMdPhALSAggGXLljF06ND2bkrLcA8CIKy8DBArP9taSnEKa8+uBWBhv4V1d6juTQu7Xim8fgHju4/HTmtHemk6hzUS2HsrKT3Obm3JZguCIAiXqQ4fqN18881MnjwZS0vLC+/cGbj1BSA0NwWAuII4ygxl7dmiy8pXJ7/CJJsY6TWSMLew2hvL8iDqT+X3Cwx7VrPUWDLFbwoAa+L/gr5XKRsiV7dQiwVBEITLWYcP1JpKr9dTVFRU66dDqupRcytIxt3KFRmZmPyYdm7U5SG7LJvVsauBBnrTIn8Dk17Jd+c1oMnHndlrJgAbEzdSHnilcmPMerH6UxAEQbhkXSZQe/3113FwcKj56d69e3s3qX5WTmDrCUCQtTcA0bnR7dmiy8ZPp3/CYDYQ7hbOII9BdXeoTskRdr2y8KOJBnoMxNvWm1JDKdvkUuXx1RfC2e0t1HJBEAThctVlArWnn36awsLCmp/k5OT2blLD3JQJ7EEqawBO5Z1qz9ZcFipNlfwU8xMA84Pn192hLA/idyq/Vy8KaCKVpGJGrxlA9fBn1f3F6k/hcpOfAJtegK2vYzzxE7EJWzmSeYSdKTtJK0lr79YJQqekae8GtBQLCwssLCzauxlN494X4rfT16Aku43OEz1qre3vhL/Jq8jDw9qDSb6T6u5w+m8ld5pHKLj0bvbxZ/WaxWcnPmNP2h5yh76Cy8HPIXYzyHKzeucEoVPSF8POt2Hvh8imSrZbWfGWiyNJWm3NLhIS47qPY37f+QzzHFY7LY4gCA3q8D1qBoOBiooKzGZzrd87NTdlnlrfolwAYgtiRYWCViTLMiujVwIwL2geWpW27k7Vw57N7E2r5ufgR7BLMCbZxA7KQGMJJZmQLeYfCl1cRSF8PhF2vUOebOSenn140NONJK0Wa7MZX4MBf8kKGZltydu4e+PdvLT3JQxm8Z4nCE3R4QO1u+++GysrK3bu3Mmtt96KlZUVO3bsaO9mXRp3ZeWnV3Yc9jp7jGYjsQWx7dyorut49nGicqOwUFtwXcB1dXfQl0DsFuX3iwzUQEnVAbAtbbdS1QAgvpM/VwWhMbIMfzwAOacptfPkvuDh7KECrUrLnaF38k/oI/yVls3vZ2P4Q/Zibp8bUEkqfj3zKw9seYCSypL2vgJB6PA6fKC2YsUKZFmu9TN+/Pj2btalqZqjJhWlEOToD4h5aq3p++jvAZjRawZOlk51d4jdpKz2dO4F7sEXfZ7xPuMB2Ju+F73fKOXGeLGgQOjC9n0M0X9iUGl5pM8AIktTcLJw4qeZP/HwoIexGXIX3PoH6GzplbCPZ022LJuwDCuNFXvS9rBgwwJKDaXtfRWC0KF1+ECtSzp/5aelGyDmqbWW3PJcNiUptTfnBc6rf6eaYc+rLmk+WZBzEO7W7pQbyzng4K7cmLATzKaLPqYgdFgph2DTcwC8GDaBvXmRWGms+HDSh/g7+Z/bz280TPuf8vs/rzJe48zyK5fjbOnMqbxTPLPzGcxyJ5/OIgitSARq7aUqn1qQWVnPIVJ0tI4/4v7AaDYS5hpGX5e+dXcwVsLpjcrvlzDsCUpJqXE+4wDYXp4MFvbK/J2ME5d0XEHocGQZNj4LZiPbgybyZ9Ep1JKapeOX1k0kDRA+H4JmgtkAvy0kxL437018D61Kyz/J//Dp8U/b/hqES5JclMxXxz/j/tXX89Sv17Ds52vY8Nd9mIrT27tpXY4I1NpLVYWC4AqlKkFMfgwm0fPSosyymZ9jfgZgTp859e+UvF8p+WTjBl4DL/mc1fPUtqfuRO5RNfwp8qkJXU38dkjaS7nGgtfUxQDcGnIro71H17+/JMGsZcrrLDsadi+jv1t/nhuu9Mh9dPwjtiaJsmudQUpxCrf/fTvTf5/OO8feZ0dhDH+VxPJFWSyP5exk7qoJ7PvjLijNae+mdhkiUGsvVfPU/HKTsVRbUm4sJ6k4qcUOn3Ymn12/nGHDFyf5/e0jbP02moyzhciy3GLn6Oj2pe8jpSQFW60tU/2m1r9T7Gbl396TQHXpL4ehnkOxVFuSUZrBaa8Q5UaxoEDoSmQZtr0BwKeBI0gry6SbTTfu6XdP4/ezcYUrlfux9wMoy+OagGu4MehGAF7c+yIFFQWt2HDhUm1J2sINa27gcOZh1LLM8PJyniyu5FFdd+Za+2EnS8TotNxdsJ8Xv58ketdaiAjU2kvVyk91zmn6OPUBWmZBQV5aKX99eJzf3z7K8c3JxB7KIu1MAVG70/n1zcOs+u8BMuM7aHmtFvbL6V8ApcSTtda6/p2qV3v6X9Ei57TUWDLcazgA23RVNybtVYZYBaErqOpNi7W05uvyRACeHvp0w6+x84VcC+4hoC+CPe8D8Njgx+jl0Iu8ijzeOvRWa7ZcuARfRHzBw1sfpthQTP8KPetS0vjccRg3L9jNghvX8eycNfw1dxs3dRuLSoZfdWae+2kGJtGzdslEoNZeqnKpUZRCkEMv4NLnqUXvSWPVKwdIiMhFUkkEjfBk9JwArlgQTOBwTzRaFXlppax+5wiJkbmXegUdkizLmMwyOeU5NUMpcwIbGPYsSofMCECC3hNbrA3Vqz935J9ShnoMZZBysMWOLwjt5rzetA96hGCUTYzvPp4JvhOadn+VCib+n/L7/k+gJAudWsdLI19CQuLPuD/ZmbKzlRovXKw/Yv9g2ZFlANxaVMLy9Ey8Rj8Bc79TekqrOFk58/SUD3lz0OOoZZk1GgNP/zQNY8Xl0TnQWrpMZYJOx8pRWflZkkGQ1hG4tJWfxzYnsfsXJRebX5gLI6/zx8nTpmZ74DAlaNv0ZSRJUXms+/AEE2/rS+Awz0u5ig6hrNLIDweS2RuXy+HEPEorTfTqvQ+jykioS7+aHss64v5R/vUeCDYuLdaekV4jATiZe5LiHiOwi/pT6VWrTtlxOagsU+YiaaxAZwMO3RsdWi6pLOFgxkHii+IpNZRSZijDXmePh40HXrZeBLsEY6+zb8MLEOqVdhSS9hJnYcWWykwkJB4Z+EjzjhE4XZkPmnYEdr0DV75OuHs48/vO57vo73h538v8cfUfTeuhE1rdvvR9vLjnRQDuKDXySG4eBM+GcU82uEp+atitqM0mHj/6NutVFfT46w7uv+6Xtmt0FyMCtfbk1gdKMgiuWkNwKu8Usiw3u7TKgTVnOfhXAgADJvsy4tre9R7D0kbL9Pv6seXraM4czGTLiigc3Kzw7OVwqVfSbpLzyrj7m0Ocyig+71YzycatqHRwOjaU48kF9O/uWPfOsUrajpYa9qzWzbYbvna+JBUnccjJkwmgpDK4XMT8DWsfgeLzaju6BcHVH4HPoJqbZFlme8p2VkSu4HjWcYyysdHD9nToySCPQYzxHsPwbsPFB3l7OPodAF/6BoExl0m+k+jl2Kt5x5AkmPgsfHctHPwSRj8Ctu48OOBBtiZvJbUklS8ivuChgQ+1wgUIzZFclMwjWx/BKBuZhi2Ls6KUoevZH10wldEV/Rfwckk6z8T+wGfFpxgauYohIQ2kSBIaJYY+25OrsqDAvyQftaSmQF9AZllmsw5xam96TZA2fHYvRl7n32igp9aomLwgGP/B7sgybFoeRWVF4x+QHdWuMznM+mAXpzKKcbXV8fS0IH67bySvz7dApctHMluRm9mXOZ/u5ZfDKbXvbDJCXNUqsxYO1ACGdVMqE+xXVf1tUw4ow0ZdWWUp/HoX/DBXCdIsHcDaFVRayD4FX16hFOw2VhKZG8kdG+7gwX8e5HDmYYyyEV87X2b2msmNQTdyR+gdXN/nekZ7j8bH1geA+MJ4fjn9C4u3Lmb0qtEs3LiQb6O+JbEoseUuocJIemwBBVllyOYu/ng1l6EcTv5CikbNOmM+AHeF3XVxx+o9EbwHKYmmDy0HwFprzeNDHgfg68ivSS1JbZFmCxfHLJt5dvezlBhKCLftwX8TolCpdTD3W6WXvAlmjXqG2WoXzJLEUwdfo6C8a065aW2iR609Va38tMiJpZdjL87knyE6NxpPm6YNR2bEF7JtpVJLcvB0PwZd6dek+0kqifE3BZJxtpCi7HJ2/XyGibfUk2OsA4tKK+KOrw9SaTTT38eBT24ZRDcHKwC+/ucvAOYEziZR5cPm6Ewe+/k45ZVGbhnhpxwg7QhUFIClY4uk5fi3Yd2G8fPpn9lffBbUOijLhbyzF1XwvdP46zGI+BkkFYx4AMY/DTprKMuD9U9CxE+w+13W5J3g+coEjGYjFmoL5vedz5w+c/Cx82nw0HkVeZzIPsGetD3sSNlBakkqe9P3sjd9L28efBOduRse6oHM6jOFhUPHoVapm9xsk8HM0U2JxB7OIjetFKriM62lGs9eDgyZ7kc3f8dL/ON0Aaf+gopCVnTrjgkzI7qNIMQ15OKOJUkw/D749U44VNWrptExsftEhnkOY3/Gft45/A5Lxi1p2WsQmuz76O85knUEK40Vr6clYyEDI+5v9nvY0zNWcOzX6SRo1by4bgHvXvdn6zS4CxM9au3JtWruVE4MfZ2VQKmp89RKC/Ss/yQCk9FMz/6uDJ3Zs1mntrDWcsXtwSBB9O50zh7Lbtb921Op3sgD3x+h0mhmXB83flw0oiZIyyzNZHuKkrdsfvA8PrtlEPeMU95YXloTxd64qm90NWk5JoC65b+vDPUcqpym8Cw53aoSgHblBQURv8Dx75Ug7ebfYMp/lSANwNoZrvsc+bqv+MzRgWcqYjGajUzyncTaa9byyKBHGg3SAJwtnRnffTzPDHuGe3p9gTbtKSoyZ2As9UeWVVSq0kmW/+KjmMUM+nos9214mh0pO9Cb9I0eNz22gB9fPcD+P+PJTVWCNBsHHWqNCkOFieSoPH5bcoSNX0ZSkt/4sbq8o9+Rp1Lxu6USBN/d7+5LO17w1WDXDUoyIfJ3QEka/fiQx1FJKjYkbOBw5uFLbbVwERKLEmsWDzzmOACf3ARlTvWY/zT7WNZOfrwVeBsaWWZLSTw7zq5v4dZ2fSJQa09VPWrkJxDkoAQTTQnUZLPMpuVRlBVW4uxlwxULgpFUzS995N3HiQGTfQHY/WssJlPnKOPy3B8nOZtTiqe9Je/MDcdSe6735LfY3zDJJga6D6SXYy9UKoknrwzk6nAvjGaZ+78/QnJeGZypnp82uVXa6GTpRJCzsrJ3v2t35cbkA61yrnaXn6DMSQMY+7gS/NbjPUMK7zsp8yEXFBSx1GVUk3uPAcxmmbc3xvDwj8fJK3TEyXAFd/Z+g7eGrmZuj6foYTES2WSJSVXEzoy13L/lfsasGsMjWx9hTdwaCvWFtY53Ymsyv719hPyMMqzsdUy8NYjb/zeK2/83mruXjWXus0MJHu0FEpw5mMlPrx0gO6m4gdZ1cQXJcHYba2xtqMRMsEswgz0GX9ox1VoYcqfy+76PaqYGBDoHcl3AdQC8dfCtyyr3Y0cgyzIv7HmBClMFw90HMuf4WmXDFS+Chd1FHTNo1OPcbFDyFb25979UmkS6ouYQgVp7svUACweQzfTVKCvampJL7fg/yaTG5KPRqZi2KAyd5cX3CA2Z0RMrOy1F2eVE7+74yQn/OJbKb0dSUUnw3o0DcLbR1WwzmU38duY3oHZKDkmS+N91/QjzdiCvtJLHv/4HOe2ostF/Uqu1dZhn1Tw1bdUNKV0wUJNl+P1eJS9W92Ew9ol6d1sfv54vIr4A4Cm7UB7NL0D15wOQG9ek0xhNZh5adZT3/1FWNt8zrjd7nprIY1MDmRbck2fHz2ftvE/ZeN1WBlk8SWXecMwGe8qN5WxO2swzu55h/I/jeeifh9iatJWTu1LY+eMZkCFouCc3vTCMviO9sHGwAECtVuHqY8uEm4O44ekhuPjYUl5sYPXSI6Sezm+BP1wnc/wHZGR+cVZqE1/f5/pmL3qq16AFoLGE9GNKlZAq94ffj7XGmsjcSDYnbb708whNtilxE4czD2OptuQl3JEqS8BrAPSbe/EHValYNPQxXI0mEo3FfHvi85Zr8GVABGrtSZKUlZ9AUKXyDSOjNKPR7Ny5qSXsW30WgFHXB+DocWkr37QWagZP9wPg0F/xGCs7bhmrCoOJ19cpgeziSX0Y2tO51vZdqbvIKM3A0cKRyT1q95RZatV8dusgnG10uGfvQUIGjzCwa730JDULCspSlWlPmZGgL2m187WLs1shaY+ShuPaz+sdRo7Ji+H53c8DsCB0AfNnfwc9x4GxAv58CMwX7sl9ff0p1p5IR6uWePP6fjw1LQiNuu7bl5eDLcvnzueu4P9QGvs0pfEPMNTxBvo49cEoG9mavJVlP3/Ftu+U51HoxG5MvK0vljbaOseq5uZrxzX/GYhXgCOVFSbWvHec5FN5Tf0LdQ0nf+OwpQUJkhErjRXTe05vmePauEJY1Zeq/efqfbpYuXBryK0AvH/0fYzmzrngqbOpNFWy9PBSAG4PnIfX0R+UDWOfuOTKLbZhc3nEYAnApxFfkFnavIVzlzMRqLW3qpWftvlJdLdThsgaGv40Gc1sWh6FyWimR5gLIWO8WqQJIaO9sXO2pLSwkohtHXel1Yo9CWQUVeDtaMU94+umBPj5tFLX86reV2GhtqizvZuDFS/MCmac+jgA+V5jW7W9gzwGoZE0pJVlkuLoA7JZWcTQlexU3tQZdBs49aizubiymMVbF1NhqmCk10gWD1gMKjVc9R5orSFxFxz5utFTrD6aype74gFYNm8ANwzu3uj+kiTx2JRAHrkiEHOFD1v3DeTx0M9YffVqFnjey8TYW5FQEeW+h+fN9/Dz6Z8xy40HixZWGmY91B+/fq6YjGY2fHaSgsyyRu/TZeTEQnY0v9opw17Te07HRtu0VX9NMqRq5eiptVB6blXgbcG34WjhSHxhPGvi1rTY6WRZJjethPjj2Zw5lEnM/gwKsi6Tx/ICVkavJLUkFTcrNxaUVip1kN36Qp8rL/3gKjUzRz5N/wo95bKRj4+8d+nHvEyIQK29VfWokR1TM6epoUDt8N+J5KaUYGmrZcLNQS0z9ACotSqGVC1GOLwhgcryjvfttaCsko+2KsNe/5nSBwtN7VV9GaUZ7ExVMppf3+f6Bo9zVT9PrtCeBODdBF/MjaRgqCg1ELU7jb8+OsFvSw6zeukR/vrwOMe3JFOUU37BNltrrenn1g+A/R5+yo1daZ5ayiFI2AkqjbLKsx4fHP2A1JJUvG29eXPsm+dWYzr5wSSll41Nz0Nh/V8QTqYW8tRvJwC4f0Jvpod1a1LTJEli8RUBXD/IB7MMi1cdxR5vuu0fhFpWo+ulJ67fbvL0efx333+5ed3NDVcGMVTAoeVotr7AVK/leDrmoS8z8tdHJ6goNTSpPZ3aqTUUqlRstFWCs8ZeXxfFKxy69QdTJZxYVXOzrc62Jv3Hh8c+vODCkAupKDFw+O8EVv33AKtePsC6jyPY+EUkm5dHsfL5fax8YR/7/ojrkO9/bSGvIo/PTnwGwEP97sH6gDJVgdGPtEgdZABV6LX8x2QLwB9n15BcnNwix+3qRKDWiPfCIAAAnotJREFU3qp61Mg5XbPy81Ru3XlquaklHF6XAMDYuX1q5tK0lMDhnjh6WKMvNRK9p+PNVft4WxxFFUaCPO24Oty7zvZfz/yKWTYzxHMIPR0aXgErZZzAwVxAqWzJ9+ndWHWw7huFQW9i28pTLH98F1u/PUXCiRzSYwtJPV1AQkQuu34+w7fP7uXXNw+Tdqag0XYP8lASvB6xULr8u9TKz+retH5zwbFuL1dUbhSrYpQP3hdGvICDxb8SKw9dCD5DlfltG56uc3+90cTiVUepMJgZH+jGo5MDm93El68OobebDZlFet5/9yB5aaVY2eu4+d5JrL12DU8NfQobrQ0RORHc9NdN/HDqh3OT12VZWc36wRBY+zDseR/Nsa+Ypn0UW1UWBZllbPxwb6PBfpcQvYa1ttZUIhPoFEiIy0Wm5GjMQGWYkyPf1Mo3OC9oHh7WHmSWZfLjqR8v6tCyLBN7OIvvX9rHvtVnyUsrRaWRcO9hh3cfRzx7OaBSSRRklnF4fSIrX9xH7OGsy24Rw+cnPqfEUEJf575cVZAPZTng6Auh17XcSVRqBgx/hJFl5RiR+ez4pxe+jyACtXZX3aOWc4a+TsoH0fk9avmllaw/kc6PHx7DbJbxCnbCf7B7izdDpZLoP0n5sD2xLaVDJfvMKqpgxZ4EAJ68Mgj1v1a4Gs1GfjtdtYigTwN1PatVpeXIcR+BAQ1vb4yhuOJcr0h2UjE/vXaQyJ1pmM0yLt62DLuqJ1cuDGXKXSGMut4frwBHJAkyzhby+9tH+OujExRm19/DVhOoGarmNKUc7BqJb7OiIeYvQIJRD9fZbJbNvLrvVcyymWl+0xjhNaLuMVRqmLVMSekR9Qck7K61+ZNtZ4nLLv1/9s4yuopzbcPXbI+7KyFESCAEd3d3bQstFdpS49RdaU/pKTWoQKlQwd3dPSSEuLu7Z+v3Y0IgDYEEAqX9uNZiJWRmvzPZSWaeeeS+sTVV8sWMTo1+7s3BWCHjm9md8dJLccgRf86DH/TDyEyBTCJjjv8ctk3cxhD3IWgNWhafXczbp96mtqYU1swWdb5K08DMGXo+DQNfx7jLOMbYfIpMqCE9SUvY2iMtPq9/DGVZkBnCVlMxCzK53eRWy+Q3oMM0sRSeH9Mg66yUKnmq01MArLi8ggp1y3o81dVa9v4Qwd4VEVSXa7ByMmHQg3488mlfpr3WjYmLOjPl5S488r9+DJ8fgIWdEVWlavauiGD/KrHN5P8DeVV59a0jzwc/g+TMMnFDn+daX76ow1SeqhavgdsTt7eqYPW/lfuB2t+NpQdIlaCrxU8mXgxTy1I5Ep/O+G9OEPzBflatCsdQpKYGA29mZDFx2Umis1vf5Na3hyNKYxll+dX3lGn76jOp1Gr1dHa3ZKCvXaPtxzKOkVedh5XSiiHuN5niTDgIgGu3cXjZmVBYqWb5EXHyMDm8gA3/vUBJbhUmlkomPN+JmW91p+voNrTtbE+7rg50GurOpP90Zu4nfQjo74IgEUgJL2Dth+eIOZ3d6Cm8k30nJIKEzJoCcuR1wrelGY1O6x/HObFEgv/Yqw8b17ApfhPhBeGYyE14sduLTa/j0F6c/APY8yroxWGWpPwKltWVut8e1x5LY0VTK9wUHztTphrEsl20sR5zr4aeofbG9iwduJRFXRYhESRsSdjCgrVDqYrbLU4kDnoTngmBkYth4CswcRm2L2ykX9tTAJw9qiH/4r9U7ytmJ8lyGdFKBTJBxqg2o+7McVQWEDBJ/Pzirw02jW87Hk9zT0pqS/gl6sb9jNdSVaZmy9JQEkPzkUgEuo7xZMbr3WjfxxmlccPhEaWRjHbdHJj5dne6jfFEIhGIP5/LzuXh/1jnlpbw4+UfqdXVEmwfTK/KSihJFcXAg2a3/sHkRgR1eIB+VdXo0PP9/azaTbkfqP3dSKRg2w4A27I8bFS2GDAw/49thGeUYq0T6FcrXlSiHSRUS+FSRinjvznBssMJaFtR+0yulOLfRxxQCD98bwQTNRodv59NA+DRfl7XfZr/M0acTJrYbiIK6Q1u6NUl9U/r0nZDeX2UWGr+8UQyl8Jy2bciAr3OgGdHW2a+2R1XP+smlzKxUDJwti8z3+qOk7cFmlodB3+JZt+PkQ0u7CZyk/rew4t2dSXZ7LDmfvv3Jlp1vUApXec32lyjreGb0G8AUWbB3vgmGeBBr4syNTnhogyEwcAbmyNQ6/T097FjXMfm9aU1RcTRTAzlGmqlsE9ey6d7GrcWCILAw4EP892ApZgaBC5QwzNOjlTP+hMGvHRVvPcK1m3wf/YNvKzi0SNj30+xaHISbus870mit7HbRAxyezn3wkpldeeOdaX8GbkJaq4+iMoksnrfz18jf6WwGTZEZQXVbPoshPy0cozM5Ex+uQs9xnkhld/4lieTS+k+zosxCzsiU0hIjypi6xdh1Fb9e3sRcypz2BAnGqY/1ekphPN1vWnBDzT+vW8tus3n6RLxZ7wzaQdpZWl35jj/Eu4HavcCdQ4FJWkRlJU6ACBRZTGrmxsvW9shNYBbe2tWvDuQM68PYai/AxqdgSV7Y3lpQ/h1eym0xcVUnj1H+aFDlG7fQeWpU+hKSm56Kh0GuCAIkB5VRFF2Zat+m7fCtrAsiirVuFgaMby9Q6PtSSVJnMk+g0SQMMP3Jjo/yUfBoBPfbysPhvjb07utDSa1Bo6sjEKr0eMRaMPIJwJRmTYt13At1k4mTFzUmR4TRHHdhAt5bPjkAsU5V9+7zvaiRVWImaX4haywZq19z5JwAKqLRaXyNo0nZzfGb6SwphBnE2dm+jXDhNnEFgbU6a8dfJ9dIQmcTipEJZfw0cTA2yq11VRqOL9TnBj1G+aKWoA159MJTbuOFprBQK+zP/NtdjbGegPnlHKeSfyjySZ2QWHEoBenYSwro0TjyOnlm5olNfKPoaoIQ8pJdpmKN+s7lk27glsPsWdXUwURGxpsGuI2hDZmflRpq5j8xwcM/t8Run54gNkrzrBkbwxnkgrrr4OVpbVsWRpKaV41ZtYqJr/YBQdP8+sdsUnc29sw4YVglCYy8lLK2Lsi4h8jCN5SVl5eiVqvpotDF3oo7OraQ4SrYsR3Akt3AtoMo29VNXoM/BLZ/Ezp/0daHKidOHGCpUuXsm/fvkbbnnrqqVY5qf931DkUHDt1kooyMRgZ2knDDAtLClPLkauk9VOe9mYqVjzUhSVTOyKVCGwOzWTpgXgANLm55H/1NclTpxHfuw9pc+eS8dTTZL30EmmPzCeuZy8Sho+g4LvvmgzazG2N8OxoC8DlvzmrZjAYWHVSvMk+1MvjurpZV7JpA1wH4GLaeMigAfVuBKIJuyAIvDLMhymVCmRaA6bOxox4LBDpdY5zIyQSga6jPJn0YmdMLBQU51Sx4ZMLJIcXANQruF8U6m74//SMWnhdU3fgFDEjfA21ulpWXV4FwPwO85FLmhfw0v1xsPaCilwK93wCwFMDvXGzvr0n+vM7kqmt0mLjYsLI8e2Y0lm0qnp7a2TjIYATSyFqK500Br7r8ipGMiPOZp/lozMfNdlYrrKxZshD7QG4nNeZnP0bb+t87yni9xMll5Aql6OUKhnsPvjOHk8QrmbVQsQbt8FgYGtYJiO+OE5kRB8ACiVHSC7OoKCillOJhSw7nMjMH84wa8UZLsQXsHNZOOWFNVjYGTH5pS63rDXp2MaCCc8FI1NKSY8u5vja+H/dgEFeVV69SPjTnZ5GuLAKMIjXSOvGEkitSvfHeaRUzKptSdhCQXXBnT3eP5gW3ZG+//57pk6dSkhICAsXLmTw4MEUFV0Vfvztt99a/QT/P5AhFZv4XXVpOKq8AagoLOTM1jph2ynemFmr6vcXBIFpXd34aGIgABu3nuLUE8+TMHQYBcuXUxMRAQYDcnd3VB07YtyjB3J30SpKk5ZG/hdfEj9oMLmfLkFfU9PofDoMEm9mcedy0PyNArhnkoqIySnHSC5lZjf3Rtsr1BVsSxQNfmf736SXwmCo70+7EqgBlJ4twEovoUzQc8ReLP/eKo5eFkx7vRtO3haoa3TsWh7OuR3JdLLrBEBCbRElEomYUfunXvBrSiFuj/h5x+mNNm+J30JedR4Oxg5M9J7Y/HVlChj+IQAzNFvpYFLKo/1a5l/7V0pyq4g4Ksp+9JnaDolE4NVRfpgqZVzOLGXn5Wumm+MPwMH3xc9Hf0pwxwf4YuAXSAQJmxM21zdaXw/37j74ehUDEo7srEZX8S9xLkg4wO46SY4BrgNaVzutKYJmgUQO2WHkxp5l3k/neW5NGPF5Fcg1vlhLAhAkOob3ucSWp/uweFIHJnd2QSGVcC6xiDVfhpKfVo7KVM64Z4Mwtbq96Xg7dzOGPyJ6Ikcey7xnWkJai9VRq9HoNXS270w36wAIrbuHX9G2u5O06U9XEzc61NSi1qv5I/qPO3/MfygtCtSWLFnCoUOH+O2334iJiaFHjx706dOH9HRR4uDf9rRxN8grq+HVY2KmxUeazYoZ4xEMAp6hvdFp9Lj6WYl+g9dhegc7vqw4zbcHP8Pq6F7QaDDu2hWnxYvxPnoU7317abNuLR6//Iz3vr34nDuL86f/Rennh6G6mqJVq0ieMpWa6Ib6Ua4+VpjZqFDX6Ej+G83afz4lZtOmdHHBwrhxZmZr4laqtFV4WXjV2zU1SV40lGeJCvoe4pN5VnxJfdbwoKmWwymFnEq8vac6EwslE54PpsNAMdg9vyOZMz9n0s5YzJqGqozEsfeyrNs6zt9G9HbRUcDWR9S+ugaNTsOPET8CogPBDfsFr0OF53DOEYhS0PC13VaMFbc3bRayOwW93oBHoA1u/mK/oZ2Zksf6iZmCz/fHodHpMZRmUrPyMUqSVOQX9SV7exq5ny7Bd18c76pHYlJt4ONzHxOWF9bksfo8NhKVtJJCtSthP96ajMQ9hV6PPvEgu03EbNRor1ZyIrgZJjbigApw8I/POBqXj0IqYdEwH869MZRvRr4BwJn8fZiZFTK7hzufT+/E4ZcG8qiFFW20UtQYOOsqwWDSOtOKbYLs6D1ZfIA+tSGB3OTWH+T6OyitLWVd7DpAzH4TuRlqSkRJjnZ3xgO5AYKAEPxAfVZtTewaKjV/f7vNvUiLArW8vDz8/MTGaIlEwscff8xzzz1H3759iYiIuDNj2/9iqtU6Hv31AufKrdEhwdRQiY9SQbf8ETiWt0GqEBj04PWFbSvPniNp7Dh8DmxEbtBx3sGP76e/jtuvv2I5eRJyh8YN3FJzcyzGj6fN5k24Ll+O1M4WdWIiKdNnULLxaslGkAj49RStlWJO/z2aagUVtRyMzgPgoV6ejbbrDXrWxIgaXbP8Zt38d69OlgPPviBXoVHrOPSrGKD693GiT18xsPp0T+xtP3BIZRL6z/Rh8EP+SGUSUsILGHB+HpZVDly0qrOs+qeWP6+UPTtOF0tV17AreRfZldnYqGzqTbVbwsoTybxd+wA6JHjm7IG0M7d8mqX5VcSeEy1qrog5X2F+vzbYmCioTEvn5EvvkDhiFMlbVWSfs6JgXxIla9dStGoVef/9L36fbePHL3W89UsNWz9dQGlJ3nWPZ2RlQp/hYsbpfLQHJbFRt3zu9wRZoYTqKsiTyTCTm9LPpd9dOazBYGCbdDgAYzlBb3cjdj3Xj2eHtMNcJaeDXQeGug9Fb9DzdejX9a/TpFdikSZWBw5aaNmXU8Kk5afIKW1cMbgVOg11w7urPXq9gX2rIv8Vk6BrYtZQpa3Cx8pH/PlecQjpMq9RS8MdI2gWg6rVeKo1lKvL64ca7tOQFgVqbdu25cKFCw2+tmDBAj799FOGDBlCbe3tKUf/f0KvN7BoXRjhGaWYGBujtxDtd0rjYumUIj7NGPevwNzGqMHrDDod+V9/Q9rDD6PJzETm5ITxp5/zyYAn2KK2Zt2Fmys9C4KA2eBBeG3diumQIRg0GrLfeJOiX6+Oxfv2FCft0mOKKS9qnYtdS9gSmolWbyDIzRIfB7NG249lHCOlLAVTuSnj2o67+YJXArW6smfI7hRK86sxsVTSZ2o7Fg5uh5FcSlh6CfujWseDzr+3E5Nf6oyplRJZmTGTLy8ipVIcLPhHDhSU50Ky6P5Q7894DWtjxSBujv8cVDJVo+03oqRKzcrjycQY3MnwrFO+3/PqLTfnX9idikFvwD3AplEjuaqilCW5B1l54L847NqApkSDIDVg0jUIy2lTsX3qSaznzcN8zBgU3m2RGMA/A6bvKCV56DDyv/4GXUVjPS/f8YNwtcxAh5Kjv17+Z1cYEg5wwES89gx0G9Ti7OitoNMbeH3zZZ47Z0aa3g5zoYrVPXPwtjdtsN8zwc8gESQcTDtIeH44FcU1HPxZfOjqOMiVJc/3wsXSiOSCSuauOkdp9e1PbAqCwMDZvphaKynLr+b42rjbXvPvpFpbze/RvwMwP3A+Qn4spJ8FQQqd5ty9EzFzROo9lLllYlbt9+jf74ivq0Fv+Ef/PbYoN/z8889z6dIlunfv3uDrM2bMwMrKik8++aRVT+7fzGf7YtkdkYNcKvD9g12Rn/FHV5LGwW2VSHRGZJjHYeycD1wNQjS5uWS9+BJV50V1e4spk3F8/XUkJiYsskriw53RfLw7hqHtHbA1vXlvhszaGtdvviZvyWcUrVpF7uKP0VdVYbtgARZ2Rji3syQrvoTYszl0HeV5h96JxhgMBtZfEEuS07q4XnefnyJ+Erf7Trt570xtBaSdFj/3HkplaS2XDogBbb8Z7VAaybBDxiN9PVl2OJHP9sUyxN8BiV6HOi0ddVIi+upqECQIcjkKD3cUnp5IVDcPRuw9zJn2Wje2fxdCQRL4xcxmj5EzA9OiaFkocw8QvxcwgHOwaAF1DZGFkVwuuIxMImNyu8ktXvqnkylU1IrOE+5TP4KvdkNWqJjB6zSrRWuVFVQTeyYHgG5jGp5n2e7dZL/zLk51NwaVvRqbdhWYPvwekr4LrrueJjOTyM0/Ufzb7ziWqClYtozidWtxePkVzMeOqc/mCoLAgBltWfN9GRmFdsQejcNvYMvdFO4FDAn7OGwslj1vqk3YCuj0Bl5af4lNoZlIBAkFPjNwT/gGadhq6Nyw/9TL0ovxbcezJWELX174irFRT1JTqcHO3Yzek72RyiWsebwnU749RWxuOY/9eoFfH+mOUgK1sbHUxMRSGxeHrrgYg1Yr9vM6OyH38EDl54cqIADhOpZJSmM5wx4OYMvnF4k5nYNHoC3eXVpffLw10er0FFWpqVHrcbBQ1lvvbYrfRHFtMa6mrgz3HA773xFf4DsKzBzv7kkGP8DY9fv42tqa7MpsDqQdYKTnrXuLVpbWkhVfQlZcCQUZFVQU11BZqgZAoZKiNJHj4GGGk7clbv7WtzxscjdpUaA2d+5cANatW3fd7QsWLGiwbfr0xs3G94ENIRn1IqufTO5I9zbWkODD2QpbciqNkCgMHG37J57FV6cYK44dI+uVV9EVFyMYG+P07jtYjB9fv31eb082XcwkKruMT/fE8OnUoEbHvR6CIGD/0otITIwp+Pob8r/4EompGdYPzMGvlxNZ8SXEnM6my0iPu1bavpxZSmxuOQqZhHEdG/fnheeHczHvoqgs79eMp7+U46KPoKUH2LTlwp9xaDV6HNqY49XpqoDu4/3bsv54PK7nj3JxxgrMYsIxaJp4GhcEFG29MO3TB5M+fTDu2ROJ4vpZB2NzBVMWdWfRko9pl9qTxOqB5JwPok/7HLy7OiDcguL+30LcXvGjT2OZhiu9LsM8hmFjZNOiZctrNPxUN937zOB2CKb2onbZ/rfh4HvgPw6UpjdZ5Sohe8Rsmlt7axy9RNsqfWUlOR8tpnSTOOGm9PfDxCMRe4ssjkm60r3boxg1sZ7cxYVOC9/ko2A9qdvWMueEBPv8ArJeeomSDRtw/ngxcmfx99SyU2+6ubzFmczBnNyUgkeXNhiZ3flsVKtSVURs/mUynR1QShTXd5VoRbQ6Pf9Zf4mtYVlIJQJfzQyms2dnWLoc0k5BflwjUeWngp5iZ9JO9CHWZGWUIldJGf5oQL1Ompu1MT8/3J0Z352i9txZth/7jaCUS+gKb67BJrWzxWzgICwmTcK4c3CDbc7tLOkyypMLu1I4tiYWV1+rZkv53A10egPnU4rYdTmbg9F5ZJVW188tCQI4masIdDElSiZOZj8c+DAyvQ4uidPz9VO3dxOfkaiMrJleWsZ3Vhasjlrd4kCtpkJDwsU84s7lkJ1Q2uR+tVVaaqu0lOVXE39BbGNw87eiwyA3PANt7tlr8S11Wy5btozTp0/j6OiIq6srGRkZ5OTk0Lt37wZPl/cDtcacTSrktTqT6YWDvJlSlzFKruxIaKUoJhk8w5HlCUXEFlWgrq2i5OvlFK4Um7SV/v64fP4/lG0a9t3IpBI+mBjIlG9PsfFiJk8N9MbTtnlTWoIgYPf00wgSCflffkXu4sXIXV1o27Mvx9bEUppXTU5SGU5tLW6+WCtwJZs2IsDxukMEP0f+DMDoNqNxMGmsrdaIK7Ic7YZRkl9N1Amxkb/XpLb1v6/6qirUq35i1faVSGvFUq8BEIyMULZti9TcHINBj6GqmtqUFPSlpagTEilKSKTol1+RWlhgPnYsFpMnoWrfvlFQK5NJkfcqZqvZl0yOnUWlxpF9q6IIPZBOzwleuPlb37MXCQC0tZB4WPzcZ0SDTaW1pexK2gXATN9m6Kb9hV9Pp1JWo6WtnQkjA+ue5nssgAuroDgFTn4Jg99o1lqVpbXEnBH7KruN9gRAk5tH+oIF1EZHgyBgs+AJ7LzSEEIOUYgVL1Q/ylPn0ni0343lCJ7v/h8mZ5/keZ9M3knpit/2CKrOniVpwkQc33kHi7FjQBDoNLEb8d8nU6huw8l1MQyd37HF78nfSuIhDhmJ+d7eLn0wlt+5jINeb+DljeFsDctCJhH4elYwozrUCRy3GwFxu8XeqREfNXidk6kTs80eRZUhBnADZvtgaX/1PA0aDS7nD/PnuRVIU8SHYh0gMTND1b49Sl8f5A4OCDIZBr0BTWYm6uRkqsPC0OUXULJ+PSXr12MUHIzNY49iOmhQ/d9011GeJIXlU5RVyYkN8Qyd1/6OvT8t4UhsHh/siCIxv2FDviCAQiqhVqsnq7SGPE5i5JyHQWvKuXAvBhRuxKGqULRJa3vns6eNkCmg4wxmnPuOH60sCc8PJywvjE72nW760sKsCsIPZRB7Ngedpq5NQgBbV1Oc24k+rmY2KkwtlYCAplZLRUktOYmlZMWXkBFbTHq0+M/e05yBs32xc2/cavN3c0uBmr+/P9OmTWPhwoX1X1u2bBkRERF8++23rXZy/zZSCip54rcQNDoDozs4smiYeJEpza/m4BExSOtocZDuvT/AJNUEZWEFiQ8+AOFi/4XV7NnYv/IyEuX1y5pdPKwY5GvH4dh8vjmcwGfTmpdVu4LNggWoMzMp3bCRzEX/wfO31XgF2xF3Npf4C7l3JVCr0ejYGiZKKlyv7Jlels7BNFFmY17AvJsvaDBczQR5D+PctiT0db1LLj7ie166fQd5S5agzctDCuSY2bHPpTPBD01h2sQ+jcogBoMBXWEhVSEXqTxxgoqjR9Hm5VH8++8U//47Sh8fLCZPwmL8eGTWV90NOtl3Yp/ZPqI7LGVuXEcuqmeTn1bO9q8vYW6rwr+3M22CbLF2Mml20KbXG6ip0FBdrkar1iORCcjkEkytVLclNdKIlBOgqQQzp0bTntsTt1Ojq8Hb0ptg++AmFrg+VWotP54Qs2kLB3tf9fOUKUW5jrUPwKmvRJV0K4+brhdxLBO91oBDG3OcvC2pjY8n7Ykn0GZlI7WxwWXp55hYlsAfb4v7d1tM0XFzvj+WxAM9PVDJm37PTOQmvN7jdRYeWsj7PpFs+eM7dO99Ts2lcLJefJHKU6dwfPstpAFjGeQ6kQ0pzxF7vgDf3kX1U6f/CBIOcMhYzC/eSe00g8HAu9sj2XQxE6lE4JvZna8G6gBd5oqB2qU/Ycg74g29jqoyNVanAqlBS7T9abztNfjihMFgoPzAAfKWfIYmLQ0poFOq2OcYxGm3Trzz1oP4ejSd8TWo1VSeO0/Zrl2Ubd9OdWgoGU89jXG3bji8+QYqX1+kcgmDHvBj45IQYs/k0K6bAx4BLcsitybZpdW8sTmCQzFihshMJWNEgCNjOjgR6GKBtYkCiQAFFWqSCsr5z8lvKNWBuqgvG+JzmXB5OQ4SKPWbjkVr+3o2l+AHsD2znDEVlWwxNWZ11OomAzWD3kBqZCHhh9JJj74qhWPjaopvD0fadbXH1KqpxhIlVo4muNW5zpQVVBNxNJOI45nkpZSx/uPzdBjoSq/JbZHd4Fpwt7mln8qaNWso/EsK+YknnsDW1vZ+oNYEpVUaHvn5PCVVGoJcLfjftE5IJALVFWq2fx1GbQ3Yy+PorfoOSc1LjMp1ZOSvsVAdjcTUFKcPP8R85IibHue5oT4cjs1nc2gmCwc1P6sGYmbN6Z130GRmUnX6DBkLn6Ht4lXEnc0lMSSPvtNELao7ycHoPMpqtDhZqOjjbdto+8+RP6M36Onr0pd2Vu1uvmDOZSjLAJkRRUbdiL9wCYBek7zQV1eT8/4HlG4W7ZDkrq7Yv/giFyx8+XNrJPujahk7Vo+xomGgJggCMltbzEcMx3zEcAw6HZWnTlGyaRMVBw5SGxdH3if/Je9/n2M+bCiW06dj3L17vZ5aqErLV6YbaN/Dj5DyCcScyqasoIaz25I4uy0JpbEMO3czTCyVGJspkEgF9HoDWo2emnI1VeViYFZdrqamQnN9STYBzG1U2Lqa4RVsh1cnu9sL3K4Eu+2GN5j2NBgMrIsTy54zfWe2uDz+x9k0iirVeNgYNy5z+40Fz35i6XrbQnhwK1ynd+gKWrWuXjet01B3qi9fJm3+o+jLylB4euK2cgUKcyl8X9fz1GMBvYfPxDXiCBnF1fxxNo1H+t5Yu62/a396OPXgbPZZvspfz5LffqPg2+8o+O47SjdtojYmBpevvsJh8Hg6rNnN5aoxHPkjlllvdUemuHcu/E1iMJCRfIhYGyUSBAa6Drxjh/psXyy/nhYNuT+b1rFhkAbgPUx8MCjPhtid9V6gBr2Bgz9HUVOmBataTnpuJDX0DH3VHhR8sLi+h1dqY4P1Qw9hOWM6X25L4HxULk+vC2f7M30xV12/XCkoFJj27YNp3z7YPf8cxatXU7T6N6rOnyd50mSsH3wQuxeex9HLgo6DXAk/lMGR32OY/U7P1n0waiYXUopY8NtFCipqkUkEHu7jyTN1E7J/xc5MSXjxCUp1GZjJzfh28rNsPxRKv8zLAEw67cUYeSxPDmx729I4LcYhAJw68WBBJFtMjTmQdoDMiswGIubqGi2xZ3IIP5xBSW4VIF6KvILtCBrshmNbixZff8xtjeg9xZugoW6c3JBA/Plcwg9nkJ1YysjHAzG3baoh4u5ySxZSHh4e/PJLQ8uH1atX4+bm1ion9W+jVqvjyd9DSCqoxNlCxYq5XTFSSNHU6ti5LJzSvGpMrZWMdv0ZiUFL3qeLmf59LObVUOJhTZuNG5oVpAF0chONy3V6A98cbrn3oCCX4/rll8jd3dFkZSH9ZQlKIxlVZWqyE0pavF5L2X5JLEtO6ORyNbtSR05lDpsSxB6jRwIfad6CsWJJjraDCT0iPnF6BdthrisiZfoMMUiTSLBduBCvXTsxHzmCGd3ccbc2pqCilpXHk296CEEqxbRfP1yXLqXd8WM4vP0WqoAA0Ggo27WbtHkPkzhqFA6bT2FfLafUoCVFLsO4+AL9pvsw79O+DJnnj1t7a2RKKbVVWjJiiok9k0Po/jRC9qQSui+Ny4cziL+QR2ZsMUVZlVSXXw3SVCZyTK2VGJsrUKikYICyghqSwvI58FMUq146zpE/YqkqUzfvfbsWg+GqyK1Pw96RywWXSS5NRiVVMcZrTIuWrdHo+P6YKOr81MC2jZ0nBAHGfQlyY0g+Blc8CJsg7lwuNRUazKxVOMnz6oM0o06d8PjzDxRODrB+HlTmg30ADH0XuVTC04NEjazvjiZSo7mxwLMgCLzU9SUEBPam7OVScSR2zz6D+48rkVpZURMVRcqUKVRUeNDTajMmkgLK8qu5sCulRe/N30ZeNIcQb4JdHDpjqbK8I4dZdjiBZYfFkuQHEwKYFHydoSGp7OoE4jVG7aH700iLKkIqlzD+iS5YK03ptjORlMlTqDp/HkGpxGbBE7TduxfbJx5HZmnJkqkdcbE0IrWwio92RDc+1nWQ29tj/5//0HbnDsxGjAC9nqJffiF56lRqoqLoMd4LM2sVFUW19TZld5N159OZteIMBRW1+Dmasef5/rwxpn2TQajBYODHy2ILzQy/GfRt68Z/vcQH13BlZ5K0tnx9KIGh/zvK3sicuz8lGfwAPhoNPXRS9AZ9vQBuWWE1Jzcm8Mtrpzi2Jo6S3CrkKikBg12Z80FPRj7eASdvy9vqoTaxUDJ8fgBjnwlCZSInP62cdR+fJy3q5j2NdwPBcAs/jfPnzzNlyhRUKhVubm6kp6dTU1PDxo0b6dat2504zxZTVlaGhYUFpaWlmJu3zOetNdHq9DzzZyi7I3IwUUjZ8GRv/J3M0ap17P4+grTIQpTGMia/1AWTNVPJ3hhHdYGY4t8bLBA+qwurxq9u0TFD04qZtPwUUonAof8MwMOm5Yri1ZGRpM6chUGjIXnaf0nONyVwgAsDZjUxxVYQD8c/h8o8sZ/JyBL6LgKXzs0+ZlmNhq4fHkCt1bPr2X60d274c/vwzIesjV1Ld8fu/Djix+Yt+n1/yL5ExdBvWf2nE3qdgXEz7ah58yl0BQVI7WxxWfIZJj0bCuZuv5TFM3+GYqyQcuTFgdibt3xGszoykpL16ynbvgN9pdg3ohcgyl3A1rWKvm5K5O/GNniNXqenIKOCoqxKqsrUVJWq0RsMSKQCUpkEI1M5RmYKjM0UGJkrMDKTozKVN7K9qi5XU5RVSUZsMXHncynLrwZArpLSdZQnQUPckMqa+ZyWFwPLe4BUCa8kg+Lq79Pis4v5M+ZPRrcZzX/7/7dF78+vp1N4e2skLpZGHH5xIIqmzufcCtj1oihW/ORJsGnbaBeDwcCf75+jOLuS7n3NMP/6GfSlpRh17oz7ih+QmJjAntfgzHJQmsPjR+rXUWv1DPrsCJkl1bw7rj3z+tzcEeGdU++wKX4THW078tvo3xAEAU1WFhnPPU/N5csgCNgO8aDMRMee0leRSASmv9ENG5fmD0X8LZxextzwL7ioUvFq91eZ49/6Ug0/nkjmgx2iztyro/xYMKDxz7OeomT4qhMgwHOXyCm2ZNNnFzHoDQx6wA8v6xKin38SVZr4EKbo3wf3d9+vH+64lnPJRcz44TQGA/zySHcG+Ng12udGVBw9Stabb6LLLwC5HIeXXqI0aCS7vr1813++V/52AEYFOvLZtCBMlDfOgp3LPsf8ffNRSpXsmbIHW4UlLA2AihwM035hr6EHH+yIJrNEvFYM9rPnvfEBt23j1myqi+EzX44pBJ6xd6RdRTBTdU9TGFsuNgwDxRI9IUotEQodGgHkUoH2zhZ0dTFngHElHWoL0CQlosnIRJOZibagAH1FBfo6OR1BoUAwUiG3d0Du7ITCsw2qjh0w6tgRuYPY71xeVMOe7y+Tl1qOiYWCBz7odcey4c2NU24pUAPQaDScPn2a7OxsnJyc6NWrF3L5vTP9ci8Eanq9gZc2hLPxYgYKqYQf53WlXzs7aio07Fx+iZykMvGpcGEHlCe2kL/0cwxaPRKlDOHNRUyp+hxjmTGnZ59GIrQs+fnQqnMci8tnXm9P3h0fcEvnX/THH+S+/wGFtoFcCnwSIzM58z7pg+TaoMBggJCfYe/roplyAwQIngND3gXTm18UN4Zk8J/1l2hrZ8KBRQMaPCHlVOYwatMotHotq0asoptjMx4ISjNhaXtA4JTfMUKPFODgJKPDzpfQl5Wh9PPD7Yfvkds3HrE3GAxM/vYUoWklzOzmxidTbr0hXF9ZSdmePZSsW0/1pUsNtik83DDu1RtVQAAq//YoPD2QmrbsYm/QaNBXV2PQasV+OpkMibFxfW+dwWAgK66EU5sSyEstB8CprQUjHg/ExKIZFjsnvoAD74ilqAeuClJq9BqGrBtCcW0xy4csp59r80VR1Vo9A5ccJqu0hg8mBPDgdUSN69HrYfVESD4Kzp1h3k5QNLx5pEUWsv3rS8gVAn1C3kdSmINRcDBuK1YgNTWB8PWwqc4WZ+Yf4Ncw+/fbmVTe3BKBg7mSoy8NumGvGkB+VT5jNo+hWlvNsiHL6O8qmtPr1WpyP1pMyVpRU87UuYbwDk+RUtsFO3czpr7SpeHfzz1G4W+TGKyNRy8I7J2yF2fT67ui3Cq/n03ljc0RADw/tB3PD/W5ySuAXydA0hFqur3I2pODqSiqxbuLHZ21JylYtgy0WipMZfwwVI/DmIl82O+jJpd6b3skP51MwclCxd4X+jeZfWoKbXExOW+/Q/l+cUDJYsJ4Qt1mkRJRhJO3BZMWdb7jQ0F/nkvjtU1iufLx/l68OtKvWS0pT+x/glNZp5jhO4M3e74JMTthzWwwtoVF0SBTUK3W8c3heH44loRGZ0Apk/DMYG8e6+9VL+1xp1DXaMn86X1S4moJ1fRBqb16HUyR6QhRakmS6REkYFVTjm9hKn7FqfgXpdKuJB2V7vb08hTebTEbNBizYUOR+bXn5PoEfLo74tzO8ja/s6Zpbpxyy4VouVxO//79b/Xl/3o0Oj1vbo5g48UMpBKBr2cH06+dHSW5VexcHk5JbhVKIxkDe2qpfuEhSpPEEpCJYw1O04MQpjyI6o/lVGmrSCtLw9PCs0XHn9+3Dcfi8tkQksF/hvtg1sILEoDVrFlUnT2Hft9+5LpqqstF2yXXukZM9HrY/DhcrvNBbNNf9OqTKsSepsvrRO+45GPwyF4wv/FFf3u4WPYcF+TcKI298vJKtHot3Ry7NS9Ig/qyp9q5L5FnxKZTx6M/1JfD3L7/DqnF9QckBEHgzTH+TPn2NOsupDOvjyd+jrcW8EtMTLCcMgXLKVM4dm4De396h/6xBtyz9ahT01GnNrQckpiaIrO3R2JigsRI7JEwqNXiP40Gg1qNvrYWfVWVqO92PQkRqRSplRUyOzuU3t6ofH0YPaQjaWofTmxIJDuxlPWLzzPyiQ71EhZNckUs+C/TnqcyT1FcW4y1yrrFEg6bLmaQVVqDvZmSaV1v0jIhkcCEZfBdX8i6CBvnw/TVYmmsjksHRV08p7xzSApzULVvj9uKH8QgLWYnbKnTSOv7QqMgDWBaV1eWHU4gu7SGdRfSr+uGcS12xnbM9J3JT5E/8W3Yt/Rz6YcgCEgUCpzeexejjh3Jee89KrLAo3otWV2CyE8rJ3R/Gl1G3njtvw2tmqP5YeitTfE392z1IG1jSAZvbhGDtCcGePHckGb0mAJ0fxxD4hEOH1RRUVWLuaUMr4NLKAgTe9HMhg9H88w0zpx6EpK2Mc1vOkF21x+kemmEL4di8kgtrGLxzugWP4DJrKxw+epLin75hbwln1G6dRuegdlkOD1MdkIpMWey8e/duu/btWwJzeT1zWKQ9mjfNrw26vrONX8lsjCSU1mnkArSq0NYdcb3BM+pH9QwUkh5aYQfk4JdeWtLBKeTCvlsXxybLmbywcTA+r5hrUZHTYUGdY0OTa0OiURAIr3yT1L/ufSazwWpgE6jR1Oro6ZSQ0VRLeWF1RRkVpKXUkZBRgUG/UAAlECVvJx4q0hk1n3oZV7NrPJMzBJjIOoy2ozGnqvVMiUpZo6kmDtSZGlP957tGdgnAIWlBVITExAEDGo1uspKtLm5aLKyqY2NpfryZWrj41EnJFKYkEjhihUo23nTcepUzG3HNzrO38HfNOLRfPLz85k3bx6HDx/Gzc2N5cuXM2TI3zBC3AKKK9U8+XsIZ5KKEARYMrUjQ/3sCdmTwvkdKei0ekyMoUv+OjTviBOMUisr7OeNxyLrYwRNMkhk+Fj7EJ4fTnRRdIsDtf7tbGlrZ0JifiUbQjJ4uBnlnL8iCAKO775D1cUQbHMvku3ch4SQvKuB2tnvxCBNIoeh70DPp682e3eYKhr7bn4CipNh9WR4eBcYX3/6rahSzYl40WdzXFDDC11WRRYb40WLqyeDnmz+NxC7G4BIZqKu0WFSk4d11kWMe/TA7dvlSIxvnNLv4mHNmA5O7LyczYc7olk9v/tta8l16DiEp3u+x7aecCw+B6nNTGp0XtRERVETHYOuuBh9RQXq6yjftwidDl1BAbqCAmqjoynbLn5ZYmpKv17DuWA+hNJSNVuWhjLm6Y71U1CNUFeJiuUAbRtOAG5PEhcd3WY0MknzLyVanb5eR/Dx/l43zV4BYOkGs9aI2ZXYXWIpdOxSEAQKsypIiyoCgx6XmO3IXV1x++F7MTMZtw/WzQW9FjrOgMFvXXd5pUzKUwPb8tbWSL49ksiMbm43zSDMDZjLmtg1RBRGcCLzRIOMouWUySj9fMl8fB4UVuAd9QdRPg9xbkcynh1tsXFu/RJZWHoJx+LyicgsJTqnDI3WgFwmYKqUE+hsTid3S/p62zbdCpFxnkMq8Xse3KZ1vT13hmfz0oZLGAwwt5cHr45sXoABgM9IIphDUlUXJOjxPfk/tPlxSExNcXzrTczHj8dVEJiQO4GtiVv54PQH/Dn2T+SSxg+nxgoZn07pyIwfzrDmfDoTOrnQq23LJjYFQcBm3jxUfv5kvvACRJynTa0D8S6jOLUxkTYd7e6Ittr5lKIG7+EbY/yb/R6uuizqpo1sMxJXM1cozYCEOtmiznMb7e9tb8ofj/Vg26UsFm+LRpddzbdfh3DSyAhbJFSXquvLka1JBRoCDcdxrTrP2eocpoSpcSv8HaHOoaTes0AQUHq3xahTJ/FfUBB6Nw9So3LZdzSJmJxyfssFn5NVfD7dh0CXvzyMBjSsMulKS6k4foKKQwcpP3SY2vgEcj/+hMJVP+F9+NB1BZDvJvd8oPb000/j7OxMQUEB+/btY9q0aSQmJmJlZfV3n1ojDAYDR2LzeWdbJGlFVZgopHwxLQjXcgPrPjpPUZbYp2RTnYzfqRXI1KUIcjnW8+Zi8/jjSIVq+OxjKE4FTTX+1v5ioFYYzag2jUVGb4QgCMzr04a3tkTwy6kU5vbyvKWJTZmVFU7vvU/+G1+Jgdr5bPrP9EGSHymWwwBGfSIGZX/FvQc8tBVWjYD8aPhjuvh/ReMbxZ6IHLR6AwHO5rS1a3gT+yr0K7R6LT0cezQ/m1ZTBsnH0BskXE5wAQy4pe7HqEMgrsuW3TRIu8IrI/3YH53LiYQCtl3KYkInl5u/6AZYqazwNPckpSyFy2Zy+jsWYz7rxfrt+qoqNNnZaPML0FdXYaiuFpvqZTLyawzEF9UQV1xLmV6C1NgYhakJQd6O9OnghspYBTodBq0WXWkZuqJCNNnZ1MbFURMTS9WZM+hKSmD/JoKkO4nqtIACMx92LQtn7DNB9XIlDUg7LYoFm7uC9VWdsXJ1OUfSjwAwtu3YFr0H2y5lkVZUhY2Jgtk93Jv/Qo9eMGUlrHsIQn4SS+2jl3BpvzjpaVdwCVOVDrcVPyCztoJT38DB90GvgfYTYcLyG3oYTu/mxrLDiXVZtQwe7HljORAbIxum+0znl6hf+O7Sd/R16dvgxmkUEECbP38hc+4YHLLOkmsdTKFtBw7+FMWUV7o2v0fwBmh1erZdyuKXUylcymhK6LOa6Owy1oeIWYhgd0smd3ZlcrBLg76mqoR9nK5z2xjiMfS2z+0KG0MyeGVjOHoDzOjqxjvjAlr0wJOfUcWJPNHtom3CJszy4zDu3l0UGna5+vf4QpcXOJpxlNjiWH68/CMLgq7vNNHDy4Y5Pdz5/Wwab2y5zO7n+t1SWc+kZw/abNxAxjPP4hK1iyzLICpx5tTmBAY/6N/i9W5EelEVT6wWpZ1GBTq26D1MKU1hf6oYlNUPYYX+Bga9OFXdRM9nVnwJJmGlPJwvQ6ep+12t1VJdt4+AHrlEj1TQif8zgN4gQY+A3iBgaHJW0YAUDYK2An11CUbV+dgVJ+BUHIOqpogr39XVxx49UhsbVAHtMQoKEgOzjh2RmjXWO5sU7Mr4IBfWnE/js72xxOVWMHn5KV4d5cfDfTybfM+kFhZYjB2Dxdgx6MrKKNu5k+L16zHp3uNvD9LgHg/UKioq2Lp1KykpKRgbGzNx4kQ+//xztm/fzkMP/Q0KytdBrzeQWlRFZEYxfxxLJC65EEu9gYmCQD8jM1K+jyBOK14EZJpK2iVsxDH3LFIzM6wemo/VnDnIneoEHg2moLKEmhIoTKC9jSikGFV0awbPk4Nd+HRPDCmFVRyJy2OwXzPEYa+D2eBBePTfT2R+ObWYkX4xHY9zj4o3cJ9R0HV+0y+28oAHNsFPoyDjvOjfOP7rRrttuyTebP+aTYssiGRn0k4AFnVd1PyTjt8Heg2p0jGUlxmQaSpxM8rH7YdfxHJYM3G3MeaZQd78b38cH+yIYoCPHZbGt6c0H2QXREpZCmEqJf3/4vkpMTZG2bYtyrbixVOj07PrcjYrjydzObMUkAJXgkw9UA4R5RjtTGJYewf+M9wHDxsTJCoVcgd7VP7+mA0WM2EGnY6ayEjK9uyldPNmAi8uIzzwcYpsAtjxRQjjFnbAuf1ffkeSj4ofvQY0kOU4kHqAWl0tbSza0N66+YKfOr2BZXXTyPP7tWm5DED78TD2c9j5HwhfS1XCJWKTPgSkuOeewG3Z1yglOfDTAkivM3VvP0EM8G6iEaWUSXlyYFve2RbJt4cTmN7V9aY38HmB81gbu5bwgnBOZZ2ij0ufBtul7u1xm9uRgu0h+MX9yVkLL/LT4eQvofSf36Vl3/tfiMwq5ZWN4URkinZYCqmEYe0dCHa3JMDZAlOlDI1eT0F5LeEZpYSkFnM2uZDQtBJC00r4375Y5vdpw0O9PbEwknMi9SBqmYCbwhJvS+/bOjcQb/bfHk3k0z3iwMzkYBcWT+7QogfG6opadn1+Gr1Bhm1BOG7Zh7B/fDrWz7/b6AZqY2TDa91f45Xjr/B9+PcMcR/SpITPyyP92BeVS1J+Jd8eSWxer9wVtGqxHSDpMPKko3h0KSRHZ4xv3BouBi8i+mQ2fl1tcPZvHXupilot8385T1GlmkAXc/43PahF7+FPkT9hwMAA1wH4WPmAXgcX6wbUusxrsK/BYCDhaALndqZQUn71d19ZU4xVSRyWpQmYVGZjVJ2PXFPBjc5CTLgJ6CVSDIIUgyBBotch0aubfJ3E2Bi5ox3y2hh0Njre97UiwUHP8hnf4mPXoVnfr1QiMKeHB6MDnXh5Yzj7o3J5f0cUp5MK+WJGp5sOXUjNzbGaNQurWbMwqG9hSv4OcE8HavHx8VhYWOB0JZABgoKCiIyMbLRvbW1tA1P4sjovvzvJ78//TFmlAyBgEKT0kUjpg2X99hxRIB1VTSEumcdxLjiHZfcgzJ/9EPORI8VJtGsRBLDzE28weTH4uYjp2ejCaAwGQ4vLbiZKGTO7ubHieDI/nUy55UANwOmNV3F47DsyFF2J+HErHo4xYOoAE75pcAO/Lg7tYcZq+GW8OGbvMwr8rpZWcstqOJtcBMCYDld/1gaDgc8ufAbAOK9x9YFrswhfJ845pA0CGbiUhNJmxbfIbiET+8SAtmy9lEVCXgWf7I65rcECEIVvtyZu5ZJSCcVZUJEHpo0v6nsjc3h/e1T9FJZCKqGDqwWd3S1xMFdRo9GRV17Lweg8Mkuq2XYpiz0ROczv14aFg7wbXZAEqRSjjh0x6tgRu+efo3zffuTfreBCkYRia392fn6WseONcRw35OrvWtIR8aPXwIbnliLqqo1pM6ZFv5e7I7JJzK/Ewkh+04xVk3R9RJTX2PwE5y50RW8ixawshfbdUzHaPRa0dc/8CjNR0b7zQzf/Ha1jRjc3lh9JIKu0hg0hGczpceNztDWyZZrvNFZHrWbl5ZWNAjUAIWgadilHUHlpKQ/bRHjbB7l8vhTr8rUEPDutxU/sOr2BLw/EsexIIjq9AQsjOY/392JmNzdsmvD4HR4gapTlldWw7VIWv51JJaWwiv/tj+OHY0k80cOGjJosMDVhiPuQ2y7x12h0vLc9kj/Pib2DLWl6v0JtcjLbPzpGhcwNVXUBnWt24DEyD4VTQpN6eqPajGJ3ym6OpB/h7ZNvs3r06uuW5S2M5Lwzrj0L/whl+eFExnZ0bmT+3giDQex33Pem2M5RhwRRA1plXEh29imynXpz4NP9zHizM8q2t5dZMxgMvLn5MnG5FdibKVn5ULcWPdxkVmSyLWEbAI92qKt6JBwUtSWNrMBvLAaDgZqICFK2neBCggVlSkdAilRbg0PeBZxyTmNemY7C0RG5ixMVKg+iKjxILNehRUAvSNALEmRyKTamSoykAiqJAa1Wh7pWQ2W1mhq1Bqlej0YipUamRGJkRDtPe4LbOeHk7ojc1QW5szNSyzqZjZ/GQOoJHAM7c74yiV+jV/Op3acteu+sTBT88GAXVp9J5cOd0eyPymXqd6f5cW5XnC2bp48mNGELeLe5pwO1ioqKRpMQ5ubmlJSUNNr3448/5r333rtLZyYiEQT00oYXRsGgQ66uwLQ2D2tJEXbmaly722PcYTpGwYtvPtFn7y8GavnReAdMQCaRUaYuI6syq4H4X3N5qJcnK08kczy+gJSCyhYJ4F6L1Nyc9lN7knFQS4bGk/IcI8ye/QxMGovSXpc2/aH3Qjj1NWx7Bly71gcnO8OzMRigs7tlg1HwI+lHuJB7AaVUyTPBzzT/ZCsLIfEg6fGe5JqJvXldnhzeoEzSEhQyCR9P7sC0706z5nw64zs507ttM7/v63BF+PaySoUWkGVfgnbD6rdnlVTz9tZIDkTnAmBrqmRuLw/m9PTA2qTxheO98QbCM0r5bF8sx+ML+PZIIvsic1g5txttmvh5SxQKLMaOwXzUSGy27Wbn1hzKVY7sW5tG/13P4vreW8jNZJAt2p3R5urgUGltKWezxb61EZ7N0/cDMfv8zSExm/ZwH89bGnCpx70HBZYvEC8Xe086KHZgbp4oNrEY24DXILFv0rIFpVVAJZeyYEBb3tsexfLDiUzr4ta0bEgdD7V/iD+j/+RC7gUiCyMJsPnLlLXfGNj+PGYm8fRc+gVlX14mRerLqXAV0pkP4/Ha8xgHN8/RoaJWy3N/hnKwToV+TAcn3hnfHnuz5snH2JureLSfF/N6e7LzcjbLDicQl1tB2IltRHmLN69gl5a1WfyVuNxynvkjlNjccgQB3hzTnvk3ERK+Fn1lJQUrV3JhXxb5biOQ6DUM6G2g7cRvEL7tIfYo5kaJD4B/QRAE3ur5FiE5IUQURvDtpW+bvHaM6eDERt8MDsfm88bmy6x5vGfTAWp5Dmx6/GqG2cRezO56DQIrT4SaEqwLExmw6Xc25nSkXOnEsYVf0+eZHhiPbtwD1lzWX8hgS50H6rI5nXG0aJlM0I+Xf0Rr0NLTqedVpf+QnwHQuE+kZMUqCjfvIE4RTLrrIFBKkOpq8ayNIMBPgvnELqjaP4DCzQ3hGlWHAKCwopYd4dnsjsjmUnop1TfQIJQI4ONgRq+2NowKdKKLh1UjncwGBD8AqSd4MCeF7WawL2Ufi7oswtGkZYbxgiDwUC9PAl0sePzXC0RnlzFx2UlWzevWuG/tHuaeDtRMTU0bZcbKysowvU6w89prr7Fo0aIG+91pAd5+Tw+nMKsQFztz5CoFMmMlKjMVEqUCQXqLo8z2dU9gedEopAraWbYjuiiamMKYWwrU3KyNGeBjx5HYfHGse/StP+G1ndIP5YEd1MpNiUjoS3f3wbTouxz8FiQcgrxI2PYszPoTBKF+2nP8NWXPGm0NSy4sAeDB9g/iZOp03SWvS+QmKnMkXCoZBeYSHC1rcBp6e1Y43TytmdXdnT/PpfH8mjB2PdcP2yayFzfDy9ILM4UZ5epy4hRy2meF1QdqeyKyeXlDOGU1WmQSgScGeLFwUDuMbqDjIwgCQW6W/PpIdw5E5/HWlggS8yuZ8M0Jls3pTL92TUujCFIpNpPGMqF7CesXn6PCzJ0LeXmox4/H6fGxmGMQs7xmVy+Qh9MPozVoaWfVrkVDLgeic4nJKcdUKePh3i0fbrmWsv37Cf/5KGrfBzCSaej4+ZeQHwnWbcDWp9kZtOsxq7s7y48kkllSzcaLGczqfuNgz9HEkZFtRrIjaQe/RP7Cp/3/8uRvZAXeQyBuD/L8Ywxf9jLrXz9IcYUZ52UD0M2Zi9XoEdgueAKld9Mlx6ySah75+TwxOeUoZRI+ndrxlnsmZVIJEzq5MK6jM/uicone9x1npRKMtVKeXFnAzG4RPNjL8+ZZpmsoq9Hw/dFEVh5Pplarx9ZUydIZQTf8/bsWfW0tpZs3k79sGdkGV5IDHwOg3wQ3vMfUPRD4j4fobXDsU5j283XXsTe2561eb/HysZdZEb6CLg5d6O3cu9F+giDw/oRAhi89xtnkItaHZDD9ehPIGRdgzRyoyBG1BHs/A32fB+VfeqQ8+2LTZS49V+/l+ElIdBmL3evv43HpNJavftviLGVcbjlvbxOnZBcN86GbZ8tsyLIrstmcILquXBnCMpRlU33iIIUxVlSs3Ue5SSQR7edTbSw+NLdx1dH/4W6YNiNYtzFVMre3J3N7e6LV6YnJKSe1sIrSag1lNRpMFFKsTZTYmytp72R+05JjA9qPh10v4V+QQjfXoZwvjeOPmD9Y1KUF7S/X0Nndii1P92H+zxeIzS1n5g9n+OHBLvS+jvvNvcjf3yV3A9q1a0dpaSk5OTn1X7t06RIBf5nYAFAqlZibmzf4d6dx9XYiqH8gtv7uWLRxxMTBCqmx0a0HadAgUAPwtxH/f6t9agCz624060MyqNXeWHn9RkjUZXibiH0/2SbB5H26pGULyJQwZUWdfMduiNxMelEVoWklSAQY3fFqMLby8krSy9OxN7JnfuANeuCug+bkGtJO2ZHtJF6cg2e2jgjzW2P9aWdvSl55Lc+vCUOnv7WxJ4kgqZcPCFMqITuMGo2Ot7ZEsOC3i5TVaAlys2TXc/14aYTfDYO0axEEgWHtHdi2sA/B7paU1WiZu+pcvXfqjbBwsWT0890QJJBn35U0k45kLvmdrLOW6F36Ntj3SmPyMI9h11vquuj1Br44EA/AQ708sDC+9WxaVUgImf95kTSXQQB0GueL1NoNfEeCne9tBWkgZtWe6C8OTiw7nIBGp7/pa+YGiFmTfSn7yK7IbrxDgNgMT+Rm5HIpo1/uh9JISrm5J1H+cyndsZOkseNIX7iQytOnMega/p3mldUwa8UZYnLKsTVVsvaJXrcUpBkMBnRlZahTUqiOjKQm5AL9ypIwKUwhIEVP93Qn7Itz2Xb4MsP+d5hZP5xh3fl0ckprmlwvJqeMz/fH0f/Twyw7nEitVk9/Hzt2P9evWUGatriYwh9XkTh0GDnvvkeh2oKo9g8D0GGgC4FjrsmcDXil7n3cUn+NvB6j2oxiqs9UDBh47fhr5FflX3c/N2tjXhgm9rEt3hVNYUVtwx3C14n9tRU54gPLk6dgyFuNg7Rr6DBnOA7uxuhkKuLaTiPnl6NkzRuPrqKyydf8lSq1lqd/v0iNRk+/drY8eSNR4Cb4MeLH+iGsYOsOlO7YScq06aQetKY804gsx16EdHmZamN7TCwVjF0YxOg3h2Hq0vLgRSaVEOhiwZiOTszu4c6CAW15sJcnYzo60c3TumVBGogDZ4GiZdiDavH6tyFuA1WNtDqbj6uVMRue7EUvLxsqarXM++k8O+qSBPc693xGbfz48bzzzjt88cUX7N+/n4iICMaNG/d3n9qdw77uolScAuoq/K3FQC26sHm2J9djsJ89juYqcspq2BuZ2yBz1SLO/YCP6hCRVUPItw2iaP2rmA0bhmm/vjd/7RUcAkTHgqOfwJ5X2dtJzKz09LKpL98klSbxY4ToPPBK91cwVTT/qV6fE0/G+hRyzPugkZtiaqnAs2PrPDUZK2Qsn9OZ8d+c5ERCAV8fim9ZE/I1dLLrxInME4SplEzLuMjEZSeJyRHFaBcMaMt/hvsgv0VhVHtzFWse78lrGy+zKTSTF9aGAdz0xu7czoo+U9pxYn08Cb7TsSxNgORsqpeF4BqYgNLbm3J1OaezTgMw3GN4s89pV0Q2UdllmCllPNbP6+YvaILa+HjSn3yKIuM2VJq6IFNIaN/39iZxr8ecHh58dzSJjOJq1p5P54Gb9NP5WfvRw7EHZ3PO8nv077zY7cWGO/iOErMxBXGQG4mlYyCjnwpi65eh5NsFkz74WdwPfUnFgYNUHDiIzN4es5EjMOnRA41/Bx5aF0NqYRVu1kasebwXLk302Bi0WrT5+Wiyc9BkZqDJyECdkSEqtWdkoM3Lw3Ad3b1+XJmySwHEBzCNREq+kSV5RpasM7JCY2uP3tkFwcWdEhtH0nUKkgoqSC+qrl+nnb0pL43wZVh7hxtmkHRlZVSePkPZzp2UHz5crwVY4x5IhM8T6LUS2gTZ0nf6X/6+HAPBfxxEb4ejn8K0n5o8xivdXiE8P5y44jhePPoiK4avQCFt3DrwcJ82bA7NIjq7jI92RvP5jE7ihourxTYNDKLv7KTvbhigXUGQCAx8KJB1i8+RbxdMoY0/nI2mevQQnL/8tlll7ne2RhKfJ/alLZ3RqcUT+zmVOWyK34RRjYGF0W4kfDICbXbdA4QUUvsvJMkg3ls8Am0YOq/9HZEUuS2CH4SLvzIg7hju/sGkVWSwKX4TD7R/4JaXNFPJ+fmRbrywNoxdl3N45s9QiirVN9VN/Lu5pwM1gOXLlzN37lxsbGxwdXVl3bp196Q0R6thYisqRVcVQEFsfUYtuujWAzWZVML0bm58dTCeP86m3lqgpq6E08txlJdgbKynqsqYIis/FG++idf2bUhbksHs+wJEbIDCBBzOLwHm1E97GgwGPjrzEVq9ln4u/VqUtTEYDOS8+SI1RQqyg8VsWvt+Lq1qJN/OwYyPJgWyaN0lvjgQj42p8paa4q/0i4SplMjzs8irycTGxJbPZ3RqsbXN9VDKpHw2LQiFTMKa8+m8sDYMQRBu+rPvOMiVtKhC0iKLiO/2IMFnl6BOzyV52nQc336bE0EyNHoNXhZetLVs3lO+Vqfn8/1xgDjpaXWdPrvmoMnJIe2xx9GXlZHZRyzl+Pd2RmXS+jcYI4WUhYPa8u72KL44EMfEYBdMb5IVeCjgIc7mnGVD/AYWBC1o+IChMhfL2zE7IHITOAbi3M6SwQ/6c+CnKBL0Ppi8shqv5B2U792DNi+P4l9XU/yrOJ33upEFhWa2BHTyQfL5UXKUStDr0VdXo6+oEAU8c3LQ5ueLQtQ3QWJigsTUFImJCbXqYtJqi5EawFPpjKGiEl1ZGXK9DufKQpwr6/wO04HQq2uUy43INLUlx8wOhbsHXh3a0SXIFLm+AHVCOchkYDCgLytDV1qKOi2d2sQEaqKiqYmIaHCeSj8/pJMf4mykHepSNQ5tzBk2P+D6f7sDXhEDtcjN4uf2ftf9HlUyFf8b8D9m7ZzFxbyLvHniTT7p/0kjlxe5VOxBnbT8JJtCM5nc2ZW+pdthx/PiDt0ehVFLmhxguB62rqYEDXYj7EA6iV0ewebUa2jySkmdPRvrh+Zi9/xz9WLWf2XTxQzWh2QgEeDLmcG31GKxev8SZu2rYVi4BGXtGrSA1MIUM7d8Lro8TUqtPwjQY7wXXUZ43HE3hVvCtRvYt0eSF8VcE28+qMjg58ifmeE7A7n01v/mlTIpX8/qjI1JJKvPpPL21kjyy2tZNMzntodo7hT3fKBmZ2fHrl27/u7TuLvY+0PKcciLxidwEhJBQkF1AflV+dgZ39pNfGY3N745FM+ZpCIS8ipa1HsCQNRWqC5CYu1JW383Lh/JpKBNf2xDviX3o8U4//eT5q8lV4lipb+MY0zNLn6W9mRUoBiQbUnYwrmcc6ikKl7v8XqL/nBK1qyl9EQcVca2FFv4gAB+vVrQ29ZMJnd2JTa3nO+PJvHWlggwGG5sgXQdnFQ+gEC2TEaOVMp010IeeWjSLXmKNoVEIrB4UgcMBlh7IZ1Fa8OwMpbfuGdNIjBkbnvWvH2U4hoP8kY+QJvcBCpPnSb7tdfQ9HRG2cfQogB6c2gmSfmVWBnLW9RUfi3aoiLSH3sMbU4Oap+u5MvdQYCOg69j5t1KzO7hwc+nUkgprOKHo4ksGt6Ez20dfV364mXhRVJpEtsStzHbf3bDHQImiYFaxCaxX1MQ8O3hSFWZmlMbE7h0tgz9gFn0ef01qk6eoPTIUZIPncS2MAu76lLsqkvR7Uuk5GYnLpMht7dH7uKC3NUVuasLCldX5K6uyBwckdnaIFFd/T37+vdh/KAtZ5iRG59PF6+1Bo0GbV4emuxsNNnZlKdmkBeXjC49DVl2JqqSAsw01fgVp+NXnA5pF+EE3LzIfhWFlxem/fphMXEC5aaubP8qjOpyNVZOJox5uiPypkr+jh2uZtX2vg4PbGyy3O1p4cnSQUt5cv+T7E7ZjZOpEy90eaHRfp3cLHmopwe/nE7l3PpP6av+XtzQ40kY+fEtldO7jW1DYmg+5YWQPell/I6/SWmKMUW//EL5/v3YPf8c5mPHNpj6TcirqHdveHZIuxaJ8Rr0eipPniTj5xWMPnm+rq9Jh8K7LTbz5qEo/JM9EfPIrvVHIhMY9nAA3l1aR0LkjiAI4oT3rheZkHiW7+zsyK3KZXvSdia3m3xbS0slAu9PCMDOTMnn++P4+lACBRW1fDAhENk9aPF2zwdq/y+pD9SiMJLNxsvCi4SSBKIKoxhgPOCWlnS2NGKwnz0HovP481wab41tgdQFXNXdCX6Qds4OXD6SSb51IO2kCkq3bsVsxPB6va5m0aY/UXajaZ+/i6XGP2OpfIrMikz+e1409n6q01OignYzqQoNJeejDwEoDRIN1t3b22Bm3XqBz7W8OtIPDPD9sSTe2hpJblktzwzxvqnullanZ9PFTD7ZE4PO3gmpKotLSgUvd6xF0opB2hUkEoGPJ3egWqNj26UsnvztImuf6EmAc9MTT8bmCgYHnGFnSB8iinvS9uUnsDu8jvyvv8HvTBaLE8C98/WzGH+lVqur7017cmDbW5r01BYWkjbvYWrjE5DZ2ZE99nm4WEqbjrZY2t85w2iFTMIrI/148veLrDiezJyeHjjc4GckESTM9JvJ4rOLWRu7lll+sxo+aPiMBJlKlHbIjRTLeEDwMHfkSilH/4zl8tFMKkpq6T+7Lx9lW7Jb0wN7Qw3fD7bHS1OGNjcXfW0NhppakAhIjIyRGBsjs7dH7uSIzNERma1tk5IfOq2eopwqinNyqSyppaq0lsyY3vSRCnSy9ufC7hRMLZWY26qwdXXAuG5S2gK49q9RX12NOi0ddWoK6tRU1KmpaLNz0BYXoSsqxlBbW99nJzUzQ2JujtzJSdQIbOeNcbdu9fqR6TFF7F0aSm2VFjt3M8Y9G4SR6U2yrkPeFW3qEg+KGcrAKU3u2tOpJ+/1eY83TrzBqohVmCnMrkpVXMOLI3wxC/+JReqV4hd6LYThH95yz6NCJWPIQ/5sWRpKdLoL3hNm4Ra6iuwQazRZWWS9/AqFP/2MzaPzMR82jFpBysI/LlKl1tHLy4ZnBjfPYktbVETZjh0U//4H6tRUQGw+Twuwpc/zizHp25eK2Ets+Xo8xTo3FCoJo59qQuD6XqPjdNj/Nsr8WOYGLeKzxA38ePlHxrcd3yI3lOshCALPDmmHramSN7dc5s9z6RRWqPlqVnDz3FLuIvcDtXuR+oGCGADa27QnoSSByMJIBrjdWqAGMLuHOwei89h4MYOXRvg2/5exIAHSToEggU6zcTS1wNRKSUVxLZppC5Gu+Zzst9/BKDi42TplBoOBN6pmsspwDHdNIvozy3mrIoxKTSXB9sE81L75gsaavDwyn30OtDpM3NSkmg+BWmjft/WzaVcQBIFXR/mBAN8fTeKbwwnsjczho0kd6OZp1SgTWKPRcTA6jy8OxBGfJ9pDOeJNJVmEqZSMyLl0vcO0ChKJwJJpHckrr+FMUhEP/3SezU/3abLPCcCzagPtjaqIqh7G4d9imfnW40S5gOy9r3ArAB59mZJ33sZy4sQbHnvViRQyS6qxN1PeUh+IGKTNqw/SbJev4uD3osJ+p6F3dqobYGSgI108rAhJLebzfXH8d+qNNfTGeY1jachSkkqTuJB7oaGThtIUvIeKWbXo7fWBGkBgfxfkSimHfokm+VIB8TFFRMqqUagkfD5vAMHtbq3PUl2jJSu+hMzYYjLjSijMrECvazgE48YA3BAVKM5GJTXYZmFvhHM7SzwCbXDzs0ZhJN4yJEZGqHx9UPneWo8miAMm53cmc2FXChjAqa0FYxYGoTRqxm3J1hv6/QeOfAx7XoO2Q8DIssndx7cdT25lLl+FfsWXF7+kRlvD052ebvB3aha6ghd1YpD2g24cA4Newec2S2EuvlZ0HORK+OEMDqWMYVbHC7S1v0BRVlsKwyXURkeT9Z8XybWz5VL7Psh0zji4+/DlzE5NylcY9HpqExKoOn+e8gMHqDp7rr6MbDAxYlf7Gg50kfHtw79iatGGwswKtn+bSaXODRNlJeNeGoSNS+tbmN0RVBZiEB66mmk5qaxQWpBWnsb+1P0tdutpitk93LE2kfPsmjD2ReXy0I/nWDG3KxZG907P3v1A7V7EruHkZ6BtINsStxFeEH5byw7wscfF0ojMkmp2R2QzKbiZGavQumya9zAwd0YA2nax59KBdPKce+Dt3RZ1QiI577+P69KlzVoyMquM0EIZn8ln85H0B/64sJTzlqYYyYz4sM+HSG9g9XMtBrWazOdfQJufj9JCg6aTN1XlSozM5K02RNAUgiDw6kg/OrpY8s62COLzKpj+/WlcLI0Y5GeHramSWq2e1MJKjsTmU6UWMwyWxnKeHuiNvbOBN08eE4Vvs+9coAZiX8b3D3Zl2neniMutYN6qc2xY0Pv605elmVCcQm/zX0lTjqasoIYzWxLZ65LB0flSFh90wC4yi+xXX6Pq3Hkc33rzuv02OaU1fH1IzKa9MtKvxU+ptUnJpC9YgCYtDZm9Pe6//ExouB6dVo9DG3OcvC1v5a1oEYIg8Ppof6Z8e4p1IelM7+ZKF4+mZRJMFaaM8xrHurh1rIlZ09jyzH9cXaC2DQa91mCTbw9HLB2MWft1KLJKHTNqlRjbmuDVgsu0Vq0jJ6mUjNhiMmOLyU0px/CX6WSFkQwbZxNMrZSkFB7ltDoVV0HB6IB5VJWpqSyppTi3ioqiWkrzqinNqyb6ZDYSiYBjWws8Am3wCLTB2tnklnt6cpJLObUhgexE0faqfV9n+k1vh6yZE86A2Ot6eT0UJsChD2DM/264+2MdH0MQBL68+CXfh39PpaaSF7u+KF5rTn0tCtkCOy1msTh3LLs2XmbDgl63XQrrObEtqRGFlOZXc8j1I0aazcLWPQHLEQ9RnOtD8fp16PILCDy6lSWA3siYqigfMt3ckNnbIQgCBr0BbUE+moxMahMT0Zc2tAtTBQRgPmUy/zHaRkhZJFN9ptDGog2ZscXs+vYS6lojrGRpjHs8ALN/SpB2ha6PQOhqjKO388DI11kWtYofwn9ghOeIRv2Gt8rIQCd+fUTBY79c4FxKETO+P80vj3S/YQb9bnI/ULsXudIcW5YBNWV0tBOf4i/nX74lh4IrSCUCM7q58fn+OP44m9a8QE2nhUt/ip8HX5228a4L1FIii+n9wSdkPDCT8t17KB06FIsxY2667BXttBLf6cSqL7JUEMVd/9NlEe7mzRcpzf3kv1RfvIhEJcW1by77lW9DudibJr0LvQaCIDCmoxO929rwye4YtoRlkllSzW9n0hrt62yhYnJnVx7r74WFkZysCvEiEK1UUJ2TilF1sai5dYewMJLz88PdmbT8JPF5FTy2+gKr53dvXK5NPQmA0tmbQX3bs/3rS4QfziCmUxqlJgJGXy3GdmsIBd8so3TTJmouh+OydGkjDbDFu6KpUuvo4mHFpOCWTWZWnj1HxrPPoi8tRe7sjPuqH8HRlYivTwEQPNz9rjX+dvGwYnpXV9ZdyODVjZfZ+Wy/G4rgTvedzrq4dRxKO0ReVR72xtf0AfmMAIkM8qLETLVtw/dsQ3IeX8sqGKCQE6yRUZVayeb/XcTK0RhXXyuc2lliYqFAaSxHrzNQXa6moqSWgowK8lPLyU8rR6dtOExgbqvC1dcKFz8rHL0sMLNW1b93836eR4hQy1D7/vQa1fBcqsvV5KaUkR5dRFpkESW5VWTFl5AVX8LpzYmY26rw7GCLW3trnL0t67NtTaHXG8iOLyH8SAZJoaJchlwpZeAcX3y6t0zIFBDlfup6XTm/UvStDJh4w5c82uFRjGRGfHLuE36L/o3EkkQ+VbbB8nBdj23/lwkOfgGzL48Tll7CssOJPDe0eSXIppArpQybH8CmJSEkRVYSPvAHgmKmIIv+FbupP1EydTufvfEdXdLD6V2ciLKyjOqwMKrDwppcUzAywjg4GJPevTAbMQKFmxub4zcTcioSI5kRTwY9SUJIHvt/ikSvNeAkj2R0hwOoAubd1vfyt+DSWbR+yL7ErIoqfpWbkVCSwO7k3Yzxuvm9prn09LJh7RO9mPvTOWJyypm8/BS/zu/eyHv67+B+oHYvYmQFZs5QngX5Mfi4BKOUKilTl5FaltoikdG/MqObG18ejOd8SjFxueX4ONxk3DxhP1TkipOoPiPrv+zgaY6ZjYrywhpy9fbYLlhAwbJl5LzzLkYBASg8mz5Hg8HAjkviqPiwQBteTJCirhToV1XN9OqbT6xdoWTTZor/+AMEAecehaiNLUktEINP/953rux5PaxMFPx3akfeHR/A6aQCjscXoNbqUcmlWBrJGeBrRwcXiwbBhZOJE/ZG9uRV5xGpVNA1O1z01LyDOFsa8fPD3Zn23WnOJRfxn3WX+GpmcMPpupQT4kfPvrgH2ODfx4nok9l0iR5Lfrd0gp26IHuqB8adu5D50ovUxieQPGUqtk8+ic0jDyMoFJxNKmTbpSwEAd4b38T03nUwaLUU/riK/G++AY0GVVBH3JYtQ2Zry6WD6dRWabGwN6JN0O1PxraE10f7cygmj/i8Cr47msizQ5q+efta+9LZvjMX8y6yMW4jT3Z68upGIyvR5SHxEMRsF7NCdaw+k8qSvbEgQM9p3kzzcyR0XxrRp7MpzqmiOKeKy0dv3q5vbKHA1c9KDM58rDC3vX6Ju7g8i1BqAIFBAbMbbTcyU+DZwRbPDmJmujS/itSIIlIjCsmMLaasoIbwwxmEH85AkAjYuppi42yClZMJKlM5MoUEg85AWWENJXlVpEcVUV0uynAIAvj2dKT7OK/b6yNt019s+D/7LWx+AsxdwO3Guolz/Odgo7Lh7ZNvcTr7NDM0x/lUqSCo14sw8BWcgQ8mBPL82jC+OhTPAF87OrlZ3vo5Il4v+05rx7E1cZw6JsW+/zs4xbyHYdszvC//jOMOHajoOYDHHumGLikRdXIK6vQ0dAWF4pslCEitrcShEDd3VL4+DZwCSmpK+DzkcwCeCnqK7DO1nFgfDwbwMjrPMPMlyPo1LWVyz9PjSdiyAIuQX3h46At8dWk534R+w3CP4bc1AfpX2jubs+nJ3jy06hzJBRXMXnGGoy8N+tt71u4Havcq9n5ioJYXjdytO/7W/oTlh3G54PJtBWoO5iqG+tuzNzKXP86m8e74xuLBDQj7XfwYNBNkVxt8BUHAu4s9ofvSSAjJZcSCJ6g8c4bqkBAynnsez7VrGkyWXcvFtGIyS6oxVco4U7aClMps7KXGfJSfgbD7JfDoCdY31tqqCgkh5913AbAd4oGZbSYXpAswGMC5nSVWjrdmlXW7GCmkDPZzaJavqiAIBNkHsT91P2FKJV2zL93xQA3A38mc7x/swtxV59gRno2zpRGvX+tYUZdRw0P0rewztR1RYalYVNoxOn9ufROvSc8eeG3eTNYrr1J58iT5X3xB6fbtWL6wiDcuiRmnWd3dm23VUpuURPZrr1N9SSwDm48ehdPixUhUKnQ6PWEHxSxlp6HurSq50hwsjRW8PS6AZ/8M5ZtDCYzu4Ii3fdMPOTN8Z3Ax7yIb4jbwaMdHkUuuuZn4jxMDteirgdrWsEze3ipO+z0z2JtH67TmBs7xo+fEtmTFlZARW0xeahm1VVpqqzQIgoCRuQJjcwXWzibYuZlh72GGpYNxs7KNR8N/Ri8I+GkNOLs1Vu7/KxZ2xnQcZEzHQa5oanWkR4tBW0ZsMWX51eSniRm9G6E0ltGmkx2dhrph49xKmYoRH4m6k3G74c+ZMH8f2NxYOmakYw/aGBx4QZNAulzOg86OPGAisFBThbHcmAmdnDkQncuO8GxeWBvGzmf7tshj83oEDnAhO6GE+At57A3tziSP4Vjk7ePlmk9IMfsv38zujFwuQ+7ri8r3xhPGf+XL0C8pqS3B28KbtjG9OVE3wNPBK5O+lZ8gcQoA39bLPt11AqfAwfehPIs5WgW/q2zIqNNVm+E3o1UP5WZtzIZHOpC/fAxlwU//7UEa3OPOBP+vuSJ8W9en1sGuAwDh+bfXpwai7ADAxosZVKtv4FRQWw5x+8TPg2Y22tyuqxiMpF4uRKMTcPn8c6Q2NtTGxpLz4YdNLru9LpsW4BPLzuQdSAQJnw75BivXnqCugI2Pgq6xKOcV1CkpZDz1NAa1GrNeQdjanMJgkBBVIfpRtu9zd7Npt8MV389LSsUd71O7lj7etnxa1xj/w7EkfjpZZzJdniP2/CCARy8AlEYyQvx2AmAW60FWfHH9OjJbW9xWrsB5yadIbWxQJyaSt/Bpnlv3IWOKonhxgOdNz6U2KYnMl18maew4qi9dQmJqitPHH+P8v//VB/uxZ3KoKKrFyEyOX89bKJO1AuM6OjHQ1w61Ts9Tv1+kslbb5L5DPYZirbImrzqPI+lHGm70GwsIkBkCpRkcjM5l0bpLGAwwt5cHi4Y1bNBXmcjxCraj/0wfpr7SlTnv9eSRJf14+NO+zHyzO+Of7UTfqe3w7eGIlWPz+8YOpx8GYJCJR4snG+VKKV6d7Bj0gB8PftCLBz/qxcgnAuk+rg3tujng0cEGF18rXP2s8O/tRI/xbRj/bCceXtKXIQ/5t16QBiCRwpSVYnmsqgB+GASX1ogm6n/FYBDlUb7vj2/icf7MLWW8dRAGYHXUaiZtncTOpJ0YMPDRxA44mqtILqjkpfXhGK63XgsQBIGBD/hh7WxCZama3xOfJEvnTAdJChu9d2FndmuWdGF5YWyM24hUJ2dG5iLCD4jDNj1H2dOv9iUkgh4GvdkiHbh7DpkCei4AwPjM9yzo+AQA34V/d1tuBU1hc/pj/LTRdI/9FDTXd+W4m/yDf3L/cuzq+tTyROuojrbiTfV2BwoA+nnb4mZtRHmN9sYWGrF7QFcLNt7gENhos62bKRZ2Rmg1elIuFyB3sMflsyUgCJRu2EjRr782eo1Ob2BHeDYSVSZxup8BeLrT03Rx6gaTfxCnfDJDYP87173QaouLSXviCXSlpagCA3BuH4kgQEabVykvNaAwktG28z2sDfQXrhW+NWSH3dVjT+7syksjxCf393dEib8LV7JpDoH1/XIppSlcUBwh1l40Yj/4awya2qsBviAIWIwbR9tdOykdP4NqqQLv0kwWHltF/tCBZC76D0W//07F8ePUxMZSdTGU8kOHyfviC5InTyFp9BjKtm0HvR7TQYPw2rYVy0kT6wMOnU5PyO4UAIKHe7Ss4bwVEQSBT6d0xM5MSVxuBa9sbPrmrZAqmNJOlIxYG7O24UZTe3AXg+DYw3/y5G8X0ekNTOzkzDvjAu5K7121tppTNaI13+BWmJ4ztzGibbA93ca0Yfj8AMY+HcTEF4KZ8Hwwgx/yp+voNri1t75zfaNKU5i9Dly6Qm2pWAb9Yzpc/FU0cE87C2d/gJVDYMPDUJIGFu5YPLKXj8b9xvIhy3E0cSSrMotXj7/KzB0zCS08yZezgpBLhXoD+9tFoZIx7plOSExlGCrht6L/otYbYR/9i6hV2UIqNZW8dvw1TGotmZvwNoWXNXVaiP50kf+KoKsWhWN9Rtz2uf/tdJkHCjMoiGWKYI6LqQsF1QX8EvVL6x4n5SScXyF+Pu4rUffzb+Z+oHav4lCXUcuNBIOhfqAgriiOGu3tRfgSicDMbmLD/h/nGje91xO1RfzYfuJ1n7gFQcC7qxgUJVzIA8CkVy/s/yMa5+Z+/Alle/Y2eM2JhAIKqoswcfsdrUHDANcBVzWNLN1g3Jfi52eWwdH/NnitrqSE9PmPoklNQ+7igtsMdySVaWDhRlStaGfk293hb7uR3wr+1v4oJQpKpFJSS1PFLOZd5KmBbZnTwx2DAZ5bE0ZKSF0G1bNP/T5HM44CUNsjHVMrJWX51ZzZmthorWy9nAWmvZk3/A1ih01F5uCAvqqKsl27yP3gQ9Ife5zkCRNJnT2bjKeeovC776mJEh9ETIcMwXPDBty+XY7cuaF7QuzpHMoKajAyVxA4oPXtolqCvbmKb+d0RiYR2BGezcrjyU3uO81nGhJBwtmcsySVNJS9wF+0wSu5uBG1Ts+IAAeWTAu6ayXdM4l7qBHAWaPFN6B1S0d/G2aO8MheUUxYIof4faIF1Le9YNVw2P2S+BAoN4GBr8NTp8FJvK72c+3H1glbWdhpISZyE6KLonnm0DN8GPYwE/qngqDms31x7I/Kve3TPJ9XykppJZWCAROdKZtqfqBMZwdbF4oDJi1g8dnFCOlmTLv8Eooic1SmciY81wk/PzWE1PWk1Ykr/+NRWUAX0VNXfnoZz3d+HoCV4StJK7vBfawlaKrrbMMQLazaDmqddW+T+4HavYp9exCkYiq/PBsnEydsVDZoDVpiimJue/lpXV2RSQRC00qIzi5rvENNGcSL5tsETGpynfryZ2QhtdViKch6/nysZs8Gg4Gsl1+m6vz5+v03XEjDyHktyIpwM3Njcb/FDUesAybB8I/Ez498DMeWgMGArqSEtEfmUxMVhdTaGreH/JFFin6g1YOXkhReAoB/31v0Mf2bkEvlBNiK2cpQlQJyLt/V4wuCwPsTApnS2RWd3oA68bi4weNqoHaldNffqw+DHhAzveGHM8iKL6nfJ7eshjkrz1JSpcHDy5nRS9/D+/AhPNeuwebxxzEdMgSljw9SKyvk7u6oAgMxHzMGp08+pt2J47gt+wajwMb9kjqtXtTZArqM8Gharf4u0tXTul4wevHuaFafTrnufk6mTgxwFXsO18ZezaoZDAbWVQaJawkxPBBoxLLZnW/Z2/VWOBy3EYBBgjGC6d0dzLijSGXQ/0V44pjoKezZTwzMTB3FYaiBr8OzoTDwFTELdw3GcmOeCHqCXZN38XDAw5jJzUgpS2FvznKs/T9FYbeHhWsPczTu+gbvzeFIbB5P/XaRQkFPURcLjMwVFJaZsqF4KdnlzrBmtnjtbQbbo3dSuteEMTELUGpMsHUzZdprXXHxsRTtr3RqcdjiLvS93jV6PiUG4aknGaGV0dOpJ2q9msVnF992aRqAw4uhKBHMnESx43uE+4HavYrcCGzrelVyLiMIQqv2qdmbqRgeIAZZf5y9ztNI3N5ryp5NDxxYO5tg5WiMXmsg+ZJ4ARMEAYc3Xsds2FAMajVpjz9B+ZEjlNdoOJjzGzLTOBQSJUsHLsVccR2P0N4LYeh74ueHPkTz1VDS5kwXgzRLMzym26FMriurDnqT2Hxf9DoD9h5m2Lnd3DT5XuNK+fOS6s7rqV0PqURgydSOzA82xUciThUuT3ZApzdQUlNCaJ5o8DjQbWD9FCgGOPhrNBq1joKKWmavOFNvGv7DQ11QyCQIEglGQUHYL3oBt2Xf4LVtKz6nT+G9by9tNqzH5X+fYTlxIjLbpvXuYk5nU15Ug7GFgoB+904Q/lAvD+b19sRggLe2RvLlgfjr3ihm+oq9ndsSt1GlqaK8RsPCP0J5+UAJl/ReSAUD7/ul31XbGp1ex9FiMZM5yKH7XTvuXcWhPQx9B+btgDey4MVYmL1WDNDMbjzoY62yZlHXReyftp9Xu7+Kq6krGkMFStsjyNt8zJP7n+Hr09vQ6W/Q33sdNodm8OgvF6jW6Bjoa8f78zoz7dWu2LqZUq01YXPRRxxOHETl2kU39GtV12jZt/UCscu1+Of3BAwEDXFjyktdMLcxEgfAEg+JLhhjmqdr+Y/BwgW6Pw6AcOBd3uj+GnKJnJNZJ9mXuu/21k49JerpAYz5/IYCyneb+4HavYyjGJiRLQZmrdmnBjCnbqhgc2hm48boyM3ix4BJN0ybX5n+BEgIybv6dakU5yVLMOnbF0N1NRlPL2TrkreR2hwA4N3e7+BrfYPJpr7Pw/CPqCoyIfmndGoS05Eqdbj3TERZcli8CE1dhaH/i0SdEPvs/PvcOzfylnBloCBMqYCssL/lHCQSgTcCxSGBGL0bnx4v4KFVZ9mZeAidQYePlQ8upmLZsc/UdvUl0G2/RjLtu9Mk5lfiZKHij0d74mTRtONBS1DXaDm3XSwtdh7x9/WmXQ9BEHhnXHueq5PpWHogjsd+DSGhznXiCj2de+Ju5k6FpoIPj/7GmK9OsPNyNjKJgMZHnMKTxGy7q+d+KS+MIoMGM52ezr5NWy/9f8dEbsIc/znsmLSDLwZ+QbBdZwRBj9Q0kh/i3qDfn8P4Nuw78qrybrhOrVbH//bF8sLaS2j1BiZ0cuaHB7uikEkws1Yx+cUutOvmgAEJUdUj+O3MJA59uob487mUFVRTXlRDaX418RdyOfx7DL+8fpL43WUYacyoMSlj/KJO9J1WJxZclgV7XhcPPOj1Rjp9/wr6vwhKC8i9jGfqufrWmf+e+y8lNSW3tmZNKWx6AjBApzngN7rVTrc1uB+o3cvU9U+QUxeoXSN82xr08rLB08aYilot2y9dM1RQUwYJYkBF+4k3Xce7rvyZHlVETeXVaU2JSoXbt8uxmDABdDq6/L6Fp3bo6CYZwri24264pr62loJIJamHbNDVSFFa6PAcWoDKzR7aDoZ5OyFwCjmJpRTnVCFTSPDpdnNJjHuRIHuxDJaoUFCadfFvOw9Jqigmq2jbDyO5lJMJhSw+LJbIuthdLYUqVFL8xolBfvaFfNQ51Tiaq/jjsZ64Wbee9+aFXSlUlamxsDcisN/f25t2PQRB4IVhPqJOnAAHonMZ8cUxFq0NY/WZVE4nFrLrcg72DARgS+J60orEgHbtE73oOlLstyHpKFSX3LXzPhS3AYABNWrknn3v2nH/qUglUoZ4DOHX0b+wYewmXCXDMeiMKNfms/zSMoZtGM5zh57jeMbxRlm28ylFjPnqBF8fEnvPHunThqXTOzUQTJYrpQyfH8CkFztjb69GazAiOsWRfT9GsvrN0/z6+il+e+s0+1ZGEnU8C3WVjlJlPlGBB3jkg4G4+dQZt+s0Yp9bbSk4d4aeT9+19+iuYmwN/er0Bw9+wHy/OXiae5Jfnc8bJ99Ab2i+Fmc9u16C0jSw8oRR/73p7neb+zpq9zKODQO1QNtAJIKErMoscipzcDS5PZkCiURgVnd3Pt4dwx/n0pjZvc4RIH5fs8qeV7B2MsHGxYTCzEqSwvJpf01mS5DLsf7oXTaVnWTQ4QIGXjYwMO0MRYbVmI8e1ajspauopOLgAfK//ApNlhg8mo0YgfP7byMxUoGiYSAQdVLcx7urw02V0e9VrFXWeJi6kFqRSXhlOv1qykB1nZLwnaZO6Nar63C2jezDf9aHkGQcC8DKvcZsPLAfVysjsktryCuvZYRCTke1jGk6Ix58qic2lq03HVWSW8Wlg+kA9J3WDqn83n2mnNvbk95tbfjvnlgOROeyKTSTTaHXCNNKPDFtJ0eqyuHBgXpeGTQAU6UMsBKnu/NjxL+5jtPv+LkaDAb2pR8BYIip5z0x0fZPwtemHTvnfMZPp+P438kNGMzOIDNO4VD6IQ6lH8JK4UB3m1FYG/pyNKqW2FxxOMjWVMG74wMY27HprL+ztyVT3xtBxoaVpJ2+TLo6iGK9J0gkCIKAiY2MCNVZIlTnUDsVsXrsaqyMLcUX6/Ww9WnRpF6qhAnLxH69fys9FsC5FVCWgfLMtywZsIQ5O+dwLOMYP0f+zCOBjzR/rUtrIHyt2BM+eQUo7732mXv36nefq6XP4hSoKcVEboKftdjMfTG3dTIvU7u4opBKCM8oJSKzzj8uZof40X9cs6eFvLuI2az4842noj678Bnf9yzhzdkm5No6QWkpuYsXE99/AClzHiBz0SKyXnmV1AcfIq5XL7JeeRVNVhYye3ucFi/G5YulSCysGwVptdXa+mnT9v/QsucVghy6AHXlz7ss0wFAVRHkRYqfe/SlnYMZr05SIEhrkRnM0de4UFip5lJGKXnltShkEir9zZCbypFX64nel96qp3NifTx6nQGPQJt6Zfx7mXYOZqyc25X1C3qxYEBbBvvZ425tTJCrBTO7+BJkJU6P1RqdqAvS6qib/iT67pQ/wwvCydZWYKzX09fr3irv/FOQSATm9/Flz/wX6KZ8i8rEF1AX9cGgU1GszmVv9s/8kf04qbLlKM3imN7FhQOLBtwwSLuCIAi4TXuMPuMcmWm7iCftJ/PkmL30fN2Ylf5vsMvpZ2qcC/h2+LdXH9QNBtj1ohhsSGQw/derqgH/VuRGMOx98fOjn+JXWc6rPV4F4KuLXxGSG9K8ddLPw7Znxc8HvAxu92bP5r845P4XYGwNFm5Qmg45EeDZhy4OXYgqjOJC7gVGt8KF1sZUyYhAR7ZfyuL3s2l8PN4H4uvKnn5jm72OT3cHzm5LElXKC6rrbWv2pOypn3gLF+ZQsnQyHWNPULp1KzWXL1MdEkL1X9aSu7lhOWUy1nPnXtfs+wrx53PRavRYORrj6PU3ZKBakWD7YLYlbuOiSgmZF8VprbtJXdkTW1+omwI8knEEgAk+w3hhxkjSi6rIKK7GwkhOsLslKrmU1IhCdnxziUuH0nHxtWwVa6f4C7mkRhQikQr0nXZ7Pot3m26e1nTzbGzaHlU4nxk79rE/bT8F1QXYGtUFn/7jxcnm+AOgrgTFnXXU2JMgBoSDqqpRteDv+z6Ncbcx5tdHupNZ0oHdlwdyOC6TfPV5SqTHqJYmIjePBPNIwiV7WZ8whYneE7Ezbubfx8DXwKCn/PhnfB//J7/n7kQriHI+Xw/+GgeTujaPvGjY8xokHQYEmPQ9+I684dL/GgKnQOxuiNgAmx5l6uPHuJBzgV3Ju3jm4DP8MPwHAm0b63/WU5IuTtnqakXXhv4vN9gcWxSLg7EDlirLO/t9NIP7gdq9jmPHukAtHDz70NWhK6ujVjf/iaEZzO7uzvZLWWwNy+Qtv0yM1eXiOLtz52avYW5rhKufFRkxxcScyaH72DaklaXx7ql3AagtGIQlgYzs5Iqq2xysH5iDOiOTqrNn0FdWYdCokZiZYdKzJwr35pmyXxkiaN/X+a4ZdN8putRl1C4rFagzL6C4yf6tTr2/p9iLZjAY6mU5BrkNwsJIjoWLRSM7KI9AGzoMdOXykQz2/xTF1Je7Yu1868FGWUE1R34Xy62dR3hg6dB6PW9/J+1t2tPRriPh+eFsjNvIE0GisjqOHcS+mOIUcdI6cPIdOwe9Qc++5D0AjBDMwfafFQTfq7hYGvFoP686269+wCLii+PZGL+RbYnbyKzI5KvQr/gm7Bu6OHRhsNtgerv0xtPcs6E00TWklqexz9aB37z9KNJWAjC8opIPKtMxPvO9qJZfkioGKgYdSBXipGKHqXfvG/+7EQQY+zmkn4PiFIRdL/LOuC/IqczhYt5FHt/3eNPBWmWBaDdWmSeKe0/+od65QafX8XPkz3wT9g2D3Qbz2YDP/vb7y/1A7V7HsQPE7qzX1+psLwZPSaVJFFYXYmNkc9uH6OlljZedCUn5lWSc3owPiFMvLbQc8evlJAZqp7LpOMKJF4++SKWmEmN9O8rzhzJjoFsD3zSFqwsK11ubOstJLiU/rRyJTMD3b7IUak08zT2xlptRpCknIu8SzQ+RW4nUq0bsAHHFcWRXZqOSqujh1OOGL+0zzZvCzAqy4kvY9W04U1/tisqk5UbJOp2efT9Goq7W4uhlTtcxni1e415mpu9MwvPDWR+3nvkd5oueqYIgTlafWAqRm+5ooBaWF0aepgxTvZ4+Xv9g38d/AO2s2vFq91d5rvNz7E/dz/rY9YTlh3E+5zznc87DeTCVm9Lepj12xnaYK8zRG/TkVuWSVpZGUulVgWRPU1derlXQr/Ak6Avr3Wrq8R8Hwz4A6zZ3+bu8B1BZwJQV8NMouLwOY4Uxy4d/zVOHnqkP1t7s+Saj2oy6GmwVJcNvk6EoCUzsYNaf9Zp6aWVpvHXyLS7mia1Far0atV6NUnpr9l6txf1A7V7nyuRnnUSHpcoSb0tvEkoSCM0LZajH0Ns+hCAIzO7uzkc7I7HNqCt73oKBb9tgO46tkVFeVMMXO34guiwac7klWVFTkQhS5vT0uO1zvUL4IdHPzqerA0amdz3/1OoIgkAXhy7szzjCBW0JnSsLwOQu9WZVF4uldQAPMVC7kk3r6dwTlezGDedSqYSRjwey7uPzlOZXs+vbcMY+HdTi4Y6zW5LITS5DYSRj2CMBd85u6G9ihOcIPrvwGblVuRxJP3L1bzdgshioxe8XnSnuUDPz3rps2uDKKhT/ZIPufxBGMiPGtx3P+LbjySjP4HD6YY6kHyE8P5wKTQXncs5d93VSQUoPpx6M9BzJ2LZjkUvkYh9p9HbIOCfau5k6ivZQ7jd+kPrX494Txn4hivyG/IxJVSHLx33J08f+Q0huCK8cf4W9KXt5tfurOOXFwsbHxEyapTs8sAks3ckoz2Dl5ZVsTdiK1qDFRG7CK91eYaL3xL89mwb3A7V7nysDBfnRoK0FmZIuDl1IKEkgJDekVQI1EIcK9u7dgbWhGJ3cFGmbfi1eQ6aQ0q6bA5HHMskOqYF2EKh4gkytBcPaO+Bi2Tr6WpUltSTWabZ1HOzWKmveC3R17sX+jCOEXOlT8xl+dw6cehowiFO+dWKg15Y9m4ORmYLRT3Zky+ehZCeUsu2rMMY9E4TS+OaZNYPBwPmdKYTuF4WXBz3gV9/j+G9CIVUwud1kVl5eyZrYNVf/dh07iO99YYJYyroD0586vY59ybsAGKERxJvbfe4qrmauPNj+QR5s/yBavZbEkkRiimIoqS2htFYc5HI0ccTB2IEgu6DGvVHG1qKFUp2N0n2uoctcUaB246MQvR2TjBBWdJnLSp92/BC/nkPphzicdojg2hoGSauxcPZF1ucZktN2c/bcu0QWRKIziNIqfZz78Favt+p1I+8F7gdq9zoWbqCyhJoScYzfKYiuDl1ZG7uWC7kXWu0wlsYKnnaKhXw4J+tCL9mtpXqdOhsReQy8CjviMuJRfj1gB2h5qJdnq51rxLFM9HoDTt4W2Lnfe6PUt8qVPrVQlRJN5gXkdy1QqzNiryt75lXlEVEYgYBAf9fmDzXYuZkx4flObPsqjNzkMrZ+EcaIxwKxsGs66DIYDJzdlkTI7lQAek1qWy+g/G9kms80VkWs4mz2WZJKk/Cy8Korf06GY59CxKY7EqidyzlHgboUM52eXq4DQNry0vR9Wg+ZRIavte+NRb/v0zLaTxDvlRsfhfIs5Ec+5klgsFzOf22sOG+k4qJK/AfVcOHTBi/v7dybJ4OerHeKuZf4d9UW/o0IwjXlT9Fe6MoNPbYoljJ183zhmkMf7RkA/ijtwLnkolta44fsLyk0ykJmUKCK6ENFrZa2dib08b79XjoArUZH5HFRo6rjoH9PNg3EvhZziZJqiYSYzNN378BXBgnqyp5XTNg72Ha4Op3YTOw9zJn4QjBGZnLy08pZ88FZwg6kodc3tlcqzKpgxzeX6oO0PlO96Tyi9crj9yLOps71we/amKv+n/W9aQkH7oj47ZaELQCMrqxE7ne/7HmffyleA+CFCFEPzbU7SJX4yi1YpTFnv2UfXg58nGEew+jv2p9eTr0Y5zWOD/p8wN4pe/l+2Pf3ZJAG9zNq/wycO0PyMcg4D50fws7YDg9zD1LLUgnLC2tR1qNJ8uOQFyegFWQc0Xei8EAcfzzWsvLIobRD7EvbR4BTJf2SplMZUYpgCs8Oaddqdf7483lUl2swtVbi1ene19dqCRJBQmdrf44UhHGhNJ4OBkOzdexumZrSekHlKxOfR9PFQG2g28BbWtLW1YwpL3fl8OpoMuNKOLkhgbD9abj5W2PvaU5VmZqi7EqSw/IxGKiX4egw0LU1vqN7nlm+sziSfoRtidt4rvNzGMuNwd7/qvhtzE4IntNqxytTl3EwVew9nVhRDd5DWm3t+9znnkOmFLPSf8lMOwIP1v37p3E/o/ZPwK2uWTT9auPplaza+ZzzrXOM2J0AaN36UiM14VRiIWeTCpv98nJ1OR+d+QiA7gN8MSgkmOsE+hubNEvosTno9QYu7hWzLx0GuCL5lzWbA3R1GwBAiEQLpRl3/oBpZ8CgB2svMHemSlPFmWwxs3qrgRqAhZ0RE54PZuAcX5TGMipL1cScyeHYmjgu7EohKVQM0ryC7Zj1To//N0EaiAMaHuYeVGgq2J64/eqGgLqs2uX1rXq8Pcl7qNWraatWE+DcU2xEv8997vOP4d93p/s3ckUtOT9GnNADejiKwduJzBOtc4wYsdFY1WEc07uKJcVP98Zet2R1PZaGLCWvOg93M3dm+88nRC56fvYzKJFKWicrlHAhl5LcKpQmMgIH3DuNnq1JV+deAFxUKtGln73zB6wve4rZtDPZZ6jV1eJi6oK35e0ZOgsSgYB+Lsz7pA/jn+tE8HB3PAJtCOjnTO/J3kx5pQujnuiApf2/QyutuUgECbP8ZgHwa9SvV/0hr2QAko6IYpytxNa6sufE8kqEu2BTdZ/73Kd1uR+o/RMwsRUzHgAZ4gBBb+feSAQJCSUJ5FTm3N765TliWRXAdzQLB3tjrJASklrMH+fSbvry8znnWR8nZgHe7f0uP53M5JxUjU6A2pxqcpJKb+/8ELNp53emANBpqDsK1b+zau9r7YuJIKVcKiEu+cCdP+BfBgmuTHsOdBvYauVqmUKKm781vSd7M3ZhEAPn+BE83B3HNhY3f/G/lEnekzBXmJNWnsbBtIPiF63bgGc/wACX/myV4ySVJBFecBmpwcDYai3433cjuM99/mncD9T+Kfyl/GmpsqSDrSjdcTzz+O2tHbsbMIi9cObOOFkY8fIIcRrpk90xZJf+1eTpKjXaGt47/R4AU9pNQaFpx4/Hk6mUgLWfJQBh+28e7N2Ma7NpHf/FZTKZREZnMzEoP5PXOn6uTVJbDllh4ucefdDpdfWDBANcB9zZY/8/x1huXJ9V+yniJwyGusx18APix9DfRKPt2+TKEEG/qmpsvYeKAqH3uc99/lHcD9T+KVwpf15TDuvrImZBTmTcZvkzRuxP45ppsAd7eRLsbklFrZa3tkRcvZH8he8ufUdqWSp2RnY82fE5XlgbhlZvYExHJ0ZOES1qEkPzyU2+9elUvd7AhV0pAHQa4t5iIdV/Gr09xGbv09piMZi6U6SdFe1nLD3A0o2w/DCKaoowV5jT1bHrnTvufQCY7T/7/9q78/ioqrvx45+ZTDKTZLKThWwkgZBADEuRXSCyKSAUFFuKWhYXELRaH6U+ilIoKiqVytM+0uclslgEfLEK4g+EQrEsolDZdxKCQCAh+76d3x+XDMbsJJPMTL7v12teJPeee+Z7OLmZb+695xyMTkZO3Dpx51nTTmPAxUNbHqjiauddKigtYOOFjQCMzc2D+EcbG7IQogVIomYvQm8nalcPw+1nWgaEapPSHrx+kJKykrurtygHErWrKD9dhN1Jr+PdR7rg7KRj5+mbLP13YpVDz6SfYfnJ5QC83ud1Pvz6Ry6l5dHWy8TbY+NpE+phWd5p3/rzNSZ7dTnxrx/JSMnH6Gagy/2OezWtQt8obVHlw0YjhRWLpVvDz5aN2nl7ZGBCWII2E7qwKl+TL2M7jAXgkxOfaBtd3CD+9rJq//lHo+r/4sIXZBZlElpSQkKZM0Q307x8QogmJYmavQjopP2lXZxrWeutk28nfE2+5JfmW9Yma7DzX0NZMfi2B//Kky92DPTg5eHatvlfnmblgSTLvtLyUt7c9yZlqoxh7YaReDmSz77VbnH++dGueN2ekb7PL6MwOOu5fiGLS/9JbXB4uRmFHNysrXvXZ2x7h7+aBhDlFUWAzplivY4jF7dZ742Sbl+xadcfpRT/TP4nAIPDB1vvPUUlk+Imodfp2XdtH8dTtfV86X57AoFTm7XpU+5CuSrn09OfAvB4dg5OnUaDs+Ot9iBEayCJmr3QO0Ho7dtRt29/6nX6O7c/73b056nN2r+xo6qds+uZgVHMSGgPwJubT7LkXxcpLCnj01Ofcjr9NB4uHpTd/CXzvzwNwIyE9vTrcGd+M7OPiW7DwgHYv/EiZSUNe+7mm8/PU1JYRmCkJ3H3Nc00H7ZOp9PR11MbcXng5mHrvElRDly7ndxH9Od0+mmu5V3D1eBKv+B+1nlPUUWYRxijo0YDsOjIIu2qc0gP8O8EpQVw5NO7qnfPlT1czr6MR3k543LktqcQ9kwSNXtieU7tznxqA0K02593lagV58G57drXceOqLaLT6XjlgRieHhAJaIML+ry/lr8c/h8ASm4+xOYjueh1MHtUJ155oOqSKN2Hh+Pm6UJ2agGHtl6qd3iJR1O59J9U9Hod9z8ei66JpvmwB5bn1IpvQVlp079B4jdQXgo+keATYRl52D+4P64GufLSnGZ2m4mL3oXvUr5j37V92h9MfWdoOw/8VVvjt4FWnFwBwK+yc3BrEwNRCU0YsRCiOUmiZk+qGVDQN7ivZZqOH3MaOEHque3aX+0+ERDcvcZiOp2O10Z2Yu6YOIK9TRR5r6WcEkrzOpB6vQueJgOfTO7JUwOiqp3SwcVkYMCvOwJwZHsy57+/UWdot67msmuFdpWu27Bw/ELMDWubnevdUZv89KyLgbTkxj1UXq2Lt6eEuD1L/a7L2vdD2sms9c2trbktE2InAPCXw3+hXJVDl1+DRzDkXIdja+uoobIfbv7AkZtHMCjFxOxc6DvT+itcCCGsRhI1exLaE3ROkJGkvQAvoxc9A3sC8FXiVw2r76Q2Ioy4cXX+ItfpdEzqF8FL4zIxuF9CjwuTov+LT5/szb9fHUxCTO0LaXfoEUD327dA/7nyNGk/1jyaMftWAVsW/0BRfilt23vRc1REg5rlCPzc/YnFCMDB85ub/g0u3J6jrf0QErMSuZh1EYPO0DTLkYkGezr+aczOZs5mnNXOY4NRS7AA9n1oGUBUF6UU73//PgCjc/MIMPpAvExyK4Q9k0TNnpi8IPz2+pvnv7ZsHhWlTaux9dLW+o+sLMqF8zu0r2u47flzqfmpfHD4zwC8dO/veHXYfQyI9sfTVL8Rgn3GtSessy+lxeVsWXyUpGNpVcrcuprLlsVHycsqxjfYnZEzumBwcapfmxzMnefUmng+tVsXtURfb4DIAZbRnr3a9sLTxbNp30vUi7fJmyn3TAFg4fcLySrKgh6TwOQNty7A6S21V3Dbl4lfciz1GK4KnsvIgl5Pg7PJipELIaxNEjV7Ez1M+7ciyQKGthuKi96FS1mXOJN+pn71nPt/UFqorXgQ1KVeh7z97dvklOQQ5xfHY50avmi0Xq9j+JNx+Aa7k59dzJf/e4wdS09y9tsULv2Qyq4Vp1gz/xCZN/Ix+xgZ/XxXTO6td5qIfhFDAdhXnEZZUz6ndlEb3UlYHzB6sC1RG1n6YMSDTfceosF+2/m3RHpFklaQxjuH3gGjB/R6Rtv5r/egjil48kvyWXR4EQDPZGQSgAHufdLaYQshrMxmE7XS0lIeeeQRQkJC0Ol0pKQ0cpkkRxH9gPZv4l4ozgfAw8WDQbcX8/7y0pf1q6cBtz1Bm2NrZ/JODDoDc/vNxaC/u2kyTO7OjH/1XroNC0eng/Pf3WDnslN8teQ4Zw6kgIL2vwhg3Mu/wOzTuq8E9Og8AY/ycm456Th2blPTVXzhzvNp5zLOcSHzAs56Z3k+rYWZDCbm95+PXqfny0tfas8N9nkWXH3h5kn496Jaj196Yik3828SUg5PZGfDL34LZv9mil4IYS02m6gBDBw4kPXr17d0GLYloBN4hmpXw5LujPR8KEqbrHZb4rY7izzXpCDzzq3Tetz2zCrK4q1v3wJgyj1TiPGtOrKzIZxdnOj/SAcentWD6J6BhMb6EBDhSUSXNjzyhx48+Mw9ePrJyENno5lBTt4A7Dy7rmkqLS3WknyADkPYdkm7mjYgZIDc9rQBXfy7MCVOuwU67+A8blIKI97Tdv7rPbhxstrj9l/bz9LjSwF4OTUVozkYhrzRLDELIazLZhM1g8HACy+8QJ8+fVo6FNui00HH2zOMn99u2VzxQZtakMp3N76rvY5jn0NZEQR0hsB76nzLRYcXkVaQRoRnBNO6TmtM9JUERXox/Mk4fvlidx599V5GzejSqhfqrs6Q4P4A7Mo8e9crO1Ry5SCU5IG7PyrgHssAlJFRIxtft2gSM7rNoIN3B9IL03lqx1Pc6nA/xIyE8hLYNKPKdC2Xsi7x8p6XKVNljMnNY0h+ATy0SNb1FMJB2Gyi1lBFRUVkZ2dXejmsiqVgzu+A2x/ezk7ODI/Qtm+5WMuDx0rB4eXa1z2m1Hnb89D1Q6w/r13V/GO/P2J0MjYqdNEw/eInYSwv56qulHM3fmh8hZbRnoM5eus41/Ku4WZwk0XYbYiLkwt/HfJXAt0CScxK5Jmd08gaPldLvK7/AJ//Fgq1329pBWk8v+t5ckpy6F4Kc1JvoYt/FGLkeUMhHIXDJGrvvPMOXl5elldYWFhLh2Q9kQPByQiZyZB61rJ5XAftNua2xG2k5NXwTN+P32nPuxhM0KX2Yfu5xbm8uf9NAH4d82t6BPZomvhFvbkFdKZ/qXaa7jyxsnGVKXVn9GD0cMvzjEPbDcVkaN3PA9qaEHMISx9YShvXNpzLOMeju59jY7+plDq5wNkvKf94MJ/ve4sxGx4iOSeZkNIyFl39ERfvdvDggpYOXwjRhFosURs+fDgmk6na1/z58xtc33//93+TlZVleV25csUKUdsIF3fLQtqcuzN3Whf/LvQM6klpeSnLTiyr/tiKq2lxD4Ord61v8+5373I19yoh5hBe/MWLjQ5b3AWdjiG+nQHYlXKwcXWlHIf0S2AwUdJ+CDsuayOHR0SOaGyUwgraebbj4+EfE+gWyPW867yZuJ4HozsxNiyMIa75/OnCGnJK8+hUVMxHKTfwaz8UntkD7m3qrFsIYT9aLFHbsWMHhYWF1b5mz57d4PqMRiOenp6VXg6tk7Y+IEdWQvmd9TOfjn8agPXn15NW8LN5ygoy4cQG7esek2utflfyLjZd2IQOHW/d9xZml9a1MoAtGdTxEQxKcb4sl+Ts5Luv6NQm7d8OQ9l181vSC9Np49qG3m17N0mcoum1927P1nFbefnel/E2enOjKIOLBh1pBifcyxWv5hSzOhsiB74Gv1kLbr4tHbIQoond3RwLzaSoqMjyAHVRURGFhYWYTHKLBtAWWf56jnaF5OIuy/xqfdr2Ib5NPMfTjvPpqU/5fY/f3znm2FptySj/TneWo6pGan4qc/fPBWDyPZPllmcL84p+kHv3zeagq5GvTn3GtD6vNrwSpeDkJu3ruHGsPaMtS/RI9CM461vvXHX2wGQwMSluEuM7judo6lEMOgOuBlfaebWTkbpCtAI2/YxaTEwMrq7aNA0RERGWrwVgNEP3x7Wvv11i2azT6Xgq/ikA1p5dq81wDtqcaxXzMN07tcZBBEVlRbyw+wUyijLo6NOR57o9Z7UmiHoyeTLG2BaADRe/0NaCbKgbJyH9IjgZuRjYke9vfI+TzonxHcc3cbDCWtyd3ekX3I9ebXsR7x8vSZoQrYRNJ2pJSUkopSq9xE/0egrQaSP50i5YNieEJRDtE01eSR5/Ovgn7f/t4N+0BZ69wrWJMKuhlGLu/rkcTzuOp4snixIW4eLk0kyNEbUZFjMez7IyrpXmsP/a/oZXUHHbM3oYnydqgwgGhQ4iyD2o6YIUQgjR5Gw6URN18I2CjreH4R/6P8tmvU7P3L5zMegMbE/azoYTK+DfH2o7h7xZ49p/S08sZculLTjpnPhzwp8J9wy3dgtEPZm6TGBMXgEA644vb9jBP7ntmR8zgi8ufgFoI3mFEELYNknU7F3v2xPQ/rAKsq9ZNsf7x/P8L54HYMGRRVxUBdC2G9zzSJUqlFL85fBf+PCIlszN6jmLPm1lomGbYvbnEV9tTdY9Nw6Rmp9a/2Ov/wC3zoOTkW0ukFuSS5hHGH2CpY+FEMLWSaJm76ISoG1XKM6F1ROgOM+ya3LcZPp6daSQcqYHBfBdrydAX7nL80vyef3fr7P0hLb8zMxuM/lN7G+aswWinjp0m0z3wkLKUGw6v7H+Bx78CICSTg/x8Zl/ANrVNL1OTn8hhLB18pva3ul08KuV4OYH14/CxmmW6Tr0Jzfy9om9hJWUkGIw8OSxxSw4tIA9V/Zw5MYRFh9ZzLB1wyy3O+f1m8f0rtPR1WORdtECOo5gfIHWt+tOr6KkrKTuY7KvwwltZYn1oZ24mnsVP5Mfj3Z81JqRCiGEaCI65aBP6GdnZ+Pl5UVWVpbjz6kGcPkArBwDZcXagAGzP1w9Aijy7nmY99uGsf5C9Vdhwj3Ceb336/QL6de8MYsGK/ziOR5M/Se3DE682utVHuv0WO0H7JoH3/yZ/PDejDKXkFaQxmu9X5OrpkII0cLqm6fIFTVH0a4vjPkf0BsgKxmuHgYU9JiC+8NL+WP/efxtyN8YGDqQOL84Qswh3Bt4L4sSFvHF2C8kSbMTpm6P81xmJgD/+5+/3Zl+pTrF+fD9JwB81q4LaQVphJhDGB8tU3IIIYS9sOkJb0UDdZ0AkYMgIwnyb2mLOEfcZ5kzbWDoQAaGDmzZGEXjhPVmnEdHVhVf5wI5LDm6hD/0+kP1ZY+tgYIM0nzb8clNbUqPmd1m4uwkE9wKIYS9kCtqjsazrXZ1rdNDEDmgxolthZ3S6XAa8R6vpGcCsObMapKykqqWy02FPQsoAf4rKIic4hxifGIYGTmyOaMVQgjRSJKoCWFvwnrRr8No7ssvoFSV8eLuFyuv61peDpumQ+4N3g+J4kjBdczOZhYOWoiT3qnl4hZCCNFgkqgJYY+GzmV2VgEBpaVczLrI0zue4lbBLW3fgb9ScmEnn/j4stqlFIB3BrxDhFdEy8UrhBDirsgzakLYI68QQvr9nk/2vsPUtgFcyLzIxE3jGISJdilnWBPSliQX7Vm0Z7s+S0JYQsvGK4QQ4q5IoiaEvbrvJdo5u7F0z594MsCba2SwGsDXCwAfow/Tu05nQuyEFg1TCCHE3ZNETQh7pddD3xlEtB/Mhk3T2J97laOB0VxwNdMtfBCT4yZjdjG3dJRCCCEaQSa8FcIRVJzGMspXCCHsQn3zFLmiJoQjkARNCCEckoz6FEIIIYSwUZKoCSGEEELYKEnUhBBCCCFslCRqQgghhBA2ymEHE1QMZs3Ozm7hSIQQQgghKqvIT+qafMNhE7WcnBwAwsLCWjgSIYQQQojq5eTk4OXlVeN+h51Hrby8nGvXruHh4YHOilMXZGdnExYWxpUrV1rVfG2ttd0gbZe2S9tbE2m7tN1abVdKkZOTQ3BwMHp9zU+iOewVNb1eT2hoaLO9n6enZ6v7QYbW226QtkvbWx9pu7S9tbF222u7klZBBhMIIYQQQtgoSdSEEEIIIWyUJGqNZDQamTNnDkajsaVDaVattd0gbZe2S9tbE2m7tL2lOexgAiGEEEIIeydX1IQQQgghbJQkakIIIYQQNkoSNSGEEEIIGyWJmhBCCCGEjZJErR5SU1MZNWoUbm5uxMTEsGvXrmrLFRQU8Pjjj+Ph4UF4eDirV69u5kibVlFREVOmTCE0NBQvLy8SEhI4fvx4tWUnT56M0WjEbDZjNpuJi4tr5mibXkJCAiaTydKmESNGVFvO0fq9or0VL51Ox/r166sta+/9PmfOHDp37oxer2fNmjWV9i1YsAB/f398fX2ZNWtWrevxLV++nNDQUDw9PZkyZQrFxcXWDr3Ramr78uXL6datGx4eHkRFRbFkyZIa69izZw96vb7Sz8s333zTHOE3Sm1tNxgMldqTnJxcYz2O1O/Tp0+v1G5nZ2dGjx5dbR322u91fabZ6jkviVo9zJw5k+DgYNLS0nj33Xd59NFHycjIqFJuzpw5pKenc/XqVdasWcOzzz7LuXPnWiDiplFaWkpUVBQHDx4kPT2dMWPGMHbs2BrLz507l9zcXHJzczl58mTzBWpFy5cvt7Tpq6++qraMo/V7RXtzc3PZv38/rq6uDB8+vMby9tzv0dHRfPjhh/Tq1avS9m3btvHRRx/x7bffcvLkSbZu3cqyZcuqreP48eO89NJLbNq0iStXrpCUlMT8+fObI/xGqantRUVFLFmyhIyMDLZs2cKcOXPYu3dvjfV07Nix0s/MgAEDrB16o9XUdoChQ4dWak94eHi1dThavy9ZsqRSu+Pj42v9fW+P/V7bZ5pNn/NK1ConJ0e5uLioa9euWbYNGDBArVixokrZoKAgdfDgQcv3TzzxhJo7d26zxNkcioqKlE6nU2lpaVX2TZo0Sb3zzjstEJX1DBo0SK1evbrOco7c77NmzVITJkyocb+j9PvP+3rChAlqwYIFlu+XLl2q7r///mqPffXVV9X06dMt3+/atUtFRkZaL9gmVtfP+cSJE9XChQur3bd7924VExNjrdCs7udtX7ZsmXrggQfqdawj9/upU6eU0WhUmZmZ1e63936v8NPPNFs+5+WKWh3Onz+Pl5cXbdu2tWzr2rVrlSsHGRkZpKSkEB8fX2s5e3bgwAECAwPx8/Ordv/777+Pn58f/fr1q/UvcHvy/PPP4+/vz7Bhwzh27FiV/Y7c70opVq9ezWOPPVZrOUfs91OnTtW7T6srm5iYSEFBgdXjtLaysjIOHTpU6y3tpKQkAgICiI6OZt68eZSVlTVjhE1v3759+Pn50blz51pv+zpyv69atYqHHnqo1nUoHaHff/qZZsvnvCRqdcjNza2yIKunpye5ublVyjk5OeHm5lZrOXuVlZXFtGnTeOutt6rd/8ILL3DhwgWuX7/OzJkzGT16NFeuXGnmKJvWe++9R2JiIsnJyQwbNoyRI0e2qn7fu3cv+fn5PPDAAzWWccR+h6rnfW19Wl3Ziu32bvbs2YSEhNT4MxAbG8sPP/xASkoKmzdv5vPPP2fx4sXNHGXTGTRoEMePHyc1NZVly5Yxb948Nm7cWG1ZR+73zz77rNY/0Byh33/+mWbL57wkanUwm81kZ2dX2padnY3ZbK5SrqysjPz8/FrL2aPCwkLGjh3LqFGjmDp1arVlunfvjo+PDy4uLjz22GP07duXr7/+upkjbVq9evXCbDbj6urKrFmzMJvNHDp0qFIZR+73VatW8atf/QpnZ+cayzhiv0PV8762Pq2ubMV2e7ZkyRI2bNjAunXr0Ol01ZYJCgoiNjYWvV5P586dmT17do2JjT2IjIwkIiICvV5P7969+d3vfldjexy13/fv309GRgYjR46ssYy993t1n2m2fM5LolaH6OhosrKySElJsWw7evRolVsBPj4+BAUFVRpBUl05e1NaWsqECRMIDg5m4cKF9T5Or3e8H63q2uSo/V5cXMy6devqvO35c47S7507d653n1ZXNjIyEldXV6vHaS1r167lrbfeYvv27bRp06bexzlK/1eorT2O2O+g/YE2fvz4Bq1xaU/9XtNnmk2f81Z7+s2BjB8/Xj3zzDMqPz9fbd68Wfn4+Kj09PQq5V5++WU1atQolZ2drQ4cOKC8vLzUmTNnWiDipjN58mQ1fPhwVVxcXGu5devWqdzcXFVSUqLWrFmjPDw8VGJiYvMEaQUZGRlqx44dqrCwUBUVFakPPvhABQYGqqysrCplHbHfN27cqCIiIlR5eXmt5ey934uLi1VBQYEaMGCAWrlypSooKFBlZWVq69atql27durSpUvq+vXrKi4uTi1durTaOo4dO6Z8fX3V4cOHVWZmpho8eLB64403mrklDVdT27dv3678/f3V0aNH66xj9+7dKjk5WSml1Llz51R8fLx69913rR16o9XU9q+++krdvHlTKaXU4cOHVUhIiFq7dm21dThavyulVElJiWrTpo3avXt3rXXYa78rVfNnmi2f85Ko1cPNmzfViBEjlKurq4qOjlZff/21Ukqpf/zjH6pz586Wcvn5+WrixInK3d1dhYaGqlWrVrVUyE0iKSlJAcpkMil3d3fLa+/evVXa3r9/f+Xp6am8vLxUr1691M6dO1sw8sa7efOm6tGjh3J3d1c+Pj7q/vvvV4cPH1ZKOX6/K6X9cfLaa69V2e5o/T5p0iQFVHpVfEi9/fbbys/PT3l7e6tXXnmlUtJacR5UWLZsmQoODlZms1lNmjRJFRYWNndTGqymtickJCiDwVDpnJ82bZrluJ+2feHChSo4OFi5ubmpiIgI9cYbb6iSkpKWalK91dT2l156Sfn7+yt3d3fVsWNHtXjx4krHOXK/K6UlK6GhoZbE7accod9r+0xTynbPeZ1StczoJoQQQgghWoz93FgWQgghhGhlJFETQgghhLBRkqgJIYQQQtgoSdSEEEIIIWyUJGpCCCGEEDZKEjUhhBBCCBsliZoQQgghhI2SRE0IIYQQwkZJoiaEaDWSk5MbtHbl3UhKSkKn02E2m9m0aVOtZdevX4/ZbEan01VaT1gIISrIygRCCIdiNpstX+fl5eHm5oZOpwPg1KlThIeHW/X9k5KSiI2NpbCwsN7H6HQ6rl+/TlBQkBUjE0LYI0NLByCEEE0pNzfX8rXJZOLkyZNERES0XEBCCNEIcutTCNFqJCUlYTKZLN/rdDo++ugjwsPDadOmDWvXrmXr1q1ERUUREBDA2rVrLWXT09OZOHEiAQEBREVFsWLFinq/78GDB+nevTseHh4EBQXxwQcfNGm7hBCOS66oCSFatX379nHu3Dm2bNnC9OnTGTNmDCdOnGDXrl1MnTqV8ePH4+TkxBNPPME999zDlStXSExMZPDgwXTr1o2uXbvW+R4vvvgir7zyChMnTiQjI4OkpCTrN0wI4RDkipoQolWbNWsWJpOJhx9+mMzMTGbMmIGbmxujR48mJyeHa9eukZKSwjfffMPbb7+N0WgkNjaWiRMnsmHDhnq9h7OzM2fPniU9PR0fHx+6d+9u5VYJIRyFJGpCiFYtICAAACcnJ5ydnfH397fsM5lM5OXlkZycTF5eHn5+fnh7e+Pt7c3f//53bty4Ua/3+Pjjjzl9+jQdOnSgX79+HDhwwCptEUI4Hrn1KYQQdQgJCcHb25tbt27d1fExMTF8/vnnlJaWsmTJEh5//HEuXrzYxFEKIRyRXFETQog6hISE0LNnT958803y8/MpLS3lyJEjnDp1ql7Hr1q1ilu3bmEwGPDw8MDJycnKEQshHIUkakIIUQ+rVq3i8uXLlhGhL774IgUFBfU6dtu2bcTExODh4cHixYtZtmyZlaMVQjgKmfBWCCGa0OXLl4mNjcVoNLJy5UrGjBlTY9kNGzYwdepUCgsLuXz5MoGBgc0YqRDCHkiiJoQQQghho+TWpxBCCCGEjZJETQghhBDCRkmiJoQQQghhoyRRE0IIIYSwUZKoCSGEEELYKEnUhBBCCCFslCRqQgghhBA2ShI1IYQQQggbJYmaEEIIIYSNkkRNCCGEEMJG/X9jsVkXNUz9iQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Do some Python magic to get different colors\n", + "from itertools import cycle\n", + "prop_cycle = plt.rcParams['axes.prop_cycle']\n", + "colors = cycle(prop_cycle.by_key()['color'])\n", + "\n", + "for X0 in [[1, 0, 0, 0], [0, 2, 0, 0], [1, 2, 0, 0], [0, 0, 1, 0], [0, 0, 2, 0]]:\n", + " response = ct.initial_response(sys, T=20, X0=X0)\n", + " response.plot(color=next(colors), label=f\"{X0=}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b3VFPUBKT4bh" + }, + "source": [ + "### Step response\n", + "\n", + "Similar to `initial_response`, you can also generate a step response for a linear system using the `step_response` function, which returns a time response object:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out = ct.step_response(sys).plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iHZR1Q3IcrFT" + }, + "source": [ + "We can analyze the properties of the step response using the `stepinfo` command:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input 0, output 0 rise time = 0.6153902252990775 seconds\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "[[{'RiseTime': 0.6153902252990775,\n", + " 'SettlingTime': 89.02645259326653,\n", + " 'SettlingMin': -0.13272845655369417,\n", + " 'SettlingMax': 0.9005994876222034,\n", + " 'Overshoot': 170.17984628666102,\n", + " 'Undershoot': 39.81853696610825,\n", + " 'Peak': 0.9005994876222034,\n", + " 'PeakTime': 2.3589958636464634,\n", + " 'SteadyStateValue': 0.33333333333333337}],\n", + " [{'RiseTime': 0.6153902252990775,\n", + " 'SettlingTime': 73.6416969607896,\n", + " 'SettlingMin': 0.2276019820782241,\n", + " 'SettlingMax': 1.13389337710215,\n", + " 'Overshoot': 70.08400656532254,\n", + " 'Undershoot': 0,\n", + " 'Peak': 1.13389337710215,\n", + " 'PeakTime': 6.564162403190159,\n", + " 'SteadyStateValue': 0.6666666666666665}]]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "step_info = ct.step_info(sys)\n", + "print(\"Input 0, output 0 rise time = \",\n", + " step_info[0][0]['RiseTime'], \"seconds\\n\")\n", + "step_info" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F8KxXwqHWFab" + }, + "source": [ + "Note that by default the inputs are not included in the step response (since they are a bit boring), but you can change that:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "stepresp = ct.step_response(sys)\n", + "out = stepresp.plot(plot_inputs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out = stepresp.plot(plot_inputs='overlay')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stepresp.time.shape=(1348,)\n", + "stepresp.inputs.shape=(1, 1, 1348)\n", + "stepresp.states.shape=(4, 1, 1348)\n", + "stepresp.outputs.shape=(2, 1, 1348)\n" + ] + } + ], + "source": [ + "# Look at the \"shape\" of the step response\n", + "print(f\"{stepresp.time.shape=}\")\n", + "print(f\"{stepresp.inputs.shape=}\")\n", + "print(f\"{stepresp.states.shape=}\")\n", + "print(f\"{stepresp.outputs.shape=}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FDfZkyk1ly0T" + }, + "source": [ + "## Forced response\n", + "\n", + "To compute the response to an input, using the convolution equation, we can use the `forced_response` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHbCAYAAABGPtdUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3QUZRfGn00PaVTpvXeQJr03UcGPKipgARVBsYCiIKEL0puASu/SpSPSa0IvIaEkkJDQkpDeduf5/nh3Z7PpfZfw/s6Zs7tT7+y0O7dqSBISiUQikUgkkpceK3MLIJFIJBKJRCLJGaRiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2EkkEolEIpHkE6RiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2EkkEolEIpHkE6RiJ5G8hPj5+UGj0eDKlSvmFuWlwd3dHcWLF4dGo8HOnTvNLU6Oc+zYMWg0Grx48SJb66lQoQLmzZuXIzK9DNuVSPIbNuYWQCKxJIYMGYLVq1cnG3/nzh1UqVLFDBJJcgIvLy9MnDgRO3bswBtvvIFChQqZWyRJEjw8PODk5GRuMSSSlx6p2EkkSejWrRtWrlxpMq5YsWJZWld8fDzs7OxyQqxsY0my5DX37t0DAPTs2RMajSbL60lISICtrW1OiSWB8bzM6jUmkUhMka5YiSQJ9vb2KFGihMlgbW0NADh+/DiaNm0Ke3t7lCxZEj/++CO0Wq26bLt27TBixAh8++23KFq0KDp37gwAuHnzJnr06AFXV1e4uLigdevWqrIBACtXrkTNmjXh4OCAGjVqYMmSJSYyXbhwAQ0bNoSDgwMaN26My5cvp7sfFSpUwJQpUzBkyBC4ublh6NChAIAzZ86gTZs2cHR0RNmyZfHVV18hKipKXW7JkiWoWrUqHBwcULx4cfTp0yfZ/o0YMQIFCxZEkSJFMG7cOJBU5wkNDcWgQYNQqFAhFChQAN27d8edO3fU6atWrULBggVx8OBB1KxZE87OzujWrRuCgoLUeY4dO4amTZvCyckJBQsWRMuWLfHgwQN1+j///INGjRrBwcEBlSpVwsSJE02OQ2Lc3d3x9ttvAwCsrKxUxU5RFEyaNAllypSBvb09GjRogAMHDqjLGdzdW7ZsQbt27eDg4IB169aluI0XL15g2LBhKF68OBwcHFCnTh3s2bNHnb5t2zbUrl0b9vb2qFChAmbPnm2yfEru4YIFC2LVqlUmsmzatAktWrSAg4MDateujWPHjqUoj4H0jvXTp0/x9ttvw9HRERUrVsT69evTXB+Q9rFxd3dHgwYNsGzZMpQtWxYFChRA3759TdzDQ4YMQa9evTB9+nSUKlUK1apVA5DcFavRaPDnn3/i3XffRYECBVC1alXs3r3bRJbdu3ejatWqcHR0RPv27bF69ep03dEajQbLli3DW2+9hQIFCqBmzZo4e/Ys7t69i3bt2sHJyQnNmzc3uT7v3buHnj17onjx4nB2dkaTJk3w77//mqw3retm69atqFu3LhwdHVGkSBF06tTJ5DhIJDkKJRKJyuDBg9mzZ88UpwUEBLBAgQIcPnw4vby8uGPHDhYtWpQTJkxQ52nbti2dnZ05evRo3r59m15eXgwICGDhwoX5v//9jx4eHvT29uaKFSt4+/ZtkuTy5ctZsmRJbtu2jffv3+e2bdtYuHBhrlq1iiQZGRnJYsWKsX///rxx4wb/+ecfVqpUiQB4+fLlVPelfPnydHV15W+//cY7d+7wzp07vHbtGp2dnTl37lz6+Pjw9OnTbNiwIYcMGUKS9PDwoLW1NTds2EA/Pz9eunSJ8+fPT7Z/X3/9NW/fvs1169axQIECXL58uTrPO++8w5o1a/LEiRO8cuUKu3btyipVqjA+Pp4kuXLlStra2rJTp0708PDgxYsXWbNmTQ4cOJAkmZCQQDc3N37//fe8e/cub926xVWrVvHBgwckyQMHDtDV1ZWrVq3ivXv3eOjQIVaoUIHu7u4p/g8RERFcuXIlATAoKIhBQUEkyTlz5tDV1ZUbN27k7du3OWbMGNra2tLHx4ck6evrSwCsUKGCemwePXqUbP06nY5vvPEGa9euzUOHDvHevXv8559/uG/fPpKkp6cnraysOGnSJHp7e3PlypV0dHTkypUr1XUA4I4dO0zW6+bmps5jkKVMmTLcunUrb926xU8//ZQuLi58/vw5SfLo0aMEwNDQUJJM91iTZPfu3VmnTh2eOXOGnp6ebNGiBR0dHTl37twU/8v0js2ECRPo5OTEDh068PLlyzx+/DirVKmiHltSXGPOzs788MMPeePGDV6/fp2kOF8Tb9ewvxs2bOCdO3f41Vdf0dnZmcHBwep/Ymtry++//563b9/mxo0bWbp0aZP/ICUAsHTp0ty8eTO9vb3Zq1cvVqhQgR06dOCBAwd469YtvvHGG+zWrZu6zJUrV7h06VJeu3aNPj4+/Pnnn+ng4KDud1rXTWBgIG1sbDhnzhz6+vry2rVrXLx4MSMiIlKVUSLJDlKxk0gSMXjwYFpbW9PJyUkd+vTpQ5L86aefWL16dSqKos6/ePFiOjs7U6fTkRSKT4MGDUzWOXbsWFasWFFVbJJStmxZbtiwwWTc5MmT2bx5c5LksmXLWLhwYUZFRanTf//99wwpdr169TIZ9+GHH3LYsGEm406ePEkrKyvGxMRw27ZtdHV1ZXh4eIrrbNu2LWvWrGnyH/zwww+sWbMmSdLHx4cAePr0aXX68+fP6ejoyC1btpCkqmTdvXtXnWfx4sUsXrw4STI4OJgAeOzYsRRlaN26NadNm2Yybu3atSxZsmSq/8WOHTuY9D22VKlSnDp1qsm4Jk2acPjw4SSNytS8efNSXS9JHjx4kFZWVvT29k5x+sCBA9m5c2eTcaNHj2atWrXU3xlV7H799Vd1ekJCAsuUKcMZM2aQTK7YpXesvb29CYDnzp1Tp3t5eRFAqopdesdmwoQJtLa2pr+/vzpu//79tLKyUhXqwYMHs3jx4oyLizNZNiXFbty4cervyMhIajQa7t+/n6Q47+rUqWOyjp9//jlDil3i9Z49e5YA+Ndff6njNm7cSAcHh1TXQZK1atXiwoULSTLN6+bixYsEQD8/vzTXJ5HkFDLGTiJJQvv27fH777+rvw0B3V5eXmjevLlJjFbLli0RGRmJgIAAlCtXDgDQuHFjk/VduXIFrVu3TjE269mzZ/D398cnn3yiukoBQKvVws3NTd1u/fr1UaBAAXV68+bNM7QvSWW5ePEi7t69a+JyIwlFUeDr64vOnTujfPnyqFSpErp164Zu3bqprjADb7zxhsl/0Lx5c8yePRs6nQ5eXl6wsbFBs2bN1OlFihRB9erV4eXlpY4rUKAAKleurP4uWbIknj59CgAoXLgwhgwZgq5du6Jz587o1KkT+vXrh5IlS6r74OHhgalTp6rL63Q6xMbGIjo62kTW1AgPD0dgYCBatmxpMr5ly5a4evVqmv9hUq5cuYIyZcqoLsWkeHl5oWfPnsm2M2/ePOh0OtXNnxESH3cbGxs0btzY5H9NTHrH2sfHR12HgRo1aqBgwYKpbj+9YwMA5cqVQ5kyZUxkVhQF3t7eKFGiBACgbt26GYr3rFevnvrdyckJLi4u6nni7e2NJk2amMzftGnTdNeZdL3FixdXZUo8LjY2FuHh4XB1dUVUVBQmTpyIPXv2IDAwEFqtFjExMXj48CEApHnd1K9fHx07dkTdunXRtWtXdOnSBX369JEJPJJcQ8bYSSRJcHJyQpUqVdTB8NAimSzwnvrYssTjk2b2OTo6protRVEAAH/88QeuXLmiDjdu3MC5c+dMtpHVfUm6vc8++8xkW1evXsWdO3dQuXJluLi44NKlS9i4cSNKliyJX375BfXr189wCY3UZE363yVVcjUajcmyK1euxNmzZ9GiRQts3rwZ1apVU/8PRVEwceJEk324fv067ty5AwcHhwzJmXi7ackJJP8Pk5LW8U1tnUn/p6T7D4hEjYyQWjJIesc6pXM3I6R1bNKSL61rJDVSOk8M10xG/teMrNewjpTGGbY1evRobNu2DVOnTsXJkydx5coV1K1bF/Hx8QCQ5nVjbW2Nw4cPY//+/ahVqxYWLlyI6tWrw9fXN0OySiSZRSp2EkkGqVWrFs6cOWPy8Dhz5gxcXFxQunTpVJerV68eTp48meKDunjx4ihdujTu379vokxWqVIFFStWVLd79epVxMTEqMul9SBNi9dffx03b95Mtq0qVaqoFhQbGxt06tQJM2fOxLVr1+Dn54f//vsv1W2fO3cOVatWhbW1NWrVqgWtVovz58+r04ODg+Hj44OaNWtmStaGDRti7NixOHPmDOrUqYMNGzao++Dt7Z3iPlhZZeyW5urqilKlSuHUqVMm48+cOZNpOevVq4eAgAD4+PikOL1WrVopbqdatWqqta5YsWImySN37txBdHR0snUl/u+1Wi0uXryIGjVqpLjd9I51zZo1odVq4enpqS7j7e2dISU+tWMDAA8fPkRgYKD6++zZs7CyskrVoplVatSoAQ8PD5NxifclJzl58iSGDBmCd999F3Xr1kWJEiXg5+dnMk9a141Go0HLli0xceJEXL58GXZ2dtixY0euyCqRSMVOIskgw4cPh7+/P0aOHInbt29j165dmDBhAr799ts0FYoRI0YgPDwcAwYMgKenJ+7cuYO1a9fC29sbgMgknD59OubPnw8fHx9cv34dK1euxJw5cwAAAwcOhJWVFT755BPcunUL+/btw6xZs7K0Dz/88APOnj2LL7/8EleuXMGdO3ewe/dujBw5EgCwZ88eLFiwAFeuXMGDBw+wZs0aKIqC6tWrq+vw9/fHt99+C29vb2zcuBELFy7E119/DQCoWrUqevbsiaFDh+LUqVO4evUqPvjgA5QuXTqZOzI1fH19MXbsWJw9exYPHjzAoUOHTBTDX375BWvWrIG7uztu3rwJLy8vbN68GePGjcvUfzF69GjMmDEDmzdvhre3N3788UdcuXJF3ZeM0rZtW7Rp0wa9e/fG4cOH4evri/3796sZtt999x2OHDmCyZMnw8fHB6tXr8aiRYvw/fffq+vo0KEDFi1ahEuXLsHT0xOff/55iq77xYsXY8eOHbh9+za+/PJLhIaG4uOPP05RrvSOdfXq1dGtWzcMHToU58+fx8WLF/Hpp5+maYFM79gAgIODAwYPHoyrV6/i5MmT+Oqrr9CvXz/VDZtTfPbZZ7h9+zZ++OEH+Pj4YMuWLWoWcXZK2qRElSpVsH37dtXqOXDgQNWaB6R93Zw/fx7Tpk2Dp6cnHj58iO3bt+PZs2eZfoGQSDJM3of1SSSWS1pZsSR57NgxNmnShHZ2dixRogR/+OEHJiQkqNPbtm3Lr7/+OtlyV69eZZcuXVigQAG6uLiwdevWvHfvnjp9/fr1bNCgAe3s7FioUCG2adOG27dvV6efPXuW9evXp52dHRs0aMBt27ZlKHkipSD4CxcusHPnznR2dqaTkxPr1aunJhGcPHmSbdu2ZaFChejo6Mh69epx8+bNJvs3fPhwfv7553R1dWWhQoX4448/miRThISE8MMPP6SbmxsdHR3ZtWtXNdOUFMkTbm5uJjIlTm54/Pgxe/XqxZIlS9LOzo7ly5fnL7/8oiaokCIz1pDB6erqyqZNm5pk5iYlpeQJnU7HiRMnsnTp0rS1tWX9+vXVwHzSmLCQ1n9sIDg4mB999BGLFClCBwcH1qlTh3v27FGnb926lbVq1aKtrS3LlSvH3377zWT5R48esUuXLnRycmLVqlW5b9++FJMnNmzYwGbNmtHOzo41a9bkkSNH1HUkTZ4g0z7WJBkUFMQePXrQ3t6e5cqV45o1a1I9b8j0j82ECRNYv359LlmyhKVKlaKDgwP/97//MSQkRF1HatdYSskTaSWUkOSuXbtYpUoV2tvbs127dmpSUUxMTIryp7TelI5z0v/S19eX7du3p6OjI8uWLctFixaZXOtpXTe3bt1i165dWaxYMdrb27NatWpq0oVEkhtoyGwE8EgkkleKdu3aoUGDBrL1Ux7j5+eHihUr4vLly2jQoIG5xUkVd3d37Ny502yt7qZOnYqlS5fC39/fLNuXSCwBmRUrkUgkkpeSJUuWoEmTJihSpAhOnz6N3377DSNGjDC3WBKJWZGKnUQikUheSu7cuYMpU6YgJCQE5cqVw3fffYexY8eaWyyJxKxIV6xEIpFIJBJJPkFmxUokEolEIpHkE6RiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2EkkEolEIpHkE6RiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2EkkEolEIpHkE6RiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2EkkEolEIpHkE6RiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2EkkEolEIpHkE6RiJ5FIJBKJRJJPsDG3ALmFoigIDAyEi4sLNBqNucWRSCQSiUQiyRIkERERgVKlSsHKKm2bXL5V7AIDA1G2bFlziyGRSCQSiUSSI/j7+6NMmTJpzpNvFTsXFxcA4k9wdXU1szQSiUQikUgkWSM8PBxly5ZVdZu0yLeKncH96urqKhU7iUQikUgkLz0ZCS3Lt4qdxIwcPgwcOwa0aAH06GFuaSQSiUQieWWQip0kZ9mwAXj/fePvFSuAjz4ynzwSiUQikbxCyHInkpwjMBD45BPx3WAu/vxzMV4ikUgkEkmuIxU7Sc6xYAEQGws0bw7Exxs/ly83t2QSiUQikbwSSMVOkjNERQFLl4rvP/4I2NgAX38tfi9bBiQkmE82iUQikUheEaRiJ8kZ9u0DwsKAihWBt94S4959FyhaFHj8GDhzxrzySSQSiUTyCiAVO0nO8Pff4rNfP8BQFdvODujWTXzfv988ckkkEolE8gohFTtJ9omOBvbuFd/79jWdJhU7iUQikUjyDKnYSbLPsWNCuStXDnj9ddNpXbqIDNlr14CgILOIJ5FIJBLJq4JU7CTZ59Ah8dm1q7HMiYFixYC6dcX3s2fzVi6JRCKRSF4xpGInyT56xY5duuLoUWDCBGDKFMDTUz/9jTfE57lz5pFPIpFIJJJXBNl5QpI9AgIALy/Qygr9lnbA1iPGSePHA19+CSxo+gasli+Xip1EIpFIJLmMtNhJssfx4wCAG/aNsPVIIdjZAQMHAj17ismLFwMTD+otdp6esp6dRCKRSCS5iFTsJNlCOX4CAHAgpi1KlRK62/r1wM6dwJYtovLJ5L+rI76AGxATA9y8aV6BJRKJRCLJx0jFTpItQncJxe6CfRvs32/MkwBE5ZNx4wDCCp4JDcTIq1fzXkiJebh6VZhv+/YF/v3X3NJIJBLJK4FU7CRZ5qHnUxR5ehsKNHjr11aoVy/5PD/9BFStCngk1BcjpGL3anDkCNCsGbBxI7B1q8iYXrnS3FJJJBJJvkcqdpIss/2bkwAAX6e6GPR1oRTnsbcXSRRXIRQ73SWp2OV7XrwABg8G4uKAdu1EazlFAUaMAHx9zS2dRJK73LoF9OkDtG0LzJwpzn2JJA+xeMVuwoQJqFWrFqysrLBp0yZziyPRc+0aoDkl3LCub7VJVr4uMe+9BzwvJRS7hItXATIvRJSYi6lTgUePhKl2715g2zbxkIuOBr77ztzS5R4kEB9vbikk5uTCBaBRI3HOnzgB/PADMGSIvOdJ8hSLV+yqVq2K+fPno2nTpuYWRZKI2bOBthAZscV6t0lzXhsboPXntaGFNRwig4HAwLwQUWIOQkOBpUvF97lzgQIFRNHqJUvEuJ07AR8fs4mXa+zYAdSqJUzUDRokKuIoeWUICRHW6dhYoE0bEWBsYwOsXSvCESSSPMLiFbsPPvgAnTt3hoODg7lFyRtevAD++gs4cADQ6cwtTYoEBgL7N4SiHq6JEa1bp7vMh0Md4INqAIAH+2RmbL5l+XIgMlJk0bz5pnF8rVrAW28Jy8W8eWYTL1f480+gd2/g9m3x++pVYaG8dMm8cknylkmTxM2xenVgzx5g8mTg55/FtG++EaEJEkkeYPGKXUaJi4tDeHi4yfDSce2aeAB++inQvbvIJrRAE/6iRUAz7SlYgUC1akCJEukuU6IE8KJEDQDAre23c1tEiTkgjQkSo0Ylby83apT4XL9eWDVecp4/B5YOOgPt0M8BEtuKD8e2ybfA9h2E2/mTTwCt1txiSvKC+/dF0U5A3CBdXMT3H38ESpcWoQlbtphPPskrRb5R7KZPnw43Nzd1KFu2rLlFyhzR0UD//kBQEODsLMbt2AHMn29euZIQFSU8bQY3LNq1y/Cyzk1qAgDCznvlgmQSs3P+PODtLdyvffsmn96+PVC2LBAeLiwaLzHHjwOv14pF57UfwgY6bMQA9HmyCH3G10Rf7UYoBQsBV67ITOBXhUWLAK0WftU6o/8fndCvH/Dbb8CzCAfgiy/EPAsXmldGyStDvlHsxo4di7CwMHXw9/c3t0iZ47ffhCunZEmRObhokRg/fbpFBWRv2SLCqLraHxMjMqHYVe4hFLsSoV7wkrpd/mP9evHZu7fRYgHxzhIeDlBjJeraJZ73JeTIEVG95cNns1EZ9xFduDRqnVyOGTM0KFAA2HbyNSx0Gy9mnjvXIq3ukhwkMhLxy1YAAIb7jMKWLcDffwNjxoj8oe1FhgK2toCHhyzQDkCn0yE2NlYOaQy6bIZh5Ztesfb29rC3tze3GFkjLEw8AADxWbQoMGyYyC4MCgK2bwcGDDCvjHrWrQPc8AK14y+LEW3bZnhZp0bCFVsDt7FuL1CzZm5IKDELpEiMAID+/RETAyxbBqxYAVy/LkaXKweMffM9fI4ZwMGDohOJo6PZRM4K3t4iPr5oXADGW08DdECBRb+hfisX1G8lFL727YHxDz7BMNsJcPTyAg4fBrp0MbfoklyABPa9tw49osNwB1XwqE43zPhQdNxZt06EW/b+4jXcr90VFW/uERpf7drmFttsREZGIiAgAJQvO2mi0WhQpkwZOBu8d5nE4hW7hIQE6HQ6KIqChIQExMbGws7ODlZW+cbYKHybYWEivs7gwrK1FcrdxIkimcICFLuAAODoUeBNnIIVFRFfV6pUxldQQyh2JfAEJ3aF4vvvU659J3kJuXRJnCBOTjjv3BHv1wXu3TOd5eFD4Iul9fCOTVmUivEH/vsP6NHDPPJmgbg4UZ4sIgLYXmwMHJ5FA61amVyb9euLCIoOHVzxZ8JgjMQikRX5Kip2Oh1w8aIIRmzeHCiU/673hQuIDnuEd8Wn85e4uM8KNvqn6qhRotrJnDnA+Jv9sQ57gM2bgQkTksefvgLodDoEBASgQIECKFasGDSv4H+QEUji2bNnCAgIQNWqVWFtbZ2llVg0gwcPJgCT4ejRo+kuFxYWRgAMCwvLfSGzg05HVqhAAuSKFabTfHzEeFtbMjzcPPIlYsYMIc7GMt+JL0OHZnod8SXKkABbW5/mixe5IGQukJBAHj5M/vwz+fHH5Ndfkxs2kJGR5pbMghg3jgT4oFkf2tqK06N0aXLpUvLJE3H6bthAlipFLsYXJMCoDz8zt9SZYvJksV9vFzwhvmg05KVLKc47bhzZDGdJgIqzMxkdncfSmhkfH7JBA/E/AaSDA7lsmbmlylGOHSM7ao6QAOPsnJjSDU1RyC+/JF0QxljYif/i9m0zSJvHnDhBDh5M9upFzp9PRkczJiaGt27dYvSrdi1kgejoaN66dYsxMTHquMzoNBav2GWVl0ax279fXOwFC5JRUcmnV64spu/alfeyJaFuXSHK0/KNxJf16zO/ks6dSYAf4S/u3JnzMuYkikKuXUtWrGh8PiUeihQhf/9dzPfKU6cOCfADzToC5P/+R6Z06T16RH5Sah8J8IldaWoTXo4/784d0t6etEYCQ8rXFyfAZ6krpjExZOVKCn1RXsy7dWueyWp2/PzI114T++3iQpYpY7xoFi0yt3Q5Qni4eB/fgZ5Cef9ieKrzxseTb7xBHkZHMe+8+XknaF6j1ZLffJP8ZtmgAWMCA5MpK5KUMSjBWVXs8pE/8yVlhQi6xaBBIpswKd26ic8DB/JOphS4dk3EShWzfYGi/pmPr1PRB9bVhBeOH89BAXOY0FDgnXeADz8UuSxFiogC8lOmCBdLpYqEdfATzPriLj7sH/9ql6i6exe4cQMJsMEevolPPhGhRK6uyWctVQr48WB7RKEAXot/hA1jruS5uJmFBIYPF67Y+dV/R6EHV4VbccqUVJdxcAB+naHBVvQBAMRte7mzgDNMQoIIQnz6FKhXTySEPXhgrOf29dfAuXPmlTEHGD0aoJ8f3sY/AADNyBGpzmtrK5Kjj1h3BQA8XXswT2TMC+7fFyX6atQAHOyJFY5fqvHi8R98DEybBrz2msgQ/+wzsyYS+fn54Y033jAZN2DAABw7dgxfffUVihcvnmx6RoiMBO7csazKRlKxMyehocDu3eL7kCEpz9NV3Axw5EieiJQa27eLz29ePw6NogBVqoj6TJlFH2dnyYqdvz/QooWoyGFvL3JYHj4UN+efB/piboGfcVepiCcogbuoiuV/F8R/NYZD9yzE3KKbhcDfdwEAjqMten9SCMuXi+Dx1KhSxwHP6ncGADxY9A8eP84LKbPOv/+K/Idydo/x+aNxYuS0aSLJKQ3+9z/Au4J4MYvbc+jVyI6dORO4fFm8Ce3ZIzR5KytRrLd/fxF3N2yYUABfUo4dE4lBw7EE1lCATp3SzQSrUQMoOVjEWbpcOoaEyJf7TVCrFeHf1auLeuPe3sBn8QvwccIyKNBgINaj9IG/sLbMWFEbqGBBYR0ICzO36CkyYMAA7Nu3L9PLxcWJ99qwMJHnaDHkpjnRnLwUrthly4SZuk6dZP48nU7/5flzozk7ODjvZdTTsKE+PKTdZ+LLl19mbUVHj5IA76AyraxSDEsxK48fk1WqiF0sU0YfQhUWJnyyXbqIuCrD8bCyotbeUf39uFANMjDQ3LuQpzx/Tl6wb0UCXFRjIbXajC2n/PEnCfA8mqTl0TQ7iiLcaADpUeMD8aVxY2Z0R/9eG8MoiHMk7PT1XJbWzDx8KGLpAHLduuTTnz0T8QsAuXhx3suXA+h04l7oiChG2hfKVJhM2AuFj61KkAAP/nAklyXNPaKiyB49jLfBLl3IozPOU9EH157431xWr26c/umnZNyqDYwpX563DhxgTFgYFUXEKOf0kFZYjK+vL5s1a2Yyrn///mrMfkrT00KrJW/cIK97RNP3Wji12pwLK8muK1YqduaklXggcuZMkuKkXLGCrFZN6A916pB//02yalUx3/79ZhHz4UN9rDgUasuUEz/27MnayoKCSIBaWNEeMVleTW4QF0c2ayZ2r3q5aD5btIl8910RXJU4XqRzZ3Fg9HeSY78c4UOIOKKQKo1FUM0rgKKQH3R5Qh2Esht67WHGFw4MJAHqoGFJm6f09889ObPDPhEOyAF2W40JE+fPZ3h5nY484dSNBPhv91m5KKn50OnI//4jL9UfQgK86NKWzZoq7NRJJBqtWUOGhOhnXrjQmFkTG2tOsbPEmjVC/K8dloovFSpkWMknyWuvDyIB/lF4jPHl/SUiNlYNk6ajoz7MOiTEmADYpw+pKIyPJydONL4Ht2iuMKJ3P97av58xd+4wMjLluOXsDmkltOWkYqco5N27pIcHGeqp/xIQkMV/NTlSsUsFi1fs7t5VrT589IhaLfnRRymfrLcafyi+TJiQoyIoisLA8EDGa9NWRJYsEZt/v+FN8cXePuVEj4xtVCSKAKyLqxw9OmuryQ2+/54siqecaT+OCYWKmh6EatXI8ePJe/dSXHbap/cYDPEGH/3duDyW3Dz89Rf5MYTlLapWo8yvoF49EuB7WM9vv815+bKLopBNmpDl4Mcoe3HO8ocfMr2e8+/NJQEet++cGR3A4klIEHpa1apkXVxVFfwmOJ/sHmZrS/bsSXqeihFK3UuYSBEdTZYtq0+gKVxJ7MO8eZlaR9Sf60mAl1Gf27blkqC5iOEZ5eREnjpFodW/9ZYYWalSMhfMoUPq7Z7fdj4vFDsPD0YGx+a5Yufn55eiYnfs2DGSmVPsnj8Xutw1j1gqHh7iR1afiSkgFbtUsHjFzt3daP0hOWKE+GltTf76q8jC+/ZbvddTs9ho884hHkc8ZvtV7Ql30HmaMzdc25DqvN2EwYHHu04RX7p3z97G9b6tPtjCpk2zt6qcYs8e8k3s4VMkUujKliV//JG8fDnd1Ne4OHJU6S0kwHgrO5EZmI+5f590dib34E3xX02alPmVjBlDAlyFQXRxsbzyMUeOkHaI5Vmr5mIfmzXLkjU29vItEmAM7PnP5py7+ZuTq1eFR9pwqRy07k4C9GnQl7t2kbt3C8X/m2/UhGl1+KPBIqPV7iXKkJw9W4g9vMhG8aVIkcyftE+eqH9El3pBL1VG/erVRlvEwYP6kRMmGF/2L15McbmLF8lChcjy5WN45cBRxnh4UHnon+eu2IiICFarVs1kXOfOnXnjxg2SGVfs4uJEiI6HBxlx66H44u2dkb8ww0jFLhUsWrHT6cjy5cUFsW6desEA5JYtprO+9x7ZGBdIgErRojlSW0On6Njyr5aEO9TBaqIVD949mGze8HDSTl9+Kaa6sLAkq7eXWQYPJgH+jMm0tjZ/ib6ICHKE2xpqYSX2r25d4WpNSMjUeo4dVXgE7UmAT7sPyiVpzY+ikJ06kW4IZbxGX7Tu1q3Mr+iIqAH21Lo4NdBx1aqclzU7vNVD4Rro4+pcXYU2mxUUhaEuZUmAYxuaJ5wiJ/n7b2N0QsGC5PYR4jjSxka8kabAjRvkoEHCNWeHWD6y0lvtXpJYu+hoskQJElD4vGz9rL/MkEyoKwKWB2ADM1CS1SK4dYssUEDs9sSJ+pF//218cKVz8V68SNapE8Nj+z2FYnfpUqZc2DlFw4YNee7cOZJCkatcuTJj9SEBGVHsFEWUaPTwIG/fTKBy8aL4kcPB4lKxSwWLVuwOHRIXg5sb/X2i6eYmfrq7J581JIQs7hptVDpyIDh/xaUVhDvoNNWJ159c5/vb3ifcwWoLqyVzy27frjcslrtt9KmoATNZZNo0EuB2pw/E235yfTJP+euD/xgPGxJgwqCPxCtZFnF/87xYD6yp88tEzFkaxCbE8nnU8xxZV06webM4FT620b+R1K6dtRXFxgqfDsD6uMzWrXNWzuzg7U264xfxQmVtne2TNLzfJyTAWfg2p1/u85RFi4xxU2++SQYG6IyZVSNHprv8tWvCAz8CC0iAYUUqZPoFyhwYQgM/Krrb6IvMajLbd6LA+x/4hP365aycuYFWK0ISALJDB70+tmaNUOSBDCfSHTkSw/37b/KFx1WhDD1+nLuCp8DVq1fZqlUr1q9fn02aNFHdsMOGDWOJEiVoZ2fH0qVLc1cqCTGhoUJ0T08y/mGQ+HH9eo4XM5WKXSpYtGLXr594YAz/UnVzNm1K+ocGce7ZuZxwdAJP+J2goj9ZJk4kb6GGWGZf9t74dYqOledXJtzBGadmkCRfxLxgsZnFCHfwd4/fTeYfPlzId6jRj8a7eQaI18ar8idj2zYS4N0iTUzfAM3AwyvBDEJxEuDD1gOzfYE+eUIet25HArz91nfZWlecNo4j9o6g7SRbwh3stq4bA8JyLkA3K4SHi+4RAHm72lupv5FkFH18zo+a6QRy3KORZVZ0Wp/Id/hH9le4YQMJ0BOv85tvsr86c7B8ufEv+eIL/QN+3TqjRfPp0wytJzqa/PKjKD5BMRLgoSFZKHSeh8TGigx5W8Qx9LVqYn/HjMn6CvUZOfdQkTY2lp9Iv3ixsFTWdH7I4OVbRTcJw4kwcGCGLW8xMTE8f/4W73oEkB4e1F659lJVd9fpxIuJhwcZ8FBLXrkifmTwvM8MUrFLBYtV7J4/V32bO365pIYnuP+zjA5THEzco4N2DKJWp2VoKLnFuj8J8MHwX7O1+UN3DxHuoOt0V0bGGeND5p2dR7iDNRbVMFHIatUSrpNYV3ET5o4daa4/Mi6SA7cNpP1kexadWTSZokhS+GUAxjq4ElAyqivmCscqDCYB+haoSSUqZ1rdrH/vHxJgqFUhJkRkLYZIp+jYY30Pk/MB7mDtxbUZGhOaI3JmhdGjxWlQv8ILKgYfvT5GJUssEvFWVwu3IyBCGs1N+JELjIYo2+HXPxsP8MQ8ekRCZAFXLBSapYRQRVF4OegyLwRcYIIub61ce/aI+F/DMVIUiqCmcvos+WnTMrU+RSH3txIxu1dRl2vXWO4D/k+RH8TpzvoY49dey57rLSJCtXZVwH1OnpxzsuYoYWF88dty7rbpxUcoaRooaWVF/vJLptypBmXl3t1IJniIILX4ZznrwsxNHj0SetyVK6QuQP/j2jXmRnqzVOxSwWIVu3nzSIBxdRrS1VVcIx2n/KI+uBsvb8y+W/rSZpIN4Q6O2DuCJPl3w6kkwDOVBmZr83229DFZr4Gw2DA6T3Mm3MF/7/1L0hjn+yH0Of6lSqXpNknQJbDj6o7JlJG1V9eazhgbK24MAIsjiEWKZP7F7XnUc36590tWnl+Z9X6vx1/++4VhsZk71g93eKo3Ku/VZzMnQBqEh2oZYCXKn/w7bHOW1jH1xFTCHXSY4sBdt3fR65kXS80uRbiDn/1jnsJv/v7G2KrL360VX2rWTHHeFzEvOOHoBLZf1Z7Ddg/jraepxODduSMUHmsbOiOcJUuaJfTGyNOnjCwoTJJHnd+ikpBzwijVhLXnbezi5kyeFgFhAWy8vLF6TVVZUIU3nmRDoc4EV68a46uGDEl0rY4aZUwyykL/TyU4hDG2ziTAXrZ7ePlyjoqdIyiKiDRoBA9qrfSux7Vr018wPVq2JAF+jD9ZpowFeqP37DEEFaqDYm0t+v9+8QV582amV2lQVqKiYvjsskg6iLjk/VIY7eLjRZyghwcZ+jhG+GI9PHKttqxU7FLBIhU7rVbt/bqw5mICZPn+89Wb9eTjk1Vr2dabW9Xxx/2O8+bMPSTAm1a1s9xPPDIuko5THAl38GJg8gymL/Z8QbiD7219j6RI5LBGAv3sqmborXz+uflqlu1en70cfWg04Q4WmFoguQuxkigX0NHmGAFR/SWj3A+5zwrzKiRTICvOq8hrj69leD03y3YhAR4p9UHGN55Bznf+iQT4n323TCf+3Qm+Q7vJdoQ7uOKSMVHluN9xwh3UuGt4OehyjsmqKApDokMYp007tvDzz8Vp0KYNqbypz4b95Zdk8wWEBbDW4lomx8Z5mjMP3DmQ8or118R7TrsIiP7hZkFRyN69SYC3UIPzJuXwvWPYMBLgbHxjSIbPEMHRwaw0vxLhDtpNtlMt+4V+LUS/0NzNvg4PF5V+AJEwoyYF79xpDLbLRn1N5XthAj6JlqxYMfvhuznN4cNkKQQwQKNP9ujdO2fch+PHkwD/th9IwCJagRvZvFk1z95BZY7FVHotP5Htch6JlZXYsBi1TEiQn+VnRj94IPQ4r5s6KrduGTNhc0krlYpdKlikYqfPIopxKswCiKRtzf20mmhFuINTT0xNNvunuz4l3MEGSxtQd+++cF/Cjju3Zu31btutbaoClFL82/mA84Q76DjFkeGx4fziC/Jz6IvYFS0qXAipEBwdTNfproQ7uNRjKUlSq9Oy+Z/NU7QQsrsojzCtwjIC+kKXGSAmIYavL3udcAcrza/EHV47uPbqWlXRc5vuxnP+59JdT8ixq2qSw5kNvhnbeCaIu+FDQhRi/nNi5uLiem7sSbiDXdZ2SXac+v3dj3AH+27pmyNyXnt8jXWX1CXcwYK/FuSs07NSPDfu3zfGSp/b7Gd8qPv4mMwXr41Xj3mp2aU47+w8tlvVTnX/+zz3SbZuQyDnv9W+ICCK2pqFXbtIgPGw4euaSzkf+7RRlMm4iIYEMp5k+97W9wh3sMK8CvQN9eXzqOdstKwR4Q62+KsFtbocNnFqteTZs1R2/8Pvu9+gFbQsU0Y0jiBJ/vOP0YSX1Q40Bh49Ul36rXCC77+fbelzlCEdH9IHVYzW6ZzKftR34AlzKkFA4dtvZ2wxRVF48O5BDt8znD8e/pE3n2becpYmN26o3UOOlB1MO8TmWIJHUmUl7qZIL33s8dDslRHSIjZWGOg8PXSMv3VHKHWXL+dqgW2p2KWCxSl2Wq0oowFwus04othNOrgLRejjnR+n+DB9FvWMBaYWINzB/d57GW8tLrhv3k65pEB6GLJfvzuYclC/oiisuqAq4Q6uubKG7as8ZBhcxE1twYI01/3b6d8Id7DukromD5r/7v+nWhqCIoKMC+jdOEcafJuph/mkY5MId7DIjCJ8+MKYdRocHcxWK1oR7qDLNBeeenAqzfVcev1jEuCBQv1zzRUQVEV0FpniPC3D5a4MyrXVRCt6PfMSyvTYsWSjRuR77/GWx351um+ob7bk83nuQ5dpLsksnxOOTkg2r75CjSilOG6cMUUuCdNPTlcV7LvBwgwbr41Xj02zP5pRpySJSdktMg0ji1ckoLBsWTPEVMfGqpbDafiR3brlwjYSddsohGCOH5/+IoaYWOuJ1jwfYOx4cT/kvvoitfLyypyT8cABY9ycfgiDC0MbdRC9odq0MU7r3j3Nun53g+9yyM4hrDy/MusuqcupJ6YyJiEF68xnok3hCbQioPBAKobdvMb3mB/voaJQ9ktXIH19M7xsWGwYd9/ezV23dzE4OgV3XWysqkDVxE1aWaXfuCBeG8/BOwabXKs2k2y44Fza9+YMo9ORr78u4oPf6EoNdLSyIm/fzpnVJ1NWXrwgPTyY4HGJN65qLbZ4t68vedMjkjEXbxpTYnNZE5WKXSpYnGK3ahUJ8IVVQRZyvkGHseUId7DNyjZpusBG7R9FuIMdVndgZBVRR66P455Mx2ToFB2LzixKuIMn/FL3dU08NlFkYC7uwIsQZQwSGr+RZuCTVqdlxXkVCXfwj4vJMwjf+PMNwh2cfnK6ceTvv5MAAxr0ICBqFqdHUEQQnaY6Ee7gxusbk02PiItQrUNOU514zPdYiutJePSEMRDBYgcn5lxsXbLtLP9LZMeiGmf8mjFNpdu6boQ7OGTnEFG81dCo1DCUKsUPZ4kahD8cznwXBFU2XYJq9Wn+Z3MGhAWoyjncYVLT0MtLDYmk539hotookKzoYmhMKAv+WpBwB1ddNq1r5R/mr8Zw/nXpL1NhIiJEGR2A9Qv4EMhU164sodVpefDuQU44OoHuR915c/JXJMAnViXojHBuTH565Qz6JprvYCdLl047nlCn6NhwaUPCHfx6/9fJphuOV6nZpRgdn/XEn6uPr/Kdje9w2Ptu1GnEeaZzceNlq4aMgJPp+QcIN93IkWkqdUd9j6qKZ+Kh/u/1k4dlBASI/lQAe2IHy5dP0zmQo5wPOM+3NrxF1+muLDGrBEfuGylKCz14wOeuFUiAjwpUFn0VM8j6a+vpNt1N3We36W7J44xJ4dsGOLfSAgJMN4nCECpjPdGan+z6RL1XpHhNZZItN7bw189qkwCjCtiye2cRIvPxx9larQnJlBVFoaJPM/XzeJLhmu5anZYxCTGpV13IJIqiMDg6mHeC79D7uTcDwwNV40RsaBRDPPRWOg8PUZk4D8yLFqPYJSQk8KOPPsqp1WUbi1LsnjwRxYUBjraeSJuR9dS6cc+inqW5qF+oHzXuGsIdDO8p4pq+xSzRziUTXAq8pFqz0mohdif4DjW/gNtriJt4sE2xdH1G/3j/o8b8RMUnj8Mw1M2rNL+S0Vrz338iiaR8FUKfGZxe+bif/v2JcAeb/tE01Ys6Kj6KndZ0Ul3KhkSQxNx+fxIJ0NOmae62dQ0PZ4KdeGB1dL3A9E7F0w9PqzfueyH3VEsGCxUiZ80ia4iSN49bNSAmgGXmlMmyG+7Pi3+qx8w/zNiodcTeEYQ7WH5uefVY6qvzsGdPiqcPIGRJopX88p9IAqq1uFaKchkUkZKzSiZXRNqLws4rGoqHXHaqSaTHUd+jrLGohtHqMR68X1Cc7yNdxtDNLUu5ACTFQ+di4EXuv7OfTyKfJJ9BH6i4xH4UAXLv3tTXtf3WdvWaTek+EZsQy/JzyxPu4KLzWWvPtcd7Dx2mOLDu52C0jfgPVjQAqw0aTYBs1VxL7eVrouTLpEnihSyVtnoGrj+5rr6ANf+zOff57ONfl/5SSypVW1gt+X/z888kwLs21WiD+Fw9/gaWeS5Tk9QSD01+KcmYsiL5yQdVeGx9xkMpFp1fpK6nwrwK6gtvipbV6dNJgA8a9SIg2q2mlmBpCKPRuGu4/dZ2kkIh+fHwj2qS1fUn1zP9H2h1Wn6y6xNaJ7oGfugIYrwtretvzlYDnWdRzzh8z3CWmFWCLtNc+N6m93jp2iUTZYWPH5MeHoz2uE4PDyVNT3d0fDR9nvvQ45EHPR558FLgJT4Kf5TcA5AKKRUg7tevHxeuXMjGLRuzYtWKrFKzCmf8MYM3Aq9Se9eo0CkeHuK8z0aN08xgMYpdbGwsrayscmp12cZiFLv4eOo6iyD9K5ratPtEWElKzCqRYVdal7VdCHfwvw+Ea285Ps2QGycxM07NINzBtzekH8yxtqtIbY/R2HBev9MZlu/7g9+nOD0yLlJ1+R33Oy5G6ss/KNbWLF4ojgB54ULq20jQJbDkrJKEO7jlxpbUZ6SIw+u+rrt6w9vns884UatlsIPIelzdLfU2ajmFrv8A8VaOr9Ot12fIKP5016fCZGWwkBw6JGbw8VFL5fQf7GSSwZwZYhNiWXZOWcIdnH1mtsm0iLgIVVmYdmIar1wRImg05O09d1TLStKgyOdRz9Vj/PfNv1Pdbrm5wlI958wc04kzZgjryOvCglu5cs67Y3WKjhOOTlAftAV/LchBOwZxybfCvfjYCXQYXYBvjjicpfUfuX+E1RdWV9dvNdGKo/aPMlViN20Sluqi9QmQ776b8roURWHTP5oS7uBP//6U6jYXX1isKuLp9XxOyrXH14QCNgG8UbUgCdCrcQVa/SLkt22xOLVGEqkSHR/NagurEe5g+1XtTVyvfqF+6vFvtaIVYxMSxSiFhZHFREmlrzGX9vYiYD23WHV5lXqc+m7pS89Hntzrs5e1Z1emZ0lx3d2xKsd2VfwzfB4evHtQfQn/7uB3TNAlMEGXoHpdbCbZmCat6a9xpWBBFnLVmlzqiYlJiFGvyR8Pm9YDUhSFb65/U43Fzuw5YLAC9ukvTPKxBV1YYqi4n2smWHGP955Mrc/ApcBLLDGrhInCXP638tx/Zj99n/kaX8wTEtR0Ux+PUF65knKG8IuYF7wYeFFV6jwfearfvZ97Z+gFN6lip1N0fLPXm5z550yu3rua/mH+vHH/BkuUKsGQc6dUpS7Y4y5jQnKmFFZGyVPFrnv37qkOXbp0yRXF7unTp3zzzTfp6OjIatWq8d9/M/YgswjFLiqKUW/1FeZtjT3rfVBcjQ/LTFbj5hubCXdw5AfC6nccrZnBXsUqBitWuvEYifqbDehQkTt3pj377We31TfJeyGpv8l/tPMjwh38/J/PxQhFEc1GAQ5tdYtA2j3BDVbBojOLmj4QUiE2IZbvbHxHle2LPV/QN9SX4dtE149nKMIrF/Lg7WuPyGZ+jNdYyCUh1ez4g3cPqrGIviH31XIIHDzYdMbvvxfu3Xqi9MmgHZlvXbbu6jrVhZdSzJNhuut0V3bt9Vy4ZP4Xauww0KFDMq3rh8M/qK62tN6gDZbCYjOLMSIukb9Nr0Eqjo4sZB9FZLM8XlJCY0LV88GgPL+I0ZsHWokXpokNhHXFfpKjSTxbRljmuUxNhHKZ5sIqC6qo2+qytotRuQsKEvupEXF2NjZiVFKO+h4Vsky25+OI1Cv0R8dHs/hv4r6y+srqDMur1WnV8imTvxAuODo58d6JANq0nyYUO3cH3n6WuQArgwWp1OxSKVoZvZ55qW7Kj3Z+ZGp5X7ZMvFBaObIqvJOd+mcenuEXe75gx9Ud2e/vflx1eVW6mdwpcT7gvJp1/s2Bb0xkiPlCZC4/LQCWe78GF/yesUzQxxGP1ePw6a5PTdapKAr/t/l/hDtYc1FN4/0rIYGGtkMz+5wnQPZNISfKYOkuPbt0ih6RxxGPWXhGYcLdWHQ+Ixiuc427hk9fF96A2/3GERotrXsPUe8Bd4Izp917PfNS5am5qCb339nPK0FX+OP+H7n/zH56PPDgg9AHjIiNYGRcJCPvezPy7Ak+O+fBE2cjeNMnUozXD4HhgTzpd5In/E7wUuAlPo98zojYCD4IfcBTD07xhN8JXn18lRGxEWm6Z5MqdgFhAez8Tmcu27qM4bF696pWy7pVq/LRvn2Mu+TBW3eu8e69nK9Tlx55qtg5OTlx6tSpXLVqVbJh+fLluaLY9e3bl59++imjoqK4Y8cOFipUiCEZyIk3l2Kni4nj4xPevDh8AYPcRH/IeI2Gb70nbvJVF1RNvaZXKkTFR7HA1AJsOEwoXE9QjFZWGS+hEx0fTfvJ9oQ70t62t7fa4sm9jXjzPHfXK811f7XvqwxZAg1B4IVnFDbejBs1IgGu77sjRR0mMYZM0W8PfJvmdhITp41TM4sNw6aGwjKxunw7Xgi4kOKNMrMoisKTD07yq31fscf6Hhy4bSD/uPiHUFzi41U3fFfs59ixyZfXKTo2WNqAcAdH7R+lZszR3l5YNhPz4IEa8FZruIglNFGQMoChT/DEYymbEHWKjk0W1GWZb8CGb7zPTzR/Ma68PjOwWLFkQeSPIx6rST67b+9Oc9vx2ni184lJzKWiqP2TJ70uzofp01Neh9czL445NIYdV3dkm5Vt+OmuT7nDa0eqcWYn/E6oliL7yfamLrHr10VMmbUNS1rdp+PQbqriaUj+SA/DAxLu4OAdg9V6inu896guyUE7BhkfOjVrkgDHVBP7OSOFZ7Ehfkp9EUqDX0/+SriL4uIZdUst81wmHtzTXBhfSzzUdRMm6kM6FRb+WlhtMpN1e/XxVVpPtCbcwR1eO1Kd78CdA6oSbGIx1unUuLOzaEYbJPDKFXH/G7p7aDKXKdzB6gurp1i6KTWeRT1TrdXvbnrXVBE4c0bN9u7SWyif7235MN1YLp2iU70WdZfUTfE8fBb1TFX8fj2ZqMi8vrxO0GcTCIhQ08SNDIKjg9W41cSlj5Ky8vJK1UORkfP2Xsg91cK+cPWXqvekXfVAAuQPP8WpCU9NljfJsAIdERfBmotqqiEz6ssThbJy4coFejzw4Am/Eykez+wOiYvuJyWxYhcWG0aPRx7s/E5n7jpgrDXjuXs3a1WsSN3ly7zme5kejzx4/3kumo5TIU8VuzZt2nBjKlHFMTEx1Gg0mVldukRERNDOzo6BieoOtG7dmqtXJ38zjY2NZVhYmDr4+/vniWLn72zFZ44ahtiDYXagVmMaaBzoDLYdLNwyw/cMz3QRXQN9tvSh01jjegvjeYaLnBqUqtKzS6d+k1IUsmNHYV2q1Z5WA4R5f9yRcamuNzw2XA2QThxsnxIJugT1xqaa9wcOJAHeHPwrgdRbjgZFBKkPjKyk9x/1PcoOqzuwwDgNw+zE/9fyI6O7rN7v9Tjz1Mw0LSOp4fPchx1Wd0jxJlNyVkkRD/OluHGuwQd0dEyeXJfYQvYs6hnZubM4zl98kfJG332XBPhXO/HwWXNlTYblvfb4GuEu4vgehSdRGnU6cskSVfFINpQqJarVJsHgakor9jExa6+uJdxFfF/iGz+/+YYE6N1U9BBu0cJ0OUVROP6/8eq5kHRwmurE3pt7c/WV1Tzz8Ax33d7F97e9ryoRleZX4oWAJP7+H34gAZ4o9i4B8if3cDVhoeqCqnwamXa7oH0++9Q4rZH7Ribb/3/v/avK++fFP8XIL74gAd7oMJIAWbWqqQHUEA9rNdEqQw/psNgw1Qq27da2dOd/HvVctajsnDVUHFsXF84eH0pAdAc7c/OB+uBP6q5PCa1Oq7qO/7f5f+nOb+h0YzXRint9EgUaPnyoWrF+gTvb9rnB2otrq5alwTsGc9XlVXQ/6q7eTwpMLZB6jcREJOgS2HlNZ/XYmpx7iqI2RN1fYghR4Sg1E8RxW3JhSZrrNSjWjlMc07w/rbmyRj1P1bjWFSvE/9+okdqP9bffjMt8e+BbVWFMS8FWFEUN5ei4umOa12G8Nl5NaGv5V0vqxohagv4N3yZAFiwo6gk+fPGQhX4tRLgndwGnJsOArQPUe1/S+6lBWXkU/CjXFLu0Wi76+fmxWbNmjNfG80rQFXo88uBb776l9osNefCAdSpX5um//uKDG2H0uPZCdfeanCt5QJ4qdidOnKCnp2eK0xRFUf+gnOLSpUssVqyYybgRI0ZwTAqRtRMmTCCAZENuK3ax1skfgJG24PlS4I8dHdhoWhOO/++XbJem2Hh9I+EOBhYUxcSa43SGM5bGHBpDuOszLVPjH9EGi3Z2/Pm9e0Qdsb0K8yqkepMwxPdUW1gtQ5YCg3Vv4DZ994yJE4Wbuv9HBIQhKqVsOMONs/mfzTOyu6nyYIG4ifo6uLLtso5qMLdhsJtsx9GHRmeoZZeiKPzj4h+qpcpush2H7BzCZZ7L6H7U3SRoesn8D0mA0VYF6IIwvvWW8UH+IuaFakGYdmKaCDSEPvMwtfIKO3aQAF8Uc6XmF+HqyyiGmJrem3ubToiLI99+2+Q8jtdo+MgZ9KpSTCRNpHAtBYQFqNbgjDxcSaEEGN7q3Y+6GyecPCksR65utEUcNRqj9UJRFLXgNdzBHut7cMWlFdxwbQNH7R+lWuRSG4bsHGJ0txhIZCXsg78JiL88MDxQjWlq9kezVK26R32PqsWCB24bmOo1YDh/naY6CUVN3ytZV6WaIRqBiW+dvTb1EtYifaHwjPDzkZ8Jd7DRskbpKtfDdg9TlQVd167iZe7D79Q6hStXivmWey5XFZa0wixIcuH5herLSbIXhhRQFEW1prtMczG1uq0VXU100LDLAOEyLTGrRLJ40uDoYHZd25VwB20n2XLT9U1pbjNxwfRkhcy3bycBah2d+Boe09qa/GnPb+q6U6uNefrhaVVxT6kiQNJ9NljLB2wdIEY+fqxeb2tnCmtZ9eri1Lwfcl91GWfk2roTfEc9H5NmpSfGcK64TXejX/B9tfnz58W3ETCtQ584aePI/SNpbn/BuQWEu4glTKncVGJlJSg8iCf8TvCE3wneC7nHyJhwRl46x8izJxhw/hpPeDzjSd8zPOF3ghcDLzIsJszEPZt08HrmJeZ9dDHVUJ2IiAhWq1ZNTcC4/uQ6O3XqxBs3bjA+Lo4dmjXjyl9+YZyPn1rV5H7wA3o88uCVoCuZjl/MDmZJnti8eXOGhuxy4sQJVq5c2WTcTz/9xOHDhyeb11wWu0OrtvG/Dbt4evt+euz7l1fPe/DuE3+GROdsCfXw2HDaT7bnoUriJjAEK1imTMYCzA0WiHVX16U8g6KQTZuKG8yYMaIig20UHSaJ8hQpXaSKoqgP54zWUTrnf059wEXGRaqB5GzRgqX1hd2PH0++HUNtveym9PvW70kCXFXa6A8Nigjics/lbLK8iaoEFJlRhAvOLUj1BvEo/BHf2vCWOn+7Ve14P8Q0czgmIYbfHfxOzDMBfFBKuLg/txYFmXfsEPv2wfYPCHdRNDoqPsrYYHtQGrFzMTE09KNr8bGwegSGp19NNzw2PFnbOJLi+BsK1Tk4UJkzlz2aPSNKnldv6lcfJ7fUkUYlodWKVpkqP7DlxhZVEVDrfOl0ahuj4ZX2ExBVghRF4dh/xxoV5RQsKIqi0PORJ38+8jOb/9mc5eeWZ90ldfnZP5/R81HKL6M8c0YEjNs50wHRbNvWOOnW01uqtaLH+h7J3GunH55W3axvbXgrzZu+TtGpZXia/9mcCSHP1cr+P/a7R4D8QN/85HLQZfU/z0zIxtPIp2pXmUN3U4jA13M+4Lwa4H/+5GbV9di18h0C5P/+Z7ynKIrC9qvaE+5g5zWdUz2+AWEBqnUvPetWYuK0cWy7sq16T5h3dh59Q3153O8497YXWanPHcHGn7ZJ1Zoep41TrUQadw0XX1ic4nwbrm1Qz5/NN5I8mxRFrd+2p/5Paqyboijsvbk34S4y0JNm8j6JfKK+lL239b0Mnf+XAi+p/79ajqlZMxFbOHuxIRKGJ04YC1N3XpPxNiWGl4jCMwqnmJV91Peouv3NNzaTp0+La8DBlXaI5WuvMVnNTcM1nlrcJCniHw2W62SJUXqSKiuB4YGqRcwv1I8J4WFU9K26Am+J5IjrQTcz1BdZp+h46+ktejzy4K2nt1J9yapbvy5X/rOSno88ecvnFitXrszY2Fh+OmgQfxg0iMrFi/S+GU8PD2E81ik63nhygx6PPOjz3CfFYxweG06f5z452r/ZLIpdmzZtaGtry7Jly7J58+YsW7YsbW1t2bZtW7Zr147t2rVj+/bts7JqEzJjsUuKRSRP5DBvb3ibC5sIxe43qzEEmG7W2rOoZ+oNzaRAcGL0Fzft7Rl05TGhz4IcsGkQ4a7P0kzC/juiUK7zNOcMu5cVRVFbI228vlFU7wbIIkVUfWbWLNNlDG20nKc5ZzqWzISQEMZrRK205V8lLwugKAr3+uxVlVXDzXz+ufnqQyUoIogzT81UH/h2k+0489TMNK2VG69vpOMUR37bRRy3eyWqEVBYqkw8P9sxSnVHnXxwUmQLGP78W+k81D8UVsCNnUumeTNNzO8ev6sWVpMblN5aQWtr8sAB7t+v6nh8e43odPHm+jeTre/a42uqmzOt2ogpoVN0rP97/eRuHr2b0qPhUAJknz7GMipwBxeeX5ip7aTJV6J23U5X4fpdkSSE6dSDU6oFpNGyRjzme4z+Yf787fRvqpWy05pOKRfdTYJfqJ8atjDl+BSydWsS4P3RS9T/OiSEfHfTu6YWnUzw9f6v1ReNlEicMPHh9g9FOziAt8t2IiB06mdJnts+z33StAIpiqLKnGLx6XR4EfNCdY+aWM/HgRdKC6XTE6/T63Lq/7FWp+XwPcPVZcf+O9ZE0d50fRNtJ9kS7qnUfjx2TMSYOTqylN0zAlTLSYXFhqmZznWX1FVbuPmF+qkdW6osqJKpEBuD1bzOkjpCGZg1S1xwbdrwk0/E1zc/9VCV1cwk2sVr49XrqtemXibu2wcvHqj9pj/eqXf3fPcdCXCbo2htllId+si4SLU80Dsb30mm3DyJfMLSs0sT7iLDODUFN6myoiiKiXLn8ciDfnc81WzU59cu8+a16AwXLo5NiOWlwEuqophUjsi4SG78dyMbNG3A2nVrs0mTJjx27BivX79OAKxXtSrr1ajFqlXr8++/b6qlsKLio9Qs3KSu3tiEWF4OErF4iQvmZxezKHafffYZFy40vcEuWrSIn3+efqBvZjDE2AUlShtLLcYuKflRsVt1eRW/7C4UhJOF3yFALl+e9jKGjNq6S+qmPpM+1o0ff8wNG8TX11+nGgdhN9nOxCKkKApb/NWCcBdZZZnB4AZ4e8Pb4tUQYn/m/CyyLwckeZ59uP3DVJXLzBC3aDkJ8ArqpRQmppKgS+BSj6XqjcowGB7khqHRskYZbsJ+/cl1vjGtMmP0bvu2/coS3xlLARhasPH998X/0bt3iuvRakUt1wcPSO0m0Z4upHxxVZ60UBSF9X6vl1wJjI6mai79+WfqdGpOC7/7TjzYDW/ihvpZpHiANPujGeEO9tnSJ0P/Q1J2396t/rdez/RJOocPCzdwoWK0RgLtOk1W/6e5Z+dmaTspotWq1sHu2MsCBVKuO3rc77iqyCcd3lz/ZprB2kkxxFjZTLJhwA+ijZry5pusU0f836PnGh/mWYklffjioarAHL6XvGSLQbF3ne7KoPBAtV/ze1hPIPWWr4ZuIi7TXIzHSc+SC0sIdxGzmZpVNz0M11zdJXWpcdewyIwiHLxjMO9e/o9hdkVIgEcrf5LmOhRFoftRd/XYVF9Ynd8c+EZ11cId7P93/5Tj1P73P6FANv2cANm4saknxOuZl1q6w36yPZv90Uy1jpacVZLez70ztb/B0cEsMqMI4Q7OPzdfmIb0L3QXdwcQGi01Q0UMXFay3j0eeajnwcBtA/k08inP+p9Vk5ZqLqopXpIVhawoOmu8i20sVy71LlmXgy6rbuExh8aoSlNgeKCq4FZfWD15uEMiUlJWSKE833x6U1XuHt7xVPvIaj0uMuymf5rFsBMTGh1qXM+Lh6qckXGRqgKWzPIWGSlq1Xl68vb1OHp4JO8C8izqmcl6tTotI+IiePXxVXo88uDNpzdztLWfWRQ7Nzc3apOo0QkJCXRzc8vK6tKkT58+HDZsGKOjo7lr1y6Lz4rNTYKjg9llkMiIfFykIgHyvXTCcAzZZKkqYBERxr6P584Z+pTzW33yqSEzKnGv151eO9WbXEZcgIm5+fQm4S7iVoKjg8myInP4/NzTBET9MgOhMaHqDTQj/V/T4nndtiTAaW6/Zsh9HZsQyyUXlqhubMPQeHljrri0ItPxFuGx4TzRVSQl7KqmX9+YImzz5QZRt+nqVWP/1YvGeKP4eBH++L//GQ8TQBaze8EEjQiKqjZKxPik5bozFD92mOJg2uJo/nyxwnLlyOhobt4sfjo7G+PbDKVM3Ka70eORB7U6rXpeuU1344MXWcsaUxRFrTfYeHlj4YqOj1frmfVuNEj932eempmlbaSKvkB2hH1h2iJOdYWmxKPwR/x458cs9Gshatw1rLmoJpd5Lsu0dUpRFPbZ0kcohePEA5W2tlwy/QVhFU/7r4Wl5YPtaQiTDiP3jVStSIljA32e+6iu4/nn5qtu6Ag4sQAi02z5Gq+NZ5uVbQh3US/v5tObVBSFa66sUZX+zJTZSIuk/6n34sPUQtzznkxPPxRj/bX1yRRxq4lW/OHwDyk/eIOC1CbIbYrcICBC/JJyP+S++h8YhlYrWqUbe5gaSz2Wml4/+pI7yuQpLPmuSCxxmOiSZjJAWmy+sVm1piceKsyrYLQsXbokYpzhyAKITGaxTorhxQDuIlP2012fqkk4JWaVSFfBTU2xMxCnjWNMfIw4ByIimHD9lrFAsKeneKPNQMulJ5FPVCXs2uNrvP3stmpxS1EBe/CA9PBg7K27anOJlDaT1LqYeBtZKbuTFmZR7OrVq8e//jK9yFasWME6depkZXVp8vTpU3bv3p2Ojo6sWrUqDx/OWPHQ/KjYkWT/OS1EkK+1FW0Qz5Il046zMwTxmxTpTcz69VQ1KkVhtWri52591YrD9w6rVoRDdw/x4YuH6ttrRjKlUsJgOVruuVzNAI2c94eqtBjKuBisAXWW1Mle+5iHD6mDUJp++iDzSkhkXCR9Q32z5womydu3qeiVt5Xj5lFjJ+q1deqoMLKlPhO2Xz/qdCKH4rvvyOLFTXNzbGzU7lv8D+1IgGPb1073eBhi+UwSaOLijNa6pUsZF6e2SzUpphyvjVeDvm0n2aqt6eAObr25NVt/SeLMuy5ruzAwPJDRX4qOG1tqiW00Hz0t/RVllq+/FgHrdh8TSLkwbFJ0ii7bcTTPo56rhbYflhZ9mCOWrqJtP2GZdplcJN1M3LR4EfNCXf//Nv+PsQmx9A/zV+NU269qL/bjM2OmduPGImwzLZ5EPlHXYTXRSnXpGaxKOdXeKSVWVpsqYtBsnZmRVggvYl5wuedyfnPgG049MTWZldEEfWHsp5XfIPSJ36k1F1AUhR6PPLj+2npeDLyYrX3W6rRqXG/DpQ0Z8ecSsY8li9HmF/GiVrrXomwV6T7ud1y919pPtuf7294X7dIM6Hs+b8O7rFkzQzoT/7z4p5owZhgaLm2YIatleopdMhSFj71DGeFhVPB49SoZlX6JquDoYNUtaxjuBt9Nfv3qdCIkyMOD9y+/oIdHynUlDYREh/D6k+tqkeT7IfeZoM252DoDZlHsLly4wLJly7Jq1ars0KEDq1atyrJly/JCWq0D8pj8qtgtODOPUfrWP7VsRV/N1Jo03wu5pz6MU1VKDMFt48YZmkHQyooMDTXO8smuT9SL2BB4W3NRzQzFFqWEIcC33ap2aowHR45UlYqD+sopry97nXAH552dl6XtGFBmzCQBHkObNFs45QkGk2idOty5LoIFCpBfYDEJME5jx/eb3TEYrNThtdeEBfXSJeFB1OlE+bUdLcR+7XMSNfAKTy+WYsLHs6hnqivZpPDuxo1iAyVLkrGxXLRI/CxePHl2clhsmEmBX+dpzul2AMkoJx+cVOO44A7W/VzseKw1WLjxRFasmMNdKBRFdUP2xI50e7bmNIfvHabdZDtOaiP280hN/b7/Ys1qPfakvq+RkeLAP0mhVVkijvsdV91mRWYUUY99+bnlGRAWQF1sPMPsRW3Fvi77M9w26knkE9XCarD+/nzk50xbLjPL6ZM6noQo2B3dIXmsZ7aoLYozTyyznEDqtRNzA99QX/UlqcqMMgxzFl1l+vUBrfr1J6Ck2Y0no4REh6R4r46vVosEOBDruGtXCgumwqPwR5xzZg7HHBrDbbe2Zdh7kWnFjkLZvHJFobdHGOMvXTP2a82AcqfVaRkcHcwnkU9Sr1caGipcvhcv08ND4dWrqbd1M6AoCuO18Tnqek2K2VqKxcfH8/jx49y0aROPHz/O+Fxtupl58qti9+DFA14pLh4I3zVYR0C0b0wJQxHSNivbpDxDbKxakJgXL6rGu0ZJwrUi4yJVFxLcwXq/11ODiLOCX6ifqiQGL50nNtq2LQeI7lucOtVYy8tusp3pW2YWiK5enwQ4wnZplnuA5hjPnpH6gsVs0YIh7w1XXU1fY66qzLm4iMSBXbvSCC/RJ1vEwJ6OI4QFZdKu5DXtxv83Xo3DM7Ey6AP46e7O4GDVA8olqSQ2KopC7+fePHzvcKZiyzLC5aDLamA/3MFbZR1IgF/ZLCKQs10o6OUl4vis7OiECP6YNcNztvj33r9s+YP4w7UasM4PbrStv4WAqE9tQlwcOX682qmFVlYiDjONCuV7vPeYtHRq9kczNXP7j3f3CtcmivHfA5m3Ntx+dpvH/Y5ny7KYWQY1u8046E3VOfV2pr9+dDa2LIgQFiiQ8aLvOcXVx1dZYV4Fwh0c305c/IElnTlwYBgB8R6YK+ivgTjYsnvz0Bxv35cSWVHsSFX34iWPBGpveBktdzmhc9y9S3p48InnQ3p4kM+z96jJMSymV6ylkV8VO5I8/HpBEuCfXfsTIPv3T3m+vlv6iof9sUkpz3DwoNFioygcOtQYNJ8URVF4Oegyzwecz5F6PobYvTWrvhUbLVSIs2cpBIQR8fN/PlcDnrOF/uYdB1sO7GohV+25c6YBcwAj3/uUu3bouH69KOeWoV7Tieqwvd9KuPKsvqpBz0vGh3VoTKhavNbEbaq/sdPamgwI4EcfiZ+1auXM/TKrPIl8IrKQ9bF/Pq6Nct6S8ttvJMAD6EpA/BXmICYhhs+a1RWWqDHfcbjIpzDt2BYSYlTAAeOLGEBWq5bmkygiLoJHfY/yfMB5VaGfMoVcB5Es5dVpRKrLWhr//kvOhGinl1C9dvpmlYygzwo+/9pbBJhmnGFuEh4bzrVX13Lm/vGMKyLu7fc/nqTGuqZU2zO7BI0U7u196MZz2QtfzjBZVexI8v59oc/dup5A5fp18ePOneyZ8hMSRLE6Dw/e8IjizZs53586q0jFLhXys2J38gPRtHxbq/Kq6yzpCRmvjVdjl848PJPyivTlHviJyDirWlX8/OefXN4BGosbv7GooVrT6+zf/gTIEpWeq0kTaq2nrPLTTyJhAW9z6dKckT1H8PYmR4wQacBr12b9jqIvDxIx5BPa/CQy7ZzbLuN1fUUXQ2mFWotrmbrM9P8L33qLR44YdYXTp7O/aznCs2dqMGFDXEzWhSJbtG1LAvwSC9m0aQ6uNyv8/bdqon3g+ZR2whvHAwcolDZDf15XV3LLFnGeXLyoJh2xQ4cM+ZEVRTTZcEY4o+Aolj2fuX645kRRyI6NQvkCon4jt6XfYSPdFdYQrdQ+wBpqNKSPT87Imi3WrBFJFFZW/KrkljQ9MtnB21Wkvi9tlE5ZhRwkO4qdcMkKfe6Jb5SqkDEDiZSp8vQp6eHBKI8b9PBQUqq/bjakYpcK+Vmxezh/sojNqaShvdsLAuTNJNURjtw/QriLnpepxgLo40v4998MCDB6eV68yP19eBr5VK3YHlND9CGN3rpXtEFtM1kNys1WULaiUFuugohbwSb6++ec/BaDoWNI+fKcemS2cL39VIAF653kpD1/qK64/+7/Z1xGpxNZsACjVm5WYxtT62BmNvRleFZgCDWa5DXWskRIiPoiUQH3uTjlerZ5h06nFsfl4MH89hthtW5XxZ+6OsKax2LFyGtJOiVcv250zc6fn+YmYmLIIUP0m8BK8cXQ3uAlYvduchJEwH9CvYbZk//qVeGOt7anC8LYs2eOiZl9Pv5YfdPagj78tuhqJpw6Jy6AHDhmh5ffFyEAsOL9c2nHa+Yk2VHsSHHpGnIo4nwDxJfr1zP8nyTuFUuSipcX+3fuzM1Lt9Hbmxw5ciRfe+01k3myw+DBg7k/UQ0hLy8vttVXQf/9999Zq1Yt1qtXj++++y7Dk9Rayq5iZwXJS0eZxh0AAFWeExXf3AYAOHbMdJ6dt3cCAN6u9jasrayTr+TpU+DmTfG9XTt1+ddfB9zccl7mpBRzKoYe1XoAADyLxAMAHO9cQ9UGT4CWMwEA37f4HhqNJusbOXkS1g/9EAFnPKz3NsqUybbYlkeHDoCDA/DgAX4o1gnty3UB7KLx4n+t8YvnUADAV02/QvuK7Y3LnDwJPHwIurrik51v4949oEwZYPp0M+1DaowcCQB4X7MBRfkU+/blwDoPHAB0OtxAbQTaVcSAATmwzuxgZQXMmQNoNMDq1Zj29FO4O/2GjXcbw+rGdaBECeD4caBuXdPl6tQBZs0S38eOBQICUly9nx/QqhWwapXY1NQaa8WEDz8U23yJeOst4N/aoxABZ9hcuwzs3Zv1lW3eDADYp3RHBFzx3Xc5JGROsHw58PXXAIC+2IrZzwfDptUbQLFiQJEiwNChwIMHWVp1VBRwYcxWAIBfubao2Oy1HBM7tylUSAwAcD+qOGhjA8TGAsHBmV9ZbCw0kZEAgAi4oHx5YMCAAdiXiZtMu3btMr9dPXXq1IGHhweuXr2KunXrYu7cuVleV0pIxe4lRFO9OgCgXDhgVXENAODoUeN0naLDjts7AAC9avRKeSXHj4vPunWBokVVxS4b52qmmdx+MjTQYI/DQwAAr11FTMcvAPsIlGRjDKiTzafuypUAgM3oj07vFMiuuJZJgQJAe6G0We8/gO3vbUbvqgPFtAQHOHqORW/nJDeNteLhfqpkX2za5QhbW2Dr1rxR6DNFs2ZAkyawYzyG4g/8808OrHPPHvGBt/D220DhwjmwzuzSti0wbx4AwH79CkyIGoMSeIIbqI0rS84ANWumvNzQoUDLlkB0NPDTTyaTFAVYulRc3hcvCn3g+Dp/lPbW3yg++CAXdyh30GiAL38pgiUYDgDQTZyStRWRwJYtAIBN7Id27YDWrXNIyJzA2lqcD1eu4EKrb3ECrfHEppSYFhoK/PmnOLA7dmR61ZMmAZ1e/A0AKPNN3xwUOpOQQsvM5FCuSBTsEqIQHRKHMMUViIkB7t4FIiLEPGSGNq97JpTBBNiiYFFb2NsDLVq0QJEiRXJzr1VatWqFAgXEM6l+/foISOXFLMvkiM3RAsnPrliS1BYSQbZ1PwdR2IdFixot0gfuHCDcwUK/Fkq9JIk+NotffUXSWL9sz5482gGDGHu+YPeBwu3gU1KUaMA4O77RJ5sRveHhVPQJCi1wKs8ChM3CwoXi4LUxZj/f8w9nw0YJqnt91CgRgKyLjGaCk4hTaoNjtLISLXstFn1DeH+UZiHn+IwllaRGQgKVQoVIgC1xMlMlHvKEQ4fId96h0q0bV9afS3vEsEwZ0ZggVTw8jAGS+pg5Dw+13i0BsmVLffm36dPVDPSXFa2WbFH5MWOhD0Y8k0r8cFpcvCjCEOBIJ0Qkz0K2IMLDSf0py00ro0X7s5YtjXEzWzJecujCBbKyta8aw8fHKfffzS1M3IuJug7l6JC00W0iDK5YRVEYf/Eq6eHBt7v24pEjR5PNkxHapnMdpeWKTUzPnj25cePG1P8rPdIV+wpgXb0GAKBaMGDTciGePzd6Vv+6/BcA4IN6H8DBxiHlFZw5Iz7btIG/P3DvnnDV5PWb67xu81D0DWFxqvg4Ho46a2Dnatw91iyjL18p8/ff0ERHwxvVcKdoCzRpkjPyWiQ9hEsbp08DL14AACqVccHJ4zb44ANhvZk3D6hUCfjAeSdsosLxAOVwqUBrbN4M9O9vNsnTp29fsHhxlMEj9IjcpBqas8TZs9CEhiIYhXGv6Bvo3j3HpMwZOncGdu2CZv9+vHt8FCrVdEBAANCxI3D/firLNG4MDBoEAIj67Fu8N4Bo0gQ4dQpwdATmzhXG+fJldMCyZWKZwYPzZn9yAWtrYOi44liP9wEA8TPmZH4lemvdXvRA47bOeeqlyCwuLsC334rv341zRGSjtuKAfvSRuLAHDRIm2XSIjATefx/opRNuWE2bNkDx4rkpusVhCOsJeRgJWyUeOljB3tkO1tYZD0n45Zdf0KBBAzRo0ACenp7q9927d6e6vbTGLV68GCTRP6dvwumqfi8p+d1ix0GDSIBjO4DW450IlwAuWEDeenpLTUq4EnQl5WUjIsTbHkA+emQwirBJk7zdBQNabQLj3UQguN+RfWpnBV/fbKxUb7L4AdM5ZEhOSWrB1BTtyrh5c7JJ+/eT7dqJnIED6CIyquuM5507ZpAzK+gtTTdQi1+PzEaZi+9FuYy1eJ+jRuWceLnFgwdqjgvd3MjFi5N3iAgNJbfMDWC0lbBO98VmAuSHHyax9G3fLlZUpAjNX8wxeyQkkO9UvEYC1GmsMnejUBTGlRYJVX2wxaKtdQaio9WWrhwzRj9SqyV79DCWvUnnmBpKWV2ybSq+mCFryMQKpSjCupbFQYmIpM/lSF46Ec74E2fJEyeEWTqNRIqIiAhWqVKNTz18SQ8Pxnj5snPnzryRqEhmTlrsvv32W27YsEH9ffr0afbpY+yrffDgQTZs2DBZ4kSy/0qPtNi9ClSrBgBoGVsMOuso4M2R+O94PEYdHAUddehZvSfql6if8rKenuJtr2xZoFQp/PefGG2uN1draxvYNmgEACj/8Anq1RPjPTyyuEIvL+DUKehghTUYhLfeyhk5LRqD1S6FN8du3UQMZvhNf3TRHAYA/G/XEFSpkpcCZoMvvkBCAVfUxi1Ebd6TNUsuCe1WEZO0E73wySc5K2JuUK4ccPYs0LQpEBYGfPklULSoSIbo2hWoWlUEk/f7pjR+VcYAABYXGIMrZ6KxZo24vAGIa33aNPF92DBhynuJsbEBPl9cF4fRCVZU8GLywgwvyzNnYfdIJFRZv93Doq11BhwdgQULxPc5c4BbtyBMl2vXAqVKAT4+wPjxqS6/bBnwxx9AZdxDw4QLIljxf//LG+FTQ6MBnJyyPGicnVCprhMcirrgsWMFwNERSlhEmpsknWFj7QSfGycAAEHaSNy/fx9VculG2KZNG2zcuBE6nQ4AsH79erRp0wYAcOvWLYwYMQI7duyAi4tLzm88A4rpS0m+t9ht2SIK2zaup1roDIPtJFvefpZKnzHSGGvTty8VhSxTJlHtLHNhaC32+ef8/HPx9dtvs7gufduu7ehFW1taVH2iXEPf1J3Ozqm325k69aWNsYr77kcS4Bm8watXslDyIVGXjg5Nkr8hWzIJCeSCBUbrXdKhRg1y2rgoJpTUX8hff226gk2bjOdGHsdV5RaKQv7cUHTQiLRxFcFoGeBuN9Ejd63VIN6/n8tC5jDvvCMOY4MGiSy3e/aIkRpNikUo9+1Tq/vwVGtxDbF797wVXE92y52kREIC6XVDywSPS6SHB8P8gpMZ7RRFdOHz9CT3bjjOVg0asH716mzSpAmPHTPWSR02bBhLlChBOzs7li5dmrvSCcJNz2KnKAp//PFH1q1bl/Xq1eOwYcMYGytaPvbu3ZuvvfYa69evz/r163PkyJEmy8o6dqmQ7xW7y5dV18rayxuJcaIfpN0ke+702pn2sj17imVnzVIbENjZZaj9Xu6xdasQpH59rlsnvmapeOzTp6SDaEfVCifYqVOOS2qZJOpCwb//Tnl6FVEvkCtX5rV02ScoiHFW9iTA3/sfzfTiyuQpJMA9eJN//JHz4uUFOp0ov7Z5M7l6tWgcY9J4Yt8+o7ZnCMZ+8MDYwm7iRLPInVtcv6qjF6qTAC8PmZfu/MGP4/nMSrRxWz3QnG+xWSMgwHgoBw5M1Hxj8OAUXbLHjhlLHX7yYRyV4sXFj+3bzSJ/bih2pFDunl8Tde0iPW7yxg2FgYGiPVxQkHinM9S/i76sb0n26FGOypDTSMUuFfK9YhcRYbyJBwez7TsPiSr76D4nIO3lFEW0qgDIU6e4YIH42qFD3oidKokqJD+4GUGAtLFJM8kpZSZNIgF6uTQhoHBe+vf7/MMPP4j/sEeP5NMM7SWcnHKnR1EecK+byOT+z75rRpotmBBeozEJ8Eu75Rk17rycjBoljrO1tTDxGK71119/6WPrUmJn96UkQF+rivS9m/pJodORk5oLxfeZ9WuMCst8j1xL4PBhcV+EqGctssRDQshSpcTI776jopB//UXai/cgdu5MJvz+h/hRsqTZegbmlmJHkkp8AnWeF0kPD3p7vFAVOcNw8SL5/GGU+OHpad6+iRlAxti9qjg7A6VLi+937qB7i7LA3e64fLx02ss9fAg8eSICVV5/HYdFyBU6d85dcdOldGkRFKQoKPfEA2XLAlotcP58JtYRGwssWgQAmBz1LQDNqxFfZ+Djj8Xnvn2itlNifv1VfA4eLM6dl5Ayc7+HDlZoH3cQHr97ZnxBf3+43PaEAg3ser+N3AhpsRhmzwY++QTQ6US85ZMnIh53+/aXPrYuJbpv+BAvrAujguKLBR13ITQ0+TykKPNX4ewGAIDSpz8KuNrksaQ5Q6dOwOrVooLB6tVAkybA7pOFELtwOQCAc+ZgVNMz+OQTIC4O6NUL2L01HjYz9TGWo0cDtrbm24FcQmNrA6vXigEAKtoGoFBBwtkZKFhQPFbq1QOKxAWKmQsVypf/QWKkYvcyo0+ggI+PoUYtTpwQsdKpcu6c+GzQAAk2jmphYrMrdgDQooX4PHECrVqJrydPZmL5JUuAp08RXaQstii9UaMGULlyjktpuVSrBrz5pniSGboSAKL2xeHDIuB69GjzyZdN7GpUgmd1UebCYfqEDC/37M9dAICzaI6PfyqRK7JZDFZWooDt8eOAuzvw++/AlStA+fLmlixXsCtYAJrPPwcAvPtgLjp0MC0NExsrGpgsmxGK3hBdel4bNdAcouYYAweKOtuFCwPXrgE9ewKOvXtgNQZBQ+Jbz/dQ1u4Jpk0Dtm0DHGZPBXx9gddeAz77zNzig9mqY5UGJUoA1tawTYhBZbfnqFEDqFJFVHWxiYtSS0GhZMnc2X4Okt3/6OV8bZEIqlUT6Y4+Pnj9PVHzKDQUuHoVaNgwlWUMit0bb+D8eVGwu0iRNObPSzp0EK1+/v0XrQdOwMaNQifJEKGhwBRRiX5DNXdoz9qqiaKvFD/8ICx2y5cL61zduqJDASAsehUqmFW87OIwZTy0fTegQeA+RB05B6eOb6S7TOSydSgG4EaNPvisTu7LaBG0aSOGVwC3n76Esuw3tNaegvUVT9Sq1Rg9ewrDzL59gL8/8C1WoABigPr1RUeTl5zu3QFvb2DmTGD9eiAwEPga89HS+hyq6Hxwt2x72LX4HVh0FZg6VSy0cKHoVGMmbG1todFo8OzZMxQrVix77SJTo1gx4PFj4ZmyswPs7YWlw6Dtu7mJjNzY2Jzfdg5BEs+ePYNGo4FtFi2LFqvYabVa9O/fH+fOnUNgYCCCgoJQokQ+f9vOLIksdjY2orjwvn1C10tXsWvWTHXDduokXvTNjsFseO4c2s6KAOCCs2eFS9YmvTP111+B0FCwdm387CMKsL5SblgDbdoIhW71aqEou7qKvsAlSgAzZphbumxTr3dVbHcbhN5hKxE84hc4eR1Kc/7Q8z6o+OQ8tLBGrUnv5ZGUkjylVClYvTcAWLsWM16bg05PNxhqEAMAyhaPx2QuBJ4CGDHipeuRmxpFiwrFbuZMICQEAAqi0PM9QLu2sLvnZVq/auhQoF8/M0kqsLa2RpkyZRAQEAA/P7/c2QgprBVxceJPKVhQtBqLjRUPOQcHYb20cDQaDcqUKQNr6xT6vGcAi1XsAFEHZvTo0WjevLm5RbFMEil2gGgZum8fcOyYsVq5CXFxwKVL4vsbb2DvPPG1S5fcFjSDVKwofKf37qHG42MoVOhthIYCly8j7c4Rvr7A/PkAAK/BM/B0jDXc3EQbzVeSefNEK5FTp8QNrVgxYOdOYwftlxiNBoj6ZjwS3Nei3O3D0B3+D9adO6Q6/43vV6E1gHMuXdCqj3wxzLd88w2wdi06PN+MKyu+x96g1xEdLWKr3g38A7bfPBAvNwNfbjdsaqg9jwtXFff4b74B9u4V1/wXXwhLvgXg7OyMqlWrIiEhITc3IrwTieOMHRyAxYvxshTvtLW1zbJSB+DlqGMHgEFBQWnOExsby7CwMHXw9/fP31mxJOntLTKdChQgdTp6ehqr1KeYNXjunFoi5eEDRS1/9ORJXgueBsOHCxk//phvvSW+zp6dxvw6nWirAJDt23PU12K/PvggzyS2TOLjRa3DlSvzTe0yA5GR5DL7ESTAF6Vqpprh9tg3ms9RhAR46nvzlHiQ5CEDBiTPAPb3F902AHLJEvPKJ8k7QkJEp5kGDcg+fUQm7EtOvit3khHFbsKECQSQbMjXil18vChAp++/pdUaG0YnqrtoZP58tRyGoW98q1Z5LnXaHD0qBCtYkHN+jUu/nqZhRwoUoHLnLsuWFT93plPKT/JyM+vnED6FKOqVMG1mivOseGMZCfCRXQUqCZmsjyJ5+QgMNN4Au3cnd+8WSh5ANmyorw0ikbycvJLlTsaOHYuwsDB18Pf3N7dIuY+tLVCjhvh+4wasrUWGFAD8/XcK8ydKnDBM79Urt4XMJK1bC5fJixf4n7OInzp2DIiJSWFeLy+ji2HmTHiEVIa/v7DEW4x7WZIrfD62EKa5zQQA6CZMBB48MJm+d0sUup5zBwDEf/E1NDbZcGtIXg5KlgR27BBB8/v3A++8I9yShQqJG6KdnbkllEjyBLMpdl26dIGDg0OKwxR9dmNmsLe3h6urq8nwSlBHn+Z34wYAoG9f8XPbNlHKyoQzZwAAj8s3w4kTIl7JzPG0ybG2BgYMAACU+2cRypQRSt2JE0nmCw4G3n4biI4WSQJffIGtW8WkHj3yZckuSSKcnIBWfwzGabSAfUIUQjv1UbX/ixcBvw/GoRSCEOxWERVmfGFmaSV5Rtu2wOnTQMeOojbm22+LE+KVqnskedUxm2J36NAhxMbGpjiMGzfOXGK9fCRR7Dp1EolAjx8D//6baL6AAGHVsLLCGh9RIqJDh0SNwi2JkSMBKytoDh7E0MaXAYg4YJX4eKB3b5EgULEisGkTqLHCNlGmCn365L3Ikrynd18r7BmwHsEojEJ3PXGnYmcs7HMcB5pNwJcJ8wAArn/NEyUPJK8OjRuLm19AgCjSXLGiuSWSSPIUi3bFxsXFIVZfbybxd0kikih2dnbAoEFi1NKlieY7fRoAwHr1sWi1KL1vmM/iqFQJ6N8fADDi9pewhhbbtukLL0dHA+++KwqwuroC//wDFCuGixdFqSJHR1HjSfJqMHltBSzrvgsv4IaqT05j5LZ2+Fk3CQAQO3o8bHu/Y2YJJRKJJG+xaMWuevXqcNT71CpUqKB+lyTCoNh5eQH6FHJDcfF//klUskev2Pm81hL+/qIIucW5YRMzfTrg6orCt89ire3H0AQGwGv+IaBpU1HTxdFR+Jtr1wYA/PWXWKxnT+Gmk7wa2NgAP+1rBa8V53CpUh9E2BdBeNlaUFatgcOMieYWTyKRSPIcDZlb/T3MS3h4ONzc3BAWFpa/4+0URRQxCgsTrYPq1wcgkgcOHwbefx9Ytw5Ao0bApUsYVXIT5gf1x+TJgMV7vLdsAd57L3mPtOLFga1bYeg7FhUFlCoFhIcDR44IF7NEIpFIJPmFzOg0Fm2xk2QAKyuhtAGAp7Ex+vTp4nP9euDA1kjRZwzA1qCWKFFCFGC3ePr1Aw4eRHjlBgCAUBRC/LAvxb4YmskCWLlSKHWVK5sWW5dIJBKJ5FVDKnb5gcaNxWcixa5RI1FwHADmDzwP6HR4gHJ4hDKYP18kWLwUdOoEZ5/LqFs5GoURjL8aLBIWOz3x8aKlDiC6bVhEazSJRCKRSMyEfAzmB1JQ7ADRZevNN4GmCacAAKfQCjNnWnhsXQpYWQFDv3IEoMGUKUBkpHHaggWiyXfx4qKLjEQikUgkrzJSscsPGBS7q1dFb1A9trbAnj3AyNdF4kTbsS0xerQ5BMw+w4aJZNnAQGD0aNHr+coV4JdfxPSpU0U7QIlEIpFIXmWkYpcfqFBBVF1PSADOnjWZpImJRtFbJwEAZQa2MYNwOYODg7BAAqKMS7NmIp4uJkbU7pPWOolEIpFIpGKXP9BoRKV1QKSFJuboUWHFK1dOLQ3ysvLWW8CiRWJ3PTxEInDLliJBVqMxt3QSiUQikZgfqdjlFwyKnUm7CQhfLCD6bOUD7efLL0XJvrlzRZ2+o0cBNzdzSyWRSCQSiWVgY24BJDmEQbHz8ACePQOKFQO0WmDXLjG+Rw/zyZbDVK8uBolEIpFIJKZIi11+oWxZkUShKPqKxBDWuqAgoeR17mxe+SQSiUQikeQ6UrHLT3z6qfj84w+h4C1cKH5//LFoIiuRSCQSiSRfI1uK5SfCw0VvragowN4eiIsTNU9u3xa1QiQSiUQikbx0yJZiryquriJtFBBKHQD8+qtU6iQSiUQieUWQyRP5jSFDRGuGM2eA1q2Bzz4zt0QSiUQikUjyCOmKlUgkEolEIrFgpCtWIpFIJBKJ5BUk37piDYbI8PBwM0sikUgkEolEknUMukxGnKz5VrGLiIgAAJQtW9bMkkgkEolEIpFkn4iICLil024p38bYKYqCwMBAuLi4QJOLrbTCw8NRtmxZ+Pv7y1g+C0MeG8tEHhfLRR4by0UeG8skr44LSURERKBUqVKwsko7ii7fWuysrKxQpkyZPNueq6urvNgsFHlsLBN5XCwXeWwsF3lsLJO8OC7pWeoMyOQJiUQikUgkknyCVOwkEolEIpFI8glSscsm9vb2mDBhAuzt7c0tiiQJ8thYJvK4WC7y2Fgu8thYJpZ4XPJt8oREIpFIJBLJq4a02EkkEolEIpHkE6RiJ5FIJBKJRJJPkIqdRCKRSCQSST5BKnYSiUQikUgk+QSp2GWDZ8+eoUePHihQoACqV6+OI0eOmFukV5YJEyagVq1asLKywqZNm0ym/frrryhWrBgKFy6MMWPGZKjXniRniIuLw0cffYQyZcrAzc0N7dq1w/Xr19Xp8tiYl2HDhqFkyZJwdXVF3bp1sWfPHnWaPDbm5+zZs7CyssKvv/6qjpPHxby0a9cODg4OcHZ2hrOzM7p3765Os5hjQ0mW6du3Lz/99FNGRUVxx44dLFSoEENCQswt1ivJ2rVreejQITZr1owbN25Ux+/du5flypXjvXv3GBgYyJo1a/Kvv/4yo6SvFpGRkZw0aRL9/f2p1Wo5e/ZsVqpUiaQ8NpaAl5cXY2NjSZIXLlygm5sbQ0JC5LGxAHQ6HZs1a8amTZty+vTpJOU1Ywm0bdvW5BljwJKOjbTYZZHIyEjs2rULkyZNQoECBdCrVy/UqVMH//zzj7lFeyX54IMP0LlzZzg4OJiMX7t2LYYPH45KlSqhZMmS+P7777Fu3TozSfnq4eTkhPHjx6NMmTKwtrbGiBEj4Ovri+DgYHlsLIAaNWqo9bc0Gg1iY2MRFBQkj40FsHz5cjRr1gw1a9ZUx8njYrlY0rGRil0WuXPnDtzc3FCyZEl1XP369XHz5k0zSiVJyq1bt1C3bl31tzxG5uXs2bMoXrw4ihQpIo+NhTB8+HA4OjqiSZMm6NatG2rVqiWPjZkJCQnBvHnz4O7ubjJeHhfLYOTIkShWrBg6d+6Ma9euAbCsYyMVuywSGRmZrOGvq6srIiMjzSSRJCWSHid5jMxHWFgYPvvsM0ydOhWAPDaWwpIlSxAZGYnDhw+jbdu2AOSxMTc//fQTRo0ahUKFCpmMl8fF/MycORO+vr54+PAhOnfujDfffBORkZEWdWykYpdFnJ2dER4ebjIuPDwczs7OZpJIkhJJj5M8RuYhNjYWvXr1Qo8ePfDxxx8DkMfGkrC2tkanTp1w5MgRHDx4UB4bM3L58mVcuHABQ4cOTTZNHhfz07RpUzg7O8PR0RFjxoyBs7MzLly4YFHHRip2WaRq1aoICwvD48eP1XFXr15F7dq1zSiVJCm1atUyycKUxyjv0Wq1GDBgAEqVKoVZs2ap4+WxsTwURcG9e/fksTEjx48fh4+PD0qXLo0SJUpg8+bNmDp1KoYOHSqPiwViZSXUKIs6NmZJ2cgn9OnTh8OGDWN0dDR37dols2LNSHx8PGNiYti6dWuuWbOGMTEx1Ol03LNnD8uXL8/79+8zKCiItWvXlllkecyQIUPYpUsXxsfHm4yXx8a8REREcN26dYyIiGBCQgK3bt1KBwcHXrt2TR4bMxIVFcWgoCB16NevH3/++WeGhobK42JmQkNDeejQIcbGxjIuLo5z5sxh8eLFGRYWZlHHRip22eDp06fs3r07HR0dWbVqVR4+fNjcIr2yDB48mABMhqNHj5Ikp02bxiJFirBgwYIcPXo0FUUxr7CvEH5+fgRABwcHOjk5qcOJEydIymNjTiIjI9m+fXu6ubnR1dWVr7/+Ordv365Ol8fGMhg8eLBa7oSUx8WcPH36lI0aNaKTkxMLFSrE9u3b8+LFi+p0Szk2GlJWN5RIJBKJRCLJD8gYO4lEIpFIJJJ8glTsJBKJRCKRSPIJUrGTSCQSiUQiySdIxU4ikUgkEokknyAVO4lEIpFIJJJ8glTsJBKJRCKRSPIJUrGTSCQSiUQiySdIxU4ikUgkEokknyAVO4lEIpFIJJJ8glTsJBKJRCKRSPIJUrGTSCQSiUQiySdIxU4ikUgkEokknyAVO4lEIpFIJJJ8glTsJBKJRCKRSPIJUrGTSCQSiUQiySdIxU4ikUgkEokknyAVO4lEIpFIJJJ8glTsJBKJRCKRSPIJUrGTSCQSiUQiySfYmFuA3EJRFAQGBsLFxQUajcbc4kgkEolEIpFkCZKIiIhAqVKlYGWVtk0u3yp2gYGBKFu2rLnFkEgkEolEIskR/P39UaZMmTTnybeKnYuLCwDxJ7i6uppZGolEIpFIJJKsER4ejrJly6q6TVrkW8XO4H51dXWVip1EIpFIJJKXnoyElsnkCUnWuH0biIw0txQSiUQikUgSIRU7SeYIDwe6dQNq1gTq1QPu3TO3RBKJRCKRSPRIxU6SOWbPBg4eFN99fYGePQFFMa9MEolEIpFIAEjFTpIZwsOBBQvE9wULADc34OZNYPdu88olkUgkEokEgIUrdnFxcfjoo49QpkwZuLm5oV27drh+/bq5xXp12boVePECqFED+PJLYPhwMX7WLLOKJZFIJBKJRGDRip1Wq0WlSpVw7tw5hISE4J133kGvXr3MLdary6FD4rNvX8DKChg5EtBogNOngQcPzCubRCKRSCQSaEjS3EJklPj4eDg4OODZs2coUqRImvOGh4fDzc0NYWFhstxJTqAowGuvAcHBwMmTQKtWYnzbtsCJE8CcOeCob0AKnU8ikUgkEknOkBmd5qV6BJ89exbFixdPUamLi4tDeHi4ySDJQS5fFkqdiwvQrJlxfJ8+AICHc7aiSBGgSBFg1CggIcE8YkokEolE8irz0ih2YWFh+OyzzzB16tQUp0+fPh1ubm7qINuJ5TCnT4vPNm0AW1vjeL1rvHTAOSihL/DiBTB/PvDee8DLYwuWSCQSiSR/8FIodrGxsejVqxd69OiBjz/+OMV5xo4di7CwMHXw9/fPYynzOZcvi89GjUxG779RFrdRHdZQsPnzY1i3DrC3B7ZtA9asMYOcEolEIpG8wli8YqfVajFgwACUKlUKs9LIvrS3t1fbh8k2YrmAQbFr2FAdpdUCo0cDR9ARANDV+l+8/z4wcaKY/v33sjmFRCKRSCR5icUrdkOHDkVMTAxWrVqVoR5pklwgLk7UqwNMFLtdu8To886dxIgjRwAA334LVKkCPH8OrFiR18JKJBKJRPLqYtGK3YMHD7Bq1SqcOHEChQoVgrOzM5ydnXHy5Elzi/ZqcfOmMM8VKgSUK6eO/v138Vnl03YiFfb2beDRI9jaAt99J6bNnQvodHkvskQikUgkryIWrdiVL18eJBETE4PIyEh1aN26tblFe7W4elV8Nmgg6tYBuHNHGOg0GmDwqELA66+Lef77DwAweDBQuDDg56eOkkhefkJChBl69WrZSk8ikVgkFq3YSSyE27fFZ61a6qjNm8Vn585A+fIAOoo4O/z7LwDA0REYMECMkkkUknzB8+fi5eaTT4AhQ0TqtzRHv7o8fSo8GRKJhSEVO0n6eHuLz+rV1VF//y0++/fXj+iUKM5OX+fkww/FqO3bgaioPJBTIslNhg8HEmfbb9kCrFxpPnkk5iE6WrgkihcX90R9bLFEYilIxU6SPj4+4lOv2N25A1y7BtjYqGXsgJYtRZ2TR4/U+Zs1AypVEvdBQzcyieSlxMtLvM1YWwMXL4rgUQAYP16+tbxqjB9vdEPcvw/07m2q8EskZkYqdpK00WqBu3fFd71it3+/+Nm2rYijAyB8ry1aiO96d6xGA/TsKUbt3Jk34krykJAQ4Nkzc0uRN/z1l/js0UPEkw4fDlSoADx+LCx3klcDHx9gwQLxfd064I03gLAwYMQI88olyXsiIoC1a4WSHxtrbmlMkIqdJG38/ER/MEdHQN/N4/BhMalLlyTzdjItewIYLXp79shwlHwDCXz9tegf99prwMiR+buHnFYrkiUAYOhQ8WlnBwwbJr7Lmj6vDkuXivOhe3fg/feFK16jAXbvNpaEkuR/wsOFUj9okHDLt28vXvIsBKnYSdLGEF9XtSpgZYWEBODYMTGqc+ck8xoSKI4eVYPKW7QQVr2QEOD8+TyRWJLbzJ5ttFoAwKJFwJgx5pMntzl/XiROFC4MdOumjg7qMhi0sgJOnULs9TtmFFCSJ+h0wKZN4vvnn4vPGjWA//1PfJ8zxzxymQt/f/EwiIkxtyR5z4gRwK1b4ruNDXDunLgvWghSsZOkzR39A6tqVQDiGRcZCRQtCtSvn2TeRo0ANzfgxQvg0iUA4pw36HsvdYyx4SZmYSb3PCcyEjD0a16wwJgePW8ecPw4APFXzZwpupL8/beob/1Sc+CA+OzSBbCxQWQk8NFHQJmmpXBYESf3lKa7sHChrICSrzl+HAgKEvU8Eyn4+OYbAICycRMO74zCtWuvwHnw22+ipmn79iJT3MvL3BLlHQ8eAOvXi++nTwsFb8gQYMoUs4qVGKnY5TXx8eIEqFcPcHe3fEXB11d8Vq4MwOiG7dhR1CQ2wcYGaNdOfNfH2QFGD61h2ZeOSZOMN7G6dYEbN8wtkflYsUIo7lWrAl9+CfTrp7on+cMPmDeXqFwZ+OEHYNYsMblJE2PFnJcSg2LXrRvCw0Vs6apV4uHtWfIdAECX2N346ivhlcnPXulXmr17xWevXsIVr+eqUwv421eGVUw0Vry7G/XrAzVrAvv2mUfMXOfQIXGBG/DxAfr2zQdvcBlkyRJx8XfsKFxSVasKl7y9vbklM8J8SlhYGAEwLCzM3KKYMmgQKaKUxPDxx+aWKG3eflvI+fvvJMnmzcXPP/9MZf6FC8UMHTuqo+7fF6NsbMjw8DyQOSdZs8b0eAFkzZpkTIy5JTMP9euL/2DxYuO4x49JR0cS4JvYQ4Bs3Zr8/HOyaFExe8mSpK+vuYTOBsHB6nFXHgXyzTfFz2LFyBMnSPr5kQB1GisWs3pOgPz0U1JRzC14LqIo5PLl4lxo2ZI8cMDcEuUNDRqIg79hgzpq717Szo6ciPEkwKMub9HJyXirmDbNjPLmBopCNmwodu6zz8gnT8jXXhO/3d3NLV3uo9ORJUqI/d2xI083nRmdRip2ecmhQ+KE0GjI/v2NV//x4+aWLHXq1BEyHjjAFy9Ia2vx88GDVOa/dUvMYG9PRkaqoytVEqP37MkbsXOEyEjGFylOApxuM46VXZ8y1EF/UU+caG7p8h69EkMrK/L5c5NJd94dTQL0xOv8dbqiKjaPHxtPoddfJ+PjzSB3dvjnHyF89epcvlx8dXAgPTwSzVOvntj3r9fQyiq53pvvWLnS9EXH2po8fNjcUuUuz58b9zcoiCR59qy4zQHkZ21uqW+v4b7P+eWXxtnnzjWv6DnKf/+JnXJ0NN4DNm4U4woWJC3peZsbeHiIfXV2JmNj83TTUrGjhSp2zZqJk2LkSPF72DDx++23zStXaigKWaCAkNHbm7t2ia/VqqWzTMWKYsbt29XRhl0dNSr3xc4pbgyeSQK8h4q0RRwBsj/ETSzWpQgZFWVuEfOWRYvEQWzVymT08+dkjaLPGA7nFN9k/f3JQoVeUn147FgSYMz7H9PNTezDnDlJ5hk3Tkzo04ezZxvfa27eNIfAuUxgIFWT1Kefkr16ie9FigjrZn5l61axn7VrkyRDQshy5cSod97Rv7AYLFlLl5Ikp0wxvgcdPWo+0XMUg0Hiiy+M43Q6skYNMX7GDPPJlhdMmCD283//Mxmt0+X+pqViRwtU7Ayavp2dMF+TpJeX8Y338WPzypcST54YLYyxsfzhB+P9PE2++UbM+OGH6qgtW8SoOnVyV+Sc4uolLR9oxJ17Tt0VvHSJPHWK7Ng2gfcgFNeLQ383t5h5S/fu4iDOnGky+rPP9M+zoj+JLw0aJPNFbthgfNH3989LobNJmzYkwM1d/yQgvI9abZJ5zp8XO+fiQiUmVv2b2rbNhy7ZX34RO9ekifgjYmKMJtmvvza3dLmH4Z42fDhJ44tqlSqJjFS//UY1DoHi2A8ZIkaVKkW+eGEm2XOKmBhhqQLEOZ+YFSvE+AoV8kbLMReNG4v9XLlSHbVvH9mihXjnyU2kYkcLVOw++UScEO+/bzreYMVLZgawAM6dE7KVKUNSfcbxr7/SWe74caNpPi6OpLDqaDRidG5fANklIYH8vOIBEmC4TUEmhEer07RackPTuSRAD6smvH7dfHLmKVot6eIiDuCVK+rou3dF7CRAnt793HjjT2K1UxRh6HsZwkpV4uOF3xVgPTsvAiKmKhmJ424OHqSfnxpymDgc6+UnNtYYT7Vli3H84cPGINpUYzReclq0EPu4Zg09PIz3shMnEs3j72+c4OdHUkSjVK2a3Mj1UmIISyhTxkR5e/KEnDQ2mmHWBUmAb9nsZ4MG5KRJ5LNnZpQ3pwkLoxprERBAUkQeubqKUaNH5/bmpWJnWYpdXBxVP86xY6bT5s8X4zt0MItoaWKInWjdmvHxxofVrVvpLKfVimh5QLgw9Bhijzdvzl2xs8vCheQm9CMBRn86Mtl0beATajUi2LBTeR+Ghua9jHnO5cvi4Lm6mpisPvhAjO7WTT/ip5/UmLSkAXVnz75kz3/9Psc4uFEDHRs3TsMC9+mnJmEWBjdcyZL5KOxo926j+SlpsGSHDiTA212/Yr9+4lpv0kRYc5Mad146Ein4vH1bTaD54IMU5m3fXkycPl0dZQhL02jIq1fzTuwcx2Cc0J/jiiJy6gzvcnPxNQlwB3qq8YWFC+ejl5sD4mWfFSuSFAbMWrWMRlq9DSPXkIodLUyxM7zplCyZ3Ezt7W100SZKNrAIpk9XXapr/vUg3u9Oh64TGRkbnf6yP/4olu3eXR01cqRpiKElEhNDVngtipHQxxZeuJDifHEdupEAJ2AC+/XLYyHNgSHbuWtXddSNG0YDhaenfuSLFyJlFBCuqSR06EDaIZaz+54V574l+yr17qVTtu0IiPecVNm50+iKUhTGxgo3HSBC8PIFH38sduirr5JNujxTJIZFwZFF8Ex9sBuGQYPIiAgzyJwTXLqkeiA8L+jUuLk7d1KY988/jbF4ic7tfuI9kW+9lXdi5yiKYgwq3L+f8fFGNzNANmpE7p4hEkgUa2tumRvAunWN08eNs+xLPUMYYmkHDSJJfved+Fm8uDG6KjeRih0tTLEzlDhJ4YZIRSHLl2fqfh4zMnw4CdB/5GBau9sS7iDcwbc2ZODu5ONjjBz29iYpLHWAiDG2VJYsIXvjb3GD0j+kU2T1ahLgNdRJapjMnwwYIA7epEnqqPfeSzGOmPzjD+PLyrlzxvFRUfT5aCpfwNV4x+/QQUSiWyL6N5HZ+IYlS6aT0RsZaUyRvHGDpMgdAoRF46V3SWm1xto1//2njlYUkfVppVHoiddJgEda/cK9e8U18cEHRuW/YUPy6VPz7UKWWbpU7EDnzuzZM1n4sCmhoeK8TxKy4O1trChw6lReCJ3D3LsnhLe1pTYskn37ip/W1uTs2YnsFa1biwkTJzIhQc09IiDCM19q2rYVO7J8Oa9cMXpl86rSg1TsaEGKXUKCsEcDqZc1sdSU0bfeIgH+NriqUOp+dFOVuyP3j2R4eQ4cSJJ89Mio65n7sKSEooiMX4MbNs2giZAQNbisCnz42mv54OGdFoZM53//JSniJA2xdZcuJZlXUch33zVqNZMmiRpXpUurd/lgFKJieOI3a5ZCRoIFoA8KfB9rMxY/Y/DR6d1wiiJKvORF/E2uc/q02JFChcQ9jeJh/sUXxgf3ovZ/G+dJZJ47dcpoxG3c2PIcE+mizw568vGPqkvVyyuN+Xv3Fjv7/fcmo4cONbrtXjrrlaHWT+vWHDVK1fG4e3eS+datM8bh6c+TBQuM58iaNXkveo6QkKBWiFBu3FTjzfv2zTsRpGJHC1LsTp5MdkNMhiFlsEmTvJUtPfTFaLu9D2K8HeESwHeWjiDcwbYr26a/vMGFodGob/mGenaWWNP06FHSFnEMgz5J4OzZtBfo3JkEOKv4DALCgpUvCQkx3pn11rWJE8XPFi1SWSYsTBSpTuqTK1+e/wxcTw107F/rmjH2dNmyPNudDKHTUeckgodq4UbGkmSWLBH70rKlOmrPHjHK0VEtf/ZyMmmSyZNMUYyhFRqNsNooCVpjpkCSZDAvL1ERBRD5Y0p8grjvffaZMPlZsp9WX5V9abuNBJh+6IXBVFuypEnglb+/0aibNNTa4tGb52/0maBeyonzZ1RiYowHOpHWZwi9LVAgFRe2pXP9uvqiemCvloA4lg8f5p0IUrGjBSl2hhohSbNhE2Mo/GpjY1m10fTFx2oNB/H2p9RoyBv+Dwl3UOOu4aPwR+mvwxBUXrIkefu26pW2xLijgQPJTjhkDJxIL21f/yCPqPOGapbP42LkecORI2Ln9EHD8fHG3Jg0A6Pj48Wbfs+eov7VypVkTAyfPjV6qx5+P9/4f+d29HFm0IcSRMOBTRqm8kKWlIcPjSZpvflWUYyJ70kMOC8XhqSAJUtICgOs4QG/dm2i+Qxu+NKlkxVwPXFCuO4cEM1HdbuYKvxNm1qmS16nU7MDXne4SSBJJmxKxMYas6STmKg+/1yMfvttirp/Z868HBq/Plyoh+MRAuSYMWnMawg+69FDHaXTqfk1bNHCMg30aaKPt1XatFErnnzzTd6KIBU7WpBiZ0ib0UdeR0eLMmD16wtr9YAB5K2bisg0S8tdm9dERKg3XZcfQVT811Cbk83/bE64gwvOLUh/PZGRIpBYb7U8NmQlAYVt2+aq9JkmKkq8Tc6H3gzxySfpLxQYqAYQTfsyQNVP8p1L1lCfq3dvksaahNnRxQwhe198Gp9iBrXZ2bSJBHgOTTl/fiaWM6R+J+q5Z7Daubi8pLXMYmKMpqbbt1VvGyByakyIjTW63JPUOyTJaeOieAidxEPSyUlcZwULivk/+ihv9icz6GPLtDZ2tEYCa9bMoBt12jSxT3XqmHhqvL1Ja2jpjl+oc3A0BqpZYrkrA4GB4j+AFZ0RzjZtUnc+kTQmBFpZmaS/+/kZKyb9+qt+ZFSUqJlk6S0a9fHmd3p+R0DU6M6LhInESMWOFqLYGQJOra3JkBA+eSK8rUm9U46O5KPmvU3ic8yOvjVYqD3oMKEwYZWgFiaec2ZOxt2xpIiYbtpU3eEjaM86dt4WZaDZto0EFPpblxdy7tyZsQX1bpr4eYtVHT7fZckasiSmTuX9kPus2v9PouRFjh+f9VUaSkC4upIJo/UR1okybs1NyDBhaV+m+SxzAf+GB3q7duoonc74fpeCrmP5HD2qWt09PRS18sePP6Yy/6pVRk02cYPgqCjq2gmzTTicOfOdk2K8IX5PoxElZiyJHTtIgLccGhIg583L4HIhIUaFNXFPsdBQerzW3XjzN3T2ASy3DpTetXwF9ejsnMEC4wYLbxLXjKGOsYO9wpCfZxmLwBUpYtKpyOLQP79+KC/c8T/9lPciSMWOFqLYGWrUtWvHqCiREm44h5cvF3Ho+jAt/mAzS3zp2dN88ibm4EES4LXXwOKfDSZgLEx8N/gu4Q7aTrJlVHwGXcfx8eSvv1LRF8OLhgNvLsxAAkYeMWAAWQfX9Hcdh4xHeM8UbcfYqRM9PY2Zb5s2pbGMogj/1fvvkz//bFnu95TQtwu6smI6naa4qAk0kw5mwGKbCjqdsFgD5MHFd0xegCwBvxrCVTin+tLMLfjggfFBrS9SSxofaKVKJbJyviwV+vXKasw7fdVj1qNHGuLrdOoLDxs0EK5Gf3+1yG+CozNb4BSBREnThlZVqaabmgl9MOlKDKaDQyZPT0PCgZ2diCHdvp2sXJmEKAsz2GYdnz5RRGaNXnFmeHiu7UpWifxSyLcUwzKu2BrM+q6uJqnQikJ2bBPP1fgwuYXDyso0i95SSEhQLdZV4ENHR/N0z5OKHS1EseskXA6cNUuNLStalLx9m1T09vyEBNFrsDVEtwZd6TLmkzcx+liZPVVB28ZrCBgLEyuKwnJzyxHu4KG7hzK33vv3ebWoeGuPtXcRsUxmJjpahNH8hCnJYkPS5U4ipSQ4WO24VLhwGqEzhhu5fgio8hoDgsz/P6RIbKyqrTYc/5qq1MEdtJ5ozbP+6SSYpIHhb+jTh8lCFsyKojDUVqRxrv86C9V1DdaKRCat2Fijx/nvmfdFj1Vra6HdrlqVg8LnAu+8QwJcXnMOAZE5nq5L+cEDY3kUQ/YzIJJlTp1S74cdO+rnN1SvdnS0rJR5fYbrN5ideZ1TpxMndxIFRilblu/X8CSgL/UYE2PMKlu0KDf2Ilt4vyayw38ptzJtF2xidDpj79whQ4z+66govmgpsscTYM373y8W+2+on1KzZjp+XjNw44YwRtg4UwMdhw41jxhSsaMFKHbBwWo9iAMLfcT9zSaeg1aOZ+EZhekwxYHD9wxneGw4w8LIGqXDqYP+BmgBfWNjfhpDAvy9EQhXfxYsaPqGPnjHYMId/PFwav6Y1Jk7PYbH0drofjNz7r/e28JLdnp38dJMWmkMlThXr2ZcnDHMKkWrhqGZOMDtdWz4zFF8n9rJnt7PvXNqlxivjadOyQGL0NWrwlrj7EBMADWjKhA2MWy/uD/hDnZb1y39daSCoZmFgwMZ+5Vey0uxnH/eEukdoD54bl/OQDHupBiKFbu6mmhAv/5Kvg5PPrd+LdnDXrd6tfqylxP8d/8/1l5cmw5THPjFni8YHZ+F/SDFtalvI/YGztDePhPdE27dMj7cAZEtrK9p6ecnymUA+gxRRTE2kk8Un2hulCoiy7cjDvNQJt9hSQolZdw4kXhUrpwoafXihWrMq1pVf/szeHdyuMhncHQw/733LwPCArK0/M3LcYyG8L1f2Xw7cwsfP25U6seMEa3n9JbcWGtHdsdetmih3//gYOOLwN9/Z0nWXEMfVHoaLQiYlCfMU6RiRwtQ7PQFbLW164q8CI2W1cb3MrF4wB3ssb4HdYqOe/eSN1GTBBj0l/kLFT94V5SqmNKxMIFELaP0rLq8inAH3/jzjUyv+9w5sgp8GAt9amQu1D7xD/PnV/u+4ofbP+ROr7Tj5d5/nyyDh0brQmab2U6YYOJGv3bNGGuuBgmT4iGvf0j+3qUw4Q5+85EINI+yATvPbsAEXfbeViPiIjhoxyDCHaw8vzIP3j2YrfVx/XoS4PkK+gLV9dawTh3yzvO7tJpoRbiDl4MuZ2nViZ/lB8YeM8YpmNlFefZn0SnG27Z21t45EgfVffmlOjri7/2MgBMJMKxiffL8eUYP/YgE+LQA2Gx2TZ58cDLb8t8Nvkvnac4m95kv936Z/oIpcf8+CTAOtrRHjCEpNuNKqE4nguPv3Us2yVADT63rNnWqGGEp7RkiI9Vai7WKPmFCAun5yJMDtw3kZ/98xhtPbmR51RERxlZc//1H8vlzKoZU8RyKMzzme4xOU50Id9BxiiPXXV2X6XV819aDBBhuWyhr16UhVCXxULAgn+08pbaoVG//hs4OlpZZ9/33JMBFGM7WrcmnkU855tAYvrvpXW66vilHX8jSQip2tADFTl+i/N9WE8S5/O54wh20n2zP1VdWc6fXTjpMcSDcwTln5lBRyMMlROPNbfUnmkfmRPg0LE8C/K5rGwIi1CQx90LuEe6g3WQ7xibEpriO1IiLEx6Xefgq867PDHD72W0W/LWgyYNtyvEpKc6r1YqqLiOwwGhVyCxXrhhNT/rYPMMbubV1oppV+mJOIRVK0G4cWPy34nwa8YRx9YXF7+uu4Mbr2XNFDtk5xGS/Xaa50DfUN+sr1Mu8tBFoNbYwYR2nGjT7/y2sdsP3DM/y6g3l0d7sHG8MJM9Q0bjcY2djIdSF6tmwHupjVAmIB8OPP6oW/EPoxLfbhvH/7J13eBTFG8e/V9J7Jx0ISQgJvYN0BAFBuqAo9oqCys9eIhYsKGJDEBQElCZF6b2XQOiBNCCkkN57crfv74/Z3btL7pK7SyAx7Od58txlb29udnfmnXfe95131JyaHlgxnK65sfM+HAxy+cKFbhU0bCPdoSuHEiJB9/12H/127jexLZijNJYtY4r9KfSiiROJMooz6f4/7ierT6yox9IedCnjktn1TE3VTIB27VFR2tGdGndsc1glefo0m2jDi15+mWhb3DZSfKwQ76fLFy4Nun4+7zFNmV5Bj/z9CG0MY+3gzLMNl4e3Cm6R43xHHVmgnKc0qb4nT2rkYvGAUfV/QR9CPHGHDiwWYfp0pugTSxcCMCOeWs3Rpr0/kErOW/iaQYiOgHoYC4R/Bktp5V9FFPJDiM59/erY3VkRJSl21MSKXXGxuGl0V+UlgtdFkkcygaA9a1p8ZjEhEuT2pRsVVRRR0mvfEQH0j2yscSuPahCbHUuP/P0IjV4zmrbHN8zql+zFplPjuv+PAKrlhuA4jty/cidEgk6nmh6HNGQIs9oRQJxMRv/7ZRK9tus1Si9uWE6niuoKivg5ghAJ6rS4E03bOE3sgPriAXnZTUcUg9mbb74x/Uc5ThMjw6fs4DjNTnIeHkRJJ9JImKI+/RS7b4tO8Xk0fvqJuTq8QF0XdzF7Brj3+l4xx+Dma5up3/J+xm8BZwg+vmrWKBDGvEiOjppcsrsSdhEiQe5fuVOVqq79tgyjHaJYOYBPdLV4sfn1bSAcR7TDmu2ace1Z3bZwPv08/XnpT+Nd5m++WctaUTxhBlnJKgkg+nDrUkIkaMbDzCeZ4WxB8g9Bo1abOYgS0enU0+LCpht5N4iI6KktTxEiQeP+GmdyefvDWfqfZQ6zKS2rjLr+0lVnUHP5wsW4fJYGePVVIvgfI5u32hE+At12kt8xK76pVP3M4ox34376d382eX7tKWYDCP8pnBAJivg5glRq85KyCfnb5ZMfJUSCnhzH2sgp38ab4PX+tTeVVpXSQ389RIgE9V/e32j5Mnw40RrwK+K1thKMy4mjp7Y8RQ+sfoA2xGwwW16lp/PDpExF/b+fQIgE7Qpi92DXs0PNKlObksoSenPPmxS0KIjG/jmWLmYYG0OgBcdRuSOLtx3lHkWP/c1CkHy+8aGpG6YSIkHyj+UUlap/T/HGRFLsqIkVO35FUJpdOwKqyfGNXoRI0KR1k3ROq1ZXi9r//KPz2d47AKXCp+4EkHpIyk8ip/lOOkJ3W5x5m9hVq6qoTMk6WBvXXSST6Y9nHr1mNCES9MPpmsms6ueDD5i8OOPLAtLeGcrq3HZRW0opNEOr5fn+1PeESGYNE5TEl7e/TIgEBS4MpPJqXUvAp58SuSOLVOAHlBs3zPthISnntGnioZISTYjROie2n1Betw6Ej5gyL8Y95eaKbpjwF0HHbpm3meSwlcMIkaBZ22cREVP0ZZEyQiTMjt/j+FV8g2eCEHCEZs/WfFatrhYHO3PbGsdx5DvpW8KcAPpqiDO7WfwWdA3hfPp5GrpyKDl87kBj1owx+vovXCC6gdbM/bj7oFjHN3a/obNoZOnZpfUXxnEsPmf4cBbLsGEDEcexeHqZihzeCyJEghYe/EJMBj58JnNvR9+ONuu6p6yfQogEzdw8UzwWmx0rKvwJucan/d+5k+g0WH6mmA/+oi+PfUmIBHl85UGbr22mLr90IUSCxv451qy6EhEdvJhAeMtFvLdLuzG5k/Fsw9vA6ourafSa0TRl/RSzwgUSRjOl9heHN2jOztcIkaAOP3Wg8upyyinNEb0CK86bv/gldMRhphxEKmj/0VUs3hKg8EhPKiivb4WKfuJz4sUwiVMpbJVpSmGK6CE6klRfhmWiM8wDS9fBbyXIz+yvZl0lj688dMaZz458ZlY9iYhmzyZCv69Fb9aCx5i8OeEH+ie25n5lxqPm1DR+rW7ok/tX7uJkx2j4fTBVkNNr70eLZR1PPk4cx4lei4ZMxozFFJ1GDonGZ9MmAMCq0omQ91mMIocoOFo54vtR3+ucppQr8e597wIAfjn7C7jOnUByOXxxG1sX30ZxsXE/R0R4cuuTKKwsRLhHOEYGjQQAPLn1SeSX55tc/WvXjsJGxd6n5Q1EeDjg6Fj7vF4+vQAAp9NOm/wbAwYAsCzBrxHXAQAzrtvCz9EPN/JvYPau2SaXBwDl1eX4/NjnAIDIwZFoZd8KAPDF8C/g5+iHW4W38Gv0rzrf2bsXGId/oAAHdO0KtGlj1m9j2jT2umkTkJkJALCzA7ZtAwa3isWkwuUAgB8mBgIyYGr4VNhY2LDvuLpCNnw4AGB0ArD60mqTf/5y5mXsv7kfCpkC/+v/PwBAqHsoHgx5kP3u6R9Mv6ayMuDGDQBAjJMdkNoXL72k+VgpV+Lh8IcBAH9f+9v08gF8dfwrpHV8HXBOxi7/AgBA8f4dZpUlEJMVg6Erh+LAzQMorirG9oTtGLxiMG7k36j3uwf+zkcbJAEALHt1AQD8GPUjvjn5DQDA294balLjuW3P4VDSoboLk8mARx9ljWznTmDyZEAmw5w5ANpvQbHFdbhYueLZfrOAKVMAAO+ltAbA7oupFFQUYEvsFgDAnD5zxOOh7qF4oN0DIBBWXFhhVFn5+cDLT5WjK84DAPwe7YD5x+YDABaMWIDx7cdj1YRVUMqV+Df+X5xKPWVyfYkI884/B9jkA6m9MTUpG9l9OgIA8nZvAUecyWUKfH70c8zYPAM7EnZgw9UN6PVrLxxPPm5SGZVnLgEAbO5ri1/PLQUAfDPiG1grreFm6ybK7s+PfQ4iMqueqkHvAAAcEp7BkP4zwHXuDDmAjpez8GPUj2aVuTR6KTjiMDp4NHr79QYA+Dn64bFOjwEAvo/6vq6vAwC++ALwRCba4iZrx716gSMOM7fMRHZZNsI9wjGz80wAwIcHPzTr+QPA4y/fBoa+DwCYE/Ij3vjiCACgbyowb/1LKK8uN6vcxWcWY0vsFlgqLPHdyO/QzbsbcspyMGPzDJOeVfyGi+wVoUgJWwgAmBg2Ef38+0Emk+GzoZ9BIVNgZ+JOnEk7Y1Zd7wQmK3bHjh3DwoULsWfPnlqfvaQt9e9V8vNBW7cCADbaDYBiJOv8Xwz7Aj4OPrVOnxo+Fc7WzrhVeAt7M04AYWEAgODiaCxbZtxPHkw6iINJB2GjtMHWaVuxddpWhLmHIbssG0ujl5p8CXEX9gEAsuwtUQUb9O2r/zxBaESlRZn8G336ALK+C7GlYzE4GdDhVhn2Df4dCpkCm65twsGbB00u8+9rfyOjJAP+jv54qutT4nF7S3u8P4AJj8+PfY4KVQUAoKQEOHECmAReKZk0yeTfFOnRA+jdG6iqAhYvFg/7+ABbO7wDBThskT2ITyqPAQAe6fiI7vdHj2YvCcC6mHWoUleZ9PO/nf8NADAhbAICnALE47N6zQIA/HnlT1Srq027pmvXICNCli2QnT0Eo0YqERKie8qE9hMAAP/E/QMVpzKp+HPp5/DOfjaw4fAHiEqeCw6AQ2YBEq4cMa2uPGpOjce3PI78inz08euD3TN2I8IzAukl6ZixaUa9ykLSpnMAgCK3NoCzM1IKUzB371wAwMKRC5H2ehqe7PIkAOCFbS+Y/JwAoF8/wHngGgBARNVzsLO0Ax5mCnL/y4WQccDm2M3IK88zqdytsVtRzVWjg0cHdGnVReezxzs9DoC1LWMGttmzgVbp52ABFcjTCyvzD6GgogBh7mF4tOOjrO6eEaKy8OXxL02qKwDsvr4bB5MOwkJmCWxYh81r3DH+kVUAgJCUMmw8sdzkMgHgePJxvHfgPQDAM12fwdA2Q1HNVWPyhslG39PiIoJ3NlPs0gZdQ2l1Kbq26ipOmgHgxZ4vwt7SHvG58Th867DJ9Tyffh7Xq08AagsUbv0Ihw8D8qFDAQD3JQOLzy42uc9Wqauw8uJKAMDz3Z/X+Wx2bzZh3nxtM7JLsw2WERfH5qd9cZId6NABcHLC6kurceb2GThYOmDf4/vw+0O/Y3rEdKhJjTf2vGGWcrvmxjeAshJI7oe4tU8DPj5Qd+0CAAi+kIpVl1aZXGZxZTE+PvwxAGDB/Qswu89sbHl4C2yUNjiRcgLb4rcZXdbFPy4AAHJbd8A/N9YDAN657x3x8yDXIMzoNAMAsP/mfpPreqcwSbFbsmQJJk+ejOjoaMyaNQtDhw5FXp6mo6xebbqlocWxahVk5eW4hI64POlXVMtK0M+/H57v8bze020sbEShu+LiCsh69AAAdEc0fv6ZBebUx9cnvgYAPN31aQS5BsFKaYW3+r8FgM3OTB18bsew2ddtK3cAMKjY9fTpCQCIz4032TJobVsNRb8fkWUP3AwKBQCEnk4UhZE5A4Ug0J7u+jQsFZY6nz3Z9Un4O/ojoyRDtIgdPgy4VGdiBPhJSkMUOwDMFAPg22+B1FT2/p9/4HhgC0gux3tBw6FSFMNBHYC+fv10vztqFADgvhRAXZCPPddrT5wMwRGHDVc3AIA40AoMbTMUHrYeyCvPM33wuXIFABDjCeDGcMzWY0gdEDgALtYuyC3PxYmUEyYV/96B90AgTA2fii4FH6Pk0Fe46WkPAPjzj7mm1ZVn+fnlOJd+Dk5WTtg6bStGBI3Ajkd2wN7SHidTT2LZOcOzpdxcwPpqNABA0Yf1wy+Pf4kqdRUGBg7E7N6zIZPJ8O3Ib+Fl54W43Dj8dfkvk+tYWl2CUp+dAICr66ehqgpA//6AnR0ssnMxRRWCKnUV1l1ZZ1K566+ygWdqh6m1PhsbOhY2Shsk5iXifMb5Osv55x9g1Sqgn4wf2Pv2wa/n2X17sceLUMgV4rlv9n8TMsiwJXYLbubfNKm+ggXwld6zcF/HQFRXA6u2dUa+jwsUBBz6y3RLGEccXtrBDAxPdXkKv477FVunbUV79/bIKMnAF8e+MKqcvSvS4Ip8qKDAGstdrJ69XoFMJhPPsbe0F5XcJdFLTKonwLw0ANC2ciJQ4o3ffgNrBwAGpyqRVpyGf+L+ManMnQk7kV2WDW97b4wOHq3zWbhnOHr49ICa1HVa2L/+mo07j7XjrXB9+4KIRKv1ewPeQyv7VpDJZFgwYgGsFFY4kXICB5NMm4wXVBTgl2h2D3DkfWzdIkNCAqAYxrwXQ28C35781mTL7S9nf0F2WTbaubbDCz1eAAD4O/nj1d6vAgDmHZlnVDnZ2QAuXAAAFPUnVKmr0MmrE3r49NA57+PBH+PiCxfx9n1vm1TPO4lJit3XX3+NAwcOYPXq1YiNjUXv3r3Rv39/pKSkAIDZ5ugWg0qFyoU/AQCWePVBZdt/oJQrseTBJZDLDN/qRzsx4bAtfhuqunYCAPRRnEViInCkHsPFzfyb2JW4CzLIdNwv0yKmoZV9K9wuvo1dibtMuoyixBgAwI3q1gAMK3Zutm4IcgkCAJy5bZoZemfiTqissoAST8S4MGsFDh7EG/3egAwy7L6+G7E5sUaXl1yYjP032Izp8c6P1/rcUmEp3p9vTn4Djjjs3Qs8gj+hhJpZ29q3N+kaajF1KjNFFhczC8ySJcATTwAAZHPmwO559jCLT07D/M9rtIe2bYHgYCg5NlvffG2z0T97MuUk0orT4GjliBFBI3Q+U8qVolVt49WNJl2O6hJzQ1zxBNpgGEaMqH2OUq7E2NCxACC6AY0hKi0KuxJ3QSlX4vOhn2PqFBkAGRIsmcVCfeYMLmRcMKm+HHFYcGIBAOaK97TzBMCE+idDPgEAzDs8D5WqSr3f37MH6E5nAQB2A3sgvThdVAQ/GvSROKg7Wzvj9b6vAwAWnFxgstzbHr8d1VQBRWE75MZ0wvr1AKysgMGDAQCzCphZ1BRrRX65ZjIwJXxKrc/tLe0xJmQMAODvq4YH9eJi4OWX2fvH2zHFLi3cH5ezLsNaaS1aJwTau7fHsLbDAAC/X/jd6PrGZMXgyK0jUMgUeL3v63jjDXb8l18Ay4EPAAD8LyaZPBnZlbgLlzIvwcnKCV/ezyaH9pb2WHA/axffn/4et4tv11vOpdXMWpfpEYiYokTYWthicofJtc57ttuzAJi1tKSqxOh6Vqgq8NcVNil4YxBTPjZuBIo6MsUuLEMFxwpmaTeFjddYH58WMQ1KubLW50LoxLoY/ZOG7GxAsM8MtxcU+744n3EelzIvwUphhee6Pyee7+PgI/4vKH7Gsu7KOpRVl6GDRweMaf8AiICFCwHwVsvhSTLE5cZh3419RpfJEYelvNv87f5vw0JhIX42t99cWCmscPb2WaPcpsuWAZ24CwCA/V7xAIAZHWfUOi/QORCdvDoZXce7gUmKXVZWFtrzg59cLsf8+fMxe/Zs3Hfffbhy5YrObKaxyM7OxpgxY2Bra4vQ0FDs3998zJ01Ua1cDaukeOTKnLHuMRZn92a/NxHhGVHn93r69IS/oz9KqkpwypOZ3vtangVA9bpjhQ46tM1QBLkGicetlFaYHjFd5xxjyC/Ph9XtLADArbKOcHZGLfebNr18WZydqe5YwbqGS49hUy6boeHQIbR1biMqCsKM1hhWXVwFAmFQ4CC0cdEfJ/dMt2fgaOWI2JxY7EzYiT27CU+BuTAFBcwQ6cXp2JmwEymFKYZPksuBX39lwXUnTgAvvMCClfr0QeFHb+NSxXZ23uVH8MEHTO/TYcAAAEyx+yfeeNfm+hhmqXko9CFYK61rfT6pA7NEbo3batLstyCaWeBiHB3wxmPhMNS9x4eOB8AUO2OVHOHZTo+YjiDXICHEDHvTBgMAuqUDi04vMrquALD/xn4k5CXA0coRz3R7RuezF3u8CF8HX6QVpxlUQLZvB3qAKXbo3h1fn/galepK9PPvhyGth+ic+1z352BvaY8rWVdMVj6Ewbe/82QAMixcyFvmec2519UCyCDDydSTdbc3LbbEboGKUyHCMwIdPDroPUdQ8LfGbTVYzvvvM2Nzm9aE8GI2sG93Y16ZsSFj4WLjUus7z3Rl9/r3C79DzamNqq9g4RoXOg6+jr4YOxZo1w4oKABOgQ3svVOBn878ZFR5AsL5T3Z5Eu627uLx0cGj0c+/HyrVlVhytm7rWl4eUBXNFLukdmyInBQ2CQ5WDrXO7ebdDe1c26FcVY5/4/41up67E3ejuKoYfo5+eP4BFsdcXg78dbAV0K4d5AT0TWGTgKLKIqPKrFRViha+SWH6vQ9Tw5k193DSYaQXp9f6fPlyoLIS6N2tGo5xvPLTpw9+P8/6zPj242u1gVd6vQKAKdWpRalG1RXQTASe6vIU5r7BhMvvvwO5YfcBSiVa5xMC85kV3lgOJR1CYl4iHCwdMC1ims5n7rbu4qTn57M/11mOSgWs/KkEwUgAAKyWX4EMMkzvON3oujQlJil2QUFBOHv2rM6xF154AV999RWGDRuGykr9M+GG8PLLL8PHxwc5OTn48ssvMWXKFOTnm74g4E5DWdkomc3iOr7sY4Nc+1x0adUF7w98v97vymQycTa4UnYBUCjgVJ4JX6Rh40amGxhi7ZW1AFCrEWsf2xq7FWXVZUZdR1RaFAIK2ftkVSj69GH6iiF6+7I4O1MWUJRXl2NnAnNF4dKjWHujF8jGBsjKAq5exXPd2AxwzeU1RrmRiUhUFJ/o8oTB8xytHMWyPzu0AF6xh9ARV0B2dprFDzWoVFVi1o5Z8P3WF6P/HI2A7wLw0vaXDFp9EBEBnDwJDBzIrHCzZgH792Pzje2oVFcizD0M7z3LZncvvshm6SL33QeAuWFyynKMcm1qu2EFoV2TQYGDYGdhh4ySDFzMuFhvmQJ08RoAIJ5644knDE/aRgSNgLXSGjcLbuJy1uV6yy2sKBTbreB6b9cO6NIFOEPdAQDd04E/L/+JnLIco+srCOuZnWfC3tJe5zMrpRXe7P8mAOCLY1/Uil1Sq4FTO/JYsDiA7FB/Ufn8YOAHtSatztbOovVj1UXjLWulVaXYHs8U/A8nT4G1NXDuHHD8OIAhTHm0OnMeg/1YWzDWylqXG1ZgVLtRUMgUiMmOwfW867U+j4oCfuDX2KyYlwx5RjpIqcTPYJO2iWET9ZY7vv14uNq4IrUo1agQgtKqUrG/vtjjRQCAQgG89hr7/LsTbLLY4zbwz9UtRreBG/k3RLnyUk/deG+ZTCbGmC2JXlKnXPn7b42lZp8TU1SEhQI1kclk9VrB9CH02clhk6GQy/EUHxK8fDmY1R/AqEJ3VKorjXbH7r+5H0WVRfC290Zff/1ulgCnAPT16wsCiXUQUKmAn3l9571xlyErLwecnVHRrjXWXGYxodqxywLBbsEYFDgIHHFGL865ln0Np9NOQyFT4NFOj2LQIKB7d6CiAvh5lQNbyAagTyrzXhjbBoSY8hmdZrDY1RoI7W19zPo6Laz//gt4pJ2HHIQid0dk2QND2gyBn6OfUfVoakxS7ObMmYOLF2sPDA8//DBWrVqF/nx8QGNRUlKCrVu3Yt68ebC1tcX48eMRERGBf/81fmZ0N8g+k4T4juPgXHobsS5K/DA0HZ52ntg0dZNm5WM9CIrdxqQd4DqwGffEwGhUVAB/GrDGX8u+houZF6GUK/UK3Z4+PdHGuQ1Kq0uxO3G3UfU4lXoK/oJihwDU90gFi93p1NNGW2sOJR1Cuaocfo5+aOfQBZWwQk4o/0OHD2Nku5HwsvNCTlkOdiTUv0LyZOpJJOQlwM7CTq+7RJtXe78KpVyJk+mHMMcqEgAgmzkTcHaudW61uhoT1k3AT2d+AoHERQmLzy7GzC0zDV9vx44sgO/6dTZS2tqKbpdHOj6CT+bJ8NxzzErz6KPAgQP89/ib3T2Ng6XKOHfs8eTjSC9Jh5OVE+5ve7/ec6yUVhjelllFjbmfAMAVFMGjgFkKfHuPg11tGSliZ2knuoCNcceuubwG5apydPDogH7+mljDqVOBC+gCAPAvApwKq/DHxT+Mqm9qUao4AApxNTV5ttuz8LLzwq3CW7XcnKdPA23yWXwdtWuHb2J/Q7mqHD18eugEzGsjxDNuvLbR6NV7OxN3olxVjjbObTA0rCtm8J6d774DEB4OODkBpaV4XskGd0Fhq4uCigLRXaXPDSvgYuOCQa0HAUAtZaG6GjptcqAFs9ZVhIfiUnEiLBWWtWK2BKyUVuK9MMa6svbKWhRVFiHIJUh04wLA44+zy9+Z3AFqKxs4VgFts1VYc2lNvWUCbCUkgTAiaASC3YJrfT6h/QR423sjszSzTnf02rUQVwMfd6+Av6M/hrQZYvB8QbHbmbgThRWF9dazvLpctJoKk7HHHgOUSuDMGeC2dzcAwIhCZnEUJkH1IUwCJoZNrDP0x5Ai+u+/QEoK4O4OPODEu2F798Y/CduQX5EPP0c/DGszrGZxACBayJefX26UV0BQAEcHj+bj9YC5fFjtDz8Aqp5MMR2X74lqrtqoyVN2aTY2XWOeMm13sTZ9/foi2DUYZdVl4rn6+OEHFucOAGe92fXoc8M2V0xS7GbOnIlnn30W69evr/VXUFCAF154QedYQ0lISICTkxO8vb3FY507d0ZMTEytcysrK1FUVKTzd6fJT8xFoosCHr3aIDTrFIotgcnTVPByD8ThJw4bdAnqo49fH/g4+KCosghpwV4AgBntmXX011/1L6IQOvzIoJFwtXGt9blMJsO40HEAgO0J242qx+m00xqLHQIE76BBunp3hYXcAtll2UgqSDLqN4S6jAkeg4EDmCXkkh0/wJ8+DaVcKQ4UxswAhXMmd5hcy1JTE38nfzwc/jA6pwMPVR4BBxnwyit6z31156vYmbgTNkobbH9kO27NuYV/p/8LpVyJdTHr8EOUcSlEMksyxYF3esR0yGRsZjxxIltE+9BDwNWrAIKDAQ8PWFZz6H6brYysT1kWZt0PtX8IVkorg+eNascWZ+xM3GlUnXd9z6w0qQ7AWy+Oq/d8bXdsXRCR6IZ7rttzOpawKVOAYjgiDsz33y0d+PXcr0ZNGIQUD4NbDzboirSxsMHcfmz0mH9svo6re8cOjRu2qkuE6NLTZ60TGBA4AAFOASiqLMK/8cZNNoXBd3KHycyKxC9I2bwZSEqWiwGtD2Q5QgYZTqWeqtcduy1+G1ScCuEe4WjvXnec6EOhDwGo7Y798Ufg4kXA1ZWt/cFJNrBfacv60/C2w+FopSfnEc/TXZ8GwBTGrNKsOuuw+CxbNf589+d1FBB7e+CZZwA1lLhqwyy3vdKYslBfGyivLsdvF1hYxcs9X9Z7joXCQlT6Dbl409OBMweKEQoWU3XemynwdSlKEZ4RCHMPQ5W6qk43t8Du67tRUlUCP0c/MbOAhwcwju9mm24yxS4oqUg8v77VvNXqarHv1Te5nRI+BTLIcCLlBJILk8XjP/LZVZ59FrCI5hdO9Okjukxndp6ps3BGm0lhk+Bk5YSkgiQcuHlA7zkCKk4lTqy0PSyTJwMBASzO70gVm9gMy7IFYFwbWHFhBaq5avT06VlrVbiATCYTY7ANTRpjYoCDB4HuYCvkD7mVwEphZdBi3RwxK4/dTz/9hBkzZmDu3Ln47rvvMHfuXMyYMQM///wzFi9ejMWLF+OXX4yPjzJESUkJHGskUHN0dERJSW0T6vz58+Hk5CT++fv7N/j368O5rSscqpk2f9wfGPVyKzw06V1cfvFyvQK2JnKZXIyLOOjOEth1UZ2FlRUTuOfO6Z5PRFgbwxQ7IZZOH2NDWLza9oTt9c6kiAhnb52ED58/L0Ppj5496663tdJa7ETG5DIiIh3FTlAcd+YxAYfTzKUrdPjtCdvrHCjKq8vFmachd0lNXuv9Bj7hF3AlD35Q76KJVRdX4ZfoXyCDDOsmrxOtFQ+GPIiFI1k+o3f3v2tUDNT6mPXgiEMv315iHKRCAaxZAwwaxNKuPPQQkF8gE612Q9KUuFV4q84FBBxxoqJQlwsOAEYFM8XuZOrJegcJtRo4sm4LACDO0xYRfoH1XuODIQ9CLpPjfMZ53Cq4ZfC8M7fPiEHYj3XWXcEruGOjwQb13lkWiM2JxfGUuvOPVamr8Os5lp/wpR51p1x6occLcLVxRWJeIjbEaFxR27drZuiH3EpQUlWCzl6dxf6jD7lMLs7ijVnoUF5dLqZamNKBWdYiIoDhwwGO4wdW/vk7RV/BfQHGuWMFy4MxA48w0TuafBS5ZbkAWNrFyEj2+ZdfAp6eEBW7La4sJ+PE9nWX3dGrI3r59qrXunL29llEp0fDUmGJJ7s+WevzWbNY6MeeAuYJ6JMux+WsyziXfq7WudqsvbIWeeV5CHQKxJjgMQbPe677c7CQW+B4ynG9ZW7YAHQC80qlOgI5dnWHdwCmu2OFydiUDlN0FManmW6Mb/Z3AQBYptzGQLtwqDhVndYlgHlB8ivy4WHrgQEBdc/GfRx8MCCQnSP0gatXmedALmehwTh6FACQ3amd6F6v6z7YWNiIC2vqS7G15/oepJekw93WXcyzCTCLpeCO/2w/U+w842/DCdaIyY6pM9yHiLCMX7ktLGgxhFDPAzcP6JXfP/E6/yAHJg+ifYAxIWPgZO1UZ7nNCbMUu7CwMHz77bdITk7GiRMnkJycjIULFyIsLAwHDx7EwYMHceBA3Vq7Mdjb29eyvBUVFcHevrZV5p133kFhYaH4J6zUvZPI5DLELdqKmIsXER6fj2PfpuOzYZ/pDbI1BkHYr7RgFknLS9GYNJHNUn7VzauLCxkXEJ8bD2ultSis9TEgcAAcLB2QUZKB6NvRdf5+Ql4CbLMKIAdQCUv4d/eErW399e7jxzqhMYrd1eyrSCpIgpXCCkPbDBXCyrAmkVfs4uKA/HyEe4ajp09PqDgV/rxseGXYltgtKKosQqBToOhmqg/X9bcwNh5QyYCF42rniTqXfg7PbWOm/A8GfiAu5hB4qedL6O/fH6XVpWKOs7oQ3bARurnrrK3ZQBIQACQmAo88AnB92cD+UA5zw2yONeyO1XHDBul3wwoEOAUg3COcrQa+vrfOc5cvB7xLmTJV3aFd3RfH42HnISoidVktBKE/ucNkvVbmqVOBc2AWi7HFLO+joLQZYkvsFmSUZKCVfSuMbz++znPtLe0xp/ccAEDk4UhUq6uRlsayGggWux84ptS8P/D9eheECYPErsRddeYGE84prS5FgFOATsoEIUvOsmVAWRfecn3qlCgPasZCaVNaVSquejdGsWvt3BqdvDqBI06cYL37LlBUxFIxPvUUWBT/eeaK/NM+CXKZvE4ZIyBY7eqyrggLFyZ3mKyzuEGsX2s2yTkDNqMckesMQJOnUR9EJFrgaqZjqUkr+1aiRev707UT9f71l8YNe74VcF/AfXrdujV5OIIpdnuu76lz4lReXS66wWvGxI4cCfj6Akn5TihuxfrdC7xLvi4ZCGiU/wntJ9R5/WJ9ayiigrVu/HggQH0TuHULUCqxwi4BHHEYGDgQ7VzrlgWCQrU5djMySzINnidYAB/t+GittFRPP83c8QdutkalkydkVVV43Zq5wetKVXQ0+Sjic+NhZ2GnN95cm9bOrTEocBAIVCsZfGEh8McfgC1K4V/KsjKc8wamhdddZnPDLMVu7dq1ePHFF3WOPf/88/jrL9NzOtVFcHAwCgsLkZGRIR67ePEiwsPDa51rZWUFR0dHnb+7wcCnxyG8Uyc4Wzs3uKx+/v3Qyr4VjjuXgFMqgOxsvDyOKah//sksOwJChxwTPKZORdJSYYmR7ViMUH2JGU+nnoY/r0enwB/9BxjXPATFzpgFFMJgMqTNENhZ2iEoCGjVCsiodkO5Ly84zrDVWMIMsS537IqL7LOZnWfW6S4RKSyEeyRz1XzdD/i+aJdO3Fl2aTYmrJuAClUFRgePxoeDPqxVhFwmx0+jf4IMMqyPWY+TKScN/tyN/Bs4mXoScplc7+IGDw9gyxbAxgbYtQv45QpTjjpdLxET1RpC2w1bU0DqQ3DH7kg0HGdXUAC89x4QoWKrwdx6GR83K6y6NOSOLaosEpXcmslTBaZM0VjsOqSwAPcNMRtQUFFg8Hd/PsMivp/t9qxOegNDvNr7VbjbuiM+Nx5Lo5di507AHdloDWZpPOpWigjPCKMUpTCPMPTw6QEVpxKvzRDCatjJYZN1FMZRo9jK88JCYPU1du24dQtTPAfXuzp2V+IuMWavs1fneusLaNyx/8T9gzNn2EpEAPj+e36hVHQ0oFKh1NUBSc7AgIAB8LDzqLfcaRHTYGthi2s513AytXafKKworPf5A8CrrwJRYBa71reKYaliaT8MxTFGpUUhOj0aVgorPN3t6XrrKSyi+OvKXzoKyM2bwKlTQDfeBXfOm63YNIb27u3RyasTVJyqztjYXYm7UFJVAn9Hf3HhmYBCAczknQ7C5OaBQnbfDyUdQlpRmt4y1ZxalBP1uWEFJoVNglwmx5nbZ3Ax+Qb+4L2Ss2aB+SEBUK9eWBrPFEohKXdddG7VGb19e0PFqQwq4rlluaJiq88C6ODAWwwhQ5SCjSuPljIvx9ora1FcqX87JkHpmx4x3SjDiuDd+ePSHzqTkBUrgNJSYELrC5BxHG7bA8WudmKqoP8KZil2gYGBWLlypc6xVatWNbr7097eHuPGjcNHH32E8vJy/PPPP7hy5QrGjjXsHvkvo5ArMClsEiotgBR/Zvbta3EW7dqx/FJC2CIRiYqdMPOqiweDmbl7W0Ldit2JlBNifF0K/EVrWn0Iit35jPOGV4vyCIqdUCeZjC0gBYBEVybMBcVuWsQ0WCoscTHzol6XZFpRmhi7pi93nV7eegsORbcRj2AcGMncdo9tfgyHkw4jITcBI1ePRHJhMoJdg7Fm4hqDs9/OrTqLwq6urOvLz7Fg8uFth8PbwVvvOV278qvhAMxZ1Q1qS2tYF5QgPF+BK1lXkJCbUOs7prhhBQR38q7EXQbd8vPmATkVGYgoKAUABA+aYFTZgEZhOHLriOjm0+avy3+hrLoM7d3bi9a9mrRrB6gi2Io427R09LUNRbmq3GAAfUxWDA7fOgyFTGEwYLomTtZOiBwUCQB4e//bWLc3Ab3BJiVxbkCRNdtlwqiJAjS7OtS10KNCVSGmw6i5wEEuhxhr9/VSJxCfX6hVXBr6BzDF2lBC2U2xzEU3KWyS0emmBOvbrsRdmDWnAkTAjBla+Sr55JnRrS0BmUZhrw9HK0dx8iK0e23WXF6D0upShLmH1ekuHDQIcOjYBjlwg6K6GiNKvXS2S6uJYK17OOJhvVbAmvT2640+fn1Qpa7SSam0jvei9nNku8Nc87OqczFKTYxxx2q7YfU9ryd5/WlXBusDLtduYkDAABDI4MThyK0jyC7Lhou1Cwa3HmxUXb3svcQUPu//tQ6lpWztzuDBEFdzpXQPRmJeolGL0gSEGMal55bqlTG/X/gdVeoqdG3V1WAc3KuvAhYWwI48Nq60jc9GiFsISqtLxdRO2hRUFIj39dnudbthBSZ1mAQbpQ1ic2Jx9jaz1HOcxg37Qk+NG/ah9g/B1sII11UzwizFbtmyZYiMjERISAiGDRuGkJAQfPTRR/jtN8PmcnP5+eefkZKSAjc3N8ydOxfr16+Hi0vtXEotBaEDHXZn5jlZ9Fk8w6fkEtyxZ2+fRVJBEmwtbI2aSYwKHgUZZDiXfs7grA8ADt86rLNwwthFzm2c28DD1gNV6qo6s9rnl+eL+zVqr7Dj81HiaAkTZuBXXrvauIrKgr7cU7+c/QUccRgQMEAnh59BjhwRk8c9i1+xYMK36OnTE3nleRi8cjBCfgzB+Yzz8LD1wJZpW+q1wn4y9BPYWtjiZOpJvXFQKk4luh3qi/uYPh144w2gGpY4pWZuqCfKWeyfPjdMnW7Y7duZf9fZGXj7bSaxAPQP6A97S3tklWbpjS86fhxYtAjw8N8ML6bXwblbv1rnGaKNC7MaqUmt1zosJA6tuWiiJqOmO+MG2MKjN2zZal5DiygEa9240HEmpSJ4occLGBQ4CCVVJdjvOxwDAj8DABwNYCuXhVXExjC943Qo5UpEp0cjJqv2wi6AueiEvGXCSnJtHn+cPa7ERCCN39EFZ8+K7lh9A1pZdZmoLBq0Lubns4yzf/7JckkA6O7dHb4OviitLkVU9gHY2bHYOhE+V+j6Vkw5nxBmvHIv5LRbG7NWZzcaFacS8xI+3/35Op+/TAbMniMT3bHPqZkVU1h0oU1mSaaoSBlaNKEPwWq3+OxiVKoqQcRiXi1RiaASlgrGf9C4ehdjaSModgduHtDrli+tKhWtVYYUxnbtmGIbzVvscP68uP2gkHKkJoI7cUL7CUZZrGvWd89tdv9mzQJknJrtbQxgrWemeJ6x90HYIjOpIKlW6huOOPEZ1kxHo42PD5tonAJT7GSnTontSoij02b1pdWoUFWgo2dHcTek+nC0chTbtTAh27EDSEhg+6L3smDKXvR/0A0LmKnY9ezZE9evX8eyZcvw3HPPYdmyZbh+/Tp61hdpbwYeHh7YsWMHysrKEB8fj+HDjRe4/0UGBAyAp50njnvxeZaio/HEEyyw9NQp4PJlzYxwbMhYo2YSnnae4uorQ6tjs0qzcC3nmqjYlbkFwL3+yS8AFjxsTJzd3ht7oSY1wtzDdFYMD+NX0P+T3IW94bdxATR5h1ZcXKGziKKsukwUEoKQrpOKCrbcC8ASPIfrvoPQKdwK+x/fjxmdZkAhU0AGGUYEjUDUs1EGV1Zq4+Pgg//1+x8AZvmpaa1cd2Ud0kvS4WHrYVSM0vz5LJXdMTUznTyYzdwwKy+urDX7FYR8LTfsgQMsSCklhfn2vvySKXdgbnkhJYqYR5CnsJClueA4YEQ4UxZyvZ1QZ54TPQjWnZppL86kncG59HOwVFjWa12dMkWT9mRgljesFFa4mHkRR27pbsOSVZolKs6mDOoAs46vmbgGPtbtQE7JGKBm7TalS2v8OrbumL6auNu6iwH7hqx2grVFcIHVxN5ebJ74J42Pvzt7FpM7TIZCpsDJ1JO4mn1V5zsbYjaguKoYbZzbiP1bh/h4thrlscfYw+3WDbhxAzKZDA+05dtj6Fa8/z4bTAGw+LrjbPK1rw1TArX3Hq6Pfv790NGzI8qqy8QtwwAWThGfGw93W3e9udBq8sgjwBUbpgCHXLCDhdwCR5OP1srtuODEAlSpq9Dbt7dehdkQk8ImwdfBF5mlmVgSvQQXL7Id9Dq7b4OSI+RZA4+MMW2LqCDXIHT37m5wy66NVzeitLoUQS5Btdyw2jz9NHAe/CQ3Ph5T/R6AUq7EhYwLtdpAWXWZaK2a2cW4xWMCE8MmQiFTosr1IuzaXmSpd06fBrKywDk74ROOuWSNcW8L2FrYihbs7059p/PZ31f/xo38G3Cycqq9V3YN5s4FzqIH1JADt27hCa+RUMqVOJV6SicXZ5W6StxSs74JQ00Ed+zqy6tRUlXCdr0AS/tTfoYlHU9o41BrN5//AmYpdgBgYWGBgQMH4uGHH8bAgQNhYWH8TEHCMAq5AhPbT0S04LU7exZenoSHmOEKS3/lxNm7MW5YAWF1n6E4u6O32CqooEIWn2DXwXhhDhi3gEJ7Naw2QUHMwBSt5mOEEhOZ7xnA4NaD0dOnJypUFfjq+Ffid344/QNyy3PRxrlNvQHzAIBPPgHi41Fo54238CVGjGCWAQcrB6yasAol75Yg76087J6xG62dWxt93XP7zUUr+1a4kX9DJxhbzanx6dFPAQBz+swxKgbOwoLl0LrqyBQ7uyOZcLRyxM2CmzopBAoqCjTpAjo/oSlApWLTbrUamDABWMC2UcK33/L5VPTH2RGxuJZbt4DWbQhtVewZqjuEGX0fBJ7t/qw4CGtv2/PRoY8AsDbrZutWZxnBwUBmK9YW8vcmiC5vYWNvgYUnF6JcVY6ePj0xtM1Qk+vq6+iLcZlnYHP4dfS8zQaEd97ZaZbbRXuQqLn7Qn55vhh3VXMvX21mzWJxVn8maBQ7HwcfcVKw+IyuxUqwgD7T7ZnayqJKxdpAcjLLYeLsDFy7xnJqFBej+AwrU9HhX8yeozVpOHECqKxEtrMl4tz1Jz6vC5lMhi+Gs/1YF51ehNOpp3Ez/ybe3MuSQ79737tGxUBZWwOtxjJDgeXZGHEy8MHBD0TLbVpRmpiU+oOBH5hUTwuFhfidDw9+iMVrUgGZGv27sYTyqUHu6OrTzaQyAY1M1pd7TpiEPNHliToVkEmTgCpHDySDhTa5JqSI/bami3t9zHpRuTcU3mAIN1s3eOYyS2/gw4tgbw9gK1v4dK1na5RQJbp5d0NfPwN7Shrgld6vQClXYvf13eI2jypOhQ8Osvv9Wp/X6u1jHToAgx90QAxYPL3HlRuiVfqtfW+JbWBp9FIkFybD297bqAmDNsPaDEOwazAKKgow79/lOHCA9b9XnyqBfSJLA9PxgZl1ppFqtlALpbCwkABQYWFhU1fFZA4nHSbL90GVChABRDdu0O7d7K1dxH5CJMjhcwcqry43usyLGRcJkSCbT22orKqs1ucvb3+ZEAm64uxKBNCht3eaVOf9N1i9AhYG6P1czanJ4ysPQiTowI0DtT5/4gl2fQX2PuzN8ePiZ9vithEiQYqPFXQq5RRdy75Gtp/ZEiJBKy+srL9y8fFESiURQHNabyaA6M8/Tbq8Oll+bjkhEmT5iSWdSTtDRESfHv6UEAly+cKFCitMa4NHNmQQAaSGjMZ9+iwhEjTo90Hi518c/YIQCer4c0fiOE6rIsvZvXNzI8rLY8fGj2fHxo8nIqKUwhRCJEgWKaPs0mwiInr/fXaKQkG0Zu8V+qU7a3dVb/3PrPvx2KbHCJGggb8PJJVaRTvidxAiQcp5SkrITTCqjPWPbiECKNG+M90quEUW8ywIkaANMRuIiCgmK4YsP7EkRIK2xm41q55ERMHBRMOwl90APz8i7ftpAhXVFeT6pSshEvRv3L86n/0U9ZP+56WHKVOI7FBMapmc1en2bdp7fS8hEmT3mR2lFaUREdG+6/vEeyoc0+GHHzRtITOTKDWVqFUrIoAKHnuZLGwqCO84ECJBp1NPa7736qtEAP3WhbWRlMIUk+8Fx3H00F8PESJB8o/lZPWJFSES1OvXXlRRXWF0OekXNP1g2+4LZP2pNSEStOTsEqpWV9PIVSMJkaA+y/rUe1/1oVKrqPuS7ky2vBFImDmEfurB2n7Oy0+ZXB4R0a2CWyT/WE6IBJ1PPy8eP3f7nHg/bhXcqrec558n2oJx7Bl+950oA+0/t6fcslwiYjK1/Y/tCZGgL45+YXJdExOJ4H+Cya55VpScl0TUti0RQE8/ytrG7+d/N7lcIqJZ22cRIkGtv2tN6cXpNHvnbEIkyO1LN6Pl4eHDREvxDBFAJa+8TQm5CaIc+PH0j3Qh/YI4Dvxw+gez6vnLmV8IkSDb930JlkU0bRrRuZVfEgF00xlGPau7hSk6jaTYNUM4jqOwH8PojDev2G3YQGo1UevWRJjGBOZL214yuUz/b/31DoQcx1HgwkBCJChfbkcEUP7xGJPKL64sJuU8JSESdD3veq3PT6eeJkSCHOc7UpWqqtbnq1axSz3qOJq9+eknnc8f3vAwIRKiUiIoDkYJ9IkTiQCqGDaawN/SrCyTLq9OtAcy+8/tafSa0aJwN1cw5rm0IQJojNNqspjHFJhNVzdRSmEK2X9uX7tsjiPq0oVd3Ndfa47HxLBjcjlRcjIREXX8uSMhErTm0hpx/AeIliwhmn90Ph3z5w+Yqf1ez7tOdp/ZESJB/Zb3I6f5ToRI0Cs7XjG6jBsHk4gAqoQFZadV0rv73hUV5S+PfUkhP4QQIkFj1owxa1AnYvo+QLRQ/hp785R5g7nA3N1zCZGgvsv6inWqVldT0KIgQiTou5Pf1VvG8eOsKldk4ezNv/8Sx3HUZ1kfQiTo4Q0PU0llCXX5pQshEjRr+6zahVRXE/n61u5H+/aJilIPRJHny1MIkaA3dr/BPlermXIL0IPTWf8yl+LKYuq/vL/YZ8N+DDNLScyyDSAC6LP7D9KXx74Uy3P70o0QCbL+1JquZl01u54382+S5+cBYrnnvfi2v26d2WVO2ziNEAmaumGqeGzy+smESND0jdONKiMqiigSHzK59eiTxHEcdVrciRAJem3Xa0REtOL8CkIkyGm+U/3KkkpFdPkyUVKSeGjOHCKAI5fXBxIiQR+804cIoDJbS7J9FxT6QyhVqipNvwFElFuWS20XtRXvq/D399W/jS6D44g+a/MrEUAJ/kOIiOiTw5/UKnP4H8NJpVaZVc/y6nIK+Iav59hnac/RXPp5lDsRQKeHhJpV5p1CUuzov63YEREtOrWIFvOWk+r/McH76rxrhI+YUmOOMJuzc444OGhzKeMSIRLk+o6VZpQvKjK5/IG/MwHxy5lfan320cGPCJGgyesn6/1uWhr72c/wLnvz7LM6n+eV5dGwlcPEztx9SXfKLMmsv1Lnz4uKzb9fXCGAqGtXky+tXvLL88XrF/5e2vaS2UoHN/0RIoA+wMfkPPUNsUybT21EhUnNqTVfOHmSXae1NVFurm5hQ4awzz78kIiI3tr7FiES1GXeDPFxz5vHTr3v135UYMUfvHjRrLoTaQYd4a//8v4mWWuI46hQ4UwE0N8fnKdKVSX1/rW3Tpl+3/qZpSwIfPMNu8xbtqHszcaNZpdFRHS76LZonRImT7+d+40QCXL/yp1KKkvqLYPjiHr2JPodM3WeWVRqlDihEf6c5jvp7wP//MO+6+5OVKF7zzOGP0oEUDS60o87NouTrcKKQrENFVnJyOo90Lor5is3RMwidvTWUdqVsIuq1dVmlZE7dBIRQG/JvqTE6yp6cduL4vXbf25Pm65ualAdiYgmPn6bMHAe9Z79FHEymWgpNZcL6RfEOm6+tpn+vvq3+P/lzMtGlcFxRK8GbCICKMufCSzBaodI0OObHxcnT58d+ayeCl3grQJ8vx40iIqjY8nRkf37y6bLpJynpM2h7PPve7Hf2JlgmtemJnE5cdThpw7is/r+1Pcml3H0p4tEABXCgTLSVMRxHL29921x4vzA6gcoq6Rhs/Rxc/bq9KuDgew+lPy4sEHlNjaSYkf/fcWupLKE5k5xYibhLm1Izamp/9KhrPFNG0dnzphe5pm0M6JyUFShUdwEt+HgJwYSAVRq7WJWnYXZ1MR1E2t91mNpD0Ik6Ldzvxn8flgY0WSsZ9KmV69an6vUKjp48yAduHHA+Jnk9OmsvIcfppkz2ds33zT2ikyjSlVFv5//nd7Z9w7tStjVsMJ4U9oB6wcI8irymjtCFDytv2tNcTlxuuc//zy7uMcfr13W2rXsM39/IrWa9sQfYmW96UpQVND//scGklsFtyj4FSbUOCsroqrallVTOJVyil7Z8Qr9FPUTlVaVmvz9pDaDiQD6Kvx3ImJ94vVdr1O3Jd1o+sbp+l2QJjBwIFFbJLJ7o1QSNYKsEKx27l+501fHvhKtq18e+9LoMtasIXoZ7PlXjxwtHv/9/O+iVdzhcwc6nnxcfwFjx7JrmjtX57BKRTSkQwblgSnM6oULKfSHUI1ywMdDrO7IQirMVcYalS+ZW2w9JtNLvJPiZMpJWnt5bYOUeoGcHCIrfj4b+91O9iYoqMHlvrH7DR1lQccyaiTL37/BrNYyS7EvCi5O4W/IiiF1W6tu3CBRg1MqmeUeoCpLW5qGPyk0lBlqdy19i7fmgsJeAi08ubABV6+B4ziKy4kzORxF/H61ikp5L9JXM6+Ix4sqiuhm/k2zJ84CqalElpZE6PYrWXxsSVbvgcqVvAIcG9ugshsbSbGj/75iR0S0adPnzBSvAAV93orFgnxoTXC5TtONs+jrwHGcKMh/imIuGpVaJZrMJ4TPJgKoOKiTWfXVdrdqW2fic+LF+JKM4gyD33/1VaJgxGksT9UNHFhSUljgGEBc9Dny4cP39u1rWLF3hbNn2cDu4EyWSjVBXk3TP9pGv537rbaQrKpi1hmAaO/e2mWVlxPZ2xMBlPTncerctZrwui8hEjTza427dd6hefTwJBhUrO82eU/MIQLoO9lsyjTCOGsK2dlsjHsXn7LrHTasUcotry6nzos76wy+Q1cO1Rt+YIiqKqKJPsx6VmLvqRP3dz3vOu1M2GnYSlFSotFULutah35lXi2abf0Le2NvTxt2LyREggLnKqlayQb9Xs+AlkUvM+v6G50DB9jkFoFkZUWUnt64xX/9NYlWfO4d3lswc2aDy61UVdLUDVPFNjB1w1ST2gARUXYWRwVgSlnshktExOT1r9G/0tg/x9Knhz+l4spiwwVwHNHIkeyaevdmcbe3bhE3dKhovbvS7xmilStF133slKF0If1CQy690cntOIgIoOctlpv//LOz9U5UX3mF3Yr77iNKL8qg+D++Ywd8fc2Ot71TSIodtQzFjlOrKdfTgQigUY+w4PzP/llD4APd+ZApk/jh9A+ESDYjr1RV0r9x/zJl7DMXek6+iM3aRj9oVn1VahX5fsMUho0xGrfW+/vfJ0SCRq0eVef39+whkkNFJTI2Q6Or5sfOEBHRJ5+wcgYMoIvMok82NkzPafZUVbHKArT2o6uiF+Xbb/Wcu2sX+9DT06AyrJrGXHA/Kl4lgMh2VCQhEnTfb/cRx3FUqaqkwIWB9FU//odefPHOXp8x/P47s1pisP7rbgArVrD4oiTLYHa9K1Y0WtmZJZn09Nanqf2P7enFbS9SXlmeyWX8saSMqsAW/JRcM6Gjb93Krqd1a52BqbCQNQ+A6NsFaqK+fdmEp2dPemzZGNoWzJ77kQDWTxtqCWk0CgtF96gHMul/5q3n0YtaTdSuHbsnS5cS84EDbBFSI5GYm6g35thYYtwHEAG0fPAfpn95zx52PVZWRHEaC/+u7Sr6VAh50f4LDSXKzze7rncKbu7/iABajOfpmWdM/PKVK5rn6uBA9O67ooxMSdHMgcT58AsvNB/5VwNJsaOWodgREXHPPksE0PkpA8T4DCFkSsfTUl7OYinqmdKUVZVRqwWtREuCzzc+bICfN1fT2RvQqIX4rbF/jiUitlrQ71s/QiTor8t/1fndykpmWDoONug0aOmquNoERCtX0ufM+EkPmqezNg0DB4qjzqefauTvggU1JpPCkuKX9C+o2b2b6HkfFneVBm+6f5iazsaniivM1l1ZJwamHw2yYGUtawYWGz4+Mg/OFBHONeoEesIEogE4zK7Vzo6ouA7LRxNQXU0UY8kWw/w9w4Q4sueeY9f08ss6h+fOZYdDQlg/o7g4tmJWa2CvUMro+59m1m0FagrCwogAGo1tZGPD4nEbA0HvcXQkKklM19yLBsTXNTapE2YRAbRQ8QZlZ5v4ZcFa9+qrOodH8+vTfpy0n2jMGKKICKJnnmmWSh0RsdhXgM6hC8lkTCwYRVycxpOh/ffQQ0QqFT3yiDjvZ7KF4zSLjnbsuHPXYyaSYkctR7GjTSyAlgIDmbJCRNu2aSYgOTlEtHMnkZcXO2hhQfTxx3WakdddWafjKmq7qC117ZdLa8DHo331ldnVvZp1lbmMP1bQ+fTz9N3J7wiRIO8F3nrTrNRk0iSin/FCw4PhhOWFDg5EpaXUvz/7d/Fi84u863zIVsXR9OnEcex2CLJpxgxeDldUaGJojhwRv8pxRAcPaiYBlqigApkTs9IcOkxEmgUt4mrjD0GV9sxKaLz0vINUVhJnwRTNACSZFVeqj7IyIltbor0Yxq61xkKd5kL8IJbqYYH1u8YN6hwnrmrVHpguXBAjEmjbNq3zo6KYpgcQOTk1aCXoHYUPjl3u9yEBTHdtDB56SEsH/u039k+PHo1TeCPB/bqMCKC9GEaffGLCF2Nj2fXI5SzOjufKFXZYJiNKMC7zUNOTkkIEkEqmIBuU0qBBRnhJ1WoShX63bmw2sHataKJLnT5XvA/R0fx39u7VjBnN0K0jKXbUghS7sjLNwH3wIBGxNitktvh9wlYxIFbn7zfDixSIiP648Ad1X9KdHlj9AO27cI0AohNgy90bujpQWNov5J1CJGjp2aVGfXfFCqLnsZjV44EHzK/E//4nKkW5uZpbdKv5pCWqn4MHWaVbtSLimMXqm2801+LuTvTXtC3Mfe7jSwV5ajpyhOizz4jat9c0BQsLotmziSof0bXsVVRX0IhVmkUZH37L582yt294fGNj0bkzEUDjsKXRvCP//EP0AHYwJdfCQicFRHNC/TOLhduN++mFF4z4woULmniDMjaJUqk0nqhJk/R8R6Uiunat1urZZsWPPzLLba+RBD4MpaFx7ZcuaRScq1eJWa4Aoo8+aowaNx5nzhABlAV38vLkjH9MQhjKKN3wF8FKNVl/coLmCccReXsTATTM8ggBRKtX1/MdQVG3s9MV+n/+KQrGJ7Fc17UraPqz9KQQagZIih21IMWOiJnJAZ2g3u3bifriOJXBmn326KNMmM+bpxmcjYw4//Zb9pVcCz4I59y5BlX3dtFtcv/KXVQYRqwaYfQKu8xMor44wWZoXt7mVYDjNMEz69aJfTkiwrzimozyck0QyLVr4uGjR0XvlGhlXYDXa+n2NjbMqy7KtZ38qj+tWDyO4+jQzUN0IvkE0Xffsc9HjmyCizUAb635EJHk5CTqKw1i9pgEygLvopk9u+EF3in4BTS5cCEZuPq7pZ54g0WLNO7GxnJh3nWElEUODjRujIoAMd923aSlsVXiAQFEHToQzZ8vKrBTp7Iip0whptgLaU60YtGaBWVlxPHmVh+kGh/+17Urux6tL8THayaFzcEgbxKTWNqb/cM/J4DI2ZkZ8vRSXS0mWqYva69GPzaMeUKqoKS89Xxw3alTmpujJWubE5JiRy1MsTvBFB1SKsUFBVxcPOUrWYzMpcAHNRYWlYqoe3d2/gcfGFV8164s272oETRCrEVaURp9evhT+vr41yanTRjas0hTF3MyCQv+BisroqIimjGj4Z7dJkNYwfbddzqHq6qI1v1WQuUKWyKAeuI0AcwT99BDbAVkraZfVUXkynYW0bs0eMIE9tnnn9+xyzEZftax03YCoaGhfzk5VP7RfMqFCxFApSFdmqXLRaSigs/FAGqD69SvH+veBqkRb3DpEltcDtTK9/3fQqUSvRYJ66JFt/LWujYcSUjQrBbR/uvcmeJ3XRf1uEuXiOjtt9k/jbQyutHp0IEIoFHYTm3a8DGSdXH9OommTS0f/lNPscNjxtzZ6t4Rvv+eeSZGjBQt0PffL0Yn6fLHHxqXRolu7sjTp4mUCk4TdmRlxXzxgYHs/0ceuSuXYw6SYkctTLEjIho3ThMD8scfRG3YzgRR6EEO8hLdXLIbNrBzXV2JSuvOHyZ4b7oqed+Ei3k57BqTL78kSkAQq8/+/aYXILghxowhlUoTP3v4cOPX9Y6zcCGr/JAhtT9bt465E9u0ocICrqYM049g/a0ZV6ZSaYLpjxvIj9YU8Oku8l3bEEAUHm5GFoLkZBaYxa8yJoAuWvckLq35BMkbpEcPIoAes1pHgO6mIjrk5OjEG5SUaNzxo0YZGAD/S4waJU5w3mIp18jX10DqwfJyTexgRASzVC9bJgqCIks3GohDNHEisYmyYBXf1PBkx3cE3n863/5T45T0BQvY9QwdKh7S2lWRTpy4s9W9IwgDlb09xV6pFrvyZzVzM3OcxlpZ48OCApaiECB6ZGI5ccKYKvy1bt18F5CQpNgRUQtU7BISNLF2wl+bNvTUmAwCWNoxcTavUmlmIGvX1lmskMfni74sVou6d7/jl1IfyclEf4NZj/I+MCPPhWCx/PVX2r9fo682MN9u03Djhmb2nZOj+5mw6u2dd4wvTwgQdnHR9Wse5leIOjkZYRK4i+Tmiu3dxzafAP2p+gyybh2Ls+HLSLDvQjPxO332UTO6xrrg0y9cHPk/Ali85LFjes5bs4ZdY8eOxHGaWCofn8bdPq/JENzMEydSaanG06Y39lA418dHN0tAaioVtWeKcjUUVHDfaI1Vb9SoZpe3TITfIuV65/EEsJDbOufr/fqxa/rxR/HQgw9qLvM/iUrF/K8AUVQULV2qGQZXrdI679gxdtDaWsdaWVGhcX4EBPBbaavVTOGfOpVZbZt5R5EUO2qBih0R8/0PHsysdU8+SZSdTWlpGn1v0SKtc995hx186CGDxeXlaca8a88v1Ao6aXp+ax3JBrTuT5j2xeRkdh1yOVFmppj9weT8R82JTp3YRSxZojmWmKiRbNdNyJOlrfT//rvm+Msvs2NPmHi/7wZ82prvH9pnmitp9WpN7FS/fpS18TDJwJl8y5qUZWxVJDdkiBgX5uHBtgDWgdfkuLfe5vcAZXOBQ4eapNaNj7BlnpMTUVWVOD+pNbCnp4vJuGtG2JeXE3ULK6OVeEx3gty+PduCoLly5Ah7tr6+YganWpYqAWFvRkC8JiG0VqlstuFjxiEsbuCXB8+erRH1vwi7WE6Zwg5q7fucn8+87LzBT7MK9j+GpNhRC1XsDLCYX0Rqa6uVbF5Y9mVpyU9PajN/vsZbwb3M8iXRW2/dvYrXwZ4XWZqXGOuupk2k+YGQ+vSpN6TsP4PgWomI0FgVBFOrOQsdhAfftSubtVZUaNLlNMP8TTRtGhFA2a99Ko5ZtRSbmly4oAkwe/55IpVKNOT0739Xat04CJm17e2ppKBaNEa7u2tZLlUqsaF/NPSIeI+09fb/PNqhAnxMxXvvaYwz4mAthBr06lXL/yx0GU9Povxdp5hl75dfGmdFzp2kpER0s2/84TYBLKpA7+Tkp5/YRfbtS0Ssa4fyWyG//vrdrXajs2SJzrWp1SyiRGjvL4xJFhea0MWLpFIR/f23Zh5rby8mlvhPIil2dG8pdmo10fDhrPEGBWnpcXzQLa1ZU+s7ubkay/bKlaQpoJ40KXeLwvMsALgClnThrAmLLx5+mF3Hhx/SDpbRgry86gk6b+7k52tMq5s3s1wPQsCMSX5JnuxsjVXj119Z3kLBddWc3LACwmrdBx8U13dMrL0dsYbqak2cDR9gVl3NtsoFGnWTiTtPDRdUTo4m0gAgGjGC6LenmfspT+ZCClSTQtFsunHj8uijOpNPlUqTpcTbm+j6pgsaC22NOFFh8guwjAL/OSIimNVuy1bRpXjffXqyEgmmKT4YU0hM7enJYsz+0/D57EgmE92sHMf0c4WC6HOwRTCnbQfTffcxy7bwzNu2/e9a6gQkxY7uLcWOiLVzYWYyYgQ/PgurvR5+uNb5L73EPurUiVd6hMSmzSWyVq2mMiVTPr547Er95/PfEWf1R4/S44+zt800LZFpCHn5ZDKNJaoh22jwcTs6f83VxHP6tGimunKZE9cInD5t4Hw+7xk5O4spf9av17gxm/NCWL2MHcsqzycOLy1lsWXCffgMLOziT0yjkBADMXgtASGOMDhYtFzn5xN17EgEcHRIyTQeTkveqVSks2vLxx83Ud0bypNPsgt4911KTGQ5dIEauw/l5GgyUV+/LmzYQEA9K4j/S/B5LWsujz9/vJQKLZjV+iFsFq/bxYXo/feJioqaprqNiaTY0b2n2BGx3ETCaqGHHiKqOHBcJy5F4J9/NB1+3z5irV44kJvbRLWvTW4YCwJ+2vZP41Z88nm/yMGBygqrROHXIga6igpxf09xcGtItuXqajE3FAEs1UlzXTpZWalZuRgXJ+6gNmSInnj3sjIWXQ6IweNqtWY8+PDDu177hiMo4TWCC+PimLUi2YXFYJ6ds+q/bZmuj6IiFm9So1Pn5BDNDWF75JbDih7qkkQffcRctUK+R4Dotdea7/qIehFCTAYOJCK2Jk5bWeU40iTl7dKFtm7VzP+ac6pGk/niCx13rMgvLJm3KqANbduqorVrmdG2OTogzEVS7OjeVOyIWKCsMAb26KqiahfeHs2nDdmxQ6P8zZnDf0lQiDw9m67ieuCeZysCv8CbmuDYuhBix8aO5Td519mJ7b9PaSkT3osW1V4haw4cxzbMPHSo+Y94gwaxB7p4MSUliendaMuWGucJbtuAAFGqC5YLB4dmNW8xHq0JS62RKiGBfVYjZ1mLRdDqn3xSc6y8nLh2wUxWyN+pZYh2ciLjE/s2V+Lj2cVYWYkmZ0HcASzUNqMnW/q6pcc80SM9fvx/PAylJunpmjCUS5fYsZISFkYCsPRQLRRJsaN7V7EjYuO04JH8DUwQHu4+hx54QCMIRo/W2kVo9Wqd2WCzgV/TvhfDqF07I3a5EoJPvv+eevVib5tTrl2JBiDsqMLvhSREGXh7a8WUalvr+BXEpaWaEAUj83U3P9RqzXXt2qX7mbAi5P77m6ZudxthD2iFgiUiJyJ64w12rFUruh1XRIsWsTUUzz/PREgzTk1mPBynaQNaCTkXL2YpcBxQSBVgs50OuEIAc9c3l50BGxXB0zB8OLsvr7/O/m/d+j8YZ2E8kmJH97ZiR8RWuk+cSDQBfxMBlIi2BD7Vw8sv12j/77/POkZj7a7dWJw7RwRQvsyZAK7u/QFLS0UzTvSfsQSwf43cVU2iuSPsvuLqyuIvy5g3Wgg1VKtJr7VOSP3h718rCf1/i+efZxfy/POaYxyn8TH/+muTVe2uM348u+b27TWxZwDRv/82dc3uLEK+mxqBggkJRMuHssn5dYsQmjqFazlpbvSRkKBxSwn5X4Dmm2C6kZAUO5IUO4HYs8VUrWAKz7LXY/Rvni1k4K6xbVWToxVb1RaJ1KZNHXuVC8ma/P1p1ANMgX366btaW4k7SXW1JmL81CkiYqvcBPn+ytOlxAkpW3hr3cqVLWjM37VLEy4hdALBemVp2Tiu+f8KN29qtpMR/t59t6lrdef59Vd2rfqSyAs7c/wng0jN4KefNKuH9Ci7LRFTdBo5JFo0od3tobx/KADgac9/ERqq56ToaPbavfvdq5gxWFoCnTsDAO53PoubN4FFiwycu3MnACC9ywPYuUsGhQJ45527VE+JO49SCYwZw96vWwcA6NYN+P13QCYDLJf/DFlmJiq8W+P6gCfw3nvAE0+w0//3P+DBB5um2o3GkCGAjw+QlQWsXs2OLVzIXmfMANzcmq5ud5vWrYFz54DHHwfGjWP347PPmrpWd56xY1ljj44GUlI0x7OygD172PtHH22aut1tXnoJOHsWWLAAOHkS+PDDpq5R8+IuKJpNgmSx00JIWqkvM2t6OvtMLicqLr77dauPF18kAujyyDfE2OGrV/Wcx/vl5gRuapZeZYlGYCtb+Ug+PjorYtYuK6YsMAvOE/hNx5Dz0kstaPGMsDo2IIBtqCxcpJiVXKLFc999tb0rwiqKnj2brl4SdxzJYiehi2CuOHECyM7W/Uyw1rVvD9jb3916GUPfvgCA8MLjGDkSqKwEJk0CCgq0zrl+HUhIgFquxPJbw+DiAnz+eZPUVuJOMnIk4OwM3L4NbNsmHn44YxE8kIMM+3bY6vAY5HKgVy9g0ybgxx8BeUuRcs89B/j5AcnJwFtvsWOzZwMREU1bL4m7x9Sp7PXHHwGVCqioAL77jh2bNavJqiXRvGgpIk+iLgICgC5d2Px+xw7dz86eZa/NzQ0rcN99AADZ2bP4/acy+PoC164Bw4cDqansFG7nLgDAUa4/iuGIZcvuLc/UPYOVFfD88+z9Bx8AajUQEwN88gkAoNUvkcgrUqK6Gjh9GpgwgXmuWgz29sDBg0BQEGBjw1ywX33V1LWSuJs8+STg6gokJgJ//AF8+imQmQn4+wPTpzd17SSaCZJid68wdix7/fdf3eNHjrDXXr3ubn2MpXVrwNcXUKngnXwa27YxpS06GggOBkaNAo68zeLrdmIUIiOBiRObtMYSd5I33wScnIBLl4A+fVjsWWUlMHo08MgjAFqQhU4f7doBcXFAcTGwahWLQ5W4d7C3B954g71/+mlNbOFXXwEWFk1XL4lmRUsWgRLaCIrd7t1sIASAoiLg6FH2fuTIpqlXfchkotUOR4+iSxfg1CmgXz/mhTi4qwK9Sg8AALq9OwoffdR0VZW4C7i6Ar/+yhZTnD3LQgvCw4Hffmth5rk6UCjYn8S9yf/+Bzz2mOb/d98Fpk1ruvpINDskxe5eoXt3wNsbKCkBdjHXJfbtA6qrmekrOLhp61cXgwez1927ATCjxbFjbDHU3y8fhC3KwXn74uFPOzZdHSXuHlOmAIcPA3PmsGDKkycBL6+mrpWExN3BwgJYuZLFG6Sl3RsrgiVMQlLs7hXkcs0sb8EC9rphA3sdPbpp6mQsQpqLkyfFxR8yGfPEjSn8EwAgnzj+3rHYSDCT7cKFLKeNg0NT10ZC4u4ik7HwGR+fpq6JRDNEUuzuJWbPZjE5x44BL78s5gPTMes3R/z9ga5d2eKP7ds1x0tLgc2b2ft7JX+ThISEhIREHUiK3b2Ejw9L7AgAP//MFKWHH26+K2K1GTeOva5Zozm2di1T7tq0YeY7CQkJCQmJe5xmq9jFxcXhwQcfhLu7Ozw8PDBjxgzk5+c3dbX++3z9NVsWL5MBw4YB337b1DUyjieeYO7kffuAy5dZDqcvvmCfvfSS5IaVkJCQkJBAM1bsCgsLMXXqVFy/fh1JSUmoqqrC3Llzm7pa/32USmb1KitjStJ/JUajdWuWmRhgucxmz2a5nNzcgBdeaNKqSUhISEhINBdkRERNXQlj2Lt3L15//XVcvnxZ7+eVlZWoFNJ4ACgqKoK/vz8KCwvh6Oh4t6opcSe5coW5XEtLNceWLWP5nCQkJCQkJFooRUVFcHJyMkqnabYWu5qcOHEC4eHhBj+fP38+nJycxD9/f/+7WDuJu0JEBFssERgIuLuzpJySUichISEhISHyn7DYXbhwAcOGDcORI0cMKneSxU5CQkJCQkKiJfKfsNiNGDEC1tbWev8+/fRT8bybN29i7NixWL58eZ0WOysrKzg6Our8SUhISEhISEjcSyib6of37NlT7zkZGRm4//778cEHH2D8+PEmlS8YIouKisypnoSEhISEhIREs0DQZYxxsjaZYlcfhYWFGDlyJB5//HE899xzJn+/uLgYAKRYOwkJCQkJCYkWQXFxMZycnOo8p9nG2K1cuRJPPPEE7OzsdI6XlJQY9X2O43D79m04ODhAdgdznAmxfCkpKZL7t5khPZvmifRcmi/Ss2m+SM+meXK3ngsRobi4GD4+PpDL646ia7aK3X8FUwIaJe4u0rNpnkjPpfkiPZvmi/RsmifN8bn8Z9KdSEhISEhISEhI1I2k2ElISEhISEhItBAkxa6BWFlZ4aOPPoKVlVVTV0WiBtKzaZ5Iz6X5Ij2b5ov0bJonzfG5SDF2EhISEhISEhItBMliJyEhISEhISHRQpAUOwkJCQkJCQmJFoKk2ElISEhISEhItBAkxU5CQkJCQkJCooUgKXYSEhISEhISEi0ESbFrANnZ2RgzZgxsbW0RGhqK/fv3N3WV7lk++ugjdOjQAXK5HGvXrtX57IsvvoCHhwdcXV3x5ptvGrWJskTjUFlZiSeffBJ+fn5wcnLC4MGDcfnyZfFz6dk0Lc899xy8vb3h6OiIjh07Ytu2beJn0rNpek6ePAm5XI4vvvhCPCY9l6Zl8ODBsLa2hr29Pezt7TFq1Cjxs2bzbEjCbKZMmULPPPMMlZaW0ubNm8nFxYXy8vKaulr3JKtWraI9e/ZQ79696a+//hKPb9++nQICAuj69et0+/ZtCgsLo+XLlzdhTe8tSkpKaN68eZSSkkIqlYq++eYbatu2LRFJz6Y5cO3aNaqoqCAioqioKHJycqK8vDzp2TQD1Go19e7dm3r16kXz588nIqnPNAcGDRqkM8YINKdnI1nszKSkpARbt27FvHnzYGtri/HjxyMiIgL//vtvU1ftnmTGjBm4//77YW1trXN81apVeOmll9C2bVt4e3tj7ty5WL16dRPV8t7Dzs4OH3zwAfz8/KBQKDBr1izcvHkTubm50rNpBrRv315MrCqTyVBRUYH09HTp2TQDli5dit69eyMsLEw8Jj2X5ktzejaSYmcmCQkJcHJygre3t3isc+fOiImJacJaSdTk6tWr6Nixo/i/9IyalpMnT8LLywtubm7Ss2kmvPTSS7CxsUHPnj3xwAMPoEOHDtKzaWLy8vLw3XffITIyUue49FyaB6+88go8PDxw//3349KlSwCa17ORFDszKSkpgaOjo84xR0dHlJSUNFGNJPRR8zlJz6jpKCwsxPPPP4/PPvsMgPRsmgs///wzSkpKsHfvXgwaNAiA9GyamnfffRdz5syBi4uLznHpuTQ9X331FW7evInk5GTcf//9GD16NEpKSprVs5EUOzOxt7dHUVGRzrGioiLY29s3UY0k9FHzOUnPqGmoqKjA+PHjMWbMGDz11FMApGfTnFAoFBg+fDj279+P3bt3S8+mCTl//jyioqLw7LPP1vpMei5NT69evWBvbw8bGxu8+eabsLe3R1RUVLN6NpJiZybBwcEoLCxERkaGeOzixYsIDw9vwlpJ1KRDhw46qzClZ3T3UalUmDZtGnx8fLBgwQLxuPRsmh8cx+H69evSs2lCDh8+jPj4ePj6+qJVq1ZYt24dPvvsMzz77LPSc2mGyOVMjWpWz6ZJlmy0ECZPnkzPPfcclZWV0datW6VVsU1IVVUVlZeX04ABA+iPP/6g8vJyUqvVtG3bNgoMDKQbN25Qeno6hYeHS6vI7jJPPPEEjRgxgqqqqnSOS8+maSkuLqbVq1dTcXExVVdX08aNG8na2pouXbokPZsmpLS0lNLT08W/qVOn0nvvvUf5+fnSc2li8vPzac+ePVRRUUGVlZX07bffkpeXFxUWFjarZyMpdg0gKyuLRo0aRTY2NhQcHEx79+5t6irds8ycOZMA6PwdPHiQiIg+//xzcnNzI2dnZ/rf//5HHMc1bWXvIZKSkggAWVtbk52dnfh35MgRIpKeTVNSUlJCQ4YMIScnJ3J0dKRu3brRpk2bxM+lZ9M8mDlzppjuhEh6Lk1JVlYWde/enezs7MjFxYWGDBlC0dHR4ufN5dnIiKTshhISEhISEhISLQEpxk5CQkJCQkJCooUgKXYSEhISEhISEi0ESbGTkJCQkJCQkGghSIqdhISEhISEhEQLQVLsJCQkJCQkJCRaCJJiJyEhISEhISHRQpAUOwkJCQkJCQmJFoKk2ElISEhISEhItBAkxU5CQkJCQkJCooUgKXYSEhISEhISEi0ESbGTkJCQkJCQkGghSIqdhISEhISEhEQLQVLsJCQkJCQkJCRaCJJiJyEhISEhISHRQpAUOwkJCQkJCQmJFoKk2ElISEhISEhItBAkxU5CQkJCQkJCooUgKXYSEhISEhISEi2EZq3YVVZW4sknn4Sfnx+cnJwwePBgXL58uamrJSEhISEhISHRLFE2dQXqQqVSoW3btjh16hS8vb2xaNEijB8/HtevX6/3uxzH4fbt23BwcIBMJrsLtZWQkJCQkJCQaHyICMXFxfDx8YFcXrdNTkZEdJfq1WCqqqpgbW2N7OxsuLm56XxWWVmJyspK8f+0tDR06NDhbldRQkJCQkJCQuKOkJKSAj8/vzrPadYWu5qcPHkSXl5etZQ6AJg/fz4+/vjjWsdTUlLg6Oh4N6onISEhISEhIdHoFBUVwd/fHw4ODvWe+5+x2BUWFqJ3795488038dRTT9X6vKbFTrgJhYWFkmInISEhISEh8Z+lqKgITk5ORuk0zXrxhEBFRQXGjx+PMWPG6FXqAMDKygqOjo46f01CUhLw2GPAiBFAdnbT1KEpIQLefhuYMAFYubKpa9M03LwJdO8OPPMMUF7e1LW5+xABv/0GdOgArFnT1LVpGs6dY3Jg2jQgLa2pa9M0vP02MGAAsGdPU9ekacjIAAYNAh588N6VA0uWAEOGAD//3NS1uado9hY7lUqFyZMnw87ODqtXrzZ6IYQp2m2jwXFAeDgQG8v+f/HFe69B79wJjB6t+f/aNaB9+6arz91GpQIGDgROnmT/T5gAbNrUtHW626xezZQaALCwYP2hbdumrdPdhAjo0gW4dIn9/9RTwPLlTVqlu87evWxyCwByORAdze7JvUJVFdCjByBkcZg5E1ixokmrdNdZuxaYPp29t7QEEhKAgICmrdN/mBZlsXv22WdRXl6OFStWNP/VrUePapQ6AFi6FDBiBW+LgQj45BPdY0uXNk1dmopt2zRKHQBs2QJkZjZZdZqEJUs076urgcjIJqtKk3DokEapA5iim57eZNVpEubO1bznuHvPen/ggEapA9j1Jyc3XX2aAm05UFVVe2yQuGM0a8Xu1q1bWLFiBY4cOQIXFxfY29vD3t4eR48ebeqq6UeYkT3zDDB0KKBWA9u3N2mV7ioJCUypsbTUWChWrGCd+l5BeN6zZ7MZOxHwzz9NW6e7SUoKcOwYIJMxhQZgrrjm7RhoXIQB7YUXgH79WPsX7sW9QFISU2wVCo1MXLeOycN7hc2b2avQBgBg9+6mq8/dJjGRTXDkcmDVKnZs40am5EvccZq1YhcYGAgiQnl5OUpKSsS/AQMGNHXVasNxwNat7P3jjwP338/eHzrUZFW66wjX2rcvcz24uQH5+cD5801arbsGEXNFA8CoUcwNC9xbrti//2avAwYAkycDtrbMYhkT07T1ulsQMWsNADz6KDBpEnt/7FjT1elus3cve+3dm7niXFyYxfLUqaat191CrWaWegCYOBF44AH2XpAN9wI7drDXYcNYnKmdHVBQAFy50qTVuldo1ordf4r4eKbE2NgAffoAgwez44cP3zuzFEGxGzyYzdZ792b/nz7dVDW6u1y+zALlbWxY0PTYsez40aP3jrVCUGDGjAGsrFi8IQDs29d0dbqbJCSwRVNWVkDPnhprzYkT947VUlDs7r+fWe8HDWL/R0U1XZ3uJpcuAVlZgKMjk4WjRrHj+/ax0IR7gRMn2OvgwYBSCfTvz/5vrt62Foak2DUWQlxVz54sYLx7dzZLycu7N2YpRLqKHXDvKXbHj7PXAQMAa2u2KtTGBigtZa6JewHhWQvPftgw9nr4cNPU524jDFy9ejHlrmtX9pqTw5S+lo62xVLwWnTvzl6jo5umTnebs2fZqzAWdOsGODgAxcXMAHAvICh2ffuyV8HLduRI09TnHkNS7BoLQbHr04e9Wlgw4Q7cGwItKYm5WywsNIP6vabYnTvHXnv0YK8KBdCpE3t/L7ijb98GUlNZXI0wmAuv98oez4LFUhjIBMsdoFH8WzIpKUBuLrPS1GwDgsLT0tFW7ADWHwQ5oL2opqWSksL+FArNPRD6g/bCMok7hqTYNRZC/IgwQwGAiAj2ei/EF128yF7Dw5mVCtAottevM2Hf0hGUt65dNceE9/eCYnfmDHsNDwfs7dl7oQ/cuMEsly0dYVAXJniAph8IfaQlc+ECew0LY1ZrQKPYxcczq1VLR2gDwgQPuLcUO2Ei36mTRg4I15+SAhQVNU297iEkxa4xqKwErl5l77U7c3g4exU+a8kIAkvowAALmhbyFl27dvfrdDeprtZYpbp10xy/FxU7YZYOAB4egJcXc9G19H5QVaVJd6TdD8LC2Kt2KqSWiqC8ak9uPD0BPz/WBlp6P6io0MgB7bGgY0f2ei8odkI/79xZc8zFBWjVir2/F/pBEyMpdo1BXBwLjndyAnx9NccFxe5esNjpU+wATXLiuLi7W5+7zdWrbGB3cgLatNEcFwa4e8FaI8SS1kxEK1jtWnqsaXw8S1Dt6KibiFXoAy19cgNoLHY124Cg2LT0Qf3aNTbJc3PTbQP3ksVOkPWhobrHO3Rgry19gtcMkBS7xkBQ3MLDWf4uAaEhJye3fBeEMEutqdgJnbulK3aC4ta5s24bEAb1rCygsPDu1+tuIghsod0L3CuKndAHIiJ024BgsUtObvnuaEOKXUgIe23piwcExTUsTLcNCIptairLntCSqU+xuxcmOE2MpNg1BtqKnTaurhrzc0tuzGVlmhV/96piJ1yfMIgLODgwVyTQslfGVlRodlmp2Q/uFcu1oLgKg7iAmxvg7s7et+R+UFbGYimB2vcgOJi9tvSVwYaUGkdHwNubvW/J94BIstg1AyTFrjEwpNgBmsbckl0QsbGsQ7u7a5QYAcFi1ZKvH9BYImoKMwBo1469tmTFLj6e5Wt0candBoRBvaVvr6dtsavJvRBnJ7RvV1eNIitwr1jsDCk1gEYOtOR+kJ4OlJSwlcBBQbqfSYrdXUNS7BqDuhQ7YfPzmzfvXn3uNnUpNcKxGzdadnJO4R4IA5g294K1QugDHTrouqAAjYBPSmrZiZoFpa2mKxq4NyY4Qh8Q2rs2Qr+4fv3eaAP6ZKHQD1qyYicotm3asFQ/2gjt4tYtFosqcceQFLuGUlWl6aj6BLqg2AkuipaIoLDoE+i+vixRs0rVcpVbjtPcA30CXbgvLdliZyi+DgB8fNgOBCoVS3fQEqmu1vTxugb1ltoHAE0f0De58fdnA311NRvYWyIcp1FuBUVem3tJsdPXB1q1Ym1ArW65cqCZICl2DeXGDdah7e01MRTa3AuKXV3WKpkMCAxk75OT716d7iapqUB5OUvO3Lp17c8FF0xLttgJAl3fgKZQaFYKt9R+IFgjbW2ZIlsT4fpbsmJXlxyQyzX9oKW6Y9PSWJyhUqm7Ml7gXgjJqEuxk8s18rEl94NmgKTYNRRt90NNFxRwb7hi65qpAxrFrqXO1AVhFhTEhHpN7gVXbH1tQOgHLdVaUZ8cuJcUO32We0DTBu4FOWBhUfvze8FiV1dYDnBvGDqaAZJi11DqG9AEgZ6WxlYOtjS0V0EZEuhCPqeWarGry1IBaNpAdjaz7LU0iOp2xwMtf1Cr7/oFS8Xt2y1TDgD1y8KWLgfqslYBmj6Qns4sey2R+u7BvTDBaQZIil1DqW9Qd3NjKS8A5q5pjhCxmAci07+bmwsUFLD3gquhJv8Fi11VFZCRYd536xNmTk6arXWac2wJx5nXBtLTWX42uVy/CwrQDGrNeaZeVMTagTnUJwfc3VmsKdC8+0FSEmsHppKfzyYuwH97gkdk/pZX9ckBV1cmC4DmPRaYu7ChslKjsP2XLXZ5ef/5nKOSYtdAqD73g0zW/BvzSy8xoTt2rEZJMxZhlu7nx+KL9NHcFbsLF1g6Cj8/YPNm079f36AukzXvQY3jgClT2PMLDzc9mbbQBtq0YYsk9NHcZ+oXLrCFPn5+wOrVpn/fGDkg3IPmOKgTAXPnsjqOGGG6RUloAz4+mklMTZpzHwDYHqehoYCzs3ltoD7FDtDcg+Y4wSMCJk9mCxxGjGAKjilcv85kiYODJn9rTZq7HIiLY33Yzw/YsqWpa2M2kmLXQDKPJMtzeQAAjM1JREFUMoH+9m8h2LSJ9Y2FJxdi1JpROJR0iJ3UCAI9oyQDD6x+AHN2zUF5deO58w5/PQv45Rf2z/btwPvvG/W9/Hxg/nzgs5ns+s8UheC995i8KqgowLSN0/DwxodZXRtJoG++thkDfh+AjVc3NqgcbTKK05H54BCmdKvVwGOPGSV0iICDB4EZM4DUA0ygf7AqBFu2MNm27so6TN0wFb+d/419oRHuQWxOLGbtmIXn/n0O6cXpZpdTk7+/eQbYuJHNuK9dA774wqjv5eWxU796hrWBEznBeO89FnVwPe86JqybgPf2v4eiyqJGG9AWnFiAB/98EAdvHmxQOdqkF6QibtIgln8rOxt45hm2U4gRHDjAmsztI0yxeef3EGzezNrAygsr0WdZHxy4eYCd3AiDWn55PqZsmIJH/n6kUeXA2a/mAN98w/7Zvx94/XWjvpeXx+TAJ4+xNhBdHIx332VtILMkE7N2zMLk9ZNRUFHQaHJgfcx6TFo/Cb+f/71B5WgTlx2LtOljmIJKBMyaxdzmRnDgAPDoo0DaQSYH3l8VyrcBwoITC/Dk1iex5tIadrK/P3ttQD9IzEvEpPWTNH2rkdjw7bPApk2s8e7dCyxYYNT3hLHg3Uns+q9yoXj/AxlSU4G0ojQ8sPoBzN0zF2XVZY2m2P12/jf0Xd5XM8Y2AvnF2UgZ1pM16pISYOpU1pDrgQg4ebLRqtE4UAulsLCQAFBhYeEd+42yrGIi9lzJBbkEEEU8eIgQCUIkSBYpo9Opp4lefZWd9/bbZv2OSq2iISuGiOU++OeDjVL/bXHb6HAAq/8FL/ZKDg5ExcV1fm/jRiIXF3b6J3iPCKCf8QIBRDZ21eT/SXexrtM3TidKTmYnW1gQqdVm1XVjzEaxTJtPbSgmK8ascrThOI5mvBVMBFC5ApTm58Tq+eGHdX4vJ4dowgR2qhXKSQ0ZEUCeyCCAKOyhf8S6KucpKT4nnui559gXIiPNrmvvX3uL5c7YNMOscmqy/8Z+2t+aPft8K74NWFmxi6yDDRuI3NzY6V/if0QAfYdXCSCytuEo+LPBYl0nrJ3AyuP7CpWXm1XXQzd1+1ZUapRZ5WijUqvozdc7EQFUbAHKcrVmdZw3r87v5eYSjR/PTrVGmXhtbsgmgKjDQ9vFuio+VtCplFMaOfDmm2bVtVpdTT2W9hDLnbZxmlnl1GRjzEba05bV/7w3a8tkZ0dUUlLn9zZs0MiBSHxIBNASPCu2Ad9POol1fXrr00QpKexkpZJIpTKrrltjt4plWsyzYH2rgXAcR0+9FUYEkBqgfBcbo56TdhuwQanYBtyRRQBR+Ni9Yl0RCSazXniBnffBB2bXdfAKTd+auG6iWeXU5NDNQ3TKl9U/10ZrLMjLq/N7GzYQubqy09/CfCKAVuMRfixQUchnNcat3FyNHCgrM6uuO+J3iGXKP5azvtVAqtXV9PwboUQAFVqC0r3sWB0//bTO7+XkEI0bx07dvbvB1agTU3QayWLXAKxcbJF8JAkXFuzD82+7ws4OuOI7R/ycQFh8drFmlmbmTHVHwg4cTNJYKLbFb8P1vIYHoX+38yP04yeO46cBGa3smRtu3TqD3/nqK2atz89nXrtHurOZeq9HgtG/P1DueRgp6mjx/L+u/IUYRR5LeVFdbXYc249nfhTfl6vK8d6B98wqR5ujyUfR4xCztGzsAMztxcdVrF1rMNYsORno3595bJVK4L2piZCDoLJ1xFNvecLeHrjmvFA8X8Wp8O6BdxtsrTh86zBOp50W///z8p+IzWlYslsiwqJNb2FoEqCWAZ1eBFIDnJnlbscOg9/76ivmuc3NZW1gamfWBvo+Hox+/YAK/+1IqD4knr8ldguS5EUaV31qqln1nbN7jqbuQt9qINsTtqPVCbYx+58dgVeH8Asbliwx2AZSU4E+fZinxsICeHcq64vV9s545k032NkBVz0jxfPVpMb3Ud83OO3PwZsHcfb2WfH/tVfW4mp2w7P4rzjwDYbwBpQpkwkZnnYsZrIOV5TQBvLz2UYbj/ZkbaD7tBDWBjyPIE2t2fB++fnluCDLZHJApWJxmWaw6PQi8X01V4139r9jVjnaHLl1BH33sC0fV3YBXhjOt4HNmw22gZQUoG9fdouUSuC9KUyOVDu44uk33WFnT4jxiNT5zlfHv2qwxW5Hwg4dK9WW2C24md9wt+bHG2ehN2+cCn8JSAtwZmNBHaEpX37J2kBeHpMDT/ZjFruIiaHo1w8o99uG+GrdcesmCjSxpmbKgQ8OfiC+54jTGRvM5cDNAwg+weq/OQx4sy+/p/Py5QZjTlNSgH79gH/+YREozcm7Lil2DUCulCNgQCC6vDEM8+cDu04lAd4XAE4Ox+1bATC3Qbm3B/uCmQJ9axwr65Ver+D+tvcDYAN7Q0gtSoXLsWgoCSgK8keSC7AkopJ9+O+/er/z44/AW2+x96+/Dpw/D7RVM4HWfXoIjh4Fej+zlp1w9jm0VY0BAGxO/JfFLABmxdndKriFQ0mHIIMM/0z7BwCwO3F3g11Ry84tw3heN7o1qi/+DQWqLZUsXkrYzFyLnBwWehIXx+RzVBTwwcNsQFOGh2L+FzJsOnINaHMQ4ORw2s7u49bYrahoYBv4+czPAIAXur+AsSFjwRHXYFdUXG4crE4xRaE4rC1SnIFVrXnXjgltoHUVr9w/GoJjx4Buj/Nt4OQcBKruB4GwJHppgwa1pIIkXMi4AIVMga3TWH9YF7Ouwa6orbFbcT8/R8rs1xGbwoBqKwvmghH2ftUiNxcYOpR57AIDWViW0AYsOoTgiy9l2HM6BfA9A5AMTjvZwPhP3D+o9OHjjsxsA+tj1gMAnu/+PEYHjwbAwhMaQlJBElz3n4SSgMLQ1kh0A5YLcmDtWr3fqdkGzp0D2qkFxS4YR48C3Z9dzk6IfgbtVOMBAFsTtmnkgBn3IDYnFgduHoBcJse/01n7/Df+X5RWlZpcljY/nfkJg3ixlDyyN3YEEVQWCvaQ9Wx/lZMDDB/OxERAAHDmDPDeFL4NhLM2sPlILBBwHFBZwmHHJgDAmstrUNrKlf8h89rAn1eY3J/dezbub3s/OOKwJHqJWWUJ3Mi/Abco1tYLQwKR4QCsDCphH+7erfc7P/wAvP02e//GG0xchhJTjDpPDcWxY0DPx1g/xanZCFANBwCsvrymQZPclMIURKdHQwYZtjy8BQBTbhs6Fqy/sg7j+BDJ1EFdsLEDUGljyVzGly7VOj83Fxg2TNMGTp8Gnn66QVVoVCTFrhG5XL4TAGCX3w9FZ8bCsigEZdVlOC7jBzIzGjJHHP6NZ0JsXOg4zOg0AwCzhDWEzdc24wE+T6bD+KkIcArA9tb8ll+HDtXa9ufQIWD2bPb+449ZOI6FknSCxlVcNeIVf7P/r0zDje0T2G/Fbm7QAgphQBvSZggeDHkQfo5+KFeV61gxTUXNqXHi7GYEFgIkk8F/7KMosQJOdOADv/fs0T1fDUybplHqjh8HunaFJmCaXzgRU8kEoUP2/Sg8MwYWpYGo5qpxwZIPRDazDQhxWo91fgxTw6cCAA4kHTC5LG0O3DyA+/jqOA8bg1C3UGwJ4Wenu3fXWiG6b5+eNiBXa1KYhISAwCHNah/7P+4h3NrMpN2OxB0NEug7E1jf6uvfF2NDxiLULRRl1WXYnah/4DEGjjicPbsVEdmsDYRMfgFVSuBUW34ByN69Ouer1SzsJiGBXcqRI3wbqJHqJLpkCwDALq8/Ck8/BIvSAJRUleBEA+RAtboam2KZgvBw+MOY2H4iAIjHzGVDzAaxDTiOfxh+jn74ux2/KvLIkVpy4MgR4NVX2XsdOaCV6oSgRrx8C/v//FNI3P4gAL4NNMBqKbSB+9vejzHBYxDoFIgqdRWO3DpiclkCHHG4cHkvgvnu2X7MEyi2Bk6F8nLgn390zlepmBwQBvRjx4AuXVArf1t8NeubDnkDURw1AZbFwVBxKly0yGfnmTG54YjDvhusb41vPx5Pd2V9a1fiLpPL0mZ34m7RYus4chxC3ELwb1u+DezdW2uV7L59wJw57P28eSwUT6mEzuIRAodbVtvZ/3FjkfzP4wCAtTFrGyQHtsRuAQD0D+iPcaHjEODE+taOBMMehvqoVlfjzKm/EZwHcEoF/CY9hXJL4EyQNTvhgK6c5Tjg4Yc1ckBsA80ISbFrRHYkssb1ygOj4eMjQ9W1EQCAI5TETkhLM3kp+dnbZ5FVmgVHK0cMDByIsSFjAQDXcq4htyy3QXXtzntDZAMGYGL7iYj2AcrsLNlS73PnxHMLC4HHH2cNeuZM4APBEn77Nls9x+8scCHjAvIr8uFi7YKPnhgIxI0DODnOpZ9DWQMsVsdSjgEAxgSPgUwmw4PBbKD4N06/VckYrmRdQWgSPysNC8OwTuMBAFu8CtixI7qDxRdfsJhyOztg506N8ammQD+afBQAMGvsYHh7y1Ady9rAvmr+vORkk1OKxGTFILc8F7YWtujh0wNDWg8BAJxLP4f88nyTytJm/8394qCO++7DoMBBOOMDlDjZsJQP0RqXen4+WyTAccATT2i1geRkpgBaWgL+/riceRmZpZmws7DD+0/0BZIGAwAuZ15Gpa/5Fiuhb41qNwoymQzD2zILwImUE2ZcOeNM2hmExLE+RF27YHjPhwEAm/15C1ANxW7RIibj7eyAbds041PNVdHbE9iA9saY8awNXGYTnD3VvHn49m2T900+n3EeeeV5cLVxxcDAgRgXOg4yyHAu/VyDFtIcTT6KboIc6NkTDwY/iIuteDlQVKRjuS4sZG2AiMkDsQ1kZjK3nVwOtG2Ly1mXUVxVDEcrR3z0TC8g8QEA7H5X+Hiy75jRBoS+NaT1EMhkMowIYn1rz/U9dX2tTmKyYhCaWAAAoLD2uK8zk68b/HlLcA058PXXGjmwfbseOcC3AWHS9dLoIfD2BqriBwMADnH8JMiM9FKXMy8jqzQLtha26OvXF4NaDwIAXMq8xBanmMnOxJ0YnMTey4YOxbA2wxDlC5TZW7GOf+aMeG5+PhsDBDkgrrXLzdWsog0O1hm33n98AJDALMxXs6+iwseLnWdGG9iWsA0AMD50PGQyGcaHjgeABk3yz6WfQ5ubLAxHFtERo7tPYxZBb74NHNQte9Ei1gZsbVnEitgGmhGSYtdIcMThcNJhAMCUriPxxx8AUvoBADakX2TBOGq1ybElwsA1KHAQLBWWcLFxQXt3tm2TdsyVKRARzt86jTA+7RS6dEE//37g5EBUOxt2bP9+8fzZs5kcCgpibhgxsX6NNBdCfXr79caHHygwrK8HkB0OAEhx5puaiRY7IsLJFLbkqK9fXwDAyHYjAQDHU46bVJY2x1OOoycfUyLr0QO+jr7o6NkRRwKFE46L1oq4ODYzBYDFi1k8iYj2LJUIR2+xwWdM+AD89ReAG8x1virjNLtxFRXMl2MCh2+xdtXfvz8sFZbwdfRFqFsoOOLMtlZwxCEq9gA6Z/IH+vfHoNaDQHLgbGveYnVCozS98QYLjwwNBX7+WasNCANau3aAQiFaFAa1HoSPP7DCgG5eQG4wCIQkB94aaKJA1+5bD7RjSkJ///4AGtYGTqScQCf++uXdusPN1g0hbiHYy6fcw5Ej4kTs2jXg3XfZ4W+/BTp21CpIy2pNRDhzmw2EYzsOwpo1AFJYu92cfokpwBxn9IpLgai0KABAb9/eUMgV8LDzQAcPti+v8HumQkQ4l3QSHYU20L07RgSNACcHzrTlN3A/dEg8/+WX2aNr27aGHBCuv3VrwMpKlFl9/Prgww8UGN7bF8jsCALhpgNvATSxDRARjiWzCd6AwAEAICp2+27uM6ksbQ7fOow+fKiXrE9fsW8d9eeVrpMnRTkQG8uslADrAxERWgVpKXYcceKq7fGdh2L5cogTnD8zzpktB8S+FTgIVkortLJvhXau7UAgsyc4HHE4FX8A7YWq9O2L/v79wcmB08F8TKyWHHjtNdZ0g4OBn37SagOCHPT3B+zsxGc1uPVgfPyhJQb1cgNymNJ7y5G/t2a0AaEfDGnDJrd9/VnfMncsBFjf6sqHfsu6doWHnQfCPMJwQEjJefiwKAdiYoB3+LDOb7+tMRY0IyTFrpG4nncdxVXFsFZao5NXJwwbBjwykCl2scUXoPbxZSeaaIKPTmdWkx4+PcRjffz6AICo8JjKzYKbaJWcD0sOIGdnICAAvXx7AQC2efM5zPj129u3AytXssn4ypU1UlTVyN0lKna+vSGXA0uXAopMVu89ubwVxMTOfCP/BrLLsmGpsEQ3724ANPfiavZVs2MrjqccR09hbO3ZEwC7rxe9gApb3mp5+TI4DnjuOWaUGj2apTfRQUugx+XGIbssG9ZKa/Tw6YFBg4Cnhg5kp1VeA+dl3kxVUN4Gtx4sHhPeC1YMU4nNiYV3SgEUBJCXF+Dri0GBzAKw05OfqfICffdu4PffmRD/7TfAxkaroBqWCkHJGBAwAHI5O1+RxgbibenmuaES8xJ1+hYA9PNnfet8xnmWRsEMotOjNUoNr6n19euLGA+g3M6KWaP5NvDEE2xNyciRwLPP1ihIyw15I/8G8srzYKmwRCevThgyBHhkUG8AQFzJJah9zYsxE/qW0E8BoKcva7dn0sxT7G7k34BnUg6TAy4uQGCg2Le2efPW7MNMod6xA1izhsmB1as1OdcB1JIDgrLdz6+fRg5ksHuwP5/vryZef3xuvE7fAoD7Au4DwKxu5sbZHbl1RJzgoQ+Tq4NbD8YlL6DCxoLJgZgYcBx77pWVwKhRzHKpW0FNP7iWfQ35Ffmws7BDD58eGDUKeLQ/61sxZReh9jTPahl1myk1AwMHiscGBLC+JUwoTSUhNwH+t0shB0Du7oCXF/oHsEnTXjd+MVkU+11hLJDJmDzQSVtaI4efMG719OkJuRxYtgxQpDMlbFsGX66JcuBG/g0UVBTAUmGJCE+mVff2Ze3qYsZFVKjM29El6nYUughr+nifak+fnrjYipcDxcXApUvgOODJJ1kbGD2ajQvNFUmxayTOpTPXZSevTlDK2X6hP38eAEWpDyBXIYGc2IkmdmZhFZyOYufLBNCptFNm1fVM2hnRUiPr3BmQyRDgFABPO0+c9OGtKlFRqK4iMZ3Va6+x1aA61NhC6HSqRrED2Mz+oZ6s3jsL+R800WJ3MpUpmN28u8FKyawIvg6+8LTzhJrUuJRZO7DVqHJTTqKrYDzt0UP8DbUCuBLEj1rHjmHFCma4sbWtYakCmPshl3eHBweLs8mePj3Fun77iRfkpd6AjJAk5wOnTRRoQtvSHtSF9nAx86JJZQlcyLiADrzFVsZPO30dfeHv6I/jfvyM+sQJVFUSXn6Z/fvqq2wVmA412sCFjAsAgK6tugJghrypfVnD2V3Kj6Am9oHz6ecB6PatAKcA+Dj4QMWpdFaKmkJ0erRosUMnpjD29esLkgMxbfiVe6dOYfVqNrY5OrIBSqcNFBUxVyQguqAAoLNXZ1gqmOXz588DIS/3BOQqxHHO7FxTB3Uti51ATx9esTPTYncq9ZQmHKNbN0Amg5+jHzxsPTQWq9Ona8mBvn1rFFSjDQjWI0H5btMGGNeTTcp2FfCNzsTrP5XKZF1Pn57ifW1l3wqt7FuBQLicddmk8gSi06MRJlireOW+u3d3qBXA1bYaOfDbbyyWyt6eWe1ryQHBDdmundgHurTqIrbXX772haLUD5BzuKU0Tw7U7FuARrk112J1PuM8IviUjTLeBBnoFAgfBx+c0hoLqqo08bV6x4Kait1tpth19+4OgMmBiT1Zw9lRyJtITWwDQjvv0qqL2AZaO7eGh60HqrlqUU6YSlRabcWul28vcHLgWhveknHmDNasYV5pBwc9cqCZISl2jYQw+HZr1U085uQkQ/dWbDCOLuc3hTahMRdXFiMuh3UYoYMAzNUJMAWNzNgC6sztM+gsNOTOnQEAMpkMvX1743wrgFPIgYwMrP4yDfHxgIcH8OGHegrSmqnnl+cjIY8JeG0FZO4jbPC5EcDHlpio2IlKjY+mTJlMJt4PYWZoCqVVpcjJuAkf3iiBsDAAGoF5yItZFVQnz4gxJPPmaeK+RWq4HwQls7NXZ/EUJyegs1cXdi0VvHvLhDZQUlWC6/nXa5UrvL+YcdGsNnAx46JmQOvQQTzeyasTon0AtVIBZGTgr/lJuH6dJZL/9FM9BWm1gZKqEsTnsv+7tOoinvLaNPb+pq+w9NC0OEN9fUsmk4mKjTDgmUJxZTHS0mLRtoA/wA/qQt/a78ksQKpjp/Aen1nnvfc0izpFBKXGywtwdBQHH6FuAJMD3TxZ+z1brmAHTWgD+eX54n3Vsdjxv3H29lmz2sDZ22fFQV0Y0GQyGXr49MCFVoBaIQeysrBmfjLi4pgcEOPqtNGyVpVUlSCpIAkARAs7ALzxCHt/05/ffcfEQV1Q3LTblfb/5gzqxZXFyMq4ASGcTlBKOrdifeuAN7MAqY6fFuWfXjkgXL+/P2BrK062tPurvT3Q0ZNNHi4IcsAExa6kqgQJuaytad8D4TcuZ102qw2cSz+naQO8Yie0gWgftqgISUn4Y0EWrl9nzVxwR+ugpdgVVxaL7bW7j2bcemsG61s3A/k+Y6IcEI0c3hojh0wmE/usMPkxhfzyfGSnxCNQ2EGMHw+FvnXIg3kDVCfPiC7Y994DvL1N/qm7iqTYNRLnMtjgo92QAWBEFzZgJDnxiyZMEGgXMi6AQPBz9IOXvZd4PMw9DAqZAoWVhUgrrj8zdk20Z2mCpQJgymO5JZAS4AwAOPQV6ygff8ysFbXQdj/ksDxQ/o7+cLN1E0/p5tMJSpkFUoRFCUVFJu3DJ+RqE+KJtOsKaGaGphCfG48QYd2Jl5e4f2Mnr05QyBQ44Mk6c+HeKKSns9ChV17RV5CuG1IYfAR3ocDIzl0AALecTW8DV7JYGgJve2942HmIxyM8IyCXyZFdlo2MEtNzA17I1Fjsaip2FRZAchtmVTj6LVNUIiMN7BSldQ8uZ14GgeBt763TXiO8wiCHHKlCGygtZVHYRiL0LW1FAQA6erK+JdwjUzifcR7hQh/w8WF7OkPTtw56s5QfhbtPIjWVLZQQVoPqUMMNKSih2hZ2ABjdlbXXJGd+0YQJbUBoV4FOgTp9q5NXJ1jILZBbnovkQjPSh+TGavqB1jZY3b27o9ICSGntAgA4/DWTA598otnqVAeteyAM6O627rXkgBwKpHjxzz0/36St64R7IDxzAWEyZo5yfyXriub6PT3ZXq7Q9C1hUM/fd1aUAy+9pKegGnJAVOxaddY5bWQXJhduOZoeZ3gp85LevtXBowPkMjlyynKQWZpZRwn60RkLtIIGIzwiUGQNpPuxB37gSyYHPv7YgBzQUuzOZ5wXxy1PO09NmV5hkEOBNA/+uZeXazweRqAvLAnQTPjMsdpezrqsiS/099cZCyzkFjjiySb5ubuikJbGlHrBctmckRS7RkKfmRwAOnqxzpLsxaaFxVdNH9S1Z34AYKW0QohbiM45phCbE4t2wjaAWvubhnsyl9x5P2ZVaF9yBmFhemKKABZQrJXmQrAshrrr7pNopbRCe49QlFkC2QpeOzTBaheXq7/crt7sPl/KMt0VG5cbh1A9A5qNhQ3au7fHGT4c0i07Fo4oxCefGNgCtYb74XImP/h46Q4+3fi6JvOKjSlt4GIGGyRqKos2FjZiGzDHHXsx46JGseMtltq/c86XiYaQ4rMICTGQo6myUvMsQ0JwPoNZTYRno13XYLdgVFgAWXJeMzDBWiFYY2qWK8TZmNMHrmRd0Qh0LcXWSmmFYLdgRAltIDcBrsjF/PmAtbWegmoM6sIER6ibpq6sbyV7sklNyTXj24CQhFjon9p1FfqFOYmK43LiECz0Ay05IFiEov1YG+hQGoWICANtwJAccNPtrzYWNujgGYZiayBfzru5TVFuDfQt0WKXYbrF7lLmJU0b0OoDtha2CHELwVkf9r9b1jXYoQTz5rFtVGtRU7HLqG2xY3Vl/yfzMaxFV43vA+L4oqdvtXNtJ16PKRARzqdrTXC0VgII9/mCP/M0hRZFoX17A21ApQIS+dxZoaHis6o5FloprRDiHowqJZCuMD2f37Xsazp1ExD6RUx2jNFlCcRkxWjGQq19noUxVpAD7pkxsEUpvvzSgBxoZkiKXSOQW5aLnDImIYQVqwKCgE8LYMEseeeNb8iCUlOzTECrMWeZ1piLKouQnX9bY3pu1078TLCK7XNjgqcXovDRR3yOoprcusVSNlhZAf7+GgWshkDXLjfFmsWsJB83TqBVqipFt07NcoV7EpcTZ7ILIi4nTq+lAmDPK8cOuO3MBM+U1mcxfbqBgrRSneSU5SC9hD3jcA/dAViYuaf6sRl1ZpRpM3WgtmIH6LpjTSGzJBOFBZloU8AfqGGxA4B9Lsyy0hNnMH++gTZw44Zm028vL1HB6uRZu66CME62YW0g7aRx9yCnLAe55exhhbmH6XymrdiZ0wb0CXSh3HxbIMWNWUgfaXsa06YZKEgrvqywolC0ntaciAh9IC2AfZ53wfg2IPTxmu1Ku1xTFbsKVQXScm5q2oDWPRD61j53ZlnpiTP4+OM65EBlJZMDAQGihV2vzOLrn2zNJnjJx4y7B7lluYb7Ft8HrmRdAUf6dwgwxKXMS5rMAO1169vZqzMyHYAsByfIQZjc9jweecRAQVqKXWZJJjJLMyGXyWspIELfSvNjbSDzjOmKbU1lUbtc4RxjySnLQWlRLgIEV7TWPRD6ltAGeiHKsBxISmJjgY2NzlhQZxuwYWY/Y+VAQUWBaJEUJrQC2n3AVDlwNfuqmMOwphzo4NEB6Y5AtoMTFOAwNegcpk41qfgmQ1LsGgGhIfs7+sPO0k7ns2DXYFjILXDThZl07QtSxMmNseXqU5aEDmLqLCUuJw6tCwAFga0IaNVKp65KuRJHWjE3VE/ZWUyaYEBYCtaqdu0Aubxuxc6ddbwcT2YJPLDSOMUuMS8RHHFwsHRAK/tWOp8FuQRBLpOjuKrYZFdkXG4cQoWZeoiukBDqf8zeGQDw+n1RUCgMFaRJTiwI1TbObeBg5aBzWluXtlDKlbjlzBL+2uYmi2NBfRhy7wIat5RgJTKW2JxYBOUBcgLg7MyCp3hC3EJgpbDCcS9W157yaEx4yEAb0HZDymSiG06fQBfqmu3FRM7BlcYJdMECpK9vhbiFwEJugeKqYqQUmRaIHpcbhyBBoAcF6Xwm9K0DfBt4qetJyA1JSq17IPQBb3tvOFrpxi4Eu7G+JcgBp8Jk0dBVH1dzmNJWMxwB0PQtUxW7xLxEUQ6QnZ1O0FA713aQy+Q44sVizHrJz2L8WLX+goSdGUJDAYWiTjkgHMv2ZFag/SuMawNCH2jr0tZg3ypXlSOtyLSwFB03XHv9E/ITDszC/MbAM4blgJ6QlDbObWBrYatzWohbCCwVlkhyYfLVOjsFN24YV9f4vPr7lqmuyLjcOLQRIiIcHcVwBKGuFnILHOXbQF9FFB4aZ0BpEuRgcHC9Y4FwX3N4OXB4lWlywMfBp1bfCnELgVKuRFFlEVKLTNumLCZby2KnZeQANP3tuIMzAOC1/lHNesGENpJi1wgYckMCgIXCAu3d2yOFb4tuyMOiz0pqnWdquWYrdrlxug1Zq6VaKCwQ4hqCqx5AmcwKjlQE5Q0DGkgM/7u8+b6uugodJNeXCbT0qBSjvLHablhZjR5lpbRCG+c2OucZiyFXrPBbAHDKmwmxsGIDAblqtY77QRDoNd1lAKCUKxHkEoRk3gvZChlY+GVVrfP0UZeyJMxchXOMJT43XmOpCQrSaQNKuRJBzsFiG7DniiFLTDBQkK4LSqhHzRk1oBHo2b5soEg/nWxUGxDKrKtvAaZbK+Jy4xAkDGoGFLsTfiwern2BgdXnRCy5GQCEhtbZBywVlgh2DUYK3wacUITvPzUu1rQui12YB7NiCsqfsWhbrWW8Yi5gpbRCgGNrxLoDxTIb2HKlkMcZmDxc44/zrkxDoROApl3k8fc1/bRxckB0Reu5fguFBdq6tAVgej+Iy41DW6EN1BjUhbqe4eeTERUGVl5znI7Vtq72qpQrddqAD27jq8+NS1hvTN8yVbmPz43X9IG2bXXagKXCEsEuobjkBVTKlHBW50F204AWWmP3HWPGrWx/JgcyooyTA3Upi0LfAky/B1ezr2rCEfRY7ADgtA8bCzqWm744o6mQFLtGQOx0rrU7HcAaSLE1UGbLnPOHV6fUu/9xeXW56IasyxVrqvlZJ76uhjADABd1B6gVwHlHPsAkykBjFmbqHTpAxamQmMeUHH2CRxh8Yu0LAAB+lIwFC+qvq6F4HQFBcAjnGQMRIS47VmOtqXEPAuxY/aN4iSc7Y+D6k5N1XFCiQK+jrtl2QLWFEnIQDqxKqzdHbVFlkeh+EASXNg1R7MQBrU2bWp8rCkJZ2hdn3oqjlXletyCNYldWXSZazfS1AaENx9ozZcaPkvHll/XXtS6BDmi1Ld4FaAzl1eW4VXBL0w9qKHZt7FnfOhXK7r0s6nStrbUAsDjB4mKWfDw4WOOGdKvdXwHWZ8ssgRJ7Zsk5ujoZafUYmXLLcsU2IFyrNua6oeJytcIRQmo/L+uSUHBy4JILn1bfCDnAEVdnPxD6a7wDc+/5Ugq++ab+utbbt/jjpvSDgooCZJVmIUDQrWssdfW35RU7ftm0LNqAYpeayhYBKJVA69b1jgWh7qHItANUCgUU4LBvZVq9Y0FpValoidLXt4Trj8s1LSwlLkdLsa3RBwBAWRCGKiVwxamesUCY5HfogPLqcnEhj15PEz9uXbNjP+xHyfj66/rrWpeLX7tcUwwduWW5yCzJNBiS0cae9a2odqyjGBwLmiGSYtcI1DVLBbRmqp5MoHurkvHdd3WXmZiXCALB2doZHrYetT4X3CUlVSVi/ImxdTXUkAEg7QJrzImhvNurvs4cHo6kgiRUc9WwVlojwCmg1qnBrsFQyBRIsGUWO3+kYNkyICur1qm16grUL9BNsdilFadBWVwGR8FgVkOgn9rOntX5tgUghYKlWdc3+mq7HxSKOmfUAC/oZUCBB7uvrarrbwNCegMvOy84WddejigETeeW55q0vVx8XrzGBdO2rc5nVVXAjTPsviaH88vfzhoY1IQ20L69qNi72rjqrIYUEFznCfaaNvD77/Un3xeeraH7KihRprSBhLwEOJcRXIR8pjXuwcnt7QBOjhjfcnB2tkx5u6bHYnWFX7QREgJYWtYrBwS3aa4ny/DsrUrGwoV111UY0Pwd/WFvWXs5otC3iiqLcLvY+N0s6rJWqVRA2kV2DamdeFeDITmgZbFLK0pDWXUZlHKlaEXTRniG12yYxyIAyVi2DMjOrnWqDvX2Lf64SW0gNwE2VYC7kN88QFdundjG7kl0Wz4ALSEBKCioXZAgB4KCAKWy3rqGuoWC5ECBOxsLWqlS8OOPdddV6FtuNm5wtXGt9bkwFmhPBI2hrnCEqirgRhTrW7cEOWBogif0g44dkZCXAALBxdoF7rbutU4V5EC8lhxYvrz+NlDvBM/d9AlebE4s3MsA50owa2UNORC1KxjgFDjbmk9+nZRUf0WbCSYpdra2tvX+2djYwM2ttmBvydTX6ARrS4oTM3ULAq2u1f7aZdZ0QwLM/Cy4Ik2ZqepY7Gp05gsXgKSz7BoSIngXgT6BTqQzUxcsZsGuwZDLajcpK6UVglyDRBdEO6sUVFQAv/xSd13rGyjNUezicuI0s3R3d5306Wo1sPg7R6DYG2WWQFko39H13YMa7gchh199g0+aMwvU8UcKfvml7swvwnMNdqutgAOAnaUd/Bz9dH7fGOqy2K1fD5Te4u9rGN8G9Al0jgMu8avwOncW24Ch6xdc54I7up1FMioqgCVL6q6rsVZbUwR6XI6WG9bbm238ycNxwI+LLIGC1lArgMJO/O+e0uOOFRRbPk1EfVYF4d4I/cAYOSA8V0N9wEppZZYrMjYn1qC1avNmoDiJ/V5iR02S2lrUkAPC9Qe5BMFCYVHrdEcrR7Syb6VpA1YpKC9nib/rwljFzpTrT8hL0OSvc3TUyePCccDiRfZAkS/ybIGKAN5ipbV/tojQB/g2YIxiBwCpvBwIQDKWLAFK6ojOqa9MK6UVWju3BmCa90JHua+h1KxfD5TwbeBae95ara8NcJxOPxDagL7wGaGugU6BYhsI4uXA0qX11DXH8IIMQHNvTJWD4gTX11dnuSsR8NMiKyC/DYqsgdIgXvHXJwurjAuruZuYpNjJ5XJcu3at3j+1PrdFC0XNqcUZVX0Wu3g7ZiLo6paMwkJgxQrD5dYVp1CrXCMFmppTIyE3QSPQW7fW+fzbbwHkMiVirxdvSrl4kbkctUlJYZKId0HVp4AJdRXiDL3VqZCBw+LFtYsWIKJ6O7M5rti4XC3Frsbuzdu3s4WeykJ2X2+359e66xNowuboHTuiSl2Fm/k3AdQh0Pm6JtozIdDDIxnFxSyDuSHqc+to/56xbUDFqXA977omxk5LsSMCsyDlsLruduGtgOfPi3slity8yfLRWVnpxBYZun6A3QNBoHuq0qCACj/9ZFguarv4G1W5zzXsgtqxg3mYhTaQ1J4PsqpLsQsPZ31LUMIMKKGiZcmOmYm6uDA5sHKl4breiTYg9C2xH9SwVn33HYAc1ud2ufJy4PJl5nLURnBFKxRAu3ZGyYFQt1BRDvioU+qVA1XqKjEkpT5lyRTFLj433uD1b9/OMrgoC1i5GaG8HNA3qAtyoEsX1rf4ZOL1ywF2wV3dklFQYGQbqKtvmdgPBDmgL85UlAO5rMydQhs4d65uOdCuXb0TMeE6BDngoUqHBarqlAM6fau+MdbcNlBjcrN3LzNGK3g5kBZahzv6lVdY5vI//jD6t+80Jil2n3zyCQIDA+v8a926NT7Wm5q6ZZJUkIQqdRWsFFbwd/TXe45gcblmw0y6w9qxGIRFi9iERx/1WQEBrVlKrnGzlFuFt1CpqtSkOtESaGlpYJvW57G6RlnmgHNzZb1NmJUKCP+HhAAWFsZ1ZtcQpDkCnAxQqKrQ0SsbGRlsZqiPnLIc5FfkQwaZ3vgy7d+7WXATlSoDI0MNdCwVNQT6okXsNdyLlXulNW/N09eZhdl7t264mX8TalLDzsIO3vb6U5LXdEON7KBpA9XV+usqrISrS6ALA76xAu1WwS1Uq6v1ztSPHWOXZVXCrwy2zgY5OLABPaZG7IrQBsLDmQsqr34FJNSNjy9SyiEnDl09byM9HVi3ro66ctWwUljpdfEDmnuTVZqF/HLjkh7rKPc1BLrgGu3ky+cka83P4vUpdoILKiJClAOGwhEAbTnAEt8OCWJt4PvvDcuB+qy2gOmDWlZpFgorCxFYwB/Q6gdRUWyLYGUhawMnZClsL2GVSqPECETzycEjIgArK6PkQKhbqI4c6NQqG5mZhuWA0LfsLe1rrYwXEK7fFDlQl2InygFvVm5sG34lrr42cJFPNdS5M5IKkqDiVLBWWsPX0Vfv7wr3JtaWKckPhLE28N13dbQBI+SAWK6RluukgiRUq6vRuoA/oFcO8FvE2eSCHA3IAaEPhIUBSqXR41aOLVBtqYSMCF090pCebrgNGNW3+DHidvFtlFQZtzgxIS/B4CRfCJPp6MPuQUxdY0FUFBtAdTbPbVpMUuxee+01o86b/V9IzdxICA052C0YCrn+9fCuNq5wt3XXcUE4O7NZ4bZt+sut5dZJSGCblmr57oTGLHT8+ojNiYVTBeAgzIy0GvMPPzDZPbCXM8sWLgOKO/G/XbMxCzNXfo9VYzuz6v/tXXd8W9X1/0qyPOS9YscrsRPb2Tu2sxOSsAJhhdkAJWVTINBCS+mvUEZDKauUUcqGpMyyCWFkkpA9ndixndiOHe9ty9vS/f1x3n1Dw5aUEBv5fj8ffWQ/PV3d995Z95xzzzEADWFU4fPuSynR/rnnHHeV4WMmhSYhwBhAS/r33tMUtIwNikWwbzCszCqvlPtCXl2eEoJRCfTsbGDDBnI+XDiTrmPb0G7letVSt6NDEXCTJ2uUr6PwA0B5csG+wTgheSvSAkoxZAg5Pf73P8dztVupnzhBbt62NvkcOSHdRaVeUF+A6FYgsBuUV6K6B1yYXX8l0QDTAy0TJRrYtk07EDfspM4lrnoVmB6oCScauPNiooFnn+2dBlIjpRC/xULKdedO+Zxgv2DEB8drzu8LzrxVBw8qNHDxXLqOjVJ7OeTkaOPmnZ1ENAAwYYIy1wjncoDny6rDUKGhxNrffON4rnYh/v37gc2bNasB2bBzUQ7k1eUhpEPKLQI0coAbNVdfKPEWGMyTpE0btnKAG3ZTp8rjAq7JgcYwMpi5HPjnPx3TgMxbERJv9fQAa9ZoDAy1HChscK1+iDPDLjsbWL8e0OuBC2fSfd3K++Zu26adZEeHkmM4aZK8wHaWkgIA4QHhGhoYHViCsDDaYO9MF9jxVk0N8P771MVHghy9cIMHoluBgB6QHFD1yuOLm+uvCkFccByYHmge7yQlwSYU7Wr0BjqgJkKSAxeVyL/riAa4LkyLTKP72toKbNoEdc2o8AAlp89VR4czGsjLI37U6YBLJDmwNVZSmrt3ayfZ3q7IgQyl3V9/w6PNE01NTVi9ejUeeOAB3HnnnXjggQewevVqNLnRKspb4MoqFSBm58xsKCvBzTfT344S6BljWiG5dSvVWZo3D5g/X96h5+5K/WjtUcWoiYyUVxhms5LrdO+9qlygdCdhKC7gJUJ2mZkBlIaQ4XNZRin8/WllaGszADahaMaA668HrrmGvIQffQSA+gS6G451ptSff57eL7kEyBxJc90QUEn3qKVFyakDiJEtFsrRS0hwyajhc+X5VYaTJbjjDvr76aftBRpjTDvuli3Ux/CGG4BLL5XjFu7SQH6dqi9iXJxcSr+oCPjsMzp8990qb+h46R79+KN2oP1SpX83DDu+SDkRShd7ydQSBATQULbDAza8xRiwdCl1oM/KopipBHdogPNWooOVOufFyy4DMkfSoml3zwnyZjCmNWwOHKBnEBUFpKT0mV/HoQ5DGcpKcOON9Dc3qNSwMqvGWMCePcD06SQDZs/2mAbyalXXHx5OBaZBTgfuNVl5t8JbpemSF9rWsOObamwWeL3dAz7myVBSPcsySuDvTzbiTz/Zn6+hK4sFuO46YPly+s2vvwZAvOXOBgrOW73JgUsvBbIkOfBtaC3xSU2NUtoEIGO/p4dakbkoB/g94DTgU14id/ZxtpFGM+6GDeRlvvpq4OKL5QWnHIp1UQ7m1+UruiA2Vm6tU1joWA4Uj5U8kFu2aAfavp3ep0/XpM+4Emk6Id2DiyaXyLpg61b78zW6kDHg8suBBQuoVNXHH9uN6wofWJkVx+qP9UoDF14IzEqnMb8LqqLUo9paEpYcBw4QXQ4ZYuf160+4bdht2LABKSkpeO2119Da2orQ0FC0trbi1VdfxYgRI7Bx48bTOsGamhosWbIEJpMJ6enpWL9+/Wkd/1TR11Z8jrTINFmpo7QUv73dCoMB2LjRPsJR1VqF5s5m6HV6jAxLIWuLe4wOHABWr5bHBIDj9cfRY+27HpIzo+bNN2nDV2oqETMPp+0fKe2G2rBBsTzUCi4jA82dzUq1fReY+ZiUZxjaXIpf/Yo+c6TU5CTcyHTy1PF4XWcncP/9snHrTgiCb8W3vQe1tfIt1Qizo43HwCSlpTFuVWFY6HSKV6WXMCSgVeooLcVtt1G+7p499gKtpq0GzZ3N0EGHEeEpwB13KB6jb78FXn5ZHhMgOnSl8n5+Xb5Do+Zf/yISO/tsakTB78G+kVJ44ccfFRqwWhVLbMYM1LXVob6dduTwnbqOwJV6gUQDwQ0luO46+syRUtMI9G++0RhzuPNO8pgAbuUXcd6Sq+1L96CyEvjvf+nQPfeo6LX+GKyZmfSBmga4QsvKAnS6PvNBOTQ0UFaG397aA72ecnpso1xlzWVo72mHj94Hw4MTyajn+cu7dsk8weda2FCIbouTuL4KzkLRL74oee3nEmnz+3pomBSO3rpVKwdUHru27jalzEUfOXYA5N3RwY2lWL6cPnO0yNUYNR9+KOWLgJ79jTfKOV/ueK6rW6vR0tXSpxzg9zWn5TgY98aoV6GcHiZP1hTo7tOwi1QMO5SU4M47yUu8aZOyXuLQ8Fb4COC++5Rcx40b5Z0nnO5cDUc7yzX+17/o0Z5zjlYO7E6TNhht2qSVA5wPZs1CpbkSLV0tpLd6kQM80sRzTfuSA5pF0xdfaN3bDz4o04A7hh3nrWE20ZuGBiX3feVKZcyj5iKwaVIfeLWNw6NX06djIFUvdtuwu+OOO/DGG29g06ZNeP755/HYY4/h+eefx+bNm/HGG2/gtttuO60TvOOOOxAXF4fa2lr8/e9/x+WXX44GNxqI/9xwxVsFEIGUBwNWvQ7o6kKiXzWWLaPPbA0briSGhw2H34bNRDzBwcDvfkcnrFoFAEgMTYSfwQ/d1m6caOy7yuPROvv8MotFEaj33EMhCE7MG+K7yPIoL1cKsR4/DtTX0wp2wgR5rs5KcnDEBcfBZDShhBcNLymRmyl/8ol9+1iNUuc7DO67jzwMxcXAunXK53BNqfOt+MObJbKXBNqrr5KemDoVmDULSA5PlqvZN0+T2gJ9/70yEGdsSdi7I9B54jiamhDt2yQLNNt6XnzMYWHD4L9rH+WymEzUhRuQrZDhYcPdqryvWalL19/SArz+Oh3i2RacnjfEtNJKtaxMWakeOUI0YDIBU6fKc00ISbDrDqFGTGAMQvxCNDSwciX9+fnnsKvCryn2+thjdPC228jTWFgIfPklfe4GDXAlMYzTgMQH//43OcCysuiVGKLwVv0k6blyJQYoSj0ri8atUy1EekFaZBoqgyjPEBYLhvtV4OKL6TPuKbC9/uSwZBi3/kQ0EBamPKSnngIYk3mrx9ojbzToDRqlLl1/W5vitefPhF/Lxvgu8uiUlCie6+PHyRLy8QEmTJDnytNOnIHzVnGwZKCWluKuu+jPTz+1bx2qyS974w06+Mc/UsShshL44Qf63I1cU35OSouP5h785z9aOcB5q627DS3Tpc4vaqW+YQO9L1hgP9dekB6peO7R1ITEkCZcfjn9a6sL+FwTQxJh2rqTFpUBAcD//R+dIN0Td9NSHHmtm5t7kwNtRAPl5Uph9txc8giYTJp0hOFhw+Hn4+f0t5NCk6gDR7C0EFXpgs8+0zrE+FwBiR4l3Yc77yQayM8nBQIVDbiQksAX48NapLQJiQZee414YcIEcozHh8QjwCcAPdYeNMyWFvnffacMxJ0c06f3+ZtnEm4bdiUlJTj33HMdfnb22Wej1I3m3n3BbDbj888/xyOPPAKTyYSLL74Y48aNw5eSQFejs7MTzc3NmteZQF91tjh4bklNqFQGQKXU/vtfbU03DSFzv/ivfgX85S8kSPPygMJC6HV6OanalW3ejsIPXKFGRFC0U30tR1qOU8gHUAwb7jGdOtWl2l0cOp1OU3UdpaUYPx446yxa+L34ovZ8Pu54SyStEgHg9tvJawHIyyp3ckuO1h6F3goMbbbK96C7W/ntu++mRRfvFAEAeVnSyvObb2hlaLEo9+KccwC4luAO0H1t9QOaA33ke8AF6BdfaKM86twivPoqHbz6auCWW8j63rULKCrSzNVVpWa7Un/zTRLq6enksQMUpZ7dclw2XuQkoM2b6X3mTMBodNmw1el0Wm9FaSlGjaLbyBjs6nnxZzq2K4yMKp0OeOghyI1bpZW7XPzYBa9tfl0+ArqAyFarfA86O2UHqKxgDHqD7HXIT5Vqh+3YQcTKmOJinTFDHteVe5AWmQamB6rC7OXAO+8AdapyhBrDloecLruMlLqfH+U35eeTHOD5ti7QgCPP/erVZKsnJ1PEW/5dAIfMxykNBFC8Jdx7OmcO4O/vckoKp9dSlXHP5YDFYi8HeCh6bHuwIntuuQVyA+d33wXgXi27/Lp86KxAfFPvckDd1eLYdGnX6NdfkxywWhUj76yz5HHVc3GG9Kh0mP2AJpNkVJSWyjTw3ntkr6rnKo/Jd11efz0ZNno9ufhKStxOS9Es8CQaePNNWuSNHq3IAc5bh5oLFDnA5R/3XmZmuryJDlB4S+21HDOGftOhHJDGHdcToeTXPvAA5DwGKSTvzmbC/Lp8+HcDUS0W+R709JDHElBoQK1j86ZI3u0ffiBitVgUI2/WrD5/80zCbcNuwYIFuOuuu1BtU122uroa99xzD+bPn3+65oaCggKEhoZiqKqP4cSJE3HENmYBYNWqVQgNDZVfiWcg3t3S2SIXBXVlpQ4AxSHKKiUri5w+XV3amm4yg0SkKcp06VKqt2TDXK66n3nI1HaV9swz9O9ttymbetRjskWL6CA3MLmCuegi7Vz7uH4+rizQpQUAV6Svvko5sQDQbemWk6DH/5hP3D5jBpVnufRSOmnzZoAxt9zvebV5GNoC+FhBBnJsLP73P3JGxcRA0+CZC8ndCXpaGTY2UhLQ3r2kAUNDgawsmLvMKGsp09y33q4fAEpCmHwPRo0CliyhS1SHopQyF6mydxLLl9NEOY/xlaqL94CHotU0YLUqnqK774bcE1Ud2rLye84TsCQvCVf2rpTk4FDnF3H3DKeB119XarqpeWvULsmVl5VF13/++fT/N98AVqtSQqL+GCzW3kst5dXmIYErtKAgICwMH3xAC6v4eLKbOPh93T/ESrzX0EB0t307EU1QEJCVpU1HcMFzDwCFIRb5HsyeTdE823pecomH0JHkzgKAZcvIa83lgLTocZUGuixdKGwo1Bh2atq76y7IPVE1ZUTOO48OcoOOy6UlSwC4ll/HoaGBXuSAhre25RKTzJ1LcuCaa5T5qGjAVaMmug3w7bYSwcfF4eOPyRllKwfk1mLJfpRPWV9PeWaHDtHfQUHAtGmajguueOwA4IRKF2Rm0iO11QUaOcCNiMsuo/7OM2fS/256rjlvqeWAxaIYNXfdpUQV+ZjH6o/BukTiO56zwHXC3LmaubqqC5zJAXVtx6aOJrnoctpP0nVlZlL9SW59/vCDRhe40oEjvy7fTg589hmRY1SUQl58rgCwO0FHkbP6epIB27dT3mVYmLLwGSBw27B766230NDQgKSkJMTGxiItLQ2xsbEYNmwY6uvr8XZvBXnchNlsRkhIiOZYSEgIzA6qOT7wwANoamqSX6fTc+gMQb5BKL2nFBuv34jwgPBez+Wr/8JgKRdOmh9fqb38slLHh7uSZ9WZSIEEBsrufpmYJcPO1ZU6X8WMMEuegqQk7NxJiy5fX8iJ/AAwImIEdNChqbMJdUsXkfDbuJG8FHyVKmlAV3bCcdjmGQKkF0aMILuJL0gLGwrRY+2ByWhC2E9SHg+PV02bpiQy5+fL11/fXo/att7bGGhCUAkJgMEghz5uu03eR6C5nqMNBYoh8Z//0G40AFi4EPDx6bMqvO31A0BRsKLUAUqhBGjFXE/pNPLzzGoKBqqqKPwieYe4p5Bnm7vqrTjecJxC0WZJcycmyjW7wsIgh4UBCv/xEG/FOZIC2baNaIArdcm4dzUEBdjnF/HLSUsjryEXH/z6o03RCPxB8hBy42L2bOKJykrg4EEkhSbB38dfU/PMGWxzixh0Mg3cfjtFnTk4bR1tOq54iF57TVFsl1wCmEzyXGODYu0alNuCe1dlOVBSAp1OkQMvvqhseOXjzqgNoGsNCZG9Q7I8kAw7V+VAYUMhLMyCFFUo+rvvKKoWHAysWKG6/kiFtxoWSZ77H34gGuBe2wsuAOCeHNCEIlVyICWFbGee58Z5K8oUhcCtUsiLR4umTSOeaGwE8vJk2qtpq+mz7E1+vcprHRcHGI2uyQHuyly9WrHAzzoLMBrluYb7hyMyoPcC/SnhKRSO5gs8iQ/UukBKH5V5a0ZjMFBRQdfMoygXXkjvksHnar4xp5ERZilykJiItWsVOXDttcq5SaFJ8DP4odPSidIL5pIu2LaNcmy//ZZOkpKlXY1eAbQI1MgBxnDuufZygC9uYoNiEbBOWlBKcgczZ2pShbiObexoRF1775147CIXOp28uOG5z+q5ApIc4Cu/F1+UF9a44AKt4BgAcNuwi4qKwocffoi6ujqsW7cOb7zxBtatW4fa2lp88MEHiIpynl/hLoKCguxCqs3NzQgKsm+t4+fnh5CQEM3r54ZOp0NCSALmD5/f57kmowkJIQl2Sm3ZMpIt6ppufNU5IV+ivPnzFUpbvJjepSRWV1fq/PPhKoHO87quuYYWQBzqekF5gR2KQJszh9zPkybJBS1dDcUCNh678nKgpwcGA+QcG17XT179h6dB96MU8uIrIj8/xVuxZQsCfQPl+oF93QPb3KIdOyi65usL3Hqr9lzN6pcvJdesUbJ7f/MbAIrB7IowC/INQnxwvJ23YsECuqXt7cpqnV/L1JxGOjBnjqJxeDK/FJZwteq6HQ0kJsoK7aabNA0YYDQYZSMkx7dJMSQ4DcyfD4wfrxnXVcNOpoGGBqClBXq9QgO8phungdERaUoIjht2fn6KctuxA3qdXklydkGpqUNQ27ZR2pK/P+Sd6hyaMiJ86+J//6vE7KRlvTvXH2AMQFJokp0cuPJK8haVlSnlb/i4Ewokop09W969KD+PjRu1cqCP/CIuW5JV+WWcpFesINuRw2Q0ybyVG9ZNhixANNDVRUTrQuN3W2hooLwc6O6GwUDRRUApfSJ7gMJTFUOSe6uNRqW8xE8/ybwF9L3A0RRpT0zE9u3ESr6+pNTV4AZzQX2Bkgby5ptK7F5alblS8oiDh3htaeDSS2m9WV2trB/5uNMO1ynXz3UBD/9JCfyupqXIpaRckAMGvUE28HOMjbSgBchLZ7USLUitKd3RBamRqrQcsxloanIsB3hHm4hUZds014H+/vT7ALB+PQKMAS7rAtu0pN27yV41Gh3QQKRq0cR1wfvvK7pA7eYfIPCo3AkABAYGYtKkSZg9ezYmTZqEQDU1nCakpqaiqakJlaqkg4MHD2Ls2LGn/bfOBBy5n41G8hQAFA7p6lHCkAm5UjI8N2QAitn4+FAyTmmpy4ZdXl0e9FZgSAO5BUt1SbIC4R4j27nK4/7xj/SbAL1LSxt1OQZXPXZVQUC3HsS1FRUASF6GhFDq4Lp1CjMvbI8lF1ZgIG3T4+DMLO3MlD1WvYRhGGPa4sSJifIK7ZprSKmqoRGSU6dCzm4GyGsqGRnuKHU+ri0N6HTKM/jXv4D2DqvsAUjaJyVC85A4QPPR68kKKCtTlE8fuSX5dfkwWICoZvIW5bYmyTW71B5bh/fgxRe1y9g//AGAlgZcMuyi0tHiDzTxoSTj9vrrIdd0U9PA3PYYissEBhLtq+8BIO/MdCUMZReGVCm0X/2KQjBqaHhgyhQlDQAgT42kYNwJRfNxbWnAz08rB9TpCAkHpWxyTvcAGfe+vuTNLSpyOb8ory4PBgswpJHcgvkdSfj2W6JBrlTV0Ow2ffBBRQ7o9bQK0ensyzP1gfSodFQHAp0GkAVXTiH3FSvIa5ibS84gfl/PaolS5ADfpQ4oHmxpU4sr4VjeKUit1Lkc+NWvqGqFGhqlPnu21p01Z45dGNJlOeDAc200Ksbts88CFqvCW4nZUgSKG1YAGdZ6PcnR8nJNyZPeQpF5tUQD0U1EA0fbepcDmhzWJ55QLD+9XpYD6u47ruqCDiNQG6TX3AO1HPjmG+W+zukaSgtBadOeDB6OlioVuKIPOW+paYDLgSuv1Do51GMW1BfQPeeeUoC8ddzxMYDglmGXpTYwesFsvpo+RQQFBWHp0qV46KGH0N7eji+++AKHDx/Gheob+wtCWkSaJmmY4+abIddy+t8GCpWYjCYE7JeqeqsLH/r50T50ANi/X8nbaipBR0+H09/Or8tHrBkwWBng44Nn34uF1Uq6SXK8aOeqZpDMTKrJcfXV5FaUvGelTaVo72mHUW9Ecnhy39cfmQarHigL1t6D4GAlD/a55xTlPO+EtPKVkvRlcDqUagO4otQrzBUwd5kxrJnGbApLktMFeQhEDT5mSVMJ2rrbSIk9+STtzH3jDTkJhXtInHXHsMWoyFEOaeDKKxXP7UtrStFp6YRR5wPT3kN0gpqngoLkgqDYuVNWPn2Vu8ivy0dcC6C3MsBoxLNrSItdeqldAwbNPcirzaOM6o8/pge1aZMcEtOU5JD6VfaG1IhU6KCTCzVzwy4oSHaC4rnnVCGoCsmQmDpVSf7i/wOyQHeljhfvYsC9VY0hSXLqmqOa6nK9rcYT6LB00ir9z3+mJf2XX8rzcScEBTgIQ0m49Vay1XbuBD7ZSHM1+QTAf6eUjqCmAT8/6voBAAcPKnUim0uJXp0grzYPQ7kcMBrx9H9Ji118sV27UHmu/HuYOpXcGnfeSZuXJM8xr/Zv0BkwImKE/SC2Y0obSE7a0EBIiCIHnn1WUc6zTjDl+tVygCt1bti5IAdKm4m3kiVvVXOYssB1JAfUXS26Ld3kSrrvPjJwvvxSlgOuljzicGTYAXT9JhOl8H38rcJbgQekvHLurQfIwOI0sGePLAcaOhp6TUvJqyMa4HLgmTW0qr3kkj7kQF0eLXDWrqWF7saNco4lD/EHGgMRFxzX5/XLOeeqnbEAyQF1bUdZDpRLvD95suK1BsjQAuSaYa4YdkWNxFsp0o7Y5rAkpX7jSudzLWkqQXt3O+nAp56iib79tpKYPIDg487JBw4cwJNPPtnnedm8EvNpwEsvvYTrr78ekZGRSEhIwIcffojw8N7z2QYqUiNTsd0BM0dH02rx9deBF9/PB4YB0/1SoDsuGXa2W6knTybO378f0UuXItQvFE2dTThefxxjhzj2Zqpdz9ah8Xj1DSJqXkHFFnahnYkTldwiCVyAjogYAR9936QUERCByIBIFIfVYXgTqGyJFE747W9JoX//PTBlqbQb8rgUM7NdKPAV29GjQGenSzWs5FBRmwlAK9bnJ8FiIcfLxIn250eZohDuH46GjgYU1BVgYuxEEug28MRj96FNKBYgWXXnnbTZ68X384HZwFzdcOiqj5GXRO2tAkjAHzoE7N6NuEsuhsloQlt3G4obi53uzlU3PrfEJeDdNSSQnDWKsVOUS5bIgtz2+lPCUxw2frdFgDEAw8KGoSS0GBOqoeEDNQ2MXiKFYoukLGrbqu7csDt8WEMDvOyII8hepbYAAC34LpeSxhcscLy4GRI4BCF+IWjubEZhQyHGRI8BHn3U7jx3aSAtMg0bHMiBIUNIDrz5JvDCe/lAErDIMhy66lwy5GzlwMSJtLg5eBCRl1yCiIAI1LfX41j9MUyImQBHUKcjWOIS8M5qogFnTYVk3uJyICPD7lnw+5oSngJfgy/6QrQpGmH+YSgJbaRepap7cNddpNC/+w6YeAEZS6OKJKLlHjoOTgN5eUBHh0u7o/mzGtUWCKAFG44pcmCCg1sWFxyHAJ8AtPe0K7zlQAd6Ige2OaABXp3g5ZeBf67JB1KBGbok6MoLaSFhKwemTaOC6Xv2wLR0KYX5m0qQV5eH6MBoh7+toYGh8bIccGTUAA7kwNy5sqfS0fX3FYoGlE48paEtmFYBOznw7LMuygFu2B0+DHR1uWTYySH+1gAAZnxzhHZFz5mjkJQakQGRsi44Vn8M42PGO1ecAwRumZpXX301cnNz+3xdeeWVp22C0dHRWLt2Ldra2pCfn49F6pDULwyaEEx1taapNleuP+UTIZ9TLyXip6XRLjg1OHPv309lRNThAgewrbRe5pMEs5kWe3wvhqO59jYm4N6OWPW4hfxyVIXLkpOV/RE51TRubO5JOmDLzAkJ5K/v6QGOHnVp8wD/LFlapb23jXIInSk0dfkAV4SEOyEYTeK4qlXZzTfTar2oicZcXB9GH0yYoA2D8mMAcOSIpiBoX3PlO+HKdIno6KAFuLOd+q7k7Lh7/YDNPVAJdKXUBkOBZEgMzZE+t6WBpCTSgt3dwOHDslLvzWPH55okeW3X/Eg04Myw5SV61N+1hbpDiCu5RYBNrmljo6Y1FJ/LtqM05sI66cTJk7VZ/YCyIpH6lbrEsyqlflKXhI4Osg2cBVlcSXNwJ78OcFD2prhY/mz4cCWV72gNXUeMMxoYOpRko8UC5OW55LGTawNKcuDDHUQDzowaV0tKnVIo9uRJpfA0lJD4dqlllqwLxo7VJsABSmjaRc+1lVm1ckDvuhzozWD2hAZSI1Mdei2HD+f7IxzIAbXHEiAXY2goyYHcXLcMu6QmkgPvbCIacLBul+fqbneX/oZbht2bb77p0us/6j37AjLSItPQEACY+aL25En5s/HjyXPAIohwMsulVY+j/nMqw46PCzgnuqrWKqq0Lim03ZVEyPfe67xYtjpnx1lHA3dDUPxcR4YdIBlZ/g3oMNQgtB3wLzxBH6jzagCaNDdssrM1W/Kdlbvggie2nnIMc9uSkJqqbHh1hL4UhasdF9QYFTUKZcFAjx4kjKT8IoDslBUrAERKNFDWCw3wEIxU+qevDRSNHY2obq2WlfruKkoyXrnSOQ3YhaMdwN38Mj6uI4EOSIZNSBl69K0w9ejhd0S697b3QKdTVuvZ2fL1V7VWoamjCY6QV5sHMCC6jhZUOeZEJCfLGzsdoi/eqjRXwtxlhl6nl2ue9QVez7AuQDqg8txOnEjeIy4HpvKa07Y8wE8G5H6dfc2V7xznNLCrUlnc9EUDvfKWG/l18rhR6U7lwMqVAALq0GmoJzlwrJg+sPVY6nRKSsLhwy6VvZF3MEtyIKc1CSNH2jmiNejLuG9ob0BNWw2d20ctS470qHRUBAM9OpBRJ+UbA9Q98rzzAEg0kFUuqWlHcoBff04OfZcvcJzIrLLmMrR1t2FYC425p0pZ3PRFA5XmSjR3Njs8R9YFbsgBR7mmHCtXAgiuQI++Ff4WPfyzJaOyNzlw4IC2Y4wTvZVfl6+RA0fbEuWyU73NVf7uLwAeB4c//PBDpy8Bx0gOS4ZBb1Aq79uUZLnnHgCRxCAj8xvpYG/MXFoKmM19Vl2XCzx2UHLb0fYkxMXJu9QdIik0CUa9kba5NzkuHeOJQNcYdjYlxmfNAtJn0ZhzyqWSAcnJ9lntgGLYHTokb8nvsnThRNMJh797tO4oAjuBwBbKQyxFoqZumyP0ZdhxI6qvjgtqJIYmwtcvAMVcoB3XVom/+27Iht3wXEkD92bYFRUBbW1Kmx4nK3XZq9Ruov/bExEbq63ZZQsejgacJ+Xn1ubSuC6u1Pm5tjuDOebNA0Zm0TXMroiDrqeHYpSqFngyRkk10/LyEOIXgqFBlC/m7Hnl1+cjvB3w7aA8xJNIwD33aFP3bNGXQFd3h3AlDAlQNxEfvU/vSk2igZRjUukOR5XtOQ8UFgLNzS7LgbFtRKv5HYmIj9fuC7KFutwFr9NmN64nhl1kOo5zOWDDA7NmAaNm0TXMK5d4PyXFsRxQGXaulL0pqC+AfzcQ3EgLlRIk4a67epcDfdEAlwNxwXEI8rWv2OAI0aZohJjClDxDm9Y7K1cCiCJjJvWYZEw5kgM837q4GGht7VNm8ePjOuiH89oTMXQo5fg6Q6h/KGKDYun8vuSLG3LAWa4pQGHRkZk05szKOOi6umjlO8JBDqdqke9KJ578unxEtQHGLtpEdhIJ+P3vXaQBF7paDAR4bNi9/PLLmtdDDz2E5cuX42W+DVzADs62uXMsWQL4xNBqIvyAxOiOmDkiQhFyBQV9Ep28Fd9M4bxSJGLlSvvIjho+eh85EdqZF8hd9zvQu8dOpwPOuoLGHJ8r3SRnrVp4UtShQ5ouAc4ET15tnpxf1oQQ+ESEyp02nKGvXXaa7hAugpfmOM5L3tkotZEjAVOStIM5TzJ6HN2DIUOIBhgDcnOV/CInOWa5NZIB1kaGXSkScc89vdOAppq9E0XBDbvRUaOdD2QDZ2E4+k1g3qX0W2MOSSdlZDh2J6RLdCe1ueorx0rdcaEa0QiKCpA3bDhDX0rdE681777QlxzQW4EIHoJy5LGLjKQG7gCQn+/yXFPbyFVYgiT89re9l+DS8JYTGtD08nQR6ZHpTnlApwPmL6NrGJ8jWT7O5IDKsHOl7I26QLUZgdBHhGtq9zkCvy5O67bIqcmRr8lV8HC0fA94my4JixcDxrgc6KxA9GFJDjjSBVFRihzIy+szbMplWWorMX4pEnHvvb3LAaDvRa6ni3xnPEA0IC1EDkk04EwO8AVeQQF89D6y57y3xRiXA5WIQUSsn9yvuLe59jbmQIPHht3GjRs1r9zcXLz22muYxN2iAg6hySuw8ViZu5vRE1CJ4Y1AcFsjmNHoOLMfkOtHuSLQ+fGYatpdVm9KxC239D3X3sZt7WpFaTMJHI89didPAp2dms+Dk0kgTSuVdsI5UmgA7dIEZKXeWz5cezclPnNmLkESVq6kHVi9QS3MHJUPkI0lN66fz/WYE4He2tWKNr8ijKoFTN3tsJoClWu1hSocOzaa/uZKxhb8eEwNCcaGwES72n0O59pLzo65yyx7ccZEj+l7MD5mVDoKpOtnJ07Y0UBgkhSGPCmFUhwpNEAx7KRcpN7myivYc+O+BEm4+26l24ozuMpb7tJAb0qtvacVPaYyjKoF/Lo7wAIDlWu1G8h1OSD3deZyIDBJLrHS11ydjdve3S73qXbXa8s9dsyRHEgh3pp6UuI729wqDpVhB/RugLR2taKosUgrB+7R2aWt2YLTdl+8xXnQVaRFpiGf1zIu0C6eW7vN6A4sQWo9ENDZChYQoPC73QQl3svNla/f2Q55/gyjqun/+sAkl3RBb8WPeZoH4HooGrDhAamuqRpBwyQ5wHWBMzmg4gE+LuCYXnk3E55jeALDcNddfRu2g8awc4Tly5fjLamHp4BjjI4arTBznlb4yN0Giojaq4dOsk+a51B5KzgzVbdWO6y6zj15YdWUUzDz6mFwpX6zptSBDbgXL9w/vNem37YYGTESNYGA2QhaZdqEIPLqSKBnSC0YOic7Eej8+k+cANrbexXoubW5YGBIbSEJXm4gT4Urc9Xr9GjubJbb2qhxuIaUyfgYB1sqe0F6pHPDjnsFZpygsHlJ9DTnsUIu6HNyZK9CdWu1w1IHObWkfMJriAZmX53oEg30dl+5kB8SOASRpt6r7asRHxwPc7gJzb6Azmq189zm19NvZdRTUdauyX0I9GPHAIulV++ivBvSTPe1wpDosGaXLbg3tqq1yjFvebB5hJ/vzGvJaxhmFkv0GjvFOQ2olBr3rNW116Guzb7yPqctTgPzr3WTBhzIAc5bkQGRiDY53oXpCCMjRqI2EGjxBXSM2S1yc2spd1SWAxOceOz4osdWDjiZKwCMaiEaKDckuUQD3BvtlLckw86dxQ1A95UvcLhRwsF5K6tImmvsFKWGoC24YZeTg/iQeJiMJvRYe+Q6iGpw3girolD0nGsSERxsd5odesvd4zwwNGhon51X1EiLTENVINBqBOUZ2tDAsQYaN6Oe+K67Lzlw/DjQ06PoLQdz5byVZibeqjC4tsDlvFXbVivnVQ9keGzYVVdXa17FxcVYtWoVYnloQMAhxg8ZjzxuBzkx7BbXkStpbW0G2pyVpFIJ9BC/ELlTxOHqw3anHq09So3Pu6gV29V/cJCv5ACcmblRoAb/nTHRY1za3s5hMpqQGJqoeO1sDJvs6mzENQMJ3U2wQI+3DjnYfw5QKDI0lIzDY8d6XVHxuSZKeXuhE5LsNho7gp+Pn1ybzZGi4OO6u1IfFTVKyS+yuf4j1aTQFtWTtP26erp687QWKo9VoG+gPFdHnoWcmhz4dQNRnUQDV93nWi/l3owl7rF0JwwLSGGo6FHKAsdGqeXV5iG8DUjrJC/AG4ecKPWkJFpqd3YCJ0706lXg8x9aFgYACJvoGg2E+of2yVuA+4bd6KjRinFvIwf47yyoIxr4qqoXGlDJgUDfQCSEJNCQDp5XdnU2TF1AuLQR5ur7XaOB3lI9squotNX4mPFuyQF/H38MD092mmd3uPow4pqB+O4m9MCAtw5Oth8EoDBkeDjJgYKCXlMS+H2NLyPCCx7nGg2oeYvTvBqyx85JqSlnSI9KR4ETjx0fc5G0K/qr6gy5zZgduHGbk6MJRzuigby6PPh3A1FdVD7kyt+7KQccyEFPUnIA4q2EsETk8XtwVPvM8mrzENoOjO6gBgVv5zox7BISqNVadzdQXIzR0XQ/HPErl69x5bSqipzsGg2oO5v01d1mIMBjwy42NhZDhw5FbGwsYmNjMW7cOKxbtw7vvvvu6Zyf12F8zHiZkFl+vqbcBReSc+rJJb2xLQMvvOBkIJv8Il636lDVIc1prV2tKKhT6pd1+AZjSGooXAEf82DlQbtQJP+diTFOQsW9YNyQcTjKjdtcRVC2dLagsKEQGVLO62GMw0NPBsJBa2DKtVAZNlygH6k5Yncqv68x5RR3G3eua8IMcB6CMHeZ5QRttwW62mN3/DgpJQl8/jNqKIyyqT0DTtNWuVKXlIKzcGxbdxuKGork3KIunwBEpkbAFfRWzd5TTwUf15HnuqOnA8WNxZgmbRYuwEj85bkIuSm4BgaD3M4IeXkyDTjaFckFemwlbXCYcpFrixuAFmOAY97iHoBxQ8a5PB5AvJUr8QA7elQjBw5WUfmSWQ10vzeZpzmXAzZhKD4P27ly3uIhqA7fEEQkuyYH+H11pCizq4m3xkW7d/2AFI514Llu6WxBcWMxpkty4AjG4uF/uCAHVDlmjgwQTgMx5ZRjOPZc12nAWTiWh3fV57gKtceOFRRo5AD/ndn1khxonY5XXnEyEM8x6yMlgYfNOQ10GgMRlepaTVg+ZkF9gR1veZJjyDEhZoLi6FAZduYuM47VH5PlQCGS8eBz0Y5pQK9X5EB+vqyTDlbZ6y3OW0MriQamXOy6LuCRGVveGojw2LCzWq2wWCywWq2wWq0wm8348ccfMc1ZTpQAAFqpn4jQoVsP6NraNCVPDlQdgI8FGF5Irt5dyMCqVdRJxQ5qgc4YJgxxbNhlV2eDgSGpghjYmOK6MBs3ZBz0Oj1q2mpQaa7UfMYZZGKs+4bdpNhJODJE+idHEZTcqDmrhtzkuSGZqKqC3NPWDvwe5OVh/JDx0EGHSnOl3Vyzq0ghJTUTkweNce8eAPb3lQuz2KBYt0LRgFLqwQpQDbPqavmzIzVH4NcNJBRRKG0XMvDYY9RRyQ5qw85qlRULV2AcR2uPgoEhsZpW/4bkJOe1DWzAw9EtXS1295WHok/ZsFN57LKriF7n15ARfjRoOmpq5C52DgZSlLp6B6ft7uh9FVQaKEkybgNHu04DfIHDjRh5rhJvDQ0aipigGJfHA2gxUBQpyYHWVo0cOFh1ED4WIKmYaGAPprksBybFTAIAHKg8oDmNG2VJFWRJ+KS4p9Cc8RYf1910BIAMZnmBp5IDnLcW1JIcOBqcgcrKXuSA2rCTjIuq1iq7sOlhiS+SmtyXA2OiJN6qsectgHa5uisHRkaMRFE4YNFJNKBqnXm4+jCMPUBSkaILHnmkDxrgKQlO0idkXVBFcsBnxDCX5cDwsOHwNfiio6fDbnf0/krirUmxk1waSw0NDagMOy4HFtVQ9ConKAPV1Up7VjuodMHYIWOh1+lR21ZrR68HKklvJUq6IHCU6zTgjLcGIgZeLwwvR4AxAMOjU5UQhMpbsb9iP8ZWA8bObrDQUBjHpKGxEfj73x0MNHIkMWVzM1BVpXjsqrUGyK6SAwCAxDJyIxuSXSfkAGOA7NbnhhwHN3ScVbjvDZNiJyGHp+McUQQlH3NOBWWyjryaXO//+IdG5ilQCfRA30B5tb5fUuIcO4tJIQ+XwpAOS2c4wZShUwAAeyv2ao5z48ndMCxAbv2kmFTFa6fq1JJdlY2JVYDBYgWLjkbI2CQ0NACPPeZgoKQk2tLY2QmUlsqeJS5oOXaWUPHSpJMSDQxzXan7+fghOYzaxam9FYwx7CnfA0C5R+4gPcqxYcfv8wLJuI+/hGjgqaeoLar9QAoNqBuWqz2sjDFsL6Z7MqzDfRpw5g3nAt6TxY3JaEJydJqSY6XyXB+qOoRx1YBPVw9YaCj8x4xAQwN1sbJDSgp5LFpagKoqWbnaKp+9J4nGEsupJIyPG3IgyDdIlgO2vMWNXU577mDK0CnI5gs8FQ9w42l2JcmBEZIcePJJTbk3BSoaCPYLlvMi91Xs05y2o4h+Y1iXlN/iAQ3Yjsl5zRPDNsAYgPioZJzgjlNJFzDGsLdiLyZUAYbuHrCICASMSUF9vcPGJ0BiIrWu6eoCSkqc7ozdcUKSA6XE/4bhrl+/QW9QSiqpDEbGmHxPJsc6CZf3ggkxExwadpx+51XTAi/+Esq1/sc/gJoaBwOpFjgmo0meqy3P7igiPTasUwoBuEEDnLdsdeFAhDDs+gGaVYrEzBUtFahqrcJMqSitbto0/O0JejzPPKOxfwh+flSiGwDy8xWvQlW2pjDjW+uICFMbJemR6LpSB5RQ68FKhZirW6tRaa6EDjq3Q1CA1rBjOTlyCCK7Kht6KzDqBCnfqbdnIiMDaG0F/vhHBwPZ7IrkgkVt2OSV1qLRWgadFUiySit4N5h56lDK8TtYdRA9VmXX1u7y3QA8C0UDwLS4aTjEnTxS54CKlgqUNpciUwpB6TIy8NTTRA8vvGCXhkPJ1LyuU0EBMuJJAe6r2KfZEffq2l0AgBH1EtG5SQPccOPXDFB/0EpzJfQ6vUcr9bHRY+UQjJoG9lXsAxgwtpiU76SbMzB1Kq1fHHYJcVLyRG2EHiysQIu1GoYeHeItklbwQKlnV2t5iysfvpJ3FxNjJyKXL3Akw47z1iypwoUuIwOr/k5y4LnnNPYfwUYO8GdxqOqQJmT27nek4EY2eSYHJg+1563atlqUt1CszN10BIDo6rBk2LHDh2Ua2FO+BzorMKa4FQAw9dbpyMoC2tqABx90MJANDUyLmyaPw5FdVIFG60nACiRb3aeB6fGU57mvYp9GDuwqI97KiHOS/9UHpsVNQ7aNHOC8lSUVqddlZOCZZ+nvf/3LLiWVUhJGSgXSCwpkI/tg1UENDby5jhZNqQ2SV8GN6wcU3lJHBMpbylHTVgODzuDRIn9CzAQlNcnWsGPA+ELSBRNvIjnQ0uKkm5dNSoKcRqQywrILq9DCquDTA8RZJF3gBh/wBZwtb/1l419w1ttn4cu8L10e6+eGMOz6AdPjpiseK4mZucA8r0raojRrFi64gFosdXcDN92kScMhqNzPqZGpCPAJQGt3q7xSO3IE2F9xAACwMEraUeUmM3PDRS3Q+QptRMQIlwtyqjEifATKY0wUhmppAcrIktlZthPptYB/WxcQGAjd2DF47jlyTL79NvDNNzYDqa4fjMmGnXpVfdMjPwEAEqpS4dPTSYPFx7s+14gRCPYNRkdPh8ZY2H5yOwBgRuIMZ1/tFdPipuEg32ckdQ7YWbYTALC4Tqnfds45wLnnEg3ccIOm8xBBlVuSGpmKEL8QtPe0y16PQ4eA/dVkkJ09RNph7aZSz4yn1fKOkzvkY9yzNjZ6LEzGPmqGOMCY6DEoiQ8iGqirk0t+7K3Yi+QGIKS+FTAaoZ86Ga+8Qk6p994D1q2zGchWqQ8lpc6fDwDc/QTRbkrVSOiZlbycMa6HTtMi0xDgEwBzl1njBZENOw8MW4B4i+fZcYuNe8TOqZL4atYsLFlCHVK6uoDf/MYBDdjsjDUZTWjvaZc3EmVnA7vLyQCZHy4VrXPXuI8l414tB34qJd4aHTXard2QHCMjRqI8LghdXA5INLD95HaMrAcCWjuBgADoxo2Vw7BvvtkHDTDm0LC77XHirfjq0TB2t7stB9Ii0xTeUhk2smEX75lhlxmfif1cDkidhPi8z64No+PTp+Pss4kGenqo9WBvNDAmegyCfYNh7jLLofLsbOBANfHs4miJBtzUBdPjyLj96eRP8jFOD6OiRiHAGODwe70hLTINJ2MDYAWgq6+XXbL7K/djZD0Q1NgG+PlBnzENL71Ej+3dd/uWA1xvqSMtd62iuSZXJdNObF9f2oTnIlIjSMe2dbdparuuO7YOG4s3oqnTcceb/oAw7PoBs5NmY5ckU9guEgxcQMwoklaDs2dDpwNefBEIDga2bwdeeslmIJXHykfvIxsZW05sQU8P8JvbWoGhRNjjDJIHx01mzkrIksfkiaibizfL1+EJDHoDxiVOUcJQ2dlo6WzBvop9srcKU6cCBgNmzFD6ON58M9Ck5h1u1DQ0ALW1Gs8SYwyffAL8WLwNAHAFzwMbOrT3iqw20Ov0Sji2nO6lucssu/hnJHhu2MkeO27YnSTlk1kiJfxKRVlffploYNs28t5qoMqz0+v0svDdXbYbPT3Ar29qA4ZQCGqir0Rbbip1TgM7y3bKNMCVD1ei7sKgN2By8gwlFLd3Lzp7OpFdlY15PD1u+nQgIABTpyr9M2+7DdoEas4D5eVAS4tMk1tLtoIxhrVrgS3HyLBdGj6czk1M7L3MvA1seQugpHm+gJga52Tndh+YmThT9tYwqdfnpuJNAIAZnAZmzYJOB/z734ocePFFm4FUSt2gN8gLnG2l29DVBfxqRQtYLI0/yVeyCNyUA9xjt6tsl0wD20qIt2YlOmky2gf0Oj3GJ0xRoheSHDhUdUjeQIXJkwGjETNnKjRw443UYlfGyJH0PKW0FFvD7rPPgG0naFFyZYxEL7GxfRcvs5krH5d7rlu7WmXDyWPDLiET+yg6DmZj2M0slGS21Mj3+eepVezmzQ7kgGqBZ9AbkJlAi7HtJ7eTLrilExgi7eLXSzUDhw1za66zkug5byvZZicHOH24C6PBiIkpM5Sc61270NrVioNVBzGbp/JNnw74+SEjQ+mlfMstNnKA80BZGWA2y3Pleuubb4BNRcS7l4RL5yYkuCUHDHqDzOtbS7YCgKy3AGDesHluXfvPCWHY9QOmxU3DwSTanYfDh4HWVnxf+D0SG4Go2jZyrc8gRZKQAKxaRafed5/s4COoPVZQCGvzic14+GFgZ/lWwNCN+MAkBFS473oGyCPlZ/BDhblCzq3YdGITAGD+sPlujaXGWcPPwp446Z+ffsL2k9thYRYsrpY8FaqCpI89RhHHkydJscsbnUwmRUHl5SEzIRNGvRElTSXYmnOM6hMlkfJZEkplINxVaIDisdpYvBEAGU1WZkVSaBLiQ1xf9asxZegUZMdSeIXl5ADd3dhZthPDGoAhlc1EA1JX7uHDlaThP//ZhgZUAh1QFMyOkzvw0EPA/sp9gN6CIQGx8K+QQlAehGJ99D6oNFfKidNcsHlq2AFkFO/lNLBnD7aVbkO3tRvnlEmexXmKoHz0UXp0xcUk1GUaCAtTVt35+ZgWNw1+Bj9Ut1ZjW+5x6i4y4jsAwPkh0rP3gAbmJs0FoBh2W0u2otvajaTQJIwId9DmyAVkJWRh3zBJDuzfD7S2YmPxRsQ1A1E1raR0JD5ITKQcM4DSEhzKAYkGFiYvBACsL1qPhx8Gsht+AvQWJAUnI8BDGshKyJJ5i3srtpYSDXi6wAOArPgsORyL/fuxq2wXrMyKC8ulqsEzlIXTqlVE7mVlwO23q2hAHY7Oy8Pk2MnQ6/QobS7FjtwTVIA3gQy786SSFZ7QAF80bS8lb/C+in2wMAuGBg09JTlwKE5Sw0eOAB0d2Fa6DcMbgKgaM6VbzJwJgGQg30T04IPAgQOqgWx2yPMF5/aT2/HQQ8Duym2AoRvRATHwL5c2a7l5D6bFTYOvwRdVrVU43kDlab47TrzF+cMTzE2ai5389u3YgR9LfkSXpQvnVko0MFuhr0cfJXu0pMRGDkREUCcWADh2DFkJWfAz+KHSXIkfc/JJDiRvAAAskUrXeEIDZw0/CwDxFkBeawuzIDksGYmh7vHUzwlh2PUD/Hz8kDg6EyeDqUBry/bN2HlyJ+ZyT8XkyZq2CLfdRk2hOzqAiy6SI5d2OWZzhxFzfZu7BY8/zoAUIr6zR54FHa9u7yYx+/v4Y2YiCZaNRRth7jJjdxmtWOcN93yFsihlEbZIC0a2ZQt+PPEjwIBzCqR4s0qpm0zAW2+RrfPee8Df/qYaSHUPgnyDMGfYHADArx5ah5qGdujiaa7jOqXwpgfMfH7q+QCAtQVrYbFaZAPPU28dQAnpCeNnod4f0HV1wbxtE34q/QkLeY3OzEyoq8euWEHN6ru6gAsvJAcVADuBzo37/2V/jb+tsgDpXwAAzhoxHzrel9VNpR5gDJC9lt8e/xb17fWygXPuyHPdvHIFMxNnysY927sHX+d/TXMtldIGVDQQFASsWUM08N//KosdAJowjJ+Pn5wP9as/bUGtuQFIIE/olG7JNeSJYSfx1uYTm8EYww+FPwAAFiUvcqt+mxr+Pv5IHDeT5IDFgrZtm7GnfA8W8bqykydDXT325pspLN/ebiMHbGhgUcoiAMDa3PVY9YQVGEbPakHyHKXLhZs0EOQbJBtw3x77Fu3d7bK35lQMu/NTz8c26XGwTRvJY8mARVwOnH22fK6tHHBGA8F+wbIX8fI/f4nqpiboEsmwG9cp8ZQHNLBg+AIAwNcFX8NiteDLfMqpOhU5aDKaMCR9CmpMRANNu7diy4ktmF8snZCRodEFv/mNkp5z0UUO5ICkC7jM/vrIJvxtlRVI+woAcEHquaekC/hCbsuJLWhob5DTR84ZeY57F67CnGFzsFNad7OdO4m3GLCgWDJPVIZdUBCFYh3KAZWjw9/HX440LP/zJtQ0NwNxRK8TOsPoPDd5AAAWptCiaUPRBjDGsPkERa+4fBgoEIZdP+Gs5LPkcGzxuvdhYRZcK1UZx6JFmnP1emD1alqtnjgBLFggFetXV9zu7kZmfCaMOj80WMqBhJ2IyqJEhPPDMsgqdDOvRD1XgATaNwXfwMIsGBY6TC7a6QmyErKwbyTlZrGdO/DZwQ8wrhqIrG2jbhsLFmjOnz1bWa3++c/A449LqzUbr+XsWDI0Sv2/QVDmR2CGLgwPG04eEMAjgT4zcSZC/UJR116HHSd3YPWh1QCAC9MudHssNS4adTF+oLaGOPb+i+i0dOLSMknx2NAAzzNMSwNKS8nmKSqC4rErLAS6u7EgeQFM+jA0WaqApK0InfExAOCqpCVKHNsDgbZs9DIAwHuH3yMDl1kwbsg4uS+jJ5gzbA5yhxENWLb/hO9yv0JaLTCkSuup4Jg9G/jnP+nvBx90QAOSYTMzhu5dSegahExaD+isGB01GmHVUq0TD2iAewDKW8qx/eR2rDtOvMWNKE8xP3mBbNgc//pdWJgF1xRKOYsXXKA5V68n43bkSJIDCxdKcoDTgFTuIjMhE746E5otNcDQvYiY/T8AwNlh0yBXOk5IcHuu3Ihfd3wdPs75GF0W4q1ToYGZiTOxK50MF7ZtGz7a+w7G1ACR9e0kB+bM0Z4/0wkN2ORYLUy4CABwMvBzBE77FMzQiTHRYxBTJ4UhPTHskhcgzD8MVa1V2Fa6DR/lfARA4Q1PsWzs5dguPY7CD16BhVmwTCqgi/nzNefqdMAbbxDJl5TQxxo5UFwMdHVh3rB5CNCFoK6nBEj6EeGZZNhdGjGbVod6vUe6YHHKYgDAmuw1+KHwB1gZlVniRbw9QVZCFvYlUXqMdddOfJf/DcZXAUOqWsgbO1drNM2Zo/VcrlrlmAYyhswHAJSavkDI5O8AvQUjwkcgrMb9HbHquZqMJlS3VmNvxV58evRTAMD84fPdHuvnhDDs+gk3TLoBm5Nppd/2/rswdQELciWhe/nldudHRADff0+0WFAATJkCvPBZAvUQ7OlB4YZi3PKbAHTvu5q+cOMM1BqyEeATgIVGSfHFxLiVV8Jx+ZjLoYMOXxd8jSs+vgIAsHxCH12T+4DRYMTIrPNRFQjoO7sQcagAlxVKc1u40GETz9/+FvjLX+jvP/+ZmqWXmoiZLTl5WLMGeOV35F1D6jfoPoeaIN44+UboeJ0wD5jZaDDKSu38/56PosYiBPsG45LRl7g9lhoXjboI66TNbD1rv0JgJ7DwqKR4FtkbDBERlDQ8fDjp8MmTgRc+iQMzmQCLBYXri3DTCl+07b0YAOB33WVo0hchwCcAi32lIqahoXCph5ANrhp3FQDKAVu5biXNP/0it8dRw2Q0YdTCq1AeBPi0tGLYrnxcmy15v845x+E877jDngZOBhIN9Eg08NbKGwCrHkjZgOZziZfOTz1f8VZ5QAMBxgBcPZ54a9Ybs3C4+jDd1xGL3R5LjSvHXontkp1d9/n78O8GFuRLuVVLl9qdHxEB/PADXUJeHqWivvhFIpifH9DVhaJNJ3DjDb7oOryEvnBzBur1eQjxC8HSQCkPasgQ560Ke4Hac33dZ9cBAG6acpPHHkuAeCtlxnk4GUxyICG7BFccl+TA3LnUUcAGjmjghL8kB3LzsHo18PLd0r0b8QP059N26mvGXaN4rT2gAV+Dr0zzl314GYobi2EymnBe6nluj6XGVeOuwhe8tu/nnyKoE1icLZVksTHuAYo4rltHIcmCApIDL/4vFiwoCLBaUbS+ELf8JgDte4n2jdcvRYO+AEa9EfMNUtpAXJxbucYcN0y6ATrosKFoA6799FoAwPkjz3d7HDVMRhMmnXUN6v0BQ2sbYnbl4Mo8qYWeEzmg1gV/+hPdprJA0nM9uflYswZ4+/fXAEwHpK2V5cAVY6/w2GsNEA0sSSXemv7qdBytPYoQvxBcOvpSt8f6WcG8FE1NTQwAa2pq6u+pOMXyl89m3TowBrBn5vkyBjCWksKY1er0O2VljGVm0qkAYwcwgTGALcGXdCzmEMPDkF9//P6PjH36KZ2ckeHxXK/86Ep5zIDHAli1udrjsTiOVB9hb0+kC/ksHaxuSDDN85VXev3eyy8zZjTSqYvxLWMAO4LR8j0JuuEKea6GvxpYWXMZY9On04effurRXHeX7WaGvxrkcW/64iaPxrHF8n/OZwxgFoD9Y5aO5piaypjF4vQ7paWMZWXZ08D5+IqODdusoYEVn61gbO1aOnn8eI/nuuidRfKYgY8HsmN1xzwei2N76Xb2XCZdyH/HgdXEhtI816zp9XsvvsiYnx+duhSfMQawPZgq35PAmy6Q5xqyKoRVtFTQtQOMrVvn0VwPVByw563TgFtfWsJ6JDnwr5k+NMfExD7lQEaGQgOHMI4xgJ2LtXRsyGGme0gvz/Xedfcy9vnndPLUqR7P9YqPFN7yecSH7uspYk/ZHvbWJKL998aCNUSYaJ5vvNHr9156SZED87GBMYDlY6R8T0w3naeZa2F9oSI8P/nEo7luLnbAW6cBlz0/m1mkia9aIF1UenqvNHDypFYO7MEUxgB2IT6nY4nbNHO9+5u7GfvoIzp55kyP53r+mvM1vFXeXO7xWBwHKg6wf02nC/k0HawmPpzm+fbbvX7vxRcZ85VU5yX4H2MA241p8j0JXrFMI7NqWmsYmziRPly71qO5Hq46zHQP6+Rxf/ft7zwax124Y9MIw64fUdRQxLZNjFQ4E2Ds0Uf7/F53NxF0WhpjH+ByxgD2e/1T7NxzGdu+nbEHfniAxT0dx8a/NJ7VtdUx9s9/0tjLlnk81/zafJb2rzSW8EwC++eOf3o8ji2e/c8K7fXHxzPW1tbn944eZezKKxlL8ytmDGCdMLLhCd3s0UcZK6g8yeKfjmdxT8ex1QdX0xdiYmj8vXs9nuuTW59keBjsovcuYvVt9R6Po0Ztay3blmbS3oPnnuvze11dpNjS0xn7EMsYA9g9umfYkiWM7djB2L93/5sZ/mpgC99eyNq62uhkgLGlSz2ea3lzOct6LYsZHzGyj4987PE4tvj41Xu11x8SwpjZ3Of3cnIYu+oqxiYYcxgDWBOCWXyclT32GGM55UVs/lvzme5hHXtt72v0hdBQGj8nx+O5Prj+QTb0qaFs/EvjTxsN5NXmse8mBWvvwdNP9/m97m7GXniB5MBHuIwxgN2rf5addx7RwB++/wMLWRXCFry1gAywF16QNOAlHs+1tKmUxT0dx+KfjmfvHnzX43Fs8fYrd2ivPy6OsY6OPr+Xm0tyINmvjDGAdcPAkuM72WOPMVZSW8NSn09lwX8LZp8f/Zy+cBrkwEu7XmKGvxrYoncWsdauVo/HUaOipYLtSbOhgSee6PN7XV0KDbyHK0kX6J5i559PuuCFnS8w0+MmNvWVqSQHnnqKxr7qKo/nWtSg8Nab+9/0eBxbvPX6Xdrrj45mrLGxz+9xOTDR5zBjAGtECEuIJzmwr+QoG/fSOBb7VKyit8Ilo/HwYY/nev9397PwJ8LZvDfnscqWSo/HcQfCsGO/DMOOMcbY7t0KoWVmEqe6gZZ7/swYwLpuuNn5Sb//PY1/zz2nONmfCcuWKcz85ptufbWjzcIsfv6MAcyaXyAf77Z0Mytf7ba3K+NXn5qnsbmj+ZS+7wgdeTnMGhhI85s8mbFm936j5e4/kVK76TbN8bq2OuUe3HcfjX/XXac0V6vVyhraG05pDAeDsp6bfkPz0+sZ++wzt77e2dzBrHo90UC51oNksUqez8ZGhQZaWk7XzE8f9uxhLDhY8aq6IQesVsbMEg10/eZW5yf+4Q+nhQYsVotCV6cRXdctV57RW2+59d32NiuzBAYRDRxRDPf27nYyaBhjrLVVGb/+1Izy2tba034PrDk5zBIZQfObNcttOm255/9IDqzQ6oL27nbW1SPR012S8XT//ac8X3nM04mrr1aekSdyQKdzKAdktLQo4w9028AG7tg0Pv0ZBhYAMG0aJct88QVwySVu5z0ETaHkDGOhfdNrGaeQW3RG8O67VKQqIIDuhxvwC9ADaalAdjZ0+XlAKiWt+ehVpF1cTO9BQUCUe/0cbRHs535+Wl/wSxsN/PgjbYK5+GLaOOAGgiZR4rRPobYkfURAhPIPvwfJyacwU0Cn0yHMP+yUxnAwKAyvvAqcfS4QHa3ZDesKfIOlcheFhUQDQ2Plz/Q6KY2Y51ZFRGh2GQ4YTJ1KiZM7d9JOSDfkgE4HBE6lHErj8aPOTzyF3CI15Ht6mmF85VXgwosogTjFvQ0Z/gE6YFQ6sHcv0cCY0XTcR5VLyHkgNBQID7cfxA1EmiL7PslN6EaPhu6n7cCmTcC11zrML+wNQVMox8xWDmjuAacBN2vYOYLR4H6OXp9Yswa49VZqk7jYvfxVWQ4UFdnJARlcDoSGaqoOeBuEYTcQEB1N+9g9gc02d4cY6Iadg91vbiE9nUqr5+dTJrUtCqX6ESkpLje9PuOYPJlensBmV6hDFBXR+ykadj8bdDpg2SnsLkxPp+ecn+/YMDxNRs3PiiFDqJaNJ7DZEegQx6n2mLtG0xmDv/+p08Devc7vAZcDA5UHAOJlzs/ugu+M7U0ODHRdoNPZ7YJ1C+npJOvy8n65cuA0QOyK/aWDC/SKCqq87ghcqZ+GVdqARF9KTW3YeSO4QC8pUcpZ2IJ7K3ghV29DXwucga7QThWuyAFv54O+5MBAX9ycKrgckLovOMQJqViqt/OBMxrgixveY9tLIQy7XzpCQ5W+l46UWksLUFVFf/NG0d4Gm1p2duAKzVuZOSqKOjAAFM6zhdkM1EqdRwarYcdpwFuvPzSU2mQBjvmguVmhAW/lg8Fu2EVEKKkmjuRAaytQV0d/D1bDjt8Xb+UBCcKw8wb0ptQ4IUdHk/D3Rth04LCDt3sqdLrewzDcWxce7r000Jdxz2nD0zDXLwG9KTXuqYiO9qiO4S8Cg92wA3qXA5wGwsKUhaC3oS9dwPWhtzo5JAjDzhvQm0AbDITMlbXUCN4O3m7YAa4Z94Ph+o8fB3p67D/nio4rPm/EKKkI9VEHGygGQwiKP9u6OsUzpQY37AYDHziSA/wY1xfeCH5thYXUYcMWg0EfQhh23oHeVimDgZDDw8kTAdjfA8YGl2HnyLjnx7xZoCck0C7Cnh7FQ8lhtSqGjTcbdq547LzZsAsMVJLibe+B1aoY9958Dzh992bYebPXOi6Odr1bLIrc57BavT8tR4Iw7LwBvSn1wWDYAc6VWkUF5Zbo9d67eQQAxoyh98OH7T/jHhzu0fFG6PXOlVppKZVPMBq9N7cIUHhgsHrsAOdyoLQUaGsjGvDmezDYF3g6nfN7UFZGcsDHx7vlAIRh5x1Qe+wY03422Aw7W6V+5Ai9p6Z61Cf3F4MJE+j9yBFaraoxGAw7QBHoOTna49xTk5Lido3AXxT48y0ocE4Dg0UO2Cr13Fx6T031bhoYO5beDx8mD5Uag8FjBzinAa4Lk5O9mwYgDDvvQEoK4OtLnil1GIoxrUDzZjhjZm7YcYHnrRgxgkKR7e3aEARjg8ewmziR3g8e1B4fDPl1AHmk/fzIK8HLuwBEA9nZ9Pf48f0ztzOFvgy70aPP7HzONNLSiAZaW+1DkYPNsOPPnINHM7zZYylBGHbeAKNREdj79inHKyuBmhoKU3m7YcOFlW0YijOzt1+/waCEYw8dUo5XVwONjdqds96KSZPoff9+7XFu1Hi7UjcYFKWlpoGyMqIBg8H778FgN+x8fIBx4+hv9QKnthaor6e/vd1ry+WAWhcCyv3gC0AvhjDsvAVTptC7mpgPHKD39HTAZDrjUzqjUIciOzqU49xjx4WdN4PfA27IAIpCS06myv7eDN654+hRbaFmzhOcR7wZvCXf7t3KMU4P6enenY4AKIbdsWNAd7dynIfnvd2wAxTDhst/QOGBESNok4k3Y+pUej9yRCsH+GJHGHYCvxhwpbV3r3KMMzZndG/G8OHUkqm7W/HYMDZ4QrGAYtipjftdu+h9EAgzxMXR7miLRfHU9vQoK/XBYNhNn07vjgw7bw/DArQrNjyc5ACXf1arQg/cq+3NcJSSsGcPvXP68GbEx5MusFiUe6CWCYNAFgrDzlug9tjxDRScqAeDYafTAZmZ9PfOnfR+7BjVtfP19f4wJADMnEnvW7cqidM7dtD7jBn9M6czCZ1OoXW+wDl6lDy4wcHeH4ICFMW9Z48iB7inYjAYdnq9wgfbttF7Tg7Q1ESeqsHgueee6507FRrghh336HozdDrFa8flQEEBee9MJu/eFS1BGHbeggkTKNeupkZJFudEPRgMO0Ax7Lgxs3EjvWdlkXHn7Zg8mZRXQwN5KhkDtm+nz7Ky+nduZwpcqW/YQO/cezl5Mil9b8f48UTr9fVU4oQxYMsW+mwwKHUAmD2b3rdu1b5nZXn9bkgAZNwHBFB+LY9YDCaPHaDQOpd/3IM9fjzlmno5BoGkGyTw9wfmzqW/v/6avFXHjpEgy8jo37mdKXDj5ccfyWPFlftZZ/XfnM4kjEbFsNmyhXZGVlYSDQwWpX7OOfT+ww8UfuHG/WC5fl9fRXl/+y1tIigtpdy6OXP6d25nCrNm0fu2bWTYcs8dN/i8HX5+ii5Yv542z5SWkieLe/O8HVzmf/MNpWOsXUv/L1zYf3M6gxgEy5dBhAsuIEb+6ivFBT9vnvf2BbTFrFnUC7W8HNi8WVHqCxb077zOJObOBb7/ngSZTkfHJk2iFfxgwPTpRO8NDaTQP/uMji9d2p+zOrO45BK69o8+UurZzZnj/RuoOLjHqrKSvHWbNtHxwWLYAWTAfPstyQJOA1lZ3tsn2BazZwMREeS53rIFWLeOji9Z0r/zOkMQHjtvwoUX0vvGjcBjj9HfF13Uf/M50/D3By6/nP6+4AIKRZhMSoh2MOCKK8igW7sWuOMOOnbttf07pzMJHx9g8WL6+8ILqcxHbOzgUurLltH75s3AX/9Kf599dv/N50zD3x+46ir6e+5c4ORJUvLcmz0YcO659P7118Dvfkd/X3dd/83nTMPHRzHirriC5EBk5KDRBcKw8yaMGEEuaMbIY+HrC1x8cX/P6syCGzFtbfT+u995f4kHNdLStMZ8UBDw61/323T6BVyRNTfT+xVXDIq8GhnDhilh1/p6ICQEuPrq/p3TmQZf1HCsXDl4PJYA5ZJdconyv68v8cFgwvXX03tdHb1fffWgkQMD1rDLy8vDBRdcgKioKERHR2P58uVoaGjo72kNfKxeTWUfjEbgww+VptiDBXPmkLfSaKSaVX/8Y3/P6Mzj4YeBmBhS6A8/TO+DCZmZwB/+QH+fey7dg8GGd9+lTiN6PfCf/wAJCf09ozOLqVOB22+nzUTJycCdd/b3jM48/v53SkuIiiIaiIjo7xmdWSxcCDz+OP09Zw7w5JP9O58zCB1jts1FBwZ27dqFo0eP4qKLLoKPjw9uuOEGBAcH4/XXX3fp+83NzQgNDUVTUxNCBptia26mrd0xMf09k/4D91h6ezFOAcdgjEJwCQlKruFgQ1cX5Zl5ecPzXmGxkHE7WGmgtZUWuYOhKoAzHD9OdU5/4d46d2yaAWvY2eL777/Hvffei2x1VX0VOjs70dnZKf/f3NyMxMTEwWnYCQgICAgICHgN3DHsBmwo1hY//fQTxvbSPWDVqlUIDQ2VX4mDLQQpICAgICAgMOjxi/DYHThwAAsXLsSWLVucGne2HrumpiYkJSWhtLRUeOwEBAQEBAQEfrHgUcjGxkaEhob2fjLrJyxevJj5+fk5fD366KPyeYWFhSwhIYF9+umnbo1fWlrKAIiXeImXeImXeImXeHnFq7S0tE/7Z0B77CorKzF79mzcf//9uPnmm936rtVqRXl5OYKDg6H7GRNnuRUtPIMDD+LZDEyI5zJwIZ7NwIV4NgMTZ+q5MMbQ0tKCuLg46PtojzhgO080NTXhnHPOwXXXXee2UQcAer0eCWdwi39ISIhgtgEK8WwGJsRzGbgQz2bgQjybgYkz8Vz6DMFKGLCbJz777DMcOnQITz75JIKCguSXgICAgICAgICAYwxYw+76668HYwxms1nzEhAQEBAQEBAQcIwBa9j9UuDn54eHHnoIfoOpbdUvBOLZDEyI5zJwIZ7NwIV4NgMTA/G5DOjNEwICAgICAgICAq5DeOwEBAQEBAQEBLwEwrATEBAQEBAQEPASCMNOQEBAQEBAQMBLIAw7AQEBAQEBAQEvgTDsTgE1NTVYsmQJTCYT0tPTsX79+v6e0qDFQw89hDFjxkCv1+P999/XfPbEE08gOjoaERERuP/++yH2C505dHZ24oYbbkBCQgJCQ0Mxf/58ZGdny5+LZ9O/uPnmmzF06FCEhIRg/Pjx+Oqrr+TPxLPpf2zfvh16vR5PPPGEfEw8l/7F/Pnz4e/vL9fWPe+88+TPBsyzcasBq4AGl19+ObvxxhtZa2sr+/TTT1l4eDirr6/v72kNSrz77rvsu+++Y5mZmey9996Tj3/99dcsKSmJHT9+nJWXl7PRo0ez119/vR9nOrhgNpvZI488wkpLS1lPTw97+umnWUpKCmNMPJuBgNzcXNbR0cEYY2zXrl0sNDSU1dfXi2czAGCxWFhmZibLyMhgq1atYowJnhkImDdvnkbHcAykZyM8dh7CbDbj888/xyOPPAKTyYSLL74Y48aNw5dfftnfUxuUWL58ORYvXgx/f3/N8XfffRe33347UlJSMHToUPz+97/H6tWr+2mWgw+BgYH4v//7PyQkJMBgMOC3v/0tioqKUFdXJ57NAMCoUaPk+ls6nQ4dHR2oqKgQz2YA4D//+Q8yMzMxevRo+Zh4LgMXA+nZCMPOQxQUFCA0NBRDhw6Vj02cOBFHjhzpx1kJ2CInJwfjx4+X/xfPqH+xfft2xMTEIDIyUjybAYLbb78dAQEBmD59Os4991yMGTNGPJt+Rn19PZ577jk8/PDDmuPiuQwM3HnnnYiOjsbixYtx6NAhAAPr2QjDzkOYzWa7hr8hISGi7dkAg+1zEs+o/9DU1IRbbrkFjz/+OADxbAYKXnrpJZjNZnz//feYN28eAPFs+ht/+tOfsHLlSoSHh2uOi+fS/3jyySdRVFSEkpISLF68GOeff77c8nSgPBth2HmIoKAgNDc3a441NzcjKCion2Yk4Ai2z0k8o/5BR0cHLr74YixZsgQrVqwAIJ7NQILBYMCiRYuwfv16fPvtt+LZ9CP279+PXbt24aabbrL7TDyX/kdGRgaCgoIQEBCA+++/H0FBQdi1a9eAejbCsPMQqampaGpqQmVlpXzs4MGDGDt2bD/OSsAWY8aM0ezCFM/ozKOnpwdXXXUV4uLi8NRTT8nHxbMZeLBarTh+/Lh4Nv2IzZs3Iz8/H/Hx8YiNjcUHH3yAxx9/HDfddJN4LgMQej2ZUQPq2fTLlg0vwbJly9jNN9/M2tra2Oeffy52xfYjurq6WHt7O5szZw575513WHt7O7NYLOyrr75iw4YNY4WFhayiooKNHTtW7CI7w/j1r3/Nzj77bNbV1aU5Lp5N/6KlpYWtXr2atbS0sO7ubvbxxx8zf39/dujQIfFs+hGtra2soqJCfl1xxRXswQcfZA0NDeK59DMaGhrYd999xzo6OlhnZyd75plnWExMDGtqahpQz0YYdqeA6upqdt5557GAgACWmprKvv/++/6e0qDF9ddfzwBoXhs3bmSMMfa3v/2NRUZGsrCwMHbfffcxq9Xav5MdRCguLmYAmL+/PwsMDJRfW7ZsYYyJZ9OfMJvNbMGCBSw0NJSFhISwKVOmsE8++UT+XDybgYHrr79eLnfCmHgu/Ynq6mo2depUFhgYyMLDw9mCBQvY3r175c8HyrPRMSaqGwoICAgICAgIeANEjp2AgICAgICAgJdAGHYCAgICAgICAl4CYdgJCAgICAgICHgJhGEnICAgICAgIOAlEIadgICAgICAgICXQBh2AgICAgICAgJeAmHYCQgICAgICAh4CYRhJyAgICAgICDgJRCGnYCAwKBGSUkJoqKiftbfKC4uhk6nQ1BQED777LNez/3f//6HoKAg6HQ6TS9qAQEBAVcgOk8ICAh4PYKCguS/W1tbYTKZoNPpAAA5OTlISkr6WX+/uLgYo0aNQkdHh8vf0el0qKioQGxs7M84MwEBAW+DT39PQEBAQODnhtlslv/29/fHkSNHMHz48P6bkICAgMDPBBGKFRAQGNQoLi6Gv7+//L9Op8PLL7+MpKQkREVF4YMPPsBXX32FlJQUDBkyBB988IF8bn19Pa655hoMGTIEKSkpePvtt13+3R07dmDy5MkIDg5GbGwsnnnmmdN6XQICAoMTwmMnICAgYINt27YhPz8fX375JW699VYsXboUhw8fxvr167FixQosW7YMBoMB1157LcaNG4fS0lIUFRXhrLPOwqRJkzBx4sQ+f2PlypW47777cM0116ChoQHFxcU//4UJCAh4PYTHTkBAQMAG999/P/z9/XHppZeisbERt99+O0wmEy688EK0tLSgvLwclZWV+PHHH/G3v/0Nfn5+GDVqFK655hp88sknLv2G0WhEXl4e6uvrER4ejsmTJ//MVyUgIDAYIAw7AQEBARsMGTIEAGAwGGA0GhEdHS1/5u/vj9bWVpSUlKC1tRWRkZEICwtDWFgYXnnlFVRVVbn0G6+99hpyc3MxcuRIzJw5E9u3b/9ZrkVAQGBwQYRiBQQEBDxAfHw8wsLCUFdX59H309PT8eGHH6Knpwf//ve/sXz5chw/fvw0z1JAQGCwQXjsBAQEBDxAfHw8pk+fjr/85S9oa2tDT08P9u3bh5ycHJe+v2bNGtTV1cHHxwfBwcEwGAw/84wFBAQGA4RhJyAgIOAh1qxZgxMnTsg7ZleuXIn29naXvrt27Vqkp6cjODgYzz//PN58882febYCAgKDAaJAsYCAgMDPjBMnTmDUqFHw8/PDO++8g6VLlzo995NPPsGKFSvQ0dGBEydOICYm5gzOVEBA4JcOYdgJCAgICAgICHgJRChWQEBAQEBAQMBLIAw7AQEBAQEBAQEvgTDsBAQEBAQEBAS8BMKwExAQEBAQEBDwEgjDTkBAQEBAQEDASyAMOwEBAQEBAQEBL4Ew7AQEBAQEBAQEvATCsBMQEBAQEBAQ8BIIw05AQEBAQEBAwEsgDDsBAQEBAQEBAS/B/wNBslcF5GmZ+gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "T = np.linspace(0, 50, 500)\n", + "U1 = np.cos(T)\n", + "U2 = np.sin(3 * T)\n", + "\n", + "resp1 = ct.forced_response(sys, T, U1)\n", + "resp2 = ct.forced_response(sys, T, U2)\n", + "resp3 = ct.forced_response(sys, T, U1 + U2)\n", + "\n", + "# Plot the individual responses\n", + "resp1.sysname = 'U1'; resp1.plot(color='b')\n", + "resp2.sysname = 'U2'; resp2.plot(color='g')\n", + "resp3.sysname = 'U1 + U2'; resp3.plot(color='r');" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show that the system response is linear\n", + "out = resp3.plot()\n", + "axs = ct.get_plot_axes(out)\n", + "axs[0, 0].plot(resp1.time, resp1.outputs[0] + resp2.outputs[0], 'k--')\n", + "axs[1, 0].plot(resp1.time, resp1.outputs[1] + resp2.outputs[1], 'k--')\n", + "axs[2, 0].plot(resp1.time, resp1.inputs[0] + resp2.inputs[0], 'k--');" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show that the forced response from non-zero initial condition is not linear\n", + "X0 = [1, 0, 0, 0]\n", + "resp1 = ct.forced_response(sys, T, U1, X0=X0)\n", + "resp2 = ct.forced_response(sys, T, U2, X0=X0)\n", + "resp3 = ct.forced_response(sys, T, U1 + U2, X0=X0)\n", + "\n", + "out = resp3.plot()\n", + "axs = ct.get_plot_axes(out)\n", + "axs[0, 0].plot(resp1.time, resp1.outputs[0] + resp2.outputs[0], 'k--')\n", + "axs[1, 0].plot(resp1.time, resp1.outputs[1] + resp2.outputs[1], 'k--')\n", + "axs[2, 0].plot(resp1.time, resp1.inputs[0] + resp2.inputs[0], 'k--');" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mo7hpvPQkKke" + }, + "source": [ + "### Frequency response" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Manual computation of the frequency response\n", + "resp = ct.input_output_response(sys, T, np.sin(1.35 * T))\n", + "\n", + "out = resp.plot(plot_inputs='overlay', legend_loc='lower left')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "muqeLlJJ6s8F" + }, + "source": [ + "The magnitude and phase of the frequency response is controlled by the transfer function,\n", + "\n", + "$$\n", + "G(s) = C (sI - A)^{-1} B + D\n", + "$$\n", + "\n", + "which can be computed using the `ss2tf` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": u to q1\n", + "Inputs (1): ['u[0]']\n", + "Outputs (1): ['q1']\n", + "\n", + "\n", + " 4\n", + "-------------------------------------\n", + "s^4 + 0.2 s^3 + 8.01 s^2 + 0.8 s + 12\n", + "\n", + ": u to q2\n", + "Inputs (1): ['u[0]']\n", + "Outputs (1): ['q2']\n", + "\n", + "\n", + " 2 s^2 + 0.2 s + 8\n", + "-------------------------------------\n", + "s^4 + 0.2 s^3 + 8.01 s^2 + 0.8 s + 12\n", + "\n" + ] + } + ], + "source": [ + "# Create SISO transfer functions, since we don't have slycot\n", + "G1 = ct.ss2tf(sys[0, 0], name='u to q1')\n", + "G2 = ct.ss2tf(sys[1, 0], name='u to q2')\n", + "print(G1)\n", + "print(G2)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "G1(1.35j)=(3.3300564744031984-2.706863274436471j)\n", + "Gain: 4.291431568743418\n", + "Phase: -0.6825322008139448 ( -39.106214488414615 deg)\n" + ] + } + ], + "source": [ + "# Gain and phase for the simulation above\n", + "from math import pi\n", + "val = G1(1.35j)\n", + "print(f\"{G1(1.35j)=}\")\n", + "print(f\"Gain: {np.absolute(val)}\")\n", + "print(f\"Phase: {np.angle(val)}\", \" (\", np.angle(val) * 180/pi, \"deg)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "G1(0)=(0.3333333333333333+0j)\n", + "Final value of step response: 0.33297541813724874\n" + ] + } + ], + "source": [ + "# Gain and phase at s = 0 (= steady state step response)\n", + "print(f\"{G1(0)=}\")\n", + "print(\"Final value of step response:\", stepresp.outputs[0, 0, -1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "I9eFoXm92Jgj" + }, + "source": [ + "The frequency response across all frequencies can be computed using the `frequency_response` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "freqresp = ct.frequency_response(sys)\n", + "out = freqresp.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pylQb07G2cqe" + }, + "source": [ + "By default, frequency responses are plotted using a \"Bode plot\", which plots the log of the magnitude and the (linear) phase against the log of the forcing frequency.\n", + "\n", + "You can also call the Bode plot command directly, and change the way the data are presented:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out = ct.bode_plot(sys, overlay_outputs=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "I_LTjP2J6gqx" + }, + "source": [ + "Note the \"dip\" in the frequency response for y[1] at frequency 2 rad/sec, which corresponds to a \"zero\" of the transfer function.\n", + "\n", + "This dip becomes even more pronounced in the case of low damping coefficient $c$:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out = ct.frequency_response(\n", + " coupled.linearize([0, 0, 0, 0], [0], params={'c': 0.01})\n", + ").plot(overlay_outputs=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c7eWm8LCGh01" + }, + "source": [ + "## Additional resources\n", + "* [Code for FBS2e figures](https://fbswiki.org/wiki/index.php/Category:Figures): Python code used to generate figures in FBS2e\n", + "* [Python-control documentation for plotting time responses](https://python-control.readthedocs.io/en/0.10.0/plotting.html#time-response-data)\n", + "* [Python-control documentation for plotting frequency responses](https://python-control.readthedocs.io/en/0.10.0/plotting.html#frequency-response-data)\n", + "* [Python-control examples](https://python-control.readthedocs.io/en/0.10.0/examples.html): lots of Python and Jupyter examples of control system analysis and design\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From d459569267d5a47de0b78465cdc280916d4a95a1 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 29 Jun 2024 13:40:01 -0700 Subject: [PATCH 11/12] add show_legend processing --- control/tests/timeplot_test.py | 33 +++++++++++++++++ control/timeplot.py | 22 ++++++++++- examples/cds110_lti-systems.ipynb | 59 +++++++++++++++--------------- examples/springmass-coupled.png | Bin 0 -> 58410 bytes 4 files changed, 82 insertions(+), 32 deletions(-) create mode 100644 examples/springmass-coupled.png diff --git a/control/tests/timeplot_test.py b/control/tests/timeplot_test.py index e351d02af..0fcc159be 100644 --- a/control/tests/timeplot_test.py +++ b/control/tests/timeplot_test.py @@ -588,6 +588,39 @@ def test_errors(): match="(has no property|unexpected keyword)"): stepresp.plot(unknown=None) + +def test_legend_customization(): + sys = ct.rss(4, 2, 1, name='sys') + timepts = np.linspace(0, 10) + U = np.sin(timepts) + resp = ct.input_output_response(sys, timepts, U) + + # Generic input/output plot + out = resp.plot(overlay_signals=True) + axs = ct.get_plot_axes(out) + assert axs[0, 0].get_legend()._loc == 7 # center right + assert len(axs[0, 0].get_legend().get_texts()) == 2 + assert axs[1, 0].get_legend() == None + plt.close() + + # Hide legend + out = resp.plot(overlay_signals=True, show_legend=False) + axs = ct.get_plot_axes(out) + assert axs[0, 0].get_legend() == None + assert axs[1, 0].get_legend() == None + plt.close() + + # Put legend in both axes + out = resp.plot( + overlay_signals=True, legend_map=[['center left'], ['center right']]) + axs = ct.get_plot_axes(out) + assert axs[0, 0].get_legend()._loc == 6 # center left + assert len(axs[0, 0].get_legend().get_texts()) == 2 + assert axs[1, 0].get_legend()._loc == 7 # center right + assert len(axs[1, 0].get_legend().get_texts()) == 1 + plt.close() + + if __name__ == "__main__": # # Interactive mode: generate plots for manual viewing diff --git a/control/timeplot.py b/control/timeplot.py index 6d27be58d..2eb7aec9b 100644 --- a/control/timeplot.py +++ b/control/timeplot.py @@ -50,7 +50,8 @@ def time_response_plot( data, *fmt, ax=None, plot_inputs=None, plot_outputs=True, transpose=False, overlay_traces=False, overlay_signals=False, legend_map=None, legend_loc=None, add_initial_zero=True, label=None, - trace_labels=None, title=None, relabel=True, **kwargs): + trace_labels=None, title=None, relabel=True, show_legend=None, + **kwargs): """Plot the time response of an input/output system. This function creates a standard set of plots for the input/output @@ -131,6 +132,10 @@ def time_response_plot( relabel : bool, optional By default, existing figures and axes are relabeled when new data are added. If set to `False`, just plot new data on existing axes. + show_legend : bool, optional + Force legend to be shown if ``True`` or hidden if ``False``. If + ``None``, then show legend when there is more than one line on an + axis or ``legend_loc`` or ``legend_map`` have been specified. time_label : str, optional Label to use for the time axis. trace_props : array of dicts @@ -565,6 +570,9 @@ def _make_line_label(signal_index, signal_labels, trace_index): legend_map = np.full(ax_array.shape, None, dtype=object) if legend_loc == None: legend_loc = 'center right' + else: + show_legend = True if show_legend is None else show_legend + if transpose: if (overlay_signals or plot_inputs == 'overlay') and overlay_traces: # Put a legend in each plot for inputs and outputs @@ -611,6 +619,14 @@ def _make_line_label(signal_index, signal_labels, trace_index): else: # Put legend in the upper right legend_map[0, -1] = legend_loc + else: + # Make sure the legend map is the right size + legend_map = np.atleast_2d(legend_map) + if legend_map.shape != ax_array.shape: + raise ValueError("legend_map shape just match axes shape") + + # Turn legend on unless overridden by user + show_legend = True if show_legend is None else show_legend # Create axis legends for i in range(nrows): @@ -621,7 +637,9 @@ def _make_line_label(signal_index, signal_labels, trace_index): labels = _make_legend_labels(labels, plot_inputs == 'overlay') # Update the labels to remove common strings - if len(labels) > 1 and legend_map[i, j] != None: + if show_legend != False and \ + (len(labels) > 1 or show_legend) and \ + legend_map[i, j] != None: with plt.rc_context(rcParams): ax.legend(labels, loc=legend_map[i, j]) diff --git a/examples/cds110_lti-systems.ipynb b/examples/cds110_lti-systems.ipynb index e9d5c2c95..2f28f06c9 100644 --- a/examples/cds110_lti-systems.ipynb +++ b/examples/cds110_lti-systems.ipynb @@ -32,16 +32,12 @@ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", - "try:\n", - " import control as ct\n", - " print(\"python-control version:\", ct.__version__)\n", - "except ImportError:\n", - " # Version 0.10.0 is enough for this notebook\n", - " !pip install control\n", - " import control as ct" + "import control as ct\n", + "print(\"python-control version:\", ct.__version__)" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": { "id": "qMVGK15gNQw2" @@ -51,7 +47,7 @@ "\n", "Consider the spring mass system below:\n", "\n", - "\n", + "\n", "\n", "We wish to analyze the time and frequency response of this system using a variety of python-control functions for linear systems analysis.\n", "\n", @@ -395,7 +391,7 @@ "id": "F8KxXwqHWFab" }, "source": [ - "Note that by default the inputs are not included in the step response (since they are a bit boring), but you can change that:" + "Note that by default the inputs are not included in the step response plot (since they are a bit boring), but you can change that:" ] }, { @@ -576,7 +572,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -589,7 +585,10 @@ "# Manual computation of the frequency response\n", "resp = ct.input_output_response(sys, T, np.sin(1.35 * T))\n", "\n", - "out = resp.plot(plot_inputs='overlay', legend_loc='lower left')" + "out = resp.plot(\n", + " plot_inputs='overlay', \n", + " legend_map=np.array([['lower left'], ['lower left']]),\n", + " label=[['q1', 'u[0]'], ['q2', None]])" ] }, { @@ -618,18 +617,15 @@ "text": [ ": u to q1\n", "Inputs (1): ['u[0]']\n", - "Outputs (1): ['q1']\n", + "Outputs (2): ['q1', 'q2']\n", "\n", "\n", + "Input 1 to output 1:\n", " 4\n", "-------------------------------------\n", "s^4 + 0.2 s^3 + 8.01 s^2 + 0.8 s + 12\n", "\n", - ": u to q2\n", - "Inputs (1): ['u[0]']\n", - "Outputs (1): ['q2']\n", - "\n", - "\n", + "Input 1 to output 2:\n", " 2 s^2 + 0.2 s + 8\n", "-------------------------------------\n", "s^4 + 0.2 s^3 + 8.01 s^2 + 0.8 s + 12\n", @@ -638,11 +634,9 @@ } ], "source": [ - "# Create SISO transfer functions, since we don't have slycot\n", - "G1 = ct.ss2tf(sys[0, 0], name='u to q1')\n", - "G2 = ct.ss2tf(sys[1, 0], name='u to q2')\n", - "print(G1)\n", - "print(G2)" + "# Create SISO transfer functions, in case we don't have slycot\n", + "G = ct.ss2tf(sys, name='u to q1')\n", + "print(G)" ] }, { @@ -654,17 +648,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "G1(1.35j)=(3.3300564744031984-2.706863274436471j)\n", - "Gain: 4.291431568743418\n", - "Phase: -0.6825322008139448 ( -39.106214488414615 deg)\n" + "G(1.35j)=array([[3.33005647-2.70686327j],\n", + " [3.80831226-2.72231858j]])\n", + "Gain: [[4.29143157]\n", + " [4.681267 ]]\n", + "Phase: [[-0.6825322 ]\n", + " [-0.62061375]] ( [[-39.10621449]\n", + " [-35.55854848]] deg)\n" ] } ], "source": [ "# Gain and phase for the simulation above\n", "from math import pi\n", - "val = G1(1.35j)\n", - "print(f\"{G1(1.35j)=}\")\n", + "val = G(1.35j)\n", + "print(f\"{G(1.35j)=}\")\n", "print(f\"Gain: {np.absolute(val)}\")\n", "print(f\"Phase: {np.angle(val)}\", \" (\", np.angle(val) * 180/pi, \"deg)\")" ] @@ -678,14 +676,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "G1(0)=(0.3333333333333333+0j)\n", + "G(0)=array([[0.33333333+0.j],\n", + " [0.66666667+0.j]])\n", "Final value of step response: 0.33297541813724874\n" ] } ], "source": [ "# Gain and phase at s = 0 (= steady state step response)\n", - "print(f\"{G1(0)=}\")\n", + "print(f\"{G(0)=}\")\n", "print(\"Final value of step response:\", stepresp.outputs[0, 0, -1])" ] }, @@ -768,7 +767,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHbCAYAAABGPtdUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACumElEQVR4nOzdd3gU1frA8e9syaYnJAESktADSAcBBaUpRUEBCxYsYLsWrGDjqhewXDvq9YL32ssVC1ZEfkqRIipFBASkQ6gJhJIsm7LZ3ZnfH5ssCSlkk93M7ub9PE+e7M7Me+bdsxw4zJlzRtE0TUMIIYQQQgQ9g94JCCGEEEII35COnRBCCCFEiJCOnRBCCCFEiJCOnRBCCCFEiJCOnRBCCCFEiJCOnRBCCCFEiJCOnRBCCCFEiJCOnRBCCCFEiJCOnRBCCCFEiJCOnRAiqEyYMIExY8b4/TyKovDNN9/4vFxN0/jb3/5GQkICiqKwfv16n5/DHyZMmICiKF7XS2Zmpieue/fufstPCOEmHTshhM+V7QQoikJiYiIXXXQRf/75p96p+U1NO5w//PAD77//PvPmzSMrK4vOnTv7Pzkfueiii8jKyuLiiy/2bGvZsmW571pRFB599FHP/vT0dLKyspg8ebIeKQvR4EjHTgjhF6WdgKysLBYvXozJZOKSSy7ROy3d7dq1i5SUFPr160dycjImk8nrMjRNw+l0+iG76lksFpKTk7FYLOW2P/nkk57vOisri8cff9yzz2g0kpycTHR0dH2nK0SDJB07IYRflHYCkpOT6d69O4888gj79+8nJyfHc8zGjRu54IILiIiIIDExkb/97W/YbDbPfpfLxaRJk4iPjycxMZGHH34YTdPKnUfTNF544QVat25NREQE3bp144svvqg2t5YtW/LUU08xbtw4oqOjadasGa+//nq1MdXlOm3aND744AO+/fZbz1WrpUuXVihjwoQJ3HPPPezbtw9FUWjZsiUAdrude++9lyZNmhAeHs7555/PmjVrPHFLly5FURR+/PFHevXqhcVi4eeff65QfnFxMXfffTcpKSmEh4fTsmVLnn32WQBuvvnmCh1rp9NJcnIy7777LgBffPEFXbp08XzGIUOGkJ+fX229AMTExHi+a+nECaEv6dgJIfzOZrPx8ccf07ZtWxITEwEoKCjgoosuolGjRqxZs4Y5c+awaNEi7r77bk/cyy+/zLvvvss777zDihUrOH78OF9//XW5sh9//HHee+893njjDTZv3swDDzzA9ddfz7Jly6rN6cUXX6Rr16788ccfTJkyhQceeICFCxdWeuyZcn3wwQe56qqryl2l7NevX4VyXnvtNZ588knS0tLIysrydN4efvhhvvzySz744AP++OMP2rZty/Dhwzl+/Hi5+Icffphnn32WLVu20LVr1wrl/+tf/2Lu3Ll8/vnnbNu2jf/973+ezuOtt97KDz/8QFZWluf4+fPnY7PZuOqqq8jKyuLaa6/l5ptvZsuWLSxdupTLL7+8Qke6Ms8//zyJiYl0796dZ555huLi4jPGCCH8RBNCCB8bP368ZjQataioKC0qKkoDtJSUFG3t2rWeY958802tUaNGms1m82z7/vvvNYPBoGVnZ2uapmkpKSnac88959nvcDi0tLQ0bfTo0ZqmaZrNZtPCw8O1X3/9tdz5b7nlFu3aa6+tMr8WLVpoF110UbltV199tXbxxRd73gPa119/XeNcx48f78mrOq+88orWokULz3ubzaaZzWbt448/9mwrLi7WmjVrpr3wwguapmnakiVLNED75ptvqi37nnvu0S644AJNVdVK93fs2FF7/vnnPe/HjBmjTZgwQdM0TVu7dq0GaJmZmZXGVvX5ZsyYoS1dulTbsGGD9tZbb2lJSUnaLbfcUuG4qVOnat26das2fyFE3ckVOyGEXwwePJj169ezfv16Vq1axbBhw7j44ovZu3cvAFu2bKFbt25ERUV5Ys477zxUVWXbtm3k5eWRlZVF3759PftNJhO9evXyvP/rr78oKipi6NChREdHe34+/PBDdu3aVW1+Zcstfb9ly5ZKjz1TrnWxa9cuHA4H5513nmeb2WymT58+FfIp+9krM2HCBNavX0/79u259957WbBgQbn9t956K++99x4AR44c4fvvv+fmm28GoFu3blx44YV06dKFsWPH8tZbb3HixIkz5v/AAw8wcOBAunbtyq233sp//vMf3nnnHY4dO1ajzy+E8C3p2Akh/CIqKoq2bdvStm1b+vTpwzvvvEN+fj5vvfUW4L43TlGUSmOr2n46VVUB+P777z2dyPXr1/PXX3+d8T47b87ri1yropUMdZ5eTmXnLNuxrEzPnj3Zs2cPTz31FIWFhVx11VVceeWVnv033ngju3fv5rfffvMM0/bv3x9wT3JYuHAh//d//0fHjh15/fXXad++PXv27PHq85x77rkA7Ny506s4IYRvSMdOCFEvFEXBYDBQWFgIQMeOHVm/fn25m/N/+eUXDAYD7dq1Iy4ujpSUFFauXOnZ73Q6Wbt2red9x44dsVgs7Nu3z9OJLP1JT0+vNp+y5Za+79ChQ6XHnilXgLCwMFwuVw1r45S2bdsSFhbGihUrPNscDge///47Z511ltflxcbGcvXVV/PWW2/x2Wef8eWXX3ru1UtMTGTMmDG89957vPfee9x0003lYhVF4bzzzmP69OmsW7eOsLCwCvc0nsm6desASElJ8Tp3IUTdeT/PXgghasBut5OdnQ3AiRMn+Pe//43NZuPSSy8F4LrrrmPq1KmMHz+eadOmkZOTwz333MMNN9xA06ZNAbjvvvt47rnnyMjI4KyzzmLGjBnk5uZ6zhETE8ODDz7IAw88gKqqnH/++VitVn799Veio6MZP358lfn98ssvvPDCC4wZM4aFCxcyZ84cvv/++0qPrUmuLVu25Mcff2Tbtm0kJiYSFxeH2Ww+Yz1FRUVx55138tBDD5GQkEDz5s154YUXKCgo4JZbbqlRXZd65ZVXSElJoXv37hgMBubMmUNycjLx8fGeY2699VYuueQSXC5XufpZtWoVixcvZtiwYTRp0oRVq1aRk5NTbefyt99+Y+XKlQwePJi4uDjWrFnDAw88wKhRo2jevLlXuQshfEM6dkIIv/jhhx88V21iYmLo0KEDc+bMYdCgQQBERkby448/ct9999G7d28iIyO54oormDFjhqeMyZMnk5WVxYQJEzAYDNx8881cdtll5OXleY556qmnaNKkCc8++yy7d+8mPj6enj178ve//73a/CZPnszatWuZPn06MTExvPzyywwfPrzSY2uS62233cbSpUvp1asXNpuNJUuWeD7rmTz33HOoqsoNN9zAyZMn6dWrFz/++CONGjWqUXyp6Ohonn/+eXbs2IHRaKR3797Mnz8fg+HU4MyQIUNISUmhU6dONGvWzLM9NjaW5cuX8+qrr2K1WmnRogUvv/xyucWIT2exWPjss8+YPn06drudFi1acNttt/Hwww97lbcQwncUTavBXHYhhAghLVu25P777+f+++/XO5V6V1BQQLNmzXj33Xe5/PLLaxw3YcIEcnNza/2YtWnTpvHNN98EzSPUhAhWco+dEEI0AKqqcujQIZ544gni4uIYNWqU12XMmzeP6Oho5s2bV+OYffv2ER0dzT//+U+vzyeE8J4MxQohRAOwb98+WrVqRVpaGu+//77XjzJ74YUXPI8K82ZiRLNmzTxX6U5/FJkQwvdkKFYIIYQQIkTIUKwQQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIiQjp0QQgghRIgI2Y7dsmXL6Nu3L+effz6TJk3SOx0hhBBCCL8L2Y5d27ZtWbp0KStWrCA7O5uNGzfqnZIQQgghhF+Z9E7AX1JTUz2vzWYzRqOxxrGqqnLo0CFiYmJQFMUf6QkhhBBC1IimaZw8eZJmzZphMJzhmpwWBP7xj39oZ511lqYoivbJJ5+U23fkyBFtxIgRWkREhNauXTtt0aJF5favXbtWGzFihFfn279/vwbIj/zIj/zIj/zIj/wEzM/+/fvP2IcJiit2GRkZvPbaazzxxBMV9k2cOJFmzZpx9OhRFixYwNixY9m1axeNGjUiOzube++9ly+//NKr88XExADw9ttvM2bMGMxmc43iHA4HCxYsYNiwYWeM8ebYhi7Y6krvfP19fl+XX9fy6hJfm1hp5/4RbHWld77Szv0bG2jt3Gq1kp6e7umfVCcoOnbXX389AM8880y57TabjW+//ZbMzEwiIyMZM2YMM2bM4LvvvuOqq65i3LhxvP766zRt2rTa8u12O3a73fP+5MmTAERGRhIREVHjL8pkMtU4xptjG7pgqyu98/X3+X1dfl3Lq0t8bWKlnftHsNWV3vlKO/dvbKC1c4fDAVCj28MUTdM0v2ThB4MGDeKOO+7gmmuuAWDdunUMHz6cI0eOeI655557iIyMpGXLlkyfPp0OHToA8Oyzz9K3b99Ky502bRrTp0+vsH327NlERkb64ZMIIYQQQtRMQUEB48aNIy8vj9jY2GqPDepZsTabrcIHjI2NxWazceedd5Kdnc3SpUtZunRplZ06gClTppCXl8dLL71E+/btadu2rb9TF0IIIYTwuaAYiq1KdHQ0Vqu13Dar1Up0dLRX5VgsFiwWC5MnT2by5MlYrVbi4uIAGDx4MCZTzarJ6XSyZMmSGsV4c2xDF2x1pXe+/j6/r8uva3l1ia9NrLRz/wi2utI7X2nn/o0NtHZ+el+nOkE9FGuz2UhMTGTv3r0kJycDMGDAAG699VZuvPFGr8ufOXMmM2fOxOVysX37dhmKFUIIIYTuQm4o1uFwUFRUhKqq5V5HR0czatQopk6dSmFhIXPnzmXTpk1ceumleqcshBABSVU1lC1fUrB3td6pCCH8ICiu2E2YMIEPPvig3LYlS5YwaNAgcnJyGD9+PEuXLiUtLY1Zs2YxZMiQOp2vdCh29uzZjBw5Mmgv3YaKYKsrvfOVIRr/xgZ7O9+waDZ9/5gMQMHDWTpnc0og1lV19M5X2rl/YwOtnVutVlJSUmp0xS4oOnb1RYZihRChLmzL51xcNA+Ab7t/APJ0HSECnjdDsdKxq0TZK3ajR4/2akHDhQsXMnTo0BotaFjTYxu6YKsrvfP19/l9XX5dy6tLfG1ig72db3jtKnrZfgLAdv9uLFHV/yNRXwKxrqqjd77Szv0bG2jt3Gq1kpSUFDr32AkhhPCNMEee57Ut75iOmQgh/EGu2JUhQ7FCiFCXsW46HdkFwBctn8bcqLnOGQkhzkSGYutIhmIDS7DVld75yhCNf2ODvZ1n/7Mr6dohALYO+5g2vYfrnJFbINZVdfTOV9q5f2MDrZ3LUKwQQohKRWk2z+vi/BM6ZlI/snZt4M8PJmE7ceTMBwsRAuSKXRkyFCuECGmaxoh1N2NWXAB82+hWaDlA56T8a8QfN2FWXKww9eNYlzv0TkeIWvFmKDbwFwuqRxMnTmTixInlHikWzJduQ0Ww1ZXe+coQjX9jg7md2/OtmNe7PO9TG8fQbcQIHTM6xV91ZV7n/rytXLs4x4efVe/vVtq5f2MDrZ1780gx6didgdls9vqL8iamNuU3VMFWV3rn6+/z+7r8upZXl/iG0s7zCvIo+yRtrTAvIPIqy191pWL0S7l6f7fSzv0bGyjt3JtypWN3Bg6Hw+tjaxLjzbENXbDVld75+vv8vi6/ruXVJb42scHczq3HjpBUdkPh8YDJzV91VfrPoaoYfVq23t+ttHP/xgZaO/embLnHrgy5x04IEcqKs/9ibNZznvcrTOdyrMtdOmbkf6PX3QjATtLZ3OMZnbMRonbkHrtaknvsAlOw1ZXe+cq9N/6NDeZ2/ucP2VDm8bCxJodP7zurC7/V1Tr3L4PRzAi5x0638qWd143cY+dDwTwmH2qCra70zlfuvfFvbDC2c9XmXvIjX7MQpdgJd54MiLzK8mVdlR2QUhW5xy4Qypd2XjvelCvr2AkhRENx8jAAB03up01EuE7qmY3f2YsKPa9VxahjJkLUH7lidwbBfLNlqAi2utI7X7mp2r+xwdzOlYIcAHJj2kLuDhqpudjtxRgMis6Z+aeuck8cJbnktYpBJk/oWL6087qRyRO1JJMnhBChrMWG5+mububL2PFcYf0AgE87/JeIiAidM/OPwrwcrtk9GYAttGZ7j2n6JiRELcnkiVqSyROBKdjqSu985aZq/8YGczvP2fAIAC16Xoh16RfEkk/XDi3J6HS2zpn5p652bVwFu92vIwxOmTyhY/nSzutGJk/4UDDfbBlqgq2u9M5Xbqr2b2zQtXPVRWPVPXkiKb0DJ4xJxLryyT92ELP5XH1zK8OXdeWwn3oubphml8kTAVC+tPPakckTwP79++nZsyfh4eE4nU690xFCCF1Zc/ZhxkWxZqRpaitslqYAFOZk6puYHxXn53leWzS7jpkIUX9CtmPXuHFjfvrpJ849N3D+JyqEEHo5tnczAFlKEyLCwyiOawmAenSnjln5l7Pg1PBVJIXVHClE6AjZjl14eDjx8fF6pyGEEAHBtn8TAIctLQEwNWkHQKR1t14p+Z2r6FTHLgI7mrNYx2yEqB9B0bGbOnUqHTt2xGAw8Omnn5bbl5OTw8iRI4mMjKR9+/YsXrxYpyyFECJwaUe2AGCLywAgPr0zAI2L9xKqiyOoReXX6SuwHtMpEyHqT1B07DIyMnjttdfo06dPhX0TJ06kWbNmHD16lOeff56xY8dy4sQJHbIUQojAFZf7l/tFk47uX63dHbt07TBHckN0oWJ7+c9lyz2qUyJC1J+g6Nhdf/31DB06lPDw8HLbbTYb3377LU8++SSRkZGMGTOGzp0789133+mUqRBCBKDifFLt7nvpYjPOA8DSKI18IjApKgd2bdYzO/8pLt+xKzwpV+xE6Avq5U527NhBXFwcKSkpnm3dunVj8+bNFBUVcckll7BhwwaGDx/OtGnT6N+/f6Xl2O127PZTM6bKrhcTzCtVh4pgqyu985UV6f0bG4ztPH/Hb8SjkqUl0KplG08+RyzNaWXfxpFdG3B066Vrjv6oK8NpV+wKTuQEzJ/bQD+/tPPAauch++SJQYMGcccdd3DNNdcA8PPPP3PTTTexc+epWV2PPfYYubm5zJw5s8blTps2jenTp1fYLk+eEEKEgtg93zE4dw6L6EN+j7s925tueZtzi5bzmWkU4V2u1DFD/4jf8G8Gqqs9779OuhNDel8dMxKidrx58kRQDMVWJTo6usJqzFarlejoaK/KmTJlCnl5ebz00ku0b9+etm3b+jJNIYTQVVL+NgAOWcr/3WaLaQNAi+KdqEHzX/yai1HLX7EzOvN1ykSI+hPUQ7EZGRnk5eWRnZ1NcrL7Uc8bNmzg1ltv9aoci8WCxWJh8uTJTJ48udwjxQYPHozJVLNqcjqdLFmypEYx3hzb0AVbXemdr7/P7+vy61peXeJrExt07bw4H/M698SJxr0vZ2C/8zy7XIdT4YP36KLsIqJrHzKS4/TJEf/UVfa6KQDsU1Jprh0kNdbMWUOH+qRsvb9baef+jQ20du7NI8WCYijW4XDgcrkYNmwYt912G2PHjiUsLAyDwcDYsWNJSEjg1VdfZeHChUyYMIFdu3bRqFEjr88zc+ZMZs6cicvlYvv27TIUK4QIeonH1nD+vtfJVJuyrNMLxIcrp3ZqKkPW30kUhbyc+DRtmzfXL1Efc6kweP1dNFJs/Gw8l/6ulfxsGcjxjrfonZoQXgu5odjbbruNiIgIfv75Z2688UYiIiJYvnw5ALNmzWL//v0kJiby4IMP8vnnn9eqUyeEEKEo9uhaAH4x9CzfqQNQDOwLcw/PRuRuq+/U/Crf4aSR4n5W7LFwd4c12pmrY0ZC1I+guGJX30qHYmfPns3IkSOD9tJtqAi2utI7Xxmi8W9sULXzolxMr3cjTCvmvfb/4erRoysccnLpqzRd/TxL1e60v28ucRH6PNDe13X1144d9Pp6AC4MLOv+Chesv4+95tY0fuAXH2Sr/3cr7dy/sYHWzq1WKykpKTW6YicduzJkKFYIEUrSDy+i56EP2aqms7Dd0zSPUSocE1N4gAu2/p0izcyzqf+hZ1N9Ona+dujgHu48MpVjxPN1s4e49dBj5BLNsh6z9E5NCK95MxQb+Jc/6tHEiROZOHFiuckTQ4cOxWyu2V90DoeDhQsX1ijGm2MbumCrK73z9ff5fV1+XcurS3xtYoOmnasuiv71BAA/hA3jrqtGoCgVO3ZoGtaXXiO2+DDhhQcYMWJi/eZZwtd19cMXb8EROBnRjD4XjIL/PUY8NkYM7gsRdb9dR9p5/ZbX0Nu5N5MnguIeOyGEEN5Rts4lJn8vJ7RoTGdfV3mnDkBRUNpfBEC7o4vIPBYaS4K4TuwHwB6VSkrjJA5pCe732Vv1TEsIv5Oh2DJkKFYIEQoU1cmAv6YQ7zjMK44rSOg2mnhL1cc3su1gwI6nsGnh3B/3by5tE1Z/yfpJ8fqPGav9yC8xIzna9mqS1r7AeYZNLGl6C9ZmA/VOTwivyFBsLclQbGAKtrrSO18ZovFvbDC0c8PKmRgdh8nR4tjXbjx3X9av+gBNo/Bf7xNt20/MiQ306v8oTWKq6Qn6gS/ryqVqrFo7AwyQ0b0ffQaM4P+2zIGiTTSPcdF8xIiAyjcQzy/tPLDauQzFCiFEQ3V0B8rSfwLwovMqxg/qfOYYRSGs+9UAjGY57/6S6ccE/W/30XzaKAcAiGvRBYDC2NYAGI/vrDJOiFAgQ7FlyFCsECKYKaqT/jueplHBbpa7uvBi1EPcelbNYqOKshmy5WFUTWFo8Utc170xieH+zddffs8q4qnsvwEwv8ssHKZodu3ayiTrPzmsNGZl95d1zlAI78hQbC3JUGxgCra60jtfGaLxb2zAtnNNwzh/EoaC3eRpkTym3s474wfSKimqxkWony7AsGsRNxh/ZEXhQ7xxeQ8/JlyeL+tq54efAmAzJzF01FUA/N+aVrDgnzTVchgx6ByITAyYfAPx/NLOA6udezMUKx27MzCbzV5/Ud7E1Kb8hirY6krvfP19fl+XX9fy6hIfEu18xauw/iNUFO53TGR4v7NplxLvXRnn3QO7FnGVcRmvbL2Sn7Y3Z3inZH9kW6W61pWmadgPbQbAmdie6JKy0tPS2a6m0s5wEPOh3+GsSwIi30A/v7TzwGjn3pQrHbszcDgcXh9bkxhvjm3ogq2u9M7X3+f3dfl1La8u8bWJDcR2blj5b4yLpwHwjGMc22P78vLAVt6fN60fpiadiTyyiZtMP/Dol43olBxF01j/j8n6qq525+TT1J4JJohI7eQpr2VCOPO1DrTjILbty7C0HR4Q+Qbq+aWdB1Y796ZsuceuDLnHTggRVDSN9tlf0yH7GwBedV7Oq84ruLujSkZc7f5qb3ZiNb0z/00+4Zxf9CqJsdHcdZaKMUim2v14QOGmw0/R27Cddc1vZV/iAM++tetW8iSzOBTWmjWdpumXpBBeknvsaknusQtMwVZXeucr9974NzZg2nlxPsbv7sGQPReAf6ljedV5Gbf3b8V9wzJqX652Edo7y4g6vJF7LfOYbh3Hr450/jmmY9WLHPuAL+pK0zTe+NdSuiq7Aeg88jY6J7Tx7P8jLxx2zyK5OJMRA/tAVJKu+daFtHP/xgZMOy8h99j5UDCPyYeaYKsrvfOVe2/8G6trOz+wFr7+GxzbiWYw8zS38k5Rfwa2a8zDF5+F0VDHDtiQqfDxlYw3/shHhsF88Qc0T4zi3gvr0GGsobrU1Yb9uUQf24jF4kSNbIy5SXso0xlt1aYdG3e2pIshE8PuhdDzRl3z9QVp5/6NDZR/z70pN0gurgshhMB+Ehb+A94ZCsd24opK5k7TdN4p6E+H5Bj+dW2PunfqANoOgTYXYlAdfJTyJaAxY+F2Xl+8o+5l+9FbP++ml2E7AIYW55br1AF0TY/nB1cfALQt39V7fkLUB7lidwbBfLNlqAi2utI7X7mp2r+xurRz1YWyaQ7Gn55EyT8CQF6bUVy1/0q2WU20SozkvfE9iTT58Hsf9k9Mb/Yn9divvN59NPesT+flhduxFhbz4NAMDL7oQJZR17rKPJbP/23K5j2je0asK7UP6mlltWscyROGc3iIz2HnTzhOHIToJrrkW1fSzv0bG2j/nsvkiVqSyRNCiECiaE7Sjv9Gu8NzibYfBsBmacrihHH8fX8v8p0KjcM17uroIsEPTwDrcOgL2h+eS6G5EdPjn+XT/e6btrs0UrkhQ8Vi9P05a+utrQZ2nSjmz/C/YcbJ4rOexRaeWuG4N/4y8GzhNHoYdvJXylh2JF+qQ7ZCeMebyRPSsatE6eSJ2bNnM3r06KC92TJUBFtd6Z2v3FTt39h6aee2Ixg2zMaw7gOUvP0AaBGNcJ17Nx8rI3n6xz04XBpdU2N584aeJEaF1bxsbzgKML01EOXEHtTOY/mi+RM89u1mHC6N1klRvHRlZ7qkxvnmVHX4Hv9vUzb3fvYnw4xredP8Mlp8C5x3/V5hKBbg7RWZ7F70Ji+a30SLa47zrtVg8H7wStp5/ZYXku3cC1arlaSkJJkV6wvBfLNlqAm2utI7X7mp2r+xPm/nzmLYvQTWz4at80B1urdHNYa+d2PtfCNP/N9e5m5wz/i8uHMyL43tRpTFj3+Nm+Pg8jfh3eEYNs3hqrMuoe3tA7nzf2vZfTSfq95czT0XZHDnoDaEmXxzy7a338Weo/k8MXcLABNTd8IRUNoNxxxWeWd3QPsmvPZjX6aYPiEhbx/mv76CHtfVW76+Ju3cv7GB8u+5TJ4oMWnSJPr378+9996rdypCCFGRowi2/whf3wkvtoXZV8Ff37g7dWm9YfQsuO9Pfkq6lmGz/mDuhkMYDQqPjzyLWdf19G+nrlR6Hzj/AffreQ/Qs5GdH+4bwMguKThVjVcWbeeiV5ezZOsR/+dympyTdsa/u5q8Qgdnp0XR1brMvaPDyCpjOqbEkhgfz3+cJU+eWP4iuJz1kK0Q9SNkO3Z//PEHNpuNn3/+GYfDwZo1a/ROSQjR0GkaHNkCv82E/10Bz7d0d+Y2zAZ7HkQnQ5/b4Y4VcOsiDrS8jIlfbOXm93/nsNVO66QoPr+9L7f2b+3XNeUqGPgoJHeBwuPw5a00Cjfw73E9eO2a7iRFh7H7aD43vb+G699excrdx6iPO3z2HM3nqv/+xr7jBTRPiOTd83JRinLdddiyf5VxiqIwoksyH7mGctIYByf2wLoP/Z6vEPUlZIdif/vtN4YMGQLAkCFDWLlyJb1799Y5KyFEg+K00yh/B4aVM+HQ77B/NdgOlz8mJgXOGgWdxkD6uWAwYLM7+c+P23jz590UO1UMCtzavzWThrYj3KzDjAVTGFz5Hrw5CDJ/hiXPoAyZyujuqQzu0IR//7ST937Zw4qdR1mx8yhnt2jEDee24KLOyT7PV9M0vll/kKnfbsZa5CQ1PoIPb+5D3E93uQ/ociUYqj/niC4pvPXzHl53jOHvhg9g0XTocClEN/ZprkLoISg6dlOnTmXOnDls3bqV2bNnc80113j25eTkMGHCBJYsWUJ6ejqzZs3iwgsvJDc3lzZt3CuOx8XFsXnzZr3SF0I0BPaTcPgvOLwRsjdB9kZM2X8ywFUM28scZwqHFudBmwug7YXQuIPnJv+8Qgfv/7KLd3/ZQ16he3mDvq0TeeKSjnRsVv0N036XlAGj/gVf3AwrZriHaNtfTGy4mb+POIsbzm3Bf5fv4vPfD7B27wnW7j1B7LcmRnVvxkWdUujTKqFO9+FpmsbK3cd5ddF2Vu05DkCP5vG8eUMvGpuLYPsP7gO7jD1jWd3T40mNj+Cd3CHcnbya2Nwt8OMUuOLtWucnRKCoVceusLCQf/zjH8yZM4fjx49jtVr58ccf2bJlC/fff7+PU4SMjAxee+01nnjiiQr7Jk6cSLNmzTh69CgLFixg7Nix7Nq1i/j4eM8jOKxWK/Hx8T7PSwjRwGga5OeQYNuGsv4E5O6BYzvh8Gb3kN5pFMBuisHc+nwMzc+B9HOgWQ8wR5Q7LiuvkI9+28tHv+3lpN19v1frpCgeubgDwzo2rd9h1+p0vgL2rYLV/4Wvb4fbl0OjlgCkJ0Ty9Jgu3HNBBp+s3sec3w9wMLeQ/63cx/9W7iPaYuK8ton0bN6IrmnxdE6NJSa8+hvCixwuNuzP5dddx/h2/UEyjxUAEGY0cO+Fbbl9YBvMRgOseh+cRe5Ockq3M34MRVG4pGsK/12+m1fCJzJVuRc2zoG2Q6Hb1XWtJSF0VauO3V133YXD4WDevHn07+++l6Fr167cd999funYXX/99QA888wz5bbbbDa+/fZbMjMziYyMZMyYMcyYMYPvvvuOvn378t///perrrqKRYsWMWHChCrLt9vt2O12z/uyz2QL5gUNQ0Ww1ZXe+crCpXWI1TSwWyHvAIr1AEreQbAecC85cmIPyvFdmO0n6Q9QyUMYtOhktKad0Zp2QmvSCUdSJxb8vpOhw4aVn9XmcKCqGr/uPs7s1ftZvPUIasltaRlNorhrYGsu7pyM0aDgdAbYjf0XTMV44HcMh9aifXIdzgnzwXxqvc+ECCMTB7bizv4t+XX3ceZtzGLZ9qMctRXz4+bD/Lj51FB0QpSZtPgIGkWGYTEpHD1i4Jtjf1DgcHEot4iDuYWeegGIDDMyulsKdw5sTUpcOKguHC4nptVvoQCunjeh1rC+ruzp7ti9vzeBe8+7l0a/v4o27wGcTTpDUrszxks7r9/yZIFiPy9Q3KRJE/bv34/FYiEhIYHjx92XxePi4sjLy/O2uBobNGgQd9xxh2codt26dQwfPpwjR07NxrrnnnuIjIzk+eef5/7772ft2rV069aNf//731WWO23aNKZPn15huyxQLESI0FTMrnzCHXlYnFYsjlwsTmvJ+zwsjjwiHMeJKD6GWS2qvigUCsISybckY7Mkk29JxhqRijWiOcWmmDOmcrgQ1h41sPaowtGiU1fi2saqDEjW6JKg4eOHOvhcePExBm37BxbnSfY36scfLW6vdM24UqoG+/Nhe57CPpv7J7e4Zh8yxqzRNlajYyONbglahUWRk05u5rydz+MwhLOg82s4jRGVF1SJWX8Z2JZnYGiKk386nqWxbQv5YY35ud0/sJt9sz6fEL7gzQLFtbpiFx8fT05ODmlpaZ5te/bsoVmzZrUprtZsNluFDxgbG0tubi4Ar776ao3KmTJlCpMmTfK8t1qtpKenAzB48GBMpppVk9PpZMmSJTWK8ebYhi7Y6krvfP19fl+X71V5mgrFBSj2PCjKRSnMRc0/xvYNK+nQIhljsRWl6IRnn1KUC4XHUQqOoqg1v/KlRSSgxaaixqahxaaixaSiNWqB2qg1juhUlvz8G4MHDya6hu28bfdz+WnHCeZvOsyWbJtnf7TFyOhuyVx9diptG0fVOL9AoHVpjvbZVaSf+JWmPS7C2es2r+KtRQ4O5hZxKK8Ia6GTfLuDv7Zup2vH9sREhNEkOoyWiZEkRYdVOxRt+fIj94tu1zJ46CivclDSc7j38038nheB8bZPUT8bTVRuJkOPvo39mq8grOr/2Es7r9/y6hJfm9hA+/e87EjimdTqit3MmTN5++23eeyxx7jlllv4+OOPefrpp7npppu4/fbbvS2uxry9YucteaSYED6iqRg1Bwa1GKPnx4FRs7t/l2wzqUWYXEUlvwsxqYWnvT99vx2F2i+lUWyMwm6Oo8gUh90Uh90cW/I7jkJzAoVhiRSGJeAy1O35XC4Vdp9U2HxC4a9chcOFpzomBkWjQ5zG2Unuq3OB9Fgub7U+8gNdDs5GxcCvbR/lWEyHej1/bME+Bm97HA2FxWc9T354slfxLg2eWWfkmF3h8pYuRjTKov/2J7G4bByNbs+q1pO8ugIohL/4/YrdxIkTadKkCe+88w5paWn861//4oEHHuDqq+v3ptOMjAzy8vLIzs4mOdndoDds2MCtt95ar3kIUW80FUVTMeBCKXmtaC4UTr02lHmtaCoGzen5UTQnRs2JopZuc5Xbb1Cd7jLKbivZfuq9C4N2qnNmUB0YVTvGMtuMmn/vO1IVI8XGaIpN0TiMURQbo3CYSn9Hn/Y7iiJTHMWmWFSDf1aFVzU4VAA78hR2WRV2WhUKXeU7c21iNHokaXRP0IgKngeoVGt34+HEF+wh/cRv9M58naXtn6QoLLHezp9x+DsADsaf43WnDsCowAXNVObsMfLTIQPnNU1mZZvJ9Nv1Ikm2bfTd+QIr2zyIwxRcV1NFwxYUz4p1OBy4XC6GDRvGbbfdxtixYwkLC8NgMDB27FgSEhJ49dVXWbhwIRMmTGDXrl00atSo1ucr+6zYkSNH+uXSrbZvJet/X0X37j0wGg1QehXC83Vo5V979mnlNpU9TqkspspyOO21VvNzV1lOzT6DUll8pZ/R/Vt1udixYzsZGRkYSm8+Kj1Owz08h+r+rWme34qmltmnnba/dJ9WYZtSxXb38VTcVrK99Hya6uL4saMkNGpU8llLylGdnt+K6gLN5d522mul7PZyMQF2E30NaQazexaoKRzNFO7+XfKesChUUyQHj50kpUUGhvBYtLBotLBo8PyOQrPElHuPKcJzT5ceQzQ/LFpCUkYPNh8uYO3eXNbuy/PMZi2VEGnm/DaNSLBncdsl59MoOtyr3IKGo4Dwj0dhOLIZV3J37OO+dn+3XvL2u1CO7yL87f4oaBROWIzWpGNtssfudDHsXyvJsRUzdWQ7rj47FSV7A+GfX4NSlIua0Ab75R+iJbSuU76+JkOx/o0NxKHYlJSUGl2xq3HH7oUXXqjRyR9++OEaHeeNCRMm8MEHH5TbtmTJEgYNGkROTg7jx49n6dKlpKWlMWvWLM/CxN6qz6HY4RvvJdyZ65eyRcOjoaApBlSMoBhQFQMaBjTFiKqYUA0m92/FiKaYcClm9z7P9lP73cebPceW228woipmVMWEy2DGZbCgKmZchrDyP8qp1yjB/YAbuwuyC2F/yU3/e20KhwvddV6Wxei+Ktc21v2THk3AT4LwlUh7DgO3/YMwVz57EweyPv3maidT+EL3vW/R4vjPZMX2YHWbB+pU1rIsha8yjcSYNZ7o4cJihNjCfZyzawaRjuMUG6NY0+oejsbUrvMoRF15MxRb447dTTfdVO4EX3/9Neeccw7p6ens37+f1atXc/nll/PJJ5/ULfsAUB9X7MI+HkPhsf1ERkW7/3lQFCj9h8LzF6JS/nWpkm3a6ftPP7bSMk8rv9pjTy+fMnGVxVQ8v3am81f7Wd3bNE3l8OEcmjZtimIwlC9HMZz6KT2+7LYy26mwnXLv3XEln+P0Y6vZrp22XdU0/tqylbM6dsJoNJ2KNxhBMaEZjO7XBhMo5V9rntcG9+8yr7UqtrvLPVUv8j/52sVqioG9xwvZccTGjiP57DiSz/Yj+Rw4UVjpXX1NYsLomhpLt7Q4zmkZT4fkaExl/3z64LMFE8OepVi+uA5FUyke9jzO7jd6Fe9NXSl5+wl/qx+K6qTo+nmozc6uS+oUu1QunbWa/ScKuXNAS+4Z1Mq9w3YEy9cTMGatQ1MMOPs+gKPf/WAw6f7dSjv3b2yDuGJX1hVXXMGNN97I6NGjPdvmzp3Lhx9+yBdffOF9xgFCJk8IEdpcKhyzw9EihZyiU79zihSO20HVKr/KFG3WSIvUaB4NzaM1mkdrxIXVc/JBICP7OzpmzUFVjKzI+DsnojL8cp4u+z+k9dFF5ER35NeMR31S5vpjCu9tN2I2aDze3UV8yfwZg1pMt/3v0/z4CgCORWWwtuWdFIYl+eS8ou4URcFoDOJZSKdxuVwVnrfslyt2ZcXFxXHs2LFyPVOn00liYqJf17GrL2Wv2I0ePbr8wqLVcDgcLFy4kKFDh54xxptjG7pgqyu98/X3+X1dfl3LKxtf5FLIyiskK8+9jEZWXhFZuUVkWYs4VLK0hkut+q+8qDAjGU2jadckmnZNS36aRJMYban0fNLOT6NpGL+6GcPW79Cik3Heshiim9YotMZ1ZTuM6d89UVx2nNd9hdZygI9S17jm7TX8sS+XEZ2b8trV5Z9goWz6AuP/PYhSbEMLi8Yx4O/839FmDB02XNp5PZRXVXx+fj5ZWVkVOkJlaZpGUVER4eHhNX6KizcxtSm/OoqikJKSQlTUqUk7VquVpKQk/82K7dy5M08//TSPP/44JpP7kvQ///lPOnXqVJvihBCiSk6XyvECB0dtdo7aisv8dr8+Yi1i72Ejj/2xHJvddcbyws0GWiRE0jwhkuaNwrFl7+Hi88+mdZNYkmMtgfP4rmCkKLgu+RfK0e0oR7dh/OoWXNd9BUbfXd40rP4PisuOmtoLrUV/n5WrKAr/GNmBK/67ivmbDjO6ew4XtG/s2a91vhJnai+M396J4eAawhb9nf6RbVC6p0PqmR9jJnzP5XKRlZVFVFQUiYmJVbZdTdPIz88nKirKq45dTWNqU351ZR07doysrCxatWpVqyuRtbpit3v3bsaNG8fmzZtp0qQJR44coWPHjnz88ce0bdvW6yQChQzFCuE/muaeiJDvhAInFDiVMq8h36lUeJ3vcB9/+kSF6kSaNBqFQSOLRnwYxFtOvU+0QGxYw5nUoJeooiwGbpuGWS1kd+OhbEy7wSflmpz5DNv8AGa1iJWtH+BwXA+flFvWt3sN/HTIQHyYxt+7uyquM6iptDz6Ex0PfY5ZLULFSGbjC9iWPKZGTx4RvmMymUhOTiYtLQ2LpW5rTwYSu93OgQMHyM7O9jxS0O9DsaX27dtHVlYWKSkpNG/evLbFBBwZig0swVZXeufrq/O7VI0ih4sih4tCh0qhw4XdoWItKGLF6rVknNWFIpeGze4k3+7CZneWe51f8t5md3leVzMKWi2DAglRYSRFhZEUY6FxdBiJ0e7f8RFG9m7dxIjBfUlPjCYyrOYDEbWpK2nnNaNs/wHTHPdzvp3XzkFrPbja42tSV4ZfXsW49Gm0xmfhvG2ZX2ZcFxa7GPHvXzlwopCre6Xx9OjKZ8I6j+/jxOy/0SzvdwA0SyzqeQ+g9r6tVsu9eEuGYqGoqIj9+/fTsmVLwsOrrnNN0zh58iQxMTFeXbGraUxtyq9OUVERmZmZpKenez6X34diS5/0EB4eTqtWrcpta9KkSW2KFEKUoaoaDpdKsUul2KlS7NI8rx2ebSoOl1ZhW1Gxkz+zFA78tg9VU0ri3OUVOd2dtKJiF4UlnbYiZ+l7taQT5/5xuKrrhRlh61+1+mwWk4H4SDPxEWbiIszEhhuxHT9CxzYtSIgOJy7CTFyEiUaRYcRFmGkcE0ajyDCMVVxmczgcLMzeSOukKMzm0J55Gky0dhfh6nUrxt/fxvj9/Thv+xnCq/8HqVqOQgxr/guAq+89fltGJyLMyLNjOnHj+7/z2e8HGJCRyLCOFe8T1GJSWNP6XoZnWLAsfQrlyCaMP03HsPY9XOdPRutyFRgbVmdewPvvv8+UKVO44YYbeOGFF9A0jbvuuovFixcTHx/PJ598Qps2bZg7dy4PPvggZ599ts9XE6nVFTuDwYCiKJ6bFcv2UF2uM9/jEqgCZShW005bCvi0NYk1Tlsb+LRjyy4lTJljT18O+PTtp5dZ1fbTc6ysjMpyqpBDmWNLj1PLlO3+raCWea+Wyd2zvYr3GpSLLVdGFe/VknNWtr3sj6tkv0t1/y633fNaqbBN5dR7V2Vllvz2ZuixPpgNGmEGMBsgzAAWI4QbNcKNeH4splPbLGW3lzkuwghhoTN5TZyB0WVn8NbHiCo+QmbiQDY0v6XWZbXMWUS3Ax9SEJbEoo4voCn+7cTP3Wtg8SEDkSaNR7qemiVbKU0l/fgvnJX1BRGOEwDkhzVme9NL2Z9wvnupIuFzpUOx6enphIUFxjT12bNns337dqZNmwbA//3f/zFnzhzeffddfvzxR2bPnu1Zl3fFihW8++67vPvuu+XKKC4uZv/+/bUeiq3VnzZVVcu9z87O5umnn+acc86pTXEBY+LEiUycONEzFAv4bYim/4vLOGItKlkHrXznSYjTmY0KYUYDYSYDZqOBMKNy6vVp24yKwoljR0hvloLFbCLM5I41Gw2Emw2Em41EmI0lv93vy76OMBuJCDNiMRmIMLt/G8pcLQuGIRp/xspQrHeUbk3ho1G0PLaMtEunoKX2qvS4autKdWKa9TgAlkEPcnHvUf5OmyFOlavfWs2mQ1b+70Rj3ht/NibjqauEFfO9BBxP4Fr7HoaV/yYqP4ce+9+lu3Uhat97ULteA2bfXSiQodhTQ7HR0dG6DMVOmTKFjIwMbrrpJk6ePMmECRM4++yzsVgsns7XTz/9xE033URsbCxXXnklkydP9pQZGRmJ2Wyu0FErKioiIiKCAQMGlBuKrSmf/DciOTmZGTNm0Lp1a264wTc3yQYKs9ns9R/CmsS4r94o5S9h6UApWXdYUZSS3yXbSxYkVjzHKJUeX3bdYkVRKu73lFl2XxXlKWBQFIyGU68NJfttJ08SHx+LseRqsUEBo6JgKBNnMJTGuPe79ykYy2yv6hzu+DKvS441lmxXFDAbDBgNCiaDgtFY8ttgwGRQMJV5j6ayccN6ep3dE4vZhNlYJq7k2MriPPtLfoeZ3J22MKPBq/s2HA4H8+fPZ8SIbn7tTNSmbfizvLrE+6ud16X8kNFmIHS/DtZ/jGnBFLj1JzBUPYxaaV1t+QHy9kFkIsZe4zHWQ12azfCva3twyesrWLnnBK/+tJspI86qPl9zHPS/H875G6x9D355DSVvP8YfHsa47FnodQv0uQ1ivH+ubdV5+vfPViC3c5fL5f73oOTfhUJH5SOGqqpSWOzC5HBhqObPXmUxMVBlzE033cSdd97JzTffTG5uLtu2bWP06NFs27bNE5OVlUV6errnfWJiIidOnCApKcmT9+nll24v+1m9qTOfXR9etWqV55JhKHE4av4w89JjaxIz57azWbZsOQMHDMBsNns6OACU6WQpZTpEJbs4vZNUsuXUcRU6aeU7bsG2nMOp/6n1Cop/HB0OB+aDGhe2S6h7vpqK06me+bjTzl/2t6/5uvy6lleX+NrEehPj7+8iaAx8DNOWuSiH1uFcNxut69UVDqmuroyr38IAuLrfgKqYoZ7qMz3ewnOXdeLez/7kv8t3c1ZyNCO7JJ8xXxQz9PobdLsBw/qP3Uu05GbCzy+h/fIaWucrcPW5A5p2rnVu0s7drzVNQ1VV8u0OOk9bWPdET7Nx6hCiLJX/m9muXTvsdjuZmZl88803XHnllWia5skJ3B3E0p9SpftVVS13bKnS7Q6Hw7PciTf1Vqt77M4666xynYOCggKOHTvGa6+9xs033+xtcQEjUO6xE0KIUNP28Pd0OvQZtrAm/NTxuRrfIxddlMWFWx5BQ2Fhx5cotDQ+c5CPld5vF2bQuL+zi9SoM8eUo6mk5K2lzZEfSMzf4dl8LKodmUmDORTfG9UQGPeIBZOy99i5MNJ3xkqfn+O3SecSUc2Nwe+++y7Hjx9n0aJFvPHGG/z222/l7rG7//77ufjiixk+fDiaptG5c2c2bdqEoiiBdY/df/7zn3Lvo6KiaNeu3RlPFujq8x47ufem5oKtrvTOV+698W+stPNaKh6INusnovOPMCL1JFr368rtrqquDIueAEBrO5TBl42v15RLDVc1bv3oD1bsPMYHe6KYc/s5JEUavfxuLwGm4jy4FsPqN1C2fEdi/nYS87fT88jnqF2vQe1xIyTW7DFs0s7L32NnsVjYNG1opbGapmE7aSM6Jtqre+xsJ200Toirdvh2woQJ9OrViyZNmtC1a1fWrVtX7h67MWPG8NlnnzF27Fjmz5/POeec4+lfBNQ9dmvWrOHBBx+ssH3GjBlMmjSpNkUGLLn3JnAEW13pnW9DvvemPmKlnXvJHA/n3QcLHsf06ytw9g1gqHglpFxdqS7Y/DUAhl43YdCpDs3AzOvO5so3fmXHERu3fbSO2bf0qphvTbQ81/1jzYJ1H8HaD1CsBzCuegPjqjegZX/oOR46jISwM48YNeR2XvYeO6PRSHQVT2lQVRWX3UiUxezVPXYuuxGDwVBtTEJCAl26dGHQoEHl7vcrjRk1ahTz58+nXbt2xMXF8emnn3r2+eseu1otBPTkk09Wuv2ZZ56pTXFCCCEagl63QHg8nMiE7T+c+fi9v4At2x3Tdoifk6teXISZ92/uQ5MYC9sOn2TiJ+vx8vbX8mJTYODDcP+fMO5zaHeRe22+zJ/hq1vh5fbw7d2w91dZNiGAORwOdu7cyeWXX17pfoPBwJtvvsnOnTtZu3YtGRk1uyJbF15dsfv8888BcDqdzJkzp9xDdzMzM0lISPBtdgFAbqrWX7DVld75yk3V/o2Vdl4HihlDjxsw/vY66so3cLUZ5tlVWV0Z/pyDEVA7XIJLU+pt0kRVmkSZeOuGHox7ew0r95ygMM/AULu97gW3usD9k3cAw/r/Ydj4GUrefvcVvXUfocW3QO1yFWqXq6FRS0DaeenrshMRqlLaV6lsokJdYjZs2MDYsWO55ZZbiIuLQ9M0LBYLX3zxBU6nkxdeeKHK8ufOncvf//53+vfvr+/kicGD3Y+E+fnnn+nf/9TDlxVFoUmTJtxzzz2cd955NT55oJHJE0II4V8RxUcZunkyChoLOr5c5WQIRXNy0cZ7CHPl80vbRzga06meM63a1lyFN7cacGkKZyepXN9W9e3zhzWVRNt20o//TGruGkxqkWfX0aj2HGx0Lofie1NsDu772usqEBco9oW6Tp6o1azYp59+mscff7x2GQcBeVZsYAm2utI7X7mp2r+x0s7rzvi/MRj2rsA16DHU8x4AKtaVkvkzpo8vQ4tqjPPeTZXej6enHzdlce/nf6JqCledncpTozqWW8jbZ4rzUbbPx/DnZyh7lqGULH6qKUZyos8i7rybMXQcBRHxPj1tMLRzeVZs5Wo8FHv06FGSkpIA+Nvf/uZ5NuzpQu1ZsXJTdeAItrrSO9+GfFN1fcRKO6+D7tfC3hUYN32BcdDD5XZ56ipzKQBK2yGYLVX/o62X4Z1TuPGP9Xy408jnaw8SHmZi+qhOvl8n1BwPPca5f/IOwqYvYNNXKFnraXJyE/wwCRY8Am0vhE6XQ4cRYInx3ekDuJ2XnTxR3QSH0qHOyiYq+CKmNuVXp94mT7Rq1crzOjk5mZSUFJKTk8v9pKSkeJG6f+3fv5+ePXsSHh4ekgsnCyFE0DrrUjCY4Og2OL678mN2/uT+3ebC+svLSz2SNJ67rDOKAh/+tpdHv9yIS/XjRIe4VPfM4tuX4bhzNVtSrkRr0hFUh3syytd/gxfbwmfXw8YvoCjPf7mIgFXjjt3Jkyc9r1VVxeVylVtRuXRboGjcuDE//fQT5557rt6pCCGEKCs8Dpr3db/evqDiftsROLwRUKDN4HpNzVuX9WjGS1d2w6DAZ7/v575P1+Fw1WW6bA0ltGZ78iicty2Hu1bBwEcgsS04i2DLd/DlLfBCG/jflbD2A7Dl+D8nERDqfs0wQIWHhxMfH693GkIIISqTUTIjdsePFfftX+X+3aQjRCXVX061dMXZafx7XE/MRoV5f2Zxx0drKariuaV+0aQDDP473P073P4znD/JvdCx6oCdC+G7e+HldvDeCFj5BuTur7/cGpj333+fpk2b8tBDDwGwdu1aevVyPw7zhx9OLfEzd+5c2rZtyzXXXOPzHGrVsdu/fz+33XYbffr0oWPHjuV+amvq1Kl07NgRg8HAp59+Wm5fTk4OI0eOJDIykvbt27N48eJan0cIIUQAKO3Y7f0VXKct5XBgjft3Wq/6zakORnRJ4c0be2ExGVi89Qg3vbcGa1E9L8+iKJDSFYZMhXt+h4mr4YLHIaU7aKp7XcAfHoVXO8N/B8LyF+HIVlknz8duuukmXnzxRcB969rbb7/NtddeW+6YUaNG8fbbb/vl/LV68sTVV19NRkYG06dP99lyIBkZGbz22ms88cQTFfZNnDiRZs2acfToURYsWMDYsWPZtWsXdru9Qm83OjqaefPm+SQnIYQQfpLUzr3wcFEuHN4EjTuf2ndgrft3Wm89Mqu1we2b8MHNfbjl/TX8tvsYY9/4jfdu6k2z+Ah9EmrcHho/BAMegtx9sGUebJ3n7kxnrXf//PS0e228dhdD+4ugeT8wBeHSIZoGjoLK96mqe1+xEWo6uaE0Rqt6Isqjjz5Ku3btmDBhAgCXX345vXqV/89IamoqqampPplUUVO16tht2rSJFStW+DTR66+/Hqj49Aqbzca3335LZmYmkZGRjBkzhhkzZvDdd99x4403snTp0jqf2263Yy+zyGTZZ7LJwqX6C7a60jtfWbjUv7HSzn3H2OxsDLsX48pciSO+PQAOeyGmQ3+gAI7k7rovSlyVqr7bs9Nj+fiW3vztf+vYdvgkl838hTdv6EHHFN+uOef1n62oFOh1m/snPwdl+w8Ytn2Pkrkc5UQmrHoDVr2BZolBa30BaushmJ2GgG7n5RYottswPJdWaawBiPfyfKUxrkf2o1qiKz3mxhtvZOLEiYwfP57c3Fy2bdvGpZdeyvbt2yssOlzZQsqlCxH7eoHiWnXsLrroIlauXEm/fv1qE+6VHTt2EBcXV27Gbbdu3di8eXO1cUVFRVxyySVs2LCB4cOHM23atHKLKpf17LPPMn369Er3LVy40OucvYmpTfkNVbDVld75+vv8vi6/ruXVJV7auT7aFcRxFnBozVz+yGkGwMp5H3GBowCHIZz5q3eCUsWs2QBR1Xd7Zwb8d4uR7JN2rvrPb9zUXuWseN8Pedb+z1YixN6IsdNVNDm5iaZ562hq3UC43Yqy5VssW77lYhSO7f4Xh+O6kx3XA5slxT3cq0u+FeNLFyi22WwUK06vO281cdJmA3vlk2GaNWtGfn4+mzdvZtGiRYwaNcpzoajsBSJwd8wKCgrKbS8oKMDhcFQ4tri4mMLCQpYvX15ugeKaqlXHLiIigosuuohhw4ZVWLdu1qxZtSmySjabrcJifLGxseTm5lYbFx4ezqJFi2p0jilTpjBp0iTPe6vVSnp6OuB+2obJVLNqcjqdLFmypEYx3hzb0AVbXemdr7/P7+vy61peXeJrEyvt3HcMe8ww5ytStUPEDR7MkiVLODcjCbaCoelZDB02XO8Uq1ST7/biIQ7u/WwTq/fm8tZWE49dnME1vVLr7fw1dykAqqZSlLUO484FGHYuwHh0K0n520jK30anQ5+hxrfC1WYIrrZDUdPOAWPNh2z90c7tdjuHDh0iKiqKcIsF1yNVTwo5abMRE135lbdqYxo1qbYzO2HCBL799lu+//57PvzwQ1asWEFYWBgxMeWHcM1mMxEREeW2R0REYDabKxxbVFREeHg4/fr1w2KxAFTo/FWnVn8aWrduzeTJk2sT6rXo6OgKH8hqtRLt5RdUHYvFgsViKfdIsVJLlizxujxvYmpTfkMVbHWld77+Pr+vy69reXWJl3aujzDnSS4GDLmZLF/0AxgtZP6+kI7AoaII/giCK51n+m6vTgY138DvRw08OX87i9Zu5YqWKiYf3cnknz9bvSC9FxFNcki2ric5bx2Jtq0Yc/dgWPsW5rVv4TRYyInpyJHYbhyO7UphWM1mL/uynZdescvPzz/zUKU5kpNVXHmrNsZmq/aQkSNHMnDgQJKTk2nSpAlFRUUUFxeXWyIO3FfsCgsLy20vLCzE4XBUOLa4uJiioiJ+/fXX+rtiN3Xq1NqE1UpGRgZ5eXlkZ2eTnJwMuB+8e+utt9ZbDkIIIXyv2BRDkSmWcKeVGPtBciNbE2XPBsAWnqxzdr5hMsD1bVWSIzW+32fg18MGDhco3NTeRUyAP4yk0NKYPY2HsqfxUEyuQhqf3ERy3nqaWP8k3JlHSt46UvLWAXAyvBmHY7pyJLYrx6LboxoC/MP5SFxcHJ06dWLIkCGV7t+xYwdjxowhNzeXBQsW0KFDB79P8KxVx+6FF16odLvFYiEtLY0LL7zQ6zXkHA6HZ9Fjh8NBUVERYWFhREdHM2rUKKZOncqrr77KwoUL2bRpE5deemltUq/WxIkTmThxoudZsSBDsYEg2OpK73xlKNa/sdLOfct8tDPs/5U+LWNZcARSwwsBaN1rGC3OGqpzdlXz9rsdBozYfpSHvvqLXSdd/Ht7FP++ugsdU2r3+C992vkowD1kW3h4E8Y9P2Hc/ROGQ2uJKTpETNEh2ub8gGaOxNX8fNTWF+BqfQFaXLr/h2KreVYs4HmWqzdqEuNwOMjMzOTyyy8nJiaG8PDwckOxPXv2ZN++fZXG+msoVtE07xewueaaa/j6668555xzSEtL48CBA6xatYpLL72UQ4cO8ddff/HVV19xwQUX1LjMCRMm8MEHH5TbtmTJEgYNGkROTg7jx49n6dKlpKWlMWvWrCp7x3VRdih2+/btzJ4922fLuQghhKio2773aHlsCduSR7M15Qou2jgRi/MkS9o/hTWyhd7p+Vx2Aby9zUhOkYLZoHF1a5XejYN7HTmzM5/GJzfR1Pqn52peWSctKRyO7cqR2G4+vZpXOhSbnp5OWFj9L9GyceNGxo8fz4033sj9998PwFdffcXTTz/NyJEjeeqpp6qMnT9/Pk8++SR9+/bllVdeKbevuLiY/fv3k52dXW4odty4ceTl5VWYd3C6WnXsrrzySiZMmMAll1zi2fb999/z/vvvM2fOHD7++GNefPFF1q9f723RAaH0it3s2bMZOXKk/E9eZ8FWV3rnK1fs/Bsr7dy3TCtfJ2z5Pyk+63IWmYYwYuNdABTcvxPConTOrmp1+W6tRQ4e/PIvVuw6DsDYnin8/aIMLCZjvZzfr+VrKsqRzRh3/4Rxz08YDq5F0U7dt66ZIlCbn4er1UBcLQeiJbSt0Uzb6q7YtWzZUrcrdnUpvypFRUVkZmbSrFmzclfsUlJS/Nexi4uL4/jx4571VcBd6YmJieTl5aGqKvHx8V5dOgwEcsVOCCHqV7MTK+mdOYtjURlsTLuBQdv+QZEpjh+7vK53an6lavDjAQM/HlDQUEiN1Li5vYuk6vsnQcfkzKfJyc00sW6gqXUj4c7ccvsLzQkcienMkdjOHI3pRLGp5p0jva/Y+YsuV+z69u3LiBEjmDJlCiaTCZfLxbPPPsu8efNYuXIle/fupX///lWOKwe6slfsRo8ejdlcs8vGDoeDhQsXMnTo0DPGeHNsQxdsdaV3vv4+v6/Lr2t5dYmvTay0c99SDv6B6f1hqNEprG5yDefufgU1uRuuWwL70ZG++m5/3nmUyXM2cqLAQbTFxHOXdWJ4p6b1dv76Kt/hcLBwwQKGdWtG2P4VKHuWouxbieI69XAADQUtpRtaq8ForQehpfX2LKlSWT52u519+/bRokULIiKqfrqHpmmeK2pKDdfh8yamNuVXp7CwkL1799K8efNyV+ySkpJq1LGr1fXbDz74gHHjxvHiiy/SpEkTjhw5Qvv27Zk9ezYAhw8f5tVXX61N0UIIIRoQLda9+LySf4Rwxwn3xugzd2xCRf+2SXx7V1/u//xP/tiXy92fbmBC3+Y8OKwdFl+tiRIoFAWtaWfUtB7Q9x5wFLg7d3uWYNi9FCVnC0rpo85+fQXNHIXWoh9a68Eo6edXeKatyWRCURSOHTtGYmJilZ0qTdM8S4h407GraUxtyq+urGPHjqEoSq2H2Gt1xa5UZmYmhw8fJjk5mRYtgv8mVxmKFUKI+qVoTkatvxmA3UlDaH10EZmJg9nQ/CadM6tfLhW+22dgSZa7M5caqXFjhovkBvRPULjjBI2tm2l8chONT24i3Fn+dq4CcwI5sV04EtOJnJhOOEwxhIWFkZCQEFL3sDqdTo4fP05xcbFnm9+HYsue6NixY5Qtonnz5rUtLmDIUGxgCba60jvfoByikaHYBs30SnuUgmMci8ogMX8Hrv4PoQ54RO+0quWv73bx1iNM+XozJwochJsNTLmoPdf2TqtwJSjk27mmwuHNGPYsPeOwrbPVQByNu6EZKy/X6XTy66+/0q9fP68mSdU0pjblV6X0Sl3ZOQxQD0OxGzdu5MYbb+TPP//0JAIQFhbm1erIQgghBFFNoOAYcYUlj4SKaqxvPjq6sEMT5t0dx8NfbuKXXceY+t0Wft5xlGfGdCIhKnQmCJyRYoDkLqjJXaDvPTgK8lg/9w16NzqJad/PKEf+8gzbGn99hTBTBFrzc9Fa9kdtOQCadgGDu3PkcDhwOp1YLBav/gNX05jalO9Ptbpid9555zF06FAeffRRUlJSyMrK4h//+Adt2rTh9ttv90ee9UKGYoUQov712/EcjW1/ed6vaXkXhxqdq2NG+lM1WJal8N0+Ay5NIdascX1blfbxwb3mna+UH7bdXGHtvGJjFEdjOpIT04mc6I7kW5rWaFmVQOX3odj4+HiOHz+OwWCgUaNGnDhxguLiYlq3bs2BAwdqnXigkKHYwBJsdaV3viE/ROPDeBmKDQzGb/6GYfNXnvfOa+egtR6sY0ZnVl/f7eZDVibN2cjuo/kAjO/bnMlDMjApqrTzUpoGR7dh2LMMJXM5yt5fUIrLP+O1wJxAWIdh0HogWssBZ5ygE2jt3O9DsfHx8eTm5pKQkEBqaiobNmwgISEB2xkeliuEEEKcTrOc9g+VJU6fRAJQp2axfHPnufzzh218uuYAH/y2j+Xbj/LP0R30Ti1wKAo07oDauAP0uR1UJ8qhde5O3p5lKAd/J9JxHDZ+6v4BtMYdUFsOQGs5AK3FeWDxzeLCgaBWV+yefvppOnXqxGWXXcZbb73F5MmTMRgM3Hbbbbz44ov+yLNeyFCsEELUv7MOfU67w6cejL7orBfID0/WMaPA9NcJhU93GchzKChoXNBMY0S6SqitiuJrRtVOgm07jU9upvHJv4gr3IvCqa6PioHcyFbuYduYTpyIauuzx575Sr3Nii21d+9ebDYbnTp1qmtRAUGGYgNLsNWV3vnKUKx/Y6Wd+57h19cwLjn1XE3HA9sgMlHHjM5Mr+82r9DBU99v5dsNWQC0bRzFi1d0oXNq9f/Yeyuk23nBcZS9K1Ayl7uHb0/sKXe8ZopATevD1uJkWg+5GVNaD/dkDj99tprw21Bsx44dz3jMX3/9dcZjgonZbPb6i/ImpjblN1TBVld65+vv8/u6/LqWV5d4aec6i2xU7q05OgmMwbEuWX1/t0lmM69d25PhHQ/y8Bfr2JmTz5VvrmLi4LbcPbgtYT6+fBeS7TyuKXS9wv0DkLsf9iyD3Uth9zKU/CMYM5fRCeDDzyCiEbTsD60HQquBkFj58239+WfBm3K9ajl79uyhefPmXHfddQwYMMAnj84QQgjRwIWfuqdOC4tCCZJOnZ6GdmzClG4uVhSm8n+bD/OvxTtYsDmb56/oSrf0eL3TCy7x6dDjevePpsGRLbh2/sSRVV+QXLQDpfAEbJnr/gGIaQatBpz6iQqs2wa8aj1Hjhzhq6++4uOPP+b9999n7NixXHfddXTt2tVf+QkhhAh1ZSdPhIXOTez+Fm2Gf43uxg9/5TB17ma2Zp/kslm/cNN5rZg8rB2RYdJB9pqiQNOOqAkZrD6azojhQzHnbHJfzduzHPavhpOH4M9P3T+AqVEruhlawMkekKD/Qxq8+tZjYmIYP34848eP5/Dhw3z66af87W9/Iz8/n88++6xGQ7XBxuFweH1sTWK8ObahC7a60jtff5/f1+XXtby6xNcmVtq57ynmKM8/Rpo5CmcQ1Jfe323Z81/UsTG9W/Tjn/O3MffPLN5ZsYcfN2fz1KiOnN+2dvcqSjsviVGB5B7un34PgKMQ5eAalEz3PXrKoXUoJ/bQgkwKlTDw89+7NVHryRO5ubl8/vnnzJ49m4MHD/L111/TuXPn2hQVMGRWrBBC1L+YwgNcsPXvAORGtGRZhyd1zih4/XVC4bPdBnKL3bdK9WmsMqaFSpTc4ukXJlchibZtRNmz2d3kIr+dx2+zYu12O3PnzuV///sf69atY8yYMYwbN45zzw2tFcJlVmxgCba60jtfmRXr31hp535gzcL8ehcAXGnnoI7/XueEzkzv77a689vsTmYs2sn/Vu1D0yAxKox/jOzAxZ2b1vjeeGnngdXO/TYrtmnTpiQnJ3PttdfyyCOPeB52u3r1as8xffr0qUXKgUtmywWOYKsrvfOVWbH+jZV27kPRCZ6XisEQVHWl93db2fkbmc08NaYLY3qk8ciXf7LziI37Pv+TbzY05snRnUlPqPlIlLTzwGjnfpsVGx8fj91u5/333+eDDz7g9It9iqKwe/dub4r0q2XLlvHoo49iNBrp06cPM2bM0DslIYQQpwuLOvVademXR4g5u0Ujvr/3fGYt2cWspTtZsi2HITOWce+FGdzWv7XPl0YRgcGrjl1mZqaf0vCPtm3bsnTpUiwWC+PGjWPjxo106dJF77SEEEKUVXZ4UDp2PmUxGXlgaDtGdW/GE99s4tddx3jxx2189ccBnhrTmX5tkvROUfhYSHfXU1NTsVgsgPsyptFo1DkjIYQQ1VKdemcQkto0jubjW8/h1au7kxQdxq6cfMa9tYr7P11Hzkm73ukJHwqojt3UqVPp2LEjBoOBTz/9tNy+nJwcRo4cSWRkJO3bt2fx4sU1LvePP/7g6NGjIbkcixBChBJFrtj5jaIojOmRyuLJg7jh3BYoCnyz/hAXvLyUj1buxaXW+QmjIgAE1OqFGRkZvPbaazzxxBMV9k2cOJFmzZpx9OhRFixYwNixY9m1axd2u51rrrmm3LHR0dHMm+d+oHR2djb33nsvX375Zb18BiGEEHWgyRU7f4uLMPPUmM5ceXYaj32zkU0HrTzxzSa++H0/z1zWhc6pcWcuRASsgOrYXX/99QA888wz5bbbbDa+/fZbMjMziYyMZMyYMcyYMYPvvvuOG2+8kaVLl1ZaXlFREePGjeP111+nadOmVZ7Xbrdjt5+6FG21Wj2vZeFS/QVbXemdryxQ7N9Yaef+UTrnT41qihoE9aX3d+uL83dMjuKLv53Dx6v3M2PRDjYcyOPSf6/g6l5p3DOwRZ3L92W+Db2d18sCxf40aNAg7rjjDs+VuHXr1jF8+HCOHDniOeaee+4hMjKS559/vspy3njjDaZPn06HDh0AePbZZ+nbt2+F46ZNm8b06dMrbJcFioUQon40tv5J2yM/sD79JgotjfVOp8HJK4ZvMg38ccx9h1akUWNEc5V+TTWM8lh43XmzQHFAXbGris1mq/BBYmNjyc3NrTbuzjvv5M477zxj+VOmTGHSpEme91arlfT0dAAGDx7sWa/vTJxOJ0uWLKlRjDfHNnTBVld65+vv8/u6/LqWV5f42sRKO/cPp3MwS5Z0DZq60vu79cf5rwTWZJ7gmR92sP1IPl/sMbIxP4rHLm5Hrxbxuubb0Nt52ZHEMwnpK3bekkeKCSGEaOhcGvx6WOH7fQYKXe7LdT0TVUa3UIm36JxcA+XNFbuAmhVblYyMDPLy8sjOzvZs27BhA506ddIxKyGEECL0GBXon6zxeA8X/ZqoKGj8cczAM+uNLDyo4FT1zlBUJ6CudzscDlwuF6qq4nA4KCoqIiwsjOjoaEaNGsXUqVN59dVXWbhwIZs2beLSSy/16fknTpzIxIkTPc+KBRmKDQTBVld65ytDsf6NlXbuH8FWV3rnW1/t/D+3DmR7TiHP/N921h2wMm+fkT9tEUwZ1paB7Wq+uLG087oJ2qHYCRMm8MEHH5TbtmTJEgYNGkROTg7jx49n6dKlpKWlMWvWLIYMGeLT88tQrBBCCFGRpsHvRxXm7jVgdbiHZ8+KVxnTQiVZ/pn0O2+GYgOqYxcoSq/YzZ49m5EjRwZtDz9UBFtd6Z2vXLHzb6y0c/8ItrrSO1+92nm+3ckbyzP5cNUBnKqGUVG4ulczJg5sSaPIML/l29DbudVqJSUlRTp23pIrdkIIIcSZHSmEuXsNbDzhvlU/wqgxPE2lf7KGKSju3g8ucsWujspesRs9ejRms/nMQbjvEVy4cCFDhw49Y4w3xzZ0wVZXeufr7/P7uvy6lleX+NrESjv3j2CrK73zDZR2vnL3cZ75v21szT4JQIuESB4Z3o4hZzVGUU4tgCftvG6sVitJSUmhMytWCCGEEIHn3NYJfHPnufxzTEeSosPYe7yAuz5Zz43v/c5fWTW/4V/4jlyxK0OGYoUQQojaKXLBooMGlhxScGoKChrnNNEYma4SW/Xtd6IGZCi2jmQoNrAEW13pnW+gDNHUV3kNfYgmVARbXemdbyC38wMnCnlpwQ6+3+ReezYqzMht57cgLX87I4ZLO68NGYoVQgghhC7SGkXw6tVd+ey2PnRNiyW/2MWrP+3mmXVG5v6ZjarK9SR/kit2ZchQrBBCCOE7qgZrjyrM22cgt9g9mSItSmN0C5V2cdL9qCkZiq0jGYoNLMFWV3rnG8hDNP4or6EP0YSKYKsrvfMNtnZuLShi6sdLWJIdRn6xC4CBGUk8PDyDdk1j/JpPKLRzGYoVQgghRMCIMBsZmqrx4z3ncsO5zTEZFJbtOMqlM39jytebybYW6Z1iyJArdmXIUKwQQgjhf0cK4ft9BtYfd19fMhs0BqdoXNhMJTzwHzxS72Qoto5kKDawBFtd6Z1vsA3RyFCsgOCrK73zDZV2vm5fLs/9uJ0/9uUCkBBl5t7BbbiqVxpmo+GM8f76LIHWzr0ZipV+8RmYzWavvyhvYmpTfkMVbHWld77+Pr+vy69reXWJl3YeOIKtrvTON9jbeZ82jfnyziR+3HyY53/Yyp6j+Uybt5UPV+7n4Ys6MLxT03JPsGio7dybcuUeOyGEEELoRlEULuqczIIHBvDU6E4kRoWx+2g+d/xvLWP/8xtr957QO8WgIlfshBBCCKE7s9HADX1bMqZHKm8u381bP+/m970nuOKNXxl6VhN6W/TOMDhIx+4MHA6H18fWJMabYxu6YKsrvfP19/l9XX5dy6tLfG1ipZ37R7DVld75hnI7DzfCvYNbc9XZzXht8S6+WneQhVuOsAgj25SN3HdhBilx4X45d21i6uPPgjdly+SJMmRWrBBCCBFYsgrcM2g3nnDfPWZSNAYkawxJVYkKntsx60RmxdaRzIoNLMFWV3rnGyqz5eojPhRmy4WKYKsrvfNtiO38za8W8rM1kbX78gCICTdx2/ktGd+3OZFhVQ9AhkI7l1mxPhTMs2hCTbDVld75BvtsufqMl3YeOIKtrvTOtyG181YxcNdVffhldy7P/7CVrdknmbFoJx+t2s99F2Zwde/0ckuk+OLcgdLOZVYscOjQIfr168eAAQO45JJLKCgo0DslIYQQQtSBoigM7tCE+ff259Wru5OeEEHOSTuPf7OJoTOW8d2GQ6hqwx6IDNmOXdOmTVmxYgXLly/n7LPP5vvvv9c7JSGEEEL4gMGgMKZHKosnDWLapR1JjAoj81gB93yyjlEzV7B8ew4N9U6zkO3YGY1GDAb3x1MUhfbt2+uckRBCCCF8KcxkYMJ5rVj28GAeGNKOqDAjmw5aufHd1Vz39io27M/VO8V6FzAdu6lTp9KxY0cMBgOffvppuX05OTmMHDmSyMhI2rdvz+LFi2tU5ooVKzj77LNZtGgRLVq08EfaQgghhNBZtMXEfUMyWP7wYG4+rxVhRgO/7jrG6Jm/cM+nGzhcqHeG9SdgOnYZGRm89tpr9OnTp8K+iRMn0qxZM44ePcrzzz/P2LFjOXHiBNnZ2QwaNKjczyWXXOKJO//881m7di1jxozh3Xffrc+PI4QQQoh6lhht4R+XdmTx5IFc3jMVRYEfNh/mufVGHvtmM4dyQ7+HFzCzYq+//noAnnnmmXLbbTYb3377LZmZmURGRjJmzBhmzJjBd999x4033sjSpUsrLc9ut2OxuJepjouLw+VyVXluu92O3W73vLdarZ7XwbygYagItrrSO99QXrjU1/GhsHBpqAi2utI7X2nn1UuOMfP8ZZ24pV9zXlqwnSXbj/H52oN8vf4Q4/qkc+eAViRGV/0oi0Br50G9QPGgQYO44447uOaaawBYt24dw4cP58iRI55j7rnnHiIjI3n++eerLGfFihU89thjGAwGEhIS+Oijj6pcbHjatGlMnz69wnZZoFgIIYQIfrutMG+fkV0nFQDCDBoDUzQuaKYSGTCXuKrmzQLFAf9xbDZbhQ8RGxtLbm5utXHnn38+y5Ytq9E5pkyZwqRJkzzvrVYr6enpAAwePBiTqWbV5HQ6WbJkSY1ivDm2oQu2utI7X3+f39fl17W8usTXJlbauX8EW13pna+0c+9iWbKEr+7uz+p9J3ltyW42HTrJwoMKq46FcVPfdK4/J42oMoscB1o7LzuSeCYhe8WuNuSRYkIIIURo0zTYeELh+30GsgvdV/CizRpDU1XOa6phDpjZB6d4c8UuANMvLyMjg7y8PLKzsz3bNmzYQKdOnXTMSgghhBDBSFGga4LGI91c3NDWRZJFw+ZQ+DrTyNPrjPx2WMEVUJe8vBMwV+wcDgcul4thw4Zx2223MXbsWMLCwjAYDIwdO5aEhAReffVVFi5cyIQJE9i1axeNGjXySy5lnxU7cuRIGaLRWbDVld75yhCNf2OlnftHsNWV3vlKO/ddrMOl8vX6bN5Ynsnhk+6JlC0SIhiYaGPSlQMJO8PjvOprKDYlJaVGV+wCpmM3YcIEPvjgg3LblixZwqBBg8jJyWH8+PEsXbqUtLQ0Zs2axZAhQ3yegwzFCiGEEA2TQ4UV2QoLDxrId7qHaJtFaoxIV+ncSENR9MvNm6HYgOnYBRK5YhdYgq2u9M5X/ifv31hp5/4RbHWld77Szv0Xm2938sFv+3jnl0wKXe7eXNfUWO4b3Iq+rRN8mltNBeUVu0AgV+yEEEIIAZDvgJ+yDCzPUihW3R28jFiVkc1VWsXUby5yxa6O5IpdYAm2utI7X/mfvH9jpZ37R7DVld75Sjv3b2zZmBNFLt5asY/P1h7EUTKrYlBGIvcObk2H5Gi5YhfI5IqdEEIIISpz3A4/HjCw+oiCivsKXo9ElYvTVZpG+PfccsWujspesRs9ejTmM8yIKeVwOFi4cCFDhw49Y4w3xzZ0wVZXeufr7/P7uvy6lleX+NrESjv3j2CrK73zlXbu39jqYvYczee1n3bx/Ub3MmwGBXolqbxw/fmkJkR7lVtNWa1WkpKSQmMdOyGEEEKIQNEqKYpXr+rK3Lv6MqRDY1QN/jiqECiXyeSKXRkyFCuEEEIIb+w9CQcLFPo19V93SoZi60iGYgNLsNWV3vnKEI1/Y6Wd+0ew1ZXe+Uo7929soLVzb4ZiA3/qkc7MZrPXX5Q3MbUpv6EKtrrSO19/n9/X5de1vLrESzsPHMFWV3rnK+3cv7GB0s69KVc6dmfgcDi8PrYmMd4c29AFW13pna+/z+/r8utaXl3iaxMr7dw/gq2u9M5X2rl/YwOtnXtTtgzFliH32AkhhBAi0Mg9dnUk99gFlmCrK73zlXtv/Bsr7dw/gq2u9M5X2rl/YwOtncs9dnVU2tctKCigsLAQp9NZoziHw1HjGG+ObeiCra70ztff5/d1+XUtry7xtYmVdu4fwVZXeucr7dy/sYHWzgsLC4FT/ZPqyBW7Shw4cID09HS90xBCCCGE8Ni/fz9paWnVHiMdu0qoqsqhQ4e44IIL+P33372K7d27N2vWrDnjcVarlfT0dPbv33/Gy6qi5vUaKPTO19/n93X5dS2vLvG1iZV27h96txtv6Z2vtHP/xgZSO9c0jZMnT9KsWTMMhuqfLSFDsZUwGAykpaVhMpm8/pKMRqNXMbGxsfIXfg14W6960ztff5/f1+XXtby6xNcmVtq5f+jdbryld77Szv0bG2jtPC4urkbHySPFqjFx4sR6iRFnFmz1qne+/j6/r8uva3l1iZd2HjiCrV71zlfauX9j9f5+a0uGYnVSOvO2JjNchBDBSdq5EKEv0Nq5XLHTicViYerUqVgsFr1TEUL4ibRzIUJfoLVzuWInhBBCCBEi5IqdEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIkI6dEEIIIUSIMOmdQCBSVZVDhw4RExODoih6pyOEEEKIBkzTNE6ePEmzZs0wGKq/Jicdu0ocOnSI9PR0vdMQQgghhPDYv38/aWlp1R4jHbsyZs6cycyZM3E6nQC8/fbbREZG6pyVEEIIIRqygoICbr31VmJiYs54rKJpmlYPOQUVq9VKXFwcs2fPZvTo0ZjN5hrFORwOFi5cyNChQ88Y482xDV2w1ZXe+fr7/L4uv67l1SW+NrHSzv0j2OpK73ylnfs3NtDaudVqJSkpiby8PGJjY6s9Vq7YnYHZbPb6i/ImpjblN1TBVld65+vv8/u6/LqWV5d4aeeBI9jqSu98pZ37NzZQ2rk35cqsWCGEEEKIEBHSHbucnBxGjhxJZGQk7du3Z/HixXqnJIQQQgjhNyE9FDtx4kSaNWvG0aNHWbBgAWPHjmXXrl00atRI79SEEEIIIXwuZDt2NpuNb7/9lszMTCIjIxkzZgwzZszgu+++48Ybbyx3rN1ux263e95brVbPa4fDUeNzlh5bk5jM587lHOdxjq97oMI+jdqtneeJqyS8+jKr3lf9zJrK46o7V20/WzdNI2vDFK/yqO35vM2/dItWuuahptFJVTnw5xOevdppx9Y8x9p9tg4uF3v/nO4uocxhZ/psVe09Pa6dy0nmxqerLMsTV+06kKf2ZTid7Nn0zxrkWXkNtnU62bXpuQq7lQoxCqc3kzYOB3v+egGU0z+/gqYo7lwUg/s9CppiIL3Izvbts9zblVPbKTnWHaOgopCUX8jmzI/d20vLURTAgKIoKAYDKEYMJa8VgxHNaAZjWJkfMwaTBUxhGExhmMMshFkisETGYoluRERsIoaIeAiPLck1+Hjz92cg0Dtff5/f1+XXtby6xNcm1puY+viz4E3ZITsrdt26dQwfPpwjR454tt1zzz1ERkby/PPPlzt22rRpTJ8+vUIZs2fP9ttyJ+f+cR9NlRN+KVsI0TCpKJwgjiPGJuSak7FGZ+BK7IAjsqneqXlP04gv3EPSyS3EFu4j3JFLhOMERtWOQXOiaC4UTcNlsOA0WnAYIykIa4wtPIWj0WdxNLpD0HZyhThdQUEB48aNa9izYm02W4UPHxsbS25uboVjp0yZwqRJkzzvrVarZ4Fif02P3pGWwJL1f9C5c2eMJiMAmua+JnA6z5bT+uBl35aNq7KEyrrwmlb1VTlNrXxz5cVUyMN9rFbxoErKUKr5/4XL5WTr1u20b98Oo9FYg2xKT1V1XSpV5VJue/l45dSOys7o2exyudi5YydtM9q68622HivJsbQutdOPrRh9+p8JANXlYufu3bRp3RpjuRXKq/uuq6hHKn6nLlVlz+49tGrVCoNBqXB8qdI6rry6Tm1VVZXMzExatmzpXlG9yj8LlW93uVzs3buXFi1aVFiRXdNAK6l/Dffq7VqZ07tcLg4cOEBqWiqKYgCt5DgAzeVuH5r7tYKGpqloLheHs7No2qQpiqKVFKaBpqJoKpQcp2gamuri2LGjJDaKdz/Fpswx7uRUVE1FU90/qqaiqC4U1YlBLcaoOTCoDoyqA6NW8qM6UFQHRq2YCK2QWPKJI58IpRgDGonkkujKBdd2KFoOR2FPVDeiL32O+Da9q6hb/ZX7+/PETozf3Y0he8MZ48xqIbiXHqVRwR4A2vMtWlJ7XJe8hpbay//5ynInfi9PljuxnvmgEiHbsYuOjq5QEVarlejo6ArHWiwWLBZLpeX4a3p0Rtdz2XHgOO17Dgiqqf16cDgc7MuFLueNCIq6cjgcHMqfT/eB+uTrcDjIss+n54X+Ob/D4eDw/PmcPdQ35TscDo7Mn0+v4bUrz+FwkDN/Pr0v9j7e4XAwf/58+o+oeWxpzKAaxJQeO9CL8r1ld7rIt7vIttk4mnOYk0f2UpyzG/XwZlJOrKWLuo1W+RtwfjqSvQNm0OaCm/ySh6+Yj23F/OFIcBSAKRzaDoHUsyG+OUQ3dQ83G0qGqhUFivPdP4XH4fgeyN4I2+ajHN2G6eMr4G9LoHF7/+Ury53Ua3my3MmZhWzHLiMjg7y8PLKzs0lOTgZgw4YN3HrrrTpnJoQQvmMxGbGYjCREJdCqaQJwlmefqmr8vnETxfMe5nzHr6Qtf4hjrXuR2LKLfglXR9Mw/vCwu1PX4nwY+x5EN/G+nMJc+PQ62LsCFj8J13zs81SFCFQhewNCdHQ0o0aNYurUqRQWFjJ37lw2bdrEpZdeqndqQghRLwwGhT7dunD2g3P53XQ2FhwcnHvmSS96iS3cj+HgGjBa4Mp3a9epA4iIh5EvuV9v+z+w23yWoxCBLmQ7dgCzZs1i//79JCYm8uCDD/L555/LUidCiAYnwmKGC9yzyjOO/4SruFDnjCrX2LbZ/aLVAIip44SPJmdBXHP3vZIHVtc9OSGCRMgOxQI0btyY+fPn16mMYJ4eHSqCra70zleWQfBvbLC28049+pOzIJ7G5LLt94W07n2x3imV43A4aJS/CwBXel9UH9SZMbUnhrx9uA5tQG3ev87llaX3dyvt3L+xgdbOZbmTWpo5cyYzZ87E5XKxfft2vy53IoQQ9S3hz3/T37WauTHXoLUdoXc6FZy//SkS83ewuuXdZDXqU+fyOh/4mDY5P7KjyUj+Sr3aBxkKoQ9Z7qSWJk6cyMSJE7FarcTFxQH+W+5E76nywSTY6krvfGUZBP/GBnM7X5W1ELJXk2yx02NEYHXsHA4H2mb3slM9B45AS6t7x86wYiss+5E2KfG09PHn1fu7lXbu39hAa+ey3IkPBfP06FATbHWld76yDIJ/Y4OxnRsTW0M2ROQfDIh8ytE0DI48AEzxqeCL/GLcky8MRScw+HEZCmnn9VdeQ23n3pQb0pMnhBBCnBLRpA0A8faDOmdSiaJcjFrJfUTRyb4pMzLR/Tv/qG/KEyIISMdOCCEaiNjGqQBEqyd1zqQSJZ0vzRIL5nDflBmV5P5dcMw35QkRBGQo9gyCeRZNqAi2utI7X5kt59/YYG7nJksUABFaYcDkVMpZZMMMaKYInL7KzRzrLrPwuO/KLKH3dyvt3L+xgdbOZVZsLcmsWCFEKCsutDF2610AfNPtPRTD6c9e1k98/m4Gbp9GgTmRhZ1f8UmZkfbDDP3rIZyGcL7v9qZPyhRCD97MipWOXSVKZ8XOnj2b0aNHB+0smlARbHWld74yW86/scHczu1FhUS/nA5A7t3biIpL1DmjU1x7fiF89mjU+Fa4Jq7xTaF5+zH/uweaKRznIwd8U2YJvb9baef+jQ20dm61WklKSpLlTnwhmGfRhJpgqyu985XZcv6NDcZ2bjKZKNaMhCkuHPYCzGYfTVLwAUVR3b9NYb6rK7PFXabq8utsRWnn9VdeQ23nMitWCCFEBYqiUKi4JyYU5dd8Xax6oTrdv41hvivTYCpfthANQNB37J577jkURWHlypWebRMmTMBisRAdHU10dDSdOnXSMUMhhAgchUQAYC8IsI6dqxgAzeDDgSTPPYQaqKrvyhUigAV1x+7gwYPMnj2b5OSKwwnTp0/HZrNhs9nYvHmzDtkJIUTgKTK4r9gVFwTYkieukll/Pr1iV2ZyiObyXblCBLCgvsdu8uTJTJ8+nQceeKBO5djtdux2u+d92Ud3BPP06FARbHWld76yDIJ/Y4O9nRcrJVfs8nMDKi+1uBAT7it2PsvLpVF6Z5KjuMin/+Lp/d1KO/dvbKC18wax3MnSpUt5+umnWbRoES1btuTTTz/l3HPPBdxDsd999x0A7du357nnnmPAgAFVljVt2jSmT59eYbssdyKECDXN1z9HD+0vvki8C3Pzc/VOxyPt+C+cvfe/HInpzG9tH/ZJmUbVziUbbgNgXtc3cRl9tPCxEPXMm+VOgvKKndPp5IEHHuCjjz6qdP99993HK6+8QlRUFHPmzOHSSy9l06ZNpKenV3r8lClTmDRpkue91Wr1HBvM06NDRbDVld75yjII/o0N9na+aessKIT05CR6jhihdzoe6toc2AuJTVIY4au8nHbY4H45fOgQCK/+H0Rv6P3dSjv3b2ygtfOyI4lnEpAdu2HDhrF8+fJK9z3++OPExMRw/vnn07lz50qP6dGjh+f1ddddx0cffcTChQu5+eabKz3eYrFgsVgq3RfM06NDTbDVld75yjII/o0N1nauGUry0Py3BEhtuHDfA6eYLL7Ly3jqNnKzUQE/fF69v1tp5/6NDZR27k25AdmxW7BgQbX7x4wZw/Lly5kzZw4AOTk5jBw5kpdeeombbrqpwvEGQ1DPERFCCJ9RS2edugLn/jqgzHInPvyHUSnzd78qkydEwxCQHbszef/99ykqKvK87927N//9738ZNGgQAF9++SUXXXQRFouFL7/8khUrVjBr1iydshVCiACiuGeKaoG2tlvJcie+7dgp7s+ruWQtO9FgBGXHLj4+vtx7o9FIQkKCZ6LDK6+8ws0334yiKLRv356vv/6ali1b1n+iQggRYFSlpOPkCrCOTukVRIOPh7IMRnC5ZLkT0WAEZcfudJmZmeXer1ixwmdlB/P06FARbHWld76yDIJ/Y4O9nWslw5Oqqziw8nLYMQIuxYTLh3mZDCYUV7F7uRMflqv3dyvt3L+xgdbOG8RyJ/4wc+ZMZs6cicvlYvv27bLciRAi5ERu/oChxYuZF3EZrg6X6Z2Ox1mH5tDu8HfsajyMTWnX+6zcERtux6wWsqjji+RbmvqsXCHqU8gvd+IvEydOZOLEiVitVuLi4gBZ7iQQBFtd6Z2vLIPg39hgb+e/758LRyGhURy9A2i5Exb8Boehecs2NB/mu7xMWyxQVMjA/udDUobPytX7u5V27t/YQGvnQb/cSSAJ5unRoSbY6krvfGUZBP/GBm07L5mcYAjQ5U4M5nCMvsyrZBawLHcSGOVLO68db8qVdUCEEKIhKX1+aqDNEvU8K9YPkycg8D6vEH4iHTshhGhISmadKmrgTJwAUPyx3Al4rtjJOnaioZCh2DMI5lk0oSLY6krvfGW2nH9jg72da6X/n1edAZWX4rRjAFwYUX05K1YxoADOYjuazIrVrXxp53Ujs2JrSWbFCiFCnbJtLqMKvuAn8yBOdq78MYt6OHvPLNJyV7Ix9Tp2Nxnus3Iv3Pwg0cVHWN7uCU5E+W7yhBD1SWbF1pLMig1MwVZXeucrs+X8Gxvs7XzNidWQCdGR4fQPoFmxypzPIBfad+xChz4+nBW7dzocP0K/c/qgNe/rs3L1/m6lnfs3NtDaucyK9aFgnkUTaoKtrvTOV2bL+Tc2WNu5wRTm/h1gs2JVVAAM5jBMvsyr5J49k0FmxQZC+dLOa0dmxQohhKhcyWQCRQuwWaKls1YNPr7eoMisWNGwBG3H7rPPPiMjI4Po6GhGjRrF8ePHPfsKCwu5/vrriYmJoXnz5nzyySc6ZiqEEIFDMZbOig2wWaKl+fi6Y1e63Ik8K1Y0EEHZsduyZQu33347n3zyCSdOnKBFixZMnDjRs3/q1KkcP36cgwcP8umnn3LnnXeyfft2HTMWQogAYXR3nAwBe8XO6NtyPevYScdONAxBeY/dokWLGD58OL169QLg73//Oy1atCA/P5+oqCg++ugjvvnmG2JjY+nXrx+jRo3i008/5R//+Eel5dntdux2u+d92ZsUg3l6dKgItrrSO19ZBsG/scHezrUyQ5OBlJehZIFil6r4dFkSo2LEADgdstyJnuVLO6+bkF/u5PXXX+fnn3/m888/B+DQoUOkpqaybt06WrRoQUJCAvn5+Z6lSl5++WVWr17NZ599Vml506ZNY/r06RW2y3InQohQU5z5K2NP/Ie1SmcOdH9Y73Q8zt/+FIn5O1jd6l6y4nv5odx7yIrv7bNyhahPIb/cyYUXXsjjjz/O6tWr6datG88++yyKolBQUIDNZsNoNJbrkMXGxmKz2aosb8qUKUyaNMnz3mq1kp6eDshyJ4Eg2OpK73xlGQT/xgZ7O1/3f4fhBFjMRkYE0HInhuxXIR+69TibHmf5Li/jsf9A/g56du+G1tF35er93Uo7929soLXzoF/uZNiwYSxfvrzSfY8//jiPP/44b7zxBuPHj+fYsWPcd999xMTEkJqaSnR0NC6Xi4KCAk/nzmq1Eh0dXeX5LBYLFoul0n3BPD061ARbXemdryyD4N/YYG3npjD3cidGzRkwOQGoJZMbjGaLj5c7cf8zJ8udBEb50s5rx5tyA7Jjt2DBgjMeM27cOMaNGwfAzp07ef3110lLS8NoNJKcnMzGjRs555xzANiwYQOdOnXya85CCBEMSmfFGgJslqjit1mxpc+KDbDJIkL4SVDOigX4448/UFWVgwcPcvvtt/Poo49iNLpvCr7++ut56qmnOHnyJCtXrmTu3LlcffXVOmcshBD6M5TOiiXAOjqan2bFKjIrVjQsQduxu/POO4mNjaVXr14MGDCA++67z7PvySefJC4ujpSUFMaOHcusWbNo3769jtkKIURgUIynnjwRUPy1QLFcsRMNTEAOxdbEqlWrqtwXERHBxx9/7JPzBPP06FARbHWld76yDIJ/Y4O9nWuKArjvsQukvIwuJwrgVPHtcicoGACXsxhVljvRrXxp53Xj8+VOSpcVOROj0cgVV1xR45MHmpkzZzJz5kxcLhfbt2+X5U6EECGn8PA2rjn0DHtJYX2P5/VOx2Po5klEFh9lWbtp5Ea19lm5vfa8TmruGv5Mu5E9jYf4rFwh6pM3y53UqGNnMpkYMGAAZzp0zZo11S4rEiysVitxcXHMnj2b0aNHB+306FARbHWld76yDIJ/Y4O9nW9fu4ROP4zlkNKUxn/frHc6HsbXumCwZVE4fgGmtJ6+K/fr2zD89TWuoc+g9rndZ+Xq/d1KO/dvbKC1c6vVSlJSku/WsYuIiOCnn34643GNGjWqWYZBJJinR4eaYKsrvfOVZRD8Gxus7TwsPAJw32MXKDkBaCX3/JnCwn2bl6lkeRdFwyjLnehevrTz2vGm3BpNnti9e3eNCpPnsQohRGAzlHR0zATO/XWA/yZPlCzvgqvYt+UKEaBq1LFr3LhxjQqr6XFCCCH0YbaEu38HbMfOx8udlMwCxiWzYkXD4PV/jS6++GKUkllVZVksFtLS0rjsssu44IILfJJcIAjmWTShItjqSu98Zbacf2ODvZ2XLndi0RwBlZeppGPndAE+zMugmDACLkeRzIrVsXxp53Xj81mxZT3xxBN8+OGHjB8/nrS0NA4cOMBHH33ENddcg6IovPPOOzz66KM88MADXieuN5kVK4QIdcUFVsZuuxuAb7p9gGKo+B91PVyy/haMmoMfO71CUViiz8rtePATMo78HzuajOCv1Gt8Vq4Q9cnns2LL6tWrF5988gkZGRmebTt27ODaa6/l999/Z+3atYwdO7bG9+UFIpkVG1iCra70zldmy/k3Ntjb+cncYyTMdC/Ynj95v2cyhd5M/2yKorkouGs95kZpPivXsORpjL++iqv37ajDnvFZuXp/t9LO/RsbaO3c57Niy9q1axepqanltqWkpLBz504AevbsSU5OjrfFBqxgnkUTaoKtrvTOV2bL+Tc2WNt5ZPSpfxQ01RkYeWkalMyKNft6VqzZfU+hUXPKrNgAKF/aee34fFZsWcOGDWPs2LGsXLmSAwcOsHLlSq655houuugiAFavXk2LFi28LVYIIUQ9CAsL97wuLsrXMZMyyj7HVWbFClEnXnfs3nnnHdq3b8+1115LRkYG48aNo3379rz99tsApKam8u2339Y5MafTyRVXXEFqaiqKopCdnV1u/9SpU0lPTyc2NpaMjAzee+89z76lS5diMBiIjo72/Pz88891zkkIIYKdwWjArrk7Ow57kc7ZlCj7HFd/zYqVZ8WKBsLr/xpFR0czY8YMZsyYUen+tDTf3RsxYMAAHnroIfr27Vth3/XXX8/DDz9MVFQUO3bsYODAgfTp04dOnToB0K5dO7Zu3eqzXIQQIlTYMWPBQbG9UO9U3Mp17Hx9xa50uRO5Yicahlq1oO+//54vvviCnJwc5s2bx5o1a8jNzWXo0KG+S8xk4r777qtyf9nJGwCqqrJ3715Px84bdrsdu93ueW+1Wj2vg3l6dKgItrrSO19ZBsG/saHQzosV9xU7e8HJwMituIjSO4gcLs23y52gYARUhx2XLHeiW/nSzuvGr8udvPDCC3z00UfccccdPPbYY+Tm5rJ161bGjx/PqlWrvE62RkkqCllZWSQnJ5fb/txzz/HUU09RUFBAnz59WLZsGeHh4SxdupSLLrqI2NhY4uLiuOGGG3jssccwGiu/xD9t2jSmT59eYbssdyKECEW9/5hEM+Uon6dPxZLURu90CHOe5OKNEwH4tvv7oHh9l1CVmh9bRo9975Ad251VbSb5rFwh6pNflztp3rw5q1evJjk5mUaNGnHixAk0TSMxMZHjx4/XKfEqk6yiYwegaRqrV69m0aJFPPLII5hMJrKzs8nNzfUMx1511VXccsstVa6tV9kVu/T0dFnuJEAEW13pna8sg+Df2FBo51n/7Epz7RCbhs2mfe9heqcDtsOYX+uEhkLhw4d8WlfKxs8xzb0LtfVgXNfO8Vm5en+30s79Gxto7dyvy524XC7i4uIAPE+gsFqtREdHe1XOsGHDWL58eaX7Hn/8cR5//PEalaMoCueccw4fffQR77zzDrfffjvJycmeTmDHjh15/PHHmTVrVpUdO4vFgsViqXRfME+PDjXBVld65yvLIPg3NpjbuVMJAw1wOgIjr5JFklXF6Pu6KpkFbFCdGGS5E93Ll3ZeO96U63XH7rLLLuOOO+7g5ZdfBsBms/HQQw9xxRVXeFXOggULvD11tVRVZdeuXZXuMxh8d1lfCCGCncMQBiq4HIE1eULz4RCsh2fyRADcSyhEPfC6Fb300ktER0fTokULcnNzadq0KSaTiX/+858+T85ut1NUVFThNcDbb79Nbm4uqqqybNkyPv74YwYNGgS4lzvZv38/4H4qxtNPP80ll1zi8/yEECIYuRR3Z0ctDqzlTjR8vNQJyKxY0eB43bELDw9n5syZ5Ofnc/jwYWw2G7NmzSIiwvePpWnfvr2n3JYtW5Y7x/z582nTpg1xcXHcddddvPjii4wYMQKAtWvXcu655xIVFcWwYcMYM2YMkybJTbNCCAHgMrg7Oy5HoHTs3AsU++WKXenyKXLFTjQQNRqKXb16dZX79uzZ43ndp0+fumdURmZmZpX7vvrqqyr3TZ48mcmTJ/skh2CeHh0qgq2u9M5XlkHwb2wotHNnaceuyBYQuSn5JzABTkO4T5c6AVAwYAI0lx2nLHeiW/nSzuvG58udtGrV6lSAonDgwAEURSExMZFjx46haRppaWns3r27dhkHiJkzZzJz5kxcLhfbt2+X5U6EECEpZuM7XOBcxndRV6K2G6V3OjSx/knfXS+RG9GcZR2e9mnZjWw7GLDjKWxhTVjc6SWfli1EffFmuZMaXbEre1Vu+vTpFBQUMG3aNCIiIigsLGT69OlERUXVLesAMHHiRCZOnIjVavXM/A3m6dGhItjqSu98ZRkE/8aGQjtflbUIsqFJhEbPkltY9KRsKoBd4DBG+7yulEPrYAdEhYd5btfxBb2/W2nn/o0NtHZe9sEJZ+L1rNjXX3+d7OxsTCZ3aEREBE899RQpKSk88cQT3hYX8IJ5enSoCba60jtfWQbBv7HB3M4NscmQDWFFOYGRV/FJ9y9TFPG+riuLe9RFUf2ztIve3620c//GBko796Zcr+9UbdSoEYsXLy63benSpcTHx3tblBBCCB2Y49zrfEYUH9U5kxKFJwAoNnq3HmqNGEv+QXTaqz9OiBDh9RW71157jauuuopzzjmH9PR09u3bx5o1a/j444/9kZ8QQggfC09IBSDWcUznTEqUdOwcJj907MLj3b/tVvfMWGMAXKEUwo+87tiNGDGCXbt2MX/+fLKyshg4cCCffPIJSUlJ/shPd8E8iyZUBFtd6Z2vzJbzb2wotPPYlAwAktUj2HKPYYmq/mZsfzPmH8UAFBujfF9XlnhMRguKy47j+F6Ib+GTYvX+bqWd+zc20Nq5z2fFNhQyK1YI0RBoGvRZ9wDNlGN81exRjE076prPwK3/IL4wk9Ut7yarkW+XzQK48K+HiLYfZkXbKRyLOcvn5Qvhbz6fFXv11Vfz2WefnfG4cePGMXv27JplGYBkVmxgCra60jtfmS3n39hQaedrt79Hs4IltGAfXUc8qF8iziJMG24GIDeqtV/qynjibcg8zLlnpaJ19c3MWL2/W2nn/o0NtHbu81mxc+fOZc6cOZzp4t78+fNrfOJgEcyzaEJNsNWV3vnKbDn/xgZ7O3d1Hgurl9Du0Dc4rY8RkZimTyK7FoLqRItqQqE50T911aQDZC7HdOh3OPsGnxat93cr7dy/sYHSzr0pt0Ydu3POOYdZs2bV6DghhBCBr+cFY9m65iU6aLs59J+L0cbPJjKtS/0mUZQHP7kXJFa7XAV2xT/naXcRrH4T/poLQ5+E8Dj/nEeIAFCjjt3SpUv9nEZFTqeTq6++mpUrV3Lo0CGysrJITk727N+zZw+33347q1evJioqirvvvpspU6Z49r///vs8/vjjWK1WrrjiCv773/8SFhZW759DCCECUUR4GIWj3ibrmytp5tiH+nZ/9kV3Q2tzAUltexPVrD1ENwWLj2eq2k/C4b9g7y/uztbJLIhMQj3nLlj+u2/PVarVAEhsC8d2wv+uhIuehWY9weCHZ9MKoTOvZ8XWpwEDBvDQQw/Rt2/fCvvuueceWrduzffff8+BAwc477zz6NOnDxdeeCEbN25k0qRJLFiwgIyMDMaMGcPTTz/Nk08+qcOnEEKIwNSjx9msN3/Htq8fZJDrN5rb1sOG9bDh1DGFSiSFplicxkhc5khUUySYIzEYjSgGE4rRiMHg/lGMJoyoGDUHRs2BQXViUIsxuIowFByDgqMoRXnlk2jUEsZ+ANFN/PdBjWa47L/w4Wg4sBrevhCimkDTjpDQGiKTIKKR+ycsCkwWMIaV/LaAKcz9XjGCooBiAFUjvPgYWLMgrHSfwb3fUPq6zA8AZa5IKkr5bVW9V/x0FVOErIDt2JlMJu67774q9+/du5fJkydjNptp1aoV559/Pn/99RcXXnghs2fP5uqrr6ZXr14APPHEE9x6661Vduzsdjt2+6nFK8vepBjM06NDRbDVld75yjII/o0NtXbeqX17ih/8lsXr/+TEH98Qe/xPWjh2k6bkEKXYidAKiHAUgAMo8s05D2uN2Ka04mfjOSwqGAQfn8Bk/IXCfCPv7V9JmMmI2WggzKRgNhrcr40KYSaD573ZqBBuMpIQHUbj6DAaR1tonhhJYlQVIzNNu8FtyzEufQZl+w8o+Udg9xHYvbRWn8EMDAfYXKvwWtNKOn4mRWGUpsF6AxpU01GsbFtV708dbwJGOJ2YNpuocHf9GTubFfd7yvvLhFZtfOX7TMDFDgemLWFo1Z6+snNrXFTswLTVjKac6SqtUiamGNO2ME+du3dXUr6mMby4GMfAPyAq/gzl107ILXeiKEqFodj//Oc/rFu3jn/961/s27ePCy+8kO+//54uXbowevRohg8fzl133QXAsWPHSEpKoqCggIiIiArlT5s2jenTp1fYLsudCCEaogInHLdDQVERamEuiqMAxWVHcRVhdNkxuOyomupeN0VT3T+oKKqKAwN2zUShasaOkWLNjB0zJ7QYjhFLjhaHFT8sRFwiPkyjXZzGgGSV9CpOY1CLiSvYS7Q9m6jiI5id+YS5bIQ5bRhVOwbNiUF1uq86ak4Mqvu3gvvzKmgomgpoKJqGgnubaNjmdX0TlzHcL2X7fLmTQNSvXz9mzZpFVFQULpeLadOm0aWL+8Zfm81W7oOXvrbZbJV27KZMmcKkSZM8761WK+np6YAsdxIIgq2u9M5XlkHwb6y085rTNA2XquFwaRS7VBwu1f3aqVZ4X2gvZvXvf9Cpazc0DDhcKsXl4lSKnZrntcOlUVDs4nh+MTk2Ozkn7RzMLSK3WGF1jsLvRw3cM7gNdw9u4/vPBRRX9t2WdnLL/qiu0so4rYSy27x/73A4Wb58GQMGDMBsMpY7DOp+LqfDyYpfVnD+eedjMpfpKpzxWlDl+50OJ7/88gvnndfP86z5msaWxv/66y/069cPk6mqtlTFuZ0Ofv31V/r17VtNbPl4p9PJb7/+St9+ZfKt4rM7nU5+++03Lhg2ArPFPx07ny93UlZhYSH/+Mc/mDNnDsePH8dqtfLjjz+yZcsW7r///hqXM2zYMJYvX17pvscff5zHH3+8yliXy8WIESN45JFHuPPOOzlw4ACXXHIJnTp14sorryQ6OrpcJZS+jo6u/L9vFosFi8VS6b5gnh4daoKtrvTOV5ZB8G+stPOaq/jf6YocDge2XRoXd2lW67o6WeTgzwN5fLJ6H/P+zOK1n3bRPiWOEV1SalVeTej23Toc2M3xmBul+ef8DgcFlh2YmmT4pnyHg/zwXZiadqhdeQ4HtvA9mJI7eh/vcGAL34sppXPNYx0OTkbsq1mMw8HJiP2YLeEBsdyJ11OC7rrrLrKyspg3bx5Go/t/CV27duU///mPV+UsWLCAoqKiSn+q69QBHD9+nEOHDnHnnXdiMplo2bIlY8aMYcmSJQB07NiRjRs3eo7fsGEDrVq1qvRqnRBCiNAQE27mvLZJ/HtcT+4c5L5S96/FO3TOSoj65XXH7vvvv+edd96hc+fOKCU3EaakpJCVleXz5Ox2O0VFRRVeN27cmPT0dN566y1UVeXAgQN8++23nqHYcePG8fnnn/PHH3+Ql5fHM888w/XXX+/z/IQQQgSmOwa0waDA1uyTZOf5aNaHEEHA645dfHw8OTk55bbt2bOHZs2a+SypUu3bt/dcZWvZsmW5K25ffPEFH330EY0aNaJ3795ceOGF3HbbbQB06dKFl19+mUsvvZS0tDTS09N57LHHfJ6fEEKIwBQXaaZjM/f91aszj+ucjRD1x+t77O677z4uvfRSHnvsMVwuF/PmzePpp5/26v66msrMzKxyX+/evfn111+r3D9hwgQmTJhQ5xwa8jIIgSLY6krvfGW5E//GSjv3D3/UVfum0Ww6aCUz56TPvwO9v1tp5/6NDbR27vflTubMmcO7777Lvn37SE1N5ZZbbuHqq6/2tpiAM3PmTGbOnInL5WL79u2y3IkQQgSxuXsNLD5kYGCKyuUtVb3TEaLWvFnuJCjWsatvVquVuLg4Zs+ezejRo2UZBJ0FW13pna8sd+LfWGnn/uGPunp7RSbP/7id0d1SeOlK3z4HV+/vVtq5f2MDrZ1brVaSkpL8s47dq6++yuDBg+nWrRurVq3i+uuvx2g08t5771X66K9gJ8sgBI5gqyu985XlTvwbK+3cP3xZV0kx7jXFcgudfl2GQtp5/ZXXUNu5X5c7eeGFF2jZsiUAkydP5v7772fKlCnce++93hYlhBBC+E1CyePFjucX65yJEPXH6yt2NpuNuLg4Tpw4wZYtW7jzzjsxGAzSsRNCCBFQpGMnGiKvO3Zt27bl008/Zdu2bQwZMgSDwcDx48cJC6viwctBLphn0YSKYKsrvfOV2XL+jZV27h/+qKsos3utVWuRQ2bF6ly+tPO68eus2FWrVnH//fcTFhbG22+/TUZGBrNnz2b+/Pn873//8zrZQCKzYoUQInQcLYKn1pkIM2i8eI5L73SEqDWZFVtHMis2sARbXemdr8yW82+stHP/8EddHcotZODLPxNmMrB56hCflFlK7+9W2rl/YwOtnft1Viy4n736y/+3d+9RUZX7/8DfM1yGyzgzBnIEobyEIorHnwdZZfK1rxmYZfLrm1QcFCztrMLK0O8yBAIMO8k5VKdvVP7sYjc067Rcp75mWF4gs/RooCaKqagppAeFYRTn/vsD2YcRVC6z2XsP79darmbPs59nPvPM+jQf9szzzI4daGhoQPu68Pnnn+/JcLKm5FU0nkZpcyV1vFwtJ25f5rk43DlXGt/Wq3QOh5OrYmUyPvO8Z0RdFfv6669jypQp+O677/Diiy/i0KFDKC4uxi+//NLdoYiIiETjpW79jp3NwQ+mqP/odmFXXFyMLVu2oLS0FBqNBqWlpfjyyy/R0tLi1sAOHz6M++67D8HBwRg0aBBSU1Nx4cIFoT0zMxPDhw/HgAEDEBsbi/LycqFt27ZtUKvV0Gq1wr+Kigq3xkdERPLWVtgBrVftiPqDbhd258+fx4QJEwAAvr6+sFgsiI+PR1lZmVsDa2pqQnJyMo4ePYra2lpYLBYsWbJEaNfr9SgrK0NTUxOWLl2KpKQkNDc3C+0jR46EyWQS/sXHx7s1PiIikrf2hR2v2lF/0e3v2I0aNQqVlZUYP348xo8fj5UrV0Kv12PQoEFuDSwuLg5xcXHC8YIFC5CZmSkc5+XlCbdnz56NRYsWoaamBn/4wx+6/Vhmsxlms1k4NhqNwm0lL4/2FEqbK6nj5TYI4vZlnotDjLly2G3CbbPFApXTy21jS/3aMs/F7Su3PBd1u5MffvgBvr6+mDBhAg4ePIiFCxeiubkZK1euxNSpU7sdbFcVFBSguroa69at69BWW1uL0aNHo76+Hnq9Htu2bcP06dOh0+mg1+sxZ84cZGdnw8ur86TOz89HQUFBh/u53QkRkXJZ7MB/72q9frEyzgY/99V1RH3K47Y7qaysxF133YXy8nKMGTPGpc1qtWLatGmYMmUKli9fDgCor69HY2MjRo4ciUOHDiE5ORmPPfYYnn322U7H7+yKXUREBLc7kQmlzZXU8XIbBHH7Ms/FIcZcWWwOjCn4BgCwZ9l/QufvvtdA6teWeS5uX7nluejbnZw8eRIHDhyAyWRyuT85ObnLYyQkJLgseGgvJycHOTk5AIDjx49j5syZeOeddzoUdU6nE+np6QgJCUF+fr5w/+DBgzF48GAAQHR0NHJycvDGG29cs7DTaDTQaDSdtil5ebSnUdpcSR0vt0EQty/zXBzunCsvr39ft1B5eYvyGkj92jLPxe0rlzzvzrjdLuyKioqQn5+PmJgYl48pVSpVtwq7riy2qK+vx913343c3FwkJSV1aH/qqadw5swZbNq0CWr1tdeBXK+NiIg8k7rd4gk7F09QP9Htwu6vf/0rdu/e3eHqmbs1NTUhMTERc+fOxeOPP96hPS8vDzt27MD27ds7XG3btm0bRowYgYiICBw5cgSFhYVITU0VNV4iIpIfb7UKNoeThR31G92+lKXVajFixAgxYnGxYcMG7Nu3D0VFRS770bVZvnw5qqurERYWJrR9/PHHAIA9e/bgtttuQ2BgIBISEpCUlOSyopaIiPqHti1P7PL/OjmRW3Tpit3Zs2eF21lZWZg/fz6ysrI6bHESEhLitsDS0tKQlpZ2zfbrrflYvHgxFi9e7JY4lLw82lMoba6kjpfbIIjbl3kuDrHmqq2wu2y2wGrt0dfKOyX1a8s8F7ev3PLc7dudqNVqqFSq6xZTKpUKdru9yw8sRyUlJSgpKYHdbkdNTQ23OyEiUrjndnmhxa5C9ngbQvyljoaoZzxuu5O+ZjQaodfrud2JTChtrqSOl9sgiNuXeS4OseZq4otb0dhixVdPTcKtIdobd+giqV9b5rm4feWW56Jsd+J0OrF69WocOHAA48ePx6OPPtrrQJVAycujPY3S5krqeLkNgrh9meficPdceXu1fhSr5nYnshifed4z3Rm3y4snFi9ejLy8PNTX1yM7O1vYZ46IiEiu1KrWws7mcEgcCVHf6HJht379epSXl2P9+vXYunVrpz/tRUREJCfeVxZPsK6j/qLLhZ3RaERkZCQAICoqCufPnxctKCIiIndo26SYV+yov+jyd+zsdjt2794trIy9+hgA4uLi3B+hxJS8PNpTKG2upI6X2yCI25d5Lg7Rtju58lGsxWpz69hSv7bMc3H7yi3P3b7dCQAMHToUKpXqmu0qlQrHjh3r8gPLEbc7ISLyLCt+8sLZyyo8NcaGW6+/mJBItrjdSS9xuxN5UdpcSR0vt0EQty/zXBxizdWM/9mBI2cv4sN5sbht+E1uG1fq15Z5Lm5fueW5KNud9FdKXh7taZQ2V1LHy20QxO3LPBeHu+fKS33lq+RqNbc7kcH4zPOeEWW7k752+PBh3HfffQgODsagQYOQmpqKCxcuCO1jxoxx+Q1ZtVqN4uJioX3NmjUIDw+HTqfDvHnzYLFYpHgaREQkobZ97OwOfjhF/YNsC7umpiYkJyfj6NGjqK2thcViwZIlS4T2n3/+GSaTCSaTCSdOnICPjw9mzZoFANi/fz8yMzOxYcMGnDp1CrW1tSgsLJTqqRARkUTaFk+wsKP+QrYfxcbFxbmssl2wYAEyMzM7PXf9+vWYMGECbr31VgBAaWkpHnroIcTGxgIAcnNzMX/+fCxfvrzT/mazGWazWTg2Go3CbSWvovEUSpsrqePlajlx+zLPxSHWXF3Z7QRmC1fFSjk+87x3RFkVK7WCggJUV1d3ujHy5MmT8fDDD2PhwoUAgFmzZiExMRFPPvkkAKChoQHBwcG4dOkS/P07/gp0fn4+CgoKOtzPVbFERMr2twNeONaswryRdowPUsTbHVEH3VkVK9srdu1VVlbitddeQ3l5eYe22tpa7Nq1C59//rlwn8lkcnnibbdNJlOnhV1WVpbL1UCj0YiIiAgAUPQqGk+htLmSOl6ulhO3L/NcHGLNVWn9bhxrvoDfj/8/mBEz2G3jSv3aMs/F7Su3PG//SeKNSFbYJSQkdFqoAUBOTo7wW7THjx/HzJkz8c4772DMmDEdzi0tLcW0adMQEhIi3KfVal0moe22Vqvt9PE0Gg00Gk2nbUpeReNplDZXUsfL1XLi9mWei8Pdc+Xt1fpVchVXxcpifOZ5z3RnXMkKu7KyshueU19fj7vvvhu5ublISkrq9JzS0lJkZWW53BcdHY39+/cLx1VVVRg2bFinV+uIiMhztW13YrPzY1jqH2S9KjYxMRFz587F448/3uk5lZWVqK2t7VD0paSkYP369di7dy+ampqwYsUKpKam9kHUREQkJ1d2O4FdGV8nJ+o12RZ2GzZswL59+1BUVOSyX117H3/8MWbNmoXAwECX+2NiYlBcXIyZM2ciPDwcERERyM7O7svwiYhIBtqu2HG7E+ovZLt4Ii0tDWlpadc95y9/+cs129LT05Gent7rOJS8PNpTKG2upI6X2yCI25d5Lg7xtjtpLegsVm53IuX4zPPe8cjtTvpCSUkJSkpKYLfbUVNTw+1OiIgU7r0aNSob1PivoXb8Ryjf7kiZPG67k76SkZGBjIwMGI1G6PV6ANzuRA6UNldSx8ttEMTtyzwXh1hztdm0D5UN9Rg1OhozJt3itnGlfm2Z5+L2lVueK2K7E6VQ8vJoT6O0uZI6Xm6DIG5f5rk43D1Xvj5eAAAnVNzuRAbjM897pjvjynbxBBERUW/5XtnHzsbFE9RPsLAjIiKP5XOlsLPYHBJHQtQ3WNgREZHHaivsrHYWdtQ/8Dt2N6Dk5dGeQmlzJXW83AZB3L7Mc3GIvd2JmdudSDo+87x3uN1JD3G7EyIiz/K/J9UoO63Gfwx24L+G8aodKRO3O+khbnciT0qbK6nj5TYI4vZlnotDrLk6uvUoyk4fxZCImzFjRrTbxpX6tWWei9tXbnnO7U7cSMnLoz2N0uZK6ni5DYK4fZnn4nD3XPn5tr7N2Z3d2zKiq6R+bZnn4vaVS557xHYnJpMJkydPRlBQEAYOHIi77roLhw4dEtrfeOMNjB8/Ht7e3njppZdc+m7btg1qtdrlN2YrKir6+ikQEZHEfIXFE/zWEfUPsi3sNBoNVq9ejXPnzqGhoQEPPPCAy2/HhoWFobCwEPfff3+n/UeOHAmTyST8i4+P76vQiYhIJrzVKgCAhatiqZ+Q7UexPj4+GD16NADAbrdDrVbj+PHjQntSUhIA4LPPPuv1Y5nNZpjNZuG4/WfZSl5F4ymUNldSx8vVcuL2ZZ6LQ+xVsRarnatiJRyfed47HrUqdty4caiurobD4UBRUREWL17s0p6eno6oqCg899xzwn3btm3D9OnTodPpoNfrMWfOHGRnZ8PLy6vTx8jPz0dBQUGH+7kqlohI2X44q8Lao16INjjwp9G8akfK5FGrYvft24eWlhZ89NFHGDJkSJf6REVFobKyEiNHjsShQ4eQnJyMAQMG4Nlnn+30/KysLGRmZgrHRqMRERERALgqVg6UNldSx8vVcuL2ZZ6LQ6y5slbVYe3R/RgYNAgzZvzBfeMyz/t0vP6e54pYFZuQkIDy8vJO23JycpCTkyMc+/v7Y/78+QgNDUV1dTUGDhx43bEHDx6MwYMHAwCio6ORk5ODN95445qFnUajgUaj6bRNyatoPI3S5krqeLlaTty+zHNxuHuu/H1bx7I5nFwVK4Pxmec9051xJSvsysrKunW+0+mEyWRCXV3dDQu7q6nVsl0jQkREIvL2al08wZ8Uo/5CthVPVVUVysvLYbFYcPHiRSxbtgwGgwGRkZEAAJvNhsuXL8Nut7vcBlq/Y3fq1CkAwJEjR1BYWIj77rtPsudCRETS4HYn1N/ItrCzWq145plnEBQUhJtvvhmVlZXYuHGjcDmysLAQ/v7++Oijj5Cbmwt/f398+OGHAIA9e/bgtttuQ2BgIBISEpCUlOTyHToiIuoffITCjlfsqH+Q7eKJ2NhY/PTTT9dsz8/PR35+fqdtixcv7rB6tqeUvDzaUyhtrqSOl9sgiNuXeS4OseZKhdZPciw2B7c7kXB85nnveNR2J32ppKQEJSUlsNvtqKmp4XYnREQKV9sMvHLAG0EaJ56fYJc6HKIe6c52JyzsOmE0GqHX61FaWopZs2Ypdnm0p1DaXEkdL7dBELcv81wcYs3VgdNG/N+3fsBgnQYV/z3FbeNK/doyz8XtK7c8NxqNCA4O9ox97KSm5OXRnkZpcyV1vNwGQdy+zHNxuH27Ez9udyKn8ZnnPdOdcWW7eIKIiKi32lbFmq1cPEH9Aws7IiLyWMEDWjefbzbbcMlikzgaIvGxsCMiIo+l8/PBAE3rt45OX2iROBoi8fE7djeg5OXRnkJpcyV1vNwGQdy+zHNxiDlXYQY/HP7NhJMNJgy9yc8tY0r92jLPxe0rtzzndic9xO1OiIg8z/87pMbPF9R4cJgd8YP5lkfK053tTnjFrp2MjAxkZGQI250AUPTyaE+htLmSOl5ugyBuX+a5OMScq1/8fsHPW4+hyS8UM2aMd8uYUr+2zHNx+8otz41GY5fPZWF3A0peHu1plDZXUsfLbRDE7cs8F4cYczU9Jgz/s/UYttWcw/HzlzHydwPcNrbUry3zXNy+cslzj9juxGQyYfLkyQgKCsLAgQNx11134dChQy7nvPfee4iMjERgYCBGjx6NmpoaoW3NmjUIDw+HTqfDvHnzYLFY+vopEBGRDESH6vCfowbBandi9ls78ea2ozh2zgSHgx/LkueR7RU7jUaD1atXY9SoUQCAN998E2lpafjxxx8BAF988QWKi4uxYcMGREdH49ixYxg4cCAAYP/+/cjMzERZWRkiIyORlJSEwsJCLF++XLLnQ0RE0lCpVPjr7N8j/b3d2H+6CSs3HcLKTYcQ4OuFoUGBCB6gwcAAHwwM8MUAP29ovNXw8/GCxlsNTdt/vb3gpVbBW62CWq2C02HHkSYVdtWeh5+vD9QqFbzUKuG/beepVSqoAKhUgAoqqFRtMbXGdXWbCgCuOr76PKgAu82KyzbAZLbB16HqdPx/P7bKdT46zE/H+SLlkm1h5+Pjg9GjRwMA7HY71Go1jh8/LrS/8MILeOWVVzBmzBgAwIgRI4S20tJSPPTQQ4iNjQUA5ObmYv78+dcs7MxmM8xms3Dc/rNsJa+i8RRKmyup4+VqOXH7Ms/FIfZc6TRqrF8wEZ//dAb/u78eu09cwCWLHQfrjEBdT0f1wusH/+nOMLvJG0t3bxF1/Gd2lrnc06EIvKpH+6Lw6jan0wuLf9zcYYyu9FUBsDu8sHT3N1cK32v37ay/ze6FZXu+FYpm174dHwsArFYv5P60xaW9s75OZ+u5k6a0wBDY+XPrLY9aFTtu3DhUV1fD4XCgqKgIixcvht1uh5+fH1auXImXX34ZPj4+mDdvHnJzc6FSqTBr1iwkJibiySefBAA0NDQgODgYly5dgr+/f4fHyM/PR0FBQYf7uSqWiMgz2R3Av8zAvy6rcNEKmGzARasKZgdgveqfzQFYHSo4AdidrW/kDifgQOttuxNw4sp97e5vu40r7VduCsed3dd6k1fMlKgozgaNlzhje9Sq2H379qGlpQUfffQRhgwZAgD47bffYLPZ8O233+LAgQMwGo245557EBERgXnz5sFkMrk88bbbJpOp08IuKysLmZmZwrHRaERERAQAroqVA6XNldTxcrWcuH2Z5+JQ2lz1RbxOpxPOtiLQ6bzy39Zjq9WCb77Zgql3TYW3t3e78wDAedVxuzHhvOox2rf9m81qxbbt2zFlyhT4eHtf1auzcV3jvrrNZrWhvLwc8f8RD2/va89X+77tR7FabaioqEB8/GShf/vncr14rFYrdny3A3dMvgM+3j7Xn4Mrt202G3Z8vwOTJk369+N18rzazt35/feYkTgNGl/faz633lDEqtiEhASUl5d32paTk4OcnBzh2N/fH/Pnz0doaCiqq6uF4mzp0qUwGAwwGAzIyMjAxo0bMW/ePGi1WpdJaLut1Wo7fTyNRgONRtNpm5JX0Xgapc2V1PFytZy4fZnn4lDaXEkVr9VbDV8vQBfgJ9ofcAN8gMGGQLf9AWfQABFBA3r8B9xBP2DoIF2P/oCr8Qdu/Z2+W3/A/eIPjAo1dOkPuOMBgMbXVxarYiUr7MrKym58UjtOpxMmkwl1dXWIjo5GWFhYh/Y20dHR2L9/v3BcVVWFYcOGdXq1joiIiMhTyHa7k6qqKpSXl8NiseDixYtYtmwZDAYDIiMjAQDp6ekoKipCc3Mzzpw5g7feegv33nsvACAlJQXr16/H3r170dTUhBUrViA1NVXKp0NEREQkOtkWdlarFc888wyCgoJw8803o7KyEhs3bhQuR+bl5SE0NBTh4eGYOHEiHnjgAaSlpQEAYmJiUFxcjJkzZyI8PBwRERHIzs6W8ukQERERiU62iydiY2Px008/XbPd19cXq1evxurVqzttT09PR3p6eq/j4DYI0lPaXEkdL7c7Ebcv81wcSpsrqeNlnovbV2557lHbnfSlkpISlJSUwGaz4ciRI3j77be53QkRERFJ6tKlS5g/fz4aGxuF37K/FhZ2nfj111+F7U6IiIiI5ODUqVMIDw+/7jks7DrhcDhw5swZTJ06Ff/8Z/d2FZ84cSJ27959w/Pa9so7derUDTcbpK7Pq1xIHa/Yj+/u8Xs7Xm/696Qv81wcUudNd0kdL/Nc3L5yynOn04nm5maEhYVBrb7+8gjZfsdOSmq1GuHh4fD29u72i+Tl5dWtPjqdjv/D74LuzqvUpI5X7Md39/i9Ha83/XvSl3kuDqnzprukjpd5Lm5fueX5jT6CbSPbVbFykJGR0Sd96MaUNq9Sxyv247t7/N6O15v+zHP5UNq8Sh0v81zcvlK/vj3Fj2IlYjQaodfru/S7b0SkTMxzIs8ntzznFTuJaDQa5OXlXfOnzIhI+ZjnRJ5PbnnOK3ZEREREHoJX7IiIiIg8BAs7IiIiIg/Bwo6IiIjIQ7CwIyIiIvIQLOxk7NSpU5gwYQL8/Pxgs9mkDoeI3CQzMxPx8fF4+umnpQ6FiEQg5fs3CzsZGzRoELZs2YLbbrtN6lCIyE327t0Lk8mEiooKWK1WRf2EFhF1jZTv3yzsZMzPzw8Gg0HqMIjIjXbu3Ilp06YBAKZNm4YffvhB4oiIyN2kfP9mYedGeXl5iI6Ohlqtxrp161zazp07h3vvvRcBAQEYNWoUvv32W4miJCJ36UnONzY2CrvT6/V6XLhwoc/jJqKuU9p7u7fUAXiSyMhI/O1vf0Nubm6HtoyMDISFheFf//oXysrKMHv2bBw9ehRmsxkPP/ywy7larRZffvllX4VNRD3Uk5w3GAwwGo0AWn+KiFflieStJ3k+cOBACSK9wkluN2XKFOfatWuF4+bmZqevr6/zzJkzwn3x8fHO999/v8vjWa1Wt8dJRO7RnZzfs2eP8/HHH3c6nU7nE0884fzxxx/7PF4i6r6evLdL8f7Nj2L7wJEjR6DX6xEaGirc9/vf/x4///zzdftdvnwZ06ZNQ1VVFRITE1FRUSF2qETkBtfL+QkTJsDf3x/x8fFQq9WIi4uTMFIi6qnr5bmU79/8KLYPmEwm4Ts1bXQ6HRobG6/bz8/PD998842IkRGRGG6U86+++mrfB0VEbnW9PJfy/ZtX7PqAVqsVvlPTxmg0QqvVShQREYmJOU/k+eSa5yzs+kBkZCSamppQX18v3FdVVYUxY8ZIGBURiYU5T+T55JrnLOzcyGq14vLly3A4HC63tVot7r//fuTl5aGlpQX/+Mc/cODAAcycOVPqkImoF5jzRJ5PcXnep0s1PFxaWpoTgMu/rVu3Op1Op/Ps2bPOe+65x+nv7++MjIx0bt68WdpgiajXmPNEnk9pea5yOp1OaUpKIiIiInInfhRLRERE5CFY2BERERF5CBZ2RERERB6ChR0RERGRh2BhR0REROQhWNgREREReQgWdkREREQegoUdERERkYdgYUdEJDP5+fnw8fHB4MGD3TbmnXfeiXXr1nWrz6JFi+Dv74+oqCi3xUFE4mJhR0SyNHToUAQEBECr1UKr1WLo0KFSh9SnHnvsMZcfFxfD2LFjUVtbe832V199FV999ZWoMRCRe7GwIyLZ2rJlC0wmE0wmU6cFiNVq7fugZMAdz/vXX3+FzWbrdwUzkadjYUdEirFt2zZERUUhOzsbwcHBePHFF9HS0oKFCxciLCwM4eHhWLlypXD+xYsXkZKSAoPBgAkTJmDZsmWYPn26y1jtqVQq4SrZ+fPnkZKSgpCQEAwfPhzvv/++cN6dd96J5cuXIzY2FjqdDo888ggsFovQ/sknn2Ds2LEYMGAAYmJicPjwYaxYsQLz5s1zebw77rgDn3/+eZee+9ChQ1FUVIRRo0YhOjoaAPDkk08iLCwMBoMBCQkJOHnypHD+7t27MW7cOOh0OvzpT3+Cw+FwGe/rr79GYmIiAODdd9/FLbfcAq1WixEjRmDr1q1diomI5IeFHREpyi+//IKAgADU1dVh6dKlWLJkCZqamlBTU4Ndu3bhgw8+wBdffAEAKCgoQENDA06ePInS0lJ8+OGHXX6cOXPmICIiAqdOncLGjRuRlZWFqqoqof3TTz/F559/jpMnT2Lfvn345JNPAAA7duzAwoULsWrVKjQ1NeHTTz+FTqfDH//4R2zYsAFmsxkAcOLECRw8eBAzZszockwbNmxARUUF9u/fDwCYPHkyqqurUV9fj/DwcDz99NMAAIvFggceeABPPfUUGhoaMHbsWHz//fcuY23atAmJiYm4ePEiFi1ahG+++QYmkwlbtmzhVTwiBWNhR0Sydffdd8NgMMBgMCArKwsAEBAQgOeeew4+Pj7QaDR47733UFxcDK1Wi7CwMDzxxBP47LPPALQWX7m5udDpdIiKikJaWlqXHre+vh4VFRV48cUXodFoEBUVhZSUFJerawsWLMDNN98Mg8GAe++9Vyj61qxZgyeeeAJ33HEH1Go1oqKiEBoaiqFDh2Ls2LHYuHEjAGDdunVISkqCn59fl+fj2WefRUhIiNAnJSUFer0efn5+WLp0Kb777jsAwM6dO6HRaLBgwQL4+Phg4cKFCA0NFcax2+347rvvcOeddwJovVK5f/9+mM1m3HLLLRg2bFiXYyIieWFhR0SytXnzZjQ2NqKxsRF//vOfAQChoaHw8vICAJw7dw4tLS0YOXKkUAAuW7YMZ8+eBQDU1dUhIiJCGK/97es5efIkLl68iKCgIGHcVatW4bfffhPOCQkJEW4HBATAZDIBaP3u2vDhwzsdNzU1VViZWlpaipSUlK5OBQAgPDzc5XjFihW49dZbodPpEBcXh4aGBgAdn7dKpXLp++OPP2Ls2LEICAhAYGAg1q5di9dffx0hISF48MEHcebMmW7FRUTywcKOiBRFpVIJt4ODg+Hn54cTJ04IBaDRaBRWcoaGhuLUqVPC+e1vBwYG4tKlS8Jx+xWoQ4YMgcFgEMZsbGxEc3Mz3nrrrRvGFxERgePHj3faNnv2bJSVlWHXrl04e/Yspk6d2vUnDtfnvn37dqxatQpfffUVmpqasGvXLqEtNDQUv/76q0vf9sdtH8O2mTFjBrZs2YLTp0/Dz88Pubm53YqLiOSDhR0RKZZarUZaWhqWLFmCxsZGOBwOVFdXC0XOgw8+iBUrVqC5uRmHDx/GBx98IPQdOXIkGhoasH37dpjNZrzwwgtC25AhQzBx4kQ8//zzuHTpEmw2G/bu3YuDBw/eMKb09HS8+eab2LlzJ5xOJw4fPoy6ujoAwE033YQpU6YgPT0dycnJwpXHnmhuboa3tzeCgoJw8eJFFBYWCm233347Wlpa8M4778BqtaKkpESIAXBdOPHbb7/hyy+/REtLCzQaDQICAnoVFxFJi4UdESnayy+/jMDAQMTExOCmm27C3LlzceHCBQBAXl4e9Ho9wsPD8cgjj2DOnDlCP71ej9deew3JyckYNmwY4uLiXMb9+OOPceLECQwfPhwhISFYtGgRWlpabhjPpEmT8Oqrr+LRRx+FTqfD7NmzYTQahfbU1FRUV1d3+2PYq02fPh233347brnlFsTExGDSpElCm6+vL/7+97/jlVdeQVBQEPbt2ye0NzQ0oK6uDjExMQAAh8OBlStX4ne/+x1CQkJw+vRpLF++vFexEZF0VE6n0yl1EEREfWHNmjVYt24dNm3aJFkMO3fuRGpqKo4ePXrNcwoLC/HSSy/BYDB0+Ei1t9auXYvNmzfj3XffveG5mZmZePvttzFs2DCXFcFEJF8s7Iio35C6sLNarZg7dy7Gjh2L7OxsSWL4+uuvERQUhNjYWEken4jE5S11AERE/UFDQwPCw8Mxbtw4rFq1SrI42i+aICLPwyt2RERERB6CiyeIiIiIPAQLOyIiIiIPwcKOiIiIyEOwsCMiIiLyECzsiIiIiDwECzsiIiIiD8HCjoiIiMhDsLAjIiIi8hAs7IiIiIg8xP8Hnhe1ngILPScAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/springmass-coupled.png b/examples/springmass-coupled.png new file mode 100644 index 0000000000000000000000000000000000000000..bc898da099c18ec2c67e9163878f61ed10a8fc99 GIT binary patch literal 58410 zcmeFZXH-+)7ClN+0Tn?+kgfi;B`hqw zVk|7|m-rWfzgR8*Isj4z#}ZId!Yup zx=PR4@3rY&*VS$7W@90=b5`>A4^+~HHq5&bbSJR57f#`kkt znh(=EFM50#B{mtcVtX%fqnE~RlJDLyaHlGf3GIB`b+{3DB~XrnLTr}k<*5KMbwZ%N z39&x@YvNdjhWeSha2Ra<+LNx-D3~6M2p1Qv@-{l=Hm>(;5!|L)f%dd#MlTE~J_X*Q zz~91lE|u}lU~AU^EceJrP1;yq9*Y%tjgN)xXNH9byut>4D1jd=ESw~q-+#d?PQv~D z8v7;YP0-|lA{Leymh@9`6&LK)8iF_@kmE)jOU(Mkn9rX;#J6r-5WmXU$!Zx3BWJ$+$6EgV@^w;k;=h0U$9g~Cd7Z?oBFd?7^RH{d5)Tl?{jaAyyOzW= zEOCoWFU>gif12R;jo#dZUi^n`e!qd|`yT7f(2LXZN9upIAvPWd>dN1Yi;aJU3>y#e z`N-C`@b7D~7yI>aBNPPe>V>Iswk@~j7e&#o696JlWTz)k(7v_KNS7)5eToS#< z7RkkB6eiyR*WS%8Y`&>s85mVBAP#IDg&WR9fFDY#?E+>Y(FJ(K#m1{4k(a%J4d9N$ z1LtXLiEPhai&FIXMrt(Q5n+_*xyNGTemvf(Ug~>Pt#@Ar@NWvAjc%) zG~uvoA)4^aRym^B>&+{@A4tyZqiYU0g*=Cjq#tH?VI}nW4om&pWng7?bFx+}%8w3yI?LK<&(b_M;uU*RwI@zQK_vx?V2Xbu{i=1CQJ5apu#HRM2)bhV^QgT>^ycfv2vuqrUW6Q5`8U?MNW3snICB^^RUCZCiVTq` z=C=p0>&K_|N(-Ba9*6fPLcLr|YBW!yMNgXS7CxCoUZQi+h2*W1(xF`rck`fY_9C+c ziuX276VXK*C#q#n%R)m#?NSka5apNp<)1$`@y1h~Vjkq_%rh>xP^j0>6uOAA1eate zcFQI7yiUhj*|Z4ab^5Y)j(h&pyXUa;c)aovaA{w?N2%%dv5tRUE^XN zSw?Pn?pGNhvq8#kwcfSlq9>b8&ywT5RA!7vx&KI6IjldP)}i&-Y+$LmdGXxUM#XhW zWmVGolt0l>SIA(jDIq_@h5E)Nq_^x$qG40xD6pC2-64L+bK7i%;BBgxLEvyYv;t&vOc6UaPdIsDBFY<{P&R4A54}k+O^A(pmR}n!Ook$%wn(qVQx$b#ZNmiSxS0tJOO_o>s%9 zwtf5Gnghtmg$2Dfg!g|6N8qk)gckJ*WU#B{C)tPwohJfVJMoML5wipV72xZV*B?!w z(xR{9-Njjohn%8pQ3%cy4uJoYR<@(SSU^)fe_rC187lqF&P$RP9x+@J*4%wLBOQ zR-0bVcDJ)pFVOeNi$Qjbvb#OiK#wFH=kFcUy{a$Y@B6t_M)$o&P3K{{iEF>m)Fbn@;RbJZM6Sqn_}VpqQo_4!D3AQ0bGy?lV6phx!(X`bq6*M-LFbU zN-4T_C>wv9M<97wUPAOk%H`63ghsEGjpwdBxK-!Hr*rg;Jl0s)_@G0zwot%YHJm=) zaY$W$U~k-JgN-c47c%NJ+h{j5Y7(Vol{O5ReQJA2(KCDatpQ**1_t^9iTy+qp}AXB zqo3r_OM$_`k?w)5hVS1VudQlV$4_3{c`zl4pJP@nJ{8bg>b@(_KdB;e@cEkKU0v(MOUt&fO(sW-61<)PYvt3WSb1nH4B~bYUb5+Dw|akNvgAji0LW;b&1J` zfZ;3=hSf8K2q~d5gkz%SFL1fQm=&N0e$XH2n1nUug5eaVwf+sZ$&IRwTDxs&=8|sB zOu_!ziVqkdqsv6%vM+ifu_Nz$Ji?Dti#nL=gs<|fihB~Yy5s<>@!Gboim>sTqk6Wn zN13-e=oWfP>%K0KaBJ;X`0)Z;3t_l(1yj(vG;!z-H~miMo6u`@r~KrFKV4=W$PhRd zQ97vYsI?}$keU~2I;zl(n*GSA>hFy6$J6NAebE*5Ue=mgtzc?QYM{7}17UG*CQ}U` zu3dMW-z}w-4IxudU8+gU?X7W1s4=kJ$PjUCRIWSDt%^aN?v3YVDgR2wIUE2+C}H#! z#w6ogPsFCvcjF|kacrEd)M;nfG(&W*RE^esUrB2@s&t9a8R6IU+-1{YxfHFNwx3-+ zJ;k`=?%q38v6!Hta15_APk;O#sebh`E3j)_^!Z4zMuaR^RgS6Xq*3KYGr5jOfzG$0 z#M9O7;tXM{O0KBG^NM~Ez+*AuqH>&P+dW3y_c&eqDY9$gXno{fc*TdQnjO0b9^d=-=JyYO+OXkEWwtO{PLCSTD;?IfZn z@^-m2&@T!aI1}DsJ^}zog1{@gqxRcpo54MZH|2S>G+&QF$Tp6Fxfv2YGgnnO{;mdO?yuwQd zviYnJd8EzA<+rk{al)pU8g8wc>Ml_5N8M|fN6g1d-`4gxUMq{LE0*fO#Qk=bBDC_y{ML=Livb~eeI~JDIEo&1 zZUrMe&hnWz$x*{5qaQXtwcDRxrj$f2(S2(Jiay>RDyuE&;wM?5KK>X2ly$Gt**Uj! zbH2yVe`4{z{{A_z%@Kv|&G{a0)Imq}{Ah-tFC>BFjKOJl@^kmUk+FfpMfrIwmH=no z5k((ve_%`yS`a<@krFFNc5Vn-oE0~& zA^zb6kA7*C*B5&$qoMVxjj8>&Qt1HkI@TM!~ghpgd1^(f|N= zZ`34lyURqRXcAfGHQk>ke{28;^Ev`i0<4Rh2ew;74tx~tc?i@YC89zb#A$z2-D=`q zU?sDT&9t?97J+s~-J-5WW-s15UFgC>Jg~arQpCQZ#0rj*@(bcO)Tx@iw zBdx|mKHcBo6|=rn9aO=hwG;Ne!Up#&Yj%g`rK{Eg!0YB88quyoCMg#fVs&3L`be#2w$Wy}!*+FFWhEdZ}gUZ&VXDssNye zQZ&KL(V0ol3-DQ3o`wAf3}Gy!qsaIxVKjaWq|i|m^Xru}oOtefXI_8yQbH2AcAJ-O z9Oro%`sc-?*DzsyoQRc6cOCA|ImL}^#8*<9nF9hB8qaE-z-Pgq^%cmjjxTM0?-E2d%d+z8dXyXi`np8 z&N2>d&4r#=)jiLa2OYJ?Ys|{$9QwCQ{M&(;?s8`ci9l#IO0sjbh0X5_nW`J@wu1Ba zPJftETTBlcp+^j?fggC+sVzWW5?hUIJPVQ0De1vMki;V?PuiU#5gO>$j?O)RvqmIN z00ibu67OutyK~n0Z~s4cT-e>25Nhkfb|$YJGL@q*FIlFnJt4*Om&>x_ci+l$_HR2O zdX*%0%lPP+Js*nEJQ~}%G4cxt|0@nLkqqpm?lxYGvuVY8YLKU9bs^6QNyClIyQ=D1 z*($3>5Hi+8#of}nP7Tgi^U-!upfy{rGp_xg7Xd;{jS7d;R60qfpq-8HNtqhs?G99! zcACiX^KkQaphQe3pN?$XN=P#z9CC!NowTTD!T8+Xkec zQze$d-bAe^ZEwkBOfEXxvK^^7hE0_B@wOLzx$?I-2lgl8H34MH|MO)Pkb`+Kli5qh z<_NBW`^>wpP_p!F6eDA&oBkwt(9o3ka9qJkdm>k$1HAXQqyRiw^bHsZd7PXB;baFW zn^oZxRM_$c`*23TynqHJ{3k7MV0@*7WEx}FsiY0 z>2pwYG>8#9daUBg9Z*P;*4MC_#8y6Z>Rk4Rg9ETR}vXn-xlW;R0hjMZG+T| zNxp$SiavkO?h$0CNvoq?kzq%Sd@S;;2KkM`2{G9CR{;FGJOG!skgl(r=k}0$`*C@Y zGuP1Pb=txQgg%`y2dE>iNf?o8fb?3iU|)$|Gdr)D|9uVJLcACofj}cQj#+7j=d&Lv z7KK9rL$2VQ-yZZ}7{@11C5?qQ=}#klH@E)M9>HwYlwycO(D)K*Y~+P)Y|L{E@}*!92s6 zHAlvXy4#&Aj?Ixro);piDqk_`L~!qDU;TD9*CIYY}n0Wv6(n>H;a$#xCyrTrg!9(J2sO7gZg2qx1J zMy3;w{E7T$&aui%2KyU)&0ykhmzOhOcA2w5j(KdYbkLK0ojZ#d2Jzd)U<3r4kGI~s{CEp&HuozWCR3yhQ}{jJF^FSY zR_e2~M<5^0r58s}?Q^O>W^pyRc?>>IiLG@gB|KPW+vh06UX=GW-u|; zZ+s!$`AiPjq+W%X!q%u`FzZI9$46G}`E0n0T;E;RfzN_CQS7@S9OFJkYbo;MZZjg* zCLFilR)lKg-?GLriFX9M?!tA}^oMv_sg=FlW_{-C(EDg@R41E`I+5qPeQdxnKuBH! zqTCeqZ-RVgih8-*z}>0#73~1Q(5U?*BMP9r?m~${s_XYICCm)mZKB%WwRIwn?#5eq zZqz^LUGRz(tdM3J5kkfqx#E1YVwrRg$ znt-$iVFZg$&W%zB;p8MkC@BSBd*q`;Hivs6FL8w}^L+umU3Qu_CQ7gHL zgWX7aO@&;iu|2jQV+&=9!2mmYGp=l4s{CQf3!p|^luD|-p^Xa}DZwfJlw4ZjgH-;$ zy`WM)@u&&hfcWa5>0LV}eQ%(HGqKZi{x+unst5%_Q}oz(dy*69IjwACNoYTHbl({uZI(CDLEru34y{%;DLCOkvO8 zJw8O3)Rw-~@zM_;k?f(aD7t230I+&k1F3&hqei&vhcVe%ciF2N7T_qoz~%=ezlCyUW`>0Qt<(ENJY70@^F5AD!1h`EcR5byd)~)TKYe z!8a7Ej`Z4`BEr5WA&s@9n~9@xv$9arsHk-RyISj!nz6-2^KA!Js&`uEVLp8EUjI1FP(WsSa*Gvb`rv4|s%Iaxch&D7*|m!abN2~RDK~`tA$rubB4jxRrdAs>JEyI9eRs2R3&=)9T1TR7veVlegZ#1dgI|$)L){bc5xvv7s#0m*s9|5gUe2tFL*0<*Q4AE1wI?k~_ zp*eRrW?$|>Ee#aL?6v39ctaw@nPWkfkRttYBt*r$2hMlMx1L=rLuh2aJy@1eXCy-g z(1B|}bu+4GWg-hdq|mb}!~dyvtw|7c)p=#J4}ndGqq>{duuj6xb<6Ghuohw%d-N(c z3{yJ=Ix*Q<=wQaX+qP=EQwLR8eFVy5rE@_ak9QCLsV8v%JolHkEHCD#Kv~sy$rH>` zRPU_Wf)I+V$dgAq6OwTA`7*npd7AC7Gl-tJ06>+^pTg7Z>%W&PZ5D=YZdLGv?Lsbb z)s4WZb&<7tm6|oW+p8p+tt#A|*?Ve1_vP?{U6*8I2Ry%rN_EtE%;0t>`m6#4rS@g; z#sOMIpj<(;BS0@RXZ;TwZ zD|#vA)-1#n_KF;bKgh9(0!rNo*SnoF`R*4esfUmNi!Es^v880A0THb}3EvZx?{%5; zh!_Yi4=o8Ux8mJm=U38_)-}$k=Chy4)@;_>Eh`lFV+e|85PAfWGFOd%eY+Gal~?U!VF&4Qut!Wbn_nA82m{UV4t48o_^V=_=-9u}y9oYXL>sL{7vg1Q{gg z%1r^A@iKD=51t0_Y)L?nzo#$ChkqTqSy(7vl-@_?IG$dZ=39O>lgFCKE613sY^(yB z4YB(Ru}yy`reXP>jGV`oz4b*NV@|Gcg5@eH~{2O&F(#!o`$ zPZpg-23rsxV|>x9!kfA#MncuFX7yhCg1xpC5+t%N_%#9-Ap;w;qvgLZP$;DyJ! zna75yKUuNjRL<($R#&u(7#^D7yK-mJ(T7z@r>rlX(To>0HMN$gTnK2Q7bWWP5FcVS zpGAsA%nfx!BO&H_p0$^qEsAC4@@!+U3vcfGIOOsB#06uzP=BxwjM!sNpmt|D%Ysln z22p!Yn^!0GvmwaIytiv;nZ;}Os8eV_=P>Jl(?gRk09*=e8W!LreRt~bys$VxVikX4 z=YH@DSxm96lGU6ci{*bKi~rUc%55gis=&BM=kP$(J z@aCP#9?j7%fSyrMW1}ORD0-eex>NF?QmXudo|UTH0&}2{4BUMRNAPC%)=yZdO1Y33pE1(mGf3onX{tgu&~M2zzFAi)M|i6?^@^-i$`Jk#5$g#WZ7 zKeizVXJP&6RX( zKs)3X!?1Duwi^i$@l2u%iODqtjggS}(`A*1VN&1>-bvaf zC$~C2EB@{l{b21ygz@f_f6t55$sWoqUAbxSy^mnfp zt2?ADXyIm$M{|_MW5~vHhmw`-wM*K|Y*o`hO81n*eBXOi8HoWkp8_AKVvN&{WajpZ z1>!bmHD4k?GViU6(e9%_Zbja4T+N25r{#xjeUF!Ohj=N0D5prokm=TqRFfJ4pyz*+ zB9E>`zCsSFy>smj4MiSvlXIe%o51W_(jogB6SuiF@w_}5F3fY-xOTpZ|0(HJ zdg94{K-YH-`ZJ{vpt(d|x{`0}iAkTIN>}79RygKS^OC#$*uHZK+$|Ko5BUnNSbx4U z0v|J-ffz2*)_yG?ZNfyxT|n%(5zfMwCWa(3md|{(FQy_iUT~@r(`xx8Gr3GM|6<|w zGCy-m&+Uk{xpiGYU~RGF!-rv}k}BqU9`mxp-JCVXMWz!%S+T4Pwi zK!3iZuNGOo@y$TcG|2G2d$~aFL`fg~pc^4< zouN&jqy4?l_B|ga1J)D#LJ_89C3ch+%Xn#0sjX?|Byhxh7^iu2CCA1vg~&qYC3~0Q zQh#gp7npwH^=MJ3*Qm!%H?vvLExh!E`t(?9!QC)!Ts%HI9ERAyS2j~^P|2dLpWAc^ zCUYhB-Nb4P*z=jJr6DCZBXQl8wR}LxY^G~`1H>g=ZAbl+VH0DjVFp2CH*}EmoZDGX zR0m`+k%NbgNc>qZ2kW@heU2VzvI#70ieg_|HjeIX?-B7XC((kxb`eoQHw^#8Q|H+v znh7VeO43cEndPxR83Z(wy_A#jg|`A!x+v&H%j-+ckiCCxzV3_F$ zp~H5?DSDG4U`o#NgX^aof68#Z0zdl-fyo9dVq#I$RtRS1rc!(%AtKC8M8h7E20ywd z4QiI@ww&YM8E;|Q9&LLkffW{&U{AO)md6(~d|;AijLBNwcV6fa>fmyEmn+V=ei(X` zV=UjdY?&Wx6E@{tHTt_68$;k48u7uH#&it`M`8yzlG0u6f`p?=7%VPeZ z4mT-Hh;4~0pq4-kQ4k=wzI>2Q{Zi6PF(m5bTde=52>EOK1#uEW0HuS4 z{c}*|_3=vXrZ7z!_d+VOTpHI(c+iP~YICmf!<9mX!%ifB!Hk3yrk>>E$@M91`ncuP z@01Tvmt0@Ai+_k)1PJvL-C`v1s4;$AL&QaQno80g$5&2&W|;E|opo3DU1mlui=kQW zQL+p2Ny#=}7C0Wj9+4Yvl;bOTEppJN#>GwB2!>&iqGVuaaPM+6zfoskRncI}6jG|G zAgJ%@Z}(SK_xp6`;VDvST&uLSmhvD=-w1_f@(KsV;m4ERE>~l_(2#@F(3|BkL*g5i zIGW!ld{E+JRQ;e6g5ZJ-BA15o!)F=tEk_FhPH~zoU|SoJhM61tmyL99UU%7qU8?jF zt=&K!o80!9E&nd(YSFUH9Pesby!2e)Rq4tl6@d+-C{YGrO%+rRd7g|)XR{)Sm z0Eg-j(qVsURA$3Rex6Y-<`*APf*0w;U(dCi=G%=GmvpBQ10)ZME=KPEZky_M|H3ks z=UAq!<{pE+rlQ?^D%y%JE6=EEb}9nb;>7q3x8{zt9yT_94(YkZ!SqO7=&04ZZ+S}l zTJ@R6QS>ao>a&0^v{*`mv0de&)5YuAirT=3;e<}Xl0BH$e_3QS$r{QS*OP?@cyQZ`Ga%Zk9 zhzgOtP)RABn?O|+0)fN}Vuqh^Z_m7ml(d_aj=l22B7h9S@=6*O+!srWQrS~#(qMIn?#&cM)qC4;9?MGoadN(6dz^zO&it8 ztKC!kqn#L3apM=NaBY^{xCy@zu$Op2|6&GCZN;rN0fvzky$$A3LjAmjbh1tFN{W`h z;QQzGc1pc4qg2gu<5JMKZ9YX0grZe#l7wsSp^@PDfh#L@yVXKp==I~f397AIZ%v*u z0~!nw1|1A>=WZ8VLR=jokh$D{AlfLr_AqOiq$#K-F+j@tXVx-P#nxk(M!{e1DU2;E z7ZJ-!vl~8WH+rK`2!y=#)NirEyi)?{5NBq+X8X9ph-i(7hS?FL8ne&?%|*Pl%c?iy z+zv)Z)-4 zH*5G397F5Pw+9NThmQJ%?Z>E_vf6lPC4T9*i*BX_!UK` zKD^ZKRV#>>+3u^{&~+N~zyaB+<^Ecpx7Yw*{oNiq-^ADT4~g?9kjg4+paR95zHFQ* zXGrYcpOv{cBWBDbue8n6%7HFtQkDjT1z;rCbT4y<6i}M72=c-f#aHyGLMMp~<9$w6 zv>%&I5Zc=)mt3qm8XPKy!~WtpL^vI;r=;J)@mSMxf?UW(&8hhgZN~;ROM_>#ay2b3 z=I99x@6P6wZSCJ0l*jZ6o@06iTNdK!ArUtUl}40eFPQ~3ncsxvDX`tvFF8$Ve$0X4 z^EYRw!a~df92EPCIwhw zAHIA{kNrS2e=7SfBn7UOjRf<$ds%o!P9IT}hPrzhhBDst{legPJMIu`v>Ou@#4s0@ z>Sv!UKp+?M5JaEy2RAIZPN}(a%9{!SQ%cYlI_F!nJYqq{$;#l;uRZ%W8I4xJNf?I^ zt+>lu5?BpJjIgeh)G${F4z=2io3FZCf{Qe%rWYNH_-f!OfIU;SHJ-U zYq5Ri9G1LLI%bi$(Kty-HnNoG$y@k5uY__Hspa(#t^Ukw>WfM8pAISy-za=&%WM*K zqS~IlI+*YYf#jG5^-@52jgP2qTBihggi9))HBjRmCpy&5`7Il-U_FH4r^`IM+2Tf(2hy`uId zU^i#l<~lMrSUqIq*W~#hibcAQSbB9XzpE2fO!)mt(=Z>qnS`?%xWL2{jA8Uo#zg}k zdk$irjM%hxKEGpt*MDW^UxYpi0!fU8VEI)~&To`bHXW%%A#lb$TUt(ZbN$b!M1On9 z*(Q48-y;VtXFCi&V}?t4QC@ziG_-v#{AYcQvsi{ZQmx0rYjgNpI%-DUQB>Ypu|OPM z`2ZAO5uE!z8DQdUiG~bQn>YDsV3RsQvhGrw*rRUxlp3O>rfSS#fYLLw zestQsB!cT0;Iz#}cOaGl8*?LZ`T13<^}xLc?oqr@aDUUI4AKI(@2bD@Ky=RoERZ)o zCV7}E7t@ekbc9sf(aP(<%zIyn0|s+=XDsQ=?L{Qj#yN1vylCIZ>khptYe}Cp=hRcr zXHBPq$%?Sv&q4m!2T!wWRTlq{xTS!@rkcw>tmQoUDnZEP>c67S_#Q0Qy3)*7d$g-I zXWXXF(^zNbVyz&c%*gMq)ASlqfn=_JC0%o}B*<9~ZGqH`xk0<_C!bx^yUV=)4rmM% ze-m~f;HswWkK`UjIy!RL`|d# zqy3LZKc%Y?e=>3~EW4w%2A+S%U&3$umEz<00HETMe7RLn8zKUlyvtunFlZN816?xW za#yDZZMY4)g*0IqV6>V@Wkq2}%S#;pO1ipN@lfj< zs9cPQZjqntPK@WZ6FVIaJuZV%eR(ne1sHm!&PStgZv}|IUwqu*9;5#*%WihYt^3WRv!o}ps$oj@`#NZM7cE-p#H4_P(Fd)CkAIy;q&_m8%=2t7SGwp4O81$&dRCMe_Syuj~W0!Q1;c zM)$3e7L7ar;7P!f6w)R8Lh_DBQ_`$O>*}U8Og0?=168krpWCFumse|PjH)~h{M*lG zr~eg)7|W)^UeD)-PJwMZi1dBHWaZTZW5s!{xyw_QRJ^V=!6|Mc<|88RCC}C^QcS!i z`H}!eki!ond6t6HWsq|b@?JrH#(c@MGUPfT=7+$bo{(ZJ?CX+zx|pTvs=G#~zvcL9;*2I+_TaJR6# z%xD*)iFUo%y#-D76s!4mU`8SAz8bz}{9a4iEguZydIacp&oqCJC@ht$7tA}3r#7bb zFvYEOH-sQ9=fIEmox5dk|78+Sjt*8j@*U2(Jb2qEYxp`?wMqq!NT?kW>9p~@GX6dJ zs-mq%6fs-jw@?YX>e(d8|!kkz2*R7C5vOWf4*b!88(PfR0t# zk1H=bFJx1XQOnuB_dDYd@sv@F+b3o8| zSN|`->Lw0mGT{5Dm8nvPLyG*(T>_@OXGE*g1(jpC(Gt|g28-9Xr8D+~;#Rh$C#&mIs0gCE@XDF4~;j%*p7JN}`lJW+0 zCnDy4CUVJ&q|NN#0{^V{U#2qUaACxS;hjSsLzF^Q2u$N&a-ke_Y9}#Y7XWhy6)ph7#s8sIG zp^j}cS=ul9{r9Yz*<>F`!o)f+GlH-(|OIv8+gn14f(8$r zEBg2|wO!lob?DYJ@~EAj$GyGiOQI*UZ+GfadZy>01&7e}YP*l|XiQgv;B@I%Gh2=q z+bFL?+P(y|9+9%}MM-zRrIGWb6hw<-bGSJ42y0nFnA?T^0c zH0Nng=TXo7Nh%)MDEqg?hV8o>-diDZ2HCP3RZ|s#2m4Pft~2H?l$S7JIJ!X(+U7x)t+OyY`7~ z(9uF8+f$9e8Wgk87Qwpc*WD0zeTQEK^P+UUol07k%x}EplASH%;F16@6;hFJ{j@Md zTNW03Stq;g^IYmpOtHKG$hGg29By|c7ZIq*8;b){OGul7Wk+8Q9A#9x9CeS0>~Rah z=gupL+trAswHStfbpU-6>nBSqrRQOnXesP@fPpzg8HakIp_~riLsaL{0heY`9auFh zXXRw6ZWU(aD%0&1YgM*Y34R@<+K+CyL`!XO|I-TH+*90hMxo1!Z-`@Y{M?MeZ+8N` z11iaG_eOqS)Dy@7<|2&C1$<+R`L?610!bN)E3+__iJto#wnf8&t%gL&yZ*q(!-=a& z1kYnf$BR$;muEE@CLa${WJEb3(>x9Eaet?^S>{(JWZ}jAS!Jn7VabX%b-@EVZ1HZL zrQ>gtB9c{s-;465PlD({y|#DIwQtmVL}5w1Ur)j+P+p5qe;;a{!DDycy#aCut&*}8 zXV=fi52br{+k^Iv$1~ek9I2622};?_IlrVAr+kbIDyjPgcjTX7OVY3mS3Tnnx^h^7 zvaE4pTm{jPD^kL{X8yawYK#TD;Q$QAYJ+n%M;)KBJeR*~YNR8IzLBc*bD6T5)^Peg z8Cy$_j;eoJ_ghq_>Wz4bDoYJj|4G-y__c*xx8TW*6K4BUEpOXjO@wIH|JMQzFzDXr z{fJM*fl!^rGV7~%am#196pp=@ss;{kp=}UrJ=nxg$XjN+0@nEh3N#kJkp1o{MK%4LA(R5b6tRI@KL+Ol;@988kdCk+E2e zceYM%BU4%vi0Oft?Ju1;j~Yd_7{*#HGx(9_Y?>#INAKjlQ5#POQU|6)-4dJmbi6UW zd%U%vVabD=YrdfUW_zNQZaOva;Ihk;x69pn5xEP@&($QyuV+4#+_PYjN-yhh2U;u<~@OX?Ot^3kxhoz1eAVrE(SFI^}Iw&+uRyid0qI^o^@>iUb1 z_Fb|%f^p2f>X`H#eFvxFiFDIGAtdbjTS&;xWZf#N_6=CWVYw!-R4w&z{0+Egx>P+3 zs?jGSzM4BEuy<6}E59*oe%Y@31bCcfnh@YjI~GpUQ?Y5|&W+ZlEz-^$&~YVglcHt- zr`)&qlJj{Cknqpw`||7G%S3#w2BYZcQmyZp1W%0m6&9R9LCm=dj*b>W6(04g8joLm zfs}U)1*=3TN9jDw9!3|vC+9DTVVf-pqWKkJOe7zY9wbATOYVqgX;F%sB$FvH?WICD z+;jTtIATg#Rkid%MNxsXnZMo=YDmx*9xL+Z)rV7?1TC7evjxa@tl3PM`tJe z0Je1jdpriYj6ckv|Ea0CEF|hIK_+fWn-X^?02s@t9>% z_e5O{VYV~%p#^Qk)Zu)cZo`{}=B=7q!J(0zh3=i)DH}ltG~%Y53u?RfaCrXYIG)t% z7tCoO{Vk12{6CS#qDdPvVPu&Fsr?yS&vzG?uo%j_JC1II#XG7A%0LB%Y$y7T%xB6@ zJ+O*WErswRIkh0x74wl-?Vh+58=+1PsSK@|fSEXYZhV~U;SO{fdR(9lGKYt?VD)z6 zYG5~Z7K1kOKnkQsYcJ6Q9)Cg(aI!o$FNrnj*dq~?@n99XLLk1VadI|_e>J)6$F6q_2B<9*hPR@ zSPj8F0ym&8clI##i0Yzub6@r2U3ajqTuQICmwxMZ@Y$~sjZO7=F;rAQnz(AKg{pNI z+IH&9c}?U%S4UiSXZlssRnJq^k(2H5cI~_94<~ChYBkTMi(Q(a!E;)QA;&%kri-mV$L`Mtfd|2|9`Rckj6>IUZur7yM_mITUQEbx2+{X2&mRHC5Al<6o zk!ZU5d2YO4v2{cMphg;zrG?mDt{uw=B~fviH~lW~jD8)qYTyet8fB)#Gm(l%7n`O& zvL!C`PEV+s?UJTGL}N~g0QhEjMSFV^;)N=ev8djOssr!rMQT=*RK!;S=O={Gg3!9! zsjYv79oc_Q73F-%wz^(w_({Q0M|oN<6j8O%N?DaqzF{?YXu~%o0<>A{b@2~mXBp^~ zUCb|h7QEr{evb)X!`yKXuG|>0HlFVFpv^Q7_XoEPwRZ)cB;WxUWNoR2598_<&^>+MOk>rKFkM~$Bxel@_mS#m$}4jJ$5x*EPpKD3t;h3;%H$4C<^ zx7+V}SDKxyoh*(X?vo<=MVre?MFAV1fjbA17qyUK&FK8J?}KQY?a965z%EEJ5R|O3olxdhQj>^0jpDH?)8IDoXnnyuar*Q$rF@TYiVEVcmCu z0`-;FN}gNeS;M-gc~@Hq)9-@+nd!rwZXx$eLqZy9sjd6KS@o)1mJ3;4Z(ihnh_TWC zIF+)yDRC`iOHthX4wOLu=*Lzo&yJ$xhwYt2Rm`#VLg0iz?PB8M*m{@!NBZ=g;kl5S z9YqJ!T0!P7ke(j%T1k00ra0@JIWX}YrlHo1c5Yz(IIqx?gH7p7mt#M~5}wtpJe`0F zX5_gU+sE9_TG)Po3Q?*pYKe6%8aNP3|N;CmuJ@l&gU5%9ge(O5*CUP&7c1nxZ@h^nP+F=3POS6pWI%h64r+|8;n5j9 z{m{b2Y1#lmOliF;KJ&mNu3@8@3g_fvw6a;Iom!21D`s?x*DYC#dDsglOC(EW$DlWe z*Ef*Yl&uaFw%D>==G|3>z{s9};C&fFsn}6qb6;%jMcoHh90p(}37DL!y_jBhh)-GH z>W{*orEKsj`jFLZ8n%Y338*sq%9~Pvb?0z4UmT#<3+ps1Z9hmmy)XqIkSP6?}_a z?q^Wps`TsW0RFqDOYx8ILt>RLb3b&PWRtSGtQd;hDJE@6?aFB(z4q6Ms&fIB_eb`x zkt$Vs)|-qU{_p?aiP}ZOz;H+xOsHEwIYW3g!0ts2MH{qzMxW~@9qIMaVmpnrT zpT7A3ev}5)_+XAJEza7U=cF@dvyu1lUV8trzKdsPl8h+Ya^O&QP-)4N$KwIiQzx1V zDPIPadSNmC5aopU%~&on0*qxF3<$b(pR6Lv2i3#0Io31Tip*o}^m@$(6myrA?LoQU z`u;E4-a0DEHe44+2`QyRMN*Is5fDL!5CIYCp&3FNMCl$nL;;nQ6r{UBVvtmZ?vkNX znjwaX^P=Ck_x`Q5_wSsw&N~0GU@>dn=Y5|0x$o<~uIs*cP&c!4DV`1bP6gyRSIbFt z)F@Aga_{uun9tNIwv1P3*3>93czjl#W){8rcpFATzAMj2^0)U;@r77<=mX_f*zF#g z(7HJncs3p0xtHmMajksO0gF=Hj778n`rx-1Dwad}CnQ++t@_S62EFs<`-cxyQn9?s z)1=iNm&B$H+0%a_04_CB*nVvxj=-$E_9? zt-Zf7=sKPlQMCDRbZ%zZ!v%gXWe%uQ1piB&67=8IDY_y0*~vP;8SjM(iq?ehPb3$K zDS`9m$HNc*!!w~Y#=0&PygNg$Obh`VYhFL2-EUFBe|pm$`h7t=`vcv!BOpEo`S z)}*wk!G%hh2gF8N6yCq_vC}h|kq8$y`^WNt(ex@xyzSDZjp`$iK}(hRL=&W&%Bf&g zlLVc>Pjhh?`0k#&kdI^KBm}{=fpxdiA$7nIlm;BZae!O{NeBL{QCy(o!(yOg1d@9W zEk|7XLX^P}=Wq~=N^AMw?K=9R4Lg7M|5MK#ZRVcT7F^Q2eqD1o)w-k?%l!}aj1AlW zT+f6jxBWVK!4oClSY-$JRUwt|FG%F6zutXNs$ZGixWuWN*nmUxD(6D?q)Jw@7~tDh z+kpMu-eD4VVk~JM6eOn_{IS*ljW--(5q~ku5y89boDD{t_u~M&xLZ9SaQG^E`TTSM zVN6W-?3yfT&0F)&P83-F?+i)a?3lV;O}_%X`>h)<4W! zWbXc32-$uAlCN9vv zyJ0fC8(1z|WGV>a2nF;5XAfuG&LBmcOdAJB{wdoS@!e^%x3ajUK zEiEEd->IbYA=RQVL&CvM_Bz56*VJ-&v6;Hf4Ta;zKg*nc|AYI92FY@4)aWT2_yZcz z)l(SGf08qgb(}u*mR!k>b8s@61-QWlfr8oPg}XQwIZHCm^=7lOhnX){dTuB4C|`XR zCJw;2*Col${X8vS(XTwf)RDfE$W)0tg#E`BHEgXl}w@Jy>yVCaxJEM9{I!E zWM_OkGg#-X{*J@uH|!gNO1}vGflcA5f3{8Dhrp_dA8MT9)1A6CMK>Mqo$IdIp-=&SupA7l|bsQ_FT(OBut!_E%-C@;ia1!fF>{0jGq|%8`YvB;4e%j|9 zYvR$Wh7j=aQ^7}K}c#ryS_u!R>eEIi?g#tH2@DXj?A%RPnRypg} z0Fq}WvA=&p-?7qO)dZdn`dEBwRYdRi;B*HAro(lpz<_v#{jZ?AQG_fQ>&0G%)Ef0h@@#-7x-np|rCt5y?@5;H@YYDLG5?W#q*t11iFi#;Jea0&P9UWJ1AxoIqA z5&t#^v0d1x*rf3?v`1#Y4d1HkaMcPh8*{yw+n|z7n5P5VkNTDzue-Xr)kq%?DOfe0 zJJ`05q&dL(VKD0VQbk zyz1A(XrN`~w_BabR}3yav~(J{nDbuU1YFoiZp=zJ>9EETxa8`TDffEpAUz8Ris#wo zR7kLoPv^8RG5EcKq#yN8tDp>4P7!77G@?nKzvm}bdcyQbmE5T6rHVJuLuuiIup{cU zTQajIPV|@xkENis>JMN8P(U{M;ieT4%>q_B1lnMHiy%Dy^62FGoW`tIz30sh--z;% zsv`g+l`Tt6omyaPjl1k2!XH0fbROO~@7yDp|4syS2Dz_5BNCq;dyRF=FlSBB^VMiA ze7t&Rk?CT-tweL~Oo@1sI3^1$>@a6d)PIT6uvP>RWVmj)_RgyN_<94*dkC>1(G&l0 z7Tj+e5ML&CEZ<*u;?n%D`{`*Ft{Dr$ocSU!rjpxz)xE)lWW93N?u<K49OU{YS=PbYYv2%l>p#n`7## zG3P6a@hQ{_-)zsX@8aWg@24*#A|NLAVLKhoIC;Rbc z`yOEL+j@TuaJY4LJl9~^+IMVY;$59I8Zn??$f;Ba;K ze4vmZyN6OY0QY0hzY8KGUr<-aI#x2YMHPAr>YJv{M>LD&Ayy%8f*Le07kP$F_0sW) zC4gQ`ZD$_AL3*~xvI@h-`)K6DoUI+kA*p7al}x^x!*ug`^VH+XWuSvYR{y@|Hl}O; z8gsJXZyWB*b9Q_UZgqLixbKXEWEv@RTLgcI&Ntj&t>Jj}vXtWv75sBiAyMQzeQ&3= zHr>Xz9b3*$wNl;IK-ED0F0g!v^q^PFjwVC;$zxkF)yYc2;vR>l$M3Rp#>>_sjR{?J zR&UEEj$7QS1ym@&e}uNZhqYARv;lfkLa77OV=OnNSK<_Up^pz>-?(1`*sr)as#^?m z-*vZfJ+Vgf&>h}i|3JKGV_1=t07YdB)_)Haf%&JE3N1P&xh?H>(sIu|0IOy#%8$tt zB^9?saW0KMn@DvzRV>dBWSOv0r8I%$b>VKPIkDj{>@U7ft+-FPl zz;7PLz-2xg)m^ zVg@jK)jXMT5Q5D;)!6cWsUhSu$S!9aF`>Gw9rtk$bAF@LRIZ4VTZM84KnPtM%9Q9? z3ixV#^ppk4`8rpCRsojB*1ddaD`4gI`P<#2OH69bhAz9mr+gt7dVz0eAzqe*YObaF@SvY z{b+Py@8YPG&JGl$t)wRDuP&Jnc*K1N3)+-Q4|?Km=HB#VKJv&4d@u};uAf$ujag*+ zuxpXv=<~ZoQ834D`!5Xvki!{Lxd8h_BE$rWL1L>;X%IdZlgozZ1N=AVfo?l?pv1T( zVPL1zAv1sPQ~&QCw%6YY8EE~jwa=l5le$9*=#fNgy9#1#GT^QT(+pp{kKV&tmYc@* z!HJy{l~@6}!u8avu3e-H99xRJcNKCxI#YBSX>&{N!F8^R6k0G6J<$ z-`fK^sXQFZml;QJj9*}RO#pan3zH{1z5QWIYOlF^BX|2~-4j%{jurS~GmU?cQF3?k zER{8v&afqxEC#3);*a%r0HgRti!^MrL-RbO=H4Ud`SveY>dqSZ;&SK(+IKC<>$H9k zHQSu_+bhc6KlP1f74>*$7g<=d=cpJSUW8C5xfbYVJY3dbYVx~NuJ%% zdIlQ?rF}2EteTG}7yu*Q5rfE#fg9JvreA*c?0TF;o+`OZ8Dqvy=K-9%~WmU~U-LXe1bkjcJ6G5&OS0n&tV;VA1v$4`Ar1o2rydtIh zBg^lozxt?7l2#uKK!Ot=+s~Y$CSPNL=8AMR$!loFGze05-`aeWNN63QMZydF~%t;^-PZ!vd(u+jEH~vvak=_Qz|piv{8v z*TO!p{zlmEttG2^kfcZ6ZQ!W1e__cdD2os zGWvJhLR4D8pTUtxx|-j2%#1$6EP&{&#&;7b@ZKM@gX*#yNRwR6;5^-k=c!J{J6$(G zcdU=FRZvk5^;)z@=w_yS&QIfBjUmdnFQ$nF-)jf9mD~el64JBVhPp|zbdGH2kndwo-Pg>X08@jx99&V68S?so5&3OxOHL~e2wX~EP|o2{!>xQ>3q}gla*iH z&*uYrCV-SqDle0WII^uhj7+ta)-Pa??AJKVqU#w{J>HZEaq%My#i=ZY^#?0&{?hUp zj5p1jcMeM+;CU=xeBap=D)$_V(%U#7C|un{oT8lqF1jFC|8)tuSKj^y{t!7h*p}zb zP)-4Llyl=MJxEWyIu>}&=~L15xBr-gj4HM z$qlSPSAqb$l=?ZZ<@YrD8_FdFe=1bxc@ox;OJ~CN?B}DtyPCN$LwjGkpAQ1->(KJ! zpWT}q&44pbN?b$3^>{5e$^A6(WQ#wF{DP$dTCOrIRaa%}jmq%d*|flAAJI2v9W<|l zgqo)7iP2|0AVE~$7`xnd2n#9;qq~M8CoF%@`bpkx|kiN`j{J=);>F+ z2Q>juh8RhzwTUC3`Fh-b2Em~wt=!zkSa7P{hF=nL^(a5#fc_?ZaAFG@qX$$rjJUFM zU$E`tx~|)3H3RaPD$m)W^4IT)3BuY+j)_dR5GFFiZsC1Ss{Q< z+ZQ#LnV%?>^Dq5ODrn8yk%zUW~< zH(WkCPY<)FoR-ZtD!V67)NDjZry#UGBn~_FcS=*8skSdN}f{Qm$NSe zN{z!k>KZPum%@Z!{8luuKC!w+L-x_CmIRzMF*++C1c3luOHZ+Yd@ZJjrgH@rRyyPY zmBQ7jpOV(Tl6x-HsrP|(QjmJxM=z)LBBE5VGWNa*kaPcIa`y+?M{+C(g`I}!zuzA- zjLN-Hs6m}sbDB+O^yTR}DZg|5`}(e&FuSe2;kV!WMGf5YdX!OZWh;U=M&NkQDD7@>3kHVJF_W?f3u?o~ii zqi5=5PO@g|yCb&dLoZ}H$LV7i28ID8N$i9EKUo0-?5ykXV^Z_iV_yW=QrYS$&5$LO zw?*h_=EfZ`kMd8wYz+{u?%{Zop)g@(9nc#1hL{|qPx8U&jV0B>Awt%Ao0z<=I#vl! z(^LDdHFUp3IqbCS(CJNy-d96YLb1nH$|=7H8bE`)nYeB*qz?hwz1-hP@>p_^N62T9 z3~mF=ov3}(@6Zp~BaFw9;T9-*0UM~z>)W_O^-=`dVG{=aWd4VWaO<*DtC029(@e#K zv=IPvk!@W(<+IOBZt|t+a?^XDCX%wsY z2Jre@?E-Z9xGtagC}Rg+A>U0^)r%JTU0gOpg8D4v_ooBsIoxz@FYKrH2u}Ni;bK^c zCB1)n_tKvr$pOf`@*r5D%A?E@97_t$*$0hdp<$K*^yP`53Wx@Gbwt|^tf{3@zs1ex zWv3e|gI$gf4#eDb1XEJa4rW(!5p?)3os`nHHMmS$UpDn;-Q1LEW%gdDU2^qT>u) zB3V16IIjmaNe4dpk@dtPA>e4R@-$@gO|J+Ruvp_g|M7*TA|>JS74))PJoO!hTx{vV z3-dE>;VNF)6bijP?*WDaT`F{rJTax4ofqe@Qx@DXW)MgU#Tt{|U|<)&T;{VC9gcx` z*$SRNi1Bnw$Nib0VR8gwX2$s*()aoT2&z za2r2d1Nm2jh+KXS3h|)e$6xDVE$CiTR%y-QUj8Tp6Kqm4Zhe5y89F=LTW%z;342p> z{~4~G6DQGfu7*V-lXRf{FfLqdFJjI10^;*CxBt9+7?;E1F5(dT_+)<@((u~6@mTAq z{s?rw@@euR6y}ia371GctsT^$7)})675etPue#f;e&{sr=z2Z|Qu3`mMW!01TZt<3q@E?vRk!no?c= zl{FE-va$2$ek-)QvZY>N4{HMBN4lcj7&2^(;KOrQ%SP-Nr9*RZH^ z+zjEFMC<1J)vS;kyr}T`K|hq}>c>o6bDDGT(6;01xR;eQPE^MAY2#SHHPe^DV?ZlH zDx(PouRx%8%Ms=~o@dK3Qm>4mt2TQz&hN)Ttj!1SJ+RkUbQ0&A#`KamE6(FZiB(Lekf%ezDTR@ z;`t@5wpc_#7CyzP+dI2sZ@h0`_KZ|_7O^UDIw&HRR${NdtYWo8ydlC(7i9nlrCM-& zE#MDKhrbojU0tZB#Zk{ts_*R46jCM97t@1+J}X;Ez-*8wyQ^ftL!QE+5qCTyf!kKH z4sD3lgZLvuv6tf*y3b$>6$}rK$~RLhQ2jzw?1MN!U!VLs;1QcJ^Oe%@;ijsSd0*$w zk^|QMsuNl(A3{#^xa9eAWsMQbKx)6k$66TlIHFvc@)N9E9S0JMRHbGrawP=Mqc ztkh1k_J@bLE+>-f&j%0zkcqwRN6^!Hz3_sxY9buTwS1aO+A`5yK%7lbM4Q@dac@ij ztP)v;`>IzsC_|ll*RPOSMwe(*7QA(xUjHI=R?CQ{Aeeb8K& zAT8kEjd{zl6tnP%cVU2;lCYbQlIkhtgFybP;hg*if%~`tJ@+kLy~&;3B!WXznD#zu z-bgpUXm@j<^jm%_YU|(%G}pixN!nRIo+%VolAs`Mnt0fTD*txaEB$Rd?W_vhc(mp- zUtHe$jVy;)gq5hX?X57L(!Rcj9!cy0 zex|SY<9$or9w8NZ`b4Jok0s#|th!w}n7TPC4Eg>m6>#N{eJQA8eP_IpkrLm+%w43d za`Cr8x+UVh#QaoOI$&OV;y5!7px>LTQ{KyJ;wL150cQ?NQ#DLY*#Xa4kGra|*_hi- zHN&!JZn&-~7OzMnF^AcVP;O1~$SWekPZVH~L{tSVh}aF42b|D|Ntbv_);;yEZCiJfJb5}Vw+jR3Ep-M0 zt7sVnDB+d{LN()q=i_U*Y&D0MdKHV4*EThi-+lvA);_Olhbo`G6dE1iZx?B>y!Mr^ zllxupmA<@cZC*&+nM;lBaP|cCfj>2*mGxlNTC?jOIoaRq&4oj{*mlo{ z9U%cO?nq?Ey49xf0}(i5%7L!2;Zv{Jfw@Xk|?dzP)D7OND- z8GW1*c7JxiWox}G^o|$JBBPlA_(Vc^SyT!J9gE#YV+~?rEM&rQ5b zQLgVrZ#wO4hxL@zN9$dskSl^oZ z(36-fqegN%#d{8(&E)nvlzC4H1m_sgc5INojcadpMFxa&Y}X7dr58wZtns9(_NBO` zI9r)8m_4YofJ9GHFeT&#HUKVAdInuVGN@|k;{^Qoy%y!Tx9_#;T`abJIvcrnorspW z{EUZ8ey-H23h%)r+P6b$W#& z5UN#Pdgkhf62HaGY3y^2kXrrggDRmhCrV`If{ibm+-UKEWhi+;^eR@B)L}_FqsvQX zNph0D;cms-`k!HjEFY4>4*29HJ(QR-y8I6+F=Em)u|G{uSh%anaT_5$m}(q%ZX5Vyx>{+xkkE=gf}ke$rL+kxF+T$kA|DAqeo`ab z5+Sa4>^gmk7`xUY0U0@?_XkSgOC#g=-^4NQtl+?%>=k0uizS=!JVhN!f4O zpdK=?ppS@9toO9%+;pRfbnB_oH2-kc*@(*heMZ_9_X<w5F6&Hz+D5&*nffMq z(@(|E8@DPp-kvk5>ym|Wzxy0ChboxhG4F2Hix>+MN+iz~*`W1ZJQ}F-YrGQBB6DUO z$0tyu4=umZ0>NN*S=_mS@5V~>v_m#E3{36jLRR=TYb-nhFIJX{813xTbi*Q!PJMGg{1YGeYkbC_s*b?Ulj*jZmR>unTU|eAOn-Ri@3~J8TA-aLxHnn# zh@fcbm{oIeZXhnE*<;n<`dARz2j%Nv{Xm1ja5~|X@x=TM%NlYG$98_rbC=+%As&l# z5EISh)vj!CGl^Eq{%`)uE@!p4b~5@ptp7sLHT!W1$yTmNIgJoWuiF`_%(GiPm=1Nh z+pRO)if=Dh!AH1_({ojn%&2rQStN%tG`N;pggbFb=Xz}JgqR#p{cHACzqKXFjWc77 zB7X0e23DDJey`ZNk9uCpG(-x`QlKAgmsrB@ijoPThI;n_>&uUquW!NJ25;GrSWY|t z1@c?34I3e6OeLJi+?b55gwEMgk09pF#Uk8>hp<*$dWH~a%s z2{g}a3GFFO{t2j+oq)1l?$zOH7-hlKH?NOEQf^4n1Cf3Tonnm_?Kx>Wc!R-biVt4{ z(J-+3-e{hBIhmpL7sC8ar|kv1#RtFkts)}3v$VTB=O+sDQTb{Py__L!9r8sC8Ax?e zKgn5;2Bxx_2snMoD%!wT2Z9$V(F_4+{ClgAW8W|bV)+W68MBbfOFzj~}#Nd(0t&Tog_SL;%PDNaRNq|I#nlk_Tmc8DWg44YBjvzrgwQpg^GpV!yK zizcS%QnZ|@*=+4{j>>249;kP`xu49|&SIMV zFm=$c5KAvdQvIYe2Xh9;xA{5q2+4#f#?~3sH4COkU!F7~b3D}=^EbK!Z}FpTxJoR} z`Aw`Rp5@}WkHca`qKj`a4?d5S)4vgd_og5`B0(S6YG`1|giNf@HjYR)$ty;RNDaA^ zuVl_R!|iQ{75QT#`H~7*Gj`Oy96Y41^lbMH3GaMJg_|^YCc(OCA zlwh5Tl4tEShIS#w=&-M5rmIy6iVa?24`8>yx-UN#>fJ}P2@ws%99(58iPaRwgXgmn zBgJp$dA~8JS?+)2@D0NjKg)1R16;eeTQjF0BwqEoFzRdFTxqD)4rjHoFhrn?2x>o4 znEbm&>}t9iZ&h_|Im0-Th}TxXvAV6Bc*keD783L441unKZplS`!b@g)ZQe^ztGSq? z`)VFb*RBLIoevO@_>Ib-V*`@>Ez3aF1M30fp4*zfiI(VT@te=kvgQ{m+@*WDYH}0fN*2h zBpAAbZTXJ+8;tPqD}35TE9PE@fJ^nauJLgmJ3G;9iAmq1VkMwLaB*LOyz=_673-xR zJ0p{{yg>xT_i%auI#q<%34qVy-#l@$)((V$mN;v6WsuIB3_#NEzcT$b-6KHs9=ps@>w`9+oe98+*rINREFTQW<9vL5ee? zUFm%xw#c`A=G?l;1-qkfQ%mCF2%Y6O8i*M9b9;u|$1CPLj!I_yp+Ft_eCUh9aS^Lk zFtvOVF$?BKyC?ksNO>z|uUSq?8M9(9-$Z;0%_8znbpsk1+ie-g z1O8JKpVzyeY)_DfL1fZg#`Z|h1t%es zeP(ZBrACnEr%~|jz;Nj#-%i0dh_gG?!Rm`b9 z)HLz$QstNjvTL8SE0A&ienrg38M^hcgZqBMAivXZ4pr~-ziim|i2&F58btcJlY6zD4J0Lm!Mk`_P&DU~d?_Gb9u$(9@ z7n*%h4C0G4(a4pa7t#E3*wg_Gx8bj`NU0c*FH2tH_9q{}Q{=6Wv!{yJxMkhv5KO6< zcZ00hBA;e~oLFEXKbgzn+kxxd14wNer*?vmB!rIF= zmdIb#cbL+j)b<*;6Kpzf{Wq#Js}KnXq*>qQWivyQp3<4XdzM#ZXV2Vc#;D|q!`G|h zELYLkW^8EY?k?zCqO%h89n<#OS*l~$Rdf%#894<5lgZf>)(~^Y>vjmj)0q&FgKZXg z#PFy75hF4lB26@qbG%>MJF8qQAkHXmQ08espji0QZ8e!YglezR!unH1{&eBZ#K z`|m;7DvhdvNTci|Aw6zFA?4bedDO9c4StPRnT3?~l^{eORgC0W0SoY?+h#+BdIy?! zLs*Gad3z=a#EM}v*vJUhiQ<47SolAiHvfXB8V^qvPvwc6PGpeWP32&%#i={9S><+c z4db}C!IVd9R@#)jHr+uzM|}b{w&uD9_m%y4l+9i62450CtD!75P}Y3OcR_BZw68f- zG&Xo2E`zUM!v=%aiNT{M2iFESbp3lZDFb zgOznQb+Od3BEs^L0c$Hy4L}(?`dcwJ0`j*r=)qPP&WzRgiEmCw-`u|u^PM?S6=%fv zS8wIPc42fSwZS)5<>_g8$;wn0rAc)d6cN+k-1Y zT3%~hWQ7gV!p`%S4KFLLsLfQ?I*PdpM9OHtYV-iCi*;-@cch535~fmZ+(u@Gf=s08 z8bO^{&-Ne8qT&%_pgZ+d&z|rw8u`?$j>sfl z$&}}8#dPYxISEr_Xzj8hA$%NzY!Ufqt?-EeDZLcUQ%&Ay8ecYt3bVTsco>-@)Irhh zI`8U~JLPG~RB0bi!)ruUUC5v9`)!hnkmBDDeDUE0+m#giwb4~_ilynoDjEf*t7TFL zIY;<-a@XbQONuFhazS#!aZ~47ch8ITs~LLMES;l|O4Wv*rMnClRx|xAd~&SJfQJ4J zJG#*4eL>pDlr{X4B?_3VsWJyC-n25i zaPTL(C&K#dy9IdwIUG+q12?WhOKez)Nw!^FW45~aw~m$`As@0}v3yEED!*DCNB=Ah zZ6zg1&l%Gr*sRvgE(|*0k9}B|L*`t}N12>?b~kcZo_}5`YTdP->B4i-Qql_2UgCUEU2J3{PQ!D(5GOlM`Mv~VMf6qftBc+7}-kR?sF^Jerbny z*Nn||$jv5*?y#BiQVP%Fi*C3?n>44f#;0pV^*9bb_C$<^Id6{*sVrG>jytEb*9Gkz zDp1}rO00gqp`+^8PjO{i$Re9kBpuI(PYjZklf@jsEdjo3)!5JOj0e>=gJnx1B*E(q^`PBu{W@rG zJkR@OK6;A{S0?A3d`_dN$=ZJt@1O{I>e$>Yd=VB)oi!UH$wXkusAIk2hZ&sRS>ydl zw#pVI6Im+vi|T}lhjT;}~= z(F3EkGVNSex9Sv=b+119@%^9eaDp1?tWP=av`d=w`%be{p6***%I-_~r)7x4^(#ov z8qfq}9yAM?|Ib^`3U6QpoOxZF%Q8G3hcg|M9>@jbs%~K3i zN-1StTy5(uVrlh@Qn;92KXw2e^8Nt}fG}@+@IZo;kI~Lx22XX*Q z*mCYrl5^1TOVt(57;PaC`S;v#bm0N@Kg(hn{ud@+_8ZGe&okD7EDg?}iW?C^JsBom z)f0-`J!O#!koJ?MTWpI?)C@s19ZqL1+IixBvxjd4hmU)Y*@%c<;&orA%mwDpH)uB9 zX-i%+oozfqV0RFoIb_bhmx&AnsxcNh0zubN?X>e53pg_rx9EBmY6jPx7H_y0FE?W|0>$>;&)Pq)miur>ZcK!pKscgwr zX4S5vHXG(8)S^hkcdb3?A>Q!=0acTfOcww&~OE zvCsxDsM4>G|0JpQXc;suS-cTquDE~R8^$}|4HJ{QK4>wP3CfYA-?N31G5eG3M>{Ts zdBl z57N6b3}3kmhKqR1VYFZO&E$Jjsjho(pM49{zYe2Z{$;d$R~0gOSWuJpI7EnV~@@7P)t z-Mv4H`1K~Rh?WRHE#}GE^on!-)npo{JJ&P(ukO9pE!BHiCBCBw zw`fD}Q5VLf zoa~Y8ofkQFdHZ6!_%J1jOdg-a!ZW6?HOI6ybfK9c!)~uz%+uV^MMp_f;aDnfW-G9 z3vObc5jwdA{8-L{b%vkRFIht3Cm|h{{IRIn#Mt$-*F7j&{9okg^FipV`8PvyuZGXC zr!biJmUiY$x?Q}85|j7K>i*G;i8S{KgMK9tYFINn;+_<_cIzo-Pl^JD`L$=faXX{Q z2XX1qw(%GyJwR-sv2Ru zBYJ(=h^+RT{Tk&zGZ_UFUIs`oCqAuPugxw1gMP9e^d))ZbOy{)>lD#ZbE0!|OkVX*1#2 zV=tWhyURirB-g^sbb8cXMR*{eBVAO<1Qu|BTaC^PA~-e}YznCPv|sm(%6fL~I_>t!x^%}#cjvX_Kc$Ta2ZNPFT4MMM|@j0}GGp4*%Q zrOW?G_|7#;Rs(LUbY4?guGA=N0FI^}=4pRxR=C3yBpl3A8F!VLE5j*jrc((>1bAaHjSDhT?N1MKKy`R?vp#w`TF3A*jDjHUxAzN>{|9qawf1nHT(w0 zC>FYza?S{`HCo`@w{4l>VfEPNRxH(PLTIvA&+2L8Uy0iE#Rv&BFS#?wkjgW;=A%^o zj2AUd2y?T-86+a@O?I3+Mz6gxcA1Ky*t=>4ktGwYgSz|KSQfs}XKh)3yl1yIn29iB zFbkt1iowjSe})4zdXqUOk12Bw690kySKsQRAW+n3CfcMj5fi2EXL0n5<|pO+#r)~F zgqH%DOI*zOPB0co+>U%Anc8;{IQtsO3B$)=?*urQesPIzL|Sy@b@#SL@Ves74A9r_ zy>Jmz*&>yD{)|~!9lvyw{oh7uSw)1_j5wxvc`S7*j1?_T7ivY`639qre_l#uPY;fa z$Qp;oUMa1aY8>I=svxF3e&%qcvpQfR`r*Hqx@={>ABkMb_U9~oa~lkD(z!G^SYs!J zOpf%-pxU~2d9!1yOseV7jQYyibhV9Vu1K(jQ7xtfb}hp~x4-B_bNi$`b7$yJ(`a8= zSoprj9fLc8KARMEeu)W|kQlj?Os6&XD0R!hjl3M7gaeunmd;DAo-DQsKpTR~8^MI{ zxs1VQBC?O3iCXuCE`>nB$Qhv=WqkW8j=JO-vQ zv4`?~wKDLhvf!5PS{gYhlvdT+fa5*lbTdo-IoR>_=O;r?dpVhfwSn|)C4Q0L-Rfn_ zlJJ-5F72r|ZKEPs!KhDiEx&2aPtXlLj|Y;Z<=^ohG_*Qs=7Sh}Qp0Y_M=AMxCzJct zrIL+4V^2>1qt(6t zTD0w_2B~a`^V{=$IqoihY0Cqq<&Te*8}Bb%}_A( zPAE0(_?|~Yp-A2_? zx67K!B#+*SepYq7*5#CmJ(h+yNJa#PT)=u`PGtCzM#iKJs~Z4N3VrgVT zOvu!6ZMlD`XVcTry?JY0G8G#gKUo% z(qEr@jO?9S1}Ca$X}$|)B1|XArVZ}tA!Eo#&mFSTjC`PZ(`K}C%k)L0yzvj_!@K0{ zZx*At70oG$h8oAPi_5-2Gf_@Hl}#-8gm*l`+tj0F%9F1tHP5}ijk+mn^Y!j$6IbB{ zBm>uIMkC=MDyoN{#@{3N*=vilYb?aGLpdBa+yZ?}h>?JWy_WU)yc`VeN>#e4e%;?2 zozBW^`Mt!eG8h)M1~4xbkJ8qqdoF&CI#vWRM9VQ{bD9DYq9Ipa!YZN`%WJ=r5~&Z?%8_=H zbUIt%KlmF)^vwg?pYv>VP9_VILElBWvXn4&BnC5LYUB9`0((LQ-$*BVK`HKkd?sf< zgqlpI-OYL%LGkP1$!cW@0d^bYs|Qa& z#K}|Bdx}Cnnn&^%x5o^5=uU{!WN90FLqqwTQdkmEn4eE*^#`+95CDu&MxXY&ouuCi zdKS{7K=9pP#MtQ}zu1$&z*%QK1^!v|5<}|{ddfqvuhf0FPTYSWQGmVqI9JGt8F$um z;f+1GO5?MjLv>YKY@4zcf806wflDqxvZ zf4)Gav@*=+9{|i~IWLPJVyDc~`(1aj+n?dPJMCE6MSo}2GR^z&=RJwcvz2?Ph~ys; zcg#WNOqdNNkbS`G5tX0*L~mKGOOJLt!T?D4Mbkl^>StJo5wl znRJvR{N-fEZLF-8(ntmA(+B>?FYyp06N}m_KSiZ*^g-_E#wWQOAL4^VQ3XE_8YBqFc@IyL zkn4>9zq$kI0iDf$#Qa(~Kwb{32$xbWsG`IS@=-0wZJTDJwnG z7wQ=@*{NR_m#1@Hwwag>hwKVj33w5^R0fnkVd?*FZE*Z46aCfl)MMl-iw%SE>mZ!} z0zQjv-L&;>hCtTW=3%{CHy9y~Ce#0mu=kE?YVF#7L3$6p6TnRmU62yMfQVa^BGP+D zrFWzwflvfgnp6Q1l-_%9Lg>;#s`M5>F!Zy6`+4{Cz2`gQ{H4Y*lC0e8o@?H7Ue|B> zgXHC2TG09N1fFSSx)wN8vWA$j1-yWYK&Lw+Qp)hYb8NJp%1ZI$Kw?ngsG;kNA?tEe zCr4FzM)tWmk6$ClUYa&cmMYOT&4&pkwaLe?!51HWQUnc^gPi1d$ceVUjNYC7;+ctJ z#&0XpMekot$K6)Z=-M77*~HDf#7tIL$krzw9Oo@Ufv=-K89%Nb zaEw%wgXs*W%<&W=nKCFoxF+(LhG(Lt$;0hM#!sj+ak;i>%)UQFqE?pcPB8KoJ z&{ORSXxA{lo+Kps(b=@lpW>eYvK5$*HJ)ZIUSa6eR7LUEFok2w<;lP);1am_u5hWf zuv~NJ!Y|cD;Gl&G@5(+k0r<Wsg>g!96MGbWH>XsjIoHzZ~sr1q3|jNo3#&JSL=7e%)0 zI;7!lSHo}$6Bebw*b_T670v*=-?~l4q3L)+HBlR(5|qmnpa7VrZT(N35xZA@nS$qy zXDKh|mig7?fTGiZ%a8T`o@ua9Lx0P82ZaK3XqnD}l~Ta_VAm|*I;cKwC8ZKaw?mGqb(9I!EH>Y~`$qaK6*XFzw*$tPfr#cCF>T32h~IP3;kXWIkBk zB`;H2_#q_7j!`aiAGJDFj>CHz?Y@-V^9)MurrHsvqa>L{B6c0Z#!Q}A!aQ!83Ow#j zKp#Zsn)d)icNn+V!q9M=f+w_0?AFjLcx!9a!03i_!_MepuJ5q(8zOSF?A}r4?_5Mf zGYURHvP*&dwL#!8T&}|n#;xn2RXy{xFN-{D``wcHwO#D4p1CMQEVFAe1$irMMhy0O ziBK?D=S83d&mt+Pmtm-OrVMgzQL*u=mRV+-bF}$bdYtJb&$v0 zUNuD6v@a5x>eO6!y>ubFa2jLiveZcG$1MklocBs!glvZk1Gz3Mb=vuEOCXLaKca}R zG|XT+Xn>M@$g?KY`ON1$UFnl$>(TD6lW*!dLU}H?<+|yb*+S-Gw0TYkvbaFd;nnXN z)iN-05dgGPG(WnI6W2eZ`F!{?N)d9!>+K`-^WZ%LxC{p9P!Wfai&DF=mT7V-k;!L- zq^KWZC}D#O0&DCp{a-1R2NU(R9I>8QA(NKt-TV(i=2ai8S-K$6J36Y5HA zCTO2pJ{lGNcc4^X*#0Nu$A5Jkcd#xh3Dh)x6+G&QiD?mg=@1qeuqJ*P;4|#&(vG(wtIcx>9s6Z9JSY8YA{J z%!ql|xdd)v1+BLs|JG$Y?f_qvwq>>x;%MwG*pvT2;rvaf_Fd*l%yiZ*ZQ@4=rMxku zqCij02jdE*`#!nwvGQD)&jSNK1P3`qJ-J_*)!RM~=8OQ+8QikQ%klG?Gtu{0rV=-` zJIpo&4)e)&q!;0DZu2~CU1RE*a%I&En!9yfFde4yGdKj~hcttHh;=%B7nAhc@JVRU z%C?vWs9=eY_Y~bg2B_{d?)tH`)dvS(xk?9^yxe_zXKe{x6E=h=U1?tFJ%3$SU1_wm zWRBHN<)^tsG2vD^^{QD=-7ol5g2`(0II!}UjwaF7t1iwN0UacCBKX={^S|`4Gv+VB$ z7(ARaHK)viIK>k;+FZYK+hobTCq|AMFi(mEd&HGyG*Pc(x3tmHR+i4%I=cM!He{+V z5#)m?HA88ipSs2PsKUszUohgIUOslQ?i=GHerEEJro_&Jc8vFZ{p0YEp*L{^nIoBW z%EIa)dhqw0nd_4NQ9ipV<^?VvX_Q{r349p-hbe4GOKGsf4Jr;nP+gYU??RnYum5OiIlxvA!N;cpzX$StAqUy$qxdHjdB0WTJ@$`Z3 zb?nbGcc;Y;RPed(jhN_W0Wls3l>4mai$Tk^LPB>V3(2#*H%vRc_~BiIt5!nGC|9EG zHz^;LVP70}h%QF0!!ny-+QZrG6C|-`=02`DPtX<@BvFiEp|Ocvt5fu+W(UE!dZ4jK zP`oOWV@pM5BoRk)f_G!`gbDw2b3_2{-G=>YUpJsgE(dwm+Cq6%YDCh~W&0ua)A|(H z^Yd%*V_G86Kxqz}(v#t{9nqdoxs~6-7pykdzxwffFhVduTA*tdGjh|T&(XQVq{7|n49xyw^k9K$TPOtq02LL+#XNOyp zjbTZfdS{!8@`x(y+Vc!wne5N%`$liVI$;3{LV2(jSIPoVIj?<|2;!Nj&rd`sLkNQQ z*;n>ZID@)m76~A<{?lT^mhlw9616d$ou^J8xOE;L1ip23c#ot&dQGqRvw>UUS~s(! z9k=d5n*iT9DuF!#5te&)gsf@Yfh zjd^j^SDGIwlFTA4{p65QTzc9P(oV@6f$=DUV$LFqEt73;pVfVn`<7l3 zCZB=ourF`VnWPY}Z3h?YRL7#g3w`>_SA%Nt^z!1uVa zG}{%3`KZt)1 zyYKunogkW(<58Q77>h&_bv=U$PHdTgA|GHWu{>lHcAVlW1)6S?+cjmvo|pW1RiU<* zU0a09cke)FOqWHmNtduKZA)74VvYB&fSwnCi<*Oe_hZV{mW~-!5yoH3lv^k|f3>PV zeFyT|zgRkEp)0Lh3HNIR_Unna=R@uLpN-A{UcG-Ia^zC2%T;Mixh(!T5!uC%2{vbZ zfE2ord^ut6b9Km~6Hi*lb$jKEHPAx#Q3*d%Xy@tQ9JQuRj|modGF=}Xy>ar(IW18S zC|~iyAwgaa&r>Iv301hdqb(rkfiX2X$=0wLk3jEd&=ClfxZ|drtq99yk-W zb$-PrB#K?To+azvnVGL;9 zP8Vx|=5{LML|tOA8ebV)_LhvqAj48h$g@^2*{VSN3ETw$&78 zC<{QB{cSrB5G0pPw2;z#La3Y{5dawxosiKK^>yOimT6Xj450F3^RB_|XzJSb^DMfJ z3^v>n#et^sAi=Z_F?&ge8VBjX?K9OwRdsO0DtU6BSMZb6Nt&(N3gsghp$kLcLO>6z z)NYCfSHNDQPlicXDl%Gj2Ib<>(P)Bhys}W@I?H6Oz2ut5l?&~ey}aIjX*!!`g%ppy zoGT;qWKK2saBu7bQ2g7raD=0h`WHD)&Ve`hF(?!HA@}+5qcAEbN-ir-|*qO zRIueMJreWD4kPqeX-8q!D6Ps}-qPA{Nl|j+dlVK2c8WrF2@|rHeRaFlvnjwh_Vmkg zvb5$8r`LT8TE5szffPgdm5f7qn2M6mG}2_kZ>#01;I#R4BqaY07D?sM3^&~hY`DE* zU%gB1J)n^=AgPl8ce>5_GHRG81lt4NQjDbD)x!8=4$HeRxGNQ# zVp86#Fz>|ZCKk4472%WU??a`6fP#=k{_|3LU19G2(F8Vx94kOXUyN5UJ%HRmQI>S`So?Vc8DHVY=r`Z>a zmN;Qe0k0=J;c$HH9KtZ#vSH4XxAGQlcOleGosc-YON7@>><3G#DPD5MrIO6X@8P4`7DCtEASKBE#gTk29H7BT{b>qb?5x|SLq zMTGW=aws?l%0tBkTA$c)AN7$lx~T33hk&VQx61*+O=#mP)2mKceh9;_>;6L8tet1F zTO~v5|eZch~96l39L4Rf9X>PURklRh%3Es-7{t3EDW5{6jT6_({kK#lJhj>RVAb~pJ&$V}| zLI;I)Zq61*w-a}ly}ItT81;Yy{cyIw00qBmtEb0=;K5RN3*IjB?i$uIk`>v3DRXT+ zrZ`dqwu~o>fvFDFn?Ys~`xrLD+Hpyse`E`Q;cCDWtYLbjud`=G8=ugUR3TcCBdlO@ zgjgLWMEkb@o`aq>Y9We}Qop);k|_(Z`>qVc;{Ro2;4tJ^WGIhG!-i7PyDr0a z;06W=YzEuSzQNQruIi|TmX>Yf0C`FURIB%H%hk)IkD&wvHlC>1I+{>+A;mbw@MPRv zMbIrag}zsoxX$pvsqrx2yWwRi{rs9QXYWAHy}z&=^noE7wc7%S<|mi zeN^9-6T9Q0-bHu3opALr+HIVJ?r~7hsW6K)e-eV(pZY06x0Zz}N;kgh+nRrm`mU~! z-i3A}r*rUO7})38b!7ZW6O#R1)zkKq8_-VHDI`K zHeo}bs`;ZGk}h0BCP{O%gQU#*7+qWc_udrS1^m zadkRCAdkZKLS#fKr6a=Ew@LypU-C1A;No&gaVm6l;vx({C0AAjhKC}^xse@9`OHOv z&HS9$!S^Y0{a+Ecx)vPZnnIx-R+UkHbqwerkmqnPfuxh)3UlguN@i)m5@z5=-wl!k zIU~juvqT;Jeek?XxZZ#e>^tY8Et(yIS4jxUW84 zdbHiLIapa(`Ao_B7RLyco~chyv&wn3krVSM2EBB<(4IQlHI66HvBi8yjv4ZNpaZD1 zbK6ZnZTonqju$VT5Am$FQd}L$DaZ+t>mPkf)J{8EUZ@xPFiU`jMu;`ml{O9A{ShGw zrj76UH5X2uuBbTNmSW_mD*=m4e?>okWzN1B{gTj8;Sp-(}o zIK&+t6bz`Q?fpuT93uX%#+dHSn*>&*leG12M{%_gc7;BMCX@njNOJ&g*S6pCN5WiLgpwgBL1CVc{l%(zlS+6Qk7?u4ooLg8Y;si`gp35VXZ}66hv6tz%V7OBnm9}n z^8$aO6zEeaE{$+0O~RvXB7@{7)nzV>?D^(BvU-`7%PUsiv`)J!KRW73tA4)JHp&U? zqAD}N-Zvle?iNo0YS4|Rt0e*BX)j_{%vmePbqtR~(4&5LlZ*>#Lq|f2J*K2v&VTtV2?vx`_gaejHh@#%VSCi?5-#`1@exOoaxo_`wkx8&qOSnDw zw14PmY>>llZ3$_5_LLuIe+_)Tp_2MuU4FU>E?7O)UJ-DTZ24|qkf9SZldzc*8yP%q zI&kK4rv?1}s%%W;n?_ttzG)U!tjaq)poa_?X7r6pTiYYJrWAfkG_rJtOR-U6J3t<& zXbTu^SGaUBW~)tS1v7g_=4PwI2t#OW;!qUX{DfWU#Hvu+WOf7xS+*P05K{gulOK6C)y=wvh^*OvITcu>;r z%%~9B_T2U;{FjAW`s=^B8>8M-VFf<9K2o@TpMod)Yq*2_<%x((1U8-G>C z_0pn%4-^kl*6FV}94g{bsb9ZDVR`2&(d2A2Npk-*_WEIJ&eD~2JIiwD6d3(KYgSHd=( zJvN+7?%qgJMDX9SYd_9^8pq!g!%lW(D}C~b{h1o!_aDlB$jwEj72Rd6OD~V&QnO3> zrG;Q}c_&`pvNTskUtH6mT`Fe9viSh?)+KYsu~$-Y@;hwE05T~WhV~g0YN$mVLk%Sf zUbd96EZQ+!3||9>q>2ndu29S4@&RX0^5Csln*$utTUQ9*Cov8dA*kSLca(VMmAhM3 z0!hz0h`SH96zliNXA^)cA*pJB#Pe_c4+rl*^`&Xpv>)9OR{pt;}{eBI=iUu;Ayp>-2Dz=vQV33#rFUWw{)h4!N@^V*^D zSGwz#eAFIn#vMG4`TexZXznvLTg5C^2O+XOEh(3p+?=14}mK;L_|4-RZDJyM9808W>> z|MW7|xmS7b=hXUDhS5XR#kxX^^!l7zDrS23z^$Wo$*v4!DdAk#73;xi()!Sl%F($C zjN}$=7q>#$sH-L(+_E<-%49fi=ao-bNA#gVJg!>C=`rqia)##C%6=yj=J@2k(i z9N}`ktq0_Rq;ms)dsCLFx{b@U1E-R7r`1FTz9}T331len@xF^~drkAM!;0gVrM~%V z@3xiG%HQ+86k|qECk&5^G~P>D{K+j5gzk-@Dx5ZP_24CS)<>l!;nfN^-Gc0UUEcQz zvH()ejit(H>d@#+1mEtt_E}jr`+e*vt1PW{Qt~cg&tk5OWevWESy0}2nwF`$q;&o+ zLC=ue$6m{Pg$b`CpS7Hle#5~P;w{cKCKo0KGT2vaF22EOWmkC zVyf}n9e?zB|4|Wi^kKn2xb8%qccH22^nDifl52aCuXRF4+eutn6*QJt^b##60?>PB z9eT-@jzZEeiWUmX4qMAm_q^StN3~ntTvAGXNJ}a@a>OsCaiTvW`%APSmAUiYnA8<| z#s9L<7k|2MU>pP#Jski(Nue$Zh(XN1BWxgAzK^(jOtlzC_bY}e>Z_E z$Zud&XJ>8CG4MS{WL3w|OfYL2LYGz z1cWMz8vF-4bE>c?*)Dhehx$I99|Nj$S)Tm`6By*@5Wcmw-dv8YW355Z`)}V#W0MYDcZeEE z4DjTMEC8!5&pa;ISo&lp?iZ;wxW+A86wV~L=aA+4q;ob@WDB2wv@mm@6a)7ukprE81yvp0qN)L#p0*;DVY4k$scKG;I;Wu0BreTvhi$uz@cV-1~cz?pupZ%9#2$+ z3IFrG!Vr%{X1&uM#72A~MG8KxpN0O&H_K}Us{p!P&@GhI?fC?ePDapKLWEv_R8FSq z&SEYMzjSx*P(&ypRl6s?NSu68+|MwY~J`VlCusV!5!V~>BMAbQojwpE~tMtrmq zz@5l|`GLX@58MJTM)BV_upak_-dz^CYTEi*;McCuZ~ZA+XX5>5BY9tkKDvKQ~C&O@|TPgm0Xa(+FzqKz*x-a!`szy^T1d!nPvAI zsXD_xshKPF`^w)xyiBQzoz)p+IW;ujwGa}UU zqoY)^lXye7S@5xN#8sgybj$;I0U(}LxDDZznFN3uFT=vE>2AsX_6zHy{-f4U#v)y0 zJZp#&dgPUIKJ=>U!!Fo-P=Avh7@}PLJmA*~_%6=}#_QsSy%Z4{O3Xb*ii5)vl}Md! zRNf;hyhppz-{$;^h7pNUdLQ#j)H5fd2UD)E7+QtAyV)U%A^Lo@l&+^W{i;B=WCd<$IUf zuxMG@2MSn?vHVwq4T|Q|wkfNT$5f`(3a>Z*pjawNjr@AK$Sw%Qeuhk7tUiExRbC#u zY`^)u-ZZMHW#jS|jmbuXNz5mm-xc|V zsPCIZo6e$EiK8fCke$bb(2Vn(p4eZsssg(zb$`rI2mSvtalG#y{AKF7u|>OVnF7w& z$w~`Vk^X{}fp-w)yhtO%U`HE@DG9|8J@mQ9qe~l)h)sV%6&k75RCU!}#)T(3_^6DG z;aNP+txs|?DNo!IqkEW|C$8SA$+`Dcf&>oi!~bNH<~Ho6j-hhbdc#Wk@qKV0Va84*)Addc0RvS@ z*{n^~11B$tfdN3CU^)-`dwgW2Bl*MoUVCAukmDo(?4y7uy8NL9%w{p4Q~u-w#@!rO z9*~&xhkw&3Cc^hY9Tpn06;GgB9ufrKU^j$YeoOrF6rbFAEhL8ayP)7|wDsEf22>=j z|8tZYBP-P{IIp|o-k8hD4pwyLjule>^JqI!x-6=K#Lu*1`*ED2isABfZ=#Nl@o{P? z{slfDil4rcdZ}HVNoUd+=)Q$^NI=K5{}ay?@k^VIt&@xs_ejZ?V#R!?HL@F{~UrK%0m;sh8~T?7qJ`MZHPW$pRLvdhj}&LXYr~-d@j{ zw2sZCo&n;`hrTjjugkX4mzCagEt5kh^dT(&VIVb%nMH;P(z*-sBc2X_2ziM2rf(1` z7*&ZV{UxHR!cD0A5Ltf4*~#k;4+(@AcN&50-W@5^gaf0YW{+ohyV8ye}h* z(j3t)fbyE9VEwqJD$~0Jn4o4fAVQcyJri*4Li&#@8iPwb=msL0jVx^!uiazxYhL&w zz>ewSQ;4NAe5j(!HXWY*#$#bgvnk$x&^`FVjdDXIlYWc65S?X{%ee^4+T-L1fLX~xKHKw`5xrYxOQ z!E2{%005t7E~`P8Lfwn0Z|Xt!&9FkofB^`zbAi{FtTn1If?`PkoccQ@Cj$Yur9nb^t7!Z)8~|0j32Z^m9TsAzhy1K4K# zdoZ4i%@cJ1JZ-bo4&OB30Uq9nU~^mcx<=maOa@=hd;KB#;x8v4VA~`=XT_?@!$$xp zh)V#+JNi9xI4tiYKBRk*!PYX(5I-gYNwoC#$=eWi0PG}?L1$7H5M5zDU2xMAW8elD zFCq7o%X-y!$e&krrNWyMwv8WFC?KBpZV;Qbv}3P-qwW$?2(^w3=!=aTING``f;A}W z_SDnvp>iH#e{=qP@3>#$z4ap45)E*VDxj?kUibqq6t^RkAQA1vF(u~(0XC!cMeOH)vWke-dqQ>&Kseuf$nd*q(!@9Si6m=@~WCaTM} zKccI9^v44&h-P?OzH+anWx zF6=*z96gTU$(WjRQ9;3_0`$IdY(4XD|)`+ongJB`I@CPC3BEtt!PAcY~xTGK7sqb$Y&G$shrA z_iT;X(BFTjGbPPcxknbEd3gn!g(0Uex8p~?%md`G0UQcwobEo|Q$#D1f2brhRBTaI z0sl@acSd>*eWE{>>Cx-fbDriWamdKgKUgz62E9@Vz?Dev4zhueGtA7^qFuWf`tHOSg>$W2`j5e%hq;MTY*(|29mHci(9p^Q{EZdPgQk} zg`Cx1=Cd0ipr74*GZKDt=Y3XMi4X;6U? z6dq@VvnDS83I7a|_)^>uJgzyO?%2{|MY{?Bj9K5_hGOyk%__SvUH6mH*1_kbE2pHkKTH^qL;$&9<2?iYEBJoBTY{uWyRFq{)asY7Vomu$j>nCWzUN&zcEG-yS?@I5RtFC}G_ulR*E-o_ZC znXRE`AI+yyn$jXAWo#l-sqV+@*jt`={u^z=+=Hk)K#B(QUQrhz+<{Sxa*pJV>wfoO#ZZ z*}4JOO!*U$#IZyPv!6eH<;lCjZgPkp7gnRH;~@3WlF{U|9SFC-1QWccV9 zU)I@QtgljaX;iM4?6B?~X(DkU(&G=zB>7@sO?o7^J>M;fgWCQiQq2&QfBaRq>4m+- zi*JT*vko;9K>HKT(W3fe-rF(=xzlafpj+9*0ATkokByzroRx2R9y*e=n)>cm8TT4- z1cg>}g=a_-Hg_2l90b;_F{OFps%>zVn_l`K$ZhTCKcl~S9J<_)SwFe{c;N#oI6NVU zAQsh37IPtX$r!)q=nF)-*bIONVgchFN0$BCW3u38O~a0q18Udz`$y*h#?^Cu^EYCi zo)S=*E<>lfDyMLS>r3ykK%`*Jufj|VeLh6iUmYAO)Jsr95*b`!UnfI(br{Uj@LuM# zEO7AZXH<)Tn!`Vat|F3V+iWB)=NCz~UWC_1F^wN=^$QdeCsp zGsUbU&s!Y??-Bi3*}m5Jd?o#(*HzjWqQ(}rJ0z6du`OG`&Y-l0csefFyR*}Kh=CY2 zMY{fqo>+Us42zX6aji;UisJ~#As2#sg%Kr0Pj@~Z#fbGRv#<&!-c3~d@wQv-aztMx z3JnDTXjB#J3T0`!^$q9Aa%`0+!51RJvXleRNDbHQ52TK_rVh(tEQW2*5P^85vZv~yr{W9W}b-y$3nju=aZKC6EAQI#yUUwLfdP9{mD6q+Zy+@=YkZgGrkIN9ML<5oFmR zyVsbr()~c(6Tg%t5GcQsl$Zn`do76re|pChA&DG_Eg&sL(K?O0_Aw$=>gTh4+Ko4% zs8D<{s^9pVYZf26=h2%7A(#J6Umc3RlXf5zzv!bGwodW9^w2e$KJLZn-`!Y{Pwa#) zseoiUTq(4t(>gd>IM#8=x`8E;9JU|GZZF$!9l;edSvkyqPzaVS`$cRY7-0)skU7Uh zSf0K|i6rln|3mj|AtExHNXpqNp~43I+_qU`Ve3;>ldj5RlaZ!$-Sht2nR2tKKgI)Q z(^<@S*^sPnW=A*J_r41qqO-2C>F)G@83M<$r(jp$VB3LI^`uIQI1-;_VAYn zoPr4fRZnF=pyIf-Ov+d^uX`Dmkqp}^|1-uZAVB=!TfI0v(vpD`2b|9?)aUfs&gkqk zwM)+0uXx-47{t2R4>*_Y*#}aV=wh}S?tlQEjAMmu{h_bR3=wAstVz4JmpCg!Y;}Qz zew`Rula2PDGSYvR=&>`t$>B2ntUwRb0N%RkFpy0)MZ5vVYs?OLO}X^Y=*s%^s+v%t z=ozjuC@=JFGbH#gF!t04g_j~1QL|gI=-rxyX26lDasj6|ngYhk$njl4mc6Dpx;Fn@ z^kdS(gW*F0aLB9c#n;Fup?dR+7ud7rI4V28+AL*ipvk-Ut_b><3CJ1BZWD-5aJ1xd z?Blei=9kSazinobO11VL9(DFVq)>a*aEsLs)i!|9@pW`=Kl*_L#?Pe&R>#oK4W-LY zPVSrftR@V+<5EqzyH};_1`JL94Y@v=Pm>p5uQNned{$nQ= zKLMwqq1)MJp6&s?v0vGF@@_=n`E2TUby>m18eqzbLGipf3lf(8R3e}^z8KrB)pkn&kdP9$Nj!b@&GPN-13fbY z0uW4Oq%v4Vqd*EeeEOHWDb}*1X)jopF$sYY@QfSCO)}ZyTuNOyOl-EGGoZ*j$TJ9^ zf&;9G^GN;9>p4`aefi%iml*G)sVIrJRK@-C;1)nMWmFsbjmS>{^U~r@duq_x=gX7# z$#@}ugmM4*J!BZr%Sp{+JJqv}@*J;vyOQqQ1)jPU)6^NmX$}Hxi!nK-=yv*+Da;u& z9X%lVa`27-Pwn>&dcZy^e5Zlh=~l`l_~0@TlDz}W)+wI$kCjurq{Juz=C{GP*MRGL zo+m(*BcPXf@%%^T=*;o-X zet$c0u#TZU%}&wWRNp&ub88ZsA2P_IA{J`r(qToy6MfN&Ra`nBuxpTi=T3$`xQNtD z_kDnDYGsI^dE-ji%5sVT@7nRQ^3A&c&#l(ci&c23%ME;FpEFM(<|6@YFT0^D1K!u# z`yfvGTX4aaYTnLe;jZwdh-9{+x+ zn_UKsc;SW>wu`lyNzp>`cx7@|Ul&^|7w}tEUT2wi0m$INCeTBDP=y7HnxOd6^2R#i zza3xyuQ$!HYW25+rMXfH{DT%0^S?n0O3s-1B)~d}8E?sVdS??EKRkG*RRM()C)p0) zoSXi8$N$&mGDKr~PamF`XTxb}1!CDWGkD!|H=vob#vCQR+MkV-&kHqd`q#a`8t~q~ zk)r(9Q}VwrH2U3t4MNa(`v23vxoNxo?!FLD#t9`pw7x^BqCw}s#)xN~PD3$5ztCEi9Dn%gRU)4uJghtb#D zMc_pV2JH@6y7WFv`!iSKKg<7bY`lqDnqrF$Ecnq88XD<`i;r|br65+T0%y``G3~xq z>_Ma9GK>1$+_bX(MyB*wb^Js@LrHn&Vx5}|=zrcZIQ#?ln*^{;$W4ksoe|7u)(VHv zrzFM_sy_~5z>^^Uu=6c9Ldb+Gi}?A&oz8~NRVh6?Jk6KVqOeOvL1N3aU;?mTsXl75 zMN-$qL;J|~ykQG~uN4CWlh!ap4+9RrXG*FE9KP>Cv*!E!*9v1c*^>D^%hm93-2{G2 z9N578!qv}2h=5^J>_U`t?Zos*mtY25J$vA5Y_Nm1&Vt;t;zu5Y<`8}0K{vg8mAo71LAvGMhMxMUAMdv`v%&brpz_4#JlQ26ZvO9}9`nG94HsZE}X=C$% zi>CO4jK_=mi3m)%`1dXbEXj6-(2-`BA0@zlSi*ri4Z9>BA21oKU~* zA9BejM2B{qpHL5h@J4R?AYj;Ki@>vmS3?${`nS^-mZ1%?ZSvB+*l@o>|Lg66&oawr z9M<#6Z!!6SDS27OW7Ag-Oa2jznE-0f;p|r0PNDp#Z2QUi8d+Gn1+I-q!`@dU*6n&E zh~!&w?NSztGcQXVFgoe6<#f*(zVtuo)W0|GV=MeSIvL*X@K0JcM%b>hTaO6KAx6SwZ08;Lr%ov!Dd$e)eG zI#$oTC~z;jsr~*NG(_HFu7NY~yxt4QZvkTS^t%qTyUH8||1+10gg60j5|CKo@h>Z7 zum8HUVUz&}WA9D>5|w8_YjfM})~>`1eEPe$)yZ!z$lzue!@ujm#tmFRKr%wR>}I3T z;Xi(h_y?Abr&LPRMInx>Vt{O?Q0_pCPw%tR z8$u&H;s4v5rIoN?fbrI-UumcLqJ*WL=l}2BKiB>{wy5$EW^7TUFCBgvN&AFrXBQS! ztqHVY1}XyCs-&eXcKsP!)J=v%Z{iGlv26)HpR&OSGk}3k{v~y*6NXv_0p%Dd>{Pej z{|cU@;y6qK6i2{e7?5n36^e=Ak-ZMqM!ltd#!akGQw^oC`pT=AYw4*A>+Cz==&nc} zhSR7^NFcS0#`}neH-ZMb z-PeIG+R6Z80K+zE?MGVDg2#UXf2DjkTni%l$#I(5)=rB8^+>U{kV@8i_1^lVQ z{u=h>m}TkdH4(w(HOlj}7J65kZDVXQ^JQ%$i}P5OMY`fsmZ$YvKPwhowwgXbTASeAL-SMtBNKp`ej z6fP9*sREmeB; zyGgNExqb?=Z`De0j;ZT&c@%JL($VhO$8FzzJbOmcc-C^;x0%Uvmvi3Tcc-OlGq5T6 z?99x^H98R+7TkQ@o1X(53E1|`__)mFJ+DI7&$?jq@)@|X2P!6;iT&uFaY}J794x z@Dv=r*E(ozCWAmwK3`P#c~?HjUM6OtEyoURH)y*J41hVn>DkS|Gv=0E`*&>3_I0~n zt-?~!p*b6<{g$~=+pXf)Yqy(Sk16)ex@fp<^26tSw%a0sLubKvI@RY)I0qRaMr0J= ziXmXUOv#V>4hqJIREMT(5r5N;Iqd!TV#hKJC+!lXd$_US3+Z<wXAB`EJMzcu-Qhv9R6j`P}ljV&L(Bpm~P%ncMCZ z0T;}pRnNfLF<^RJmLL2bSehTG00m^l-)C~q%Hj+D{ao1wJY;Ek<*RGa%d_X??ECrb zYHFv{7wzJcLyYSMkt%=n1BVb;msoW+5Iq7v~ z{k&`&?tB0aGG{LHn|tdGa98lz#d2R)Y`kc&6=iEVusTWu`ZDfpe8Vc>wGY7d!h{8; zSK`;_`JqN0qB(i^c*8UqzWe2?tc8% Date: Sat, 6 Jul 2024 19:20:13 -0700 Subject: [PATCH 12/12] address @slivingston review comments --- control/ctrlplot.py | 2 +- control/nlsys.py | 10 ++++------ doc/conventions.rst | 6 +++--- examples/plot_gallery.py | 5 +++-- 4 files changed, 11 insertions(+), 12 deletions(-) diff --git a/control/ctrlplot.py b/control/ctrlplot.py index de70f96cd..c8c30880d 100644 --- a/control/ctrlplot.py +++ b/control/ctrlplot.py @@ -103,7 +103,7 @@ def _make_legend_labels(labels, ignore_common=False): common_prefix = common_prefix[:last_space] prefix_len = len(common_prefix) - # Look for a common suffice (up to a space) + # Look for a common suffix (up to a space) common_suffix = commonprefix( [label[::-1] for label in labels])[::-1] suffix_len = len(common_suffix) diff --git a/control/nlsys.py b/control/nlsys.py index 976dfdc84..d1c816ba8 100644 --- a/control/nlsys.py +++ b/control/nlsys.py @@ -1317,7 +1317,7 @@ def nlsys( def input_output_response( - sysdata, T, U=0., X0=0, params=None, ignore_errors=False, + sys, T, U=0., X0=0, params=None, ignore_errors=False, transpose=False, return_x=False, squeeze=None, solve_ivp_kwargs=None, t_eval='T', **kwargs): """Compute the output response of a system to a given input. @@ -1327,7 +1327,7 @@ def input_output_response( Parameters ---------- - sysdata : I/O system or list of I/O systems + sys : NonlinearIOSystem or list of NonlinearIOSystem I/O system(s) for which input/output response is simulated. T : array-like @@ -1449,16 +1449,14 @@ def input_output_response( raise TypeError("unrecognized keyword(s): ", str(kwargs)) # If passed a list, recursively call individual responses with given T - if isinstance(sysdata, (list, tuple)): - responses = [] + if isinstance(sys, (list, tuple)): + sysdata, responses = sys, [] for sys in sysdata: responses.append(input_output_response( sys, T, U=U, X0=X0, params=params, transpose=transpose, return_x=return_x, squeeze=squeeze, t_eval=t_eval, solve_ivp_kwargs=solve_ivp_kwargs, **kwargs)) return TimeResponseList(responses) - else: - sys = sysdata # Sanity checking on the input if not isinstance(sys, NonlinearIOSystem): diff --git a/doc/conventions.rst b/doc/conventions.rst index ad56c0ccc..21f3ab82b 100644 --- a/doc/conventions.rst +++ b/doc/conventions.rst @@ -157,12 +157,12 @@ response from a non-zero initial condition. For linear time invariant (LTI) systems, the :func:`impulse_response`, :func:`initial_response`, and :func:`step_response` functions will automatically compute the time vector based on the poles and zeros of -system. If a list of systems is passed, a common time vector will be +the system. If a list of systems is passed, a common time vector will be computed and a list of responses will be returned in the form of a -:class:`TimeResponseList` object. The :func:`force_response` function can +:class:`TimeResponseList` object. The :func:`forced_response` function can also take a list of systems, to which a single common input is applied. The :class:`TimeResponseList` object has a `plot()` method that will plot -each of the reponses in turn, using a sequence of different colors with +each of the responses in turn, using a sequence of different colors with appropriate titles and legends. In addition the :func:`input_output_response` function, which handles diff --git a/examples/plot_gallery.py b/examples/plot_gallery.py index 214e53289..272de3d8e 100644 --- a/examples/plot_gallery.py +++ b/examples/plot_gallery.py @@ -6,7 +6,7 @@ # used to compare what things look like between different versions of the # library. It is mainly intended for uses by developers to make sure there # are no unexpected changes in plot formats, but also has some interest -# examples of htings you can plot. +# examples of things you can plot. import os import sys @@ -21,9 +21,10 @@ savefigs = 'PYCONTROL_TEST_EXAMPLES' not in os.environ if savefigs: # Create a pdf file for storing the results + import subprocess from matplotlib.backends.backend_pdf import PdfPages from datetime import date - git_info = os.popen('git describe').read().strip() + git_info = subprocess.check_output(['git', 'describe'], text=True).strip() pdf = PdfPages( f'plot_gallery-{git_info}-{date.today().isoformat()}.pdf')