diff --git a/cosipy/polarization/__init__.py b/cosipy/polarization/__init__.py index 08187a3b..038b4834 100644 --- a/cosipy/polarization/__init__.py +++ b/cosipy/polarization/__init__.py @@ -1,3 +1,4 @@ from .polarization_asad import PolarizationASAD +from .polarization_stokes import PolarizationStokes from .conventions import PolarizationConvention, OrthographicConvention, StereographicConvention, IAUPolarizationConvention from .polarization_angle import PolarizationAngle diff --git a/cosipy/polarization/polarization_stokes.py b/cosipy/polarization/polarization_stokes.py new file mode 100644 index 00000000..0bded79f --- /dev/null +++ b/cosipy/polarization/polarization_stokes.py @@ -0,0 +1,1187 @@ +import numpy as np +from astropy.coordinates import Angle, SkyCoord +import astropy.units as u +import matplotlib.pyplot as plt +from scipy.optimize import curve_fit +from cosipy.polarization.polarization_angle import PolarizationAngle +from cosipy.polarization.conventions import MEGAlibRelativeX, MEGAlibRelativeY, MEGAlibRelativeZ, IAUPolarizationConvention +from cosipy.response import FullDetectorResponse +from scoords import SpacecraftFrame +from threeML import LinearPolarization +import scipy.interpolate as interpolate +from histpy import Histogram + +import logging +logger = logging.getLogger(__name__) + +#we can define all these functions in a separate file to import + +def R(x, A, B, C): + """ Function to fit to the modulation of the azimuthal angle distribution. + """ + return A + B*(np.cos(x + C)**2) + +def constant(x, a): + """ + Constant function to fit to mu_100 values. + + Parameters + ---------- + x : float + Mu_100 + a : float + Parameter + + Returns + ------- + a : float + Constant value + """ + + return a + +def stokes_u(phi): + """ + Calculate the U Stokes parameter from the azimuthal angle phi. + + Parameters + ---------- + phi : float + Azimuthal angle in radians + + Returns + ------- + u : float + U Stokes parameter + """ + return np.sin(phi * 2) * 2 + +def stokes_q(phi): + """ + Calculate the Q Stokes parameter from the azimuthal angle phi. + + Parameters + ---------- + phi : float + Azimuthal angle in radians + + Returns + ------- + q : float + Q Stokes parameter + """ + return np.cos(phi * 2) * 2 + +def rotate_points_to_x_axis(newPD, newPA): + """ + Rotate arrays of points (x_, y_) in the QN-UN plane by an angle + + Parameters + ---------- + newPD : float + Polarization degree + newPA : float + Polarization angle + Returns + ------- + rotated_Q : float + Q Stokes parameter + rotated_U : float + U Stokes parameter + + """ + # Create a matrix of rotation matrices for each point + rotated_Q = newPD * np.cos(2 * newPA) + rotated_U = newPD * np.sin(2 * newPA) + + return rotated_Q, rotated_U + +def polar_chart_backbone(ax): + """ Preparing canvas for Stokes chart + Parameters + ---------- + ax : matplotlib.axes._axes.Axes + Axes to plot on + """ + ax.spines['top'].set_visible(True) + ax.spines['right'].set_visible(True) + c0 = plt.Circle((0,0), radius=0.25, facecolor='none', edgecolor='k', linewidth=1, linestyle='--', alpha=0.3) + c1 = plt.Circle((0,0), radius=0.50, facecolor='none', edgecolor='k', linewidth=1, linestyle='--', alpha=0.3) + c2 = plt.Circle((0,0), radius=0.75, facecolor='none', edgecolor='k', linewidth=1, linestyle='--', alpha=0.3) + c3 = plt.Circle((0,0), radius=1.00, facecolor='none', edgecolor='k', linewidth=1, linestyle='-', alpha=0.5) + plt.gca().add_artist(c0) + plt.gca().add_artist(c1) + plt.gca().add_artist(c2) + plt.gca().add_artist(c3) + plt.annotate('0.25', (0.25, 0), textcoords="offset points", xytext=(10,0), ha='center', fontsize=8, color='k', alpha=0.3) + plt.annotate('0.50', (0.50, 0), textcoords="offset points", xytext=(10,0), ha='center', fontsize=8, color='k', alpha=0.3) + plt.annotate('0.75', (0.75, 0), textcoords="offset points", xytext=(10,0), ha='center', fontsize=8, color='k', alpha=0.3) + plt.annotate('1.00', (1.00, 0), textcoords="offset points", xytext=(10,0), ha='center', fontsize=8, color='k', alpha=0.3) + plt.hlines(0, -1, 1, linewidth=1, color='k', linestyle='--', alpha=0.3) + plt.vlines(0, -1, 1, linewidth=1, color='k', linestyle='--', alpha=0.3) + plt.plot([1,-1], [1,-1], linewidth=1, color='k', linestyle='--', alpha=0.3) + plt.plot([1,-1], [-1,1], linewidth=1, color='k', linestyle='--', alpha=0.3) + +def calculate_azimuthal_scattering_angle(psi, chi, source_vector, reference_vector): + """ + Calculate the azimuthal scattering angle of a scattered photon. + + Parameters + ---------- + psi : float + Polar angle (radians) of scattered photon in local coordinates + chi : float + Azimuthal angle (radians) of scattered photon in local coordinates + source_vector : astropy.coordinates.SkyCoord + Source direction + reference_vector : astropy.coordinates.SkyCoord + Reference direction (e.g. X-axis of spacecraft frame) + + Returns + ------- + azimuthal_angle : astropy.coordinates.Angle + Azimuthal scattering angle defined with respect to given reference vector + """ + + source_vector_cartesian = [source_vector.cartesian.x.value, + source_vector.cartesian.y.value, + source_vector.cartesian.z.value] + reference_vector_cartesian = [reference_vector.cartesian.x.value, + reference_vector.cartesian.y.value, + reference_vector.cartesian.z.value] + + # Convert scattered photon vector from spherical to Cartesian coordinates + scattered_photon_vector = [np.sin(psi) * np.cos(chi), np.sin(psi) * np.sin(chi), np.cos(psi)] + + # Project scattered photon vector onto plane perpendicular to source direction + d = np.dot(scattered_photon_vector, source_vector_cartesian) / np.dot(source_vector_cartesian, source_vector_cartesian) + projection = [scattered_photon_vector[0] - (d * source_vector_cartesian[0]), + scattered_photon_vector[1] - (d * source_vector_cartesian[1]), + scattered_photon_vector[2] - (d * source_vector_cartesian[2])] + + # Calculate angle between scattered photon vector & reference vector on plane perpendicular to source direction + cross_product = np.cross(projection, reference_vector_cartesian) + if np.dot(source_vector_cartesian, cross_product) < 0: + sign = -1 + else: + sign = 1 + normalization = np.sqrt(np.dot(projection, projection)) * np.sqrt(np.dot(reference_vector_cartesian, reference_vector_cartesian)) + + azimuthal_angle = Angle(sign * np.arccos(np.dot(projection, reference_vector_cartesian) / normalization), unit=u.rad) + + return azimuthal_angle + +def get_modulation(_x, _y, title='Modulation', show=False): + """ Function to estimate the modulation factor. + _x is the central value of the histogram bins + _y is the value of the bins on the histograms + + Parameters + ---------- + _x : array + Central values of the histogram bins + _y : array + Values of the histogram bins + title : str + Title of the plot + show : bool + Whether to show the plot or not + + Returns + ------- + mu : float + Modulation factor + mu_err : float + Error on the modulation factor + """ + + popt, pcov = curve_fit(R, _x, _y ) #sigma=np.sqrt(_y), absolute_sigma=True + pcov[0][0], pcov[1][1], pcov[2][2] = np.sqrt(pcov[0][0]), np.sqrt(pcov[1][1]), np.sqrt(pcov[2][2]) + print('A = %.2f, B = %.2f, C = %.2f'%(popt[0], popt[1], popt[2])) + + Rmax, Rmin = np.amax(R(_x, *popt)), np.amin(R(_x, *popt)) + print('Rmax, Rmin:', Rmax, Rmin) + mu = (Rmax-Rmin)/(Rmax+Rmin) + print('Modulation mu = ', mu) + + mu_err = 2/(popt[1]+2*popt[0])**2 * np.sqrt(popt[1]**2 * pcov[0][0]**2 + popt[0]**2 * pcov[1][1]**2) + + if show: + + plt.figure() + plt.title(title) + plt.step(_x, _y, where='mid') + perr = [popt[0]+np.sqrt(pcov[0][0]), popt[1]+np.sqrt(pcov[1][1]), popt[2]] + merr = [popt[0]-np.sqrt(pcov[0][0]), popt[1]-np.sqrt(pcov[1][1]), popt[2]] + plt.fill_between(_x, R(_x, *perr), R(_x, *merr), color='red', alpha=0.3) + plt.plot(_x, R(_x, *popt), 'r-', label=r'$\mu=$%.3f'%(mu)) + plt.legend(fontsize=12) + plt.xlabel('Azimuthal angle [rad]') + plt.savefig('%s'%title) + + return mu, mu_err + +def create_asad_from_response(spectrum, polarization_level, polarization_angle, source_vector, ori, response, + convention, response_file, response_convention, bins=20): + """ + Convolve source spectrum with response and calculate azimuthal scattering angle bins. + + Parameters + ---------- + spectrum : :py:class:`threeML.Model` + Spectral model. + polarization_level : float + Polarization level (between 0 and 1). + polarization_angle : :py:class:`cosipy.polarization.polarization_angle.PolarizationAngle` + Polarization angle. If in the spacecraft frame, the angle must have the same convention as the response. + bins : int or astropy.units.quantity.Quantity, optional + Number of azimuthal scattering angle bins if int or array of edges of azimuthal scattering angle bins if Quantity + source_vector : astropy.coordinates.sky_coordinate.SkyCoord + Source direction + ori : cosipy.spacecraftfile.SpacecraftFile.SpacecraftFile + Spacecraft orientation + response : cosipy.response.FullDetectorResponse.FullDetectorResponse + Response object + convention : cosipy.polarization.PolarizationConvention + Polarization convention + response_file : str or pathlib.Path + Path to detector response + response_convention : str + Response convention. If in the spacecraft frame, the angle must have the same convention as the response. + + Returns + ------- + asad : histpy.Histogram + Counts in each azimuthal scattering angle bin + """ + + if isinstance(convention.frame, SpacecraftFrame): + + target_in_sc_frame = ori.get_target_in_sc_frame(target_name='source', target_coord=source_vector.transform_to('galactic')) + dwell_time_map = ori.get_dwell_map(response=response_file, src_path=target_in_sc_frame, pa_convention=response_convention) + psr = response.get_point_source_response(exposure_map=dwell_time_map, coord=source_vector.transform_to('galactic')) + expectation = psr.get_expectation(spectrum, LinearPolarization(polarization_level * 100., polarization_angle.angle.deg)) + + azimuthal_angle_bins = [] + + for i in range(expectation.axes['PsiChi'].nbins): + psichi = SkyCoord(lat=(np.pi/2) - expectation.axes['PsiChi'].pix2ang(i)[0], lon=expectation.axes['PsiChi'].pix2ang(i)[1], unit=u.rad, frame=convention.frame) + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, source_vector, convention) + azimuthal_angle_bins.append(azimuthal_angle.angle) + + else: + + scatt_map = ori.get_scatt_map(nside=response.nside*2, target_coord=source_vector) + # scatt_map = ori.get_scatt_map(nside=response.nside*2, target_coord=source_vector, coordsys='galactic') + psr = response.get_point_source_response(coord=source_vector, scatt_map=scatt_map) + expectation = psr.get_expectation(spectrum, LinearPolarization(polarization_level * 100., polarization_angle.angle.deg)) + + azimuthal_angle_bins = [] + + for i in range(expectation.axes['PsiChi'].nbins): + psichi = expectation.axes['PsiChi'].pix2skycoord(i).transform_to('icrs') + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, source_vector, convention) + azimuthal_angle_bins.append(azimuthal_angle.angle) + + if isinstance(bins, int): + bin_edges = Angle(np.linspace(-np.pi, np.pi, bins), unit=u.rad) + else: + bin_edges = bins + + asad = [] + + for i in range(len(bin_edges)-1): + counts = 0 + for j in range(expectation.project(['PsiChi']).nbins): + if azimuthal_angle_bins[j] >= bin_edges[i] and azimuthal_angle_bins[j] < bin_edges[i+1]: + counts += expectation.project(['PsiChi'])[j] + asad.append(counts) + + asad = Histogram(bin_edges, contents=asad) + + return asad + +def create_unpolarized_asad(spectrum, source_vector, ori, response, convention, response_file, response_convention, bins=20): + """ + Create unpolarized ASAD from response. + + Parameters + ---------- + bins : int or astropy.units.quantity.Quantity, optional + Number of azimuthal scattering angle bins if int or array of edges of azimuthal scattering angle bins if Quantity + spectrum : :py:class:`threeML.Model` + Spectral model. + source_vector : astropy.coordinates.sky_coordinate.SkyCoord + Source direction: + ori : cosipy.spacecraftfile.SpacecraftFile.SpacecraftFile + Spacecraft orientation + response : cosipy.response.FullDetectorResponse.FullDetectorResponse + Response object + convention : cosipy.polarization.PolarizationConvention + Polarization convention + response_file : str or pathlib.Path + Path to detector response + response_convention : str + Response convention. If in the spacecraft frame, the angle must have the same convention as the response. + Returns + ------- + asad : histpy.Histogram + Counts in each azimuthal scattering angle bin + """ + pd = 0 + pa = PolarizationAngle(Angle(0 * u.deg), source_vector, convention=convention) + unpolarized_asad = create_asad_from_response(spectrum, pd, pa, source_vector, ori, + response, convention, response_file, + response_convention, bins=bins) + + return unpolarized_asad + +def create_polarized_asads(spectrum, source_vector, ori, response, convention, response_file, response_convention, bins=20): + """ + Create 100% polarized ASADs for each polarization angle bin of response. + + Parameters + ---------- + bins : int or astropy.units.quantity.Quantity, optional + Number of azimuthal scattering angle bins if int or array of edges of azimuthal scattering angle bins if Quantity + + Returns + ------- + polarized_asads : dict of histpy.Histogram + Counts in each azimuthal scattering angle bin for each polarization angle bin + """ + + polarized_asads = {} + for k in range(response.axes['Pol'].nbins): + pd = 1 + pa = PolarizationAngle(Angle(response.axes['Pol'].centers.to_value(u.deg)[k] * u.deg), source_vector, convention=convention) + polarized_asads[k] = create_asad_from_response(spectrum, pd, pa, source_vector, ori, + response, convention, response_file, + response_convention, bins=bins) + return polarized_asads + +class PolarizationStokes(): + """ + Stokes parameter method to fit polarization. + + Parameters + ---------- + source_vector : astropy.coordinates.sky_coordinate.SkyCoord + Source direction + source_spectrum : astromodels.functions.functions_1D + Spectrum of source + + data : list of dict + Data to fit + background : list of dict + Background to fit + response_convention : str + Response convention + response_file : str or pathlib.Path + Path to detector response + sc_orientation : cosipy.spacecraftfile.SpacecraftFile.SpacecraftFile + Spacecraft orientation + fit_convention : cosipy.polarization.PolarizationConvention + Polarization convention for the fit + show_plots : bool + Whether to show plots or not + """ + + + def __init__(self, source_vector, source_spectrum, data, + response_file, sc_orientation, background=None, response_convention='RelativeX', + fit_convention=IAUPolarizationConvention(), asad_bin_edges=None, show_plots=False): + + ###################### This will need to be changed into IAUPolarizationConvention hardcoded! + ###################### + print('This class loading takes around 30 seconds... \n') + ###################### + + if isinstance(fit_convention.frame, SpacecraftFrame) and not isinstance(source_vector.frame, SpacecraftFrame): + attitude = sc_orientation.get_attitude()[0] + source_vector = source_vector.transform_to(SpacecraftFrame(attitude=attitude)) + logger.warning('The source direction is being converted to the spacecraft frame using the attitude at the first timestamp of the orientation.') + elif not isinstance(fit_convention.frame, SpacecraftFrame): + source_vector = source_vector.transform_to('icrs') + + if ((isinstance(fit_convention, MEGAlibRelativeX) and response_convention != 'RelativeX') or + (isinstance(fit_convention, MEGAlibRelativeY) and response_convention != 'RelativeY') or + (isinstance(fit_convention, MEGAlibRelativeZ) and response_convention != 'RelativeZ')): + raise RuntimeError("If performing fit in spacecraft frame, fit convention must match convention of response.") + + # if not type(data) == list: + # self._data = [data] + # else: + # self._data = data + + self.SHOW_PLOTS = show_plots + + self._ori = sc_orientation + + self._convention = fit_convention + + self._response_convention = response_convention + + self._response_file = response_file + + self._response = FullDetectorResponse.open(response_file, pa_convention=self._response_convention) + + self._source_vector = source_vector + + self._spectrum = source_spectrum + + self._nbins = self._response.axes['Pol'].nbins + print('Number of azimuthal angle bins used:', self._nbins) + + self.asad_bin_edges = asad_bin_edges + + # self._binedges = Angle(np.linspace(-np.pi, np.pi, self._nbins), unit=u.rad) + + self._reference_vector = self._convention.get_basis(source_vector)[0] + + self._expectation, self._azimuthal_angle_bins = self.convolve_spectrum(source_spectrum) + + self._energy_range = [min(self._response.axes['Em'].edges.value), max(self._response.axes['Em'].edges.value)] + #print the energy range considered due to responses: + print(f'Energy range considered (by responses design): {self._energy_range[0]} - {self._energy_range[1]} keV') + + # do a data cut before anything else! actually this should come as a separate routine: data selection and response + # prep shold be done before analyzing the data + if not type(data) == list: + iii = np.where((data['Energies'] >= self._energy_range[0]) & (data['Energies'] <= self._energy_range[1])) + self._data = [{key: data[key][iii] for key in data.keys()}] + else: + data_ecut_list = [] + for dlist in data: + iii = np.where((dlist['Energies'] >= self._energy_range[0]) & (dlist['Energies'] <= self._energy_range[1])) + data_ecut = {key: dlist[key][iii] for key in dlist.keys()} + data_ecut_list.append(data_ecut) + self._data = data_ecut_list + + self._exposure = sc_orientation.get_time_delta().to_value(u.second).sum() + + self._data_duration = self.get_data_duration() + + self._data_counts = self.get_data_counts() + + self._data_azimuthal_angles = self.calculate_azimuthal_scattering_angles(self._data, show_plots=self.SHOW_PLOTS) + + self._background = background + + if self._background is not None: + print('Background provided. Make sure there is enough statistics.') + if not type(background) == list: + iii = np.where((background['Energies'] >= self._energy_range[0]) & (background['Energies'] <= self._energy_range[1])) + self._background = [{key: background[key][iii] for key in background.keys()}] + else: + background_ecut_list = [] + for bkg in background: + iii = np.where((bkg['Energies'] >= self._energy_range[0]) & (bkg['Energies'] <= self._energy_range[1])) + background_ecut = {key: bkg[key][iii] for key in bkg.keys()} + background_ecut_list.append(background_ecut) + self._background = background_ecut_list + + self._background_azimuthal_angles = self.calculate_azimuthal_scattering_angles(self._background) + self._background_duration = self.get_background_duration() + else: + print('No background provided. Will not subtract background from data.') + self._background = None + self._background_duration = 0 + self._background_azimuthal_angles = None + + self._mu100 = self.calculate_average_mu100(asad_bin_edges=self.asad_bin_edges, show_plots=False) + + self._mdp99 = self.calculate_mdp(modulation_factor=self._mu100['mu']) + + def get_data_counts(self): + """ + Calculate the total counts in the data. + + Returns + ------- + data_counts : int + Total counts in the data + """ + data_counts = 0 + for i in range(len(self._data)): + if type(self._data[i]) == dict: + data_counts += len(self._data[i]['TimeTags']) + else: + data_counts += self._data[i].binned_data.axes['Time'].nbins + + return data_counts + + def get_data_duration(self): + """ + Calculate the total duration of the data. + + Returns + ------- + data_duration : float + Total duration of the data in seconds + """ + for i in range(len(self._data)): + + if type(self._data[i]) == dict: + + if i == 0: + source_duration = np.max(self._data[i]['TimeTags']) - np.min(self._data[i]['TimeTags']) + else: + source_duration += np.max(self._data[i]['TimeTags']) - np.min(self._data[i]['TimeTags']) + + else: + + if i == 0: + source_duration = (np.max(self._data[i].binned_data.axes['Time'].edges) - np.min(self._data[i].binned_data.axes['Time'].edges)).value + else: + source_duration += (np.max(self._data[i].binned_data.axes['Time'].edges) - np.min(self._data[i].binned_data.axes['Time'].edges)).value + + return source_duration + + def get_background_duration(self): + """ + Calculate the total duration of the data. + Returns + ------- + background_duration : float + Total duration of the data in seconds + """ + if self._background is None: + background_duration = 0 + else: + for i in range(len(self._background)): + + if type(self._background[i]) == dict: + if i == 0: + background_duration = np.max(self._background[i]['TimeTags']) - np.min(self._background[i]['TimeTags']) + else: + background_duration += np.max(self._background[i]['TimeTags']) - np.min(self._background[i]['TimeTags']) + + else: + + if i == 0: + background_duration = (np.max(self._background[i].binned_data.axes['Time'].edges) - np.min(self._background[i].binned_data.axes['Time'].edges)).value + else: + background_duration += (np.max(self._background[i].binned_data.axes['Time'].edges) - np.min(self._background[i].binned_data.axes['Time'].edges)).value + return background_duration + + def get_backscal(self): + """ + Calculate the background scaling factor to match the source duration. + + Returns + ------- + backscal : float + Background scaling factor + """ + if self._background_duration == 0: + logger.warning('Background duration is zero, returning backscal = 0') + backscal = None + else: + backscal = self._data_duration / self._background_duration + + return backscal + + def convolve_spectrum(self, spectrum): + """ + Convolve source spectrum with response and calculate azimuthal scattering angle bins. + + Parameters + ---------- + response_file : str or pathlib.Path + Path to detector response + sc_orientation : cosipy.spacecraftfile.SpacecraftFile.SpacecraftFile + Spacecraft orientation + + Returns + ------- + expectation : cosipy.response.PointSourceResponse.PointSourceResponse + Expected counts in each bin of Compton data space + azimuthal_angle_bins : list + Centers of azimuthal scattering angle bins calculated from PsiChi bins in response + """ + polarization_angle = PolarizationAngle(Angle(self._response.axes['Pol'].centers.to_value(u.deg)[0] * u.deg), self._source_vector, convention=self._convention) + polarization_level = 0 + if isinstance(self._convention.frame, SpacecraftFrame): + print('>>> Convolving spectrum in spacecraft frame...') + target_in_sc_frame = self._ori.get_target_in_sc_frame(target_name='source', target_coord=self._source_vector.transform_to('galactic')) + dwell_time_map = self._ori.get_dwell_map(response=self._response_file, src_path=target_in_sc_frame, pa_convention=self._response_convention) + psr = self._response.get_point_source_response(exposure_map=dwell_time_map, coord=self._source_vector.transform_to('galactic')) + expectation = psr.get_expectation(spectrum, LinearPolarization(polarization_level * 100., polarization_angle.angle.deg)) + + azimuthal_angle_bins = [] + + for i in range(expectation.axes['PsiChi'].nbins): + psichi = SkyCoord(lat=(np.pi/2) - expectation.axes['PsiChi'].pix2ang(i)[0], lon=expectation.axes['PsiChi'].pix2ang(i)[1], unit=u.rad, frame=self._convention.frame) + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, self._source_vector, self._convention) + azimuthal_angle_bins.append(azimuthal_angle.angle) + + else: + print('>>> Convolving spectrum in ICRS frame...') + scatt_map = self._ori.get_scatt_map(nside=self._response.nside*2, target_coord=self._source_vector) + # scatt_map = self._ori.get_scatt_map(nside=self._response.nside*2, target_coord=self._source_vector, coordsys='galactic') + psr = self._response.get_point_source_response(coord=self._source_vector, scatt_map=scatt_map) + expectation = psr.get_expectation(spectrum, LinearPolarization(polarization_level * 100., polarization_angle.angle.deg)) + + azimuthal_angle_bins = [] + + for i in range(expectation.axes['PsiChi'].nbins): + psichi = expectation.axes['PsiChi'].pix2skycoord(i).transform_to('icrs') + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, self._source_vector, self._convention) + azimuthal_angle_bins.append(azimuthal_angle.angle) + + return expectation, azimuthal_angle_bins + + def calculate_azimuthal_scattering_angles(self, unbinned_data, show_plots=False): + """ + Calculate the azimuthal scattering angles for all events in a dataset. + + Parameters + ---------- + unbinned_data : dict + Unbinned data including polar and azimuthal angles (radians) of scattered photon in local coordinates + + Returns + ------- + azimuthal_angles : list of astropy.coordinates.Angle + Azimuthal scattering angles + """ + azimuthal_angles = [] + + if isinstance(self._convention.frame, SpacecraftFrame): + for i in range(len(unbinned_data['Psi local'])): + # if unbinned_data['Energies'][i] >= self._energy_range[0] and unbinned_data['Energies'][i] <= self._energy_range[1]: + psichi = SkyCoord(lat=(np.pi/2) - unbinned_data['Psi local'][i], lon=unbinned_data['Chi local'][i], unit=u.rad, frame=self._convention.frame) + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, self._source_vector, self._convention) + azimuthal_angles.append(azimuthal_angle.angle) + else: + if len(unbinned_data) < 2: + + for i in range(len(unbinned_data[0]['Psi galactic'])): + # if unbinned_data[0]['Energies'][i] >= self._energy_range[0] and unbinned_data[0]['Energies'][i] <= self._energy_range[1]: + psichi = SkyCoord(l=unbinned_data[0]['Chi galactic'][i], b=unbinned_data[0]['Psi galactic'][i], frame='galactic', unit=u.deg).transform_to('icrs') + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, self._source_vector, self._convention) + azimuthal_angles.append(azimuthal_angle.angle) + else: + for j in range(len(unbinned_data)): + for i in range(len(unbinned_data[j]['Psi galactic'])): + # if unbinned_data[j]['Energies'][i] >= self._energy_range[0] and unbinned_data[j]['Energies'][i] <= self._energy_range[1]: + psichi = SkyCoord(l=unbinned_data[j]['Chi galactic'][i], b=unbinned_data[j]['Psi galactic'][i], frame='galactic', unit=u.deg).transform_to('icrs') + azimuthal_angle = PolarizationAngle.from_scattering_direction(psichi, self._source_vector, self._convention) + azimuthal_angles.append(azimuthal_angle.angle) + + if show_plots: + plt.figure() + plt.title('Azimuthal scattering angles') + plt.hist(azimuthal_angles, bins=50, alpha=0.5, label='Data fine binning') + plt.hist(azimuthal_angles, bins=self._nbins, alpha=0.5, + histtype='step', linewidth=2, label='Response binning') + plt.xlabel('Azimuthal angle (radians)') + plt.ylabel('Counts') + plt.legend() + plt.show() + + return azimuthal_angles + + def calculate_average_mu100(self, asad_bin_edges=None, show_plots=False): + """ + Calculate the modulation (mu) of an 100% polarized source. + + Parameters + ---------- + asad_bin_edges : array-like, optional + Bin edges for the ASAD. If None, default binning is used. + show_plots : bool, optional + Option to show plots. Default is False + + Returns + ------- + mu_100 : dict + Modulation of 100% polarized source and uncertainty of constant function fit to modulation in all polarization angle bins + """ + + if asad_bin_edges is not None: + self._nbins = asad_bin_edges + print('Custom Number of azimuthal angle bins used:', self._nbins) + + print('Creating the 100% polarized ASADs (this may take a minute...)') + polarized_asads = create_polarized_asads(self._spectrum, self._source_vector, self._ori, self._response, + self._convention, self._response_file, self._response_convention, bins=self._nbins) + print('Creating the unpolarized ASAD...') + unpolarized_asad = create_unpolarized_asad(self._spectrum, self._source_vector, self._ori, self._response, + self._convention, self._response_file, self._response_convention, bins=self._nbins) + mu_100_list = [] + mu_100_uncertainties = [] + + for i in range(self._response.axes['Pol'].nbins): + logger.info('Polarization angle bin: ' + str(self._response.axes['Pol'].edges.to_value(u.deg)[i]) + ' to ' + str(self._response.axes['Pol'].edges.to_value(u.deg)[i+1]) + ' deg') + asad_corrected = polarized_asads[i] / np.sum(polarized_asads[i]) / unpolarized_asad * np.sum(unpolarized_asad) + mu, mu_err = get_modulation(asad_corrected.axis.centers.value, asad_corrected.full_contents, + title='Modulation PA bin %i'%i, show=show_plots) + mu_100_list.append(mu) + mu_100_uncertainties.append(mu_err) + + popt, pcov = curve_fit(constant, self._response.axes['Pol'].centers.to_value(u.deg), mu_100_list, + sigma=mu_100_uncertainties, p0=np.mean(mu_100_list), absolute_sigma=True) + mu_100 = {'mu': popt[0], 'uncertainty': pcov[0][0]} + + if show_plots == True: + plt.figure() + plt.scatter(self._response.axes['Pol'].centers.to_value(u.deg), mu_100_list) + plt.errorbar(self._response.axes['Pol'].centers.to_value(u.deg), mu_100_list, + yerr=mu_100_uncertainties, linewidth=0, elinewidth=1) + plt.plot([0, 175], [mu_100['mu'], mu_100['mu']]) + plt.xlabel('Polarization Angle (degrees)') + plt.ylabel('mu_100') + plt.show() + + return mu_100 + + def compute_pseudo_stokes(self, azimuthal_angles, show_plots=False): + """ + Calculates photon-by-photon pseudo stokes parameters from the photon azimutal angle. + + Parameters + ---------- + azimuthal_angles : list + Azimuthal scattering angles (radians) + + Returns + ------- + qs : list + list of pseudo-q parameters for each photon (ordered as input array) + us : list + list of pseudo-u parameters for each photon (ordered as input array) + """ + + qs, us = [], [] + + #this is stupid... need to fix! + try: + for a in azimuthal_angles.value: + qs.append(stokes_q(a - np.pi/2)) + us.append(stokes_u(a - np.pi/2)) + except: + + for a in azimuthal_angles: + qs.append(stokes_q(a.value - np.pi/2)) + us.append(stokes_u(a.value - np.pi/2)) + + if show_plots: + plt.figure() + plt.title('Source Stokes parameters') + plt.hist(qs, bins=50, alpha=0.5, label='q$_s$') + plt.hist(us, bins=50, alpha=0.5, label='u$_s$') + plt.xlabel('Pseudo Stokes parameter') + plt.legend() + plt.show() + + return qs, us + + def compute_data_pseudo_stokes(self, show_plots=False): + """ + Calculates photon-by-photon pseudo stokes parameters from the photon azimutal angle. + + Parameters + ---------- + show : bool, optional + If True, display a diagnostic plot in the Q-U plane with + uncertainty circles, by default False. + + Returns + ------- + qs : list + list of pseudo-q parameters for each photon (ordered as input array) + us : list + list of pseudo-u parameters for each photon (ordered as input array) + """ + + qs, us = [], [] + ###################### + # ATTENTION: I need to add 90 degrees because the stokes convention assumes that EVPA // + # source polarization, while for Compton scatttering it is perpendicular) + try: + for a in self._data_azimuthal_angles.value: + qs.append(stokes_q(a - np.pi/2)) + us.append(stokes_u(a - np.pi/2)) + except: + + for a in self._data_azimuthal_angles: + qs.append(stokes_q(a.value - np.pi/2)) + us.append(stokes_u(a.value - np.pi/2)) + + if show_plots: + plt.figure() + plt.title('Source Stokes parameters (%i events)'%len(qs)) + plt.hist(qs, bins=50, alpha=0.5, label='q$_s$') + plt.hist(us, bins=50, alpha=0.5, label='u$_s$') + plt.xlabel('Pseudo Stokes parameter') + plt.legend() + plt.show() + + return qs, us + + def compute_background_pseudo_stokes(self, show_plots=False): + """ + Calculates photon-by-photon pseudo stokes parameters from the photon azimutal angle. + + Parameters + ---------- + azimuthal_angles : list + Azimuthal scattering angles (radians) + + Returns + ------- + qs : list + list of pseudo-q parameters for each photon (ordered as input array) + us : list + list of pseudo-u parameters for each photon (ordered as input array) + """ + + qs, us = [], [] + + if self._background_azimuthal_angles is None: + logger.warning('No background data provided, returning empty lists for pseudo Stokes parameters.') + return 0 + + else: + try: + for a in self._background_azimuthal_angles.value: + qs.append(stokes_q(a - np.pi/2)) + us.append(stokes_u(a - np.pi/2)) + except: + + for a in self._background_azimuthal_angles: + qs.append(stokes_q(a.value - np.pi/2)) + us.append(stokes_u(a.value - np.pi/2)) + + if show_plots: + plt.figure() + plt.title('Background Stokes parameters (%i events)'%len(qs)) + plt.hist(qs, bins=50, alpha=0.5, label='q$_b$') + plt.hist(us, bins=50, alpha=0.5, label='u$_b$') + plt.xlabel('Pseudo Stokes parameter') + plt.legend() + plt.show() + + return qs, us + + def calculate_mdp(self, modulation_factor): + """ + Calculate the minimum detectable polarization (MDP) of the source. + + Returns + ------- + mdp : float + MDP of source + """ + if not type(self._data) == list: + source_counts = 0 + for i in range(len(self._data)): + source_counts += len(self._data[i]['TimeTags']) + else: + source_counts = len(self._data[0]['TimeTags']) + source_data_rate = source_counts / self._data_duration + + if self._background is not None: + if type(self._background) == list: + background_counts = 0 + for i in range(len(self._background)): + background_counts += len(self._background[i]['TimeTags']) + else: + background_counts = self._background[0]['TimeTags'] + + background_data_rate = background_counts / self._background_duration + mdp = 4.29 / modulation_factor * np.sqrt(source_data_rate/self._data_duration + background_data_rate/self._background_duration) / source_data_rate + else: + mdp = 4.29 / modulation_factor / np.sqrt(source_counts) + + logger.info('Minimum detectable polarization (MDP) of source: ' + str(round(mdp, 3))) + + return mdp + + def simulate_unpolarized_stokes(self, n_samples=100, show_plots=False): + """ + Simulate unpolarized Stokes parameters from the source data. + The simulated data have the same statistics as the source data, but are unpolarized. + We use the response files given in input. + This is useful to estimate the background contribution to the polarization measurement. + 1. Create unpolarized ADAS + 2. Calculate pseudo Stokes parameters from the azimuthal scattering angles + 3. repeat for a number of samples + 4. compute the average and standard deviation of the pseudo Stokes parameters + + Parameters + ---------- + n_samples : int, optional + Number of samples to simulate, by default 100. + show_plots : bool, optional + If True, display a diagnostic plot in the Q-U plane with + uncertainty circles, by default False. + + Returns + ------- + qs_unpol : list + List of pseudo-q parameters for each simulated unpolarized photon (ordered as input array) + us_unpol : list + List of pseudo-u parameters for each simulated unpolarized photon (ordered as input array) + """ + + unpolarized_asad = create_unpolarized_asad(self._spectrum, self._source_vector, self._ori, + self._response, self._convention, + self._response_file, self._response_convention, bins=self._nbins) + azimuthal_bin_center = unpolarized_asad.axis.centers.value # Get the bin edges of the azimuthal angle distribution + # Create the spline from the unpol azimutal angle distrib + spline_unpol = interpolate.interp1d(azimuthal_bin_center, unpolarized_asad.full_contents) + #plot the unpolarized azimuthal angle distribution + if show_plots: + plt.figure() + plt.title('Unpolarized azimuthal angle distribution') + plt.step(azimuthal_bin_center, unpolarized_asad.full_contents, where='mid', label='Unpolarized ASAD') + plt.xlabel('Azimuthal angle [rad]') + plt.ylabel('Counts') + + # Create fine bins and normalize to the area to get a probability density function (PDF) + # also, avoiding edges that wouls break the spline + fine_bins = np.linspace(azimuthal_bin_center[0]-0.01*azimuthal_bin_center[0], + azimuthal_bin_center[-2]-0.01*azimuthal_bin_center[-2], 1000) + fine_probabilities = spline_unpol(fine_bins) + # total_area = np.trapz(fine_probabilities, fine_bins) # Numerical integration using trapezoidal rule + fine_probabilities /= np.sum(fine_probabilities)#total_area + + #Generate random samples from a uniform distribution and map them to azimuthal angles + _qs_unpol_, _us_unpol_ = [], [] + print('Simulating unpolarized Stokes parameters from the source data...') + for _ in range(n_samples): + unpol_azimuthal_angles = np.random.choice(fine_bins, size=self._data_counts, p=fine_probabilities) * u.rad + qs_unpol_, us_unpol_ = self.compute_pseudo_stokes(unpol_azimuthal_angles, show_plots=False) + _qs_unpol_.append(qs_unpol_) + _us_unpol_.append(us_unpol_) + + # Convert lists to numpy arrays for easier manipulation + _qs_unpol_ = np.array(_qs_unpol_) + _us_unpol_ = np.array(_us_unpol_) + #Average over the samples + + if show_plots: + plt.figure() + plt.title('Unpolarized Stokes parameters (averaged over %i samples)' % n_samples) + for i in range(n_samples): + plt.hist(_qs_unpol_[i], bins=50, alpha=0.1, color='tab:blue') + plt.hist(_us_unpol_[i], bins=50, alpha=0.1, color='tab:orange') + plt.xlabel('Pseudo Stokes parameter') + plt.legend() + plt.show() + + return _qs_unpol_, _us_unpol_ + + def calculate_polarization(self, qs, us, mu, bkg_qs=None, bkg_us=None, show_plots=False, ref_qu=(None, None), + ref_pdpa=(None, None), ref_label=None, mdp=None): + """ + Calculate the polarization degree (PD), polarization angle (PA), + and their associated 1-sigma uncertainties given Q and U measurements + from both polarized and unpolarized data sets. + + This implements equations (21), (22), (36), and (37) from Kislat et al. (2015). + + Parameters + ---------- + qs : array-like + Array of Q measurements (from polarized source). + us : array-like + Array of U measurements (from polarized source). + mu : float + Modulation factor. Used to convert raw measurements into normalized Q/I and U/I. + bkg_qs : array-like, optional + Array of Q measurements from unpolarized background or simulation data, by default None. + bkg_us : array-like, optional + Array of U measurements from unpolarized background or simulation data, by default None. + show_plots : bool, optional + If True, display a diagnostic plot in the Q-U plane with + uncertainty circles, by default False. + ref_qu : tuple of (float or None, float or None), optional + Reference (Q, U) point (e.g., from simulation) to be plotted for comparison, + by default (None, None) (no reference shown). + ref_pdpa : tuple of (float or None, float or None), optional + Reference (PD, PA) point (e.g., from simulation) to be converted to Q/U + and plotted for comparison, by default (None, None) (no reference shown). + ref_label : str, optional + Label for the reference point in the plot, by default None (no label shown). + mdp : float, optional + Minimum detectable polarization (MDP) value to be used for uncertainty calculations, + by default None (no MDP used). + + Returns + ------- + polarization: dict + + fraction : float + Polarization degree, PD = sqrt(Q^2 + U^2). + fraction_uncertainty : float + 1-sigma statistical uncertainty on the polarization degree. + angle : astropy.coordinates.Angle + Polarization angle (in radians internally), + computed as 90 - 0.5 * arctan2(U, Q) (converted into an Angle object). + angle_uncertainty : float + 1-sigma statistical uncertainty on the polarization angle (in degrees). + """ + BACKSCAL = self.get_backscal() + + if BACKSCAL is None: + logger.warning('Background scaling factor is None, assuming the unpolarized signal'+ + 'has been simulated with the same statistics as THE data') + BACKSCAL = 1 + + pol_I = I = len(qs) + pol_Q = np.sum(qs) / mu + pol_U = np.sum(us) / mu + print('I, Q, U, mu', pol_I, pol_Q, pol_U, mu) + + self.QN = pol_Q/pol_I + self.UN = pol_U/pol_I + print('Q, U (unsubtracted:)', self.QN, self.UN) + + if bkg_qs is None or bkg_us is None: + print('No background data provided, assuming no background contribution.') + else: + print('Unpolarized bkg (or simulation) provided, subtracting its contribution.') + bkg_qs = np.array(bkg_qs) + bkg_us = np.array(bkg_us) + if bkg_qs.ndim == 1: + unpol_I = len(bkg_qs) * BACKSCAL + unpol_Q = np.sum(bkg_qs) * BACKSCAL / mu + unpol_U = np.sum(bkg_us) * BACKSCAL / mu + I = pol_I - unpol_I + print('check I(src+bkg) vs I(src):', pol_I, I) + else: + BACKSCAL = 1 + unpol_I = [] + unpol_Q = [] + unpol_U = [] + for i in range(len(bkg_qs)): + unpol_I.append(len(bkg_qs[i]) * BACKSCAL) + unpol_Q.append(np.sum(bkg_qs[i]) * BACKSCAL / mu) + unpol_U.append(np.sum(bkg_us[i]) * BACKSCAL / mu) + unpol_I = np.mean(unpol_I) + unpol_Q = np.mean(unpol_Q) + unpol_U = np.mean(unpol_U) + # print('I unpolarized:', unpol_I) + print('Q, U unpolarized:', unpol_Q/unpol_I, unpol_U/unpol_I) + unpol_modulation = mu * np.sqrt(unpol_Q**2. + unpol_U**2.) / unpol_I + unpol_sI = np.sqrt(unpol_I) + unpol_sQ = np.sqrt((2 - unpol_modulation**2) * unpol_sI**2 / unpol_I**2 / mu**2) + unpol_sU = np.sqrt((2 - unpol_modulation**2) * unpol_sI**2 / unpol_I**2 / mu**2) + print('Q, U unpolarized uncertainty:', unpol_sQ*100, '%') + + self.QN = np.sum([pol_Q/pol_I, unpol_Q/unpol_I * BACKSCAL]) + self.UN = np.sum([pol_U/pol_I, unpol_U/unpol_I * BACKSCAL]) + + print('Q, U, subtracted:', self.QN, self.UN) + + + pol_sI = np.sqrt(I) + pol_sQ = np.sqrt((2 - self.QN**2) * pol_sI**2 / I**2 / mu**2) + pol_sU = np.sqrt((2 - self.UN**2) * pol_sI**2 / I**2 / mu**2) + pol_covQNUN = - (self.QN * self.UN) / I**2 + print('Q/I, U/I, uncertainty:', pol_sQ, pol_sU, np.sqrt(pol_sQ)) + + # Reconstructed polarization fraction uncertainty: See eq 36 in Kislat 2015 + polarization_fraction = np.sqrt(self.QN**2. + self.UN**2.) + m = mu * polarization_fraction + polarization_fraction_uncertainty = np.sqrt((2 - m**2)/((I - 1) * mu**2)) + pol_PD = polarization_fraction * 100 + pol_1sigmaPD = polarization_fraction_uncertainty * 100 + + # Reconstructed polarization angle uncertainty: See eq 37 in Kislat 2015 + pol_PA = 0.5 * np.arctan2(self.UN, self.QN) + # Convert to 0 to 180 deg (just the convention) + if pol_PA < 0: + pol_PA += np.pi + + pol_1sigmaPA = np.degrees(1 / (m * np.sqrt(2. * (I - 1.)))) + print('\n ############################## \n') + print(' PD: %.2f'%(pol_PD), '+/- %.2f'%(pol_1sigmaPD), '%') + print(' PA: %.2f'%(np.degrees(pol_PA)), '+/- %.2f'%pol_1sigmaPA, 'deg') + print('\n ############################## \n') + + if show_plots: + + fig, ax = plt.subplots(figsize=(6.7, 6.4)) + + polar_chart_backbone(ax) + + if ref_qu[0] != None: + # print('Drawing Reference point:', ref_qu) + plt.plot(ref_qu[0], ref_qu[1], 'x', markersize=20, color='tab:green') + plt.annotate(ref_label, (ref_qu[0], ref_qu[1]), textcoords="offset points", xytext=(0,10), + ha='center', fontsize=12) + if ref_pdpa[0] != None: + # print('Drawing Reference point:', ref_pdpa) + ref_q, ref_u = rotate_points_to_x_axis(ref_pdpa[0], np.radians(ref_pdpa[1])) + plt.plot(ref_q, ref_u, 'x', markersize=20, color='tab:green') + plt.annotate(ref_label, (ref_q, ref_u), textcoords="offset points", xytext=(0,10), ha='center', + color='tab:green', fontsize=12) + + if mdp != None: + c_mdp = plt.Circle((0, 0), radius=mdp, facecolor='tab:red', alpha=0.3, linewidth=1, linestyle='--', + label=r'MDP$_{99}$ = %.2f %%'%(self._mdp99*100)) + plt.gca().add_artist(c_mdp) + + + if bkg_qs is None or bkg_us is None: + label_data = ("PD = (%.1f ± %.1f)%%\n" + "PA = (%.1f ± %.1f) deg" + % (pol_PD, pol_1sigmaPD, np.degrees(pol_PA), pol_1sigmaPA) ) + pass + else: + label_data = ("Measured (Unpol subtracted)\n" + "PD = (%.1f ± %.1f)%%\n" + "PA = (%.1f ± %.1f) deg" + % (pol_PD, pol_1sigmaPD, np.degrees(pol_PA), pol_1sigmaPA) ) + plt.plot(unpol_Q/unpol_I, unpol_U/unpol_I, 'o', markersize=5, color='0.4', \ + label=r'Unpol (PD$_{1\sigma}$ = %i %%)'%(unpol_sQ*100)) + unpol_c = plt.Circle((unpol_Q/unpol_I, unpol_U/unpol_I), radius=unpol_sQ, facecolor='none', edgecolor='0.4', linewidth=1) + unpol_c2 = plt.Circle((unpol_Q/unpol_I, unpol_U/unpol_I), radius=2*unpol_sQ, facecolor='none', edgecolor='0.4', linewidth=1) + unpol_c3 = plt.Circle((unpol_Q/unpol_I, unpol_U/unpol_I), radius=3*unpol_sQ, facecolor='none', edgecolor='0.4', linewidth=1) + plt.gca().add_artist(unpol_c) + plt.gca().add_artist(unpol_c2) + plt.gca().add_artist(unpol_c3) + + plt.plot(self.QN, self.UN, 'o', markersize=5, color='red', label=label_data) + pol_c = plt.Circle((self.QN, self.UN), radius=polarization_fraction_uncertainty, facecolor='none', edgecolor='red', linewidth=1) + pol_c2 = plt.Circle((self.QN, self.UN), radius=2*polarization_fraction_uncertainty, facecolor='none', edgecolor='red', linewidth=1) + pol_c3 = plt.Circle((self.QN, self.UN), radius=3*polarization_fraction_uncertainty, facecolor='none', edgecolor='red', linewidth=1) + plt.gca().add_artist(pol_c) + plt.gca().add_artist(pol_c2) + plt.gca().add_artist(pol_c3) + + plt.xlim(-1, 1) + plt.ylim(-1, 1) + plt.xlabel('Q/I') + plt.ylabel('U/I') + plt.tight_layout() + plt.legend(fontsize=12) + + plt.show() + + polarization_angle = Angle(np.degrees(pol_PA), unit=u.deg) + polarization_angle = PolarizationAngle(polarization_angle, self._source_vector, convention=self._convention).transform_to(IAUPolarizationConvention()) + polarization_angle_uncertainty = Angle(pol_1sigmaPA, unit=u.deg) + + polarization = {'fraction': polarization_fraction, + 'angle': polarization_angle, + 'fraction_uncertainty': polarization_fraction_uncertainty, + 'angle_uncertainty': polarization_angle_uncertainty, + 'QN': self.QN, + 'UN': self.UN, + 'QN_ERR': pol_sQ, + 'UN_ERR': pol_sU} + + return polarization + + +if __name__ == "__main__": + + print('Just some tests here...') + + pass \ No newline at end of file diff --git a/docs/tutorials/polarization/Stokes_method.ipynb b/docs/tutorials/polarization/Stokes_method.ipynb new file mode 100644 index 00000000..fc7e9577 --- /dev/null +++ b/docs/tutorials/polarization/Stokes_method.ipynb @@ -0,0 +1,773 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4e111ad9-5599-451c-83a5-f89a79b0dd42", + "metadata": {}, + "source": [ + "# Polarization example (GRB) - azimuthal scattering angle distribution (ASAD) method" + ] + }, + { + "cell_type": "markdown", + "id": "f9b8addd-aaa4-488c-8041-385881689986", + "metadata": {}, + "source": [ + "This notebook fits the polarization fraction and angle of a Data Challenge 3 GRB (GRB 080802386) simulated using MEGAlib and combined with albedo photon background. It's assumed that the start time, duration, localization, and spectrum of the GRB are already known. The GRB was simulated with 80% polarization at an angle of 90 degrees in the IAU convention, and was 20 degrees off-axis. A detailed description of the Stokes method, which is the approach used here to infer the polarization, is available on the [Data Challenge repository](https://github.com/cositools/cosi-data-challenges/tree/main/polarization). " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "26c12d83-7afc-4000-8b8f-d353e0b08d12", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
10:42:52 WARNING   The naima package is not available. Models that depend on it will not be         functions.py:47\n",
+       "                  available                                                                                        \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m10:42:52\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=753510;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py\u001b\\\u001b[2mfunctions.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=712313;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py#47\u001b\\\u001b[2m47\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:68\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=539094;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py\u001b\\\u001b[2mfunctions.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=715852;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py#68\u001b\\\u001b[2m68\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": [ + "
10:42:53 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;46m10:42:53\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=600551;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/astromodels/functions/functions_1D/absorption.py\u001b\\\u001b[2mabsorption.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=594049;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/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": [ + "
10:42:55 INFO      Starting 3ML!                                                                     __init__.py:39\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m10:42:55\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=552615;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=298482;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#39\u001b\\\u001b[2m39\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   WARNINGs here are NOT errors                                                      __init__.py:40\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=226250;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=888216;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#40\u001b\\\u001b[2m40\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:41\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=177418;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=662591;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#41\u001b\\\u001b[2m41\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: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 \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=794853;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=469960;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#44\u001b\\\u001b[2m44\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
10:42:56 WARNING   ROOT minimizer not available                                                minimization.py:1345\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m10:42:56\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=254056;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=871483;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/minimizer/minimization.py#1345\u001b\\\u001b[2m1345\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Multinest minimizer not available                                           minimization.py:1357\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=319190;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=848592;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/minimizer/minimization.py#1357\u001b\\\u001b[2m1357\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   PyGMO is not available                                                      minimization.py:1369\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=404745;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=503003;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/minimizer/minimization.py#1369\u001b\\\u001b[2m1369\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
10:42:57 WARNING   The cthreeML package is not installed. You will not be able to use plugins which  __init__.py:94\n",
+       "                  require the C/C++ interface (currently HAWC)                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m10:42: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=744482;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=681910;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#94\u001b\\\u001b[2m94\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 HAWCLike.py. Do you have the relative instrument         __init__.py:144\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=222570;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=966236;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#144\u001b\\\u001b[2m144\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 FermiLATLike.py. Do you have the relative instrument     __init__.py:144\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=955734;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=412794;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#144\u001b\\\u001b[2m144\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": [ + "
10:42:58 WARNING   No fermitools installed                                              lat_transient_builder.py:44\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m10:42:58\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=664471;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/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=142732;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/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": [ + "
10:42:58 WARNING   Env. variable OMP_NUM_THREADS is not set. Please set it to 1 for optimal         __init__.py:387\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m10:42:58\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=881316;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=360777;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#387\u001b\\\u001b[2m387\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:387\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=104856;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=914817;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#387\u001b\\\u001b[2m387\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:387\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=219046;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=258154;file:///Users/mnegro/opt/anaconda3/envs/test2_stokesmethod_cosipy_env/lib/python3.10/site-packages/threeML/__init__.py#387\u001b\\\u001b[2m387\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": [ + "from cosipy import UnBinnedData\n", + "from cosipy.spacecraftfile import SpacecraftFile\n", + "# from cosipy.polarization.conventions import MEGAlibRelativeX, MEGAlibRelativeY, MEGAlibRelativeZ, IAUPolarizationConvention\n", + "from cosipy.polarization.polarization_stokes import PolarizationStokes\n", + "\n", + "from cosipy.threeml.custom_functions import Band_Eflux\n", + "from astropy.time import Time\n", + "import numpy as np\n", + "from astropy.coordinates import Angle, SkyCoord\n", + "from astropy import units as u\n", + "from scoords import SpacecraftFrame\n", + "from cosipy.util import fetch_wasabi_file\n", + "from pathlib import Path" + ] + }, + { + "cell_type": "markdown", + "id": "4b292969", + "metadata": {}, + "source": [ + "### Download and read in data" + ] + }, + { + "cell_type": "markdown", + "id": "5f241124", + "metadata": {}, + "source": [ + "Download data (same as ASAD method tutorial: if you have already downloaded them you don't need to run these lines)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3e7fa183", + "metadata": {}, + "outputs": [], + "source": [ + "# fetch_wasabi_file('COSI-SMEX/cosipy_tutorials/polarization_fit/grb_background.fits.gz', checksum = '21b1d75891edc6aaf1ff3fe46e91cb49')\n", + "# fetch_wasabi_file('COSI-SMEX/DC3/Data/Responses/ResponseContinuum.o3.pol.e200_10000.b4.p12.relx.s10396905069491.m420.filtered.nonsparse.binnedpolarization.11D_nside8.area.good_chunks.h5.zip', unzip = True, checksum = '9c1309efec9a37afdcd49b7a443b280b')\n", + "# fetch_wasabi_file('COSI-SMEX/DC3/Data/Orientation/DC3_final_530km_3_month_with_slew_1sbins_GalacticEarth_SAA.ori', checksum = 'b87fd41b6c28a5c0c51448ce2964e57c')\n", + " \n", + "# fetch_wasabi_file('COSI-SMEX/DC3/Data/Sources/3C279_3months_unbinned_data_filtered_with_SAAcut.fits.gz',\n", + "# checksum = 'd0b1c3f2e4a5f8b6c7d8e9f0a1b2c3d4',\n", + "# unzip=True)" + ] + }, + { + "cell_type": "markdown", + "id": "ce33b697", + "metadata": {}, + "source": [ + "Read in the data (GRB+background) and get the background by reading the files containting background before and after the GRB" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ac0ad83d", + "metadata": {}, + "outputs": [], + "source": [ + "data_path = Path(\"/Users/mnegro/MyDocuments/_COSI/COSIpy/eliza_pull_request_updated/cosipy/docs/tutorials/polarization/\") # Update to your path\n", + "\n", + "grb_plus_background = UnBinnedData(data_path/'grb.yaml')\n", + "grb_plus_background.select_data_time(unbinned_data=data_path/'grb_background.fits.gz', output_name=data_path/'grb_background_source_interval') \n", + "grb_plus_background.select_data_energy(200., 10000., output_name=data_path/'grb_background_source_interval_energy_cut', unbinned_data=data_path/'grb_background_source_interval.fits.gz')\n", + "data = grb_plus_background.get_dict_from_fits(data_path/'grb_background_source_interval_energy_cut.fits.gz')\n", + "\n", + "background_before = UnBinnedData(data_path/'background_before.yaml')\n", + "background_before.select_data_time(unbinned_data=data_path/'grb_background.fits.gz', output_name=data_path/'background_before')\n", + "background_before.select_data_energy(200., 10000., output_name=data_path/'background_before_energy_cut', unbinned_data=data_path/'background_before.fits.gz')\n", + "background_1 = background_before.get_dict_from_fits(data_path/'background_before_energy_cut.fits.gz')\n", + "\n", + "background_after = UnBinnedData(data_path/'background_after.yaml') # e.g. background_after.yaml\n", + "background_after.select_data_time(unbinned_data=data_path/'grb_background.fits.gz', output_name=data_path/'background_after')\n", + "background_after.select_data_energy(200., 10000., output_name=data_path/'background_after_energy_cut', unbinned_data=data_path/'background_after.fits.gz')\n", + "background_2 = background_after.get_dict_from_fits(data_path/'background_after_energy_cut.fits.gz')\n", + "\n", + "background = [background_1, background_2]\n", + "# Save background_1 dictionary to a file npz\n", + "np.savez(data_path/'background_1.npz', **background_1)" + ] + }, + { + "cell_type": "markdown", + "id": "2cc0300a", + "metadata": {}, + "source": [ + "Read in the response files and the orientation file. Here, the spacecraft is stationary, so we are only using the first attitude bin ( The orientation is cut down to the time interval of the source.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ecb484f2", + "metadata": {}, + "outputs": [], + "source": [ + "response_file = data_path/'ResponseContinuum.o3.pol.e200_10000.b4.p12.relx.s10396905069491.m420.filtered.nonsparse.binnedpolarization.11D_nside8.area.good_chunks.h5' # e.g. ResponseContinuum.o3.pol.e200_10000.b4.p12.s10396905069491.m441.filtered.nonsparse.binnedpolarization.11D_nside8.area.h5\n", + "\n", + "sc_orientation = SpacecraftFile.parse_from_file(data_path/'DC3_final_530km_3_month_with_slew_1sbins_GalacticEarth_SAA.ori') # e.g. DC3_final_530km_3_month_with_slew_1sbins_GalacticEarth_SAA.ori\n", + "sc_orientation = sc_orientation.source_interval(Time(1835493492.2, format = 'unix'), Time(1835493492.8, format = 'unix'))" + ] + }, + { + "cell_type": "markdown", + "id": "c6951d6c", + "metadata": {}, + "source": [ + "Define the GRB spectrum. This is convolved with the response to calculate the ASADs of an unpolarized and 100% polarized source" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "26cec39d", + "metadata": {}, + "outputs": [], + "source": [ + "source_direction = SkyCoord(l=23.53, b=-53.44, frame='galactic', unit=u.deg)\n", + "\n", + "a = 100. * u.keV\n", + "b = 10000. * u.keV\n", + "alpha = -0.7368949\n", + "beta = -2.095031\n", + "ebreak = 622.389 * u.keV\n", + "K = 300. / u.cm / u.cm / u.s\n", + "\n", + "spectrum = Band_Eflux(a = a.value,\n", + " b = b.value,\n", + " alpha = alpha,\n", + " beta = beta,\n", + " E0 = ebreak.value,\n", + " K = K.value)\n", + "\n", + "spectrum.a.unit = a.unit\n", + "spectrum.b.unit = b.unit\n", + "spectrum.E0.unit = ebreak.unit\n", + "spectrum.K.unit = K.unit" + ] + }, + { + "cell_type": "markdown", + "id": "39c52ea7", + "metadata": {}, + "source": [ + "Define the source position and polarization object" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41cbf55e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This class loading takes around 30 seconds... \n", + "\n", + "Number of azimuthal angle bins used: 12\n", + ">>> Convolving spectrum in ICRS frame...\n", + "Energy range considered (by responses design): 200.0 - 10000.0 keV\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Background provided. Make sure there is enough statistics.\n", + "Creating the 100% polarized ASADs (this may take a minute...)\n", + "Creating the unpolarized ASAD...\n", + "A = 0.72, B = 0.56, C = 1.55\n", + "Rmax, Rmin: 1.2765994095848665 0.7208759491498263\n", + "Modulation mu = 0.2782129241319227\n", + "A = 0.71, B = 0.57, C = 1.28\n", + "Rmax, Rmin: 1.277565221044138 0.7145656302116623\n", + "Modulation mu = 0.2826117523743843\n", + "A = 0.71, B = 0.58, C = 1.02\n", + "Rmax, Rmin: 1.2811347880756978 0.7115098904640041\n", + "Modulation mu = 0.2858637587254843\n", + "A = 0.71, B = 0.58, C = 0.76\n", + "Rmax, Rmin: 1.2832547944023935 0.7105732262477737\n", + "Modulation mu = 0.28722716414020205\n", + "A = 0.71, B = 0.58, C = 0.50\n", + "Rmax, Rmin: 1.286333723259795 0.709611209311379\n", + "Modulation mu = 0.2889471069752825\n", + "A = 0.71, B = 0.57, C = 0.25\n", + "Rmax, Rmin: 1.2795091218061168 0.7209409818293889\n", + "Modulation mu = 0.27922123074283006\n", + "A = 1.28, B = -0.57, C = 1.54\n", + "Rmax, Rmin: 1.2816992490648778 0.7193171518560963\n", + "Modulation mu = 0.2810482197696847\n", + "A = 1.28, B = -0.57, C = 1.28\n", + "Rmax, Rmin: 1.282324586598261 0.724706750909539\n", + "Modulation mu = 0.2778321520286452\n", + "A = 1.29, B = -0.58, C = 1.02\n", + "Rmax, Rmin: 1.2897273462156322 0.7181465237202669\n", + "Modulation mu = 0.2846696852096655\n", + "A = 1.29, B = -0.57, C = 0.76\n", + "Rmax, Rmin: 1.286606127370973 0.7197829170713229\n", + "Modulation mu = 0.2825091234772001\n", + "A = 1.29, B = -0.58, C = 0.51\n", + "Rmax, Rmin: 1.2880870304466803 0.7157297168971504\n", + "Modulation mu = 0.28563356120674255\n", + "A = 0.72, B = 0.57, C = 1.81\n", + "Rmax, Rmin: 1.2815309169458988 0.7196863013802212\n", + "Modulation mu = 0.28075143988398316\n" + ] + } + ], + "source": [ + "source_photons = PolarizationStokes(source_direction, spectrum, data, response_file, sc_orientation, \n", + " background=background, response_convention='RelativeX', show_plots=False)" + ] + }, + { + "cell_type": "markdown", + "id": "54defb88", + "metadata": {}, + "source": [ + "Let's check some numbers:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "57c9a289", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Data duration: 0.541 s\n", + "Data counts: 8114\n", + "Count rate: 15006.507 counts/s\n", + "\n", + "Background duration: 378.9 s\n", + "\n", + "MDP_99: 16.837 %\n" + ] + } + ], + "source": [ + "data_duration = source_photons.get_data_duration()\n", + "data_count = source_photons.get_data_counts()\n", + "print('\\nData duration:', str(round(data_duration, 3)), 's')\n", + "print('Data counts:', str(data_count))\n", + "print('Count rate:', str(round(data_count / data_duration, 3)), 'counts/s')\n", + "\n", + "background_duration = source_photons.get_background_duration()\n", + "print('\\nBackground duration:', str(round(background_duration, 3)), 's')\n", + "\n", + "MDP99 = source_photons._mdp99 * 100\n", + "print('\\nMDP_99:', str(round(MDP99, 3)), '%')" + ] + }, + { + "cell_type": "markdown", + "id": "1e5cb5b3", + "metadata": {}, + "source": [ + "Derive the modulation factor. This depends on the source spectrum and the instrument polarization response averaged over polarization angles. This steo needs to be re-computed for every source." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2db5d9d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modularion factor: 0.283 +/- 0.000\n" + ] + } + ], + "source": [ + "average_mu = source_photons._mu100\n", + "mu = average_mu['mu']\n", + "mu_err = average_mu['uncertainty']\n", + "\n", + "print('modularion factor: %.3f +/- %.3f'%(mu, mu_err))" + ] + }, + { + "cell_type": "markdown", + "id": "eb4a7306", + "metadata": {}, + "source": [ + "Get the azimuthal angles for each photons and calculate the Pseudo Stokes parameters from the scattering angle for each photon in the data and background simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5db15edd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qs, us = source_photons.compute_data_pseudo_stokes(show_plots=True)" + ] + }, + { + "cell_type": "markdown", + "id": "26df3de8", + "metadata": {}, + "source": [ + "Now get the stokes parameters for the background observations" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c69dae6c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bkg_qs, bkg_us = source_photons.compute_background_pseudo_stokes(show_plots=True)" + ] + }, + { + "cell_type": "markdown", + "id": "5bced9c7", + "metadata": {}, + "source": [ + "The background is rate is estimated over a longer time period and therefore its flux needs to be rescaled to the expected flux during the GRB.\n", + "\n", + "This factor is simply computed as the ration of GRB duration / background duration." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "da3b6513", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Background scale factor: 0.0014270214696478288\n", + "Consistency check : True\n" + ] + } + ], + "source": [ + "backscal = source_photons.get_backscal()\n", + "\n", + "print('Background scale factor:', backscal)\n", + "print('Consistency check :', data_duration/background_duration == backscal)" + ] + }, + { + "cell_type": "markdown", + "id": "b3417867", + "metadata": {}, + "source": [ + "Compute the expected MDP assuming " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f19a7f75", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I, Q, U, mu 8114 -6825.917273322408 686.8752520880079 0.2828654127255937\n", + "Q, U (unsubtracted:) -0.8412518207200403 0.08465309983830513\n", + "Unpolarized bkg (or simulation) provided, subtracting its contribution.\n", + "check I(src+bkg) vs I(src): 8114 8111.672527983004\n", + "Q, U unpolarized: 0.31281332049973815 0.1294702859721143\n", + "Q, U unpolarized uncertainty: 326.9602341890562 %\n", + "Q, U, subtracted: -0.8408054293956954 0.08483785671606878\n", + "Q/I, U/I, uncertainty: 0.044634633579211894 0.05541113952798577 0.21126910228240167\n", + "\n", + " ############################## \n", + "\n", + " PD: 84.51 +/- 5.47 %\n", + " PA: 87.12 +/- 1.88 deg\n", + "\n", + " ############################## \n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo4AAAJvCAYAAAD1FlDHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydBbhUVffGF90ipYCCdEtJiVKiYnfrZwf2Z392d3eLfzuwExUxQCWku5EuQUAa5v/89rAv586dvmdmzpmz3ucZr9w7ceacffZ+97vWeleJUCgUEoVCoVAoFAqFIgFKJnqCQqFQKBQKhUIBlDgqFAqFQqFQKJKCEkeFQqFQKBQKRVJQ4qhQKBQKhUKhSApKHBUKhUKhUCgUSUGJo0KhUCgUCoUiKShxVCgUCoVCoVAkBSWOCoVCoVAoFIqkoMRRoVAoFAqFQpEUlDgqFAqFQqFQKJJCackTrF+/Xt577z2ZPHmyTJkyRdauXSs33nijHHrooUm9nue/8MIL8ssvv8imTZukZcuWcskll0jz5s2LPHfo0KEyYMAAmTdvnuy6665y2GGHyZlnnimlS+fN6VQoFAqFQqHIX8Xxn3/+kddff92QuSZNmqT02u3bt8sNN9wgP/zwgxx33HHSv39/WbVqlVx55ZUyf/78Qs/9448/5Oabb5bKlSubv/fo0UPeeOMNefLJJ13+RgqFQqFQKBTeQt5IZDVq1JBPPvnE/Jw6dapceOGFSb/2p59+kokTJ8pdd90lvXv3Nr874IAD5LTTTjPK4m233Vbw3Oeee04aN24sjz76aIHCWLFiRXnrrbfkhBNOkL322isD306hUCgUCoUi98gbxbFs2bKGNKaDn3/+WapXry49e/Ys+B0h6D59+piw9ObNm83v5s6dax5HHnlkobD0scceK6FQyBBQhUKhUCgUinxF3iiOxcH06dOladOmUrJkYR5NnuMXX3xhwtWojDwPROY91qxZU2rVqiUzZsyI+RkrVqyQlStXFsqpJKzerFkzQ3oVCoVCoVAonEC4Wrx4sXTp0sUIWl6AEkcR+fvvv6Vdu3ZFfm8VTAgfxNESv2jKJr9zEsNIfP755yYHU6FQKBQKhSIV3HLLLXLwwQeLF6DEUcRUUUdT/ezv+DuwIetYz6WyOxaOOuoo2W+//Qr+PXPmTHnwwQfl8MMPl86dO8see+zhyndRKBTJY+PGjbJ69eqCx5o1a+Tff/819zIPUlAsSpQoYfKZeVAcZ/+/fPny5v7nUaZMmYKH/XepUqUydvxbt26VLVu2mLmJn5H/v2HDBvN97HfiJ79zgkgL36NSpUrmUbVqVaNs8OD/NSKiUGQfM2bMkCVLlsguu+wizzzzjNSuXVu8AiWOIlKuXLkCUuiE/R1/B3YCjfVc+7xoIJzNIxIonUzmdevWlSpVqhTreygUiuiuCbgkkC4S+bAkClJYrVo1k+tMgRv3on0wcfMTchWZzuJHbNu2TdatW2fSZZwPSDOP5cuXm42tBd/dzl9EVuz/Qyo5bwqFwl1QrMum9ZBDDjH8AMTjF9mGEkcRs1hECzNHhqadoevdd9+9yHPJiUwVDRs2NPmRShoViuIDIrho0SJZuHChyQuCHJKKAlmyk68lPuQXWyLEHJBrH1YsxfCRpUgPUpYpoIDy/vE+g40wc5qTZP/1118yZswYo3IC1FTOH/MXG18ederUUYVSoSgGiBQsW7ZM2rZtK3vuuadMmzZNvAYljiKmMGb8+PFGmXAqChiJE4aqV69ewfMAF7JVq1YFz2NSZZdOODodsGiBWbNmGVWDyVehUCSeYCGHkERLFiGJgPuW+6hRo0YmqdySRULMqpIlBuSP8xc5FzFHQnCdhJJFDgs0rgfndrfddjMkkvQbHvw7k+F6hSJfsH37drMh69Wrl6fvmcARRyY6pF8mNKswcJGw0mG3b30cyXcaMmSIdO/evWAHjTpYv359U2kNSbQX9tNPPzUTJu9THDAhMwF36tSpiKKpUAR9QoWgQA7tg80av+c+huCgIFrCwmZMCaL7YGNNSJ+H3Ug7r48l8DzGjRtXcH3Iz+K62OuDUqnXR6HYCYSjBQsWyP777+9p0ph3xPGjjz4yuTs2xDxs2DAzmYHjjz/eqA0vvfSSfPvtt/L+++8X7KYhiwMHDpT777/f+DQSwoEMMumde+65hT6DNoS0Mrzmmmukb9++Mnv2bGM8fsQRR0iDBg2Kdfzt27c3IbVRo0ZJ165do+ZEKhRBAPk9S5culTlz5ph7DOsqwqcQFxQsyAdKIj8JlXp9os13cF0ghzw6duxofocCSXK/VYTJmxw+fLj5G5EVNuIowvyEiCqRVAQVc+fONe2S2Yz5YS7LK+IIGWSiskBB5AEoY4c4RgMX6qGHHjJdYSCfVFG3aNHCEEQURidQIO+55x5jrUObQUjmGWecIWeffbYrk+8+++wjI0eOlBEjRpjP8opvk0KRaaJIAYslikykRAZQq7gHyfvjJ5s9QjmJAGmxeY1+AcSY78tPqr3zAZB6HmyKAd/LKpP44xLpIbJDjjf5XKQFsRmguluhyGeU2eG4wH0wYcIEs4mCd/gBJUJOvwlF1kCe5AUXXCAvv/xyEUNxFjz+Tugt1wn7CkWmQHTAEkV+kh6C6gRxsGoURCKVe4CqYNJRrIWWn8BUzINzEBT1je9LsY19WLLPgsp1t4+gnA9FcFBih70X9RVsiimGiYZ4XCFXUFbiQTBp2uIbVBcmUyxBFAq/kwSKWSg6YzK0aSSEnpkQIYpY4VDYkg4gjYRFiSyQ5sGOXgmHv8BcZ30o+Um6EIA8UhHPQzfTinyYC//991+Tp40lH2q7n6B3oMcxadIkE8LDPDxWqF2h8CpY+MlPpOiLBwVgFSpUMGp6jx49jLLo1rhGaeS9mIT9SBghTYRyIc5+yHPKFGyYmsWVc4J67HxAHDlHPHRzoPAjtmzZYuYqxrP1afQTlDh6HOQG/fbbb/L777+bnEfN/VH4YVIk/IyySH93OpagmJO/g9cpqqLbRtp8JpMwSqNfiQREie/hJaPfXILraEPVzHtsQrjGkGsWW1IdINiWROJ+4ddrrwgOtm7dauZExjW5vURK2CD5SUn3z5EGFEyG++67r6kQhzyiPKLYKBReAos5LbIgi1TPEmaExFFhC1nEhiWTi7rNjUumcEbhT7DZYO7jAclmjGH4btsq8ndLIiHfSiIVXiSN//77r9nwkN9oi+D4vRJHhatgEkRt/OOPP8xORYmjwguArEEWx44da37ybwgiIWjURappsw0lC8EA19nmPFqllkUYEskcyd8hkCzOqkQqvIBt27YVkEYUdD8XwSlx9AmYBDEYZ6DZSkRVVxTZBmMPyyvIIhYSLNJY5Bx00EFGWcxkqzyFIhqYEyGHPAj9MTdCIhmbEEmr7rDh9pOqo8gvlCxZ0oxR1nK/EkYLvYt8BDvYMArF5JwQtpJHRTZAPhlEEcKIMTeJ3eTfUhGoXY7cgQ21up3/GbQ5kjmRB2PUhrMZv2vXrjULNyRSz7MiW9jmsJjKl2ihEkcfAm87TEPpwtCtWzfdRSsyApQbilsgi+Qtsihjm0PHpCZNmujCmyHiqHA/nE1xllUhrV+ohrIVmcb27dsL8m/zyRVFGYcPwSQIYaRYhg4ztCcMsn2Hwl2gKP75559GYUStwZD70EMPlTZt2uTNjtmLsCkoanjtPli4IYk8OMc2F9KGshnX/E034Qo3SeO6devM/zO28gl6l/gUtCKEMFIwg08e5skKRXEmOdRFVGy6uJArRvtLQtG5KHJxG2t/HJLrQ5AqB/RJKnkeZSIagaHN6TnnnGP+/9dff5X999+/CPGkA8WCBQvk8MMPly+//LLI6wAKXPXq1WXvvfc2z+NvXO9Yn2Vfw3vTuvXWW2/1TXoCC/fDDz9sxjWbbDxxBwwYYFrEcp4pqoFAWnsfjOkfffRRY4GGQsm8euGFF8oVV1yR8LMoEOPcDB06VP7++29zvk477TS59tprYxKHe++9V2655RZp3bq1TJw4MeFnYHDP8XD98St98MEH5cgjjyz0nI8//lj69+9vjkdzjnNPGitVqpR30Rkljj4Gkz8VrPkkgSuyCxSXMWPGmEWVEB5pECeccIIpdFEV25sgxPrOO+8UIY4///yzIY2xfCDvuusuY7gOWaLAiT7R//3vf+Wxxx6Tzz//PGrLM/saSBSE6Pnnn5evv/7akBw/qCiYwvMdIHFsgvjO0YpqiOJAtE888URD4q666iozv/7111/mnCYCqUNdunQxRO2yyy4zryUidPvttxv1/rPPPivyGt73vvvuS8mb96yzzjLkEcKIRRvHi7F+gwYNzN+5ThDVe+65R0ljDrF9R8cjrm0+zqNKHH0OqxTQuogJhclRw1yKRGC8QBbJX2SSY7FkESIsrfA2DjvsMPnwww/lqaeeKqRMQiZRiSFL0UC6QadOnQr+feONN8qPP/4oRxxxhBx11FHGgzMyFcH5mvPPP19q1KhhiCZE6NRTTxWvg4p/2lzWrl1bRo0aJZ07d476PNQhlDwU2LfeestsqDAbtyFu1OB4BODNN980Gy/INfcS4P24t9544w2jdFarVq3QayB4pBzx3rGumRMcE9cL8tuzZ0+jKqKMDho0SC666CLznEceecQQRq6VIvsIhULmpzX3zte1OL/00wCDvB12sOPGjSsYvAqFE4wLwtEscs8++6whChjKo64cd9xxShp9Aggbrgrff/99we+oHh44cKAJjaaCAw44wIRXSXeBMCXzfEA6gx+A+gppTARIN7m9hI5t1TUkGSJNGJu/Qf44z9FA9w8QGcKHuFobFid++eUXc72eeOKJpL8LaiL3sCWgkBJSlgi1A4SDBx54QJ588sm8C436qf/0hg0bzL/zlTQCHV15AiaoDh06mJBJMrkyiuCAxY4cr2eeecYskExsEEXClL1799ZUB4+AhYYFP9GCQ1gSK65333234HfffPON6QN+yimnpPy5//nPf8zP7777LuFzZ82aZX5CqjIBwuiob8k8bDjQDfzwww8mXA35wjmAe4Lv+L///c8oePyN+4jPRa2HrDk36NxH4LzzzjMqPvPw+++/b0L75Ec6w9EojJdffrlRBckzTRYQxsaNG5vwNsT97bffNp9FiBxcf/31RiFGjVTkhjRu27atyCYhH6Gh6jwCihEDF9WRnXazZs1yfUiKHIKFbuTIkSacBVls1aqVHHPMMSapPp93w34FoVAISjJAWSTUzHVFFYNE0CCAzj2pgvEAObKk0AnIKGQJtYucOvIF+TzC25kAn9GnT/wiIgvIk83tKy4oJCFqc/TRRxvyd//995uQ8NNPP21C0JB0yB/ha8La/A5fSMKRnI9DDjlE7r77bkPqyBe1uPnmm02+oRMvvPCCUXghq6nipZdeMjnI7733nvk3mz+iBtzjn3zyiYkiKLJPGtevX2/GT6zCtnxD/n/DgIEk8EwqAgrvg8WN/EWS8/l/jLoppIjMsVL4FyeddJIhDRR0QFr4Sc5jumDBgwhF4sADDyz077322suQ1EylNZCj7QzBx0MyIehkARlk8Sdv0J5HVHk2Xy+++KIhzE2bNi3ohc3vnQSS88e5Qe07/vjjzfz71VdfGSLJcVIwA0gxuO2220x6QDpuBaQKULAzadIks0mgmA3lFVXzmmuuMceAykm4GkJDGgrfSZE5bN682SjlbCyCQBpBML5lQMkjOyByczR3LRhAFSIkjUUTk1nHjh0NYdTqSn+AaAFkBBKSqBIT0gGpI/UAwsNrUaLSBZ+72267Ffk9ubBELlgQyd8jjOvMn4PAXHzxxSZkinL53HPPFYRt4/0tFtjcRJLVbMAWBUUW/KDsQhzZhEEcLQhHUjkNYYA4UgADceO78jwUfYgnpO6GG24w7wuZxHqH1xGqTheMD6zYLLAXokqesDoq5nXXXWfyVTkGjp9rlqyKq0gdZcuWNfdHPlZPx4ISxzwG+Trjx483JAJLDUV+gnAlZBHSyGaBylrCV8mGPRXeAAqRfSQDSMEFF1xgSAO5bRRKpAOK6ghJ0w0oEuTPOSuxnYA0EdpF7RoyZIh5QF7xQmTsxfpbvGgIcxUeiMkA8uzWYo16B9GNLG6xZJrCmGigtSFEEAJPviKkjs06IWyKbKhWxxMTyyvUQELNFMQsWrSo0IaPczl37lxz3ni/ZEFRDuFwqqlRvAipc55JSQH8PwqxEsfMzLulS5c2YyBIpBEoccxjMFGRsEuxDAPbKpGK/ABKk+0ehLLBAt+9e/ciZs6K/MSxxx5rbFjYNFCIkS6osgf9+vVL6XWQQAiVNcdGKaRAj1w7bGZi/S2eVQy5ernIcWSzRYjcFsdYWIKXKKy8bNkyo5byPNRbiDhKpA3/s6HjvW1YOZqhOJv7K6+8MqVKa+uzefrppxccL+fZSYhRQRXuYsMOu6agEUYLJY55DgoibMEMg1zD1v6HLVRAYQR400EYUzESVvgfqFvks6FURXYPSRb4AlLU4SQfqSBSHeXfKHcQx1h/82KOIzmjWNm8+uqrBZZD4JVXXjGqkjPEzoaNPMOaNWuaByCcT1U6ZJb/Z/MGaUQBJLRPNTSKMMQ5EoSveS55iTwvWWCthVMC1j622A3FFENwC4pl3DxPip2kkfSGIFRQR4MSxwCAHsOQRwa7wr/gGo4ePdqE/QhtkecEYfRDBw9FZkAnkWSBZQ+kwuY+QxohaUQmqASm6CMVoMxBhjAEJ2dv8ODBpnsNbfri/S3bOY6QK4pYrHr4xRdfFHSD4djIAUalO/fcc+W1114z54cKdaqqMVqnet1ZrY7CjypKV5g77rjD/I68Qs4vnbwohCEcT8HSt99+a+yO2NShNqLqcp6drgZWYbTh5WRB4cvJJ59cYMdjQ9OkCNx0000F39W2nlQUH6yhmzZtMtcwVoemIECJYwDAJEVlrVOxSnWRUOTeuJtFnqpMVBlUEc1hdK9PtBdARCCZwph0QTWvs7CDnDxIS7Re1cmA3K5PP/3UkC+Ms0mVgMhQCBPvb9kG+X/Y3zh7OfMAZ5xxRkHxGDY5pPNQbIIyCKF+/PHHTfV6IlBNTZgdIkkREPcpKi7fHX9F7mHyEQnf2xaHxVGraPuI0si84AQ2SXwmNkJ8JrZC5L8q3AHqc4UKFQJNGkGJkLYZyQnIDyKx/eWXXy6UU5NpkEiPasUu1YZZFN4FKgkhMMKRLEQHH3ywMXtXFAabIcKEnCPdFOUOKOAQVCyCUvlbkMYpBBJVEwICYQ+KhYufQdEW18ntjjwbk5i3csUV4kFHbMBAlSBqA+EW8pBSqeBTZA8k1xPeoyqehHsqaK3NhyI/QSiTMBhqhl9axjE+yenj2LHu4aclhvH+FlTYECd5kuQ1ki+HyszDL9c8iKSR62U9PBXacjBwYHKimIL8I4orICgK7wDiAGEk1EQnD0JPeOGxACtpDAZxdLOVXqZBWJfiCx5UdxOeTuZvQQb3MTmPbOJRHHG+oCqbnxoA9CZpJK0g6OFpJ1RxDCDIoSJUzWRO1R3KoyK3gCzYwhfIA2E9vBh1slJ4GeQA8kj1b4rwJt76PaI+sonHyoecS1W2cg8KECGN5OuSVqAb951Q4hhQkK/h7D6gyB3IO6X6EZ83W/ii3V4UiuBs5IkAoUJCHjFAhzhSQKP5j7ndzEMaIfZKGgtDR2WAwU0B2FXR2QBLCrV2yW4YBMsPlF8KlbADUZN2hSK48zE2PhRMQCCXL19uFEkIpRKX7BJG1GCiPRrxiQ4ljgpzkxAepQsJ4VENk2QeVMphqUFeEwrjvvvuG9guBIqd9yG5VFokEVxAEK3dC+FrKrApoCECEVSz6WyCanfm5CCbeycDnaEUhihCXEjMxotMjcIzBxYC2sPRUYJq6UsvvVT2339/JY0KQxhR/JU4KhgDkEUiEczLK1asMCqknwqn/NhgAdLIXGyjcYroUMVRYcAOC/IIcaTamg4IGh5xD0z4I0eONBXT7GTp8NC6dWs9x4oCQBBYvFi4dFwoAHMFG0wIjbXvscUzOkbcA/cdhUl286bnNj6UOCoKQC4N5JHJSW8cd028afu1ePFi00Gjb9++mg6giLl44emnRREKC+ZixgRzBqoj3WcIZUMgdZy4A/JKIY2sgar4J4aOOkUhWDNa1A8c7SnW0MkpfTsH+gFT/IJn23nnnZeTlmsKhcL/YB6mYYMWz7gPVEbWPCWNyUEZgSIqqLSmgGPp0qXG81Fz8FJXGemHu3r1ajnwwAONV6aeQ4VC4XbxDEQSOx/d4KeePsQ6x/nU9JDUoPRaERXsYvF5JCwyatQoTcpOEpynX375RV555RWTYH3RRReZSnUljQqFwu3iGex7qARGfYQEaeeZ5Odp8kZ1XUsPukVRxARhEdoT0tf6zz//lH322Uel/DjAuBeVESNviot69eqlhFGRNFA87EOhSAYoj6TBELomuoH6CKHUeSc50khalp6r1KHEUREXVPRR0EHoVREd7PIh1oMGDTI5Rxh516tXL9eHpfAZWMC0Y5AiVbCZr1atmimegTyiPhK61gK86ECZVdJYPKh8pEiI3Xff3XSVYYJip6bhkJ2gCvadd94xVdNt27aV/v37K2lUBB6vv/66UU7nzp2b1PMfeughadGihYYOiwFy9VAfSZEh+gGJ9Mr5fOGFF0yhpRc8glFpScVS0pg+lDgqUmqRR/7epEmTcn0onsCUKVPkueeeM2rsaaedJkceeaR2G1AUy46Hggd+RsMdd9xhyBhm0NHQpk0b6d27t/gNFHg8+OCDcsMNNxSkwljiaR+oZ82aNZPLLrvMFOxZRHte3bp1pV+/fvLUU0+Z8+k3ML+eeOKJ0qhRI1Ptiwl4z549TT/7SOANyznBExYy1LBhQ7n44otl2bJlxlYN9ZF522L06NFy1FFHmTQk3psxw3lKBNJvDj/8cNM/u1WrVlGPhTQdGzaPxNlnn22O48UXX5RcALED0spPiLUWEhUPevYUSQNSxKQxfvx4M8Hz/0EEE9A333wjY8eONSoJhJFJW6FwwwA8aIr+a6+9Zgo8Tj311CJ/u+uuuwwZIndv6NCh8vzzz5tWnRMnTjTEJ/J5WGAtWbLE9ID/73//K4899ph8/vnnJhrgF8ybN88Q3rPOOsuQYEKrH330kSF8EK8LL7yw4LkQ7mHDhhmiyXfkuz/zzDPmHP3666/G/ouNBik0NHfgPYge3XrrrSZUO2vWLFmwYEHCY+JYII/Oz5s6dao0aNDA/J3rc+2118o999wTNd0CQs97cD0uv/zyrObxcj9xDhkbEEZVGl1ASJETTJ06NdSjRw/z02+YNWtW6PPPPw9NmzYtFDQsWbIk9OSTT4buu+++0JgxY0Lbt2/P9SEpQqHQhg0bQpMnTzY//YotW7aEVq1aZX5Gw+233w6jDC1fvjzq31u3bh3q1atXyAsYMGCAOdY5c+YkfG7btm1DZ5xxRtTXjxw5stDvr776avP7d955J+7zwODBg0MVKlQI7bXXXqH169eH/IytW7eG2rVrF2revHmh3w8bNiy0adOmQr+bPn16qFy5cqHTTz/dzE9r1qwx60ytWrVCxxxzTGjbtm0pfTbnrkSJEqGff/7Z/Jv3bNiwYeiFF14oeM7dd98dat++fdz3HjVqlLlWXJdsgWNdt26dua82b94c8uO8NdWDXEFD1YqUQQgFpY38JWcYJN+BwojNDsorNjvt27fXCtgAgNDoJ598Yq49P52hUi/DhrZnzpxpQoUUTKAGnXPOOUaBiXweCtJJJ51kwpHYvFx55ZVGSYrEmDFj5NBDDzXPQ7WiExIm9+mAJgNEMPA6TQYHHHBAweuSeS7KGgreW2+9JX4GKhm50+QtOtG9e/ci6TFNmzY1oWtSabiuqI3ff/+9CVtfddVVRnlLxYqGMYBqRwEO4D0ZS3YMoUQ+8MAD8uSTT8Z13cCVgxD5Z599JtkAx0y4nu9LREj7T7sHDVUr0gKT01577WUmLW7QfCZQhNEITVM5TZjnsMMO00koICAs9+abb5rxbcc51fNnnnmmWbT9AMggYdz777/f5LhBgMlFI+wY+TxCjzwPIkjuGz6ub7zxRqH8O6ymII3XX3+9uQ8In5Jb+fPPPxvv11RA+BR07NgxqecTWgUQ22Twn//8R2666Sb57rvv5IILLpBMAXISLbcvGiBPydiaQe4gPrwv4XbmoJNPPjnh6xinbG4gjxaE7rlmkEdSjGbPnm3IFOfn8ccfj1uBDWFs3Lix3HfffebBNWMT/fTTT5u/Mw7YSJCHmQhcZ+6pbIKUBp2v3YUSR0XagDSSk4XP4x577GGq5vINLJwffPCBmXDJD0p2gVP4Hyy+kEYWYpt3aH9Cppo0aWIImFvIVK9cNjuvvvpqwb9Xrlxp/h1JHCGXVg269NJLDdGg+IvcNZsjeMsttxiSRL4hkQcAiW7evLkhEJDHVIDKaT87GiBN5OihekE4yGWkeviII45I6v3J8UNltYQzU+DY+vTpk9RzUUttbmA8XHPNNQXFJIyJ4447zuQvJsLbb79tVEDOlcWMGTPMBphrBVnEYo15m2pnVMx333037nu+9NJLcsIJJ8h7771n/k3+KI0NIJGo8KibyYAxwz2VabAuodI682AV7kGJo6JY4OZksRs3bpz5fwhkvmD69OlmUmQ3Tp/pOnXq5PqQFFkEi6JVGiPB7yELxx57rGufBznIhME+FlFOoBgyrqlmhhxaQBadoIgB4kihBcSRxRjl7phjjikgjYD7AleBl19+uch7JgIkloIFQt7REBnCJsoBMUplnuG9M11d3a5dOxMOTga1a9dO6nmQM8garg1sXjn/iVKDIOJcx3333dcUozhtwwgtMxYoMIKIUyVNoR+bIEgmUaR4Yf+//vrLKM4U7BA2J9R9xRVXGILLdeF9CVdzvxASjxx3Vr1EReVYMkXqeH/OEyF6bViRGShxVBQbe++9t5nUyH2CPCY7MXoVTIiEdrAeQklhoUTlUAQLkJpYFc78nr+7Pe5Y8FDy013woqWMREYCbK4aarqT5EUSB8KTHIf1YrRt7bgnItGyZUtz/PPnzy8UIi0unn32WWPDA7nET5bPTvXcQJqcyjAEB5I7YcIEufnmm02OZ3HBOU02TzNZkEfOA6AUHnzwwcbBYfjw4VGvMxXVkEEU1oEDBxaqHrbzl61cZzNMc4fjjz/eEEfmu3jE0RJwZyrCgAEDzGf+73//kx9++EGuu+46k0vKsbGR4FpFqrD2fspUahOEGDLM91PSmDkocVQUG0wCFIqwcJAHSL6TX+1pyCvC+oJwEkn/+++/f17nbypigzy6eIpjsnl2yYL7h4UPkhRt0bN5aCgq0QCpi5arFst+JJHtTzbGve21jCKIQhSJLl26mLBqusBqhnA3aQVOhRSyiHG/W4DwY7qdDCBs6VjCoD5SlEckJJK88x3JMyTsjA0PqqAT/Bu1EPJtwTiz52Xx4sXmtZDOZK47yjKk+5FHHjFzPaFujo9Ntj1WlOFI4shmBaUxExtxCCP3D/eAds3JLJSSK1wBkw25VDz8ShpRS8gpIreNHT4hPSWNwQXFL/EUR3K8sgnCgWDatGlRSSPj1z4nHZAH5wTV2JBZm48H4WHRj/b5hEghu6l2TbKKWjJV0unA5tNhCG4BuSFfmcrgaICYEybmu0DwrLk4Ydl4aQ0Q0mQeXKd0YDcMkUU4kCWUSAglHayi+etS0QzIfXQCxRDwXRlD5JNC5BPB+maefvrp5t+E051klf+P/Cx7nVGnM2XwTVcYJY2ZhyqOCtfAwmEnDyZHCCQVhH4AOZpULnL8mNumkqelyE+gzrCBIJTnrKrmJ793szAmGaCAE8Ym1ErOmVOVpHiBBR/VqThhYcKhFrZq1r4nJIq/U0BD+NoSSjZaqHeo86neN+TigVGjRrlu0v3jjz/K3XffXYjgJAOKgSimoQKda80GghAvOZ/ZyHGk60vk2KIgiXGIUuckhqQIUWn9+++/m+tiz2ckqJjHMoeiKGtpBKiwR3mEWLMxQDWFPBJ6h4RFAwSVIh1SeezGmnvFFjoBimWifU/OaSrXIllwHITSNTydHShxVLgOJluIIztjJt1onQS8dKzk91ANilpKtaZ2FlBYMH4J51EIQ04joVWUxmyTRsBn3nbbbaayGesTVDMUQNQuQoU2By5doAbxnocccoghIuSrkasGKbKgMwgECZJ4ySWXGNKBSo/aQ7/pVEGRDW3vyJE799xz0z52rGogLpBniCykkeNEgWVDmKwKxTWmkw3EGCIFIFWoevGuuZs5joSjCQVzjSkCQhUk7Mv3e/TRRwsVElGYwvfjukP6Iv0qzzjjDPOTuY3za7v09OrVy8x7H374odx4440FG35LHjkPKLLRClgofIGskkZgQWj66KOPNtZHgJaEqJ9OkMbEe/M8N1MEeGTCjUARB7l2IA8qvOgG7ybofvHLL7+Evv32W9O5wKvHOHDgQNOR49dff9UuMD5GPnSOoTsIXS74GQ9vvfVWqFu3bqFKlSqZDiEtWrQI3XnnnaGNGzcm1WkmsquLfR7n74QTTghVqVIlVK1atdBll10W9XyOHj061K9fv1DlypVDFStWDPXp0yf022+/xf2MeHjsscfMezm7u8TrCBPtc+yjbNmyodq1a4cOOugg0+Ep3txz0UUXme/uBPNB165dC/3utNNOCz300EOhbOHdd98NHXjggaHdd989VLp0aXMt+Pdnn31W5Ll0CnJ+/8iHE3ROueOOO0wnnTJlyoSaNGkSevzxx4u8J/Pg33//HVq4cKE5f8558auvvjLXatGiRUVed//994fq1q0bqlOnTujBBx8s8vcbbrghVL9+fdfmWb4PHWG4Z/w6d2/waecYJY45ghcHg9vgxv7pp59CgwYNMje3l8DxvPLKK6ZV1sSJE3N9OIpiIh+IY66QqJVhprF69epQ9erVzf2YTUQjji+99FLokEMOKfj3v//+a1r1TZo0KRQk2FaFkEdIZHGJGZsaCP0TTzzhyvHlA2n0M3FUbVeRMeDWT85NzZo1PeXcj60IuT2ETWjF5qZ9iEKRLtjIU4ySqNo530AqC+bhDz/8cNJt8IoDQrWEnskPdP4/YC6gaw6FQoSL6TZDjme0gpN8hm1VaH0XCV3bc5QOsO5hDYjm7ZgqGCMU8pAmQShdCxizDyWOioyCZH66rfCTCTpa79tsgjwuEsSZxFgU6CyhUHgBLMyQleIs0H7FDTfcUFCZnWmQp0mRCZvHe++91/y/rb4mpxUDbXI4yb0k9892bwkiODds/CHYFM1QpJMOIIwYiMcquEkFjBGOi7xGJY25QV4Vx5AkCymguwG+YBjYnn/++dK5c+e4r6PizNoSRILkZGc7plj9OC+88MKCRGRFdGAQDnFkcnZjAknn80napsqSymm1bVAoggc8HOOZfkMseSjCYNMPebQV1zhl5GL+tgoxn80xKXKHvCKO999/v6kUgxSgJFFpRwiENkjxrB6wWYg01YVIsiONRjoxpKXy0IlErvsKMdeAClBCQYSws3XzE/obPHiw6a/LtTvssMO0Ak+hSJJIKRSEhSGPGHjHq7jOJGmkAxDzNuuGKo25Rd4Qx8mTJxtycPHFFxe0VcJGgRw2fM94xAJGz5H4v//7P/PzoIMOKvI3zFKdfmeK5EBoAcKItQlts7p165bx3Ed2qPTlZXwwHvhMnXQUCoUiNUDaUBuxWaPLDHMreZCZnk8hjXT04vM1PO0N5I3sgg8f/nv4kFkgadO7k1ZLeHulAnzFcPmnD3M04FvGQ5Ea8CCDPKLwMvlkOnWBNAM6XeA7xufqpKNQKBTpgfmTYiaM3lEAycnNZDEXhTCQRqBejd5B3iiOVMERno5sd2fbG9E+y9mnMx5wxp83b5785z//ifr3b7/9Vj799FNzw2AwSxeJaMqkE+SGIPFb8P5BBZMO3QsIf9jJwe0JgVxKulmQckCnAvIaFYpsYIfNWcGCag3l2chE/o2wG3/nbyg4/NuaGnN/8G/uD/4NbPs7Hlatt5XI9vcKRSZhu7TwE/WR8UfoOlNjj/uDYhgljd5B3hBH29UhEvZ3ELdkYVtHRSODVNrRuB01ks/8+OOPTVsrdkW2wXs04O7/+uuvJ30M+Q5LGmlNxa6VXFK3JgauBR0UUDQh9Vo5rXALLJLWMsf+P2MZEgfxY+w5FRjGtG3Dx2aG5zsJniV/vCaymtreD/zNSTqdyg9A+XGSR1t1ynFxTLwvv+Nh/65QFBdWASTvkXGJdY9b5NGOZxueVngLeUMcCRtHy5ezBRjJhpUZsLSrotjF9mJ14rnnniv0bwotqNymVyx+X7GqzQih06rMqThq5Z6YhOvZs2ebHqb77LNPsSceSCg9XVmkyW9NVmVWKCwsKYRw2Z9U4KN8MK6s+gcsGWPu4f+5/+3vIhXAePlgvA6iRwoHpM/Z9pL/d/aAdhJIQJGC0wPSklNgfQoj50ReY5VM3t9JLBWKZMFYZcxQcc0D8ljcjYkzPM09o/Ae8oY4MvFG85iyk3yy9gFjx441BtFUZicDFozjjjvO9BAlly5W9TYEiYeiMOiNSqXzyJEjjV0OPVXTXbyYuCCNLJ7nnHNOVAVaoXACUmgJorVnwsrLqeBBrCxRs1YgTnJowe/iWTwlGtd8BkQvUc5Y5Oda9T4aOB6O2amQ2oWd/2dD7fw8vqtdrDkWSygVinhjjLnWkkcKaNIdM4xFSCNj09mTW+Et5A1xZOBC+CJh8wqTJW2EqRn0qTSs32233QrULkXqQBXEJBzVkUknmtKbCMuWLTMmvizqhKdtGE+hcC5KEC7beQLCaEmTVQv5u1VRopEmpxLoF1iiGfldIJzcJ5ZQOkPlnBdC4IDX8b15WNKsUDjBvcMazHrLg3k81XvFSRoJT/vxXgsK8oY4NmnSxChWDDxnTgQ2LPbviYA6SXV2+/btU1IHFy1aZH6SIKxID3RoYFFiwkkVnH9yGlFKKGjSnarCKmyoZs48P5vUz4PFzhIiJxnyUnvMbMASZKdyyfkhPG5Nl/mJOmlTfwip2/xOHrrIK6xRuCWPEMlUxoVV/1m/46noitwjb7aOvXv3NoOOIhQnEfz6669Nn1Gb64YtT6yKZoyp2WXHqpCOZh+DcjFw4ECzc2/evLlr3yeIYNJhAeM8U9meDLiWeG5COMlpVNIYXDhVM8gOIWcIDiQSMmjTVSBFLE6E2GxuoqIoOC+cHxRY7ivmOHuurHLL+eU8E23hnIOg9dpW7ATjhXmcMUBBqh0T8WDHC2SRzYqSRu8jb64Q5JBqZ4pUIB60CsQ2BzsW+qBa0JuUPMZffvklapiaXVOvXr2ifgYV1HQfoWUeRJRdFcQUMnrzzTcHTqnIFKjSI18UNGvWLObzZs2aZXwaMWQ/5ZRTctIGS5E7sDEkPYUFitwqFh1UMatY2J9+Kfiw1dB+ILKQbh6WrNt8SEAxDv+2aqSfroGi+OB627A19yb/H2tthDQivtixr+PEH/D+DJUCbrrpJlPUMmjQIHnqqafM5PXggw+a0HMiEOL+/fffTWeRWKoVZuCEo7/88kt5/PHH5YMPPjCk5bHHHtNOMi4Cz8UWLVoY8gg5jIY5c+YY0shz8WlU0hgMoHCx0IDFixebvFg2GixOjAFbnGIrnf20EDmrsv2oStrjtqFrihWZV/H6c1aiZzMKxSMZEGkiV/3tt98WP2Lu3LlmrGfT8s1+5iOPPBKzRSFjAgIZTXmENHI/M078nOrw008/mfPATwuEjJNOOknyFXmjOAIm3UsuucQ8YgFCGQ2oE3SLiQe8BqP1rla4D+yQUDLIUWVhql+/fqHwNObemK/TEUZDG/kNQqGQRKIHkBCKp9jEEVVA+YcsonKxmfAT6YoE6h2LaLTwOYQApwDw66+/yv77719kEeYeWbBggemWxeY2V+D4rcJk1UhLDKwaaZ/jlev15JNPmhxpFnwLUl9IQ7JFQpFAYDjhhBPUnzcGuOZWeXz//feNEHDXXXcV/B3SyIYCayibO5tJ3HfffSYyGc9v2S3ccMMNxi1k3Lhx0q5dO8k3eOOuVSiiANWRULWzQnr+/PlGFcDUm0leSWN+wtrh4PHJTh7lmc0d1fe2GxTXPp79jd9gcwbtd48Gvi+bpkhQ1Adp9JryDnmwRUj234DvSV4km4JoNmrZBJ8PccSP18/Kl5fJ4+DBg02jDKs82u5IKNXZII2WONLxLRvo0KGDIY7Y9OUjlDgqPA0KjqxlyMSJE031NF17Tj31VM0pzTOgRtEadMiQIeYnqF27tnTt2lX69etnDOJRGYO8WaDhwIcfflgk9AeZ5PxwvrwM7lmUOvJRUZqciiMEjhxVyGQ2gTpLrmw+hxZzCdsyEKA+okIzDtgIRtvoMLZzkdrgNk466SRTFxFLsfYzlDgqfAEMwsmlYaI57bTTsrZLVWQe5CjiaECqCOEsNgrWDgtyQe6ZV0KauQYbJhZf2xYVsMgSUuW+iAY2XU888YS0bt3aKJaE9y+66CJz3p347LPPTJgbayzus8aNGxuVKLIV4owZM+T44483JJX3s+o/aQSJ8u34/R133GGuJ/fwww8/bH6SknLGGWeYY6PDFrmREEm8WSHEEA+cE/gcog6RoCiS4+V5Xbp0MeH8ZIEKRfoDry8O+L58v2HDhsnVV19tmhtAjo499tgiHsN83hFHHCHfffedycHnPBJGhWhEAtWd3H2+P/cDefhfffVVWsfIOb3zzjtNKpA17ibtwTmeYuWGErqP5bFLzj+pQ5x/ikvZ5DtfZzuuMWbY+NncWGeeJGOUa8DYYzwwrm+77TZz/ZkTOJc9evQwG8toYxzVmBQWvhfn/pBDDpFRo0aZv/MZjCkcOKwdF8dlsXDhQjn33HPN+OPzuVdee+21Ip+Dqn/MMceYY2Feuuqqq2J2pcOdhc90ntt8QXC37grfgIWSUBwLGsUwhLiYGBT+BVXQgMXQVubSdQk1WZXk2GDh3nfffU1hGC1OwTfffGNIG6QqWg43JNHmSF5xxRUmF/SZZ54xvreQHHu+eQ5qIKSHn7ReZeHmfoPgARZz1F8Wy8svv9wQARZdVDvcLNI13ocYQWZwvUBxYkxAcAgvotycd955pkL36aeflp49e5pjt765r776qvmOuF3897//NUSLFq+MLYoXE+G3334zKRBugfNC673bb7/dECMI0WWXXWby/CIJODna/fv3l7POOksGDBhgzgNuINYSDscOvhcFYVw7iB7kh+/HZgFSmgog7ffff78Jy0OwubaQK4rMYtnQJQLdulCJL730UhM1gMAdcMABMmHChIJNCl67ECgIJOQV8uhMyeC789oLL7zQEDeuHcf2yiuvmM3SBRdcYD6Da834GzFiRKGiV8YH45d7gu/GGGLzwIaUkDEbEPud+QxgNwqcY8g4ZJLrxNrCPcV7cgyMKZte0bdvX/nrr7/MtWA94n25T6KBjQBEmnss1evkeYQUOcHUqVNDPXr0MD8VsbFq1arQY489FnrmmWdCa9euDQ0fPjz05ZdfhlasWJHrQ1OkiC1btoTmzJkT+vHHH0Off/55aOTIka6994YNG0KTJ082P/2KrVu3mjHOz0gMGDAAsztzzrgXqlSpElq/fr3524knnhjq06eP+f+99tordPjhhxe87tdffzWve/vttwu937ffflvk9/b9nLjoootCFStWDG3cuNH8e8yYMeZ1H374YczvwTXmORxzJPj97bffXvBv/p/fnXrqqYWeN3fu3FCpUqVC99xzj/n3v//+G1qzZk1o9OjRodKlS4fuvfde8/vNmzeHdtttt1D79u1DmzZtKnj9Sy+9ZN63V69eoURjskSJEqFrrrmmyN/OOuusUKVKlWK+lr/xnMhrdOCBB4a2b99e8PurrrrKfJfVq1cX/I7rxHM/+uijgt/9888/oTp16oQ6dOhQ8Lv//ve/5nlcRwvGSMOGDUMNGjQIbdu2LeE5d6Jdu3aFxkc0cM6inTe+K8dtYT+zQoUKoQULFhT8njma3/O9Lfr3729+xxjjmi1evDi0bNmy0KxZs8zvd9llF/NvJ7gPnNfUrge777576Nxzzy34HfMJ73HFFVcUOWbndYi8XhbnnXeeOe+Ra8opp5wSqlq1asF98cQTT5jP+eCDDwqew7hs0qSJ+f2QIUOKvHezZs1Chx56aKg485YXuYLGfxSeBbkh7GYJa9BGEBWE3SO7btQHhX+AGoXiQAiL6lVUM0JQisK5YIzxRAUaKHCoH6h8qDD8jBWmJh8SFRA1iXvGPjj3fJYz7Gfz0ADvy/MIDaJ2TZ061fzeKopYnllbJDeA6uYEIVsUKRQ5jgNFlcgDuZEoRRRb8HfUMtqN8npn+gphyGTUT5Rv+CwKoVtA0XLaQHEOUdQjG0+gWDmVKL4b8xxqKg4CAJ9gVDJnFT3Xjc9AzbSd0ZIFKu2kSZOM2ukWCN2Se2zB8ZKXzLFbldrm5DLGULhRFPmdbapB6kNkFMm2uARca64Vr2ENQCG1+Oijj8z5RuFNpz88rz/yyCMLTMvtA2WTcWc/i+9DROSEE04oeD2pA1bBjAbGVT6uVRqqVngSLIyQRsIa5J5ANgAkkonJ5rxZo2GF98CECQEhvYDr16hRI2MZ4yQoip1wdlyJt+CxwB544IGmIMb23HYuZk5AEFj8yMeKBkiXBYTilltuMaE3QnRO2PxFriWhbLxrcTeAFBE2JT+xOP3hed/I4+Z8EL6OBnvPWzIW+TzICeMtWaTb7SbadXJahwFLSiNzSmmDG/l62/AAUkgaAN8PEhYJ6yzA39u0aZP08WKHc/TRR5vP4XXkAdKmlTSRdBHtGvH++BwD29bTCdte1uarxsqdJCxPZTIbF2f1vXO84LgACU+nXS25p5BXcmR5xLtHONfRrlnzOB3jGFd+8pJNFrriKjwHJggWRRRH8rIi1QBLGslNwScL9coSS0VuAYkh5408M0gjZIJFgYVDW3ImPneMeRSlRJshFEbyvlCmyOuy+X6RQKmJZ2xtVR4WT4oaUL0gF6h6FBmgtuBJ58xHYyFH0aOYhuIO8r3ImyOfjEKZWAtlZJGNE5GbCT6P9yHXLJoCS3EC84AlfNYTMFXTd8gGz48kdYDvTy5ntMWf35GTF80OKpZi7IVWjOSHQrTstSOHkMKWF154weQAAr5rtGONd/1igffhfEQbz+QyOjcbkecZBw3GGYrmddddZ8Yx78VYi9UYIlXYcc3GhzzTaCgOqV61alXMzY+focRR4SkweXzyySdmQWTSiFcEw6TP5EPHHyoxWUwUuQPqL6FPFlTUEhQNWx2tcBeEOCk6gKxFFl04AQGkWp37I57Si1cmoWBCxJALCwppooHqVR4olBSX8P6Qj3vuuadgo2fDkBaRodp44LiZC1CW4rUdpZIXQCQ4BsikJXMceyLzZQgNnxXte/LejGneG6XJCeyiIFL289MB7xFJlqZPn15IgeP9bftVJ2zqQDqfz7zJhpwHGxWuN0Uzljhy/dj4RSLW9YsW9uaYUV4h3lyPWGTe2vFwnjkWpwBA8Q+qMWPS+frIkDTXj9QJQtnxVMdox8D6wmdyLVHx44FzTapNKOKaRbs+9juhqKLI5xs0x1HhKZAHN2XKFJPz4sybiQbUBarh+Al5dDPnSpEcmBxZZNi5swijKlJRSYclJY2ZA6rk888/bxZ88rPi5UOyKGKrEwlnjplVyZxKEwqetVGxIIQd6SEJgYSwWVsSVEuu/S+//FLoeZHvFQ/HHXecOSYqqyPVL/4NyQWMMxZ/qnIJf/IajoMK20jiGgtELKxtixO2ap0K9Eg8++yzhZ6TDqg0ZpPsPLek51AtbP048e2kgpj5zQKLF8KqkEsqd1OBPW/OcQQpdlrKQMQgpk4LISI7VAfHsjMiymDBRoJjpg2vJYZ2Ux/rmvA8IhTOOTzamBw+fHihcwFYK3gOYyUSztdyDJGfz2fwevIcnRZCFs5zwLXgmg0cOLDgdxxvrBA3+adsoqmKzzeo4qjwlFcjkw6TMV1jkgETDhM/kxr2D9HygRSZSSdApYE0QkxQKXhE5ncpModYoTUnCD+jTBLeGzt2rFnM2WihElE4g3UK+ZEsblw/3pPQM4oKViORpI38RyxLsI1BCYRE8jy7AFugXj3wwAPmJ8UMkEirpiUDyAvq5Y033mjy/QhXogwx5iBbFCRce+215rvwPL4j341iGsYkxBG1irEJKYJUxlK9yPnjO3B8TnUTAsfxc444X9auhs0thRL8rTjt5PgsLF+Y97CtwTeQ9BtIsMX//ve/AuslrguKGnl/nAfITqr+phBNPBopjuK9IMwQIa6pBTnl5LBSHMLxkeOHmoy3YWTuK4B4Urxz8cUXm5QBzhfvfdNNNxWcc1sIx3fgfRkvzvaOXB8KTSB2ttsQPpeojajr+IvynTkOvoPTVLtPnz4mTxMrKq4TeZtsZLHj4W/2u3EMqO98N2vtxnrBOCVSwv+T/sH7o16SpsHzrXUYf2MTceaZZ8qff/5pCmUYNxx3NDBO+Fu6NkeeRq7LuoMKL5bY5xKchzvuuCP0zTffpPV6LBOsZYgis8CGg+uELdKECRM8YYGTD3Y8WMNgN8LPeHY88RBpx+O0p9lnn32MdQpWPnvvvXfo+uuvDy1atKjgOcOGDQt169bNPKdu3brm74MGDSpkNTJ79mxjhdK4ceNQ+fLlQ9WrVzdWQD/88EOR+xGbE+xM+LyTTjrJ2K3EsuNZvnx51O+DXc3+++9vrFR4tGjRInTppZeGpk2bVuh5zz33nLGoKVeuXKhTp06hX375JdSzZ0/zWs4pVjfMD057FgssX2rWrBm6++67i/wNu5snn3zS2NjwfXnw/0899VSBFU6ia8S5i7RrsdeJ89u2bVtz3Hy3aDZHWNaccMIJoV133dV8fpcuXcy950SydjzYG/F63ovrzGdibYRFjhNvvfVWqFGjRqGyZcsaqyOOM5Ydz8MPPxx69NFHQ/Xq1TPfo3v37qGxY8cWsda5/PLLQ7Vq1TL2R5Z6ON+Da4MlDmOS4+Hf9913n/lM3hebIr535HHY9+c9+D4cM5+DDc6ff/5ZaI1hTPC9+UynNc/SpUvNuOI7lClTJlS7du1Q3759zX3jxLx580JHHXWUsahizFx55ZUF1laRdjxdu3YNnXHGGXGvh1/teErwn1yT1yCCvAh2MC+//HLgiwaQ/9lls3NFyShOlxBCA1SHktCsRtLuAeUGdQklgLAUyoAtoPACuO4oEqgIXjmmVMFUbPOn8rESM1ewqiOhd8ZvtFxPQvnMQShW2ehXTZiZHGCslPIBzry/4lQSoxTixsB7kO7g197hY8eONabyqJZOo/J05i0vcgXNcVTkFBAQKqipmCOvqbit5SA3TDwUDUTmYilSBxM4Cd6EKCHkgNxT275O4R5YbBn/ShrdBeSDkCGhbptzB4l02rvQOo7w53vvvZfDI/UvMSc/0faXLs74Zfzj08u8Q4jYWc3vJzzwwAMmBSQeafQzNMdRkTOw28ImBGWQtlJuKIQke1MwQwI1idT8v193rbkGBByySF4TOUHJ5p0q0l+ArcWLjln34TynkEbb+g4FknnD6WmpSA4QO4p1gFt+ulwn2+QBOxtrmeQnvJfnGxBVHBU5WySxEWGXf/rpp5uJ2y3gDUaiM4SHxHNF6oDAQLxZDEh8J7E8VhK4wh2gskBmNHso86DClgfEx1bz6nlPDZw7W6TC/F3caJETiAgUa5FigPm8XhtvQRVHRdbBJPD555+bZvFUqGXCtoVJhw4zECBFcmCSpiKVPBpUL7qCYK2iUOQjICdsjGxLPDdy9JIFleJ+BxXUTjN2t8EchAgAceQ6uSkuKIoHJY6KrAPrHHzBsO8ojoFuIhDucBbgYJ/gt5BHNsBCibkv/pmcH84TnUiUNCryHYx38h6dRtSoj7ansiI2OEe2M0ymACklOkX0CPKoedXegIaqFVkFXRgGDx5s1CyMg7MBQlFUt1HppiGPwmBCth6Y5DFi3h2rfZ1CURxQZMXCH8tI2ksFSuTt8fBrcQb49ttvjUrnNLEuLpg/IdacF85TNnJxKWpi3JDvqAWP3oASR0VWK6gxrcXGBWPWbIGJB2sEbGQgSIqdYBFgMqZdG2bGGPEqcgPbLi9a2A9Da2vTw4PnYSCNuTGm0c7Wgc7noaRhLo3p83333ecqiUgV9MAm95ix5gQmy8wHpKywaSHFBGPleBg6dGjBd6SIIhEiz4vzgQODBUQIskU+L/cFm063yUrktXQ+aLWaCLRijfbayOI1jLCxOMP8PVq3F55PKJjOQ0RkIkGrPIzWnaQRMk0ebjYJNd+NccF94edK63yChqoVWQGT7wcffGCIiRu2O6kCNY2QB6ojiwN2MkEFRIMHXpe0NoNYaAg/93D2WY5HvvB8I3cX8kTbQbqY0C7NWbxEhw7a8THmIYt0ZKLHL10zuA9RlrMJjoGOJzycINeZrjB0f6J9IuOQ4yP3GUKITU4kIA6XX365CWPait5kYc+LE5F9qAHzFKFR8n6tqmZVNrdgr6UTyar9bAheeeWVQr+DBEaCjjp02KEdn+0DTR4zHXZ4cN6feOIJ07eafs8W/D/dfmwfaksaGU+cd7cqqJMF553qasYEOY+cJ52zcgcljoqMg0nnq6++MnYXtLDKVXVuvXr1zMQHaXJ7EfADIBsQjMWLF5v+vpwLFkWdgL0BxqS9JrHGJq3naOEHaHlHHi9k8LPPPjOWVhakguAj5wR5xbTlI7eYPrrksmYLb731liEbkX21aeHGceATavMMITuoYShz0YgjvYEJe9t2gKkg2nmJBa6BNQu31dcQSsi9VfkwDUcBTAfOa5kqOJdnnHFGwudxrSHZtJeklSD47rvvZM899zQknu/QsmVLs5GwVlBs8jnvt912m5knnJGJXJBGC3JOIYyErPl/LZbJHYK1cipyAvILx4wZY3qPZnOxitWxgVAYi4I1rA0CFixYYPqxEuohbK/+lt71xEslFGeVQ7pPJAKpCKhLpIxA2LIJQqOEqSMXe3JscUCwpBFATAhbR+vwwvi95ZZbjFqXbi5uOuFnG/ZnzuD1TvPw4oD3YrOQDmzRSDzQWIHIAhsLZzW0U7FDyWNzb6ukGRu8N4TTAqIGacx1wRBjguPge6MGK3IDJY6KjBMWQmmEh7zios+Eye4alYOwTRDAokBYmlwyOr8o8qfYLNJBIB5Q21h8UZ0SgbBgMo9ECzgkCz9VNiyRIPcSk/lbb71VZs6cab4P7f9GjRol119/fZHn8zzGMapkOiAki1sAyhr3Ap+T7P2DZyHzBuQVKzHA75znAjUsWfD5HAsRGPIJbVg4GaAA8lrC0xC/Sy+9tMBTMRJ4sJKqYMFczEb+3XffNRuOe++914TrIfCkFBDWRsW2VkUApTXXpNGC783xcK7TJd2K4kFD1YqMAfWEfCVURhK1vQQWDqyAWLRQ3jJpC5QrkBrAYtKoUSNp2rRprg/Hv2BBf+01zPeQrEUI+eXofJLfBUGBwFCdjPIGEUTNTwYs/hTVWMIZDzZMmQiJwrWQLIhXZD6fJYKWvNxzzz3mdxApiuiOPvroQs8dP368vPjii2YjmqpaDtEgbHvYYYcZNZNQ/SOPPGJC15CqDh06xH39Qw89ZAhVJFDlnMoc80gij0a+H+fLEsc///zTELXu3bub6AwpNfHAfAqphoijTlM9/dxzz5lUBIqAIkPJ3P+MGeYDFEgM/Tnm0047zfwd4jlw4EDz/zfffLOJRhx++OHmmrEpIDqTq/B0rI2/JbmQeK6npttkF94ZDYq8AhMaeTXsCE866SRPhkXJ7eH4WJA4PvJ+8gF8Jwgx3owUvrBg68SaJgYMIJmQ1Ypk3fDPhx4SefVVyluzfjgHHnhgoX9DVGjbmYqKTLiYEGkifP/990m9X6JCs5UrV5qfLPaRIPwLkUUJpWiOsUsOI/l7fD4kxlnYQl4geZqpAlLGwwKFj88kjHvjjTca8hUPFOtAuJw46KCDTOEJ5BNiBSlPJn+b+ZCHBcVB/fr1k549exoC/cILL8R9fWSV9CmnnGLOIaQPAsi/nbDnHfIIcQTkhl5zzTWmirtVq1ZmTFA4+MYbb5if/J7zzeaETSdFWMyXXgHzdWSxjCJ7UOKoyAiw2LCdYbxsJN2mTRuzWFE0AsnySjgmXRC+IQyFIsWimI9KalaVRkhjtJzD884TgUhEqchNF5D7RMVKzz77rCEJEBXGK11+Ui3yQoW2FbapkNTiIpqHKnZC2OGgtNnvAamCjF555ZWm7SWgPSnKIPepWyA8i6r58ccfFxQlxQKqHY9IQLogkChztu91OoCUkgPKvJkOKGZBveX1kcTRnvfIcVW/fn3zsIAo9u/f3+SBM29TREduJEU0FDVNnTrVU8ojKrLtLMP/a0vU7ME7o0CRNyAMxCRPeJpJyOuAYLGI+J00AsJ+fA8WIZLIFcUA4elYJI7fozpG8chLFxCXRISOwq50K3FtvuH06dPNhikRkvEUBCze8QiTzb+MzP8jf+7VV181YVcn+WX8oixSpMFzIAXXXXednHjiieb/bSiYIh9AhTXPw3IrVRAW5rWk1aSzwYWM2S4z5B1Cyvl3On6oHMu0adMkHfCZnGdCt5Gw5z1ea1eIOZ2jIIqcD4qZyINlrEHiX375ZUPwI1XXXAOyyJhmLHAN8mEO9wOUOCpcBbs/vNnYiUNe/AAmf0gW4XXCNEzgyeZ3eQGoHSx8hG4gwWqx4xIgKLE6DfF7H/YbJpRJ7hqh0URI1gEhUY4jqhbEJrLymxA21c3RChysybT9G+TwnXfeMY9IkOtHxTj3bqqgOI585+Jau6DEQfo5t+neexxLuvMOqQeEbaO9nvMOaYz13hBeiDk5nIS12TBw/i0R59rxexooeA2cawg/ZBeCzPcMms1aLqDEUeEamOg/+eQTs9smtOFH8mIrQCG9yVaq5hIoDCTXs3BRoeqlUJLvgVoeT3F0WU2HJKFYQWIykRNM8cR///tfQwKows1WjiMqEMpVZAUz+XbkpjFnUORjVTrOwRdffGG8HK2SyXMi8d577xmljLw8Z36yrXCGsNrwJYUUkcSJ88EmF3UzHbIRGXpnvrOfx99IF+E7RV7LaMdCwQ/3MeFiJ2wRE922AO/JHBWpTFOJzmdGK0LkfTH6joUHH3zQXAdC3IxByBfzCKFp0iI4lxwz1exeBNfOFstAoKMZoSvcha4yCtdAeJqCjLPOOivtXJ9cT0AscCNGjDAPEvOjJfR7BSgUpAVwjFhu+JGoexpUT1MIEw2QBvIcXQQLv30UF7/++qshGRABlD2KHCBJLKqQsGRIgJs5juQSUryB/54NCUOoKC7Bl5F7jbw6jpfwNTZemIY7C0giYRVGiJ8zDEuIG/UM31I2U4AuKcxJFMhAWLlvKMKB6D3wwAMJj58COh6JAOnnWLmGEDyUMD7DGULlGKjiZq7hepDf+dprr5lIx0033VTo/fr27Wt+2vA8aiCvxezdthikywvEE9IYWYlOJTXHHWujQB76ww8/bAg4yqslubwPmwz+znhBfYxHPnMNzq/Nd6TgKlEHJkUxEVLkBFOnTg316NHD/MwHLFy4MHTnnXeGvv/++5DfsWXLltDQoUND33zzTWj9+vUhL2Ly5Mmhzz//PDRp0qTQtm3bQkHHhg0bzDnhp6sYMCAUKlkyFCpVqvBPfp+Bcbdq1Srzs+hhDIBNhkaOHBn3PYYMGWKeZx9lypQJ1apVK9SzZ8/QvffeG1q2bFkoF1i6dGmodOnSoTfffLPI395+++1Qly5dQrvuumuoQoUKoa5du4YGDhyY8D1vv/128x2XL18e9fecC4snn3zSfEb16tXNcdSpUyd0xhlnhGbMmJHU8dv3TPTYa6+9Cl7Dfblu3TpzTZlHtm/fbn5/8803h9q3bx+qWrWquT7169cPXXzxxaElS5YU+Vzez/mevBfH3aRJk1DFihVD5cqVC7Vu3Tp03333hTZv3lzk9c8//7x53po1a6J+r+OPPz505JFHhv7999+C47PXi99XqVIl1LFjx9CoUaNCXgfHv2LFitDixYtDW7duDeXLvDXVg1yhBP8pLvlUpA6SoC+44AKTdExlpJ/Brhp/NXZ6tBT0ovVOqkAtIK8qWiWlF0BIhpBerjvxeAWoa+RyYT3kutowc2a4EMb6OKI0ulhNbUG+nw1V52PKAXMDhTmooUEbmzxQHtMpmikOUCdRXR9//PEif2PpRwFmrHFs+RCxsL3ZUSDJ+fb6d9qYxLzlRa6Qf7OTIusgVMIERDeHfCCNgInHkkZ6W7OY57pKmeR0QlaE9chxSsZSReECIIkuVk8HFbfffrvJmSNsvt9++0lQACFgPrF5lOSCZ6OAA29KutEwP0cDpIp5jWPxOsFKFqw/5GuS+03RT67n7HyFEkdFsUACNcnXFMPEs3vwK9iVY1OBGsRil6vcTXadqDX5YlKuiL7oZaowxgugWAWFJYiw15R5BAeEdC17UgE5j9HaEHIMODGgMubjWIOoQxitv6Na9LgPrVtXFCtcSsI9SdrR+tDmA9iJo/Dx8/fff8/6woc6QfI8pJHzTOgpHyd7RXisETbMF/VHURTcu9bzMRck2hLXfM9QIxrDvYRFT75/11xAiaMiLXAzYhLLREj7rnxe7NjBUlFI/gzkkZzObAErDCopqZrWftP5DTYJEAp+KvIT1rKHOQXiyPXOFrFh/oI0EppGkcvnOdta9ECUSaNSuAsljoq0QBcBPMawnghCqye+IzYahD6iGRa7DUJJAOuQAw44IK2uGAp/AcLIpkSJY/4D4sicwlySDeLImCJsHQTSaIGyi/UTZDmoKRKZghJHRcrAG4yeqKhw1pg2CGDCtXmOVF2zm82UyogHHR5qQD3JFIr8A5tQW5zi7JKTCfAZNvcvSJ1V+L6cZ1oS6obMPQRnBClcAbtjujoQBrDmtEEE3WWGDx/u+mSPBRBqLpWBarWjyAdccsklctBBB+X6MDwJq/zRqhBF0I3N6P/+97+Cdq+QJTa5ALu0VEhjgwYN4raS9Mv5Za2y1kMKd6DEUZEyYYLcUEWdj15zyaJly5amao/z4dZOFusMumFQfdqlSxetBlQU4PXXXzeLoH2gHmFtc9lllxm7qEjQSYTnkeKQS6UFj7pXXnmlSEcU7p3rr7/e5O2i4O+1117G59Gq7E7y4vzezkcyOb/fffeded82bdqYfGzeL1eIdyycA34HeYyVQ83f6OaCswIkkDno+eefL/I8nkM7RXLQeQ2kNMgFIpxXQtbkk9oUIEXxENyVX5EymOwJUdMqi4k+yGAXy64edZAevJyT4oSAWNwJUWPwCiFQBA+Mn0SqED2dMQsmZ2vo0KGGOEASJ06cWCjX+O233zbEBN/PH3/80dX2gangySefNMfbp0+fQmMdBZK2f6iRjPeZM2fKc889ZzwHsb+yHqVPPPFEEUsZ2prSpvDggw9O+PnvvPOOaaeH60Ou84TjHYvNPYTc8ABOux4iG/369TNzDe0DIc2cK84flcNOYk47SQoWaSVIfnRQchrjgXsDAk3ImrzxoJ+PYiPXrWuCCi+2EUrUzonWYI888oj7bd18DFpzffnll2m3cuO80u7L/r/CYy0HPYJYLQevvvpq8/t33nmn4He0uatUqVLoqaeeCnXo0CF09tln5+CIQ6YFXs2aNUO33HJLod8PGzbMHPMzzzxT6Pevvfaa+f3HH38c933vvvtu8zzeJ5lWqLYV3+GHH16ofV9xrkM6SOZY7HywadOmQr//4IMPzOe++uqrRVoGli9f3sxDzlaHtHYsUaJEaPr06aF0wfGdddZZoXwB555r8M8//4S8gg0+bTmooWpFUkAdwEvw8MMP12INB9i9kutZq1atlF+L8jJmzBijHJHbpLvgYINwIuMglbAiipINCVt88sknRl058cQT5ZRTTpGPP/44J1WljGtU9Ei10+aa7b777oV+b3N6E5nso9yhYuJykAgoe15J+UjmWKxdj1UbbX6ibdPI9XSCf3NtP/vss0K/p80g+PLLLxMeF+PtnnvuMSFwPht1eNKkSVGfi2JHKLxevXpGHW/SpIk8+OCDRdIhVq5cKf/5z39MiJh87bPOOsuEz/l+pF3kApx7lGwUbHteFelBQ9WKhGARIhzWqlUrY0KtKAxLpMlR5Fy1bds24WuYaOm4Q4U6pt5BzhdV7AxHptqrGkssUKNGjUJhahZ/QpYQC4olKGiDSCaCM1SaKG+MdI14+O233wxRYHw7QVoH4dNbb73V9BMmPYNQNTmPnTt3jhtWZ6NFKPvmm2+WbIAwsLMAzobNIcROQLjctiWzZt0QNHLzOOeR3WbsZzKXnH/++YYEEvaGBOJ4QXvHq666Ku7n3HbbbYY4HnbYYeZBwwHSACJzLRkXvXr1Mq1PaS9LLjbX+MYbb5TFixebtAI7t5EDP2LECLn44ovNmgGxhTzmGtxbNmRNpzPdrKcHXa0USSV1M3keeuihuT4UzxNIWjAywbdu3TrugkBRDf1UWShRLRWKZPOMIS2oTJACch5R6I444ohCVlm2aILFHdssyGQyxPGhhx6SO++8M+HzyHEmfzIeuBcghqhOTrBgk+t3wQUXFHJmIIdv4MCBcUkz3wOcfvrpkg1AesmpjERkhIE+3HfccYern8154NpCdFBYmYPJqd5///0LnmOVSMic7QgDOYIQNWrUyESK4mH58uXmmhNJYnNhiRTE/L777iv03Mcee8xsVCDvtjAJAomSSj7lNddcY5RIinJolACRvPLKK83zIJBeqKzn+6GAcg9xvjhXitShxFERF7NnzzYTBTtIm7CuiA4mTSb3CRMmGPIYS51l545yQStDp1KkUCRCpBoHgYNM7bHHHubf7733nlGcjj/++ILnnHrqqWZRRz1LpBKeeeaZhYhJLCTTs51wZazPg3hByqgKZ5OFmwAE5pxzzpEPP/ww6mtQsvh+vI6K4myAcwtxc26iIUnff/99oedB0jIB1EbIzrHHHisPPPCAnHvuufLss88a4saxUFAErJWPsxCGc8/cHQ9sMlAWL7/88kLqG+HoSOLIdenRo4d5X6fiypjk2H755RdD6L/99lsTFmZjYMGYpKiHQq1cA9WW80TLXDb7Gu1JHXrGFDFBHgg5MlRn5msvarfBuYI8stNnN0vIyIKJ3VpDoLQEyYhX4Q4gDVQhs9iRI0iY1zmO3nrrLWPlBGnjASBakAMW/gsvvDDu+0OA3CRB0fI12YwSSn/jjTcKCO7RRx9d4Bv4zTffRI1u/Pzzz0ZZSxR6dRMY/juxYMEC8zObVeoQHRRHVFqun60mZx556qmnzDkjZA0ZcuZQcu4ThWKtmhppbQSxjyT9pOKMHz8+Zj43ard9T/JVI0P35EN6BYggqPYo+KjiGrJODUocFTHx008/mUR2dpF6YyUPcotQCpwG3pBGwkxMWO3atVPSqCgCp0dhLEAKyRGMBhZ2UiBANI9D1LNExBHlKtL+JhrYACUqCENNR+WMBMURLNo2vG6BhQwgBB+NOHL83DcoqEED5JFQPqQbdRYVtH379gW+l0Q3IgtvOPekBbgFa6NELmo0+MlGjHFUtWpVky7EuQxC21w3ocRRERVLliwxeSooAxpOTR1WaSQcwuSEUsH/Y/6rUMQiYyxm6QJiBXl48803zXtFVjijTkE0yHuMhUceecS1HEfIDMeEquP8XhiWo4ZFdl2yla7RuqdQHPLRRx+ZauFc+zHmEmwqUO64zqQLsLkHkMpIUGnPJjUerB8vmw6n0kzuYyTpZ0PMpiKR2sp70jKVlBwnIaMAyksgTM05RBzh/3UznzyUOCqKgEmdPBUk/GQsLxSxQZedr776ylS4koBOYrZCkQlA0shBO/nkk4v8jQIZiOO7774rN9xwQ1ZyHPlM5hIqfq1tkFWm+P0HH3xQqKUdxwYiq7ABrg5UwsYriqEYB6ISjxgXFxxvptvwQaApQoFsR7Ydhdxw7jkXixYtMlY4uDhEkjnIOu9BUUo88DpI6NNPP21C4FbtthXSTpx00kmmAAjj8UiiyvFYNwD+9vLLL5uHLY5BrSTNwmsg3E+InU19cTZtQYMSR0URYHeBmnDGGWcUUS4UqYGFzLYT03ZXinhAgaPSk1y1VO87+qaj6FBsEg0Uz5CnDLmMRxzdzHGEgBKtoADDSRwhXiibVORSvEFxDBYwtCbk/ykEiQTHTfqHs+gnEhTMYBdjVThATt7nn39u/p/zA6HCegagxlH0Fw+2bV8iQN4S2XAleyzkcfJdsK9xeh7y3SDjKHooxyjLqHrkoUeqZZxzyDm5o/FAusG1114r999/v0kdwI6Ha0KeaWSY+7rrrjPHz/O4hvvss48ZrxQDUg3PmsFrjjnmGJNSQUEW3xPlmdcReQFeSnviPiN9CNWRudornp+eR64dyIMKL7rBgy1btoQef/zx0FtvvZXrQ8kbrFmzJvTnn3+Gvvjii9CSJUtyfTh5iXzoHMO9t2rVKvMz2c4xFpdffrn5+6xZs2K+/x133GGeM27cuFC2cMUVV4SaNGlS5PcLFiwInXvuuaGGDRuGypYtG6pTp07oggsuCC1fvrzIc+n0QXeU4447Lu5n8d169eoV9bxFeyTTFYXuKbFe73zcfvvtCd8r2WOZM2dO1OO76qqrzPkqV65cqFatWqGTTz45NHbsWNMpJhL8bf/99w8lA15/5513mmtQoUKFUO/evUMTJ06M2jlm7dq1oRtvvNFcU64bnYG6d+9uOorZrjiA63jaaaeFqlSpEqpatarpXmQ7Br333nshL4FuPczLK1asyHr3rg0+7RxTgv/kmrwGEdOmTTN2Bcj5VEZ6BfiCkZ9CD1Q3E6uDBnoHc/4IUdtQDZ0TCKNpzqj7oNiCnC6qT/3a2YjcvlQNwL0OijlQnFCwnJ6NivRC2NYQ3KYKMK9Eqo3kp3MfYF2USHHMJlBvUZPJt42sVs81KJAhp5P0rGzOHxuTmLe8yBXyY3baASwnXn31VeNvRc4Cyby46WOyHA+vvfZa1DZIVLIh+UeC0AA3JTcoUv8JJ5wQN4TiF3DOII6EGZQ0pg9yrZgMnDkzTO42d4u9mprPKoIAwt7nnXee8flT4uiOITjE0TmvMJ8QsibMyppFfuLee++dU9IIEXPmwZKGQR4lOYVetHaDtHHuSB+w3pmKgBBH8jTIb6FDAlWt7HKxDnjyySeTagNHToZzsEersqJ10qOPPmryTUhCJ2+F92fnkK1uBpnC4MGDzeTEd1OkB3KPqFAkRwlD8Ggg74cH+UpaLKPId9guNor0BRFy8Xg4SaOFtXCCPLJmQdJzDQzFIY/MceR20y+d9oSYiidTWJVtcP7Y6FNNrpv6ABFHDJchPlSRWZ8vqrtI4mXiSmbygjDFW8i5AUjg5ma4++67ze9IaCZcgJktPmR+7a5ChR7+YFT+evHG9gOYdNhIkLwez+yWsASVfPg6UrUe2ZJNEUxADNIpjFHkd3gaQogaFs9rkDmbdciSnlyPIYqhEFiIziGqMB+iOMYq3vICUGw5x0TebEGjIjryxriIrgJcaGsiC9idQYQmTZpkvMOSge33GQ1U/iFlUzXmBHkb7K7wPfQjrP0OPZOplFOkBxZ9ul8QJooHVF3SAZikGDPJVG0q8h+oHixeGiZTOHMarWdjPDBmmE/4yWsgkbnEaaedZmyYWC8RXFiDvUwaLazwA3lUBEBxJDxIeJrF2wnb05TQIC264oHQs83NwEqC3pokyzo/A0T2ILZtv6ZPn17QDioS9Pa0LcCcrZ68AG5qQqx4uKkJaupgR82mhYk7WYNvFgN6VRO+wesxW713FbnbnNnFnLHCvwlBOjep/J2Fnw0vhTL2384Nh30tUIKZv+D6W9JoCWEiMHez/kE4dR4vvj1PZAtHRR4SR0hZtGpV+ztnU/ZIMFCOO+444yHGQCHc+Mknnxg/QyqZLBnlMxhYkT08eQ3hRicxjAQ+VtEKcHINJpnvv//ekGE3e9QGaYLHQ4/FHiKYCgg/UV1oK2iT6S2r8Ba4ZpYU8uD/LcGDGLKpsM8B/M3mT/E3JyyxZD5hXNlOKva1Nnxmw5eMFQgCP/m9VaX4u/2bEgj/IhXSaGFzIQFjiP/XOSU1sN5zf6GWwh/0/OUxcUQOj7Y7YHG2f48FimmcoK0VChB5jBBIjLDte8SyyeBz4n0GIXSnBQGKozV/zSVQvAiVxlJKFbFhu2IwyUTrdpEM7JglP5I83a5du/rWTsYLyLS7GNWhPGxIGVUoskWeJXiQNvs8S+IskbPJ+NHseEC0fDYn+eTvlqg6w5K2Yt/CkkqebytwdSH0LhhbXCeucXEsmXgfxpLTukeRHLg/EIIwLGdzl8nzF/KpG2LeEEduELtDd4Jdv/17KqCZOy2SIAaWONoQUjTwOfE+A3sbr1ncsMAMGzbMkBVnSF6RvFcjhI/zV9wCF3a5jCFbMGM3PIrk4CRybk/0LB7c9yzGdqInSgEhg+TzO6v8ORW+4i7+kbCEj8+INT7somcJpSW69rU2/80qUzw4RiWTuYcle1zb4o5hq0CTesV4SXX9Czq4rzln5Dry/5m6P9avX29++i0knjfEEUmZRTwSNnycDmmjWIRcB+dncHNjFOoMV0NYeZ7fjJ0hjSCZ3rSKwuB602KLVmF4eRYXKEJU66MAUzADefTbZJJLsFBaOw2Uf8hTqoSIe9tJEG2KCmTLKnf2wT3v3KjymuKCz7bhbTcJp7PdpSWUHLtVLCEYjDV+Z0PtGuLOLhg/1k6HaxGZxlAcEHJlfskXU/lsgevAvU8fbrc3o6Ed3pu4a+Dk4rcK7rwZSZT702PT9nq1IPxn/57qhcXgu2nTpgW/s/+PwTOLvAX/ZhJ2PtfrYGc7cuRIQ1Di2TwoogNiQkqDm/ZL5L7Zghm6zHTq1Mm19w4C6NLDBM9k7NzwJXOvQ6xsMYoNKWebuPP5kMdsEjf7nXlAHPl8q6BakqwkMvPXwBkZc1PdskVY9r0VqQE+sXjxYjPPZ0J13HXXXQu6i/kJeUMcWcTp5kIRivVx5Ib5+uuvpVWrVgUV1djysJvDa8+CHUWkfyPtkfg9YUgLHO8hDJiAO4kj/0bOdv7O66BDDIuCn47ZC2BMLViwwBQSZcKzk/HFNVG1MXUwsXMfozxa9TDaIs19TbEc15IqeBZXXBeIIpCyEWSiBHkktwvlFgKOYwQLGwso51Q9R90HXaZQBcmTzgS5Y5zbvElFamCegFf06dPHFM+6iTJlyvhOabTIm5EEOeTivvTSS2Zh2GOPPYw3IarhDTfcUPC8e++91xhd//LLL4WKYzAshQyQXzJhwgRjJo6CGOkLSfusxx9/XG677TbjxYcyRItDekn6ZVJlkho1apQxPNdCjNSLYVCzGF+Z2sHbogkWcSygqHgPMplJh0BG5heiKBJ9YOPIeUWZrFOnToHCk8h7MxuA1Fo7sFxdb+YDNkRsrG1upLUao6CPv3PeIJNacVo82EIlCjFpj5upvGY7xxMaZT1U94zkgcUf9wJ8gbQkJd9h5NVZuOmmm4yyOGjQIBOK5QZ58MEHpX379gkLYSh0wESc3RnvgWqJr2EkscLsm8Hz/vvvmxxB8iAxNo2szPa62siC6VRTFYlBSgI5syiC2Qj7kJiNGoHagzG7ksfUFmUUM84haSrs7pkTMGiH+ERWNHsBHCsLVM+ePT1xfE41BGJdt25dQzx4MC5RYJhjIbw6NlMDmxcK4Zo1a2bWm2wUw6Ei49nLZ0GIFMlHM5977jmTCte5c+dcH44nkFfEkcX8kksuMY9YeOqpp4r8jn7WqYA2gzz8CAp76IDTt29fzXlJAeS5EM5kscxWERRhUyYqclGZtEiVUIUnPghPY2ZP4RKEm3MIcYTY9OjRI9eH51sw7qwzBOF9Z8GA3VDRShNyqSQy8RiFNKIAZjO/HOWM+R+fYqJjfomQ5RoUP7JxYlOHCFVG04jyp+WgIjkw+JnwdeeUOnFkUcx2mAdFG8LI55MWoYi/IP/www8mJE2uI24BTu9UhXvg/NqNJwsriymbG84/YW1bkKEoDML/NAxgU0MhXCbypOMBAkQRHpvRaPZ1itiqI9eMVCVFnimOivhAFYB8YPatPoGpgcT1XJm1Elrl83Uxjh5+o2UjSgApJCyMKMKau5s9QBx52NQK296VOQZyogrNTpA/T440pDEX6QikH+DWgHODHy3kcgUiF8wxpHl17Ngx8OunEscAgRxOdptq85I8CMMxubIw5jJMTDGOBVWvQTZsR1mksh2SQt4iITecEgj7Oc+TIrtAPWvbtq0pVLRFBOSBQxwJY1NQE/QwNlXq9evXL9K2NpvgPqEYNOjXIlWQe4zwMmLEiMB7H+vICZAyw26XPC+tDEsOFAFQ1Wzd/b1SEc9iPG3aNAkqmLgpZoOoEIrGHSAfvEhRoMid9kJhTHHg7L2OIwAbLkJ8OFWgRrphlu4ncB7YgBIxIE3IC5s+SCPXgXxHlGJFcukZqI3Dhg2L2144CFDiGBD89NNPZkFi4CsSAwWL3SUqidPzM9fgGmLfQR4Zi3AQwALHd7ULHIoWxV0o515YhBXRAWHk/qHJAOSefF0Kl4JGGrF/Y/yy6fMaiF5QLOnsd66IDYSXLVu2mDzVIEOJYwDA5EDBAPK6Xw1HczHZs/Dh3eU1UCWMjceUKVNMuDafrwMh6SFDhhjFhopQu/N3uwWYF0DYfejQoeZnvoF0Au4ligyYg1Dx+a4YLOczUPQWLlxoNuxutCZ1E1wHjovxxv2lSG4cd+zY0VTFB7m4SIljAEDvY0J5ifwsFWEQhmBhoyDFq0nQ5EphGsyilKuinUwCdZFEdCp1IYqY+5Mblu/KKuQ4n0O5Nq/OfkfmJlIP8pEs45mIwgphxpHBq0SICMasWbNMOpMiMfbdd19j1B9klwsljnkOCBDqGV1uNLcxOVCRizLiNYUgEoRsmcRQRvMl1GQJBQUVjFdyGAlJO/vPK/wP8lOJgGBszyaBVJp8C2NTiEiVf7169cTLoHCJuQ5vTkViVKtWzcy9bHryZd5NFUoc8xz4dQH1bUyOtKBw4dfll4pDwk3kYxLOxevRr6BwgIKXH3/80VRNQ97JjdMcxvwGShxqMguxtYaBSPpZdbUpFeRG06nI62DjSRcxWuwqksO+++5r7O3INQ8i/LE6KtICCzBhIELU+VB1mmmQ57No0SLf7SIxYiacS5I7bfb8BM41hQNU3OLHiPrhF9KucAdcb4z1UZVJu2CzywaC/Fa/Yfbs2SZ3E1LhJ1irMXKm/Xjec9XD+rfffpMgQmfoPAY5GISq2R0pEqsETPrk+2S7m4Mbkz75mFStsuj6qeAAsgthJ5xHpbRtDxhEsLnjOgZ5k2fVL8KBqP8UIaCo+wHz5s0zeY2MYb8aa1P5jfLvl3OeS3Tv3t2kV7DhDRqCOUMHAOzcycHAR03DfYlVL0g2qh2Klx8B2SJfjAULzzzUZi+PTeuDRnU4xrr0P/ZqIVK2QF4nSkbQO62gPJLXSncVwtY23cbLgDxQQc38webTryBlgLkE8qiIj2bNmpn5lnU2aFDimKcg9wLliV2RIj5ovcUOm+rHXHaHKS6Y8Mll9XIhFAo44R1SKGxVJw9FOM9z7ty52lpyByjYwP/RukFwj3rRAoWNEMSRqn82QH4Gmze+A/nSNEBQxEaJEiXM+ootGpZ3QYISxzwFizPhP69X9HkBKI0HHXRQXhAYimUI87GYETaDFHsFLK60vcTKAmVDURicF7o78VOxk8jY1BEUPaqvvZSKQbTChtdpt5gvBUv0GiffWxEfbdu2NaklpFQECUoc8xAkN5Nvg5WJIjYgV/iXoWLkmzE6Vakk6DOhecEjD0soHnXq1DFWR37NAVPkDljbYHFDaJBNUa6L2PA9xM0AFZ35w8/Rikhgcq1dxhKjTJkyJsJDPq6XWtNmGkoc8xBMrCzM5GAoYgNyTUcdL6lyboFQNTliKDaMh1xNatacnMId8tYIO3o1jK7wNugWxJhu3bq1CenTMzhX5vdsysi9hMhiHZVvsPco6q61F1JER+fOnc04HDVqlAQFShzzDNzkkCEqqYNanZoMyJciN4W8pHxVvyCNjAPUEMijLUjJBijOIbRouysQ/kJtVCiKA1Q9rHsoqKJ6mX+jrmeTQDLHkqNLSgiboXyeZ6dNm2YiBblWd/3ghjB8+HBPFyW6ifwd8QEFFbX4+nmxx7KXQC4ZhCrfc+0YC5BHiFu2qpYJjf/yyy8mZYLFVZG8ykNBiCqyiUHeo92IELYmpzsbRUUQKJQl8qFRmvItxSVaDh/RiqAaXSeLrl27msYRiBFBgBLHPOx8AmkMuqVHPBCapmKQ6sEgnCdCfFiEoM5Q/ZfJBZbQFgbIqDBUxGKSq0jehoZQrLZXTA1YGLFo09s80/m8jGtURi87F7hN0FF2yQXnHCuio2bNmqZLEMJNEKDEMc/CCtzc+PkpYgO1AFKDChckoJZYU+VM2ZrQuQaVkT7ESoBSA+FWQl25ytvzK/CpZbyh/rFpyUTVNfMqyibXhvEdhA2nBcSRyAUdnhSxwbpL7q3fugalAyWOeQR2O9jvUIigiA4UCSb/fLDeSdfnkdCTm/k4nM/Vq1eb/0fZDIoakwkl/JtvvsnLYq1s5JnhIoG1ltv+g9gjkSPMpsiLPpKZBoSce5qiJEVsMPcR3QmC6qjEMc9a5qnaGBuEaFEkgrxzhjDbjhwk+JPeUBzweiZKKlwpOCIcnk+2JAr/WaNYgkP7vOKqt4xpSCNjmlzhoHY3Yt5gM8j5UEU8Ojg/uEZQTJTvRTJKHPMEhCAJJ+iuMH4oHwQ97w5VhmRuFoHi9KSlSpuiBJQYNiz5aEui8J+qDsljbLJJZFOT7uYIdRHSyOshjUEf35zTH3/80fRnVkQH3pdEdKZOnSr5DCWOeVQUQwVckHJvUgEKG76NeFsGVTWIzAvr06ePyUNk/KRqt0HIn2IEiCchwtq1a2fsWBWKVMEmms0Mmxo2N+lYUaEgMa5pK0coPOjgnFLJDikKYsg+GdSqVcsIE6NHj5Z8hhLHPMCMGTMMMVKn/9ggsZ3Jn8o3RRg2pEzImvBKKiEoNihVq1aVHj16mJ8KhdcA6WNTw+YmlYprwoy4D3B/kLemRV47wflgo6n2PLHBOkzaWD73r1bimAcgHLPHHnuo6hMDECJ2yrQsy2ez3nQBmaYvLWbdicgj/aZRb1AfKLQJevjObeuTfv36FfRmVhQfdnNjc/QSAVJE4RhejcXN/81HcL83bdpU5syZ44lWpl5Eq1atzHnKZ9VRV1GfgwRwij20KCY2UA4IHxBGUBQFpJqkbkjhxIkTYz4PLzeUyYULF2b1+IICNjWkUejmxl2wiFM0w08K5GLZ9ZCuQRtB5tQgmHunCzr34J2pRXCxozF4KZM+lq+bD52hfA52NSw2mFkrigIylIySFnSwEJAjiw9ZtIWV0AutLFEbWDgUkhGvQNIG1Gg5c2Dzg6K4dOnSqB1h8OCjcEw7HsUGhJqNpobwYwMhh/vYFmTmG5Q45oGhMyFYLfiIfn64cclZ0t1xYqDK0gOYLgiRpJEcUUhjixYtcnZ8+Q7GKYQm3608conmzZsbn1tIIoUzFqRfEHpFmczX3vVuY/ny5aZ1q6IoGGN4Kuerp6MSRx+DPBPMgrUoJjqwjcC8l0pqRXKwhS5UoKPOAPIZlTQq8gGkAaAGsbATloaoE07EuLl3796azpIC2OAQocjnIpDioGPHjmYOzUdDfyWOPgb5aOyOyVFTFAaLAdXmFA1psUHqoBKVsCmbE86hkkZFPpJHcnZpwUkqi+aWpgaKMSk6ynfPwuJUoJcqVcpEa/INeqf4eLc3ZcoUk9uoYdiiYBdMIjyhKUXqIH+Jc4iJshr+KvINkETsuZgj6tevb34qUgPrDhtK8kIz0R88XyrQJ8YpOPQrlDj6FEjgqEJaFBMdhJwOPPBATeBOA4TvUGL2339/Ux1IcZHb/X8V0RcaOj+pxVHmgUpG7i754WDIkCF5GVLMNHbffXfTiYqQtaIoWJ9xoaAlcD5BiaNPwS6Gm1ZzcoqCBYDCGHLzFKkB9YDCAcJQVFmzsKIqaMFA5sF4pWJdx21mwSJOGgt+e3iYMtbJcSRkTbs4RWro1KmT5tnHAPn12PPkm+qoxNGHIKzCjlnVxughfPrLameD9EBOIySRhYBQFA/CLUx+FBppSCpzoI0bRuzazi2zwGoHU/DGjRubfzO2u3XrZgzCmTuK0789iIB0E/pnflAUBm4npEspcVTkHOyWWVwIaymKEh/Io7YWTA8QRhSEaIUCjDs88JQ8ZgaoXdh3qOqVGeAUwPwACK86gcq77777mkiFFnukDjwLBw8eXMQfUyFG4OG8YF+UL1Di6EOwe6HStXr16rk+FE+BSZ+FAf8szRNLHrbNGiE8CGOs1mxMgKiRVFurBYfCT1iwYIGMHz8+rrk6yhl5vaRoKFIDueSQcWvhpdiJJk2amI1JPqmOShx9BsIoKD8api4KkpAx8tXOJqmBBZXcxkQt1iCVtGJjgYBo0ppNofA6CP9T7EX1dKIojQ27kietbgKpgdA/88jq1atzfSieQunSpY01D8QxXzqYKXH0GWwnFA1TFwW5SpDGypUr5/pQfAMUWtQYqqfxZEsEyCXdNTAK11wwhddBWgVtWevWrWuUxGStyyCbbKg0LSN5UGSE8qiqY1Eg9ECq8yWUr8TRZ2DXQmu4ZBb5oIGJSwl18iDcjDktZJvUh1R20N27dzdV/QCVV1F8QMoh5ImUX0Xy4HxS3EVv5VT8bilooPUmOada9JEcOL+ojozffFHW3ELDhg2Nb2i+hKuVOPoIJM2zm9MwdVEQvl+7dm2uD8NXICSHEkMYpTjn/ZdfftGCDheAUk6vcFXM3dkUMSaJQkACU+0KAwmiUAwShD0V+dOKxEDUSJWkBwGlSpUy9k/5Eq5W4ugj0CmGQccAVOwEuXZUQipxTA4sgjzIVWRxLE6rNQqRmBTVxkThFZBjRw5ucaujsVIhp5dxvW7dOteOL9/B3DJ//ny1lYoAgg9jk1x8v0OJo8/yG0nw1m4ohYEKSxhAe3Ynh8mTJ5uF1Y2dL9Xr2JjwXr/99puGrYu5Afrqq6+06KgYoKgFI2/607tRHU2ou2/fvpoalAIgjOSHYn+k2AnWbtYp1nG/Q4mjT0BBDIUMONErdoL8IxLZydPT8EhiUAjDOIJku3W+qESFPGLro4nxxYOGRNMHqiDKN4tz165dY9pKpQoUeeZfQtZaMZwYWM/sueeeZp7R8Vx4HGHNQ3qP36HE0SegFyg7ORK9FTvB5MQCwW5OkViNQQlgUnfbIB0VHA+84uRLKhTF3URCGukCQ26j24s+IWvII527FPFBkQzni029YidYv5csWeL7vuhKHH0CWugRNtHe1IUBAbJJ7IrYQA0cOXKkIXiZMjhGeUTFpDCBUDgqjUKRaUDkSJVgbmTzQm6i24A40lGJ+4hK63wocMgkKPDiemi4ujBQHJkj/a46KnH0AZikGGiEqTUcWxgoDLvttluuD8PzgFiz2yXZP9Mkm0UW8ghRZaFVKDIFVK2hQ4cW5I1lcn4knxfyiLfj7NmzM/Y5+USSqLJWFN5cU1CoxFGRcWAcSjs4DVMXBt0gyNlTxIetbrTJ2ZkG1drkmDFm1cokNZWmd+/easeTgtJIIQybk2ylqtByE0KkSAx8MEmLURQG6zgbDz9HZJQ4+iRMTR4fJqKKMOg5i+WDIj5YVPFZzLZCQh911E3UmQkTJmT1s/0KlGCqgTXtIrnNEIUwkEfM6LOxIbIgj5ccPkVy8/S4ceN08+gAkUPGrZ/D+EocfQBkbUij2wnffgZ9ZDkfasETH4TwCOfZLi/ZBDlOkEfd8CRf3MEiq51KkiuK4zxRzZ8rezJ8IjXikdxcvXjx4lwfhmew2267GXsnP4erlTh6HPjisTPRMPVOsHtlMiIMoupMbGAdgtJI54xcLa52kkT5ZLHXooLYQIVgXGvVbmIwH/bo0cMotLkCnWnoBKLepbHBvEPI2s/qmtsoUaKEUR2VOCoyBnzxIEpKHHdi2bJlZnHVxOvYYMygXrGw4nHphTxdFll6YysU6Y5pcmZJf2DxzXUjBDqBcBw6puOD/FPuf+2+sxOs55wTHn6EEkePg10JIb9q1arl+lA8g9q1a+dcbfA6UPbY6dM3tjgtBd1UHrEBQnWkdaZCkSppxAZn6dKl4hVg+9O6dWvTQo7NrCI6SCfiXKnquBOk71C34FfVMfcriiKhDY+qjdErdxWxQQifRQ3vT68AhZhjmjlzpin4UiiSnQfHjBljyBk5s2yIvALSZdjYL1++PNeH4lmwccVrVwuKdgIijQexX4mjOz2ZPALCl6+++qp89913snbtWjNQzz//fDPZxMPPP/8sP/74o0l2xn8OdYSk67POOquIqnXSSScZ5/dIHHXUUXLttde6+n3YXSPvK3HcCUgHoSq6QyiiY8SIEWaXj1+Y10DYnHxHrbKM3qoNqxd+Kgr3Vqe4Ag9FL3q2ZsMb1e/QxhVFwboOV8EhwG+Fr3lFHO+//3756aef5MQTTzQ7wW+++Uauv/56efLJJ+N2y3jkkUeMP9fBBx9sqk/JK/zkk0+MRxhENHIi54KffPLJhX6XCb8q2gwyIXmRAOQKhIU0RB0bFFew4fByJbNzI4RdR65z1bwCDKa1ZWN0pRp7J1JUvAhLGmmvh8GzphVFB2kqODzoGA8DxZFNNJX5Xp6v85o4sisdPHiwXHzxxXLqqaea3/Xr10/OPvtsef75580jFu666y7p0KFDod9RiXrffffJ999/L0cccUShvxEqgWRmGrZymFwIhRgVmR6fXBtFUVDdyX3ARsMPO3wMwocNGybt2rXTzZGIMQT+559/THqB3vNicuL22GMPY4judVN0wukIDhCBnj17eiKv2GtAWUMMoaJYFVox6jkbDdZ5vxHHvBndhJsZjISMLVAKDz/8cFP1Fi+pOpI0Am5+wECPdRNk0m+NiYiJUyuHd4IdPQuqF8NVXgCpFlR5tmrVSvwAlBkqLqn+RkkOOlBff/vtN/Mz6MB/dPz48b4pOuG+YwNEalGsNSPoYBPA5sgv1zQbY6Z+/fq+LBrKm20tSaaoc5FhLyuLkxuXigmyLZOPVoQxevRooziyuyR8QmicRzyQl+csvU80WHguC0hOiCMt6kj23rgRGYRYjAg5GDVqYMwluQLkn9w93c1H32iwkSEMTOK1X7D33nub+4jiBzZ+Xg1Hun2tUId5sBFizrJ+rYxxFAhUR8a5TYFhwQ2KCmmLp5i769atK34BfqVcL46feVtVtcJgnDOu2SRq44YwGCdDhgwxc6CfxkvezEQQLfIUI2F/B3FLBe+88465kL169SqS3E++JKE1wqbkUT799NPm/QmTx8Lnn38ur7/+etKfzyLCjiRjvT4xYkblGTFCZORIkYkTw//mAWmMZdRMlS6T+R57kKwm0qUL2eEiLVqECWYGsd9++/m6v2cmwVihYMhvBtscN5ZBTJyQBTZ3/C6fQs8QCpLfIRTkeUES7XUizwnyDOnHpgjSSA4vLfTYANj7n7aRPIc8SB78nU2C10O4qcLaNRHO9GNPaI6bnDU/hh+zpToSGQnSRigRcSR6SfGXn/p6582VYzKOVplk1ZdU3P3Ja/zqq69MrmRk7tUDDzxQ6N+HHXaYXHfddfLBBx/I8ccfHzOMSggd4uMkhvfcc0/MY+Dv7MpcrbAkBPbttyKffioyeLCIbQMFEWzfPkwCIYT8G+WnfHkRbm4qYOlmAfmGWC5aFP75008iL7wQJpksYN27ixxzjMjRR4ffw0Ww0ELk/bQryxZQpnkw9vxIujhm7Dogj348ficgDGxi6dpjDY+pukVJhRASmrLkjwc5TjayccghhxhCSJoMyoyz8hwbIzqVMI9BIHlvSz4hWtjB8B6E/yHfflKdnYBQ4Ibh1zxmrh+OHFogEx2QI8QcJY1hMC9Yj0sljjkABAvmHgnbvitZAka+1YMPPihdunSRCy64IOHzWeiw6MECZezYsTGLZiioScV/jIHkSq4aCt1nn4m88YbId9+Fw8977y1y1lkiXbuG1ULIYrpYs0bkzz/DyuX334tcfrnIJZeIYJdD5fnZZ7MqFvtrUC2P2qs5n0XBDp5CkwMOOMC3YXyOmwdVl9xLqHB+WHyJOhBehuxw/Pw/xI57HcUMMmdVQQhdvHQZ5hLIpCXPzmsZ73WcJwglVmI2UsH589O9Aim2KqrfYaNcqqoVBeuw2k3thHVN4b51CkteR96Mam7WaCasNq8wGdJGKOnGG280BIVK62Rveqsysoi4AdQKQlzFmvj//lvklVdEnn0WGSSsJt59d1gRdDMEtMsuIn36hB833BD+3C+/FPn4Y5Hrrxe55ZYweYRQpqkiQIpQWPItLOcGGHMUDZGY71fS6ARRAybT4cOHG+XGSwbmFoxFlEX8XFF6mScgdoSkE3nGxgOvP+igg9JSLWxuKAQS8op9jZ3TGB/W1xNi6jUQpqMrDKkWXjL3Lg7I46PFJps5v3n0ZWPOmjBhghFn9NyIWecpiiPC4Jc53B9HmQTY3ZNbElmRiD2J/XuiGx0Db3bvDz30kNn9JgsmZje7mdjCGcJaKeOff8IEDtn71ltFDjggrAgOHy6CQXmm84ZYsM48MxwO53tcc43Ihx+GcyCPPZZyyZTfkgWaXapdDBWFq08Zq34Kc8QDpLFr164mkR4fVSyYvAZIzvz5881mlWPF9gvS5wVwnzBv2E0WxJtzSfEgdmUU9nnpnFJhyzFRBBMtR92v4LugOM6ePTvXh+I5EJpFHfdS+8hcE8eNGzf6qto8b4hj7969TY4URSjOMPXXX39tQr421MNgjaxoRpW85pprDNvHDDwWAWSnxGc4weTw9ttvm51TNFufdMDxoWKmQl5NJfQzz4jQ1omfELb580UGDBDp2FFyAirn7rwzrHhyHGPGiLRpE1YfU2jRxTXza/5eJoEqDakmH8wvO9VkgIKH+oQ6BnmMvOeyCe5vCjboLMX5BnQwQRlE5WVcunXumV/Ir3YrcgHw89xnn33M8VKljHrPIgX4mcsOPhQUjhw50pxDCqTy6f5m7FIcA3G06VKKneeGDY2fiFKmC4ZKlSrlK1uevAlVQw779OkjL730kgn1cjG+/fZbs7DegAK3A/fee6/JRaRK0YLiFlRDimGQ0HlYoEDa8BNmxW+88YaptCb0w86diZ6F5cILL3Rtx5xyRd7vv4ucc44I/X/PPRdHc9eLU4oFcloIV59yisjTT3MRwjmXDz8sQh5pnAWD0Bvn2a/J8pkEShK5bIz1fAMbMcgjZC0XBVGQVRZ9Qr38P/e7PY5Mdbqh2AUyl4nKeM4nKTjMK5agYYFE2L1FixZGsc42cUMtZ86E2ObTxseCKBeejhiDa7eUwkDIYd1krOfThiHdjTJzOOs+EQw/IG+II7jpppvMgBw0aJCZEJkoKXRhNxsPLA7g3XffLfI3XmuJoy3OgCxCTrngJHPfeeedhrS6AY6bnTgKakKwk4Uk3n9/OIdx7FiROK0Vcw7yq667Lkxyb7xR5KKL8CkK52LG8O8j9EYoUKupi4Lxh51LvoJrb/OHWXyZXLOVo0dol8/k/FL44sXcwHTgXKTbtGljLJDYSEOS2Xxns+MQOW62KCpfQ7KMHVUci4L7mrGHAq4pSGJ4BRs5vxDp0vm20FxyySXmEQtPPfVUkd851cd4QPWKtONxG+ROJZXfSK7gaaeJjB8fJo+oqn6p4CMB/uWXw7Y9550XDl+/+mr431HgV2uRTILKYwoJ2MzkO1h4USfYkXfv3j1jVZls2FC4IaicV4pJ8rmPNvZAqH18V3LByd088MADM1oJTBge5wrC/daKKJ+hkZLoIB0Mdc2LxW+5QP369eXXX3/1DZHOz62ej0GFIYntTOoxgQcjkjaFQH/8IXLzzf4hjU7QAxzj8R49wtXe991XyHicECEJ/ZoLI0Vycsn7DMLCazcOVFhjt0XOYzTbreIAskiu3e+//24K7Oxn5jNpdIJ0HKxAevToYUgjRB0i6XZuKdEUrh+qSpBsasgjZdNjc0sVYeUb1VEjSWHYDkms/36AEkePgZxMrDViytWEdQ85JOyTiHfiPvuIr0FoDOueO+4IE2ByNHeEdiBI1t9NsROEFdlYBKltFyQO8sjiC/lwq4MQ9xseoez0MSHPZY4R3xFFNVeE1X4uqiAKL5EYUnLcAPcxxBxCTu5qkGxYIOCTJk3yVfFDNsCYYMOG72nQUalSJePMwHzkByhx9BjYcUQlBChxN90ULibhgVeiRyxAig1I8u23i7z1Fr0eRfr1M8biqGqQRvVv3AmIE+cln3MbYwGyDOlgPLiVF0ceI6EhCt5yXWSECueFrhqkQHA+OI6hQ4eaXLTiFOyguEH2UZe4fkFLPYEk2+IHv7UEzfR5YS7TiFIYCEaqOCpSBh6UVBBbM98CMNngwUgRzCOPhE298zHUc/rpIj/8ELbtOeQQWTF7dswWjkEFeXiQplyTnFyBnChsrzgH3Cvp2MngIYfCCFAYKX7zQjcLNgW0D/RCSBNyTvia4j8KhYpjEcS1ohAHxThfioyC4NWXDeJImoT6OYaBYKSKoyJl2N1GEcWR7iuPPbbTn9EHVVdpg3zH77+X0OTJ0pYq+Xi5ngEEtikUMAQp1BdPxRo1alRK5JEwP10aCMWCXKt7kbmWODzw0wuA8FHc0bdvX0PYUcss4U4G5Eqi6AI2gEHJyY0Gzh8PDVcXBi4obIZz6SfqFdSuXdvkAXvJoD8WlDh6CLZDSqEevRBGikZQGi+9NFsHIoKXJTmUv/4aLsAZN45VlxU785/fubOU+PZbqT53rtSiQt7lYgi/gqIQFu+ghfpikRqssmgzSueRRCFA/o4/K7lmVBG7ZdYfBFiVkMIhvGwt6Y4HW8gEEfaCguoFQMKDGimIBeyfyAF1K5fWz6izQzDyg+rone22wiiOhQpjvvkmHKLGagelMRNAQRg1SmTkyDBR5OeOFopRgQLYqZMhd+aBf2S9eu6roN26SYlPPhE57DCR//1P5NFHJejAxoSdOf53ivCig60LCfZ4EcbrPsLfaStKt5e0WnkqjNqNGkIPZtJqWrduHfV8U7hEr3GKHyj2CWp4OhK2e5liJygIYROneexiFGlUeXgAKSJehhJHD4GdRkFPbdQ9fBoPPzysOLoJVMNvv8XUUmTQoPDvKLSBCNJnmp/YAxBaIveLClYq3yCZo0eHCSZFLA89FH4tXRGuuELkP/+hPMyVQ0StaNC2rdSGMP73v2GCevLJElQQvmR8sFgrCi/GVEOjJkJUYlUkU0wE8cmmwXW+AZKISTjnmPMNeYS4Oy1VUI/wGIVgktPolR7eXgHnhW4y5Hz6weg50+AccF8qxJwLhCNVHBUpEQPsZ/BSk/XrRY47ToQWhm++SVzOnQ8hd+L118Nt/2bMCFv5vPSSSM+eIuxwkvmcgw/e+f/kZA4fHj5Gwuh0gzn//PD/F6PqFwJACNK0XYSQQlQxCoc0YRYeQGAMr5NsbA80cujIV3R2XmCRprADJbJQ+odHQQoCaqjXUxEo9MDtgAUu0oePc49qQhtDTJ4VhQGxhjiy4dHCvzCUTO8ExHHq1KnidWiOo0dgdxmmovrqq8N9p/E3dGPyRTFEtSS/5qqrRMjvGjYsHJbG2ofuBumQU3IyMO7+6CN8TcLvhc9k48bhCukVK9I6XAg0MA76TCSQWzqknHgipacSNECGsPKAIAW9KCYWLGkkbM3Ey2KEbyA/3TayzhQgXITS/VBEgnJLn3R7v5LHSGI/uaeEHv3Q/SIXgEyjwmqRTOF8WIhjcSr38ynPcdWqVZ7PC1bi6BHY3XutyZNFXnxR5OGH3ek7TR9uFMVbbw2rgXPnirz/vkj37u7mJaIwErqm8wbV34TCWVjI00zDLoXJtYAkEX6kjzjk9N57JWhgEoEUofQoYgO1Ag/C8ePHy8CBA02hGeFSv5BtCK6fiC4g55bipDfffNMYqbtlzJ7P4D7Ggsbr5CCbZJoNhxUMgozaO6z4vB6uVuLoJePvatWk1MUXh0kdP4sDqkxR6tq3F8Eni37cVGhnOtQJyePYaSXIZ1Pcwr9pj5gkmEAwQi4EwtQYoNMrnIrvAAEF6oADDlAVJwkQyifVgfuJcKDXw75OoNhBvvjpJ7JO2Jrz7XYryHwFldUQJdJPFGGHBFJJEAyCjpo1a5roideNwJU4egTsQHtA7lAEX365eHmNWBscdZTIRReJnHoqJaUi++0nWQVh7K+/FnnuOZH/+79weBxLnyRAuC6qukYOJbmYhMR9pMoUByzGFCEEPfcnWUAUe/bsKYcffrjJb9TFKLOgwppzfOKJJ5rqaVIF1JMvPlDA99lnH6mHG4XCgE2xKo5iSDQbXq+bomtxjAdAGHLLrFnS9NNPw+SoVav034yFkgIWwrqffRYmkLkCZAe18YADRE45RaR3b5HvvgtXbcdBEbXRggpvSPX++4dD12ecIfkOvPMmT54s/fr185RZtdcAWSE3iLGDT6MN+3hVpQ1t3izbN2+W0KZN4cfWrbJ59WrZsnSpbJ43TzbvuquUKFtWSpQrJyV3/CzhsetPqHXRokUFFkcUe5AmQO/hXPXb9gvUmqdobh+EmvvYrXaiflYdV3qcRHtrJgooUJS6DR4s2+nBe9116b8Rg61vX5GFC0WGDAmHir0Aim9++knk0ENFDjwwbAHUrVvUp9p+rjHz+VBOIcN33hkmox5bTN0GLcogP0oa4wN7GHwa6XJi2wfaxRlyAyguyhVJ3LZmjXls5+fadRKKEtbdtG6dbF2yVDbNnSebKhddOEqUKyuldtlFSlWpIiX5ucsuOSOT3KMojKRQ2BxSSHvv3r1VHU8SKOLktduNTpBhO+soxMz3GOd7GcGm9h7BP2PGSIexY2UD1jPpGqFi4XPEEd4jjRZMChBGCn7Ie5wyJerTyPuhBVVc3HVXuOjnjTckn0GRBOdC1Yn4YLPBgyrfaD2nId8UcGQz4Xz7xo2yef58WT96tKwbNkw2jJ8gm+fOk61/r4pKGi1KxFFbQps2y9blK2TT7DmyYew4WTd0qGwYP162LFpkyGm2wKKGwTfqUGThEaSRVoN0mNE0gcSCAeNWEQbjBRu2oKNGjRpmbHi5eEqJowdQ/uGHZX3FilIeq5x0QCUj6tv48eG8Qq96HdJ15osvwrZAhxwSJrkRKgaWDAl3nu3aiZxwQphAZnHBzDZsD1f1e4sNWpWhNmLwHStnjFAqYes///wzowtTaPt22bJkiawfNUr+/e132TRjpmxb/Y9I/G6IBahaubIc0q2b+ZkUtodk64qVsnHqtDA5HTtWtqZpgZUsaDc4ZcoUU8wQK6QImYRA0kfcy4tfrsGGkCp6QvsK0vvnyrRp0yToqL4jvcbLGy8ljrnGqlVS7ZtvZDQhn3Sl+scfF/nqK5GBAxPmD+Yc+FJi1UMC/dlnh6u/d4BqWOw8kgpZ3HabCF5o5HHmKVBuWKC1HVds4NnIeInXUQcSQ3cZcoco3nB7QiZXERUQsrhx8hTZtmatZB0hMWomyua/f/whmxcsMHmTbgJ1jGKYxo0bm77L8c43xR+WPGqxTHQwHjlHXi+EyBa4jxEOEvWdz3dUV+KoSIgvvpBQiRKy2NmRJRVQBAOJuvLKcA6hH4DiSJHLDz8UCjf/888/5mdSxBGPSPIdsRzKU6Cg7U8hkCImaHnXuXPnhAn1/J3nYteDfYwbgJhBGNf//rtsnju32OHidRs2yLDx48zP4mD7+g2yafoM+feP4bJl4UJXFmIWdHqlo+zSdjARSBngfHNPo1AqoiuzkARSKRTheZ/0HMK0QUb58uVNcZmXC2SUOOYan3wiszp0kEr166f+WhYELHcwDb37bvEVCFVTFU2XnB0TJzdLs2bNkvfeu/DCMPmEPOehDY/64sUGiy0LDEVD0fIao4FChLZt25qJGTU33U4VxgVh0SJDzAxh3OaOosaiuWbdv64ZgENkN06bLuuHjyh2CBtDfgg6beGSBWo5SnAVUlQUUUFrRuY8xU7BwAoIQUb16tVVcVTEwV9/yfC2bWNb0MQD/oiDB4u88ELYeNstEFpCJfj8c5EPPjDk1vSkdjtfCUNyKjD/+9+CiSNeCKwIaEFI6Bv1Ms9AS7IffvhBw3wx+rpT7FKcykNCrrYlYSrYvn69bBg92uQVZrMgpTgwxzx+gmyYMDHlY4agU60OyBNNtWIahRKrnmyBsO8nn3wir7zyivnp9TAwBEF7eu9UYLHliex/HkRU9zhxVI+PHCNUt67MqltXOqfqN8eEiFr3n/+I9OtX/APZtCncihAySg/raAsq1h9URR97bFjtK27RRq1aIk88Ef4Op58uC9q1M3k/KEJJgZ6+J58cJrf33+9uC8UcgwWPcxF0T7NYpA8C07Jly7Tfgwrs3377zZDH/fbbLynfQcK+m2bOdE1hzDa2Ll8u/675R8q3aCGlk9ioUpxFTijFWXQ7KQ7wd6QDUlMM/DMEKrlpfcjYQBXm56BBg+TMM8+U7nTj8ijIHSW3W215wqknCjFCEnZNXoWuSjnGem6UEiVSNyp+9tlwNTWqXXHAe9BjGlXgrLPCHWto7UcIGP87utBQiQqZfOopERbr++4LP/+888J/Kw5OP90Yg2+/804ZM2aMqZJNCUceSamnSB5V4xGixsxaq6mLAksdfBkJmRannSDqRrdu3cxPyGO8ylbsc7C9IezrV9LotPTZMG68bJw+PW7uI2rHiBEjzAJGoUtxwbWaPn16xtopstGCNPKdUOmdP9944w1P5xESmqVaXRFOA0k1CpCPqF69uikW9aorgRLHHGNVq1ZmZ5wScYTsvfqqyGmnUZqX/odPnx7uwkK3muOOC4env/9e5H//CxuJ0zaQvBM+A4JLF5i33sJsMWyFQ0UzRSpffpn+MaASXn65lBw5UqrMmZO6CWyfPmQTh6vK8wRYxjCBKnEsDM4JhRbYmBRXAQPkRu67775G1YWoR8P2DRtk/Z+jje1NplGxfHlp36yZ+ZlpbFmwUDaOGxfVUxIig08jIdRkCo+SAUojiiMFNpmomkU9jhVG5/eokV4F4xmSoIQpnBpBv/agWxRV93hltRLHHGNx3bom8TylziDffBNWAwkXpwsURfpHU7nFpPr882RqJ/dawlzXX0/MUAQ1AtXvjjsKWeukhCOPlK01a0rDH34wi0tKoEIW8phHxJFJk0U75XOR54AAdO3a1RS4uAXSIuh2YrvKOAtTtv3zj6wf9afJEcwGypQuLXVq1jQ/swHse9aPHmPIceQ5IdesS5curuWb8T74abIQ2k4+boIK1FiElN97uUIVVZfz42VVNFtgLQTpFq7lG3Fc6dFxq8Qxx1i9fn3qYWosaCBsHTum96G0/6PLTK9eImPGxGz/lxBUc6M23nNPuAUgP9NBmTKy8qijZA863qSzSFOhPXRoOE8zD4BPntrwFA3fQ+qw0kk6BzZJWEWNYpuhQ4eazyIfcP2YMXG7vLiNTZs3y5xFi8zPbGH7v/8aRXXbunWmSp3CI5TY9u3bu97mEoJEgU0m7FZ473iKY1rFh1kCpJF8Zq8X8mQD3Nvcj2rJU97kXaviqIgKQhQphWcXLAh3h0lXbZw7V+SYY8Ihaqqli2suzWR9881hOyD8JCmwSQPrTjlFSpP/9OGHqb+YMDoL/KRJ4nfYvCzt91sY5Mf9/PPPGTUHJmRITtGwb7+VtXRh2p5dI+KNmzfL1Llzzc9sgkrrlb//Ib8OHmyKWDJd/JAJ+xmKX+IpjhRAeRlNmjTR4pgdJB/CFHTiaNVXr6YvKHHMMbhBUuoM8t57JGeJnHpq6h/GxNq/PyNS5KOPwu/jFiCPJ50kctlllGOm/PLGBx0UzqskhzJV0IIQooV66nMsXrxYvvnmG1NlqQgDMkc7MvIaM0mo8Rvs1KKF/D1lioyaNNk1P0WvA6I6fNw42TZnrrRu3Dijn8X1Y3NEJbGbVlOQfqqneX8UK+dPfu/1fGGiTqixCrSMyuphK+Hz4FXiqHY8HshnS4k4Ut2MwpaOqe7bb4sMGhQOL6fb3jAWWNBt1TU9t998MzVD5S1bpGzv3iKPPhomuKkQBKxU8H/MA+JIYQKhQrfDhH4GIWTCeZlWZLatXSvl5s2TTs1byIjJk2TWwoXSLIsehLkAYfHhkyaae7Bzs2YSmjpVtnfqJCWLUbGezGbZFsnstdderqqOKHcUwpAbRngapdHrpNGCzREqU8qpS3kG264y6KhSpYpn0xdUccwxUDVSIo6QI4paUgVkjDxEqqcPP1wygt13F3nggbBqmII5M7sq/NbW4vGGHQ89qFNF+/Yi48ZJPhDHlCvL83xjhRk6eZ9Y52QKpsvKhAkS2rpNqlWpIt1at5HGLlRuex2r162T7dtD0qVVK6lQrpxs37hJNk4ME8lMLogUI5F+4LbBPSTx2GOPlfPPP9/89AtpBLNnzzYRh6BDSWMY8IJM2VcVF0ocPYCkW3IhW2MKmk5RDAUxkLkdXVoyBsy86YTwyitJv8Tms5SzRTrpKIcNGoTzP30OJY6FQbEGhQMNGzbM2GdAkjZOnmxIk0XVypWNyrnm339l4qxZGSVSFqVLlZJa1auZn5mGJWy7V68uPdu3l0qOCv5tq/+RzcXoypMM6BBFCkImKqz9Cu57bbcXrqgePHhw4PMcKytxVMRD0oqjVdTSURzxfcRuJ9PVuixAkMcBA8J+k0mAmwM1qSxhK1TLdIgj+UFLlqRvCeQRdY2QvbWkULAH2dVY8GQydL959mxjTRMNGzdtkvnLlsl4OsZkeGxB3jq1aFmIxGUCW7dtk+GTJskM/Fh3VPVGYvP8BbIlg2Ey5jw2BKjJisLEMRubFC+DtYCiUa+SpmyBe4SIpBdNwJU4+ok4QqgoaInTaq3fwH5y89Cbi/7h559Fjj46tdxB1E3MwSnE4WeCFkjPjX1O9v6/vcMtCfEkw2A8CTBJFLR8gxSnQxwxK+cGi/D/WrhuoTmmT2d+Kl4Hvo2HHHKIWVAVYky5M21HsXXVKtk876+Yf9+tenVp37SpLFqxQibNnp1xFXDzli0Z7U/OQvTn1Kmydv16qVWtWtznbiLfMYOLFqbgmVSS/UgcKYpjPgwy1JKnMC/wohm6ZuDnGCgpybZOmz5/jLxwdROZ+NnhsnLDStm13K7SaNdG0rtebzm95emxX0hbQMK4qYS4UQzPPz9MNG2xCq0JUS7PPjtxviGAALZqlfCjmCj/2PiHrJy5Uo6BFKdj5m0rEskR8nGoN5N5fH7DtGnTDNHJlJVKaPt22ZREq0pMubdt3y4TZs405tzNXSzocAIy99v48dK9bVsTKncbENLR06fL6nVrpXPLVrJrgs+gvSLnpwKuBRmAbpCKEsd69epJ0KGWPIVT2Ly4kVDFMcfA0DiZZOCxy8bKKS1HybTdS8rxTY+Xm7reJMc1O05Kligpb095u+B5Xxz7hdzR/Y7oIW5L6BIBZRHSiPKBJYnzJ/2pE+U/oWSQczh2bFIfR8/gYf8Ok89mfhaukE5H5SCvEvi44wAeel5ubJ9NsGjQerF+BquaN8+ZI9vXJ7eb33O33aRN48YJVTovY/aiRbLyn39kn+YtpHqS6RBbV/6d0ZA14cixY8dmVGX1CxAQMF4viL4EfF30otKWTVTaMQ68eB5UcfTADZIMXhr/klTZWkre/bKy7HLlRYX+hvpoUbZUFPXShvuS9Ql77bXYIW1+j+p4//3x34PPitH/t+hblthJnukKkg5xtDlwPvY/xHphzz33zPVheAL4/KG+2laAboNOKZv/ih2ijoZ65N/uUO6Wr15tCkv8hEZ160qNqlVN1Xgq2DR9hpSuVk1KZMiiZ/78+VKrVi1X+o/nQzEYClM1H29Q3ECLFi1c6ZHu941EuXLlVHFUFEWy/Yjnr50vjdeWk122FQ1l1qhQI2aOI7l9e2+4W0Y3rSj3T3hCer7XU7q/013u/P1O2bJti6zZvEZu+vUm6f5ud/N4bNRjEpo7p6DIZGSLSrL3623MTwN+P3du4txBEu63bJFPZnwi5w06T3q930s6vtlRjv70aHl/6s7uMhSD9Hq7l8xcPVNGLR0le+/5nuz90G5yzrfnFDyHY3xwxINy4IcHmvc47OPD5NUJr8r2kEOlKFlS1lQsKTcvGSD7vrOv+Y6ch7WbvWmgGonN2MFs3KgV1TuwYMECQyTc6pUcCVM1nGYNwtK//5bRU6ea9oBeB4UWU+bOkX/WrTMLcaqk0bzHli0pk+xU8rjwLeR6K0TmzJkjI/HqDTgoEEzJpi5PUblyZU+G7FVx9IniWLdyXRlX9S+ZUamENE3jc+4/o47U+GeeXNL+Ehm/fLwMnD5QqpStIuOWjZPalWrLlR2ulF8X/ioDJg2QJm3by1EfxlEcCUMnArukChXkg2kfSONdG5s8zFIlSsnPC36We4bfI9tlu5za4lRDlg4rf5gM2jpIKperLBfMqiXy449S4+ULzNts2LrBkMhl65fJic1ONMc6bvk4eXL0k7Jiwwq5ocsNBYvbFVfsJWPWDpcTm58kjao2kh//+jF6oZAHYW04lDiGFT1C1Jny4Nu2enXMKupkQM4jNj20ByxVqqTU3927HT+mzJ0r8xYvlqqVKhcrb3LLwoVSpl49Kelmt6kdqFOnjkyZMsXks2Zqo+AXcP+jOjIvut2T3U9gPkSJbt26daB9HStXrqyhakX6xPGs1mfJJQt/kxOPWydtvj5DOu7eUbrV7iad63SWMiUTF1TUWLNVnq98lpRo0VNOaXGK/LX2L3l94uuGjN26763mOSc0O0H6fdRPPmmxRY6KZQnB78lzjAfyIamoPu00GXDIZVK+9M4J8LSWp0n/7/vLG5PeKCCOrcq2kt9K/ibVy1eXI1fuLjK1pEjd7ub5PA+19cMjP5S9dgkXJZzU/CSpVaGWvD7pdXNeIJNDVvwhf7aoJFfXPknO6XaLed7JzU+WcwedK36ZKCmUSnY85DNQxvD5yxQ2zZ5T7PegQIaCmUmzZkupkqVkj1q1iv2eu1SqJAd17SqlXArRTZs3z5DG1o0bSd1iHh+FMpvnzZPyGegzzQZh0qRJsmLFCtM6MMiwG0e8DINMHCFLqK9U3hOuDXKBzN8ZdpZIBxqqzjGSnRy61+0ub83vKb2nbJbpq6bLgIkD5KIfLjLh2yF/DUn4+mN/WyclHMUqe9fcW0ISkuOaHlfwOxbA1jVay4JtK8N5jCxgdhGz/8/vmzSJ/2EUeCCvd+hQiDQSNl61cZV0qt1JFqxbYP7N7hoU7CrxYnTkjn037ztDkncpu4t5rX10q9tNtoW2mfA2+HXZH1J6a8iQRef3gaj6AagunTt3DvTu2gKlIVPhGex3UBzdQMsGDWTP3Xc3YWA3wLXH/NuNMUC7xNkLF0qLBg1cU0S3LFok23fcr26rKu3atVO1fYeQgOrq1R7F2YIli3Z9CPJ42OhBH0dVHH1kv9KmRW954qTnZMuShTKt1N8y+K/B8ubkN+Xqn6+WgUcONCHhWKhTo4HIb7+JXHGF+TdharB7pcI7/MplK8uaTWvCljuYhb/7oIj8IXLKySKn3pCYNAI+B7RvL2OWjZFnxz5rwuOEnZ1Yt3mdmRhQ2kpsL7HTwode3Dvw15q/DFHu+X7PqB/194bwbmzxhqVS858tUnGPwmH0BrskEVb3SAWdVlOGc17pY9y2bduMnI8tLubSQfDaNGpUQPS2bN1q7HrSxb8bNsikOXOkdcOGxTYBpwgG0tjQzeKi7SETsi6XgZ7hmaye96PpfdA3kFZQCTpxLFu2rJkTvQYljn7y7dvRMabMuInS5uCDpU3NNiZ8e+uwW+W7ud/Jxe0vjvnSUgf0FbnxyXCFtUPRI+8wEiiRBpDECy4UGfRH+GftnaQxrn0GHpB9+8r8Muvl/K/Pl4ZVG8q1na41IWXC6uRSQnjJcyRMZQqEyAfnPSdNErnggp2fE9ou+9bZV85ps7NYJioxZIIpWYoTKn4EfWpJCA+6t92yZctMQUcm8htRy7auWOHqe9oF/u81a2TUlCnSsXlzqWmtodLo6LKS/EtSPdLE8lWrDGnEozGRT2M62LJ4sZRt2NB1YkNxGFZUe+21V+CLIrp3D6fpBBlWcfSi2pZNKHFUFJ84stOnKnL0aJGDDza/IrQMlm9YHv+1RxwhcsPjIm+8kVK/akLEtrLZiUX/xqkoHTpU5P335acFP8nm7Zvl6QOeljqV6xT8eeSSkYVyOAp6dVNQw03iaKlYr0o9Wb91vexbd9+4x1lnTQkZXqOUrN+yXiqW2ZknOHfNXPEDZs6cKQ0aNFDiuGyZIdCZyO/aijl8hrq5QdKq7bKL/DltqjHXTtYn0U0sWLbMmJTjN2mtg9xGaNNm2bZihZR2IafTCaIOtB/kugedOCrCec6NGjUKfBSmbNmyppuQ16A5jj4hjiMWj5AQu3xMvB0t+VDvkgrJVqsuctJJIg8+KJJCjhfV3KiSfy79s9Dv35+201KnALaghvZ/Rx9tzMnNrx2rNXmNTgufhQsXmqT4iqUrytp1K8JV223bFvy9X4N+pop62MJhRT4OMrt1e/im6jHxX9laqvBxbdu+Td6Z8o54HShshGSCnAxvsXr1aqlRY6e9lNtqWSYXuo7NmsmulasY5XF1lvvsLlq+XCbMmmUIY6ZIYybPI+ePEC3XP+iYOnWq/PLLLxJ0UFGNVVOQUdajxFEVR58Qx/tH3G9yBPseUVkajhwrW6a+a7rJDJo7SPaovIcc0/SYxG8CaaQF4PXXi1ySXBcZciEP3utgeXfKu1JCShgFEEudvzdGqfSaMiX885lnTE9tCnoITV/242Wmehs18KMZH5nqaauQorQxObSs0VI+WD5eXjynhdRf9ot5Ttc6XeXsNmfLkPlD5LLBl8nRTY6WVjVamfNA3uP3876XQccPkmrldpXeX0yWDvu1lydGP2E8Jsn3HDxvsKzbkt0FPB3YPJ4gVw9aoLhiBu02tq1ZI9s3ZDbsRVHDPi1aGOI4afYs2a9tZlr1RfOVHDdzptStWVNaZyD/MBJb//5bQlu3Soli5HNGA8UxmOAHHYwjL1qwZBt0FQJBVqDLZsh0v7hQxTHHIESTDK7pdI10qd1Ffq27UR7uW0oeHvGQTFwx0VQRv33Y2wUh5bigMwPk8eWXd5K8KNiyfYu8MO6Fgn/f2PVG6VO/j3w4/UN5eszTUqdSHbl3v3sLv2juXJGvvw7//3HhSm1yGx/r/ZghnI+OetS8HssfZ1/tr/7+Sj5e8rH0b3W+9Ji6SQbsV1au/+X6gs+vULqCvH7I64ZAEuJ+YMQDxvyboplL219qinn47JKrVsvTdS6RwxseLl/N/kqeHv207FZxN7l3/4jj9CCUOO7E3nvvnRFLlq0rdnZXyiRK7yCPHZu3SPm1FcqVk1aNGpmfqWD12rVSu0YNadukSXaKKraHDHl0G6QoUE3vRYUlmyDyQM5n0NswTp482fh7BhnlPLomlAgRJ1NkHdOmTZMLLrhAnnnmGVNBmjSYVDHgJmfxhZ3kLmkwGZ1yisgXX4h8+aUpYokEpI1KaIhZ/3b9E7/nwoUiBxwQ9m+kojrJwgb7OafUO0VuXt1S5PjjadgMe0jtO338cfi1dPIgTO7DnTXKa8uWLT07UWQD1oInE3lN60eOlG1rs6s+b96yRcbPmikt92pQ7CrpaHBWcTONZ7MSt0yd2lK+ZUtX35PWaqSukOubUu53Hub5Dh8+XA488MCkO4vlI/78809DoPfdN35+ez5j3rx58tRTT5luQi+//HJG/W1TgSqOOUbKEyQLBQbcb78N40j9A/FipECmd+8w+UR9jNg7QBYhjZA6p/IYFX/8IdKjB46tIoMGpUwaD6p4kJza4FSRl14S6dYtddIIyAeix7MPSaMNxbRv3z7QpBFAnkeNCvtyuontmzdnnTRaMofFzojJk2VDErYiEMGFy5ebn4mwau1a+Wn0aFm5o+NQtu1btq78OyOedRg+B5k0ArWi2RmNo5tQkFFWQ9WKaCiJ4XWqgDiizrz3XnofysT06aciZ5whcuGFIkcdFVYNUyGPEMXbbhPZbz8RctIgb41j+0jGUjQhjbusXCny3XfhY0kHhMgPO0z8CiwnvNjIPhfdczJhAr1tVfrtBYuDcmXLStfWbQypGzF5kmzcvDnu89dv3CjjZ8wwP+MBw3HyKKtUrJgRy51kEIKMr3PfpJ3iGBS3IIONZK9evXa6TQSYOAY9baGsEkdFTOuaVIFZ7qGHhlW6dIG6hdr42WciI0aEw9+nny7y++/hkHM08ogyOXu2yE03idSrJ3LffSJ33CEybFhy/aujhMHpllKTY2CSpOo7VdClhsfhh4tfgX8doYigg5A9eW5uY3sOu3CUL1tWurRqJdu2bZeRkycXO29t7fr1MnLKFKlUvrx0atkyp72dt69z/7zOnTvXpPEEGVSYcx8EvW83pEnPQVnxIrSqOteAdKWDSy4Jh5pRDo9JoqI6FlAbe/UKm3Y//bTIO++QZCbSsSN+CNKf3sk1Gsiz8qzIQw9J/3fmkMUucu65IpddlrTKGI00EsrbPHeulH3mGSlx1lnhz01HbeTmIsfSpyAkFfQwNSa3hKUyYUm0PcvWOJGoWL68dG3d2oSXIQXFwaTZsw0Z7dyqlSnEySUMIa/tTjtDC64/9lxBB5Y8kMe6bnb+8RlIW+ARZJRV4qiIiuHDRQjVpupdR2gWle3SS0X69MHLIv1j4LWYgl9+eZjIckyokKiPGzdKfwbvQVXkWTzHj7pS+h92d1ghTAHRCm4Iz645/XTZvWxZKYFymQ4++CBMGn1s2QBxJL8ryCAkRSFAJohjLvIbI0FxjC2QIY9x9+rV0yJ+7Zs1k5IlShSrtaGXzysbqKDn9gHC9RSGBJk4KsSz+b4pzz7XXXddyh9Cjs9DDz2U8usCAcK/b76ZUjcXA5Lhn3vOqILyv/+JPP988Y+Fhaxnz/AjAobq7SB/MrtFctXWiaq0P/lE6vz+u6wfMEAqpmP0SntCqrghjz4GC2W1atUkyIA0UkWaiTaDIQ+17Nq0ebNRDRcsWyqdWhQONfP/u1apUiQ8t3HHa+iLjdroFWz/133iyMaBcD4KtF00qbYfM2aMIVL8jkKyyPw/VEqsW9iAsN7QshKXAv6fDeqPP/5Y6DWdOnXydFeSSAKdzDlYuXKl/PHHH4V8D/fff/+C8fTXX3+ZAjQiPfilYn1VXAU8k1iyZIlMnDhRDjjggILjTOY8zJ8/37RwdeaQ4xVMWpTfxkLJkiWLWPZxTjg3eH2SCxsrvSfe9S7uWEiZOI5AiUoRQW/YHheoZeQqXnllmAymmut4//1hpfC008LVzRmEJX2GPDr+nRZpXL1aKlx7rSzp0kWqnHBCegdEjiaFOUcfLX4G90eyfp6K1BDyWK9bCmbITRw5ZbL8OW2adGrRomDCrlyhguwb4SoA0RwxaZJs275dtnvMOS20ZauEtm2TEi6GzFHeWeRJW7DEcfz48aaHdb169WTx4sUyduxY6REx1/HcffbZx7we4vn777/LggULzGsA9xeLrF/AmHA65SVzDpyFNZGAMJE72rNnT0NKWcchD1gfeRV8f8gRY8HeI8mcB/5mrzv46aefZE9cN3bAb2OhRAQvqFOnjjRp0kSGxqmPiHe93RgLKa9W778fpdWcR8Au5NVXX5XvvvtO1q5dK40bN5bzzz/f7DQSYfny5cZTkSIFJp4OHTrI5ZdfHjVU8OWXX8p7771nWD9dLk444QQ5Hh/BdIBZ9n/+Ew4R779/6q+/+OJwXuIFF4R7WGc45JkKeYzrB0n3mn//lQn9+0uPdEgTVd3YCvG9PaTCpIM+pBoEHBRFoBKgLrhd/es10McatZEilzHTp0sHws9RdvvY8vCcrdu2mRzJVI3Bs4HQpk1SwsU5h6r6/XBq2AFUNyqtu2HVtWPRnDBhglGenCqRsxrfFpf42akAsmCtaJI9B/EAycJY3+ZSQxIoyvMycbRKqd1EpHMeVq1aZV6XiaYCuSKOybRkjXe93RgLKa/YtV1OhnYT999/v9ldnHjiiWaH8c0338j1118vTz75ZFyTbSaYK6+80gzAM844w+xIPvjgA0McX3vttUKT0meffSaPPvqo2bGcfPLJZgfE+yOHn05Vcqro1IksYJHHHkuPOHJzvfKKCOT41FNFPvoo7PWYY/IYlzQ+9ZRRC9c98ohsrFkzvYP4v/8L99w+//z0Xq/wFFAWMtGLYPsm7xFHUKNqVdmneXOZs3ixURJL7rDZ+W38eOnetq3sUqmSqcImTA1pzISBuGvE3OXNKuOABwSQeZUFzrl4ktbAeIlFFiAKLI5dunQp+B0h7F9//dW8L2sYRRdejoRBimwFfirngLWMPtc8F9XNkgGe6zQTt6/3Muz3tfNCOmMBJQ0u4NyY+W0slEjj2OJdbzfGQsoM48ILLzQSJ7vChg0bipfaEw0ePFguvvhiORUCJSL9+vWTs88+W55//nnziIVPP/3UhDVefPFFkxcDunbtal6Lwsp3thPSK6+8Ypzs7777bvO7I4880tzgb7zxhhx11FGpe28xKG6+WeTss8OKIdXMqYL+0wMHcjDhausXX0w97O0ieYxLGslHJJ/z2mulytVXy6HbtqVuuUD48Z57wkQ5D6ruCDnY8EtQwWSeiXC9FxVHi1rVqpkHgCA6iTOLxV516hivRh5eBebqbtd2f/3119KmTRtzT6Qzjgi9EcrbddddC/ImDzroIEM6yJ2kI8msWbPMc7yKPWgPmyIQOMgTRp2DZNF9hqrcoBbYoFQuWrTI5Hla+HEslPAgqU05MxbyROubc845xxC0Z599VsaNG5cRtSAV/Pzzz4aAQN4sGByHH364TJo0SZYuXRrztaiULVq0KCCNgEmrY8eOMmTIkILfjR492pgUHxNhf3Pssccaxk5eTVpAqaSVEIba6QJfR5RH8v6wyclCn9NoJuFxSeOHH4a/K/mYDz5YkNuX8o1BTijG6bffLvkA0iqYxIIMNl+ZSNQPbd3iiwUOpXHqvLnmPCzGZQHyUKuWUR49jQwZNFu1jYWeNce5vkQqJjsPZaspDkFFatSoUcHvGVc2LAepYoP2dwZ6bbvtaUpYNpVzwFxq80J5DYTRfs9IVSnWOfQSIMKEpa0lTSpjAUAaEXKcYo4fx0I6iHe93RgLKW/x/+///s9cEKTeYcOGycCBA+XDDz80OSXdu3c3SiQhgmz70hGjR5KOlKwtGaSCKFqeAxMUuVWHRek8wmvJeUT+J+mazwCQTCfoH8mAnD59uhx8MJ41RUHVH1Vvzh6UdoL4hy4w5Pydd56U+eknqdi7tzkuCEUkbNic10W2Y6p4+ulSZssW2XzhhbIB7zrC3ztUHCYVzg033Zo1a4q8LzcX34FwfaRbPzes3aFF5g2d0fgM8xOy+NL4l2TL9i1yfovzTUcYSDbJ2hD6DQMGyGbCyuR0PvkkbMl8FqEEKuMiLTggk7ZajOMtmCz4/HvukUqkFDRrZnbWka9louFG4PxwnlI6hxUrFuTT8N5O2HMY69pwvBx3tHPI8XBc0c4h/7bkmXMW69rwvEiCyXXh+vB5ttezBa+xk2ahc7gDfBe+U6rn0HltOA+RptbxziG/twUMznPI8XH8tudyvHNILnNkaCXW+N64Zq1sWbfOqHbmHG7cWKSlH5XKFK3w+8iuLeYc7lD81uw4PicoaDHje9Mm05vaCd6T9yZHkdaDRc7hjrlq/aZNUrtGDROanjBrlqxet07q1qxp/o4SSYFMoXNYurTxhjTnMEoeX9UdVbXrdhQWOMHreD3HGtkGEXsgQuLmHEaMJWDPId+F7wQ2/fOPlKlUKe4cwfmxlb7RxnfBHLFhQ8G15RryXN6T+5UcWIpmyCtnXPDgOXYcsvgzV1MhSkU1r7Xjm/+3GxN+Mo9bFwOvzhEUffB61lTA59liHwob7Dmw55P7nHPHsdq/sa6hXHKMhL4JYUOqOadU5pIrx2d4dY7gc/kM53szTqiarl+/vlEKI8+Dc44gCsn3t3/j/eyD97RjgfHHc+LNs/HGd8kE82zk+E52/rbnMB3FkesNP7Mewdw/VnmO97dkkVZsiA8hv48HJ/y3334z4TbUOfIKORgq3Kh2YuDbkEEmASmLljRqfxfLVJYLzcVM9FoGKp/BAIi0TmGgc4GdxDASn3/+ubz++utFfo+1AETc+Dg2aCB7XHKJdBw/3kzq3OiRIDQOmFhI/HWCgp49L7hAFv3zj0yAiNJH+uqruWCmiIfdGzd5tPclrM8NF02dbd26tdnBU0CEtB85wfbv2b+ANJaSUtJoWSP5ZVn4M3p36iRVbr9dpr/8svzVt29YccRCZ8drGT98j8gexTakAAi5FEwunMNVq6T7FVcIV2fOnDlmU+AE16pdu3YF+T6RNzkqtFNBdoJxy/heuHChORdOsPFgU8RNHu0cHnrooWZSImGbc+UEdgfkG3FuueZOMAHyuSDa+1IwwgSOKTDH5USzZs3MxoVziNriBK+xxSao4ZGTFiEcxjKf77SvABwrx8wEG3lMfEe+K2A8RC6QFKOxQLEp4JidYNLC/oJjcb4v15eJ3BJHohiR9xPXlGsLeeDvkfcqcw2vd77v5gULZNvKv6VPp06GxE2dN0+WRrxv0/r1pcmee8rfa9bI6IjjrVyxovRo3978/x8TJxYhEeQjQtRmL1wof0W0D21Qt460bNDQkLs/JkwoMmccuKNob/S0qfLv+g0y/a+/ZMKsmVKzatUCEjp/6RKZOX9B4XNYs6bxc2SOQKmMxKE7yMaEmTNldcS1adu0qVEyUTUnR1zzGrvuGu5ys3171Pft27mzlC1ZUqbMmyvL/w7PPaVXrpQyNWsknCNIbwKsE5Ekonfv3mbhZePNmIHUQAT5f0KI5KcTUeK+Yf7lc7jG3AtEfxhrzK+MYYgDxZHmePv2NfcrY4XPZVwxPpirbQGOV+cIPtdJLllTERsgOsyH9hww/7G+UpyJ9+P3339v7hu+J/e2ta1hjuDYXtrRbYxzQFSN53p1jkBxJVWM47ZKKuQLosOcz+u4753ngbFkSSXfB1GCvwGeS3odtk2cQzsWbIU26w3rDoSTfzuBWEQuJOdrZESXL8YunwsgZJEbAsY+9wDHzLE7wXXk3uH8RFZJsx6zLkcSR+oqGCMQP+Z8zjXXkHHOueK8Qry55vY92VDZ1I94f0sWJUIuxpj5IpxUDogvxGLGTciJYQBys2Yqj+uUU04x7/3www8X+j2kjL9ddtllclKUlnZcAIpp+vfvL6cRQnXgq6++kgcffNBUajNoHnjgAZNHyc0ZCSqrWcTvow1fkorjPffcI48//vjO/Io//5QyfftKxUcfle3//W/qiuOOXZzZtf/8c7j3MyTwvvuk9PnnS6XKlV1XHJnI35r1llEcy5QsU6A4nt3ibGMkXvnii6XU0qWy4YEHZDO9sR03AeODCZQJPnKHF1VxhCxQgXzLLVLp1lvT2gl7UXH84YcfTFoEk1pQFcdUzmFKiuOMmbKFkJWHFUfeF8K4ePkKqUgYadNGOahLV18ojuWbNpEydeu6qjhC/JhLISbJKDJuj28vzBEQGz6bfPpkzmE+zhEQYTwXKUR1Nkhwe45I5hzmUnG85ZZbDDkmRRDC5wW4mo3OSYAg8uDksXO0IW2KU1544QWTT5gJ2IsaCXuhYoXO7e+TeS0/YzVd57nxwvOweh6RYFAVVG2z88PP8ZZbpOQxx0hVR55OtNfFAjdOWdQ6VI5rrhG56ioRyO6rr0qJ2rULVYlHIp69Azd05Gsjcxrtv8sNGyr9r/tYhMrGQYOkQpMmEplFYW9sbqp4nVPMBMR553u0aWPOjw3Bc9PF6jbC+8b7rvHOIdcy1vVkonDzHHK/2GOJ977xzhGTYrzXxusBXZxzGK8YLJVzyA6f8WB/F+8cmvEdw4KJydb5vuWr7iKbHYsExCkWIFSWdEVDvHxDrHJi2eVAyOK9L32ny5QuI/u1a2fURAidfS+IZyzTb3MO47wvpDYWypYpYx4xz2G843W8b/mqVaWM43xHG99OxPsbiz6PI444wryPs1gqV+M7V3MEnxs5li2CNEdwnnjvaN/LrTkilXOYaHzvEucc2vGd6rXJdf1INGTMNp6Lg4x9ySWXyNtvv21yIy/Acy9DQIaOFiq2v4tG2uyFZoAl81o+g91VZIgY0slOIxl/pYSgWhhTa/IBI3a6KYNJjwrrL74waqbpK03VdURoIF0UKYRZuVL6f/uPXDp4ozxbY6q88PhJIr/+KhKjYi2l3A06D40dGy7+8WgbpnRBeMGrnQuyBRR5cpfcRgmPjxUURRZeQsSQtbHTpxfY0YybMUPmxynq8wJKZMBDlcU16Ib4EJRMtN/0Eyxh8mJVcdCR8t1JuDYeuMgsgphvE9u3CyJhh0yajRLuJQcm0gyUfAX791i7GvIMIvMs7GvJZbE7ENtwnefaEIL9N1K8Kw3ZIXsDBoigGFJlfe+9xX/PI46gT5HIs8+GWxPyoIgHdfOQQzgJxSONpfYPh8XfestUc/cn5F+3gTwrH4pMeiWmSTiknc1FwkVi8GCRW28Nt1Z0eLPlC8jBYbdJ8n9QYcNLfiA2bmHavHkyf9ky6dWhg1E7CZUvXrFCGjLnlC9vlMqJs2ZJqZIlpS6bSQ/C7fPLJpxcLebSeMpOvoP0LkUYQSeOIQ8qjikTR4pfkr3YTz/9tNxwww1Zae9DcirdXEiStj6OLER4grVq1aqgopqcRnIqnMmgHB8ejhBAWzFN0i5ElAIgC/LQIDuYgDuJI/9md+j8XbFAyJpWgjfcEDb2jrD/SQuoptjXQL6wxaGymQRw2hbic8Xn8OjQIb6h77Zt8sKP98qziz6US+fXl/5PvSwy+mJTgGNCyKjKtWrt6G29W1yTcJSFhJuJv/4igZVMd5G77pJ8BEnTjMcgE0fbm9cWx7iFEh7stgJmLlhgCmpaNGhgSGM0tGrY0BSqjJs502xwqbz2Gtw+v8zNpC047XQUwQRrKk4pKfv85hlC+UAc6ZISDyhvJO+S30hxCUbZlMRn2mATckjrNqrGqMbiM7/99ltTgQl5tbj33ntNRbKzCgwfRtoI8jwKaRiodI6hmox/Oxe38847zxS03HbbbQUVeyRzE4aPl9+QMq67jsbgImeeGf4ZYQGUNpjoKVKhupkq3PfeE6FK7OOPw8ba3KTsdiGC5GMQLiH/k3zEVavkhTrz5Nkjq8mlHy+T/jO3hxVAKrix2YkICybqMAOxJwHaWTVXCBwPrRxRkN99N3xseQiIUmTyeBAXCSZIFKdYuUn5ojjOXrRQZvz1l6nmRl2Mm+7TuLEZG2NnzJB9saaJk3OXC7idCmALMLJt5+Y1sEZxP+CUEVSQGxnk759XxJHy9mQAicMb8aKLLjIl9TfTHSXDuOmmmwwJGTRokKnyYtdKVXSiYyYUDSGmVzUdYGyvaiqxI62EIJmEVvlOFP3gGcbzqMx2FaguhKzpy0k4mV7WaXQTiPv+KKRWJYUcEs6GRGKNg33RDrJoekFXqCAv9K0ozzauJpfuerj0f+tm7uyEHxOPPKIuoOpi21TEsoliGNRe7C7Ik/Sg2uIW2KjEKroKCigGyEQnqpIeyxMjpxF7ncZ77mksgBIB8ti2SROpvnyZ58zAS5YvJyVcNm1X4hgGhWJubqD8CIQFNpJBz//e7kFRIaMZyOQ5YsET6bmWKTDZUIzDIxaeok9yFEAA70oyFIqXovVTzCggZt9+Gw4lk/NIRfpuu2Xms1AO2N3x2NFi0Ym4HWHSJI82BFGENFEUdM459B4jDwDjNMln2I4IQSeOtJnLhCJWskJ52b6hsOVHrkCF9P7t2kWt7sa+p0m9Pc1PJwhT19+9tvn/FatXm39XdzO6kSZKptpeNQmwmbQmzUEG84GrESwfAsNz0seiNecICrZt21bEDiqvq6otyFHIx5Y+WQO+l1jpoPyR57dsWdYPoTikMV57Qrs4FLox+P/zzhN5551wsU0AJg3M2YNcCGBBikmkp5sbKFnZfYKTKih6oWIa9SCWJRCksmm9+jHtd8CcxYtl1JQpprtMrlGykvthc/J8IztzBRHcB0FXXVkXgp7fuDkDBYO+II588aDvHouNZs1E6JlNpwG6Qkyb5ivSGIs82nFRoDiyGJIr+eab4YejMCmfQf5vpnOA/QCaBmTCkqdUldzmBS79+2+To0jYOV7hD6baKIrWXDsaOjRrZoy4aU8YzaQ7m8jEeSWvPBMpC34CmwtCtEEnjqwLQecOm4NKHAlTU6iiKCbYhdOqDzWCvMQMGalnijRGI48vT3zZLBRmcqCVHm3JfvyR/owiEV188n1nHdk1IIggNBetK4YXQ6rJAiI4Zvp02b16dZOrGI840pEFQhjZZcYJLHo6tWwpFcuXk5FTJpvuMLlCyQyEUglPBv1eYIyQ9036VJDBvKjEcbMEijiyaxowYIDpP8pNoIiOlPIXsKiAPHbsGPZhfOUVSq58QxqjkceJVSbK7qhMXbuGFVX6Z+7oExsUYD9Cay0v5rJkE7Z3udsoReFVyex7wUHq/pw2VWruWlXaN23qms0Q9j2dW7aSXSpVllw53JWsVElKuqyIoTBRLBf01CbGCcWCQVcc4RBKHDdLIAzAudh0USGplZwlchyj9YhWSMxWh3HBIoiX5uWXhz0TKZ554YWwT6MPSKOFed/t28MFM58ul/5164t8+mnYBihgsAsECfHx2l0FgTjOnj3b3BNR7ZnSRIlSpaR0tWqydWV2CQmtBFvs1UDq7babKWhxE7QL7Nyypfl/Qts84uVGuo3SNdz3HLX9g4Oe78u6uRCPzxYtAp3j17ZtWwk6NucLcUzWAJyJ/6CDDpJLL7000IthIqRlw8KiClk88ECRiy4S2XvvsHUPtj0uYHtoe0ZJo8GsWdL/0rdEdlsmazt1FHn/s3AYPoCwrcVIiA/yvQJhwHqD8+AmcQSlatTIGnEk93DT5s1Sq1o12at2uBo6k5gwa5as+XeddGvdpkhFdqbA+XQbqM0Q7Hj9oYMAzgPdpPAmVgQbm/OFOCYyAEdm58avV69e4H2oMqI4OnHCCSL77Sdy7rkihx4qgrJLx5lidl24pH1sO6NiY+1akYcfFnnkEZE6daTbGbdLSeyGAjxWnIpjkIHh7wF0TcoASteoIZtkhmQaa9evlxGTJ0vlChUMcUwFkKaKFcqnrE42r19f/pg40Xxu19atjRqZSZQoUzoc/s8AYWIMuK3O+rWiOuit9khbgEu40srXp9icL8QxWQNwRZYGRp06Yb/DN97AAT1cREMYm/Z/KS5cGQXK6muvhftvr14tctVV5ng3TZ4sJQNOmNhgsVgWaxORR3A7VA1KVqggpXatKttWu59DaUFRy4jJk0zIeJ80LGWolu7VoWPKr8Pep0vr1jJ80kRTMNOlVeuYbQzdQOnddssIqaEFaZAVdws2kEHPbwSrVq0qiMYEFZs9ShyDvbXzAFwhC0ziZ50lMmNGmJi9+KIIlhbXXCMyZ47kFOQtYbpOPhZhdYzMp08PK6NVqhT0KA46Dj30UKlP3/CAY8aMGfJThhwDyrDJyhA2bNpkFL8ypShcaZlR4hYNKJwUzKzfuEmW4/maQZTJUB5y8+bNpRnWYwGHEscw1MtSDHF0exPtBpQ45hiutppjt47SOHNmmKSR94g/4LHHinz3XbitYDZApff48SJXXokDfJjAduoUbmWIP6ODILGjzITps98Q9PCcBdWkjAdbKOG6UlamdMb6yVrlL908Q3Ijfxg5Mm1/RloS9urQQerWqlVwTJnwbiyVAXsjLHh0HgiDtrl1A1gkGLku4jIRdOK4adMmJY6KoshIeJKE/AcfxBRN5Pnnw0pkv37MSCJnninyySfM1O5+JlYy9NO+9loRclLatQt3f7niCpG5c0XefTdq60DaUvbEvzHgwIVgPGQ74KhRo4apJF26dKnr722qq7kHXMTmLVtky9athjSSX1icymaIHvNBcQifzW+ct2SJjJo61fU+t5lSG6dNmyYjRozIyHv7DUQeqBEIMmwUSkPVmz1JHINtkpTvOQwokPSdxrZnzJgwYeSB6kcojd7AXbqIdO5M8mq4vSFqRTz1i0UNNQjD7kmTRJjsR44U+fPPcOcXTGuPPlrkmWdE+vSh8iPuIXrxpsjVOCCnJ+hAeaUF47JlyzKSFF+2Xj3Zwth1QYyDMBKeLl+urHRqEbbG8QoIXU+ZO9eYj9Ntxg1Fu0S5slI6A1XiEGWud9A7xgCI/ooVK0zrxSB7GKI0durUKfD9ujd5VHEM7sj0CDZko/MDOZCYhvO4++5wjuHgwWHCh6E4RuJWmWCyIheMB6SPf/M3CO6KFWHCuH79zveGbEI+CZFTHd2tm0gK3mOEqCZPniytW7cOdGI8E+Rff/1lFo6gh60J1U2ZMiUjvWopkiHXccuixcV6H3wT6fKycfNmaefBqs8aVavKPs2by5/Tpsn4mTPNMRa3oKXsXnsZ1dZtsGFCaeW6Bx3r1q2T4cOHy3777WfIY1ABaa6TwZxkv+Dff/81RWNegxLHIBDHSJCAzuPii8P/RimcMkVk0aIwMeTnkiVsd8LV0CwW7Hrok037SMJV/GTBdGGyX7JkiVEbgu5hiPKydu3awBsg0zSAUF2m7EjKNmggWxjf29OTHSG0o6ZMkX83bpQurVqZamgvAjsgOtagOlauWFGakG+cJkqWL5exMDVpCTgLBH3cA9s5KehKG92DOBdBV6HXrVvnyXVRiWOOsd6p3uUKGO4Srs4B1MNQCi0UTJZBX0Ct4poJWx7z/uXLS5k6dcMh6zSw4p9/TAFL51atpKqLZtWVKlSQbnvvbX66hdo1akinFi1k12IWtBi1MYNKOOpS0H0LAUVhmOAHOUxtNxOLFi1S4rhundR0sSucWwh2TMwjUnSQwQRJODLoxJFz0LVrVw3X7QA5b999913GKm3LNWwgJVIkpbZoZffq1U31cjWXq4tLlypl3pOfbiuP2APhMzkrDbJMJXXpDFb5tmzZUtvL7YBuHMNQS6LwfANx9GKoWoljEEPVHgOVc3oeqCvaLfCTpUW1atWMAjV//vyMvH+JsmWlXLOmKU3iY2fMkNmLwsQrE639yJecMneO+ZkJ/L1mjUyfN09mzP8r+ReVECnXokXG1MCVK1ea0L9i50Y6yLmNFmwYg15RvXHjRmNL5MVQtRJHD4SqM+G35idg+ls7Cz19/RCmwpIn6OMBEKLGy46CoUydjzK77y6layRepPl8CkyWrFwplcpnbvdPf+u5ixabn5lAvd13l2Z77SUz5y9IWnksW79+RnwbrZPAH3/8IfPmzcvI+/sRXbp0CXx41kbivEiYsol11B4YcxTvnQcljjkGi1LQ1TaKIfDvCzoIz7CIBj19wWKvvfYyGyvsSTKFcs2bS4nS8UPDk2bPlkXLl0u7Jk1MmNrPaLzHHtKk3p5GeZy7OH5lecmKFUwhUaZg1WTuf0XY9Fo3jWFgyRX0NWGdEkdFMgMkqIA4Q5iCPmna3CZbWRl0EK7mnFBpnilQKFOedpgxALmav3Sp7N2kSUFHFr+jab360njPPaVSnFBgiVIlpXybNhmx37HgnqcohopqBQ2/ZsqQIUNyfRieADmvQc/3XqfEUREPmVwY/fL9CdEGveUYCyiJ0Eocd6JHjx7SqFGjjH5G6Vq1pGyDvaL+bc/ddpMOzZubn/mEZvXrm6IZNmuro2xcyWss5WLFeLTiJ5R1VGVFGNz3lTN4zv0UedGoixjiyJrgxQp7JY4eQNAVR+wngE4WYdUxE32a/QqKMmw3jUyibMOGUrp6tUJKI1XIVDhjaZMN0C6wfu3aBW0Ds4GFy5fL7xMmmPzNguOot6fJ/8y0iwCt9YIejowkjkH3bwQLFy6Un376KfARqLVr13p2I6HEMcdgRxF04ojKBkFQ4kgjnnqmKERROBeOIopMjg/GX/nWraVkpUoyZ9EimTJnjixd9bdkExXKlZPWjRqZn9nCHrVqGWJMxfjyVaukdM0aUrZJk4x/LoSxHf3sFQZEW1Da1IonLCAgJgTd13PdunVKHBXRQf5C0Ikjhs+cByWOYqrLUWIUhck0NkXTpk3L6Ofg67is2q4ybfEiabTHHtKo7h6STWBL88+6dVm1p2Fxpuin1q67ytgF82Xd7rtndMFGRZo4cWLg03MiYc+HEsedxDHoWLdunVTJkKNBcaHE0QNqm06i4f7EQfftcuZ/abi68MaiadOmJoSVyXtlwYIFMnHaNGl+wAHSsnkzyTbWbdggv40fb35m+/x26tJZ6uyzjyyiFWMGsXjxYpkzZ47pCqQoXEV8yCGHeLIQIttQ4uh9xdF7WZcBAwNj9erVEnS0bt0614fgGUyaNMmYAGsobydQYak6RXXs1KlTRj4DVRMPPcZiaONG2TBuvGz3QkvQDKNUtV2lwt57S5cSJQraPZJXav/fTbWR6wdJUpProshEe02/gTHC2PMqYcoWQhStrV7tWQVaFcccg4FBQ3dF2JYn6AnRtoMMqqNiJyAxELo99tgjI0UJjDsITRssaCBQFSpIxX06GlKVzyhTt45UaNdOSuxo/cl3X7Vqlfz444+uq97Y76CitGjRwtX39TvIbfzhhx90HdiROnHQQQcFPl1n3bp1xiDfqxssJY4eII6YHAfdBJxJk8lTw/bhsD3J8mrLUxh4/vEAbm0wli9fLkOHDpW5c+dGzXmEVJWpk59djco1biTlaScYoSyi9qB+UZDkVv41KtKMGTOkQYMGsuuu+U3G0xmDzP8anlVY2E2EV10HlDjmGFaKDvpu09pQaG6fmF0m3l2qOkbH6NGjXSmU4Z4bOXKk1KxZM6afIKQKg3D6WmOKnWm1xap+Gf0c/ELb7i1lY3xnSOO+++5rHB9+//13s7F1QzHGk1PVxqJYunSpIdPap15kypQpZsMSdPz9999mHqAJghehxNEjhCnoxBGixI5bVbbwIkuuHYVTiqKg0pB8x+JsMsgfGj58uJmYyZlMlM9Xds89pWKnTlKqSuZyr3apVEkO7trV/MwUSteqKRW7dJbSNWvGfR6ksVu3bobIQtSLA0LfFMNQ/KZ5fIWBco7iGPQuKc77kjEXdKxcudJwAy+afwMljjkGEzSEKejEEXCjKHEMA2VGe/hGR+PGjU04ddy4cWmHrKmgZrx17tw56YUKj8cK++wT7jJT0l8ecyXKlJbyLZqbIpiSSbb4g+ihPLZv3z7tzyVPa8SIETJ58uS03yOfYUk1ec2KcL6xVwtCsom///7bs2FqoMTRI6FJdhhBBxNG0HM9IydRDd0XBeogFeeoE7NmzUo51w5QaNO1a9eUd/SErss1aiSVunQxrQrdxNr16+XXsWPNT9dQsoSU2XMPqdS1q5RJw1ge1RuSvnXrVtMWFCKYCvBshNw3b9485c8Oytzfu3dvJUs7iiMh0XouxBBHrxbGACWOHgADRBXHsJLUt2/fXB+GZ4CiRkhWURSEmPF2TEVxxB+OVmZs0sgfKk4YqGTFilJh7zZSsWMHKbWrOwsdpHbd+vUF5La4gNhCcMs3a2byGotb+YsHI/lnyXowUnCE9+bee++tHq0JUi+C3iUF2GhT0IljKBRS4qhIDCRpJY5hJUmxE+Q9USCjFkWxw/mQR5DoHKFmUOjBAu2mR1ypXXeVih07Guue0rvvJpLj9b9E6VJSZg8Uxi6G2EJw3QDpNIStKZQhNxQFMhHRxI+UXN1MWCjlAxiTP//8szpJ7ADh+p49ewZ+k7FuhxWPhqoVccHOQi15wkDRyHRrOT9NpKg75EEp4itbw4YNi6nUYW1kSSPkJxPVq6WqVpUKrVtLpe7dpWyDBq4RtqQ/f5cqUq5pE6m0775Svnkzk4/pNsgJpWAGokM1ejxllHPcvXt3adWqlevHkU/V1JzLoBMlp3AQdLURWBFJFUdFXNgBoqpj2JJEO+mEgUUHxVNqy5P4PBHmIp8uGsaMGWP6P0MaM71IlyxXTso1aiiVunU1qh//D6lzXYksWcKYk5dr1kwq7dfdVHyXrVfPeE9m+lyTG8qmJlqEADL5119/GQWYdAKNIsQG9zVzv1aah/Hnn3/qXCfhimovW/EAb9Z6BwxWkoY4Bj2sw8IUzYw5iGDyoIOCLiyJxwx5dOSE8v+RXSfatm1riEy2+wCj+pXl0aCBhLZtk+1r18o2HmvWSGjDBtm+aZOEKDbZEWWvWL68dGzRwvzc+SYlTBV0iXLlzPuVqlJFSu6yi5SsXDlneXGQHbvZxUqG+csSRKqnuX+5DtZqTFEUbGRWrFihRUOOqMCiRYukbhoFXPmGv//+2yivXrXiAd49sgCBsA45RFpZHV6Upk+f7ukG79lEy5Ytc30IvgBkEaWayl8IIsRl6tSpJg/SCx05SpQqZfIheTgBoYU8hig4CYWkKrmaEMISJaVk2TLFLmrJJEitwWqHbj4dOnQwFe5z5swxJF5JY3xAuCGP6t/on/BstvC3xwtjgBJHj4DuFUwmQQfyPEoKJFqJ487dOLlQ9FJWxAaEBfsYqlQhNFgZQSi9TGIY66iJUq6cKSghzMsx+6GLCOe6Y8eOJsRIvh75uChotBVUxAeEcb/99tM5bgeY79ng+WHcZxrwAIrKvAxNQPEIateuLUuWLJGgA3me1mT16tXL9aF4BrNnzzbdO9yyaclXQMKwdCKnEeuYZs2aeZo0RtsgoJLy0y9AbcQgnII2FDQNvSY/Vr2uKmUTXje8zha2bNliUhjgA16GEkcPTcDsulAdgg7yOzSpfidQoLBngAwpYoOwL+oX9xGhasiMFpxlFoxLOhwdc8wxhgglsulRiNkcME4VO0FKSax+8UHC0qVLzTwGH/AydHX2COwOg4ETdGDUjFccFkUKMeEsduOEMRXxVRzOE20EbTcOxhE7eIX7YDwOHjzY5CMTniZSQMRAyWNs2Kpz3BIUhUP3bPaCjsWLFxvRxOtpSUocPQIGCj1zVVUSU0WMLYOqRTvBbhwCBKlWFAY7dEsOGzVqZKxiuJe6dOlicmbxBqU3tcK98z1lyhRTxY7aaIuPWPAItWFqnWoryKCAeY2okqprO0F3Ib0/wyBdjfnLyxXVQImjR8BCx4DRPEcxu3EKHLTKfCcIXWjeZ3Tg3wg5jCTVTL6QRxZpCjn8sGHiOnvZfok8RsKstMKk3zcFSU5bII4dSzFry6MojHnz5pnNjJ9yb7ORw63+jWEgHHk9vxEocfQQWDRUcQyDkKMSx51AzaEIwQvWMl4Cbe0gKHg1Rjs3nDfIDeMJpQwlDPLjRWAj1KlTp6z7Taaa04jZOukAqLux8tX424QJEzS9wgHUWKIokT6jQQZpDYwnLYwRMy+Rqub1/EagxNFDYKfBzktzhMJ+XihIWixUNKyjhDoMil9QKyCGySzGWBrxmt9++82T7T3Jf6Oi2ovV8yzuEB+U2z59+iRURVAjUXohj36qEs8kUGMPPPDAwDd5cIJ2qmzotMJcTLoN5FEVR0VKYKfBoqF+juGcz3322cfzuR7ZBurajBkzJOjgPmGTRS/kZH0DCQ/incdm5KeffvJcXhXE9vvvvzc/vQIWdcbbr7/+aoz5QbKOBxD6/fffX3sx7ziPCAKQR9KSFGGw1uHdSGpS0LF4R7RRiaMi5coy8oU0XB3Oc6T9lE6yhYGyxmQb5IpzduWQF0ggvo2pgErrXr16mckZv0fdpMUGiv+wYcOMStukSZOUuxgxl3G+ATmPQc5jIwTJpkDV18IgRK3en2FQ38D58IMJuhJHj5ElBo4WyIRB5w8qN9mtK8KATKNaBDV3jO89ZMgQk2uXrtcn548Wed27dy+wvcBSRrEThKVRGTnPnCfyFtM936jDnN+RI0cGNs2CcYutlqqvRcUSrTD3V2EMUOLoMWiBTFHPM7Xl2QkUWCxQqM70apFHpkBomY0Ek6sbPng2IZ88K8jo2LFjA68IESbnvrPkumfPnsXOP4NwUvTD+cZXk/MdNOUWtVWLYorm9KlIEgbiCOfCD4UxQImjx8CiSFjDiwny2QZhLmT7IIe4ooGKVcKGThuUfAebKYgdlkQUXrgJ7FGoyua++/HHH01oNmgFahBmSDkejFbNRg1yK8cY8kglNvc01klBUnjJDWUeUzutwsDhYM6cObk+DE9g1apVJvfaL4qjVh54MBRJeIjdGL6OQQbEiHPAgp5qflU+A7uWIKkX3A/kI3JvtGvXLiOEmXAZ748/IQ8+g17X2QTFO4cffnhWNwSo1izgfGfIHaQ8U2MLtbxr167m87xsOeS2ksT4bdq0qbZRjRh3rHE6r+90ywB+URyVOHoMWDUwwRCKDDpxBJyD+fPnG/sUP5g4ZxPjx48354RFKZ9BWJo8O4hVJkkV4VkWMqq0rQk36hufae/LTILPybaKzOJN1XTDhg3NOMq0+TgKpi2GWL16tfm8fPYm5XpClhVFxx1RNV3jpGCeqVmzpm/uBd0CebSaGOKoCNvyYOuhtjxFAZFBvaGQIR9BbisG36g29LHNlmIDGbfjjaprQuRUxBLCzmQOJLlweExmsq0kIWK8FSlUseHovn37GlujbHesoeMP3zdfHQLIFyVaoigK0o9QnSkYUohZ7/1UJFQ6n27SF154QX755ReTK4BycMkllyQs9WfXM2jQIJPbw86b90EuPuCAA+SUU04pUhpPsng0XHjhhXLGGWe48l0YQKhJLJhBymOLBhazZH36ggYsUtipQh6pes0noEZRSEFOXC7vA7xEObfkYmE2zhzB3JCJUCt5lVQdu51fyfljoeY7WN885hh7XnNV6UvBDMTx999/N9ZK+VZxPHXqVLOesPnVMHVhsBFU78Yw2Dhxf+J56hfkBXGE/N1www1mAYXssdh8+umncuWVV8rLL78cNykZBeH+++83uT1HH320SZRH5RgwYICMHj1annjiiSKLFhPeIYccUuh3boYLmdTxTyNhVh31wzcWix6bAFUed4KFFlLNuaFgxo1KY6/YMFFAwcJCr+lcL7qEj9q0aWPGn1VKAMeIYkJCOxXDXtrkkUMGaWGBZn6kvzTHSqU0EY1cn1M7fvfdd18z10EeSUfwg4ddshsfqmQ53144116DFgrthC1GU8Uxy6ALBGGPu+66S3r37m1+hypw2mmnGQJ42223xVW0nn32WRMOtTjyyCPNYvDaa6+ZCReiGDnoDz744Ix9H96fRYgBpcQxDNQeFkFt1xVddUSp8ktidaJNAiQCckZumJc2CswVdvxBxiBiVHtD3CHthH3ZgGY75GtBHjDjAMJinQj69etnilKYF71YkEJaAORx1KhRJlKUL8SRtAbGh85XRUH4nuvMfK4QE6bmXFizfD/AO7NyMUCYGYLlDCNzIeipSm4SVW2x1BgmeSdptOjRo4chjlzUSOIIbA/lTEx0TKYsQnx2+/btJehgwUMJXrRokU7EEWBc0//WSwSruCoUO28U1FwRsGSAioQKycOqS5A2ex0gQmz+mIfsouDmNWJO43MJa6Mgkuf6ww8/mL/xeURA2EjYzkteJI1ORZe5m/MFIefh5/FMpAjiTpqDl1RorwCRh0IQJY7+zG8E/r07I3yyotkdkOf4xRdfmKrcVFuTWdPpaLuAb7/91oTCyRHigp955ply0EEHJawic3ZNSFT8wvtqT+KdYHGcMmWKWSC9TChyARZZFluIhF8VatQy0kbYIPgtX9OSw0gyxByC8mSN2iFHzCfMR1wrSDIPyD/PtxXyFMewMeWaQhBRrriuvAavRc4TvweE8203oW7dupl/+zFX0BIsbJf4fnwXv7YbpfofX9B8iAC4DcYwUQUVAMLgPidqEU2c8jLygjgyQePvFqszBIQtVeL47rvvmsk80koBhQElk0mB9/3444/l7rvvNpP9McccE/P9Pv/8c3n99deT/ny81CgOIN+LiSjoYHEk9xRlR/NjioJwKcn4VMj6jThAFAhPs/Gjj3Q+qDTWn47NJbmGLJhW9WOxYM5yEkAII4SZjRHpMZHpCBBHyCHEmuvL3ARZddp32PaJfgbzNGNhxIgRJr/Vj+SRY/abgpRNv0KidHZtDjrmz59v5gi/+fJ6jjiyy07WXoSdOosME3G0ULT9nQ0rJ4s333zThJquvvrqIpVfzz33XKF/H3bYYXL++efLSy+9JIceemjM0PVRRx1lKgediuM999wT8xjsxEP+GmQ16GCxZBfvV0Ut07AKNY9oqRdeBcSJIhNUOVSmfCCNTvB92Pg5N38QQR7AqoqoxvxEdSRNhvHOa+0cByCJ3AP5DMgwm3XGBHMw3Wb8VFzCcZNmhC+mojAgSKQbIQLk232eLuAB3Nd+I9KeI46EYqiGTpbgsWBC1uzO3Qn7u1TyEAcPHiyvvPKK6eAQT0G0QAU47rjj5NFHHzVhqVgTOzkdPJIF4SkGEwNLiWMYuouPDYgHZATVkfPkB5WaDSILLfcpFbVezsPLFCBFViH+559/TDoGIW2/qcZugs0hhBHVkTCeX8KakCLsjsjPVRQFm6Q999xTQ/gOIAwxX/uNSHuOOCLZ3njjjUk917J0Jhpn/qCF/V2ybB5T3Pvuu89U+V1zzTVJH7N1vyes7CYYUGoEXhi2XZlOPkXBgrVgwQKz+cITzOuTEZEAqzSqEbDCCcLuVIL7pZMGmx+M1ZmXtBtK7BC+thjcCQrbmK8z6dASGOIIySPkmwrID8Iwmx2NM6zB7p2dezI5cZMnT5ZbbrnFeLXdeeedKVX1sdMEbleJQRzxkiSZOIhqTDSwo+c6K3EsCsY+VfiMFy+TRlssAlmEHHj5WBW5gyWNLK7khHo5TM/6QShWo0PRwbnBUg3FMV8sl9zI92Qu9GMkzT/JI3FAQj0TC11jLEhGHzJkiAmBOfMfuVi2objF3LlzjYE43o0PPvhgzIHNe0aCRXrgwIGmWjJRl5pUYTumUPigCIOwFUpyJlu/+RlsXsghchI0LwHSj7JvC0CUNCqSAZEXbFy8Soq412jbGOQUg0SuIpBrnbd3AiJNTrMfFWrPKY7pANUC8kYHGEig7RzDInXuuecWeu5VV11lfn7wwQcFxO/aa681lY90naGizwkWYbuLpIJ66NChhoySAA2B+frrr42h6c033+y6TQzfg0FFwQPGwgox5J6QB9VobnbryTdQgc6YJgzsFdgOJtw3kW4FinCeKhEXP3sYZgKoVBAzokpeDHey+cGzURE/l48Ig59MrrNhI9ikSRNfFX9Z5MUMxWTy0EMPmYrnjz76yOROYW1BrmSiMncS0m2XhRdffLHI32ktaIkj1arser/88kuTz8jukkkMtTJTEwfkaOzYsdq3OqJ7BwoEN52ek9g5YuxoCfOx8OYajF88+rjXKHxIpVAsSKFZNqWKoiCcB3lkQ4RK45X+9WzqIUSaOhMbrMfYqHmN8OcSa9euNYVf1FP4EXlBHAG2ORA4HvFglUYLbnhniDseWPB4ZBPNmjUzvVy1a0phrzcbjlVEB0o144WFlv/PdR9rVHkmSjZYfgzNZItc2w2iboiiF3+hxhLt8QIQHXDS8JthfbbB5hV4YQPrFcyYMcPc49aWy2/wn0YaMFDYg7KpXWR2gh0+ipourvFhlXIv5IaRYkAusiozsUEU46uvvnLdnSGfQASJHHRy5SJz1bOddkEkCMFC7XfiA9cTUq1yvXn1EmbMmGGItF+LXpU4ehzkP6CwkQ+h2Ak69eABmKq5e5DARA15ZHJCycoFcDYgvwlEmukrFOmCHGccJ/iZC5AGQriRjmV+zFHLJuh25JXUAi9g27ZtZvz4OUdfR7wPQLiaUPW6detyfSieIkUUWeRq4fALCFcTSsuFOksYb+bMmZ6s7lb4Gyy65D3iWWrt0LIFNmGkXdAdxm0LtnxU1khTUewE+fkIHqzrfoUSRx/AFoGwCCt2FsmQ58hNmCs1zW/G6ah/2QJjFZWchHhtv6bIBChWZGOE8kjxRbbAXEz7WM1tTGyKzhyggkdRMk30xSu5uulAiaNPqi0hSRquLgwUB+yU8AhTxIfdeFgHgUwnw0NS2VH7Nflb4Y8xjeE9c2O2VG3SLghRE57GzUORuCgmmQYcQSOOTZs29XWOvhJHn4BFGNVIw36Fk67ZudkJShEbqH7scG0nokyCqmmS4d02xM93MJYPOuggzQVNASy+HTt2LHCcyOTYZoOKl2Qui3L8BKJBFMNpUcxO0KiEceTnMDVQ4ugTsEMhL0Jz+gqDRYOQlSLxAtuhQwczidO5JRMbEMKFVLvyGVppmjpQsXBQ0GKL9NXAn3/+WVatWuX6e2/YsMGY12PQrhui5FrDEqL2Yzu9TKuNpUqV8v38qDOUT8DODRsaDVcXxi677GK83bDHUCTOC+3UqZMZR26fL4oFRo0ape0xiwHUMs5hphXhfAWqI/PB8OHDjceiW+Be4bqw4OND6ucQYzajQZwriLZiJ1i/IdN+V2GVOPoETFaojurnGF3p+uGHH2TLli25PhTPg4WVCR0S6ZbqSN4kIXA2N1owkD4YvxBwHcfpAWJHK0tywrHqIhfRDaCcoaSz6fL7gp/Na6FNGooWC9ES2e9haqDE0UdgUSYEkI0CBz8BSwwWW+sXqEhuMfzxxx9Nzk1xQL4OoW/yGgmFqxqjyCWIPtCfnZC/Wy4UbLb69u2r1jtJAoukqVOn5vowPKk2btu2LS9SHZQ4+ggYgTMh0kZOsROcE8JUmKpqyDo5YArOg7yt4pioQ9jp4oOKqbl5Ci8ANZ0ewJhzFwerV68298fWrVt1bKeQC0oeviqzRUEHL7rFYIjud+jd4LPdNL54DED1LixKqgknZdsM2K9gIST0BsjfSpVws0AAwtNdunTRhVXhKUBcGJPkOv76669mbkg1rGjzTXVsJw9ynFmnaA2p2AnGH2lmtg2s36F3hM/AwKNjSjYNb/0ALEwIl7qZFJ/voOcvSiHKSiqhJXopU72KwqtwVzknHYWfCvfURxT133//PWllnU05SiNhRTZXShz/v73zgLKqytLwtXscR9uBFiOmQVEawTSCYhOUrCggCAIKRto4hmXPtI4ztj2m1ma1Oq4Zc8KsgEpWCYIEURFEgjSIgCIggiIqxh5r1rfpU9569V7VffGm/1vrrSoeFV7dd++5/9n733sHzz7QgofiD8Sj+AnWVzbnLVq08JKArogY9uMjxUjUUdTk6KOPtv6BIr/qR5ook0IJ6o2k8IBzUI19Sy/kKYDjoygNnKekrRE1nLdBCo+4ybM5Z1O14447VuR1JgGOGeJIk6Jqw/0aQY1fNglIOMYMdr+II6Wrsx8bjgkLmMi/jQkRlroqUUnbEbkhDUgBAtEcUToQNWQSVFVdWqiyRjySLiT9XB9Ey4gM7bbbbhV5fUlhr732sgb2ipjXZOvWrZadSUqaGiQcYwgnIClZTUypzYYNG7zXXnutLE2Akw6RltmzZ+cUj0wuos0GolHm99KDMKdCXX0cy2Nl4bzFI54Ll8om6hv3Bs2VhkwE0UatC7Vh/CrUde7FDQnHGILxmIVQ6eraMFaPY7Ns2bKwX0rsoL8YqTlSetnEC5Hudu3aKaIgYknDhg2tpQ4Ch0IFf0EYbammTp1qG0+RHxxH1ox333037JcSSRYvXmwbESLfSUHCMYbQK4+oI2151H6m9rGhTxb9LpWyzg9Sz0RliCpyIyACQ3UpUUgiuFgB5L8TcYeIOsLRdROg2ItpM7RJobWUyA8KYrABNGnSJOyXEjm++OILOz5JSlODhGNM4UQkPcBJKWpCixiiC2pCmz8IQ8QjfkcaqiMgOc/kZxRJgbWBQjo2l2yK8O0SDeI5VVDnB+sEjdbxSTPKVNSEKCznVNImaukqiSmMc2KHrHR1djC3s5ipgKiwStT27dtb2o6UNUJSN4Xyww0Gm4XES/lxTevxlLL5ZlShWsjkD8eOzEQSxuiVg8WLF3sHHXRQ4uw9WqFinq5mR1OqmcNJgopIUicagVf4gkdKjzY9fM70DFFeEI0dO3a0j6IyVcD9+vWzSKMsGIWBJxrRmCT/XqnYvHmzFbAmLU0NEo4xhhOSCR74dURt8C8xN1WzvfOHmwFRGISj84BJPIokwJpJepqP9NZjxjpwnov8bUGKNmZn4cKFZvFJwmzqTCQcY15BTDp2/vz5Yb+USELKD3+evI7BhTZ+JT7iA6M5OFWopKolHssPx/jFF1+UgCkjiEXadWV2DeDfM2bM0FoREHqNLliwoHr0qKgJa+jbb79twZ0ktiiScIw5Rx11lEUcNWovO5iSOTbr168P+6VEGryg3AhoY8QIQj94aZ14VMuN8r4HCHP5cssDlb9EGqFt27Y1psLg68UXzVqqDE790NB67dq1sgLVcXxYR/HRJhEJx5jDjoZwOLsbUZtdd93VZljThFWti7KDUCGlv27dOtuIEGnMBPHI9I2kVQeKdMC1T6SRj5zH2UYJ0muPtCJRR81hr1uAMwyA0YJJK/ooFfPmzavOCCYRCceYg6n7sMMOs3S1hFF2iCSQUlFfx+xQ/LJmzRqbWY1nKRekrUm7UEVJGxOlVEWcbCtssukWQHQxF/j1qIJdvXq1ig5zwCacXq9M2BG1oaiQzA3RxqRGZCUcEwAnKDdx/GmiNlSpdu3aVc19c0DE+vDDD7dCmKARSm6qs2bN0qQNEWmIHC5atMg+J/MQJELGaLgOHTqYOJJtoHa0kcwEx0i9XbOD5YeNCmtqUpFwTEhPRyJFhMdF7sgsN4FNmzaF/VIiA4VDQPqZ6tKgcPNl9CBCnD54q1atKuOrTA/0yjzuuOPUM7MEcK0jGJmuVYgARBRRADJz5kwTSuKna79Tp07efvvtF/ZLiSRVVVWW/SO6neQ0voRjgqKOy5cvV/qwDuiphTlehUSeeZSmT59uaZVC4GbcunVr84VRMLN169aSv8a0wTGlmp2PonAoMHrzzTetOfURRxxhVpVCUoY0BEfEIwQUWd9W9U+mgVR/UlOwpYhwb968ObFFMQ4Jx4SAz5GFjjC5yI4bi0UUIs3g30Ls4eUqptk0Nw9uyjStpgGwqwoWhYEPlyiZWpwUf/P+7LPPrA/p/vvvX9T5TY9HGoUz15oRhWkFwUg7rrSvnfUxf/58s0QEtf3EFQnHhKAimeAGeYpk0tqehyIYxAmRwlJVSLupEVSjUjQj4VMY33//vYl6Por8cZsWNkSk/EvhaUY80mmASVTYMigMSyP45zkvObYit/WHwiHOl6RHZCUcEwQnLL2j1EoiN9xMaJNAxC1tApu/lxQ1fsaWLVuW/Oezy3a+sMxekEKUEzaCU6ZMMRsKG8RSjsDj52HL4JHG0YRsBBGOTZs2rbMiPe288847dq5gj0g6Eo4JS8UiilQkUzeIJvq1JX1X6Ic0MosaRS1EpssBaW+qUbm50DOP6KYQ5d4M0fqEVDKbwnIVFuE7JQUJbL7S5CWnXRfFQoo21r2+zps3z6w72XqEJg0JxwSBEMKUy0KapoUtX4hGEB3jeKWhVxuzuokCkmriBlBOwUxEhgbLVPqrb6YoJ4wJxBrBpBc2gmRcyl1YhFClypoiu0ILy+IGGQqiaHjoRXboLIGvNulFMQ4Jx4TBBY44oKpQ1A2evNdffz3RvdoQb3izaA1RqYWfmzfNxF3KhhutqlKDiW68p2lMhxZ6nhFFp6k3jbsrkUHg91F0w/XE2pHkbgLOykOklUyWyM2cOXOsiKqYYqw4IeGYMLjp4MUhdZNWI3dQWBDZJdK2I4nQFoJKSMYuck5w06sk7kb+8ccf20Zm4cKFqrquA8QINook938rRQNqxqsSPWetw3rBRKNKwvQkZrezEUMwJLUYjBS1bE/BMjrvvfeezT9Pi/1JwjGBsCNmYaXCWuSGmcykYaiES9riT5EKopG+gEcffXTFRaMfUohMUaCP5owZM0zQitogqjk2EtfZIXJN71Ha4pCmDhNnycBXiZBMYqaCDTWbTlE3c+bM8Ro0aFCWgsOoIuGYQDiJKYAglZIGD18xMDqLyIEbS5YUsCsg2NhERKGhNAL9+OOPt5usesFlh7QnYxyTnP4sdBNElJHoF21x6Bta6ShjNogMY8fg+qIVS1LaKJGipkLYbaxFbr788kvLpBCBjsI6WykkHBMKYXNaU9B2RtQtsBDZVGMmweuI6HAzy0nFR8nQTlESqUUioEABlxt7KERd5zTpQJpxY7mIWoTPVdQSeULkxh0mkJGBIUuQltRrobz55pu2xrJJTxMSjgkFMzN9t2iLkgRBVE4wNRc6lixKkL5zbXCimu7kGLviD6r/X331Ves7qnNU+OH8decF0cWuXbtGdhqHaxKO/5IsT1SvvXw201SpFzNVKg18//33VnhIJXXafMkSjgmPOtIYl2kUon44TqQd4gg3LSIepEvwXkUp0pgLbrakwkhd411T5bVAKH744YfeK6+8Yt5j10g+6mlARBbpSqKjeIvjbBEi4KCejfXz9t+KtLADpQ0JxwRDaw8ij0ShRP1wc8IQjgk/TrB4IRq56SIa47L75XgzApLxcLxmfFVxvuGWInJFGjbuke9C2bRpk0WgOQ/wMnbu3NnbZZddvLhAIRoiAvEYRwsGGQBalIlgPtA5c+bY+sX7njYkHBMMNyCijrQKwCMk6ma//fazxtVEHeNUZY0A4waLaIzj1AIWXl47ApK/hegp4oGPaStqO+GEE+xjmnA2Bd5vhDPTh4hGx/Fc5jrs0qWLndP8XXEZa0pbMu4TUY/sRoWlf4uGc39NIxKOCYcdETcidkeifjCEs3iShoi67w4jPlV9ruF2KefzhoGLlBKtoffj1KlTLQISd8+YyI7bIHCtAR5GbsRRqJguBie+FixYEJt1hNZtiF6lqOunqqrKJhaR0cMfn0YkHBMOixjeG6JoaRmRVYo2NvQ9jLJgIaVLRR/m7KjfmPKFNCVRG7xWzAXG75aGiDnXJ39r0q9TrivSovytbBBo+5JEGjdubB5zBGSUr1FakSEeqVpPq00iHz74m50prdFGkHBMAQghiiWo+BP1Q9NbxDYiMsqikXY2SV3sOV+bN29uPjeaLLu0ZVJ65WWDtCb+uLikNwuBv41CKFpGHXDAAfb+NmnSxEsiRKO4Pml8H9U+se5cI9Oy0047hf1yYsHs2bOt1Rkb27QS/dJLUZIU4DHHHGPCkV1S3FOalYIpHqRKOXZR8f6w0DNOkteGET9OxQOFgGDk5uv+dhpk814gOkhthjkRRwSDaBaV0ghE3jua7nPepkGo7LPPPrbRcwU/eKijBNdP2noQFgObgPfee8/r169fIjfsQdGqmxIQjCwS3HhFMIg4ItCiNOmEiBSN3WminbZxYJy/NGtHTHIjnjx5sgn7NFdix2Gqhnuf3KhJxFQaRKNj//33t/WX1HVUIHVO1gKrgAjOtGnTLNpI7UCakXBMCdxsqVzFE5d0D1WpYJoM80fxtOBVChNXoUm/OPx/pG/TCH83EWBSnEQc6f3ooo5xbIGSVJhY5XpzUnBBA28ibmmFTR4RKo4Hvt2wcZ02ojaFJ8pwH+C969SpU6qjjaBUdYrAt0dz2pkzZ3onnXRS2C8nFtCgeuPGjWZwR7QhJsMQjURuSPkxci0qafMwwW6BqOfYsIgzNYdoAG1QqHYkJRi3NDZ/E9doHK0knJtMLCIFzYOoDO8FUba4vQ/lhGwBhUGcs5ynYYBg5DUwHSaphUmlhnWGYi7O5+bNm3tpR1d0yryOpEyYq8oCJoJBqxtuhmGlREmV4xFLa+uHunA7fyLqeD6JoNACZcqUKdUzu+NUEERENQ5TfxxEeSn8IB1NlNGlo4kukpKWaKxJs2bNLALrrulKwwaL1jsMhjj44IMr/vvjyqpVqyziqGjjNuKzQomSwM2VIpkZM2Z4vXr1CvvlxAJu5ESCgHRxJW+GNJpl0aLqMaqzeqMAizlRLh6IGY7Zd999Vx0Nw9SO8I5yU2n6GnJzIsod5ek/7hrgmCLSEetUmEb9dUcFioNcwQxrSyULZoickTZnMywBlF+0kfVXYnsbEo4pg0W+Xbt2FpFp37594qtyyzFmCgFSiVYMpJSImpGS5aYsgoGdgCIaBxMeiIYtXrzYmkvz/pFyCsN2UBcI3eXLl9vri5IA48bJMaSQAq8v0SrOSaKKVOQqHZ0/HD9EYyWbnSNWsUFQWCeCwxrMJunMM8+U2P4butpTCAsHVY3MhRXB4eaIJ4goIHN1yw3RMyKdYXmhkgLp3+7du1ePsaMwwFXKsxlAFInsIBbZZNKNgdQq0SpnmUDcKh1dGAgQvHKsw0TEP/3007L+vtWrV1uWKcpDDaIcbWTjrnX4JxRxTGmbGebBvvTSSxZ1THO1Y76w2OMPxSfKbOVypD5JV+6www52g05r9XQ5znlEjuur5xqJc8PGuoEI4njzYHOQxgIkJ2CIKpKJoO8iwoZUqjsuiriUJ6K1cuVKsxGVYy1mDjXRdt7POPlnowBtpLgezjnnHJ37PhJzFtFi5t5777VdFSkffCSXXHKJVY7Vxx//+EcTUdn6bz3xxBM1niNC8cwzz3ijR4+2CxLfw5AhQ6zdRJxo1aqVdcCnZUb//v3DfjmxgcWDyBXnGY24SfuXMuJCZSoV1Gmeg1puEIVO8HOjpmCMmwPRNSIzCCTeV6INRNlIJ1JRn6TImiv04lisXbvWqmzpEQr8ra5HKHPuSauK8sE9iilQ9FUkw1DKSmfuhWxy2Qi0aNGiZD83DXD906mBtTip041SLRwRc1dffbX1WBo0aJC1gUDYXXHFFd4DDzzg7bfffoG8f1dddVWN57K1xeDnPfnkk1ZYQvSJFM4NN9xggoL+enGBnScRswkTJthH0qIiGJwrtMVhsS+lmGD+KYZ50iK6WVcGrltEEg+a+vKeOlFFBSoVw9xAeJ9ZVxCRvDfliD64qGg5Rl2ysWajS1qeB//GB8q5RnSb65+/DYERx3ZAcYZzi/UE4Ui7NPrtlsL7yHnL5tYFCpK08akE2FnwmauINKHCkagZoXgEXMeOHe05GgSfccYZ3iOPPOJdd9119f4Mdt74oOqCfn7PPvus17dvX+/KK6+053r27Olddtll3t13322/O04pLka5EXXEw8SxEsFhYXeLO6lrREUxsEDRJgPh4C/sEJWFCJsDAdWjRw97f/2Cy4lGos6IPL6HVDcPBBjPuf6S+UBauJjxb1STf/PNN1ad7R60f0EY4utkY0I0kfOWCIqzQRB1lV0lXLhv4D1HOHK+lUI4cv5RxMf7H6ViqzjA5pFoI1XUQQJPaSMRwpEiD8L7RM4cXHj0XKK/GH6mIB3yOVlYbHPtuIkuYi5GOPovzj59+phoZYdC25Q4LVak2EeOHGnR2jQPbS8UimSotEaEF9Muhxs685dJJ8lLE61rhLUlM32IMKSaGDGJ6GfdYG1g84hwJFKJUHOCkgdfT0UyXkLEAe8zUSA+8ntYd+iDyOc856YF8b2ISn4HP9MvDPl+1yqKTaDzbvIa+D6+BuFAlPSII46I1cY2bZAFwjbhrn/Ok0KjzwQ52BjI7lIYCHgi9AMHDgz7pUSSRAhHWliwM8gMxeNzHDdunPnG6hNFLLBEF/joxrpddNFFNWaqsmvHG5XZGoXf4/4/l3BEYPgr5yiAiAIIFf4ePJ4XX3yx0hl5QqSGHSkpZs6NfOdHIxQQDHyv0tPxgZt7Zk83hKMTZhSUOLHHg2ggH4EbEmlJP5wDpBOxwRC19G9e8VhxbhBNpKKfc8WJUf/6hIBEaCAUMwUiz4no40Qj3lp8pwjJfK0D3FvwSVNsIwtS/uD1JRiFfUDHL8HCkYWY3XQm7iaOYKtLOPJ1p59+uqV12OWz28AjSRTuzjvvrK5E4+fgAcqMCLnfU1eLlrFjx3rDhw/3ogZ/y4knnujdf//95odhDrDIDzYLiALmgFOlHrQ/IKKRil4ilUpPxx9/xWpd6V+eZ2PqIoourc3nCE5SlmRMeI6Hy5aw9px88sk5f3+xdgkRHYhMU21NNoNCraDdG4h+E+0meyHRUxi03+G6I2MpYiIcWTwJ0QeBBZU3mMqxbKlo95ybIJGLCy+8sMa/WdSJIlEIw87DFb3wc7KlDoL8nt69e9sC4N8V3nTTTV4UIIVGqhVPBwImytM1oghRWlelTvQ7iE+NVCUbFPxxqnZMF0QD/ZFC/zlBZBDRKBGYbjgPiDaypiAe+bw+nyLnD5t/16Bd5A+dFfCan3DCCVmvURFR4UjKj2roIDz++OPVVYHO2+PHPVdImmbAgAHeQw89ZBeiE478nGyiNsjviboBnWIiPJoUGpGyF/nBhsKlCuuDAgsijaSgSCfJdyaEyAShSIU14pF+gowJrAtaSWGzYuMqn3T+EPnHskUGUdN1YiYc6Z14zTXXBPpalyLGuJ6t8757Ll/fmROBRINoz+H/fcxmzayYdL8nysKwPkivUlw0depU83ao8XT+uIgA5wyLONHbbAs4kQG+FqGphrxCiFwQ9SLaGCT4gWXG77MV+YE4Z90ePHiwjmE9RO6uhTjLN+KFSR0zMGluf3EHRnJu0IWU09PDLbMtwkEHHeSNHz/e0sz+hqDMwXX/H2eIftEs9uWXX7aLR7vWwsDviLmd8xHvrTuOLOoIRTyNeNlUiCT8kJ5WzziRiSuOocDKRR7dhpNOIGTFuPdw7yxHD9A0wNo8adIk0xKZRW+iNom4cx1//PFWIENfNQdtMvDssVvz+x+ZksDDgS8RkZjJo48+apFFxJSDwgcu2BdeeKH6Ob5mzJgxFqGjgXCc4W+jlyWmbCrERWFgSsczSjW/m4mMmMQvu2rVKvu3RKMQIh8QibTZoSKfz9mYUpBHxkvrSXFgHSJQhLdRxDDiWAj0Ths1apR3yy23WKjZTY7hwjrvvPNqfK1r3D1ixAj7iOAcOnSo9TMkTQ5cmJxIiEbEol8QnHbaad7TTz9tOxTa8MycOdOinb///e8TEd5m/BUVeUQdqURPwt8UBjTy5hzh3AAWfDYZ6qsmckFEacGCBRZRClqZL9ID9zXuSdybuEchFhGNPEfFvSgMPOcEnegoEme7WSVJhHBE3AwbNsymtzz33HMWRWQcIF5JJwZzwQJNVJKdG8ZYxCY3/QsuuMDGF2bu5KjAxoBMex2+nrTjtdde63Xr1s1LAq49D3O/WZwwZ4vCoHCLc5F+bHiU8mmrIdIHUSRaNLmRh0Jkgp8fgUPgg6JM2shJ7BTffodsG5lLkSLhCIg55lXzqAsXafR/H8IvKAjJIUOG2COp0M6B9jKkVinwUPSjcNzUIgphiChpDrAQohgQimzusVixVovCwbZGlP+kk07Spj4PZIwQOdvzIJKJqorCwc5ApJF0CBFc53EUQoh8Yf0gIs00ITz12F/wUvNR5AfHkclyLlAigiPhKHK2gWBXu3jxYmtqLYKD3YEmsohFbBREbLE/4BnleEZl3KQQIj6wdvDwTyjD2kDEjOdFftBYnUk7p5xyioqL8kRHS+SENDVtHiZMmFDv9B3xk2ikPQYTCDKb0jMhhsIjCmYUeRTZNmtU42tihfBDNNGtGfRq9Ken8TzS8ouiUNcWTtQPRUUMu8DDz+Q0kR8SjqLOQpmePXualwYDsah/gSfSSAU1kweyNZ4nvUTkkWikEH7owUexnXrxCf+awtAJ+sJSbU/BXSYUgLKuvP/++1aIJ+o/pqSoqW+gI4vIHwlHUSc0QGfkIv48vDQiN4sWLbJII36ZuibvEHkkmgv+yUQi3RChJnKUbXyqSO/mHasLa0pdgyzIZOCnZpMvv2PdIMS5zmi2r01aYUg4inqh/QOTTtilqVVIbvAxMic2SK9Gbgg0BXd9QLXYi2+++cY2H3wU6YYesBs2bLDPmzVrFiidiq0Iq4NbW0RtyPQwIYboLQVGojAkHEW9YBzu3bu3mbJnzZoV9suJZEsHhB+paQR2UBiHiWeJNBS7YPyRQoh088MPP1iTb9aEQqLPtP3CWsS6Imry4osvWsEiE9JE4Ug4ikBgyKatDB328fCJbTA71vkaC4H0E2mo9evXW1GNxKMQ6YUixNdee83EH71f/eNyg0Jqm3XlnXfeqTFeN+2wVlNA1KNHDxWgFYmEowgMnfXxPJKyVmrVs3nePPAsMo6yUEhDUUyzdetW+duESClYFGbPnm1rAJt01tpCoVgG8UjUkk1p2iF1T3cQ0v4tW7YM++XEHglHERjGMmEoJgVCdCzNrFy50nawzPamSrpYEJ5U+JG+Juogn1s6ry+Kqvgo0gfvO5OlGIFLxW8x4HOkTQ+b0iVLlqQ+kzF16lRbV08++WQ7NqI4tEKJvGjSpImlVqdMmWK7t4YNG3pphFQSZnSOQalwCxoLPX5SipKKiTqIeIFoID0p0gWdGFhHGXnXpk2bkq4nFMsgmNLc4JqBC3PnzrWxgmm9X5Wa9J5NomC6devm7bDDDt4LL7yQup2sa4ROUQvtL8oBqRQ8OHidlGZKD9g/qKaVDSQ9rFixwkRNuaZJIRgRpJxXb7zxhvfZZ595aUtRc5+i12Xr1q3DfjmJQcJR5A3p1L59+9pix9imtLBu3TpLeWzZsqWsvwdRzkQDCpKwBNDYVyQfenpS9anensmHDTfFK0uXLrWsRfPmzcv6+4g+0koN8Vju9StKTJw40Ww/p556aqqjrqVGR1IUBA1nMXDT9gFBlXToqUb1ND0aGzRoUPbfR8sIekIefPDB8rwJkTDYEH700UeWSsYnXYn1BOsL3kk2+2nYnNAflwfTz2T5KS0SjqJgOnXqZEUdzz//fKKrgWm1w0KPaHQNdisBv4dIhBszRlESPd6EEPGG1Cl+VkZMVgo2oHgoscHQJzLJa8nnn39uVdRYityULlE6JBxFUbvYfv36WeqDbvxJBL/Z4sWLvd12280igGFV5OGtpAcZk2bSEC0QIml88sknVvgGbEKzzbIvN4zYQ7Diz07quD1sAAQz8HZSECNKj4SjKAoE1YknnmgROdrTJA2EIgstxuowPTL4Hjt06GBinek9pLmEENGHzeeyZcvMX0iv1rALCmkq7uZes44krfUX6+OaNWvM14gfX5QeCUdRNETiSKmOHTvWZoEmAaJ6LPSkc9i5Itii0K6lffv2NhObxr4Sj8kC/9kJJ5xQdA8/ER2w8LCOMCiANZJG/1Ep0qBYBkGL59F1i4g7rInTp0+3TTZ2AFEeonEGi9hH5ZhlzYI4evTo2LcTQfxGdTFFwNLYlwiom4sddgRDlAauH6JBUREWonhWr15tVh6yFhS6Ran5NGsJ3RsQkKx3cfep8/pJUdP0nClnonxohRIlAcM1LXpoHcMOAU7GlQAAO+dJREFUO66QSsI4ToqDxT6qPiAWRwQGIpcWQVR9i3jDuffmm2/aRxFvXOaFIQGIGCw9UV23EY9skuNeMEMrKwYz4LuPQoYoyUg4ipLB6D0WocmTJ8dSyNAkl5031YeIRqI/UQeByzQEBAce07hHe9MM5x/XDR9FPOG9o23XjBkzzDvI5i7qPrudd97Z1u04rHe5oHAQ+06PHj28Ro0ahf1yEo+EoygpXbp0sd31qFGjYpf6QDDSU41FlGKUOEBEFN8U/immUDBtJmlmdyHiwObNm00wIv5p24U3Oi7Qm9ZlWJi2Qvo6Tq13xo0b57Vo0cI78sgjw345qUDCUZRcfPXv3998PRTLxCEChsB1hSZUG0Y9QpAJvin8U23btrUFP0o+KiHSwNq1a73Zs2eb8DruuOOq/cdxg/WalDVdMuLgnSa1/uyzz9qa3atXL619FULCUZSc3Xff3evTp4/1P2QRivrCQ3qaVEec/T1AioabFosofwsjzaJY4CNEUnDiiiwLUX+6HtD9IK4gvA499FBv06ZN3rx58yItHhG5NPlmQMPAgQNjFeGNOxKOoiyQNmAkIX5HKguj6kdC2JKaIT0d1UKYQqDA4uOPP/ZeffXVWPpN0wiCv2XLlrGLeKcRRMuqVau8adOmWcYCawuFMEmIeCGC6dpAw/IFCxZENmuEsOX1EWmkobqoHBKOoqx+R8bljRw5MnLTTkjpuoa8eHuS1juP2awdO3a0jxTOEH1U0UW0QXwceOCBsfHXphU2mqwdZFQYuZrECt4999zT+vOy+Yza2g00+KaKmvnbtCcTlUXCUZQNKgrxO+J7HDFiRKSECykYFnxmt1KVnEQQIG5hXbduXSRvAOInsBfwPsXdMpFkiN7TYJp2O2w4mYOcROHoWn6x+Y/a+kjLHe4n+EhpmC8qj4SjKCv4fQYMGOCtX7/ee+mllyIhGIkYuJmtu+yyi5d0mKDQtWtX80CSdlq+fHnsKt7TwNdff23pNz6KaOHStbSsIcpIb0a83EnHRb8XLVpkPvAoZIro2MH7wX0lqaI96kg4irLDiDyGzVOpR6+tsGCx4fdT/Rhl03c5cP5NUvMrV670XnnlFUv3CCFywzrBRos2V6wfbDRJ4ca552GhAQCGO3AswmTKlCnehx9+aKIxafaiOPF3Yb8AkQ5atWplLSuogsM/U+l2FSz6GKmJfGL8TutYN5r9durUyaIHHA/E4+GHH27PCyF+4tNPP/UWLlxomy2GG7CGJKH4pRDw3hLtY8gAUT6OR6XBU0oHDJp8aw51uKTz7ilCgagjaR78KZVOx5FqoVcjjXnTXoFH+onjQKqetD03SCHETyxZssSijEQWSUsfcsghqd1sOugVy4NNZ6U7NVDhPWbMGNvk4tsW4ZLuK0FUFIpk6LeFv+65556rWLoYIzuikakCpM3FNvBoUXntdu/Lli2zBVqEA5EcChHk2woHIoqugI9uBBSV0VRfKdGfoFclqXoCAJWCzS1NvvFoq8l3NJBwFBWFGyOV1vRAmzhxYkV6hLHwd+7c2abCiJoQRWEhRsR/9tln1maE3paqwK482AVo4C7bQOWhiTTjAok0AhtMNlQSKbXh2HBcWC/oAlBOSI8jGslQEXRIUq/dOCPhKELxy/Ts2dOKZUgHlYv33nvP+heCmirXLyBpgs7caxZpbqL4u4RIMmQj3GaJjIi8c8EhizN//nzr9VgOCCowtpZimEGDBlnEUUQDFceIUCDdwXB6JsuQFmJiRimhchgj969+9auS/tykg/+TNNQHH3xQPa6QaCQPbqyifDDffdasWTa2Lmq985II5zcbJEbVUTBH30IRHHpY0nOUFlJsOEudvqZfJht/MlQMkhDRQXcCERpU927evNl74YUXLJ1cqt0+O1RSTowAa9asWUl+ZtqijwcccED1vxGRK1asMBFOul/pu/KRtjZRlYbUJ+sDQsQ1yN91111TX/hSCKwDFNkhHOfOnWvDFBhXWAro+MC4VPrPMjtbRAtdLSLUheeUU04xz8wzzzxTkupefga7VIQPlZCieGifxM2V40qEhpZGUZ1fK0QuQb569WrrX0pVMNkOVyAm0Vg4HDtardFerVS9LckWkaLm57Zr164kP1OUFl0xIlRIf+Jf2Wmnnbwnn3yy6DY9+GConi516jvN8N5gLSCFys0BbyrFBELEAfrHTp061foAsgGik4D8cqUVj0QeGzRoYBFdfKOFQlcHimHwwZ988snKbkQUCUcROniMBg8ebJ6jp59+uqBZvfQV27Rpky00SqeWB6ZmUEDToUOH6nFrWAK4MSsCKaIEAsZ5dIEUKoKRDRBTUER5wFfOZK5CxCPfQ/CAdea0005TJDjC6J0RkYDF4owzzrAKvdGjR+clRIh+EQXDuyTKD8VMroUPUzWorJw2bZpNoZGALBza8CBu1I6ncOjDyGg8Ioz+1jpExHRcyw+ecgIBTHhhbQgKvX2feuopWz+4D7gZ2SKaSDiKyMAC369fP/MgMZM0CPQSw5hNRIEUtagcRAQoLqD3IMVNztAu8VgYNP7mOKoBeP6QpaD9FoKRqBe+XJpVi8pCn0WyEnyk1VoQ6xEb0JEjR9paTuaJlLeINhKOIlKw2J9wwgmW7kAQ1gUGd3qwEa1M8/zpsKF1DO04GM1GJTvRSCI/S5cu9b755puwX15s4FhRgKRj5uUVqXKpaSr/KdKg2T9TX/DmisqDDxrxyAaovh6PbDIZBEGUmPQ0gl9EH7XjEZGDGcqIQhYUGnfTLyxXYQ1eOyKNitKED5ECFy1g8gxtfLgh0BuSKncKE0TdIgi7RZMmTSzdJ3KLDQQJ06e++uora9nCOtG9e3etAxGB94NMhOv9SlQx28aeKndsRr1797ZNp4gHEo4ikhB1ZEYpPR7ZwfobeeOdYWHCs0SkUUQPqla5oTNdghs8aSt65x1++OFhvzQRY8FIqxbOJ6KynGP0+HOFcBKN0cKJRorniAYThfS37KHZ/cyZM03wU7Qk4oOEo4gk3AzYhRKFwf+CYZoWDYhGRAhTCkhHiWjfOIieIRipeHc3EnptUgVP9TuePiHqguyDK8iihyiRa9YCTdeJB7xPBAEY6+j8j9iQ8LFjb2nbtm3YL1HkiYSjiCykNk499VRrDs4DDwzpTyILMr7HB274rn0PIP5JyZLGRhAgIEvZQFjEHyKKVOkTseZ8QWBgg6AhtFptxQsyQwhGNvxvvvmm2TAmTJhgliS6CIj4oWoCEWmIUg0cONCqpocNG2YjCtmhql1DfGG0JOkpCmqwHNCYGYHgqmPTOnaPcxqfV9rPbdo7EY0ivUk6muvdRaYlGuMJoh+hyLX+4IMPWnsk7Eh6P+OJIo4i8pDaYK41VbrLli2z6AOCQ8Q7mkzRDA8aNTvj/PLly80TRWsmHkQk0wLndNrGZLJJoA0LGweyCBwDUtFEqBs3blxtbxDxh6kwZIwYINCrVy+Jxhijq1JE3hDPAnPwwQd7119/vTWJffTRR71zzjmnRvpTxBd/hI20NSAkKIRASFBQk4Y2HbQw2rJli3nCki6YEBFsEPC6EmWmdQ7pad5vPLEiWRA9ZpQgvvT+/fubdx2rSosWLSQgY4hS1SLSN1L6ObqJMKQ7zjrrLPPMIB4pshDJgveYOeOksvFFEXVyrWlWr15tTcZpxULfvqThCr/ymbgRFxCHbAa4pgH/IiKZ4inatnTp0sX6sYrkQRU8HvWmTZuaaMSjznhBnn/77bc1MCCGJHtbK2ILwgAjNQuMv3qSyATicfjw4dWRR3xQIlkQhcDXysP/HB5XRAc3HyrruRlJcEQTeiwyDtTNkUcg4HMjU4DHTQ37kw+pabJEbBAGDBhQ3TKJc4AWPPhZeY6sgiKP8UFXroik74l2DbThaNOmTa22G7/4xS9MPOJ9VOQxPZDCxOvKA+sCqU03OWTdunXewoULrV2Le05UFlquIOpdcdOiRYtsfCiCkX6L3bp1q7aXSDQmHzIETz75pNlPKHDMtF/QSYHhDWSUOE9EfFDEUUQOZs0iBhGNuaKJVFmeffbZ3mOPPeY98sgj3plnnpkKH5zY1t4D4cjDQQqUqBYRDmCzQTSSAhtRPhDqHHciiy7Fjt2A44+fDf+qGnOnD4rcRowYYZs9RCOb/Gzsu+++ttHI9f8imkg4isiBIEAE1jeijhvUueee6z3xxBOWuh48eLAtRCKdLX54EIVEyPBwUS08kVTjU6FNWpuPiM+oRb1I1VEcEsWUHdYRxkiSBcA+4iYAcVy58WMpoCKca9b149Ss6HRCy53nn3/epn3169ev3kIvrlsH163fniKiSWKEI4vZvffe682YMcPae7CIXXLJJTVG1eUCc3YuGGl3++23V++u2T1l4w9/+IMZvEVhkM7iJsQOlWKIoHONSVsTecRHQ/Tx9NNPt7nIIp1w7pAac9XZQNQLsYjoIZXKuUYbIPpIIogQlvw/QidM0cZGiHRu2CAESfcjYilqmTNnjolGjhtim9fJ80SJ2rdvn/gKcBEcPIvjxo2zjcUpp5yS1+aMqDXTZai0JlsgoksirngWuquvvtrK+wcNGmRpktGjR3tXXHGF98ADD9S4iWTj2muvzZouHTVqlN1cMmEGLyZvP1SCiuJ2qXhieO9cFW1QuMENGTLE2j3gqcGE3axZs7K9VhEviDK6AhqEItW8TiCy4eRmB6RU2YggjCje8M9FT2K61bW6cpN8KGbhwb+xgtAvFXHIsWNDh7jmeb8YkGgUDjYYL7/8snfMMcd4PXr0yHsThv+VbBN+R643CmpENEnEVT99+nQTHjfccEP1CKPOnTvbfGP8b9ddd12d30/rj0xoE8CJny2KyMmd7XtEYbBQIBrxRNF+pRBIjxFtfO6556z1A6MKMeQL4Ycbkt83ixhiggViEhGJcPJPrpk1a5ZF39jMkN5GWDLdhX8jsPhahGUpPFpE9d544w3z9iJei4XXjbBD6OEZ5kEqn9fN30mKkKbbZGjoqcjfx82biL3/9x922GFFvxaRXNiAvPrqq3Yfprk3995CI/ecj2zuKKziWq0v6CPCIRHCkZOWm4E/5cwNgerLyZMn2wKazxxcvp6fScUXLT+ywQLMoixTb/EmaiLFiDy/16UQeD+YZz1mzBgTkNwQW7VqVbLXKpIJawOCKVtDeUSci8QhLJly4vrOce66UYnc5BCQpNiIzvH1/B/Pc17yIGXu1hPEG4KOG6x7IEJ5nvOWNYjfw4OfwTpDeph0O4VA7sH3ucgMPS75fqqbefDzmO3M2kjDbdL0vEYEor/VEf9PFkWIfOH8nDRpkkUbOYewLhQL2TtnIZFwjCaJEI4s4EQBM/0U+BzxW7Bg5uOZwGfBwp/Lb0Qhxj333GOLNh7K3/zmNxaerwtMv/62Ma76M+0Q2cDTUipfIudAnz597CbNe89NmFm3QhQCG9BcYw9ZXxCJTqjxcDYLPieK5wQeIo40rxOOeLFdM2wHEXdSxnwvkU0HaxfXCMKVtcl/ruPL9Kf0+Df+YM5/FyV1rzVt4wxFeeGcHj9+vFk9Tj755Ky2rkIhyu02aIjIJFpF4kwihCNRABbdTFyBBYItH+FIlJIoBB4fPyzUXBxENtmt0zuOlgNXXXWVd8stt9iki1yMHTvWBKfwqt8T3h+KFEoNgh6PDTdPdsOIRywMUaxWFfGF6F2umemsD36bCzdZ/7QbIpkIR3dz5CNRSYQljZHZULlIpBOjCFiiOnwdN9LMjTIZEiEqAecyldNLly71+vbtm/X+Wwzu3GezRDQTz7FGzEaHyAlHFlhSMkFA3HFyIQyypaLdc/x/UEj1cKKysBMh8EOLmNtuu63Gc/ijaEZ911131Skce/fubWkjf8Txpptu8tIIUZV33nnHKtYL9TTWh/OnIh6nTJniff311yYmo9aCRaQDzjv/uZetPyk+SyKNrDOZTe/dz8i3cEyIUsP9dOTIkTYyEGtQOSPZXA9smJgiRkFq0G4bImXCEUFBNXQQHn/8cUsVIQ6yTYtwz/H/QcHbyPcFbYtBZABBQjUvPqJcnsjM8WlphfQd7zHptXKJRj94brjZTpgwwcbVsdDlcz4IUSm4SWKr8KephYgSeGxpfUYhF31zDzzwwLL+PjZLBBgQjhSOEZzRiNHwiZxwpEDimmuuCfS1bvfB7j3b2Dn3XD67FNLU+ILy8cU5sUhYPZdwFNv6YFKtjuG5khXPFMiwa8VW8PDDD1u1fbaIjhBhQgpaERUR5U3/008/bYVaQ4cOrVjq2FnE8Pfip6ToVZmjcImccGThJIKXDxTGMKeWNLf/hMJ/gQcpaGUWBSwImxNPPDGvKmy8jiAxUr9wZD4pfphK+w3xuFLERGSY3p607tE4OhElKIoh/UehWC7vpBBhtUx74YUXzJNOr+RKR8Xx9GIfo5uJRGP4JOIdoIiFAhkqFf0h9WnTplnk0C8C2TXxyMYrr7xi4jNXmpqfma3b/cSJE02YKBWdHVcUgMEZA39YRSrskBGPRB8pVGJjIUSUvGMrVqzIy5MtRDmhaGv27NmWraGDCFO6wrJSEJGn7oB7tGs9JcIhchHHQqBilikvVDa76SNMjuEEO++882p87ZVXXmkfuRCypakRf25qRCa04EF0kvrk6+gzRbU0kYLLL7+8TH9dvEHQz5s3r7qpcdiVzdgQWPw4P5g0wyaBzUXYr0sIIaK24ccbTnqYTiKkiKOwTtKNAL86Rays3ZqJXnkSIRwJYw8bNsy7++67qxs/04Eer2TQptJU+jIrmXF1uULh+CxISxOyx8+ICGEmJ1XVQWZipw0itBiaEfJRMvzj0enfv795Y9ks4IWlD5l6hQkhxLYBFwRXuC/SFzdKrZ7IIFIk89prr5l4pFuJrB2VJRHCEQhhM6+aR11kizQCAtOf6s4GPdQ0YSEYVN1hZuZ9oTl61ESZa9eDp5ZG4YhcNg1agIQQaYZoHl5wUsFnnnlmJGdGs04jHkmjIx4Zdai56ZUjER5HET1fDOkNUgikqKN8QbOTZnGkcOehhx6y1LoQYUVS2MDmU5gnRCkhwvjggw+azQs/eBRFo4M2a4hHil+jfI9JIhKOoizRPHygNGyNwyxvFkfaS+Dpuf/++82yIEQYN0I6DqjJtwhjs4+tiKJB/PuIxji0hsICddBBB9nn9FEOOjxEFIeEoyipL4bm3ggwUtRxipywWF5wwQXWUJ5eZVOnTrVdtxCVgusG77R/NKEQ5YaaAIpLX3zxRcsQ4dmPW8EJBTO00qNRuK6f8iPhKEq2+OA1oT1RXHd9+GboUYaPddasWTaZ6Kuvvgr7ZYmUwLk2ffp0nXOiYrBe09eWNlB4vBmhGzU/ehBIVeOlx1uPeNSmv7xIOIqiYUQjopGdHp6TOBeYkGZnTCEte1hU77vvPvP9CCFEkli0aJGJRrqInH/++V6LFi28OMMoQsQjxT1vvfWWxGMZkXAURYFYpHqaiCOiMUptd4r1PV544YW2GOH74W/EBySEEHFfsxlaQes62tbhZ0zK8Ap8mbTNwzYV18xXHFApkigK0hqMEWRGN30tkwQ+TSKP+B1feuklb82aNV7v3r29HXbYIeyXJoQQebNlyxZv5MiR1kWC3rWtW7eORFPvUk8Io2E5fxfikTR20v7GsFHEURS8a6WKDahqYypMUoVx9+7dzf+DD4jUjvu7hSg1msMrysX7779v1hsKsJioRmQuqYKKv4tUNU3CFy5cGPbLSRxapUTecEHOnTvXRgnib0wD+H+ouubGjnikelypa1FKmLBEFIiPQpRyvX711Ve9J554wrJDWHD22WcfL+mwVh944IHmUV+yZEnYLydRKFUt8l6EEIyM6aN1Q5xa7pTCP4MfiPmtjJ1877337EavvntCiCjCQAPWqo8++sg7/vjj7ZHUKGM2aA7OPYuoI9kjPJ2ieBRxFIEhwrZgwQJL1eKNSYqhOh8Qyn379rVZ16SumY9OCkiIYqEND2NP1Y5HlGKtZoN/77332vl07rnneh07dkyVaHTQm7dly5a2XtOuRxSPIo4iryar+GOOOuoob8899/TSzKGHHmrj4caMGWP9HmkD0a1bt1hMyhHR9Q1TvKAGxqIYEIpjx471li9fbms1vRnTXtBHypqiGQoeRfFIOIpAUJ2GKHLVasKzgqAhQ4ZYw9nJkyd7K1eu9E499VTzEQkhRKX5y1/+4o0bN84+P/30071f/epXYb+kyOBEIyNl6TVMJFIUhoSjqJd3333X27Bhg4nGOE4VKCeIaLyeTZs29Z5//nnvwQcfNB9Rhw4dVCErhKgI9NGlZRhj9xCLtA1LSk/dcgRBiMZyL9t3333DfjmxRMJR1AkXGB4+UrMSjbnB7zl06FDzqDE2jsIZvJAU1AghRLmgapgCmK1bt3qnnHKKd+SRRyorVAfcy7CD4Ndnc68MUf5IOIqcIBgJ6x9yyCHeAQccEPbLiTwI606dOnkHH3ywRR8xpuMvatWqlRZyUS877bSTnSt8FCKI55xN6uzZs616+KyzzrJJV6J+Dj/8cKu2nj9/vvk/tcHPDwlHkRV2r0uXLvWaNWtmDb5FcEh/XHTRRd6kSZO88ePHWw+xnj17anESdYKHWNEPETTKyNpCW7QuXbp4bdu2lTUmD9jIE5nF9/jLX/4y7JcTOyQcRVbwx+BpTOpEmEq07UEsEq1lgb/nnnvM99iuXTsbgSVENp/a2rVrrTlz2qtgRXaYwTxlyhRrtcMG9fzzz/f22muvsF9WbMWjC4rQpocIbqNGjcJ+WbFAdzBRA25cXEQIHonG4qFo5pJLLjHvI9MbFi1aZIKySZMmYb80ETG+/fZbi04TmZZwFJl9GVk7Xn75ZRM4DB7A1qAoY+m8/Bs3bvSOPfZYpfsDoLNOVPPxxx9bVR6RD43TK20KknQS6Wv8a8OHD/dGjx7tff3112G/NCFEDKa/0CsW3zQbzksvvdTmTEs0lg7S1gRK3njjDTUJD4AijsJgGgzpj8aNG3tHHHGEijnKwB577GETHDBk0/eRXW737t11vIUQtSCy+Nprr1m2Yuedd/YGDx5shXei9GAfYojDnDlz7IFnVM3CcyPhKGxaxdy5c03Y/PM//7NETBnh2JJiotcaxTNEHmkLQfo6jSMchRC1+eCDD6qLXxAx9IbVVKrywvElVc29ENEuciPhKGxnRfU0fjylPyoDEQSmzBBtnDBhghXPtG/f3gpoVDyTTnjfGeWp9z+9YF8hG4FliBY7F154YerHu1a6qJECRqBdD83C5TeujVaolEcaoWHDhkqBhARi/eKLL/ZmzpzpzZo1y6KPXbt2tSa1ivymr5MB6TKRPohwMbqUtDSQgVD/1/AnpmHhIuLLiELxExKOKeXLL780Lwc9rAjPi3BTJJ07d7boI9GG5557zt4bmodrnmp6IMKBgCDiqMh/OqAIkUr6qVOn2kYesdixY0eNC4wABx54oLd+/fpqz6Mijz+h1SmFfPXVV3Yx7LjjjrZQiWhAG5ZBgwZ555xzjv37kUce8Z555hnzOYl0bOZot8JHkY4m3g899JA3atQo85eTeaDNjkRjNKADBoKRdPXrr79uH8U2JBxT6KFBNOLl+PWvfy3DdQSh5QaNffv162c73rvuusubOHGi2vcIkZD2OiNGjPAefvhhm5l89tlne6effrq3++67h/3SRAaIeO6T9FhF6IttKFWdMr7//nvza9AHDPEoognepsMOO8wasbPbxQP5zjvv2DSfNm3aqIBCiBhOfWEIAFW7CJK+ffvazGT5GKNfPMq6S4ZObEN3nxQJRsQGnkYqd0U84D2j2po2Sdx08EJx46GhuApohIg++Fa5Zrl+8bHiYcRXrmxPfHCikSEZH374ode6detU+5AlHFMiGklPUz1Nh3wRP4hQnHTSSVZ1y6xaCmhoDkx/N3pCSkAKES1IQ9MlgWwB00jwk3O90opLxBPE/saNG7233nor1eJRwjHhOGMvHg0VwsQfmoRTQEOD4GnTplnxzF577WWpFNLaEpDxhZFnPXr08H7+85+H/VJEkRFG+jDSXgvB2LJlSxOM8jAmo4Dx6KOPtggy7/FRRx2VyjVXwjEFvcEoqqA6TDvd5ECbHqqvEZCkwDDbU5mJgGzRokVqd8JxhhuQvKvx3qQzThTBSOcKPMrYgiQYk8Uee+xhQRiijkuXLrX1Nm1olUowa9eutR0vVWFEM0QyBeRZZ53lrVmzxgQkrT2ISiIg8UBKQMaHrVu3eosWLTLBoZYs8bICzZs3z5s9e7Zt0nn/uP6ITolkstdee1mqGvtXGpFwTLioYLdLPyqRbBhPNmTIENssICCff/55+0jEg8pNCch4ZAjwT2lObnwEIylLvMZUTNPAn+utUaNGYb80USHx6M6Djz76yBqGpwUJxwROIiBd0rhxY2/vvfeWaEwZ++yzj3fGGWd469ats/Flo0ePriEglQoVojjwiyMYKTj87rvvrOCQzge77LJL2C9NhMDGjRtt+g8Csnnz5l4a0F0kYaIRwy5No/fdd9+wX44IETYNFNHQPgIBOXbsWGvlQ3qFB73JhBDB2bRpk/fGG29YP1UqpimMQDCmNV0pftqss5lgtjWFbQcffLCXdCQcEyQaFy5caJEmFrQ999wz7JckIpJOGTBggN30KJQiSoJ5n0pPGomz6Akhcq+rK1asMMHIR7ynFBpSHKHNl3A0bdrUNhN/+ctfTDwmPW0t4ZgQWNRoTEqjaKJNQvihYIY+kJ07d7aoNCKSjQaRaQQklYFqAxN+k2EKKzShInxIQdODkeuEWfGsqUx6YcMlu4fIRrNmzUw8puH8SP5fmKLiCPyMiiCJumDcJFX2iMX33nvPIik0E580aZL1JyOSoorecGAEKHPKRbhzpBGLbK5or0Nv1D59+tgGK439+kR+HHLIIdWf05IpqS3wJBxjDn38SEciCCQaRVCosmbiDI9PPvnEBCQTLvBD0sYHYUmBlagcCJUNGzaYzUTj6Cqbjl65cqVdA2ymiPgyoYmNlNqYiULYsGGDFVCxEU/iOirhGGPef/99M+S61jtCFNrQtlevXjb/2qWxSdOxIaHFCNXYikKWH3oAcvzpAaiCi8pEFyl04fH555+bYOc6wC4g4S6KXVP33ntv6+/JBiRpNQcSjjFl9erVJhqp4JJoFKUAq0O7du0slU3khRsqc7EnT55s5xltR/DxyAsp4uxdpHUKGyM84TvssIP5Fjm3sfsoHS1KwXbbbWf1Bj/++KNNmCGCnaQJQhKOMYQpIUyYoHIrLX2jRDhpbKJgixcvthvts88+W13AwY2WFIxutCLqcPNetWqVbYQYEUeDddbOfv362fqp6KIoB9ttt511OCFljRVCwlGEDiZ6dspClDsKyW6ZB15Ibr5UY5POJh2DgERIqjWJiBq0oHKpaEavulGc2C/kXRSV2oS3bt26hp82CZttCceYzbLFa0ZKhYcQlQSh2K1bN/NC4q/lhvzKK69YKps+ZrT0IUopP2RhYAFg+oisAIWzefNm66VHOpoxcBQNUuzFBofiwSTctEW8+Pnfrmfu30QfiULGfeMi4RijsUZEedwCKESYu2g8jzyY0ctNGuvEuHHj7LH//vtbCpDWFL/85S/DfrmxgdYdTCIRwSGCQyScFDSCkUlJ9NEjFd2/f387D9PQV0/Eo93Wz372MxvCgJc8zq16dEXFABrQslPBI5HE0n4RX/A8ujGG7KiXLVtmN3GKal5++WWrzEZA8uD8VcRHlEIs4vNGKHKuEWWkyIXCLWayH3TQQfZvIaLE9ttv7x177LHea6+9ZuKRCURxzc5IOEYcFkUijY0aNbKbMzsWIaIIiyBpGB5Ur1KZzc2dhXLatGl2DiMgiQKpoXJttmzZYn001Y6nNkzkoMCF84kHzZU53ziXeBxwwAGKLIpYRB1//etfe7Nnz7b7eseOHWO5DupKizh4yfBD0AtKolHEBSI+eMt4UMXKTZ/oENXZLJqkafBFcsMnrRh3z48ofVSRTAvVqJw7PL799lvzgFKMxQaEzYfWRBHHtbFt27bWsSKOohEkHCOKq76iFxSfyzAv4gqRIOeJpDUKaUZS2ogCCmxg1113NQGJkOShec3pg8pnv1Dk3whDBCIpPiKLNFKO681WCAdFWzy4t7MWsvYRjYwLEo4RBK8YTUNJ+anNiUgSCAEa1rum9ey6nVAguo6XF2GAN5LFlAfFNuq1lzworGKQgROLtM8B3nsi1WwgOE/idEMVIh+IotOInhGFRCHjss5JOEYMbqR4wojSaMEUaegTST9S15MUn58TEkQjSWsTbaf9FAKSjgKM8tKGKl4QWWGs39q1a+3xwQcfeOvXr7fn8b6yQejUqZOJRc4JIdLAjjvuWF0ww6x0Po+DVzf6rzBluw+qrbhRYqBVZaBIGxSFYM9wFg2iUE5IMveV4hHAE4mIdEKSB6mfOIMY7ty5cyLS9BSvrFu3rloo8jmbYqBFE5sAfNsIRhUCiTTToEEDu98jHimYadOmTeStaRKOEYI0HTdLQtZxvwkKUSykrGnhw4PFlGsD35tfjMycOdMquIHJIAhIJyhJecZh9+5P48exPQcbXqKH7j3hI5Fj4O/hPWHykBP5cfwbhSgnDRs2tDWO6ygOBV/xWVXrgKjEqFGjqpvA4p258847LWqRT4Pt//3f/zXxhoGf773ssstsoctk/Pjx3jPPPGPNZrmp0WiWuafFgq+H9HQSIg5ClENIssDyYEoNuKikP7pFQ3Lat7AAU4WLoMx8RPEaIyLH+kURSNTStRxnoogc68yHE4msXayXrGNOwPNeqZhFiPrBssEDuKbIQERVRCZCOFKl+dRTT1n1HakPbhz5LthXXHGFFaUMGTLEohQjRoww4fjwww/XSKWMGTPGu+2227zjjz/eGzhwoM3tRaSy6x48eHDer51WJVRVUXHKTU4IUVhUkhnEgGjEbM7u3Ymbd9991zx2CCAg6kUld6agJI0a1mL9ww8/mPClTVFYsB7ROzabQHSRXY4PNziOF61xOPYIRY5nVG90QsSFH374wdLWjHilQDaKJEI4Mh+XKCBegenTp3vXXXddXt8/evRom2t63333WX8wIGx8zjnneM8++6x3wQUX2HMsnA8++KD5EW688UZ7rlevXhahfOyxx7zevXvnbdpH5PK6Eb1K4QhRPPiDnO8xc0H+7LPPaoghxOXixYu977//3r4G4UOPSa5j9+D69P+bB1aSOEXSEMxskL/88kt7kPJ3n/uf42ucuCYqizjkBkaEl88Rh5qnLUT5oLKa0cJ4uikQjGJ2JBHCsdi0DmLTzdZ10AYCtc/ECycc58+fbyHkPn361Pj+vn37epMnT7bClu7du+f1u4lyduvWTaJRiAosyPQB5OEHoYRwQkgiLP1iilYZfHSFHf6f5UQk6w+FbDxI1/o/5vqcrAbC04nPbCLUCTg2pnxONJDNKw+Erv9jrs9ZX9zfQiTWwe9jzXGimLQyayD/dtFE/q44iWMhkkLjxo3NLofmiGIUPxHCsRhYlKnaPOmkk2r9H0ISzyM3DRZRRqgBC2xmxJM3d/ny5TmFIzclJiE4VqxYYR9Jg3/yySf2EEKEixODmSC68E7j82M9QJC5j2wmEWo8iGq6B2tLPvA9REDZhObbz40IIN/DA3HqPndRQ6qYEYo8WMvqEoXYbsjACCHCpUGDBiYewVlFokDqhSPpGRZ8UjCZuOcQfSy8CD8W6EwvIgs0b7BfGGYyduxYb/jw4bWe/+///u+S/B1CiGSAP1MIIfwQuDr88MO9KBA54cgunZ13ENhZF5tKcSo+2w7fNeB2X8PHXO09+Nq6dgT4H9u1a1f9byrAb7/9du/qq6/2DjroIC+N0AT4pptu8q699trqSSJpRMdBxwB0DLah46BjADoGP2Un//SnP0XqGEROOGIGpcI5CI8//njRB9M12c4mVp1h3n0NH/EZZYOvratht6vazATRSKo7zfAepv0YgI6DjgHoGGxDx0HHAHQMthGlaVmRE46khK+55ppAX5stvZwvpJiJFmZLM7vnnODj9+F1ol2FP12N6CTlXYrXI4QQQggRVSInHBFfPXr0qNjvo6iF3o803s2E3m+09HBV2/RaBL6WljwO/k2K3f2/EEIIIUQSiV6ddwWM53gn/NDMG/HnF4+04Xj77be9jh07Vj9Hex4ilDQB98O/6evmF5NBBDJ9ItMcpdQx2IaOg44B6BhsQ8dBxwB0DKJ7HLarcs3CYs6jjz5qH1evXu1NnTrV2uvQCwnOPvvs6q+7/PLLvQULFngzZsyofo62GkOHDrWPgwYNssppJscQRWRyDNMkHC+88IJ3xx13mKBk/iqezJdfftk7//zzvTPPPLOif7MQQgghRCVJjHA87rjjcv6fXyRmE45AH8XMWdWXXnqpTXTJZNy4cTZRhp5rTFWgAfhpp52mZrlCCCGESDSJEY5CCCGEEKK8pM7jKIQQQgghCkPCUQghhBBCxLMdT9xhPOGoUaNsMgxV2sy3vfPOO80zGZSNGzfW8ltedtll1hook/Hjx3vPPPOM9/HHH3u77767179/f69fv35eFPjyyy+9e++91/ykTNVh9vcll1wSqJlrXZ7V1q1b29QdwGc6cODArF/3hz/8wevSpYsX12Pwxz/+0XvppZey9jp94oknajzHecJ5MHr0aO+zzz4zb+6QIUO8rl27emFT6DHgb6Lw7NVXX7VxW/wcCt46d+5sRWyZDfdznTMXXHCBHYtKwCCAhx56yJs0aZK93qZNm3q/+c1vvKOPPjo1132hx4D3+ZVXXrF1k3MY/zidKihuzGx+PGDAAPvbs03o+rd/+zcvzseBgsxs42npNzxlypRUnAu53l/YZ599vKeffjpS131dUHTL+0N7P3QBx4Fe1UHbDuazfs6aNct75JFHrHMMRb0UCZ911lk5J94VioRjiVmzZo331FNP2Y2b/pBLlizJ+yRjcs7WrVvtpOcNp8KbGwgLSsOGDWu0AbrtttusnRDiaeHChSZSv/32W2/w4MFemHDjY5zi+++/bzd5Xjeihr/tgQce8Pbbb786v58xU5lwQ0GUZ1t0EEjHHntsjedatmzpxfkYuJvFVVddVeO5X/ziF7W+jp/35JNPer169fKaN29uC8gNN9xgBVthiudijgHn8S233GLv4ymnnGJN97meWBjnz59vc94zC9LYVJx44ok1nqtkf1Ve7/Tp061YjjXgxRdftPeP67KuObNJue6LOQZ//vOfreVI9+7dvT333NPOGbpYvP766yY+MjcKvK+Zm8ZsxYxxOw6Of/3Xf/V23HHHGj2HM0nqucB5T9DFD0LywQcfzLr+h33d18WWLVtsI8A5zaQ42vyVY/3kOvnP//xP78gjj7T/X7lypffYY4/ZwBLOpZJCcYwoHVu3bq3asmWLfT5t2rSqDh06VM2fPz/w9z/55JP2Pe+++271c6tXr67q2LFj1X333Vf93LffflvVs2fPqquuuqrG999www1V3bt3r/riiy+qwmTq1Kn2d3AMHJs3b67q0aNH1fXXX1/Qz7z11lurjjvuuKoNGzZUP7du3Tr7PU899VRV1Cj2GNx88832XtbHJ598UtWpU6eq22+/vfq5H3/8sepf/uVfqk499dSqv/71r1VxPAbff/991cKFC2s9/8gjj9jPnDt3bo3nec5/DCrNkiVLap2LXKeDBg2quuiii1Jx3RdzDLKtky+++KL9vHHjxtV4/rTTTqt1DKJEMcfhoYcesu/lOqmLJJ8L2Rg+fLj9vMw1Iezrvj6+++67qk2bNtnnS5cutdc7ceLEqlKvn2eeeWbVueeeW/XDDz9UP3f//ffbPZO1pJTI41himDJDk/BCYXdGxIhwtH9WJ83Hp02bVv0cERd2Mn369Knx/bQGYqc2Z84cL0xIOzVq1KhGGoHQeadOnSwa5uaAB4Wv52eymyKFlQ3+7mwzx+N+DBhzSSQqF/wsZqjz3juIxHFukP7MN+odlWOw/fbbe4cddlit5zt06GAfMxv5O0jn8Ajjb6UHLOlSB1Gyk08+2d4Dhg+k4bov9Bhks/O484b+vNnges+MTEWBYo6DH677XI1PknwuZIM0PVaVbGtCmNd9kKxRoc27g66fXB88yDj509KcC5w/rC+lRMIxQhCWJrzMDSQTbihr1661lBbg+YLMr8X3QEpj+fLlXpjw+0kVZKZX+DtIo5DSzwfC8F999ZXXrVu3rP9PKuCEE06wlDXeljfffNMLm1IcA74OLwwPFly8ne4ccHAukNJCaGT+Hvf/STkPAP8b+NO3DjyhpDo5T2jIP3nyZK9ScJxJx2VaCdz7sGLFisRf94Ueg1x8+umn9tE/hMEvnHivue7xxI0cOdKLCqU4DqSeue5Jwd54443V573/d6TlXOBvYaOYy7Md5nUfhfXTvdeZvsfddtvNfK+lvgfI4xghvvjiC9tBZNuduOcovqE4ggWV3Ry+r8woDRFPt+CGBYvcEUcckfPv4PVhlA4KCwE7N7w8frig8LywI+MiWbdunXnD8NHgr8lnDGTUjgFfd/rpp3vNmjWzXeMbb7xh/hb8LniE3M6Sn8N5kOn3858zSTkPAGM8N6M2bdrUeP7QQw+1nThRCX7u888/bzdcojaZUZlywO+s79pN+nVf6DHIBX5x/t7M6x7/OB45PF4cP7xz//M//2M//+KLL/bCppjjQCHQqaeeat5e3ld8i3g9KazA1+aEWJrOBScEswUOwr7uo7B+uvc61/Eu9bkg4VgHRAKCpj4RNcVOjnFhdi78bD/f/zV8zFUpxdeWMmRfyHHg97vXnPn/kM/rYwEg7YJQyKyuxHCMOdwPEQgqye66666SCccwjsGFF15Y498UuXCj5OZBCsMVvfBzgpwzcT8P4PHHH/feeust77e//W2tc+Huu++u8W8qCqngvP/++y1yk1lcUWoKfR+iet0XQinPRcTChAkTbPOUWUR166231nqvf/e739mmkYriXHaWOBwHCkn8MN6WCBNiCAHpKoXTci6w7lBtT+StSZMmtf4/7Ou+nARdP13KOtfXZmapikXCsQ6YQ011UtAbWmaqMF/cCZ7t5uxODPc1fMTXlg2+tpQXSyHHgd+fzb+W+XcEAZHE9+VKU2fCbpsFgypjRkmW4iYS9jFwkJKjwhTx5IQjPyfIORP3Y8AMeqoqSdkHiSRw0yJyw8Zi2bJlgSpZi6HQ9yGq130hlOpc5Fz705/+5B1zzDHe+eefX+/Xs0nh2sCiwkhZ0pZhUuprkrWPjfC8efOqhWNazgXeT7zamYI6Ktd9OQm6fjrBmOtrS30uSDjWAakh+i0FoVDza6bg4QTIFlZ2z5GOdb+PoglK7f2pCi5UUjeleD3FHAcMvXX9Hfm8PiIPO++8s9e2bdvA3+PEIj2wSiEcwz4GDhYAzhPeY//vo8UD6Wx/1DvznInzMaC3IX0tiSDn01rCvff+41Uu+Fu4wWVS3/sQ1eu+ksfAD943zjPS0bSUCtqDrpLvdSWOQ7a/L/O6T/q54NZ/LEn59KSN0rlQDEHXT3/qmixc5tf6i+5KgYRjHfBmBG3SWQq4OFgs6VeYCc1DaQRM1ba/RxVf60/H8m9C+6XsYVXIceD3483htfiNvfh0/uEf/iFQD0Png0EUYRDPFobPBV7HXAUUcTsGfkg5UEnpLxagNxhNgDGP+1M5nDPu/+N8DPg76OuJ8fv666/Pq5mtOw+yFVeUGtejDWuFvyCgvvchqtd9JY+Bg0IgGngjhIYNG1b9d0ftvS73cciETSF9DP3vb9LPhcxuGvmI7SidC8UQdP107zUR1hYtWtS4fyLe/ZXtpUBV1SFCO4LMliKYwLnw/TeRDz/80C5AvC4O2nQQqaABrB/+zQkVZlGI+zsw9tLt3vH5559baxEih34RyM2CRzbwtnDR5EpT8zMz4UKZOHGimYZLFW2r9DHAu5LNl/Loo4/aTcRfGNK+fXsTU/ifHHwN5wIVdZjH43oe0GKCBrh77bWXpS5zpVyynQccPxrGs3kIMqmnWLg+iQCNHTu2xo2Pc5HF3EUCknzdF3MMiIwQTeYGSTPwXDd9okj8Dj+kbLGmkKbMZ0pXFI9DtnOZojie91/3ST4XgnbTiMJ1XyoQeRwHv/0g6Pp5wAEHWEZo3LhxNa4NzhuyUJnFZcWiiGMZ4Obu7z3G2DR2DcD4LMfNN99s/g3/SUHfJaJH3CzpFE/VHIZvduD828ENdOjQod4dd9zhXXfddeYFwhfEaCc8QcX0kizVosHFS2Uzx8F1vEcEnnfeeTW+9sorr7SP/J3Z0hSIv1w3g3vuucfERqtWrezr2JWzUNGq4PLLL/fiegxYLHh/Sc+wIAD+LRZSbh6IRX9aBv8P1cYsOqQlZs6caefc73//ezuH4ngMuAEQfcJuwLmf2ZeOSJwTxVRS0teMxZQbEiKEGxQ3JaYpZDPplxpuhlR3YspncWc0Gm1COCe5ntNw3RdzDChuIVJEMcyiRYvs4eA4uIkhs2fPtokY3AyppOX8YJ1YtWqVteIKO0Vb7HHgWmasJlFohAHHAX8vUaXMnohJPRfq66bhiMJ1H4TnnnvOBLBLMXMO478HirmwYnGcOD7PPvusndf5rp+MIcTiweYL/zstvggm9OzZM2tRUTFIOJYBihf8cCI7/MIxG6RmaLXCzFoWRzez9tJLL621A+dmQ6SJE40TEQHB1wU1EZcTbnykmqh446Ihgka/MU5sJ4Tqg4gLoXdM79nGbQE3E242XCDcQLgAMUNTVR32brOYY+A8nXj7WEw4D1h4uTEiJDKPBxXYVBkjmvl6+qeR3g1aUBTFY0BK3i2u9913X63/x77ghCNNgRcvXmzii4gUERcENDcoNhWV4j/+4z/sBsZmkRsFN38ipaTa0nDdF3MMXF8//xxiB9/rhCM/j8IrRAWChGOBqMLGgFCJCoUeB65ZzmVXFMjPQEyzpnFep+Fc8HfTYJQs62E2onLd1wfvj3/2NiLZCWUKuXL9ffmsn9wvbrrpJutpzFqCyKSQ6pxzzvFKzXaMjyn5TxVCCCGEEIlDHkchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEICUchhBBCCBEIzaoWQogKMH/+fG/MmDE2W5cZyzvuuKPXpEkTm6/cu3dvb/vtt8/5vcy4//u//3vvgQce8NavX+8NHDjQO+aYY7w///nPFf0bhBBCwlEIIcrIX//6V++OO+7wxo0bZ2KxTZs23j777ONt3brVmzt3rnfnnXd6Y8eO9YYNG+btueeetb5/7dq13qpVq7yhQ4eG8vqFEMKPhKMQQpSR+++/30Rj8+bNvZtvvtnbfffdq//v//7v/7xHH33UGz58uHfVVVfZ1+6www41vn/WrFn2sX379hV/7UIIkYk8jkIIUSbWrFnjjRgxwmvQoIF366231hCN8POf/9w777zzvK5du1pUceTIkbV+BsKxcePGXtOmTSv4yoUQIjsSjkIIUSZeeukl78cff/R69erlNWrUqE4PI4wfP77G83gh8UQq2iiEiAoSjkIIUSYQfdCqVas6v+6f/umfvN12281bt26d9+mnn1Y/P2fOHEtnd+jQoeyvVQghgiDhKIQQZcKJwD322KPer3Vfs2nTphpp6oYNG3qHHXZYGV+lEEIER8JRCCEiBKlt+O6776zq+thjjzUvpBBCRAEJRyGEKBO77rqrffzkk0/q/Vr3Na6ABtH47bffyt8ohIgUEo5CCFEmDj30UPs4b968Or/ugw8+sBT1P/7jP1YX0ZCmpuk3jb6FECIqSDgKIUSZOPHEE72f/exnVi1NhXQuHn/8cfvYvXt3+3rS1RTGtG7d2pqGCyFEVJBwFEKIMrHffvt5AwYM8LZs2eL9+7//e43CF0Ag0gB80qRJ3s477+yddtpp9vySJUu8zZs3K00thIgcmhwjhBBl5IILLrDxgkyPGTx4sBW7+EcOfvTRR5aS/q//+i9v7733tu+ZOXOmRR7btm0b9ssXQogaSDgKIUQZ+bu/+zvvd7/7nde5c2ebSb1o0SJvxowZ1p8RWrZs6V177bUmJh34G1u0aFFn03AhhAgDCUchhKgANAH3NwJnHOFFF13krV+/3quqqqp+fvXq1RaF7NmzZ9afw/hBhKcQQoSBPI5CCBGS//HGG2/0vvjiC++3v/2tt3HjxupoI8jfKISIIttV+be6QgghKsrs2bO9ZcuW2djBLl26hP1yhBCiTiQchRBCCCFEIJSqFkIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQgZBwFEIIIYQQXhD+H0cLL/owMD4oAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "polarization = source_photons.calculate_polarization(qs, us, mu, bkg_qs=bkg_qs, bkg_us=bkg_us, show_plots=True, ref_pdpa=(0.8, 90), ref_label='Simulated', mdp=MDP99/100)" + ] + }, + { + "cell_type": "markdown", + "id": "bc5136dd", + "metadata": {}, + "source": [ + "Extracting the informations from the polarization dictionary:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5447d326", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Polarization degree: (84.51 +/- 5.47) %\n", + "Polarization angle: (87.12 +/- 1.88) deg\n", + "Normalized Q: -0.841 +/- 0.045\n", + "Normalized U: 0.085 +/- 0.055\n" + ] + } + ], + "source": [ + "Pol_frac = polarization['fraction'] * 100\n", + "Pol_frac_err = polarization['fraction_uncertainty'] * 100\n", + "print('Polarization degree: (%.2f +/- %.2f) %%'%(Pol_frac, Pol_frac_err))\n", + "\n", + "Pol_angle = polarization['angle'].angle.degree\n", + "Pol_angle_err = polarization['angle_uncertainty'].degree\n", + "print('Polarization angle: (%.2f +/- %.2f) deg'%(Pol_angle, Pol_angle_err))\n", + "\n", + "Normalized_Q = polarization['QN']\n", + "Normalized_U = polarization['UN']\n", + "QN_ERR = polarization['QN_ERR']\n", + "UN_ERR = polarization['UN_ERR']\n", + "print('Normalized Q: %.3f +/- %.3f'%(Normalized_Q, QN_ERR))\n", + "print('Normalized U: %.3f +/- %.3f'%(Normalized_U, UN_ERR))\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "test2_stokesmethod_cosipy_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/polarization/test_polarization_stokes.py b/tests/polarization/test_polarization_stokes.py new file mode 100644 index 00000000..1c14e371 --- /dev/null +++ b/tests/polarization/test_polarization_stokes.py @@ -0,0 +1,104 @@ +import numpy as np +from astropy.coordinates import SkyCoord +from astropy import units as u +from scoords import SpacecraftFrame + +from cosipy.polarization.polarization_stokes import PolarizationStokes +from cosipy.spacecraftfile import SpacecraftFile +from cosipy import UnBinnedData +from cosipy.threeml.custom_functions import Band_Eflux +from cosipy import test_data + +analysis = UnBinnedData(test_data.path / 'polarization_data.yaml') +data = analysis.get_dict_from_hdf5(test_data.path / 'polarization_data.hdf5') +response_path = test_data.path / 'test_polarization_response.h5' +sc_orientation = SpacecraftFile.parse_from_file(test_data.path / 'polarization_ori.ori') +attitude = sc_orientation.get_attitude()[0] + +a = 10. * u.keV +b = 10000. * u.keV +alpha = -1. +beta = -2. +ebreak = 350. * u.keV +K = 50. / u.cm / u.cm / u.s +spectrum = Band_Eflux(a = a.value, + b = b.value, + alpha = alpha, + beta = beta, + E0 = ebreak.value, + K = K.value) +spectrum.a.unit = a.unit +spectrum.b.unit = b.unit +spectrum.E0.unit = ebreak.unit +spectrum.K.unit = K.unit + +source_direction = SkyCoord(0, 70, representation_type='spherical', frame=SpacecraftFrame(attitude=attitude), unit=u.deg) + +def test_stokes_polarization(): + + bin_edges = Angle(np.linspace(-np.pi, np.pi, 10), unit=u.rad) + source_photons = PolarizationStokes(source_direction, spectrum, data, + response_path, sc_orientation, background=None, + response_convention='RelativeZ', asad_bin_edges=bin_edges, show_plots=False) + + average_mu = source_photons._mu100['mu'] + mdp99 = source_photons._mdp99 + + qs, us = source_photons.compute_data_pseudo_stokes(show_plots=False) + polarization = source_photons.calculate_polarization(qs, us, average_mu, mdp=mdp99, + bkg_qs=None, bkg_us=None, show_plots=True) + Pol_frac = polarization['fraction'] * 100 + Pol_angl = polarization['angle'].angle.degree + + assert np.allclose([average_mu, mdp99, Pol_frac, Pol_angl], [0.22, 0.20, 178, 82], atol=[0.1, 3.0, 5, 10]) + +######################################### +print('Expected values for polarization:') +print('Fraction:', 13.73038868282377, '%') +print('Fraction uncertainty:', 2.1295224814008353, '%') +print('Angle:', np.degrees(1.4851296518928818), 'degrees') +print('Angle uncertainty:', np.degrees(0.07562763316088744), 'degrees') + +import matplotlib.pyplot as plt +chi_gal = data['Chi galactic'] +psi_gal = data['Psi galactic'] +fig = plt.figure(figsize=(8,4)) +ax = fig.add_subplot() +ax.set_title('Polarized source') +ax.hist2d(chi_gal, psi_gal, bins=40, cmap='viridis', cmin=1) +ax.set_xlabel('Chi galactic (deg)') +ax.set_ylabel('Psi galactic (deg)') +print(source_direction.galactic.l.deg, source_direction.galactic.b.deg) +ax.scatter(source_direction.galactic.l.deg, source_direction.galactic.b.deg, color='red', label='Source direction') + +source_photons = PolarizationStokes(source_direction, spectrum, data, + response_path, sc_orientation, background=None, + response_convention='RelativeX') + +data_duration = source_photons.get_data_duration() +data_counts = source_photons.get_data_counts() +print('\nData duration:', str(round(data_duration, 3)), 's') +print('Data counts:', data_counts) +print('Count rate:', round(data_counts / data_duration, 3), 'counts/s') + + +average_mu = source_photons._mu100['mu'] +print('Average mu100:', average_mu) + +mdp99 = source_photons._mdp99 +print('MDP99:', mdp99 * 100) + +# _bkg_qs_, _bkg_us_ = source_photons.simulate_unpolarized_stokes(n_samples=100, show_plots=True) +# _bkg_qs_, _bkg_us_ = np.load(test_data.path / 'simulated_unpolarized_stokes.npz')['qs'], np.load(test_data.path / 'simulated_unpolarized_stokes.npz')['us'] + +qs, us = source_photons.compute_data_pseudo_stokes(show_plots=True) + +polarization = source_photons.calculate_polarization(qs, us, average_mu, + bkg_qs=None, bkg_us=None, show_plots=True, + mdp=mdp99) +QN = polarization['QN'] +UN = polarization['UN'] +QN_ERR = polarization['QN_ERR'] +UN_ERR = polarization['UN_ERR'] +print('Normalized Q: %.3f +/- %.3f'%(QN, QN_ERR)) +print('Normalized U: %.3f +/- %.3f'%(UN, UN_ERR))