diff --git a/cosipy/response/ExtendedSourceResponse.py b/cosipy/response/ExtendedSourceResponse.py index 14e9beb9..15860cb1 100644 --- a/cosipy/response/ExtendedSourceResponse.py +++ b/cosipy/response/ExtendedSourceResponse.py @@ -1,8 +1,11 @@ -from histpy import Histogram import numpy as np + import astropy.units as u -import gc -from astromodels.functions.function import Function1D, FunctionMeta, ModelAssertionViolation, Function2D, Function3D + +from astromodels import Function3D + +from histpy import Histogram + from .functions import get_integrated_extended_model from .functions_3d import get_integrated_extended_model_3d @@ -29,26 +32,34 @@ def __init__(self, *args, **kwargs): """ Initialize an ExtendedSourceResponse object. """ - # Not to track the under/overflow bins + kwargs['track_overflow'] = False + kwargs['sparse'] = False super().__init__(*args, **kwargs) - if not list(self.axes.labels) == ['NuLambda', 'Ei', 'Em', 'Phi', 'PsiChi']: + self.post_init() + + def post_init(self): + """ + Do init operations specific to our subclass + """ + if not tuple(self.axes.labels) == ('NuLambda', 'Ei', 'Em', 'Phi', 'PsiChi'): # 'NuLambda' should be 'lb' if it is in the gal. coordinates? raise ValueError(f"The input axes {self.axes.labels} is not supported by ExtendedSourceResponse class.") + # unit required for get_expectation() input + self._exp_unit = (u.s * u.cm**2 * u.sr)**(-1) + @classmethod - def open(cls, filename, name='hist'): + def _open(cls, name='hist'): """ - Load data from an HDF5 file. + Load response from an HDF5 group. Parameters ---------- - filename : str - The path to the HDF5 file. name : str, optional - The name of the histogram group in the HDF5 file (default is 'hist'). + The name of the histogram group (default is 'hist'). Returns ------- @@ -60,11 +71,16 @@ def open(cls, filename, name='hist'): ValueError If the shape of the contents does not match the axes. """ - resp = super().open(filename, name) + + resp = super()._open(name) + + resp.track_overflow(False) if resp.is_sparse: resp = resp.to_dense() - + + resp.post_init() + return resp def get_expectation(self, allsky_image_model): @@ -73,7 +89,7 @@ def get_expectation(self, allsky_image_model): Parameters ---------- - allsky_image_model : Histogram + allsky_image_model : Histogram The all-sky image model to use for calculation. Returns @@ -81,20 +97,16 @@ def get_expectation(self, allsky_image_model): Histogram A histogram representing the calculated expectation. """ - if self.axes[0].label == allsky_image_model.axes[0].label \ - and self.axes[1].label == allsky_image_model.axes[1].label \ - and np.all(self.axes[0].edges == allsky_image_model.axes[0].edges) \ - and np.all(self.axes[1].edges == allsky_image_model.axes[1].edges) \ - and allsky_image_model.unit == u.Unit('1/(s*cm*cm*sr)'): - - contents = np.tensordot(allsky_image_model.contents, self.contents, axes=([0,1], [0,1])) - contents *= self.axes[0].pixarea() - - return Histogram(edges=self.axes[2:], contents=contents, copy_contents=False) - - else: + + if allsky_image_model.axes[:2] != self.axes[:2] or \ + allsky_image_model.unit != self._exp_unit: raise ValueError(f"The input allskymodel mismatches with the extended source response.") + contents = np.tensordot(allsky_image_model.contents, self.contents, axes=((0,1), (0,1))) + contents *= self.axes[0].pixarea() + + return Histogram(edges=self.axes[2:], contents=contents, copy_contents=False) + def get_expectation_from_astromodel(self, source): """ Calculate expectation from an astromodels extended source model. @@ -115,13 +127,14 @@ def get_expectation_from_astromodel(self, source): A histogram representing the calculated expectation based on the provided extended source model. """ - - if isinstance(source.spatial_shape, Function3D): - allsky_image_model = get_integrated_extended_model_3d(source, image_axis = self.axes[0], energy_axis = self.axes[1]) - + if isinstance(source.spatial_shape, Function3D): + allsky_image_model = get_integrated_extended_model_3d(source, + image_axis = self.axes[0], + energy_axis = self.axes[1]) else: + allsky_image_model = get_integrated_extended_model(source, + image_axis = self.axes[0], + energy_axis = self.axes[1]) - allsky_image_model = get_integrated_extended_model(source, image_axis = self.axes[0], energy_axis = self.axes[1]) - return self.get_expectation(allsky_image_model) diff --git a/cosipy/response/PointSourceResponse.py b/cosipy/response/PointSourceResponse.py index d139a5fb..60abbe4c 100644 --- a/cosipy/response/PointSourceResponse.py +++ b/cosipy/response/PointSourceResponse.py @@ -100,7 +100,7 @@ def get_expectation(self, spectrum, polarization=None, flux=None): if flux is None: energy_axis = self.photon_energy_axis flux = get_integrated_spectral_model(spectrum, energy_axis) - + expectation = np.tensordot(contents, flux.contents, axes=(0, 0)) # if self is sparse, expectation will be a SparseArray with @@ -110,6 +110,6 @@ def get_expectation(self, spectrum, polarization=None, flux=None): copy_contents = False) if not hist.unit == u.dimensionless_unscaled: - raise RuntimeError("Expectation should be dimensionless, but has units of " + str(hist.unit) + ".") - + raise RuntimeError(f"Expectation should be dimensionless, but has units of {(hist.unit)}.") + return hist diff --git a/cosipy/response/functions.py b/cosipy/response/functions.py index 929e4c1f..5182e5a0 100644 --- a/cosipy/response/functions.py +++ b/cosipy/response/functions.py @@ -1,8 +1,7 @@ import numpy as np + import astropy.units as u -from astropy.units import Quantity from astropy.coordinates import Galactic -from scipy import integrate from histpy import Histogram @@ -23,8 +22,8 @@ ) def get_integrated_spectral_model(spectrum, energy_axis): - """ - Get the photon fluxes integrated over given energy bins with an input astropy spectral model + """Get the photon fluxes integrated over given energy bins with an + input astropy spectral model Parameters ---------- @@ -45,8 +44,38 @@ def get_integrated_spectral_model(spectrum, energy_axis): Notes ----- - This function determines the unit of the spectrum, performs the integration - over each energy bin, and returns the result as a Histogram object. + This function determines the unit of the spectrum, performs the + integration over each energy bin, and returns the result as a + Histogram object. + + """ + + from cosipy.response.integrals import get_integral_values + + spectrum_unit = get_spectrum_unit(spectrum) + + flux_values = get_integral_values(spectrum, energy_axis.edges.value) + + flux = Histogram(energy_axis, + contents = flux_values, + unit = spectrum_unit * energy_axis.unit, + copy_contents = False) + + return flux + + +def get_spectrum_unit(spectrum): + """ + Get the unit of the spectral model. + + Parameters + ---------- + spectrum : astromodels.functions + One-dimensional spectral function from astromodels. + + Returns: + astropy.unit for the spectrum + """ from cosipy.threeml import Band_Eflux @@ -77,33 +106,18 @@ def get_integrated_spectral_model(spectrum, energy_axis): except: raise RuntimeError("Spectrum not yet supported because units are unknown.") - if isinstance(spectrum, DiracDelta): - flux = [spectrum.value.value - if spectrum.zero_point.value >= lo_lim and spectrum.zero_point.value <= hi_lim - else 0 - for lo_lim, hi_lim in zip(energy_axis.lower_bounds.value, - energy_axis.upper_bounds.value)] + return spectrum_unit - else: - flux = [integrate.quad(spectrum, lo_lim, hi_lim)[0] - for lo_lim, hi_lim in zip(energy_axis.lower_bounds.value, - energy_axis.upper_bounds.value)] - - flux = Histogram(energy_axis, - contents = flux, - unit = spectrum_unit * energy_axis.unit) - - return flux def get_integrated_extended_model(extendedmodel, image_axis, energy_axis): - """ - Calculate the integrated flux map for an extended source model. + """Calculate the integrated flux map for an extended source model. Parameters ---------- extendedmodel : astromodels.ExtendedSource - An astromodels extended source model object. This model represents - the spatial and spectral distribution of an extended astronomical source. + An astromodels extended source model object. This model + represents the spatial and spectral distribution of an + extended astronomical source. image_axis : histpy.HealpixAxis Spatial axis for the image. energy_axis : histpy.Axis @@ -116,21 +130,26 @@ def get_integrated_extended_model(extendedmodel, image_axis, energy_axis): Notes ----- - This function first integrates the spectral model over the energy bins, - then combines it with the spatial distribution to create a 2D flux map. + This function first integrates the spectral model over the energy + bins, then combines it with the spatial distribution to create a + 2D flux map. + """ if not isinstance(image_axis.coordsys, Galactic): raise ValueError - integrated_flux = get_integrated_spectral_model(spectrum = extendedmodel.spectrum.main.shape, energy_axis = energy_axis) + integrated_flux = \ + get_integrated_spectral_model(spectrum = extendedmodel.spectrum.main.shape, + energy_axis = energy_axis) + + l, b = image_axis.pix2ang(np.arange(image_axis.npix), lonlat=True) + normalized_map = extendedmodel.spatial_shape(l, b) / u.sr - npix = image_axis.npix - coords = image_axis.pix2skycoord(np.arange(npix)) - normalized_map = extendedmodel.spatial_shape(coords.l.deg, coords.b.deg) / u.sr + flux = np.tensordot(normalized_map, integrated_flux.contents, axes = 0) flux_map = Histogram((image_axis, energy_axis), - contents = np.tensordot(normalized_map, integrated_flux.contents, axes = 0), + contents = flux, copy_contents = False) return flux_map diff --git a/cosipy/response/functions_3d.py b/cosipy/response/functions_3d.py index 5be60316..55eb757a 100644 --- a/cosipy/response/functions_3d.py +++ b/cosipy/response/functions_3d.py @@ -1,18 +1,18 @@ import numpy as np -import astropy.units as u -from astropy.units import Quantity -from astropy.coordinates import Galactic + from scipy import integrate from scipy.interpolate import interp1d -from histpy import Histogram -import sys +import astropy.units as u +from astropy.coordinates import Galactic + +from histpy import Histogram import logging logger = logging.getLogger(__name__) def get_integrated_extended_model_3d(extendedmodel, image_axis, energy_axis): - + """ Calculate the integrated flux map for an extended source model. @@ -31,48 +31,51 @@ def get_integrated_extended_model_3d(extendedmodel, image_axis, energy_axis): flux_map : histpy.Histogram 2D histogram representing the integrated flux map. """ - + + from cosipy.threeml.custom_functions import GalpropHealpixModel + if not isinstance(image_axis.coordsys, Galactic): raise ValueError - npix = image_axis.npix - coords = image_axis.pix2skycoord(np.arange(npix)) + l, b = image_axis.pix2ang(np.arange(image_axis.npix), lonlat=True) - # GalpropHealpixModel: - if type(extendedmodel.spatial_shape).__name__ == "GalpropHealpixModel": - - # The norm is updated internally by 3ML for each likelihood call: + if isinstance(extendedmodel.spatial_shape, GalpropHealpixModel): + + # The norm is updated internally by 3ML for each likelihood call norm = extendedmodel.spatial_shape.K.value - - # Make sure the dummy spectral parameter is fixed: + + # Make sure the dummy spectral parameter is fixed extendedmodel.spectrum.main.Constant.k.free = False # First get differential intensity from GALPROP model (ph/cm2/s/sr/MeV), # and then integrate over energy bins. We attach the integrated flux - # to the extended model instance so that it only needs to be calculated once. + # to the extended model instance so that it only needs to be calculated once. if not isinstance(extendedmodel.spatial_shape._result, np.ndarray): - - intensity = (1/norm)*extendedmodel.spatial_shape.evaluate(coords.l.deg,coords.b.deg,energy_axis.edges.to(u.MeV),norm) - - # Integrate over energy bins for each sky position: + + intensity = (1/norm)*extendedmodel.spatial_shape.evaluate(l, b, energy_axis.edges.to(u.MeV), norm) + + # Integrate over energy bins for each sky position extendedmodel.spatial_shape.intg_flux = np.zeros((intensity.shape[0], intensity.shape[1]-1)) - - # Convert units outside loop to optimize speed: - energy = energy_axis.edges.to(u.MeV) - bin_low = energy_axis.lower_bounds.to(u.MeV)/u.MeV # unitless for integration - bin_high = energy_axis.upper_bounds.to(u.MeV)/u.MeV # unitless for integration - - # Integrate spectrum over energy bins for each spatial pixel: + + # Convert units outside loop to optimize speed + energy_edges = energy_axis.edges.to_value(u.MeV) + + # Integrate spectrum over energy bins for each spatial pixel logger.info("Integrating intensity over energy bins...") for j in range(len(intensity)): - - interp_func = interp1d(energy, intensity[j], bounds_error=False, fill_value='extrapolate') - - extendedmodel.spatial_shape.intg_flux[j] = Quantity([integrate.quad(interp_func, lo_lim, hi_lim)[0] - for lo_lim,hi_lim - in zip(bin_low, bin_high)]) - - flux_map = Histogram([image_axis, energy_axis], \ - contents = norm*extendedmodel.spatial_shape.intg_flux*((u.s * u.cm**2 * u.sr) ** (-1))) + + interp_func = interp1d(energy_edges, intensity[j], bounds_error=False, fill_value='extrapolate') + + extendedmodel.spatial_shape.intg_flux[j] = \ + np.array([integrate.quad(interp_func, lo_lim, hi_lim)[0] + for lo_lim, hi_lim + in zip(energy_edges[:-1], energy_edges[1:])]) + + flux = norm * extendedmodel.spatial_shape.intg_flux + + flux_map = Histogram((image_axis, energy_axis), \ + contents = flux, \ + unit = (u.s * u.cm**2 * u.sr) ** (-1), + copy_contents = False) return flux_map diff --git a/cosipy/response/integrals.py b/cosipy/response/integrals.py new file mode 100644 index 00000000..e96135b9 --- /dev/null +++ b/cosipy/response/integrals.py @@ -0,0 +1,496 @@ +import numpy as np + +from astromodels import ( + Powerlaw, + Cutoff_powerlaw, + Band, + Band_grbm, + Gaussian, + DiracDelta, + StepFunction, + StepFunctionUpper, + Constant, + Line, + Quadratic, + Cubic, + Quartic, +) + +from cosipy.threeml import Band_Eflux + +def get_integral_values(f, x_in, force_quad = False): + """ + Compute the integral of a function f between the specified + endpoints. If available, use an integral formula specific + to the function family; otherwise, use adaptive quadrature. + + Inputs + ------ + f : Astromodels.Function1D + the function to integrate + x_in : array-like of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + force_quad: bool, optional + force integration with adaptive quadrature rather than using + any available family-specific integrator; default False. + (This option has no effect if the function family is known to give + inaccurate results with adaptive quadrature, in particular if + if has a discontinuity.) + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + + x = np.asarray(x_in) + + # Functions with discontinuities either give inaccurate results or + # fail altogether with adaptive quadrature. + if force_quad and \ + not isinstance(f, (DiracDelta, StepFunction, StepFunctionUpper)): + return integral_generic(f, x) + + match f: + case Powerlaw(): + return integral_powerlaw(x, + f.index.value, + f.piv.value, + f.K.value) + + case Cutoff_powerlaw(): + return integral_co_powerlaw(x, + f.index.value, + f.piv.value, + f.xc.value, + f.K.value) + + case Band(): + return integral_band(x, + f.alpha.value, + f.beta.value, + f.piv.value, + f.xp.value, + f.K.value) + + case Band_grbm(): + # Band_grbm is same as Band, except that everywhere + # the Band_grbm formula uses xp (the cutoff value), the + # Band formula uses xc/(2+alpha). So correct for this + # before we call the integral. + return integral_band(x, + f.alpha.value, + f.beta.value, + f.piv.value, + f.xc.value*(2 + f.alpha.value), + f.K.value) + + case Band_Eflux(): + # Band_Eflux is like Band_grbm, except that the + # returned values are normalized by the integral + # of the Band function between a and b. There is + # no pivot value (so treat it as 1.0). + + # normalization constant + norm = f.get_normalization(f.a.value, + f.b.value, + f.alpha.value, + f.beta.value, + f.E0.value) + return integral_band(x, + f.alpha.value, + f.beta.value, + 1.0, + f.E0.value*(2 + f.alpha.value), + f.K.value / norm) + + case Gaussian(): + return integral_gaussian(x, + f.mu.value, + f.sigma.value, + f.F.value) + + case Constant(): + return integral_polynomial(x, + np.array([f.k.value])) + + case Line(): + return integral_polynomial(x, + np.array([f.b.value, + f.a.value])) + + case Quadratic(): + return integral_polynomial(x, + np.array([f.c.value, + f.b.value, + f.a.value])) + + case Cubic(): + return integral_polynomial(x, + np.array([f.d.value, + f.c.value, + f.b.value, + f.a.value])) + + case Quartic(): + return integral_polynomial(x, + np.array([f.e.value, + f.d.value, + f.c.value, + f.b.value, + f.a.value])) + + case DiracDelta(): + return integral_diracdelta(x, + f.zero_point.value, + f.value.value) + + case StepFunction() | StepFunctionUpper(): + return integral_stepfunction(x, + f.lower_bound.value, + f.upper_bound.value, + f.value.value) + + case _: + return integral_generic(f, x) + +def integral_generic(f, x): + """ + Compute the integral of a function f between the specified + endpoints using adaptive quadrature + + Inputs + ------ + f : function of type float -> float + x : array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + + from scipy import integrate + + return np.array([ + integrate.quad(f, xl, xh)[0] for + xl, xh in zip(x[:-1], x[1:]) + ]) + + +def integral_powerlaw(x, b, p, c): + """ + Compute the integral of a powerlaw between the specified + endpoints. A Powerlaw has the form + + f(x) = c * (x/p)^b + + where p and c are positive real numbers and b is a non-positive + real number. The argument x is a non-negative real number. + + Inputs + ------ + x : array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + a, b, p, c : float + function parameters + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + + if b == -1.: + # special case: f(x) = cp/x, so + # integral is cp * ln(x) + v = np.log(x) + v *= c*p + else: + # integral of powerlaw is + # cp/(b+1) (x/p)^(b+1) + v = np.power(x/p, b + 1.) + v *= c*p/(b + 1.) + + return np.diff(v) + + +def integral_co_powerlaw(x, a, p, c, K): + """ + Compute the integral of a cut-off powerlaw between the specified + endpoints. A cut-off powerlaw has the form + + f(x) = K (x/p)^a * exp(-x/c) + + where p and c are positive real numbers and a is a positive-negative + real number. The argument x is a non-negative real number. + + Inputs + ------ + x: array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + a, p, b, c, K : float + parameters of function + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + Note: integral formulas were sourced from Wolfram Alpha. + """ + + from scipy.special import expn, gamma, gammaincc + + z = x/c + + if isinstance(a, (int, np.integer)) or a.is_integer(): + # For integer a, use generalized exponential integral, since + # the gamma function diverges at integers <= 0. + v = -np.power(x/p, a) * x + v *= expn(-a, z) * K + else: + # For non-integer a, use upper incomplete gamma function + # (denoted Gamma(s,z) below). + + # compute Gamma(1 + a, x/c) + if a > -1.: + # SciPy gammaincc() is normalized by 1/gamma(a); undo that. + v = gamma(1. + a) * gammaincc(1. + a, z) + else: + # SciPy, unlike some other tools (but similar to the + # C++ standard library), does not support computing + # Gamma(s, z) for s <= 0. So we use this recurrence + # (see Wikipedia on Gamma(s,z)): + # + # Gamma(s, z) = 1/s [Gamma(s+1, z) - x^s exp(-x)] + # + # Apply the recurrence repeatedly until s becomes + # non-negative, then use the base case above. + + expmz = np.exp(-z) + + v = np.zeros_like(z) + d = 1. + s = 1. + a + + while s < 0.: + d /= s + v -= np.power(z, s) * expmz * d + s += 1. + + v += d * gamma(s) * gammaincc(s, z) + + v *= -np.power(c/p, a) * c * K + + return np.diff(v) + + +def integral_band(x, a, b, p, c, K): + """ + Compute the integral of a cut-off powerlaw between the specified + endpoints. A cut-off powerlaw has the form + + A Band spectrum is a combination of a cutoff powerlaw and a + regular powerlaw. Specifically, let the critical value + x_crit = (a - b) c / (a+2). Then + + { (x/p)^a exp(-(a+2)x/c) if x <= x_crit + f(x) = K { + { (x/p)^b exp(b-a) [(a-b)c/(a+2)p]^(a-b) if x > x_crit + + where p and c are positive real numbers and a and b are + non-positive real numbers. The argument x is a non-negative real + number. + + Inputs + ------ + x: array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + a, b, p, c, K : float + parameters of function + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + dc = c/(a + 2.) + cutoff = dc*(a - b) + + # x[split - 1] <= cutoff < x[split] + split = np.searchsorted(x, cutoff, side='right') + + def lo_int(x): + return integral_co_powerlaw(x, a, p, dc, K) + + def hi_int(x): + return integral_powerlaw(x, b, p, + K * np.exp(b - a) * np.power(cutoff/p, a - b)) + + if split == 0: + # all of x is above cutoff + v = hi_int(x) + elif split == len(x): + # all of x is below cutoff + v = lo_int(x) + else: + if x[split - 1] == cutoff: + # subarrays of x below and above cutoff share no bins + x_lo = x[:split] + x_hi = x[split-1:] + v = np.concatenate((lo_int(x_lo), hi_int(x_hi))) + else: + # split bin containing cutoff and add low and high + # contributions to that bin + x_lo = np.concatenate((x[:split], (cutoff,))) + x_hi = np.concatenate(((cutoff,), x[split:])) + + v = np.zeros(len(x) - 1) + v[:split] += lo_int(x_lo) + v[split-1:] += hi_int(x_hi) + + return v + + +def integral_gaussian(x, mu, sigma, F): + """ + Compute the integral of a Gaussian between the specified + endpoints. A Gaussian has the form + + f(x) = F/[sqrt(2*pi) * sigma] exp(-(x-mu)^2/(2 sigma^2)) + + where mu is a real number and sigma a non-negative real number. + The argument x is a real number. + + Inputs + ------ + x : array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + mu, sigma, F : float + parameters of function + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + """ + + from scipy.special import erf + + # Gaussian integral from -inf to x is given by + # 1/2 [ 1 + erf((x - mu)/(sqrt(2) * sigma)) ] + + z = (x - mu)/sigma + + isqrt2 = 0.7071067811865475 # 1/sqrt(2) + v = erf(isqrt2 * z) + v *= 0.5 * F + + # skip this, since we only compute diffs below + # v += 0.5 + + return np.diff(v) + +def integral_polynomial(x, coeffs): + """ + Compute the integral of a polynomial between the specified + endpoints. The polynomial is given by its coefficients + in order from highest to lowest power; e.g., [3, 4, 1] + describes the polynomial 3x^2 + 4x + 1. + + Inputs + ------ + x : array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + coeffs : array-like of float + coefficients of polynomial + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + + # denominators associated with each term of integral + corrs = np.arange(len(coeffs), 0, -1) + + # evaluate the integral at x + v = np.polyval(np.append(coeffs/corrs, 0.), x) + + return np.diff(v) + +def integral_stepfunction(x, x_lo, x_hi, value): + """ + Compute the integral of a step function between the specified + endpoints. A step function has the form + + f(x) = { value if x_lo <= x <= x_hi + { 0. otherwise + + Note that the inequalities can be strict or non-strict; the + integral is not affected. + + Inputs + ------ + x : array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + x_lo, x_hi, value : float + parameters of function + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + + # contribution of Heaviside(x_lo) + v_step_up = np.maximum(0., x[1:] - np.maximum(x[:-1],x_lo)) + # contribution of Heaviside(x_hi) + v_step_down = np.maximum(0., x[1:] - np.maximum(x[:-1],x_hi)) + + v = v_step_up - v_step_down + v *= value + + return v + +def integral_diracdelta(x, x_nonzero, value): + """ + Compute the integral of a Dirac Delta function between the + specified endpoints. A Delta function integrates to 'value' if the + domain contains the point x_nonzero or zero otherwise. + + Inputs + ------ + x : array of float + array of monotonically increasing grid points; integration is + performed between each successive pair of points + x_nonzero, value : float + parameters of function + + Returns + ------- + array of |x|-1 values containing definite integral values + between each successive pair of points in x + + """ + + bins = ((x[:-1] <= x_nonzero) & (x[1:] >= x_nonzero)) + v = np.where(bins, value, 0.) + + return v diff --git a/cosipy/threeml/custom_functions.py b/cosipy/threeml/custom_functions.py index 6c41fc68..9b5920c7 100644 --- a/cosipy/threeml/custom_functions.py +++ b/cosipy/threeml/custom_functions.py @@ -1,20 +1,19 @@ -from astromodels.functions.function import Function1D, FunctionMeta, ModelAssertionViolation, Function2D, Function3D -import astromodels.functions.numba_functions as nb_func -from astromodels.utils.angular_distance import angular_distance -from threeML import Band, DiracDelta, Constant, Line, Quadratic, Cubic, Quartic, StepFunction, StepFunctionUpper, Cosine_Prior, Uniform_prior, PhAbs, Gaussian -import astropy.units as astropy_units -from astropy.units import Quantity -from past.utils import old_div -from scipy.special import gammainc, expi -from scipy.interpolate import interp1d, RegularGridInterpolator -from scipy import integrate import numpy as np -import math +from scipy.interpolate import interp1d + import astropy.units as u from astropy.io import fits +from astropy.coordinates import BaseCoordinateFrame, Galactic, SkyCoord + +from astromodels.functions.function import ( + Function1D, + Function2D, + Function3D, + FunctionMeta, + ModelAssertionViolation, +) + import healpy as hp -from histpy import Histogram, Axes, Axis -from astropy.coordinates import BaseCoordinateFrame, ICRS, Galactic, SkyCoord import logging logger = logging.getLogger(__name__) @@ -57,7 +56,10 @@ class Band_Eflux(Function1D, metaclass=FunctionMeta): min : 0 fix: yes """ - + + def _setup(self): + self._params = np.full(5, np.nan) + def _set_units(self, x_unit, y_unit): # The normalization has the unit of x * y self.K.unit = y_unit * x_unit @@ -66,18 +68,48 @@ def _set_units(self, x_unit, y_unit): self.E0.unit = x_unit # alpha and beta are dimensionless - self.alpha.unit = astropy_units.dimensionless_unscaled - self.beta.unit = astropy_units.dimensionless_unscaled + self.alpha.unit = u.dimensionless_unscaled + self.beta.unit = u.dimensionless_unscaled # a and b have the same units of x self.a.unit = x_unit self.b.unit = x_unit + def get_normalization(self, a, b, alpha, beta, E0): + """ + Compute normalization constant for function. + """ + + from cosipy.response.integrals import get_integral_values + from astromodels import Band_grbm + + # Cache the normalizing integral so we can reuse its value + # instead of recomputing it if its parameters have not + # changed. We must test for change in all the parameters of + # spectrum. + + params = np.array([a, b, alpha, beta, E0]) + if not np.array_equal(self._params, params): + self._params = params + + spectrum = Band_grbm(alpha=alpha, + beta=beta, + K=1.0, + xc=E0, + piv=1.0) + + self._integral = get_integral_values(spectrum, [a, b])[0] + + return self._integral + def evaluate(self, x, K, E0, alpha, beta, a, b): + + import astromodels.functions.numba_functions as nb_func + if alpha < beta: raise ModelAssertionViolation("Alpha cannot be less than beta") - if isinstance(x, astropy_units.Quantity): + if isinstance(x, u.Quantity): alpha_ = alpha.value beta_ = beta.value K_ = K.value @@ -91,29 +123,13 @@ def evaluate(self, x, K, E0, alpha, beta, a, b): else: unit_ = 1.0 alpha_, beta_, K_, E0_, a_, b_, x_ = alpha, beta, K, E0, a, b, x - - spectrum_ = Band(alpha=alpha_, - beta=beta_, - K=1.0, - xp=E0_*(2 + alpha_), - piv=1.0) - - # Cache the normalizing integral so we can reuse its value - # instead of recomputing it if its parameters have not - # changed. We must test for change in all the parameters of - # spectrum_, as testing equality of two Band objects always - # returns False. - - params_ = np.array([a_, b_, alpha_, beta_, E0_]) - if not hasattr(self, "_params") or \ - not np.array_equal(self._params, params_): - self._params = params_ - self._integral = integrate.quad(spectrum_, a_, b_)[0] - A_ = K_ / self._integral + A_ = K_ / self.get_normalization(a_, b_, alpha_, beta_, E0_) + # accelerated eval uses function of Band_grbm(), not Band() return nb_func.band_eval(x_, A_, alpha_, beta_, E0_, 1.0) * unit_ + class SpecFromDat(Function1D, metaclass=FunctionMeta): r""" description : @@ -123,7 +139,7 @@ class SpecFromDat(Function1D, metaclass=FunctionMeta): desc : Normalization factor initial value : 1.0 is_normalization : True - min: 0.0 + min: 0.0 max: 1e6 delta: 1.0 units: ph/cm2/s/kev @@ -132,204 +148,66 @@ class SpecFromDat(Function1D, metaclass=FunctionMeta): desc: the data file to load initial value: test.dat defer: True - units: + units: energy: keV flux: ph/cm2/s/kev - """ - def _set_units(self, x_unit, y_unit): - - self.K.unit = y_unit - - def evaluate(self, x, K): - dataFlux = np.genfromtxt(self.dat.value,comments = "#",usecols = (2),skip_footer=1,skip_header=5) - dataEn = np.genfromtxt(self.dat.value,comments = "#",usecols = (1),skip_footer=1,skip_header=5) - - # Calculate the widths of the energy bins - ewidths = np.diff(dataEn, append=dataEn[-1]) - - # Normalize dataFlux using the energy bin widths - dataFlux = dataFlux / np.sum(dataFlux * ewidths) - - fun = interp1d(dataEn,dataFlux,fill_value=0,bounds_error=False) - - if self._x_unit != None: - dataEn *= self._x_unit - - result = np.zeros(x.shape) * K * 0 - - for i in range(len(x)): result[i] += K*fun(x[i]) - return result - - -class Wide_Asymm_Gaussian_on_sphere(Function2D, metaclass=FunctionMeta): - r""" - description : - - A bidimensional Gaussian function on a sphere (in spherical coordinates) - - see https://en.wikipedia.org/wiki/Gaussian_function#Two-dimensional_Gaussian_function - - parameters : - - lon0 : - - desc : Longitude of the center of the source - initial value : 0.0 - min : 0.0 - max : 360.0 - - lat0 : - - desc : Latitude of the center of the source - initial value : 0.0 - min : -90.0 - max : 90.0 - - a : - - desc : Standard deviation of the Gaussian distribution (major axis) - initial value : 10 - min : 0 - max : 90 - - e : - - desc : Excentricity of Gaussian ellipse, e^2 = 1 - (b/a)^2, where b is the standard deviation of the Gaussian distribution (minor axis) - initial value : 0.9 - min : 0 - max : 1 - - theta : - - desc : inclination of major axis to a line of constant latitude - initial value : 10. - min : -90.0 - max : 90.0 - - """ - def _set_units(self, x_unit, y_unit, z_unit): - - # lon0 and lat0 and a have most probably all units of degrees. However, - # let's set them up here just to save for the possibility of using the - # formula with other units (although it is probably never going to happen) - - self.lon0.unit = x_unit - self.lat0.unit = y_unit - self.a.unit = x_unit - self.e.unit = u.dimensionless_unscaled - self.theta.unit = u.degree - - def evaluate(self, x, y, lon0, lat0, a, e, theta): - - lon, lat = x, y - - b = a * np.sqrt(1.0 - e**2) - - dX = np.atleast_1d(angular_distance(lon0, lat0, lon, lat0)) - dY = np.atleast_1d(angular_distance(lon0, lat0, lon0, lat)) - - dlon = lon - lon0 - if isinstance(dlon, u.Quantity): - dlon = (dlon.to(u.degree)).value - - idx = np.logical_and( - np.logical_or(dlon < 0, dlon > 180), - np.logical_or(dlon > -180, dlon < -360), - ) - dX[idx] = -dX[idx] - - idx = lat < lat0 - dY[idx] = -dY[idx] - - if isinstance(theta, u.Quantity): - phi = (theta.to(u.degree)).value + 90.0 - else: - phi = theta + 90.0 - - cos2_phi = np.power(np.cos(phi * np.pi / 180.0), 2) - sin2_phi = np.power(np.sin(phi * np.pi / 180.0), 2) - - sin_2phi = np.sin(2.0 * phi * np.pi / 180.0) - - A = old_div(cos2_phi, (2.0 * b**2)) + old_div(sin2_phi, (2.0 * a**2)) - - B = old_div(-sin_2phi, (4.0 * b**2)) + old_div(sin_2phi, (4.0 * a**2)) - - C = old_div(sin2_phi, (2.0 * b**2)) + old_div(cos2_phi, (2.0 * a**2)) - - E = -A * np.power(dX, 2) + 2.0 * B * dX * dY - C * np.power(dY, 2) - - return np.power(old_div(180, np.pi), 2) * 1.0 / (2 * np.pi * a * b) * np.exp(E) - - def get_boundaries(self): - - # Truncate the gaussian at 2 times the max of sigma allowed - - min_lat = max(-90.0, self.lat0.value - 2 * self.a.max_value) - max_lat = min(90.0, self.lat0.value + 2 * self.a.max_value) + """ - max_abs_lat = max(np.absolute(min_lat), np.absolute(max_lat)) + def _setup(self): + self._dat_file = None - if ( - max_abs_lat > 89.0 - or 2 * self.a.max_value / np.cos(max_abs_lat * np.pi / 180.0) >= 180.0 - ): + def _set_units(self, x_unit, y_unit): - min_lon = 0.0 - max_lon = 360.0 + self.K.unit = y_unit - else: + def evaluate(self, x, K): - min_lon = self.lon0.value - 2 * self.a.max_value / np.cos( - max_abs_lat * np.pi / 180.0 - ) - max_lon = self.lon0.value + 2 * self.a.max_value / np.cos( - max_abs_lat * np.pi / 180.0 - ) + if self.dat.value != self._dat_file: - if min_lon < 0.0: + # data file property changed -- reload and rebuild + # interpolator function - min_lon = min_lon + 360.0 + self._dat_file = self.dat.value - elif max_lon > 360.0: + data = np.genfromtxt(self.dat.value,comments = "#", + usecols = (1,2), + skip_footer=1, + skip_header=5) + dataEn = data[:,0] + dataFlux = data[:,1] - max_lon = max_lon - 360.0 + # Calculate the widths of the energy bins + ewidths = np.diff(dataEn, append=dataEn[-1]) - return (min_lon, max_lon), (min_lat, max_lat) + # Normalize dataFlux using the energy bin widths + dataFlux /= np.sum(dataFlux * ewidths) - def get_total_spatial_integral(self, z=None): - """ - Returns the total integral (for 2D functions) or the integral over the spatial components (for 3D functions). - needs to be implemented in subclasses. + self._fun = interp1d(dataEn, dataFlux, fill_value=0, bounds_error=False) - :return: an array of values of the integral (same dimension as z). - """ + return K * self._fun(x) - if isinstance(z, u.Quantity): - z = z.value - return np.ones_like(z) class GalpropHealpixModel(Function3D, metaclass=FunctionMeta): r""" - description : + description : A custom 3D function that reads a GALPROP HEALPix map and - interpolates over energy for a given set of sky positions in - Galactic coordinates (default is all-sky). The intensity is - interpolated from the GALPROP spectra stored in the HEALPix - map, and scaled by a normalization constant K. + interpolates over energy for a given set of sky positions in + Galactic coordinates (default is all-sky). The intensity is + interpolated from the GALPROP spectra stored in the HEALPix + map, and scaled by a normalization constant K. This class is compatible with healpix outputs from GALPROP v54 and - v57 (default). The GALPROP maps should be defined in Galactic - coordinates and specify the intensity in units of ph/cm2/s/sr/MeV, + v57 (default). The GALPROP maps should be defined in Galactic + coordinates and specify the intensity in units of ph/cm2/s/sr/MeV, with energy given in MeV. - When calling the function, energies are assumed to be in MeV, - coordinates in degrees (galactic frame), and fluxes are returned + When calling the function, energies are assumed to be in MeV, + coordinates in degrees (galactic frame), and fluxes are returned in 1/(cm2 MeV s sr). - + latex : $ K \times \ \mathrm{GALPROP_map(l,b,E)}$ - + parameters : K : desc : Normalization factor (unitless) @@ -348,7 +226,7 @@ def _setup(self): self._gal_version = 57 def set_frame(self, new_frame): - + """ Set a new frame for the coordinates (the default is Galactic) @@ -360,13 +238,13 @@ def set_frame(self, new_frame): self._frame = new_frame.name def set_version(self,v): - + """ - Set GALPROP version for input skymap. + Set GALPROP version for input skymap. "param v: version number, either 57 (default) or 54. """ - + if not v in [54,57]: raise ValueError("GALPROP version must be 54 or 57.") @@ -385,7 +263,7 @@ def load_file(self, fits_path): if self._gal_version == 57: self.table = np.stack([skymap_hdu.data[col] for col in skymap_hdu.columns.names], axis=1) self.energy = energy_hdu.data['ENERGY'] * u.MeV # in MeV - + if self._gal_version == 54: self.table = np.stack([skymap_hdu.data[s] for s in range(skymap_hdu.data.shape[0])], axis=1)[0] self.energy = energy_hdu.data['MeV'] * u.MeV # in MeV @@ -394,18 +272,18 @@ def load_file(self, fits_path): self.nside = hp.npix2nside(self.n_pixels) def _set_units(self, x_unit, y_unit, z_unit, w_unit): - + self.K.unit = u.dimensionless_unscaled def evaluate(self, x, y, z, K): - + if x.shape != y.shape: raise ValueError("x and y must have the same shape") - if self._fitsfile == None: + if self._fitsfile is None: raise RuntimeError("Need to either specify or load a fits file") - if self._file_loaded == False: + if not self._file_loaded: self.load_file(self._fitsfile) if self._frame != "galactic": @@ -422,10 +300,10 @@ def evaluate(self, x, y, z, K): logger.info("Interpolating GALPROP map...") self._result = np.zeros((x.size, z.size)) for i, p in enumerate(pix): - spectrum = self.table[p] + spectrum = self.table[p] interp_func = interp1d(self.energy, spectrum, bounds_error=False, fill_value='extrapolate') - self._result[i] = interp_func(z) - + self._result[i] = interp_func(z) + return K * self._result * ((u.MeV * u.s * u.cm**2 * u.sr) ** (-1)) def to_dict(self, minimal=False): @@ -437,9 +315,9 @@ def to_dict(self, minimal=False): data['extra_setup'] = {"_fitsfile": self._fitsfile, "_frame": self._frame} return data - + def get_total_spatial_integral(self, z, avg_int=False, nside=None): - + """ Returns the total integral over the spatial components. @@ -448,30 +326,26 @@ def get_total_spatial_integral(self, z, avg_int=False, nside=None): # access with results.optimized_model["galprop_source"].spatial_shape.nside - if nside != None: + if nside is not None: # Get spatial grid from nside - n_pixels = hp.nside2npix(nside) + n_pixels = hp.nside2npix(nside) ipix = np.arange(n_pixels) - coords = hp.pix2ang(nside, ipix, lonlat=True) + x, y = hp.pix2ang(nside, ipix, lonlat=True) logger.info(f"using nside={nside} from user input in evaluate method") else: # Get spatial grid from GALPROP map: self.load_file(self._fitsfile) ipix = np.arange(self.n_pixels) - coords = hp.pix2ang(self.nside, ipix, lonlat=True) + x, y = hp.pix2ang(self.nside, ipix, lonlat=True) logger.info(f"using nside={self.nside} from GALPROP map in evaluate method") - x = coords[0] - y = coords[1] - intensity_3d = self.evaluate(x, y, z, self.K.value) # We are calculating the average intensity (and not the total in) - intensity_2d = np.sum(intensity_3d,axis=0) + intensity_2d = np.sum(intensity_3d, axis=0) - if avg_int == True: + if avg_int: intensity_2d /= len(intensity_3d) # return average intensity return intensity_2d - diff --git a/docs/tutorials/apps/get_tutorial_data.py b/docs/tutorials/apps/get_tutorial_data.py index 6f84b6ba..839b6411 100644 --- a/docs/tutorials/apps/get_tutorial_data.py +++ b/docs/tutorials/apps/get_tutorial_data.py @@ -3,7 +3,7 @@ import subprocess from pathlib import Path from cosipy.util import fetch_wasabi_file -from cosipy import COSILike, BinnedData +from cosipy import BinnedData # indir=str("./") # @@ -73,4 +73,4 @@ def get_data (wasabipath,outpath,unzip): grb.combine_unbinned_data(["GRB_bn081207680_3months_unbinned_data_filtered_with_SAAcut.fits","GalTotal_SA100_F98_3months_unbinned_data_filtered_with_SAAcut.fits"], output_name=grb_bk) subprocess.run(["gunzip", "galbk_grbdc3.fits.gz"]) -# \ No newline at end of file +# diff --git a/docs/tutorials/source_injector/Extended_source_injector.ipynb b/docs/tutorials/source_injector/Extended_source_injector.ipynb index 50c91b60..71c8c1a6 100755 --- a/docs/tutorials/source_injector/Extended_source_injector.ipynb +++ b/docs/tutorials/source_injector/Extended_source_injector.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -50,20 +50,20 @@ "\n", "from threeML import PointSource, Model, ExtendedSource\n", "\n", - "from astromodels import Gaussian, Gaussian_on_sphere, Parameter\n", + "from astromodels import Gaussian, Gaussian_on_sphere, Asymm_Gaussian_on_sphere, Parameter\n", "\n", "from histpy import Histogram\n", "\n", "from cosipy import SourceInjector\n", "from cosipy.util import fetch_wasabi_file\n", - "from cosipy.threeml.custom_functions import Wide_Asymm_Gaussian_on_sphere, SpecFromDat\n", + "from cosipy.threeml.custom_functions import SpecFromDat\n", "\n", "%matplotlib inline" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -140,9 +140,220 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + " * gaussian (extended source):\n", + " * shape:\n", + " * lon0:\n", + " * value: 359.75\n", + " * desc: Longitude of the center of the source\n", + " * min_value: 0.0\n", + " * max_value: 360.0\n", + " * unit: deg\n", + " * is_normalization: false\n", + " * lat0:\n", + " * value: -1.25\n", + " * desc: Latitude of the center of the source\n", + " * min_value: -90.0\n", + " * max_value: 90.0\n", + " * unit: deg\n", + " * is_normalization: false\n", + " * sigma:\n", + " * value: 5.0\n", + " * desc: Standard deviation of the Gaussian distribution\n", + " * min_value: 0.0\n", + " * max_value: 20.0\n", + " * unit: deg\n", + " * is_normalization: false\n", + " * spectrum:\n", + " * main:\n", + " * Gaussian:\n", + " * F:\n", + " * value: 0.04\n", + " * desc: Integral between -inf and +inf. Fix this to 1 to obtain a Normal distribution\n", + " * min_value: null\n", + " * max_value: null\n", + " * unit: s-1 cm-2\n", + " * is_normalization: false\n", + " * mu:\n", + " * value: 511.0\n", + " * desc: Central value\n", + " * min_value: null\n", + " * max_value: null\n", + " * unit: keV\n", + " * is_normalization: false\n", + " * sigma:\n", + " * value: 0.85\n", + " * desc: standard deviation\n", + " * min_value: 1.0e-12\n", + " * max_value: null\n", + " * unit: keV\n", + " * is_normalization: false\n", + " * polarization: {}" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Define spectrum:\n", "# Note that the units of the Gaussian function below are [F/sigma]=[ph/cm2/s/keV]\n", @@ -183,21 +394,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot spectrum:\n", "energy = np.linspace(500.,520.,201)*u.keV\n", "dnde = gaussian_extended_source.spectrum.main.Gaussian(energy)\n", "plt.plot(energy, dnde)\n", - "plt.ylabel(\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", - "plt.xlabel(\"Energy [keV]\", fontsize=14)" + "plt.ylabel(r\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", + "plt.xlabel(\"Energy [keV]\", fontsize=14);" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -212,9 +434,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot healpix map:\n", "plot, ax = skymap.plot(ax_kw = {'coord':'G'})\n", @@ -244,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -261,9 +494,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Define the file path\n", "file_path = \"gaussian_extended_source.h5\"\n", @@ -295,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -342,7 +586,9 @@ "# Define Spatial Model Components\n", "MapNarrowBulge = Gaussian_on_sphere(lon0=359.75,lat0=-1.25, sigma = 2.5)\n", "MapBroadBulge = Gaussian_on_sphere(lon0 = 0, lat0 = 0, sigma = 8.7)\n", - "MapDisk = Wide_Asymm_Gaussian_on_sphere(lon0 = 0, lat0 = 0, a=90, e = 0.99944429,theta=0)\n", + "MapDisk = Asymm_Gaussian_on_sphere(lon0 = 0, lat0 = 0, e = 0.99944429,theta=0)\n", + "MapDisk.a.max_value = 90\n", + "MapDisk.a.value = 90\n", "\n", "# Fix fitting parameters (same for all models)\n", "for map in [MapNarrowBulge,MapBroadBulge]:\n", @@ -371,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -387,9 +633,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot spectra at 511 keV\n", "energy = np.linspace(500.,520.,10001)*u.keV\n", @@ -400,7 +657,7 @@ " axs.plot(energy, dnde,label=label)\n", "\n", "axs.legend()\n", - "axs.set_ylabel(\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", + "axs.set_ylabel(r\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", "axs.set_xlabel(\"Energy [keV]\", fontsize=14);\n", "plt.ylim(0,);\n", "#axs[0].set_yscale(\"log\")" @@ -408,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -436,9 +693,40 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot spatial structure of the extended components\n", "List_of_Maps = [mDisk,mNarrowBulge,mBroadBulge]\n", @@ -461,7 +749,7 @@ " lat.set_ticklabel(fontsize=4)\n", " lat.set_ticks_visible(True)\n", " lat.set_ticklabel_visible(True)\n", - " ax.set_title(n)" + " ax.set_title(n);" ] }, { @@ -473,7 +761,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -490,9 +778,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.42 s, sys: 5.03 s, total: 8.45 s\n", + "Wall time: 10.9 s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAG5CAYAAAC9VCFYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAMbpJREFUeJzt3Xl4VPW9x/HPkJCwJCwmkCBhkUUkgiuIiFjUgYYqVEWF6vVKlcgiQpUCgu0tKgj0Iu5i4XrFulSoGC+lbEZEhLpWlkJCBMEQxCCJCWTISnLuHzwzTcgkmZnML5OZvF/P42Ny5sw53+/5TWY+nG1slmVZAgAAgF81C3QBAAAAoYiQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZHmguLhYGRkZKi4uDnQpAAAgSBCyPJCZmank5GRlZmYGuhQAABAkCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAA8IDXUBDevvtt7VmzRo5HA4lJCTohRdeUKtWrQJdFgAACEFNJmS99957+vzzz/Xyyy+rY8eOOnTokMLDm0z7AACggTWJlFFeXq433nhDL774ouLi4iRJPXv2DHBVAAAglDXKkFVYWKh33nlHaWlpSk9PV0FBgebMmaORI0dWm7e0tFSvvvqqNm/erIKCAvXs2VMTJkzQwIEDXfOcOHFCJSUl2rp1q1avXq2oqCiNGzdOo0aNasi2AABAE9IoT3w/efKkVq5cqczMTPXq1avWeRcuXKjVq1dr+PDhmjZtmpo1a6ZZs2Zpz549rnlOnDghh8OhrKwsrV69Wk888YSWL1+u3bt3m24FAAA0UY0yZMXExCglJUV//etfNXny5BrnS0tL04cffqgHHnhAU6ZM0ejRo/Xss88qPj5ey5Ytc80XGRkpSRo/frwiIyPVs2dP3Xjjjfrss8+M9wIAAJqmRhmyIiIiFBMTU+d8H3/8scLCwjR69GjXtMjISN10003at2+fjh8/Lknq0qWLmjdvLpvN5pqv8s8AAAD+1ihDlqcOHDighIQEtW7dusr0vn37SpIOHjwoSWrZsqV+9rOf6c9//rNKS0v13XffacuWLbr66qvdLjcnJ0cZGRmu/zIzM802AgAAQk6jPPHdU7m5uW73eDmn5eTkuKY9/PDDWrx4sUaNGqW2bdvq/vvv16WXXup2uWvXrtXKlSuN1AwAAJqGoA5ZJSUlat68ebXpERERrsedoqOjNX/+fI+WO3r0aA0ZMsT1e2ZmpsfPBQAAkII8ZEVGRqqsrKza9NLSUtfjvoiNjVVsbGy9agMAAE1bUJ+TFRMTo9zc3GrTndMISgAAIFCCOmT16tVLR48e1enTp6tMT0tLcz0OAAAQCEEdsoYNG6by8nKtXbvWNa20tFTr169XYmKi6yt0AAAAGlqjPSdrzZo1cjgcrkN/O3bs0I8//ihJGjNmjKKiopSYmKjrr79ey5cvV35+vjp37qyNGzcqOztbs2fPDmT5AACgiWu0IWvVqlXKzs52/b5t2zZt27ZNkjRixAhFRUVJkubOnau4uDht2rRJDodDPXr00OLFi3XZZZcFomwAAABJks2yLCvQRTR2GRkZSk5O1ooVK9SnT59AlwMAAIJAUJ+TBQAA0FgRsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMCARnufrMYgNTVVqampcjgcgS4FAAAEGUJWLex2u+x2u+s+WQAAAJ7icCEAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwIDwQBfQmKWmpio1NVUOhyPQpQAAgCBDyKqF3W6X3W5XRkaGkpOTA10OAAAIIhwuBAAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwIDzQBTRmqampSk1NlcPhCHQpAAAgyBCyamG322W325WRkaHk5ORAlwMAAIIIhwsBAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMCA8EAX0JilpqYqNTVVDocj0KUAAIAgQ8iqhd1ul91uV0ZGhpKTkwNdDgAACCIcLgQAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABgQHugCGrPU1FSlpqbK4XAEuhQAABBkCFm1sNvtstvtysjIUHJycqDLAQAAQYTDhQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMCAcH8vcMOGDfrmm28UHR2tm266SXFxcf5eBQAAQKPnc8h6//339frrr8tms+mll15Sp06dNG/ePG3durXKPCtWrAjaoJWamqrU1FQ5HI5AlwIAAIKMz4cLd+3apZ9++kkRERHq1KmTvv/+e3300UeSJMuyZFmWTp06pXfeecdvxTY0u92uRYsW6aGHHgp0KQAAIMj4HLIOHjwom82m/v37S5J27twpSQoLC9OQIUMUFhYmy7L0z3/+0z+VAgAABBGfQ1ZeXp4kqWPHjpKkw4cPS5KuvfZaPfXUU/r5z38uSTp+/Hh9awQAAAg6PoesoqIiSVLLli0lSUePHpXNZlOPHj0kSZ07d5YklZeX17dGAACAoONzyGrdurWks+dm5eXlKS0tTZKUkJAgSSooKJAktWnTpr41AgAABB2fQ5Zzj9VXX32lW2+9VadOnZIk9e3bV5J04sQJSVJsbGx9awQAAAg6PoespKQkWZYlSa7/JyYm6vzzz5dlWdq5c6dsNpsuuugi/1QKAAAQRHy+T9bIkSP1ww8/aO3atSotLdUll1yiRx55RJJ06NAhtW7dWq1bt9bAgQP9ViwAAECwsFnO3VCoUUZGhpKTk7VixQr16dMn0OUAAIAg4POerJUrV0qSBg4cqIsvvrja4/n5+a7bNxBMAABAU+NzyHrttddks9nUsmVLtyFr48aNeuWVV2Sz2Vx3ggcAAGgq/P4F0U7Or9YBAABoiny+urA2JSUl2rt3r4lFAwAABAWv9mQNGzasyu+WZWnZsmVatmxZjc9p1aqVT4UBAAAEM69ClmVZstlsVQ4D1nRI0GazyWazuT1fCwAAINR5fbjQ0/OsLMvSeeedp0mTJnldFAAAQLDzak/Wo48+6vp50aJFstlsuuGGG6rdcDQ8PFwdOnTQxRdfrObNm/unUgAAgCDiVcgaOXKk6+dFixbJsiz16dOnynQAAADU4xYOq1atkiS1adPGb8UAAACECp9DVnx8vOvnoqIiFRQU1Hi+VlxcnK+rAQAACEr1uhnphg0b9PbbbysrK6vGebjjOwAAaIp8Dlnr1q3TkiVLJHl+xSEAAEBT4fMd31etWkW4AgAAqIHPe7J++OEH2Ww2RUZGKjk5WV27dlXz5s1ls9n8WR8AAEBQ8jlkRUdHKy8vT7/85S91++23+7MmAACAoOfz4cJrrrlGlmWppKTEn/UAAACEBJ9D1n333aeYmBht2LBB//jHP/xZEwAAQNDz+XDhE088ocjISOXm5mru3LmKiYlRp06dFBYWVmU+m82mZ599tr51AgAABBWfQ9auXbtks9lks9lkWZZycnKUm5tbZR7LsjgRHgAANEn1uhnpubdw4JYOAAAAZ/kcspKSkvxZBwAAQEjxOWTNmTPHn3UAAACEFJ+vLgQAAEDNfN6Tdfz4cY/njYuL83U1AAAAQcnnkHXnnXd6dOWgzWbTRx995OtqAAAAglK9ri6UuKIQAADAnXqdk1VTwHLePwsAAKCp8nlP1nPPPVdtWmlpqY4ePaqUlBRlZWVp8ODBGjduXL0KBAAACEY+h6zLLrvM7fSrrrpKI0aM0L333qvPPvtMo0aN8nUVAAAAQcvILRyioqLUv39/WZalt956y8QqAAAAGjUjIev06dNKT0+XJB08eNDEKgAAABo1nw8XTp8+3e30kpISHTlyRIWFhZKkiIgIX1cRcKmpqUpNTZXD4Qh0KQAAIMj4HLJ27dpV4xWElmW5rjAcOHCgz8UFmt1ul91uV0ZGhpKTkwNdDgAACCL1uk9WbffIsixLCQkJmjJlSn1WAQAAEJR8DllJSUlup9tsNkVFRalv374aOnRoUB8uBAAA8JXPIWvOnDn+rAMAACCkGLm6EAAAoKmr93cX7t69W6tXr9a+ffvkcDgUFRWlfv366Y477tCll17qjxoBAACCTr1C1urVq7Vs2TJZluU6CT4vL0/bt2/Xjh07NHnyZN15551+KRQAACCY+Hy4MD09XcuWLVNFRYXbxysqKrRs2TLXTUkBAACaEp9D1po1a1RRUSGbzaYWLVpo2LBhuu222zRs2DC1aNFC0tnbOLz33nt+KxYAACBY+Hy4cM+ePZKkuLg4/elPf1K7du1cj+Xl5WnixIk6fvy4du/eXe8iAQAAgo3Pe7J++ukn2Ww22e32KgFLktq3b6/hw4e75gMAAGhqfA5ZYWFhks5+GbQ7zunO+QAAAJoSn0NWp06dZFmWNmzYoC+++KLKY1988YXWr18vm82mTp061btIAACAYOPzOVlXXXWVDh8+rJKSEs2aNUvt2rVT+/btlZeXp/z8fNeXRA8aNMif9QIAAAQFn/dk3XnnnYqOjpZ09irCvLw8HT58WHl5ea57ZkVFRemOO+7wT6UAAABBxOeQFRsbq/nz57uCliRXuJKkNm3aaMGCBYqNja1fhQAAAEGoXnd8v+yyy/SXv/xFGzZs0L59+3Tq1Cm1adNG/fr1U1JSkqKiovxVJwAAQFCp93cXOg8JclgQAADg37wOWcePH5ckRUZGVrs/llN+fr5KSkoknb1ZKQAAQFPj1TlZn3/+ucaOHauxY8dq+/btNc63fft2jR07VuPGjeOO7wAAoEnyKmRt3bpVlmWpffv2GjlyZI3zJSUlqV27drIsS1u2bKl3kQAAAMHGq5CVlpYmm82mq666qtY7uYeHh+uqq66SZVnatWtXfWsEAAAIOl6FrOzsbElS586d65zXOY/zOQAAAE2JVyHrzJkzkqreD8vT5wAAADQlXoUs541Hv/nmmzrndc5T+WalAAAATYVXIatr166yLEuffvqpvv322xrn+/bbb/Xpp5/KZrOpS5cu9S4SAAAg2HgVsq688kpJUnl5uWbMmKFPPvmk2jzbt2/XzJkzVV5eLkkaMGCAH8oEAAAILl7djHT06NF68803VVZWpry8PP3+979XdHS0EhISJElHjx5VQUGB65yt5s2ba9SoUf6vGgAAoJHzak9W+/btNWXKFFmWJZvNJsuydOrUKaWnpys9PV2nTp1yPWaz2TRp0iSdd955pmoHAABotLwKWZJ06623auLEibLZbJLk+n/ln202myZMmKAxY8b4qUwAAIDg4tMXRN9111265pprtGbNGn399dfKycmRJMXGxurKK6/Ubbfdpu7du/uzTgAAgKDiU8iSpO7du2vGjBn+rAUAACBkeH24EAAAAHUjZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABPt/CAf7x131/1X9t/S8VlBQEuhQAAAImOjJaT17/pG5PvD3QpfgNISvA/mvrf2l/zv5AlwEAQGAVSL//6PeELPiPcw9WM1szdYrqFOBqAABoeD84flCFVRFyR3UIWY1Ep6hOOvrI0UCXAQBAg0tYmqDvC74PdBl+x4nvAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADwgNdQGOWmpqq1NRUORyOQJcCAACCDCGrFna7XXa7XRkZGUpOTg50OQAAIIhwuBAAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAMIWQAAAAYQsgAAAAwgZAEAABhAyAIAADCAkAUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwABCFgAAgAGELAAAAAPCA11AQ5k2bZrS0tIUFhYmSbrkkkv03//93wGuCgAAhKomE7IkadasWRoxYkSgywAAAE0AhwsBAAAMaJR7sgoLC/XOO+8oLS1N6enpKigo0Jw5czRy5Mhq85aWlurVV1/V5s2bVVBQoJ49e2rChAkaOHBgtXlfeOEFvfDCC+rdu7cefPBB9ezZsyHaAQAATVCj3JN18uRJrVy5UpmZmerVq1et8y5cuFCrV6/W8OHDNW3aNDVr1kyzZs3Snj17qsw3adIkrVq1Su+++64GDBigmTNnqrCw0GQbAACgCWuUISsmJkYpKSn661//qsmTJ9c4X1pamj788EM98MADmjJlikaPHq1nn31W8fHxWrZsWZV5ExMT1apVK0VGRuquu+5Sq1attG/fPtOtAACAJqpRhqyIiAjFxMTUOd/HH3+ssLAwjR492jUtMjJSN910k/bt26fjx4/X+FybzSbLsvxSLwAAwLka5TlZnjpw4IASEhLUunXrKtP79u0rSTp48KDi4uJUUFCg/fv369JLL5XNZlNKSooKCgqUmJjodrk5OTnKzc11/Z6ZmWmuCQAAEJKCOmTl5ua63ePlnJaTkyNJKi8v1/Lly3XkyBGFh4erV69eWrx4saKiotwud+3atVq5cqWxugEAQOgL6pBVUlKi5s2bV5seERHhelyS2rVrpxUrVni83NGjR2vIkCGu3zMzMzV//vx6VgsAAJqSoA5ZkZGRKisrqza9tLTU9bgvYmNjFRsbW6/aAABA09YoT3z3VExMTJVzp5yc0whKAAAgUII6ZPXq1UtHjx7V6dOnq0xPS0tzPQ4AABAIQR2yhg0bpvLycq1du9Y1rbS0VOvXr1diYqLi4uICWB0AAGjKGu05WWvWrJHD4XAd+tuxY4d+/PFHSdKYMWMUFRWlxMREXX/99Vq+fLny8/PVuXNnbdy4UdnZ2Zo9e3YgywcAAE1cow1Zq1atUnZ2tuv3bdu2adu2bZKkESNGuG6/MHfuXMXFxWnTpk1yOBzq0aOHFi9erMsuuywQZQMAAEhqxCFr9erVHs0XGRmpKVOmaMqUKYYrAgAA8FxQn5MFAADQWBGyAAAADCBkAQAAGEDIAgAAMICQBQAAYAAhCwAAwIBGewuHxiA1NVWpqalyOByBLgUAAAQZQlYt7Ha77Ha79uzZo6lTpyozM9Pv64jIj1Dr060VUR6hjIwMvy8fAIDGzvRnYbdu3dSiRQu/L7cuNsuyrAZfa5DZvHmz5s+fH+gyAACAD1asWKE+ffo0+HoJWR7Iz8/XF198oU6dOikiIsLvy3/hhRf00EMP+X25jUWo9yeFfo+h3p8U+j3SX/AL9R5N9heoPVkcLvRAu3btNGLECGPLj4qKCkjCbiih3p8U+j2Gen9S6PdIf8Ev1HsMxf64urARsNvtgS7BqFDvTwr9HkO9Pyn0e6S/4BfqPYZifxwuBAAAMIA9WQAAAAYQsgAAAAzgxHdUUVpaqqVLl+qrr76Sw+FQ9+7dNXXqVPXr1y/QpRkXrL0Ha93+FkrbIZR68UYo9R1KvXgjVPr2Wx8WUElhYaH12muvWdnZ2VZ5ebmVmppq3Xzzzdbp06cDXZpxwdp7sNbtb6G0HUKpF2+EUt+h1Is3QqVvf/VByEKdbrnlFmv//v2BLiMggrX3YK3b30JpO4RSL94Ipb5DqRdvhErfvvQR0ocLd+7cqenTp7t9bNmyZbr44otrfX5paaleffVVbd68WQUFBerZs6cmTJiggQMHVps3IyNDK1as0N69e2VZli6++GJNnjxZvXv39ksvUu39JCYmKisrSwUFBZozZ45Gjhzptp8VK1Zo7dq1Kioqks1mU0JCgn7zm99U68nZz549e1RcXKyXX35ZU6dOrdZPfbexr7xdb+WxPHXqlNq2bauYmBgdO3asxm3m3J6dO3cOSM2V6960aZPy8/PVsmVLVVRUqKioqMZxzsrK0qlTp7Rp0yY9+uijtb52G2L8alvHL37xC+Xk5Cg9Pd3tOBQWFuqdd97R3r17tWfPHpWWliosLEwXXnhhtX6c86alpbmWFxYW5rfx81cvletr3bq1ysrKqo2PN72E0himp6dr48aN2rlzp7Kzs9W6dWvl5eXJ8uNF8A01ht70YnoMa1v+M888o927d1fpqXLf3vR8+PBhvfbaa8rIyNBPP/2kFi1aKD4+XidPnvTr36E77uqs6T1S8u7zXfL98yCkQ5bTmDFj1Ldv3yrTPNlQCxcu1NatW3XHHXcoISFBGzZs0KxZs/Tcc8/pkksucc2XkZGhBx98UB07dtT48eNlWZZSUlI0bdo0/elPf1LXrl2N9ZOfn68XX3xRJ06cUK9evbRz585a+9myZYskacCAATp27JiysrI0c+ZMPf/8866enP106NBBbdq0Ub9+/XT06NFa+/F1G/tDmzZt1L59e2VmZmrUqFFu11t5LKOjo7VixQrl5OSod+/eKigoqDZ/SUmJ5s+fr7vvvltRUVEBqbly3SNHjtS6detUWlqqsrKyGpfrrDshIUEpKSl1vnadGmL8zl2H87UbFxdX42v35MmTWrlypVq0aKHS0lJJ0vDhw5WVlVWtH+e8cXFx6tGjh3bv3q3BgwcbGb/69BIXF6ewsDBJ0sUXX6zrrruu2vj40ksojOHbb7+tf/3rX7r++uvVtWtXvfnmm4qMjNT06dO1bNky9ejRo1H04skY+tKL6TF0t/yoqChXT+769qbn7OxsFRYWKikpSbGxsXI4HFq5cqXOnDmjLVu2aPTo0X7r5VyV66zrs1Dy/PNdqufngYE9ao3G119/bQ0dOtT66KOPvH7uvn37rKFDh1pvv/22a1pxcbE1btw4a9KkSVXmnTlzpvWLX/zCys/Pd007ceKENWLECOuxxx6rdT2nTp2ytm7dWuPjH3zwgVVYWFhjPyUlJVZOTo5lWZaVnp5uDR061Fq/fn2N/VTuqbi42Bo7dqx14403VunJ2c/DDz9sPf7441ZFRUWN/fi6jb3p2x3neteuXWtZlme9O/suKSmxjh07Zo0bN8669957qz2vrKzMmjVrlqt3f9XtTc3n1u0c5+LiYuu2225z+zxn3Y888ojHr92GGL+a1uHJa7ekpMT6xz/+YQ0dOtR69tlnXfO468e5vLKyMmvKlCnW0KFDrb///e9+7ae+veTk5FT5W3TOc24/3vQSSmO4Z88eq7S0tMrf4JEjR6wbb7zReuKJJ/zST0ONoTe9mB7D2pZfV9/e9FyZs+958+ZZv/71r627777bL73UxNPPQsvy7vO9ts8DTzSZWzgUFhbqzJkzHs//8ccfKywsrEryjoyM1E033aR9+/bp+PHjrul79uzRgAED1LZtW9e02NhYXXbZZfr0009VWFhY43pSUlI0b948bdu2rdpj69at0xNPPKGNGzfW2E9ERIRiYmI86sdms6lZs2auniIjI3XzzTertLS0Sk979uxRy5YtFRERoblz58pms3nUjzfb2Ne+zxUdHa3CwkKVl5fXOM+5YxkREaFOnTrppptu0qFDh6rMW1FRofnz58tms7l693fdntR8bt3OcY6MjNS1114r6ey/3NzV3aNHD49fu5U1xPhVXocnr92IiAjt2rVLYWFhuu6662rtJyIiQu3bt3dtB0nVxs+f/fjSS0xMjD7++GM1a1b1rffcfnztJdjHsH///goLC6vyN9ilSxd1795dmZmZfu/H5Bj62ovpMTx3+XX17U3PTpXfjx577DF17NhRDofD7724q9MTnn6+1/V54IkmEbIWLlyopKQkDR8+XNOnT9f+/fvrfM6BAweUkJCg1q1bV5nu3NV68OBB17SysjK3XxzdokULlZWV6fDhwzWu56677tLVV1+tJ554Qv/85z9d0z/++GM9/fTTGjFihG655Ra/9BMZGakuXbpU6anyrmNnT8XFxSorK9Pjjz+u8PB/H1GurR9va/Klb3ec633wwQclST/88IPb3msby8qWLFmi3Nzcar37s25Paq6t7u7du0uSfvzxR7d1f/vttx6/ds+tyeT4+fK6lf69HVq2bFlnP87t8MADD3i0bF/78bUXZz8dO3asNv3cfrztJdTG0Pk3aFmW8vLyqvwj1h/9NOQYetqL6TFsiJ4ladGiRTp+/LgmTpyo9957T59//rmuuOIKv/ZSH55+vtf1eeCJkD4nKzw8XD/72c909dVXq23btvruu++0atUqTZ06VS+//LIuvPDCGp+bm5vrNhU7p+Xk5LimdenSRWlpaSovL3cdsy4rK1NaWpok6cSJE7XWOG/ePM2cOVNz587VM888o6KiIj355JMaNGiQHn30UVd6rquf2uTm5lap/9x+nD1lZ2eroqJCeXl5GjVqlGvdTz31lNt+fN3G3vRd0/Mrr/fLL79USkqK3nzzTV177bVV1lvXWDplZ2dr3bp1ioiIqPIvnD/+8Y+69NJL6123NzXXVrfzDdp5Ltm5dRcXF8tms2n37t2uuiv3W/m12xDjV5+/w9q2w7n9VN4OM2bMkHT2TfL888+vsh3q0099e3H207ZtW2VnZ9fYjze9hOoYOv8Gz5w5o7KyMt133321rqMxj2FdvZgew4bqWTo7hs49Tvfee68kqVmzZho+fHity6/vZ4I3PHk9evJ54ImQDln9+/dX//79Xb9fe+21GjZsmH79619r+fLlWrJkSY3PLSkpUfPmzatNd+6xKikpcU279dZb9fTTT2vx4sW66667VFFRoT//+c+uYOM82bMmkZGRWrhwoaZPn65Zs2aprKxMffv2rZae6+pnwoQJtfZjWVa1nirvgSspKVF8fLxmzJihp59+WsOGDauzn/psY0/7dufc9cbGxiolJUWSqq23rrF0io+Pd7ur2l91e1NzbXU7pzl3+Z9b97hx49SlS5dqbwTuXrsNMX71WUdt2+Hcfipvh/379+uBBx7Qb3/7W4/fED3pp769OOtt1apVrf1400uojqEkZWZmatKkSbrwwguVlJRU6zo87ScQY1hXL6bHsKF6ls6O4RtvvKETJ04oJydHH330kcLDw9WnT58611GfzwRvePJ69PTzoC5N4nBhZQkJCbr22mu1c+fOWs+JiYyMdHsVlzNgREZGuqb98pe/1D333KPU1FT953/+p8aPH69jx47pV7/6lSRV20XuTuvWrTVlyhSdOnVKRUVFeuihh6qsw5N+Kioqau3HZrNV66lyYHKur779eLqNJd/7rknv3r2rrbeusfSFP+t2V7NUc93OaTW96Xjz2nWnIcbPm3XUtx9v+NKPN71IZ+t1d86NP/sJhTHMzc3V7Nmz1bp1az355JOuowR1aYxj6EsvpsfQZM/dunXTgAEDlJSUpMWLF6uoqEiPPvqoR7fi8PdngjsN+Z7S5EKWJHXs2FFlZWUqLi6ucZ6YmBjXnpvKnNNiY2OrTE9OTtb//d//6cUXX9Rrr72m5cuXu15QXbp0qbOmY8eO6cknn1TXrl0VHx+v3//+91UO63jST+U9FO76qVz/uf2c21N9+/FkG0v169udNm3aVFtvXWPpC3/W7a5mqea6nSe8R0dHu12et69ddxpi/Dxdhz/68ZSv/Xjai3S2n8oXLTj5u59gHkOHw6FZs2bJ4XBoyZIlXm2TxjaG9enF9Bg21Ot22LBh2r9/v7Kysupcj78/E9xpyPeUJhmyjh07poiIiFr3yPTq1UtHjx7V6dOnq0x3npfUq1evas+Jjo7WJZdcop49e0qSvvrqK3Xo0KHO+2Tl5OTokUceUXh4uJYuXaqnn35axcXFmjFjhk6dOuVxP7Wl7169eqmkpERZWVlVenL2464nX/upXFNt27i+fbuTn59fbb11jaW3/F23u5prq9t54YG7k1Bre15tr91zNcT4ebKOyv0UFRX53I8n6tOPp70466180YKTv/sJ1jEsKSnRo48+qqysLC1atMh1oYcnGtsY1qcXT2tqbD2749wBUNcVhiY+E9zxx3ukp0I6ZOXn51ebdvDgQe3YsUMDBw50XY5aXFyszMzMKvMPGzZM5eXlWrt2rWtaaWmp1q9fr8TERMXFxdW67g8//FD79+/XHXfcUe2y18oKCgr029/+VkVFRVq6dKk6duyoLl26aMmSJTpx4oRmz57temPytJ+ysjK3/ViWpYqKCldPzn6aN29eZ0819eNpTfXp2x1365XOXjVy7thedNFFNY7lBRdcUOM6/F23NzVnZmZqwIABbuvesWOHJNV4hZI3r92GGD9v1pGbm1ttfmc/lc+P8OZv0ROe9lPfXpz9nHtovz79hNIYlpeXa968edq3b58ef/xxr76Mt7GNoTe9mB5DT5fvDEPubtPjSc95eXnVnnfmzBlt2rRJkZGRtYbM+n4meKO+n+/eCOkT3//whz8oMjJS/fr1U/v27fXdd9/pb3/7m1q0aKGJEye65ktPT9f06dM1fvx411UfiYmJuv7667V8+XLl5+erc+fO2rhxo7KzszV79uwq69m1a5def/11DRw4UG3atFFaWpo2bNigQYMG6fbbb6+1xpSUFP344496/vnnqxyG6927txYtWqQZM2Zo48aNuvXWW2vsp1mzZoqPj9f69eslSZs3b9aSJUt0+eWXa8GCBYqKinL1s3XrVr3yyiv66quv9P333+vYsWNq1qyZJk2a5FM/nm7j+vRd29g67/3lvOLFZrMpPj5er7/+usaMGaMDBw5o3rx56t69e5WxfOutt5Sdna0hQ4bo8OHD2rFjh+tfaWPGjKnxrr71qdubmp2vx8qvwePHj2vv3r2uXec11ezNa7chxq+2dfTo0UOvv/66azf98uXL9eWXX+qKK65w9ZSenq4LLrhA7733niTp3Xff1auvvqoTJ05o2rRpVepas2aNHA6Ha3n+HtetW7fWqxdnfeeff76OHTumN954Q9u2bdOBAweUk5NTZXw87SWUxvCll17Sjh07dM0116igoECbN2+uUvOIESPq3U9DjaE3vZgew9p6njhxoqsn5y0dUlJSXHudxowZo02bNnnU85IlS3T69Gldeuml6tChg3Jzc/XBBx/oyJEjevDBB92eOO9tLzV9Jkie/8148x5ZXzbLkzPRgtS7776rDz74QN9//71Onz6tdu3a6corr9T48eOVkJDgms/5vU6VQ5Z0NtU7v9vI4XCoR48emjBhgq666qoq6/n++++1dOlSffPNNyoqKlJ8fLySkpI0duxYt1cwVHbmzBllZWXVuEfl22+/VY8ePWSz2Wrs5+uvv67xmPWqVavUqVMnVz/Lly/X3/72N9dl/p07d9ZvfvObKj1504+n27g+fbvjXO/+/ftrPJly1apVys7O1vTp03XPPfeorKzMNZYVFRU13vCv8jbzZ93e1jx+/HjdfffdrtfgTz/95PY57mr29LXbEONX2zoeeeSRapeEn9vTnXfeWec8Tt7M60s/a9asMdbL3Llzq1x15mkvoTSG06ZN065du2qsubarvRrbGHrTi+kxrK3nhISEOsdn+vTpHvX84Ycf6u9//7sOHTqkkydPqlWrVurTp49uu+02102U69tLbbdx8Obv39P3yPoK6ZAFAAAQKCF9ThYAAECgELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgACELAADAAEIWAACAAYQsAAAAAwhZAAAABhCyAAAADAjpL4gGAEn64YcfNHbs2GrTe/Xqpf/93/+V9O/vMHWq7bsOA2Xu3Lnavn17tenPPfecLr/88gBUBKA2hCwA9XZuQKlJUlKS5s6d2wAVNU7/8R//oSNHjkiSunXrpjfeeMPtfEVFRbrllltUVFQkSRo6dKgWLFjQYHUC8A9CFoAm55577lFUVJTat2/foOtNSkrS8uXLJUmZmZnKyMhQnz59qs33ySefuAKW83mSNHLkSPXv31+StGzZsgaoGEB9ELIA+N0NN9zgNjz06NEjANVUd/PNNwfkUODPf/5z/c///I8qKiokSRs3bnS7nTZu3Oj6uV27dho8eLCks3u0nAhZQONHyALgd4MGDdLIkSNrnefc86SeeeYZHTp0SO+//76OHz+uzp076+6779aIESNUVFSkV199VVu2bNGpU6fUrVs3jR8/vkroMGn16tV68cUXXb+PHz9e9913nyTp9OnTSklJ0SeffKIjR46opKRE5513nq644gr96le/0gUXXOB6XocOHTRw4EB9/vnnkqQtW7bowQcfVHj4v9+Kc3Jy9PXXX7t+HzFiRJXHAQQP/nIBNAqvvPKKMjIyXL8fPnxY8+fPV2FhoTZs2KD09HTXYwcOHNDvfvc7LV26VFdeeaXRulJSUqoErIkTJ+ruu++WJGVlZWnGjBnKzs6u8pwff/xRGzdu1JYtW/TYY4/p+uuvdz2WlJTkCll5eXn68ssvXXuqJOmDDz5w7emSVGdYBdB4EbIA+N3nn3+u/Pz8atNvuOEGxcXFuX1ORkaGBg0apIsuukjr1q1Tbm6uJGnp0qWSpCFDhuiCCy7QmjVrVFRUJMuy9Je//MVoyFq3bp2effZZ1+/Tpk3T7bffLkkqLy/X7373O1fAateunex2u9q0aaMvvvhCe/fuVWlpqRYsWKA+ffro/PPPl3T2kF9UVJQcDoeks4cGK4eszZs3u37u3bu3evbsaaw/AGYRsgD43ZYtW7Rly5Zq0y+66KIaQ9bAgQP1xz/+UTabTR06dNCSJUtcjw0ePFgLFy6UJFmWpbfeekuStH//fgPVn7Vp0yatXLlSlmXJZrNpxowZGj16tOvxTz/9VIcPH5YkhYWF6aWXXlKXLl0knT2x/v7779ehQ4dUWlqq9957T1OnTpUkRUREyG636/3335ck7dixQw6HQ1FRUTp48KC+/fZb1zrYiwUEN0IWgEbBbrfLZrNJkuLj46s8VvlwW+fOnV0/FxQUGKvHef+sZs2aafbs2dUCz7/+9S/Xz+Xl5a5DiO7s3bu3yu9JSUmukFVaWqqtW7fq5ptv1qZNm1zzNG/eXMOHD69vGwACiJAFwO/mzJnj9V6Y2NhY18/Nmzev8bGwsDDXz5Zl+Vih58LDw93uffMm4J176DQxMVHdu3fXd999J+nsXrORI0cqNTXVNc/gwYPVtm1bn2oG0DgQsgA0CrVdQVc5WDWUrl276siRIyotLdWcOXP0zDPPKDEx0fV4dHS06+eIiAjdf//9NS4rKiqq2rSkpCS98sorkqQ9e/ZUOQ9N4lAhEAoIWQDgxh/+8ActWLBAhw4dUlFRkWbOnKnnn3/edSJ6v379XPOWlpbqggsu0NVXX11tOWlpadX2zElnb82wYsUKlZeXy7IsvfTSS67HzjvvPA0aNMhAVwAaEiELgN/VdHVhVFSURo0a1fAF+SAqKkpLlizR5MmTdfz4cRUUFGjGjBl64YUX1KVLFw0ePFjdunVTZmamJOmxxx7Tddddp+7du6uiokLHjh3T7t27lZ2drTlz5qh3795Vlh8bG6uBAwfqs88+kyQVFxe7Hhs+fDj3xgJCAH/FAPyupqsL4+PjgyZkSWeD0JIlSzR16lSdPHlSP/30kx5++GG99NJLiouL01NPPeW6T1ZZWZk+/PBDr5Y/cuRIV8g6dzqA4Ncs0AUAQGPWrVs3LV68WC1btpR09kajDz/8sHJzc9WlSxetXLlSkydPVr9+/RQdHa2wsDC1atVKPXv21M0336wFCxbIbre7XfaQIUPUpk2bKtP69OnTaL5+CED92KyGuDwHAALo3K/wqfwF0c4vXw4Gn3zyiY4ePSqp6ncXPvfcc7r88ssDVRaAGnC4EECT88Ybb0iSevXqFVQha8OGDdq+fXugywDgIQ4XAgAAGMDhQgAAAAPYkwUAAGAAIQsAAMAAQhYAAIABhCwAAAADCFkAAAAGELIAAAAMIGQBAAAYQMgCAAAwgJAFAABgwP8DPgGSQIyHiMQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "%%time\n", "\n", @@ -515,9 +822,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -539,7 +857,7 @@ "ax.set_ylabel(\"Counts\", fontsize=14, fontweight=\"bold\")\n", "ax.set_xlabel(\"Em [keV]\", fontsize=14, fontweight=\"bold\")\n", "\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -558,7 +876,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -573,9 +891,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The difference between the injected and simulates is 0.0877110098356934%\n" + ] + } + ], "source": [ "# Compare and plot the simulated and injected counts:\n", "\n", @@ -589,9 +915,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAG5CAYAAAB4JrvJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYO5JREFUeJzt3XlclNX+B/DPMMwMy7AOm4IbYCqaaYqWSi6NWyppauW9LeZWYOqvTXMp9V7XNMss6WIUV1sUU7tUuFzcSFPbXFKQXEkt9sUZQAaG5/eHlydGtgFmnBnm8369fOVznvOc53uYgK/nnOc8EkEQBBARERFRgxwsHQARERGRrWDiRERERGQkJk5ERERERmLiRERERGQkJk5ERERERmLiRERERGQkJk5ERERERmLiZEK3bt1Ceno6bt26ZelQiIiIyAwcLR1AS5CcnIzk5GRotVqcOXMGmzZtQqdOnSwdFhEREZkYEycTUKvVUKvVSE9Px/Tp0y0dDhEREZkJp+qIiIiIjMTEiYiIiMhITJyIiIiIjMQ1TiZQfXE4ERERtVxMnEyAi8OJiIjsA6fqiIiIiIzExImIiIjISEyciIiIiIzExImIiIjISFwcbgJ8qo6IiMg+MHEyAT5VR0REZB84VUdERERkJCZOREREREZi4kRERERkJCZOREREREZi4kRERERkJCZOREREREbidgQmwH2ciIiI7AMTJxPgPk5ERET2gVN1REREREZi4kRERERkJCZOREREREZi4kRERERkJCZOREREREbiU3V3+Pzzz7Fjxw5otVoEBQVhw4YNcHFxsXRYREREZAWYOFWzc+dOnDhxAhs3boSfnx8uX74MR0d+iYiIiOg2ZgX/o9frsWXLFrz//vvw9/cHAISEhFg4KiIiIrImNps4lZSUYOvWrUhNTUVaWho0Gg3mz5+PkSNH1qir0+kQFxeHffv2QaPRICQkBNOmTUN4eLhYJycnB2VlZTh06BASEhKgVCrx5JNPYsyYMXezW0RERGTFbHZxeFFREeLj45GRkYHQ0NB6665cuRIJCQkYOnQoZs+eDQcHB8ydOxdnzpwR6+Tk5ECr1eLatWtISEjAP/7xD8TGxuL06dPm7goRERHZCJtNnFQqFXbt2oXt27cjKiqqznqpqanYv38/ZsyYgejoaERGRuLdd99FQEAAYmJixHoKhQIAMHnyZCgUCoSEhODhhx/G8ePHzd4XIiIisg02mzjJ5XKoVKoG6x0+fBhSqRSRkZFimUKhwKhRo3Du3DlkZWUBANq0aQOZTAaJRCLWq/53IiIiIptNnIx14cIFBAUFwdXV1aC8S5cuAICLFy8CAJydnTFw4EBs3rwZOp0OV69exYEDB/DAAw/U2XZubi7S09PFPxkZGebrCBEREVmczS4ON1ZeXl6tI1NVZbm5uWLZSy+9hNWrV2PMmDHw8PDA1KlTcd9999XZdmJiIuLj400eMxEREVmnFp84lZWVQSaT1SiXy+Xi+Spubm5YtmyZ0W1HRkaif//+4nFGRkajriciIiLb0uITJ4VCgfLy8hrlOp1OPN9UPj4+8PHxQXJyMpKTk6HVapvcFhEREVm/Fp84qVQq5OTk1CjPy8sDcDv5aS61Wg21Wo309HRMnz692e0RERGRdWrxiVNoaChOnjyJ4uJigwXiqamp4vnm4ogTERGRfWjxT9UNGjQIer0eiYmJYplOp0NSUhLCwsLE16s0h1qtxqpVqzBr1qxmt0VERETWy6ZHnHbs2AGtVitOux09ehTZ2dkAgPHjx0OpVCIsLAyDBw9GbGwsCgsLERgYiD179iAzMxPz5s2zZPhERERkY2w6cdq2bRsyMzPF45SUFKSkpAAAhg0bBqVSCQBYsGAB/P39sXfvXmi1WgQHB2P16tXo0aOHSeLgVB0REZF9kAiCIFg6iJaianH4pk2b0KlTJ0uHQ0RERCbW4tc4EREREZmKTU/VWQtO1REREdkHJk4mwH2ciIiI7AOn6oiIiIiMxMSJiIiIyEicqjMBrnEiIiKyD0ycTIBrnIiIiOwDp+qIiIiIjMTEiYiIiMhITJyIiIiIjMQ1TibAxeFERET2gYmTCXBxOBERkX3gVB0RERGRkZg4ERERERmJiRMRERGRkZg4ERERERmJi8NNgE/VERER2QcmTibAp+qIiIjsA6fqiIiIiIzExImIiIjISEyciIiIiIzENU42YPt2YMlnyZDct7PBupWFrXBzxxsGZcoRG+AYmNbgtWVnh6D0xASDMs+p0UbFqN07ExXXu4rHjkHnoBz+gVHXFsZtNDh27vslFN0ONHhdxY0u0O6ZZVDmPv6fcPD8s8FrS088hrKzavFY4lIAj0kLjYr35s5FqCxoLR7LOx2By4DPG7xOKPFE0RcrDMpcH94EWfuTDV6rS++HkiNPGZR5PvMyILvV4LXFB6ai/Eov8VjqdxluY9Y2eB0AFG5+Gyh3Fo+den4Lp/u/bfA6fXYHaL5+zaDMbcwaSP2uNHjtrV9G4dbJUX8VyErh+cwrRsWr+fpV6LOD/7q0w89wHRLX8IXlTijcvM6gyGXAp5B3+r7hS6/2RPF+w7WNHpMWQOJS2OC1JUf+Bl36APHYwesPuD+2rOF4ARR9sRxCiZd4rOiWDOe+/BlRHX9GtLyfEQ56J0zo+DjefPYBo+IzByZONuDNN4FcvzK0dstvsG55sQtu3DAs6yDRQGHEtcXlJfjzjmtVRlwHAHkFFdBWu1bpWgEPI6+9M95W5SVwMeLaEommxrWusiLIjLj2ZmkZcqtdK/OohLeR8Wbn6FGW9dexd6AObkZcq9PX7GvbSi2cjLi2VF9c41pPlwJInUobvLbgZjmKql3r4lgBTyP7+uefAirL/jr2DyuBqxHX3spX1Yg3xPEm5EZcqy0rQVa1ax0UgtH/H+bmV6Ck2rUeqnK4G3Gt/pZzjXiD9MVwNuJaTaW2xrVuikKj+lqk1SG/2rWKCj28jOxrVnYlyov+OvYJKYOSPyMM8GdEy/wZ8eWFBLwJJk5UD40GqPRQoLzIGw4NTK5Kyz0QGGhYJhfcoNd4N3gfV5lLjWuNuQ4AVF6O8Kh2raOXo9HX3nlPZ5mLUdfKBbca10rLPaDXlDR4rbuzAopq10pcHIyO189Xispq3zlypdyoax3KPGvE6+SgNOpaZ6lrjWtR4gV9tX/p1cXLXQZltWul3sZ/Nq1aSYDyavEqjPtsZBXuNeKVVbgbda1S4QLH6tfKJEbH6+PtCH1FtUvdZcZdW+5U8/9DqatR1zo5KGtc61DmCb2m4dt6KOVwrnatg5fU6L76+zlAUP51rHBWGHUtf0bwZ8SdbOVnhNQtH/k/PQRFcTujYjMXiSAIgkUjaAGq7+N05swZbNq0CZ06dTJZ+0FBt/8VEhgIXL9usmaJiIhshrX8LuSIkwlwHyciIiL7wMTJBkhcCiDzqITExQGAV4P1iYiIyDyYONkAj0kL4e2W/7+5340N1iciImpxZKVwUAiATAKg4bVb5sLEiYiIiKye5zOvQGUFgwjcAJOIiIjISEyciIiIiIzEqbpqZs+ejdTUVEilUgBA9+7dsWbNGgtHRURERNaCidMd5s6di2HDhlk6DCIiIrJCnKojIiIiMpLNjjiVlJRg69atSE1NRVpaGjQaDebPn4+RI0fWqKvT6RAXF4d9+/ZBo9EgJCQE06ZNQ3h4eI26GzZswIYNG9CxY0fMnDkTISEhd6M7REREZANsdsSpqKgI8fHxyMjIQGhoaL11V65ciYSEBAwdOhSzZ8+Gg4MD5s6dizNnzhjUe+GFF7Bt2zZ8+eWX6N27N1577TWUlDT8TiMiIiKyDzabOKlUKuzatQvbt29HVFRUnfVSU1Oxf/9+zJgxA9HR0YiMjMS7776LgIAAxMTEGNQNCwuDi4sLFAoF/va3v8HFxQXnzp0zd1eIiIjIRtjsVJ1cLodKpWqw3uHDhyGVShEZGSmWKRQKjBo1CrGxscjKyoK/v3+t10okEljDO5Bv7lyE7Bw9/HylwFJLR0NERGS/bDZxMtaFCxcQFBQEV1dXg/IuXboAAC5evAh/f39oNBqcP38e9913HyQSCXbt2gWNRoOwsLA6287NzUVeXp54nJGRYZY+VBa0RlkWUNniPy0iIqLaab5+Fbn5FfDxdrToIEKL/1Wcl5dX68hUVVlubi4AQK/XIzY2Fr///jscHR0RGhqK1atXQ6lU1tl2YmIi4uPjzRI3ERER/UWfHYySG4C+wrJxtPjEqaysDDKZrEa5XC4XzwOAp6cnNm3a1Ki2IyMj0b9/f/E4IyMDy5Yta0a0REREZM1afOKkUChQXl5eo1yn04nnm8rHxwc+Pj5ITk5GcnIytFptk9uqj7zTEXgH6iBXygEMMMs9iIiIqGEtPnFSqVTIycmpUV61NsnHx6fZ91Cr1VCr1UhPT8f06dOb3d6dXAZ8DjfxjdBMnIiIyP7IOvwMD1U5ZO4yAL0sFkeLT5xCQ0Nx8uRJFBcXGywQT01NFc83l7lHnIiIiOyd65A4uIuDCJZLnGx2HydjDRo0CHq9HomJiWKZTqdDUlISwsLC6tyKoDHUajVWrVqFWbNmNbstIiIisl42PeK0Y8cOaLVacdrt6NGjyM7OBgCMHz8eSqUSYWFhGDx4MGJjY1FYWIjAwEDs2bMHmZmZmDdvniXDJyIiIhtj04nTtm3bkJmZKR6npKQgJSUFADBs2DBxK4EFCxbA398fe/fuhVarRXBwMFavXo0ePXqYJA5O1REREdkHm06cEhISjKqnUCgQHR2N6Ohos8Rh7sXhREREZB1a/BonIiIiIlOx6REna8GpOiIiIvvAxMkEOFVHRERkH5g42QChxBM6PeBQ5mnpUIiIiOwaEycbUPTFCty4AQQGAlhj6WiIiIgsoNwJ+lvOQLmTRcNg4mQCXONERERkXoWb1/01iLDCcnEwcTIBrnEiIiKyD9yOgIiIiMhIHHGyAa4Pb0LbSi2cHJQAOKJFRERkKUycbICs/Uk4iW+EJiIisj8uAz5FkL4YzlJXAE9ZLA4mTibAxeFERETmJe/0PZzFQQQmTjaNi8OJiIjsAxeHExERERmJiRMRERGRkZg4ERERERmJiRMRERGRkbg43AT4VB0REZF9YOJkAnyqjoiIyD4wcbIBuvR+KBU3/SIiIiJLYeJkA0qOPPXXG6GJiIjsUPnVntCIrx+zHCZOREREZPWK90+3ikEEPlVHREREZCQmTkRERERG4lSdDfB85mV4uhQAJV4A1lk6HCIiIrvFxMkEzL6Pk+wWpE6l0Jc7m6d9IiIiK+cxaQHcFIVwKPMEsMJicTBxMgHu40RERGReEpdCyN3yoddYNg6ucSIiIiIyEhMnIiIiIiMxcSIiIiIyEhMnIiIiIiMxcSIiIiIyEhOnWpw9exYDBw7Ev//9b0uHQkRERFaEidMdKisr8f7776Nz586WDoWIiIisDPdxusPXX3+NLl26oLi42NKhiIoPTEXBzXJ4ucuApZaOhoiIyH7ZbOJUUlKCrVu3IjU1FWlpadBoNJg/fz5GjhxZo65Op0NcXBz27dsHjUaDkJAQTJs2DeHh4Qb1ioqKsH37dsTExGDDhg13qysNKr/SC0U3AKWF3whNRERkKSVH/oYirQ4eSrlF47DZqbqioiLEx8cjIyMDoaGh9dZduXIlEhISMHToUMyePRsODg6YO3cuzpw5Y1Bv06ZNmDhxItzc3MwZOhERETWSLn0A8n8YAl36AIvGYbOJk0qlwq5du7B9+3ZERUXVWS81NRX79+/HjBkzEB0djcjISLz77rsICAhATEyMWO+3337D+fPnMXr06LsRPhEREdkgm52qk8vlUKlUDdY7fPgwpFIpIiMjxTKFQoFRo0YhNjYWWVlZ8Pf3x6lTp3Dt2jWMHz8eAKDVaiGVSvHHH39g/vz5ZuuHMaR+l+HiWAGptyOAYIvGQkREZM9sNnEy1oULFxAUFARXV1eD8i5dugAALl68CH9/f0RGRuLhhx8Wz7/33nto1aoV/v73v9fZdm5uLvLy8sTjjIwME0d/m9uYtfB0y4de4w1go1nuQUREZM0cvP6AokIPBy8pgNYWi6PFJ055eXm1jkxVleXm5gIAnJyc4OTkJJ5XKBRwdnaud71TYmIi4uPjTRswERER1eD+2DJ4WcEgQotPnMrKyiCTyWqUy+Vy8XxtFixY0GDbkZGR6N+/v3ickZGBZcuWNTFSIiIisnYtPnFSKBQoLy+vUa7T6cTzTeXj4wMfHx8kJycjOTkZWq22yW0RERGR9WvxiZNKpUJOTk6N8qq1ST4+Ps2+h1qthlqtRnp6OqZPn97s9oiIiMg6tfjEKTQ0FCdPnkRxcbHBAvHU1FTxfHNxxImIiMg+2Ow+TsYaNGgQ9Ho9EhMTxTKdToekpCSEhYXB39+/2fdQq9VYtWoVZs2a1ey2iIiIyHrZ9IjTjh07oNVqxWm3o0ePIjs7GwAwfvx4KJVKhIWFYfDgwYiNjUVhYSECAwOxZ88eZGZmYt68eZYMn4iIiGyMTSdO27ZtQ2ZmpnickpKClJQUAMCwYcOgVCoB3H5Czt/fH3v37oVWq0VwcDBWr16NHj16mCQOTtURERHZB5tOnBISEoyqp1AoEB0djejoaLPEwcXhRERE9sGmEyd7Ubj5bfz5p4BWrSTAUktHQ0REZL+YOJmA2afqyp1RWQag5nZUREREdqHoi+XIyq6Ev5+DRQcRmDiZAKfqiIiIzEso8UJ5ESAoLRtHi9+OgIiIiMhUOOJkA5x6fgv/sBI4KVwAjLJ0OERERHaLiZMJmHuNk9P938JVfCM0EyciIrI/im7J8Akpg8JZAUBtsTiYOJkA1zgRERGZl3PfnVCKgwiWS5y4xomIiIjISEyciIiIiIzExImIiIjISFzjZAJ8Vx0REZF9MHnitHv3bvz2229wc3PDqFGj4O/vb+pbWB0uDiciIrIPTU6cvvrqK/z73/+GRCLBBx98gFatWmHJkiU4dOiQQZ1NmzbZRfJERERELV+T1zidOnUK+fn5kMvlaNWqFW7cuIGDBw8CAARBgCAIuHnzJrZu3WqyYImIiIgsqcmJ08WLFyGRSHDvvfcCAE6ePAkAkEql6N+/P6RSKQRBwM8//2yaSO2YPrsDijM6Qp/dwdKhEBER2bUmJ04FBQUAAD8/PwDAlStXAAADBgzAihUrMHz4cABAVlZWc2O0e5qvX8Ol9/8JzdevWToUIiIii6gsbIVbmUGoLGxl0TiavMaptLQUAODs7AwAuH79OiQSCYKDgwEAgYGBAAC9Xt/cGK0en6ojIiIyr5s73sCNG0BgIID1loujySNOrq6uAG6vdSooKEBqaioAICgoCACg0WgAAO7u7s2N0eqp1WqsWrUKs2bNsnQoREREZEZNTpyqRpZ++uknjBs3Djdv3gQAdOnSBQCQk5MDAPDx8WlujERERERWoclTdSNGjMCpU6cgkUggCAIAICwsDK1bt4YgCDh58iQkEgk6d+5ssmDtlduYNQhxvAlZhTsArnMiIiKylCYnTiNHjsSff/6JxMRE6HQ6dO/eHS+//DIA4PLly3B1dYWrqyvCw8NNFqy9kvpdgVx8IzQREZH9UY7YgA4SDeSCGwDLLY1p1s7hU6ZMwZQpU2qUh4SE4NNPP21O00REREQix8A0KKxgEKHJiVN8fDwAIDw8HF27dq1xvrCwUNyKoFOnTk29DREREZHVaHLi9Mknn0AikcDZ2bnWxGnPnj348MMPIZFIxB3FiYiIiGyZyV/yW6XqtSv2gPs4ERER2QezJE5lZWU4e/asOZq2Smq1Gmq1Gunp6Zg+fbqlwyEiIiIzaVTiNGjQIINjQRAQExODmJiYOq9xcXFpUmBERERE1qZRiZMgCAb7NlWV1UYikUAikdS6/omIiIjIFjV653Bj1y0JggBvb2+88MILjQ6KiIiIyBo1asTp9ddfF/++atUqSCQSDBkypMYml46OjvD19UXXrl0hk8lME6kdu/XLKGjLSqBUcNqTiIjIkhqVOI0cOVL8+6pVqyAIAjp16mRQTqZ36+QoZN0AHAMtHQkREZFllJ0dguLyErjKLDuI0OSn6rZt2wYAcHd3N1kwlrZmzRocPXoUt27dgr+/P2bMmIH+/ftbOiwiIiK7V3piAv68AQRaeBChyYlTQECA+PfS0lJoNJo61z/5+/s39TZ31eOPP445c+ZALpcjLS0NL7/8MrZu3QoPDw9Lh0ZERERWoFn7OO3evRuff/45rl27VmcdW9o5vF27duLfJRIJysvLkZuba/nESVYKB4UAyCQAnC0bCxERkR1rcuL0zTffYO3atQCMf9LOlEpKSrB161akpqYiLS0NGo0G8+fPr3W9lU6nQ1xcHPbt2weNRoOQkBBMmzatxqJ2AFi3bh2SkpKg0+nwwAMPIDg4+G50p16ez7wClfhiw42WDoeIiMhuNWuNU9W+TpZQVFSE+Ph4+Pv7IzQ0FCdPnqyz7sqVK3Ho0CFMnDgRQUFB2L17N+bOnYv169eje/fuBnVffvllzJkzB6dOncLly5ct1j8iIiL6i+fUaKsYRGhy4vTnn39CIpFAoVBg+vTpaNu2LWQy2V1LNFQqFXbt2gWVSoXz589jxowZtdZLTU3F/v37ERUVhUmTJgEAhg8fjsmTJ9e567lUKkWvXr2wfft2BAUF4cEHHzRrX4iIiMg2NDlxcnNzQ0FBAR599FFMmDDBlDEZRS6XQ6VSNVjv8OHDkEqliIyMFMsUCgVGjRqF2NhYZGVl1bl4Xa/X48aNGyaLmYiIiGxbo3cOr9KvXz8IgoCysjJTxmNyFy5cQFBQEFxdXQ3Ku3TpAgC4ePEiAECr1eK///0vSkpKUFFRgYMHD+LkyZO477776mw7NzcX6enp4p+MjAzzdYSIiIgsrskjTlOmTMGxY8ewe/du9O3bF/369TNlXCaTl5dX68hUVVlubi6A20/RffPNN3jnnXcgCAICAwPxxhtvoGPHjnW2nZiYiPj4eLPETURERNanyYnTP/7xDygUCuTl5WHBggVQqVRo1aoVpFKpQT2JRIJ33323uXE2WVlZWa2vfZHL5eJ5AHB1dcX69esb1XZkZKTBBpkZGRlYtmxZM6IlIiIia9bkxOnUqVOQSCSQSCQQBAG5ubnIy8szqGPJp+6qKBQKlJeX1yjX6XTi+aby8fGBj48PkpOTkZycDK1W2+S2iIiIyPo1awPMO/dvssR+Tg1RqVTIycmpUV6V5Pn4+DT7Hmq1Gmq1Gunp6Zg+fXqz2yMiIiLr1OTEacSIEaaMw2yq9ngqLi42WCCempoqnm8ujjgRERHZhyYnTvPnzzdlHGYzaNAgbN26FYmJieI+TjqdDklJSQgLCzPJe/TMPeKk+fpV5OZXwMfbEVhq8uaJiIjISM2aqrO0HTt2QKvVitNuR48eRXZ2NgBg/PjxUCqVCAsLw+DBgxEbG4vCwkIEBgZiz549yMzMxLx58ywZvtH02cEouQHoKywdCRERkWVo985EXkEFVF6WHURocuKUlZVldF1TjOrUZtu2bcjMzBSPU1JSkJKSAgAYNmwYlEolAGDBggXw9/fH3r17odVqERwcjNWrV6NHjx4miYNTdUREROZVcb0rtDcAj0DLxiERmriie+DAgUY9MSeRSHDw4MGm3MLmVE3Vbdq0CZ06dTJZu0FBwI0bQGAgcP26yZolIiKyGdbyu7DZU3XW+CRdSyPr8DM8VOWQucsA9LJ0OERERHbLpNsRVKkaibKXpMrcU3WuQ+LgLr4RmokTERHZH8egc1C6VsDRyxFAV8vF0dQLa9tlW6fT4fr169i1axeuXbuGBx98EE8++WSzArQF3MeJiIjIvJTDP4CHOIiw0WJxNDlxqmthdZ8+fTBs2DA8++yzOH78OMaMGdPUWxARERFZFQdzNKpUKnHvvfdCEAR89tln5rgFERER0V1nln2ciouLkZaWBgC4ePGiOW5hVbgdARERkX1ocuI0Z86cWsvLysrw+++/o6SkBAAgl8ubegubwTVORERE9qHJidOpU6fq3MdJEARIJBJIJBKEh4c3OTgiIiIia2KW7QiqzgUFBSE6Oro5tyAiIiKyGk1OnEaMGFFruUQigVKpRJcuXRAREWEXU3VERERkH5qcOM2fP9+Ucdg0sy8OL3eC/pYzUO5knvaJiIjIKGZ5qs7emHtxeOHmdeL7ebDC5M0TERGRkZqdOJ0+fRoJCQk4d+4ctFotlEolunXrhokTJ+K+++4zRYxERERk5wrjNv41iLDUcnE0K3FKSEhATEwMBEEQF4oXFBTgyJEjOHr0KKKiovD444+bJFAiIiIiS2vyzuFpaWmIiYlBZWVlrecrKysRExMjboRJREREZOuaPOK0Y8cOVFZWQiKRwMnJCX379oW3tzfy8/Nx4sQJlJaWQhAE7Ny5EwsXLjRlzHbHZcCnCNIXw1nqCuApS4dDRERkt5qcOJ05cwYA4O/vj3/961/w9PQUzxUUFOD5559HVlYWTp8+3ewgrZ25n6qTd/oezuIboZk4ERGR/XHu+yValZfAWeYCYILF4mjyVF1+fj4kEgnUarVB0gQAXl5eGDp0qFivpVOr1Vi1ahVmzZpl6VCIiIhaJEW3A/B9KAmKbgcsGkeTEyepVArg9gt9a1NVXlWPiIiIyNY1OXFq1aoVBEHA7t278cMPPxic++GHH5CUlASJRIJWrVo1O0giIiIia9DkNU59+vTBlStXUFZWhrlz58LT0xNeXl4oKChAYWGh+KLfvn37mjJeIiIiIotp8ojT448/Djc3NwC3X+hbUFCAK1euoKCgQNzTSalUYuLEiaaJlIiIiMjCmpw4+fj4YNmyZWLyBEBMmADA3d0dy5cvh4+PT/MiJCIiIrISzdo5vEePHvjiiy+we/dunDt3Djdv3oS7uzu6deuGESNGQKlUmipOIiIiIotr9rvqqqbj7HlKztz7OBEREZF1aHTilJWVBQBQKBQ19m+qUlhYiLKyMgC3N8hs6dRqNdRqNdLT0zF9+nSTt19+tSc0lVo4OXAEj4iIyJIalTidOHEC8+bNAwC8+uqrGD16dK31jhw5grVr10IikeDdd9/Ffffd1/xI7Vjx/ul/vRGaiIjIDlXc6IISiQZywa3hymbUqMXhhw4dgiAI8PLywsiRI+usN2LECHh6ekIQBBw4YNkdPomIiMj2affMwpWPFkC7x7Jv6WhU4pSamgqJRII+ffrUuyO4o6Mj+vTpA0EQcOrUqebGSERERGQVGpU4ZWZmAgACjZgzqqpTdQ0RERGRrWvUGqeKigoAhvs1GXsNNZ3HpAVwUxTCocwTwApLh0NERGS3GpU4ubm5obCwEL/99luDdavqVN8g05rpdDqsW7cOP/30E7RaLdq3b48XX3wR3bp1s3RokLgUQu6WD73G0pEQERFZhvv4f8JVVgRpuQeANywWR6Om6tq2bQtBEHDs2DFcunSpznqXLl3CsWPHIJFI0KZNm2YHeTfo9XoEBATggw8+QFJSEiZOnIj58+ejpKTE0qERERHZPQfPP+EUcB0Onn9aNo7GVO7VqxeA20nGK6+8gu+++65GnSNHjuC1116DXq8HAPTu3dsEYZqfs7MzJk+eDH9/fzg4OODhhx+Go6Mjrl27ZunQiIiIyEo0aqouMjISn376KcrLy1FQUIA33ngDbm5uCAoKAgBcv34dGo1GXAMlk8kwZswY00cNoKSkBFu3bkVqairS0tKg0Wgwf/78WrdJ0Ol0iIuLw759+6DRaBASEoJp06YhPDy8zvavXbsGjUZj1EJ4IiIisg+NGnHy8vJCdHQ0BEGARCKBIAi4efMm0tLSkJaWhps3b4rnJBIJXnjhBXh7e5sl8KKiIsTHxyMjIwOhoaH11l25ciUSEhIwdOhQzJ49Gw4ODpg7dy7OnDlTa/2ysjIsW7YMf//73/m+PSIiIhI1KnECgHHjxuH555+HRCIBAPG/1f8ukUgwbdo0jB8/3kRh1qRSqbBr1y5s374dUVFRddZLTU3F/v37MWPGDERHRyMyMhLvvvsuAgICEBMTU6N+RUUF3nzzTQQGBmLy5Mlmi5+IiIhsT5Ne8vu3v/0N/fr1w44dO/DLL78gNzcXAODj44NevXrhscceQ/v27U0ZZw1yuRwqlarBeocPH4ZUKkVkZKRYplAoMGrUKMTGxiIrK0t8n15lZSWWLVsGiUSCBQsWGCSFRERERE1KnACgffv2eOWVV0wZi1lcuHABQUFBcHV1NSjv0qULAODixYti4rR27Vrk5eVh7dq1cHRs+EuTm5uLvLw88TgjI8OEkRMREZG1aXLiZCvy8vJqHZmqKqsaLcvMzMQ333wDuVxuMDr11ltv1fmS4sTERMTHx5s+aCIiIrJKLT5xKisrg0wmq1Eul8vF8wAQEBCAlJSURrUdGRmJ/v37i8cZGRlYtmxZM6KtXcmRv6FIq4OHUm7ytomIiMh4LT5xUigUKC8vr1Gu0+nE803l4+MDHx8fJCcnIzk5GVqttslt1UeXPgD5NwBn7oxARER2qvTEY7hZWgZ356b/3jaFFp84qVQq5OTk1CivWpvk4+PT7Huo1Wqo1Wqkp6dj+vTpzW6PiIiIDJWdVSP3BqCw8CBCi0+cQkNDcfLkSRQXFxssEE9NTRXPN5e5R5yIiIjIOjR6HydbM2jQIOj1eiQmJoplOp0OSUlJCAsLE5+oaw61Wo1Vq1Zh1qxZzW6rNg5ef0Dhfw0OXn+YpX0iIiIyjk2POO3YsQNarVacdjt69Ciys7MBAOPHj4dSqURYWBgGDx6M2NhYFBYWIjAwEHv27EFmZibmzZtnyfCN5v7YMni55UOv8Qaw0dLhEBER3XUSlwLIPCohcXEA4GWxOGw6cdq2bRsyMzPF45SUFPHJuGHDhomvS1mwYAH8/f2xd+9eaLVaBAcHY/Xq1ejRo4dJ4uBUHRERkXl5TFoIbysYRLDpxCkhIcGoegqFAtHR0YiOjjZLHFwcTkREZB9a/BonIiIiIlOx6REna8GpOiIiIvvAxMkEOFVHRERkHzhVR0RERGQkJk5ERERERuJUnQlwjRMREZF9YOJkAlzjREREZB+YONmAoi+WIyu7Ev5+DsBSS0dDRERkv5g42QChxAvlRYCgtHQkRERElnFz5yJk5+jh5yu16CACEyciIiKyepUFrVGWBVRaOHNh4mQCXBxORERkH5g4mYC5F4cruiXDJ6QMCmcFALXJ2yciIiLjMHGyAc59d0IpvhGaiRMREdkfeacj8A7UQa6UAxhgsTiYOBEREZHVcxnwOdzEQQTLJU7cOZyIiIjISEyciIiIiIzEqToT4FN1RERE9oGJkwnwlStERET2gVN1REREREZi4kRERERkJCZOREREREbiGicbUFnYCuXFLpCWe1g6FCIiIrvGxMkG3NzxBm7cAAIDAay3dDRERER3n1DiCZ0ecCjztGgcTJyIiIjI6hV9seKvQYQ1louDiZMJcB8nIiIi+8DEyQS4jxMREZF9YOJkA5QjNqCDRAO54AZglqXDISIisltMnGyAY2AaFOIboYmIiOyP68Ob0LZSCycHJQDLze4wcSIiIiKrJ2t/Ek5WMIjADTCJiIiIjMTEiYiIiMhITJyq+eqrrzB16lQMHjwYH3/8saXDISIiIivDxKkalUqF5557DgMHDrR0KERERGSFuDi8moiICADA8ePHLRwJERERWSObTZxKSkqwdetWpKamIi0tDRqNBvPnz8fIkSNr1NXpdIiLi8O+ffug0WgQEhKCadOmITw83AKRExERka2y2am6oqIixMfHIyMjA6GhofXWXblyJRISEjB06FDMnj0bDg4OmDt3Ls6cOXOXoiUiIqKWwGZHnFQqFXbt2gWVSoXz589jxowZtdZLTU3F/v37ERUVhUmTJgEAhg8fjsmTJyMmJgYxMTF3M+wmKTs7BMXlJXCVuVg6FCIiIrtms4mTXC6HSqVqsN7hw4chlUoRGRkplikUCowaNQqxsbHIysqCv7+/OUNtttITE/Bn1RuhiYiI7JAuvR9K9cVwlrpaNA6bTZyMdeHCBQQFBcHV1fAL3aVLFwDAxYsXxcSpoqICer0elZWV0Ov1KCsrg6OjI6RSaa1t5+bmIi8vTzzOyMgwUy+IiIjsW8mRp3DDCgYRWnzilJeXV+vIVFVZbm6uWLZ582bEx8eLx1u2bKlzwTkAJCYmGtQnIiKilq3FJ05lZWWQyWQ1yuVyuXi+ypQpUzBlyhSj246MjET//v3F44yMDCxbtqwZ0RIREZE1a/GJk0KhQHl5eY1ynU4nnm8qHx8f+Pj4IDk5GcnJydBqtU1uqz6eU6OhEl9suNEs9yAiIqKGtfjESaVSIScnp0Z51dokHx+fZt9DrVZDrVYjPT0d06dPb3Z7REREZMjzmZfh6VIAlHgBWGexOFp84hQaGoqTJ0+iuLjYYIF4amqqeL65zD3iREREZPdktyB1KoW+3NmiYdjsBpjGGjRoEPR6PRITE8UynU6HpKQkhIWFmWQrArVajVWrVmHWrFnNbouIiIisl02POO3YsQNarVacdjt69Ciys7MBAOPHj4dSqURYWBgGDx6M2NhYFBYWIjAwEHv27EFmZibmzZtnyfCJiIjIxth04rRt2zZkZmaKxykpKUhJSQEADBs2DEqlEgCwYMEC+Pv7Y+/evdBqtQgODsbq1avRo0cPk8TBqToiIiL7YNOJU0JCglH1FAoFoqOjER0dbZY4uDiciIjIPrT4NU5EREREpmLTI07WglN1RERE9oGJkwlwqo6IiMg+MHGyAdq9M5FXUAGVlyOw1NLREBER2S8mTjag4npXaG8AHhZ+IzQREZGlFB+YioKb5fByl1l0EIGJkwlwjRMREZF5lV/phaIbgNLCgwhMnEyAa5yIiIjsAxMnG+AYdA5K1wo4ejkC6GrpcIiIiOwWEycboBz+ATzc8qHXeAPYaOlwiIiI7jqp32W4OFZA6u0IINhicTBxIiIiIqvnNmYtPK1gEIGJkwlwcTgREZF9YOJkAlwcTkREZB/4rjoiIiIiIzFxIiIiIjISEyciIiIiIzFxIiIiIjISF4ebAJ+qIyIisg9MnEyAT9URERHZByZONqAwbiNu3AACA2HRN0ITERHZOyZOREREZPUKN7+NP/8U0KqVxKKDCEyciCxEEATo9XpUVFRYOhSiFkkmk0EqlVo6DDKVcmdUlgEot2wYTJyI7jJBEFBYWIicnBzo9XpLh0PUonl6eiIgIAASicTSoVALwcTJBjj3/RKtykvgLHMBMMHS4VAzZWZmorCwEO7u7nB3d4ejoyN/qBOZmCAIKCkpQXZ2NgCgVatWFo6IWgomTjZA0e0AXMQ3QjNxsmV6vR5FRUXw9fWFj4+PpcMhatGcnZ0BANnZ2fDz8+O0nY1z6vkt/MNK4KRwATDKYnEwcTIB7uNExiovL4cgCHB1dbV0KER2wcXFBcDt7z0mTrbN6f5v4SoOIjBxsmncx4kai1NzRHcHv9fI1PjKFSIiIiIjMXEiIiIiMhITJyKi/2nfvj0mT55skXsvWbLE5NNKhw4dgkQiwaFDh0zaLpE9Y+JERCZT9Yu6tj/Hjx83qLtv3z5MnToV3bp1g1QqRfv27etsd/ny5YiMjIS/vz8kEgmWLFnSqLh+/fVXTJgwAe3atYOTkxMCAwMxdOhQbNiwoQm9tD4bN25EfHy8pcMgsgtcHE5EJjd79myEh4cblIWGhhocf/7559i2bRvuv/9+tG7dut72Fi1ahICAAPTs2RN79+5tVCzff/89Bg8ejLZt22L69OkICAjAtWvXcPz4caxfvx6zZs0S66anp8PBwfb+Pblx40b4+PjUGC176KGHUFpaCrlcbpnAiFogJk7VFBYWYsWKFTh16hR8fX3x8ssvo1evXpYOi8jmREREYMKE+vccW7FiBTZt2gSZTIbRo0fj7Nmzdda9cuUK2rdvj9zcXPj6+jYqluXLl8PDwwM//vgjPD09Dc5VbY5YRaFQNKpta+fg4AAnJydLh0HUotjeP63M6J133oG3tzcSExMRFRWFxYsX4+bNm5YOCxU3ukCT3h0VN7pYOhQio2k0mnrfw9e6dWvIZDKj2qpvGq8hly5dQteuXWskTQDg5+dX4z7VR23i4+MhkUhw5MgRzJ49G76+vvD09MTzzz8PnU6HwsJCPPPMM/Dy8oKXlxfmzp0LQRDE6+taY3T16lVIJJIGp9c++eQTDBkyBH5+flAoFAgLC0NMTEyNmM+dO4fDhw+L06KDBg2q9/7bt29Hr1694OzsDB8fHzz11FO4ceOGQZ3JkydDqVTixo0bGDt2LJRKJXx9ffHqq6/yVUFk1zji9D8lJSX47rvvsHXrVjg5OWHAgAEIDg7GkSNH8Mgjj1g0Nu2eWbhxAwgMtGgYREZ77rnnoNVqIZVKERERgTVr1qB3794WiaVdu3Y4duwYzp49i27dujWpjVmzZiEgIABLly7F8ePHERsbC09PT3z//fdo27YtVqxYgaSkJKxZswbdunXDM888Y5LYY2Ji0LVrV0RGRsLR0RFff/01oqOjUVlZiZkzZwIA3n33XcyaNQtKpRILFy4EAPj7+9fZZnx8PJ577jmEh4dj5cqVyMrKwvr163H06FGcPHnSIMHU6/UYPnw4+vbti7Vr1yI5ORlvv/02QkJCEBUVZZI+EhlLn90Bt/JVkFW4WzQOm02cSkpKsHXrVqSmpiItLQ0ajQbz58/HyJEja9TV6XSIi4vDvn37oNFoEBISgmnTphmswbh+/TqcnZ0N/gUaHByMK1eu3JX+ELUEcrkc48ePxyOPPAIfHx+kpqZi7dq1iIiIwPfff4+ePXve9ZheffVVjBw5Ej169ECfPn0QERGBhx9+GIMHDzZ6xMvf3x9JSUmQSCSIjo7GxYsXsWbNGjz//PPiCNCMGTPQvn17fPzxxyZLnA4fPiy+NgQAXnzxRYwYMQLr1q0TE6exY8di0aJF4shRfcrLyzFv3jx069YNKSkp4jTegAEDMHr0aLzzzjtYunSpWP/WrVt44okn8MYbbwAAXnjhBdx///2Ii4tj4kR3nebr1/4aRIhpsLrZ2GziVFRUhPj4ePj7+yM0NBQnT56ss+7KlStx6NAhTJw4EUFBQdi9ezfmzp2L9evXo3v37gCA0tLSGq/BcHV1RVFRkVn7QVSld28gM9PSUdwWEAD89FPjr+vXrx/69esnHkdGRmLChAno3r075s+fjz179pgwSuMMHToUx44dw8qVK7F3714cO3YMb731Fnx9ffHRRx8hMjKywTamTp1qsFVA3759cezYMUydOlUsk0ql6N27N37++WeTxV49aSoqKkJ5eTkGDhyIvXv3oqioCB4eHo1q76effkJ2djaWLFlisPZp1KhR6Ny5M7799luDxAm4nSxVFxERgS1btjShN0Qtg80mTiqVCrt27YJKpcL58+cxY8aMWuulpqZi//79iIqKwqRJkwAAw4cPx+TJkxETEyP+a9HZ2RnFxcUG1xYXFxv84CIyp8xM4I5lJi1CaGgoHn30UezcuRN6vd4i7wsLDw/Hzp07odPpcPr0aezatQvvvPMOJkyYgFOnTiEsLKze69u2bWtwXJWwtGnTpkZ5QUGByeI+evQoFi9ejGPHjqGkpMTgXFMSp4yMDABAp06dapzr3Lkzjhw5YlDm5ORUYzG+l5eXSftIZGtsNnGSy+VQqVQN1jt8+DCkUqnBvyoVCgVGjRqF2NhYZGVlwd/fH0FBQSgtLUVOTo74g+LKlSsYPny42fpgLPfx/4SrrAjScg8Ab1g6HDKTgABLR/AXU8fSpk0b6HQ6FBcXw93dcusT5HI5wsPDER4ejnvuuQfPPfcctm/fjsWLF9d7XV3JXm3l1ReH17WhpTGLqy9duoSHH34YnTt3xrp169CmTRvI5XIkJSXhnXfeQWVlZYNtNBdfiktUk80mTsa6cOECgoKCakzDdely+wm1ixcvwt/fHy4uLhgwYAA+/vhj/N///R9+/vlnXLp0CQMGDKiz7dzcXOTl5YnHVf+aMzUHzz8hc8uHXlPScGWyWU2ZGrMVly9fhpOTE5RKpaVDEVUtVv/zzz/Ndg8vLy8At7c6qc6YnxVff/01ysrKkJiYaDDidfDgwRp1jd1xvF27dgBu71c1ZMgQg3Pp6enieSJr5DZmDUIcb/5vcfhrFoujxSdOeXl5tY5MVZXl5uaKZS+//DKWL1+O0aNHw9fXF0uWLKn3X8eJiYncrZeomuojtlVOnz6NxMREjBw50iKbSx48eBCDBg2qkVwkJSUBqH3aylTatWsHqVSKlJQUjB07VizfuHFjg9dWjfZUH8EqKirCJ598UqOuq6trjeSsNr1794afnx8+/PBDTJkyRdy3avfu3UhLS8Obb77ZYBtEliL1uwK5Wz70Gm+LxtHiE6eysrJan5yp2km3rKxMLPP09MSaNWuMbjsyMhL9+/cXjzMyMrBs2bJmREtk25544gk4OzujX79+8PPzQ2pqKmJjY+Hi4oJVq1YZ1D1z5gwSExMB3B75LSoqEr9/7rvvPowZM0asu2XLFmRkZIjrfFJSUsS6Tz/9dL0jJbNmzUJJSQnGjRuHzp07Q6fT4fvvv8e2bdvQvn17PPfccyb9GlTn4eGBiRMnYsOGDZBIJAgJCcE333xTY+PN2gwbNgxyuRxjxozB888/D61Wi02bNsHPz6/GKFmvXr0QExODZcuWITQ0FH5+fjVGlABAJpNh9erVeO655zBw4EBMmjRJ3I6gffv2eOmll0zWd6KWqsUnTgqFAuXl5TXKdTqdeL6pfHx84OPjg+TkZCQnJ0Or1Ta5LaKWYOzYsfjss8+wbt063Lx5E76+vnjsscewePHiGq9c+eWXX8TH3KtUHT/77LMGiVNcXBwOHz4sHh88eFCcshowYEC9idPatWuxfft2JCUlITY2FjqdDm3btkV0dDQWLVpU68aYprRhwwaUl5fjww8/hEKhwOOPPy7u91SfTp064csvv8SiRYvw6quvIiAgAFFRUfD19cWUKVMM6r755pvIyMjAW2+9BY1Gg4EDB9aaOAG3N7asSmTnzZsHV1dXjBs3DqtXrzb714KoJZAI1ceBbVTVU3W17eP08ssvIycnp8bjsz///DNeeuklrFy50mDUqDnS09Mxffp0bNq0yaTD/90WR0P6v+HJs0sbHuIn63Xr1i1cuXIFHTp04KswiO4Cfs+1HNbyu7DFjzhV7fFUXFxssEA8NTVVPN9cHHEiIiKyDy3+XXWDBg2CXq8X11IAt6fpkpKSEBYWVu+rCYylVquxatUqg7esExERUctj0yNOO3bsgFarFbcEOHr0qLjocvz48VAqlQgLC8PgwYMRGxuLwsJCBAYGYs+ePcjMzMS8efMsGT4RERHZGJtOnLZt24bMau+oSElJQUpKCoDbT6RU7RmzYMEC+Pv7Y+/evdBqtQgODsbq1avRo0cPk8TBqToiIiL7YNOJU0JCglH1FAoFoqOjER0dbZY41Go11Gq1uDjc1EpPPIabpWVwd276E4BERETUfDadONmLsrNq5N4AFIGWjoSIiMgybv0yCtqyEigVLhaNg4mTCXCqjoiIyLxunRyFrBuAo4UHEZg4mYC5p+qIiIjIOjBxsgESlwLIPCohcXEA4GXpcIiIiOwWEycb4DFpIbzFFxty53AiIrJDslI4KARAJgHgbLEwmDiZANc4ERERmZfnM69AZQWDCEycTIBrnIiIiOxDi3/lChFRc0gkEixZssTSYTRafHw8JBIJrl69alT96OhoDB061LxBNdGdn8GHH36Itm3boqyszHJBkd1i4kREJnPo0CFIJJJa/xw/ftyg7r59+zB16lR069YNUqkU7du3r7Pd5cuXIzIyEv7+/o1OZKoSiJ9++qmJvTKfkpISLFmyBIcOHbJoHFeuXMFHH32EBQsWALj9js+6Psfqf4z5HD7//HO8++67Jo138uTJ0Ol0+Ne//mXSdomMwak6IjK52bNnIzw83KAsNDTU4Pjzzz/Htm3bcP/996N169b1trdo0SIEBASgZ8+e2Lt3r8njrU9paSkcHc3zo7KkpARLly4FcDtZsZT169ejQ4cOGDx4MABg4cKFmDZtmnj+xx9/xHvvvYcFCxagS5cuYnn37t0bbPvzzz/H2bNn8X//938mi9fJyQnPPvss1q1bh1mzZkEikZisbaKGMHEyAS4OJzIUERGBCRMm1FtnxYoV2LRpE2QyGUaPHo2zZ8/WWffKlSto3749cnNz4evra+pw6+Xk5HRX73e3lZeX47PPPsMLL7wglt05Zefk5IT33nsPQ4cOtWiCV93jjz+Ot956CwcPHsSQIUMsHQ7ZEU7VmYBarcaqVaswa9YsS4dCZDU0Gg0qKirqPN+6dWvIZDKj2qpvGq8pJk+eDKVSiRs3bmDs2LFQKpXw9fXFq6++Cr1eb1C3timpGzduYMqUKfD394dCoUDXrl3x8ccf17jPrVu3sGTJEtxzzz1wcnJCq1at8Nhjj+HSpUu4evWqmAQuXbq01umv8+fPY8KECfD29oaTkxN69+6NxMTEGvc5d+4chgwZAmdnZwQFBWHZsmWorKw06mtx5MgR5ObmQq1WG1W/uo0bN6Jr165QKBRo3bo1Zs6cicLCQvH8oEGD8O233yIjI0PsX9VnqdPp8Oabb6JXr17w8PCAq6srIiIicPDgQaPu3atXL3h7e+M///lPo+Mmag6OOBGRyT333HPQarWQSqWIiIjAmjVr0Lt3b0uHZUCv12P48OHo27cv1q5di+TkZLz99tsICQlBVFRUnddlZWXhgQcegEQiwYsvvghfX1/s3r0bU6dOxc2bN8UpKb1ej9GjR2P//v148sknMWfOHGg0Gvz3v//F2bNnoVarERMTg6ioKIwbNw6PPfYYgL+mv86dO4f+/fsjMDAQr7/+OlxdXZGQkICxY8dix44dGDduHAAgMzMTgwcPRkVFhVgvNjYWzs7G7XPz/fffQyKRoGfPno36+i1ZsgRLly6FWq1GVFQU0tPTERMTgx9//BFHjx6FTCbDwoULUVRUhOvXr+Odd94BACiVSgDAzZs38dFHH2HSpEmYPn06NBoN4uLiMHz4cPzwww/o0aNHgzHcf//9OHr0aKPiJmouJk5EVmTzT99iy0/fNlivi38HvDfuNYOy2bvWIC3rSoPXPt17FJ7pPUo8LtaVYuzHr9R5vjHkcjnGjx+PRx55BD4+PkhNTcXatWsRERGB77//vtG/nM3p1q1beOKJJ/DGG28AAF544QXcf//9iIuLqzdxWrhwIfR6PX799VeoVCrx2kmTJmHJkiV4/vnn4ezsjM2bN2P//v1Yt24dXnrpJfH6119/HYIgQCKRYMKECYiKikL37t3x1FNPGdxnzpw5aNu2LX788UcoFAoAt598GzBgAObNmycmTqtXr0ZOTg5OnDiBPn36AACeffZZdOzY0aivw/nz5+Ht7Q13d3cjv3JATk4OVq5ciWHDhmH37t1wcLg9edG5c2e8+OKL+PTTT/Hcc89h6NChCAwMREFBQY3+eXl54erVq5DL5WLZ9OnT0blzZ2zYsAFxcXENxhEcHIwtW7YYHTeRKXCqzgbc3LkI6WvX4ObORZYOhcysuKwE2dr8Bv8UlNyscW1ByU2jri0uKzG4ThCEes83Rr9+/fDll19iypQpiIyMxOuvv47jx49DIpFg/vz5TW7XXKqv6wFur826fPlynfUFQcCOHTswZswYCIKA3Nxc8c/w4cNRVFSEX375BQCwY8cO+Pj41DqF39Bi5vz8fBw4cACPP/44NBqNeI+8vDwMHz4cFy5cwI0bNwAASUlJeOCBB8SkCQB8fX3x97//3aivQV5eHry8Gvcqp+TkZOh0Ovzf//2fmDQBtxMfd3d3fPttw8m/VCoVk6bKykrk5+ejoqICvXv3Fr+GDfHy8kJpaSlKSpr+/yxRY3HEyQZUFrRGWRZQyU+rxXNVuMBP6d1gPS+XmqMDXi7uRl3rqnAxOJZIJAbX3Xm+uUJDQ/Hoo49i586d0Ov1kEqlJm2/qZycnGosNPfy8kJBQUGd1+Tk5KCwsBCxsbGIjY2ttU52djYA4NKlS+jUqVOTnsi7ePEiBEHAG2+8IY6I1XafwMBAZGRkoG/fvjXOd+rUyej7CYLQqPgyMjJqvYdcLkdwcLB4viH//ve/8fbbb+P8+fMoLy8Xyzt06GDU9VVx86k6+6D5+lXk5lfAx9sRWGq5OPir2AT4VB2ZyjPNmCa7c+rOWK5yZ/z3BfO+vqBNmzbQ6XQoLi5u1JSQOTUlgatacP3UU0/h2WefrbWOMY/oG3ufV199FcOHD6+1zp3bOzSVSqWqN1k0l08//RSTJ0/G2LFj8dprr8HPzw9SqRQrV67EpUuXjGqjoKAALi4uRq/nItumzw5GyQ1AX/czJ3cFEycT4CtXiOp3+fJlODk5iQuDbZWvry/c3Nyg1+sbfAotJCQEJ06cQHl5eZ1PD9Y1UhIcHAwAkMlkDd6nXbt2uHDhQo3y9PT0eq+r0rlzZ3z22WcoKiqCh4eHUde0a9dOvEdVrMDtJ+WuXLliEHNdffzyyy8RHByMnTt3GtRZvHixUTEAt7epqL6vFNHdwDVONkDe6Qi8+xyAvNMRS4dCVK+cnJwaZadPn0ZiYiKGDRtmsB7GFkmlUowfPx47duyodd+p6v0fP348cnNz8f7779eoVzXF5OJye1q0+iP8AODn54dBgwbhX//6F/7888967/PII4/g+PHj+OGHHwzOf/bZZ0b16cEHH4QgCPj555+Nqg/c/seiXC7He++9ZzDNFxcXh6KiIowa9deoqaurK4qKimq0UTXiV/36EydO4NixY0bH8csvv6Bfv35G1ycyBY442QCXAZ/DTXwj9ABLh0NUpyeeeALOzs7o168f/Pz8kJqaitjYWLi4uGDVqlUGdc+cOSPuSXTx4kUUFRVh2bJlAID77rsPY8aMEetu2bIFGRkZ4iLglJQUse7TTz8tjoDcDatWrcLBgwfRt29fTJ8+HWFhYcjPz8cvv/yC5ORk5OfnAwCeeeYZbN68GS+//DJ++OEHREREoLi4GMnJyYiOjsajjz4KZ2dnhIWFYdu2bbjnnnvg7e2Nbt26oVu3bvjggw8wYMAA3HvvvZg+fTqCg4ORlZWFY8eO4fr16zh9+jQAYO7cudiyZQtGjBiBOXPmiNsRtGvXDmfOnGmwPwMGDIBKpUJycrLRG0n6+vpi/vz5WLp0KUaMGIHIyEikp6dj48aNCA8PN3iCrlevXti2bRtefvllhIeHQ6lUYsyYMRg9ejR27tyJcePGYdSoUbhy5Qo+/PBDhIWFGbXs4eeff0Z+fj4effRRo2Im2yfr8DM8VOWQucsA9LJcIAKZzPnz54WIiAjh/PnzJm2365tRQvc1Twhd34wyabt095WWlgqpqalCaWmppUMxi/Xr1wt9+vQRvL29BUdHR6FVq1bCU089JVy4cKFG3U8++UQAUOufZ5991qDuwIED66x78ODBemOqus+PP/4olj377LOCq6trjbqLFy8W7vyxCEBYvHixQVlWVpYwc+ZMoU2bNoJMJhMCAgKEhx9+WIiNjTWoV1JSIixcuFDo0KGDWG/ChAnCpUuXxDrff/+90KtXL0Eul9e416VLl4RnnnlGCAgIEGQymRAYGCiMHj1a+PLLLw3uc+bMGWHgwIGCk5OTEBgYKPzzn/8U4uLiBADClStX6v36CIIgzJ49WwgNDa3z/Pbt22v9Wr///vtC586dBZlMJvj7+wtRUVFCQUGBQR2tViv87W9/Ezw9PQUAQrt27QRBEITKykphxYoVQrt27QSFQiH07NlT+Oabb4Rnn31WrFOlts9g3rx5Qtu2bYXKysp6+9bSv+fsibX8LpQIQiMfp6A6Va1x2rRpU6OeaGlIt8XRkP5vxOnsUvMu4iXzunXrFq5cuYIOHTq0+Fd5tAR6vR6Ojo745z//iUWLWu52IJcvX0bnzp2xe/duPPzww5YOp0FlZWVo3749Xn/9dcyZM6feuvyeazms5XehbS84ICIyo6r1RT4+PhaOxLyCg4MxderUGtOp1uqTTz6BTCarsQ8X0d3ANU5ERLX48ssvsXnzZkgkEgwePNjS4ZhdTEyMpUMw2gsvvMCkiSyGiZMJcB8nopZn7ty5kEgkiIuLM+nUOxHZNiZOJsB9nIhanvpevUJE9otrnIiIiIiMxMSJyAL4MCvR3cHvNTI1TtXZAKHEEzo94FDmaelQqJlkMhkkEgmKi4v5fi2iu6Bq09S6XntD1FhMnGxA0RcrcOMGEBgIYI2lo6HmkEql8PDwQE5ODsrKyuDu7g5HR0e+3Z3IxARBQElJCbKzs+Hp6dmklzqTlSl3gv6WM1Bu2f24mDgR3WUBAQFwdnZGdnY2bt68aelwiFo0T09PBAQEWDoMMoHCzev+GkRYYbk4mDjd4auvvsLXX3+Ny5cv4+mnn8aUKVMsHRK1MBKJBJ6envDw8IBer0dFRYWlQyJqkWQyGUeayOSYON1BpVLhueeeQ3JysqVDoRZOIpHA0dERjo78NiQishX8iX2HiIgIAMDx48ctHMlfXB/ehLaVWjg5KAFwnygiIiJLscrEqaSkBFu3bkVqairS0tKg0Wgwf/58jBw5skZdnU6HuLg47Nu3DxqNBiEhIZg2bRrCw8MtELl5yNqfhNP/XmxIRERkj1wGfIogfTGcpa4AnrJYHFa5j1NRURHi4+ORkZGB0NDQeuuuXLkSCQkJGDp0KGbPng0HBwfMnTsXZ86cuUvREhERkbnJO30P774HIe/0vUXjsMoRJ5VKhV27dkGlUuH8+fOYMWNGrfVSU1Oxf/9+REVFYdKkSQCA4cOHY/LkyYiJiTF4aeXMmTPx66+/1trO008/zVelEBERUYOsMnGSy+VQqVQN1jt8+DCkUikiIyPFMoVCgVGjRiE2NhZZWVnw9/cHAHzwwQdmi5eIiIjsg1UmTsa6cOECgoKC4OrqalDepUsXAMDFixfFxMlYFRUV0Ov1qKyshF6vR1lZGRwdHWt9pDU3Nxd5eXni8cWLFwEAGRkZje1KvaSaUjjodUBJKdLT003aNhERkS24G78L27VrByen+jfYtOnEKS8vr9aRqaqy3NzcRre5efNmxMfHi8dbtmypc2F6YmKiQd0qy5Yta/R96+Mh/i0X03/ilCIREdmfu/G7cNOmTejUqVO9dWw6cSorK6v1/UNyuVw831hTpkwxetPLyMhI9O/fXzzWaDTIyMjAPffcI8ZgChkZGVi2bBkWLVqEdu3amaxda9LS+8j+2b6W3kf2z/a19D7ejf4Z065NJ04KhQLl5eU1ynU6nXjenHx8fODj42NQ1rt3b7Pdr127dg1mwraupfeR/bN9Lb2P7J/ta+l9tHT/rHI7AmOpVCqDNUZVqsruTGqIiIiImsOmE6fQ0FBcv34dxcXFBuWpqanieSIiIiJTsenEadCgQdDr9UhMTBTLdDodkpKSEBYW1ugn6qyVSqXC5MmTjdqiwVa19D6yf7avpfeR/bN9Lb2P1tI/iSAIgkUjqMOOHTug1WqRl5eHr776Cg899BA6duwIABg/fjyUSiUAYPHixUhJScHjjz+OwMBA7NmzB2lpaXjnnXfQo0cPC/aAiIiIWhqrTZwef/xxZGZm1npu27ZtaNWqFYDbT85VvatOq9UiODgY06ZNQ58+fe5muERERGQHrDZxIiIiIrI2Nr3GiYiIiOhuYuJEREREZCSb3gDTGp08eRJz5syp9VxMTAy6du0qHv/666/48MMP8dtvv8HV1RWDBw/G9OnT4eLiYnBdeno6Nm3ahLNnz0IQBHTt2hVRUVHiYvmG5OTk4P3338ePP/6IyspK9OzZE7NmzULr1q1tvn8ff/xxra+9kcvlSE5Oblzn/sfYPv7www84cOAA0tLSkJGRAT8/PyQkJNR6XWVlJbZu3YqvvvoK+fn5CAoKwlNPPQW1Wm1UTBqNBh9++CFSUlJQVlaGLl26IDo6ukmbwFlb/3bv3o2VK1fWem7Xrl2NfoLGHP3bvHkzUlNTkZaWhoKCAkyePNnoNwwAt5/2rVqLqdFoEBISgmnTpiE8PLxRfatibX1szM8FU7ZnbP8yMjKQlJSEH3/8ETdu3ICzszPuueceTJkyBZ07dzYqJlN+htbWP1N/fo1p09g+5ubmIiYmBufPn0dubi6kUimCgoIwbtw4jBgxAhKJpMGYTPUZMnEyk/Hjx4svG64SGBgo/v3ChQt46aWX0K5dO7z44ovIzs7Gtm3bcP36daxZs0asl56ejpkzZ8LPzw+TJ0+GIAjYtWsXZs+ejX/9619o27ZtvXGUlJRgzpw5KC4uxlNPPQVHR0ckJCRg1qxZ+Pjjj+Hh4VHv9dbevyqvvPIKnJ2dxWMHh+YPpjbUx+TkZBw4cAD33HNPg7/cN23ahM8++wxjxoxB586dceTIEfzjH/+ARCLBww8/XO+1lZWVmDdvHi5duoQnn3wSHh4e+OqrrzBnzhxs2rQJbdq0sen+VZk6dar40EeVqqdnm8KU/fvoo4/g7e2Njh074ocffmh0LCtXrsShQ4cwceJEBAUFYffu3Zg7dy7Wr1+P7t27N7q9KtbUR2PiMXV7xvbvm2++wbfffouBAwdi7NixKC4uRmJiIqKiorBmzRqj3vhgjs/QmvpnTDxNYao+FhUVIScnB4MGDYKfnx8qKirw008/YeXKlbh27RpmzJjRYCwm+wwFMqlffvlFiIiIEA4ePFhvvVdffVUYO3asoNVqxbKvv/5aiIiIEE6cOCGWvfbaa8IjjzwiFBYWimU5OTnCsGHDhIULFzYYz2effSZEREQIqampYtnVq1eFQYMGCf/6178a0bPbrK1/cXFxQkREhFBQUNDovtTF2D7m5OQI5eXlgiAIwty5c4WJEyfWWi87O1sYPHiwsG7dOrGssrJSmDlzpvDYY48JFRUV9d5n//79NeIpKCgQRo4cKSxdutS4TlVjbf1LSkoSIiIihLS0tMZ1pA6m7p8gCMIff/whCMLtr3tERIQQFxdndDznzp0TIiIihM8//1wsu3XrlvDkk08KL7zwgtHtVGdtfTQ2HlO3Z2z/zp8/LxQXFxuUFRYWCmPGjBGio6MbjMfUn6G19c/Un19j2mzM/6O1mTdvnjBs2LAGf86Y8jPkGiczKikpQUVFRY3y4uJi/PTTTxg2bBhcXV3F8uHDh8PZ2RkHDx4Uy86cOYPevXsbjAz5+PigR48eOHbsGEpKSuqN4dChQ+jcubNBxt+uXTvcf//9BvdpCmvo3533FUz8kGhdfQRux+no2PCg7ZEjR1BRUYFx48aJZRKJBGPHjkVOTg7OnTtX7/WHDx+Gt7c3HnroIbHM09MTgwcPxpEjR8R3MzaFNfTvznj0er3R9Y1pr7n9A1BjJKwxDh8+DKlUisjISLFMoVBg1KhROHfuHLKysprcNmAdfTQ2HlO3Z2z/OnXqVGOJgIeHB7p3746MjIwGrzfnZ2gN/TM2nqYy1f+jtQkICMCtW7cajNmUnyGn6sxk5cqVKC0thVQqRffu3REVFSXONV++fBl6vb7G+hSZTIaOHTviwoULYll5eTnkcnmN9p2cnFBeXo4rV67UOf9cWVmJy5cv45FHHqlxrkuXLvjxxx9RUlJS4xvOVvpX3RNPPIHS0lI4OztjwIABmDlzJry9vRvdL2P72BgXLlyAs7NzjbduVyWzFy5cqHeY+LfffkPHjh1rTD926dIFX3/9Na5du4aQkJBGx2Ut/asyZ84clJaWQiaTITw8HDNnzmzyNCRguv4114ULFxAUFGTwjwjgr6/PxYsXm/yWA2vpo7niMXf/8vPzjVquYK7P0Fr6Z854TN1mWVkZSktLUVpailOnTmH37t3o2rUrFApFvdeZ8jNk4mRijo6OGDhwIB544AF4eHjg6tWr2LZtG1588UVs3LgR99xzj/gS4trmc1UqFU6fPi0et2nTBqmpqdDr9ZBKpQBuJxtV7+PLycmpM5abN29Cp9PVeR/g9oI7Y9cRWVv/AMDNzQ2PPfYYunbtCplMhjNnzmDXrl1IS0vDpk2banyTmKqPjZGXlwcvL68aixerfwb1yc/Px3333VejvOr6vLy8RiVO1tY/hUKBkSNHomfPnnB1dUV6ejoSEhIQHR2Njz76qNG/kEzdv+bKy8tr8Huwsaytj6aO52707/Tp0zh37hyeeeaZBuua+jO0tv6ZIx5z9XH79u2IjY0Vj3v16oXXX3+9wetM+RkycTKxe++9F/fee694PGDAAAwaNAjPPfccYmNjsXbtWpSVlQG4PQJzJ7lcbjD1Mm7cOLz99ttYvXo1/va3v6GyshKbN28Wk5P6pmkauk/1OrbYPwCYOHGiwfGgQYPQpUsX/POf/8SuXbvw1FNPNap/xvaxMcrKypr1GZSVldU6KmfOz7Axmtu/IUOGYMiQIeJxREQE+vTpg1mzZmHLli149dVXGxWPqfvXXM39+tTG2vpo6njM3b+CggL84x//QKtWrTBp0qQG65v6M7S2/pkjHnP1Ua1Wo3PnzigsLMT333+PgoICo5YrmPIz5BqnuyAoKAgDBgzAyZMnodfrxSHF8vLyGnV1Op3BL8lHH30UTz/9NJKTk/HMM89g8uTJ+OOPP8RvhupPkt2poftUr9MclupfXYYOHQpvb2/8/PPPTexRTXf2sTEUCkWzPgOFQlHrDwZzfoaN0dz+1aZ79+4ICwsz2WfYnP41lzm+PrWxZB/vRjymaq+0tBTz5s1DaWkpVqxYYdRShbvxGVqyf+aMx9RtBgQEoHfv3lCr1XjzzTfRunVrvPTSSw0mPqb8DJk43SV+fn4oLy/HrVu3DKZY7pSXlwcfHx+DsunTp+M///kP3n//fXzyySeIjY0VF0HXtwbE3d0dcrm8zvsAqHGvprJE/xqK5+bNm026tr42q/rYGCqVCvn5+TUWrhv7GXh7e9f7GZrqTeGW6l998ZjyM2xq/5pLpVLdle9BwHJ9rIup42lue+Xl5Vi0aBEuX76MFStWIDg42Kjr7tZnaKn+mSueu9HmwIEDkZ2dbbAEpDam/AyZON0lf/zxB+RyOZydndGhQwdIpVKkp6cb1CkvL8eFCxcQGhpa43o3Nzd0795dXMvy008/wdfXt971SQ4ODggODsb58+drnEtNTUXr1q2b/K+RO1mif3URBAGZmZnw9PRsUl/qUr2PjREaGopbt27VeLqlah1XbV+P6qoW1FdWVhqUp6WlwcnJqVkLqKuzVP/qi8eUn2FT+9dcoaGhuH79OoqLiw3Km/v1qY2l+lgXU8fTnPYqKyuxfPly/PLLL3jjjTfQo0cPo6+9W5+hpfpnjnjuVptVI01arbbeeqb8DJk4mVhhYWGNsosXL+Lo0aMIDw+Hg4MDlEolevfujX379hk8br93716UlpZi8ODB9d5j//79OH/+PCZOnGjwpFVWVlaNX14DBw7E+fPnDZKn33//HSdPnsSgQYNsvn+1xfPVV1+hsLAQffv2bVzn6mnzzj42xoABA+Do6Ihdu3aJZYIg4D//+Q98fX3RrVs3sTw3NxcZGRkGj9YOHDgQ+fn5SElJMYjx4MGD6NevX63rn+pjbf2rLZ5jx44hPT0dffr0aVQsdbXXnP419t4ZGRkG/5oeNGgQ9Ho9EhMTxTKdToekpCSEhYU16Wksa+ujqeMxR//effddHDhwAC+99BIGDhxY773N/RlaW//MEc/d+H8CAL799ltIJBKDxebm/gy5ONzEFi9eDIVCgW7dusHLywtXr17F119/DScnJzz//PNivWnTpmHmzJmYNWsWIiMjxZ21w8PDDX7hnzp1Cv/+978RHh4Od3d3pKamYvfu3ejbty8mTJhgcO/ly5fj1KlTBr9gx40bh2+++Qbz5s3Dk08+CalUioSEBHh5eeHJJ5+0+f5NnDgRQ4YMQXBwMORyOX799Vfs378fHTt2NNivwxx9vHTpEo4cOQIAuHHjBrRaLf79738DuP2vl/79+wO4PTQ9ceJEfPHFF6ioqECXLl3w3Xff4cyZM3jjjTfEpwkBIDY2Fnv27MG2bdvEfXUGDRqEL7/8EitXrsTVq1fFncMrKysb9doPa+1fVFQU7rnnHnTq1Amurq747bffkJSUBD8/Pzz99NMW7x9wO+nPzMwU/3V7+vRpse7w4cMREBAAANi5cyfi4+Oxfv169OzZEwAQFhaGwYMHIzY2FoWFhQgMDMSePXuQmZmJefPmNbp/1thHY+OxVP8SEhLw1VdfoWvXrnBycsK+ffsM7hcRESGOgNyNz9Da+mfqz88cfdy8eTPOnj2LPn36wN/fHzdv3sThw4dx/vx5jB8/HkFBQWKb5v4MmTiZWEREBP773/8iISEBxcXF8PT0xEMPPYTJkycbfLCdOnXCunXr8OGHH2LDhg1wcXHBqFGjavxP6uvrCwcHB3zxxRcoLS1FQEAApk6diieeeMKoTcNcXFywfv16vP/++9i8ebP4rroXX3yxSdMg1ta/oUOH4uzZszh8+DB0Oh38/f0xadIkPPPMM3Bycmp0/xrTx99++w1xcXEG11YdjxgxwuCX0vPPPw83NzckJiZiz549CAoKwqJFizB06NAG45FKpXjrrbewceNG7NixA2VlZejcuTPmz5/fpKlMa+vfkCFDcPz4cfz444/iGrkxY8Zg8uTJTdqLyxz9+/bbb3Hq1Cnx+OTJkzh58iSA2wvZq5KKuixYsAD+/v7Yu3cvtFotgoODsXr16iZPp1hbH42Nx1L9u3jxIgDg3LlztW7Ium3btganjkz5GVpb/0z9+Zmjjw8++CD++OMPJCUlobCwEHK5HCEhIZg/fz5GjBhhVEym+gwlgqm3WiYiIiJqobjGiYiIiMhITJyIiIiIjMTEiYiIiMhITJyIiIiIjMTEiYiIiMhITJyIiIiIjMTEiYiIiMhITJyIiIiIjMTEiYiIiMhIfOUKERGAP//8E0888USN8tDQUHz88ccAbr+GZM6cOeK56u/csxYLFiwQ3/1VXfX3dhFR0zFxIqK74s6koy4jRozAggUL7kJE1umpp57C77//DgBo164dtmzZUmu90tJSjB07FqWlpQBuvxts+fLldy1OInvFxImIqBZPP/00lEolvLy87up9R4wYgdjYWABARkYG0tPT0alTpxr1vvvuOzFpqroOAEaOHIl7770XABATE3MXIiayL0yciMgihgwZUmtCEBwcbIFoaho9erRFpuGGDx+Ojz76CJWVlQCAPXv21Pp12rNnj/h3T09PPPjggwBujzxVYeJEZHpMnIjIIvr27YuRI0fWW+fOdUfvvPMOLl++jK+++gpZWVkIDAzE3//+dwwbNgylpaWIi4vDgQMHcPPmTbRr1w6TJ082SCTMKSEhAe+//754PHnyZEyZMgUAUFxcjF27duG7777D77//jrKyMnh7e+P+++/HpEmT0KFDB/E6X19fhIeH48SJEwCAAwcOYObMmXB0/OvHdW5uLn755RfxeNiwYQbnich8+J1GRDbjww8/RHp6unh85coVLFu2DCUlJdi9ezfS0tLEcxcuXMCiRYuwbt069OrVy6xx7dq1yyBpev755/H3v/8dAHDt2jW88soryMzMNLgmOzsbe/bswYEDB7Bw4UIMHjxYPDdixAgxcSooKMCPP/4ojigBwH//+19xRApAgwkoEZkOEycisogTJ06gsLCwRvmQIUPg7+9f6zXp6eno27cvOnfujG+++QZ5eXkAgHXr1gEA+vfvjw4dOmDHjh0oLS2FIAj44osvzJo4ffPNN3j33XfF49mzZ2PChAkAAL1ej0WLFolJk6enJ9RqNdzd3fHDDz/g7Nmz0Ol0WL58OTp16oTWrVsDuD3dplQqodVqAdyelqueOO3bt0/8e8eOHRESEmK2/hGRISZORGQRBw4cwIEDB2qUd+7cuc7EKTw8HG+99RYkEgl8fX2xdu1a8dyDDz6IlStXAgAEQcBnn30GADh//rwZor9t7969iI+PhyAIkEgkeOWVVxAZGSmeP3bsGK5cuQIAkEql+OCDD9CmTRsAtxefT506FZcvX4ZOp8POnTvx4osvAgDkcjnUajW++uorAMDRo0eh1WqhVCpx8eJFXLp0SbwHR5uI7i4mTkRkM9RqNSQSCQAgICDA4Fz1qa7AwEDx7xqNxmzxVO3v5ODggHnz5tVIYn799Vfx73q9Xpy+q83Zs2cNjkeMGCEmTjqdDocOHcLo0aOxd+9esY5MJsPQoUOb2w0iagQmTkRkEfPnz2/0aImPj4/4d5lMVuc5qVQq/l0QhCZGaDxHR8daR8kak7TdOW0ZFhaG9u3b4+rVqwBuj26NHDkSycnJYp0HH3wQHh4eTYqZiJqGiRMR2Yz6nhyrnizdLW3btsXvv/8OnU6H+fPn45133kFYWJh43s3NTfy7XC7H1KlT62xLqVTWKBsxYgQ+/PBDAMCZM2cM1nUBnKYjsgQmTkRETbR48WIsX74cly9fRmlpKV577TW899574mLtbt26iXV1Oh06dOiABx54oEY7qampNUbQgNvbDGzatAl6vR6CIOCDDz4Qz3l7e6Nv375m6BUR1YeJExFZRF1P1SmVSowZM+buB9QESqUSa9euRVRUFLKysqDRaPDKK69gw4YNaNOmDR588EG0a9cOGRkZAICFCxfioYceQvv27VFZWYk//vgDp0+fRmZmJubPn4+OHTsatO/j44Pw8HAcP34cAHDr1i3x3NChQ7l3E5EF8LuOiCyirqfqAgICbCZxAm4nN2vXrsWLL76IoqIi5Ofn46WXXsIHH3wAf39/rFixQtzHqby8HPv3729U+yNHjhQTpzvLiejuc7B0AEREtq5du3ZYvXo1nJ2dAdze3PKll15CXl4e2rRpg/j4eERFRaFbt25wc3ODVCqFi4sLQkJCMHr0aCxfvhxqtbrWtvv37w93d3eDsk6dOlnNq2mI7I1EuBuPnBARWbk7X+9S/SW/VS/QtQXfffcdrl+/DsDwXXXr169Hz549LRUWUYvBqToiolps2bIFABAaGmpTidPu3btx5MgRS4dB1GJxqo6IiIjISJyqIyIiIjISR5yIiIiIjMTEiYiIiMhITJyIiIiIjMTEiYiIiMhITJyIiIiIjMTEiYiIiMhITJyIiIiIjMTEiYiIiMhITJyIiIiIjPT/AUWXi1je9a4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots() \n", "\n", @@ -611,9 +948,9 @@ ], "metadata": { "kernelspec": { - "display_name": "cosipy", + "display_name": "cosipy-312", "language": "python", - "name": "cosipy" + "name": "cosipy-312" }, "language_info": { "codemirror_mode": { @@ -625,7 +962,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.19" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/docs/tutorials/spectral_fits/extended_source_fit/diffuse_511_spectral_fit.ipynb b/docs/tutorials/spectral_fits/extended_source_fit/diffuse_511_spectral_fit.ipynb index ae29923b..21b5fbf7 100644 --- a/docs/tutorials/spectral_fits/extended_source_fit/diffuse_511_spectral_fit.ipynb +++ b/docs/tutorials/spectral_fits/extended_source_fit/diffuse_511_spectral_fit.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "d3dc3a08", "metadata": {}, "source": [ "# Diffuse 511 Spectral Fit in Galactic Coordinates\n", @@ -38,43 +39,288 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, + "id": "af0ff1b1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
14:25:55 WARNING   The naima package is not available. Models that depend on it will not be         functions.py:43\n",
+       "                  available                                                                                        \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m14:25:55\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The naima package is not available. Models that depend on it will not be \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=964471;file:///project/cassini/miniconda3/envs/cosipy-312/lib/python3.12/site-packages/astromodels/functions/functions_1D/functions.py\u001b\\\u001b[2mfunctions.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=259826;file:///project/cassini/miniconda3/envs/cosipy-312/lib/python3.12/site-packages/astromodels/functions/functions_1D/functions.py#43\u001b\\\u001b[2m43\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mavailable \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   The GSL library or the pygsl wrapper cannot be loaded. Models that depend on it  functions.py:65\n",
+       "                  will not be available.                                                                           \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The GSL library or the pygsl wrapper cannot be loaded. Models that depend on it \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=737004;file:///project/cassini/miniconda3/envs/cosipy-312/lib/python3.12/site-packages/astromodels/functions/functions_1D/functions.py\u001b\\\u001b[2mfunctions.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=998414;file:///project/cassini/miniconda3/envs/cosipy-312/lib/python3.12/site-packages/astromodels/functions/functions_1D/functions.py#65\u001b\\\u001b[2m65\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mwill not be available. \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
14:25:56 WARNING   The ebltable package is not available. Models that depend on it will not be     absorption.py:33\n",
+       "                  available                                                                                        \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m14:25:56\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The ebltable package is not available. Models that depend on it will not be \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=243935;file:///project/cassini/miniconda3/envs/cosipy-312/lib/python3.12/site-packages/astromodels/functions/functions_1D/absorption.py\u001b\\\u001b[2mabsorption.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=672858;file:///project/cassini/miniconda3/envs/cosipy-312/lib/python3.12/site-packages/astromodels/functions/functions_1D/absorption.py#33\u001b\\\u001b[2m33\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mavailable \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
14:25:56 INFO      Starting 3ML!                                                                     __init__.py:44\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m14:25:56\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;49mINFO \u001b[0m \u001b[1;38;5;251m Starting 3ML! \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=541220;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=664953;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#44\u001b\\\u001b[2m44\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   WARNINGs here are NOT errors                                                      __init__.py:45\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m WARNINGs here are \u001b[0m\u001b[1;31mNOT\u001b[0m\u001b[1;38;5;251m errors \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=808576;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=748320;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#45\u001b\\\u001b[2m45\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   but are inform you about optional packages that can be installed                  __init__.py:46\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m but are inform you about optional packages that can be installed \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=404631;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=422735;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#46\u001b\\\u001b[2m46\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING    to disable these messages, turn off start_warning in your config file            __init__.py:47\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m \u001b[0m\u001b[1;31m to disable these messages, turn off start_warning in your config file\u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=162053;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=580091;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#47\u001b\\\u001b[2m47\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   no display variable set. using backend for graphics without display (agg)         __init__.py:53\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m no display variable set. using backend for graphics without display \u001b[0m\u001b[1;38;5;251m(\u001b[0m\u001b[1;38;5;251magg\u001b[0m\u001b[1;38;5;251m)\u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=784430;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=701135;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#53\u001b\\\u001b[2m53\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   ROOT minimizer not available                                                minimization.py:1208\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m ROOT minimizer not available \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=987075;file:///project/cassini/cosi/threeML_git/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=601627;file:///project/cassini/cosi/threeML_git/threeML/minimizer/minimization.py#1208\u001b\\\u001b[2m1208\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Multinest minimizer not available                                           minimization.py:1218\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Multinest minimizer not available \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=898579;file:///project/cassini/cosi/threeML_git/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=739421;file:///project/cassini/cosi/threeML_git/threeML/minimizer/minimization.py#1218\u001b\\\u001b[2m1218\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   PyGMO is not available                                                      minimization.py:1228\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m PyGMO is not available \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=909722;file:///project/cassini/cosi/threeML_git/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=80253;file:///project/cassini/cosi/threeML_git/threeML/minimizer/minimization.py#1228\u001b\\\u001b[2m1228\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
14:25:57 WARNING   The cthreeML package is not installed. You will not be able to use plugins which  __init__.py:95\n",
+       "                  require the C/C++ interface (currently HAWC)                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m14:25:57\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The cthreeML package is not installed. You will not be able to use plugins which \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=712;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=559491;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#95\u001b\\\u001b[2m95\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mrequire the C/C++ interface \u001b[0m\u001b[1;38;5;251m(\u001b[0m\u001b[1;38;5;251mcurrently HAWC\u001b[0m\u001b[1;38;5;251m)\u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Could not import plugin FermiLATLike.py. Do you have the relative instrument     __init__.py:136\n",
+       "                  software installed and configured?                                                               \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Could not import plugin FermiLATLike.py. Do you have the relative instrument \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=890007;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=219605;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#136\u001b\\\u001b[2m136\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251msoftware installed and configured? \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Could not import plugin HAWCLike.py. Do you have the relative instrument         __init__.py:136\n",
+       "                  software installed and configured?                                                               \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Could not import plugin HAWCLike.py. Do you have the relative instrument \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=879300;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=640253;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#136\u001b\\\u001b[2m136\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251msoftware installed and configured? \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   No fermitools installed                                              lat_transient_builder.py:44\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m No fermitools installed \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=368308;file:///project/cassini/cosi/threeML_git/threeML/utils/data_builders/fermi/lat_transient_builder.py\u001b\\\u001b[2mlat_transient_builder.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=269027;file:///project/cassini/cosi/threeML_git/threeML/utils/data_builders/fermi/lat_transient_builder.py#44\u001b\\\u001b[2m44\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Env. variable OMP_NUM_THREADS is not set. Please set it to 1 for optimal         __init__.py:345\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Env. variable OMP_NUM_THREADS is not set. Please set it to \u001b[0m\u001b[1;37m1\u001b[0m\u001b[1;38;5;251m for optimal \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=207854;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=777029;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#345\u001b\\\u001b[2m345\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mperformances in 3ML \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Env. variable MKL_NUM_THREADS is not set. Please set it to 1 for optimal         __init__.py:345\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Env. variable MKL_NUM_THREADS is not set. Please set it to \u001b[0m\u001b[1;37m1\u001b[0m\u001b[1;38;5;251m for optimal \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=657672;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=805287;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#345\u001b\\\u001b[2m345\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mperformances in 3ML \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Env. variable NUMEXPR_NUM_THREADS is not set. Please set it to 1 for optimal     __init__.py:345\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Env. variable NUMEXPR_NUM_THREADS is not set. Please set it to \u001b[0m\u001b[1;37m1\u001b[0m\u001b[1;38;5;251m for optimal \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=253092;file:///project/cassini/cosi/threeML_git/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=173544;file:///project/cassini/cosi/threeML_git/threeML/__init__.py#345\u001b\\\u001b[2m345\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mperformances in 3ML \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# imports:\n", - "from cosipy import COSILike, test_data, BinnedData\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord\n", + "\n", + "from mhealpy import HealpixMap\n", + "\n", + "from astromodels import Model, Parameter, PointSource, ExtendedSource, Gaussian, Gaussian_on_sphere, Asymm_Gaussian_on_sphere\n", + "from threeML import JointLikelihood, DataList, update_logging_level\n", + "\n", + "from cosipy import COSILike, BinnedData\n", "from cosipy.spacecraftfile import SpacecraftFile\n", "from cosipy.response.FullDetectorResponse import FullDetectorResponse\n", "from cosipy.response import PointSourceResponse\n", - "from cosipy.threeml.custom_functions import Wide_Asymm_Gaussian_on_sphere, SpecFromDat\n", + "from cosipy.threeml.custom_functions import SpecFromDat\n", "from cosipy.util import fetch_wasabi_file\n", - "from scoords import SpacecraftFrame\n", - "from astropy.time import Time\n", - "import astropy.units as u\n", - "from astropy.coordinates import SkyCoord\n", - "from astromodels import *\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "from threeML import PointSource, Model, JointLikelihood, DataList, update_logging_level\n", - "from astromodels import Parameter\n", - "from astromodels import *\n", - "from mhealpy import HealpixMap, HealpixBase\n", - "import healpy as hp\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt \n", - "from pathlib import Path\n", - "import os\n", - "import time\n", - "import h5py as h5\n", - "from histpy import Axis, Axes\n", - "import sys\n", - "from histpy import Histogram" + "\n", + "%matplotlib inline" ] }, { "cell_type": "markdown", + "id": "e6114d2b", "metadata": {}, "source": [ "## Get the data\n", @@ -83,9 +329,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 2, + "id": "afbf58d3", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A file named 20280301_3_month_with_orbital_info.ori already exists with the specified checksum (416fcc296fc37a056a069378a2d30cb2). Skipping.\n" + ] + } + ], "source": [ "# ori file:\n", "# wasabi path: COSI-SMEX/DC2/Data/Orientation/20280301_3_month_with_orbital_info.ori\n", @@ -95,9 +352,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 3, + "id": "59af8882", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A file named cosmic_photons_3months_unbinned_data.fits.gz already exists with the specified checksum (faa82255b43d42a2b9c90621fabcb7d6). Skipping.\n" + ] + } + ], "source": [ "# cosmic photons:\n", "# wasabi path: COSI-SMEX/DC2/Data/Backgrounds/cosmic_photons_3months_unbinned_data.fits.gz\n", @@ -107,9 +375,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "id": "f45eab34", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A file named 511_Testing_3months_unbinned_data.fits.gz already exists with the specified checksum (34ac3ae76359969e21058d712c8b6684). Skipping.\n" + ] + } + ], "source": [ "# 511 test model:\n", "# wasabi path: COSI-SMEX/DC2/Data/Sources/511_Testing_3months_unbinned_data.fits.gz\n", @@ -119,9 +398,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, + "id": "14e3a3aa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A file named SMEXv12.511keV.HEALPixO4.binnedimaging.imagingresponse.h5 already exists with the specified checksum (1fddb86ff5818e16e8c7900c61f17db9). Skipping.\n" + ] + } + ], "source": [ "# detector response:\n", "# wasabi path: COSI-SMEX/develop/Data/Responses/SMEXv12.511keV.HEALPixO4.binnedimaging.imagingresponse.h5\n", @@ -131,9 +419,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "id": "aeb24c91", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A file named psr_gal_511_DC2.h5 already exists with the specified checksum (50eb36c2bc0089ba230af457ec768fa0). Skipping.\n" + ] + } + ], "source": [ "# point source response:\n", "# wasabi path: COSI-SMEX/develop/Data/Responses/PointSourceResponse/psr_gal_511_DC2.h5\n", @@ -143,11 +440,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, + "id": "3581bc1a", "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A file named cosmic_photons_binned_data.hdf5 already exists with the specified checksum (8b46c07ccf386668ec6402de8f87ec93). Skipping.\n", + "A file named gal_511_binned_data.hdf5 already exists with the specified checksum (6a05d682b46a9f78a197c9a9c16ac965). Skipping.\n", + "A file named combined_binned_data.hdf5 already exists with the specified checksum (9b005571860d36905bd5aee975036236). Skipping.\n", + "A file named combined_binned_data_thin_disk.hdf5 already exists with the specified checksum (3690422b417e73014de546642799d6e3). Skipping.\n" + ] + } + ], "source": [ "# Binned data products:\n", "# Note: This is not needed if you plan to bin the data on your own. \n", @@ -162,6 +471,7 @@ }, { "cell_type": "markdown", + "id": "327cee87", "metadata": {}, "source": [ "## Create the combined data\n", @@ -172,29 +482,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, + "id": "ed644f4b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "adding cosmic_photons_3months_unbinned_data.fits.gz...\n", - "\n", - "\n", - "adding 511_Testing_3months_unbinned_data.fits.gz...\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: VerifyWarning: Keyword name 'data file' is greater than 8 characters or contains characters not allowed by the FITS standard; a HIERARCH card will be created. [astropy.io.fits.card]\n" - ] - } - ], + "outputs": [], "source": [ "# # Define instance of binned data class:\n", "# instance = BinnedData(\"Gal_511.yaml\")\n", @@ -206,6 +497,7 @@ }, { "cell_type": "markdown", + "id": "c4493ec0", "metadata": { "tags": [] }, @@ -217,21 +509,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, + "id": "a87fdde1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "binning data...\n", - "Time unit: s\n", - "Em unit: keV\n", - "Phi unit: deg\n", - "PsiChi unit: None\n" - ] - } - ], + "outputs": [], "source": [ "# # Bin 511:\n", "# gal_511 = BinnedData(\"Gal_511.yaml\")\n", @@ -240,21 +521,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, + "id": "cf2fb152", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "binning data...\n", - "Time unit: s\n", - "Em unit: keV\n", - "Phi unit: deg\n", - "PsiChi unit: None\n" - ] - } - ], + "outputs": [], "source": [ "# # Bin background:\n", "# bg_tot = BinnedData(\"Gal_511.yaml\")\n", @@ -263,21 +533,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, + "id": "115ed66f", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "binning data...\n", - "Time unit: s\n", - "Em unit: keV\n", - "Phi unit: deg\n", - "PsiChi unit: None\n" - ] - } - ], + "outputs": [], "source": [ "# # Bin combined data:\n", "# data_combined = BinnedData(\"Gal_511.yaml\")\n", @@ -286,6 +545,7 @@ }, { "cell_type": "markdown", + "id": "3a35bc8e", "metadata": {}, "source": [ "## Read in the binned data\n", @@ -294,7 +554,8 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, + "id": "4c13f074", "metadata": {}, "outputs": [], "source": [ @@ -313,6 +574,7 @@ }, { "cell_type": "markdown", + "id": "72570ad5", "metadata": { "tags": [] }, @@ -326,7 +588,8 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, + "id": "e40a5d33", "metadata": { "tags": [] }, @@ -419,7 +682,7 @@ "\n", "
  • desc: Integral between -inf and +inf. Fix this to 1 to obtain a Normal distribution
  • \n", "\n", - "
  • min_value: None
  • \n", + "
  • min_value: 0.0
  • \n", "\n", "
  • max_value: None
  • \n", "\n", @@ -517,7 +780,7 @@ " * F:\n", " * value: 0.04\n", " * desc: Integral between -inf and +inf. Fix this to 1 to obtain a Normal distribution\n", - " * min_value: null\n", + " * min_value: 0.0\n", " * max_value: null\n", " * unit: s-1 cm-2\n", " * is_normalization: false\n", @@ -545,12 +808,14 @@ "source": [ "# Define spectrum:\n", "# Note that the units of the Gaussian function below are [F/sigma]=[ph/cm2/s/keV]\n", - "F = 4e-2 / u.cm / u.cm / u.s \n", + "F = 4e-2 / u.cm / u.cm / u.s\n", + "Fmin = 0 / u.cm / u.cm / u.s\n", "mu = 511*u.keV\n", "sigma = 0.85*u.keV\n", "spectrum = Gaussian()\n", "spectrum.F.value = F.value\n", "spectrum.F.unit = F.unit\n", + "spectrum.F.min_value = Fmin.value\n", "spectrum.mu.value = mu.value\n", "spectrum.mu.unit = mu.unit\n", "spectrum.sigma.value = sigma.value\n", @@ -583,6 +848,7 @@ }, { "cell_type": "markdown", + "id": "e4867b10", "metadata": {}, "source": [ "Let's make some plots to look at the extended source:" @@ -590,22 +856,13 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Energy [keV]')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, + "execution_count": 14, + "id": "a5d3d39c", + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
    " ] @@ -619,12 +876,13 @@ "energy = np.linspace(500.,520.,201)*u.keV\n", "dnde = src1.spectrum.main.Gaussian(energy)\n", "plt.plot(energy, dnde)\n", - "plt.ylabel(\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", - "plt.xlabel(\"Energy [keV]\", fontsize=14)" + "plt.ylabel(r\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", + "plt.xlabel(\"Energy [keV]\", fontsize=14);" ] }, { "cell_type": "markdown", + "id": "4c0f468a", "metadata": {}, "source": [ "An extended source in astromodels corresponds to a skymap, which is normalized so that the sum over the entire sky, multiplied by the pixel area, equals 1. The pixel values in the skymap serve as weights, which we can use to scale the input spectrum, in order to get the model counts for any location on the sky. This is all handled internally within cosipy, but for demonstration purposes, let's take a look at the skymap:" @@ -632,14 +890,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, + "id": "f7e3e3b5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "summed map: 0.9974653836229359\n" + "summed map: 0.9974653836229357\n" ] } ], @@ -653,17 +912,18 @@ "skymap[:] = src1.Gaussian_on_sphere(coords1.l.deg, coords1.b.deg) \n", "\n", "# Check normalization:\n", - "print(\"summed map: \" + str(np.sum(skymap)*pix_area))" + "print(f\"summed map: {np.sum(skymap)*pix_area}\")" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, + "id": "fdac4f0b", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApUAAAGaCAYAAABe77jvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAABcSAAAXEgFnn9JSAACaVUlEQVR4nOzdd1gU99rG8e/MdjoIgoqKvfdYYo1Ro1ET03uPacb0fpKcmN5Oct70nPRumumWmNiS2HtHUVFRQJBet828f6ysomChDbDP57q4hN3ZmQeE3Xt/VdF1XUcIIYQQQohqUI0uQAghhBBCNHwSKoUQQgghRLVJqBRCCCGEENUmoVIIIYQQQlSbhEohhBBCCFFtEiqFEEIIIUS1SagUQgghhBDVJqFSCCGEEEJUm4RKIYQQQghRbRIqhRBCCCFEtUmoFEIIIYQQ1SahUgghhBBCVJvZ6AKEEKKu6bqOy+WipKSEkpISXC5XuQ+n01nhbW63G6/X6//QNK3cv0ffBqAoCoqioKqq/+uyz1VVRVEUAEwmE1arFbPZjMViwWw2l/u67KPsdrvdjt1ux+FwlPvcbJandSGEMeTZRwjR4Hg8HgoKCsjPzyc/P/+YzwsLCykpKaG4uJiioiKKi4spLi4ud5vX6zX626gVZrO5XNh0OBwEBwcTEhJCaGgoISEhFX6U3RcWFobD4TD62xBCNECKruu60UUIIQKb2+0mJyeHnJwcsrOzy/1b9nFkeCwuLq6xa5vNZt+HyYzJZDr0r+82i9mMxXqoldBmwWq1go7vAwVd00EDXePw7Yc+FBR0HYrzigmOCiJ7fx6KAoqqoJoUVJOKYlYwW0yYLCZMFt/XiglQwOV04SxxUlriwlXqwuV04Sp143a5cbvdaLoXXdUJjnJQWlpaoyHZZrMRERFBeHg4ERERx3yU3R4VFUWTJk2w2+01dm0hRMMloVIIUWs0TSMnJ4fMzEwyMzPJyMjwf37w4EF/cMzPzz/lcyuKgs1qw2a1YTVbsahWTIoZE2YUrwoeBc2to5XqaE4NT7GOt9SLt1QjKDiIqLhIYhNiiGsXQ3TrKKJahKNpOtn7cslJzSN7fx75GQUUHCyk4GARBQeLKMwuwuvRTqlO1aTy74V38tQZr6N5T+6xqkklJCqI0OhgQqNDCG0STFjTECKbRxAVH05U8wjMVhM5afkc3JNN+o5M0ndlkrEnk5wDeWiKBqoOJh3dpINJA7OObtbBrPluM2v+rzHpRLQIo6CgAI/Hc8r/FyEhIURHRxMdHU2TJk3KfX7k1xaL5ZTPLYRoOCRUCiGqrLS0lPT0dNLS0khNTSU9Pd0fGsuC48mGFEVRCLIHYbfasZhsWLCges0obhWtBLzFGq4CL65cN848N5rT1xp4IhFxYcR3iyO+azNadIkltl00HreXjF1ZHNh1kAM7D5K5O4vslFyKckuq+yM5RlVC5clwhNlpEh9BTEIUTdtFE9s2mth20VgdFjKSs9i/JZ19W9PZtzmd7H25J3VOHV8QxayhW3R0iwYWrcJ/dYuOLdyM0+k8qXMrikJUVBRxcXHExsYSGxtLXFyc/+u4uDiCgoKq8RMRQhhNQqUQolJer5eMjAxSU1NJS0s75iM7O/uE5ygLiw5bEDbVjslrQXGpaEXgyvPizHZTmu066ZB4PKpJoVnHpiT0aUnL7s2I7xaH2WJm39Z09m9JY9+WdNKTMik4WFSt65xaTbUTKisTHBlEXIcYWnSJJb5bM+K7xAH4AuamNJLXprB/y4EaqaUshOpWDaxedKvm+9x2+PO4TtFkZWXhcrlOeL7Q0FB/0IyPjyc+Pp4WLVrQokULYmJi/BOchBD1k4RKIQKcruvk5uaSkpJCSkoKe/fuZd++faSkpLB//37cbvdxH2+1WglxhGI3OTB7rVCq4snTKM1yU5zhQivWUfTqhcXjiW0XTZu+LWnTN57WveMpzith99p97N2Qyr7NaWSl5GDks1xdh8qKRLUIJ75bM1r2aE6bPvGExYSwZ0MqyWtSSF6dQnpSRq3+jHR0X/e73Ytu831g96LbNHSbl5BmDgoKCo57DqvVSvPmzf0hsyxwtmzZkqZNm0rgFKIekFApRIDwer2kpqaSnJxMcnKyP0SmpKRQWFhY6eNMJhMhQaE4zEGYvRb0IhV3rpfSA25KD3rAo1S7hfFUmK0m2vRrSafBbek4uA2KSSV59V6SV6eQvGYfuemnPj6zNtWHUHm00OjgQ0G8JW1Pa4nJbGL70mS2L0lm16q9uEqO/0aiNugmzR8ysXt9AdThoUWvWNLS0o47jMLhcNCqVStat25NQkKC/99mzZrJEktC1CEJlUI0MpqmceDAAX94LPvYs2dPpV2QiqIQ7Agh2BKM2WuDIhXXQY3iVCfuPK1OQ2NFHKE2Og9vT+dh7WjTtyWZu7PYvsQXgmq7la266mOoPFrTtk3oOLgtnQa3Ia5jU/as38+2v3eyZdEOinJqbqZ9VenoYNPQHZ5DYdOLbvcQ3yeO1NTUSgOnxWIhPj7eHzTbtm1Lu3btaNGihbRsClELJFQK0YCVlJSwY8cOkpKSSEpKYteuXezevZuSkoonnJjNZsKDI3AoQSglZtzZGkX7SnFmaSiascHxaLYgK52GtaX7qE606RPP7rX72Pr3TpKWJFOQVXdjIqurIYTKIwVFOOgwMIEuI9rT9rRWpGxKZfP87WxdtIOSgpOblFOXdOVQt3qQxxc2gzzoQR6sTUyVTiKy2+3+gNm+fXvat29P27ZtCQ4OruPqhWhcJFQK0UDk5eX5w+P27dtJSkoiJSWFiv6EVVUlPDgCuxKEUmTClalRlOLEW1D9yTC1STWpdBzchp5ndab9wAT2bUlj07xDgSa/1OjyqqShhcoj2YKtdB7Wju5ndiShTzzJa1LYMHcbiX/vwOOq34vHl7VuaodCZtmHpYlaaYt9s2bN/CGzU6dOdOrUiSZNmtRx5UI0XBIqhaiHCgoKSExMZMuWLWzbto3t27eTkZFR4bFBjmBCbeFYnTbcB3UK9zpxZXtrdXJMTYtuFUmfid3oNbYLBQeLWDtrM1sWJFGYbXzXa3U15FB5pKBwO12Gt6fX2V2JbhXJxj8SWfPbZg7sPGh0aadER/e1aAZ70IPd6MEemnQKJzMzs8LjY2Ji6Ny5M506dfL/Gx4eXsdVC9EwSKgUwmBut5udO3eyZcsWtm7dytatW9m7d2+Fx4YFhxFsCoVCM6X73BTvc4HLVMcV1wyz1UT3UZ3oe053YhKi2Dg3kTUzN5OeVPGLe0PVWELlkWISougzvhu9xnUh70ABa37bxIa5iYZM8KkpullDD/agHQqarQbGsWfPngp7Apo1a0bnzp3p3LkzXbp0oXPnzrKrkBBIqBSizmVkZLBx40Y2b97M1q1bSUpKqrA7Liw4jBBzOEqBmeIUN0V7nb6dYhq4sJgQTjuvJ/3O7c7BPTms+mkDW/+q/92pVdUYQ2UZk9k3XOG0ST1p3iWWtTM3s/KH9eSk1a8Z+FWlqxp6iActxI0e4qFZnybs37//mONMJhMdOnSge/fudO/enR49ehATE2NAxUIYS0KlELVI13X27NnDhg0b/B/p6enHHGez2gi3RaIWWSnd76F4jxvF0/AD5JHiuzVj0MW96XB6G7YsSGL5jHWNrlWyIo05VB4punUkAy/sTc+zOpO8Zh/Lv19L8pp9RpdV43SThh7iRgv1oIe4iewUQlZW1jHHxcbG+kNm9+7dadeunSxvJBo9CZVC1CC328327dv9AXLTpk3k5eWVO0ZRFCJDonBoIXgydPJ3lNb7CTTV0W5Aa4Zd3Z8m8RGs+GE9q3/dRHEtbIdYXwVKqCxjD7HRZ0JXBl7Yh6KcYv7+YiXb/tlZr5d9qg7/hKBQF1qYm/ZntGTHjh1oWvn/a4fDQY8ePejduzd9+vShU6dOEjJFoyOhUohq8Hq9JCUlsWbNGlavXs3GjRspLS0/S9lsMhPhiMRcbKdkr4eSFE+j6MY+HkWBzsPbM+zq/jhC7fzz5SrWz9nSaLu4jyfQQmUZ1aTSfXRHhl3VH12Hf75YyaZ529C8jf8lR1c19FAPWpgLPdRNUCvrMRsMSMgUjZGESiFOQVl39urVq1mzZg3r1q07Zns5m9VOhD0SJddCwQ4n7sza3aawPlEU6DqyI2dcPwhd0/j7i5Vsnr89IIJEZQI1VJZRFOg8rB3Drh6AI8zOX58uZ/3vWwPqd0JH9y1pFO5GC3cR2s5+TA/GkSGzf//+dOjQQRZoFw2OhEohTuDgwYOsWLHCHySPHj9ltViJsEeh5lgp2O7Ena032q7s4+kwKIEzbxqMyWJiwQdLSPy78XZ5nopAD5VHaj+gNWfeNBirw8L8D5aydVFSQP6OHB0yQ9rayM8vP7kpPDyc/v37+z+io6MNqlaIkyehUoijeDweNm3axLJly1i+fDk7d+4sd7/JZCbSEYWaZ6VwuxNPVt3ufV3ftOrZnFE3DyEsJoQFHy1l4x/b0DV5WikjofJYXUa058zJg3E73cx/bwk7VuwxuiRDlYVMLdyNHuHCFq8esytWmzZt6N+/PwMGDKBXr17YbDaDqhWichIqhcC3zM+KFStYtmwZq1evpqjo8DaAZRNrbKXBFO1wUbpPC5ju7OOJbB7OWbcPI75bM/76ZDlrftuE1yOh6WgSKiummhR6ntWFM24YRFZKDr+/8RcZycfOog5EuqKjh7rRIlx0HNuKxMTEcutlWq1WevbsyeDBgxk8eDDNmzc3sFohDpNQKQKS1+tly5Yt/PPPPyxbtozk5ORy99utdsJMUXj2QWFS41vepzpsQVaGXTOA0yb1YMUP6/nni5UNetHr2iah8vjMVhOnX9qXIZefxoa5W1nw0bIGuyVnbdHNGlqECy3CSZMeocfs/pOQkMDgwYMZMmQIXbt2xWRqmBsiiIZPQqUIGE6nk1WrVvHPP/+wZMkScnJy/PcpikJkcBTmfAcFiU682YHdpV0RRYHe47sx6qbB7Nmwnz/e+YfcRrLIdW2SUHlyQpsEM+qWIXQ8vQ2LPlnOyp82yM+rAmXbTGqRTnpe2IENGzbg9R5eVSE8PJxBgwYxePBg+vfvT0hIiIHVikAjoVI0anl5eSxZsoR//vmHlStXllvux2qxEmmJxr1foXCbS1ojjyO2XTTnPDAKs9XM7NcXsmfdsbuKiIpJqDw1zTvHcvadI7A4LPz68jz2bzl2swBxmG7S0CJdaFFOgttZyq1GYTKZ6NOnDyNGjGDYsGFERUUZWKkIBBIqRaNz8OBBFi5cyF9//cWGDRvKLUIcZA8mxB1O0XYP7nRkbOQJWGxmRlw3kNMm9WTRp8tY/v26gFoKpiZIqDx1igJ9JnZn9C1D2PTnNua9twRn8bFbmYrydHT0MDdalJMWg6PZu3ev/z5FUejZsycjRoxg+PDhNG3a1MBKRWMloVI0CllZWSxatIj58+ezcePGcoPaw4MisBUFk7/ZiZarSrf2SWrXvxUT7x9F5u4sZr66gLwDBSd+kDiGhMqqC4kKYuwdI2jdqwWz/28BW//aeeIHCT/N7kFr4qTD2fEkJiaWu69bt24MHz6cESNGyEQfUWMkVIoGKycnh0WLFrFgwQLWrVtXLkhGBTfBlO0gf3MpFMug9VNhC7Iy7s4RtB+UwOz/W8iWhUlGl9SgSaisvvYDE5hw70hStx1g5qsLAmqbz5qi27x4m5TSdVIbNm3aVO75smPHjowaNYpRo0ZJC6aoFgmVokEpKChg4cKFzJ8/n7Vr15br2o4IikLNsFG4xY3ikiBZFW36xjPpkbNI2ZjKrP8uoKTAaXRJDZ6EypphdVg4a8owOg9rx68vz2Pb4l1Gl9Rg6RYvWhMnPS5uz/r16/3Po4qi0KtXL8aMGcOIESMICwszuFLR0EioFPWe2+1m+fLl/P777yxZsgS3+/DyNRFBUZiy7BRsdqGUSpCsKovNzOhbh9B9dCdmvrJAWidrkITKmtV+QGvOfXgMO1fuYc7ri3AWyVjL6tDNGlp0KV0vaMOGDRv8t5vNZgYOHMiYMWMYPHgwdrvdwCpFQyGhUtRLuq6zdetW5s6dy7x588rtkxseFIE1N5i8jU6UEgmS1RXXPoaLpp1NVkoOv748j8LsYqNLalQkVNY8e4iN8fecQeteLfj+ydmkbEwzuqRGQbd58UaXkjA6ttxOYg6Hg+HDhzN27Fj69u0re5KLSkmoFPVKeno6c+fOZe7cueVmLtqtDkKcERRscEOBBMma0v+8noy6eQh//u8fVv280ehyGiUJlbWnx+hOjL93JIu/Ws3iL1cG5D7itUUL8qDFlBDTP4z09MPLOsXFxTFu3DjOPvtsmjVrZmCFoj6SUCkM53a7+eeff/j1119ZtWqV/3azyUykKZqirV48abIYeU2yh9g496HRNG3ThO+emMWBnQeNLqnRklBZu6LiI7j4yfEU5Zbw4zO/U5QjLe01Sce3ZaS3aSlBHUwUFhb67+vXrx/jx49n+PDhshe5ACRUCgPt3buX3377jTlz5pCbm+u/PSooGm2vmeIkL4pXullqWosusVw0bTx71u9n1n8XyBaLtUxCZe0zWUycNWUoXUd25IenZpO8Zp/RJTVKuqqjNSml1xUdWL16tf/2kJAQRo8ezfjx4+nUqROKIg0AgUpCpahTTqeThQsX8ttvv7F+/Xr/7Q6rg6DCcAo2eGTCTS3qM6EbZ90+jN/f+It1s7cYXU5AkFBZdzoPa8e5D43m789XsvSbNUaX06jpNi/epiXEDAwt1z3eoUMHzjvvPEaPHo3D4TCwQmEECZWiTuzZs4effvqJ33//3d99oigKkdZonIk67v2yKHltMplVxt4xgo6D2/DNo7+Stj3T6JIChoTKutWkZSSXP38Oqdsy+PWlP3E7PUaX1Kjp6Ojhbs649zQWLVqEy+WbjR8cHMy4ceOYNGkSCQkJxhYp6oyESlFrvF4vy5cvZ8aMGaxcudJ/e5AtGHteKIUbPLKeZB0IjgzikqfGo2k63z0xSxaOrmMSKuueLdjKBY+NJaxpKF//61fZDaqO6GYNb9MS4oaFs3//fv/tffr04bzzzmPYsGGYzWYDKxS1TUKlqHEFBQXMmjWLH3/8kdTUVOBQq6QlmtKtyKSbOhTXPobLXziXrYt2MPftvyXUGEBCpTEUBUZcN4jTzuvBt4/NZO/GVKNLChg6OnqEi0G39WDx4sX+xdWbNGnCxIkTmTRpEtHR0QZXKWqDhEpRY5KTk5kxYwZz586ltLQUAKvZSkhJJEUbNVSnvEOtS+0GtOaCx8byxzt/s272VqPLCViqSeWxeVN5ZtSbEioN0Hl4O855YBQzX13AlgWyqH9d06xevLHFhPW0kp2dDfgWVh89ejSXXHIJ7du3N7hCUZMkVIpq0XWdlStX8vXXX5dbDijUFgYpdgae3p9Rk4caWKEQQgijzf9wCQt++4uul7Qut3NPv379uOSSSxg4cKAsqt4ISKgUVeLxeFiwYAHTp09nx44dwKEubnM0xZt0tEzfxBtFVWR5iTqkKHDm5MF0H92R6Y/8QsaubKNLCnjSUlk/RDYP4/IXzmXPuv3Mfm0hmlde+uqSruvomu9nroW4GXZvbxYtWoTX6wWgVatWXHLJJYwdO1bWvGzAJFSKU1JcXMzMmTP57rvv/MtImE1mQp1RFK3VUJwy8cYoqknlvH+NISahCV89+DMFWUVGlySQMZX1iSPMzmXPTsRZ7OLbx2ficXmNLimg6TYv3mbF2DspFBX5nq/Cw8M5//zzueiiiwgLCzO4QnGqJFSKk5KTk8OMGTP48ccfKSjwzaS0WezYs8Mo2ayjeKTbwkhmq4mLnxyPNcjK9Id/kQXN6xEJlfWL2WriomnjsYfamP7QLziLXUaXFPB0k4Y3toSYwSH+xgqHw8GkSZO45JJLZFJPAyKhUhzXwYMH+eqrr/jll18Orz9mDUFNceDcqaBo0rVtNKvDwuXPn4ur1M13/5bWl/pGQmX9U9aqH90qii/u/5HivFKjSxL4Zo1r0U7anNOUpCTfpCqr1crZZ5/N5ZdfTvPmzQ2uUJyIhEpRoQMHDvDVV18xc+ZMf5gMs4bj2WbBIwuV1xuOMDtXvXwe2ftz+fHZuRJa6iEJlfWTosDZd48koU88n9/7AwUHZbhIfaGjo0W66HxpPJs2bQLAZDIxevRorrrqKlq3bm1whaIyEipFOenp6XzxxRfMmjULj8e3E0WYJRLXJhUt0yRhsh4JCrdzzf9dyL5Nacz87wL/IHhRv0iorN9G3TyYbiM78smd35OfWWh0OeIIOjp6mJveN7b3b6Chqipjxozh2muvJT4+3uAKxdEkVAoAMjIy+PTTT5k1a5Z/Nl64JRLnBhUtS8JkfeMItfkC5eY0Zr66wOhyxHFIqKz/Rt54Ot1HdeSTO76XCW71lBbiZsDtXVi8eDHga7kcO3Ys11xzjXSL1yMSKgNcbm4uX3zxBT/99JO/mzvcEkXpegWyZbHy+sgeYuPa1y5k/9YDzHxlHvIXXL9JqGwYRt08mC4j2vPJnd9TmFVsdDmiElqIm363dmTZsmWAL1yOHz+ea665htjYWIOrExIqA1RRURHffPMN33zzDSUlvr2gw8wRONebIEfCZH1lD7FxzX8vIH1HJr++9KcEygZAQmXDMea2oXQc3JZP7/qewmwJlvWZFuqi9+TD3eIWi4XzzjuPq6++moiICGOLC2ASKgOM0+nkxx9/5MsvvyQvLw+AUEsYro1m9INm6eaux6wOC9f89wIy92Tzywt/SKBsICRUNixn3T6M9gNa8/HU7ygpcBpdjjgBLcxF92sTWLt2LQDBwcFcccUVXHzxxdjtdoOrCzwSKgOEruvMmzeP9957z78OWLA1BC3RhjdVxkzWdyazyuUvnIuz2MX302bLpJwGREJlwzPx/lHEtm3CZ/f+gLvUY3Q54gR0dPQIFwnnx/iXIoqOjuaGG25g3LhxmM3S+1ZXJFQGgA0bNvDWW2+xdetWAOwWB6bkINy7JUw2BIoC5z82jpAmQXz5wM943bIOZUMiobLhUVSFi58cj8VmZvojv8r/WwOho6PFlBI9IsjfeNK6dWtuu+02Tj/9dNkyuA5IqGzE9u3bx7vvvstff/0F+LZTtGeE49pmkkXLG5Bxd4ygVa/mfHLH97JTTgMkobJhMltNXPnyeeRnFvLTs7/LcJMGRFd0vM2KCe6tkp+fD8CAAQOYOnUqCQkJxhbXyMneeo1QcXExb7/9Ntdccw1//fUXiqIQ5myCuiQC91azBMoGZOiVp9Hh9AS+vP8nCZRC1CGPy8vXj/xK0zZNGHPbMKPLEadA0RXMqcGU/m7j8ssvx2KxsGLFCq6//npef/11/1bDouZJqGxEdF3njz/+4Morr+Trr7/G4/EQpkRiWROFc6UZxW0yukRxCrqN7MCgS/rw+X0/UpRbYnQ5QgQcZ7GLLx/4ia5ndOC0ST2MLkecIsWr8sPt81GWhjF06FC8Xi/ff/89V1xxBT///LN/gw9RcyRUNhI7d+7kzjvv5OmnnyYrKwuHOQjbtiicf1tRimSQckPTokssEx8YxTeP/kZuWr7R5QgRsAqzi/nqoZ8ZdfMQ2vZraXQ5ogqUUjMrX0jCsimChIQE8vLyeOWVV7j55pvZvHmz0eU1KhIqG7jCwkJee+01brzxRtavX49JNRF0MArvohDItBhdnqiC8KahXPb8ucx6dQEpm9KMLkeIgJeRnMUPT8/homnjiW4VaXQ5oorUXBupXxRj3hlKaGgoO3bsYMqUKbz88sv+sZeieiRUNlC6rrNw4UKuuuoqZsyYgaZphHojMS2PxJtoQdFl3GRDZHVYuPzFc1n9y0Y2/rnN6HKEEIckLdvNok+Wc8WLkwgKl/UPGyoFBVNaEM4/7Jx99tnous6vv/7KVVddxZw5c5C5y9Ujs78boAMHDvB///d//j1Qg8zBeDfaIEtaJhu6S56egK7pfD9tlsw2bSRk9nfjMuHekUS3iuLz+35A88ofaUOnhblocW44u3fvBqB3797ce++9Mku8iqSlsgHxer3MmDGDa665hsWLF6MqKkFZkXgWBUugbAQGX96PJi0j+en5uRIohain5ry+CJPVxJk3DTG6FFED1HwrqV8WY0oOwWazsW7dOm688Ua++OILmchTBRIqG4jk5GSmTp3Ka6+9RklJCcFKKKbVkXi3WqWruxFo0zeeYVf159vHf5MdPISox7weje8en0mvcV3oMryd0eWIGqDoCub9wej/hDJo0CDcbjfvvfcet956Kzt27DC6vAZFQmU95/V6mT59OpMnT2bz5s2YTRYc+6Nw/+1ALZZZ3Y1BWEwIFz5xNj89P5eslFyjyxFCnEBBVhHfT5vFuQ+NoUlLmbjTWChOE2v+swvztjBCQ0PZvn07N910Ex999BFut6wTfDIkVNZjKSkp3HHHHbzzzju43W5CtHDUpeFoyRbZXrGRUE0qFz85nrUzN7Ptn11GlyOEOEl71u3nr89WcOmzE7HY5Q1+Y6GgYMp04PzTxrBhw/B6vXzyySdMnjyZbdtk8uSJSKishzRNY8aMGdxwww1s2rQJs2rGvjsS1xIbiksWMG9MRk4+Ha9XY/4HS40uRQhxipZ+s4aslBzG3THC6FJEDVPcJpY/vw3z1nAiIiJITk7m1ltv5YsvvsDr9RpdXr0lobKeyczM5L777uO1117D6XQSpIWiLo9A32eV1slGpk3fePpN7M4PT89B12RmjhAN0S8v/kmHQQl0PaO90aWIGqagYMqyUzzHwogRI/B6vbz33nvcddddpKamGl1evSShsh75+++/uf7661m9ejUm1Yx9XySeJQ4Up7RONjZB4XbOf2wcv778J/kZhUaXI4SoopL8Un545ncm3jeK8KahRpcjaoHiUVn67FbM28MICgpiw4YN3HDDDcyePVvWtTyKhMp6wOl08uqrr/Loo4+Sn59PkBKCuiIcfbe0TjZW5z40hu1Lktn6106jSxFCVNPutftY9ctGLnh8LIoqz9mNkYKCKcOBZ1EQPXr0oLi4mOeff55p06ZRWCgNA2UkVBps165d3Hzzzfz0008AOLLC8fwThFoqA78bq74Tu9GkZSS/v7HI6FKEEDVk4UfLMFlMDLm8n9GliFqkOE1se+cAN998MyaTiQULFjB58mQSExONLq1ekFBpEF3X+e2337j55ptJTk7GarJh2RyJttUu6042YuFNQxlz2zB+eu533E5Zj1KIxkLzavz03FyGXtmfmIQoo8sRtUhB4dNrfkZdHU6zZs1ITU1lypQpzJgxI+C7wyVUGsDpdPLiiy/y0ksv4XK5CPKEwpIw1Byr0aWJWnbOg6NY/ctG9m89YHQpQogadnBvDn99voJJj5yFapLGgcZOLbSQ9YOHYcOG4fF4eO2113j88ccpKCgwujTDSKisY2XvaGbNmoWCgj0tAs8yB4pb/isauz7juxIeG8bCj5cZXYoQopYs/WYN6DqDLulrdCmiDiheleXPb8O0MxSz2cxff/3F5MmTSUpKMro0Q0iSqUNLlizx/7JZVCvmjeHoO20yGScAhMWEcNbtw/n5+bl4XLLGmRCNla7p/PT8XIZfPYDoVrLbTiBQUDCnBaGsCiMuLo60tDSmTJnCvHnzjC6tzkmorAOapvHRRx/x8MMPU1hYiN0bjLIsDDXPZnRpoo6Mv2cka2ZuYt+WdKNLEULUsoN7cvjny5Wc+9BoFGkzCBhqoYXsn7z0798fp9PJk08+yTvvvBNQi6VLqKxlpaWlTJs2jU8++QQAR2442rJg2RkngHQa0pa4DjEs/Ei6vYUIFEu+XoM9xEavcV2NLkXUIcWjsv6/e7j88ssBmD59Og8++CD5+fkGV1Y3JFTWooyMDKZOncrChQtRFBXrrgi0TTK7O5BYbGbOvusM5ry+CHepzPYWIlBoXo3fXpnPmNuG4giVXqlAoqDww+3zMSeGY7PZWLlyJTfffDO7d+82urRaJ6GylmzZsoVbbrmF7du3Y1EsmNeHo6TKE0ugGXbNADKSD5L4tyxyLkSg2bshlaRluxl18xCjSxEGMB20oy0LJi4uzj9Jd+3atUaXVaskVNaChQsXcuedd5KVlYVNd6CsCEfNl+WCAk10q0gGXNCL2f+30OhShBAG+eOdf+g6sgMtusYZXYowgFrkG2fZrVs3CgsLue+++5gzZ47RZdUaCZU1bMaMGTzxxBO4XC7spSHoy0Jk7+4ANe6uM1j6zRpy0gJjLI0Q4lhFOcUs+GApE+4ZKZN2ApTiUUl6P5ORI0fi8Xh47rnn+OijjxrlQukSKmuIruu8++67vPbaa+i6ji07FG1VEIpXfsSBqN2A1sS0jmLxV6uMLkUIYbDVv27EbDXRfXQno0sRBlE0hcVPb+aKK64A4JNPPuG5557D42lcY+0l8dSAsnceX331FQDWfWHoWxyy/mSAUlSFs6YMY977i2VNSiEEmldn7tv/MOrmIZit0nMVqBQUZkyZhzkpFJPJxO+//85jjz2G0+k0urQa0+BC5a5du5gyZQp33HEHDz74IMXFxcybN4/bbruNu+66iwMHfNvfLV26lClTpjBz5sxaraekpISHH36Y33//HQUFy44wlN0SKANZn/Fd8Xq8bJybaHQpQoh6Ysfy3WSl5DDwoj5GlyIMZjoQhLIhFKvVypIlS7j//vspLCw0uqwa0eBCZatWrXj77bd544036NKlC3///Tfffvstr7/+OpMnT+azzz4DfKHyzTffJDGx9l7Yi4qKeOCBB1ixYgUmxYRpczhquqPWrifqP6vDwsjJg5n71t80wuEyQohqmPvW3wy96jSCIuR1ItCZcmzoq4IJDg5m/fr13HXXXeTk5BhdVrU1uFBpNpv9n5eWlhIbG0ubNm2wWCz06NGDXbt2ATBgwABuv/12OnWqnTEsBQUF3HvvvWzYsAGTYkZdF4YpR5YMCnSnX9qX1K3p7F67z+hShBD1zIGdB0n8ayfDrxlgdCmiHlDzrbj+sREREUFSUhJTp07197Y2VA0uVAKsXLmSG2+8kbVr12IymQgKCvLfV7Yd0tChQ3nnnXeYOHFijV8/NzeXu+++m61bt2LGjLomDLVAlgwKdPYQG4Mu6cP8D5YaXYoQop5a+NEy+ozvSlhMiNGliHpALbJQ9KeJ2NhYUlJSuPvuu8nIyDC6rCprkKGyf//+fPjhh5xxxhmsX7+e4uJi/30mU+0Ogs7Ozuauu+4iKSkJMxaUNWGoRZZavaZoGE6/tA+7Vu7lwM6DRpcihKin8jIK2DA3kaFX9Te6FFFPqKVmcn710rx5c/bv389dd93VYINlgwuVLpfL/3lwcDAOh4Pdu3fjdrvZuHEjbdu2rbVr5+Xlcc8995CcnIwFK8rqMNRiCZQCHKE2BlzYm4Ufy/7eQojj+/vzlfQa25nwpqFGlyLqCcVl4uDPLpo1a+YPlpmZmUaXdcrMJz6kflm1ahXTp09HVVUiIiJ45JFHiIiI4M4778RqtfKvf/2rVq5bUFDAfffddzhQrgpFKW1wPz5RS06/rB87lu8hc3e20aUIIeq5/MxC1s3ZyrCr+/PbK/ONLkfUE4rTRNYvbpqd6wuWd955J6+//joxMTFGl3bSFL0xLulew4qLi7nvvvvYvHmzr8t7dRhqiQRK4eMIs3PXN9fzwa1fc3BPw5+9J2qWalL598I7eeqM19G8mtHliHoitEkwU7+8hrev/YK8AwVGlyPqEd3mJeocM+np6bRu3Zo333yT8PBwo8s6KQ2u+7uuOZ1OHnnkETZv3owJM8raUAmUopz+5/dk54o9EiiFECetIKuIDXMTOf2SvkaXIuoZxWki+1cPMTEx7Nmzx78md0MgofI4vF4vTz75pG+WuWJCXSeTckR5ZquJgRf2ZvH01UaXIoRoYJZ+s4be47viCJXl6ER5itNE7hyN8PBwtm7dymOPPVZuTkl9JaGyErqu89prr/HPP/+gKirq+jDUQgmUorxe47qSkZxFamLDXltMCFH3svfnsXPlHk47r6fRpYh6SC0xU7zIhMPhYNWqVTz77LP+ZRPrK+nHrcT06dP56aefADAnhmEqsoNs2SqOoKgKgy/ry+9v/oVqkvdnomJlvxvyOyIqsvTbNVz27Dks/34dHlf9Dgyi7qklNryrwdzTzYIFC4iKiuKuu+4yuqxKyUSdCvzxxx88/fTTAEyYMIGhQ4caXJEQQgghAtWGDRuYPn06APfccw/nn3++wRVVTELlUdavX88999yDx+PBkh6MOTnM6JJEPXX1q+ez8c9trJu1xehSRD2mmlQemzeVZ0a9KbO/RYU6DmnDyBtO5383fmV0KaIeu+qjibz//vuYTCZefPFFBgyof9t9Svf3EQ4cOMDjjz/uC5R5QSg7gtGQFwFxrJiEKOLax/DVgz9LUBAnRfNq8rsiKrTtn12Mu2ME8V3j2Lsx1ehyRD316bU/M/bpsfz+++888cQTvPPOOyQkJBhdVjkyyOcQp9PJo48+Sm5uLmaXDWVzCAqK0WWJeuq0ST1YN2cLbqfH6FKEEA2crums/mUj/c+XCTuicgoKC/69lp49e1JUVMRDDz1Ebm6u0WWVI6ES30zvl19+me3bt2PSzajrQ1E0CZSiYlaHhV5ju7Lqp41GlyKEaCTWztxMpyFtCY4MMroUUY8pukLie2k0b96ctLQ0nnnmmXo1I1xCJfDtt98yd+5cFBTUTaEoTpnmLSrXY3Qn9iemk5Uii50LIWpGYXYx25Yk02dCN6NLEfWc4lHJ/K0Um83GihUr+Oyzz4wuyS/gQ+WmTZt45513ADDtDEHNsxpckajv+p3bg1U/SyulEKJmrfp5A/3O6Y4iHWXiBNRiC/fddx8An3zyCStWrDC4Ip+ADpUFBQU89dRTaJqGOduBmuYwuiRRz8UkRBHRLIztS5KNLkUI0cjsXb8fgFY9WxhciWgIXhn/Ieeccw66rvP0009z4IDxm3AEbKjUdZ2XXnqJ9PR0TB4L6jaZmCNOrNe4rmyatx2vu/6MYRFCNA66Dut/30qvcV2MLkU0EL8/vJyOHTuSl5fHU089Zfj4yoANlb/88guLFi06PI7SG7A/CnGSFFWh51mdWT9H1qUUQtSO9XO20vWMDlhssuKfODFFV9j9ZTZBQUFs3LiRr74ydq3TgExSu3fv5vXXXwdA3RUse3qLk9Kmb0tcxS72bzW+i0EI0TjlpOaRsesgnYa2M7oU0UAoTpN/68aPPvqIbdu2GVZLwIVKj8fD888/j9vtxpxvx5QqyzeIk9NrbGfW/77V6DKEEI3cujnSBS5OzSsTPmTEiBF4vV6efvppSktLDakj4ELld999x9atW1F1E2qijKMUJ8dkMdFpaDs2/WncO0AhRGDYumgHCb1bYA+xGV2KaCAUFJa+uIUmTZqwd+9e/ve//xlSR0CFyj179vDBBx8AoCYFo7hkPUpxctqe1pKc1Dxy0vKNLkUI0ciV5Jeyd0MqnYa2NboU0YAoHpX8Rb6JOj/88AObN2+u8xoCJlR6vV5eeOEF3G43pjwbaobd6JJEA9J1RAe2LEwyugwhRIDYsjCJriPaG12GaGDUXBtjx4717xTo8dTtVsIBEyp/++03Nm/ejKqrmLaFSre3OGmqSaXzsHZsWbjD6FKEEAEi8e+dtD2tFbYg2ZBDnJoFT64hPDycXbt28c0339TptQMiVObl5fH+++8DoOySbm9xatr0jSc/s1C2ZRRC1Jmi3BL2bUmn4+A2RpciGhjFozJlyhQAPv74Y/bv319n166RUFlQUGDoFPYTef/998nPz8dUYsEku+aIU9RxSFsS/95pdBlCiACT+PdOOg6RcZXi1L0y4UP69u2Ly+XijTfeqLPrVjtULlq0iJtvvpnHH38cgB07dvDAAw9Uu7CakpiYyK+//gqAmiSzvcWp6zAwgR3LdxtdhhAiwOxYvpt2/VuhqPK6JU6NgsLG9/dgMplYsmQJq1evrpPrVjtUfvbZZ7z33nuEhoYC0L59ezIyMqpdWE3QdZ3XX38dXddRM+2o+TI2RZyaqPgIHGF29m1JN7oUIUSAyUrJpbTQSYsucUaXIhogtcTMeeedB8Bbb71VJ1s4VjtUWiwWf6Asoyj1413V4sWL2bRpE4quYk4OMboc0QB1GJTAzpV70DXd6FKEEAFox7LddBjU2ugyRAP16wN/ERISwo4dO5gzZ06tX6/aobJZs2asXLkSgKKiIj766CPatzd+GQSv1+ufnKPus8vkHFElHQYlkLR0t9FlCCECVNKy3bQfmGB0GaKBUjwq11xzDeCbX1JSUlKr16t2qLz33nuZO3cumZmZXHbZZaSlpfn3oDTSvHnzSE5ORtFUTPuCjS5HNEBmq4nWvVqwY8Ueo0sRQgSo3Wv30bRtNEHhsrayqJoPrvyeZs2akZ2dzc8//1yr1zJX9wShoaE8+uijNVFLjXG73Xz44YcAqHuDULwBsXKSqGEtusSRm55PUU6x0aUIIQKU2+khdWs6rXq2kFUoRJUousI111zDiy++yNdff815552H3V47b1KqHCo///zz495/9dVXV/XU1fbHH3+QlpaG6jFhSg0yrA7RsLXu3YLd6+pufS8hhKjI7nX7SegdL6FSVNl/z/2YuAvjSE9P55dffuGSSy6pletUuQnP4/Hg8XjYs2cPs2bNIi8vj7y8PGbNmkVaWlpN1nhKNE1j+vTpACgpDhStfkwaEg1PQu949qzbZ3QZoqE5mYmK9WQyo2gY9qzbR+veLYwuQzRgiq74G/u++uornE5nrVynyqHy+uuv5/rrryczM5MPPviAqVOnMnXqVN5//30yMzNrssZTsnTpUvbs2eMbS5kuC52LqjGZVeK7NWOPtFSKU3EqYVGCpThJKZvTiEmIwh5iM7oU0YC9dt6nxMbGkp2dzezZs2vlGtUebJiVlYXDcTi82e120tONW9OvrJVS3W+XsZSiypp1iqXgYCEFWUVGlyIaiiND4vEC48keJ8Qh7lIPadszadWzudGliAZM0RUuu+wyAL7//ns0Tavxa1R7os7AgQO5++67GTVqFOCbdT1w4MBqF1YVmzdvZsOGDSi6gilNxlKKqovvFkfKJuOGcYhGQFFA14+9TYgqSNmUSnzXOLYvSTa6FNGAvXPZVwSPDmbv3r2sXLmyxvNatZvy7rjjDi6++GJSUlLYu3cvF198MVOnTq2J2k7ZTz/9BICSYZN1KUW1tOgcS2riAaPLEA1FZWHxZFolJWiKk5CaeIDmsrOOqCbFqzJ+/HjA11pZ06rdUgkwbNgwhg0bVhOnqrL8/HwWLFgAIK2Uotqad45l2ffrjC5DNAQnCoUnO3Hn6FZNIY6wf+sBxt8z0ugyRCPw84PzUQYoLF++nNTUVJo3r7lhFdUOlZUtdP7aa69V99SnZM6cObhcLpQiM0phjWRlEaDsITbCY0M5sMO4CWeiYVDMvucavbI9dRUV1XGC9eAUFcVkAl1D93hquELRWOSk5qEoCpHNwshJyze6HNGAKU4z/fr1Y9WqVcyePZsbb7yxxs5d7fQ1efJk/+cul4u//vqr3MSduqDrOjNnzgTAlOZAQbqTRNU179SUjOQsPK5KgoIQHA6UAIrJdGywVFRU++HZuqrNhlZccswxisl0+HOzWYKlqFRZF7iESlFd675Igs4we/ZsrrvuOkymmhkyWO1Q2aNHj3Jf9+vXr863ady1axfJycmgK6iZspWVqJ5mnZqSti3D6DJEPXZkoPTfdmSwPCpQAqAqvmBZtj7ckYHSfxIJlqJyqdsO0LxTUzbP3250KaKBU7NshISEkJGRwerVqxkwYEDNnLdGznKEHTt2kJFRty/If/zxBwBqllWWERLVFpPQhIxdWUaXIeqpigKl/z6TqeJAWUZVUW22igOl/yTqca8hAldGchYxCVFGlyEaAUVXGD16NADz58+vsfNW+5lr5MiRKIcGoquqSmxsLFOmTKl2YSdL0zT/D0RaKUVNiEmIYv3vW40uQ9Q3ilJ5ECw7xGxGDQ9DLyis/CCLBXNEON6snOOcSFosxbEyk7OJSWhidBmikZj59CLoAX///Tf3338/5hp4M1vtM5TNuDZKYmIi6enpKF4FNUd2GxDVoyi+lsrM3dJSKY6gKChWq+/zSiblKGYzapMo0DROOI/bYsHUJPK4wVIxm8FkQq+l7dREw3NwbzbhTUOx2M24S+UNh6geJc9CZGQkOTk5rFmzpka6wKvdV3zvvfcec9sDDzxQ3dOetKVLlwKg5Fhln29RbeGxYXjdXgqzio0uRdQXRwZKgApaK/2BUlHAZEINC634XCYTaniY7/NDwbLCS5rUQ5dWUGzyZln4eFxectLyiGktXeCi+hQUhg8fDsCiRYtq5JzVDpV5eXnlvnY6nXU6pnLJkiUAqNnyxCuqLyYhSlopxWFHB8oyRwTLcoGyjNl8bLAsC5RHHldBsCwLlIdLkGApDsvcLV3goubMetYXJpctW4ZeA2vlVrn7+9NPP+WTTz5B0zTOPPNMwLe0j8Ph4KKLLqp2YScjMzOTpKQk0CVUipoR3TqSg3uPM9ZNBI7KAmUZkwlFUY4NlGXKgmWRb3ylGh5GhVvtHtEVfnSgPFyKAjabdIULDu7JJrp1xS3cQpwqJd+K1WolMzOTPXv2kJCQUK3zVTlUXnvttVx77bW8+eabhm3LuGrVKgCUQjOKR2Z9i+qLiAsjJzXvxAeKxk1RUMyWEx+nqsffMcdsRo2M8J+TykZbmkyVBsrDJSlgsaK7XSeuSzRaOWn5JPRuYXQZopFQNIVevXuzYsUKli9fXu1QWe0kZlSgBFi/fj0Aau5xWhOEOAURcWHkysLCge3IQKlV3h2kWK0oLZujB1e+2YNut1LU8wQBwKSiRYahtDr+cbqug6qgWOT5LpDlpucTERdmdBmiESmboFPWUFcdVW6pvPnmm3nvvff8Swrpul7u35pc96gy69atA0DNkydZUTMimoWTmy6hMmCdZAulYrWiNI+FQ62LerADpaj8bjm63Upxp2iw+loySzvEYk1ML38ik4oWFgSKgu6worRqgb53//EvfihYSotlYMpNyyeimYRKUXP+d+NX0Ac2b96MpmmoatXbG6scKt977z3AuCWFMjIySE1NBR2UgpPophLiJEQ0k5bKgFVZoNR8LYT+w44KlACY1HLBsixQahbF3x3kDjGhdYzFvv2A/zFlgbJMZcHymAH0EiwDVt6BfIIjgzBbTbKVrKgRSpEZu91OYWEhe/bsoU2bNlU+V7W7v5977rljbnvhhReqe9oTSkxMBHw/DNlFR9QER5gdk1mlMLvI6FJEXTtRC+WhbvAKA2WZQ8HyyEBZ/hq+YFnaMbbCQFmmLFj6v65sRqZ0hQckj8tLUU4x4bGVLFslxClSUOjSpQsAmzZtqta5qp3Gdu7cecxt27fX/r6kZddQCmU7M1EzwmJCKDhYRA2sqiAaGuXET4WK2Vx5oDzEG+4g7axmxwZK/0mgNMpM6oT4407w8bdYnuiXUVVAPf4uP6LxycsoJKyphEpRc7p37w7A1q3V202uyolsxowZfP/992RmZnLFFVf4by8uLmbQoEHVKupklIVKtVC6vkXNCI4MojBbFj0POIfCne71VroNo2K1oMbGHHenHG+YnbTBIXhtkGcxE77n2B1PvFaV3PYqmhnShkfS7K/Kl6/SrRbUls3RUlKPc9FD3Z+qCTTpCg0URTnFBEdUPkFMiFM1/dFfoDPs2rWrWuepcqgcO3YsgwcP5s033+SOO+7w3x4cHExoaO2/g0pKSgJ83d9C1ITgSAdFORIqA84RrZQVBUt/oDSbQNfBqx3TWnlkoATQK3la0hXQDr0PdkYeJ1h6D8VXm7XyYOn1oh9ndrpovHyhMsjoMkQjUpalkpOTqzVZp8rd3yEhITRr1oxnn32WuLg4/0ddBMqioiKysny7nijFEipFzQiODKIoV0JlQKloTOMRe3uXC5T+Aw4Fy0OODpQAXivktS7/3OS1quS1O+IpVzkcLMsfeDgo6oriD5blj6kgUEo3eMAoyi0hOFJaKkXNUUpMWK1WSkpKSEtLq/J5qp3IkpKSePXVV0lOTsblOjwTsTaXFNq3b5/vE5cqk3REjQmODKIop+TEB4rGQVEqHUupe72oDvuxgdJ/gC9YeiODjgmUZTxBvmAZmeILqXntVDTzUUHwULBMHxZJ3N855QKl/1KKgnJki+XxWiilGzwgFOUUy/7fokYpKLSIj2fXrl3s27ePFi2qtsB+tRPZq6++yj333EOLFi347bffuPnmm5k8eXJ1T3tcZaFSKZF35qLmBEdI93fAOE6gBFBMJpSgoIoD5SFaiI30gRUHyjKeIMht73vvrlU2/FuB0ihIG1H51nu6ooDFjBoacuIub2mxbPSKcooJjpTub1GzmjVrBlCtlspqh0qPx0PHjh3xeDwEBQVx2WWXsWTJkuqe9rhSU33ji5RSefIUNccRZqe0QPZWDnSKqqCGhYCuoRRUvLyUFmonfUg4mg2UivbzPsQdqtP13MQTXlM3HeoKH1lx65OiaSj5RShmM6aoiBOc7DgFiUahJN+JI/Q472aEqIJ6ESrNZt+78Li4OObPn8/GjRv94x1ri388pUtCpag5VrsFV4ksJh0QdL3C8KWoCmpo6OEZ4dqxx2ihdtIHh+O1H3qMXnGwdIfqDDhjK/GOXACaDd1XcSnq4X+dUZUHy7KZ3scNlrqGrInV+LlL3VgcsvKJqFk/vjQHgPT09BMcWblqh8rrrruOwsJCpkyZws8//8wbb7zB3XffXd3THld2djYAikvGU4qaY3VYcJW4jS5D1JWjgqU/UB45s9vrLdda6Q+UR82RODpYlgXKZvY8/23dI9JoPqx8sNSPegqrKFgqmoaSV1j+ehUFSwmUAcNV4sIqoVLUsLKGupycypc6O5FqT9QZOHAg4JsN/tprrwEwa9as6p72uMpCJRIqRQ2yBkmoDDi6DmgoJtOxgbLsELcbpaAIPTQYVPWYQFlG8Z0KV/ixgRLAonjpEZkKwyD17/hjAqX/eir+a/gDpffYyTdlwdKbnSuBMsC4StxYHbKbkqhZitvXQ5OXl3eCIytXK6nso48+qo3T+pV9w4pHQqWoORa7hMqAZTIdd6cc3e37vUgfdPwl09yhOmeNWXNMoCxjUbyc1mQvg8/ecNzzeByQPiKq0kB5ZN2KySSBMsD4QqW0VIoadihT1btQecKtxaqppOTQsi/eyrc5E+JUSfd3AFIUXyjTdPTiypeTUux2nC0jCD5Q+SQYV5jOmLFraOvIJNJc8SoCNtVDz6AUxkRuZsjYyoOl4gFHlkZJl2aVHqPrOnpBoewBHoAkVIraoLh9kbCgoKDK56iVUKkcsaDwW2+9xdSpU3nqqadwu918+umn3HHHHSQmnnhGZGVKS0t9n0ioFDXIZDHh9cgafwGjLFAeWlpId3sqDJaK3U5pxzg0i4qlwEvY7mOD5ZGBEsCuuo8JljbVQxdHKnbFjUXxVhosVReE79JQ3TruMDMl3eOPOaYsUPoXapdgGVC8bi+qSUU1yWugqEGa7/fJ7XajVTBJ8WRUeUzlvffeW+l9ZU2n27dvJzs7mzfffJPPPvuMhQsXkpmZyUsvvcRHH31E586dq3TtslCpaPIHJWqOoijoFSw+LRqhowJlGd3tgeISlCDfoEZ/oLT6jlN0DgVLyE/w3XZ0oCxTFixz3SEAdD4UKMuUBUvGwuLfewKHA6XJ5fs91BVwh5mhezyOTb5JPscEyjKHgqXulhUMGrvDnYEKHHdHeiFOwRG/Sm63G5vt1JetqnKovOaaa054zObNm+nfvz/gm9Aza9YsoqKieOCBB5gyZUpVL43H4/F9IsuxiRqkqEqtD90Q9UAlgbJMWbBUoyLLBUr/w48Ilgd7KhUGyjJ21U0zax4UUy5QljkyWC79tWe5QOmv54hgad+YUnGgLCPBMiCULYCvqApI54qoKUc01OXm5hIbG3vKp6hyqOzdu/cJjyksLCQ6OhqA4OBgCgoKuOeee7jhhhuqelngcPe6alJRtLqbrHP6uf3p0DeBrcuSWDlnXZ1dd9A5/ejYry2Jy3ewYvZauW4tiY6J5vJHLmDjoq0B8f0G7HVX7GDlH5uPe6yigGq3gN1U6RghDfBGa7SzZx27NtAhVtXBFW3/D4cWTUZqCB698JhjLOh0D07n75geWLYDasU9MHqQGZPNgrdARznOpCJMoGsqAyf0pVP/dmxfvYtlv64+7vdbk4y67oCz+9B5YPuAuK6iKkRGRnLttEtIXLmj0X+/gXzdpDW7WfrLyjq5pn5EU6V/7sopUvRabJr56aefsNvtjBs3jsTERGbPns0999xT7fOeeeaZeDweHn74YcLDw2ug0pOTkJBAZGQkWVlZ7N27t86vm52dzZ49e+S6ct1Gcd2cnBx2797dqK+rqiq9evUCYP369VUep1QVgfRzNvK6rVu3JioqSq4r123w1/V6vTz22GMAfPfdd3XbUnkyunbtyjfffMO4ceNYsWIFPXr0qJHzqqrvXfp/L/4ItQ531Znyf9fR+8we/PPDcj6b9l2dX3fxjyv49Ilv6uy6t716HX1G92DJTyv55N9f1/l1l/6yko8fq7vrfrjzFbJSclj8U91e95b/XEO/s3rV+fdbdt1lv67io0en19l1b37pak4b15vlv63mw399VefXXTFrDR88/KWvG9xcfgatYlJRwkNRDj3HoKroIUGUJBzel9sdrJLZT8VrPzzuUY0p5dYef5c7V5ipmEtCD2K3/EKpuxmt4yezuLT8fs1p7kje2jgCd/GhOnQwZ1touvJw+DS5dIK3Z6E4j+jSdrl961MeRXcdPmby81cyYHwfVs5ey/sPfXHSP6fqmvzClQwY35dVc9bx3oOf19l1b3zuCgZO7Ffn173h2csZdM5pdX7dD5NfIWtvDit/X8f/7v+szq57/TOXcfq5/Vnzxwbeve/TOr/u2j838s69n9TZda976jIGn1f31732yUsZcv4A1s3fyNt31811dVUH39LjhIYef/m0ytRqqOzYsSNRUVFMnTqVpk2bcvnll9fIeW02Gy6XCw1vnc4ALwuzXreG5q27Foey7n6vx1un1y2bWVjX1y3j9dTtz9nXaK+geev2umXq+rpl47IM+3413YD/36O+X6/mD5aKSYWQENCPmLDl9UJeEbadOiVtInEHq2T0VfDatMOD2nXwZtp4a+NQpvT8C4BwUzGXhu4mRG1C2TNUU7ONYUH7+bvEt0xQqjuSNzYOx11sxn8yBbxRLtJOsxC7wje+0rEtC93pKj8dw2RGCQ/Hm31454sjA+WR36+u1+3PuexadX5d7fBPyIjvty6vq5p847913TdUw4jvV1GUOr2ux3V4pYM6va7bN4dDNdXtdctWIlFVtc6uq6uHB+ja7fYqnaPaofKJJ57g/vvv96fa/Px8Xn31VaZNmwbA7bffXt1LHKNsfCamup1UsWfLPhyhDlK27a/z6waFBZGyLbXOrxscbsR1UwiJDGZfHf+cdV1HVRS0Op4BvmfLPsKahJKyLa1Or7s3cT/hMWHsTazj/9+t+4hoGkZKYt3+/+7dso+IpuHlf591Hd3jRrXZUMLDDrdQHknTUAqLsR20s394qL+F8kiKBlqmnbc3DOeRPnO4KDSZEPXYrXeamoIZ5kjjm/yuvLHhjMMtlOVOBp4mbjL7Wmj3aUb5FsojWS2YoiLxZuccEygB9m7dR1RcBClb6/bnnLItlegWu9hbx/+/KYn7iW4RVefX3ZuYSszquv1+zVYzuqajo6BUMuGstqQk7idp9S72bEmp2+tuS2XHml2kbN134oNr+Lq+7zcArnsoUzkcDn8j2qmq9pjKG2+8kQ8//PCEt9WkG264gR07dmDZFIGae+pT3oWoyAdJ/8GkWVkw/R8+m/at0eWIuqIoqDYbamRE5cdYLbhbRFHY0sGBQZUfptk1Bvbcwddt5h+6JRilyQxK3M2w5g1FVQpI8xRy/Y5L2ZZc+cLmSomJFvPBccCJZV9W5Rf0angPZKJ7jrNov6xo0OgERTh4bdVTKE4z6xds4o2ptfd6KwKHFuzG3SebJk2a8OOPP1bpHNV+i+P1eikuPrzIb1FR0eElf2pJcHAwALpZnixFzdF1HUWt264kYbBDywvpHg9afiW7SFgteGIjQFGwFla+fotu1QlrVkBKQQS37Du9wmMyvEU8sG8iXl0lJu44W6FpYMn34HGYcMc3qfgYr4Z2qPtbMVUytlwCZaNksZr93aNHbjYiRLWYfa99VR1PCTXQ/T1x4kTuuusuzj77bABmz57NueeeW93THleTJr4nWd0qC3SJmlNcWIK3qITs9FyjSxF1oWy9ykN0pxMtH9SwI55QDwVK3eI7zpLvIXaZ6ZjWSt2qE9oiH4fVjVdT2ZTdjFs4nf/FL8V7cAJrd31I29aZ3LdvApklIajohNtLIQ4y08uvYKGUmGi+6PDXHocJ4puUb7E8FCj1Q+O9UFQUE+XXr5RA2WiZbSaKi0spPVAgz1eixuhWX6gsWwqyKqodKi+66CJat27NypUr0XWdW2+9lX79+lX3tMfl/4at0qIkas7GlVuY995iklfX7VghYYCjAmWZioJlWaAEUDSd4FQnscts/mB5ZKAsc2SwfKfFCgAeSDmbzNJg/zEVBUulxETzBWDNK9/bo1mO6FQ6OlD6izsiWEqgbNTMVjO7t+/m9cs+MboU0YiUhcqyhruqqJHZ3/379/fvnFMXYmJiANBt0lIpao6zyIk9WPZPDgSVdhdzRLCMjvJ1ex/92COCZfrwYwNlmbJgeUnpKO5TILM0hKO31DsyWB5MjqowUAJoZgV3fBMsezIrDpT+4g4Fy1oegiSMZQ+x4SySXZNEzTrv/rHMmDHDmFD56quvcu+991a6B/irr75a5aJOpGxBTt0mLZWi5pTkl+IIP3bGrmh8dK/3+MHS5UYvdZZrpTySoukEZbgI32rH1qbySTKFpTbW7Y6BbpXXoqLj8ao0Wa1izas8KOhmBb2ouPJAWXZcZVs4ikbDEWanOK9qO54IUZn9+30rGDRrVvkkwhOpcqicMGECcHJ7gNe0li1bAqAHeTi0qEKd1yAan+K8UhyhVVubSzQwul55sFRUFKsFSkqx7MnE3Trm2IebFVxhZoIOeCn4sylBozOOOabEZSE/NRSz29d1nbQnjnatj102KrMoGH1OE8ylGq4IM9bcY0Oj6tGxbk9D1zUUuw291Fnxt+VxS9d3AHCE2SnJLzW6DNHIpKT4hn61atWqyueo8uzvTp06AbBz50569+5d7iM5ObnKBZ2M+Ph434w3sw4Waa0UNaMkv5SgcAmVAeNQsCynLFCqqm9x6fwCLHsyyz/MrOCMsKCbFFQvhKZ4Kf6zabljygKl4j78FKsUmti+J67ccWWB0p6r+RY+tyi4Isq/11c9OrZtqeiH9uJVTCqK/dil1CRQBo6gcAmVombpik5amu9Nb1nDXVVUe0mhWbNmHXPb7Nmzq3va47LZbP7mWT1IunpEzSjJL8URJqEyoBwZwo4IlIfvLh8sjwyUZSoKljqUC5S+GxVwHb7tYHHQ4UDpr6F8sDw6UPoPqyhYSqAMGI4wB8V5EipFzdEdXjRNIygoyJgxlYsXL2bx4sVkZGTw8ssv+28vLi7GdJyxSjWlTZs2pKamogW7UfNkcoWovuL8EoJkTGXA0b1eFLPlmEDpv1/XIb8Ay34TBb3iygXKMmXBsuDPpijDcyhIC61wUI7iUti+N5ao6AK02dHlA6X/IF+w9ASbCF2x95hA6T/MpMKhrvDjLn4uGp2gcDsZu46zKL4Qp0gP8T2HtG/fvlprn1a5pTI2NpYePXpgt9vp3r27/2PkyJHlQmZt6dy5MwB6iMxyFDWj8GARoU2CT3ygaFzKusFPsC2ZXlRCyPacSu9XvRC214vltwgUVyXn0hXMGVZM3zepOFAeYnLphG7MQPccvydGURTp9g5AoU2CKcgqMroM0YhMemQMcHhoY1VVuaWyffv2tG/fnhEjRhAUFFStIqqiS5cuAOih8g5dnBpVVXnw06lEt4jiwO5MXr35XYZeMJBLHjyXJi0j+enpP8jcl8WA8X254pHzmf3RfH7/eIHRZYvaoiiga+glJSiOY1uqFUUBixl0DbLzCN0KBV2ijj2PDpZCDUuhxr3nn0nHXnGkFhTw8J+/Ex8fz1cJrXl+3iIO/JOGpVBDsyq4g48NnyanTtj6DCguQTGp6FjBXcGscE1HK9vNTFEkWDYiHfq25bb/Xoeu6eQcyOXFa97g+TmPAWB1WGnWIYa/PltBqy7x3PO/W1BNKp/8+2vWzttIXJum3PverexN3M+bd8j2jeLkbNu2Dah+qKz2mMoHHniAgoLD25vl5+czderU6p72hPwtlQ4vulkm64iTN/SCAaQlH+D+M6exZ2sKQy8YyIX3TOT+M55gX2oKV/37IgAGTujLPcP/Taf+7Y0tWNSeI7p5dK/32LGLZYGy7Div91CwzC5/Hh3MJRqKptOhTQxNbQ5u/9e3JGVnMa59R2w2Gzd/9yOXRHbEUuh7vlJdOpai8s9dZYFSKTy89a1iUsFy1BCfQ4Gy3EQj2a6v0Ti4P5tHxj3DfSOfIHVnOqefexr3nzmN+8+cxs9vziYrK5u8jAJuePZy/nPDWzwy7hmuffJSAIZdOIj/3vI/CnIKCWtS9e32RODQFZ3t27cDh7NVVVU7VJaUlJTbJzIsLKzcXuC1JSwsjNatWwOghcsisOLkNWsby851uwFIWpPMhJvHsGdLCiWFTjL2Z9K+dxsAVs1Zx3//fpqk1TsNrFbUmgpCWEXB8pjjyoJl4qGu8CMCJUC3Li1YtTqZoAwP63/fTd9mzXG5XHw69nwWzd9a7lRHBsuKAuXhA4+ooaJAeZzvSTQ8OQdycZb4Xtc8bi9ez+E3H2dcOpjcvBwKs4qIahbJ/h3pFBeUkJ9VQFiTUBb/uIJ73ruVsCah5GdVsp+9EEfQQ924XC6ioqKqNfMbaiBUKopCdvbhd+1ZWVm+ge11oG/fvoCESnFq9m7dT58zuwPQd3RPwDdJByA/oxCz3TcqZOmvq7h76GPM/nC+MYWK2nOc8FUWLP2tlBXxeiErl9DNWeUCJUBIsI3iYheKpqOlFBNXYCMlJYW7H5zO1u3px5xKdenYszyVB0rKWkytxw+UJ/G9iYYlpmU0fUf1YNlvqwFwhNiJTWhKRkommlcvN6GiKK+Y0KgQUnem8+DoJ3nj9g+MKls0MFe+OgmAPn36VGuSDtTANo1XXnklt912GyNGjADgr7/+4pZbbqnuaU9K3759+fHHH9EjJFSKk7fst9X0GtmNl+c9we7NKRTmFBIU5htLl3cgH1WVF+VGT9dPGCw1pxPVaqn8HF4vSmExihZR7uaCwlKCgnzd1WFWC869eQSfYC1h1a1DXiGYjv8+/4SBEmRsZSMRFOrg4c/u4OUb3sZ7aMLW6eeexuZliRR6CwHQtcMtmCERwRRkFxpSq2jY1q5dC/hCZXVVu6XyzDPP5MUXXyQuLo7Y2FhefPFFRo4cWe3CTkZZqtaDvOhWWa9SnBxd13n33k95YNST5GcV8MNrM2ndJR6zxYzdGkR2RuUzfEUjcoLwpbs96IXHmWGr6+hOJ/ajlnbZkphK/35tUN0agzq3YOvKXQA4Uit+wTe5NOxJB3yThbwVjw/XvRpabh66poNynKdtCZSNgqqqPPzFnXzx9HfsTzq8C9Pwi05n56ZdZO/zPUdlp+fSon0cQaEOQqNCpLtbnDLdpLFp0ybgcO9vdVS7pRIgISGBhISEmjjVKQkLC6Nbt25s2rQJrYkTU1rdz0IXDU9kbASPTr8br8fLmnkb2fRPIj+8NpNXFj6JLcTKkj+XG12iOIrNYeXG569k0MR+FBeUgA6r/ljPR498haZVPlHv6icuxuvx8tWzP1R8wHFaLNv1bEnTVk1ZPncDSkgwHXq1YtxVQ3njga8Ohzddh9x87LugtK1vweAdOzPIOVjIh29fT3hUENePfJ4hF7ZGKS7FkapT0jzEfw2TS8O+/cDhcZy6hu49NDmnrMSyQFluUo7qm40OvLX8eW4f+AjoOlc9fhFfPP39iX6cp/5zEnVqxCWn021wJ4JCHVz52EX8+u5cVsxaQ9NW0XhVL3l78wH46NHp3P/R7agmlU+f+MbgqkVDpEW68Hq9tG7dmvj4+Gqfr9qhMikpiVdffZXk5GRcrsPd0PPn1804tGHDhrFp0ya8URIqxcnJOZDL/WdOK3fbwm+WsPCbJST0jmfsHcMNqUtU7p73bkXXdW7qcS/OEhcWm4VLHjgXi83sn9BQZZUEy3a9E+g+pDNLf1uNWlhE0vq9JK3/6tjWwKOCperW+OjJn1nVuyWXTxmNx+0Lg4qmoxSV4kiFkuYhxwZK//kOB8sKA2WZQ8GyLFACVQ6Von5Z8PViFny9+Jjbp5z2EFe/ej571u0DYO/Wfdwz/PG6Lk80ImdM7c+ff/7JkCFDauR81Q6Vr776Kvfccw8vvvgib7zxBr/88stxWw5q2tChQ3nnnXfQw13oJg3FW+0efRHADqZk06RlpCz7V4/EtWnK6eeexuXxt/gDpNvp5stnZviPuf31G+gysANWu5Wd63fz6uR3cLvKb4zQf1xvrv73xZitZjxuL69PeZ8da5MBGH7RIK545AJQoLTIySNnP8u10y7FHmyjY792zPlkIclb9nPloxfwyEX/B8Ckm0Yy7qph6JrG/uQMnr3xfey7wBUfieKseP1cRdOJjgzizmkXERNix13q4u1/fUPi6mR6Du7Itf+axIG9B2nfsxXpew/y5AWv4PV6iUuI4eHPphIUFsTmxYn0H9ebu4c/wcF9B5njnM4462Xc+uq1mMwm3l3zMnkH83norKeZ4/qacdbLAOg2pDPXP32Z/w3Vra9ey4Cz+5KdlkPmvixStu0HIDQyhDvemkyztrFYbGa+fGYGf89YVlP/naKaoltFcnCPDNER1acrOsuW+f62602o9Hg8dOzYEY/HQ1BQEJdddhlTp07liiuuqIn6Tqhly5a0adOG5ORkXxd4hmyzJ6quMKsYXdMIjQkhP0MGvdcHCd1akrbzgK/buxKfTfvWP0lhymvXc9Z1ZzDzvT/LHbN1WRJ3DXkMXddp36cNd7w5mbuGPEqrzi2Y/MJV3DP0MbLScwmNCqGksJRPp31D9yGdefXm/wHQ84zu/hbDPiO6MOaywdw38SWKC0oJjQz2vQvJycNWWAxBlT8P3fbQBFb/vJqf35tHx96tefSDm7lhkK+1qV23eF6+/WPSd2cy7dNbGTqpH/OnL2bKf6/l908XMfvD+Qyc0JeJt/h2vzjync+7937KeVPP5ta+D5zwZzp4Un869G3LTT3uxRZk453VL/pD5W3/vY65nyxg1dz1hEQE8+aKF1g3fxMFOfL3YDSL3UxokxCy9+caXYpoBLRIJ4WFhTRp0oSuXbvWyDmrHSrNZt8p4uLimD9/PjExMWRl1e2epKNHj+b999/H27RUQqWotoN7cohpHSWhsh45cpmyEZcM5vKHzyc0KoSnLn6FbSt3MHhSf8659SysdivB4UGoFWy5GBUXwcOf30nT1tFoHo3m7eMA6DOqB4t/XE5Wmq/1p9IZtLoGuo5WWES/kV2ZO30JxQWlvsfkFIHmm7ijl5SiOCvpktc0eg5oy0vXvIHu9LB93R4K84tp0TYWgB0b95K+OxMtv5BtK3cQ16YpAN2HdubZK14HYPnMNeRnF4JW9cmJPUd0ZeE3i/F6vBTnF7P011X++/qf3Ye2PVsz+YWrADBbTDRr25SC1fL3YLToVpHkZRTgccnEVFF9w27vy4IFCxg1ahQmk6lGzlntUHnddddRWFjIlClTePXVVykpKeGuu+6qidpOWlmo1MNd6FYviqtmfjgiMKXvzCS2fQw7V+41uhQB7N6cQvP2cThC7JQUlrLo2yUs+nYJ/5k/DbPVTGzrGK554hKmnPYQeQfzmTR1HO16JRxznjvemsys9/9kwdeLcYTY+TH7E98dRw+nPN5yQ7qO7vaAp3zXelmg5NDQH93phIKjZo5rGnp2ru/8mgZeL/qh8FkWmt1OD1p+oW9JI6+GyVzxc9nJLiWnHbF+ptV2+On+eGvRqarCfSOfoCiv9jexEKcmrn0M6UmZRpchGgHdpLF4sW/c7pgxY2rsvNUegDhw4EBCQkJo3bo1r732Gu+99x6DBg2qidpOWrNmzejVqxco4G1aWqfXFo1P2vZMmnVsanQZ4pD05AyW/LySqW/ciNXuW/9RURSsdt8ako5QB84SFwU5hdgcVkZdWfFEq6CwIDL3+XpRJtw82n/72j83MuT8gUTFRQAQGhUCuk5xfgmO0Ap6PnSNFbPWMOaSQQSF2kHTCQk2+wMl4AuQbne58Kln56K7XKz/eyvjrh0BmkbHXq0IDnWQmpzhC6xeb4WTcjYt3saZVwwFYODZvQiNDDnmGIDSYic2x+EtHTP2ZNKudwIAQy8Y6L99/cLNnHHpEExmE0FhQZx+zmn++1bMXstF957j/7qigC6M0axjU9KSMowuQzQCWnQpLpeLVq1a0bFjxxo7b5VbKj///PPj3n/11VdX9dRVMm7cONavX483rgTTviCUY5ofhDg56dszGHRRb6PLEEd47db3uOG5K/hg838pziumtNjJugWb2LV+NyWFpaxftJkPN/+XjL0H2bZyR7lgVebTf3/N/R/dTk56LstmrvbfvjdxPx8+8iXPz/GNtywpKOWe4Y+zdv4mLrn/XN5a/jxzP11I8uYU/2PW/rmBPz5bxKu/PYDX42V/UjrPXv1m+QtqGt0GtuPTBQ8T2iSYzzZ04bNnfuCd+z/nnrcnM/baEbhdHl64/m08BcVoxSWVzg57597PePiz25l482g2/LWF7PRc/y5QR/rx9Vm8sfx5Du7L5l/jn+X9h77g39/dR2ZKFokrd/iPW/LzSnqO6Mp7G17hwO5M1i/a4r/v7bs+Zspr1/Pe+ldQVIXMlCwenfBcne2UJioX17Epf3++wugyRCPQbmJztm3bxsSJE6u9i86RFL2KzxQff/zxce+//vrrq1RQVZWWlnLBBRdQWFiIeXMEphxbnV5fNB4Wm5mH59zGi+PfxVVS8SxeESBO5slWUU+4886/59/OM+PeQ6tkcXPN5faN2axkYXObw4qrxImuaXQb0pl737uFG7vdczLfgWgkFFXhkdm38cYVn1KQdZxF+YU4AS3Ejbt3Nlarle+//56IiIgaO3eVWyrrOjSeiN1u5+yzz+a7775Da1YsoVJUmdvpISsll7j2MezdmGp0OcJIJ9jO0deyqKG53BUGS83lpmzOkO7xVBga/YESKg2WbbrHc++htTo9Lg8vX/9WVb4b0YA1iY/AVeqWQCmqbcy/BjFr1izOOOOMGg2UUENLCs2ePZtdu3aVW/z8gQdOvKxFTZs0aZIvVEa60O0elNIa2TBIBKDUxAO06BoroVJUHiyP3FWHY1sgD4dFX0jUNR1d96CYj3pe0rVjvz4yWOoaicuTuLnXfVX/HkSD16JLHKmJB4wuQzRwusXLn3/6llubNGlSjZ+/2hN1XnzxRXbt2sXixYtp27YtO3fuxGo9djxTXWjVqpVvkpACnniZuSiqbu/GVFp2b250GaK+qGgXnaNoLnf5zysIi7qm+1osK3jM0cf6/5WxjAJo1bM5ezemnfhAIY7j4tfH4nK56N69O927d6/x81c7VO7YsYO77rqLoKAgLrzwQv7v//6PPXv21ERtVXLVVb611bSmJehWWctLVM3eDftp1VNCpThCuZbJCu7Tfd3g+qHPKz6HL1hCJcHzqGMlUIoyLXs0Z++G/UaXIRow3aTx008/AXDFFVfU6ASdMtUOlWWtklarlfz8fCwWCwcOGNdE37NnT3r27AkqeFtIa6Womqy9OagmlagW4UaXIuqT44W8Q2FSd51gL3JdQ3M6TxAodQmUws8RaiOqebh0f4tquf6TCygqKiIhIYHBgwfXyjWqHSq7du1KQUEBkyZN4sYbb+Taa6+lT58+NVFblZW1VnrjStDNdbcPuWg8dB1SNqXRsoe0VopTUBYGTxg+j3OMhElxlJY9mpOWlCk76Ygq01Wd7777DvC1Ula061hNqPZMlrLdcyZMmEC/fv0oLi6mbdu21S6sOgYOHEiHDh1ISkrCG1+EeXeoofWIhmnvhlRa92rB+jlbjS5FNEQVTfCpaGzmkcdIoBQVaNWzBXs3Ste3qLprP57E+++/T7NmzRg9evSJH1BFVY6quq7jdDr9XycmJpKZmUlRURElJccuyluXFEVh8uTJAHibF6Pb5N2dOHW7Vu2l7WmtjC5DNGRHhsQTtUxKoBSVaNe/FbtWpZz4QCEqoJs1vvrqKwBuvPFGzEevQFGDqhwq//e///HNN9/4v3788cf54IMPePvtt/niiy9qpLjqGDRokK8bXgVPq0KjyxENUHpSBla7hSYtI4wuRTRkJxMWJVCKSgRFOIhuHcXe9dJSKarmgv8bRVFREe3bt6/VVkqoRqhcuXIll19+uf/rsLAwXnvtNd566y3WrVtXE7VVi6Io3HLLLQBoTUvRgmRnFHFqdB12rd5Lu/6tjS5FCBGg2vZrRcrGVNxOz4kPFuIoutXLDz/8AMDNN99ca2Mpy1Tr7BbL4R0krrzySt8JVZXS0tLqVVVDunbtysiRI33rVrYpREdaA8Sp2blSusCFEMZp178VO1cat0yfaNiGPdILl8tFr169GDhwYK1fr8qhsqioqNwOOmeeeSYATqeTwsL609180003YbFY0CNdaE2cJ36AEEfYtXIvbfrGo5pq992dEEJUpF3/VuxcsdfoMkQDpIW7mDdvHqqqcscdd9TKupRHq/Ir5emnn87LL79cblJOSUkJr776KkOGDKmR4mpCfHy8vxXV07YA3SRLDImTl5dRQN6BAlr3bmF0KUKIABPXPgZFVTiwM9PoUkQDoys6zSb4Vr4577zz6NixY51ct8qh8tZbb8Xr9XLBBRdw4403MnnyZC644AI0TfOPZawvrrzySpo3bw42DW/LIqPLEQ1M4t876TKsndFlCCECTOfh7Uj8Z5fM4xKn7IbPL2Dv3r1ERERw44031tl1qzyv3Gaz8e9//5vU1FR2794NQEJCgi+81TM2m4277rqLhx56CG+LYtQMO2qx5cQPFAJfqLzsuXOY9X8LjS5FCBFAOg9rxx/v/GN0GaKB0W1ePv30UwBuu+02QkPrbq3uag8Ua968OYMHD2bw4MH1MlCWOf300xk2bJhv0k6HfHRF3vqJk5O6LQNdh+admhpdihAiQEQ2CyMiLozda2R9SnHydHS639KKkpISevbsydixY+v0+gE1++Cee+4hNDQUPdSDN166wcXJS/xnJ52lC1wIUUc6DWtH0tJkvB6ZByBOnhZXwpo1a7Db7Tz88MO1voTQ0QIqVEZHR3P33XcD4G1VhBYsa1eKk5P41w66ntHB6DKEEAGi64j2JP690+gyRAOi2zyYu/tyzS233EJ8fHyd1xBQoRJg9OjRjBgxwtcN3lG6wcXJ2b1uP7YQG806xhhdihCikYuICyO2XTTblyQbXYpoIHR0ukyOp7S0lD59+nD++ecbUkfAhUpFUbjvvvuIiIhAD/bgbV1/1tQU9Zeu6Wyat40eYzobXYoQopHrMaYTiX/vlF10xEm75pNzWb9+PQ6Hg4ceeqjOu73LBFyoBIiIiODBBx8EwBtfjDdKFkUXJ7ZxbiI9RndCUWt/AVkhRODqMaYzG/7YZnQZooHQwlx89NFHANx9992GTpoOyFAJMHToUC6++GIAPB3y0G1egysS9V3qtgycxS4S+tT9OBUhRGCIbRdNULid5NWyi444Md2sETHKjKZpjB07lrPPPtvQegI2VIJvAffOnTuDRcfdKU/GV4oT2vjHNnqeJV3gQoja0XNsZzbP347mldcjcXw6Ov3uaU9mZiYtW7bknnvuMbqkwA6VFouFadOmERISgh7mlvGV4oTWz9lK1xHtsQVZjS5FCNHImMwqvcd1Ze3MLUaXIhqA6z47j6VLl2K1WnnyyScJCgoyuqTADpXgW7z9kUceAQ6Nr4wpOcEjRCDLTc9n78Y0eozpZHQpQohGptPQduSm5ZO+Q/b6FsfnjXLy/vvvA3DnnXfSvn17gyvyCfhQCTBs2DCuvvpqwLfbjhYi61eKyq3+ZSP9zu1hdBlCiEam37ndWf3rRqPLEPWc5vBgPc2FrutMmjSJc8891+iS/CRUHnLjjTcydOhQUMHdJRfdKhN3RMW2L0kmpEmwbNsohKgxkc3DadEljk3zthtdiqjHdJNG7CQHxcXF9OrVizvvvNPoksqRUHmIqqo89thjtGnTBmyaL1iqMlBaHEvzaqyduZl+k6S1UghRM/qe051Nf27DVSI9ZaJiuqLT684E9u3bR2xsLE8//TQWi8XossqRUHmEoKAgnn/+ecLDw9FDPXg65qEjwVIca/UvG+l+ZkccoTajSxFCNHBmq4m+E7ux6mfp+hYV09EZ/exprFy5ErvdznPPPUdERITRZR1DQuVRmjdv7k//WrQTT9sCCZbiGHkHCtixYg/9JvU0uhQhRAPXa2wXMnZmyQQdUSlvqyJmzZqFqqpMmzaNDh06GF1ShcxGF1Af9e7dm8cee4xp06ahNS9B85iw7A81uixRzyz7bh2XPDWe5d+txevRjC5H1FOqSS33rxBHUhQYdElf/vzfP/I7IirkaVqEt1URAPfddx+DBw82uKLKKbquSzNcJWbMmMFrr70GwIUXXshpp51mcEVCCCGECBRbtmzhiy++QNd1rrvuOm644QajSzouCZUn8O677/LVV1+BDtbtkZiy7UaXJOqRriM7MOTyfrx/89dGlyLqKdWk8ti8qTwz6k00r7Roi/Ku/M8ktv29S8ZTimN4w53ovQpwu92MHz+ehx56CEVRjC7ruKT7+wRuueUWsrOzmTNnDq4OOZi3RmDKkckZwmfLgu2MvnkICX3i2bVK9uoVldO8moRKUU6zjjE0a9+Urx/5VX43RDlamAu1TzEup5uhQ4dy//331/tACQ1sos6uXbuYMmUKd9xxBw8++CDFxcUAzJs3j9tuu4277rqLAwcOALB06VKmTJnCzJkzq3VNRVF48MEHOfPMM0EFT5dctAhntb8X0ThoXp1/vlzJiGsHGF2KEKKBGX7tQJZ+uwZ3qcfoUkQ9ooW6MA8sxel0MnDgQKZNm4bZ3DDaABtUqGzVqhVvv/02b7zxBl26dOHvv//G4/Hw7bff8vrrrzN58mQ+++wzwBcq33zzTRITE6t9XbPZzGOPPcawYcN8i6N3zUULd1X7vKJxWDtrC5HNw2ndu4XRpQghGojYdtEk9I5nxQ/rjS5F1CNasBvbEDclJSX07duXZ555BqvVanRZJ61Bhcojk3ppaSmtWrVi3759tGnTBovFQo8ePdi1axcAAwYM4Pbbb6dTp5rZo9lsNjNt2jTfrCsJluIIXreXf75axYhrBxpdihCigRh29QCWf78OZ5G8jggfLcSNfbibwsJCevbsyfPPP4/N1rCG2zWoUAmwcuVKbrzxRtauXUuLFi0oKCggKCjIf7/X69tecejQobzzzjtMnDixxq5tsVh48sknGTBgAJh03N1y8EZKV7iANb9uIqZNE1p2b2Z0KUKIei66dSTtB7Rm2XdrjS5F1BNamAvL4FIKCgro1q0bL774Ig6Hw+iyTlmDCJXffPMNd955J9988w39+/fnww8/5IwzzuCXX34hNDTUP7YSwGQy1WotNpuNZ5991t9i6emSi7dJaa1eU9R/HpeXJdNXccYNg4wuRQhRz51x/SBW/Lie0kJplBCghTsxDSihuLiYPn368MorrxAcHGx0WVXSIELlpZdeyuuvv87555/vvy04OBiHw0F8fDy7d+/G7XazceNG2rZtW+v12Gw2nnnmmcOTdzrn4W1aUuvXFfXbyh83EN0qirantTK6FCFEPdWsY1PantaKJdNXG12KqAe8kU6UfsWUlpYycOBAXnrppXK9rw1Nw5hOdMiqVauYPn06qqoSERHBI488gtls5uKLL+bOO+/EarXyr3/9q05qMZvNPP7449jtdmbNmoWnYz6WIBPa7oYzoFbULI/Ly4KPljL61iG8f9NeZAVYIcTRRt86hH++WCmtlAJvTAl61yJcLi/Dhg3jiSeeaFCTcirSoELl4MGDK9yeaNSoUYwaNarO6zGZTDz44IM4HA5mzJhBSXwOJj0I054QFOr/elKi5q2fs5XBl/al25kd2TRvu9HlCCHqkbantSK6VRTTH/7F6FKEgXR0vPHFeBMKwQtjxozxN5I1dA2i+7s+U1WVO++8kxtvvBEAb8tiPB3z0RVppgpEuqbz5/8Wc+ZNgzGZ5c9LCOGjKDDmtqEs+GgpHpfX6HKEQXR0PG0LfIESuPzyy3n00UcbRaAECZU1QlEUrr32Wh555BFMJhNa01Lc3XLQTbJDQiDaviSZgoNFnHZeT6NLEULUEz3GdMZkMbF+zlajSxEG0VWdgY90QmtegqIo3HHHHdx2222oauOJYo3nO6kHzj77bP8yAHqEG3fPbHSbvCMNRL+/sYgR1w0kOKLhLQkhhKhZVoeFMbcN5fc3FqFr0osViHSLlw43xfD3339jsViYNm0aF198sdFl1TgJlTVswIABvPnmmzRp0gQ92IurVzZaqCxuG2hSt2WwddEORt0yxOhShBAGG37tQPZtTmfnyr1GlyIMoAW7iThHZfPmzYSEhPDKK68wcuRIo8uqFRIqa0GHDh149913ad++PVg13D1y8MbKkkOBZt77S+g8rB0tusQaXYoQwiBNWkZy2qQe/P7mX0aXIgzgbVKK6fRiMjIyaNmyJf/73//o3bu30WXVGgmVtSQ2Npa33nqLESNG+Nay7JCPp00BOtL1ESiKc0tY8OFSxt89EkUWAxAiIJ191wiWfrOG3PR8o0sRdUhHx9OyEE+XPEpLSxkwYADvvvsuLVu2NLq0WiWhshY5HA6efPJJbrjhBgC8LYpxd8tFN8sEnkCx+peNmCwm+kzsbnQpQog61nlYO5q0jGTxV6uMLkXUId2kcfqjXfC2LgLg4osv5oUXXiA0NNTgymqfhMpapqoq1113HU8//TR2ux090oWrdxZaiNvo0kQd0Lw6v70yn9G3DCGkScPdJUEIcWrsITbG3zOSWf9dIEsIBRAtyE3Ti20sWrQIs9nMgw8+yB133NFolgw6EQmVdWTEiBG88847tGjRAuwa7p7ZeJsVS3d4ANi3OY0NcxMZf3fjHJgthDjWmNuGsnvtPpKW7Ta6FFFHvDElqKcXsW/fPpo2bcqbb77JxIkTjS6rTkmorEPt2rXj/fffPzzOsl0BerdCWc8yAMx/fwnNO8XSZXg7o0sRQtSyhN7xdB7WjjlvLDK6FFEHdEXH3S4fT6d8nE4n/fv354MPPqBr165Gl1bnJFTWsZCQEJ566immTp2KyWTCHVmMu1c2WpB0hzdmrhI3v/5nHuPvPRN7iM3ocoQQtcRsNXHOg6OY88YiinNl1Y/GTrN7aHNDJFoz34Lm1113HS+99BIRERFGl2YICZUGUBSFSy65hNdff52YmBj0IC/u3tl4pDu8Udu5Yg87V+xh7NThRpcihKglIyefTta+XDb+sc3oUkQt0tHxNi3BPKyYbdu2ERYWxksvvcQNN9yAyWQyujzDSKg0UI8ePfjwww85/fTTQQVvuwI8XXPRLTKou7Ga8/oi2vVvRedh0g0uRGOT0DuePmd347eX5xldiqhFukljyOPd8HTMp6SkhD59+vDxxx8zcOBAo0sznIRKg0VERPDCCy9w9913Y7Va0aJcuPpk4410Gl2aqAWlhU5+fG4u5zwwSmaDC9GI2ENsnP/YWcx8dT75mYVGlyNqiRbqIvI8lQULFmAymbj55pt59dVXiYmJMbq0ekFCZT2gKAoXXHAB77//Pm3btgWrhqdbLu62+eiqdIc3NsmrU9gwN5FJD59ldClCiBoy/p4z2L12H5sXJBldiqgFuqLjaV2At08eBw4coEWLFrz11ltcddVVAd3dfTQJlfVImzZt+N///sdFF10EgNa8BFefLLQw2Tu8sZn33mLCYkLof35Po0sRQlRT91EdadWjBbP+b6HRpYhaoAW7aXFVMN6WxWiaxtixY/nwww8Dcnb3iUiorGdsNht33nkn//nPf2jatCk4vLh75Pi2eJRWy0bD4/Lyw9NzOPOmwcS1l24TIRqqyObhjL9nJD8++zvOImkAaEx0RcfTqhDttDySk5OJjIzk2Wef5dFHHyUoSIYvVURCZT01YMAAPvnkEyZMmADKoS0epdWyUTmw8yB/vruYi58ajy3YanQ5QohTZLaauOTpCSz9Zg171u83uhxRg7RgN62uDcPbqgiv18uZZ57Jp59+yrBhw4wurV6TUFmPhYSE8NBDD/HSSy/5lh4qa7Vsmy8LpjcSq3/ZyP6t6Zz70GijSxFCnKKxd4ygMLuYf75YaXQpooboqm/spHZaHjt27CA8PJwnn3ySadOmBezak6dCQmUDMGjQID755BPGjx/va7VsXoKrbxbeJqVGlyZqwG//mU/TNtEMuLCX0aUIIU5Sj9Gd6Hh6G358Zg66jExqFLQIJ9EXmfG2LMbr9TJixAg+/fRTRo6ULXZPloTKBiI0NJSHH36YV155xbd/uE3D0yUPb498dKusa9mQuUrcfPv4b4y88XTiu8YZXY4Q4gRiEqIYf+9Ivp82i+I8eXPf0OlmDXfHPNzdc0lNTSUmJobnnnuOp59+mqioKKPLa1AkVDYw/fv355NPPuHqq6/GZDLhCS/B1S8LT3PZjachy9ydzcxXFnDpsxMJjQ42uhwhRCUcoTYuf/5cFny4lJRNaUaXI6pBR8cbW4L9LCda01IUReHCCy/k888/Z+jQoUaX1yBJqGyAbDYbN910Ex999BHdu3cHk463bQHu3tkykacB2zRvG+tmb+Gy587BbJV1z4Sob1STwsVPTSB5TQorZqw3uhxRDVqIm3Y3NcHTIZ/8/Hzat2/PO++8w1133SUzu6tBQmUD1qZNG958803uu+8+QkND0UM8uHvm4O6YJ13iDdT895dQmFXEpIfHGF2KEOIoY6cOx2QxMeu/C4wuRVSRbtZwt8/H0yeHrVu3EhQUxJQpU3jvvfdk3ckaIKGygVNVlUmTJvHll19y7rnnoigKWtNSX5d4fBG6Il3iDYmuww9P/05su2iGXtXf6HKEEIf0ndiNTkPa8e1jv+H1yOobDY2OjrdZMdbRJWhxJei6ztixY/niiy+47LLLMJvNRpfYKEiobCQiIiK4//77ef/99+nRo4evSzyh0DdLPKpUxls2IM5iF9Mf+ZXTL+lDt5EdjC5HiIDXrn8rxtw2jOmP/EJRbonR5YhTpEU4aXF1MJ52BRQWFtKhQwfeeustHn30UaKjo40ur1GRUNnIdOzYkTfffJPHHnuMJk2agMOLp2se7h45aCFuo8sTJyknNY/pD//CxAdG0bp3C6PLESJgxXWI4aJp45nx5GwO7DxodDniFGhBbnre0wp391ySk5MJDQ3l3nvv5b333vM1vogap+i6rLDVWBUXF/Pll1/y7bff4nQ6AVAzbZh3h6A4pam/Ieg0pC2THh7Dx3d8R+bubKPLEVWgmlT+vfBOnjrjdTSvdJs2JBFxYdz4ziXMe28J62ZvMboccZJ0qxdPq0L0Zk50XcdsNnPBBRdwzTXXEBYWZnR5jZq0VDZiQUFB3HTTTXz55ZecffbZvvGWMU7feMs2BehmeYGr77Yt3sX8D5Zw1X/Ok6WGhKhDjlAbV758Hit/3CCBsoHQTRqeVoWowwvR4krRdZ2RI0fy+eefM3XqVAmUdUBaKgPIjh07eOedd1i58tCWYh4F0/4gTKlBKF55f1GfnXnTYDoNacsnd35PSb4sttyQSEtlw2N1WLj6lfM5sCuL3/4zz+hyxAnoqm8STkhvE3l5eQB069aN22+/3bfsnqgzEioD0IoVK3jnnXfYuXMnAIpHxXYgDNvBUEoLZJ3L+mrCfWfSonMsn949A2eR/D81FBIqGxaz1cSVL51HUW4JPzw9G80rL5H1la7oaLElRAyycfCgb7xrq1atmDx5MiNGjEBRFIMrDDwSKgOUpmksWLCAjz76iJSUFAAiwiMoXO1FPeBA0eWPsb5RFJj0yFlExUfwxX0/4iqRiVcNgYTKhsNkMXHZsxPxejS+fXym/H/VUzo6WkwpMWcEk5bm29UoLi6O6667jrPOOkuWBzKQhMoA5/F4mDt3Lp988gnp6em+G0tVzCnBqBkSLusb1aRw4b/PxhFu56sHf8bjkkXu6zsJlQ2DalK4aNp4rEFWvn7kF/nbqod0xRcmm40K9zeGREVFcfXVV3POOedgtVoNrlBIqBQAuFwufvvtNz777DOysw/NMnaqmPcF+1ouNQmX9YXJrHLJMxNRVIVvH/tNXvzqOQmV9Z9qUjjvX2MJaxrCl/f/hNvpMbokcQRd0dGalhAzPMTfMhkWFsbll1/OBRdcgMPhMLhCUUZCpSintLSUX375henTp5OVleW70aX6JvSkOVA0mdBTH5itJi59ZiKqSeXrf/0qL4L1mITK+k01qVz473GENAnmqwd/xlks45XrC131jZmMHGQnMzMTgMjISC699FLOO+882aO7HpJQKSrkdDqZPXs2X375JQcOHPDd6D40WzxNZovXByaLiYueOBtHmJ2vHvpZxljWUxIq6y+z1cTFT47H4rAw/eFfcJfKm7P6QFc1vM1KCO9n9fecRUdHc/nll3POOedgt9sNrlBURkKlOC63283cuXP54osv2L9/v+9Gr4Ip3eFbishpMrbAAKeaVM5/bCwRcWF8+cBPlBY6jS5JHEVCZf1ksZm59Llz0LyaDCOpJ3SLF2/zYoK6migoKAB8E3CuvPJKxo0bh81mM7hCcSISKsVJ8Xg8zJ8/n+nTp/uXIkIH9aAN0/5g1EKLsQUGMEVVOPeh0cS2i+bLB36mKKfY6JLEESRU1j+2YCuXP38uJQWlfD9tNl63BEojaUEevC2KUFt48Hh8rcUtWrTgqquuYuzYsTKbuwGRUClOia7rrFy5kq+//ppVq1b5b1dyLb5wmWNFQSb11DVFgbOmDqfT4LZ8cf+PZO/PM7okcYiEyvolNDqYq/5zHmnbM/nlxT/l/8QgOjp6uAtPfDF65OFxrD169ODSSy9lyJAhmEzSE9bQSPwXp0RRFAYMGMCAAQPYsWMH33zzDX/++SfeCDeeiFyUIhOmtCDUDLtM6qlDug6/v/EXBZmF3PDWJXz10M+kbsswuiwh6pXo1pFc9Z/z2TA3kfnvLzG6nICkKzpadCkJE5qyY8cOAFRVZfjw4Vx66aV069bN4ApFdUhLpai2jIwMZsyYwS+//EJRUREAilfBmhWC9WAormzpWqpLPcZ0YvzdI5nx5Gx2rNhjdDkBT1oq64eW3Ztx2fPnsOjj5az4Yb3R5QQc3ebFG1dMaA8rubm5ANjtdiZMmMDFF19M8+bNjS1Q1AgJlaLGFBYWMmvWLH766Sf27dvnv13NtWFOC0LNtUnXeB1p068lFz1xNvPeX8KaXzcZXU5AU00qj82byjOj3pRQaZCuIzsw4d6R/PafeWxdtNPocgKGjo4W7sITVwTRbjTN9/sfExPDeeedx6RJkwgLCzO4SlGTJFSKGqdpGqtWreKHH35g6dKllP2KRUZGMmjQIPr160dwcLDBVQohhKgNpaWlrF69mmXLlvn35Abo27cv559/PkOGDJHJN42UhEpRq1JTU/npp5+YOXOmf4kINDBl2TFlBKHmy8Se2hQU4eDiJ8fjcXuYMW2OLDlkAGmpNIbFbmbSI2OIbBbOt4/9Rl5GodElNWo6OnqIG0/TYiytdUpLSwEICgpi3LhxnHfeeSQkJBhbpKh1EipFnSgtLWXevHn88MMPJCUlHb6jxITpgANThh3FJTP9aoPJrDLhvjNp3asF0x/+hYN7c4wuKaDImMq6F940lMtfOJfs/bn8+Ozvsqh5LdLNGt6mJbQaFUNycrL/9jZt2nD++edz1llnyc43AURCpahTuq6zbds2fvvtN/7880+Kiw+tqaiDmm1FPeBAzZaxl7Vh4EW9OeP6Qfz68jy2LEw68QNEjZBQWbfaD2jN+Y+NZeWPG1j0yTLkFa7m6ejoES68cSWocV7/2pI2m40zzjiDCRMm0KtXLxRFnscDjYRKYZiSkhIWLlzIzJkz2bBhw+E7XCqmA3bUTAdqsYy7qUmtejbn4ifHs3lBEn+8/Tdej4Sc2iahsm4oqsIZ1w/ktPN68uMzc9mxfLfRJTU6us2DN7aUJqcFk5FxeMmyTp06MXHiREaNGkVISIiBFQqjSagU9cKePXuYOXMmc+bM8S83AaAUmlEz7Jgy7Shu6R6vCcGRQVz4xDisdgvf/XsWeRkFRpfUqEmorH3BEQ4ufOJsrEFWvvv3TPIOyO90TdHNGlp0Kd6mpehhbv/toaGhnHXWWUyYMIH27dsbWKGoTyRUinrF7XazePFifv/9d5YtW4bXe2iNSx2UXCumDDtqlk0WVq8mX6vOIE47rwc/P/8H25ckn/hBokokVNauhN7xXPDvcWxdlMTct6T1vSboqo4W5URrWoIS4/U/D6uqSt++fZkwYQJDhw6VvbjFMSRUinorNzeXhQsX8vvvv7N58+bDd3gVLHkOrDkhmAvsMqO5GtoNaM15/zqLxL93MvfNv3A7ZUJDTZNQWTtMZpWRkwfTd0I3fntlvowTrqaybRO9TUuxt1EPj3cHOnbsyJgxYxg1ahTR0dEGVinqOwmVokHYv38/f/zxB3Pnzi23sHpwUDAlyV5f93ieFUWXgeGnKijCwbkPjia6VSQznppD2nbZ3rEmSaisedGtI7nw32dTkl/KT8/NJT9TlguqCl+QdONtUkpEdwfZ2dn+++Li4hgzZgxjxoyRpYDESZNQKRoUXdfZunUrc+fOZcGCBeTkHLE8jltBzbahHrSj5krAPFV9J3ZjzJRhLJm+msVfrULzylNDTZBQWXMUBfqf34szJw9m0afLWfbtGpndfYr8LZLRTsK72ss9h4aGhnLmmWcyZswYunfvjqrKMCNxaiRUigbL6/WyYcMGFixYwF9//VXuXTYeBTVLAuapioqP4Px/nYXJYuLnF/7gwM6DJ36QOC4JlTWjScsIzn1wNLZgGz8++7v8bp4CXTkcJEM7WcnLy/PfFxoayrBhwzjjjDPo168fFovFwEpFQyehUjQKXq+XjRs3Mn/+/IoDZo7V14qZY0PxyLvv41FUhQHn9+KMGwexYsZ6/vpsBV631+iyGiwJldWjmhROv7Qvw64awOLpq1j81Wr5OZ4E3aShRbjQmjgJaW8lPz/ff194eLg/SPbt21e2TBQ1RkKlqNTatWv59NNP8Xq9XHLJJQwbNox58+bx/fffY7Va+de//kVsbCxLly7l888/Z8KECUyYMMHosv0Bc8GCBSxatKh8wNRBybOgZtswZdlQnPJkWpmIZmGc88AowmJC+OXFP0nZlGZ0SQ2ShMqqi20XzaSHx+D1aPzy4h9k7s4+8YMCmG7zokU58UY5MTfVcbsPLwEUERHB8OHDOeOMM+jdu3e9CpIN9bVGHKv+/FaJesXpdPLNN9/w8ssv+7tDPB4P3377LW+++SaJiYl89tlnPPDAAyxdupQ333yT//73v/XiD91kMtG7d2969+7NXXfdRWJiIosXL+aff/4hOTkZPcKNN8KNt20hSpHJ14KZbUMpsMhOPkfITcvn83t/pM/4rlz+/LlsW7yLP9/9h6LcEqNLE42cPcTGyBsH0XNsFxZ9vJzlM9aha9L+cTTfftse3/I/UU70kMOrN7jd0KJFC4YOHcqQIUPo3r17vQqSZRrya404Vv37DRP1wqZNm7DZbDz88MPY7XbuvfdeCgoKaNOmDRaLhR49evD2228DMGDAAG6//fZ6+Ueuqipdu3ala9eu3HTTTaSmpvoD5vr169GCvXiDi/G2LPZN9Mm1oubYUHOsstj6IWtnbSHxn12MunkIt39xDQs/WsaqnzfIRB5R4xQFep3dldG3DGHXqhTevvpzCrKKjC6rXtHNGlqEEy3SRWTXYLKyDrfeqqpK9+7dGTJkCIMHD6ZVq1b1fqvExvJaI3wkVIoK5eTkkJaWxltvvcXq1av5+OOPGTt2LEFBQf5jyhbEHTp0KEOHDjWq1FPSvHlzLr74Yi6++GIKCgpYtmwZixcvZvny5RQVFaHFONFifOteKoVm31jMXBtKviWgJ/uU5Jfy23/msebXjYy/90z6TuzOrP9bwN4NqUaXJhqJZh2bMv6ekVgdFr57YhZ71u03uqR6QUdHD3P7xkdGOiHMS9motaysUhwOBwMGDGDw4MGcfvrpREREGFvwKWqsrzWBSkKlKOebb75h8eLFnHbaafTo0QOLxULfvn354osvCA0NLbcgrsnUsFvyQkND/euweTwetmzZwvLly1m5ciWJiYnoIR68IR5fK6ZXwVxox5LvwJOhoJSYArKrPHVbBh/e+jV9JnTjkqcmkLI5jXn/W8zBvTknfrAQFYiIC+PMmwbTfmBr/vp0BSt+WB/wY091m9ffGulobaao6IjWWh3atm3LgAEDGDBgAD169GiQO9sE0mtNIJFQKcq59NJLufTSS8nLy+Opp54CICkpiebNmxMfH8/u3btxu90kJibStm1bg6utOWazmZ49e9KzZ09uuukmcnJyWLlyJStWrGDFihXk5ubiCS/BE14CLQGnippn9X3kWlGcgfOkp+uw5rfNbJq3ncGX9WPyu5excd42Fn28jMLs4hOfQAjAEWpj2DUD6DuxO6t/3cgbl39CSUFg7o6lW71o4S5fa2S4C+yHQ3VRkZOwsDBOO+00BgwYQP/+/YmJiTGw2poRqK81jZ3M/haV+uGHH5g/fz6qqvLwww/TvHnzCmfkNXaappGUlMSKFStYtWoVmzdvxuVylT+oVPWNxzwUNBVX4ITMkCZBnHHdILqP6sTyGetY9u2agA0HFZHZ3+VZHRYGXNibwZf1JWnZbhZ8sJTc9PwTP7AR0S1lIdKNHu5Cd5RfsstkMtGlSxd/a2SnTp0adWudvNY0HhIqhThFTqeTTZs2sWbNGtauXcvWrVv9Y37KKMUmlHwLar7VNx6ztPF3l0e3iuSMGwbRbkBrVsxYL+HyEAmVPv4weWlfUjalsuCjZaQnZRpdVq3T0cGmoYW50MIOhcig8s8XqqrSsWNH+vTpQ58+fejZs2e5MYVCNBQSKoWopuLiYjZu3OgPmdu3b0fTjgoPLhU134JSYPG1ZBaZG+3En5iEKIZfO5AOAxNY8cM6ln67lpL8UqPLMkygh0pbkJUBF/bi9Ev6sndjKos+Wd6o95f3L/MT5kYP9QVJbOX/3xVFoX379v4Q2atXL0JCQgyqWIiaI6FSiBpWUFDAxo0b/R+JiYnHdpd7QSk83JKpFpob3RJG/nA5KIH1c7aw7Nu15KQFVjcnBG6oDI0OZuBFfeh3bnf2rNvPok+Wkba98bVM6mYNPcSNFuZGC3NhizNRWlr+TZTJZKJjx4706NGDnj170rt3b8LCwgyqWIjaI6FSiFrmcrnYtm0bmzZtYsOGDWzatKnc3rt+pSpq4aHWzEILSqEZxdvwt5SMbB7OoEv60HtcF3as2MPSr9ewb0u60WXVmUALlbHtohl8WV86D2/P5vnbWfrNmkazE46u6r4AGeJGD3WjhXjAcewWpiEhIXTv3p0ePXrQo0cPOnfujN1uN6BiIeqWhEoh6piu6+zdu5eNGzeyadMmtm7dyu7duznmT1E/NDaz0IJaYMHuDcZUavV3m5cUNqwuZUeojf9v7+5jozgPPI7/npn1y9oYDLbBS8A275AAuYQGouqUqqEpvqAop6DSRPdPVen+aBU1aRUpVaUqUqsqUhu1UVVSKWqlJopSoqpNGrVSTHLlkl5TAUcgkMO8hhgwXoOxMcb2eu2d5/6Y3dldvwEZYNf29yONZvZ55pl9Fj+sf97ZeeYL/75eG7f9i3rO92rvHz9W6wcnp/19xWdCqHRco5VfXKqNj92t+uV12vfWIe178+MpORtAdJYf/qyxSpUnlXD70yFyRKbKG/vVFvl3rlm7dm0QJJuamuQ4U/8PQuBGESqBIjAwMKBjx46ptbVVR48eVWtrqzo7O8fs5ziOYvUL1bioUXve+Ng/bd5fIjMydX6BuSWu1m5eqS88ul7zFs3Rgb8e0f63D6vn/Dif3k4D0zlUzplfpXsfuUv3bF2rgcuD2vfWIR1qadXw0Mi1GxcR63qylSPyZo3oi/9xj86ca1N7R7tGRsa+jpqaGq1Zs0arV68O1lVVVQXoNVB8CJVAkbp06VIQMFtbW3X8+PHxT5tL/ryZ/RGZqyX+RUD9kSlxxXn98jpteHSd1n1lldqPxPXRX/9Px/7nlEaS0+fTy+kWKt0SVyvub9I9D9+ppnsX68juE/rftw+rfQp8pSG4ErtyWHbWiB8kK4fz5oXMNWvWLK1evTovQE6HOSKBW4VQCUwR1lp1dXXp5MmTOnHihE6cOKGTJ0+qvX2C29l5khlMB8wBV2Yg4i9FGDZLoyVa95VVuvvf7tT8JTVq/eCkDrW06rOD7bLe1H6Lmi6hsmHdQq3/6mrd9eBK9Zzv1cfvtOrjllYlrhbftFF+eEzJq0zJRkdkKzJLSnLHH0/19fVavnx53hKLxYr+3tlAMSFUAlNcf3+/Tp06lRc029raNDQ0wS97T9mAOeD6wTORXnuF/wU6NzZb6766WndvWaOSsogO/9cxHfnvkzrfGtdUfLeayqGyfkWd7vzScq17aLWMMTq0q1WH3j2qrrbiuC2nNVY2mpIt9wNjEB6jI9IEkymUlJSoqakpCI4rVqzQsmXLOIUN3ASESmAaSqVS6uzs1OnTp3X69Gm1tbUF6wnDpiQNOf59zYOgmbNdgHk1F65eoPUPrdbqB5bJcR0d/fspHf3gpD472D5lAtpUCpXGMVq8NqY1X1qu1f+6TJGyiI7+/ZQOv3tUZw+fL0iot8bKlqey4TGa3TZRO/YCt7TS0lI1NDSoqalJjY2NWrJkiZqamrRw4UJFItyhGLgVCJXADDJe2Dx37pzOnTs38fc1JcnKD5wJV2bI9dc520o6t/yUemzlfK15YJlWP7BcVTWVOrnnM53c26ZP951R36X+W/rcYRR7qKysjmrpFxq0bGOjlm9q1FB/Ukf/fkqtH5xS+5GOWx4kraxU6smWpfzwWOal1354dCrsuFdcB/2vrNSiRYvU2NgYBMhMeJzOtzYEihGhEoAk6cqVK0HAPHv2bN56YOAaU8N4koZcRUZK5CQjcpKuzHBEI1dSUtKVGXKklLlpwbNmcbWWb2zSsk2Narr7DvV0XNGpfW06tbdNZz/pUHJw+KY8z81QbKEyUupq0V0xLdvYqGX3NaiucZ7OHDqvU/vadHJPmy6cvnRTn8+6nmypJ5WmVDLblVc6Iq80Ja90RKnIsGxZSrrG5AXRaFSLFi0ad6muruZ7j0CRIFQCmJS1Vt3d3Wpvb1c8HldHR4fi8XjeMvre5+NKSSbp+p94Jl2ZpCMN+Wsz7Pifdg7fePh0S1wtXhvT8o2NWraxUXVN89R5qktnD3fozOF2nTl8XlcvFW6+xEKHyorqqBrWLdTidTE1rLtDsRV1unTush/C953RmY/bb3gKICvrX/AS8QOjHxo92dL0J43pEGlLPSly7V8xruuqrq5O9fX1wRKLxRSLxbRo0SLV1NQQHIEpgFAJIJRUKqWurq4xgbOrq0sXL15UV1eX+vr6rv+AnqTh/KBphp1s2YgjM2Ky62En7/ueZZWlWnRXTA3pEHXHnfXq7xlQx/EL6eWiOo5fUH/P7QmatzNUVswpV/2K+YqtnK/YyjrFVs7X7PlVOt8a15lPOnTmULvOfdKhwb7879Vakw6IkZx1iSdb4o1ZZ7YnuhBmPJWVlaqtrVVdXZ3q6uoUi8W0YMECxWIx1dfXq7a2lu85AtMAoRLALZdIJNTV1RUEzcySKbt8+bJ6enqufZp9IimNDZsj/qeejnU0a84sVdfN1rz6uaq9Y57mN9RKKaOrFwfVf2FAV+L9utx+Rd1nrujKhT7pJl6UdCtC5azaCtU2ztXcO+Zo9sJZml1foVnzK+SWObpwpksXz15SV3u3ei5c1pXuPnnyJDcnNLr5IfJGAmKusrIyzZ07VzU1NaqtrQ2Wurq6YF1TU6OKioqb8roBFDdCJYCiMTQ0FATMnp4eXb58Wd3d3cF2T0+P+vr61NfXp6tXr6qvr2/Sizg+L9dx5TiuHGNkrCN5kh2RbMrKjkjeiJWXsv6tNDPvoNb4FzRJ/jodTI2M1n11lQ6/e9Q/bewX5qytlG7quEZOiZGJGDkRf23c9BXQxspaTykvpZGRlLJPdnMYY1RZWamqqipVVVVpzpw5mjt3rqqrqydcR6PRm9oHAFMboRLAlOV5ngYGBoKgOXoZHBzUwMCABgcHr7k9Vd8KHcdRNBq9rqWqqkqzZs0KgmPudmVlJferBhAKoRLAjGet1fDwsJLJZLDOLOOVDw8Py/M8eZ4na61SqZSstUHZ6MUYI8dx5DhO3nbu48w6EomopKREJSUlKi0tHXed2c4sXMQCoBgQKgEAABAa5zoAAAAQGqESAAAAoREqAQAAEBqhEgAAAKERKgEAABAaoRIAAAChESoBAAAQGqESAAAAoREqAQAAEBqhEgAAAKERKgEAABAaoRIAAAChESoBAAAQGqESAAAAoREqAQAAEBqhEgAAAKERKgEAABAaoRIAAAChESoBAAAQGqESAAAAoREqAQAAEBqhEgAAAKERKgEAABAaoRIAAAChESoBAAAQWqTQHQCKgbVWiUSi0N0AgBtSXl4uY0yhuwFIIlQCkqREIqEtW7YUuhsAcENaWloUjUYL3Q1AEqe/AQAAcBPwSSUwSune+TI2/feWcWQcIxlHcoxkjIyTqUuXGyM5RiazT1BngjbBIuWUZY8ZtFG2jTUm+2dfzjGC8px2uWU2fZigzpGkTLkJ6jJtbLosqJeyx3DS+wdt8p8jr43SZc44dXn7K6+P2TIzpm5MG+W3yatXts1Ez5X3eIJ+jGkz2XGDcpvXfvTxgvqcY9l0uUa1k7E57f16k1sX7Jups8ExTe7+6XJjbHb4pcuzw8MG9Y5s8Nivk5z0Y7/Of5xpF9QZK6NsOyddFiyyQTvHKK8828bL7isrx3hyM3Xpx9ljecHx3Jzju/LLXeONaufJzRxT2ecL9lf2eI789o785/fr/OO56TIjT26mvTL98ORKfjv5z5N5bZnH/nPZ9LbSdVZO+t/FlZEjyU3/sB2ZdJmRa4yc9JuBkdFw0tW2/6wXUGwIlcBoKZN+e5cfKpUOgOnf1tk6IznZBGX8hJY+SCZ5ONntMWnDGZt4jBm7f+7xNGr/vLrR2zn7ZMJkTqgcU5YTAnMfj+5i/v7jtHEmqZvoZYx33InaTVZ+3c91Y8ccN8TmtbvJoXK8eo1+bINj5/Yj9znz24wKoUFdbr0d53h2nOeyeUtuqMwG1fQyUd14YVOZMKq8oJd57Cq/zg+VXjaUmdxQ5m87xviBL71WsG2CdtkAK7kmu3alnAA4Tl36eP5jmw6lNgiRfjt7zVCZezw3XecovywTYJ306waKEae/AQAAEBqhEgAAAKERKgEAABAaoRIAAAChESoBAAAQGqESAAAAoREqAQAAEBrzVAKjuVbW+hMe+/Mumpy1GTUheWads63cMpuzPUldpjxn0sLsFNWaoDy7tnnbymtnJclmyrPHtDKSVdA2tz44Rt7kirl9GeexzevSqH+PCZbR+15r7khNUH6tusnmopysLvcVTtpuvPkmcxc7QR8nnvw8f27JnLpg388/+Xm2HznzVOrzz1NplW1njc1f5K/9OuWVe8HxvOzzyErGy5lP0+bVW+MFx1Pe8dPrzHOlHzvpfTJrSWPKvJy5IT2TXXvKzlPppcuMJpqn0gQTlrvK/swyj510m9FzX17/5Ocm/WMxGk6O9/8SKDxCJTBKcuOFQnfh1sj8zg5hdJwFpPyh5RWyI59b7sjmBB7wefG/B5CUSCQK3QUAAKY0PqkEJJWVlQXbf/7zn1VeXl7A3mCqSyQSevTRRyUxnhDOtcYSYwvFhFAJSDIme0K3vLxc0Wi0gL3BdMJ4ws3CWEKx4/Q3AAAAQiNUAgAAIDRCJQAAAEIjVAIAACA0Y60NOXMdAAAAZjo+qQQAAEBohEoAAACERqgEAABAaIRKAAAAhEaoBAAAQGiESgAAAIRGqAQAAEBohEoAAACERqgEAABAaJFCdwAotIGBAe3cuVPvv/++4vG4HMfR4sWL9eCDD2rbtm0qKSkpdBdRYIlEQgcPHtSxY8d0/PhxHT9+XJ2dnZKkb3zjG/rmN795zWN0d3fr9ddf1z//+U91dnaqrKxMS5YsUXNzs7Zu3SpjzK1+GSgSvb29+sc//qH9+/cHYymVSqm6ulqrVq1Sc3OzHnjggUmPwXhCMeI2jZjR4vG4vvOd7ygej0uSysvL5XmeksmkJGnFihV68cUXVVVVVchuosAOHDigp556aty66wmVx44d0zPPPKPe3l5JUjQaVTKZVCqVkiTdd999ev7551VaWnpzO46i9OUvfzn42UtSaWmpXNfV4OBgULZp0yb9+Mc/Vnl5+Zj2jCcUK05/Y8ZKpVL6/ve/r3g8rpqaGv385z/Xrl27tGvXLj333HOqqKjQiRMn9KMf/ajQXUURqKqq0oYNG/TEE0/oueee07x5866r3dWrV/Xss8+qt7dXDQ0Nevnll9XS0qJdu3bp6aefViQS0b59+/SrX/3qFr8CFItUKqU1a9boe9/7nnbu3Kn33ntPLS0teuONN7R161ZJ0p49e/TCCy+Mact4QjHjk0rMWH/5y1/005/+VJL00ksvae3atXn17733XhAof/GLX2jDhg23vY8oDqlUSq7r5pVt375d8Xj8mp9U/uY3v9Grr76qsrIyvfLKK1q4cGFe/WuvvaaXX35Zruvq1Vdf1eLFi2/Ja0Dx+Oijj3TvvfdOWP/CCy/o7bffliT94Q9/0IIFC4I6xhOKGZ9UYsZ65513JEn33HPPmEApSZs3b1YsFsvbFzPT6EB5I1paWiT542l0AJCkxx57TNFoVKlUSu++++7nfh5MHZMFSknBp5WSf6o7F+MJxYxQiRkpkUjok08+kSTdf//94+5jjNGmTZskSfv27bttfcP0cebMmeCCnsxYGq2iokLr16+XxDiDL/e7kJ7nBduMJxQ7QiVmpLa2tuDNesmSJRPul6nr7u7WlStXbkvfMH18+umnwfZk42zp0qWSpM8+++xWdwlTwMGDB4PtzNiQGE8ofoRKzEhdXV3Bdl1d3YT71dbWjtsGuB6XLl0Ktq9nnPX392tgYOCW9wvFq6+vT6+99pokaf369WpoaAjqGE8odoRKzEi5b7RlZWUT7pc7nQdvzrhRjDPcCM/z9JOf/ESXLl1SaWmpnn766bx6xhOKHaESAIAi8Mtf/lIffvihJOm73/2uli9fXuAeATeGUIkZqaKiItgeGhqacL9EIjFuG+B6MM5wvXbs2KE//elPkqQnn3wy7wrwDMYTih2hEjNS7nclL168OOF+ud+jzG0DXI+amppg+3rGWWVlJSFgBvr1r3+tN954Q5L0rW99S9u3bx93P8YTih2hEjNSY2OjHMcf/qdPn55wv0zdvHnzNHv27NvSN0wfuVfuTjbOMlf1NjU13eouoci89NJL+v3vfy/JD5RPPPHEhPsynlDsCJWYkcrLy4MJz/fs2TPuPtZa7d27V5J/L13gRjU0NAR3Q5lonA0ODurQoUOSGGczzY4dO7Rz505J1w6UEuMJxY9QiRmrublZknTgwAEdOXJkTP3u3bt1/vz5vH2BG7VlyxZJ0t/+9jd1dHSMqX/zzTc1ODgo13X10EMP3e7uoUB27NgRnPL+9re/fc1AmcF4QjEjVGLGam5u1tKlS2Wt1Q9/+EPt379fkj+tx+7du/Wzn/1Mkn/nCu77jb6+Pl2+fDlYMpPnDw0N5ZWPnsLl8ccf17x585RIJPTss88Gt90bHh7WW2+9pd/+9reSpEceeYT7NM8Qud+hfPLJJ/X4449fd1vGE4qZsdbaQncCKJSOjg499dRTisfjkvzT4p7nKZlMSpJWrFihF198UVVVVYXsJorA9u3bg3EymebmZv3gBz/IKzt27JieeeYZ9fb2SvKvyE0mkxoZGZHkn6Z8/vnn827Ph+mps7NTX/va1yRJjuOourp60v2//vWvj/kUk/GEYhUpdAeAQorFYvrd736nnTt36v3331c8HlckEtGSJUu0efNmbdu2TSUlJYXuJqa4VatW6ZVXXtHrr7+uDz/8UBcuXFB5ebmWLl2q5uZmPfzww8GFY5jecu/l7Xmeuru7J91/cHBwTBnjCcWKTyoBAAAQGn/KAAAAIDRCJQAAAEIjVAIAACA0QiUAAABCI1QCAAAgNEIlAAAAQiNUAgAAIDRCJQAAAEIjVAIAACA0QiUAAABCI1QCAAAgNEIlAAAAQiNUAgAAIDRCJQAAAEIjVAIAACA0QiUAAABCI1QCAAAgNEIlAAAAQvt/fJZd8m4UyQ8AAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
    " ] @@ -686,397 +946,160 @@ "lon.set_ticklabel_visible(True)\n", "lon.set_ticks(color='white',alpha=0.6)\n", "lat.set_ticks(color='white',alpha=0.6)\n", - "lon.set_ticklabel(color='white',fontsize=4)\n", - "lat.set_ticklabel(fontsize=4)\n", - "lat.set_ticks_visible(True)\n", - "lat.set_ticklabel_visible(True)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1e-50, 1)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAGyCAYAAADERJFvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAADu4klEQVR4nOy9f5ydVXUu/pxJCEkgBGVaElACCf5CKZUCN4pRJGCFi3j9WJXKBSOl2tbehuot9tI0IdygFTVw6w/8ClhorRaUqiHYWMAAQQENoBIpIZAw/BxCQjL5MZlMZuZ8/5jMOe+793r2fs4+k8yv/fiRzNnv2muv85733fvZa629d6VarVaRkZGRkZGRkZHREFqG2oCMjIyMjIyMjJGITKIyMjIyMjIyMhKQSVRGRkZGRkZGRgIyicrIyMjIyMjISEAmURkZGRkZGRkZCcgkKiMjIyMjIyMjAZlEZWRkZGRkZGQkIJOofYiuri6sXbsWXV1dQ21KRkZGRkZGxiAjk6h9iLa2Nvzpn/4p2trahtqUjIyMjIyMjEFGJlEZGRkZGRkZGQnIJCojIyMjIyMjIwGZRGVkZGRkZGRkJCCTqIyMjIyMjIyMBGQSlZGRkZGRkZGRgEyiMjIyMgYB3bt6sPnpbahWq0NtSkZGxn5CJlEZGRljFp1buvDbn7Rh+8ZOKtPb04dH/v1JPHr7BkqQ+vqquP2KB/CDy36GR37wZNN29ezuRW9PX9N6MjIy9i0yicrIyBizuOcbv8H9Nz2G//zyQ1TmtyuexkPfX4cH//VxPPPwRlNmyzPbsbltOwDg4e9zEvXSE1tw8yV3495vPkpldmzahe/+r5X4zl/8FDtfyRv1ZmQMZ2QSRdDd3Y3Pf/7z+OAHP4j3vve9+LM/+zM8+ijv+DIyMoYXXnlmO559ZCP6+nh47flHNwMAtjy7g3qZfnPb+trf6+9/0ZTp3dMr2XTb5Q9g+8ZdeOLu57D9Zdv79asfPoXdO/Zg9449uO+GNZLejIyMoUEmUQS9vb2YPn06vv71r+PHP/4x3v/+9+Oyyy7LR7hkZIwAdHbsxo/+/uf4yRcfwlM/f0Gqs6fLJkI93fWw2rgJ40yZ3p7G86BYe13bu2t/b96wjdbv6+nDK89uzzlYGRlDiEyiCCZNmoR58+bh8MMPR0tLC8466yz09fXhueeeG2rTMjLGNLa9tBN3XP0wHr19A5VZu/JZ9O7pJz/3fP03pkzV8VD17LZJTaUStyklf2nAPhcHTBxft6mbe7hWfGE1/v2z92H1zU8E2ujFk/c9j01PdzRsX0ZGRhzj4yJDi87OTtx0001Yt24d1q1bh46ODsybNw8XXXSRKXv99ddj5cqV2L59O4466iicf/75mDt3btN2tLW1Yffu3TjiiCOa1pWRkZGOu7/2G2x8civafvkSXvvW38GhRxzsCwmcxiU+fb12pUpLnUVVe0lieQqJIgRp3IT63JaRqL6+Kl74bX8o8tfL1uPk895gyv32P5/BL/71cQDA//z/5mLilAkN25mRkcEx7D1RHR0duO2227Bnzx7MmTMnKLtgwQKsWLEC8+bNw1VXXYU3vvGNWLx4Me64446mbOjq6sKVV16JCy+8EJMnT25KV0ZGRnPY+OTW2t9bn99hyighLpf4MIJUEVxRKSQq5GWKta22N0CgAOCZR+yk+IyMjHQMe0/UtGnTcPvtt6NSqWDr1q1Yvny5KXf//fdj9erVWLhwIc444wwAwIknnoj29nZce+21OP300zFuXH8+wyWXXII1a+yEzfPOOw8XX3xx7XNPTw8WLVqEGTNm4IILLgjaumnTJmzevLn2ua2traHvmpEx1tHXV0XnK104uHWSJJ+Si1Sv63qibF0lQkb4FAvNhcBIG4rFpD03FKmAhSszMjLSMexJlDILBIBVq1Zh0qRJOO2000rlZ599Nq644go89thjOP744wEA11xzjaSzr68PV155JVpaWvDZz342asuyZctw4403SrozMjJ8rPiHX+KFNZtxyvlvxO/992Oi8i3El655j8pEhIXzFLi6pDqECBVJG/dEObb3VdHSEv7Ovd38+1WrVfT1VjFu/LAPTmRkDCsMexKlYsOGDZgxYwbGjy9/pVmzZtWuD5AoFV/60pewefNmfPGLX/T0Wjj33HNx6qmn1j63tbVhyZIlDbWZkTFW0b2rBy+s6ffk/uJfH5dIFMv6rqLxcB73REWbQ28CAWPeJKU9l/D1dveiZWK4jwrlVy1f/AC2Pr8D7/3sSfjd170qqCcjI6OOUUOiOjo6zKTvKVOmAAC2beNLhS20t7dj+fLlmDBhAs4999xa+VVXXYUTTjjBrNPa2orW1taG2snIGCuo9lWBSvN5PqU6SkiMwA3B0fAa4qymz9XVVy0lpJt1qO1Ce07d3j19OGBisLnSVg1FPPPQS9i4bisA4Mef+yXm/dN7wooyMjJqGDUkCtBDfwqmTZuGe++9d9D0ZWSMZex8pQvLr3gA4w4Yh3MXz8aEyQd4MinbBLAQnLJ1kus9ouE8RZfr1eqrYlyERFFPVEEV90SV66bkSA1g9849tb9DeVObn96GNSuexqxTj8Brjs+TxYwMYASszlMxdepUdHT4e6Fs395/FMMhhxyyv03KyMjYiwf/9XFs37gLW5/fgYe+t86Ucb05Crj3KA4/J6qJ8JpLogRCyHKiioSMebNcwhfalb2mi9jeIuZBLbv8fqy793ms+PwvJfmMjLGAUUOiZs6ciba2NvT09JTK16/vP7LhmGOE/IqMjIx9guJWBJuf2W7K9CSQKCkkRuCG86iuEsREb0GXsueU7IlS2iMiajJ5MTE975KekdGPUUOi5syZg127duGee+4pla9YsQKtra047rjjhsiyjIyM4gaS7Jy5FE9UM+E8P7Gc6SoqE7ZBgE1qXG8RC8EVCRL7Hq6tSjiPfb+UFXkpWzpkZIxGjIicqAceeABdXV3o7Ow/sLOtrQ133303AGD27NmYOHEiZs+ejZNOOglLly5FZ2cnjjzySNx111148MEHsWDBgtoeURkZGUOA0lZLxJuTkNfDPD7KdgXqZptF23keU3y7hKoYglO8PK6tzXi+2F5UIfR092I8OUcwI2MsYUSQqKVLl6K9vb32eeXKlVi5ciUA4Oabb8b06dMBAEuWLMF1112HG264oXbsy6JFiwbl2JeMjAwbzzy8EQ/fug5vOuMovOHdrzVlSnlFLM8nIbGch8QEUuERnzipUfKmAJsgqSG4ol2Kt4q1F6sTKw8htOdURsZYwoggUbfccoskN3nyZMyfPx/z58/fxxZlZGQM4D+/9BAAYNV1aziJKgzyFRI9krwp1bjHB9BIhUJ8+gULf6qeKIPEWRtk2rqKNmpn9Sk5UfReDeKRNb17erH6lnVoGd+CP/jQ66IbgGZkjHSMCBKVkZExMlCtVs2tRkq7cIsrzkz9ogdGIQY+8SE5UUJ7Xk6U5Ynq04hPUVeVfI2ULQ72hyfqtz9pw6O3bwAAHNw6EW+ae1TDujMyRhJGTWJ5RkbG0IMSkdLeR9oGkha8/ZhI2C7Jq6V4omgIzm3fyIlyZQSvFg3nuQRQ8bw1kT/mgnminvzZC7W/19//YsN6MzJGGjKJysjIoKhWqw2Fe9iu2BAO8XUHeSuUJe/tlLDkv0oIWZHzqZ4oS07xVrl2sXBe1QvnCYn0LJynhAIdWxmJKobvUjxcGRkjDZlEZWRkmOjr7cNtix7Av/7FT/Hyen8jWwu9ZHCVDtV1l+0bY7AXEutjxCAhnMdWxRXMVXOiYDXvbnEg7HFFtzjwPFG2XEmmiSR8l0izcF5lXP1mhYjsi//1yt4NWDujbWdkDGdkEpWRkWGibfVL2PjkVuzesQcr/kHbpVpJllYTyy3vipcM3kw4zyM+zBMVJwaeV8v0RDnNKaE69jW89tJ3SFfquvtCcU9U/ccNhStv/78P4tHbN9QWJWRkjFRkEpWRkWFi98767v+7d+wJSNahJEurBxCbSdViLlDK6jy6PZMQzvO8TIYyNZxnerEiuqSQHAnLpnmibBJV9EQxb2Axr23LcztMmYyMkYJMojIyMkyMn9B496AkZ7OcKC9EZSZnayvqmFcppIvlH5U8USJps1T5yedCfhXLiXIJYIrnLWJHSIYd0VPMiWI25d3OM0YTMonKyMgYNCgbSDIoG0iqR7YpcqpnqJRYLuxqznTJieXF1XlV4tUSj5Apgoc+B287iJZx8cRyd4VlRsZIRiZRGRkZJlKICF+9Vvhb3NupKSIiHZ7n1GFju5ATpZyLpxIfz3TLqyXmV5Vk2NmAiu0q4RTCeSmbe2ZkDFdkEpWRMUaxc0tX2Cug8BBx00fl6BTlWBQ/BGfbRQlRsT2XGFDiVfAMsZvi6YqKaOE8ZldCThS7J1JSvHhEDst3KyKH8zJGEzKJysgYg9jwi3Z89y9X4t8/ex/3UAjeHPX4kRQSZYbzPO+RRmrsBtXwWrGO1pxCfGi+0yB5tSQyZtRt5r6nLCDIyBjJyCQqI2MM4q5rHgGqQMeLO/HcrzeZMspgp54HV4GwTYC7T5TliRLDSoO5Oq90DEtTxEdsT5CTSI3gYbL0NxPOU6DmRG15bjuWLbwfD3z7v5LbysjY18gkKiNjjGNPV49Z3qssfXeIj7bSK340DMA8Ilo4TwlFekSAshpBRFmdp3qGBMKibHHgt2c2p+nySKKtS1qFKYbzfvLFh7Dxya1Y8+OnsUnc7DUjY38jk6iMjDGOZg7xTcmJUpPBbU9UrIDokvZtMlU5q+XEZHCB+ND0qkEK1ckr+FyzhPuueLVYOE/1RO14eVft7+2bdgUkMzKGDplEZWSMcdD9fCQSFV9RB5QHV9kjIuUCEV2el8mSidSp2RXWY9plyXlhOpHUCOlVVq6WlKcFIydKIGR8P7C4C9D1cEqhQXVvi4yM/YxMojIyxjia8kR5BwLHl9FLCdxoLidKIRDqZptSTlRCCE4PDRqCyg7pKuGUPIAJxEcM50n7VGUOlTFMkUlURsYow6YNHXjkB09i55YuSZ4tSk/JiWomJOZvE2CRB7eKGs5rQqboRWtidZ4eEnPKJS+TISPmfEk7qaurIgW4z4zynGUSlTFcMX6oDcjIyBg8VPuq+OHf/RwA8OyvX8a5l78tXol5DBJyoqhXQSAi7jm4JodSE8uFQT/l0GB9dV5chocGy5/N8JrAotQNORUvk3ckjxSCI8WuXXv6gEkxXdz2n33rt9j6/A6885O/h0MOnxy3KyNjEJE9URkZowjFPKaNT2yV6lQIixrMxPI+IZynuVfUcJ6SEyXokomPEF5LJGRmkrq0DUKi7eZ2CY3fd/X79TYRznvuN5vw+F3Pov3xLVj5tV9F9WRkDDYyicrIGEVI2siQeKKkxHLhqJb+Cwl5RUJCtbpaTlqdp4T81BVuChGhtyolFNlEHpPL2QxS43kJlbw2kbRJzyy5WVuf31H7++Un8zYIGfsfmURlZIwiKPs0uWBERPNEaftEaSvc3M9NJEsr+zYleI8YlPa8EJhKACXPUKIeBHLUGmzP1SV7ooR9o3JKVMZwRSZRGRmjCCmeKL7FQXzoUo5qAcoDp5ybI3hgAu6cqFwaaVPDh5bx4fZpm4YuP39MsF29VSYhU+9D4+25KzwtsOdaOKovI2OfIpOojIxRBIX4uGhmiwOZZPQpo6v7OU58OCEL17OFBBHRi6bttq55akzbFa9WanuJhNMrF8O2KVtp1JFZVMbQIpOojIxRBGXPHb+O6BkSVq9RXaXEctsObTCPEx+rruTNkfKYRE+U4s0ZzHyuJsJ5/uae8fuueBPVfbCU3DsqkzlUxhAjk6iMjFEEL9FbyHehBwIrezIJK8n66xb1quTBklG9K+F6VgN23pSgB2n5VSrJkLZekGwi7SkEUD1CplBXJYnSAgbxvL2MjP2NvE9URsYIQc/uXvzsW79FZVwFp170Zowb78+B3LBHta+KyrjwdF0+yy4x3JV68G5TR7WkHAisnHenbrapbJcwmLlhyg7p8r0SSJt0RqIpkrQ6j22DkHOiMoYamURlZIwQ/HrZU1i36nkAwNTpB+GE9830ZNxZfV9vFS3jwnqVZHDrM6ARJNkjktKeeJSJRMiUsJndnEjaoibZF0wPoCvSTB5TvLmkxHLhCCBAW53HcqIa2Tl99449OPDgA2T5jAwFOZyXkTFC8MzDG2t/P/vIRlPGWy2nJIer4Txh00cpOVsezBVCNnh5PoO5TUAz+zYpu4NL3qrE/DE7oV/MiSquwmTbbbhONGFbDka01IUUv/rRU/iXT9yJ+65fI8lnZKjIJCqAdevW4S/+4i/w3ve+Fx/5yEewfPnyoTYpYwyjZVz9dWUDj0ualOM59rsnqpkwVmI4Twp3SYns8VwgZpdCOPt1CTlKCkl0V8Hth/terKySRM0TZcuouVKrb34CAPD4T5+V5DMyVGQSFcCSJUtwyimn4Mc//jGuuOIKfOUrX8HTTz891GZljFFUxtcTQGQSJczymyM1gjdHDOf5S/3SPDBWeTIxEG33zvTb16vzFKLlkTaxvSbCqMUVj+rvrCx+YCRKSUrPyNiXyCQqgPb2dsydOxctLS14wxvegBkzZuCZZ54ZarMyxihaWuokiuWbuINKNeH8u1rdQToPzitSB3NBaDDDa82EIiVioGxLIOwvZdqlhA9Fz5dGlpvxRLkFxK4CWNiukZyojIx9gWGfWN7Z2YmbbroJ69atw7p169DR0YF58+bhoosuMmWvv/56rFy5Etu3b8dRRx2F888/H3Pnzk1q+4Mf/CDuuOMOXHjhhXjiiSewceNGvPnNb272K2VkpEFYiuTlRBkEKSVJmMoleKuaCR96A7C40k/zkA2e58vMK0ogPrTNhBV8+tYSgu3SPlHMbScSsohNwTZCuvqqqLTkZX0Zg4Nh74nq6OjAbbfdhj179mDOnDlB2QULFmDFihWYN28errrqKrzxjW/E4sWLcccddyS1fcopp2DFihU488wz8alPfQp/8id/gsMOOyxJV0ZG0ygOGIRQKeE8j9SwDTpTkpeVbQJkIhIX8khV7ULEBmjhPJ98aQTQsktJ9JbuMbRz+OT8MWklo0gmhXCeGtYMtW+1pyJ7rzIGE8PeEzVt2jTcfvvtqFQq2Lp1K03uvv/++7F69WosXLgQZ5xxBgDgxBNPRHt7O6699lqcfvrpGDeuf633JZdcgjVr7FUa5513Hi6++GJ0dHTgs5/9LC699FKcdtppeOmll/C3f/u3ePWrX41TTz3VrLtp0yZs3ry59rmtra2Zr54xxtDT3YvxEyL7EUTgLgW3CJJLrHh+i0KQ3M9WXpEj00RITE301kJ1grcqdUuFxGNflNBdf2FcJoX4cBsS7ru6ClPxRKkLCAT09VWHv/cgY8Rg2JOoirib2qpVqzBp0iScdtpppfKzzz4bV1xxBR577DEcf/zxAIBrrrkmqu+FF17ApEmTaqHAI444Am9/+9vxi1/8gpKoZcuW4cYbb5Tszcgo4rc/acOD3/4vvPGMo/D2jx2XrMclTZYnyvdWMRZV/igNrpYaNayk7Fek7iCukDspj0lsT9pzKvy5X49IrJSQmHjfPTlLJGFrCd0TZcuF2o/aEYCy2CIjQ8WwJ1EqNmzYgBkzZmD8+PJXmjVrVu36AIlScNRRR6G7uxt333033vWud+Gll17Cfffdhw996EO0zrnnnlsiWG1tbViyZEmD3yRjLOL+mx4DADz2kza87YI3mTkbynhhbbYZ09PMrt8+0bJkVI9IfNCXPUNSsnS4jlmm2i54vuwQnEZUFSJihhSrVW9iqnjR/PCoLwLYZMtrTyVkpTqNlYfAJg27d+zBXf/vEYyb0IK589/atFc4Y2xg1JCojo4OHHHEEV75lClTAADbtm1rSN9BBx2ExYsX4xvf+Ab+4R/+oeaVOuecc2id1tZWtLa2NmZ4RoaD7l09OPCg8M7KzEFrHfviIvVMNfMQX2kVnK07OphbNsmrxOJGKLuR68nZAtkSCKfsnUrwtA0Uuc9Oyo7l+sad8A4Jllc8CjLWMxp7rtjmsg9+53G88Nv+dIxHf7wBb/0fx0btysgYNSQK0EN/Kk4++WScfPLJg6ozIyOG7k5Coop9v5hY3lR+i0JYUvN8+vwz/ZTBVSIPRrm0nYDUntlc4pYDYnjUJGRxUmPudN5XBVoiJEP4DRsJa1YQ8UQJuWguWWe6+nqrGDc+3B5bHfrCmno+66anOkyZjAwXoya/burUqejo8B/87du3AwAOOeSQ/W1SRkYSaI5SAWy6MFiHBpty0rEocZu4XY2HxJrxonkDvqBHJZzSnlMq4TTtiutSVtlZZRJ5HdQNWuO2q3l01qac3kIKYV+0vAVChopRQ6JmzpyJtrY29PT0lMrXr18PADjmmGOGwqyMjIZBN7/kR9bWZVJ24R7UDSt1T1SsrKkjZKQz/RJCcM2QNmnFoGVDoi6BnJhtqroMaN7Exu+V+oxqCykEEjUuk6gMDaOGRM2ZMwe7du3CPffcUypfsWIFWltbcdxx6SueMjL2JxRPFHNFaQNU+HOtXPFQJKyoY7q8wVs6ysSXsfQnh9fUFYnSfRC8aKonKiUpHuphxgqpMYyy2hSeB83zpbWnbelhPzTFe9OSPVEZIkZETtQDDzyArq4udHZ2Auhf9Xb33XcDAGbPno2JEydi9uzZOOmkk7B06VJ0dnbiyCOPxF133YUHH3wQCxYsqO0RlZEx3FFlJ9MLzoCUFW48RBUXUzwG6eE8YTBnm19KYSW3IK5nQJebkqYc9KyEqBTPoWWXmFdO9Cv1wu2zyqkrC3WPo+CJ8nbxtxlZDudlpGBEkKilS5eivb299nnlypVYuXIlAODmm2/G9OnTAfQfGHzdddfhhhtuqB37smjRouRjXzIyhgJ0QC4WU09U+DNgDVBEl5JMnLCijtWT9lryksFJm4MWVjKUG8nZHnlIJK9qXnkKWWHKJCIsb/UQqWeUNRW2dR8HYwLi7Z3GPFEFspVJVIaKEUGibrnlFklu8uTJmD9/PubPn7+PLcrI2HdgJ9YXvS7uiqeajLLizEuoFr05ZngoXKe/zLIz3p6UnO2L7DVMICxS6Cnds+britfRVzcqMlZoMNF2gbTZcpaM87mZVZhCOM8jZEJOVEvOicoQMWpyojIyhiuq1Sp6unuD14uQdlRmnqiUcJ66kaGykaa6Ok9ZkcW8QDE9Rt3UEFVqmCzdA+PrtqAlllsVLbkU2zW7NC+TqShqk6lfuA9SYnn2RGWIyCQqI2Mfoq+3Dz/8u5/jX//sLrQ//oop486M+YHA8fakLQDUWX5SfovoETHk3DCLHKISZOz7oNwrNb4Wh+ZpE0NwKTukU/2D4z3qL3cKhEUFmqfNbE7aA0rJm3Lr5sTyDBWZRGVk7EO0rX4Jm5/ehj1dvbj9yl+YMn7iazOeKPfzIHoVhLCLsk0AE5Pyirxk8DTC1F+URmqSk6UV8irbIMgkbnGQSl4tOWl/LuE7qx5H5XeuWufhOG1kT1SGikyiMjL2Ibp31fctY7kYXuKrsjqPiQzS0v5+XW49QyZxdZ6Sq5XqgZH2VTLqquE1LRQpeHzk0J1V5jUo1jPKhGR9+by7OC/VbE9dnScQfTZJGTe+Phz27uE/ztqVz+I/Pv9LbHxyK5XJGDvIJCojYx+i2DEz+IcGk5lyYTRobsdo97M2QKUvjzcGNqu9lBVnqudGzA+SdCnkRLnvieE2ANomoKKuJO+Ruk+UsDJTIT5qYrlEAAmJmlA4amn3zj2mTO+eXqy6bg2ef3QTli2835TJGFvIJCojYx+iRSBR8maABTmeHOt+TiMiVt3knKhEb1FqSCw1P0gKVxJdKe2pO5anewBFXSlbS4ikRmkvddsFS5fyvLMtDsYfUPBEkRWyIQ9VxthEJlEZGfsQLeMEEuWE71g4r0ic5GTwxP2R+i84H5XQVhOeKM+LoIR51PYEr5MJwfvWr79xD5m8f5ZEJn2ZdE9UYnumXBp5de87SWPyGpR2kycTkGIelLKreUYGkElURsY+hbuztQUvJ4qE84rl8gaZSgiO6PJWyyWGXeRcIyFnSEsk9uspcrLnxmRIbj0hJOZrsSF5tTSiarbp3dO4DU39zinPlUhqmvFEFRdr0HeC5StmjFlkEpWRsS8hkahq8HMNVfqhXirkyihbCViVU/f8sQekNELm22SpTiNW+vYMlqq4J0phbarHTEqwV0Jppi6/okc8RMJpexPj9dTEcmVvMXWLA8kTpZxrmTGmkElURsY+REVwRbk7lCuzbuqJUsIbYk6UT7YEVSoRUTxR6kDtwPQ0JG7PoK4s1FalOZ+b2Jg0OUldIa/K95PvsUK8hZAf+eFTvKWMCBXfVfoOklypjLGLTKIyMvYhlCRkL7Fc8Aypq5WaOVJDOjBX8q6Ig7mUvCx4KJQwoGGCHnaMqiJbOCgEVyoymIElYxQNUj6XbVIqWRZIIvVEJXhLBU8UDanncF6Gg0yiMjL2IZS9gFRPVEkXG1MSEq8phxJCOFI4RS2T9qUybPBkRI+I4D6SPTzuPTXtCn+mFROJiJYAlaarmZWMiudLyY8DLE+UZUO4zgAqhdGQkaXeHM7LcJBJVEZGIl55Zjt+8H/uw33Xr6EySZ4oIVQnnxknhbFEr1ZqaEbeOXsfDuaCpyY1p8dQJRIDgdixMoVwCvUASAsNtP3H1N9C0CX8zqYuxQMo5BzSvdqyJyrDQSZRGRmJ+OlXHsHmtu14/KfP4sX/2mzK0DBEQEYZMJoL56mkzS0Q2pMHV4FYKYO5L6J7opITvVWvT0TG9GgZ9VJDYuJ4Ly008IpUspxIJtXE8pR9ooQDiOn5etkTleEgk6iMjERsfX5n7e8tz+0wZZJIFCNIVfvvYF2J+GgDojRQq3k+iXZJy/HVvXwUT5RVTUjq1nZD16qZWyp4NqV5+yxDNM9QXIbKpRB9Xw0AbfGD772MnwjAyFKv6Ina8tx23L7kQTz0vSck+YyRi/FDbUBGxmjAnq5es1xJRFW2CfDkRE9U6pEaqTuBq3kxkodCIiJpIaT+QsUmoU3xOydtg0D1x2X07+MUCB6lZG8fDBKqLA4QFlswXeoWB0W7+Ia3midqxRdWY+fmLrz42CuY+fYj8KojD5bqZYw8ZE9URsZggHTy7PiIUFVltZwegrMGKKdMPWTXak86GsaoJ3k70oiI3F7ks1pR5ULSakDRdsl7ZFSzc7ziXh/lsZJXCArsWCXUrlMpNW/PLafhPNETtXNzV/3vV7oCkhkjHZlEZWTsQyhnbenhvGpcRjguQ/NExXX3Fzqf1ZQRmXnERXz705iVspKyX867gVp7nkgTDFCQST5PT2KczXii4vddTSyXPFHunEHJiSKTH9cTpUw2WlqEHXczRiwyicrI2IfQPFHaYF5OLI/LAEg/6Ff1RAlhHnPAVVaciXk+SWf8mWapRCTRG5ZAHriuiE0MtntKsCvtmZE8jmqSugFtQ1gxnCfkRPmnC8Tf75ZxmUSNZmQSlZGxD9GX4okSti+QT7VXPAGqF0PKrzJsEkM/2lEmirdDG8yN0dwXMarF29d0qcRH2eNK2cKB6kpIlE/dzsAUTEw+l+1KyYkSvFUhuSJaxudhdjQj/7oZGfsQkicqIWdDT7S19IQ/h9QHbQIL6Rj1Ejd9FBwpUj6SVSSTIWlTUKVBq55fpm1yqhJHo8yrJ+iSv7NAvKVzFH3VgPbu+M87WZ2XsIWIQqIqOZw3qpFJVEbGPoS0xYE6YJRyomwZZc8fyXOjeqIUAmgmtwtiasgoWiB6V1TypTJMv6JgUxoZUomcRF6FA6ObOSInbZNTjdQ0s0+UdDalunFnxKaM0YNMojIyBgFyjpIgo4Tq5PBGYkK16gVKzHmWVo6lrhC0VQtkMtFjlkr29BxygQypN1kJ+yneI/FhkHZlFwigfuB23C6+Y3mRRJF30ClmR8iU6mQSNaqRSVRGxiCAd7oJJIqFElI8Uamr88Sds6UVbk2sHPOFBBFVt0Q4jXqDldRtPjPibyF5LzUi7MkoBElenWfokvL24jKmnHFP3egdIz7KJMUjbUJieSZRoxuZRGVkDAL4MRFOKEHK2SADVLVUYBuiDHbeEn1LjRgKEjZFlIcQ16zUs9gs3You9T5IK9XiupryRClEWPWQJdiV+p0B0RMlPKOWnOR5FVbnqWf1SZ6ozKFGNTKJysgw0Nfbh44Xd8peBravzGBtOaAeUSIt+VbCh8ou0rBs17w56YO54opSvVyJtnvkSyOcEkkTyYkfV4qLMCjfx6+jeaLSk+Ib984ChMiJxEfaQsS97QknEmSMLmQSlZFh4D+/+BC+95l78ci/PynJK8umARa6iJOa5ANZJa+C5j1KTUpOTcSWtwBIzYnyvGhGvcT2VFKT/FsI9dQwqkRqFM+QTJaFeoKMpV/xyNGNNBMmFzknKiOTqIwMB9VqFc/9ZhMA4OFbVRKleaJSPUPyzFzYTTvF88XkUg/jlQiFutJPEUlzYCXXsw8NVr60US01ZKSO3WISd1lGJXvx72zKKHuGGeVNTUAEXR7RyqvzxjwyicrIcJDiOFE355M2rJSSwW07JIKk5DHJZCiNkGkxS63aYOU2qQ1qXiBJlfKVk1cyqrfduwvKdxZsYoLKbVe26gCs98tqz/EeCVsc0DZdrxbZcypkY8bowpgnUT/84Q/xJ3/yJ3j3u9+Nb33rW6bMmjVr8K53vQs33XTTfrYuY0iQ0OnRU99TPFFKOEVMfLVGKGn5uDgCS54veQfxxmX65RoP6ZjtWQOwUU1hFHI+klsget+8EjVLXWJRvogfE9PusX3fGycrNJynkEnXdOY9SiBkiidqz+5es7xareKBf/kv/OSLq/MhxSMYY55EHXbYYbjoooswZ84c83pfXx++8pWv4E1vetN+tixjqKDkOXh1xHCeFF5LPF7FlJOOV2lmQEyrJ3k7Uj1kKgF077u46Wi0fdKeUiarcsOoiSbIR/4MEsG1xPTnw7I1LuOHBm3dHtlq4giZIrq2d5vlz/3qZaz5j6fx7CMv497/79GonozhifFDbcBQY4A83Xfffeb1ZcuW4fjjj8e2bdv2p1kZQ4kU7zsjNcrsVtlygORJVSqVqJxfL/x5QLdWFpfR04NEphipl+r5Un933xGVTkKlBGrbHZZUL/XwZKar+PzJJFT4zuxeOY+79H08MpToMQP891chUT3EE7Xp6fqY8vyjm6J6MoYnhgWJ6uzsxE033YR169Zh3bp16OjowLx583DRRReZstdffz1WrlyJ7du346ijjsL555+PuXPnDrpdHR0d+P73v49vfOMb+Md//MdB158xPJHkiRLDa6mzaUpOIoOKlKSuDHSszEsSsUTSPEqpx4jIhCJFt1GoklDJrtR7ZYoI9SyTxJCs9/zJ5Etoj4Y13Qc+rkuSEZLIrbpNHTMjELCM4Y9hEc7r6OjAbbfdhj179tCw2gAWLFiAFStWYN68ebjqqqvwxje+EYsXL8Ydd9wx6HZ985vfxIc//GEcfPDBg647YxhDTWgR6gzWFgfKHk1We4pNKqSwUmI+kt2e5jKQ8sPNBhJ0i+2ZzSkhxUQiYlZUnhmV7CXuEaatzjNE5Jwrxcvkvl++jDkJUvacMsL4XlhQ3UMuY0RiWHiipk2bhttvvx2VSgVbt27F8uXLTbn7778fq1evxsKFC3HGGWcAAE488US0t7fj2muvxemnn45x48YBAC655BKsWbPG1HPeeefh4osvDtq0du1aPPHEE/jMZz4jf49NmzZh8+bNtc9tbW1y3YzhA4mIuLNN2RMV1yXv/CwMPqmeKHlATPTKqB4QXyZeaBOmRAKT6MJKJ6qiF0i575Lt6TZI5DWRAKrESvEyKYstzDCgYJflTVLzpjKJGh0YFiTKzetgWLVqFSZNmoTTTjutVH722WfjiiuuwGOPPYbjjz8eAHDNNdc0ZdOvf/1rPP3003j/+98PANi1axdaWlrw3HPP4e/+7u/MOsuWLcONN97YVLsZQw8rBBfNPSKDptcRpx77klhmDr/JOSJxOXlgGMzkZfdzanhSJEN+DpaFRK+WpUkKa2rf2f/KIgEUyKuay5dKvC2k3D/VEyVNQAQS1cs8UZlDjQoMCxKlYsOGDZgxYwbGjy+bPWvWrNr1ARKloqenB729vejr60Nvby92796N8ePH45xzzimRta997WuYNm0aPvrRj1Jd5557Lk499dTa57a2NixZsqQhezKGHpanpjKuTKK8M/FoOK/x0EUzITFPTiIr2uiurYxLG8xVXaZ3RUmmN8sGyRMlEGPagEBETAiE0/w+0iaWquewcRnAuDfqsy1s/6CdWagRJvt3dd57ZSKTPVGjGiOKRHV0dOCII47wyqdMmQIASSvo/vmf/7nkPfqXf/kX/J//839w1llnYfLkybXyAw88EJMnT8bUqVOprtbWVrS2tjZsQ8bwguWObxkXllH3bZLyYpoIr6Ucxisfy6LM+lWvQuJu5GaeimZEvOLgVTNLJQ4lDvBKLpBNQuNQyJdpV6Krrald7r3Pwn0Xn1FrH01ldZ7Xf+ScqFGNEUWiAD30p+Kiiy4yVwG6uOyyywa13Yzhi6S8B5VESfs2WTLxev11Gydktm6jLDGvSM1d9sY6kzDFvT6yDZJHzi/SwlhWvXiZHOJJJLQeGWqCfEk56okE0M7nUryCcRtkoqoQfSEc2itsxDvIw1rGfsSwWJ2nYurUqejo6PDKt2/fDgA45JBD9rdJGaMQSt6Df1gp0SXM1t0Zr5z/lOjMkbwfao6Nx3zEekqScHIcUBRRCKCgS3fkiffZlZH2/tKM8H8u7blKZVGKLttTqTSn3c9kop/6rjr1lI14Ky2ZRY1UjCgSNXPmTLS1taGnp6dUvn79egDAMcccMxRmZYwg7N6xBz9a8HP8aOHP0d25x5TxvUzGMmYllAHLSxLvwdUOXdKVuLmnzl8Uj9wghnTMykGT9oooA7w2uirEcTD3ibKQumlmaghJ22hVrZfmiZLqWXxFOSsy0ROl3GMlnJdJ1MjFiCJRc+bMwa5du3DPPfeUylesWIHW1lYcd9xxQ2RZxkjBIz94Ei+v78DLT3bgF99Za8p4xMcK5zlFLJyneKz8uuIAnLhqK32zzTSPjxQuVLmXFB5S2VfEJqJKI71WvXhZqi51cYAn0sRGq5L3K9n21HqJnqjEfamU0KCyxUEmUSMXwyYn6oEHHkBXVxc6OzsB9K9su/vuuwEAs2fPxsSJEzF79mycdNJJWLp0KTo7O3HkkUfirrvuwoMPPogFCxbU9ojKyGDY8tyO2t8v/tcrpkzKChw2SCv5GN7gkJj/tLcw9NHUr3sQos2ZIENIVMYOf8VtSA5HWZDyg8TBXAjnJf8WzRC5lPYAj8Sn2q6nog2O903d1sH2TjkFyoacgieqZVwmUSMVw4ZELV26FO3t7bXPK1euxMqVKwEAN998M6ZPnw4AWLJkCa677jrccMMNtWNfFi1atE+OfckYfZgwuf7I79nVY8q4OQx9RmJocmK5NAvWCJNEahRvhBpKk2b5qncgLiN7pxTvmxDOS12lqOfYCGWJiVkKUe1Xn+hFU+6pSE60GyhUs0SU7yMTpniZ8l5yT1T979CCqT1dPXjht5sx/U2vxoTJB1C5jKHBsCFRt9xyiyQ3efJkzJ8/H/Pnz9/HFmWMRhRnfGzQ7N1T7mWlGSnNiVIGGqdjbmK1nC+j2GTImMqEMtkjkmZD8gpBZbWcTHyU0byJslh7ll3id1bqqWRI8wAK5NWsJtQTt8lI2WZELVPeL77ZZkEu4Ii674bf4qmfvYDpx70a/33Bf+OCGUOCEZUTlZHRLIq5ByzJ1iVR5vlY+3SLA61D1/buMc2K6tfDh5LyaJGpRszXkYiBaZbiRWtcT3+1NFdUeo6S/KWdWmI9S07xoAqq1O0gkicNEuEUiaOwUMTPg7TtVvoiAHjqZy8AAF58zE4/yBhaZBKVMaZQ7LiYm90jUYpbv4nNNhkBi9XTUnq0elIkyxzfBSJi2hU3QA3X+HlgaV/Q5lACqbFUK5uCiqoUkpZ83qKYTK/wSzUHy7crkbArDA3qJMXQlLoPm9g3jDugPvy6fU7GyEEmURljCqXZHwvnOe53e3WeU8bOzpO2OHA+mkdQGNUSk3bNQiXsKAySMn8RwiJ6TDEukhyWSzw7T97jSmJR8bLUfb2S7QSkjTtTF1JY0FbGKfVM5YYuhSDFVTH+Pm58JlGjAZlEZYwpFBM4WeftrqYZzB3LrUFZ8UTZ3jCrQbEH96olDjRKqGQQ6ym5P9o39gX1zRtjBZBJb3puWFwouT05P0hpTykSyZCwGtCE8HvJnihhUiR7qeUHNWM4I5OojDGFSuGJl0Nwg5hYnrpBpt3xp3mi0uspdqWxAD0MKBCd1BCm7A0TdJuC8aLkcwZTbZcLLRMUQmaUSbv9K+63RO+RSjgtC4QXJTXUnzEykUlUxphCSzEnqpltCZxC67BSWZfnSdFIgJbUbRQps+5EIiLnxRhiUj2rorRx5z70yKleDOG3T/VEqY+HtjIz7fkjb5NZGoP0nqhkz9MteswSJzzSZrZMvwPFS50xtMgkKmNMoTIuviLGI0TKjFf1RCmr3vbxPjaJ45o2aomDcupGjVJyu2WWSHRSPE9NrXDzbNd+56hRpLlUQiF5QuU8OoFkKM9D6m8qPmsakbN+r7iefjmBROVcqWGPTKIyxhRKxyuInZt0tIM425TCG+JqpeRjNyyxxBVM3oCo5rdIGelGexa8XaRT3XaGVOo9lsmJIGO2KTxXSq5WOocSj+4RnyNPJm6Y6jFL3spC0mXIDGJOVM+e3mD7GUOPTKIyxhSUM6pSVuCwwc8jV0Yn6MnIm21aZY0TQAt2Xy0MWurEWfJEWWWGDZHPjehyCZgWwlQHc0WXISM9f2leO7PeIHnoWJm0GlX5vcTcQWk1oOjV0vIlRRIlvIfexr+ZQw07ZBKVMabQopCo3sHsKJ3PgnfAJgGqdyquy4KUH64s55aUW4O5WVFRpRmhehoGqT2VhPojfJqhqZ4o/VYJz19irpFswz70RCnkHNDe5+SVuwZ6u50Gc47UsEMmURkZDvoSvDnN7FjutScmJUujz2DuPG4iPpBKHphUwmTpkpPIhULl+6h2JpJQmSAJkMirVSZ4b1RVvlCq284SUZix1pz07ihbWZCbIHmElRzHjCFFJlEZGQ6SlkSrieVq+ESQkVYPmUZZRY173yxdqSGd9BGYNeCKaIZJY5TiSZFtj3xWlVlfTyE+sldG8URZ7cXryc63VKedQrJVT5Q0wXI/k75Bee2FvihjaJFJVMaoQfvjr+A/Pv9LPHnf81RGOmLFy1GKd5TNbZfgfhYJjOLZUL1aiRtWppCO/qI0r0L6obpSkUYKPZu0BrUDbRM9eSKjUHP5BFWGbtWbqNRTnhmVBDf+DgKQ3ns7h61c2Ew4zyPsOZw37DB+qA3IyBgsLL/iQQDA849uwqxTjyjtTj6ANBe6L6Mkg/fXFQiZ11FaegTdKqQcJY3IqXviGA0G9fBq8YFTXsko3VOVfTkiaoJ9skdO8b7FC20SoDWXHNYcJCKneIqaaU/Kr5IOAWeeKF+Xu/Ale6KGP7InKmNUwj26pVYu7LuSEoKjHq6kEIQ6MxdkxINwk3ccSPZQOPfYrCe2lxAeYqTN9+QJNjSRg6Wokpb7J9uQ7kWTnm3ThjTPkDIhIQ2G9UCbIFhyzXmiyp/7ev2HTSVkGUOHTKIyRiX27O41y3sEEuUdGixufmlB85LE2zN1S7NU0QMjyEiDlhoqSfRi6CvhItVYnYT8KmUg5YLxG5FYTfMcikTV/inSbNeYY7yeKSKEr2UPruCls9rzvEeil9o+ozOsu4g9XT30Wsa+QyZRGaMSPYREKaelV50ZodXp+h2l7rI3pCKfSZEwGCnHUtgmGLr8WlJOT6rtFqTcH8VrQvUL7e1D50DquYmyDcqjlqhL9hwK7Q1mWM6DHC436iY87+o+UcpB5yxtYOVXf4V//tM7sXbls7ZAxj5DJlEZoxKMLBXDeUbKFABttil5UkQ5vz1DRsouVgwgRUp4LXETRtOqQQznScdsCEnJpn7FA6OGh6RNVNO9JIpMakK6Ht+N65dCVIJnTV6AoXiwxDw6ZUGEPMFyn1uBRFmeqO7OPXjq5y+i2lvFquvWmG1l7DtkEpUxKmF1SED5GIWW8fbjn5JYznNsFLn4aJRqg5qkrs6efV3xezWo55lJVgnNMQ6VFBvURMykeGXlmBDe1Y8FipMAOUfJtV3deTxBtwnZ9jQ7Fc/uYO5YruRE9Xb7HvY9XbbXPWP/IJOojFEJyzUOlD1ULeNsV5RyVIuWj6Q5QNR9ZfyKcd1SRbWywv8Sw3JNHYSrDFoyi3LF4kROT4AXykRCoW0RYZQpW1moj4dC7iQWJdqgvHNSGFD1OlnqG/eGqRMsy8vklvUYJMoqy9h/yCQqY1Siz80O34syiRI9UdJeS+KgnLjPS3I9dXCIFqQTitRdpAcxqiTnEKUkXjezpYK0yi5x00zReKOa9mOkksl9uTeWlsdkycTbAzQi59nJEstdT1RP/Jmxcj2VPM+MfYdMojJGJcwOCc4WBzQnSugoE1fgJIcbBN36yrh4Z526caKFxDx24sWwSEbaIGlB4sZKLprqUVLCa8qqN/X7JY63UsJ74jOjP6OJ913y9mk2ePehmXCe8LD5nij/h7DCgBn7D5lEZYxKsI6rtMWB7I1Id9lLq96UsSFxZq4ObJoHJj5qyR4Y7/fR6knjpnKPxX29ZGLgySR6okxd8cJErqznzClEzqyWxrJlx5onkzZBsDfBtVQ53qMmNqBVJmKSVzxzqCFFJlEZoxIsJ6q4CSfbc8Wrm3jIqL56SJiaC2WpA0+/oCBieuQEPUIYMDmHyCgjQ5ZZ6klJ5CSNOEoeMlWX1F6cLKjePonAJO7RpD6jqQnifvK+8DwSOa8vMCcIjkgT258oq/PcLVky9i8yicoYlWAu7mKnJM8QUz1RybNpsV7iAKyFPNIGKAu2Y0O4x6llypmCzGzBQRatw6oJtqeGXweXfFk2xO1KdUwln7ln6lfuVVw3K9MImfCbIrGfMSaHJP0zYz8hk6iMUQm2xUGJRJHeTVvG7BYYelQS4O1zJHoH4iKyDa42VZeSOK95KKz2/DLNE5XIVJHmZdKPERHMSCXeamFyXpHwfQaRnCuEU/JwGvWaek8Sn1vlAHElnGdvg5BZ1FAik6iMUQkWzit2jLonKqyHySiu/n4xwZNiqEqdYWv5VVo9LZRm6UqrKA2AqjfHbCDy2VKlfmmpecVbpXqdBPKqJLsT/ZJMatg78Rk1jyYSiH7quyOHFJXjYQQyrhwNk7F/kUlUxqgEzYkqhfPsuoMVzpNnt8l79zg2CAPw3sK4/kRvWFO5TUJ7hC3ERbzBT2vS5l7ufRcUqWUKUSX3LonYKwcsE2jvgPtZJWhp90pW79VLfHdEwm7mXwrk2D/H05DJOVFDivFDbcBQoru7G1/+8pexevVq7Ny5E0cffTQ+9alP4fjjjwcAbN26FZ/73Ofwq1/9Cq2trfjrv/5rnHzyyUNsdYYC2rEUF+exxPKEVTOpHp/+qm57aofufG5mQJRCHkaZsjGpRAwEggbyWwjeFT3kF2dkWig3rtmS03ZMZywK5W07JOJN9ETq0fYjhanc0irTJw3OR9V7JHnDxOfdgBeFE7aRyJ6o4Ycx7Ynq7e3F9OnT8fWvfx0//vGP8f73vx+XXXYZurq6AABXX301Xv3qV2PZsmX4i7/4CyxatAgdHR1DbHWGApkgpXqZBnHFXnLycqInSvJQJNppEwXBrlRvlahLDh+meKLEUVMa7JTBPMChwhUNIZO8as+MRmr8eppyQ045jFd5T0TCpLBedcKjrMpVdiw3E8uzJ2pIMaZJ1KRJkzBv3jwcfvjhaGlpwVlnnYW+vj4899xz6OzsxKpVq/Dxj38cEydOxDve8Q4ce+yxuO+++4ba7DGJnt29ePyuZ/DSE1skeZoTJe27InhXlNyLxITj5IN+5dl03OujkiEpvGHqEmxSQywR3bZQel2J1IguHu34IMF7ZFRWfkM7ryhqgl0o3Ac94V55RgdvgiA/f+7nJry/KcdLWScxZE/U0GJYhPM6Oztx0003Yd26dVi3bh06Ojowb948XHTRRabs9ddfj5UrV2L79u046qijcP7552Pu3LlN29HW1obdu3fjiCOOwHPPPYdJkybh8MMPr12fOXMmNmzY0HQ7GY3jVz96Cr/64VMAgI9+/XRMPvTAoLyyxUHt87iYTFwP0N/pVgrxlNTZrQVzwPBW9Ym6FTnRdjYAViqVmJDRQLw9MSYmiDThikokgMkJ6AIJsORUwhJrjpVq6UGil857ZgwZIYSuECQ13Kblp4mkUJp0xetZnqi8Om9oMSw8UR0dHbjtttuwZ88ezJkzJyi7YMECrFixAvPmzcNVV12FN77xjVi8eDHuuOOOpmzo6urClVdeiQsvvBCTJ0/Grl27cNBBB5VkDjroIOzataupdjLSMECgAOD532yKytMtDoQOVQr5KZ1nYj198BPIg1DNtEEM85hQBocEGWqX4gxTcoFUu0jdGKT7kLgdRLJd4o2XPC6JRMHUJaCZsJy00aVEyBL7BqNNZSsVM+RH+rqM/YNh4YmaNm0abr/9dlQqFWzduhXLly835e6//36sXr0aCxcuxBlnnAEAOPHEE9He3o5rr70Wp59+OsaN63crXHLJJVizZo2p57zzzsPFF19c+9zT04NFixZhxowZuOCCCwD0h/p27txZqrdz505MmjSJfo9NmzZh8+bNtc9tbW3Ct89oFL17/EM4izuRA6Fwnvs57kKXj1pQci+UM8gsKAOwVU3ZUsGqrJIa697AOZZQ0SWzPUtOqCa1Z5QL3g49nKK61iIyjEQleGpk8irYKQ3l5Fl3nxltb7YmCEwVqJCzM2l7gEYKVSI3aFscZBI1lBgWJKoSe5r3YtWqVZg0aRJOO+20UvnZZ5+NK664Ao899lhtZd0111wj6ezr68OVV16JlpYWfPazn63Z8prXvAa7du3Cxo0b8bu/+7sAgA0bNuA973kP1bVs2TLceOONUrsZ6egxTi3f45xuzo50SSFIqR4RNbHcd2CpU2wH5ncWB5WE/BaKanlIVL6PnMzMmit9Vkii9mW0sJw+cMfKNBnV9rT2bGWWrvgzI4fS+qpAS+GZsUxQdMlk3H1GtXqeXKIHyyqTzs4zdyyP/4gbn9yK3yxfj9fNORIz/uDwqHyGjmFBolRs2LABM2bMwPjxZbNnzZpVuz5AolR86UtfwubNm/HFL36xpHfy5Ml4xzvegX/6p3/CJZdcgoceegjr1q3D4sWLqa5zzz0Xp556au1zW1sblixZ0pA9GXH0dvueqF6XWJHeOmX7gvTdjMVZY6IXSAlRyYmviu3iLD8prtTEjD4lp0wmD2Zzii6VAXrKtXpKk5KHM+3ZtqomH7liFSvfeRBtV0OYqUQu9aQCt78yz84TSNSyhfcDAJ7+xUu4+DtnReUzdIwoEtXR0YEjjjjCK58yZQoAYNu2bQ3pa29vx/LlyzFhwgSce+65tfKrrroKJ5xwAj796U/jyiuvxDnnnIPW1lZcfvnlOPTQQ6m+1tZWtLa2NmRDRuPQ8gtI5ZTVeYlLqfXk7HjHnOr5khmZYLq84kzKNwnXaaTMk1F+LxZWUj0nUSPiuu32BdWMiOxv2xO+DwsLpqyIVb+fto2JWTNalLynm2WDsiGnFc7LOVFDihFFogA99Kdg2rRpuPfee+n1Qw89FF/84hcHrb2MwYE5Y+uNd0jVatXrLPsUXamJokLozipMDdfI+1mZuuIsKnmWbyKNcIqJN0nNmReE315eCCA8MwopbSYGlxI+pE1698GSESYkcdWmKuUdZHKKkJLr1sw7oS1ycT4bq46VcF7GvsOwWJ2nYurUqeZml9u3bwcAHHLIIfvbpIyhQHIILl7PqquE0izYhEkZJEVlSj2rWuIeV6mESRqUVdtTiYGanB3RHaqbAtFBpulSuJb3bKd/QWWK4P/MmidK8cooBJeYlXQ+plkvdZJi6DLzqxISy9VJWMbgYESRqJkzZ6KtrQ09PT2l8vXr1wMAjjnmmKEwK2M/I9U9b5+kLhAKdYNA7xgHsZ7iUUoMBakrdzwpdVBJzYNReKOaH5RAQun9VDxyQn7VYJ7F5nu+fBlVl19HLVOIt6BrX4/vKhlPeEZtPeLMInHripTNgb38UK/dTLIGEyOKRM2ZMwe7du3CPffcUypfsWIFWltbcdxxxw2RZRn7E7bbW/BEmccqWPqVQdIocwdXX0Qc4MX2UmegqR4KdZYveTvC7XPdiphAXpvwfCUng6eSO/d+Mm+ORMbNqlEZyRsrPQukzYSzKJvKoxOe0dTjiuTHIYEgKakM0X2jMocaVAybnKgHHngAXV1d6OzsBNC/su3uu+8GAMyePRsTJ07E7NmzcdJJJ2Hp0qXo7OzEkUceibvuugsPPvggFixYUNsjKmN0w+xslJyo1C0A5Nmm+9ka3oWOWT0gVZFJ9IZZSF5anzi42iQ01SMiDuaDZLuk21Kf6j1S63peNJV0KEWJhNNA8m+okppUUp1K5KTJmkCiErdBcNupYPByi8c6hg2JWrp0Kdrb22ufV65ciZUrVwIAbr75ZkyfPh0AsGTJElx33XW44YYbase+LFq0aFCOfckYGdA2yFTrWQ04M7vE877MrkzZwM+qp41ioogwMzc7fass0XOS6M1RBs5Ub5VtlyIjEpHE31Cto4UZBV3y7+x8FJ4Zyv+E5f7SpEGcIfjvqto3uDKq2ymuP9Xb7G+DEAvnBS9nNIhhQ6JuueUWSW7y5MmYP38+5s+fv48tyhiuUMJ5lpC9ikXoPG2XSLRE3i08rrqJDl2dFStGxG2wkB5CEr0WCSyK5RX5Idk4gRYfD414CyE4+gwlENNm8mOkSYNbyjbBTXgvmlr8kLihrtuA4mGi+oVwnseHLD2eFz7cTmZRg4sRlROVkQGQTkrZ98X0ThllXkcpzlKVzkroTPurxgcoJQfL7i/jnWhTISrB26HlSRlFyZuVql/Irdd4HVIkkVDJgUXdOYIuwab0BQSJhBPw302pPUNEDkUKhgmTGdUTpe1YHn+ZJC+8sw1C6v5aGRoyicoYebA8UUJOlLUnlNnpCqEFxSw190giP0oOlpwcm9aevBIpySNiiSQSH6UKTYqKfO6v3HiDYF6tuC51t3WFGEjeI5VQqOROkNFy5NImDdq2GOK7k+Cp3Cso2ODL+AtmDBk3sTyyy3k+a29wkUSiZs6ciV//+tfmtTVr1mDmzJlNGZWREULqKhZ51qjklgjbJeikQ5iBpg6uclnabNVWLwx2kfb1ihZ5SPNiqLqUATg19JlMSi27FBeZ7DUxW4ypkr0g/vMgCInha1NXwmpAU05kcql7s6UcQRULE2ZP1OAiiUQ9/fTT2L17t3mtq6sLbW1tTRmVkeGhsJhkUBPLFQ+PuteSNEAllqUSg9RBMnVQAXxPnjSAaLq1Mwvj9VK9i7JQIrESuAq3ySMZTLBYR5xYSM+McLfU+678zlY9UZdvuvbAJ7/jhl1JoTrLwx7Z4iDnRO1bJIfz2PEr69evr51ll5ExWCg+b5rbW5sNagOuIZN4HpwJdRCOVJPCRaI2qdNnHhGFegijUTI3SfUCWXLCb2/ed0u14tVStsVg38UL1QleC3nAJ21GdElkWdWvhCvVA7eTPVGKZyhezyxScjaV5zEazjPsy0iGvDrvpptuwk033VT7/Od//ufeMSu7du3Cr3/9a7zrXe8aPAszxgx279yDAw86wLxWqdT7D7PjStwnShrYhJmsXTEuottgtCcclJzs+VK8b+qAKAzUcshUUJZ6NIypS/KuaGXqbx/VRclr43bJoUizQeV5Fx4GQ5dGyNLdQMrzoJTJhEnZwkFo0NxupUFPVN6xfHAhk6jOzk68/PLLAPq9Alu3bvVCegceeCA+8pGPYPHixYNrZcaox69+9BRW3/wE3jj3tXjHn7zFu15pqQB7OwctJ8pvQ56lCm52rWNO7+SlfAnvcypjMtqzTFIdIkJz0UqNyEmGacYrREQmZClQngW1bjI/SpxsKOSVbi0RqWjKGHrU12swY++SDQLhVDzlhvJY4rg3wcwkalAhk6g///M/x5//+Z8D6D+j7tZbb8UJJ5ywzwzLGFtYffMTAIDH73rWJFGxF9876qAZT5Qn47c3qOfbmXIKq4krShwHNEOZIukGptmQSsiUAd8StNvTWFS1Wi2nPQg/hnTbxbPzUs81TPZeil4ZE5KHx5UR32fpfExDJHWiZN0I1xNl1RL6GcVjG/dEGY1nJCNps80NGzYMth0ZGTV4gw+Avp7wm6+ddxfv3AC/Q9V3JQ7rYRW1GaihKYVoMV2KJy81N0cZHBLz1SwzpFVpzCMiuDtUjxyqKC+ISB2UxZCYxHFT3xNJlzKJ0MhrssdR5WzS7ywoM98lqz1hkqd4iBOSz70NO/MWB4OKpnYs37hxI9ra2rBr1y7v2jvf+c5mVGeMYfTu6cP4CfwcRGWFir37b3wA7i+Md9bSUmOTMFkNxm1QkrVT97rpL4sV+GUihwpINiIREJTIq1slzUNiljFeAAzKCWVyWlFSwnAaYZJVKR4mo6ryjOoEUHhXxVB/qldH4n+DdBh61BNltL2rYze2v7wLvzNrKl00lmEjiUS9+OKLuOCCC2pn2xUx4EXo7e1t2riMsYme7t4gibJOKU/dJyp5lZ3SV4uDmrIjur1lQ6R9UiZ5FYTBlW7alzJApYb8kOgBGUwvWtC7UlhVmpjzEq1TvxIV1LxVUpFGkNTvpxBFhZyrj5Hk+FKIo9anKDcr9fmI7gvlLUApf+7p7sWtl65C1/Y9mPOJt+ANp73WayODI4lE/eVf/iUeeeQRfOELX8Dv/d7v4cADDxxsuzLGMHr3ND6l9pMnDRnhsOH+orhXK/Xg3eTz4IhUkkyid0X13khWKe0l5p1JuVQa/yOGabpSboT2eGhEJJXUKKSDN+CKiM+MMHFJDdlLHrrEiVKyJ0q0XZqQOIjtWO5OQp/+5Uvo2r4HALDqm2syiWoQSSTqnnvuwZe+9CV8/OMfH2x7MjI8QuRdT9yUTs27UQYjqUxeDWiUSUe6OJ+bOcdLkEklD9JBrpaEeN818iB6j9xqSmhQda4o30eyXbND86Ip7dkN+nwz/szoXjQm11h7rDA5h1L4waS+J7FPkXY1j4TzepxJau+eHDVqBkmbbVYqFbz2tZmtZuwbxM52sjob5Xyo5M02xeMlpEODE/OW5LCcp1usJ3TyGjnSZueaZyjNO6BAJSK2jMomvZrRBqU9yVQiomeahUxqgCxbIiJ5VR6/QQ1fxytKpMY8wDyO5FWECZMp97NLmmKLdjLCSCJRH/rQh7B8+fLBtiUjA4Cd81SCMhuz+qPUs7ZSPSKJ+0tZZcleBQOJY0oDyd8CCfWqiA0qXq1miJbihREGUrPR1HuaSl4lIhxXJBMf6cEiqhJItRzOU0OWLlJXsQl9j3Lf+4san0zFEst7ux1PVE/ewrwZyOG8hx9+uPb3hz/8Yfzpn/4p+vr68L73vQ+HHXaYJ3/iiScOjoUZYw7WKrrYdY94qZ2pQk7UXCAlR0QtTWE1ag5Roi6VHEmERSEYqbwq9fuJUIdkKX9GIstSc0leC8kDQ4mP8M5FC+wLyWf1yRMe91mWVGlpA6n3XdmrSmivr7fP+eyQKCecF0ufyAhDJlEnnXSSc35ZFV/96lfxta99rSSXV+dlNIvoSy0cLmxuZ6Ds3wJtENE28DNkmrAr0pwcykj1aum8o3FdzZ0zGNbdLyLM6C3Vqd4cU1cquXNJvabftqvx+yDyHhvikSMpXjTbJJF5C/UUDypRFi1MzcEy+7XI7+5vxpk9T4MJmUT90z/90760IyOjhnhOlOGJEs6RMz1cgzpICjKaKsmroLsoYvXSIOcVpY5F8plfQoNCPo1Zrnj3mjArKfdNDK9JBLoJr51iu+yJkkh13AuU/Aqo25EIoU5phaA4MUsilxGPcfY8DS5kEvWxj31sX9qRkVFDLJyn5DvJ+0RJg6Q4S1XCXeIMNCUXQt1s0VQlkoyoIqO8qZV+gowSNvN3W9eM1zxRzLsifCllcFWJgSYWrSPn2iX8zs0M3xJ3FcmJb5dAfCwbRI+ZRr4Gp17MyxvrXzMaQ1JieUbGvkTVcTdLHYmwT1RygrhlpFVN8UTJiT5xmeRjNpTRR8mJkqf9cbukAUTVL/72pqqU+y7rNp5bL1SneGBoA46c8MBL3irSXLTA+A1pHp1wT5XfxtRuySn3IY3879sUgXh7fo5U5DfIG5Q3haR9oi666CJ6raWlBYceeihOPvlkfOADH8CECROSjcsYm3DPekrZA0reIFPJMVDzmJTwU6InSkFz7YU/m6rY+XPeMRODRPbYABzV7gvpS+0F21l5CrlTvB9N+HO0XDThOfbFmoNgl3c7xcQ9yUOWPFPSPErKBETps7T3JKw3Odcrw0QSiVq5ciU6OjqwdetWjB8/Hocddhg2b96Mnp4eHHrooahWq1i6dCne8IY34O6778bhhx8+2HZnjGJU+8KrS8yUl2QCo5X5qhRi0ER73gx0kIgPLRSExMFcJVuNWsA9UQLpDVfRjWhEmeBJ879jmvcD8Im9tru7WGbWjb9zfi6Q+MwIRCTVs9wvF395pHdOPgUhKiLmw1n1wr+Da6N3IHHmVE0hKZx36623YsqUKfjud7+LXbt24cUXX8SuXbvwne98B1OmTMFPfvIT3HfffdiyZQsuu+yywbY5Y5QjeoCm0OHJK96UMquTETxRetKGZULCANgEcfSJiFBPdMEo46Fke4J3jtalvCdxoFag5MgpuqljSPiO0qDsfFY9gMLzzvOrBLmUeyXqSv1N7aOdDEFpx3KFfAmTm8ikwk2XyGgOSZ6oT3/60/jf//t/4yMf+UitbNy4cTjvvPPw0ksv4dOf/jTuu+8+fPazn8WXvvSlQTM2Y2wgfqCmX0fZJyrVE6XkslhQk0ftWXCCDaJuS1AbROLkyK4Wv8laUq1kln7fFV3mvYo/j1abNsdQCKcrQ1lUsP2GdAlICV/rZMV63l1dzbii4tVSw/OSM1HWFe4LLV0xEqwuQMnQkOSJ+uUvf4njjjvOvPaWt7wFjzzyCADg93//97Fp06Z06zLGJPyzn5zrQkep7KdCdaUkuRq6ZMKU6n1QjsHQTEia8XJvTrw9CWp70QLfCNm7opydpxqm/D7NeKs011DcJmV3bVWXzx7sqt7AHxdKfbbNuoMYgpNWBgv3XbbBvVexA4i9eF5GM0giUYcccghWrlxpXvvpT3+KQw45BACwa9cuTJkyJd26jDGJ6Dl4SkfSzCQ1tfNMODSYQVq9Jk2nLeVmg1EZiWhZdZUBKvVoGEOZ8pVpa4IuOTSoeCu9JPw4+G0XnhnNdKeO9juLtFTSNZh1lImSNOGRPV+Wrng9bSPN+NOdPVH7F0nhvI9+9KP4whe+gGq1ig996EM4/PDD8dJLL+Hmm2/Gl7/8ZcyfPx8A8NBDD+FNb3rToBqcMTLRs7sXq7/3BA6cfAB+/wOzSrvfu/B22BU6Em0Vi+aJ0tz4yqAfFWmKiGiDWANtRmVE8iARkagJNV2hZ8WE5M0ZPAIoOXxSB1tbmVZXIQaKx1bjrtLkhu6p5REBxSuTPmnwq6b9zkoYsF9OIW1CmZmLGWkrlh5hNJuhI4lEff7zn8eLL76Iz3/+8/iHf/iHWnm1WsUf//Ef43Of+xwA4G1vexv+8A//cHAszRjR+PWyp7Dmx08DAA6ZfhBmvW06lfUSy2P7nAD++K7s/kvKYrqprgSX/WCOh6E9eEpERPk+kky68fIxLFXU9rERHVFamKcJ7urrrgtVKoU6xbqh70d0sbLgvYroilSxC6kawVPj1hBtl2TMZ1QkVl69eHupkylLTA/1x/u++Go8Z1Kq9KcZMpJI1IQJE/Cd73wHf//3f4977rkHmzdvxmGHHYZ3vvOdpVypM844Y9AM3Rfo7u7Gl7/8ZaxevRo7d+7E0UcfjU996lM4/vjjazK33347vv3tb+OVV17B7/zO7+ALX/gCjjzyyCG0emTi8ZXP1f5u++VLJRIVC98pxENJ9k3tuCwk72MjGeWXSxsn0jYQ3VAvxXvEx8OEWTf1UBRMb4ZxhmyqsDoEoQGxpQIMDFLVogwjuFx3paXS/7urP3NSrC5eRLeyEIhB6hE59jYV7m8oEhizUJjwKCF1c6KktKdN8lKIsfesN9i/ZjSGJBI1gDe96U0jOlzX29uL6dOn4+tf/zp+53d+Bz/5yU9w2WWX4Xvf+x4mTpyIn/3sZ/j+97+Pz3/+85gxYwaef/75Wr5XRmMYN74+ivc6S2x7u8uHVUdJlRLaksN5hrGSLqOetIxZaF9EI96VIoeSjqNROlbVq9BMKLKv2k9MiJr+uo0/H0VllUqlXkewPTSQVSp1FSW7RG9OUfWALq+qSMiUOUNTK+oSBng1nKe011x4LW5Xyoa3/WYp7Rn1Er2QsZynmCc/k6jmMKaPfZk0aRLmzZuHww8/HC0tLTjrrLPQ19eH557r95rcdNNN+Mu//EscffTRqFQqeM1rXpMT5RPRMq7+qPXtcUmUc8yL89JHE82hdoq+XckrYiSClM6iBjXvZpC8TFqSq6HLHKc1FlUVZFLCNcWPpZSrFO+DQ8isRqjpPkOq62qpuEXUJlF52nMkEkDJBJmQJcqkZvgo7QknJQCQdp23GWC8XkqumJdjKh/s3Y9HfvAkbl/yIF55dntQbqxC9kSNGzcO999/P0455RS0tLQEkz0rlQp6enpkIzo7O3HTTTdh3bp1WLduHTo6OjBv3jzzeJnOzk5cf/31WLlyJbZv346jjjoK559/PubOnSu3x9DW1obdu3fjiCOOQG9vL9atW4ennnoKn/vc5zBu3DicddZZmDdvXuOJrhkYd0CdRPW6JGpPY54ou5NKkCHwc5tSWZQg0sSgkqpLyVGSklwpZ5MajNSpXShU0UiblCtT+FgphOAC/IgWVl1dlhkiwS2zO1NT4He25WphQfj30A49RWxkdZV7ZWqy2rREhMFfsMEqUsLzKuxd5+P3XSKOwu8V64YaWa3X0b4TD31vHQDgJ19YjT/+6ru58BiFTKIWLlyI17zmNbW/B5NIdHR04LbbbsOsWbMwZ84cLF++nMouWLAAjz/+OD75yU/ita99Le68804sXrwYfX19OPPMM5Nt6OrqwpVXXokLL7wQkydPxqZNm9Db24tf/vKXuPHGG7Fjxw585jOfwbRp03DWWWcltzNW0TKu/rz0OeE8b6PMQQjnmSeVW0XS0vq0sqb2WpIGDJEUCiVpoRmt3BwwBJM8XUU9hTymlMG1JFPhco0OpRWiS75XRbMqJIwpey+rNZtqlxK+n8zNlUdU3J8r9fgb+TWRYp+K7jhBA7R+xnxThZmSP4GM9J8NJJZvf3lX7e+dr3RRubEMmUQtWrSo9vfll18+qEZMmzYNt99+OyqVCrZu3UpJ1P3334/Vq1dj4cKFtaT1E088Ee3t7bj22mtx+umnY9y4cQCASy65BGvWrDH1nHfeebj44otrn3t6erBo0SLMmDEDF1xwAQDgwAMPBACcf/75mDJlCqZMmYJzzz0Xv/jFLyiJ2rRpEzZv3lz73NbW1uCdGMUIkG7fvdzY9f6yhM6G6Uo8viVlb6dmDnf1yYo2UktH4kgDRupc3aiqfF8n1FU1ErgBkVsaZKW/rnIfAp9L4TzpS9GCSguT0VD0RFnJ7kUZv25hRaf6XCnkNWbsAFJDYqbuuC6NaGkTM4n/Ja4eTsoHjfWnARJV7cmbSsXQVGL5YEH1aq1atQqTJk3CaaedVio/++yzccUVV+Cxxx6rray75pprJJ19fX248sor0dLSgs9+9rM1W6ZMmYLW1lb5OwDAsmXLcOONNzZUZ6wgNLbEPE2DdrxEaodnEabUMIg6IEreB02Z36cOzv3Tw0rx0UEK1ZWIT/2jxFWCIbhQvYhNjhDbSULdId30RInhPMmrqrKaKupbSxSK6RYOTbYnPaNuHTFkr+15ZtTz9FjtaTZ4pwsYFikNKN85xv1iOVJF9PY0MVEaI0hOLH/88cfxx3/8x5g+fTomTJiAhx9+GACwePFiupt5s9iwYQNmzJiB8ePL3G/WrFm1643iS1/6EjZv3ozLL7/c03vWWWfhu9/9Ljo7O7Fx40YsX74cb3vb26iuc889F9ddd13t/wsWLGjYntGK0Gw/urok8tnUKXuirA4vPiu2oC2J1maBSbtPpxI0s0goEQdEqb2AR8QSCU68GiavoT20rPvAlRVzoiSOG8rVqhgsRlZcFwvbRJ6/ol1FEZbz1V/JVyTs4m8bYBQpm0Sq6lMmXSphUuRUr7hXLV4v1hc2sjrPTb3I8JHkifrVr36FOXPmYMqUKTjttNNwyy231K7t2LED3/jGN/Dudw9+AlpHRweOOOIIr3xgxdy2bdsa0tfe3o7ly5djwoQJOPfcc2vlV111FU444QTMmzcPV199NT74wQ9i8uTJeN/73of3vOc9VF9ra2vD3qsxg+KYFyNJMaKhdCRqTpSiS8lVsOopHTOD0IFr3qo0XdrkXfsyyZs+unYUCUYLJ1GaWXWhsJc0WNWrw1b6ca9dwMSKLSMfeDyQE1WYKnuPAhsjixzK+X5V64LRfr+auIx5IYWAUrF4X5B+CoLWXuqO5dJKyVgo1L3cSDgvb38QRRKJ+tu//Vv83u/9Hu644w5MmDABN998c+3aKaecgltvvXXQDHQxmAnt06ZNw7333kuvH3DAAbj00ktx6aWXDlqbYxUlT1QsLyhCiKTwkLj6JSXngOlSWFTKIMbsUney1jbSVFiUW4cUKzllbpmQd6Nu4WCL8HtVJmTp37tfWWOr8xRV+jBmS4Z2q5e4XTFc2dLgzqQi8U7zuFh6tPc3CakTIKss0faU7V28z5ED3jMaQxKJ+tnPfoZvf/vbmDx5Mnp7y8vTDz/8cLS3tw+KcS6mTp2Kjo4Or3z79v79K/JGmMMYxcCx54kKv/T+MQW+eo0MCR1sKmEybTDqeSGJxgdXKqTOzBP3xnIbbHRMKebTSMQu0HxpKwFhoAk1EPREmURYeGhUhAY8MmGUdz9XhARiWjZp8O57CKmTFPX9VU448Amn8SwMYoK4ZGfCZCpKsrK3qSkk5URVq1VMmDDBvLZly5bayrbBxsyZM9HW1ubtQbV+/XoAwDHHHLNP2s1oHhXwXIrYsS6KJ0o6t07ppHwRiTCZZYInSotjNeUY0uoKYQPl+9lye/8NhODk/Kq9aNQhHbwFwfwqQTfzalVtGRU1s9RQFxk86d5VAV3lJl1P1IBM/Ev577rSXjpkNcKN0FbbWrrjuqSwnCGXtKClQU9/RmNIIlG/93u/hx/84AfmtRUrVuAP/uAPmjKKYc6cOdi1axfuuecer83W1tbSuX0ZwwulvIzoZpqR68I7b604kciXPLOMswwl70E/U034PjQ0KHofYnYljlADuloCCc7SVg/FsFLIIyLc97Iuu2mKgCOKerXEe2d5fVQOZWjzbFLDedymgC7rkfHeJ5EtK55ehVCYNsR5hy0ktqe89yZpi+saHE9U+XNodd5gkdvRjKRw3vz58/HRj34UBx10UG1fpWeeeQY//elP8a1vfQvf//73G9b5wAMPoKurC52dnQD691i6++67AQCzZ8/GxIkTMXv2bJx00klYunQpOjs7ceSRR+Kuu+7Cgw8+iAULFtT2iMoYhgjETPoaTCyXjl8QOzxPJDUMaIkp5CthcGV1pfPHRF1mPZccqV6Fgc8NbqHktlmqEjiqRSOJBVWBZ1MZgEsoEbKC7SkhOEbu9Ju3V09oHyxiFxlYQ/lVjd73xuWc30ZmMEIDirdZmcioZYkEUOoHIgtxGgrnZRYVRRKJ+shHPoKnnnoKl19+Of7xH/8RAPDBD34Q48ePx+LFi/G+972vYZ1Lly4t5VKtXLmytlXCzTffjOnTpwMAlixZguuuuw433HBD7diXRYsWDcqxLxn7DsG+t+FwntKi2Ll5BE7RRAqF/AXZE5AUXtNUKbqaIm1ErhJwY0gJ9kXiEwoNKkYVUfSSKr9PQBUlGaxOYKCub3GgPf/MI9H0SsaiTOnrSbMS+rmcIxe3S3qOTROE91AhberkwyRDQjWFhAoe9qgnKsGzn8GRvNnmZZddhgsvvBArVqzAxo0b0draij/8wz/EjBkzkvQVt0kIYfLkyZg/fz7mz5+f1E7G0CC4QiiWWC7lRIU/99ezygSyom7qFy0wbGD7RHkdYVyZuvu5NFNW2KQ4mA/MukubWio3yylmYaWUAZh6ohSzAvedhRn5AgI+gg3cL5Uss3LiHAvrojaF3uO4SaXvUtxJXTFMeif8IolsSaSNvatVBHe9N8qSt2CRJoJiv7AXOZzXHJJI1Mknn4wzzzwTZ5xxBi644IJ9lkieMToR7VAaXL1n6lRd/UrHLE95G9cl91GJA0F/seIxcD420R7ztjWcx4SA7SGvluxO9FX5VRu7dxXGWIpqArsElNpn5I4N5sy+EOFk5K5EXosksUFdkfteo1Ap5E58eczblXIKQsiOmGNUeYySPWaRtiJkN+8T1RySEsunT5+Or3/96zjjjDPwqle9CmeeeSauuuoqPPTQQ4NtX8YoQTmxvHwtRoBiJGtvpaiM4omSOZRE5Ix6kY3wmB3SUS22KrEjFpQpRDVgRyicpxEybTC3b1XoJgRyoqpGe8RUgG+9UOZGodi2YZX6O7uq9hrQsKetv7JtU4O6gvtzhbzTqe+qIWd6b+yqQdAcQK/9uE1qrp1Ur8ED2xvJOc0kKo4kErVs2TJs3rwZ9913H/72b/8W3d3d+Pu//3uccsopaG1txYc//OHBtjNjhKORfBj3s5t4rqy8EziAXSYniloNOJ/NDkiYAVsNKESOblgZ0W01V/Q+tNirxBpeDTioHh+NiCjqg6vzBuo1epyLK1eyXbSrdt/5s8B2SC/Klc8GTGRkAyiFZBXi7X72nysLkjdRDV8rMtJqXtJewokKkh6jSY1cRm5AJlGDiuSz88aNG4e3v/3tWLhwIe655x6sWrUKZ555Jl555ZV9umN5xvDGzi1d6N7V418ojkExd3I0M1KYxUmMyS9Tq0mhQaWa2EcppI07c4QZfMgjwqJKpD3W8QfzaYTxsOTFCB0abLpzeHvBjTv3FrQE9keyCKffni3j/TaS7QUZidw1vrWE4kVTvKUh8lD2JjZO7kQOpU1AFKTPUbR+xqymsKiwSPRz4EDiUL5URj+SE8vb29tx55134o477sBdd92FF198Ea997Wvx8Y9/HGecccZg2pgxQtD++Cu4fckvMGHyeHzkmndhwuQDClcDs87Y6jxlwBVW8Cll8rEvhgnRMKRRsbl9ogSjQuUBO4rfpTKQACwmMrHmGj0z2FdWGs4LdfkAXKlU+q+rYwHTpXirHLkqYSLBA4Ed2y2TijItLRX07k3OVu67+BNSocbz2gLvZaOn7ajEp1qtKVfrJPcNhqDkubZkEk8S8D3EkX7I+Rg6Sy8fCRNHEok6/vjj8dhjj+FVr3oVTjvtNCxYsABz587F6173usG2L2ME4Y6lD6PaV8XuHXvw6I+fxh/8UfF54J1Z7EBMKS9AmQ5KPaUlYnV4vlzSQEDruKRGkBFJjRYqKfxtr7QXiU9RT+P7FbFyNb1qIHnZ9044JNFWVedQAQZYbo9tcaASgIKuFqPQVRXc/LK6V48aPyxcJmJK+BABEUbI/HrCBEQJX4vPaPLmuVa5OcPSdPn1nI8JWxxE5QORgaqbS5HhIYlE/fa3v8WkSZPwR3/0R3jve9+L008/PZ9bl4HdO/bU/u7u3FO61tdTfzFbxpU7z+g+UNJsLN6RDKYnyir0zBb6n2Y65mRPlMKhXG8HUW23Z/9gUu5RoJiSBxeF54l50UqfQhzDsj3EQ4RtoiqBfakcbaQ9QkQEL1qM1Aw8/6VNTkvErkF3YuPckdZL4R30lVDfHUVG6EOSPd4pqwgjk8745/rfmUPFkUSiVq9ejTvvvBN33nknPvrRj6KnpwcnnXQSzjzzTJx55pl429velncPH4OojKvUTgh3Twrv662/jXESFek4GvWkBMqSdxCXPFGJnalRtZmZshJuCLqZKvZgzjwBdJxu7oi6spdG9QyxpHimi92GQBiLhfOoTCi0XSJIRMb4aUJNqqvgilsOpOQkNcpDymHNFLIgGEZzeuLtqe+qdi5e5HNAf8P1VLY5IJ6YWF6tVrFx3VYcesTBOPDgA6jcaEdSYvmJJ56ISy+9FP/5n/+JLVu24D/+4z/wzne+E8uXL8e73vUuvPrVrx5sOzNGAIrkyA3RFT+3jCs/dtEddBUOJeUlGBWVHcuFVXZWZZtoJXZ4Eu/RSI00QBb+rm+c3WDv7CCUT1P2iBBDirpCB+E2OJqXPEOkMt3/qd+AgpxNDFzPnnnBUG2JlA0LVvVkQrpprhaTCcVRa/q5TPB3Nl+5wDtObqk4r0gmPpYum/8lEqSUY18ifWFsi5m+4nMbIFG/XfE0brv8Afzgsp+N6QT05NV5A2hvb8fTTz+NtrY2PPvss6hWq9i5c+dg2JYxwlAiUY4nquiZqrieqIiHI2W3X6WzMXVb5MtSFTfBLhH7mkbzHEhzZrn5fQL7V/EVZ6Idez8HQ09FhEiG0F55JVy8usIygisLi5qoqviAXxKrBMyipM3WFdxNm+aGVc2/gxt3NvpbFe0KiNGyEiFrbGPSqG74xIdqUliUsMGldgpCvJ7fn0bkEz1RD/zL4wCAHZt2YdP6Dio32pEUzrv11ltr4bz169ejWq3i9a9/PT784Q9j7ty5OP300wfbzowRgFJn3eu+yUVB51JkFqN01sqeLtqqGcuAtDIl5CclxwIia1OnypYqTibJEW50gKKDaYirFO4VW3HGyFHQUcPOn4OtSw4ZlZUVG4zWDeaGDcgU/hvcsDLokRsggPH2gmBkJeHd8VZ9Ul3SLKVgmC2nhrjNsJ83sRAJmfJ+ifX85zZeL7q3U+QZz/tENYYkEvWhD30I06dPx9y5c7FgwQKcccYZOPLIIwfbtowRBjlPxRlNY4mOWjjP+SzuWK7kYqSW2TNLbXYrjSlK+NDU1egAVRGEOOo7ZxfL3OZtbwcNK6m7fgvbBAR11WQKIoHbQENUhGi5MMUSx7GBauq2BIrtIdLm5VdFSFVopV+jIfsS8RbieVoaU9wmwHjvlPdLPjsvLhP7Ms3sYK6SqMYPBB89SCJRa9aswXHHHTfYtmSMYpReTLdziu4TJcwaJY+BRXwEPWqZIqPObiXPWkAitFy9we/DBnM1Kb6upzHi098GqRJgNaWPQqJ32SyBRQW9diQkxtpjbLlSCa9AtMxyUTVkAs9VaKsHsz1PqFCwd1VkMMQX4q6Nvl80mmcrkrw3ynsDbWIkkbYGJmthYhy+ebGupXgv3LQMBsW7OlqR5OjNBCqjYQRmh94+UbGZleSVEQiTUaZ4j5icQjLU2a0UVgrltwhhpZBdiudEz+/aqyawUzf1UJAGw+G84n0QDFTyigK7mpdAQ4P2b0MJYIFDBXNelEP9gvsxFcVsXcqKQbcO9aIJ7blt1soCy+0bfd7Fl8Kpok0apA0qhb4IgHROaMNbGEQ9UfwaQ/BMxVGOphPLMzJqEFcBNbLZmyVv6lD6RIGImB2gfJhx3AZ9dqvJsfbZeWkpOzjznKjC38FwV9WTCQ6awvK80GI5kwAG2gsuEjNCkanEwGwwJEJsL5PJxnKwgj8/81gR0qYcf+PfKkb0BVdNyANIzvSTc3oERxQPDQovtRDqNz3lUnthNVHzApNaecfyMcwkxvBXz9ifKHVm0bPz3OuGvsDAYuo0K2kdoNCfm4VSYrk6u5VCkczbEahD2qOeE4LQAdN1GS5SvFfSxpahAdgQCw7SgcTyuiLaBJVj4TxJl7J1gafKJst6GJWIlch5wHvEyKTQnifW8CSlMU+IFAJz+xRxxqP1V4IMWD/m1osQtJjnyRUvhPByYnkcmURl7BeUZjcRwiPN7GJ5VIYNUjhP2dsJGqmRwoCU1MQ7ryB5YB4KMUekPHDa7Vkr+MK6AuG8ApjtZU9bQojKMsmVIffHXQwhtVe677ZMmAgbelyw3c8JSQzuVyTdK7vcLvDLSroaXZ0X0M1+Qj5piL+HXl1x4Ub4BxvQHSdHtK772bUrsvddLBE+aXXeGN7ZPJOojP2C0osZnUm5dQ190dlXvA6T8+tZhUKZMCNlg5o0poS8OSScJ3fU1sgZ8jwIpCbl6BRmu57gXLbB1sUTquv5XMUyrkzaKDSUpF6UYdszFG0XPDCVgFuLEWHJIxf6DVsUBli0I/zZKpQImeY8SkmRqiNwbEq9TOifLDpm5XbGtoQJhD33FoQ+Bvtq2uYY9lhlEpWxX1B6yWKhNyXEFp19aYQpur2CaQ8jP24nL3QsbAan9PIBQiatcIvpH9Al1Akd4VFSRBOOGUMqiJSYD2+uUZIRJgYWAwy0R1a4Kbtru5UoDWG5QLaaBkKRcXdOOCneJ2RhD6fIyOzmKKkuh1E1FtXwUUhclQRTVaI3p+mzRwPkVGVRecfyjIx9jPKKD35Nud4vEyEsoidKOy7G1yV5mSS7bSiJ88p39srVcF6RkNXOnxPb83TX/CsNcyjKx2S3FpGhoUhbV3CXgAYhe3wkZ06jxMepTomIrVZdpVgh3kuH4VJdkmeDPjSw/0agXJhz0e8rTMSUHCzVExV97xpdjRf4oordtpKxg0yiMvYJghu4RTpMaXWe27kIhEUKwVlQ+7EEXU2tHpJn+YE6rLmiHBnMSyIsN6coU0HARVGUEwZEeak9W51XkAltFFjnfxKop8ayyWpO+I4lEUZEiJ5gLlqDm44GUbvtfNLQ8LJ49Tcs3XbmPYr3MSqL0l4pQUr0RMVzSl35sCkheXXi1JdzojIy9i1C4Tx/nyi3sqFPmSFJsz/XTqstbYbo64rPSCm8vkv4fiw3J1BHab+267cgE20zzqE4YSHthT0iRKZBUhNMPhe8K6UaQe5QrbVHQ5EKWS42F1oVKYQGmccntmN5zDC2LYFlp9WeEs6TPVFFkGeGPmfCxEjxtJlzPMEzHu0LY972IItyLtFjqrInKiNjn6KR1XnRlx6IzqbMeoInSspjYpC8SlrP7BUrqwbJyFm8D+oOzkXUBrvQAKyQmkqAH1GCVLBdIYmuXdQjZxMf6oFpcjUgC6+pM316lIkQ+izJBSco8d8wvNmmwWoSnxlzf64QyG8oEx/zcYhM7mrljpzQniliJpGbDQY/R9MjGuFQkQlvrHwsIJOojP2CxsJ5gj6JRcVFvMJ97YmKdHBMm5kv4X5mHooAqREMAZ2ai7pqA2KgBebNKcsU21PZQxxhJ9OAK0prLuhdqQkVZdz2CjYxYlAik3HSVmwyeKfIqkhKEoP3geRE0fbKqLUZyMHix+1YinhdV47aTllU5LPZflxGrRvKaTLtaSBHSvGghcrHAjKJytgvKIfznGuxl1rYRVxwMpk9l9+/xMkYhdQzqrNbwQaV0xT/LvwOYe9KUY40ZzgebGUFodpozo0fzAOB6/xPbI80qKfvKN4cccWgxlcKQmSiEtouwRGLNqiSyYia/vZC96q/oEVZ9Qn+zIiOqLKu2kKKgFBRV6Q/M8sUGRByEvAUWWXR/jREsgIESykfC8gkKmO/ILSBm++dCXcCgO+ZUfZmsT1Rkc+knjLzanSX8bAuTX8NgkdEJSI0OdsK30RA86tKQoU2Sg0aNhkwPSeh3zm4+WXMKMcutuWAfKsK5FVIsKJ5TAUUvVohck63xRBtL+lusQrd9lhlEYoumsPjfCzd0wESFe+HzHKhn5H6IoJYzlc0nOdN5Pjn7ImKI5OojIbx3K9fxt1f/zU2Pd0h12lsx3KnskR+UkmNQNiaIDq+EK8THFQU5SS8wdtTiUi86dDSd9PyhPtQ4j2ho1oML5rXPCMizHsU2PVbyvOhpI09+04CGdEltYdA5MwKY7kK6HMVIki2N0d9/gZ0BZ8rg/i4VtG3RiF36isYmlyQMnUrFZOcRA4Ijnq9Ip6o0HNEyVImURkZOlZ8YTWevO8F/PCyn8t1GgnnSZ2S+1npgBrjIcF6ipzmPSp8FgcMBjZA8cGc2OErKxQTj0iQABZkaHpVnACywVwJ1alE2L0P9QRnMRdI8K4Ew2aFe8V3eiA3nranhVElhPLHlN+w9LwHdBWfGaOqVyAQTlJz72dh1pD2CLEGDZl4P9dfVpyQxtU07OmvBmRzYrmHTKIy9guCm21GSJPZ7wt7SXk2mD2OJxTVw+SkzS9VD4xkA7/EBp/iPWhRN05sMEndH+vqI2KFTPOpV8F2iESy1BU5RsgEPaHnl245UGyPquJQCFlJvOrI2WHU0mchvNvoVhYh0HBlucGC+jhZdnWp3iOLQ8nhPGVfu2iB1s95dQUW5XtOw7YEw3mMlI7hfaLGD7UBQ43LL78cjzzyCHbv3o1p06bhE5/4BN7+9reju7sbX/7yl7F69Wrs3LkTRx99ND71qU/h+OOPH2qTRwRCG2hGPU/RY2DETknIiZJ2Blf3e0qZjHnkoWrqb3S/mHJ4w/YeqaO5yx8sp0bIUzPwMeT4avTehZfHlyRtmxh5ZZ4h1S5mR8J9p7lahKxItzBIHkhyNiNHIQ8gkSkTzoBZNQ+gbWvIrioV8vVbkPLoAsWal9p6n4V+zilTPFF++C7c51UDDdCcqGY9nCMYY94T9bGPfQzf//73sWLFClx66aX4v//3/6KjowO9vb2YPn06vv71r+PHP/4x3v/+9+Oyyy5DV1fXUJs8IlDyPEXCavFwntVARIdpVGNEhDTF21M6ysCsNbyho2GEyjxKHMr2iHhVyGDHRnPJi8YXiXlyRhMBGX6vlJWFIPk0pc8hj4iSM8RIm9teIXyoRJVk4kPuu7TZphSmg3PfyQo3kXg3IhOSS4riNhrNkzoR4X22fhtLLpAaUatXUhubKHL7vVCgkFj+8lNbccfVD2PDL9pN2dGGMU+ijjnmGBxwwAEAgHHjxmHPnj3YtGkTJk2ahHnz5uHwww9HS0sLzjrrLPT19eG5554bYotHBoKr8RrMgZJyi5R+S+lQZRZlFQk2BZpTN3RUlCmn2pfDZgEiIg3U2uo1epZdSRXzopHv5zVnDPqBgUPJ54qWDUA4/ia8MdWATKBNRsiIB6E/v4pkS5cNK1QvvL+kvVBOFAe770Ss9FgFyCu978SmgO0snMeSp1MmYlpCuNmc8zMrE7VwOyH72SKKUK7Uj/7+frT98iXcdc0jlvmjDsMinNfZ2YmbbroJ69atw7p169DR0YF58+bhoosuMmWvv/56rFy5Etu3b8dRRx2F888/H3Pnzk1u/4orrsC9996L7u5uzJ49GzNnzvRk2trasHv3bhxxxBHJ7YwGqG7bvoJc7FiX+D4m8V4puVNKIWykrMExxGswnCNs2RBohww+fDbtfiyOnIF2BkRCg11JD1u1ZQ+IjLSJUSVJqCLExGpJ8VVfpmzX4OVEScnzUs6Q6M0RVimG3WhGk6F7xULOsGWCuggjozk8QaJPQsC2qqT33qyS0J50QHGDW8qU6hNPVNIEdZRiWJCojo4O3HbbbZg1axbmzJmD5cuXU9kFCxbg8ccfxyc/+Um89rWvxZ133onFixejr68PZ555ZlL7CxcuRE9PDx5++GG0tbV5Luuuri5ceeWVuPDCCzF58uSkNkYNxJclvC9UuLfQPFHhz4peW49IjiSbFKPqf4bCeXbiJr9PyiG+0sG7ji4+tjJvVYE8oBCiCgxiUggnlOxe0kVEigWB3JwSyYXJocoQVok1fdCvY1NMV1GfHF6jMoH2Bj4XPF8pHs5ivYT0scB9L35/YldwgYTdtr9nXdqETvd8RTrhaFN6/0v344v16QVdDR80PcIwLEjUtGnTcPvtt6NSqWDr1q2URN1///1YvXo1Fi5ciDPOOAMAcOKJJ6K9vR3XXnstTj/9dIwbNw4AcMkll2DNmjWmnvPOOw8XX3xxqWz8+PE45ZRTcOutt+I1r3kN3va2twEAenp6sGjRIsyYMQMXXHBB8Hts2rQJmzdvrn1ua2vTbsAIgrxnUuCYl6hOidjEWZS0ys+rRIqdziBVlzcLLPxdCQ3mjYZKmFeBeL5CoOEu6hoif6dkZ6eINEwMQqHBmpA7ChNdcZvKIT/3GSX3lKhiCRleCI6EUamnxi7Wf8NGQQiZmhPFkvDdcxSrvcSTMiBTVCVNimCfa+kiYbJGv27x+1mbDLufo54oLu/xugFPlNsGuTfVvioq4zKJ2udQmeqqVaswadIknHbaaaXys88+G1dccQUee+yx2uq5a665JsmWvr4+PP/887W/r7zySrS0tOCzn/1s1M5ly5bhxhtvTGp3xEDjUM6+UOFZS9SDk8ahIu4HW4Z2lFXEY0heQqelJvDdgjPzusjA36F7wLxH5ea0nCg+QNm6KEIeirJYwQy7Q6d5U+5nNiAW2xNyosoeH94eyzMrc0nBA+jczyr5ERWPYyiMCmJ7UZBvJmo/70EnWtGs0AamA3+Edt6n5NV+tiotFaA38vKUNujSWE1sB3CrObNPcz8LOVjSBNO7rHSezKiqaZti62jFsCBRKjZs2IAZM2Zg/Piy2bNmzapdb2QLgs2bN+PRRx/Ff/tv/w0HHHAA7r33XjzyyCP45Cc/CQD40pe+hM2bN+OLX/yi16aFc889F6eeemrtc1tbG5YsWSLbMxIQ9ESRTjx6VpPXhtJm4x2Xku8kcyhLRugoQ8QuuB9TtS5TrQ0EXDf3HhXKAzkw6iq+upBd17sFyiyfEoPCByV/x7GLy4iur0ZDYswuNa1ISfxSctFE9xGVUslyiYiUizwZVxf7esGtLBi5KwoVlZlmlD9XCo+oOsGS+rd4fyUzDvY+EzWx/jck79pZy2+NtVErH/0sakSRqI6ODjOxe8qUKQCAbdu2Nazz+9//Pr7whS+gUqngNa95DS6//HIce+yxaG9vx/LlyzFhwgSce+65NfmrrroKJ5xwgqmrtbUVra2tDdswkmB1LJZ3ofyehzuQ6L5QSn+jsBrlfaYsyqFRqboCJoWSs2s5IsXZdAhC6LHoEQk4KGi5loNVGOhE9qBs7hlMBq/acqWQLAlr0nGsUs+J8sAG6pIMIaWUPDjKSqriRMR9fniIqvBBWlnIZUpEhIQPqYfTbafGxwLe0iLYYoRSc8pzBTCizz1RzufE/ioUVmNyKakOcU9UoR8nHqfUjUhHI0YUiQL00J+Cww47DF/96lfNa9OmTcO99947aG2NGhjvn5W0WnqpIjF4r4nY6hFiR0TE9lYphxRD6LiMuiavCxQEO/nCABWzo18XuVDyfAUMKw2I8YGMmk4IRggCxwiGgkr3ylVmDJCMtHnflbkoiiLEe1Ql7YW9WqYq2h6773ruGyFtpD1mVKXw3yCHEs4/VPcyk44KCuYcDgihYLrWNzCSUmmpNLQ5pZ7DaT9X/lUiE+k7g8GGPlJnDIfzRtQ+UVOnTkVHR4dXvn37dgDAIYccsr9NGnMIriAhbubQ/i6ARWTinYl0plPC2XncAxPuuMIXuIyytL+I8KHBzENRsL2sjeuKSpT1stHcHYDZHjylT/HxMJw/VlTDdFFVtvH9KwsZyYjfBw4ywhVCYp4YZTVMJpCLpoTX2O8cAF8NKMxSCs2HQ9y27ZzoK260glxoxmNXLYmFCKdponivSpNMaYIZ6SsD7dLNNj2dpqljwhM1okjUzJkz0dbWhp6enlL5+vXrAfRvnJmxb+FxKLKSI+X8JatufyPCdMvSE9Nr2iZ0lHLuQkSPh2J4w+74VC8GDc2w8TDk6lA8IqEEYFefa6tnF2uwONCZVe22LDmBAJZ1BUSI7VRVkAgXm7OfB8ppQhMXFqKyZNz6KocqGq+kmQV2irc9ryFdRl2490og3pUKJYCNTp7kd5XIJMzJpLZifV75o90PyTuZjwFX1IgiUXPmzMGuXbtwzz33lMpXrFiB1tZWHHfccUNk2RiC4gHy6rgqIjoC2wDIOmC86Ipt7PuQjrlsU9jGGEK5MlVLJqiL5dMUZIKDmE1YaIiKGcJIaUiOEEBme9BDIYzCnIgUhWwZ96OytUTQpAJ50HKnlO8XJ239cnZ75e/HiUGRiCho+NiXEANk5LVkfECT9WOLrIa+96FnRmE/tJ+JdUYuKQqzqtDXZGQp50TVMWxyoh544AF0dXWhs7MTQP/KtrvvvhsAMHv2bEycOBGzZ8/GSSedhKVLl6KzsxNHHnkk7rrrLjz44INYsGBBbY+ojH2H4AtXcgNXzfL+glgbCUTN1lT+aBEtLebCO65StnGCnTKp2SsTGDSl1UqCHaU6wZiYPQIz7oAK32yzLCaEqJgdcGyXxmDiAXRvHAtRMTDC2eBqwL2G2R+UXDTwMKopZNQ3ERyb7fAhdQBSFydvjxNAhSzHn5kUz1DRzpaWCnprdeN9YIpX3ORi0X2gog1TG+ixL+LEcjRi2JCopUuXor29fmDhypUrsXLlSgDAzTffjOnTpwMAlixZguuuuw433HBD7diXRYsWNXXsS4aOIMFhL3dkT5HYS2/b4XxWPFHxSRuN7TM9pQ38lKXOoc4nOOAbs9sQ6IBRIFqhs/MKahpNcOZehaIg/5GlATFEOAdkwHlB+TcEESrqKuZE8QFRsis0mLO8GxrOi+eilW5EgPhIuWGBo1qKRIT+zAKZlCcDii49FlnTw6S8d7Vq21X7KOYv2g2AP0ABkmNWjHiNgn0pUyX0v6Hy0YRhQ6JuueUWSW7y5MmYP38+5s+fv48tyjAhvjy0Qzc/R156a1deaSYU7jxMY9ggRjqWSkXq6wJl9oDByFbKyi4mE94VsUDalDAPS+x1bKyNraGHQtmeIUTarHCKCzIAUwKv3KuIWKFB3l7N9AolSI3+zuFbRZ6/shBpJADqTCzoUshrKeEkQDjjaXR6jhJ7SJ17Vbt3hPwEJx8Kh5Jmk4qecJ3QIg/mQfN1ElvHAIkaUTlRGUMPNdRWDu05F2M5UAqxEWSkjiuSH2BB3cGZ0yu7veASbKNjDobEyIBBQyAE/d+PhbsKgkJPUikmqQc6cj6Wq/edQAkZFcWLIuJ9Z2f6yfd9QM4hr/QbspCY06DgAGyYLLOHtOjNCe9MT55R0p7siVIIJyEa/StIK6Uyq30lwT44KTLrBT/WywObYZp6Ip4oryHJG1+u1EdzpeK6RjoyicpoCKGOhXsgwi9WdDNO60V0dVgvfmxGZsiwt56OT+Ip87S9AsKrh/yOOXSEDE/IJZ6HECGLq6IbabK9lkK5aFJOVGAQq/GQ4p4KcAdqch9Kiso28mX7vky/HHtoiOFOWyUx8j7p+VWNhlHtv6W9xYrKQveKeZkYoRZ1lXfMb3DCo3ocQ16tmpCmi9rEJqjF7yd46WP9ku+JKup3rg18JhNhJc1itCGTqIzGEHpJCKGKvuiRF8/MdxJCdcoZUYKIr6vUmdryDEGbQp38wEdhg8J+XXZxCeIsX9v9UpBBgWyJfavioQgOrkq4i+QoefekJpdAAJlMaLwjngwvN8eozEwPP37xfK5SXTI5kjxtjqDyjIYgeaKEnfBROvelfKVkegt/4KuGjNLPqH1R9MeJkaTYPlElT5ct6lUh5CpvcZCR4SD0QrJcBPOtJ5N067MJIYlb0iuHguwq4UN847pZOI8RA9171GhYyR4Q3dm0Nsu32yuFqFQPBbmHoXwTZrsyuIYHcxbmsckrG+yCq9KKxisEkNnumkTvO3kgSqStOGmIh/PCJ/IUnxnbXsmz5+hSNialifOw3+mQR0fJdwqHD83OyBUyZMp1U7aY8fW54gE2TvaJGlDijw9x80Y6MonKCKJzS1fYa0Q628Y8UeGZke2JCugjek1vVbiKLSjObpXZZhHEIVJSrc7yqYdMHQj2CvZvPqjM8kkjTmiGRnkIMQ0I2TIoiqi7jEdVlWyPtVlrgz3iLVwRJ6+kPSblEjspjEovkfYCchJZtlkGnQy4YJMZyl7tusXPKV40TpYFz3KxSF2lXPqZjT4tkg4RO6uUpmgUmyZ1cjgvI6OA1bc8ge98aiVWXbemVpa0xYGBEIeSoHRKgQ6climzP5KzoX2NEIsSMl8Du5o7ygpVBZeIi9KAQawigwr/PYujeWh0jdsU8qKxe6wcB8K9qVpzfDVZ4Zkhaks2uXJsHqOQyb3/8ysbjQ60we5DYAuHep0iW+YDNCXxxQ+BQ5EZp2H3St47jTyi1ItWlFG9dkJnMWjhvMj5oMF+klxj40DsCK/RiEyiMih+9cOnAABP3P1crWxgT6Ta51pCIX8zzdkIISXmZ8sTJXh9FBe6+pIz8qDlWYQ6XVsXDysxo9wO3JZTVsGVmgskOEuhGU/hgB3lYh4iJWrFhGMKQhJDz6UGMaxplbtqmGuSkXh2r4ptivedyxQvuIJ1GeaIKtuktBeK2xb+Zu8hIzVem9Vae/UmufXKlh6hQ7LNvijiIbLq2l5+s5oswCaMxc/skHjfExWxZRQgk6iMhtDbU34r6scAlOXK/ViEBEUGQZsgCZ2S6BuKtuXYRFd2KZ08n75rjihAGqEaPsMtEgKIQR2ApXCQ4IIJeRUGPju7M1BSoyaDs1wZKcooE4PC8wDyG1JdtkzJMRS0y7ajCOWYmYE27QYJlEmDV4eQSVtEjJcXBEP9kuD5CrmplfeLyZQ5W3z2GHpeY2RO8uajQJaEfnm0IZOojIbQ10Neksgu5C5CL2rKEQnmy60ckhkgNdSmEjkKqfI7+eC4I7hzirwgaUCUPSLVuozs7jAusIEnACXsElodVWxPIwZRkZo+uzni7VCIiKupWpBRvHuEcPrkQXQ7WvXVQHWJTVKhQnONEf3gu1P04pI8HFmXEnFmXi011C94oiQConiiAv1ro16ruifK7e8HymGWA8DunXvQu6cXow2ZRGVIGFjC2ud4omqbrLkVIi5nJmspi3my6BlTQucv8DXvQml8EpOiFE9NKP+jPrpCyjehmz4KNpV1lQdz6uxghwZ7LhHL2PJnvmrLHqQpAXQFGUiD1IsRaE4hZOxe+YK2HPsNGfEJHcKs5fkU2pOOtVGeKzfkbH/BoHdWaZOFuD2xar09YTECfe1LtjfmiQo+xqRyymab3FW3tyiwxUHjOVH9/7781FZ85y9+ipsvuQd7unp8m0cwMonKkDBAntxwXm2TtUDyokVmgp4oT9gwSPGIeLMiS0hkUbSTJ7kRTpV6LlCIPMQ73aKHIkQeeCdf+CRtqcCja+qAUbRJ2Q2aD2JaeyUCyMA8BpEBJqIqkOfDmBZRWnHIT4kJ22SSouC+DHpXGl2ex3Q5tisJ/eWvVyQ+RdLG31XF44iSTUyknhMV2k+JhTXLEwvVxWlURmByyGYypF7IO2Q3QZ61gm72/jJy9Z9ffhi9e/rQuWU3fvuTNqvREYtMojIkMBJVeyFDHUDE5RzfYTfcAXFPlPs5POsyK1nFzGviG1aQs/Ms2PgrOihYc473gegJLcFmDVZJB8tCMxoP4e0RXcpSdHdbAsH0CAEcqMu/FCdkpD0XBvGO2WXKOPK0yaIc85CxEJz8zMRlOKcJkWXy/LHfObT/GLvvRITvS2UTXK8vMhfLBCZhpDzlPFA6qarZxi/XPpPfwpPf+z13bd1dK9uzK3uiMsYgBsiTuzqPnZlUDiFFOowIaTL7CT5ZqpdHzuizGqchQGEgCIbzlH2blJmrmFcEMmBQ8kDQfw6aEsIhF9zBieYV2bqU7RmaH8xFd46UnS2oKtW0Z/rlVWJhz4lhhf87kzBqKUQlLBsM7opRCokV22B2EW9Og0QyZpfZngOryfBmm8p9j+dpUSNcZaRc4VCeTAOeKG6C7XGSiKD0vo0cZBKVIYFtZUBX50U8UUEPhdCZBDfrpGotPZpdjeek2B2q2jHTUAnA84qYXVyI1ld24eYz80In7LTezH1odHsG17AqGRwYwVUjcBIxKFokbovhtBK1KxTnYWHUshBpWbWx9MjEXYAa8SlWDTwzyoHbJRlbVyknKvBDB08XMNpzwUN18ZsdFYl69vk1AGXvvEqWBuoIR3a1jMskKmMMIhYLD724sf2Zgsc5GKp9/abJ/gWFzNEOymYPwVVi8gApmFXyUFRs9WyAIp1m0NMx8Nn1KlBdjYUPXZQJkuD5Cp5LVrxXtMm6Lpa/4+htePuCslG2HvY+VcqC9L6zBQRlpm/b5OpSHKEKAfQS6eK6WPiwX9BuTyKT5L7736/qCYW7BkYSCxIBoqWF6myZWOenkN56f27UN+Q8qPtEGfUbPW90uGOUfZ2MfQW6+oItbY25nEP9gPAihuSZXmmWp4TzWN6Dx6GKM1eWE8Vmt0pP6HwUZt3yHlcFsARnaed2V20tr4g2J63aKoEReHcgZ78h25iUhelCP41AOMsDta3MzeeKhcdDKIfzytdKZrFjWESi1fCYL93TCjPdEYuzNmnhRlFV6Bml4crCO2HoZ+2bgqlEywupWR1woH5o0Q9Zjc09VBaJyp6ojDGIKluFV3upAj1qLHAf642t6qUX3e5tQuE1WrdB7qKf7UXUl2RCnpoBIWhEhHpEikK8PstvofeH5HOVxEvEoDEi4KjVZ7OC7dKqtJLxAcIZHDkVNPYA0i0HHDUNh1FLMoRFkXfeS+gnDbLz7rzmKuyBJ7oYyQg9M6X3i7RH7nvQI0eEaGhaIcuxOaXSf1Jh5xlhJsiTab9uSyZRGWMSA28De4EDL0+MvEQ5VMzlzJI2FRYV0EurssE89EVonoUhY6gaECxuExB2K5ByMmjSWyMmONNuserKEI8cuQ8K8VG5SnCgrpXbA0gxQhXycNKE48LfWu5bwkCTRNoKUH7nICmtGkIhZUSX+xzHOZTTpN1eaNuF2rNR/J3d5qgHmjxX6tl5IhGOtdcQSPgt1FZJnpQrnqicWJ4xJsFW4fHYeuRFD3iSQvuzhJWGRSQ1VC0bgAO5OWY4j3TeiCSrNji4SsQnpEq4D5JXy2Er3Klgz8yZF0P1okmbodLYjCsX0QMEznArqAnucl83STqfjfyIHrET7nu53C4Wt96iEwL27ijhvHB7pLzB96sSYlHF5qTwIbOp/Pu0sFW5dEZXUhS+DkJkCOnplw/oYuSLTbKtcJ5vzYhGJlEZGmovnVYeWuHhFTU4G3Lrsx3R2QqS4FYCUmjQIEflYg+NhvNCuTKsPbqhY5EAMiISIpwNDojcqwWpB1WSpSVvTjDBOU7avHvVTLQrhawIYR5p9/NAGLXEQ0iYpdHfuZRX5Ckr6ioWk2d0QKHZYPw9pB5OhtAzSogw+52DxzgJBJD1AY3um2dOHgMXS78FmdC65X0sZzbO8UY8MonKkMBfEptFNZZYHiYyZp8Rqm/IFAtCAw99wZlXgYWCPDkSxkJRhhtiDdThnChyQSVtAzPzSsguMmAEJ9MkN4eByLEB2G7TL2/cI8LbU+2qyTS6k7VrlmK7pzYeTuZhzQaJgfvsMbKleO0KHjnPdHYfSNvyu0rCfg1PGor9TODoKyl/kZTH+laqh0YQUErN8O85MYptgdNsiHkEIJOoDA3UjYtgef+1GIvil6zrsfoMtidKaCvQtLyBn7DZJg0FFVGaKXOySTt5MgOmLjIl2R1uiMr+bUoeCoEkhhtU8qac8ZwN1NIZboVNR8OjuVmf3XYX9XfF2Z5BySsqirtihHizfC6mKzwBGXhm1DAj0SU/owWxEEGqyfBnpnbXAx5AysiKnpuCSCiBWpo8SXPDyAyTyNRzm6zaAZZW6+/L5X1kfIiemzoKkElUhoTay6AmFEZITiPJkal7mfi5AP2fQx4YbRO8Yk9ZlAkYKcSCgt6VwuBa9+ZwXcrgGiKTtdwcBHJzGMo/TtQm37CKWQxbJDxmNJgcFhzDGs2VYcpCh/gWuSslIr5J/VXtwc8jBgwiYaEytWem3Jiy63xZjSPPPK8lIszCeYX7EMhFQ/H9Yj8hmzRQAhh4bwQ5+hPEdhwPTFA8UatvDh77UvVkijZlT1RGBgHbJ4olFAbDdXA7HufFU+LqffHOxutzFU9UAXTpseOhoIaS0Y7OlFnvXfhcCq+FbBdCRkoOVig3h0+niYgzQJXlioN+Y/ktvu3Fm2XbUoTkCSjc9yB3JR45tn9Q0ONI2ihBXmofD6PSTU6F31lG6d0pltuTruLmshqzC0nFJw39jyhNUrI0OW3bkyJfUJBjEzr6gVQLEa0G86uoJyo2PoxiZBKVIYHuSOtcL1TwhayKhk6j8fB1tsUBKZe9GMLSYzmcxwhZsYKYJEzbI3ZRwqp6hmgxGQgCtteGw1BOSuk+MMLJ2yt50YhcWW/c01bxW01G8PiRQntKkrp034tyoeddIjW8jXpMrKyLO6KEvKLA9yt7mQTiI2xmW4m0WRcU2guu3C3aZcvRexLpDmMnQBRlYhNUb+saZsPAZ2GfqNGGTKIyJNCwnbDJmr2MlvcWIT5WL4xch/Ge722zvEEhb1vJSQmujmIdqiDDUAyvyQfvFptjHMrr5OtMhN2HsgeG3FPXRLpMMQ6P98QcFKEwFhtcWYNBj2NRTPEMkXIEyB1RpmxYGWqTe1WLf1ZNGbYKzF+MULXrsDMLnc/KQgq+krEgEjgqqMi8eX6VTdpYOE/dQ07KfSuJkPtp6DY/l5UFi7yrkYOGpX2iRhkyicqQUHsZxO0EaFjEkDde47But4x1PCmeKBZWYm2HklWFmTLfuThwDxRi0KgngOiqeCxKAPtpQvxCIZPOF6Ecis7g40QkqIYM5iyEk0SWC0xECSdH9cCLanIotgd3/a4ZD9oim1gwIlKyKzThYZMUkQBWCzLELjrBKpke7z+89sXnvdBIVITJu/XM6sX+yU2toO1WzXJ7j6rRRawyicqQwM5Gqr9VTjHxWNi63QLns0HcFA7lTcj6aj0lHYGpd4V18qWBJ/BFhRBBeKZsNuiIkA6c3Sxlc08x5MdtL9hUXHEmEhF6r4rxLha+cPJb6K9Dw2ZlGXorinLKfkWsrvuxwWeGeY/C4Upy3ylCxKAuoqza5zlR7gtW8Yo9q4TfUJ0L8Byloky8b2BkzGuvwXAeDc/XimziYymxVs+FbK1Ppu0HV8lnHW0YP9QGDDUuv/xyPPLII9i9ezemTZuGT3ziE3j7298OAFi3bh2uvvpqrF+/HlOnTsUFF1yAc845Z4gtHhrUSZRTXoutB14eM5xX+sTrIkJObPWWWqd/q6BaNTSzTpcO5gH3ijRTJrq4Kg5CahiUA4hdk5irXxl4ECA+jIjwTrjOahgv8BLZSwMU81DQ1grEm9teDpHao6uyQaZ331mojv2EHg8hYVT2/AXIpNleAFRO8QAWCZlne/GeEk9vUV5cUMKMKeuy7SjdqlBuX4P9TKlqMN5mvQ8hpda1wvch3nw+DtjlJTS7OGGYYcyTqI997GP4u7/7OxxwwAF47LHH8JnPfAb/9m//hqlTp2LJkiV497vfja9+9atYt24d/uqv/gpvectbcPTRRw+12YOO5379Ml5atxVvfs8MTDxkgnedxryr5X+9C9Y1R4+fTxWang/UYb18XE9xyTfbBqEuOFBKOuZAB1j2atkXpAGxoLsYbQgvm7Z1iZHIgMeg+DdpkCDgACzLEUvc5ioRPcEEZ+qhYDcrEoar6Yp7vtSdrJX8Kmk8Cv3O7CcsEQObcFLi7emy/5ZCznaxLyeFUQPtDXx2fmdt01HSnrCFiKsruFt4uDmpLbfM9EQFjn2peZzYpNltLO8TNfpxzDHH4IADDgAAjBs3Dnv27MGmTZsAAO3t7Zg7dy5aWlrwhje8ATNmzMAzzzwzlObuE3Rt68aKL6zGI//+JFZdv8aUqe8PQt7QgCcqnvwYIU2xvoRd98rrTIQ6TpQZIvNiBAzn3o74bLr0ucSi3NYaG+yCIzDJb6EbaSokcUCdU9f9yMOoTiXJMxT3drDfpswvuLdKOUqnTFYEVhNKZGKDecBDoewSIHlLlZwoh0Xx/avYzbLtCnq7FcIZmPHUz1sMvROkOdY3kLpuQfBMP0tZxBMluQir3h+2mHfPB/p7W5+0T9Qoi/ENC09UZ2cnbrrpJqxbtw7r1q1DR0cH5s2bh4suusiUvf7667Fy5Ups374dRx11FM4//3zMnTs3uf0rrrgC9957L7q7uzF79mzMnDkTAPDBD34Qd9xxBy688EI88cQT2LhxI9785jcntzNcseX5HbW/21a/BKC+78cAauRJ41Bxl3Nxn6fIbCXWT0i5A4XPcmhG8TxIhwaDDoiUtBFVquefRmYUkliUc/NblP45RJDVsF8ElZrHgFNX/36SZ1LZTT4EYjvfOTuuKmS6ZhJhUdQFA/pwKYSz+LkSSoov6qIbVjo20XBe0a5iddI5KFuIDLRpyDGiT0yinmyvfbYq0umLzJCZlSrhFVgye3WZnig+CWIRiXrdaNOjDsOCRHV0dOC2227DrFmzMGfOHCxfvpzKLliwAI8//jg++clP4rWvfS3uvPNOLF68GH19fTjzzDOT2l+4cCF6enrw8MMPo62trdZRnHLKKfjc5z6Hf/mXfwEAfPrTn8Zhhx2W1MZwhtUh9PWU34boyxMgI7Edx+O6YrMZpo3YJAzAA3LWBe6K51AIGQLejqIIzxEpNWiXMy9aQmhGGlQcm9xzySrG4K6tlhO9aAIBpJsrus3F7nuFe76Y3mBYySh262iLHyrcdPYsNx1fs21RntEyJ+UNKivhGAH05OikocHZGpsMBDoHvjil8P1a6gQl5ohSwnk6KbeVsUnzWNziYFiQqGnTpuH2229HpVLB1q1bKYm6//77sXr1aixcuBBnnHEGAODEE09Ee3s7rr32Wpx++ukYN24cAOCSSy7BmjV2aOq8887DxRdfXCobP348TjnlFNx66614zWteg+OOOw6f/exncemll+K0007DSy+9hL/927/Fq1/9apx66qmm3k2bNmHz5s21z21tbQ3fi6FAyziDRPXaL4M30yBbH0RX55WuB2ZppH6SJ6oWzisV0krS3keKNweh0GBBpuQR4aRUSciVvEehAbFq3Cu494ERMrvtYi5a7VpsUCYjhvr9lLAL81BUnd85tj9XiHCW5FoUIYSMr4up3LxBbw6VIeUpUBcjSDmAzCNMnxn7RlS8H9GGtKXCwH+qrhDouxOerFX9C7Tvq0ZI40B/7isIRQlqTZM+OxiRcHTu3NKFp372Ao566+/i0CMPprYOdwwLEqXN0oFVq1Zh0qRJOO2000rlZ599Nq644go89thjOP744wEA11xzTZItfX19eP7553HooYdi0qRJtTDhEUccgbe//e34xS9+QUnUsmXLcOONNya1O5RQPFG1TdbYao3QoG+9SGx2an02G4x3JH6d/n+Kq7aC0Q3qgbGJVkgZn+ULRKSI0CjGPBTkBinH35SP3eByKR6KIocqjZvSuWSgvyEPIVSNv0L9T3FADHlEHLsMOxihTgkrlWXi5NXVRZtjKzpLhDPwXA18DBBvviqSTLqKZDJwr2heG5sU0Ve1Iv0+LIzvPgsCh3LeVVsv9/QyFgVOnAtl5qXQM0nIUq3ASwMxVOyVufPLD+Pl9R1YfcsTuOif3xtodHhjRCWWb9iwATNmzMD48WXuN2vWrNr1RrB582bcfffd2LVrF3p6evDTn/4UjzzyCH7/938fRx11FLq7u3H33XejWq2ivb0d9913Xy1fysK5556L6667rvb/BQsWNP4lhwDWaeOeJ6r28rgvycDLA1Pe/dtCLHzXaDiQNlzo5Nl5XHRwpbNbHs4rNc92Z1ZIW2l2WwjNBGe3TFfcDu+zFNYMKCupYiyjqIt52sp6Y2eqVTzDSsoKeuxynZwPsHPv6F1bvsHfmTW3t0nzgs83hVBdqRHzz0geXXWvTALxpreqTmrkCQ97HoRwnuktdWQ8XQHbufElwbiu4sSiwVV7wf4z4ub3932qknJbXWij5JfXdwAA+nrUF214Ylh4olR0dHTgiCOO8MqnTJkCANi2bVvDOr///e/jC1/4AiqVCl7zmtfg8ssvx7HHHgsAWLx4Mb7xjW/gH/7hH2peqdA+Ua2trWhtbW3YhqGG6YnqdXKi2D5RA/8GRuF4OM/WyQtQIm08T8tWEwwFsTAPsSesqygneAyoJ6DwdyA0IxFA4vkKMQYpcsaIj+t5EAgE9a4wsN/Q9Yhw4207SjJ1ffRRd0Jw1BNF86bs9nxlRdMF75F1340QmRA91MgRUGqPvjt0LzNHMZ3wCM9Mqb1CMSMiTjiPh/EVmX6xqmuTaxe58dRrR/SU9Rd+ZPO615xlAg2hsu+j5LNK7/QIwogiUYAe+lNw2GGH4atf/Sq9fvLJJ+Pkk08etPaGK6xly+7soL60VXupaP6Jed29GJCtiZCOK4TCaDfwnYMTRNa5SWE6V5llB5/l02NxioN5iEWVCKBNWIOvEiEGNIwqDMBqyE/KzalwD0XdqxA6OsUmD5aeAZm6nP07u7eKQvH/V9xni8tZ8ENihWusmkKqQ+NylYgxMsneHZeIGHVdOenREscOLYxPZOiEh/Snji4+WbNZqeJZDk1i40dqkWvu99kr6HmoIqv/RgNGVDhv6tSp6Ojo8Mq3b98OADjkkEP2t0mjAiZJIVsc0I0xAy9jw+E8r8xkUaGrZrslj8He3i2U1K55j0jjjm7FY6CGCCp1FkVRYa4ARmpIZ+l6j8r9K/t+hADC4WOW4S5CpC1CalTwsdWzvrHmyESC5gKJai2TnCY8ERZGLT3vNORsK6YnCYSId+mZMYt9os+itvRZjk8aeNiJe0s1j1zh+6Ee1gz9tvzg54IM3f1cYFGGTJVfapikFetEN06GTaKkEPMwxYgiUTNnzkRbWxt6enpK5evXrwfQv3FmRuOIk5j6SyO7d0vXLP2+nFWXXZcOICblpT4+NLsVPSIhOxvSpST2Ajycp8xui2qk41UCs3wyANPB3FXEQlR0D57iAFX/r+pN5N6OeAjOEXMMqxaNKlls2xTRA5QWP/h2xcmr32hcLLShqCXj6xkg3uX2qFVUxn7evb2Witep145NUux+zP1tlFW5g7tyN8QmfV1S19dU3+zc89o2C+74ULXLTcLE7RmJGFEkas6cOdi1axfuueeeUvmKFSvQ2tqK4447bogsG+EwSYrzmRxAHFwqW2NeVptVX46YlPrS+bMlNtgV1RaJCAvnwZRRd1Sm3nISzvPCG4pDRPFqJQ3AgvFFBJiINF4EBoMoEXYGc2ZWo7u7k/F3r9dOIGSKh7MSsEu6V0WhwONQlFM2HZU8Q2pSvMC0KnHPa+Bn9sNrMVT45IKfCGC3VySTtC+qCXqq+MSiQcIRCufFJqj+s763gB0aH+oDDf21shEc4hs2OVEPPPAAurq60NnZCaB/j6W7774bADB79mxMnDgRs2fPxkknnYSlS5eis7MTRx55JO666y48+OCDWLBgQW2PqIzGoGzNz8J5+84TVQXvrQWSZVyocajC6qGU8+fKoRlStxG5iIw//jJmwHQRwhoMb9RlpAN6FT7m5iiVWyyINUZqPE3FUKTdhKaKDIhROau9kpcpqkZN3xEHc/c+2DdCCfkNOMiq4I+773E0mwskVHuG2XqKDSqPTMDzWntm4Pw+AZJrFbufYitIXbsaDudRVxRtrnQ55MUNHdelRiTGQjhv2JCopUuXor29vfZ55cqVWLlyJQDg5ptvxvTp0wEAS5YswXXXXYcbbrihduzLokWLmjr2ZczDelfUTdYCSoKeqGLNwMtqNOnrTOlHpHAeCSuRGaIcViJfTtnAjxri2qXMboPEp+rLeBJMGTXRasJHnCOWyJ3aAdPBThiAi4Lqbt5UVXBvMVsfFRPJluQBVEKyA7pi91wJUYmrX5nntUz04+0FPV81Xa7bjhBONuFhTJhNUlwx0q+x95l3DWL/GiI5VrWByANT5xIk60gvU68hN0IwbEjULbfcIslNnjwZ8+fPx/z58/exRWMH5jvG9gdxZZmHqiAb80RFOFTwZe6/LLKoQqfLwFbgaC95gNRIh4wKeQ+FWbdvk20792oFb8SAVMAjVzarLmM3WPG8Wswwu9jjPfFJfsAjV5BhngDnBjOnAhsQaQhYij1xObYdBIVLMkrKJMOYIbw9xAd9ebsE/sAXrmr3od4cpdT0+ZNCwIwAypO1BAJoIObpr/fNVuVAMwOFbOGR9274WtxzWYv1RyJGVE5Uxj6CSXLIS+K+PES+eDHqSbIux16q4mV2gDF5ocvL412h+p9KWEnbBbmBHIpYexVpuEBRKuUctFKkRAi7aDkboRBcQYoNGKrHqUiWBZJBvYSuTCQU6eZEMW8pHX+DhIYP1PX69m+jQuJ2ARIvrXBzVPl1y39XAu2VHxq7mL9frq66DA3nlWwnnl5f0JQqPWfKhIeE8+jvHH0A+PXwiuuw+tgRXqzpkeyJyiQqw/YEkU7G6zgF12+zhCm2epANfNRDBdAYQXgg84XU3GywgZoQEWVi7v8YRV2kLgsfJhAtBd5vQHlp/J663gJKhIVQJLOJholDutiAwj5ISf/lRqnTTiCcodyw8mBOJgQOEYlwSX91HnuY6ftVlAmQu6KMNAERiL77BVlokO4TVb7vtWeUJWLD8drR+54+sWg0nGe247RHN9VkZ6tG7Rm5LCqTqAx7xtGIx4mUh8N5MWZF/o5cD5EaK4dC5D22HoRDYtLmfAJ58HhILRdItCuFGDQINTlbCq8pnqFgjKouVTKFkgzbXrflOndlg7TuTVSgJeuruuJhVG47J8LMJmVXdn0CYtlU1FNmbYxjBM+TLD4Pgi4I91P+bcjB4/zcP4E4FclMgLOE+EyAQ/nlxLbYAcf1MlvvSEAmURnE5Uq8HPakP6wjQoJSVmvQPj4YVip4KFiyAhlc+Wy6KEPuWQiMPITCG5Kyol22SaFVdyw0w4mIOqgII0ujniHyTPbbZZdLpM19FhTvJfl+dJf7EGtjYN+PQX1kJF38peDvrEIMTJP2NmlPGiRCRkJ+3m9YFGkwFElM2is3YHugbwi8h3UZ0h4lNYV7TiQohHCed//o/lFa0yN5dV4mURliOK+/gCWcu4mGRR2xfaDi9oXfRNIfGbPNmhSPiDFlpYGgIELP/yobppzULr+NioeshbGHgkzIa1Kty5QHDPs+8LyOsl5lJRJf6UdIoidXVCN4tRrcg4c+zRX1+9nlfi4QI6Zx8uq9MsqEgIUPHfnYLtxpRCRAXgmKPF9pr0XJXwyEIun7xUjbgD7DpkY90A2H89iz51QLRvPMbrdKrlVL/9TFA0QsIjdSkElUhj3joKd0k3JTL/hF4mkx27deupK72h5UmMeg5P0PvLs0aZwOYk57xY6yfMGWkVbn2Xrcz9q5a6pXKK5LSbQNHUBMzQr9PrHf0Auvkb8VDhUK2xbIubaXlEba1Nww+0J5kKZhVOK9LIESbyJXqVAyST2AoWeU3vqqp6e/lJBJxbXshSLj5I6/E3a5q1bbSsUup49PjGhV+TWNWNmTLsatyjqqRtiPtznckUlUhjQzoFscDLw8gZBcbB+o2Ozfvmx3lFJydoFEeUud1QHDlLE7Fk+Q5nYQEafzVvZHUsIbKodq/D6E5G3PEAtZ0iT8EkMKsShyqSglhPxKcuQd8O5nwKy6CBvwA6qE590PMcbjT5xoOah4IrZc7EqDISp10qA8o+V7VZzsaERf8VIXyaTXnxbFhHPx+DYItnnxcF4AVedf4yIN/7vl1qKhajWQPjDykElUBvEEEWEWzgsQsdAeUu7fZlnsegHhxPLaVBn0KAnm1SJtS+E8N0RgyfQ3SC4UIbACT8zuUJUdnEOQ+j2HGDT8FQV+JNteZTIiwWB5dATlgaw4UMchJ6mXGzT/dnWZ75YX+rTbLpJ4D0UyybxM1GvMJxZs0iB5aNmkgfUvoXvl2GXKuPJsBYtAANmELtY3KjJsX6d+8YFrgXHBe+eshomOKvz0j7xPVMaIRoAAuTLUExX0NoVZUNRTZdRnHXOwByx18ty0GpST0+PN+X6ARjtKF8wToIQZG53lJ+TmMC+GSP9oaNAbNBv0DPE9oOxGvHwu0lxZF3N3kAbpF+Rypd8gYfdz6wuoHsfILEUSM20q6SHlRNCPEtvPH3uOyzLcGBaKLDuGXMJptOErs20p2RVvr6x/oBn7Ovn2ESMCQlWz1J5A9xnhvJHLoTKJygjMFgwZeSfzQpn5ItEPA0V252UVUiLiVSl0unFHlDhDDDZYECTlBUierxKn4T0Pt73QyZeO3XB+15IucqEImjjvGm/romFUYlXRcUIHEtdrwtqT9ufiocHSWX1q1CXKyMqNNcpDQpKcZJAGVeJd08OtYu9OOc/HYcsxB6DLANl8Rxjt3K0zym2S9znoLrWNL33D0qIMMkkRFoqUGyCsxrlu962+KfVqgXpWe2RsyeG8jBEPugx9AGJiea1ugEWZrwebWdfat2WDZUB4pdXA56IrirnWwPtl1jHT/KpKIXzo6bJJDdjvU2YPdnsAP5esqCpIAAdkzGKvvRTPA9tOQCFa/WLsPlTragYpzKMlVHOPiGO4yaE4WQ7Zxbx2ZWXRHLlQcrZrPvOEDlxHAApZDt2HolhNrnzj6bsqegCVHDkaxidzhkA3I0+eTHPJI1YNXw7Wr/32oQiB+9vXwoOcLNYLq/5kPCeWZ4wkPHHPc/j2J+/CIz98EoBNYryEQPJeCRyKbH8QJnEsn8SqwjubwOyPhsQKMkKoRNsFGRoxEGfmNDWnwXyT8P5B9cFVys0h992PUMXvl3LfyyOULdJPXqPN0TCPR14Vt4/iESnKhX4b4b4r3qOK8vwpz4Kni7MouvVCsQ7dJqDwd8jjU+B/TIzuzxVoL5bz1YguusUBIfH8cW8wnFc7ScK+HnT8BK6xA4gb0VXts/pdWeOwQyZRYxD3/n+PYveOPXjolnUAIgSoXtL/X49cVYl84VrEnpBLmSogbu/gkrPipJtNEYWZKz0AlpAazyNCoHXeqi67vjQzL+pxlbFpvmCUex9CnDPWXDjfJGpKuT162x0PRdGbKJCa8uDqsCirTZdwknvKQ2JFssJhDbwVaM+DzCYF9lrmiKFJE/uhqbK4DPG0ue8XO5KKL5bzfkS7vAh6AHZRxhSh96QauV6fFPMJanBc8HKaBhS68oZ+M55H7BwByCQqA309vi+V7uNhcyjzjQtdC7nTvWYkktePcDivzqLoLsglZXF7yuOOc88MPW6bZc+X3UaDXMUzjI7liu0OqC7hrD4vrYgOGApp26vQq+xIsYT3BslksTlXrpRrR6rS+0kHYDe8Rj4peT6ud8UyJuCtcnXVROjEolyHvjuhla219rjn1duaINYenVjwH70sVmhP2Dy3UgmtArbt4jvmk+c4Yjh/jwMCVTR+rUbKiLxT5obvogfOD2NkEpUhnWVU50P2DMTeJ6r8r3WNXS/P7iLXWYdEJjvhyAXruCL2BC6UOlNPmd1e2L1dMWV4jhJjZIHiws1qxqvlkRU6ChfkbAv954SGNQfaKysLhl3MBgsiCkMSvKD9zREfk/v7xR8Z/iz7CWRRuXJzNuGs2ebYVG4qEAIm9z34iEbue3ATV/KM0v4nFL5mz4wSAvYIoG2XQl7pBMvSz/qREMmqRRB4x+29crUC3ifVy6r+pC2H8zJGKqp9VfT1WgTIfuvVXKlSnQBLkg40Zi5h1wi4IbEAi2IDQWmmXGrQtLMi6pKSc9SwkmR7PBRUajNkU4OhkhTvHs9dYQMUPeK2MRnXJpFo0XFMvVcVQ4YNwCEIOVh+0rj/t09wmS5ih2c7ef7YuxokK5Eb4ZHlAgEsee3iL2ElYHtZLj7BKqoyerC4LvI+l3TRl62qXLb7VrMhR5zMXFgaiKfD80QBm9Z3YPkVD+A3t60nRg9PjB9qAzKGFn19VTOcx9w41F0beuFC6mMvudVm4Do7HqGEQngjvOu31nFVKpW9syvHxAJpazR5lA3mIY8IO4+L34d+klEtN+GFSWiohNjOpXg4jwux9gIXmauGDK7Mdp9vuje1bERoAHbDXf1tBjNleH23zaJJA3+7ciVl5G8q4j/vrk2USAYUCymANG/KBaXL5FGgDbqXhGeU9g2lxD0yoQP4Ct8mwnmx1W6p4Tw+6bXrUE+UEdFYtuh+9PVW0f74FrzunUdi0tQDqf3DCdkTNcbR19OHPiMU1+fOFIhXKXS0S30lB++l6JWIezfkobDKWf5EUK80666TGj+kWd0r4ioqdIJsUAkMUHUnRqBjTkkaZ0I0rBQnbeVQiavL/g3lMKrlzSnIVVxdllBRTwCeQ0QhIipDqqlxyAolBoX7rh403ejvXDasoIuQ+FBeUYDEmzLOS8E8r8VcNPqMFptj5885ZIUmjSukxnmuyCPqhRBjtjecbBciSZHLwX57oJ7d1Ulhuf7NNv02ixGR3Tv2RPUMF2QSNcZhhfPM1RMD8MhVoY6n3PnXabekgFQNyVgojxWsN0Wd+JDOoF+XNphLM1w2YFCPCLGpqCtge3mmTFiNQGg8XQp5LdnkDFBCAjCYN9EhbdH75YbgCPGR9g9yBleTtoXCh6XbHg+bBTfuJMRb8Zq4gnTOoOhitns5UXYVyXmpkDvnXvGQbHxiUW90QCxATBUwFkW8xsHnwVAV8wxFj0AK3Qer3yb16PFfZFzw7HI9Z+r9HQbIJGqMo6+niqqbE1WFsTP5wL/2lIq5bdm1Yluxclu33w4Q6GyKlUvhNXM43KvLbsOf5duGDnx0003odxPIQ6j35vkmRG/Rixa6V0KP1vCg4oCfLRcgdwPFKnlg7aleNKarWhBR7gMh8fwZDemKk9e6cUY7RW+pSqqjNpUbpESkxZYJmF4C/3lsg9VnVCKA7NzJavk5ZquAq/Q+2G3TlbsMEZna5cDk11JBvVSNcKhqlZ/Buhd0gjQMkUnUGEdfb5/pieLuWqc4NKMJvMhs4lK0QQbpkJhXoX+mLHhz6K7E5el7raNkhoX6AzLbVDwB4mQ6KGia5oY+mwhvBBtTPAZERB8R42bpDLBojKEs4PnywjyRJW4B55FmXkmXQ4OZt4N4CV2CW0/zqZryoUmD6000ZUq2F6vaA7erjHsvizKEtAVCg9QTlUC8ua7iPSW2C96x+PEs/IEK9ulGu6WPgbSO2mdzs02n0sjhUJlEjXX0R+58D0ojuU+1Sm5R4FrBtUX0kb8Nne4M3iwnHaVPFuOdvDtAMTvrqrQeocyhyPcryoUIoNJe0TQaplM9IoXqbFAJyFnXqYwry4hdkSx7hrEmA6RGTfyPCbHmgr8fGzjj3y8YEqvpEe3yGJLR9kCbBsqq4hOeMmuzdQY9vYJN9J2HS1hsxsIPtq6Yz6ghaDZBXW3s/bImkLFwn32V1yUV6+kZRrnXLxqJ5Y5nagQ5ojKJGuuw8p+qff7ZRrX3yjvzqFq87Cov/kPaj5dHD0gWPCL+pHXAze58n5Kc2LlRQlZvj8+CC7YLx2CUBnM2M/ecR8X2yrZbXjT/XhWuKeTBNGrvfRAygFUvhtkmG3hCYkJoJkQma/c31B7jBbQ93iA9RJq9ZwG3luI5oTIhslxSQP4mq9Kq5LkyeoEBId6g9IwW4RJv808aXvO4pLGS0f0s5UIKG9DKKV+kDbfMvFS7FqRf4bIq/H0IPaGRw6IyiRrjqPb5DzR8XoXgkthQOROPyjegsNTZEBVezJ00Qztdm/gooZkBOdsuyyhXxmmPtFbgUJKutNmeTUylAdhld4ZW/3KcGShHsMhqiyKhAdj4Db3QJwNZ4Ra6nw2H89znnSX0FwmgEQ5yIUTgvAeLemrE2DRfnVewSUi8VnLfQiv9ypMZ0YsmgO1Hp4Tz6DMqhvOCE9QQI/I6n2r532KxQSBZbu0AsicqYwTB3rPDOzTYfkeCYb5gxC4yKgRDQu71Qjk/1b4kFBj0G5vlh8N5+mxtwKy6jE1WKkEWVZiZx8Jme7WZjfjTafuSO/hYumw1vE3HAxN7DlyEJrSSpyY4mDfGAKV7xbwmvjrbptAxRzVdoee9KKWNXLE5g+clJKSGngdXUgY+ohbuu7TSjx1sXX7BOIciBCkUzhvoQ0KcQdsfjhlVkLFyOMm9CL9LvONmuVZBsmbJOmXWNjsjBZlEjXFU++A/5OY+HrW/SLmlnAsRdYYAEWL5LRUig7JMbRwIfQHBzV7swHk4L3CUBGuOdJSh0bWmNuAQ8Zo2bHcJJx1aSSiSboMA7g0o2iNEBn2PgWUTKgHCYs/yVVjPjR+BYz9iv3WOGf5l8sxIzg73mYmYFfbAuOzOYFHkuTKv1URYuNKW9zwaRS8aa46SV0PPgDJhkYS0+rVoXIB1SN0MI1pFb1WRlPYNXCUTuVrfzK9ZNflvw697RaYnSmxnGCKTqDEOO8nPGCTYmxV6GUPT+tpLx17yQAftC9f/Vnqkohz7Pq4qNoiVBh86WlC7qsR2Nob1E6TwoF+p/cdS4OiKrRILDOaDiVjn7IGNcx55IF6toljJ42j/zmp+FROkzj36QyPwLBfkCHkNhagUj1yjpNrbsLJ4DfYHJfRe1OUPxgNmi5MU8iy477zAoRo4GSEiAzi/oW0XG6mpR6vWwZI2Q+G+QJ/Ow3Z2e9UqjDxag1OSjYpHAjKJGuuoWpOkKk384+E8W3fsWsgut23LHlcVSxKme0kF9NKE40a9CoE2yh24GJop6WKCrGMmM2DWeXuCtphy38PxvL0iAQl6hiALfYpeLSHWVV5pBXZP3d+GtK3cT1GX6kQL0BoCRkTiNvUL2jfLJWSSMsaiqC6iVoqPgn9J1h4xinpLjSbt9uw+i3vhjXsQ/am5QKjfZT8X2z+qrMMfdLyfNnJszXBCJlF7sWbNGrzrXe/CTTfd1NC1kY7+0J0/q5A8REDh6bfeFn4tto9JvJtnHYmmhDtgCMkoSrgzc6KreCyF5LKnBx47imNhl1A4z1FkzZRDK4dCM3hTyJWJkTv3XgU9kg2G4dh3FHvBqGfSs93+W11ZKH07IcwzoM9C/Rlt4LBmK5pnzyuiqmr1SzaR9hRFcL85IyK0Ag2d0fkAI4kF461tZGpS7LDwkk12XToXGCA7kXCeTZQCDIz116RKP2HyyzySlHOiRjb6+vrwla98BW9605saujYa0J9E7pT1wZ8pRGY2diw8QJRq+uIKY1sccC8TmwEX5AKdGx+gSqo4aoNroJcnM0k6HrqhGbO5kNek2B4aHuxKZilhVFcXGTnLtscHO2mPIRF6tDL8HUNXmdrgykKBxEuDufL8BQguI0g0XO82xx5m5dkLyBRfL+k+sC0V5NAR6WeCZNkv9z4r76qw8a+Zl0i/mvCdAwTLeyZYe1XjGTfSReLhveGL8UNtwHDAsmXLcPzxx2Pbtm0NXRstsPKf6EviFpNN1kplAYKlGSiWAeVpARlci+QhGEWg07/yQED3gilrK5TbuijBcDtmr9eteHWkTRgD1pYgRl0a1NowSvetMEDRAd9b6ccGfeIJIANdEty2FW8Oq85+ZwKHH2mhQfruFFbxBd4vapVChH1/aaGZqjEBCjFOoT1XRnntVfcDNcsmZEVjpFMbGNGKcKj6pJhPUBuZ/NY5lNsHWvrjWxyMHAo1TDxRnZ2duPbaa/HpT38a73vf+/DOd74T3/rWt6jsP/7jP+IDH/gAzjjjDFx00UW46667ktvu6OjA97//fcybN6+ha6MFZpJf7T+FstqLxR52kykFGi7rteySIXXMRYTiXcWZndB2aamfbZc/UyYmshVuYjivNKYoqNSFORHRnEx8Zk5Iogv2HLD2av8J2aSH1+rltlAw4bgQiqSkjbVXQqG9QLK0SyZtVYJMEBqppgKCZ0hK6Pd0GWpDvw3I88fewQr4BKQkx7x25R+6YpU7jUpbqSi5ntaWEZRFBdoLhB2ixM7oA02+FNtsM8GjPFQYFiSqo6MDt912G/bs2YM5c+YEZRcsWIAVK1Zg3rx5uOqqq/DGN74Rixcvxh133JHU9je/+U18+MMfxsEHH9zQtdGC/vi0/4Ibr4+tYGDH8gCHMsNxEbXlUFz4ZWbhDb4pnT+7teXE8AZFkUX5xe7fDedgwb191b0igdm0O8u3CGCI+DBiQD2Aru2R+x4Izbi6mnEPlcM8gidKGMy9rSwYKsVcNPb9av+JqSL2EiGnoWLenhTOE7yl/foIqaYeGFuv+zNbX1G8VeXvR1hUUE2V2B4iy7Uf2tVVlFM8ZLYdRZg2NUFGwn26U07GgapZSPYmjLQ9XDEswnnTpk3D7bffjkqlgq1bt2L58uWm3P3334/Vq1dj4cKFOOOMMwAAJ554Itrb23Httdfi9NNPx7hx4wAAl1xyCdasWWPqOe+883DxxRdj7dq1eOKJJ/CZz3zGkwldY9i0aRM2b95c+9zW1ibXHSrYhw370wf2TgbJEIuTF8poWI8NxGZZcTYW75D8FTiwe0/FAwPYAyIKg6tTh+eSxL1oQVJD5VgnL408YDeCEs6QfzLihakEyBH1WkrhSn5Jp2JkEBYa9O+D36o3GaBepqKc/cx49yqWwxPKm3LUmLxAmAx4bYs3nqa80wciLkL1qOG8OP8ryfn9ZtwwLzQdkbGIK2sltLAn4IiKdPgh+bJ+f8yx7RsJGBYkSt3sbtWqVZg0aRJOO+20UvnZZ5+NK664Ao899hiOP/54AMA111wT1ffrX/8aTz/9NN7//vcDAHbt2oWWlhY899xzeN3rXkev/d3f/Z2pb9myZbjxxhul7zJUsJL8zHg0e8gJiwpxKGIIr+iUx14nyXvksihn7KkUPxi6WEiizKJcwwrN0cGuOLs1m+M9s4uSnCBTsIse8xF0+KhT+IIuZguR494V24vm7VckhOrUJPxoNxW6Lgz4IdDngXlXHLOUR0YJM9Y1uka5DTJdhh6nieCChaox4/H4H5s0wCx3Xxs6AQm0WbavKEdZlGkYC+NLiezW6t5Y/xpyN5n1bPJVT2T3LtiyEU+U+l4MBwwLEqViw4YNmDFjBsaPL5s9a9as2vUBEqXgnHPOKRGyr33ta5g2bRo++tGP4oADDqDXGM4991yceuqptc9tbW1YsmSJbM/+gPVAW7OCmLvVKw8wpmbDedby14bPS/Mmm+7I6ZMJnvcqyKDwHSzPl2U6TeDhsGbK5rjj2jRgkklEtPaKoONOSBf7oNwrr1ECNZk40p6HANmqFQteQmP6YsqVSDzs54/+hgJ5DTmiWFgzOElh9cmgT5+rwLtTDqMSQuYp3FsYfI4JYSnKCRtkhtIlyxMsu36V3KuiED1fL0SSLHtK1waIUgP9NudQnqyZh8tI2QjAiCJRHR0dOOKII7zyKVOmAEDDK+gmT56MyZMn1z4feOCBmDx5MqZOnVq7zq5ZaG1tRWtra0M27He4u8eahMmox7hS1fnXUhTSx17nPk/UbtcxSlqVppIa4VwygO8TVedQze3gHPSu2A1KCdUUzr2ig3lRjoZRi18wriucfF7WFYVKDGi0iIyIjrLiXktiUhTxohVFNHeO0lz4nhI58u64t8GS6ZeLuxPppMHTRS8VhIgtzoTH5FCB9iTiXSI1jiLSNxQ4lFkeao+TUv+XofcrEM4L9+lBdUZ51evj7TxccoNGAEYUiQLch3dwcdlllyVdG+7Y09WDl9ZtxfQ3vsq/WK2a0yQ6ESAzhoY5VMTdbHYmlfrfdJwms1u+27U4uNLBLhAS8wZFH0ooMjDJJ3aJ7wizKcA42WNRvp/2oFIJLvWrE0Bmi0syauMTI3YINMdm8KoHUJEjz0w5iZuTFaKKP1f0QXafLePhcglgo4NYwPaSmECE5aYL/YLwM9e/oxtOEsl5WuidKqspUkLO0qTIsinWjwfCeaF+m21RECRlhc9xT5ShZ5hiRJGoqVOnoqOjwyvfvn07AOCQQw7Z3yaNCNx59cN4/tHNeN2cI3Hqn7y5dK1ahXm2ke+CHSBL7qzC/cNA4MWKzZSKqFQqUfKlrfhxBwy7Q6WDq9uZRmabPvGh01uz3OuX2YBYGA85QSoqqouFluNz3mPfK6WT5+ChGV/UUEgGupAuzfMQ+I41oUBzLrmzTZHs4hyKUtyAt822h972knel+Iw6RCTuiAo8M6HfsEiYq74exxav6drzbjftEn0ektVsZ3tc1cTcd5VN1uiu5oF75eoo1fNN93Q20KfXPloTSWMsiUY/RhCLGhZbHKiYOXMm2tra0NPTUypfv349AOCYY44ZCrOGPZ5/tH/F4LpVzxuEyTrixXDBen/EESJYsZlSjSuxDpV5Hxg3QllGSV6m4bWyVL1j9t10dbvjnC0wuw13lDFQglRUqBIfZnsxR4QZ4pIMNmAIHsCSqlCD0jNDBjFDnQX2G5ZNtI0PjhWNhpWU++nqYjJFceLVCtnOkrO1591RxDy0rMEAWTa/pnOvpDwzdiBwqUHw37AgQuvTe8UmPA24osIsioNdI7yrP9DhEqaqrydGqoYxRhSJmjNnDnbt2oV77rmnVL5ixQq0trbiuOOOGyLLRg7Mh9wa+31eVf534GNgn6iai9e2xDaIiAGBgbqgo6WF9MxsAHausfBa0ENRZ1EE2rlkUg6WMxLwWX7hAyFkZHGUoYzoEuAPwEywfr3cHPuCcZM8T4DRXtgmTl6tKYbq+eoX9mVCZxZG9bjNqbaz+xDwTJrw3hvBfo0Jq2lmdU3seScIEU5+T8Pe4H5Vzr5olq4QaSuaJZFlyxXlF5UqBkiUGemrXfMvVsnAYczRqV5eMHwxbMJ5DzzwALq6utDZ2Qmgf2Xb3XffDQCYPXs2Jk6ciNmzZ+Okk07C0qVL0dnZiSOPPBJ33XUXHnzwQSxYsKC2R1RGANYTbWy2yWYK/EDLwEMfehlZlVr4sABphqi5C5ROsDQDpr0bzAGx1KQ3I7WNl8dN+hUHBnOuyL3fdmoO/y2l89KoSJCJGEa5jZcHsWhytmhX2STOSumYX/s74OJ0SYblvQwO5ozp2+aWwRcjlFaQqrl0pp7ANUJq2NQi+DNZt4F5mDwUBInrK7RTfEkT7Yuc36Yo11et9U81071ZA+kbWL9WtMnIB42H8wwy5P1hXCXkyyRM1vDieZ7cz/1lvXv6MH7C8B7Xhw2JWrp0Kdrb22ufV65ciZUrVwIAbr75ZkyfPh0AsGTJElx33XW44YYbsH37dhx11FFYtGgR5s6dOyR2jzT0GflP5ozDc8HWLjj1+UsVmrUE3clmw6HZn01EQuE82hxsXSGSYUXE3Ob4Ds6GIpS/X3BSZn1Jd3ZL7SKCzoAv55mFbNprV/HmW7vSe22Fvnts5q06RJR8Lrc94/eh4SJDl+W99Jsj3ocGZXxbfEGXPJRfL+edsCYNzn2nntAi2BYH5flOYFJQrcmoodZ+Xc4b7D0zhNyRCRaFy6lJm4q3tOxpY32fddOjLMq4Vt17iffbhEP540MV8Dowg1h5x8D0VbH8igfxSts2nPmZP8ARbz7MaHF4YNiQqFtuuUWSmzx5MubPn4/58+fvY4tGKbwzi8gW/N7LEHh7aHlw9B9QbF81XnJ2lh0dVMio4k66aQdOw4duewMDotWDIDCy+p28LeTKNOYxCB8t4l8IEs7Q4GrU9wcxW1epPTqYG/LOhfB+RT5pK4kafb0nw675zTkcw3kAIz9hMCLWIHkNLTSgNgWIvrkateRh4tDC5e7LWrxkfUdPyNYreLJTFiOEwnnMLu6ltptWwnnWo0A9UYH+PJROFbpmNda/xYFX6pW5Jc/+ehNeWrsFAPDjK3+Bi79zltHg8MCIyonKaB7mqgj/iY66gUv1Yc9alJeR0iwjn0o+hd1t3/3gDeaBwSfSXrETpBxKzGOis2mnwZjHwBs0CfERoht+lIcNKtKeWuAjLB83qZDlEPG8GI3m5tDnSqSuyr0CkRFD4tFDZ90PAY7BHRVkNFfgJYML7xcxKfT7FT2ALPnc65cam3/wZ0vKX+R2DVTy+wZCTJXmLCE68Rj4R3vm/Ip2f29u82L1i66cM7nfvb2b2zXMkEnUGIP37FvLTc2KREGIDYVmQ7GX3NWPEEGq/6msqKsEXAFsB2Dm7RAjRg2HxELhjeig77TF+3jGRIpCWlI8R6OdNJzvZwtJucuhWT4ZW8vjXIDZmaQmNCAWGyscQGxb7t33xs/qK8vHHr+Qo8pr2ZCtOtelcJ7GouITEJHgKocie2aRe5rkeSVNKm8YI22l72GM5vykCV+XezE0MbbHiGpQX/2zr8Bty007Gc7IJGqMwU7g84T8rRAGXizGoYLPvPEyOvWZneU8BFtnOVSidczMmwPSKfFZPnPnFOS8AbhgO8tpYDfGcQ3R89KEzrvkRQsxjFL1qinGwhuhPBI7J4obXzYr7pX07bKVSeEup0kzryjg+fJvqe++9GQ09wO5UBRxXVGWYYH9uejvTHQ6KIsRIhJ43pnXWNm4038efLrsPaOCl1pKdgrYUvaihWXc5liM28wZpeZU6eWq94dx0bhm/YRWOM/fQMfoOjOJyhi2MLbbVx7YaGw9cM32RIWmQnYd9bwqyzaPjDWRtFs2qi7nE8wBYqD5cljOV4gYSFGXwM8bTXAO3KtwMonVlnAvXKIVGqhNj0joWWYDNfM4FpsqH95jalJddkXyGjJJ8WIoni/HOJMIBz2c5QbrbZLBHIHHoaSKEU7hhw5cp89MzIOLMBGmtgcmDfGd4kViWok8e55NYdmwJyrSEEi/X+Xl3md3zDH2LxwpyCRqjMH0JHmzgIAzgnlblJfHrKdflzpmmqtQ7OTdvCJ78FGcWjJIRxny1NTbc1kUMaY0u1U6edjjkzvBV7ikeHYea8drMwI62LkDnUhgTVITulcBUm3KuCTDqqs5MRxO07jn1YL/9WxjKoX/Bol3yRY2S7FFyqoChheedzn0HiGvpAlfF/NSF+C+OyW91ZKU2SJrj3qrLJtiX5TkNjnNSLAXJBlN+GLGqvFMojKGKayVeH5OlPHk1+LkrsLSZesSeVGrtB6zV+ooGwxjedeIdyW867ehp6jKG8T4DN4yQ5m9lwS9fBq7bWaSS3zoLSWEk/6mXqiE2EgJJ39YzGtuFIsNPr6orzPgGap5HI02TVDeU35I6e/DdJXuJ/mdg7ri3tmiWJD4UF3kXQ0QreizJbwStQYNL5rXx0geK2HSAMf2Pv87hpLiWXumR8trTCNPthTv1Bs687Smw+iB3L7SSSzv680kKmOYwCNI3n4cBuu3CFHVvhbeZFMhSuQ1tioJ+8ow4hOKPNEDcyX2UO/grONz6npIR1lsj3pzikJuC/531GbAKIVmeHNegzbIiO9+V0ruCoOKlhtmD3begE/MDd1TBebzFwhF0ghVyAsqGC/vPxabNMhEhMgGn1EmRzyvoftgkGrPW8ruO3sxAt+v1IcQ04NpA8LDpTyjPPRp2xSa3JbKreuRuuyaGdUwymBN3LMnKmPYwmP8zsNatbflJ3ygoWheMDwRe1GN67QjAZGhvXdoJhmXCZIM0qS0WqkkQjrvgF31wZzb4dsUdStwF1mJS4qDRcxVKC4TcwfXqiUDcNtLhhVIBpFxc6JAfx/hhy7kykj5O65g8TuWenDykAZQ41AO0aIeQIWcQ3jeGyKu1HVXa2wQ1gUU5CLt7W0z3mBgp/gBAhhIZFfCedRbZckG7CiXheQDiq3YnVVkVc0kKmO4wuNCRmK5R7TgTx/qL5vOooIvcmgmVGyPhvOshkBzFbzcI+qNtzsuJVeGdxa8w2U5DVyI227Z1F890CFZtrsDIozOGeVOHkLORpAYFEXEAdbOiXLvle2p8bcA2EtqSrocwyLEIOQ9EniIr4/d92pZymwvIBLOd1JssjyvzheUiLctEhr52eTClTJRfBzIDQ17AMu6rOZCv7PtvQR9RrmHXbCppsIWlqID1N3EL3njjTGWFJuo1y0X5C0OMoYPIg9n/+QhPnsoXivXD01buEx03xs2SFntNkq0nMkfD1ERz4MXzgsr8hK9SdvyakBSv5wHE/H41NX5EiHyQFQpm5x63iNGtogtSui4BPdeleRLYlGVbo56iHSGTKo1qAx4mlPLlnE5jfhs1WUaJSJFEddr54v5XkLStOvNoY9A/PmT4Mf6TV38WQiRSdIkMYWnINh9UWObbVbp9WiUgMHiS1V4KSQwoh/ZE5UxbOE9rE7CHiNRPlka+NeQNdrhhW49MlMyVLBDOMmELdw+6wUVYlBUU3JFsbbKH8t5Fmxqbpu31zD7YrVgkxJ28dik37iaE0UT58tScVJTCehyBxXjfsldr0sUrXJZ18CND4SVGib6GgNsejAvshrFIzIgG0LokSncKyUkFiJbYKqChMzyojltxrsGJ7UgMHkqeRPjLIpHnOO/TTnkp70QqWkYduTBz3XiJM0fh0qfM4nKGDZwnk4rnCc89zU9fsiKT3kC75swUzKuK54Act5daAUOHXuEPAR/0LfaDMymGWkLhVyYU6E0zVfaKxlry3veIzqqmKpU1L6vO/BQPkYIi8tJ6YBoPw9qWKl4jd32EOzz54oCTmtF4k2edzqYh/ySe5VVKiGZsl0x72U4Gbyup1RfjImZckp+EpznITRJcVq0/mR71rmhVk7uBu576D0sPKPCSG3lRMXDefzLh/pt85rrcQIhVkZ9P1eXmjXskEnUKIf7MJr7cZjEijzU5OEOEyV71hJQVydt7mBnNMgOwpWJDxk42WzTC3dZ5YUqoQhBaOA0FQccFLXxKRQ2c+qwjULr17n/KLiM3mg7mCtTEwkMPKSN0jUaarXbq4kaA7HvtYuQO4+8kmdGQP+tYuy8aBYZzAO6Gx+fir9zsT32goET78Jl6nB07ntsQUmIQrF31VSEgXeHESRO7swKkgfQuxOmKuYeozZF+ms2KS7pDPTbpkpU/faqhg1Wm8IK8eGKTKJGOwTG73uX/HoNeYxqegJvQoBgldSVZn9cXU2mYnfyHnlgg4HboZpmOuRBCG+wwZwSETYxl3I2+EqycljJNlce8MnMnLn2+nmIGDKKtOdfswkZ/XE4ezdLnbE1QNAVL1rdrCDxURwsAjHwjLcMCxFvpovJIEAA3TYte4mIJ1dkUeS9p2HUkpryF5Ruu7RSmLdT+rqDFs4z7gHRZ/WvtnHkGqlnjSXeUGIMOjzCMfyRSdQoh7fqwcuJYu5WR27AcxR5+G0btDK7cv3PRjsS1qAUbgDKoZLATHlAmbWRKQauCnkw5aX21pcYkCs14v8Z4A5UFyGJfntESuIqAaOqcRH/NzS8R25B1G0XU9AAAl7CEvF2SXVNhDD4gF2ceFfLQgJhVvbnovnp7Dl2r9VCcJyI+I2SNgvXteTzAv8LTZxUj1WtnL8Usfy3UDiPphbYJtne1LI5xgV+s8LhPGvMMPRZs3RD90jKgXKRSdQYg+U29TfgNKYPfXV5TwHIzCE4a6kW/6F16eHCoZmyIVOCmxNFRgNlwCh1gt6Uy1DkiLmdXJRDVRwvmi1Sbi9A2qzcHD+MRXQ5YnWZ+ADsonSrmFchoMwMN7s8xBjrBkTipIYMUkViF2BRfNLA7jvofacrsghc34r1vKt8RpEN5YzXf2f3neD3gRHFukgDZMzwooWeGU5qhAmd+xuWFZtC5Z+G/M6h9tzyiI5gOM+42cFV1VUjv9bU75f5k3vezHBDJlGjHC5p6ustMybLtQpYfIA81QGiVPcoB2YiTK3hji7vAWX3JDRHxGmHbpwozcw9ZSZcLsKqm2pC+TSKLskzROCSRElObJDe0jqtUXKiiCPKH4CZx6AmwwkGzUmB/XwGvVqeS8AYzG0JS0Edpb3MuLL4bxggy0yvONBJYVvSHvU4OjY1Gpoum+S+z4QgCV/YXW1LnVrVmojWN7BJCiFJtceTzkGN59exIeyJIpcErxNgkS2BfQ1TZBI1xuBtcWAcNlytwmJRe681MmMIvKg1ifDLUh7H4p6ocmdqj8ChcB4lBoHBNTZA+e0RZlATdvU4HWVssAu5otwBqmHEbzz3fAmek9Dl0KNS9YXcnCg2yy+3azdScW2zxCruQEZ0FcgdfX8YS4R72xsnr1ajvveIkHhifDiHxdBVcf6l1Yk7MUBeWcJ7yENWlxFzouhB5wFYZgX6IppaQFSC7V4/0FRRRx+TMl8l/yJhUV5xtWqPJe44klfnZQxXuA+jtxOsxZgM71TwxYLdiYa8TTFPlOXhUhJ76dJjp9cV0j/Ks3zLNscmOpuqBBaZu0QkNrgi7kWrKKPFXk2x9lxdjP/xsTzEoO2BmnsVnFm+QMioV8sdzGNDpztQ+yobg9Vc4EcXo5q2fOBeNTpYFcd8/k7wZ6Ykg+hd90iGed9dwsmICIutBQhnMFRXk2GTtYorWBCzJzzcw67YZNzz4qSptP1L1btu6Wzgkj0GwP1O5JmziNYIQSZRoxzRgx4hvkd769mviXmhIBFgUZSUuX84nYTQ2Vhm2jL2jFp21Fh5FoWPjUR5omNryItGECRkhgcmGCoRBhXGtLT8nTJCISpTLjAgau3ZfwPkO5aeF96Y/z2sEFWxrdDeYvY9YaGn0HcsC4WJT03OYFHKc2xImqXUSVgUDNz34ITHSmD0CKdpYuMeQEIAix8qgeRzJbWAbu9i6jDsNH+Oqqc7pLdUzSJDge5/AN7WOyOIRWUSNdrhPqxOOM96yE3nFNEX5EIRotR/iV00SJt0PhuZsnmdW3zAKLvsi7PIkMVGQYj4FDs5FORSQhKF9qiI16kaBNC9VwoUz5c7qFgjZ8CrUFalhLrci6S9oiwZzVluTnDQpPe0+Ow1N1iwZ7QspJA7bUPYvaKCYaVGAroMV6h33w1dIeITmjRETPLnV+RGkHM1vTMZS7qMv9W+QZmAxJ6F0iTUb86rGrpIiJGZ7uGNGVXPvpG8T9T4oTYgY/DRu6cXj97+NCYcNB7H/LdppWt+7NmeUvDt+0l5YLbR8ItKrpunlLsyaucWC/N4QpZxDqkJvfjE/a9s4EdDEt61AZsqUsdcHHxC45xjTaFtexZMyQOC4/ne65pXwci8thssXfGvycvsBeagRlGlZyboLS3qipNJW59vE4O0GjDgtrP4Ue1y9PmzQ+HeayrfeEOBx7wVgh6frDnOPXMi5r+q5IFQDkM3EPdEWR03V13v0+1xw6rgyVZ9yUyiMoYV1vzH01h9yxMAgPEHjitds07HVpLFB2ToxDk0ozYvBd5Uope6vQviips9OHA2SgyULOFKONRTFxtw7XP/nByKZIOrx2osIdcTIIR52J5aRS+aYY2lVyK4ribrWiUQKvFEYyzDbi/4+AbjqIK4ct+FZ9T9as16yNyNat175xIDp/UBJbV/vJZCtlO9RSEySSm0G9pSQbun7P0q6ioTwPKEoEajqOc1eriwY5+ZD1rUoXgtUbg3DfbpdJGScRyMx6vcbXaa9NDuT+Rw3ijEb5ZvqP395H0vlK5JjL9qlFedfwc+DpArS01gthMdhAy95gGbzt/Kfipuoi1dRUWJgSNn1A3uHxSwKyoDaIMrsaXREAHc3JyS4oIYbbysCxBsl7JoXbJFSL56T2tqyOAKtz0iRL0YVVMqtFy98Vw0sA/cc1IwSE1St+6p5MF1G2QQ2nO/g3IbKsJkxnNq0b6BiCi2F+u4pA22fLlbsxuMe3n9WiQQYRjjVDBvS9VQ6E8I+8N5RpllwwhAJlGjEMXBv6/H2RdKOPalv9yXA6xXYkDAKuMEK/wWFwlYobDhcF7VEjHc7Ea7CHRczFtFbPImm6S9YocadGIoHbOCwo2QZ370XhV/G/u+hwZqFGynIiUORcIu3qAZ0eWElViYp+I8NPUd/AvylcCqT/e5ksOIPugGtEUZkdSUdtUvN2LCjXZVvT8GBG1bKOcUvXa1fsj9fpRFEZDf2e8cimK0czB1uaoId+V5U0U5+fSEcjl9DoJEKXrJHAfsccS4UPXrWwueRgoyiRrl8FY9eE+nz6Kqff5maOzNqr+sgcc+QNJiY7cU5ilW0JbWcPMIMeBvdcUcgF3y4BhDNBXDTwUiErDd0usNdGymXFQXGuh49YKiuFDoNtRPtQ/8NkFlcTSaE1WWDnjkarq4XfQZDRFqVl8h+qQ5apgY4u43LeLNIV7CYnsD12s75pdMarw9nk9YteWEyYBrV9mmokxg0hBLdPS8VfZ7ryTO297Ggg7jbD2TDIXaiZAvwxFlcSh/HDG33qljT1cPdm7eZTQ69MgkahSi9LL0RBi/RXAspezlCcXWQwRLJk/FjsTvBFwbVI8P6+TdHYctez1OY/WTXjgv5oIJwGmP34dCi3Qw5zNl3l7xms3IpDCqCtGrEI1QucYzJqKY5N4npXpjP63XnhJW4h4RV65BVTzWWv5IB+N0TxudyBQvhog+CV8XPYWhn0YiLPTA7YKMdw+KBGmgrVDelG0U9Yobo3l0/mWSoWr5X+uSUS18wZGJkCi36Vv++h7821/djecf3SQ0sH+RSdQoRPFd8Y55sc7Os4iRF84b6CwJQi9jCEzGeFvZIZxFSIeo9guSdovtsY6rrMxNtLVkSk2wwU7xtBn6XL3+uBMYVGoihEgGk2Vsm1gn7yacKHtABcmycb9YIrFrLvPI0QHY0cVn5MIzU2hPMsoFGxhDppOYUZUJqZMG8z5UwEgb8zhSAij8zi4RYWrrCh2jiIirgHoKje9Xk1EmBMJv2OheUlY6hKnDsClMlPjFatVfiWceK2bJucnnTp1dHd2oVoH/+PwvTauGEplEjUYUflXvYEdvdV7VfyHs5975o/wx6GwiL5xbzxozqKuddSTsifbyHpic0J432Pn13Ukk9UM5378S6eMljwh1MRkDgXnTtfYaDbVWQh6yak2ID4gKm/QILrHLJZyR++CH1waeX2cwF37oUk5UKXxTrMBJRsmbqHgoAs8D3PvgN+ffU+u1IM8xa8/NRauy7+fYJjnIQu+O1Z7wO7uCfOPfsq5ojpxDtOgiEHZ6QrG5iOfSSoYPnygQKGMdvjKWGLq9HFxu1bDDmN/i4K/+6q/w2GOPYdy4/q0A3vjGN+L//b//BwDYunUrPve5z+FXv/oVWltb8dd//dc4+eSTh9JcCcUXPEaiqlX/RTIfYEaWgkyJ1GGNtFSAXpdc2SM19+bYMsG8B0aQYh3ggC7TTR4iWsz4ohzr5Z1mSLky8DCCwYVcMcN2+nz4uqyROpTfUm7L+Q0HSI0nxxRU7esBsqzlyDFdJUW2WQHySkmN0LZ3r6rGhxABLMF2q9IwuNego812yRUFXGVRs6TXi9jXT4TjN6JCNv4t3wZue9EjpxwJJYXLS57zcjt7lfgVzb7ZnyC4JtEuPUKOBgS9biLvEzWycemll+I973mPV3711Vfj1a9+NZYtW4bVq1dj0aJF+O53v4upU6cOgZU6iu+KvzrPESazB/UhNlcpFfWU//Auue94vYqvt0IO2GQz89B3oHkPgbHAlDcGuwrc2W15SspnwYRBODI0n6vszmkIoUG6qdyckkygzcaEfCeaIRcMa5L2OCkV7qkYvlEiPP1tFgWtL+h8TnneiaoQmdTYlj+gy3ArGO15OY4CERFZIrWFhs4CdtGJHxw5q72iSPSdJ78x+frBCELwBwuTL3NjzeDYYKvzIybDFzmcR9DZ2YlVq1bh4x//OCZOnIh3vOMdOPbYY3HfffcNtWkCGvBE1f5TLPR3LK+yty7wrFeDL1y9rZrVVsdEOi5KfEpu72JnU5B3whtm7oo3IBLSBqcDt9zoofE30sk5Ir6goSs4eXfCmpYjQE0SZs62cnNlISm/XvQqKB5AlrTr2W7qMsqcayGHY1BXxAET1CboUoegkpzwAHoeMmOw9uRKRKRq6uFeO9YeIQ+OBvraszBqiAiz+8BmIJXQfbDbo8+74WVyYfWP1cj1IAIEi+YzWsODwtScccnaFHq4Ylh4ojo7O3HTTTdh3bp1WLduHTo6OjBv3jxcdNFFpuz111+PlStXYvv27TjqqKNw/vnnY+7cucntf+UrX8FXvvIVzJo1C5/61Kfwute9Ds899xwmTZqEww8/vCY3c+ZMbNiwIbmd/YWSJ8pNLFeS/AyddOZidGruNXsmYpANtuJl4LoaXrN0hHJXCIeSw4eRGWBdoaHLFTOZiHE9pCtAEqmHjA6agdm7a1el0q+HfEHPW2AMZBXPq1CUKQ9QzJaSUZEBMUw4i7qIqsBgXg3ZbjkcRa9J6Rnd+2/VMTdMMmxlCi/wiIEhIx07tFeJmQPo3qqo667cHn9X689zlXxB33R78gR2rmbgES2jTiaZL1TZ4qDsqTfe+aKOFkNJw/22UVawxbvMuJY/DJU/ZxLVGDo6OnDbbbdh1qxZmDNnDpYvX05lFyxYgMcffxyf/OQn8drXvhZ33nknFi9ejL6+Ppx55pkNt/1nf/ZnOProozFu3Dj88Ic/xN/8zd/g29/+Nnbt2oWDDjqoJHvQQQdh69atDbexv1HebNMhSGI4zydL9kM92OE8V6A0sFidQMEGpsME7eTroyt1mgQGlfr3CpE21lEqIQlhlg/tPhTHcnXQDLr6IwOinyUcMSrQnr+fD3kOS7oaY6/+dhAxw8jDYIkVSW5179EpzrvAJw0OA4yQV9cu8z4EPDDBo3uqpX9MIbqPUkmWMQPfVE+EETtEiLehK/gbkskFf3fK+VVsOxIl5Kds7xKdzBnPk+0ksiq7QqTMYFHhNuzPsit1GGBYkKhp06bh9ttvR6VSwdatWymJuv/++7F69WosXLgQZ5xxBgDgxBNPRHt7O6699lqcfvrptQTxSy65BGvWrDH1nHfeebj44osBAMcdd1yt/CMf+Qh+/OMfY82aNXj1q1+NnTt3lurt3LkTkyZNot9j06ZN2Lx5c+3zk08+CQBoa2uL3YJBxcbOF7CzuwsAML7Sgp7uOnN6pn0CNne31z+/dCBe2rYZW7p31Mo2PPMUXnhlEzZ3F/bk2LYTa9euxaZdL6K7u6dW3LdtB9auXYsXXnkWm7s3lux4+oWDUF27E+0dz2Fzd0fp2vObgLVrx2PTM9tq9hRtffqFg9G3dgd2vLyrdv3Ard3Y3P0KAKBl6y6sXTsVAPDsS8/WZNraD6rLb+nG2rWTAQCb2urtPLepBT27e7G5+yUAwJNPr8Om3QcDAF7a8Ty2du9EpaWCDc8+Vavz7MbxmLK2uvfventPP7se7duew+bu7QCAJ9auRcv4FvR099ZkWrbtAto763WePwQ9a/vl++tu66/75BPYvLsd3d096NoxEWvXru236dktdds3TkDn1t112zesw9Rd/WR/8+529PVW0bNzO55cf0itzsRX9tTuw3Mbn6mVb3j2Kby04/nabz/Q3tbnd9RkXtgE9DxXv3fPtk/ApLU9Bdv7f9d1T67DK7vb0ddXRc+O7TVdz7zYXv9tXpiCHZu7ap/XP7seOyf2/56bdr+I3u4+7NkxGeufPrje/uY+rF07of/vV57F5u6X+7/3+if3Pldb+ttftw4HHnwAtr1Uv88vvNKH7hc6ap+feXEyxq3tfy827nwBO7p3YcK48Xuf6xfQ1b0HnTsn1Gxve+Gluu0vHoRtm+u6n3r6KbzSczB6unrqz++2Ljy5fmLt84St3Vi7tv+3eX7zM7XfbP3T/ff9ldoz8wRQAV5+Zmvhdx6PnRMONu978Rldu3YtNne3o9pXRc/2+n1/9qXn6rY/vx5bXq7/phvansKOA/r7qYGy6vadeKrtwMI7UsXatf3Dw4tbnq29d0+ufxIvbX++9ruvfWItxk8Y5z0zO8ZPLrR/MKpr+/vSlztfQGf3bhzYdUD/fe9qR093L3bvmFS/74Vn5pkXDsamLdtqfcuT69fh4G2TsMe5709tGG8+M+59H+gbJ+waX2tv0zP1Z+T5TeOwpa/+Gz79wkHA2s7++769/pute2pdTeaALbuxdm1///FM+4uF5/0QbNyytWb7U+ufxMHb+8ePTV0voqe7D3s6J6HthZbCMzoJB6zdvdeWuu1PP7e+/n237sbatVP6v+uWZ2v99PObxnn3/KVn689Ud+ckbO/etbediZiwtrvUHwzggJZxWLt2LV58brN3baBfenFr/d0bwJMb1uHFLc+Uyjt3TsD6Zw7y9LQ9P6lUNn5LFzZ3b6193rXjQHR274aFgd9tf2HGjBmYOHEivV6pDrOT/rZu3Ypzzz3XDOddddVVuOuuu3D77bdj/Pg6/7vzzjtxxRVX4Gtf+xqOP/74ptqfN28ePvnJT+KEE07AOeecg3/7t3/D7/7u7wIA5s+fj/e85z347//9v5t1v/Wtb+HGG29sqv2MjIyMjIyM4YHrrrsOb3jDG+j1YeGJUrFhwwbMmDGjRKAAYNasWbXrjZCo7du34/HHH8cJJ5yASqWCH/3oR3jllVfwlre8BZMnT8Y73vEO/NM//RMuueQSPPTQQ1i3bh0WL15M9Z177rk49dRTS/rb2trw+te/HhMmTGjw23K0tbVhyZIlWLBgAWbMmDFoekcb8n2KI9+jOPI90pDvUxz5HmkYTvcp1v6IIlEdHR044ogjvPIpU/pdm9u2bWtIX29vL775zW/imWeewfjx43Hsscfiqquuqun79Kc/jSuvvBLnnHMOWltbcfnll+PQQw+l+lpbW9Ha2loqO+mkkxqyqRHMmDEjyJAz+pHvUxz5HsWR75GGfJ/iyPdIw0i4TyOKRAGR1UIN4tBDD8V1110XvP7FL35x0NrLyMjIyMjIGD0YUftETZ06FR0dHV759u39yX6HHHLI/jYpIyMjIyMjY4xiRJGomTNnoq2tDT09PaXy9evXAwCOOeaYoTBrv+Owww7DvHnzcNhhhw21KcMa+T7Fke9RHPkeacj3KY58jzSMpPs0olbnPfDAA7j00kuxaNGi0uaaf/M3f4OnnnoK3/ve92pbHGRkZGRkZGRk7EsMm5yoBx54AF1dXejs7N+To62tDXfffTcAYPbs2Zg4cSJmz56Nk046CUuXLkVnZyeOPPJI3HXXXXjwwQexYMGCTKAyMjIyMjIy9huGjSfqwx/+MNrb281rN998M6ZPnw6g/9iX6667rnTsy//8n/+zqWNfMjIyMjIyMjIaxbAhURkZGRkZGRkZIwnDJpyXEce+OHx5JOCRRx7B/PnzzWvXXnst3vzmN9c+r127Ft/4xjfw2GOPYdy4cXjrW9+KT33qU+b+Yrfeeit+8IMf4MUXX8Rhhx2Gs846CxdccIG3metwRCOHdu+Le7JlyxZce+21uP/++9HV1YVjjz0WF198Mf7gD/5gn33nRqHeo8997nNYsWKFV/+oo47Ct7/9ba98NN2jhx56CHfccQfWrFmDjRs34uCDD8Yb3vAGzJs3z9ufZ6w+R+o9GsvPEdB/9NJ1112H9evXY+vWrTjwwANx1FFH4QMf+ADe8573lGRH07M0/EeLjBoG+/DlkYZPfOITeOtb31oqK67IbGtrw/z583Hsscfi8ssvR3d3N771rW/hL//yL/Gtb32rtFHqP//zP+OGG27A+eefj5NPPhmPP/44rr/+emzatAl/8zd/s7++UjLUQ7v3xT3p7u7GJZdcgh07duB//a//hVe96lX4wQ9+gP/9v/83rr76avz+7//+Pv72Gho52PzAAw/ENddc45W5GG336Ec/+hE6OjrwR3/0Rzj66KOxdetW3HzzzfizP/szfOlLX6oNQGP5OVLvETB2nyMA2LFjB373d38XZ5xxBlpbW9HV1YU77rgDS5YswYsvvoiPfexjAEbhs1TNGBH4+c9/Xp0zZ071jjvuKJX/9V//dfUDH/hAtaenZ4gs2/d4+OGHq3PmzKmuXLkyKLdw4cLqOeecU92xY0et7MUXX6y++93vrn7961+vlW3durU6d+7c6lVXXVWq/8///M/Vd77zndUNGzYMpvn7BH19fdW+vr5qtVqtbtmypTpnzpzqDTfc4Mnti3vy7//+79U5c+ZUH3300VrZnj17qhdccEH1E5/4xGB9xaah3qMrr7yy+p73vCeqbzTeo1deecUr27lzZ/X9739/9ZJLLqmVjeXnSL1HY/k5CuGTn/xk9YMf/GDt82h7lkbUPlFjGatWrcKkSZNw2mmnlcrPPvtsbNq0CY899tjQGDZM0NPTg5///Od417vehYMOOqhWPm3aNLz1rW/FqlWramUPPvgguru7cfbZZ5d0nHXWWahWqyXZ4YpKpRLdvX9f3ZNVq1bhqKOOwlve8pZa2fjx4/Ge97wH//Vf/4WXX3652a83KFDuUSMYjffoVa96lVc2efJkzJgxAxs3bgSQnyPlHjWC0XiPQpg6dWpt5fxofJYyiRohUA5fHu24+uqr8e53vxvvfe978ZnPfAa/+c1vatdeeOEF7N69u3Y/ipg1axaef/557N69G0D9Xs2cObMk19raiqlTp46ae7mv7sn69eupzqKukYTdu3fjf/yP/4HTTjsNH/zgB3H11Vd7Z3GOlXu0Y8cOrFu3DkcffTSA/BxZcO/RAPJzBPT19aGnpwdbt27FD37wA/ziF7/ARz/6UQCj81nKOVEjBIN9+PJIwkEHHYQ/+qM/wlvf+lYccsgheP755/Hd734X8+fPxxe+8AWccsopteOArKN/DjnkEFSrVWzfvh0HHnggtm3bhgkTJmDSpEmmrHW00EjEvron27Ztqz13RYzUZ/HYY4/FscceW8uv+9WvfoXvfe97eOihh/DNb34TkydPBoAxc4+uvvpq7Nq1CxdeeCGA/BxZcO8RkJ+jASxduhTLli0DABxwwAGYP38+3v/+9wMYnc9SJlEjCIMZmhhJeP3rX4/Xv/71tc8nnHAC5syZg3nz5uHaa6/FKaecIulR799Yus+p9yRUb6Tdvw9/+MOlzyeffDJe97rXYeHChVi+fLl3nWE03KPrr78ed9xxB+bPn++tzgthLD1H7B7l56gfF1xwAc455xxs2bIFP//5z3HNNddg165d+OM//mOp/kh7lnI4b4QgH75cxpQpU/D2t78dTz31FHbv3o2pU6cCsGcc27ZtQ6VSwcEHHwyg/151d3ejq6vLlB0t93Jf3ZNDDjnE1Pn/t3e/IU21bxzAv2eNiWZbbOLCQZAoqCGJFv7DJaw0Zb7IxBLnzKSkkAyCpKhpviipFxVCSSBTsUgRFQKNrDShIgJNxAqiSIlUhsvQMmrq78VD52n5pzi/Z7Nt3w8I7pz7Pp774nJcO+feuX/k4lKfCD2NXq+Hv78/hoeHxW3eHiOr1YrGxkYcPHgQe/bsEbczj/61XIyW44t5pNVqERERgcTERBw/fhxZWVm4fv06pqamvDKXWER5CC6+vNjCT8+JDQkJgZ+fnxiPn719+xY6nU78qvGPe+y/tp2cnMSnT5+8JpauikloaCjevHmz6Jg/tv06h8FTLSwsQCb79y3Sm2NktVphtVpRVFSEgoICp33Mo3+sFKOV+FIeLSUyMhJzc3P48OGDV+YSiygPkZKSgtnZWTx8+NBp+507dxAUFISoqKhVOrPVMT09jSdPniA8PBx+fn6Qy+VISkpCX1+fuP4iAExMTGBgYAB6vV7cFh8fD4VCga6uLqdjdnV1QRAEpKSkuG0cruSqmOj1eoyOjjp9I9ThcKC7uxtRUVEICgpy4ajco7e3F1+/fnX6v/LWGDU0NMBqtcJsNqOoqGjRfubR72O0HF/Ko+UMDAxAJpMhJCTEK3OJc6I8hC8vvlxVVYXg4GBERERApVLh/fv3aG5uht1ux8mTJ8V2Bw4cwKFDh1BeXo78/Hx8+/YNdXV1UKlU2Ldvn9hOqVTCbDajrq4OSqUS27Ztw8uXL1FfXw+j0bjoGzd/qz9ZtNsVMcnMzER7ezssFgtKSkrEB9uNjo7i0qVL7gzBb/0uRlNTU6iqqoLBYIBOp4MgCOKE4E2bNsFoNIrH8sYY3bp1C3V1dYiPj0diYqLTbScA4moAvpxHfxKj8fFxn84jALh48SICAgIQGRkJtVqNqakp9Pb24sGDB8jLyxMfoultucS18zyIry6+3NTUhJ6eHoyNjWF2dhbr1q1DdHQ0TCYTIiMjndr+WE5geHgYa9asQWxsLI4cOQKdTrfouK2trWhvb8f4+DjUajUyMjJgNps9YtkX4M8X7XZFTOx2u9MSC+Hh4SguLsbWrVv/+4H+H34Xo8DAQFRXV+P169f4+PEj5ufnodVqkZKSgoKCAnF+xs+8KUZHjx7F8+fPl93f19cn/u6refQnMZqenvbpPAKAzs5OdHZ2YmRkBDMzM/D390dYWBiMRuOyy754Qy6xiCIiIiKSgHOiiIiIiCRgEUVEREQkAYsoIiIiIglYRBERERFJwCKKiIiISAIWUUREREQSsIgiIiIikoBFFBEREZEELKKIiJaQmpqK1NRUlx2/vr4egiDg3bt3LvsbRORanrG+BRGRm129enW1T4GI/nIsooiIlhAVFbXap0BEfzneziMin1JZWQlBEDAwMIDs7GwolUqoVCqYTCbYbDax3a+386qrqyGTyXD79m2n4+3fvx8BAQEYGhoSt927dw8GgwFKpRIBAQFITk7G/fv3XT42InIvFlFE5JN2796NsLAwtLa2orKyEh0dHUhPT8f379+XbF9eXo6MjAwUFhZiZGQEAGC1WtHQ0ICamhpER0cDAJqampCWlgalUomGhga0tLRArVYjPT2dhRSRl+HtPCLySdnZ2bhw4QIAIC0tDVqtFvn5+WhpaUF+fv6i9oIgoLGxETExMcjNzUVtbS1KS0thMplQXFwMAPjy5QvKyspgNBrR3t4u9s3MzERsbCxOnTqFp0+fumeARORyvBJFRD7p10IpNzcXcrkcPT09y/bRaDRobm5Gf38/kpKSsHHjRtTW1or7Hz9+DLvdjsLCQjgcDvFnfn4eu3btwrNnz/D582eXjYmI3ItXoojIJ23YsMHptVwuh0ajweTk5Ir94uPjsXnzZgwODuLw4cNYu3atuG9iYgIAkJOTs2x/u93u1IeIPBeLKCLySePj49DpdOJrh8OByclJaDSaFftVVFRgaGgIcXFxsFgsMBqNCA0NBQAEBQUBAGpqapCQkLBkf61W+x+NgIhWG4soIvJJN27cQFxcnPi6paUFDodjxQdsdnd34/z58zh9+jSOHTuGmJgY7N27F48ePYJCoUBycjLWr1+PFy9eoLS01A2jIKLVxCKKiHxSW1sb5HI5du7cieHhYZw5cwZbtmxBbm7uku3HxsZgMpmwfft2VFRUQCaTobm5GXq9HidOnMDly5cRGBiImpoaFBYWwm63IycnB8HBwbDZbBgcHITNZsO1a9fcPFIichVOLCcin9TW1oZXr14hOzsbFosFWVlZuHv3LhQKxaK2c3NzyMvLgyAIuHnzJmSyf946ExIScO7cOVy5cgUdHR0AAJPJhJ6eHszMzKCkpAQ7duxAWVkZ+vv7YTAY3DlEInIxYWFhYWG1T4KIyF0qKytx9uxZ2Gw2cQ4TEZEUvBJFREREJAGLKCIiIiIJeDuPiIiISAJeiSIiIiKSgEUUERERkQQsooiIiIgkYBFFREREJAGLKCIiIiIJWEQRERERScAiioiIiEgCFlFEREREEvwPZ+CCLbmhvy8AAAAASUVORK5CYII=\n", - "text/plain": [ - "
    " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot weights directly\n", - "# Note: for extended sources the weights also need to include the pixel area.\n", - "plt.semilogy(skymap[:]*pix_area)\n", - "plt.ylabel(\"weight\")\n", - "plt.xlabel(\"pixel\")\n", - "plt.ylim(1e-50,1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup the COSI 3ML plugin and perform the likelihood fit\n", - "Load the detector response, ori file, and precomputed point source response in Galactic coordinates:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "response_file = \"SMEXv12.511keV.HEALPixO4.binnedimaging.imagingresponse.h5\"\n", - "response = FullDetectorResponse.open(response_file)\n", - "ori = SpacecraftFile.parse_from_file(\"20280301_3_month_with_orbital_info.ori\")\n", - "psr_file = \"psr_gal_511_DC2.h5\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Setup the COSI 3ML plugin:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "... loading the pre-computed image response ...\n", - "--> done\n", - "CPU times: user 1min 55s, sys: 37.4 s, total: 2min 32s\n", - "Wall time: 2min 49s\n" - ] - } - ], - "source": [ - "%%time\n", - "\n", - "# Set background parameter, which is used to fit the amplitude of the background:\n", - "bkg_par = Parameter(\"background_cosi\", # background parameter\n", - " 1, # initial value of parameter\n", - " min_value=0, # minimum value of parameter\n", - " max_value=5, # maximum value of parameter\n", - " delta=0.05, # initial step used by fitting engine\n", - " desc=\"Background parameter for cosi\")\n", - "\n", - "# Instantiate the COSI 3ML plugin\n", - "cosi = COSILike(\"cosi\", # COSI 3ML plugin\n", - " dr = response_file, # detector response\n", - " data = data_combined.binned_data.project('Em', 'Phi', 'PsiChi'), # data (source+background)\n", - " bkg = bg_tot.binned_data.project('Em', 'Phi', 'PsiChi'), # background model \n", - " sc_orientation = ori, # spacecraft orientation\n", - " nuisance_param = bkg_par, # background parameter\n", - " precomputed_psr_file = psr_file) # full path to precomputed psr file in galactic coordinates (optional)\n", - " \n", - "# Add sources to model:\n", - "model = Model(src1) # Model with single source. If we had multiple sources, we would do Model(source1, source2, ...)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "tags": [] - }, - "source": [ - "Perform likelihood fit: " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "scrolled": true, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
    11:55:08 INFO      set the minimizer to minuit                                             joint_likelihood.py:1042\n",
    -       "
    \n" - ], - "text/plain": [ - "\u001b[38;5;46m11:55:08\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;49mINFO \u001b[0m \u001b[1;38;5;251m set the minimizer to minuit \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=641391;file:///discover/nobackup/ckarwin/Software/COSI/lib/python3.9/site-packages/threeML/classicMLE/joint_likelihood.py\u001b\\\u001b[2mjoint_likelihood.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=11475;file:///discover/nobackup/ckarwin/Software/COSI/lib/python3.9/site-packages/threeML/classicMLE/joint_likelihood.py#1042\u001b\\\u001b[2m1042\u001b[0m\u001b]8;;\u001b\\\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Adding 1e-12 to each bin of the expectation to avoid log-likelihood = -inf.\n", - "\n", - "WARNING RuntimeWarning: invalid value encountered in log\n", - "\n" - ] - }, - { - "data": { - "text/html": [ - "
    11:56:43 WARNING   get_number_of_data_points not implemented, values for statistical        plugin_prototype.py:128\n",
    -       "                  measurements such as AIC or BIC are unreliable                                                   \n",
    -       "
    \n" - ], - "text/plain": [ - "\u001b[38;5;46m11:56:43\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m get_number_of_data_points not implemented, values for statistical \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=619529;file:///discover/nobackup/ckarwin/Software/COSI/lib/python3.9/site-packages/threeML/plugin_prototype.py\u001b\\\u001b[2mplugin_prototype.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=819028;file:///discover/nobackup/ckarwin/Software/COSI/lib/python3.9/site-packages/threeML/plugin_prototype.py#128\u001b\\\u001b[2m128\u001b[0m\u001b]8;;\u001b\\\n", - "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mmeasurements such as AIC or BIC are unreliable \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
    Best fit values:\n",
    -       "\n",
    -       "
    \n" - ], - "text/plain": [ - "\u001b[1;4;38;5;49mBest fit values:\u001b[0m\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    resultunit
    parameter
    gaussian.spectrum.main.Gaussian.F(4.6951 +/- 0.0025) x 10^-21 / (cm2 s)
    background_cosi(9.32 +/- 0.05) x 10^-1
    \n", - "
    " - ], - "text/plain": [ - " result unit\n", - "parameter \n", - "gaussian.spectrum.main.Gaussian.F (4.6951 +/- 0.0025) x 10^-2 1 / (cm2 s)\n", - "background_cosi (9.32 +/- 0.05) x 10^-1 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
    \n",
    -       "Correlation matrix:\n",
    -       "\n",
    -       "
    \n" - ], - "text/plain": [ - "\n", - "\u001b[1;4;38;5;49mCorrelation matrix:\u001b[0m\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "
    1.00-0.40
    -0.401.00
    " - ], - "text/plain": [ - " 1.00 -0.40\n", - "-0.40 1.00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, + "lon.set_ticklabel(color='white',fontsize=4)\n", + "lat.set_ticklabel(fontsize=4)\n", + "lat.set_ticks_visible(True)\n", + "lat.set_ticklabel_visible(True);" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "60311b24", + "metadata": {}, + "outputs": [ { "data": { - "text/html": [ - "
    \n",
    -       "Values of -log(likelihood) at the minimum:\n",
    -       "\n",
    -       "
    \n" - ], + "image/png": "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", "text/plain": [ - "\n", - "\u001b[1;4;38;5;49mValues of -\u001b[0m\u001b[1;4;38;5;49mlog\u001b[0m\u001b[1;4;38;5;49m(\u001b[0m\u001b[1;4;38;5;49mlikelihood\u001b[0m\u001b[1;4;38;5;49m)\u001b[0m\u001b[1;4;38;5;49m at the minimum:\u001b[0m\n", - "\n" + "
    " ] }, "metadata": {}, "output_type": "display_data" - }, + } + ], + "source": [ + "# Plot weights directly\n", + "# Note: for extended sources the weights also need to include the pixel area.\n", + "plt.semilogy(skymap[:]*pix_area)\n", + "plt.ylabel(\"weight\")\n", + "plt.xlabel(\"pixel\")\n", + "plt.ylim(1e-50,1);" + ] + }, + { + "cell_type": "markdown", + "id": "fb18ce05", + "metadata": {}, + "source": [ + "## Setup the COSI 3ML plugin and perform the likelihood fit\n", + "Load the detector response, ori file, and precomputed point source response in Galactic coordinates:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "21da19ed", + "metadata": {}, + "outputs": [], + "source": [ + "response_file = \"SMEXv12.511keV.HEALPixO4.binnedimaging.imagingresponse.h5\"\n", + "response = FullDetectorResponse.open(response_file)\n", + "ori = SpacecraftFile.parse_from_file(\"20280301_3_month_with_orbital_info.ori\")\n", + "psr_file = \"psr_gal_511_DC2.h5\"" + ] + }, + { + "cell_type": "markdown", + "id": "f1e47f1c", + "metadata": {}, + "source": [ + "Setup the COSI 3ML plugin:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "837541f1", + "metadata": {}, + "outputs": [ { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    -log(likelihood)
    cosi-1.527559e+07
    total-1.527559e+07
    \n", - "
    " - ], - "text/plain": [ - " -log(likelihood)\n", - "cosi -1.527559e+07\n", - "total -1.527559e+07" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 46s, sys: 10.3 s, total: 1min 56s\n", + "Wall time: 1min 57s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "# Set background parameter, which is used to fit the amplitude of the background:\n", + "bkg_par = Parameter(\"background_cosi\", # background parameter\n", + " 1, # initial value of parameter\n", + " min_value=0, # minimum value of parameter\n", + " max_value=5, # maximum value of parameter\n", + " delta=0.05, # initial step used by fitting engine\n", + " desc=\"Background parameter for cosi\")\n", + "\n", + "# Instantiate the COSI 3ML plugin\n", + "cosi = COSILike(\"cosi\", # COSI 3ML plugin\n", + " dr = response_file, # detector response\n", + " data = data_combined.binned_data.project('Em', 'Phi', 'PsiChi'), # data (source+background)\n", + " bkg = bg_tot.binned_data.project('Em', 'Phi', 'PsiChi'), # background model \n", + " sc_orientation = ori, # spacecraft orientation\n", + " nuisance_param = bkg_par, # background parameter\n", + " precomputed_psr_file = psr_file) # full path to precomputed psr file in galactic coordinates (optional)\n", + " \n", + "# Add sources to model:\n", + "model = Model(src1) # Model with single source. If we had multiple sources, we would do Model(source1, source2, ...)" + ] + }, + { + "cell_type": "markdown", + "id": "6a18c3b1", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true }, + "tags": [] + }, + "source": [ + "Perform likelihood fit: " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "90a2449e", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ { "data": { "text/html": [ - "
    \n",
    -       "Values of statistical measures:\n",
    -       "\n",
    +       "
    14:29:22 INFO      set the minimizer to minuit                                              joint_likelihood.py:994\n",
            "
    \n" ], "text/plain": [ - "\n", - "\u001b[1;4;38;5;49mValues of statistical measures:\u001b[0m\n", - "\n" + "\u001b[38;5;46m14:29:22\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;49mINFO \u001b[0m \u001b[1;38;5;251m set the minimizer to minuit \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=1705;file:///project/cassini/cosi/threeML_git/threeML/classicMLE/joint_likelihood.py\u001b\\\u001b[2mjoint_likelihood.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=761608;file:///project/cassini/cosi/threeML_git/threeML/classicMLE/joint_likelihood.py#994\u001b\\\u001b[2m994\u001b[0m\u001b]8;;\u001b\\\n" ] }, "metadata": {}, "output_type": "display_data" }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Adding 1e-12 to each bin of the expectation to avoid log-likelihood = -inf.\n" + ] + }, { "data": { "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    statistical measures
    AIC-3.055119e+07
    BIC-3.055119e+07
    \n", - "
    " + "
    14:29:27 WARNING   get_number_of_data_points not implemented, values for statistical        plugin_prototype.py:119\n",
    +       "                  measurements such as AIC or BIC are unreliable                                                   \n",
    +       "
    \n" ], "text/plain": [ - " statistical measures\n", - "AIC -3.055119e+07\n", - "BIC -3.055119e+07" + "\u001b[38;5;46m14:29:27\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m get_number_of_data_points not implemented, values for statistical \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=809656;file:///project/cassini/cosi/threeML_git/threeML/plugin_prototype.py\u001b\\\u001b[2mplugin_prototype.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=259356;file:///project/cassini/cosi/threeML_git/threeML/plugin_prototype.py#119\u001b\\\u001b[2m119\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mmeasurements such as AIC or BIC are unreliable \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" ] }, "metadata": {}, @@ -1086,28 +1109,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6min, sys: 3min 20s, total: 9min 21s\n", - "Wall time: 1min 36s\n" + "CPU times: user 42 s, sys: 37.2 ms, total: 42 s\n", + "Wall time: 5.28 s\n" ] - }, - { - "data": { - "text/plain": [ - "( value negative_error positive_error \\\n", - " gaussian.spectrum.main.Gaussian.F 0.046951 -0.000025 0.000025 \n", - " background_cosi 0.932137 -0.004667 0.004841 \n", - " \n", - " error unit \n", - " gaussian.spectrum.main.Gaussian.F 0.000025 1 / (cm2 s) \n", - " background_cosi 0.004754 ,\n", - " -log(likelihood)\n", - " cosi -1.527559e+07\n", - " total -1.527559e+07)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -1117,11 +1121,12 @@ "\n", "like = JointLikelihood(model, plugins, verbose = False)\n", "\n", - "like.fit()" + "like.fit(quiet=True);" ] }, { "cell_type": "markdown", + "id": "cfd292e5", "metadata": { "collapsed": true, "jupyter": { @@ -1136,7 +1141,8 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, + "id": "8ad15fcd", "metadata": { "tags": [] }, @@ -1190,7 +1196,7 @@ " \n", " gaussian.spectrum.main.Gaussian.F\n", " (4.6951 +/- 0.0025) x 10^-2\n", - " 1 / (cm2 s)\n", + " 1 / (s cm2)\n", " \n", " \n", " background_cosi\n", @@ -1204,7 +1210,7 @@ "text/plain": [ " result unit\n", "parameter \n", - "gaussian.spectrum.main.Gaussian.F (4.6951 +/- 0.0025) x 10^-2 1 / (cm2 s)\n", + "gaussian.spectrum.main.Gaussian.F (4.6951 +/- 0.0025) x 10^-2 1 / (s cm2)\n", "background_cosi (9.32 +/- 0.05) x 10^-1 " ] }, @@ -1231,7 +1237,7 @@ { "data": { "text/html": [ - "
    \n", + "
    \n", "\n", "\n", "
    1.00-0.40
    -0.401.00
    " @@ -1401,9 +1407,9 @@ " * main:\n", " * Gaussian:\n", " * F:\n", - " * value: 0.046951164320587706\n", + " * value: 0.046951157075239634\n", " * desc: Integral between -inf and +inf. Fix this to 1 to obtain a Normal distribution\n", - " * min_value: null\n", + " * min_value: 0.0\n", " * max_value: null\n", " * unit: s-1 cm-2\n", " * is_normalization: false\n", @@ -1436,6 +1442,7 @@ }, { "cell_type": "markdown", + "id": "03bb6a88", "metadata": {}, "source": [ "Now let's make some plots.
    \n", @@ -1444,22 +1451,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 22, + "id": "9f845a89", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAG2CAYAAACu3oj0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABoIElEQVR4nO3deVyU5f4//tcsDAzbgICCCu65Jy6lprhramaLPeyYaamorWYetVMZmnnM6iTf+pXkQcTsk9WpNC23MrEs99IsFVeEXFDWYRkGmJn79wfO7YwMCMM9K6/n4+HjDPd93fd1XcO57e11Xff7kgmCIICIiIiIHE7u6gYQERERNRYMvIiIiIichIEXERERkZMw8CIiIiJyEgZeRERERE7CwIuIiIjISRh4ERERETkJAy83odfrcfr0aej1elc3hYiIiByEgZebyMzMxMyZM5GZmenqphAREZGDMPAiIiIichIGXkREREROwsCLiIiIyEkYeBERERE5idLVDSAiIiLnMhqNqKysdHUzPIqPjw8UCkWD78PAi4iIqBEpKSnBpUuXIAiCq5viUWQyGVq2bInAwMAG3YeBFxERUSNhNBpx6dIl+Pv7IyIiAjKZzNVN8giCICAnJweXLl1Chw4dGjTyxcCLiIiokaisrIQgCIiIiIBarXZ1czxKREQELl68iMrKygYFXlxcT0RE1MhwpKv+pPrOGHgREREROQkDLyIiInKZ1q1bo1OnToiNjUXnzp3x2GOPobS01O77rVu3DmfOnKnx/IEDB9C9e3f07NkTO3fuxNixY3H+/Pk6XSsFBl5ERETkUl999RWOHTuGkydPoqioCOvWrbP7XrcLnj7++GNMnToVR48exb333ott27ahXbt2dbpWClxcT0RE1Eh98+qv0GnLHXZ/f40vHvz3gDqXLy8vR2lpKUJDQ8Vj//nPf/C///0PBoMBkZGRWL16NaKjo/Htt9/i1VdfhVwuh8FgwL///W/k5OTgyJEjmDNnDhYtWoTly5dj7Nix4r1WrFiBL774Av7+/vj000+xZ88exMbG4rvvvsOBAwdqvVYqDLyIiIgaKZ22HLp8xwVedfXII4/Az88PGRkZ6N27NyZOnAgA2LBhA86cOYP9+/dDoVDgk08+wXPPPYfNmzdj0aJF+Oijj3DPPffAZDKhqKgIISEh+L//+z/Mnz8f48aNq1bPv/71L6Snp6NPnz547rnnrM7Fx8fXeq1UGHgREXmoMm05Lh3PRXTPCPgFqlzdHPJA/hpft7j/V199hW7dusFgMGD27Nl46aWX8O677+Kbb77BkSNH0Lt3bwBVecjMqRyGDx+OuXPn4pFHHsGoUaMQGxvrqG5IioEXEZEHKrxSgq1vHESZtgKB4X6477V+CIpgXiaqn/pMAzqDUqnEhAkTsGDBArz77rsQBAGLFi3C9OnTq5VduXIlTpw4gbS0NDzxxBOYPHkyFi5c6IJW1w8X1xMReRhtdim2/fsQyrQVAICSXD22LTuI0rwyF7eMqOF2796Njh07AgDGjx+PVatWIT8/H0BVAtijR48CANLT09G1a1c899xzePrpp3HgwAEAQHBwMLRarV11N+TaumLgRUTkQQwVRux48zB0BdbrcopzyrDjrSMwGUwuahmR/R555BHExsaia9euOHXqFN577z0AwJQpU/D4449jyJAh6NGjB2JjY5GWlgYAePnll9G1a1f07NkTn3zyCZYsWQIAmDVrFpYuXYrY2Fhs27atXu1oyLV1JRO4S6ZbOH36NGbOnInk5GQx0iciutWFA1ex+/1jAIDQ6EAMebYHfkw8iqJrOgDA6H/1Qcs7I1zYQnJner0eGRkZaNOmDfz8/FzdHI8i1XfHES8iIg+ScShb/Nzv8c4IiwnGXZNu/mMt4+A1VzSLiOqIgRcRkYcwlBvx99EcAIBvoA+iujQBAET3iIDSt+pNr8wj2TAZOd1I5K4YeBEReYi//8iBodwIAGh9VzPIFVV/hSt9FYiOrZpe1BdX4uqpfJe1kTwDVxnVn1TfGQMvIiIPcdFimrHN3ZFW59r0vflzxsFsENlizoFVUVHh4pZ4HvN3Zv4O7cU8XkREHsBQYUTW79cBAL4BPmjeNczqfHRsBBQ+chgrTbh4+BrumdYVcrnMFU0lN6ZUKuHv74+cnBz4+PhALuf4S12YTCbk5OTA398fSmXDQicGXkREHuDyn7mo1FdNM8b0bgq50vo/mD5+SrSMjUDm4WvQF1Xg2ul8RHUOs3UrasRkMhmioqKQkZGBzMxMVzfHo8jlcsTExEAma9g/aBh4ERF5gOzTBeLnVr2b2SzTqndTZB6+JpZn4EW2qFQqdOjQgdON9aRSqSQZIWTgRUTkAXIv3Mym3bS9xmaZpu1DLMoXObpJ5MHkcjnzeLkIJ3eJiNycYBKQm1EVSPk38YV/qO3/YGoiA+Cjrlr4axmoEZH7YOBFROTmiq7pUFlmAABEtLE92gUAMrkM4TfOl+broSssr7EsEbkGAy8iIjeXYzF6Fd625sALgBh4AUBuBke9iNwNAy8iIjdnOW0YXsuIV9X5YJvXEZF7YOBFROTmLEeuLAMrWyxHxMzrwojIfTDwIiJyYyaTgLyLVQFUYLgf1BrfWssHN/OHyr/qhXWOeBG5HwZeRERuTHu1VEycertpRqAqQaa5nK6wHKUFeoe2j4jqh4EXEZEby63Hwnpb5TjqReReGHgREbkxewKviLY314HlnGfgReROGHgREbmx/L+Lxc/hrWpfWG8W1vpmgFZwqUTyNhGR/Rh4ERG5Me3VUgCAX5AP/IJVdbomMEINhY/8xvUMvIjcCQMvIiI3VVFmgK6gKvt8cFRAna+Ty2UIbuYPACjK1sFkNDmkfURUfwy8iIjcVFF2qfg5pB6BFwBobpQ3GQWU5JZJ2i4ish8DLyIiN2WeZgRuBlJ1ZVlee6W0lpJE5EwMvIiI3FThlQYEXs1vli+8ysCLyF0oXd2A+tLpdFizZg3S0tJQXFyMmJgYTJ48GcOHD7/ttQUFBUhKSsL+/fuh1+vRvn17xMfHo3fv3mKZ0tJSfP311zhy5AiysrJQVlaGyMhIjBo1Co888gh8fa2zRhsMBnzyySfYvn078vLyEBUVhYceeggTJkyQvO9E1LhYTjXWO/CKtBjxYuBF5DY8LvBatGgR0tPTMXv2bERHR2PXrl14/fXXYTKZMHLkyBqvq6iowNy5c1FSUoLnn38eoaGh2LRpE+bPn4/ExETExsYCAK5du4Yvv/wS9957LyZOnAi1Wo3jx48jNTUVR44cwcqVKyGTycT7rly5Et9//z1mzJiBTp064dChQ3j//feh0+kwZcoUR38dROTFzCNeMhnExfJ1ZTnixcCLyH14VOC1f/9+HDlyBAkJCRgxYgQAoFevXsjOzkZSUhKGDRsGhUJh89qtW7ciIyMDq1atQrdu3QAAPXv2xPTp05GUlITVq1cDAKKiovC///0ParVavLZ3797w8/NDUlIS/vzzT9x5550AgIyMDGzduhUzZ87EpEmTxHsWFRVh/fr1eOCBBxAcXLe8O0RElgRBEEe8qtJD2P67rSZ+gSr4BflAX1wJbTYDLyJ34VFrvPbu3Qu1Wo0hQ4ZYHR87dixyc3Nx8uTJWq+NiYkRgy4AUCqVGDVqFE6dOoWcnBwAgFqttgq6zDp37gwAuH79utU9BUHAmDFjrMqOGTMG5eXlOHjwYL37SEQEVO2zaN6jURMVaNc9zCkodPnlqNQbJGsbEdnPowKvjIwMtGrVCkql9UBdu3btxPM1uXDhgliuvtcCwO+//w4AaNOmjVV7QkJCEBYWVu975ubm4vTp0+KfzMzMWusnosbF8k3EkOb1W98lXhfF6UYid+NRU41arRbNmzevdjwoKAgAUFRUVOO1RUVFYrn6Xnv+/Hl89tlniIuLswretFqtzalEtVoNHx8faLU175G2ZcsWrFu3rsbzRNS4WU4PBkfWb32XmeaWwCu8Td32eiQix/GowAuA1cJ2Ka+t6dzVq1fx0ksvoWnTpnjppZckq2/8+PEYMGCA+HNmZiaWLVtWr/sTkfeyHvGyb6rRcoqSI15E7sGjAi+NRmNzFKm4uGoT2doWsgcHB9sc1TJfa2s0LDs7Gy+88AIUCgUSExOr3V+j0eDcuXPVrisrK0NlZWWt7QkPD0d4eHiN54mocWtI8tSb190cKWPgReQePGqNV9u2bZGZmQmDwXqR6IULFwBYr7+yde358+erHTcfa9u2rdXx7OxszJkzBwDw3nvvoWnTpjbvWVhYiLy8vHq3h4ioNuZASemrgH+o721K2xbczB/mgfdCZq8ncgseFXjFxcWhrKwMP/30k9XxHTt2IDw8HF26dKnx2kGDBiErK8vqzUeDwYAffvgBXbp0sRp9unbtGubMmQOTyYT/9//+HyIjI23ec+DAgZDJZNixY4fV8e3bt8PX1xd9+/a1p5tE1MiZjCYU39hfMTjS3+4lFgofBQLDq97SLr6uk6x9RGQ/j5pq7NevH/r06YOVK1dCp9OhRYsW+PHHH3Hw4EEsWrRIzOG1YsUK7Ny5E5999pkYNI0dOxabNm1CQkICZs+eLSZQzcrKQmJiolhHQUEBXnjhBeTn52PhwoUoKChAQUGBeD4iIkIc/WrTpg3uu+8+pKamQi6Xo3Pnzjh8+DC+/fZbxMfHM4cXEdlFV1AOwSgAAIIi7FtYbxbU1B/FOWWo0BlQXloJ3wAfKZpIRHbyqMALAJYtW4bk5GSkpKSIWwYtXrzYassgk8kEo9EIQRDEYyqVComJiUhKSsJ7770HvV6PDh064J133hGz1gPAxYsXceXKFbGuWz355JOYPn26+PO8efMQHh6OjRs3Ij8/H5GRkZgzZw63DCIiuxXnlImfA8P9GnQvy+tLcssYeBG5mEywjE7IZU6fPo2ZM2ciOTkZHTt2dHVziMiFzu69jJ+SjgMA+k3phG5j7F8v+vvGs/j9q6qXgEb+sxda9W4mSRuJyD4etcaLiKgxKLEa8WrgVKPF9ZYjaUTkGnZNNd76BqA95s6dK741SEREN5kX1gNAUET1LczqI9Di+hIGXkQuZ1fgdfHiRWg0GoSEhNhVaVZWFgoLC+26lojI21mPeDUw8LK43jKgIyLXsHtx/YsvvoiEhAS7rpXLOcNJRFSTkhsBko9aCVVAw96BCmjiC5lcBsEkcMSLyA0wAiIiciMmkyAGXkER6gZtkwYAcoUcAWFVbzaWcMSLyOXs+qfU2bNn0aRJE7srbej1RETeqqxAD9ONHF6BDVzfZRYUoUZJThnKSypRoauEyp8pJYhcxa7Aq127dg2qtKHXExF5q2IJ13fZuk9Jrh5NYhh4EbkKpxqJiNyI1RuNDgi8inO4dRCRKzHwIiJyI5brsKScarx5f70k9yQi+0gaeBUUFGD9+vVS3pKIqFGxfPOwoTm8zKxyeXGBPZFLSRp4ZWVlYdq0aVLekoioUXHEGq8gTjUSuY16La7Pysqq9bx5c2kiIrKPecTLx08B30BpFsEHNPGDTAYIArPXE7lavQKv1q1b15pTRhCEBuecISJqrASTgJK8qsAoUIIcXmZyZVUur5JcPacaiVysXoFXaGgoli9fjiFDhtg8f+rUKUyYMEGKdhERNTo6bTlMhhs5vCSaZjQLDFejJFcPfXElKvUG+Pg1LCM+EdmnXk9e7969kZOTg44dO9o8r9frIQiCJA0jImpspNyj8VZV9yuoqie3DKEtgyS9PxHVTb0Cr6effhqlpaU1no+JiUFqamqDG0VE1BjpCm6megi8sc2PVAKa3LxfaUE5Ay8iF6lX4PXQQw/Vej40NBRPPPFEgxpERNRYlebfDLz8m0gceFkEcro85vIichUmUCUichOl+eXi5wCpAy/LEa98Bl5ErtLgwEuhUNw2zQQREd1eqcVIFAMvIu/U4MCLi+mJiKRhGRAx8CLyTpxqJCJyE+aAyDfQB0qVQtJ7+wWpIFfIrOohIudj4EVE5AYEkyC+1Rgg8RuNACCTy8QF+wy8iFyHgRcRkRsoK66AyVi1dCMgVPrAC7g53VheUglDhdEhdRBR7Rh4ERG5AZ0DF9bbui9HvYhcg4EXEZEbcOTCelv3ZeBF5BoMvIiI3AADL6LGocGB16uvvoqQkBAJmkJE1HhZZa13wOJ6AAho4it+1jHwInIJu7enNxgMUCqVeOONN6RsDxFRo+T0ES9uG0TkEnaPeDVv3hzz58/HqVOnpGwPEVGjxKlGosbB7sBLq9Vi5cqV6NatG+655x6kpKSgpKREyrYRETUa5kDIR62ESm33ZESt1CG+kMms6yMi57I78Lp69SoSExPRvXt3HDhwALNmzUJUVBRmzJiBX375Rco2EhF5NUEQxEDIch2W1OQKOdShVfdn4EXkGnYHXk2aNMELL7yAY8eO4ciRI3j66aehUqmQmpqKwYMHo3PnznjnnXdw7do1KdtLROR1yksrYawwAXDcNKOZ+f5lRRUwGkwOrYuIqpMknUSvXr3wwQcf4OrVq9iwYQOGDx+Os2fP4l//+heio6Px0EMP4bvvvoPJxIeciOhWuvxy8bPDAy9zVnwB0BWU116YiCQnaR4vlUqFf/zjH/j+++9x8eJFLFmyBNHR0di8eTMeeOABREdHS1kdEZFXcMbCelv353QjkfM5LIFqy5Yt8dprr2Hbtm0YMGAABEFAdna2o6ojIvJYLgu88socWhcRVeeQV2dKS0vxv//9D2vXrsW+ffsgCAL8/f3xyCOPOKI6IiKPZpU81UEbZIv3twi8ONVI5HySBl579+7F2rVr8dVXX0Gn00EQBNx1112YMWMGJk2ahKCgICmrIyLyCmWFNwMgfwe+1QgA/iEW2esLGXgROVuDA6/Lly/j448/xrp163D+/HkIgoCwsDDEx8djxowZ6NatmxTtJCLyWqUFFiNeIQ4e8WLgReRSdgde//vf/5Camopdu3bBaDRCLpdj1KhRmD59Oh588EH4+PhI2U4iIq9lnvKTyWXwC1Y5tC7/0JuBVxkDLyKnszvw+sc//gEAaN26NaZNm4Zp06ahZcuWkjWMiKixMAdAao0KcrnMoXX5qJVQqOQwVpigK+RbjUTO1qDAa8aMGRg+fLiU7SEialRMRhPKtFWBl6MX1gOATCaDf4gviq+XcXE9kQvYHXht2LBBynYQETVKZUUVEISqz5bTgI7kH+KH4utlqNAZYKgwQqlSOKVeIpIwj5fBYEBiYiLuvvtuBAcHQ6m8GdMdO3YMzzzzDM6cOSNVdUREXqHMYtTJcuG7I1nWw3VeRM4lSeBVVlaGoUOHYv78+cjMzERwcDAE8z/hALRp0wapqalYv369FNUREXkNqzcanTTipQ7lm41EriJJ4LV8+XL8+uuvePPNN5GdnY34+Hir8xqNBoMHD8bOnTulqI6IyGtY5fBycCqJm/Uw8CJyFUkCry+++AJDhgzBwoULIZPJIJNVfyunbdu2yMrKkqI6IiKvUWo51ei0NV4WgRcX2BM5lSSBV1ZWFu66665aywQHB0Or1UpRHRGR19C5OvDiiBeRU0kSeAUFBSEnJ6fWMufPn0dERIQU1REReQ3LXFrOmmpUWyVRZS4vImeSJPDq168fvv322xpHtC5duoRt27Zh0KBBUlRHROQ1nJm13owjXkSuI0ngtWDBAuTn52PEiBHYt28fDAYDAECn0+HHH3/EqFGjUFlZiXnz5klRHRGR1zAHPuoQx2etN/MLVEGmkFnVT0TO0eBNsgFg0KBB+PDDDzFnzhzExcWJx4OCggAACoUCq1atQu/evaWojojIK5iMJujNWeudNM0IVI2u+Wt8UZqv5+J6IieTJPACgKeeegqDBw/GRx99hIMHDyI/Px/BwcHo27cvnnnmGXTt2lWqqoiIvIIrstab+YdUBV764gqYjCbIFZLl0yaiWkgWeAFA586d8d5770l5SyIir6VzQdZ6M3GBvQCUaSsQ0MR5I25EjZlT/4ljMpmcWR0RkVvTuSBrvVgfF9gTuYQkgdeaNWtuW8ZoNOKxxx6TojoiIq9gGfD4hzp3xMk6iSpTShA5iySB19NPP43NmzfXeF4QBEyePBlffvmlFNUREXkFV041cqNsIteQLI/XpEmTsHfv3mrnzEHX//73Pzz11FNSVEdE5BVckbXeTM2pRiKXkCTw+u6779CuXTuMHz8ef/75p3hcEARMmTIFn3/+OWbPno0PP/xQiuqIiLyCK7LWi/VZTG0y8CJyHkkCL41Gg507d0Kj0WD06NG4ePEiBEHA448/jg0bNmDWrFlISkqSoioiIq9hnuKTyeC0rPVmXFxP5BqSvdXYvHlzfP/996ioqMCoUaMwadIkfPbZZ4iPj8dHH30kVTVERF5DdyN5qp/G12lZ683UGhVwo8oyJlElchpJ00nccccd2L59O7Kzs/Hll19ixowZ+O9//ytlFUREXkEwCSjTVgBw/sJ6AJAr5FDfGGXjiBeR89iVQHXp0qW1nr/77rtx7NgxtGjRwqqsTCbDa6+9Zk+VREReRV9SAcFYlbZerXF+4AVUBXxl2grotOUQTAJkTh51I2qM7Aq8lixZUqdytwZoDLyIiKqUFVaIn/1DnLu+y0wd4gdkFkMwCtCXVEAd7JoAkKgxsSvwSktLk7oddabT6bBmzRqkpaWhuLgYMTExmDx5MoYPH37bawsKCpCUlIT9+/dDr9ejffv2iI+Pr7Z59759+5CWloYzZ84gKysLRqMRP//8c7X7Xb16FY8++qjNuhYvXlynNhFR42Re3wW4cMQr1HqBPQMvIsezK/AaPHiw1O2os0WLFiE9PR2zZ89GdHQ0du3ahddffx0mkwkjR46s8bqKigrMnTsXJSUleP755xEaGopNmzZh/vz5SExMRGxsrFj2559/xokTJ9ChQweoVCqcPn261jZNmDABI0aMsDrWsmXLBvWTiLxbmQtzeIn1WiZRLSgHYlzSDKJGRdJNsh1t//79OHLkCBISEsRAp1evXsjOzkZSUhKGDRsGhUJh89qtW7ciIyMDq1atQrdu3QAAPXv2xPTp05GUlITVq1eLZRcuXAi5vOq9g8TExNsGXk2bNkXXrl2l6CIRNRJuMeLFlBJETufUTbIbau/evVCr1RgyZIjV8bFjxyI3NxcnT56s9dqYmBgx6AIApVKJUaNG4dSpU8jJyRGPm4MuIiJHsdymxxVvNQLMXk/kCh414pWRkYFWrVpBqbRudrt27cTz3bt3t3nthQsX0KNHj2rHLa+NiIiwq10bNmxAcnIyFAoF7rjjDkyaNAkDBw6s9Zrc3Fzk5eWJP2dmZtpVNxF5pjLLES8XBV4c8SJyPo8KvLRaLZo3b17teFBQEACgqKioxmuLiorEcvW9tiY+Pj64//770adPH4SFheHatWvYuHEjXnnlFSxcuBDjxo2r8dotW7Zg3bp19a6TiLyDzg1GvCzXljGJKpFzeFTgBVSlpHDEtfbcNzw8HAsWLLA6NnToUMyePRurV6/G6NGjq43OmY0fPx4DBgwQf87MzMSyZcvq3QYi8kzmwEvpq4CPn2v+KrZcW8YRLyLn8KjAS6PRQKvVVjteXFwMAAgODq7x2uDgYJujWuZrbY2G2UOpVGLYsGFYvXo1Ll26hNatW9ssFx4ejvDwcEnqJCLPY17j5arRLgBQqhTwDfBBeWml1YbdROQ4HrWKvG3btsjMzITBYLA6fuHCBQBAmzZtar32/Pnz1Y6bj7Vt21aydgpCVTZqLtInIlsMFUZU6Kr+HnPV+i4zc/26wnLx7y4ichxJI4OCggKsX79eyltaiYuLQ1lZGX766Ser4zt27EB4eDi6dOlS47WDBg1CVlaW1ZuPBoMBP/zwA7p06SLZ6JPBYEBaWho0Gg1atGghyT2JyLtYLqz3d1EqCbH+G4GXscKEyjLDbUoTUUNJOtWYlZWFadOmYerUqVLeVtSvXz/06dMHK1euhE6nQ4sWLfDjjz/i4MGDWLRokZjDa8WKFdi5cyc+++wzREZGAqhKObFp0yYkJCRg9uzZYgLVrKwsJCYmWtWTnZ2N9PR0AMCVK1cAAHv27AEAREZGolOnTgCADz74AAaDAd27d0eTJk1w/fp1fP311zh79ixefvnlGnOKEVHjZplKwtUjXlbZ6wvKofL3cWFriLxfvQKvrKysWs+bgxRHWrZsGZKTk5GSkiJuGXTr9jwmkwlGo9Fq2FylUiExMRFJSUl47733oNfr0aFDB7zzzjtWWesB4OjRo3jzzTetjiUkJAAARo8ejVdeeQVA1dTmli1bsGvXLpSWlsLf3x+dO3fGf/7zH9x9990O+gaIyNPpLPZpVLton8ab9VsvsA9pEejC1hB5P5lQj0l9uVxe69t/giBAJpPBaDRK0rjG5PTp05g5cyaSk5PRsWNHVzeHiBzo1K4s/Lr2BAAgblY3dBwS7bK2/LktAwf/r2qEf8izPdB+QPWUPUQknXqNeIWGhmL58uXVMsebnTp1ChMmTJCiXUREXssqh5ebrPECmFKCyBnqFXj17t0bOTk5NY7I6PV6vhVDRHQb7rrGq4yBF5HD1Svwevrpp1FaWlrj+ZiYGKSmpja4UURE3sxyg2xX5vGqqt9P/KwrYC4vIkerV+D10EMP1Xo+NDQUTzzxRIMaRETk7cTteWSAX7B7La4nIsdihk8iIiczj3j5BakgV7j2r2GVWgmlb1XqGwZeRI7HwIuIyIkEQXCL7YIsmdvBNV5EjtfgwEuhUNw2vxcREVUpL62EyVj1EpLbBF43FthX6AwwVDAdEJEjNTjw4luMRER1505vNJqpLVJaWG5nRETS41QjEZETWa6jUrs4h5eZZQDI6UYix2LgRUTkRJaBjb+Ltwsys06iWlFLSSJqKAZeREROpNNa7tPoV0tJ57HMnq8rZC4vIkdi4EVE5ETuOOJlNdWo5YgXkSMx8CIiciL3XON1MwDkGi8ix2LgRUTkRNYjXu4ReFltG8S3GokcqsGB16uvvoqQkBAJmkJE5P3M6RoUKjl81PXatc1h/IJVkMmqPovbGRGRQzT4qX/jjTekaAcRUaNgnmr01/hCZo52XEwul8EvWIUybQVHvIgczKFTjYIg4OzZs7h06ZIjqyEi8gjGSiPKSyoBuE/yVDO1xbZBTIxN5DiSBF6bN2/G9OnTUVBQIB67ePEiunfvjk6dOqFVq1aYPHkyTCaTFNUREXmksqKbbwy6y/ouM3N7TEZBDA6JSHqSBF4fffQRDh8+jNDQUPHY3LlzcfLkSQwdOhR33nknPv/8c6SmpkpRHRGRR9IVuN92QWbcNojIOSQJvE6cOIG7775b/Fmr1WLbtm149NFHsWvXLhw6dAidO3dGSkqKFNUREXkky4DG301SSZhZZ69n4EXkKJIEXjk5OYiKihJ//uWXX2AwGDBp0iQAgI+PD0aOHIlz585JUR0RkUdyxw2yzaxGvBh4ETmMJIFXcHAw8vLyxJ/37NkDuVyOuLg48ZiPjw9KS0ulqI6IyCNZvjHodmu8QjniReQMkgRenTp1wrfffov8/HxotVp8/vnn6NWrl9War8zMTDRr1kyK6oiIPJLnrPHitkFEjiJJ4DVnzhxcuXIFLVq0QHR0NK5cuYKnnnpKPG80GvHLL7+gR48eUlRHROSRLAMaf4177NNoxjVeRM4hSdrkCRMm4MMPPxQXz0+cOBHTp08Xz//444/Q6XQYPXq0FNUREXkky7VTfm62uF6t4X6NRM4g2X4VTz/9NJ5++mmb50aNGmWV44uIqDEyr/HyC/KBQuleW+X6qJVQ+ipgKDdyxIvIgdzrySci8lKCIIgjSe62vgsAZDKZOOrFPF5EjsPAi4jICSp0Bhgrq3bvULvZNKOZOSAsL6mEsdLo4tYQeScGXkRETmC5bsrdUkmY+fPNRiKHY+BFROQEOjdOnmrGNxuJHI+BFxGRE+g8YMTLMiDkOi8ix2DgRUTkBB4XeHHEi8ghGHgRETmBO+/TaGa5xotTjUSOUe/Ay2Qy4a+//sKVK1eqnausrMTPP/8sScOIiLyJrkAvfnbXES+u8SJyvHoFXpmZmejevTvuvPNOREdHY/z48VabY+fn52Po0KGSN5KIyNN53FQj32okcoh6BV4LFy5Ey5YtkZWVhT/++APl5eUYMGCA1eiXIAiSN5KIyNOZF6srfRXwUUu2aYik1ME3tw3SFeprKUlE9qpX4PXTTz/h7bffRsuWLdGtWzfs2LEDcXFxiIuLQ1ZWFoCq7MdERGRNV1AVePmH+Lrt35NypRx+QT4AgLJCjngROUK9Ai+dTgdf35tD0TKZDMnJyRg1ahQGDRqE8+fPS95AIiJPZ6gwokJnAOC+C+vN1CF+AKpG6DiDQSS9egVeHTt2xJEjR6odT0pKwtixYzFu3DjJGkZE5C08IWu9mX9I1XSjsdIkBotEJJ16BV4PP/wwNmzYYPPcqlWr8Oijj/JfSEREt/CEhfVmaqaUIHKoegVeL7/8MrZt21bj+aSkJJhMpgY3iojIm1gFXqFuHngxiSqRQzGBKhGRg5kX1gPWI0ruyJ/bBhE5FAMvIiIH86SpRiZRJXKsBgdeCoVCTCVBRETVlVnkxFK7+1Qj13gROVSDAy8upiciqp3OIieWu494cY0XkWNxqpGIyMHMI14yhQx+garblHYtrvEiciwGXkREDmaesvPX+EImd8+s9WYqfyUUPlX/aeBUI5H0GHgRETmQyWhCWVHVVKO7TzMCVTuSmNd5caqRSHoMvIiIHKisqAK4sRTW3RfWm6lvZK/XF1fCZGBuRiIpMfAiInKgsgLPSSVh5n9jv0YA4mgdEUmDgRcRkQN5Ug4vM7Xm5gsAXOdFJK0GB16vvvoqQkJCJGgKEZH3sQxc1B4SePkzpQSRwygbeoM33nhDinYQEXmlMk8c8WL2eiKH4VQjEZEDeeJUo/W2QfpaShJRfTV4xMuSyWTCpUuXcPnyZVRWVtosM2jQICmrJCJyax4feBVwxItISpIEXoIgYMWKFUhMTEReXl6tZY1GoxRVEhF5BHHESGa9D6I78w+1eKuRU41EkpIk8Hr55Zfx9ttvo2nTppg2bRqioqKgVEo6mEZE5JHMgYtfkApypWes7lBrVIAMgMARLyKpSRIdrVu3Dh07dsThw4cRGBgoxS2JiDyeIAg3twvykGlGAJAr5FAHq1CmreDieiKJSfLPr5KSEtx3330MuoiILJSXVMJkqEpb70mBF3CzvTptOQST4OLWEHkPSQKv2NhYXLlyRYpbERF5DU/M4WWmvpG9XjAK0Bczez2RVCQJvBYtWoTNmzfj999/l+J2RERewRPfaDTzD2UuLyJHkGSN1+jRo/Hxxx9jzJgxGD9+PHr06IHg4GCbZadOnSpFlUREbq/Mg0e8bk0pEdbKhY0h8iKSBF7l5eXYvHkzcnNzkZKSAgCQyWRWZQRBgEwmY+BFRI2G94x4MYkqkVQkCbzmzZuHTz/9FHfeeSceeeQRh6aT0Ol0WLNmDdLS0lBcXIyYmBhMnjwZw4cPv+21BQUFSEpKwv79+6HX69G+fXvEx8ejd+/eVuX27duHtLQ0nDlzBllZWTAajfj5559t3tNgMOCTTz7B9u3bkZeXh6ioKDz00EOYMGGCJP0lIs/lidsFmfmH3MzlxalGIulIEh19+eWX6N27N/bv3+/w/F2LFi1Ceno6Zs+ejejoaOzatQuvv/46TCYTRo4cWeN1FRUVmDt3LkpKSvD8888jNDQUmzZtwvz585GYmIjY2Fix7M8//4wTJ06gQ4cOUKlUOH36dI33XblyJb7//nvMmDEDnTp1wqFDh/D+++9Dp9NhypQpUnadiDyMZQ4syxEkT2A14sVcXkSSkSRK0uv1GDp0qMODrv379+PIkSNISEjAiBEjAAC9evVCdnY2kpKSMGzYMCgUCpvXbt26FRkZGVi1ahW6desGAOjZsyemT5+OpKQkrF69Wiy7cOFCyOVV7x0kJibWGHhlZGRg69atmDlzJiZNmiTes6ioCOvXr8cDDzxQ41o3IvJ+llN0liNInsCfG2UTOYQkbzX27t0b586dk+JWtdq7dy/UajWGDBlidXzs2LHIzc3FyZMna702JiZGDLoAQKlUYtSoUTh16hRycnLE4+agqy7tEQQBY8aMsTo+ZswYlJeX4+DBg3W6DxF5J3PA4qNWQulr+x+F7sryZYAyjngRSUaSwGv58uXYsWMHvvvuOyluV6OMjAy0atWq2shau3btxPM1uXDhgliuvtfW1p6QkBCEhYXV+565ubk4ffq0+CczM7Pe9ROReyvzwKz1ZgqlHH5BPgC4uJ5ISpLMDf7www8YMmQIHnjgAQwdOhSxsbE2p9hkMhlee+01u+vRarVo3rx5teNBQUEAgKKiohqvLSoqEsvV99ra2mOrn2q1Gj4+PtBqtTVeu2XLFqxbt67edRKRZ6jUG1CpNwLwvPVdZv6hftAXV0JXUC6+mU5EDSNJ4LVkyRLx8+7du7F7926b5RoaeJnv4YhrHfEXSm33HD9+PAYMGCD+nJmZiWXLlkneBiJyDauF9R444gVUtTs/qxgmo4Dy4kr4Batc3SQijydJ4JWWlibFbW5Lo9HYHEUqLi4GgFoXsgcHB9sc1TJfa2s0rC7tsbW2raysDJWVlbW2Jzw8HOHh4fWuk4g8Q5nWInmqxjMDL/UtC+wZeBE1nCSB1+DBg6W4zW21bdsWu3btgsFgsFrndeHCBQBAmzZtar32/Pnz1Y6bj7Vt29au9vz444/Iy8uzWudVl/YQkXfz5OSpZv6hlrm89GgSU/9/oBKRNUkW1ztLXFwcysrK8NNPP1kd37FjB8LDw9GlS5carx00aBCysrKs3nw0GAz44Ycf0KVLF7tGnwYOHAiZTIYdO3ZYHd++fTt8fX3Rt2/fet+TiLyD5VSj2lPXeIUwlxeR1CQZ8fr111/x9ddfY+HChYiMjKx2Pjs7G2+//TYmTpyIfv362V1Pv3790KdPH6xcuRI6nQ4tWrTAjz/+iIMHD2LRokViDq8VK1Zg586d+Oyzz8T2jB07Fps2bUJCQgJmz54tJlDNyspCYmJitfamp6cDAK5cuQIA2LNnDwAgMjISnTp1AlA1onXfffchNTUVcrkcnTt3xuHDh/Htt98iPj6eObyIGjHvGPFiLi8iqUkSeK1cuRLHjx/HypUrbZ6PjIzEd999h8uXL+OLL75oUF3Lli1DcnIyUlJSxC2DFi9ebLVlkMlkgtFohCAI4jGVSoXExEQkJSXhvffeg16vR4cOHfDOO+9YZa0HgKNHj+LNN9+0OpaQkACgakPwV155RTw+b948hIeHY+PGjcjPz0dkZCTmzJnDLYOIGjlP3i7IjElUiaQnEyyjEzvFxMRg+PDhSE1NrbFMfHw8fvjhB+arqsHp06cxc+ZMJCcno2PHjq5uDhE10PY3D+Hyn3kAgCn/HQHfQB8Xt6j+inN0+OKFqqUdre9qhhEv9nJxi4g8nyRrvK5fv44WLVrUWiYyMhLXr1+XojoiIrdXml81QqRQyaEKcOx2ao5itbiea7yIJCFJ4BUSEoKsrKxay2RmZiIwMFCK6oiI3J6uoCrbe0Con8cmHlUo5WIKidICZq8nkoIkgVf//v2xadMm/P333zbPZ2Vl4ZtvvsE999wjRXVERG6tUm9Ahc4AwHOz1psF3Gi/rrAcgqnBK1OIGj1JAq958+ZBp9NhwIABWL9+Pa5evQoAuHr1Kj7++GMMGDAAZWVl+Oc//ylFdUREbs1yWi6giV8tJd2f/432C0YBZUUVLm4NkeeTZOFBXFwc3n//fcydOxfTpk0DULVdjnndvlwux3vvvYdBgwZJUR0RkVsrzb85LWe5TsoTBViu88rXe+wbmkTuQrIVn88++ywGDx6MpKQkHD58GIWFhQgJCcHdd9+Np556Ct26dZOqKiIit2a5HiqgiWcHKv4W7S8t0CMcGhe2hsjzSfqqTbdu3fDhhx9KeUsiIo+j89IRL8uRPCKyj0dtGURE5AlKvXCNF8CUEkRSYOBFRCQxjngRUU0YeBERScxyjZenp5OwXOOlYy4vogZj4EVEJDHdjaz1fsEqKJSe/desb4APFD5VfTBn4yci+3n23whERG7GZBLEDaU9fX0XUJUayNwPjngRNRwDLyIiCem1NzO8e/o0o5m5HxU6Ayr1Bhe3hsizMfAiIpKQN73RaBbANxuJJCNZHq+Kigp88803YvJUo9FYrYxMJkNKSopUVRIRuR3LNxoDPPyNRjP/W95s1EQFuLA1RJ5NksArMzMTI0eOxPnz58Vtgmxh4EVE3s7qjUYPz1pvZjllWsp1XkQNIkng9eKLL+LcuXOYMmUKpk+fjpYtW0KplDQpPhGRR7B8889bRrysphqZy4uoQSSJjnbv3o3hw4fj448/luJ2REQeS2c14uUdgZfVVCPXeBE1iCSL600mE3r27CnFrYiIPFqpF67xstzomyNeRA0jSeDVv39/nDp1SopbERF5NPOIl0IlhyrAO5ZcWI94MfAiaghJAq8VK1YgLS0NX331lRS3IyLyWOY1XgGhfpDJZC5ujTQUSjn8glUAbmblJyL72PXPsaVLl1Y7NnToUDz66KMYPHgwevbsCY1GU62MTCbDa6+9Zk+VRERur0JXicqyqgSj3rK+yyygiR/0RRXQFZbDZDRBrmAaSCJ72BV4LVmypMZze/bswZ49e2yeY+BFRN7Mcn1XYJh3BV6BYX7Iu1gE4caWSIFhalc3icgj2RV4paWlSd0OIiKPV5JnsbDeywITy/6U5ukZeBHZya7Aa/DgwVK3g4jI45VaBF6B4d414hVgMYJXkqdHMxe2hciTcZKeiEgipXll4udAL1vjZTl1atlPIqofyd91NhgMOHPmDLRaLTQaDe644w5msSeiRqGxTDVa9pOI6keyEa+cnBzMnDkTISEh6N69OwYOHIju3bsjJCQEs2bNQk5OjlRVERG5JW+earQe8WLgRWQvSYaiLl++jAEDBiArKwsREREYNGgQmjVrhmvXruG3337DmjVr8MMPP+CXX35BixYtpKiSiMjtlNyYgvNRK6Dy93Fxa6TlH+oLmQwQBE41EjWEJCNeCxcuRFZWFl5//XVkZmZi27ZtSE1NxbZt25CZmYklS5YgMzMTL730khTVERG5HUEQxJGggCbeNc0IAHKFXMxgz6lGIvtJMuK1Y8cOjB492maOLj8/PyQkJGDfvn3Yvn27FNUREbkdfXEFjJUmAN6Xw8ssIMwPpfl66IsqYKgwQqlSuLpJRB5HkhGviooK9OrVq9YyvXv3RkVFhRTVERG5nVIvXlhvZplSopSbZRPZRZLAq3fv3khPT6+1THp6Onr37i1FdUREbqck13uz1psF3pJElYjqT5LA64033sB3332HdevW2Ty/du1abNu2DcuWLZOiOiIit1Oaf3PBeYCXBl4BfLORqMEkWeOVlpaGoUOHYsaMGXj77bcxYMAANG3aFNevX8evv/6K06dPY9SoUdi9ezd2794tXse9G4nIW5RYpZLwzqnGQKvs9XyzkcgekgRelptmp6en25x23LlzJ3bu3Gl1jIEXEXmLUoupxgAvy1pvdut+jURUf5KNeBERNWYljWCqMfCW/RqJqP4kCby4aTYRNXbmESC/YJXXplnwC1ZB4SOHsdJktaaNiOqOm2QTETWQyWiCrqAcgPdOMwJVy0PM/bN8i5OI6s6uwOuxxx7Dxo0b7a60odcTEbkTXWE5BJMAwHtTSZiZp1Erywyo0FW6uDVEnseuwOvzzz/HX3/9ZXelDb2eiMidNIbkqWaWuby4zouo/uxe43Xs2DGsX79eyrYQEXmk4us68XNghJcHXuEWC+xzytAkOsiFrSHyPHYHXt988w02b95c7+sEQbC3SiIit1Sce3OheZCXB15BEf7i5+IcLrAnqi+7Aq/U1NQGVxwbG9vgexARuYPi640n8LIc0SvO0dVSkohssSvweuKJJ6RuBxGRxyrJsQy8/Gsp6fmCmlqs8eKIF1G9MZ0EEVEDmUd+fNRKqAIkSY/otgKa+EEmlwHgVCORPRh4ERE1gMkkiG/3BTVVQyaTubhFjiVXyMWUEhzxIqo/Bl5ERA2gy9dDMFa9NBTkpZtj38q8jq28tJK5vIjqiYEXEVEDWE63BTX17vVdZkFWC+w56kVUHwy8iIgawPLNvsBGMuJl9WbjdQZeRPXBwIuIqAGs3mhs2jgCL8s3N0tymVKCqD4YeBERNYDlVJu3Z60341Qjkf0YeBERNYDVGq9GMtXIwIvIfnYHXr169cJ///tfq2M7d+7EvHnzbJZ//fXXoVR6d34bImp8zFONvoE+UPn7uLg1zqEO9YNcUZU2gykliOrH7sDr2LFjyM7Otjp24MABvPfeezVew30aicibmAwmlOZVBR6NZWE9AMjlMrG/xTk6/t1OVA+caiQislNpvh7mmKOxLKw3M69nqywzoryUubyI6oqBFxGRnYob0R6Nt7Jc51XClBJEdcbAi4jITpY5vIIayRuNZpaBZnEuAy+iumLgRURkJ8vkoY0llYSZ5dRq0TXm8iKqKwZeRER20maXip81kQEubInzBTe7OeJVlM3Ai6iuGpTf4f/+7/9w4MAB8edz584BAMaOHVutrPkcEZG3MAccMlnjG/EKbnYz0Cy6VlpLSSKy1KDA69y5czYDqh07dtgsL5PJGlIdEZHbEARBDDgCI9RQKBvXBIJvoA98A31QXlLJES+ierA78MrIyJCyHUREHqWsqAKVZUYAjW+a0UwTGYDr5wpRmq+HodwIpa/C1U0icnt2B16tWrWSsh1ERB6l6OrN6TXL9U6NSXCkP66fKwRQtcC+SUyQaxtE5AE8bg8fnU6HNWvWIC0tDcXFxYiJicHkyZMxfPjw215bUFCApKQk7N+/H3q9Hu3bt0d8fDx69+5dreyRI0eQkpKCc+fOwc/PD/3798fTTz+N0NBQsczVq1fx6KOP2qxr8eLFdWoTEXkmyzf5ghvpiFdwpMUC+2ulDLyI6sCuwGv69Ol2VSaTyZCSkmLXtWaLFi1Ceno6Zs+ejejoaOzatQuvv/46TCYTRo4cWeN1FRUVmDt3LkpKSvD8888jNDQUmzZtwvz585GYmIjY2Fix7LFjx7BgwQL0798fy5cvR0FBAVavXo25c+ciOTkZKpXK6t4TJkzAiBEjrI61bNmyQf0kIvemtVjXpIlsnCNellOsWq7zIqoTuwKvdevW2Twuk8ls7tllPt7QwGv//v04cuQIEhISxECnV69eyM7ORlJSEoYNGwaFwvYag61btyIjIwOrVq1Ct27dAAA9e/bE9OnTkZSUhNWrV4tlV61ahejoaCxdulTc2DsqKgrPPvsstm3bhgcffNDq3k2bNkXXrl3t7hcReZ4ii1QSjXbEyyqlBN9sJKoLu17DycjIsPpz/vx5jBs3DmFhYXjjjTewZ88enDp1Cnv27MHSpUsRFhaG+++/H2fPnm1QY/fu3Qu1Wo0hQ4ZYHR87dixyc3Nx8uTJWq+NiYkRgy4AUCqVGDVqFE6dOoWcnBwAQE5ODtLT0zFq1Cgx6AKA7t27Izo6Gj///HOD+kBE3sE81SiTyxpd1nozy4CTSVSJ6sauEa9bF9avWLECBw8exB9//IGoqCjxeMeOHTFo0CBMmzYNPXv2xFdffYWFCxfa3diMjAy0atXKKiACgHbt2onnu3fvbvPaCxcuoEePHtWOW14bEREhvq1pPn5r2T///LPa8Q0bNiA5ORkKhQJ33HEHJk2ahIEDB9bal9zcXOTl5Yk/Z2Zm1lqeiNyHIAjiCE9QhBryRpZKwsw3wAd+QT7QF1daJZMloppJsrg+JSUFEydOtAq6LLVo0QITJ05EcnJygwIvrVaL5s2bVzseFFS1oLOoqKjGa4uKisRytV2r1WoBAMHBwTbLWtbh4+OD+++/H3369EFYWBiuXbuGjRs34pVXXsHChQsxbty4GtuzZcuWGqdsici9lWkrUKmvSiXRWN9oNAtuFgB9cSF0+eVMKUFUB5IEXpcuXYKfn1+tZfz8/HDp0qUG19WQJKy1XXvruZrKWh4PDw/HggULrM4PHToUs2fPxurVqzF69Ohqo3Nm48ePx4ABA8SfMzMzsWzZstv2gYhcj+u7bmJKCaL6kWR8vGXLlti0aRP0er3N8zqdDps2bWrwm34ajUYckbJUXFwMwPYolVlwcLDNETHzteaRL41GAwA11mNr1MySUqnEsGHDoNVqaw00w8PD0bFjR/EP86IReQ7LTO3BjfSNRjPrNxs53Uh0O5IEXvHx8bhw4QIGDBiAzZs3i2uX8vLy8M0332DgwIG4ePEiZs6c2aB62rZti8zMTBgMBqvjFy5cAAC0adOm1mvPnz9f7bj5WNu2ba3uYb7nrfXUVoeZ+c1Oubxxrvsg8nZWm2M39qnGSL7ZSFQfkkQGCxYswLRp03D06FE8/PDDaNq0KXx8fNC0aVNMmDABx44dw5NPPlltWq6+4uLiUFZWhp9++snq+I4dOxAeHo4uXbrUeO2gQYOQlZVl9eajwWDADz/8gC5duiA8PBwAEBERgc6dO+P777+H0WgUy544cQJZWVkYPHhwrW00GAxIS0uDRqNBixYt7OkmEbk5Jk+9KZi5vIjqRZI1XnK5HCkpKZg6dSo+/vhjHD9+HFqtFhqNBj169MDUqVNvG7DURb9+/dCnTx+sXLkSOp0OLVq0wI8//oiDBw9i0aJFYg6vFStWYOfOnfjss88QGRkJoCrlxKZNm5CQkIDZs2eLCVSzsrKQmJhoVc9TTz2FefPmISEhAQ899JCYQLVNmzYYM2aMWO6DDz6AwWBA9+7d0aRJE1y/fh1ff/01zp49i5dffrnGnGJE5NkKr1SN7MgUjTeVhJll8ljtVY54Ed2OpFsGDR48WJIAqzbLli1DcnIyUlJSxC2Dbt2ex2QywWg0WiVzValUSExMRFJSEt577z3o9Xp06NAB77zzjlXWeqAqserbb7+NtWvX4l//+pe4ZdAzzzxjlbW+TZs22LJlC3bt2oXS0lL4+/ujc+fO+M9//oO7777bod8DEbmGyWiC9moJgKr1TY01lYSZyt8H/k18ocsvR+GlEjFZNhHZJhNspZqvg9TUVIwbNw4RERFSt6lROn36NGbOnInk5GR07NjR1c0hohpor5biy39WJVJuc3ckhs/t6eIWud72Nw/h8p9Va3sfSxoGf42vi1tE5L7s/qfajBkz0Lx5c8TFxeHdd99tcFZ6IiJPUHCpRPwc0jLQhS1xH6Etb77tXWjx/RBRdXYHXvv27cP8+fORn5+PBQsWoFOnTujcuTNeeeUVHDhwQMo2EhG5jYLLxeLnUAZeAICQFje/hwIGXkS1sjvw6tevH958802cOHECZ8+exVtvvYWIiAi8/fbbGDBgAKKiojB79mxs27YN5eXlUraZiMhlLEd0LAOOxszyeyi8zMCLqDaSrApt164d5s+fj59//hnXrl3DmjVr0LdvX3z66ae4//77ER4ejgkTJuCTTz5Bfn6+FFUSEbmEObCQyWVWb/Q1ZqGWI14MvIhqJfnrOGFhYZg2bRq++eYb5ObmYtOmTZg4cSJ+/fVXPPHEE2jWrBmGDBkidbVERA5nMgliKongZv5Q+DBlDAD4BvrAP6RqQX3hpeLblCZq3CRNJ3ErPz8/jB8/HuPHj4cgCNi3bx82b96MLVu2OLJaIiKHKMnRwVhpAsCF9bcKaREIXWE59MWVKCsqhzqYbzYS2eK0BDQymQwDBgzA22+/jfT0dGdVS0QkGcuF46Fc32XFMhDlOi+imtk94vXMM8/U+xqZTIYPP/zQ3iqJiFzKMqDgG43WQm95szGqc5gLW0PkvuwOvD766KM6l7XMYszAi4g8VQHfaKyRZSDKXF5ENbM78EpLS6tTuaysLCxduhTnz5/nNhJE5NHENxplgCaqcW+OfasQvtlIVCd2B16325OxoKAAy5cvx4cffgi9Xo/+/fvjrbfesrc6IiKXEizeaAxq6g+lim80WvILUsEvWAV9UQWTqBLVQvLF9Xq9HitWrEC7du3w7rvvonXr1ti4cSN+/fVXDBw4UOrqiIicQptdCkO5EQAQGhN0m9KNU5Mb34u+qAK6Ar2LW0PkniQLvARBwJo1a9ChQwe88sor8Pf3x3//+1/89ddfePDBB6WqhojIJfIuFomfw1sHu7Al7ivM4nvJtfi+iOgmSQKvb775Bl27dsXs2bNRUlKC5cuX49y5c4iPj4dc7rSMFUREDpPLwOu2LL+XPAZeRDY1KIHqL7/8gpdeegkHDhyASqXCiy++iFdffRWhoaFStY+IyC3kZdwMJMIYeNnEES+i27M78Bo/fjy2bt0KuVyOJ554AkuXLkXLli2lbBsRkVsQBEEcwVGH+MI/1M/FLXJPmsgAKH0VMJQbOeJFVAO7A6/vvvsOMpkMMTExyM7OxqxZs257jUwmw9atW+2tkojIJUpy9SgvrQQAhLXiaFdNZHIZwloF49qZApTklEFfUgG/QJWrm0XkVho01SgIAjIyMpCRkVGn8szjRUSeKO+iVvwc3oaBV23CWlcFXgCQn1mM5l2ZwZ7Ikt2BV12DLSIiT2c5bcb1XbWzXGCfm6Fl4EV0C7sDr1atWknZDiIit8U3GusujG82EtWKuR6IiG7DHECo/JUIjFC7uDXuLaRlIOTKqmUlfLORqDq7RrymT59uV2UymQwpKSl2XUtE5Aq6wnLoCsoBVI3mcK1q7RRKOUJbBiHvYhG0V0tRqTfAx69By4mJvIpdT8O6detsHpfJZBAEocbjDLyIyNPkXri5sJ7ru+omvE1w1SihUDVaGNmpiaubROQ27JpqNL/JaP5z/vx5jBs3DmFhYXjjjTewZ88enDp1Cnv27MHSpUsRFhaG+++/H2fPnpW6/UREDmV+Qw8AmnUIcV1DPEjT9iHiZ8vvj4jsHPG6dWH9ihUrcPDgQfzxxx+IiooSj3fs2BGDBg3CtGnT0LNnT3z11VdYuHBhw1pMROREVoHXHdyVoy4sv6fs0wXo4cK2ELkbSRbXp6SkYOLEiVZBl6UWLVpg4sSJSE5OlqI6IiKnMBpMyDlfNdUYFKFmxvo60jQPgG+gDwDg+tlCCKbqS1CIGitJAq9Lly7Bz6/2v5D8/Pxw6dIlKaojInKKvAwtjJUmAECzjhztqiuZTCaOepWXVKLwaqmLW0TkPiQJvFq2bIlNmzZBr9fbPK/T6bBp0ybu5UhEHiX7TKH4mdOM9dPsjhDxM9d5Ed0kSeAVHx+PCxcuYMCAAdi8eTPy8vIAAHl5efjmm28wcOBAXLx4ETNnzpSiOiIip7jO9V12s/y+rp1m4EVkJklylQULFuDMmTNITU3Fww8/DACQy+UwmaqG6AVBwLRp07BgwQIpqiMicjhBEMSRGpW/EqEtA13cIs8S3lYDuVIGk0HgiBeRBUkCL7lcjpSUFEydOhUff/wxjh8/Dq1WC41Ggx49emDq1KkYPHiwFFURETlF8XUdyrQVAICmHUIgkzNxan0oVQqEt9Hg+tlCFGXrUKYth1rj6+pmEbmcpOmEBw8ezACLiLzCtdOF4mdOM9qn2R2huH62EABw7UwhWt/VzLUNInID3KuRiMiGKyfyxM98o9E+kRbfm+X3SdSYMfAiIrqFYBJw6XgOAEDpq2DGejtFdWkCmaJqitb8fRI1dgy8iIhukZ9VLK7viurSBAofhYtb5JlU/j5i0FqUrUPRNZ1rG0TkBhh4ERHdwnJ0JrpHhAtb4vla3nnz++OoFxEDLyKiai4dzxU/t7gz3IUt8Xwte9z8/iy/V6LGioEXEZGFijIDsm8k/Axu5g9NZICLW+TZwloFwy9YBQC4eiIPRoPJxS0ici0GXkREFq6eyINgrNrUmaNdDSeTy9DyxvdYqTcymSo1egy8iIgsWE6HtWTgJQnL7/HSH5xupMaNgRcR0Q0mk4DMI9cAAHKlDM27hrm4Rd6hxZ3hwI3E/5lHrkEQBNc2iMiFGHgREd2QfSofusJyAEDLHhHw8ZN0c49GSx3si6jOTQAA2qulyLtY5OIWEbkOAy8iohsu7L8qfm7XP8qFLfE+lt/neYvvmaixYeBFRATAZDAh41A2gKps9TG9mrq4Rd6l9V2RYhb7jANXIZg43UiNEwMvIiIAl//KQ3lJJQAgpmdTTjNKzC9YhRbdqhbZl+Tqcf1coWsbROQiDLyIiACc33dF/NzuHk4zOoLl93p+H6cbqXFi4EVEjV5FmUF8m1Hlr7TKtk7SadW7KRQ+Vf/ZuXDgKoyVRhe3iMj5GHgRUaN39udLqNRXBQFt+kZxU2wHUfn7oFXvZgAAfVEFLuzPdnGLiJyPgRcRNWqCScCJnZniz13vbeXC1ni/Lhbf7187LjKnFzU6DLyIqFG79EcOirJ1AICoLk3QJCbIxS3ybs3uCEF4m2AAQN7FIlw7U+jaBhE5GQMvImrU/tpxc7Sr2+jWrmtIIyGTydDV4ns+seOiy9pC5AoMvIio0crLKsLlP6v2DgyKUCOaubucom2/SKg1KgDAxcPXUHSt1MUtInIeBl5E1Ggd3nBa/Nx1dGvI5TIXtqbxUPgo0HlkDICqNXaHvzjj4hYROQ8DLyJqlC79mYtLx6tGuwLD/dBpeLSLW9S4dBvdGn7BVaNeGQeymVCVGg0GXkTU6JhMAg5tSBd/7jPxDihVTCHhTCp/H/Sa0F78+eCn6XzDkRoFBl5E1OicTvsb+ZnFAICw1sFod09zF7eoceo0NBqaqAAAwLXTBVablBN5KwZeRNSoaK+W4uD/3Rzt6ju5E2Rc2+UScqUcd0/qKP7869oTKMkrc2GLiByPgRcRNRpGgwlpHxyDobwqS32nYdFo3jXMxa1q3GJ6N0XbflV7OFboDNiz6jhMJk45kvdi4EVEjYIgCDj4aTpyM4oAAJqoAPR9vJOLW0UymQwDZnRFYLgfACD7VD5+/+qsi1tF5DgMvIioUTi66RxO3tgaSK6QYehzPeDjp3RxqwgAfAN8MOSZHpDdmPE99s15/LU9w7WNInIQBl5E5NUEQcDx7y7g96/OiccGzuiG8DYaF7aKbhXZqQn6Pt5Z/PnAJ+k4tSvLhS0icgwGXkTktQwVRuxN/guHLBKl9pvSCXcMaenCVlFNuo1pbZVi4te1J7Dv45MwGUwubBWRtDjOTkReKeeCFr+s+Qt5F4vEY70f6YBuY9q4sFV0Oz0fbo9KvRF/bq2aajy5MxO5GVoMnN6NG5iTV/C4wEun02HNmjVIS0tDcXExYmJiMHnyZAwfPvy21xYUFCApKQn79++HXq9H+/btER8fj969e1cre+TIEaSkpODcuXPw8/ND//798fTTTyM0NNSqnMFgwCeffILt27cjLy8PUVFReOihhzBhwgTJ+kxEdae9Woo/vr2AMz9dAm68HKdQyRE3szvaD2C+Lncnk8nQd3InaKICsG/dCZgMAq6fKcSml39BpxExuHNcGwRF+Lu6mUR287jAa9GiRUhPT8fs2bMRHR2NXbt24fXXX4fJZMLIkSNrvK6iogJz585FSUkJnn/+eYSGhmLTpk2YP38+EhMTERsbK5Y9duwYFixYgP79+2P58uUoKCjA6tWrMXfuXCQnJ0OlUollV65cie+//x4zZsxAp06dcOjQIbz//vvQ6XSYMmWKI78KIrpBX1yBv4/l4Py+K7j0R67VOU3zAAx7PhZhrYJd1DqyR6dh0WgSHYi0D/9A8fUyCAJw6ocsnNqVhZheTdGufxRa9oiAb4CPq5tKVC8eFXjt378fR44cQUJCAkaMGAEA6NWrF7Kzs5GUlIRhw4ZBobC97cfWrVuRkZGBVatWoVu3bgCAnj17Yvr06UhKSsLq1avFsqtWrUJ0dDSWLl0KpbLqK4qKisKzzz6Lbdu24cEHHwQAZGRkYOvWrZg5cyYmTZok3rOoqAjr16/HAw88gOBg/mVPJBVjpRFlRRUovq6D9qoOeReLkHO+EHkXi3DrbjM+aiV6TWiPrqNaQa7kclZP1LRDKCa8HYe/tl3Esc3nq/KvCUDWb9eR9dt1yBQyhLcKRkT7EDSJCUJghBpB4WoEhvtB4cMtoMg9eVTgtXfvXqjVagwZMsTq+NixY7F06VKcPHkS3bt3r/HamJgYMegCAKVSiVGjRuG///0vcnJyEBERgZycHKSnp2PWrFli0AUA3bt3R3R0NH7++Wcx8Nq7dy8EQcCYMWOs6hozZgy+/fZbHDx4sNZROGf4a8dFGCuMtZap8/ZodSgn1K2Qc+ur672kzNlYx5tJWWed7iVhhXW/1e0LCgJgqjTBeOOPodJY9bnCiEq9EfqiCpQVVaCyzHDbewWGq9FlZAzuGNISfkGq25Yn96ZUKRD7YDt0HNoS6bv/xqldWdAVlAMABKOAnAta5FzQVrtOrVFBFeADlVoJlb8SPmollCoF5AoZ5Ao55Ep51Wdl1c/mVBY3P9zyo8z8PzKrn2s6LuNmCG7Jv4kfOgxs4dI2eFTglZGRgVatWlkFRADQrl078XxNgdeFCxfQo0ePasctr42IiEBGRobV8VvL/vnnn1btCQkJQVhYWLVy5vM1yc3NRV5envhzZmZmjWUb4timc9AXVzrk3kRuQQaEtghEyx4RaNW7KZreEQo5twDyOmqNL3o+1B49xrdFdnoBsn6/jr//yIH2SqnN8mXaCpRpK5zcSnJ3Te8IYeBVH1qtFs2bV18cGxRU9aZLUVFRtXNmRUVFYrnartVqq/7lZGuKMCgoyKoOrVZrs5xarYaPj494L1u2bNmCdevW1XieiG5S+SvhF6yCOtgXfsEqBIb7QRMVgJDmgQhvEwyVP9f5NBZyhRzNu4ahedcw9JvSGeWllci9oEXRdR1KcspQnFOGkpwylObrUVFmqNMoKZEzeVTgBVS98eKIa289V1PZ+tRfW9nx48djwIAB4s+ZmZlYtmxZne9dV4Of7lG3HDgSDhDU6TuqY311KlbX34l0zapbwTq2q259rNOtGvR82FNn3au7fUGFjxwKlRxKH0XV5xt/lCoF12hRjXwDfNCiezhqGsMQTAIq9QZU6AwwVppgMppgMghV/2sUxJ8F4Ob8ufX/VH24cc7qGKoS9FpXKPGyBZKUb6Dr/5HmUYGXRqOxOYpUXFwMwPYolVlwcLDNETHzteaRL42mKpt1TfVYjpppNBqcO3euWrmysjJUVlbW2p7w8HCEh4fXeF4q0bERDq+DiMhdyeQyqPx9OCpKbsOj/hnZtm1bZGZmwmCwHjq+cOECAKBNm5oTI7Zt2xbnz5+vdtx8rG3btlb3MN/z1nos62jbti0KCwut1mrVtT1ERETU+HhU4BUXF4eysjL89NNPVsd37NiB8PBwdOnSpcZrBw0ahKysLJw8eVI8ZjAY8MMPP6BLly7i6FNERAQ6d+6M77//HkbjzbcBT5w4gaysLAwePFg8NnDgQMhkMuzYscOqru3bt8PX1xd9+/ZtUH+JiIjIu3jUVGO/fv3Qp08frFy5EjqdDi1atMCPP/6IgwcPYtGiRWIOrxUrVmDnzp347LPPEBkZCaAq5cSmTZuQkJCA2bNniwlUs7KykJiYaFXPU089hXnz5iEhIQEPPfSQmEC1TZs2Vqkj2rRpg/vuuw+pqamQy+Xo3LkzDh8+jG+//Rbx8fHM4UVERERWZEK1lYHuTafTITk52WrLoMcff9xqy6Dly5djx44d+OKLLxAVFSUez8/Pt9oyqEOHDpgxYwb69OlTrZ7Dhw9j7dq1OHv2rLhl0DPPPGNzy6D169dj+/btyM/PR2RkJB5++OF6bxl0+vRpzJw5E8nJyejYsWM9vxUiIiLyBB4XeHkrBl5ERETez6PWeBERERF5MgZeRERERE7CwIuIiIjISRh4ERERETkJAy8iIiIiJ2HgRUREROQkDLyIiIiInISBFxEREZGTeNSWQd6svLwcAJCZmenilhAREVF9tWrVCn5+frctx8DLTWRnZwMAli1b5uKWEBERUX3VdecZbhnkJgoLC3Ho0CFERUVBpVJJdt/MzEwsW7YMixYtQqtWrSS7rzvx9j56e/8A7+8j++f5vL2P7F/DccTLw4SEhGDUqFEOu3+rVq28fg9Ib++jt/cP8P4+sn+ez9v7yP45HhfXExERETkJAy8iIiIiJ2Hg5eXCwsLw5JNPIiwszNVNcRhv76O39w/w/j6yf57P2/vI/jkPF9cTEREROQlHvIiIiIichIEXERERkZMw8CIiIiJyEubxciNHjx7FCy+8YPNcUlISunbtKv58+vRpfPTRRzh58iQUCgV69uyJZ599Fs2bN6927ddff41Nmzbh6tWrCAsLw5gxYzBlyhQolbf/9RsMBnzyySfYvn078vLyEBUVhYceeggTJkxwef/+/vtvbNmyBUePHsWVK1cgk8nQqlUrTJw4EUOGDLlte65evYpHH33U5rnFixdj+PDh9esgHPM7HDRokM37zZo1C48//vht2+TOv8Pt27fjzTffrLG+2/VR6t9hXft3/PhxbN++HWfPnkVGRgYqKyvxxRdfICoqyua17vIMOqKP7vYcOuJ36InPYF37527PIFC3PhqNRnz11Vc4fPgwMjIyUFRUhGbNmmHgwIGYPHkygoKCql3rLs8hAy83NGvWLPTs2dPqWJs2bcTPmZmZeOGFF9C+fXssWbIEFRUVWLt2LZ577jmsXbsWISEhYtn169cjJSUFkydPxl133YX09HSsWbMGubm5WLBgwW3bsnLlSnz//feYMWMGOnXqhEOHDuH999+HTqfDlClTXNq/Q4cOYf/+/bj33nvRqVMnGI1G7N69GwkJCZg+fTqefPLJOrVnwoQJGDFihNWxli1b2tU3qftoNmTIkGp/uTVr1qxObXHn32H//v2RlJRU7f4pKSk4cuRIjf/Bu5XUv8Pb9e+3337Db7/9hg4dOiAgIABHjx6t8V7u+AxK2Ud3fQ6l/B0CnvcM1rV/7voMArX3sby8HKmpqRg+fDjGjRsHjUaDM2fOYP369di3bx+Sk5Ph6+srXudWz6FAbuP3338X4uLihLS0tFrLJSQkCOPGjRNKSkrEY1evXhWGDh0qrFq1SjxWWFgoDB8+XHj77betrl+/fr0waNAgISMjo9Z6Lly4IAwaNEj45JNPrI6//fbbwogRIwStVlu3jt0gdf8KCgoEk8lU7fqFCxcKI0eOFMrLy2ut58qVK0JcXJywYcOGevWjNlL3URAEIS4uTli5cqVd7XH336EtOp1OGDVqlPDss8/etj1S/w7r2j+j0Sh+3rBhgxAXFydcuXKlWjl3ewYFQfo+uttzKHX/BMEzn8H69O9WrnwGBaFufTQYDEJhYWG142lpaUJcXJywc+dO8Zi7PYdc4+VhDAYD9u3bh8GDByMgIEA8HhkZiZ49e2Lv3r3isYMHD6KiogJjx461useYMWMgCIJVWVv27t0LQRAwZsyYateXl5fj4MGDEvTIWn36FxISAplMVu0enTt3hl6vR1FRkeTtk0J9+thQ7v47tGX37t0oKyvDfffdJ3nbpCKX1+2vTk98Bs3q2kdPfQ7r2r+GctXvsCH984RnUKFQQKPRVDveuXNnAMD169fFY+72HDLwckOJiYkYOnQoRo8ejX/+8584fvy4eO7KlSsoLy9Hu3btql3Xrl07XL58GeXl5QCAjIwMAEDbtm2tyoWHh0Oj0Yjna5KRkYGQkJBqCefMdd/u+ppI1b+aHD16FCEhIQgNDa1TezZs2IBhw4Zh5MiRePbZZ/HLL7/Ur0M2SN3HXbt2YcSIERg+fDji4+Oxbdu2OrXDE3+HW7duRUBAAIYOHVrn9kj9O6ytf/Xhrs8gIF0fa+Lq51Dq/nnSM9hQ7vAMAvb18ffffwcAtG7dWjzmbs8h13i5kYCAADzyyCPo2bMngoODcfnyZXz22Wd44YUX8NZbb+Huu++GVqsFAAQHB1e7Pjg4GIIgoLi4GL6+vigqKoJKpYJarbZZ1nyvmmi1Wpv1qNVq+Pj43PZ6R/fPlu+++w5Hjx7FnDlzoFAoam2Pj48P7r//fvTp0wdhYWG4du0aNm7ciFdeeQULFy7EuHHj6tU/R/VxxIgR6N+/P5o2bYqCggJs3boVK1aswJUrVxAfH19rezztd5iZmYm//voL48ePh5+f323bI/XvsC79qw93ewYB6ftoiyufQ0f0z9OewYZw9TMI2N/HnJwcrF69Gp06dcI999wjHne355CBlxu54447cMcdd4g/9+jRA3FxcXjyySeRlJRU5wfK1rB/Q8pJdb2j+3fgwAEkJiZiyJAhdXrTJDw8vNqiyqFDh2L27NlYvXo1Ro8eXae3XSw5oo8JCQlW54YMGYJ//etf+PTTT/HII49UW4hfH+72O9y6dSsA1Pkva6l/h1L1r66c/QwCju+jq59DR/TPG5/Bmrj6GQTs62NRUREWLlwIQRCwZMmSek21Ovs55FSjmwsKCsI999yD8+fPo7y8XJzTtrVuoqioCDKZDIGBgQCqIvmKigro9XqbZW1F8JY0Go3NesrKylBZWXnb6+uiIf2zdOjQISxatAh9+vTBa6+9ZveDpFQqMWzYMGi1Wly6dMmue9xKqj5aGjlyJIxGI9LT02st50m/Q4PBgJ07d6J9+/bo1KmT3e2R+nd4a//qwxOeQaBhfbTkrs+hVP2z5M7PoL3c9RkEau9jcXEx5s2bh9zcXKxcubJaSh53ew4ZeHkAwWI7zebNm8PX1xcXLlyoVu7ChQto0aKFOIVjns++tWxeXh60Wq3Vq8e2tG3bFoWFhcjLy6tWD4DbXl9X9vbP7NChQ3jllVcQGxuLN954Az4+PpK0R8rFtw3tY01u10ZP+R0CwL59+1BQUCDJgl6pf4eCnVvaesozCNjfRzN3fw4b2r+auOMzaC93fgYt72mpuLgYL774Iq5evYp3333X5tpSd3sOGXi5ueLiYuzfvx8dOnSAr68vlEol7rnnHvz888/Q6XRiuWvXruHo0aNWOVf69u0LlUqF7du3W91z+/btkMlkiIuLq7XugQMHQiaTYceOHdWu9/X1Rd++fV3aP+DmX/Z33nkn/v3vf0OlUjWoPQaDAWlpadBoNGjRokWD7mXW0D7asnPnTiiVSqvheFs84XdotnXrVqhUKowaNapB7ZH6d3hr/+rDE55BoGF9BNz/OWxo/2xx52fQXu76DAK2+2gOuq5cuYJ33323xt+Fuz2HXOPlRpYuXYqmTZuiU6dO0Gg0uHTpEr744gvk5+fj5ZdfFstNnz4ds2bNwksvvYTJkyejoqICKSkp0Gg0+Mc//iGWCw4OxtSpU5GSkoLg4GDcddddOHXqFNatW4dx48ZZvfWxY8cOvPXWW3jppZcwevRoAFVR/H333YfU1FTI5XJ07twZhw8fxrfffov4+Ph6D69K3b/jx4/j1VdfRZMmTfD444/j3LlzVvW1bt1aTGdgq38ffPABDAYDunfvjiZNmuD69ev4+uuvcfbsWbz88su3XRTsjD5+9tlnuHjxInr37o2IiAhxYe/hw4cxbdo0q7Ulnvg7NMvNzcWhQ4cwdOhQmxmna+qf1L/DuvavsLAQx44dA3DzX70HDx5ESEgIQkJCEBsbC8D9nkFH9NHdnkOp++epz2Bd+2fmLs9gXftYXl6Of/7znzh79iyef/55GI1GnDhxQrxHSEiIGPS523PIwMuNtG3bFmlpadiyZQvKysoQFBSE7t2749VXXxVzkwBAq1at8P777+Ojjz5CQkICFAoFevXqhWeeeabaIs+pU6fC398fmzZtwueff44mTZrgsccew9SpU63KCYIAo9FYbSh33rx5CA8Px8aNG5Gfn4/IyEjMmTPHrm0SpO7fkSNHUF5ejuzsbMydO7dafe+9956Y9dhW/9q0aYMtW7Zg165dKC0thb+/Pzp37oz//Oc/di9QlbqPMTEx+PXXX7F//37xTcD27dvb3IrDE3+HZtu3b4fRaKx1Qa8zfod17V9GRka1BdcrV64EAMTGxuL9998Xj7vTM+iIPrrbcyh1/zz1GazP/0cB93kG69rH/Px8cX3drX0BgNGjR+OVV14Rf3an51AmOGrim4iIiIiscI0XERERkZMw8CIiIiJyEgZeRERERE7CwIuIiIjISRh4ERERETkJAy8iIiIiJ2HgRUREROQkDLyIiIiInISBFxGRG7p48SJkMpn4JzIy0ur8kiVLIJPJsGfPHtc08BaPP/64VXvXrVvn6iYRuSUGXkTkVLcGFLb+3LqPXGPWo0cPLF68GPPnz3d4XatXr4ZMJsNTTz1127K9e/eGTCbD77//DgB4+OGHsXjxYjzwwAOObiaRR+NejUTkEu3atcPjjz9u89ytozuNWWxsLJYsWeKUuiZNmoR58+bh888/R2JiItRqtc1yx48fx++//47Y2Fj06tULQFXg9fDDD2PdunXYvHmzU9pL5IkYeBGRS7Rv395pAQXVTXBwMB555BGsX78eGzduxOTJk22WS0lJAQDMmDHDmc0j8gqcaiQityeTyTBkyBDk5ORg+vTpaNq0KdRqNfr161fjGqfi4mIsXrwYXbt2hVqtRkhICEaPHo1ffvmlWtkhQ4ZAJpOhvLwcCQkJaN++PXx8fKwCw40bN6JPnz5Qq9Vo1qwZZs6ciYKCArRu3RqtW7cWyz3xxBOQyWQ4fPiwzXYtXLgQMpkMmzZtashXUqPjx4+jefPmCA8Px8GDB8XjGRkZiI+PR0xMDHx9fREVFYUnn3wSmZmZVtebg6nU1FSb96+oqMCnn34KX1/fGgMzIqoZR7yIyCMUFhZiwIABCA4OxuTJk3H9+nV88cUXuPfee/Hbb7+hW7duYtn8/HwMGjQIJ06cQFxcHO69915otVps3rwZQ4cOxZdffokHH3ywWh0PP/ww/vjjD9x7771o0qQJ2rZtCwBYu3YtZsyYgZCQEEydOhUajQbbtm3DyJEjUVlZCR8fH/Ees2fPxvr165GcnIy77rrL6v6VlZVYv349IiMjcf/990v+He3duxf3338/goODsXv3bnTq1AkAcPDgQdx7770oLS3F/fffj/bt2+PixYv49NNPsX37duzfv1/s66BBg9ChQwfs3r0bFy9etAoqAWDLli3Iy8vDpEmTEBoaKnkfiLyeQETkRBkZGQIAoV27dsLixYtt/tm+fbvVNQAEAMIzzzwjGI1G8fiaNWsEAMLs2bOtyj/22GMCAGHt2rVWx7Ozs4Xo6GghIiJCKCsrE48PHjxYACDExsYKeXl5VtcUFBQIgYGBQlBQkHD+/HnxeGVlpTBixAgBgNCqVSura7p16yYEBQUJJSUlVsc3btwoABBeeumlOn9PTzzxhM3zixcvFgAIaWlpgiAIwjfffCP4+fkJXbp0Ef7++2+xXEVFhdC6dWshKChIOHbsmNU99u7dKygUCmHcuHFWx998800BgLBkyZJq9Y4ZM0YAIOzatctmu1JTUwUAQmpq6m37SNQYMfAiIqcyBxS1/XnhhResrgEgBAQECMXFxVbHKysrBaVSKfTq1Us8lpOTIygUCmH48OE263///fcFAMK3334rHjMHXps3b65Wft26dQIA4cUXX6x2bv/+/TYDL3MdKSkpVsfHjh0ryGQy4ezZszbbZqk+gdeaNWsEhUIh9O/fv1rgaA723njjDZv3efjhhwW5XC5otVrx2JUrVwSFQiG0bt1aMJlM4vHLly/bPG6JgRdR7TjVSEQuce+992LHjh11Lt+hQwcEBgZaHVMqlWjWrBkKCwvFY4cPH4bRaIRer7e5eP/s2bMAgPT0dIwbN87q3N13312t/B9//AEAuOeee6qdu/vuu6FUVv9rdMqUKXjppZewZs0aTJ8+HQBw+fJl7Ny5E4MHD0b79u1r72w9JCYmYsuWLRg7diy+/PJL+Pv7W50/cOAAgKr+2vo+srOzYTKZcObMGfTp0wcAEBUVhTFjxuC7775DWloahg0bBgBYt24djEYjpk2bBplMJlkfiBoTBl5E5BE0Go3N40qlEkajUfw5Pz8fAPDrr7/i119/rfF+paWl1Y41a9as2rGioiIAQERERLVzcrkc4eHh1Y6HhIRg4sSJ+Pjjj3Hy5El06dIFqampMBqNmDlzZo1tssfevXsBAKNHj64WdAE3v49PP/201vvc+n3MmDED3333HVJTU60CL7lcjieffFKClhM1TnyrkYi8SnBwMADgn//8J4Sq5RQ2/yxevLjatbZGccz3y8nJqXbOZDIhNzfXZjtmz54NAFizZg0EQUBqaiqaNGmChx9+2O6+2ZKSkoJevXrhhRdewKpVq6qdN7f/22+/rfX7GDx4sNV148aNQ7NmzfD111+jqKgIe/fuxdmzZzFy5EjExMRI2geixoSBFxF5lbvuugsymQz79++X5H49evQAAOzbt6/auUOHDsFgMNi8rn///ujevTs++eQTbN++HRcuXMDjjz8OPz8/SdplFhoail27dqFXr1549tln8eGHH1qd79u3LwDU+/tQKpWYOnUqysrK8Pnnn2Pt2rUAmLuLqKEYeBGRV4mMjMTEiROxb98+vPPOOxAEoVqZgwcPQqfT1el+DzzwAAIDA7FmzRpkZGSIxw0GA1577bVar501axZyc3PF6cX4+Ph69KTuzMFXnz598Nxzz+H/+//+P6v2x8TEYOXKlfj555+rXVtZWWkztxlwM8hatWoVvvzyS4SFhXFLIKIG4hovInKJc+fO1Zq5viFZ7VetWoXTp09j4cKF+OSTT9C/f39oNBr8/fff+O2333D27FlcvXrV5pqoW4WEhGDlypWYNWsWevXqhUcffVTM4+Xr64vmzZtDLrf9b1jzIvsrV66gb9++6N69u919qks7f/jhB4waNQpz5syBIAiYM2cOfH198dVXX2HMmDEYPHgwhg8fLuY8y8rKwt69exEWFob09PRq9+zYsSMGDBggrpWbOXMmVCqVw/pA1Bgw8CIilzh//jxef/31Gs83JPBq0qQJ9u3bhw8++ABffPEFPv30U5hMJkRGRqJHjx547bXXbC6Kr8nMmTMRGhqK5cuXY926ddBoNBg/fjzeeusttGrVCu3atbN5nUajwQMPPIDPPvtM8kX1tlgGXy+88AIEQcALL7yAu+66C3/88QfeeecdbNu2Db/88gt8fX3RokULPPjgg5g0aVKN95wxY4YYeJnf0CQi+8kEW+PwRER0W+fOnUOHDh0wceJEfPHFFzbLdO3aFVlZWbh69Wq1dBi1uXjxItq0aYMnnngC69atk6jFjrdu3TpMmzYNqampfPuRyAau8SIiuo2CggKUl5dbHSsrK8OLL74IADa3HwKAbdu24eTJk5gyZUq9gi5LH3/8MWQyGSIjI+263lkef/xxyGQyTJs2zdVNIXJrnGokIrqNn376CTNmzMCoUaMQExOD3NxccS/DYcOG4dFHH7Uqn5SUhL///hvJyclQq9VYuHBhvesMCQmxSnlhb+DmLA8//LBVYtjY2FjXNYbIjXGqkYjoNs6ePYvXXnsN+/btE/N5tW/fHo8++ijmz59fLUVE69atcenSJXTs2BFvvfVWtQz5RNR4MfAiIiIichKu8SIiIiJyEgZeRERERE7CwIuIiIjISRh4ERERETkJAy8iIiIiJ2HgRUREROQkDLyIiIiInISBFxEREZGT/P8dS6oUwHgCGQAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
    " ] @@ -1478,13 +1476,14 @@ "ax.plot(energy, flux, label = \"Best fit\")\n", "\n", "\n", - "plt.ylabel(\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", + "plt.ylabel(r\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", "plt.xlabel(\"Energy [keV]\", fontsize=14)\n", - "ax.legend()" + "ax.legend();" ] }, { "cell_type": "markdown", + "id": "19d5e7ff", "metadata": {}, "source": [ "Now let's compare the predicted counts to the injected counts:" @@ -1492,7 +1491,8 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 23, + "id": "92d6c1d5", "metadata": { "tags": [] }, @@ -1501,12 +1501,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Error: [2129.064008]\n" + "Error: [2129.06384372]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
    " ] @@ -1536,11 +1536,12 @@ "ax.legend()\n", "\n", "# Note: We are plotting the error, but it's very small:\n", - "print(\"Error: \" +str(np.sqrt(total_expectation.project('Em').todense().contents)))" + "print(f\"Error: {np.sqrt(total_expectation.project('Em').todense().contents)}\")" ] }, { "cell_type": "markdown", + "id": "a8c6f8b7", "metadata": {}, "source": [ "Let's also compare the projection onto Psichi:" @@ -1548,22 +1549,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 24, + "id": "ecb9bca0", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "Text(0.5, 1.0, 'injected counts')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
    " ] @@ -1573,7 +1565,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
    " ] @@ -1589,11 +1581,12 @@ "\n", "# injected src counts:\n", "ax,plot = gal_511.binned_data.slice[{'Em':0, 'Phi':5}].project('PsiChi').plot(ax_kw = {'coord':'G'})\n", - "plt.title(\"injected counts\")" + "plt.title(\"injected counts\");" ] }, { "cell_type": "markdown", + "id": "dd9f6c3d", "metadata": {}, "source": [ "Here is a summary of the results:\n", @@ -1609,6 +1602,7 @@ }, { "cell_type": "markdown", + "id": "20d322f1", "metadata": {}, "source": [ "## **********************************************************\n", @@ -1617,6 +1611,7 @@ }, { "cell_type": "markdown", + "id": "6da299ce", "metadata": {}, "source": [ "Define the point source.
    \n", @@ -1625,7 +1620,8 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 25, + "id": "dc85da2d", "metadata": {}, "outputs": [ { @@ -1633,7 +1629,7 @@ "output_type": "stream", "text": [ " * description: A Gaussian function\n", - " * formula: $ K \\frac{1}{\\sigma \\sqrt{2 \\pi}}\\exp{\\frac{(x-\\mu)^2}{2~(\\sigma)^2}} $\n", + " * formula: $ F \\frac{1}{\\sigma \\sqrt{2 \\pi}}\\exp{\\frac{(x-\\mu)^2}{2~(\\sigma)^2}} $\n", " * parameters:\n", " * F:\n", " * value: 0.01\n", @@ -1706,6 +1702,7 @@ }, { "cell_type": "markdown", + "id": "d1334d15", "metadata": {}, "source": [ "Redefine the first source.
    \n", @@ -1714,7 +1711,8 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 26, + "id": "083aebb2", "metadata": {}, "outputs": [ { @@ -1973,6 +1971,7 @@ }, { "cell_type": "markdown", + "id": "b6409c85", "metadata": {}, "source": [ "Setup the COSI 3ML plugin using two sources in the model:" @@ -1980,17 +1979,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 27, + "id": "11394acc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "... loading the pre-computed image response ...\n", - "--> done\n", - "CPU times: user 2min 10s, sys: 41.5 s, total: 2min 52s\n", - "Wall time: 3min 10s\n" + "CPU times: user 1min 44s, sys: 10.2 s, total: 1min 54s\n", + "Wall time: 1min 54s\n" ] } ], @@ -2020,6 +2018,7 @@ }, { "cell_type": "markdown", + "id": "8e3ebced", "metadata": {}, "source": [ "Display the model:" @@ -2027,7 +2026,8 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 28, + "id": "6fc90305", "metadata": {}, "outputs": [ { @@ -2164,6 +2164,7 @@ }, { "cell_type": "markdown", + "id": "0b3e274f", "metadata": {}, "source": [ "Before we perform the fit, let's first change the 3ML console logging level, in order to mimimize the amount of console output." @@ -2171,7 +2172,8 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 29, + "id": "d7254296", "metadata": {}, "outputs": [], "source": [ @@ -2182,6 +2184,7 @@ }, { "cell_type": "markdown", + "id": "4f2fd3f4", "metadata": {}, "source": [ "Perform the likelihood fit:" @@ -2189,7 +2192,8 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 30, + "id": "106b5f41", "metadata": { "scrolled": true, "tags": [] @@ -2251,12 +2255,12 @@ " \n", " gaussian.spectrum.main.Gaussian.F\n", " (4.6951 +/- 0.0025) x 10^-2\n", - " 1 / (cm2 s)\n", + " 1 / (s cm2)\n", " \n", " \n", " point_source.spectrum.main.Gaussian.F\n", - " (0.0 +/- 1.3) x 10^-9\n", - " 1 / (cm2 s)\n", + " (0.0 +/- 2.1) x 10^-9\n", + " 1 / (s cm2)\n", " \n", " \n", " background_cosi\n", @@ -2271,13 +2275,13 @@ " result \\\n", "parameter \n", "gaussian.spectrum.main.Gaussian.F (4.6951 +/- 0.0025) x 10^-2 \n", - "point_source.spectrum.main.Gaussian.F (0.0 +/- 1.3) x 10^-9 \n", + "point_source.spectrum.main.Gaussian.F (0.0 +/- 2.1) x 10^-9 \n", "background_cosi (9.32 +/- 0.05) x 10^-1 \n", "\n", " unit \n", "parameter \n", - "gaussian.spectrum.main.Gaussian.F 1 / (cm2 s) \n", - "point_source.spectrum.main.Gaussian.F 1 / (cm2 s) \n", + "gaussian.spectrum.main.Gaussian.F 1 / (s cm2) \n", + "point_source.spectrum.main.Gaussian.F 1 / (s cm2) \n", "background_cosi " ] }, @@ -2304,16 +2308,16 @@ { "data": { "text/html": [ - "
    \n", - "\n", - "\n", - "\n", + "
    1.00-0.01-0.40
    -0.011.00-0.03
    -0.40-0.031.00
    \n", + "\n", + "\n", + "\n", "
    1.000.01-0.40
    0.011.000.03
    -0.400.031.00
    " ], "text/plain": [ - " 1.00 -0.01 -0.40\n", - "-0.01 1.00 -0.03\n", - "-0.40 -0.03 1.00" + " 1.00 0.01 -0.40\n", + " 0.01 1.00 0.03\n", + "-0.40 0.03 1.00" ] }, "metadata": {}, @@ -2449,48 +2453,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7min 24s, sys: 3min 55s, total: 11min 20s\n", - "Wall time: 1min 46s\n" + "CPU times: user 1min 53s, sys: 946 ms, total: 1min 54s\n", + "Wall time: 20.6 s\n" ] - }, - { - "data": { - "text/plain": [ - "( value negative_error \\\n", - " gaussian.spectrum.main.Gaussian.F 4.695126e-02 -2.403110e-05 \n", - " point_source.spectrum.main.Gaussian.F 5.975791e-13 2.623492e-10 \n", - " background_cosi 9.320815e-01 -4.914467e-03 \n", - " \n", - " positive_error error \\\n", - " gaussian.spectrum.main.Gaussian.F 2.433950e-05 2.418530e-05 \n", - " point_source.spectrum.main.Gaussian.F 1.929678e-09 1.096013e-09 \n", - " background_cosi 4.582905e-03 4.748686e-03 \n", - " \n", - " unit \n", - " gaussian.spectrum.main.Gaussian.F 1 / (cm2 s) \n", - " point_source.spectrum.main.Gaussian.F 1 / (cm2 s) \n", - " background_cosi ,\n", - " -log(likelihood)\n", - " cosi -1.527559e+07\n", - " total -1.527559e+07)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ "%%time\n", "plugins = DataList(cosi) # If we had multiple instruments, we would do e.g. DataList(cosi, lat, hawc, ...)\n", "\n", - "like = JointLikelihood(model, plugins, verbose = True)\n", + "like = JointLikelihood(model, plugins, verbose = False)\n", "\n", - "like.fit()" + "like.fit();" ] }, { "cell_type": "markdown", + "id": "1f4b050f", "metadata": {}, "source": [ "We see that the normalization of the point source has gone to zero, and we essentially get the same results as the first fit. This is not entirely surprising, considering that the two components have a high degree of degeneracy, and the point source is subdominant. \n", @@ -2500,6 +2479,7 @@ }, { "cell_type": "markdown", + "id": "1e983de4", "metadata": {}, "source": [ "## *****************************************\n", @@ -2508,6 +2488,7 @@ }, { "cell_type": "markdown", + "id": "b50b0a63", "metadata": {}, "source": [ "## Read in the binned data\n", @@ -2516,7 +2497,8 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 31, + "id": "4b5c4ea0", "metadata": {}, "outputs": [], "source": [ @@ -2531,6 +2513,7 @@ }, { "cell_type": "markdown", + "id": "d806eec8", "metadata": {}, "source": [ "## Define source\n", @@ -2539,7 +2522,8 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 32, + "id": "6f06701e", "metadata": {}, "outputs": [], "source": [ @@ -2586,14 +2570,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 33, + "id": "a3bed0d3", "metadata": {}, "outputs": [], "source": [ "# Define Spatial Model Components\n", "MapNarrowBulge = Gaussian_on_sphere(lon0=359.75,lat0=-1.25, sigma = 2.5)\n", "MapBroadBulge = Gaussian_on_sphere(lon0 = 0, lat0 = 0, sigma = 8.7)\n", - "MapDisk = Wide_Asymm_Gaussian_on_sphere(lon0 = 0, lat0 = 0, a=90, e = 0.99944429,theta=0)\n", + "MapDisk = Asymm_Gaussian_on_sphere(lon0 = 0, lat0 = 0, e = 0.99944429,theta=0)\n", + "MapDisk.a.max_value = 90\n", + "MapDisk.a.value = 90\n", "\n", "# Fix fitting parameters (same for all models)\n", "for map in [MapNarrowBulge,MapBroadBulge]:\n", @@ -2604,20 +2591,22 @@ "MapDisk.lon0.free=False\n", "MapDisk.lat0.free=False\n", "MapDisk.a.free=False\n", - "MapDisk.e.free=True#False\n", + "MapDisk.e.free=True\n", "MapDisk.theta.free=False" ] }, { "cell_type": "markdown", + "id": "e298ccaa", "metadata": {}, "source": [ - "For the Wide_Asymm_Gaussian_on_sphere model, note that e is the eccentricity of the Gaussian ellipse, defined such that the scale height b of the disk is given by $b = a \\sqrt{(1-e^2)}$" + "For the Asymm_Gaussian_on_sphere model, note that e is the eccentricity of the Gaussian ellipse, defined such that the scale height b of the disk is given by $b = a \\sqrt{(1-e^2)}$" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 34, + "id": "229770ad", "metadata": {}, "outputs": [], "source": [ @@ -2636,7 +2625,8 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 35, + "id": "3613f683", "metadata": {}, "outputs": [ { @@ -2712,7 +2702,7 @@ "\n", "
  • value: 0.99944429
  • \n", "\n", - "
  • desc: Excentricity of Gaussian ellipse, e^2 = 1 - (b/a)^2, where b is the standard deviation of the Gaussian distribution (minor axis)
  • \n", + "
  • desc: Excentricity of Gaussian ellipse
  • \n", "\n", "
  • min_value: 0.0
  • \n", "\n", @@ -2818,13 +2808,13 @@ "
  • K_2: \n", "
      \n", "\n", - "
    • value: 0.004499999999999998
    • \n", + "
    • value: 0.0045
    • \n", "\n", - "
    • desc: Normalization
    • \n", + "
    • desc: Normalization factor
    • \n", "\n", - "
    • min_value: 1e-30
    • \n", + "
    • min_value: 0.0
    • \n", "\n", - "
    • max_value: 1000.0
    • \n", + "
    • max_value: 1000000.0
    • \n", "\n", "
    • unit: keV-1 s-1 cm-2
    • \n", "\n", @@ -2880,8 +2870,7 @@ " * is_normalization: false\n", " * e:\n", " * value: 0.99944429\n", - " * desc: Excentricity of Gaussian ellipse, e^2 = 1 - (b/a)^2, where b is the standard\n", - " * deviation of the Gaussian distribution (minor axis)\n", + " * desc: Excentricity of Gaussian ellipse\n", " * min_value: 0.0\n", " * max_value: 1.0\n", " * unit: ''\n", @@ -2918,10 +2907,10 @@ " * unit: keV\n", " * is_normalization: false\n", " * K_2:\n", - " * value: 0.004499999999999998\n", - " * desc: Normalization\n", - " * min_value: 1.0e-30\n", - " * max_value: 1000.0\n", + " * value: 0.0045\n", + " * desc: Normalization factor\n", + " * min_value: 0.0\n", + " * max_value: 1000000.0\n", " * unit: keV-1 s-1 cm-2\n", " * is_normalization: true\n", " * dat_2:\n", @@ -2929,7 +2918,7 @@ " * polarization: {}" ] }, - "execution_count": 9, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -2940,6 +2929,7 @@ }, { "cell_type": "markdown", + "id": "06fdccf1", "metadata": {}, "source": [ "Make some plots to look at these new extended sources:" @@ -2947,12 +2937,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 36, + "id": "5e046a06", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmgAAAG5CAYAAAA6ZcheAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAsKpJREFUeJzs3Xl4VOX58PHvzCSZrJM9gRAICUsgbGFfFAU3QCqCiqC1Fhe0KlRrW6G2Wuvyq7ZaivKKu1ZtC9QFEBFZZAcFWYUQCEuABLLv20wyM+8fkzmZgexzJsmE+3NdtjNnnvOcJxGTm2e5b43VarUihBBCCCE6DG17D0AIIYQQQjiTAE0IIYQQooORAE0IIYQQooORAE0IIYQQooORAE0IIYQQooORAE0IIYQQooORAE0IIYQQooORAM3DVFVVcfz4caqqqtp7KEIIIYRwEwnQPMzZs2eZO3cuZ8+ebe+hCCGEEMJNJEATQgghhOhgJEATQgghhOhgJEATQgghhOhgJEATQgghhOhgvNp7AEIIIYRomNlsprq6ur2HIZrJ29sbnU7ncj8SoAkhhBAdVFlZGRkZGVit1vYeimgmjUZDbGwsgYGBLvUjAZoQQgjRAZnNZjIyMvD39ycyMhKNRtPeQxJNsFqt5ObmkpGRQZ8+fVyaSZMATQghhOiAqqursVqtREZG4ufn197DEc0UGRlJeno61dXVLgVockhACCGE6MBk5syzqPXvSwI0IYQQQogORgI0IYQQQrSLf/7zn2RlZbX6fo1GQ1FREQATJkwgPj6e5ORkEhMT+dOf/tTk/Q8++CCbN29ust2WLVtYt25dq8fZGhKgCSGEEKJdNBagWSwWLBZLi/pbtGgRBw8e5Pvvv+fTTz/lq6++arT9e++9x8SJE5vstz0CNDkkIIQQQniAlX/cSUWx0a3P8A/WM/2lqxpts3v3bn7/+99TWlqK1WrlhRdeICkpiSeeeIKcnByMRiMPPfQQ8+bNA2yzXC+99BIrV64kNzeXZ599lvvuu4/nn3+eCxcuMGvWLPz8/Pjoo49YuXIlP/30E2VlZZw/f54NGzawaNEitm7dSnV1NQaDgXfffZfExMRGxxgaGsqoUaM4fvw4EydO5Ne//jV79uwBYObMmfz5z38GbLNuTzzxBNOnT2fOnDno9XpOnjzJ+fPnGThwIMuWLSMlJYW33noLs9nMli1buO2223j22WdV+G43TgI0IYQQwgNUFBupKHBvgNaUgoICpk+fzmeffcb48eOxWCwUFhYyadIkPv30U/r160dFRQVjxoxh9OjRjBw5EgC9Xs+ePXtITU1l5MiR/OIXv+DZZ5/lgw8+YPny5SQnJwOwcuVKdu/ezYEDB4iOjgZgwYIFvPrqqwAsW7aMxx9/vMnZrIyMDHbs2MEjjzzCCy+8gNFo5PDhw1RWVnL11VfTr18/Zs2addl9Bw8eZPPmzej1eq655ho+//xz7rrrLn71q19RVFTEP//5T/W+mU2QAE0IIYTwAP7B+nZ/xu7du0lMTGT8+PEAaLVasrOzOXr0KLNnz1balZaWkpKSogRoP//5zwHo168fXl5eZGVlERsbW+8zbr75ZiU4A9iwYQNvvPEGpaWlWCwWCgoKGhzfb37zG5577jm8vb155plnmDhxIr/73e947bXX0Gq1BAQEcO+997Jhw4Z6A7QZM2bg7+8PwKhRozh16lSj3w93kgBNCCE6qYu5uZw8ew5TtYmI0DDiYmIIMQS197BEKzW19NherFYrYWFhHDx4sME2vr6+ymudTkdNTU2DbR0z8J87d4558+axd+9eevXqxeHDh7nmmmsavHfRokVMnz690fE2lgajJeN0NzkkIIQQnYzFYmHb3h/5csNGfjpxguNn0tm5fz//WbOGlRs3UVxa2t5DFB5q3LhxpKWlsX37dsD2Zy0yMhKDwcCHH36otDt58mSjM112BoOB4uLiBj8vLi7G29ubrl27YrVaWbJkSYvHfMMNN/D+++9jtVopLy/nk08+4aabbmpRH02N0x0kQBNCiE7EarWybe+PHElLq/fzCzk5fLF+AwVt/MtGdA6hoaF8+eWXLFy4kMGDBzNs2DB++OEH1qxZwxdffMHgwYMZMGAADzzwAJWVlU329+tf/5q5c+eSnJxc7wzcoEGDmD17NgMGDGDkyJH06NGjxWN+5pln8Pb2ZtCgQYwePZpp06Zx5513tqiPGTNmcPDgQZKTk3n++edbPIbW0FilAqtHOX78OHPnzm3WKRYhxJXnRHo6G3ftBkCr0XDVsGFERYRzITuHoydPUlJWBkBwUBAzJ0/Cx9u7PYcrGlFVVcWZM2eIj493WnoTHZta/95kBk0IITqJyioj23/cp7yfOGY0gxL7Eh0eztCk/sycPImI0BAAiktL+f7goXYaqRCiKRKgCSFEJ3HgWApGkwmA3j16kBgf7/S53seHSVdfjZeX7XzY0ZMnya/Nwi6E6FgkQBNCiE6gvLKSn07Y9p3ptFrGDRtab7vgoCCGJSUBtv1qP/50pM3GKIRoPgnQhBCiEziadhKz2QzAwD59CKzN5VSf5H6J+NfujTl1/ryc6hSiA5IATQghPJzZbCbl5EnAluNpSP9+jbb38vJisMMho0Opx906PiFEy0mAJoQQHu50RgYVVVUAxMfGNjp7ZjegT2+8dDrAdvKzPRNyCiEuJwGaEEJ4uOOnzyivB/bp3ax79D4+9OrRHQBTdTVnMjLcMjYhROtIgCaEEB6ssspIRlYWAIH+/nRzqGHYlH4JvZTXxxyCPCE80ZYtW/Dz8yM5OZnk5GQGDBjAu+++26x758yZ06aF0JtDanEKIYQHO33+PJbafOO943o0WmfwUjFRkRgCAigpLyczO5sqoxFfvfsLcgtRU1OjpHup731rJSYmKhUJMjIy6NWrF7NnzyYoyPNq0EqAJoQQHizt7FnldZ+4uBbdq9FoSOjRnYPHUrFaraRnZtIvIUHtIQqV3HXsH+RVu/fEbYR3EP/t/2SjbTQaDS+99BIrV64kNzeXZ599lvvuuw+A3/3ud2zdupXq6moMBoNT1RuNRsOzzz7L2rVrmTBhArm5uWi1Wk6ePElOTg6pqan8/e9/56OPPkKr1TJ48GDefPNNgoOD6datG3v37iUmJoY777yTjIwMdu3ahdFoJCYmhgsXLlw2zpKSEgICAvCurZYxYcIEnnjiCaWY+h133MHPfvYz5syZ43RfaWkpDz74IIcOHSIyMpKkpCSMRiMfffQRAK+++iorVqygpqaGqKgo3n77beJa+N9ec0iAJoQQHqrKaORibi5gy28WERra4j4SutsCNIDT5zMkQOvA8qpLyanuGDVU9Xo9e/bsITU1lZEjR/KLX/wCLy8vFixYwKuvvgrAsmXLePzxx1m3bp1yn06nY+/evYBtWXHfvn3s2LGDoKAgvvnmGz744AN2795NSEgIDz30EAsXLmTp0qVcf/31bNy4kXvuuYdDhw7h5eVFSUkJe/fuZfjw4ehrZ36PHz9OcnIyJpOJU6dO8cYbb7S43NLzzz+Pn58fx44do6ysjHHjxjF8+HAA/vOf/3D8+HF2796NTqfjk08+4dFHH+Xrr79W49vqRAI0IYTwUOcuXMReTjk+tluLljftosPDCfDzo7yykvMXL2Kqrpb6nB1UhLf7l+ma+4yf//znAPTr1w8vLy+ysrKIjY1lw4YNvPHGG5SWlmKxWCgoKHC67/7773d6P3PmTGX5cePGjcyaNYuQkBAAHnnkEWbOnAnADTfcwMaNGxkwYABDhgwhOjqaLVu2sHv3bq6//nqlv0uXOK+66ipGjBjBsGHDmv092LRpE4sWLUKj0RAUFMSsWbM4WZvGZuXKlUpQCCi5B91BAjQhhPBQZx2WdeJiYlrVh0ajIT42liNpaZgtFjKzs4mPjVVriEJFTS09tiXHWSmdTkdNTQ3nzp1j3rx57N27l169enH48GGuueYap/sCAwMbfe/I8S8cN9xwA3/4wx9ISkrihhtuIDo6mo0bN7J7926WLl1a7/2xsbGMHj2aTZs2MWzYMLy8vJwCqqra1DRNcRyH1WrlD3/4Aw899FCz7nWFnOIUQggPZLFYOHfxIgA+3t50iYxsdV89unZVXp+/mOXy2MSVqbi4GG9vb7p27YrVamXJkiUtuv+GG25gxYoVlJSUAPD2229z0003ARATE0NwcDBvvfUWN9xwAxMnTmTNmjWkp6c3ODtWXFzMvn37lD1wvXv35ocffgDgzJkz7Nixo977rrvuOv71r39htVopKytjxYoVymfTp0/nrbfeUmYGq6urOXDgQIu+zuaSGTQhhPBAOfkFSmH07l26oNO2/u/b3aKj0Gq1WCwWztcGfUK01KBBg5g9ezYDBgwgPDxc2YzfXFOmTOHIkSOMHTvW6ZCA3Q033MCaNWtIqN0n2aVLF4YOHYrW4c++fQ8agNFo5J577mHatGkAPPXUU8yaNYtBgwYxYMAARo8eXe84nn32WR544AH69+9PREQEQ4YMUZZdf/7zn5Ofn8/EiRMB2+nT+++/n6FD66996wqN1b6BwUOYTCbef/991q9fT2lpKb169eLBBx9k5MiRTd6bm5vLkiVL2Lt3LxaLhaFDhzJ//nxi6lkaWLNmDcuWLSMrK4vIyEjuuOMObr/99lb3eek0r91DDz3EPffc08yv3vaHb+7cuU4nY4QQV54fDh1m39GjAEwcPZr+vVzb3L9y4yYu5OQA8PNptxDcyNKTaBtVVVWcOXOG+Pj4Fm90F61XXV2N2WzG19eX8vJyJk2axPz585k1a1az7lfr35vHzaD99a9/ZcuWLcycOZPY2Fi++eYbnnrqKRYvXszgwYMbvK+iooLHH3+c8vJy7rnnHry8vFixYgXz58/ngw8+IDg4WGm7atUqXnvtNa699lpmzZrF4cOHWbx4MVVVVcrGyJb2CTBixAgmT57sdK1Pnz4qfWeEEFeSzJxs5XX3rl1c7q971y5KgHb+4kWC5WeTuEIVFhYyZcoUzGYzVVVV3Hrrrdx5551tPg6PCtBSUlLYtGkTjzzyCHfddRcAkyZNYs6cOSxdurTBjYJgO3mRkZHB22+/Tf/+/QEYPXo0c+bMYfny5cqGP6PRyHvvvcfYsWN54YUXALjllluwWCx8/PHHTJs2TTlx0tw+7bp3766spwshRGtV19SQk2/bAxMcFNSs2ptN6d6lCz8cOgxAZlY2AyVAE1eoqKgo9u3b197D8KxDAlu3bkWn0ynryWDLxTJ16lSOHj1KdnZ2g/du2bKFfv36KYEUQFxcHMOGDWPz5s3Ktf3791NcXHzZ2vmMGTOorKxk9+7dLe7TkdFoxGg0NvtrFkKIS2Xn5WGxWADoFhWlSp8RoaFKeo0Lubl42O4XITodjwrQ0tLSiI2NJSAgwOm6PUCy5ym5lMVi4fTp0/Tr1++yz/r3709mZiYVFRXKM4DL2iYmJqLVajlx4kSL+7Rbt24dN910EzfeeCO/+MUv2LBhQ3O+bCGEcJKZnaO8jolWJ0DTarV0iYgAoLKqiuLSMlX6FUK0jkctcebn5xMeHn7Zdfu1vLy8eu8rKSnBZDI1eW+PHj3Iz89Hp9MReklGbm9vbwwGA/n5+S3uE2DgwIFMnDiRrl27kp+fzxdffMELL7xAeXl5oydd8vLylGcCnHUo6yKEuDLZ94oBxKg0gwbQNSpSSd1xMTeHEIPn1S8UorPwqADNaDQqNbUc+fj4KJ83dB/QrHuNRmODBVt9fHyc2jW3T8DpqDDAzTffzIMPPsg777zDlClTlDIVl1q9erVS/0sIIaprasiu/UtbcGCgKvvP7Lo65FK7kJNL/169VOtbCNEyHrXEqdfrqa6uvuy6qTYXUENBjv16c+7V6/XU1NTU24/JZHJq19w+6+Pt7c1tt91GWVkZx48fb7DdtGnTePfdd5V//vSnPzXYVgjR+eXk5yv7z2Kio1XtOyo8XMmnZq/xKcSlNBoNRUVFbfrMiIgI0tPTAVvR8/j4eJKTkxkwYAA333xzo3vQ7dLT05V8Zp7AowK08PBwp+U+O/u1iNr9E5cyGAz4+Pg0697w8HDMZjOFhYVO7aqrqykpKVGWL1vSZ0Oiapcm7FmT6xMREUFiYqLyT1xcXKN9CiE6t4u5dVs5urpQPaA+XjodUbU/40rKyii/ZB+tEC3R0GSHGhYtWsTBgwc5evQocXFxSoH2zsSjljh79+7NgQMHKC8vdzookJKSonxeH61WS0JCAqmpqZd9lpKSQkxMDP61ywT2vGSpqamMHTtWaZeamorFYlE+b0mfDblQW0fPkyJ6IUT7ynH4S2GXJv4S2BpdIyOV2bOs/Hx6qbiEKlxz76//TH5hsVufER4azMev/6XJdq+++ipff/015eXl/PnPf1ZyhGo0Gp599lnWrl3LhAkT+P3vf8+vfvUr0tLSsFqtzJ8/n4cffhiA3/3ud2zdupXq6moMBoNTAvbVq1ezYMECvL29L8sf6qimpoaysjK6d+8O2LIrPPHEE0rB9CNHjvCzn/1MmX1ztGrVKhYuXIiPjw+TJ0/m/fff58cff6Rnz56kpaXxxBNPkJOTg9Fo5KGHHmLevHkt+Va6zKMCtAkTJrBs2TJWr16t5EEzmUysXbuWpKQkomun+7Ozs6mqqnKabbr22mt5++23SU1NVU5enjt3jgMHDjhlBx42bBgGg4FVq1Y5BWirVq3C19fX6Vpz+ywqKrosCKuoqOCzzz4jODhYKgIIIZrFarWSXXsYSu/jQ3CQ+tn+oyPqDj7l5OfTq/YXn2h/+YXF5OQXNt2wDWg0Gg4cOMDp06cZMWIEV111FT179gRsxdP37t0LwKxZs0hMTOSLL74gJyeH4cOHM2TIEMaMGcOCBQuUma9ly5bx+OOPs27dOnJycrjvvvvYvn07SUlJvPPOO5etVv3mN7/hueeeIzMzk65du7a47mdOTg73338/O3fupF+/fnz44YfKM8xmM3fddReffvop/fr1o6KigjFjxjB69OhmVS1Si0cFaElJSUycOJF33nmHoqIiunXrxrp168jKymLBggVKu5deeomDBw+ybds25dqMGTNYs2YNCxYsYPbs2eh0OlasWEFoaCizZ89W2un1eh544AEWLVrEs88+y6hRozh06BDr169n7ty5GAyGFvf5xRdfsGPHDsaNG0d0dDT5+fmsXbuW7Oxs/vjHP9Z70EAIIS5VUl5OZe3ho+jwcDQajerPiAp3DNAKVO9ftF54aHDTjdroGQ8++CAACQkJXHPNNWzbtk0J0O6//36l3caNG5Wkr1FRUdx2221s3LiRMWPGsGHDBt544w1KS0uxWCxKAfLvv/+ewYMHk5SUBMADDzzA/PnznZ6/aNEipk+fjtVq5bnnnuP+++/n888/b/bXaX+GfXLll7/8Jb/61a8AW0nFo0ePOv0eLy0tJSUlRQK0xjz99NNER0fz7bffUlZWRkJCAq+88opSHLUh/v7+LF68mCVLlvDxxx8rdTPnzZt32ezWjBkz8PLyYvny5ezcuZOoqCjmzZvHzJkzW9XnoEGDOHLkCGvWrKGkpARfX1/69+/PggULGD58uErfGSFEZ5ftkEoo2g3LmwABfn4E+PtTXlFBTn4+VqvVLYGgaLnmLD22F8c/I4GN1HG1tzt37hzz5s1j79699OrVi8OHDzdYs7qxP38ajYZZs2YpM3FeXl6YzWbl86qqqhZ9HWCbqQ4LC1OWSduLxwVoer2eRx99lEcffbTBNq+//nq916Oionj++eeb9ZxbbrmFW265pcl2zelz5MiRbRp1CyE6p+y8umWe6HpyMKolOjyM0xUVVNfUUFhSQliw+2duhGf58MMPee6550hPT2f79u3885//rLfdDTfcwLvvvstLL71Ebm4uX3zxBf/73/8oLi7G29ubrl27YrVanZYox44dy3333adsH/rggw+U7Aj12bRpk7JVKCEhgbNnz5Kbm0tkZCSffPJJvfeMGTOGw4cPc/z4cRITE/n000+VZyQmJmIwGPjwww+57777AFsi/LCwMMLCwlrz7WoVjwvQhBDiSpXtsA8nKsJ9AVpUeDinz2cAtn1oEqCJS5nNZoYOHUp5eTmvv/66srx5qddff51HHnmEQYMGYbVa+eMf/8jo0aMBmD17NgMGDCA8PNwpYXtkZCQffPABM2bMUDbwX5oU3r4HzWKxEBoayr/+9S8AYmJieOqppxg1ahTR0dFMmTKl3nFFRUXx3nvvMX36dPR6PTfeeCOBgYGEhITg5eXFmjVreOKJJ1i0aBFms5mIiAj+85//uP6NawGNVQqueZTjx48zd+5cp9MuQojOr8Zs5r3/fYbFYiHEYODun01127Mys7NZtek7AAb26cM1I0e47VmiYVVVVZw5c4b4+Hh8fX3bezidTmlpKUFBtmoZK1eu5A9/+APHjh1zuV+1/r3JDJoQQniAvMJCJUGtO5c3ASIdlnGy68n1KERn8MYbb7B8+XLMZjMGg4F///vf7T0kJxKgCSGEB8gtqDtRGRXu3n0wPt7ehBoMFJaUkF9UhNlsRqfTufWZQrS1p59+mqeffrq9h9Egj6okIIQQV6o8h+omkaHu36gcERYKgMViobCRaidCCPeQAE0IITxAbkFdgBYeGuL250WGhiqv8wo7RnJUIa4kEqAJIUQHZzabKSi2lfgJNRjw9nL/7pQICdCEaFcSoAkhRAdXUFysHBBwDJzcKTzEMUArapNnCiHqtOqvYY51Jltr5syZ3HHHHS73I4QQnZ3T/rOwtgnQ/Hz1SkWBvMJCqSggRBtr1QxaVlYWpaWlWK3WVv2TnZ1NWVmZ2l+LEEJ0So77z9pqBg0gorZknam6mtLy8jZ7rvAsERERpKenc/PNN3P8+PFG22o0GoqKitpmYB6u1RsZ7rzzTubMmdOqe6+99trWPlYIIa44jjNoEW1YaiYiNJSzFy4oYzA0UmNRiLVr17b3EDoVyYMmhBAdmMViIa92xiEoIABfH582e3ZEmPM+tITu3dvs2eJy/1v3LRWVlW59hr+fHzMnT2q0zerVq1mwYAHe3t5MnjxZud6zZ09WrlxJcnIyL774Iv/+97/R6/UArFq1iri4OKWt1Wpl4cKFHDt2jGXLluHv7++eL8iDtSpA++STTwh2oTabq/cLIcSVori0jJqaGqBtlzcvfZ6c5Gx/FZWVlLs5QGtKTk4O9913H9u3bycpKYl33nmH/EuqTRQWFvLqq69y8eJF/Pz8qKioQKut21FlNBq56667CA8P58svv5QkyA1oVYDWo0cPlx7q6v1CCHGlyCusqyDQVgcE7AwBAfh4e2OqrpYArQPw9/Nr92d8//33DB48mKSkJAAeeOAB5s+f79TGYDDQp08f7rnnHm666SamTp1KbGys8vnUqVO59dZbeeaZZ9T/AjoRWeIUQogOzDHFRVvPoGk0GsJDQriYm0tZRQVGkwl9Gy6xCmdNLT22h/pO9up0Or7//nt27drFli1bGDNmDP/9738ZP348ANdddx0bNmzg8ccfx2AwtPWQPYaqedBKS0tZt26dml0KIcQVLb82QS1AeO2pyrYU6rAdpcBhLOLKNHbsWA4fPkxqaioAH3zwASaTyalNaWkp2dnZjB8/nmeeeYarr76aAwcOKJ8//fTT3Hbbbdxwww2XLY+KOqoGaNnZ2bz88stqdimEEFe0gtoDAj7e3gS2w0bqcAnQhIPIyEg++OADZsyYwZAhQ0hLSyM8PNypTXFxMbfddhuDBg1i8ODBVFdX88tf/tKpzRNPPMHcuXO57rrryMrKassvwWO0aIkzOzu70c/z8vJcGowQQog6RpOJsooKAMKCg9slUWxYiEOAViQBmoBbb72VW2+9VXn/yiuvAJCenq5c+/777+u912q1Kq/nzp3L3Llz3TPITqBFAdqdd97Z6A8IyTQthBDqcZyxCmuH5U2wBYZ2MoMmRNtpUYAWFBTEAw88QHJycr2fnz17lueee06FYQkhhMh3yLgeHtI+qYn8fH3x0+upNBolQBOiDbUoQOvbty+lpaXEx8fX+7nZbHaavhRCCNF6jkuKYcEh7TaOsJBgMrNzqKyqorLKiJ+vvt3GciWS36ueRa1/Xy0K0KZPn05VVVWDn0dHR7Nw4UKXByWEEAIKiouU1+01gwa2Zc7M7BzAtszZzTeq3cZyJfH29kaj0ZCbm0tkZKRsIfIAVquV3NxcNBoN3t7eLvXVogDtmmuuafTzoKAgpkyZ4tKAhBBC2H7Q59fOoPn7+eGrb79ZK8dUG4XFxXSLlgCtLeh0OmJjY8nIyHDagC86No1GQ2xsrMsVEiRRrRBCdEAVlZUYa/NLhbdzabxwh+XVfIdZPeF+gYGB9OnTh+rq6vYeimgmb29vVcpXuRygTZgwgU8++YTuUkRXCCFUk+90grN9A7TQEOcZNNG2dDqd1Ku8ArmcqFY2LwohhPoKnE5whrTbOAB8fXwIqK3RmF9ULD/3hWgDqlYSEEIIoY78ovbPgebIvg/NaDJR0chhMSGEOiRAE0KIDsgx51hoBygo7ZiwtqikpB1HIsSVQQI0IYToYCwWi7LXKzgoCG+v9j/P5RgkFkqAJoTbSYAmhBAdTGl5OTVmM+A8c9WeQhwDtGIJ0IRwNwnQhBCig3GcoeoIy5sAoYYg5bUscQrhfhKgCSFEB+M4QxUa3DECND9fX3xqM6MXlZa282iE6PxcDtDuvvtuDB3kb3hCCNEZdMQZNI1Go4yltLyc6pqadh6REJ2bywHaww8/THAH2SMhhBCdQUcM0MB5H1qxzKIJ4VatDtBMtSVIhBBCqMdqtVJUe4Iz0N/f5YLLagqVgwJCtJlWB2gzZsxg0aJFHD9+XM3xCCHEFa2yqgpjbd3FjjR7BhDicFBAUm0I4V6tTq5jMplYuXIlq1atolevXkydOpUbb7yRoKCgpm8WQghRL6flzQ5yQMDOcYlTTnIK4V6tnkFbtWoVTz75JImJiZw8eZLXX3+d2267jeeff559+/apOUYhhLhiOAZoIR1sBi04MBCNRgPIDJoQ7tbqGTR/f39uvfVWbr31VtLT0/n666/ZsGEDmzZt4rvvviMqKoqpU6cyefJkoqOj1RyzEEJ0Wk4pNgwd6wCWTqcjODCQotJSiktLsVqtSsAmhFCXKnnQevbsyWOPPcbnn3/Oiy++yJgxY8jLy+ODDz5g9uzZ/P73v2fLli3UyLFsIYRoVGGJQw3ODrbECXWzejVmM2UVFe08GiE6L1ULvOl0OsaPH8/48eMpKCjg22+/Ze3atezZs4e9e/diMBhYvXq1mo8UQohOxT6DpvfxwU+vb+fRXC7UYCA9MxOwjTUoIKCdRyRE5+S2SgJhYWHcddddPPfccwwaNAir1UqJ7FkQQogGmaqrKa+sBGyzZx1x+VBOcgrRNlSdQbOrqKhgw4YNfP3115w4cQKr1Yqvry8TJ050x+OEEKJTcE5Q27H2n9nJSU4h2oaqAdr+/ftZu3Yt27dvx2g0YrVaSUpKYurUqVx33XX4+/ur+TghhOhUnA8IdMyURU7JaiVAE8JtXA7QcnJy+Oabb/jmm2/IysrCarUSEhLCtGnTmDp1Kj179lRhmEII0fk5HRDooDNovno9eh8fjCaTlHsSwo1aHaBt2rSJtWvXsn//fiwWC1qtlpEjRzJ16lSuvvpqvLzcsnoqhBCdVlEHTlLrKCQoiOz8fMorK6muqcFbft4LobpW/1f1/PPPA9C1a1emTJnClClTiIqKUm1gQghxpbEvcXrpdB36dGRwbYAGtqLpEaGh7TwiITqfVgdo119/PVOnTmX48OFqjkcIIa5IZrOZ4rIywHZSsiOe4LQLdijpV1xaJgGaEG7Q6gDt2WefVXMcQghxRSsuK8NqtQIdd/+ZXUhQoPJa9qEJ4R6qbRyoqanhiy++YOPGjZw7dw6j0cjmzZsBSEtL46uvvmLmzJl0795drUcKIUSnUVRSF+iEdNATnHaOM2hFEqAJ4RaqBGhGo5Hf/va3HDlyhODgYAICAqiqqlI+79q1K2vXriUoKIi5c+eq8UghhOhUSsrqAp3gQM8J0GQGTQj3UKWSwCeffMJPP/3EQw89xMqVK5k6darT54GBgSQnJ7N37141HieEEJ2Off8ZgMFhCbEjcixDJQGaEO6hygzad999x9ChQ7n77rsB6t3cGhMTQ1pamsvPMplMvP/++6xfv57S0lJ69erFgw8+yMiRI5u8Nzc3lyVLlrB3714sFgtDhw5l/vz5xMTEXNZ2zZo1LFu2jKysLCIjI7njjju4/fbbXerT7vDhw8ybNw+A1atXExIS0vxvgBCiUyopdQjQAjt2gAa2WbRKo5GKqipM1dX4eHu395CE6FRUmUHLyckhMTGx0TZ+fn6Ul5e7/Ky//vWvrFixghtvvJFf//rXaLVannrqKQ4fPtzofRUVFTz++OMcPHiQe+65h/vvv5+0tDTmz59PcXGxU9tVq1bxt7/9jfj4eB5//HEGDhzI4sWL+fe//93qPu0sFguLFy/Gz8/PtW+EEKJTsc+geXt5dcgi6ZeSZU4h3EuVGTQ/Pz+KiooabXPhwgWCg107mZSSksKmTZt45JFHuOuuuwCYNGkSc+bMYenSpSxdurTBe1euXElGRgZvv/02/fv3B2D06NHMmTOH5cuX89BDDwG2/XTvvfceY8eO5YUXXgDglltuwWKx8PHHHzNt2jSCan8wNbdPR1999RU5OTlMnTqVzz77zKXvhxCic7BYLJTV/gXWEBjYoVNs2F2aaiMyLKwdRyNE56PKDNqAAQPYtWsXpQ38LSo7O5vvv/+eIUOGuPScrVu3otPpmDZtmnJNr9czdepUjh49SnZ2doP3btmyhX79+imBFEBcXBzDhg1TTpuCrZ5ocXEx06dPd7p/xowZVFZWsnv37hb3aVdSUsJ7773H/fffT6AHLGEIIdpGaUUFltoUG8EdfP+ZXYic5BTCrVQJ0GbPnk1paSm/+c1v+OmnnzCbzQBUVVWxb98+fve732E2m5k1a5ZLz0lLSyM2NpaASzJs2wOkkydP1nufxWLh9OnT9OvX77LP+vfvT2ZmJhUVFcozgMvaJiYmotVqOXHiRIv7tHvvvfcICwtzCjCbkpeXx/Hjx5V/zp492+x7hRCeocQhwPGE/WfgHEjKEqcQ6lNliTM5OZknnniC119/nfnz5yvXJ0+eDIBWq+XJJ59scp9aU/Lz8wkPD7/suv1aXl5evfeVlJRgMpmavLdHjx7k5+ej0+kIvSQztre3NwaDgfza8iYt6RPg1KlTfPXVV7zyyivodLrmfsmsXr2ajz76qNnthRCex/EEZ0dPsWEne9CEcC/VEtVOnz6d5ORkVq1axbFjxygpKSEgIID+/fszY8YM4uPjXX6G0WjEu56TQj4+PsrnDd0HNOteo9HYYKF3Hx8fp3bN7RNg8eLFjB49mlGjRtXbd0OmTZvGVVddpbw/e/YsL774Yov6EEJ0bCUelGLDzsfbG39fXyqqqiRAE8INVAvQAHr27Mnjjz/e4Odms7lFs0eX0uv1VFdXX3bdZDIpnzd0H9Cse/V6PTU1NfX2YzKZnNo1t89NmzZx5MgR/vWvfzXwlTUsIiKCiIiIFt8nhPAcxaWOM2ieEaCBbRatoqqKSqMRo8mEvvYvp0II16myB+2LL75oso3ZbOYvf/mLS88JDw9Xlhgd2a81FMgYDAZ8fHyadW94eDhms5nCwkKndtXV1ZSUlCjLly3pc+nSpUyYMAEvLy8uXrzIxYsXKav9G3NOTk6DS7NCiCuDfQZNq9EQ6O/fzqNpPlnmFMJ9VJlBe/311wkLC2PChAn1fm6xWPjLX/7Ctm3bXHpO7969OXDgAOXl5U4HBVJSUpTP66PVaklISCA1NfWyz1JSUoiJicG/9odinz59AEhNTWXs2LFKu9TUVCwWi/J5S/rMyclh48aNbNy48bK2Dz74IL179+aDDz5o1vdACNG5WK1WZQ9aUEAAWq0qf29uEyGXBGhR9ezJFUK0jioB2qBBg3jxxRcxGAwMGzbM6TN7cLZ161Zuu+02l54zYcIEli1bxurVq5U8aCaTibVr15KUlER0dDRgS+tRVVVFXFyccu+1117L22+/TWpqqnLy8ty5cxw4cMDpdOmwYcMwGAysWrXKKUBbtWoVvr6+Ttea2+dLL7102deyadMmvvvuO/74xz8SGRnp0vdFCOG5Ko1GZVuFp+w/s3Muml7WSEshREupEqC9/PLLzJs3jz/96U8sXrxYmWWyWCy88MILbNmyhenTpze6P605kpKSmDhxIu+88w5FRUV069aNdevWkZWVxYIFC5R2L730EgcPHnSasZsxYwZr1qxhwYIFzJ49G51Ox4oVKwgNDWX27NlKO71ezwMPPMCiRYt49tlnGTVqFIcOHWL9+vXMnTsXg8HQ4j7Hjx9/2ddiT+cxevRoKfUkxBWspNTzTnDaSaoNIdxHlQAtICCAV199lUceeYTf//73vPnmm3Tt2pXnn3+ezZs3c+utt/Kb3/xGjUfx9NNPEx0dzbfffktZWRkJCQm88sorJCcnN3qfv78/ixcvZsmSJXz88cdK3cx58+ZdFiDNmDEDLy8vli9fzs6dO4mKimLevHnMnDmz1X0KIUR9iss8LweanexBE8J9NFZrbfpqFZw/f57HHnuMgIAA+vTpw9atW/nZz37G73//e7UeccU7fvw4c+fO5d1333U5r5wQov3t/ekn9v50BIAp14wnPja2nUfUMv/6ciXllZX46vXcf7tr21iEEHVU3Y3avXt3/va3v1FYWMi2bdskOBNCiCY4ptjwtBk0qFvmrDIaMdWTdkgI0TqtWuJsKrN9//79OXnyJOHh4U5tNRoNv/zlL1vzSCGE6JScktR6YIBmCAzkQk4uYFvmlKLpQqijVQHahx9+2Kx2lyZmlQBNCCGc2VNs+Pv54d1AFZOOzOBwsKGkrEwCNCFU0qqfBosXL1Z7HEIIccWprq6msqoK8KwKAo4cx+1YU1QI4ZpWBWhNnZgUQgjRtGIPX94E59xtJZILTQjVeE7KaiGE6GQc95/JDJoQwpEEaEII0U6cZtA8rIqAna9ej97bG3AOOIUQrpEATQgh2olzFQHPDNAADLUJa0vLyzGbze08GiE6BwnQhBCinTjvQfOsMk+OHPfPlZSXt+NIhOg8JEATQoh2Yl8S9PH2xlfv086jaT3H2T85KCCEOiRAE0KIdmC2WCitnW0yBAag0WjaeUSt57h/Tg4KCKEOCdCEEKIdlJWXYy+F7MnLm3DJDFqZFE0XQg0SoAkhRDso7gQpNuwc96AVyxKnEKpQNUArLS1l3bp1anYphBCdUkknSLFhF+jvj05r+3UiqTaEUIeqAVp2djYvv/yyml0KIUSnVNxJUmyArc5yUO3XUFJWpizdCiFar0WlnrKzsxv9PC8vz6XBCCHElaKkE5R5chQcGEhRSQlmi4XyykoC/f3be0hCeLQWBWh33nlnoyeNrFarR59EEkKItlJcu5leq9V2imDm0n1oneFrEqI9tShACwoK4oEHHmiwWPrZs2d57rnnVBiWEEJ0XlarlZIyW4qNoIAAtFrPP68VHOR8krNbdFQ7jkYIz9eiAK1v376UlpYSHx9f7+dms1n2HgghRBMqq6qoqakBPH//mZ1BiqYLoaoWBWjTp0+nqqqqwc+jo6NZuHChy4MSQojOrLiT7T8DCHbI5SbVBIRwXYsCtGuuuabRz4OCgpgyZYpLAxJCiM7O6QSnh6fYsDMEBiivZQZNCNd5/sYHIYTwMJ3tBCeATqdTDgZILjQhXOdygDZhwgTOnz+vxliEEOKKUOxQDinYw8s8ObLPBhpNJqpMpnYejRCezeUATQ4FCCFEyzju0XJcGvR0Bqd9aFKTUwhXyBKnEEK0MfsSYICfH15eLdoK3KEFy0lOIVQjAZoQQrQhU3U1lUYj0Hn2n9kZnHKhSYAmhCskQBNCiDbkGLh0lhOcdsGXVBMQQrRe55lbF0IID9DWOdCMJhMHj5ygxmwmeUBfAvz93PYsx69HZtCEcI0EaEII0YacDwi4N0A7dPQET7+ylJy8AgD8fPXcOulafn3/LLy91f/xr/fxwVfvQ5XRJHvQhHCRLHEKIUQbcgxc3Fnm6WR6Bo8/+5oSnAFUVhlZtmo9z776tttO4NtPcpZXVFBjNrvlGUJcCVwO0O6++24MBoMaYxFCiE7POUmte3Kgmc0Wnv/Hu5RX2krzDe7fm1snXYtOpwNg4/Y9fLVhu1ueHSzLnEKowuUA7eGHHyY4OFiNsQghRKdnD1q8vbzw1fu45RlrNm7n2Ml0AOJ7xPD/XnqKPz1+Py//4TGlzZv/+ozKKqPqz5Z9aEKow61LnFarlfPnz5Odne3OxwghhEcwWyyUlpcDthOcGo1G/WeYLXz8v6+V93+YNwdfXz0AE8YNZ+K4EQDkFxbz+drvVH++48lUOckpROupEqBt3bqVl156iVKHzNEXL15kzpw5/OIXv2DWrFk899xzmGU/ghDiClZWUaHs/XLX8ua2H/Zz7oLtL8UjBvdn6MBEp89/de9tyuvP1mzCYrGo+nyZQRNCHaoEaKtWrSItLY2goLofOEuWLCE9PZ2hQ4fSq1cvtmzZwtq1a9V4nBBCeCTH8kfuKvHkuLfsntunXPZ5Qo9ujB46AIDMrFy+339E1edLNQEh1KFKgJaenk7//v2V9xUVFezevZvrrruORYsW8fbbbxMXFycBmhDiiuZ8glP9GbTC4hJ2/fgTAFHhoYwZNqjedrdPvU55/c3mXaqOwd/PTzmMUFIm9TiFaC1VArSSkhLCwsKU94cPH8ZsNnP99dcD4OXlxYgRI8jMzFTjcUII4ZGcTnC6oYrAhm0/KFtJJl83Dp2u/h/xV49MJjDAH4Dt3x/AaDKpNgaNRqPMDpaUlbstnYcQnZ0qAVpAQAAlJSXK+wMHDqDVahkyZIhyzcvLi6qqKjUeJ4QQHqnEzTnQtuzer7yeMmFsg+28vb24duwwAMorq/h+n9rLnLbZQYvFQllFhap9C3GlUCVA69GjB7t27aK4uJjS0lI2btxI3759nfakZWVlERoaqsbjhBDCI9lPNWo1GgL9/VXtu6yikv0/HQegW5dIevWMbbT9DVePVF5v2b1P1bHIQQEhXKdKgHb77beTl5fH7bffzsyZM8nPz2f69OlObVJSUujdu7cajxNCCI9jtVqVYCUwIACtVt0sRz/sP6Isb149KrnJFB4jk5PQ1+Zh++HAEVWXIuWggBCuU+UnxIQJE/jNb35DfHw83bt35+GHH2bKlLrTQwcPHqS8vJxRo0ap8TghhPA4VUYj1TU1gHuWN3fsOai8vnrUkIYb1tL7+DB8UD8AcvOLOJWeodpYHPfXlUguNCFaRbVqudOnT79s1swuOTlZTnAKIa5oxWXuK5JutVqVdBl+vnqG1QZeTRkzbBC7fjwMwO79P9E7vrsq45EZNCFcJ8XShRCiDbjzBOe5zGzyCooASB7QFx9v72bdN3b4QOX1DyrmQwsKCFCWWGUPmhCtIwGaEEK0AcelPrWXOPcfSVVeN3f2DCAutitR4bbDW4ePnaRGpWovOp1OOQThmJxXCNF8EqAJIUQbcOcS5/6fWhegaTQakgf2BaCyykja6XOqjcn+NRqrq6kyql+UXYjOTgI0IYRoAyVuCtCsVquSXsNX70NSn54tun9IUl/l9YGjJ1Qbl+xDE8I1EqAJIUQbsAdofr76Zu8Ra47MrFxy8goAGNy/D15eLTv7lTygLkA7pGKAJrnQhHCNBGhCCOFmNTU1lFdWAmAIUHd586BDUDV0YGKL7+8VF0uAv5+tr5Q01fKhOaXakABNiBaTAE0IIdyspLxcea32Cc6jx08rrwcntTwZuE6nZXB/230FhcVkZuWoMi6nJU7JhSZEi0mAJoQQbuZ8gjOokZYtl5JWF6Al9YlvVR+D+vWq6+9EuqtDAmSJUwhXtThAs1gsnD59mry8vMs+q6mp4eDBg2qMSwghOo3isrpUE4bAANX6NVVXc6L25GXP7l0JDGhdfc/+DoHdsZNnVBmb3scH39pSUnJIQIiWa1GAlpWVxZw5c7jvvvu44447WLhwIcXFxcrnJSUlPPHEE2qPUQghPFpJWd0Sp5ozaGlnzlNTY8td1trZM4B+vXsqr4+lqROgARhqv9byigrVcqwJcaVo0XGfpUuXEhERwSuvvEJZWRlvvvkmjz32GP/85z+JiIgAULXgbn1MJhPvv/8+69evp7S0lF69evHggw8ycuTIJu/Nzc1lyZIl7N27F4vFwtChQ5k/fz4xMTGXtV2zZg3Lli0jKyuLyMhI7rjjDm6//fZW9Wk0Glm0aBHHjh0jJycHi8VCTEwMN998MzNmzGjxqSshhGcpdlMVAcf9ZwMSE1rdT0RYCFERYeTkFZCalo7FYlGlmHtwYCA5+fmAbZkzLDjY5T6FuFK06L/AQ4cO8eijj9K1a1f69OnDa6+9xuDBg5k3bx7Z2dkASnkPd/nrX//KihUruPHGG/n1r3+NVqvlqaee4vDhw43eV1FRweOPP87Bgwe55557uP/++0lLS2P+/PlOs4AAq1at4m9/+xvx8fE8/vjjDBw4kMWLF/Pvf/+7VX0ajUbS09MZM2YMDz30EI8++ii9e/dmyZIl/N///Z963xwhRIdUUrvE6aXT4e/rq1q/KSccArS+rQ/QACV/WnllFecuZLvUl53sQxOi9Vo0dVNVVYW3Q/4ee3D02muvMX/+fJ555hnVB+goJSWFTZs28cgjj3DXXXcBMGnSJObMmcPSpUtZunRpg/euXLmSjIwM3n77bfr37w/A6NGjmTNnDsuXL+ehhx4CbMHUe++9x9ixY3nhhRcAuOWWW7BYLHz88cdMmzaNoKCgFvVpMBh46623nMZz6623EhAQwBdffMFjjz1GeHi4it8pIURHYbValSVOQ2Cgqn+JTTlhW4708tLRJ6GHS30l9U1gy+79gG2Zs2dsV5fHFxwkJzmFaK0WzaD16NGD48ePX3b9t7/9LWPGjGHhwoWqDaw+W7duRafTMW3aNOWaXq9n6tSpHD16VJnFq8+WLVvo16+fEkgBxMXFMWzYMDZv3qxc279/P8XFxUyfPt3p/hkzZlBZWcnu3btb3GdDunTpAkCZ/M1SiE6rrKICi8UCqFtBoLyikvSMiwD0ie/hcvLb/g4VCOyBn6tkBk2I1mtRgHbNNdewYcOGej978sknuf766926By0tLY3Y2FgCApxPQdkDpJMnT9Z7n/3kab9+l9eo69+/P5mZmVRUVCjPAC5rm5iYiFar5cSJEy3u0666upqioiKys7PZtm0by5Yto0uXLnTr1q3BrzkvL4/jx48r/5w9e7bBtkKIjscxMFGzSPrJM+eVn7f9ese53F+/3nWHDE6oVJMzWAI0IVqtRUuc99xzD/fcc0+Dnz/55JM8+eSTLg+qIfn5+fUuBdqv1Zf6A2ynS00mU5P39ujRg/z8fHQ6HaGhoU7tvL29MRgM5Ns3vLagT7tt27bxl7/8RXnfr18/FixY0OghgdWrV/PRRx81+LkQomNzVw3OE2fOK6/7xLu2vAkQYggkKjyUnPxCJfhzdTnW388PnU6H2WyWVBtCtJBHHR80Go1Oe+DsfHx8lM8bug9o1r1Go7HBgMnHx8epXXP7tBs6dCj/+Mc/KCsrY9++fZw8eZKqqqp6n2U3bdo0rrrqKuX92bNnefHFFxu9RwjRcbjrBGfambpZrr7x3VXps3d8d3LyCykpKycnv5DoiDCX+tNoNBgCAygsLqG0rEyVoE+IK4XL56gnTJjA+fPnm26oAr1eT3V19WXXTSaT8nlD9wHNulev11NTU1NvPyaTyaldc/u0CwsLY8SIEUyYMIHf/va3jBs3jieffFKZlatPREQEiYmJyj9xca4vZQgh2o5zFQF1lzjteqkYoNXXvyvsed/MFgtll2z7EEI0zOUAzd15zxyFh4fXG8zYr9lzsV3KYDDg4+PTrHvDw8Mxm80UFhY6tauurqakpERZvmxJnw2ZMGEClZWV7Nixo9F2QgjP5bjEGRSgThUBi8XCyfQMAGK6RBJYW+zcVX161gVoaSoFaHJQQIjW8ahanL179yYjI4Nyh8LDYEu/Yf+8PlqtloSEBFJTUy/7LCUlhZiYGPz9bSVS+vTpA3BZ29TUVCwWi/J5S/psiH0J9NKvRwjRediXOAP9/dHpdKr0mXExh8oq288PtZY3wV0zaA6pNiRAE6LZPCpAmzBhAmazmdWrVyvXTCYTa9euJSkpiejoaACys7MvO+147bXXkpqa6hRQnTt3jgMHDjBhwgTl2rBhwzAYDKxatcrp/lWrVuHr68vYsWNb3GdRUVG9M41r1qwBbCdEhRCdj9Fkwli75SFY1f1n6h4QsOsZ2wUvL1sQmZau0gyaw9ddIrnQhGg2jzokkJSUxMSJE3nnnXcoKiqiW7durFu3jqysLBYsWKC0e+mllzh48CDbtm1Trs2YMYM1a9awYMECZs+ejU6nY8WKFYSGhjJ79mylnV6v54EHHmDRokU8++yzjBo1ikOHDrF+/Xrmzp2LwWBocZ/r169n9erVXH311cTExFBRUcGePXv48ccfGTduHMOHD3fzd04I0R7cdYLTKUBLUG8GzcvLi/juMaSdOc/Z8xcxVVe7nF9NZtCEaB2PCtAAnn76aaKjo/n2228pKysjISGBV155heTk5Ebv8/f3Z/HixSxZsoSPP/5YqZs5b948QkJCnNra62MuX76cnTt3EhUVxbx585g5c2ar+hw8eDBHjx5l06ZNFBYWotPp6N69O/PmzeO2225T6TsjhOhoit0WoNWd4Oyj4hInQO+e3Uk7cx6zxcKZcxdI7OXawaSggAA0Gk1tRQUJ0IRoLo8L0PR6PY8++iiPPvpog21ef/31eq9HRUXx/PPPN+s5t9xyC7fcckuT7ZrTZ79+/ZzynwkhrgzOJziDVOs37bRtBs3fz5eY6EjV+gVbwPdNbSGUtDPnXQ7QdDodgf7+lJaXU1JaqsIIhbgyeNQeNCGE8CTOM2jqnOAsK6/gYo4tKXfvnrFoter+GO/VM1Z5feZcpip92mcPjdXVVNXuyRNCNM7l/7Lvvvtup31ZQgghbIodZoyCg9SZQTtz/oLy2jGYUkt895h6n+UKp5JPMosmRLO4HKA9/PDDBAcHqzEWIYToVOwBmq9ej762woirzpyrC5riuzdcx7e1oiPD8NXbxpp+/qIqfRrkoIAQLSZLnEII4QbVNTWUV1YC6s2egfOsVkKPmEZato5Wq6Vn964AZGblKGlCXOGUakMCNCGaRQI0IYRwA8dARM0ST44zaD3dEKBB3cycxWLlXGaWy/05pdqQXGhCNIuqpzjNZjO5ubnk5eU1WM+yqXQYQgjRGTgGIqrOoNVu3A/w8yUqPFS1fh3FOwR+Z85ddDkZrpR7EqLlVAnQLBYLn3zyCZ999hmlTWwA3bJlixqPFEKIDs35gIA6M2iVVUYuZNtOcMb36IZGo1Gl30vZlzgB0lU4KKD38cFX70OV0SR70IRoJlUCtLfffptly5YRGhrKlClTCA8PV63mnBBCeKLiMvVPcDoGS/FuWt6ES05yqpZqI4gqYz7lFRXUmM14ye8IIRqlSoD27bff0r17d955550mC4QLIcSVwB1LnE4nON0YoMV2jcLLS0dNjZkzKp3kDA4MJCc/H7Atc4bJ6X8hGqXKIYHKykrGjh0rwZkQQtSyL3HqfXzwVSvFhuMMWnf3BWheXl50j4kG4FxmFjVms8t9yj40IVpGlQAtISGB/Nq/GQkhxJWupqaGsooKAEJUPSDgOIOmfg40R/YAsLqmhgtZuS73FyypNoRoEVUCtHvvvZft27dz/PhxNboTQgiPVlJerrw2qHRAAOr2g+n1PnSNClet3/r0VLmigEFSbQjRIqrsQRs7dix/+MMfeOqpp7jqqqvo1asXAQH1152bPHmyGo8UQogOy+kEp0pF0o0mExlZOQDEd++qeg3OSyU4pdq4wLVjhrnUX7AscQrRIqoEaCaTiV27dlFcXMzXX38NcNnxb6vVikajkQBNCNHpOQZoai1xnsvMwmKxAu4p8XQpxxm0sxmuHxTw9/NDp9NhNpsl1YYQzaBKgLZkyRI2bNhAr169uPbaayXNhhDiiuZ8glOdJc62OsFpZz8kAKhSTUCj0WAIDKCwuITSsjLlL+1CiPqpEqBt2bKFxMRE3nzzTby8VC1OIIQQHsc5Sa1KKTba6ASnnb+fL5HhIeTmF3EuM1uVPoMDgygsLsFssVBWUUFQA1thhBAqHRIwmUwMHTpUgjMhhABlCU/v7Y1epRQb6W1Qg/NSPbp1AaCopJSS0vImWjdNUm0I0XyqBGiJiYlkZGSo0ZUQQng0s9lMae0pzuCgINWW8c5esM1i6XQ6YrtEqtJnU+wBGsD5CyoXTZcATYhGqRKgzZ07lz179rBr1y41uhNCCI/lGHiotbxpsVg4X7sPrFuXyDZbrXAM0M6qsA/NMeVIiaTaEKJRqvxX/uOPP5KcnMzTTz/NsGHDGkyzodFo+OUvf6nGI4UQokMqccMBgdyCIqqMJsA5aHI3x2epsQ9NZtCEaD5VArQPP/xQeb1v3z727dtXbzsJ0IQQnZ07iqQ7prlovwDN9Rm0oIAANBoNVqtV9qAJ0QRVArTFixer0Y0QQni8IjckqXUMjuLaMEDrFh2JTqvFbLGoEqDpdDoC/f0pLS+XAE2IJqgSoCUnJ6vRjRBCeDx35EBzDI7acgbN29uLmC6RnL+QzbnMLFVylxkCAyktL8doMlFlMqlWSF6IzkaVQwI//fQTS5YsabBgel5eHkuWLOHo0aNqPE4IITqsktoZNB9vb3z1elX6dNz/FRfbdgEa1AWElVVG8gqKXO7PqeSTw2yjEMKZKgHa8uXL2blzJ+Hh9RfvjYiIYNeuXaxYsUKNxwkhRIdkNpspragA1E2xYZ9B8/PVExEWokqfzaV2RQGDHBQQollUCdBSU1MZPHhwo22GDBlCSkqKGo8TQogOqaS8HKvVVi/TcabIFdXVNVzIygVss1ltXR7Jrak2JEATokGqBGhFRUVEREQ02iYsLIzCwkI1HieEEB1ScYn6Jzgzs3MxWyxA2+4/s3NOVqtyqg1Z4hSiQaoEaIGBgeTk5DTaJjs7Gz8/PzUeJ4QQHVJhaYnyOsTg2Sk27OJUTrXhGLgWS7JaIRqkSoCWlJTEtm3byM6u/29X2dnZbN++nYEDB6rxOCGE6JAcZ9BCggyq9Ol8gjO6kZbuERURit7H+7KxtJaPtzf+vr6Ac0oSIYQzVQK0O++8E6PRyGOPPca6devIy8sDbKc3v/nmGx599FFMJhOzZs1S43FCCNEhFblhBq29cqDZabVa5aBAxsUcasxml/u0z6JVVlVhqq52uT8hOiPV8qA99thjvPnmm7z88ssASrZo++v58+dLvjQhRKdWWDuD5uerR69Sfi/HFBvtscRpf+7J9Axqasxk5eQR29W1mbwQQxAXc20HH4pKS4kKC1NjmEJ0KqpV3J05cybDhg1j1apVpKamUlZWRmBgIP379+fWW28lISFBrUcJIUSHYzSZqKyqAtRb3oS6GbSwEANBgZfXOG4Ljqk2zmZkuRygOe1DKymRAE2IeqgWoAH06tWLJ598Us0uhRDCIzjupwoxqBOglVdUKslh22v27NJnq3GSM8QhQCuSgwJC1EuVPWhCCHGlKypx2H+mUooNx2CoPQM0xxk0VVJtOAVoJY20FOLKJQGaEEKooNhpBq1zpNio79nnVM+FJjNoQtRHAjQhhFBBYYn6S5ztnWLDLizEQICfLTWGGqk2vLy8CPT3B2x70OwHyoQQdSRAE0IIFdiXODUaDYYAdTbzn3Uqkt5VlT5bQ6PR0L02QMzKyaO6usblPu2zjMbqaqqMJpf7E6KzkQBNCCFcZLValSVOQ2AgOp1OlX7ts1UajYbYrlGq9Nla3WNsy5wWi5XMrMYrxzSH7EMTonESoAkhhIvKKiqUBK5qHRCwWq1KgNY1OgIfb29V+m0tx4MCauxDC3Eq+SQVBYS4lARoQgjhoiI3HBAoKCqhvKISaN8DAnaOe+DOZ6p9klMCNCEuJQGaEEK4qNjNBwTao8TTpexLnADnL7h+UMAxma/MoAlxOdUS1VZXV7N9+3alioDFYqm33cKFC9V6pBBCdAiFTjnQ1AnQnFNstN8JTmUMKi9xBgUGKCUBi0okQBPiUqoEaFlZWTz55JNcuHCh0ePSGo1GAjQhRKfjniLpHSNJrV2wIRBDYAAlZeWqLHHqtFoMgYEUl5ZSXFqK1WpFo9GoMFIhOgdVArQ33niDzMxMbrrpJqZOnUpkZKRqp5iEEKKjsy9xent54e/rq0qfzkuc7Zdiw06j0dA9JpqjJ06TnVeA0WRyuSB8cFAQxaWl1JjNlFdWKrnRhBAqBWgHDhxg+PDh/PGPf1SjOyGE8Bg1ZjMl5eWAbf+ZWrNA9gDNx9ub6MiOUUy8ezdbgGa1Wsm4mEOvuFiX+gsJCuJc7evi0lIJ0IRwoMohAYvFQp8+fdToSgghPIpTiSeVUmyYzRbOX7QtI3aPiUar7RjnuZz2oalQUSBETnIK0SBV/qtPSkri7NmzanQlhBAepcgNJzgv5uRRU2PLq9YR9p/ZOZ3kVCPVhkFyoQnREFUCtIcffpj9+/ezZcsWNboTQgiPUVhSrLwO7WQ1OC/VvZv7ktXKSU4hnLVqD9pHH3102bWhQ4fy3HPPMWTIEPr27UtAPbXoNBoNv/zlL1vzSCGE6JAKi+tOcIYGq5ViwzFA6zgzaI5LnOdVCNAC/f3RabWYLRaZQRPiEq0K0D788MMGPzt48CAHDx6s9zMJ0IQQnY19Bk2j0ai2B83pBGc7Fkm/VFBgACGGIIpKSlVJVqvRaAgOCqKguJji2vyZHWW/nRDtrVUB2uLFi9UehxBCeByLxUJh7dJcsBuKpEPHqCLgqEe3aIpKSsnNL6Kyyoifr96l/uwBmsViobSiguDAQJVGKoRna1WAlpycrPIwhBDC85RWVGCuLZIeGhysWr/2AM0QGECwoWMFLN27deHwsZOAbZmzb0IPl/pzTOxbXFIiAZoQtVQr9WRXXFzMyZMnKS8vJyAggN69exOs4g8uk8nE+++/z/r16yktLaVXr148+OCDjBw5ssl7c3NzWbJkCXv37sVisTB06FDmz59PTEzMZW3XrFnDsmXLyMrKIjIykjvuuIPbb7+9VX1mZ2ezdu1adu/eTUZGBjqdjvj4eO69915GjBjh2jdECNFuCovVPyBQZTSRlZsP2PafdbTs+pfuQ3M1QHP8vhWWlNCjnp/HQlyJVAvQLl68yOuvv87333/vVO5Jo9EwduxY5s+fT9euru+l+Otf/8qWLVuYOXMmsbGxfPPNNzz11FMsXryYwYMHN3hfRUUFjz/+OOXl5dxzzz14eXmxYsUK5s+fzwcffOAURK5atYrXXnuNa6+9llmzZnH48GEWL15MVVUVP//5z1vc544dO/jPf/7D+PHjmTx5MmazmW+//ZYnn3yShQsXcvPNN7v8fRFCtD13HBDIuOBY4qnjnOC0665yLrRLAzQhhI0qAVpmZiaPPfYYhYWFxMbGMmjQIEJDQyksLOTIkSPs3LmTlJQU3nzzzXpnq5orJSWFTZs28cgjj3DXXXcBMGnSJObMmcPSpUtZunRpg/euXLmSjIwM3n77bfr37w/A6NGjmTNnDsuXL+ehhx4CwGg08t577zF27FheeOEFAG655RYsFgsff/wx06ZNI6h2I3Bz+xw2bBj/+9//CAkJUcZz6623cv/99/P+++9LgCaEh3JKsaHSSoFzio2Otf8MnMekSrJahwCtSAI0IRSqHJd56623KCoq4re//S2ffvopCxcu5OGHH2bhwoV88sknPPnkkxQVFfHWW2+59JytW7ei0+mYNm2ack2v1zN16lSOHj1KdnbDx763bNlCv379lEAKIC4ujmHDhrF582bl2v79+ykuLmb69OlO98+YMYPKykp2797d4j7j4+OdgjMAHx8fxowZQ25uLhUVFc3+HgghOg6nGTSVljjPdvAALbZrlPJajVQbeh8fpX6p4/dTiCudKgHavn37uOqqq5g2bdpl+yU0Gg233norY8eO5ccff3TpOWlpacTGxl6WY80eIJ08ebLe+ywWC6dPn6Zfv36Xfda/f38yMzOVICktLQ3gsraJiYlotVpOnDjR4j4bUlBQgK+vL3p9w6eg8vLyOH78uPKPVGwQomOwWq0U1O5BCwoIwNtLnR0jZztoig27AH8/wkNts4VqBGhQtzxcaTRSZTSq0qcQnk6VnygWi4WePXs22iYhIYEDBw649Jz8/HzCw8Mvu26/lpeXV+99JSUlmEymJu/t0aMH+fn56HQ6QkNDndp5e3tjMBjIz89vcZ/1ycjIYNu2bUycOLHRo/mrV6+uNzGwEKJ9lVdWUl1TA6g3ewbOy4aO+706kh4x0eQXFlNQVEJZRSWB/n4u9RdiMJCZnQPY9qF1jYxUY5hCeDRVArS+ffuSnp7eaJszZ86QmJjo0nOMRiPe3t6XXffx8VE+b+g+oFn3Go1GvBr4m7CPj49Tu+b2eamqqir+/Oc/o9frefjhh+ttYzdt2jSuuuoq5f3Zs2d58cUXG71HCOF+Tic4VTogAHUBWlREmMs5xtyle7cuHDhqW004n5lF/z7xLvUXaqjbvycBmhA2qixxzp07lx9++IE1a9bU+/nq1avZs2cPDz74oEvP0ev1VFdXX3bdZDIpnzd0H9Cse/V6PTW1fyuur61ju+b26chsNvPcc8+Rnp7O888/T0RERL3PsouIiCAxMVH5Jy4urtH2Qoi24XjiUK0DAkUlZRSXlAEdc/+ZnePY1FjmDDU41uSUfWhCgEozaPv27WPo0KG8+uqrLFu2jEGDBhEWFkZBQQE//fQTGRkZjBw5kn379rFv3z7lvpaWfgoPDyc3N/ey6/Zlx4aCHYPBgI+Pj9KusXvDw8Mxm80UFhY6LXNWV1dTUlKiLF+2pE9Hf//739m9ezfPPPMMw4cPb/TrFUJ0XAUOG9rDDOoEaI7lk+I6YIoNO+dUGyoUTXdMtSEHBYQAVArQHGtznj9/nvPnz1/WZs+ePezZs8fpWksDtN69e3PgwAElCa5dSkqK8nl9tFotCQkJpKamXvZZSkoKMTEx+Pv7A9CnTx8AUlNTGTt2rNIuNTUVi8WifN6SPu3efPNN1q5dy/z587nhhhua/XULIToedyxxdtQi6ZdyTlbreqqNQH9/vLy8qKmpkVxoQtRSJUBrq9qcEyZMYNmyZaxevVrJg2YymVi7di1JSUlER9t+aGRnZ1NVVeW0HHjttdfy9ttvk5qaqpy8PHfuHAcOHGDWrFlKu2HDhmEwGFi1apVTgLZq1Sp8fX2drjW3T4D//ve/LFu2jF/84hfMnDlT5e+MEKKt2QMJfz8/9LX7Tl3VUYukX0rtVBsajYZQg4HcggJKy8upMZvxUqmuqRCeSpUAra1qcyYlJTFx4kTeeecdioqK6NatG+vWrSMrK4sFCxYo7V566SUOHjzItm3blGszZsxgzZo1LFiwgNmzZ6PT6VixYgWhoaHMnj1baafX63nggQdYtGgRzz77LKNGjeLQoUOsX7+euXPnYnCYim9un9u2bWPp0qXExsYSFxfH+vXrnb6uESNGEBYW5o5vmRDCDSqrqpR0EO46wdmRZ9B8ffVERYSRk1fAOZVSbYQYgsgtKMBqtVJcWkr4JbkjhbjSqF6L092efvppoqOj+fbbbykrKyMhIYFXXnmlySDR39+fxYsXs2TJEj7++GOlbua8efMuSyI7Y8YMvLy8WL58OTt37iQqKop58+ZdNvPV3D7t+dkyMjLqPYG5ePFiCdCE8CAFDsubYW4okq7T6ega3fgBovbWIyaanLwCikvKKC4tIzjItSLnl57klABNXOk0VsfCmaLDO378OHPnzuXdd991OW2JEKJ1Dh8/zo59+wGYMGokSQ3sf20Ji8XCNbc/jNFoIi62K5+987LLfbrT/73xIV9+swWAD//xLAP79XKpv1PnzvPtjh0AjBw0iJGDBro6RCE8WqvSbDz//PNs3bq11Q919X4hhGhP+UUOM2gqzfTk5BdiNNpS9HTEIumXcjrJqcJBAceDFpJqQ4hWBmibNm3izJkzrX6oq/cLIUR7KigqUl6rtcTpKfvP7NTOhRYcGKiUCpSTnEK4sActLS2NdevWqTkWIYTo8KxWK/m1e9AMAQH41FNNpDUcU2x05BOcdj1iHAI0FXKh6XQ6DIGBFJeWUlRSgtVqvay2sxBXklYHaDt27GDnzp0tvk+2vAkhPFlJeblSbUSt5U3wvBm0bl0j0Wo1WCxW1U5yhhoMFJeWUmM2U1ZRQZBDvkshrjStCtAWLlzo8oPtCV+FEMKTOC5vqnnS0CkHmgcEaD7e3nSJDOdCdh7nL2SrMuMVajCQnpkJ2E7KSoAmrmStCtCmTJmi9jiEEMIj5DvuPwtRP8WGv58v4aHq9etO3WOiuZCdR1l5BUUlpS5XVHCsaVpQXExcTIyrQxTCY6lSLF0IIa4Ujic41ZpBq66u4UK2rc5wj27RHrP3qrvDPjQ1anI6BryOpbSEuBJJgCaEEC1gX+LUarUEBwWp0mdmVg4Wi21/rifsP7Pr3s2xaLoKqTYcqjI4BsJCXIkkQBNCiGYym80UlZYCtmBCp1XnR+hZDzsgYOdcNN31GTRvLy+CA20VCQqLi+VQmbiiSYAmhBDNVFib/gFUPiCQ4aEBmmMuNBVm0KDuZGyN2UxJWZkqfQrhiSRAE0KIZsp3OsGp3kb+sxkXlddx3Tp+DjS7mOgIZRZRrVQbYZccFBDiSiUBmhBCNJPzCc4Q1fp1WuKM9ZwZNC8vL2K6RAIoqTZcJQGaEDYSoAkhRDPluykHmn0GLSIshEB/P9X6bQv2mpyVVUbyC10PqBxPchbIQQFxBWuzAK26upry8vK2epwQQqjKarWSV1gIgK/ehwA/dQKpktJyCottBw/iPGj2zM6paLoK+9BCgoLQ1qYZkRk0cSVrdYA2a9YsPvvsM6dre/bsYcmSJfW2//TTT5k6dWprHyeEEO2qorKSyiojABGhoarlKjub6Zn7z+x6dFP3JKdOpyPYYEtfUlhSgtlicblPITxRqwO0rKwsyi45YXP06NHLgjYhhOgMcmtnz8AWoKnFuUi6J86gOSSrVe2gQAgAFouF4tq0JkJcaWQPmhBCNEOeQ4AWqWqA5jCDFut5M2iOS5znVagmABAuBwWEkABNCCGaI89pBi1MtX49fQatS1Q4Xl46QJ09aCAHBYQACdCEEKJZ8gpsAZqXTkdwUKBq/aZnXABsWfS7RkWq1m9b8dLpiO0aBUDGxWwsKuwZk1QbQkiAJoQQTTKaTJTUnkIPDw1Fq1KJJ7PZQsaFHABiY6LQ6TzzR7J9mdNoqiYnv7CJ1k0zBAYqCXALiotc7k8IT+SZPw2EEKINuWv/2cWcXKpragDP3H9m53hQQI19aFqtltDaWbTi0jJqzGaX+xTC03i5cvP69es5evSo8j4zMxOA3//+95e1tX8mhBCeJq8NTnD29OAA7dKi6SOTk1zuMzwkmLzCQqxWK4XFxUSGqbfvTwhP4FKAlpmZWW/gtWfPnnrbq5U3SAgh2lJugUOAFiYnOC/V3SEX2rkL6hwUiAgN5fiZdMAWIEuAJq40rQ7Qli9fruY4hBCiw7LPoGk1GqcUEK7y9BOcdj0clzhVyoXmOFOZV1ikSp9CeJJWB2hdunjuDxMhhGiuGrOZwpISAEKDg9HpdKr17elVBOyiIkLR+3hjNFWrlwvNodap4xKzEFcKOSQghBCNyK/dBwUQqeLyJtTNoIUGB2EIClC177ak1WrppqTayMFsdj3Vhq9eT6C/P4CyF02IK0mrZtBefvnlVj9w4cKFrb5XCCHaWnZ+gfI6KixctX7LKyrJKygCPHv/mV2Pbl04fTaT6poasnLz6dbF9ZxuEaGhlFVUUF1TQ0l5OcGB6uWfE6Kja1WA9s0339R7XaPR1Pu3HPt1jUYjAZoQwqPk5Ocrr6PC1duonn7+gvI6rpvnbxlxPsmZpVKAFkJ67UG0vMJCCdDEFaVVAdqlBwQsFguvv/46KSkp3HHHHQwePJiwsDAKCgo4dOgQn3/+OQMGDGD+/PmqDFoIIdpKToEtQNNqtU77olx1+lxdgJYQ1021ftuLY03Oc5nZjBk2yOU+wx0OCuQXFtKre3eX+xTCU7QqQLv0gMCnn37KsWPH+OCDD4iIiFCu9+jRg+TkZG6++WYeeOABtmzZwt133+3aiIUQoo0YTSaKSkoB23KbmgcETp+rS1EU36MTBGjd5CSnEGpS5ZDA119/zcSJE52CM0eRkZFMnDiRr776So3HCSFEm8gpqNt/Fq3i8ibAmU42g3Zpslo1GAIC8PH2BuQkp7jyqBKg5ebm4uPj02gbHx8fcnNz1XicEEK0Ccf9Z5EqHhAAOH3WNoMW4O9HVLi6p0PbQ0RYCH6+egDOZ6qTrFaj0SjLymUVFVQZjar0K4QnUCVAi4yMZPv27Rgb+I+nqqqK7du3Exnp+qZRIYRoKzn5jjNo6gVoFZVVXMzJAyChR0ynqLKi0WiIrZ1Fy8zOU61+ZkRoiPI6v6hIlT6F8ASqBGg/+9nPuHDhAo899hjbt2+nuLgYgOLiYrZv385jjz1GVlYWt9xyixqPE0KINmGfQfPx9ibEEKRav+nn6xLUdob9Z3b2ZU6z2czF7DxV+gx32ocmy5ziyuFSLU67u+66i/Pnz/PNN9/wzDPPAM4pN6xWK1OmTOGuu+5S43FCCOF2ZRUVlFdWAhAZFqbqLJfjAYEENwdolRYT6VU5WK1WYvURGLz83PYs55OcWU7vW8vxoIBjTVQhOjtVAjStVsvChQuZPHky69at49SpU5SVlREYGEivXr2YNGkSQ4cOVeNRQgjRJhyXN9XMfwZwxukEZ4yqfdulV+Ww9MK3bCo6TLW1brmxpz6Ku6PGc3vkGLw06p1KBVuyWju1DgqEBQej1WiwWK3kFhY0fYMQnYQqAZpdcnIyycnJanYphBDtIju/bokuSsX9Z1B3QADcM4P2Zd4P/PXc5xitNZd9lm7M4f/Of87XBft4rdccIr0Nqj3X8SRnesbFRlo2n5dOR3hICLmFhRQWl1BdXY137clOITqzVu9B+/LLL+VUphCi08rKrQvQujaQQqi1TtdWEfD38yU6Ut3ZuX9lb+G5s8uV4CzUK5Bp4SO5LWI0gwPilHaHytP5ZerrZBrVm5Vy3E/nGIS6KtJhBjNX9qGJK0SrZ9D++c9/snjxYvr27cvVV1/NVVddRa9evdQcmxBCtAuz2awcEDAEBuLvp96+rcoqIxeybH+5je+u7gnOVXl7+EfGauX9zIhxPBl7C/46vXLtQNkZnj7zKRdMhWSaCph38l0+7vdrgnSuf42GoAAiwkLIKyji9LlMpcSfq6LCwknhFGBbeo6JinK5TyE6ulbPoL3zzjvcc889VFdX8/777/PAAw8we/ZslixZwsGDB7FYLGqOUwgh2kxOQQHm2p9hXSPVnT1zrMGpZoLaYxUZvHTuM+X9YzFT+FPcHU7BGcDQwHg+SpxPD70t7dHpqmyeOfPfeusot4Z9yba4pIyCohJV+nTcA2gvvSVEZ9fqGbTExEQSExN58MEHuXjxItu3b2fnzp18/vnnfPbZZwQFBTFu3DiuvvpqRo4cia+vr5rjFkIIt3Fc3uyicv7G0244IGC0VLPg9CfKsubMiHE81PXGBttH+4Tw/3o/yC9SX6fIXM7m4iN8mf8Dt0WMcXksCXHd2HPwKGCrlhAeGuxyn6HBweh0OsxmM7n5clBAXBlUOSTQtWtX7rzzTu68805KSkrYtWsX27dvZ8uWLaxbtw4fHx+GDx/O+PHjGTduHKGhnp81WwjReWXl1e2v7RqhboB2Kl39AwLvXNzAWaNtzAP8u/NU9+lN3tPDN5K/9JzF46c+AOBv51dylaEf0T4hLo3FcVbw9LkMRgzp71J/ADqtloiQELLz8ykuK6PKZMK3ieo1Qng6VU9xAhgMBiZPnszkyZMxmUz8+OOP7Nixg127drF79260Wi1JSUn8v//3/9R+tBBCuMxqtSozaHpvb0KD1TvlCJB25pzyuk98d9f7q7zAR1nfAeCl0fFCz7vw0TbvR/uEkIHMCB/Nl/k/UGkx8c/MNfw1/h6XxpPgpoMCUeHhZNfuC8wtKKB7ly5N3CGEZ1M9QHPk4+PDuHHjGDduHFarlSNHjrBjxw527tzpzscKIUSrFZeWUllbti46MlL1MkwnzpwHINgQSKQKNTj/kfEVNdj2yz3Y5Xp6+bUscHki9md8V/QTxeYK1hbsZ2bkOIYFJrR6PAkOy7aqnuQMc9iHlp8vAZro9FQp9dQcGo2GQYMG8cgjj/Dpp5+21WOFEKJFLjqm11D5gEB+YTEFhbZSeH3ie7gc/P1QcoJdJccBiPEJ5YEuN7S4jxCvAOZ1u1l5/3rm1y4dGAgKDFCKv9tPcqrB8aBAboHsQxOdX6tn0F5++eVW3bdw4cLWPlIIIdzOcf9ZF5X3n52snT0D6BMf61JfFquFf2auUd4/FjOl2Uubl7o9Ygz/zdnO6apsDpSd4fvSE4w1JLZ6bAlx3cjJL6S4tJz8wmIiwkJa3ZddqMGAt5cX1TU1TlUehOisWh2gffPNN81ua6/LqdFoJEATQnRoF7JzAFsJO7VLPJ1w2n/Ww6W+NhcdIaUiA4BEvxhuDhvW6r50Gi0Pd72JBWc+AeDNC+sYE9S31TN8CT268f3+I4BtFk2NAE2j0RAZFsaFnBzKKiqoqKxUNT+dEB1NqwO0pUuXNqtdRkYGH374IRcuXGi6sRBCtKPS8nKKy8oAiA4Px9tL3W26jjNofRNaH6BZrVY+qD0YADCv281oNa7tWLkpdAjvXNzAqaosDpefZXfpCca1chbN6STn2UxGJQ9waWx2UeG2AA0gOz+f+FjXZiGF6Mha/dMnKSmp0c+Lior46KOPWLNmDdXV1QwaNIhf/epXrX2cEEK4XWbt7BlAt+joRlq2TlptgKbTal3Kgban9CRHKmyzcYl+MYw3uJ7KQls7i/bUmY8B+CR7izoB2jn1DgrYlpxTAVuuOgnQRGem+inOqqoqli1bxvLly6moqKBnz5489NBDXHXVVWo/SgghVHUhJ1t53S1a3XJC1dU1nKmtIhDXvSs+LhT8/iBrk/L6vi7Xq3bS9IbQwXTLDCPTVMCukuOkVV6kj1/XFvfjrpqcXSLqitZn5eU10lIIz6faKU6z2cyXX37J7Nmz+fDDDwkICGDBggV8+OGHEpwJITo8q9VKRpYtQNPpdESrXCA9PeMCNTVmwLX9Zynl5/m+9AQAsT7h3Bg6WJXxgW0v2s+jrlHef5q9tVX9BPr7KUXg1TzJ6e/nhyEwELCl2jCbzar0K0RHpEqAtnnzZu69914WL15MdXU1Dz/8MP/+97+5+eab0WrbLJOHEEK0Wkl5OWUVFQB0iYjAS6dTtf+00w77z1xIUPvvnO3K6192mYiXRt1xTo8YRZDOVprv64J95FeXtqqfXnG25cfSsgqy89Q7ddmlNnA2WyzkFRaq1q8QHY1LS5wHDhzgrbfe4vjx43h5eTFr1izuuecegoKC1BrfZUwmE++//z7r16+ntLSUXr168eCDDzJy5Mgm783NzWXJkiXs3bsXi8XC0KFDmT9/PjExl+8FWbNmDcuWLSMrK4vIyEjuuOMObr/99lb3uXLlSvbv309KSgo5OTlMnjyZp59+uvXfCCGEqjKzHZc31d9/5niCs3crA7SC6jK+LTwAQLDOn2nhI1QZm6MAnS+3R4zlo+zNVFvNfJn3Aw92bXl+tT7x3dn142HAFpx2iQxv4o7m6RIZwYn0dMC2zKn2TKcQHUWrp7d+//vf85vf/IYTJ04wefJk/vOf//DII4+4NTgD+Otf/8qKFSu48cYb+fWvf41Wq+Wpp57i8OHDjd5XUVHB448/zsGDB7nnnnu4//77SUtLY/78+RQXFzu1XbVqFX/729+Ij4/n8ccfZ+DAgSxevJh///vfre7zP//5D/v37yc+Ph6dyn8zF0K4LjPLffvPAFJPpiuvW3uC88u876m22pb1pkeMwlfrnnqUMyPHocG2r+3zvO8xWy0t7qNvQpzy+sTps6qNrYtDQOaYVFiIzqbVM2h79uxBo9EQHR1Nfn4+f//735u8R6PR8Le//a21jyQlJYVNmzbxyCOPcNdddwEwadIk5syZw9KlSxtN/bFy5UoyMjJ4++236d/fduJp9OjRzJkzh+XLl/PQQw8BYDQaee+99xg7diwvvPACALfccgsWi4WPP/6YadOmKUFoc/sEeP3114mOjkaj0TBp0qRWfw+EEOqzWq3KDJqXlxdR4erM9thZLBZST9qClKiIsFblBTNbLfwvbzcAGjTcGem+vb2x+nDGGRLZWZLKBVMBu0uOc3Vwy06K9k2omyU8cfpcIy1bJiw4WElYm5Wbq+TYFKKzcWmJ02q1cvHiRS5evNis9q7+R7R161Z0Oh3Tpk1Trun1eqZOnco777xDdnY20Q0sTWzZsoV+/fopgRRAXFwcw4YNY/PmzUowtX//foqLi5k+fbrT/TNmzGDDhg3s3r2bm266qUV9AnSRunFCdFj5RUVUVFUB0C0qCp3Ke2fPX8ihvKISgKQ+PVvVx7biFC6abHuurjb0I1avbhB5qTsix7KzxJbS4rPc3S0O0LrHdEGv98FoNCnpRdSg1WqJjoggIyuLiqoqSsvLlYMDQnQmrQ7Qli9fruY4miUtLY3Y2FgCAgKcrtsDpJMnT9YboFksFk6fPs3NN9982Wf9+/dn7969VFRU4O/vT1paGgD9+vVzapeYmIhWq+XEiRPcdNNNLerTFXl5eeTn5yvvz55Vb6lACGFz7kLdXzJ7xLQ8rURTjqWdUV737xPfqj6W5exQXs+OutrlMTXlmuAkIr0N5FaXsK04hWxTEdE+Ic2+X6fT0qdnd44cP8X5C9mUV1QS4K9O5v8utQEa2PahSYAmOqNWB2jtMSOUn59PeD1LD/ZreQ3kxSkpKcFkMjV5b48ePcjPz0en0xEaGurUztvbG4PBoARLLenTFatXr+ajjz5yqQ8hROPOXayrdNKjq3sDtH69e7b4/vSqHCW1Rvfa5Ud389LouC1iDG9fXI8ZC1/m/cCvYlq2PaNPgi1AAziZnsGQpD6qjK2LQxH7izm59O3ZU5V+hehIVE9U605GoxHvepI7+vj4KJ83dB/QrHuNRiNeDZR38fHxcWrX3D5dMW3aNKc8cmfPnuXFF190uV8hhI3RZCKrdrN5cFAQwW446OQ8g9azxfd/mfeD8npmxDiXyzo1120Ro3n34gYsWFmVv5eHut7Yomc7HoY4cfqcagFa14gItBoNFquVzJycpm8QwgO1KkB7+eWXW/1AV4ql6/V6qqurL7tuMpmUzxu6D2jWvXq9npqamnr7MZlMTu2a26crIiIiiJBj5EK4TUZ2NpbaRKrumD0zmy0cr90k3zUqgtBgQ4vur7aaWZ2/F7DNat0S3nRKIbV08QlljKEvu0qOc8FUwL6y04wM6t3s+911ktPb25vI8HCy8/IoKimhvLKSACmcLjqZVgVo33zzTb3XNRpNvRmj7dc1Go1LAVp4eDi5ubmXXbcvOzYUyBgMBnx8fJz2cjV0b3h4OGazmcLCQqdlzurqakpKSpTly5b0KYTouM67ef/ZucwsKiptBxBaM3u2vTiFghpbAfeJwQMJ827b/VbTwkexq+Q4AKvz97YoQOvdM1b5+e+YqFcN3aKiyK7d1nIhO4c+PeOauEMIz9KqAO3SAwIWi4XXX3+dlJQU7rjjDgYPHkxYWBgFBQUcOnSIzz//nAEDBjB//nyXBtu7d28OHDhAeXm500GBlJQU5fP6aLVaEhISSE1NveyzlJQUYmJilM38ffrYpuBTU1MZO3as0i41NRWLxaJ83pI+hRAdk9Vq5WztKXSdTke3KPXzn7l6QOALh+XNGRGjVBlTS0wMGUCQzpdScxUbCg/xh+634a9r3uqAv58v3btGce5CNifTz1NjNqtWoaFbdBT7a3/2Z+ZIgCY6n1ZtZOjSpYvTP9999x3Hjh3jgw8+4N577yU5OZkePXqQnJzML3/5S95//32OHj3Kli1bXBrshAkTMJvNrF69WrlmMplYu3YtSUlJygnO7Ozsy047XnvttaSmpjoFVOfOnePAgQNMmDBBuTZs2DAMBgOrVq1yun/VqlX4+vo6BW3N7VMI0THlFhZSXlveqVtUVIP7T12R4higtfCAQLapiJ3FxwDo4h3CmDY4HHApX60PN4UmA1BpMbGxqPGk4Jey70Mzmqo5l5ml2ri6REairU3ddMGhCoQQnYUqP42+/vprJk6c2OCSXmRkJBMnTuSrr77i7rvvbvVzkpKSmDhxIu+88w5FRUV069aNdevWkZWVxYIFC5R2L730EgcPHmTbtm3KtRkzZrBmzRoWLFjA7Nmz0el0rFixgtDQUGbPnq200+v1PPDAAyxatIhnn32WUaNGcejQIdavX8/cuXMxGAwt7hNg586dnDx5EoCamhpOnTrFv/71LwCuvvpqevXq1ervixCidc6cz1Bex3ePdcszDqfYUvdoNBqS+rZsBm11/l4s2LaN3BoxCl0bHQ641K3ho/g873sAVuXtYVoL9sH17RXHxh22PXSpaekk9Oimypi8axMKZ+XlUVRaSnlFBQGyaiE6EVUCtNzcXOXkYkN8fHzq3T/WUk8//TTR0dF8++23lJWVkZCQwCuvvEJycnKj9/n7+7N48WKWLFnCxx9/rNTNnDdvHiEhIU5tZ8yYgZeXF8uXL2fnzp1ERUUxb948Zs6c2eo+t27dyrp165T3aWlpSs61qKgoCdCEaAdnMhwCtG7qBA6OKquMShb9hB7dCAoMaOKOOharhZV5ewBb5YBbw9t+edNucEAccfpIzhpz+bHsFBnG/GYnyk1yWNZNSTvDzderVwGhW3Q0WbX70DJzciTdhuhUVAnQIiMj2b59Ow888EC9JxerqqrYvn07kZGRLj9Lr9fz6KOP8uijjzbY5vXXX6/3elRUFM8//3yznnPLLbdwyy23NNmuuX0+/fTTUhxdiA6kqKSUgtqauV0iIvB3wynAlBOnMVtsdSwHJzV/cz3A3tJTZJhsB45GB/Whmz5M9fE1l0aj4dbwkbx+YS0Aa/J/bHZONMd9dyknTqs6rpjoKPYdPQpAZrYEaKJzUWW+/Gc/+xkXLlzgscceY/v27Uqh8OLiYrZv385jjz1GVlZWswIeIYRoC2cy6k4Vum1589hJ5fXg/i3LAbYy3/FwwGjVxtRaPwsfoRRQX52/F0szC6gbggLoEWPbH3z81Dmqq+tPY9QaXSIi0NaW5crIyqo3i4AQnkqVGbS77rqL8+fP88033/DMM88Azik3rFYrU6ZMUQqcCyFEezudkam8Toh17/4zgMH9mz+DVlJTwcZC22b8YJ0/14UMUn1sLRXtE8LooD58X3qCTFMBB8rOMDyoeVsz+vdN4NyFbEzV1Zw6m9Gqagr18fbyomtkJJnZ2ZSWl1NcWkqIoWV55oToqFQJ0LRaLQsXLmTy5MmsW7eOU6dOUVZWRmBgIL169WLSpEkMHTpUjUcJIYTLSsvLlRxaYcHBbqkeYLFY+CnVNoMWYgiie8zldYIb8nXBPkxW20zTz8KH46PtGEVfpoWPVEpOrcrf2+wAbUDfBL7dshuAo8dPqxaggS25cGbtKc5zFy9KgCY6DVX/q09OTm5ys74QQrS3kw5peHrHuSd/1rnMLIpLywEY1L8XmtqUEE2xWq1OpZ06wvKm3XWhgwg4p6fcYmRD4SEWdp/RrJxojqdXU9LOcLuKY+oR05XdBw8CcO5iFoMT2z4ViRDu0D5ntoUQoh2dSK8L0NyV4PSQ0/Jm8/efHavI4HilrXj7QP8e9PGLUX1sreWn9WFSWDIAFRYjm4p+atZ9iQk90NXuFTt6XN2DAmHBwUqZpwvZ2dSYzar2L0R7kQBNCHFFKSgqJr+oCIDo8HCCA91TOunHw8eU18kD+jb7vi8dDgfc1oFmz+wca4F+VVsjtCm+vnoSetr2+Z05n0lllVG18Wg0Grp37QJAjdnMRSmeLjoJCdCEEFeUE2fTldd93JSWwWq1sq82QPPV+zCgb0Kz7qu0mFibv992n9aHSWEdb+/u0IB4utfmQNtTepKLpsJm3TegdpnTYrE6lb9SQ4+udbOM5y5ebKSlEJ5DAjQhxBXDarWSVru8qdFo6N2ju1ueczYzi9z8IgCSBybi7d287b4bCw9TZrEVVp8Umkygztct43OFRqNRZtGsWFmT/2Oz7huYWHegwDH9iBpiu0Qre/wkQBOdhQRoQogrRkZtOgaw/VJ3R3JagH2H6pY3Rwzu3+z7vqwtpwQd63DApW4JG6G8Xp3/Y7Pyjw1xWOY9ePSEquPx1euJCrMl8i0sLqG4tFTV/oVoDxKgCSGuGCknTymvk9xYXs1x/9mIwf2adU96VQ77ymwb6Hvqo0gO6OmOoakiRh/GyCBbXrdzxlwOlac3eU9cty6EBtvSmRxKScNiaV6i2+aKd8hld8Yhx50QnkoCNCHEFaGyqkqpvemn19PTDbU3wXn/WYC/H4nNzPllr7sJtsMBzU3L0V5udTgssLoZhwU0Go0yi1ZWXsHps+oGUY7VIBxrrArhqSRAE0JcEY6fOaPM2iQmxKPT6dzynFPpGRQW25bYhg5MxKsZz6mxmpUTkV5o+Vn4iCbuaH/XhwzGT+sDwLcFB6mymJq8JznJYZkzRd1lzlCDQUlSezE3l4qqKlX7F6KtSYAmhOj0rFZrmy1v7t5XlxtsVPKAZt2zvfgYeTW2oO7akAGEe6tf2UBt/jo9N4YOAaDMUsXmoiNN3pM8oC4f3MEj6gZoAPGxdbOi6ZmyzCk8mwRoQohO79yFixTVbhyPiYpyazmgnT8eUl5fNXJws+753EMOB1xqWguXORN7xeGrt826qT2DBs41Vc+cl2VO4dkkQBNCdHqHUlOV10P6ua8UUFl5BQeP2ioIdI+Jpke3Lk3ec9FUyM5i2561rj6hjDM071BBRzA8MIEYH9vpye9LTpBtKmq0vZeXFwP72Q4XZOcWcDE7T9XxRIWHK1UFMrKyMFVXq9q/EG1JAjQhRKeWV1hIRm0x7eDAQLcdDgDYc+Ao5tpSQ+NGNG/2bGXeD1iwpamYHj4KncZzfixrNVpuqd0vZ8HK1wX7mrxnqEO6jX0/pTbSsuU0Go1ymtNsschhAeHRPOcngRBCtILz7Fk/t56O3PnjYeX11aOGNNm+xmrmy9rTm1o0HrW8aXeLw4GGr5qRE21kcpLy+ocDTe9baynH2qppDjVXhfA0EqAJITqt4rIypTC63seHxIR4tz3LbLawc69t/5mv3oehA5teSt1ZnEp2dREA44OTiPYJcdv43KW7PoJhgbZSVqersjlSca7R9oP69cLfz1YhYc/BlGYluW2JLhERBAUEAHA+K0tOcwqP1bz6I0II4YH2HTmiBACD+vbF28t9P/IOH0sjv7AYgNFDB6L38Wnyni8cDgfcHjFGtbFYrVbyzpRw4UgeBedKqSwxYbVY8Q30wT9UT2TvELoNCsfPoFfledPCR7K/Nsnuyrw9DAqIa7Ctl5cXwwYmsmPvIQoKizmVnkHvePVKbmk0GnrH9eBAyjGsViunzp1jUN/mF6sXoqOQAE0I0SkVl5Zy/Ew6AD7e3m49HACwaUfdKcbrx49spKVNlqmQbcUpAER5B3NVsOuHA2pMZk5syeDIN+mUZFc03PDbs2i0GnqOiGbQz+KJ6h3i0nNvCh3C386vpMJi5OuCffwm9pZG64iOHDqAHbWzjXsOHlU1QAPo27MnB1JsBy/S0s9KgCY8kixxCiE6pR8dZs+G9OvXrBmt1rJYLHy30xageXt5MX5UcpP3LMvZqRwOuC1iNF4a1xLnnv0xm/89uY1dH6U0HpzVslqsnNmTxepnd7N5yUEqClu/FBig8+XmsGEAVFpMfJ3f+GGB0UPr8sP9cOBoq5/bkPCQEMKCgwHIysuT2pzCI8kMmhCi08kpKFBmz/Te3gxOdO8Myk/HTpKbXwTA6GEDCQzwb7R9pcWkLG96aXTMjBzX6mebKqrZ8d5RTn9/0el6zIBw4sd0IbpvKIERfmg0UFVqoiSrgoyf8ji5PZPKYlv2/1O7LpL5Ux7jHxpE3PDoVo3jzshxfJa3G4AVuTu5M3JcgwcyEnp0IyIshLyCIvb/lIqpuhofb+9WPbchifE92X3QNkt37NRpxiQ3fWhDiI5EZtCEEJ2K1Wpl5779yvvhA5u3H8wVG7bX1dG8oRnLm2vz91Fsts1yTQpNJsK7dYlzCzNKWfXMbqfgLHZwBNP/bxw3/3EU/a/vQVj3IHz8vPD29SIo0p9ugyIYfXc/Zr8xkXFzktAH2gKjqtJqNry2n73LT2C1tHzjfqJ/N6XA+8mqLA6Un2mwrUajUWbRqowm9qucbgMgMT4ebW2AeOz0acwqF2cXwt0kQBNCdCqnzp3nYm4uACFBQQzq26eJO1xTXV3Dui22mSMfb2+uGT200fZWq5V/52xX3v886ppWPTfzpzxWP7ub4ovltmf7ezHhsSFMWjCCiJ7BTd6v89KSdFMcM1+9hrgRdbNmh1ad4rvXD1JjMrd4TI4zgf/L3dVo2/EO36etuw+0+FlN8ffzo2dtTrTKqirOSukn4WEkQBNCdBpGk4kd++tmz8YNG+q2ouh22/ccpLikDIAJ44YRFBjQaPs9pSc5VZUFQHJATwYEtHyD/Jk9WXz79x+prrIFUWFxQUx/6Sp6XxXT4jxvvgYfbvjNUMb8oj/2W8/syWL9q/uoMbYsSLsxdAghOtvXv6HwEAXVZQ22HTNsoHKqdtsPB1RPtwGQ1Luu5qpjLVYhPIEEaEKITmPn/gNUVFYC0CMmhriYGLc/86sNdbNht9w4vsn2H2V/p7y+uxWzZye2ZvDd4gNYamwBTdzwKKY9NxZDdOP73hqj0WgYOKUnN/5uOF56W0B74Uh+bRBY0+x+9FpvpkeMAqDaaubz2j1p9Qnw92PEkP4A5OQVcOJ04/nTWqN7ly5KTrRzFy9SUtZwwChERyMBmhCiUzh38SKpp225uLy9vLh25Ai3Vg0AyCsoYndt9YCoiDBGDhnQaPuU8vPsKjkOQIxPGNeFDmrR807uvMC2d37CPtnU55puXP/EUCWoclWPoVFM+cNIvP1sM1sXUwpsM2ktWO6cGTkOLbbv+39zdmC0NFwP85oxjsuc+xts11oajcZpFu3w8eOqP0MId5EATQjh8SoqK9m0uy7p67ihQ5WZE3f67OvvlM3nP7v+KnS6xn+kvpe1UXl9X5fr8G5Bao30vdlsXXqY2swcDJgUxzUPDULbxDNbKrpvKDc/PRIf/7ogbfOSQ1jMzdtkH6sP54ZQWx3S/JrSRutzOu5D2/K9+gEawIDevfGqXeZOOXWaKpPJLc8RQm0SoAkhPJrFYmHDrl1U1pb06d61i9OsibsYTSa+WGtbrtRptdw29bpG25+qzGJT0U8ARHobuDW86dOedhmHcvnujQPK6cp+13dnzL390WjdM0MY2SuEKX8YqczMnf0xmx3vH232PrF7oycorz/J3orFWn9wFx0RRlJfW/mttNPnSD9/wbWB18NXr1dKfNXU1JBy8qTqzxDCHSRAE0J4tO8PHSIzOweAAD8/bhg71u1LmwDrt/5AYbEtAep1V48kOiKs0faOs2e/iJ6AXtu8vF9ZqQVsWLRf2XPW++oYrrpvgNu/xsheIdzw5DC0OttzTmzJ4MflJ5p176CAOIY71OfcUdJwGo1J19aVuPp26/cNtnPFkMS6Kg0/HT+B2dzyE6pCtDUJ0IQQHutIWhoHj9l++Ws0Gm68ahx+vg2XGFKLxWLh0y++Ud7PvvWmRtufqLjANwW2VBIhugBmRoxt1nMKzpey/tV9mE22Gaieo6K55uFBbps5u1TsoAgmPDaE2i1lHFp9mpQNZ5t1773RE5XXH2Z912C7G68ZrQSb6zbvdstpzhBDEPGx3QAor6wk9UzDOdqE6CgkQBNCeKTT5zPY/mPd/qbxI4YTExXVJs/euH0vp8/a8moN6t+bQf0aX1J9/cJarLWbx+7vej3+uqaLlJflVbLulb2YKmynKLsNimDivGTV95w1JWFMV8b9Mkl5v+ujFNL3ZjV53zXB/Yn3tf372F92mj2lafW2iwwPZfhg22nOjIs5pJw4rcKoLzcsqe5r2HfkqMyiiQ5PAjQhhMc5df4863fsUGZbkvv3Y2Af9yaktTObLbz3n5XK+4d+Pr3R5cb9pafZXlsUvYt3CLMjr2ryGVWlJr55eS8VBUYAIhKCueE3Q9F5tc+P7KSb4hgyzbZkiRU2LzlEVmpBo/doNVoe6nqj8v7NC+sanB2bMrFuRnHtd40nuG2t6IgIJe1KWUWF5EUTHZ4EaEIIj3Ls1Gk27NiJpfaXfd+ePRmbnNxmz/9m8y7O1G5mH5LUh9FDBzbY1mK18I/M1cr7R2ImN7n3rLqqhvV/30fxBVuFAEMXfyb9fjjevu1bOnnErL70GW9bJjRXW9jw2n4KMxvPKzYpdCgJvrYqBQfKzvB9af172CaOG45ebyvHtfa7XVRWGVUceZ1Rg+vSmuxLSaG6pvk53oRoaxKgCSE8gsViYfeBg2z+4QclOOuXEM91Y0a3yaEAgLLyCt74cIXy/uF7bmv02Svz9/BTuS0Bay/fLtwSPqLR/i01Fr574yA5J4sA8AvRM2XhSPyCm14SdTeNRsP4uQPpNigCAGN5Nd++spfywqoG79FptPyq6yTlfUOzaEGBAdx0zWjA9j3esO0HlUdvExkWRnxt+aeKykoOHjvmlucIoQYJ0IQQHV5peTmrv9vMAYdfqIP69mXi6NFotW33Y+zdf6+koLAYgInjRjAyOanBtkU15SzO+Fp5v7DHDHSahsdqtVrZ/t4Rzh+w1RH19vNi8lMjCIpqfYUAtWm9tFz/xFDCe9qKu5flVfHtKz9iqmg4Ge2NoYPp7dsFgMPlZ9lUdLjedrffXHeo4LOvGz5U4KoxQ4YoRdT3pxyjtLzcbc8SwhUSoAkhOiyLxULKyZOsWPsNF3JsqTQ0Gg3jRwxn/IjhbTZzBnAoJY1lq9cDoPfx5om5sxttvzhzDUVm2y//KaFDGRXU+B65H5efIG2b7eCB1kvDjb8dpgRCHYmPnxeTnhpBYKQfAAXnStm46ADmmvpznWk1WuZ3m6q8fy3jq3qrCyT1TaBf7zgAjqWd4Uiqe/aIhQYbGJTYFwCz2cyu/eoXahdCDRKgCSE6HKvVSmZ2Np+v38CWPXsxVtt+oQf6+3Pr9dcxqG/fNh1PRWUVf371bSy1iWIfuOtWYqIjG2y/o/gYX+TZlukCtHqejJ3WaP8/fX2GQ6trTy9qYOJjQ4hJCldn8G7gH6Jn8oIR6ANt++kuHM1n21uHlUS6l7o2OIkxQbZ/ZxdMBXyavfWyNhqNhjumXq+8/9dnX1/WRi0jBg7Ez9e2bHzq/HnSMzPd9iwhWksCNCFEh2GxWDiTkcGXGzayatN35BbUnRTs0zOOWTdPabNUGnZWq5UXFr1HZpZt6XFw/9784o6bG2xfVFPOn9OXKe+fiL2FKJ/gBtunbcvkh3/XJXIdNyeJ+NFdVRi5e4XEBDLp98PR+dh+jZzadZE9y+qvdanRaPhd91uVGp3vZm0k21R0Wbsp140jMjwEgC279nH6nHsCJ72Pj9PBkq179koJKNHhSIAmhGhXVquV3IICdh88yMerVvPNtu1k5eUpn4eFBHPr9ddz47hx6H182nx87/13FRt37AUgwM+Xv/zuIaW246UsVgvPnV1OXo2twsBVhn6NJqU9tz+Hbe/8pLwfdkdvkm6MU3H07hXVJ5Tr5idjX2n+ac0ZjnyTXm/bPn5duSPS9r2otJh48dxnlx0Y8PH25uczpijv/7VijVvGDZAYH0+PrrZAuLyykp37Gq4ZKkR7kABNCNGmrFYrRSUlHD9zhs0/7OHjlav437pvOZByjIrKSqVdaLCBG8aN5c7Jk+kW3bazZnbLVq3nnU+/BGyzQC8ueITYrtENtv8g6zs2Fx0BwKDz47m4WQ3ukzt/IIeN/9yvLAsm3RTH0Bm9Vf4K3C9ueDTj7h+gvP/+02Oc/v5ivW3nx9xMhFcQANuKU1hbcHmB9BlTJhAcZCt0v27Lbk6mZ7hh1LZ/nxNGj8LH27ZMe/xMOselwoDoQNo3sY4QolOyWq1UVlVRUVVFWUUFRSUlFJWWUlRSSn5REcYGlpO0Gg1x3brRv1cCcTExbXoIwJHVauXjz9ayxCGlxvz77+TqUckN3rO9OIUlF2zlnzRo+L/4nze4tHluvy04s9fX7DWuK2Pv7d9uX6+r+l/fg4qCKg58eQqssOXNQ/gF+9C1v/M+OoOXP3+Km8kTpz4A4JXzXzIyqLfT98nfz5d775jKGx+uwGKx8vr7y3j9hd+5ZdyB/v5cPXw4331vqwG6dc9eIkJDCQ8JccvzhGgJCdCEUJl92Ub5f9sb5Zq1rqHyWrmutLPdeWkfju2bfIYVpbyQ/bXjkpLjvVaLBYvFitlixmKxYrFasDR4zUJ1TQ3V1TWYqqsx1VTXva6uVgKz5tZU1Ol0xEZHE9cthoTu3fFvg1qajamsMvLKmx/z9cYdyrW5d0/nF7c3vO/sUFk6vzv9sfL9fiRmEuOD60/Bkb43i+9eP4jFbGubMKYr1z4yuM3qa7rLsDv6UF5QxYmtmVhqrGx4bT9TnxlNeJzzSdSJIQOZFJrMt4UHKTZX8Iczn/J231/hpalbNp516438b80msnLz2b3vJ3b9eJhxIwa7Zdz9EuK5mJvDsVOnqTGbWbdtO7fddJNyiECI9qKxuqMyrXCb48ePM3fuXN59910SExNV63fP4Z8oLS/Dav+lrvxet9b9olcuW6n7U2N73XgwUt+9dX0ofTcQjNheX96+wWc4BDtNBTTO9zp8XY0FT008QzTOz9eX6PBwosLDiY4Ip0tEBN5eHePvivt/SuXFxR9w/kK2cu2Re2/nvlm3NDi7lVqRydwTb1Jiti3P3hgyhL8l/AJtPTnPjn6bzu6Pjyl/fnuNswVnbV1f010sNRbWv7afjEO2AxU+/raUHNF9Q53aFdaUMSvlH2RXFwHwYJcbmN/NOQBet3k3z/z9LQBiukTy3//3Iv5+7gnea8xmvly/gdzCQgCiw8OZdv11HebPpbgySYDmYdwVoP1v3bdOJ+aEaA2NRoOfry8Bvr74+fkR4OdLgJ8fhsAgQg1BBBsM+LbDRv+mpJ5M593/rGTb93U5sfR6H557ci43jB/V4H37S0/z61PvUWq2ZdMfHdSHJb3n4qN1/sVusVjZ+9/j/PR13R6nPuO7Mf6hgZ0mOLOrrqrhm//bq1RD8NLruOE3Q4kd7JyW5GDZGR44/v+owZY/7W/x9zIpLFn53GKx8KuFL3PgiO1k6KxpN/K7X93jtnGXlpfz+foNyj7IHl27Mvma8Q0eCBHC3SRA8zBXUoBmn7FQ/t/2Bk1Tn9te1L53fK1pfh+1bzS2/0G5w+G1xqG/y++9pA+nZzmP7/JnOI9PU/eF1N1bXx/1PUOZ9NE4jPfyezUaDVqtFp1Wi1arRau1vddqtA7X6655e3nh7e2Ft7c3Pl7e+NS+9tLpPGYfVXZeATt+OMiajTs4ctw5Kerg/r159jdziYvt0uD9X+fv4y9nl2O02uo5DgnoydI+DxGgc57lqSw2snnJIS4czVeuJU/vxfCZfTzme9VS1VU1bHhtv/I1a3UarnpgAIkTuju1+1f2Fv6RYatV6q3R8XafXzE8qJfy+fkL2dz12J8wGm17Fv/5lye5auQQt407r7CQlRs3YarNuxfbpQtTrhkvM2miXUiA5mHcFaCVlJVhsVhw+qVe+wvd8ZdI/YGMEh4o9zYe+NQFIJcHI53zF5ZoPxaLhYKiEjKzcjmVnkFK2hmOHj9V7+nAqPBQHvz5dKbdeA26Bma2KsxGFmV+xYrcXcq1cYZEXkuYg7/Oed/SxWP5bP5/h6gosBX/1mg1XHVfEv2u76HiV9gxmavNfLfkEGf31i0XD5gUx+if90PrZfveWq1Wnju7nJX5ewAI0vmxtM9DDAqoSzXyn5Xfsuid/9g+D/Tn48V/Ibar+071Zmbn8PWWLdSYzQB0iYhg8jXj231vpLjySIDmYdwVoHV2jnvQlH12tgtO7+2fK59dem/t9UvbKvvXlH1ql+zNu2RzvvXSvWtOe/Ac+rV16vS+vvHX3Xfp+C/t65IxOO3rq+frUcZ3yZ68S/cIOu0JbHwMl4/Defxc0hfYlghramqorjE7/L+ZGnON7f9rajBV11BWXklpeQWlZeWUlldQXFxKVm6BMiPSkD4JPbh9ykSm3nA1vvqGl2B3Fqfy0rnPyDTVzTZPDx/Fn3rcgbfDsqapsoa9y45zbMM55ZpfiJ7r5ifTtX9Yo2PpTCxmC99/kkrK+rPKtS79Qrn2kSEE1ZaKqraa+fXJ99hVYlvKDNDqWdJnLsMCEwDbn4OnXnqDLbtsecp6du/KO397mtBg95XBupiby9dbtip/bgL9/Zk8/mqiwjtudQfR+UiA5mHcFaAt/L8lpJ0577QRvuHAxPmXZ6OBSW0Dq+O9DQZHdcGAmmMQ4lJarYZ+vXty9ahkrhk9lL4JPRqdvT1QdoalF9bxQ2macs1H48UfetzGbRFjlGtWi5WTOy/w4/ITlBdUKde7JoUxcV4y/iFX5snA1M3n2fXBUeXkqrefF+PuS6L3VbZUKhVmI/NPvsePZbalZr3Gi+d6zuLmsOEAlFVUMueJv3A2w5ZfLbFXHG/+3wIMtfnS3CG3oIC1W7dRXrsnTavVMmrQIJL790Or7Vz7BkXHJAGah3FXgHbv489xLO1M0w2F8CAB/n5ER4YRExVB1+gIenTrQv8+8fRN6NFkGoWimnI2FB7i87zvOVbhvBw6IrAXz8TNpKevbanNYrFybl82B748RX56idLOS69jxKy+JN0Uh9bD02i4KvtEIZuXHKQsry5wjRkYzthfJhHaLZBKi4knT32ozKQB3BN1Db/uNhW91psL2bnM/d1L5OTbTlrGd4/hn88/2WhNVFdVVFaybvsOp8oWUWFhXD1iOF0iItz2XCFAAjSP464A7ZE/vMLxU+m1G8ZrL2o0DpvPa/eTOewpq9vAbt/o7tAWjfOG9Qb2mtVt7He+1/6hphljcLqviTE4j705Y9A4vW98DJccGqhn/HX3aer66ihjuOz/6xnDJfc2bwyXj7+pMdTdV7sPUqvB28sLLy+d8//rdOhqX3t7eRHg74chyJ/AgAACA/xadAKvpKaSlIrzHC4/y87iVA6Xp2PB+cdjrE84j8RMYmrYcDQaDZXFRk7tukjK+rOUZFc4te2eHMnYX/bHEO2+WR5PY6qoZtdHKZzccUG5ptFp6Hddd4ZMS8An1Ju/nv9cKTQPEO8bxZ/jZjE0MJ708xd4eMFfKSiyBcEhhiD+9MT9XDtmmNvGbDab2XP4Jw6mpjrNyvfq0YMRAwdIUlvhNhKgeRjZgyZE89VYzZgsNRit1ZTUVFJcU06RuYKimnIKqks5b8wnw5jPeWOe076ySw3w786dkVcxNXw4VXkmMg/ncnZ/DhmH8pRSTXbhPQ2MujuRbgNlhqUhZ3/MZvcnxyjLrSvtpdVp6D2+G/1v6M53gUf5e8ZKqq1m5fPrQwbxWMwU9EVanvjzP5TlToApE8fx2H0ziY5w3/6+rLw8Nn//A4UlJU7Xu3ftwqC+fenetSs6WfoUKvK4AM1kMvH++++zfv16SktL6dWrFw8++CAjR45s8t7c3FyWLFnC3r17sVgsDB06lPnz5xMTE3NZ2zVr1rBs2TKysrKIjIzkjjvu4Pbbb2+TPhvjrgDt/YsbuWAqxEr9fxyc9npdeq2edk73Om4Kr6dd6+5xHl3DY6v/HscM+5ffU087x+vWy8fe1D31/WfW1Nga+k+zsWc639K873t937emxlnfvx/Hdy25p7FnNjS2+l5ZrFaM1mpMlhpM1hpMlhrMtTm2WiNeH8U4v0TGVvUl9Jw/eWdKyD1VTPHF8nrbxwwIZ9DP4okdHCGnkZuhxmTm8FenObzmDDVGs9Nn4T0N+F6r56OuW0mtznT6bExQX37mN5TvPtjFjh8OKtf1eh+mT7qWO2+5gR7dGk6P4gqLxULKqVPsPfwTlUaj02e+eh969ehBz5huxERHSWoO4TKPC9D+8pe/sGXLFmbOnElsbCzffPMNqampLF68mMGDGy4FUlFRwYMPPkh5eTmzZs3Cy8uLFStWYLVa+eCDDwgODlbarlq1itdee41rr72WUaNGcfjwYb799lsefvhhfv7zn7u1z6a4K0C7+9gijlacV60/ITyJn8WHLsYQupeGE5MfQsTpILzPaC8LHC4VEO5L76ti6H11DKGxQW002s6lqtTEkW/SOfrtWaora5w+s2gsnL46j51DT1DiXen0mZ/Ghz4pIaSvOk1VuXOwNLh/byZeNYIxQwcS36NbgylTWqu6uppjp09zKPU4peWXB+xarZYuEbZqGZGhYUSGhWIIDJTDBaJFPCpAS0lJ4Ve/+hWPPPIId911FwBGo5E5c+YQEhLC0qVLG7z3P//5D2+99RZvv/02/fv3B+Ds2bPMmTOHu+66i4ceekjp74477iApKYlXXnlFuf+FF15gx44dfPbZZwQFBbmtz6a4K0CbuvlFMgwdK1GtaGMOPwk0ymtNPdcauMfe1una5TTWeq5aL+mjoX7qe57DZ15mLboaLV41OnRmDTqzDl2NFp1Zi97ohW+lN75V3vhV+uBb6Y2h2I/gYj98K70v768eWp2GyN4hxA6OoNugCCITgj2+hmZHYaqs4fTuixz/7jy5p4udPqv2MnNkSAaHk89TEuIcqFFhQbe1Et1eI1Rf/ofUz9+Xfn3iiI/tRnxsV7p1iSIs1EBYsIHQEEOjaVWaYrFYOHvhAifSz5KemYnZ3HBAr9VoCAoIIDgoiKDAAPx9/fDz1ePn64u/3he9j48t+XPtfkqdVDC44nnUHOzWrVvR6XRMmzZNuabX65k6dSrvvPMO2dnZREdH13vvli1b6NevnxJIAcTFxTFs2DA2b96sBFP79++nuLiY6dOnO90/Y8YMNmzYwO7du7npppvc1md7mfHDSHIvFl92vb5fyvX9gq33l3cTv9ydr2ka7sfhefX/om7e85odTNT3vFb1U0+7S67Xjbee72mr+rns7vq/980IRq5kWp2GwEg/DFH+BEX5Ex4XRER8MKHd/397dx4XVbn/AfwzC8MyLAKKKBgGsiuWBpU5wxLugVYXxVupFdzcyfKl93Y1r5qaW2aWml693HpVFyJxZRFwpSxMcWMRFEFBEWQRhp2Z8/vD35w8zAwMMIMDfd+vV6+c5zznOc93njkzX87yHHMIjOiHUx9EpkJ4BA2BR9AQVJfIUHSxDLcvlKEsvwpGrQI8e8EJIy8+hdtOFbjhfh8Fw8rQZNIKmPEhnySG3N8U/ItN4Gc2gV/2R6LUUN+IzMvXkXn5uvoNC3jgGfHAE/LBF/L///889sYY8Hjg8fHHTTzsTTp4bDfjQSgQwN7KCgOtrDCwXz+Yt5nYVsEweCiT4aFMptX7oVAo0KpQQK5QgGEYKBgGCgUDBfPHa+X/gT+mNGL//f9ULi3ooA55RM4w2Lh40RPtQ69K0PLz8+Ho6AixmHtXlDJBunHjhtoETaFQoKCgAJMnT1ZZ5unpifPnz6O+vh5mZmbIz380z5GHhwennru7O/h8PvLy8jB+/Hi9tKnOgwcPUFHxxyNibty4AeDRkTpdEtY2QFzbZjLPNr/hqpfVtK3Q7kvVgk5ep8O5rkelrc413fGmuRVU6ne0fgcb6Oi97Pi9a/uygze/s/lYJ+Pr+P3u7Fi336GOx4P7WREIeRAYCcAX8iAQCsA34kEg5EMg5MPIVAiRmRDGYiMYmQlhbGYEYwtRm200oKKlARUFnQqDdIOJG+DmZg3nRgtUFctQeUeGquJa2JcLYXnUFiN51qiwrUO5XQ0eDKhFtU096p0UUDgZQVEtAL+oBfxSOVDaCl59OwmIHEDzo4Sl/RPaHavBPeQp+29sBCsrc1hZimFlKYaZmQnEZiYQCnWT4CvzQzppqh8NTU24fl1DUt9NTk5OMNHiyRS9KkGrqKiArZqZnJVlDx6bq+ZxNTU1aG5u7nDdp556ChUVFRAIBLC2tubUMzIygqWlJZss6aNNdQ4fPozo6GiV8k8++UTjOoQQ8qdQCiDr0T8FAAzqKsAG4GE1oHpegvQWZ48e0Uu72l6i1KsStKamJhgZGamUi0Qidrmm9QBotW5TUxOEGu6+EYlEnHq6blOd0NBQvPTSS+zr2tpaFBUVwc3Njd2OrhQVFeGTTz7BihUr4OTkpNO2DQHF1/v19Rgpvt6vr8fY1+MD9B+jtm32qgTN2NgYLWqeqdfc3Mwu17QeAK3WNTY2Rmtrq0o9Zd3H6+m6TXX69++P/m1mrH7uuec01tcFJyenPj3HGsXX+/X1GCm+3q+vx9jX4wOefIy96vS1ra2t2tOByrK2iYySpaUlRCKRVuva2tpCLpejqqqKU6+lpQU1NTXs6Ut9tEkIIYQQAvSyBG3YsGEoLi5GXZt5Z7Kzs9nl6vD5fDg7OyM3N1dlWXZ2NgYPHgwzMzMAgKurKwCo1M3NzYVCoWCX66NNQgghhBCglyVoAQEBkMvlOHz4MFvW3NyMhIQEeHl5sXdw3r9/X+UuR39/f+Tm5nKSpNu3byMzMxMBAQFs2ahRo2BpaYlDhw5x1j906BBMTEzw4osv6rXNJ8nW1hZz5szps0f0KL7er6/HSPH1fn09xr4eH2A4MfaqiWoBYNWqVThz5gymT58OBwcHJCUlIScnB9u2bcMzzzwDAFi8eDEuXbqEM2fOsOvV19fj3XffRX19PcLDwyEQCBAbGwuFQoH9+/ej32MPvI2Pj8e2bdsQEBAAPz8/XL58GcnJyYiMjMRbb72l1zYJIYQQQnpdgtbU1MQ+i1Mmk8HZ2RkRERHw8/Nj66hL0ACgrKxM5bmZCxcuhKOjo8p2jhw5gpiYGNy7dw92dnZ49dVXERYWpjKfkz7aJIQQQsifW69L0AghhBBC+rpedQ0aIYQQQsifASVohBBCCCEGpldNVEseyczMRFRUlNplu3btgre3N/v66tWr2L17N/Ly8iAWixEYGIjIyEh2ChCl5uZm9tq+2tpauLi4ICIiAr6+vlr1qby8XOVavEWLFmHw4MEGEWNOTg6SkpKQmZmJ0tJSWFpawtvbGxERERgyZEiH/UlMTMSGDRvULouPj+/03T66jq8z7WmiyzHUdXzr169HUlKSxu399NNPGDBggMbl+/fvV/vINJFIhNTUVC0iUqVtjBkZGThx4gRycnJQVFQEOzs7xMbGql1PoVDgf//7Hw4ePIjKyko4OjrizTffRHBwsFZ9qq2txe7du3HmzBk0NTXB09MT8+fP79Jkm7qOr6ioCAkJCTh//jxKSkpgamoKNzc3vPPOOyrPKe5Of7Sl6/ju3buHGTNmqG1v1apVePnllzvsky7HD9B9jJr2I6WvvvoKI0aM0Lj8SXyPNjY2IiEhAenp6SgoKEBDQwMcHR0REhKCkJAQCATcZ6Ma0j5ICVov9vrrr7MPildycHBg/52fn48lS5bAyckJCxcuRFlZGWJiYlBcXIzNmzdz1tuwYQNOnTqFsLAwODo6IjExEcuWLcP27dvh4+PTbj/q6+sRFRWFuro6vPnmmxAKhYiNjcWiRYuwf/9+WFlZPfEYv//+e1y9ehWBgYFwcXFBRUUF4uPjERERgV27dsHZ2Vmr/rz77rsYNGgQp8zc3PyJx6dte5roawx1FV9oaKjKEzQYhsHWrVthb2/fbnL2uA8//BCmpqbsaz6/+ycROooxNTUVJ06cgJubW4c/QHv37sV3332HkJAQeHh4ID09HWvWrAGPx+vwB16hUGD58uW4efMmwsPDYWVlhYMHDyIqKgp79+7V6g8RfcZ39OhRHDt2DP7+/pg2bRrq6upw+PBhzJs3D5s3b9b6CSld/Yx3tb3OjB8ABAcH44UXXuCUaZM86mv8AN3F6O/vr/YGuD179qChoUGrRBvo2e/Ru3fvYvv27Rg9ejRmzJgBMzMzZGRk4LPPPkNWVhb++c9/ctYzqH2QIb3OxYsXGYlEwpw8ebLdekuXLmWmTZvGyGQytuzIkSOMRCJhfvvtN7YsKyuLkUgkzPfff8+WNTY2MuHh4czcuXM77M93333HSCQSJjs7my0rLCxkAgICmK+//roTkf1B1zFeuXKFaW5u5qx7+/Zt5uWXX2bWrFnTYX8SEhIYiUTC5OTkdC4QDXQdn7btaaLrMdR1fOpcvnyZkUgkzDfffNNhf/bt28dIJBKmqqpKm+5rRdsYy8vLmZaWFoZhGGbZsmVMWFiY2nplZWVMYGAg89lnn7FlCoWCWbBgAfPaa68xra2t7W4nLS1NpT9VVVXMpEmTmNWrV2sX1GN0HV9ubi5TV1fHKauurmZCQkKY+fPn66w/2tJ1fHfv3lX5Hu0MXY8fw+g+RnVKS0sZqVTKbNq0qcO6T+J7tKqqiikoKFAp37BhAyORSJg7d+6wZYa2D9I1aL1cfX292ud81tXV4ffff8f48eMhFovZ8gkTJsDU1BQnT55ky06fPg2BQIDQ0FC2zNjYGFOmTEFWVhbu37/fbh9OnToFDw8Pzl8wTk5OGDVqFGc7XaWLGEeMGKHyYPshQ4Zg6NChKpMaa9MfuVzeySjab6+78WnTXnv0OYa6jk8pNTUVPB5P61MPj2+X0fHN6+295/3794dQ2PHJivT0dLS2tuLVV19ly3g8HqZNm4by8nJkZWW1u/7p06dhY2MDqVTKlvXr1w+BgYFIT09nnxHcFbqIz93dXeXSCisrK/j4+HRpH+zsZ7yr7Wkb3+MaGhrUPqe5PfocP0D3MSqlpaWBYRiMGzeu0/3pie/Rfv364emnn1Ypl0gkAMD57BnaPkinOHuxDRs2oKGhAQKBAD4+Ppg3bx57iLmgoAByuVzlvLeRkRFcXV2Rn5/PluXn58PR0ZHzIwmA/bG+ceMG+5SGthQKBQoKCjB58mSVZZ6enjh//jzq6+tVvph7OkZ1GIZBVVUVhg4dqnV/oqKi0NDQACMjI/j6+mLBggXdOvWg6/jaa08TfY6hvsavtbUVJ0+exPDhw1VOlbRnxowZaGhogKmpKcaOHYsFCxbAxsam03E9rivvuTr5+fkwNTWFk5MTp1y5H+bn57d7uUFeXh5cXV1VTtt6enriyJEjuHPnDlxcXDrdL13Fp0llZWWnTqHruj+6bi86Ohq7du0Cj8eDu7u7yjydmuhr/AD9jmFKSgrs7OwwcuRIrdfpye9RTSorKwGA89kztH2QErReSCgUwt/fHy+88AKsrKxQWFiImJgYLFy4EDt37oSbmxv7wHZ11xPY2tri8uXL7OuKigqN9QDgwYMHGvtSU1OD5ubmDtd/6qmnnmiM6qSkpKC8vBzvvPNOh/0xNjbGpEmT8Oyzz0IsFuP69euIjY3F/Pnz8e9//1tjAttT8WnTnib6GEN9j19GRgYePnyo9V/tFhYWeO211+Dt7Q0jIyNcuXIF8fHxyMnJwd69e1X+ONFVjJ1RUVEBa2trlYmrtdkPgUc/OOp+JJXrV1RUdO7HQcfxqXP58mVkZWVh1qxZPd4fXbfH5/Ph6+sLqVSK/v374+7du4iNjcWyZcuwYcOGDh/pp+vxA/Q/hrdu3cLNmzcxc+ZMrSZcfxLfo+q0tLTgxx9/xKBBgziJnMHtg1rXJAZjxIgRnDtlxo4di4CAALz99tvYs2cPtmzZgqamJgBQOa0HPLpz7fFDrU1NTRrrKZdr0tF2OlpfE13H2FZRURG2bdsGb29vTJw4scP+BAUFISgoiH0tkUjg5+eHRYsW4dtvv8XSpUs7E57O49OmPU30MYb6Hr/U1FQIhUIEBgZq1Z+wsDDO64CAAHh6emLt2rWIj4/Hm2++qVU7j+vOe65Od/ZD5XJl3a6s35au42urqqoKa9aswaBBgzBz5swe74+u2xs4cCC2bt3KKZswYQJmzZqFr776qsMETdfjB+h/DFNSUgAA48eP16r+k/geVefzzz9HYWEhNm7cyDm1a2j7IF2D1kc4Ojpi7NixyMzMhFwuh7GxMQCovQ6iubmZ8yEyNjbWWE+5XJOOttPR+p3RnRgfV1FRgeXLl0MsFmPt2rUqt1lry8fHB15eXrhw4UKX1m9LV/Fpak+TnhpDXcVXX1+P9PR0+Pn5desO4XHjxsHGxkZn4wdo/56r0539ULlcXVKrzzHsqoaGBixfvhwNDQ1Yv359ly+B0FV/9NWepaUlJk2ahNu3b6OsrKzduj0xfoDuYmQYBqmpqXj66ae7fOoV0P/3aFs//PADjhw5gnfffVclaTa0fZAStD7Ezs4OLS0taGxs5BxSbauiogL9+/dnX9va2mqsB4BTty1LS0uIRKIur99ZXY1RSSaTYdmyZZDJZNiyZUu3+2ZnZ4eampputdG2ve7E1157mvTkGOoivvT0dDQ2Nnb6omRN/dHl+Cnb7Og9V8fW1haVlZUqNzBoOwY2NjbtjmFn55jSpKvxKbW0tGDFihUoKCjA+vXrtZ7iRl/96Yn2gEfzY7Wnp8ZP2afuxnj16lWUlpYa5H6oKb7ExETs3r0bU6dOxezZs1XWM7R9kBK0PuTu3bsQiUQwNTXF008/DYFAgOvXr3PqtLS0ID8/H8OGDWPLhg0bhuLiYtTV1XHqZmdns8s14fP5cHZ2Rm5ursqy7OxsDB48uMt/HavT1RiBR4eX//73v+POnTv49NNPO3VzQHv96devX7fbeby9rsbXUXua9OQY6iK+lJQUmJqa4qWXXupWXxiGQWlpqU7HD9DuPVdn2LBhaGxsVLmjUZv9EAB7Y4VCoeCU5+TkwMTEpFsXYT+uq/EBj25IWbduHS5evIiVK1fimWeeeaL96an2AHR4tLenxk/Zp+7GmJKSAh6Pp5METZ/fo0pnz57Fpk2bIJVKsWTJErXrGdo+SAlaL1RdXa1SduPGDfz888/w9fUFn8+Hubk5nnvuORw/fhz19fVsveTkZDQ0NHCu3QkICIBcLsfhw4fZsubmZiQkJMDLy4tz4eb9+/dVPrz+/v7Izc3l/MDfvn0bmZmZCAgIMIgY5XI5/vWvfyErKwurV6/G8OHDNW77wYMHKCoq4tyyra4/586dw/Xr17W6Q0vf8WnTnlJPjKGu43u83d9//x1SqRQmJiZqt60uPnX9OXjwIKqrq/H88893Lrh22tT0nmtj7NixEAqFiI+PZ8sYhsGhQ4cwYMAAzmdW3WfU398flZWVOHPmDKePJ0+exJgxYzo8Jd6WruMDHl37c+LECSxZsgT+/v7tbruoqIhzBETX/emJ9srLy5GQkAAXFxfO0ZeeGD9NferuGAKP7qI+deoURowYofHCfkP5HgWAS5cuYfXq1fDx8cHKlSs1xm1o+yDdJNALrVq1CsbGxhg+fDisra1RWFiII0eOwMTEBO+99x5bLyIiAgsWLMCiRYsQGhrKztLu6+vL+VHy8vJCYGAg9uzZg+rqajg4OCApKQmlpaVYvnw5Z9vr1q3DpUuXOB/AV199FUePHsXy5csRHh4OgUCA2NhYWFtbIzw83CBi/Oqrr/Dzzz9jzJgxqK2txfHjxznbe/wi1z179iApKQkxMTHsFA7z5s2Dm5sb3N3dIRaLkZeXh4SEBNjZ2eGtt9564vFp2x7QM2Oo6/iU0tLSIJfL2/2rXV18YWFhCAoKgrOzM0QiEa5evYq0tDS4urpy5v/TR4w3b95Eeno6AKCkpAQymQz//e9/ATz6i1x5JNDOzg5hYWH44Ycf0NraCk9PT5w9exZXrlzBypUrOddKqvuMBgQEIC4uDhs2bEBhYSE7i7lCodDqTmV9xxcbG4uDBw/C29sbJiYmKvugRCJhj3gcOHAA0dHR2L59O5599tlO9edJxbdr1y6UlJRg9OjR6N+/P0pLS3H48GE0NjZi8eLFnG33xPjpI0Ylbe6iNpTv0dLSUnz00Ufg8XgICAjAqVOnOG24uLiw19AZ2j5ICVovJJFIkJKSgtjYWNTV1aFfv36QSqWYM2cO5zEc7u7u+Oyzz7B7927s2LEDZmZmmDJlitovs48++ggDBw5EcnIyZDIZnJ2dsXHjRq1OQZiZmWH79u348ssv8c0337DPcVy4cGGXD1vrOsYbN24AAH755Rf88ssvKtvr6C6koKAg/Prrrzh//jx7/VRISAjmzJnTpXm0dB2ftu1pousx1MdnFHh096a1tTVGjx7dqf6MGzcO165dw+nTp9Hc3IyBAwdi5syZmDVrlsYjcbqKMS8vD/v27eOsq3w9ceJEzo/fe++9BwsLCxw+fBhJSUlwdHTEihUrtDqNJBAIsGnTJuzcuRM//fQTmpqa4OHhgX/84x+dnuZGH/Ep98GsrCy1E37GxMS0e8qtu59xfcfn6+uLu3fvIj4+HrW1tTA3N4ePjw9mzZql1XMYdT1++ohRKSUlpVN3USs9ie/Re/fuQSaTAQC2bdum0sacOXM4NzkY0j7IY3Q9pTYhhBBCCOkWugaNEEIIIcTAUIJGCCGEEGJgKEEjhBBCCDEwlKARQgghhBgYStAIIYQQQgwMJWiEEEIIIQaGEjRCCCGEEANDCRohhBBCiIGhBI0QQgghxMBQgkYIIb2cVCrl/NfU1MQuS0xMhFQqRWJi4hPs4R8OHTrE6ev69eufdJcIMUj0LE5CiEG6d+8eZsyY0W4de3t7xMbG9lCPDJu9vT0mTpwIAJyHOutDRkYGli5dCl9fX2zdurXdumvWrEFqaipWrlyJcePGwd3dHXPmzIFMJkNcXJxe+0lIb0YJGiHEoDk4OGh8ULG5uXkP98Zw2dvb45133umRbT333HMYOHAgLly4gPv372PgwIFq68lkMpw9exbm5uaQSqUAAA8PD3h4eODevXuUoBHSDkrQCCEGzcHBoccSD6IdPp+PSZMmITo6GklJSZg9e7baeqmpqWhqasLkyZNhbGzcw70kpHeja9AIIX2GVCrF4sWLUVlZiXXr1iEkJATBwcGYO3cuMjMz1a5TX1+P/fv3Y9asWQgODsbkyZPx4Ycf4sqVKyp1Fy9ezF7jtXfvXoSHhyMwMBD79+9n65w+fRqRkZEIDg7G1KlTsWnTJtTW1mL69OmYPn06W2/t2rWQSqXIzs5W2699+/ZBKpUiNTW1m++KemVlZZg9ezaCg4Nx6tQptryqqgo7duzAzJkz8fLLLyMkJAQrVqxAQUEBZ/3JkyeDx+MhMTERDMOo3UZCQgIAYMqUKXqJgZC+jBI0QkifIpPJsGDBAhQWFmL8+PGQSqW4fv06li5dqpJk1NTUYN68eYiOjoaFhQWmTp0KqVSKvLw8REVF4ezZs2q3sXLlSiQlJeHZZ5/FX/7yFwwaNAgAcOzYMaxcuRLFxcWYMGECJk6ciKysLHzwwQdobW3ltBEaGsqu05ZcLkdCQgKsrKzYU4O6VFhYiPnz56OsrAybN29GQEAAAKCkpAQRERH48ccfMXjwYLz22mt44YUXkJGRgXnz5nGSSXt7e4wePRp3795Vm/wWFBQgNzcXrq6ucHNz03kMhPR1dIqTEGLQSkpKOEeoHuft7Y3nn3+eU3bjxg1MmzYN77//Pvj8R3+Djho1Cps2bcKBAwewdOlStu7nn3+OW7duYdmyZXjllVfY8qqqKkRGRmLz5s3w8/NTOT1XUVGB//znP7C0tGTLamtr8cUXX8DU1BR79uzBkCFDAACRkZFYunQprl+/Dnt7e7b+yJEjMXToUKSlpWHhwoUwNTVll2VkZKC8vBxhYWEQiUSdfcvalZWVheXLl0MoFGLHjh0YNmwYu2zdunWorKzEli1b4Ofnx5bPmjULkZGR2LRpE6Kjo9nyKVOm4Pfff0dCQgJGjRrF2Q4dPSOke+gIGiHEoJWUlCA6Olrtf7/99ptKfVNTU8ydO5dNzgBg4sSJEAgEyM3NZcuqq6tx8uRJjBo1ipOcAYC1tTVmzpyJ6upqXLhwQWUbb7/9Nic5A4D09HQ0NDRg8uTJbHIGAEKhEBEREWpjCw0NRX19PdLS0jjlR48eBQCEhIRoelu65Ny5c1iyZAksLCywc+dOTnKWl5eHa9euYcKECZzkDACGDBmCV155BQUFBZyjkBKJBFZWVjh9+jTq6urY8tbWVhw/fhwikUjjDR6EkPbRETRCiEHz8/PDli1btK7v6OgIMzMzTplQKISNjQ1kMhlblpubC7lcjpaWFrVH6IqLiwEARUVFGDNmDGeZp6enSv2bN28CAHx8fFSWeXl5qZ36YsKECfj6669x9OhRNkmsrKzEL7/8guHDh2Po0KEdRKu9kydP4vz583BxccHmzZthbW3NWa48fVlVVaX2/bh9+zb7f2dnZwBgE7C4uDikpqZi6tSpAICff/4Z1dXVCA4OhoWFhc5iIOTPhBI0QkifIhaL1ZYLBAIoFAr2dU1NDQDg6tWruHr1qsb2GhsbVcpsbGxUypRHkNomPsCjux6trKxUyi0sLBAYGIikpCQUFBTA2dkZiYmJkMvlOj96lpWVBblcDh8fH7V9VL4f586dw7lz5zS209DQwHk9ZcoUxMXFISEhgU3Q6PQmId1HCRoh5E9JmcjNmDEDCxYs6NS6PB5PY3tVVVUqyxQKBR4+fIgBAwaoLJs6dSqSkpJw5MgRREVF4dixYxCLxQgMDOxUnzryt7/9Denp6YiLi4NAIFCJWdn/qKgovP7661q36+LiAg8PD+Tk5ODWrVuwsLBARkYGBg0apHJdGiFEe3QNGiHkT8nDwwM8Hg9ZWVk6ac/FxQUA1B6Ny8nJgVwuV7uet7c3XFxckJKSgoyMDBQXF2PcuHEwMTHRSb+URCIR1q1bhxdffBExMTH48ssvOcuVp2278n4oj5QdO3YMycnJkMvl7DQchJCuoQSNEPKnZGtri8DAQFy7dg0//PCD2rm8srOz1Z7iVGfs2LEwNTXFsWPHUFJSwpa3trZi37597a4bGhqKmpoafPrppwCgctOCrohEInzyyScYM2YMYmNjsWPHDnaZl5cXvLy8kJaWpnLTAvDoKOClS5fUthscHAwTExMcP34cCQkJ4PP57GOnCCFdQ6c4CSEGrb1pNgDgjTfe6PIs9R988AHu3LmDXbt2ITk5Gd7e3jA3N0d5eTlyc3NRXFyM+Ph4rY5mWVhYYOHChdi8eTMiIyMRFBQEsViMX3/9FSKRCP3799d4RGn8+PHYvXs3Hjx4AHd3d73OG2ZkZIS1a9fi448/xo8//giGYbB48WIAwMcff4z3338fq1evRlxcHFxdXWFsbIyysjJcu3YNDx8+VDtxrlgshr+/P5KTk1FdXY3nn39e4+OfCCHaoQSNEGLQlNNsaBIWFtblBM3S0hI7d+7EgQMHcOLECaSmpkKhUMDGxgbDhg3D7Nmz1V7cr0lISAgsLCzw7bffIikpCWKxGC+99BLmzp2LsLAwODg4qF1PLBZDIpHg+PHjejt69jhlkrZq1SrExcWBYRhERUVh8ODB2LdvH2JiYnD27FkkJiaCz+fD1tYWI0eOZCe0VWfKlClITk4G8OgpA4SQ7uExmp7RQQghRCeKi4vx17/+FYGBgVi9erXaOrNnz0ZpaSkOHDig8U5UTaRSKZ555hl88cUXuuhuj7h37x5mzJiBiRMn4qOPPnrS3SHE4NARNEII0ZHa2loYGxtzZv9vampiL8iXSCRq1/v1119x69YthISEdDo5U7p06RL7WKiUlBSDfTj5oUOHsHXr1ifdDUIMHiVohBCiI5cuXcLGjRvh6+sLOzs7PHz4EBcvXkRpaSlGjRqFoKAgTv2DBw+irKwMR48ehUgkwhtvvNGl7c6ZM4fzWt2kuIbC3d2d019XV9cn1xlCDBid4iSEEB25c+cO9u3bh2vXrqG6uhoA4ODggKCgIISHh6sc1Zo+fTrKy8sxZMgQzJ07V+WJBYSQPy9K0AghhBBCDAzNg0YIIYQQYmAoQSOEEEIIMTCUoBFCCCGEGBhK0AghhBBCDAwlaIQQQgghBoYSNEIIIYQQA0MJGiGEEEKIgaEEjRBCCCHEwPwfaET+b/vDy/sAAAAASUVORK5CYII=", "text/plain": [ "
      " ] @@ -2971,7 +2962,7 @@ " axs.plot(energy, dnde,label=label)\n", "\n", "axs.legend()\n", - "axs.set_ylabel(\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", + "axs.set_ylabel(r\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", "axs.set_xlabel(\"Energy [keV]\", fontsize=14);\n", "plt.ylim(0,);\n", "#axs[0].set_yscale(\"log\")" @@ -2979,6 +2970,7 @@ }, { "cell_type": "markdown", + "id": "9d0e2653", "metadata": {}, "source": [ "The orthopositronium spectral component appears as the low-energy tail of the 511 keV line." @@ -2986,7 +2978,8 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 37, + "id": "9c25d07b", "metadata": {}, "outputs": [], "source": [ @@ -3014,12 +3007,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 38, + "id": "3866405b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
      " ] @@ -3029,7 +3023,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
      " ] @@ -3039,7 +3033,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApUAAAG+CAYAAADC0v/PAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAv4xJREFUeJzs3Xd8VfX9x/HX95y7sgdh743IEBVRFHGg4p61Wq3irrtq1fZXZ221amur1dq6iqNq3XuDoOJiyF4BAoQZyJ53nPP9/XFzb26Se5OQdTM+z0ep4eZ7z/ncBC7vfKfSWmuEEEIIIYRoASPeBQghhBBCiM5PQqUQQgghhGgxCZVCCCGEEKLFJFQKIYQQQogWk1AphBBCCCFaTEKlEEIIIYRoMQmVQgghhBCixSRUCiGEEEKIFpNQKYQQQgghWkxCpRBCCCGEaDEJlUIIIYQQosUkVAohhBBCiBaTUCmEEEIIIVpMQqUQQgghhGgxCZVCCNFMmzdvRimFUopZs2bFu5w2M2vWrPDr3Lx5c7zLEUJ0UBIqhejmQmEh2i/DMEhNTWXMmDFceOGFfPDBB/Eut0uKDKfRfpmmSXp6OhMmTOCKK67gq6++infJQghRj4RKIURMWmtKS0tZt24d//3vfzn11FM56qijyM/Pj3dp3Ypt2xQXF7NixQqeeeYZpk+fzrnnnktVVVW8SxNCiDBHvAsQQnQcb7/9dq3f27bN3r17+f7773nllVeoqqpi/vz5nH766Xz99dcopeJUadfVs2dPnnrqqVqPBQIB8vLymD9/Pm+++SaWZfH666/jcDh4+eWX41SpEELUprTWOt5FCCHiJzIYNvR2sHLlSqZOnUppaSkAH330ESeeeGKb19eRbd68maFDhwJw8cUXM3v27BZfZ/DgwQ3OW5w7dy7HH388lmUBsHr1avbbb79m3bepZs2axfPPPw9ATk4OQ4YMadP7CSE6Jxn+FkI0ybhx47j88svDv58/f34cq+m+jjnmGE477bTw7+X7IIToKCRUCiGabMyYMeGPi4uLo7aJtlL4rbfe4rTTTmPQoEG4XK6ow+aBQIBnnnmGk046iX79+uF2u+nRowcHH3wwd9xxBzt37my0vj179vDMM89w4YUXMm7cOFJTU3E6nWRlZXHooYdy1113sWvXria/3hUrVnDZZZcxePBgPB4Pffv25fjjj+fVV19t8jXaQlO+D6HvwVFHHdXo9falbWPefvttTj75ZHr37o3H42HIkCFceOGF/PDDDwDMnj07fL/GenZ9Ph/PPvssp512GgMHDsTj8YQXLN1yyy2yEl2IDkbmVAohmmzv3r3hjwcNGtRoe6/Xy1lnnVVvrmZd69ev57TTTmPdunW1Hi8oKKCgoIDFixfz97//nX/+859cdNFFUa+xadMmRo0aFR4WjpSfn09+fj4//PADjzzyCC+88AJnnXVWgzU9+eST3Hjjjfj9/vBju3btYteuXXz++ee89tpr/PnPf27wGm1lX78P7cHv93PBBRfw+uuv13p8y5YtbNmyhVdffZUHH3yQHj16NOl6ixYt4txzzyUnJ6fW416vlxUrVrBixQoef/xxHnvsMa666qpWex1CiOaTUCmEaJKqqir++9//hn8/Y8aMRp9z00038fHHHzN8+HB++ctfMnr0aCoqKmoN2W7bto0jjjiCPXv2ADBixAhmzZrFiBEjKCws5L333uPjjz+mvLycWbNmYZomF1xwQb17+Xw+LMti2LBhHHvssYwbN46ePXti2zZbt27liy++YO7cuZSXl3PeeeexYMECJk+eHLXu1157jWuuuSb8+xNPPJHTTz+d9PR01q5dy7PPPttoUG4r+fn5vPPOOwC43W6mTZsWlzrquvLKK8OB0uPxMGvWLA477DBM02TRokU8++yz/OY3v+Gcc85p9FrfffcdM2bMoKKiAqUUJ5xwAscffzz9+/ensrKS7777jhdffJGKigp+9atf4Xa7u/Q+oUJ0GloI0a0B4V91WZal9+zZo99//309ZcqUcLtZs2bFvN7FF19c65o/+9nPtNfrjdl+5syZ4bbnnHOOrqqqqtfmP//5jzYMQwM6JSVF79ixo16b/Px8vWDBggZf69y5c3VSUpIG9FFHHRW1TWFhoc7KytKAVkrpp59+ul6bkpISPW3atFqv8+KLL27w3g3JyckJX2fw4MH1Ph8IBPSOHTv0q6++qseMGRNue88998S8ZqjN9OnTG71/Y20jv6c5OTn1Pv/FF1+EP5+VlaVXrFgR9TUOHjy41tfsP//5T712JSUleuDAgRrQ6enpet68eVFrys7O1oMGDdKATkpK0nv27Gn0dQoh2paESiG6uch/5Bv7tf/+++tHHnlE27Yd83qRAWTAgAG6rKwsZttly5aF2w4ZMkRXVFTEbHvttdeG2/7+979v9uu96667wtfZunVrvc//7W9/a1J43rFjh05JSWn1UNnYL6WUPuSQQ/Tzzz/f4DXbM1SefPLJ4c+/+uqrMe/z5ZdfNhoq//rXv4Y//9577zVY95w5c8Jt//SnPzXYVgjR9mShjhCiyVwuF4mJiQ1uPRTp0ksvJSkpKebn33rrrfDH119/PQkJCTHb3nbbbeEFPpHP21dTp04Nf/zjjz/W+3zksPYtt9wS8zp9+/blwgsvbHYdzaWUwul04vF42v3e0VRVVfHZZ58B0K9fP372s5/FbHvUUUcxYcKEBq/34osvAjBq1ChOPfXUBtsec8wx9OvXDyBcgxAifmROpRAiLNo8wbKyMtauXcurr77KTz/9xK9+9Stef/113nvvPRITExu8XmPz/SJD3fHHH99g20GDBjFmzBjWrFnD2rVrKSkpITU1tV67VatW8fzzz7NgwQKys7MpLi7G5/NFvea2bdtq/V5rzeLFiwHo1asX48aNa7CmY489lieffLLBNvsq2ubnWmtKSkpYvnw5r7zyCgsWLGDBggW8//77zJ49G9M0W7WGfbFs2bLwYqYjjzwSw2i4r+Koo45i+fLlUT9XXFwc/lzv3r3Dc0cbkpycDMCaNWv2oWohRFuQUCmECDvjjDNifu6uu+7ikksu4eWXX2bOnDnccMMNPPPMMw1er3///g1+PnKboFGjRjVa36hRo1izZg1aa3bt2lUrVGqt+e1vf8tf/vIXbNtu9FoAJSUltX5fXFxMeXk5EFww1JimtNlXiYmJDX4f7rnnHs444wzmzp3LSy+9xOjRo7njjjtavY6m2rFjR/jjYcOGNdq+oTa5ubnh793XX3/N119/3eQ6CgsLm9xWCNE2ZPhbCNEkLpeLJ598MhzkZs+eTW5uboPPaWg4GwifzuNwOHC5XI3WEOqVinxuyP33389DDz2EbduYpskJJ5zAvffey3/+8x9ee+013n77bd5++23uu+++8HPqbj9UVlYW/rixXligwaH9tpKSksIzzzwTngrwl7/8hcrKynavIyQUwqHlX7NYe242ReTWT0KI+JCeSiFEk6WmpnLYYYfx6aefYlkWc+fO5eKLL2729VJSUoDgxuc+n6/RYBkZ+kLPBaisrOSBBx4IP/7ll19y0EEHRb2G0+mMef3I0FpRUdFo/ZGBqj0NHTqUUaNGsW7dOoqLi/nxxx+ZPn16s67V1F7dWCJDYku/ZpFf/4suuih8NKQQonOQnkohxD6J3Lw6cuizOfr27Rv+ODs7u9H2oTZKKfr06RN+/LvvvguHlauuuipmoITgZtyxpKWlhUPShg0bGq2nKW3aSmPfh1BAjzWfNCRyI/XmCC2UgeAG9I1pqE3kdIm6812FEB2fhEohxD7Jz88Pf9zS4d9DDjkk/PHnn3/eYNvc3FzWrl0LBI8pjJxPuXv37vDHw4cPb/A6n376aczPKaU4+OCDAcjLy2PVqlUNXmvOnDkNfr4tNfZ9SE9PBxoP/qHjE5tr4sSJ4d7fr776qtGez3nz5sX8XFZWFmPHjgXg+++/rzfnVQjRsUmoFEI0WWlpKd9991349/vtt1+Lrhd5VOI//vEPqqqqYrZ9+OGHw4Hl7LPPrvW5yLl8GzdujHmNJUuW8MEHHzRY05lnnhn++JFHHonZbvfu3bVOGGpPOTk5rF+/Pvz7aN+HUDjbsmVLg72Djz32WItq8Xg84ZX7O3bsqHdMY6R58+bFXPkdEppOUVFREbdjMIUQzSOhUgjRJH6/n6uvvjrce9SvX79mz+MLmTBhAieeeCIQHBa95JJLog7XvvjiizzxxBNAcM5k5BGKQLh3EeCZZ56pd140BIfOzz777EZ70i6++GKysrIA+M9//sPs2bPrtSkrK+O8886LS09aaWkpl19+eXiv0IMOOoiRI0fWazdz5szwx7fffnvUvUXvuusuvvjiixbXdNNNN4U/vu6661i5cmW9Nps3b27SUYrXXnstgwcPBuDPf/5zrR8moikuLuaxxx5rldchhGgZWagjhAiLti9geXl5eJ/K0BxCwzB4/PHHm7RiuzFPPfUUBx54IHv27OHVV19lyZIlXHzxxYwYMYKioiLee+89Pvzww3D7J598stZcTAjOxTvrrLN46623KCoqYuLEiVx11VVMmDAB27b59ttveeGFF6iqquKiiy7ihRdeiFlPeno6TzzxBD//+c/RWnPJJZfwxhtvcNppp5GWlsa6det49tln2bp1K2eeeWarnwFeUVFR7/ugtaa0tDS8T2VoSNvj8YTDdl2XXnopDz30EAUFBbzxxhtMmzaNCy64gKysLLZu3cqrr77KokWLOO+883j11VdbVPOxxx7LrFmzmD17Nnv37mXy5MnMmjWLqVOnYhgGixYt4rnnnqOkpIRzzjmHN954AyDqnpZJSUm88847TJ8+nZKSEm677Tb+/e9/c/bZZzN27FiSk5MpKSlh06ZN/Pjjj8ybNw+fzxfeNF0IEUdxO8tHCNEhsA/HNAI6MzNT/+9//4t5vcaO9Itm3bp1evTo0Q3eNzExscGjCffu3avHjx8f8/mGYej77ruv1lGBd999d8zrPfHEE9rhcMS83tlnn63Xr1/f7sc0hn4NHDhQz507t8Hrfvjhh9rtdse8ximnnKIrKipafEyj1lr7fD59zjnnNPj1/8tf/qKffvrp8GNvvfVWzNrXrl2rJ02a1KSvhdvt1h9//HFTv9xCiDYiw99CiAYlJCTQv39/Zs6cyd///neys7M599xzW/Ueo0aNYsWKFTz99NPMnDmTPn364HQ6ycjI4MADD+T//u//yM7O5qKLLop5jR49evD999/zwAMPMGnSJBITE0lMTGT48OFccsklfPvtt/u0Sfg111zDkiVLmDVrFgMHDsTlctG7d29mzJjByy+/zBtvvNHg9kStLSkpiSFDhnD66afzzDPPsGbNGo4++ugGn3PSSSexbNkyLrnkEgYNGoTL5aJnz54cffTRvPjii7z33nuN7iXaVE6nk9dff50333yTmTNn0rNnT9xuN4MGDeKCCy5gwYIF3HLLLbUWGGVmZsa83ujRo1m8eDHvvvsuF198MaNGjSI1NRXTNElPT2fixIlcdNFFzJ49m507d9Ya7hdCxIfSuomH+AohhBAtdPbZZ4fPbs/Pz28wWAohOhfpqRRCCNEuNm/eHF59P3HiRAmUQnQxEiqFEEK02MaNGxvcsHz79u2ceeaZ4dX9V111VXuVJoRoJzL8LYQQosVeeuklLrnkEo488kimTZvG8OHDSUhIID8/n++//57XXnstfIzjoYceyjfffINpmnGuWgjRmmRLISGEEK0iEAgwd+5c5s6dG7PNUUcdxZtvvimBUoguSHoqhRBCtFhxcTGvvfYan3/+OWvWrGHv3r0UFBSEV81PmTKF8847j1NPPTXepQoh2oiESiGEEEII0WKyUEcIIYQQQrSYhEohhBBCCNFiEiqFEEIIIUSLSagUQgghhBAtJlsKCSG6Ha01Pp+PyspKKisr8fl8tX55vd6oj/n9fizLCv+ybbvWf+s+BqCUQimFYRjh34c+NgwDpRQApmnicrlwOBw4nU4cDket34d+hR73eDx4PB4SEhJqfexwyNu6ECI+5N1HCNHpBAIBSktLKSkpoaSkpN7HZWVlVFZWUlFRQXl5ORUVFVRUVNR6zLKseL+MNuFwOGqFzYSEBJKSkkhOTiYlJYXk5OSov0KfS01NJSEhId4vQwjRCcmWQkKIuPP7/RQWFlJYWEhBQUGt/4Z+RYbH0MksrcHhcAR/mQ5M06z+b/Axp8OB01XdS+h24nK5QBP8hULbGmzQNjWPV/9SKLSGiuIKkjITKdhejFKgDIVhKgzTQDkUDqeJ6TQxncHfKxNQ4PP68FZ6qar04avy4fP68FX58fv8+P1+bG2hDQ1m9S/Val8S3G436enppKWlkZ6eXu9X6PHMzEx69OiBx+NpvZsLITotCZVCiDZj2zaFhYXs2bOHPXv2kJeXF/44tDl2KDA2h8ftwe1y43K4cBouTOXAxIGyDAgobL/GrtLYXptAhcaqsrCqbBKTEsnsk0HvIT3pM7wnWYMzyeyfhm1rCrYVUbijmILtxZTklVK6t4zSveWU7i2nrKAcK2DvU42GaXDXvBv4w1GPYVtNe65hGiRnJpKSlURKVjIpPZJI7ZVMRr90MgekkdkvHYfLpHBnCXu3FLBrwx52bdpD3pY9FO4uxlY2VAdObWowbXBotEODww4+5rDDv8es+VxzZtonJyeTlZVFVlYWPXr0qPVx5O+dTue+X1wI0WnI8LcQotmqqqrYtWsXO3fuZMeOHezatSscGkPBMRAINOlaSikSPYl4XB6cphsnTgzLgfIb2JVgVdj4Si18RX68xX5sL2gUVUAVAIHqX7Wl90llwP79GXBoX/rv15vew7MI+C3yNuWze9NeNi7ayvdv/ERBbhHlRZWt+NVpPtuyKdlTRsmeMmB31DYJqR56DEin55BMeg3PYsqZB9B7eBauBCd5OflsX72LbWt2sW3VLgq2FTXpvprqXk+HjXZqtNMGpx31v9qpwWmBCWVlZZSVlbF58+aY11ZKkZmZSZ8+fejduze9e/emT58+4d/36dOHxMTEff9iCSE6DOmpFELEZFkWeXl57Nixg507d9b7VVBQ0KTrJCUkkeBOxG14MC0nymdgl4Ov2MJb4KeqwIftDQ4Zt4RhKvqO6sWQSQMZOK4vA/bvg8PpYNuaXWxfvZNtq3exK3sPpXvLW3Sffatp33sqWyIpI5E+I3vSf7/eDNi/LwP26wMQDJgrd5LzUy7bV+9ulVpCIVS7bHBZaJcd/Ngd8bHLRrusJvWApqSkhIPmgAEDGDBgAP3796d///707NkzvMBJCNExSagUopvTWlNUVERubi65ubls3bqVbdu2kZuby/bt2/H7/Q0+3+VykZyQgsdMwGG5oMogUGxTle+nIs+HXaFRuhUn/NXRe3gWQw8cyNADBzD4gAFUFFey+adtbF2+g22rdpKfW0g83+XaO1RGk9k/jQH792Xg+H4MnTSA1J7JbFm+g5wlueQszmVXdl6bfo00Ojj87rHQ7uAvPBbabdf83tlwAS6Xi379+oVDZihwDhw4kF69ekngFKIDkFApRDdhWRY7duwgJyeHnJyccIjMzc2lrKws5vNM0yQ5MYUERyIOy4kuN/AXWVTt9lO1NwAB1eIexn3hcJkMPWggo6cOY9TUoSjTIGfxVnIW55KzZBtFu5o3P7OtdIRQWVdKVlJ1EB/IsIMHYjpM1n+Xw/pvc9i0aCu+yoZ/kGgL2rTDIROPFQygCQF0QnXobCAzJiQkMGjQIAYPHsyQIUPC/+3bt69ssSREO5JQKUQXY9s2u3fvDofH0K8tW7bg8/liPi85MYUkZxIOyw3lBr69NhU7vPiL7XYNjdEkpLgZc+QIxkwbztADB7Jncz7rvw2GoLbuZWupjhgq6+o1rAejpg5j9NSh9BnViy3LtrPu642snr+B8sLWW2nfXBoNbjsYMj1WMGh6qgOnJ3bgdDqdDBgwIBw0hw0bxvDhw+nfv7/0bArRBiRUCtGJVVZWsmHDBrKzs8nOzmbTpk1s3ryZysroC04cDgdpSekkqERUpQN/gU35tiq8+TbKjm9wrMud6GL0tGGMO3Y0QycNYPNP21jz9Uayv82hNL/95kS2VGcIlZES0xMYOWUI+00fwbCDB5G7cger5q5nzfwNVJZ6411ePVpVD6snVofMxED1xwEwoz/H4/GEA+aIESMYMWIEw4YNIykpqX2LF6KLkVApRCdRXFwcDo/r168nOzub3Nxcov0VNgyDtKR0PCoRVW7i22NTnuvFKm35Ypi2ZJgGo6YOZcLxYxgxZQjbVu9k5ZzqQFNSFe/ymqWzhcpI7iQXY6YNZ9wxoxgyaQA5S3JZ/tk61n69gYCvY28eH+rdtEMhM+JXrLDZt2/fcMgcPXo0o0ePpkePHu1buBCdmIRKITqg0tJS1q5dy+rVq1m3bh3r168nLy8vatvEhCRS3Gm4vG78ezVlW734Cqw2XRzT2rIGZTDplP2ZeMJ+lO4t56ePVrH6y2zKCuI/9NpSnTlURkpM87DfkSOYeOJYsgZlsOLztSz5YBW7N+6Nd2n7RKODPZpJAXSSH50UwE4KgDv696Znz56MGTOG0aNHh/+blpbWzlUL0TlIqBQizvx+Pxs3bmT16tWsWbOGNWvWsHXr1qhtU5NSSTJToMxB1TY/Fdt84IvR7dLBOVwm444dzYGnjqPnkExWfLaWJR+uYlf2nniX1qq6SqiM1HNIJpNO2p+JM/ejeHcpSz5YyfLP1sZlgU9r0Q67OmAGg6ZO8aMTrKgnFfXt25cxY8YwZswY9ttvP8aMGSOnCgmBhEoh2l1eXh4rVqxg1apVrFmzhuzs7KgLaFKTUkl2pKFKHVTk+inf6g2eFNPJpfZM5uAzJnDQaePYu6WQRe8sZ81XHX84tbm6YqgMMR3B6QoHnz6Bfvv15qcPV7HwrWUU7uxYK/CbSxs2OjmAnexHJ0cEzTpM02TkyJGMGzeOcePGMX78eHr27BmHioWILwmVQrQhrTVbtmxh+fLl4V+7du2q187tcpPmzsAod1G1PUDFFj8q0PkDZKQB+/fl0J8dwMjDhrL6y2x+eHNpl+uVjKYrh8pIWYMzmHL2AUw4fgw5S7bxwxs/kbNkW7zLanXatNHJfuyUQPC/qX5w1f++9u7dOxwyx40bx/Dhw2V7I9HlSagUohX5/X7Wr18fDpArV66kuLi4VhulFBnJmSTYyQTyNCUbqjr8ApqWGH7IYKb9cjI9BqTz41vLWPz+Sio6yHGI7aG7hMoQT7KbSSePZcrZkygvrODrlxay7puNHXrbp5YILwhK8WGn+tGpweHzun+dExISGD9+PAcccACTJk1i9OjREjJFlyOhUogWsCyL7OxslixZwuLFi1mxYgVVVbVXKTtMB+kJGTgqPFRuDVCZG+gSw9gNUQrGHDmCab+cTEKKh2/+u4hln6zuskPcDeluoTLEMA3GzRjFtAsnozV889JCVs5Zh211/X9ytGGjUwLYqT50SnVvpqP265aQKboiCZVC7IPQcPbixYtZsmQJS5cupbS0tFYbt8tDuicDVeSkdIMX/562PaawI1EKxh49iqMuORRt23z90kJWzV3fLYJELN01VIYoBWOmDWfaLw8hIdXDV8//wLJP13SrPxMaHdzOKM2PnebDTvPVO5YyMmROnjyZkSNHygbtotORUClEI/bu3cuPP/4YDpL5+fm1Pu9yukj3ZGIUuihd78VfoLvsUHZDRh46hGOumIrpNPnymW9Z+3XXHfLcF909VEYacchgjrliKq4EJ3Of+Y4187O75Z+RpoTMtLQ0Jk+eHP6VlZUVp2qFaDoJlULUEQgEWLlyJd9//z0//PADGzdurPV503SQkZCJUeyibL2XQH77nn3d0Qya0I9jrzyc1J7JfPncd6z4fB3alreVEAmV9e03fQTHXD4Vv9fP3Ke+ZcOPW+JdUlyFQqad5ken+7DTfWDW/js0dOhQJk+ezCGHHMLEiRNxu91xqlaI2CRUCkFwm58ff/yR77//nsWLF1NeXvsYwMyUHrirkijf4KNqm91thrMbktEvjeOvncaA/fvy1ewfWPLBSqyAhKa6JFRGZ5iKCcfvx1GXHkp+biGf/uMr8nLyG39iN6CVDs7FTPdhZ3jRybUX/rhcLiZMmMDUqVOZOnUq/fr1i1+xQkSQUCm6JcuyWL16Nd988w3ff/89OTk5tT7vcXlINTMJbIOy7K63vU9LuBNdTLvoEA4+fTw/vrWMb15a2Kk3vW5rEiob5nCZHPbzAzn8/INZ/tkavnzu+057JGdb0Q47GDDTvdgZvnqn/wwZMoSpU6dy+OGHM3bsWEyzcx6IIDo/CZWi2/B6vSxatIhvvvmGb7/9lsLCwlqfz0zugaMkgdK1XqyC7j2kHY1ScMBJ+3PsFVPZsnw7nz/5DUVdZJPrtiShsmlSeiRx7FWHM+qwocyf/QML31kuX68oQsdM2hledA9vcGV5xFtVWloahx56KFOnTmXy5MkkJyfHr1jR7UioFF1acXEx3377Ld988w0LFy6std2Py+kiw5mFf7uibJ1PeiMb0Ht4FqfeeiwOl4OPH5vHlqXb411SpyGhct/0G9ObE2+YjjPByfsPz2H76vqHBYga2rSxM3zYmV7sDG+tBT+maTJp0iSmT5/OtGnTyMzMjGOlojuQUCm6nL179zJv3jy++uorli9fjm3X/EOe6Eki2Z9G+foA/l3I3MhGON0Ops+awsGnT2D+89/zwxtLu9VWMK1BQuW+UwomnTKOGVcdzsov1jHnqW/xVtQ/ylTUptHoVH8wYGZ60Yk1+8IqpZgwYQLTp0/nyCOPpFevXnGsVHRVEipFl5Cfn8/8+fOZO3cuK1asIPKPdVpiOu7yJEpWebGLDBnWbqLhkwdxym+OZc/mfD585EuKd5c2/iRRj4TK5kvOTOSE66czeGJ/Pv77l6z5amPjTxJhtieA3cOLnVWFTgnU+tz+++/PkUceyfTp02Whj2g1EipFp1VYWMj8+fP58ssvWbp0aa0gmZnUA7MggZJVVVAhk9b3hTvRxcwbpjPi0CF8/Pd5rJ6XHe+SOjUJlS03YsoQTr75aHas282Hj3zZrY75bC3abWH1qMLO8qJTas/DHDVqFMceeyzHHnus9GCKFpFQKTqV0tJS5s2bx9y5c/npp59qDW2nJ2Zi5LkpW+1H+SRINsfQAwdw+u+OJ3fFDj7625dUlnrjXVKnJ6GydbgSnBx/zTTGTBvO+w/PYd2CTfEuqdPSTivcg2mn1QRMpRQTJ07kuOOOY/r06aSmpsa3UNHpSKgUHZ7f7+eHH37g008/5dtvv8Xvr9m+Jj0xEzPfQ+kqH6pKgmRzOd0OZvzqcMbNGM2Hf/1SeidbkYTK1jXikMGc9tvj2LhwC588Nh9vucy1bAntsLGzqrB6VqHTat5bHQ4HU6ZM4bjjjmPq1Kl4PJ44Vik6CwmVokPSWrNmzRo+++wz5syZQ3FxcfhzaYnpuIqSKF7hRVVKkGypPiN6cs49J5KfW8j7D8+hrKAi3iV1KRIqW58n2c1JNx3F4In9eePej8ldsTPeJXUJ2m1hZVVh96pCJ9XMwUxISODII4/khBNO4MADD5QzyUVMEipFh7Jr1y4+++wzPvvsM7Zu3Rp+3ONKINmbTulyP5RKkGwtk8+YwLFXHs4X//6GRe+uiHc5XZKEyrYzfsZoTrr5aBa8vJgF/13YLc8Rbyt2YgC7ZyVWzyrw1Py57dOnDzNnzuTEE0+kb9++caxQdEQSKkXc+f1+vvnmG95//30WLVoUftxhOsgwsyhfYxHYKZuRtyZPspvTbp9Br6E9eP3uj9i9cW+8S+qyJFS2rcwB6fzs3pMoL6rk7T9+Snmh9LS3Jk3wyEirVxV2zypw1ESGgw46iJNOOokjjzxSziIXgIRKEUdbt27lgw8+4JNPPqGoqCj8eGZiFvZWBxXZFsqSYZbW1n+/3pxzz0lsWbadj/72pRyx2MYkVLY902ly/DVHMPboUbz1h4/JWbIt3iV1SdrQ2D2qsHtXYafXzGVNTk5mxowZnHTSSYwePRqlpAOgu5JQKdqV1+tl3rx5fPDBByxbtiz8eIIrgcSyNEqXB2TBTRuadPL+HH/tND79x1cs/Xh1vMvpFiRUtp8x04Zz2u0z+PrFhXz3vyXxLqdL024Lq1clVu/KWsPjI0eO5IwzzmDGjBkkJCTEsUIRDxIqRbvYsmUL77zzDp9++illZWVAcPuKDFcW3rUa/3bZlLwtmQ6DE66fzqipQ/nf799n5/o98S6p25BQ2b56DMzg/AdOZce6PN5/6Av83kDjTxLNptHoND9W70rsrCqoHlxKSkpi5syZnH766QwZMiSuNYr2I6FStBnLsvjhhx948803WbhwYfjxRHcSnuIUypYHZD/JdpCUkci5fzgJ29a8fvdHsnF0O5NQ2f7cSS7OuuMEUnul8Or/vS+nQbUT7bCxelVi961EJ9QcETlp0iTOOOMMpk2bhsPhiGOFoq1JqBStrrS0lI8++oi3336bHTt2hB/PdPWkag2y6KYd9RnRk/P/fBpr5m/gs39+LaEmDiRUxodSMH3WoRx8xnheu+NDtq7Y0fiTRKvQaHS6D6tvJXamN7y5eo8ePTjllFM4/fTTycrKim+Rok1IqBStJicnhzfffJPPPvuMqqoqAFwOF8mVGZSvsDG88hNqexp+yGDOuuMEPn/ya5Z+vCbe5XRbhmlwx5zr+OOxj0uojIMxRw7n1FuP5cNHvmT1l7Kpf3uzXRZW7woCvSrAFfzz73A4mDFjBueeey4jRoyIc4WiNUmoFC2itWbhwoW8+uqrtbYDSnGnQq6HKYdN5tjLj4hjhUIIIeJt7rPf8uUHX2H1rah1cs9BBx3Eueeey5QpU2RT9S5AQqVolkAgwJdffskrr7zChg0bgOqFN44sKlZq7D3BhTfKULK9RDtSCo65fCrjZozild+9R96mgniX1O1JT2XHkNEvlfP/fBpblm7n40fnYVvyT1970lqj7eDX3E72Y/Uvx86qGRofNGgQ5557LieccILsedmJSagU+6SiooIPP/yQ119/nV27dgHBTcpTvJmU/2SjvLLwJl4M0+CM/zuOnkN68PJt71KaXx7vkgQyp7IjSUj1cN6fTsFb4eO1Oz8k4LMaf5JoM9ptYfWtwOpTGd5UPS0tjTPPPJNzzjmH1NTUOFco9pWEStEkhYWFvPnmm7z99tuUlgZXUrqdHjwFqVSu0qiADFvEk8Nl8rN7T8KV6OKV374nG5p3IBIqOxaHy+Sce07Ck+Lmldvfw1vha/xJok1p08bqXYnVryK852VCQgKnn3465557rizq6UQkVIoG7d27l5dffpn33nsPny/45pvkSsbITcC7UaFsGdqON1eCk/MfOA1flZ/X75Lel45GQmXHE+rVzxqUyUu/eZuK4qp4lyQIrhq3s7xYA8rRycH9RV0uFyeeeCLnn38+/fr1i3OFojESKkVUu3fv5uWXX+aDDz7A7w/2eqW60giscxKQjco7jIRUDxc+fAYF24t4+0+fSWjpgCRUdkxKwYm/Ppohkwbw4s1vUbpXpot0FBqNneHDGliOTg3++2OaJjNmzODCCy9k8ODBca5QxCKhUtSya9cuXnrpJT766CMCgeBPiqnODHwrDew9poTJDiQxzcNFfz+bbSt38uHfvgxPghcdi4TKju3YK6ey/9GjmH3DG5TsKYt3OSKCRqNT/VgDy7EzgiNlhmFw3HHHcfHFFzNgwIA4VyjqklApAMjLy+P555/no48+wrKCw6dpzgy8yw3sfAmTHU1CijsYKFft5MNHvox3OaIBEio7vqMvO4xxx45i9vVvyAK3DspOrg6XPbxAsOfyhBNO4KKLLpJh8Q5EQmU3V1RUxEsvvcTbb78dHuZOc2ZStUxBgWxW3hF5kt1c/OjZbF+zmw//Ogf5G9yxSajsHI69cir7TR/B7BveoCy/It7liBjsZD/WoDLszGDPpWmanHTSSVx00UX07t07ztUJCZXdVHl5Of/73//43//+R2Vl8CzoVEc63mUmFEqY7Kg8yW4u+ttZ7Nqwh/cf+kICZScgobLzOO7qIxg1dRjP3/gGZQUSLDsyO8WHNahmWNzpdHLGGWfwy1/+kvT09PgW141JqOxmvF4vb7/9Nv/9738pLi4GIMWZim+FA73XIcPcHZgrwclFfzuLPVsKeO/Pn0ug7CQkVHYux187jRGHDOY/171OZak33uWIRtipvmDPZXpwpC0pKYlf/OIX/OxnP8Pj8cS5uu5HQmU3obVmzpw5PPXUU+FNy5Ncydhr3Vg7ZM5kR2c6DM7/82l4K3y8cc/HsiinE5FQ2fmc8ptj6T2sBy/c/Bb+qkC8yxGN0Gh0uo/AkLLwVkRZWVlceumlzJw5E4dDRt/ai4TKbmD58uU88cQTrFmzBgCPMwEzJxH/ZgmTnYFScOYdM0nukch/b30Xyy/7UHYmEio7H2UofnbvSTjdDl753fvyfeskNBq7ZxWBwWXhTdQHDx7M1VdfzWGHHSZHBrcDCZVd2LZt2/jXv/7FV199BQSPU/TkpeFbZ8qm5Z3IzOunM2hiP2Zf/4aclNMJSajsnBwukwsePoOSPWW886dPZbpJJ6KVDh7/OLAcnMFv3CGHHMJ1113HkCFD4ltcFydn63VBFRUV/POf/+Siiy7iq6++QilFqrcHxrfp+Nc4JFB2IkdccDAjDxvCf3/zjgRKIdpRwGfx6u/ep9fQHhx39bR4lyP2gdIKx44kXIuyMLclgg0//vgjl1xyCY899lj4qGHR+iRUdiFaaz7//HMuuOACXn31VQKBAKkqA+eSTLwLHSi/Ge8SxT7Y/+iRHHruJF685W3KiyrjXY4Q3Y63wsd/b32HsUeN5ODTx8e7HLGPlGXg2JyCa0kPjHw3lmXxxhtv8Itf/IJ33303fMCHaD0SKruIjRs3csMNN3DfffeRn59PgiMR97pMvF+7UOUySbmz6b9fb0659Vj+9/sPKNpZEu9yhOi2ygoqePn2dzn2ysMZdtDAeJcjmkFVOXCuSce5Mh1VYVJcXMxf//pXrrzySlatWhXv8roUCZWdXFlZGY8++iiXXXYZy5YtwzRMEvdmYs1Phj3OeJcnmiGtVwrnPXAaHz3yJbkrd8a7HCG6vbycfN667xPOuecksgZlxLsc0UxGkRvnkh44NqaAX7FhwwauueYaHn74YUpK5If31iChspPSWjNv3jwuvPBC3nzzTWzbJsXKwPwhA2utE6Vl3mRn5Epwcv6Dp7H4vRWs+GJdvMsRQlTL/n4z82f/wC8ePJ3ENNn/sLNSKMydibgWZ2Hu9qC15v333+fCCy/kk08+QdYut4ys/u6Edu/ezd///ncWLFgAQKIjCWuFG/KlZ7KzO/e+k9G25o17PpLVpl2ErP7uWk6++WiyBmXy4i1vYVvyl7Szs1N9BEaUoBODW7UdcMAB3HzzzbJKvJmkp7ITsSyLN998k4suuogFCxZgKIPE/AwC85MkUHYBU88/iB4DM3jngc8kUArRQX3y2HxMl8kxVxwe71JEKzBKXDh/6oGZkwyWYunSpVx22WW89NJLspCnGSRUdhI5OTlcd911PProo1RWVpKkUjAXZ2CtcclQdxcw9MABTLtwMq/d+YGc4CFEB2YFbF6/80MmztyP/Y4cHu9yRCtQWuHYnhRcJV7gwu/389RTT/GrX/2KDRs2xLu8TkVCZQdnWRavvPIKl19+OatWrcJhOknYnon/6wSMClnV3RWk9kzm7LtP5J0HPiM/tyje5QghGlGaX84b93zEabcfR4+BsnCnq1BeE8fqdBzrUiGgWL9+PVdccQXPPfccfr/sE9wUEio7sNzcXK6//nqefPJJ/H4/yXYaxndp2DlOOV6xizBMg5/dexI/fbiKdd9sinc5Qogm2rJ0O1+98CM//9MpOD3yA35XoVCYexJwLa7Z23L27NlcfvnlrFsniycbI6GyA7JtmzfffJNLL72UlStX4jAceDZn4PvWjfLJBuZdydGXH4Zl2cx95rt4lyKE2Eff/W8J+bmFzLx+erxLEa1M+U0ca9JwrEkDnyInJ4df/epXvPTSS1iWFe/yOiwJlR3Mnj17uOWWW3j00Ufxer0k2ikYP6Sjt7mkd7KLGXrgAA46ZRxv3fcJ2paVOUJ0Ru89+AUjDx3C2KNGxLsU0coUCjPfg2tJFsbeYK/lU089xY033siOHTviXV6HJKGyA/n666+55JJLWLx4MabhwLMtg8C3CSiv9E52NYlpHs68YybvP/wFJXll8S5HCNFMlSVVvPXHTznllmNJ65US73JEG1ABA8faNBzrU8FSLF++nEsvvZSPP/5Y9rWsQ0JlB+D1ennkkUf4/e9/T0lJCYkqGePHNPRm6Z3sqk67/TjWf5vDmq82xrsUIUQLbf5pG4veW8FZd56AMuQ9uytSKMy8BFxLeqBKnFRUVPDAAw9wzz33UFYmHQMhEirjbNOmTVx55ZW88847ACTkpxH4JhGjSiZ+d1UHnrI/PQZm8Ok/5se7FCFEK5n33PeYTpPDzz8o3qWINqS8Js7lGTg2J4OGL7/8kssvv5y1a9fGu7QOQUJlnGit+eCDD7jyyivJycnBZbpxrsrAXuORfSe7sLReKRx39TTeuf9T/F7Zj1KIrsK2bN65/zOOuGAyPYdkxrsc0YYUCnNbEs5lmagqkx07dnDNNdfw5ptvdvvhcAmVceD1ennwwQd56KGH8Pl8JAZS4NtUjEJXvEsTbezU245l8Xsr2L5md7xLEUK0sr1bC/nqxR85/XfHY5jSOdDVGWVOnD9lYuS7CQQCPProo9x5552UlpbGu7S4kVDZzkI/0Xz00UcoFJ6d6QS+T0D55VvR1U06aSxpvVOZ95/v412KEKKNfPe/JaA1h557YLxLEe1AWQaONWmYG1PAhq+++orLL7+c7OzseJcWF5Jk2tG3334b/sPmNFw4VqShN7plMU43kNozmeOvPZJ3H/iMgE/2OBOiq9K25p0HPuPIXx5C1iA5bac7UCgcOxNxLs9EVRns3LmTa665hjlz5sS7tHYnobId2LbNc889x29/+1vKysrwWEmo71Mxit3xLk20k5NuOpolH65k2+pd8S5FCNHG9m4p5Jv/LuS022egpM+g2zDKnDiX9sAodOH1ern33nt58sknu9Vm6RIq21hVVRX33HMPs2fPBiChKA37+yQ5GacbGX34MPqM7Mm852TYW4ju4ttXl+BJdjNx5th4lyLakQoYOFalY25LBOCVV17htttuo6SkJM6VtQ8JlW0oLy+P6667jnnz5qGUgWtTOvZKWd3dnTjdDk688Sg+eWw+/ipZ7S1Ed2FbNh/8dS7HXX0ECSkyKtWdKBSOzSk41qaBpVi4cCFXXnklmzdvjndpbU5CZRtZvXo1V111FevXr8epnDiWpaF2yBtLdzPtokPIy9nL2q9lk3Mhuputy3eQ/f1mjr3y8HiXIuLA3OvBuTwDVWWEF+n+9NNP8S6rTUmobAPz5s3jhhtuID8/H7dOQP2YhlEi2wV1N1mDMjjkrIl8/Pd58S5FCBEnnz/5DWOPHkn/sX3iXYqIA6M8OM9SlTgpKyvjlltu4ZNPPol3WW1GQmUre/PNN7n77rvx+Xx4qpLR3yfL2d3d1Mwbj+K7/y2hcGf3mEsjhKivvLCCL5/5jpNvOloW7XRTKmDgXJmBsTe4n+X999/Pc8891yU3SpdQ2Uq01vzrX//i0UcfRWuNuyAFe1EiypIvcXc0/JDB9BycyYKXF8W7FCFEnC1+fwUOl8m4GaPjXYqIE2UrHGvTwgt4Zs+ezf33308g0LXm2ne6xFNQUMDVV1/N9ddfz4033sjevXtZvnw5V199Nddeey0bNwbnrq1Zs4brrruOF198sc1rCv3k8fLLLwPg2paKXp0g+092U8pQHH/NNOY8vUD2pBRCYFuaz/75DcdeeTgOl4xcdVfhBTzZKaDh008/5Y477sDr9ca7tFbT6UJlWloaTzzxBP/4xz+YOXMmH374IU8//TQPPfQQd911F//6178AmDNnDg8//DB5eXltWk9lZSW//e1v+fTTT1EonBtSUZslUHZnk04aixWwWPHZ2niXIoToIDb8sJn83EKmnDMp3qWIODN3J+JYnQ528FCU3/zmN5SVlcW7rFbR6UKlaZoYRrDsiooK+vfvj2EYpKSk0Lt37/CZm8cccwy33norWVlZbVZLeXk5t956Kz/++COmMjFXpWHsSmiz+4mOz5Xg5OjLp/LZE1/TBafLCCFa4LMnvuaICw8mMV3+nejuzEI3zpUZEFAsW7aMG2+8kcLCwniX1WKdLlQCZGdnc9VVV/HWW28xbtw4kpKSwp8zTRO/38/YsWN5/PHHufjii9ukhtLSUm6++WaWL1+OqRwYS1MxC2XLoO7usJ8fyI41u9j807Z4lyKE6GB2b9zL2q82cuRFh8S7FNEBGCUunCsywG+QnZ3Nddddx+7du+NdVot0ylA5cuRI/v3vf3PZZZfx4osvUl5eHv6cZVk4nc42vX9RURG//vWvWbNmDQ4cGEtSMUply6DuzpPs5tBzJzH3me/iXYoQooOa99z3TDppLKk9k+NdiugAjHInzmUZUGWQm5vLr3/96zaftteWOl2o9Pv94Y+Tk5NJSEjAsixKS0vZvXs3KSkpbXr/goICbrzxRrKzs3HgRC1JxShv2xArOofDfj6JTQu3snvj3niXIoTooIrzSln+2VqOuHByvEsRHYRR5cC1PBNVabJ9+3ZuvPHGThssHfEuYF9lZ2fzz3/+E9M0cblc3H777Wzbto3bbrsNpRQ333xzm927uLiYm266iZycHJy4YHEKRmWn+xKKNpCQ4uaQsw/guWtei3cpQogO7usXF3Lti79kwX8XUZxXGu9yRAegfCbOlRn4xxeGg+Vjjz1Gz549413aPlG6K+6+2QZKS0u56aabgscu4kItSkFVSaAUQcdcMZWMfmm8ee/H8S5FdDCGaXDXvBv4w1GPYVt2vMsRHcSJvz4K0zT44K9z412K6EC028I/vhDtsejfv3+nC5adbvg7HioqKrjttttYv349DpywWAKlqJGQ6uGQsyYyf/b38S5FCNFJfPPiQsYfN5q03m07ZUt0Lspr4lwRPC98+/bt3HzzzRQXF8e7rCaTUNkIr9fL7373O1atWoWJA/WTDHmL2iafOYGNP25h75bOvx2EEKJ9lOaXs/yztRx27oHxLkV0MMFgmQlegy1btnDbbbdRUVER77KaREJlAyzL4t577+Wnn37CVCbGUlmUI2pzuEymnH0AC15ZHO9ShBCdzHf/W8IBJ40lIUW2oxO1KW9wjiV+xZo1a7jjjjvw+XzxLqtREipj0Frz6KOP8s0332AoA2NZKkaZBEpR28SZY8nLyWfH2s69t5gQov0VbC9m48ItHHzGhHiXIjogo9KBc1UGWIpFixbxpz/9Ccvq2Ef/yjhuDK+88grvvPMOAI61qZjlHpAjW0UEZSimnncgnz7+FYYpP5+J6EJ/NuTPiIjmu9eWcN6fTuWHN5YS8HXswCDan1HpRq3LwDemgC+//JLMzExuvPHGeJcVk6z+juLzzz/nvvvuA+Dkk0/miCOOiHNFQgghhOiuli9fziuvvALATTfdxJlnnhnniqKTUFnHsmXLuOmmmwgEAjh3JeHISY13SaKD+uUjZ7Lii3Us/Wh1vEsR8aJUzcfR3kqVwjAN7vjiWv444wnsQJSeqMauIbq8UYcP5ehLD+Pfl70c71JEB+bvV0pgcBmmafLggw9yyCEd77hPGf6OsHv3bu68885goCxORG1Iwkb2lRP19RySSZ8RPXn5tndl78HuSimgTgiMDIV1Pm9bNratG2xT7xqiW1j3zSZmXj+dAWP7sHXFjniXIzooIzcRIyGA1auKu+++myeffJIhQ4bEu6xaZJJPNa/Xy+9//3uKiopw+NyoVckoVONPFN3SwaePZ+knq/F7A/EuRcSDivHeEOvxtrqG6BK0rVn83gomnykLdkRsCoUjOxVV7KS8vJzbb7+doqKieJdVi4RKgiu9H374YdavX4+pHRjLUlC2vLGL6FwJTiaeMJZF76yIdykiHpoS+hpq09Lniy7ppw9XMfrwYSRlJMa7FNGBKa1wrklHVZrs3LmTP/7xjx1qRbiESuC1117js88+Q6EwVqagvLLMW8Q2fsZotq/dRX6ubHbe5TQS5pTpQBkNvG0qhXI0svVYE9oowwSzkfchCZ5dSllBBeu+zWHSyfvHuxTRwamAgWNNGliKH3/8kRdeeCHeJYV1+1C5cuVKnnzySQDMjckYxa44VyQ6uoNOG8+id6WXsssJhbQYYU2ZDoIzYmIPWyvTBFXdtrltqm+hlIodLBupVXROi95dzkGnjpNvq2iUUeHEuTF4xOfs2bP58ccf41xRULcOlaWlpfzhD3/Atm0cBQkYOxPiXZLo4HoOySS9byrrv82JdymiNTVpSLrmv/V6K0NhEVXdIEpobEobqnsp69yyxbWLTmHrsu0ADJrQP86ViM7AyEvA3JWA1pr77ruP3bvjfwhHtw2VWmseeughdu3ahRlwYqyThTmicRNnjmXlnPVY/o4zh0W0ULRQVuexqAExFCxrhcVwg3qhsUltDLNOkyi9lU2oV3ROWsOyT9cwceZ+8S5FdBLmxhRUmYPi4mL+8Ic/xH1+ZbcNle+99x7z58+vmUdpddsvhWgiZSgmHD+GZZ/IvpRdRhMW1NQMe9f/fE2PZdQGwf85HA23CX1UN1CGbxMRLFu6AEh0eMs+WcPYo0bidMuOf6JxoYU7WIoVK1bw8svx3eu0WyapzZs389hjjwFgbEqSM71Fkww9cCC+Ch/b18R/iEG0gsZCWGhBTUPNDAPD42noIjQ6iG0ojISEBpuppiwACjZsvI3o0Ap3FJO3aS+jjxge71JEJ6G8Znh+5XPPPce6deviVku3C5WBQIAHHngAv9+Po8SDuUO2bxBNM/GEMSz7dE28yxCtoSmB0jSD7RrYT1K5GlnYpxQqoQmL/xq7loo9BzNqW9GpLf1EhsDFvlF5Hoy9bizL4r777qOqqioudXS7UPn666+zZs0aDG1irJV5lKJpTKfJ6COGs/KL+P0EKFpJUwNlw12HNSFQKZQzSthTCuVxh99jlDtKT6MC5XTWv2a0hg0s7ol2b9F5rZm/gSEH9MeT7I53KaKTUCgcG1LBZ7B161b+/e9/x6WObhUqt2zZwjPPPAOAkZ2E8sl+lKJphh08kMIdxRTuLIl3KaIlmhUo6/RWRgt/dYNlOFBGPGQYKHfE8yIDZSPXrv0kCZZdXWVJFVuX72D0EcPiXYroRFTAwLk+FYC33nqLVatWtXsN3SZUWpbFn//8Z/x+P2axGyOvoXlQQtQ2dvpIVs/LjncZoiVa1EOpwkPhMXsTQ8EySqAMNwkFy2iBMvI6Eb2g9euRYNkdrJ6XzdjpI+JdhuhkjKJgvgmdFBgItO9Rwt0mVH7wwQesWrUKQxuY61Jk2Fs0mWEajJk2nNXzNsS7FNFcTQmUTicNDnkbBkZSUsPXcTgwMtMbfHdRDgdGZkbD1zEMjOSkBuppJODWairvdZ3R2q83MuzgQbgT5UAOsW8cm1LAr9i0aRP/+9//2vXe3SJUFhcX8/TTTwOgNsmwt9g3Qw8cQMmeMjmWsbNqQqA0XK7g1j2xjmA0FEZSIphG7CBnmhgpycEthJJiLAA0DFRSIsrhQKUkx6xHuVxgmMF7xirbNIKrwiVYdknlRZVsW72LUVOHxrsU0cmogIEzJ7ga/D//+Q/bt29vt3u3SqgsLS2N6xL2xjz99NOUlJRgVjox5dQcsY9GHT6MtV9vjHcZojmaGChrNa8bLEOBMnQtI0qQqw6UNXtbmvWDZXWgDLeJFixDITE06m0YGEn137OUaUQ8RYJlV7X2642MOlzmVYp9p/I8GEUufD4f//jHP9rtvi0OlfPnz+eqq67izjvvBCA7O5tbb721xYW1lrVr1/L+++8DYGTLam+x70ZOGcKGHzbHuwzRTupnrwa2FWrgiaopJ98Y0drU+VjCYLe14YfNDJ88CBXtz4kQDVAozI0poOHbb79l8eLF7XLfFofKF154gaeeeoqUlGBX68iRI8nLy2txYa1Ba81jjz2G1hpjjwejROamiH2TOSCdhFQP21bvincpYl81ZR5lrB6+UG+loaL2FNbqrQz1Uka7RkRvpYoylK0Ms6a3MlY9qnZvZWQvZc1Lkd7Krig/t4iqMi/99+sT71JEJ2RUOsKjs0888US7HOHY4lDpdDpJTq79hhr1J/Q4WLBgAStXrkRpA0dOjPlLQjRg5KFD2LhwC9rW8S5F7IsmBsqYy2Cqj1esNexdl6FQHk+tYe961zFrh8aobRwOjNSUmmHveg0Iz6+MFihrapZg2RVt+H4zIw8dHO8yRCdlbk2GgGLDhg188sknbX6/FofKvn37smjRIgDKy8t57rnnGDEi/tsgWJYVXpxjbPPI4hzRLCMPHUL2d5vjXYbYFy0MlACYJio1GWJt+1Pdhl6Z6JTYi2m0aWD1amylt0JnpEJWesM1u92xF/eEm0mw7Gqyv9/MiClD4l2G6KRUwMCRG9y14umnn6aysrJN79fiUHnzzTfz6aefsmfPHs477zx27tzJjTfe2Bq1tcicOXPIyclB2Qbmtka2AREiCofLZPDE/mz4cUu8SxFN1VqBMjkpGNCUAkeU/SBNE3qkB4e4TROdXH+IXJsGdo/U8LxJKyOl/nUMhU6u7g11OoPXrF909f6XdXo+Y75ECZZdyeafttFrWBaJabK3smgeY0ciqsqkoKCAd999t03v1YTdcxuWkpLC73//+9aopdX4/X6effZZAIytiSirW+ycJFpZ//36ULSrhPLCiniXIpqilQNlzdMU2uGA0CbCkYEy4nk6OQFVFuwFqBsoAXA5sDJTMAtKg7+PDJQhoWCZXxS6e70jIJVpQkoyurSsgZeqwOVC+3wNvdrgvbVM7ejI/N4AO9bsYtCE/rILhWgWpRVmbhKBkSW8+uqrnHHGGXg8bfNDSrND5Ysvvtjg53/5y18299It9vnnn7Nz506MgIm5I/bQlBANGXxAfzYvbb/9vUQLtFGgrHl6dbDUun6gjHi+Tk6ASm/9QBkSCpZFZfUDZYjTUR0si6OfKY4Ey+5m89LtDDlggIRK0WxGngc1sIyCggLee+89zj333La5T3OfGAgECAQCbN68mQ8//JDi4mKKi4v56KOP2LIlfsOFtm3zyiuvAKByE1C2DPGI5hlywAC2LN0W7zJEY9o4UIY5ovRQ1mF7nFSM6RU9UIbaJDgpH9OrgbpVMFg2NMcSGQrvTrYs3cbgA/rHuwzRiSmtwlMBX375Zbxeb5vcp9mh8pJLLuGSSy4hLy+PZ555huuuu47rrruOp59+mt27d7dmjfvku+++Y8uWLcG5lLtko3PRPKbDYMD+fdkiPZUdW1MCpcPZcE9cdThTDYRF7XRg9euBneyO2cZ2GVQOTEY7GnlbVQo7wUHFgNiBUBsGVloiVt/Mhi/lcKBSo8zVrNeugQVHEXWJjil31U56DsnE08CfPyEaY+xOgCqDgoICPv7447a5R0svUFBQQGJizRCzx+OhoKCgpZdttlAvpbHdI3MpRbP1Hd2b0r1llOaXx7sUEUtTA2V1Mx0tWIYCZehaUa6pnQ6sPhlgGmjDwE6sH9Bsl0HlgGS0qdAORVXP6POVbIcR/JwC22NGDZbaUMF7GArtcsYOlhGn98QKluHXHPpaNEaCZYfkrwqwc/0eBk3oF+9SRCemtMKxI9hb+cYbb2Dbdqvfo8Wp67DDDuOmm27i3Xff5d133+WWW27hsMMOa43a9tmqVatYvnx5sJt3p8ylFM03YP8+5K7cGe8yRCz7GChDagXLuoEyyrUjA2Xwc8FeRDuhfkDTpgq3sV1GvWAZDpSh3c1UxHNC1zBU8Nqq5lra5cTqUydY1j29J0qwrPVaq0/mkWDZeeWu3MGAsbIJumgZY7cHAoqtW7eycOHC1r9+Sy9w3XXXcfbZZ5Obm0tubi7nnHMO1113XWvUts/eeecdAFSeW/alFC3Sf0xvdqyN3zQO0YBmBsoQrXXsQBlxjXqBMvy56tXd1cHSdgZ7Keu2qRssawXKUC1OI9xbGQ6UdedjKtDuiGDZ0Ebr1cEyaq+sBMtObcfa3fSTk3VECynLwMwLTg184403Wv36Ld5SCODII4/kyCOPbI1LNVtJSQlz584FkF5K0WL9xvTm+zeWxrsMUVcLAyWAMgxUUmKDi3K004HVNyP2/aqDZSDNg7eHq16PY6iN7TKo7Fs9t9sE6o42hYbBB6XgzvfGXuBTHSwD/Xvg2BF7epEyTUhKQpfFWBWugv+nHE50wB/zOsG2siq8I9m+Zjcn3XR0vMsQXYC5PQGrbwU//PADO3bsoF+/1ptW0eJQGWuj80cffbSll94nn3zyCX6/H1XuQJW1SlYW3ZQn2U1a7xR2b9gT71JEXVo3uGpaKQNsu37vYqiFYaCSG+ihrLkU2jRAg4oRrCy3QckwD2jwFEefm2S5FCWDGx41sU1FZV8nVRkmaZtin3ahTYXSTRhcMk2M5GTsWMESQNsow0A3NKdKAmWHUrijGKUUGX1TKdxZEu9yRCemvA6MIhd2ho+PP/6Yyy67rNWu3eL0dfnll4c/9vl8zJs3j6Sk9j3BRmvNhx9+CIC5MwHV8OYhQjSo3+he5OXkE/BZ8S5FRBM1WKrg6m0FoMGqHyxDgRJDoQFl66g9g9rpINAnI3RZNKpesLRcBiXDPdjVPZRVaUa9YGk5FaWDTJQj2KZkgEny1kCtNrah8GYYaAWBRIPiYQlRg6WurlObJoF+mbF7K207+DVwxAiWGrCr/1wrFTtYSqDskEJD4BIqRUsZuxPCoXLWrFmYZutMGWzxnMrx48eHfx100EHccsstLF26tBVKa7pNmzaRk5MDWmHskaOsRMv0Hd2Lnevy4l2GaEit0BMZKMMNgsEy1CIiUNa00GDXDk/hYe8YPZ1QHSiH1QRKANupqEqreU4oUNoRP7bbCYqSgTVv3Lah8KYHA2VIKFjGVL1wJ9Avyopw26bWq6nusax5cdQEyvD1VP2tlCRQdlg71u2m3+he8S5DdAFGvhsCiry8PBYvXtx61221K1XbsGEDxcXFrX3ZBn3++ecAGPku2UZItFjPIT3I25Qf7zJEY7QmeqAMNwDLjhooa1rUBMtQoNTRFuZU94yGA6Wj/rVCwTJaoATQCqzqYBkOlFHeruoGSx1t4U7dYFk3UFa3CwfLaIEy3C4iWEqg7NDycvLpOaThvUuFaAqlFWZ1J1xoPUpraPHw99FHHx2en2QYBr179+aaa65pcWFNZdt2+AsivZSiNfQcksmyT9fEuwzRFEo1uCgHQ6Hc7gZPuNEEV4NHDZTh+4DlNikZ4o4aKEP8yYrC8Rp3jOm4WoE/BfZM0aRkxy47FCxTN1fFrEe7nAT6ZuLYvrd+oIxoh2mg3C50Zez5mqBkYU4nsCengJ5DesS7DNFFGHs9WH0r+frrr/nNb36Dw9Hy9SgtvsKXX37Z4iJaYu3atezatQtlKYxCOW1AtIxSwZ7KPZulp7LDa+AEnHr8fnDG2ErHYWL3TA+uzI4xrchyGxSN8qANMGIsmrY8UDLaInbCq2aALxVKRtukrosdYn3pwXumr48RLAkO61u9MjDyCqM30Bp8/uDZ5Y2UBSr4NW2DDZFF69i7tYC0Xik4PQ78VYHGnyBEA1SxE3wGpaWlLFmyhEMOOaTF12zxWPHNN9/cpMfaynfffQeAKnTJOd+ixdJ6p2L5LcryK+JdimiIYRDqooy6J2N1GyPBA6Ehbn+UNOgwsXsF51AqrVH++oEqFChthwruJRklm4YCpe0E2wlVfaIPNWuHprKPBQr8yZqS0VECnAquGtdK4U8M3rv+hcDwV9/D5Qy+hnptgoEy2FihEmLM1dSRX0O1b2FdtKuAz6JwZzE9B8sQuGg5hQrOrQTmz5/fKtds8btH3fmTVVVV5OW13yKHb7/9FgCjQHopRcv1HJIpvZQdXUSgBOqEopo2RoInYpW4rt+DGBEoQ+oGy8hAGb5dnWAZGSiDFwHLo+sFS+3QVPa10I6advWCZXWgrPl9lGAZGSirnxMzWEa8aGUa9YNltK+dBMsObc9mGQIXrcesDpXff/997B/Q90Gzh7+ff/55Zs+ejW3bHHPMMUDwzSkhIYEzzzyzxYU1xZ49e8jOzg6+yUqoFK0ga3AGe7fGGEoU8Vc3UIbo4NxIpVSUQBlqo2uGwaMEyhClNfhtAsmOeoEyfClDYTs12qwTKMMXqQmWSbuDb7OVfSICZUS7ULBMXW/UDpThNjXBMn1dVe1AGXGdULA08gojeinrNDMNSEgIzq+MGigjLihD4R3S3i0FZA2O9gOEEPtOlbjACuapLVu2MGTIkBZdr9mh8uKLL+biiy/m8ccfj9uxjIsWLQJAlTlQAfnJWrRcep9UCne07+4FoomUosFVORowVPRAGWpgA1rHDJQhtktR2siiHG0obJeOOhwerDcYLCsGBOe+1QuUke1cGsvZ0DFAikCCQekQN2nZMaZmhIJlz3SM7XnEmtwZCpZ2eROmeMjinQ6ncGcJQw7oH+8yRBehbIVREtwI/YcffmhxqGyVs7/jZdmyZQAYRa641SC6lvQ+qRTJxsIdTygk6tg9Z0oplGmi/Q0sYHCYkJaC8sVuY7kNikckYhsK0xc7UNkJNpUTqjCTYh936HH7mTQuJ3Y9gFIao4ePygmxF+QEh7whkGhSPKKBY2i1xghoyEhr8FoEAihnQ30KuiZMyjngHUrRrhLS+6TGuwzRhajCYIYKddS1RLN7Kq+88kqeeuqp8JZCWuta/23NfY9iCW2ybhRLqBStI71vGkW7JFR2KPWGsW1QdU7LUQpCIcnWaJ8f5arThehwBMOWYaAsGyp96ITa7x3hQNlADyVUB8pxXrRLB3ftSfJjlde+n8flZ//h23CZwRXhY4dtY8Wm2j1MSmmMZH+wtzLFpnJ8FQkrYmyNVj0tNJAUDJZpG+r0NNoao9IXDINOJ2SmQ0FR/Wv4gm1CX7P6IVzX752UHssOo2hnCel9JVSK1mMUu7CAVatWYds2RgvmVDc7VD711FNA/LYUysvLY8eOHcGzeUtjjT8JsW/S+0pPZYfShF6yUDiKPCsHm9rBMiJQhprUDZZRA6UNpk/XmusYGSjDNZi6VrAMB0pHgNCROSmJVew/bBurNg2orjsYKMMvMVaw1NTqMY0aLEOBMvKEoLrBMiJQ1v3aNdi7W9NYgmUHULy7hKSMRBwuU46SFa1ClTvAgrKyMrZs2cLQoUObfa0WD3/ff//9TXqsta1duxYIfjHkFB3RGhJSPZgOg7KC8niXIqDhQFk9DF4/UIYbhHss6wXKiCbKslGVvoZ7KO2aUBctUIbLrQ6WtQJl5OfRpCQFg2W9QFnTKBwsQzWavvor1yODZdRAGRIKllECZfiWSkUMhUfppazdOPbnRLsI+CzKCytI650S71JEF6FQGNWdcytXrmzRtVqcxjZu3FjvsXXr1rX0so1av349EFykI0RrSO2ZTOnecumM6TR0jEAZ8XmlwOWKvUWOBm0qqrKir/KudSkzdqAMyUgs54KJ39ULlCEKTa+UEn5xwHex81koWI6rihooI0rC8ph4e3qiB8oQ0wx+DRr4gx0OlvKHv1MozisjtZeEStF6VGlwxGbNmpadJtfsRPbmm2/yxhtvsGfPHn7xi1+EH6+oqGiVXdkbEwqVRpkMfYvWkZSRSFmBbHreYWjdQM+YQikDLCsYmqIxTVRSEsq20eWVkFR/82/bbVI5MAUFuIttvGnRw6ft0RSPsdDawCT6kGO6u4LzRy4kyenlAGeApaUD67VJMP1MStmKQ1mcN3Ihr2ZPjnotDficBiVjA6Suiv42bdjBmi23SeWgVBK2Rpm2oTWqvDK40j05GV1WFvVaAFgWyjDQDW0jJKGzQygvrCApPcZm9kI0gyoPvs9s2rSpRddpdqg84YQTmDp1Ko8//jjXX399+PHExERSU9t+EnF2dvDg3NAXQoiWSspIoLxQQmWHEjVYKpRhBLfQ0RptWai6wTIUKENnfjcQhrQjGCRNv44aLO0ETfFYC9ulwVJYXhPTXTtYhgJlstMLgMuI3VMZ+lz/pCJ+PmIR/9twcL2XbFUF39f8KZqS/esHS8MGd5GNsnXwHHBHrEEnHd5rUjnMmMFSB6pfj1Kxg6UEyg4jGCob2AVAiH0UylI5OTktWqzT7OHv5ORk+vbty5/+9Cf69OkT/tUegbK8vJz8/OCpJ6pCQqVoHUkZiZQXSajscGqFmYhAGfF5bUWEvLqBElCWBRWVtS5ru00qB9QeQgwFy3CbyEAZul11sAypGygBEkwfE1Nya13bY/prPWYozYDkQn4+omYbj3CgjDg1MRQsw8+LDJShOp0GlYPqvPdqjSqr/ZqVw0QlJ9duFrCoNcZeHSzrXkt0HOVFlSRlSE+laD2q0gQbKisr2blzZ7Ov0+I5ldnZ2Vx99dXMnDmTY445JvyrLW3bti34gc+QRTqi1SRlJFJeWNl4Q9H+tCZqoIz4vK4eCq8bKEOUPxAOlqFAqZ313z9CwTJaoAzfrjpYprsrOG9E7UAJwRLTnRW1QuQBKbm46/RgRgbLeoEy4mKhYBktUIbaWAmOmmCpNaqsIuqJOJHBsl6gDDeKCJYSKDuc8sIKkjKkp1K0HoVCVQY76cIZqxlanMgeeeQRbrrpJvr3788HH3zAFVdcwaWXXtrSyzYo9IJVZYy5VEI0Q1K6DH93eA0uPg5ufh4tUIZb+APogC9moAwzoLKnihooQ1KcXmYOXU2Kyxv186FgOSU9uPl5rCFxQ2n6JhVzwpA1MRfloCCQCJVZ1A+UEW2sBAeVA5JjBsow06iei9pQYJSV3h2VhErRFlRVMFPFtafS7/czatQoAoEAiYmJnH/++cyfP7+ll23Qjh07gJovgBCtISHVQ1Vp9IAg4qyxrWyUQrldaK3RVbG/h9pholOTcZXEPgXHciuKRhigFa490afXpHqqOGnMCtyOAEWB2P+4pxkBLkrb0WDptlYUWwn0Ti7hxDHRt/NQlsKV5yCQoCgaEft9T9kaV6mF1SP2NCStNVRWBTeBd7sbrC14UQmXHU1liZeElCZ874TYBx0iVDqdwdXXffr0Ye7cuaxYsYKyhlYYtoLwfEqfhErRelweJ75KX7zLEHWFQ42OvoBEqWA4qm6nLStqsNQOE7tnOpgGptfCnV+/TShQ2k5VvY9l/UCV6qnixDErSKruofRpR9RgmWoEOCUpn5TqHsqTkvLrtbG1oiCQhI2BoTR9UoqjB8tQLQr8SdGDpbI0nj1VwZ5MlxOrZ3r9y1QHSh0a0o4VLDVoO2KeqgTLDsVf5ceZIDufiFbmDUbCXbt2NfsSLQ6Vs2bNoqysjGuuuYZ3332Xxx57jF//+tctvWyDCgoKAFA+mU8pWo8rwYmvMnYPloiDekc01gmWdQJluFmdYBkZKIMPUC9Y1gqUocsHavdWhgJlcp0h77rBMhQok42aYNbH9HNyRLCMDJQh0YKlsur0mEYJluFAaelwm7rBsl6gDN+0TrCsGyjDN5Fg2VH4Kn24JFSKVhbqqCssLGz2NVqcyqZMmUJycjKDBw/m0Ucf5emnn25RQU0RCpVIqBStyJUoobJDiRViQsEyRqAMN6sOlvUCZbhBTbC03Iqi4bUDZaiN4TXCoc5Qdr1AGRIKltECZfC5mr6mj5OS8qMGysh2oXuEhr1VoE5dEcGyXqCMaIPLid0zPXagDN+0OljGCpTha0qw7Ah8lX5cdc6tF6KllD/497u4uLjZ12iTVPbMM8+0xWXDQi9YBSRUitbj9Eio7DQ0gGpCyNHgMOsHysjr2JqAR2G7YoXYYLDMKg1wwqhVDd4t0bA5PjGvXqAMCQZLLzMS86IGypBkdxUnjVgVPVCGKLDcYLlU/UAZ0UY7TJRpxg6U4bYSGDuLYKiUnkrRyqozVYcLlY2+ebVQZWX1ti9R5jsJ0Vwy/N3BxHwfqd7uRttob+w5sMowUImJKMvGKIw+z9t2GlT082D4IXl77NXSymVhD6piWVH/mG3SDR/npuSQZPjx6+ihUmsIEKCfo5KfpebEvFaV5WRZeV/cw0pjtjECmpRcje00KO8fY89Cy8YoKAVDoZIaWC2sNdrrDeb0hjY9lu2FOgQJlaItKH/w735paez3nca0SahUET/xPvnkk1x33XX88Y9/JBAI8Pzzz3P99de36Hzwqqqq4AcSKkUrMp0mVqCBoT/R/mKFmNBffduKGiyVYQRDlGFUH5JdPzAGw5gH7TBQGhzl0YOlclu4R5WgnZo9Vcks2D2sXpt0w8e5qTmkmcFabOx6wVJr8BEANKbSDHSURw2WFQEXX+0aToXlxEwO4BpV//hFI6BJ2aox/MGvheUxYwZLZdmACu5PGS1YhgJl+Gsde9qB6Bgsv4VhGhim/BsoWpEd/PPk9/uxG9qSrAHNPo7m5ptvjvm5UNfphg0b2Lt3L48//jgvvPAC8+bNY8+ePTz00EM899xzjB49uln3DoVKZctfKNF6lFLoWMOIIn5qHdUY5bSX6mCp3ME5ZrUCZehZloVRWIadEdz0OzJQhttEBMuy/sHHQ4FSuYJvsLZW4WB5eO/gGbl1A2W4LGz8GkyCk9/9BFAR+0JGBsvXS4YCEYEy4AoXFQqWvvXBbYJqBcpw8TXBMml7aCSnupcyopFymJCUiC6vCH9tawdKwr2VtRZESaDsUGq+HYqG9xoVYh9E/FHy+/24m7LlWB3NDpUXXXRRo21WrlzJ5MmTgeCCno8++ojMzExuvfVWrr322ubemkCgehPh5gVpIaJShmrzqRuimbQGZcQ+Uce20D4fhsdTL1AGnw/K58coLCPQK7VeoAyJDJblwzTuUaXhQBm+VXWw/Hb3ME7suzZqoAy3xcbWoU3P6//ZCgXLc1JyeKFwdO1AGVFUKFgGVqeQXDdQhttFBMut5RgFpdW9lLUbhYNlWXn9QBluFnEGuPyd6HB09Qb4ylAggyuitUR01BUVFdG7d+99vkSzQ+UBBxzQaJvS0lJ69OgBQFJSEqWlpdx0000tPnEnNLxumAbKbr/FOoedNpmRBw5hzffZLPxkabvd99BTD2LUQcNY+8MGfvz4J7lvG8nqmcX5vzuLFfPXdIvX2+nuqwxUrAU3AEphOBTKGX3/2ikzxjHigEGs3rqXudt3NnxeTCB44IzpCg4d16MVlQE3JopUw0LrWHvmJuHu+RaT0vuhC1OA+nOVDCDVsNG2SVXAHX1OkgLl0mgUTouGJy65DAxDcdgx+zHqgMFkL8/lhy8i974M7ndpmwptqOivD4IrwRX7HCqnnHwgoycPZ/3iTXz//uJ9em5LHHLiJMZMGdEt7qsMRUZGBhffcy5rF27o8q+3O983e8lmvntvYbvcU0f84Bteu7KPlG7Drpm3336bhIQEZs6cybp16/joo4+46aabWnzdY445hkAgwG9/+1vS0tJaodKmGTJkCBkZGeTn57N169Z2v29BQQFbtmyR+8p9u8R9CwsL2bx5c5e+r2EYTJw4EYBly5Y1e55Sc3Snr3M87zt48GAyMzPlvnLfTn9fy7K44447AHj99dfbt6eyKcaNG8drr73GzJkz+fHHHxk/fnyrXNeoHtr628+ew2jHU3Wu+fssDjhmPN+89QMv3PN6u993wds/8vzd/2u3+179yCwmzRjPt+8sZPZdr7b7fb97byH/uaP97vvsxr+Sn1vIgnfa975X/eUiDjp+Yru/3tB9v39/Ec/9/pV2u++VD/2Sg2cewA8fLObZ/3u58SfU3epG1ZlXWX1EY2Q75XSgEmsWpWiHwWX3nM3kqS5+WLCZZ56YQyDRQWVfT61LW04oH6Bq9qtUGjPVj3N4TQ9jktPH4b02keQIDnkbaAY7yzgrtW4wVzhJxXS+TpW/L5MGXY+tau/hW2y5eL1kCMV2cMg7PLSeN7Smdp+BLzsV7a1+r9PgqNQkb6vdH6ACmqTtlRj+YHC97LpjmTLVyaI563n2/veCjWwbXV5Re76kXWcVfay9KpvY/3D5ny/gkJMOZNEnS3nqtheb9JzWcNn9v2DKKQe1+30v/dP5HHrqwe1+32dz/kr+1kIWfrqUf//mhXa77yV/PI/DTpvMks+X869bnm/3+/70xQqevHl2u9131h/OY+oZ7X/fi+/9OYefeQhL567gn79un/tqQ8OU4McpKSnNukabhsqRI0eSkZHBddddR69evTjvvPNa5bputxufz4eN1a4rwENh1vLb2FFWk7aV0HC/FbDa9b6hlYXtfd8QK9C+X+dgp73Cttr3viHtfd/QvKy4vV5bN35fFW0hgkKZNZ9XbhfapnY7y4+yysPBUivQ1ctkbFujLY1R5se9XYeDpeWCsv4K20FNgNJgFTuwNiTjGlFKktPH1N4bSXT4wnezgM2BRN4qHcjZqZvDNbpwoJQdHlx2GMGhdD/BOZbFlovXSgdRrB2g7PDLzUoo4bDeG1mwexjaZ+Bdn4L2GrVen+UBqz+k5FbPrQtoErdXgt8OTzXXuvo1a41t6eiBsrpWHM7g/Mrq1xz1OMzQRRsR+p4G79t+f65su6a2dr1vxL3a676GGfy+htawxeP1KqXa9b4BX/UPOkY739cf/PtqmO1739BOJIZhtNt9dcT+uh6Pp4GWsbU4VN57773cfPPN4VRbUlLCo48+yp133gnANddc09Jb1BOan4nZvhPIt6zeRkJKArnrtrf7fRNTE8ldt6Pd75uUFo/75pKckcS2dv46a60xlAr+A9yOtqzeRmqPFHLX7WzX+25du520nqlsXdvO398120jvlUru2ka+vzE34w6eqKNMs+ETdfwBqKiA1GTsjGS25uSRnpHIti3BoxKVBkdFgISdVZQN9lAW2UNZ60IKq8SJc4ubIw5fE+6hjGSj2OJP5s2SIZyduqU6UNa/lKEUTu1gr2XwWsnQcA9l7Taanp4ypmZsZu7XB9T0UNb62kAgQVE6EFJz7Fo9lCG5m/eS2SOZLTuKGwiUoZsaKJcL7fU1fqJOI8Eyd90OsvpvYmtj399Wlrt2O1n9M9v9vlvX7qDn4vZ9vQ6XA20H59gq1b6HgOSu3U724k1sWZ3bvvddt4MNSzaRu2Zbu983+Hq7wX2rM1VCQkK4E21ftXhO5WWXXcazzz7b6GOt6dJLL2XDhg04V6ZjFO37knchonkm+y+YtosvX/mGF+55Ld7liAZPeFEohwPlafjvvzIMSEvG7pURs43tNCgbnEDh6NhTabRDY/X20TezkONHrY7ZzqUsxnvyOTGp+ihZklA93qTS3xdX8REYqpRS2+Tdsp5s9qXHvE6Z183Ha8dTVpxY+9zvOkyfpseKAAm7GphUH7Axdu5FVzQy8V5rdGVVw6Gyup2Ir8T0BB5d9AeU18GyL1fyj+va7t9b0X3YSX78kwro0aMHb7/9drOu0eIfcSzLqrVKqKKiombLnzaSlJQEBN/ohWgtWmuU0b5DSaIBTTlRx9fQiToKPG7wWxj59TcQB7AdBt5MN2aVJi0nxik4Do2vZ4CAoSj1xh4SMpVNilnJjoCbT8ozo7YptU0+Ku9BhTZINytiXsvWBiVeD7bHxtcz+vup4dekbbDRhsLbI0a4tmyMvUUopRoO4BEn6tTbjqlOOxF/TpcjPDyq5HhN0VocwX/7mjufElohVJ5yyinccMMNvPXWW7z11lvceOONnHbaaS29bINC2xRpl2zQJVpPRVklBbuKKNhVFO9SREi9EKNq71VpWVGDZTBQeoJhSmuo8tULlrbDwNvDjXYolAZnSf1gGQqUoR9gS70JfL5+bL37mcom3azAVDYWiu3hYFmOtfdkfvrpJ8psLx+V96DYDvY8uoxA1GBZ5nXz6fr9a+qMEiwNvyY928b06eozwM36wdKyMfYUoULhwzSjB8s6G6ArpaIHSwmUHYbDbVJRUUXe1r3yfiVaja7ekzcrK6vZ12jxnMpzzjmHwYMHs3DhQrTWXHXVVRx88MEtvWyDwi/YJT1KovWsWLiaOU8tIGdx+84VEo0In6ijom9+Xh0slSt0ok5NoAxRWqOrg6XdI7VWoKxpEwyWqTkWJUOrh8JV7RERy1ZsL8ng8+yxHDcyOAweGSjD7aqD5aflmRyXGDxh7OPyTIp17bDmMgKkU0GRFVxQVOZz8/G68ZRU1e4RjazB8GvSN1QHynDxNcHSne+tFyjDzUwTPG50VWhRTpQTdag+XcowIDQHUwJlh+JwOdi8fjOPnTc73qWILiQUKkMdd83RKqu/J0+eHD45pz307NkTAO2WnkrRerzlXjxJ9RdOiA4gFCxjjfRZoRN13PUCZUgoWFJcindUr1qBsqYNuKqDZfFIA19W/aFny1ZsLw4Gy5mjVtYLlOF2KLYF3LxVmkV/CPZQRmkXCpbbKjP4eG39QAk1PaaeHWYwUHqjnYJTHSzTnSSs3V0vUIabhYJlZVXsE3UAFTpUUgJlh+NJduMtjz31Q4hmqc5UcQmVjzzyCDfffHPMM8AfeeSRZhfVmNCGnNotPZWi9VSWVJGQlhDvMkRz2TbasjEamGOmlMIwHLh3l1PVPzl6Gw3OcvAUaLx9oweqYI9lOnO3jOJnw5fEvF+57eKHkgFc0kjpVQEHn+XsFzVQRhaWsIfogTLUJGDj3l0ObjcEYs/ZRCkIWBIYO6mEVA8Vxc078USIWLQnGCr79u3b7Gs0O1SefPLJQNPOAG9tAwcOBEAnBqjeVKHdaxBdT0VxFQkpzdubS7Sx6v0qtW3X3vi8pgEYJlgWdnkFRlJi/SaGgU5KABSOcj+e7WVRg6U2Fb4UA0cZpKxzUDq6fm+lMgCXTW5ZJm9vOoAzhy2t16bKdrK8dABVVnAe48qy/oxLqT+1osTn4bWNB1Hq92C6LawoWwgZPkXaGhNlgzfVwF1S/wdq5bdJyC3F8NngMNFJiajy+sFS2xpdXgHo4FmUVrSNziM2QG/CNkKifSWkeqgsqYp3GaKL0QnBv/ODBg1q9jWavVBn9OjRAGzcuJEDDjig1q+NGzc2u6CmGDBgQHB4y6HBKb2VonVUllSRmCahssOJ7HnUOvrm3aZZnTs1BALYdcNUKFCGAqmtw8EykjYV3lQD2wRscBUpUtbV/tlbGWC4AygFlm2QU5rF25sOqNUmFCgrrJrpFEX+RFaU9a/VLhQoC6uCO1ooU2PWmdZj+BRpq02MyurN213BGmvVFA6UEc+tDpa1Xp+t0eXl4SCpVPBrV7tRlBN1ZIVxh5KYJqFStC6tdLinMtRx1xwtXv390UcfNemx1uR2u8PdszpR5lWK1lFZUkVCqoTKDiVamKkVLCMCZcTn6wZLHW1Fs61rhTBtRATKcJvawTIyUIZEC5a2VrUCZeixyojHSnweXo8IlOGXHBEsDZ8itTpQhuukfrBUmtqBMsSMeF6dQBl+bmSwbOg0HQmWHUZCagIVxRIqRevRCRYoSExMjM+cygULFrBgwQLy8vJ4+OGHw4+Xl5fjcLTp6Y8ADB06lB07dmAn+TGKZXGFaLmKkkoSZU5lx9FQiNE6uK+oI/rJNZHB0khJhsToPywYfhvP9jIqB6bgTasTKEOqg2Vqtkn5BG/U+0UGyxOHrGJlnR7JkCrbycqy/gxy5fP6xoMoqBMoQ5SpcSqLpNVuzMr6N4wMlp78AJ7tpfUvAqCqe2hLK6IGynAzpdCmifb5qX8sZq2GMhTeASSmecjblB/vMkQXopP9AIwYMaJFe582O/317t2b8ePHs3DhQsaNGxd+PDExkQMPPLDZBTXVmDFjWLBgATq5bTdaF12PYRjcOvtasvpnsmtzHn+78t8cceYh/OKOs0jukcQXTyxg7/YCDjnpQH7xuzP5+Nk5fDp7XrzLFnVpgiHJEeMkHK2Dq8L9fjCihzdsjVkZwFXopTKzgR8oNBjlBgnrXFSNib7q1rINcoqzeH3FZG4/fDqjUoazx5vPUxueZ0D/AdyZfgsvbHmN9UXb+W7dCIqM2JuRK58iYY0bZcV+c9cACjz5XgxvAyM2hgE+X8xAGb5WIBBcXS+ZMe5GTx7BNX+/hIA/QP72Av521b+5773fAuBOdNNzcCb3XfBXMnqnc/vz1+FJcvP+vz5jzn+/Jjk9id++eAPlxRU8NOvx8CbpQjQkFCpDUxubq9nD3yNGjODEE0/k+eef58QTTwz/mj59eot2Y2+q/fbbDwCd4m/ze4mu5fAzD2HX5jxuPfZectdu54izpnD2Tady11kPkZOzmQvuPAeAKScfyE1H3sXoQ0bGueJuqqEeseqfpLVto2P9o6kMlNMRDEvF0U/UwVBotxNHuUXq5hiraRXYLkArHIUmnrXRR0a0Bl+ZmzRzFKa/L/esepjtlbs4pMdBuN1uHlrzD6ZkHMqqnAHsLUvBqoj+M73yKRJWujEqDbShiHI8OACmX5O6sQJlaeyEGI1sGwqLAQ0uZ/S6AfyB6i+3arSHWLS9Pbl7ufXYe7nlqLvZtWUPB59wAL855h5+c8w9vP/kp+zemUdJXik/v/10/vfwu9x81N2cds1MnG4nk44dz5t/e5+f5q5g+MTB8X4popOwqzvo4hYqQ26//XZKS2uGXkpKSrjxxhtbetlGjRkzBgjOA9AOWawjmq7f8N5sXLoZgOwlOZxy5XFsXbuNwu1FBLSP4ROCb8SLPlnK376+j+zFbbvwTDSggaMaw02iBUtloFyOmuFar69+sDRUMIwZwVN3nCVRgmV1oNShoGVHD5Zag13uRNuKSb0GMHfzNtZt6cuyopWMThmOz+fj1v1u5KVlW6n0Bp+rA0a9YBkZKMPXjhIsQ4HS9Fa/9zmM+sEyFCirj81VhlEvWNYEyiaERQmU7aZgVxG+qmCPeMAXqDXP9chzDqOotJDivFLGTB7B0rkrsS2b9Ys3MnTcQJZ+uZJzbj6VA2dMYNPyrfF6CaIT0Uqjk4IddKFs1VwtDpXl5eW1eiZTU1Nrhcy2kpqayuDBwX/87TTZBFY03ZbV25h0THDKxoEzJqAMRUVJJX5vgMrSKpzu4D/0372/iF8fcQcfPzs3nuWKumEmSk9arWAZGSgjrxEZLCMCZfiy1cEyJTJYqohAGVInWEYGSoA0t5sSr4+i0iRWbU0hyZFEbm4uP3vnNRbuqD0PLjJYKp8iYVXtQBluF1GD6dekbooIlCGRwbJOoAy/nIhgGTtQRumtlEAZF70GZXHQcRP57v3FACSlJdKjXwaWDlCWX47pdIS/f+XFFaRkJlNaUMbvT3mA+3/xdwJ+mR4mGqdT/GBCZmZmi1Z+QyuESqUUhYWF4d/n57ff5OHQ3E0JlWJffP/BYnxVfh764m48SW7KiipITA3OpyvJKwse8yc6llCoqT6uMWqT6s3P6wXKyGt4fVBSWi9QhiitcYWCpQI7+ohxTbBc7a4VKAFKfF6SXW5srdD+dLbmB99mQz2U9coKGOhCZzBQVsR4S67uMQ0HyqoYozMOA9vtiBoow5cyDHA6G+mhjAiWEijjIjElgdtfuJ6HL3kiPC9y6umT+enL5ZTll2NbGssfCC+qSEpLpLSgrKFLChGVnR7MUJMmTWrRIh1ohVB5wQUX8Ktf/Yp//vOf/POf/+Taa6/ll7/8ZUsv2yShUKnTJVSKffPv37zAbTPupSS/lLcf/ZBBYwbgcDpwO9zkbdsb7/JENFoT+5zGUBsb29vI+4GtMQpjzLGkOliWWiRv99XvpYxkKcwSo1agBFi8ewdH9A+OohzZdyhLVuY1XA+AX+Eobvi1qYAmeWtV7EAJwTO/84sbXznv9TZeU3Vb0f4M0+D3r/yal/7wOtvW7wg/fuQ5h7Hyh7UU5wXD47pFG5l41P4YpsHIA4exedW2eJUsOrFQx9ykSZNafK0Wh8pjjjmGBx98kD59+tC7d28efPBBjj766BYX1hShVK0TLbRLVriJpsnonc7Dc+7moc/vIuALsPyr1bz16If85ct7mHDIOBZ++VO8SxSx6NiBKvwTdiCAXRUlNCkV7KEDqPQFw1f0C6FNA2epRWpOjPClg72GZhWkbKz9Nro6P4+9leW8ccr5jEnoyRfLNgDgyYu+St3wQspGM7jXpD96iDP8NukbvZg+jXbEeNu2bIw9RcHjF0O9kfXq1tiVVcHhcUUDvRI62EbExTHnH8GYKSO54I5z+Mvce5h+7lQSUxPJ7JNOwPJTsC04Ovi/B9/hvN+eySPz/8AH//4sPA9TiKbSph1e8NwaO/co3aQZ2h3XNddcw8qVK3FsTMHcGeVoNiH2wUGnjWfIpAG8ee/H8S5FRHB5XFx6//lMPW0yFaWVoGHRF8t57v9ewbZ1MBzVzUcOBxfd/TOsgMUrf/0wuHN55EIVpSDBhd0jrdZjtsMABcNH9KZn3zTmr9hEyVA3Ywf25qyp4/jjq3Mw/BpV/c6pDfCnaUqH14Qwww/TEgZz9ZGHcuVzb/Gvkyfzq48W4vPYVPWu+QHY8EFqtokZmsapQCuwnSriWjbpG7y1eiiVrVGB4O8ff/4Krrvw3xh7ivjFdcfx8t+q/+xqHdxKKCQyUEbScOGdZ2MFLF6+/20kUHZsJ/76KMryy/n6xYXxLkV0AVZWFYExxQwePJgXX3yxxddr8S7l2dnZPPLII+Tk5OCLeAObO7d9FjdMmzaNlStXYmV6JVSKFsvfWsjBp4+Pdxmijl//60qUobhi/M14K304PS7OvfV0nG4nvip/9FHxQAAdCBCeH+is83andbjH0u6RVitQAgwf2ZtxEwby3YJsUnO8rGY3q1/dXStQAigbnMWKlI0GpcNtDD+4d5uoAXUXu4BZqfDsNqnqbdUPlNVtFMEeS9upogZKCK4Ix2GgAnY4UOIPcMHNJ9aEylDPrN8fO1BS/eWJLEACZYeWNSiDLUtlmFu0DrtHcDTm8MMPb5XrtThUPvLII9x00008+OCD/OMf/+Ddd9/FamCT3dZ2xBFH8OSTT6LTfGjTRlktHtEX3dje3AJ6DMyQg0M6kD5DenH4mYdw/oCr8FYGf3D1V/n47x/fCK70NhTX/G0W+00ZgcvjZNPyrTxy5b/x+wLBb2L1UPDBx+7PBTefhNPlIOC3ePy3r7JhRS5U+pg+ZSg/v+F4lFJUlHv5v9+8yqzLp+PxOBk1pi+ffLSM9TvzueDiw7n6b28CcN4xkzhz2ni0rdm8q4Dbn/2QlI0G5QNtDH+MYWUNfROSufeE4+jrTMbvs3jolS9ZkbOTg0YN4NozDmdnfimjB/ZkZ34J9972GnaVTa/eafzf3WeQlOxmzcrtHHTIMG68ejb5O4r45Ie7OHngDVx579mYDpMnPv8dJQVl/O7n/+DD7Y9zcv/rwOtj/0NHMuvec7n1uPsAuOqhC5ly8oEU7i5mT+5etqzZDrZNSkYy1z9xOX2H9cbpcvDfP73J129+3y7fa9G4rEEZ7N1S2HhDIRqhlcbO6GCh0u/3M2rUKAKBAImJiZx//vlcccUVXHjhha1RX6MGDhzI0KFDycnJwe7hxcyTY/ZE85XlV6Btm5SeyZTkyUrKjmDIuIHs2LArOOwdSevgodcoXrzvjfDK12seuZjjL5rOh8/MCZ5lHbBAKdYuzuHmU/+K1poR4wdy7f3nctOpf2XQiF5cduvJ3HT+E+xRBqmpCVRW+pj9zHzGTRjIIw9+CMDEAwaHewyn7DeIU6eO5dIHX6W8ykdakgdlg7tA4clXVPSM/XrunHkMC7/ZxMvzlzF2cG8euuoUzrjzPwCMHtiLO5/7hJ07i/jHladx9JRRzPliFdf9+ng++3g5H73/E1OmjuCk0yahAjZmXlH4uk/d/SanXzqda497oN49ta/2XLvDTz+YkQcO44qJt+JJcvPPH+5ny+pg79fVf5vFp/+Zy+LPl5OUlsgTP/6ZpXNXUloofx/izelxkNIjmYLtRfEuRXQBdoYXHJoePXowduzYVrlmi0Ols3oyeJ8+fZg7dy49e/akrKx933xmzJjB008/jdWrSkKlaLG9WwrpOThTQmUHNf3cqZz/2zNJyUzmD+f+lXWLNjH11IM55aoZuDxOklITa7aFUgosG11eQcbI3tz2+Cx6DcjECtj0G9oTBRwwbT8WfLyMwq17MRPcRFsXrmwNWmMENClbvRx2zhDeW7CK8uqFEcXlVcFQWWyjbDB8Ngytfx3Dr5k8pD8P3P8hbttm9ZbdlFZ6GdgrHYC1W3ezc2cRqZurWL9qB336paNszfgDBvGne94G4IdvN1BSXIm5txjlq9nYXMcYttZlFWhb19pCafwR+zH/9e+wAhblRRV8+96i8Ndr8omTGDZhMFc8GHzI4XLQd1gvShfL34d4yxqUQXFeKQGfLEwVLWf3qgLg2GOPxTRjHHe7j1ocKmfNmkVZWRnXXHMNjzzyCBUVFe1yok6kUKjUaT60y0L5WueLI7qnXRv30HtETzYulNMoOoLNq3LpN6IPCckeKsuqmP/at8x//Tv+MuduHC4HvQdl8cs7z+baQ/+P4r2lnH7NCQybMAiM0PuARvsDXPfHn/HxK98x753FJCS5eWPtw2AY4d13lK2h0ou5pxirZ8TinTrTIJylAdyltf9RDwVKwwo2dpZDwt7aIU/5Ncnb7OD1tMbwgavErjXNwuezSNlchem1sW0b06w/nUcFbJS2Uf46NRh12to2tq3RtgUquNip3txTTb0wahiKW46+m/Liinr3FvHVZ0RPdmXviXcZogvQpo2dGRz6Pu6441rtui2egDhlyhSSk5MZPHgwjz76KE8//TSHHnpoa9TWZH379mXixImgwKpO3kI01871e+g7qle8yxDVduXk8e27C7nuH5dVByOFUgqXJzhKkpiagLfSR0l+Ke4EF8decERwpXetAKVJTElgz6ZdAJz8yyPCn/np63UcfuJEMnqlomxNqsvE3FNMZYWPpCQ3qs7kWqVh8dfZnDl5LEkeF8qGnpYrHCiDbTSOKjC9NY+lbLcxfZqfVuVy0jHjUGjGDuhNqsdNbl4RRkDjqLJx1D0pB1ixdCtHzxiHCtgcul8fUtKTon6tvJU+3AkusG10WQV5W/eGz3+eduYhgALDYPnXazjynEMxDEViqofDTj0ofI0fP1nK2TedEv798AOGNPj9Ee2n76he7Mxuwr6nQjTCzqoCAwYNGsSoUaNa7brN7qlsbOl5e22AHjJz5kyWLVuG1acSc1siqrFNkoWIYdf6PA4954B4lyEiPPqrp7j0/l/wzKq/UVFcQVWFl6VfrmLTsi1UllWxbP4qnlv1N4r3lrBu0aZg+Kxj9r2vc/M/L6OitIpvP1kWfjx3w27+88B7/PG/1wDB4+5u/cU/+WnJZn5+wWH8a/YVfPLhUjZtqPnH/Kcfc/j8g2W8cPPPCaDZvHUv9/79w1r3U1ozcWR/5vzmMtKSXLz9jwk8/fLX/P3ZOfz2mpmcdtxE/IEA9zzyAc48PwkeX7C3NIon//4Zv737DM4+9xDWfpdNQV4J5SWV9dq9N/trHv/0dvZuy+f2kx7gmd+/yp0v30BJQRnLv1oTqoxv31/CuMNH88yKv1C4u5g1P2SHr/HPG5/jmkcv5allf0UZij25+fz+5Pubdj64aFN9RvXi6xd/jHcZoguw+gbfP0455ZQWn6ITqdn7VP7nP/9p8POXXHJJswpqrqqqKs466yzKyspwrErHLHS36/1F1+F0O/jtJ1fz4En/wlfpj3c5oq7G3gANA+Vo6OdlhXK7MJJib0GmlUInuLAjh8HrsjWGN4CVYFLVJ/q1VECTUOTj7geO5nd/+w47SmhUfo1nZzmGpbETop8L6XY78FX4MHYXMe6AQdzw0HlcdfT99evWGl1aVr2VUqwXp4Ofb+ytX0Jkh6IMxe8+vpp//OJ5SvPL412O6MTsZD/+AwpwuVy88cYbpKent9q1m91T2d6hsTEej4cTTzyR119/HbtvhYRK0Wx+b4D83CL6jOjJ1hU7Gn+CaF9aNxwsbRsdCMQMlkoBfj92eUXMYKlsGyq8GHuKowdLW2NU+lG2xiyz8eyqqBcsVUDjzveGh8Vd+T6qMmqHxlCgNL3BeY9GpT9qsBw6pCe/vvVEDMDvt3jk5v/WaxMKlFhW8KSxaKFQAmWn1WNAOr4qvwRK0WJ23+B86aOOOqpVAyW0wkKdQCDAxx9/zKZNm2ptfn7rrbe29NL77PTTTw+Gygwf2hNAVbX45Yluasfa3fQf21tCZUfVzGAZHubROnawrA5USuvowTIiUAbbgeGts2gmFCj9dnjVtVkVwJWv8fWIGJrXOhgoIbjxuWXXD5YBm+wvV3Ldp0sj71BrzmhkoIx8rbWCpQTKTq3/fn3YsXZ3vMsQnZx2Wlg9g2tPTj/99Fa/fosX6jz44INs2rSJBQsWMGzYMDZs2IDLVX8+U3sYNGhQcJGQgsAAWbkomm/rih0MHNcv3mWIhjQWfqqDZUi9eUMRwTLWNZXWqOpgGbxm7UAZbhewce+qqP44IlDWulYoWAZ/+FZ+jWdXnfepiGAJQMDGzCsMbx1Uq2HomMgogbLea5ZA2ekNmtCPrSt2xrsM0clZ/SvAgHHjxjFu3LhWv36LQ+WGDRu48cYbSUxM5Oyzz+bRRx9l3bp1rVFbs4Q2Xbd7VaJdspeXaJ6ty7czaIKEyg6vCcGSQCD2RPTIYBnjWqFgae4uwqiqHyghuKWQo9wfDJaaeoGy5lrBz9Ua9q5XU3WwLPNi5hVFCZQ1DbVto0vLowbKWi0lUHZ6A8f3Y+vy7fEuQ3Ri2rSx+gQX6PziF79o1QU6IS0OlaFeSZfLRUlJCU6nk8LC+B0hNWHCBCZMmABGdSIXohnytxZimAaZ/RtYqCE6hkbCkK7TYxn1+X4/dkX91dQhSgf3sFT5xbHb2OAo9ZGwqaDBegxfgISN+dEDZYhlofYWoXyxF4ppW6PLysGK/dq0Bl199neDJFB2aAkpbjL7pcnwt2gRu28lODRDhgxh6tSpbXKPFofKsWPHUlpayumnn85ll13GxRdfzEEHHdT4E9tQqLfS6lOJdkTvMRCiIVpD7sqdDBwvvZWdQmPB0rJaFiy1hkAAvD4oinbmDmDbGGWVmGVVGEUxFlNYNkZhGWa5Fypi7KlrW1BQAn5/8IjJaOXYGl3ecA+lBMquY+D4fuzM3iMn6Yhm04Ym0C/Y0faLX/wCo+5hCa2kxStZQqfnnHzyyRx00EGUl5czfPjwFhfWElOmTGHkyJFkZ2djDSjHsTklrvWIzmnr8h0MntifZZ+sabyxiL9GFu/o6gAWc7uhcLAEIzGh1uPasmrCVyhYpqfWtLFtVEUVWMEfYpXXh1EEduQm5ZaNUVQWPglHBQLoiipI9ERcpzpQhgKwttEBUI6aU8L2LVA28kO1BMpOYdCE/mxdIUPfovns/hXgsunbty8zZsxos/s0O6pqrfF6veHfr127lj179lBRUUFlZexhpPaglOLyyy8HwOpXgXbLT3di321atJVhBw+KdxliX7R2j2XdQBlqE9ljWSdQBtuEgmVNj6VRXFb7aEUdDJbhHsu6gTLczg73WEqg7J6GTx7EpkW58S5DdFLaYRPoH3wvuuyyy3A0uI9vyzT7yv/+979JTEzkoosuAuDOO++kX79++Hw+DjzwQK644opWK7I5Dj30UCZNmsRPP/1EYFAZzmyZGyf2za7sPFweJz0GppOfWxTvckRTtVaPZblGuV3Rw1coWBYUg8tZO1CG2wSDpSosDd7Pb9U9RjwcLHVpBfi89QNluJ2N9tvoKq8Eym4mMT2BrMGZbF0mPZWieayB5eDQjBgxok17KaEFPZULFy7k/PPPD/8+NTWVRx99lCeeeIKlS5e2Rm0topTiqquuAsDuVYWdKCejiH2jNWxavJXhkwfHuxSxr1qhx1J7fegGFu8Ez9cuh5Ky2G0sO/YczIg2urgkOBQe814au7wC7W/KohwJlF3JsIMGkbtiB35vA39ehYhBuyys6s3Or7zyyjabSxnSoqs7nTUb9F5wwQXBCxoGVVUNvDm2o7Fjx3L00UcH960cWoau308gRIM2LpQh8E6rBcFS23Z4b0ddGeX9TOtgwLNttN+PLo+y04RtB58bGrqOdh3bxi4vD/ZQ2nb00Ghr7MrKYEDVGh1lSyMJlF3X8MmD2LhwS7zLEJ1UYGgpGDBx4kSmTJnS5vdrdqgsLy+vdYLOMcccA4DX66WsrIGf3NvZFVdcgdPpRGf4sHt4G3+CEBE2LdzK0AMHYJht+9OdiA9txwhhuua/OsbQNqHnhuZdRhP5eJQ2Gh0OnWhdc826N6s1XzNaMNSNB0rRKQ2fPIiNP26NdxmiE7LTfNg9vRiGwfXXX98m+1LW1ex/KQ8//HAefvjhWotyKisreeSRRzj88MNbpbjWMGDAgHAvamBYKdqUN17RdMV5pRTvLmXwAf3jXYpojiZsp1O3t7Je0NR27V7GKM/Btmv3Vtp2/Z5JrWs/Ztvo8vrD67V6K22NHaWHM7K3MthL2YShUeml7HT6jOiJMhS7N+6Jdymik9FKExgenHpzxhlnMGrUqHa5b7ND5ZVXXgnAWWedxeWXX87ll1/OWWedhW3b4bmMHcUFF1xAv379wG0HJ6wKsQ/Wfr2R/abFd5ss0QL7MAweHPau24CaYfCIYe+69wgPg4cCZd2eyeq9LnVlVfWwd0WUld66Zhg8ctg7ymvStpZh7y5uzJHDWfvNJvn2iX1m969AJ1qkp6dz2WWXtdt9m7362+128/vf/56dO3eSk5MDwJAhQ4LhrYNxu93ceOON3H777Vj9KzDyPBgVzsafKATBUHne/afy0d/nxbsU0VxNWBGutUYZZowGwd5AbdsoM1Ybjfb50D5fw238fnRD8861BsvC9nohyvzJmnY2OmBLoOzCxkwbzudPfhPvMkQno90WgeoOtKuvvpqUlPbbq7vFmxX17duXvn37tkYtbeqwww5j2rRpfP311wRGluBcnonSbT+/QHR+O9bloTX0G92LHevy4l2OaK5GgiW2HWwSNRDq6p5GG21rlDP6W6f2V5+xbdooV/0fXHV18MTWYBi1NjWv1c4X6n1UMWqOsn9m1AtJoOysMvqmkt4nlc1LZH9K0XQaTWBkCZiaCRMmcMIJJ7Tr/bvV6oObbrqJlJQUdEoAa4AMg4umW/vNRsbIEHjn12gIs6MsutG1n2dbUecwhgMl1T2fdc7trhUoIRhioxzDWBMoo9y7+jEJlF3f6GnDyf4uBysg6wBE09l9KrHTfXg8Hn7729+2+RZCdXWrUJmVlcWvf/1rAKxB5dhJsnelaJq1X21g7FEj412GaA1NCZZ2I6dw2bW3I4oMlOHH6gRL7fPXH86uEyxrB8rwo7U+lkDZPYydPoK1X2+MdxmiE9HuAIGhwd13rrrqKgYMGNDuNXSrUAkwY8YMpk+fHty7clQJWsmbr2jc5qXbcSe76TuqZ7xLEa2hsdBlh3oso/UUVrOsmjAZo422LGxvdbCMNT9SBxcHRQ+UkfVKoOwu0vuk0nt4Fuu/zYl3KaKT0Gj8o4LD3pMmTeLMM8+MSx3dLlQqpbjllltIT09HJwWwBnecPTVFx6Vtzco56xh/3Jh4lyJaS7OGwuuwreCQdoNtGl9Io33ehhfchLYxkkDZLYw/bjRrv94op+iIJrMHlqPT/CQkJHD77be3+7B3SLcLlQDp6encdtttAFgDKrAyZVN00bgVn61l/IzRKEMWeHUZDYWw0PY+sYKlDm5BFHMD9epG2mokGOjqofIGNmLXttVgj2i4XtEljD9uDMs/XxfvMkQnYaf6CAwKrhP59a9/HdddeLplqAQ44ogj+NnPfgZAYGQx2t1Ij4To9nasy8Nb4WPIpPafpyLaULQwFvlYtBNzNGhth4Ne9OBZe7g6Zhu75kSd+huvRwTKptYrOrXew7NITPOQs1hO0RGN0w4b/+hiUHDCCSdw4oknxrWebhsqAX71q18xZswYcGr8o4tlfqVo1IrP1zHheBkC73L2ZVg5MlCGH6u7uCfK/Md6w+nR2tQNlo30TjaldtGpTDhhDKvmrse25PsqGqbRBEYVg9tm4MCB3HTTTfEuqXuHSqfTyT333ENycjI61S/zK0Wjln2yhrHTR+BOdMW7FNHaQuGsgUU39dpGskPBsoEFNbpmAVDsNqE6aGBIvOFaRedkOgwOmDmWnz5cHe9SRCdgD6jAzvThcrm49957SUxMjHdJ3TtUAvTr14/f/e53QPX8yp71z+IVIqRoVwlbV+xk/HGj412KaAuNzFkMnrzTwBxK2258QY1uvI0OBVSZQ9mtjD5iOEU7S9i1Qc76Fg2zMr0EqjvCbrjhBkaMGBHnioK6fagEmDZtGr/85S8BCIwswU6W/StFbIvfW8FBp42PdxkiHqoX7zTaprEw2IQtjSQ0dj8HnTaOxe+viHcZooOzEwIEqudRnn766Zx22mnxLilMQmW1yy67jCOOOAIM8O9XhHbJwh0R3fpvc0jukUS/0b3iXYqIl1iBb1+CYGtcQ3QZGf3S6L9fH1bOWR/vUkQHpk2bwNgiMDUTJ07khhtuiHdJtUiorGYYBnfccQdDhw4Ftx0Mloa8uYv6bMvmpw9XcdDp0lvZrdUNf439vrnPEd3CgaeOY+UX6/BVykiZiE4rjX9MMTrBonfv3tx33304nc54l1WLhMoIiYmJPPDAA6SlpaFTAgRGFaORN3lR3+L3VjDumFEkpLjjXYqIp8YWzDS2FVBTriG6PIfL5MBT9mfRuzL0LaLTaAIjStAZwXO977//ftLT0+NdVj0SKuvo169fOP3bWV4Cw0olWIp6ineXsuHHLRx0+oR4lyLirTW2/JFA2a1NPGE/8jbmywIdEZM1qBy7dxWGYXDPPfcwcuTIeJcUlSPeBXREBxxwAHfccQf33HMPdr9K7ICJc3tKvMsSHcz3ry/l3D+cxA+v/4QVaGTxhui2DNOo9V8hIikFh557IF/8+xv5MyKiCvQqx6o+MeeWW25h6tSpca4oNqW1/Igcy5tvvsmjjz4KwNlnn83BBx8c54qEEEII0V2sXr2al156Ca01s2bN4tJLL413SQ2SUNmIf/3rX7z88sugwbU+A7PAE++SRAcy9uiRHH7+QTx95avxLkV0UIZpcMec6/jjsY9jW9KjLWq74C+ns+7rTTKfUtRjpXnxjSkAA0466SRuv/12lFLxLqtBnWr4u6CggN///vc4HA4Mw+DOO+8kKyuL5cuX8+STT2IYBjfffDPDhw9nzZo1PPHEE0yZMiW8B2VzXHXVVRQUFPDJJ5/gG1mIY006ZqEszhBBq79cz4wrD2fIpAFsWiRn9YrYbMuWUClq6TuqJ31H9OLV370vfzZELXaqD//oIjDgiCOO4De/+U2HD5TQyRbqpKWl8cQTT/CPf/yDmTNn8uGHHwLw9NNP89BDD3HXXXfxr3/9C4A5c+bw8MMPk5eX16J7KqW47bbbOOaYY8CAwH5F2OneFr8W0TXYluab/y5k+sWHxLsUIUQnc+TFU/jutSX4qwLxLkV0IHaKD//+RWBqpkyZwj333IPD0Tn6ADtVqDRNE8MIllxRUcHQoUPxer0YhkFKSgq9e/emtLQUgGOOOYZbb72VrKysFt/X4XBwxx13MG3atODm6GOLsNN8Lb6u6Bp++mg1Gf3SGHxA/3iXIoToJHoPz2LIAQP48a1l8S5FdCB2kj8cKA888ED++Mc/4nK54l1Wk3WqUAmQnZ3NVVddxVtvvcWoUaMoLS0lKSkp/HnTNPH7/YwdO5bHH3+ciy++uFXu63A4uOeee4KrriRYigiW3+Kblxcx/eIp8S5FCNFJTPvlIfzwxlK85fLviAiyk/34xxeCQzNhwgQeeOAB3O7ONd2uQ/an5ufnc++999Z7/O6772bkyJH8+9//Zu7cuf/f3p2HR1Xe7QO/zzmzZiMhCSQsCRAIW8JOQJBddhAUEf1V31IrfWuLWmlV+mqrgLYWsO2LIFqqokJBfUVEQEABsYIQFoEgYS17EiAbWSaTmTnn+f0xk0nCKk6SM8v9ua655szZ5ptkMnPPOed5HixbtgzTp09HeXm5dx1VVeuth3mj0YhZs2bhueeeQ2ZmJpydeY0lue377BAGPJyBlmmJOHcoV+9yiMiPxSXHoG1GMtbO36x3KeQntKjqU96dO3fGX/7yF1itVr3Lum1+GSpjY2OxYMGCa+Y7ndXDV0VERMBiscBisUBVVZSWlsJmsyEysn77kzSbzXj55ZfxwgsvYMeOHXB1LAaONoJSwFbhoczlULFjxR4MfqQv3p/xid7lEJEfG/yzvsj85ADsZbw+nwCtUSWcna4AikD37t3x5z//GWFhYXqX9aP4Zai8kePHj+P111+HoigwmUx49tlnAQCPPvoonnnmGUiShBkzZtR7HWazGS+99BJeeuklbNmyBa4OV4DjAsqlwPtWQXVn9ycH0XdyD7TplcSW4ER0XYmpTdCmVxLWzl+qdynkB9SYSvfBKRno06cPXnrppYA75V0T+6n0gaqqmDdvHtavXw8AsJ6PgXY6cC6opbrXbUwnZNzbFUumreDIewTA3U/lH796ArMHL2C3MYSH/3oPTmaewY6V+/QuhXSmxlfAlVoCSMCAAQPwwgsvBFSjnOsJuIY6/kRRFDzzzDOYNGkSAKCiRRFcyRwrPJQd2JANg1FB56GpepdCRH6mTa8kxCU1ZovvECcg4GpRDld7d6AcPnw4Zs2aFfCBEmCo9Jksy3jiiSfw85//HACgtrTBlVoCITFYhiKhCXz55nYMndYPioH/XkTkJknA8MfuxNa3v4XLoepdDulEQMDVphRqqzIAwIMPPugd1CUY8FOvDkiShJ/+9Kf4/e9/D0VRoDWxw9m5CELhqa5QdGzHKZTml6PXxC56l0JEfiJ9eAcoRgUHNmTrXQrpRMgCro5XoDWrgCRJePzxx/HYY495+98OBsHzk/iB0aNHe7sBENFOOLsUQpj5jTQUbXxtGwZN7YPwaDbeIgp1JqsRwx+7Extf2wah8SxWKBJGFc60ImixlTAajXjxxRcxefJkvcuqcwyVdSwjIwMLFy5EbGwsRLgKR9dCaJHs3DbU5By9hOxtJzDsv/vrXQoR6WzgT/vg/Pd5OLmbvUKEIi3cCUe3QogoJyIiIvDqq69iyJAhepdVLxgq60G7du3wxhtvoG3btoBJgzO9CGrTCr3Loga2eckOdBiQguYdm+pdChHpJLZlDHpNSMfGhV/rXQrpQI21w9mlCDBraNmyJd58801069ZN77LqDUNlPWnatCkWLVqEQYMGATLgalcCV2u2DA8ltuIKbH3rW4z5zRBIkt7VEJEeRj85CN9+sA/FeSV6l0INSEDA1bIMro7uTs0zMjLwxhtvoGXLlnqXVq8YKuuR1WrFrFmz8MgjjwAA1OY2ODsXQxjYgCdU7F2TBcWooPu4NL1LIaIG1mFACmJbxmD7v/boXQo1IKFocHW4AjXZPYT05MmT8corr9T7iH/+gKGynsmyjKlTp2LOnDmwWCwQMQ44uhVAi3DeemMKeJoqsPbVLbjrv/sjIjYwh90iottniTBjzFNDsP5vW9mFUAjRwpxwdiuEFlcJg8GAZ555Bo8//njQdBl0KwyVDWTQoEFYvHgxmjdvDlg0OLsUQk208XR4CDj/fS4ObjqCMb8Jzguziehawx+7E6e/O4/jO0/rXQo1EDW+As6uRRBWFU2aNMHChQsxbtw4vctqUAyVDSglJQVLliypvs4ypRSicxn7swwBW5bsQLP2TdFxYIrepRBRPWvVrQU6DEjBhte26V0KNQAhCThTStwj5CgCvXv3xj//+U906tRJ79IaHENlA4uIiMDs2bMxffp0KIoCZ4wNzq6F0MJ4OjyYOSqc+Gz+ZoyZMRSWCLPe5RBRPTGYFIx/Zhg2vLYNtmL2+hHsNIvL/Rme6O7QfOrUqZg7dy6io6P1Lk0XDJU6kCQJ999/PxYsWID4+HiIMBXOboVw8XR4UDuZeQYnM89g5PSBepdCRPVkyKN3oOB8MbK+OKp3KVSPBATUJhVwdi+EiHAhKioKc+fOxSOPPAJFUfQuTzcMlTpKT0/HW2+9hTvuuAOQATWlFK5OxRBGXtQdrDYs2IaU3knoMICnwYmCTatuLdB9dGesnbdZ71KoHrlbd5fAleo+3d29e3e888476NOnj96l6Y6hUmfR0dF45ZVX8Jvf/AYmkwlaYwcc3QuhxlTqXRrVA3tZJT750yaMf3oYW4MTBRFLhBn3PD8C6/66BSWXy/Quh+qJFumAo0cBtDg7FEXBL37xC/z1r39FfHy83qX5BYZKPyBJEu69914sWbIEbdq0AUwaXJ2L4WxTAiHzdHiwObX3HA5uOoIJM0foXQoR1ZExTw3G6e/O4/utx/UuheqBkARcyaXe0XGaN2+ORYsW4aGHHgrp091XY6j0I61bt8abb76J++67DwCgNauAo3sBtCiOHR5sNv9jO6LiI9D7ni56l0JEPkobloqk9OZY//ev9C6F6oEW7oSzeyHUljZAAkaOHIm33norJFt33wpDpZ8xm8144oknMH/+fDRp0gSwqnCmF7mHeORRy6DhcqhYNWcDhk7rh4S2PG1CFKhimjXCmKeG4JOXN6KynAcAgomQBFxJZXB2K4QIcyEmJgYvv/wynnvuOYSF8fKl62Go9FMZGRlYunQpxo4dC0ieIR551DKoXDyZjy/f2I7Js8fAHG7Suxwiuk0Gk4L754zFtx/sw5kDF/Quh+qQFu4eGUdNKgckYOjQoXj33XcxYMAAvUvzawyVfiwiIgLPPvss5s6d6+56qOqoZZsSdpgeJPauycKF7Dzc/exdepdCRLdp5OODUFZowzfLdutdCtURIXuunexWCBHuQqNGjTBr1iy8+OKLIdv35O1gqAwAffv2xdKlSzFmzBj3UctmFXD0KIAaa9e7NKoDa+dvQZPWcciY1FXvUojoB0q/qz1S72iNT17aAMErk4KCFl0JZ48C77WTgwYNwrvvvoshQzjE7g/FUBkgIiMjMXPmTLz66qvu8cPNGlwdr0BNL4EwsV/LQOaocOLDP6zFkJ/fgRadEvQuh4huIb5VY4yZMQT/9+J62K7wy32gEwYNztQrcKYVQ1hUxMfH409/+hPmzJmDxo0b611eQGGoDDC9e/fG0qVL8fDDD0NRFLgaVcDRswCuZhyNJ5BdPl2Ida9uxZSXxyEyLlzvcojoBqyRZjz457ux9a1vce5Qrt7lkA8EBNSmFXD0zIfWxA5JkjBp0iS8//77uPPOO/UuLyAxVAYgs9mMadOm4e2330ZaWhqgCKht3NeAsCFP4Dq0+Sj2f34YD/xpPAwm9ntG5G9kRcLk2WNxat85ZH58QO9yyAdahBPOrkVwtSsBjAJt27bF4sWL8eSTT7Jltw8YKgNY69atsXDhQvz2t79FZGQkRIQLzi5FcKZe4SnxALVlyQ6UFZRjwszhepdCRFcZOX0gFKOC9X/bqncp9CMJgwZn2xI4uxZCRDoRFhaGX/3qV/jHP/7BfifrAENlgJNlGRMmTMDy5ctx9913Q5IkaE3s7lPiLcohJJ4SDyRCAKvmbETTlDjc+VBvvcshIo8e4zqjff8UfPj8Wqgu9r4RaAQE1EQbHL3yoSVUeDsxX7ZsGR544AEYDAa9SwwKDJVBIjo6Gr/73e+wZMkSpKenu0+JtypztxJvbOf1lgGk0ubAit9/hjvu747OQ9rpXQ5RyEvpnYThjw3Ait+vQXlxhd7l0G3Soivh7F4IV0opYBBo164dFi1ahOeeew5xcXF6lxdUGM2DTGpqKhYuXIgvvvgCixcvRkFBAVydrkC6YoThVCTkMqPeJdIPUJRzBStmrsFP5k9EWZENZ/azY2UiPSS0i8d9L47Bx7M+x8WT+XqXQ7dBC3NCbV0GLcbd1iAyMhLTpk3D+PHjOV53PeGRyiAkSRJGjBiB5cuX4+GHH4bZbIZo5B4dwNm+GMLs0rtE+gHOH87D6pc3YcqccYhvxW4tiBpadEIUfjJ3AjYu/BonMs/oXQ79QMKkwtn2CpzdC6HFOGAwGHD//fdjxYoVmDhxIgNlPWKoDGJhYWGYNm0ali9fjtGjR7uvt4yvdF9v2boUwsDrgvzd0e3/wZZ/7sBD8yeyqyGiBmSNNOMn8yZi9ycHsf/zw3qXQz+AUDS4ksrg6FkALcEOSMCQIUPw/vvvY/r06YiKitK7xKAnCcGxAELFiRMnsHjxYuze7RlSzCVBuRAGJScMksrvF/5s6LR+aN+/DZY+8X+oKGFny4FEVmT88asnMHvwAmgqv8gFApPViIdfvQcX/1OAtfM3610O3YKQ3Y1w1BblgNEdaTp37oxf//rX7m73qMEwVIagzMxMLF68GCdPngQASC4Z5otRMOdHwl7Kfi791djfDkXzDk3x7m8+RmU5/06BgqEysBhMCn4ydyLKiyuwas7n0FR+RPorIQloTSvgSioHTO7/raSkJDz66KMYNGgQJEnSucLQw1AZojRNw9atW/H222/j3LlzAIDoRtEo26tCvmiFJPjP6G8kCZjw+xFo3CIay377CRwVTr1Loh+AoTJwKEYFD7w8DqpLw4d/WMe/l58SENDi7VCTyyEs7j6ZExISMHXqVIwYMYLdA+mIoTLEuVwubNq0CUuXLkVeXp57pl2G4Vw45EsMl/5GViRM+uNoWBtZ8K9nPoXLwU7u/R1DZWCQFQn3vTgGpjATVv5+Df+3/JCQPGGyZTmE1f33ady4MR5++GGMHz8eJpNJ5wqJoZIAAA6HA2vXrsV7772HwsJC98xKGYbz4e4jlxrDpb9QDDLuf2kcJFnCh8+v5Yefn2Oo9H+yImHi/4xEVJMILP/dajgr2UOGPxGSgNakAmpLm/fIZFRUFB588EHce++9sFqtOldIVRgqqRa73Y41a9ZgxYoVKCgocM90yO4GPblWSBob9PgDg0nBlJfGQVZkrPyfz/gh6McYKv2brMiY9MdRiIgNx7+e+RSVNl6v7C+E7LlmskU5YHb/78TExGDKlCmYOHEix+j2QwyVdF2VlZX4/PPPsXz5cly8eNE90+lpLZ7L1uL+QDEquO+F0bBGWfCvZz/lNZZ+iqHSfxlMCibPGgOj1YgVM9fAaeeXM38gZA1qYgXU5jZvA5y4uDg8+OCDGD9+PCwWi84V0o0wVNJNOZ1ObNq0CcuWLcOFC55RXVQJSp7V3RVRJTuR1ZOsyLjn+ZGITojC8qdXw15WqXdJdBWGSv9kNBsw5U/joakaLyPxE8KoQm1mg5pYARjc0SQhIQE/+clPMGrUKJjNZp0rpFthqKQfxOVyYcuWLVixYoW3KyIIQM43Q7kQzuEfdSTJEu5+9i40TYnD8qc/RXmRTe+SqAaGSv9jDjfhwT/fjYpSO/7vxc+hOhko9aSFuaA2L4cWb/cOydK8eXM89NBDGDlyJFtzBxCGSrotQgjs3r0bK1euxJ49e7zzpWKjO1wWmSCBjXoamiQBI6YPRPt+bbDsd5+g8MIVvUsiD4ZK/xIZF46H5k9E7rHLWPOXL/k30YmAgGjkgKuFDSKm+jrW9PR0TJkyBf379+dwigGI8Z9uiyRJyMjIQEZGBk6cOIEPPvgAX375JdRoJ1zRxZDKFSi5YZAvWdiopwEJAWx87WuUXi7DI4vux7+e/RQ5Ry/pXRaRX4lLjsFD8+/BwU1HsGXJDr3LCUlCEtDi7FBb2CDC3dewyrKMgQMHYsqUKejcubPOFZIveKSSfHbp0iV8/PHHWLNmDcrLywEAkirBVBABU34kHIU8tdSQ0oe3x5jfDMHHsz7HicwzepcT8nik0j+0TEvEA38ej23v7ELmqgN6lxNyhFmFmmCDmmAHjO7/A4vFgrFjx2Ly5Mlo1qyZzhVSXWCopDpTVlaG9evXY/Xq1Th//rx3vlxshiE3DHKxmafGG0jrni1x3wujsXnJDuz77JDe5YQ0WZHx/ObpeGnYQoZKnXQa0g5jZwzB2vmbkb3tpN7lhAwBAa2RA66Ecmgxlah6+4+Pj8fEiRMxYcIEREVF6Vsk1SmGSqpzmqZhz549WLVqFb799ltUvcRiYmLQt29f9OzZE+Hh4TpXSURE9cFut2Pv3r3YuXMn8vPzvfN79OiBe+65B/3792fjmyDFUEn1KicnB6tXr8a6detQWlrqnqkBSoEFyqUwyCVs2FOfwqKtmDxrDFxOFz5+cQO7HNIBj1Tqw2gxYMLvhyMmsRE+fH4trlwq07ukoCYgICKccDWxQY2zA4o7WoSFhWHUqFGYOHEiWrVqpW+RVO8YKqlB2O12bN68GatWrcLx48erF1QoUC5aoVyyQHKwpV99UAwyxv52KJK7NseKmWuQf7ZI75JCCq+pbHiNmkTiwVfuRuGFYnzy8kZ2al6PhEGD2qQCWoIdIqz699y6dWvcc889GDFiBEe+CSEMldSghBA4evQo1q5diy+//BI2m6dPRQHIhSbIF62QC3ntZX3oc183DP5ZX3w2bzMOf3X81htQnWCobFhtM5Jxz/MjsfuTg9i2dCf4CVf3BAREtANqQgW0xpXeviXNZjMGDx6MsWPHomvXrpAkvo+HGoZK0k1FRQW++uorrFu3DgcPHqxe4JChXLRAvmyFbON1N3UpqUszTJ41Bt9vPY4vXv83VBdDTn1jqGwYkixh8M/6oNfELvjkpU04seu03iUFHWF2QW1qh9a0AsJc/Vpu3749xo0bh2HDhiEiIkLHCklvDJXkF86cOYN169Zhw4YNKC4u9s6XygyQL1mgXLZAcvL0eF0IjwnDpBdGwWQx4qM/rseVS6V6lxTUGCrrX3i0FZNeGA1TmAkf/XEdrlzka7quCIPm7leyiR0iyumdHxkZiREjRmDs2LFo27atjhWSP2GoJL/idDqxfft2bNy4ETt37oSqevq4FIBUbIJyyQK5wMyO1X3kPqrTF70mpuPTP3+BYztO6V1S0GKorF+turXAvX8chextx7FpEY++1wUhC2iNK6E1qYAW4/B2BSTLMnr06IGxY8fizjvv5FjcdA2GSvJbxcXF+Oqrr7Bx40Z8//331QtUCcYrVpiKImAotbBFsw9SMpIx8X9G4Mi/T2LTwq/hrGSDhrrGUFk/FIOMIY/2Q4+xnbH21S28TthHVcMmqk3s0OIqva23ASA1NRXDhw/HsGHDEBcXp2OV5O8YKikgXLhwAV988QU2bdpUq2P18LBwVJxS3afHr5ggCV4YfrvCoq24+5m7EJcUg49nb0DuMQ7vWJcYKuteXHIMJv1xNCpK7Fj9p00ouczugn4Md5B0Qo31BElT9eszISEBw4cPx/Dhw9kVEP1gDJUUUIQQyM7OxqZNm7B161YUFdXoHscpQS40Q863QC5mwLxdPcZ1xvBfDcCOFXux/V97oKl8a6gLDJV1R5KA3vd0xdBH+2Hbu7uw88N9bN19m7xHJOMq3UHSWP2ajIyMxNChQzF8+HCkpaVBlnmZEd0ehkoKWKqq4uDBg9i6dSu+/vprFBYWVi90SZALGDBvV+MW0bjnf0ZAMSr49JUvcPFk/q03optiqKwbsS2jcfczd8EcbsYnL2/ka/M2CKlGkIy9NkgOGDAAgwcPRs+ePWE0GnWslAIdQyXd1HfffYd3330XQghMmjQJAwcOxMGDB7F48WLIsowZM2YgJSUF2dnZWLRoEfr06YOHH364wetUVRVZWVnYsmXL9QNmkcl9FLPIDMnFb983I8kSMu7pisE/74vMjw/g6/cyoTpVvcsKWAyVvpEVCXdM6YEBD2Vg+4o92P6vvfw9/gBC0aBFO6DFVrr7kjRUf9Q3atTIGyR79Ojhd0MmBsrnDl3Lv15J5FcqKyvxwQcfYN68ebW+vS5ZsgRz586FzWbD/PnzMW/ePGzevBnz5s3D66+/rkutiqKgW7du6NatG5588klkZWVh69at2LZtGwoLC6HFV0KLr3S3Ir9ihFxohlJghlTJf4GrCU1g18f7cXTHfzD+6WH45dv/D2v+8iXOHcrVuzQKMU1T4jBh5nCoLg1v/eoDXD5deOuNQpgwq9AaV0JtXAnRyOHtlBwAoqOjMXDgQAwePBjdunXzuyBZJZA+d+ha/vmqIr9w6NAhmM1mzJw5ExaLBTNmzEBERARkWUZkZCQiIyO943kPHToUTz/9NHr37q1z1dcGzCNHjmD79u345ptvcOrUKYhoJ9RoJ9Q2ZZDKFfcRzEIzpFIjR/KpoTi3BO/P+ATdx3TCg3++G0e3/wdfvvENyosr9C6NgpwlwowhP++LLiM7Yts7u7Dr4/0QGk+qXc093rbL3f1P40qIiNq9NzRv3hx33nkn+vfvj7S0NL8NkjUF6ucOufn/K4x0U1RUhPPnz+ONN97Anj178M4772Dq1KkIDw/3rqMoCpxOJzp16oSFCxfqWO31ybKMTp06oVOnTpg2bRpycnK8AfPAgQPQwlWo4TaoLW3uhj7FJshFZshFJna27vHd+sM48s1/MOwX/fHrZf+Fr97eiT2fHmRDHqpzkgR0Hd0Jd/13f/xnzzm8/vD7KC0o17ssvyIMGrToSmgxDogYB0SNFtuyLCMtLQ39+/dHv379kJSUFHBDJQbD504oY6gkFBQUYNasWdfMv/vuu5Geng6j0YiePXti+fLliIiIQHl59Zu8qqoBdWF3s2bNMHnyZEyePBmlpaXYuXMntm/fjl27dqG8vLz6NDk8o/kUmSAXmyGVGEO6sU9FiR1r52/Gvs+yMGbGUPQYl4b1f9+Kswdz9C6NgkRiahOMeWoITFYjPnphPc7sv6B3SX5BQEBEOd3XR8Z4jkbWeCuyWq3IyMhAv379cMcddyA6Olq3Wm9HKH3uhBKGSkJsbCwWLFhwzfzi4mKsW7cOQgicOHECiYmJsFgsUFUVpaWlsNlsiIyM1KHiuhEZGenth83lcuHw4cPYtWsXdu/ejSNHjkBEuKBGuNxHMVUJhjILjCVWuC5JkCqUkDxVnnP0Et765Up0H9sZ988ei3Pf52Lzm9uRf7bo1hsTXUd0QhSGTuuHtn2S8fW7mchcdSDkG+IIs+o9GqlFO2o1sgGANm3aICMjAxkZGUhPTw/IkW1C9XMn2LH1N93UqlWrsGXLFkiShJkzZ6J58+bYv38/3nzzTUiShBkzZgTluK9FRUXYvXs3MjMzkZmZWWs8cgBApQz5isl9KzZBqgy9U+UmqxH9HuiJvpO7I2vzUWx7ZyfKCm16l+V32Pr7+qyRZgz4rwz0GJeGvZ9l4Zv3d6OiNDRHxxImFVojd4DUGjkAS+3XSVRUFHr16oWMjAz07t0b8fHxOlXaMEL1cycYMFQS3YKmaTh+/DgyMzOxZ88efP/993A4HLVXssvu6zE9QVNyhE7IjIgNw+CpfZE2rD12fbwfOz/cF7Lh4HoYKmszWY3ImNQN/R7ogeM7T2PrP79FcV6J3mU1KGGsCpFOiEYOCGvtLrsURUHHjh29RyPbt28PRQmd9xQKXAyVRLepsrIShw4dwr59+/Ddd98hOzsbqlr7Q0GyKZBKjJBLTO7rMe3Bf7o8LikGgx/pi5SMZGR+fIDh0oOh0s0bJqf0wLlDOdj69k7kHb+sd1n1TkAAZg1alANalCdEhtV+v5BlGampqejevTu6d++OLl26ICwsTKeKiX48hkoiH9lsNmRlZXlD5rFjx6BpV4UHhwy5xAip1Og+klluCNqGP/GtGmPgT/ugXZ9WyFy1H99++B0qSux6l6WbUA+V5jATMiZ1xR3398DZrBxsW7orqMeX93bzE+WEiHQHSZhr/90lSULbtm29IbJr166IiIjQqWKiusNQSVTHSktLkZWV5b0dOXLk2tPlKiCVVR/JlMsMQdeFkTdc9m2FAxsOY+eH36EoN7ROcwKhGyoj48LR577u6Hl3Gs7sv4BtS3ci91jwHZkUBg0iwgktygktygER6QKU2h+riqIgNTUV6enp6NKlC7p164aoqCidKiaqPwyVRPXM4XDg6NGjOHToEA4ePIhDhw7hypUr165olyGXeY5mlhkhlRkgqYE/pGRMs0boe393dBvVEScyz+Dblftw/nCe3mU1mFALlU1T4tDvgR7oMLAtvt9yDN9+sC9oRsIRsnAHyAgnRKQTWoQLsF47hGlERATS0tKQnp6O9PR0dOjQARaLRYeKiRoWQyVRAxNC4OzZs8jKysKhQ4eQnZ2N06dP45p/ReG5NrPMCLnUCIsaDsVu8p42rygLrFPK1kgzek3sgoxJ3VCUcwWZHx9A9tcngn5c8VAIlbIiIbVfG2Tc2xUJbeOxe/VB7P7kQED2BmCNcIc/IQmoFgfsSrknRLogwmr3EVmlefPmSEtL8wbJVq1aQZYD/wsh0e1iqCTyAzabDUePHkV2djaOHDmC7OxsXLx48Zr1ZFlGYkIzJLdIxq4PDrhPm5cbIbkC5wNMMSpIG5aKXhO6oHGLRvhu3WHsXZOFopzrHL0NAsEcKhs1iUSP8Z3RfWwabMUV2L36IA5uzIaz0nXrjf2IUDSIcBe0CBf6/aQ7zp4/g/M5569pgAe4+1fs2LEjOnTo4L1nv4lEbgyVRH6qoKDAGzCzs7Nx7Nix6582B9z9ZpYbIJUZ3Y2Ayg0B0eI8oW08ek5IR/pd7XHhcB72rfseR785CZcjeI5eBluoVIwK2vVthe5jOqFVj5Y4vPU49qzJwoUAuKTB2xI73AkR4XIHyXDnNf1CVomIiECHDh1qBchg7yOSyBcMlUQBQgiB/Px8nDhxAsePH8fx48dx4sQJXLhwg+HsNECq8ARMmwLJZnDf/DBsmqxGpN/VHl1Hd0KT1rHI/voEDm7Mxun9FyC0wH6LCpZQmZTeDF1GdEDnoakoyrmCAxuycWBjNuxl/tdtlDs8qtDCVQir+7S1+6Ze04imSkJCAtq2bVvrlpiYGHBjZxPpiaGSKMCVl5fj5MmTtYLmmTNnUFl5gw97DdUB06a4g6fdc6/p/wEakxiF9BEd0HVkRxjNBmRtPorDX51ATnYeAvHdKpBDZUK7eHQa1BbpwztAkiQc3JSNg18cQf4Z/xiWU0gCwqpCWNyB0RserS7gBp0pGI1GtGrVyhsc27Vrh5SUFJ7CJqoDDJVEQUhVVVy8eBGnTp3CqVOncObMGe/9DcMmAFTK7nHNvUGzxrQO/Wo269AUXYZ3QIeBKZAVGUf+fRJHvj6B0/svBExAC6RQKckSWqYlouOgtuhwZwoMZgOO/Psksr44gnNZObqEeiEJCItaHR6t1dMwa9dtOAMAJpMJSUlJaNWqFZKTk9G6dWu0atUKzZo1g8FgaNgfgihEMFQShZDrhc3z58/j/PnzN75eEwAE3IHTrkCqVNz3NabhkOv9lHpiahN0HJiCDgPbIjI2HCd2ncaJzDP4z+6zKC0or9fn9oW/h8rwaCva9EpCSkYy2vZJRmW5A0f+fRLZX5/EhcO59R4kBQRg0iDMqjs8mjXPvTs8wqzeMDgCQHh4OFq0aIHk5GRvgKwKjxzakKhhMVQSEQCgpKTEGzDPnTtX695mu0XXMBqASgUGlxGywwDZoUByGuAqUQGHAqlSBlSpzoJnbMtotM1ohZQ+yWjVtTmKcktwcvcZnMw8g3OHcuGocNbJ89QFfwuVBpOCFp0TkZKRjJTeSYhPboyzB3NwcvcZnNh1BpdOFdTp8wlFgzBpgEmFMUqBZnJBM6nQTC6oBieEWQVu0XmB1WpFixYtrnuLjo7mdY9EfoKhkohuSgiBwsJCXLhwAXl5ecjNzUVeXl6t2/W6XrmGCkgOxX3E06FAcshApftecsruo53O2w+filFBy7REtM1IRkpGMuJbNcbFk/k4l5WLs1kXcDYrB2UF+vWXqHeoDIu2Iim9GVqmJyIpvTkS28Wj4HyxO4TvPouzBy7cdhdAAsLd4MXgDozu0KhBmDxHGj0hUpg0wHDrjxhFURAfH4+EhATvLTExEYmJiWjRogViY2MZHIkCAEMlEflEVVXk5+dfEzjz8/Nx+fJl5Ofno7S09IfvUAPgrB00JadcPc8lQ3JJ1fdOudb1nuZwE1p0TkSSJ0Q175SA8iIbco9d8twuI/fYJZQXNUzQbMhQGdbIgoR2TZCY2gSJqfFITG2CqCaRyMnOw9lDuTh78ALOH8pFRWnt62qF5AmIhhr3Rg3CqF1zXzV9o4Yw1xMeHo64uDjEx8cjPj4eiYmJaNq0KRITE5GQkIC4uDhe50gUBBgqiaje2e125Ofne4Nm1a1qXnFxMYqKim59mv1GVFwbNl3uo56ykBHRKALR8VFonBCDuOaN0SQpDlAllF2uQPklG0ryylF8oQSFZ0tQcqkUqMNGSfURKiPiwhCXHIOY5o0Q1SwCUQlhiGgSBsUs49LZfFw+V4D8C4UoulSMksJSaNAApUZoVGqHyNsJiDWZzWbExMQgNjYWcXFx3lt8fLz3PjY2FmFhYXXycxORf2OoJCK/UVlZ6Q2YRUVFKC4uRmFhoXe6qKgIpaWlKC0tRVlZGUpLS6FpdX/0T5EVyLICWZIgCRnQAOEChCogXIDmEtBU4R5Ks+odVEjuBk2A+94TTCVISB/RHllfHHGfNnbPrHEvAM+msiJBNkqQDBJkg/teUjwtoCUBITSomgqXS0X1k9UNSZIQHh6OyMhIREZGolGjRoiJiUF0dPQN761Wa53WQESBjaGSiAKWpmmw2WzeoHn1raKiAjabDRUVFbecDtS3QlmWYbVaf9AtMjISERER3uBYczo8PJzjVRORTxgqiSjkCSHgdDrhcDi891W36813Op3QNA2apkEIAVVVIYTwzrv6JkkSZFmGLMu1pms+rro3GAwwGo0wGo0wmUzXva+arrqxEQsR+QOGSiIiIiLyGc91EBEREZHPGCqJiIiIyGcMlURERETkM4ZKIiIiIvIZQyURERER+YyhkoiIiIh8xlBJRERERD5jqCQiIiIinzFUEhEREZHPGCqJiIiIyGcMlURERETkM4ZKIiIiIvIZQyURERER+YyhkoiIiIh8xlBJRERERD5jqCQiIiIinzFUEhEREZHPGCqJiIiIyGcMlURERETkM4ZKIiIiIvIZQyURERER+YyhkoiIiIh8xlBJRERERD5jqCQiIiIinzFUEhEREZHPDHoXQOQPhBCw2+16l0FEdFssFgskSdK7DCIADJVEAAC73Y6RI0fqXQYR0W3ZuHEjrFar3mUQAeDpbyIiIiKqAzxSSXQVU2YTSMLzfUuSIckSIMmALAGSBEmuWuaZL0mALEGqWse7TPJu470BNeZV79O7Daq3EZJU/bWvxj6882tsV3Oe8OzGu0wGgKr5kndZ1TbCM8+7HKjeh+xZ37tN7eeotQ088+TrLKu1PmrVWD1PumbZNdug9ja1lqN6mxs9V63HN6jjmm1utl/vfFFr+6v3511eY1/CMx9XbQdJ1NjevVyqucy7btUy4d2nVHN9z3xJEtUvP8/86peH8C6XIbyP3csA2fPYvcz9uGo77zJJQEL1drJnnvcG4d1OllBrfvU2WvW6EJAlDUrVMs/j6n1p3v0pNfavwD1fkbSrttOgVO0T1c/nXR/V+5Ph3l6G+/ndy9z7UzzzJGhQqrZHVR0aFMC9HdzPU/WzVT12P5fwTMOzTED2/F4USJABKJ4/tgzJM0+CIkmQPW8GEiQ4HQomTUsAkb9hqCS6mip53t7hDpXwBEDPp3X1MgmQqxOU5E5onp1UJQ+5evqatCFfm3gk6dr1a+4PV61fa9nV0zXWqQqTNULlNfNqhMCaj68usfb619lGvsmyG/0Y19vvjba72fwf/Fy3t8/rhtha29VxqLzeclz9WHj3XbOOms9Ze5urQqh3Wc3l4jr7E9d5LlHrVjNUVgdVz+1Gy64XNlEVRlEr6FU9VlB7mTtUatWhTKoZytzTsiS5A5/nHt5pybtddYAFFKn6XgFqBMDrLPPsz/1YeEKp8IZI93bilqGy5v4UzzIZtedVBVjZ83MT+SOe/iYiIiIinzFUEhEREZHPGCqJiIiIyGcMlURERETkM4ZKIiIiIvIZQyURERER+YyhkoiIiIh8xn4qia6mCAjh7vDY3e+iVONeuqpD8qr7GtOoOU/UmL7Jsqr5NTotrO6iGjeYX30vak2j1nYCAETV/Op9CkiAgHfbmsu9+6jVuWLNWq7zWNQq6arfxw1uV697q74jcYP5t1p2s74ob7as5k940+2u199kzZu4QY037vy8dt+SNZZ51/3xnZ9X11Gjn0r8+H4qBaq3E5KofYP73r0MteZr3v1p1c8DAUhajf40Ra3lQtK8+0Ot/Xvuq57L81j2rFN1D+CaeVqNviE1qfpeQ3U/lZpnnoQb9VMpeTssV1D9N6t6LHu2ubrvyx/e+bnk+bNIcDqu939JpD+GSqKrODIu6V1C/aj6zPbB1XGWCKj90tL0LORHq/nK5gk8oh+L/z1EAOx2u94lEBERBTQeqSQCYDabvdOffvopLBaLjtUEL7vdjgkTJgDg77m+8XfdMPT+PfPvSv6EoZIIgCRVn9C1WCywWq06VhMa+HtuOPxdNwz+ninU8fQ3EREREfmMoZKIiIiIfMZQSUREREQ+Y6gkIiIiIp9JQggfe64jIiIiolDHI5VERERE5DOGSiIiIiLyGUMlEREREfmMoZKIiIiIfMZQSUREREQ+Y6gkIiIiIp8xVBIRERGRzxgqiYiIiMhnBr0LINKbzWbDypUrsW3bNuTl5UGWZbRs2RJDhw7FpEmTYDQa9S4xoF25cgXbt2/H3r17cezYMVy8eBGqqiI6Ohrt27fHqFGjMHDgQL3LDFrLli3DP/7xD+/jr7/+Wsdqgk95eTlWr16Nb775BufPn4fNZkN0dDRatGiBrl27YvLkyYiMjNS7TKIGwRF1KKTl5eXhiSeeQF5eHgDAYrFA0zQ4HA4AQLt27fD3v/+dHwo+GDJkCFRV9T42mUxQFAUVFRXeeX369MGcOXNgsVj0KDFonT17Fo888oj39QwwVNalffv2Yfbs2SgsLAQAGI1GmM1mlJWVedd566230K5dO71KJGpQPFJJIcvlcmHmzJnIy8tDbGwsnnvuOfTq1QuapmHr1q2YN28ejh8/jjlz5mDu3Ll6lxuwVFVFx44dMXr0aGRkZKBZs2YAgNzcXLz33ntYt24ddu3ahfnz5+P555/XudrgoWkaXnnlFTgcDnTu3Bnff/+93iUFlaysLDz77LOorKzEwIED8dBDD6F9+/aQJAl2ux2nTp3CN998g/DwcL1LJWowPFJJIWvt2rXesPj6668jLS2t1vIvv/wSs2fPBgD87W9/Q8+ePRu8xmCwb98+9OjR44bL58+fjzVr1gAAPvroIzRt2rShSgtqH330EV577TUMHz4czZs3x9KlSwHwSGVdsNvtmDp1KnJycjBp0iQ8+eSTepdE5BfYUIdC1oYNGwAA3bt3vyZQAsCwYcOQmJhYa126fTcLlAAwduxY7/TRo0fru5yQkJOTg3/+859o1KgRHn/8cb3LCTobN25ETk4OGjdujF/+8pd6l0PkNxgqKSTZ7XYcOnQIANC3b9/rriNJEvr06QMA2L17d4PVFmpMJpN3WtM0HSsJHvPmzUNFRQV+/etfIzo6Wu9ygs7GjRsBuK8XNpvNOldD5D94TSWFpDNnzngDTOvWrW+4XtWywsJClJSUICoqqkHqCyX79+/3Trdp00a/QoLEZ599hr1796JXr14YNWqU3uUEHYfD4T2inpqaiosXL+K9997Dzp07UVRUhMjISHTs2BETJkzAHXfcoXO1RA2LoZJCUn5+vnc6Pj7+huvFxcXV2oahsm6VlpZi2bJlAIAuXbogKSlJ54oC2+XLl7F48WKYzWb87ne/07ucoJSXlwen0wnA3djspz/9KWw2G4xGIywWC4qKirBjxw7s2LED48aNw9NPPw1JknSumqhh8PQ3hSSbzeadvtnpq5pd3NTchnynaRpefvllFBQUwGQy4amnntK7pIA3f/58lJWV4Wc/+5m3lT3VrdLSUu/0e++9B4PBgNmzZ2Pjxo1Yv349PvroIwwZMgSAuzHghx9+qFepRA2OoZKIdLFgwQLs2LEDAPDUU08hJSVF54oC26ZNm/Dtt9+iXbt2uP/++/UuJ2jVvO5X0zQ8++yzGDx4MAwG94m/pk2b4oUXXkDbtm0BuDufd7lcutRK1NAYKikkhYWFeacrKytvuJ7dbr/uNuSbRYsWYdWqVQCA6dOn12oBTrevsLAQr732GhRFwdNPP+0NOFT3ar4PtGjRAgMGDLhmHVmW8cADDwBwjyh17NixBquPSE8MlRSSal4refny5RuuV/Pay5rb0I+3ePFifPDBBwCAX/3qVzyqVgfefPNNXLlyBePHj0dSUhJsNlutW80jZVXzqq4LpNtT8xrsm10DnJyc7J2uGrGLKNjx6yyFpOTkZMiyDE3TcOrUqRt2K3Tq1CkAQOPGjdlIpw68/vrrWLlyJQDgscce8x7NId/k5uYCAFavXo3Vq1ffdN2qFuH33XcfnnjiifouLehERUUhPj7+pl9Gr8aGOhQqeKSSQpLFYvF2eL5r167rriOEQGZmJgCgd+/eDVZbsFq0aFGtQPnggw/qXBHRj1P1fnDmzJkbrnP69GnvdNUgCkTBjkcqKWSNGjUKBw8exHfffYfDhw+jU6dOtZZv3boVOTk53nXpx1u0aFGtU948Qlm3FixYcNPlb7/9NodprEOjR4/G+vXrceHCBfz73/++5rpKTdO8X6Di4+ORmpqqR5lEDY5HKilkjRo1Cm3atIEQAn/4wx+wd+9eAO4PhK1bt2LevHkAgD59+nDcbx/UvIZy+vTpDJQU8Lp27YrBgwcDAObOnYuvvvrKe93qxYsXMWvWLJw8eRIA8Oijj0KW+VFLoUESQgi9iyDSS25uLp588knvhfQWiwWapsHhcAAA2rVrh7///e+IjIzUs8yAdfHiRUyePBmAu0XsrYYMnDJlCk+L1wMeqax7FRUVeOaZZ3DgwAEA7uFGzWZzrX4sp06dikceeUSvEokaHE9/U0hLTEzE0qVLsXLlSmzbtg15eXkwGAxo3bo1hg0bhkmTJsFoNOpdZsC6uk+/wsLCm65fUVFR3yUR1Qmr1Yr//d//xfr167Fx40acOnUKNpsN8fHx6NKlC+69916kp6frXSZRg+KRSiIiIiLyGS/0ICIiIiKfMVQSERERkc8YKomIiIjIZwyVREREROQzhkoiIiIi8hlDJRERERH5jKGSiIiIiHzGUElEREREPmOoJCIiIiKfMVQSERERkc8YKomIiIjIZwyVREREROQzhkoiIiIi8hlDJRERERH5jKGSiIiIiHzGUElEREREPmOoJCIiIiKfMVQSERERkc8YKomIiIjIZ/8f3VPRWwubcFMAAAAASUVORK5CYII=", "text/plain": [ "
      " ] @@ -3069,11 +3063,12 @@ " lat.set_ticklabel(fontsize=4)\n", " lat.set_ticks_visible(True)\n", " lat.set_ticklabel_visible(True)\n", - " ax.set_title(n)" + " ax.set_title(n);" ] }, { "cell_type": "markdown", + "id": "7d2014b6", "metadata": {}, "source": [ "## Instantiate the COSI 3ML plugin and perform the likelihood fit\n", @@ -3082,7 +3077,8 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 39, + "id": "1c3caa29", "metadata": {}, "outputs": [], "source": [ @@ -3095,7 +3091,8 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 40, + "id": "91c210b6", "metadata": {}, "outputs": [], "source": [ @@ -3110,6 +3107,7 @@ }, { "cell_type": "markdown", + "id": "9899c7a4", "metadata": {}, "source": [ "We should re-run the following cell every time we set up a new fit:" @@ -3117,17 +3115,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 41, + "id": "3f24160f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "... loading the pre-computed image response ...\n", - "--> done\n", - "CPU times: user 1min 56s, sys: 37 s, total: 2min 33s\n", - "Wall time: 2min 51s\n" + "CPU times: user 1min 42s, sys: 32 s, total: 2min 14s\n", + "Wall time: 2min 15s\n" ] } ], @@ -3147,7 +3144,8 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 42, + "id": "a64a965f", "metadata": {}, "outputs": [ { @@ -3215,7 +3213,7 @@ " \n", " \n", " \n", - " disk.Wide_Asymm_Gaussian_on_sphere.e\n", + " disk.Asymm_Gaussian_on_sphere.e\n", " 0.999444\n", " 0.0\n", " 1.0\n", @@ -3256,28 +3254,28 @@ " \n", " \n", " \n", - " disk.Wide_Asymm_Gaussian_on_sphere.lon0\n", + " disk.Asymm_Gaussian_on_sphere.lon0\n", " 0.0\n", " 0.0\n", " 360.0\n", " deg\n", " \n", " \n", - " disk.Wide_Asymm_Gaussian_on_sphere.lat0\n", + " disk.Asymm_Gaussian_on_sphere.lat0\n", " 0.0\n", " -90.0\n", " 90.0\n", " deg\n", " \n", " \n", - " disk.Wide_Asymm_Gaussian_on_sphere.a\n", + " disk.Asymm_Gaussian_on_sphere.a\n", " 90.0\n", " 0.0\n", " 90.0\n", " deg\n", " \n", " \n", - " disk.Wide_Asymm_Gaussian_on_sphere.theta\n", + " disk.Asymm_Gaussian_on_sphere.theta\n", " 0.0\n", " -90.0\n", " 90.0\n", @@ -3301,7 +3299,7 @@ " disk.spectrum.main.composite.K_2\n", " 0.0045\n", " 0.0\n", - " 1000.0\n", + " 1000000.0\n", " keV-1 s-1 cm-2\n", " \n", " \n", @@ -3350,7 +3348,7 @@ " broadBulge.spectrum.main.composite.K_2\n", " 0.0027\n", " 0.0\n", - " 1000.0\n", + " 1000000.0\n", " keV-1 s-1 cm-2\n", " \n", " \n", @@ -3399,7 +3397,7 @@ " narrowBulge.spectrum.main.composite.K_2\n", " 0.0011\n", " 0.0\n", - " 1000.0\n", + " 1000000.0\n", " keV-1 s-1 cm-2\n", " \n", " \n", @@ -3441,7 +3439,7 @@ " centralPoint.spectrum.main.composite.K_2\n", " 0.00046\n", " 0.0\n", - " 1000.0\n", + " 1000000.0\n", " keV-1 s-1 cm-2\n", " \n", " \n", @@ -3472,22 +3470,22 @@ " \n", " disk.spectrum.main.composite.dat_2\n", " OPsSpectrum.dat\n", - " None\n", + " NaN\n", " \n", " \n", " broadBulge.spectrum.main.composite.dat_2\n", " OPsSpectrum.dat\n", - " None\n", + " NaN\n", " \n", " \n", " narrowBulge.spectrum.main.composite.dat_2\n", " OPsSpectrum.dat\n", - " None\n", + " NaN\n", " \n", " \n", " centralPoint.spectrum.main.composite.dat_2\n", " OPsSpectrum.dat\n", - " None\n", + " NaN\n", " \n", " \n", "\n", @@ -3505,47 +3503,47 @@ "Free parameters (2):\n", "--------------------\n", "\n", - " value min_value max_value unit\n", - "disk.Wide_Asymm_Gaussian_on_sphere.e 0.999444 0.0 1.0 \n", - "disk.spectrum.main.composite.F_1 0.0017 0.0 1.0 s-1 cm-2\n", + " value min_value max_value unit\n", + "disk.Asymm_Gaussian_on_sphere.e 0.999444 0.0 1.0 \n", + "disk.spectrum.main.composite.F_1 0.0017 0.0 1.0 s-1 cm-2\n", "\n", "Fixed parameters (27):\n", "---------------------\n", "\n", - " value min_value max_value \\\n", - "disk.Wide_Asymm_Gaussian_on_sphere.lon0 0.0 0.0 360.0 \n", - "disk.Wide_Asymm_Gaussian_on_sphere.lat0 0.0 -90.0 90.0 \n", - "disk.Wide_Asymm_Gaussian_on_sphere.a 90.0 0.0 90.0 \n", - "disk.Wide_Asymm_Gaussian_on_sphere.theta 0.0 -90.0 90.0 \n", - "disk.spectrum.main.composite.mu_1 511.0 None None \n", - "disk.spectrum.main.composite.sigma_1 1.27 0.0 None \n", - "disk.spectrum.main.composite.K_2 0.0045 0.0 1000.0 \n", - "broadBulge.Gaussian_on_sphere.lon0 0.0 0.0 360.0 \n", - "broadBulge.Gaussian_on_sphere.lat0 0.0 -90.0 90.0 \n", - "broadBulge.Gaussian_on_sphere.sigma 8.7 0.0 20.0 \n", - "broadBulge.spectrum.main.composite.F_1 0.00073 0.0 1.0 \n", - "broadBulge.spectrum.main.composite.mu_1 511.0 None None \n", - "broadBulge...sigma_1 0.85 0.0 None \n", - "broadBulge.spectrum.main.composite.K_2 0.0027 0.0 1000.0 \n", - "narrowBulge.Gaussian_on_sphere.lon0 359.75 0.0 360.0 \n", - "narrowBulge.Gaussian_on_sphere.lat0 -1.25 -90.0 90.0 \n", - "narrowBulge.Gaussian_on_sphere.sigma 2.5 0.0 20.0 \n", - "narrowBulge.spectrum.main.composite.F_1 0.00028 0.0 1.0 \n", - "narrowBulge.spectrum.main.composite.mu_1 511.0 None None \n", - "narrowBulge...sigma_1 0.85 0.0 None \n", - "narrowBulge.spectrum.main.composite.K_2 0.0011 0.0 1000.0 \n", - "centralPoint.position.ra 266.404988 0.0 360.0 \n", - "centralPoint.position.dec -28.936178 -90.0 90.0 \n", - "centralPoint.spectrum.main.composite.F_1 0.00012 0.0 1.0 \n", - "centralPoint...mu_1 511.0 None None \n", - "centralPoint...sigma_1 0.85 0.0 None \n", - "centralPoint.spectrum.main.composite.K_2 0.00046 0.0 1000.0 \n", + " value min_value max_value \\\n", + "disk.Asymm_Gaussian_on_sphere.lon0 0.0 0.0 360.0 \n", + "disk.Asymm_Gaussian_on_sphere.lat0 0.0 -90.0 90.0 \n", + "disk.Asymm_Gaussian_on_sphere.a 90.0 0.0 90.0 \n", + "disk.Asymm_Gaussian_on_sphere.theta 0.0 -90.0 90.0 \n", + "disk.spectrum.main.composite.mu_1 511.0 None None \n", + "disk.spectrum.main.composite.sigma_1 1.27 0.0 None \n", + "disk.spectrum.main.composite.K_2 0.0045 0.0 1000000.0 \n", + "broadBulge.Gaussian_on_sphere.lon0 0.0 0.0 360.0 \n", + "broadBulge.Gaussian_on_sphere.lat0 0.0 -90.0 90.0 \n", + "broadBulge.Gaussian_on_sphere.sigma 8.7 0.0 20.0 \n", + "broadBulge.spectrum.main.composite.F_1 0.00073 0.0 1.0 \n", + "broadBulge.spectrum.main.composite.mu_1 511.0 None None \n", + "broadBulge...sigma_1 0.85 0.0 None \n", + "broadBulge.spectrum.main.composite.K_2 0.0027 0.0 1000000.0 \n", + "narrowBulge.Gaussian_on_sphere.lon0 359.75 0.0 360.0 \n", + "narrowBulge.Gaussian_on_sphere.lat0 -1.25 -90.0 90.0 \n", + "narrowBulge.Gaussian_on_sphere.sigma 2.5 0.0 20.0 \n", + "narrowBulge.spectrum.main.composite.F_1 0.00028 0.0 1.0 \n", + "narrowBulge.spectrum.main.composite.mu_1 511.0 None None \n", + "narrowBulge...sigma_1 0.85 0.0 None \n", + "narrowBulge.spectrum.main.composite.K_2 0.0011 0.0 1000000.0 \n", + "centralPoint.position.ra 266.404988 0.0 360.0 \n", + "centralPoint.position.dec -28.936178 -90.0 90.0 \n", + "centralPoint.spectrum.main.composite.F_1 0.00012 0.0 1.0 \n", + "centralPoint...mu_1 511.0 None None \n", + "centralPoint...sigma_1 0.85 0.0 None \n", + "centralPoint.spectrum.main.composite.K_2 0.00046 0.0 1000000.0 \n", "\n", " unit \n", - "disk.Wide_Asymm_Gaussian_on_sphere.lon0 deg \n", - "disk.Wide_Asymm_Gaussian_on_sphere.lat0 deg \n", - "disk.Wide_Asymm_Gaussian_on_sphere.a deg \n", - "disk.Wide_Asymm_Gaussian_on_sphere.theta deg \n", + "disk.Asymm_Gaussian_on_sphere.lon0 deg \n", + "disk.Asymm_Gaussian_on_sphere.lat0 deg \n", + "disk.Asymm_Gaussian_on_sphere.a deg \n", + "disk.Asymm_Gaussian_on_sphere.theta deg \n", "disk.spectrum.main.composite.mu_1 keV \n", "disk.spectrum.main.composite.sigma_1 keV \n", "disk.spectrum.main.composite.K_2 keV-1 s-1 cm-2 \n", @@ -3574,10 +3572,10 @@ "--------------------\n", "\n", " value allowed values\n", - "disk.spectrum.main.composite.dat_2 OPsSpectrum.dat None\n", - "broadBulge.spectrum.main.composite.dat_2 OPsSpectrum.dat None\n", - "narrowBulge...dat_2 OPsSpectrum.dat None\n", - "centralPoint...dat_2 OPsSpectrum.dat None\n", + "disk.spectrum.main.composite.dat_2 OPsSpectrum.dat NaN\n", + "broadBulge.spectrum.main.composite.dat_2 OPsSpectrum.dat NaN\n", + "narrowBulge...dat_2 OPsSpectrum.dat NaN\n", + "centralPoint...dat_2 OPsSpectrum.dat NaN\n", "\n", "Linked parameters (0):\n", "----------------------\n", @@ -3607,6 +3605,7 @@ }, { "cell_type": "markdown", + "id": "05d1a3e3", "metadata": {}, "source": [ "Before we perform the fit, let's first change the 3ML console logging level, in order to mimimize the amount of console output." @@ -3614,18 +3613,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "# This is a simple workaround for now to prevent a lot of output. \n", - "from threeML import update_logging_level\n", - "update_logging_level(\"CRITICAL\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, + "execution_count": 43, + "id": "77794760", "metadata": { "scrolled": true }, @@ -3637,282 +3626,25 @@ "Adding 1e-12 to each bin of the expectation to avoid log-likelihood = -inf.\n" ] }, - { - "data": { - "text/html": [ - "
      Best fit values:\n",
      -       "\n",
      -       "
      \n" - ], - "text/plain": [ - "\u001b[1;4;38;5;49mBest fit values:\u001b[0m\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
      resultunit
      parameter
      disk.Wide_Asymm_Gaussian_on_sphere.e(9.9985 +/- 0.0005) x 10^-1
      disk.spectrum.main.composite.F_1(1.643 +/- 0.011) x 10^-31 / (cm2 s)
      background_cosi(9.906 +/- 0.032) x 10^-1
      \n", - "
      " - ], - "text/plain": [ - " result unit\n", - "parameter \n", - "disk.Wide_Asymm_Gaussian_on_sphere.e (9.9985 +/- 0.0005) x 10^-1 \n", - "disk.spectrum.main.composite.F_1 (1.643 +/- 0.011) x 10^-3 1 / (cm2 s)\n", - "background_cosi (9.906 +/- 0.032) x 10^-1 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n",
      -       "Correlation matrix:\n",
      -       "\n",
      -       "
      \n" - ], - "text/plain": [ - "\n", - "\u001b[1;4;38;5;49mCorrelation matrix:\u001b[0m\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n", - "\n", - "\n", - "\n", - "
      1.00-0.330.09
      -0.331.00-0.60
      0.09-0.601.00
      " - ], - "text/plain": [ - " 1.00 -0.33 0.09\n", - "-0.33 1.00 -0.60\n", - " 0.09 -0.60 1.00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n",
      -       "Values of -log(likelihood) at the minimum:\n",
      -       "\n",
      -       "
      \n" - ], - "text/plain": [ - "\n", - "\u001b[1;4;38;5;49mValues of -\u001b[0m\u001b[1;4;38;5;49mlog\u001b[0m\u001b[1;4;38;5;49m(\u001b[0m\u001b[1;4;38;5;49mlikelihood\u001b[0m\u001b[1;4;38;5;49m)\u001b[0m\u001b[1;4;38;5;49m at the minimum:\u001b[0m\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
      -log(likelihood)
      cosi-166772.754018
      total-166772.754018
      \n", - "
      " - ], - "text/plain": [ - " -log(likelihood)\n", - "cosi -166772.754018\n", - "total -166772.754018" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n",
      -       "Values of statistical measures:\n",
      -       "\n",
      -       "
      \n" - ], - "text/plain": [ - "\n", - "\u001b[1;4;38;5;49mValues of statistical measures:\u001b[0m\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
      \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
      statistical measures
      AIC-333547.508036
      BIC-333545.508036
      \n", - "
      " - ], - "text/plain": [ - " statistical measures\n", - "AIC -333547.508036\n", - "BIC -333545.508036" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 30min 29s, sys: 15min 41s, total: 46min 11s\n", - "Wall time: 8min 12s\n" + "CPU times: user 3min 46s, sys: 1.03 s, total: 3min 47s\n", + "Wall time: 34.8 s\n" ] - }, - { - "data": { - "text/plain": [ - "( value negative_error \\\n", - " disk.Wide_Asymm_Gaussian_on_sphere.e 0.999853 -0.000045 \n", - " disk.spectrum.main.composite.F_1 0.001643 -0.000011 \n", - " background_cosi 0.990610 -0.003091 \n", - " \n", - " positive_error error unit \n", - " disk.Wide_Asymm_Gaussian_on_sphere.e 0.000045 0.000045 \n", - " disk.spectrum.main.composite.F_1 0.000011 0.000011 1 / (cm2 s) \n", - " background_cosi 0.003209 0.003150 ,\n", - " -log(likelihood)\n", - " cosi -166772.754018\n", - " total -166772.754018)" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "%%time \n", + "%%time\n", "# likelihood of data + model\n", - "like = JointLikelihood(totalModel, plugins, verbose = True)\n", - "like.fit()" + "like = JointLikelihood(totalModel, plugins, verbose = False)\n", + "like.fit(quiet=True);" ] }, { "cell_type": "markdown", + "id": "e56bc7e3", "metadata": {}, "source": [ "## Results" @@ -3920,7 +3652,8 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 44, + "id": "9cd0b813", "metadata": { "scrolled": true }, @@ -3972,18 +3705,18 @@ " \n", " \n", " \n", - " disk.Wide_Asymm_Gaussian_on_sphere.e\n", + " disk.Asymm_Gaussian_on_sphere.e\n", " (9.9985 +/- 0.0005) x 10^-1\n", " \n", " \n", " \n", " disk.spectrum.main.composite.F_1\n", - " (1.643 +/- 0.011) x 10^-3\n", - " 1 / (cm2 s)\n", + " (1.645 +/- 0.011) x 10^-3\n", + " 1 / (s cm2)\n", " \n", " \n", " background_cosi\n", - " (9.906 +/- 0.032) x 10^-1\n", + " (9.908 +/- 0.032) x 10^-1\n", " \n", " \n", " \n", @@ -3991,11 +3724,11 @@ "" ], "text/plain": [ - " result unit\n", - "parameter \n", - "disk.Wide_Asymm_Gaussian_on_sphere.e (9.9985 +/- 0.0005) x 10^-1 \n", - "disk.spectrum.main.composite.F_1 (1.643 +/- 0.011) x 10^-3 1 / (cm2 s)\n", - "background_cosi (9.906 +/- 0.032) x 10^-1 " + " result unit\n", + "parameter \n", + "disk.Asymm_Gaussian_on_sphere.e (9.9985 +/- 0.0005) x 10^-1 \n", + "disk.spectrum.main.composite.F_1 (1.645 +/- 0.011) x 10^-3 1 / (s cm2)\n", + "background_cosi (9.908 +/- 0.032) x 10^-1 " ] }, "metadata": {}, @@ -4021,15 +3754,15 @@ { "data": { "text/html": [ - "
      \n", - "\n", - "\n", + "
      1.00-0.330.09
      -0.331.00-0.60
      \n", + "\n", + "\n", "\n", "
      1.00-0.320.09
      -0.321.00-0.60
      0.09-0.601.00
      " ], "text/plain": [ - " 1.00 -0.33 0.09\n", - "-0.33 1.00 -0.60\n", + " 1.00 -0.32 0.09\n", + "-0.32 1.00 -0.60\n", " 0.09 -0.60 1.00" ] }, @@ -4080,11 +3813,11 @@ " \n", " \n", " cosi\n", - " -166772.754018\n", + " -166795.926926\n", " \n", " \n", " total\n", - " -166772.754018\n", + " -166795.926926\n", " \n", " \n", "\n", @@ -4092,8 +3825,8 @@ ], "text/plain": [ " -log(likelihood)\n", - "cosi -166772.754018\n", - "total -166772.754018" + "cosi -166795.926926\n", + "total -166795.926926" ] }, "metadata": {}, @@ -4143,11 +3876,11 @@ " \n", " \n", " AIC\n", - " -333547.508036\n", + " -333593.853852\n", " \n", " \n", " BIC\n", - " -333545.508036\n", + " -333591.853852\n", " \n", " \n", "\n", @@ -4155,8 +3888,8 @@ ], "text/plain": [ " statistical measures\n", - "AIC -333547.508036\n", - "BIC -333545.508036" + "AIC -333593.853852\n", + "BIC -333591.853852" ] }, "metadata": {}, @@ -4171,12 +3904,13 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 45, + "id": "2268995d", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmgAAAHOCAYAAAAsQvUnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAADDh0lEQVR4nOzdd3hUVfrA8e+k9x5ISCGEXk0AKdIFUUFBBF0VFaWIFRHBymJnscHi7gosICA/21oAUZoUFZCqRqWEGhIChPReZ+b+/pjMZYYUksxNfz/Pw+Nk5t5zTsYQ3jnnvO/RKYqiIIQQQgghGgy7+h6AEEIIIYSwJgGaEEIIIUQDIwGaEEIIIUQDIwGaEEIIIUQDIwGaEEIIIUQDIwGaEEIIIUQDIwGaEEIIIUQDIwGaEEIIIUQDIwGaEEIIIUQDIwGaEEKUIycnh2eeeYY2bdrg6OiITqcjJiaGH3/8EZ1Ox6uvvlrfQ2xSIiIiiIiIsLkdnU7H0KFDbW5HiPomAZoQQjM6na7MH2dnZyIiIpg0aRLHjx+v0/E89NBD6HQ6zp07V+17n3/+ef75z3/SrVs3XnjhBV555RWCgoIqvH7o0KHodLpq9/Pqq6+i0+n48ccfq32vEKLpcqjvAQghmp5XXnlFfZyVlcXBgwf5+OOP+frrr9mzZw9RUVH1N7gq+vbbb+nQoQMbN260et7Ly4vjx48TEBBQTyMTQjQHEqAJITRX3vLfU089xb///W/++c9/snr16jofU3VdvHiRwYMHl3nezc2NTp061cOIhBDNiSxxCiHqxMiRIwFISUkp9/XPPvuMYcOG4evri4uLC507d+bNN9+kqKiozLU//vgjt912G6GhoTg5OREYGMj1119vFRjqdDrWrFkDQJs2bdQl12vtczIvVSqKwk8//aTeZ97XdPUetHPnzqHT6fjpp5/Ufq++pyIRERG89tprAAwbNszqXksXL17k8ccfJyIiQv1+x40bx6FDhypt/2rmMV2+fJnJkyfTsmVL3N3dueGGG9i9ezcAubm5zJo1i/DwcJydnenatStfffVVue0VFhbyj3/8g+7du+Pm5oaXlxeDBg3i888/L/d6RVH497//TdeuXXFxcSEkJIQnnniCrKysSsddnZ8NIZoKmUETQtSJ7du3A9CnT58yr02ZMoWPPvqIsLAwxo8fj7e3N/v37+fvf/87O3bsYNu2bTg6OgKwadMmbrvtNry9vRkzZgwhISGkp6dz/PhxlixZogZOr7zyCuvXr+ePP/7g6aefxsfHB0D9b0Ueeughhg4dymuvvUbr1q156KGHACoM7Hx8fHjllVdYvXo18fHxVsu71woGZ86cyfr16/npp5+YNGlSudefPXuWgQMHcunSJYYPH869997L+fPn+fLLL/n+++/58ssvGTt2bKX9WMrMzGTAgAF4enpy7733kp6ezueff87NN9/ML7/8wrRp08jKyuL222+npKSEzz//nLvvvptffvmFfv36qe0UFxczcuRIdu/eTZcuXXjiiSfIz8/nyy+/5N577+X333/n7bffLvP9fvDBBwQHB/PII4/g6OjIhg0bOHjwIMXFxTg5OZUZb3V+NoRoUhQhhNAIoADKK6+8ov555plnlIEDByo6nU4ZO3askpOTY3XPqlWrFECZMGGCUlBQYPXaK6+8ogDKokWL1OfGjRunAMrvv/9epv+UlBSrrydNmqQASlxcXI2+lyFDhpR5fteuXer3aGnIkCFKTX6lmr/HXbt2lfv6TTfdpADKggULrJ7fvXu3Ymdnp/j6+irZ2dlV6sv8/2f69OmKwWBQn//4448VQPH29lZuu+02q/8Pe/fuVQDljjvusGrrrbfeUgDltttuU0pKStTnk5KSlLCwMAVQdu/eXaadtm3bKmlpaerzBQUFSr9+/RRAad26tVUf1f3ZMH+P5f1/E6KxkQBNCKEZcwBQ3p8uXbooa9euLXNPVFSU4ujoqGRkZJR5Ta/XK/7+/krv3r3V5+68804FUE6cOHHN8TT2AO38+fNq4GIZBJndd999CqCsWbOmSn0BipubW5mATq/XKw4ODgqgnDlzpsx9bdq0USIiIqyea9u2raLT6cr9//Df//5XAZSHH35YfW7q1KkKoHz00Udlrje/p1cHaNX92TB/jxKgiaZAljiFEJpTFEV9nJeXx9GjR3nhhRd44IEHOH78OG+99RYA+fn5/PHHHwQEBPDPf/6z3LacnZ2JjY1Vv544cSLffPMNffv25Z577mHYsGHccMMNhIaG1ur3VB9+//13AAYNGoSDQ9lf1yNGjODTTz/lt99+48EHH6xSmx06dMDT09PqOXt7e1q2bEleXh6RkZFl7mnVqhUHDhxQv87JyeHMmTOEhobSoUOHcscF8Ntvv6nPmR8PGTKkzPXlfX81+dkQoimRAE0IUavc3d3p06cP33zzDaGhobzzzjs8+uijhIWFkZGRgaIopKSkqJvlr+XOO+/ku+++4/3332flypUsXboUgN69e7NgwQKGDx9em99OnTJvnq+o/lpwcLDVdVXh7e1d7vMODg6VvqbX620al/lxy5Yty1xvb2+Pv7+/1XM1+dkQoimRLE4hRJ3w8fGhY8eO6PV6dTbFHBBER0ejmLZcVPjH0ujRo9m5cycZGRns2LGDZ555hiNHjjB69Og6L4Zbm8zvT1JSUrmvX7p0yeq6ulKTcZkfX758ucz1BoOBtLS0cvuo7s+GEE2FBGhCiDqTkZEBgNFoBMDDw4OuXbty9OhR0tPTq92eu7s7N954IwsXLuSll16iqKiIzZs3q6/b29sDpgCgttW0r8rui46OBmDPnj1WM1hmu3btAqBnz57V6tNWnp6etG3blgsXLnDq1Kkqjcv82FyOxNLu3bvLfH+2/mwI0dhJgCaEqBPr168nLi4OR0dHbrjhBvX5WbNmUVxczOTJk8nMzCxzX0ZGhtVeph07dlBQUFDmOvPMjIuLi/qcedns/PnzWn0bFappX5XdFxoayk033cS5c+fK7MM6cOAAn376Kb6+vowbN65mg7bB5MmTURSFOXPmWAWXqampvPHGG+o1ZuZyJW+99ZZVwFVYWMiLL75Ybh/V/dkQoimRPWhCCM1ZFozNy8vj2LFj6szW/PnzrfYhTZ48mV9//ZUPP/yQtm3bcvPNNxMeHk56ejpxcXH8/PPPPPzww+pes2effZZz584xdOhQtXDrr7/+ys6dOwkPD+eee+5R2x4+fDjvvvsu06ZNY/z48Xh4eODj48OTTz6p+fc8fPhwvvzyS+68805uvfVWXF1dad26NQ888ECl9w0bNgw7OztefPFF/vrrL3x9fQGYO3cuAEuXLmXAgAHMmTOHbdu20bt3b7UOmp2dHatWrSqz6b8uzJ49m82bN7Nhwwauu+46Ro0apdZBS05O5rnnnmPgwIHq9QMGDOCpp57iX//6F926dWPChAlqHTRfX19135ql6v5sCNGk1G3SqBCiKaOc8hr29vZKUFCQMmbMGGXbtm0V3rtx40Zl9OjRSmBgoOLo6Ki0bNlSuf7665WXX35ZOX78uHrdF198odxzzz1Ku3btFHd3d8XT01Pp2rWr8tJLLynJycll2n3//feVTp06KU5OTuWWcqjse6lOmQ29Xq+8+OKLSps2bdSSFVUt97B27VrluuuuU1xcXNT3zVJiYqLy6KOPKuHh4Yqjo6Pi7++vjB07Vjl48GCV2r/W96QoitK6desK35uKSogUFBQob731ltK1a1fFxcVF8fDwUAYMGKB8+umn5bZjNBqVf/3rX+r/j+DgYOXxxx9XMjMzK+2/qj8b1/oehWhMdIoiOyyFEEIIIRoS2YMmhBBCCNHASIAmhBBCCNHASIAmhBBCCNHASIAmhBBCCNHASIAmhBBCCNHASIAmhBBCCNHASIDWCBUWFnLixAkKCwvreyhCCCGEqAUSoDVC8fHxTJs2jfj4+PoeihBCCCFqgQRoQgghhBANjARoQgghhBANjARoQgghhBANjARoQgghhBANjEN9D0AIIYSoCwaDgZKSkvoehmgGHB0dsbe3t6kNCdCEEEI0ebm5uSQmJqIoSn0PRTQDOp2O0NBQPDw8atyGBGhCCCGaNIPBQGJiIm5ubgQGBqLT6ep7SKIJUxSFlJQUEhMTad++fY1n0iRAE0II0aSVlJSgKAqBgYG4urrW93BEMxAYGMi5c+coKSmpcYAmSQJCCCGaBZk5E3VFi581CdCEEEKIehAREUGnTp2Iioqic+fO3HfffeTl5dW4vdWrV3Py5MkKX9+/fz/du3cnOjqarVu3MmrUKM6cOVOle2vTuXPn+O9//1vj+1999VVmz54NwI8//oibmxtRUVH06NGDgQMH8ueff1Z6/+HDh5k4cWKV+youLq7xWKtDAjQhhBCinnz11VfExMRw7NgxsrOzWb16dY3bulaQtWbNGh588EF+//13br75ZjZt2kTbtm2rdG9tulaAptfrq9Vely5diImJ4c8//+Suu+7i4YcfrvT63r1788knn1Sp7ddee00CNCGEEKK5KCoqIi8vD19fX/W59957jz59+tCzZ09GjRrF+fPnAdi4cSM9evQgKiqKbt26sWHDBlasWMHhw4eZMWMGUVFRbNq0yar9BQsW8MUXX7B48WKioqLIzMwkIiKCI0eOXPPe8rz99tt0796d6667jn79+pGfnw/A2rVr6du3Lz179mTIkCEcOXIEMAWAN998M/feey/du3end+/enD17FoBHH32UY8eOERUVxZgxYwDT7OJbb73FsGHDmDRpEklJSQwbNoxevXrRtWtXZsyYUaWM3JtuuokTJ04AsGXLFnr27EmPHj0YMmQIx44dA0yzbr179wZMwWJAQADz5s2jV69etGvXTn0/Hn30UQBuuOEGoqKiSE5Ovmb/tpAkASGEEM3O+pf3kp9VVGvtu3k7c8dbA6553YQJE3BxcSEuLo5evXpx9913A/Dpp59y8uRJ9u3bh729PWvXruXJJ59kw4YNzJ07l6VLl3LDDTdgNBrJzs7Gx8eH//u//2P27NncdtttZfp54YUXiI2NpXfv3jz55JNWr02dOrXSe6+2Zs0a1q9fz969e/Hy8iIjIwNnZ2f27t3L559/zs8//4yzszO7d+9m4sSJ/PHHHwAcOHCAP/74g9atW/PCCy/w9ttvs2zZMpYuXcrs2bM5fPiwVT8JCQns3LkTnU5HYWEhGzduxMPDA4PBwNixY/n666+ZMGFCpWP9/PPP6dWrF8nJydx///3s2rWL7t2788knn3D33XerAaSltLQ0evXqxeuvv86WLVt4+umnGTVqFEuXLmXZsmX88ssvNpXPqCoJ0IQQQjQ7+VlF5KfXXoBWVV999RXdunVDr9czffp0nn/+ed5//33Wr1/P4cOH6dWrF2AqFWLOBhw+fDgzZ85kwoQJjBw5kqioqDod83fffcdjjz2Gl5cXgDrrt2HDBv744w/69u2rXpuSkqIuCQ4cOJDWrVsD0L9/f/71r39V2s/DDz+sbrY3Go08//zz7NmzB0VRSE5OJioqqtwAzTwbB9ChQwfWrFnDgQMHiIqKonv37gBMnDiRJ554gkuXLpW5393dnbFjx6rjNO/Tq2sSoAkhhGh23LydG1T7Dg4OjB8/njlz5vD++++jKApz585l8uTJZa5duHAhR48eZdeuXUyaNImJEyfy3HPPaTX0GlMUhcmTJ/P666+X+7qLi4v62N7e/pp7yyxnqRYuXEhaWhoHDhzAxcWFWbNmUVhYWO59Xbp0KTMb9+eff5abWVnec1eP02AwVDrO2iIBmhBCNFH5BQUcOXWK/IJCPNzd8ffxpnWrVtjZyfbjqiw/1rWdO3fSsWNHAMaMGcPixYu544478PPzo6SkhCNHjhAdHU1sbCxdu3ala9euODg4sG3bNgC8vLzIysqqUd9X33vhwgWGDx9ObGxsmWvHjBnDhx9+yB133IGXlxeZmZl4enpy++238+CDDzJt2jTCwsIwGo389ttv6v6uqvZdnoyMDIKCgnBxceHy5ct8+eWX/O1vf6vy99e/f3+mTJnC8ePH6dy5M59//jmhoaEEBQWV+z1WxNPTk6ysLFniFEIIUTOpGRls+ulncks3b5t5eXjQs0tnOkVGSqDWAJj3oJWUlBAREcHSpUsBeOCBB0hLS2Po0KHodDr0ej1TpkwhOjqaF198kZMnT+Lk5ISbmxtLliwB4JFHHuHZZ5/l3XffZf78+YwaNarK47j63sDAQBwcyg8RHnjgAS5evEj//v1xdHTEzc2N7du3M3jwYObPn8/YsWPVc09Hjx59zQCtR48edOzYkW7duhEZGcm3335b5poZM2Zw1113ERUVRUhICCNGjKjy9wamwrFr165l4sSJGAwGfHx8+N///letNgCeffZZbrzxRlxdXdm2bRstWrSodhtVpVPkYLJG58SJE0ybNo3ly5ern7aEEMIsMSmJzT/vpqSSJaROkW24sV+/OhxV/SksLCQuLo42bdpYLV+Jii1cuJAWLVpw//331/dQGiUtfuZkBk0IIZqQ4pIStv+yTw3OWvj7MyA6mryCAo6dOUNiUhIAsWfjCA9uRbvW4fU5XNFAzZo1q76H0OxJgCaEEE3I78eOk1+6eTo0qCWjBg9Wl6ratQ4n9uxZdu4/AMBPhw4RHBiAu5tbvY1XCFE+2YAghBBNRE5eHjGlG57t7OwYcv31ZfYRdWzThrbhplmzouJidh08VOfjFEJcmwRoQgjRROyP+UMtCdC9Q3u8PT3LXKPT6RhyfW/cXF0BSLh4kZT09DodpxDi2hrdEmd+fj4rVqxg165d5OTkEB4ezsSJExk+fPg1783IyGDJkiXs27ePwsJC2rVrx9SpU9VCgJYOHz7MypUrOX36NC4uLvTv35/HHnvM6hgOMJ0RtnbtWjZv3kxaWhrBwcGMGzeO8ePHW1330UcflXvGmpOTE9u3b6/emyCEEFfJzs3lVHw8AC7OTvTu1q3Ca12cnendrSs/HzLVijpy6hTDLIqLCiHqX6ML0ObOnUtsbCzTp08nLCyM7du389prr2E0GrnpppsqvK+4uJiZM2eSm5vLU089ha+vL+vWrWP27NksWrTIqhJzTEwMc+bMoX///syfP5+MjAyWLVvGzJkzWb58OU5OTuq1CxcuZNu2bUyZMoVOnTpx8OBBPvjgA/Lz83nggQfKjOO9997D3d1d/bq8InlCCFFdJ+LOqY97dOyIs8XvqfJ0jIhgf8wfFJeUcPJcPP2jonBxrt3irUKIqmtUAdq+ffs4fPgw8+bNU2ug9OzZk6SkJJYsWcKNN96oHoVxte+//564uDg+/PBDupV+soyOjmby5MksWbKEZcuWqdd++OGHhIWF8frrr6v7N4KDg3niiSfYtGkTd9xxBwBxcXF8//33TJs2jXvvvVdtMzs7m48//pixY8eqR2GYdejQAR8fHy3fFiFEM6coCidKD54G0z6za3F0dKRTZBv+PHESg8HA8bNnie7cuTaHKYSohka1B2337t24uroydOhQq+dHjRpFamqqejJ9RfeGh4erwRmYjtYYOXIkx48fJyUlBTCdGxYbG8vIkSOtNtd2796dsLAwfv75Z6s2FUXh1ltvterr1ltvpaioiAMHDtjy7QohRJVcTE4hOy8PgNCgIDwtZukr0619e/Xx0ZOnMBqNtTI+Ub6IiAg6depEVFQUnTt35r777iOv9P9jTaxevZqTJ09W+Pr+/fvp3r070dHRbN26lVGjRqnnTF7r3sZi6NChREZGEhUVRbdu3Rg1ahSXL1++5n3nzp0jICCgDkZYdY0qQIuLi6N169ZlspLatm2rvl6Rs2fPqtdVdq/5vxVda9lHXFwcPj4++Pv7V3k8Dz30EEOHDmXs2LG89dZbVfrBEUKIypyIuzJ71jny2rNnZj5eXoQFBwGQnZfHxeRkzccmKvfVV18RExPDsWPHyM7OLnevclVdK8has2YNDz74IL///js333wzmzZtUv+9qusAzWg0lvlAcK2zOavqgw8+ICYmhiNHjhAREcF7772nSbt1rVEFaFlZWWWWDMF0NhZAdnZ2hfdmZ2er11V2r/k8sIr6seyjovG4urri6OhodbZYSEgI06ZN44UXXmDhwoXcfffd7Nu3j+nTp6uzdxVJTU3lxIkT6p/40o3AQghRUlLC6YTzADg5OtImNLRa93eKjFQfxyVe0HRsouqKiorIy8uzSkR777336NOnDz179mTUqFGcP2/6/7xx40Z69OihzhJt2LCBFStWcPjwYWbMmEFUVBSbNm2yan/BggV88cUXLF68mKioKDIzM4mIiODIkSPXvPdqq1ev5uabb+bee++le/fu9O7dm7OlS+xJSUkMGzaMXr160bVrV2bMmIH5wKJXX32VBx54gDvvvJOoqCj27dtHQEAAr7/+OoMGDeJf//oXp0+fZsSIEer3t379egCWLVvG9OnTgSsHn//www8A/P3vf+eNN94oM069Xk9OTo76nv74449Wx06ZA7jyfP3113Tq1Ino6GjefPNNdDodubm5ABw6dIgbb7yR3r1707NnT77++utK36+aalR70MC2TfWV3Xv1axVdW53+La+9+eabrV7r2bMn0dHRPP7443z66ac8/fTTFbbz7bff2vSpSgjRdJ27cFGdeWhXzgrDtYQHB2NnZ4fRaCQuMZGBvXo2i+Sle48vJLUkp9baD3D05LPO167Gbz6LMy4ujl69enH33XcD8Omnn3Ly5En27duHvb09a9eu5cknn2TDhg3MnTuXpUuXcsMNN2A0GsnOzsbHx4f/+7//Y/bs2dx2221l+nnhhReIjY2ld+/ePPnkk1avTZ06tdJ7y3PgwAH++OMPWrduzQsvvMDbb7/NsmXL8PHxYePGjXh4eGAwGBg7dixff/01EyZMAGDXrl389ttvtGjRgnPnzpGWlka7du2YN28eAH379mXKlCk88sgjnDp1in79+tGrVy9uuukm3n77bQB27NhB//792bFjBzfddBPbt29n4cKF6thmzJjB3LlzuXDhAsHBwfz73/+u0vdklpyczCOPPML+/ftp3749//znP9XXMjMzmT59Ot9//z3BwcGkpqbSq1cvBgwYQFBQULX6uZZGFaB5e3uXe+J9To7pL1l5s1lmXl5e5c6wme81z6R5e3sDVNiP5Syct7c3p0+fLnNdQUEBJSUllY4HoEuXLoSGhla6dw5gzJgxDBgwQP06Pj6eN998s9J7hBDNQ8Kli+rjduFh1b7f2cmJVi1akJiURG5+PmmZmQRcVU6oKUotySG5pOzv+br21Vdf0a1bN/R6PdOnT+f555/n/fffZ/369Rw+fFgtA2UwGNQkuOHDhzNz5kwmTJjAyJEjraoQ1JWBAwfSunVrAPr378+//vUvwLR0+fzzz7Nnzx4URSE5OZmoqCg1QLvtttusDhh3cXFRk+xycnKIiYlhypQpALRv356BAweyZ88e9ZqzZ8+yfft2/vGPfzBnzhyys7M5efIk119/vdrmBx98wG233YaiKLz66qtMnjy5WrNc+/fvp2fPnrQv3aP58MMP88wzzwDwyy+/cPbsWau954qicOLEieYdoEVGRrJ9+3b0er3Vp0Tz1GqbSjKXIiMj1c2QlszPRZZO85vbOHv2LP3797e69uzZs1Z9REZGsmPHDtLS0qz2oVVlPJbs7CpfaQ4ICGhwmxeFEPVPURQSLl4CwNHBgeDAwBq10yY0RD2jMy7xQrMI0AIcy255qc/2HRwcGD9+PHPmzOH9999HURTmzp3L5MmTy1y7cOFCjh49yq5du5g0aRITJ07kueee02roVWJ5ALi9vb06i7tw4ULS0tI4cOAALi4uzJo1i8LSo8cAPDw8rNpxd3dXZ2zNS6EVrWgNHz6czZs3c/r0aYYMGYLRaOTrr79m4MCB5c4c63Q6/va3v6l70BwcHNRCzoDVuCwpilLhLLKiKPTo0cMqYbC2NKoAbdCgQWzcuJGffvrJqjDtli1bCAgIoEuXLhXeO3jwYBYuXMixY8fU6/R6PT/88ANdunRRA6DAwEA6d+7Mtm3buOeee9RPLEePHiUhIYG77rpLbXPgwIGsWLGCLVu2MHHiRPX5zZs34+zsTN9rFH48evQoiYmJZYraCiFEVSSnp1NQVASYsjcrKjN0LREhIew+/CsA5xITub57xUVum4qqLD/WtZ07d9KxY0fAtHKyePFi7rjjDvz8/CgpKeHIkSNER0cTGxtL165d6dq1Kw4ODmzbtg0wrRSVt/pTFVffe+HCBYYPH05s6dFhVZWRkUFQUBAuLi5cvnyZL7/8kr/97W9VHkNUVBRr1qzh4Ycf5syZM+zdu1ddohwxYgTPP/88gwcPBmDYsGG89tprPPvssxW2uWPHDvU9bdOmDXFxceqkytq1a8u9p1+/fkyePJnTp0/Trl071qxZo752ww03cOrUKXbu3MmNN94ImGqndunSxapGqhYaVYDWr18/evfuzcKFC8nPzyckJIQdO3Zw4MAB5s6dq/5yWrBgAVu3buWzzz5TpxxHjRrFunXrmDdvHtOnT1cL1SYkJLBo0SKrfh599FFmzZrFvHnzGDdunFqotk2bNlbTmm3atGH06NGsWrUKOzs7OnfuzKFDh9i4cSNTp061WuJ8+OGHGTlyJK1bt8bJyYnjx4/z2Wef4efnp07dCiFEdZhnzwDCWwXXuB1Pd3cCfH1JzcggJSOD3Px8POQA9Tph3oNWUlJCREQES5cuBeCBBx4gLS2NoUOHotPp0Ov1TJkyhejoaF588UVOnjyJk5MTbm5uLFmyBIBHHnmEZ599lnfffZf58+czatSoKo/j6nsDAwOrvZ8RTPu/7rrrLqKioggJCVFrllbVJ598wvTp0/nnP/+JTqdjxYoVhIWZlu6HDx9OQkKC2uZNN93Ee++9V6YP8x40o9GIr6+vGmCFhIQwe/ZsevfuTUREhBroXa1ly5YsXbqU0aNH4+/vz+23346joyNubm7Y2dmxceNG5syZwzPPPENJSQnh4eFqMoOWdIp5TrGRyM/PZ/ny5VZHPd1///1WM2rz589ny5YtfPHFFwQHX/mllZ6ebnXUU/v27ZkyZYpVVofZoUOH+Oijjzh16pR61NPjjz9e7lFPH3/8MZs3byY9PZ2goCDuvPPOMrNir732GrGxsaSnp1NSUkJAQAB9+/Zl0qRJ1V6+PHHiBNOmTWP58uXqJwMhRPPz9dZtXE5LA+CBsWOqXP+sPIf++otDfx0BYPD1va1qpDV2hYWFxMXF0aZNG6ulOVGxhQsX0qJFC+6///76Hkq9sNxzvmrVKlauXMmePXuqfL8WP3ONLkATEqAJIaCgsIhV33wDgJ+3N/eMrvpsSXmS09P5astWANqGhXHzoIE2j7GhkABNVNdbb73Fl19+iV6vx8/Pj2XLltG5GidtaPEz16iWOIUQQpicv3RlebN1q1Y2txfg44OToyPFJSVcTEmudKO0EE3dyy+/zMsvv1yvY2hUhWqFEEKYJF5OUh/bsv/MzM7OjqDSLNCCwiIys2uvRpgQ4tokQBNCiEboUrLpBBI7OztaalSGJ6TFlTIdcuyTEPVLAjQhhGhk8gsKyCo9dqalvz8ONSyvcbVgiwKiEqAJUb8kQBNCiEbmksX5vUGB2hWxDvTzU0srXExORnLIhKg/EqAJIUQjYxmgtQpsUcmV1WNvZ0dQ6XJpXkEB2aWzdKJ2RERE0KlTJ6KioujcuTP33XcfeXl5NW5v9erVnDx5ssLX9+/fT/fu3YmOjmbr1q2MGjVKPU3nWvde3Y/56Ka68uqrrzJ79my1fx8fH6KiooiKiuK6665jw4YNVWpn6NChfPfdd7U5VM1IgCaEEI2Mef8ZaDuDBtDKah9aSiVXCi189dVXxMTEcOzYMbKzs1m9enWN27pWkLVmzRoefPBBfv/9d26++WY2bdpE27Ztq3RvTVkeraSlESNGEBMTQ0xMDMuXL2fq1Km10k99kgBNCCEakeKSElIzMwHw9/HBWePjZVrJPrR6UVRURF5enlUx9Pfee48+ffrQs2dPRo0axfnz5wHYuHEjPXr0ICoqim7durFhwwZWrFjB4cOHmTFjBlFRUWzatMmq/QULFvDFF1+wePFioqKiyMzMJCIigiNHjlzz3vJkZWUxfvx4oqKiGDJkCAkJCYAp0Lvlllt48MEH6d27NwcPHmTLli307NmTHj16MGTIEI4dOwZAUlISw4YNo1evXnTt2pUZM2aoy+pZWVlMmDCBLl26cPPNN3P69OkKx5Kenm71vpm/L7PevXvz448/lrnPfJxV165due2227jtttvUY6VycnKYNm0affr0oUePHjz66KOUlJRc833RktRBE0KIRuRyaqr6j1hND0evTEt/f+zs7DAajVxOTdW8/YbiwRmvkJZRs3Mrq8Lf15uPP3jtmteZj3qKi4ujV69e3H333QB8+umnnDx5kn379mFvb8/atWt58skn2bBhA3PnzmXp0qXccMMNGI1GsrOz8fHx4f/+7/+YPXs2t912W5l+XnjhBWJjY+nduzdPPvmk1WtTp06t9N7y7Nmzh5iYGDp27Mg777zDo48+qgZ2e/bs4ffff6d9+/YkJyfTpUsXdu3aRffu3fnkk0+4++67OXLkCD4+PmzcuBEPDw8MBgNjx47l66+/ZsKECbz++ut4eXlx7NgxUlNT6dmzp/reAGzfvp2oqCjy8/O5cOECX3zxRZXGbWnGjBkMGzaMuXPnkpCQQLdu3bjlllsAePbZZxk8eDDLly9HURSmTZvGv//9b5555plq91NTEqAJIUQjYrn/LFjj5U0Ae3t7Anx9SU5LIzMnh6LiYs1n6RqCtIwsktMy6nsYfPXVV3Tr1g29Xs/06dN5/vnnef/991m/fj2HDx+mV69egGmp0Hze9PDhw5k5cyYTJkxg5MiRREVF1fm4Bw4cqJ5k88gjj/DKK6+oHxwGDhxI+9Kjwg4cOEBUVBTdu3cHYOLEiTzxxBNcunQJb29vnn/+efbs2YOiKCQnJxMVFcWECRPYtWsX//rXvwAICAjgzjvvtOp/xIgRfPXVVwAcOXKEESNG8Ntvv9GqGkWbd+3axQcffABAeHi41ZGR69evZ//+/bz//vsAFBQUaH4Y+rVIgCaEEI2IVYDWQrsEAUst/PxILj3jMyU9ndCgoFrppz75+3o3qPYdHBwYP348c+bM4f3330dRFObOncvkyZPLXLtw4UKOHj3Krl27mDRpEhMnTuS5557Taug28/DwUB9XdCKFTqdj4cKFpKWlceDAAVxcXJg1axaFhYXqfVXVrVs3wsPD2bt3L3fddRcODg5We9/MbZanotMyFEVh/fr1REZGVnkcWpMATQghGglFUUhOSwfAw80NDze3Wumnhb8fnDI9Tm6iAVpVlh/r2s6dO9VZqTFjxrB48WLuuOMO/Pz8KCkp4ciRI0RHRxMbG0vXrl3p2rUrDg4ObNu2DQAvLy+ysmq2bHv1veb9WbGxseVev3fvXk6ePEmHDh1YsWIFN954Y7nBTv/+/ZkyZQrHjx+nc+fOfP7554SGhhIUFERGRgZBQUG4uLhw+fJlvvzyS/72t78BplnCVatWMWDAANLT01m3bh133XVXuWNJTEzk1KlTdOjQAYC2bdty4MABrrvuOg4ePMiJEyfKvW/o0KGsXr2al156ifPnz7Nz5051Fm3MmDEsWLCADz/8EAcHBzIyMkhLS6Ndu3ZVf1NtJAGaEEI0EpnZOZTo9UBpEFVLWvj5q4/NAaGoHeY9aCUlJURERLB06VIAHnjgAdLS0hg6dCg6nQ69Xs+UKVOIjo7mxRdf5OTJkzg5OeHm5saSJUsA01Ljs88+y7vvvsv8+fMZNWpUlcdx9b2BgYFqTbzyDBkyhFdffZVjx47h7e3Nxx9/XO51gYGBrF27lokTJ2IwGPDx8eF///sfYNoDdtdddxEVFUVISAgjRoxQ7/v73//O5MmT6dKlC61bt+amm26yate8B01RFPR6PfPnz+e6664DTAedT5o0iZUrV9KzZ0+6du1a7tgWL17Mgw8+yBdffEGHDh0YMGAA3t6mmc9//vOfPP/880RFRWFnZ4ejoyNvv/12nQZoOkUqETY6J06cYNq0aSxfvlz9tCWEaPpOxMWxY99+APpe14NeFfzDYyuj0ciKr75Gr9fj4ebGg3eMrZV+6kphYSFxcXG0adMGFxeX+h5Oo7Bw4UJatGjB/fffX99DqTUFBQU4Ojri4ODApUuXuP7669mxY4cm/65q8TMnM2hCCNFIpKRfmc1q4Vd7M2h2dna08PPlYnIKufn55BcW4iaBTbMya9as+h5CrTt16hQPPvggiqJQUlLCK6+80qAmPSRAE0KIRiLZIkALrMUAzdS+v1qoNjktjYiQkFrtT4i61qNHD2JiYup7GBWSQrVCCNEIGI1GUtNNZSG8PDxwcXau1f4s97jJPjQh6p4EaEII0QhkZGejLy0dUNuzZwAt/C0SBdIlQBOirkmAJoQQjYDlLFZt7j8z83J3VwvUpqSlVasulRDCdhKgCSFEI2CVIFCLJTbMdDqdOlNXUFREfkFBrfcphLiiRkkCWlTWnTlzJjNmzLC5HSGEaA7qMkHALMDXh8SkJABSMzNxr6XCuEKIsmo0g3bu3DkyMjJQFKVGf+Lj48nMzNT4WxFCiKbJYDSSlmFKEPDx8sTJ0bFO+vX38VEfp8nvbM1FRETQqVMnoqKi6Ny5M/fddx95eXk1bm/16tWcPHmywtf3799P9+7diY6OZuvWrYwaNYozZ85U6d5r9TthwgQAvv32W+bMmVPp9a+++iqzZ8+uUV/NSY3LbDzzzDPMmzevRvfa2cnKqhBCVFVGVhYGoxGAQN+6mT2DqwK0jMw667c5MR+WrigKt99+O6tXr+aJJ56oUVurV68mICBAPfLoamvWrOHBBx9UA6ibb765yvdW1ZgxYxgzZoxNbQgTiZSEEKKBs5y98vf1qbN+fb281A/UMoNWu4qKisjLy8PX11d97r333qNPnz707NmTUaNGcf78eQA2btxIjx49iIqKolu3bmzYsIEVK1Zw+PBhZsyYQVRUFJs2bbJqf8GCBXzxxRcsXryYqKgoMjMziYiI4MiRI9e892rFxcVMnz6dDh06MGzYMA4cOKC+ZjmbdurUKQYMGMB1111H9+7dmTt3bpm2jh07Rvfu3dm8eXON37umqkYzaKdOncLPhj0Qtt4vhBDNiWVwFGAxq1Xb7O3t8fXyIi0zUy3z4WBvX2f916Yvt2yt1cQHN1dX7rrl5mteZz6LMy4ujl69enH33XcD8Omnn3Ly5En27duHvb09a9eu5cknn2TDhg3MnTuXpUuXcsMNN2A0GsnOzsbHx4f/+7//Y/bs2dx2221l+nnhhReIjY2ld+/ePPnkk1avTZ06tdJ7r7Zs2TLi4uI4evQoJSUlDB48mIiIiDLX/fvf/2b06NG89NJLAKRfVa5l586dPPXUU3zyySdERUVds9/mpkYBWtu2bW3q1Nb7hRCiOUm1WF70t5hhqQv+Pj6kZWaiKAoZWVl1lqBQ2/ILCshrAJmp5iVOvV7P9OnTef7553n//fdZv349hw8fplevXgAYDAbsS4Pj4cOHM3PmTCZMmMDIkSPrPLjZtWsXkyZNwtHREUdHR+6//3727NlT5rrBgwczZ84c8vLyGDJkiNVh6D/88AObNm1i69athIWF1eXwGw1Z4hRCiAbOPIPm4uxc52diWi6pNqVlTjdXV9xr8Y+bq2u1xuPg4MD48ePZsmULAIqiMHfuXGJiYoiJieGvv/5SjyVauHAhq1atws3NjUmTJvHOO+9o/fZUqqo18caPH8/evXvp2LEj//73v61m59q3b4+iKBw8eLC2htnoyVmcQgjRgOUXFFBQWAiYljd1Ol2d9h/QRBMFqrL8WNd27typHtY9ZswYFi9ezB133IGfnx8lJSUcOXKE6OhoYmNj6dq1K127dsXBwYFt27YB4OXlRVZWVo36vvreCxcuMHz4cGJjY8tcO3z4cNauXcvf/vY3SkpK+PTTTwkPDy9z3alTp4iMjOTBBx+kT58+3HDDDeprERERfPDBB9xyyy3k5eXx4IMP1mjcTZmmAVpGRgYbN26UN1oIITSSapkgUIf7z8rrsynNoDUU5j1oJSUlREREsHTpUgAeeOAB0tLSGDp0KDqdDr1ez5QpU4iOjubFF1/k5MmTODk54ebmxpIlSwB45JFHePbZZ3n33XeZP38+o0aNqvI4rr43MDAQB4fyQ4RHHnmEP//8ky5duhAaGsqgQYOIj48vc92XX37JJ598gpOTE4qiqN+bWatWrdi5cye33HILubm5PP7441Ueb3OgUzQ8v+OPP/6gZ8+eGErPixO148SJE0ybNo3ly5ern7aEEE3T78ePs+/3GABu7NeXThoUCq+uVd+so6CwEBdnZx6+c1ydz+LZqrCwkLi4ONq0aYNLHS8RN1YLFy6kRYsW3H///fU9lEZJi5+5as2gJSQkVPr6xYsXazQIIYQQ5bNcVgyo4wQBM38f04kChUVF5BcW4l7N/VWi8Zk1a1Z9D6HZq1aAFhERUeknJ0VRGt0nKyGEaMjMy4p2Oh2+Xl71MgZzgAamgFECNCFqX7UCNF9fX+bPn8/QoUPLff348eOMHz9ei3EJIUSzZzAYyMjOBsDHy0sts1DX/H281ccZ2VmEtwqul3EI0ZxUK0Dr1asXKSkpFe57KiwsrHL6rRBCiMplZGdjLD3iqS5PELiar9eVAC09K7vexmEr+fdJ1BUtftaqFaA99thjlR7kGh4ezqpVq2welBBCiPo7QeBqvt5XllYzaljGoT45Ojqi0+lISUkhMDBQtuKIWqUoCikpKeh0OhwdHWvcTrUCtHHjxlX6uq+vL5MmTarxYIQQQlyRbhEM+Xn71Ns4nBwd8XBzIzc/n4ysrEa339je3p7Q0FASExM5d+5cfQ9HNAM6nY7Q0FCbtiVIoVohhGigMiyWE/0s9oHVB19vL3Lz8ykqKWmUmZweHh60b9+ekpKS+h6KaAYcHR1t3jNqc4Bmb29PXFxcuVWEhRBC1Jx5Bs3BwQEPN7d6HYuflzfnL5kyOTOyshpdgAamf6/qK9FCiOqy+SxO2XQphBDaK9Hryc7NBcDPy6velxR9vZtGooAQjYUcli6EEA2QubwG1P/yJjT+RAEhGhsJ0IQQogFKz7wSBFnOXtUXyzFkZEuAJkRtkwBNCCEaoAyrDM76D9BcnJxwK913JkucQtQ+CdCEEKIBSm9gARqY9sIBFBYVUVBYWM+jEaJpkwBNCCEaIHOA5tgAMjjNJFFAiLojAZoQQjQwJSUl5JSe2uLn7V3vGZxmkiggRN2xOUB7+eWX8anHI0iEEKKpsczgbAgJAmZ+kiggRJ2pcaFavV6Pg4MDb7zxhpbjEUKIZs96/5lXJVfWLR9PT/VxRnZOPY5EiKavxjNorVq1Yvbs2Rw/flzL8QghRLPXEBMEAFxdXHAqPfw5M1v2oAlRm2ocoGVlZbFw4UK6devGDTfcwMqVK8ktrXothBCi5izP4GxIS5w6nQ6f0kzO3Px89Hp9PY9IiKarxgHapUuXWLRoEd27d2f//v088sgjBAcHM2XKFPbs2aPlGIUQolkxz041hDM4r2a5zJmZI8ucQtSWGgdofn5+PP3008TExHD48GEee+wxnJycWLVqFUOGDKFz5868++67XL58WcvxCiFEk6Y3GMguzeD09fRsMBmcZuYZNJAATYjapEmZjZ49e/Lvf/+bS5cu8emnnzJ8+HBOnTrFCy+8QFhYGOPGjeO7777DaDRq0Z0QQjRZWTk5KIoCgE8DShAw8/WymEGTfWhC1BpN66A5OTlxzz33sG3bNs6dO8err75KWFgYGzZsYOzYsYSFhWnZnRBCNDmWQY+vV8ML0Kxm0CSTU4haU2uFakNDQ/n73//Opk2bGDBgAIqikJSUVFvdCSFEk2CVIODVcBIEzLw9PNTHMoMmRO2pcR20yuTl5fG///2Pjz76iF9++QVFUXBzc2PChAm10Z0QQjQZGQ18Bs3BwQFPd3dy8vLILF2ObWj75IRoCjQN0Hbv3s1HH33EV199RX5+PoqicP311zNlyhTuvfdePC2yf2oqPz+fFStWsGvXLnJycggPD2fixIkMHz78mvdmZGSwZMkS9u3bR2FhIe3atWPq1Kn06tWrzLWHDx9m5cqVnD59GhcXF/r3789jjz2Gr6+v1XV6vZ61a9eyefNm0tLSCA4OZty4cYwfP77Ssbzxxhv88MMP9O/fn7fffrt6b4IQoskyz0rpdDq8PT2ucXX98PHyJCcvj+KSEgoKC3Fzda3vIQnR5NgcoF24cIE1a9awevVqzpw5g6Io+Pv7M3XqVKZMmUK3bt20GKdq7ty5xMbGMn36dMLCwti+fTuvvfYaRqORm266qcL7iouLmTlzJrm5uTz11FP4+vqybt06Zs+ezaJFi4iKilKvjYmJYc6cOfTv35/58+eTkZHBsmXLmDlzJsuXL8fJyUm9duHChWzbto0pU6bQqVMnDh48yAcffEB+fj4PPPBAuWPZt28fe/bswd3dXbP3RQjR+CmKos6geXl4YG9vX88jKp+PpxfnL5m2rGRk50iAJkQtqHGA9r///Y9Vq1axfft2DAYDdnZ2jBw5ksmTJ3PHHXfgWFptWkv79u3j8OHDzJs3jxEjRgCmDNKkpCSWLFnCjTfeWOEvtO+//564uDg+/PBDNWiMjo5m8uTJLFmyhGXLlqnXfvjhh4SFhfH666/j4GB6i4KDg3niiSfYtGkTd9xxBwBxcXF8//33TJs2jXvvvVdtMzs7m48//pixY8fiddUSRW5uLu+99x5Tpkzhq6++0vT9EUI0brn5+egNBqBhLm+a+VqV2sgmpGWLehyNEE1TjZME7rnnHrZu3UpYWBivvfYa586dY/Pmzdx11121EpyBaQnV1dWVoUOHWj0/atQoUlNTOXbsWKX3hoeHW83oOTg4MHLkSI4fP05KSgoAKSkpxMbGMnLkSDU4A+jevTthYWH8/PPPVm0qisKtt95q1dett95KUVERBw4cKDOO//znP/j7+19zCVQI0fxYJwg03ADNR0ptCFHrajyDds899zBlypQq7f3SSlxcHK1bt7YKnADatm2rvt69e/dy7z179izXXXddmect7w0MDCQuLs7q+auv/euvv6zG4+Pjg7+/f4VtWjp8+DBbt27lv//9b4NduhBC1B/LBAGfBh2gSakNIWpbjQO0Tz/9VMtxVElWVhatWrUq87w5+SC7kk9y2dnZ5SYpXH1vVukhxVcvTZqvtewjKyur3OtcXV1xdHRU2wJTcsM777zDPffcQ7t27SocZ3lSU1NJS0tTv46Pj6/W/UKIxsGqBloDLFJr5u7qioO9PXqDgaxcCdCEqA2aZXHq9Xr+9a9/8dlnnxEbG0u+xUG6MTEx/Pe//2XmzJl06NDBpn5sSeeu7N6rX6vo2ur0b3ntsmXLcHBwYNKkSVW+3+zbb79l9erV1b5PCNG4NJYZNFOGqSdpmZlk5+ZhNBqxs6u1sppCNEuaBGgFBQWMHDmSX375hYCAALy8vMgrPUsOoE2bNqxatQo/Pz/efPPNGvfj7e1tNStlllN6Hlx5s1lmXl5e5c6wme81z6R5e5sKQ1bUj+UsnLe3N6dPny5zXUFBASUlJep4jh07xvr163nzzTcpLi6muLgYAKPRiMFgICcnB2dnZ6vsUEtjxoxhwIAB6tfx8fE2vY9CiIYpq/T3kauLMy4V/D5oKLw9PUjLzMRoNJKbn4+XR8MsCSJEY6XJR5758+ezd+9e/vGPf5CUlMTUqVOtXvf29mbIkCFs3brVpn4iIyOJj49XZ+bMzp49C5gCwcruPXPmTJnnzc9FRkZatWFu8+p+LPuIjIwkMzPTavmxvPHEx8ejKAovv/wyo0ePVv8kJydz8OBBRo8ezfr16ysce0BAAB07dlT/tG7dusJrhRCNk16vJ6+gAAAvD9trRtY2b4sxZsmh6UJoTpMA7YsvvmDo0KE899xz6HS6cpcBIyMjSUhIsKmfQYMGUVBQwE8//WT1/JYtWwgICKBLly4V3jt48GASEhKsMj31ej0//PADXbp0ISAgAIDAwEA6d+7Mtm3bMJSmuwMcPXqUhIQEhgwZoj43cOBAdDodW7Zssepr8+bNODs707dvXwD69OnD4sWLy/zx8/Oja9euLF68uExmqhCiecnOvbLq4N0IZqMsi+hm5ebW40iEaJo0WeJMSEhg3LhxlV7j5eVV7rJhdfTr14/evXuzcOFC8vPzCQkJYceOHRw4cIC5c+eqmZELFixg69atfPbZZwQFBQGmUhzr1q1j3rx5TJ8+XS1Um5CQwKJFi6z6efTRR5k1axbz5s1j3LhxaqHaNm3aWJXUaNOmDaNHj2bVqlXY2dnRuXNnDh06xMaNG5k6daq6xOnv718m0xNMh8t7eXkRHR1t0/sihGj8si2CnMawXOjtKTNoQtQmTQI0T09PtY5YRc6cOUNgYKDNfb355pssX76clStXqkc9vfLKK1blPsx7uxRFUZ9zcnJi0aJFLFmyhMWLF1NYWEj79u159913rU4RAFOx2XfeeYePPvqIF154QT3q6fHHHy+zT2zWrFkEBATwzTffkJ6eTlBQEDNmzJA6Z0KIarHMhmyoRzxZsg7QZAZNCK3pFMsopoZuv/129u/fz+nTp/H29ua1117j9ddfV5cIExMT6dixI3fccQeffPKJzYNu7k6cOMG0adNYvnw5HTt2rO/hCCE0sPvwYf46eQqAcTeNIFiDD7S1SVEU/vu/LzEYDPh6eXHvbaPre0hCNCma7EGbM2cO6enpjBgxgl9++UXdxJ+fn8+OHTsYOXIkJSUlzJo1S4vuhBCiybGchWoMe9B0Op06zqzcXIxGYz2PSIimRZMlzsGDB/Of//yHGTNmMGjQIPV5c0kKe3t7PvzwQ3r16qVFd0II0eRk55kCNAd7e1xdXOp5NFXj7elBelYWRqORvIICPN3d63tIQjQZmhWqffTRRxkyZAhLly7lwIEDpKen4+XlRd++fXn88cfp2rWrVl0JIUSTYjQa1SxOLw8Pmwpy16WrEwUkQBNCO5oFaACdO3dm8eLFWjYphBBNXl5BgbpE2BgSBMysa6HlEhpUj4MRoomp07M5ZI+CEEKU1dhKbJhZ10KTUhtCaEmTAG3FihXXvMZgMHDfffdp0Z0QQjQploVevRvBKQJmUmpDiNqjSYD22GOPsWHDhgpfVxSFiRMn8uWXX2rRnRBCNCnZOZYzaI1nH5e7q6t6SLoUqxVCW5oEaP369ePee+9l9+7dZV4zB2f/+9//ePTRR7XoTgghmpQsqyXOxjODZmdnpy7JZufmokFZTSFEKU0CtO+++462bdsyZswY/vrrL/V5RVF44IEH+Pzzz5k+fTr/+c9/tOhOCCGaFPMeNJ1Oh6e7Wz2Ppnp8Spc59QaDeti7EMJ2mgRo3t7ebN26FW9vb2655RbOnTuHoijcf//9fPrppzzyyCMsWbJEi66EEKLJMQdoHm5u6pnCjYVlUV1Z5hRCO5plcbZq1Ypt27ZRXFzMyJEjuffee/nss8+YOnUqS5cu1aobIYRoUgqLiykqLgYaVwanmSQKCFE7NC2z0aFDBzZv3kxSUhJffvklU6ZM4b///a+WXQghRJOSbTHr1BiOeLqal5TaEKJW1KhQ7euvv17p63369CEmJoaQkBCra3U6HX//+99r0qUQQjRJ5hMEwDrYaSxkBk2I2lGjAO3VV1+t0nVXB3ISoAkhhDXLWafGuMTp6eaGnU6HUVFkD5oQGqpRgLZr1y6txyGEEM1StlWR2sYXoJlLbWTm5JBVWmqjsZwlKkRDVqMAbciQIVqPQwghmqWsnMZ5zJMlL09PMnNy0Ov15BcW4u7qWt9DEqLRq9OzOIUQQlgzz6C5ODvh7ORUz6OpGSm1IYT2JEATQoh6YjAYyM3PB8DLvXHOnoEkCghRGyRAE0KIepKd17gzOM28pdSGEJqTAE0IIeqJdYJA4zmD82o+MoMmhOYkQBNCiHqSbZUg4F6PI7GNh7u7mrkpe9CE0IYEaEIIUU+yci0DtMY7g2ZvZ4enuynAzMrJQVGUeh6REI2fBGhCCFFPrJY4G/EeNLgy/hK9noKionoejRCNn6YBWkZGBh9//LGWTQohRJNlDtDs7ewafe0wyz10sswphO00DdASEhJ4+OGHtWxSCCGaJEVR1ADN08Oj0Vfft8rklEQBIWxWrZMEEhISKn394sWLNg1GCCGai/yCAvQGA9A4j3i6muUMmuXSrRCiZqoVoEVERFT6KU/OYBNCiKqxThBo/AGal9RCE0JT1QrQfH19mT9/PkOHDi339ePHjzN+/HgtxiWEEE1aU0oQAPByv1ImJFuWOIWwWbUCtF69epGSkkLHjh3Lfb2wsFDSq4UQogqym9gMmoODA+6uruQVFJCdJwGaELaqVoD22GOPkWdxNMnVwsPDWbVqlc2DEkKIpi4rp2kFaGD6PvIKCigoLKK4pAQnR8f6HpIQjVa1ArRx48ZV+rqvry+TJk2yaUBCCNEc1PUMWlFxMXq9AXe32ivn4e3pwaWUFMD0/QX4+tZaX0I0ddUK0IQQQmjDHKC5u7riYG9fa/0c+O0IG7b9zM8HfkcxKjz64J1MHHcLdnba1ym3DDSzJEATwiYSoAkhRB0rLilRq+3XZoLA19/vZMF/1lg998HKL9j361+89fxj+Hp7adqfZbkQSRQQwjY2f4Syt7e/Zn00IYQQV9TF8mZGVjb/Xv2lRT9XDjQ/FHOM1xau0LxPy/NEs6QWmhA2sTlAk6xNIYSonro4JH3Z/60jNy8fgFuH3cDWTz/gP289h6+3qb+9h/4g9vQ5Tfu0nA3MllpoQthEDksXQog6Zrn85+3hXsmVNXP6XCLrNu8CwM3VhRlT/oaDgwPXR3Vh2sQryV5r/vedpv06OzmpmZuyxCmEbSRAE0KIOlbbM2jL1n6N0Wha3Xjo7tsI8PNRX7v9pkH4+Zj2nu3Ye5j4xCTN+tXpdOo+tJz8fAxGo2ZtC9HcSIAmhBB1zHL5T+skgZzcPPYc+gOAAD8f7ht3s9XrLs5O3HuH6TlFUVj71fea9m8+8klRFHIrqZsphKicBGhCCFHHsnNNgYuToyPOTk6atr37QAx6vekQ9hGD+pTb/oTRN6r10Dbt/IX8gkLN+rcqtSHLnELUmARoQghRhwxGIzmlM0teHh5qZqVWduw9pD4ePvD6cq/xcHfjlqH9ACjR6zkUc0yz/q1KbUgmpxA1JgGaEELUody8PDX73VvjEht5+QXs//UIYFre7NG5XYXXDrg+Sn2851CMZmOwLlYrmZxC1JTNAdrLL7+Mj4+PBkMRQoimz6oGmsb7z/Ye+oPikhIAhvbvVelpAddf11nNuPzl0J+alUzy9ryS9GBeyhVCVJ/NAdobb7yBl5e21aiFEKKpyqrFIrU79x5WH1e0vGnm4uJMrx6dAEhOy+BU3HlNxuDu6qoGhjKDJkTN1eoSp6IonDp1isTExNrsRgghGg3LGTQtlziLiovZW5q96evtSVS3Dte8Z2Cf69TH5nttZWdnh5e7qbZbdm6eFDMXooY0CdA2bNjA5MmTycjIUJ87d+4c3bt3p1OnTrRu3ZqJEydilJo4QohmzjKzUcsZtOOnzlFYVAzADddfV6UD2C33oWkVoMGV70uv11NQqF2GqBDNiSYB2tKlSzl06BC+vr7qczNnzuTYsWMMGzaMHj168Pnnn7Nq1SotuhNCiEbLPINmp9Ph4eamWbsxR0+qj3t261ile0KCAmkT1gqAv2JPk5mtTdalZW03OZNTiJrRJEA7evQoffr0Ub/Oyspi06ZN/O1vf2P79u0cPHiQzp07s3LlSi26E0KIRklRFDVA83R3r3QTf3VZBmjXdbn28qbZDdf3AMBoVPj9SKwmY5FaaELYTpPfDikpKQQHB6tf79mzB71ez7333guAo6MjN910E6dPn9aiOyGEaJQKiooo0esBbTM4jUYjfxw7BYCfjxfhIS2rfG+URTB35MRZTcbj7WGZySkBmhA1oUmA5uXlRVpamvr1jz/+iJ2dHYMGDVKfc3R0JE+O/RBCNGPWh6Rrdwbn2fgL5OblA6bZs+oUv+3Wqa36+OiJM5qMx8tTaqEJYStNArROnTqxceNG0tPTycrK4vPPP6dnz55We9Li4+Np2bLqn+qEEKKpsaqB5uGuWbu/WyxvRnVtX617A/x8CAr0B+DYyTj0BoPN4zFncYJ1UCqEqDpNArQZM2Zw8eJFQkJCCAsL4+LFizz66KPq6waDgT179nDddddV0ooQQjRt1jXQtJtB+8MqQKtagoAl8yxaQWERZ+Mv2DweBwcH3F1NZ33KEqcQNaNJgDZ+/Hj+85//0LVrVzp06MA//vEPJk+erL6+Y8cO8vPzueWWW7ToTgghGqVsi+U+bw33oMUcMwVori7OdGgbXu37u1sscx7RapmzNFGgoKhIPd1ACFF1Dlo19Nhjj/HYY4+V+9rIkSOtaqQJIURzZHn0kVY10C5dTuVySjpgmgmrSv2zq3XtaBGgxZ7hzluH2Twub08PLqWkAKZZtACLLS9CiGuTw9KFEKKOmJc4XV1ccHTQ5vPxX7FXZryiqlFew1LHtq1xcDAFdkditZ1BA6mFJkRNSIAmhBB1oESvJ7+gAND2iKcTZ86pjzu3b1OjNlycnWjfxrQ0Gnf+IjkaHHJu+T1KooAQ1ScBmhBC1IHsWjok/cSZePVxxxrsPzOz3Id27GScTWMC6yQImUETovo024NWV/Lz81mxYgW7du0iJyeH8PBwJk6cyPDhw695b0ZGBkuWLGHfvn0UFhbSrl07pk6dSq9evcpce/jwYVauXMnp06dxcXGhf//+PPbYY1alQ8B01tzatWvZvHkzaWlpBAcHM27cOMaPH2913fbt21m/fj3nz58nNzcXLy8vOnbsyMSJE+nevbttb4oQosGzOiRdowQBRVE4eTYBMB2QHuhf831e3Tq15X8btwOmRIG+PbvZNDbL7zFbaqEJUW2NLkCbO3cusbGxTJ8+nbCwMLZv385rr72G0WjkpptuqvC+4uJiZs6cSW5uLk899RS+vr6sW7eO2bNns2jRIqKiotRrY2JimDNnDv3792f+/PlkZGSwbNkyZs6cyfLly3FyclKvXbhwIdu2bWPKlCl06tSJgwcP8sEHH5Cfn88DDzygXpeVlUX37t2ZMGECPj4+pKWl8cUXXzBjxowy/Qshmp7amEFLScsgI8sU/HRs27paBWqv1qlthPr4dNx5W4eGs5MTTo6OFJeUyBKnEDXQqAK0ffv2cfjwYebNm8eIESMA6NmzJ0lJSSxZsoQbb7wR+woymL7//nvi4uL48MMP6dbN9MkwOjqayZMns2TJEpYtW6Ze++GHHxIWFsbrr7+OQ+lG3uDgYJ544gk2bdrEHXfcAUBcXBzff/8906ZNU4+1io6OJjs7m48//pixY8fi5eUFUGZGDaBv376MGTOG77//XgI0IZo4yzMptQrQTpxJUB93aNvaprbCQlqqAdWpc4m2Dg2dToe3hwcpGRnk5OdjMBqx1/DsUSGaukb1t2X37t24uroydOhQq+dHjRpFamoqx44dq/Te8PBwNTgDUzHFkSNHcvz4cVJK08FTUlKIjY1l5MiRanAG0L17d8LCwvj555+t2lQUhVtvvdWqr1tvvZWioiIOHDhQ6ffj5uaGk5NThUGlEKLpsFri1CxAs9h/FmlbgOZgb09k61YAnL+YRGFhkU3twZUjnxRFIVeO+hOiWqodoBmNRo4cOcLFixfLvFZSUmIVwGgtLi6O1q1bWwVOAG3btlVfr8jZs2fV6yq71/zfiq617CMuLg4fHx/8/f2rPB6DwYBer+fSpUu8//77KIrCuHHjKhw3QGpqKidOnFD/xMfHV3q9EKLhMQdoDvb2uLq4aNLmibOWCQK2BWgA7SLCADAaFc4mlP0dX11WpTZkmVOIaqnWEmd8fDyjRo3i+PHj6HQ6Ro8ezapVq9QAJT09nWHDhmHQ4Cy38mRlZdGqVasyz3t6mrKFsrOzK7w3Oztbva6ye7OysgDUpcmrr7XsIysrq9zrXF1dcXR0VNuyNGnSJBISTMsS/v7+vPfee3TsWPnRLN9++y2rV6+u9BohRMNlNBrJLp1B8vb0tGmvmKWTpTNobq4uhLVqYXN75gAN4PS583TpULOyHWZWpTYkk1OIaqlWgPbcc88RGhrK1q1byczM5Nlnn2XAgAHs3LlTDZwURamVgZrZ8outsnuvfq2ia6vTf3nXvvHGGxQUFJCcnMyGDRuYM2cO//jHP4iOjq6wnTFjxjBgwAD16/j4eN58880qj0MIUb9y8/MxGo2AdvvPsnPyuHg5FYD2bcKw02B/V7s21gGarayL1UompxDVUa0A7aeffmLr1q2EhoYSGhrKli1beOSRRxg0aBC7du3C2dlZs0+G5fH29i53Vionx/QXv7zZLDMvL69yZ9jM95pn0ry9vQEq7MdyFs7b25vTp0+Xua6goICSkpJyx9OmjekTaZcuXRg4cCBTpkzhgw8+YNWqVRWOPSAggICAgApfF0I0bFm1UGLDXF4DoENkzeufWWpvEaCdirM9UcDb4velzKAJUT3V+siVn5+Ps7Oz+rVOp2P58uWMHDmSwYMHc+aMNkeEVCQyMpL4+Hj0er3V82fPngWuBD8V3Vve+MzPRUZGWrVhbvPqfiz7iIyMJDMzk7S0tGqPB0xJCh06dOD8eds/qQohGi7LMhPeHmW3WtSEdYFa2/efAfj5eOHnY/pgeTruvM0rIu6ururMnuxBE6J6qhWgdezYkcOHD5d5fsmSJYwaNYrbbrtNs4GVZ9CgQRQUFPDTTz9ZPb9lyxYCAgLo0qVLhfcOHjyYhIQEq0xPvV7PDz/8QJcuXdQZqsDAQDp37sy2bdus9tIdPXqUhIQEhgwZoj43cOBAdDodW7Zssepr8+bNODs707dv30q/n6KiIo4dO0ZISMi1v3khRKNlubyn1QzaKYslSK1m0ODKPrTM7BzSMsquJFSHnZ0dXu7ugGkGrba3wAjRlFRrifPOO+/k008/5f777y/z2ocffoiiKFb1xLTWr18/evfuzcKFC8nPzyckJIQdO3Zw4MAB5s6dq5arWLBgAVu3buWzzz4jKCgIMJXiWLduHfPmzWP69OlqodqEhAQWLVpk1c+jjz7KrFmzmDdvHuPGjVML1bZp08aqpEabNm3URAk7Ozs6d+7MoUOH2LhxI1OnTrVa4nzssccYMGAArVu3xsPDg6SkJNavX8/FixdlP5kQTVxt1ECLS7gAmFYy2oSVTZ6qqXZtwjgYcxQw7UML8POxqT0vDw8yc3LQGwwUFBbi5uqqwSiFaPqqFaC9+OKLvPjiixW+vmTJEpYsWWLzoCrz5ptvsnz5clauXKke9fTKK69YHfVkNBoxGAxWn9acnJxYtGgRS5YsYfHixRQWFtK+fXvefffdMkVio6Ojeeedd/joo4944YUX1KOeHn/8catTBABmzZpFQEAA33zzDenp6QQFBTFjxowyhWm7devGzp07SUpKoqCgAG9vb7p27cqTTz4pRz0J0cSZ91/Z2dnh4eZmc3tGo5G40jIYIUGBuLg4X+OOqrPeh3aefj1t+/3k7ekBl0yPs3JzJUAToooa1UkCYCru+vTTT/P0009XeM1LL73ESy+9VOZ5Pz8/Xn755Sr1c/3113P99ddf8zoHBwcmT57M5MmTK73uiSeeqFK/QoimRVEUNUnAy91dk2zLyynpFJQWkm0Trt3sGUC7iFD18RkNThS4uhZacGCgzW0K0Rw0qpMEhBCisSkoLFQTm7zKqcVYE2dLlzcBIsO13cPaJrwVdnambPzTGgRolkkRkskpRNXZHKDZ29urhVeFEEJYy8rR/oin2gzQnJ2cCAkyFb2NT7yk1m+rKS9PqYUmRE3YHKBJVo4QQlTMMijRKkHgbLxFgNZa+yzw1qHBABQWFZOclmFTW+YsTrAuNyKEqJwscQohRC2ymkHTqMSGOUFAp9MRURpMaSki7Eqb8ecv2dSWg4MD7qWJAbLEKUTVSYAmhBC1yDIo0aJIraIoxJ03BWitWgZomsFpZhn0nUu0LUCDKzOHBUVFFJeU2NyeEM2BBGhCCFGLsnIslzjdK7myai6npJNfUAhAG433n5lZBWg2zqCB9cyhzKIJUTUSoAkhRC0yl9jwcHNTi2nbwipBoBb2nwG0tih8q+UMGsiRT0JUlQRoQghRSwqLiykqLgasDw63hXUGp7Y10Mx8vDzw8TKN91zpcqotLLNXsyWTU4gqkQBNCCFqSbbF8qZWJTbMCQKgfYkNS+ZEgdT0THLz8m1qy8ti711Wbp5NbQnRXNgcoL388sv4+PhoMBQhhGhasnK1z+C0LLERoeEZnFdrbbEPLd7GZU7rPWgygyZEVdgcoL3xxhtWh4ILIYQwsT4kXZsMTvOesOAWAbjWQganmWWpDVv3oTk7OeHk6AhILTQhqkqWOIUQopZYzhZpMYOWkZWjLje2Dg2yub3KaJnJqdPp1CXenPx8DDaeTiBEc6DpYelGo5HExEQuXLhASQW1bgYPHqxll0II0WBZz6DZHqBZLjWGh9RygKbhDBqYjnxKychAURRy8/I0S5oQoqnSJEBTFIUFCxawaNEi0tLSKr3WYDBo0aUQQjR45ppfri4u6hKfLSwDtNqeQQtuEYiToyPFJSU2nyYAZUttSIAmROU0CdBefPFF3nnnHVq0aMHDDz9McHAwDg6aTs4JIUSjUqLXk1dQAGiXwRl/IUl93DpE+yOeLNnb2xEe0pLT5xJJuHgZvcGAgw113CxPUZBitUJcmyZR1OrVq+nYsSOHDh3CQ6NfREII0Zhl10IGp/UMWu0GaABhrYI4fS4Rg8FAUnIaocEtatyW5SkKWZLJKcQ1aZIkkJuby+jRoyU4E0KIUlpncALEJ5pm0JydnWgR4KtJm5UJa3UlIEu8dNmmtiyXNGUGTYhr0yRAi4qK4uJF26tNCyFEU6F1Bqder+dCUgpgShCws6v9JPzQVi3Vx+cvJtvUlrurqzpmOe5JiGvT5G/43Llz2bBhA7/99psWzQkhRKNnGYRosQctMSlFTbJqXcsZnGbhFgFa4kXbZtDs7Ozwcjctc2bn5qIoik3tCdHUabIH7ZZbbmHNmjXceuutjBkzhuuuu67C4rUPPvigFl0KIUSDZnmKgBZLnHVZYsPMagbNxiVOMGVyZubkoDcYyC8sxN3V1eY2hWiqNAnQioqK2LBhA6mpqaxcuRIwFSa0pCgKOp1OAjQhRLNgPofTydERF2cnm9tLSLTI4KzlEhtmgX4+ODs5UlRcQqKNS5xQutRbGmdm5+ZKgCZEJTQJ0GbNmsUnn3xCjx49mDBhgpTZEEI0awajkZx8U8V/bw+PMh9Ya6KuMzjBtCwZEtyCs/EXSLyUjMFgxN6+5jtjrq6FFhwYqMUwhWiSNImivvzyS3r16sW+ffskMBNCNHu5eXnqHisvjQqyJljWQKujAA0gLLglZ+MvUKLXk5KWQVAL/xq3JbXQhKg6TZIECgsLGTZsmARnQggBZOVYZHBqXKTW39cbD7e6WxoMtSi1cd7GRAEvi2xWqYUmROU0CdB69erF6dOntWhKCCEaPasMTg1KbOTk5pGemQ3UXYKAWViwdokC5ixOgGwptSFEpTQJ0ObPn8+WLVv47rvvtGhOCCEatcycbPWxj2f5Ge3VkWAxc1XXAVqoVakN2xIFHBwc1MQAWeIUonKarEn+8MMPDB06lLFjxzJs2DCioqLKLbOh0+n4+9//rkWXQgjRYGVmX1m+8/GyfQ/a+QsWAZpFwFQXLE8T0KrURl5BAQVFRRSXlGhyiLwQTZEmAdqrr76qPt65cyc7d+4s9zoJ0IQQzUFm6R40Z0dHXJydbW7PMjAKC6nbAK1lgD8ODvbo9Qabi9WCacn3UorpRITs3FwCfGv/yCohGiNNArRdu3Zp0YwQQjR6eoOBnLw8ALy9vDQpsWE5g2a5J6wu2NvbERLUgvjES5y/lKzWtKypq0ttSIAmRPk0CdCGDBmiRTNCCNHoWW5+99GoxIZl9mRocItKrqwdYcGmAK2oqJjU9EwC/WseVFlmtWZLJqcQFar903aFEKIZsU4Q0CpAM5XYaBHgh4uL7Uum1WV9aLqNmZwWtdCyJFFAiAppEqDt3buXWbNmkZSUVO7rSUlJzJo1i/3792vRnRBCNFiWCQLeGiQIZOXkkpVjWjKt6wQBM8tEgcRLtmVyWpYdkVIbQlRMkwBt4cKFbNy4kaCg8tO/g4KC+O6771i0aJEW3QkhRIOl9Qya5cZ8y6KxdSnUYt+b5YkGNeHs5KRmbkqpDSEqpkmAdujQIQYOHFjpNYMHD5YZNCFEk5dpcYqAFgGaVQ20VnVbA80szLIWmo0zaDqdTt2HlpOfj8FotKk9IZoqTQK05ORkQkJCKr0mKCiI5GTb/mILIURDl1W6xOnu6oqjBjW+LGfQwuppiTO4hT/2dqZ/LmzdgwZXjnxSFIXc0oxXIYQ1TQI0Hx8fEhISKr0mPj4eD43OpBNCiIaosLiYgqIiQJsCtWA9g1bXNdDMHBwcCG4ZAJhm0MwHwdfU1aU2hBBlaRKg9e/fn3Xr1nH+/PlyX09ISGD9+vXccMMNWnQnhBANUpZlgoAGRzyBdQ20kKD62YMGVzI58wsK1XNBa8rbIpNT9qEJUT5NArRZs2aRn5/PgAED+Pjjj7l06RIAly5dYs2aNQwYMICCggKeffZZLboTQogGqXZKbJgCtJaBfrg4O2nSZk2EWdRfs/VEActMzqwcqYUmRHk0KVQ7aNAgPvjgA2bOnMnDDz8MmDaCmqfB7ezsWLx4MYMHD9aiOyGEaJC0PoMzKyeX7FzTHq2wekoQMLOqhXYpmeu6dqhxW94WwWumBGhClEuTAA3giSeeYMiQISxZsoRDhw6RmZmJj48Pffr04dFHH6Vbt25adSWEEA2S1hmc9XlI+tUsj5iyNVHA3dUVB3t79AaDzKAJUQHNAjSAbt268Z///EfLJoUQotHIKl3i1Ol0eGqQFJVw8UrNsfqqgWZmXazWtgBNp9Ph7elJWmYm2bm5GIxGNUtUCGEifyOEEEIDiqKoS5xeHh6aBBznG0ANNLNWQYHqIennL9peMsm8BGxUFHJypdSGEFeTAE0IITSQV1CA3mAAtEwQuBII1VeJDTMnR0eCAv0BU+Boa6kNH4ssV8vkCiGEiQRoQgihgSyN95/BlUPSdTodIUGBmrRpC/Mya25evno+aE1ZJlFYJlcIIUwkQBNCCA1YZ3DaXgNNUZQrJTYC/HB2qr8SG2aWiQK2ltrwkUxOISolAZoQQmggM9uiBpomJTbyyMnNB+p/edPMMlHhvI2JApalNrJkiVOIMiRAE0IIDVjOAnlrUWLDIoOzvktsmGk5g+bi7IyLszMgS5xClEcCNCGE0IA5QHOwt8fd1dXm9ixroNV3kVqzUMvTBC5pl8mZV1BASUmJze0J0ZRoVgetuLiY9evXq0VqDaXZTJZ0Oh0rV67UqkshhGgQDEajeqakj5enWo7CFpaHpNd3DTSzEK0DNE9PklJSAVOAG+jnZ3ObQjQVmgRo8fHx3HTTTZw5c6bS1GsJ0IQQTVFObq76u0+rQ9ITG1ANNDNXF2f8fb1Jy8giMSnF5vasS21IgCaEJU0CtGeeeYbTp0/zwAMPMHnyZEJDQ3Fw0PSQAiGEaLC0PuIJrsyg2dnpCAmu/xIbZqHBLUjLyCI9I4v8gkLcXF1q3Ja3RTJFluxDE8KKJlHUzp07GT58OGvWrNGiOSGEaFS0zuC0LLERFOiPk6OjzW1qJTS4BX8cOwXAhaRk2rcJr3FbUmpDiIppkiRgNBqJjo7WoikhhGh0tJ5By8zOITfPVGIjNLhhZHCaabkPzdvivFIJ0ISwpkmA1r9/f44fP65FU0II0ehYlonw1qBIbUM64ulqWmZyOjg44OnuDkBWdrbNx0cJ0ZRoEqAtWLCAXbt28dVXX2nRnBBCNCrm2R8XZ2dcNKj43xBroJmFBF0J0C5okihgmnEsKimhsKjI5vaEaCpqtAft9ddfL/PcsGHD+Nvf/saQIUOIjo7G29u7zDU6nY6///3vNelSlZ+fz4oVK9i1axc5OTmEh4czceJEhg8ffs17MzIyWLJkCfv27aOwsJB27doxdepUevXqVebaw4cPs3LlSk6fPo2Liwv9+/fnsccew9fX1+o6vV7P2rVr2bx5M2lpaQQHBzNu3DjGjx9vdd13333HL7/8wunTp0lPTycwMJDevXszadIkAgICbHpPhBD1p6i4mPyCAgB8NZg9A0hogDXQzCxn0C5oVAvtfJIpIM3MzsHVpeZJB0I0JTUK0F599dUKX/vxxx/58ccfy31NiwBt7ty5xMbGMn36dMLCwti+fTuvvfYaRqORm266qcL7iouLmTlzJrm5uTz11FP4+vqybt06Zs+ezaJFi4iKilKvjYmJYc6cOfTv35/58+eTkZHBsmXLmDlzJsuXL8fJ4hPywoUL2bZtG1OmTKFTp04cPHiQDz74gPz8fB544AH1uo8++ojo6GimTZtGYGAgCQkJrFmzhj179rBy5Ur8JL1ciEYpI+tKgoCvtzYB2vmLlgFaw6iBZubr7Ymbqwv5BYWa1ELztiq1kU1wi4aTsSpEfapRgLZr1y6tx1El+/bt4/Dhw8ybN48RI0YA0LNnT5KSkliyZAk33ngj9vb25d77/fffExcXx4cffki3bt0AiI6OZvLkySxZsoRly5ap13744YeEhYXx+uuvq+VCgoODeeKJJ9i0aRN33HEHAHFxcXz//fdMmzaNe++9V20zOzubjz/+mLFjx+JV+ol65cqVVrNvUVFRdOjQgUceeYSNGzcyadIkbd8sIUSdyMjOUh/7epVdOaiJRMsSG0ENK0DT6XSEBLfg1NkELiWnoTcYcKjg925VSCanEOWrUYA2ZMgQrcdRJbt378bV1ZWhQ4daPT9q1Chef/11jh07Rvfu3Su8Nzw8XA3OwLRBdeTIkfz3v/8lJSWFwMBAUlJSiI2N5ZFHHrGq5da9e3fCwsL4+eef1QBt9+7dKIrCrbfeatXXrbfeysaNGzlw4IA6q3f10ihAx44dsbe3JznZ9k+hQoj6kZGt7QyaoihqDbSgFgE4Oja8mpKhQaYAzWAwkJScZrXsWV2WZUnkTE4hrmhUZ3HGxcXRunXrMkVw27Ztq75ekbNnz6rXVXav+b8VXWvZR1xcHD4+Pvj7+1d7PGBaSjUYDLRp06bS61JTUzlx4oT6Jz4+vtLrhRB1J91yiVODPWgZWTnk5Zv2tDW0BAEzLfehebi5YW9n+qcoS2bQhFBp/tFMr9dz8uRJsrKy8Pb2pkOHDpqdKpCVlUWrVq3KPO9ZOkWebfFJ9mrZ2dnqdZXdm5VlWq7wKucXraenp1UfWVlZ5V7n6uqKo6Oj2lZ58vPzWbhwIS1atGDUqFEVXgfw7bffsnr16kqvEULUj8zSv+eODg54uLnZ3J7l/rOGVgPN7OpSG31taMvOzg5vT0/Ss7LIysnBaDRiZ9eo5g6EqBWaBWgpKSm89NJLfPbZZxSUZjSBKVi57777eOuttwgMtH3zpy2HEFd279WvVXRtdfqv6NqioiLmzp3L5cuX+ec//4nbNX6pjxkzhgEDBqhfx8fH8+abb1Z5HEKI2lGi15OdlweYZs+0OCTdKkGggdVAM7MqVpukRaKAKUAzGI3k5ufjZVHAVojmSpMA7cKFCwwYMICEhAQCAwMZPHgwLVu25PLly/z666+sWLGCH374gT179hASElLjfry9vcudlcopnRYvbzbLzMvLq9wZNvO95pk0c3mQivqxnIXz9vbm9OnTZa4rKCigpKSk3PEUFxczd+5c/vzzT95++226dOlS4ZjNAgICpBSHEA1Qpsb7zwDOX2i4NdDMtCxWC2X3oUmAJoRGe9Cee+45EhISeO2114iPj2fTpk2sWrWKTZs2ER8fz6uvvkp8fDzPP/+8Tf1ERkYSHx+PXq+3ev7s2bMAle7lioyM5MyZM2WeNz8XGRlp1Ya5zav7sewjMjKSzMxM0tLSqjSe4uJiXn75ZX7//Xfmz59fbv01IUTjYZUgoFEGZ8LFhlsDzaxloJ+aMa9JLTTJ5BSiDE0CtC1btnDLLbfw97//HZerigy6uLgwb948Ro4cyebNm23qZ9CgQRQUFPDTTz+V6T8gIKDS2ajBgweTkJDAsWPH1Of0ej0//PADXbp0UWeoAgMD6dy5M9u2bcNgMKjXHj16lISEBKsM1oEDB6LT6diyZYtVX5s3b8bZ2Zm+fa/szDAHZ7/99htvvPEGffr0qdmbIIRoMGqjBlripSslNlq1bJgz5w729urYEi8l23xEk4/FakNWTsV7iYVoTjRZ4iwuLqZnz56VXtOrVy/27t1rUz/9+vWjd+/eLFy4kPz8fEJCQtixYwcHDhxg7ty56ie6BQsWsHXrVj777DOCgkyfQEeNGsW6deuYN28e06dPVwvVJiQksGjRIqt+Hn30UWbNmsW8efMYN26cWqi2TZs2ViU12rRpw+jRo1m1ahV2dnZ07tyZQ4cOsXHjRqZOnWq1xDlv3jwOHDjAAw88gJeXF0ePHlVfc3d3JyIiwqb3RghR97SugaYoCudLTxEIbqAlNsxCgltw/uJlCgqLyMjKwc+n5gGq1QyalNoQAtAoQOvVqxexsbGVXhMbG6vJkt6bb77J8uXLWblypXrU0yuvvGJ11JPRaMRgMFh9qnNycmLRokUsWbKExYsXU1hYSPv27Xn33XetThEAU7HZd955h48++ogXXnhBPerp8ccftzpFAGDWrFkEBATwzTffkJ6eTlBQEDNmzChz1NMvv/wCwNq1a1m7dq3Va1FRUXzwwQc2vzdCiLplnkGzs7PDy8Pd5vbSM7PJKygEICykYS5vmoUGWe9DsyVAc3F2xtnRkaKSElniFKKUJgHaG2+8wU033cTq1at56KGHyrz+0UcfsWnTJn744Qeb+3Jzc+Ppp5/m6aefrvCal156iZdeeqnM835+frz88stV6uf666/n+uuvv+Z1Dg4OTJ48mcmTJ1d63c8//1ylfoUQjYPBaFTrdvl4eWpSGsIyg7OhJgiYWScKXKZH53Y1bkun0+Ht5UVyWho5eXno9XrNyjMJ0Vhp8jdg165dDBs2jClTpvDOO+8wYMAAWrRoQXJyMnv37uXEiROMHDmSnTt3snPnTvU+Lc7mFEKI+pCVk4OxdJZeqwSBxlADzUzzQ9M9PUkuTbjKzMkhoJzTV4RoTjQJ0CwPT4+NjS13uXPr1q1s3brV6jkJ0IQQjVW6RSkef2/tA7TwBloDzSwk6EpdSy1KbfhZvIcZWdkSoIlmT7MZNCGEaE7SM68EaH4+GgVoFjXQwhr4EmeIxrXQLLNgMyo5FUaI5kKTAK2+Dk8XQoj6kp6VqT728/bRpM3zpYGOvZ1dgy2xYebq4oy/rzdpGVkkJqXY3J7lOaYZlRyTJ0RzIQeeCSFEDZhn0Ozt7TXJ4FQURV3iDG4Z0Cg2yZv3oaVnZJFfmn1aU14eHmqihcygCVHDAO2+++7jm2++qXGntt4vhBD1Sa/Xk5WbC4Cfl5cmGZxpFkFOQ1/eNLNKFLDxTE47Ozu1Hlpm6aHpQjRnNfqt8vnnn3PkyJEad2rr/UIIUZ8ysrPVOoua7T+zShBo2DXQzGprH5rRaFQDYCGaqxrPocfExPDxxx9rORYhhGgULDM4Ndt/ZnUGZ2OcQdNiH5o3cB4wZXJa7ksTormpcYC2fv16NmzYUO37bD2zTQgh6lutZHBa1UBrUcmVDUdorWZyZgGhNrcpRGNVowBt1apVNnd89fFKQgjRWKRZzaA13yVOrYvVXl0LTYjmrEYB2qRJk7QehxBCNBrpmZkAODk64uHmpkmbCaUBmr29PcENvMSGmY+XJ+6uLuQVFGoyg+bj6YlOp0NRFMnkFM2elNkQQohqKC4pITc/HzAtb+p0OpvbVBSFxNIALaRlAA729ja3WRd0Op2aKHApOQ29Xm9Te/b29ni5m0qWZGRlyZYY0axJgCaEENVgtf9MowSBtIwsCgqLAAhtJAkCZuaEBoPBQFJKms3t+ZYuc+oNBjUQFqI5kgBNCCGqIc3qBAFt9p8lNKIjnq5muQ8t4cLlSq6sGstEgXQ5UUA0YxKgCSFENaRmZKiPA3x9NGmzMR2SfjXLhIbES7YHaJZBrwRoojmTAE0IIaohLSNTfezv46NJm9Y10BpHBqeZ1jNoVgFapgRoovmSAE0IIapIURRSSzM4Pd3dcXZy0qRd6wCtcdRAM7OeQdOgFpqXl5p4ITNoojmTAE0IIaooOzdXzVTUankTrgRo9vb2BLVoHCU2zPx9vXF1cQbgvMVeuppycHDA28MDMGVyypmcormSAE0IIaoo1Wp501eTNhVFUQO0kKDARlNiw0yn06mZpxcup6I3GGxu03w6g95gICcvz+b2hGiMahyg9ezZk//+979Wz23dupVZs2aVe/1rr72Gg0ONT5YSQoh6VxsJAilpGRQWFQONL4PTLKx0H5rBYCApOdXm9izLl6TJPjTRTNU4QIuJiSEpyXo6e//+/SxevLjCe6TooBCiMUsr3X8GEOCrzQya5cb61o3kiKerWdZuO39RgyOffCwTBTJtbk+IxkiWOIUQoorMM2hOjo54lla8t1V84iX1cevQYE3arGvhVgGa7fvQLDM50yRRQDRTEqAJIUQVFBYVqZXt/X18NDniCSD+wpUArbEckn41rWfQvD09sbMz/fOUblEYWIjmRAI0IYSoAuvlTR/N2o1PvDLj1Dq0cQZo1jNottdCs7ezw9fLdKJAVnYOBg0SD4RobCRAE0KIKrBMENAqgxOuLHG6uboQ4OejWbt1KcDPBxdnU004LQI0uLLMaVQUMnNyNGlTiMZEAjQhhKgCqxIbGs2gFZeUcKk067F1SJBmy6Z1TafTqRmoF5JSNC21AZIoIJonm+pe/N///R/79+9Xvz59+jQAo0aNKnOt+TUhhGiMUtLTAbDT6TQ74inxUjJGoym7PbyRJgiYhQa35FTcebXURmiwbSVD/K8qtdHexvEJ0djYFKCdPn263MBry5Yt5V7fWD8dCiGatxK9nozsbMA0s6NVMVmrDM5Gdkj61cIsxp9w4bLNAZrlDFqazKCJZqjGAVpcXJyW4xBCiAYrNSNDreMY6OevWbvWCQKNewbNsoZbwoUkbujdw6b2PN3dcXJ0pLikxGr/nxDNRY0DtNatW2s5DiGEaLDMy5sAgX7aJwhA4w/QLEuEWAaeNaXT6Qjw9eFicgp5BQUUFBapZ34K0RxIkoAQQlyDZYDWws9Ps3YTLA4Xb6w10MwsS4RY1nazhWW2bFqmzKKJ5qVGM2iTJ0+uUWc6nY6VK1fW6F4hhKgvyeYEATs7zRIEAOJLA7QWAX6NfnbIx8sTLw93snPzrAJPW1jWm0vNyCQ0qHEHsUJUR40CtNWrV5f7vE6nK/e8TfPzEqAJIRqbkpISMrNNdbj8vb2x1yhBIDM7l6zsXKDxz56B6fd869Ag/oo9w+WUdE2WJC3PO5V9aKK5qdESZ1xcnNWfM2fOcNttt+Hv788bb7zBjz/+yPHjx/nxxx95/fXX8ff35/bbb+fUqVNaj18IIWpVakbmlQQBf+2WN633nzX+AA2sS4VoMYvm6+2tZv+nyhKnaGZqNIN2dYLAggULOHDgAH/88QfBwVf+gnbs2JHBgwfz8MMPEx0dzVdffcVzzz1n24iFEKIOJVslCNRSgBbSuBMEzFpflSjQsa1tyWQO9vb4enmRnpVFZlY2BoNBsxlMIRo6TZIEVq5cyd13320VnFkKCQnh7rvvZvny5Vp0J4QQdaa2EgTizl9UH0eGt9Ks3fp0dakNLZhPbTAqCulZWZq0KURjoEmAlpiYiIuLS6XXuLi4kJiYqEV3QghRZywTBMznQ2rhbPwF9XGbJhKgWS5xapXJabkPTQrWiuZEkwAtNDSUdevWUVhYWO7r+fn5rFu3jtDQUC26E0KIOlFUXExm6QkCAT4+mi6vxSWYZtDc3VwJ9Neutlp5iowlnCtM5nxRarmJXFoJa9VC3TOmRS00ML3vZpIoIJoTTQK0qVOncvbsWQYMGMCGDRtIS0sDIC0tjfXr1zNw4EDOnTvHtGnTtOhOCCHqxOXUNPVxy4AAzdrNLyhUD0mPDG9Va8fgbc/4k7FHFtDn9+cZe3QBtx2Zz81/vcFr8V+QWJR27QaqydnJieCWpvcpIfGSJsGgv1UmZ6bN7QnRWNh0FqfZnDlzOHnyJKtWreLOO+8ETMsBRqMRAEVRePjhh5kzZ44W3QkhRJ24nJaqPg4K0O6Ip3Pnryz/RYaHaNauWaY+j/kJX7M1I6bMa5dLMvkm9QA/ZPzJO5EPcoNXR037bh0SxMWkFPIKCknLyCLAz8em9txcXHB3dSWvoEA9ckvOdRbNgSYzaHZ2dqxcuZJdu3YxadIkoqOjiYiIIDo6moceeohdu3axcuVK+UslhGhUamsGLe685f4zbQO0fEMRj5xcahWcdXQN4VbfaPp7dcRZZ/pcnmMo4IlT/+WL5L2a9t/aah+aNsuc5uzZ4pISsnJyNWlTiIZOkxk0syFDhjBkyBAtmxRCiHqhKAqXU00zaK4uLni6u2vW9tmEKxmcWiYIGBQjz8et5USBKQD0tnfjhfBx3OrbU/2AnGMo4OW4T/kp6yhGFP5x/hvCXAI0m0mzPpPzEr26d7K5zUA/P85dMH1PKelp+Hh52tymEA1djWfQVq1aRUpKipZjEUKIBiMzO4eikhLAtLyp5QpAXMKVGTQtlzgXJn7Lz1nHAPC0d2F1x6cY5dfLauye9q78s+3DPNhyKAAKCi/F/R+XizM1GYPVmZzntcnktCxvYlmXToimrMYB2pQpU2jVqhWDBg3i/fffl1MChBBNSlLqlf1nLf21W96EKxmcbq4utAzUprbawZxT/F/yzwA4YMf7kQ8T6dqy3GvtdHY8E3Ibg7w6A5Chz+O5sx+jVww2j8My4LSs9WaLQL8riQIp6ZLJKZqHGgdov/zyC7NnzyY9PZ05c+bQqVMnOnfuzEsvvcT+/fu1HKMQQtQ5ywQBLfefFRYVcyHJtPoQERasycxcsVHPW/Ffq1/PDhtLX6/2ld5jp7PjzTb3EexkCn5i8s7xdYrtv7v9fb3x9HAD4KzFTKEt3FxdcXcztZmSnl6rpUKEaChqHKD169ePf/zjHxw9epRTp07x9ttvExgYyDvvvMOAAQMIDg5m+vTpbNq0iaKiIi3HLIQQtc48g6bT6Wih8Rmc5gBDqwSB1Zd3ca4oGYAe7q35W+CAKt3n4+DO/DYT1a8/vLiFbH2BTWPR6XS0CTPtq7uckk5uvm3tmZmXOUv0ejJzcjRpU4iGTJMszrZt2zJ79mx+/vlnLl++zIoVK+jbty+ffPIJt99+OwEBAYwfP561a9eSLvsHhBANXHFJCemZpmOF/H28cXTQLp/KclYpMsz2BIHEojSWX/oBAHvsmBs+ATtd1X+19/SI5BbfaAAyDXksT/rB5jFZBp7xmi1zXgmSU9Lk3xHR9GkSoFny9/fn4YcfZv369aSmprJu3Truvvtu9u7dy6RJk2jZsiVDhw7VulshhNCM1f4zDZc34cr+M9BmBm3Fpe0UK3oAJrYcTEe36rf5dMhotfzGp8m7SSi0LQHM8mxRy4xVW7Sw2IcmiQKiOdA8QLPk4uLCmDFjWLlyJZcuXWL37t0888wzJCVpUxtHCCFqw8XkZPVxq8AWmrZ9+tx59XFka9sCtMSiNDamHQJMWZvTgm6qUTutnP14oDSrU68YWJ603aZxWX5fcRoFaFYzaBKgiWagVgM0SzqdjgEDBvDOO+8QGxtbV90KIUS1XUq+MoPUqkWgpm2fOmsK0NxdXWjV0rbZuRWXtqPHdGLL/S2G4OXgWuO2JgfdiKe96f5N6b/ZVHbDcmZQq0QBy1p0KRkZ6kk1QjRVNd5Y8fjjj1f7Hp1Ox3/+85+adimEELVOr9dzufQ8YW8PDzV7UAs5uXkkpZjabtcmzKYMzqtnz+5rMdimsbnbu3BP4ACWJ21HrxhYe/knZoeNrVFbLfx9cXd1Ia+g0Krmm60C/fzIyctDr9eTkZ2Nv8VB6kI0NTUO0JYuXVrlay1/CUmAJoRoyC6npamzM8EttF3ePBV3ZXmzfZtwm9pac3mXZrNnZve2GMTHl3+kSNHzVeo+pgWPwNuh+ico6HQ62oSHcOTEGS5eTqWgsAhXF2ebx9fS35+z503v4eXUNAnQRJNW4wBt165dVbouISGB119/nTNnzshZnEKIBu9ibS5vWgZokWE1bidbn8+3aYcBcLVz4r4Wg2weG4C/oydjA/rwv5RfKDAW80XKLzwSXLN9bW3CW3HkxBkAzp2/SOf2bWweX5BFwkZSaipd2rW1uU0hGqoaB2jXOnMzIyOD+fPn85///IfCwkL69+/P22+/XdPuhBCiTlyyTBCo1Rm0mgdo36Tup9BYDMAY/+vxctBuGXZSy2F8lbIPIwr/S9nLw0E34qizr3Y7lmeMxiVoE6AF+vlip9NhVBSrQsJCNEWaJwkUFhayYMEC2rZty/vvv09ERATffPMNe/fuZeDAgVp3J4QQmjEYDGqJDQ83N00PSAc4FZcAmJYA27YOrVEbesXA5yl71a+1mj0zC3X2Z4hPVwBSSrL5KfNojdqxPPLpjEb70BwcHPD3NZXbyMjKpqi4WJN2hWiINKu+qCgKK1eu5LXXXuPChQu0atWKd955h8mTJ2Nnp10cmJ+fz4oVK9i1axc5OTmEh4czceJEhg8ffs17MzIyWLJkCfv27aOwsJB27doxdepUevXqVebaw4cPs3LlSk6fPo2Liwv9+/fnsccew9fX1+o6vV7P2rVr2bx5M2lpaQQHBzNu3DjGjx9vdV1cXBzr1q3j1KlTnDlzhsLCQhYvXkx0dLRtb4gQQjMp6RnoDabzKINbBGq6LcNgMHIm3hSohAa3wM3VpUbt/Jh5hEvFpvMoB3l1JsJF21k+gLsDB7Ar8wgAX6b8wgjfHtVuwzJAOxuvXaJAUECAWmbjcloa4cHBmrUtREOiSeS0fv16unbtyvTp08nNzWX+/PmcPn2aqVOnahqcAcydO5ctW7bw0EMP8c4779CpUydee+01fvih8urXxcXFzJw5k19//ZWnnnqK+fPn4+vry+zZs4mJibG6NiYmhjlz5uDr68v8+fN56qmn+PXXX5k5cybFV31iW7hwIZ988gnjxo3jvffeY9CgQXzwwQesXbvW6rrY2Fh2796Np6cnPXv21OS9EEJo60LyZfWx1sub5y9dpqjI9PvDluXNz5L3qI/va2lb5mZF+nm2J8zZH4D9OSeJr0Hh2paBfmpiwNn4RM3G1jLAX318OTVNs3aFaGhsmkHbs2cPzz//PPv378fJyYlnnnmGl19+ucwsk1b27dvH4cOHmTdvHiNGjACgZ8+eJCUlsWTJEm688Ubs7cvfK/H9998TFxfHhx9+SLdu3QCIjo5m8uTJLFmyhGXLlqnXfvjhh4SFhfH666/jUHrES3BwME888QSbNm3ijjvuAEyzYt9//z3Tpk3j3nvvVdvMzs7m448/ZuzYsXh5eQFw8803c+uttwLw448/8ssvv2j/BgkhbHL+0pUi2qFBQZq2fepsgvq4phmccYWXOZxr2ngf4dyC/p4dNBnb1ex0dkwI6M+iC98B8FXqPp4NHVO9NuzsaBcRyl+xpkzO3Lx8PNxt3ytnmShwOVX2oYmmq8bTW2PGjGHIkCEcPHiQSZMmcerUKd57771aC84Adu/ejaura5mjokaNGkVqairHjh2r9N7w8HA1OAPTfoaRI0dy/PhxUlJMnxBTUlKIjY1l5MiRanAG0L17d8LCwvj555+t2lQURQ28zG699VaKioo4cOCA+pzWM4lCCG2VlJSo+8+8PDzw9vDQtH0tEgS+TtmvPp4Q2L9WM+PHBvRRkwM2pB6k2KivdhuWgejpc9rMonm6u6szc5fT0tSD54Voamo8g/bdd9+h0+kIDw8nKSmJRx555Jr36HQ6vv/++5p2SVxcHK1bt7YKnMB0WLv59e7du5d779mzZ7nuuuvKPG95b2BgIHFxcVbPX33tX3/9ZTUeHx8f/P39y1xnfl0I0ThcTE5R65+FaTx7BraX2Cg26tlYWlrDUWfPbf5l985qydfBg5t8r2NT+m9kGfLZnXWM4dXci2b5fZ6KO09UV9tn/HQ6HUEBAcQlXqCouJjM7Bx8vb1sbleIhsamJU5FUYiLi6tyIGLrp72srCxatWpV5nlPT08AsrOzK7w3Oztbva6ye7OysgDUpcmrr7XsIysrq9zrXF1dcXR0VNuyVWpqKmlpV/ZaxMfHa9KuEOKK80mX1MehwdoHaCfPmP7euru5Etyi+kc87cj8i0xDHgAjfHrg66DtDF95bve/nk3pvwGwMf1w9QM0ixk0cwarFlr6mwI0gEupKRKgiSapxgFafc0O2RLkVXbv1a9VdG11+tdq+eHbb79l9erVmrQlhCjf+STT/jOdTkdoy5aatp2anklyminzsnO7iBr9bvg6dZ/6eHxgf83GVpm+nu0JdPQipSSb3VnHydDnViswbBdxpZSI+QxSLQRbFBC+lJxMl3JWPIRo7GocoLVu3VrLcVSJt7d3ubNSOTk5QPmzXmZeXl7lzrCZ7zXPpHl7ewNU2I/lLJy3tzenT58uc11BQQElJSWVjqc6xowZw4ABA9Sv4+PjefPNNzVpWwgBufn5ZGSZfj+08PPD2clJ0/aPnbrygbZLh+oXbD1flMqhHNPvmnDnQHp71E1AYq+zY5RfT9Zc/hG9YmBregz3tKh6PUt3N1dCggK5kJTC6XPnMRqNmuzHbeHnh729PQaDwerkByGakka1cz0yMpL4+Hj0euvNqmfPngWgTZuKf/FFRkZy5syZMs+bn4uMjLRqw9zm1f1Y9hEZGUlmZqbV8mNVx1MdAQEBdOzYUf1TH8GxEE1ZYtKV7M2wWljePHbySoBWk4r635Yeig5wR0CfOj0273b/3upj8x646mgfaVrmLCwqJvFS8jWurhp7e3uCSstt5OTlkZOXp0m7QjQkNZpBmzx5co060+l0rFy5skb3AgwaNIiNGzfy008/WRWm3bJlCwEBAXTp0qXCewcPHszChQs5duyYep1er+eHH36gS5cuBJSmbgcGBtK5c2e2bdvGPffco5btOHr0KAkJCdx1111qmwMHDmTFihVs2bKFiRMnqs9v3rwZZ2dn+vbtW+PvVQhRdxIuWew/q4UEgeM2zKAZFaMaGNmh4za/2k0OuFp711Z0dA3hRMEFjuQncK4wuVrFcdtHhPHjL78CpkSB8BBt3t/gwBZcuGwK+C4mJ9NRow/EQjQUNQrQKtoPpdPpyk15Nj9va4DWr18/evfuzcKFC8nPzyckJIQdO3Zw4MAB5s6dqwZTCxYsYOvWrXz22WcElf6yHTVqFOvWrWPevHlMnz4dX19f1q1bR0JCAosWLbLq59FHH2XWrFnMmzePcePGkZGRwbJly2jTpo1VSY02bdowevRoVq1ahZ2dHZ07d+bQoUNs3LiRqVOnWi1xFhYWsn+/KUX+6FHT0SkxMTFkZWXh4uJCv379avy+CCFqzmA0knDRFKA5OTrSMqD6G/groyiKOoPm4+VZ7QSBQzln1JMD+nt1pKWTj6bjq4rb/XtzonRT/ndph3kyZFSV7706k3P4wOs1GVMrq31oKRKgiSanRgHa1QkCRqORp59+mv379/P0008zaNAgWrZsyeXLl/n555/54IMP6N+/f5lAqCbefPNNli9fzsqVK9Wjnl555RWrGTWj0YjBYLAKFp2cnFi0aBFLlixh8eLFFBYW0r59e959912ioqKs+oiOjuadd97ho48+4oUXXlCPenr88cdxumpvyqxZswgICOCbb74hPT2doKAgZsyYUeaop4yMDObNm2f13KpVqwAICgrif//7n83vjRCi+pJSUiguKQGgdatW2Gtcs/BSciqZ2aa9rp3bVz9BwHJ5c6x/H03HVlW3+kWzKHEjBox8l/4rj7e6BTtd1d6nWsvkDAjAzs4Oo9HIxRRtlk6FaEh0igZV/hYsWMCiRYuIiYkhuJxz0S5cuEB0dDSzZ8/mueees7W7Zu/EiRNMmzaN5cuX07Fjx/oejhCN2p5ff+PPEycAuOmG/rSPiNC0/e27D/LiP/4DwJR7x/LoA3dW+d5cQyHD/3iFQqUET3tXdvR4FWc7R03HV1VPnPove7JjAVjR4XGu92xXpfuMRiPD7nqM/IJCglsE8O3q9zUb0zfbflCLCz807g7cXF01a1uI+qbJR8WVK1dy9913lxucAYSEhHD33XezfPlyLboTQghNKIrCuQumpTs7nY6wcuos2sqW/Wc/ZPxBoWKa3bvVL7regjOA2/yvLE1WJ1nAfOQTmGYTs3O029BvWW7jYopkc4qmRZMALTExERcXl0qvcXFxITFRuwNzhRDCVhnZ2WTn5gIQ3KIFLhqX1wDrDM4u1czgtFzeHOOvzd6tmhrm0xUPO9Pv+R8y/qDAWFzley0zV4+fPqfZmEIsDrS/eFmWOUXTokmAFhoayrp16ygsLCz39fz8fNatW0doaGi5rwshRH04V7rxHSAiJETz9o1GoxqQtPD3JcDPp8r3JhSm8FuuqWRPpEtLurnV7IB1rbjYOXGTr+m4vHxjEbsy/7rGHVd0bh+hPj52smwJo5oKCgzErnRP33mLUilCNAWaBGhTp07l7NmzDBgwgA0bNqh1wdLS0li/fj0DBw7k3LlzTJs2TYvuhBBCE3EXLAK0UO0DtHOJl8jLLwCqv7y5Mf3KMuIY/+vrtPZZRSxron2f9muV7+vSPlJ9bFm011aWWbdZOTnqbKgQTYFNZ3GazZkzh5MnT7Jq1SruvNO0AdacXQOmfR4PP/wwc+bM0aI7IYSwWU5eHpdLN5j7eXvj7aH92ZYxR06qj3t0aV/l+66ufTa6jmufVSTaow1Bjj4klWSyL/skaSU5+DuWPeP4aq1Dg3B3dSGvoNBqyVcLYcFBXCrdf5aYlESXdlVLXhCiodNkBs3Ozo6VK1eya9cuJk2aRHR0NBEREURHR/PQQw+xa9cuVq5c2SA+AQohBMCZhCslH9qF187y4e9HT6iPo7tWPePasvbZDV4daeHkrfnYasJOZ8etfj0BMGBkW0ZM1e6zs6NT6TJncmo6qemZmo0pzKKwsCxziqZEkxk0syFDhjBkyBAtmxRCiFpxKt4iQGtdOwGaeQbN2dmJjm2rfkSbdXJA/dQ+q8ho/56surwTgE3pv3Fvi0FVuq9z+zb8+qepTMexU3EM7hutyXgC/fxwdnSkqKSExKTLmp33KUR9k59iIUSzk5WTQ0p6OgCBvr74WJz6oZWk5DSSUkz7cbt3bIujY9U+D+cZCtme+ScAnvauDPXpqvnYbNHetRXtXU0llf7Mi+d8UWqV7rPMYD2u4T40Ozs7Qkpn0YqKi0nJyNCsbSHqkwRoQohm53RCHcyeHb2y/yyqW4cq3/dDxp8UlpawqO/aZxUZVbrMCaZZtKro0sEiUaAW9qGZnb8ky5yiaZAATQjR7JyKj1cft62l/WcxFvvPorpUPUD7Nu2g+ri+a59V5FbLAC3tt3LPYL5aq5YBeHuZEjGOnYyr0j1VZbkPLTHpUiVXCtF4SIAmhGhWUjMySM/MAkznOXrVQvYmwO+lM2j2dnZ071y1zMLzRan82oBqn1Uk2MmXXh6mGbFzRckcz792EXKdTqcWrM3MzuFSctWWRqvCy8MDb09TNumllFQKi6teRFeIhkoCNCFEs3L8zJVCqR0iqr5xvzqycnI5G2+qsdahbWvcXCs/acXM8gilhlL7rCKjLEp/fF/VZU6LfWhHYs9oOp6IENMxXYqikHDxoqZtC1EfJEATQjQbeoOBk+fOAWBvb6/5wehmVvvPulat/pmp9pkpe7Mh1T6ryEjf63DU2QOwNeN3DIrxmvf0sJhJtHyPtBARcuWkGssTIoRorCRAE0I0G3Hnz1NUuvzVNiysVs7eBDj4+1H1cc9unap0z+HcM1xsgLXPKuLl4MZA784ApJRkcyjn9DXvua5Le3VWMObYKU3HExwYgHPp/8+ES5cwGAyati9EXZMATQjRbByzWN7s3LZtrfWz/1fTOZX29vb0jupSpXu+TW24tc8qMtpqmfPaRz95uLvRvk0YAKfjzpOTm6fZWOzs7GjdyrTMWVxSwsXS0wWEaKwkQBNCNAtZOTlcuHwZAG9PT1q1CKyVfhIvJZNw0dRPj05t8XBzveY9eYZCfmjAtc8qMti7Cx52pv11OzL+pMB47c350d1MJyooisKfx68961YdlgfeyzKnaOwkQBNCNAtHTl1ZUuvSNrLWNuDv/+0v9XG/Xt2rdE9jqH1WHmc7R0b49gAgz1jErsy/rnGHaZnT7PcjJyq5svrCgoPUUwTOXbigaSkPIeqaBGhCiCavqLiYY6dNWYP29vZ0ioy8xh01t//XI+rj/lUM0Cxrn41tJMubZrf791Yff2uRhVoR8wwawB8a70NzdnKiVYsWAOTk5amnRQjRGEmAJoRo8o6fOUOJXg9AxzYRuLpUrexFden1eg7/cQwAX2/PKp2/GV+YYlX7rKtbWK2Mrbb09IgkxMkPgAPZJ7lcnFnp9QF+PoQGm4KooyfOqkkbWmkbfuX9szwxQojGRgI0IUSTZjAa+fPElZIO13WsWlZlTfx5/DR5BYUA9InuVqVDu79J3a8+vsO/T4OufVYeO52dOotmRKlSskBUV9PJCiV6vebHPkWGhmFX+h6ejk+QZU7RaEmAJoRo0s4mJJCbnw9A61at8PXW/mB0s32/XtmD1b9Xt2teX2LU821p7TMHnT231+LRTka9EaPh2rXKasJy3BvTDl8zKDIHaKB9PTRXF2dCS49+ys3PJylVuxMLhKhLDvU9ACGEqC1Go5Ffjx5Tv47qXHuzZ4qisOsX0+yRTqejb/S1A7Sfso6Srs8F4Eafbvg5anPslEFvJDEmhfMxKVw8mkZeRiGGYiPowM3XGa8WboRFBRLZPxjPQDeb+wt19qenRyS/5Z7lbOFljuQn0N294uXdXj2u/H848PsRHv7b7TaPwVK71q1JuGQ6k/N0fDzBgbWTsStEbZIATQjRZJ1OSCA9q/TcTX9/dQN5bThzLpH4RFNQENWlPQF+Pte852uL5c07A/rZPAaD3sipnxKJ2XCG3NTCshcokJ9eRH56EUmxGRz6/CRh0YH0va8TPiG2BYdj/K/nt9K9dN+k7q80QAsNbklIUCAXklL449gp8gsKq3wcVlVEhoXy00E7DEYjpxPOM6BnzyotNwvRkMhPrBCiSTIYjRz688qSY9/retTq/q4de68Umh0+6NqZmBeK0tmXbVreC3Hyo69n1Y6EqkhqXBbrXtzLnpVHrYIzOwcdvmEetOzgS0CkN67e1qcnnP89ha+f38P+tcfRF9e8+v7NvlG42TkDsDn9d/IM5QSIFswlSPR6A4f/PF7jfsvj5OhI69KzOQsKC7mQnKxp+0LUBZlBE0I0SSfOxpGVa1o+DGnZQt2XVFt27DYFaDqdjhsH9L7G1fBlyi8omPZqjQvoi52uZp+XFaPCHxvP8utXp1AMV/Z+hV4XSOcRYbTq6o+ji/Wv+uzL+Zzdd4lj2+PJTy9CMSoc2XyOS8fSuPHpaLyD3Ks9Djd7Z0b59eSr1H0UGIvZkv474wP7V3h9/57d+fr7nYDp5IXBfaOr3Wdl2rduzdnziYApizeslv//C6E1mUETQjQ5JSUlHPrryuxZnx49arW/M/GJxJ2/CJgKsQb6+1Z6fYGxWM3edNDZ13h5U19sYOe/Yjj8xUk1OPOP8GLMa/245fnetO7VskxwBuDV0o2oO9py9/tD6DWhPfZOpn8K0uJzWP/yXhL/rNkxSeMtvg/L5dvy9L6uM/b2psPWLZMrtBIREoKLs2lG7+z5RAqLijTvQ4jaJAGaEKLJOXzkKHkFBYApc7O2N4mbZ88Ahg+8dibm5vTfyDKYMktv8Y3G39Gz2n0WZhez6a2DxB1IAkCng6g72jLm9f60aF95gGjm4GxP9J3tGPvGDXi3Ms2alRQY2Pbur5zZd6naY+riHkYnV9NxS0fzzxObX/FxS+5uruqpAomXkkm8dLna/VXG3t6ejm0iAFOyyIm4c5q2L0RtkwBNCNGkpGdl8UdsLAD2dnYM7NWzVvtTFIVtPx9Qvx52jeVNRVH4NHm3+vW9LQZWu8+C7CK+f+sgyacyAVOgddPsXvS+uwP2DtX/te4X5skdb95A6+tbAmA0KOz6dwyxu85Xu63xgVdm0b5M+aXSa/v1vJLpus/iBAatdG7bVn18/MwZqYkmGhUJ0IQQTYaiKOw+fBhj6T/E0V264O1Z/dmp6og5elLN3ozu1pGWAX6VXv9r7hlOFZiuv849gm7u4dXqLz+riE1vHiTjfA4Abj7O3P5KP8KjbctQdXRxYPjT0XQcFmp6QoE9K45wek/1Dh0f5ddLTRb4Lv1XsvX5FV57Q+8rS8/7fv2z+oO+Bj9vb4ICAwBT4H45LU3zPoSoLRKgCSGajKOnTnPhsiljz8vdnZ5dOtd6n99s3qU+Hnfr0Gtev+byj+rj6s6eFeeXsGXBITISTckP7n4ujJ7XF/8IbYrv2tnpGDi1G91GRZieUOCnpX9x7lBSldvwsHdhTGnh2kJjMesszhm9Wvs2Yfj7egNw8Pej5BdUnvlZE10sZtGOnNT27E8hapMEaEKIJiE9K4u9v/+ufj34+t44ONRuonpmdi4795gOCPf2dL9m9ubJ/Iv8nGUqnBvk6MMIn6onLxj0RrYv+p30eNPMmbu/C6P/3qdGGZeV0el09J3Yic4jTDN7ilFh17//4PLJjCq3YRl4fp68B4NS/gkGdnZ2DL2hFwBFxSXsORhT84FXoG14OM5OptIipxMSyMuveEZPiIZEAjQhRKNnMBjY/ss+DAZTHa9u7dsT3qpVrff7/fY9FJeUADB6+EA1EKjIR0k71MeTgobhaFe1AFIxKvy87C8uHjUt0Tl7OHLri9fj1VLb4MxMp9Nxw0NdaDfQ9B4aSoz88P6vZF+uWnAT4dKCAV6m0wIuFqerQWl5Rgy8UjNuu0WyhVYcHRzo2q4dYEoW+POktkdLCVFbJEATQjRqiqLw8+HDpGaYZnh8vby4ITqqTvpdt+VH9etrLW8mFKawNSMGAF8HD8YF9K1yX4e+OMGZvaYyHvaOdoyc3QufVtocC1URnZ2OwY90p1VXfwAKc0rY+u5hinJLqnT/fS0GqY//7/JPFV4X3a0jfj6mJdpfDv9RK8uc3Tt2UE8SOHbqNCUlVfsehKhPEqAJIRq1P0+c4PgZ0xFD9nZ2jLihf60vbQL8fOB3NTmgZ/dORIRVPmO36vJOjKWFae9vMRhXu8pn28yObj3HnxvjAFMpjRufiqJlh6qV0bCVncP/t3fe4VFV28N+z6RMJr2S0JIAoRMJEDqhd7GhV0SKdGwXrngFK2C5XssVfnIVRKpwAflQUFACiKC0SA1FEAwkoYWSRhJSp5zvjyEnM5mZJMAEZuJ+nyfPzNln7b3XOnt2Zs0ua6voM7WNEoIjJy2fnz9NRK+r/ND1Lr5NiVQbNy4cunmOYzdTrcq5uKjoZTbNecw+ypvgpdHQJNJ49FSxVssfySl2r0MgsDfCQRMIBE5LyqVL7Es8qlz36tSRkMCKd1HaA1mWWbL6e+X66UcHVCh/viid7zOM03feKg+eDOlapXpSDlwlYUXZMUhdxrYkIjb0DjS+c9Tebgx4JRYPX6NDmXYyk71LT1YaskIlqRgb1lu5XmIyvVuePibTnD/vsb2p4G5o3azsgPajf/yhTIcLBI6KcNAEAoFTcv5yGlv37FUchXYtW9IkMvKe1L334DH+OJsKQJOG4XTvVPExRZ+lxaPHOOo0KrQHvq6aSuu4ejqLXz4/xq1BN2IebaQs3L/X+IZ60m9aW1zcjF8Zf/5yieObkivN92BgW8Lc/AH4NeckfxakWZVrE92UAD9jOJS9h45zs6DQPoqbEOTvr6xLvFlQwKlz5+xeh0BgT4SDJhAInI7zl9OI370bg8Ho9DSOiKDDA9H3pG5ZlllsMno24elHKjyE/WT+RbbdWnsW6OrNqNAeldaRffkmP31yBL32ln3d69Lub3d3mPrdEtokgO7Plu06Pbj2z0rDb7ipXBkd1lO5XmpjFM3VxUUZRSsuLmHLzooD3N4ppp+Rw7+fRKvTVUs9AoE9EA6aQCBwKn7/M4nNu3Ypzlmj8HD6dO5UoZNkT3b9lsjJP42jR40b1KdHJ9snFciyzKeXf1CuJ9Xuh5eLR4Xl52cXsfXDgxTnGxey13sgmLgJre6ZfRXRqHNt2j1xy1GU4Zf5x8lIzakwz9DgTgS4Gtewbck+ytlC607dowPLHNf18b9US9T/WoGBNKxvDMRbUFQk4qIJHBrhoAkEAqdAp9ez6+Ahdh06pHx5NwoPp1+XzsoOveqmsKiY/3zxP+V6wtOPVlj3zzdOsD/P6ATUcw/iieDOFZZfUqBl64eHuJlh3MkYFOlL76ltUN3B8U3VRcxjjWjUpTYAumI92/5zmPxs2zsvNSp3ngntBYCMzH8v/2hVrmmjCFo2aQhAUvIFTp6pfAr1TugQXTYKeOTUKXGIusBhcZxeLxAIBDbIyM7mmy1b+T2pbMQjpnmze+qcAXy5agNX042xyDrEtFR2H1ojX1/Ehxc3KNf/qDekwrhnSiDaC8ZAtN4hGgZMj8VdU/07Um8HSZKImxRNrcb+ABRkFfPTfw6jK7a96H54rW7UcjOeGPBLzkmO3LTufA0d3Et5b3pCgz0J9PdT1ioWl5Sw/5j9j5gSCOyBcNAEAoHDUqLVsi8xkW+2biMrxziVplKp6NWxA13atLmnztmZc+dZs2ErAO5ubrz64jMVTjvOT9vCda1R526+zSo8NUA2yOz64rhZINqBM2Lx9Ffb0QL74eruQt9pbfEONm52yEjJ5ZcFx5AN1qclPVTuPFenbKfrp5d+tDqF2b97R7y9PAHYtms/eTfzq0F76BTTWgnFcvLsWXFGp8AhEQ6aQCBwOEq0Wo7+cZpVmzZx9I/TynqzIH9//jZwAM1Nzle8F9wsKOSNDxegv6XH2GEPUb+O7XAXv+dfYPX13QCoJVdeC3+8QmfuwJoznNtnjKl2rwLR3i2efmr6v9ION40LAKkHrnH4G9truh4Oak9DD+MzO5qfwrZsy3hnHh5qBvfuAhg3C3zz445q0By8PT3pEN1Kud518JDyGRMIHAXhoAkEAochKyeHfYmJrPx+I/sSEyksMq4PclGpaNeyJU8M6E+Qv/891clgMPD2J18qQWmjIusx+m+Dbcrn64t4NWWlEpR2Uu3+1FMH2ZT/PT6FEz+aBKKdcu8C0d4tgfV96P1iDKW+59HvzpG0+7JVWVfJhal1hyjXH1/6jpt6y7Vrwx7uh0plLHDVhi3VcrIAQHTTpgT6Gadd07OyOHbmTLXUIxDcKcJBEwgE9w2DwUBGdjaHfj/Jui1b+frHzRz94zTFJSWKTKPw+gwf8iAdWz+Ai4vLPddxyZrv+SXhCAA+3p58/NYU3N3cbMq/f2E9F4uNU2bRXuE8E9bLpuy5hCv8tvK0ct11XEsi2t3bQLR3S/02teg4srlyvXtR2Zmh5enh14Iefi0BSNfm8tnlzRYy4XXDGNDDuJkiJ/cm636wHeD2bnBRqejevuxw+/3HjivHhQkEjoBw0AQCwT1BlmVuFhRwIS2NA8dPsHHHTpZ+u57/F7+FA8ePk56VpciqVCqaNmjAUw8OZkC3bvh635/pviVrvufLVd8BxsXx777yLPVq23agvss4wA9ZhwDwUqn5oMEo3CTrTuXFo+n8uqBsmq/N0Cia9bk/gWjvlpYDI2jWpz4ABp3MT58cJj3ZMvyGJEm8Wv8xPG4dc7U2fS+/51+wkBs3/GFlFO1/38ZX2yhanVq1iGluPGHAYDDw0959IjaawGFwrO1BAoHAqZBlGa1OZ/zTainWaiksKqKwqJjCoiIKiorIy88nJy+P3Js30VVyvE5wgD9NGzSgSWQDNB73b4G8wWDgi5XrWbZ2k5I2ZfwwurZvbTPPwbyzvHthnXL9ZsQTNqc2Lx5N56c5hzHojNOgTXrWo+3jUXbS/t4jSRJdxrSgILuYC0euoy3Ss/XDgzw4sxMBdc2d6zrqQJ6t3Z//u/wDBmReT1nF182n4elS1t6R9WrTr3sntv6SwI3cPNZ8t5Xxwx+pFt07PvAAl65eIyM7m+zcXHYdPEjvTvcurp5AYAtJro5ogIJq5cyZM0ycOJFFixbRtGlTu5RpMBjQ6/Wlp8ogy7Lx/a2Ph/GlLM3s9Za82Wu5vDIyyEoJynvTj59pXtmYyaROyzJKdSqvb1myXFa3aRlm8uXqkGXLOs3sq1in8mnmOpbpZLMOWZEufXwmz6W8/eWeg2zy7MqXYaqLWR0yBoOMwWDAIBss3996lQ0G9Cb3dTodJTodurscbfDUaAgLDqZOrVpE1q1z30bKTMm6kcus/yzktyO/K2lTxg9j1OO2150lF15j9Jl55OmNRxQNC+nK6+GPW5U9f/gaP3+aqDhnDTqG0evF1qhcnH9CQ1eiZ8sHB7l62jhVqPFzZ/CbHS2cNK2sZ/TpTzlVcAmAR4I68E7kU2YyqRfTGPbc6xgMMmp3N75e8D71ateqFr2zc3JZt2WL8gOiU0xr2rZoUS11CQRVRThoTkh1OGiply+z+ddddilLICiPSqXCz9sbPx8f/Ly9qRUURFhIMN6eng4zUqHXG9i8Yy+fL19HZrZxek6SJKZNepqnHulvM19y4TUmJS0gXZsLQJxvc/4vahyuVqY2T++8yN7FvyuOc01yzkopKdCy+V8HyEgxPg+NnzuD3+hAQD0fM7nzRekM++MTCg3G9YYfNBjJoEDzUxnmfrma1d8ZQ5t0ahfNvHderrbPy7kLF9i6Z69yPSCuG43q16+WugSCqiCmOAUCQaWoJAmVSoVKpUKSJNxcXXFzc8Xd1e3WezclTaP2wFPjgcbDA0+1B95ennhpNPc0ZtntUKLV8vOeg6z8Np6k5LL1UIEBfrz7ymQ6xLS0mfdMwWUmJy0kW3cTgKaaunzUcLSFcyYbZI6sP0vi+rNKWqMutenx3AM1yjkDcPd0Y9BrHdj8/gEyU3MpzCnhh3f2M+CVdtRqXLY7NcIjhDfCH+fN1DUAzE5dS111EA94RSgyk0cNZfueg1zPyOK3wyf4add++vfoVC16NwoPp8MDuRw4fgKAn/buwyWuG5F161ZLfQJBZYgRNCekOkbQrmVkGCNqSwASEpT9UpWM19xKk27J3LqlyCtykpKivFfklB+/krEspSjzvFbrKFeGZBQ2f7Umb1qHmbxSobm9VvKW3iuf17pdtuowsatcGVJZgnleqdyzVfS0fA5K+5SzqzSv6ciDYo8k4XLL6Sp1wFTl3ku3/moSRUXFHD5xmt0HjrJjz0Gyc/LM7vfo1JbX/j6GoAA/m2X8nH2cmalfc9NgXMDeTFOXBY0nE+hmPp1XUqDll/nHuXDkupLWalAkHUc0Q1LVrOdqSvFNLfEfHCTj1mYBF3cVfaa0Ibxt2TSlLMvMPP81GzMPAhDg6s3/mk01W7v3y77DvPLePMC4i/ar/5tdYQy6u0GWZX5O+I0/U1MB48jvQOGkCe4TwkFzQqrDQRMIaholWi1Z2blkZt8gIzuHi2nXSL14hdNnUzmbclEJOmtKs6gIpo4fTmzr5lZKNFJs0PJ5WjxfXftFSWvtFclnURPxddWYyV5PyuaX+cfJvVYAGH88dHi6GdEPNrCPkQ5OSYGW7XMTy8JuSBD7tya0fqSh4vSXGHQ8l7SQQzfPARCuDmFxk+cIdfdXynn1/c/4eY/RiYuKrMfSOTOrbROJwWBge0ICZ88bR1NVkkRcbCwtGzvvJg6BcyIcNCekOhy0Eq2W3DzjsSqyLNtYsF+6uL78AnaTzQCy+cJ05PIL1cuusVqWST2VlmWSp9yGBdnkujSf6WJ7o9rlrsvZXnZtZSG/zbLMN0xYbGSwuinA/PmB9VezDQClz9oir7Wyyp6f6bVlWRU9g8rKMmlDG2XJJm1R9uwq/zzo9Qb0Br3xVa9Hd+u1NF2n01NcUnJr52gxRUUl5OUXcDO/gKrg5upKzy7teOLB3rRp1bTC0cLfcv/kXxe+5UJxupI2MKANsyKeNNuFqCvRc/S7cxz7/pxij9rLjV5/b029B0KqpFdNQa/V8+sXJ0hOuKKkRbQPJW5iKzy8jeE2cnUFjD4zj5Qi4yhjHfdAFjV5ThlJu1lQyNiX3ib1orGMPt3a868Zz+NSTdPD5Z00gOgmTejSJua+xOIT/DURDpoTUh0O2p4DR3lp9ly7lCUQODKSJNEwvC7RzRvRJfYBOrZphafGo8I8R24ms+jKT+zLLYs274qKafUf5umQOMWpk2WZC0eu89vKP8i7XqjIhkT50euFGHxDPavHKAdHNsgc/f6c8SioW984ngFquj/7APWigwFIK85iUtICJchviJsvcxqNVdakpV5MY8w/3ib/Vky0AT06Mfufk3CtJofJYDCQcPQox06XtXlwQAB9u3RWTiAQCKoT4aA5IcJBEwgskSQJD7U7Gg81Xp4aAv19CQrwI9Dfj8AAX+qGhhBRL4zI+nXw8tRUWl6mNo+t2UfZmHmQP26FgyglxiuSNyOeoLGmDmB0zC7/nsmRb5O4/ueNMp1cJNoOjaL1ww1r3GaAO+FC4nV++fwYJQVl4VmiutWhw/CmeAZ4cL0kh8lJX5BcdA0wHg/1Sr1HGBbSFUmS2HPgKK+8Nw+dzhgOo1eXWN755yQ8qjFm3qlz58zO6nRRqWjTogVtWjTHzVXssxNUH8JBc0Kqw0H7IymFpV9vNF5IksmCdpOF5yYLy5WF7aXyJgvWJZNF9eUXqFuWZb4A37j+XbJaluVr6QL5qpRVqnfZNabX5TcZ3HoGpuWWX2QvlSvbfKF+ZWUpJZldS5jUUyprpU7Ta4tNE+WfgfLMyrWpSdmlbVimp6U95mWVa9MKPw8m9lb6eSivB7i4uODiojK+qozvXU3SVCoVHu5uqNXud7yZQZZlMnR5nMy/wPH88/yW+ycnCy5ayNVxD2Ry7f48HBSLSlJRUqDl3L4r/PHzBbLOm280qN0ikC5jWliEl/irk59ZyK4vT3D5RNlxUG4eLkQPaUDLAZHkuxczLXkZiTdTlPudfZvyev2hhHuEsHv/UWb8679KxP+GEXV5/9XnaRRRr9p0Ts/KYntCAtk5uUqal0ZDbKtWNG3YoNpG8QR/bZzOQSsoKGDx4sXs3LmTvLw8wsPDGTFiBH369Kk0b3Z2NgsWLCAhIYGioiKioqKYMGEC7dq1s5A9dOgQS5Ys4ezZs3h4eNC5c2eee+45AgICzOR0Oh0rV64kPj6ezMxMateuzWOPPcbjj1sGqUxLS+Pzzz8nMTERvV5Py5YtmTx58m07WWKTgEBgiSzL6DFQYtChlXVoZf2t93pKZB15+kJydQXk6ArI0ReQrs3lUnEml4ozuFicqcTjskYLz3oMrxXHoMC2aG9ouXwik9SDV7l0PAO91nyzgX9db9o9EUVkh7Aat/vVXsgGmdM7LnJo7Z8U52uVdHdPV5r3DSeqdx2WFO9g5fVfy+5JrjxVqxujQ3ty9vh5pr83j6JiY5up1e6M+dsQRgwdWG2bB3Q6HQdOnOD46TMYTL42NR4etGrcmGYNG+Dj5VUtdQv+mjidgzZt2jROnz7N5MmTqV+/Ptu3b+eHH37grbfeol+/fjbzlZSUMHHiRG7evMnkyZMJCAhgw4YNJCQkMHfuXGJiYhTZo0eP8tJLL9G5c2cee+wxsrOzWbhwId7e3ixatAh3d3dF9qOPPmLbtm2MHz+eZs2aceDAAVavXs2ECRMYNWqUInfjxg3GjRuHj48P48aNw93dnVWrVnH27Fm+/PJLwsOrfgZfdThov+df4MsrPwEmUfGh7J3ponFr903SzdJsfLysypqWayVfpfXK5tIV62hal/U6Kq1XtrTBvF7LfGaL723UYTW/DR2tv6s4n219q66jVX0ryWezXqs6Wi/LdBOEaR6drKdE1lvV605pqqlDR48mdMyNwueiB1nnc8lIzSUnLd+qfEiUH9GDG9CgQ1iNDp9hT4pySzi07k/O7LyEbDBpOwnqRQeT1bWA5b6/cE2Xo9xyl1wZHNiWDkUN+N+8jZxNLZt+DgnyZ8Rjg3iwbzf8favnVIobubnsSzxK6uXLFvfq1KpFg3r1lFMxhIMuuBucykFLSEhgxowZzJw5k759+yrp06ZNIzU1lXXr1tncYbNhwwbmzp3L/PnzadWqFWD8RTRu3Dg0Gg0LFy5UZCdNmkRRURFLly7F9dYagxMnTvDCCy8wbdo0Hn30UQBSUlIYM2YMEydOZOTIkUr+jz/+mG3btvHtt9/i6+sLwIIFC1i3bh2rV68mLCwMgPz8fJ566inatm3L22+/XeXnUB0O2q6cU/z97GK7lCUQOBMusopgvQ/BxT6E5foTdtWP4BQfXK6Atqjis0M1fu5Edgijaa96BEeKheN3Su61fI5+n0zS7svIevOvJK27jt8HXmZ/o3NoVebtUVvyw+9nmdRfUzGYOHjubm5069CauI5t6NS2FcGB/nbX+XpmJol//EHyxUtWf1B6engQGhxMaHAQoUHBBAX442Hy414gqAynWuG4e/duNBoNPXv2NEsfPHgw77zzDqdOnSI6Otpm3vDwcMU5A3B1daV///58+eWXpKenExISQnp6OqdPn2bSpEmKcwYQHR1N/fr12bVrl+Kg7d69G1mWGTRokFldgwYNYtOmTezfv18Z1du1axdt27ZVnDMALy8vunfvzrZt29DpdGb13WsyUnIqF6rpmP6AN/t/K1lJs5EPySLd1m9oSbZyp5KyLMqTrcjaLK80TbJMq7AOy7Jt3S+ro+plgfVna/X52LivMki46FW3/iRUyvuyNPdiVzyK3PAockNd5IamwB2/HA3eeR6oytVlQI9llDTjov/gBr7UbRVM3ehgQpsGoBKjZXeNb6gX3SdFE/u3xpz59RJndlziZoZxF6xbiSttNkbQxDOMo7HnOfHAJbRqo6N2Rc7hSm8g2g/XbfmoThunS0u0WnbsPcSOvYcACA72p2lUBBG1w6gbFkLtWiHUCQsmwM8Xby8N7m5ut61zraAgBnTrRl5+PmdSUjmTkkJOXtk6xIKiIlIuXSLlUtkIn9rNDV8fH3y9vfD18kbjocZD7YGnhxoPDw/Ubm64urri5uqK6631lYK/Lk7loKWkpBAREWHhyDRq1Ei5b8tBS05OpnXr1hbppnlDQkJISUkxSy8ve+LECTN9/P39CQoKspArvQ9QXFxMWloa3bt3t1pmcXExV65cof59PPettSGCCfN7WL9pzWmoxGGwJWuKrS9g61/y1p2VsrKslmDTqbLp0AgEgKvaBa9AD7yCPAgM9yEo3JfACB/863rj4iq+NKsLzwAP2jwaRczDjUg/d4OUA9e4eDSdG5dv4lWgpuuuJnTY14hzja9zukUal+tnY3CRIcQF3QhfSNfjcqgI1dFipIKyzp+RcYOMjBvs5Zj1il0kVGoVkpsKyUVCUknKK6XvTTfHyFB6Oogx0fhfx0ejoW5QICG+fgT6eONe7ruqWKslPSuL9KysKj0PvcGATq9HZzAoMQUNSozIstiI1tKsYW3JitX7NnCiCTe7UDssjL//7Yn7Vr9TOWg5OTnUqVPHIt3Hx7hLKjc31+JeKbm5uYpcRXlzcowjSaVTk+VlTevIycmxKqfRaHBzc1PKysvLQ5Zlq/WX5s/JybHpoGVkZJCZWbbj6exZ43l+58+ftyp/J2Rcz0HlVmh5o5wfU5UlFZXLWBmRKZ9U7tri30K5DNb+bZT+H62w3soSrNhi4dxVKU8lVMVfLGdz1dri9h1Ryyy331539hCqoEslj94ik2Q8rsfF1fjF6+IiIbmpcHGRULmpcFO74ubhcuvPFbW3Gxpfd1w9zP81GrhJRtFNMs7dvg2CO8c/VsI/thZFef5kpuaSe7WAG1eKCU9VE3KsLlrXMNJDc0kPzSUzKJ/swGK0rUDfUo10TYfqvA7pqg7S9UjaCirSg1xSuYNSGfnAVcqC23p7aQjw9yEgwBsvTw1enmo0GrVd16ZJgNhDWj0kn03izJkzlQveAREREXh4VBx/0akcNLizL5yq5C1/z5bs7dRf1TIru7dx40aWL19ukf7ee+9VWReBQCCokaSVvfW49eco6AohPQPSKxcVOCgT4+OrpdyqrCF3KgfNz89PGZUyJe/WvL+10axSfH19rY6wleYtHd3yuxUh2lY9pqNgfn5+ymiWKYWFhWi1WkUfHx8fJEmyWn9pWkW6P/zww3Tt2tVMj/Pnz9OkSROzHaV3y/nz53nvvfd48803iYiIsFu5jkJNtw9qvo013T6o+TYK+5yfmm7jvbCvKuU6lYPWsGFDtm/fbrGgPjk5GYAGDRpUmPfcOcv5idK0hg0bmpWRnJxM586dzWSTk5PN6mjYsCE///wzmZmZZuvQyuujVqupW7eukl6+TLVaTe3atW3qHhwcTHBwsFlabGysTfm7JSIiokbHV6vp9kHNt7Gm2wc130Zhn/NT02283/Y51WrXuLg4CgsL+fXXX83St2zZQnBwMC1atLCZt3v37ly4cIFTp04paTqdjp9++okWLVooDlBISAjNmzdn27Zt6PVlW7pPnjzJhQsX6NGjbCF9t27dkCSJLVu2mNUVHx+PWq2mY8eOZrofOXKEa9euKWkFBQXs2rWLrl273tcdnAKBQCAQCBwLp/IKOnXqRGxsLHPmzKGgoIC6devy888/s3//ft58800lBtoHH3zA1q1bWbNmjRLWYvDgwWzYsIGZM2eaBaq9cOECc+ean0H57LPPMm3aNGbOnGkWqLZBgwZmITUaNGjAgw8+yLJly1CpVDRv3pyDBw+yadMmJkyYYDZtOXz4cLZt28aMGTMYP348bm5urFq1ipKSEsaOHXsPnp5AIBAIBAJnwakcNDAujF+0aBFLlixRjnqaNWuW2VFPBoMBvV5vtiXY3d2duXPnsmDBAj799FOKiopo3LgxH3/8sdkpAgBt2rTho48+YunSpbz66qvKUU/PP/+8xZqvadOmERwczPr168nKyiIsLIwpU6ZYHPXk7+/PZ599xvz583n//feVo54+/fRTh5nDDwoKYsyYMRZhQ2oKNd0+qPk21nT7oObbKOxzfmq6jY5in1OdJCAQCAQCgUDwV8Cp1qAJBAKBQCAQ/BUQDppAIBAIBAKBgyEcNIFAIBAIBAIHw+k2CQggMTGRqVOnWr23YMECWrZsqVyfOXOGL774glOnTuHi4kKbNm144YUXrB6Z9e2337JhwwauXLlCUFAQgwYNYtSoUVUKAaLT6Vi5ciXx8fFkZmZSu3ZtHnvsMYvNEvfLxosXL7Jx40YSExNJS0tDkiQiIiJ48skn6dmzZ6X6XLlyhWHDhlm9V36Tyv2wD7B61ivApEmTGDlyZKU6OXobxsfH8+9//9tmfZXZeb/a8Pjx48THx5OUlERKSgparZa1a9fajH3oKP3Q3vY5Wh+E6mlDR+qH9rbPGfugXq/nm2++4eDBg6SkpJCbm0toaCjdunVjxIgRVo9gdJQ+KBw0J2bSpEm0adPGLM00kO758+eZOnUqUVFRzJ49m5KSEpYuXcqLL77I0qVL8ff3V2RXrFjBkiVLGDFiBO3bt+f06dMsXryYjIwMXnnllUp1mTNnDtu2bWP8+PE0a9aMAwcOMG/ePAoKChg1atR9t/HAgQMkJCQwYMAAmjVrhl6vZ8eOHcycOZNx48YxZsyYKunz+OOP07dvX7O0evXq3Xf7SunZs6fFP8DQ0NAq6eLobdi5c2cWLFhgUf6SJUs4dOiQzS/G8tzrNjx8+DCHDx+mcePGeHl5kZiYaLMsR+yH9rLPUfsg2LcNwfH6ob3sc8Y+WFxczLJly+jTpw9DhgzBz8+PP//8kxUrVrBv3z4WLVqEWq1W8jlUH5QFTseRI0fkuLg4eefOnRXKzZw5Ux4yZIh88+ZNJe3KlStyr1695Pnz5ytpN27ckPv06SN/9NFHZvlXrFghd+/eXU5JSamwnuTkZLl79+7yypUrzdI/+ugjuW/fvnJOTk7VDDPB3jZmZ2fLBoPBIv/06dPlfv36ycXFxRXWk5aWJsfFxcmrV6++PUNsYG/7ZFmW4+Li5Dlz5tyRPs7QhtYoKCiQ+/fvL7/wwguV6nO/2lCv1yvvV69eLcfFxclpaWkWco7WD+1tn6P1QVm2v42y7Fj9sDrsK4+j90GdTiffuHHDIn3nzp1yXFycvHXrViXN0fqgWINWQ9HpdOzbt48ePXrg5eWlpIeFhdGmTRt2796tpO3fv5+SkhIGDx5sVsagQYOQZdlM1hq7d+9GlmWzIL6l+YuLi9m/f78dLLLkdmz09/e3eiB98+bNKSoqsnpO6v3mduy7W5yhDa2xY8cOCgsLefDBB6tFP3ugUlXt36yz9sOq2ueMfbCUqtp4tzh6G1rD0fugi4uLcsa2Kc2bNwfg+vXrSpqj9UHhoDkxc+fOpVevXgwcOJCXX36Z48ePK/fS0tIoLi6mUaNGFvkaNWrE5cuXKS4uBiAlJQUoO4+0lODgYPz8/JT7tkhJScHf398iqF9p3ZXlrwh72WiLxMRE/P39CQgIqJI+q1evpnfv3vTr148XXniBPXv23J5B5bC3fdu3b6dv37706dOHCRMmsHnz5irp4axt+OOPP+Ll5UWvXr2qrM+9bMPbwVH7ob3ss8X97oNgfxsdrR9WZxs6ax88cuQIAJGRkUqao/VBsQbNCfHy8uKJJ56gTZs2+Pr6cvnyZdasWcPUqVP58MMP6dChAzk5OQBmx02V4uvriyzL5OXloVaryc3Nxd3dHY1GY1W2tCxb5OTkWK1Ho9Hg5uZWaf57YaM1fvjhBxITE5kyZYpyTJgt3NzceOihh4iNjSUoKIhr166xfv16Xn/9daZPn86QIUPuu319+/alc+fO1KpVi+zsbH788Uc++OAD0tLSmDBhQoX6OGMbnj9/nt9//52HH34YDw+PSvW5H214OzhaP7S3fda4n30QqsdGR+qH1d2GztoH09PTWbhwIc2aNaNLly5KuqP1QeGgOSFNmjShSZMmynXr1q2Ji4tjzJgxLFiwoMqdztp0w93I2TN/ddv422+/MXfuXHr27Fml3TXBwcEWC0R79erF5MmTWbhwIQMHDrytA++rw76ZM2ea3evZsyevvvoqq1at4oknnrDYUHA7OGIb/vjjjwBV/qfuqG1YVe51P6xu++53H4TqsdGR+mF1t6Ez9sHc3FymT5+OLMvMnj37tqZ373UfFFOcNQQfHx+6dOnCuXPnKC4uVubcra3ryM3NRZIkvL29AeMvg5KSEoqKiqzKWvtFYIqfn5/VegoLC9FqtZXmryp3Y6MpBw4c4M033yQ2Npa33nrrjjudq6srvXv3Jicnh0uXLt1RGabYyz5T+vXrh16v5/Tp0xXKOVsb6nQ6tm7dSlRUFM2aNbtjfaq7DW8HZ+iHd2OfKY7aB8F+NpriSP3QXvY5Yx/My8tj2rRpZGRkMGfOHItQRY7WB4WDVoOQTY5VrVOnDmq1muTkZAu55ORk6tatq0wblc63l5fNzMwkJyfHbDu2NRo2bMiNGzfIzMy0qAeoNP/tcKc2lnLgwAFef/11YmJiePfdd3Fzc7OLPvZaRHy39tmiMv2cqQ0B9u3bR3Z2tl0WJldnG94OztIP79S+Uhy9D5qWaW8cpR/awz5n64N5eXm89NJLXLlyhU8++cTquldH64PCQash5OXlkZCQQOPGjVGr1bi6utKlSxd27dpFQUGBInft2jUSExPN4tV07NgRd3d34uPjzcqMj49HkiTi4uIqrLtbt25IksSWLVss8qvVajp27GgHC+/ORij7YnjggQf417/+hbu7+13po9Pp2LlzJ35+ftStW/euyoK7t88aW7duxdXV1WwawBrO0oal/Pjjj7i7u9O/f/+70qe62/B2cIZ+eDf2geP3Qbh7G63hSP3QXvY5Ux8sdc7S0tL45JNPbLaDo/VBsQbNCXnnnXeoVasWzZo1w8/Pj0uXLrF27VqysrJ47bXXFLlx48YxadIkZsyYwYgRIygpKWHJkiX4+fnx1FNPKXK+vr6MHj2aJUuW4OvrS/v27fnjjz9Yvnw5Q4YMMdvlsmXLFj788ENmzJjBwIEDAeOvggcffJBly5ahUqlo3rw5Bw8eZNOmTUyYMOGOhuXtbePx48d54403CAwMZOTIkZw9e9asvsjISCXMgzUbP/vsM3Q6HdHR0QQGBnL9+nW+/fZbkpKSeO211ypd4Fzd9q1Zs4bU1FTatWtHSEiIsjj54MGDjB071mzdi7O2YSkZGRkcOHCAXr16WY0CbsvG+9WGN27c4OjRo0DZL+n9+/fj7++Pv78/MTExgOP1Q3vb52h9sDpsdLR+aG/7SnGmPlhcXMzLL79MUlISf//739Hr9Zw8eVIpw9/fX3EMHa0PCgfNCWnYsCE7d+5k48aNFBYW4uPjQ3R0NG+88YYS2wUgIiKCefPm8cUXXzBz5kxcXFxo27Ytzz//vMVC1dGjR+Pp6cmGDRv4+uuvCQwM5Omnn2b06NFmcrIso9frLYaQp02bRnBwMOvXrycrK4uwsDCmTJlyx8cE2dvGQ4cOUVxczNWrV/nHP/5hUd+nn36qRKK2ZmODBg3YuHEj27dvJz8/H09PT5o3b85//vOfO1poa2/7wsPD2bt3LwkJCcqux6ioKKvHpzhrG5YSHx+PXq+vcGGyI7VhSkqKxcLxOXPmABATE8O8efOUdEfqh/a2z9H6YHXY6Gj9sDo+o+BcfTArK0tZ+1feDoCBAwfy+uuvK9eO1Aclubom2wUCgUAgEAgEd4RYgyYQCAQCgUDgYAgHTSAQCAQCgcDBEA6aQCAQCAQCgYMhHDSBQCAQCAQCB0M4aAKBQCAQCAQOhnDQBAKBQCAQCBwM4aAJBAKBQCAQOBjCQRMIBAInJzU1FUmSlL+wsDCz+7Nnz0aSJH755Zf7o2A5Ro4caabv8uXL77dKAoHDIRw0gUDgsJR3PKz9lT+G5q9M69atmTVrFv/85z+rva6FCxciSRLPPvtspbLt2rVDkiSOHDkCwNChQ5k1axaPPPJIdaspEDgt4qgngUDg8DRq1IiRI0davVd+tOivTExMDLNnz74ndQ0fPpxp06bx9ddfM3fuXDQajVW548ePc+TIEWJiYmjbti1gdNCGDh3K8uXL+f777++JvgKBsyEcNIFA4PBERUXdM8dDUDV8fX154oknWLFiBevXr2fEiBFW5ZYsWQLA+PHj76V6AoHTI6Y4BQJBjUKSJHr27El6ejrjxo2jVq1aaDQaOnXqZHMNVl5eHrNmzaJly5ZoNBr8/f0ZOHAge/bssZDt2bMnkiRRXFzMzJkziYqKws3NzcyBXL9+PbGxsWg0GkJDQ5k4cSLZ2dlERkYSGRmpyD3zzDNIksTBgwet6jV9+nQkSWLDhg1380hscvz4cerUqUNwcDD79+9X0lNSUpgwYQLh4eGo1Wpq167NmDFjOH/+vFn+Uqdr2bJlVssvKSlh1apVqNVqmw6cQCCwjhhBEwgENY4bN27QtWtXfH19GTFiBNevX2ft2rUMGDCAw4cP06pVK0U2KyuL7t27c/LkSeLi4hgwYAA5OTl8//339OrVi3Xr1vHoo49a1DF06FCOHTvGgAEDCAwMpGHDhgAsXbqU8ePH4+/vz+jRo/Hz82Pz5s3069cPrVaLm5ubUsbkyZNZsWIFixYton379mbla7VaVqxYQVhYGA899JDdn9Hu3bt56KGH8PX1ZceOHTRr1gyA/fv3M2DAAPLz83nooYeIiooiNTWVVatWER8fT0JCgmJr9+7dady4MTt27CA1NdXM+QTYuHEjmZmZDB8+nICAALvbIBDUaGSBQCBwUFJSUmRAbtSokTxr1iyrf/Hx8WZ5ABmQn3/+eVmv1yvpixcvlgF58uTJZvJPP/20DMhLly41S7969apcv359OSQkRC4sLFTSe/ToIQNyTEyMnJmZaZYnOztb9vb2ln18fORz584p6VqtVu7bt68MyBEREWZ5WrVqJfv4+Mg3b940S1+/fr0MyDNmzKjyc3rmmWes3p81a5YMyDt37pRlWZa/++472cPDQ27RooV88eJFRa6kpESOjIyUfXx85KNHj5qVsXv3btnFxUUeMmSIWfq///1vGZBnz55tUe+gQYNkQN6+fbtVvZYtWyYD8rJlyyq1USD4qyEcNIFA4LCUOh4V/U2dOtUsDyB7eXnJeXl5ZularVZ2dXWV27Ztq6Slp6fLLi4ucp8+fazWP2/ePBmQN23apKSVOmjff/+9hfzy5ctlQH7ppZcs7iUkJFh10ErrWLJkiVn64MGDZUmS5KSkJKu6mXI7DtrixYtlFxcXuXPnzhYOZqlT+O6771otZ+jQobJKpZJzcnKUtLS0NNnFxUWOjIyUDQaDkn758mWr6aYIB00gsI2Y4hQIBA7PgAED2LJlS5XlGzdujLe3t1maq6sroaGh3LhxQ0k7ePAger2eoqIiq5sQkpKSADh9+jRDhgwxu9ehQwcL+WPHjgHQpUsXi3sdOnTA1dXyX+6oUaOYMWMGixcvZty4cQBcvnyZrVu30qNHD6Kioio29jaYO3cuGzduZPDgwaxbtw5PT0+z+7/99htgtNfa87h69SoGg4E///yT2NhYAGrXrs2gQYP44Ycf2LlzJ7179wZg+fLl6PV6xo4diyRJdrNBIPirIBw0gUBQ4/Dz87Oa7urqil6vV66zsrIA2Lt3L3v37rVZXn5+vkVaaGioRVpubi4AISEhFvdUKhXBwcEW6f7+/jz55JN89dVXnDp1ihYtWrBs2TL0ej0TJ060qdOdsHv3bgAGDhxo4ZxB2fNYtWpVheWUfx7jx4/nhx9+YNmyZWYOmkqlYsyYMXbQXCD46yF2cQoEgr8svr6+ALz88svIxiUfVv9mzZplkdfaqFBpeenp6Rb3DAYDGRkZVvWYPHkyAIsXL0aWZZYtW0ZgYCBDhw69Y9ussWTJEtq2bcvUqVOZP3++xf1S/Tdt2lTh8+jRo4dZviFDhhAaGsq3335Lbm4uu3fvJikpiX79+hEeHm5XGwSCvwrCQRMIBH9Z2rdvjyRJJCQk2KW81q1bA7Bv3z6LewcOHECn01nN17lzZ6Kjo1m5ciXx8fEkJyczcuRIPDw87KJXKQEBAWzfvp22bdvywgsv8Pnnn5vd79ixI8BtPw9XV1dGjx5NYWEhX3/9NUuXLgVE7DOB4G4QDppAIPjLEhYWxpNPPsm+ffv4+OOPkWXZQmb//v0UFBRUqbxHHnkEb29vFi9eTEpKipKu0+l46623Ksw7adIkMjIylGnNCRMm3IYlVafUSYuNjeXFF1/kv//9r5n+4eHhzJkzh127dlnk1Wq1VmPDQZkzNn/+fNatW0dQUJA4ykkguAvEGjSBQODwnD17tsKTBO7mlIH58+dz5swZpk+fzsqVK+ncuTN+fn5cvHiRw4cPk5SUxJUrV6yu2SqPv78/c+bMYdKkSbRt25Zhw4YpcdDUajV16tRBpbL+u7h0s0BaWhodO3YkOjr6jm2qip4//fQT/fv3Z8qUKciyzJQpU1Cr1XzzzTcMGjSIHj160KdPHyVm3IULF9i9ezdBQUGcPn3aosymTZvStWtXZS3fxIkTcXd3rzYbBIKajnDQBAKBw3Pu3Dnefvttm/fvxkELDAxk3759fPbZZ6xdu5ZVq1ZhMBgICwujdevWvPXWW1YX99ti4sSJBAQE8P7777N8+XL8/Px4+OGH+fDDD4mIiKBRo0ZW8/n5+fHII4+wZs0au28OsIapkzZ16lRkWWbq1Km0b9+eY8eO8fHHH7N582b27NmDWq2mbt26PProowwfPtxmmePHj1cctNIdqQKB4M6QZGtj+gKBQCCwK2fPnqVx48Y8+eSTrF271qpMy5YtuXDhAleuXLEIE1IRqampNGjQgGeeeYbly5fbSePqZ/ny5YwdO5Zly5aJ3Z4CQTnEGjSBQCCwI9nZ2RQXF5ulFRYW8tJLLwFYPTYKYPPmzZw6dYpRo0bdlnNmyldffYUkSYSFhd1R/nvFyJEjkSSJsWPH3m9VBAKHRUxxCgQCgR359ddfGT9+PP379yc8PJyMjAzlrMrevXszbNgwM/kFCxZw8eJFFi1ahEajYfr06bddp7+/v1kokDt18O4VQ4cONQvAGxMTc/+UEQgcFDHFKRAIBHYkKSmJt956i3379inx0KKiohg2bBj//Oc/LUJnREZGcunSJZo2bcqHH35ocWKBQCD4ayIcNIFAIBAIBAIHQ6xBEwgEAoFAIHAwhIMmEAgEAoFA4GAIB00gEAgEAoHAwRAOmkAgEAgEAoGDIRw0gUAgEAgEAgdDOGgCgUAgEAgEDoZw0AQCgUAgEAgcDOGgCQQCgUAgEDgYwkETCAQCgUAgcDD+P7SyxYwOWgBNAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmgAAAHRCAYAAADewkVpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAxbJJREFUeJzs3Xd4VNX2N/DvlMykTnrvoYQQAhN6ESGigJQA0ovCDykWEMWXYrn2gnoRUa6IoiAgl4B6adIUCV2KEISEhJqQ3jOTOvW8f0zmZIa0KSd9fZ7H507OnL3PnlwIK3vvtTaPYRgGhBBCCCGk1eC39AAIIYQQQogxCtAIIYQQQloZCtAIIYQQQloZCtAIIYQQQloZCtAIIYQQQloZCtAIIYQQQloZCtAIIYQQQloZCtAIIYQQQloZCtAIIYQQQloZCtAIIaQOcrkcL730EkJCQiAUCsHj8ZCQkID4+HjweDy88847LT3EdiUkJAQhISFW98Pj8TB8+HCr+yGkpVGARgjhDI/Hq/WfWCxGSEgI5s6di5s3bzbreObNmwcej4fU1FSz265cuRJfffUVoqKi8Nprr+Htt9+Gj49PvfcPHz4cPB7P7Oe888474PF4iI+PN7stIaT9Erb0AAgh7c/bb7/NvpbJZLh48SK2bduGX375BWfOnIFUKm25wZno4MGD6Nq1Kw4cOGB0XSKR4ObNm/Dw8GihkRFCOgIK0AghnKtr+W/p0qXYsGEDvvjiC2zdurXZx2SurKwsPProo7Wu29vbo1u3bi0wIkJIR0JLnISQZjFy5EgAQH5+fp3v//e//0VMTAxcXFxga2uLiIgIfPDBB1AoFLXuPX36NMaPH4+AgACIxWL4+Phg4MCBePfdd9l7eDwefvzxRwBAaGgou+Ta2D4n/VIlwzA4efIk206/r+nhPWipqang8Xg4efIk+9yH29QnJCSEHXNMTIxRW0PZ2dl48cUXERISApFIBE9PTzz11FP4+++/G+z/Yfox5ebmYv78+fD29oaDgwMGDx6M06dPAwDKy8uxYsUKBAcHQywWIzIyEnv27KmzP4VCgTVr1iAqKgr29vaQSCQYOnQodu/eXef9DMNgw4YNiIyMhK2tLfz9/bFkyRLIZLIGx23Onw1C2guaQSOENIs//vgDANC3b99a782fPx9btmxBQEAAJk+eDBcXF/z111/417/+hePHj+P333+HUKj7cXXkyBGMHTsWEokEsbGx8Pf3R1FREW7evImvv/6aXV59++23sXfvXly7dg3Lli2Di4sLALD/W5958+Zh+PDhePfddxEcHIx58+YBQL2BnYuLC95++21s3boVaWlpRsu7jQWDL7/8Mvbu3YuTJ09i7ty5dd5///59PPLII8jKysJjjz2GmTNnIj09HXv27MFvv/2GX375BePGjWvwOYZKSkowZMgQODk5YebMmSgqKsKuXbswatQonD9/HosXL0ZRURHGjRsHlUqF//73v5g+fToCAwMxcOBAth+lUolRo0bh5MmT6NatG1588UVUVFTg559/xvTp05GQkICPPvqo1uf98ssv4evri0WLFsHGxgb79u3DhQsXoFQqIRKJao3XnD8bhLQrDCGEcAQAA4B5++232f9eeeUV5pFHHmF4PB4zbtw4Ri6XG7XZsmULA4CZNGkSU1FRYfTe22+/zQBgvvjiC/baU089xQBgEhISaj0/Pz/f6Ou5c+cyAJj79+9b9FmGDRtW6/qJEyfYz2ho2LBhjCU/UvWf8cSJE3W+P3LkSAYA88EHHxhdP3v2LCMQCBg3NzemtLTUpGfp//9ZvHgxo9Fo2Ovbtm1jADCurq7MuHHjmMrKSva9U6dOMQCYiRMnGvX10UcfMQCYJ598klGpVOz13NxcJjg4mAHAnD171mi8AJhOnToxhYWF7PXKykpm4MCBDAAmODjY6Bnm/tnQf8a6/n8jpK2hAI0Qwhl9AFDXf927d2d++umnWm2kUikjFAqZ4uLiWu+p1WrG3d2d6devH3tNH6ClpKQ0Op62HqClp6czAJigoCBGqVTWen/OnDkMAObHH3806VkAGHt7+1pBslqtZoRCIQOAuXv3bq12ISEhTEhIiNG1zp07Mzwej7l582at+zdv3swAYP7v//6PvbZgwQIGAPPDDz/Uul//PX04QDP3z4b+M1KARtoDmhcmhHCOYRj2dXl5ORITE7F69WrMnj0biYmJ+PDDDwEAFRUVuHbtGjw8PPDFF1/U2ZdYLDYqzzF79mz8+uuvGDBgAKZPn46YmBgMGTIEAQEBTfqZWsLVq1cBAEOHDoWNjU2t9x977DHs2LEDV69exTPPPGNSn127doWTk5PRNYFAAG9vb5SXlyMsLKxWG39/f1y4cIH9urS0FHfu3IG/v3+dCROPPfaY0fgB4MqVKwCAYcOG1br/kUcegUAgMLpmyZ8NQtoTCtAIIU3KwcEB/fv3x6+//oqAgAB8+umneO655xAYGIji4mIwDIP8/HyjDf4Neeqpp3Dw4EGsXbsWP/zwAzZt2gQA6NOnDz7++GM88cQTTflxmpV+87yvr2+d7+uvl5SUmNyns7NzndeFQmGD76nVaqvGpW/j7e1dZ/8Ply2x5M8GIe0JZXESQpqFi4sLwsPDoVar2dkUfUAQHR0NRrflot7/DI0dOxZ//vkniouLcfz4cbzyyitITEzEuHHjkJSU1Oyfranovz85OTl1vp+dnW10X3OxZFz617m5ubXuV6vVKCgoqPMZ5v7ZIKS9oACNENJsiouLAQBarRYA4OjoiMjISCQmJqKoqMjs/hwcHPDYY4/h888/x+uvvw6lUonDhw+z7+uXzTQaDQejb5ilz2qoXXR0NADgzJkzRjNYeidOnAAA9O7d26xnWsvJyQmdOnVCZmYmbt++bdK49K/15UgMnTlzptbnt/bPBiFtHQVohJBmsXfvXty/fx82NjYYPHgwe3358uVQKpWYP39+nUt1xcXF7IwbAJw6darOYEU/M2Nvb89ec3d3BwA8ePCAq49RL0uf1VC7gIAAPPHEE0hNTa21D+vChQvYuXMnXF1dMWnSJMsGbYX58+eDYRisWLHCKLgqKCjA+++/z96jpy9X8uGHHxoFXFVVVXjttdfqfIa5fzYIaU9oDxohhHOGJwmUl5cjKSmJndn66KOPjPYhzZ8/H3///Te+/vprdOrUCaNGjUJQUBCKiopw//59nDp1Cv/3f/+Hb775BgDw0ksvITMzE0OGDGELt/7999/4888/ERwcjBkzZrB9jxgxAp999hkWLlyIyZMnw8nJCS4uLliyZAnnn3nEiBHYs2cPnnrqKYwZMwZ2dnYIDg7G008/3WC7mJgY8Pl8vPbaa7hx4wZcXV0BAG+++SYA4JtvvsGQIUOwYsUKHDt2DH379mXroPH5fGzZsqXWpv/m8P/+3//D4cOHsW/fPvTq1QtjxoxBRUUF9uzZg7y8PKxcuRKPPPIIe/+QIUOwdOlSfPXVV+jRowemTJnC1kFzdXWtcz+buX82CGlXmjdplBDSnqGO8hoCgYDx8fFhYmNjmWPHjtXb9sCBA8zYsWMZT09PxsbGhvH29mb69evHvPHGG0alHOLi4pgZM2YwnTt3ZhwcHBgnJycmMjKSef3115m8vLxa/a5du5bp1q0bIxKJ6izl0NBnMafMhlqtZl577TUmNDSULVlharmH7du3M7169WJsbW3Z75uhjIwM5rnnnmOCgoIYGxsbxt3dnZkwYQJz8eJFk/pv7DMxDMMEBwfX+72pr4RIZWUl8+GHHzKRkZGMra0t4+joyAwZMoTZuXNnnf1otVrmq6++Yv//8PX1ZV544QWmpKSkweeb+mejsc9ISFvCYxjaYUkIIYQQ0prQHjRCCCGEkFaGAjRCCCGEkFaGAjRCCCGEkFaGAjRCCCGEkFaGAjRCCCGEkFaGAjRCCCGEkFaGArQ2pqqqCikpKaiqqmrpoRBCCCGkiVCA1sakpaVh4cKFSEtLa+mhEEIIIaSJUIBGCCGEENLKUIBGCCGEENLKUIBGCCGEENLKUIBGCCGEENLKCFt6AIQQQkhTYxgGarUaGo2mpYdC2jkbGxsIBAKr+6EAjRBCSLumVCqRnZ2NioqKlh4K6QB4PB4CAgLg6OhoVT8UoBFCCGm3tFot7t+/D4FAAD8/P4hEIvB4vJYeFmmnGIZBfn4+MjIy0KVLF6tm0ihAI4QQ0m4plUpotVoEBgbC3t6+pYdDOgBPT0+kpqZCpVJZFaBRkgAhhJB2j8+nf+5I8+Bqhpb+xBJCCCHNLCQkBOHh4ZBKpYiIiMCsWbNQXl5ucX9bt25FcnJyve//9ddfiIqKQnR0NI4ePYoxY8YgJSXFpLZNKTU1Fd98843F7bdu3YqJEyeyfQkEAkilUvTq1Qt9+vTBiRMnGmyflZWFoUOHmvSsL774Ajk5ORaP1VwUoBFCCCEtIC4uDgkJCUhMTIRMJsPWrVst7quxIOvHH3/ErFmzcPXqVYwaNQqHDh1CeHi4SW2bUmMBmlqtNqs/JycnJCQk4Nq1a3jjjTcwbdo0MAxT7/1+fn44ffq0SX1TgEYIIYR0IEqlEhUVFXB1dWWv/fvf/0b//v3Ru3dvjB49mj1/+cCBA+jZsyekUil69OiBffv2YfPmzbh8+TJeeeUVSKVSHDp0yKj/NWvWIC4uDhs2bIBUKkVJSQlCQkKQkJDQaNu6fPLJJ4iKikKvXr0wcOBANjt2+/btGDBgAHr37o1HH30U165dA6ALAB9//HHMnDkTUVFR6Nu3L+7duwcAeO6555CSkgKpVIrY2FgAutnFVatWoX///pg7dy5ycnIQExODPn36IDIyEkuWLIFWq210nKNHj0ZBQQEKCwtx+fJlDB48GD179kT//v1x9uxZALoA0cXFhW3D4/Hw0UcfoX///ggNDcWWLVsAAO+99x6ysrIwffp0SKVSJCQkNPp8a1GSACGEkA5l7xtnUSFTNFn/9s5iTPxwSKP3TZ8+HXZ2dkhNTUWfPn0wbdo0AMDOnTuRkpKC8+fPQyAQYPv27XjhhRfw22+/4c0338SmTZswaNAgaLVayOVyuLi4YMeOHXj55ZfZ5T5Dq1evRnJyMqRSKV5++WWj9xYsWNBg24f9+OOP+OWXX3DmzBk4OzujuLgYYrEYZ8+exX//+1+cOnUKYrEYp0+fxqxZs5CYmAgAuHTpEhISEhAaGorVq1fjk08+waZNm/DNN9/g5ZdfrhXwFBYW4sKFC+DxeKiqqsKBAwfg6OgIjUaDCRMmYPfu3ZgxY0aDY/3vf/+LoKAgSCQSPPXUU/juu+8watQonDlzBpMnT8adO3fqbCcWi3Hx4kUkJyejX79+ePrpp/HWW2/hhx9+QFxcHKRSaaPfJy5QgEYIIaRDqZApUFHUdAGaqfT/2KvVaixevBirVq3C2rVrsXfvXly6dAl9+vQBAKPiuiNGjMCyZcswZcoUjBw5stmCBb2DBw/iueeeg7OzMwCws3779u3DtWvXMGDAAPbeoqIiVFZWAgAGDRqE0NBQ9vVXX33V4HPmzZvHbrbXarVYtWoVzpw5A4ZhkJeXhx49etQZoJWWlrLfE39/f+zfvx8pKSng8/kYNWoUAOCRRx6Bt7c3EhISEBAQUKuP2bNnAwC6desGoVCInJycOu9rahSgEUII6VDsncWtqn+hUIjJkydjxYoVWLt2LRiGwWuvvYZFixbVuvfzzz9HYmIiTpw4gblz52L27NlYuXIlV0O3GMMwmDt3Lj766KM637e1tWVfCwSCRveWGRZ5/fzzz5GXl4cLFy7A1tYWy5cvR1VVVZ3t9HvQDF2/fr3WfQ1lWpo71qZCARohhLRT9zMykJqZBbHIBk4ODgjy84OzldXN2wNTlh+b259//slu2p84cSLWrl2LKVOmwM3NDSqVCjdu3EB0dDSSk5MRGRmJyMhICIVCHDt2DAAgkUggk8ksevbDbTMzMzFixIg6EwdiY2Px1VdfYfLkyXB2dkZJSQmcnJwQGxuL2bNn47nnnkNQUBC0Wi2uXLmCvn37mvXsuhQXF8PHxwe2trbIycnBnj17MHnyZJM/X3h4OLRaLX7//Xc88cQTOHfuHHJyciCVSlFQUGByP9Z8jy1BARohhLQzWq0W5xMScC05xeg6j3cFXYKD0bdHJFwkkhYaHdHT70FTq9UIDg5msxlnz56NwsJCxMTEANBlMs6fPx/R0dF4/fXXkZKSApFIBHt7e2zcuBEAsGjRIrz66qtYt24dPvroI4wZM8bkcTzc1sPDA0Jh3eHB008/jaysLAwePBhCoRAODg74448/MHToUHz66aeYNGkS1Go1lEolxo4d22iA1rNnT0RGRqJHjx4ICwvD/v37a92jX9KNjIyEn58fHn/8cZM/GwCIRCL8+uuveOmll/Dqq6/C1tYWP//8MxwdHc0K0F566SUsXLgQ9vb22Lp1a5MvL/OYhvJPSauTkpKChQsX4rvvvmN/2yKEED2NVoujp88gNTOz3nuEQiEmj3wC7gbZa+1VVVUV7t+/j9DQUKOlK1K/zz77DL6+vpgzZ05LD6VN4urPHM2gEUJIO3I95RYbnPF4PAzpHQ13Fxdk5eXj+q0UVCmUUKvV+OPceUwZNdKqo2hI+7RixYqWHgIB1UEjhJB2o7JKgcs3brBfjx02DD3Dw+Hv7Y1+UT0wJzYWbtXZd4UlJbhYx+ZpQkjrQAEaIYS0E5euX4dSpQIAdAsLRZCfr9H7IhsbPD54EHsu5dWkm8gxYw8OIaT5UIBGCCHtQJFMhsTqwptCoRADevas8z4PV1f07xnFfn01KalZxkcIMQ8FaIQQ0g4k3ExmzxzsHREBB3v7eu/t1a0bHOzsAACpmVmQl5U1yxgJIaZrc0kCSqUS33//PY4dO4bS0lJ06tQJCxYsQL9+/Rptm5+fjw0bNuDSpUvQarWIjo7G0qVL4efnV+vegwcPYteuXcjJyYGnpyemTJlSZ90VU/t89NFH6xzTokWLKFOGEGIVlVqNuw8eANAtY/aK6Nbg/QI+H5FdOuPiP9fBMAwS79zBoGauSE8IaVibC9A+/vhjxMfHY+rUqQgICMDhw4excuVKrF+/Hj3rmdIHgIqKCixbtgzl5eWYM2cOhEIhdu/ejaVLl+KHH35gj60AdEdWrF27FsOGDcP06dPxzz//YP369aiqqmKPgDC3TwDo27cvRo8ebXStS5cuHH1nCCEd1d0H6VBVVzvvHBQEm3pqWBnq3qkTLt9IhFarxc27d9GvR496a18RQppfm1riTEpKwvHjx7Fo0SK88MILiI2NxRdffAEfHx+2WF999u7di4yMDKxZswazZs3CtGnTsHbtWhQVFSEuLo69T6FQYPPmzRg0aBDef/99jB8/Hm+88QaeeOIJbNu2DaWlpWb3qRcYGIiRI0ca/ac/m4wQQiyVcv8e+zo8zLSfKfZ2dugUFAgAqFIocad6Bo40j5CQEISHh0MqlSIiIgKzZs1CeXm5xf1t3bq1zsr/en/99ReioqIQHR2No0ePYsyYMUhJSTGpbVsxb948+Pv7QyqVIioqCo8++qjJn4vH46GkpKRpB2imNhWgnTx5EgKBALGxsew1sViMsWPHIjExEbm5ufW2jY+PR7du3RAREcFeCw4ORu/evXHixAn22pUrVyCTyTBx4kSj9pMmTUJlZSXOnz9vdp+GFAoFFIqWP6SXENI+yMvKkJmbBwBwcXKCj4eHyW2junZlXyfdvcv52EjD4uLikJCQgMTERMhkMmzdutXivhoLsn788UfMmjULV69exahRo3Do0CG22HlLBGiGB8AD4Oy8yxUrViAhIQHXr1/HmDFj8K9//YuTfltCmwrQbt++jYCAADg4OBhd1wdId6ozmB6m1Wpx7949dOtWe19GREQEMjMzUVFRwT4DQK17w8PDwefzcevWLbP71Dty5AhGjhyJJ554Ak8//TR+//33Rj9zQUEBUlJS2P/S0tIabUMI6ThS7t9nX4eHhTZ4CPTDvN3d2SOfcvILUFnPAdSkaSmVSlRUVMDV1ZW99u9//xv9+/dH7969MXr0aPZn/4EDB9CzZ09IpVL06NED+/btw+bNm3H58mW88sorkEqlOHTokFH/a9asQVxcHDZs2ACpVIqSkhKEhIQgISGh0bYP27p1Kx5//HHMnDkTUVFR6Nu3L+7d083g5uTkICYmBn369EFkZCSWLFkCrVbLtouJicHkyZMRFRWFixcvgsfj4e2330a/fv3w2muvIS8vD0899RSioqLQo0cPbNq0CQBw7NgxjBw5EgAgl8thY2ODb7/9FgCwbds2zJ8/v9Y4GYaBXC5nv6epqalwMTg5o6ysrN6/K+fOnWNn4ebPn49evXohPj6e/YzTpk1D//79ERUVhTfffLPB75c12tSGg8LCQri7u9e6rr9W35lacrkcSqWy0bZBQUEoLCyEQCAw+osCADY2NpBIJCgsLDS7TwDo0aMHYmJi4Ovri8LCQvz66694//33UV5eXmu2ztD+/fut+q2KENK+3U7TLU3yeDyEm7llgsfjITTAH1eT5AB0GZ0RncI4H2NrM/Pm5yhQlTZ+o4U8bJzw34jljd6nP4szNTUVffr0wbRp0wAAO3fuREpKCs6fPw+BQIDt27fjhRdewG+//YY333wTmzZtwqBBg6DVaiGXy+Hi4oIdO3bg5ZdfrvPfk9WrVyM5ORlSqRQvv/yy0XsLFixosG1dLl26hISEBISGhmL16tX45JNPsGnTJri4uODAgQNwdHSERqPBhAkTsHv3bsyYMQMAcOHCBVy9etXomEKBQIBLly6x34/w8HD8+uuvyMvLQ58+fdCrVy8MHToUM2bMgEKhwIkTJ9CvXz/88ccfWLRoEX7//Xc8+eSTbH+fffYZtm7divz8fAgEApw6dcqkz6SnVCoxffp0bNu2DTExMThx4gS2bNnCvj937ly8/vrrGDZsGNRqNcaNG4c9e/Zg6tSpZj3HFG0qQFMoFLCxsal1XSQSse/X1w6ASW0VCkW9G2VFIpHRfab2CQBff/210T1jxozBggUL8O233+LJJ5+EWCyu85mxsbEYMmQI+3VaWho++OCDOu8lhHQssrIylMh1wZWPhwccGyitUZ9Q/wBcTboJAEjNzOwQAVqBqhR5KllLDwNxcXGQSqVQq9VYvHgxVq1ahbVr12Lv3r24dOkS+vTpA8B4OXDEiBHs4eEjR45s8gO76zJo0CB2//SgQYPw1VdfAdCtLK1atQpnzpwBwzDIy8tDjx492ABt8ODBtc6QNpz9+uOPP/D3338DALy8vPDUU0/hjz/+wMCBAyGVSnH27Fn88ccfWL16NZYvXw6tVos///wTn332GdvHihUr2CB0y5YtmDJlCi5fvmzyZ0tOToZQKGQPqo+JiUGnTp0AAOXl5Th+/LjRdqqysjJ2Lx/X2lSAJhaLoaqukm1IqVSy79fXDoBJbcVicb1r4Uql0ug+U/usi42NDZ566imsXbsWKSkp9Wagenh4wMOMPSWEkI7jQVYW+/rhUwNM5eXuBjtbMSqrFEjPzoZarW732ZweNk6tqn+hUIjJkydjxYoVWLt2LRiGwWuvvYZFixbVuvfzzz9HYmIiTpw4gblz52L27NlYuXIlV0M3ieEB4AKBgP038/PPP0deXh4uXLgAW1tbLF++HFUGy+aOjo61+qrrmp7hEuTjjz+OP/74A6dOncKaNWsQFRWFHTt2wNXVFT4+PnW2nz59OubPn4/8/HwIhUKjQLfKjOV8/Tj0dQb/+usvqw5BN1Wb+lvo7u6O/Pz8Wtf1y471BTISiQQikYi9r6G27u7u0Gg0KC4uNlrmVKlUkMvl7PKlOX3Wx8vLC4BuuZQQQsz1ICubfR1cRz1HU/D5fIT4++Pm3XtQazTIyMlFSIA/V0NslUxZfmxuf/75Jzu7NHHiRKxduxZTpkyBm5sbVCoVbty4gejoaCQnJyMyMhKRkZEQCoU4duwYAN2/STKZZbOCD7fNzMzEiBEjzE4cKC4uho+PD2xtbZGTk4M9e/bUWT+0Po8//ji+++47fPjhh8jPz8evv/6KPXv2sO9NmzYNwcHBcHBwwOOPP4633nqrwWXZ48ePw8PDA+7u7tBqtWAYBklJSejevTu2bdtWZ5vw8HCoVCqcPHkSw4YNw8mTJ9n97Y6OjoiJicGaNWvwzjvvAACysrKg1WoREBBg8uc0VZtKEujcuTMyMjJqpSInVR9V0rlz5zrb8fl8hIWF1fmHLSkpCX5+frCvXhrQ1yV7+N7k5GRotVr2fXP6rE9W9W+/hhsXCSHEFGqNBpnVSy32dnZwt+LnSIh/TUB2PzPT2qERE02fPp3d7H/z5k2sX78eADB79mzMmzcPMTEx6NWrF6RSKf78808AwOuvv47IyEhER0dj+/btbKCwaNEifPTRRyZt9H/Yw20zMzMtmkVdtmwZLly4gMjISDz99NN4/PHHzWr/5Zdf4ubNm4iKikJMTAzeeOMNDBgwAICujqhMJsOIESMAAE888QTS0tLYr/U+++wzSKVS9OrVC++//z5+/vln8Pl8CIVCfPXVVxg3bhz69etX5+oXoFv52rVrF1566SVERUVhy5YtCA8PZ/+d/umnn3Dnzh306NEDUVFReOqpp+qcqOEE04YkJiYyQ4cOZXbu3MleUygUzIwZM5jFixez13JycpjU1FSjtjt27GCGDh3K3Lx5k72WlpbGDB8+nNm4cSN7raqqihk7diyzatUqo/bvv/8+88QTTzAymczsPouLi2t9lvLycmbGjBnMuHHjGKVSafL3IDk5mRk6dCiTnJxschtCSPuTlpnF/Oenncx/ftrJHD//l1V9KVUqZtOuOOY/P+1kfvjlV0ar1XI0ypZXWVnJJCUlMZWVlS09lDbj008/ZbZv397Sw2gxcrmcfX3x4kXGx8eHKS8vN7k9V3/m2tQSZ/fu3RETE4Nvv/0WJSUl8Pf3x5EjR5CTk4NVq1ax93344YdISEgwyt6YNGkSDh48iFWrVmHGjBkQCATYvXs3XF1d2Q2MgC56fvbZZ7Fu3Tq89dZb6N+/P65du4Zjx45h4cKFkFSnpJvT56+//oozZ85g8ODB8Pb2RmFhIQ4dOoTc3Fy88cYbdSYaEEJIQ9IM9p9ZurypZyMUwt/bG2lZWaisqkKxTA43F+fGG5J2acWKFS09hBb1yy+/YN26dWAYBkKhENu3b290RawptKkADdBN73p7e+Po0aMoKytDWFgYPvnkk0YzWezt7bF+/Xps2LAB27ZtY8/NXLJkSa0lxkmTJkEoFCIuLg5nz56Fl5cXlixZUiuN1tQ+o6KicOPGDRw8eBByuRy2traIiIjAqlWr2CwdQggxhz5BgM/jIcDH2+r+/Ly92KAvKz+PAjTSYc2bNw/z5s1r6WGAxzDVaQmkTUhJScHChQvx3Xff1UpXJoR0DKXl5di+bz8AwM/LExPN3OtTl9zCQvxyVLfhvHNQEEY+MqSRFm1DVVUV7t+/j9DQ0GbJvCOEqz9zbSpJgBBCCJCdV5PN7udl/ewZAHi6urKHrGfl5YF+dyekZVGARgghbUx2vmGA5slJn3w+Hz6eutJAFVVVkJWWcdIvIcQyFKARQkgbow/QeDwevOs4bs5SftW1GQHdLBohpOVQgEYIIW1IlUKBouqioh6urpxmgVOA1nxCQkIQHh4OqVSKiIgIzJo1q1aNT3Ns3bq1wcKyf/31F6KiohAdHY2jR49izJgx7BFFjbV9+DmmntnJlYMHD2L48OEAdIeeCwQCSKVSSKVSdOvWzeTjD995551aZ5G2ZhSgEUJIG5JTUMC+9vPkZnlTz8vNDUKBAAAFaM0hLi4OCQkJSExMhEwmw9atWy3uq7Eg68cff8SsWbNw9epVjBo1CocOHWITzcwJ0MxheLQSl5ycnJCQkICEhARcuHABGzZsQGJiYpM8qyVRgEYIIW2IYYKAD0f7z/QEAgG8q4+oK6uogLyM9qE1B6VSiYqKCqPjBf/973+jf//+6N27N0aPHo20tDQAwIEDB9CzZ0/2BIJ9+/Zh8+bNuHz5Ml555ZU6TxJYs2YN4uLisGHDBkilUpSUlCAkJAQJCQmNtq2LXC5HbGwsunfvjkcffRSpqakAdIFeTEwMJk+ejKioKFy8eBFHjx5F79690bNnTwwbNow9+ScnJwcxMTHo06cPIiMjsWTJEmi1WgC6oxVfeOEFdOnSBf3798eJEyfqHUt5eTkYhmFrlM6bNw9ffPEF+/7/+3//jz1twZD+GV27dsXAgQPx6quvsrN0ALB9+3YMGDAAvXv3xqOPPopr1641+n3hWpurg0YIIR2ZYYKAL8czaIAu6UB/hFRuQQEkDRxm3VY989LbKCy27NxKU7i7OmPbl+82et/06dNhZ2eH1NRU9OnTB9OmTQMA7Ny5EykpKTh//jwEAgG2b9+OF154Ab/99hvefPNNbNq0CYMGDYJWq4VcLoeLiwt27NiBl19+uc7lx9WrVyM5ORlSqbTWEt+CBQsabFuXs2fPIiEhAREREfj000+xaNEi9kzQCxcu4OrVqwgPD0deXh4iIiIQHx+PqKgo/PTTT5gyZQoSExPh4uKCAwcOwNHRERqNBhMmTMDu3bsxY8YMfPvtt0hJSWFnxUaNGmX0/NLSUkilUmg0Gty6dQsrV65EYGCgSWPX+/bbb3H79m32GWPGjDH6fP/9739x6tQpiMVinD59GrNmzWr2WToK0AghpI1Qq9XIKyoCALg4OcG+Cep6eRkkHeQVFqFLSAjnz2hphcUy5BUWt/QwEBcXB6lUCrVajcWLF2PVqlVYu3Yt9u7di0uXLrGFzA2XCkeMGIFly5ZhypQpGDlyZKNF2pvC4MGDERERAUB3juebb77JjnHw4MHs0umFCxcQFRWFqKgoALozRl988UVkZmbCzc0Nq1atwpkzZ8AwDPLy8tCjRw/MmDEDx48fxzPPPAORSAQAmD9/Pr7//nv2+folTgAoKirCiBEj0K9fP8TGxpr8GY4fP445c+awezjnzp2LzZs3AwD27duHa9euseeA6p9TWVkJOzs7S75lFqEAjRBC2oi8oiJ2GcinCWbPAN0+NMPntUfurk17SoK5/QuFQkyePBkrVqzA2rVrwTAMXnvtNSxatKjWvZ9//jkSExNx4sQJzJ07F7Nnz8bKlSu5GrrVHE2ccf3888+Rl5eHCxcuwNbWFsuXL0dVVVWd9/J4vHr7cXNzwxNPPIGjR48iNjYWQqHQKKCtqqoyaUyGz2AYBnPnzsVHH31k0mdpKhSgEUJIG5FbWMi+1tcs45qdrS2cHBxQWl6O/OqAkM9vX9uVTVl+bG5//vknO/M0ceJErF27FlOmTIGbmxtUKhVu3LiB6OhoJCcnIzIyEpGRkRAKhezSokQigUxm2bLtw20zMzMxYsSIehMHzp8/j+TkZHTr1g2bN29GTEwMBNXJJYYGDhyI69ev48aNG+jRowd27doFf39/+Pv7o7i4GD4+PrC1tUVOTg727NmDyZMnAwAef/xx7NixA7NmzQLDMNiyZUu9Y1coFDh79iymT58OAOjcuTMuXrwIAOy5188880ytdo899hh27tyJWbNmAQC2bdvGvhcbG4vZs2fjueeeQ1BQELRaLa5cuYK+ffs29q3kFAVohBDSRuQX1sxoGc50cc3LzQ2l5eVQazQolsvh/tB5xYQb+j1oarUawcHB+OabbwDolgILCwsRExMDQLe0PX/+fERHR+P1119HSkoKRCIR7O3tsXHjRgC6pcZXX30V69atw0cffWS0p6oxD7f18PCAUFh/eDB48GCsWrUKd+7cgbu7u1FwY8jT0xM//fQTnnnmGajVari6umLPnj3g8XjsMm1kZCT8/PzwuMFxZQsXLsSNGzfQvXt3uLq6YujQofj777/Z9/V70ABdgBYTE4Pnn3+e/SxTpkxBREQEwsLCMHDgwDrHtnjxYly/fp19Rt++fZFVfRbt0KFD8emnn2LSpElQq9VQKpUYO3ZsswdodBZnG0NncRLSce3YfwDysjIIBQIsmDqlyWa2riYl4XyCLmstZsAARHQKa5LnNAc6i9N8n332GXx9fTFnzpyWHkqTKi0thZOTE1QqFWbPno0+ffpg1apVVvfL1Z85mkEjhJA2oEqpZMteeLi6Numyo1GiQFFhmw7QiPlWrFjR0kNoFo8//jgUCgWqqqrwyCOP4KWXXmrpIRmhAI0QQtqAfIMN+55NuLz5cP95he0zUYCQCxcutPQQGtS+dn4SQkg7ZbT/zL1pAzSRjQ1cqgt/FpaUNFlFeEJI/ShAI4SQNiCvGWfQgJokBK1Wi4KSkiZ/HiHEGAVohBDSBuiXOG2EQrg4OTX58wz3oeXTMichzY4CNEIIaeUqq6pQWl4OAPB0a9oEAT1Pt5pzIQuKW77qPiEdDQVohBDSyjX38iYAo9pntMRJSPOzKItTX7HXGlOnTsWUKVOs7ocQQtq75ipQa0hkYwOJoyPkZWUoKilplycKtKSQkBCIxWLY2dlBoVAgOjoa3333HRwcHCzqb+vWrRg4cCC6detW5/t//fUXFi5cCKFQiDVr1mD9+vVYt24dwsPDG23bkIMHD+Lf//434uPjcfnyZXz22WeIi4trcJx79+7F3r17zX5WR2PR37acnByUlpaCYRiL/svNzUVZdT0fQgghDSsoqVli9GimAA2omUVTazRsDTbCnbi4OCQkJCAxMREymQxbt261uK+tW7fWezQTAPz444+YNWsWrl69ilGjRuHQoUNssfPG2pqqb9++DQZnxDwW10GbNm0a5s2bZ1HbYcOGWfpYQgjpcAqKSwAAQoEAziYeRs0FD1cX3M/IAKArt6EvvUG4pVQqUVFRAVfXmn1///73v7F7926o1Wp4eXlh06ZNCA4OxoEDB/DGG2+Az+dDrVbjww8/RH5+Pi5fvoxXXnkF77zzTq2jntasWYO4uDjY2dkhLi4O8fHxkEql2Lt3Ly5fvtxg24epVCosW7YMv//+O3sMk158fDxefvllJCQkID8/H7Nnz0Z2djZ4PB769OlT60zNrKwsTJgwAc8//zzmz5/P4Xe0faBCtYQQ0oopVSp29srNxaVZlxmN9qEVl6BTUFCzPbsp7TlyFBWVlU3Wv72dHaaOHtXoffqzOFNTU9GnTx9MmzYNALBz506kpKTg/PnzEAgE2L59O1544QX89ttvePPNN7Fp0yYMGjQIWq0WcrkcLi4u2LFjB15++WVMnDix1nNWr16N5ORkSKVSvPzyy0bvLViwoMG2D/v222+RkpKCxMREAMCoUXV/zh07diA0NJQ9zL2oyDgT+Pr165gxYwbWrVuHkSNHNvrcjsiiAG379u1wdna2+KHWtieEkI6iqETGvvZo5kPL3Q1mdArbUaJARWUlypswQDNVXFwcpFIp1Go1Fi9ejFWrVmHt2rXYu3cvLl26hD59+gCAUaHgESNGsAeNjxw5kj00vLkcP34czzzzDEQiEQBg/vz5+P7772vdN3DgQKxbtw6vvvoqHn30UYwePZp9LzExEbGxsdi7dy969erVbGNvayz6VSwoKMiqAMva9oQQ0lEY7j9zd3Vp1mdLHBxgI9T9Ht+eAjR7Ozs4NOF/9nZ2Zo1HKBRi8uTJOHLkCACAYRi89tprSEhIQEJCAq5fv47r168DAD7//HNs2bIF9vb2mDt3Lj799FPOvz/m4PF4dV4fNGgQEhISMGDAAPz666/o168fG2j6+fnB29sbf/75Z3MOtc2hJU5CCGnFDAMj92aeQePxeHB3cUFOQQFKy8uhUCohrp45actMWX5sbn/++Se7aX/ixIlYu3YtpkyZAjc3N6hUKty4cQPR0dFITk5GZGQkIiMjIRQK2SVEiUQCmUzW0CPq9XDbzMxMjBgxos7Egccffxw7duzArFmzwDBMrX1levfv34e/vz+mTZuG0aNHw8vLi00OdHV1xfbt2zFu3DiUlpbirbfesmjc7R2nmxlKS0vZ3wAIIYRYr7A6QQBo/gDt4We2p1m01mD69OmQSqXo0aMHbt68ifXr1wMAZs+ejXnz5iEmJga9evWCVCplZ5tef/11REZGIjo6Gtu3b8c777wDAFi0aBE++ugjSKVSHDp0yKxxPNw2MzMTQmHd8zcLFy5Ely5d0L17dzzyyCP1LrHGx8ejT58+kEqlGDx4MD777DOjlTMnJyccOXIE586dw4oVK8wab0fBYxiG4aqzO3fuYMGCBYiPj+eqS/KQlJQULFy4EN999x372xYhpH1iGAab9/wMlVoNJwcHPD0httnHcOP2bZy6dBkAMLRvH0R17drsY7BGVVUV7t+/j9DQUNja2rb0cNqEzz77DL6+vpgzZ05LD6VN4urPnFlLnLm5uQ2+X1BQYPFACCGEGJOXl0OlVgNomdmzh59rOJtH2i+a0WodzArQpk2bVu+GQED3215D7xNCCDFdocEZmB7NnCCgR0uchLQMswI0JycnPPvss/WuOaelpbHr4YQQQqxTYLT/zLX+G5uQyMYGTg4OKC0vR7FcTr+IE9JMzArQunbtitLSUoSGhtb5vkajAYdb2gghpENryQxOQ64SCUrLy6FUqVBeWQlHe/sWG4ultFptSw+BdBBcxUFmBWgTJ05EVVVVve97e3tj9erVVg+KEEJITYAmFAjg7NR8Rzw9zNXZGQ+yswEAxTJZmwrQRCIR+Hw+srKy4OnpCZFIRDOApMkwDIP8/HzweDzY2NhY1ZdZAdqjjz7a4PtOTk548sknrRoQIYQQQKVWs0c8uTo7t2hQ4eZccwZnkUyOQF/fFhuLufh8PkJDQ5GdnY2srKyWHg7pAHg8HgICAiAQCKzqhwrVEkJIK1Qil7Ov3Vr45BVXg+cXyy0rhtqSRCIRgoKCoFarjY5NIqQp2NjYWB2cARwEaMOHD8f27dsRGBho9WAIIYToFBlUdm/xAE1SM4NWLJM3cGfrpV9ysnbZiZDmYvVJApQUQAgh3GtNAZpYJIJD9fmSRTIZ/dwnpBlwetQTIYQQbhSVGARoLi0boAE1y5wKpRKVDSSLEUK4QQEaIYS0QsXVe9BshMJWkTVpmChQLG+by5yEtCUUoBFCSCvTmjI49QwTBQyXXwkhTYMCNEIIaWWKjTI4JQ3c2XzcJAaZnG00UYCQtoQCNEIIaWUM95+5tnCCgJ6rUS00mkEjpKlRgEYIIa1McSvK4NSzFYthZ2sLwHh8hJCmYXWANmvWLEgkrWMKnhBC2oPWVGLDkH65tVKhQJVC0cKjIaR9szpAW7x4MZxb0Q8QQghp6/QBWmvJ4NRzcaJMTkKai8UBmlKp5HIchBBCoMvgLC0vB6CbPWsNGZx6LhIn9nWJvLQFR0JI+2dxgDZp0iSsW7cOKSkpXI6HEEI6NMMzOF1bSQannovBdpaSUppBI6QpWXwWp1KpxN69e7Fv3z506tQJY8eOxRNPPAEnJ6fGGxNCCKmTYQkL11a2v9coQKMZNEKalMUzaPv27cPy5csRHh6OO3fu4Msvv8RTTz2F9957D3///TeXYySEkA7DcG+Xq6R17e91sreHgK/7Z4Nm0AhpWhbPoNnb22PChAmYMGECUlNT8dtvv+H333/H8ePH8eeff8LLywtjx47F6NGj4e3tzeWYCSGk3TIM0Fxa2Qwan8+Hs5MTimQyyErLoNVqwedTtSZCmgInf7NCQkLw4osv4pdffsEHH3yAgQMHoqCgAD/88ANmzJiBFStWID4+Hmq1movHEUJIu6Xfg8bn8yFxdGjh0dSmTxTQarVsMgMhhHsWz6DVRSAQYOjQoRg6dCiKiopw9OhRHDp0CBcvXsSlS5cgkUiwf/9+Lh9JCCHthlarRUmpbm+Xi5NTq5ydMiy1USIvhTPtOyakSTTZ3343NzfMnDkT77zzDqKiosAwDORUN4cQQuolLyuHVqsF0PqWN/WMSm3QPjRCmgynM2h6FRUV+P333/Hbb7/h1q1bYBgGtra2iImJaYrHEUJIu2BUYqPVBmiGxWopk5OQpsJpgHblyhUcOnQIp0+fhkKhAMMw6N69O8aOHYvHHnsM9hxUxFYqlfj+++9x7NgxlJaWolOnTliwYAH69evXaNv8/Hxs2LABly5dglarRXR0NJYuXQo/P79a9x48eBC7du1CTk4OPD09MWXKFEyePNmqPvX++ecfLFmyBACwf/9+uLi4mP4NIIS0W8VtLEAroVURQpqM1QFaXl4eDh8+jMOHDyMnJwcMw8DFxQWxsbEYO3YsQkJCOBhmjY8//hjx8fGYOnUqAgICcPjwYaxcuRLr169Hz549621XUVGBZcuWoby8HHPmzIFQKMTu3buxdOlS/PDDD0bHVe3btw9r167FsGHDMH36dPzzzz9Yv349qqqqMHv2bIv61NNqtVi/fj3s7OxQWVnJ6feGENK2FctrzuBsbUVq9WxFItiJxahUKNj9coQQ7lkcoB0/fhyHDh3ClStX2FTrfv36YezYsXjkkUcgFHK/epqUlITjx4/j+eefx8yZMwEAo0aNwrx587Bx40Zs3Lix3rZ79+5FRkYGNm3ahIiICADAgAEDMG/ePMTFxWHRokUAAIVCgc2bN2PQoEF4//33AQDjx4+HVqvFtm3bEBsbyxbjNbVPQwcOHEBeXh7Gjh2Ln3/+mbtvDiGkzTNcMmyte9AA3dgq8/NRUVkJpUoFkY1NSw+JkHbH4iSB9957D5cvX4a3tzfmz5+PuLg4fPbZZxg+fHiTBGcAcPLkSQgEAsTGxrLXxGIxxo4di8TEROTm5tbbNj4+Ht26dWMDKQAIDg5G7969ceLECfbalStXIJPJMHHiRKP2kyZNQmVlJc6fP292n3pyuRybN2/G/Pnz4ejoaNZnJ4S0bwzDsEuGjvb2sGmin6NcMD6Tk5Y5CWkKFgdoI0aMwOeff45du3Zh7ty58PLy4nJcdbp9+zYCAgLg4GBcG0gfIN25c6fOdlqtFvfu3UO3bt1qvRcREYHMzExUVFSwzwBQ697w8HDw+XzcunXL7D71Nm/eDDc3N6MAszEFBQVISUlh/0tLSzO5LSGk7aisqoJCqQTQevef6RmW2pDRMichTcLiX9HeeustLsdhksLCQri7u9e6rr9WUFBQZzu5XA6lUtlo26CgIBQWFkIgEMDV1dXoPhsbG0gkEhQWFprdJwDcvXsXBw4cwCeffAKBQGDqR8b+/fuxdetWk+8nhLRNbWV5EwCcnWpWAGSlZS04EkLaL87m0NVqNX799Vf88ccfePDgARQKBbvMd/v2bRw4cABTp05FYGCgxc9QKBSwqWOvg0gkYt+vrx0Ak9oqFIp6l2hFIpHRfab2CQDr16/HgAED0L9//zr7rk9sbCyGDBnCfp2WloYPPvjArD4IIa2frLT1Z3DqGRanlZXRDBohTYGTAE2hUODVV1/FjRs34OzsDAcHB1RVVbHv+/r64tChQ3BycsLChQstfo5YLIZKpap1XVm9LCAWi+ttB8CktmKxuN4jqZRKpdF9pvZ5/Phx3LhxAz/++GM9n6x+Hh4e8PDwMLsdIaRtkZXVzERJnFr3HlWJI82gEdLUODlJYPv27bh+/ToWLVqEvXv3YuzYsUbvOzo6QiqV4tKlS1Y9x93dnV1iNKS/Vl8gI5FIIBKJTGrr7u4OjUaD4uJio/tUKhXkcjm7fGlOnxs3bmSTJ7Kzs5GdnY2y6h/GeXl59S7NEkI6DrlBgObcypOIbIRCONjZAaAZNEKaCiczaH/++Seio6Mxa9YsAACPx6t1j5+fH7sB31KdO3fG1atXUV5ebpQokJSUxL5fFz6fj7CwMCQnJ9d6LykpCX5+fmwR3S5dugAAkpOTMWjQIPa+5ORkaLVa9n1z+szLy8Mff/yBP/74o9a9CxYsQOfOnfHDDz+Y9D0ghLRP8uqZKB6PB0eH1ndI+sOcnZxQXlmJyioFldogpAlwMoOWl5eH8PDwBu+xs7NDeXm5Vc8ZPnw4NBqN0YHrSqUShw4dQvfu3eHt7Q0AyM3NrZXtOGzYMCQnJxsFVA8ePMDVq1cxfPhw9lrv3r0hkUiwb98+o/b79u2Dra2tUdBmap8ffvhhrf8ee+wxAMAbb7zBnipACOmYGIZhlzid7O0haIWHpD/MOFGAZtEI4RonM2h2dnYoKSlp8J6srKw6K+ubo3v37oiJicG3336LkpIS+Pv748iRI8jJycGqVavY+z788EMkJCTg1KlT7LVJkybh4MGDWLVqFWbMmAGBQIDdu3fD1dUVM2bMYO8Ti8V49tlnsW7dOrz11lvo378/rl27hmPHjmHhwoWQGGzeNbXPoUOH1vos+tnEAQMG0FFPhHRwCqUSyur9rK19/5mes6NBokBpGTzd3FpwNIS0P5wEaJGRkTh37hxKS0vZKvuGcnNz8ddff9UZqJjr9ddfh7e3N44ePYqysjKEhYXhk08+gVQqbbCdvb091q9fjw0bNmDbtm3suZlLliypFSBNmjQJQqEQcXFxOHv2LLy8vLBkyRJMnTrV4j4JIaQ+RgkCrXz/mZ7RDBrtQyOEczyGYRhrO0lISMDLL7+Mzp07Y9myZbhw4QJ27NiBI0eOIDExEV988QUyMzOxcePGRpdCScNSUlKwcOFCfPfdd/S9JKSduJ2aht/PnQMADJL2QnT37i08osYVFBdj9+EjAIBuYaF4bODAFh4RIe0LJzNoUqkUL7/8Mr788kssXbqUvT569GgAug31y5cvp4CCEELqYDyDVnsVojVyplIbhDQpzgrVTpw4EVKpFPv27cPNmzchl8vh4OCAiIgITJo0CaGhoVw9ihBC2hWjEhttZA+ajY0N7G1tUVFVRUkChDQBTk/jDQkJwbJly+p9X6PRmHXMESGEdATyNrgHDdCV2qioqkJFVRVUKlWdJ6sQQizDSS73r7/+2ug9Go0G7777LhePI4SQdkW/xGkrFrepemLGiQK0zEkIlzgJ0L788kvEx8fX+75Wq8W7775rVPaCEEIIoNZoUF5RAaD1nyDwMMlDpTYIIdzhJECLiorCBx98gCtXrtR6Tx+cnTx5EpMmTeLicYQQ0m6UltUU8G5Ly5sAldogpClxEqCtWbMGgYGBePPNN42Oc9JqtXj//fcRHx+PiRMnNrg/jRBCOiLDwKatBWguToYzaBSgEcIlTgI0BwcH/Pvf/4ajoyNWrFiBrKwsMAyD9957D3/++ScmTJiAV155hYtHEUJIu9IWMzj1JFRqg5Amw9mBb+7u7li7di20Wi1effVVvP322zhx4gTGjRuH5cuXc/UYQghpV9pqBicAiEUi2InFAGgGjRCucXoib2BgID799FMUFxfj1KlTGDduHFasWMHlIwghpF0xnHlqawEaAEiqlznLKyuhUqtbeDSEtB8W1UHbunVrg+9HRETgzp07cHd3N7qXx+Nh7ty5ljySEELaJf0MmkAggIOdXQuPxnzOjo7ILSgAoPss7nQOMSGcsChA27Jli0n3/fjjj0ZfU4BGCCE1GIZhAzSJowN4PF4Lj8h8zk7GpTYoQCOEGxYFaOvXr+d6HIQQ0uGUV1ZCo9UCAJzbyBmcD3MxLLVB+9AI4YxFAZpUKuV4GIQQ0vEYJwg4tOBILCcxnEGjWmiEcIbTJAFCCCGmM04QaJszaA8vcRJCuEEBGiGEtBCjGmhtMIMTAGxFIohFIgC0xEkIlyhAI4SQFtKWa6AZ0s+ilVVUQK3RtPBoCGkfKEAjhJAWImsHe9AA4xMQDINOQojlKEAjhJAWIq/eVO9obw+BQNDCo7GcYQYqLXMSwg0K0AghpAUolEpUKZQA2vbyJmA8g0aJAoRwgwI0QghpAe1l/xnwUCYnldoghBMUoBFCSAswyuB0auMBGi1xEsI5TgO00tJSHDlyhMsuCSGkXZK1oxk0W7EIIhsbAICcljgJ4QSnAVpubi7WrFnDZZeEENIutYcaaHo8Ho/9DKUVFezxVYQQy5l11FNubm6D7xcUFFg1GEII6Sjkpe1nBg0AJE6OyC8uBsMwKCsvN9qXRggxn1kB2rRp08Dj8ep9n2GYBt8nhBCio1/iFNvYwFYsbuHRWM8wyJSVllGARoiVzArQnJyc8Oyzz9Z7WHpaWhreeecdDoZFCCHtl0ajQVlFBQDjw8bbMsNlWipWS4j1zArQunbtitLSUoSGhtb5vkajAcMwnAyMEELaq7KKCvZnZVs+QcCQ0QwaldogxGpmBWgTJ05EVVVVve97e3tj9erVVg+KEELaM1k7238GGNdCk5eVt+BICGkfzArQHn300Qbfd3JywpNPPmnVgAghpL0zzuBsuiVOrVaLq4m3cDT+PK5cT8GQfr3w/DOTYSsWcf4sBzs78Pl8aLVamkEjhANmBWiEEEKsJ2uGIrVarRYrPvgSp/66yl5Ly8jGX1eu44OVz6FLaBCnz+Pz+ZA4OKCktBTysnJKGiPESlbXQRs+fDjS09O5GAshhHQIzXHM08E/zhgFZ3r30jKxcMVHyM7lviyS/rOo1WpUNrAdhhDSOKsDNEoKIIQQ8+iXAPl8Phzs7Djvv7yiEv/58Wf261UvPoMfv3gHXcKC2Pe3/XyI8+caHZpOmZyEWIXO4iSEkGbEMAy7iV7i4AA+n/sfw1t3H0RRsQwAEDO4L6aMHYHuXUOx8eNVsLPV1Vw78PspFFbfw5WHa6ERQixHARohhDSjyqoqqNVqAE2zvJmTX4id/zsKALARCvHSs9PY95ydHDHpyRgAgEKpwn/3HuX02YYJD1QLjRDrUIBGCCHNqKkPST8W/xeUKhUAYPqEJxDg6230/uxJoyAUCgAAP//2J8rKKzh7tsSJaqERwhUK0AghpBnJmziD8/jZS+zryWNiar3v5eGGsSMeAaDbi7b/99OcPVviUFN0V05LnIRYhQI0QghpRk1ZpDY7twBJt+4DALqGBdWaPdObOXEk+/p0HZmelhIKhWzSAy1xEmIdCtAIIaQZNWWJjRPnLrOvRzzSr977woL84e/jCQC4mniL22XO6s9UqVCwS62EEPNZHaDNmjULEomEi7EQQki715QB2vEzNcubjw3pW+99PB4Pj/SXAtCdoXzxaiJnYzBctqVZNEIsZ3WAtnjxYjg7O3MxFkIIaff0SQL2dnawEXJ3mEteQRH+uXkHABAW7I+QQL8G7x/ctyf7+syla5yNw/jQdArQCLFUky5xMgyD9PR05ObmNuVjCCGkTVAZVNh35nj2LP78Ffb1iCH1L2/q9enZjT2T8+zlf6DVajkZh+HnokQBQizHSYB28uRJfPjhhygtrUmrzs7Oxrx58/D0009j+vTpeOedd6DRaLh4HCGEtEnGy5sODdxpvksJNcuUwwb1bvR+sUiEftLuAICiYhmS76RxMg6JQS00mkEjxHKcBGj79u3D7du34eRU8xdzw4YNSE1NRXR0NDp16oT4+HgcOsT90SKEENJWGGdwOjVwp3kYhkFC4u3qfh3QJTTQpHaP9JOyr89e5maZ03gPGtVCI8RSnARoqampiIiIYL+uqKjA+fPn8dhjj2HdunXYtGkTgoODKUAjhHRohgELl0ucaZk5KJHr+u7ZvYvJx0cN7lezD+3ClRucjEUsEkFkYwOAljgJsQYnAZpcLoebmxv79T///AONRoMRI0YA0NXG6du3LzIzM7l4HCGEtEn6MzgB46r71kq4kcK+lkZ2Nbmdj6c7Any9AADJd1LZI6iswePx2OCztKICGo72thHS0XASoDk4OEAul7NfX716FXw+H7169WKvCYVCVFVvjiWEkI7I8PgjLktsJCTdZl+bE6ABQGR4JwC6szlv30/nZDz64JNhGJSVlzdyNyGkLpwEaEFBQTh37hxkMhlKS0vxxx9/oGvXrkZ70nJycuDq6srF4wghpE3SL/nZCIWwE4s561c/gyaysUFElxCz2kZ168S+vp58l5PxGJXaoGVOQizCSYA2efJkFBQUYPLkyZg6dSoKCwsxceJEo3uSkpLQuXNnLh5HCCFtjlarRWn1bJLE0RE8Ho+TfvMLi5GZkw8AiOwayu7/MlUPgwDtBkcBmlGpDcrkJMQinFRJHD58OF555RX89ttvAIDHHnsMTz75JPt+QkICysvL0b9/fy4eRwghbU5ZRQW0DAOA2+XNa4bLmz3CzW7fNTQIIhsbKFUqJKY0wQwaZXISYhHOylhPnDix1qyZnlQqpQxOQkiHZjiT5MxlgkDiLfZ1r+5dzG5vYyNEeOdgXL95Bw+yclEiL4OLxLrxORtsb6EZNEIsQ4elE0JIM5A10Rmc/1TPoPF4PIsCNACICq9Z5uRiFs3Bzo4t9UF70AixDAVohBDSDIxm0DgK0NRqNe6kZgAAQgJ84ehgb1E/PThOFODz+ZA46E5KkJeVgale2iWEmI4CNEIIaQbyUu5n0O49yIKqunZZ107BFvfTg+MZNKDmM6o1Gvb8UUKI6Tjbg9ZclEolvv/+exw7dgylpaXo1KkTFixYgH79Gj8cOD8/Hxs2bMClS5eg1WoRHR2NpUuXws/Pr9a9Bw8exK5du5CTkwNPT09MmTIFkydPtqhPhUKBdevW4ebNm8jLy4NWq4Wfnx/GjBmDSZMmQShsc/83EELMpF/i5PF4cHTg5hzOlLs152eGdwqyuB8fL3e4uzqjsFiGGyn3oNVqTT6NoD7OTo5Atu61rKwM9nZ2VvVHSEfT5mbQPv74Y+zevRtPPPEEXnrpJfD5fKxcuRL//PNPg+0qKiqwbNkyJCQkYM6cOZg/fz5u376NpUuXQiaTGd27b98+fPrppwgNDcWyZcvQo0cPrF+/Hj/99JNFfSoUCqSmpmLgwIFYtGgRXnjhBXTu3BkbNmzARx99xN03hxDSKjEMwy5xOjk4QGBl8KNnHKBZPoPG4/HQvWsoAKCsvALZeYVWj41qoRFinTY1dZOUlITjx4/j+eefx8yZMwEAo0aNwrx587Bx40Zs3Lix3rZ79+5FRkYGNm3axJ4bOmDAAMybNw9xcXFYtGgRAF0wtXnzZgwaNAjvv/8+AGD8+PHQarXYtm0bYmNj2QK8pvYpkUjwzTffGI1nwoQJcHBwwK+//ooXX3wR7u7uHH6nCCGtiUKphFKlAqA7zJwrtzgK0ACgS0ggTl9IAADcSU2Hv4+nVf05O1ImJyHWaFMzaCdPnoRAIEBsbCx7TSwWY+zYsUhMTERubm69bePj49GtWzejQ92Dg4PRu3dvnDhxgr125coVyGSyWiVDJk2ahMrKSpw/f97sPuvj4+MDACijH16EtGsyo/1nTg3caTqtVotb9x4A0J2paW3pjk4hgezrOxwc+WR41ijVQiPEfG0qQLt9+zYCAgLg8ND+DX2AdOfOnTrbabVa3Lt3D926dav1XkREBDIzM1FRUcE+A0Cte8PDw8Hn83Hr1i2z+9RTqVQoKSlBbm4uTp06hV27dsHHxwf+/v6mfHxCSBslNwhQuMrgzMzJR3mlbvO9tbNnANAllOMAzeDntJyWOAkxm9lLnFqtFqmpqZBIJPDw8DB6T61W48aNG5BKpVyNz0hhYWGdS4H6awUFBXW2k8vlUCqVjbYNCgpCYWEhBAJBrXNDbWxsIJFIUFhYaHafeqdOncK7777Lft2tWzesWrWqwSSBgoIC9pkAkJaWVu+9hJDWyagGGkdFarlKENAL9PdmTxS4XV26wxpCoRAOdnYor6ykJU5CLGBWgJaTk4OVK1ciLS0NPB4PAwcOxGuvvQZnZ2cAuqDl5ZdfRnx8fFOMFQqFAjZ1nDMnEonY9+trB8CktgqFot6ASSQSGd1nap960dHR+Pzzz1FWVoa///4bd+7cQVUj6ef79+/H1q1bG7yHENK6GS5xcjWDZhigdQ2zfgZNKBAgLNgPyXfSkJ6VgyqFErZikVV9ShwdUV5ZiUqFAkqVyuxzQgnpyMxa4ty4cSM8PDywa9cufPfdd1AoFHjxxReNZq6asiChWCyGqnqjrSGlUsm+X187ACa1FYvFUFfXFarrXsP7TO1Tz83NDX379sXw4cPx6quvYvDgwVi+fLnRDNnDYmNj8d1337H/vfnmm/XeSwhpnZqiSC1XGZyG9PvQtFoG9x9kWt2f4b44mkUjxDxmBWjXrl3DCy+8AF9fX3Tp0gVr165Fz549sWTJEnaDPo/Ha5KBArqlw7qCGf21h5dc9SQSCUQikUlt3d3dodFoUFxcbHSfSqWCXC5nly/N6bM+w4cPR2VlJc6cOVPvPR4eHggPD2f/Cw7m5gcxIaT5yEp1e9DsbW3rnHW3REp1goCzkwO8Pd046bOLQaLAbS72oVGpDUIsZlaAVlVVZfTDRV+DrF+/fli6dCkyM63/jashnTt3RkZGBsrLy42uJyUlse/Xhc/nIywsDMnJybXeS0pKgp+fH+ztdUekdOmiO8vu4XuTk5Oh1WrZ983psz76JdCHPw8hpP1QqdWoqN7KwNX+s8JiGYqKdbUWu3YK5uwX486GiQKp1gdohrOFcsrkJMQsZgVoQUFBSElJqXX91VdfxcCBA7F69WrOBlaX4cOHQ6PRYP/+/ew1pVKJQ4cOoXv37vD29gYA5Obm1tpMP2zYMCQnJxsFVA8ePMDVq1cxfPhw9lrv3r0hkUiwb98+o/b79u2Dra0tBg0aZHafJSUldS79Hjx4EIAuQ5QQ0j7pZ88A49pg1riXVvPLcKfgAE76BIwzOW/ftz5RwLCkiKyMfhElxBxmJQk8+uij+P333zFy5Mha7y1fvhwAagU2XOrevTtiYmLw7bffoqSkBP7+/jhy5AhycnKwatUq9r4PP/wQCQkJOHXqFHtt0qRJOHjwIFatWoUZM2ZAIBBg9+7dcHV1xYwZM9j7xGIxnn32Waxbtw5vvfUW+vfvj2vXruHYsWNYuHAhJBKJ2X0eO3YM+/fvxyOPPAI/Pz9UVFTg4sWLuHz5MgYPHow+ffo02feMENKymmL/2f30mgAtLJi7Mj1uLhK4uUhQVCLHnfvpYBjGqtk54z1oNINGiDnMCtDmzJmDOXPm1Pv+8uXL2UCtqbz++uvw9vbG0aNHUVZWhrCwMHzyySeNlvawt7fH+vXrsWHDBmzbto09N3PJkiVwcXExuld/PmZcXBzOnj0LLy8vLFmyBFOnTrWoz549eyIxMRHHjx9HcXExBAIBAgMDsWTJEjz11FMcfWcIIa2RYYkNa4vJ6hnOoIUFcVtHsXNIIC4mJKJEXorCYhk83Fws7kssErGlO6gWGiHmaVNHPQG6Ga4XXngBL7zwQr33fPnll3Ve9/LywnvvvWfSc8aPH4/x48c3ep8pfXbr1s2o/hkhpONoilME7j3IYl+HBflx0qde51BdgAYAd1MzrArQeDwenB0dkV9cjNKKCmi0Ws7OISWkvbP6b8rw4cORnm79ZlJCCGmPjE4R4GAGjWEY3KsugeHp7gInDs/2BIwDvtSMbKv70ydGMAyDMkqIIsRkVgdoTVn3jBBC2jr9DJrYxga29dRqNEexrBQyua7P0EDuj4kLCfBlX6emcxCgUakNQixCc82EENJENBoNyqrP5JU4cZ/ByWWCgF5wILczaMalNihAI8RUFKARQkgTKS0vZ1cZuMrgvGdQ4T+U4/1nAOAicYSLRBdMpmVkNXJ344xm0CiTkxCTUYBGCCFNpCkOSTcM0DpxnMGpFxKoW+bMLyxBWXmFVX05G8wc0gwaIaajAI0QQpqI8SHp3Cxx3jfI4AxtogAt2GAfWpqVy5wOdnbgV2du0h40QkxHARohhDQRrjM4gZo9aB5uLpA4cZvBqaefQQOs34fG5/MhcdCNU15WRollhJiIAjRCCGkixjNo1gdoxTI5SuS6oK8p9p/pNVUmp1qjQWX1uaSEkIZZHaDNmjXL6PgjQgghOvo9aEKBAPZ2dlb315QnCBgK4TqT08kwUYCWOQkxhdUB2uLFi+Hs7MzFWAghpN3QarXspniJo6NVZ1rqGc5mhQY23Qyar5cHRDY2AIA0qoVGSIugJU5CCGkC5ZWV0Gq1ALjbf5aWWRMsGW7k55pAwEeQvzcAID07F2q12qr+DBMkKJOTENNQgEYIIU3AMBDh6gzOtIwc9nVwgA8nfdZHvw9NrdYgIyffqr4kTlQLjRBzcXpYukajQX5+PgoKCur9jUsqlXL5SEIIaZVkpdxncOpLXtjb2Vp1iLkpDE8USEvPNkocMJc+ixMA5LTESYhJOAnQtFottm/fjp9//hmlpQ3/dhQfH8/FIwkhpFUz3AzPRQanUqVCdl4BACDY34eTPW0NMcrkzMjGMCv6EgqFcLCzQ3llJS1xEmIiTgK0TZs2YdeuXXB1dcWTTz4Jd3d3CAQCLromhJA2yXAzPBfncKZn5UKr1dUQC2rC/Wd6hkuo6Zk5DdxpGomjI8orK1GpUECpUrFJCISQunESoB09ehSBgYH49ttvYW9vz0WXhBDSpumL1PJ5PDhx8HOxOfefAUCArxf7Oj07z+r+nJ0ckZ2v28smLyuDh6ur1X0S0p5xkiRQWVmJQYMGUXBGCCEAGIZhZ9CcHBzYo46sYXjkUrB/08+gOTk6sIemZ2TlWt0fldogxDycBGhhYWEoLCzkoitCCGnzKhUKqKoTpZw5WN4EgLTM5p1BA4BAP90sWl5hMaqqFFb1ZbgPT06ZnIQ0ipMA7ZlnnsHp06eRkpLCRXeEENKmGWZwSjhIEACABwYzaEH+zROgBfh6s6+tLrVhUGqEThMgpHGc7EEbNGgQXnvtNaxcuRJDhgxBp06d4OBQ9yG+o0eP5uKRhBDSahlmKnJRYoNhGHYPmpeHG+xsxVb3aQr9DBqgW+bsHBJgcV+G3wfK5CSkcZwEaEqlEufOnYNMJsNvv/0GALVSwBmGAY/HowCNENLuGR+Sbv0SZ4m8FPKycgDNt7wJAAF+NTNo6dnW7UMTi0QQ2dhAqVJRLTRCTMBJgLZhwwb8/vvv6NSpE4YNG0ZlNgghHZphtXwJBzNoRhmczZAgoBdouMSZZV0mJ4/Hg7OjI/KLi1FaUQGNVgsBB8kThLRXnARo8fHxCA8Px9dffw2hkNPDCQghpM0xnCHiYg/agxZIEAC4nUEDdMFqfnExGIZBWXk5ZwkUhLRHnPz6olQqER0dTcEZIYSgZgbNwd4eQg5WE4xKbDRDkVo9ZycHODnqyidZO4MGUKkNQszBSYAWHh6OjIwMLroihJA2rUqhQJVCCQBw5WiG6IFBHbLmyuAEdMuS+kzOnPxCKFUqq/oz3I9HiQKENIyTAG3hwoW4ePEizp07x0V3hBDSZpUYHpIu4SZAS8/UBWhCoQA+nu6c9GkqfSYnwzDIsrrURk12v4xqoRHSIE7WJC9fvgypVIrXX38dvXv3rrfMBo/Hw9y5c7l4JCGEtEol8prAw4WDGTStVouM6v1f/j5eEAiad2O9YS209Kw8hAT6WdyX4Z4zmkEjpGGcBGhbtmxhX//999/4+++/67yPAjRCSHtXUipnX7s4SazuL6+wGAqlbmkx0GDTfnMJ5DBRwMHODnw+H1qtlvagEdIITgK09evXc9ENIYS0eTLDGTQOljj1y5sAENTCAZq1Z3Ly+XxIHBxQUloKeVkZWx+TEFIbJwGaVCrlohtCCGnz9HvQ+Hw+nOo5UcUchrNWgf4tPYPGTSZnSWkp1BoNKqqq4GBnZ3WfhLRHnGxmuH79OjZs2FDvgekFBQXYsGEDEhMTuXgcIYS0SgzDsOdwShwdweegEGu6wayVYeHY5uLq7AQHO1sA1s+gAQ8d+UTLnITUi5MALS4uDmfPnoW7e93ZRR4eHjh37hx2797NxeMIIaRVKquogFqjAcBNggBgvMTZEjNoPB6PLVibnVsAtVptVX9GtdAoUYCQenESoCUnJ6Nnz54N3tOrVy8kJSVx8ThCCGmVZKXc7j8DgAdZulMEbIRCeHs0b4kNvUBfXakNjVaLrNwCq/qiWmiEmIaTAK2kpAQeHh4N3uPm5obi4mIuHkcIIa2SYQ00rkpsZGbrao8F+DZ/iQ09oyOfrFzmNDyblGqhEVI/Tv62Ozo6Ii+v4c2jubm5sKPNoISQdqxEXlNiw5mLEhsFxWz1/pZY3tQzyuS0MlFAYpA4QXvQCKkfJwFa9+7dcerUKeTm1v2bVW5uLk6fPo0ePXpw8ThCCGmVSjgusaFf3gSMC8Y2t4DqJU7A+hk0oVDIZm7SEich9eMkQJs2bRoUCgVefPFFHDlyBAUFuj0KBQUFOHz4MF544QUolUpMnz6di8cRQkirpF/itBEKYW9ra3V/LV0DTY/LGTSgJpOzUqGw+nxPQtorzuqgvfjii/j666+xZs0aALrMH4Zh2NdLly6lemmEkHZLo9GgtLwcgG7/GRcFWFu6Bpqeh5sLxGIRFAql1TNogO7Ip6w83d66ktJSeLm5Wd0nIe0NJwEaAEydOhW9e/fGvn37kJycjLKyMjg6OiIiIgITJkxAWFgYV48ihJBWR15Wzv5Sytkh6VmGM2g+nPRpCR6Ph0BfL9xJzUBWbj7UGg2EAoHF/RkmUMjkcgrQCKkDZwEaAHTq1AnLly/nsktCCGkTuD6DE6hZ4hTZ2MDLw5WTPi0V4OeNO6kZUKs1yM0vgr+Pp8V9GSZQGGa+EkJqtEzONiGEtDMlHNdA02i07H4vf19PTk4lsIbhKQbWnihg+P0xTKwghNSgAI0QQjhglMHJQQ203IJCqKqr9rfk8qZegJ9BJme2dQGas6Mju0ePZtAIqRsFaIQQwgFZqWENNOsDtPSsmmzJlkwQYMfga1is1rpMToFAwB4kXyKXs3v3CCE1KEAjhBAO6GfQ7GxtIRaJrO4v3aAGWmALltioawwZVs6gATWzjCq1GpVVVVb3R0h7QwEaIYRYSalSoaI6yGiSQ9JbsEitnpeHK0Q2NgCsL1YLGM8y0jInIbVRgEYIIVbiOkEAAB5ktY4aaHp8Pp/N3MzMzodWq7WqP0oUIKRhFKARQoiVZHLDEhvcBGj6ZUSxyAZe7i1bYkNPnyigVKmQV1hsVV8uEsNSG/IG7iSkY6IAjRBCrGQ4g8bFIekajRaZ2bpK+wG+3i1eYkPP8EzOTCuPfDIMZGkGjZDaOCtUq1KpcPr0afYUgfqmv1evXs3VIwkhpFXg+pD0nPyaEhutYXlTzzBAy8jOQ5+eERb35WhvD4FAAI1GQ3vQCKkDJwFaTk4Oli9fjqysrAbTpXk8HgVohJB2Rx9g8Hg8ODs6Wt2fUQZnK0gQ0PP3MQ7QrMHj8eDs5IiiEhnk1b/Ut5aZQkJaA04CtK+++gqZmZkYOXIkxo4dC09PTwisOKeNEELaCoZhUFK9B83JwYGTn32trQaanr8vdwEaoDsSq6hEBq1Wi9Lyck7qxxHSXnASoF29ehV9+vTBG2+8wUV3hBDSZlRWVbHLkZyV2DCYQQtqBTXQ9Py8PcDj8cAwjNV70ICH9qGVllKARogBTuaTtVotunTpwkVXhBDSphgnCDRBDbRWFKCJbGzg7eEGAMjI4SBAo1IbhNSLkwCte/fuSEtL46IrQghpU0qaoMSGvgaaWCyCh5sLJ31yRZ8oUFpWAXlpuVV9uRhkvMooUYAQI5wscS5evBhLly5FfHw8hg8fzkWX9VIqlfj+++9x7NgxlJaWolOnTliwYAH69evXaNv8/Hxs2LABly5dglarRXR0NJYuXQo/P79a9x48eBC7du1CTk4OPD09MWXKFEyePNmiPnNzc3Ho0CGcP38eGRkZEAgECA0NxTPPPIO+ffta9w0hhLSoIllNgObqbH2JDbVGg6xcXYmNQF+vVrdx3t/XC5f/uQlAtw+tu1OoxX0Zz6BRLTRCDFkUoG3durXWtejoaLzzzjvo1asXunbtCofqg3AN8Xg8zJ0715JHsj7++GPEx8dj6tSpCAgIwOHDh7Fy5UqsX78ePXv2rLddRUUFli1bhvLycsyZMwdCoRC7d+/G0qVL8cMPP8DZ2Zm9d9++fVi7di2GDRuG6dOn459//sH69etRVVWF2bNnm93nmTNnsHPnTgwdOhSjR4+GRqPB0aNHsXz5cqxevRpjxoyx6ntCCGk5xXIZ+9rV4OeIpXLyCqFWawAAgX4+VvfHtYdLbXTvanmAZisWQywSQaFUUqkNQh5iUYC2ZcuWet9LSEhAQkJCne9ZG6AlJSXh+PHjeP755zFz5kwAwKhRozBv3jxs3LgRGzdurLft3r17kZGRgU2bNiEiQle7Z8CAAZg3bx7i4uKwaNEiAIBCocDmzZsxaNAgvP/++wCA8ePHQ6vVYtu2bYiNjYVT9TKGqX327t0be/bsgYuLCzueCRMmYP78+fj+++8pQCOkDSuunkET2djA3tbW6v7SW9kRTw8zKlbLxT40JyfkFhairKICKrUaNkLOynMS0qZZ9Ddh/fr1XI/DJCdPnoRAIEBsbCx7TSwWY+zYsfj222+Rm5sLb++6f6DFx8ejW7dubCAFAMHBwejduzdOnDjBBlNXrlyBTCbDxIkTjdpPmjQJv//+O86fP4+RI0ea1WdoaO3fMEUiEQYOHIjdu3ejoqIC9vb2ln1TCCEtRqVSoayiAgDgKpGAx+NZ3WdrzeDUe3gGzVouEglyCwsB6Pahebi2jmOtCGlpFgVoUqmU42GY5vbt2wgICKi1fKoPkO7cuVNngKbVanHv3r06Z6oiIiJw6dIlNki6ffs2AKBbt25G94WHh4PP5+PWrVsYOXKkWX3Wp6ioCLa2thCLxY1/eEJIq1MsN9x/Zv3yJgA8MMjgDOgQAVrNPjQK0Aipwflcskwmw507d1BeXg4HBwd07tzZaH+XNQoLC+Hu7l7ruv5aQUFBne3kcjmUSmWjbYOCglBYWAiBQADXh35I2NjYQCKRoLD6Nz1z+qxLRkYGTp06hZiYmAYLWxYUFLDPBEDZsoS0IsYBmvUJAoBx0NMaZ9AcHezhLHGETF7GUbFa41pohBAdzgK07OxsfPnll/jrr7+Mjnvi8XgYNGgQli5dCl9fX6ueoVAoYGNjU+u6SCRi36+vHQCT2ioUCgjr2QMhEomM7jO1z4dVVVXh7bffhlgsxuLFi+u8R2///v11JmUQQlpekcwgQUDCTYCWnqlb4rSzFbe6Eht6AT5ekMnLkF9YDIVSCXH1zzxLODtRJichdeEkQMvMzMSLL76I4uJiBAQEICoqCq6uriguLsaNGzdw9uxZJCUl4euvv66zpIWpxGIxVCpVretKpZJ9v752AExqKxaLoa6uCl7XvYb3mdqnIY1Gg3feeQepqan49NNP4eHhUeez9GJjYzFkyBD267S0NHzwwQcNtiGENA/DgMKNg5UCtUaDzFzdSkCAnzcne9qaQoCvFxJv3QPDMMjKKUBokOU/140DNJpBI0SPkwDtm2++QUlJCV599VWMHz/e6IcKwzDYv38/1q1bh2+++Qbvvfeexc9xd3dHfn5+rev6JcD6gh2JRAKRSGS0VFhfW3d3d2g0GhQXFxstc6pUKsjlcnb50pw+DX322Wc4f/48/vWvf6FPnz4Nfl59H40FcYSQlqHP4BQKBHCqo7SQubJzC6DR6EpstMblTb2Hz+S0JkCzEQrhaG+PsooKWuIkxAAnFRD//vtvDBkyBLGxsbV+4+PxeJgwYQIGDRqEy5cvW/Wczp07IyMjA+XlxtWrk5KS2PfrwufzERYWhuTk5FrvJSUlwc/Pj93Mrz+y6uF7k5OTjY60MqdPva+//hqHDh3CkiVL8Pjjj5vykQkhrZRGo4GsrAyAbqM7NxmcBgkCBkFQa9NUiQIKpRJV9WwNIaSj4ewszpCQkAbvCQsLg1arteo5w4cPh0ajwf79+9lrSqUShw4dQvfu3dkMztzc3Fqb6YcNG4bk5GSjgOrBgwe4evWq0ekHvXv3hkQiwb59+4za79u3D7a2thg0aJDZfQLAf//7X+zatQtPP/00pk6davH3gBDSOpSUlrL7bV0l3CRCGQZoQf6tr0itHve10Gr279EyJyE6nCxxdu3aFampqQ3ec//+fYSHh1v1nO7duyMmJgbffvstSkpK4O/vjyNHjiAnJwerVq1i7/vwww+RkJCAU6dOsdcmTZqEgwcPYtWqVZgxYwYEAgF2794NV1dXzJgxg71PLBbj2Wefxbp16/DWW2+hf//+uHbtGo4dO4aFCxdCYrAR2NQ+T506hY0bNyIgIADBwcE4duyY0efq27cv3NzcrPreEEKaV1NkcBoVqW3FS5xcz6AZ7UMrlcPHk7Z1EMJJgLZw4UK88sorOHjwIMaNG1fr/f379+PixYtYt26d1c96/fXX4e3tjaNHj6KsrAxhYWH45JNPGq3NZm9vj/Xr12PDhg3Ytm0be27mkiVLjCr8A7rASygUIi4uDmfPnoWXlxeWLFlSa+bL1D7v3LkDQFdao64N/uvXr6cAjZA2ptgog5OrGmg1RWpbc4Dm4eYCsVgEhULJeS00mkEjRIfHGNbEsNDWrVuRmJiIS5cusVmcbm5uKCoqwvXr15GRkYF+/fohMjLS+OEcnM3Z0aSkpGDhwoX47rvvrJ6RJIRY7uiZs7j74AEAYMbYMZxkcT61YCXSs3Jhb2eL+J+/abVZnAAw/fnXcS8tEzZCIU7/7zsIBJbvmJGVleGn/QcAAKEBAXjy0aFcDZOQNouTGTTDsznT09ORnp5e656LFy/i4sWLRtcoQCOEtFX6GTQ+n2+0RGcptVqNrBxdlnqAr1erDs4A3RjvpWVCpVYjv7AYPl61i3abysneHkKBAGqNxujweUI6Mk4CtJY6m5MQQlqCRqNha6C5SJwg4Fufb5WVWwBNdSJVay6xoRfgY7wPzZoAjc/nw0XihILiEshKy6DRaBo8YYWQjoCTAK2lzuYkhJCWUFJaCm317hB3ZxdO+jRKEGjFGZx6/g9lcvbtFWFVf64SZxQUl4BhGMhKy+Dmws2+PkLaKk7KbBBCSEdSVFLCvuYqkDA8JL01JwjocZ3JaZgJS8uchFCARgghZis0yODkagYtI7uDB2gGmbD6ExoI6cgsCtDee+89nDx50uKHWtueEEJaUlFJTYDG2QxaG6mBpufr5QE+X5fIkMnxDFoRzaARYlmAdvz4cdy/f9/ih1rbnhBCWlJR9QyaUCjk5AxOAEivroHmYGcLNxduCt82JRsbIXw8dYkBGRycJuDs6Ah+deYqzaARYkWSwO3bt3HkyBEux0IIIa2eSq2GvPoMTjdnZ07KYahUamTnFQAAAv29W32JDT1/Xy9k5RagtKwCstIyODs5WtyXQCCAxMkJJXI5SuRyaLVa8DnIjiWkrbI4QDtz5gzOnj1rdjsO6uISQkiLKTLYf8ZFcVpAV2JDq9X9bAzwbf3Lm3oBvl64lJAEQLcPzZoADQDcnCUokcuh0WpRWl7OSX05QtoqiwK01atXW/3gLl26WN0HIYQ0N8P9Z+4c7T9Lz6o54qkt1EDTM6yFlpmdh8iuYVb1p0sUyACgO+uUAjTSkVkUoD355JNcj4MQQtqEIlkJ+5qrGbQHbawGmh73mZwGpTZkMoT4+1vdJyFtFS3wE0KIGYwzOF046TO9jdVA0zMsVmtYaNdSxrXQKFGAdGwUoBFCiBn0NdDEIhHsbW056dOwBlqQf9sJ0AyDSS5m0FwMZtCKKJOTdHAUoBFCiIkqqqpQUVkJAHB3ceEs21K/xOlgbwcXSdvZd2VvZwt3V90y7wMOZtBshEJIHHWJBsUyGSWVkQ6NAjRCCDFRYXEx+9rD1ZWTPlUqNXKqS2wE+bWdEht6+qSGomIZyioqre5Pv69PpVajtLzc6v4IaasoQCOEEBMVGJzB6eHqwkmfmTl5bImNwDa0vKkXYLDMycWJAoYnMxiWNCGko6EAjRBCTFRYXMK+5moGzfiIp7aTwalnuA/tQWZOA3eaxt0gM9YwIYOQjoYCNEIIMVFB9RInn8czKglhjQyDAK0t1UDT4zpRwDAzttCgpAkhHU2zBWgqlQrltJ+AENJGqTUalFSXfnB1doZAIOCkX8MZtIA2HqBxMYPm4uTEnslJM2ikI7M4QJs+fTp+/vlno2sXL17Ehg0b6rx/x44dGDt2rKWPI4SQFlUsk0FbnVXozlH9MwBIyzA4RaANFanV47pYrUAggHN1Jmtx9bFPhHREFgdoOTk5KKs+MFgvMTGxVtBGCCHtQYHR/jMXzvp9kJENAHCWOMJFYt1Zli3Bwd6O01IbAODm7AIA0Gq1kJWWctInIW0N7UEjhBATFJZwX2KjorIKeYW6foPb4OyZXiDHpTaMEgUok5N0UBSgEUKICQxn0NxdOMrgNNizFRzgy0mfLSGwKUtt0D400kFRgEYIIY1gGIYtUutgZwc7WzEn/bbHAI2LRAH9EidgfDg9IR0JBWiEENKIsooKKFQqAIA7R8ubAJBWvf8MaB9LnAA3iQISRwcIq7NkaQaNdFQUoBFCSCPyiorY156cBmgGGZwB7SNA42IGjc/nw7V6H5qsrAxqtdrqPglpa4TWND527BgSExPZrzMzMwEAK1asqHWv/j1CCGlr8gsNAjQ3N876TcvUzaDx+TyjchVtjeHY0znL5HRGflERGIZBkUwGL3d3TvolpK2wKkDLzMysM/C6ePFinfe3tUOACSEEAPINZtC83LkJ0BiGwYNMXTDj5+0JkY0NJ/22BAd7O3i4uaCgqISTGTRAV8ok5b7udUFxCQVopMOxOECLi4vjchyEENIqMQzDLnHa2drCwc6Ok37zC4tRUVkFoG0nCOgF+fugoKgExbJSyEvLIXFysKo/w1ImhiVOCOkoLA7QfHza7n4JQggxVWl5ORRKJQDd8iZXKwGG+8/acoKAXnCAD65cTwagW7qN6tbZqv4MT2swLHFCSEdBSQKEENIAo+VNDveftZcSG3rB/jWfwTD4tJStWAxHe3sAukPqmepjtgjpKCyaQVuzZo3FD1y9erXFbQkhpLkZZXC6cZjBmWlQYqMNZ3DqGX4G7vahuaKsogIqtRry8nI4O7a9o7AIsZRFAdrhw4frvM7j8er8LUd/ncfjUYBGCGlTmmoGra0fkv4ww1lAw/pu1nB3cUFqdSJaQXExBWikQ7EoQHs4QUCr1eLLL79EUlISpkyZgp49e8LNzQ1FRUW4du0afvnlF0RGRmLp0qWcDJoQQpoDwzDIL9JtULe3tYVD9ZIbF/RBjL2dLTzcXDjrt6X4entAKBRArdZwssQJPJQoUFyCToGBnPRLSFtgUYD2cILAjh07cPPmTfzwww/w8PBgrwcFBUEqlWLMmDF49tlnER8fj1mzZlk3YkIIaSbyhxIEuFJVpUBWbgEAIDTQr12UIBIKBAj09cb99CykZ+VCo9FCILBum7OHqwv7uqCYMjlJx8JJksBvv/2GmJgYo+DMkKenJ2JiYnDgwAEuHkcIIc3CsEAtV/XPACA1I5vdDhIa5MdZvy1Nvw9NqVIhJ7/Q6v4kjo6wEermEQpLSqzuj5C2hJMALT8/HyKRqMF7RCIR8vPzuXgcIYQ0i9zCAvY1lzNo9x7UFPgOC/LnrN/6qBkNClRyaBltkz7HcC8dF4kCPB6PLbdRWl6OqurZTEI6AqtOEtDz9PTE6dOn8eyzz0IsFtd6v6qqCqdPn4anpycXjyOEkGaRU1AzC+RTzwqBJe4/yGJfN9UMWoVGgU3Zx3Cs+BpylSXQQAsXgQP6S7pgrFsfDHeJ5PyZDycKDOoTZXWfHq6uyCnQBcqFxcXw9/ZupAUh7QMnM2jjxo1DVlYWXnzxRZw+fRoymQwAIJPJcPr0abz44ovIycnB+PHjuXgcIYQ0OY1Gg4LqDE5nJyfY1vHLp6UMA7SwYO5n0P4uvYtpN/+NrbknkKUsgga6mbMSTTmOFSdg2d3v8fGDX6FiNJw+17DgLneJAi7sa33CBiEdASczaDNnzkR6ejoOHz6Mf/3rXwCMS24wDIMnn3wSM2fO5OJxhBDS5AqKi6HR6gIbHw9uz4G8X73EaSsWwceT275PyZLw8p0f2KDMhidAZztfOAvskVjxAKUa3fFSu/LP4E5lNtZ1mg+JkJvjq4xm0DK5KbVhuLRsWPKEkPaOkwCNz+dj9erVGD16NI4cOYK7d++irKwMjo6O6NSpE0aNGoXo6GguHkUIIc3CcHnTm8PlTYVSiYycPAC6DE4+n7sDXZIrMrHy3jY2OJM6hOLdkOkIsfUCoNuLtq/gIj5O182eXS67i3+l7sQXneZzkknq4uwEZycHyErLOZtBc3N2Bp/Ph1arpQCNdCicBGh6UqkUUqmUyy4JIaRF5BbUJAh4u3M3y/UgMwdaLfcZnHlKGZbe2YxKrW4j/UhXKdaEzoGAVxMACnkCTPYchM52vlh6ZzNkmgrEyxLxY+4JzPN5jJNxBAX44vrNO8grKEJFZRXs7Wyt6k8gEMDDxQV5RUUoKS2FQqmEuJGkNELaA4t/dfvf//5HWZmEkHYrt1A3gyYUCIwO7rbWvbSaDM5QjjI4GYbB+w/2IE+l2//b0yEY74fMMArODPVyDMHHobPZr7/MPIQrZfc4GUtoYE3QmZrO0TKnQYkTqodGOgqLA7QvvvgCU6dOxaJFi7Bt2zbcvXuXy3ERQkiLKa+sRGl5OQDAy92d02XIe02QwflnyXWckiUBADxtJPii03zY8hueZRriHIGFPo8DADTQ4t3U3ZwkDRh+pvvpmQ3caTrDfWh5tMxJOgiLf+p8++23mDNnDlQqFb7//ns8++yzmDFjBjZs2ICEhARotU1bb4cQQpqK0fIm5wkCNQFaJw4yOMs1VfgkfS/79crAiXC3cTKp7fN+o9HLIQQAkKrIw+78s1aPx7Cum2Ewag0vShQgHZDFe9DCw8MRHh6OBQsWIDs7G6dPn8bZs2fxyy+/4Oeff4aTkxMGDx6MRx55BP369YOtrXX7EAghpLnkGARoXNY/A2pmlcQiG/h6WV8bclP2MeSqSgAAQyTd8IRLL5PbCnh8rAyciNnJXwAAvsk6inFufeAsdLB4PEYBWho3M2iuzs4QCATQaDRGpzsQ0p5xkiTg6+uLadOmYdq0aZDL5Th37hxOnz6N+Ph4HDlyBCKRCH369MHQoUMxePBguBocgEsIIa1Ndn7TJAioVGqkZ+YC0JWksPasyjylDP/NOwMAEPOEeC3oKbOzMXs4BGG8W18cKLoMuaYS32Qfw6rASRaPydvTDfZ2tqiorGLLiVhLwOfDw8UFuYWFkJWVUaIA6RA4zeIEAIlEgtGjR2P06NFQKpW4fPkyzpw5g3PnzuH8+fPg8/no3r07/vOf/3D9aEIIsZpKrUZ+dYKAi8QJ9nbc1AgDgNSMLLa2GhcJAj/kHIeSUQMAZnoNRaDYstm+pf5j8HvJP6jSKrE7/xzmecfAW+RiUV88Hg8hgb5IunUfWbkFqKpSwNbW+iK/nm5ubOJGflERAnx8GmlBSNvG3c7XOohEIgwePBgrV67E//73P2zYsAHTpk1jTxoghJDWJregANrqItt+nl6c9n37Xjr7umtooFV95SpL8EvBXwAAW74Iz3gPt7gvb5EL5ng9CkBXK21H3imrxqYPPhmGQRoHZ3ICxofV0z400hE0aYBmiMfjISoqCs8//zx27NjRXI8lhBCzZOXVlA/iYo+YodupNQFaZysDtC05f7KzZzM8h5icGFCfWV5DIebpFlV+zj8PubrC4r46GSUKcJ/JmUv70EgHYPES55o1ayxqt3r1aksfSQghTS4rL4997efF9QzaA/Z117Agi/spVJVyNnum527jhAke/bE7/xwqtArE5Z/FQt8nLOrLsNQGZ4kCEglshEKo1GqjLFtC2iuLA7TDhw+bfK/+XE4ej0cBGiGk1dJoNOw+JycHBzg5WJ7NWJfb93UzaK7OTnB3dba4n58LzrOzZ1M9Blk9e6Y31zsGP+efhxYMfso7jTnew2DXSD21uhjur7vPUakNPp8Pb3d3ZOTmsnXquP7/h5DWxOIAbePGjSbdl5GRgS1btiAri5u/pIQQ0lTyioqg0eiKtfpxvLxZUFSCohI5AKBLaJDFZ1+qtGrsztPVK+ODh1leQzkbY4DYHSNdpThSfBXF6jIcKbqKSR4DzO7H18sdYrEICoWSs0xOQHcmakauLgs2t7CQAjTSrlkcoHXv3r3B90tKSrB161YcPHgQKpUKUVFReO655yx9HCGENDnD5U1fjpc373C0/+xocQIK1KUAgMdcouAndmukhXlmez+KI8VXAQB78s9ZFKDx+XyEBvoi+U4aMnLyOCuLYVg0ODe/AJ2DLF8mJqS147zMRlVVFXbt2oW4uDhUVFQgJCQEixYtwpAhQzjpX6lU4vvvv8exY8dQWlqKTp06YcGCBejXr1+jbfPz87FhwwZcunQJWq0W0dHRWLp0Kfz8ah+3cvDgQezatQs5OTnw9PTElClTMHnyZIv73Lt3L65cuYKkpCTk5eVh9OjReP311y3/RhBCOGe0/6wpMzjDLAvQGIbBzrzT7NezqzMvuRRlH4Rudv5IrsxEYkU6ksrT0d3B/PGGBfkj+U4atFoGaRk5Vu250zMsGpxTvRRNSHvFWRanRqPB//73P8yYMQNbtmyBg4MDVq1ahS1btnAWnAHAxx9/jN27d+OJJ57ASy+9BD6fj5UrV+Kff/5psF1FRQWWLVuGhIQEzJkzB/Pnz8ft27exdOnSWmU/9u3bh08//RShoaFYtmwZevTogfXr1+Onn36yuM+dO3fiypUrCA0NhUAg4OabQQjhjEajYQvU2tvZwdnJkdP+b92vSRDoEmpZsPJPeRoSK3SBXoR9AKIdQzkZmyEej4dpnoPZr3fnn7OoH8N9aHfTMqweFwDYisVwdtLttyswWI4mpD3iZAbtxIkT2Lx5MzIzM+Hg4IDFixdj8uTJEIutL05oKCkpCcePH8fzzz+PmTNnAgBGjRqFefPmYePGjQ3ui9u7dy8yMjKwadMmREREAAAGDBiAefPmIS4uDosWLQIAKBQKbN68GYMGDcL7778PABg/fjy0Wi22bduG2NhYOFX/gDC1TwD48ssv4e3tDR6Ph1GjRnH6fSGEWC+3sBBqtW7jfUD131Uu6WfQBAIBQgJ9Lerj54Lz7OtZXkM5H6Pek269sTZjP8q1ChwuvorlAbGQCM0r2NvFYBn39r10PBnDzdh8PNwhKy2FRqtFQXExvDk+iouQ1sKqGbSrV69i8eLFePfdd5Gbm4vp06dj165dmDVrFufBGQCcPHkSAoEAsbGx7DWxWIyxY8ciMTERudWbR+sSHx+Pbt26sYEUAAQHB6N37944ceIEe+3KlSuQyWSYOHGiUftJkyahsrIS58/X/IA0tU8A8PHxabIfpoQQ66Vn1xRU5bpKvVKlQmpGNgAgNNAXIhsbs/uQqytwtEi3N8xJYIeRrqafuWkue4EY49z7AgCqtEr8VnTZ7D6MAjSD2UNrGQZkOQW0zEnaL4sDtBUrVuCVV17BrVu3MHr0aOzcuRPPP/88O7vUFG7fvo2AgAA4PJS5ow+Q7ty5U2c7rVaLe/fuoVu3brXei4iIQGZmJioqKthnAKh1b3h4OPh8Pm7dumV2n4SQ1i89pyZAC/TlNkC7/yCLXY6zdHnzt6K/oagurTHOrQ9sLSh/YY6pBsucBwrND9A83V3h7KT7Wa0vL8IFw31oVA+NtGcWL3FevHgRPB4P3t7eKCwsxGeffdZoGx6Ph08//dTSR6KwsBDudRxcrL9WUM9fVrlcDqVS2WjboKAgFBYWQiAQ1DrQ3cbGBhKJBIXVG1PN6dMaBQUF7DMBIC0tzar+CCG1VSkUyKv+e+bm7AwHDs/fBIBb9wz3n5m/4Z5hGLYwLQBM9hzIybga0sXOFxH2AbhZkYHEinTcrcxBJzvTA1cej4cuoUG4/M9NFBbLUFQih5uLxOpxuTk7QygUQq1WI7uggK2xSUh7Y9UeNIZhkJ2djezsbJPut/YvkUKhgE0dSwOi6vRthUJRbzsAJrVVKBQQCuv+tohEIqP7TO3TGvv378fWrVut7ocQUr9Mg+0RgU1wCHfSrfvs626dQ8xuf73iAW5X6n7O9nQIRhe72pnnTWG8W1/crNBt8D9YdBnL/MeZ1b5LWCAu/3MTgO4UhQG9e1g9Jj6fDx8Pd2Tk5KK8ogKl5eWQOHKb0EFIa2BxgBYXF8flOEwiFouhUqlqXVcqlez79bUDYFJbsVjMbhSu617D+0zt0xqxsbFGWbBpaWn44IMPrO6XEFKjKZc3ASDp9j32dUSXELPb/89w9sxjEBdDMslot2iszdgPDbT4rfAKlvqNAZ9n+s4Yw+Xc26npnARogK4ESkaOLqjOysujAI20SxYHaD5N8FtmY9zd3ZGfn1/run4J0KOebB6JRAKRSGS0VFhfW3d3d2g0GhQXFxstc6pUKsjlcnb50pw+reHh4cFJP4SQujEMwyYI8Pl8zgvUqlRqNoMzOMAXjg72ZrWv0ChwtCgBAGDPFzdpcsDD3G2cMMS5G07JkpCrKsGl0rsYIOlicnvjTE7uEgX8vL2A67rXWXn56BYWxlnfhLQWnNVBaw6dO3dGRkYGysvLja4nJSWx79eFz+cjLCwMycnJtd5LSkqCn58f7O11PzS7dNH98Hn43uTkZGi1WvZ9c/okhLRestJSlFb/TPH19IBNPVscLHUnNR2q6ll5S2bP/iy5jnKtbrvESNdesBdwnyHfkPHV2ZyAbpnTHKFBfhDwdf/McJko4OXuDn51v4bFhQlpTyz6SbRmzRqLH2jNYenDhw/Hrl27sH//frYOmlKpxKFDh9C9e3d4e3sDAHJzc1FVVYXg4GC27bBhw7Bp0yYkJyezmZcPHjzA1atXMX36dPa+3r17QyKRYN++fRg0qGYpYd++fbC1tTW6ZmqfhJDWKzWz5qzIIF/L6pM1xHD/Wfcu5s/07C+8xL6e4N6fkzGZY5hzJJwEtijVVOH34mt4LfApk4NEsUiE4EBf3EvLxP30LKhUatjYWB8ACwUCeLu7Izs/H/KyMpRVVMCRfiEm7YxFf1MOHz5c53UejweGYeq9zuPxrArQunfvjpiYGHz77bcoKSmBv78/jhw5gpycHKxatYq978MPP0RCQgJOnTrFXps0aRIOHjyIVatWYcaMGRAIBNi9ezdcXV0xY8YM9j6xWIxnn30W69atw1tvvYX+/fvj2rVrOHbsGBYuXAiJRGJ2nwBw9uxZtgyIWq3G3bt38eOPPwIAHnnkEXTq1Mni7wshxHKpmVns65CAAM77T7ptEKB1Na/yf5aiCBdLdT83AsXuTXJyQGPEfBuMdJXil4K/UKlV4s+S62yNNFN0CQ3CvbRMqNUapGZkWVxm5GF+Xl7Irt7ykp2Xjy4hwY20IKRtsShAezhBQKvV4ssvv0RSUhKmTJmCnj17ws3NDUVFRbh27Rp++eUXREZGYunSpVYP+PXXX4e3tzeOHj2KsrIyhIWF4ZNPPoFUKm2wnb29PdavX48NGzZg27Zt7LmZS5YsgYuLi9G9kyZNglAoRFxcHM6ePQsvLy8sWbIEU6dOtbjPkydP4siRI+zXt2/fZmuueXl5UYBGSAuoUijYf+RdnJzgKrG+DMTDblYHaAI+H+Fmnkd5sOhvMND90hvr3r/FykmMd+/Hlvk4UHjZzAAtEEfjdQW+b99L5zBA88TfibrXWXl5FKCRdofH1DXlZaYdO3Zgz549+P777+vc0J6fn49nn30WM2bMwKxZs6x9XIeWkpKChQsX4rvvvkN4eHhLD4eQNu3W/VT8UX06SK9u3TCkdzSn/VdVKTB8ynPQaLXoEhaEnRveN7ktwzAYn/gR0hWF4IGHw1Fvwlfk2njDJsAwDMbd+AgZSt1Yjkb9C94iF5Panrv8D5a9tRYAMGvSaLyycCYnY1KpVNj88y9gGAauzhLMHDuWk34JaS04SRL47bffEBMTU2+2oaenJ2JiYnDgwAEuHkcIIZy4b7D/LDTAv4E7LZNyNw0arRYA0N3M+mdXy+8jXaHLCO/v1LnFgjNAt01lnHsfAAADBoeKrpjc1rDu202D5V5r2djYwMvNDQBQLJOjorKSs74JaQ04CdDy8/PZ4qz1EYlEdZbIIISQlqDRaPAgS7f/TCwSGR0hxJVEo/1n5iUI7C+oSQ6Ide/H2ZgsZbisub/wUp37jevi5iKBj6euPFHynVRoNFrOxuTnXVMSJaOBs5gJaYs4CdA8PT1x+vTpeivnV1VV4fTp0/D09OTicYQQYrWs/Hy2/EWwnx9btoFLiSl32dfmJAhUaBQ4VpwAAHDgi/GYSxTXQzNboNgDUgfdZ7hXlYvkysxGWtTQf/bKKgVSM7IauduMMRnU48wwKDZMSHvAyU+kcePGISsrCy+++CJOnz4NmUwGAJDJZDh9+jRefPFF5OTkYPz48Vw8jhBCrHb3QU3h1KZY3mQYBgk3bgEA7GzF6GzGGZzGtc+kzV77rD5jq5c5AZi1zGk4e2hYdsRavp6eEAoEAID07ByTZ/UIaQs4qcg4c+ZMpKen4/Dhw/jXv/4FwLjkBsMwePLJJ9naZYQQ0pI0Wi3uPtAVThUKhQjy4/5sy6zcAuQVFgMAorp1ZgMJUxjWPov1aPnlTb2Rrr3wyYNfoYYWh4uu4GX/cRCYcPRT9y41s4dJt+5j/BNDORmPQCCAn5cXHmRno7yyEsVyOdycnTnpm5CWxkmAxufzsXr1aowePRpHjhzB3bt3UVZWBkdHR3Tq1AmjRo1CdDS32VGEEGKpjJwcKKrPzA319+f89AAAuJZ4i30t7dHV5HaGtc+CxB6Idmj+2mf1cRE6YIhzBE7KEpGvkuOyiUc/detcUwLD8FxSLgT6+uBBtu4g+fTsbArQSLvB6U8lqVTaaD0yQghpaXfS0tjXnYO5qcv1sKuJKezr6EjTS+IY1z7r12K1z+ozxq03Tsp0BcgOFf1tUoDm5OiAIH8fPMjMwe176ZydKAAAAQb70NJzctGr+lQXQtq6NnUWJyGEWEut0eBeegYAQGRj0yTHOwFAQvUMmkAgQI9w0zI4GYbB/sKLAAAeeGYVhG0uw1wiYc/X7Yn7o/gfKLQqk9rpEwVUajXupHJ3LqebszPs7ewAAFm5udBoNJz1TUhLogCNENKhPMjKYrM3wwIDIDBjb5ipimVypKbrlt0iOofA1ta0Tf5Xy2pqnw1w6tKitc/qY8cX4XHXngCAMm0VTsuSTGpneA4pl4kCPB4PgT66c5jVGg1yCgo465uQlkQBGiGkQ7mVarC8GdQ0xwMlWLj/bF/17BnQOmqf1WeMW2/29W8mZnMalhlJ4rBgLQAEGsyCGp6tSkhbRgEaIaTDqKiqQmqGbnnTztYW/tUzL1zTl9cAAGmkaQGarvbZNQDVtc9cW772WX36O3WBh9AJAHBalgS5uqLRNuFhQRBU15q7nnyH0/EE+fmxe/VSMzKo3AZpFyhAI4R0GCn370Nb/Y93t7BQNmDg2lWDGbRe3U0L0I6XXEdFde2zUW5S2PEbPp2lJQl4fIx202XmqxgNfq8OLBtiaytG1+rD4u8/yEKJvIyz8diKRPCtLoQuKytDibyUs74JaSkUoBFCOgSGYXDzbk1l/4iwTk3ynBJ5GZLvpAIAOgUHwEXiaFI7w9pnE9z7N8XQODXGzfyitYbLvdeSbjVwp/kMiw2nZmZw2jchLYECNEJIh5BTUMDOrPh5ecFF4tQkz7l4NZFdYhvYp4dJbXS1z24DAILEnujlENIkY+NSd/sABIt1s1aXy+4iR1ncaBupQbmRa4m3OR1PiH9NgHY/0/RjqAhprShAI4R0CEazZ53MO7jcHH9duc6+HtTbtH1kB4ous68ntMLaZ3Xh8XhGyQKmzKIZ7sdLMKgTxwVnJye4SiQAgJz8AlRWVXHaPyHNjQI0Qki7V1lVhdtpurM3RTY26BRo+rmY5mAYhg3QxGKRSRmcDMNgf4FueVNX+6xPIy1aD8OzOQ8UXm50c76biwTBAbqMy6TbqaiqUnA6nhCDZc60LMrmJG0bBWiEkHbvxu3bbAHTiLAwCJvgaCcAuJuagfzCEgBA7x7hEIsa3+h/tew+MpQ1tc98WmHts/oEij0Q7agrn3GvKhdJFY3v/ZJ21508oNFocCOF22OfDJc59WetEtJWUYBGCGnX1BoNbtzS7Xfi8Xjo2c30Y5fMdd5geXNgH9OWN/9XeIF9PaEVHYxuKsN6bYZ13Ooj7VHz/TesF8cFHw8POFSfKpCek4MqBbczdIQ0JwrQCCHt2q37qais/oe6U2AgnBwcmuxZf/19g3092IQArVRTiWNFCQAAJ4EdHnNpvbXP6vOEay/Y8mwAAEeKrkKpVTd4f1PuQ+PxeOgcpCvlodVqcS+DsjlJ20UBGiGk3WIYBteSk9mve0U03UHalVUKdkbIx9Od3WvVkEOFV1DF6M6yHOvWB7ZNWPusqYq3Ogns2KK6Mk0FTjVy9JO/jyc83V0AAP/cvAO1uuGAzlydg2tOh7iTltbAnYS0bk2zEYMQQlqBe+npKJbLAQC+np7wdndvsmedvXQNSpUu2BrUN6rRTEyGYfBLwXn268keAzkbS3lhJdKu5CE9IR+FaXKoKtRQKTSwdRLB0cMOHqEShA30hU+EG/h86zNGx7v3Y7M49xVeZM/qrAuPx0PvHt1w9ORfqKxS4EbKPZNPWzCFl7sbJI6OkJeVITM3DxWVlexh6oS0JRSgEULaJa1Wi4v/1OwJ6929e5M+7/iZmkKzI4Y0vpcssSIdKZW6TMMe9kHoau9n9RhK8yqQsO8ubp3KBKOpPWNWJVeiSq5EwT0Zko+nw8HNFr2ndEaXRwOsCtQGOHWBt40LclUlOCO7iVxlCbxFLvXf37sHjp78CwBw/u/rnAZoPB4PnYODcCUxCQzD4F56Bnp07cJZ/4Q0F1riJIS0S7fT0tjZMx8PDwT5Nb7kaKmqKgXOXEwAADhLHNGnV0SjbX4t+It9PdnTutkzrUaLq/+7g92vnkLKiQyj4EzsaAMXf0d4hErg4GYLw4m98qIqnP72Bva+cRb5d0ssfr6Ax2cTHLRgsM/gVIS6DDLYn3f+7+sN3GmZLgbLnLfSUjnvn5DmQDNohJB2R6PV4tL1mg37A3r1bNLir+cu/4MqhRIAMHxQHwgFggbvl6sr8Fv1kqA9X4zRrtEWP1ueW4H4/1xD3p0S9pqNnRDdRwYjdIA33IMk4BnMjqmq1HhwNR+3T2Ui41o+AKAorRQH3vkL/Wd3Q+SoYIu+V5PcB+C77D/AgMH/Cv7CAp8R4PPqngPwcHNBl9BA3L6fjuQ7qSiRlcLFmbuTHdycneHm7IwimQw5+QUolsnh6izhrH9CmgPNoBFC2p3E23cgL9Mdxh3g4w1/b+8mfd4fBsubjw9tfHlzb+FFVGl1Ad14976wF4gtem5OchH2/escG5zxeEDP8WGYsX44+k3vCo8QZ6PgDABsbIXoNMgXo1f1xdh/9Yd7iC5w0WoY/LXtJk5suAaNSmP2WPzEbhgs0ZXQyFIW47y84RIaA6tPWWAYBheu3mjwXnPxeDyj0yJu3rvbwN2EtE4UoBFC2pWKykpc/Ocf9usBPevfsM6FKoWyZnnTyQF9eza8vKlhtNiVd4b9eqbXIxY99+65LBz66CIUZbrEBIm3Pca9PRD9Z4ZD7GhjUh++Ee6Y8N4gRI0NZa/dO5+No5/9DWWl+dmVTxkkOhgu4dbFaJnzCrcBGgB0DQkFn6/7Jy7l3n22UDEhbQUFaISQduXc1QQ2m7JbWCi8PTya9HlnL11DZfWRRcMH9Wn0lILTsiRkKosAAIMl4Qi1NX92LyU+HSf+cw1atW6vmX+UOyZ+OBjeXc0/hYAv5GPA7G54/JXeEIh0/yRk3SjE4Q8vQlGuMquvYS6RcBfqlirjS24gTymr995ekV1gK9aVFfnr7+uclwGxsxUjLCAAAFCpUCCVDlAnbQwFaISQdiMrLw+3UlMBAGIbGwySSpv8mf87fIJ9/cSwxjf778w7zb6e5TXU7Ocln0jH6W9vANXxTHhMAEat6AuRvWmzZvUJ6eeNMa/3h8heF2Dm35Ph6GeXoaoyfSbNhifAUx4DAABqaLGn4Fy994psbNjZxsJiGW7de2DF6OsW0bkT+zrpLi1zkraFAjRCSLugVKnw5181xyYNkPaCna1tkz4zIzsXF64mAtAVYO3XSPZmckUmLpTqjp0KEntgiMS8wrl3z2XhzHc1y4E9ngzBIwt6gC/k5ke5d1dXjHt7IGwlupmtvFsl+H3tFaiVpi8PTvUcDEH1Py178s83eLLAoL41y88nz1+xcNT1C/D2hqT65Ij07BzISks5fwYhTYUCNEJIu3Dm7ytsYoC3uzu6d+rUSAvr/e/ISfb1pCdj2D1P9fk+5zj7erbXo/VmOdYlK7EQJzfW7K2LGhuKAXO6cZ6d6hbohCdX92Nn0rISC3Hym3/AaE1bgvQWuWBEdaHaYnUZjhZfrffemMF92PH/cabxczzNxePx0L1zZ/bra8ncHi1FSFOiAI0Q0ubdTU9H8r17AAChUIjHBw9qNFiylkqlxsHfdcuVAoEA4x5veLN/alUefi++BgBwEzpiokd/k59V+ECO3z+/Am11fbNujwWi/6zwJisd4h4iwejV/SAU68qF3P8rB5f33Da5veHS7c680/XuL/N0d0Wv7roisvcfZOFuGvdnZ3bv3Ikte5J87x4doE7aDArQCCFtWrFMjhMGS5tD+/SGsxN3NbXqE3/+bxSV6ArhxgzqDXdX5wbv35pzAkz1xrGnvYeZfO5mWUEljn5yGarqrMqg3l4Y/H/dm7SuGwB4dXbBY0ulbGHba/vu4la8aQGU1CEEEfa6DfpJFRm4Wna/3ntHPFJTluT46YYL3FrCVixGRPVsqlqjQeKdO5w/g5CmQAEaIaTNqlIo8NvJk2zWZqfAQHQLC2uklfUYhsGOXw+zX08aE9Pg/TnKYhwougwAcBLYYprnEJOeU1WmxJFPLqGiWDfr49nZGY8tlYIvaJ4f3UG9vTDwmZp9dae/v4GsxMJG2/F4PMw2mEX7wWBp92ExQ/qyr5timRMAenarmW28nnKLSm6QNoECNEJIm6TWaHDk9Bl235m7iwseGzigyWeWAN3JAUm3dLNCXUIDG619tin7GNSMLiiY4TkUjoLGkxfUSg1+X3sFJZnlAACJjz1G/r8+7LJjc4kcFYLuo3RHJzEaBn+su4KSzLJG24126w1fka7sx2n5TSRX1F3mwtvDDT0jdPvE7j/Iwr0H3JfDcHZ0RGh1yY2Kqiok36t/Ro+Q1oICNEJIm6PWaHD41Clk5eUBAOxsbTFm2KOwsbGu1IQpGIbB5p372K8XzJzQ4H63e5W52FugmxlyEthijvejjT5Dq2UQ//U15KYUAwBsJSKMXtUPdhLLThyw1sCnIxAY7QkAUFaocfTTy6iUN7yXy4YnwDzvmpnF7xuYRRsxtGY/3u+nLtR7nzWiI2qC6MuJiVDTLBpp5ShAI4S0KWq1GkdOnUZ6dg4AwEYoxJhHh8KpupxCU7tw9QZupOhqanUKDsDwwX0avP+rrEPQVu89+z/vx+AibHicDMPgr+03kXoxFwAgFAswamVfSLztORi9Zfh8Hh5bKoV7sG5vX2l+Jf5Yd7XRI6Emevz/9s47LqorfdzPFHqTIiBgAwuKkqgBUwTB2I0lxaibrLqJbjS2FFe/m43JmsSYaExPNGbNuslvk2hcu4CAsZGmxg5iQxREihTpbeb+/hi5MMwMDDogmPN8Psrcc97znve9Z+6975x7SihuakcA4vJPkFqebVRu6KAQlDe3pNoee7BZgicvD3e6+PoCUFJaSuJ58yc9CAR3AhGgCQSCNkNpWRlb9/zIlWvXAN2MzUciIpp9t4AatFotq7/+n3w8408N956dKE7lx4JTALS3cuZPZvSendp5iaTdlwFQKBU8/EI/2vs3PAGhJbCyVTN84QDs2+l68bLO5pOwLrHBHQBsldb82WswABISX1yLNSrn6eHGQyH3AJB9PY+fj5w0Kne7hAbXbi91NDGJqqqm7ZQgELQkIkATCARtgqzcXDbtjiU7VzdI3Uqt5pGIwXTwbN9iNmyO3iuPPQvo7MeQOgPc66ORtLyTtlk+ntVhBHaNzNy8kHCVQ9/VrtUVNrMPHe9pOf8aw8HdjmELB8hbQp0/cJWTO1IaLPNk+4dop9L1GkblHeVMqfGZoI+Nqn0dujlqr1GZ28XD1ZVunToBuu2fjot10QStGBGgCQSCVo1Wq+XIqdNsiY2juLQUAEd7ex4dNhQfT88Ws+N6XgGfrd8kH//t+T832Hu2Iecnkm4GI91svRtd9+zq6esc+OKUfDxgYnd6DPa7TastT3t/FyJm1+4AcPj7c1w6lGlS3lFly8wOQ+Xjj6/uMir3wIBgvNu7A7pJGNeyrlvIYn1CgvvKE0mOJiXJk0wEgtaGCNAEAkGrJSM7m027d3Po1Cm0N1+lebm788SI4Xi4Nn1j8Nvhgy+/pbhEFyA+MnQQA/qa3qYpq7KAT69Gycevdp6IWmF69mVuaiHxH+gvRHvvhObfCeFW6TqwAwOe7C4f7/v8BNdTTG+M/mT7h/C5OaPz58Kz/FZ4zkBGpVIyYeTN16GSxNbd+w1kLIGrszN9e/QAQKPRkPC75beYEggsgQjQBAJBqyM7L4/oAwfZGr+H6/kFgG5trfv69GHCsKHY29m1qD3bYw8Qu183u9DF2ZEFz042KStJEu+kbaFEq5vl+JjHQPo5djUpX5RdSsyKI1SV6QbGdxrQMgvR3i73jg+g2yAfADSVWmJX/U5JXrlRWWulmjk+o+TjVenb5WVH6jJueDiqm72Sm6P2UlpmXN/tEhrcV/4OpV69Smq65Zf2EAhuFxGgCQSCVoFGo+HClSts3/Mjm2J2cym9dqySh2s7Hh02lNDgvvIDvKVIPJfCu599LR+//NxTtHMxvVPB5uu/yhMDXNUOvOD7iEnZ8sJKYt49QlmBLpjz7N6OIXNbbiHa20GhUBA2sw9ePXQ9Y6X5FcS+9ztV5cY3Rx/t1p9AO90syrNlGXyXnWAg097dlaHhAwEoKCxi007TS3PcDtZWVjzUr598vP/IEcorK5ulLoHgVmn9dwGBQHDXUlFZSUpaOj/++ivrt2wlNuEn0rOy5Hx7W1siQkN5YsQIvFtopmZdcnLzWbzsE3mngifGPMyoyAdNyl8sy2RF2lb5eEmnibiYWFajukJD7Hu/c+OabiFaFx+HO7IQ7e2gslIx9KV+OLXX9Ublphby4yfH0VZrDWSVCiX/6PwECnQ9g59lRJNZmW8g9+zkcXLv4f/bHE1ZefPsndmtcyf8vL0A3bIb+w8danBGqkDQ0ogATSAQtAjV1dXkFhRw5mIK+347xPe7oli36X/EHDxIcsolKur0YDg7OjI4JISnx4+jd7eAZt/43BiZObk8t3g5WTl5AAT36sZLf/2TSflSTQWLL31DuaQL5p5s/yAPuwYbla2u1BD/4VGyLxQAYN/OhpGLQ7B1Mm9/ztaEnbMNw/82ACs7NQBpx3I4sPYUktYw2Al26MwTHg8AUKat5J20LQZBUddOPgwL102oyL9RxKZdzdOLplAoiBw4EBtr3Tm/eCWNs5fEDgOC1oP6ThsgEAjaLlqtlqrqaiqrqqiqrqa8ooKy8grKysspLS+npKyMwuIiCoqKKbk5A9MUVmo1Xfx86eXvj6+X1x0dg5WWkcXcV1eSkZkDgI93e955ZS5WVsZvmdWShkWXvuF8mW59tgBbb172G2dctlJD/AfHSD+hm6VoZadmxOL75F6otoirnxPDXupPzLuH0VZLXEjIwMbRivv/3MugHef7jmZPwUnyqovZW3CabbmHDWa4PjtlPHEHdD1a32yKYsKIwTg5Wn4hYicHBwaHhhCb8BMAB478joera4tPQBEIjCECNAGgG/8jSZJuvfOavyD/uq39C7olJ+vINSRfWwhJullSkjXIn+v+iq5bVtIVqlOnoY4am2rK6ttWW1auo17ZGn2GddQ7rut/PfmatPp+1fpX10bjOmrrqClXV67ueanvf73zINU5d/V11C0rgVbSotVKtX+1WrTSzb9aLVKdzzXpGo2Gyupqqqqrb2vTaYVCgUe7dni396BTBx98vb1Qq+78673Y/b/y9sf/puTmAPWOPl58vnwx7d2NP7QlSWJF2lYO3kgCwEllx3v+07A1suZZVXk1ez48RvpJXXCmtlEx4m8DcO/s3EzetBw+Qe4MmXcvez48hiRBYsxlFEoFA58K1AvSnNX2vNLpcRam/AeA5WmbudexC11sa5dM8e/ky7DwUGL3/0b+jSI++88m/m/OtGaxu1unTlzxzyA55RLV1dVE7T/AEyOGt/hEFIGgPiJAEwCwOS6enLy8O22G4C7F1sYaF0cnXJyccHNxwcvDA093N6zUrecWdC3rOp+t/4Hd+3+V07p29OGztxc1GJx9eHUnG3J0PTBqhYr3A6bjb+dlIFteWMnulUfIuahbjqJmCyfvQLdm8ObO0CXEm7CZfTmwVjdJ4nRUKkgw8Gn9IG2Y6z085jGQzdd/o1xbyaKUb/gmcD42ytq9VOc9M4mDvx2nrLyCzVF7GT3kIXlTdUsTft995BXcIDsvj+LSUqIPHGTcw0Na1fdT8MdDfPsEAkGjKBUKFEolSoUClUqFtVqN2kqNtdoKK7UaKyvdX1tra+xsbW/+s8Hezg5nR0dsrVvv2Kq0jCx+2BnP/3btlScDAIyKfJDFc6biYG+8J0UraXknbYscnAG83vlJQp26G8gWZBQTt+qoPCHAyk7NiL8NuKuCsxp6RPghSRIH/3UaJDgdnUplaRWDZvTRm536N78JHCu+xKXybM6WXeXV1O94t+vTKBU6Ge/27sz682N88OV3SJLE8k/+zTcfL0XdDEGTWq1m1OBwNu2OpaS0lKzcXKIPHGBUeLgI0gR3DPHNEwDg6eaGtZUaauZY3fxPAbW/fBU18690aYpaQfmzoq6cQk6RP8ty8o9phU5XvTrryxutQ1atQK5GoZDr1C9brw49eblC+bO+nXVsUsgSDcjXfq4vZ+BXPR16vtTNV9Q7t3Xapb5NNZ8N6lDUa09AqVSiVChRKhU3P9/8e/NzTVDW2tfkagqSJHE1M4efDp9g3y9HOXIiSS+/Zp2zR4YOMul3YXUZr6V+x94bpwHd+f5Hp8cZ5x5iIHv59yz2fX6SqjLd8hP2rjaMWHwf7p3a/mtNU/SM7AgKOPilLkg7t/8qZYWVDJl3L1a2useOvcqGFV2nMvXsx5RpK4nNP46fjRsL6ixL8uS4Yeza8xPnUq5wITWdj9Zt4OXnnmoWmx3s7BgdHsbW+D1UVVeTnpklgjTBHUUhiXnFbYqzZ88yc+ZMvvzyS3r27HmnzREIWiWSJFFUXEpewQ1yCwrJzL7O5fRMUi5f5fTZi+TmG656b21lxZPjhvLMpLENDkhPKklj0aWvSavQ7QmqRMGbXabwiLv+vpzVlRp+/+E8p3bVzgx09XNk+N/a9oSApnDpt2vs/ewE2mrdY8a1oxPDXuqHs1ft+d1fkMgLF79Ce3NM5ct+45jqFSHnnzl/iWdefpPqat14x6UL/8roIQ81m82ZOdfZsXcvVdW6gNrT3Z1R4WE4iDFpghZGBGhtjOYK0G4UFVNdrTE+WF8yMshekvQH2ksS1DvWH5iuPyhfb2C7UV21Nkj1yhrqqmNvvQkLUp1jJH3ZumWpd1y33trjWn9qJy+Y0lXv/NWfyGBKV81kA4PJGfUmQcj+6k8e0D9/9XUZP3/GdZk6B4Zla86rQRua0CXVCNXRY+r7oNVKaDRaNFqN7q9GQ/XNvzXplVXVlJfXzB6toLy8gvwbRfIDtjH8Onjy2KhIxg4La3AB2mJNOZ9nRPNddoIcTLio7Hm761MMcumlJ3v90g32rzlFflqRnNY11JvwWX3lHqQ/ChlJucS/f5TKUl17WNurGTw7mM4DasfpfZ+dwPI6G8s/7zOSv3oPk3swN0ftZfmn6wGwsbHmi3f/TlAP/2azuX6Q5mBvz6iwQXi6uzdbnQJBfUSA1sZorgBt6oJ/cub8pcYFBYI2jqODPUE9ujIguBdhofcS0MWvwVe4xZpyNuT8xDdZ+8mvrt1YO8i+Iyv9p+FrUzuOrLyokiMbz5H8Y5ocdCvVCkIm9aTP6C531aviplCQUUzc+0e5kVEip/WI8OP+P/fC+ub6aV9ci+XzjBg5f1L7h/ib33islGokSWLZR1+xLfYAoGvDj998mb6BzTNpAOB6fj5R+w9QfHN5GKVCwX19+9K/d687si6f4I+HCNDaGCJAEwiMo1KpsLO1wc7WGhcnR9zaueDu6oKbqzPt3Vzp5OtNl44d8PVu3+gDViNpOVGSyo7cw8TmnaBYW7snpI1CzXMdhjPVKwIrpS64KC+q5HR0Kom7U+U9NQHcOjkR8fw9uHUy3TP3R6GytIr9X5zi8uHanSIc3GwZ+HQgXQd6o1Ao+DprH6vSt8v59zh0YaX/VLys21FRWcn8Jas4eioZAHs7W95bsoCQe3s3m82lZWVEHzhIVm6unObp5sagAQPwbt/yO1sI/liIAK2N0VwB2of/+o60jKw6g8u5Oai8dsC9os4AdW4OHNcfqK9/XFOmVlfNR4URXfqD3RUKakb569mkqDdgvcaG2skIjenSH1xfM3jemK6acvXPARj/qz+hwsiEhXo21Za9mVrnWFHnuFZXQ+dAv2z9SRN1zx/1/Kk9V7Xnr9bOxnTp29Dw96H+d6teWerk1WkLtVqFSqVEpVKhUuo+q1W1aeqbgZmpRWTNoVJbzcXyTE6VXOFYcQo/3zhLgaZET0aJguGu9zLPdzR+Nu5IkkTupULO7LnCxZ+vUV1RG5hZ2aro91g3gkZ2QaUWvS01SJLE2X3p/PbNGarKa89Xh95uDHiiO96Bbmy9foi3rvxA1c3N1J1Utsz3HcPjHg9QWVHFS0s/lCd2KJUKZvxpAs9MGoeqmfYv1Wg0HD59mmNJZ/Re+Xfr1IkBfYJwb9euWeoVCNpcgFZZWcm6deuIjY2lqKiIgIAAZsyYQUiI4eyp+uTk5PDpp59y+PBhtFot/fr1Y968efj4+BjI7ty5k++//57MzEzat2/PE088weOPP94iOhtCTBIQCIwjSRJVkoYqqZpKqZoqrUb3V6qmXFvFjepS3T9NKQXVJWRU5JFWcZ30ilyyqm7Ujqmrh73ShpFu9zLNK5JOag9yUm6QdjyHS79lystm1KBUKegx2I9+j3fDwdW2JdxukxRmlfLz+kR5N4UaOvR2I2hEF4oCy1mU+jUZdfbq7G3vx6wOIwi17cbfl3/GT4dPyHk123AF9QxoNpszc66z79Ah8m7oTzDp5ONDn27d6OjTAZV49SmwIG0uQFu6dCn79u1j4sSJ+Pn5ER0dTXJyMh999BHBwcb3vQMoLS1lxowZlJSUMGnSJNRqNRs3bkSSJL766itcXFxk2W3btrFq1SoGDx5MaGgoJ0+eZPfu3Tz33HM89dRTzaqzMZorQFuVvp0r5Tl6j6i6Dyy9L0ndFe2N5BtLN/U1MypbN81IObPqlQwlTNso1SuDyYe1LFs3TTJWh6F+U+VM2WW0XhM2SvWkDfKNlDNWpqk2GrPX+PkwZW9jNjbsI4BGkqiSquUeF0vgoLQh1Kk7A7Xd6ZPVkdIr5eSmFpKTUqD3CrMGKzsV3Qf5EjzWH0cPMdvPHCRJ4srRbH77f8kUZulvA2bvZoP3Q25EB50gtuqEXl4Puw486jaQvPgsvvl+F9o6e34+PCiESeOGcW9Qj2YZ76fVakm6eJFDJ09RXqG/ibudrQ3+HTvSxdcXX0/PZlmvTfDHok0FaElJScyaNYvZs2czZcoUACoqKpg+fTrt2rVj9erVJst+++23rFmzhi+++IJevXQzri5fvsz06dOZMmUKf/3rX2V9TzzxBL179+bdd9+Vy7/55pskJCSwadMmnJycmk1nYzRXgPanMx+QWJpmMX0CQVvBUWtL+ypnPMqc6JDbDs90Z9ql2lGZW0WDd0cFeAe60e3BDgQ85POHm51pKbQaLRd/usaxrRcozDTcr/V6zyL2R54lwyFfL12tUNEzqz05P6RRkFmol9e1ow8RDw7goZB7COrR1eLBUlV1NUkXLnIiOVmeRFAXpUKBu6sr3h7ueLnrds1wcnQUPWyCJtGm7ij79+9HpVIxblztJsQ2NjaMGTOGtWvXkpWVhZeX4RYrAPv27SMwMFAOpAA6d+5M//792bt3rxxMHT16lBs3bjBhwgS98o8++ihxcXH88ssvDB8+vNl03ikKMoqh3R01oXVQ54Gs0Hs4K0ykGylXI6uXZhyFZCTHmK466QpzZI3m101XGElrWLYupvLlT03RZSIIMnpujOQrJFBplCg1SlQaBSqtElW1EqX25rFGibpaiW2ZNTblamzLrbCpsMKp0BaXG3bYVFgZ6K6gyiANwK6dDT693fAJcqdjP0/s29k0aKOgcZQqJd3Dfek2yIf0U9c5E3+FtGM5SDd7xjzOOvHY2QFcCsjhSGgqWT66V4zVkoZEz0yYpUZ5xAH13jIo0QJwKS2DSxsy+PeGHVhZqQnw9yOgsx9+Xp74eHng69UeTw83nBztsbezbfKsTCu1mnsCe9K3R3euXLvG2ZRLXLp6Fa1WV79WksjJyyMnL49TnAd0Yy2d7O1xdnLE2dEJRzs7bG1tsLPR7bpha2Oj25VDrUatVqNSKv+ws34FOtpUgHb+/Hn8/PxwcNBfRLImQLpw4YLRAE2r1ZKSksLo0aMN8nr16sXhw4cpLS3F3t6e8+d1F1NgYKCeXM+ePVEqlZw7d47hw4c3i847ydMJYVy/orvxmbwlNCUIaUS2LsYexLeuy1CLyQDAtKeCPzIKsHOxwcHVBpcODrh1dsa9kxNunZ1FQNaMKJQKOt7Tno73tKe8qJLLR7JIPZJF5pk8qso1+F/0xP+iJ9c9ikgOusaFHlkUOZeDSoF2oC2V/W1QJlWiPFyO8nLtGnhVVdUkn00l+Wyq6bqtlShtlCjUShRKBSgVKFQKFHX+3pTUnwij+wCAWqnEy9WVDq7tcHdywsXeXq8OSZIoLCmhsKQEyKIxJEmiWqOhWqtFo9XqrUeprVnjsc5aj3XTjerTV95wvgl7/khoJC3vzp9/R21oUwFabm4u7kYWCqxJu379ukEeQGFhIZWVlY2W7dSpE7m5uahUKlxdXfXkrKyscHZ2JvfmdOvm0GmM69ev6+VfuHAB0L1KtSQa7Q1UVmX6ifXiF3N+zJn3g09fyKBMAzrkW4SJiureQhQGsVy9ehs3zfAcGCvVaBkzMEdI0ch5M1qk6UGoYREz6m2kzK3EwuZ8Lwyr1U9RKhQo1ApUaiUKlQKVSqk7VilR2yixslWjtlVjZaPC2l6NrZM1tk7WKFR19VRRQh4lWXnmPFcFlsIHuoxzovMYR/KvFlNwtYQbmcVorykI2utCYJwTRc5lXOtQSF77YvLciyl2rUY7Qo22VIXyShWK9GoU2RoUN7QN11UG2rKGRcyhkKyb/WVgpVbRzsURV1dHnJ0ccXCwwd7O9rZmG9endk62wNKUVVRw9uzZZtHduXNnbG0bn0TUpgK0iooKrKwMX0dY39yIuaLeoM265QCzylZUVJgcr2Btba0nZ2mdxti+fTvr1683SH/rrbdMlhEIBII/BNnAhdpDxztmiHGKiqAo/U5bIbhVDu7c0Sx6zR1D3qYCNBsbG6qqDMeGVFZWyvmmygFmlbWxsaHaxBYxlZWVenKW1mmMcePG8dBDtfvOFRUVcfnyZXr06CEHgpbi8uXLvPXWW7z66qt07tzZorpbA8K/ts/d7qPwr+1zt/t4t/sHze+juTrbVIDm7u5OTk6OQXrNK0APD+MrOzs7O2NtbW30VWL9su7u7mg0GvLz8/VeSVZVVVFYWCi/vmwOncbw8PAw8Ou+++4zIW0ZOnfufFevsSb8a/vc7T4K/9o+d7uPd7t/cOd9bFNzfrt160Z6ejolJfqLQyYlJcn5xlAqlfj7+5OcnGyQl5SUhI+PD/Y3B3R2794dwEA2OTkZrVYr5zeHToFAIBAIBAJoYwFaREQEGo2G7dtr92qrrKwkKiqK3r17yzM4s7KyDAbRDx48mOTkZL0g6cqVKxw7doyIiAg5rX///jg7O7Nt2za98tu2bcPW1pYHHnigWXUKBAKBQCAQtKlXnL179yYyMpK1a9dSUFCAr68vMTExZGZmsnjxYllu2bJlHD9+nAMHDshpjz76KDt37mTx4sVMnjwZlUrFxo0bcXV1ZfLkybKcjY0Nzz77LB988AGvvfYaoaGhnDhxgtjYWGbOnImzs3Oz6ryTuLu7M3369AZfubZlhH9tn7vdR+Ff2+du9/Fu9w9aj49taicB0M2IrNmLs7i4GH9/f2bMmEFoaKgsM3/+fIMADSA7O9tg38y5c+fi5+dnUM+OHTvYsGED165dw9PTk0cffZSJEycaLFvQHDoFAoFAIBD8sWlzAZpAIBAIBALB3U6bGoMmEAgEAoFA8EdABGgCgUAgEAgErQwRoAkEAoFAIBC0MtrULE6BjmPHjrFgwQKjeatXryYoKEg+PnXqFGvWrOHcuXM4ODgQGRnJzJkz5TXaaqisrJQnXxQVFREQEMCMGTMICQkxy6acnByDyRLz5s3Dx8enVfh45swZYmJiOHbsGJmZmTg7OxMUFMSMGTPo2LFjo/ZER0ezfPlyo3lbtmxp8mwfS/vXFH2msGQbWtq/t99+m5iYGJP1/e9//6N9+/Ym87/66iujW6ZZW1sTHx9vhkeGmOvjoUOH+PHHHzlz5gyXL1/G09OTjRs3Gi2n1Wr5/vvv2bp1K3l5efj5+fH0008zdOhQs2wqKipizZo1HDhwgIqKCnr16sXzzz9/S4ttWtq/y5cvExUVxeHDh7l69Sp2dnb06NGDZ555hsDAQIvZYy6W9u/atWtMmjTJqL7XX3+dhx9+uFGbLNl+YHkfTV1HNXz22Wf07dvXZP6duI+Wl5cTFRVFQkICKSkplJWV4efnx9ixYxk7diwqlUqvXGu6BkWA1oZ5/PHH6dWrl16ar6+v/Pn8+fO8+OKLdO7cmblz55Kdnc2GDRtIT09n5cqVeuWWL1/Ovn37mDhxIn5+fkRHR7No0SI++ugjgoODG7SjtLSUBQsWUFJSwtNPP41arWbjxo3MmzePr776ChcXlzvu47fffsupU6eIjIwkICCA3NxctmzZwowZM1i9ejX+/v5m2fPss8/SoUMHvTRHx1vfAdCSbWiOPlM0Vxtayr9x48YZ7KAhSRKrVq3C29u7weCsLi+//DJ2dnbysVJ5+y8RGvMxPj6eH3/8kR49ejT6APryyy/573//y9ixYwkMDCQhIYE33ngDhULR6ANeq9WyePFiLl68yOTJk3FxcWHr1q0sWLCAL7/80qwfIs3p386dO9m1axeDBw9mwoQJlJSUsH37dmbPns3KlSvN3iHlVr/jt6qvKe0HMHToUO6//369NHOCx+ZqP7Ccj4MHDza6QsHatWspKyszK9CGlr2PZmRk8NFHHzFgwAAmTZqEvb09hw4d4v333ycxMZF//OMfeuVa1TUoCdocR48elcLCwqS9e/c2KLdw4UJpwoQJUnFxsZy2Y8cOKSwsTPrtt9/ktMTERCksLEz69ttv5bTy8nJp8uTJ0qxZsxq157///a8UFhYmJSUlyWmpqalSRESE9MUXXzTBs1os7ePJkyelyspKvbJXrlyRHn74YemNN95o1J6oqCgpLCxMOnPmTNMcMYGl/TNXnyks3YaW9s8YJ06ckMLCwqSvv/66UXvWrVsnhYWFSfn5+eaYbxbm+piTkyNVVVVJkiRJixYtkiZOnGhULjs7W4qMjJTef/99OU2r1Upz5syRHnvsMam6urrBevbs2WNgT35+vjRq1Chp6dKl5jlVB0v7l5ycLJWUlOilFRQUSGPHjpWef/55i9ljLpb2LyMjw+A+2hQs3X6SZHkfjZGZmSmFh4dLK1asaFT2TtxH8/PzpZSUFIP05cuXS2FhYVJaWpqc1tquQTEGrY1TWlpqdCP2kpISjhw5wvDhw3FwcJDTR4wYgZ2dHXv37pXT9u/fj0qlYty4cXKajY0NY8aMITExkaysrAZt2LdvH4GBgXq/YDp37kz//v316rlVLOFj3759sbKy0ivfsWNHunTpYrDrhDn2aDSaJnrRsL7b9c8cfQ3RnG1oaf9qiI+PR6FQmP3qoW69koVXF2ronHt4eKBWN/6yIiEhgerqah599FE5TaFQMGHCBHJyckhMTGyw/P79+3FzcyM8PFxOa9euHZGRkSQkJFBZWWmmN4ZYwr+ePXsaDK1wcXEhODj4lq7Bpn7Hb1Wfuf7VpaysjKqqqiaVac72A8v7WMOePXuQJIlhw4Y12Z6WuI+2a9eOrl27GqSHhYUB6H33Wts1KF5xtmGWL19OWVkZKpWK4OBgZs+eLXcxp6SkoNFoDN57W1lZ0b17d86fPy+nnT9/Hj8/P72HJCA/rC9cuCBvo1UfrVZLSkoKo0ePNsjr1asXhw8fprS01ODG3NI+GkOSJPLz8+nSpYvZ9ixYsICysjKsrKwICQlhzpw5t/XqwdL+NaTPFM3Zhs3VftXV1ezdu5c+ffoYvCppiEmTJlFWVoadnR2DBg1izpw5uLm5NdmvutzKOTfG+fPnsbOzo3PnznrpNdfh+fPnGxxucO7cObp3727w2rZXr17s2LGDtLQ0AgICmmyXpfwzRV5eXpNeoVvaHkvrW79+PatXr0ahUNCzZ0+DhdRN0VztB83bhnFxcXh6enLPPfeYXaYl76OmyMvLA9D77rW2a1AEaG0QtVrN4MGDuf/++3FxcSE1NZUNGzYwd+5cPv/8c3r06EFubi6A0fEE7u7unDhxQj7Ozc01KQdw/fp1k7YUFhZSWVnZaPlOnTrdUR+NERcXR05ODs8880yj9tjY2DBq1Cj69euHg4MDZ8+eZePGjTz//PP861//MhnAtpR/5ugzRXO0YXO336FDh7hx44bZv9qdnJx47LHHCAoKwsrKipMnT7JlyxbOnDnDl19+afDjxFI+NoXc3FxcXV0NdhYx5zoE3QPH2EOypnxubm7THg4W9s8YJ06cIDExkalTp7a4PZbWp1QqCQkJITw8HA8PDzIyMti4cSOLFi1i+fLlje65bOn2g+Zvw0uXLnHx4kWmTJli1o44d+I+aoyqqip++OEHOnTooBfItbpr0GxJQauhb9++ejNlBg0aREREBH/5y19Yu3Yt7733HhUVFQAGr/VAN3OtbldrRUWFSbmafFM0Vk9j5U1haR/rc/nyZT744AOCgoIYOXJko/YMGTKEIUOGyMdhYWGEhoYyb948vvnmGxYuXNgU9yzunzn6TNEcbdjc7RcfH49arSYyMtIseyZOnKh3HBERQa9evXjzzTfZsmULTz/9tFl66nI759wYt3Md1uTXyN5K+fpY2r/65Ofn88Ybb9ChQwemTJnS4vZYWp+XlxerVq3SSxsxYgRTp07ls88+azRAs3T7QfO3YVxcHADDhw83S/5O3EeN8eGHH5Kamsq7776r92q3tV2DYgzaXYKfnx+DBg3i2LFjaDQabGxsAIyOg6isrNT7EtnY2JiUq8k3RWP1NFa+KdyOj3XJzc1l8eLFODg48OabbxpMszaX4OBgevfuze+//35L5etjKf9M6TNFS7WhpfwrLS0lISGB0NDQ25ohPGzYMNzc3CzWfmD+OTfG7VyHNfnGgtrmbMNbpaysjMWLF1NWVsbbb799y0MgLGVPc+lzdnZm1KhRXLlyhezs7AZlW6L9wHI+SpJEfHw8Xbt2veVXr9D899H6fPfdd+zYsYNnn33WIGhubdegCNDuIjw9PamqqqK8vFyvS7U+ubm5eHh4yMfu7u4m5QA92fo4OztjbW19y+Wbyq36WENxcTGLFi2iuLiY995777Zt8/T0pLCw8LZ01Nd3O/41pM8ULdmGlvAvISGB8vLyJg9KNmWPJduvRmdj59wY7u7u5OXlGUxgMLcN3NzcGmzDpq4xZYpb9a+GqqoqXn31VVJSUnj77bfNXuKmuexpCX2gWx+rIVqq/Wpsul0fT506RWZmZqu8Dk35Fx0dzZo1axg/fjzTpk0zKNfarkERoN1FZGRkYG1tjZ2dHV27dkWlUnH27Fk9maqqKs6fP0+3bt3ktG7dupGenk5JSYmebFJSkpxvCqVSib+/P8nJyQZ5SUlJ+Pj43PKvY2Pcqo+g617+v//7P9LS0njnnXeaNDmgIXvatWt323rq6rtV/xrTZ4qWbENL+BcXF4ednR0PPfTQbdkiSRKZmZkWbT8w75wbo1u3bpSXlxvMaDTnOgTkiRVarVYv/cyZM9ja2t7WIOy63Kp/oJuQsmzZMo4ePcqSJUu4995776g9LaUPaLS3t6Xar8am2/UxLi4OhUJhkQCtOe+jNRw8eJAVK1YQHh7Oiy++aLRca7sGRYDWBikoKDBIu3DhAj/99BMhISEolUocHR257777iI2NpbS0VJbbvXs3ZWVlemN3IiIi0Gg0bN++XU6rrKwkKiqK3r176w3czMrKMvjyDh48mOTkZL0H/JUrVzh27BgRERGtwkeNRsM///lPEhMTWbp0KX369DFZ9/Xr17l8+bLelG1j9vzyyy+cPXvWrBlaze2fOfpqaIk2tLR/dfUeOXKE8PBwbG1tjdZtzD9j9mzdupWCggIGDhzYNOca0GnqnJvDoEGDUKvVbNmyRU6TJIlt27bRvn17ve+sse/o4MGDycvL48CBA3o27t27lwcffLDRV+L1sbR/oBv78+OPP/Liiy8yePDgBuu+fPmyXg+Ipe1pCX05OTlERUUREBCg1/vSEu1nyqbbbUPQzaLet28fffv2NTmwv7XcRwGOHz/O0qVLCQ4OZsmSJSb9bm3XoJgk0AZ5/fXXsbGxoU+fPri6upKamsqOHTuwtbXlueeek+VmzJjBnDlzmDdvHuPGjZNXaQ8JCdF7KPXu3ZvIyEjWrl1LQUEBvr6+xMTEkJmZyeLFi/XqXrZsGcePH9f7Aj766KPs3LmTxYsXM3nyZFQqFRs3bsTV1ZXJkye3Ch8/++wzfvrpJx588EGKioqIjY3Vq6/uINe1a9cSExPDhg0b5CUcZs+eTY8ePejZsycODg6cO3eOqKgoPD09+fOf/3zH/TNXH7RMG1ravxr27NmDRqNp8Fe7Mf8mTpzIkCFD8Pf3x9ramlOnTrFnzx66d++ut/5fc/h48eJFEhISALh69SrFxcX85z//AXS/yGt6Aj09PZk4cSLfffcd1dXV9OrVi4MHD3Ly5EmWLFmiN1bS2Hc0IiKCTZs2sXz5clJTU+VVzLVarVkzlZvbv40bN7J161aCgoKwtbU1uAbDwsLkHo/Nmzezfv16PvroI/r169cke+6Uf6tXr+bq1asMGDAADw8PMjMz2b59O+Xl5cyfP1+v7pZov+bwsQZzZlG3lvtoZmYmr7zyCgqFgoiICPbt26enIyAgQB5D19quQRGgtUHCwsKIi4tj48aNlJSU0K5dO8LDw5k+fbreNhw9e/bk/fffZ82aNXzyySfY29szZswYozezV155BS8vL3bv3k1xcTH+/v68++67Zr2CsLe356OPPuLTTz/l66+/lvdxnDt37i13W1vaxwsXLgDw888/8/PPPxvU19gspCFDhvDrr79y+PBhefzU2LFjmT59+i2to2Vp/8zVZwpLt2FzfEdBN3vT1dWVAQMGNMmeYcOGcfr0afbv309lZSVeXl5MmTKFqVOnmuyJs5SP586dY926dXpla45Hjhyp9/B77rnncHJyYvv27cTExODn58err75q1msklUrFihUr+Pzzz/nf//5HRUUFgYGB/P3vf2/yMjfN4V/NNZiYmGh0wc8NGzY0+Mrtdr/jze1fSEgIGRkZbNmyhaKiIhwdHQkODmbq1Klm7cNo6fZrDh9riIuLa9Is6hruxH302rVrFBcXA/DBBx8Y6Jg+fbreJIfWdA0qJEsvqS0QCAQCgUAguC3EGDSBQCAQCASCVoYI0AQCgUAgEAhaGSJAEwgEAoFAIGhliABNIBAIBAKBoJUhAjSBQCAQCASCVoYI0AQCgUAgEAhaGSJAEwgEAoFAIGhliABNIBAIBAKBoJUhAjSBQCBo44SHh+v9q6iokPOio6MJDw8nOjr6DlpYy7Zt2/Rsffvtt++0SQJBq0Rs9SQQCFol165dY9KkSQ3KeHt7s3HjxhayqHXj7e3NyJEjAfT2DGwODh06xMKFCwkJCWHVqlUNyr7xxhvEx8ezZMkShg0bRs+ePZk+fTrFxcVs2rSpWe0UCNoyIkATCAStGl9fX5P74Dk6OrawNa0Xb2/vW95Uu6ncd999eHl58fvvv5OVlYWXl5dRueLiYg4ePIijoyPh4eEABAYGEhgYyLVr10SAJhA0gAjQBAJBq8bX17fFAg+BeSiVSkaNGsX69euJiYlh2rRpRuXi4+OpqKhg9OjR2NjYtLCVAkHbRoxBEwgEdw3h4eHMnz+fvLw8li1bxtixYxk6dCizZs3i2LFjRsuUlpby1VdfMXXqVIYOHcro0aN5+eWXOXnypIHs/Pnz5TFeX375JZMnTyYyMpKvvvpKltm/fz8zZ85k6NChjB8/nhUrVlBUVMSTTz7Jk08+Kcu9+eabhIeHk5SUZNSudevWER4eTnx8/G2eFeNkZ2czbdo0hg4dyr59++T0/Px8PvnkE6ZMmcLDDz/M2LFjefXVV0lJSdErP3r0aBQKBdHR0UiSZLSOqKgoAMaMGdMsPggEdzMiQBMIBHcVxcXFzJkzh9TUVIYPH054eDhnz55l4cKFBkFGYWEhs2fPZv369Tg5OTF+/HjCw8M5d+4cCxYs4ODBg0brWLJkCTExMfTr148nnniCDh06ALBr1y6WLFlCeno6I0aMYOTIkSQmJvLSSy9RXV2tp2PcuHFymfpoNBqioqJwcXGRXw1aktTUVJ5//nmys7NZuXIlERERAFy9epUZM2bwww8/4OPjw2OPPcb999/PoUOHmD17tl4w6e3tzYABA8jIyDAa/KakpJCcnEz37t3p0aOHxX0QCO52xCtOgUDQqrl69apeD1VdgoKCGDhwoF7ahQsXmDBhAi+88AJKpe43aP/+/VmxYgWbN29m4cKFsuyHH37IpUuXWLRoEY888oicnp+fz8yZM1m5ciWhoaEGr+dyc3P597//jbOzs5xWVFTExx9/jJ2dHWvXrqVjx44AzJw5k4ULF3L27Fm8vb1l+XvuuYcuXbqwZ88e5s6di52dnZx36NAhcnJymDhxItbW1k09ZQ2SmJjI4sWLUavVfPLJJ3Tr1k3OW7ZsGXl5ebz33nuEhobK6VOnTmXmzJmsWLGC9evXy+ljxozhyJEjREVF0b9/f716RO+ZQHB7iB40gUDQqrl69Srr1683+u+3334zkLezs2PWrFlycAYwcuRIVCoVycnJclpBQQF79+6lf//+esEZgKurK1OmTKGgoIDff//doI6//OUvesEZQEJCAmVlZYwePVoOzgDUajUzZsww6tu4ceMoLS1lz549euk7d+4EYOzYsaZOyy3xyy+/8OKLL+Lk5MTnn3+uF5ydO3eO06dPM2LECL3gDKBjx4488sgjpKSk6PVChoWF4eLiwv79+ykpKZHTq6uriY2Nxdra2uQED4FA0DCiB00gELRqQkNDee+998yW9/Pzw97eXi9NrVbj5uZGcXGxnJacnIxGo6GqqspoD116ejoAly9f5sEHH9TL69Wrl4H8xYsXAQgODjbI6927t9GlL0aMGMEXX3zBzp075SAxLy+Pn3/+mT59+tClS5dGvDWfvXv3cvjwYQICAli5ciWurq56+TWvL/Pz842ejytXrsh//f39AeQAbNOmTcTHxzN+/HgAfvrpJwoKChg6dChOTk4W80Eg+CMhAjSBQHBX4eDgYDRdpVKh1Wrl48LCQgBOnTrFqVOnTOorLy83SHNzczNIq+lBqh/4gG7Wo4uLi0G6k5MTkZGRxMTEkJKSgr+/P9HR0Wg0Gov3niUmJqLRaAgODjZqY835+OWXX/jll19M6ikrK9M7HjNmDJs2bSIqKkoO0MTrTYHg9hEBmkAg+ENSE8hNmjSJOXPmNKmsQqEwqS8/P98gT6vVcuPGDdq3b2+QN378eGJiYtixYwcLFixg165dODg4EBkZ2SSbGuOvf/0rCQkJbNq0CZVKZeBzjf0LFizg8ccfN1tvQEAAgYGBnDlzhkuXLuHk5MShQ4fo0KGDwbg0gUBgPmIMmkAg+EMSGBiIQqEgMTHRIvoCAgIAjPbGnTlzBo1GY7RcUFAQAQEBxMXFcejQIdLT0xk2bBi2trYWsasGa2trli1bxgMPPMCGDRv49NNP9fJrXtveyvmo6SnbtWsXu3fvRqPRyMtwCASCW0MEaAKB4A+Ju7s7kZGRnD59mu+++87oWl5JSUlGX3EaY9CgQdjZ2bFr1y6uXr0qp1dXV7Nu3boGy44bN47CwkLeeecdAINJC5bC2tqat956iwcffJCNGzfyySefyHm9e/emd+/e7Nmzx2DSAuh6AY8fP25U79ChQ7G1tSU2NpaoqCiUSqW87ZRAILg1xCtOgUDQqmlomQ2Ap5566pZXqX/ppZdIS0tj9erV7N69m6CgIBwdHcnJySE5OZn09HS2bNliVm+Wk5MTc+fOZeXKlcycOZMhQ4bg4ODAr7/+irW1NR4eHiZ7lIYPH86aNWu4fv06PXv2bNZ1w6ysrHjzzTd57bXX+OGHH5Akifnz5wPw2muv8cILL7B06VI2bdpE9+7dsbGxITs7m9OnT3Pjxg2jC+c6ODgwePBgdu/eTUFBAQMHDjS5/ZNAIDAPEaAJBIJWTc0yG6aYOHHiLQdozs7OfP7552zevJkff/yR+Ph4tFotbm5udOvWjWnTphkd3G+KsWPH4uTkxDfffENMTAwODg489NBDzJo1i4kTJ+Lr62u0nIODA2FhYcTGxjZb71ldaoK0119/nU2bNiFJEgsWLMDHx4d169axYcMGDh48SHR0NEqlEnd3d+655x55QVtjjBkzht27dwO6XQYEAsHtoZBM7dEhEAgEAouQnp7On/70JyIjI1m6dKlRmWnTppGZmcnmzZtNzkQ1RXh4OPfeey8ff/yxJcxtEa5du8akSZMYOXIkr7zyyp02RyBodYgeNIFAILAQRUVF2NjY6K3+X1FRIQ/IDwsLM1ru119/5dKlS4wdO7bJwVkNx48fl7eFiouLa7Wbk2/bto1Vq1bdaTMEglaPCNAEAoHAQhw/fpx3332XkJAQPD09uXHjBkePHiUzM5P+/fszZMgQPfmtW7eSnZ3Nzp07sba25qmnnrqleqdPn653bGxR3NZCz5499ezt3r37nTNGIGjFiFecAoFAYCHS0tJYt24dp0+fpqCgAABfX1+GDBnC5MmTDXq1nnzySXJycujYsSOzZs0y2LFAIBD8cREBmkAgEAgEAkErQ6yDJhAIBAKBQNDKEAGaQCAQCAQCQStDBGgCgUAgEAgErQwRoAkEAoFAIBC0MkSAJhAIBAKBQNDKEAGaQCAQCAQCQStDBGgCgUAgEAgErQwRoAkEAoFAIBC0MkSAJhAIBAKBQNDK+P+DCW15j8w80QAAAABJRU5ErkJggg==", "text/plain": [ "
      " ] @@ -4196,7 +3930,7 @@ "fig,ax = plt.subplots()\n", "for model in models:\n", " ax.plot(energy, fluxes[model], label = f\"Best fit, {model}\",ls='-')\n", - "ax.set_ylabel(\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", + "ax.set_ylabel(r\"dN/dE [$\\mathrm{ph \\ cm^{-2} \\ s^{-1} \\ keV^{-1}}$]\", fontsize=14)\n", "ax.set_xlabel(\"Energy [keV]\", fontsize=14)\n", "ax.set_title(\"Best fit to model\")\n", "ax.legend()\n", @@ -4205,6 +3939,7 @@ }, { "cell_type": "markdown", + "id": "a92bbf0a", "metadata": {}, "source": [ "In summary, we fitted the flux and eccentricity of the disk only, with the all parameters of the bulge component fixed. Considering $b = a \\sqrt{(1-e^2)}$, we recovered the following fitted parameters:\n", @@ -4220,9 +3955,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:cosipy]", + "display_name": "cosipy-312", "language": "python", - "name": "conda-env-cosipy-py" + "name": "cosipy-312" }, "language_info": { "codemirror_mode": { @@ -4234,7 +3969,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/tests/response/test_integrals.py b/tests/response/test_integrals.py new file mode 100644 index 00000000..5bd0ef21 --- /dev/null +++ b/tests/response/test_integrals.py @@ -0,0 +1,192 @@ +### +### Test integration code for assorted Astromodels spectral functions +### + +import numpy as np + +from astromodels import ( + Constant, + Line, + Quadratic, + Cubic, + Quartic, + Band, + Band_grbm, + Powerlaw, + Cutoff_powerlaw, + Gaussian, + DiracDelta, + StepFunction, + StepFunctionUpper, + GenericFunction, +) + +from cosipy.threeml.custom_functions import Band_Eflux + + +from cosipy.response.integrals import get_integral_values + +def test_integrate(): + + x = np.geomspace(10, 10000, num=11) + + ## Constant + const = Constant(k=1e-1) + v = get_integral_values(const, x) + v_q = get_integral_values(const, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Line + line = Line(a=1e-1, b=4e-5) + v = get_integral_values(line, x) + v_q = get_integral_values(line, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Quadratic + quad = Quadratic(a=1e-1, b=4e-5, c=1e-9) + v = get_integral_values(quad, x) + v_q = get_integral_values(quad, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Cubic + cubic = Cubic(a=1e-1, b=4e-5, c=1e-9, d=4e-13) + v = get_integral_values(cubic, x) + v_q = get_integral_values(cubic, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Quartic + quartic = Quartic(a=1e-1, b=4e-5, c=1e-9, d=4e-13, e=1e-17) + v = get_integral_values(quartic, x) + v_q = get_integral_values(quartic, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Test generic function integration (falls back to adaptive + ## quadrature) + gen = GenericFunction() + gen.set_function(lambda x: 1e-1) # like Constant() + v = get_integral_values(gen, x) + v0 = get_integral_values(const, x) + assert np.allclose(v, v0) + + ## Powerlaw + pl = Powerlaw(index=-1, piv=100., K=400.) + v = get_integral_values(pl, x) + v_q = get_integral_values(pl, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Cutoff_powerlaw + + # test all three possible branches based on value of index + # (> -1, negative integer, non-integer < -1) + pl = Cutoff_powerlaw(index=-2.53, piv=100., xc = 400., K=10.) + v = get_integral_values(pl, x) + v_q = get_integral_values(pl, x, force_quad=True) + assert np.allclose(v, v_q) + + pl = Cutoff_powerlaw(index=-2.0, piv=100., xc = 400., K=10.) + v = get_integral_values(pl, x) + v_q = get_integral_values(pl, x, force_quad=True) + assert np.allclose(v, v_q) + + pl = Cutoff_powerlaw(index=-0.9, piv=100., xc = 400., K=10.) + v = get_integral_values(pl, x) + v_q = get_integral_values(pl, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Band + + # test all three possible branches based on value of cutoff + # (less than all of x, greater than all of x, in the middle) + bs = Band(alpha=-0.5, beta=-2.53, piv=100, xp=500, K=10) + v = get_integral_values(bs, x) + v_q = get_integral_values(bs, x, force_quad=True) + assert np.allclose(v, v_q) + + bs = Band(alpha=-0.5, beta=-2.53, piv=100, xp=10, K=10) + bs.xp.min_value = 5. + bs.xp.value = 5. + v = get_integral_values(bs, x) + v_q = get_integral_values(bs, x, force_quad=True) + assert np.allclose(v, v_q) + + bs = Band(alpha=-0.5, beta=-2.53, piv=100, xp=50000, K=10) + v = get_integral_values(bs, x) + v_q = get_integral_values(bs, x, force_quad=True) + assert np.allclose(v, v_q) + + # test cutoff falling right on bin boundary, as opposed + # to between two boundaries + x_simple = np.array([10, 100, 1000, 10000]) + bs = Band(alpha=-1, beta=-2, piv=100, xp=1000, K=10) + v = get_integral_values(bs, x_simple) + v_q = get_integral_values(bs, x_simple, force_quad=True) + assert np.allclose(v, v_q) + + ## Band_grbm (NOT THE SAME AS Band!) + bs = Band_grbm(alpha=-0.5, beta=-2.53, piv=100, xc=500, K=10) + v = get_integral_values(bs, x) + v_q = get_integral_values(bs, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Band_Eflux + bs = Band_Eflux(a=100, b=600, alpha=-0.5, beta=-2.53, E0=500, K=10) + v = get_integral_values(bs, x) + v_q = get_integral_values(bs, x, force_quad=True) + assert np.allclose(v, v_q) + + ## Gaussian + + x = np.linspace(-10,10,num=21) + g = Gaussian(mu=1.1, sigma=2.3, F=2.) + v = get_integral_values(g, x) + v_q = get_integral_values(g, x, force_quad=True) + assert np.allclose(v, v_q) + + ################################################################ + + # These need to be compared to an explicit result, as they can't + # be numerically integrated accurately + + x = np.arange(-10, 11, dtype=np.float64) + + ## StepFunction + step = StepFunction(upper_bound=5, lower_bound=-5, value=3) + v = get_integral_values(step, x) + v0 = [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0] + assert np.allclose(v, v0) + + step = StepFunction(upper_bound=5.5, lower_bound=-5.5, value=3) + v = get_integral_values(step, x) + v0 = [0, 0, 0, 0, 1.5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1.5, 0, 0, 0, 0] + assert np.allclose(v, v0) + + v = get_integral_values(step, x, force_quad=True) # ignored for Step + assert np.allclose(v, v0) + + ## StepFunctionUpper + step = StepFunctionUpper(upper_bound=5, lower_bound=-5, value=3) + v = get_integral_values(step, x) + v0 = [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0] + assert np.allclose(v, v0) + + step = StepFunction(upper_bound=5.5, lower_bound=-5.5, value=3) + v = get_integral_values(step, x) + v0 = [0, 0, 0, 0, 1.5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1.5, 0, 0, 0, 0] + assert np.allclose(v, v0) + + v = get_integral_values(step, x, force_quad=True) # ignored for StepUpper + assert np.allclose(v, v0) + + ## DiracDelta + delta = DiracDelta(value=3, zero_point=1.5) + v = get_integral_values(delta, x) + v0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0] + assert np.allclose(v, v0) + + delta = DiracDelta(value=3, zero_point=1) + v = get_integral_values(delta, x) + v0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0] + assert np.allclose(v, v0) + + v = get_integral_values(delta, x, force_quad=True) # ignored for Delta + assert np.allclose(v, v0) diff --git a/tests/response/test_point_source_response.py b/tests/response/test_point_source_response.py index 799fa01b..1dbf0ef1 100644 --- a/tests/response/test_point_source_response.py +++ b/tests/response/test_point_source_response.py @@ -1,21 +1,19 @@ import numpy as np from numpy import array_equal as arr_eq -from histpy import Histogram, Axes, Axis +from histpy import Histogram from scoords import SpacecraftFrame -from astropy.coordinates import SkyCoord + import astropy.units as u -import h5py as h5 + from astropy.time import Time from astromodels.core.polarization import LinearPolarization -from mhealpy import HealpixBase, HealpixMap +from mhealpy import HealpixMap from cosipy import test_data -from cosipy.response.FullDetectorResponse import cosi_response -from cosipy.response import PointSourceResponse, FullDetectorResponse +from cosipy.response import FullDetectorResponse from threeML import DiracDelta, Constant, Line, Quadratic, Cubic, Quartic from threeML import StepFunction, StepFunctionUpper, GenericFunction -from cosipy.threeml.custom_functions import SpecFromDat import pytest @@ -102,14 +100,14 @@ def test_get_expectation(): step.upper_bound.unit, step.lower_bound.unit, step.value.unit = norm, norm, norm exp = psr.get_expectation(step) assert isinstance(exp, Histogram) - assert np.isclose(np.sum(exp.contents), 2.3038894e+12, rtol=1e-8) - + assert np.isclose(np.sum(exp.contents), 2.300714202190e+12, rtol=1e-8) + ## StepFunctionUpper (same as above except bounds are not "free") step_upper = StepFunctionUpper(upper_bound=3e2, lower_bound=0, value=1) step_upper.upper_bound.unit, step_upper.lower_bound.unit, step_upper.value.unit = norm, norm, norm exp = psr.get_expectation(step_upper) assert isinstance(exp, Histogram) - assert np.isclose(np.sum(exp.contents), 2.3038894e+12, rtol=1e-8) + assert np.isclose(np.sum(exp.contents), 2.300714202190e+12, rtol=1e-8) ## DiracDelta delta = DiracDelta(value=1, zero_point=251.189) @@ -145,4 +143,4 @@ def test_get_expectation(): ## get expectation with polarization exp = psr_pol.get_expectation(const, polarization=LinearPolarization(angle=180, degree=100)) assert isinstance(exp, Histogram) - assert np.isclose(np.sum(exp.contents), 6.30823539e+11, rtol=1e-8) \ No newline at end of file + assert np.isclose(np.sum(exp.contents), 6.30823539e+11, rtol=1e-8)