diff --git a/mapmaking/__pycache__/frequency_acquisition.cpython-38.pyc b/mapmaking/__pycache__/frequency_acquisition.cpython-38.pyc index e9eebcf61..6460d331c 100644 Binary files a/mapmaking/__pycache__/frequency_acquisition.cpython-38.pyc and b/mapmaking/__pycache__/frequency_acquisition.cpython-38.pyc differ diff --git a/mapmaking/__pycache__/instrument.cpython-38.pyc b/mapmaking/__pycache__/instrument.cpython-38.pyc index 8c5a6ea10..9552a8fc4 100644 Binary files a/mapmaking/__pycache__/instrument.cpython-38.pyc and b/mapmaking/__pycache__/instrument.cpython-38.pyc differ diff --git a/mapmaking/__pycache__/noise_timeline.cpython-38.pyc b/mapmaking/__pycache__/noise_timeline.cpython-38.pyc index 549a7f445..6eedb2927 100644 Binary files a/mapmaking/__pycache__/noise_timeline.cpython-38.pyc and b/mapmaking/__pycache__/noise_timeline.cpython-38.pyc differ diff --git a/mapmaking/__pycache__/planck_timeline.cpython-38.pyc b/mapmaking/__pycache__/planck_timeline.cpython-38.pyc index 2380a1821..fecaf4c50 100644 Binary files a/mapmaking/__pycache__/planck_timeline.cpython-38.pyc and b/mapmaking/__pycache__/planck_timeline.cpython-38.pyc differ diff --git a/mapmaking/__pycache__/systematics.cpython-38.pyc b/mapmaking/__pycache__/systematics.cpython-38.pyc index 0fdd43b33..a91897a65 100644 Binary files a/mapmaking/__pycache__/systematics.cpython-38.pyc and b/mapmaking/__pycache__/systematics.cpython-38.pyc differ diff --git a/mapmaking/frequency_acquisition.py b/mapmaking/frequency_acquisition.py index fd98b13ce..0f4a8a26e 100644 --- a/mapmaking/frequency_acquisition.py +++ b/mapmaking/frequency_acquisition.py @@ -276,6 +276,7 @@ def get_hitmap(self, nside=None): return hit def get_noise(self, det_noise, photon_noise, seed=None, out=None): + np.random.seed(seed) out = self.instrument.get_noise( self.sampling, self.scene, det_noise, photon_noise, out=out) @@ -1925,7 +1926,6 @@ def get_invntt_operator(self, det_noise, photon_noise150, photon_noise220): return (invn150 + invn220)/2 # factor 2 because it added twice the detector noise def get_noise(self, det_noise, photon_noise150, photon_noise220, seed=None): - np.random.seed(seed) ndet = self.subacqs150[0].get_noise(det_noise, False) npho150 = self.subacqs150[0].get_noise(False, photon_noise150)# - ndet diff --git a/mapmaking/noise_timeline.py b/mapmaking/noise_timeline.py index c67c765c8..f1a0f925d 100644 --- a/mapmaking/noise_timeline.py +++ b/mapmaking/noise_timeline.py @@ -4,7 +4,7 @@ class QubicNoise: - def __init__(self, band, npointings, comm=None, size=1, detector_nep=4.7e-17): + def __init__(self, band, npointings, comm=None, size=1, detector_nep=4.7e-17, seed=None): if band != 150 and band != 220: raise TypeError('Please choose the QubicWideBandNoise method.') @@ -12,7 +12,7 @@ def __init__(self, band, npointings, comm=None, size=1, detector_nep=4.7e-17): dictfilename = 'dicts/pipeline_demo.dict' d = qubic.qubicdict.qubicDict() d.read_from_file(dictfilename) - + self.seed = seed d['TemperatureAtmosphere150']=None d['TemperatureAtmosphere220']=None d['EmissivityAtmosphere150']=None @@ -41,10 +41,10 @@ def get_noise(self, det_noise, pho_noise): return n def photon_noise(self): - return self.acq.get_noise(det_noise=False, photon_noise=True) + return self.acq.get_noise(det_noise=False, photon_noise=True, seed=self.seed) def detector_noise(self): - return self.acq.get_noise(det_noise=True, photon_noise=False) + return self.acq.get_noise(det_noise=True, photon_noise=False, seed=self.seed) def total_noise(self, wdet, wpho): ndet = wdet * self.detector_noise() @@ -61,10 +61,12 @@ def __init__(self, d, npointings, detector_nep=4.7e-17): self.detector_nep = detector_nep - def total_noise(self, wdet, wpho150, wpho220): + def total_noise(self, wdet, wpho150, wpho220, seed=None): - Qubic150 = QubicNoise(150, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep) - Qubic220 = QubicNoise(220, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep) + Qubic150 = QubicNoise(150, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep, seed=seed) + if seed is not None : + seed += 1 + Qubic220 = QubicNoise(220, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep, seed=seed) ndet = wdet * Qubic150.detector_noise() npho150 = wpho150 * Qubic150.photon_noise() @@ -75,16 +77,18 @@ def total_noise(self, wdet, wpho150, wpho220): class QubicDualBandNoise: - def __init__(self, d, npointings, detector_nep=4.7e-17): + def __init__(self, d, npointings, detector_nep=4.7e-17, seed=None): self.d = d self.npointings = npointings self.detector_nep = detector_nep - def total_noise(self, wdet, wpho150, wpho220): + def total_noise(self, wdet, wpho150, wpho220, seed=None): - Qubic150 = QubicNoise(150, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep) - Qubic220 = QubicNoise(220, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep) + Qubic150 = QubicNoise(150, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep, seed=seed) + if seed is not None : + seed += 1 + Qubic220 = QubicNoise(220, self.npointings, comm=self.d['comm'], size=self.d['nprocs_instrument'], detector_nep=self.detector_nep, seed=seed) ndet150 = wdet * Qubic150.detector_noise().ravel() ndet220 = wdet * Qubic220.detector_noise().ravel() diff --git a/mapmaking/systematics.py b/mapmaking/systematics.py index 7e37058d7..ca5568efd 100644 --- a/mapmaking/systematics.py +++ b/mapmaking/systematics.py @@ -414,12 +414,12 @@ def __init__(self, d, Nsub, Nrec=1, comp=[], kind='Two', nu_co=None): # for i in range(len(self.subacqs)): # del(self.H[i].operands[-1])# = IdentityOperator() - #for i in range(len(self.multiinstrument)): + for i in range(len(self.multiinstrument)): # #print(i) # #self.Proj += [qubic.QubicAcquisition(self.multiinstrument[i], self.sampling, self.scene, self.d).get_projection_operator()] # self.H += [qubic.QubicAcquisition(self.multiinstrument[i], self.sampling, self.scene, self.d).get_operator()] # self.subacqs += [qubic.QubicAcquisition(self.multiinstrument[i], self.sampling, self.scene, self.d)] - # self.allfwhm[i] = self.multiinstrument[i].get_convolution_peak_operator().fwhm + self.allfwhm[i] = self.multiinstrument[i].get_convolution_peak_operator().fwhm #if self.d['comm'] is not None: diff --git a/mcmc_class.py b/mcmc_class.py deleted file mode 100644 index a2292f021..000000000 --- a/mcmc_class.py +++ /dev/null @@ -1,576 +0,0 @@ -#### General packages -import pickle -import os -import os.path as op -import numpy as np -import matplotlib.pyplot as plt -import scipy -import healpy as hp -import emcee -import yaml -from multiprocessing import Pool -from getdist import plots, MCSamples -import getdist -import time - -#### QUBIC packages -import qubic -from qubic import NamasterLib as nam -from qubicpack.utilities import Qubic_DataDir -from qubic import QubicSkySim as qss -from pysimulators import FitsArray -from qubic import fibtools as ft -from qubic import camb_interface as qc -from qubic import SpectroImLib as si -import mapmaking.systematics as acq -from qubic import mcmc -from qubic import AnalysisMC as amc -import fgb.component_model as c -import fgb.mixing_matrix as mm -from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator -from pipeline import * -from pyoperators import * - -class Data: - """ - Class to manipulate data from your simulations - """ - - def __init__(self): - - with open('mcmc_config.yml', "r") as stream: - self.param = yaml.safe_load(stream) - self.config = self.param['simu']['qubic_config'] - self.path = self.param['data']['path'] - self.name = self.param['simu']['name'] - self.nrec = self.param['simu']['nrec'] - self.data = self.find_data() - self.nsub = self.data['parameters']['QUBIC']['nsub'] - self.nside = self.data['parameters']['Sky']['nside'] - self.fsub = int(self.nsub / self.nrec) - self.comm = MPI.COMM_WORLD - self.size = self.comm.Get_size() - - def find_data(self): - ''' - Function to extract the pickle file of one realisation. Useful to have access to the realisations' parameters - ''' - - path_data = spath_data = self.path + self.config + f'_Nrec={self.nrec}_{self.name}' - data_names = os.listdir(path_data) - - data = pickle.load(open(path_data + '/' + data_names[0], 'rb')) - - return data - - def compute_data(self, name): - ''' - Function to compute the mean and std on your spectra - - Argument : - - name(str): CMB, Dust or Sky - ''' - - path_data = self.path + self.config + f'_Nrec={self.nrec}_{name}' - data_names = os.listdir(path_data) - - # Store the datas into arrays - ps_data = [] - map_data = [] - for realisation in range(0, self.param['data']['n_real']): - data = pickle.load(open(path_data + '/' + data_names[realisation], 'rb')) - ps_data.append(data['Dl']) - map_data.append(data['maps']) - ps_data = np.reshape(ps_data, [self.param['data']['n_real'],self.param['simu']['nrec'], self.param['simu']['nrec'], np.shape(data['Dl'][0])[0]]) - - self.nus = data['nus'] - - # Compute Mean & Error on each realisations of Noise & Sky's PSs - mean_data = np.mean(ps_data, axis = 0) - error_data = np.std(ps_data, axis = 0) - - return (mean_data, error_data, map_data) - - def auto_spectra_noise_reduction(self, mean_data, mean_noise): - ''' - Function to remove the mean of the noise realisations to the auto-spectra - ''' - - for i in range(self.param['simu']['nrec']): - mean_data[i, i, :] -= mean_noise[i, i, :] - - return mean_data - - def get_ultrawideband_config(self): - """ - Method that pre-compute UWB configuration. - """ - - nu_up = 247.5 - nu_down = 131.25 - nu_ave = np.mean(np.array([nu_up, nu_down])) - delta = nu_up - nu_ave - - return nu_ave, 2*delta/nu_ave - - def get_dict(self): - """ - Method to modify the qubic dictionary. - """ - - nu_ave, delta_nu_over_nu = self.get_ultrawideband_config() - params = self.data['parameters'] - - args = {'npointings':params['QUBIC']['npointings'], - 'nf_recon':params['QUBIC']['nrec'], - 'nf_sub':params['QUBIC']['nsub'], - 'nside':params['Sky']['nside'], - 'MultiBand':True, - 'period':1, - 'RA_center':params['QUBIC']['RA_center'], - 'DEC_center':params['QUBIC']['DEC_center'], - 'filter_nu':nu_ave*1e9, - 'noiseless':False, - 'comm':self.comm, - 'dtheta':params['QUBIC']['dtheta'], - 'nprocs_sampling':1, - 'nprocs_instrument':self.size, - 'photon_noise':True, - 'nhwp_angles':params['QUBIC']['nhwp_angles'], - 'effective_duration':3, - 'filter_relative_bandwidth':delta_nu_over_nu, - 'type_instrument':'wide', - 'TemperatureAtmosphere150':None, - 'TemperatureAtmosphere220':None, - 'EmissivityAtmosphere150':None, - 'EmissivityAtmosphere220':None, - 'detector_nep':float(params['QUBIC']['detector_nep']), - 'synthbeam_kmax':params['QUBIC']['synthbeam_kmax']} - - args_mono = args.copy() - args_mono['nf_recon'] = 1 - args_mono['nf_sub'] = 1 - - ### Get the default dictionary - dictfilename = 'dicts/pipeline_demo.dict' - d = qubic.qubicdict.qubicDict() - d.read_from_file(dictfilename) - dmono = d.copy() - for i in args.keys(): - - d[str(i)] = args[i] - dmono[str(i)] = args_mono[i] - - - return d, dmono - - def cross_sectra_convo(self, mean_sky, map_data): - ''' - FUnction that will compute the cross-spectra between each reconsructed sub-bands taking into accounts the different convolutions between each maps - ''' - - my_dict, _ = self.get_dict() - joint = acq.JointAcquisitionFrequencyMapMaking(my_dict, self.data['parameters']['QUBIC']['type'], self.data['parameters']['QUBIC']['nrec'], self.data['parameters']['QUBIC']['nsub']) - allfwhm = joint.qubic.allfwhm - _, namaster = NamasterEll().ell() - - for i in range(self.nrec): - for j in range(self.nrec): - if i != j: - for real in range(self.param['data']['n_real']): - cross_spect = [] - if allfwhm[i*self.fsub] self.sky_parameters[name][4]: - return - np.inf - elif name == 'Alens': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'Ad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'alphad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'betad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'deltad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'nu0_d': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - return 0 - - def chi2(self, tab): - ''' - chi2 function - ''' - - a = time.time() - for iname in self.param['SKY_PARAMETERS']: - if iname == 'r': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - r = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'Alens': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - Alens = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'Ad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - Ad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'betad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - betad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'alphad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - alphad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'deltad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - deltad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'nu0_d': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - nu0_d = self.param['SKY_PARAMETERS'][iname][0] - - # Add the parameters you want to find - sky_parameters_names = self.sky_parameters_names - for isky_param, sky_param in enumerate(tab): - if sky_parameters_names[isky_param] == 'r': - r = sky_param - elif sky_parameters_names[isky_param] == 'Alens': - Alens = sky_param - elif sky_parameters_names[isky_param] == 'Ad': - Ad = sky_param - elif sky_parameters_names[isky_param] == 'betad': - betad = sky_param - elif sky_parameters_names[isky_param] == 'alphad': - alphad = sky_param - elif sky_parameters_names[isky_param] == 'deltad': - deltad = sky_param - elif sky_parameters_names[isky_param] == 'nu0_d': - nu0_d = sky_param - - # Return the chi2 function - if self.param['simu']['name'] == 'CMB': - return self.prior(tab) - 0.5 * np.sum(((self.mean_data - CMB(self.ell).model_cmb(r, Alens))/(self.error_noise))**2) - if self.param['simu']['name'] == 'Dust': - return self.prior(tab) - 0.5 * np.sum(((self.mean_data - Dust(self.ell).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_noise))**2) - if self.param['simu']['name'] == 'Sky': - return self.prior(tab) - 0.5 * np.sum(((self.mean_data - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell).model_dust(Ad, alphad, betad, deltad, nu0_d)))/(self.error_noise))**2) - - def __call__(self): - ''' - Funtion to perform the MCMC and save the results - ''' - - ndim, sky_parameters_names = self.ndim_and_parameters_names() - nwalkers = self.param['MCMC']['nwalkers'] - mcmc_steps = self.param['MCMC']['mcmc_steps'] - p0 = self.initial_conditions() - ell = self.ell - print(Data().find_data()['parameters']) - - with Pool() as pool: - sampler = emcee.EnsembleSampler(nwalkers, ndim, log_prob_fn = self.chi2, pool = pool, moves = [(emcee.moves.StretchMove(), self.param['MCMC']['stretch_move_factor']), (emcee.moves.DESnookerMove(gammas=self.param['MCMC']['snooker_move_gamma']), 1 - self.param['MCMC']['stretch_move_factor'])]) - sampler.run_mcmc(p0, mcmc_steps, progress=True) - - samples_flat = sampler.get_chain(flat = True, discard = self.param['MCMC']['discard']) - samples = sampler.get_chain() - - # Plot the walkers - fig, ax = plt.subplots(1, ndim, figsize = (15, 5)) - for j in range(ndim): - for i in range(nwalkers): - ax[j].plot(samples[:, i, j]) - ax[j].set_title(sky_parameters_names[j]) - - config = self.param['simu']['qubic_config'] - nrec = self.param['simu']['nrec'] - n_real = self.param['data']['n_real'] - path_plot = f'{config}_Nrec={nrec}_plots' - if not os.path.isdir(path_plot): - os.makedirs(path_plot) - plt.savefig(self.param['data']['path'] + path_plot + f'/walkers_plot_Nreal={n_real}') - - # Triangle plot - plt.figure() - s = MCSamples(samples=samples_flat, names=sky_parameters_names, labels=sky_parameters_names) - g = plots.get_subplot_plotter(width_inch=10) - g.triangle_plot([s], filled=True, title_limit=1) - - path_plot_triangle = f'{config}_Nrec={nrec}_plots' - plt.savefig(self.param['data']['path'] + path_plot + f'/triangle_plot_Nreal={n_real}') - - # Data vs Fit plot - plt.figure() - mcmc_values = np.mean(samples_flat, axis=0) - parameters_values = [] - cpt=0 - for parameter in self.sky_parameters: - if self.sky_parameters[parameter][0] is True: - parameters_values.append(mcmc_values[cpt]) - cpt+=1 - else: - parameters_values.append(self.sky_parameters[parameter][0]) - Dl_mcmc = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2]) - plt.plot(self.ell[:5], Dl_mcmc[0][0][:5], label = 'MCMC') - plt.errorbar(self.ell[:5], self.mean_data[0][0][:5], self.error_data[0][0][:5], label = 'Data') - plt.legend() - plt.xlabel('l') - plt.ylabel('Dl') - plt.title('CMB + Dust spectrum') - plt.savefig(self.param['data']['path'] + path_plot + f'/Comparison_plot_Nreal={n_real}') - - -MCMC()() - - - - - - - - - - - - - - - diff --git a/mcmc_config.yml b/mcmc_config.yml deleted file mode 100644 index 754c9ed5d..000000000 --- a/mcmc_config.yml +++ /dev/null @@ -1,25 +0,0 @@ -data: - path : '/sps/qubic/Users/TomLaclavere/Pipeline/' - n_real : 40 - -simu: - nrec : 2 - qubic_config : UWB - name : 'Sky' - noise : True - -MCMC: - nwalkers : 50 - mcmc_steps : 500 - discard : 200 - stretch_move_factor : 0.7 - snooker_move_gamma : 1.7 - -SKY_PARAMETERS: - r : [True, 0, 1, -10, 10] - Alens : [1, 0, 1, 0, 1] - nu0_d : [353, 0, 1, 0, 1000] - Ad : [True, 10, 1, 0, 20] - alphad : [True, 0, 1, -10, 10] - betad : [1.54, 0, 1, 1.3, 1.7] - deltad : [1, 0, 1, 0, 1000] \ No newline at end of file diff --git a/notebook/.ipynb_checkpoints/notebook_JC-checkpoint.ipynb b/notebook/.ipynb_checkpoints/notebook_JC-checkpoint.ipynb new file mode 100644 index 000000000..00528d0dd --- /dev/null +++ b/notebook/.ipynb_checkpoints/notebook_JC-checkpoint.ipynb @@ -0,0 +1,4552 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ef80106d-e269-4b69-aed4-886d580de0a9", + "metadata": {}, + "outputs": [], + "source": [ + "#### General packages\n", + "import pickle\n", + "import os\n", + "import os.path as op\n", + "import sys\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy\n", + "import healpy as hp\n", + "import emcee\n", + "import yaml\n", + "from multiprocessing import Pool\n", + "from getdist import plots, MCSamples\n", + "import getdist\n", + "import time\n", + "\n", + "sys.path.append('/pbs/home/t/tlaclave/sps/Pipeline')\n", + "\n", + "#### QUBIC packages\n", + "import qubic\n", + "from qubic import NamasterLib as nam\n", + "from qubicpack.utilities import Qubic_DataDir\n", + "from qubic import QubicSkySim as qss\n", + "from pysimulators import FitsArray\n", + "from qubic import fibtools as ft\n", + "from qubic import camb_interface as qc\n", + "from qubic import SpectroImLib as si\n", + "import mapmaking.systematics as acq\n", + "from qubic import mcmc\n", + "from qubic import AnalysisMC as amc\n", + "from qubic.beams import BeamGaussian\n", + "import fgb.component_model as c\n", + "import fgb.mixing_matrix as mm\n", + "from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator\n", + "from pipeline_notebook import *\n", + "from pyoperators import *\n", + "\n", + "#### Nested Sampling packages\n", + "import dynesty\n", + "from dynesty import plotting as dyplot\n", + "from dynesty import NestedSampler\n", + "from dynesty import DynamicNestedSampler\n", + "from dynesty import utils as dyfunc\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "7e82f530-9700-4cfc-84a7-d77e07c53891", + "metadata": {}, + "source": [ + "Step-by-step explanations of the notebook" + ] + }, + { + "cell_type": "markdown", + "id": "4077c2a4-6a8e-4399-8562-9580f5f4d7fd", + "metadata": {}, + "source": [ + "1) Frequency Map-Making\n", + "\n", + "All the FMM codes are stored on : https://github.com/mathias77515/Pipeline/tree/Tom-dev\n", + "You have to use the yaml file 'params.yml' (open outside this notebook) in order to configure the FMM parameters. After that, the line 'PipelineEnd2End(comm).main()' will start a FMM simulation and store the results (maps, parameters, ...) into a pickle file at the 'path_out' (in params.yaml) location. You can import this file(s) as a Python dictionnary with pickle.load(open(your_path, 'rb')). I have write examples in following cells, even to import many simulations easily. This pickle file(s) will be used to compute the power spectra." + ] + }, + { + "cell_type": "markdown", + "id": "0f12be3c-8f90-4279-99ee-167527b4653d", + "metadata": {}, + "source": [ + "2) Power Spectra\n", + "\n", + "To compute power spectra, you will use the class Spectra. It will work with the dictionnary 'param_spectrum', where you will have to write the path for your noise and sky (cmb + dust) realisations. I think that it's more conveniant to compute the power spectrum for one noise realisation and one sky realisation simultaneously, because it allows Spectra to return a pickle file with these two spectra. It's just a technical choice but it's very easy to change it if you want in the __init__ function. You will have to change the class Data in order to take into account this kind of modification.\n", + "Spectra will compute auto-spectrum for each reconstructed frequency sub-bands and cross-spectrum between all the reconstructed frequency sub-bands, and store them in an array with dimension = Nrec x Nrec (for both noise and sky realisation), with the diagonal fills with auto-spectra and the triangle parts fill with cross-spectra. The function 'find_data' and 'save' are used to select the pair of realisations (noise and sky) on which the power spectra will be computed. The result will be stored in a pickle file at the 'path_out' location." + ] + }, + { + "cell_type": "markdown", + "id": "209eb13e-a37f-4b7a-acbf-c7a3a648ecb5", + "metadata": {}, + "source": [ + "3) Fitting\n", + "\n", + "To fit the chosen parameter(s) with your spectra, you will have to use the 'param_sampling' dictionnary. With this dictionnary, you will give the path where your power spectra are store and the simulations parameters (just for plots names if I'm not mistaken...). You will also choose the fitting method (Nested Sampling or MCMC) anf their parameters. After that, the code will correct the power spectra of the sky using the noise power spectra and use them to achieve the fit. Some useful plots will be shown at the end to understand if the fit was successful and the triangle plot with the estimation of your parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "3a83da7b-d717-474b-a763-77a565eb6764", + "metadata": {}, + "outputs": [], + "source": [ + "# MPI object\n", + "comm = MPI.COMM_WORLD" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "39f72282-079c-4b14-aefd-68262bd461bc", + "metadata": {}, + "outputs": [], + "source": [ + "##############################\n", + "#### Frequency Map-Making ####\n", + "##############################" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "b8e60f82-d50f-496f-84b8-89bfb3eb04be", + "metadata": {}, + "outputs": [], + "source": [ + "# Command to start FMM, according to the parameters in \"params.yml\"\n", + "# This will create a pickle file at the location setted by 'path_out' in this yaml file\n", + "\n", + "### Please note that you don't need to simulate maps every time you launch the notebook, you can just use a loop to generate N maps and use the same ones each time\n", + "\n", + "#PipelineEnd2End(comm).main()\n", + "\n", + "### You also need to do a simulation for CMB & Dust = False, in order to have a noise realisation. It is mandatory for the fitting part" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "11b94ada-9bd0-40de-82b7-70596d29c726", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'your_path_for_sky_simulation' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Import the FMM results\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m FMM_sky \u001b[38;5;241m=\u001b[39m pickle\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;28mopen\u001b[39m(\u001b[43myour_path_for_sky_simulation\u001b[49m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m 3\u001b[0m FMM_noise \u001b[38;5;241m=\u001b[39m pickle\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;28mopen\u001b[39m(your_path_for_noise_simulation, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Import the maps and the parameters used to simulate them from pickle files generated with pipeline.py\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'your_path_for_sky_simulation' is not defined" + ] + } + ], + "source": [ + "# Import the FMM results\n", + "FMM_sky = pickle.load(open(your_path_for_sky_simulation, 'rb'))\n", + "FMM_noise = pickle.load(open(your_path_for_noise_simulation, 'rb'))\n", + "\n", + "# Import the maps and the parameters used to simulate them from pickle files generated with pipeline.py\n", + "map_sky = FMM_sky['maps']\n", + "simulation_parameters = FMM_sky['maps']\n", + "map_noise = FMM_noise['maps']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7eb71a5-8321-456b-981c-a5e0a2354b0a", + "metadata": {}, + "outputs": [], + "source": [ + "# I advise to compute many maps using pipeline.py on a computing cluster\n", + "# you can import this by using the commands :\n", + "your_path_sky, your_path_noise = '', ''\n", + "sky_names = os.listdir(your_path_sky)\n", + "noise_names = os.listdir(your_path_noise)\n", + "map_sky, map_noise = [], []\n", + "for i in range(len(your_simulations_names)):\n", + " pickle_sky = pickle.load(open(your_path_sky + '/' + sky_names[i], 'rb'))\n", + " pickle_noise = pickle.load(open(your_path_noise + '/' + noise_names[i], 'rb'))\n", + " map_sky.append(pickle_sky['maps'])\n", + " map_noise.append(pickle_noise['maps'])\n", + " \n", + "simulation_parameters = pickle_sky['parameters']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "298fb639-c317-43ac-b7a9-af5b0862533c", + "metadata": {}, + "outputs": [], + "source": [ + "#######################\n", + "#### Power Spectra ####\n", + "#######################" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "8ac6ed1d-511e-404a-bfc8-34cb3065f547", + "metadata": {}, + "outputs": [], + "source": [ + "# We define a dictionnary in order to give the usefull parameters to the Spectra Class\n", + "param_spectrum = {'data': \n", + " # Path where the spectra will be stored\n", + " {'path_out': '/pbs/home/t/tlaclave/sps/Pipeline/spectra/spectra_comparison_pixwin_test/', \n", + " # Path where the pickle files of the noise realisations are stored\n", + " 'path_noise': '/pbs/home/t/tlaclave/sps/Pipeline/data_comparison/DB_Nrec=2_Noise', \n", + " # Path where the pickle files of the sky realisations are stored\n", + " 'path_sky': '/pbs/home/t/tlaclave/sps/Pipeline/data_comparison/DB_Nrec=2_Sky'},\n", + " 'simu': \n", + " # Parameters of the sky or noise realisations\n", + " {'nrec': 2, \n", + " 'qubic_config': 'DB'}, \n", + " 'Spectrum': \n", + " # Namaster parameters\n", + " {'lmin': 40, \n", + " 'dl': 30, \n", + " 'nbins': 16}\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "d125925d-3d7a-4f95-9a3a-1db19e4cecfe", + "metadata": {}, + "outputs": [], + "source": [ + "class Spectra:\n", + " '''\n", + " Class to compute the different spectra for our realisations\n", + " '''\n", + "\n", + " def __init__(self, iteration, param_spectrum):\n", + "\n", + " self.iter = iteration\n", + " self.param_spectrum = param_spectrum\n", + " self.path_sky = self.param_spectrum['data']['path_sky']\n", + " self.path_noise = self.param_spectrum['data']['path_noise']\n", + " self.pkl_sky = self.find_data(self.path_sky)\n", + " self.pkl_noise = self.find_data(self.path_noise)\n", + " self.sky_maps = self.pkl_sky['maps']\n", + " self.noise_maps = self.pkl_noise['maps']\n", + " self.nrec = self.param_spectrum['simu']['nrec']\n", + " self.nsub = self.pkl_sky['parameters']['QUBIC']['nsub']\n", + " self.nside = self.pkl_sky['parameters']['Sky']['nside']\n", + " self.fsub = int(self.nsub / self.nrec)\n", + " self.comm = MPI.COMM_WORLD\n", + " self.size = self.comm.Get_size()\n", + " self.my_dict, _ = self.get_dict()\n", + "\n", + " self.ell, self.namaster = NamasterEll(self.iter, self.param_spectrum).ell()\n", + " _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " self.allnus = np.array(list(allnus150) + list(allnus220))\n", + " self.allfwhm = self.get_allfwhm()\n", + " print('allnus', self.allnus)\n", + " print('allfwhm', self.allfwhm)\n", + "\n", + " def find_data(self, path):\n", + " '''\n", + " Function to extract the pickle file of one realisation associated to the path and the iteration number given.\n", + "\n", + " Argument :\n", + " - path (str) : path where the pkl files are located\n", + "\n", + " Return :\n", + " - pkl file dictionary (dict)\n", + " '''\n", + "\n", + " data_names = os.listdir(path)\n", + " one_realisation = pickle.load(open(path + '/' + data_names[self.iter], 'rb'))\n", + "\n", + " return one_realisation\n", + "\n", + " def get_dict(self):\n", + " \"\"\"\n", + " Method to modify the qubic dictionary.\n", + " \"\"\"\n", + "\n", + " nu_ave, delta_nu_over_nu = self.get_ultrawideband_config()\n", + " params = self.pkl_sky['parameters']\n", + "\n", + " args = {'npointings':params['QUBIC']['npointings'], \n", + " 'nf_recon':params['QUBIC']['nrec'], \n", + " 'nf_sub':params['QUBIC']['nsub'], \n", + " 'nside':params['Sky']['nside'], \n", + " 'MultiBand':True, \n", + " 'period':1, \n", + " 'RA_center':params['QUBIC']['RA_center'], \n", + " 'DEC_center':params['QUBIC']['DEC_center'],\n", + " 'filter_nu':nu_ave*1e9, \n", + " 'noiseless':False, \n", + " 'comm':self.comm, \n", + " 'dtheta':params['QUBIC']['dtheta'],\n", + " 'nprocs_sampling':1, \n", + " 'nprocs_instrument':self.size,\n", + " 'photon_noise':True, \n", + " 'nhwp_angles':params['QUBIC']['nhwp_angles'], \n", + " 'effective_duration':3, \n", + " 'filter_relative_bandwidth':delta_nu_over_nu, \n", + " 'type_instrument':'wide', \n", + " 'TemperatureAtmosphere150':None, \n", + " 'TemperatureAtmosphere220':None,\n", + " 'EmissivityAtmosphere150':None, \n", + " 'EmissivityAtmosphere220':None, \n", + " 'detector_nep':float(params['QUBIC']['detector_nep']), \n", + " 'synthbeam_kmax':params['QUBIC']['synthbeam_kmax']}\n", + "\n", + " args_mono = args.copy()\n", + " args_mono['nf_recon'] = 1\n", + " args_mono['nf_sub'] = 1\n", + "\n", + " ### Get the default dictionary\n", + " dictfilename = 'dicts/pipeline_demo.dict'\n", + " d = qubic.qubicdict.qubicDict()\n", + " d.read_from_file(dictfilename)\n", + " dmono = d.copy()\n", + "\n", + " for i in args.keys():\n", + " d[str(i)] = args[i]\n", + " dmono[str(i)] = args_mono[i]\n", + "\n", + " return d, dmono\n", + "\n", + " def get_ultrawideband_config(self):\n", + " \"\"\"\n", + " Method that pre-compute UWB configuration.\n", + " \"\"\"\n", + "\n", + " nu_up = 247.5\n", + " nu_down = 131.25\n", + " nu_ave = np.mean(np.array([nu_up, nu_down]))\n", + " delta = nu_up - nu_ave\n", + " return nu_ave, 2*delta/nu_ave\n", + " \n", + " def synthbeam(self, synthbeam_peak150_fwhm, dtype=np.float32):\n", + " sb = SyntheticBeam()\n", + " sb.dtype = np.dtype(dtype)\n", + " nripples = self.my_dict['nripples']\n", + " synthbeam_peak150_fwhm = np.radians(self.my_dict['synthbeam_peak150_fwhm'])\n", + " if not nripples:\n", + " sb.peak150 = BeamGaussian(synthbeam_peak150_fwhm)\n", + " else:\n", + " sb.peak150 = BeamGaussianRippled(synthbeam_peak150_fwhm,\n", + " nripples=nripples)\n", + " return sb\n", + " \n", + " def get_allfwhm(self):\n", + " '''\n", + " Function to compute the fwhm for all sub bands.\n", + "\n", + " Return :\n", + " - allfwhm (list [nrec * nsub])\n", + " '''\n", + "\n", + " synthbeam_peak150_fwhm = np.radians(self.my_dict['synthbeam_peak150_fwhm'])\n", + " synthbeam = self.synthbeam(synthbeam_peak150_fwhm, dtype=np.float32)\n", + " if self.pkl_sky['parameters']['QUBIC']['convolution'] is True:\n", + " allfwhm = synthbeam.peak150.fwhm * (150 / self.allnus)\n", + " else:\n", + " allfwhm = np.zeros(len(self.allnus))\n", + "\n", + " return allfwhm\n", + "\n", + " def compute_auto_spectrum(self, map, fwhm):\n", + " '''\n", + " Function to compute the auto-spectrum of a given map\n", + "\n", + " Argument : \n", + " - map(array) [nrec/ncomp, npix, nstokes] : map to compute the auto-spectrum\n", + " - allfwhm(float) : in radian\n", + " Return : \n", + " - (list) [len(ell)] : BB auto-spectrum\n", + " '''\n", + "\n", + " DlBB = self.namaster.get_spectra(map=map.T, map2=None, beam_correction = np.rad2deg(fwhm))[1][:, 2]\n", + " return DlBB\n", + "\n", + " def compute_cross_spectrum(self, map1, fwhm1, map2, fwhm2):\n", + " '''\n", + " Function to compute cross-spectrum, taking into account the different resolution of each sub-bands\n", + "\n", + " Arguments :\n", + " - map1 & map2 (array [nrec/ncomp, npix, nstokes]) : the two maps needed to compute the cross spectrum\n", + " - fwhm1 & fwhm2 (float) : the respective fwhm for map1 & map2 in radian\n", + "\n", + " Return : \n", + " - (list) [len(ell)] : BB cross-spectrum\n", + " '''\n", + "\n", + " # Put the map with the highest resolution at the worst one before doing the cross spectrum\n", + " # Important because the two maps had to be at the same resolution and you can't increase the resolution\n", + " if fwhm1 Third * x - Second, with x uniformly distributed between [0,1]\n", + " # Fourth : Min value of the parameter\n", + " # Fifth : Max value of the parameter\n", + " # Second to Fifth aren't relevant if First != True\n", + " 'SKY_PARAMETERS': \n", + " {'r': [True, 1, 2, -1, 1], \n", + " 'Alens': [1, 0, 1, 0, 1], \n", + " 'nu0_d': [353, 0, 1, 0, 1000], \n", + " 'Ad': [True, 0, 20, 0, 1000], \n", + " 'alphad': [True, 5, 10, -5, 5], \n", + " 'betad': [1.54, 0, 1, 1.3, 1.7], \n", + " 'deltad': [1, 0, 1, 0, 1000]}, \n", + " # Fitting method\n", + " 'Method': 'MCMC',\n", + " 'Loglike': 'fullcov'}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a9f7cec-2b5d-437a-9bee-4725aa8c525e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "59232252-7b7c-4713-99dc-c0d54d79e1d2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class data:\n", + " '''\n", + " Class to extract of the power spectra computed with spectrum.py and to compute useful things\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + " self.param = param_sampling\n", + " self.path_spectra = self.param['data']['path']\n", + " self.power_spectra_sky, self.power_spectra_noise, self.simu_parameters, self.coverage = self.import_power_spectra(self.path_spectra)\n", + " self.nsub = self.simu_parameters['QUBIC']['nsub']\n", + " self.nrec = self.simu_parameters['QUBIC']['nrec']\n", + " self.fsub = int(self.nsub / self.nrec)\n", + " self.nreal = self.param['data']['n_real']\n", + " _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " self.allnus = np.array(list(allnus150) + list(allnus220))\n", + " self.nus = self.average_nus()\n", + "\n", + " self.mean_ps_sky, self.error_ps_sky = self.compute_mean_std(self.power_spectra_sky)\n", + " self.mean_ps_noise, self.error_ps_noise = self.compute_mean_std(self.power_spectra_noise)\n", + " \n", + " if self.param['simu']['noise'] is True :\n", + " self.mean_ps_sky = self.spectra_noise_correction(self.mean_ps_sky, self.mean_ps_noise)\n", + " \n", + " def import_power_spectra(self, path):\n", + " '''\n", + " Function to import all the power spectra computed with spectrum.py and store in pickle files\n", + "\n", + " Argument :\n", + " - path (str) : path to indicate where the pkl files are\n", + "\n", + " Return :\n", + " - sky power spectra (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)]\n", + " - noise power spectra (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)]\n", + " - simulations parameters (dict)\n", + " - simulations coverage (array)\n", + " - bands frequencies for FMM (array) [nrec]\n", + " '''\n", + "\n", + " power_spectra_sky, power_spectra_noise = [], []\n", + " names = os.listdir(path)\n", + " for i in range(self.param['data']['n_real']):\n", + " ps = pickle.load(open(path + '/' + names[i], 'rb'))\n", + " power_spectra_sky.append(ps['sky_ps'])\n", + " power_spectra_noise.append(ps['noise_ps'])\n", + " return power_spectra_sky, power_spectra_noise, ps['parameters'], ps['coverage']\n", + " \n", + " def average_nus(self):\n", + " \n", + " nus_eff = []\n", + " f = int(self.nsub / self.nrec)\n", + " for i in range(self.nrec):\n", + " nus_eff += [np.mean(self.allnus[i*f : (i+1)*f], axis=0)]\n", + " return np.array(nus_eff)\n", + "\n", + " def compute_mean_std(self, ps):\n", + " '''\n", + " Function to compute the mean ans the std on our power spectra realisations\n", + "\n", + " Argument : \n", + " - power spectra array (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)]\n", + "\n", + " Return :\n", + " - mean (array) [nrec/ncomp, nrec/ncomp, len(ell)]\n", + " - std (array) [nrec/ncomp, nrec/ncomp, len(ell)]\n", + " '''\n", + "\n", + " return np.mean(ps, axis = 0), np.std(ps, axis = 0)\n", + "\n", + " def spectra_noise_correction(self, mean_data, mean_noise):\n", + " '''\n", + " Function to remove the mean of the noise realisations to the spectra computed\n", + "\n", + " Arguments :\n", + " - mean sky power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] : array that will contain the mean of all the auto and cross spectra of the sky realisations\n", + " - mean noise power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] : array that will contain the mean of all the auto and cross spectra of the noise realisation\n", + " \n", + " Return :\n", + " - corrected mean sky power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)]\n", + " '''\n", + "\n", + " for i in range(np.shape(mean_data)[0]):\n", + " for j in range(np.shape(mean_data)[1]):\n", + " mean_data[i, j, :] -= mean_noise[i, j, :]\n", + " return mean_data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "30ed1398-57e1-43ff-b795-9641189f3246", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class NamasterEll_sampling(data):\n", + " '''\n", + " Class to compute the ell list using NamasterLib\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + " self.param = param_sampling\n", + " data.__init__(self)\n", + "\n", + " def ell(self):\n", + " \n", + " nside = self.simu_parameters['Sky']['nside']\n", + "\n", + " # Call the Namaster class & create the ell list \n", + " seenpix = self.coverage/np.max(self.coverage) < 0.2\n", + " lmin, lmax, delta_ell = self.simu_parameters['Spectrum']['lmin'], 2*nside-1, self.simu_parameters['Spectrum']['dl']\n", + " namaster = nam.Namaster(weight_mask = list(~np.array(seenpix)), lmin = lmin, lmax = lmax, delta_ell = delta_ell)\n", + "\n", + " ell = namaster.get_binning(nside)[0]\n", + " \n", + " return ell, namaster" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9d4a97be-48d1-49cf-b24f-4603b6fdabdd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class CMB:\n", + " '''\n", + " Class to define the CMB model\n", + " '''\n", + "\n", + " def __init__(self, ell):\n", + " \n", + " self.ell = ell\n", + "\n", + " def cl_to_dl(self, cl):\n", + " '''\n", + " Function to convert the cls into the dls\n", + " '''\n", + "\n", + " dl = np.zeros(self.ell.shape[0])\n", + " for i in range(self.ell.shape[0]):\n", + " dl[i] = (self.ell[i]*(self.ell[i]+1)*cl[i])/(2*np.pi)\n", + " return dl\n", + "\n", + " def get_pw_from_planck(self, r, Alens):\n", + " '''\n", + " Function to compute the CMB power spectrum from the Planck data\n", + " '''\n", + "\n", + " CMB_CL_FILE = op.join('/sps/qubic/Users/TomLaclavere/mypackages/Cls_Planck2018_%s.fits')\n", + " power_spectrum = hp.read_cl(CMB_CL_FILE%'lensed_scalar')[:,:4000]\n", + " \n", + " if Alens != 1.:\n", + " power_spectrum[2] *= Alens\n", + " \n", + " if r:\n", + " power_spectrum += r * hp.read_cl(CMB_CL_FILE%'unlensed_scalar_and_tensor_r1')[:,:4000]\n", + " \n", + " return np.interp(self.ell, np.linspace(1, 4001, 4000), power_spectrum[2])\n", + "\n", + " def model_cmb(self, r, Alens):\n", + " '''\n", + " Define the CMB model, depending on r and Alens\n", + " '''\n", + "\n", + " dlBB = self.cl_to_dl(self.get_pw_from_planck(r, Alens))\n", + " return dlBB" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "12b61ced-0d90-4109-9384-b3540d3f208a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class Dust:\n", + " '''\n", + " Function to define the Dust model\n", + " '''\n", + "\n", + " def __init__(self, ell, nus):\n", + " \n", + " self.ell = ell\n", + " self.nus = nus\n", + " self.nrec = len(self.nus)\n", + "\n", + " def scale_dust(self, nu, nu0_d, betad, temp=20):\n", + " '''\n", + " Function to compute the dust mixing matrix element, depending on the frequency\n", + " '''\n", + "\n", + " comp = c.Dust(nu0 = nu0_d, temp=temp, beta_d = betad)\n", + " A = mm.MixingMatrix(comp).evaluator(np.array([nu]))()[0]\n", + "\n", + " return A\n", + "\n", + " def fnus_dust(self, nus, nu0_d, betad):\n", + " '''\n", + " Function to compute the mixing matrix elements for all the frequencies considered in your realisations\n", + " '''\n", + "\n", + " fnus = np.zeros(self.nrec)\n", + " for nu_index in range(self.nrec):\n", + " fnus[nu_index] = self.scale_dust(nus[nu_index], nu0_d, betad)\n", + "\n", + " return fnus\n", + "\n", + " def model_dust_frequency(self, Ad, alphad, deltad, fnu1, fnu2):\n", + " '''\n", + " Function to define the Dust model for two frequencies\n", + " '''\n", + "\n", + " return Ad * deltad * fnu1 * fnu2 * (self.ell/80)**alphad\n", + "\n", + " def model_dust(self, Ad, alphad, betad, deltad, nu0_d):\n", + " '''\n", + " Function defining the Dust model for all frequencies, depending on Ad, alphad, betad, deltad & nu0_d\n", + " '''\n", + " \n", + " fnus = self.fnus_dust(self.nus, nu0_d, betad)\n", + "\n", + " models = np.zeros((self.nrec, self.nrec, len(self.ell)))\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " models[i][j][:] = self.model_dust_frequency(Ad, alphad, deltad, fnus[i], fnus[j])\n", + " return models" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d6359333-062b-450a-a4e4-4abb376a4521", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class MCMC(data):\n", + " '''\n", + " Class to perform MCMC on the chosen sky parameters\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + "\n", + " self.param_sampling = param_sampling\n", + " data.__init__(self)\n", + " self.ell, _ = NamasterEll_sampling().ell()\n", + " self.sky_parameters = self.param_sampling['SKY_PARAMETERS']\n", + " self.ndim, self.sky_parameters_fitted_names, self.sky_parameters_all_names = self.ndim_and_parameters_names()\n", + " \n", + " if self.param_sampling['Loglike'] == 'cov' or 'fullcov':\n", + " reshaped_noise_ps = np.reshape(self.power_spectra_noise, (self.nrec, self.nrec, self.nreal, 16))\n", + " self.noise_cov_matrix = np.zeros((self.nrec, self.nrec, 16, 16)) \n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " self.noise_cov_matrix[i, j] = np.cov(reshaped_noise_ps[i,j], rowvar = False)\n", + "\n", + " def ndim_and_parameters_names(self):\n", + " '''\n", + " Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of these parameters\n", + " \n", + " Return :\n", + " - ndim (int) : number of parameters you want to fit\n", + " - sky_parameters_fitted_names (array) [ndim] : list that contains the names of the fitted parameters\n", + " - sky_parameters_all_names (array) : list that contains the names of all the sky parameters\n", + " '''\n", + " \n", + " ndim = 0 \n", + " sky_parameters_fitted_names = [] \n", + " sky_parameters_all_names = []\n", + "\n", + " for parameter in self.sky_parameters:\n", + " sky_parameters_all_names.append(parameter)\n", + " if self.sky_parameters[parameter][0] is True:\n", + " ndim += 1\n", + " sky_parameters_fitted_names.append(parameter)\n", + "\n", + " return ndim, sky_parameters_fitted_names, sky_parameters_all_names\n", + " \n", + " def dl_to_cl(self, dl):\n", + " cl = np.zeros(self.ell.shape[0])\n", + " for i in range(self.ell.shape[0]):\n", + " cl[i] = dl[i]*(2*np.pi)/(self.ell[i]*(self.ell[i] + 1))\n", + " return cl\n", + " \n", + " def knox_errors(self, clth):\n", + " dcl = np.sqrt(2. / (2 * self.ell + 1) / self.simu_parameters['QUBIC']['fsky'] / self.simu_parameters['Spectrum']['dl']) * clth\n", + " return dcl\n", + "\n", + " def knox_covariance(self, clth):\n", + " dcl = self.knox_errors(clth)\n", + " return np.diag(dcl ** 2)\n", + " \n", + " def initial_conditions(self):\n", + " '''\n", + " Function to computes the MCMC initial conditions\n", + "\n", + " Return :\n", + " - p0 (array) [nwalkers, ndim] : array that contains all the initial conditions for the mcmc\n", + " '''\n", + "\n", + " nwalkers = self.param_sampling['MCMC']['nwalkers']\n", + "\n", + " p0 = np.zeros((nwalkers, self.ndim))\n", + " for i in range(nwalkers):\n", + " for j in range(self.ndim):\n", + " name = self.sky_parameters_fitted_names[j]\n", + " p0[i,j] = np.random.random() * self.param_sampling['SKY_PARAMETERS'][name][2] - self.param_sampling['SKY_PARAMETERS'][name][1]\n", + "\n", + " return p0\n", + "\n", + " def prior(self, x):\n", + " '''\n", + " Function to define priors to help the MCMC convergence\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : inf if the prior is not respected, 0 otherwise\n", + " '''\n", + " \n", + " for isky_param, sky_param in enumerate(x):\n", + " name = self.sky_parameters_fitted_names[isky_param]\n", + "\n", + " if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]:\n", + " return - np.inf\n", + "\n", + " return 0\n", + "\n", + " def loglikelihood(self, tab):\n", + " '''\n", + " loglikelihood function\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : loglikelihood function\n", + " '''\n", + " tab_parameters = np.zeros(len(self.param_sampling['SKY_PARAMETERS']))\n", + " cpt = 0 \n", + "\n", + " for i, iname in enumerate(self.param_sampling['SKY_PARAMETERS']):\n", + " if self.param_sampling['SKY_PARAMETERS'][iname][0] is not True:\n", + " tab_parameters[i] = self.param_sampling['SKY_PARAMETERS'][iname][0]\n", + " else:\n", + " tab_parameters[i] = tab[cpt]\n", + " cpt += 1\n", + "\n", + " r, Alens, nu0_d, Ad, alphad, betad, deltad = tab_parameters\n", + " if self.param_sampling['simu']['noise'] == False:\n", + " loglike = self.prior(tab) \n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j])\n", + " #loglike = self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))**2)\n", + " return loglike\n", + "\n", + " if self.param_sampling['simu']['name'] == 'CMB':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - CMB(self.ell).model_cmb(r, Alens))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Dust':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Sky':\n", + " loglike = self.prior(tab) \n", + " if self.param_sampling['Loglike'] == 'fullcov':\n", + " \n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " dlth_dust = Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " clth_dust = self.dl_to_cl(dlth_dust[i][j])\n", + " sample_cov_dust = self.knox_covariance(clth_dust)\n", + " cov_matrix = self.noise_cov_matrix[i][j] + sample_cov_cmb + sample_cov_dust\n", + " inv_cov_matrix = np.linalg.pinv(cov_matrix)\n", + " loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j])\n", + " return loglike\n", + " if self.param_sampling['Loglike'] == 'cov':\n", + " \n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " cov_matrix = self.noise_cov_matrix[i][j] + sample_cov_cmb\n", + " inv_cov_matrix = np.linalg.pinv(cov_matrix)\n", + " loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j])\n", + " return loglike\n", + " if self.param_sampling['Loglike'] == 'diag' :\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " loglike += - 0.5 * ((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))[i][j]/(self.error_ps_noise[i][j]))**2\n", + " return loglike\n", + "\n", + " def __call__(self):\n", + " '''\n", + " Funtion to perform the MCMC and save the results\n", + " '''\n", + "\n", + " # Define the MCMC parameters, initial conditions and ell list\n", + " nwalkers = self.param_sampling['MCMC']['nwalkers']\n", + " mcmc_steps = self.param_sampling['MCMC']['mcmc_steps']\n", + " p0 = self.initial_conditions()\n", + " ell = self.ell\n", + " \n", + " print(self.simu_parameters)\n", + " \n", + " # Start the MCMC\n", + " with Pool() as pool:\n", + " sampler = emcee.EnsembleSampler(nwalkers, self.ndim, log_prob_fn = self.loglikelihood, pool = pool, moves = [(emcee.moves.StretchMove(), self.param_sampling['MCMC']['stretch_move_factor']), (emcee.moves.DESnookerMove(gammas=self.param_sampling['MCMC']['snooker_move_gamma']), 1 - self.param_sampling['MCMC']['stretch_move_factor'])])\n", + " sampler.run_mcmc(p0, mcmc_steps, progress=True)\n", + "\n", + " samples_flat = sampler.get_chain(flat = True, discard = self.param_sampling['MCMC']['discard'], thin = self.param_sampling['MCMC']['thin'])\n", + " samples = sampler.get_chain()\n", + "\n", + " # Plot the walkers\n", + " fig, ax = plt.subplots(1, self.ndim, figsize = (15, 5))\n", + " for j in range(self.ndim):\n", + " for i in range(nwalkers):\n", + " ax[j].plot(samples[:, i, j])\n", + " ax[j].set_title(self.sky_parameters_fitted_names[j])\n", + " \n", + " config = self.param_sampling['simu']['qubic_config']\n", + " nrec = self.param_sampling['simu']['nrec']\n", + " n_real = self.param_sampling['data']['n_real']\n", + " convo = self.param_sampling['simu']['convo']\n", + " path_plot = f'{config}_Nrec={nrec}_Convolution={convo}_plots_MCMC'\n", + " if not os.path.isdir(path_plot):\n", + " os.makedirs(path_plot)\n", + " fig.suptitle(f'Walkers plot - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/walkers_plot_Nreal={n_real}')\n", + " plt.show()\n", + "\n", + " # Triangle plot\n", + " plt.figure()\n", + " s = MCSamples(samples=samples_flat, names=self.sky_parameters_fitted_names, labels=self.sky_parameters_fitted_names)\n", + " g = plots.get_subplot_plotter(width_inch=10)\n", + " g.triangle_plot([s], filled=True, title_limit=1)\n", + " for ax in g.subplots[:,0]:\n", + " ax.axvline(0, color='gray')\n", + "\n", + " path_plot_triangle = f'{config}_Nrec={nrec}_plots'\n", + " #fig.suptitle(f'Triangle plot - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " mcmc_values = np.mean(samples_flat, axis=0)\n", + " parameters_values = []\n", + " cpt=0\n", + " for parameter in self.sky_parameters:\n", + " if self.sky_parameters[parameter][0] is True:\n", + " parameters_values.append(mcmc_values[cpt])\n", + " cpt+=1\n", + " else:\n", + " parameters_values.append(self.sky_parameters[parameter][0])\n", + " r, Alens, nu0_d, Ad, alphad, betad, deltad = parameters_values\n", + " \n", + " if param_sampling['Loglike'] == 'fullcov':\n", + " plt.figure()\n", + " cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " inv_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " error_bar = np.zeros((self.nrec, self.nrec, len(self.ell)))\n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " dlth_dust = Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " clth_dust = self.dl_to_cl(dlth_dust[i][j])\n", + " sample_cov_dust = self.knox_covariance(clth_dust)\n", + " cov_matrix[i][j] = self.noise_cov_matrix[i][j] + sample_cov_cmb + sample_cov_dust\n", + " inv_cov_matrix[i][j] = np.linalg.pinv(cov_matrix[i][j])\n", + " error_bar[i][j] = np.diag(cov_matrix[i][j])\n", + " \n", + " plt.imshow(cov_matrix[i][j])\n", + " plt.colorbar()\n", + " plt.show()\n", + " if param_sampling['Loglike'] == 'fullcov':\n", + " plt.figure()\n", + " cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " inv_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " error_bar = np.zeros((self.nrec, self.nrec, len(self.ell)))\n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " cov_matrix[i][j] = self.noise_cov_matrix[i][j] + sample_cov_cmb\n", + " inv_cov_matrix[i][j] = np.linalg.pinv(cov_matrix[i][j])\n", + " error_bar[i][j] = np.diag(cov_matrix[i][j])\n", + " plt.imshow(cov_matrix[i][j])\n", + " plt.colorbar()\n", + " plt.show()\n", + " if param_sampling['Loglike'] == 'diag':\n", + " error_bar = self.error_ps_noise\n", + "\n", + " # Data vs Fit plot\n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " \n", + " Dl_mcmc = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2])\n", + " Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.05, parameters_values[5], parameters_values[6], parameters_values[2]) \n", + " \n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.05')\n", + " axes[x,y].plot(self.ell[:5], Dl_mcmc[x][y][:5], label = 'MCMC')\n", + " axes[x,y].plot(self.ell[:5], self.mean_ps_sky[x][y][:5], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.05')\n", + " axes[x,y].plot(self.ell, Dl_mcmc[x][y], label = 'MCMC')\n", + " axes[x,y].plot(self.ell, self.mean_ps_sky[x][y], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.05')\n", + " axes[x,y].plot(self.ell, Dl_mcmc[x][y], label = 'MCMC')\n", + " axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], error_bar[x][y], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d30baa9e-9370-4c4e-a0e7-f54d5a9b41b1", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "class NestedSampling(data):\n", + " '''\n", + " Class to perform Nested Sampling in our sky parameters\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + " self.param_sampling = param_sampling\n", + " data.__init__(self)\n", + " self.ell, _ = NamasterEll_sampling().ell()\n", + " self.sky_parameters = self.param_sampling['SKY_PARAMETERS']\n", + " self.ndim, self.sky_parameters_fitted_names, self.sky_parameters_all_names = self.ndim_and_parameters_names()\n", + "\n", + " def ndim_and_parameters_names(self):\n", + " '''\n", + " Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of these parameters\n", + " \n", + " Return :\n", + " - ndim (int) : number of parameters you want to fit\n", + " - sky_parameters_fitted_names (array) [ndim] : list that contains the names of the fitted parameters\n", + " - sky_parameters_all_names (array) : list that contains the names of all the sky parameters\n", + " '''\n", + " \n", + " ndim = 0 \n", + " sky_parameters_fitted_names = [] \n", + " sky_parameters_all_names = []\n", + "\n", + " for parameter in self.sky_parameters:\n", + " sky_parameters_all_names.append(parameter)\n", + " if self.sky_parameters[parameter][0] is True:\n", + " ndim += 1\n", + " sky_parameters_fitted_names.append(parameter)\n", + "\n", + " return ndim, sky_parameters_fitted_names, sky_parameters_all_names\n", + "\n", + " def prior(self, x):\n", + " '''\n", + " Function to define priors to help the MCMC convergence\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : inf if the prior is not respected, 0 otherwise\n", + " '''\n", + " \n", + " for isky_param, sky_param in enumerate(x):\n", + " name = self.sky_parameters_fitted_names[isky_param]\n", + "\n", + " if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]:\n", + " return - np.inf\n", + "\n", + " return 0\n", + " \n", + " def knox_errors(self, clth):\n", + " dcl = np.sqrt(2. / (2 * self.ell + 1) / self.simu_parameters['QUBIC']['fsky'] / self.simu_parameters['Spectrum']['dl']) * clth\n", + " return dcl\n", + "\n", + " def knox_covariance(self, clth):\n", + " dcl = self.knox_errors(clth)\n", + " return np.diag(dcl ** 2)\n", + "\n", + " def loglikelihood(self, tab):\n", + " '''\n", + " loglikelihood function\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : loglikelihood function\n", + " '''\n", + " tab_parameters = np.zeros(len(self.param_sampling['SKY_PARAMETERS']))\n", + " cpt = 0 \n", + "\n", + " for i, iname in enumerate(self.param_sampling['SKY_PARAMETERS']):\n", + " if self.param_sampling['SKY_PARAMETERS'][iname][0] is not True:\n", + " tab_parameters[i] = self.param_sampling['SKY_PARAMETERS'][iname][0]\n", + " else:\n", + " tab_parameters[i] = tab[cpt]\n", + " cpt += 1\n", + "\n", + " r, Alens, nu0_d, Ad, alphad, betad, deltad = tab_parameters\n", + "\n", + " if self.param_sampling['simu']['name'] == 'CMB':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - CMB(self.ell).model_cmb(r, Alens))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Dust':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Sky':\n", + " loglike = self.prior(tab) \n", + " loglike += - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))/(self.error_ps_noise))**2)\n", + " return loglike\n", + "\n", + " def ptform_uniform(self, u):\n", + " '''\n", + " Function to perform an uniform prior transform for the Nested Sampling\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - ptform (array) [ndim] \n", + " '''\n", + "\n", + " ptform = []\n", + " cpt = 0\n", + " for iname in self.sky_parameters_all_names:\n", + " if self.param_sampling['SKY_PARAMETERS'][iname][0] is True:\n", + " ptform.append(u[cpt]*self.param_sampling['SKY_PARAMETERS'][iname][2] - self.param_sampling['SKY_PARAMETERS'][iname][1])\n", + " cpt += 1\n", + " return ptform\n", + "\n", + " def __call__(self):\n", + " '''\n", + " Funtion to perform the Nested Sampling and save the results\n", + " '''\n", + "\n", + " nlive = self.param_sampling['NS']['nlive']\n", + " maxiter = self.param_sampling['NS']['maxiter']\n", + " ell = self.ell\n", + " print(self.simu_parameters)\n", + " \n", + " if self.param_sampling['NS']['DynamicNS'] is True:\n", + " print('Dynamic Nested Sampling !!!')\n", + " with Pool() as pool:\n", + " sampler_ns = DynamicNestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound'])\n", + " sampler_ns.run_nested(print_progress=True, maxiter = maxiter)\n", + " else:\n", + " print('Nested Sampling !')\n", + " with Pool() as pool:\n", + " sampler_ns = NestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound'])\n", + " sampler_ns.run_nested(maxiter = maxiter)\n", + "\n", + " results = sampler_ns.results\n", + "\n", + " # Plot the traceplots\n", + " fig, axes = dyplot.traceplot(results, show_titles=True, labels = self.sky_parameters_fitted_names,\n", + " trace_cmap='viridis', connect=True,\n", + " connect_highlight=range(5))\n", + "\n", + " config = self.param_sampling['simu']['qubic_config']\n", + " nrec = self.param_sampling['simu']['nrec']\n", + " n_real = self.param_sampling['data']['n_real']\n", + " convo = self.param_sampling['simu']['convo']\n", + " if self.param_sampling['NS']['DynamicNS'] is True:\n", + " path_plot = f'{config}_Nrec={nrec}_Convolution={convo}_plots_DynamicNS'\n", + " else:\n", + " path_plot = f'{config}_Nrec={nrec}_Convolution={convo}_plots_NS'\n", + " if not os.path.isdir(path_plot):\n", + " os.makedirs(path_plot)\n", + " #plt.title(f'Traceplot - Nreal={n_real} ' + path_plot)\n", + " plt.savefig(path_plot + f'/traceplot_Nreal={n_real}')\n", + "\n", + " # Runplots\n", + " fig, axes = dyplot.runplot(results)\n", + " #plt.title(f'Runplot - Nreal={n_real} ' + path_plot)\n", + " plt.savefig(path_plot + f'/runplot_Nreal={n_real}')\n", + "\n", + "\n", + " # Triangle plot\n", + " fig, axes = plt.subplots(3, 3)\n", + " axes = axes.reshape((3, 3))\n", + " fg, ax = dyplot.cornerplot(results, color='blue', title_fmt = '.4f', show_titles=True, labels = self.sky_parameters_fitted_names,\n", + " max_n_ticks=3, quantiles=None,\n", + " fig=(fig, axes[:, :3]))\n", + " #fig.suptitle(f'Triangleplot - Nreal={n_real} ' + path_plot)\n", + " plt.show()\n", + " #plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}')\n", + "\n", + " # Data vs Fit plot\n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " samples, weights = results.samples, results.importance_weights()\n", + " mean_ns, cov_ns = dyfunc.mean_and_cov(samples, weights)\n", + " parameters_values = []\n", + " cpt=0\n", + " for parameter in self.sky_parameters:\n", + " if self.sky_parameters[parameter][0] is True:\n", + " parameters_values.append(mean_ns[cpt])\n", + " cpt+=1\n", + " else:\n", + " parameters_values.append(self.sky_parameters[parameter][0])\n", + " Dl_ns = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2])\n", + " Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.15, parameters_values[5], parameters_values[6], parameters_values[2]) \n", + " \n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.15')\n", + " axes[x,y].plot(self.ell[:5], Dl_ns[x][y][:5], label = 'NS')\n", + " axes[x,y].errorbar(self.ell[:5], self.mean_ps_sky[x][y][:5], self.error_ps_sky[x][y][:5], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}')\n", + " plt.show()\n", + "\n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.15')\n", + " axes[x,y].plot(self.ell, Dl_ns[x][y], label = 'NS')\n", + " axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], self.error_ps_sky[x][y], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4abd2225-7e98-4b19-98b1-eae216894ad2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling Parameters {'data': {'path': '/pbs/home/t/tlaclave/sps/Pipeline/spectra/spectra_with_convolution/DB_Nrec=2_spectra/', 'n_real': 200, 'pipeline': 'FMM'}, 'simu': {'nrec': 2, 'qubic_config': 'DB', 'convo': True, 'noise': True, 'name': 'Sky'}, 'MCMC': {'nwalkers': 30, 'mcmc_steps': 300, 'discard': 100, 'stretch_move_factor': 0.7, 'snooker_move_gamma': 1.7, 'thin': 15}, 'NS': {'DynamicNS': True, 'nlive': 1000, 'prior_transform': 'uniform', 'bound': 'multi', 'queue_size': 16, 'maxiter': 1000000000}, 'SKY_PARAMETERS': {'r': [True, 1, 2, -1, 1], 'Alens': [1, 0, 1, 0, 1], 'nu0_d': [353, 0, 1, 0, 1000], 'Ad': [True, 0, 20, 0, 1000], 'alphad': [True, 5, 10, -5, 5], 'betad': [1.54, 0, 1, 1.3, 1.7], 'deltad': [1, 0, 1, 0, 1000]}, 'Method': 'MCMC', 'Loglike': 'fullcov'}\n", + "Chosen method = MCMC\n", + "{'Method': 'FMM', 'path_out': '/pbs/home/t/tlaclave/sps/Pipeline/data_comparison/', 'Sky': {'CMB': {'cmb': True, 'r': [0, 'f', 'r', 0.001], 'Alens': [1, 'f', 'A_{lens}', 1]}, 'Foregrounds': {'Dust': True, 'nu0_d': 353, 'Ad': [4, 'nf', 'A_d', 4], 'betad': [1.54, 'nf', '\\\\beta_d', 1.54], 'alphad': [-0.4, 'nf', '\\\\alpha_d', -0.4], 'deltad': [1, 'nf', '\\\\Delta_d', 1], 'Synchrotron': False, 'nu0_s': 23, 'As': [0, 'nf', 'A_s', 0], 'betas': [-3, 'nf', '\\\\beta_s', -3], 'alphas': [-0.4, 'nf', '\\\\alpha_s', -0.4], 'deltas': [1, 'nf', '\\\\Delta_s', 1], 'DustSync': False, 'eps': [0, 'nf', '\\\\varepsilon', 0]}, 'nside': 256}, 'QUBIC': {'method': 'MM', 'randomreal': True, 'npointings': 5000, 'nsub': 8, 'nrec': 2, 'seed': 1, 'iteration': 1, 'ndet': 1, 'npho150': 1, 'npho220': 1, 'synthbeam_kmax': 1, 'detector_nep': 4.7e-17, 'nhwp_angles': 3, 'dtheta': 15, 'type': 'two', 'covcut': 0.2, 'kappa': 0, 'convolution': True, 'bandpass_correction': True, 'RA_center': 0, 'DEC_center': -57, 'dust_model': 'd0', 'sync_model': 's0', 'fsky': 0.035}, 'Spectrum': {'do_spectrum': False, 'method': 'namaster', 'dl': 30, 'lmin': 40, 'aposize': 10, 'beam_correction': False, 'pixwin_correction': False, 'noise_correction': True, 'nbins': 10}, 'PCG': {'maxiter': 400, 'tol': 1e-20, 'gif': False}, 'Sampler': {'do_sampler': False, 'nsteps': 200, 'N': 5, 'ndim': 2, 'discard': 100, 'markers': False, 'sig_initial_guess': 0.01, 'title_limit': 1}, 'Data': {'datafilename': 'MC', 'planck': {'30GHz': False, '44GHz': False, '70GHz': False, '100GHz': False, '143GHz': False, '217GHz': False, '353GHz': False}, 'level_planck_noise': 0, 'use_external_data': True}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 300/300 [05:52<00:00, 1.18s/it]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed no burn in\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting done\n" + ] + } + ], + "source": [ + "param = param_sampling\n", + "print('Sampling Parameters', param)\n", + "\n", + "if param['Method'] == 'MCMC':\n", + " print(\"Chosen method = MCMC\")\n", + " MCMC()()\n", + "elif param['Method'] == 'NS':\n", + " print(\"Chosen method = Nested Sampling\")\n", + " NestedSampling()()\n", + "else:\n", + " print('Wrong sampling method')\n", + "\n", + "print(\"Fitting done\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ceb11400-063b-4d7a-912b-e1384abe95d7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "108c3849-1186-4577-acb4-b38b07cef7b6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3bc31d4-7c1d-41e0-b02d-fa76c1af5526", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f5d8d40-9631-40c8-a4f1-7af6dae2b59e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "QUBIC with Python 3.8", + "language": "python", + "name": "python-3.8" + }, + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/__pycache__/pipeline_notebook.cpython-38.pyc b/notebook/__pycache__/pipeline_notebook.cpython-38.pyc new file mode 100644 index 000000000..2f7de0d5a Binary files /dev/null and b/notebook/__pycache__/pipeline_notebook.cpython-38.pyc differ diff --git a/notebook/notebook_JC.ipynb b/notebook/notebook_JC.ipynb new file mode 100644 index 000000000..00528d0dd --- /dev/null +++ b/notebook/notebook_JC.ipynb @@ -0,0 +1,4552 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ef80106d-e269-4b69-aed4-886d580de0a9", + "metadata": {}, + "outputs": [], + "source": [ + "#### General packages\n", + "import pickle\n", + "import os\n", + "import os.path as op\n", + "import sys\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy\n", + "import healpy as hp\n", + "import emcee\n", + "import yaml\n", + "from multiprocessing import Pool\n", + "from getdist import plots, MCSamples\n", + "import getdist\n", + "import time\n", + "\n", + "sys.path.append('/pbs/home/t/tlaclave/sps/Pipeline')\n", + "\n", + "#### QUBIC packages\n", + "import qubic\n", + "from qubic import NamasterLib as nam\n", + "from qubicpack.utilities import Qubic_DataDir\n", + "from qubic import QubicSkySim as qss\n", + "from pysimulators import FitsArray\n", + "from qubic import fibtools as ft\n", + "from qubic import camb_interface as qc\n", + "from qubic import SpectroImLib as si\n", + "import mapmaking.systematics as acq\n", + "from qubic import mcmc\n", + "from qubic import AnalysisMC as amc\n", + "from qubic.beams import BeamGaussian\n", + "import fgb.component_model as c\n", + "import fgb.mixing_matrix as mm\n", + "from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator\n", + "from pipeline_notebook import *\n", + "from pyoperators import *\n", + "\n", + "#### Nested Sampling packages\n", + "import dynesty\n", + "from dynesty import plotting as dyplot\n", + "from dynesty import NestedSampler\n", + "from dynesty import DynamicNestedSampler\n", + "from dynesty import utils as dyfunc\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "7e82f530-9700-4cfc-84a7-d77e07c53891", + "metadata": {}, + "source": [ + "Step-by-step explanations of the notebook" + ] + }, + { + "cell_type": "markdown", + "id": "4077c2a4-6a8e-4399-8562-9580f5f4d7fd", + "metadata": {}, + "source": [ + "1) Frequency Map-Making\n", + "\n", + "All the FMM codes are stored on : https://github.com/mathias77515/Pipeline/tree/Tom-dev\n", + "You have to use the yaml file 'params.yml' (open outside this notebook) in order to configure the FMM parameters. After that, the line 'PipelineEnd2End(comm).main()' will start a FMM simulation and store the results (maps, parameters, ...) into a pickle file at the 'path_out' (in params.yaml) location. You can import this file(s) as a Python dictionnary with pickle.load(open(your_path, 'rb')). I have write examples in following cells, even to import many simulations easily. This pickle file(s) will be used to compute the power spectra." + ] + }, + { + "cell_type": "markdown", + "id": "0f12be3c-8f90-4279-99ee-167527b4653d", + "metadata": {}, + "source": [ + "2) Power Spectra\n", + "\n", + "To compute power spectra, you will use the class Spectra. It will work with the dictionnary 'param_spectrum', where you will have to write the path for your noise and sky (cmb + dust) realisations. I think that it's more conveniant to compute the power spectrum for one noise realisation and one sky realisation simultaneously, because it allows Spectra to return a pickle file with these two spectra. It's just a technical choice but it's very easy to change it if you want in the __init__ function. You will have to change the class Data in order to take into account this kind of modification.\n", + "Spectra will compute auto-spectrum for each reconstructed frequency sub-bands and cross-spectrum between all the reconstructed frequency sub-bands, and store them in an array with dimension = Nrec x Nrec (for both noise and sky realisation), with the diagonal fills with auto-spectra and the triangle parts fill with cross-spectra. The function 'find_data' and 'save' are used to select the pair of realisations (noise and sky) on which the power spectra will be computed. The result will be stored in a pickle file at the 'path_out' location." + ] + }, + { + "cell_type": "markdown", + "id": "209eb13e-a37f-4b7a-acbf-c7a3a648ecb5", + "metadata": {}, + "source": [ + "3) Fitting\n", + "\n", + "To fit the chosen parameter(s) with your spectra, you will have to use the 'param_sampling' dictionnary. With this dictionnary, you will give the path where your power spectra are store and the simulations parameters (just for plots names if I'm not mistaken...). You will also choose the fitting method (Nested Sampling or MCMC) anf their parameters. After that, the code will correct the power spectra of the sky using the noise power spectra and use them to achieve the fit. Some useful plots will be shown at the end to understand if the fit was successful and the triangle plot with the estimation of your parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "3a83da7b-d717-474b-a763-77a565eb6764", + "metadata": {}, + "outputs": [], + "source": [ + "# MPI object\n", + "comm = MPI.COMM_WORLD" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "39f72282-079c-4b14-aefd-68262bd461bc", + "metadata": {}, + "outputs": [], + "source": [ + "##############################\n", + "#### Frequency Map-Making ####\n", + "##############################" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "b8e60f82-d50f-496f-84b8-89bfb3eb04be", + "metadata": {}, + "outputs": [], + "source": [ + "# Command to start FMM, according to the parameters in \"params.yml\"\n", + "# This will create a pickle file at the location setted by 'path_out' in this yaml file\n", + "\n", + "### Please note that you don't need to simulate maps every time you launch the notebook, you can just use a loop to generate N maps and use the same ones each time\n", + "\n", + "#PipelineEnd2End(comm).main()\n", + "\n", + "### You also need to do a simulation for CMB & Dust = False, in order to have a noise realisation. It is mandatory for the fitting part" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "11b94ada-9bd0-40de-82b7-70596d29c726", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'your_path_for_sky_simulation' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Import the FMM results\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m FMM_sky \u001b[38;5;241m=\u001b[39m pickle\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;28mopen\u001b[39m(\u001b[43myour_path_for_sky_simulation\u001b[49m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m 3\u001b[0m FMM_noise \u001b[38;5;241m=\u001b[39m pickle\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;28mopen\u001b[39m(your_path_for_noise_simulation, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Import the maps and the parameters used to simulate them from pickle files generated with pipeline.py\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'your_path_for_sky_simulation' is not defined" + ] + } + ], + "source": [ + "# Import the FMM results\n", + "FMM_sky = pickle.load(open(your_path_for_sky_simulation, 'rb'))\n", + "FMM_noise = pickle.load(open(your_path_for_noise_simulation, 'rb'))\n", + "\n", + "# Import the maps and the parameters used to simulate them from pickle files generated with pipeline.py\n", + "map_sky = FMM_sky['maps']\n", + "simulation_parameters = FMM_sky['maps']\n", + "map_noise = FMM_noise['maps']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7eb71a5-8321-456b-981c-a5e0a2354b0a", + "metadata": {}, + "outputs": [], + "source": [ + "# I advise to compute many maps using pipeline.py on a computing cluster\n", + "# you can import this by using the commands :\n", + "your_path_sky, your_path_noise = '', ''\n", + "sky_names = os.listdir(your_path_sky)\n", + "noise_names = os.listdir(your_path_noise)\n", + "map_sky, map_noise = [], []\n", + "for i in range(len(your_simulations_names)):\n", + " pickle_sky = pickle.load(open(your_path_sky + '/' + sky_names[i], 'rb'))\n", + " pickle_noise = pickle.load(open(your_path_noise + '/' + noise_names[i], 'rb'))\n", + " map_sky.append(pickle_sky['maps'])\n", + " map_noise.append(pickle_noise['maps'])\n", + " \n", + "simulation_parameters = pickle_sky['parameters']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "298fb639-c317-43ac-b7a9-af5b0862533c", + "metadata": {}, + "outputs": [], + "source": [ + "#######################\n", + "#### Power Spectra ####\n", + "#######################" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "8ac6ed1d-511e-404a-bfc8-34cb3065f547", + "metadata": {}, + "outputs": [], + "source": [ + "# We define a dictionnary in order to give the usefull parameters to the Spectra Class\n", + "param_spectrum = {'data': \n", + " # Path where the spectra will be stored\n", + " {'path_out': '/pbs/home/t/tlaclave/sps/Pipeline/spectra/spectra_comparison_pixwin_test/', \n", + " # Path where the pickle files of the noise realisations are stored\n", + " 'path_noise': '/pbs/home/t/tlaclave/sps/Pipeline/data_comparison/DB_Nrec=2_Noise', \n", + " # Path where the pickle files of the sky realisations are stored\n", + " 'path_sky': '/pbs/home/t/tlaclave/sps/Pipeline/data_comparison/DB_Nrec=2_Sky'},\n", + " 'simu': \n", + " # Parameters of the sky or noise realisations\n", + " {'nrec': 2, \n", + " 'qubic_config': 'DB'}, \n", + " 'Spectrum': \n", + " # Namaster parameters\n", + " {'lmin': 40, \n", + " 'dl': 30, \n", + " 'nbins': 16}\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "d125925d-3d7a-4f95-9a3a-1db19e4cecfe", + "metadata": {}, + "outputs": [], + "source": [ + "class Spectra:\n", + " '''\n", + " Class to compute the different spectra for our realisations\n", + " '''\n", + "\n", + " def __init__(self, iteration, param_spectrum):\n", + "\n", + " self.iter = iteration\n", + " self.param_spectrum = param_spectrum\n", + " self.path_sky = self.param_spectrum['data']['path_sky']\n", + " self.path_noise = self.param_spectrum['data']['path_noise']\n", + " self.pkl_sky = self.find_data(self.path_sky)\n", + " self.pkl_noise = self.find_data(self.path_noise)\n", + " self.sky_maps = self.pkl_sky['maps']\n", + " self.noise_maps = self.pkl_noise['maps']\n", + " self.nrec = self.param_spectrum['simu']['nrec']\n", + " self.nsub = self.pkl_sky['parameters']['QUBIC']['nsub']\n", + " self.nside = self.pkl_sky['parameters']['Sky']['nside']\n", + " self.fsub = int(self.nsub / self.nrec)\n", + " self.comm = MPI.COMM_WORLD\n", + " self.size = self.comm.Get_size()\n", + " self.my_dict, _ = self.get_dict()\n", + "\n", + " self.ell, self.namaster = NamasterEll(self.iter, self.param_spectrum).ell()\n", + " _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " self.allnus = np.array(list(allnus150) + list(allnus220))\n", + " self.allfwhm = self.get_allfwhm()\n", + " print('allnus', self.allnus)\n", + " print('allfwhm', self.allfwhm)\n", + "\n", + " def find_data(self, path):\n", + " '''\n", + " Function to extract the pickle file of one realisation associated to the path and the iteration number given.\n", + "\n", + " Argument :\n", + " - path (str) : path where the pkl files are located\n", + "\n", + " Return :\n", + " - pkl file dictionary (dict)\n", + " '''\n", + "\n", + " data_names = os.listdir(path)\n", + " one_realisation = pickle.load(open(path + '/' + data_names[self.iter], 'rb'))\n", + "\n", + " return one_realisation\n", + "\n", + " def get_dict(self):\n", + " \"\"\"\n", + " Method to modify the qubic dictionary.\n", + " \"\"\"\n", + "\n", + " nu_ave, delta_nu_over_nu = self.get_ultrawideband_config()\n", + " params = self.pkl_sky['parameters']\n", + "\n", + " args = {'npointings':params['QUBIC']['npointings'], \n", + " 'nf_recon':params['QUBIC']['nrec'], \n", + " 'nf_sub':params['QUBIC']['nsub'], \n", + " 'nside':params['Sky']['nside'], \n", + " 'MultiBand':True, \n", + " 'period':1, \n", + " 'RA_center':params['QUBIC']['RA_center'], \n", + " 'DEC_center':params['QUBIC']['DEC_center'],\n", + " 'filter_nu':nu_ave*1e9, \n", + " 'noiseless':False, \n", + " 'comm':self.comm, \n", + " 'dtheta':params['QUBIC']['dtheta'],\n", + " 'nprocs_sampling':1, \n", + " 'nprocs_instrument':self.size,\n", + " 'photon_noise':True, \n", + " 'nhwp_angles':params['QUBIC']['nhwp_angles'], \n", + " 'effective_duration':3, \n", + " 'filter_relative_bandwidth':delta_nu_over_nu, \n", + " 'type_instrument':'wide', \n", + " 'TemperatureAtmosphere150':None, \n", + " 'TemperatureAtmosphere220':None,\n", + " 'EmissivityAtmosphere150':None, \n", + " 'EmissivityAtmosphere220':None, \n", + " 'detector_nep':float(params['QUBIC']['detector_nep']), \n", + " 'synthbeam_kmax':params['QUBIC']['synthbeam_kmax']}\n", + "\n", + " args_mono = args.copy()\n", + " args_mono['nf_recon'] = 1\n", + " args_mono['nf_sub'] = 1\n", + "\n", + " ### Get the default dictionary\n", + " dictfilename = 'dicts/pipeline_demo.dict'\n", + " d = qubic.qubicdict.qubicDict()\n", + " d.read_from_file(dictfilename)\n", + " dmono = d.copy()\n", + "\n", + " for i in args.keys():\n", + " d[str(i)] = args[i]\n", + " dmono[str(i)] = args_mono[i]\n", + "\n", + " return d, dmono\n", + "\n", + " def get_ultrawideband_config(self):\n", + " \"\"\"\n", + " Method that pre-compute UWB configuration.\n", + " \"\"\"\n", + "\n", + " nu_up = 247.5\n", + " nu_down = 131.25\n", + " nu_ave = np.mean(np.array([nu_up, nu_down]))\n", + " delta = nu_up - nu_ave\n", + " return nu_ave, 2*delta/nu_ave\n", + " \n", + " def synthbeam(self, synthbeam_peak150_fwhm, dtype=np.float32):\n", + " sb = SyntheticBeam()\n", + " sb.dtype = np.dtype(dtype)\n", + " nripples = self.my_dict['nripples']\n", + " synthbeam_peak150_fwhm = np.radians(self.my_dict['synthbeam_peak150_fwhm'])\n", + " if not nripples:\n", + " sb.peak150 = BeamGaussian(synthbeam_peak150_fwhm)\n", + " else:\n", + " sb.peak150 = BeamGaussianRippled(synthbeam_peak150_fwhm,\n", + " nripples=nripples)\n", + " return sb\n", + " \n", + " def get_allfwhm(self):\n", + " '''\n", + " Function to compute the fwhm for all sub bands.\n", + "\n", + " Return :\n", + " - allfwhm (list [nrec * nsub])\n", + " '''\n", + "\n", + " synthbeam_peak150_fwhm = np.radians(self.my_dict['synthbeam_peak150_fwhm'])\n", + " synthbeam = self.synthbeam(synthbeam_peak150_fwhm, dtype=np.float32)\n", + " if self.pkl_sky['parameters']['QUBIC']['convolution'] is True:\n", + " allfwhm = synthbeam.peak150.fwhm * (150 / self.allnus)\n", + " else:\n", + " allfwhm = np.zeros(len(self.allnus))\n", + "\n", + " return allfwhm\n", + "\n", + " def compute_auto_spectrum(self, map, fwhm):\n", + " '''\n", + " Function to compute the auto-spectrum of a given map\n", + "\n", + " Argument : \n", + " - map(array) [nrec/ncomp, npix, nstokes] : map to compute the auto-spectrum\n", + " - allfwhm(float) : in radian\n", + " Return : \n", + " - (list) [len(ell)] : BB auto-spectrum\n", + " '''\n", + "\n", + " DlBB = self.namaster.get_spectra(map=map.T, map2=None, beam_correction = np.rad2deg(fwhm))[1][:, 2]\n", + " return DlBB\n", + "\n", + " def compute_cross_spectrum(self, map1, fwhm1, map2, fwhm2):\n", + " '''\n", + " Function to compute cross-spectrum, taking into account the different resolution of each sub-bands\n", + "\n", + " Arguments :\n", + " - map1 & map2 (array [nrec/ncomp, npix, nstokes]) : the two maps needed to compute the cross spectrum\n", + " - fwhm1 & fwhm2 (float) : the respective fwhm for map1 & map2 in radian\n", + "\n", + " Return : \n", + " - (list) [len(ell)] : BB cross-spectrum\n", + " '''\n", + "\n", + " # Put the map with the highest resolution at the worst one before doing the cross spectrum\n", + " # Important because the two maps had to be at the same resolution and you can't increase the resolution\n", + " if fwhm1 Third * x - Second, with x uniformly distributed between [0,1]\n", + " # Fourth : Min value of the parameter\n", + " # Fifth : Max value of the parameter\n", + " # Second to Fifth aren't relevant if First != True\n", + " 'SKY_PARAMETERS': \n", + " {'r': [True, 1, 2, -1, 1], \n", + " 'Alens': [1, 0, 1, 0, 1], \n", + " 'nu0_d': [353, 0, 1, 0, 1000], \n", + " 'Ad': [True, 0, 20, 0, 1000], \n", + " 'alphad': [True, 5, 10, -5, 5], \n", + " 'betad': [1.54, 0, 1, 1.3, 1.7], \n", + " 'deltad': [1, 0, 1, 0, 1000]}, \n", + " # Fitting method\n", + " 'Method': 'MCMC',\n", + " 'Loglike': 'fullcov'}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a9f7cec-2b5d-437a-9bee-4725aa8c525e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "59232252-7b7c-4713-99dc-c0d54d79e1d2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class data:\n", + " '''\n", + " Class to extract of the power spectra computed with spectrum.py and to compute useful things\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + " self.param = param_sampling\n", + " self.path_spectra = self.param['data']['path']\n", + " self.power_spectra_sky, self.power_spectra_noise, self.simu_parameters, self.coverage = self.import_power_spectra(self.path_spectra)\n", + " self.nsub = self.simu_parameters['QUBIC']['nsub']\n", + " self.nrec = self.simu_parameters['QUBIC']['nrec']\n", + " self.fsub = int(self.nsub / self.nrec)\n", + " self.nreal = self.param['data']['n_real']\n", + " _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25)\n", + " self.allnus = np.array(list(allnus150) + list(allnus220))\n", + " self.nus = self.average_nus()\n", + "\n", + " self.mean_ps_sky, self.error_ps_sky = self.compute_mean_std(self.power_spectra_sky)\n", + " self.mean_ps_noise, self.error_ps_noise = self.compute_mean_std(self.power_spectra_noise)\n", + " \n", + " if self.param['simu']['noise'] is True :\n", + " self.mean_ps_sky = self.spectra_noise_correction(self.mean_ps_sky, self.mean_ps_noise)\n", + " \n", + " def import_power_spectra(self, path):\n", + " '''\n", + " Function to import all the power spectra computed with spectrum.py and store in pickle files\n", + "\n", + " Argument :\n", + " - path (str) : path to indicate where the pkl files are\n", + "\n", + " Return :\n", + " - sky power spectra (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)]\n", + " - noise power spectra (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)]\n", + " - simulations parameters (dict)\n", + " - simulations coverage (array)\n", + " - bands frequencies for FMM (array) [nrec]\n", + " '''\n", + "\n", + " power_spectra_sky, power_spectra_noise = [], []\n", + " names = os.listdir(path)\n", + " for i in range(self.param['data']['n_real']):\n", + " ps = pickle.load(open(path + '/' + names[i], 'rb'))\n", + " power_spectra_sky.append(ps['sky_ps'])\n", + " power_spectra_noise.append(ps['noise_ps'])\n", + " return power_spectra_sky, power_spectra_noise, ps['parameters'], ps['coverage']\n", + " \n", + " def average_nus(self):\n", + " \n", + " nus_eff = []\n", + " f = int(self.nsub / self.nrec)\n", + " for i in range(self.nrec):\n", + " nus_eff += [np.mean(self.allnus[i*f : (i+1)*f], axis=0)]\n", + " return np.array(nus_eff)\n", + "\n", + " def compute_mean_std(self, ps):\n", + " '''\n", + " Function to compute the mean ans the std on our power spectra realisations\n", + "\n", + " Argument : \n", + " - power spectra array (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)]\n", + "\n", + " Return :\n", + " - mean (array) [nrec/ncomp, nrec/ncomp, len(ell)]\n", + " - std (array) [nrec/ncomp, nrec/ncomp, len(ell)]\n", + " '''\n", + "\n", + " return np.mean(ps, axis = 0), np.std(ps, axis = 0)\n", + "\n", + " def spectra_noise_correction(self, mean_data, mean_noise):\n", + " '''\n", + " Function to remove the mean of the noise realisations to the spectra computed\n", + "\n", + " Arguments :\n", + " - mean sky power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] : array that will contain the mean of all the auto and cross spectra of the sky realisations\n", + " - mean noise power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] : array that will contain the mean of all the auto and cross spectra of the noise realisation\n", + " \n", + " Return :\n", + " - corrected mean sky power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)]\n", + " '''\n", + "\n", + " for i in range(np.shape(mean_data)[0]):\n", + " for j in range(np.shape(mean_data)[1]):\n", + " mean_data[i, j, :] -= mean_noise[i, j, :]\n", + " return mean_data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "30ed1398-57e1-43ff-b795-9641189f3246", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class NamasterEll_sampling(data):\n", + " '''\n", + " Class to compute the ell list using NamasterLib\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + " self.param = param_sampling\n", + " data.__init__(self)\n", + "\n", + " def ell(self):\n", + " \n", + " nside = self.simu_parameters['Sky']['nside']\n", + "\n", + " # Call the Namaster class & create the ell list \n", + " seenpix = self.coverage/np.max(self.coverage) < 0.2\n", + " lmin, lmax, delta_ell = self.simu_parameters['Spectrum']['lmin'], 2*nside-1, self.simu_parameters['Spectrum']['dl']\n", + " namaster = nam.Namaster(weight_mask = list(~np.array(seenpix)), lmin = lmin, lmax = lmax, delta_ell = delta_ell)\n", + "\n", + " ell = namaster.get_binning(nside)[0]\n", + " \n", + " return ell, namaster" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9d4a97be-48d1-49cf-b24f-4603b6fdabdd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class CMB:\n", + " '''\n", + " Class to define the CMB model\n", + " '''\n", + "\n", + " def __init__(self, ell):\n", + " \n", + " self.ell = ell\n", + "\n", + " def cl_to_dl(self, cl):\n", + " '''\n", + " Function to convert the cls into the dls\n", + " '''\n", + "\n", + " dl = np.zeros(self.ell.shape[0])\n", + " for i in range(self.ell.shape[0]):\n", + " dl[i] = (self.ell[i]*(self.ell[i]+1)*cl[i])/(2*np.pi)\n", + " return dl\n", + "\n", + " def get_pw_from_planck(self, r, Alens):\n", + " '''\n", + " Function to compute the CMB power spectrum from the Planck data\n", + " '''\n", + "\n", + " CMB_CL_FILE = op.join('/sps/qubic/Users/TomLaclavere/mypackages/Cls_Planck2018_%s.fits')\n", + " power_spectrum = hp.read_cl(CMB_CL_FILE%'lensed_scalar')[:,:4000]\n", + " \n", + " if Alens != 1.:\n", + " power_spectrum[2] *= Alens\n", + " \n", + " if r:\n", + " power_spectrum += r * hp.read_cl(CMB_CL_FILE%'unlensed_scalar_and_tensor_r1')[:,:4000]\n", + " \n", + " return np.interp(self.ell, np.linspace(1, 4001, 4000), power_spectrum[2])\n", + "\n", + " def model_cmb(self, r, Alens):\n", + " '''\n", + " Define the CMB model, depending on r and Alens\n", + " '''\n", + "\n", + " dlBB = self.cl_to_dl(self.get_pw_from_planck(r, Alens))\n", + " return dlBB" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "12b61ced-0d90-4109-9384-b3540d3f208a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class Dust:\n", + " '''\n", + " Function to define the Dust model\n", + " '''\n", + "\n", + " def __init__(self, ell, nus):\n", + " \n", + " self.ell = ell\n", + " self.nus = nus\n", + " self.nrec = len(self.nus)\n", + "\n", + " def scale_dust(self, nu, nu0_d, betad, temp=20):\n", + " '''\n", + " Function to compute the dust mixing matrix element, depending on the frequency\n", + " '''\n", + "\n", + " comp = c.Dust(nu0 = nu0_d, temp=temp, beta_d = betad)\n", + " A = mm.MixingMatrix(comp).evaluator(np.array([nu]))()[0]\n", + "\n", + " return A\n", + "\n", + " def fnus_dust(self, nus, nu0_d, betad):\n", + " '''\n", + " Function to compute the mixing matrix elements for all the frequencies considered in your realisations\n", + " '''\n", + "\n", + " fnus = np.zeros(self.nrec)\n", + " for nu_index in range(self.nrec):\n", + " fnus[nu_index] = self.scale_dust(nus[nu_index], nu0_d, betad)\n", + "\n", + " return fnus\n", + "\n", + " def model_dust_frequency(self, Ad, alphad, deltad, fnu1, fnu2):\n", + " '''\n", + " Function to define the Dust model for two frequencies\n", + " '''\n", + "\n", + " return Ad * deltad * fnu1 * fnu2 * (self.ell/80)**alphad\n", + "\n", + " def model_dust(self, Ad, alphad, betad, deltad, nu0_d):\n", + " '''\n", + " Function defining the Dust model for all frequencies, depending on Ad, alphad, betad, deltad & nu0_d\n", + " '''\n", + " \n", + " fnus = self.fnus_dust(self.nus, nu0_d, betad)\n", + "\n", + " models = np.zeros((self.nrec, self.nrec, len(self.ell)))\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " models[i][j][:] = self.model_dust_frequency(Ad, alphad, deltad, fnus[i], fnus[j])\n", + " return models" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d6359333-062b-450a-a4e4-4abb376a4521", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "class MCMC(data):\n", + " '''\n", + " Class to perform MCMC on the chosen sky parameters\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + "\n", + " self.param_sampling = param_sampling\n", + " data.__init__(self)\n", + " self.ell, _ = NamasterEll_sampling().ell()\n", + " self.sky_parameters = self.param_sampling['SKY_PARAMETERS']\n", + " self.ndim, self.sky_parameters_fitted_names, self.sky_parameters_all_names = self.ndim_and_parameters_names()\n", + " \n", + " if self.param_sampling['Loglike'] == 'cov' or 'fullcov':\n", + " reshaped_noise_ps = np.reshape(self.power_spectra_noise, (self.nrec, self.nrec, self.nreal, 16))\n", + " self.noise_cov_matrix = np.zeros((self.nrec, self.nrec, 16, 16)) \n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " self.noise_cov_matrix[i, j] = np.cov(reshaped_noise_ps[i,j], rowvar = False)\n", + "\n", + " def ndim_and_parameters_names(self):\n", + " '''\n", + " Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of these parameters\n", + " \n", + " Return :\n", + " - ndim (int) : number of parameters you want to fit\n", + " - sky_parameters_fitted_names (array) [ndim] : list that contains the names of the fitted parameters\n", + " - sky_parameters_all_names (array) : list that contains the names of all the sky parameters\n", + " '''\n", + " \n", + " ndim = 0 \n", + " sky_parameters_fitted_names = [] \n", + " sky_parameters_all_names = []\n", + "\n", + " for parameter in self.sky_parameters:\n", + " sky_parameters_all_names.append(parameter)\n", + " if self.sky_parameters[parameter][0] is True:\n", + " ndim += 1\n", + " sky_parameters_fitted_names.append(parameter)\n", + "\n", + " return ndim, sky_parameters_fitted_names, sky_parameters_all_names\n", + " \n", + " def dl_to_cl(self, dl):\n", + " cl = np.zeros(self.ell.shape[0])\n", + " for i in range(self.ell.shape[0]):\n", + " cl[i] = dl[i]*(2*np.pi)/(self.ell[i]*(self.ell[i] + 1))\n", + " return cl\n", + " \n", + " def knox_errors(self, clth):\n", + " dcl = np.sqrt(2. / (2 * self.ell + 1) / self.simu_parameters['QUBIC']['fsky'] / self.simu_parameters['Spectrum']['dl']) * clth\n", + " return dcl\n", + "\n", + " def knox_covariance(self, clth):\n", + " dcl = self.knox_errors(clth)\n", + " return np.diag(dcl ** 2)\n", + " \n", + " def initial_conditions(self):\n", + " '''\n", + " Function to computes the MCMC initial conditions\n", + "\n", + " Return :\n", + " - p0 (array) [nwalkers, ndim] : array that contains all the initial conditions for the mcmc\n", + " '''\n", + "\n", + " nwalkers = self.param_sampling['MCMC']['nwalkers']\n", + "\n", + " p0 = np.zeros((nwalkers, self.ndim))\n", + " for i in range(nwalkers):\n", + " for j in range(self.ndim):\n", + " name = self.sky_parameters_fitted_names[j]\n", + " p0[i,j] = np.random.random() * self.param_sampling['SKY_PARAMETERS'][name][2] - self.param_sampling['SKY_PARAMETERS'][name][1]\n", + "\n", + " return p0\n", + "\n", + " def prior(self, x):\n", + " '''\n", + " Function to define priors to help the MCMC convergence\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : inf if the prior is not respected, 0 otherwise\n", + " '''\n", + " \n", + " for isky_param, sky_param in enumerate(x):\n", + " name = self.sky_parameters_fitted_names[isky_param]\n", + "\n", + " if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]:\n", + " return - np.inf\n", + "\n", + " return 0\n", + "\n", + " def loglikelihood(self, tab):\n", + " '''\n", + " loglikelihood function\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : loglikelihood function\n", + " '''\n", + " tab_parameters = np.zeros(len(self.param_sampling['SKY_PARAMETERS']))\n", + " cpt = 0 \n", + "\n", + " for i, iname in enumerate(self.param_sampling['SKY_PARAMETERS']):\n", + " if self.param_sampling['SKY_PARAMETERS'][iname][0] is not True:\n", + " tab_parameters[i] = self.param_sampling['SKY_PARAMETERS'][iname][0]\n", + " else:\n", + " tab_parameters[i] = tab[cpt]\n", + " cpt += 1\n", + "\n", + " r, Alens, nu0_d, Ad, alphad, betad, deltad = tab_parameters\n", + " if self.param_sampling['simu']['noise'] == False:\n", + " loglike = self.prior(tab) \n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j])\n", + " #loglike = self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))**2)\n", + " return loglike\n", + "\n", + " if self.param_sampling['simu']['name'] == 'CMB':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - CMB(self.ell).model_cmb(r, Alens))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Dust':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Sky':\n", + " loglike = self.prior(tab) \n", + " if self.param_sampling['Loglike'] == 'fullcov':\n", + " \n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " dlth_dust = Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " clth_dust = self.dl_to_cl(dlth_dust[i][j])\n", + " sample_cov_dust = self.knox_covariance(clth_dust)\n", + " cov_matrix = self.noise_cov_matrix[i][j] + sample_cov_cmb + sample_cov_dust\n", + " inv_cov_matrix = np.linalg.pinv(cov_matrix)\n", + " loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j])\n", + " return loglike\n", + " if self.param_sampling['Loglike'] == 'cov':\n", + " \n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " cov_matrix = self.noise_cov_matrix[i][j] + sample_cov_cmb\n", + " inv_cov_matrix = np.linalg.pinv(cov_matrix)\n", + " loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j])\n", + " return loglike\n", + " if self.param_sampling['Loglike'] == 'diag' :\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " loglike += - 0.5 * ((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))[i][j]/(self.error_ps_noise[i][j]))**2\n", + " return loglike\n", + "\n", + " def __call__(self):\n", + " '''\n", + " Funtion to perform the MCMC and save the results\n", + " '''\n", + "\n", + " # Define the MCMC parameters, initial conditions and ell list\n", + " nwalkers = self.param_sampling['MCMC']['nwalkers']\n", + " mcmc_steps = self.param_sampling['MCMC']['mcmc_steps']\n", + " p0 = self.initial_conditions()\n", + " ell = self.ell\n", + " \n", + " print(self.simu_parameters)\n", + " \n", + " # Start the MCMC\n", + " with Pool() as pool:\n", + " sampler = emcee.EnsembleSampler(nwalkers, self.ndim, log_prob_fn = self.loglikelihood, pool = pool, moves = [(emcee.moves.StretchMove(), self.param_sampling['MCMC']['stretch_move_factor']), (emcee.moves.DESnookerMove(gammas=self.param_sampling['MCMC']['snooker_move_gamma']), 1 - self.param_sampling['MCMC']['stretch_move_factor'])])\n", + " sampler.run_mcmc(p0, mcmc_steps, progress=True)\n", + "\n", + " samples_flat = sampler.get_chain(flat = True, discard = self.param_sampling['MCMC']['discard'], thin = self.param_sampling['MCMC']['thin'])\n", + " samples = sampler.get_chain()\n", + "\n", + " # Plot the walkers\n", + " fig, ax = plt.subplots(1, self.ndim, figsize = (15, 5))\n", + " for j in range(self.ndim):\n", + " for i in range(nwalkers):\n", + " ax[j].plot(samples[:, i, j])\n", + " ax[j].set_title(self.sky_parameters_fitted_names[j])\n", + " \n", + " config = self.param_sampling['simu']['qubic_config']\n", + " nrec = self.param_sampling['simu']['nrec']\n", + " n_real = self.param_sampling['data']['n_real']\n", + " convo = self.param_sampling['simu']['convo']\n", + " path_plot = f'{config}_Nrec={nrec}_Convolution={convo}_plots_MCMC'\n", + " if not os.path.isdir(path_plot):\n", + " os.makedirs(path_plot)\n", + " fig.suptitle(f'Walkers plot - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/walkers_plot_Nreal={n_real}')\n", + " plt.show()\n", + "\n", + " # Triangle plot\n", + " plt.figure()\n", + " s = MCSamples(samples=samples_flat, names=self.sky_parameters_fitted_names, labels=self.sky_parameters_fitted_names)\n", + " g = plots.get_subplot_plotter(width_inch=10)\n", + " g.triangle_plot([s], filled=True, title_limit=1)\n", + " for ax in g.subplots[:,0]:\n", + " ax.axvline(0, color='gray')\n", + "\n", + " path_plot_triangle = f'{config}_Nrec={nrec}_plots'\n", + " #fig.suptitle(f'Triangle plot - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " mcmc_values = np.mean(samples_flat, axis=0)\n", + " parameters_values = []\n", + " cpt=0\n", + " for parameter in self.sky_parameters:\n", + " if self.sky_parameters[parameter][0] is True:\n", + " parameters_values.append(mcmc_values[cpt])\n", + " cpt+=1\n", + " else:\n", + " parameters_values.append(self.sky_parameters[parameter][0])\n", + " r, Alens, nu0_d, Ad, alphad, betad, deltad = parameters_values\n", + " \n", + " if param_sampling['Loglike'] == 'fullcov':\n", + " plt.figure()\n", + " cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " inv_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " error_bar = np.zeros((self.nrec, self.nrec, len(self.ell)))\n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " dlth_dust = Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " clth_dust = self.dl_to_cl(dlth_dust[i][j])\n", + " sample_cov_dust = self.knox_covariance(clth_dust)\n", + " cov_matrix[i][j] = self.noise_cov_matrix[i][j] + sample_cov_cmb + sample_cov_dust\n", + " inv_cov_matrix[i][j] = np.linalg.pinv(cov_matrix[i][j])\n", + " error_bar[i][j] = np.diag(cov_matrix[i][j])\n", + " \n", + " plt.imshow(cov_matrix[i][j])\n", + " plt.colorbar()\n", + " plt.show()\n", + " if param_sampling['Loglike'] == 'fullcov':\n", + " plt.figure()\n", + " cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " inv_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell)))\n", + " error_bar = np.zeros((self.nrec, self.nrec, len(self.ell)))\n", + " clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens)\n", + " sample_cov_cmb = self.knox_covariance(clth_cmb)\n", + " for i in range(self.nrec):\n", + " for j in range(self.nrec):\n", + " cov_matrix[i][j] = self.noise_cov_matrix[i][j] + sample_cov_cmb\n", + " inv_cov_matrix[i][j] = np.linalg.pinv(cov_matrix[i][j])\n", + " error_bar[i][j] = np.diag(cov_matrix[i][j])\n", + " plt.imshow(cov_matrix[i][j])\n", + " plt.colorbar()\n", + " plt.show()\n", + " if param_sampling['Loglike'] == 'diag':\n", + " error_bar = self.error_ps_noise\n", + "\n", + " # Data vs Fit plot\n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " \n", + " Dl_mcmc = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2])\n", + " Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.05, parameters_values[5], parameters_values[6], parameters_values[2]) \n", + " \n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.05')\n", + " axes[x,y].plot(self.ell[:5], Dl_mcmc[x][y][:5], label = 'MCMC')\n", + " axes[x,y].plot(self.ell[:5], self.mean_ps_sky[x][y][:5], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.05')\n", + " axes[x,y].plot(self.ell, Dl_mcmc[x][y], label = 'MCMC')\n", + " axes[x,y].plot(self.ell, self.mean_ps_sky[x][y], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.05')\n", + " axes[x,y].plot(self.ell, Dl_mcmc[x][y], label = 'MCMC')\n", + " axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], error_bar[x][y], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}')\n", + " plt.show()\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d30baa9e-9370-4c4e-a0e7-f54d5a9b41b1", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "class NestedSampling(data):\n", + " '''\n", + " Class to perform Nested Sampling in our sky parameters\n", + " '''\n", + "\n", + " def __init__(self):\n", + "\n", + " self.param_sampling = param_sampling\n", + " data.__init__(self)\n", + " self.ell, _ = NamasterEll_sampling().ell()\n", + " self.sky_parameters = self.param_sampling['SKY_PARAMETERS']\n", + " self.ndim, self.sky_parameters_fitted_names, self.sky_parameters_all_names = self.ndim_and_parameters_names()\n", + "\n", + " def ndim_and_parameters_names(self):\n", + " '''\n", + " Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of these parameters\n", + " \n", + " Return :\n", + " - ndim (int) : number of parameters you want to fit\n", + " - sky_parameters_fitted_names (array) [ndim] : list that contains the names of the fitted parameters\n", + " - sky_parameters_all_names (array) : list that contains the names of all the sky parameters\n", + " '''\n", + " \n", + " ndim = 0 \n", + " sky_parameters_fitted_names = [] \n", + " sky_parameters_all_names = []\n", + "\n", + " for parameter in self.sky_parameters:\n", + " sky_parameters_all_names.append(parameter)\n", + " if self.sky_parameters[parameter][0] is True:\n", + " ndim += 1\n", + " sky_parameters_fitted_names.append(parameter)\n", + "\n", + " return ndim, sky_parameters_fitted_names, sky_parameters_all_names\n", + "\n", + " def prior(self, x):\n", + " '''\n", + " Function to define priors to help the MCMC convergence\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : inf if the prior is not respected, 0 otherwise\n", + " '''\n", + " \n", + " for isky_param, sky_param in enumerate(x):\n", + " name = self.sky_parameters_fitted_names[isky_param]\n", + "\n", + " if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]:\n", + " return - np.inf\n", + "\n", + " return 0\n", + " \n", + " def knox_errors(self, clth):\n", + " dcl = np.sqrt(2. / (2 * self.ell + 1) / self.simu_parameters['QUBIC']['fsky'] / self.simu_parameters['Spectrum']['dl']) * clth\n", + " return dcl\n", + "\n", + " def knox_covariance(self, clth):\n", + " dcl = self.knox_errors(clth)\n", + " return np.diag(dcl ** 2)\n", + "\n", + " def loglikelihood(self, tab):\n", + " '''\n", + " loglikelihood function\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - (float) : loglikelihood function\n", + " '''\n", + " tab_parameters = np.zeros(len(self.param_sampling['SKY_PARAMETERS']))\n", + " cpt = 0 \n", + "\n", + " for i, iname in enumerate(self.param_sampling['SKY_PARAMETERS']):\n", + " if self.param_sampling['SKY_PARAMETERS'][iname][0] is not True:\n", + " tab_parameters[i] = self.param_sampling['SKY_PARAMETERS'][iname][0]\n", + " else:\n", + " tab_parameters[i] = tab[cpt]\n", + " cpt += 1\n", + "\n", + " r, Alens, nu0_d, Ad, alphad, betad, deltad = tab_parameters\n", + "\n", + " if self.param_sampling['simu']['name'] == 'CMB':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - CMB(self.ell).model_cmb(r, Alens))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Dust':\n", + " return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_ps_noise))**2)\n", + " if self.param_sampling['simu']['name'] == 'Sky':\n", + " loglike = self.prior(tab) \n", + " loglike += - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))/(self.error_ps_noise))**2)\n", + " return loglike\n", + "\n", + " def ptform_uniform(self, u):\n", + " '''\n", + " Function to perform an uniform prior transform for the Nested Sampling\n", + "\n", + " Argument :\n", + " - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc\n", + "\n", + " Return :\n", + " - ptform (array) [ndim] \n", + " '''\n", + "\n", + " ptform = []\n", + " cpt = 0\n", + " for iname in self.sky_parameters_all_names:\n", + " if self.param_sampling['SKY_PARAMETERS'][iname][0] is True:\n", + " ptform.append(u[cpt]*self.param_sampling['SKY_PARAMETERS'][iname][2] - self.param_sampling['SKY_PARAMETERS'][iname][1])\n", + " cpt += 1\n", + " return ptform\n", + "\n", + " def __call__(self):\n", + " '''\n", + " Funtion to perform the Nested Sampling and save the results\n", + " '''\n", + "\n", + " nlive = self.param_sampling['NS']['nlive']\n", + " maxiter = self.param_sampling['NS']['maxiter']\n", + " ell = self.ell\n", + " print(self.simu_parameters)\n", + " \n", + " if self.param_sampling['NS']['DynamicNS'] is True:\n", + " print('Dynamic Nested Sampling !!!')\n", + " with Pool() as pool:\n", + " sampler_ns = DynamicNestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound'])\n", + " sampler_ns.run_nested(print_progress=True, maxiter = maxiter)\n", + " else:\n", + " print('Nested Sampling !')\n", + " with Pool() as pool:\n", + " sampler_ns = NestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound'])\n", + " sampler_ns.run_nested(maxiter = maxiter)\n", + "\n", + " results = sampler_ns.results\n", + "\n", + " # Plot the traceplots\n", + " fig, axes = dyplot.traceplot(results, show_titles=True, labels = self.sky_parameters_fitted_names,\n", + " trace_cmap='viridis', connect=True,\n", + " connect_highlight=range(5))\n", + "\n", + " config = self.param_sampling['simu']['qubic_config']\n", + " nrec = self.param_sampling['simu']['nrec']\n", + " n_real = self.param_sampling['data']['n_real']\n", + " convo = self.param_sampling['simu']['convo']\n", + " if self.param_sampling['NS']['DynamicNS'] is True:\n", + " path_plot = f'{config}_Nrec={nrec}_Convolution={convo}_plots_DynamicNS'\n", + " else:\n", + " path_plot = f'{config}_Nrec={nrec}_Convolution={convo}_plots_NS'\n", + " if not os.path.isdir(path_plot):\n", + " os.makedirs(path_plot)\n", + " #plt.title(f'Traceplot - Nreal={n_real} ' + path_plot)\n", + " plt.savefig(path_plot + f'/traceplot_Nreal={n_real}')\n", + "\n", + " # Runplots\n", + " fig, axes = dyplot.runplot(results)\n", + " #plt.title(f'Runplot - Nreal={n_real} ' + path_plot)\n", + " plt.savefig(path_plot + f'/runplot_Nreal={n_real}')\n", + "\n", + "\n", + " # Triangle plot\n", + " fig, axes = plt.subplots(3, 3)\n", + " axes = axes.reshape((3, 3))\n", + " fg, ax = dyplot.cornerplot(results, color='blue', title_fmt = '.4f', show_titles=True, labels = self.sky_parameters_fitted_names,\n", + " max_n_ticks=3, quantiles=None,\n", + " fig=(fig, axes[:, :3]))\n", + " #fig.suptitle(f'Triangleplot - Nreal={n_real} ' + path_plot)\n", + " plt.show()\n", + " #plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}')\n", + "\n", + " # Data vs Fit plot\n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " samples, weights = results.samples, results.importance_weights()\n", + " mean_ns, cov_ns = dyfunc.mean_and_cov(samples, weights)\n", + " parameters_values = []\n", + " cpt=0\n", + " for parameter in self.sky_parameters:\n", + " if self.sky_parameters[parameter][0] is True:\n", + " parameters_values.append(mean_ns[cpt])\n", + " cpt+=1\n", + " else:\n", + " parameters_values.append(self.sky_parameters[parameter][0])\n", + " Dl_ns = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2])\n", + " Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.15, parameters_values[5], parameters_values[6], parameters_values[2]) \n", + " \n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.15')\n", + " axes[x,y].plot(self.ell[:5], Dl_ns[x][y][:5], label = 'NS')\n", + " axes[x,y].errorbar(self.ell[:5], self.mean_ps_sky[x][y][:5], self.error_ps_sky[x][y][:5], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}')\n", + " plt.show()\n", + "\n", + " fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8))\n", + " for x in range(self.nrec):\n", + " for y in range(self.nrec):\n", + " axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.15')\n", + " axes[x,y].plot(self.ell, Dl_ns[x][y], label = 'NS')\n", + " axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], self.error_ps_sky[x][y], label = 'Data')\n", + " axes[x,y].legend()\n", + " axes[x,y].set_xlabel('l')\n", + " axes[x,y].set_ylabel('Dl')\n", + " axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}')\n", + " fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) \n", + " #plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4abd2225-7e98-4b19-98b1-eae216894ad2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling Parameters {'data': {'path': '/pbs/home/t/tlaclave/sps/Pipeline/spectra/spectra_with_convolution/DB_Nrec=2_spectra/', 'n_real': 200, 'pipeline': 'FMM'}, 'simu': {'nrec': 2, 'qubic_config': 'DB', 'convo': True, 'noise': True, 'name': 'Sky'}, 'MCMC': {'nwalkers': 30, 'mcmc_steps': 300, 'discard': 100, 'stretch_move_factor': 0.7, 'snooker_move_gamma': 1.7, 'thin': 15}, 'NS': {'DynamicNS': True, 'nlive': 1000, 'prior_transform': 'uniform', 'bound': 'multi', 'queue_size': 16, 'maxiter': 1000000000}, 'SKY_PARAMETERS': {'r': [True, 1, 2, -1, 1], 'Alens': [1, 0, 1, 0, 1], 'nu0_d': [353, 0, 1, 0, 1000], 'Ad': [True, 0, 20, 0, 1000], 'alphad': [True, 5, 10, -5, 5], 'betad': [1.54, 0, 1, 1.3, 1.7], 'deltad': [1, 0, 1, 0, 1000]}, 'Method': 'MCMC', 'Loglike': 'fullcov'}\n", + "Chosen method = MCMC\n", + "{'Method': 'FMM', 'path_out': '/pbs/home/t/tlaclave/sps/Pipeline/data_comparison/', 'Sky': {'CMB': {'cmb': True, 'r': [0, 'f', 'r', 0.001], 'Alens': [1, 'f', 'A_{lens}', 1]}, 'Foregrounds': {'Dust': True, 'nu0_d': 353, 'Ad': [4, 'nf', 'A_d', 4], 'betad': [1.54, 'nf', '\\\\beta_d', 1.54], 'alphad': [-0.4, 'nf', '\\\\alpha_d', -0.4], 'deltad': [1, 'nf', '\\\\Delta_d', 1], 'Synchrotron': False, 'nu0_s': 23, 'As': [0, 'nf', 'A_s', 0], 'betas': [-3, 'nf', '\\\\beta_s', -3], 'alphas': [-0.4, 'nf', '\\\\alpha_s', -0.4], 'deltas': [1, 'nf', '\\\\Delta_s', 1], 'DustSync': False, 'eps': [0, 'nf', '\\\\varepsilon', 0]}, 'nside': 256}, 'QUBIC': {'method': 'MM', 'randomreal': True, 'npointings': 5000, 'nsub': 8, 'nrec': 2, 'seed': 1, 'iteration': 1, 'ndet': 1, 'npho150': 1, 'npho220': 1, 'synthbeam_kmax': 1, 'detector_nep': 4.7e-17, 'nhwp_angles': 3, 'dtheta': 15, 'type': 'two', 'covcut': 0.2, 'kappa': 0, 'convolution': True, 'bandpass_correction': True, 'RA_center': 0, 'DEC_center': -57, 'dust_model': 'd0', 'sync_model': 's0', 'fsky': 0.035}, 'Spectrum': {'do_spectrum': False, 'method': 'namaster', 'dl': 30, 'lmin': 40, 'aposize': 10, 'beam_correction': False, 'pixwin_correction': False, 'noise_correction': True, 'nbins': 10}, 'PCG': {'maxiter': 400, 'tol': 1e-20, 'gif': False}, 'Sampler': {'do_sampler': False, 'nsteps': 200, 'N': 5, 'ndim': 2, 'discard': 100, 'markers': False, 'sig_initial_guess': 0.01, 'title_limit': 1}, 'Data': {'datafilename': 'MC', 'planck': {'30GHz': False, '44GHz': False, '70GHz': False, '100GHz': False, '143GHz': False, '217GHz': False, '353GHz': False}, 'level_planck_noise': 0, 'use_external_data': True}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 300/300 [05:52<00:00, 1.18s/it]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed no burn in\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2oAAANaCAYAAAD4Ub+mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADzmElEQVR4nOzdeXhU5f3+8fuc2bKHsIewhH3fFwEBF3CDiitKF/vVVktpq9YWqtQWl7Y/tKKtS4tarVbFugKigAq4oShIZAfZ9wRlzZ5Zz++PmJQgYAiZmTMz79d1zaWZzJn5nDDJzD3P83wew7IsSwAAAAAA2zCjXQAAAAAAoCaCGgAAAADYDEENAAAAAGyGoAYAAAAANkNQAwAAAACbIagBAAAAgM0Q1AAAAADAZghqAAAAAGAzBDUAAAAAsBmCGgAAAADYDEENcWnRokUaMGCAkpKSlJOToylTpigQCNTLcbW5TXl5ue666y517NhRSUlJat++vf7617/Ksqx6Pc/Tqamux61fv17jxo1Tx44dZZqmxo8f/637efbZZ2UYxrcuL7zwQr2dIwAAQCIhqMEWfD5fvd3X6tWrNWbMGA0ePFhffPGFHnnkEc2YMUOTJk064+Nqe98TJ07Uv/71Lz344IPauHGj/vrXv+qBBx7Qn/70p1qdw7PPPqvc3Nyon68klZWVqXXr1po6dap69+59yvvcuXOnCgoKqi9XX311rc4BAAAAx7GACPP5fJbH47Eeeugh6/vf/76VmZlpnXvuufV2/z/60Y+sbt261bju4Ycfttxut3X48OEzOq42tykvL7ecTqf1xBNP1Ljd9OnTrbS0NKu0tPQ7z+GZZ56x2rRp8523q21N9XXcOeecY1177bUnrFeSVV5eXquaAQAAcGqMqCHi1q1bJ6/Xq7/97W8aOXKk8vLy9NRTT1V/f+bMmUpLSzvlpXv37ie9/yVLlmj06NE1rhszZox8Pp+WL19+RsfV5jZ+v1/BYFApKSk1bpeamqqSkhKtWLHiFD+d0xfO8z1d3bp1U7NmzTR8+HC98sordboPAAAASM5oF4DEk5eXJ0l66qmndOGFF37r+2PHjtVZZ511yvtwuVwn/V5BQYGys7NrXNe8eXNJUn5+/hkdV5vbpKena8SIEZo2bZr69eunrl27as2aNZo+fbokad++fd967JkzZ2rChAnVXwcCAfl8PqWlpVVf16ZNG61fvz6i51tbnTt31rPPPquePXsqEAjozTff1A9+8ANt2bJFd95552ndFwAAAAhqiIK8vDz16NHjhCFNqgw66enp9fqYhmHU+G99Hnei27zwwguaOHGievbsKcMw1KBBA916662aOnWqHA7Ht+7j+HA6a9YsPfLII/rggw+qrztVOK1L3fV53JAhQzRkyJDqrwcNGqSysjLdd999+t3vfndatQMAAICghijIy8vTyJEjT/r940eXTuRko0uSlJ2drYKCghrXVX19/AjS6R5X2/tu2bKl3nzzTXm9Xh04cEDNmzfXO++8I0nq0KHDtx77+HDatGlTOZ3OE962LnXX53G1NWTIED300EM6cOCAWrRoccb3BwAAkEhYo4aICgQCWrNmjQYOHHjS24wdO1arVq065WX+/PknPX748OFasGBBjevmz58vt9utQYMGndFxp3vfHo9HLVu2lNPp1PPPP6+OHTuqT58+J62hLsJ5vmciLy9PycnJaty48RnfFwAAQMKJdjcTJJaVK1dakqxNmzaF7TFWrVplud1u6+abb7Y2bNhgzZo1y2rQoIF16623Vt9m1qxZVufOna29e/ee1nG1uY1lWdbixYut2bNnW1u3brU+++wz6yc/+Ynl8XisDz744IQ1l5WVWQUFBae8fP3113U+3xOdc22P83q91sqVK62VK1da/fv3ty666KLqr71er2VZlnXXXXdZb731lrV582Zr/fr11n333We5XC7r9ttvP8W/FAAAAE6GoIaIeuqpp6zMzEwrFAqF9XEWLlxo9evXz3K73Vbz5s2t22+/3fL7/dXfr2onv2PHjtM6rra3mTt3rtW5c2fL4/FYGRkZ1iWXXGItX778pPVW1XOqy6na9demphOdc22O27Fjx0lrqrqv2267zWrbtq2VlJRkZWZmWgMGDLCefvppKxgMnrRmAAAAnJxhWZYV8WE8AAAAAMBJsUYNAAAAAGyGoAYAAAAANkNQAwAAAACbIagBAAAAgM0Q1AAAAADAZghqAAAAAGAzzmgXkAhCoZDy8/OVnp4uwzCiXQ6AKLAsS8XFxWrRooVMk8/IAADAqRHUIiA/P1+tWrWKdhkAbGDPnj1q2bJltMsAAAA2R1CLgPT0dEmVb9AyMjKiXA1Oh8/n04MPPihJ+u1vfyu32x3lihCrioqK1KpVq+q/BwAAAKdCUIuAqumOGRkZBLUY4/P5lJSUJKny34+ghjPF9GcAAFAbLJQAAAAAAJshqAEAAACAzRDUAAAAAMBmCGoAAAAAYDMENQAAAACwGYIaAAAAANgMQQ0AAAAAbIagBgAAAAA2Q1ADAAAAAJshqAEAAACAzRDUAAAAAMBmCGoAAAAAYDMENQAAAACwGYIaAAAAANgMQQ0AAAAAbIagBgAAAAA2Q1ADAAAAAJshqAEAAACAzRDUAAAAAMBmnNEuAEhElmXp7x969Y+PKzSotVOWJQ1s7dBt5ybJMIxolwcAAIAoY0QNiLAVuwM659Fi/WZOmVpmmvry66BeWunTb98oV98HirRkmz/aJQIAACDKGFEDIujtjT6NfapEfXMcWvyLdJ3fyVX9vTX5Af3+rXKd/49iPfuDVP1wgCeKlQIAACCaGFEDImTxZr+ufqZE4/u6teSWjBohTZJ6tXDqzZvSdMuIJP30pVIdKQtFqVIAAABEG0ENiIDPdwc06p/FGt7Opae/nyq388Tr0AzD0F0XJyvdY+hXr5dFuEoAAADYBUENCDNvwNINL5ZqZCen5k9Ik8tx6mYhGUmGXvhRql7M8+mRDysiVCUAAADshKAGhNn9iyq060hQT12bWuuOjhd1deuOkUn688Jy+QJWmCsEAACA3RDUgDDadzSk+98r1x8vTFZuI8dpHfur4UkqqrD05KfeMFUHAAAAuyKoAWE05a0yNUs3dcuIpNM+NqeBqYlne/TXxRUKBBlVAwAASCQENSBM3ljr0/MrfJo+NkVJrrptYn3riCTtKwxp1hpfPVcHAAAAOyOoAWFwtCykG18q1Y8GuHVFL9d3H3ASuY0curKXS3/7gKYiAAAAiYSgBoTB3W+XS5IevTKl1g1ETua2c5P02a6gPtsZqI/SAAAAEAMIakA9W7E7oIc/8mr6ZSlqkHLmv2JDcp0a2NqhR5cwqgYAAJAoCGpAPfvLwnINbO3Qjwe66+X+DMPQL85O0murfDpQEqqX+wQAAIC9EdSAerSuIKA5a/2684LkM57yeKxr+7qV6jH0789o1Q8AAJAICGpAPfrzuxXqke3Qpd3r3kDkRJLdhq4f6NbjS73y06ofAAAg7hHUgHqyriCgl1f6dO8lyTLN+htNq3LLN636/5tHq34AAIB4R1AD6sm/PvWqUxNTl/es39G0KrmNKkfqnlvB9EcAAIB4R1AD6oEvYGlmnk/XD/LU69q04/14oEfvbQlo71GaigAAAMQzghpQD15e6VNhuaXrBnrC+jiXdHWpYYqhmYyqAQAAxDWCGnCGLMvSA+9VaHw/t1o2CO+vlNtpaFxvt/77BevUAAAA4hlBDThD8zb4tbYgqMnnJ0Xk8b7f363V+UFt3B+MyOMBAAAg8ghqwBma/l6FLu3uUq8Wzog83rC2TrXINPTySqY/AgAAxCuCGnAGNn0V1IfbAvrV8MiMpkmSaRq6to9bL630ybLYUw0AACAeEdSAM/Cvz7zKbWhqVKfIjKZVGd/Po01fh7RqH9MfAQAA4hFBDagjb8DSf5Z7deNgT1g2uD6Vga0datXA1Fvr/RF9XAAAAEQGQQ2oozlrfDpSbumGs8Lbkv9EDMPQhV1cencTQQ0AACAeEdSAOvrXZ16N6eZSi8zo/Bpd2NmpT3cGVFTBOjUAAIB4Q1AD6mDbwaAWbw7oZ0MiP5pWZWQnl0KW9P4WRtUAAADiDUENqIOZK3zKzjB0cVdX1GpolGqqf0sH0x8BAADiEEENqINZa3y6qrdbjgg3ETnehV1cevdLghoAAEC8IagBp2nbwaBW5wd1ZS93tEvRhZ1d2nowpO0HadMPAAAQTwhqwGmatcanRqmGhreL7N5pJzIk16lUt7SQ6Y8AAABxhaAGnIZQyNLjn3g1vq9bTkd0pz1Kkttp6LyOtOkHAACINwQ14DR8tiug7YdCmjA0et0ej3dhZ5cWbw4oEKRNPwAAQLwgqAGn4ZWVPnVtZqpHtiPapVS7sLNLhRWWVuxhnRoAAEC8IKgBtRQKWXp1tU/X9vXIMKI/7bFKp6amWmeZdH8EAACIIwQ1oJY+3RVQfqGla/pEv9vjsQzD0IWdWacGAAAQTwhqQC29vtqnntkOdW1un2mPVUZ1cuqzXQGVeFmnBgAAEA8IakAtzVnr17V97TWaVmV4e5eCIWn5rkC0SwEAAEA9IKgBtfR1saVxNpv2WKVFpqk2WaY+2UFQAwAAiAcENaCWemQ71Kmp/aY9Vjm7nVNLCWoAAABxgaAG1NIVvVzRLuGUzm7r1Kc7AwqFWKcGAAAQ6whqQC1d3sOe0x6rDM11qrDC0vr97KcGAAAQ6whqQC11bmbfaY+S1LOFQ+kesU4NAAAgDhDUgDjhMA0NzmWdGgAAQDwgqAGnsONQbE0jHNbWpY8JagAAADGPoAacwpy1vmiXcFqGtXNqx6GQ9h0NRbsUAAAAnAGCGnAKb6z1R7uE03JWG6ccpvTJjtiqGwAAADUR1ICT2HU4qBV7YmvqY6rHUL+WDn28nemPAAAAsYygBpzErDV+ZSYb0S7jtA1r62SdGgAAQIwjqAEn8fpqn8Z0s/cm1ycyrJ1Lq/cFVVTBxtcAAACxiqAGnMD+opCW7gxobI/YC2pnt3MqZEmfsk4NAAAgZhHUgBN4c71PyS5pZMfYC2rN0k11amJqCevUAAAAYhZBDTiBOWv9uqiLS8nu2FujJkkj2rv00TaCGgAAQKwiqAHHKfVaWrzZr8t6uKNdSp2d08GpZbsCKvexTg0AACAWEdSA4yza7JcvKI2OwUYiVUa0d8oXlJbvZlQNAAAgFhHUgOO8td6vwW2capIWu78erbMcym1o6sOtBDUAAIBYFLvvRIEwCIUsvbXBp+91j93RtCrD2zm1ZDudHwEAAGIRQQ04xhd7g9pfZMVHUGvv1Kc7AwoEWacGAAAQawhqwDHeXO9T6yxTPbMd0S7ljA1r61KpT1q1LxjtUgAAAHCaCGrAMd5a79el3V0yjNhsy3+szk1NNUg29Nku1qkBAADEGoIa8I19R0P6Ym8wLqY9SpJpGjqrjVOf7SSoAQAAxBqCGvCNeRt8SnVL53aIj6AmSYPbOBhRAwAAiEEENeAbb67364LOLiW5Yn/aY5UhuU5tOxjS18WhaJcCAACA00BQAySV+Swt2uzXpd3d0S6lXg1q45QkLWNUDQAAIKYQ1ABJ72/xq8Ivje4WP9MeJSkrxVSXpibTHwEAAGIMQQ2QtGCjX/1aOtQ8I/5+JYbkVu6nBgAAgNgRf+9KgdNkWZYWbPTrkq7xNZpWZXCuU8t3BRQMsfE1AABArCCoIeFtORDS9kOhuA5qpT5p/X42vgYAAIgVBDUkvAUb/WqQXLnnWDzq3tyhNI/06Q6mPwIAAMQKghoS3lvrfbqkq0tOR/y05T+WwzQ0qLWThiIAAAAxhKCGhFZUYenDbQGNibNuj8cbkuvUZzQUAQAAiBkENSS0RZv8Coaki+N0fVqVwblOffl1SIdL2fgaAAAgFhDUkNDe3eTXwNYONUqN71+FqvV3y3czqgYAABAL4vvdKfAdFm7y64LO8T2aJklN0kx1aGwy/REAACBGENSQsLYfDGr7oVBCBDWpcvojG18DAADEBoIaEtbCTX6luqXBcdqW/3iD2zi1bFdQITa+BgAAsD2CGhLWws1+ndvBJbczPtvyH29IrlOFFZY2fU1DEQAAALsjqCEhBYKWFm8O6MIEmfYoST1bOJTsEtMfAQAAYgBBDQnp050BHS23NDrO9087lsthaEArNr4GAACIBQQ1JKS31vvVsYmpDk0c0S4lotj4GgAAIDYQ1JCQ3trg16Xd3dEuI+IG5zq1bn9QRRU0FAEAALAzghoSzvaDQW3YH9Sl3RNn2mOVwW2csizpcza+BgAAsDWCGhLOW+v9ykwydHa7xGjLf6zsTFNtskwaigAAANgcQQ0J560NPl3S1SWXIzHa8h9vMOvUAAAAbI+ghoRSXGHpg60BfS8Bpz1WGZJb2fnRslinBgAAYFcENSSUdzf5FQxJF3dN3KA2uI1Th0otbT3IxtcAAAB2RVBDQnlrvU9nt3WqUWriPvX7tHTI7RDTHwEAAGwscd+tIuGEQpbmbfAn9LRHSfI4DfVn42sAAABbI6ghYSzfHdSBEkvfS8D90443uI2Dzo8AAAA2RlBDwnhrvU/tGpnq2oyn/eBcp9bkB1XqpaEIAACAHfGOFQnjrfWV0x4NIzHb8h9rSK5TwZCUt5dRNQAAADsiqCEh7D4S1Or8INMev9GygakWmYY+3UFQAwAAsCOCGhLCvPV+pXmkEe2d0S7FFgzD0OA2NBQBAACwK4IaEsK8DX5d2Nklj5Npj1XY+BoAAMC+CGqIe76ApQ+2+nVRl8Ruy3+8wblO7S+ytOswG18DAADYDUENce+zXQGV+qQLOhPUjtW/pVNOU0x/BAAAsCGCGuLewk1+tW9sqm0jR7RLsZVkt6E+OQ59xn5qAAAAtkNQQ9xbuMmvUZ0YTTuRwblONr4GAACwIYIa4tqRspA+3x1k2uNJDMl1auW+oCr8NBQBAACwE4Ia4toHWytHi87vSFv+Exncxil/UFrJxtcAAAC2QlBDXFu4ya8BrRzKSuGpfiJtG5lqkmYw/REAAMBmePeKuLZwk59pj6dgGMY3+6kFo10KAAAAjkFQQ9zaeSiorQdDNBL5DoPbOOn8CAAAYDMENcStRZv9SnFLQ9qyPu1UBuc6tedoSPuOsvE1AACAXRDUELcWbgronPYueZxGtEuxtYGtnTINNr4GAACwE4Ia4lIoZGnxFtan1Uaax1DPbDa+BgAAsBOCGuLSyn1BHSq1NKoT0x5rg42vAQAA7IWghri0aJNfzTMM9ch2RLuUmDAk16m8vQH5Amx8DQAAYAcENcSlhZv9GtXJJcNgfVptDG7jVIVfWpNPm34AAAA7IKgh7pT7LH28PaALaMtfax2bmMpKYeNrAAAAuyCoIe4s2R6QNyCNJKjVmmkalfup0fkRAADAFghqiDuLNvvVrblDOQ14ep8ONr4GAACwD97JIu4s3OTXBXR7PG1D2jq1/VBIXxez8TUAAEC0EdQQV74uDmnVviD7p9XBoNYOGWx8DQAAYAsENcSVxZv9cprSOR0IaqcrM9lU12ZsfA0AAGAHBDXElUWb/RqS61Sah7b8dTGEja8BAABsgaCGuGFZlhZuCjDt8QwMzXVq2S42vgYAAIg2ghrixuavQ9pzNERQOwPD2ztV7pe+2MvG1wAAANFEUEPcWLjZr8wkQwNaOaJdSszq0NhU8wxDH23zR7sUAACAhEZQQ9xYtMmv8zo65XSwPq2uDMPQiHYufbSNdWoAAADRRFBDXAgELb2/lfVp9WFEe6c+3h5QMMQ6NQAAgGghqCEuLN8dUFGFRVCrByPaO1VYYWltPuvUAAAAooWghriwcFNAbbJMdWjMU/pMdW/uUFaKwfRHAACAKOJdLeLCos1+jerskmGwPu1Mmaah4e2c+mg7DUUAAACihaCGmFdcYemznQFd0MkZ7VLixoj2Tn20LSDLYp0aAABANBDUEPM+2OpX0JJGdmJ9Wn0Z0d6lAyWWNn0dinYpAAAACYmghpi3cJNffXMcapzG07m+9M1xKNUt9lMDAACIEt7ZIuYt2uzXKEbT6pXTYejstk4t2U5DEQAAgGggqCGm7T0a0savQrTlD4MR7dn4GgAAIFoIaohpb2/0KcUtDW9PI5H6NqK9U7uPhLTrMPupAQAARBpBDTFtwUa/zu/oksdJW/76NrC1Ux6nGFUDAACIAoIaYpY/aGnR5oAu7sK0x3BIchk6q42ToAYAABAFBDXErE93BlRUYemSrgS1cKncT43OjwAAAJFGUEPMenujXx2bmGrX2BHtUuLWiPYubT4Q0v4i9lMDAACIJIIaYtaCjX5G08JsSK5TDlO06QcAAIgwghpiUkFhSKv2BVmfFmZpHkP9WzqY/ggAABBhBDXEpHe+9CvJJZ3bgaAWbuynBgAAEHkENcSkBRv9Ore9S8lu2vKH24j2Tq0tCOpwKevUAAAAIoWghpgTCFpauNmvi1mfFhHD2lVuJv7JDkbVAAAAIoWghpizfHdAR8poyx8pWSmmemY7mP4IAAAQQQQ1xJy3N/rVtpGpjk14+kbKiPZOfUhDEQAAgIjhnS5iTlVbfsNgfVqknNPepS/2BlVUYUW7FAAAgIRAUENM+bo4pBV7aMsfaed2cCoYEm36AQAAIoSghpjy7ia/3A7pvI4EtUhqnGaqdwuH3ttMUAMAAIgEghpiyoKNfg1v71Sah2mPkXZ+R6fe20JDEQAAgEggqCFmBEOW3vnST7fHKBnZyaXV+UEdKGE/NQAAgHAjqCFm5O0J6lCppUu6uqNdSkIa0d4lpykt2sT0RwAAgHAjqCFmvL3Rr1YNTHVtxtM2GtKTDJ3d1ql3viSoAQAAhBvveBEzFmz00ZY/yi7q4tK7m/yyLNr0AwAAhBNBDTHhUGlIy3YHdTHr06Lqoi4uFRRZWlsQjHYpAAAAcY2ghpiwcJNfDqOyoQWip0+OQ03SDKY/AgAAhBlBDTFhwUa/zm7rVEYS0x6jyTQNXdjZRVADAAAIM4IabC9EW35bubirS0u2BVRUwTo1AACAcCGowfZW7Qvqq2KL9Wk2MaabSyFLmr/BF+1SAAAA4hZBDbb39pd+tcg01KuFI9qlQFJWiqnzOjo1ew3THwEAAMKFoAbbW7DRr4u70JbfTq7s5da8DT5V+Jn+CAAAEA4ENdja0bKQPt0Z0MVd3dEuBce4rIdbZf7KbpwAAACofwQ12NqizQFJ0gWdnFGuBMfKzjQ1JNep2WtYpwYAABAOBDXY2oKNPg1u41SDFJ6qdnNFT5feWOdXIMj0RwAAgPrGu1/YlmVZepu2/LZ1RS+3DpdZ+mhbINqlAAAAxB2CGmxrbUFQ+YW05ber9o0d6t3Codlrmf4IAABQ3whqsK0FG/xqmmaobw5t+e3qil5uzV7jUyjE9EcAAID6RFCDbb253q/R3VwyTdry29WVvVzaV2jp893BaJcCAAAQVwhqsKWDJZVt+S/tTlt+O+uR7VCHxqZm0f0RAACgXhHUYEvzN/jlNKULu7A+zc4Mw9BVvd16dbVPlsX0RwAAgPpCUIPtWJalx5d6dX5Hl9I8THu0u2v6uLXjUEhf7GX6IwAAQH0hqMF2VuwJ6tOdAf3+gqRol4Ja6NvSofaNTb2ykumPAAAA9YWgBtt5dZVP7RubGtbOGe1SUAuGYeiaPm69vJLujwAAAPWFoAZbsSxLr67yaVxvtwyDaY+x4gf93dp1JKSlO9n8GgAAoD4Q1GAreXuC2nk4pHF96PYYS3pkO9WrhUMzVzD9EQAAoD4Q1GArr67yqV0jU31bssl1rPnRALdeXuWTN8D0RwAAgDNFUINtWJalV1f7NK4P0x5j0Y/6e1RYbunNdf5olwIAABDzCGqwjS/2BrXjENMeY1V2pqkLO7v0n8+90S4FAAAg5hHUYBuvrvKpbSNT/Zj2GLP+b5BbCzb69VVxKNqlAAAAxDSCGmyBbo/x4bIebqW5Dc1cwagaAADAmSCowRa+2BvUdqY9xrxkt6Fr+7r1n8/p/ggAAHAmCGqwhappj/1bMe0x1v3fILfW5Ae1ai97qgEAANQVQQ1Rx7TH+DIk16mOTUw9u5zpjwAAAHVFUEPUrWTaY1wxDEPXD/LohTyffOypBgAAUCcENUTdq6t8ym3ItMd48uOBHh0pszSXPdUAAADqhKCGqGKT6/jUsoGp0d1cemJpRbRLAQAAiEkENUTVqn1BbTvItMd49POhHi3aHNCWA8FolwIAABBzCGqIqpl5ldMeBzDtMe5c3NWlNlmmnlhKUxEAAIDTRVBD1FT4LT273KsbB3uY9hiHHKahCUM9emaZV+U+mooAAACcDoIaombWGp8Kyy395CxPtEtBmPxksEfFXkuvrWYDbAAAgNNBUEPUPLHUq8t6upSdydMwXjVLN3VlL7ceZ/ojAADAaeEdMqJiw/6gPtoW0IShSdEuBWE28WyPlu4I6PPdgWiXAgAAEDMIaoiKJ5dWqH1jUyM7OqNdCsJsRHunBrZ26P7F5dEuBQAAIGYQ1BBx5T5L//ncp58N8cg0aSIS7wzD0B0jkzVrjV/rCxhVAwAAqA2CGiLulVU+lfosXT+IJiKJ4vKeLvXMdujed9gAGwAAoDYIaoi4J5Z6dVUvt5qm8/RLFKZp6K6LkvXqap/WMaoGAADwnXinjIhakx/QpzsDmjCU0bREw6gaAABA7RHUEFGPLfGqS1NT53SgiUiiMU1Dd1+crFdX+bQ2n1E1AACAUyGoIWIOloT0/Aqvfn1OkgyDJiKJ6PKeLvXJceied+gACQAAcCoENUTM40u9SnEZum4g0x4TlWEYuueSZL2+2q9PtvujXQ4AAIBtEdQQEb6ApX98XKEJQz1KcTOalsgu7e7ShZ2d+uVrZQoErWiXAwAAYEsENUTEyyt9Olhi6ZfDkqJdCqLMMAw9elWqNnwV1IxPvNEuBwAAwJYIagg7y7L00AcVGtfHrZwGPOUgdWrq0OTzk/SH+eXaXxSKdjkAAAC2w7tmhN3cdX6t2hfUHaMYTcP/3HlBshokG/rd3LJolwIAAGA7BDWElWVZuvvtcl3V26VeLWjJj/9JcRt6+IoUPb/Cp4+20VgEAADgWAQ1hNUbaytH06ZelBztUmBDl/V06ZKuLv3ytTL5aSwCAABQjaCGsLEsS/e8w2gaTq6ysUiKthwI6rElNBYBAACoQlBD2FSNpt3FaBpOoX1jh24fmaS7FpQpv5DGIgAAABJBDWESClWuTbu6t0s9GU3Dd7hjZLIapZqaTGMRAAAASQQ1hMkb6/xanc/aNNROstvQI1em6MU8n97fQmMRAAAAghrqnT9o6Y/zGU3D6bm0h1uXdnfpl6+V0lgEAAAkPIIa6t0/P/Zqy4Gg7rs0JdqlIMY8fGWKdhwO6YH3KqJdCgAAQFQR1FCvvioOaeqCcv1uZJLaN3ZEuxzEmLaNHPrL6GRNXVCuD5gCCQAAEhhBDfXq9rllapBsaMoo1qahbm47N0lX9nLrmv+UaO9RukACAIDERFBDvVm6w6//fO7T3y5PUYrbiHY5iFGGYejp8alqnGpo3DPF8gZYrwYAABIPQQ31osJv6caXSnVRF5eu6OWKdjmIcelJhmb9JF3r9wf1y9fKZFmENQAAkFgIaqgX975Trj1HQ3ry2hQZBqNpOHNdmjn03x+n6ZllXv35XZqLAACAxEJQwxn7cKtf9y+u0ANjU9Q6iwYiqD9jurv1+DUpmrqgXE99SlgDAACJg02ucEYKCkO69j8lurKXSxOGeqJdDuLQTUOSlF9oacIrZUrzGBrfj+cZAACIf4yooc78QUvX/qdEmUmGnv5+GlMeETZTL0rSbecm6UcvlGrOGl+0y0EUBYNBpaSk6Pnnn492KQAAhBVBDXX2+7fKlbc3oNd/kqaMJEIawscwDD0wNlkThnp0zX9KNHcdYS0e+P1+9ezZU4Zh6PPPP6/VMRs3blR5ebn69+9fr7WsX79e48aNU8eOHWWapsaPH3/C2y1atEgDBgxQUlKScnJyNGXKFAUCgXq5f8uydN9996lz585KTk5Wdna2xo8frx07dpzx+Z1MXc6nNufy73//W/3791fDhg2VlJSkjh076s4775TX6w3XqQBA3CGooU5eX+3T9Pcr9OQ1qeqRzQxahJ9hGHr0yhT99CyPrn6mRPPWE9Zi3f33369hw4YpOztbeXl5tTomLy9Pqamp6tKlS73WUlZWptatW2vq1Knq3bv3CW+zevVqjRkzRoMHD9YXX3yhRx55RDNmzNCkSZPq5f6nT5+ue+65R3feeac2btyo119/XVu3btXFF19cq3N49tlnlZubW6vbnsn51OZcmjVrpj/+8Y/6+OOP9eWXX+q+++7Tk08+qVtvvbXW9QFAouMdNk7bZzsDuu6FEt083KMfDmC9ECLHNA39c1yKgpZ01TMleuFHabq6jzvaZaEOtm3bphkzZmjNmjXasWPHCYPaV199pd/85jeaO3euUlJSNHnyZO3Zs0d9+vSRadbv54wDBw7UwIEDJUlPP/30CW8zffp0dejQQY899pgkqVu3btq3b58mT56su+66S1lZWWd0/x999JHOO+88/fjHP5Yk5ebm6ne/+52uvfZaHTp0SI0aNarz+dXn+dTmXMaMGVPj69zcXH388ceaN29ePZ4BAMQ3RtRwWjbuD+qyp4o1qpNLf7siJdrlIAEZhqEZ41Kqp0E+/CHdIGPRxIkTNWXKFDVq1Eg9e/b8VlArKCjQgAEDdPToUS1ZskSLFi3S3Llz9cILL2jAgAEnvM+ZM2cqLS3tlJfu3bvXueYlS5Zo9OjRNa4bM2aMfD6fli9fXuf7rTJ8+HAtW7ZMy5YtkyQdOHBAzz//vIYOHVrvIU0K//kca/369Zo3b57OP//8er1fAIhnjKih1j7Z7telT5Woe3OHZl6XJofJujREh8M09PcrUtQ6y9SvZ5fpSFlIUy9KlslzMibMnDlT+/fv18SJEyVJvXr10sMPPyyv1yuPp3KU/rbbblPTpk01d+5cORyV2378v//3/zR8+PCTrk8bO3aszjrrrFM+tsvlqnPdBQUFys7OrnFd8+bNJUn5+fl1vt8qkydPVigU0rBhwyRJgUBAI0aMOOko1MyZMzVhwoTqrwOBgHw+n9LS0qqva9OmjdavX3/C48N9PoWFhcrJyZHf75fP59NNN92kf/zjH2d8vwCQKAhqqJU5a3z6/vMlGt3VpZnXpSnJxRtiRJdhGPrtecnKTDI08dUyrdoX1H9+mKrMZCYK2NmRI0f029/+Vv/973+rA1jPnj3l9/u1Zs0aDRw4UIcPH9Zrr72mF198sfo20v9C1smCWnp6utLT08N/Eseo6nZbH11v586dq4ceekiPPfaYhg4dqoKCAv3xj3/UZZddpvfee6/Gz0L6djCdNWuWHnnkEX3wwQfV151uMK3P80lPT9eqVatUXl6uvLw83XHHHWrSpIn+8pe/nPF9A0AiIKjhlEIhS9MWVWjqgnL9/GyPHrkyhZE02MqNQ5LUrblDVz9TogEPFumZH6RqWLu6j5ogvG6//XZ99dVXuuCCC771vby8PA0cOFCrVq1SMBisXgdVZdmyZadsJHL8CNOJnGqE6btkZ2eroKCgxnVVXx8/MlUXt9xyi2666abqc+jZs6fatm2rTp06aeHChd9qKnJ8MG3atKmcTqc6dOhQq8cL9/mYplldS8+ePWWapq6//npNmjTplOv5AACVCGo4qd1HgrrhxVJ9vD2gv1+Rol8N97BXGmxpaFuXvpiUqZ++VKrhjxTrpiEe3X9psrJSGF2zk6VLl+r555/Xhx9+qIYNG9b43vjx46vXqVU1Cqmo+N/6w4qKCj300EPq27fvSRuJhHvq4/Dhw7VgwQI98MAD1dfNnz9fbrdbgwYNqvP9VikrK/vWqNnxX9encJ/P8SzLkmVZtOgHgFoiqOFbLMvSM8t8+vXsUrVsYGrprzPUvxVPFdhb8wxTb92UpldX+XTr7DK9sdanv1+RovH93HzAYAN+v18TJkzQz3/+c40YMeJb3+/Ro0d1UOvTp48yMjI0adIkTZ8+XWVlZZoyZYr27t2ryy+//KSPcSZTH30+nzZs2CBJKikp0dGjR7Vq1SpJld0Q3W63Jk2apEGDBumWW27RxIkT9eWXX2rq1KmaOHFijRGi2bNna8qUKVq8eLFycnJqff9XXHGFHn74YXXu3FlDhw7V/v37dccddygnJ0dDhgz5Vs3l5eUqLCys/vriiy/WxRdfrP3791df53A41KRJkxOec23Op67nMmXKFI0aNUq5ubkKBoNavny5br/9do0ePbp6HRwA4DtYCLvCwkJLklVYWBjtUr7T5q8D1kUziizj14esyW+UWuW+ULRLiiqv12vdfffd1t133215vd5ol4NaOlIatH7+comlWw9ZF80osjZ/HYh2STH1dyAcpk2bZmVkZFgHDx484ffvuusuy+VyWRUVFZZlWdb8+fOtzp07W6mpqVbv3r2tRx991EpPT7eee+65sNS3Y8cOS9IJLzt27Ki+3cKFC61+/fpZbrfbat68uXX77bdbfr+/xn0988wz3zquNvdfVlZm3XnnnVaHDh2spKQkq3nz5taVV15pbdiw4YQ1Vz3OqS5t2rQ55Xl/1/nU9VwmTJhgtW/f3kpKSrIyMjKsXr16WdOmTbNKS0u/898CAFDJsCzLikQgTGRFRUXKzMxUYWGhMjIyol3OCe09GtLDH1bokY8q1KWZQzPGpWhoW9b5+Hw+TZs2TZI0ZcoUud3s2RVLlu7wa8IrZdqwP6jx/dz6/agkdY/SBu2x8HcAAADYB/PZEtyynQH9/cMKvbbap8ZphqZflqKJZ3vkdDBVDLFvaFuXVk3O0KurfPrLwgr1uL9IV/Zy6c4LktWP6bwAAMDGWGkfB7xer+6+++5aL9AuKAzpsSUVGvy3Qg3+e5G2HAzqmR+katfUBrp5RBIh7SRYAB8+p/scPh0O09D4fh6tnpyhOT9N0+4jIfV/sEjn/6NIT3/m1ZGyUL0/JgAAwJli6mMEhHvK03fdf6nX0sp9AX22M6A31vn1yY6A0tzSZT3d+vlQj4a2ddJs4SSOnfr4q1/9So0aNYpyRfEpktMCLcvSu1/69dRnXr21wa9gSLqoi0vj+7o1pptLDcLUKZKpjwAA4HQw9yfOlPssrckPasWegD7fHdCKPUFt/CqokCU1STN0SVeXJp2Xpou6uNi0GgnJMAxd1NWti7q6VVxhae46n15a6dP1L5YqaEk9sx0a1s6pYW2dGtbOqZYNTD7IAAAAEUdQiyGhkKUj5ZYOllg6UBpSQZGl/MKQtn8dlC55WoMfC2jLwSMKhKSsFEMDWjk0todL916SrAGtHWrFG06ghvQkQz8c4NEPB3h0uDSkJdsD+nh7QB9v9+vJpV4FQlKDZEMdm5jq2MShjo0r/5uTaapZuqlm6YayUgx+rwAAQL0jqEVAMBiUJP3pza/lSCqTPyj5g1IgZCnwzf/7g5b8IanMb6ncJ5X6LZX7LJX6LJX7pTKfpaPllo6dqGoYUrMMQ01TLCno06jWxZo8LEX9WjmV29BU5XvHwDcXqbg44qce83w+X/Wmu8XFxWe0WS5OrqioqMZ/o8Ep6bw2lRedZ6jM59DKvQF9+XVA2w6GtO1gUC9uCWrH4ZACwWOOc0hN001lJRtKcRtKcUkpbkOpbkPJLkMpbinFZShQXrnf1eHDh6NyfgCiz7IsFRcXq0WLFifduB0AqrBGLQI+//xzDRo0KNplAAAAG9izZ49atmwZ7TIA2BwjahHQoUMHSdL69evD0kSguLhY3bp104YNG5Senl7v95/I/H6/Hn30UUnSDTfcoKysrChXFJ8S4Tm8b98+DR48WHv27KGZCJCgioqK1KpVq7j9OwegfhHUIsDhcEiSWrZsGbauj5KUk5PDG8B65vP5lJmZKUlq0aIFXR/DJJGewxkZGXF/jgBOjXWtAGqDCdIAAAAAYDMENQAAAACwGYJaHPB4PLrrrrvk8XiiXUpcc7vd0S4hbvEcBgAAqIk1anHA4/Ho7rvvjnYZcY8QET48hwEAAGpiRA0AAAAAbIagBgAAAAA2Q1ADAAAAAJshqAEAAACAzRDUAAAAAMBmCGoAAAAAYDMENQAAAACwGYIaAAAAANgMQQ0AAAAAbIagBgAAAAA2Q1ADAAAAAJshqAEAAACAzRDUAAAAAMBmCGoAAAAAYDMENQAAAACwGYIaAABn4GhZSLuPBKNdBgAgzhDUAACoA1/A0v2LypX1+6Nqc0+hfvBcibYeILABAOqHM9oFAAAQS8p9lh76oEJPfeZVQVFId16QpDKfpYWbA+r110I9MDZFvxjmkWEY0S4VABDDCGoAANRSidfSdS+UaM5avwa3cWjujRnq2aLypdQXsHT7m2W6eVaZth8KafplyYQ1AECdxeXUx/Xr12vcuHHq2LGjTNPU+PHjT3i7RYsWacCAAUpKSlJOTo6mTJmiQCDwnfd/5MgR3XrrrWrVqpXcbrdycnL0xz/+sb5PAwBgI8GQpfH/KdEnOwL68OZ0fXpbZnVIkyS309DfrkjV0+NT9bcPK3TdC6WyLCuKFQMAYllcjqiVlZWpdevWGjt2rB566KET3mb16tUaM2aMbrrpJj333HPauHGjfvrTn6q8vFx///vfT3rfpaWlGjFihJo0aaL//Oc/ateunQ4ePKivv/46TGcDALCDvy6u0MJNfn10c4bOyj35y+cNZ3mUlWzoin+XaGwPl67p64lglQCAeBGXQW3gwIEaOHCgJOnpp58+4W2mT5+uDh066LHHHpMkdevWTfv27dPkyZN11113KSsr64THPfDAAyoqKtLnn3+upKQkSVJubm6t6ioqKqrxtcfjkcfDCzgQj7xer7xeb/XXxcXFUawGZ8obsPS3Dyt0x6ikU4a0Kpf3cuuXwzy68aVS9clxqlNTRwSqBADEk7ic+lgbS5Ys0ejRo2tcN2bMGPl8Pi1fvvykx7322msaMWKEpkyZopycHHXo0EE/+9nPdOjQoe98zFatWikzM7P6Mm3atDM+DwD2NG3atBq/7926dYt2STgDzyzzqrDc0oShSbU+5sHLU9S5qUO/fK00jJUBAOJVwga1goICZWdn17iuefPmkqT8/PyTHrdt2za9+uqrKigo0Jw5c/TPf/5TS5cu1ejRoxUKhU75mHv27FFhYWH1ZcqUKWd+IgBsacqUKTV+3zds2BDtklBH5T5Lf3q3XD8/26MWmbV/2fQ4Df1uZLLe3xrQuoLvXv8MAMCx4nLqY11Vdec6VZeuUCikhg0b6rnnnpPb7ZYk/fvf/9ZZZ52lpUuXatiwYSc9NiMjQxkZGfVbNABbOn5q8/FTnxE7Hv6oQsUVlqaMSj7tY6/o6dKQXKd++HypvpiUIYdJF0gAQO0k7Ihadna2CgoKalxX9fXxI23HH9epU6fqkCZJPXv2lCTt2LEjDJUCAKKl1Gvp4Y8q9KvhSWqecfovmU6HoafHp2pdQVAvr/SFoUIAQLxK2KA2fPhwLViwoMZ18+fPl9vt1qBBg0563LnnnqutW7fWaOO/ceNGSVK7du3CUywAICr+36JyVfilX59T+7Vpx+vU1KGfDvbollllKqqgXT8AoHbiMqj5fD6tWrVKq1atUklJiY4ePVr9tc9X+YnmpEmTtGXLFt1yyy3auHGjZs+eralTp2rixInVHR9nz56tLl26aN++fdX3PXnyZB0+fFg/+9nPtHHjRn366ae68cYbNWTIEA0ZMiQq5wsAqH8lXkv/WOLV7SOT1DT9zF4u7/tesooqLL2xllE1AEDtxGVQy8/PV9++fdW3b1/l5eXpnXfeqf66qlFI7969NW/ePH3yySfq06ePfvGLX2jChAmaPn169f0UFhZq06ZN8vv91dd1795dCxcu1KZNm9SvXz+NGzdO/fr105tvvinTjMsfJwAkpP8s98ofsvSzIWe+jUrDVFOX9XDp7x9WsAk2AKBW4rKZSG5ubq1eCEeNGqW8vLyTfv/666/X9ddf/63rhw0bpk8++eRMSgQA2FgoVLk27f8GetQwtX4+hPv9BcnqN71I737p10Vd3d99AAAgoTEEBADAcRZs9GvLgZBuGVH3tWnH69vSqfM6OjXjE+933xgAkPAIagAAHOeRjyp0UReXujRz1Ov9/nyoR2+u92v3kWC93i8AIP4Q1AAAOMaeI0Et3BzQz4ee+dq0413e061m6YaeWMqoGgDg1AhqAAAc44UVPjVKMTS6m6ve79vtNPTTwR49s8yrQJCmIgCAkyOoAQDwDcuy9Oxyr37Q3y230wjLY/zkLI8Kiiwt2Oj/7hsDABIWQQ0AgG8s2xXU5gMh/d/A+p/2WKVtI4dGdXLq6c+Y/ggAODmCGgAA3/jPcq96ZjvUt2X9NhE53k8He/TWBr8KCkNhfRwAQOwiqCGqLMtSuc9SiddSqdeSL2CxGSyAqAgELb2yyqcfD3TLMMIz7bHK5T3dykwy9J/PGVUDAJxYXG54DXvyBixtOxjSjI8rVFRhyfdNd2qXQzINyZIUDFVeTENK8xhKTzJ042CPcjJNpSeF940TgMT28faADpdZuqJX+DejTnIZum6AW09/5tXtI5PCHgwBALGHoIawKygM6Z53ylVYbqlZuqHmGaY6NTXkduikb06CocpRtqIKS49/UqGj5Za8ASkz2VDjVEO/PS9JWSkMCAOoP3PX+dS9uUPtG4d32mOVnw726OGPvPpoW0DndKj/DpMAgNhGUEPYlHgt3Ta7TIGQpQ6NHeqbY9T6U2OHaSgz2VBm8v+uC4UsFVZYOlhq6TdzyuQNSI1SDd12TpLaNDTlMPlEGkDdWJalN9b5dW3f8I+mVenZwqlBrR2a8YmXoAYA+BaCGsLiUGlIN79eps5NHcrOqJ+RL9M0lJViKCtF6tjEoWDI0oESS9Pfr9DhMkuNUg1NPq8ytDGNCMDp+GJvUNsPhXR5z8gFNUm67dwk/fD5Ut33vaByG0VmJA8AEBuYO4Z6d7AkpF+9VqbeLeovpJ2Iw6ycRtknx6lz2zvVPN3UfYsr9IPnSnXb7DIdLKGbGoDaefozr7o2MzWwdWTD0tW93WqSZmhmni+ijwsAsD9G1FCvSryWbplVpr4tHWqQHLnPAUzTULN0Q83STfmDlvYXhzR5bplCIal1lqmpFyfL5WCUDcC3lfksvZjn0x8vinxTD6fD0Lg+br200qc7L0z+7gMAAAmDETXUG8uydOusMnVpGtmQdjyXw1CrBg4NyXWpT45TJT7pxy+U6tZZpYyyAfiWN9f5VOKzdN2A8G1yfSrj+7q1riCodQWBqDw+AMCeCGqoN3+YVy6PU2oexumOpyvVY6hrM4dGtHeqQZKpyXPL9H8zSzR1frn8QfZrAyC9sc6vc9o71TQ9On+7huQ61TrL1ItMfwQAHMM+76gR08p8lrYfCql7c3suhneYhnIamBqS61LvFk4VVYT04xdKdfNrpdpfxCgbkKj8QUvzN/h1WY/INhE5lmka+ulZHj22pEKF5fw9AgBUIqihXvz+rXK1bWTGxDqwNI+hbs2dOqe9U03STP1+Xrl+/EKJ/ji/TAFG2YCE8sn2gAorLF3aI7rt8W8Z4ZE3IL2x1h/VOgAA9kFQwxnzBy19VRxSqwax9XQyv+kaObiNU31znCqqsHTdC6WaNKdMpV4CG5AI3t/qV7tGptpGuTV+gxRTl3R16aWVTH8EAFSKrXfWsKWtB0JqkmbE9IbTqR5D3Zs7NbydUy6HdNPLpfrVa6U6WMo0JCCevb8loPM62mOz6fH93Fq4yU/TIwCAJIIa6sHDH1WohY0aiJwJp8NQ20aVzUeapJn6/Zvl0S4JQJiU+Sx9tiug8zrYY6eaS7u75XZKs9YwqgYAIKjhDPkClgrLLTVIid3RtBMxDUPZGabOyv3fdKifvVyqP71TLstiWiQQDz7dGZA/KJ3bwR4jaqkeQ5d2dzP9EQAgiaCGM/SXhRVqlm7KjPAmsZFy7Oa33Zs7lF8Y0nUvlGrq/HKFQgQ2IJa9v8Wvjk1M5dhofe34vm59sDWggkKmPwJAorPPqxNi0r7CkFpkxmdIO156kqG+LZ0a2Mqpo+WVgY0RNiB2vb81oPNsMppW5eKuLqV7DL26ilE1AEh0BDXUWYXfUrnPUmZSYgS1KsluQz2ynRrY2qm9R0O6/kUCGxBrSryWlu8K6LyO9lifViXJZeiKnnR/BAAQ1HAGdh8JqVGqUWN6YCJJcRvq38qpntlOFRRVjrDdtYDABsSCT7b7FQjZZ33ascb3c+vTnQHtOhyMdikAgCgiqKHOnljqVVYyT6GMJEN9cpwa0Mqpg6WVge3etwlsgJ19sDWgrs1MNbdhx9qRnVxqmGJo1ho2vwaARGa/VyjEjBKvpTRPtKuwjxS3od4tnOrfyqn8osopkfuO0hAAsKP3t/ptOZomSS6HoYu6uLRgI9MfASCREdRQZ5VBLTGnPZ5KqttQv5ZOdW/u0O/nlekXr5aqxMvoGmAXxRWWVuwJ2maj6xMZ3c2lD7cG+NsBAAmMoIY68QYq3zw4TILayTRINjU016kmqaZueqlUt88tU5CW/kDULdnuVzAknWuTja5P5KIuLvlD0ntbmP4IAImKoIY62XkopMZphLTvYhiGchqYGt7OKX9Q+vELpfrzO+XRLgtIaB9sDahHtkNN0uz7EtgkzdTAVg4t2EBQA4BEZd9XKdjav5d5leYmqNWW02GoSzOHBrRyateRkG78b6mOlLF+DYiG97f4bT2aVuWSri7N3+inMREAJCiCGuqkxGcplfVppy3VY2hga6dyG5r61Wtlun1umUJMhwQiprA8pC/2Bm230fWJjO7m1u4jIW3YT5t+AEhEBDXUSXGFpQyCWp01TTc1rJ1T3oCl/5tZqq+KGV0DIuGjbQFZks6JgRG1Aa0capJmaMFGpj8CQCIiqKFO/EHJ7SSonQmHaahbc6d6tnDot3PKNGkOo2tAuL2/xa9e2Q41SrX/y59pVrbpn09QA4CEZP9XKthOIGiJZo/1p0GyqbPbOhW0pOtfLNXBEkbXgHD5YFtA53W0/2haldFdXVqyLaCiCj7EAYBEQ1DDaSuqsJTsIqnVJ4dpqGszh7o1d+iWWWW6860yGggA9exwaUir9gVtu9H1iVzYxaWQJS3ezKgaACQaghpOW1GFpaTYeZ8TUxqmVI6uHa2w9OMXSrW/iNE1oL58tC0gSRrRPnZG1BqlmjqrjVPzadMPAAmHoIbTdrTcUgojamHjchjq3cKpXi0cmvRGZWdIRteAM/f+Vr/65jiUlRJbL32ju7m0YKOPvwMAkGBi69UKtvBCno+pjxGQ+c3atRKvpZteLlO5jzdpwJl4f0tA53WMvekAl3R1aV+hpbUFtOkHgEQSl0Ft/fr1GjdunDp27CjTNDV+/PgT3m7RokUaMGCAkpKSlJOToylTpigQCNT6cdauXavU1FQZhqGKior6Kt/2fAFL7tiZORTTHKah3jlO5WSY+ulLpdp9hDdqQF0cLAlpbUFQ58VAW/7j9c1xqFm6wfRHAEgwcRnUysrK1Lp1a02dOlW9e/c+4W1Wr16tMWPGaPDgwfriiy/0yCOPaMaMGZo0aVKtHqOoqEhXX321Ro0aVZ+lxwRfUHI5ol1FYslpYGpgK6f+MK9ck96gjT9wuj7cFpBpSMPaxV5QM01Dl3R1EdQAIMHEZVAbOHCgHnzwQV133XXKzMw84W2mT5+uDh066LHHHlO3bt101VVX6d5779WMGTN05MiR73yMn/zkJ7rooot0xRVX1Hf5tlfmY41aNKR6DA3JdcoftPTTl0pV6iWsAbX1/ha/+rdyKDM5Nl/2Lunq0tKdAR0to8EQACSK2HzFqgdLlizR6NGja1w3ZswY+Xw+LV++/JTHPvTQQ9q1a5emT59+Wo9ZVFRU4+L1ek+77mizLEs+NruOGodpqHtzp9o2dOiml0v1dTFv2uzK6/XW+H0vLi6OdkkJ7f2tAZ0XQ235j3dBZ5csS1q8pfbT8wEAsS1hg1pBQYGys7NrXNe8eXNJUn5+/kmP++STTzRt2jS9/PLLcrvdp/WYrVq1UmZmZvVl2rRpp194lPmDkithnzX20TzDVN8ch349u0z3vl0e7XJwAtOmTavx+96tW7dol5Swvi4OacP+YExtdH28rBRTg3OdWrCR6Y8AkCh4y30MwzBq/Pd4Bw8e1DXXXKPHH39c7dq1O+3737NnjwoLC6svU6ZMOaN6o8EbkJysT7OFzGRTQ3Kd2nYoqElv0MLfbqZMmVLj933Dhg3RLilhfbDVL4cpnd02dkfUpMrpj7TpB4DEEbsfL56h7OxsFRQU1Liu6uvjR9qqrFu3Tvn5+br22murr6t6wUxLS9Ott96qBx988KSPmZGRoYyMjDMtPar8QUsOM7amPU54pbTOx7rk151Z9VhMPfM4DQ1p49Ta/UH9/JUyPXZ1ilyO2Pr3iVcej0cej6f666KioihWk9je3xLQwFYOpSfF9u/GxV1c+uP8cq0tCKpXi4R9+QaAhJGwI2rDhw/XggULalw3f/58ud1uDRo06ITHDBw4UGvXrtWqVauqL/fee68kafny5Zo8eXLY6462QEiKlZw24ZXSMwppx7vl9bJ6vb/6YpqGemU71DDF0E//W6riCj5tB471/lZ/TO6fdrx+LR1qmmZoAd0fASAhxOVHcj6fr3qaUUlJiY4ePapVq1ZJkrp16ya3261JkyZp0KBBuuWWWzRx4kR9+eWXmjp1qiZOnKisrMohlNmzZ2vKlClavHixcnJylJqaqh49etR4rBUrVlTfb1JSUuROMkpOMivUVsIdpo69/yeuSQ3rY9WWYRhq28ihVLehCa+U6u9XpKhpesJ+DgNUyy8MadPXobgIaqZp6OKuLi3Y6Nfto5KjXQ4AIMziMqjl5+erb9++Na575513JEk7duxQbm6uevfurXnz5un222/XE088oYYNG2rChAn685//XH1MYWGhNm3aJL+fTy+rmIZk1y28ojHaZbfQ1jTdlMcp3TqrTL1aODTlAt7MIbF9uNUvl0MamhsfL3eXdHXpuhdKVVRhKSPGp3ICAE4tLj9yz83NlWVZJ7zk5uZW327UqFHKy8uT1+tVQUGB7rvvPjmd/3sxv/766791zPGqbpMIo2lSZVCz4zp2O0xJrO+plnWVmWzqrDZOrSsI0hESCe/9rQENau1Uqic+Qs2FnV0KWdKiTXyACADxLi6DGsLHYRq26zhmh3B0rKrAFs26UtyGBuc6tfVgUH+YVxa1OoBoW7LNr3M6xMdomiQ1TK38IIY2/QAQ/whqOC0Om019tFtIO140A5vHaeisNk7tKwzp9rmENSSegyUhffl1SMPaxk9Qk2jTDwCJgqCG0xKyYqOhiN1EK7C5HIYGtXbqcJml38xmrzUklqU7AzIMaUicrE+rcklXl/YVWlpXEIx2KQCAMCKo4bS4HFIwFO0qKtl9NO1EolGzwzTUv5VDFQFLv3q9TCE7DYkCYfTJ9oC6N3eoQUp8vdRVt+ln+iMAxLX4evVC2Hmckp8Pcc9INEbXTMNQ7xYOuUxp4qtlChLWkAA+3hGIu2mPUmWb/ou6uAhqABDnCGo4LcY38x6jPYUuFkfTjhfpwGYYhro2cygzydCNL5XKGyCsIX5V+C2t2B3Q2e3iL6hJldMfP94eUBEb3ANA3CKo4bQ5TSlgk+mP8SDSYa1DE4daZpq66aVSVfh5k4f4tGJPQL6g4nJETZIu7EKbfgCIdwQ1nDanI7pBLR5G044X6dG1VlkOtW3o0M9eLlW5j7CG+PPJ9oBaZBpq0zA+X+YapZo6u61Tr67yRbsUAECYxOcrGMIqyWkwEhMmkQxrOQ1MtWvk0IRXCGuIPx/vCOjstq7q6drx6Jq+bs3f6Jc/yO8vAMQjghpOm8dpyBuIzmPH42ja8SI5utYiszKs/exlpkEifoRClpbGaSORY13S1aWiCkuf7ozSH2QAQFgR1HDakl1SOW/qwy6iYa2xQxNeLpWPBiOIA5u+DulwmRW3jUSqtG/sUMcmphZsYJ0aAMQjghpO2w1neVRGUIuISIW1nExTrbJMTXillGlUiHkf7/Ar1S31buGIdilhd0lX2vQDQLwiqOG0NUo1VOqNdhWJI1JhrXWWQ83TTU18hX3WENs+2R7Q4FynnI74XZ9WZXRXl1bnB7X3KK14ASDeENRw2rKSDZVGoflEIqxPO5lIrVtr28ihzGRDN79eFvW98oC6qmwkEt/THquc08GlFLe0YCPdHwEg3hDUcNpM05BpiFGXKIhEWOvUxJQh6bdzysP+WEB9+6o4pG0HQxrWzhXtUiIiyWVoZEeX5q1n+iMAxBuCGuokPclQsZegFg3hDmuGYahnC4eKKiz9YV5ZWB8LqG+fbA/INKTBbRJjRE2SRndzadFmP82AACDOENRQJ2keglo0hTusmYahfi0d2nU4pL+8y8gaYsfH2/3q1cKh9KT4X59W5aIuLpX6pM920aYfAOIJQQ118pOzPCqhoUhUhTusOR2GBrR2al1BUIdKaVSA2PDJjoCGxXlb/uO1beRQh8am3v2S6Y8AEE8IaqiT7AxDheW8eY+2cIe1ZJehPjkO3TqrjGlVsL0yn6Uv9gYTppHIsS7s4tK7mwhqABBPCGqokwbJhsr8ojOgDYQ7rGWlmGqdZdIJEra3fFdAgZASppHIsS7s7NKKPYx+A0A8IaihTgzDUJrbUCkdoW0h3GGtTZYphynd/ibr1WBfH+8IqHWWqZYNEu+l7byOLpmGtHgzo2oAEC8S79UM9aZhiqHDZXx6axfhDGuGYahntkP7i2guAvt6b4tf57RPvGmPkpSRZGhIrlPvbqKhCADEC4Ia6uxXIzw6XMZUODsJZ1hzmIb6t6psLlJUwb877KXMZ+mT7QFd0Dnxpj1WubCzS+986WeKMgDECYIa6iw7w1RhOW8I7CacYS3ZZahHtkO/eq1UgSD/9rCPZbsC8gWl8zsmblC7qItLe4+GtPErZjoAQDwgqKHOXA5DpiG6AdpQOMNakzRT2RmmfkVzEdjIpzsDatXAVE4Crk+r0r+VQ41SDb29kcXDABAPEvcVDfWiUaqhQ0x/TDjtGn3TXGQu69VgD5/tDGhIbmKuT6viMA1d0Kly+iMAIPYR1HBGfjk8SQdpB21L4W4u0qO5Q/uLQ9p9JBi2xwFqw7IsfUpQk1Q5/fGj7QGV+/gADQBiHUENZ6RNlqnDpbwhsKtwNxfpk+PUHW+Wq8LPcwDRs+nrkA6WWhqagBtdH++iLi5V+KUPtzGqBgCxjqCGM+J2sk7N7sIZ1tI8hto1MvWbOWVhewzguyza7FdmkqH+rRzRLiXqsjNN9WrhYPojAMSBiAS1ioqKSDwMoiQrxaBNv82FM6y1amDKF5DufZv1aoiO97b4dW4HpxymEe1SbOGCzi4tZD81AIh5EQlqaWlp6t69u374wx/qgQce0MKFC3XgwIFIPDQi4FfDk3SAdWq2F66wZhiGerVwaONXQdbFIOIsy9JnOwM6ux3THqtc0Mmp9fuDKijk7zIAxLKIvLJ973vf0+rVq/Xf//5X//3vf2UYlZ96Nm/eXH369Klx6dixYyRKQj1q28jUwRJLlmVV/9sisSS5DHVs4tBtc8r0+DWp0S4HCWTv0ZAKiiyd1YagVmV4e5fcjsopodcN9ES7HABAHUXklW3OnDmSpMLCQq1evVqrVq3SwoULNW/ePBUUFGjBggXVb/BTUlLUq1cv9enTR3379tWNN94YiRJxBlwOQyluQyVeKT0pfI/zxDWpYZ3ClwgmvFKqJ8IUpHIyDeUXSfe8Xa67Lk4Oy2MAx/tsV1AOU+rfkqBWJcVt6Ox2ToIaAMS4iDYTyczM1IgRI3Tuuefq008/1dixYzVr1ix98MEHevbZZ3XFFVeovLxcn332mWbMmKEJEyZEsjycgWbphr4qYZpNLAjrFMhsh778KqhSL1MgERnLdgXUM9uhVA+j+ce6oJNLCzf52ZQeAGJYVLo+3nzzzerWrZvmzJmjyy+/XCNGjNB1112n1157TevWrVP//v3VoUMHvfjii9EoD3Vwx6hk7S8iqMWKcIW1JJehTk0c+u0bdIFEZHy2M6DBTHv8llGdXSoosrRhP/scAkCsikpQW7FihYYOHXrC73Xp0kVvv/22iouLtXr16ghXhrrKSKr8NJtmEmiRaSgQlP70Dl0gEV4Vfksr9rDR9Yn0a+lQVoqhRZvp/ggAsSoqQa1Ro0b68ssvT/r9hg0b6qqrrtLrr78ewapwprIzTBUUM6oWK8I5BbJHdmUXSPbXQzgt2xWQNyCd04GgdjyHaej8jk4t3MR+agAQq6IS1MaNG6d58+Zp4cKFJ72NYRjavXt3BKvCmZoyKkkFYZ7+GK5GGIkqXGEtxW2oVQNTk+cyBRLh88HWgNo2MtWmIRtdn8gFnVz6YKtf/iAfmABALIpKUJs6darat2+vsWPHavLkydq/f3+N72/ZskUvvfSSsrKyolEe6qhBiinLksqY/ghVbttwuNTSV4yyIkw+2OrXue0ZTTuZCzq7VOqrXMcHAIg9UQlqmZmZ+vjjjzVs2DA9+OCDys3N1dlnn63x48dr5MiR6tmzpw4dOqSf/OQn0SgPZ6BlA1P72GQ1poRrVM00DHXPduiON8voPId6V+G39OnOgM7t4Ip2KbbVrrFDbRuZTH8EgBgVlaAmSY0bN9bChQs1Z84cjRw5UqtXr9Yrr7yi999/Xw0bNtT999+ve++9N1rloY7+cGGy8gtDYX1jzvTH+heusNYwxZTHaeietyvCcv9IXKxPq50LOrloKAIAMSpqQa3K2LFjNW/ePJWUlOjAgQM6evSo8vPzNXnyZJlm3ctbv369xo0bp44dO8o0TY0fP/6Et1u0aJEGDBigpKQk5eTkaMqUKQoETv6i9swzz2jkyJFq2rSpUlNT1atXL/3zn/+sc53xJsVdufn10XJGUFCpWzOHNh8Isk4G9er9LX7Wp9XCBZ1dWr47oMJyZjoAQKyJelA7VqNGjeR2u7VixQo9/fTTuuWWW+p8X2VlZWrdurWmTp2q3r17n/A2q1ev1pgxYzR48GB98cUXeuSRRzRjxgxNmjTppPe7ePFijR49Wm+99ZbWrl2riRMn6te//rWmT59e51rjzeTzk7T7CG8KYk0491ZrmWnqjjdp14/68/7WgM5jNO07ndfRqZBV2XgFABBbDCuKi0f27dun1atXa82aNVq9erVWr16tLVu2KBSqnDpnGIaCwTPfrPPcc89V8+bN9dJLL9W4/rrrrtMXX3yh9evXV1/3yCOPVDc4qW0zkxtuuEFr167VihUrTvj9oqIiZWZmas+ePcrIyKi+3uPxyOPx1OGM7C0UsvTD50s1vJ1TTocRtscJV7A4lkt+3Zn1uCTpL0d+Lr/ifz1MOKaWBkOWPt4e0D+uTlGDFFt9PhQ2Xq9XXq+3+ut9+/apW7duKiwsrPF3AKev3GepwZQjevr7qfrRgPj7G1rfBj5YqLPaOPXY1Uwbj7aq9wP8HQBQGxH7OHLVqlXVYazqcuTIEUmqsZ4pKytLQ4YMUffu3dWjR4+w1rRkyRKNGzeuxnVjxozRrbfequXLl+uiiy6q1f0UFhaqUaNG33m7Vq1a1fj6rrvu0t13313remOFaRrKzjCVXxRS6yymJaFyT6fOTR363ZvlevLaxHizOG3aNN1zzz3RLiMuLd0ZkC8onUcjkVoZ1cmlWWt80S4DAHCaIhbU+vXrJ8MwqkNZ8+bNNXLkSHXv3l3du3dXt27dNGzYMF111VV68sknI1JTQUGBsrOza1zXvHlzSVJ+fn6t7mPevHl64403NHfu3O+87YlG1OLVXRcn6ZevlalVA1OGEZ5RtSeuSY3IqFqimfBKaVhG1ZpnmNp5JKSdh4LKbRT/AX7KlCn6zW9+U/111Ygaztz7W/zq2MRUToPEGJ09Uxd0dum+xRXafSTIh2cAEEMiOsHfMAzddttt+sMf/qAGDRpE8qFrrSpU1CZcLF68WNdcc43+8pe/aMyYMd95+4yMjISZ6pCZbCrFbehwmaVGqeGb/ojY0q2ZQ3+cX67nfpQatgBvF8dPbS4qKopiNfGlcn0ao2m1NbStU8kuadGmgH4ymKAGALEiYh9HzpkzRx06dNDf/vY3jR07Vp999lmkHvqksrOzVVBQUOO6qq+PH2k73ty5c/W9731Pf/rTn3THHXeErcZY9scLk7TtYHibitCqPzzCNVKZkWSoQbKhqfNpLIK6KfFaWr4roPM60kiktpJchoa3c2rRZvZTA4BYErGgNnbsWK1bt04PPPCA1q1bp7PPPlvjxo3Tli1bIlXCtwwfPlwLFiyocd38+fPldrs1aNCgkx733HPPady4cXrkkUdqTG1CTa2yHApalooqaMsei8IV1jo2cWjrwRDt+lEnn2z3KxASG12fpgs6u7Ros1+hEL93ABArIjrB3+l06je/+Y22bNmin/3sZ5ozZ4569OihX/7yl/r666/r9bF8Pp9WrVqlVatWqaSkREePHq3+2uerXFQ9adIkbdmyRbfccos2btyo2bNna+rUqZo4cWJ1x8fZs2erS5cu2rdvnyTp4Ycf1g033KC//vWvuvTSS7V///7qC74tt6FDOw+feefOU2FULbYkuQy1bGDq928xqobT9/7WgLo2M9U8g/Vpp+OCzi4dKLG0Jj+8f48BAPUnKq90jRo10owZM7Ry5Uqdc845mjFjhjp06FCva1by8/PVt29f9e3bV3l5eXrnnXeqv65qFNK7d2/NmzdPn3zyifr06aNf/OIXmjBhQo090QoLC7Vp0yb5/ZVTRv72t78pFArp17/+tbKzs2tc8G1/vDBJR8osVfj5FDcWhWtUrV0jU3uPhlTu43mB0/P+Fr/O68ho2unqme1Qo1RDH25jPzUAiBVR/UiyR48eevfddzVnzhxlZ2fLsizNmTNH//rXv3Sm27vl5ubKsqwTXnJzc6tvN2rUKOXl5cnr9aqgoED33XefnM7/rX24/vrraxyzc+fOk94vvs00DbVtZGrbIUbV8D8O01C7RqZ+N7cs2qUghhRVWMrbG6SRSB2YZuU6tY+2sU4NAGKFLeaOjB07VuvXr9f06dMVCAT085//XP3799dHH30U7dJQD+65JFkHSyyVM6oWk8I1qtY6y9TRcksHSsLbcAbxY8k2v4Ih6dwONBKpixHtXfpoW4APFgEgRtgiqEnfXr+2du1anX/++dEuC/XAYRrq0MShzV8zqob/MQxDXZs7dMebrFVD7by/NaCe2Q41TrPNS1dMGdHeqYOllr78ig9HACAW2O7V7tj1ayNHjox2Oagnd1+cpKKK8HeAJKyFR7hG1RqnmjIMaftBGhzgu1WuT2M0ra765DiU7hHTHwEgRtguqFXp0aOH3nnnnWiXgXpiGIb+PCZZG/Yz7QY1dWvm0NQF5TwvcEpHykJauY/1aWfCYRoa1s5FQxEAiBG2DWqIP20aOuR0GPq6hFG1WBSuUbU0zzebYC9gCiRO7qNvwsU5rE87Ixd0dmneBr/K6LgKALZHUENE3X9psr78KqhgmDddJazFlk5NHNp2MKQAm2DjJN7b4lefHIeyUnjZOhPj+7pVVGFpCdMfAcD2eMVDRGWlmMrONLX1IIvZ8T9JLkPN0039cT6jajix97cEmPZYD7IzTXVv7tDiLUx/BAC7I6gh4u6/NFlfFYdUTGORmBOu6Y+S1L6xqZ2HQ/IGGFVDTQdKQlpbEKSRSD0Z1cmpRZsZUQMAuyOoIeIcpqFp30vWmvyAQmFuIEFYix0uh6HWWaZ+/xajaqjpw60BmYY0vB1BrT6M7OTSqn1BHWQPQwCwNYIaoqJVlkOZyYZ2HAr/GwXCWv0K56habkNT+YUhGh2ghve3+tW/lUOZybxk1YdzOrhkGpX70gEA7ItXPUTNg5enaO/RUNj3VkPscJiG2jUyNeWtsmiXAht5f4uf9Wn1KCPJ0KDWTi3cxPRHALAzghqixuUw9MBlKVq1L0AXSFRrlWXqYIkV9jWMiA37i0La+FWI9Wn1bEw3l95a72P/QgCwMYIaoqpFpqkWGaY2fBUM+2MR1upPOKc/moahdo1N3TmPUTVIH2z1y2lKw9oxolafLuziUkGRpY1fsU4NAOyKoIaou39sskq9lgqKWK+GSjmZpg6WMqqGyrb8A1s7leYxol1KXOnX0qHMJEOL6f4IALZFUEPUGYahx65O1aavgyrxhv+NOWHN/kzDUPvGpn7PqFrCe3+rn2mPYeAwDY3s5NQ7XxLUAMCuCGqwhRS3ob+OTdEXe8O/Xk0irNWHcE5/lCpH1Q6XWiosZ2pWotq4P6gtB0Ia1Ylpj+Ewuptb723xq5wuqwBgSwQ12EbLBqZaNjC1tiAYkQXuhDV7qxxVc+iP89lXLVHNzPOqTZapc9ozohYOl3R1qdwvfbiNUTUAsCOCGmxl2veSFbKknYcjM4pCWLO3FpmGDpZaKo3AlFjYz5vr/bqsp0umyfq0cGiRaapvS4fmbSCoAYAdEdRgK4Zh6NGrUrTnaEiHSwlric40DOU2NBlVS0C7Dge1Jj+oS7u7o11KXBvd1aX5G/y06QcAGyKowXZcjsqwtjo/qNIIrZ0grNVNuNepSVKrBqYKikLyBXgjmUjeWu9XRpKhEUx7DKvR3VzafiikzV+zFhQA7IagBlvKSjHVu4VDK3YHIvYGnbBmTw7TUItMU3ctYFQtkcxd59PFXVxyO5n2GE5ntXGqYYqheRt80S4FAHAcghps644LktWxiUOf745MJ0iJsGZXuQ1N7T4SYnpWgiiusPTB1oAu7UG3x3BzmIYu7urS/I2sUwMAuyGowdbuviRZOQ1M5e0NKhShN+mENfvxOA1lJhvaepDpWYng3U1+BUKVXQkRfqO7uvTRtgAbzAOAzRDUYHv/73spyvAYWpMfmbb9EmHNjlpnmZr+XkW0y0AEzF3n07B2TjVK5SUqEi7u6lIgJC3azKgaANgJr4KICQ9enizDkDZ+FbkRFcJa7USioYgkZSUbKvbSqj/eBUOW5m/w69LujKZFSqNUU4PbODWfNv0AYCsENcQEwzD06JUpKvNb2nogGLHHfeSqlIg9Fk7N+KZV/x9o1R/XPtsZ0MFSi7b8ETa6m0vzN/pYBwoANkJQQ8wwTUMzxqXoYJmlnYcjF9ZgH60amNpfFFIgyJvJePXmer86NjHVuZkj2qUklDHdXMovtLR6H39bAcAuCGqIKQ7T0BPXpKigKKTdRyL7hoLRtehzmIaapBn687usVYtXc9f5NLYHo2mR1ifHoewMg+6PAGAjBDXEHJfD0OPXpGr3kZDyCyPbBZB1a9HXOssR8ZCOyNh2MKiNX4VYnxYFhmHokq4u1qkBgI0Q1BCTPE5DT1yTqq0Hg9pfFPmwRmCLnowkQ4GQdKSMVv3x5s11fmWlGDq7rTPapSSkMd3c+nRnQIdK+d0CADsgqCFmJbsrw9rmA0F9VRz5NxaEtehp1cBk+mMcenO9T6O7uuR0GNEuJSGN6uySw5Te/ZJRNQCwA4IaYlqqp3Ia5KavIz+yJhHWoiU7w4zKvzfC52hZSB9tCzDtMYoykgwNb+dknRoA2ARBDTEvzVM5srblQFD7jkYnrBHYIsvtNOR2Mv0xnrz9zSjOxV0JatE0uptLCzb6FQzRWRUAoo2ghriQ6jH0r/Gp2nkkqF1Rat1PWIuspmmm/rqY6Y/x4s31fp3TwanMZF6Woml0V7cOlVpatIlRNQCINl4RETeSXIb+dW2qCopC2nowGJWNWxldi5zm6ab2R2FtIupfIGhp/gY/m1zbQJdmps7v6NTfP/RGuxQASHgENcQVt9PQk9emqqjC0hd7gyrzRWf6TiKFtWida6rHkC8gVfiZohXrPtwW0NFyS2N7MO0x2gzD0PWDPHpvi19FFfxuAUA0EdQQd5wOQzPGpSgn09SyXYGorWNidC38mqQZ2n6IUbVY9+oqn/q3cqhtI0e0S4Gk73V3KWRJ8zf4ol0KACQ0ghrikmEYmnpxsh67OkWr84M6GMV9gQhr4dMkzdQ/PmadWiwLhizNWuPT1b2Z9mgXWSmmzu3g1Ow1rFMDgGgiqCGuNUo1NWNcitYXRKd9fxVG18KjYYqhI2VMz4plS7YFdKDE0lUENVu5opdb8zf6mFoMAFFEUEPcy0w29eS1qdp6MKjdR6LTEbJKvIW1aJ+PwzTkNKVSL28mY9Wrq33q3cKhjk2Y9mgnl/Vwq8QrLd7MqBoAREtcBrX169dr3Lhx6tixo0zT1Pjx4094u0WLFmnAgAFKSkpSTk6OpkyZokAg8J33X9fjED1V7fvzC0PafCA6HSGrMLpWvxqmGNoThf3zcOaqpj2O68Nomt3kNDA1qLVDs9cS1AAgWuIyqJWVlal169aaOnWqevfufcLbrF69WmPGjNHgwYP1xRdf6JFHHtGMGTM0adKkU953XY9D9HmclWGt1GtpTUFQoShv6Brrgc0utWelmHr8E1qJx6KlOwLaX2SxPs2mrujl1tx1Pja/BoAoicugNnDgQD344IO67rrrlJmZecLbTJ8+XR06dNBjjz2mbt266aqrrtK9996rGTNm6MiRIye977oeB3twmIb+OS5FSU5Dy3cH5A9G/w2IXQJPrGqQbOhoOSNqsejVVT71yHaoczOmPdrRFT3dOlBiaekOZowAQDTEZVCrjSVLlmj06NE1rhszZox8Pp+WL19e78dJUlFRUY2L18soQDQYhqEHL09RTgNTn+4MqDRKe60dK9ZG1+xUa5JTqggoqtNZT8Tr9db4fS8uLo52SbYSCll6fY1P4xhNs63OzRzq2szU7DW06QeAaEjYoFZQUKDs7Owa1zVv3lySlJ+fX+/HSVKrVq2UmZlZfZk2bVpdSkc9+dPoFPVo7tDyXQEdKLHHiEwsBDa71WcYhpJdUrHNPveYNm1ajd/3bt26RbskW/lsV0D5hZauZn2arV3Ry63Za/22+yAEABJBwga1EzEMo8Z/6/u4PXv2qLCwsPoyZcqUuhWKenPHBcl64tpUfflVUDsPR7cj5LHsGtjsWJMkpXkM24TtKlOmTKnx+75hw4Zol2Qrr67yqWszU92aM+3Rzq7o6dbOwyGt3mefv48AkCgSNqhlZ2eroKCgxnVVXx8/YlYfx0lSRkZGjYvH46lL6ahnGUmGnv5+qg6UWFpbEIh6k5Fj2Smw2aWOE0lxGTpabp9/N0nyeDw1ft/T09OjXZJthEKWXlvtp9tjDOjfyqGWDUzNXsv0RwCItIQNasOHD9eCBQtqXDd//ny53W4NGjSo3o+Dvbmdhp68NkVuh6FluwPyBuz1pr8qsEUrLNk5pElSssvQi3m8kYwVn+8Oau/REN0eY4BhGLq8p0uz19CmHwAiLS6Dms/n06pVq7Rq1SqVlJTo6NGj1V/7fJVv5iZNmqQtW7bolltu0caNGzV79mxNnTpVEydOVFZWliRp9uzZ6tKli/bt21d937U5DrGpqslI24YOfbozYNtOgpEMbXYa0TuVZJdUZoOmMKidV1f71KmJqR7ZTHuMBVf0dGttQVDbDjL9EQAiyRntAsIhPz9fffv2rXHdO++8I0nasWOHcnNz1bt3b82bN0+33367nnjiCTVs2FATJkzQn//85+pjCgsLtWnTJvn9//sksTbHIbZNvThZB0pC+vWsMrVtEJQr2gWdwvEhasIrpfV+n7HA7TDk5z1kTAgELb2Y59WNgz2nvR4Y0TGivVMNUwy9vtqn341MjnY5AJAwDItWTmFXVFSkzMxMFRYWKiMjI9rloJa8AUs3v3JUOVsekSQ1O/83Mh2xNVWrNsEtFoPZ8QJBS0t3BvTCdWnRLuWk9u7dq1atWiX834EFG3wa/WSJtv0hU+0aM6IWK372cqlW7Anoi0kn3psUtcP7AQCnIy5H1ID64HEaevSqFN13X+XXXr+l5Bh7XxkPIaw2nA5DQXvOVMVxnlnu0zntnYS0GPODfm7961OvvvwqqC5sUA4AERGXa9SA+nLs1Kxlu4K2awEPxJLDpSG9sdan6wfR8TbWDG/vVItMQ//9wmYbFgJAHCOoAbX08BXJ2vx1UJu+DirEjGHgtP33C59cDrHJdQxymIau7ePWf7/wsfk1AEQIQQ2opcwUU//+QaqCIemznQGV02XQVgxDvIG0uWeWezWuj1tpHpqIxKIf9Pdoy4GQ8vbQuQcAIoGgBpwGh2no71emqGMThz7bFVBBEVMh7cKQWKdmY2vzA8rbE2TaYwzr38qhDo1N/fcL9iwEgEggqAF1cOeFyXpqfKp2HQlpXUFAoRAjOdEWsiQHf9Fs6z+f+9Sukanh7ehhFasMw9AP+rv10kqvgvzNA4Cw420NUEepHkNPj0+R22lo6c4AGy7bAPty2VMwVLl32nUD3DJN/o1i2ff7eZRfaGnJtkC0SwGAuEdQA86AYRiaflmKujR1aNmugL4qZu4dcLwPtwZUUGTp+/2Y9hjrujRzqG9LB9MfASACCGpAPfj9hcl68tpUbT8U1LqCANOCgGM8vtSroW2d6sz+W3Hh+/3cem21T74Af+cAIJwIakA9SU8y9PT4VHmchj7ZEdDRckbXIoXtEuzrYElIc9b69LMhjKbFi/F93TpcZundTf5olwIAcY2gBtQj0zT0wGUpevDyFK0rCGrjV0EajURAmU9KdbP2yY5ezPPJ45Su7s3eafGiVZZDw9s5mf4IAGFGUAPCoFm6qWd/kCpD0tKdAZV6CWvhVOqzlMqAjS09s9yra/t6lMreaXHl+/3cemOtj79tABBGBDUgTEzT0ENXpOhPo5P1+Z6Adh8JsiFzmJT7LaW4CAJ2s3JvQKv2BfWTsxhNizfj+rjlDUhvrGNUDQDChaAGhFmbhg79+/upOlhq6fPdQZX7CWv1rdRn6YazGFKzm2eWedW5qakhueydFm8ap5n6XneXnlnmjXYpABC3CGpABCS5DD1+TapaZ5n6bGdA+46GGF2rR0UVlpqmMaJmJ96ApZl5Pt0wyMP+dnHqhrM8WrwloJ2HgtEuBQDiEkENiKCpFyfr6e+nan9xSCv2BFXB6NoZsyxL5X4pM5kwYCezVvt0tNzSdQMZ6YxXl3R1qWmaof98zvRHAAgHghoQYSluQ09cm6qWDUx9ujOgnYdZu3YmSr/p+MiojX1YlqUHP6jQ1b3dapHJy0y8cjkMXTfAo2eXe+luCwBhwCsoECV3XZysZ3+YqsJyS5/tCqiE7ml1cqQ8pCxG02zlo20B5e0JatL5SdEuBWF2w1ke7Twc0jPLGVUDgPpGUAOiyOM09I9xqerYxKG8PQFt/jqoIJ9Mn5aviy3deg7T6+xk+vsVOqe9UwNb00Qk3nVr7tC4Pm79YX6ZfAH+dgFAfSKoATbw+wuS9Z8fpkqSPt4e0FfFoShXFBv8QUtFFZZaNuBPmV2sKwjorfV+/fY8RtMSxUOXp+hAiaXXVjOqBgD1iXc3gE04HYamX56ix65O0e4jIS1nOuR32lcYUotMk/VpNnLP2+Xqk+PQmG6uaJeCCGnZwNQ1fdy6f3EF620BoB4R1ACbyUox9a/xqfr9BUlauTeg1fkB9l47AX/Q0o5DIf1pdHK0S8E3Vu8L6LXVft19cbJMk/CcSO4YlaQ1+UEt2OiPdikAEDcIaoBNtWvs0HM/SlXjFFPLdwW0tiCgMh+BrcqG/UG1b2wqxU0gsIu73y5Xv5YOje3BaFqi6dXCqdHdXJq2qCLapQBA3CCoATZmGIbuGZ2s53+UqobJplbsCShvT0CF5Ym9hu1oeUglXovRNBvJ2xPQnLV+3XtJMlNRE9SUUUn6eHtAH29nVA0A6gMtuYAYYJqVgc2yLO08HNI9b5fL6QipfSNTDVMSaw+xYMjSmvygpl+WklDnbXd3v12uQa0dGs3atIQ1rJ1Lw9o5dd+iCr31M54HAHCmGFEDYohhGGrbyKFnf5imuy5K0vZDIS3dEVBBUUihBFnEv35/UDmZpppn8OfLLpbvquz0yGga7hiZpHkb/FqTH4h2KQAQ83inA8SoVlkO/Wt8qh68PEUHSkL6cGtAWw8G43ovo+2HgqoISPddypRHO7lrQbmGtnXqwi6MoiS60d1c6pnt0P2LWasGAGeKoAbEuMZpph67OlX//n6qDElLdwa0al9Ah0pDcdMq27Isbdgf0KFSSzPGMeXRTpbu8OvtLxlNQyXDMHTHqCS99IVP2w8Go10OAMQ0ghoQJ5Ldhu4fm6KZ16Xqt+claefhkD7YGtDGr4IqLI/d0BYIWvpib1BBS3rimhS5HIQBO7lrQblGtHfq/I4seUala/q41aahqenvM6oGAGeCoAbEGcMw1L6xQ09cm6pnf5iqNI+06UBlaFuTH9BXxSEFQ7ER2g6XhrR0Z0CNUg09cmUKe3PZzJvrfFq0OaA/jWY0Df/jdBiafF6S/r3Mq/1Fid2hFgDOBB+BAnHM4zT0p9Epkio3iN51OKSHP6zQhv2W0jyGGqcaapJmKtUtW73RPlIW0taDIQVClh68PEXN0vlMyW7KfZZunV2m7/dza0R71qahphvO8uied8r18IcVmnZpSrTLAYCYRFADEoTLYahDE4cevTpVlmXp6xJLD71fofX7gyr1WUpzG2qQYigzqfLicUYuvFmWpaIKS18VW9pfHFKS09AfLkxSbiNHRB4fp2/aonIdLAlp+mW8Cce3JbkM/fqcJE1bVKE7RiUpM5kPWwDgdBHUgARkGIaapVeuaZMqg9KhUksPf1ihAyUhbT1oyRuQkl1SusdQqrvykuI2lOySHGcwBTEQtFTqs1Tml46WWzpaHlK5v/JxmqUbeuKaVKV67DO6h2/bciCo+xdX6P5LU9QikzfgOLGJZ3t036IK3beIUTUAqAuCGgAZhqHGaYb+NOZ/b6Ysy1JhuaUDpZb+/ZlXX5eEVOaXKvyWgt8sO3GakstpyGVKpiGZ3/zXqL4PKWhJvqDk9VsKhCSHqerQd9MQj1pkGMpMTqxNu2NZKGTpppdK1bWZQ78a7ol2ObCxzGRTfx6TrN/MKdOPB3rUtTkj5ABwOghqAE7IMCqnQjZI0Qk/DbcsS75g5Volb1AKBKVAqDLEVbUqcRiVUy49TinNYyjJRRiLdU9+6tXHOwJafluGnHTgxHeYeLZHzy736hevleq9X6bzgQwAnAaCGoA6MYzKAOZx8sYrUew+EtTkuWX63flJ6teKlw98N4dp6PFxqRr0tyLNzPPpRwMYhQWA2mJxAQDgO1mWpQkvl6llpqmpFyVHuxzEkAGtnZp4tke/nVOmo2W06weA2iKoAQC+03Of+/TOJr/+/f1UprDitP1ldGW4v3N+eZQrAYDYQVADAJxSQWFIv55dpltHeDSkLXum4fQ1SDH14OUpmvGJV5/vDkS7HACICQQ1AMBJWZalX75eqoYphv48mhbrqLsf9nfr3A5OTXy1VMGQ9d0HAECCI6gBAE7q1VU+zV7j11Pj2d8OZ8YwDP3z6lStzQ/qr4srol0OANheQge18vJy3XXXXerYsaOSkpLUvn17/fWvf5VlnfyTPsuydN9996lz585KTk5Wdna2xo8frx07dkSwcgAIvy0Hgrrp5TL9cphH53VkyiPOXJdmDt1/aYqmLijX8l1MgQSAU0nooDZx4kT961//0oMPPqiNGzfqr3/9qx544AH96U9/Oukx06dP1z333KM777xTGzdu1Ouvv66tW7fq4osvjmDlABBeZT5LV/27RJ2aVK4tAurLLSM8GtnJpe8/V6IjdIEEgJNK2KBWUVGhmTNn6u6779bYsWPVtm1bXXXVVbrjjjv0wAMPqKys7ITHffTRRzrvvPP04x//WLm5uRo6dKh+97vfafPmzTp06FCEzwIA6p9lWZr4aqn2FYb06vVp7JWHemWahv7zw1T5gtI1z5YoEGS9GgCcSMIGNb/fr2AwqJSUmp8Up6amqqSkRCtWrDjhccOHD9eyZcu0bNkySdKBAwf0/PPPa+jQoWrUqNEpH7OoqKjGxev11s/JALAdr9db4/e9uLg42iXV2t8+qNDzK3x64Uepym3kiHY5iEPN0k298dM0fbIjoNvmnPiDUQBIdAkb1NLT0zVixAhNmzZNGzZskGVZWr16taZPny5J2rdv3wmPmzx5siZPnqxhw4bJ5XKpadOmKioq0rx5877zMVu1aqXMzMzqy7Rp0+r1nADYx7Rp02r8vnfr1i3aJdXKW+t9mjS3XNPHJuuSbu5ol4M41q+VU8/9ME2PLfHq8U9oLgIAx0vYoCZJL7zwgtq1a6eePXvK5XJp5MiR+r//+z9JksNx4k+R586dq4ceekiPPfaYvvjiC73zzjuqqKjQZZddpmAweMrH27NnjwoLC6svU6ZMqfdzAmAPU6ZMqfH7vmHDhmiX9J1W7wvo+8+V6KdneXTbuUnRLgcJ4Oo+bt1zcbJufr1M72/xR7scALCVhA5qLVu21JtvvqmysjLt3LlT+/fvV79+/SRJHTp0OOExt9xyi2666SZNmDBBPXv21IUXXqgXXnhBH330kRYuXHjKx8vIyKhx8Xg89X5OAOzB4/HU+H1PT0+PdkmntHpfQCP/WazBbZz6x9UpMgzWpSEy/nhRkq7q7dZVz5Ro64FTf+CJ6Pn3v/+tBg0anLIz9omOyczMPK1jTkfVEpbnn38+LPcPRFtCB7UqHo9HLVu2lNPp1PPPP6+OHTuqT58+J7xtWVnZt0bbTjb6BgCxoCqk9clx6I0b0+WmeQgiyDAMPfP9VLVvZOrSfxWrsJxOkHaUl5enfv36ndaHOHl5eerbt2/YPvjZuHGjysvL1b9//7Dc/5latGiRBgwYoKSkJOXk5GjKlCkKBL57W4raHLd+/XqNGzdOHTt2lGmaGj9+/Cnvc+3atUpNTZVhGKqoCN9U43Cd8zPPPKORI0eqadOmSk1NVa9evfTPf/7zW/cTb9toJXRQe++99zRnzhxt27ZNy5Yt009/+lPNmTNH//rXv2SalT+a2bNnq0uXLtVr1q644go9/PDDmjlzpnbs2KFPP/1UN9xwg3JycjRkyJBong4AnLZVewM6/x/F6pvj0Nwb05XiJqQh8pLdhub8NF1FXkujnywhrNlQXl7eaQeiqnAXLnl5eUpNTVWXLl3C9hh1tXr1ao0ZM0aDBw/WF198oUceeUQzZszQpEmT6uW4srIytW7dWlOnTlXv3r1PeZ9FRUW6+uqrNWrUqNM+j2effVa5ubm1um04z3nx4sUaPXq03nrrLa1du1YTJ07Ur3/96+reElXibhstK4HNnTvX6ty5s+XxeKyMjAzrkksusZYvX17jNs8884wlydqxY4dlWZZVVlZm3XnnnVaHDh2spKQkq3nz5taVV15pbdiw4aSPU1hYaEmyCgsLw3k6CAOv12vdfffd1t133215vd5ol4MYtmfPHtv9Hfhij99qOOWwdcE/C60ybyja5QDWl/sDVs7Uw1b/6UetgyXBaJdT7+z6fuDxxx+3Bg8ebGVlZVmpqanW4MGDrY8//rj6+36/30pKSrL++9//WpZlWcFg0EpLS7OmTJlijR492mrWrJnVsGFD6+c//7nl8/lqHPPQQw9ZN954o9W4cWMrMzPT+sUvfmGFQqFaP3aV/fv3Wz/4wQ+stLQ0q2nTptYDDzxg3XLLLdbZZ58d5p9O3fzoRz+yunXrVuO6hx9+2HK73dbhw4fr9bhzzjnHuvbaa096n1dddZV18803V7+nLS8vr/V5PPPMM1abNm1qddtInrNlWdb1119v9e/fv8Z13/ve96xLLrmkxnUvv/yyJck6ePBgrc7DThJ6RO3SSy/Vl19+qYqKChUWFmr+/PkaOHBgjdtcf/31siyr+tOE5ORk/fnPf9aWLVtUXl6ugoICvf766+ratWsUzgAA6ubNdT6NeLRIA1o59MZP05XMSBpsoHMzhz66OUOHSi2NeLRYm75izVokHDlyRPfee69WrFihpUuXKjs7W1dffXX199evX6+KigoNGDBAkrR582aVlJToySef1Pjx4/Xpp5/q/vvv1xNPPKEnn3yyxjGPP/64RowYoc8++0wPPPCA/vnPf+qDDz6o9WNLUkFBgQYMGKCjR49qyZIlWrRokebOnasXXnihuqZjzZw5U2lpaae8dO/ePQw/yf9ZsmSJRo8eXeO6MWPGyOfzafny5fV+3Mk89NBD2rVr17dGnsIh0udcWFj4ra2xzmQbLTtyRrsAAEDkWJal6e9X6PY3y3XjYI8euyqFNWmwlXaNHfro5nRd/UyJ+j9YqMevSdWPBtB8K5zuuOOOGl9PmjRJZ599to4ePaoGDRooLy9PmZmZat++vaTKKYeS9OSTT+rKK6+UJN144416/vnntWTJEv3yl7+svs3zzz+vQYMGSZLatWuniRMn6quvvqr1Y0vSbbfdpqZNm2ru3LnVfQH+3//7fxo+fPgJp2OOHTtWZ5111inP2eVyfefPpbCwUAUFBd95P1U/l2MVFBQoOzu7xnXNmzeXJOXn55/0/up63Il88sknmjZtmpYtWya3u3bbrcycOVMTJkyo/joQCMjn8yktLa36ujZt2mj9+vX1Vntdjps3b57eeOMNzZ07t8b1kydPVigU0rBhw6rrHzFiRK220bIjghoAJIhyn6WfvVKqF/N8+tvlKbplhIfujrClVlkOLbklQ7+fV67rXijVe5v9euzqVNZQhsGBAwf06KOPat68edq7d69KS0sVDAaVlpZWHZSObySSl5enbt26VYe0KklJ/9vWIy8vT2eddVZ1SJOkHTt2KBgMqmPHjrV+7MOHD+u1117Tiy++WKN5W1XQOlFQS09Pr5dOu6+++qpuuummU96mTZs22rlzZ63ur+rnd7p/d+ty3MGDB3XNNdfo8ccfV7t27Wp93PEhd9asWXrkkUdqjILWJuRWCcc5L168WNdcc43+8pe/aMyYMTW+d+w2WkOHDlVBQYH++Mc/6rLLLtN7770Xcw0ACWoAkAB2HgrqqmdKtONwSG//PF0XdK79Cy0QDW6noemXpeic9k5d/2Kplu0u0gs/SlXflrx1qS/FxcUaNGiQcnNzdeedd6pdu3ZKS0vT7bffrgMHDlTfbsWKFRoxYkT11ydqLBIIBLRy5Ur97ne/qz5m+PDhNW6Tl5cnt9utnj171vqxV61apWAw+K2lKcuWLTtpI5HjR4VO5GSjQse68cYbdeONN57yNieTnZ39rdG4qq+PHz2qj+OOt27dOuXn5+vaa6+tvs76ZpuEtLQ03XrrrXrwwQe/ddzxIbdp06ZyOp0n3baqPmo/nePmzp2ra6+9Vn/5y1/0m9/85lv3dew2WpLUs2dPtW3bVp06ddLChQtjrqlIQq9RA4B4Z1mWZq7wqu/0IgVC0ue/ySCkIaZc2sOtlZMz1DjVUP8HizTh5VIdKKErZH14++23tXPnTs2ePVtXXnml+vTpI4/HU90qXaoMYGvWrKn+2rIsrVy5UqFQzX+Dp556SmVlZbruuuu+dUyVvLw89ejRQ263u1aPLam6C/exLeUrKir00EMPqW/fvtXfP9bYsWO1atWqU17mz59fPz/Ekxg+fLgWLFhQ47r58+fL7XbXGGWsr+OON3DgQK1du7bGOd97772SpOXLl2vy5MmncTa1E+5zfu655zRu3Dg98sgjJwxpUhxuoxXVViYJwq5dnvDd6PqI+hKNro8HioPWVf8usnTrIeuW10usUjo7IoaFQiHrhc8rrBZTD1sN7jhs/f2DcssXiK3ntN3eDyxevNiSZP3jH/+wtm/fbs2aNcvq37+/JcmaOXOmZVmWtWrVKkuStWXLFsuyLOvLL7+0JFnNmze3Zs+ebe3YscN69NFHLbfbbT311FM1jtm8eXONxxs1apT1s5/9rNaPbVmWdeTIESsjI8MaPXq0tWHDBmvFihXWBRdcYDkcDuvWW2+NwE+pblatWmW53W7r5ptvtjZs2GDNmjXLatCgwbdqnjVrltW5c2dr7969p3Wc1+u1Vq5caa1cudLq37+/ddFFF1V/fbL3K7Xp+lhWVmYVFBSc8vL111/X+ZyPP9/aHvf3v//dMk3T+vvf//6teo510003WRkZGdYLL7xgbd++3Vq6dKk1YsQIKycnxzp69OhJz9uuCGoRYLc/zKg9ghrqS6SD2uzVXqvZHw5bre8+Yi3e5IvIYwKRUFwRsn7/Vqnl/s0hq9u0o9a7X8bO89uO7wfuuOMOq2HDhlZ6erp12WWXWa+88oolydq0aZNlWZb19NNPW5mZmdUt9WfOnGmlp6db7733ntWlSxfL7XZbPXv2tObPn199n8cfU6Vhw4bWk08+WevHrjJ//nyrc+fOVmpqqtW7d2/r0UcftdLT063nnnsuXD+WerFw4UKrX79+ltvttpo3b27dfvvtlt/vr3Gb47eBqu1xO3bssCSd8HLsfZ3osU4V1Kpuc6rLqdr1f1ftJzrf2hzXpk2bk9ZzrLpso2VnhmV9M2EVYVNUVKTMzEwVFhYqIyMj2uXgNPh8Pk2bNk2SNGXKlFp3TQKOt3fvXrVq1Srsfwc27g9q0twyzd/g1w2D3PrbFSnKTGaWO+LP9oNB/faNMs1Z69fYHi7dPjJJQ3Kdtm6QEw/vB377299q+fLlWrJkSbRLAeIer94AEAe2Hgjq5tdL1fuBQhUUhfT+L9P17x+kEdIQt9o1dmj2T9P17sR05ReGdPbDxeo3vUj/+rRCpV4+gw6Xqg6QAMKP1kkAEKMsy9IHWwP62wcVemuDX7kNTT1yZYpuGuKRw7TvqAJQny7o7NIFnTP1+e6A/rGkQje/XqbfzCnTqE4uXdK18tIqK4abCdiI9U0jkeuvvz7apQAJgY9a44DX69Xdd98tr9cb7VLiGj/f8OE5XHuhkKVlOwP6/Vtl6jatUOf/o1hrvtypl37k0ZY7M/Xzs5NiOqTF03Mhns5Fsv/5DGzt1LM/TNO+exrogbEpCoak2+aUqfU9hepxX6Emv1Gm9zb75QtUjrbZ/XzsyDAMFRYWEtSACGGNWgSEe056PMx5t6tj16j96le/UqNGjaJcUXxKhOfwmaxR8wYsfbDFrzlr/XpjnU8FRZbaNTJ1eU+3xnbx69yuDeLmZxdPz4V4OhcpNs/HG7C0ZFtACzb6tWCjTxu/CinNIw3JdapL46AenfpzffzGkxrYLkNuZ/g/4IjFnyGA6GHqIwDYSFGFpdX7Alq1L6hV+wJauS+o9QVB+YJSv5YOTTw7SZf3dKlHtkOGYaioqCjaJQO25XEaGtXZpVGdXXrw8hTtPBTU21/69dnOgD7cHpBG/l3D/hmU0zyirs0c6tXCoc5NHWqTZSq3kak2WaZyMk05HbE7Sg0gdhHUACCCNuwPyPu1X4dKLX1VHNK+wpDyCyv/u+1QSNsOVm4i2zDFUN+WDp3f0aXfnJukEe2das06G+CM5DZy6OdnO/Tzs78Z3WrQVMs2H9L2oiStyQ9qdX5QL6zwateRkLyBymMcptQy01SbhqZyG5pqmmaqQbKhzGRDDY65ZCZ9899kU8kuyWnK1h0oAdgfQS0CgsGgJIXtk++q++WT9frn8/lUUVEhSSouLpbL5YpyRfEpEZ7DR48elSQNuX+f5E6XJGWlGmqRYSr7m8uAbqZ6tXCoVwunWmQaqnyPF/jm4tWJfjzx9rOLp/OJp3OR4vR8rKBaJBWrS1NDoztUfcdUKGToQImlPUdC2n00qN1H/NpzNKTdB0NavzukwnJLhRWWjpZZ8gdP/hhup+R2SC6nIY9TMr2VP7vDhw+H/fwA2JdlWSouLlaLFi1kmidvGcIatQj4/PPPNWjQoGiXAQAAAMAm9uzZo5YtW570+4yoRUCHDpUf061fvz4si4eLi4vVrVs3bdiwQenp6fV+/4nM7/fr0UcflSTdcMMNysrKinJF8SkRnsN79uzR0KFD6/3vQLz97OLpfOLpXCTOpz7s27dPgwcP1p49e2gmAiSwoqIitWrV6jv/9hDUIsDhqFxX0rJly7B1fZSknJwc/vDXM5/Pp8zMTElSixYt6PoYJon0HK7vvwPx9rOLp/OJp3OROJ/6lJGRERc/QwBn5rvWsbKPGgAAAADYDEENAAAAAGyGoBYHPB6P7rrrLnk8nmiXEtfcbne0S4hbPIfrLt5+dvF0PvF0LhLnAwCRRtfHCCgqKlJmZqYKCwuZkx5jfD6fpk2bJkmaMmUKYQ11tnfvXrVq1Yq/A0AC4+8AAKn22YARNQAAAACwGYIaAAAAANgMQQ0AAAAAbIagBgAAAAA2Q1ADAAAAAJshqAEAAACAzRDUAAAAAMBmCGoAAAAAYDMENQAAAACwGYIaAAAAANgMQQ0AAAAAbIagBgAAAAA2Q1ADAAAAAJshqAEAAACAzRDUAAAAAMBmnNEuAAAAAEClogpLMz6ukMOUfjY0SRlJRrRLQpQQ1AAAAIAoK/FamvFJhR54r0L+oFTstTR5brkW/yJd53ZwyjQJbImGoAYAAABE0Sfb/brmPyU6Wm5p4tlJuvOCJO0rDGncMyUa+c9ijerk1H9/nKbGaaxaSiT8awMAAABRkrcnoAsfL1anJg5t+0MDTb8sRVkppnpkO7VhSqaW3pquL78Oqckfjur3b5XJsqxol4wIYUQNAADU4A9aKvdL3oAlf1CyLMnpkFJchlLdYgoWUE/2HAnq0n8Va3g7l966KU1OR83fLcMwNKStS6smZ+iXr5Vp2qIKZSYZun1UcpQqRiQR1AAASFD+oKV9R0P65ydeFVVYKvFaCv7/9u48Pory/gP4Z2b2zkUOSEJIOMMRriBKBeUQlFNQUbyvVinerQhaqgKKFrVoqaUqtVZqbRVEURSQQzxQETxIUIEQbggBEkKu3c0eM8/vjzX5GeRIstfs7uf9euUF2ezMPrM7M/t8n+P7aIAiA0YFMCoSZAmQAKjC93yX1xe4mQ1AgllCgkXCPYMtyEiQGMARNdP05U4kWSQsufWXQdrPpcbJePOWeAzuVId73nYg2Sbht4MsISwphQMDNaIgEMJXmXG4BdwqoAnAqwloGiBJgEGWYDL4WqdtJl+LGRFRsGmawOFqgfmf1KHcrsGtAslWCck2CZ1SZcSbpDNWFuvV3+NqXQJVdQKPfehEVZ1AokVCZoKMh0daYDLwvkZ0JgWHvHirwI3XbohrcmbHuwdbUFar4d63HRjU0YBemazKRzN+ukQtpGoCFQ6B8lqBVze5YHcLODwCdR7f340KYDJIMMi+1mj5p38FAE0DvBrgVgXcXt/z480SWlkl3HGBGe1ayTCzkkNEAaBqArvLNfzlkzqccAokWSS0jpfQL8sAq6ll9xlJkmAxAhajhLR432NC+IK2w1UCt/zXjiSrhBkXW5CTLLMxiugkmiZw11IHzu9gwHXnmJq17aOjrPio2Itr/m1HwfREGJvQuEKRiYEaURPtPa7i1W8cqHIKVNcJCABxJgnxZgnxJiDZJiPOJMFsaH4PmSYEal1ApVPD/E/qUOEQUGQgK0nGIyOtiDPzJkxEzVNh1/D46jocrdGQFichu5WMvlkS5CAFTZLka2xqZQV6pMs4bhd4cm0d7C6BDikyZo+xskJJ9JPXvnZj8wEvvpuW2Owhw4os4T83xKHbn6qw8EsX7hnMIZDRioEa0c8I4QvCDlVqeHmjC5V2Nzr+9LcFn9chwWpG+xQZieamDQ9qKlmSkGgBEi0KkOx7zOkRKKnSMGWJHRaDhIxECSecAmk2GY+MsrDCQ0S/IITAnuManlxbB1UVyEmR0a2NAUqI545JkoS0eAlp8TLqPAJ7KzTc/LodOcky5l5q5Vw2iml2l8DDKx2YMsiMPm1bVhXvkKrgwREWPPCuA8NzjcjLUAJcStIDBmoU01RNoLRa4G+f+Xqxal0CFiPQyiojxSajYysFlXt8z+2ZYYCshO5GaDVK6JKmoEuaggqHhrJagcwEGeV2X4WnTYKEx0Zb0crGVTaICDhwQsWjK5ywGCX0aCMjyaqPe4PFKKFHuoLcNBk7jqm47U07nr3MhpQ4fZSPKNSe/bgOtS5g9mj/Mjc+NtqKFds8mPGBA+/dnhCg0pGeMFCjmOJRBQ6e0LBggwsVDg0uL5BklZBik9CtjYJ4MxoNC9JUfbT6pthkpNh8/2+TIKN7G19CgHvediDeLOGpSxmwEcWqSoeGB993wqsK9G5raHJSglAzKBJ6ZRpQ/lMihIxEGU+N53BIii2lVRqeWe/EoyOtaO3n4tWyLGHuOCtGL6zF1we8OC+H1fpow0+UopoQAkeqBZ79pA7ltT9lOLNJSLPJaJ/c8on04SbLEtq1kpCVJOFojcDdSx1oHS/j6QlWJiEhihEeVeAP7ztxpFpD93QFbeKliEjakRYv48JOEvYe940O6NJaxuNjrBFRdiJ/zVzlRGqcjN8NDcy8spHdjRiQo2DuOife+Q171aJN1DbBr1u3Dueeey4sFguysrIwY8YMeL1ev7dbtGgRJEn6xc/rr78ezMOhZvCoAsVlKu5Zasf1r9kxc5UTFgPQL8uAYV2M6NvWgKxWcsQGaT8nSRIyEmUM7mSAxQj8+n92PLHaGe5iEVEQCeFLh3/Lf+2QJeDCTgakJ0RWZkVFltCltYKBHQyocAjc+l87jtVo4S4WUVD9UOrFvza5MPdSKyzGwFyvkiThwRFWvPu9B7vL1YDsk/QjKnvUCgsLMW7cOEyePBmvvfYatm/fjttuuw1OpxPz588PyHb79u2D2Wxu+L1Vq1bBORhqElUTOHBCw3Of1KG8ViAtXkJ6goxeGbGxAKssS+iUqiAzQUbhYS/uXuqbAxKoLwIi0ofDVRpmvO+AzSThVzmROyqgnsUooW9bA044NEx914HMRBnPTGDvGkWnP6+vQ+9MBdf2a146/rO5vLcR7ZNlPP9ZHf46MS6g+6bwispAbd68eejSpQsWLFgAAMjLy0NJSQmmT5+OWbNmITk52e/t0tPTYbE0r9u6urq60e9ms7lRsEfNI4TA3uManllfhyqnQLJNQkaCjJ7psRGcnYrVJOFX7Q3Yf0LDr/9nR16GgkdH+TdZmVrG5XLB5XI1/F5TUwOA9wFqGU0TeHC5E0drNPRuq6CVThKFBEqyTcYFHSVsO6LijiUO/P0qW0Az64bL6e4DFHuO2zUs3uLG3660BbyOosgSfjfEgkdWOjB7tBXJnLMeNaLyk9ywYQPGjh3b6LFx48bB7XZj8+bNAdkuLy8P6enpGDx4MJYsWdKkcmVnZyMpKanhZ+7cuU08Ivq5KqeGB99z4Mb/2PHM+jrkJMsY2sWA/CwDMhLlmA3S6kmShA4pCs7vYMC+Cg13LLHD4RbhLlbMmTt3bqPrPS8vDwDvA9R8R6o13Po/O7wacEFHQ9QFafUUWUKvTAVJFglTljjgVSP/vnW6+wDFnn9vdsFskHD9OcFpmLvtfDOMioQXPned/ckUMaKyR620tBSZmZmNHsvIyAAAHD582K/tunXrhkWLFqF3797wer14//33cf3116O4uBgPP/zwGct18OBBJCYmNvzOVvSmUzWBx1fX4cAJFarmWwh6YAcDTEyccVpWo4QBOQoOVWm47Q07nr3chrZJ0VnB06MZM2Zg6tSpDb+XlJQgLy+P9wFqMlUTmPaeE+W10dmLdiqS5Ju7JpWrmLLEgYVXR3bP2unuAxRbNE3gpS9duPk8E+LMwTmfEywS7rzAjAWf1+HBEVxrNVpEZaB2KvXj3Zs77v3k7QYOHIiBAwc2/H3AgAFwOBx46qmn8OCDD8JoNJ52X4mJiY0qaHR2TrfAo6ucKKnU0DpeQq8MAxJ0mnpajyRJQnYrBclWGdPec6BnhoKHR3IoZCicPKSxfsgj7wPUFMftGu5f5svmekFHQ8yNFOicpkCSVPz2p2AtUiudp7sPUGz5eJcXxWUalv0muA1zUwaZ8dRHdXjvew+uyg/sPDgKj6hsnsvMzERpaWmjx+p/P7nHLBDbDRw4ELW1tSgrK2tpkekkmiYw430HfvOGHQbZl9WsVyaDtJaKN/vmru04qmLG+w4IEflDioii1cyVTtz7tgN56Qq6tVFiLkir1ylVQXq8bxikqvGeRZHrxS/qMLiTAT0zg9s/0j5FwdX5Jjy8IjqGDlOUBmqDBw/GqlWrGj22cuVKmEwmDBgwIODbffvtt7BarUhLS/Ov4AQA2Htcxc3/tcPhEbiwkwGdUpWIbU3VE6tRwqCOBhx3CPzuHQZrRHrjVQXufduOw9UaBnUwICUuKr+im6VjqoJkq4T7lznCXRSiFqmwa1j+gweTB4ZmmPuT46zYWaZhbZEnJK9HwRWV3wLTpk1DcXEx7rvvPmzfvh3Lli3DzJkzceeddzZkbly2bBm6d++OkpKSZm03e/ZsrFixAsXFxdi2bRuefvppPPvss7jvvvtgMrGb2R8llRp+/b9aPLm2Dv2yDOiZYWCAFmCKLKF/OwUAcOdbbHEj0ouyWl/CEItBwnnZCuff/kzX1jJqXQJzuEYkRaC3CtwwKsAVfUJTR+ycpmBoZwMWbXaH5PUouKJyjlrfvn2xYsUKPPTQQ1i4cCFSUlIwZcoUPPHEEw3PqaqqQlFRETweT7O2q66uxr333ovS0lKYzWbk5ubipZdewq233hrKQ4wqDrfA1HcdqPMI9EhXmFY2yCRJQs8MBbvLtaiYrE8U6WavcmJnmYq+bXn/OxVJktA3y4Cv9nnh9goGsRRR/vutG5f1MiE+SElETuXWAWZMWWJHhV1jz3yEkwTHPwVddXU1kpKSUFVVxSQCJ/nTWie+P6yia2sFbZMk3S1yqqluHF3/HAAgffhUyEp09ZruKldRbhd4cZINZlZ+gurQoUPIzs7mfYAaaJrAA+85UenU0L8ds9ieze5yFS4vMH+iLdxFaTHeB2LL/goVHR6vwgeT4zGuZ+jqD7UugYxHT+Dp8TbcPbh5a/5SaDQ1NmCYTWGhaQLT3nVgx1EVA9obkNVK1l2QFgu6pClomyjhtjfsqK5jmw1RqLi8ApMX++aK/qo9g7Sm6Jgio6xWQ6VDC3dRiJpk8RY3UuMkjOx++ozgwRBvljAp34R/beKaapGOgRqFXE2dwK/f8C3eOqiDAXEmVlDCKSdZQV66gjuW2FFWywoQUbBVOX1rG7ZNlJCXYYDMRqomkWXfGmuPruRcNYoMSwrcuLKPKSzz7W8/34zvDqn47qA35K9NgcNAjULqSLWG3y62o0uagryM2E07rTdp8TL6ZSm4720HjlQzWCMKlkOVGu5Y4ku9n52shLs4ESczUUK5XaDOwxEApG+7y1V8e1DF1f3CM2ViUEcDemcq+PP6urC8PgUGAzUKmT+tceL+ZQ70zzYgPYGnnt4kWWX0zzZg6rsOONysBBEF2uxVTjy03IHzcgxIi+c9sCVkSUJ2KxmPfcheNdK3twrcaB0vYWjn8OTtkyQJ9w+zYNn3btS6+J0eqfhNQSHx2IdObDuq4vz2BiRy0WrdSrRI6NpawV1v2eFh6n6igNA0gfuXObD/hIqBHQwhzf4Wjdq1knGwkj3/pG8rtnkwvqcxrFmVx/c0wqMCH27nmmqRioEaBd1jHzqxq8wXpFk5H0332ibJyEiUcddbDqgagzUif9hdAre9aYcQYNKQALEYJSiyb64fkR5VOjRs3OfF6B7hzRSdFi9jaBcD3i7kmmqRioEaBdWTa5woLlNZQYkwnVIVJFokBmtEfiit0jB5sR0dUn6ak8ukIQHTOl7m3BvSrVXbPZAAXNw1/MsVX9nHhA+2ueHklIaIxECNguZwlYYfj6gYkMMgLRJ1bS0jwSxh8mIH3F7e4Ima4/EPnXjgPQf6tzMgM5FftYHWyiJxSRHSrXe/92BYF4MuFrC/sq8JdjewegeHP0ai8J9BFJVq6gQeeNeBc7MNsBgZpEUiSZLQtY1vnbXb37QzwQhRE81434Hd5b75aAmckxsUCQzUSKfqPAIrt7txRZ/wDnusl5EoY0gnA5Zy+GNEYqBGASeEwO+XOdAjXeGk+SiQk6ygc5qC3y5msEZ0JkL4koaU2wXO72CAmSMJgsZqlODi8lCkQ+uLPah1AZf10kegBgATehmxcrsHXiYJizgM1CjgHl3phNnga8Wh6JCZKCO3tYIpi+0c5050Cm6vwB1LHPCoAv2zFShcI5IoJi3b6sGAHAVZrfRTBxrfy4QTDoEv97F1I9Lo5yyiqFDl1LDnuIaeGVzINdpkJsoNPWtcbJbo/1XYNfzmDTtS4yT0zmTSEKJY5VUFlv/gxuW99dObBgC5rRV0byPj/R84Ty3SMFCjgJr2nhPd2ygwhnHdEAqetkkyOqX5etYYrFGsE0JgxvsO3PO2A70yFHRIUSAxSCOKWat3eHCsVuDqfvoK1ABfr9oHP3KeWqRhoEYBs/e4Ck1wyGO0y0qS0T7F17PGYZAUq7yqwD1LHTjhFBjcyYCUON73iGLdvza5cFGuAZ3T9DeqaFR3I3Yc03DghBruolAz8JuFAkIIgVmrnMhL19/NiQKvXSsZnVIVTFlih4up+ynG1NQJ3PaGHTaThH5ZnI8WDpomwLed9KTWJfDBjx7cfK453EU5pQs7GWA1AmuYpj+iMFCjgNhzXIPVKDEVdQxpmyQjJ1nGlMV2eJhJimJEaZWGKUvs6NJaQW5rDnUMF5cKmMK/ljBRg/XFHng0YFxPY7iLckpmg4RhXYxYU8SEIpGEtzkKiD+trUO3Noz7Y01OsgJNAL9dbMc/ronj3ESKanNWO7H9qIr+7fS7PtqUJfYWb7vw6rgAliS46jyCyx+Qrqz40ZftsXW8futCo7ob8dhqJ1RNcCRAhNDv2UQRo7xWg1cTaGXl6eRPJSlSdUhRkJno61njGi0UjYQQeHC5A8VlKs5vr78gbcoSe8NPIPYTCWpdAglcp5N0QgiBlds9GNtDf0lEfm5kNyNOOAS+OcB5apGCPWrkt8dXO9ExJfrnpt33tgMenH1s99kqOpHUat1UHVIUqBpw11IHXppkg8yWOooSbq/AvW87YJCBgR0MummFDmZAVb9vPd+rat3A5IH6nAtEseeHUhWHKjXdDnus1z1dRnYrGat3ePCrDgwBIgE/JfKLVxUoqxXIS9dH5SVQ6isqRnjwcHJw9l1Pz5Wh5uicpmD7URV3L3Xg71cxWKPIV+nQcM/bDuQky+igg8aoUPd2TVli1+39qbpOID2B9xjSh5XbPEhP8CUX0jNJkjCyuxFrijyYOdoa7uJQEzBQI78Ul2loHS9FRaU8XEN+fv66eq0UNVX3NjJ2HNNwx1sOvDjJppveB6LmemK1Ez8eUdG7rYK0MKfeD+dwRD0Ga5oQsLsFUmy8v5A+rNjmwZgexoioC43qbsSizS5UOTUkccqK7vETIr/M/7QObZMi+zTS07yMQM01CRdJktAjXUGSRcKUxQ7OWaOII4TAQ8sd2Fmm4vwOhrAGaXq5F+ihDD93wiGQbJWYcZN04YRDw5f7vBibp+/5afVG5BogBLC+mNkfI0Fk17AprLyqQHWd7wszEumlEnQ6ei/fmeS2VpASJ+GOJQzWKHK4vQJ3LHGgxiUwsIMBVmN47m16vPb1VJ4jNRruGcz5aaQPa4t8c9dHdouMQWopcTLOy1GwmuupRYTIOKtIlw5Vaki2RV6rpp4qHE0RqUMju6Qp2COp+O1iOxYydT/pXHmtht8v881Ha58sh+W+Fmn3pnAQQuBYjUBua33PBaLYsXKbBxd2NETUMMKR3Yz4zzduCCEirg4XayLnrCLd+etnLl2vF3IqkV4R0mNL+5l0SlWQnsBFsUnfZq9y4r53HOidqaBDSugXsY6U61oPZTxuF0iySjBxDTXSAU0TWLXdg7F5+s72eLJR3Y3YV6FhV7kW7qLQWURWLZt0pcKuITWCJnProZIRKJFSsQOAjqkK2iTIuHOJA6rGYI30Q9UE7nvbjoOVGgZ1MCDZFvqvxEi5jvXiQKWGh0ZYwl0MIgDAt4dUHKsVEReoDWhvQKJFwhoOf9Q9Dn2kFtE0AbcKWMI0h6M5orkiFAnrHQG+njWvquKun7JBRkJmLIpuFXbfUMc28TJ65oR+qGM035eCxe31zYvukMI2ZtKHlds8yEmW0TMjsobiGhUJF3UxYN1OD+4ezIYPPWOgRi1SbheIN+u/sh0rlaFICNhyW/tS99+11IEXuM4ahdHsVU4UHVPRp62C1BBndYyVe1Iw7D+hISdM8weJTmXFNjfG9jBG5Dl5cTcjHlnhhKoJLqWjY2yWohYpq9WQoPNALRYrRHo+ZkmS0L2NDKtRwp1vOaBxGCSFmKYJ/P4dBw6cUDGoo4FBWguE6xg0IXCoUsNsLtJLOnG0RsPXB9SIG/ZYb0SuEVV1At8eVMNdFDoDBmrUIq9udiOO2ZF1Sc/z1+qDtTiThLuWOiAEgzUKDYdb4PbFDgC++RnmECaj0PM1GSmO1QikxEkRMdyeYsPq7R6YDcDw3MgM1Lqny2ibJOGjnZynpmcM1KhF7C6BeJN+vzBZKdLveyBJErq1kWExAHcvZc8aBd+BEypuf9OO7FYy8jIUyCEcpqTX6zDS7K1Q8ehI9qaRfny8y4NBHQ2I0/nootORJAkXdzViLQM1XWOgRi3i8IiwLQZ7NqwY/T+9tuRLkoQe6QqMCnDv2+xZo+DQNIEH3nXgkRVOnJdtQFZS6L7y9HrtRaITDg2SJCEjkVUW0o/PdnsxpFNkp3q4pJsRX+zxwu7id7Be8a5HLeL2AmYd3p9YMTo1Pb4vkiQhL12BJAH3L3OGuzgUZSodGn79hh2aAAZ1CG2rtx6vt0i245iKOWPYm0b6cfCEij3HNQzuHJnDHutd3NUItwp8tpu9anrFQI2arb73IxKzHMUyPbbwS5KEXpkKat0CD3/gCHdxKEo89qETd77lQLfWCnqkKyHLMKrHayzSVdg1GGQJWa1YXSH9WFvkhcUIXNBRhy3WzZCRKKNvWwVrihio6RXvfNRsbhUw6PDMYQWpafT2PsmShHOyFBys1PD4h+xZo5arX8B6f4Uvq2NafGiHOlLgFZdrmDmK6zyRvqwt8mBIJ0NUJLe5pJsRa4q84S4GnYYOq9ukd3UeAWNkre1IJ9FbpdKgSDgvx4Adx1Qcq9HCXRyKQJUODb/+nx0mg4RfhTCrY6z1ooVyrcbjdt+9IDuZXzikH5omsG6nB5d0i+xhj/VGdjdi2xEVJZX87tUjBmrUbC6vr2KtJ7FUUQoUvVUwzQYJ/bIU3L/MAbeXE5up6Z5c4xvq2L2Ngq6tlZANy9bT9RNthBAoOqbiibGcm0b6UlCiotwuMLJ7dARqF3Y0wGL09RKS/jBQo2bT69BHahk9VTaTrDJykmX8fhnnq9HZaZrAtPccKDqm4vwOHOoYTY7WCJgNEjJDmKmTqCnWFnmQniChd2Z09PRaTRIGdzJwnppO8Q5IzaZqAiGam98krDD5T0/vYYcUGR4VeHQlgzU6vRM/ZXX0qgIDOxhCtlyI3nqio5Gq+XrTnpnA3jTSn7U7Pbi4qzGqEqqN7GbEup0ermuqQwzUqNlUDboK1Cgw9FL5lCQJ+VkK9h7XcPCEGu7ikA499qETd73lQLc2CvIyDFBCmNWRgm9vhYb0BBlJVlZRSF8cboENu70YGSXz0+qN7G5EWa1A4WF+5+oN74LUbKoAoqghiX5GLxVRoyLhnHYGPPS+E3UetvCRj0c9KatjHIc6hlIoEom4vQIHT2h4ajx700h/Nuz2wK0CF0dZoNY7U0F6goQ1Ozj8UW8YqFGzCQHoJU5j5Snw9PKexpsldE6V8bt3HA1r91HsqrD7sjpajczqGM12lqnolCrDFKLPl6g51u70omeGgrZRNndSkiRc0s2ItTsZqOlNdJ1pFEL8Eo1meqmYtvtpkduZK7m+Wix7co0Tdy91oFeGgs5pzOoYrWrqBCocAnOY6ZF06qOdHozoGtmLXJ/OJV2N2LDbC6ebDaN6wkCNms1XR+KFHO30UEmVJAl92irYfVxrWFOJYocQjbM6pnCoY9gEe9ijEAI/HPHiyXFWyJwETTpUXquhoETFiK7RNeyx3rBcA9wqsPkAF7/WEwZq1GwSACYGig16qKwaFQk90hU8yl61mFLnEZi82AGXR2BQCLM6Avo472PNwUoNVqOE9inRkfKcos8nu7yQJWBo5+jsUctJVtA+WcZnuxmo6QkDNWo2vSQSYWUqNPTwPreOk3DCIeDgkIyYUF6r4bY37MhMkNC7rSFkPSycjxYeTo/A7nINz15mC3dRiE7ro50enJejRHU20qFdDPh0N+ep6Un0nm0UNLLkSyhCsSPclVdZlpDbWsED73JttWj35Bon7n3bgT5tFWQnh653JdznuJ4Fc9ijEALfH1bRI12B1aSTVkCiU/io2BO1wx7rDelsxJd7vXB7WcnTCwZq1GyyBHC2UOwJd0U2K0lCnVdwbbUoNnOlE9uP+uajJds4Hy0WHKzUYDIAM0czgQjp18ETKorLNIzIjfZAzQCnB/juEL9n9YKBGjWbIkvsUaOQkyQJeekKHlnhZLr+KCOEwEPLHThYqWIg56PpSjB709xeDnmkyPDRTi8sRmBQx+icn1avS5qMjEQJn+7i8Ee9YKBGzaZITCYSq8JdqU2yyrCaJDyxpi6s5aDA8aoCdy91oKpOYECOAUaFQVqs+PGIii6tZQ55JN37qNiDCzoaYAlhI1I4SJKE4blGfFTMQE0vGKhRsyly+AM1VrDCJ9zvfdfWCnaVcVhGNHB5BSYvtiPOJKFflgIlhGnZw30eR4Jg9qYdrdHgUoHHx3DII+mbEALriz1RP+yx3sVdjdiwx4s6D1vk9aBZgVpdHVuxSR+BGsWueLMEo0HiXLUIZ3cJTH7TjnZJMnJbh24Ra4BBWri5vQLbjqiYf4UtpJ87UUsUHdNwuEpEfSKRekM6G1DnAQpL+B2rB80K1OLj49GzZ0/ccMMN+POf/4y1a9eirKwsWGXzy7p163DuuefCYrEgKysLM2bMgNd79rUhmrJdS/cdLRRmfYx54a7odkmV8fhqNhxFqiqnht8utqNLWmgzOwLhP3cjRTB707YdVdE5TUaihUEa6d9HOz1Iskjonx0ba/x1SpWRbJPw9cHYqdfqWbNmRV566aUoLCzEG2+8gTfeeKOhJSwjIwP5+fmNfnJzc4NS4KYoLCzEuHHjMHnyZLz22mvYvn07brvtNjidTsyfP9+v7Vq672giSQDjNJqyxB7UytyZJNsk1B0RqHJqUb2mTTSqsGu4520HemUqSItjZsdYc6Rag9sLzBnLIY8UGd4qcGNMD2NIh2aHkyRJODdbwdcHGKjpQbMCtXfffRcAUFVVhcLCQhQUFGDt2rVYsWIFSktLsWrVqobgzWazoU+fPsjPz0e/fv1w++23B7zwpzNv3jx06dIFCxYsAADk5eWhpKQE06dPx6xZs5CcnNzi7Vq6bwCorq5u9LvZbIbZbA7EIYceu9QojCRJQnayjDmr6zDvcn1mjHO5XHC5XA2/19TUAIiy+0AzHbdruPdtB/q2VZh+X8eC1QBT5xHYflTFP66Ji5khj6e7D1BkcLoFvtznxaLrw9MoGS6DOhjw76/dEELEzLWqVy36pkxKSsKQIUMwbNgwbNy4ERMmTMA777yDTz75BIsWLcIVV1wBp9OJr776Ci+++CKmTJkS6HKf0YYNGzB27NhGj40bNw5utxubN2/2a7uW7hsAsrOzkZSU1PAzd+7c5hyWbiiyxDlqBCC8FeCsJBml1ZpuU/XPnTu30fWel5cHIHruA81V8VOQlp/FIC0WCSFQeFhF93QFCTE05PF09wGKDJv2e+FRgcGdojst/8nG9zJhX4WGr/axVy3c/Drz7r33XuTl5TX0tNW76aabsGPHDtx8882orKzEnDlz/HmZZistLUVmZmajxzIyMgAAhw8f9mu7lu4bAA4ePIjExMSG3yO1FZ3p+UkPjIoEq1FCWa1AmwT9VfxmzJiBqVOnNvxeUlKCvLy8qLkPNIfdJXDv2w70aaugVQiHqjJIa75g9abtrdBgMQKzYmxh69PdBygyfLbbi/bJcsjn0oZb/2wDOqXKWL3Dg4EdYyOJil759Y35zTffYNCgQaf8W/fu3fHhhx+ipqYGhYWF/rxMQNR33Ta3C7cp2zV134mJiY1+IrWCJnNKEP1MOCvDreMlPPuxPpOKmM3mRtd7QkICgOi5DzSVwy1wxxI7urVRkMKetJhU4dBwqFLD/Cv0OUw5mE53H6DIsL7Yg+G5sdWbVm9wJwM27GGPWrj59a2ZmpqKHTt2nPbvKSkpuPLKK/H222/78zLNlpmZidLS0kaP1f9+cm9Yc7dr6b6jiYTw9qixAkb1WsfLKLeze1ev6jwCUxbb0aW1goxEBml6F4zetDqPQGGJiucn2kK6mDmRvxxugY37vBgeI2n5Tza4sxEb93nh9vI7Npz8+uacNGkSVqxYgbVr1572OZIk4cCBA/68TLMNHjwYq1atavTYypUrYTKZMGDAAL+2a+m+ownnldLJwlUxjjMBdreAxrG4uuNRBaYssaNTqoJMBmm6F4wgTQiBLSVe5GUoSAlhhk+iQPhyrxduFbioS2wGakM6G+D0AN8yTX9Y+XXnnDlzJjp37owJEyZg+vTpOHLkSKO/FxcX48033zxjJsRgmDZtGoqLi3Hfffdh+/btWLZsGWbOnIk777yzoSzLli1D9+7dUVJS0qztmvKcaCeBSR9JHyRJQoJZQhl71XRF0wTufMuBtokysloxSItV+yo0xJskPDoqtualUXRYX+xB19ahvYfpSZc0GVlJEj7exUAtnPw6+5KSkvD555/jwgsvxLPPPosOHTrgggsuwLXXXosRI0agd+/eOH78OH7zm98EqrxN0rdvX6xYsQJffPEF8vPzcdddd2HKlCmYN29ew3OqqqpQVFQEj8fTrO2a8pxoxx410pMUm4T5n+hznlosEkLgd+84kGCW0DE1dBPwGaS1XDB602pdAgdOaHhWp8tnEJ2Nb35abPamAb6G0OG5Rqwv9pz9yRQ0fs+QTEtLw9q1a7F8+XIsXLgQn376KTZu3AjAlw3x/vvvxwMPPOB3QZvr4osvxrfffnvav99666249dZbm71dU58TzSRwwWv6pXAtgJ0WJ2FXuRby16VT+8P7TrhVoFcme9JilaYJFJR4MXe8FSYDW/Yo8lQ5NXx9QMUDF8V2b/DwXCPuXGpHnUfAYuS1HA4BS2UzYcIETJgwAQBw/PhxGI3GRimoKXoI+II1Ij1IsEiormPTgR48/qETR2o0nN/eELJFUhmk+ScYjSs7jmloHS8jJ8ZSmlP0+Gy3F5oAhnWJzYyP9S7KNaDOA3y1z4thMdy7GE5BafJMTU1lkBbF2KNGeiJLEswGMFgLs2M1GnYcU3FutgGKzCAtEgQjSCu3a6h0avjzhNjuiaDItrbIg37tFLSOj835afXapyjonCZz+GMY+X0GulwubNiwAW+++SY+//xzVFVVBaJcpGOSxGQidGrhqji3sko4XMXhj+HidAvcv8yBflkKzCEa6sYgTX80IbD9iIp5l9kghyhYJwqGtUUeXBKjaflP5punxoQi4eJXn+6BAwcwevRoFBUVNXo8JycH/fr1Q35+fsNPTk6OXwUl/QjVkCaipkqyyHh5o4uJC8LAqwrc+ZYdua0VJFlju/U5kgSjN21PuYaUOAlpMd4LQZHt4AkVO45pWNCdgRoADM814NVNLtS6BOLNrP+Fml+B2sMPP4yioiL88Y9/RL9+/XDVVVchNzcXFRUVePfdd/Hee+81PFdVVb8LS0R0KklWCSXV7FELh98vcyAtXkbbJCYPiRTBCNJOODQcrtaw6PrQJxQiCqS1RV5YjMAFHWN7flq9i3KN8GrA53s8GN3DFO7ixBy/vlk/++wzjBw5EnPmzMHEiRMBADfccANKS0vx6quvIj4+HuPGjcOUKVMCUljSB8Fxj6QzNhNgd/G8DLVHVzjg8gK5aQzSYplHFSg8rGL+FTYYFLa4U2RbU+TB0M5GZjn8SXqCjF6ZCoc/holf367Hjh1Dfn5+o8eEEDAYDLjlllvwwQcfYP369bjnnnv8eRnSGQ59pDMJR0ValiQoMuDyMlgLlSPVGvYc15CfpTDDYwQJRm/aj0dUdEyROeSRIp6mCXy004NLurE37eeG5xrw0U4mFAkHv+6q6enpqK2tbfg9Li4O1dXVDb8PHjwYF110EWbPnu3PyxARnVW8WcJxOwO1UKjzCDzwrgP92hlgDFEPCoM0/wUjSCup0uD2Ak+MY5ZHinwFJSrK7QKXdOP8tJ8bnmvElhIVFXZOMQg1vwK1Xr16Yffu3Q2/d+jQAdu3b2/0nLy8PHz88cf+vAwR0VnFmSRUOPglEmxCCNz7tgOd0mQkWti7HsuO2zXsKlPxtyttHGlBUWHdTg/axEvonck1AH9uaGcDJACf7ubwx1DzK1AbPXo0Pv7444ZetYsvvhjr16/Hjh07Gp5TWFgIr5cfLBEFl80E/HuzO9zFiHqPrnTCIAPZrUJXkWFvmv8C3ZvmUQW2Hlax4CobrCYGaRQdPi72YniukQ0PJ2llk3FOO4XrqYWBX4HanXfeiY0bN8Lt9lWOpk6dCpPJhKFDh+K3v/0txowZg7Vr12Lo0KEBKSzphyz5xnIT6YXNKMHh4TkZTOW1vnlpvULY2swgzX/BGPL4famKLmkykm2cl0bRwaMKbNjjwUW5nJ92KlxPLTz8usMqioL8/HykpKQAALKzs7FixQpYrVb885//xOrVq9GvXz8sWLAgIIUl/TAqgJsrLpCOWI0SnGzsCxpV8y1q3betwnlpMe5wlQZVAx4fy3lpFD2+OeCF3e1LR0+/NDzXgG1HVBzhUjghFfBmg8GDB2Pv3r0oKiqC2WxGx44dA/0SpAOKLEFl5wXpiMXoS3JBwTHtPSfaJLAHJdIEujfN6REoOqbileviODyMosrHu7zISpLQJYTLjUSSCzsZYVSAj4s9uK6/OdzFiRlBORslSUL37t0ZpEUxgwx4GamRjsiSBCG4zl8wHK7SUF6rcb20CBPoIE0IgYISL/IyFNg4L42izNoiD0Z05fy004kzSzi/vYHDH0PM7x61l19+GR999BFcLhc6deqEvn37om/fvujZsycMBo7zjVYmBfBw6CPpjEH2Dck189YTMKom8OByB/KzDJBlDnmMZfsqNMSbJDw6ikMeKbrUugS+2OvF5IGBn88ZTYbnGrBosxtCCAa0IeJXdeaPf/wjnn76aQghIMsyNM03blWSJBgMBvTo0QP5+fnIz8/H73//+0CUl3TCZJDgYqBGOmM2Sqh1CZgN/AIJlAeXO5GewFT8kSbQvWm1LoEDJzS8ej0rshR9PtnlgUcFLu7K+WlnMrK7EY+trsOucg25rbmEQSj4NY7ltddeQ1ZWFrZv3w6Px4Pdu3fj7bffxiOPPIJRo0ahoqICr732Gh544IFAlZd0wmwAXF4OMSN9MSuAw83zMlCOVGs4WsMhj5Em0EGaJgQKD3vxp0utMLERhKLQmh0enNNOQZsEzk87kwE5BiRaJKzZwcxdoeJXj1pVVRXuuOMOdOvWDQDQsWNHdOzYEVdccUXDcyoqKrBlyxb/Skm6c+sAM174vC7cxSBqxKiAmR8DRNUEpr/ny/IYqiGP5L9gpOLfe1xDkkVC+xS2oFN0Wr3Dg4l9TOEuhu4ZFAkjuhqwpsiDuwdbwl2cmOBX00G/fv1QXl5+xuekpKRgxIgR/rwM6VCSlanQSX8MioQ69vQGxEPvO9E6XkaSlb1psazWJXCoUsO8y2zhLgpRUOw7rmJnmYZR3TnssSlGdjNifbEHHiaUC4lmfQOfOHGi0e+///3vsXLlyl88TtEv2SrBziFmpDMGGXAzIZXfymo1lFZpyG3NYUCRJBhDHgtKvHhqPIc8UvRaU+RBnAkY2JFZqJpiZDcjal3AV/v4ZRsKzfoWTk1NRU5ODsaPH49HH30UmqZh0KBBuOKKK3D06NFglZF0yGSQoGpMhU76okjA0kJ3uIsR0YTwDXnsnalACeGQR/am+ScYQx53l2tIjZORncwhjxS91hR5MKyLkUmomqhTmoLOaTLWFHFYVSg0q/ng5ptvRmFhIdauXYsVK1Y0pOYUQiA3Nxdjx47FRRddhPz8fPTp0wdWK1P4RjOrEXB4gDgO6yadkCUuG+GvmaucsJkkpMSxNy1SBCNIq3JqKK3WsIhZHimKeVWBdUVezBnL+mpzjOpuxOodHswZG+6SRL9mBWqLFi0CAHi9Xmzbtg0FBQUNP1u3bsWSJUuwZMkSSJIEWZaRm5uL/Px89OvXD9OnTw9G+SmM4swSHG6BOC58SjohSRIE2MvbUi6vwK4yDYNCPASIvWn64lEFCkpUPHeFDQaF93eKXl8f8KKqTmBkN85Pa46R3Yx48QsXjtt9ve4UPC36NjYYDOjTpw/69OmDm2++ueHxgwcPNgRuhYWFKCgowOLFi7F48WIGalHIIEth6b1YeHUcK3Y6FozW/abiUFz/PLjcgQ4pMocARZBgXG8/lKponyIjnanKKcqt3uFB+2QZXdvwXG+Oi3KNkCXgo50eXN3PHO7iRLWANptmZ2cjOzsb48ePb3ispqYGW7duDeTLkE78+lcm/Hsz5wORfmjCN/yRmq+8VsNxu0CPTqGdj8RGl5YLRpB2sFKFVwOeHMehYBT91hR5MbK7sWEqDzVNokXCwA4GrCnyMlALsoA1IZSWluLAgQNwuxtX3BMSEnDBBRcE6mVIRzISZFTXsQeD9EMVwKR8TppsiT+870SPdAUyKywRIRhBWnWdwJ5yDc9PtLHiSlGv0qFh034v0/K30MhuRqzZ4eFIliDzK1BTVRWzZs1Cq1at0K5dO3Ts2BEJCQkYPnw4Fi9eHKgykk6lxkmodfECJf3wqoCF37nN9uQaJyABreM5/CcSBCNIUzVfKv55l9lg5bxjigEfFfvSyw/PZVr+lhjZzYiDlRqKjmnhLkpU8+tbefr06ZgzZw5UVcX48eNxyy23YPDgwdi0aROuv/56DBkyBKWlpYEqK+mMIks/rVsV+mAtnPOg6PTC/bm4VAGrkZXM5tA0gR1HVeSlhz4FO4c9Nl+wrrEfjqjISpKRmcRgnWLDmh0eDMhRkGzjOd8S5+YoaGWVsGYH0/QHk1/NCP/973/Rtm1bbN68GW3btm14vKamBi+++CIef/xxDBkyBJs2bUJKSorfhSX9aWWVUOkUaJPAyjGFX50HSDDzXGyOmaucaGWTEM/3LWYdrtLg8gALruS8NIoNQgis3uHBrQM4VL6lFFnCxV0NWFPkwX1DLeEuTtTyqxmhuroaV111VaMgDfDNS3vwwQfx4YcfYv/+/Xjsscf8KiTp128HmXHcweGPFP7eNABwegRaWRlwNJVHFdhdrqFray5oHAmCcY053AJFx1Q8fyXnpVHsKC7TsP+EhpGcn+aXkd2N+HiXB64wjKyKFX4Fah06dIDL5Trt3y+88EJMmDABb7/9tj8vQzrWJU1BWW14xifrITAg/RBCQNUAE1PLN9kjK5zISgpPOn4Oe2yeYNzvNE1gyyEvemcqsHFeGsWQ1Ts8SLJIGJDD+Wn+uKSrEQ43sHGvN9xFiVp+BWqTJk3CW2+9hfLy8tM+p0uXLjhx4oQ/L0M6ZjVJkBCeeWqkH3oImp0ewMrG0SbzqAIHTmjomMr5GXoXrOurqMy3WO0fR3LII8WW1Ts8GNHVwAXd/dQhVUHX1jLWFHGeWrD49Q3duXNnpKam4pJLLsHOnTtP+ZwNGzagV69e/rwM6VxqnMThjxR21XUCCRZ+6TbVoyt9vWlGVlR0LVhBWmm1hkqnhnmXMUij2OLyCny8y8O0/AEysruRgVoQ+dXn++tf/xqSJEEIgd69e2PMmDG45JJLkJOTg6qqKrzxxhvYunUrVqxYEajykg7dN8SCZz+uQ2Zi6FvmF14dxyFUYaaH3jQAqKoTuO18LrzZFKomsL9CwwUdOexHz4J1bdW6fPPSXr4mDjJXiKcY8+VeLxxuMFALkJHdjPj75y6U1Wpc4iUI/PqWfu2111BYWIiCggIUFhZi+fLlWL58eaMJycOGDcOmTZvgdDrRp08fZGZm+l1o0pf2KTIqHAKaEFwsN8boJUgDgAqHhuxW/JJoisdX16F1vMT5fDFI1QS+O+TF0+OtiGOmT4pBq3d40K2NjPYpTKIUCMO6GKFIwPqdHlxzDhtLA82vQO3GG2/EjTfe2PD74cOHUVBQ0BC4FRQU4NNPP8XHH3/cELylpKSgb9++WLdunX8lJ91QZAmtrBIqHAJpcaH/4mevGqmaQJ0HXA+nifYeV9Evi71pehaMRhAhBLYeVpHdSkZ2MiupFJtW7/BgZDf2pgVKgkXC+R0MWLvTy0AtCJr1TX3ixAkkJyef9u9t27ZF27ZtMXbs2IbHHA4HCgsLGwK3LVu24Kuvvmp5iUmX7hlsxssb3UjTTwcLBZmeetPK7eFpJIhEpVUajIrE3hQdC9a1VVIloAngT5dyXhrFpqM1GgpKVDwxltdAIF3c1Yh/bXJBCMFlPgKsWYFaamoq2rVrh/z8fOTn56Nv377Iz89H586dT7uNzWbDwIEDMXDgwIbHhGDiiWjTKbU+TX94WmnZqxZaegrSAOBQpYaHR3LBzab401on2iez51GvgnVt1XkEistUvHJdHCtSFLPWFnlgUnzD9ShwLulmwOwPndhdrqEL1+UMqGYFajfffDMKCwuxZs0afPDBBw03+/j4ePTp06chcMvPz0fv3r1hNp+6C5RfEtHHapJgVAC7WyCO6/FENb0FaS6vQK1LcH5aE3hVgXK7QM8MXqN6FKxrSwiBwsMquqdzvTSKbat3eHBhJwNHFATYeTkGJJh9gTADtcBqVqC2aNEiAIDX68W2bdsa5qMVFBRg69at+OKLLwD4AjFZltG1a1fk5+ejX79+mDZtWsALT/qSniDjWI2GjqnsVYtWegvSAGD/CQ05yTIbgJqguExD63iJmf50KJjX1r4KDRYjMGs0h3tR7NI0gdU7PJg+nKMvAs2oSBjR1YjVOzy480K+v4HUotnkBoMBffr0QZ8+fXDzzTc3PH7w4MFfJBN588038eabbzJQiwHThlvwh/ed6Jga7pJQMOgxSNM0gZJKDYtu0F/Z9Ojvn4dnGQ06s2BeW1VODQdOaHj1el4jFNu+O6SirFZgTA8OewyG0d2NmLbcAbdXMKNwAAU07Vd2djays7Mxfvz4hsdqamqwdevWQL4M6VRanASnR8CjirAtosteteDQY5AGACXVvh4iM78UmqSmTqBra75XehLMa8ujChSUqHjuChsrThTzVm33ICtJQs8MDs0LhlHdjbjjLd86dcNyGQwHit+BmsvlwubNm1FSUoJ27dqhd+/eSEpKavh7QkICLrjgAn9fhiKAJEm+4Y+1AllJrBREC70GaUII7CnX8MIkW7iLEhGcbgGvBliMvDb1IpjXlhC+IK1Tqoz0BPaiEq3a7sHoHiYOkw+SDqkKureR8eEODwO1APLr7n3gwAH069cPw4YNww033IChQ4ciJSUFHTt2xMSJE/H4449j+fLlOHDgQKDKSzp3/zAzjtZoYS2DXgOLSKTn9/JwtUArm4QkKyuhTbHnuIo2Oqqw6/ncCoVgH//eCg0mBZgzjg0ZROW1Gr7a78WleQwggml0DyM+3O4JdzGiil89ag8//DCKiorwxz/+Ef369cNVV12F3NxcVFRU4N1338V7773X8FxVVf0uLOlfuyQZlU4BTQjIbLWKaHquSHtUgZ3HVCy8Rr9l1JuXvnQhPV4/gRoFT4VDw6FKzksjqrdymwdGGbiYC10H1ajuRsz/1IXDVRraJvH7JhD8ehc/++wzjBw5EnPmzMHEiRMBADfccANKS0vx6quvIj4+HuPGjcOUKVMCUljSP1mWkGyVUOEI71p5eg4y9G7h1XG6f/++L1XROU1GooWNAU11wiGQbOP7pQfBvL5cXoHCEhV/nWgL21xhIr35YJsHF+UaEc+0/EE1tLMRFqNvGQQKDL8CtWPHjiE/P7/RY0IIGAwG3HLLLfjggw+wfv163HPPPf68DEWY+4ZYcKQ6vMMfAQZrLREJ79mBEypUDZgzlqnGm0rTBFQNuqu4R8L5FmjBPGZNCGw55EW3NgpS49iaTQQAbq8vLf/4nuxNCzarScLwXCNWbHOHuyhRw687eXp6Ompraxt+j4uLQ3V1dcPvgwcPxkUXXYTZs2f78zIUYTqlyThuD2+PGjVfJFSaK+wa9lVoWHCVjRPCm6G6TsDKOkrYBfsaKzqmIdEiY/YYNmIQ1ft8jxfVdQLjOD8tJMblGbFmhwduL+uBgeBXoNarVy/s3r274fcOHTpg+/btjZ6Tl5eHjz/+2J+XoQhjNkgwGQC7K/wXaSQEH3oQCe9TdZ1A4WEVC660MR1/M5XbhW6H/ETCueevUAwnPlylocqp4bnLGaQR/dwHP7rRK1NBh1Sm5Q+FsT2MqHEBX+z1hrsoUcGvQG306NH4+OOPG3rVLr74Yqxfvx47duxoeE5hYSG8Xn5YsaZNvIxjteEf/gjERkWwpSJhPhrgC/q/PejFX66woZWNQ7qa65WvXLoN1KJdKK6vWpfAzjIVC66Kgyzzcyb6uQ+2eZjtMYQ6pCrIy1CwYhvnqQWCXzWeO++8Exs3boTb7RuLOnXqVJhMJgwdOhS//e1vMWbMGKxduxZDhw4NSGEpckwbbkFZbfh71OpFQjASapHynthdAl8f9OLPl9mQkcggrSWcHgGrjtdPi5RzsblCcVweVeC7Q148M8EGm0m/nzFROBQdVVFcpmEc56eF1NgeRnzwI+epBYJftR5FUZCfn4+UlBQAQHZ2NlasWAGr1Yp//vOfWL16Nfr164cFCxYEpLAUOdLiJNjdAqrGYE2PIuW9sLsENh/wVULbtWKQ1lIuL2DiqJ+QCsU1Vr+odYcUmdcH0Sks+96NNvESBnbwazUqaqbxvYwoOqZhVxmX5vJXwO/sgwcPxt69e7Ft2zbs3r0b33zzDdq1axfolzmrdevW4dxzz4XFYkFWVhZmzJjRpCGYZ9tu0aJFkCTpFz+vv/56MA8n4kiShNbxkq561YDICVCCJVKGOgK+XqBvfupJYyXUPx4dZnw8WaScl00RqmMpLtNgMQBPcFFrolN6u9CNy3uboHBIcEgN6mBAsk3C+z9y+KO/glL7kSQJ3bt3R8eOHYOx+7MqLCzEuHHjcP755+O7777D888/jxdffBHTpk0L2Hb79u1DaWlpw89VV10VrMOJWPcPs+BIjT7mqcW6SArQAKDKqWHTfi96ZigM0gJA0wR0HqcBiI5gLVTHUFqtodyuYf5EBmlEp3LghIpvDqqY2IfDHkPNoEgY08OI9zn80W9R2Rc8b948dOnSpWHIZV5eHkpKSjB9+nTMmjULycnJfm+Xnp4Oi8US/IOJYO2TZVQ4BDRN6GqCe31FasoSe5hLEhqRVvk9btfwfamK+VfY0CaBQRpFjlBda+V2DcVlKv5xTRx7CohOY9lWD1pZJVyUy0AtHMb3NOKm1+2odGhMAuaHqHznNmzYgLFjxzZ6bNy4cXC73di8eXNAtsvLy0N6ejoGDx6MJUuWNKlc1dXVjX5cLlcTjygyybKEFJuECqe+hj/Wi7QAprkirRcNAI7VaPihVMULV0V+kOZyuRpd7zU1NQDCcx+QZQmqPi/DX4i0c7ZeqMrtcAt8/9MyFUweon+nuw9Q8L1d6Mb4nkaYuJxLWIzuboQAsHoHhz/6IyJqQlVVVdixY8cZf36+nltpaSkyMzMb7SMjIwMAcPjw4dO+TlO269atGxYtWoSlS5fi/fffx7Bhw3D99dfjySefPOtxZGdnIykpqeFn7ty5TXsDIthdF5p1N0/t5yK1Ung2kXZcQgjsq1Cx45iKl66Oi4rWt7lz5za63vPy8gCE5z5glH3ZASNFJJ2/oWwQ8ai+eZt92ipRcY3EgtPdByi4jtZo+HyvFxP7mMJdlJjVyiZjSGcD3vuBgZo/ImLo41tvvYXJkyef8Tnt27fHvn37Tvt3SZIa/dtUJ283cOBADBw4sOHvAwYMgMPhwFNPPYUHH3wQRuPpu9gPHjyIxMTEht/NZnOzyhKJOqcqKKvV0CNdvynnFl4dFzXDICOpgltP1QS+L1WhCeBf18VFTevnjBkzMHXq1IbfS0pKkJeXF5b7gNngy/wYSSLhugzl9aYJgS2HVHRMkTHjEi5qHSlOdx+g4Fr+gxtWIzCqO4c9htMVvU14ZKUTLq+AOUq+20MtIprkbr/9dgghzvjz8yAtMzMTpaWljfZR//vJPWY/19LtBg4ciNraWpSVlZ3xOBITExv9xEKgZjVJkCWgzqPv1vxIDHB+LhKHOQK+82LjPi8SzBJenGSLmiAN8AVgP7/eExISAITnPmAzSXDq/Bo8FT2f16Eu146jGuLMwBxmeIwop7sPUHAt/8GDkd2MsHJ4cFhd3tuI6jqB9TvZq9ZSERGoNdfgwYOxatWqRo+tXLkSJpMJAwYMCPh23377LaxWK9LS0vwreJTKSJRRWq3/7I96rhSeTiSWuV5ZrYaN+7zo2lrB0xNsze7tpqabPNCMGlfkBWr19HSOh+OaK6nSUO0S+MvlDNKIzsbuEli304MJvTjsMdyykxUMyFHwzlYGai0VlYHatGnTUFxcjPvuuw/bt2/HsmXLMHPmTNx5550NmRuXLVuG7t27o6SkpFnbzZ49GytWrEBxcTG2bduGp59+Gs8++yzuu+8+mEy8KZzKQyMiK02/niqFpxPJARoA7KtQUXRMxcJr4vDIKA7jCrasJF8G1kimh/M9HGWoqRMoLlPx9yttusqeS6RX63Z64PIC4/I47FEPJvYx4d3v3VC1yP4OCpeImKPWXH379sWKFSvw0EMPYeHChUhJScGUKVPwxBNPNDynqqoKRUVF8Hg8zdquuroa9957L0pLS2E2m5Gbm4uXXnoJt956aygPMaKkxslwewG3V0TM0Lb6Ctk9SyrDW5CT6KGy6g+31zcfTQD457XRMx9N70wGCUbFN9TUYozc9zxcS2uE67rzqALfHfJi3mU2DuEiaqLlP7gxsIMh4jMHR4sr+pjwhw+c+HyPF0O7MHhuLkkIwRA3yKqrq5GUlISqqqpGSQRiyQPvOmA1AjnJ+k0qciqa6sbR9c8BAJ48cQc8CP1NJtKDs3rVdQJbDnnRKU3G42OsMTfU8dChQ8jOzg7bfeD+ZQ4kWiRkJUVP5SXYAVs4rz1NCHx9QEVWkozHx7LXOVqE+z4Q7VRNIHNmJR4YZsFDF/O60YveT1dheK4Bf50YHfWZQGhqbBCVPWqkP3+42IKH3nci59RrjUeE56+0QVZMIWnNj5bgrN7hKg07y1Q8e5kNmVEUKESSqcPMeHx1XVQFasHoYdPLtbftiIoEs8QgjagZNu/3oqxWcH6azkzsY8S/Nrkx/woRc420/mKgRiHROl6GyyMiavjj6ZxckQtEJVEvlcNA0zSBbUdV1Lp9Qx25QG/4tGslw+UVcLhF1H0O/l6Terv+9h5X4fQA/7iGQRpRc7y91YMuaTK6p0dPg1Q0uLKvCY+vrsM3B1Wcl8PQozn4blHIZCTKOFKjRdzwx7PRWyVPL9xegW8PeZFik/HKtbE31FFvJElC2yRfBtbOadF1DZ4skq/JozUaSqo0vHJdHK8ZombQNIElW9y4ZYCJ147O9M5U0DlNxjuFbgZqzcQmBwqZGRdbUFIVOdkfqeVq6nzro+UkK3j2cqbe14s/XmKNiKUyYlWlU8OOoypemBQHo8Jrhqg5Nu7z4mClhmv6cdij3kiShIl9THh7qxtMjdE8DNQoZNLiZWgCqI3g9Zzo7I7bNXxz0Is/X2bDY2M4dEtPEi0SDLIvsQvpi9MtsOWQivkTbYg3M0gjaq43t7jRM0NBr0z22OjRxD4mFJdp2HZEDXdRIgoDNQqpjikK9hznRRqNhBDYc1zFtiMqXpxkQ9soSloRTdqnKNhbwWtQTzyqwNcHvejdVkHreF43RM2lagJvFbhx7TnsTdOrATkK2iZJWFrIxa+bg98IFFIzR1lwwiFQ52GLfjTRNIEfSlWccAj86/o4tLLx1qJXj460oNIh4OQ1qAuqJvDNQS86pyr44yXsgSZqiU93eXG0RnDYo47JsoSr+pqweIuLwx+bgbUpCilZltAhRcbeCs6TiRZ1HoGN+70wGSS8dLWNc2t0TpYldElTUHSMvWrhpmkC3x5SkZEg4zGm4SdqsTe3uNE/W0Fu6+hOlBTpru1nwvajGn4o5fdPUzFQo5B7bIwVR6o1eFS2qES6KqeGjft8vQFMGhI5Zo+xwO0Fk/uEkSZ8QVqyVcLc8bZwF4coYrm9Am8XutmbFgHO72BA+2QZb25xh7soEYOBGoWcQZHQPkXGnuOsJEayozUatpSo+OtEG2aOZm9AJJEkCc9facOuMhUVdl6HoSaEQEGJb0HrP1/GII3IH+t2elDhELg6n4Ga3kmShGv6mfDmd8z+2FQM1CgsnhhrxeEqDW4vL9RII4TA3uMqistULLw6Dm0SeBuJRDaThAVX2VB4WOWc0RASwjef06QAz17OBg4ify3e4sagjga0T+Gwx0hw7Tkm7Dmu4esDHP7YFKxhUVgYFAmdUmXsLOOFGklUTWDrYRUVDoFXrotDgoVDHSNZsk1GXoaCbw95obF1M+iEEPjxiApVAH+dyKHCRP6q8wgs2+rGtRz2GDHysxR0byPjv9+6wl2UiMBAjcJmzlgrTjgEqpwcehUJ6jy+RazjTEwaEk0eHWVFik3GjqO8DoOpIUjTgL9fxSCNKBBWbffA7gYmcdhjxJAkCTedZ8Yb37mZq6AJGKhR2MiyhKcn2PBDqcqxyjpXXSfw1X4vclsreOYyVjKjzbOXWVHtEtjP9dWCpuiYBrcKLGCQRhQwb37nxtAuBmQksjobSW7ob0JZrcDqHVxT7Wx4ZlNYtU2SYTVJOFLDQE2vymo1fHfIi79cYcOjozinJhrJsoSXJtlQWq2huIwNJ4FWXKai1i3wAoM0ooCxuwQ+2MZhj5GofYqCoZ0N+M/XzP54NgzUKOyemWDDjqMqE4vojBACxWUqio6peOnqOKQzaUhUMxkkvHxtHGpdAoWHVagar8dA2F3uWwj+xUk2yDKDNKJAef9HN9xeYGIfBmqR6KbzzHjvBzenv5wFa14UdokWCd3aKPiOCQ10w6MKfHNQhdMj8K/r4pDIpCExQZElvDDJhjiThM0HvJw/4Kfd5SrK7QIvXW2DwiCNKGCEEFj4pQuXdDMiLZ5V2Uh0VV8jJAlYWsjhj2fCs5t0YfYYKxItEorL2LISbrUugS/3epGeIGHBVXEwMGlITJEk39pe2a0UbNznZer+FtpV5gvSFl5t4zVEFGArtnnwyS4v7hlsDndRqIWSrDIu62XCa18z++OZMFAj3Xj2chvK7RqO1jBYC5cj1Rq+PuDFny+z4YlxXIg3lj0+1opubRRsPuDlsORmEEJg2xEVlXUC/7iGQRpRMLzylQvDcw0Ym8dhj5HspnNN+Gy3F/uOM5HV6TBQI91QZAl/vyoO24+qOOFgsBZKqibwQ6kX+ypUvHxtHNom8dZAvtT9ua0VfLXfCyd71s5K0wS2lKhQhcBLkzjckSgYjtZo+OBHD247n71pkW5kdyPaxEv477dMKnI6rI2RrsSbJSy40oaCEpUTTEOkuk7gi71eWAwSXrkuDvFmVi7p/80abUWPdAWb9ntRXcdg7XQ8qsDXB1XEmyU8P5GJQ4iC5fVvXIgzSbiiN3vTIp1RkXDdOSb85xsXsw2fBgM10p2UOBnPX2nDd4dUtuIHkRACu8tVFJR48cwEG9dHo9N6eKQVz11uw5ZDXhw8wSEqJ7O7fYvBZyZKmMfriChohBB45SsXru9vgtXE6ywa3HSeGUXHNHx9gN8tp8JAjXSpdbyMXpkKvmbmuaBwe31ZHWtdAq9ez6GOdHYZiTJeuS4OR2oECg97mb7/JxV2DZv3e/GnS62c10kUZJv2q9h+VOOwxyhyTjsFPdJl/OcbJhU5FdbOSLceHmlFp1QF3xxkpTCQjts1fLHXi7ZJMv4+KQ5GJjugJrIYJfzjGhviTRI+3+NFhT22hycfrFTxwxEVL0yyISdZCXdxiKLeK1+50DtTwTnteL1FC0mScPN5Zrz5nZsN86fAQI107fGxVrSJl7mmUwA4PQIFJV7sOOarWD42xhruIlEEkiQJT0+w4a8Tbdh2VMXOMhVajDWkaEJg2xEvDlcJ/PPaOCTb+FVKFGxVTg3/+86FKYPMHF4cZW7ob0KFQ+Dd77mm2sn47UK69/QErunkD5fXV6nctN+L1vEyFl3PiiX5Ly1exr+ui4OqAZ/vjZ1EIy6vwFf7vJAlCS9fY4PFyAojUSj85xtfZsAbz2USkWiTnazg8t5G/PXTunAXRXdYW6OI8PhYK7q38QVrsT7cqqnsLl/K/Y37vIgzSfjPjXF4bIyVLZEUMAZFwl+usOGZCb5EI3uOq9CiOHNXpVPDl3u96JSq4LkrmNmRKFSEEHjxCxdu6G9GkpVV12h03xALvtjrxbcHveEuiq7wbKeI8cgoK/5+lQ0/HlFRXBbdFUJ/OD0C35d68e0hL5KtMl6/MQ5PXso1nSh42ibJePX6ONR5BD7f4426dRDrM6RuPazi+SttmDmaw4aJQunzPV5sO6LizguYRCRaDelsQN+2CnvVTsJAjSJKSpyvQuhRBb7c60Ul11oD4Fto92iNhq8PePH1AS9aWSS8dkMcHhtrZas/hYTJIGH+xDg8d7mvMWX7UTUqkgDVeQQ2HVDhcPsypLaO59cmUai9+IULA3IU9GtnCHdRKEgkScLvhlrw5hY3jlSzbleP3zgUcQyKr0L49HgbfixVUXjY14JfbtdiasFEIQQqnRp+POLFp7u9OFKjYeYoC/5zYxzmjOOwLAqPNgm+xhSjDHy224v9FZGbbKS0WsPGfV50SJbxt6uYIZUoHI5Ua1ha6MadF1jCXRQKsuvOMaGVVcJLX7BXrR6bJihiZSbJWHRDHGaucmLPcQ1eDdgvA70zFZgM0VmhEkKgrNbXe1ZuF4g3S8hKkjHvMgsrkaQbiizhmctscLgF/viBAxv2eJHbWkFmohQRcyRdXoEfj6jwasDL18Yh3qz/MhNFq79/Xodkq4Rrz2ESkWhnMUqYMsiMF79wYcYlVpijtC7XHAzUKKJJkoQ5Y32LzAohMGtVHb7Y60WHFBk5yXJUzMvSNIFyu0BptYYKh0CyTcLUYRa0T5EZnJGu2Uy+3u8qp4YZHzix97hA77YGJFr0ed4KIXDghIY9xzV0baNg9mhLRASWRNHK4fYlEblvsIUZVmPEnRdY8NS6Oiz+zo2bB3BOIgM1ihqSJOHxsVY43QKPrHTis92+RZ1zkmVYI+gG7/YKVNUJVDgEKhwa6jxAik3CAxdZkJMsw8DgjCJMklXGC5PiUFKp4cHlDrRNktEpVV8NKSccGn48oiLJIuHV6+NYKSTSgX9vdsHuFrjzQlbYY0XbJBnX9DNh/md1uOk8U8w3ljFQo6hjNUl49nIb3F6B2R868c0BL4wGCW0TJbSJl3VTAdOEgNMN1LgEql0CNXUCNS4BRQJaWSVMHmRGTisZrbjmGUWJrFYy/n1DHB5634kNe7zoqoPhkNV1AkXHVHg1gafH25CZxOuNSA80TeAvn9bhlvPMTOITY+4fZsG5z1bjk11eXJRrDHdxwoqBGkUtk0HCny71DYs8VqPhmY/q8M1BLzQBJNsktLJKSDRLiDdLQWvZF0LA5fWlzHe4AbtHwOEWqK4TUDXf0LAEs4Rf/8qE9AQZreODVxYiPTAovoaU6jqBP7zvwO5yga5tFLSJD13AJoTvGtxVrsHpEZg92oqOqXLMt9wS6ckH2zwoLtPw/u1MIhJr+mcbMKyLAc98VMdALdwFIAqFNgky5l3uC9rqPAKHKjW89KULx2o01LoENAGYDYDV6Avc4s0SzAZA+VkWSYdbALLvuUL4/vVqvh+PKuD2Ai7VF5jVeXz/Ar792kwSrEYJtwwwIcUmIy1O0k3PHlE4JFokvDApDuW1Gh5e4cSuMl/AlhYXvIDN5RXYV6HhcJUGm0nCjIst6JzGAI1Ij579uA6X9jSiW7oS7qJQGPxhhAWjF9ai4JAX+TG8LEPsHjnFLItRQpfWCuZdZmt4TAgBuxuodAq89EUdKp0CLq+A5lWR+dNzth9RIRQVsgTIEiABMCiAQZZgUoDr+5sQZ5YQb6oP9sAKINFZpMXLWHhNHI7VaHh0pRM7jgq0T5GRlRSYOWzqT8l4DlX6GmVykn3DL6M1MyxRNPjmgBef7fbi47sTwl0UCpOR3Y3o107BUx/V4c1b4sNdnLBhoEYEX0AVbwbizRKeGPf/AZzbbcTcub7//31SHEwmpgcmCoY2Cb6ArdKh4bHVdfhstxdJVgltE3090M1JolPnESir1XCkRqDWJZAS5+s9a5/C3jOiSPDcJ3U4p52CoV1YTY1VkiThDyMsuO41O54Yq6JL69jsWeUVQEREutHKJuMvV9gaUuU/+3EddhwTMMhAktXXY202SDAqvl5tVfiGNDo9QK3LN/fMpPh66h4bYw17shIiap4DJ1QsKXDjtRvieO3GuCv7mtAp1Yk/r6/Dwmviwl2csGCgRkREuiNJEtqnKHj+St+Xc63Lt9D7Pze6UF0n4NUEBABF8s0n/c2vTEiNY0Ieokj3/GcuZCbKmJTPESyxTpElPDjCgnuWOjB7tDUms/IyUCMiIt3zzftUMHe87exPJqKIVF6r4R9f1mHmKCuMXDOUANx8nhmzVjnxl0/r8MyE2Lv/x15oSkRERES6M3ddHWwmCXdewJT85GM2SJg6zIIXv6jDCYcW7uKEHAM1IiIiIgqrgydU/P3zOjw60oo4M3vT6P9NGWSBUZHw10/rwl2UkGOgRkRERERh9fjqOrRNkjF5oDncRSGdSbBImHaRBc99Uofj9tjqVWOgRkRERERhs/OYilc3u/DYaCvXOKRTum+IBVajhLnrYqtXjYEaEREREYXNoyud6N5GwfX9memRTi3eLGHmKCue/6wOu8vVcBcnZBioEREREVFYfHvQiyUFbjwx1sqlNeiMpgwyI7e1ggeXO8JdlJBhoEZEREREISeEwAPvOnBBRwMu620Md3FI5wyKhOcus+KdrR58UuwJd3FCgoEaEREREYXce9978OluL5673AZJYm8and2oHiaMzTPi/ncd0DQR7uIEHQM1IiIiIgopt1dg+nIHru9vwoD2hnAXhyLIvAk2bD2sYvEWd7iLEnQM1IiIiIgopF78woVDVRrmXmoNd1EowvTIUHDTuSbM+tAJrxrdvWoM1IiIiIgoZCrsGh5b7cTUYRbkJCvhLg5FoFmjrdhXoeEfG13hLkpQRW2gtm7dOpx77rmwWCzIysrCjBkz4PV6z7jNjz/+iEmTJiE3NxeyLOPaa68N2L6JiIiICJizxgmjDPxhBHvTqGU6pir43RALZq5y4oQjehfBjspArbCwEOPGjcP555+P7777Ds8//zxefPFFTJs27YzbORwO5OTkYObMmejbt29A901EREQU64rLVCzY4MIT46xIsDCBCLXcIyMtUCTg4RXOcBclaKJy9ua8efPQpUsXLFiwAACQl5eHkpISTJ8+HbNmzUJycvIptzvvvPNw3nnnAQBeeeWVgO6biIiIKJYJIXDXW3bkZSj4za/M4S4ORbgkq4y/TrThutfsuPYcE4Z0jr4lHqKyR23Dhg0YO3Zso8fGjRsHt9uNzZs3h23f1dXVjX5crugeV0sUy1wuV6PrvaamBgDvA0Sx5HT3gVj1r01urC/24uVr4ri4NQXENf1MGN/TiN+8YUetK/oSi0REoFZVVYUdO3ac8Wf37t0Nzy8tLUVmZmajfWRkZAAADh8+7FdZ/Nl3dnY2kpKSGn7mzp3rV1mISL/mzp3b6HrPy8sDwPsAUSw53X0gFu07ruL+ZXY8cJGF6fgpYCRJwj+uiUOVU+D+ZY5wFyfgIuJKeeuttzB58uQzPqd9+/bYt2/faf9ev5BiMBZUbOq+Dx48iMTExIbfzWZ2+xNFqxkzZmDq1KkNv5eUlCAvL4/3AaIYcrr7QKwRQuD2xXbkJCt4fAwTiFBgZSTKePmaOFzxr1qMyzPi8j6mcBcpYCIiULv99ttx++23N/n5mZmZKC0tbfRY/e8n94Y1lz/7TkxMbFRBI6LoZTabGwVh1dXVAHgfIIolp7sPxJqFX7rwcbEXX92fCIuRQx4p8C7vY8JvfmXC5MV2DOxoQHpCRAwaPKvoOIqTDB48GKtWrWr02MqVK2EymTBgwADd7puIiIgomuwpVzF9uQMPjbDgvJyI6B+gCDX/ijgkWCTc/qYdQkTHfLWoDNSmTZuG4uJi3Hfffdi+fTuWLVuGmTNn4s4772zIyrhs2TJ0794dJSUlDdu53W4UFBSgoKAAtbW1qKysbPjd7XY3ed9EREREsc6rCtzwn1p0TlUwazSHPFJwJVgk/OeGOKza7sH8T6MjUVdUNm307dsXK1aswEMPPYSFCxciJSUFU6ZMwRNPPNHwnKqqKhQVFcHj8TQ8dvjwYfTr16/RvlavXg0A2Lt3Lzp06NCkfRMRERHFutkfOlFwWMW3DyTBbOCQRwq+CzoZ8adxVjy43IFftVcwqGNkp+yPykANAC6++GJ8++23p/37rbfeiltvvbXRYx06dGhSV+nZ9k1EREQUy94pdOPJtXV4+Rob8jKUcBeHYsi0iyz4Yq8XVy+qxZbpSWgdH7kDCCO35ERERESkO98f9uLm/9birgvNuH2gJdzFoRgjyxIWXR8HoyLhutdq4VEjd74aAzUiIiIiCogj1Rouf6UW/bMNmH+FLdzFoRiVbJOx7Dfx+GqfF797xxGxyUUYqBERERGR347bNVzyYg0MMvDWrfEwKpyXRuGT386A/94Uj5e+dGHBhshMLsJAjYiIiIj8Ul0nMGZhDWrqBNbdlYA2UbKOFUW2y3qb8NSlVvx+mQPvfe8Od3GajVcREREREbWYwy1w6T9qcKhSw7q7EpCdzOQhpB/Th1swZZAZ175Wiw27PWffQEcYqBERERFRi7i8Ape/UoPtR1WsuysRXVozSCN9kSQJf7vShkvzjBj/ci0KS7zhLlKTMVAjIiIiomarcmoY/3INNu9XsebOBKbhJ91SZAmv3xSPc3MUXPxCDbYejoxgjYEaERERETXLvuMqBv21Bj+Uqlh/dwL6tYvapXkpSpgNEpbfnoDebRWM+HtkBGsM1IiIiIioyb7a58Wv/lINkwJsnpqEc7IZpFFksJkkfDDZF6xdtKAGX+zR95w1BmpERERE1CT//caFYQuq8av2Bmy4LxHtWrEqSZGlPlgb2sWAES/UYNEm/abu59VFRERERGdUUycwZbEdN75uxz2DLVh2WzzizVwnjSKTzSThrVvjMXWYBb9+w467l9rh9upvUWz2VRMRERHRaa340Y27ljrgcAu8/et4TOxrCneRiPymyBL+dKkN/bMNuOW/tSgsUbH01/HISNRPP5Z+SkJEREREurH3uIrL/lmDS1+uxQUdDdg2I4lBGkWdK/uasOn+RByr1XDOvCps3KufeWsM1IiIiIiogdMt8NiHTuQ9VYXiMhUf3ZWA/90cj9bxrDZSdOqZacDm+xPRP9uAIX+rwexVDl0MheTQRyIiIiKCyyvw2tcuzF1Xh7JaDU+MteK+IRYYFc5Fo+jXyibjvdvisWCDCzNWOPD2Vg/+dV0czssJX7jEQI2IiIgohh2q1PDPjXX4x0YXjtsFbh1gxqzRVrRNYg8axRZZlnDfUAsu7WnE5MV2DHiuGlf2NWLWKCt6tw192MRAjYiIiCjGqJrAh9s9WPilCyu2eZAWJ+E3vzLj3iEWBmgU8zqlKVh3VwLe/9GDR1c60eeZaozpYcSUQWaMzTOGrJeZV2IUcLlcmD17Nlwu/a4DEQ34/gYPz+GWi7b3LpqOJ5qOBeDxRLL6Y3U667Bhtwe/f8eODo9X4dKXa+HwCLx5SzwOzm6FueNtURekxdLnfCqxfPz+HrskSZjQy4Qt0xLxweR4eDWBK/5Vi+zZlXhwuQM7jqoBLvEpyiCECP9MuShXXV2NpKQkVFVVITExMeL2H8vcbjfmzp0LALjnnnuQmpoa5hJFp1g4hw8dOoTs7OyAH2O0vXfRdDzRdCwAjycQgnUfOJ2aOoHvDnnxebEdjzz/FtoNuBKHqoCeGQqu6GPEzeeZkdtaCXo5winaztvmiuXjD8ax769QsWizG69ucmH/CQ192yoYnmvA8K5GDO5kQJK1aQ0dTS0bhz4SERERRSAhBJwe4FiNhv0nNOw9rmFfhYpd5Rq+O+TFjmMahADaxAMwxuGW/jKuOy8ePTNZ/SNqifYpCmaNtuLRkRZ8vMuLD350Y32xF3/51AVZ8jWC9Gn7/z+9Mg3ITJSgyC0bKskrlYiIiCiEdperMDtUeFQBjwrfvxoa/u/yApVOgQqHwAmHhhNOgRMO8f///uwx989GX1mNQIcUGR1TFUzsY8K52Qacl2NAvFSDVq1uwIOvVyExkVU/In/JsoQRXY0Y0dUIACiv1fDpbi++PejF1sMqFmxw4WClBgBQZCAjQULbJBlZSTLaJsmIh6NJr8OrNQTqR5dWV1cHZf/1+w3W/mOZ2+1GXV0dAKCmpgZGozHMJYpOsXAOB+sYo+29i6bjiaZjAXg8gXzNc548BJgSzvhcqwloZZXQyir/9K+EVhYJHVr/9JjN93uyTUKKTUb7ZBlp8RIkSQIgAHh/+gGqq2savX4sibbztrli+fhDeewmAJd09P34yDjhAIqOqjhcraG0WqC0WsORGg1b92ooq/CV6Wwz0DhHLQTqx6QTEREREREBwMGDB9GuXbvT/p2BWghomobDhw8jISHhp5YuIoo1qqpi165d6NKlCxQluifvE9Gp8T5ARICvJ62mpgZt27aFLJ8+AQkDNSIiIiIiIp2JrsUyiIiIiIiIogADNSIiIiIiIp1hoEZERERERKQzDNQixLp163DuuefCYrEgKysLM2bMgNfrDeh233//PeLi4iBJUkNK+mgTzPexpfuONjxXA8fpdGLWrFnIzc2FxWJB586d8cwzz5wxna8QAk899RS6desGq9WKzMxMXHvttdi7d28ISw78+OOPmDRpEnJzcyHLMq699tpTPi8U50sgBOt4Xn31VYwYMQJt2rRBXFwc+vTpgxdeeCFYhwEg+J9NvVBdp8E+nhMnTuB3v/sdsrOzYTKZkJWVhUcffTTQh+GXlhxbqM6DUAjWfWTRokWQJOkXP6+//nowD6fF5fVnO71/zrHyGf+CIN0rKCgQJpNJ3H333eLHH38US5cuFUlJSeJ3v/tdwLarqqoSXbt2FRMmTBAAhNPpDM7BhFEw38eW7jva8FwNrFtuuUVkZmaK9957T+zZs0csXbpUpKWliccee+y02zzzzDPCYrGIf//732Lv3r3iiy++EP379xddu3YNYcmF2Lx5s5g6dap47bXXRH5+vrjmmmt+8ZxQnC+BEqzjueGGG8S8efPEpk2bxO7du8ULL7wgjEaj+POf/xxxx/JzobxOg3k8tbW1olevXuKiiy4SH330kdi7d6/4+uuvxYoVK4J0NM3X0mMLxXkQCsG8j7z66qsCgNi3b58oLS1t+AnH904s12Fi5TM+FQZqEeDGG28UeXl5jR7761//Kkwmk6ioqAjIdldeeaW49957G05YvZyggRTM97Gl+442PFcDx+l0CoPBIBYuXNjo8Xnz5on4+Hhht9tPud2ll14qxowZ0+ixxYsXCwCivLw8aOU9k6FDh56yEhiK8yUYAn08J7v11ltF//79/S5nUwTrWMJ1nQb6eGbNmiVycnJ0fZ8JxHkX7HM6mIJ5H9HT90ws12Fi5TM+FQ59jAAbNmzA2LFjGz02btw4uN1ubN682e/tnnvuOezfvx/z5s0LbMF1JpjvY0v3HW14rgaOx+OBqqqw2WyNHo+Li0NtbS2++eabU243ePBgbNq0CZs2bQIAlJWV4T//+Q8GDRqE1NTUoJe7OYJ9voRaoMpVVVUV9s/Kn2PR43Xa0uNZunQphgwZghkzZiArKwtdunTBb3/7Wxw/fjzYRW6yYF4Per3Wfi4U95G8vDykp6dj8ODBWLJkSeAK3wyxXIeJlc/4VAzhLkAsqqqqQmlp6RmfYzQa0blzZwBAaWkpMjMzG/09IyMDAHD48OHT7qMp233xxReYO3cuNm3aBJPJ1LwDiTDBfB9buu9ow3M1cBISEjBkyBDMnTsX55xzDnr06IGtW7c2VH5LSkpOud306dOhaRouvPBCAIDX68WQIUOwYsWKkJW9qYJ5voRDIMq1YsUKvPfee1i+fHnAy9ccLT0WvV6nLT2e3bt3Y9euXbj88svx7rvv4sSJE5g6dSrGjh2LjRs3nnGh2pYKVR2hKcJxrempjtStWzcsWrQIvXv3htfrxfvvv4/rr78excXFePjhh5t3YH6K5TpMrHzGp8JALQzeeustTJ48+YzPad++Pfbt23fav0uS1Ojfpvr5duXl5bj66qvx0ksvoVOnTs3aT7QIxPsY6H1HG56rLff666/jzjvvRO/evSFJElq1aoXf/e53mDlzJhRFOeU2y5cvx3PPPYcFCxZg0KBBKC0txaOPPorLLrsM69evP+12ehHMazIcmlOujz76CFdffTWefPJJjBs3LthFa7azHUukXadN+Ww0TUNKSgpee+21hsDzX//6F371q1/hyy+/bGgQCaRw1hGaItjXml7qSAAwcOBADBw4sOHvAwYMgMPhwFNPPYUHH3wQRqOxWfsPtFiuw8TKZ8yhj2Fw++23Q/jmB5725+c3oMzMzF+0LtX/fnJLwc+dbbsffvgBhw8fxjXXXAODwQCDwYDbbrsNABAfH48HHnggEIerG8F6H/3Zd7ThuRpY7dq1w/vvvw+Hw4F9+/bhyJEjOOeccwAAXbp0OeU29913HyZPnowpU6agd+/eGDlyJF5//XV89tlnWLt2bSiLf1bBvCbDwZ9yLV++HJdeeinmzJmDP/zhD0ErY1O15Fj0fJ36c6517dq1Ue9g7969ASBomVRDVUdoinBca3qpI53OwIEDUVtbi7KysuYeml9iuQ4TK5/xqTBQiwCDBw/GqlWrGj22cuVKmEwmDBgwoMXbnXfeefj+++9RUFDQ8PP4448DADZv3ozp06cH/mDCKFjvoz/7jjY8V4PDbDajXbt2MBgM+M9//oPc3Fzk5+ef8rkOh+MXvWZ67UUL5jUZDi0t12uvvYZJkybh+eefx9SpU4NdzCZpybHo+Tpt6WczbNgw7Nq1q1E67+3btwOAbnoNg3k96PVa+7lQ30e+/fZbWK1WpKWl+VfwZorlOkysfManFLq8JdRS9elF7733XrFt2zbxzjvviFatWjVKL/rOO++Ibt26iUOHDjVru5PpPfuNP4L5PrbkvY5GPFcD66OPPhLLli0Tu3btEl999ZX4zW9+I8xms/jkk08annPy+zl58mSRmJgoXn/9dbFnzx7x5ZdfiiFDhoisrCxRWVkZsrK7XC6xZcsWsWXLFtG/f38xatSoht9dLpcQIrTni16PZ/78+UKWZTF//vxGqaFLS0sj7lhOJRTXaTCP54cffhAWi0X8+te/Ftu2bRNffvml6Nevnxg4cKBQVTVox9QcLT22QL1v4RbM+8isWbPEBx98IHbu3Cl+/PFH8dRTTwmj0SgeeuihEB5h08sbrXWYWPmMT4WBWoRYu3atOOecc4TJZBIZGRnioYceEh6Pp+Hv9V+Ge/fubdZ2J4v2ym8w38fmvtfRiudq4Cxfvlx069ZNmM1mkZiYKMaMGSM2b97c6Dknv58Oh0M8/PDDokuXLsJisYiMjAwxceJEsW3btpCWfe/evQLAKX9+/tmH6nzR6/G0b9/+tPuNtGM5lVBcp8E+ng0bNohBgwYJi8UisrKyxG233Ra2pS5OpyXHFqj3TQ+CdR+5//77RceOHYXFYhFJSUni3HPPFa+88krYgvRYrsPEymd8MkkIIQLZQ0dERERERET+4Rw1IiIiIiIinWGgRkREREREpDMM1IiIiIiIiHSGgRoREREREZHOMFAjIiIiIiLSGQZqREREREREOsNAjYiIiIiISGcYqBEREREREekMAzUiIiIiIiKdYaBGRERERESkMwzUiIiIiIiIdIaBGhERERERkc4wUCMiItKZyy+/HIqiwOFwhLsoRPSTW2+9FZIk4fjx42HdR0vxvhJ5GKgREREF2PLlyyFJEiRJwnfffdfs7QsKCtC1a1fYbLYglI6IWqKgoABZWVlITU0N6z78eW3eVyILAzUiIqIA8ng8mD59OiRJAgAUFhY2a/vKykrs378f+fn5QSgdEbWEx+PB9u3b/bou6/fRt2/fwBWsiXhfiUwM1IiIiALob3/7G3bu3Inf//73AJofqNU/nxUqIv3Ytm0b3G63X9dlIPbRUryvRCYGakRB9s9//hOSJGHZsmVYtGgR+vfvD4vFgssvvzzcRSOiACsvL8ecOXMwaNAgPPLIIwBOH6hVVlbigQceQHZ2Nmw2G4YMGYLCwkIUFBQAYIWKKNi8Xi8WLFiAcePGoX379rBYLMjJycGNN96I/fv3N3pu/XX5896w119/HZIkYdGiRZg5cya6d+8Oi8WCNm3a4P7774fH4zntPt555x0MHjwY8fHxyMrKwowZM6BpWovLV4/3lehiCHcBiKJdfSXtxRdfxHfffYerrroKw4cPR15eXphLRkSB9uijj6KyshLPPPMMUlJSkJGRccpAraysDIMHD0ZxcTHGjh2LHj164Msvv8Tw4cMxcOBAAKxQEQXb999/j2nTpmHYsGG49NJLER8fj4KCAvzvf//DN998gy1btsBqtQLAKQOd+sf+9Kc/oby8HJMmTcLIkSOxdOlSzJ8/H/Hx8ZgzZ84vnv+///0PX3zxBcaOHYsBAwZg8eLFeOqpp9ChQwdMmTKlReUDeF+JSoKIgmrw4MECgOjTp484duxYuItDREHy/fffC0VRxBVXXNHw2MUXXywAiAMHDjR67sUXXyxMJpNYtWpVw2OapokJEyYIACIjIyNk5SaKVWVlZaKqquoXjz/88MMCgPjkk08aHhs2bJiIj48XmqY1PDZixAgBQPTu3VscOXKk4fFDhw6JuLg4kZCQ0Oj5w4YNEwDEhRdeKMrKyhoe3759uwAgJk2a1OLyCcH7SjTi0EeiINu6dSuMRiP++9//onXr1uEuDhEFydSpUyFJEubOndvwWM+ePQE0Hv64fPlyrFu3DnfffTdGjx7d8LgkSbj11lsBsNWbKBTS0tKQmJj4i8fPOeccAEBJSUnDY1u3bkWfPn0akgQBvuvaYDBg8eLFSE9Pb3g8KysLI0aMQE1NDQ4fPtxoH3FxcVi8eDHS0tIaHu/atStkWYbL5Wpx+XhfiU4M1IiCaO/evaiqqsLw4cPRq1evcBeHiIJk+fLlWLt2LW677TZ069at4fH6QG3r1q0Njy1cuBBGoxHTpk37xX5SUlIAsEJFFAoHDhzA/fffj169eiE+Pr5hSY0rr7wSANCuXbuG51VUVDSan1ZSUoLy8nKMHj0aPXr0+MW+66/l+nlq9fsYM2YM2rZt2+i5+/btg6Zp6NSpU4vKB/C+Eq04R40oiOpb0ceOHRvmkhBRsNSn44+Li8Ps2bMb/e3kHjUhBD755BP079//F5U1AA0JAlihIgquDRs2YOzYsXC5XBg+fDguueQSJCYmQpIk/O9//0NxcTF69+4N4Mzz00aOHHnK/R84cAAGgwEZGRmNnj98+PBfPPdUiUqaUz7eV6IXAzWiIKqvnJ177rlhLgkRBUt9On4AyMzMPOVz6u8Fx48fh8PhQHZ29imft3z5cgCsUBEFk6ZpuOmmm2CxWPDVV181NKgAvoaXBQsWICcnB8nJyQDOHKjl5OT8Yv/V1dXYuHEjBg0aBIvFctp9nLyv+kCtueXjfSV6MVAjCqKCggLIsow+ffqEuyhEFAT16fhTU1NPu+TGO++8g+LiYjgcDhiNRgC+7Gwn27FjB5YtWwabzYbc3NxgFpsophUVFWH//v247bbbGgVBgC8j4/Hjx3HhhRc2PFZYWAhZlht6sOofA4Cqqqpf7P+ll16C0+lslMGxfh+nqg9s2bIFBoOhoSzNLR/vK9GLgRpREBUWFqJLly6Ij48Pd1GIKAjq0/G/+OKLuOOOO075nNLSUqxcuRI//PADBgwYgIyMDHzxxRcoKipqmM9WUVGBm2++GZqmoU+fPpBlTiEnChaz2QwAOHjwYKPHN2zYgHvvvRfAL3vPunbt2igVfn0v2BtvvIGbbrqpIcnI559/jsceewyDBg3Ctdde2+j5ubm5iIuL+0V5CgoK0KNHD5hMphaVLykpifeVKMVPjChIqqursW/fPvTr1y/cRSGiIPjhhx/w8ssvo0+fPpg8efJpn3fyPLX6hXAvuOAC3HPPPbj77ruRl5eHiooKAByeRBRsHTt2xDnnnIM1a9Zg1KhRePDBB3HppZdi1KhRGDJkCID/vw6rq6uxd+/eRtel3W7H7t27MWzYMHz22We44IIL8NBDD+Gqq67CRRddhPT0dCxZsqQhMDrVPuodP34chw4davS35pSvHu8r0YmBGlGQbN26FUII3hyJotTUqVOhqirmz58PRVFO+7z6jK/1gdoDDzyAGTNmwGAw4OWXX8aaNWtwyy23NCyMy3sGUXBJkoRly5Zh/Pjx+Oqrr/DKK6/AbDZj8+bNDfO86q/DU32XFxYWQtM0jB49GitWrIDH48Hzzz+PL7/8ElOmTMHmzZuRlZXV8Pwz1Qe2bNkCoHEikeaUrx7vK9FJEkKIcBeCiIiIiCgSvPjii7jrrruwcuVKjBkzJtzFoSjGHjUiIiIioiaqn5/GRGEUbAzUiIiIiIiaqKCgACkpKY2GNxIFAwM1IiIiIqIm0DQNP/zwA3vTKCQ4R42IiIiIiEhn2KNGRERERESkMwzUiIiIiIiIdIaBGhERERERkc4wUCMiIiIiItIZBmpEREREREQ6w0CNiIiIiIhIZxioERERERER6QwDNSIiIiIiIp1hoEZERERERKQzDNSIiIiIiIh05v8AQsDWLTbo2YUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAGdCAYAAAAotLvzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAApSklEQVR4nO3df3RU9Z3/8ddNQiaBnUSDm0xGQ4x72GIJRQpURSqh1WwjpWtZfyCKoLs9eAgIpqVAqWt0D5nF3bK0ZsUT/0A8Lso/imxrxbRCkGNRSKSwbg8/1gipmJOjxyYQJCEz9/sHMl9HQjKTe+/MvZPn45x7DnNz7+e+ycnknff7c+d+DNM0TQEAANfISHUAAAAgFskZAACXITkDAOAyJGcAAFyG5AwAgMuQnAEAcBmSMwAALkNyBgDAZbJSHcBXRSIRnTx5Un6/X4ZhpDocAECCTNPUqVOnFAwGlZHhXA149uxZ9fb2Wh4nOztbOTk5NkRkH9cl55MnT6qkpCTVYQAALGpra9NVV13lyNhnz55VWelfqb0jbHmsQCCg1tZWVyVo1yVnv98vSZqu25SlESmOBgCQqD6d0x69Fv197oTe3l61d4TV2lyqPP/Qq/OuUxGVTT6u3t5ekvNALrSyszRCWQbJGQA854sVG5IxNZnnz7CUnN3KdckZAIB4hc2IwhaWbwqbEfuCsRHJGQDgWRGZimjo2dnKuU4iOQMAPCuiiKzUvtbOdk76NeoBAPA4x5Lz008/rbKyMuXk5Gjy5Ml66623nLoUAGCYCpum5c2NHEnOW7du1fLly7VmzRq99957+va3v62qqiqdOHHCicsBAIapC3POVjY3ciQ5r1+/Xv/4j/+of/qnf9K1116rDRs2qKSkRBs3bnTicgAApBXbk3Nvb6+am5tVWVkZs7+yslJvv/32Rcf39PSoq6srZgMAIB4RmQpb2BKtnEOhkKZOnSq/36/CwkLdfvvtOnz4cMwxCxculGEYMdsNN9yQ0HVsT86ffPKJwuGwioqKYvYXFRWpvb39ouNDoZDy8/OjG4/uBADEK9lt7aamJlVXV2vv3r1qbGxUX1+fKisr1d3dHXPc9773PX388cfR7bXXXkvoOo59lOqrT4YxTbPfp8WsXr1aNTU10dddXV0kaACAK73++usxrzdt2qTCwkI1Nzfr5ptvju73+XwKBAJDvo7tyfmKK65QZmbmRVVyR0fHRdW0dP4/4PP57A4DADAMWL3j+sK5X51SjTc3dXZ2SpIKCgpi9u/atUuFhYW67LLLNGPGDK1du1aFhYVxx2V7Wzs7O1uTJ09WY2NjzP7GxkZNmzbN7ssBAIaxiA2bJJWUlMRMsYZCoUGvbZqmampqNH36dJWXl0f3V1VV6b/+67/05ptv6he/+IX27dun73znO+rp6Yn7/+VIW7umpkbz58/XlClTdOONN6qhoUEnTpzQQw895MTlAACwpK2tTXl5edHX8VTNS5Ys0cGDB7Vnz56Y/XfffXf03+Xl5ZoyZYpKS0v1m9/8RnPmzIkrHkeS8913361PP/1UTzzxhD7++GOVl5frtddeU2lpqROXAwAMUxfuurZyviTl5eXFJOfBLF26VNu3b9fu3bsHXbO6uLhYpaWlOnr0aNzjO3ZD2OLFi7V48WKnhgcAQGFTFlelSux40zS1dOlSvfLKK9q1a5fKysoGPefTTz9VW1ubiouL474Oz9YGAHiWXXPO8aqurtYLL7ygLVu2yO/3q729Xe3t7fr8888lSadPn9ZPfvIT/eEPf9CHH36oXbt2afbs2briiiv0wx/+MO7rsCoVAABxuvCky4qKipj9mzZt0sKFC5WZmalDhw7p+eef11/+8hcVFxdr5syZ2rp1q/x+f9zXITkDADwrIkNhXfwMjUTOT4Q5yMe2cnNztWPHjiHHcwHJGQDgWRHz/GblfDdizhkAAJehcgYAeFbYYlvbyrlOIjkDADwrXZMzbW0AAFyGyhkA4FkR01DEtHC3toVznURyBgB4Fm1tAACQFFTOAADPCitDYQt1ZtjGWOxEcgYAeJZpcc7ZZM4ZAAB7MecMAACSgsoZAOBZYTNDYdPCnLNLn61NcgYAeFZEhiIWmsARuTM709YGAMBlqJwBAJ6VrjeEkZwBAJ5lfc6ZtjYAAIgDlTMAwLPO3xBmYeEL2toAANgrYvHxndytDQAA4kLlDADwrHS9IYzkDADwrIgy0vIhJCRnAIBnhU1DYQsrS1k510kkZwAYrgynEpMhlxaknkFyBgB4Vtji3dphl/4VQXIGAHhWxMxQxMINYRGX3hDGR6kAAHAZKmcAgGfR1gYAwGUisnbHdcS+UGxFWxsAAJehcgYAeJb1h5C4s0a1PapQKKSpU6fK7/ersLBQt99+uw4fPmz3ZQAAiD6+08rmRrZH1dTUpOrqau3du1eNjY3q6+tTZWWluru77b4UAABpyfa29uuvvx7zetOmTSosLFRzc7Nuvvlmuy8HABjGWM95iDo7OyVJBQUF/X69p6dHPT090dddXV1OhwQASBPWV6UaJm3tLzNNUzU1NZo+fbrKy8v7PSYUCik/Pz+6lZSUOBkSACCNXPics5XNjRyNasmSJTp48KBefPHFSx6zevVqdXZ2Rre2tjYnQwIAwPUca2svXbpU27dv1+7du3XVVVdd8jifzyefz+dUGACANBYxDUWsPIRkuCwZaZqmli5dqldeeUW7du1SWVmZ3ZcAAEDS+c8pW2lNu/VzzrYn5+rqam3ZskWvvvqq/H6/2tvbJUn5+fnKzc21+3IAAKQd25Pzxo0bJUkVFRUx+zdt2qSFCxfafTkAwDBmfcnIYVI5my5dGxMAkH7CMhS28FllK+c6yZ1/MgAAMIyx8AUAwLNoawMA4DJhWWtNh+0LxVbu/JMBAIBhjMoZAKwy3HlT0aAMp+qzDClJ9wbT1gYAwGXSdeELkjMAwLNMi0tGmnyUCgAAxIPKGQDgWbS1AQBwmXRdlcqdfzIAADCMUTkDADwrbHHJSCvnOonkDADwLNraAAAgKaicAQCeFVGGIhbqTCvnOonkDADwrLBpKGyhNW3lXCe5808GAACGMZIzAMCzLtwQZmVLRCgU0tSpU+X3+1VYWKjbb79dhw8fjjnGNE3V1tYqGAwqNzdXFRUVev/99xO6DskZAOBZ5herUg11MxN8QlhTU5Oqq6u1d+9eNTY2qq+vT5WVleru7o4e8+STT2r9+vWqr6/Xvn37FAgEdOutt+rUqVNxX4c5ZwCAZ4VlKGxh8YpEz3399ddjXm/atEmFhYVqbm7WzTffLNM0tWHDBq1Zs0Zz5syRJG3evFlFRUXasmWLFi1aFNd1qJwBAMNeV1dXzNbT0xPXeZ2dnZKkgoICSVJra6va29tVWVkZPcbn82nGjBl6++23446H5AwA8KyIaXXe+fw4JSUlys/Pj26hUGjQa5umqZqaGk2fPl3l5eWSpPb2dklSUVFRzLFFRUXRr8WDtjYAwLMuzB1bOV+S2tralJeXF93v8/kGPXfJkiU6ePCg9uzZc9HXDCO2XW6a5kX7BkJyBgAMe3l5eTHJeTBLly7V9u3btXv3bl111VXR/YFAQNL5Crq4uDi6v6Oj46JqeiC0tQEAnhWRYXlLhGmaWrJkiV5++WW9+eabKisri/l6WVmZAoGAGhsbo/t6e3vV1NSkadOmxX0dKmcAgGcl+wlh1dXV2rJli1599VX5/f7oPHJ+fr5yc3NlGIaWL1+uuro6jR07VmPHjlVdXZ1GjhypefPmxX0dkjMAAHHauHGjJKmioiJm/6ZNm7Rw4UJJ0k9/+lN9/vnnWrx4sT777DNdf/31euONN+T3++O+DskZQPpL4EYc1zGcm300Mpz5vhimIUUcGfoidt0QFi/TNAc9xjAM1dbWqra2dohRkZwBAB4WkcX1nC08wMRJ3BAGAIDLUDkDADzLHMId1189341IzgAAzxrKylJfPd+NSM4AAM9K9g1hyeLOqAAAGMaonAEAnpWubW3HK+dQKBR9YgoAAHZK9uM7k8XR5Lxv3z41NDToG9/4hpOXAQAgrTiWnE+fPq17771Xzz77rC6//HKnLgMAGMasreVsrSXuJMeSc3V1tWbNmqVbbrnFqUsAAIa5dE3OjtwQ9tJLL6mlpUX79u0b9Nienh719PREX3d1dTkREgAAnmF75dzW1qZly5bphRdeUE5OzqDHh0Ih5efnR7eSkhK7QwIApKl0rZxtT87Nzc3q6OjQ5MmTlZWVpaysLDU1NelXv/qVsrKyFA6HY45fvXq1Ojs7o1tbW5vdIQEA0lS6Jmfb29rf/e53dejQoZh9DzzwgMaNG6eVK1cqMzMz5ms+n08+n8/uMAAA8Czbk7Pf71d5eXnMvlGjRmn06NEX7QcAwApT1pZ9HHx15tTgCWEAAM9K1yeEJSU579q1KxmXAQAMM+manFn4AgAAl6GtDQDwrHStnEnOAADPStfkTFsbAACXoXIGAHiWaRoyLVS/Vs51EskZQPwMd/4iG5Th3SahkeHc99zIciYFGGZE6nNk6ItYXZN5WK7nDAAAEkflDADwrHS9IYzkDADwrHSdc6atDQCAy1A5AwA8i7Y2AAAuk65tbZIzAMCzTIuVs1uTM3POAAC4DJUzAMCzTEmmae18NyI5AwA8KyJDBk8IAwAATqNyBgB4FndrAwDgMhHTkJGGn3OmrQ0AgMtQOQMAPMs0Ld6t7dLbtUnOAADPStc5Z9raAAC4DJUzAMCz0rVyJjkDADwrXe/WJjkDADwrXW8IY84ZAACXoXIGAHjW+crZypyzjcHYiOQMpBvDnXNogzKca+QZGQ5/TxyMXU7GPmKEM+OapnTWmaEvvlR63hBGWxsAAJehcgYAeJYpa2syu7SrTXIGAHgXbW0AAJAUVM4AAO9K0742yRkA4F0W29pyaVub5AwA8CyeEJaAjz76SPfdd59Gjx6tkSNH6rrrrlNzc7MTlwIAIO3YXjl/9tlnuummmzRz5kz99re/VWFhof7v//5Pl112md2XAgAMc+l6t7btyXndunUqKSnRpk2bovuuvvpquy8DAMD5OeM0nHO2va29fft2TZkyRXfeeacKCws1adIkPfvss5c8vqenR11dXTEbAADDme3J+YMPPtDGjRs1duxY7dixQw899JAefvhhPf/88/0eHwqFlJ+fH91KSkrsDgkAkKYu3BBmZXMj25NzJBLRN7/5TdXV1WnSpElatGiRfvSjH2njxo39Hr969Wp1dnZGt7a2NrtDAgCkK9OGzYVsT87FxcX6+te/HrPv2muv1YkTJ/o93ufzKS8vL2YDAMCtdu/erdmzZysYDMowDG3bti3m6wsXLpRhGDHbDTfckNA1bE/ON910kw4fPhyz78iRIyotLbX7UgCAYe7C3dpWtkR1d3dr4sSJqq+vv+Qx3/ve9/Txxx9Ht9deey2ha9h+t/YjjzyiadOmqa6uTnfddZfeffddNTQ0qKGhwe5LAQCQ9NZ0VVWVqqqqBjzG5/MpEAgM+Rq2V85Tp07VK6+8ohdffFHl5eX6l3/5F23YsEH33nuv3ZcCAMAWX/3UUE9Pj6Xxdu3apcLCQv3t3/6tfvSjH6mjoyOh8x15fOf3v/99ff/733diaAAAoux6CMlXPyn02GOPqba2dkhjVlVV6c4771RpaalaW1v16KOP6jvf+Y6am5vl8/niGoNnawMAvMumVana2tpibkiON4n25+67747+u7y8XFOmTFFpaal+85vfaM6cOXGNQXIGAHiY8cVm5Xw5+mmh4uJilZaW6ujRo3Gf48jCFwAA4LxPP/1UbW1tKi4ujvscKmcAgHfZ1NZOxOnTp3Xs2LHo69bWVh04cEAFBQUqKChQbW2t/uEf/kHFxcX68MMP9bOf/UxXXHGFfvjDH8Z9DZIzkAqGOx+2PyjDuWabkeHg98TBuCXJyHRw/MxMx4Y2fNnOjBtxZNj+pSA579+/XzNnzoy+rqmpkSQtWLBAGzdu1KFDh/T888/rL3/5i4qLizVz5kxt3bpVfr8/7muQnAEASEBFRYXMAR7KvWPHDsvXIDkDALwrTZeMJDkDADzL6spSw2ZVKgAAYA2VMwDAu1JwQ1gykJwBAN6VpnPOtLUBAHAZKmcAgGcZ5vnNyvluRHIGAHgXc84AALgMc84AACAZqJwBAN5FWxsAAJdJ0+RMWxsAAJehcgYAeFeaVs4kZwCAd3G3NgAASAYqZwCAZ/GEMAAA3CZN55xpawMA4DIkZwAAXIa2NgDAswxZnHO2LRJ7kZyBSzHc+rYdhOFcQ8zIcPB74mTcmQ43CUeMcGxoI8u5X9NGTo4z40aS+N7ho1QAACAZqJwBAN6Vpndrk5wBAN6VpsmZtjYAAC5D5QwA8CyeEAYAgNvQ1gYAAMlge3Lu6+vTz3/+c5WVlSk3N1fXXHONnnjiCUUiEbsvBQAY7kwbNheyva29bt06PfPMM9q8ebPGjx+v/fv364EHHlB+fr6WLVtm9+UAAMMYc85x+sMf/qC///u/16xZsyRJV199tV588UXt37/f7ksBAJCWbG9rT58+Xb///e915MgRSdIf//hH7dmzR7fddlu/x/f09KirqytmAwAgLhce32llcyHbK+eVK1eqs7NT48aNU2ZmpsLhsNauXat77rmn3+NDoZAef/xxu8MAAAwH3K0dn61bt+qFF17Qli1b1NLSos2bN+vf//3ftXnz5n6PX716tTo7O6NbW1ub3SEBANLUhTlnK5sb2V45r1ixQqtWrdLcuXMlSRMmTNDx48cVCoW0YMGCi473+Xzy+Xx2hwEAgGfZnpzPnDmjjIzYgjwzM5OPUgEA7JembW3bk/Ps2bO1du1ajRkzRuPHj9d7772n9evX68EHH7T7UgCA4c5qa3q4JOennnpKjz76qBYvXqyOjg4Fg0EtWrRI//zP/2z3pQAASEu2J2e/368NGzZow4YNdg8NAEAs2toAALhMmiZnFr4AAMBlqJwBAJ6Vrs/WpnIGAMBlqJzhbYY7n4s7KMO5v4uNDAe/J07GnelgrTBihHNjSzKynPtVaviyHRvbHJXrzLhh6j6rSM4AAO9K0xvCSM4AAM9K1zlnkjMAwNtcmmCtYGIAAACXoXIGAHgXc84AALhLus4509YGAMBlqJwBAN5FWxsAAHehrQ0AAJKCyhkA4F20tQEAcJk0Tc60tQEAcBkqZwCAZ6XrDWEkZwCAd9HWBgDAZUwbtgTt3r1bs2fPVjAYlGEY2rZtW2xIpqna2loFg0Hl5uaqoqJC77//fkLXIDkDAJCA7u5uTZw4UfX19f1+/cknn9T69etVX1+vffv2KRAI6NZbb9WpU6fivgZtbQCAZ6VizrmqqkpVVVX9fs00TW3YsEFr1qzRnDlzJEmbN29WUVGRtmzZokWLFsV1DSpnAIB32dTW7urqitl6enqGFE5ra6va29tVWVkZ3efz+TRjxgy9/fbbcY9DcgYADHslJSXKz8+PbqFQaEjjtLe3S5KKiopi9hcVFUW/Fg/a2gAAz7Krrd3W1qa8vLzofp/PZy0uw4h5bZrmRfsGQnIGAHiXTR+lysvLi0nOQxUIBCSdr6CLi4uj+zs6Oi6qpgdCcobzEvhr0VUM52Z9jAwHvydOxj3CwV8ZmZmODW1kj3Bs7PPjZzs3eG6OY0OH83OdGbfPo+95G5SVlSkQCKixsVGTJk2SJPX29qqpqUnr1q2LexySMwDAu1LwEJLTp0/r2LFj0detra06cOCACgoKNGbMGC1fvlx1dXUaO3asxo4dq7q6Oo0cOVLz5s2L+xokZwCAZxlfbFbOT9T+/fs1c+bM6OuamhpJ0oIFC/Tcc8/ppz/9qT7//HMtXrxYn332ma6//nq98cYb8vv9cV+D5AwAQAIqKipkmpcuuQ3DUG1trWpra4d8DZIzAMC70vTZ2iRnAIBnsSoVAABuk6aVM08IAwDAZRJOzslYKgsAgLglcbnIZEk4OSdjqSwAAOJxYc7ZyuZGCc85J2OpLAAAhjNb55yHslRWT0/PRUt1AQAQF5uWjHQbW5PzUJbKCoVCMct0lZSU2BkSACCNpWtb25G7tRNZKmv16tXq7OyMbm1tbU6EBACAZ9j6OeehLJXl8/ksr5sJABim+Jzz4L68VNYFF5bKmjZtmp2XAgAgbdvaCVfOyVgqCwCA4Szh5JyMpbIAAIhLmra1E07OyVgqCwCAuJCcAQBwl3RdlYqFLwAAcBkqZwCAd9HWBgDAXQzTlDHAfVDxnO9GJGd4m+HczIyR0f9T7Wwa3LmhMx2crcrMdGxoI8u5X0dGdrZjY0uScpx7kFJkZI5jY/cWODN23zlHhh1WSM4AAO+irQ0AgLtwtzYAAEgKKmcAgHfR1gYAwF1oawMAgKSgcgYAeBdtbQAA3CVd29okZwCAd6Vp5cycMwAALkPlDADwNLe2pq0gOQMAvMs0z29Wznch2toAALgMlTMAwLO4WxsAALfhbm0AAJAMVM4AAM8yIuc3K+e7EckZAOBdtLUBAEAyUDkDADyLu7UBAHCbNH0ICckZAOBZVM5IX4bh8PjO3dpgZDgYu5NxZzp4u8eIEY4NbWQ7OXa2Y2ObfzXSsbElyRzpc2zsc5fnOjb2qSudSQHhXlKLVXwHAQDelaZ3a5OcAQCela5tbT5KBQCAy1A5AwC8i7u1AQBwF9raAAAgKaicAQDelaZ3aydcOe/evVuzZ89WMBiUYRjatm1b9Gvnzp3TypUrNWHCBI0aNUrBYFD333+/Tp48aWfMAABI+v9tbSubGyWcnLu7uzVx4kTV19df9LUzZ86opaVFjz76qFpaWvTyyy/ryJEj+sEPfmBLsAAADAcJt7WrqqpUVVXV79fy8/PV2NgYs++pp57St771LZ04cUJjxowZWpQAAPQnYp7frJzvQo7POXd2dsowDF122WX9fr2np0c9PT3R111dXU6HBABIF8w5J+7s2bNatWqV5s2bp7y8vH6PCYVCys/Pj24lJSVOhgQASCOGLM45p/o/cAmOJedz585p7ty5ikQievrppy953OrVq9XZ2Rnd2tranAoJAABPcKStfe7cOd11111qbW3Vm2++ecmqWZJ8Pp98PudWdAEApDGeEBafC4n56NGj2rlzp0aPHm33JQAAkJS+TwhLODmfPn1ax44di75ubW3VgQMHVFBQoGAwqDvuuEMtLS369a9/rXA4rPb2dklSQUGBsh1crxUAgHSRcHLev3+/Zs6cGX1dU1MjSVqwYIFqa2u1fft2SdJ1110Xc97OnTtVUVEx9EgBAPiqNL1bO+HkXFFRIXOAHv1AXwMAwE6GacqwkHcSPbe2tlaPP/54zL6ioqJol9guPFsbAIAEjB8/Xr/73e+irzMzM22/BskZAOBdkS82K+cnKCsrS4FAwMJFB8eSkQAAz7rQ1raySeefTvnl7ctPrvyqo0ePKhgMqqysTHPnztUHH3xg+/+L5AwAGPZKSkpinlYZCoX6Pe7666/X888/rx07dujZZ59Ve3u7pk2bpk8//dTWeGhrAwC8y6a7tdva2mIemHWph2N9eeGnCRMm6MYbb9Tf/M3faPPmzdFPL9mB5OwVhlufAJtihnPNHyPTwcbSiBGODW1kOfe2Npx8VkGOc08KNEc6+xTCvstyHBv77Gjnfla6r3Tm90q4J4m/r2x6QlheXt6AT7O8lFGjRmnChAk6evTo0GPoB21tAIBnWVr0wuLTxaTzKyv+6U9/UnFxsT3/oS+QnAEAiNNPfvITNTU1qbW1Ve+8847uuOMOdXV1acGCBbZeh7Y2AMC7krzwxZ///Gfdc889+uSTT/TXf/3XuuGGG7R3716VlpYOPYZ+kJwBAJ5lRM5vVs5PxEsvvTT0iyWAtjYAAC5D5QwA8C7WcwYAwGXSdFUq2toAALgMlTMAwLOSvWRkspCcAQDelaZzzrS1AQBwGSpnAIB3mbK2nrM7C2eSMwDAu5hzBgDAbUxZnHO2LRJbMecMAIDLUDkDALwrTe/WJjkDALwrIsmweL4L0dYGAMBlqJwBAJ7F3doAALhNms4509YGAMBlqJwBAN6VppUzyRmS4WwDxciwcivlIJwcOzPTsaGNLOfeeoYv27GxlZvj2NCRkc6Nfe7yXMfGlqSzo0c4NvbpoHM/h+fGnXFk3MiZs46M2680Tc60tQEAcBkqZwCAd6Xp55xJzgAAz+KjVAAAuA1zzgAAIBmonAEA3hUxJcNC9RtJk8p59+7dmj17toLBoAzD0LZt2y557KJFi2QYhjZs2GAhRAAALuFCW9vK5kIJJ+fu7m5NnDhR9fX1Ax63bds2vfPOOwoGg0MODgCA4SjhtnZVVZWqqqoGPOajjz7SkiVLtGPHDs2aNWvIwQEAMDCr1a87K2fb55wjkYjmz5+vFStWaPz48XYPDwDA/5emd2vbnpzXrVunrKwsPfzww3Ed39PTo56enujrrq4uu0MCAMBTbE3Ozc3N+uUvf6mWlhYZRnyPbAmFQnr88cftDAMAMFxETFlqTafL3doDeeutt9TR0aExY8YoKytLWVlZOn78uH784x/r6quv7vec1atXq7OzM7q1tbXZGRIAIJ2ZEeubC9laOc+fP1+33HJLzL6/+7u/0/z58/XAAw/0e47P55PP57MzDAAAPC3h5Hz69GkdO3Ys+rq1tVUHDhxQQUGBxowZo9GjR8ccP2LECAUCAX3ta1+zHi0AAF/GDWHn7d+/XzNnzoy+rqmpkSQtWLBAzz33nG2BAQAwqDSdc044OVdUVMhM4C+NDz/8MNFLAAAQnzStnFn4AgAAl2HhCwCAd5myWDnbFomtSM4AAO+irQ0AAJKByhkA4F2RiCQLDxKJDIOHkAx7cT6ydGhjO9fkMDIcjFuSkeXgj9mIEY4NbfiynRs7J8exsc1RuY6NHc53buzeAue+J6eudPZXXfeVzr2Hzo0749jYxyqec2TcrlMRXe7IyP2grQ0AAJKByhkA4F1pWjmTnAEA3pWmTwijrQ0AgMtQOQMAPMs0IzItLPto5VwnkZwBAN5lmtZa08w5AwBgM9PinLNLkzNzzgAAuAyVMwDAuyIRybAwb8ycMwAANqOtDQAAkoHKGQDgWWYkItNCW5uPUgEAYDfa2gAAIBmonAEA3hUxJSP9KmeSMwDAu0xTkpWPUrkzOdPWBgDAZaicAQCeZUZMmRba2qZLK2eSMwDAu8yIrLW1+SgVAAC2StfKmTlnAABcxnWV84W/Yvp0ztLnylPDcHBs5/6OMkwn45YMJ9tGDv7Va+VZ+oOP7dz33Aw797MS7nMu7r5zjg2tcK+zv+rCPc59XyJnzjo2dtcpZ37Iu06fHzcZVWmf2WOpNd0nB3/wLHBdcj516pQkaY9eS3EkQ+Dkz6GTYzs95dLn4NjO/d4C0t7lDo9/6tQp5efnOzJ2dna2AoGA9rRbzxWBQEDZ2dk2RGUfw3RZwz0SiejkyZPy+/0yjMH/Gu3q6lJJSYna2tqUl5eXhAjtQdzJ59XYiTu5iNs60zR16tQpBYNBZWQ418k5e/asent7LY+TnZ2tnJwcGyKyj+sq54yMDF111VUJn5eXl5fyH8ihIO7k82rsxJ1cxG2NUxXzl+Xk5LguqdqFG8IAAHAZkjMAAC7j+eTs8/n02GOPyefzpTqUhBB38nk1duJOLuKGG7juhjAAAIY7z1fOAACkG5IzAAAuQ3IGAMBlSM4AALiMp5Pz008/rbKyMuXk5Gjy5Ml66623Uh3SoEKhkKZOnSq/36/CwkLdfvvtOnz4cKrDSlgoFJJhGFq+fHmqQxnURx99pPvuu0+jR4/WyJEjdd1116m5uTnVYQ2or69PP//5z1VWVqbc3Fxdc801euKJJxSJuG95u927d2v27NkKBoMyDEPbtm2L+bppmqqtrVUwGFRubq4qKir0/vvvpybYLxko7nPnzmnlypWaMGGCRo0apWAwqPvvv18nT55MXcBfGOz7/WWLFi2SYRjasGFD0uKDPTybnLdu3arly5drzZo1eu+99/Ttb39bVVVVOnHiRKpDG1BTU5Oqq6u1d+9eNTY2qq+vT5WVleru7k51aHHbt2+fGhoa9I1vfCPVoQzqs88+00033aQRI0bot7/9rf73f/9Xv/jFL3TZZZelOrQBrVu3Ts8884zq6+v1pz/9SU8++aT+7d/+TU899VSqQ7tId3e3Jk6cqPr6+n6//uSTT2r9+vWqr6/Xvn37FAgEdOutt0afo58qA8V95swZtbS06NFHH1VLS4tefvllHTlyRD/4wQ9SEGmswb7fF2zbtk3vvPOOgsFgkiKDrUyP+ta3vmU+9NBDMfvGjRtnrlq1KkURDU1HR4cpyWxqakp1KHE5deqUOXbsWLOxsdGcMWOGuWzZslSHNKCVK1ea06dPT3UYCZs1a5b54IMPxuybM2eOed9996UoovhIMl955ZXo60gkYgYCAfNf//Vfo/vOnj1r5ufnm88880wKIuzfV+Puz7vvvmtKMo8fP56coOJwqbj//Oc/m1deeaX5P//zP2Zpaan5H//xH0mPDdZ4snLu7e1Vc3OzKisrY/ZXVlbq7bffTlFUQ9PZ2SlJKigoSHEk8amurtasWbN0yy23pDqUuGzfvl1TpkzRnXfeqcLCQk2aNEnPPvtsqsMa1PTp0/X73/9eR44ckST98Y9/1J49e3TbbbelOLLEtLa2qr29Pea96vP5NGPGDE++Vw3DcH3XJRKJaP78+VqxYoXGjx+f6nAwRK5b+CIen3zyicLhsIqKimL2FxUVqb29PUVRJc40TdXU1Gj69OkqLy9PdTiDeumll9TS0qJ9+/alOpS4ffDBB9q4caNqamr0s5/9TO+++64efvhh+Xw+3X///akO75JWrlypzs5OjRs3TpmZmQqHw1q7dq3uueeeVIeWkAvvx/7eq8ePH09FSENy9uxZrVq1SvPmzXPFohIDWbdunbKysvTwww+nOhRY4MnkfMFXl5Q0TTOuZSbdYsmSJTp48KD27NmT6lAG1dbWpmXLlumNN97w1CowkUhEU6ZMUV1dnSRp0qRJev/997Vx40ZXJ+etW7fqhRde0JYtWzR+/HgdOHBAy5cvVzAY1IIFC1IdXsK8/F49d+6c5s6dq0gkoqeffjrV4QyoublZv/zlL9XS0uKZ7y/658m29hVXXKHMzMyLquSOjo6L/kJ3q6VLl2r79u3auXPnkJbITLbm5mZ1dHRo8uTJysrKUlZWlpqamvSrX/1KWVlZCofDqQ6xX8XFxfr6178es+/aa691/Y2DK1as0KpVqzR37lxNmDBB8+fP1yOPPKJQKJTq0BISCAQkybPv1XPnzumuu+5Sa2urGhsbXV81v/XWW+ro6NCYMWOi79Pjx4/rxz/+sa6++upUh4cEeDI5Z2dna/LkyWpsbIzZ39jYqGnTpqUoqviYpqklS5bo5Zdf1ptvvqmysrJUhxSX7373uzp06JAOHDgQ3aZMmaJ7771XBw4cUGZmZqpD7NdNN9100UfVjhw5otLS0hRFFJ8zZ85ctEh9ZmamKz9KNZCysjIFAoGY92pvb6+amppc/169kJiPHj2q3/3udxo9enSqQxrU/PnzdfDgwZj3aTAY1IoVK7Rjx45Uh4cEeLatXVNTo/nz52vKlCm68cYb1dDQoBMnTuihhx5KdWgDqq6u1pYtW/Tqq6/K7/dHK4r8/Hzl5uamOLpL8/v9F82Ljxo1SqNHj3b1fPkjjzyiadOmqa6uTnfddZfeffddNTQ0qKGhIdWhDWj27Nlau3atxowZo/Hjx+u9997T+vXr9eCDD6Y6tIucPn1ax44di75ubW3VgQMHVFBQoDFjxmj58uWqq6vT2LFjNXbsWNXV1WnkyJGaN29eCqMeOO5gMKg77rhDLS0t+vWvf61wOBx9rxYUFCg7OztVYQ/6/f7qHxEjRoxQIBDQ1772tWSHCitSe7O4Nf/5n/9plpaWmtnZ2eY3v/lNT3wcSVK/26ZNm1IdWsK88FEq0zTN//7v/zbLy8tNn89njhs3zmxoaEh1SIPq6uoyly1bZo4ZM8bMyckxr7nmGnPNmjVmT09PqkO7yM6dO/v9mV6wYIFpmuc/TvXYY4+ZgUDA9Pl85s0332weOnQotUGbA8fd2tp6yffqzp07XRt3f/golTexZCQAAC7jyTlnAADSGckZAACXITkDAOAyJGcAAFyG5AwAgMuQnAEAcBmSMwAALkNyBgDAZUjOAAC4DMkZAACXITkDAOAyJGcAAFzm/wEPhx189pI0dAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAL3CAYAAABmqb+qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU1dfA8e+m95AeAil0Qu8llNB7F6UJ0lQEROBFkKIUURRRAaWoVAUFFQRBWuhVeic0CYSS0ElIz2bv+8f+dmVJDykI5/M8eSCzd2bu7G529sw9c65GKaUQQgghhBBCCPFMzAq6A0IIIYQQQgjxIpDgSgghhBBCCCFygQRXQgghhBBCCJELJLgSQgghhBBCiFwgwZUQQgghhBBC5AIJroQQQgghhBAiF0hwJYQQQgghhBC5QIIrIYQQQgghhMgFElwJIYQQQgghRC6Q4Oo5smTJEjQajfHHwsKCokWL0q9fP27evFnQ3XthxcXFMWnSJHbu3FnQXXlpNGrUiEaNGhV0N3KF4e/1s88+S/WY4W/6yJEjBdAzmDRpEhqN5pm3Ex0dzSeffEKjRo3w9vbGwcGBihUr8vnnn5OQkJCqfXJyMpMnTyYgIABra2vKli3LN998k+a2r1y5QpcuXShUqBAODg40b96cY8eOZalfjRo1Mj7/ZmZmODo6UrJkSV599VV+//13dDpdqnUCAgJMPmdtbGwoWbIkI0eO5N69e9l6Xq5evWrczooVK1I9bnj+s7vdgpLd1zkrEhMT+fbbb6lfvz4uLi5YWVlRpEgRXnvtNXbt2pXLR5C3+vbtS0BAQI7W3b9/P5MmTeLRo0epHnsePw+ffG9n9nP16tWC7m62GY5vyZIl2V733LlzTJo0Kc+O2/C5YWZmxpUrV1I9Hhsbi5OTExqNhr59+6Z6/Pbt23zwwQdUrFgRBwcHbGxsKFWqFO+99x6XLl3K9/28jCwKugMitcWLF1O2bFni4+PZvXs306ZNY9euXZw+fRp7e/uC7t4LJy4ujsmTJwM8dye4F9XcuXMLugu57rPPPuOtt97C1dW1oLuS68LDw5k5cya9e/dm5MiRODg4sGfPHiZNmkRISAghISEmQdzgwYP56aef+Pjjj6lZsyabN2/mvffe4/Hjx4wbN87Y7u7duzRo0AAXFxcWLVqEjY0N06ZNo1GjRhw+fJgyZcpk2rfixYuzfPlyQP9lICwsjDVr1vDqq6/SoEED1q1bh7Ozs8k69erVY8aMGQDEx8dz5MgRJk2axO7du3McCI8fP55XXnkFS0vLHK3/PMju65yZe/fu0apVK06dOkX//v15//33cXV15ebNm6xdu5amTZty9OhRKleunIdH9XzYv38/kydPpm/fvhQqVMjksefx87Bw4cIcOHDAZNngwYOJiooy/r092fZlcu7cOSZPnkyjRo1yHGxnhYODA4sXL+bjjz82Wf7bb7+RnJyc5mfNoUOHaNeuHUophg4dSt26dbGysuLChQssW7aMWrVq8fDhwwLZz0tFiefG4sWLFaAOHz5ssvzDDz9UgFq2bFkB9SxrdDqdiouLK+huZNvdu3cVoCZOnJil9rGxsXnboRfYi/jcAapZs2bKwsJCjRw50uSx9P6mn5ZXz8vEiRNVbnzMx8TEqJiYmFTLv/jiCwWoPXv2GJedOXNGaTQa9emnn5q0ffPNN5Wtra26f/++cdn777+vLC0t1dWrV43LoqKilLu7u3rttdcy7VdwcLAqX758mo8tWrRIAam24+/vr9q2bZuqveFz9sKFC5nu1yAsLEwBqnXr1gpQs2fPNnnc8PzfvXs3w+08L38X2Xmds6J169bKwsJCbdu2Lc3HDx06pK5du5ajvhaEN954Q/n7++doXcNzGBYWlqt9yk8Z/b096b/wPcDwt7t48eJsr/vbb78pQO3YsSPX+6XUv58bAwcOVL6+violJcXk8fr166sePXooe3t79cYbbxiXR0VFKW9vb+Xr66uuX7+ebt/zez8vI0kL/A+oU6cOANeuXQMgISGBsWPHUqxYMWOKxZAhQ0zSDd5//32cnZ1JSUkxLnv33XfRaDR88cUXxmX379/HzMzMJGUnOjqaUaNGmWx/+PDhxMbGmvRLo9EwdOhQ5s+fT2BgINbW1ixdujTd49i+fTuNGjXCzc0NW1tb/Pz8eOWVV4iLiwP+HaafPn06n3zyCX5+ftjY2FCjRg22bduWanuXLl2iZ8+eeHp6Ym1tTWBgIHPmzEnV7tGjR/zf//0fxYsXx9raGk9PT9q0acP58+e5evUqHh4eAEyePNmY5mAYAjcMmx87doyuXbvi4uJCiRIlADhy5Ajdu3cnICAAW1tbAgIC6NGjh/F1ykxiYiJTpkwhMDAQGxsb3NzcaNy4Mfv37ze2ycprDfpUp3bt2rF+/XqqVq2Kra0tgYGBrF+/HtCnpwUGBmJvb0+tWrVSXZ3v27cvDg4OnD17lqZNm2Jvb4+HhwdDhw41vj4Gc+bMoWHDhnh6emJvb0/FihWZPn06ycnJJu0aNWpEhQoV2L17N0FBQdjZ2dG/f3/jY0+PEs6bN4/KlSvj4OCAo6MjZcuWNRnlADhz5gwdO3bExcUFGxsbqlSpkuo9t3PnTjQaDb/88gvjx4/Hx8cHJycnmjVrxoULF7L02mRXmTJlGDBgAHPmzMn09Tc816dPn6ZFixY4OjrStGlTAJKSkpg6dSply5bF2toaDw8P+vXrx927d022sXLlSlq0aEHhwoWNr/UHH3yQ6m80t9jb26c5al6rVi0Arl+/bly2Zs0alFL069fPpG2/fv2Ij49n06ZNxmV//PEHTZo0wd/f37jMycmJLl26sG7dOrRabY773K9fP9q0acNvv/2Wpb9Jw+hWTkaemjRpQsuWLfn44495/Phxhm0z+rvI6mevTqfjm2++oUqVKtja2lKoUCHq1KnDn3/+me2+Pyk7r3Nmjh49ysaNGxkwYABNmjRJs03NmjXx8/Mz/p6bf9/Dhw/H3t6e6OjoVPvt1q0bXl5exs8snU7H9OnTjX93np6e9OnThxs3bmR4jBmllmk0GiZNmgTozyPvv/8+AMWKFTOeZwyp6Gl9Hj548IDBgwdTpEgRrKysKF68OOPHjycxMTHVfoYOHcpPP/1EYGAgdnZ2VK5c2fjZn9cM557Vq1dTtWpVbGxsmDx5cpafG4Osns+z2p8//viDSpUqYWNjQ/HixZk9e3aW1t+7dy9NmzbF0dEROzs7goKC+Ouvv4yPL1myhFdffRWAxo0bG19Lw3EeP36cdu3aGY/Dx8eHtm3bZvpeSkv//v25fv06ISEhxmUXL15k7969xs+MJ/3www9ERkYyffp0ihYtmuY2u3btWmD7eZlIWuB/wOXLlwHw8PBAKUWnTp3Ytm0bY8eOpUGDBpw6dYqJEydy4MABDhw4gLW1Nc2aNWPGjBkcOnSIunXrArB161ZsbW0JCQkxftBv27YNpRTNmjUD9ClywcHB3Lhxg3HjxlGpUiXOnj3LRx99xOnTp9m6datJWsiaNWvYs2cPH330Ed7e3nh6eqZ5DFevXqVt27Y0aNCARYsWUahQIW7evMmmTZtISkrCzs7O2Pbbb7/F39+fmTNnGk96rVu3ZteuXcZjOXfuHEFBQfj5+fHll1/i7e3N5s2bGTZsGPfu3WPixIkAPH78mPr163P16lXGjBlD7dq1iYmJYffu3URERBAUFMSmTZto1aoVAwYMYODAgcbn+kldunShe/fuDBo0yPhF5+rVq5QpU4bu3bvj6upKREQE8+bNo2bNmpw7dw53d/d0X1OtVkvr1q3Zs2cPw4cPp0mTJmi1Wv7++2/Cw8MJCgrK8mttcPLkScaOHcv48eNxdnZm8uTJdOnShbFjx7Jt2zY+/fRTNBoNY8aMoV27doSFhWFra2tcPzk5mTZt2vD222/zwQcfsH//fqZOncq1a9dYt26dsd0///xDz549jV8AT548ySeffML58+dZtGiRyXFGRETw+uuvM3r0aD799FPMzNK+nrNixQoGDx7Mu+++y4wZMzAzM+Py5cucO3fO2ObChQsEBQXh6enJ7NmzcXNzY9myZfTt25fbt28zevRok22OGzeOevXqsWDBAqKjoxkzZgzt27cnNDQUc3PzdF+bnJo0aRI//fQTH374IT/++GOGbZOSkujQoYPxudZqteh0Ojp27MiePXsYPXo0QUFBXLt2jYkTJ9KoUSOOHDlifL0uXbpEmzZtjF8gz58/z+eff86hQ4fYvn17hvvW6XRp3ov0NI1Gk+nzZNhX+fLljcvOnDmDh4cH3t7eJm0rVapkfBz06Xj//PMPnTt3TrXdSpUqER8fz5UrVyhdunSmfU1Phw4d2LBhA3v27DEJ4JRSxsAtISGBw4cPM3PmTOrVq0exYsVytK/PP/+cqlWr8sUXXzBlypQM26b1d5Gdz96+ffuybNkyBgwYwJQpU7CysuLYsWMm94Dk9eucmS1btgDQqVOnLLXP7b/v/v37M2vWLH799Vfj5zroL7atXbuWIUOGGAPpd955h++//56hQ4fSrl07rl69yocffsjOnTs5duxYhp/lWTFw4EAePHjAN998w+rVq41pdOXKlUuzfUJCAo0bN+aff/5h8uTJVKpUiT179jBt2jROnDhh8mUf4K+//uLw4cNMmTIFBwcHpk+fTufOnblw4QLFixcH9O/5Jy+2ZsTCIntfDY8dO0ZoaCgTJkygWLFi2b59Iavn86w6ceIEw4cPZ9KkSXh7e7N8+XLee+89kpKSGDVqVLrr7dq1i+bNm1OpUiUWLlyItbU1c+fOpX379vzyyy9069aNtm3b8umnnzJu3DjmzJlDtWrVAChRogSxsbE0b96cYsWKMWfOHLy8vIiMjGTHjh2ZXnRJS6lSpYzfmVq2bAnAokWLCAgIMF6Qe9KWLVswNzenffv2z+V+XioFOWwmTBlSiP7++2+VnJysHj9+rNavX688PDyUo6OjioyMVJs2bVKAmj59usm6K1euVID6/vvvlVL6NBMrKys1ZcoUpZRSN27cUIAaM2aMsrW1VQkJCUopfaqOj4+PcTvTpk1TZmZmqdKYfv/9dwWoDRs2GJcBytnZWT148CDTYzOsf+LEiXTbGIbpfXx8VHx8vHF5dHS0cnV1Vc2aNTMua9mypSpatKiKiooy2cbQoUOVjY2NsU9TpkxRgAoJCUl3vxmlBRqGzT/66KNMj1Gr1aqYmBhlb2+vZs2alWHbH3/8UQHqhx9+SLdNVl9rpfSpTra2turGjRvGZSdOnFCAKly4sEna0Zo1axSg/vzzT+OyN954QwGp+v3JJ58oQO3duzfNPqakpKjk5GT1448/KnNzc5P3QnBwsALSTAkKDg5WwcHBxt+HDh2qChUqlO5zoZRS3bt3V9bW1io8PNxkeevWrZWdnZ169OiRUkqpHTt2KEC1adPGpN2vv/6qAHXgwIEM95NdgBoyZIhSSqnx48crMzMzdfLkSaVU2mmBhud60aJFJtv55ZdfFKBWrVplsvzw4cMKUHPnzk1z/zqdTiUnJ6tdu3YpwLhvpdJOCzTsP7OfJ1+ftJw8eVLZ2tqqzp07myxv3ry5KlOmTJrrWFlZqbfeeksppdTNmzcVoKZNm5aq3c8//6wAtX///gz7kFma0saNGxWgPv/8c+Myf3//NI+3Vq1aKiIiIsP9Pc3wmfXFF18opZTq1auXsre3N24nrbTA9P4usvrZu3v3bgWo8ePHZ9i3vH6dMzNo0CAFqPPnz2epfV78fVerVk0FBQWZtJs7d64C1OnTp5VSSoWGhipADR482KTdwYMHFaDGjRtnXPZ0WmBGqWVPn1MySgt8+vNw/vz5ClC//vqrSbvPP/9cAWrLli0m+/Hy8lLR0dHGZZGRkcrMzMzkb8vwvGXlJ73UxbT+3vz9/ZW5uXmqdNrsPDdZPZ9nhb+/v9JoNKm+azRv3lw5OTkZz4Vp9a9OnTrK09NTPX782LhMq9WqChUqqKJFiyqdTqeUSj8t8MiRIwpQa9asyXJ/0/Lk58bixYuVtbW1un//vtJqtapw4cJq0qRJSimVKl2vbNmyytvb+7nbz8tI0gKfQ3Xq1MHS0hJHR0fatWuHt7c3GzduxMvLy3gF8enKLa+++ir29vbG9Dk7Ozvq1q3L1q1bAQgJCaFQoUK8//77JCUlsXfvXkA/mmUYtQJYv349FSpUoEqVKmi1WuNPy5YtTdIYDJo0aYKLi0umx1SlShWsrKx46623WLp0aZqVaQy6dOmCjY2N8XdHR0fat2/P7t27SUlJISEhgW3bttG5c2fs7OxM+tmmTRsSEhL4+++/Adi4cSOlS5c2OcaceOWVV1Iti4mJYcyYMZQsWRILCwssLCxwcHAgNjaW0NDQDLe3ceNGbGxs0hxyN8jqa21QpUoVihQpYvw9MDAQ0KecPDkyaFieVqpUr169TH7v2bMnADt27DAuO378OB06dMDNzQ1zc3MsLS3p06cPKSkpXLx40WR9FxeXdFOCnlSrVi0ePXpEjx49WLt2bZrV1bZv307Tpk3x9fU1Wd63b1/i4uJS3XzdoUMHk98NIyeZpYg9+X7SarUopTLtv8Ho0aNxdXVlzJgxmbZ9+j21fv16ChUqRPv27U32X6VKFby9vU3+9q5cuULPnj3x9vY2vgbBwcEAmb73Jk2axOHDhzP9+e6779LdxtWrV2nXrh2+vr4sWLAg1eMZFT14+rHstM2u9F67+vXrG49z3759LFy4kLt379KkSZNnquw3depUY6XEjKT1d5HVz96NGzcCMGTIkAz3kR+vc27Ki7/vfv36sX//fpN0wcWLF1OzZk0qVKgA/PvZ9vTnbK1atQgMDEwzJT2vbd++HXt7+1SpVYY+Pt2nxo0b4+joaPzdy8sLT09Pk+eievXqWXo/HD58GB8fn2z1t1KlSjkeYc7O+Tyrypcvn6pISs+ePYmOjk63EmlsbCwHDx6ka9euODg4GJebm5vTu3dvbty4kWlaecmSJXFxcWHMmDHMnz/fJPMip1599VWsrKxYvnw5GzZsIDIyMs3Kff+V/bwsJC3wOfTjjz8SGBiIhYUFXl5eJpV47t+/j4WFRaq0NY1Gg7e3N/fv3zcua9asGR9//DGxsbFs3bqVJk2a4ObmRvXq1dm6dSvFixcnLCzM5IvA7du3uXz5crr3HTz9xSOrVYJKlCjB1q1bmT59OkOGDCE2NpbixYszbNgw3nvvPZO2T6cTGZYlJSURExNDTEwMWq2Wb775Jt3yzoZ+3r171ySnP6fSOs6ePXuybds2PvzwQ2rWrGksWdqmTRvi4+Mz3N7du3fx8fFJN00OsvdaA6mq1FlZWWW4/OnSyhYWFri5uZksM7wWhn2Fh4fToEEDypQpw6xZswgICMDGxoZDhw4xZMiQVMed1fdH79690Wq1/PDDD7zyyivodDpq1qzJ1KlTad68ubEPaW3P8EXg6efj6WMxpFBm9NpcvXo1VVrYjh07slxF0snJiQkTJjB8+HCTgPRpdnZ2ODk5mSy7ffs2jx49Mr4+TzO8p2NiYmjQoAE2NjZMnTqV0qVLY2dnx/Xr1+nSpUum7z0/P7908+SflF5gc+3aNRo3boyFhQXbtm1L9f5yc3PjxIkTqdaLjY0lKSnJ2N7FxQWNRpPqdQP9/SaQ+r2bXYYvl09/WXR2dqZGjRrG34OCgihXrhx169blyy+/ZNq0aTnaX0BAAIMHD+bbb79l5MiR6bZL632c1c/eu3fvYm5unubn5JPy+nXOjOFzNywsLEtVH/Pi77tXr16MGjWKJUuWMG3aNM6dO8fhw4dNqvMZtpvevrN6D21uun//Pt7e3qleG09PTywsLDJ9LkD/fDz5XDg4OFClSpUs7T+7aYHPUi3w/v37WT6fZ1V63yEM+0vLw4cPUUpl6z34NGdnZ3bt2sUnn3zCuHHjePjwIYULF+bNN99kwoQJObqf097enm7durFo0SL8/f1p1qyZSYrzk/z8/Lh06RKxsbHZTs3Mr/28LCS4eg4FBgaanPif5Obmhlar5e7duyZfupVSREZGUrNmTeOypk2b8uGHH7J79262bdtmzFtu2rQpW7ZsMX6JfDKn1t3dHVtb21T3zjz5+JOyc2W5QYMGNGjQgJSUFI4cOcI333zD8OHD8fLyonv37sZ2kZGRqdaNjIzEysoKBwcHLC0tjVeT0rt6azg2Dw+PHN1I+rSnjzMqKor169czceJEPvjgA+PyxMRE4xfDjHh4eLB37150Ol26AVZ2XuvcoNVquX//vsmJ2vBaGJatWbOG2NhYVq9ebfLBm9aXacje+6Nfv37069eP2NhYdu/ezcSJE2nXrh0XL17E398fNzc3IiIiUq1369YtIPV7Myd8fHw4fPiwybKsfDF80jvvvMOsWbMYM2YM77zzTppt0npe3N3dcXNzMyn48CTDlent27dz69Ytdu7caRytAtKcPyct/fv3z7DwjEFwcHCqkepr167RqFEjlFLs3LkzzS/vFStWZMWKFURGRpp8yTl9+jSAccTA1taWkiVLGpc/6fTp09ja2hrvF8mpP//8E41GQ8OGDTNtaxj5OHny5DPtc8KECSxatIhx48ale49Seq9/Vj57PTw8SElJITIyMsMvtXn9OmemZcuWjBs3jjVr1tCqVatM2+fF37eLiwsdO3bkxx9/ZOrUqSxevBgbGxt69Ohhsl/Q3wf39HHeunUrw/0aMiyeLjKR2ZfwzLi5uXHw4EGUUibvlTt37qDVanP0XOzatYvGjRtnqW1YWFi2Soyn9X7O6nPj4uKS5fN5VqX3HQLSDkQN/TAzM3vm96Dh808pxalTp1iyZAlTpkzB1tbW5LtCdvTv358FCxZw6tSpVGXwn9SyZUu2bNnCunXrTL5TPW/7eRlIWuB/jCEQWrZsmcnyVatWERsbaxIo1apVCycnJ2bOnElkZKRxBKBZs2YcP36cX3/9lXLlyplc1W3Xrh3//PMPbm5u1KhRI9VPbszpYG5uTu3atY2VgJ4epl+9erXJqMrjx49Zt24dDRo0wNzcHDs7Oxo3bszx48epVKlSmv00fIC2bt2aixcvZniTf1ZGNJ6m0WhQSpkUlABYsGBBlm4abt26NQkJCRlOYJid1zq3PP2B+vPPPwP/zv9lOIk+edxKKX744Ydc64O9vT2tW7dm/PjxJCUlcfbsWUD/fBgCiyf9+OOP2NnZGatqPgsrK6tU76Un022yuo2pU6dy+PBhfvvttyyv165dO+7fv09KSkqa72lDkJfWawBkmN71pJymi4WHh9OoUSNSUlLYvn17ulc1O3bsiEajSfXFfsmSJdja2pp80e7cuTPbt283qUL3+PFjVq9eTYcOHbJ9Bf1JixcvZuPGjfTo0SNLo9eGCwTpFeXJKjc3N8aMGcPvv//OoUOHsrxeVj97W7duDeira2Ykr1/nzFSrVo3WrVuzcOHCdD9/jxw5Qnh4OJB3f9/9+vXj1q1bbNiwgWXLltG5c2eTeaYM6ZlPf84ePnyY0NDQDD9nvby8sLGx4dSpUybL165dm6ptds4zTZs2JSYmhjVr1pgsNxTKyclnf16mBaYlq89Nds7nWXX27NlUF0l+/vlnHB0djQUonmZvb0/t2rVZvXq1yWuk0+lYtmwZRYsWNaY+ZuW11Gg0VK5cma+//ppChQpleWL0tNStW5f+/fvTuXPnNAsAGQwYMABvb29Gjx7NzZs302yzevXqAt/Py0BGrv5jmjdvTsuWLRkzZgzR0dHUq1fPWEGuatWq9O7d29jW3Nyc4OBg1q1bR7FixYwlxOvVq4e1tTXbtm1j2LBhJtsfPnw4q1atomHDhowYMYJKlSqh0+kIDw9ny5Yt/N///R+1a9fOdr/nz5/P9u3badu2LX5+fiQkJBiv0D59P5S5uTnNmzdn5MiR6HQ6Pv/8c6Kjo03SF2fNmkX9+vVp0KAB77zzDgEBATx+/JjLly+zbt0648l8+PDhrFy5ko4dO/LBBx9Qq1Yt4uPj2bVrF+3atTPmqvv7+xsntXR1dcXd3T3DQNLJyYmGDRvyxRdfGNvu2rWLhQsXppogMi09evRg8eLFDBo0iAsXLtC4cWN0Oh0HDx4kMDCQ7t27Z+u1zg1WVlZ8+eWXxMTEULNmTWO1wNatW1O/fn1A//6zsrKiR48ejB49moSEBObNm/fMkwW++eab2NraUq9ePQoXLkxkZCTTpk3D2dnZOEI3ceJE1q9fT+PGjfnoo49wdXVl+fLl/PXXX0yfPj3VRLEFqUePHsyYMcN4f0xWdO/eneXLl9OmTRvee+89atWqhaWlJTdu3GDHjh107NiRzp07ExQUhIuLC4MGDWLixIlYWlqyfPnyLI+4BAQEZPsiyZ07d2jcuDEREREsXLiQO3fucOfOHePjRYsWNV71L1++PAMGDGDixImYm5tTs2ZNtmzZwvfff8/UqVNN0stGjRrFTz/9RNu2bZkyZQrW1tZ89tlnJCQkpCrVnJ74+HjjPRmGCoNr1qxh/fr1BAcHM3/+/FTrPHr0yLhOcnIyoaGhfPrpp1hbW2d6L1NWDB8+nDlz5mTr9c/qZ2+DBg3o3bs3U6dO5fbt27Rr1w5ra2uOHz+OnZ0d7777LpD3r3NW/Pjjj7Rq1YrWrVvTv39/WrdujYuLCxEREaxbt45ffvmFo0eP4ufnl2d/3y1atKBo0aIMHjyYyMjIVFMElClThrfeeotvvvkGMzMzWrdubawW6Ovry4gRI9Ldtkaj4fXXX2fRokWUKFGCypUrc+jQIeNFqSdVrFgR0J+73njjDSwtLSlTpkyaF2/69OnDnDlzeOONN7h69SoVK1Zk7969fPrpp7Rp0yZH9xA7OjqmmxGTF7Lz3GT1fJ5VPj4+dOjQgUmTJlG4cGGWLVtGSEgIn3/+ucn9x0+bNm0azZs3p3HjxowaNQorKyvmzp3LmTNn+OWXX4wXtgyj799//z2Ojo7Y2NhQrFgxDhw4wNy5c+nUqRPFixdHKcXq1at59OiR8eJ2Ti1cuDDTNs7Ozqxdu5Z27dpRtWpVk8l9L126xLJlyzh58iRdunQp8P288AqmjoZIS1YnHI2Pj1djxoxR/v7+ytLSUhUuXFi988476uHDh6nazpo1SwHqzTffNFnevHnzVBXjDGJiYtSECRNUmTJllJWVlXJ2dlYVK1ZUI0aMUJGRkcZ2PFElLTMHDhxQnTt3Vv7+/sra2lq5ubmp4OBgk/0bqvd8/vnnavLkyapo0aLKyspKVa1aVW3evDnVNsPCwlT//v1VkSJFlKWlpfLw8FBBQUFq6tSpJu0ePnyo3nvvPeXn56csLS2Vp6enatu2rUkVq61bt6qqVasqa2trBRgr42Q0CeiNGzfUK6+8olxcXJSjo6Nq1aqVOnPmjPL39zeprJOe+Ph49dFHH6lSpUopKysr5ebmppo0aWJSIS2rr3V6E6Om9Ro9XeFMKX0VLHt7e3Xq1CnVqFEjZWtrq1xdXdU777yTalLRdevWqcqVKysbGxtVpEgR9f777xursj1ZPSmjSm5PV8daunSpaty4sfLy8lJWVlbKx8dHvfbaa+rUqVMm650+fVq1b99eOTs7KysrK1W5cuVU1agMVbGensTwWSaNzEh6fwdbtmwxVt96ulqgvb19mttKTk5WM2bMMD6/Dg4OqmzZsurtt99Wly5dMrbbv3+/qlu3rrKzs1MeHh5q4MCB6tixY6mOL7cmEc6s0tjTlTaTkpLUxIkTlZ+fn7KyslKlS5dONcGuweXLl1WnTp2Uk5OTsrOzU02bNlVHjx7NUr8MlfcMP/b29qp48eKqa9eu6rfffks1KaZSqasFmpubKz8/P9W1a1d1/PjxbD0vaf0tGXz//ffGfTxdLTC9v4usfvampKSor7/+WlWoUMHYrm7dumrdunXZ6v/Tsvs6Z0V8fLyaPXu2qlu3rnJyclIWFhbKx8dHdenSRf31118mbfPq73vcuHEKSHOiVKX0z+fnn3+uSpcurSwtLZW7u7t6/fXXU02QmtYkwlFRUWrgwIHKy8tL2dvbq/bt26urV6+m+XyNHTtW+fj4KDMzM5PPy6c/D5VS6v79+2rQoEGqcOHCysLCQvn7+6uxY8caK/0apPf5k9XzUHakVy0wrXOPUtl7brJ6Ps+MoT+///67Kl++vLKyslIBAQHqq6++SrW/tN4ve/bsUU2aNFH29vbK1tZW1alTJ82/q5kzZ6pixYopc3Nz43bOnz+vevTooUqUKKFsbW2Vs7OzqlWrllqyZEm2jiGrk48/XcXPIDIyUo0ZM0aVL19e2dnZKWtra1WyZEn19ttvG6tk5ud+XkYapbJRCkuIPGQoJvDFF19kOBeFyH19+/bl999/JyYmpqC7IoQQQuRIQEAAFSpUyLdJlIVIi9xzJYQQQgghhBC5QO65EkIIIZ6glMq0MI25ufkzz8P1X6XVajN83MzMLMNpJoTIrpSUlAznHNRoNJibm+djj7JPp9Oh0+kybPMsRXzE80PSAoUQQogn7Ny5M9Oy1YsXL35pJ9nMLKh84403MqyEKkR2BQQEZDjnWFpTCjxv+vbtm+n0CPKV/MUgwZUQQgjxhMePH3PhwoUM2xQrVizbJaJfFEeOHMnw8cyqrQqRXadPn041Z9aTHB0dsz0nYX67evVqphMi52dFR5F3JLgSQgghhBBCiFwgSdFCCCGEEEIIkQskuBJCCCGEEEKIXCDBlRBCCCGEEELkAgmuhBBCCCGEECIXSHAlhBBCCCGEELlAgishhBBCCCGEyAUSXAkhhBBCCCFELpDgSgghhBBCCCFygQRXQgghhBBCCJELJLgSQgghhBBCiFwgwZUQQgghhBBC5AIJroQQQgghhBAiF0hwJYQQQgghhBC5QIIrIYQQQgghhMgFElwJIYQQQgghRC6Q4EoIIYQQQgghcoEEV0IIIYQQQgiRCyS4EkIIIYQQQohcIMGVEEIIIYQQQuQCCa6EEEIIIYQQIhdIcCWEEEIIIYQQuUCCKyGEEEIIIYTIBRJcCSGEEEIIIUQukOBKCCGEEEIIIXKBBFdCCCGEEEIIkQskuBJCCCGEEEKIXCDBlRBCCCGEEELkAgmuhBBCCCGEECIXSHAlhBBCCCGEELlAgishhBBCCCGEyAUSXAkhhBBCCCFELpDgSgghhBBCCCFygQRXQgghhBBCCJELJLgSQgghhBBCiFwgwZUQQgghhBBC5AIJroQQQgghhBAiF0hwJYQQQgghhBC5QIIrIYQQQgghhMgFElwJIYQQQgghRC6Q4EoIIYQQQgghcoEEV0IIIYQQQgiRCyS4EkIIIYQQQohcIMGVENn0+PFjRo8eTYsWLfDw8ECj0TBp0qRM11NK0bBhQzQaDUOHDk31eEREBH379sXT0xMbGxsqVarEwoUL8+AIUps5cyZdunShWLFiaDQaGjVqlKX1JkyYgEajoUKFCqkeS0pK4qOPPqJYsWJYWVnh7+/P2LFjiY+Pz+XeCyGEeNHOTRcvXmTUqFFUr16dQoUK4erqSr169fj9999Ttb1x4wbDhw8nODiYQoUKodFoWLJkSZrblXOTyGsSXAmRTffv3+f7778nMTGRTp06ZXm9OXPmcPny5TQfi4qKon79+mzbto3p06ezdu1aqlWrxsCBA/nqq69yqefpmz9/PteuXaNJkyZ4eHhkaZ0TJ04wY8YMvLy80ny8R48efPHFF7z11lts2LDBeCzdunXLza4LIYTgxTs3bdmyhb/++otXXnmF3377jeXLl1OqVCleffVVpkyZYtL28uXLLF++HCsrK9q0aZPhduXcJPKcEkJki06nUzqdTiml1N27dxWgJk6cmOE6YWFhysHBQa1evVoBasiQISaPT5s2TQHqyJEjJstbtGih7O3t1cOHD3PzEFJJSUkx/r98+fIqODg4w/bJycmqSpUqatiwYSo4OFiVL1/e5PEDBw4oQH355Zcmyz/99FMFqC1btuRa34UQQrx456a7d+8aj+dJbdu2VXZ2diohIcG47Mlz2OHDhxWgFi9enGpdOTeJ/CAjV0Jkk0ajQaPRZGudt956i+bNm9O5c+c0H9+3bx9eXl5Ur17dZHm7du2IjY1l06ZN6W5bKUWbNm1wc3MjPDzcuDwuLo7y5csTGBhIbGxshv0zM8veR8Fnn33GgwcP+OSTT9J8fN++fQCpriC2a9cOgFWrVmVrf0IIITL2op2b3N3d0zyeWrVqERcXx4MHD4zLsnoOk3OTyA8SXAmRxxYsWMChQ4f49ttv022TlJSEtbV1quWGZadOnUp3XY1Gw08//YSdnR2vvfYaycnJAAwePJiwsDB+/fVX7O3tn/Eo/nXu3DmmTp3KvHnzcHBwSLNNUlKSSf8NsnI8Qggh8t5/9dy0Y8cOPDw88PT0zPa6cm4S+UGCKyHy0M2bNxk1ahTTp0/Hx8cn3XblypXjxo0bJlf3APbu3Qvoc+kz4ubmxooVKzh69CijR49m8eLFLF26lG+++YaKFSs++4H8j06no3///nTp0iXDvPZy5coB/14lNMjq8QghhMg7/9Vz04IFC9i5cycTJkzA3Nw82+vLuUnkBwmuhMhDgwYNonLlyrz55psZtnvrrbewtLSkV69enD17lvv37zNnzhxWrlwJZC3loV69enzyySfMnDmTd955h9dff50BAwbkynEYfPXVV1y6dImZM2dm2K5169aULFmSMWPGEBISwqNHj9i0aRPjxo3D3Nw822mIQgghcs9/8dy0ceNGhgwZQteuXXn33XezvT7IuUnkD3kXCZFHfv/9dzZt2sT06dOJiori0aNHPHr0CNCnJjx69MiYJhEYGMgff/zBtWvXqFChAu7u7nz++ed8+eWXABQpUiRL++zVqxdWVlYkJiby/vvv5+rxhIeH89FHHzFx4kSsrKyMx6PVatHpdDx69MhYytbKyoqNGzfi5+dHixYtcHFxoWvXrowbNw4XF5csH48QQojc9V88N23evJkuXbrQvHlzli9fnu17ywzk3CTygwRXQuSRM2fOoNVqqVOnDi4uLsYfgB9++AEXFxf++usvY/vWrVtz7do1Ll68yLlz5wgLC8PNzQ2Ahg0bZrq/lJQUevXqhYuLC35+fgwYMMCYX54brly5Qnx8PO+9957J8ezbt4/Q0FBcXFwYO3assX3JkiU5cOAAN27c4NSpU9y5c4dXX32Ve/fuZel4hBBC5L7/2rlp8+bNdOrUieDgYFatWoWVlVU2j9iUnJtEXrMo6A4I8aLq27dvmpPxNm7cmE6dOvHee++lmnxXo9FQqlQpQH8FcdasWVSpUiVLH/gTJ05kz549bNmyBXt7exo2bMj777/PrFmzcuV4qlSpwo4dO1ItHz58OFFRUSxevJiiRYumerxIkSLGq4ETJkzA3t4+19MVhRBCZM1/6dy0ZcsWOnXqRP369VmzZk2axTVySs5NIq9IcCVEDmzcuJHY2FgeP34M6CvoGWaNb9OmDXZ2dgQEBBAQEJDm+kWKFEl1cnv33Xdp1KgRbm5uXLlyhdmzZ3Pjxg127dqVaX9CQkKYNm0aH374IU2bNgVg2rRpjBo1ikaNGqVbZtfgyJEjXL16FYDo6GiUUsbjqVmzJv7+/hQqVCjNE3KhQoXQarWpHps+fTre3t74+flx+/Ztfv31V9asWcNPP/0kqRdCCJEHXqRz0969e+nUqRPe3t6MGzeOEydOmDxerlw5nJycjL8bjvPKlSuA/rxmqGjbtWtXYzs5N4k8V8DzbAnxn+Tv76+ANH/CwsIyXJc0JmpUSqmOHTuqwoULK0tLS+Xt7a369u2rrl69mmlfbt26pTw9PVWTJk1MJlLU6XSqffv2qlChQpn26Y033kj3eNKaiPFJaU0irJRSkydPViVKlFDW1taqUKFCqlWrVmr37t2ZHo8QQoiceZHOTRMnTkz3WAC1Y8eOVP1P7+dJcm4SeU2jlFJ5HcAJIYQQQgghxItOCloIIYQQQgghRC6Q4EoIIYQQQgghcoEEV0IIIYQQQgiRCyS4EkIIIYQQQohcIMGVEEIIIYQQQuQCCa6EEEIIIYQQIhfIJMJp0Ol03Lp1C0dHRzQaTUF3RwghXipKKR4/foyPjw9mZnIN0EDOTUIIUTCyc16S4CoNt27dwtfXt6C7IYQQL7Xr169TtGjRgu7Gc0POTUIIUbCycl6S4CoNjo6OgP4JdHJyKuDeCCHEyyU6OhpfX1/jZ7HQk3OTEEIUjOyclyS4SoMh3cLJyUlOYEIIUUAk9c2UnJuEEKJgZeW8JMnsQgghhBBCCJELJLgSQgghhBBCiFwgwZUQQgghhBBC5AK55yqHlFJotVpSUlIKuitCCJGvzM3NsbCwkHuihBBCiKdIcJUDSUlJREREEBcXV9BdEUKIAmFnZ0fhwoWxsrIq6K4IIYQQzw0JrrJJp9MRFhaGubk5Pj4+WFlZydVbIcRLQylFUlISd+/eJSwsjFKlSslEv0IIIcT/SHCVTUlJSeh0Onx9fbGzsyvo7gghRL6ztbXF0tKSa9eukZSUhI2NTUF3SQghhHguyOXGHJIrtUKIl5l8BgohhBCpyciVEEKIXLP7xm62h2+nTuE6tCrWqqC7I4QQQrDw9EIiYyPpXKoz5dzK5em+5NKjyFU7d+5Eo9Hw6NGjLK8TEBDAzJkz86xPInM5ed2eV5MmTaJKlSrZWqdRo0YMHz481/uyZMkSChUqlOvbfZ6duHOCVZdWcfT20YLuihBCCAFAyLUQVlxYQWRsZJ7vS4Krl0jfvn3RaDQMGjQo1WODBw9Go9HQt2/f/O9YJvr27UunTp1ydZs5+QKe1x4+fEjv3r1xdnbG2dmZ3r175zjYiY+Px8XFBVdXV+Lj43O3o2k4e/Ysr7zyCgEBAWg0mnSD5blz51KsWDFsbGyoXr06e/bsyfO+vWiUUkyaNAkfHx9sbW1p1KgRZ8+ezXS9VatWUa5cOaytrSlXrhx//PGHyeOTJk1Co9GY/Hh7e2e7f3fi7gDgaeeZ7XWFEEKIvHA77jYA3vbZP69llwRXLxlfX19WrFhh8oU7ISGBX375BT8/vwLs2YsjKSkpR+v17NmTEydOsGnTJjZt2sSJEyfo3bt3jra1atUqKlSoQLly5Vi9enWOtpEdcXFxFC9enM8++yzdL+QrV65k+PDhjB8/nuPHj9OgQQNat25NeHh4nvfvRTJ9+nS++uorvv32Ww4fPoy3tzfNmzfn8ePH6a5z4MABunXrRu/evTl58iS9e/fmtdde4+DBgybtypcvT0REhPHn9OnT2e7f3fi7AHjYeWR7XSGEECK3Jackcz/+PiDBlcgD1apVw8/Pz+QL9+rVq/H19aVq1aombRMTExk2bBienp7Y2NhQv359Dh8+bNJmw4YNlC5dGltbWxo3bszVq1dT7XP//v00bNgQW1tbfH19GTZsGLGxsVnq76RJk1i6dClr1641Xk3fuXMnADdv3qRbt264uLjg5uZGx44dTfa/c+dOatWqhb29PYUKFaJevXpcu3aNJUuWMHnyZE6ePGnc5pIlS7LUn7QYRtamTZuGj48PpUuXzvY2QkND2bRpEwsWLKBu3brUrVuXH374gfXr13PhwoVsb2/hwoW8/vrrvP766yxcuDDV41l53bKjZs2afPHFF3Tv3h1ra+s023z11VcMGDCAgQMHEhgYyMyZM/H19WXevHnZ2teYMWMoXbo0dnZ2FC9enA8//JDk5OR02xten8mTJ+Pp6YmTkxNvv/12qiBYp9MxevRoXF1d8fb2ZtKkSan6X7FiRezt7fH19WXw4MHExMSYtFmyZAl+fn7Y2dnRuXNn7t+/n61jy4xSipkzZzJ+/Hi6dOlChQoVWLp0KXFxcfz888/prjdz5kyaN2/O2LFjKVu2LGPHjqVp06apRhgtLCzw9vY2/nh4ZD9AMo5c2crIlRBCiIJ3O+42CoWVmRUu1i55vj8JrnKBUoq4JG2B/Cilst3ffv36sXjxYuPvixYton///qnajR49mlWrVrF06VKOHTtGyZIladmyJQ8ePADg+vXrdOnShTZt2nDixAkGDhzIBx98YLKN06dP07JlS7p06cKpU6dYuXIle/fuZejQoVnq66hRo3jttddo1aqV8Wp6UFAQcXFxNG7cGAcHB3bv3s3evXtxcHCgVatWJCUlodVq6dSpE8HBwZw6dYoDBw7w1ltvodFo6NatG//3f/9ncpW+W7duae7fcC9SZsHHtm3bCA0NJSQkhPXr1wMwaNAgHBwcMvwxjNocOHAAZ2dnateubdxmnTp1cHZ2Zv/+/Vl6rgz++ecfDhw4wGuvvcZrr73G/v37uXLlivHxrLxu4eHhmfY9rfTS9CQlJXH06FFatGhhsrxFixbZPj5HR0eWLFnCuXPnmDVrFj/88ANff/11husYXp8dO3bwyy+/8McffzB58mSTNkuXLsXe3p6DBw8yffp0pkyZQkhIiPFxMzMzZs+ezZkzZ1i6dCnbt29n9OjRxscPHjxI//79GTx4MCdOnKBx48ZMnTrVZB979uzJ9Hn99NNP0z2OsLAwIiMjTZ5Ha2trgoODM3weDxw4kOq5b9myZap1Ll26hI+PD8WKFaN79+4m75uskpErIYQQzxPDfVZe9l75MjetVAvMBfHJKZT7aHOB7PvclJbYWWXvZezduzdjx47l6tWraDQa9u3bx4oVK4wjQgCxsbHMmzePJUuW0Lp1awB++OEHQkJCWLhwIe+//z7z5s2jePHifP3112g0GsqUKcPp06f5/PPPjdv54osv6Nmzp7FYQKlSpZg9ezbBwcHMmzcv0/lxHBwcsLW1JTEx0STdbNmyZZiZmbFgwQLjH8rixYspVKgQO3fupEaNGkRFRdGuXTtKlCgBQGBgoMl2DVfpM2JnZ0eZMmWwtLTMsJ29vT0LFizAysrKuGzKlCmMGjUqw/V8fHwAiIyMxNMz9ZV+T09PIiOzd/PlokWLaN26NS4u+qszrVq1YtGiRcYv+ll53Xx8fDhx4kSG+3Fycspyn+7du0dKSgpeXl4my728vLJ9fBMmTDD+PyAggP/7v/9j5cqVJoHO06ysrFi0aBF2dnaUL1+eKVOm8P777/Pxxx8bS4pXqlSJiRMnAvr36bfffsu2bdto3rw5gEnBi2LFivHxxx/zzjvvMHfuXABmzZpFy5YtjYFq6dKl2b9/P5s2bTKuV6NGjUyfV1dX13QfMzxXaT2P165dy3C9zJ772rVr8+OPP1K6dGlu377N1KlTCQoK4uzZs7i5uWXYZ4PElESiEqMAuedKCCHE8yE/77cCCa5eSu7u7rRt25alS5eilKJt27a4u7ubtPnnn39ITk6mXr16xmWWlpbUqlWL0NBQQJ/KVqdOHZOrAHXr1jXZztGjR7l8+TLLly83LlNKodPpCAsLMwl4ssOwXUdHR5PlCQkJ/PPPP7Ro0YK+ffvSsmVLmjdvTrNmzXjttdcoXLhwtvZTq1Ytzp8/n2m7ihUrmgRWoA+M0gqY0pPW1RSlVLausqSkpLB06VJmzZplXPb6668zYsQIJk+ejLm5eZZeNwsLC0qWLJnl/WbV08eS3eMD+P3335k5cyaXL18mJiYGrVabaaBXuXJlk0m/69atS0xMDNevX8ff3x/QB1dPKly4MHfu3DH+vmPHDj799FPOnTtHdHQ0Wq2WhIQEYmNjsbe3JzQ0lM6dO5tso27duibBla2tbZaf1+XLl/P2228bf9+4cSPm5uZAzp7HzNYxXEQB/fu5bt26lChRgqVLlzJy5Mgs9flunH7UysrMCierrAffQgghRF4xjFx520lw9Z9ha2nOuSktC2zfOdG/f39jat6cOXNSPW5IN8zoC1lWUhJ1Oh1vv/02w4YNS/XYsxTQ0Ol0VK9e3SRoMzDcJ7J48WKGDRvGpk2bWLlyJRMmTCAkJIQ6derkeL/psbe3T7Vs0KBBLFu2LMP1zp07h5+fH97e3ty+fTvV43fv3k014pCRzZs3G+9Fe1JKSgpbtmyhdevWWXrdwsPDKVcu43kgXn/9debPn5+lfrm7u2Nubp5qlOrOnTvZOr6///6b7t27M3nyZFq2bImzszMrVqzgyy+/zPI2nvTk+/vp0UmNRoNOpwPg2rVrtGnThkGDBvHxxx/j6urK3r17GTBggPF+r6w8r3v27DEJYtIybtw4xo0bR4cOHUzSRIsUKUJERASgH4l68kJBZs+jt7d3tp97e3t7KlasyKVLlzLs75OeTAnMj9QLIYQQIjNPpgXmBwmucoFGo8l2al5BM9ybBPp7L55WsmRJrKys2Lt3Lz179gQgOTmZI0eOGNOjypUrx5o1a0zW+/vvv01+r1atGmfPnn2mURArKytSUlJSbXflypXGAgXpqVq1KlWrVmXs2LHUrVuXn3/+mTp16qS5zdyWnbTAunXrEhUVxaFDh6hVqxagv4cnKiqKoKCgLO9z4cKFdO/enfHjx5ss/+yzz1i4cCGtW7fO0uuW22mBVlZWVK9enZCQEJPRnZCQEDp27Jjl7ezbtw9/f3+T48soHc7g5MmTxMfHY2trC+iP18HBgaJFi2Zpv0eOHEGr1fLll18a0wh//fVXkzblypVL9Tw+/Xt20gIdHR1TjcwWK1YMb29vQkJCjAVokpKS2LVrl0la59Pq1q1LSEgII0aMMC7bsmVLhu+txMREQkNDadCgQYb9fZKhmIWXXf6cwIQQQojMRMb9b+RKq82X/f23IgKRawzpYYb/P83e3p533nmH999/H1dXV/z8/Jg+fTpxcXEMGDAA0I/MfPnll4wcOZK3336bo0ePpqq6N2bMGOrUqcOQIUN48803jelTISEhfPPNN1nqa0BAAJs3b+bChQu4ubnh7OxMr169+OKLL+jYsSNTpkyhaNGihIeHs3r1at5//32Sk5P5/vvv6dChAz4+Ply4cIGLFy/Sp08f4zbDwsI4ceIERYsWxdHRMc0qd4cOHaJPnz5s27aNIkWKZOcpzlZaYGBgIK1ateLNN9/ku+++A+Ctt96iXbt2lClTJkvbuHv3LuvWrePPP/+kQoUKJo+98cYbtG3blrt372bpdctuWmBSUhLnzp0z/v/mzZucOHECBwcH43ZGjhxJ7969qVGjBnXr1uX7778nPDw8W4UxSpYsSXh4OCtWrKBmzZr89ddfqeZrSq9/AwYMYMKECVy7do2JEycydOhQY6CUmRIlSqDVavnmm29o3749+/btSzVqN2zYMIKCgpg+fTqdOnViy5YtJimBkL20wLRoNBqGDx/Op59+SqlSpShVqhSffvopdnZ2xosgAH369KFIkSJMmzYNgPfee4+GDRvy+eef07FjR9auXcvWrVvZu3evcZ1Ro0bRvn17/Pz8uHPnDlOnTiU6Opo33ngjy/0zpAVKMQshhBDPi9sxtwDw3vU1FG4IvjXzdodKpBIVFaUAFRUVleqx+Ph4de7cORUfH18APXs2b7zxhurYsWO6j3fs2FG98cYbxt/j4+PVu+++q9zd3ZW1tbWqV6+eOnTokMk669atUyVLllTW1taqQYMGatGiRQpQDx8+NLY5dOiQat68uXJwcFD29vaqUqVK6pNPPjE+7u/vr77++ut0+3Xnzh3j+oDasWOHUkqpiIgI1adPH2P/ihcvrt58800VFRWlIiMjVadOnVThwoWVlZWV8vf3Vx999JFKSUlRSimVkJCgXnnlFVWoUCEFqMWLF6e57x07dihAhYWFpdu/zJ7XrLp//77q1auXcnR0VI6OjqpXr14mz6NS+udq4sSJaa4/Y8YMVahQIZWUlJTqseTkZOXq6qq+/PJLpVTWXrfsCAsLU0Cqn+DgYJN2c+bMUf7+/srKykpVq1ZN7dq1y+TxiRMnKn9//wz39f777ys3Nzfl4OCgunXrpr7++mvl7Oxsso3KlSsbfze8Ph999JFxvYEDB6qEhARjm+DgYPXee++Z7Ofpv4evvvpKFS5cWNna2qqWLVuqH3/8MdVztnDhQlW0aFFla2ur2rdvr2bMmGHSt9yg0+nUxIkTlbe3t7K2tlYNGzZUp0+fNmkTHBxs0nellPrtt99UmTJllKWlpSpbtqxatWqVyePdunVThQsXVpaWlsrHx0d16dJFnT17Nt1+pPVZ+OWRL1WFJRXUZwc/e6ZjzOgz+GUmz4sQQmRT1E3VcHFFVWFJBXV+WmGlzvyRs81k4/NXo1QOanm/4KKjo3F2diYqKipV6lNCQgJhYWEUK1Ys00p3QuSm+Ph4XF1d2bBhA40bNy7o7uSJvn37AjzTvGNpbfPRo0epUiHFs0nrs3DsnrGsv7KekdVH0q9CvxxvO6PP4JeZPC9CCJENt06Q+Et3arjr76neW38mziWa5mhT2fn8lbRAIf4jdu3aRZMmTV7YwAr0x7h79+6C7obIIUkLFEII8VwIXQ+r3+S2SgJ8sDG3wql4k3zZtQRXQvxHtGrVilatWhV0N/JUWFhYQXdBPIM78fqCFp62MseVEEKIAqAU7J8NIRMBRWTxOqBu4W3vk29VbLN2N3cemjt3rjGtpHr16uzZsyfD9rt27aJ69erY2NhQvHjxVDeVJycnM2XKFEqUKIGNjQ2VK1dOdVO5EOLlsWTJEkkJzCcyciWEEKLAaJPgz3ch5CNAQc2B3K77DpB/ZdihgIOrlStXMnz4cMaPH8/x48dp0KABrVu3Jjw8PM32YWFhtGnThgYNGnD8+HHGjRvHsGHDWLVqlbHNhAkT+O677/jmm284d+4cgwYNonPnzhw/fjy/DksIIV46cclxxCTHAOBpJyNXQggh8lH8Q1jWBY7/BBozaPU5tJlB5P/mX8yvCYShgIOrr776igEDBjBw4EACAwOZOXMmvr6+zJs3L8328+fPx8/Pj5kzZxIYGMjAgQPp378/M2bMMLb56aefGDduHG3atKF48eK88847tGzZMseTjAohhMicYY4rOws77C1TT6othBBC5In7/8CCZnB1D1g5QI8VUGcQaDT5PoEwFGBwlZSUxNGjR2nRooXJ8hYtWrB///401zlw4ECq9i1btuTIkSMkJycD+okvn67iZ2trazKfy9MSExOJjo42+RFCCJF1d/93dVBGrYQQQuSbq/tgQVO4fxmcikL/zVC6pfFh4wTC9i/ByNW9e/dISUnBy8s0kvTy8iIyMjLNdSIjI9Nsr9VquXfvHqAPtr766isuXbqETqcjJCSEtWvXEhERkW5fpk2bhrOzs/HH19f3GY9OCCFeLoaRK7nfSgghRL448TP82FGfElikOry5HbwrmDQxjFy9NGmBQKrKHUqpDKt5pNX+yeWzZs2iVKlSlC1bFisrK4YOHUq/fv0wNzdPd5tjx44lKirK+HP9+vWcHo4QQryUjMUsbCW4EkIIkYd0Otg6Gda8A7pkKNcJ+v4FjqlT/27H3QZekpErd3d3zM3NU41S3blzJ9XolIG3t3ea7S0sLHBzcwPAw8ODNWvWEBsby7Vr1zh//jwODg4UK1Ys3b5YW1vj5ORk8iOEECLrjGXYJS1QCCFEXkmKg9/7wt6v9L83GAVdF4Olbaqm8dp4ohKjgJckuLKysqJ69eqEhISYLA8JCSEoKCjNderWrZuq/ZYtW6hRowaWlpYmy21sbChSpAharZZVq1bRsWPH3D0AIYQQRi/ayFV2pgmJiIigZ8+elClTBjMzM4YPH56qzQ8//ECDBg1wcXHBxcWFZs2acejQoTw8AiGEeME8joQlbeHcWjCzhE7zoemHYJZ2OGNICbSzsMPB0iHfulmgaYEjR45kwYIFLFq0iNDQUEaMGEF4eDiDBg0C9Ol6ffr0MbYfNGgQ165dY+TIkYSGhrJo0SIWLlzIqFGjjG0OHjzI6tWruXLlCnv27KFVq1bodDpGjx6d78f3vOnbty8ajcb4/D5p8ODBaDQa+vbta1wWGRnJu+++S/HixbG2tsbX15f27duzbds2Y5uAgAA0Gg0rVqxItc3y5cuj0WhYsmSJyfLjx4/z6quv4uXlhY2NDaVLl+bNN9/k4sWLuXasQoj8Zbjn6kUYucruNCGJiYl4eHgwfvx4KleunGabnTt30qNHD3bs2MGBAwfw8/OjRYsW3Lx5My8PRQghXgyRp+GHpnDrGNi6wht/QpUeGa8S+28xi/yaQBgKOLjq1q0bM2fOZMqUKVSpUoXdu3ezYcMG/P39Af3VwCdPZsWKFWPDhg3s3LmTKlWq8PHHHzN79mxeeeUVY5uEhAQmTJhAuXLl6Ny5M0WKFGHv3r0UKlQovw/vueTr68uKFSuIj483LktISOCXX37Bz8/PuOzq1atUr16d7du3M336dE6fPs2mTZto3LgxQ4YMSbXNxYsXmyz7+++/iYyMxN7etCTz+vXrqVOnDomJiSxfvpzQ0FB++uknnJ2d+fDDD/PgiIUQ+cFQLfBFKGiR3WlCAgICmDVrFn369MHZ2TnNNsuXL2fw4MFUqVKFsmXL8sMPP6DT6UwuVgkhhEjDxc2wqBVE3wC3UjBwK/inneX2pKfvtzLUachrFvmylwwMHjyYwYMHp/nY0yMeAMHBwRw7dizd7QUHB3Pu3Lnc6t4Lp1q1aly5coXVq1fTq1cvAFavXo2vry/Fixc3tjOMZB06dMgkQCpfvjz9+/c32WavXr34+uuvuX79urHS4qJFi+jVqxc//vijsV1cXBz9+vWjTZs2/PHHH8blxYoVo3bt2jx69CgvDlkIkceUUsa0wP/6yJVhmpAPPvjAZHlG04TkRFxcHMnJybi6uubaNoUQ4oWiFPw9D7aMB6WDYg3htR/B1iVLqz85crUt9Dbf777C4n41sbPK2/CnwKsFvhCUgqTYgvnJQRTer18/k5GmRYsWmQRMDx48YNOmTQwZMiTVyBOQahTQy8uLli1bsnTpUkD/pWHlypWpgrDNmzdz7969dFM0ZXRRiP+mx8mPSUhJAP7791zlZJqQnPjggw8oUqQIzZo1S7eNzMEohHhpJcfDH4Ng81h9YFXtDXh9dZYDK/g3uLp+x5KBPx7hYNgDFu4Jy6seGxX4yNULITkOPvUpmH2PuwVWqQOgjPTu3ZuxY8dy9epVNBoN+/btY8WKFezcuROAy5cvo5SibNmyWd5m//79+b//+z/Gjx/P77//TokSJahSpYpJm0uXLgFka7tCiOefYdTKycoJGwubTFr/N2R3mpDsmD59Or/88gs7d+5MNen9k6ZNm8bkyZNzZZ9CCPGf8fAarHwdIk+BxhxafAx1BkM2P4MjYvTB1Z5QLUpBr9p+DGpUIi96bEJGrl5C7u7utG3blqVLl7J48WLatm2Lu7u78fGn5w7LirZt2xITE8Pu3btTjYQ9vV0hxIvlRSpmkZNpQrJjxowZfPrpp2zZsoVKlSpl2FbmYBRCvHT+2Q7fB+sDKzt36LMG6g7JdmB1LyaRIzf/N0qldWZyh/JM7VQBS/O8D31k5Co3WNrpR5AKat850L9/f4YOHQrAnDlzTB4rVaoUGo2G0NBQOnXqlKXtWVhY0Lt3byZOnMjBgwdN7qkyKF26NADnz5+nbt26Oeq3EOL5Yyxm8R9PCQTTaUI6d+5sXB4SEvLMU3p88cUXTJ06lc2bN1OjRo1M21tbW2Ntbf1M+xRCiP8EpWDv17D9Y30aoE816PYTOBfN9qZCI6IZuPQIiZ4P0ACftG/Aa1UCcr3L6ZGRq9yg0ehT8wriJ4dpKq1atSIpKYmkpCRatmxp8pirqystW7Zkzpw5xMbGplo3vcIT/fv3Z9euXXTs2BEXl9Q5sS1atMDd3Z3p06enub4UtBDiv8kwcvUiVAqE7E8TAnDixAlOnDhBTEwMd+/e5cSJEybFlaZPn86ECRNYtGgRAQEBREZGEhkZSUxMTL4emxBC3I27S1xyXEF341+Jj+HX3rBt8v/ur+oD/TbmKLDacjaSV+bt52b0IzTm+nuB25YPzO0eZ0hGrl5S5ubmhIaGGv//tLlz5xIUFEStWrWYMmUKlSpVQqvVEhISwrx584zrPikwMJB79+5hZ5f2aJq9vT0LFizg1VdfpUOHDgwbNoySJUty7949fv31V8LDw9OcL0sI8Xx7USoFGnTr1o379+8zZcoUIiIiqFChQobThABUrVrV+P+jR4/y888/4+/vz9WrVwH9Z2pSUhJdu3Y1WW/ixIlMmjQpT49HCCEMrkZdpeu6rlTzrMb3Lb4v6O7A3YuwshfcuwjmVtDmC6jeN9ubUUoxb9c/fLH5AkpB9ZJwEXC0dMTeMnu1CZ6VBFcvMScnp3QfK1asGMeOHeOTTz7h//7v/4iIiMDDw4Pq1aunO9cLgJubW4b77NixI/v372fatGn07NmT6OhofH19adKkCVOnTs3xsQghCs6LlBZokN1pQjK7p9QQZAkhREHaGr6VxJREDkQcICImgsIOhQuuM6Hr9RUBkx6Do48+DbBo5inTT0tITmHc6tOsPq6flL13HX+aVX/I0O3gZf/s98pmlwRXL5G0vhA8ac2aNSa/Fy5cmG+//ZZvv/023XUy+8KQVqpfjRo1WLVqVYbrCSH+O16kghZCCPEi23dzn/H/28K38Xq51/O/E7oU2PEJ7PlS/7t/PXh1CThk/xxy53ECb/90lOPhjzA30zCpfTl61w1g9aXVwL8TCOcnuedKCCHEM3nR7rkSQogXUWxyLCfunDD+vi18W/53Iu4B/Pzav4FVncHQZ22OAquzt6Lo9O0+joc/wsnGgqX9atG7bgBgOoFwfpORKyGEEDmmUzpjWqCnrYxcCSHE8+pQxCG0SouLtQsPEx9y7M4xHiQ8wNXGNX86EHkaVvSCR9fAwhY6fAOVXs3RpjadiWTEyhPEJ6dQ3N2eBW/UoLiHw7+7+l9w5WWX/2mBMnIlhBAix6KTotHqtAC427pn0loIIURB2XdLnxLYIqAFga6B6JSOXdd35c/OT/0KC5rrAyuXABi4NUeBlVKKOTsuM2jZUeKTU2hQyp0/BtczCaygYEeuJLgSQgiRYw/jHwLgauOKpbllAfdGCCFEegz3W9XzqUcTvyZAPqQGpiTDxg9g9ZugjYeSzeGtneBdIdubSkhOYfjKE3yx+QIAfYMCWNy3Js52qc89kXESXAkhhPgPup9wH3iiUmDMHVj+Gjy8VoC9EkII8aTw6HBuxNzAQmNBrcK1aOrXFIADtw4Qm5x6TtNc8fg2LO0AB/9XZbrhaOi5EmxTz4WamTvRCXT7/m/WnriFhZmGTzpXYFKH8liYpw5llFL/jlzZSXAlhBDiP+RBwgPgf8UsHl2Hxa3h0mb4423IpDy5EEKI/GFICaziWQV7S3tKFiqJv5M/Sbok9tzck/s7vH4Yvg+G8P1g5Qjdf4Ym48Es9dyqmTlzM4qOc/Zx8vojnG0t+XFALXrV9k+3/ePkx8Rr44GCKcUuwZUQQogcMwRXnmY2sKgV3L8Mzn7QcQ5oNAXcOyGEyHuRsZF0/bMrf1z6o6C7kq79N/cDUK9IPQA0Go0xNXD7te25tyOl4Mgi/YW2xxHgXgbe2gFl2+ZocxtPR9B1/n4iohIo4WHP2iH1CCqR8f29hlErZ2tnbC1sc7TfZyHBlRBCiBx7EP+/4Or8Roi+AW6loP9GcCtRwD0TQoj8EXIthAsPLzD35NxMJxQvCMkpyRyKPATo77cyMKQG7r65m6SUpFzYUQL8+S6sHwG6ZAjsAG9uA/dS2d6UNkXHtI2hvLP8GAnJOhqW9mD14HoEuNtnum5BpgSCBFdCCCGewYOoqwB4xD8G74rQbyM4Fy3YTgkhRD4Kjw4H9F/qz90/V8C9Se3E3RPEaeNwtXGljGsZ4/KK7hXxsPUgNjmWgxEHn20nj8L1o1XHfwKNGTSbDK/9CNaO2d7UnccJvL7wIN/tugLAgPrFWPRGDZxts1Y06XbcbaBgilmABFdCCCFySpvAgztnAPB0KQFvrAcHj+fyyq0QQuSV8Mfhxv8XyMS8mdh7cy8AQT5BmGn+/epvpjF79qqBSsGxn2BePbh1DGxd4fXVUH94jlLDD199QLvZe/n7ygPsrcyZ07MaH7Yrl2bhivQUZBl2kODqpdK3b180Gg0ajQZLS0u8vLxo3rw5ixYtQqfTZXk7S5YsoVChQnnXUSHE8y/hMcTc5cH/ziIebb4G20JcfxBHl3n7uXT7ccH2Twgh8olh5Aqez+Bq/y39/VZBPkGpHjMEVzuu7yBFl5K9DUdHwM+vwZ9DITEaitbSl1kv0TjbfVRKsWDPFbp//zd3HidSytOBtUPr07ZS4WxvqyAnEAYJrl46rVq1IiIigqtXr7Jx40YaN27Me++9R7t27dBqtQXdPSHEf0HcA4i+jkLx0NwCAE8nPy7fecyr8w9wPPwR4/44LSNYQogXXnJKMrdibwGgQcOVqCuERYUVcK/+dS/+HucfnAfSDq5qetfE0cqRBwkPOHH3RNY2qpR+UuC5deDSFjC3huZToP8mcEm/il96YhK1DPn5GFP/CiVFp+hQ2Yc1Q+pR0tMh85XTcDtW0gJFPrK2tsbb25siRYpQrVo1xo0bx9q1a9m4cSNLliwB4KuvvqJixYrY29vj6+vL4MGDiYmJAWDnzp3069ePqKgo4yjYpEmTAFi2bBk1atTA0dERb29vevbsyZ07dwroSIUQeSL2HjzSz2Gls7JDoU8tuXXfnNe++5vI6ARKeTrwTY9qaKRaoBDiBXcr9hY6pcPG3Ia6PnUB2B6ei9X3ntGBWwcACHQNxM3WLdXjlmaWNCraCMjiqFvMXVj5un5S4IRH4FMV3t4N9d7LUZn1i7cf0+HbvWw4HYmluYbJHcozq3sV7K0tsr0tg4KcQBgkuMoVSinikuMK5Cc3rgw3adKEypUrs3r1agDMzMyYPXs2Z86cYenSpWzfvp3Ro0cDEBQUxMyZM3FyciIiIoKIiAhGjRoFQFJSEh9//DEnT55kzZo1hIWF0bdv32funxDiOfH4NkRd1//fxgWdtRMATpau9FpwmAexSVQq6syvb9fF29mmADsqhBD541q0/mKTr5Ovsfre8xRcGea3MpRgT8uT/c7we+XZNTC3NpxfD2aW0HgCDAgBz7I56tvaEzfp+O0+rtyNxdvJhhVv1eWNoIBnujCnlPp35KqAqgXmPCzMJXPnzuWLL74gIiKC8uXLM3PmTBo0aJBu+127djFy5EjOnj2Lj48Po0ePZtCgQSZtZs6cybx58wgPD8fd3Z2uXbsybdo0bGzy5mQfr42n9s+182TbmTnY8yB2lnbPvJ2yZcty6tQpAIYPH25cXqxYMT7++GPeeecd5s6di5WVFc7Ozmg0Gry9Td+0/fv3N/6/ePHizJ49m1q1ahETE4ODQ86GdoUQzwGl9POVxOhPWDh4gaULKbcfAfAg2obYRC21i7my4I0aONpkraKTEEL8111/rL/g5OfoRxO/Jkz9eyqn7p3iduztApnA9kk6pTOOXKWVEmgQVCQIG3Mbbsbc5MLDC5R1fSpYinsAG96HM7/rf/eqAJ3mQeFKOepXklbHJ3+dY+kBfWBar6Qbs7tXxc3BOkfbe1JUYhQJKQkAeNp7PvP2cqJAR65WrlzJ8OHDGT9+PMePH6dBgwa0bt2a8PDwNNuHhYXRpk0bGjRowPHjxxk3bhzDhg1j1apVxjbLly/ngw8+YOLEiYSGhrJw4UJWrlzJ2LFj8+uw/pOUUsYrBTt27KB58+YUKVIER0dH+vTpw/3794mNjc1wG8ePH6djx474+/vj6OhIo0aNANJ9PYUQ/wFKQfTNfwMrx8Lg5AMaDQnaZABSkh1pWtaTpf1rSWAlhHipGIpZ+Dn54W7rTiUPfcCx4/qOguwWAKEPQnmQ8AA7CzuqeFRJt52tha0x+EqVGnhhk/7eqjO/g8YcGoyCN3fkOLC69Siebt8fMAZWQxuX5Mf+tXMlsIJ/UwJdbVyxNs+dbWZXgY5cffXVVwwYMICBAwcC+hGnzZs3M2/ePKZNm5aq/fz58/Hz82PmzJkABAYGcuTIEWbMmMErr7wCwIEDB6hXrx49e/YEICAggB49enDo0KE8Ow5bC1sO9nzG+QGeYd+5ITQ0lGLFinHt2jXatGnDoEGD+Pjjj3F1dWXv3r0MGDCA5OTkdNePjY2lRYsWtGjRgmXLluHh4UF4eDgtW7YkKSkXJqYTQuQ/pfRzl/xvomCci4K9BwAP45KITdJ/JgQ4F2Z+z+pYZqNUrhBCvAgMZdj9HP0AfYrdybsn2Ra+je5luxdk19h/U18lsFbhWliaZ3zhq6l/U7Zf38628G0MqTIEEqJg01g4sVzfwL0MdJ4HRarnuD97L91j2IrjPIhNwsnGgq+7VaFpYO6O7hV0pUAowOAqKSmJo0eP8sEHH5gsb9GiBfv3709znQMHDtCiRQuTZS1btmThwoUkJydjaWlJ/fr1WbZsGYcOHaJWrVpcuXKFDRs28MYbb6Tbl8TERBITE42/R0dHZ+tYNBpNrqTmFZTt27dz+vRpRowYwZEjR9BqtXz55ZeYmem/KP36668m7a2srEhJMS3Xef78ee7du8dnn32Gr68vAEeOHMmfAxBC5D6lg4dX9SdYgEL+YOcKwN3HCdyJTgD0Uzh0rBgogZUQ4qX0ZFog6IOrr45+xZHII0QlRuFs7VxgfTPeb+WT/v1WBsFFgzHXmHPp4SXCT6/AL2SKPmsBDQQN1d9fZZmz22t0OsXcnZf5MuQiSkF5Hyfm9aqOn1vuf3cu6EqBUIBpgffu3SMlJQUvL9PI0svLi8jIyDTXiYyMTLO9Vqvl3r17AHTv3p2PP/6Y+vXrY2lpSYkSJWjcuHGqIO5J06ZNw9nZ2fhjCA5eRImJiURGRnLz5k2OHTvGp59+SseOHWnXrh19+vShRIkSaLVavvnmG65cucJPP/3E/PnzTbYREBBATEwM27Zt4969e8TFxeHn54eVlZVxvT///JOPP/64gI5SCPFMdCnw4Mr/AisNuBQDO1eUUkRGxRMRpc9nt/hfYSivAsprF0KIgqTVabn5+CagTws0/FuyUEm0SsvuG7sLrG8xSTGcvHMSyFpw5WztTE3PagBs2zpKH1i5FteXV28xNceBVVRcMgN/PMKMLfrAqlsNX1a9E5QngRUUfKVAeA6qBT5dEeTJe3+y2v7J5Tt37uSTTz5h7ty5HDt2jNWrV7N+/foMv+iPHTuWqKgo48/169dzejjPvU2bNlG4cGECAgJo1aoVO3bsYPbs2axduxZzc3OqVKnCV199xeeff06FChVYvnx5qhTNoKAgBg0aRLdu3fDw8GD69Ol4eHiwZMkSfvvtN8qVK8dnn33GjBkzCugohRA5ptPC/X8g8TFozPQnV9tCKKW49SiBO4/1o/zujtaYafSfvx62HgXZYyGEKBARMRFolRZrc2s87f69yPQ8VA08FHkIrdLi5+iHr1MWBg2u7qVp2GEAttnZQa23YNBe8KuT4z6cuRlFu2/3sP38HawszPj8lYp83rUSNpbZL9meVS91WqC7uzvm5uapRqnu3LmTanTKwNvbO832FhYWuLnpa/d/+OGH9O7d23gfV8WKFYmNjeWtt95i/PjxxlS3J1lbW2NtXTA3veWnJUuWGOeyysiIESMYMWKEybLevXub/D5v3jzmzZtnsqxHjx706NHDZJlMIirEf0hKsj6w0sbrb1x2LQ7WDuiU4ubDeB7G6e+fLFLIFnsLxUWlTw9+8kuFEEK8LAz3W/k6+mKm+ff7ZVO/pnx36jv23dpHgjYBG4v8n5pi/y39LTYZVQkEICkOtk2Bg/NobG7OJ35FOGljzd1Go/Gwss/x/lceDufDtWdJ0urwdbVlXq/qVCiS9ymShuDqpRy5srKyonr16oSEhJgsDwkJISgo7TdC3bp1U7XfsmULNWrUwNJSf6NeXFxcqgDK3NwcpZR80RdCiPRok+D+JX1gZWYBbiX1gZVOEX4/jodxSWjQ4Odqh5uDNTqlQ6f091x52MnIlRDi5fNkcPWksq5l8bH3IV4bbwxy8pNSir039wIZz2/F9UMwvz4c1F8s96r8OpVcywE5r3aYkJzC6N9PMmbVaZK0OpqW9WT90Ab5EljBSx5cAYwcOZIFCxawaNEiQkNDGTFiBOHh4cZ5q8aOHUufPn2M7QcNGsS1a9cYOXIkoaGhLFq0iIULFxonsQVo37498+bNY8WKFYSFhRESEsKHH35Ihw4dMDfPu2FIIYT4z0qO/19glaifGNKtFFjZkaJTXL0fS3RCMmYaDf5udhSyswL09xoAmJuZU8i6UAF2XgghCoaxDPv/ilkYaDQamvg1AdIobZ4f/Xoczs2Ym1iYWVDLu1bqBskJEPIRLGoJD/4BRx/otQo6zKZJgL5wXE76HX4/ji5z9/PrkRuYaeD9lmX4oU8NnO3yZ4oOpRS34wq+oEWBlmLv1q0b9+/fZ8qUKURERFChQgU2bNiAv78/ABERESZzJBUrVowNGzYwYsQI5syZg4+PD7NnzzaWYQeYMGECGo2GCRMmcPPmTTw8PGjfvj2ffPJJvh+fEEI89xIfw4MwUClgbg1uJcDCGm2Kjqv344hL0mKm0RDgZo+Dzb+njBSdPiXQzcbNJB1GCCFeFsYy7E5+qR5r4teEZaHL2HVjF1qdFguz/PvKve+mvkpgVc+qqatZ/7MDNn0Ad8/rf6/cA1pNA1sXQJ/SOPPYTA5FHCI6KRonK6cs7XPj6QjGrDpFdIIWV3srZnevSv1S7rl2TFnxIOEBybpkNGjwtC24dPUCDa4ABg8ezODBg9N8LK37g4KDgzl27Fi627OwsGDixIlMnDgxt7oohBAvprgH+nmsUGBpr7/HytyC5BQdYfdiSUhOwcJMQ4C7PXZWpqeLlP/db+Vi41IAHRdCiIL35ATCT6vmWQ0XaxceJj7k6O2j1C5cO9/6leb9VncvQsiHcHGT/nd7D2g/C8q2NVk3wDmAkoVKcvnRZXZd30X7Eu0z3Nfdx4lM/PMMG07r0/Gq+hVibq9qFHbOnXlYs8NQKdDN1i3Teb3yklxuFEKIl41S8Pg2PLoGKLBx1t9jZW5BkjaFf+7GkJCcgqW5GcU9HFIFVgDJOv0Ewm62bvnceSGEKHgpuhRuxNwAUqcFgj5lupFvIyB/UwOTU5I5FHkIgPpF6usvom0YDfPq6gMrMwuoPQiGHEoVWBkYUhozqnaolGLtiZu0+HoXG05HYm6mYWjjkqx8q26BBFbwxP1WdgWXEggSXOWYFMcQQvwnKQVRN+DxLf3v9h76eazMzEhITuGfu7EkaXVYWZhRwsM+3ZK5KSkpKBQu1jJyJYR4+UTERqDVabE0s0y37PeTJdnz63vj8TvHidfG42bjRunzW2F2FTj0nX6ajdKtYfDf0Ppz46TwGfXbUO3wabejE3jzxyO8t+IED+OSCSzsxNoh9RjVsgxWFgUXWjwPxSzgOUgL/K95siqhrW3BROZCCJEjuhR4eA0So/S/OxUBB31eelySlqv3YtHqFDaW5hRzt8fSPP2TZEJCAlqdFkdbx/zouRBCPFcM91sVdSyKuVnaF6Hq+NTB1sKW23G3OXf/HOXdy+d5vwz3WwVFP8Bsy3j9Qq8K0PITKN4oS9sIdA3Ex96HW7G32H9rv3EkSynFb0dv8PH6czxO0GJprmFYk1IMalQiw/NFfnkeilmABFfZZm5uTqFChbhz5w4AdnZ2GU56LIQQz4WUZP2IlTYe0OgDKwsnSEggJiGZW1EJKKUPrHwcrEhJTiIlOfVmlFLExcVx9+5ddt/fTZ0yOZ9gUggh/quuR18HwN/RP9021ubW1C9Sn5BrIWwL35b3wVXEKfad+Qk0EPToLth7QpMJUPV1SCcATIuh2uGy0GVsC99GE78m3HwUzwerTrHn0j0AKhd1ZnrXypTxfn4usD0PEwiDBFc54u2tj4gNAZYQQjzXUpIh9q4+LURjpk8FjL0P3Cc2UcujuGQUYGNphoW9FdejM79gtP/BftbfXU/7Khnf7CyEEC8i4xxXTr4Ztmvq19QYXA2rNixvOvM4ErZ/zL1Tv3DBrwgAdSv3g+CxYJ2z4MdY7fD6LpYe+IfpGy8Rm5SClYUZ/9e8NAPqF8PiORitetLtWBm5+s/SaDQULlwYT09PkpPTuLQrhBDPi4hTsH6EPhXQ0Qc6zAaXAHQ6xcJ9Yaw4dBOAluW9GdG8dJZSOywtLRl4YiAKhaddwZW7FUKIgpLeHFdPa1i0IRZmFlyJukJYVBjFnIvlXieS42H/t7D3a0iOZb+DPQCBziVwa/HpM226mmc1nK1ciEp6yJSQ9aQklaSGvwufd61ECQ+H3Oh9rpN7rl4A5ubmMjGxEOL5FboOVg0EbQL4VIWey8DBk0RtCmN+O8W6k/qiFiObl+bdJiWznOKcoE0gOikaAA87jzzrvhBCPK+Mc1xlElw5WjlS27s2+27tY1v4NgZWHPjsO1cKTv8OWydBtL5iIUVrsq9oANw+SP3/3SOVUyk6xdL94Ty8Wwoz50PYOJ9jVNMO9KkbgLnZ83krjE7puBOnzygr6ODq+RrPE0IIkTv+ng8re+sDq9KtoO9f4ODJo7gkei88xLqTt7Aw0zDj1coMa1oqW/eO3o2/C4CNuQ2Ols9Pvr0QQuSHFF0K1x/r77lKa46rp2WltHmWhR+EBc1g9UB9YOXsC68sRNd/MwceXQSemt8qmy7fieG17w4wZf05EqLLAeDhfYk3gvyf28AK4H78fbRKi5nGDHfb/J28+GkSXAkhxItEp4PN42HTGEBBjf7QbTlY2XP9QRyvzNvPobAHOFpbsLR/LbpWL5rtXdyN0wdXHnYeUtBHCPHSuRN3h2RdMhZmFlkaJWni1wQNGk7fO228LyjbHl6D3/rBohZw8whYOUCTD2HoYajYldCH53mY+BB7S3sqe1bO9ua1KTrm7fyHNrP3cPTaQxysLfioaQfsLOy4n3CXs/fO5qzf+cSQEuhu646FWcEm5klaoBBCvCiSE+CPt+HcGv3vTSdC/RGg0XDqxiP6LznMvZgkCjvbsLhfTcp6O+VoN4bUCw9bSQkUQrx8jGXYHYpm6Yu8u607lT0qc+LuCXZc30H3st2zvrOEaNj7FRyYCymJgEZf/a/Jh+D4b1W8/Tf3A1DLuxaWZpbZOp7zkdGM/v0Up27op+loWNqDaV0qUqSQLaeTGrD56ma2hW+jokfFbG03P0XGPR/3W4GMXAkhRJ6JTormXvy9/NlZ3AP4qZM+sDKzhC4/QIORoNGw9dxtun33N/dikggs7MQfg+vlOLCCf4MrKWYhhHgZXYu+BoCvY8aVAp9kSA3cFr4taytoE+HwAvimmr5gRUoiFGsIg/ZAx29NAiuAvTf3AlDPp16W+5ScomPW1ku0/2Yvp25E4WRjwRddK7G0X02KFNLP5WqYUHhb+LZ8mwg5J4zFLOwKPriSkSshhMgDybpkuq/vzr34e/zQ4gcqe2Q/TSPLHl6FZV3h/iWwdobuy/QnYeCnA1eZ+OdZdEp/NXJur2o4WD/bR7/hnispZiGEeBkZ7rfyd0p/jqunNfVryldHv+JI5BGiEqNwtnZOu2FKMpxYDrtnQJR+P7iWgBZToUxrSCMVOyYphlN3TwEQVCRr91uduRnF+7+fIjRCX5yoWaAXn3SugJeTjUm7BkUaYGlmydXoq1yJukKJQiWyeMT563kpww4yciWEEHli7429XH98nXhtPMO2D+NmzM282dHNY7CguT6wcioK/TdBsYbodIppG0L5cK0+sOpe05eFb9R45sAKnhi5spWRKyHEy8dQhj07I1d+Tn6ULFQSrdKy+8bu1A1StHB8GXxTHda9pw+sHLyh9Rcw+G8o2ybNwArgYORBtEqLv5N/pn2KTdQyfdN5Os7ZR2hENC52lszqXoUf+lRPFVgBOFg5UKewfrL4LI+6FQBDWmBBTyAMElwJIUSe+OPyHwBYaCx4kPCAIVuHGMuX55qLW2BJW4i9A14VYGAIeJUjITmFd1cc57vdVwAY1aI007pUzNIcVlkhI1dCiJeZsQx7FioFPunJFDujFC2cXAFzasLaIfDoGth7QqvP4L0TUPstsLDKcLuG+60yqhKYnKJj2d/XCP5iJ3N3/kOKTtG2UmFCRgbTsUqRDIsTpdnv58zzMscVSHAlhBC57l78PeOVyTnN5uBp58k/Uf8wcudIknW5NPH40SXwS3dIjoPijaHfRnDy4WFsEr0XHuSvUxFYmmv4ultlhjbJXqn1zBiqBco9V0KIl41O6f4tw57JHFdPMwQp+27uIz4pRj9X1dw6+kJED66Anbs+/e+9k1DnHbC0zXSbSin23doHpH2/lVKKTWciafn1biasOcO9mET8XO2Y/3p15vSshruDdab7aOTbCDONGefunyMiJiJbx5xfJLgSQogX2Pp/1pOiUqjkXokgnyDmNJ2DrYUtByMOMvXvqc92U7BSsO1jfdqISoEqvaDXb2DjRPh9fan1w1cf4mijL7XeuWr2S61nRgpaCCFeVnfi7pCYkoiFxgIfB59srVvWtSw+9j4kpCRwYFEwrBqgT+m2dYFmk/RBVdC7YGWX5W2GPw7nZsxNLMwsqOld0+SxI1cf0HX+AQYtO8qVe7G42lsxqX05to4MplWFrAchbrZuVPGoAsD267kwV1cu0+q0xuJRElwJIcQLRinFmstrAOhUqhOgP6HOCJ6BmcaM1ZdWs+jMopxtPO4B/NID9szQ/x78AXScA+aWnLj+iM5z93HlXixFCtmy6p0ggkrk/kSKscmxxGnjACnFLoR4+RhGrXwcfLI3n5JOhyZ0HU0e6Uf+t2kfgI0zNJkA753ST5th7ZDt/hiqBFbzrIadpT4ou3znMW/+eISu8w9w9NpDbC3NebdJSXa934i+9YphZZH9r//Pc2rgvfh7pKgULDQWuNm4FXR3pFqgEELkptP3TvNP1D/YmNvQKqCVcXnDog0ZXXM0nx36jJnHZuLr6EuLgBZZ3/CNI/oJJKPCwdwK2n2tn+sE2HI2kmErjpOQrKO8jxOL+9bEM40bk3ODYdTKwdLBeCIXQoiXhbGYhVMWi1koBRc2ws5PIfI0TWysWVbYi13Ormj7b8HC7tmCgf23/r3f6nZ0AjO3XmTl4evoFJhpoFtNP0Y0K/XM54Sm/k354sgXHL19lAcJD3C1cX2m7eUmQ0qgh50H5mbmBdwbCa6EECJXGQpZNPNvhqOVo8ljvQJ7cf3xdZaHLmfc3nF42XtlXqJdKfh7HoR8BLpkcCkGry2Fwvr1lu6/yqR1Z1EKGpXxYE7PatjnQkXA9Bjut5JiFkKIl9G1x/o5rjK930opuBSiD6puHdcvs3KkWs23cbm7mYeJURyNukztZwiuklKSOBx5GIAr4UVp9OtO4pNTAGhezosxrcpQ0tMxo01kWRGHIgS6BhL6IJRd13fRuVTnXNlubnieJhAGSQsUQohcE6+NZ2PYRgA6l0z7xPN+jfcJLhpMYkpi5iXa4x/Bytdh81h9YFWuI7y9CwpXRqdTfPLXOSb+qQ+setTyZUGfGnkaWAHciZcy7EKIl9f16EzmuFIKLm+DBc3g51f1gZWlPdQfCcNPYd70Qxr5ZnNC4XQcijhKvDYeUhxZvieZ+OQUqvkV4rdBdfmhT41cC6wMsj0Rcj4xznH1HEwgDBJcCSFErtl6bSuxybEUcShCDe8aabYxNzNnesPpBLoGZlyi/eYx+K4hnF+vTwNs/QW8uhRsnPWl1n85zg97wgB4v2UZPu1cEYtcKrWeERm5EkK8zAxl2FPNJ6UUXNkJi1rBsi5w8whY2ELQMBh+CppNBDt9Kp3h/qXt4dtzVOBIKcW6k7cY8edKAJIfl6K4uwPzX6/OqneCqBmQNyl7hn4fuHWA2OTYPNlHTjxPlQJBgishhMg1hpTATiU7YaZJ/+PVztKOb5p8k3aJdqXg4HewsIV+vpNC/tB/s36uE42GezGJvL7gIH+d1pdan9W9CkMal8zVUusZMdxzJcGVEOJlo5RKuwz7tQOwpB382BGu/w0WNlBniD6oavEx2JsWF6rjUwc7Cztux93m7P2z2erD/n/u0XHOPt795Tix5ucA6BLYhM0jGtKqgneengtKFiqJn6MfSbokYyGN58HtOP3IlZd9wU8gDM9BcDV37lyKFSuGjY0N1atXZ8+ePRm237VrF9WrV8fGxobixYszf/58k8cbNWqERqNJ9dO2bdu8PAwhxEvu+uPrHI48jAYNHUt0zLS9l71X6hLt8Y/gtzdg42h9GmDZdvD2bihSDdCfVFvP2sORaw9xsrHgx/616VilSB4fmSnDBMKSFiiEeNncjb9LvDYeM40ZRRyKwK0TsKwrLG4F1/bqswxqvQ3DTkCrT8Eh7c9Ja3Nr6hepD+hHr7LifGQ0/RYfoucPBzl1Iwp721jMbSLQoGFUw/a5Nkl8RjQazXNZNdA4ciVpgbBy5UqGDx/O+PHjOX78OA0aNKB169aEh4en2T4sLIw2bdrQoEEDjh8/zrhx4xg2bBirVq0ytlm9ejURERHGnzNnzmBubs6rr76aX4clhHgJrb28FoA6hetQ2KFwltYp61qWLxp+8W+J9qUN4dxaMLOEVp9Bt2VgW4gUnWLW1ku8vuAgdx8nUsrTgdWDg6hbIv9Lzr4saYHZufAXERFBz549KVOmDGZmZgwfPjzNdqtWraJcuXJYW1tTrlw5/vjjjzzqvRAiLxgqBfrYemC5aiB8HwyXQ8DMAqr30wdVbaaDU+bngKzev3TrUTyjfjtJ61l72HHhLhZmGvrU9WfsK/qqeIFugflauc/Q7903dpOUkpRv+82IpAU+4auvvmLAgAEMHDiQwMBAZs6cia+vL/PmzUuz/fz58/Hz82PmzJkEBgYycOBA+vfvz4wZM4xtXF1d8fb2Nv6EhIRgZ2cnwZUQL4gbj28Yb159XqToUlj7jz64ym4FpeCiDRnt1QCAmbaKLe5++jTAOu+ARsOdxwn0XniQr7deRKfgtRpF+XNo/Vy/UTmrXoYJhLN74S8xMREPDw/Gjx9P5cppV388cOAA3bp1o3fv3pw8eZLevXvz2muvcfDgwbw8FCFELrp+W1/1z+/+NTi3BtBAxddgyCFoPxOcs55J0LBoQyzMLLgSdYWwqLBUj9+JTmDq+nM0nrGT34/eQCloU9GbkJHBTOlYgVMP9J8d9Xzq5cKRZV0lj0p42HoQmxzLwYiC//xK1iUbJxB+6dMCk5KSOHr0KC1amM7z0qJFC/bv35/mOgcOHEjVvmXLlhw5coTk5OQ011m4cCHdu3fH3t4+3b4kJiYSHR1t8iOEeP5EJUbx6rpXeW39a2kXgSggByMOEhkbiaOVo/GqXpYkPobf+9PrwE/0jHoMwDhnK07+r+Lfvsv3aDNrL/v/uY+dlTlfvVaZ6V0rY2tVMPN4KKWMaYEv8gTC2b3wFxAQwKxZs+jTpw/Ozs5ptpk5cybNmzdn7NixlC1blrFjx9K0aVNmzpyZh0cihMgVjyPhr1GE7/oUAN/k/6Vtv7MfXvkB3Epke5OOVo7U9q4NmI5e3XwUz0drz1B/+g4W7A0jUaujVjFX/hgcxNxe1Snmbo9O6fj71t8A1CuSv8GVmcbsuaoaeDfuLgqFpZnlczP3VoEFV/fu3SMlJQUvL9Mo08vLi8jIyDTXiYyMTLO9Vqvl3r17qdofOnSIM2fOMHDgwAz7Mm3aNJydnY0/vr5ZnBhOCJGvTt87TUxyDA8SHvDTuZ8KujtGhkIWbYu1xdrcOmsrRZ6G74Lh7Gows2B09REEF21Ioi6JYduHMXnjXl5feJB7MYmU9Xbkz6H16VKtaB4eReaik6JJTEkEXty0wJxc+MuK9C4OZrRNufAnRAGLewAhE2FWFTj8A+Hm+mIRftXfgu7LwavcM23eEKRsD9/O1XuxjPn9FMHTd/DjgWskaXVU8yvE4n41WflWHar6uRjXC70fysPEh9hb2lPJo9Iz9eFZ+r3j+g5SdCn5vv8nGVICPe08MywklZ8KvBdPVzVRSmVY6SSt9mktB/2oVYUKFahVq1aGfRg7dixRUVHGn+vXr2e1+0KIfHT63mnj/3869xNRiVEF2Bu9qMQo4w3JWUoJVAqOLtHPgfLgH3AqCv02Yl7vPaY3/IISzqV5kPCAldcnojTx9Kjly5oh9Sjp6ZC3B5IFhpRAZ2vnrAeR/zE5ufCXFeldHMxom3LhT/wXKKWYf3I+H+37iO3h20nQJhR0l55d4mPYNR1mVYZ9M0EbD0VrEe5VBgA/36Bc2U0TvyZo0HD63mmazlrLyiPX0eoUQSXc+PnN2qx6J4jGZTxTfcfdd2sfALW9a2NpZpkrfcmOmt41cbRy5EHCA07ePZnv+3/S83a/FUDezjaZAXd3d8zNzVOdWO7cuZPqBGTg7e2dZnsLCwvc3Exv7I6Li2PFihVMmTIl075YW1tjbf1iflEQ4kVy9p6+ZK0GDbHJsSw9u5Rh1YYVaJ82hG0gSZdEaZfSBLoGZtw4MQbWj4DTv+p/L9UCOn9nnPvkSFgs4ee6o/Ocibn1HSpXX8uUTouwNCuYNMCnGYtZvMApgQbZvfCXF9scO3YsI0eONP4eHR0tAZZ47oRFhzHnxBxAP4pva2FL/SL1aebXjIZFG+JgVfAXhrIsOQGOLIQ9X0Lcff0yrwrQ5ENUqRaE/1IXAD8nvww2kjVnbkYxZ8c1tHF+mNtdw8zhHA09OzC0SUmq+2ec3rbvpj64yu+UQANLM0uCiwaz/sp6toVvo5pXtQLpB0Bk3PMXXBXYyJWVlRXVq1cnJCTEZHlISAhBQWlfEahbt26q9lu2bKFGjRpYWppG7r/++iuJiYm8/vrrudtxIUSBUEoZR676VugLwPLQ5TxMeFiAvYI/LulTAjuX7Jzxl+/b5+CHxvrASmMOzSZDj5Vg54o2RccXm8/zxuJDPIi2wzthCDbmtlyJOaEv0Z6DSSbzwp34F7+YRU4u/GVFehcHM9qmtbU1Tk5OJj9CPG8ORxwGwMvOCx97H+K18YRcC2HMnjE0XNmQwVsHs/rSah4kPCjgnmYgJRmOLIbZVWHzOH1g5VoCui6Ct/dAmVbcT3xAnDYODRqKOuQ8RfvotYf0X3KYdt/sZeOZSJIflwegRrmbLO5XK9PA6nHSY+NoUZBP7oyg5cSTJdkL8hxlKHD1vJRhhwJOCxw5ciQLFixg0aJFhIaGMmLECMLDwxk0aBCgv2rXp08fY/tBgwZx7do1Ro4cSWhoKIsWLWLhwoWMGjUq1bYXLlxIp06dUo1oCSH+myJjI3mQ8AALjQXvVH6HQNdA4rRxLDm7pMD6dP7BeUIfhGJhZkHb4hnMpXd8GfzQBO5dBEcf6PsX1B8OZmZERiXQ84eDzNnxD0pBr9p+/PV2N2YEP1Gi/cyifDumjLwMI1c5ufCXFeldHHyWbQrxPDgUeQiArqW7sumVTaxst5I3K75JMediJOuS2XNzDxP3T6Txr43pv7k/y0OXG1O5CpxOB6d+g29rwvrh8PiWPlW7wzf6CoAVXgEz/Vdlw+TBhe0LY2Vula3dKKU48M99ei34m1fm7Wf7+TuYaaBjFR8WdO0LwPmHJ7KU6n4o4hApKoUApwCKOhbcfbhBPkHYmNtwM+YmFx5eKLB+GN5Lz0ulQCjAtECAbt26cf/+faZMmUJERAQVKlRgw4YN+Pv7A/q5Q54sfVusWDE2bNjAiBEjmDNnDj4+PsyePZtXXnnFZLsXL15k7969bNmyJV+PRwiRdwyjVqVcSmFrYcuQKkMYun0ov5z/hT7l+uBmm/8XUtZcXgNAY9/GuNi4pG6QFAt/jYKTP+t/L9EUunwP9u4A7Lxwh5G/nuRBbBIO1hZM61KR9pV9AAj2DWZ0zdF8dugzZh6bia+jLy0CWqTeRz56Gcqwg/7CX+/evalRowZ169bl+++/T3Xh7+bNm/z444/GdU6cOAFATEwMd+/e5cSJE1hZWVGunP6G9/fee4+GDRvy+eef07FjR9auXcvWrVvZu3dvvh+fELlFKcWR20cAqOVdC41GQzm3cpRzK8ewasO48ugKW8O3svXaVkIfhHI48jCHIw/z2aHPqOhekaZ+TWnm3wx/J//87jhc2ADbp8Kdc/pl9h7QYBTU6AcWqW8VuRZ9DQBfp6yn5iql2HXxLt9uv8yRa/osCwszDV2qFeGdRiUp5q6vZF3ydEkuP7rM7hu7aV+ifYbbNNxvVZCjVgB2lnYE+QSx/fp2toVvo6xr2QLphzEt8DkauSrQ4Apg8ODBDB48OM3HlixZkmpZcHAwx44dy3CbpUuXfm7SaIQQuePM/TMAVHCvAOjnCKngVoEz98+w+MxiRtVMPYKdl5JSklh/ZT2gTwlM5eo+WPce3L8EGjNoPB7qjwQzM5JTdHy55SLzd/0DQHkfJ+b0rEaAu+mUEb0CexEeHc7P539m3N5xeNl7Udkj7XmU8oOhDPuLHlxl98IfQNWqVY3/P3r0KD///DP+/v5cvXoVgKCgIFasWMGECRP48MMPKVGiBCtXrqR27dr5dlxC5LbLjy7zIOEBtha2VHSvmOrx4oWK81aht3ir0lvcjLnJtmvb2Ba+jeN3jnP63mlO3zvNzGMzKVmoJM38m9HMrxmlXUo/8/2NGQrbA1snws2j+t9tnKHee1DrbbBO//4wwwTC/o6ZB4I6nSIk9Dbfbr/M6Zv60SgrCzO61fDl7eDiFHWxM2nf1K8plx9dZlv4tgyDK6UU+2/pK4wW1P1WT2rq39QYXA2pMqRA+iAFLYQQIofO3DMNrjQaDYOrDGbwtsGsvLCSvhX64m7rnm/92Xl9J1GJUXjaeppeQYx/CCEfwbH/jWo4eEPXhRBQH4Bbj+J595fjHP3fVcw+df0Z1yYQG8u0i1aMrjmamzE32XVjF8O2D+Pntj9TxCHrE1XmJmNa4Atahv1J2b3wl5ULel27dqVr167P2jUhnhuGlMAqHlWwNM+4al0RhyL0Kd+HPuX7cC/+HtvD9V/KD0Uc4vKjy1x+dJn5J+dT1KEozfyb0dSvKZU8KuVeee2oG7B5/P8m/wUs7fSTtQe9C7ZpZB48xZAWmFExixSd4q/TEczZfpkLt/VzF9pamtOrth9vNiyOl5NNmus19WvKd6e+Y9/NfcRr47G1sE2z3bXoa9yMuYmlmSU1vGpk2ue8Flw0GHONOZceXuJ69PVsjerlhqSUJOO9fM9TcFXgpdiFECIzKboUzt3Xp24YgiuA+kXqU8mjEgkpCSw8vTBf+2SY26pDyQ6Ym5nr00xO/67P3TcEVtX7wZCDxsBqW+ht2szew9FrD3G0tmBur2pM6Vgh3cAKwNzMnOkNp1PWtSwPEh4wZOuQAptA2VjQwvbFHrkSQmTN4Uh9MYtahTOe8uZp7rbuvFbmNb5r/h07u+3k0/qf0sS3Cdbm1tyIucGSs0vovbE3zX9rbtxHjmkTYfcM/WfzuTX6TIKaA+G9k9D0oywFVgDhj/UjV76OqQOI5BQdvx25TrOvdjHsl+NcuP0YB2sLhjQuwd4xjZnQrly6gRVAWdey+Nj7kJCSYByZSoshJbCaZzXsLO3SbZdfnK2dqeGtD/IKYkLh23H6YhbW5tYUsi6U7/tPjwRXQojn3tXoq8Qmx2JrYUtx5+LG5RqNxpiK8OuFX433BOW1yNhI4wmwU8lO8PAaLO8KqwZA7F1wLwP9NkH7mWBbiOQUHZ9uCGXA0iM8ikumYhFn1g+rT5uKhbO0PztLO75p8g2etp78E/UPI3eOJFmXnHcHmAad0nEvTj9Z+8swciWEyJhO6Yz3W9X0rpnj7ThbO9O+RHtmNZnF7m67+arRV7Qp1gYHSwfuxN/hl/O/5LyTF7fA3Dqw/WNIjgO/IHh7N7T9EhyyfpFIKWVMC/Rz/HfkKjlFx69HrtP0y128//spwu7FUsjOkpHNS7NvTBPeb1kWN4fMp/rRaDQmEwqnx1CCPajI81MI58mqgfnNWMzCzitvU0mzSYIrIcRzz5ASGOgaiIWZaTZz3cJ1qeZZjSRdEgtOL8iX/qz7Zx06paOaZ1X8T6/Vn7wvbwVzK/29VYP2gL9+PpQbD+N47bsDfL/7CgB9gwL4/Z26+LvZZ7SLVLztvfm26bfYWthyMOIg807My/XjysjDhIdolRYNmgIpHiKEeL5cfHiRqMQo7CzsKOdWLle2aWdpR3P/5nze8HNmN5kNwKm7p7K/oQdh8HN3+PlVeHBFn57dZQH02wDeqe8Ny8zDxIfEJMegQYOvk68+qDp8nSZf7mT076cIfxCHu4MVH7Quy94xTRjWtBTOdtmb3NcQXO28vhOtTpvq8aSUJGMwW8+n4O+3Mmjiq+/3ibsnjKnj+eV5vN8KJLgSQvwHGCoFPpkSaPDk6NXvF3/P8xK/SiljlcDON85DyIf6K6L+9eGd/RA82lhpatOZSNrO3svx8Ec42lgw//XqTOpQHmuLnE0KHOgWyPja4wEIuRaSSevcZShm4WrjiqVZ9r40CCFePIci9PdbVfOqliefCeXdymOmMeN23G3jXEaZSoqD7Z/AnNpwcSOYWejvqXr3CFR6FXI4umEYtfKy82LtsTv6oGrVKa4/iMfdwYrxbQLZPboxg4JL4GCds3IG1Tyr4WLtQnRSNEdvH031+LE7x4jXxuNh60Fpl9I52kde8LL3opJ7JQB2XN+Rr/s2pAVKcCWEENl09t5ZgDSrUYE+37+md02Sdcn8cOqHPO3LsRv7CH8cjp1OR4tbF8GmEHT4FvquB/dSAERExTPop6MMWnaUqPhkKhd1ZsOwBrSq8OwngMZ+jdGg4Wr01XxLg4SXpwy7ECJrjPdbeWfvfqussrO0o1Qh/Weq4QJbupSCc3/CnFqwezqkJELxRvoLXi2mgrXjM/UlLEpfhv3eI8c0g6o3GxbHzurZasSZm5nTyLcRkHaK3f6b+lT0uj51n6sUOPh31C2/UwOfTAt8nkhwJYR4riWlJHH+4XkAyruXT7fd4Mr6ym6rL6/mVsytvOnMhU38sVE/11HL2DjsKnSFoUegWm/QaEjRKRbvC6PZl7vYdDYSczMN7zQqwW+DgvB1zZ2bj52snIzziTzzjd7Z8DJVChRCZEyr05rMb5VXKnnoR0QyTA28exF+6gy/9oao6+DsC6/9BL3XgEeZZ9p/coqOlYfD+WTLHgDiYl1wd7BiQttA9oxukitB1ZMM9y9tD9+eqgKpoZjF85QSaGDo96GIQ/lacMkwoikjV0IIkQ0XH15Eq9NSyLoQRR3Sn42+hncNaheujVan5ftT3+duJx5Hwq9vELuiO1ss9Se8zkFj4ZUF4KAPNk7fiKLTnH1MXneO2KQUqvoVYv279RnTqixWFrn7UWv4MpOfwZWhUqCHrQRXQrzszj84T0xyDI6Wjnk6eawxuLqXRnCV+Bi2fAjz6sKVHWBuDQ1Hw5BDUK5DjlMA4d+gqvGMnYxZdZqYFP0ISZMS+qBqYIPi2FrlLL07I3V86mBnYcftuNucvX/WuPxu3F0uPryIBg11ferm+n6fVYBzACWcS6BVWnZd35Vv+zVOICzBlRBCZJ0hHaS8e/lMUyEM916tvbzWOCfJM9Hp4Mgi+LYWnFvDZgcH4s3MCHD0o0rVNwGISdQyed1ZOs7Zy+mbUTjaWPBJ5wqsGhREYGGnZ+9DGgyVuQpi5ErSAoUQhvmtqntV109FkUcM9/KcvXf23yIPSsGp3+CbGrB/Nui0ULo1DPkbmowHq5xnCTwdVN14GI+7gzVFPeMA6Fqpap4EVQbW5tbUL/K/qTueSLEzVKct51YOF5uslY7Pb838mwH5ez+wpAUKIUQOGCcPdktdzOJpVT2rUs+nHlqVC6NXd0JhcWtYPwISo8CnGn+U1I8YdSrVBdAXrGj25S4W77uKTkGHyj5s+79getX2x8ws73Liq3lVw0xjRvjj8Dwv4GEgaYFCCANDcPUsJdizIsA5AEdLRxJSErj08BJEnoHFbWD1QIiJBJdi0PNX6LkCXItnvsF0JKfoWHEodVClT/9rTLzSp5/lxyS5aZU2N5Rgr1fk+UsJNGgR0ALQ9zUmKSbP95egTeBR4iPg+Ru5yr1EUSGEyAOZFbN42uAqg9l3ax//z955h0dRdXH43ZbeSA8tJNTQIbTQUeldVJQiKKAURcAOKoIF/WyAUkRpCiIKojQpIqGGHgiEEAhJSAIJaaS3LfP9MexCTAipJIH7Ps8+sDP33rl3NzszZ845v7Pt6jYmtpiIp51nyQ6ozYFDX8Hhb8CgBTMbeOx9whs/wdmtw1EpVLR36cOkn07xT4gcKlfX0YqPhzWne6MHY3jYmtni4+hDcFIwJ+NOMrj+4Ao/plGVSRQQFggebbQGLWdungFKXjy4pCgVSlq4tODojaOc95+Hz4XdIBlAbQnd3wC/V0Bz7+K890OrN7D5dAzf7Q8j5lY2AM425kzpWZ9RHepiaaYiNTfVlEdUWAHh8qZb7W6olWoiUiMITw3H09aTgNgAoGrmWxlp6NCQenb1iEyLxD/Gn0Hegyr0eMZrkqXaEjuziokSKS3CcyUQCKosmdpMwlPl+lBFiVncTUuXlnSv3R29pOf7c9+X7IARh2B5F1ltyqCFxgNg2nHoNJm/wrcBUMeiLc8uDeafkHg0KgWv9GrAnpndH5hhZeRB510ZpdiF50ogeLQJTgwmW5eNvbl9xUuCGwy00Ml5rudij8uGVdNh8MpJ2bgqpWGVp7vjqXrnD9lT5WJrzvuDmnLorV5M6OplCv+7liYrBbpauWKptiyXZRWFrZktHd07ArKwRUhyCCm5KdhobGjhUvIaXQ8KhUJB33p9AdgTuafCj1dVCwiD8FwJBIIqzMWki0hIeFh74GzpXOx+U1tN5WDMQXZE7GBSy0l42XsV3SEzCf75AALXye9t3GHAF+AzGBQKdAYdmy//CUDIlcbo8vS0r1eDT4e3oKFb2SR+S0t79/asDl79QIwrnUFHUnYSIHKuBIJHHeM5p71be5SKCnxGH3cBtk2nZXIwuLty3soWnl8tS6yXEr1BYvOZGBbvu2LyVLnYmjO5R31Gd6yLhaZgPlVUulzjqq5t3VIft6Q8Vvcxjtw4wr9R/6I36AHo6NGxytcY7FOvD98HfW8KDbQxs6mwY1XVAsIgPFcCgaAKU1Tx4KJo5tyMnnV6YpAMLD+3/N4NdXlw9DtY3Oa2YaWAdhPglTtqU2k5Wqb88QupeckYdNZY6Vrw+YgWbHzJr9IMK5DzrlQKFTEZMcRmxFbosZKyk5CQUClU1DCvmsnUAoHgwVDh+VZ6HRz4Alb0hOunaSGZARChkkit1abUwwZcTWLwt4d5a1OQyVP1wV2eqsIMK4DoNFkcqa7dgzWuFCg4n3ie7eHbAehcs/MDO35pMYYG5hny8I/xr9BjCeNKIBAISoFJzKKExhXcqXv1d8TfXE25mn+nJEHIdljaEfbMkQUr3FvCi7th0NdgYY8kSewIiuWJrw5wKHYnAPXMu/Hv648zsn3dChWsKA7WGmuaOcmhkidvVqz3yhgS6GzpXKHKYAKBoGqTp8/jbPxZoILqW8VfgpVPwP6P5dDsJoOoMe2kyWtkvCaUhGtJmbz88yme++EYF2PTsLVQM2eALFTxYhFGlRGj5+pB5FsZcbZ0ppVLKwAi0yKBqi1mYeRBhgYac66EcSUQCAQloCRKgf/Fx8mHJ+o+gYTEsnPL7uyIDYK1g2HjaEgOBxs3GLoEXvKHunKce3RyFi+sOcm0X86QkJWExjYEgIUDX8LZxrzM6yov2rm3A+TCjRVJfJYs3CFCAgWCR5vziefJ0efgaOFIfYf65TewQQ9HFsH33eFGIFjYw/AVMHId2LoXXe/qHqTlaFmwM4TeXx9kd/BNVEoFz/t5cuDNXkzq7n1fo8pIVJpsXJVYHKmMGFUDAerZ1aOWTa0HevzS8qBUA6uqDDsI40ogEFRRErMTic2MRYGCpk5NSzXGlNZTANgduZvLMQGw9VX54h15CNQW0O0NePU0tBkDShVavYFl/lfp/c0B/EMTMFMpeaxdNCgMNHdqTsMaDctziWXmQYlamGTYRQFhgeCR5u6QwHITEUgMg1X9YO8HoM+Fhn1g6nFoNdJUCNioFhuUcH/jSm+QWH/8Gr2+8Of7g+Hk6Q10a+jM3691Y/7Q5jham5VoepWRcwVyaKCR6uC1MvKgQgOragFhEMaVQCCoohgl2L3svUqdFNuoRiP61pULGy7fPh7O/ARI0HyErDb1+PtgLudNnb6WzKDFh/l81yVytAb8vJ3Y+VpXkpVyfZFhDYaVdUnlThvXNqgVam5k3uB6xvUKO058tuy5EkqBAsGjjfFBTrmEBBoMcGwZLO8KMSfAzBaGfCfXrbLzyNfUGCJ3PvE8kiTdc8gjYYkMXHyIOVsukJSZR30Xa1aPb89PL3agUSlyZFNzU021lB5kWCDIOV7GB4s96/R8oMcuCw8qNNCUc2VV9YwroRYoEAiqJBeSSp9vBch5VcFbmHL+H/bYSey1NONS7VY06fOFKfwPIC41hy92h7L5TAwAjtZmzBngw5NtaxGcFExYShjmKnP6e/cv85rKGyuNFc2cm3Eu4RwnYk8wvOHwCjmO0XMlwgIFgkeXXH0u5+LPAeUgZpEcAX+9AtcOy++9e8qGlUPhBkyjGo0wV5mTmptKVHpUgRC9iMRMPtkRwj8hch6OvaWGmU80ZHQnTzSq0vsRYtLl64KzpTNWGqtSj1NaFvZcSFhKGJ08Oj3wY5eFilYNzNJmkZ6XDlRNz5UwrgQCQZWktEqBAFw/DbtmQ/Qx6gP9LGrzt7mCpV6tWXzbsMrM1fH9gausOBROjtYAwNO+tZk9wIcat8NGtlzZAsix71WtSKGR9u7tOZdwjlM3T1WYcWXyXImwQIHgkeVc/DnyDHm4WLpQz65e6QaRJDi1Cva8D9pM0FhDn/mySmsRYYYalQYfRx/OJpwlKCHIZFylZmlZ/O8VfgqIRKuXUCsVjOnkyYwnGuJgVbLwv8Iw1rh60CGBRjxsPPCw8bh/wypGRRcUNoYE2mhsKlTuvbQI40ogEFQ5JEkyhQUaY+2LRep12Dcfgn6V32usoMsMJjcfzO6dz7E/Zj/nE4IJjrDlq72XSUjPBaB9vRrMGdiU1nUcTENl67LZGSGrBFaU0VIetHdvz4/nf+RE3AkkSaqQYorCcyUQCMqcb5USDVtfgXB/+b1nVxj6HTjepw7hbVq6tDQZV/3rDWTDiSi+3nuZW1laAB5r4srsAT40cC2/m21TvtUDlGF/GDCGBn4f9D17IveUv3FVhcUsQBhXAoGgChKTEUNKbgpqpZpGNRrdv0NeFhxdDIcXgk4uDEmr5+DxD8CuJt7AQK+BbAvfxgt/fkzi1TEAeDpZ8W7/JvRt5l7gZmFf1D4ytBnUtK5ZMZLD5URrl9aolWriMuOIyYipkLwAk6CFyLkSCB5ZSp1vJUlyHcHdsyE3DdSW8MRc6PAyKIsfstfCRX7QdiTmDP2PHuJKvKxE19DVhvcGNaVHo/I/P0Wn365xVUmeq+pMRYYG3sysujLsUAUELZYuXYqXlxcWFhb4+vpy6NChItsfOHAAX19fLCws8Pb2ZvnyggVCU1JSmDZtGh4eHlhYWODj48POnTsragkCgaCcMXqtmtRogpmqiNAOgwHObYRvfcF/gWxY1ekEk/6F4cvBriYAl2+mEx7mhyQpyTW7gJ39Dd4f1JS9M3vQr7lHoU9h/wz7E5CFLJSKSj9V3hMrjZXJu1cRqoF5+jxu5d4CwNVSeK4EgkeRbF22SQa9RMZVWiz88ozsscpNg9odYPJh6DSlRIYVgL2iAQBRGWFcSbhFDSsNHw1txt+vdasQwwruyLDXsXuwYhYPAxWpGliVCwhDJRtXGzduZMaMGcyZM4fAwEC6detG//79iYqKKrR9REQEAwYMoFu3bgQGBjJ79mymT5/O5s2bTW3y8vLo3bs3kZGRbNq0idDQUH744Qdq1aoe9QEEAsGdfKtmzs3u3SjqOPz4OGx5CdJvgENdeHoNvLgLavkCkJCey+wt5+m38CDHQpXo09oC0KHtKSZ09cJMXfgp8HrGdY7HHgdgSIMh5bewCsKYXF4RxlVidiIAGqUGe3P7ch9fIBBUfQLjA9EZdLhbu1Pbtvb9O0gSBP0GSzvBlT2gMoPe8+Xzs3ODEh07JSuPD7cGM+b7UAxaWxQKA0M7GPB/oxdj/eqhLoNgxf2oLBn2h4GKVA00FhB2sxZhgQX4+uuvmTBhAhMnTgRg4cKF7N69m2XLlrFgwYIC7ZcvX07dunVZuHAhAD4+Ppw6dYovv/ySESNGALBq1SqSk5M5evQoGo0GAE/PB1v4TSAQlA1j8eBC861SomDvXAj+Q35vZgPdXodOU0FjAUCOVs/KwxEs879KRq4OgH7N3Bnf412m+I/keNxRzsafpbVr60KP/1fYXwB09OhYLQo3tndvz4qgFRWSd3V3AeGKyOcSCARVn7tDAu97HsiIh+0z4dJ2+X3NNjBsObg2KdExdXoD645d45t/rpCaLedVOWkacosztG2Ujr2VpsTrKAkZeRkk5yQDwrgqLRUVGliVZdihEj1XeXl5nD59mj59+uTb3qdPH44ePVpon4CAgALt+/bty6lTp9Bq5R/e1q1b8fPzY9q0abi5udG8eXM+/fRT9Hr9PeeSm5tLWlpavpdAIKgcdAYdIckhwH+UAvOyYP+n8F3724aVAto+D6+egW6zQGOBwSCxJTCGx77054vdoWTk6mhV257fXvZj+VhfOtVtxNAGQwFYcnZJocc3SAZTSODwBlVXyOJuWrm0QqPUEJ8Vb8oRKC8SskUBYYHgUeduMYsiCd4CSzrKhpVSA73egwn/lNiwunA9laFLjvDhtoukZmtp4m7L+okdGde2OwDnEs6Vah0lwei1crRwrJKKdNWBigoNNAlaCM9VfhITE9Hr9bi55f9g3NzciIuLK7RPXFxcoe11Oh2JiYl4eHgQHh7Ov//+y+jRo9m5cydXrlxh2rRp6HQ6Pvjgg0LHXbBgAfPmzSufhQkEgjIRnhpOti4ba421LPd7u14Ve96HNLnmCPW6Qd9PwaOlqd+JiGQ+3nGRoJhUAGraW/BWvyYMaVUTpfLOk9ZJLSfx19W/OBZ7jFNxp2jn3i7f8Y/HHic2MxZbjS2P1328wtdbHliqLWnh3IIz8Wc4EXeiXJWtjJ4rIWYhEDyaZGozTXmw98y3ykyCnW/ciShwawHDl4F7CdRekaMOFu27woqD4egNEvaWGt7q15hn29dFpVRgFief842h4xWJCAksOxWlGmiUYhc5V/fgv+7l+4W0FNb+7u0GgwFXV1dWrFiBr68vzz77LHPmzGHZsmX3HPPdd98lNTXV9IqOLt8nvwKBoPgYQwKbOjVFFR8CawbBphdkw8q+DjzzE4zbZjKsIhIzefnnUzzzfQBBManYmKt5s29j/n2jJ8Pa1MpnWAHUsqnFkw2eBGDpuaUFjr8lTK5tNcB7ABZqi4pcarnSwUO+6SnvvKu7wwIFAsGjx+mbp9FLemrZ1KKmTc2CDcL2wTI/2bBSqKD7W7KoUAkNq+PhSfRfdIhl/lfRGyQGtvTgn1k9GN3RE9Xt83gzp2YoFUriMuNM56aKIjrttlKgkGEvE33qyRFnxtDAspKel06mNhOoumGBlea5cnZ2RqVSFfBSxcfHF/BOGXF3dy+0vVqtxsnJCQAPDw80Gg0qlcrUxsfHh7i4OPLy8jAzK6g8Zm5ujrm5eVmXJBAIygGjcdU8NQG+7waSAdQW0HUmdJ4OZlaAnOS8aN8Vfg64hs4goVTAcx3qMrN3I5xtiv49T2o5iS1hWzgZd5ITsSdMhklqbir7ru0DZJXA6kR7t/YsZzkn406Wa96VSYZdhAUKBI8k95Rg1+XKdQUDvpPfuzSBYcugVtsSjZ+eo+Wzvy+x/rjsKXKzM+ejoc3p06zgjbOVxoqGDg0JvRXK+YTzPO5ZcdEFlV1A+GGhvAsKG2XY7czssNJYlccUy51K81yZmZnh6+vL3r17823fu3cvnTt3LrSPn59fgfZ79uyhXbt2JvGKLl26EBYWhsFgMLW5fPkyHh4ehRpWAoGgCmHQcyHKH4DmkSdlw6rpMHjlJPR8B8ysyNMZ+PFQOD2+8Gf1kUh0BomejV3YNaM7nwxvcV/DCuRQgqcaPQXIuVdGD/iuiF3kGfJo4NCAZk5FKBVWQVq5tsJMaUZCdoLppqA8iM8WniuB4FGm0HyrhFBZrdVoWLWfBC/5l9iw2hdykz7fHDQZVs91qMOemT0KNayMGOtdnUus2LwrU40r4bkqE+WtGmgMCayq+VZQyWGBs2bN4scff2TVqlWEhIQwc+ZMoqKimDx5MiCH6z3//POm9pMnT+batWvMmjWLkJAQVq1axcqVK3njjTdMbaZMmUJSUhKvvfYaly9fZseOHXz66adMmzbtga9PIBCUgMgj5HzfnSu3b+Zb2NaDcdvhmbXgUBdJkth78Sa9vznAxztCTEnOP0/owJoXOtDIzbZEh5vYYiJmSjPOxJ/hWOwx4E5I4PAGw6udMp65ypyWLnKopPFmqDwweq6EcSUQPHqk5aVxKfkScNtzJUlwahV83wPizoOVEzz3Kwz8EjSWxR43KSOX6RsCmbD2FLGpOXg6WfHLpI4seLIl9pZFqwC2dJbPc0EJQaVfWDEQOVflR3mGBlZ1pUCoZCn2kSNHkpSUxPz584mNjaV58+bs3LnTJJ0eGxubr+aVl5cXO3fuZObMmSxZsoSaNWuyePFikww7QJ06ddizZw8zZ86kZcuW1KpVi9dee4233377ga9PIBAUg9QYWawi+A8umZuhs3LHUWWJ+6RDoJYvspdvpvPR9oscuiLXXHKxNeeNPo14yreOKRa/pLhaufJM42dYF7KOJWeX4GjhSHBSMGqFmkH1yyfp9kHTwb0Dp26e4lTcKZ5p/Ey5jGkKCxSCFgLBI8fpuNMYJAOedp64KTSwccwdifX6j8lhgLbFv8mVJIm/zt5g3rZgbmVpUSpgYjdvZj7RCEsz1f0HQFZHBbiYdBGdQYdaWf63slnaLFONP1FAuOyUZ2hgVS8gDJVsXAFMnTqVqVOnFrpvzZo1Bbb16NGDM2fOFDmmn58fx44dK4/pCQSCikKbDUe/hUNfgy4bFEqCG/SArFBaeHRAodaQkpXHwn+u8POxa+gNEmYqJRO7eTG1VwNszMt++prQYgKbLm/iXMI5Pjgqq4n2rNMTRwvHMo9dGbRzbwfnKLd6V1naLNK16QC4WgrPlUDwqGEKCbSqDcs6Q3qsLLH+xIdybUFl8QOgrqdkM2fLefxD5Qc2Tdxt+d9TLWlZ26FEc6pnXw9bjS3p2nTCUsJo4lgymffiYPRa1TCvgZ2ZXbmP/6hRnqqBxgLCD4VxtXXr1mIPOmTIkFJNRiAQPAJIkvzkc/dsuSAwQN3O0P9zzof9AuGh+Dg25eeASL7ae5mULLmGXb9m7swe4ENdp/JLYHW2dGZk45GsvbiWi0kXARjesHrUtiqMVi6tMFeZk5STRERqBN4O3mUaz/jk1lJtibXGujymWO6Ia5NAUHGcvG1cdQj6CzKzwLkRjPgRPFoVewyDQWLd8Wt8/vclMvP0mKmUTH+8AS/3qI9GVfLsFKVCSXPn5gTEBhCUEFQxxlWafG0SXqvyo7wKCptqXFlV3ZyrYhtXw4YNK1Y7hUJRZMFegUDwCBN/CXa9DeH+8nvbmtDnI2g+AhQKgo/NAeC3Iwquxch1VRq72TJ3cFM6N3CukCm90PwFfrv8G9m6bFwsXehcs3BBneqAmcqM1i6tOR53nJNxJ8tsXN0tw15Vc9DEtUkgqBhSbpwh9NZlANrn5IDvC3J9QbPiP+AKi8/g3T+COBl5CwBfzxp8PqIFDVxLliP7X1q4tDAZV+UVAn03It+q/Cmv0MDqEBZY7EcGBoOhWC9x8RIIBAXIToG/35HDSsL9QWUO3d+EV09Bi6dAoeBi3E0i0yIBiIp1wsFKw0fDmrNjetcKM6wAnCydeL6pLJzzdKOnKyR+/0FiLIpcHqIWCdlVX4ZdXJsEgnJGkuDMz5zaINcD9NbpcX7qJxi8sNiGlVZvYMn+MAYsOsTJyFtYm6mYN6QZv7/sV2bDCu7kXQUlVoyohUkpUBhX5UZ5qAZKkvRwhQUaMRgMrFmzhj/++IPIyEgUCgXe3t6MGDGCsWPHVtmnmwKBoBIw6CFwHeybB1lJ8rYmg6DPx+DoBUBGro4l+8NYdXoPZrXBkOfIuI7NmPFEQxysHkz5hKmtp9KzTk98HH0eyPEqkg7uHVjCEk7dPFXmvCuj56o6iFmIa5PgYeNGxg1szGwebM5P9i3YNgMu/skJxxoAdGg0DHwGF3uI8zGpvLU5iJDYNAB6NHLhk+HNqV2j/EK6WzjLcuwRqRGk5aWV+2dkqnElZNjLlbKGBqblpZGtywaqdlhgiYJdJUli8ODBTJw4kevXr9OiRQuaNWtGZGQk48ePZ/jw6purIBAIypnrp+GHx2DbdNmwcm4MY7fAs+vB0QuDQWLT6Rh6fenPMv+rSGZyGEa3um34cEizB2ZYwZ0YfpWyeGpVVZnmzs2xUFmQnJPM1ZSrZRrLJMNexcUsxLVJ8LBxKfkSg7YMYtzf49AZdA/moJFHYFlXuPgnKNWcdJbzjTrU7VWs7tl5ehbsDGHoksOExKbhYKXhm5GtWPNC+3I1rABqWNSgjq08vwsJF8p1bIDoNOG5qgiMoYF5hjz8Y/xL3N8YEljDvAYWaotynl35USLP1Zo1azh06BD79u2jV6/8P7Z///2XYcOG8dNPP+WrTSUQCB4xtDngvwCOLpaLAJvbQc93ocMkUMnS6meibjFv20XORacA4OlkRc1GGVxIAb/abSpv7g8BZiozWru25ljsMU7ePEmDGg1KPZaxgHBV91yJa5PgYWPRmUVoDVrCUsLYHr6dYQ2GVdzB9Fo48Dkc+ko+Zzt6kzT4a8IOTgegnVu7+w4RcDWJd/8IIjIpC4DBrWoyd3DTYhV1Ly0tXVoSnR7NucRzdK5VfrmyWdos07lPeK7Kl7KqBhpDAqtyAWEooedqw4YNzJ49u8DFC+Cxxx7jnXfeYf369eU2OYFAUM2IOQXfd4MjC+WLdPOn4NUz4DcVVBriUnOYtfEsTy49yrnoFGzM1bzbvwl7ZnYnPvcKIHteBGWjvXt7AE7GnSzTONWlgLC4NgkeJk7fPM3h64dN75efW47WoK2YgyVHwKp+cPAL+ZzdZgy8fIiTilwAGtVoRA2LGvfsnp2n58OtwTz3wzEik7Jwt7Pgx+fb8e1zbSrUsII7xYTPJ5wv13FjMmIAsDOzw97cvlzHFpStoHB1KCAMJTSugoKC6Nev3z339+/fn3PnzpV5UgKBoJqhzZELAa/sDYmXwdoVRq6Hp1aCjQs5Wj1L9ofx2Ff+/BF4HYUCnmlXm3/f6MHLPeqTkptIfHY8SoXyoch7qmw6uHcA4FTcKQySodTjVAdBCxDXJsHDgyRJLD6zGIDB3oNxsnDiesZ1/gr7q/wPdm4jLO8G10+BuT08tRqGLgFzG07Gyg9mjOeSwjgTdYsBiw+x5mgkAM91qMOeWd15oumD8Sq0dLltXCWeR5KkchvXGBLoaedZbmMK7lCW0ECTDHsV91yVKCwwOTkZN7d7L8jNzY1bt26VeVICgaAaEX0C/pomG1UALUdCv8/AyhFJkth1IY5PdoYQc0tOQvX1rMHcwU3zFY68kCTHzNd3qI+Vpnxj8x9Fmjk1w1Jtya3cW4SlhNGoRqMSjyFJUj4p9qqMuDYJHhYOXz/MmfgzmCnNeK3tazR1asrnJz9nRdAKhtQfgpmqHHJRc1Jhx+tw/nf5fd3O8OQKcLhT08lUPPi2F/xucnV6Fv1zheUHrmKQwM3OnM9HtKRn4wd7nmhcozFmSjNSclOITo8utxC+a+mymIUxp0tQvigUCvrU68OKoBUlDg2sDkqBUELPlV6vR62+tz2mUqnQ6R5Q4qVAIKhctNmwew6s7CMbVjZu8OwG+SJt5cjlm+mM+uE4U9afIeZWNh72Fix6tjWbJvvlM6wAghPlmlZGBShB2dCoNLRxlXPXShsamKnNNKkyOVtWnBR+eSCuTYKHAYNkYHGg7LV6rslzuFm78VSjp3C1dCU2M5YtV7aU/SBRx2B5V9mwUqig13swfns+wyo+K57ItEgUKPB1883X/eKNNIZ+d4Sl/rJhNbxNLfbM6PHADSuQz3M+TnKkw7mE8vNMGwsIi3yrisMoyV7S0MDqUEAYSui5kiSJ8ePHY25eeBxtbm5uuUxKIBBUcaKOw19TISlMft/qObm4pJUjWr2B5f5XWfzvFbR6CXO1kpd71GdyD2+szAo/5ZxPlGPmmzk1e1AreOhp796eozeOcjLuJKN9Rpe4vzGh21ZjW+W9ieLaJHgY2HNtD5eSL2GtsWZCiwkAWKgtmNhyIp8e/5QV51cwrOEwzFWlyGXS5cL+T+DIYkACB08YsRLqFPRMGR/INHFsYso50ukNLD9wlUX75PO6k7UZnwxvTr/mHqVeb3nQ0qUl5xLOEZQQxOD6xZeLLwpR46riKW1B4epQQBhKaFyNGzfuvm2EGpNA8BCTlyVfoAOWABLYuMPgRdBYzncJvpHKm78HcfF2fZPHm7jy4ZBm1HG89825QTIQnCR7roSYRflhDOc5dVPOu1IqShSoUK1qXIlrk6C6ozPoWBK4BIBxTcflE5EY0XAEqy6sIi4zjk2XN5X8YUlsEGyZDPHyeZbWo+XQbYvCa0MZjStjvlVYfAav/3aWczGpAPRp6sanT7aocMGK4nB33lV5EZUuPFcVTWlCA6tLAWEooXG1evXqipqHQCCoJBKzE9lyZQutXVsXGl9v4lqAnFuVfLt2UqtR0O9TsKxBns7Ad/9eYan/VXQGCQcrDR8ObsbQ1jXvW7w1Ki2K9Lx0zJRmNKzRsBxX9mjT1KkplmpLUnNTuXLrCo0dG5eov1EpsDoYV+LaJKjubL26lci0SBzMHRjbdGy+fWYqM15q+RLzA+bz4/kfebLhk1iqLe8/qF4HRxfB/gVg0IK1i/wwrMnAIrsZ863aubVn5eEI/rfrErk6A7YWauYPbcaw1rWqTFFuo2JgaHIoObqcMtc+ytHlmLwjwnNVsfSt15cVQSuKXVD4Vu4tcvVyFMJDFRYoEAgeHrK0Way9uJY1F9aQpcvCVmPLP0//UzAELC8L/v0Iji0DJLD1kC/QjeSY6XPRKby1KYjQm+kA9G/uzvyhzXGxLd5TTaOYRROnJmiUmnJb36OORqmhrVtbjlw/wsm4kyU2royeq6p+ERMIqju5+lyWnVsGwMQWEwu9yRxWfxgrz6/kesZ1fgv9jXHN7uOtTboKW16GmNs5l00Gyedt66LzJ2MzYolOj0apUPHd33pORVwEoFtDZ/73VEs87Ith1D1APKw9cLZ0JjE7kZDkEFOuaWmJSZdl2G01tjiYO5TDDAX3oqShgTczZa+Vk4VT+Qi7VCAlixMRCATVHp1Bx6bLmxi4ZSBLzy4lS5eFUqEkXZvO1qtb8ze+dhSWd4FjSwEJWo+BqcegUV9ytHo++/sSw5ceIfRmOk7WZiwd3ZZlY3yLbVgBXEiUjSshZlH+GMN6jE+iS0J1kWEXCKo7v4X+RlxmHK5WroxsPLLQNhqVhpdbvgzAqguryNJmFT6YwQAnfpBFK2JOykXch38PI9fd17ACOB53HAB9dk1ORWRjZabik+HN+enFDlXOsAI5vMx47QhKCCrzeMaQwDp2daqMd+5hxRgaCLAncs9921cXGXYQxpVA8MggSRL+0f6M2DqCeQHzSMxOpJZNLb7o/gVvtX8LgPUh6+W6SHmZ8PfbsHoAJIeDbU0YvQmGLQFLB05fS2bA4kMmKd4hrWqyd1YPBrQoeXKz0bgSYhblT3s3Oczz9M3TJa53VZ1yrgSC6kqmNpMfz/8IwJRWU4oMaxtcfzB1bOuQnJPMhksbCjZIvQ7rnoSdb4A2C7x6wNQAaPUsFMNQiEvN4ZtDfwOQl+FNh3qO7HqtO6M7elZpQ8OYd1UexpVRzMLTVtS4ehCURDUwLqt6FBAGERYoEDwSXEi8wFenvuLUzVMA2JvbM7nlZJ5p/AxmKjMytZl8F/gdkWmRHDnzA90OL4NbEXLnNmNkJUALe7Lz9HyxO5TVRyOQJHC1NefjYc3p06x0JzutQcul5EuA8FxVBD5OPlhrrEnLSyM0OdQkW1wcjDlXVb3GlUBQnVl3cR3JOcnUta3L0AZDi2yrVqqZ0moKsw/PZnXwakY2HimHEEoSBP0GO9+E3FRQW0Lv+dB+Iijv/wxdkiT+OnuD9/86j6H2RZRKGNm8Jx/27oRKWXWNKiOtXFoB5SNqcS3tdo0rO1Hj6kFQktDA6qIUCMJzJRA81ESnRfPmgTd5bsdznLp5CjOlGS82f5GdT+5kTNMxprhla401T3rLMrbrTnwhG1Z2tWD0Zhi6BCzsCbiaRL9FB1l1RDasnvKtzd6ZPUptWAGE3QojV5+LrcZWKDNVAGqlmraubYGShwY+6mGBS5cuxcvLCwsLC3x9fTl06FCR7Q8cOICvry8WFhZ4e3uzfPnyAm0WLlxI48aNsbS0pE6dOsycOZOcnJyKWoKgipOSk8Ka4DUATGs9rVg5p/29+lPPrh6puamsD1kPmYnw2/Ow5SXZsKrVDiYfho4vFcuwSsrIZer6M8zYeJYMfTxKTQoqhYp3HxtQLQwrkKMelAolsZmxJo97aTEpBQoxiwdCSUIDq4tSIAjjSiB4KEnJSeHzE58z5K8h7IrchQIFQ+oPYfvw7cz0nYmd2X8keCMO8dzJX1FKEketLLnaaoQcTtLwCTJydbz/5wWe++EY15Ky8LC3YM0L7fny6VbYW5VNgMIoZtHMuVmJpcIFxcOYd3Uq7lSx+0iSZLpJeRQ9Vxs3bmTGjBnMmTOHwMBAunXrRv/+/YmKiiq0fUREBAMGDKBbt24EBgYye/Zspk+fzubNm01t1q9fzzvvvMPcuXMJCQlh5cqVbNy4kXffffdBLUtQxVgVvIoMbQaNajSin1e/YvUxeq8A1p5fSdqyThCyFZRqeOw9eHE3ODco1li7g+Po881B/r4Qh1qpoH/7TECOIqjqte3uxkpjRQMHec3nE8rmvYpOu13jSjzse2AUNzSwuhQQBmFcCQQPFTm6HFaeX8mAPwawLmQdOoOOLjW78Pvg3/mk6yd42PwnJ8qgh38/hrWDqZ10jV558ub17vXAwp6DlxPo+81Bfj4mh0qM6liXPTO707Nx+dxwG/OtRH2risMor3/65mn0Bn2x+qTmpqI1aAFwtrx/EvzDxtdff82ECROYOHEiPj4+LFy4kDp16rBs2bJC2y9fvpy6deuycOFCfHx8mDhxIi+++CJffvmlqU1AQABdunRh1KhR1KtXjz59+vDcc89x6lTxjV7Bw0N8Vjy/hPwCwPQ200v0cKmvux8NlFak67NZp84DFx+Y9C90fxNU98/2SM3WMuu3s7z882mSMvNo7GbLn9O6YFdDPs8XWZKjimLKu0osfd5Vnj6P2MxYAOrYirDAB4UxNDDPkId/jP8924mwQIFA8EDRG/RsvbqVwX8OZuGZhaRr02lcozHf9/6e5b2XFy7DnR4HPw2Fg18AErQZy+h+chHLrVe3MfP3ozy/6gTXU7KpXcOS9RM78unwFthalJ9cujCuKp4mjk2w0diQrk3n0q1LxeoTny17rWqY16jykrflTV5eHqdPn6ZPnz75tvfp04ejR48W2icgIKBA+759+3Lq1Cm0WtlI7dq1K6dPn+bECTk8Mzw8nJ07dzJw4L1rDuXm5pKWlpbvJXg4WBG0glx9Lq1dWtO9dvfid4w4hOr77kyJlQ2hnx2dSB33F3i0KlZ3/9B4+i08yB9nrqNUwOQe9dn6ahea1bTjZOzt4sEeHUq8nsrGWO+qLKIWMekxSEhYa6xxsnAqr6kJ7kNxQgMNkqFahQUKQQuBoJpz9PpRvj79NaG3QgH5xDO9zXQGeg+899PQ8AOweSJkxoPGGoYshhZP0U6SqGVVn+tZV9kR8SfQg/Gd6/Fm38ZYm5fv6SJLm0VYShgAzZ2EcVVRqJQqfN18ORBzgJOxJ4ulylidCgiXN4mJiej1etzc8oeeuLm5ERcXV2ifuLi4QtvrdDoSExPx8PDg2WefJSEhga5duyJJEjqdjilTpvDOO+/ccy4LFixg3rx5ZV+UoEoRnRbN5styyOj0ttOLp8SnzYZ982+XxYAnHOrSyLo2lzNjWHt5I9PbTi+ye3JmHh9tv8iWwOsA1HOy4qtnWuHr6QhAZGok8dnxaJQaWru0Lv3iKgmj5yo4KRidQYdaWfLr1d35VlVZHfFh5H4FhZNzktEZdChQVIvrUqV7rso7aXjNmjUoFIoCL5E0LHjYuJR8iZf2vMTL/7xM6K1QbDW2zPSdyfbh2xlcf3DhhpVBD/6fyx6rzHhwbQov+UOLp0jJyuP1384RFiYXYbR0PsaGl9rz4ZBm5W5YGedvkAy4WrpWi7oV1RljmM/JmyeL1V7IsFPg5kqSpCJvuAprf/d2f39/PvnkE5YuXcqZM2f4448/2L59Ox999NE9x3z33XdJTU01vaKjo0u7HEEVYum5pegkOWS7WCF418/A991NhhW+41FOOcrUDm8AsC5kHbdybhXaVVYCvE7vrw+wJfA6CgW82MWLna91MxlWcEfwpqVLyyLl4KsqXvZe2GhsyNZlczXlaqnGiEq7XeNKhAQ+cO4XGmgsIOxi6VIs4ZfKplI9V8ak4aVLl9KlSxe+//57+vfvz8WLF6lbt2AyoTFpeNKkSaxbt44jR44wdepUXFxcGDFihKmdnZ0doaGh+fpaWFS/k4VAUBixGbF8d/Y7tl3dhoSEWqnmuSbP8VKLl3CwcLh3x4wE+GMihPvL79uMgf5fgJkVuy7E8d6fF0jMyEWpbIW5Yg+5qlukKQOBvhWyDqNsbjNnUd+qork776o4T3WNSoGulo+emIWzszMqlaqAlyo+Pr6Ad8qIu7t7oe3VajVOTnJ40fvvv8/YsWOZOHEiAC1atCAzM5OXXnqJOXPmoCxE2c3c3Bxz8+IX5BZUfa7cusKO8B0AvNr21aIb67Vw8Es5dFvSg407DPkWGskhVI/VeQwfRx9CkkNYHbyaWb6z8nW/kZLN+39eYN8l+WFJYzdbPhvRgjZ1axQ41Mm42yGB7tUvJBBAqVDS3Lk5x2KPcS7hXOGh8PfB5LkSYhYPHGNo4IqgFeyJ3FNAkr06FRCGSvZcVUTSMMhfkru7e76XQPAw8MeVPxi0ZRBbr25FQqK/V3+2DtvKW+3fKtqwijwCy7vKhpXaEoYtg6FLyFGYM3vLeSavO01iRi4NXG3YPLkHL7QcBcg1WCqK4MRgQNS3ehA0rtEYWzNbMrWZprpiRfEoe67MzMzw9fVl7969+bbv3buXzp07F9rHz8+vQPs9e/bQrl07NBr5KWtWVlYBA0qlUiFJksnLJXj4+TbwWyQkenv2LjpEN+YU/Pg4HPhMNqyaPSkruDa6k9unUCh4pc0rAPx66VcSsxMBMBgkfg6IpM83B9l3KR6NSsHMJxqx7dWuhRpWkiSZjKvqKGZhxBgaWNp6V8YCwkKGvXIoSjXQVEC4GuRbQSUaVxWVNAyQkZGBp6cntWvXZtCgQQQGBhY5F5E0LKgOpOWl8fmJz8kz5NHOrR0bBm7gf93/V3QIg8EAh76GtYMhIw6cG8NL+6H1KK4mZDBsyRF+OR6FQgFTetZnx3T54juy8UjUSjVnE86aRCfKG+G5enColCraubUDilfvylRA+BH0XAHMmjWLH3/8kVWrVhESEsLMmTOJiopi8uTJgByu9/zzz5vaT548mWvXrjFr1ixCQkJYtWoVK1eu5I033jC1GTx4MMuWLePXX38lIiKCvXv38v777zNkyBBUKtUDX6PgwROUEMT+6P0oFUpeaf1K4Y3S42DLZNmwij0HFg4wYiU8vRqsHAs071arGy2cW5Cty2bVhVWExWcwckUA7/8VTEaujrZ1Hdg5vRuvPdEQM3Xht3zhqeEk5SRhrjI3FeStjpRV1MJYQFh4riqHokIDq5MMO1SicVURScMATZo0Yc2aNWzdupUNGzZgYWFBly5duHLlyj3nsmDBAuzt7U2vOnVEvK2g6rHp8iaydFk0cGjAqr6r7q+wl5UMG0bCvnnyk8+WI2W5Xlcf/gy8zuBvD3MpLh1nGzN+erEDb/drgrlavslztnSmf73+gBzPX96k5KQQkxEDUCyBBUHZMeVdxd0/78pUQPgR9FwBjBw5koULFzJ//nxat27NwYMH2blzJ56engDExsbmq3nl5eXFzp078ff3p3Xr1nz00UcsXrw4X7j6e++9x+uvv857771H06ZNmTBhAn379uX7779/4OsTVA6LzywGYLD3YLwdvPPv1OXC4W/gW184t0He1no0TDsBLZ6655gKhYJpracB8EvIRgZ8t52TkbewNlMxb0gzNk3uTEM32yLnZXzg0tqldbVWB23hIkdBhKeGk5ZXsofkWr3WJMMuPFeVQ1Gqgcacq+riuap0tcDyThru1KkTnTp1Mu3v0qULbdu25dtvv2Xx4sWFjvnuu+8ya9adWOW0tDRhYAmqFFq9lvUh6wEY12zc/ZWMoo7Dphcg7TqozGHAF9D2ebK1Bj7cFMTGU3L4g5+3E4uebY2rXcGcxNFNR7MtfBu7I3czy3dWuRaTNRYP9rTzxN7cvtzGFdwbYy7FmZtn0Bq0RSYFP8oFhI1MnTqVqVOnFrpvzZo1Bbb16NGDM2fO3HM8tVrN3LlzmTt3bnlNUVCNOBZ7jONxx1Er1UxtfdfflSTB5V2wezYkh8vbarWD/v+D2r7FGtvG0BQznTd56nAUNfbT02ECnwxvQS0Hy2L1N+VbVUMJ9rtxtHCkjm0dotOjuZB4gc41Cw/jLYzrGdcxSAYs1ZaPZG2/qsK9VANFWGAxqaik4f+iVCpp3759kZ4rc3Nz7Ozs8r0EgqrErshdxGfF42zpzACvAfduKElw9FtYM0A2rBzrw6R94DuOsNthgBtPRaNQwGuPN2TdxI6FGlYge5TaurZFZ9CxMXRjua5H1Ld68DSs0RB7c3uydFmEJIXcs53eoDflbrhYPpqeK4GgPJEkyeS1eqbRM9S0qSnvSLgM60bAhmdlw8rGDYYthwl7i2VYZefp+WTHRYYvPUrK9ccAsHQ6wYKn6xTbsDJIhmovZnE3xhzekoYGChn2qsG9QgNFWGAxqaik4f8iSRJnz57Fw8OjfCYuEDxgJElibfBaAEb7jL532Eb2Lfh1FOx5Dww6OQH6JX9wb8Gm0zEM/vYIoTfTcbYxZ/2Ejszs3QiVsuiLyGif0QD8Hvo7ufrccluTybgS9a0eGEqFslh5V7dyb6GX9CgVSpwsRSFNgaCs/Bv9L+cTz2OptmRSy0mQkwq7ZsMyP7i6D1Rm0GUGvHoaWj8HhShH/pcjYYn0XXiQHw5FYJBgYMNutHJui17S8eP5H4s9tyu3rpCSm4Kl2vKhyH81ilqU2LhKE0qBVYHCQgP1Br0pmkJ4ropBRSQNz5s3j927dxMeHs7Zs2eZMGECZ8+eNY0pEFQ3jscdJ/RWKJZqS55u9HThja6fluughO6UL9QDvoSnVpGltOKN38/xxu/nyNbq6dLAiZ2vdaVzg+KFPTxW9zE8rD24lXuLneE7y2U9kiQJz1UlYcy7OhV36p5tjBcxJwunUhXiFAgEd9Ab9HwX+B0AY5qMwvniDljcFo4tkR+CNeoPU49B73lgXnRuFEBqlpa3Np1j9I/HiUrOoqa9BavGt2Pxc22Z4StLu/8R9gfXM64Xa35Gr1Vb17bVon7Q/TCKWpxPPF8iFU6j50rUuKp8/qsamJidiF7So1Koqk00RaVeOUeOHElSUhLz588nNjaW5s2bFytpeObMmSxZsoSaNWsWSBpOSUnhpZdeIi4uDnt7e9q0acPBgwfp0KH6u7sFjyZrgtcAMLzB8IL5SZIEJ1bA7jlg0EKNevD0GqjZhss305m2/gxX4jNQKmDGE42Y1qvBfb1Vd2OsofX16a9ZF7KOYQ2GlTlkIi4zjqScJNQKNU0cm5RpLEHJMBpXZ+LvnXdlVAp8VMUsBILyZGfETsJSwrBVWzH+1CaIvS0T7twI+i2ABk8Ue6y/z8fywdZgEtLlKILn/Tx5q18TbG4XeW/n3o5OHp04FnuMH4J+4MPOH953TKMXuzpLsN9NE8cmmCnNSMlNITo9utieqLvDAgWVizE0MDItEv8Yf9N34mLlgkpZPZRVK/2xZHknDX/zzTd888035TU9gaBSuXLrCkeuH0GpUDKm6Zj8O3NSYeurcPEv+X2TQTB0CZKFPb+fjOaDrRfI0RpwtTVn8XNt6ORduhCvJxs+ybJzy7h86zIn406WOenZKGbRsEZDLNSiuPeDpIFDAxzMHUjJTSE4MZjWrq0LtInPvi1m8YjKsAsE5YVWr2XJ7VyrF+NvYJeaBuZ20PMd6PASqIrnKbqZlsMHf11gd7CsmFbfxZrPR7SkXb2C0uzTWk/jWOwx/gz7kwnNJ1DH7t6eGL1Bz6mbshf7Yci3AtCoNPg4+XAu4RxBiUHFNq6i027XuBJhgZXOvQoKV5d8K6jksECBQFA0P138CYDH6z6eP1wh9hx830M2rJQa6PcZjFxHptKGWb+d463NQeRoDXRr6MzO17qV2rACsDe3Z0j9IUD5yLKL+laVh1KhvK8ku/BcCQTlgDaHzX9P5npWHE46PaPSMqDt8/DqGfCbVizDSpIkfj0RxRNfH2B38E3USgWvPtaAHdO7FWpYAbR2bU2XWl3QS3qWBy0vcvzQW6Gk56VjrbHGx8mnVMusipRU1EJr0JrCKIXnqmpwd2jg1dSrQPXJtwJhXAkEVZbE7ER2hO8AZPl1QA4DPLkSfuwNtyLAvi68uBs6TSEkLp3B3x1mS+B1VEoFb/ZtzNoXOuBsY17muYzyGQWAf7S/qYp9aQlODAbuXAAFD5b7iVoYc66EcSUQlAJJgpBtZC9pz/c3AwB4WeGI1aR/Yci3YFO839WF66k898Mx3vnjPOk5OlrVtmfbq115vU9jLDRFh0YZCxRvD99OZGrkPdudiJXPAb5uvg9VfqWxEHJxjavYjFj0kh4LlYU471UR7lYN3HR5EwDuVsK4EggEZeSXkF/QGrS0dmktXyzysmDLy7BjFuhzoVE/ePkAUq22/HI8imFLjhCekIm7nQW/vtSJab0aoCxBflVReNt706VWFyQkfgn5pdTjGCQDwUmycSWKB1cOxvCfs/Fn0eq1BfYbCwiLsECBoITEh8BPQ2HjGDZIt0hUq6hl5sBTz/8LNdsUa4jo5Cxm/BrIoG8Pcyw8GQuNkvcG+vDH1C74eBSvTExz5+b0rN0Tg2Qo0ntlfMDysIQEGjEWEw5NDiVHl3Pf9sZ8q9q2tVEqxG1xVeBu1cDqphQIwrgSCKokWdosU22pcc3GQUoUrOoLQRtBoYLe8+HZDaQrbZn+61lmbzlPrs5Az8Yu7HytG+3vETJSFsb6jAVgS9gWMvIySjVGZGokmdpMLNWW1HeoX57TExST+g71cbRwJEefYwrRvBsRFigQlJCsZNj5FizrAhEHSFNbsNJZzg+Z2uFNNOp7lM+4i1uZeXy0/SKPf3WAP8/eAGBo65rsndmDid28SyREBJgKFe8M38nVlKsF9usMOs7Ey/nrD4uYhZGa1jVxsnBCJ+m4lHzpvu2NMuyedp4VPTVBCTCGBhoRxpVAICgTf139i7S8NOrY1qGXXg0rekJcEFg5wfN/QZfXCI5LZ8h3R9h27gYqpYJ3+jdh1bj2OFrf/0JeGjrX7IyXvReZ2kz+uvpXqcYw3sz7OPo8VGEo1QmFQmEKDSws78r4lNDVSniuBIIiSQiFbTPg66Zw4nuQ9OAzmLWPv0qaIY/69vUZ6DWwyCFytHqW+V+l+xf7WXk4gjy9gS4NnNj+alcWPduGOo5WpZqaj5MPj9d9HAmJZeeWFdh/MekimdpMbM1saVyjcamOUVVRKBSmelfnEs7dt70x1F3kW1UtjKGBRoSghUAgKDV6g56fL/4MwFjLeqh+fhKyksC9Jbzkj1SvKz8fu8bwpUeJSMykpr0Fv73cick96pdbGGBhKBQKRjeRiwqvD1mPQTKUeAxR36pqYAwD+q9xpTVoSc5JBqg29UQElcvFpIuM3jmafVH7KnsqDwZJgrB/YN0IWNIBTq8GXTZ4tILn/yJxyEJ+Dt8KwKttXr2ndLTeIPHbqWh6fenP57sukZ6jw8fDjrUvdmDdhI40r2VfaL+SYPRe7Y7czeVbl/PtM4YEtnNrV23krUuC0bgqzDv/X66lXQMoUllR8OC5OzQQhOdKIBCUgf3R+4lOj8YONUNP/CI/DW05EibsIc3Cg1c2BPL+nxfI0xl4wseVHdO74etZ/mGAhTG4/mBszWyJTo/mYMzBEvcXxlXVwBgGdDbhLHn6PNP2pOwkJCTUCjU1LGpU1vQE1YQ8fR7vHnqXoIQgZh+abZKzfijJy4JTq2BJR9mwCvsHUMglMMbvhJcOgHdPVp5fSbYum2ZOzXis7mMFhpEkiX8v3WTAokO8tSmI2NQcajlY8vUzrdjxald6NHIpcy1BI41qNDKFVi07m997ZXyw8rDlWxkxFhMujqiF8FxVXYx/v1ZqK5wsS696/KARcTkCQRVjbdAPAIxMScIKJfT9CDpNJfRmBpPXHSciMRP17TDACV29yu1CXBysNFY81fApVgevZl3IOnrW6Vnsvnn6PEJvhQLCuKpsvOy9cLJwIikniaCEINq5y2GCxnwrZytnkdgtuC8rglYQnhoOQJYui3cOv8PafmsfrpDftBtw4gfZQ5V9S95mZgttx8q1qhy9TE1jM2JNubLT204vcG4+G53Cgp0hHI+QvcP2lhpe6dWAsX6e91UALC1TWk1hT+Qe/on6h5CkEHycfNDqtQTGBwIPX76VkWbOzVAqlMRmxpKQlXDPHFKdQUdMRgwgcq6qIo1qNOLLHl9ia2Zbra5J1WemAsEjwNlzP3M2+SIaSWJUnhrG/gF+09h+PpbhS4+YwgB/n+zHxG7eD9SwMvJck+dQKVQcjz1eINSkKC7fuozWoMXB3IHaNrUrcIaC+6FQKO7Uu7p5JzRQFBAWFJfQ5FBWnl8JwBvt3sBGY0NQQhArglZU8szKieunYfNEWNgCDn8tG1YOntB3Acy6CP0W5DOsAJadW4bWoKWDewf8PPxM2yMTM5n2yxmGLTnC8YhkzNRKXu7hzcE3ezGpu3eFGVYgC9j09+oPwNKzSwG5kHu2LhsHcwca1mhYYceuTKw11ibRpKDEe3uv4jLj0Bl0mCnNRJ5pFaVvvb50rtm5sqdRIoRxJRBUBSQJTvzAT0fmATBQb4bzxP3oPLvz6c4QXvklkKw8vZzoPL0bbepWXsiWh42HKdylJLLsxpDAZs7NKsUoFOSnsGLCQilQUBz0Bj0fHv0QnaTjsTqP8XzT55nTaQ4A3wd9z9n4s5U7wdKi10HwFljZB354DM7/DgYdeHaFketheiD4TQWLgpLoEakRJqEfo9cqMSOXuX9d4ImvD7AjKBaFAka0rc3+N3rybn8f7K3uX0i4PJjSagpKhRL/GH8uJF4w1bdq796+WnkDSkpxQgONSoF1bOs81J+F4MEi/pIEgspGmwNbXyF6zzvss7IAYNyQn0jSuDN25QlWHJTDbib3qM/aFzpUmBpgSRjbVJZl3x6+nVs5t4rVx5hY3NxJhARWBYzG1bn4c+Tqc4G7CggLMQtBEawLWceFpAvYamyZ02kOCoWCQd6DGOA1AINk4N1D75KpzazsaRaf7BQ4shgWt4bfx0P0cVBqoNVzci7VCzvAZxAUIfzwXeB3GCQDPev0pKF9Mxbvu0KP/+1nbcA1dAZJLpMxvRtfPdOKWg6WD2plANSzr8cg70EALDm7xPRA5WENCTRSHFELY40rIWYhKE8eosBogaAaknYDNo6F66f42ckRg0JBl5pdyMypzfM/HuZGag7WZiq+eLoVA1p4VPZsTbR2aU1Tp6ZcTLrIpsubmNRy0n37BCfKxYNbOLeo6OkJikE9u3q4WLqQkJ1AUEIQ7d3b3ykgLMJjBPcgOj2a7wK/A+D1dq/n+1uZ02kOgfGBxGTEsOD4Aj7u+nFlTbN4JF2F48shcD0YjUErJ2g3AdpPANviqZNdTLrInmt7UKDAW/UUPb7wJyFdfmDRsrY97/RvQuf6zhW1imIxueVkdoTv4PD1w6gUspH4sIpZGDF6ri4kXkBn0BWaC2g0roSYhaA8EZ4rgaCyiDom16+6fopUSwf+dJAV/+qpB/D08gBupObg7WzNn9O6VCnDCuScnTE+YwD49dKvaA3aIttnajNNie/NnJtV+PwE90ehUJiELIxPskWNK0FRSJLE/ID55Ohz6ODegScbPplvv52ZHZ92/RQFCv66+hd7IvdU0kyLQJIg3B9+GQnf+sKJFbJh5doMhnwHMy/CY3OKbVgB/HBbhMgsx5dFf2eQkJ5LXUcrvn2uDX9O7VLphhXInplhDYYBoJf0OFk44W3vXbmTqmC8Hbyx0diQrcsutJAyYFK4FGIWgvJEGFcCQWVwahWsGQQZN8G1Gb/3nEa2IQ87pSfLdyvJ0xvo3dSNP1/pQkM328qebaH0q9cPZ0tn4rPj2Ru5t8i2F5MuIiHhYe2Bs2Xl32gIZIxPro01b0xhgSLnSlAIf4b9ybHYY5irzJnrN7fQ3Ml27u2Y0GICAPMC5hGXGfegp1kQSYLYc+D/GSz1g5+GwuVdgASN+smF2acckRUANRbFHjYjV8dPAeHsu3YYgOTYTjhamzF3cFP+mdWDwa1qVmjtwZIyqeUkk/emvXv7hz73ValQmh7m3UvU4lr67RpXtiIsUFB+CONKIHiQ6HJh22uwfSYYtNB0KHnjt/NzxE4AbkZ3RKFQ8Gbfxnw/xhc7iweT8FwaNCoNIxuPBOSiwkVhyrcSEuxVCmPORVBCEDm6nDthgUItUPAfErIS+OLUFwBMaz2Nunb3DqOa2moqTZ2akpaXxnuH3ytVwfEyo8uDq//Cjjfgm+bwfXfwXwAJIaCxgvaT4JXTMGojePeEEhgaF2+kMWfLeTp+8g8f7t6NpMhB0lsypVN3DrzZkxe6eGGmrnq3V7VsapkiDvrV61fJs3kwFCVqoTfoiUmXZdiL+nsWCEqKyLkSCB4U6XFyflXMCUABj38AXWfybcB6knOTMGjtsNL68u0L7enRqHp4Dp5u9DQrglYQlBjEuYRztHJpVWg7k1KgkwgJrErUta2Lq5Ur8VnxnIg7QWpuKiA8V4KCLDixgPS8dJo6NTUJ2twLjUrDZ90+Y+T2kRyPO85PwT8xvvn4ip9kdopc3PfSDvnf3LQ7+9SWUP8xaNxfFqewLJniao5Wz46gWNYdv0ZgVIppu3vdaDKB7nU68WZvn3JZRkUyy3cWo31G425d/LDH6ozxmnQ+oaCoxc2sm2gNWjRKDe5Wj8bnIXgwCONKIHgQRJ+EjWMgIw4s7GHESqQGT/DjoXBWXVqL0hxq6B5jw6s9qeNoVdmzLTZOlk4M9B7In2F/sv7ielr1KNq4EmIWVQuFQkEH9w5sD9/O3xF/A2CuMsfOrKDUtODRZd+1fey9the1Qs38zvOLVSTYy96LN9u/yfyA+SwKXESnmp1o4tik/Cd36xqE/g2hO+HaEVk63Yi1KzTuB40HgFcPMCv5uTU8IYP1x6PYdDqG1Gw5t1StVNC3uTtjOnqyJnwrR29Al9ody2tFFYpCoXhkDCuAFi7yNedq6lXS8tLynduMYha1bWujKkIJUiAoKcK4EggqmjM/wY7XQZ8HLk3g2V/IsvXkrQ2B/H31AFZ141BhwR9jZuFqU30MKyNjfMbwZ9if7Lm2h1mZswpcuBOzE4nNjEWBgqZOTStploJ70d69PdvDt7Mvah8gy7A/7LkYguKTlpfGJ8c/AeCF5i/Q2LFxsfs+1fApDsUcYn/0ft4++DYbB23EQl38nKZCkSS4EXjHoLp5If9+lyayd6rxQKjlC8qSh+dp9Qb2BN9k/fFrHL2aZNpey8GSUR3r8nS72rjaWqA1aHntWCDw8MuaV1ccLRypbVObmIwYLiReyFeM1ljjSigFCsobYVwJBBWFLg92vwsnf5TfNxkEw5cTka5k8pKjhN5Mx6ruIQCe83kKV5vKKwxcFho7Nqa9e3tOxp1kY+hGXmv7Wr79Rgl2L3svbMxsKmOKgiIw3hRm67IBoRQoyM/Xp74mITuBenb1eLnVyyXqq1Ao+LDzh5zfep7w1HC+Pv01szvOLvkkdLkQcQhCd0DoLki/cddBlFDXT/ZONe4PTvVLPv5tYm5l8euJaDaeijZJqSsV8FgTV0Z39KR7IxdUdwlUBCcGk63LpoZ5DRo4NCj1cQUVSwuXFsRkxHA+4XyhxpUQsxCUN8K4EggqgvSbcjHKqKOAAnrNgW6vsy80gRkbz5Keo8PJMYk86ysoFUrGNB1T2TMuE6N9RnMy7iS/X/6dl1q+hKX6TpHMC0nyk2UhZlE1qW1TG3drd5Oqm8i3Ehg5HnuczVc2A/Bh5w8xV5mXeAxHC0c+6vIRU/6ZwoZLG+hWqxvdane7f8eMeLi6XzaowvZBXsadfRpraPC4bFA16gtWjiWelxG9QeLA5XjWH4tif2g8Bkne7mJrzrPt6/Bsh7r3LPprVNls594OpaLqCVgIZFq5tOLviL8LKAaaalwJMQtBOSOMK8EjjyTJV9NyC4WKPAKbXpBl1s3t4MkfMDTsy6J9V1i07woA7TxrULfxIfZGQ2/P3tSyqVU+x64ketbuSS2bWlzPuM6O8B081egp0z6hFFi1MeZdbb26FZDDAgWCbF02Hx79EICRjUfi6+Zb6rG61urKqCaj+OXSL7x/5H02D9mMk6XTnQa6XIg7DzEn77xSovIPYuMue6aaDIR63UokmV4Y8ek5/HYymg0normekm3a3qWBE6M7etK7qRsaVdEGk9G4EiGBVZu7FQMlSTJd66PTb9e4shU1rgTlizCuBI80WoOWV/a9QnhqOJ92/bRsF0lJgqPfwj8fgqQHFx8Y+TOpVvWYsfYk+0Nlmetxfp5M6uXE4L92AzC+2fiyL6SSUSlVjGoyii9OfcH6kPWMaDgChUKBJEmmsMDmTsK4qqq0c2tnMq5EWKAAYOnZpcRkxOBm5caMtjPKPN5M35mciDtBWEoYcw+8ybc1+6O4cUY2pGLPyTmp+VCAW/PbghT9waNNqfKn7karN3A8PJkNJ6LYHRyH7rabyt5Sw9O+tRnVsS7eLsULXc7T53E2/ixwp16coGrS2LExGqWGlNwUYtJjqGNXB4NkMBlXdexEWKCgfKl0P/bSpUvx8vLCwsICX19fDh06VGT7AwcO4Ovri4WFBd7e3ixfvvyebX/99VcUCgXDhg0r51kLHhbWXFjD0RtHicuM46W9L7HlypbSDZSTKqsB7n1fNqxajoRJ+wjRujFkyWH2hyZgrlby1dOtmDe0Ob9f+RWdQUdb17YPjUdneMPhWKmtCEsJ41jsMQBiMmJIyU1BrVSXKBFe8GDp4HHn5lCEBQqCE4P56eJPAHzg90HZciVzMyDiEBYBS/ksAzSSxIGbJ/l97ww4tlQ2rvR5YOUkF/R97D25qO87UTDlsPy+lMIUkiRx5WY6qw5H8OKak7Set4cxK4+z43wsOoNE27oOfP1MK47Pfpz3BjUttmEFshckV5+Lk4UT3vbeJZ6b4MFhpjLDx0mWyT+XeA6QC6bn6nNRK9R4WHtU5vQEDyGV6rnauHEjM2bMYOnSpXTp0oXvv/+e/v37c/HiRerWLRgDGxERwYABA5g0aRLr1q3jyJEjTJ06FRcXF0aMGJGv7bVr13jjjTfo1q0Ysd2CR5KwW2EsO7cMgKZOTbmYdJEPjn5AeGo4M9rOKL40a9x5+O15SA4HlRn0+wzavchf527wzubzZGv11K5hyfIxvjSvZU+WNovfL/8OwLhm4ypqeQ8cWzNbhjUYxi+XfmFdyDr8avqZvFaNazTGTGVWyTMU3ItaNrWoY1uH6PRokdz9iKM1aPng6AcYJAP9vfrTvXb34nc2GCDpyl3hfacg/iLcLiLcGHjNzpYvnWrwhZMj7RoOwbteL6jdDmp4laiQ771ISM/lSFgih64kciQskbi0nHz7Ha3N6N/cndEdPWlas/QlB07ePAnIIYFCXbPq09K5JUEJQZxPOM8g70EmMYtatrWKVVpAICgJlfoX9fXXXzNhwgQmTpwIwMKFC9m9ezfLli1jwYIFBdovX76cunXrsnDhQgB8fHw4deoUX375ZT7jSq/XM3r0aObNm8ehQ4dISUl5EMsRVCN0Bh3vH3kfrUFLz9o9WfTYIpaeXcr3Qd+zJngNkWmRfN7tc6w095FGD1wPO2aBLgfs68Aza8l1a82nW4NZG3ANgG4NnVn8bBtqWMvGxZawLaTnpeNp50nPOj0reKUPllE+o9hwaQMHYw5yLe2aqb7Vw+Kde5j5sseXhCaHmvITBI8mqy+s5vKtyziYO/BOh3fu3VCbDUlhkBAKCZdkQ+r6GbhdiDofdrVlA6p2e8bW8uXwpR85FneCdxRJrG82HI1KU+r5ZufpORGZzOErCRy6ksiluPR8+83USjrUc6RrQ2e6NnCmqYcdSmXZjaGTcXeMK0HVp6VLSwiRPY5wl5iFkGEXVACVZlzl5eVx+vRp3nkn/8m7T58+HD16tNA+AQEB9OnTJ9+2vn37snLlSrRaLRqNfIKeP38+Li4uTJgw4b5hhgC5ubnk5uaa3qelpRXRWvAwsDZ4LReSLmBrZsv7fu+jVCh5pc0reNl78cGRD/CP9uf5v5/n28e+xcOmkJABbQ78/aZcwwqgQW94cgVR2RZMWxbA+evyDca0XvWZ1buxSb5XZ9Dx88WfAXi+6fMPncKUp50n3Wt350DMAdaHrCc0ORQQxlV1oKlTU1GH7BEnPDWc5efkUPu32r+Fo4UjZCXLBlTi5TuvhNDbghNSwUHUllCrrWxM1Won/2tX07RbCXzs7M2IbSMISQ5hydklzPCdUew56g0SwTdSOXQlkcNXEjl97RZ5ekO+Ns1q2tG1oTPdGrjQrl4NLDTlWyA2V5/LuXg5vEwYV9WDli7yQ6NLty6Rq88VSoGCCqXSjKvExET0ej1ubm75tru5uREXF1don7i4uELb63Q6EhMT8fDw4MiRI6xcuZKzZ88Wey4LFixg3rx5JV6DoHoSnhLO0rNLAXi7/dv5EvgHeg+klk0tXtv/GqG3Qnlux3Msfmyx6cQMQHKEHAYYF4Qssz4bur3BrovxvLnpJOk5OhysNHzzTGt6NckvDrAvah/XM65Tw7wGg+sPfhDLfeCM9hnNgZgD/Bn2p2lbC+cWlTchgUBQNAYDhtQo5u2fgdagpavGiUEHlsDmGZCVeO9+Fvbg3BhcGkHNNlC7Pbg2hft4otys3ZjrN5dZ/rNYdWEVXWp1KdJIiU7O4nCYbEwduZpISpY23/6a9hayZ6qhC13qO+FkU3LJ+JJwLv4ceYY8XCxdqGdXr0KPJSgfalrXxNHCkeScZEKSQkSNK0GFUumBpv+NVb5bJrO47Y3b09PTGTNmDD/88APOzs7FnsO7777LrFmzTO/T0tKoU0f84B5G9AY97x99nzxDHl1rdWVI/SEF2rR2bc2GgRt45d9XuHLrCi/seoGPu35Mf6/+EPo3bHlZFrCwcoIRP5Ln2ZMFO0JYfSQSgLZ1HfhuVFtq/qc2iiRJrA1eC8DIJiPz1YJ6mOjk0YkGDg0ISwkDwEptJW5ABIKqgC4Xkq7m90AlXoakMH6zUHLG2RErg4EPrgah0Ovv9LOrLRtQzo3BuSG4NAbnRmDtUuo8qd6evRneYDhbwrYw+/BsNg/ZjK3Glvj0XK4lZXEtKZOz0SkcDkvkWlJWvr625mo61Xei2+1QPy9n6wea93S3BLvIt6oeKBQKWrq0xD/an6CEIBEWKKhQKs24cnZ2RqVSFfBSxcfHF/BOGXF3dy+0vVqtxsnJieDgYCIjIxk8+I5HwGCQwwXUajWhoaHUr1+weru5uTnm5hX7pEtQNVgXso6ghCBsNDbM9Zt7zwtjTZua/Nz/Z94++DYHYg7w1sG3iAhczZSg3ShAfkL79Bqi9Y688n0A56JTAHipuzdv9m1caH2UwPhAzieex0xpxrONn624RVYyCoWC0T6jmRcge4ObOTcrvjiIQCCoGNJi4ZumJnGJu4lVqfjGUQ5/fs2sDh6dn71tQDUEp4ZgXga1wP+g0xu4kZLDteRMPBWjsFHKaq1PrJlOevRIsrUF56dSKmhTx0EO9WvoTKvaDqjvU4OqIjHmWwkJ9upFK5dW+Ef7cy7hHNFpt2tc2YkaV4Lyp9KMKzMzM3x9fdm7dy/Dhw83bd+7dy9Dhw4ttI+fnx/btm3Lt23Pnj20a9cOjUZDkyZNOH/+fL797733Hunp6SxatEh4ox5xIlIj+DbwWwDebP8m7tbuRba31lizqNcivjn2CWuv/M6y9BAiXJz4qN5wLPouYO/lW7z+2yHScnTYW2r46ulWPNG08AcDgMlrNbj+4PwFNB9CBnkPYtGZRaTkpoj6VgJBVcDWXc6HUqpkr5NzI3BphOTUkI8iNpGVcJrWLq15tv9aKGMuaI5WT3RyFpG3PVBRt/8flZRJzK1sU30pAKXFCKzqLSfb/DRaywYodW2oVcMST0drGrja0LWBMx29HbG1KL3oRXmSrcsmKFEWRRDGVfXCGJ5+5MYRcvQ5qBSqwnOqBYIyUqlhgbNmzWLs2LG0a9cOPz8/VqxYQVRUFJMnTwbkcL3r16/z00+yaMDkyZP57rvvmDVrFpMmTSIgIICVK1eyYcMGACwsLGjePP+NnIODA0CB7YJHC71BzwdHPiBXn0vnmp0Z3mD4/TsBqugTvHF0PV6k87GzI7tsrImRbtBg12l+PpwMQKs6DiwZ1YbaNe6tLHgt7Rr7o/cD8Hyz58u+oCqOhdqC6W2ns/zscgZ6D6zs6QgEjzw6g8QHnuvJVjugUCpQ6hQo4yA25ihnc0+jRI1T9hjmbb2IQqFAoQClQoHy9r+Ku/6vVHD7vfx/gwTXU7K4lpRFVHIWsak5Rc7FTK2krqMV9ZysqOvoxXVSOJr8C06e29k4cBz1HKrug9Cz8WfRGXS4W7tT27Z2ZU9HUAKaOzdHgYJMbSYgR6holFXDaBc8XFSqcTVy5EiSkpKYP38+sbGxNG/enJ07d+LpKbtpY2NjiYqKMrX38vJi586dzJw5kyVLllCzZk0WL15coMaVQPBffrn0C2cTzmKtseZDvw/vHycvSRCwBPZ+AJKeEc6NqdPpbV478zUXki4QpH0Tpfk4xrfrwjv9m2CmLvpJ788Xf0ZConvt7o9MwcmnGz3N042eruxpCAQCQC9J/HIhC7iTv6RQZWLlvRalGrLje/FniA64Vi7HszVX4+lshaejNXWdjIaUNZ5OVrjbWeSTQ9cZGvHCroucTTjL3ID3WNV3VZUNJb47JFDkW1UvrDXW1Heob8oHFvlWgoqi0gUtpk6dytSpUwvdt2bNmgLbevTowZkzZ4o9fmFjCB4totKiWHxmMQCvt3v9/mEAOWnw1zQI2Sq/b/4UDF5EZkQWWZE5GJx/RGmeSI0GK+jWqgFm6qLlq1NyUvgr7C8AxjcbX9blCAQCQYlRKRS8P6gpkiRhkCQMEuxJ+JormZk4ajwZ1mYiCtQYJPK1MUgSkgQGw93v7/xfjvCTcLezxNPJ6rYhZU0NK02xjQ+1Us2n3T7l6W1Pcyb+DCsvrOSlli9V6OdRWoxiFu3c2lXyTASloZVLqzvGlZBhF1QQlW5cCQQViUEy8P6R98nR59DRoyNPNXyq6A43g2HjWEi+CkoN9P0Une8Evtx7heUHrgIONLV9B8daGzmXeJLX9r/GTN+ZjG82/p43EhtDN5Kjz8HH0UdckAUCQaWgVimZ0NXL9P5gzEGWRB5EqVCypM9nNHeu3BpndWzrMLvjbOYcnsOys8vw8/CjhUvVKuGQpc0iODEYgA4eIt+qOtLSpSWbr2wGhOdKUHE8XBVMBYL/sOHSBs7En8FSbcm8zvOKfpJ67lf44XHZsLKrDS/uIq7J8zz34/HbhhWM8/Nky5QnWN3/e55p9AwSEl+f/poPjn6AVq8tMGSuPpdfLv0i9202ToSRCASCSidTm8lHxz4CYIzPmCpT5Huw92D61uuLTtLxzqF3yNJm3b/TA+RM/Bl0ko5aNrWoZVOrsqcjKAV311wUnitBRSGMK8FDS3R6NIvOLALgdd/X730x1ObAthly/SpdNtR/DF4+yIEsTwYsPsTJyFvYmKtZMqot84Y2x1ytQqPU8F6n93inwzsoFUr+DPuTSXsncSvnVr6hd4TvIDknGXdrd/rU61PBKxYIBIL7s/D0QuIy46hlU4tpradV9nRMKBQK3u/0Pm5WbkSlR/G/k/+r7Cnl4+76VoLqibe9NzXMa6BUKKnvULA0j0BQHoiwQMFDiUEyMPfoXLJ12bR3b8/Tje8hrBAbBH9NhbjzgAJ6vI2+25ss/Pcq3+0PQ5KgqYcdS0e3pZ6zdb6uxnpOdW3r8ubBNzl98zSjdoxiyeNL8HbwxiAZTPLrY3zGCFUigUBQ6QTGB7IxdCMAH3b+ECtNfpVTvV6PVlvQC/+gMMecTzt+yntH3uPotaMEewVTv0bVuAkOTwjHw8yDzi6dyckpWhFRUHVZ0mMJKbkpOKmdxPcoyIeZmRlKZdn9TsK4EjyU/B76OyfjTprCAZX/rduiy4WDX8Lhr8GgA0tHePIH4t26Mn3VSY6FyzLrozvW5f1BTbHQ3Fu5qlvtbqzrv45X/n2FmIwYxuwcw5c9vkQn6QhPDcdGY8OIhkLRUiAQVC65+lzmHp2LhMTwBsPp5NHJtE+SJOLi4khJSam8Cd7GFlvmNplLji6HjJsZRKREVPaUMEgGnnR6EslJwk3rRkRE5c9JUDrUqHHGWXyHggIolUq8vLwwMzMr0zjCuBI8dFzPuM5Xp78C4LW2r1HH9j81U2JOy2qACSHye5/BMOArjtxU8driQyRm5GFtpuLTJ1swtHXx4uob1GjALwN/Ycb+GQTGBzJ131TcrOSCwiMajsDGzKbc1icQCASlYUXQCiJSI3C2dOb1dq/n22c0rFxdXbGysqr0/FCXPBdiM2NRK9TUs69X6fPJzMvEkGlAo9RQz75epc5FIBCUPwaDgRs3bhAbG0vdunXLdM4RxpXgoUKSJFM4YFvXtjzX5Lk7O7XZsP9TCPgOJANYOcPAr9D7DOXbf6+waN8VJAmauNuyZHRb6ruUzCBytHDkxz4/Mi9gHluvbuVG5g1UChWjfUaX8yoFAoGgZFy5dYVV51cBMLvjbOzN7U379Hq9ybBycnKqrCnmw8zcjARtAgbJgEFtwFpjff9OFUiKPgWlRomdhR0WFhaVOheBQFAxuLi4cOPGDXQ6HRpN6VM5hHEleKjYdGUTx2OPY6Gy4KMuH90JB7wWIHurkmXVP1o8A/0+41qOBW//eMwUBvhs+zp8OKRZkWGARWGmMuPjLh/jZe/FksAlPNvk2fvX1RIIBIIKxtPOkwktJnAt7Rq9PXvn22fMsbKysiqsa6WgVCixN7fnVs4tUnNTK924ytRmAhTIURMIBA8PxnBAvV4vjCuBACA2I5avTsnhgNPbTpdlVvMy4Z95cGIFIIGtBwz6Bn3Dfqw+EsGXe06QozVgqVHx6ZPNGd6mdpnnoVAomNhiIqN9RmOhEk84BQJB5WOmMuOVNq8gSdI921R26N1/sTeTjau03DTcrd0L5s4+IHQGHTk6WfjAWl25Rp5AIKg4yuscKIwrwUOBJEl8GPAhmdpMWru0ZlSTURB+ALa+CinX5EZtxkCfTwhNVfHWsqOci04BoHN9Jz57siV1ncr3iaSl2rJcxxMIBIKyUtUMqKKw0lihVqrRGXRk5GVgZ25XKfMw1tsyU5mhUQnVV4FAUDSizpXgoWBL2BaO3jiKucqc+e3eQrVjFvw0RDas7OvAmD/IG/gt3xyOZ9C3hzgXnYKthZrPR7Rg/cSO5W5YCQQCgaBsKBQKU25Yal5qpc1j7797ae7SHF2mrth96tWrx8KFCytuUoL74u/vj0KhqBIKmGXlww8/pHXr1iXq07NnT2bMmFHuc1mzZg0ODg7lPu7DhDCuBNWeuMw4vjj5BQCv1O6D17qRcHqNvLP9RJgaQKBZWwZ9e4hF+66g1Uv0burGP7N6MLJ92RRhBALBw8nSpUvx8vLCwsICX19fDh06VGT7AwcO4Ovri4WFBd7e3ixfvrxAm5SUFKZNm4aHhwcWFhb4+Piwc+fOilrCQ4HRuErPS0dv0BfYP378eBQKBZMnTy6wb+rUqSgUCsaPH1+mOeTo5ZDA8sy3Gj9+PMOGDSu38aB0N+AVza1btxg7diz29vbY29szduzYUhs72dnZ1KhRA0dHR7Kzs8t3ooUQHBzMiBEjqFdPVqu8l7Fc0nOFoCCSJPHhhx9Ss2ZNLC0t6dmzJ8HBwfftt3nzZpo2bYq5uTlNmzZly5Yt+fZ/+OGHKBSKfC93d/eKWoYJYVwJqjWSJDEvYB4Z2gxaqmwZ678E0q5DjXowbjtZvT/no73RPLnsKJdvZuBkbcZ3o9qwYqwvbnYiH0ogEBRk48aNzJgxgzlz5hAYGEi3bt3o378/UVFRhbaPiIhgwIABdOvWjcDAQGbPns306dPZvHmzqU1eXh69e/cmMjKSTZs2ERoayg8//ECtWsUr9/CoYqGywExlhiRJpOelF9qmTp06/Prrr/luuHNyctiwYQN169Yt0/F1Bh15+jzg0RazyMvLK1W/UaNGcfbsWXbt2sWuXbs4e/YsY8eOLdVYmzdvpnnz5jRt2pQ//vijVGOUhKysLLy9vfnss8/ueUNe0nOFoHD+97//8fXXX/Pdd99x8uRJ3N3d6d27N+nphf/mAQICAhg5ciRjx47l3LlzjB07lmeeeYbjx4/na9esWTNiY2NNr/Pnz1f0ckASFCA1NVUCpNTU1MqeiuA+/HnlT6n5muZS29XNpKsfO0rSXHtJ+vtdScrNkI5cSZC6ff6v5Pn2dsnz7e3SzF8DpeSM3MqeskAguA+VfQ7u0KGDNHny5HzbmjRpIr3zzjuFtn/rrbekJk2a5Nv28ssvS506dTK9X7ZsmeTt7S3l5eWVel4V9blkZ2dLFy9elLKzs03bDAaDlJmrrZSXwWDIN7+bmTelCwkXpMjUyAJzHzdunDR06FCpRYsW0rp160zb169fL7Vo0UIaOnSoNG7cONP2nJwc6dVXX5VcXFwkc3NzqUuXLtKJEyfyjbljxw6pYcOGkoWFhdStezfp48UfS4B069YtU5sjR45I3bp1kywsLKTatWtLr776qpSRkWHa7+npKX3zzTeFft5z586VgHyv/fv3S5IkSTExMdIzzzwjOTg4SI6OjtKQIUOkiIgIU9/9+/dL7du3l6ysrCR7e3upc+fOUmRkpLR69eoCY65evfoe3/j9MX6un376qeTh4SF5enqWeIyLFy9KgHTs2DHTtoCAAAmQLl26VOLxevbsKS1fvlxatmyZ1KtXrwL77/7eevbsafpM7v7eSsu9vs+SnivuxVtvvSU1bNhQsrS0lLy8vKT33nsv37li7ty5UqtWrUzvjd/Phx9+KLm4uEi2trbSSy+9JOXm3rnH6dGjh/Tqq69Kb775plSjRg3Jzc1Nmjt3br7jfvXVV1Lz5s0lKysrqXbt2tKUKVOk9PT0fG1Wr14t1alTR7K0tJSGDRsmffnll5K9vX2J1lcUBoNBcnd3lz777DPTtpycHMne3l5avnz5Pfs988wzUr9+/fJt69u3r/Tss8+a3v/3c7sfhZ0LjZTk/CsELQTVlvjES3x+ZC4AU2+l4G3vDUOXkOrchgXbQvj1ZDQANe0t+OTJFvRq7FqZ0xUIBNWAvLw8Tp8+zTvvvJNve58+fTh69GihfQICAujTp0++bX379mXlypVotVo0Gg1bt27Fz8+PadOm8ddff+Hi4sKoUaN4++23UakKL/2Qm5tLbm6u6X1aWloZV1d8srV6mn6w+4Ed724uzu+Lldmd2xN7M3sSshLIyMtAZ9ChVha8dXnhhRdYvXo1o0fLdQVXrVrFiy++iL+/f752b731Fps3b2bt2rV4enryv//9j759+xIWFoajoyPR0dE8+eSTTJ48mSlTpvDP4X+Y++7cfGOcP3+evn378tFHH7Fy5UoSEhJ45ZVXeOWVV1i9evV91/fGG28QEhJCWlqaqb2joyNZWVn06tWLbt26cfDgQdRqNR9//DH9+vUjKCgIpVLJsGHDmDRpEhs2bCAvL48TJ06gUCgYOXIkFy5cYNeuXfzzzz/y52ZvX+jx/f396dWrFxEREdSrV++e89y3bx92dnbs3bvXpDI5efJk1q1bV+T6Ll68SN26dQkICMDe3p6OHTua9nXq1Al7e3uOHj1K48aN7/tZGbl69SoBAQH88ccfSJLEjBkzCA8Px9vbG6DA93bq1Clefz1/oeyoqCiaNm1a5HHGjBlTaEhvYZTmXHEvbG1tWbNmDTVr1uT8+fNMmjQJW1tb3nrrrXv22bdvHxYWFuzfv5/IyEheeOEFnJ2d+eSTT0xt1q5dy6xZszh+/DgBAQGMHz+eLl260Lu3XI5BqVSyePFi6tWrR0REBFOnTuWtt95i6dKlABw/fpwXX3yRTz/9lCeffJJdu3Yxd27+38OhQ4fo379/keubPXs2s2fPLnRfREQEcXFx+c6h5ubm9OjRg6NHj/Lyyy8X2i8gIICZM2fm29a3b98C4ZtXrlyhZs2amJub07FjRz799FPT301FIYwrQfVDkpAubGZ+wPukm6tpnpvHuOYToOe77Lmcwns/HSA+Xb4hGdvJk7f6NcbWQig8CQSC+5OYmIher8fNzS3fdjc3N+Li4grtExcXV2h7nU5HYmIiHh4ehIeH8++//zJ69Gh27tzJlStXmDZtGjqdjg8++KDQcRcsWMC8efPKZ2HVGHO1ORZqC3J0OaTlpuFo6VigzdixY3n33XeJjIxEoVBw5MgRfv3113zGVWZmJsuWLWPNmjWmm8EffviBvXv3snLlSt58802WLVuGt7c333zzDQqFApWbisBzgaz8dqVpnC+++IJRo0aZxAIaNmzI4sWL6dGjB8uWLbtvkWEbGxssLS3Jzc3NF262bt06lEolP/74oykXePXq1Tg4OODv70+7du1ITU1l0KBB1K9fHwAfH59846rV6vvmlFhZWdG4ceP71vGxtrbmxx9/NNX+AZg/fz5vvPFGkf1q1qwJyL8LV9eCDzVdXV3v+Vu6F6tWraJ///7UqFEDgH79+rFq1So+/vhjgALfW+PGjTl//jyff/55vnmdPXu2yOPY2RVfkbI054p78d5775n+X69ePV5//XU2btxYpHFlZmbGqlWrsLKyolmzZsyfP58333yTjz76CKVSzvpp2bKlyRhq2LAh3333Hfv27TMZV3cLXnh5efHRRx8xZcoUk3G1aNEi+vbtazIgGzVqxNGjR9m1a5epX7t27e77uTo6FvzNGjF+VoV9jteuXSuy3/0++44dO/LTTz/RqFEjbt68yccff0znzp0JDg6u0ILpwrgSVC/S42DH62yP/pcDrs5oJPio55fc8ujDh78HsyMoFgAvZ2s+H9GSDl73/kELBALBvfiv0I0kSUWK3xTW/u7tBoMBV1dXVqxYgUqlwtfXlxs3bvDFF1/c07h69913mTVrlul9WloaderUKdV6SoqlRsXF+X0fyLEKO/Z/sTe3J0eXQ2peaqHGlbOzMwMHDmTt2rVIksTAgQNxdnbO1+bq1atotVq6dOli2qbRaOjQoQMhISEAhISE0KlTJxQKBTqDjlxdLq3at8o3zunTpwkLC2P9+vWmbZIkYTAYiIiIyGfwlATjuLa2tvm25+TkcPXqVfr06cP48ePp27cvvXv35oknnuCZZ57Bw6Nkheo7dOjApUuX7tuuRYsW+QwrkA2jwgyme1HYb+Z+v6X/otfrWbt2LYsWLTJtGzNmDDNnzmTevHmoVKp835sRPz+/fOOo1WoaNGhQ7OMWl5KeKwpj06ZNLFy4kLCwMDIyMtDpdPc19Fq1apWv8Lefnx8ZGRlER0fj6ekJyMbV3Xh4eBAfH296v3//fj799FMuXrxIWloaOp2OnJwcMjMzsba2JiQkhOHDh+cbw8/PL59xZWlpWezPdf369fk8UX///bfJc1+az/F+fe72qLVo0QI/Pz/q169v8uhVFMK4ElQP8jLh1Co4+CUJ2jQ+qyU/GZvceipBGW2Y/80BUrK0qJQKXuruzWuPN8SikAu0QCAQFIWzszMqlarAk+f4+PgCT0mNuLu7F9perVabno56eHig0WjyhQD6+PgQFxdHXl5egZtYkENjzM3Ny7qkUqFQKPKF5lU29mb23My8SZY2izx9Hmaqgp/Xiy++yCuvvALAkiVLCuz/r8F793bjNumuIsuZ2kyAArWtDAYDL7/8MtOnTy9wjLIIaBgMBnx9ffMZbUZcXFwA2ZM1ffp0du3axcaNG3nvvffYu3cvnTp1KvVx74W1dcGCySUJC3R3d+fmzZsF9ickJNzzt1QYu3fv5vr164wcOTLfdr1ez549e+jfv3+RxbGNlHdYYGnOFYVx7Ngxnn32WebNm0ffvn2xt7fn119/5auvvir2GHdz99/3f72TCoUCg8EAwLVr1xgwYACTJ0/mo48+wtHRkcOHDzNhwgS0Wi1AsT7XkoQFDhkyJF+YaK1atYiNlR+Kx8XF5XtQcL/P8V7n3aL6WFtb06JFC65cuVLkfMtK1TlzCgSFkZcFp1bCkUWQmYAEfFS3PmkqLQ3sm3AksBUHQs8B0NTDjv891ZLmtQqPMxcIBIL7YWZmhq+vL3v37s33xHbv3r0MHTq00D5+fn5s27Yt37Y9e/bQrl07081Nly5d+OWXXzAYDKaQncuXL+Ph4VGoYSXIj0alwVpjTaY2k9TcVFysXAq06devn0nVrm/fgl63Bg0aYGZmxuHDhxk1ahQAWq2WU6dOmcKjmjZtyp9//gncMa6Cz+SXhG7bti3BwcFl8oKYmZmh1+eXlm/bti0bN27E1dW1SK9FmzZtaNOmDe+++y5+fn788ssvdOrUqdAxy5uShAX6+fmRmprKiRMn6NChAyDn8KSmptK5c+diH3PlypU8++yzzJkzJ9/2zz77jJUrV9K/f/9835uRY8eOFZhXeYYFluZcURhHjhzB09Mz3/qKCoczcu7cObKzs7G0tATk9drY2FC7du1iHffUqVPodDq++uor0znpt99+y9emadOmBT7H/74vSVigra1tAc+sl5cX7u7u7N27lzZt2gByPtuBAwfyhXX+Fz8/P/bu3Zsv72rPnj1F/m3l5uYSEhJCt27dipxvmSm2hMYjRGUrVQkkScrNlKQj30rS/+pL0lw7+bWwpbRj32yp+ZrmUss1raWmH62UPN/eLjWcs1P67t8rUp5OX9mzFggE5UBln4N//fVXSaPRSCtXrpQuXrwozZgxQ7K2tpYiI2W1unfeeUcaO3asqX14eLhkZWUlzZw5U7p48aK0cuVKSaPRSJs2bTK1iYqKkmxsbKRXXnlFCg0NlbZv3y65urpKH3/8cbHn9SDVAqsiydnJ0oWEC9KVW1dM24yqaUZSU1PzfT7/VQt87bXXpJo1a0p///23FBwcLI0bN06qUaOGlJycLEmSJF27dk0yMzOTZs6cKe06vkv6fPnnkpu7Wz7VuXPnzkmWlpbS1KlTpcDAQOny5cvSX3/9Jb3yyium4xSlFihJkvTJJ59IdevWlS5duiQlJCRIeXl5UmZmptSwYUOpZ8+e0sGDB6Xw8HDJ399fmj59uhQdHS2Fh4dL77zzjnT06FEpMjJS2r17t+To6CgtXbpUkiRZIdHa2loKDAyUEhISpJycnEKPffz4calx48ZSTEzMPef338+1tPTr109q2bKlFBAQIAUEBEgtWrSQBg0aVOz+8fHxkkajkf7+++8C+/bs2SNpNBopPj4+3/d26dIlaf369ZK7u3uZ1AJzc3OlwMBAKTAwUPLw8JDeeOMNKTAwULpy5c7f3/3OFcXhzz//lNRqtbRhwwYpLCxMWrRokeTo6JhPka8wtUAbGxvpueeek4KDg6WdO3dKbm5u+VQKe/ToIb322mv5jnX37yEwMFACpIULF0pXr16VfvrpJ6lWrVr5PrOAgABJoVBIn3/+uRQaGip9++23koODQ7mqBUqSJH322WeSvb299Mcff0jnz5+XnnvuOcnDw0NKS0sztRk7dmy+9R05ckRSqVTSZ599JoWEhEifffaZpFar86lTvv7665K/v78UHh4uHTt2TBo0aJBka2t7z++nvNQChXFVCJV9YX+kuYdRJZ35WUpIj5X81neRmq9pLjX8Yobk+fZ26cmlR6QrN9PvP65AIKg2VIVz8JIlSyRPT0/JzMxMatu2rXTgwAHTvnHjxkk9evTI197f319q06aNZGZmJtWrV09atmxZgTGPHj0qdezYUTI3N5e8vb2lTz75RNLpdMWe06NuXGn1Wik4MVi6kHBBytbKc72fEfBf4yo7O1t69dVXJWdn53tKsW/btk1q0KCBZGZuJvl28pV++PGHAjfpJ06ckHr37i3Z2NhI1tbWUsuWLaVPPvnEtP9+xlV8fLypP3dJscfGxkrPP/+8aX7e3t7SpEmTpNTUVCkuLk4aNmyY5OHhIZmZmUmenp7SBx98IOn18oPFnJwcacSIEZKDg0ORUuz79++XgHwS7/+lvIyrpKQkafTo0ZKtra1ka2srjR49uoCx4+npWUAi3MiXX34pOTg4FFrCQKvVSo6OjtJXX30lSdKd783c3Fzq1q2btGrVqjIZVxEREQXk7YECv/2izhWSJBtG95Oyf/PNNyUnJyfJxsZGGjlypPTNN9/c17gaOnSo9MEHH5j6TZw4MZ9BfT/jSpIk6euvv5Y8PDwkS0tLqW/fvtJPP/1U4DNbuXKlVLt2bcnS0lIaPHhwuUuxS5Isxz537lzJ3d1dMjc3l7p37y6dP38+X5sePXrkm7skSdLvv/8uNW7cWNJoNFKTJk2kzZs359s/cuRIycPDQ9JoNFLNmjWlJ598UgoODr7nPMrLuFJIUjECKh8x0tLSsLe3JzU1tUQuYkEZyMuC06vh8ELIvJ1s6eAJ3d+EVs+SlG1g4o53CcvZiz7HA66/xtv9mjG2kydKZckSRwUCQdVGnIMLp6I+l5ycHCIiIvDy8rqv0l1lE5UWRXpeOs6WzrhZFz+vpaSk5qYSkx6DhdqC+g71K+w4jzrZ2dk4Ojqyc+dOevXqVdnTqRDGjx8PwJo1a8p1zJSUlAKhkIKyUdS5sCTnX2VFTrI4LF261LQIX19fDh06VGT7AwcO4Ovri4WFBd7e3gUSD//44w/atWuHg4MD1tbWtG7dmp9//rkilyAoC9psCFgKi1vD7tmyYeVQF4Z8C6+e5lbjkfxv71W6ff0HV7L/BaCxeix7ZvZiXOd6wrASCASCRwh7czmnNjU3tVjJ9qXFmG9lrSko6iAoPw4cOMBjjz320BpWIK/xo48+quxpCB4glSposXHjRmbMmMHSpUvp0qUL33//Pf379zcpzfyXiIgIBgwYwKRJk1i3bh1Hjhxh6tSpuLi4MGLECEBOmpszZw5NmjTBzMyM7du388ILL+Dq6lpogqugktBmw6nVcGQhZNxWE3Koe9tT9RypebByXzirjkSSkavD3P1fVAo9De1as3nYmBLLnAoEAoGg+mNrZotSoURr0JKty8ZKY3X/TqVAGFcPhn79+tGvX7/KnkaFEhERUdlTEDxgKjUssGPHjrRt25Zly5aZtvn4+DBs2DAWLFhQoP3bb7/N1q1bTfUoQJYFPXfuHAEBAfc8Ttu2bRk4cGCxnxyIkJQKRJsNp9fA4W/uGFX2daH7G9DqOdJ1ClYfieSHQ+Gk5+gAaFhTT4LDh+glLav6rqK9e/vKm79AIKhwxDm4cERYoMz19Ouk5KbgaOGIh03JajwVB61ey+VblwFo4tgElVKU9RAIHgWqfVhgXl4ep0+fpk+fPvm29+nTh6NHjxbaJyAgoED7vn37curUKZMm/91IksS+ffsIDQ2le/fu5Td5QcnRZsOx5bCoNex6Rzas7OvC4EXw6mkym49myaEouv1vP1/vvUx6jo7GbrYsH9OWHh3Oo5e0tHNrJwwrgUAgeMQxhQbmpWKQDOU+vtFrZaG2EIaVQCAoMZUWFpiYmIhery9Q7MvNza1AUTAjcXFxhbbX6XQkJiaaio+lpqZSq1YtcnNzUalULF26lN69e99zLrm5ueTm5prep6WllXZZgv+izYEza+HQ15Bx+3u1rwPdXofWo8k2qPj5aCTLD4STnCnXJ6nvYs2MJxoxsIUHCdnxzP5jMwBTWk2prFUIBAKBoIpgrbFGpVShN+jJ1GZia2Z7/04lIFMnQgIFAkHpqfQiwkVVSi9u+/9ut7W15ezZs2RkZLBv3z5mzZqFt7c3PXv2LHTMBQsWMG/evFKuQFAoRqPq8DeQLlffvtuoypFUrD8WxTL/qyRmyIatl7M1rz3ekMGtaqK6LVSx6sIqtAYtbV3bCq+VQCAQCFAoFNib2ZOck0xqbmr5G1ci30ogEJSBSjOunJ2dUalUBbxU8fHxBbxTRtzd3Qttr1arcXJyMm1TKpWmyumtW7cmJCSEBQsW3NO4evfdd5k1a5bpfVpaGnXq1CnNsh5tJAmun4agjXBhM2QlydvtakP316H1GHJR8euJaJbsDyM+XTaq6jhaMv2xhgxvUwu16k6kanxWPJsubwJgSuspQsRCIBAIBIAcGpick0x6XjoGyYBSUT5ZDnn6PLR6Oc3ASl0xYhkCgeDhptKMKzMzM3x9fdm7dy/Dhw83bd+7dy9Dhw4ttI+fnx/btm3Lt23Pnj20a9cOjUZzz2NJkpQv7O+/mJubY25uXsIVCEwkXYXzv8tGVXL4ne12taHbLGgzhjw0/H46mu/+DSM2NQeAWg6WvPpYA0b41kajKnhhXH1hNXmGPNq4tqGje8cHtRqBQCAQVHEs1ZZoVBq0ei3peemmPKyyYvRaWWosRb6VQCAoFZUaFjhr1izGjh1Lu3bt8PPzY8WKFURFRTF58mRA9ihdv36dn376CZCVAb/77jtmzZrFpEmTCAgIYOXKlWzYsME05oIFC2jXrh3169cnLy+PnTt38tNPP+VTJBSUA5mJELxFNqhiTt7ZrrGCJoOg5Ujw7okWJVvOXGfxv1eIuZUNgLudBa881oBn2tXBTF3408aErAR+v/w7AJNbTRZeK4FAIBCYMIYGJmYnkpqbWm7GVZY2CwBrG/IDSgABAABJREFUtQgJFAgEpaNSjauRI0eSlJTE/PnziY2NpXnz5uzcuRNPT08AYmNjiYqKMrX38vJi586dzJw5kyVLllCzZk0WL15sqnEFkJmZydSpU4mJicHS0pImTZqwbt06Ro4c+cDX99ChzYbQnRD0G4T9AwZZKh2FErx7yQZVk4FgboNOb+CvszdY/O8VriXJFysXW3Om9azPsx3qYqEp+ong6uDV5OpzaeXSCj8Pv4pemUAgEAiqGfbmsnGVoc1AZ9ChVpbtlkaSJJFvJRAIykyl1rmqqogaK3dh0EPkIdmgurgV8tLv7PNoLRtUzUeArZwnF5WUxeYzMfwRGEN0suypcrYxY3KP+ozp5HlfowogMTuR/pv7k6PPYfkTy+lSq0tFrEwgEFRRxDm4cESdq4I8OepJtmzYwviJ41n9w+p8+6ZOncqyZcsYN24ca9asAWTV4U8++YQdO3Zw/fp1XF1dad26NTNmzKBbz25cuXWFPm37cCP6Bhs2bODZZ5/NN2azZs24ePEiq1evZvz48abtgYGBfPrppxw8eJDU1FTq1q1Ljx49ePPNN2nUqFFFfwwCgaAcKK86V5WuFiioosSdl0P+zm+6o/YHcm2qls/IL5fGAKTlaNl5Ioo/zlznRGSyqWkNKw0v96jP836eWJkV/09tzYU15OhzaOncks41O5fbkgQCgUDwcGGmNMO9ljubf9vM0sVLsbS0BOSbpA0bNlC3bl1T28jISLp06YKDgwP/+9//aNmyJVqtlt27dzNt2jQCzgYAoEBBnTp1WL16dT7j6tixY8TFxWFtnd+rtX37dkaMGEHfvn1Zv3499evXJz4+nt9//53333+fjRs3PoBPQiAQVBWEcSW4Q2rMbWGK3yD+4p3tFg7QbLjsparTEZRK9AaJQ6HxbD5znT3BceTq5EKOCgV0beDMiLa16dvMHUuzkiUEJ2YnsjFUvhCJXCuBQCCoJCQJbucfPXA0VvLFpBiYqcxo2rIp0dei+W3Tb4wbOw6AP/74gzp16uDt7W1qO3XqVBQKBSdOnMhnIDVr1owXX3yRDG0GIOdzjR41mm+++Ybo6GiTevCqVasYPXq0KQ8cICsrixdeeIEBAwawZcsW03YvLy86duxISkpKqT8GgUBQPRHG1aNORgJc/ls2qCIPA7ejRFVm0KifbFA17A1qWU0xNC6dP87EsCXwuklKHaCBqw0j2tZmeJtauNuXPqxkbfBacvQ5NHdqTtdaXcuyMoFAIBCUFm0WfFqzco49+waYFS/nSalQolKoGP7ccFatXmUyrlatWsWLL76Iv78/AMnJyezatYtPPvmkgOcJwN7enpu3bprGdHNzo2/fvqxdu5b33nuPrKwsNm7cyIEDB/IZV7t37yYxMZG33nqr0Pk5ODiUYOECgeBhQBhX1Qi9QY9SoSybNycvC6KOwtX9EO4PNy/k3+/ZVQ75azoULB0ASMrIZeu5CDafieHC9TRT0xpWGoa0qskI39q0qGVfZi9TUnaSyWsl6loJBAKBoDiolWoGPz2YhR8vJDIyEoVCwZEjR/j1119NxlVYWBiSJNGkSZNCx8jT56Ez6FAoFCiQrz0vvvgir7/+OnPmzGHTpk3Ur1+f1q1b5+t35coVgHuOKxAIHj2EcVVNOHL9CLMPz8ZCZcGg+oMY7D2Yevb17t/RoIfYs3eMqejjoM/L38a9BTR7Elo8DQ5y+EOuTs+/52PZfOY6/qHx6AyyR0ujUtCrsSsjfGvTq7HrPaXUS8Pai2vJ1mXTzKkZ3Wp1K7dxBQKBQFBCNFayB6myjl2S5koNjk6OdH+iOytXr0SlUDFw4ECcnZ1NbYzaXfd6aJepu13fSm1p2jZw4EBefvllDh48aPKE/RehCSYQCP6LMK6qOJIk8eP5H/k28Fuk2yF7K4JWsCJoBS1dWjLEewj9vPrlr/GRHC4bUlf3Q8RByEnJP6hdbajfU5ZP9+4J1s6mY52LTmHz6Ri2Bd0gJUtr6tKytj0j2tZmcKuaOFqblfs6b+Xc4tdLvwIwpZXwWgkEAkGlolAUOzSvslEoFFibWTN81HA+m/0ZKoWKJUuW5GvTsGFDFAoFISEhDBs2rMAYpvpWd0mwq9Vqxo4dy9y5czl+/Hi+nCojRiXAS5cu4ecnyoYIBAJhXFVpMvIyeO/Ie+yL2gfAiIYj6OjRkW1Xt3H0xlGCEoIISgji85Of09O+IYPzVHSNOY8mJSr/QOZ24NVdNqS8e4FT/XzJwjdSstkSeJ0/zsRwNSHTtN3dzoJhbWoxom0tGrrZVuha1wbLXqumTk3pXrt7hR5LIBAIBA8X9ub2dH28K7l5uagVavr27Ztvv6OjI3379mXJkiVMnz49X96VJEnEJsZiZWtVoL7Viy++yJdffsnIkSOpUaNGgeP26dMHZ2dn/ve//xVqfKWkpIi8K4HgEUMYV1WU8NRwZuyfQURqBBqlhtkdZ/NUo6cA6F+7F4lX97Aj5Fe2pVwkFC17b11kL1DDTs8AlSODberT1Ks3ivqPQc02oLrzVadk5XEiIplj4ckcC08iJC4NY2SDhUZJv2bujPCtTef6zqiUFe9BSslJYcOlDQBMbikUAgUCgUBQMmw1tqjVarYe2Uo9u3qoVAWVapcuXUrnzp3p0KED8+fPp2XLluh0Ov7e9TffLfuO7QHb84UFAvj4+JCYmIiVVeGhitbW1vz44488/fTTDBkyhOnTp9OgQQMSExP57bffiIqK4tdff62QNQsEgqqJMK6qIPui9jHn8BwytZm4WrnyTZdPaZmbB4e+lsP8ogJw1uUwDhgHhJpp2OZSh+0WKpLIZb2dDeu5Sf2UAAanONPN0oPwODXHwpM4HpHMpbuMKSMdvRwZ4VubAS08sDF/sH8WP138iSxdFj6OPvSs0/OBHlsgEAgE1R+VUoWdmR2SrYRkUXgelJeXF2fOnOGTTz7h9ddfJzY2FhcXF1q0bsH7X7yPldoKpaJgHrGTk1ORxx46dChHjx5lwYIFjBo1irS0NOrUqcNjjz3Gxx9/XC7rEwgE1QeFJLIxC1CSKszlid6gZ0ngt/xwYSUA7VT2fJGmwzkhFCRD/sY27nKYX/3beVO27ugMOgJuBLDp8l8cjNmPTpKFKyRJgT6zAdrUtujSm4FkRgNXGzp6OdLJ24mO3o642pZePr0spOam0ndzXzK1mSzstZDH6z5eKfMQCARVh8o6B1d1KupzycnJISIiAi8vLywsKudaUB6k56UTlRaFWqmmUY1GxY6CiE6PJi03DVcrV1ysXCp4lgKBoKpS1LmwJOdf4bmqbFKvw/VTpEYd5e24fzmiyAFgTGoas5Kj0Bjb2dWCWr5Q1082qFyamPKmEjNyOXE+VvZMhUuE3uwFSj80dkGo7c+gtopEbXMFtc0VzJSW9Kr9BM80GUY792aFPqV7kPx08ScytZk0rtGYx+o8VqlzEQgEAkH1xVpjjUqhQmfQkanNxMbM5r59JEkiU5tp6i8QCARlRRhXD5LcdLgRCDGn4Ppp+ZUeS6iZhtdcXbiuUWNhMPBhShYDa7SApu2gVjvZqLLzMA2TkJ7LifNxHAtP4lh4ElfiMwocqrGLCx29n6aT92Rqu2Rx5OYetl3dRnR6NLujtrE7ahse1h4M8h7EkPpDiifrXs6k5qbyS8gvAExuJXKtBAKBQFB6lAolduZ23Mq5RWpearGMq1x9rqmGpIW6+nrtBAJB1UEYVxWFXgcJIbcNqVNw/QzEhwD5ozB32FjzobMTOQqopbFnUYc5NPbug6RQcitLS3RyFlERWUQlh3EtKZMzUSmEFWJMNXG3pZO3E528HWlfzxEnG/N8+1u6T2Fyy8mcTTjL1qtb2R2xm9jMWH44/wM/nP+Bya0mM7XV1Adq4KwLWUeGNoOGNRryWF3htRIIBAJB2bA3t+dWzi3SctPwsPa4b3SG0Wtlqbas9EgOgUDwcCCMq4pg41gI+wdu183Ih11tqO2LtmZbvsgOZ8ON/QB4WbWltcU0vg5QErXjKNHJWWTk6u55CB8PO1POVAcvx2LVnlIoFLRxbUMb1za83f5t/GP8+Svsr/+zd9/hUZXZA8e/M+m9d1LoLRQpQugQQBARVBS7ruiuoq7Iqmv7rYquKJbFsqCLvVBEqkoPHULvIYSahDTSSO8z9/fHdQZCCilTApzP8+SR3Llz7zsjzJ1z3/Oew/bU7Xxx+AsyijP4V9S/sNPaXfVYzVVQUcDPx38G1AqBclETQgjRXM62zthqbanSV1FUUYS7Q/1rIyQlUAhhahJcmUNVOVSWoNi7URnYkxzPbiQ5duaYpj0nipw5m5vBmby56B3OAFCePZwjWaM4QlaNQwW4OxDm7UyotzOhXs50CXbn5ghvvJrZyNfR1pExEWMYEzGGxScX886ud1h+ejlZJVl8NOwjs19ofjr+E4WVhbTzbMfI8JFmPZcQQogbg0ajwcPBg5zSHPIr8usNrhRFoaSqZvNgIYRoDgmuzOAzzb0ccb2dnfneFJ+8PA0wF63jIZxa/YTWrgBF54A+817aON5MaBdnwryd/wyknAjzdqaVlzOOdjV7dZja3R3uxt/Jnxe3vsiOtB38Zc1f+G/0f81WNamgooCfjv8EwN96/E1mrYQQQpiMIbgqrChEp9dho639OlqmK5P1VkIIk5Pgygx2l4SwPTsbUNBoINjDiVBvJ3DbTXzF9+ipIsg5jPcGfsxNQQ0vF2tOQ0OH8s0t3/B0zNPE58bz4KoHmTtyLm0825j8XD/H/0xhZSFtPdoyOny0yY8vhBDixuVo44i9jT0VugoKKwrxdPSsdT9DSqCzXe39rYQQoink08QMnhnRju8fu5lNLwzjxNtj2PTiIDpFriWu4mv0VDEybCTLJv5Cr+COLSKwMoj0jeSnsT8R7h5OWnEaD61+iAMXDpj0HIUVhfx4/EdAZq2EEEKYniE1ECC/Ir/O/UoqJSVQCGF68s3WDPq38WFoBz9a+7pwsTyLR9c8ypJTS9Cg4blez/HxsI9b7Id5qHsoP4z9ge5+3SmoKOCJdU+wPmm9yY4/P34+hRWFtPFoI7NWQgghzMIQXBVVFFGpr6zxeLX+VrYt83oshLg2SXBlRnsz9jL598kczT6Ku707c0fO5fFuj7eo2araeDt689XorxgeOpwKfQX/2PwP4xqp5iiqKOKH4z8A8Lfuf6szD14IIYRoiEcffRSNRoNGo8HOzo6AgABGjRrFz9//jINWbUlSUF5Q43llujL0it643uq7777D09PTwqMXQlyPJLgyA0VR+PH4jzyx7glyy3Lp6NWRRbctYmDIQGsPrcGcbJ34z7D/MLnjZBQU3t/7Ph/s/QC9om/yMRecWEBBRQGtPVpzS8QtJhytEEKIG9WYMWNIT08nMTGR1atXM3z4cJ577jmeuu8pqqqqak0NvLwEe0u/4SmEuLZIcGViFboKXt72MrP2zkKn6BjXZhw/3vojrdxaWXtojWajteG1fq8xrdc0AH44/gMvbX2Jcl15o49VXFnM98e/B+Cv3f8qs1ZCCCFMwsHBgcDAQEJCQujVqxevvvoqK1asYMO6DSxfsJzSylJmfTiLbt264eLiQmhoKM8/+zwlRSU42zmzefNm/vKXv5Cfn2+cBXvzzTcB+Omnn+jTpw9ubm4EBgZy//33k5mZad0XLIRo0aweXM2ZM4fWrVvj6OhI79692bZtW737b9myhd69e+Po6EibNm344osvqj0+b948Bg8ejJeXF15eXowcOZI9e/aY8yVUY6u1pbSqFBuNDS/f/DIzB83EydbJYuc3NY1Gw5RuU3h30LvYam1Zm7iWv63/G/nldS8Srs2CEwvIL88nwj2CsRFjzTRaIYQQpqAoCiWVJVb5URTl6gO8ihEjRtCjRw82r94MQIW+gk8//ZRjx47x3XffsWPLDj6aofZ0HDBgALNnz8bd3Z309HTS09N54YUX1OdVVPD2229z+PBhli9fzrlz53j00UebPT4hxPXLqqXYFy1axLRp05gzZw4DBw7kyy+/ZOzYsRw/fpywsLAa+587d45bb72VJ554gp9++okdO3YwdepU/Pz8uOuuuwDYvHkz9913HwMGDMDR0ZFZs2YxevRo4uLiCAkJMftr0mq0/HvQvzmdd5qb/G8y+/ksZXzb8fg5+/H8pufZf2E/j6x+hLkj5xLkGnTV55ZUlvB9nMxaCSHEtaK0qpR+8/tZ5dy779+Ns51zs4/TqVMnDh4+CMC9T9xLW8+2aDQaAloF8MzLz/D2S2/j+LUjGlsNHh4eaDQaAgMDqx3jscceM/65TZs2fPrpp9x8880UFRXh6ura7DEKIa4/Vp25+vjjj5kyZQqPP/44nTt3Zvbs2YSGhjJ37txa9//iiy8ICwtj9uzZdO7cmccff5zHHnuMDz/80LjPzz//zNSpU+nZsyedOnVi3rx56PV6YmJiLPWycLN3u64CK4P+Qf35bsx3+Dv7cyb/DA+seoATuSeu+ryFCQvJK88jzC2Msa1l1koIIYT5KYqCrdYWjUbDti3bGDlqJCEhIfh7+/PqM6+Sl5tHSUlJvcc4ePAgEyZMIDw8HDc3N4YNGwZAcnKyBV6BEOJaZLWZq4qKCvbv38/LL79cbfvo0aPZuXNnrc+JjY1l9Ojq5btvueUWvv76ayorK7Gzs6vxnJKSEiorK/H29jbd4G9gHb078vOtP/PUhqc4nXeaR9c8ysfDPmZA8IBa979y1spWK32rhRCipXOydWL3/butdm5TiI+Pp3Xr1uSn5/PUfU/xyJRH+Pc7/6bUvpTt27bzr2n/orKyZpl2g+LiYkaPHs3o0aP56aef8PPzIzk5mVtuuYWKigqTjFEIcf2x2jfd7OxsdDodAQEB1bYHBASQkZFR63MyMjJq3b+qqors7GyCgmqmqL388suEhIQwcuTIOsdSXl5OefmlIg0FBTXLtopLAl0C+X7s90zbNI29GXt5esPTzBg4g/Ftx9fY95eEX8gtyyXULZRxbcZZYbRCCCEaS6PRmCQ1z1o2btzI0aNHef755zl97DS6Kh3Pv/k8HXw6kJCbQNbirGr729vbo9Ppqm07ceIE2dnZvPfee4SGhgKwb98+i70GIcS1yeoFLa4sgaooSr1lUWvbv7btALNmzWLBggUsXboUR0fHOo85c+ZMPDw8jD+GD1FRN3d7d74Y+QVjI8ZSpVTx6vZXmXdkXrWFyCWVJXwb9y0AT3R7QmathBBCmFx5eTkZGRmkpqZy4MAB3n33XSZMmMBtt93Gww8/TNeOXamqquK7L7/jQPwBli9azi/f/1LtGBERERQVFRETE0N2djYlJSWEhYVhb2/PZ599xtmzZ1m5ciVvv/22lV6lEOJaYbXgytfXFxsbmxqzVJmZmTVmpwwCAwNr3d/W1hYfH59q2z/88EPeffdd1q1bR/fu3esdyyuvvEJ+fr7x5/z58014RTceext73hvyHn+J/AsAnx78lLd3vU2VvgqAxScXk1uWS4hrCLe1vc2aQxVCCHGdWrNmDUFBQURERDBmzBg2bdrEp59+yooVK7CxsaHXTb144903+OazbxjcZzB//PoHL79ZfUnCgAEDePLJJ5k8eTJ+fn7MmjULPz8/vvvuOxYvXkyXLl147733qq3xFkKI2mgUU9Q8baJ+/frRu3dv5syZY9zWpUsXJkyYwMyZM2vs/89//pPffvuN48ePG7c99dRTHDp0iNjYWOO2Dz74gHfeeYe1a9fSv3//Ro+roKAADw8P8vPzcXd3b/Tzb0Tz4+fz3p73UFAY1moYMwbOYOKKieSW5fLWgLe4s/2d1h6iEOIaIZ/BtTPX+1JWVsa5c+eMbVGuR0UVRSQVJBl/D3QJxMfJp55nCCFuNPV9Fjbm89eqaYHTp0/nq6++4ptvviE+Pp7nn3+e5ORknnzySUCdUXr44YeN+z/55JMkJSUxffp04uPj+eabb/j666+N/ShATQV8/fXX+eabb4iIiCAjI4OMjAyKioos/vpuJPd3vp//DPsPDjYObE7ZzO3LbzfOWtW2FksIIYSwFBc7l2qp6S52LlYcjRDiembV4Gry5MnMnj2bGTNm0LNnT7Zu3cqqVasIDw8HID09vVq509atW7Nq1So2b95Mz549efvtt/n000+NPa5AbUpcUVHBpEmTCAoKMv7IVL75RYdH89Xor/Bw8CCvPA+Ax7s9jp22ZhVHIYQQwlI0Gg3uDurdZhutDQ42DlYekRDiemXVtMCWSlJSmudc/jn+ufWfONs5M2/UPOxsJLgSQjScfAbXTtICm6e8qpzEgkS8HL3wd/a39nCEEC2MqdICpXybMLnWHq35ZfwvV638KIQQQliKg60DHb07WnsYQojrnNVLsYvrlwRWQgghhBDiRiLBlRBCCCGQVQJCiBuZqT4DJbgSQgghbmB2duq62JKSEiuPRAghrKeiogIAGxubZh1H1lwJIYQQNzAbGxs8PT3JzMwEwNnZWdK6hRA3FL1eT1ZWFs7OztjaNi88kuBKCCGEuMKcOXP44IMPSE9Pp2vXrsyePZvBgwfXuf+WLVuYPn06cXFxBAcH89JLLxl7Nl5p4cKF3HfffUyYMIHly5eb6RU0TmBgIIAxwBJCiBuNVqslLCys2TeXJLgSQgghLrNo0SKmTZvGnDlzGDhwIF9++SVjx47l+PHjhIWF1dj/3Llz3HrrrTzxxBP89NNP7Nixg6lTp+Ln51etDyNAUlISL7zwQr2BmjVoNBqCgoLw9/ensrLS2sMRQgiLs7e3R6tt/oop6XNVC+mxIoQQ1mPtz+B+/frRq1cv5s6da9zWuXNnJk6cyMyZM2vs/89//pOVK1cSHx9v3Pbkk09y+PBhYmNjjdt0Oh1Dhw7lL3/5C9u2bSMvL69RM1fWfl+EEOJG1ZjPXyloIYQQQvypoqKC/fv3M3r06GrbR48ezc6dO2t9TmxsbI39b7nlFvbt21dtFmjGjBn4+fkxZcqUBo2lvLycgoKCaj9CCCFaNgmuhBBCiD9lZ2ej0+kICAiotj0gIICMjIxan5ORkVHr/lVVVWRnZwOwY8cOvv76a+bNm9fgscycORMPDw/jT2hoaCNfjRBCCEuT4EoIIYS4wpULmhVFqXeRc237G7YXFhby4IMPMm/ePHx9fRs8hldeeYX8/Hzjz/nz5xvxCoQQQliDFLSoheGiKCkYQghheYbPXmssCfb19cXGxqbGLFVmZmaN2SmDwMDAWve3tbXFx8eHuLg4EhMTGT9+vPFxvV4PgK2tLQkJCbRt27bGcR0cHHBwcDD+LtcmIYSwjsZclyS4qkVhYSGApGAIIYQVFRYW4uHhYdFz2tvb07t3b9avX88dd9xh3L5+/XomTJhQ63OioqL47bffqm1bt24dffr0wc7Ojk6dOnH06NFqj7/++usUFhbyySefNPhaI9cmIYSwroZclyS4qkVwcDDnz5/Hzc3tmm2kWFBQQGhoKOfPn5eqUrWQ96d+8v7UT96f+jX3/VEUhcLCQoKDg80wuqubPn06Dz30EH369CEqKor//e9/JCcnG/tWvfLKK6SmpvLDDz8AamXAzz//nOnTp/PEE08QGxvL119/zYIFCwBwdHQkMjKy2jk8PT0Bamyvj1ybrn/y/tRN3pv6yftTP0telyS4qoVWq6VVq1bWHoZJuLu7yz+yesj7Uz95f+on70/9mvP+WHrG6nKTJ08mJyeHGTNmkJ6eTmRkJKtWrSI8PByA9PR0kpOTjfu3bt2aVatW8fzzz/Pf//6X4OBgPv300xo9rppLrk03Dnl/6ibvTf3k/amfJa5LElwJIYQQV5g6dSpTp06t9bHvvvuuxrahQ4dy4MCBBh+/tmMIIYS49km1QCGEEEIIIYQwAQmurlMODg688cYb1SpNiUvk/amfvD/1k/enfvL+iLrI3436yftTN3lv6ifvT/0s+f5oFGvUuhVCCCGEEEKI64zMXAkhhBBCCCGECUhwJYQQQgghhBAmIMGVEEIIIYQQQpiABFdCCCGEEEIIYQISXF1Dtm7dyvjx4wkODkaj0bB8+fJqjyuKwptvvklwcDBOTk4MGzaMuLi4avuUl5fz7LPP4uvri4uLC7fffjspKSkWfBXmM3PmTPr27Yubmxv+/v5MnDiRhISEavvcyO/R3Llz6d69u7GBXlRUFKtXrzY+fiO/N1eaOXMmGo2GadOmGbfdyO/Pm2++iUajqfYTGBhofPxGfm+EXJvqI9el+sl1qXHk2lRdi702KeKasWrVKuW1115TlixZogDKsmXLqj3+3nvvKW5ubsqSJUuUo0ePKpMnT1aCgoKUgoIC4z5PPvmkEhISoqxfv145cOCAMnz4cKVHjx5KVVWVhV+N6d1yyy3Kt99+qxw7dkw5dOiQMm7cOCUsLEwpKioy7nMjv0crV65U/vjjDyUhIUFJSEhQXn31VcXOzk45duyYoig39ntzuT179igRERFK9+7dleeee864/UZ+f9544w2la9euSnp6uvEnMzPT+PiN/N4IuTbVR65L9ZPrUsPJtammlnptkuDqGnXlBUyv1yuBgYHKe++9Z9xWVlameHh4KF988YWiKIqSl5en2NnZKQsXLjTuk5qaqmi1WmXNmjUWG7ulZGZmKoCyZcsWRVHkPaqNl5eX8tVXX8l786fCwkKlffv2yvr165WhQ4caL2A3+vvzxhtvKD169Kj1sRv9vRHVybWpfnJdujq5LtUk16batdRrk6QFXifOnTtHRkYGo0ePNm5zcHBg6NCh7Ny5E4D9+/dTWVlZbZ/g4GAiIyON+1xP8vPzAfD29gbkPbqcTqdj4cKFFBcXExUVJe/Nn55++mnGjRvHyJEjq22X9wdOnTpFcHAwrVu35t577+Xs2bOAvDeifvL3ozq5LtVNrkt1k2tT3Vritcm2yc8ULUpGRgYAAQEB1bYHBASQlJRk3Mfe3h4vL68a+xief71QFIXp06czaNAgIiMjAXmPAI4ePUpUVBRlZWW4urqybNkyunTpYvwQuZHfm4ULF3LgwAH27t1b47Eb/e9Ov379+OGHH+jQoQMXLlzgnXfeYcCAAcTFxd3w742on/z9uESuS7WT61L95NpUt5Z6bZLg6jqj0Wiq/a4oSo1tV2rIPteaZ555hiNHjrB9+/Yaj93I71HHjh05dOgQeXl5LFmyhEceeYQtW7YYH79R35vz58/z3HPPsW7dOhwdHevc70Z9f8aOHWv8c7du3YiKiqJt27Z8//339O/fH7hx3xvRMPL3Q65LdZHrUt3k2lS/lnptkrTA64ShOsqVkXZmZqYxag8MDKSiooKLFy/Wuc/14Nlnn2XlypVs2rSJVq1aGbfLewT29va0a9eOPn36MHPmTHr06MEnn3xyw783+/fvJzMzk969e2Nra4utrS1btmzh008/xdbW1vj6btT350ouLi5069aNU6dO3fB/d0T95O+HSq5LdZPrUt3k2tQ4LeXaJMHVdaJ169YEBgayfv1647aKigq2bNnCgAEDAOjduzd2dnbV9klPT+fYsWPGfa5liqLwzDPPsHTpUjZu3Ejr1q2rPS7vUU2KolBeXn7DvzfR0dEcPXqUQ4cOGX/69OnDAw88wKFDh2jTps0N/f5cqby8nPj4eIKCgm74vzuifjf63w+5LjWeXJcukWtT47SYa1OTS2EIiyssLFQOHjyoHDx4UAGUjz/+WDl48KCSlJSkKIpactLDw0NZunSpcvToUeW+++6rteRkq1atlA0bNigHDhxQRowYcV2U41QURXnqqacUDw8PZfPmzdXKcpaUlBj3uZHfo1deeUXZunWrcu7cOeXIkSPKq6++qmi1WmXdunWKotzY701tLq/IpCg39vvzj3/8Q9m8ebNy9uxZZdeuXcptt92muLm5KYmJiYqi3NjvjZBrU33kulQ/uS41nlybLmmp1yYJrq4hmzZtUoAaP4888oiiKGrZyTfeeEMJDAxUHBwclCFDhihHjx6tdozS0lLlmWeeUby9vRUnJyfltttuU5KTk63wakyvtvcGUL799lvjPjfye/TYY48p4eHhir29veLn56dER0cbL2CKcmO/N7W58gJ2I78/ht4gdnZ2SnBwsHLnnXcqcXFxxsdv5PdGyLWpPnJdqp9clxpPrk2XtNRrk0ZRFKXp815CCCGEEEIIIUDWXAkhhBBCCCGESUhwJYQQQgghhBAmIMGVEEIIIYQQQpiABFdCCCGEEEIIYQISXAkhhBBCCCGECUhwJYQQQgghhBAmIMGVEEIIIYQQQpiABFdCXIeGDRvGtGnTrD0MIYQQApDrkrhxSHAlhBBCCCGEECYgwZUQQgghhBBCmIAEV0IIIYQQQghhAhJcCSGEEEIIIYQJSHAlhBBCCCGEECYgwZUQQgghhBBCmIAEV0I00saNG3nsscfo1KkTLi4uhISEMGHCBPbv319j3+3bt/P444/Tu3dvHBwc0Gg0JCYm1nrc9PR0Hn30Ufz9/XF0dKR79+58/fXXZn41qtmzZ3PnnXfSunVrNBoNw4YNa9DzXn/9dTQaDZGRkTUeq6io4F//+hetW7fG3t6e8PBwXnnlFUpLS008eiGEENfbtenkyZO88MIL9O7dG09PT7y9vRk4cCC//vprjX1TUlKYNm0aQ4cOxdPTE41Gw3fffVfrceXaJMxNgishGmnu3LkkJiby3HPPsWrVKj755BMyMzPp378/GzdurLZvTEwMGzZsICwsjAEDBtR5zPz8fAYNGkRMTAyzZs1ixYoV9OrVi8cff5yPP/7Y3C+JL774gqSkJEaMGIGfn1+DnnPo0CE+/PBDAgICan38vvvu44MPPuCvf/0rq1atMr6WyZMnm3LoQgghuP6uTevWreOPP/7grrvuYvHixfz888+0b9+eu+++mxkzZlTb9/Tp0/z888/Y29tz66231ntcuTYJs1OEEI1y4cKFGtsKCwuVgIAAJTo6utp2nU5n/PMHH3ygAMq5c+dqPH/mzJkKoOzbt6/a9tGjRysuLi7KxYsXGzXGoUOHKs8991yD9798nF27dlWGDh1a7/6VlZVKz549lb///e/K0KFDla5du1Z7PDY2VgGUjz76qNr2d999VwGUdevWNXhsQgghrq6lX5sae13KyspS9Hp9je3jxo1TnJ2dlbKyMuO2y1/P3r17FUD59ttvazxXrk3CEmTmSohG8vf3r7HN1dWVLl26cP78+WrbtdqG/RPbsWMHAQEB9O7du9r22267jeLiYtasWVPncxVF4dZbb8XHx4fk5GTj9srKSrp27Urnzp0pLi6u9/wNHafBe++9R25uLv/+979rfXzHjh0ANe4g3nbbbQAsWbKkUecTQghRv2vl2lRSUtKga5Ovry8ajabG9ptvvpmSkhJyc3Ob9HpArk3CvCS4EsIE8vPzOXDgAF27dm3S8ysqKnBwcKix3bDtyJEjdT5Xo9Hw448/4uzszD333ENlZSWbN2+muLiYc+fO8csvv+Di4tKkcdXm+PHjvPPOO8ydOxdXV9da96moqKg2foOGvB4hhBCm0ZKuTevXr2f27NlMnTq1WdemTZs24efnV2sweTVybRKWIMGVECbw9NNPU1xczGuvvdak53fp0oWUlJRqd/dAXXQMkJOTU+/zfXx8WLhwIfv37+ell17i22+/5fvvv+ezzz6jW7duTRpTbfR6PY899hh33nlnvXntXbp0AS7dJTRo6OsRQgjRfNfbtemrr75i8+bNvP7669jY2DT6+XJtEhZh7bxEIa51r7/+ugIon332Wb371ZfXfvz4ccXBwUEZNGiQcuzYMSU7O1v5/PPPFXt7ewVQnnzyyQaN5f3331cAxcHBQXnwwQeb8nLqXXP1wQcfKN7e3tVy+2tbc1VeXq60a9dOCQ4OVtatW6dcvHhRWb16tRIQEKDY2NgonTp1atLYhBBCNMz1dm1atWqVYm9vr0yaNKnWtVgG9a25kmuTsASZuRKiGd566y3eeecd/v3vf/PMM880+TidO3dm2bJlJCUlERkZia+vL++//z4fffQRACEhIQ06zgMPPIC9vT3l5eW8+OKLTR5PbZKTk/nXv/7FG2+8gb29PXl5eeTl5VFVVYVerycvL89Yytbe3p7Vq1cTFhbG6NGj8fLyYtKkSbz66qt4eXk1+PUIIYRovOvt2rR27VruvPNORo0axc8//1zrWqyGkGuTsAQJroRoorfeeos333yTN998k1dffbXZxxs7dixJSUmcPHmS48ePc+7cOXx8fAAYMmTIVZ+v0+l44IEH8PLyIiwsjClTphjzy03h7NmzlJaW8txzz+Hl5WX82bFjB/Hx8Xh5efHKK68Y92/Xrh2xsbGkpKRw5MgRMjMzufvuu8nOzm7Q6xFCCNF419u1ae3atUycOJGhQ4eyZMkS7O3tm/xaQK5NwvxsrT0AIa5Fb7/9Nm+++Savv/46b7zxhsmOq9FoaN++PaAuvP3kk0/o2bNngz7w33jjDbZt28a6detwcXFhyJAhvPjii3zyyScmGVvPnj3ZtGlTje3Tpk0jPz+fb7/9llatWtV4PCQkxHg38PXXX8fFxYUpU6aYZExCCCEuud6uTevWrWPixIkMGjSI5cuX11pco6nk2iTMRYIrIRrpo48+4l//+hdjxoxh3Lhx7Nq1q9rj/fv3N/45KyuLLVu2AHD06FEAVq9ejZ+fH35+fgwdOtS477PPPsuwYcPw8fHh7NmzfPrpp6SkpBifX5/169czc+ZM/u///o/o6GgAZs6cyQsvvMCwYcO444476n3+vn37SExMBKCgoABFUfj1118B6Nu3L+Hh4Xh6ejJs2LAaz/X09KSqqqrGY7NmzSIwMJCwsDAuXLjAL7/8wvLly/nxxx8l9UIIIUzsers2bd++nYkTJxIYGMirr77KoUOHqj3epUsX3N3djb8brllnz54F1OuaoaLtpEmTjPvJtUmYnbUXfQlxrRk6dKgC1PlzuU2bNtW535VFIyZMmKAEBQUpdnZ2SmBgoPLoo48qiYmJVx1PWlqa4u/vr4wYMaJaI0W9Xq+MHz9e8fT0rHWh8uUeeeSROsdZ26LgK9+PKwtaKIqivPXWW0rbtm0VBwcHxdPTUxkzZoyydevWq74eIYQQjXe9XZveeOONel/Ppk2bqu3f0Ncu1yZhbhpFURRzBG1CCCGEEEIIcSORghZCCCGEEEIIYQISXAkhhBBCCCGECUhwJYQQQgghhBAmIMGVEEIIIYQQQpiABFdCCCGEEEIIYQISXAkhhBBCCCGECUgT4Vro9XrS0tJwc3NDo9FYezhCCHFDURSFwsJCgoOD0WrlHqCBXJuEEMI6GnNdkuCqFmlpaYSGhlp7GEIIcUM7f/48rVq1svYwWgy5NgkhhHU15LokwVUt3NzcAPUNdHd3t/JohBDixlJQUEBoaKjxs1io5NokhBDW0ZjrkgRXtTCkW7i7u8sFTAghrERS36qTa5MQQlhXQ65LkswuhBBCCCGEECYgwZUQQgghhBBCmIAEV0IIIYQQQghhAhJcCSGEEEIIIYQJSHAlhBBCCCGEECYgwZUQQgghhBBCmIAEV0IIIYQQQghhAhJcCSGEEEIIIYQJSHAlhBDCZLambOWNnW+w5twaaw9FCCGEAEWB+N/gu9ugosTsp5PgSgghhMkcyjzE0lNL2Xdhn7WHIoQQ4kaXdhC+GweLHoTEbbDnf2Y/pa3ZzyCEEOKGcaHkAgCBLoFWHokQQogbVn4qbHwbDi9Qf7d1hAHPQt8pZj+1BFdCCCFMJqM4A5DgSgghhBWUF8HOT2HHp1BVqm7rPhmi/wUerSwyBAmuhBBCmIwhuApwDrDySIQQQtww9Dp1lirmbShSr0OERcEt/4aQ3hYdigRXQgghTEJRFEkLFEIIYVnntsLaVyHjqPq7VwSMmgGdbweNxuLDkeBKCCGESeSV51GuKwdk5kqIG0lMcgy2GluGhg619lDEjST7NKz/P0hYpf7u4AFDX4Sb/wq2DlYblgRXQgghTMKQEujj6IO9jb2VRyOEsISc0hz+sfkf6BU9C29bSBefLtYekrjeleTCllmwdx7oq0BjA30eg2Evg4uvtUcnpdiFEEKYhnG9lcu1P2s1Z84cWrdujaOjI71792bbtm117rt06VJGjRqFn58f7u7uREVFsXbt2jr3X7hwIRqNhokTJ5ph5EJY1vGc4+gUHQoK7+95H0VRrD0kcb2qqoDYOfDpTbB7rhpYtb8FpsbCuA9bRGAFElwJIYQwkYySPysFap3Upo3XqEWLFjFt2jRee+01Dh48yODBgxk7dizJycm17r9161ZGjRrFqlWr2L9/P8OHD2f8+PEcPHiwxr5JSUm88MILDB482NwvQwiLOJF7wvjnA5kHWJtU940FIZpEUSD+d5jTD9a+AmV54N8VHloGD/wCfh2tPcJqJLgSQghhEhl/VmgKPL1ZLYV7jfr444+ZMmUKjz/+OJ07d2b27NmEhoYyd+7cWvefPXs2L730En379qV9+/a8++67tG/fnt9++63afjqdjgceeIC33nqLNm3aWOKlCGF28bnxAAS7BAPw8b6PKasqs+aQxPUk7RB8dxssegByz4KLP4z/FJ7cBm1HNPgwC04s4PODn3P64mnzjfVPElwJIYRovqoKLpz8HYBAXZXawPEanL2qqKhg//79jB49utr20aNHs3PnzgYdQ6/XU1hYiLe3d7XtM2bMwM/PjylTzN/EUghLic9Rg6tX+71KoEsg6cXpfBf3nXUHJa592adg8aPwv6GQtF1tAjz4Bfj7Aej9CGhtGnW43878xpdHviSpIMk8472MFLQQQgjRPCW58MvDZJQlg5MjgZGTYdQsa4+qSbKzs9HpdAQEVF83FhAQQEZGRoOO8dFHH1FcXMw999xj3LZjxw6+/vprDh061OCxlJeXU15ebvy9oKCgwc8VwhIKKwpJKUoBoKd/T6b3ns5LW1/im2PfMLHdRGnJIBovLxm2vA+H5oOiV7d1uxui3wDP0CYfNq0oDYAg1yBTjLJeMnMlhBCi6XLOwFcjIXEbGXZ2AAR0f8DKg2o+zRW9URRFqbGtNgsWLODNN99k0aJF+Pv7A1BYWMiDDz7IvHnz8PVt+ILrmTNn4uHhYfwJDW36FwshzMGw3irYJRgPBw/GRIzhJv+bKK0qZfaB2dYdnLi2FGXC6n/CZ73h4E9qYNVhLDy5A+76qlmBVbmunJyyHACCXMwfXMnMlRBCiKY5tw0WPQhleeg9QrlgZwuK7pq+W+3r64uNjU2NWarMzMwas1lXWrRoEVOmTGHx4sWMHDnSuP3MmTMkJiYyfvx44za9Xr0ja2trS0JCAm3btq1xvFdeeYXp06cbfy8oKJAAS7QohpTATt6dAPWmxD9v/if3/X4ff5z9g3s73ktP/55WHKFo8Uovws7PYNdcqCxRt0UMhuh/QejNJjnFhWK1ub2jjSOeDp4mOWZ9ZOZKCCFE4x38CX68Q63aFNKH3Ad/pUrRoUGDn7OftUfXZPb29vTu3Zv169dX275+/XoGDBhQ5/MWLFjAo48+yvz58xk3bly1xzp16sTRo0c5dOiQ8ef2229n+PDhHDp0qM6AycHBAXd392o/QrQkhpmrTj6djNu6+nRlYruJALy/5330htQuIS5XUQzbPoJPeqj/rSyB4F7w0HJ45DeTBVYA6cXpgJoS2JAMhOaSmSshhBANp9dDzFuwY7b6e9c7YOJcLuSfBcDPyQ87rZ31xmcC06dP56GHHqJPnz5ERUXxv//9j+TkZJ588klAnVFKTU3lhx9+ANTA6uGHH+aTTz6hf//+xlkvJycnPDw8cHR0JDIysto5PD09AWpsF+JaYqgU2MW7euPgv/f6O+uS1nEs5xi/n/2d29vebo3hiZaoqhz2fwdbP4DiLHWbX2cY8Tp0GgdmCH6M660skBIIMnMlhBCioSpKYPHDlwKrIS/CXd+AndN11UB48uTJzJ49mxkzZtCzZ0+2bt3KqlWrCA8PByA9Pb1az6svv/ySqqoqnn76aYKCgow/zz33nLVeghBmV1ZVxrn8c8CltEADXydf/tr9rwDM3j+bEkO613WqXFfOD3E/GN8PUQtdlZrx8FlvWP2SGlh5RcAd/4OndkDn28wSWMGlBveWCq5k5koIIcTVFaTDgnsh/RDY2MPtn0GPe40PGxsIX8PrrS43depUpk6dWutj3333XbXfN2/e3OjjX3kMIa41py6eQqfo8Hb0xt/Zv8bjD3Z+kF9P/sr5wvN8dfQr/t7r71YYpWVsSNrAB/s+YGfaTr4Y9YW1h9Oy6PUQvwI2/htyTqnbXANh6Etw00Nga2/2IRjTAmXmSgghRIuQfgS+ilYDKydveHhltcAKLt0ZDHC+9meuhBBXZ0gJ7OzdudZ1LPY29rzQ5wUAvo/7npTCFIuOz5ISCxIBOJJ1RNaYGSgKnFqv9qla/KgaWDl5wai34blD0HeKRQIrgLRiy5VhBwmuhBBC1CdhNXwzBgpSwbcDPBED4VE1djNUY7peZq6EEPUzBFdXpgRebnjocPoF9aNCX8HH+z+21NAszrCmp7CykOSC5KvsbV2lVaU8v+l55sfPN99JknbCt2Ph50mQcQTsXWHoy/DcERj4d7BzMt+5a2HptEAJroQQQtSkKLDzc1hwH1QWQ+uhMGU9eLepdffrLS1QCFG/EzlqpcDOPp3r3Eej0fBS35fQarSsT1rP3oy9lhqeRaUWpRr/fCznmBVHcnXbUraxIXkDnx78lEp9pWkPnnYQfrpLDaySY8HGAaKeUYOq4a+Ao+UrniqKQnrRDZYWOGfOHFq3bo2joyO9e/dm27Ztde6bnp7O/fffT8eOHdFqtUybNq3GPvPmzWPw4MF4eXnh5eXFyJEj2bNnjxlfgRBCXGd0lfD7NFj3GqBA70fhwSXg5FnnUyQtUIgbR6W+kpMXTwJqWmB9Onh14O4OdwNqaXadXmf28Vma4cs7QFx2nBVHcnVHs48CUFxZzNGso80/oKLAua0wfzL8bxic3gBaW+j9F/j7Qbjl3+Di0/zzNFFOWQ4V+go0aCx2fbJqcLVo0SKmTZvGa6+9xsGDBxk8eDBjx46tVoXpcuXl5fj5+fHaa6/Ro0ePWvfZvHkz9913H5s2bSI2NpawsDBGjx5NampqrfsLIYS4TGmemsqx/ztAA6P/DbfNBpu6y6vr9DoySzIBmbkS4kZwLv8cFfoKXOxcaOXW6qr7P93zadzs3Ui4mMDS00stMELLqdJXcaHkgvH3Y9kte+bKEFwBxKbHNv1AVRVweCF8ORi+Hw8n1wAa6HYPPL0Hxs8Gj5Bmj7e5DDf+/Jz8sKvnOmZKVg2uPv74Y6ZMmcLjjz9O586dmT17NqGhocydO7fW/SMiIvjkk094+OGH8fDwqHWfn3/+malTp9KzZ086derEvHnz0Ov1xMTEmPOlCCHEtS/3HHw9Gs5uBjsXuHc+DHjmquVxc8py0Ck6bDQ2+Dn5oSiKZcYrhLAKY/Ng705oNVf/Kunl6MXTPZ8G4LMDn1FQUWDW8VnShZIL6JRLs3Enck9Qpa+y4ojqVqWv4njOcePvsWlNCK5KctWmv7O7wbK/QcZRsHWCvo/DM/vgrnng09aEo26eyxsIW4rVgquKigr279/P6NGjq20fPXo0O3fuNNl5SkpKqKysxNvb22THFEKI605SrFoRMDsB3ILhsTXQ6dYGPdV4Z9DZj5SLZdwxZycnLxSac7RCCCuKz7lUKbCh7ul4D2082nCx/CJfHv7SXEOzOEMxi3D3cFztXCnTlXEm74yVR1W7M3lnKK0qxV6rVuk7ln2MwooGflbnnIE/XoD/dIWYGVCUAa4BMOL/YPpxGPcR+LYz4+ibxtINhMGKwVV2djY6nY6AgOr5jwEBAcbu9qbw8ssvExISwsiRI+vcp7y8nIKCgmo/QghxQ1AU2DMPvr8NSnIgqCc8sRGCujf4EIbgylnrw4T/7uDQ+TxeX3ZMZrCEuE41pFLgley0drzU9yUA5sfPv24a7hqKWbRybUVXn65Ay00NNIzrJv+biHCPQKfo2JNRT10CRYHEHbDgfrX57955UFkCAd1g4hcw7SgMeQGcW+4EhqUrBUILKGhxZW8ERVFq7ZfQFLNmzWLBggUsXboUR0fHOvebOXMmHh4exp/Q0FCTnF8IIVq0ylJY8TSsegH0VdD1DvjLKnBv3EXIcPE6mWpDXkklPVp58Pn9N5nss1wI0XLoFT0JuQlA/ZUCazMwZCBDWg2hSqniw30fmmN4FmeYGQl2Daar75/BVQutGGhYb9XNrxv9g/oDdaQG6irh6K8wbzh8dysk/AEo0P4Wtc/hk9ug531g62DB0TeNNdICbS12piv4+vpiY2NTY5YqMzOzxmxWU3z44Ye8++67bNiwge7d678D+8orrzB9+nTj7wUFBRJgCSGub3nJsOhBSD8MGi2MmqGWzG1kQFSl07PsqFodS1/pwfgewXwwqTuOdjbmGLUQwspSClMoqizCXmtPa4/WjX7+i31eZGfqTrambGV76nYGhQwywygtxzBzFewaTLh7ONByKwYagqtI30g0aFiYsJBd6bsu7VCaBwe+h91fqr0NAWwd1abx/Z8Gvw6WH3QzGYMrC85cWS24sre3p3fv3qxfv5477rjDuH39+vVMmDChWcf+4IMPeOedd1i7di19+vS56v4ODg44OLT86FsIIUzizCb49TEozQVnH5j0LbQZ2ujD5JdW8uyCg8QXn8fOHYa2ac+nE3rKjJUQ1zFDSmB7r/bYaRtffS3CI4L7O9/PD8d/YNbeWfQL6tek47QUxpkrl2AifSIBOHXxFOW6chxsWs53y5LKEk7nnQagm283nGydsNHYkFSQRGrKLkKOLoMDP6p9DQFc/ODmv0Kfx8DF14ojbx5L97gCK6cFTp8+na+++opvvvmG+Ph4nn/+eZKTk3nyyScBdUbp4YcfrvacQ4cOcejQIYqKisjKyuLQoUMcP36p8smsWbN4/fXX+eabb4iIiCAjI4OMjAyKioos+tqEEKKwopDcslxrD+MSRYHts+GnO9XAKvgm+OuWJgVW57KLuWPODraezMLWPh+Ae27qJoGVENc5Q6XAxqYEXu5vPf6Gl4MX5/LPsejEIlMNzSouTwsMdAnE29GbKqXK+D61FMdzjqNX9AQ4B+Dv7I+bnSvd3CIAiF00CXZ/oQZW/l1gwn9h2jEY+tI1HViVVpVysfwiAPmFLry67ChVOr3Zz2u1mSuAyZMnk5OTw4wZM0hPTycyMpJVq1YRHq5Oq6anp9foeXXTTTcZ/7x//37mz59PeHg4iYmJgNqUuKKigkmTJlV73htvvMGbb75p1tcjhBAGekXPg6seJLcsl5UTV+Ll6GXdAZUXwvKpEL9S/f2mB+HWj8Cu7vWoddl5Opunfj5AfmklQR6O2HuUklsuDYSFuBE0pVLgldzt3Xm217PMiJ3BnMNzGNdmnPU/I5vg8h5XIa4haDQaIn0j2ZqylWPZx+jhV3tPVmswFLPo5tNFXU+1ay5Rxac45OVBrKM9kwJGQtTT0GZ4o9PDWyrDemAbHJn8xSEURUOPVh5M7htm1vNaNbgCmDp1KlOnTq31se+++67GtqtVnzIEWUIIYU3xufGczT8LwKbzm7iz/Z3WG0z2KVj4gFpmXWsHt86C3n9p0gX0x11JvLkyDp1eoWeoJ3Mf7MGYFTmANBAW4nqnKEqTKgXW5s52d7LoxCISLibw30P/5fX+r5tiiBZl6HFlr7XHx8kHgEgfNbhqUeuuFIUjyVsA6Ba3CnK+ByDKyZW5wG6vAHT3/oKN9vpZK5tZUMbMdWprp4oyDxRFw23dg7i5tY/Zz231aoFCCHE92pl6qV/fhqQN1hvIiVUwb8Sf/auC4C+r1Rz6JhSu+NeKY/zf8mPo9AoTewaz8K/90dgWoVf02GptjV8uhBDXp8ySTHLLcrHR2NDBq3nFDWy0Nvzz5n8CsPjkYk5ePGmKIVrU5SmBhmbKLapiYN552PoBfN6HY38WruhWXADuITD0ZSKf2ouLnQv5lUUtLo2xqfJLKnl/zQmGfLCJTWfUv1NeDv78/uwgPr+/F619Xcw+BqvPXAkhxPVoR9oO4593pe+iqKIIV3tXyw1Ar4PN78HWWervYQPg7u/ArfGpe/kllTw9/wDbT2cD8OItHZk6rC0ajYaMi2raRYBzgPHLhRDi+mT4At7aozWOto1PKb5S38C+jAofxfqk9czaM4t5o+ddU+s2L68UaBDpqxa1SMxPtPznPkB5kZr+fWg+JG4HFLJttKS7t0IDdLnzB2g3CrQ22KH+P9h8fjOx6bHGwPBaVFqh49ud5/hi8xkKyqoACPcpIxcY07EzkSEeFhuLXAmFEMLEiiqKOJx5GAAvBy8q9ZVsT91uuQGUXoT5ky8FVv2egkdWNimwOptVxB1zdrD9dDbO9jZ8+VBvnh7ezvgFyJDTLuuthLj+GVICm7Pe6krTe0/HXmvP7ozdbDy/0WTHtYTLZ64MvB29CXYJRkHheM7xup5qWno9nN0My56EDzvA8qcgcRugQMRgjg6ZBkBbz3a4dBgDl6X/RQVFAXX0u7oGVOr0/LgriaEfbGLWmgQKyqroGODGvIf7MLCT+jot2eMKZOZKCCFMbnfGbqqUKsLdwxkRNoJvj31LTHIMY1qPMf/JM47BogfgYiLYOsH4T6DH5CYdavupbKb+vJ+CsiqCPRz56pG+dAl2r346Q3DlIsGVENc7QzGL5q63ulwrt1Y80vUR5h2dx4d7P2RwyGDsbexNdnxzMgRXIa4h1bZ39e1KWnEax3KOcXPQzeYbQPYpOLwADi+CgpRL273bqk1+u08GzzCOHvgUUEuwXykqWA2uDmYepLSqFCdbJ/ON14T0eoXfjqTx8fqTJOWUANDKy4npozowoWcINloNC9aq1ydLrweW4EoIIUzMsN5qQPAAosOi+fbYt2xL3UaFrsK8XxqOLIaVz0JVKXiGw+SfIKj+Jup1+SE2kbd+O45Or9ArzJMvH+qDn1vNni0ZJda5eAkhLM8UZdhr83i3x1l+ejkpRSn8ePxHpnSbYtLjm0ta8aUeV5eL9I1kfdJ6Y4U+kyrJhbilcGgBpO67tN3RA7reCT3vh1Z9q62rNTQP7uZXM7iKcI8g0CWQjOIM9l/Y3+KbOiuKwqaETD5Ye5L49AIAfF3teXZEe+69ORQH20uzcoYeV1f+/zE3Ca6EEMKEFEUxrrcaGDyQbr7d8HPyI6s0i13puxjSaojpT6qrhPX/gl1z1N/bRsNdX4Gzd6MPVanT89Zvcfy0S22DcWevEGbe2a3aBetyF4rVMsSBzhJcCXE9yy/PNwYTHb07mvTYznbOTOs9jde2v8b/jvyPCe0m4OvU8vsr1ZYWCBibCZusYqCuEk5vUGepElaDrkLdrrGBdiPVWaoOY2ttraFX9MZx1DZzpdFoiAqKYtnpZcSmxbbo4GpvYi6z1pxgb6Lau8rNwZa/DW3DXwa2xsWhekijV/TGm3+WbCAMElwJIYRJJRcmk1qUiq3Wlr6BfdFqtIwIG8GihEXEJMeYPrgqyoTFf4GkP9d0DX4Bhr9aLae+ofJKKpj68wF2nslBo4F/junE34a0qXeBuSEtUGauhLi+GdZbtXJthbu9+1X2brzb2tzGwhMLOZp9lE8OfMLbA982+TlMqUpfZfz8uzItsItPFzRoSCtOI7csF2/Hxt/oQlEg7SAcXaz+FGddeiygmxpQdbsbXP3rPUxiQSKFlYU42jjSzrNdrftEBf8ZXKW3zHVXx9MK+HBdAhtPZALgYKvl0QERPDm0LV4utWeDZJdmU6WvwkZjg5+znyWHK8GVEOLaodPr+MeWf+Bu786MgTOsPZxa7UhVZ616+ffC2c4ZgOiwaBYlLGLz+c3o9DrT9RJJ2QeLHoLCNLB3gzvmQufxTTrU6cwiHv9+L4k5JTjb2/DJvTcxqsvV11EZ7gzKmishrm8ncsyTEmig1Wh5qe9LPLT6IVacXsG9He9t0dXrMksya/S4MnC1dyXCI4Jz+ec4ln2s4TfVFAVS90PcMji+EvKTLz3m4g/d74Ee90JgzRmouhhSE7v4dMFWW/vX/n5B/QA4dfEU2aXZLWbW8NSFQj7beJrfjqShKGCj1XBPn1Cei25PoEf91SrTi9WUQH9n/zpft7lIcCWEuGYkFiQSkxwDwKNdH6WNZxsrj6imnWmX1lsZ9Ansg7u9O7lluRzMPEifwD7NP9H+72DVi2p6iG8HmPwz+DWt78zqo+m8+OsRisqrCPF04qtH+tA56Op3pit1leSU/tlAWNIChbiumaNS4JV6+vdkXJtx/HH2D97f+z7fj/m+xZZmN5RhD3INqrUNRVefrpzLP0dcdlz9wZVeDyl74fgK9efywhR2ztBhjBpQtY0Gm8Z/bT+apa63MpSIr423ozedvTsTnxtPbFos49s27SadqRxPK+DzTadYfSwDRVG33dY9iOmjOtDGr2Gl7Q3BlaVTAkGCKyHENSS54NJdvJjkmBYXXFXoKtiTsQegWt66ndaOoa2G8tvZ34hJjmlecFVZCqtfggM/qL93Hg8T54KDW+MPpdMza80J5m07B8DNrb2Z80AvfF1rFq6oTWZpJgoK9lr7pqW9CCGuGYbgypSVAmszrdc0NiZv5GDmQdYkrmFs67FmPV9TGddb1VEsIdI3kt/P/l57M2G9Hs7vhuPL1RmqwrRLj9m7qgFVlwnqeip752aNs75iFpfrH9yf+Nx4dqXvslpwdSQlj09jTrMh/oJx2y1dA3h2RPtG96kyFLOwRsq6BFdCiGtGcmH14OqJ7k9YcTQ1GUrZ+jr50sGr+ixSdFg0v539jY3JG3mp70tNuxubsk/tX5J9EjRaGPF/MOj5alWhGiqzoIxn5h9kT2IuAH8b0oYXb+mIrU3D2x9eXoa9pd5dFkI0X0llCYn5iYD50gINAl0CeSzyMf576L98tO8jhoUOa5HlwesqZmHQ1UdNaTyWfQxFUdAoekiO/XOGaiUUZVza2cEdOo5VA6q20bUWpmiKcl05CRcTgNqLWVwuKiiKb499S2xarDpeC36m70/K5dOY02w5qa4r02hgXLcgnhnRjk6BTVvfZ5i5quv/jzlJcCWEuGZcPnMVlxNHRnFGiyqkYKgSOCB4QI0L04CQATjaOJJWnMaJ3BON+4JSVQ6b34Mds0HRg2ugur6q7YgmjXPX2RyemX+Q7KJyXB1s+fDu7oyJbHzqhDQQFuLGcPLiSRQU/Jz8LLIe59Guj7L01FLSi9NZdGIRj0Y+avZzNpYhLfDKYhYGnbw7YauxJbcsl4yVUwk6uQGKMy/t4OABnW6FLhOh7XCwbVjGQGOcyD1Blb7K2Ni4Pr0CeuFg40BWaRZn8s7Qzqv24hemoigKu87m8tnGU+w8o6aX22g1TOgRzNTh7Wjn37D0v7pIWqAQQjSAYeZKgwYFhY3JG7m/8/1WHtUll/e3upKTrRMDQwYSkxzDhuQNDQ+u0g/Dsqcg88+Svt3ugbHvN6nMuqIo/G/rWWatTUCnV+gY4MbcB3s1OIf9SlIpUIgbg6VSAg0cbR15oPMDfLjvQw5nHbbIORvL2OPqypkRXRUkbsPx+AraVVRwwk7LsYRlBJWUgqMndLpNnaFqMwxszdss2VDMoptvt6vORDnYONDLvxex6bHEpseaLbhSFIVtp7L5bOMpY0l1W62GSb1b8dSwtoT7uJjkPJIWKIQQDXC+8DwAI8JGEJMc06KCq+zSbBIuJqBBY+x4f6XosGjjuJ+96dn6D6irhG0fwdYPQF8Fzr4wfnaTqwEWlFXy4uLDrI1Tc9nvuCmEf98RibN90y8DElwJcWMwNA+2VHAF0MZDXVObWJBosXM2hiEtMMQ1RP28PrdVXUMV/zuUqunWXX28OWHnyrGwXozqMx0ihpg9oLqcYb1VfcUsLjcgeIAaXKXF8lCXh0w6FkVR2Hgik083nubw+TwA7G20TO4bypPD2hLiadrUT2NaoIUbCIMEV0KIa0SFrsL4Yflo10eJSY5h34V95JXl4enoad3BcalKYGefznUWdxjSagi2GltO550mqSCJcPfw2g+WGQ/L/qbOWgF0vh1u+w+4NC0dJz69gKd+2k9iTgn2Nlr+Nb4LD/QLa3ZO/YUSaSAsxI0gPkedueri08Vi54xwjwDUm2p6RV9rRT5rubzHVXDsF3BirTGgAsDZBzqPJ9LbjyWnFxHnFawWp7AwQ6XAq623MogKjoL9sO/CPip1ldjZ2DV7DHq9wrrjGXy28TRxaQUAONppuf/mcP42tA0B7qZZX3a54spiCirUc8nMlRBC1CGlKAW9osfZ1pkefj3o4NWBkxdPsiVlCxPaTbD28NieqjbxHRg8sM59PBw86BPYh13pu4hJjuGxyMeq76DXwc5PYdO7aol1R08Y9xFE3tWkohUASw+k8Oqyo5RV6gnxdOK/D/SiZ6hnk451JZm5EuL6V6mr5FTeKcCyM1dBrkHYam0p15VzofgCQa6WXztTg14tSpF55Gd0ig47RcH34AL1MWdf6HK7uoYqfCDY2BKZewJOLyIuJ87iAWJ+eb4xlb6hM1ftvdrj7ehNblkuh7IO0Tewb5PPr9Mr/HE0nc83nuLkhSIAnO1teCgqnMcHtcHPzfRrzAwMKYFu9m642jdv7VZTtJzbAEIIUY/zBWpKYLh7OBqNhhFhajEHQ98ra9Irenal7QJgYEjdwRWoqYFQy7izT8M3t8CGN9XAqsMYeHo3dJvUpMCqvErHa8uOMv2Xw5RV6hnc3pffnh1kssAKLs1cXY8NhOfMmUPr1q1xdHSkd+/ebNu2rc59ly5dyqhRo/Dz88Pd3Z2oqCjWrl1bbZ958+YxePBgvLy88PLyYuTIkezZs8fcL0OIZjuTf4YqfRVu9m51Fm8wB1utLaFuoYCVUwP1ekjeDav/CR93hu9uJfX4rwAE6xS0vR6Bh1fAPxLUDIM2Q439qNp6tsXBxoGiyiKSCpIsOmxDSmC4ezgeDg0rY67VaOkf1B+A2LTYJp23Sqfn1/0pjPp4C39fcJCTF4pwc7Dl2RHt2PHPEbwytrNZAyuwbjELkOBKCHGNMNyBM1xsDUHKzrSdlFSWWG1coKbMXCy/iIudC939ute7ryEoPJJ1hMySTPXCHTsHvhioNpJ0cIcJc+C+heDWtBmhlIsl3PNFLD/vTkajgeei2/PdX27G28V0uf7lunJyy9Q0mOstLXDRokVMmzaN1157jYMHDzJ48GDGjh1LcnJyrftv3bqVUaNGsWrVKvbv38/w4cMZP348Bw8eNO6zefNm7rvvPjZt2kRsbCxhYWGMHj2a1NRUS70sIZrEkBLY2buzxVsuhLupqdOXV4q1CEWB1P2w9jWY3Q2+GQ27v1DLpzt4kNZmMADBoQPg9k/V4hS1NPi109oZZ/sMxSUsxdjfqoEpgQaGNcO70nc16nnlVToW7klm+EebeWHxYc5mF+PpbMf0UR3Y/vII/jG6I14mvAbVx5rrrUDSAoUQ1wjDxTXMPQyAjl4dCXENIbUolZ1pOxkZbvl8dgNDCfZ+gf2w09afo+7v7E93v+4cyTrCphOLmXz4D0hSn0+b4TDhc/Bo1eSxbDmZxXMLD5JXUomnsx2zJ/dkWEf/Jh+vLpl/lhR2tHFs8F3Ra8XHH3/MlClTePzxxwGYPXs2a9euZe7cucycObPG/rNnz672+7vvvsuKFSv47bffuOmmmwD4+eefq+0zb948fv31V2JiYnj44YfN80KEMAFLVwq8nGFdqkVmrhQFMo7AsaUQtwzyLptpsndTy6Z3vRPaDict7hs4dJLgBszkRfpGcjjrMHE5cRZtzmsI5hqaEmgQFaQGV3E5ceSX51/18z05p4T5e5JZvO88OcUVAPi42PPEkDY82D8cVwfLhxqG4MpaKesSXAkhrgmGmaswNzW4MqQG/nj8RzYmb7RucJWqBkdXSwk0iA4dwZGsI2zY+ymT0zPAzgVueQd6/6XJa6v0eoVPN57ik5hTKAp0b+XBnAd60crLuUnHu5qMkkvrra6nBsIVFRXs37+fl19+udr20aNHs3PnzgYdQ6/XU1hYiLd33eXyS0pKqKysrHef8vJyysvLjb8XFBQ06PxCmJKhUqC5mwfXJtxDDa7MllKnKJB5/FJAlXvm0mN2zmpj3653QLtR1Rr7VqsUeBWXNxO2FEVRGl3MwiDAJYA2Hm04m3+WPRl7GBU+qsY+VTo9G09k8tPuZLb+2fgXINDdkSeGtOH+m8Nwsrdp3otoBmNaoJXW6UlwJYS4JhhmrgxpgaCmBv54/Ec2p2ymUl951VkjcyisKORI1hGg9v5WNeSnEH1gCf8B9jnYkR8+AI8Jc8C7dZPHcLG4gmmLDhm72z/QL4x/je+Cg635Lm7XawPh7OxsdDodAQHVX1dAQAAZGRkNOsZHH31EcXEx99xzT537vPzyy4SEhDByZN03BWbOnMlbb73VsIELYQY6ve5ScOVtheDKkBZYaOK0wKwENZg6thSyEy5tt3WE9qMh8k5ofwvY135zyhBc1ehxVQvDzNGJ3BMWu06lFqVysfwitlrbJs04RgVHcTb/LLFpsdWCq4z8MhbuTWbhnvNkFJQZtw/p4MeD/cIY0ckfWxvrrzgyFLSQtEAhhKhDpa7S2LDx8vLlPf16Gisb7cvYV2d/KXPak76HKqWKcPdwWrnVk86nKHDoZ1jzCuHlBbRrFcxpO1u2DnqS8c0IrA6fz2PqzwdIzSvF0U7Lvyd2467eTU8rbChjcHUdFrMAaszGKYrSoBm6BQsW8Oabb7JixQr8/WtPx5w1axYLFixg8+bNODrWXYb4lVdeYfr06cbfCwoKCA0NrXN/IUwtuTCZ0qpSHG0cjaXRLcnweZ9SmNL8wKT0IhxZDAd/VNP/DGzs1ZmpyDuhwy3g4HbVQ6UWqWslGzJzFe4ejqudK0WVRZzJO2OR9ErDeqtOXp2wt2n8OqeooCh+jv+Z2LRY9HqF7aez+Xl3EhviM9HpFQC8Xey5p08o998cRpiPeTIkmkrSAoUQ4irSitPQK3qcbJ3wdbrU68lGa8Pw0OEsObWEmOQYqwRXhvVW9ZVgpzADfnsOTq5Rf2/VlxGdh3D69GJizm9ifBNKySuKwvw9yby18jgVOj0RPs7MfbA3nYPcm/IyGu16LcPu6+uLjY1NjVmqzMzMGrNZV1q0aBFTpkxh8eLFdc5Iffjhh7z77rts2LCB7t3rL37i4OCAg4N5q2oJUR/DrFUH7w7YaC2f5uXv7I+TrROlVaWkFqYS4RHRuAPo9XBuixpQxf8Ouj/TbLW20HaEuoaq063g2PB1o1X6Ki4Uq5VSG1KNTqvR0tWnK7szdnMs+5hFg6tufo1LCTToE9gHG40NKUUpDPnPr6RkXQqebm7tzQP9whgTGWjW7IimqtJXqcWikGqBQghRJ0O+fahbaI3ZA0P1vU3Jm9AreouOS1EUY/PgWtdbKYp6p/S//dTAysYeRr4Fj61lZKe7AXW9VmlVaaPOW1qh4x+LD/PasmNU6PSM7hLAymcHWSywgssaCF9nwZW9vT29e/dm/fr11bavX7+eAQPqTvtcsGABjz76KPPnz2fcuHG17vPBBx/w9ttvs2bNGvr06WPScQthDpdXCrQGjUZjXGfbqHVXeedh83vwSQ/4cSIcW6IGVgGRMOZ9eOEUPLAYet7XqMAKIKskiyqlClutLX7Ofg16Tldfy667MpynseutFEVhb2Iury45SWWx+r5fqDyKm6Mtjw6IYN3zQ/jlb1FM6BnSIgMrgOzSbHSKrlH/f0xNZq6EEC3e+UK1x5XhInu5fkH9cLZ1JrM0k2PZx65aCt2UkgqSSC1KxU5rR5+AK74s556Fta9Dwh/q70E9YOIXENAFUCtvBbsEk1acxs60ncbS8leTkFHIcwsPciKjEK0G/jmmE38d0sbiRSWMM1fXWRl2gOnTp/PQQw/Rp08foqKi+N///kdycjJPPvkkoKbrpaam8sMPPwBqYPXwww/zySef0L9/f+Osl5OTEx4e6he3WbNm8X//93/Mnz+fiIgI4z6urq64ulq+yaUQDWHNSoEG4e7hJFxMuHpwVVUOJ/5QZ6nObALU9DUcPNR+gb0egqCeTS4aZGBICQx2CW5wU2DDuqu4nLhmnbshKvWVHM85Xu28V1NQVsmyA6n8vDvJ2PDX3rcdDs7n6NnhAt/fFo2z/bURMhhSAgOcAyzatPly18Y7JYS4oV1Zhv1yDjYODG41mLWJa9mYvNGiwZUhJbCXfy+c7f5MmyjNg60fwO4vQV+ppp8MeQkGTwebS+sFDNUOf4r/iZikmKsGV5U6PXM3n+Gzjaeo1Cn4ujrw2X03EdXWx1wvr16GaoHX45qryZMnk5OTw4wZM0hPTycyMpJVq1YRHq6u/0hPT6/W8+rLL7+kqqqKp59+mqefftq4/ZFHHuG7774D1KbEFRUVTJo0qdq53njjDd58802zvyYhGktRFKtWCjQwrLuqM7jKOKYGVEcWqeuqDCIGQ6+HofN4sHMy2XgM638bUszCINJHDXJOXTxFWVUZjrZ1r7VsrtMXT1OuK8fN3q3aGuXaHE3J5+fdSaw4lEZppQ4AJzsbJvQMpm+nu3hz33pSy4/iYHvtVIQ1FBuxVkogSHAlhLgGXFmG/UrRYdGsTVxLTHIM03pPs9i4DCmBA0IGgK4K9n8Lm96FUrW5Lm1HwOh/G2errhQdFs1P8T9dtdrhsdR8Xvz1CPHpainukZ39efeObvi7m+8CXZ/SqlLyy/OB6y8t0GDq1KlMnTq11scMAZPB5s2br3q8xMTE5g9KCAvKKM4grzwPW40t7T3bW20ctQZXpXlqqt/BHyHtUrNu3ILhpgeg5/3g3cYs42lMMQuDQJdAY/GlE7kn6Onf0yxjg0vrrSJ9ImuduckrqWDNsQzm70nmSEq+cXuHAFce6BfOxJtC8HCyo0pfxUeH3SisKCQuJ86iNy6bw9hAuBHBr6lJcCWEaPHqm7kCGBwyGDutHYkFiZzNO0sbT/NcVC9Xoatgb8ZeAAZWaWHugEslfX07wi3/hvY1+4Nc7ib/m+qtdlhepeOzmNPM3XIGnV7By9mON2/vyu09gq3aW8qQEuhs64yb3dUrawkhrj2GlMA2nm2aVHHOVKoFV+e2qQHV8RVQ9WcpcK2dWpTipofUG1pmLrzRmDLsBhqNhkjfSLambCUuJ84iwdXlxSyyi8pZF3eB1cfSiT2TQ9WfFf/sbbSM7RbIg/3D6RPuVe26Yqu15eagm4lJjiE2LfaaCa5aQrElCa6EEC1apb7SeDG7vMfV5VztXekX1I/tqduJSY6xSHB1IPMApVWl+GJDh+XPqRudvGH4q2ozYJurf7zaaG0YFjqMpaeW1qh2eDD5Ii/9eoRTmWr++7huQbw1oSu+rtavHnd5MYvrqYGwEOISQ3BlrWIWBhEadYY+oySD0h/G46T8uZbKr7O6jqr7ZHDxrecIptWU4ArUmaStKVvNXtTCcPxQ5478GJvIqqMZ7D6Xw5/xFACdg9yZ0DOYu3u3wqeea0pUUJQaXKXH8rcefzPruE1F0gKFEOIqMooyqFKqcLRxxN+59r5BoFYNNARXT3R/wryDKspi59Z3ABhQmI9Gawf9n4TBL4CTZ6MOFR0WzdJTS9mUvIlX+71KRZXCx+tP8tW2s+gV8HW15+0JkYztZr0LxZWu1wbCQohLTuRYcb2VXg9nYmDP//A8vQGP0CDybWxIdvKgY+eJ6ixVSO9mF6doiqakBYJlKgaeysridN4ZAKb/mIu+6lIBjW4hHoztFsjYyCBa+7o06HiGG36Hsw5TUllyaW1xC2ZMC7RSA2GQ4EoI0cIZ1lu1cmtVb+Wf4aHDeTv2beJy4sgozjBPSkBVOeyaC9s+YoePMzjYM9C7C9z/WZPz+/sH9cfFzoXM0kx+ObKTL9dXcS67GIA7bgrhX7d1wcvFeik5tWkJaRdCXO8qdZVoNVqr9JcCK1UKrCiGwwtg1xeQc8q4OVzrxBEqSL7rczq2HW+58Vzh8h5Xjf3ybqjcl1iQSGFFIW72pkmpPp9bwppjGaw6ls6R7P04hyvoKzzRV7lxU5gnt0YGMSYykFDvxgdGoW6hhLiGkFqUyr4L+xjSaohJxmxOxuuTq6QFCiFErQyLmOsqZmHg6+RLT/+eHMw8yMbkjdzf+X7TDUJR1Bz/9f+CvCSybLScdPBEg4aoO38CR68mH9rexp6ooIFsSF7HGzELKc8eS4C7A+/e0Y3ozi1zZkiCKyHMK6M4g3t+u4euvl2ZO3Kuxc+fW5ZrTP+1SHCVnwJ75sH+76AsT93m4K5W++vzGOHHv+bI2d9I+nNM1tKUHlcG3o7exvYbx3OO0y+oX5PHkZhdzOpjGaw+ll6tKIW9j9q2pKNXVz5/eQTBns2rkqjRaOgf1J8lp5YQmxbb4oOrgooCiirVVHprtgmR4EoI0aIZe1zVUczictFh0aYPrlIPwNpXITlW/d0tiJ03TYTzf9DFpwtezQisAHaczmbHkSDwBFvXOCaEPsFrt3XBw6n2yoEtwfXaQFiIluKXhF+4WH6R7anbOZ5znC4+tVccNRdDSmC4ezgudg1LIWuSlH2waw7ELQdFLQWOV2vo/5Ra8c/BzTgOgMT8RPONpQGMZdgb0ePqcl19u5JWnMax7GONDq5OZxax+mg6q45lGCvHAmg10K+1D7d2C2Rn4Rq2p8OEzlHNDqwMooKjjMFVS5depKYEejp4WjWFUYIrIUSLZizD3oDgakTYCD7c9yH7LuwjrywPT0fPpp84PxViZsCRhervtk4w8DkY+Hd2xL4FwIDgAU0+fEFZJTNXnWDBnmTQtsbNwwatQzZ/HenSogMruL4bCAthbZW6SpaeWmr8fcnJJXSJsmxwZdaUQF0VxK9UU6xT9lzaHjEY+k+FDrfUqPh31V5XFtLUYhYGkb6RrE9a36Bmwnq9wvH0AtYfV6v8GZr7AthoNQxo68PYyCBGdw0wFjr6bnHjmgc3RL/AfmjQcCb/DBeKL7To3oaGa5M1i1mABFdCiBbOWIb9KmmBoOaHd/DqwMmLJ9mSsoUJ7SY0/oQVxbDjE9jxKVSVqtt63Acj/g88QtDpdcSmq3fwBoYMbPzxgU0Jmby69Cjp+Wop4Ydu7kimywB2pm0jJjmGdl7tmnRcSzGsOWjJF1lhGWfzzvLv3f/mie5P0D+ov7WHc12IOR9DTlkO9lp7KvQV/HHuD/7R5x8WvRNvlkqBpXlw4HvY/T8oSFG32dhD5CR1piqo7lLfhuDKcLPNWppazMLA0Ey4rqIWeSUVbDuVzeaELLaczCK7qNz4mJ2NhkHtfBkbGcSoLgE11uJeKL5AZkkmNhobk/5/83T0pItPF+Jy4tiVvqtp11ULMcwsSnAlhBB10Ol1pBSpF+GGBFegpgaevHiSmOSYxl0E9Hp1lipmBhSqqQWERcEt70JIL+Nu8bnx5JXn4Wrn2ui+H3klFcz4/ThLD6gX6HAfZ96/qzv92/iw9NRIY3DVkkveFlcWU1hZCEhaoIBPDnzCnow9lFaV0n+cBFemsDhhMQCPdH2EtYlrSS5MZm3iWu5of4fFxnAi989Kgab4kp5zRp2lOjQfKtViPTj7Qt8p0GcKuF39Jo0huMotyyW/PB8PB4/mj6sJmjtz1cWnCxo0pBenk1Oag5eDN8fS8o3B1MHki9VKpjvb2zCwnS9jIwOJ7hxQb1aDIWBr59nO5IH4gOABxOXEEZse26KDK0OlwCBXCa6EEKJW6cXpVOmrsNfaN3iWZETYCOYensvOtJ0NKx2rKHB2E2x4C9IPqds8w2HUDOgyoUap3x2pOwDoF9QPO23D0/fWxmXw+vJjZBWWo9HAlIGt+cfojjjZq+kvw0KHodVoic+NJ60ozard5etjSLtws3Mz71oM0eKlFKawOWUzoDYuPV9wnlD32nvRiYY5m3+WPRl70Gq03N3hblzsXJh9YDa/nvrVYsFVUUWRMf2uk08T0wIVBc5tUYOqk2uBPyMG/67qLFW3u8HOscGHc7Zzxs/Jj6zSLJILkqs1yLWk5vZQcrV3JdQtnOTCRKYt+43jZ0LIKa6otk+HAFeGdfRnWAc/ekd44WDbsGqRR7KPAKZNCTSICo5i3tF57ErbhaIoLba/YUaRpAUKIUS9GlqG/XIdvToaS8fuTNvJyPCRde98bitsevdSsQoHdxjyAtz8tzov/DvTdgINX2+VU1TOGyvj+P2IeketrZ8Lsyb1oHd49UIY3o7e3OR/E/sv7CcmOYaHujzUoONbmqQECoNFCYvQK3rj72sS15i/x9x1zjBrNSRkCEGuQUxoN4HPD37OkawjnLx4kg5eHcw+hoSLCYDax87b0btxT64sg6OL1aAq87J1RR3GqOupWg9pcm+qcPdwskqzSCpMslpw1ZS0QJ1e4UhKHltOZrE5IYszOi/sPBLZnXaIimI/XB1sGdjOh6Ed/Bna0Y+QJhaiMMxcdfM1/XvTw68HTrZO5JTlcPLiSTp6dzT5OUzBOHMlwZUQQtTufEHDKwUaaDQaRoSN4MfjP7IxeWPtwVXiDtg8ExK3qb/bOKgpKoOmg2vd5XULKwo5nHUYuPp6K71eYcXhVN7+PZ7c4gpstBr+OqQNz0W3x9Gu9juR0WHRLT64yij5s4GwBFc3tJLKEpacWgKof29jkmNYdW6VBFfNUFZVxoozKwC4p+M9gNpiYnjYcNYnrWfJySW80u8Vs4+jSSmBRZmw9yvY+zWUZKvb7Jyh5wPQ70nwbf460nD3cPZd2Ge1ohY6vc44c3+1zILsonK2nVKDqa0ns7hYUml8zM6rFXYeB2kdksubd/Snd7gX9raNrzx45dgMRTLMEXja29jTO6A321O3syt9V4sNrmTNlRBCXIWxUmAD11sZRIdF8+PxH9mcsplKfeWl9L3k3bDp32q6CqiLqXs/qgZV7lf/MN6dvhudoiPCPaLeO5c7T2czc/UJjqaq/Uc6Bboxa1J3urfyrPf4I8JGMGvvLA5mHiS3LLfxd40tQCoFCoDfz/5OYUUhoW6hvBn1JltStnA67zSnLp6ivVd7aw/vmrQmcQ2FFYWEuIZUmxmf1H4S65PW89vZ33i+9/M42jY8na4p4nP+LGbh04DgKueMWgDo8ALQ/Zne5t4K+v1V7VHl1LxWFZeLcI8AICnfOsFVVullPa6cqt+E0+kVDp3PY0tCJptPZnE0NR/lsrVTbg62DGrvy7COfvj5+vPc1t8o0ybRv423SVLszuWfo7iyGCdbJ9p6tG328WoTFRTF9tTtxKbF8kjXR8xyjuao1FeSVZIFyJorIYSoU2MqBV6up19PvB29yS3LZV/GPqL0dmr635kYdQetnXrhHzwdPFo1+Lg70tT1VnWlBManF/De6hNsOal+wLvY2/DUsLb8dUjbBt2ZDHENobN3Z+Jz49l8fjN3tr+zwWOzFGkgLBRFYX78fADu63Qfno6eDAoZxObzm1l9brUEV01kSAmc1GESNpeVIu8f3N+Y6rw+aT3j24436zgaVIY99QDsmA3HV2JcT9Wqr5r61/l2sDH910tDBkNSoXWCK0NKYJBLEDZaGy4WV7D1VBYbT2Sy5WQWeZfNTgF0CXJnWEc/hnbwo1e4F3Y26jWgXBeArcaW3LJc0ovTTbK+9mj2UQC6+nSt9nfHlKKCowDYf2E/5bpyHGwczHKepsosyURBwV5rb/UbkxJcCSFaLMPMVWMXydtobRgeOpwlp5YQs+GfRJ1VU/nQ2qppKkNeAM/GBWyKorAzVV1vdWVKYGpeKR+tS2DZwVQUBWy1Gh7oF8az0e2N/UcaKjosmvjceGKSY1pkcCUNhMXujN2cyT+Dk60TE9tNBODW1rcag6tnb3q2xS54b6nic+I5kn0EW62t8T010Gq03NHuDj4/9Dm/nvzVrMFVua6cs3lngVrSAg3Ff7b/R12vatD+Fhj0PIRHmW1ccNnMVUGSVYoqpBaqwZW+wou75u6sUdnPzdGWIe39GNrRj2Ed/PB3r32G0cHGgfZe7YnPjedY9jGTBlfmWG9l0M6znbGoyKHMQ41ugmxuhmIjgS6BTWrwbEoSXAkhWiSdXsf5QnXNlaEMb4OlH2HEuX0sATZVZvGqxgZtj/vUoMq7dZPGk1iQSFpxGnZaO/oE9AEgv6SSOZtP8+3ORCqq1IX947oH8eLojkT4Nq2SXnRYNJ8f+pzYtFiKK4tbXEU+mbkShlmrCW0n4GbvBsDQVkNxsnUipSiFuJw4s1Qsu579cvIXAEaGjcTXybfG4xPbTWTu4bkcyDzA2byztPFsY5ZxnL54miqlCk8Hz0v/xnVVEL8Cts+GDLUiHVpbtT/VwOcgwDINjg2FjYori8kpy6n1fTK1ovIqtp/KYtOJLNalbQcPOHfBnvL0i4Ca8j28kz/DO/rTK8wTW5uGfanv6ttVDa5yjjE6YnSzx2koZmHOf3cajYb+Qf357exvxKbFtrjgythA2MopgSDBlRCihcosyaRSX4mt1rbh63suHFcLVcSvpJ8GnMNakWlry7EHfqZ7u7HNGo+hSmCvgF5oceB/W8/w301nyC9VU0H6tfbmlVs70zPUs1nnaevZlnD3cJIKktiWso0xrcc063impCiK8QIW4CwFLW5EKYUpbD6/GYD7Ot9n3O5s58ywVsNYnbiaVedWSXDVCEUVRfxx9g/gUiGLKwW4BDC41WA2n9/MklNLeLHvi2YZy+UpgZqqMjj0M+z8DC4mqjvYOUOvRyDqafC0bNl9ext7glyCSC1KJTE/0SzBlaIonMkqZtOJTDYlZLI3MZdKnTo95RCUhT3QxjOUB/tHMryjP8FNrOwX6RPJr/xKXHbc1Xe+irKqMk5ePAnQ6N6LjRUVHKUGV+mxTGOaWc/VWC2lUiBIcCWEaKEMefWtXFtdPYc8KwE2vwdxy1Dz/zU4dL2Lwe62rE3fycb8BLrTvODK0N/KXR9J9EdbSM0rBdSeJC+P7cTwjv4mSVMxVDv89ti3xCTHtKjgqrCykJKqEkBmrm5UC08sREFhYPBA2nhUnz0Z03oMqxNXs/bcWl7o84LVU3OuFb+f/Z3SqlLaeLQxzorX5u4Od7P5/GZWnlnJc72ew97G3uRjMVYKLCmE2d2gWF0/ipM39Psb3PxXcLbeepYI9whSi1JJLkymT2Dd71VjlFXqiD2Tw6YENaA6n1ta/Zw+zgzv5M+RKh0nC2DqoL6Mb9vIbIorGG4+HM85jl7RN+vfSnxuPDpFh6+Tr9lvevUPUhuFx+fEk1eWh6ejp1nP1xjN7UFmShJcCSFaJGMxi/rKsGefgi3vw9FfMS6q7jIRhr0M/p2JPreatek7iUmOYVrvaU0eS1lVGbvS9wCwPNYVfXkpge6OTB/dgbt6tcJGa9rc/+iwaL499i3bUrdRoaswy5eopjDMWnk4eOBk27Q7tuLaVVJZwtJTSwG4v/P9NR4fFDIIN3s3Mksz2X9hP30D+1p6iNccRVGMKYH3dLyn3hs0A4MHEuAcwIWSC8QkxzC2dfNuGNVQkEb82XUAdD61BYpLwCMMBjwDNz0I9tZPUQ53D2dH2g4SCxKbdZzzuSVsTshk44lMdp7JobzqUr82exst/dp4M7yjP8M7+dP6zxTvsUvUQLMxPa7q0tazLY42jhRVFpFYkFjjRkVjHM26tN7K3OvQ/Jz9aOfZjtN5p9mVsYsxES3n5p8xLVCCKyGEqJ1hvVWtlQJzzsDWD+DIIjA0Me08Hoa+DIGX0pEGhwzGTmtHYkFik9cpHEvN59U1S6i0LUdf6YaLphVPjWnHYwNb19mvqrm6+XbD38mfzNJMdqXvYkirIWY5T2MZGghLGfYb0+9nf6ewspAwtzAGhQyq8bi9jT0jw0ay7PQyVp9bLcFVAxzKOsSpi6dwtHG8aqEKG60Nd7a/k7mH57Lk5BLTBVdZCbDjU3RHFnEyNAC0Wjq5hsMt06HrHWBjZ5rzmICxYmATyrGfzixi1dF0Vh1N50RGYbXHgjwcGdbRnxGd/BnQ1gcXh+pfj3V6nbHHnykKUNhqbenk3YlDWYeIy45rXnBlgWIWl4sKjlKDq7SWFVwZ0wJlzZUQQtSu1pmrvGR1purQAlB06raOt6ozVUE9ahzD1d6VfkH92J66nZjkmEYFV+dzS/hgbQIrD6fh4L8fex9o49qLH14cgZeLeWeStBotw8OGsyhhERuTN7aY4EoaCN+4FEXh5/ifAXXWqq40pjGtx7Ds9DLWJ63nlX6vXOoxJ2r1S4I6azW29Vjc7d2vuv8d7e7gi8NfsDtjN8kFyY1qsF7D+b1qOfUTvwOQaGdLmVaLk9ae8L/tADOV9G4OQ8VAQyXZqzmdWcgfRzJYdTSdhAuXAiobrYbeYV4M6+THiE7+dAxwq3fWJ6s0iyp97T2umirSN5JDWYc4ln2sWRUgDcGVpdY5RgVF8ePxH4lNi7VK1cbaKIoia66EEOJqqjUQLrwA2z6C/d9ealTZfrQaVIX0rvc40WHRxuDqie5PXPW8ucUVfL7xND/uSjQuZPb2PUeRAlP7jTN7YGUQHRbNooRFbDq/if/T/5/Zepc0hjQQvnHtSt/F2fyzONs6M6HthDr3uznwZmOPuV1puxjcarAFR3ltuVh2kbWJa4G6C1lcKcg1iEEhg9iWuo0lp5bwfO/nG3dSRYFT69WgKmnHnxs10Gkcx9v2g+Pz6OTbFW0L+LypjaFybHJBMjq9rtbPxboCKluthkHtfbm1WxCjuwTg6dzwz/LL1/OY6rO4q29XAI7lHGvyMXLLco39tywVXPUO6I2d1o604jSSC5MbX83XDPLL8ymtUtfKtYT1wFZfbTpnzhxat26No6MjvXv3Ztu2bXXum56ezv3330/Hjh3RarVMmzat1v2WLFlCly5dcHBwoEuXLixbtsxMoxdCmINe0V9KCzy6HD7tCXu+VAOr1kNgynp4YPFVAyuAYaHD0KAhLifOGBzUprRCx383nWborE18s+MclTqFQe18+eGvnShSzqNBQ1SQefu4XK5PYB/c7d3JLcvlYOZBi523PlKG/cZlKL8+sd1EXO1d69zPVmvL6HC1tPSaxDUWGdu1asXpFVTqK+ns3ZmuPl0b/Ly7OtwFwPLTy6nUVV5l7z9VlsL+72BOf5h/txpYae3UtVRP74F7f+YE5cBVmgdbWZBLEHZaOyr0FcaZdFADqk82nOKW/2xl5Mdb+c+GkyRcKMRWq2FYRz8+mNSd/a+P4ru/3Mw9fUIbFVjBpQbCwS7NTwk0iPRRg6GE3AQq9Q38/3gFQwn21h6tjW0RzM3Zzpme/j0BiE2Ltcg5r8Ywa+Xj6NMimhtbNbhatGgR06ZN47XXXuPgwYMMHjyYsWPHkpxc+3RveXk5fn5+vPbaa/ToUTMFCCA2NpbJkyfz0EMPcfjwYR566CHuuecedu/ebc6XIoQwocy8RMp15dgqCkG7/geVJRDSBx5eAY/8BqE3N/hYvk6+xgvBxuSNNR4vq9TxY2wiwz/czAdrEygsr6JzkDs/PHYzPz3ejxyd2telq09Xi1ZGstPaMbTVUABikmMsdt76SAPhG9P5gvNsSdkCwH2d7rvK3nBrm1sB9e9tWVWZWcd2rdIrehafXAzA5I6TG5VaNaTVEHydfMkty2Vzyub6dy68ABvfgf90hd+eg6wTYO8GA56FaUdgwn/BrwNwWaXAK5sHtyA2WhtC3dQS8LHJJ/hkwylG/2dLtYDKzkbD8CsCqrv7hOLh3PQUVcPMlSnWWxmEuYfhZudGua6c0xdPN+kYll5vZWC40WhoUWJtLSklEKwcXH388cdMmTKFxx9/nM6dOzN79mxCQ0OZO3durftHRETwySef8PDDD+Ph4VHrPrNnz2bUqFG88sordOrUiVdeeYXo6Ghmz55txlcihDCJyjLYNZfz390CQEhVFbb+XeDeBfD4BmgzrEmHjQ6LBqoHVyUVVXy17SyDZ23i/1bEkVFQRoinE/+Z3IM/nh3EkA5qXr3h4jEgZEAzXljTRIdfGreiKBY//5WMBS0kuLqhLEhYgILCoJBBRHhEXHX/Hn49CHIJoriymG2pdWej3Mh2pe8iuTAZVzvXRhemsNPacUe7OwD49eSvte+UfgSWPakGVVs/gJIc8AyDW96F6XEw+h1wvxQoKIpi7HHV2aflBlenLhRSVe4DwCu/beI/G05y8kJRtYBq32uj+NYEAdXl0opNH1xpNVq6+KoNmJuaGnh5pUBLigpWg6u9GXup0ldZ9Ny1aUnFLMCKa64qKirYv38/L7/8crXto0ePZufOpkfCsbGxPP989RzkW265pd7gqry8nPLycuPvBQUFTT6/EKIJdFVqs8ot70NBKsmuLoAjoT6dYcIS0DbvPtCIsBF8uO9D9l3Yx/n8LFbsz+Pr7ee4WKKmYgR7OPK3oW2Z3De0WgVAnV5HbLqa9jAweGCzxtAUA4IH4GjjSFpxGidyT1j1S480EL4xlVSWsOyUmlr/QOcHGvQcrUbLmIgxfBv3LavPrWZU+ChzDvGatDhBnbUa33Y8znbOjX7+He3vYN7RecSmxZJSmEIrt1ag18OptRD7X0i8LKgN7ac2/e04Dmxq/9qXWpRKYUUhtlpb2nq0bdJrMpdTFwr5488qfycvFOHg74S9D9g6ZDO4kz+3dgtiVOcAkwVStTGkBZqiDPvlIn0i2Z2+m7jsOO7ucHejnqsoitVmrjp7d8bd3p2CigKOZR8zZodYS3pRy5q5slpwlZ2djU6nIyCg+kU6ICCAjIy610VcTUZGRqOPOXPmTN56660mn1MIS9mYvJE159bQN6gvw0OHm6VDvUXp9RC3FDa9C7ln1G1uwSR1ioLsvYQF39zswAog1C2Uth7tOZN/ilvnfUlh9k0AhPs4M3VYW+64qRX2tjXPczznOPnl+bjaudLNz7IXLwAnWycGhgwkJjmGmOQYqwZX+eX5lOnUFC+pFnjjWHlmJUWVRUS4RzAguOGzt2Nbj+XbuG/ZmrKVooqietdp3WguFF9g0/lNANzToWGFLK4U6hZKVFAUsemxLD2xiL8r7rBr7qXPUY0NdJ0I/Z+GVldfm2qYtWrv2R67FlB6/UJBGUsPpLLsYAonLxQZt9vZaOjg3ZpEtjKoM8y7xTLl/s2RFgiXilAY1k41RnJhMgUVBdhr7eng1cGk47oaG60N/YL6sT5pPbFpsdYPriQtsLor84xNUdaxscd85ZVXyM/PN/6cP3++WecXwhwURWHmnpmsTlzNjNgZjPhlBI+sfoQfj/9o/OC/ZigKJKyGLwfDkinqFwJnH7hlJvz9IOed1bTfZpUZ/lNmYRkzV8Vz6lwEAJWOR2nn78rsyT2JmT6UyX3Dag2sAHakqdW0+gX1s1pJaUNKo7XXXRkWj3s7ereIBcPC/PSKnvkn1EIW93a6t87y67Xp5N2JCPcIynXlxkBCqJaeXopO0dHLvxftvNo1+Th3tRoOwIqj31C16gX1c9TRAwY+p66nmvRNgwIrgPgc66cEllfpWHU0nb98u4eomTG8v+aEMeVvRCd/Prq7B/teH8W/xqhrUVOLG1aOvbl0ep3xy7vJZ67+DK5O5502VrtrKMOsVSefTlYJiA2pgYbsDmtqacGV1WaufH19sbGxqTGjlJmZWWPmqTECAwMbfUwHBwccHOTLgmjZUgpTyCjOUJsPenXiWM4xDmQe4EDmAWbtnUUXny6MDBtJdHh0sxoSmt25rRAzA1L2qr87uMOAv0P/J8FBrXZUrQx7E6XllfLlljMs3Hue8io9WofOuHivx8n9NMsn98HVweWqxzCstxoYYvmUQIMhrYZgq7HldN5pkgqSrFb21rDeSlICbxy70nZxLv8cLnYu9ZZfr41Go2Fs67HMPTyX1edWN6uPz/WkSl9lXCfV0PLrNaTsh13/ZUTccrxDA8m0sWGbfwTD+zwDPe4Dh8bPEhqKWVijUmBcWj6L96Ww4lCqMVUboE+4F3f3acWYyCA8nC4FDxFKBKCm6lXqKs0eWBh7XGlM1+PKIMA5AB9HH3LKckjITWjUDJBhtqu7b3eTjqmhDEUtjmQdsfrsdEtbc2W1mSt7e3t69+7N+vXrq21fv349AwY0feF4VFRUjWOuW7euWccUoiXYk7EHUD9IF9y2gHV3rePlm1+mT0AftBotx3OO8+nBT5mwfAITlk/g0wOfcjzneIsohABAyj74/nb4frwaWNk6waDn4bnDMPRFY2ClKMqlMuxNmLlKyinm5SVHGPrBJr6PTaK8Sk/PUE/m3TueYNdgqpQKdmVc/U5bQUUBR7LUSoHWWG9l4OHgQZ/APoB1Z6+M661ukJTAxrQJWbp0KaNGjcLPzw93d3eioqJYu3Ztjf2utTYhP59QmwZfrfx6Xca0HgOo5ZrzyvJMObRr1taUrWSWZOLl4NW4tWi6KohbDl+Phq9GwLEl2Ck6Jmi9APi1w0C4+YkmBVZwKS3QUpUCc4sr+HbHOW79ZBvjPt3OdzsTuVhSSaC7I1OHtWXjP4by61MDmNw3rFpgBWoFWGdbZ7VlR5H5M40MmSGBLoEm7zeo0WianBpoKGZhqf5WV2rl1opQt1B0io69GXutMgaACl0F2aXZgMxcATB9+nQeeugh+vTpQ1RUFP/73/9ITk7mySefBNR0vdTUVH744Qfjcw4dOgRAUVERWVlZHDp0CHt7e7p0USuuPPfccwwZMoT333+fCRMmsGLFCjZs2MD27dst/vqEMCVDcNU3UM0xD3IN4oHOD/BA5wfIKc1h8/nNbEjeYGz2efboWeYdnUeIawjRYdGMDB9JD78ejUrtMYkLcbDx35Dwh/q71g76PAaD/wFuNb+oZ5VmUVpVio3GplE9RU5nFvLfTWdYcSgV/Z/xZP823jw7oj0D2vqg0WjYXxTNj8d/ZGPyRkaGj6z3eLvTd6NTdES4R5g8z76xRoaNZFf6LmKSY3gs8jGrjMGQFngjNBA2tAmZM2cOAwcO5Msvv2Ts2LEcP36csLCaAf/WrVsZNWoU7777Lp6ennz77beMHz+e3bt3c9NN6vo+Q5uQt99+mzvuuINly5Zxzz33sH37dvr162fpl3hVSQVJbE3ZCjSs/Hpt2ni0oZN3J07knmB98vpGL9i/Hv1y8hcAJrafiL1NA3otleXDgR/VPn95f6bBae2g2yToP5U7nd35dvl4tqftIKM4o0mVPLNLs8kuzUaDxqxrd6p0eraeymLxvhQ2xF8wNmm3t9EyqmsAd/duxeD2ftho618aotFoCHcPJz43nuSCZLNnapirmIVBV9+ubEnZ0qiKgZW6SmNAbOliFpeLCorifOF5YtNjGR423CpjMNz4c7RxxNPB0ypjuJJVg6vJkyeTk5PDjBkzSE9PJzIyklWrVhEerqa9pKen1+h5ZbhQAezfv5/58+cTHh5OYmIiAAMGDGDhwoW8/vrr/N///R9t27Zl0aJFLfLiJURDKYpivDN0c2DNHk8+Tj7c1eEu7upwF4UVhWxN2UpMcgzbU7eTWpTKD8d/4IfjP+Dr5MuI0BFEh0fTN7CvedcRXUxU+6sc/RVQQKOFHvfD0JfAq+7UtuQC9d98kEtQg9I94tLy+e+m06w+loFhkm5oBz+eGdGOvhHe1faNDlODq80pm6nUV9b7+nekquutrJkSaDA8bDjv7H6HI1lHyCzJxN/Z3+JjuJEaCF/eJgTUFh9r165l7ty5zJw5s8b+V1ajfffdd1mxYgW//fab8Zp1eZsQUG8ebtmyhdmzZ7NgwQLzvqAmWHhiIQCDQwY3KxV1bOuxnMg9wepzq2/44Op84Xl2pqqpxne3r+e9UBTIOKpWUD34M1QUqtudvKHvFOj7OLip/w4jUG+47c3Yy7JTy3iq51ONHpdhvVWER0STKhdezenMIhbvP8+yA6lkFl6qzNwtxIO7+7Ti9h7BjW7qawiukgqSTD3cGsxVzMLA0Ew4Ljuuwc9JuKg2HvZw8DD2/bKGAcED+OXkL1ZtJnx5SmBzazaYilWDK4CpU6cyderUWh/77rvvamxrSIrTpEmTmDRpUnOHJkSLkViQSFZpFvZae3r4195A28DN3o1xbcYxrs04SqtK2Zm2kw1JG9hyfgvZpdn8cvIXfjn5C272bgwPHU50WLRa8tvW0TSDrSyF7bNh+39A9+eFtOsdMOxVY7PK+hhSAq/2he5g8kU+33iamBOZxm2juwTwzIh2dG/lWetzevr1xNvRm9yyXPZl7DMuyL2SoiiX+ls1okKaufg7+9PdrztHso6wKXkTkztNtvgYbpQGwqZoE6LX6yksLMTb+1Jwfy21CSmuLGbZ6caVX6/LmIgx/Gf/f9iXsc9qNwZail9P/oqCwsDggYS61/KFuDADjvwChxdC5mVftH07Qv+noMe9YOdU42l3tb+LvRl7WXp6KX/t/tdGp66ZIyWwoKyS3w+ns3j/eQ4m5xm3e7vYM7FnCHf3aUXnIPcmH9+QMp5YkNjMkV6dOXpcXc6Q1pdYkEhBRQHu9ld/XwzFLCJ9I60aUPQN6otWoyWxILHJM6fN1dKKWUALCK6EEFdnmLXq4d+jUZXanGydiA6LJjosmkpdJXsy9rAheQMbkzeSW5bLyjMrWXlmJU62TjzZ48nmpZwpCpz4Hda+eil9pfUQtVllUP0B4eUMxSzquhu3+2wOn208zfbTao61RgO3dQ/m6eFt6RRY/0XJRmvD8NDhLDm1hJjkmDqDq3MF50gvTsdOa0efgD4NHrs5RYdFcyTrCDHJMVYJrm6UmStTtAn56KOPKC4u5p57LhUsuJbahKw4vYLiymIi3CPq/DfSUMGuwfT068mhrEOsTVzLQ10eMtEory0Vugpjv7C7O142a1VRAgmr4PACOLMRFL263cYeOo6Fmx6GdtHqB10dRoaPxGOPBxnFGexI28GQVkMaNTZDMYvmBld6vULs2RwW7zvPmrgMyirV12KjVRv8TuodyohO/nVWZ22MCPcI4FKmgzkZZq7MlRbo5ehFiGsIqUWpHM85Tv+g/ld9jmF9ljVTAgHc7d2J9I3kSNYRYtNiuaP9HRYfQ0vrcQUSXAlxTbhyvVVT2NnYMTBkIANDBvJ6v9c5lHWIDUkbiEmOIb04na+OfMWjXR9t2pqs7FOw+iX1ywGAeyu45d/QZUK9XwpqY0jzuLKYxa6zOczecJJdZ3MB9YJ9x00hPDWsLW39Gr6Ie0TYCJacWsKm5E282u/VWl+vIXWnd0Bvs6TJNEV0WDT/2f8f9mbsJb88Hw8HD4udW1GUG65aYFPbhCxYsIA333yTFStW4O9ffZamKW1Cpk+fbvy9oKCA0FDzpgDpFT0LTqhpivd3vt8kazTHtB7DoaxDrDm35oYNrjYkbeBi+UX8nf0ZGjwYEneoAVXc8ktpf6A2/O1xrzrb7+TVoGM72Dgwvs14for/iSUnlzQ6uDKkBXbyaVqlwNS8UhbvO8/ifSmk5l0qJ97e35W7+7Ri4k0h+LuZKDPiT4bMBovMXJk5LRCgq09XUotSOZZ9rEHBlaHYkrWDK1DXXVk1uJKZKyFEY11tvVVT2Ght6B3Qm94BvflHn38wYMEACisLScxPpI1nIxYHlxfB1lkQOwf0lerd1gF/h8HTwf7qpc5rY6wU+GcZ9tgzOXwScymosrPRcHefUJ4a2pZQ78YHPv2C+uFs60xmaSbHso/R3a9mGdvtaWoBHGtWCbxSuHs47TzbcTrvNFtTtlq0tHVuWS4V+go0aK774Ko5bUIWLVrElClTWLx4MSNHVi+Ycq20CdmZtpPEgkRc7Vy5ve3tJjnmLRG3MGvvLI5kH+F84XmrrhGxFkMhi0m2/th+3vvS7D6AZxh0v1cNqnzaNun4kzpM4qf4n9iSsoWskiz8nBtWMrygooCUohSgcTNXlTo9G09ksnBPMptPZhnXu7o52nJ7j2Du7hNKj1YeZktZMwRXmSWZlFSWmO0mmF7RG9MCzTVzBWp637qkdQ1ad1VQUWAMKq1VKfByUcFRfHnkS3al70Kv6C1eNKullWGHFtBEWAhRvzN5Z8gty8XRxtEsd6lstbZ08VGrbR7JPtKwJymKWqji8z6w4xM1sGo/Gqbuguj/a3JgpSiKMc0jN8+de/8Xy33zdrHrbC52Nhoe7B/G5heH8+4d3ZoUWIF6l3dwq8EAbEzeWOPxcl05+zP2AzAgxPrrrS5nrYbChkqBPk4+VmlWaUlNbROyYMECHn30UebPn8+4ceNqPH6ttAn5Of5S+XUXu6b9O76Sr5Ov8cbQmnNrTHLMa0bpRU5vn8X+C/uxURTuPLZWDazs3eCmB+HRVfD3wzDitSYHVgBtPdtyk/9N6BQdy08vb/DzEnITAAh2CW7QbHhSTjGz1pxgwHsb+duP+9mUoAZWUW18+OTenux9bST/vqMbPUM9zboWyMPBw1gZznBDzhyySszX4+pyxnLsDagYaEgJbOXaCm9H76vsbX7d/brjbOvMxfKLxr9PlmRIWZeZKyFEgxlSAnv692xY6d4m6O7bnf0X9nMk6wgT202sf+cLcbDqJUj6s72BVwSMeR86jmn2OHLKciipKgFFw/Pzk0Gxxc5Gw+S+oUwd1o5gz5qLuZsiOiyatYlriUmOYVrvadUe239hP2W6Mvyd/Gnv2d4k5zOV6LBovjzyJTtSd1BaVYqTrWnej6sxpATeCGXYofFtQhYsWMDDDz/MJ598Qv/+/Y0zVE5OTnh4qF9Yr4U2IYn5iWxP3Y4GTZPLr9dlbOux7ErfxerE1TzR/QmTHrvF0VXC6Rg17S9hNYs9nMHDjWElZQS0Hq42+u14K9ibdrZlUodJHMw8yJJTS5jSbUqDZhCMKYH1NA8ur9KxLu4CC/cms+N0jnG7r6s9k3qHMrlvKK19TROIN0a4ezh5WXkkFiTS0bujWc5hmLUKcAkweY+ry3Xx6YIGDRnFGWSXZuPr5Fvnvi1lvZWBndaOvoF92ZKyhdj0WDr7WKZXGqg3ZCUtUAjRaIbgylQpgbUxpMYZ8rhrVZoHm2fCnnmg6NQmwIP/AQOeBbvm59PHnsnh3ZhV4AD6Sk/stfZM7hvKU8PamiyoMhgcMhg7rR2JBYmczTtbLRXSsN4qKjiqxZR1Nejk3Ylgl2DSitPYmbbTOJNlbjdaA+HGtgn58ssvqaqq4umnn+bpp582bn/kkUeMVW+vhTYhhrVWQ1oNaVID7/pEh0Xz9q63OXXxFKcvnqadVzuTHt/qFAUyjsChBXB0MZSoBXdKNBpWuqv/bu4Z9R9ob7503lHho3hv93ukFqWyK31XgyqdGisF1vKF+HRmEQv3JLP0YCq5xRWAuoR2cHs/7usbSnTnAJMUp2iqcPdwDmcdNms5dnP3uDJwsXOhtUdrzuafJS47jqGhQ+vc9/JKgS1FVHCUGlylxVq0F2NuWS7luvIWl7IuwZUQLZhe0bPvwj6gecUsrsYQXJ3KO1Uzf12vh8PzYf0bxi8MdL5dLVjh2fwvYLFn1EIVu8/lYutxDqdgCHAO4acXh5k8qDJwtXelX1A/tqduJyY5plpwtSOt5fS3upJGo2FE2Ah+iv+JmKQYywVXJTdGpcDLNaZNyObNmxt0zJbcJqSoosiYTnZ/5/tNfnwPBw8GBQ9ic8pmVieu5lmvZ01+DovTVULKXji7GeJ/g8zjlx5z8YNud7PGJ4ii4/MIdQulf7ua6aKm5GTrxLg241iYsJAlJ5c0KLi6slJgWaWOVUfTWbAnmb2JF437Bbo7ck+fVtzdJ7TJKdmmZlh3Zc7gyhLFLAwifSM5m3+WYznH6gyuFEXhaJYaXNW2XthaooLUqqIHLhygrKrMdK1drsJw48/Pya9FpaxLcCVEC3by4knyy/NxtnWmq29Xs53H39mfAOcALpRcIC4n7lIgl3oAVr0IqWqAh28HGPs+tB3RrPMpilqyd/aGU+w5pxaqsLfR0r11FQnlMKJtV7MFVgbRYdHG4MqQpnSh+AKn806jQWO8WLQ0o8JH8VP8T2w+v5kKXYXZUkUvZyzDfoOkBd6IVpxZQUlVCW082pjt7/7Y1mPV4Orcap7p+UyLmxm+KkWBrBNwZpMaUCXtgIqiS4/bOECnW9W0v7YjwMaORb+rbRPu7nC3RRb6T+owiYUJC9l4fiM5pTn4OPnUuW9pVSln888CYFvVijdWHGPZwVQKyqrUl6PVMLyjP/fdHMrQDn7Y2rSsZfrXW3DV1acrK8+sNKb91SajOIOcshxsNbb1pnJaWmuP1vg7+5NZksmBzAMW6w9pSNtsScUsQIIrIVq0PelqSmCvgF7Yac17V6a7X3fWJ63nSNYR+rq1gY0zYP/3gAL2rjD0n9DvSbBt+pf5uoKqe29W0/8+PrSRhMS6e1yZ0rDQYcyInUFcTpyx+aGhcXCkbySejp5mH0NT9PTvib+TP5mlmcSmxdabPmIqxjVXN9DM1Y1Er+iZHz8fgPs73W+2oGdY6DCcbJ04X3ieuJy4FpXWVKeCNDi7Bc7+GVAVXaj+uLMPtB6qBlOdb6tWPj0uO47jOcex09pdfS2riXT07kg3324czT7KyjMr+UvkX+rc90jmCfSKHhu9Gw98GQ+o/99beTkxuU8od/cJJdDDMjMQTWHodXU9pAXCpTS/uOy4Ots0GIpOtfdqb7HZoYbQaDQMChnE0lNL2ZS8yWLBVUvscQUSXAnRopm6BHt9evj1YH3Seo6e+g1WvQ2lf6aEdLsHRs0A96Z/eNUVVN13cyhPDmtLkIc6S2VoIGwow25Ovk6+9PTvycHMg2xM3sj9ne83pgRa6sLQFFqNlpHhI5l/Yj7rktZZJrgqkeDqerY9dTvJhcm42bmZtcS/s50zQ1sNZU3iGlafW90yg6uyAnVGyjA7lX1F9TNbRwgfAG2GQZvhEBAJ2tpndAzl10dHjMbLsWE9q0xhUodJHM0+ypJTS3i066PVvqQrisLR1HwW7DnPyrPL0fpBeUkQtloto7sGcG/fMAa180WrbfmzioabcHnleWbr/WecuXIx/8xVR++O2GpsuVh+kbTitFoDupZWzOJyI8NGsvTUUjYkb+Dlm182awEQg5ZYzAIkuBKixdLpdey/oJYEt0Rw1U2nfhAeuZiAUnoRTUAk3PqB+kWiiRoaVBn2NZRhN/Vi+rpEh0Ubg6vJHScTmxYLtMz1Vpe7JeIW5p+Yz6bkTWZPDdQremNw1ZIWDAvTMcxa3dH+DrM3zR7beixrEtewJnEN/+jzD4v3xKlBVwkp+9RA6uwm9c+K7rIdNBB805/B1DC1yW8DCvgUVBSw6uwqACZ3nGyOkddpTMQY3t/zPkkFSey7sI++gX1JyytlxaE0lh1M4eQFNZXRITAFe6BfSDc+fCQaX1fL9lRrLmc7Z2MqWlJBksnXIFmqx5WBg40D7b3aE58bz7HsY7WesyUWszDoH9QfN3s3skuzOZh5kD6Bfcx+TkNw1dJu/ElwJUQLdSL3BIWVhbjZuZk3t7okF9a+RucjC7ANb0WWrS0XRv6LwKjnwKbpHxH7EnOZtTahRlD11LB2taaaXCy/SFFlERo0tHJr1eTzNsaIsBF8uO9D9l3Yx860nRRUFOBm59Yi7wpezpKpgTmlOVTpq9BqtA1uTCquHWfzz7IjbQcaNNzb6V6zn29QyCDc7NzUtRkXDljkC1g1hnVTZzerP4nbq6+bAvBucymYihgMzo3vJfTbmd8o05XRzrMdPf16Nn/cjeBs58y4NuNYfHIxH8V+jyZLx65zOcZGv/a2WsZGBnLGLp+kIrivZ9Q1F1gZRLhHmC24qtbjykKffZG+kcTnxhOXHcctEbdUe6xKX8XxHLVoSksqZmFgZ2PH8NDhrDyzkvVJ6y0aXFliTVxjSHAlRAtlKMHeO6C3+abXE1bDb89B0QWcgPa2bsTrijjcKpLAJgZW53NLeG/NCf44on7o2dtquf/mMJ4c2rbe/H3DrFWgSyAONpa50Ie6hdLBqwMnL57kg30fANAvqB+22pb90WjJ1EBDMQtfJ98W/76IxlsQr5ZfHxo61CJrHe1t7IkOj2b56eWsPrfavF/AygshK0Gt4pcZr/5cOAbFWdX3M6ybMgRUXuHNOq2iKPySoKYE3tPxHosW7qjU6dl6MovTZ7sCizmWt52ipCGguNCvtTd33BTC2G5BODtA/5/PAZcqBV6LwtzD2JOxh8SCRJMf+/IeV5b67Iv0jWTxycW1NhM+k3eG0qpSXOxcjOvNWppbIm5h5ZmVbEjawD9v/qfZZ6ZbYgNhkOBKiBbLEFyZpQR7aR6seUUtsQ5qFcAJc+ieupb4hEUcyTpS467Z1RSVVzFn02m+2n6Oiio9Wg1M7hvGc9HtG7Qo+nzhecAy660uFx0WzcmLJzmXr37RGBDSctdbXc5SqYGy3ur6VVhRyMozKwF4oPMDFjvv2IixLD+9nPVJ63m538vNL9ZTWQrZJ/8MoI5D5gn1z/nJte/fiHVTTbH/wn7O5p/FydaJ8W3Mt4bNQFEUDp3PY/nBVH47kv5nTypHnCNCsHFKZfTNKfxryJO08rqU8pmQm0CFvgJXO1eLZQqYgyHIMNycMyVLFrMw6OqjVgU+nnMcvaKvFpwYUwJ9Ii2ynqkp+gf1x9XOlczSTA5lHqJXQC+znau0qpTcMjUzpqVdnyS4EqIFqtRXcuDCAQBuDjLxeqvTG2Dl36EgFdDAgGdg+Otg50iPigwWJSwyfog3hE6vsGR/CrPWJpBdVA7AwHY+vD6uC52D3Bt8HEPFp1B38989v1x0WDRzD881/j4wuGWvtzKwVGqgsYGwrLe67qw4rZZfb+vRln6BlmtmfHPQzXg7epNblsvu9N0MChnUsCdWVUDumeozUZnxcPEc/H979x0eVZU+cPw7Nb1BKhCS0DtSlCYClgCigroriqKI+ltEVMCGyooLiqzrKjZwVRBdRXDFLiBRaQqo9NBrEkpCCqS3Kef3xzhDhhRSJplJeD/Pkwdy586dMzfJPfPe8573KGvFz/GPhPBOEN4FwjtDWGeI7O6Shc8rYx+1uj7uevyN/vX2OilZhXy54xRf7TzF8cwCx/ZQfy9u6tmCgPA7WHzgFc6o9bQMnub0XPv6Vh2bdXT/vLc6qM9y7PZKdA2ZctY2uC3eOm8KTAUk5SQ5rcFoL2bhifOt7Iw6I8Oih/HtsW9Zk7ymXoMre9/kZ/Aj0Fj9zxoNQYIrITzQvqx9FJoLCfIKokNIB9cctCQPfngWtn9o+75ZGxizEFr3d+xin2u0L2sfJovpoovybTmWxZzv9rH3dC4Asc19eXZUF67tHF7jVJiGrBRYVoeQDrT0b8mp/FPEBcV5XO52ZRoqNdCxxpWH3RkUdWNVVpYe+LP8euf6K79eEb1WT3xMPMsOLmPV8VXOwZXVCkVnIS8VziU5B1FZh8FqrvigPiHnAyh7EBXeuVbzpeoiqyiLhJQEoH4KWZwrKOX7xFS+3HGKbcnnF/n1NmgZ3jWSm3u15Mp2oeh1WvJLW/Ppkbc5lnOMnRk76RXey7H/hYsHN1b24CopN6nS8uW1ZR+5asg+Qa/V07l5Z3ak72Bv1l6n4Mp+09PT5wTHx8bz7bFvSUhO4MnLn6y34L1spUBPWzNPgishPJC9BHvfiL6uuTAd3wBfPXQ+TabfJLhmFhidK4PFBMYQaAwktzSXQ+cOVbpwcUpWIXNX7mf1XtsH7wBvPY9e0567B8Ri1NeuvSdy/0wLbKBKgXYajYYRsSNYtGcRQ6OHNuhr11VDpAamFcoCwk3RL6d+4UTeCQKMAdzQ5ob6f0GrFQqzbEFT/hlGmjQsA3469j3PnTiGV/4ZyDsD+WmVB1AAxoA/A6g/R6PC/vzXPxw84APWV0e+wmw10z20O52buyZwKTFb+Hl/Ol/uOMXag+mYLLbKFFoNDGoXypjLWjK8WyT+Xs4f6fyN/oyIHcGXR77k80OfOwVX9sIIrmqju7Tyb4VWo6XIXERGUQbhvuEuO3ZDlmEvq2vzruxI38GezD2OpREKTYUcyT4CQPcwzw6uBrYYiJ/Bj/TCdHZn7Oay8Mvq5XXsI4ueeONPgishPJB98eA6z7cqLYAfn4ff37V9H9waRi+AuMEV7q7RaOgR1oNfTv3C7szd5YKrvGITb609wge/JFFqsc2rurNfDNOu60Azv7p9sHfXyBXAg5c9SKdmnRpdcNUQqYEyctU0fbL/EwBubX9r7cuvW8xgKrRdZwrSbcHRn8ETeanO3+efcQqaLgMio1uQpoeNJ9ZybWGR87F9QyGo1fmRKHsgFdTKI4KoiliVlf8d+h9gK2RRFyaLla1J5/hm1ym+351KbvH5c9c5KpBberXkpstaEBFYdXrjrR1u5csjX/JD0g88efmTBHkFYVVWDp6zrd9Vr5VoG4BBZ6Clf0tO5J0gOTfZtcHVnwUtGjqbwZ72V7aohX0OVrhvuEvfY30w6owMjR7K98e+54ekH+ovuLJXCmzg4Lc6JLgSwsOYLCZ2ZuwE6ri+VfJm+OpB23wEgD73Qvwc8Aqo8mk9Qv8MrjJ2c0enOwDbvKrlf5zg32sOklVQCsDg9qHMHNWFjpFVH686souzyS21pRa6Y3K1l86LEXEjGvx166ohUgOloEUTYTHbFsc1FXEsN5lNpzehRcPtBSWw/l+2IMlUBOYi27/2703FFTz255fVVPN2+IVBQCRa/0hG6AtYUnKSVe0Hcm2niRAQBQER4BcO+vpbu62+bDq9iVP5pwgwBtS4IBDAyXOFbDiUyfpD6fx6JIv8kvMBVWSgN6N7teDmXi3pFFn9+SU9QnvQPqQ9h88d5vtj3zOu8zhO5p2kwFSAUWskLiiuxu30NDGBMY7gylUFoKzK6hi5asiCFnA+uDp49iAmqwmD1uBICewR6nkl2CsSHxPP98e+JyE5gScuf6JeUgMdaYH+nlUpECS4EsLjJGYmUmQuopl3M9oFt6v5AUxF8PMLsPltQEFgS7jpTWh3TbWebl8/w34x33Qkk9nf7eNAWh4AbcL8+PuoLgztGOayPGf7qFW4bzg+ep+L7C3Kqs/UQIvVQkahrWy1FLRo5Cyl8NFNACxtHgKBAQwtKKDl2n+64OCaP4OmCFuA5B9xPlAKiLIVlQiItKXulZnHOTJrH0u+G8v6ghQK2g3Dz+Dngra4z/KDywEY3XZ0ta5jxSYLvx0/y/qDGWw4nMGRdOf1tkJ8DVzTOYJberWkX5vm6LQ1v95qNBpubX8r836fx+eHP+eOTnew76wtJbBDSIe6V2r0ADGBMfxy6heXFrXILMrEZDWh0+gafKSodUBrAowB5JXmceTcETo37+zRiwdXZFDLQfgZ/DhTeIbEzER6hvV0+Wt4claFBFdCeBh7Cfa+EX1rHryc3Gobrco8ZPv+srtgxFzwDqr2IewX7+TcZCZ8uI51+21VqIJ8DEy9tj139Y/BoHPtXSh7cGWfnCyqrz5TAzOKMrAoC3qNnlCfUJcdV7iB3hvCOpNr8OIb4zlAcWdwd4gIA4MPGHxtFfQMvrbv9WX+7/jyrXi73rtWqXqdm3UmNjCWpNwkfk752TG/pDFKK0hjw8kNAPy1418r3EcpxdGMAjYcymD9oQy2HMuixHy+yqFWA71bh3BVhzCGdAijW8ugWgVUF7qhzQ28tu01Dp87TGJmIgeybMUsOjVv3CmBdvVRMdA+ahXpF9ng6/tpNBq6Nu/KltQt7MnaQ+fmnR2VAj29mIWdl86LIa2GsPL4StYkramX4Mpdc+KqQ4IrITyMvZhFjVICzSWwbh78Ot9Wktg/Am58AzrWItXN6kuAtgV51tNsTNmGTtuZ8f1jmHpte4J96ydVx1HMwg3zrRq7+kwNtN8ZDPMN89h1VUQ1abU8Hv4fzukSKMr7kLZB7bh89Bdunb+k0WgYETeCd3a9w+qk1Y06uFpxeAVWZeXyyMtpE3S+wltesYlNR7NYfyiD9QczOJXtPLcsMtCbIR3CGNIxjEFtQwnydf1IUpBXEPExtgpuKw6vcPxdN/ZKgXb1EVy5o1JgWd1Cu7EldQt7M/cyLHoYqQWpaNBUWmTKE8XHxLPy+EoSkhN4vO/jLq3oZ1VWR7ElT1tAGCS4EsKjlFhK2Jm+E4DLo6qZO356p220Kt2W6kH3v8LIl2tcgthssfLpHyd4dc1BioIiMQSfpm10FguuH0y78LrPq6qKfeQqOqBh17hqKuorNVDmWzUdWfklfL4tBb+236I1wsFDPbnz/d8Y2LY5A9o2p0erYJePSFfHyNiRvLPrHTad2kR2cTbB3sEN3oa6MllNrDi0AoC/tr+NPady2HDYFkxtSz6H2aoc+xp1Wq6Ia8aQDmFc1SGMDhH+DVJG+tYOt/LtsW9ZdXyVIxWwqQVXJ/JOYLFaXHIjyN2jIt2a/1nUInMPiRm2lMC2wW0bVersoJaD8NX7klqQSmJmomPKgStkFWVhtprRaXSE+Ya57LiuIsGVEB5kd8ZuSq2lhPqEEhd4kYnGFhNseAU2vmKrwuUbCje8Bl1uqvHrbjycwZzv9nHojC3nv0Xz9uSxnbiWWfUeWAGk5P5ZKbCBy7A3FfWVGigLCDcdRr2WidcV87+TZ8HqS9G5nmw6m8Wmo1kA+Bp1XBHXjAFtmjOwbShdWgS6JCXtYtoEt6FjSEcOnjvIjyk/8pcOf6n313Qlq1WxYv8aMooyMBLEzKWQlf+L0z5xoX5c1T6UIR3D6N+mOb7Ghv/o1Tu8N3FBcRzPOU4RReg0OtqHtG/wdtSHSN9IjFojpdZSUgtSXVIUyT5y1dDFLOzsI1RHso/wxxlbNktjmW9l5633ZkirIaxKWkVCcoJLgyt7Jcdw3/AGT9usDs9rkRCXMPt8q8sjL6/6buaZvfDlJEjbbfu+y2gY9Sr41WxeTFZ+CbO/28fXO20XqhBfA9Ou60DvdrHcsXI5iRmJWJW13hYBtHNnGfamoL5SAz15wrComQBvAycsawCY0P02Ro+6ls1HbcHVlmNZnCs0se5gBusO2gqYBHrr6demuS3YatecDuEBaOsp2BoZN5KD5w6y6vgqjw2ulFJk5JVw8EweB9PyOHQmj4Nn8jl8Jg8V/iH6AMjL7E1pvgVfo46BbZs7Rqdimrt/tMFe2OKVra8AEBcUh7e+6jLujYVOq6N1YGuOZB8hOTfZJcGVY+TKTWmBEb4RhPqEklmUyTdHvwEaz3yrsuJj41mVtIo1SWuY3me6y0Zpyy4g7IkkuBLCg9jXt6p0vpXFbJtXtW6erQyyTwhc/wp0u7VGcyeUUnyz6zT/+HYfZwtK0WrgnoGxTL2mA0G+BsxWM946b/JMeSTlJjnNIXC1nJIcskuyAUkLrIv6SA2UtMCm41j2MbakbkGr0XJ7p9tp6R9Au/AAxg+IxWpVHEjLY/OxLDYfzeS3Y2fJLTaTsO8MCftsvwPN/Yz0b2NLIRzQtjltQv1c9kFpRNwI5m+fzx9pf5BRmOH2NJ/swlIOncnn4Jk8DqXl2f49k0d2YcWl5/29bR/Eb2h/DX8Z048+MSF46T1vjuJNbW/i9e2vY7KamkxKoF1MYAxHso+QlJvEoJaD6nw8d61xZafRaOjWvBvrTq4jpyQHaJzB1aCWg/DR+3C64DR7s/a6bPQtLd+zb/xJcCWEhygyF7E70zYS1S+yX/kdzh6HLx6Ak7YUATqMhBtft5U7roHT2UXM/GoPPx9IB6BTZAD/vLUHPaODHfvotXq6NO/C9vTt7M7YXa/B1cm8kwCE+YTVfjFTUS+pgY6RK1/P7MBE9cUExjB/6HwOnTtULtVJq9XQpUUgXVoEct+VcZgtVvaezmXT0Sw2H8vij+NnySoo5fvEVL5PtN0xjgj0YmDbUAa0aU7/Ns1pGeJT6zTClv4t6RnWk10Zu/gh6Qfu6nJXnd9vdRSWmjlcQRB1Jrekwv21Goht7keHiAA6RAbQMSKA1qEaxiXYPvzOGj6UIK/qV2ZtaCHeIYyMG8k3R7+hb2RfdzfHpewp5a4oauHONa7K6hralXUn1wHgrfOmXUgtlmZxMx+9D1e1uoofkn5gTdIalwVX7g5+L0aCKyE8xI70HZitZiL9IsunNexaDt8/BqV54BVoK1jR8/YajVZZrYpPfk/hn6sOkF9ixqjT8vDV7fjbkLYY9eXT/nqG9WR7+nYSMxIZ025MHd9d5eydoYxa1U19pAaeKZCRq6ZCp9VxTcw1XBNz8fXu9DotPaOD6RkdzIND21JqtrL7ZDabjmax6Wgm21OyOZNbwpc7TvHlDtvcFI3GtlxDM18jIX5GQnwNhPgaaeZn+76Zr5FgX4PT90E+Bkeq4ci4kezK2MWq46tqFVxZrIqCUjMFJWbyi83kl9i+CkrM5BX/ub3ETG6xmWMZBRw6k0fK2cJKj9cy2IcOEf6OIKpDRADtwv3xNjiPSO3N2gtAc+/mHh1Y2c3sP5ORcSMZ2GKgu5viUrGBscD5+bt14c41rsoqG4h0bt650a5JFh8Tbwuuktcwrc80l4x4S1qgEKJaypZgd1x8inPg+8ch8TPb99H94db3ILhmc5OOZuTz9IpEfk86C0CfmBD+eWv3KotVdA+zpSDYR9Pqi2O+lRSzqDNXpgaarCYyiv5cQNhPClpcyox6LX1jm9E3thmPXNOeYpOF7cnn2HzMNmdr14lszFZFdqHJljqXWVCt42o1EPxn0BXo2wx8NezO3M3M79YTHdAKL72WglKLLVD6M0DKs/+/1DmIKiy11Oq9hfobbSNREQF0jLT92z7Cn0Dv6n2QPZ5zHIDYoNhavX5D89H7cGXLK93dDJezVwxMyk2q87HcucZVWV2bny+73tiKWZR1Zcsr8dZ5cyr/FPvO7nN6X7Xl6fOBJbgSwkOULWYBwInfYcV9kJ0CGh0MeQoGPwa66v/ZmixW3t1wjNd/Okyp2YqvUcdTIzoxvn/MRSen9wi1VfY5dO4QhabCekvZO5FnW+NKFhCuO1emBmYUZqBQ6LV6mnnXrKy/aNq8DToGtgtlYLtQHsO2jEN2kYlzBaWcLSjlXGEpZwtMnCsstW1z/Gsiu9C2T16xGauCs38+B8CndVv0fkf4bP+3lGYNq1Xb9FoN/t56/L3Of/l56W3bjLb/t27mQ4c/A6lQf686nQt7cBUXdJHqrqJe2fuP1ILUOt9YcncxC7sQ7xBa+bfiZP5JR3/cGPkafBncajAJyQmsSVrjkuDK/jOSkSshRKUKTAXszbSll1wR3gfWv2wrWqEstlGqWxdBdA0WFQb2nMrhyc93sy81F4CrOoQx9+ZutAqpXpAU4RdBhG8EZwrPsC9rX73l6NvTOCQtsO5cmRpYtgx7fVeLFI2bXqcl1N+rRoFKqdlKdlEp58oEYWtPj2RV2puER+3nitZ3UWK2OgdHXjr8vQz4eekI8NbjZ9Q7BVJ+Xnq89NoGWTfKzhFcXWzpDFGvmns3x8/gR4GpgJN5J2kTXPt5wvb5PJ7wwf2Zfs+wOXVztdJ5PVl8bLwjuJrae2qd/kYLTAXklto+13jCz6giElwJ4QG2n9mORVlo6RtBi88fgJTNtge63wajXgHv6ufyF5ssvPbjId7feByLVRHsa+C5G7pwc6+WNb6g9QjrQUJyArszd9dfcCVl2F3KVamBUilQ1CejXkt4gDfhAefLgQ/sMJaEzxaSY0nhoRsCaBvc1o0trB4ZufIMGo2GmMAY9mXts1W4rUNw5e41rsoa3Gowg1sNdncz6uyqllfhrfPmZP5JDpw9QOfmta9Wab/xF2AMwN/o76omulS1g6tvvvmm2ge96aaaL2IqxKXMMd8q4wSkp4ExAEb9G3qOrdFxthzL4ukvEjn+55yHG3pEMevGroQF1C71pUfon8FVRv3Mu8orzeNssW0emMy5cg1XpQY2lgWEpW9qOoK8griyxZWsO7mOlcdX8nCvh93dpCpZrBZHQR4JrtwvJsAWXNW1YqCnpAU2Jb4GX65seSU/pvzImuQ1dQquPL2YBdQguBozZky19tNoNFgstZtYKsQlqSSP3w/8D4DLC3Kh1eVwy3vQrPqddW6xiXmrDrD0N9soUESgFy+M6c51Xer2wdhR1CJjN0opl6fb2Odb2VM6RN25KjXQ0ycM20nf1LSMiBvBupPrWH18NVMum9KgKX41dTr/NCarCS+dl0d/0LtUxATZ5l25KrjyhJGrpiQ+Nt4WXCWt4ZFej9T6b9sR/Pp5bvBb7UR6q9VarS/pvISogVPbyPvPYPab8wC4oudEuHdVjQKrH/edIf7VDY7A6o4rWpMwfUidAyuALs27oNPoyCjKcKSJuZJUCqwfw2OHAzhSA2ujsQRX0jc1LcOih+Gt8yYlL4V9Wfvc3ZwqHc+1pQTGBMag03reosGXGntRi7oEV2XXuJKRK9ca0moIXjovUvJSOHjuYK2P0xj6phrPUrZarSxevJgbbriBbt260b17d0aPHs1HH32EUqo+2ihEvcopyXH8sTYYqwU2vgqL4tlWlIZVoyHGJ5yI+BdBV70SwJn5JUxZup37P9pKWm4xsc19+fSB/rx0S/dqlxG+GB+9Dx1COgDUS2qgFLOoH/bUwDxTHptPb67VMdIKG9cCwtI3NQ2+Bl/HaOuq46vc3JqqyXwrzxITUPfgKqsoi1JrKTqNzuNTohsbe2ogwJqkNbU+jiMt0N9zR4trFFwppbjxxhu5//77OXXqFN27d6dr164kJSUxYcIEbr755vpqpxD1osRSwrjvx3HjlzdyLOdYw7xozin4aDT89A+wmvm9la0s6eXRV1Xr6Uopvth+kmtfXc93u1PRauBvQ9qweupVDGjb3OXN7RFmKwFbn8GVFLNwLXtqIMCa5Np1Yo1pAWHpm5qWkXEjAVidtBqrsrq5NZWT4Mqz2DMgMooyKDRVvkB0VezFLCJ8I9y6xlVTdV3MdQAkJCfU+qZXk0oLBFiyZAkbN27kp59+YseOHXz66acsW7aMXbt28eOPP/Lzzz/z0Ucf1VdbhXC5zw5+RkpeCsWWYt7Z9U79v+C+b2DhQEjaCAY/GP02fwTY1hC6IvLipdZPZRcx4YM/mP7ZLrILTXSOCuTrh67k6ZGd8TbUT1qKI7iqh8WEZY2r+lOX1MBSSylZxVlA41hAuD76pgULFhAXF4e3tzd9+vRh48aNle6bmprKuHHj6NixI1qtlqlTp1a43/z58+nYsSM+Pj5ER0czbdo0iouLa9SuS8HgloPxN/hzpvAMB84ecHdzKiVl2D1LkFeQY02+2o5eSUpg/RoaPRSj1khSbhKHzh2q1TGaXFrgp59+yjPPPMOwYeUX97v66quZMWMGn3zyicsaJ0R9KjAV8H7i+47vVx9fzeFzh+vnxUoL4NtH4bPxUJwNLXrBpI3kdLnRkXvsWDy4AkopPvvjBMNf28D6QxkY9VqeGN6Rb6YMonur6pdprw374oX7svZhsppcemz7nKvoQEkLdLWyqYFbUrfU6Ln2+XVeOi9CvELqo3ku5eq+afny5UydOpVnn32WHTt2MHjwYEaOHElKSkqF+5eUlBAWFsazzz5Lz549K9znk08+YcaMGcyaNYv9+/ezaNEili9fztNPP13tdl0qjDojXZp3Aai/a7ILyMiV56nrvCv7GlcSXNUPP4Mfg1oOAmqXVWGxWhz9kycXkalRcLV7925GjBhR6eMjR45k165ddW6UEA3hv/v+y9nis8QExjAsehgKxcJdC13/Qqm74D9DYNsSQANXToOJa6B5W7ambUWhaBPUhlCf0Aqfnp5bzP0fbuXJFbvJLzHTu3UwKx8ZzEPD2mHQ1f/irjGBMQQaAymxlNT6TlNFCk2FZBZlAjLnqj6UTQ38IemHGj23bBl2T67WZufqvunVV1/lvvvu4/7776dz587Mnz+f6OhoFi6s+PoQGxvL66+/zt13301QUMU3OzZv3sygQYMYN24csbGxxMfHc8cdd7B169Zqt+tS0i64HQBHso+4uSUVO1d8jnMl5wAZefck9hTzpNykWj3fk9a4aqriY+MB27yrmqYGZhRlYFEW9Fo9Yb5h9dE8l6jRJ7OzZ88SEVF5ikhERATnzp2rc6OEqG/Zxdl8uPdDAKZcNoWHez2MBg0JyQkcPFv7KjZOrFbY9Ca8dw1kHYaAFnDPN3Dt86C3Lez6e9rvQOWjVt/tPk38/A38dCAdo07LjJGd+N+kgbQLb7iF8zQajaMke2JGosuOax+1CvEKIdAY6LLjivPsnVhNUwMb2wLCruybSktL2bZtG/Hx8U7b4+Pj2bRpU63beOWVV7Jt2zZ+/932N3/s2DFWrlzJqFGjKn1OSUkJubm5Tl+XinYhtuDqcLZnjlzZP7xH+UXha/B1b2OEQ2xQLHB+Pm9NSVpg/RvSaggGrYGk3KQa3zyxF7OI8I1Aq6n/m8u1VaOWWSwW9PrKJ/jpdDrMZnOdGyVEfVu8ZzH5pnw6hnQkPjae9iHtHXNUFuxcUPcXyE2FT26FNTPBaoJON8CDv0Kcc9EKe3B14XyrcwWlTFm6nSlLd5BdaKJri0C+ffhKJg1pi07b8CMJ9tRAVxa1cFQKlJTAetMrvBdhPmE1Tg1sLAsI27myb8rMzMRisZQL1iIiIkhLq31V0dtvv505c+Zw5ZVXYjAYaNu2LcOGDWPGjBmVPuell14iKCjI8RUdfen8rbQPbg/AkXOeOXKVlJMESEqgp6lzWqCscVXvAowBDGpRu9TA1HzPX0AYarCIMNjmfUyYMAEvL68KHy8pKXFJo4SoT+mF6Sw9sBSAR3o/4rj78WDPB1mTvIafT/zM3qy9dG3etXYvkPg5fP+YbW6V3gdGvAR9JsAF6VVni8867tqUHbn6af8ZZnyRSEZeCTqthoeGtWPKsHYY9e67S1MfRS3sI1f28rnC9bQaLdfFXMfSA0v5IekHrmpVvYqUjWHCcFn10TddmA5Z10W0161bx4svvsiCBQvo168fR44c4dFHHyUqKoq///3vFT7n6aefZvr06Y7vc3NzL5kAq21wW8A2ippbmutxo9sy38oz1SUtUCnlGBmRkav6FR8bz7qT61iTtIaHLnuo2s9rLHPiahRc3XPPPRfd5+677651Y4RoCO/ufpcSSwm9wnsxuOVgx/Y2wW24Pu56vjv2HQt2LuDta96u2YELz8L302Hvl7bvW/SCm9+FsA4V7v5H2h8AtA9pT4h3CHnFJuZ8t4/Ptp4EoF24P6/e1pMerYJr/B5drXuoLS0wOTeZ7OJsgr2D63xMe6VAGbmqX/Gx8Sw9sNSRGmjUGS/6nMZUhh1c2zeFhoai0+nKjVKlp6dXmXp4MX//+98ZP348999/PwDdu3enoKCA//u//+PZZ59Fqy1/88TLy6vSgLGpCzAGEOkXSVpBGkezj9IrvJe7m+REKgV6Jns59tzS3Br3VVnFWZRYSmSNqwYwJHoIeq2eYznHOJp91HEz5WIay42/GgVXH3zwQX21Q4gGcSL3BCsOrQDgkV6PlLsTPannJFYdX8WGkxvYnbHbMWJzUYfWwDdTIP8MaPVw1ZMweHqVCwLbg6t+kf3YdCSTJz7fzansIjQauP/KOB6L71hv5dVrKsgriNjAWJJyk0jMTGRwq8EXf9JF2NM2ZI2r+mVPDcwoymBL6pZqjV45FhD28A7MzpV9k9FopE+fPiQkJDitj5WQkMDo0aNrfdzCwsJyAZROp0MpJYscV6JdcDvSCtI4fO6w5wVXuTJy5Yl89D6OoDwpN4nLvC+r9nPtxSzCfcNljat6FmgMZGCLgWw4uYE1SWt48LIHq/U8xwLCHp4W6LmzwYSoBwt2LcCszAxqOYi+kX3LPR4TGMMNbW6w7VuduVclefDNI7D0r7bAKrQj3P8jDH2qysAKzs+3OpoSybj3f+NUdhGtm/my/P8G8OyoLh4TWNm5OjXwRK5t5EqCq/plTw2E6lcNtI9cXap3b6dPn87777/P4sWL2b9/P9OmTSMlJYVJkyYBtnS9C0fCdu7cyc6dO8nPzycjI4OdO3eyb98+x+M33ngjCxcuZNmyZRw/fpyEhAT+/ve/c9NNN6HTedbfuqdwzLvysIqBpZZSTubZMgwkuPI89lTzms67kmIWDSs+5s+qgTWYd+VI2/TgBYShhiNXQjRmh84d4vtj3wPwcK+HK93vbz3/xvfHvufX07+yI31H5XdMk36Frx6E7GRAAwMegqtngsHnom1JL0y3pZUoDWu22ypN3dmvNc9c3xk/L8/8s+we2p1vjn7jkoqBhaZC0ovSgfNpHKL+1CQ1sNhc7Cgx3VhGrlxt7NixZGVlMXv2bFJTU+nWrRsrV64kJsb2oS01NbXcmle9ep2/Tmzbto2lS5cSExNDUlISADNnzkSj0TBz5kxOnTpFWFgYN954Iy+++GKDva/Gxl4x0NOCqxN5J7AoC/4G/0qX0BDuExMYw29pv9U4uJIy7A1raPRQ9Fo9R7KPcCz7GG2C21z0OfaCFpH+nt03yciVuGS8teMtFIrrYq6rslhFdEA0o9vZ0n/e3lHBvCtTsa0K4JJRtsAqqDVM+A6Gv1itwKrEbOG5H74GwFLcgkj/Znw48QpevLm7xwZW4DxyZVXWOh3rZL7trm+QVxBBXvW7CLKoWdVAexl2H72PxxURaEiTJ08mKSmJkpIStm3bxlVXnU+nXLJkCevWrXPa357eV/bLHlgB6PV6Zs2axZEjRygqKiIlJYW3336b4ODghnlDjZB9ravD5w57VOqkfb5VbGBso1gH7lJT24qBMnLVsIK8gugf1R+o3uhVXmke+aZ8ACJ9JbgSwu12Z+xm7Ym1aDVapvSactH9/6/H/6HX6vkt7TfH3CgATu+Ed4fa1q9CQa/xthLrsVdWqx17TuVw05u/sjZ5MwBt/Hvww7SrGNLBcxfDs2sf0h5vnTd5pXm1LnNrZy/DLimBDaMmqYGNbQFh0XS1CWqDBg3ZJdlkFWe5uzkOUinQs9nXuqp1cOXhKWdNSU1SA+0pgcFewR6/tpzbg6sFCxYQFxeHt7c3ffr0YePGjVXuv379evr06YO3tzdt2rThnXfeKbfP/Pnz6dixIz4+PkRHRzNt2jSKi4vr6y2IRuCN7W8AcFPbm2gTdPGh5xb+Lbi1/a3AnyNeZhOsfxnevwYy9oNfONyxDEa/Bd4Xv7tvtlh546fDjHn7Vw6eycPofwyAJ4feQJBP1XOzPIVBa6BL8y5A3de7spdhjw6QSoENpboLCje2BYRF0+Wt93akDXtSaqAEV57NftMuJS+lRiOekhbY8K5ufTV6jZ7D5w47/q4q01jWuAI3B1fLly9n6tSpPPvss+zYsYPBgwczcuTIcrnsdsePH+f6669n8ODB7Nixg2eeeYZHHnmEFStWOPb55JNPmDFjBrNmzWL//v0sWrSI5cuX8/TTTzfU2xIeZkvqFn5L+w2D1sCDPatXkQbg/u73Y9Qa2Z6+nS1LhsHaF8Fqhs43weQt0HFktY5zJD2PWxdu4tWEQ5itimFdDGDIQqfR0Tu8d23flls4UgPrGlz9OXJlT98Q9a+6qYGNbQFh0bTZUwM9aTFhCa48W8uAlug0OorMRaQXplfrObLGlXsEeQXRr0U/ABKSE6rct7FUCgQ3B1evvvoq9913H/fffz+dO3dm/vz5REdHs3Dhwgr3f+edd2jdujXz58+nc+fO3H///UycOJFXXnnFsc/mzZsZNGgQ48aNIzY2lvj4eO644w62bt3aUG9LeBCllGPU6raOt9XoohnpE85fAzsB8LYlHeUVBLe8B7d9BH7NL/p8q1Xx/sZjXP/GL+w6mUOgt575Yy9jzMAiALo074K/0b8W78p97MFVYmbdilo41riSkasGU93UwMayjoi4NDiCKw8ZuVJKSRl2D2fQGmgV0AqofmqgfY0rrUZLhJ/cWGpIjtTApKpTAx3Blb8EV5UqLS1l27ZtxMfHO22Pj49n06ZNFT5n8+bN5fYfPnw4W7duxWQyAXDllVeybds2fv/dVub62LFjrFy5klGjRlXalpKSEnJzc52+RNPw84mfScxMxEfvw/3d76/+E7NPwH9Hc9/ulXhZrezy9uLXW9+EHrdBNeahJGUWcPt7W3jh+/2Umq0M6RDGmmlDGNOrpWMO1+WRl9f2bbmNfTHhQ+cOUWgqrPVxHGtcSaXABlWd1EAJroQnsVcMPJx92M0tsckoyqDAVIBOo5ObQx7MnhqYlJtUrf3tKYERvhEYtI0jVb+puDr6anQaHQfPHawyGJa0wGrIzMzEYrGUW/E+IiKCtLS0Cp+TlpZW4f5ms5nMzEwAbr/9dubMmcOVV16JwWCgbdu2DBs2jBkzZlTalpdeeomgoCDHV3S0XDCbAovVwpvb3wTgrs53Va9krlKwcyksHAjHNxCm9WZsaB8A3jr06UXzt80WK++sP8rw+Rv4/fhZfI065t7cnSX3Xk5kkDdwfvHgKyKvqMO7c49Iv0jCfcOxKAv7svZd/AkVKDYXO+b1SEGLhlWd1MDGtoCwaNoca12dO+IRFQPtKYGtAlpVuaSBcC97yrk9Bf1ipFKg+wR7B9MvypYaWNXolaQF1sCF1aiUUlVWqKpo/7Lb161bx4svvsiCBQvYvn07X3zxBd999x1z5syp9JhPP/00OTk5jq8TJ07U9u0ID7Ly+EqO5hwl0BjIhG4TLv6E/AxYdqdt7aqSXGh1BUz6hYnXvoaP3oe9WXtZf3J9pU/fezqHMQt+Zd6qA5SYrVzZLpQfpl7FuH6tHb+fJ/NOcrrgNHqNvvL1szxcj9C6pQbaF98MMAYQ7BXsqmaJaqhOaqB9AWFPL3UrLg2tA1uj1+opNBc6Ply5k2O+VaCkBHqy2MBYoPppgVLMwr3sqYFVzbuS4KoaQkND0el05Uap0tPTy41O2UVGRla4v16vp3lz2xyYv//974wfP57777+f7t27c/PNNzN37lxeeuklrNaK1+bx8vIiMDDQ6Us0biaLibd32taomtht4sXX69n/LSzoDwe/B60BrpkFE1dD87Y092nOHZ3uAODtnW+Xu3tabLLwz9UHuOmtX9lzKpdAbz0v/6UH/73vCqKbOZcLtY9adQvt5vGlRCtT16IW9kqBrQNaS6lvN6gqNbDQVEhuqS0tWuYdCE9g0Bocc5s8Yd6VFLNoHOwp59VNC5SRK/e6urUtNXD/2f2cyC0/wGGymsgoygBkzlWVjEYjffr0ISHBOUpNSEhg4MCBFT5nwIAB5fZfs2YNffv2xWCw5cgWFhai1Tq/LZ1O51jUUVwaVhxewan8U4T6hDoCowrlpsKK+2H5XVCYCeFd4f/WwuDpoNU5dpvQdQK+el8OnD3Azyk/O7b/diyLka9vZOG6o1isiuu7R/LjY0O4rW90hYHD72m2uYCNcb6VXdnFhGvDXsxCUgLdo6rUQHtKoJ/BjwBjgDuaJ0Q5ZRcTdjcJrhoH+8jVyfyTmK3mi+5/ukDWuHKnEO8Qx+eiH5LLZ1WkF6ZjVVaMWiPNvJs1dPNqzK1pgdOnT+f9999n8eLF7N+/n2nTppGSksKkSZMAW7re3Xff7dh/0qRJJCcnM336dPbv38/ixYtZtGgRjz/+uGOfG2+8kYULF7Js2TKOHz9OQkICf//737npppvQ6XTl2iCaniJzEf/Z/R/AthhwhSNEpmLY+G94sw8k/g80Whg01RZYRXYvt3uIdwh3dbkLgLd2vkV2UQnPfJnI2He3cDyzgPAAL/4zvg8L7uxDeIB3he1SSjmCqyuiGt98K7suzbug0+hIL0x3FD+oCXuaRnSgzG10h6pSAx3FLCQlUHgQx7wrTxi5kkqBjUKEXwReOi/MVrOjEEJVZOTK/exZFRXNu7L/DCP9ItFq3D6j6aL07nzxsWPHkpWVxezZs0lNTaVbt26sXLmSmBjbRMTU1FSnNa/i4uJYuXIl06ZN4+2336ZFixa88cYb3HrrrY59Zs6ciUajYebMmZw6dYqwsDBuvPFGXnzxxQZ/f8I9lu5fSmZRJi39W/KX9n9xflApOLgKfngaziXZtrW6HEb+E1r2qfK4d3e5m6X7l3Ik+wjXvvMmmWc6A3DHFa2ZMbLTRRcDTslLIb0wHYPWwGVhl9Xy3bmfj96HDiEd2H92P7szdte48EHZtEDhHvGx8Sw9sNSRGmifmO+YbyXFLIQH8ZRy7IWmQscNCPvIiPBMWo2W6IBojmQfISk3qcqbeUopCa48wDWtr+GFLS/YUgPzTjhV42xMZdjBzcEVwOTJk5k8eXKFjy1ZsqTctiFDhrB9+/ZKj6fX65k1axazZs1yVRNFI5JbmsviPYsBmHzZZAy6MgFPxkFYPQOO/pnW5x8J182G7n8F7cXvhJSWetPcci35fEWh3ypimvdi3i2XMaDtxde8gvMpgT3CeuCtr3h0q7HoEdaD/Wf3k5iZ6LjbVF32fGpZQNh97KmBGUUZbEndwlWtrgKkUqDwTPZy7Meyj2G2mtFr3fPRxT7q3sy7GcHewW5pg6i+2MBYjmQfITk3mcEMrnS/smtcyai9+zTzbsblEZfzW9pvJCQnMLHbRMdjjamYBXhAtUAhXOnDvR+SW5pL26C2jIr7c22zomxYNQMWDLAFVjojXDkdHt4GPcdeNLBSSvH5tpNc++p69uy/DGXxQeeVzrQxhdUOrAD+SG28JdgvZF/vqqZFLUotpY6LpKwR4z6VpQbaR64ifKWYhfAcLf1b4qP3odRa6piz6Q72+VYyatU42G/gXaxioH3UKtw33PmGrGhwlaUGSnAlhJtkFmXy333/BeDhXg+jA9j6AbzZG35bCMoCHUfBQ7/BtbPAy/+ixzxxtpC7F//O4//bRU6RiS4R4dzeYTwA7+/5T7UmyoLzfKvGXMzCzl7UYm/WXkxWU7WfdzLvJAqFn8GvUUxKbcoqqhooCwgLT6TVaGkb1BZwb2qgzLdqXGoaXEkxC/e7uvXVaDVa9mbtdSzbAhJcCeE2ixIXUWQuolvzblytfODdofDdVCjMgtCOMP5LuGMpNGtz0WNZrIpFvxwn/rUNbDyciZdey1MjOvH1lEFM6zeRYK9gknOT+f7Y99Vq2/Gc42QVZ+Gl86JnWM+6vVEPEBMYQ4AxgBJLSY0qeEkZds9RUdVAe3AlZdiFp7GnBh4558bgSioFNirVDa5kjSvPEeoTSp8I2/z3H5N/dGy3F7RoLHOuJLgSTcLp/NMsP7gcgEcKStEsGQlpu8ErCEbMgwd/hbZXV+tYB9PyuHXhJuZ8t48ik4V+cc1YPfUqHhzaFoNOi5/Bj3u73QvAO7veqdbIjX3U6rLwyxzFAxozrUbrWEy4JqmBKbl/BleBUszC3SpKDTxTKAUthGdylGPPdl85dgmuGhd7cJVakEqJpaTS/aSYhWexLyi8JtmWGqiUkpErIdzhnR1vYbKauKK4lP77fwQ00GcCPLId+j8I1cijLjFbeDXhEDe8uZGdJ7IJ8NIz9+bufPpAf+JC/Zz2vb3j7TTzbsbJ/JN8c+Sbix7bUYK9Ccy3srOnBiZmJlb7OVIp0LOUTQ08V3yOfFM+IKXYhedxdzl2i9XiGAGR4KpxaObdjABDAApV4cK0dqcKZOTKk1wbcy0aNCRmJnI6/zS5pbkUmYuAxnPjT4Ir0bgpxbFt7/P10W8BeOTsWTStB8Df1sONr4NfaLUOsy35HKPe+IU3fjqMyaK4rksECdOHMK5fa7Ta8ulrvgZf7ut2HwD/2f0fTJbKR6+sysrWtK1A0wqualPUwj5yJcUsPEPZ1MAvj3wJQIAxoOK14YRwI3taYEpuSpWjEPXFPvph1Bplbk4jodFoHFkSVaUGysiVZymbGpiQnOD4+TT3bo6XzsudTas2Ca5E43VmL3x4I29vmYtVA0NLFT1vWAj3roKo6s1ryswvYeZXifzlnU0cSc8n1N/I2+N68+74PkQGVV0u/baOtxHmE0ZqQarjg2lFDp87zLmSc/jofega2rVGb9GT2YOrpNwkckpyqvUcx8iVpAV6hLKpgZ/s/wRoPHcGxaUlzCeMQGMgFmUhKSepwV/fnhLYOrA1Oq2uwV9f1I5j3lVexcGVrHHlmez90prkNY0uJRAkuBKNUeFZ+P5xeOdK9p3ewhp/PzTAw6M/ge5/gWoUSigoMfP6j4cZ8vJaPt6SglLwlz6t+HH6EEb1iKpWsQVvvTf3d78fgHd3v1vp3dQ/0mwl2HuH98agbTplXoO9gx0dV3VSA00Wk+MiKWtceQ57amB6YTogKYHCM2k0GrfOu5L5Vo2TvWx+ZSNXssaVZ7ou5jo0aNidsZud6TuBxlPMAiS4Eo2JuRR+f89WWv2P90BZeSO6AwDXtxlFh/CLj1aZLFY+3pLMkH+t47UfD1FQaqFHqyA+faA/r/y1J8G+NSs2cWuHW4nwjeBM4Rk+P/R5hfs0pRLsF6pJUYtT+aewKis+eh+ae1d/fTBRv+ypgXYyciU8VfuQP+dduaFioJRhb5zsWRKVjXbKGleeKcw3jF7hvQAcn61k5EoIVyo8Cxtegdd7wMrHoegchHdh6+hX+dWah16j56GeD1V5CKUUq/ekMfy1Dcz8ag+Z+SXENPflrXG9+PqhQTVaDLgsL50X/9fj/wB4P/F9is3FTo9brBa2nml6863s7EUtqhNcSRl2z1Q2NRBkAWHhuewjV+4oaiEjV43TxUauZI0rz2XPqsgz5QESXIl6kF+az5SfpjB/23x3N6XhpB+Abx+FVzvDz3MgLxX8I+D6V1D/t4E30tYDcEv7W4gOrLxAwtaks/zlnc1M+ngbxzILaOZn5Pkbu5AwbQg39GhR5w/6N7e7mRZ+LcgsyuSzg585PXbw3EHySvPwM/jRuXnnOr2OJ+oeZpt3lZiZiFVZq9xXyrB7LnsnBjJyJTyXBFeipuz9TVZxFvml+eUeP11gC66kUqDnubb1tU7fS3AlXO61ba+x/uR6Fu1ZxHfHvnN3c+qP1QqHf4T/3gwL+sG2JWAuhsgecPN/YOoeuOIBNqZtZkf6DqeRowsdSc/jgY+28pd3NrMt+Rw+Bh0PX92O9U8MZcKgOIx61/z6G3QG/tbzbwAs2rOIQlOh4zH7fKs+EX3Qa/UueT1P0iGkA146L3JLcy+6UKN95EoqBXqeXuG9CPcNB2Q+nPBc9uDqVP4pCkwFDfa6OSU5nC0+C0BcoARXjUmAMcCRhl5RUQv7yFVjms9zqYjwi3CkBkLj+hlJcNUIbE3bymeHzo+IvLjlRceK4k1GaSH8scgWUH1yKxz9GdBApxts1f/+tgF63g56I1Zl5c0dbwIwrtM4Ivyc05jO5Bbz9Be7iX9tAwn7zqDTarjjitasf2Ioj8V3JMDb9XnVN7a9kVb+rThbfJZlB5c5tjfF9a3KMmgNdG1uq4B4saIW9uBKPrx7Hq1GyxvD3uC5Ac/RM6x6lTaFaGjB3sGO+YFHs4822OvaR60ifCNkmYJGyFExMKd8cGX/LCUjV57JvqAwyMiVcKFiczHPb34esKWf9QzrSb4pn2c2PoPFanFv41wh5xT8+Lwt9e/76ZB5CIwB0P8heGQH3P4JxAx0qgC4JmkNB84ewM/gx8RuEx3b84pN/HvNQYb+ax2f/n4Cq4L4LhH8MPUqXrqlO+GBVZdWrwuD1sCknpMA+GDPBxSYCjBbzWw7sw1omsUs7Kq73pV9EUcZufJMXUO78tcOf5X5cMKjuSM1UFICG7eqyrFLGXbPdl3MdfjofYjyiyLYK9jdzam2ppen1MS8s+sdknOTCfMJ4/HLHyenJIe/fPMXtqdvZ9GeRZWmxHm8k9tgywLY9xVYzbZtIbHQbxJcdid4B1b4NLPVzFs73wLgnq73EOwdTKnZytLfknnj5yOcLSgFoHfrYJ65vjN9Y5s1wJuxGdVmFO8nvk9SbhJL9y+lf1R/CkwFBBgD6BjSscHa0dCqU9TCZDU57hC2DpA5V0KI2mkX0o7NqZs5fK7hyrFLpcDGzRFcXZC6XnaNq5Z+MnLliSL8Ilh2wzK8dd6N6safBFcebH/WfpbsXQLAs/2fJdAYSKAxkGf6PcPMX2eycOdCBrYYSLfQbu5taHVZzLD/G9iyEE7+fn57zJXQ/0HoOBIusjjj10e+Jjk3mRCvEMZ3Hs+3u07zypqDJGfZ5jm1CfPjyeGdGN41osH/EPVaPZN6TmLGxhks2buEInMRAH0j+jbpRSftwdWhc4coMhfho/cpt09qfioWZcFb502Yb1i5x4UQojraB/9Zjl1GrkQ1VZYWeLb4LMWWYjRopJCPB2sT1MbdTagxCa48lNlqZtamWViUhfiYeK5pfY3jsZva3sSGkxtYk7yGGRtn8NkNn3l2HnjROdj+Efz2LuSetG3TGqD7X6H/JIiq3hyPEksJC3ctBODaFncw7t2d7D6ZA0BYgBdTr23P2L7R6HXuy3YdETuCd3e/y7GcYyzesxhouvOt7CJ8Iwj3CSe9KJ19WfvoE9Gn3D6OYhaB0Wg1ko0shKgdd6QF2tdIkuCqcSqbFqiUctx4lTWuRH2RTzke6qN9H7H/7H4CjYE83e9pp8c0Gg3PDXiOcN9wknOTefmPl93UyovIPALfPw6vdoWE52yBlW8oDHkKpu2FmxdWO7AC+OboN5wpPINBhbB4VRS7T+bgZ9Qx/boOrHt8KHf2i3FrYAWg0+p48LIHAbAo25y4pjzfCmy/jxdLDXSUYZeUQNFILFiwgLi4OLy9venTpw8bN26sdN/U1FTGjRtHx44d0Wq1TJ06tcL9srOzeeihh4iKisLb25vOnTuzcuXKenoHTVPb4LYAZBZlcq74XL2/nslq4mSe7aagVApsnKIDotGgIa80j3Ml539nThVIMQtRPyS48kDJucks2LkAgCcuf4JQn9By+wR5BTH3yrlo0LDi8Ap+SvmpoZtZsZxT8Mf78NEYeKsP/PEemAogvCvc9JYtqBr2DARUf6FSi1Xx84EzvLHpWwDyM65ArzFy94AY1j85jEeuaY+fl+cMwsbHxNM+xJa6EuwV7Ph/U1Z2vauKlF1AWAhPt3z5cqZOncqzzz7Ljh07GDx4MCNHjiQlJaXC/UtKSggLC+PZZ5+lZ8+KbxiVlpZy3XXXkZSUxOeff87Bgwd57733aNlSPtjVhK/B1/FhuCFGr07kncCszPjqfR3LFYjGxVvv7Uj7KzvvSopZiPriOZ9IBQBWZeX5Tc9TYilhQNQARrcdXem+/aL6cU/Xe1iydwnPb3qeHqE9Gn4+i1JwZg8cWAkHv4fUXWUe1ECHEbb5VHFXOVX8q470vGI+++MEn/5+glPZBfh32I9GZ3vfs+8dQlyon2vfi4toNVqm9Z7Gwz8/zPDY4ZdEGlyPUNvI1a6MXRU+bh+5qmqxZyE8xauvvsp9993H/fffD8D8+fP54YcfWLhwIS+99FK5/WNjY3n99dcBWLx4cYXHXLx4MWfPnmXTpk0YDLYUpJgYWZagNtoHt+dU/imOZB+p98yAsvOtGtOEeuEsJjCG1IJUknOTHWsnSXAl6osEVx5mxeEVbD2zFR+9D88NeO6iF/OHez3MltQtHDh7wFbk4tqF9f9h3mKCpF/g4CrbV07Zu7kaiL7CVpyi803QvG2NDq2UYvPRLD75LYUf9qZhtioAgoIzsOqK8dH78sEdN3v8gryDWw3mx7/+SJBXkLub0iC6NO+CTqMjvTCdtIK0cpODT+TZyrDHBMiHSeHZSktL2bZtGzNmzHDaHh8fz6ZNm2p93G+++YYBAwbw0EMP8fXXXxMWFsa4ceN46qmn0OkqLnhTUlJCSUmJ4/vc3Nxav35T0i6kHetOruPIufofuZJiFk1DTGAMW1K3OI1cyRpXor549ifUS8yZgjO8uvVVwBY0tQpoddHnGHVG5g2ex9jvxrLp9CaW7l/KXV3ucn3jirLhyI9wcCUc/hFKcs4/pveBtsOg4/XQYTj41zx1IruwlM+3nWTpbykcyyxwbO8TE8Kd/VpzTv8j83fA5ZF9PT6wsqsonbOp8jX40j6kPQfOHiAxM9EpuDJbzZzMt81ZaB0oaYHCs2VmZmKxWIiIcE5djoiIIC0trdbHPXbsGD///DN33nknK1eu5PDhwzz00EOYzWaee+65Cp/z0ksv8Y9//KPWr9lUNWRRCwmumoaKyrHLyJWoL43jU+olQCnFi7+9SL4pnx6hPRjXaVy1n9s2uC2P9X2Mub/N5bVtr3FF1BV0COlQ90Zlp/w5OrXSNlJlX48KwC/MlvLX8XpoMxSMNa9WqJRix4lsPtmSwne7T1NittoObdRxc++WjLsihi4tbOtdTflpK9D0K+81Zj1Ce3Dg7AF2Z+zmupjrHNtTC1IxW80YtUaZsyAajQuzBspWGasNq9VKeHg47777Ljqdjj59+nD69Gn+9a9/VRpcPf3000yfPt3xfW5uLtHRklprD64OZx+u88/lYqRSYNNgD66ScpMAWeNK1C8JrjzEmuQ1rD2xFr1Wz/MDn6/xuki3d7ydjSc3svHURmZsnMGnoz7FS+dVs0YoBak7bQHVgZVw5oLiBKEdbel+nUZByz4XXZOqMvklZr7eeYqPt6SwP/V8mkuXqEDu6h/DTZe1wL9MgQqz1cy2M9uApl95rzHrHtadzw59Vq5i4IlcW0pgdICUYReeLzQ0FJ1OV26UKj09vdxoVk1ERUVhMBicUgA7d+5MWloapaWlGI3Gcs/x8vLCy6uG1/FLQFxQHDqNjrzSPNIL04nwq/3PpSpKqfMjV1IpsFGLDYwFbP2RVVk5V3xO1rgS9UaCKw+QXZzN3N/mAnB/9/trVV1Oo9Ewe9Bsbv3mVg6fO8zr21/nycufvPgTSwsgZfP5+VO5p8ocVAvR/aHT9bYRqhrOn7rQvtO5fPJbMl/tOEVBqa1MuZdey409W3Bnv9ZcFh1c4R3IA2cPkG/KJ8AYQMeQjnVqg6g/9nLs+7L2YbKaMGhtk/YdlQIlJVA0AkajkT59+pCQkMDNN9/s2J6QkMDo0ZUXGLqYQYMGsXTpUqxWK1qt7SbDoUOHiIqKqjCwEpUz6ozEBMZwLOcYR7KP1FtwlVWcRZ4pD61GK9evRq6Ffwv0Gj3FlmLSC9PJLMoEIMw3TNa4Ei4nwZUH+NfWf3G2+CxtgtrwQPcHan2cUJ9QZg+czZSfp/Dfff/lypZXMrDFwPM7WK2QdQRO/gGnttr+PbMP/lyPCQCDH7S7GjqOgvbx4Ne8Du8Mik0Wvt+dyie/JbM9JduxvU2YH3f2i+HW3i0J9q36g8Xvab8D0CeiT41H9ETDiQ2MJcAYQF5pHofPHaZL8y6AlGEXjc/06dMZP348ffv2ZcCAAbz77rukpKQwadIkwJaud+rUKT766CPHc3bu3AlAfn4+GRkZ7Ny5E6PRSJcutr+DBx98kDfffJNHH32Uhx9+mMOHDzN37lweeeSRBn9/TUG74HaO4GpQy0H18hr2UauW/i0x6iQAbsz0Wj2tAlqRlJtEUm4SOX/OG5diFqI+SHDlZptObeKbo9+gQcM/Bv6jzhfwIdFDGNtxLMsPLmfmxmdY0X0qIWf2nw+oinPKPymwJbS/zhZQxV0FBu86tUEpxcEzeXy+9SSfbz9JdqEJAL1Ww/BukdzZrzUD2jSvdp68PbiS+VaeTavR0j20O5tObyIxI9ERXNnTAuXOr2gsxo4dS1ZWFrNnzyY1NZVu3bqxcuVKR+n01NTUcmte9erVy/H/bdu2sXTpUmJiYkhKSgIgOjqaNWvWMG3aNHr06EHLli159NFHeeqppxrsfTUl7ULasSZ5DYfPHa6315BiFk1LTGAMSblJpOSmUGCyFc6SYhaiPkhw5UaFpkJmb5kNwLjO47gs/LLaH8xihvS9cPIPHjudzO8WOF6cxT/WPcZr6Zk4whi9D7ToBa36QqvLbf8G1v3ikp5XzK9HMtl4OJNfj2RyJvd8+eCWwT6M69eav/ZtRXhAzQI3k9XE9jPbAQmuGoMeYT3YdHoTuzN3M5axACTn2aozRQfIRHzReEyePJnJkydX+NiSJUvKbVNKXfSYAwYMYMuWLXVtmsC21hXUb8VAmW/VtJQtalFqKQWghZ8EV8L1JLhyozd3vMmp/FO08GvBI71qmBqSm2objTr5B5zcaitEYSoEwAeYZzRwZ4tIfvLz5ctOw7ilzShbMBXRFVyQX1xUauG341n8cjiTX45kciAtz+lxL72Wwe1DGdevNUM6hKPT1q6a076sfRSZiwj2Cq7VXDTRsLqHdgdwFLWwWC2czJMy7EII17JXDDyafRSrstZLsRwZuWpaypZjt98MkbRAUR8kuHKTXRm7+GT/JwA8N+A5fA2VlDK3WuBcEmQegoyDcHqHLZjKPVl+X68gaNUHWl1Ol1aXMyXvIPMT/8M8y2n6dIp3XFhqw2JV7DmVwy9HMvnlcCbbks9RarE67dO1RSBXtg9lcLsw+saG4G2o+/yoP9L+AKBvRF+pNNcI9Ai1FbWw57QXmAocxS0ifaUikxDCNaIDojFqjRRbijmVd4roQNePjEtw1bTYPwOl5Kag09g+n0haoKgPEly5gcli4vlNz6NQ3NjmRttk3NJCyDoMmYdtQVTmIdtX1hH4c/jaiUYL4V0dwRStLofm7UF7PgCZYL2aX9K3sfXMVp7e+DQfjvzQUcGtOk6cLWTj4Ux+OZLBpqNZjrlTdi2DfbiyXShXtg9lYNvmNPd3fcng31Nt8636RvZ1+bGF6wV7BxMTGENybjKJmYmOBZ9bBbSSYiRCCJfRaXW0DW7L/rP7OZx92OXBVZG5iNMFtnWQJLhqGuzB1cm8k46+SUauRH2Q4KqhFWTx/tZXOJJ9hGYaI08m7YNt3SH7BFBJzr7OC0LbQ2gHiOwGra6wzZvy8q/ypXRaHXOvnMut39xKYmYi/9n1H6b0mlLp/jmFJjYdtaX5/XIkk+SsQqfHA7z09G/bnMHtQ7myXShxoX71unijyWJiZ8ZOQOZbNSbdQ7vbgquMRJr72KpNSqVAIYSrtQtux/6z+zmSfYSrW1/t0mMn59rmigZ7BRPiHeLSYwv3CPcNx1vnTbGlGLPFLGtciXojwVV9sFohJ6XMKNRBx/+PmPN4t2UkaDQ8feY0wQVlJuP6hNgW6g3rYAukQjvagqrg1rVesDfKP4rnBjzHExue4L3E9xjUchC9wnuRU2QiJauQpKwCDqblsfFIJokns7GWie/0Wg29WgdzZbswrmwfSs9WQeh1DZeal5iZSJG5iGbezRz59cLz9QjrwXfHvmNX5i7aBdl+blLMQgjhau1CbNeXI+dcX9RCUgKbHvt6ZYfOHQJsa1xJiX1RHyS4qg//uQrOJJbbbAFmRUVg1mgYih/Du42CsI62QCqsI/g2BxeNBCmlyMgvITmrkPyz3WjrcxVHizYw8ftpqJPTyC6o+EffNsyPwe3DuLJdKP3bNsffy32/IvYS7H0j+tbrCJlwLftiwokZiY401LrM9xNCiIrYb7odznZ9OXYJrpqmmMAYR3AlKYGivkhwVR9CYmyjVc3a/jkKZQugPi08xu6DH+Nn8OPZ0V+hqeNwtMWqOJ1dRHJWIclnC2z/Ztn+TTlbSGFpmcWBtVfjF5eI2ZiFKXAFFIwl1N+L2Oa+xIb60S+uGVe2DyUqyKeOb9517MUsJCWwcekQ0gEvnRe5pbmOn6GkBQohXM1ejj0pJwmTxYTBBZVw7aQMe9MUGxjr+L8UsxD1RYKrevBu8HQOtJsKWgMaNGizoDgzk41F/wSgrW4sC37MRKvJQqMBrUaD9s9/NWX+r9Xw5/f2/0NGXgnJZwtJzirk5LlCTJbK11bRaqBFsA8xzX1p3cwPL78n+SLtWQzBO5h3/VjGtL+2gc5IzZVYStiVsQuAy6Mud3NrRE0YtAa6NO/CjvQdjoUa66OSlxDi0hbpF4mfwY8CUwHJucmONEFXkJGrpqnskiCyxpWoLxJc1YMfk0v5/fjZMlsUPtGL0fuXYC6I49f97fiVZJe8llGnJbqZDzHN/Yhp7ktMM1/H/1uF+GLUl50j1Z3mO47z7u53eXnri/Rv0cdjJ3PuzthNiaWEUJ9QuXPYCHUP7c6O9B0A6DV6ovyi3NwiIURTo9FoaBfcjl0ZuziSfcRlwZVVWR0FLSS4alrKjlxJWqCoLxJc1YN7BsQS3yUCpcCqFPvy1vJz1mF0GPhrm8cI7BCFVdnmRVmVwvrnfkqB1Vr2+/P/t+8f7Gu0BVHNbUFUZKB3jRbondRzEptPbyYxM5FnfnmG9657zyNLZNvTyS6PuFzmWzVC9nlXYCvDbi97K4QQrmQPrg5nH2YEI1xyzLSCNIotxRi0Bkkda2LKzv+Vn62oL/KJpx6M6nH+Ln1mUSb//XoJAFN6T+b+7kPc1Cobg9bAvMHz+Mu3f+GPtD/4cN+HTOw20a1tqoi9mIWkBDZOPcN6Ov4vlQKFEPWlfYht3pUrKwbaUwJjAmPkxlATE+wVTLhvOBmFGTIqKepNw9XVvkTN+30eOSU5dGrWiXu63uPu5gC2nOMZV8wA4M0db7Iva5+bW+Ss2FzM7ozdgBSzaKwifCMI8wkDnHPchRDClewVA49kuz64kg/fTY9Go2HBNQt459p3PHZahGj8JLiqR2tT1vJD0g/oNDr+MfAfjrLUnuDmdjdzTetrMFvNPLXhKYrMRe5uksPOjJ2YrCbCfcOlylwjpdFo6BvRF7BVDxRCiPpgD65O5J1wWT9mD67Kzs8RTUfHZh0Z2HKgu5shmjAZ764neaV5vLDlBQDu6XoPXZp3KbePxWLBZDI1dNMcnun9DKnZqZwrPscX+77g1g63uq0tZe1J3UOUMYqhUUMpKSlxd3NELU3rOY3BEYMZ1nIYxcXF7m6O8CAGgwGdzvPmejYV7u5bGpKfxo9OAZ3IKcnhSMYRR5pgXZwrOEeUMYr2/u3l2iVEI+IpfYtGKVV5Le9LVG5uLkFBQeTk5BAYGFirY8zePJv/HfofMYExfH7j53jrvR2PKaVIS0sjOzvbRS2uvUJTIdkl2Ri0BsJ8w9zdHMA2T63UUkqwVzC+Bl93N0cIUQ+Cg4OJjIyssGCNK67BTdHFzosn9S0NKasoixJLicv6jDMFZ7AoC6E+oRh1Rhe0UAjRUKrqW+qiJv2SjFzVgz/S/uB/h/4HwKwBs5wCK8DR+YWHh+Pr6+vWanhmq5mknCQUihYBLfDSe7mtLQAWqwVLjgWFIiYwRjo2IZoYpRSFhYWkp6cDEBUlZfpdxZP6lobkV+BHTmkOwV7Bdb5JaLFaMOeYAWgT1MYjq+kKIcrzpL5FgisXK7WU8o/N/wDgLx3+wuWRztXuLBaLo/Nr3ry5O5pYTqA5kLzSPIo1xQR5B7m1Lfml+WgMGoxaIwG+AZfMhwMhLiU+Pj4ApKenEx4e7hFpHI2dJ/YtDcUff/JUHla9FW9v74s/oQqFpkK0Bi16rR4/Xz8XtVAI0RA8pW+RghYuZtAaeLjXw3Ru1pnpfaaXe9yeB+/r6znpbkFetoAqpzQHd2eJFpgKAPAz+ElgJUQTZr8GXipzg+qbJ/YtDcVbZwuois11nx9VaikFwEvn3iwOIUTteELfIiNXLqbRaBgeO5z4mPgqgwNPChwCjAFoNVpMFhNF5iK3znMqG1wJIZouT7oGNiWX4nm1B0JmqxmL1VKnVL4Si62IkqSkC9E4ecI1UEau6okn/HCrS6vREmi0Tc7LKclxWzssVoujlK4UshBCCFEdOq3OsdSJPTiqLfvzZeRKCFFbElwJwDNSA3/46Qe6hXWjKL+o2ncNY2NjmT9/fv02TFRp3bp1aDSaJlGh7Pnnn+eyyy6r0XOGDh3K1KlTXd6WJUuWEBwc7PLjCtEU2YsxFVvKpwbW5BplD656d+4tfYubSd8ifUtj5fbgasGCBcTFxeHt7U2fPn3YuHFjlfuvX7+ePn364O3tTZs2bXjnnXfK7ZOdnc1DDz1EVFQU3t7edO7cmZUrV9bXW2gS/Ax+6LQ6LFaLIzWvrAkTJqDRaJg0aVK5xyZPnoxGo2HChAl1aoM9X95X77pRqwkTJjBmzBiXHQ9qd5Gsb+fOnWP8+PEEBQURFBTE+PHja90hFRUVERISQrNmzSgqqv/Fpffu3cutt95KbGwsGo2m0g80Nb1WiPKUUjz//PO0aNECHx8fhg4dyt69ey/6vBUrVtClSxe8vLzo0qULX375pdPjzz//PBqNxukrMjKyvt6GaEJc1bfYR5pKzLUfubIqKyaLbZ6GhqqzT6RvqTnpW5ou6VucuTW4Wr58OVOnTuXZZ59lx44dDB48mJEjR5KSklLh/sePH+f6669n8ODB7Nixg2eeeYZHHnmEFStWOPYpLS3luuuuIykpic8//5yDBw/y3nvv0bJly4Z6W42SRqMhyPjn6FUlqYHR0dEsW7bM6aJYXFzMp59+SuvWrevchiKL7bh++kt3vlVpaWmtnjdu3Dh27tzJ6tWrWb16NTt37mT8+PG1OtaKFSvo1q0bXbp04YsvvqjVMWqisLCQNm3aMG/evEovmjW9VoiKvfzyy7z66qu89dZb/PHHH0RGRnLdddeRl5dX6XM2b97M2LFjGT9+PLt27WL8+PHcdttt/Pbbb077de3aldTUVMdXYmJifb8d0US4om+xF7WoS1qgyWJCodBq3H7f2eWkb5G+pT5J33IB5UZXXHGFmjRpktO2Tp06qRkzZlS4/5NPPqk6derktO1vf/ub6t+/v+P7hQsXqjZt2qjS0tJatysnJ0cBKicnp9bHqExRUZHat2+fKioqUkopZbVaVUGJyS1fVqvVqW0FpQVqT8YetS9zn7JYLU6P3XPPPWr06NGqe/fu6uOPP3Zs/+STT1T37t3V6NGj1T333OPYXlxcrB5++GEVFhamvLy81KBBg9Tvv//udMzvv/9etW/fXnl7e6shQ4eoF954QQEqPTPdsc+vv/6qBg8erLy9vVWrVq3Uww8/rPLz8x2Px8TEqNdee63Ccz1r1iwFOH2tXbtWKaXUyZMn1W233aaCg4NVs2bN1E033aSOHz/ueO7atWvV5Zdfrnx9fVVQUJAaOHCgSkpKUh988EG5Y37wwQcX+7FXyn5e586dq6KiolRMTEyNj7Fv3z4FqC1btji2bd68WQHqwIEDNT7e0KFD1TvvvKMWLlyohg0bVu7xsj+3oUOHOs7JuXPnavxaF6rs51nTa0VlnnzySdW+fXvl4+Oj4uLi1MyZM52uFbNmzVI9e/Z0fG//+Tz//PMqLCxMBQQEqP/7v/9TJSUljn2GDBmiHn74YfXEE0+okJAQFRERoWbNmuX0uv/+979Vt27dlK+vr2rVqpV68MEHVV5entM+H3zwgYqOjlY+Pj5qzJgx6pVXXlFBQUE1en9VsVqtKjIyUs2bN8+xrbi4WAUFBal33nmn0ufddtttasSIEU7bhg8frm6//XbH9xeet+q48FpYVn1egxuzqs5LRefTXf3LhX1LVVzVtxSaCtWejD1qf9Z+9d133130GlVR33I667Tak7FHHTl3RPoWJX1LTUjf0jj6lrqoSb/ktmqBpaWlbNu2jRkzZjhtj4+PZ9OmTRU+Z/PmzcTHxzttGz58OIsWLcJkMmEwGPjmm28YMGAADz30EF9//TVhYWGMGzeOp556qtJ69yUlJZSUnL/blZubW8d3V31FJgtdnvuhwV6vrH2zh+NrPP8r4KP3waAzYLKYyCvNc8zDKuvee+/lgw8+4M477wRg8eLFTJw4kXXr1jnt9+STT7JixQo+/PBDYmJiePnllxk+fDhHjhyhWbNmnDhxgltuuYVJkybx4IMPsnHLRmY8YftdMOhsE5MTExMZPnw4c+bMYdGiRWRkZDBlyhSmTJnCBx98cNH39/jjj7N//35yc3Md+zdr1ozCwkKGDRvG4MGD2bBhA3q9nhdeeIERI0awe/dutFotY8aM4YEHHuDTTz+ltLSU33//HY1Gw9ixY9mzZw+rV6/mxx9/BCAoqOK1wdatW8ewYcM4fvw4sbGxlbbzp59+IjAwkISEBMd8t0mTJvHxxx9X+f727dtH69at2bx5M0FBQfTr18/xWP/+/QkKCmLTpk107NjxoufK7ujRo2zevJkvvvgCpRRTp07l2LFjtGnTBqDcz23r1q089thjTsdISUmhS5cuVb7OXXfdVWFKb0Vqc62oTEBAAEuWLKFFixYkJibywAMPEBAQwJNPPlnpc3766Se8vb1Zu3YtSUlJ3HvvvYSGhvLiiy869vnwww+ZPn06v/32G5s3b2bChAkMGjSI6667DgCtVssbb7xBbGwsx48fZ/LkyTz55JMsWLAAgN9++42JEycyd+5cbrnlFlavXs2sWbOc2rFx40ZGjhxZ5ft75plneOaZZyp87Pjx46SlpTldQ728vBgyZAibNm3ib3/7W4XP27x5M9OmTXPaNnz48HIpNocPH6ZFixZ4eXnRr18/5s6d6/i9Ee7hrv7lwr6lOuratxw6fAiAkydOcuutt1Z5jaqsb5n+6HRmvjbzosUspG+RvuVC0rdI31KW24KrzMxMLBYLERERTtsjIiJIS0ur8DlpaWkV7m82m8nMzCQqKopjx47x888/c+edd7Jy5UoOHz7MQw89hNls5rnnnqvwuC+99BL/+Mc/XPPGGjF7amBmUSY5JTkVBlfjx4/n6aefJikpCY1Gw6+//sqyZcucOsCCggIWLlzIkiVLHH+w7733HgkJCSxatIgnnniChQsX0qZNG1577TXb67YKYsu2LSx6c5HjOP/6178YN26cY0Jn+/bteeONNxgyZAgLFy686GKR/v7++Pj4UFJS4pQS8PHHH6PVann//fcdVR0/+OADgoODWbduHX379iUnJ4cbbriBtm3bAtC5c2en4+r1+ovm/fr6+tKxY0cMBkOV+/n5+fH+++9jNJ4v4jF79mwef/zxKp/XokULwPZ3ER4eXu7x8PDwSv+WKrN48WJGjhxJSEgIACNGjGDx4sW88MILAOV+bh07diQxMZF//vOfTu3auXNnla8TGBhY7TbV5lpRmZkzZzr+Hxsby2OPPcby5cur7ACNRiOLFy/G19eXrl27Mnv2bJ544gnmzJmDVmtLH+rRo4ejw2rfvj1vvfUWP/30k6MDLDspOS4ujjlz5vDggw86OsDXX3+d4cOHOzr5Dh06sGnTJlavXu14Xt++fS96Xps1a1bpY/ZzVdF5TE5OrvJ5Fzv3/fr146OPPqJDhw6cOXOGF154gYEDB7J3795LbkFbUTt17Vs+WPwBY+4fw/IPlhMbF1vlNaqqvuWJl57A6Ft1QSXpW6RvuZD0LdK3lOX2da4uLFmulKrR+lD2uzH27VarlfDwcN599110Oh19+vTh9OnT/Otf/6o0uHr66aeZPv38gr+5ublER0fX6v3UlI9Bx77ZwxvktSp67QsFedmCq3xTPmarGb3W+VckNDSUUaNG8eGHH6KUYtSoUYSGhjrtc/ToUUwmE4MGDXJsMxgMXHHFFezfvx+A/fv3079/f8fPrcBUQM/LezodZ9u2bRw5coRPPvnEsU0phdVq5fjx406dUk3YjxsQEOC0vbi4mKNHjxIfH8+ECRMYPnw41113Hddeey233XYbUVFRNXqdK664ggMHDlx0v+7duzt1fmDrvCrq1CpT0d/Mxf6WLmSxWPjwww95/fXXHdvuuusupk2bxj/+8Q90Ol25nxvAgAEDnI6j1+tp165dtV+3ump6rajI559/zvz58zly5Aj5+fmYzeaLdsY9e/Z0Wph1wIAB5Ofnc+LECWJiYgBbB1hWVFQU6enpju/Xrl3L3Llz2bdvH7m5uZjNZoqLiykoKMDPz4/9+/dz8803Ox1jwIABTh2gj49Ptc/rJ5984nS3cNWqVY6R+9qcx4s9p+xdz+7duzNgwADatm3ruOsq3MNd/UtFfcvFuKJvGasby7HDx+hzeZ8qr1FV9S0nU07SNqxtjdtf9rjStziTvqVi0rc03b7FbcFVaGgoOp2u3N2B9PT0cpGsXWRkZIX76/V6RwQbFRWFwWBwSgHs3LkzaWlplJaWlrvQgG340svLPWtaaDSaGqdP1CdvvTdeei9KzCXkleYR4h1Sbp+JEycyZcoUAN5+++1yj18Y8Jbdbt+mypR7N1vNjkqBZVmtVv72t7/xyCOPlHusLgU0rFYrffr0cepY7cLCwgDb3cZHHnmE1atXs3z5cmbOnElCQgL9+/ev9etWxs+vfAGPmqRuREZGcubMmXKPZ2RkVPq3VJEffviBU6dOMXbsWKftFouFNWvWMHLkyGqV6Xd16kZtrhUV2bJlC7fffjv/+Mc/GD58OEFBQSxbtox///vf1T5GWWV/vy+8g6zRaLBarQAkJydz/fXXM2nSJObMmUOzZs345ZdfuO+++xwryFfnvNYkdeOmm25ySuVp2bIlqampgO1uYdkPcxc7j5Vdd6t6jp+fH927d+fw4cNVtlfUL0/rXy6mrn2Lt94bFFiUpcrXqahvUUpxLPsYES0jar3GlfQtFZO+pWakb2n8fYvbrrpGo5E+ffqQkJDgFFUnJCQwevToCp8zYMAAvv32W6dta9asoW/fvo5fwEGDBrF06VKsVqtjWPXQoUNERUVVGFiJ8oKMQaSb08kpyakwuBoxYoSj8tDw4eXvirZr1w6j0cgvv/zCuHHjADCZTGzdutUxhN2lSxe++uorAApNhQDs2b7H6Ti9e/dm7969dbpTZTQasVicO9revXuzfPlywsPDq7yz1KtXL3r16sXTTz/NgAEDWLp0Kf3796/wmK5Wk9SNAQMGkJOTw++//84VV1wB2PKsc3JyGDhwYLVfc9GiRdx+++08++yzTtvnzZvHokWLGDlypNPPzW7Lli3l2uXK1I3aXCsq8uuvvxITE+P0/qpKWbDbtWsXRUVF+Pj4ALb36+/vT6tWrar1ulu3bsVsNvPvf//bcU367LPPnPbp0qVLufN44fc1Sd0ICAgod/c8Li6OyMhIEhIS6NWrF2Cbc7B+/Xqn1JsLDRgwgISEBKfc+DVr1lT5u1VSUsL+/fsZPHhwle0Voqy69i1eOi/adGjDutXrnJ534d9SRX2L2Wqm9KzttauzzqL0LdK32EnfIn1LOS4qolEry5YtUwaDQS1atEjt27dPTZ06Vfn5+amkpCSllFIzZsxQ48ePd+x/7Ngx5evrq6ZNm6b27dunFi1apAwGg/r8888d+6SkpCh/f381ZcoUdfDgQfXdd9+p8PBw9cILL1S7XQ1ZLdATlZhL1J6MPWpPxh5VarZVu7FXtrHLyclxOj8XVnR69NFHVYsWLdSqVavU3r171T333KNCQkLU2bNnlVJKJScnK6PRqKZNm6Y2bN+g/vnOP1V4RLhTZaBdu3YpHx8fNXnyZLVjxw516NAh9fXXX6spU6Y4Xqeqik5KKfXiiy+q1q1bqwMHDqiMjAxVWlqqCgoKVPv27dXQoUPVhg0b1LFjx9S6devUI488ok6cOKGOHTumZsyYoTZt2qSSkpLUDz/8oJo1a6YWLFiglLJVsfLz81M7duxQGRkZqri4uMLX/u2331THjh3VyZMnK23fhee1tkaMGKF69OihNm/erDZv3qy6d++ubrjhhmo/Pz09XRkMBrVq1apyj61Zs0YZDAaVnp7u9HM7cOCA+uSTT1RkZGSdKjqVlJSoHTt2qB07dqioqCj1+OOPqx07dqjDhw879rnYtaI6vvrqK6XX69Wnn36qjhw5ol5//XXVrFkzp6pJFVV08vf3V3fccYfau3evWrlypYqIiHCqJDVkyBD16KOPOr1W2b+HHTt2KEDNnz9fHT16VH300UeqZcuWTuds8+bNSqPRqH/+85/q4MGD6s0331TBwcEureiklFLz5s1TQUFB6osvvlCJiYnqjjvuUFFRUSo3N9exz/jx453e36+//qp0Op2aN2+e2r9/v5o3b57S6/VOFcQee+wxtW7dOnXs2DG1ZcsWdcMNN6iAgIAqfz6eXi3w7bffVrGxscrLy0v17t1bbdiwodJ9T58+re644w7VoUMHpdFoyv0+XOjTTz9VQI3/9mtaLbAxcGXfUmQqUgk7EpTBaFBTp06t9BpVUd+yfMVyNe6+cerg2YNKKelb7KRvuTjpWxpP31IXNemX3BpcKWXrwGJiYpTRaFS9e/dW69evdzx2zz33qCFDhjjtv27dOtWrVy9lNBpVbGysWrhwYbljbtq0SfXr1095eXmpNm3aqBdffFGZzeZqt+lSD66UUupY9jG1J2OPyijMUEpd/EJ9YQdYVFSkHn74YRUaGlppKfZvv/1WtWvXThm9jKpP/z7qrf+8Ve5C+vvvv6vrrrtO+fv7Kz8/P9WjRw/14osvOh6/WAeYnp7ueD5lyuWmpqaqu+++29G+Nm3aqAceeEDl5OSotLQ0NWbMGBUVFaWMRqOKiYlRzz33nLJYbOXpi4uL1a233qqCg4OrLJe7du1aBTiV4b2QqzrArKwsdeedd6qAgAAVEBCg7rzzznIdUkxMTLkyrnavvPKKCg4OrnAJA5PJpJo1a6b+/e9/K6XO/9y8vLzU4MGD1eLFi+vUAR4/frxcCWKg3N9+VdcKpWyd18XKDT/xxBOqefPmyt/fX40dO1a99tprF+0AR48erZ577jnH8+6//36nDz0X6wCVUurVV19VUVFRysfHRw0fPlx99NFH5c7ZokWLVKtWrZSPj4+68cYbXV4uVylbydxZs2apyMhI5eXlpa666iqVmJjotM+QIUOc2q6UUv/73/9Ux44dlcFgUJ06dVIrVqxwenzs2LEqKipKGQwG1aJFC3XLLbeovXv3VtkWTw6u7B+43nvvPbVv3z716KOPKj8/P5WcnFzh/sePH1ePPPKI+vDDD9Vll11WZXCVlJSkWrZsqQYPHizBlXJt32KxWtTezL3qrU/eUm3bta3yGnVh39K1e1f1yDOPqKQc24c26VtspG+RvqU6GkvfUhc16Zc0SlUjIfMSk5ubS1BQEDk5OTUaYq6O4uJijh8/7lgN3FOdLTpLakEq3npv2gbXbnJvdZitZg6ePQhAx2YdyxXQEK5RVFREs2bNWLlyJcOGDXN3c+rFhAkTAFiyZIlLj5mdnV0uXUXUXVXXwvq8BldHv3796N27NwsXLnRs69y5M2PGjOGll16q8rlDhw7lsssuK1dOGGxzTIYMGcK9997Lxo0ba/y7VdV5aSx9S307kn2EEnMJrQNbE2AMuPgT/pRWkEZWURbNfZoT6Vd1tT5xnvQttT+m9C31o76uhTXpl5reMuTCJQK9AtGgodhcTIm59iveX0yBqQAAL72XBFb1aP369Vx99dVNtvMD23ucM2eOu5shGjn72jcXrqlYm7VvLjR79mzCwsK477776nQcUTlvne3DVEVFkqpSYrH1c9WZbyXOk75FiPLk06yokF6rx8/oR35pPjmlOYTrq1+6tSbsxSz89OWrGgnXGTFiBCNGjHB3M+rV8ePH3d0E0QS4cu2bsn799VcWLVp00YnjZblzgfvGyl7pzx4sVZd9/9pWCrxUSd8iRHkSXIlKBXkF2YKrkhzCfMJqvO5DddhHrvwMElwJz+PKNBDRuLhi7Ru7vLw87rrrLt57771yazdVRRa4r7naBFdWZcVkMTk9X4j6JH1L0ybBlahUgCEAjUZDqaWUYksxPnoflx7fZDU5OkBfg+9F9hZCiPrnqrVvyjp69ChJSUnceOONjm32tWr0ej0HDx6kbdvyc1vducB9Y+Wtt6UFllhKqh0Ql1psJdh1Gh06Tc0XQBZCiLIkuBKV0ml1BBoDySnJIackx+XBlT0l0FvvLfOthBAewVVr35TVqVMnEhMTnbbNnDmTvLw8Xn/99UoDJncucN9YGbQGtBotVmWl1FKKl/7i588x30pvrJcMDSHEpUU+0YoqBXkFOYKrCN8Il3Y89pRAGbUSQniS6dOnM378ePr27cuAAQN49913SUlJYdKkSYBtROnUqVN89NFHjufY51Ll5+eTkZHBzp07MRqNdOnSBW9vb7p16+b0GsHBwQDltou60Wg0eOm8KDIXUWIpqVFwJSmBQghXkOBKVMnP4IdOo8NsNVNoKsTP6Lq5UY75VlLMQgjhQcaOHUtWVhazZ88mNTWVbt26sXLlSmJiYgBITU0lJSXF6Tm9evVy/H/btm0sXbqUmJgYkpKSGrLpAlv12SJzEcWWYgK5eCl/e1qgBFdCCFeQ4EpUSavREugVyLnic+SU5rgsuDJZTI4OTYpZCCE8zeTJk5k8eXKFj1U0Gb2mS0bKhPb6U9OiFo60QK2UYRdC1J2scyUuKsgrCICckhysyuqSYxaYbaNW3npvdFqZQCyEEMI1arLWlVJKRq6EEC4lwZW4KF+9L3qtHquykl+a75JjOta3klErIYQQLmQPkkotpRe9IWiymrAqKxqNBoPO0BDNE0I0cRJciYvSaDQEeQXx7JRnCfIOckzqLmvy5MloNBomTJjg2JaWlsbDDz9MmzZt8PLyIjo6mhtvvJGffvrJMd+qX9d+aDQali1bVu6YXbt2RaPRlEuf2bFjB3/961+JiIjA29ubDh068MADD3Do0CGXvm8hhBD1b8KECWg0Gpf0LQB6rZ743vF0C+vGx0s/LnfMsn2LfdTKqDWya+cu6VuEEHUmwZWoFntqYGTLSJYtW0ZRUZHjseLiYj799FNat27t2JaUlESfPn34+eefefnll0lMTGT16tUMGzaMyQ9NdnRoGjRER0fzwQcfOL3eli1bSEtLw8/PeWTru+++o3///pSUlPDJJ5+wf/9+/vvf/xIUFMTf//73+nr7Qggh6lF0dHSd+5aHHnoIsN0Q1KAhsmUkHy750Ol1Luxb7POtNiZslL5FCOESUtDC3ZSCP1PkGpzBF6pZWt1b541Wq6VLjy6knUjjiy++4M477wTgiy++IDo6mjZt2jj2t99t/P33350CpK5du3LruFvJJ9+xbtadd97Ja6+9xokTJxzrvSxevJg777zTqdRxYWEh9957L9dffz1ffvmlY3tcXBz9+vUjOzu71qdCCCGaHHf1LzXoW+x69+7NsWPH6tS3TJw40fG9RqNh1K2j+Pg/H1fZt5RYSigqLOLxyY9L3yKEcAkJrtzNVAhzW7jntZ85DdWs/qfRaByVlG4ZdwsffPCBowNcvHgxEydOZN26dQCcPXuW1atX8+KLL5YbeQLQ++mh5Px8q4iICIYPH86HH37IzJkzKSwsZPny5axfv94puPrhhx/IzMzkySefrLCN9nVjhBBC4L7+pQZ9S1n33ntvnfqWsn2ABg2hYaFcdc1VVfYtpZZSfl37K2ezzkrfIoRwCUkLFNVmn+w7/Jbh/PLLLyQlJZGcnMyvv/7KXXfd5djvyJEjKKXo1KlThcdxrG9VppjFxIkTWbJkCUopPt4/WzIAABpASURBVP/8c9q2bctll13m9LzDhw8DVHpcIYQQjdf48ePr1LeUZV/wfsy4MVX2LSWWElKO2dYsk75FCOEKMnLlbgZf210+d712Deg0OrQaLSHNQ7huxHV8+OGHKKUYNWoUoaGhjv3s671oKkgLKbWUYrKa0KBxpAUCjBo1ir/97W9s2LDBcbfyQjVdR0YIIS5p7upfati32IWGhjJq1Kha9S0X0mDbZ9A1g5j92OwK+xar1YrZapa+RQjhUhJcuZtGU6v0CXcxaG2jV2PGjeGFp14A4O2333bap3379mg0Gvbv38+YMWOcHrOPWnkbnNe30uv1jB8/nlmzZvHbb7855b3bdejQAYADBw4wYMAAl70nIYRokhpZ/wK2LIYpU6YANetbKqLVatHr9dx+5+0V9i1mZQagTTvbnC7pW4QQriBpgaJG9FpbPH75kMspLS2ltLSU4cOHO+3TrFkzhg8fzttvv01BQYHTYwWmAnJzcvHTl+/wJ06cyPr16xk9ejQhISHlHo+Pjyc0NJSXX365wrbJpGMhhGjcRowYUau+Bcr3AXqNrb+6ffztFfYtZqstuLr62qulbxFCuIyMXIka0Wq0+Bn8KKCAjds2Euobik6nK7ffggULGDhwIFdccQWzZ8+mR48emEwmPvn6Ez794FN279ld7jmdO3cmMzMTX9+KU0r8/Px4//33+etf/8pNN93EI488Qrt27cjMzOSzzz4jJSWlwvWyhBBCNA46nY79+/c7/n+hivoWs9lMQkICCxcudDwXQK+zfcSJaR9TYd9ispoACA4Mlr5FCOEyMnIlasy+5pXVy0pAQECF+8TFxbF9+3aGDRvGY489Rrdu3YiPj2fzhs0896/n8K0kJ7958+b4+PhU+BjA6NGj2bRpEwaDgXHjxtGpUyfuuOMOcnJyeOGFF+r+5oQQQrhVYGAggYGBFT5WUd9y3XXX8dNPP7Fw4UKnfe0jVyXmkgr7FovVAoCXzkv6FiGEy2iUzOQsJzc3l6CgIHJyciq9wNdWcXExx48fJy4uDm9vb5ceu6FYrBYOnjuIUoq2wW3x1lfvfZwtPktqfiq+Bl/iguLquZVCCE9W1bWwPq/BjVlV56Up9C2uVmgq5HjOcfRaPR2bdSz3+JFzRyixlBATGIO/0d8NLRRCuFp9XQtr0i/JyJWoMZ1WR4DBNmKVU5JT7ecV/rmYZdkS7EIIIUR98NJ5Aba5Vfb5VXZKKUqtpQAYdcYGb5sQoumS4ErUij01MKckp1plbJVSFa5vJYQQQtQHnVbnWJ+xxFLi9FiptRSlFBqNxlEFVwghXEGCK1Er/kZ/tBotJquJQnPhRfcvtZRitprRaJzXtxJCCCHqi7fOlhZUbC522l5qsY1aeem8qrVulhBCVJcEV6JWtBotgUZbzml1UgMLzLZRK1+9L1qN/NoJIYSof/bUwAtHruzf2x8XQghXkU+5otbsqYG5pblYlbXKfe0pgZVVCRRCCCFczUtfdXAl862EEK4mwZWoNT+DH3qtHovV4gieKiLzrYQQQrhD2bTAsvODZeRKCFFfJLgStabRaAj0unhqYImlBIvVIvOthBBCNCj7yJRVWR0VA5VSlJrPz7kSQghXkuBK1EmQ0ZYamFea51iQ8UKOlECZbyWEEKIBaTXacvOuLMqCRdn6K0kLFEK4mnzSFXXio/fBoDNgVVbyTfkV7mOvJigpgUIIIRqafd5VscVWMdAeZBl0BrnhJ4RwObmqiGqbMGECGo3Gti6IwUBERATx8fF8v+x7rFZrhamBFc23WrJkCcHBwQ3ZdCGEEB6qor7luuuuY/HixVitVRdLKquyvsUxcmW2BVUy30oIUZ8kuBI1MmLECFJTU0lKSmLVqlUMGzaM5558jofGPUR2YbYjp93OPt9Kq9Hirfd2U6uFEEJ4sor6lkcffZQbbrgBs9l88QNUwVHU4s+RK/saV5ISKISoDxJciRrx8vIiMjKSli1b0rt3b5555hm+/vprNv60kS8//ZLc0lxeffVVunfvjp+fH21j2zLnyTmoEoVWo2XdunXce++95OTkOO5UPv/88wB8/PHH9O3bl4CAACIjIxk3bhzp6enufcNCCCHqXWV9y6pVq1iyZAmAU98SHR3N5MmTyc+3paNX1besWLaC2669jR6tehAZGcnfJvyNrIwsGbkSQtQLvbsbcKlTSlFkLnLLa/vofVyyMv3VV19N1+5d+en7n7h74t1otVreeOMNYmNj2bJnC89Of5Z/Pf8vPnj3AwYOHMj8+fN57rnnOHjwIAD+/v4AlJaWMmfOHDp27Eh6ejrTpk1jwoQJrFy5ss5tFEKIS427+hdX9i09e/bkiy++4P7773fqW44fP87kyZN58sknWbBgQZV9i9Vs5ZGnHyGmbQx+JX48MvURZj48k1WrVtW5jUIIcSEJrtysyFxEv6X93PLav437zWWL+nbp3IVtO7dRaCrkoYcfwqAzoJSiOLCYKTOmMPepufAuGI1GgoKC0Gg0REZGOh1j4sSJjv+3adOGN954gyuuuIL8/HxHJymEEKJ63NW/uLJv6dSpE7t37wZg6tSpju1xcXHMmTOHBx98kAULFlTZt9x3330czT5KsbmYVgGteGruU9wRfwelRaVSaEkI4XISXAmX0KBBp9UB8H3C97z977fZu28vOTk5WCwWSopLKCgowM+v8o5sx44dPP/88+zcuZOzZ886JjKnpKTQpUuXBnkfQgghPIdSyjEKtnbtWubOncu+ffvIzc3FbDZTXFxcrb7lqZlPsWf3HnKzcx19y+kTpwnpGtIg70MIcemQ4MrNfPQ+/DbuN7e9tqvs37+fuLg4Tp84ze03386Dkx7ksZmPYfG2sG/rPp6c8iQmk6nS5xcUFBAfH098fDwff/wxYWFhpKSkMHz4cEpLS13WTiGEuFS4q3+pj74lOTmZ66+/nkmTJjFnzhyaNWvGL7/8wn333VetvmXINUOYt2AezcOac+rEKf5229+qfJ4QQtSWBFduptFoXJY+4S4///wziYmJPPLoI+zduReL2cLcf84loziDvNI8fln5i9P+RqMRi8V5weEDBw6QmZnJvHnziI6OBmDr1q0N9h6EEKKpaez9i71vmTZtGlu3bsVsNvPvf/8brdZWi+uzzz5z2r+qvmXOi3OwBtlGrBJ3JDbMGxBCXJKkWqCokZKSEtLS0jh16hTbt29n7ty5jB49mhtuuIF7J9xLx/YdbR3g/H9z4PABvvnsGz5a9JHTMWJjY8nPz+enn34iMzOTwsJCWrdujdFo5M033+TYsWN88803zJkzx03vUghxqVuwYAFxcXF4e3vTp08fNm7cWOm+qampjBs3jo4dO6LVap3mBtm99957DB48mJCQEEJCQrj22mv5/fff6/EdNC5V9S133303bdu2xWw2O/qI//73v7zzzjtOx6iqb3l/4fucSDrB2tVr+c+//+OmdymEuBRIcCVqZPXq1URFRREbG8uIESNYu3Ytb7zxBl9//TU6nY6Blw/kyTlP8sarbzB68GhWrljJS3NfcjrGwIEDmTRpEmPHjiUsLIyXX36ZsLAwlixZwv/+9z+6dOnCvHnzeOWVV9z0LoUQl7Lly5czdepUnn32WXbs2MHgwYMZOXIkKSkpFe5fUlJCWFgYzz77LD179qxwn3Xr1nHHHXewdu1aNm/eTOvWrYmPj+fUqVP1+VYajYv1LZdddhmvvvoq//znP+nWrRuffPIJL71U/b7lixVfMPrK0bz/xvs8/o/H3fQuhRCXAo1SSrm7EZ4mNzeXoKAgcnJyCAwMdOmxi4uLOX78uOOOaFNjsVo4dO4QVmVLvwgwBtA6sLWbWyWE8DRVXQvr8xpcHf369aN3794sXLjQsa1z586MGTOm3Af6Cw0dOpTLLruM+fPnV7mfxWIhJCSEt956i7vvvrta7arqvDT1vsUVjuUco8hkK03fLrgdXnpZ50qIpqa+roU16Zdk5Eq4lE6rI8AY4PheytwKIRqT0tJStm3bRnx8vNP2+Ph4Nm3a5LLXKSwsxGQy0axZs0r3KSkpITc31+lL1J63zvZBS4MGg87g5tYIIZoqCa6EywV5BTn+35gnUwshLj2ZmZlYLBYiIiKctkdERJCWluay15kxYwYtW7bk2muvrXSfl156iaCgIMeXvdiPqB0vnW2kyqAzoNXIxx8hRP2Qq4twOT+DHz4GH/wMfo47hUII0ZjY11ayK7veUl29/PLLfPrpp3zxxRdVpq08/fTT5OTkOL5OnDjhkte/VPkb/dFpdU43AIUQwtWkFLtwOa1GS5ugNu5uhhBC1FhoaCg6na7cKFV6enq50azaeOWVV5g7dy4//vgjPXr0qHJfLy8vvLxkXpCreOm86BjS0WVBshBCVERGroQQQog/GY1G+vTpQ0JCgtP2hIQEBg4cWKdj/+tf/2LOnDmsXr2avn371ulYonYksBJC1DcZuXITKdIohLiUefI1cPr06YwfP56+ffsyYMAA3n33XVJSUpg0aRJgS9c7deoUH310fg2/nTt3ApCfn09GRgY7d+7EaDTSpUsXwJYK+Pe//52lS5cSGxvrGBnz9/fH39/fZW335PMqhBD1zROugRJcNTCDwVahqLCwEB8fHze3Rggh3KOwsBA4f030JGPHjiUrK4vZs2eTmppKt27dWLlyJTExMYBt0eAL17zq1auX4//btm1j6dKlxMTEkJSUBNgWJS4tLeUvf/mL0/NmzZrF888/X+c2S98ihBCe0bfIOlcVqO81VlJTU8nOziY8PBxfX19JUxBCXDKUUhQWFpKenk5wcDBRUVHl9nH3Olee6mLnRfoWIcSlqjp9S13UpF9y+8jVggUL+Ne//kVqaipdu3Zl/vz5DB48uNL9169fz/Tp09m7dy8tWrTgySefdKRqXGjZsmXccccdjB49mq+++qqe3kHNRUZGArYJ0kIIcSkKDg52XAuFa0jfIoS41HlC3+LW4Gr58uVMnTqVBQsWMGjQIP7zn/8wcuRI9u3bR+vWrcvtf/z4ca6//noeeOABPv74Y3799VcmT55MWFgYt956q9O+ycnJPP7441UGau6i0WiIiooiPDwck8nk7uYIIUSDMhgM6HQ6dzejyZG+RQhxKfOUvsWtaYH9+vWjd+/eLFy40LGtc+fOjBkzhpdeeqnc/k899RTffPMN+/fvd2ybNGkSu3btYvPmzY5tFouFIUOGcO+997Jx40ays7NrNHIlKSlCCOE+cg2umJwXIYRwj5pcf91Wir20tJRt27YRHx/vtD0+Pp5NmzZV+JzNmzeX23/48OFs3brV6S7d7NmzCQsL47777qtWW0pKSsjNzXX6EkIIIYQQQoiacFtwlZmZicViKbcoY0RERLnFG+3S0tIq3N9sNpOZmQnAr7/+yqJFi3jvvfeq3ZaXXnqJoKAgx1d0dHQN340QQgghhBDiUuf2RYQvrGaklKqywlFF+9u35+Xlcdddd/Hee+8RGhpa7TY8/fTT5OTkOL5OnDhRg3cghBBCCCGEEG4saBEaGopOpys3SpWenl5udMouMjKywv31ej3Nmzdn7969JCUlceONNzoet1qtAOj1eg4ePEjbtm3LHdfLywsvLy/H9/aATdIDhRCi4dmvvbJSiDPpm4QQwj1q0i+5LbgyGo306dOHhIQEbr75Zsf2hIQERo8eXeFzBgwYwLfffuu0bc2aNfTt2xeDwUCnTp1ITEx0enzmzJnk5eXx+uuvVzvdLy8vD0DSA4UQwo3y8vIICgpydzM8hvRNQgjhXtXpl9xain369OmMHz+evn37MmDAAN59911SUlIc61Y9/fTTnDp1io8++giwVQZ86623mD59Og888ACbN29m0aJFfPrppwB4e3vTrVs3p9cIDg4GKLe9Ki1atODEiRMEBAQ02kUYc3NziY6O5sSJE1JVqgJyfqom56dqcn6qVtfzo5QiLy+PFi1a1EPrGi/pm5o+OT+Vk3NTNTk/VWvIfsmtwdXYsWPJyspi9uzZpKam0q1bN1auXElMTAxgW20+JSXFsX9cXBwrV65k2rRpvP3227Ro0YI33nij3BpXdaXVamnVqpVLj+kugYGB8kdWBTk/VZPzUzU5P1Wry/mREavypG+6dMj5qZycm6rJ+alaQ/RLbg2uACZPnszkyZMrfGzJkiXltg0ZMoTt27dX+/gVHUMIIYQQQgghXM3t1QKFEEIIIYQQoimQ4KqJ8vLyYtasWU5VEMV5cn6qJuenanJ+qibnR1RGfjeqJuencnJuqibnp2oNeX40SmrdCiGEEEIIIUSdyciVEEIIIYQQQriABFdCCCGEEEII4QISXAkhhBBCCCGEC0hwJYQQQgghhBAuIMFVI7JhwwZuvPFGWrRogUaj4auvvnJ6XCnF888/T4sWLfDx8WHo0KHs3bvXaZ+SkhIefvhhQkND8fPz46abbuLkyZMN+C7qz0svvcTll19OQEAA4eHhjBkzhoMHDzrtcymfo4ULF9KjRw/HAnoDBgxg1apVjscv5XNzoZdeegmNRsPUqVMd2y7l8/P888+j0WicviIjIx2PX8rnRkjfVBXpl6om/VLNSN/kzGP7JiUajZUrV6pnn31WrVixQgHqyy+/dHp83rx5KiAgQK1YsUIlJiaqsWPHqqioKJWbm+vYZ9KkSaply5YqISFBbd++XQ0bNkz17NlTmc3mBn43rjd8+HD1wQcfqD179qidO3eqUaNGqdatW6v8/HzHPpfyOfrmm2/U999/rw4ePKgOHjyonnnmGWUwGNSePXuUUpf2uSnr999/V7GxsapHjx7q0UcfdWy/lM/PrFmzVNeuXVVqaqrjKz093fH4pXxuhPRNVZF+qWrSL1Wf9E3leWrfJMFVI3VhB2a1WlVkZKSaN2+eY1txcbEKCgpS77zzjlJKqezsbGUwGNSyZcsc+5w6dUpptVq1evXqBmt7Q0lPT1eAWr9+vVJKzlFFQkJC1Pvvvy/n5k95eXmqffv2KiEhQQ0ZMsTRgV3q52fWrFmqZ8+eFT52qZ8b4Uz6pqpJv3Rx0i+VJ31TxTy1b5K0wCbi+PHjpKWlER8f79jm5eXFkCFD2LRpEwDbtm3DZDI57dOiRQu6devm2KcpycnJAaBZs2aAnKOyLBYLy5Yto6CggAEDBsi5+dNDDz3EqFGjuPbaa522y/mBw4cP06JFC+Li4rj99ts5duwYIOdGVE1+P5xJv1Q56ZcqJ31T5Tyxb9LX+pnCo6SlpQEQERHhtD0iIoLk5GTHPkajkZCQkHL72J/fVCilmD59OldeeSXdunUD5BwBJCYmMmDAAIqLi/H39+fLL7+kS5cujovIpXxuli1bxvbt2/njjz/KPXap/+7069ePjz76iA4dOnDmzBleeOEFBg4cyN69ey/5cyOqJr8f50m/VDHpl6omfVPlPLVvkuCqidFoNE7fK6XKbbtQdfZpbKZMmcLu3bv55Zdfyj12KZ+jjh07snPnTrKzs1mxYgX33HMP69evdzx+qZ6bEydO8Oijj7JmzRq8vb0r3e9SPT8jR450/L979+4MGDCAtm3b8uGHH9K/f3/g0j03onrk90P6pcpIv1Q56Zuq5ql9k6QFNhH26igXRtrp6emOqD0yMpLS0lLOnTtX6T5NwcMPP8w333zD2rVradWqlWO7nCMwGo20a9eOvn378tJLL9GzZ09ef/31S/7cbNu2jfT0dPr06YNer0ev17N+/XreeOMN9Hq94/1dqufnQn5+fnTv3p3Dhw9f8r87omry+2Ej/VLlpF+qnPRNNeMpfZMEV01EXFwckZGRJCQkOLaVlpayfv16Bg4cCECfPn0wGAxO+6SmprJnzx7HPo2ZUoopU6bwxRdf8PPPPxMXF+f0uJyj8pRSlJSUXPLn5pprriExMZGdO3c6vvr27cudd97Jzp07adOmzSV9fi5UUlLC/v37iYqKuuR/d0TVLvXfD+mXak76pfOkb6oZj+mbal0KQzS4vLw8tWPHDrVjxw4FqFdffVXt2LFDJScnK6VsJSeDgoLUF198oRITE9Udd9xRYcnJVq1aqR9//FFt375dXX311U2iHKdSSj344IMqKChIrVu3zqksZ2FhoWOfS/kcPf3002rDhg3q+PHjavfu3eqZZ55RWq1WrVmzRil1aZ+bipStyKTUpX1+HnvsMbVu3Tp17NgxtWXLFnXDDTeogIAAlZSUpJS6tM+NkL6pKtIvVU36pZqTvuk8T+2bJLhqRNauXauAcl/33HOPUspWdnLWrFkqMjJSeXl5qauuukolJiY6HaOoqEhNmTJFNWvWTPn4+KgbbrhBpaSkuOHduF5F5wZQH3zwgWOfS/kcTZw4UcXExCij0ajCwsLUNddc4+jAlLq0z01FLuzALuXzY18bxGAwqBYtWqhbbrlF7d271/H4pXxuhPRNVZF+qWrSL9Wc9E3neWrfpFFKqdqPewkhhBBCCCGEAJlzJYQQQgghhBAuIcGVEEIIIYQQQriABFdCCCGEEEII4QISXAkhhBBCCCGEC0hwJYQQQgghhBAuIMGVEEIIIYQQQriABFdCCCGEEEII4QISXAnRBA0dOpSpU6e6uxlCCCEEIP2SuHRIcCWEEEIIIYQQLiDBlRBCCCGEEEK4gARXQgghhBBCCOECElwJIYQQQgghhAtIcCWEEEIIIYQQLiDBlRBCCCGEEEK4gARXQgghhBBCCOECElwJIYQQQgghhAtIcCWEEEIIIYQQLiDBlRBCCCGEEEK4gEYppdzdCCGEEEIIIYRo7GTkSgghhBBCCCFcQIIrIYQQQgghhHABCa6EEEIIIYQQwgUkuBJCCCGEEEIIF5DgSgghhBBCCCFcQIIrIYQQQgghhHABCa6EEEIIIYQQwgUkuBJCCCGEEEIIF5DgSgghhBBCCCFcQIIrIYQQQgghhHABCa6EEEIIIYQQwgUkuBJCCCGEEEIIF/h/F8JT/xEbNLkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting done\n" + ] + } + ], + "source": [ + "param = param_sampling\n", + "print('Sampling Parameters', param)\n", + "\n", + "if param['Method'] == 'MCMC':\n", + " print(\"Chosen method = MCMC\")\n", + " MCMC()()\n", + "elif param['Method'] == 'NS':\n", + " print(\"Chosen method = Nested Sampling\")\n", + " NestedSampling()()\n", + "else:\n", + " print('Wrong sampling method')\n", + "\n", + "print(\"Fitting done\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ceb11400-063b-4d7a-912b-e1384abe95d7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "108c3849-1186-4577-acb4-b38b07cef7b6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3bc31d4-7c1d-41e0-b02d-fa76c1af5526", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f5d8d40-9631-40c8-a4f1-7af6dae2b59e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "QUBIC with Python 3.8", + "language": "python", + "name": "python-3.8" + }, + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/params.yml b/notebook/params.yml new file mode 100644 index 000000000..1f8b81874 --- /dev/null +++ b/notebook/params.yml @@ -0,0 +1,97 @@ +Method: 'FMM' +path_out: '/pbs/home/t/tlaclave/sps/Pipeline/data_with_convolution/DB_Nrec=4_Noise/' + +Sky: + CMB: + + cmb: False + r: [0, 'f', 'r', 0.001] + Alens: [1, 'f', 'A_{lens}', 1] + + Foregrounds: + + # Thermal Dust emission + Dust: False + nu0_d: 353 + Ad: [4, 'nf', 'A_d', 4] + betad: [1.54, 'nf', '\beta_d', 1.54] + alphad: [-0.4, 'nf', '\alpha_d', -0.4] + deltad: [1, 'nf', '\Delta_d', 1] + + # Synchrotron emission + Synchrotron: False + nu0_s: 23 + As: [0, 'nf', 'A_s', 0] + betas: [-3, 'nf', '\beta_s', -3] + alphas: [-0.4, 'nf', '\alpha_s', -0.4] + deltas: [1, 'nf', '\Delta_s', 1] + DustSync: False + eps: [0, 'nf', '\varepsilon', 0] + + nside: 256 + +QUBIC: + method: 'MM' # 'MM' for QUBIC map-making, 'fake' for fake map-making, 'spec' for spectrum based + randomreal: True + npointings: 8000 + nsub: 12 + nrec: 4 + seed: 1 + iteration: 1 + ndet: 1 + npho150: 1 + npho220: 1 + synthbeam_kmax: 1 + detector_nep: 4.7e-17 + nhwp_angles: 3 + dtheta: 30 + type: 'two' + covcut: 0.20 + kappa: 0 + convolution: True + bandpass_correction: True + RA_center: 0 + DEC_center: -57 + dust_model: 'd0' + sync_model: 's0' + fsky: 0.035 + +Spectrum: + do_spectrum: False + method: 'namaster' + dl: 30 + lmin: 40 + aposize: 10 + beam_correction: False + pixwin_correction: False + noise_correction: True + nbins: 10 + +PCG: + maxiter: 400 + tol: 1.0e-20 + gif: False + +Sampler: + do_sampler: False + nsteps: 200 + N: 5 + ndim: 2 + discard: 100 + markers: False + sig_initial_guess: 0.01 + title_limit: 1 + +Data: + datafilename: 'MC' + planck: + 30GHz: False + 44GHz: False + 70GHz: False + 100GHz: False + 143GHz: False + 217GHz: False + 353GHz: False + level_planck_noise: 0 + use_external_data: True + diff --git a/notebook/pipeline_notebook.py b/notebook/pipeline_notebook.py new file mode 100644 index 000000000..5029273b5 --- /dev/null +++ b/notebook/pipeline_notebook.py @@ -0,0 +1,1296 @@ +import numpy as np +import yaml +import pickle +import time +import healpy as hp + +from model.models import * +from likelihood.likelihood import * +from plots.plotter import * +import mapmaking.systematics as acq +from mapmaking.frequency_acquisition import get_preconditioner +from mapmaking.planck_timeline import * +from mapmaking.noise_timeline import * +from model.externaldata import * +from tools.foldertools import * +import qubic +import os +from fgb.component_model import * +from qubic import NamasterLib as nam +from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator +from pyoperators import MPI +from tools.cg import pcg + +def save_pkl(name, d): + with open(name, 'wb') as handle: + pickle.dump(d, handle, protocol=pickle.HIGHEST_PROTOCOL) + + +__all__ = ['Spectrum', + 'FakeFrequencyMapMaking', + 'PipelineFrequencyMapMaking', + 'PipelineCrossSpectrum', + 'PipelineEnd2End'] + +class Spectrum: + + """ + + Method to produce power spectrum from I/Q/U maps stored in 'data.pkl'. Returned power spectrum are DlBB = ell * (ell + 1) / 2 * pi * ClBB + + """ + + def __init__(self, file, seenpix=None): + + with open('params.yml', "r") as stream: + self.params = yaml.safe_load(stream) + + with open('noise.yml', "r") as stream: + self.noise = yaml.safe_load(stream) + + self.seenpix = seenpix + self.mask_nam = np.ones(12*self.params['Sky']['nside']**2) + if self.seenpix is not None: + self.mask_nam[~self.seenpix] = 0 + + if self.params['Spectrum']['method'] == 'namaster': + self.Namaster = nam.Namaster(self.mask_nam, + lmin=self.params['Spectrum']['lmin'], + lmax=self.params['Sky']['nside']*2, + delta_ell=self.params['Spectrum']['dl'], + aposize=self.params['Spectrum']['aposize']) + + self.ell, _ = self.Namaster.get_binning(self.params['Sky']['nside']) + + elif self.params['Spectrum']['method'] == 'healpy': + self.ell = self._binned_ell(np.arange(self.params['Spectrum']['lmin'], 2*self.params['Sky']['nside']+1, 1), self.params['Spectrum']['dl']) + self.file = file + self.f = self.ell * (self.ell + 1) / (2 * np.pi) + self.nbins = len(self.ell) + + def _get_depth(self, nus): + + ''' + + Method to get depth sensitivity from `noise.yml` file according to a given frequency. + + Arguments : + ----------- + + - nus : list constain frequency + + ''' + + with open('noise.yml', "r") as stream: + noise = yaml.safe_load(stream) + + res = [] + + for mynu in nus: + index = noise['Planck']['frequency'].index(mynu) if mynu in noise['Planck']['frequency'] else -1 + if index != -1: + d = noise['Planck']['depth_p'][index] + res.append(d) + else: + res.append(None) + + return res + def _get_Dl(self, map1, map2): + + ''' + + Method which return cross-Dl for BB spectrum. If seenpix is provided, the map used is partial. + + Arguments : + ----------- + + - map1 and map2 : I/Q/U maps from frequency nu1 and nu2. Expected shape is (Npix, Nstk) for each of them. + + + ''' + + if self.params['Spectrum']['method'] == 'namaster': + _, Dl, _ = self.Namaster.get_spectra(map=map1, + map2=map2, + beam_correction=None, + pixwin_correction=self.params['Spectrum']['pixwin_correction'], + verbose=False) + + DlBB = Dl[:, 2].copy() + + elif self.params['Spectrum']['method'] == 'healpy': + + DlBB = self.f * self._get_Dl_healpy(map1, map2, lmin=self.params['Spectrum']['lmin'], dl=self.params['Spectrum']['dl']) + + else: + raise TypeError(f"{self.params['Spectrum']['method']} not recognize method") + + return DlBB + def _get_Dl_healpy(self, map1, map2=None, lmin=20, dl=10): + + ''' + + Method to compute ClBB auto and cross spectrum using healpy package. It works onyl with full sky maps. + + Arguments : + ----------- + + - map1 and map2 : Array contains I/Q/U maps with shape (Npix, Nstk). + - lmin : integer for the minimum multipole + - dl : integer for the binning of the power spectra + + ''' + + if map2 is None: + clBB = hp.alm2cl(hp.map2alm(map1, lmax=2*self.params['Sky']['nside']))[2] + + else: + clBB = hp.alm2cl(alms1=hp.map2alm(map1, lmax=2*self.params['Sky']['nside']), + alms2=hp.map2alm(map2, lmax=2*self.params['Sky']['nside']))[2] + + ClBB_binned = self._binned_spectrum(clBB[lmin:], dl) + + return ClBB_binned + def _binned_spectrum(self, spec, dl): + + ''' + + Method that binned the spectrum. + + Arguments : + ----------- + - spec : array contains spectrum + - dl : integer for binning + + ''' + + clBB_binned = [] + + for i in range(len(spec) // dl): + clBB_binned += [np.mean(spec[i*dl:(i+1)*dl])] + + if len(spec) % dl != 0: + clBB_binned += [np.mean(spec[-(len(spec) % dl):])] + + clBB_binned = np.array(clBB_binned) + + return clBB_binned + def _binned_ell(self, ell, dl): + + ''' + + Method that binned the multipoles. + + Arguments : + ----------- + - ell : array contains mutipoles + - dl : integer for binning + + ''' + + ell_binned = [] + + for i in range(len(ell) // dl): + ell_binned += [np.mean(ell[i*dl:(i+1)*dl])] + + if len(ell) % dl != 0: + ell_binned += [np.mean(ell[-(len(ell) % dl):])] + + ell_binned = np.array(ell_binned) + + return ell_binned + def _read_pkl(self): + + ''' + + Method that reads pickle file containing data. + + ''' + + with open(self.file, 'rb') as f: + data = pickle.load(f) + + return data + def _update_data(self, ell, Dl): + + ''' + + Method that update `data.pkl`. + + Arguments : + ----------- + - ell : array contains multipoles + - Dl : array contains spectrum + + ''' + + data = self._read_pkl() + + data['ell'] = ell + data['Dl'] = Dl + + with open(self.file, 'wb') as handle: + pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL) + def run(self): + + ''' + + Method that run the pipeline for BB power spectrum estimation. + + ''' + + print('\n=========== Spectrum ===========\n') + + ### Read external data + maps_ext = self._read_pkl()['maps_ext'] + maps = self._read_pkl()['maps'] + nus_ext = self._read_pkl()['nus_ext'] + nus = self._read_pkl()['nus'] + + depths = np.array(list(np.array(self.noise['QUBIC']['depth_p'])) + list(self._get_depth(nus_ext))) + + self.noise_model = Noise(self.ell, depths) + self.noise_correction = self.noise_model.run() + + m = np.concatenate((maps, maps_ext), axis=0) + nus = np.concatenate((nus, nus_ext), axis=0) + + self.Dl = np.zeros((m.shape[0]**2, self.nbins)) + + k=0 + for i in range(m.shape[0]): + for j in range(m.shape[0]): + if i == j: + if self.seenpix is not None: + m[i, ~self.seenpix, :] = 0 + #m[i, :, 0] = 0 + self.Dl[k] = self._get_Dl(m[i].T, None) + else: + if self.seenpix is not None: + m[i, ~self.seenpix, :] = 0 + m[j, ~self.seenpix, :] = 0 + #m[i, :, 0] = 0 + #m[j, :, 0] = 0 + self.Dl[k] = self._get_Dl(m[i].T, m[j].T) + k+=1 + + if self.params['Spectrum']['noise_correction']: + self.Dl -= self.noise_correction + ### Update data.pkl -> Add spectrum + self._update_data(self.ell, self.Dl) + print('\n=========== Spectrum - done ===========\n') + +class FakeFrequencyMapMaking(ExternalData2Timeline): + + def __init__(self, comm, file, fsky=1): + + self.comm = comm + self.size = self.comm.Get_size() + self.rank = self.comm.Get_rank() + + + self.file = file + self.externaldata = PipelineExternalData(file) + self.job_id = os.environ.get('SLURM_JOB_ID') + + with open('params.yml', "r") as stream: + self.params = yaml.safe_load(stream) + + self.plots = PlotsMM(self.params) + + _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=1, relative_bandwidth=0.25) + _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=1, relative_bandwidth=0.25) + + self.nus = np.array(list(allnus150) + list(allnus220)) + self.skyconfig = self._get_sky_config() + + ExternalData2Timeline.__init__(self, self.skyconfig, self.nus, self.params['QUBIC']['nrec'], self.params['Sky']['nside'], self.params['QUBIC']['bandpass_correction']) + self.fsky = fsky + self.center = qubic.equ2gal(self.params['QUBIC']['RA_center'], self.params['QUBIC']['DEC_center']) + self.coverage = self.get_coverage([self.params['QUBIC']['RA_center'], self.params['QUBIC']['DEC_center']]) + self.seenpix = self.coverage/self.coverage.max() > self.params['QUBIC']['covcut'] + self.coverage_cut = self.coverage.copy() + self.coverage_cut[~self.seenpix] = 1 + #self.seenpix = seenpix + self.nfreq, self.npix, self.nstk = self.maps.shape + self.nus_eff = self.average_nus() + + with open('noise.yml', "r") as stream: + self.noise = yaml.safe_load(stream) + + def _get_sky_config(self): + + sky = {} + for ii, i in enumerate(self.params['Sky'].keys()): + + if i == 'CMB': + if self.params['Sky']['CMB']['cmb']: + if self.params['QUBIC']['seed'] == 0: + if self.rank == 0: + seed = np.random.randint(10000000) + else: + seed = None + seed = self.comm.bcast(seed, root=0) + else: + seed = self.params['QUBIC']['seed'] + sky['cmb'] = seed + + else: + for jj, j in enumerate(self.params['Sky']['Foregrounds']): + if j == 'Dust': + if self.params['Sky']['Foregrounds'][j]: + sky['dust'] = self.params['QUBIC']['dust_model'] + elif j == 'Synchrotron': + if self.params['Sky']['Foregrounds'][j]: + sky['synchrotron'] = self.params['QUBIC']['sync_model'] + + return sky + def get_coverage(self, center_radec): + center = qubic.equ2gal(center_radec[0], center_radec[1]) + uvcenter = np.array(hp.ang2vec(center[0], center[1], lonlat=True)) + uvpix = np.array(hp.pix2vec(self.nside, np.arange(12*self.nside**2))) + ang = np.arccos(np.dot(uvcenter, uvpix)) + indices = np.argsort(ang) + okpix = ang < -1 + okpix[indices[0:int(self.fsky * 12*self.nside**2)]] = True + mask = np.zeros(12*self.nside**2) + mask[okpix] = 1 + return mask + def average_nus(self): + + nus_eff = [] + f = int(self.nsub / self.nrec) + for i in range(self.nrec): + nus_eff += [np.mean(self.nus[i*f : (i+1)*f], axis=0)] + return np.array(nus_eff) + def _get_sig(self, depth): + return depth / hp.nside2resol(self.nside, arcmin=True) + def _get_realI(self, depth, seed=None): + + np.random.seed(seed) + sig = self._get_sig(depth) + + return np.random.normal(0, sig, (self.npix)) + def _get_realQU(self, depth, seed=None): + + np.random.seed(seed) + sig = self._get_sig(depth) + + return np.random.normal(0, sig, (self.npix, 2)) + def save_data(self, name, d): + + with open(name, 'wb') as handle: + pickle.dump(d, handle, protocol=pickle.HIGHEST_PROTOCOL) + def run(self): + + if self.rank == 0: + + self.m_nu_in = self.maps.copy() + n = np.zeros(self.maps.shape) + for i in range(self.nfreq): + n[i, :, 0] = self._get_realI(np.array(self.noise['QUBIC']['depth_i'])[i]) + n[i, :, 1:] = self._get_realQU(np.array(self.noise['QUBIC']['depth_p'])[i]) + + self.maps += n.copy() + + self.maps[:, ~self.seenpix, :] = 0 + + self.save_data(self.file, {'maps':self.maps, 'nus':self.nus_eff, 'coverage':self.coverage, 'center':self.center}) + self.externaldata.run(fwhm=self.params['QUBIC']['convolution'], noise=True) + self.plots.plot_FMM(self.m_nu_in, self.maps, self.center, self.seenpix, self.nus_eff, istk=0, nsig=3) + self.plots.plot_FMM(self.m_nu_in, self.maps, self.center, self.seenpix, self.nus_eff, istk=1, nsig=3) + self.plots.plot_FMM(self.m_nu_in, self.maps, self.center, self.seenpix, self.nus_eff, istk=2, nsig=3) + +class NoiseFromDl: + + def __init__(self, ell, Dl, nus, depth, dl=30, fsky=0.03): + + self.ell = ell + self.f = self.ell * (self.ell + 1) / (2 * np.pi) + self.nbins = len(self.ell) + + self.nus = nus + self.nspec = len(self.nus)**2 + + self.depth = depth + self.dl = dl + self.fsky = fsky + self.clnoise = self._get_clnoise() + self.Dl = Dl + print(self.clnoise) + + def _get_clnoise(self): + return np.radians(self.depth/60)**2 + + def errorbar_theo(self): + + errors_auto = np.zeros((len(self.nus), self.nbins)) + errors = np.zeros((self.nspec, self.nbins)) + + var = np.sqrt(2/((2 * self.ell + 1) * self.dl * self.fsky)) + cl2dl = self.ell * (self.ell + 1) / (2 * np.pi) + + for i in range(len(self.nus)): + errors_auto[i] = cl2dl * self.clnoise[i] + + k = 0 + for i in range(len(self.nus)): + for j in range(len(self.nus)): + if i == j: + errors[k] = errors_auto[i]**2 + else: + errors[k] = errors_auto[i] * errors_auto[j] * 0.5 + + k += 1 + + return var * np.sqrt(self.Dl**2 + errors**2) + +class MapMakingFromSpec(NoiseFromDl, ExternalData2Timeline): + + def __init__(self, ell, file, randomreal=True): + + with open('params.yml', "r") as stream: + self.params = yaml.safe_load(stream) + + with open('noise.yml', "r") as stream: + self.noise = yaml.safe_load(stream) + + self.job_id = os.environ.get('SLURM_JOB_ID') + self.file = file + self.externaldata = PipelineExternalData(file) + self.skyconfig = self._get_sky_config() + _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=1, relative_bandwidth=0.25) + _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=1, relative_bandwidth=0.25) + + self.nus = np.array(list(allnus150) + list(allnus220)) + ExternalData2Timeline.__init__(self, self.skyconfig, self.nus, self.params['QUBIC']['nrec'], self.params['Sky']['nside'], self.params['QUBIC']['bandpass_correction']) + self.nus_eff = self.average_nus() + self.save_data(self.file, {'nus':self.nus_eff}) + self.externaldata.run(fwhm=self.params['QUBIC']['convolution'], noise=True) + + self.allnus = self._read_data() + + self.nspec = len(self.allnus)**2 + self.ell = ell + self.randomreal = randomreal + self.sky = Sky(self.params, self.allnus, self.ell) + + self.depth = depths = np.array(list(np.array(self.noise['QUBIC']['depth_p'])) + list(self._get_depth(self.externaldata.external_nus))) + + def _read_data(self): + + ''' + + Method that read `data.pkl` file. + + ''' + + with open(self.file, 'rb') as f: + data = pickle.load(f) + return np.concatenate((data['nus'], data['nus_ext']), axis=0) + def save_data(self, name, d): + + with open(name, 'wb') as handle: + pickle.dump(d, handle, protocol=pickle.HIGHEST_PROTOCOL) + def average_nus(self): + + nus_eff = [] + f = int(self.nsub / self.nrec) + for i in range(self.nrec): + #print(f'Doing average between {np.min(self.nus[i*f:(i+1)*f])} and {np.max(self.nus[i*f:(i+1)*f])} GHz') + nus_eff += [np.mean(self.nus[i*f : (i+1)*f], axis=0)] + return np.array(nus_eff, dtype=float) + def _get_sky_config(self): + + sky = {} + for ii, i in enumerate(self.params['Sky'].keys()): + #print(ii, i) + + if i == 'CMB': + if self.params['Sky']['CMB']['cmb']: + if self.params['QUBIC']['seed'] == 0: + seed = np.random.randint(10000000) + + else: + seed = self.params['QUBIC']['seed'] + sky['cmb'] = seed + + else: + for jj, j in enumerate(self.params['Sky']['Foregrounds']): + #print(j, self.params['Foregrounds'][j]) + if j == 'Dust': + if self.params['Sky']['Foregrounds'][j]: + sky['dust'] = self.params['QUBIC']['dust_model'] + elif j == 'Synchrotron': + if self.params['Sky']['Foregrounds'][j]: + sky['synchrotron'] = self.params['QUBIC']['sync_model'] + + return sky + def _get_depth(self, nus): + + ''' + + Method to get depth sensitivity from `noise.yml` file according to a given frequency. + + Arguments : + ----------- + + - nus : list constain frequency + + ''' + + with open('noise.yml', "r") as stream: + noise = yaml.safe_load(stream) + + res = [] + + for mynu in nus: + index = noise['Planck']['frequency'].index(mynu) if mynu in noise['Planck']['frequency'] else -1 + if index != -1: + d = noise['Planck']['depth_p'][index] + res.append(d) + else: + res.append(None) + + return res + def foregrounds(self, fnu1, fnu2): + + return self.A * fnu1 * fnu2 * (self.ell/self.ell0)**self.alpha + def _read_pkl(self): + + ''' + + Method that reads pickle file containing data. + + ''' + + with open(self.file, 'rb') as f: + data = pickle.load(f) + + return data + def _update_data(self, ell, Dl): + + ''' + + Method that update `data.pkl`. + + Arguments : + ----------- + - ell : array contains multipoles + - Dl : array contains spectrum + + ''' + + data = self._read_pkl() + + data['ell'] = ell + data['Dl'] = Dl + + with open(self.file, 'wb') as handle: + pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL) + + def run(self): + + Dl = self.sky.get_Dl() + + noise = NoiseFromDl(self.ell, Dl, self.allnus, self.depth, dl=self.params['Spectrum']['dl'], fsky=self.params['QUBIC']['fsky']) + err = noise.errorbar_theo() + + if self.randomreal: + np.random.seed(None) + for j in range(self.nspec): + for i in range(len(self.ell)): + Dl[j, i] = np.random.normal(Dl[j, i], err[j, i]/2) + + #self.save_data(self.file, {'nus':self.allnus}) + self._update_data(self.ell, Dl) + +class PipelineFrequencyMapMaking: + + """ + + Instance to reconstruct frequency maps using QUBIC abilities. + + Parameters : + ------------ + - comm : MPI communicator + - file : str to create folder for data saving + + """ + + def __init__(self, comm, file): + + with open('params.yml', "r") as stream: + self.params = yaml.safe_load(stream) + + self.file = file + self.externaldata = PipelineExternalData(file) + self.job_id = np.random.randint(10000) + + ### Initialize plot instance + self.plots = PlotsMM(self.params) + + + self.center = qubic.equ2gal(self.params['QUBIC']['RA_center'], self.params['QUBIC']['DEC_center']) + self.fsub = int(self.params['QUBIC']['nsub'] / self.params['QUBIC']['nrec']) + + ### MPI common arguments + self.comm = comm + self.size = self.comm.Get_size() + self.rank = self.comm.Get_rank() + + ### Sky + self.dict, self.dict_mono = self.get_dict() + self.skyconfig = self._get_sky_config() + + ### Joint acquisition + self.joint = acq.JointAcquisitionFrequencyMapMaking(self.dict, self.params['QUBIC']['type'], self.params['QUBIC']['nrec'], self.params['QUBIC']['nsub']) + self.planck_acquisition143 = acq.PlanckAcquisition(143, self.joint.qubic.scene) + self.planck_acquisition217 = acq.PlanckAcquisition(217, self.joint.qubic.scene) + self.nus_Q = self._get_averaged_nus() + + ### Joint acquisition for TOD making + self.joint_tod = acq.JointAcquisitionFrequencyMapMaking(self.dict, self.params['QUBIC']['type'], self.params['QUBIC']['nsub'], self.params['QUBIC']['nsub']) + + ### Coverage map + self.coverage = self.joint.qubic.subacqs[0].get_coverage() + covnorm = self.coverage / self.coverage.max() + self.seenpix = covnorm > self.params['QUBIC']['covcut'] + self.fsky = self.seenpix.astype(float).sum() / self.seenpix.size + self.coverage_cut = self.coverage.copy() + self.coverage_cut[~self.seenpix] = 1 + + self.seenpix_for_plot = covnorm > 0 + self.mask = np.ones(12*self.params['Sky']['nside']**2) + self.mask[self.seenpix] = self.params['QUBIC']['kappa'] + + + ### Angular resolutions + self.targets, self.allfwhm = self._get_convolution() + + self.external_timeline = ExternalData2Timeline(self.skyconfig, + self.joint.qubic.allnus, + self.params['QUBIC']['nrec'], + nside=self.params['Sky']['nside'], + corrected_bandpass=self.params['QUBIC']['bandpass_correction']) + + ### Define reconstructed and TOD operator + self._get_H() + ### Inverse noise covariance matrix + self.invN = self.joint.get_invntt_operator(mask=self.mask) + + ### Noises + seed_noise_planck = np.random.randint(10000000) + print('seed_noise_planck', seed_noise_planck) + + self.noise143 = self.planck_acquisition143.get_noise(seed_noise_planck) * self.params['Data']['level_planck_noise'] + self.noise217 = self.planck_acquisition217.get_noise(seed_noise_planck+1) * self.params['Data']['level_planck_noise'] + + if self.params['QUBIC']['type'] == 'two': + qubic_noise = QubicDualBandNoise(self.dict, self.params['QUBIC']['npointings'], self.params['QUBIC']['detector_nep']) + elif self.params['QUBIC']['type'] == 'wide': + qubic_noise = QubicWideBandNoise(self.dict, self.params['QUBIC']['npointings'], self.params['QUBIC']['detector_nep']) + + self.noiseq = qubic_noise.total_noise(self.params['QUBIC']['ndet'], + self.params['QUBIC']['npho150'], + self.params['QUBIC']['npho220'], + seed=seed_noise_planck).ravel() + + def _get_H(self): + + """ + + Method to compute QUBIC operators. + + """ + + self.H = self.joint.get_operator(fwhm=self.targets) + self.Htod = self.joint_tod.get_operator(fwhm=self.allfwhm) + self.Hqtod = self.joint_tod.qubic.get_operator(fwhm=self.allfwhm) + def _get_averaged_nus(self): + + """ + + Method to average QUBIC frequencies. + + """ + + nus_eff = [] + for i in range(self.params['QUBIC']['nrec']): + nus_eff += [np.mean(self.joint.qubic.allnus[i*self.fsub:(i+1)*self.fsub])] + + return np.array(nus_eff) + def _get_sky_config(self): + + """ + + Method that read `params.yml` file and create dictionary containing sky emission such as : + + d = {'cmb':seed, 'dust':'d0', 'synchrotron':'s0'} + + Note that the key denote the emission and the value denote the sky model using PySM convention. For CMB, seed denote the realization. + + """ + sky = {} + for ii, i in enumerate(self.params['Sky'].keys()): + #print(ii, i) + + if i == 'CMB': + if self.params['Sky']['CMB']['cmb']: + if self.params['QUBIC']['seed'] == 0: + if self.rank == 0: + seed = np.random.randint(10000000) + else: + seed = None + seed = self.comm.bcast(seed, root=0) + else: + seed = self.params['QUBIC']['seed'] + print(f'Seed of the CMB is {seed} for rank {self.rank}') + sky['cmb'] = seed + + else: + for jj, j in enumerate(self.params['Sky']['Foregrounds']): + #print(j, self.params['Foregrounds'][j]) + if j == 'Dust': + if self.params['Sky']['Foregrounds'][j]: + sky['dust'] = self.params['QUBIC']['dust_model'] + elif j == 'Synchrotron': + if self.params['Sky']['Foregrounds'][j]: + sky['synchrotron'] = self.params['QUBIC']['sync_model'] + + return sky + def get_ultrawideband_config(self): + + """ + + Method that pre-compute UWB configuration. + + """ + + nu_up = 247.5 + nu_down = 131.25 + nu_ave = np.mean(np.array([nu_up, nu_down])) + delta = nu_up - nu_ave + + return nu_ave, 2*delta/nu_ave + def get_dict(self): + + """ + + Method to modify the qubic dictionary. + + """ + + nu_ave, delta_nu_over_nu = self.get_ultrawideband_config() + + args = {'npointings':self.params['QUBIC']['npointings'], + 'nf_recon':self.params['QUBIC']['nrec'], + 'nf_sub':self.params['QUBIC']['nsub'], + 'nside':self.params['Sky']['nside'], + 'MultiBand':True, + 'period':1, + 'RA_center':self.params['QUBIC']['RA_center'], + 'DEC_center':self.params['QUBIC']['DEC_center'], + 'filter_nu':nu_ave*1e9, + 'noiseless':False, + 'comm':self.comm, + 'dtheta':self.params['QUBIC']['dtheta'], + 'nprocs_sampling':1, + 'nprocs_instrument':self.size, + 'photon_noise':True, + 'nhwp_angles':self.params['QUBIC']['nhwp_angles'], + 'effective_duration':3, + 'filter_relative_bandwidth':delta_nu_over_nu, + 'type_instrument':'wide', + 'TemperatureAtmosphere150':None, + 'TemperatureAtmosphere220':None, + 'EmissivityAtmosphere150':None, + 'EmissivityAtmosphere220':None, + 'detector_nep':float(self.params['QUBIC']['detector_nep']), + 'synthbeam_kmax':self.params['QUBIC']['synthbeam_kmax']} + + args_mono = args.copy() + args_mono['nf_recon'] = 1 + args_mono['nf_sub'] = 1 + + ### Get the default dictionary + dictfilename = 'dicts/pipeline_demo.dict' + d = qubic.qubicdict.qubicDict() + d.read_from_file(dictfilename) + dmono = d.copy() + for i in args.keys(): + + d[str(i)] = args[i] + dmono[str(i)] = args_mono[i] + + + return d, dmono + def _get_convolution(self): + + """ + + Method to define expected QUBIC angular resolutions (radians) as function of frequencies. + + """ + + ### Define FWHMs + if self.params['QUBIC']['convolution']: + allfwhm = self.joint.qubic.allfwhm + targets = np.array([]) + for irec in range(self.params['QUBIC']['nrec']): + targets = np.append(targets, np.sqrt(allfwhm[irec*self.fsub:(irec+1)*self.fsub]**2 - np.min(allfwhm[irec*self.fsub:(irec+1)*self.fsub])**2)) + #targets = np.sqrt(allfwhm**2 - np.min(allfwhm)**2) + else: + targets = None + allfwhm = None + + return targets, allfwhm + def get_input_map(self): + m_nu_in = np.zeros((self.params['QUBIC']['nrec'], 12*self.params['Sky']['nside']**2, 3)) + + for i in range(self.params['QUBIC']['nrec']): + m_nu_in[i] = np.mean(self.external_timeline.m_nu[i*self.fsub:(i+1)*self.fsub], axis=0) + + return m_nu_in + def _get_tod(self): + + """ + + Method that compute observed TODs with TOD = H . s + n with H the QUBIC operator, s the sky signal and n the instrumental noise. + + """ + + if self.params['QUBIC']['type'] == 'wide': + if self.params['QUBIC']['nrec'] != 1: + TOD_PLANCK = np.zeros((self.params['QUBIC']['nrec'], 12*self.params['Sky']['nside']**2, 3)) + for irec in range(int(self.params['QUBIC']['nrec']/2)): + if self.params['QUBIC']['convolution']: + C = HealpixConvolutionGaussianOperator(fwhm=np.min(self.allfwhm[irec*self.fsub:(irec+1)*self.fsub])) + else: + C = HealpixConvolutionGaussianOperator(fwhm=0) + + TOD_PLANCK[irec] = C(self.external_timeline.maps[irec] + self.noise143) + + for irec in range(int(self.params['QUBIC']['nrec']/2), self.params['QUBIC']['nrec']): + if self.params['QUBIC']['convolution']: + C = HealpixConvolutionGaussianOperator(fwhm=np.min(self.allfwhm[irec*self.fsub:(irec+1)*self.fsub])) + else: + C = HealpixConvolutionGaussianOperator(fwhm=0) + + TOD_PLANCK[irec] = C(self.external_timeline.maps[irec] + self.noise217) + else: + TOD_PLANCK = np.zeros((2*self.params['QUBIC']['nrec'], 12*self.params['Sky']['nside']**2, 3)) + if self.params['QUBIC']['convolution']: + C = HealpixConvolutionGaussianOperator(fwhm=self.allfwhm[-1]) + else: + C = HealpixConvolutionGaussianOperator(fwhm=0) + + TOD_PLANCK[0] = C(self.external_timeline.maps[0] + self.noise143) + TOD_PLANCK[1] = C(self.external_timeline.maps[0] + self.noise217) + + TOD_PLANCK = TOD_PLANCK.ravel() + TOD_QUBIC = self.Hqtod(self.external_timeline.m_nu).ravel() + self.noiseq + TOD = np.r_[TOD_QUBIC, TOD_PLANCK] + + else: + + sh_q = self.joint.qubic.ndets * self.joint.qubic.nsamples + TOD_QUBIC = self.Hqtod(self.external_timeline.m_nu).ravel() + self.noiseq + + TOD_QUBIC150 = TOD_QUBIC[:sh_q].copy() + TOD_QUBIC220 = TOD_QUBIC[sh_q:].copy() + + TOD = TOD_QUBIC150.copy() + + TOD_PLANCK = np.zeros((self.params['QUBIC']['nrec'], 12*self.params['Sky']['nside']**2, 3)) + for irec in range(int(self.params['QUBIC']['nrec']/2)): + if self.params['QUBIC']['convolution']: + C = HealpixConvolutionGaussianOperator(fwhm=np.min(self.allfwhm[irec*self.fsub:(irec+1)*self.fsub])) + else: + C = HealpixConvolutionGaussianOperator(fwhm=0) + + TOD = np.r_[TOD, C(self.external_timeline.maps[irec] + self.noise143).ravel()] + + TOD = np.r_[TOD, TOD_QUBIC220.copy()] + for irec in range(int(self.params['QUBIC']['nrec']/2), self.params['QUBIC']['nrec']): + if self.params['QUBIC']['convolution']: + C = HealpixConvolutionGaussianOperator(fwhm=np.min(self.allfwhm[irec*self.fsub:(irec+1)*self.fsub])) + else: + C = HealpixConvolutionGaussianOperator(fwhm=0) + + TOD = np.r_[TOD, C(self.external_timeline.maps[irec] + self.noise217).ravel()] + + self.m_nu_in = self.get_input_map() + + return TOD + + def _barrier(self): + + """ + + Method to introduce comm.Barrier() function if MPI communicator is detected. + + """ + if self.comm is None: + pass + else: + self.comm.Barrier() + def print_message(self, message): + + """ + + Method to print message only on rank 0 if MPI communicator is detected. It display simple message if not. + + """ + + if self.comm is None: + print(message) + else: + if self.rank == 0: + print(message) + def _get_preconditionner(self): + + conditionner = np.ones((self.params['QUBIC']['nrec'], 12*self.params['Sky']['nside']**2, 3)) + + for i in range(conditionner.shape[0]): + for j in range(conditionner.shape[2]): + conditionner[i, :, j] = 1/self.coverage_cut + + return get_preconditioner(conditionner) + def _pcg(self, d): + + ''' + + Solve the map-making equation iteratively : H^T . N^{-1} . H . x = H^T . N^{-1} . d + + The PCG used for the minimization is intrinsequely parallelized (e.g see PyOperators). + + ''' + + + A = self.H.T * self.invN * self.H + b = self.H.T * self.invN * d + print(self.params) + ### Preconditionning + M = acq.get_preconditioner(np.ones(12*self.params['Sky']['nside']**2)) + #M = self._get_preconditionner() + #print("PRECONDITIONNER") + + ### PCG + start = time.time() + print(start) + solution_qubic_planck = pcg(A=A, + b=b, + comm=self.comm, + x0=self.m_nu_in, + M=M, + tol=self.params['PCG']['tol'], + disp=True, + maxiter=self.params['PCG']['maxiter'], + create_gif=self.params['PCG']['gif'], + center=self.center, + reso=self.params['QUBIC']['dtheta'], + seenpix=self.seenpix, + jobid=self.job_id) + + self._barrier() + + if self.params['PCG']['gif']: + do_gif(f'gif_convergence_{self.job_id}', solution_qubic_planck['nit'], self.job_id) + + if self.params['QUBIC']['nrec'] == 1: + solution_qubic_planck['x']['x'] = np.array([solution_qubic_planck['x']['x']]) + end = time.time() + execution_time = end - start + self.print_message(f'Simulation done in {execution_time:.3f} s') + + return solution_qubic_planck['x']['x'] + def save_data(self, name, d): + + """ + + Method to save data using pickle convention. + + """ + + with open(name, 'wb') as handle: + pickle.dump(d, handle, protocol=pickle.HIGHEST_PROTOCOL) + def run(self): + + """ + + Method to run the whole pipeline from TOD generation from sky reconstruction by reading `params.yml` file. + + """ + + self.print_message('\n=========== Map-Making ===========\n') + + ### Get simulated data + self.TOD = self._get_tod() + + ### Wait for all processes + self._barrier() + + ### Solve map-making equation + self.s_hat = self._pcg(self.TOD) + + ### Plots and saving + if self.rank == 0: + + self.save_data(self.file, {'maps':self.s_hat, 'nus':self.nus_Q, 'coverage':self.coverage, 'center':self.center, 'maps_in':self.m_nu_in, 'parameters':self.params}) + self.externaldata.run(fwhm=self.params['QUBIC']['convolution'], noise=True) + self.plots.plot_FMM(self.m_nu_in, self.s_hat, self.center, self.seenpix, self.nus_Q, job_id=self.job_id, istk=0, nsig=3, fwhm=0.0048) + self.plots.plot_FMM(self.m_nu_in, self.s_hat, self.center, self.seenpix, self.nus_Q, job_id=self.job_id, istk=1, nsig=3, fwhm=0.0048) + self.plots.plot_FMM(self.m_nu_in, self.s_hat, self.center, self.seenpix, self.nus_Q, job_id=self.job_id, istk=2, nsig=3, fwhm=0.0048) + + self._barrier() + +class PipelineCrossSpectrum: + + """ + + Instance to preform MCMC on multi-components theory on cross-spectrum. + + """ + + def __init__(self, file, fsky): + + with open('params.yml', "r") as stream: + self.params = yaml.safe_load(stream) + + with open('noise.yml', "r") as stream: + self.noise = yaml.safe_load(stream) + + self.file = file + self.sampler = Sampler(self.params) + self.plots = Plots() + self.fsky = fsky + + def _get_depth(self, nus): + + ''' + + Method to get sensitivity depth from `noise.yml` file. + + Arguments : + ----------- + - nus : list contains frequencies + + ''' + + with open('noise.yml', "r") as stream: + noise = yaml.safe_load(stream) + + res = [] + + for mynu in nus: + index = noise['Planck']['frequency'].index(mynu) if mynu in noise['Planck']['frequency'] else -1 + if index != -1: + d = noise['Planck']['depth_p'][index] + res.append(d) + else: + res.append(None) + + return res + def _read_data(self): + + ''' + + Method that read `data.pkl` file. + + ''' + + with open(self.file, 'rb') as f: + data = pickle.load(f) + return data['Dl'], np.concatenate((data['nus'], data['nus_ext']), axis=0), data['ell'], data['nus_ext'] + def _save_data(self, Dl, Dl_err): + + ''' + + Method that save new data into file `data.pkl`. + + Arguments : + ----------- + - Dl : array containing BB power spectrum. + - Dl_err : array containing errors on the BB power spectrum. + + ''' + + with open(self.file, 'wb') as handle: + pickle.dump({'nus':self.nus, + 'ell':self.ell, + 'Dl':Dl, + 'Dl_err':Dl_err}, handle, protocol=pickle.HIGHEST_PROTOCOL) + def _get_Dl_model(self, x): + + ''' + + Method that compute multi-components model from parameters. + + Arguments : + ----------- + - x : array of free parameters + + ''' + params_true = self.sky.update_params(x) + model_i = Sky(params_true, self.nus, self.ell) + return model_i.get_Dl(fsky=self.fsky) + def log_prior(self, x): + + ''' + + Method that compute prior on free parameters and stop convergence until parameters are not in the range. + + Arguments : + ----------- + - x : array of free parameters + + ''' + for iparam, param in enumerate(x): + if self.name_free_params[iparam] == 'r': + if param < -1 or param > 1: + return - np.inf + elif self.name_free_params[iparam] == 'Alens': + if 0 > param or param > 2: + return - np.inf + elif self.name_free_params[iparam] == 'Ad': + if 0 > param or param > 1e9: + return - np.inf + elif self.name_free_params[iparam] == 'As': + if param < -1 or param > 1e9: + return - np.inf + elif self.name_free_params[iparam] == 'betad': + if param < 1 or param > 2: + return - np.inf + elif self.name_free_params[iparam] == 'betas': + if param < -4 or param > -2: + return - np.inf + elif self.name_free_params[iparam] == 'alphad': + if param > 0 or param < -1: + return - np.inf + elif self.name_free_params[iparam] == 'alphas': + if param > 0 or param < -1: + return - np.inf + return 0 + def chi2(self, x): + + lp = self.log_prior(x) + Dl_model_i = self._get_Dl_model(x) + return lp - np.sum(((self.Dl[:self.params['Spectrum']['nbins']] - Dl_model_i[:self.params['Spectrum']['nbins']])/self.Dl_err[:self.params['Spectrum']['nbins']])**2) + def save_chain(self): + + ''' + + Method to save resulting chains coming from MCMC in pickle file. + + ''' + + save_pkl('output_chains.pkl', {'chain':self.chain, + 'chain_flat':self.flat_chain, + 'true_values':self.value_free_params, + 'true_names':self.name_free_params, + 'true_names_latex':self.name_latex_free_params}) + def run(self): + + ''' + + Method to run the cross-spectrum analysis. + + ''' + + print('\n=========== MCMC ===========\n') + + self.Dl, self.nus, self.ell, self.nus_ext = self._read_data() + + depths = np.array(list(np.array(self.noise['QUBIC']['depth_p'])) + list(self._get_depth(self.nus_ext))) + + noise = NoiseFromDl(self.ell, self.Dl, self.nus, depths, dl=self.params['Spectrum']['dl'], fsky=self.params['QUBIC']['fsky']) + self.Dl_err = noise.errorbar_theo() / 2 + #self.Dl_err = Noise(self.ell, depths)._get_errors() + + self.sky = Sky(self.params, self.nus, self.ell) + + self.plots.get_Dl_plot(self.ell[:self.params['Spectrum']['nbins']], self.Dl[:, :self.params['Spectrum']['nbins']], + self.Dl_err[:, :self.params['Spectrum']['nbins']], self.nus, model=self.sky.get_Dl()[:, :self.params['Spectrum']['nbins']]) + + #stop + ### Free values, name free parameters, latex name free parameters + self.value_free_params, self.name_free_params, self.name_latex_free_params = self.sky.make_list_free_parameter() + print(self.value_free_params, self.name_free_params) + + ### MCMC + self.chain, self.flat_chain = self.sampler.mcmc(self.value_free_params, self.chi2) + self.fitted_params, self.fitted_params_errors = np.mean(self.flat_chain, axis=0), np.std(self.flat_chain, axis=0) + + print(f'Fitted parameters : {self.fitted_params}') + print(f'Errors : {self.fitted_params_errors}') + + ### Save result chains + self.save_chain() + + ### Plots + self.plots.get_triangle(self.flat_chain, self.name_free_params, self.name_latex_free_params) + self.plots.get_convergence(self.chain) + +class PipelineEnd2End: + + """ + + Wrapper for End-2-End pipeline. It added class one after the others by running method.run(). + + """ + + def __init__(self, comm): + + with open('params.yml', "r") as stream: + self.params = yaml.safe_load(stream) + + self.comm = comm + self.job_id = np.random.randint(10000) + + create_folder_if_not_exists(self.comm, f'allplots_{self.job_id}') + + if not os.path.isdir(self.params['path_out']): + os.makedirs(self.params['path_out']) + file = self.params['path_out'] + self.params['Data']['datafilename']+f'_{self.job_id}.pkl' + + ### Initialization + + if self.params['QUBIC']['method'] == 'MM': + self.mapmaking = PipelineFrequencyMapMaking(self.comm, file) + self.spectrum = Spectrum(file, self.mapmaking.seenpix) + + elif self.params['QUBIC']['method'] == 'fake': + self.mapmaking = FakeFrequencyMapMaking(self.comm, file, fsky=self.params['QUBIC']['fsky']) + self.spectrum = Spectrum(file, self.mapmaking.seenpix) + + elif self.params['QUBIC']['method'] == 'spec': + self.spectrum = Spectrum(file, None) + self.mapmaking = MapMakingFromSpec(self.spectrum.ell, file, randomreal=self.params['QUBIC']['randomreal']) + + self.cross = PipelineCrossSpectrum(file, fsky=self.params['QUBIC']['fsky']) + + + def main(self): + + ### Execute Frequency Map-Making + self.mapmaking.run() + + ### Execute MCMC sampler + if self.params['Spectrum']['do_spectrum']: + if self.comm.Get_rank() == 0: + + ### Run -> compute Dl-cross + self.spectrum.run() + + self.comm.Barrier() + + if self.params['Sampler']['do_sampler']: + ### Run + self.cross.run() + + + + + + diff --git a/params.yml b/params.yml index 2cc7a20d2..1f8b81874 100644 --- a/params.yml +++ b/params.yml @@ -1,4 +1,5 @@ Method: 'FMM' +path_out: '/pbs/home/t/tlaclave/sps/Pipeline/data_with_convolution/DB_Nrec=4_Noise/' Sky: CMB: @@ -10,7 +11,7 @@ Sky: Foregrounds: # Thermal Dust emission - Dust: True + Dust: False nu0_d: 353 Ad: [4, 'nf', 'A_d', 4] betad: [1.54, 'nf', '\beta_d', 1.54] @@ -32,10 +33,10 @@ Sky: QUBIC: method: 'MM' # 'MM' for QUBIC map-making, 'fake' for fake map-making, 'spec' for spectrum based randomreal: True - npointings: 6000 - nsub: 16 - nrec: 8 - seed: 0 + npointings: 8000 + nsub: 12 + nrec: 4 + seed: 1 iteration: 1 ndet: 1 npho150: 1 @@ -43,11 +44,11 @@ QUBIC: synthbeam_kmax: 1 detector_nep: 4.7e-17 nhwp_angles: 3 - dtheta: 15 + dtheta: 30 type: 'two' covcut: 0.20 kappa: 0 - convolution: False + convolution: True bandpass_correction: True RA_center: 0 DEC_center: -57 @@ -56,20 +57,20 @@ QUBIC: fsky: 0.035 Spectrum: - do_spectrum: True + do_spectrum: False method: 'namaster' dl: 30 lmin: 40 aposize: 10 beam_correction: False pixwin_correction: False - noise_correction: False + noise_correction: True nbins: 10 PCG: - maxiter: 200 + maxiter: 400 tol: 1.0e-20 - gif: True + gif: False Sampler: do_sampler: False diff --git a/pipeline.py b/pipeline.py index 6507a9524..727c8f9d1 100644 --- a/pipeline.py +++ b/pipeline.py @@ -322,7 +322,6 @@ def _get_sky_config(self): sky = {} for ii, i in enumerate(self.params['Sky'].keys()): - #print(ii, i) if i == 'CMB': if self.params['Sky']['CMB']['cmb']: @@ -334,12 +333,10 @@ def _get_sky_config(self): seed = self.comm.bcast(seed, root=0) else: seed = self.params['QUBIC']['seed'] - #stop sky['cmb'] = seed else: for jj, j in enumerate(self.params['Sky']['Foregrounds']): - #print(j, self.params['Foregrounds'][j]) if j == 'Dust': if self.params['Sky']['Foregrounds'][j]: sky['dust'] = self.params['QUBIC']['dust_model'] @@ -364,7 +361,6 @@ def average_nus(self): nus_eff = [] f = int(self.nsub / self.nrec) for i in range(self.nrec): - #print(f'Doing average between {np.min(self.nus[i*f:(i+1)*f])} and {np.max(self.nus[i*f:(i+1)*f])} GHz') nus_eff += [np.mean(self.nus[i*f : (i+1)*f], axis=0)] return np.array(nus_eff) def _get_sig(self, depth): @@ -517,7 +513,6 @@ def _get_sky_config(self): else: seed = self.params['QUBIC']['seed'] - #stop sky['cmb'] = seed else: @@ -681,12 +676,12 @@ def __init__(self, comm, file): ### Define reconstructed and TOD operator self._get_H() - ### Inverse noise covariance matrix self.invN = self.joint.get_invntt_operator(mask=self.mask) ### Noises - seed_noise_planck = int(os.environ.get('SLURM_JOB_ID')) + seed_noise_planck = int(sys.argv[1]) + print('seed_noise_planck', seed_noise_planck) self.noise143 = self.planck_acquisition143.get_noise(seed_noise_planck) * self.params['Data']['level_planck_noise'] self.noise217 = self.planck_acquisition217.get_noise(seed_noise_planck+1) * self.params['Data']['level_planck_noise'] @@ -698,7 +693,8 @@ def __init__(self, comm, file): self.noiseq = qubic_noise.total_noise(self.params['QUBIC']['ndet'], self.params['QUBIC']['npho150'], - self.params['QUBIC']['npho220']).ravel() + self.params['QUBIC']['npho220'], + seed=seed_noise_planck).ravel() def _get_H(self): @@ -720,7 +716,6 @@ def _get_averaged_nus(self): """ nus_eff = [] - for i in range(self.params['QUBIC']['nrec']): nus_eff += [np.mean(self.joint.qubic.allnus[i*self.fsub:(i+1)*self.fsub])] @@ -751,7 +746,6 @@ def _get_sky_config(self): else: seed = self.params['QUBIC']['seed'] print(f'Seed of the CMB is {seed} for rank {self.rank}') - #stop sky['cmb'] = seed else: @@ -1256,7 +1250,9 @@ def __init__(self, comm): create_folder_if_not_exists(self.comm, f'allplots_{self.job_id}') self.job_id = os.environ.get('SLURM_JOB_ID') - file = self.params['Data']['datafilename']+f'_{self.job_id}.pkl' + if not os.path.isdir(self.params['path_out']): + os.makedirs(self.params['path_out']) + file = self.params['path_out'] + self.params['Data']['datafilename']+f'_{self.job_id}.pkl' ### Initialization @@ -1298,4 +1294,3 @@ def main(self): - diff --git a/sampling.py b/sampling.py deleted file mode 100644 index b75821ef2..000000000 --- a/sampling.py +++ /dev/null @@ -1,750 +0,0 @@ -#### General packages -import pickle -import os -import os.path as op -import numpy as np -import matplotlib.pyplot as plt -import scipy -import healpy as hp -import emcee -import yaml -from multiprocessing import Pool -from getdist import plots, MCSamples -import getdist -import time - -#### QUBIC packages -import qubic -from qubic import NamasterLib as nam -from qubicpack.utilities import Qubic_DataDir -from qubic import QubicSkySim as qss -from pysimulators import FitsArray -from qubic import fibtools as ft -from qubic import camb_interface as qc -from qubic import SpectroImLib as si -import mapmaking.systematics as acq -from qubic import mcmc -from qubic import AnalysisMC as amc -import fgb.component_model as c -import fgb.mixing_matrix as mm -from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator -from pipeline import * -from pyoperators import * - -#### Nested Sampling package -import dynesty -from dynesty import plotting as dyplot -from dynesty import NestedSampler -from dynesty import DynamicNestedSampler -from dynesty import utils as dyfunc - -class Data: - """ - Class to manipulate data from your simulations - """ - - def __init__(self): - - with open('sampling_config.yml', "r") as stream: - self.param = yaml.safe_load(stream) - self.config = self.param['simu']['qubic_config'] - self.path = self.param['data']['path'] - self.path_data = self.param['data']['path_data'] - self.path_noise = self.param['data']['path_noise'] - self.name = self.param['simu']['name'] - self.nrec = self.param['simu']['nrec'] - self.data = self.find_data() - self.nsub = self.data['parameters']['QUBIC']['nsub'] - self.nside = self.data['parameters']['Sky']['nside'] - self.fsub = int(self.nsub / self.nrec) - self.comm = MPI.COMM_WORLD - self.size = self.comm.Get_size() - - def find_data(self): - ''' - Function to extract the pickle file of one realisation. Useful to have access to the realisations' parameters - ''' - - data_names = os.listdir(self.path_data) - - data = pickle.load(open(self.path_data + '/' + data_names[0], 'rb')) - - return data - - def compute_data(self, path): - ''' - Function to compute the mean and std on your spectra - - Argument : - - name(str): CMB, Dust or Sky - ''' - - data_names = os.listdir(path) - - # Store the datas into arrays - ps_data = [] - map_data = [] - for realisation in range(0, self.param['data']['n_real']): - data = pickle.load(open(path + '/' + data_names[realisation], 'rb')) - ps_data.append(data['Dl']) - map_data.append(data['maps']) - ps_data = np.reshape(ps_data, [self.param['data']['n_real'],self.param['simu']['nrec'], self.param['simu']['nrec'], np.shape(data['Dl'][0])[0]]) - - self.nus = data['nus'] - - # Compute Mean & Error on each realisations of Noise & Sky's PSs - mean_data = np.mean(ps_data, axis = 0) - error_data = np.std(ps_data, axis = 0) - - return (mean_data, error_data, map_data) - - def auto_spectra_noise_reduction(self, mean_data, mean_noise): - ''' - Function to remove the mean of the noise realisations to the auto-spectra - ''' - - for i in range(self.param['simu']['nrec']): - mean_data[i, i, :] -= mean_noise[i, i, :] - - return mean_data - - def get_ultrawideband_config(self): - """ - Method that pre-compute UWB configuration. - """ - - nu_up = 247.5 - nu_down = 131.25 - nu_ave = np.mean(np.array([nu_up, nu_down])) - delta = nu_up - nu_ave - - return nu_ave, 2*delta/nu_ave - - def get_dict(self): - """ - Method to modify the qubic dictionary. - """ - - nu_ave, delta_nu_over_nu = self.get_ultrawideband_config() - params = self.data['parameters'] - - args = {'npointings':params['QUBIC']['npointings'], - 'nf_recon':params['QUBIC']['nrec'], - 'nf_sub':params['QUBIC']['nsub'], - 'nside':params['Sky']['nside'], - 'MultiBand':True, - 'period':1, - 'RA_center':params['QUBIC']['RA_center'], - 'DEC_center':params['QUBIC']['DEC_center'], - 'filter_nu':nu_ave*1e9, - 'noiseless':False, - 'comm':self.comm, - 'dtheta':params['QUBIC']['dtheta'], - 'nprocs_sampling':1, - 'nprocs_instrument':self.size, - 'photon_noise':True, - 'nhwp_angles':params['QUBIC']['nhwp_angles'], - 'effective_duration':3, - 'filter_relative_bandwidth':delta_nu_over_nu, - 'type_instrument':'wide', - 'TemperatureAtmosphere150':None, - 'TemperatureAtmosphere220':None, - 'EmissivityAtmosphere150':None, - 'EmissivityAtmosphere220':None, - 'detector_nep':float(params['QUBIC']['detector_nep']), - 'synthbeam_kmax':params['QUBIC']['synthbeam_kmax']} - - args_mono = args.copy() - args_mono['nf_recon'] = 1 - args_mono['nf_sub'] = 1 - - ### Get the default dictionary - dictfilename = 'dicts/pipeline_demo.dict' - d = qubic.qubicdict.qubicDict() - d.read_from_file(dictfilename) - dmono = d.copy() - for i in args.keys(): - - d[str(i)] = args[i] - dmono[str(i)] = args_mono[i] - - - return d, dmono - - def cross_sectra_convo(self, mean_sky, map_data): - ''' - FUnction that will compute the cross-spectra between each reconsructed sub-bands taking into accounts the different convolutions between each maps - ''' - - my_dict, _ = self.get_dict() - joint = acq.JointAcquisitionFrequencyMapMaking(my_dict, self.data['parameters']['QUBIC']['type'], self.data['parameters']['QUBIC']['nrec'], self.data['parameters']['QUBIC']['nsub']) - allfwhm = joint.qubic.allfwhm - _, namaster = NamasterEll().ell() - - for i in range(self.nrec): - for j in range(self.nrec): - if i != j: - for real in range(self.param['data']['n_real']): - cross_spect = [] - if allfwhm[i*self.fsub] self.sky_parameters[name][4]: - return - np.inf - elif name == 'Alens': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'Ad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'alphad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'betad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'deltad': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - elif name == 'nu0_d': - if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: - return - np.inf - return 0 - - def chi2(self, tab): - ''' - chi2 function - ''' - for iname in self.param['SKY_PARAMETERS']: - if iname == 'r': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - r = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'Alens': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - Alens = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'Ad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - Ad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'betad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - betad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'alphad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - alphad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'deltad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - deltad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'nu0_d': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - nu0_d = self.param['SKY_PARAMETERS'][iname][0] - - # Add the parameters you want to find - sky_parameters_names = self.sky_parameters_names - for isky_param, sky_param in enumerate(tab): - if sky_parameters_names[isky_param] == 'r': - r = sky_param - elif sky_parameters_names[isky_param] == 'Alens': - Alens = sky_param - elif sky_parameters_names[isky_param] == 'Ad': - Ad = sky_param - elif sky_parameters_names[isky_param] == 'betad': - betad = sky_param - elif sky_parameters_names[isky_param] == 'alphad': - alphad = sky_param - elif sky_parameters_names[isky_param] == 'deltad': - deltad = sky_param - elif sky_parameters_names[isky_param] == 'nu0_d': - nu0_d = sky_param - - # Return the chi2 function - if self.param['simu']['name'] == 'CMB': - return self.prior(tab) - 0.5 * np.sum(((self.mean_data - CMB(self.ell).model_cmb(r, Alens))/(self.error_noise))**2) - if self.param['simu']['name'] == 'Dust': - return self.prior(tab) - 0.5 * np.sum(((self.mean_data - Dust(self.ell).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_noise))**2) - if self.param['simu']['name'] == 'Sky': - return self.prior(tab) - 0.5 * np.sum(((self.mean_data - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell).model_dust(Ad, alphad, betad, deltad, nu0_d)))/(self.error_noise))**2) - - def __call__(self): - ''' - Funtion to perform the MCMC and save the results - ''' - - nwalkers = self.param['MCMC']['nwalkers'] - mcmc_steps = self.param['MCMC']['mcmc_steps'] - p0 = self.initial_conditions() - ell = self.ell - print(Data().find_data()['parameters']) - - with Pool() as pool: - sampler = emcee.EnsembleSampler(nwalkers, self.ndim, log_prob_fn = self.chi2, pool = pool, moves = [(emcee.moves.StretchMove(), self.param['MCMC']['stretch_move_factor']), (emcee.moves.DESnookerMove(gammas=self.param['MCMC']['snooker_move_gamma']), 1 - self.param['MCMC']['stretch_move_factor'])]) - sampler.run_mcmc(p0, mcmc_steps, progress=True) - - samples_flat = sampler.get_chain(flat = True, discard = self.param['MCMC']['discard'], thin = self.param['MCMC']['thin']) - samples = sampler.get_chain() - - # Plot the walkers - fig, ax = plt.subplots(1, self.ndim, figsize = (15, 5)) - for j in range(self.ndim): - for i in range(nwalkers): - ax[j].plot(samples[:, i, j]) - ax[j].set_title(self.sky_parameters_names[j]) - - config = self.param['simu']['qubic_config'] - nrec = self.param['simu']['nrec'] - n_real = self.param['data']['n_real'] - path_plot = f'{config}_Nrec={nrec}_plots_MCMC' - if not os.path.isdir(path_plot): - os.makedirs(path_plot) - plt.savefig(self.param['data']['path'] + path_plot + f'/walkers_plot_Nreal={n_real}') - - # Triangle plot - plt.figure() - s = MCSamples(samples=samples_flat, names=self.sky_parameters_names, labels=self.sky_parameters_names) - g = plots.get_subplot_plotter(width_inch=10) - g.triangle_plot([s], filled=True, title_limit=1) - for ax in g.subplots[:,0]: - ax.axvline(0, color='gray') - - path_plot_triangle = f'{config}_Nrec={nrec}_plots' - plt.savefig(self.param['data']['path'] + path_plot + f'/triangle_plot_Nreal={n_real}') - - # Data vs Fit plot - plt.figure() - mcmc_values = np.mean(samples_flat, axis=0) - parameters_values = [] - cpt=0 - for parameter in self.sky_parameters: - if self.sky_parameters[parameter][0] is True: - parameters_values.append(mcmc_values[cpt]) - cpt+=1 - else: - parameters_values.append(self.sky_parameters[parameter][0]) - Dl_mcmc = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2]) - plt.plot(self.ell[:5], Dl_mcmc[0][0][:5], label = 'MCMC') - plt.errorbar(self.ell[:5], self.mean_data[0][0][:5], self.error_data[0][0][:5], label = 'Data') - plt.legend() - plt.xlabel('l') - plt.ylabel('Dl') - plt.title('CMB + Dust spectrum') - plt.savefig(self.param['data']['path'] + path_plot + f'/Comparison_plot_Nreal={n_real}') - -class NestedSampling: - ''' - Class to perform Nested Sampling in our sky parameters - ''' - - def __init__(self): - - with open('sampling_config.yml', "r") as stream: - self.param = yaml.safe_load(stream) - self.ell, _ = NamasterEll().ell() - data = Data().find_data() - self.nus = data['nus'] - self.sky_parameters = self.param['SKY_PARAMETERS'] - self.ndim, self.sky_parameters_names, self.sky_parameters_all_names = self.ndim_and_parameters_names() - self.mean_data, self.error_noise, self.error_data = Data().get_data() - - def ndim_and_parameters_names(self): - ''' - Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of dimensions for it - ''' - - ndim = 0 - sky_parameters_names = [] - sky_parameters_all_names = [] - - for parameter in self.sky_parameters: - sky_parameters_all_names.append(parameter) - if self.sky_parameters[parameter][0] is True: - ndim += 1 - sky_parameters_names.append(parameter) - - return ndim, sky_parameters_names, sky_parameters_all_names - - def chi2(self, tab): - ''' - chi2 function - ''' - - for iname in self.param['SKY_PARAMETERS']: - if iname == 'r': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - r = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'Alens': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - Alens = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'Ad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - Ad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'betad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - betad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'alphad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - alphad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'deltad': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - deltad = self.param['SKY_PARAMETERS'][iname][0] - elif iname == 'nu0_d': - if self.param['SKY_PARAMETERS'][iname][0] is not True: - nu0_d = self.param['SKY_PARAMETERS'][iname][0] - - # Add the parameters you want to find - sky_parameters_names = self.sky_parameters_names - for isky_param, sky_param in enumerate(tab): - if sky_parameters_names[isky_param] == 'r': - r = sky_param - elif sky_parameters_names[isky_param] == 'Alens': - Alens = sky_param - elif sky_parameters_names[isky_param] == 'Ad': - Ad = sky_param - elif sky_parameters_names[isky_param] == 'betad': - betad = sky_param - elif sky_parameters_names[isky_param] == 'alphad': - alphad = sky_param - elif sky_parameters_names[isky_param] == 'deltad': - deltad = sky_param - elif sky_parameters_names[isky_param] == 'nu0_d': - nu0_d = sky_param - - # Return the chi2 function - if self.param['simu']['name'] == 'CMB': - return - 0.5 * np.sum(((self.mean_data - CMB(self.ell).model_cmb(r, Alens))/(self.error_noise))**2) - if self.param['simu']['name'] == 'Dust': - return - 0.5 * np.sum(((self.mean_data - Dust(self.ell).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_noise))**2) - if self.param['simu']['name'] == 'Sky': - return - 0.5 * np.sum(((self.mean_data - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell).model_dust(Ad, alphad, betad, deltad, nu0_d)))/(self.error_noise))**2) - - def ptform_uniform(self, u): - ptform = [] - - for iname in self.sky_parameters_all_names: - if self.param['SKY_PARAMETERS'][iname][0] is True: - ptform.append(u[0]*self.param['SKY_PARAMETERS'][iname][2] - self.param['SKY_PARAMETERS'][iname][1]) - return ptform - - def __call__(self): - ''' - Funtion to perform the MCMC and save the results - ''' - - nlive = self.param['NS']['nlive'] - ell = self.ell - print(Data().find_data()['parameters']) - - if self.param['NS']['DynamicNS'] is True: - print('Dynamic Nested Sampling !!!') - with Pool() as pool: - sampler_ns = DynamicNestedSampler(self.chi2, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param['NS']['queue_size'], bound=self.param['NS']['bound']) - sampler_ns.run_nested() - else: - with Pool() as pool: - print('Nested Sampling !') - sampler_ns = NestedSampler(self.chi2, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param['NS']['queue_size'], bound=self.param['NS']['bound']) - sampler_ns.run_nested() - - results = sampler_ns.results - - # Plot the traceplots - fig, axes = dyplot.traceplot(results, show_titles=True, labels = self.sky_parameters_names, - trace_cmap='viridis', connect=True, - connect_highlight=range(5)) - - config = self.param['simu']['qubic_config'] - nrec = self.param['simu']['nrec'] - n_real = self.param['data']['n_real'] - path_plot = f'{config}_Nrec={nrec}_plots_NS' - if not os.path.isdir(path_plot): - os.makedirs(path_plot) - plt.savefig(self.param['data']['path'] + path_plot + f'/traceplot_Nreal={n_real}') - - # Triangle plot - fig, axes = plt.subplots(3, 3) - axes = axes.reshape((3, 3)) - fg, ax = dyplot.cornerplot(results, color='blue', title_fmt = '.4f', show_titles=True, labels = self.sky_parameters_names, - max_n_ticks=3, quantiles=None, - fig=(fig, axes[:, :3])) - plt.savefig(self.param['data']['path'] + path_plot + f'/triangle_plot_Nreal={n_real}') - - # Data vs Fit plot - plt.figure() - samples, weights = results.samples, results.importance_weights() - mean_ns, cov_ns = dyfunc.mean_and_cov(samples, weights) - parameters_values = [] - cpt=0 - for parameter in self.sky_parameters: - if self.sky_parameters[parameter][0] is True: - parameters_values.append(mean_ns[cpt]) - cpt+=1 - else: - parameters_values.append(self.sky_parameters[parameter][0]) - Dl_ns = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2]) - plt.plot(self.ell[:5], Dl_ns[0][0][:5], label = 'NestedSampling') - plt.errorbar(self.ell[:5], self.mean_data[0][0][:5], self.error_data[0][0][:5], label = 'Data') - plt.legend() - plt.xlabel('l') - plt.ylabel('Dl') - plt.title('CMB + Dust spectrum') - plt.savefig(self.param['data']['path'] + path_plot + f'/Comparison_plot_Nreal={n_real}') - -with open('sampling_config.yml', "r") as stream: - param = yaml.safe_load(stream) - -if param['Method'] == 'MCMC': - MCMC()() -elif param['Method'] == 'NS': - NestedSampling()() -else: - print('Wrong sampling method') - - - - - - - - - - - - - - - diff --git a/sampling/sampling.py b/sampling/sampling.py new file mode 100644 index 000000000..66a638c0c --- /dev/null +++ b/sampling/sampling.py @@ -0,0 +1,960 @@ +#### General packages +import pickle +import os +import os.path as op +import sys +import numpy as np +import matplotlib.pyplot as plt +import scipy +import healpy as hp +import emcee +import yaml +from multiprocessing import Pool +from getdist import plots, MCSamples +import getdist +import time + +sys.path.append('/pbs/home/t/tlaclave/sps/Pipeline') + +#### QUBIC packages +import qubic +from qubic import NamasterLib as nam +from qubicpack.utilities import Qubic_DataDir +from qubic import QubicSkySim as qss +from pysimulators import FitsArray +from qubic import fibtools as ft +from qubic import camb_interface as qc +from qubic import SpectroImLib as si +import mapmaking.systematics as acq +from qubic import mcmc +from qubic import AnalysisMC as amc +import fgb.component_model as c +import fgb.mixing_matrix as mm +from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator +from pipeline import * +from pyoperators import * +#from preset.preset import * + +#### Nested Sampling packages +import dynesty +from dynesty import plotting as dyplot +from dynesty import NestedSampler +from dynesty import DynamicNestedSampler +from dynesty import utils as dyfunc + +class data: + ''' + Class to extract of the power spectra computed with spectrum.py and to compute useful things + ''' + + def __init__(self): + + with open('sampling_config.yml', "r") as stream: + self.param = yaml.safe_load(stream) + self.path_spectra = self.param['data']['path'] + self.power_spectra_sky, self.power_spectra_noise, self.simu_parameters, self.coverage = self.import_power_spectra(self.path_spectra) + self.nsub = self.simu_parameters['QUBIC']['nsub'] + self.nrec = self.simu_parameters['QUBIC']['nrec'] + self.nreal = self.param['data']['n_real'] + _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25) + _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25) + self.allnus = np.array(list(allnus150) + list(allnus220)) + self.nus = self.average_nus() + self.mean_ps_sky, self.error_ps_sky = self.compute_mean_std(self.power_spectra_sky) + self.mean_ps_noise, self.error_ps_noise = self.compute_mean_std(self.power_spectra_noise) + if self.param['simu']['noise'] is True: + self.mean_ps_sky = self.spectra_noise_correction(self.mean_ps_sky, self.mean_ps_noise) + + def import_power_spectra(self, path): + ''' + Function to import all the power spectra computed with spectrum.py and store in pickle files + + Argument : + - path (str) : path to indicate where the pkl files are + + Return : + - sky power spectra (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)] + - noise power spectra (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)] + - simulations parameters (dict) + - simulations coverage (array) + - bands frequencies for FMM (array) [nrec] + ''' + + power_spectra_sky, power_spectra_noise = [], [] + names = os.listdir(path) + for i in range(self.param['data']['n_real']): + ps = pickle.load(open(path + '/' + names[i], 'rb')) + power_spectra_sky.append(ps['sky_ps']) + power_spectra_noise.append(ps['noise_ps']) + return power_spectra_sky, power_spectra_noise, ps['parameters'], ps['coverage'] + + def average_nus(self): + + nus_eff = [] + f = int(self.nsub / self.nrec) + for i in range(self.nrec): + nus_eff += [np.mean(self.allnus[i*f : (i+1)*f], axis=0)] + return np.array(nus_eff) + + def compute_mean_std(self, ps): + ''' + Function to compute the mean ans the std on our power spectra realisations + + Argument : + - power spectra array (array) [nreal, nrec/ncomp, nrec/ncomp, len(ell)] + + Return : + - mean (array) [nrec/ncomp, nrec/ncomp, len(ell)] + - std (array) [nrec/ncomp, nrec/ncomp, len(ell)] + ''' + + return np.mean(ps, axis = 0), np.std(ps, axis = 0) + + def spectra_noise_correction(self, mean_data, mean_noise): + ''' + Function to remove the mean of the noise realisations to the spectra computed + + Arguments : + - mean sky power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] : array that will contain the mean of all the auto and cross spectra of the sky realisations + - mean noise power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] : array that will contain the mean of all the auto and cross spectra of the noise realisation + + Return : + - corrected mean sky power spectra (array) [nrec/ncomp, nrec/ncomp, len(ell)] + ''' + + for i in range(np.shape(mean_data)[0]): + for j in range(np.shape(mean_data)[1]): + #if i==j: + mean_data[i, j, :] -= mean_noise[i, j, :] + return mean_data + + +class NamasterEll(data): + ''' + Class to compute the ell list using NamasterLib + ''' + + def __init__(self): + + with open('sampling_config.yml', "r") as stream: + self.param_sampling = yaml.safe_load(stream) + data.__init__(self) + + def ell(self): + + nside = self.simu_parameters['Sky']['nside'] + + # Call the Namaster class & create the ell list + seenpix = self.coverage/np.max(self.coverage) < 0.2 + lmin, lmax, delta_ell = self.simu_parameters['Spectrum']['lmin'], 2*nside-1, self.simu_parameters['Spectrum']['dl'] + namaster = nam.Namaster(weight_mask = list(~np.array(seenpix)), lmin = lmin, lmax = lmax, delta_ell = delta_ell) + + ell = namaster.get_binning(nside)[0] + + return ell, namaster + + +class CMB: + ''' + Class to define the CMB model + ''' + + def __init__(self, ell): + + self.ell = ell + + def cl_to_dl(self, cl): + ''' + Function to convert the cls into the dls + ''' + + dl = np.zeros(self.ell.shape[0]) + for i in range(self.ell.shape[0]): + dl[i] = (self.ell[i]*(self.ell[i]+1)*cl[i])/(2*np.pi) + return dl + + def get_pw_from_planck(self, r, Alens): + ''' + Function to compute the CMB power spectrum from the Planck data + ''' + + CMB_CL_FILE = op.join('/sps/qubic/Users/TomLaclavere/mypackages/Cls_Planck2018_%s.fits') + power_spectrum = hp.read_cl(CMB_CL_FILE%'lensed_scalar')[:,:4000] + + if Alens != 1.: + power_spectrum[2] *= Alens + + if r: + power_spectrum += r * hp.read_cl(CMB_CL_FILE%'unlensed_scalar_and_tensor_r1')[:,:4000] + + return np.interp(self.ell, np.linspace(1, 4001, 4000), power_spectrum[2]) + + def model_cmb(self, r, Alens): + ''' + Define the CMB model, depending on r and Alens + ''' + + dlBB = self.cl_to_dl(self.get_pw_from_planck(r, Alens)) + return dlBB + + +class Dust: + ''' + Function to define the Dust model + ''' + + def __init__(self, ell, nus): + + self.ell = ell + self.nus = nus + self.nrec = len(self.nus) + + def scale_dust(self, nu, nu0_d, betad, temp=20): + ''' + Function to compute the dust mixing matrix element, depending on the frequency + ''' + + comp = c.Dust(nu0 = nu0_d, temp=temp, beta_d = betad) + A = mm.MixingMatrix(comp).evaluator(np.array([nu]))()[0] + + return A + + def fnus_dust(self, nus, nu0_d, betad): + ''' + Function to compute the mixing matrix elements for all the frequencies considered in your realisations + ''' + + fnus = np.zeros(self.nrec) + for nu_index in range(self.nrec): + fnus[nu_index] = self.scale_dust(nus[nu_index], nu0_d, betad) + + return fnus + + def model_dust_frequency(self, Ad, alphad, deltad, fnu1, fnu2): + ''' + Function to define the Dust model for two frequencies + ''' + + return Ad * deltad * fnu1 * fnu2 * (self.ell/80)**alphad + + def model_dust(self, Ad, alphad, betad, deltad, nu0_d): + ''' + Function defining the Dust model for all frequencies, depending on Ad, alphad, betad, deltad & nu0_d + ''' + + fnus = self.fnus_dust(self.nus, nu0_d, betad) + + models = np.zeros((self.nrec, self.nrec, len(self.ell))) + for i in range(self.nrec): + for j in range(self.nrec): + models[i][j][:] = self.model_dust_frequency(Ad, alphad, deltad, fnus[i], fnus[j]) + return models + + +class Fitting(data): + ''' + Class to perform MCMC on the chosen sky parameters + ''' + + def __init__(self): + + with open('sampling_config.yml', "r") as stream: + self.param_sampling = yaml.safe_load(stream) + data.__init__(self) + self.ell, _ = NamasterEll().ell() + self.sky_parameters = self.param_sampling['SKY_PARAMETERS'] + self.ndim, self.sky_parameters_fitted_names, self.sky_parameters_all_names = self.ndim_and_parameters_names() + + if self.param_sampling['Loglike'] == 'cov' or 'fullcov': + reshaped_noise_ps = np.reshape(self.power_spectra_noise, (self.nrec, self.nrec, self.nreal, len(self.ell))) + self.noise_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell))) + for i in range(self.nrec): + for j in range(self.nrec): + self.noise_cov_matrix[i, j] = np.cov(reshaped_noise_ps[i,j], rowvar = False) + + def ndim_and_parameters_names(self): + ''' + Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of these parameters + + Return : + - ndim (int) : number of parameters you want to fit + - sky_parameters_fitted_names (array) [ndim] : list that contains the names of the fitted parameters + - sky_parameters_all_names (array) : list that contains the names of all the sky parameters + ''' + + ndim = 0 + sky_parameters_fitted_names = [] + sky_parameters_all_names = [] + + for parameter in self.sky_parameters: + sky_parameters_all_names.append(parameter) + if self.sky_parameters[parameter][0] is True: + ndim += 1 + sky_parameters_fitted_names.append(parameter) + + return ndim, sky_parameters_fitted_names, sky_parameters_all_names + + def initial_conditions(self): + ''' + Function to computes the MCMC initial conditions + + Return : + - p0 (array) [nwalkers, ndim] : array that contains all the initial conditions for the mcmc + ''' + + nwalkers = self.param_sampling['MCMC']['nwalkers'] + + p0 = np.zeros((nwalkers, self.ndim)) + for i in range(nwalkers): + for j in range(self.ndim): + name = self.sky_parameters_fitted_names[j] + p0[i,j] = np.random.random() * self.param_sampling['SKY_PARAMETERS'][name][2] - self.param_sampling['SKY_PARAMETERS'][name][1] + + return p0 + + def dl_to_cl(self, dl): + cl = np.zeros(self.ell.shape[0]) + for i in range(self.ell.shape[0]): + cl[i] = dl[i]*(2*np.pi)/(self.ell[i]*(self.ell[i] + 1)) + return cl + + def knox_errors(self, clth): + dcl = np.sqrt(2. / (2 * self.ell + 1) / self.simu_parameters['QUBIC']['fsky'] / self.simu_parameters['Spectrum']['dl']) * clth + return dcl + + def knox_covariance(self, clth): + dcl = self.knox_errors(clth) + return np.diag(dcl ** 2) + + def prior(self, x): + ''' + Function to define priors to help the MCMC convergence + + Argument : + - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc + + Return : + - (float) : inf if the prior is not respected, 0 otherwise + ''' + + for isky_param, sky_param in enumerate(x): + name = self.sky_parameters_fitted_names[isky_param] + + if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: + return - np.inf + + return 0 + + def initial_conditions(self): + ''' + Function to computes the MCMC initial conditions + + Return : + - p0 (array) [nwalkers, ndim] : array that contains all the initial conditions for the mcmc + ''' + + nwalkers = self.param_sampling['MCMC']['nwalkers'] + + p0 = np.zeros((nwalkers, self.ndim)) + for i in range(nwalkers): + for j in range(self.ndim): + name = self.sky_parameters_fitted_names[j] + p0[i,j] = np.random.random() * self.param_sampling['SKY_PARAMETERS'][name][2] - self.param_sampling['SKY_PARAMETERS'][name][1] + + return p0 + + def ptform_uniform(self, u): + ''' + Function to perform an uniform prior transform for the Nested Sampling + + Argument : + - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc + + Return : + - ptform (array) [ndim] + ''' + + ptform = [] + cpt = 0 + for iname in self.sky_parameters_all_names: + if self.param_sampling['SKY_PARAMETERS'][iname][0] is True: + ptform.append(u[cpt]*self.param_sampling['SKY_PARAMETERS'][iname][2] - self.param_sampling['SKY_PARAMETERS'][iname][1]) + cpt += 1 + return ptform + + def loglikelihood(self, tab): + ''' + loglikelihood function + + Argument : + - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc + + Return : + - (float) : loglikelihood function + ''' + tab_parameters = np.zeros(len(self.param_sampling['SKY_PARAMETERS'])) + cpt = 0 + + for i, iname in enumerate(self.param_sampling['SKY_PARAMETERS']): + if self.param_sampling['SKY_PARAMETERS'][iname][0] is not True: + tab_parameters[i] = self.param_sampling['SKY_PARAMETERS'][iname][0] + else: + tab_parameters[i] = tab[cpt] + cpt += 1 + + r, Alens, nu0_d, Ad, alphad, betad, deltad = tab_parameters + if self.param_sampling['simu']['noise'] == False: + loglike = self.prior(tab) + for i in range(self.nrec): + for j in range(self.nrec): + loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]) + #loglike = self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))**2) + return loglike + + if self.param_sampling['simu']['name'] == 'CMB': + return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - CMB(self.ell).model_cmb(r, Alens))/(self.error_ps_noise))**2) + if self.param_sampling['simu']['name'] == 'Dust': + return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_ps_noise))**2) + if self.param_sampling['simu']['name'] == 'Sky': + loglike = self.prior(tab) + if self.param_sampling['Loglike'] == 'fullcov': + + clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens) + sample_cov_cmb = self.knox_covariance(clth_cmb) + dlth_dust = Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d) + for i in range(self.nrec): + for j in range(self.nrec): + clth_dust = self.dl_to_cl(dlth_dust[i][j]) + sample_cov_dust = self.knox_covariance(clth_dust) + cov_matrix = self.noise_cov_matrix[i][j] + sample_cov_cmb + sample_cov_dust + inv_cov_matrix = np.linalg.pinv(cov_matrix) + loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]) + return loglike + if self.param_sampling['Loglike'] == 'cov': + + clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens) + sample_cov_cmb = self.knox_covariance(clth_cmb) + for i in range(self.nrec): + for j in range(self.nrec): + cov_matrix = self.noise_cov_matrix[i][j] + sample_cov_cmb + inv_cov_matrix = np.linalg.pinv(cov_matrix) + loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]) + return loglike + if self.param_sampling['Loglike'] == 'diag' : + for i in range(self.nrec): + for j in range(self.nrec): + loglike += - 0.5 * ((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))[i][j]/(self.error_ps_noise[i][j]))**2 + return loglike + + def MCMC(self): + ''' + Funtion to perform the MCMC and save the results + ''' + + # Define the MCMC parameters, initial conditions and ell list + nwalkers = self.param_sampling['MCMC']['nwalkers'] + mcmc_steps = self.param_sampling['MCMC']['mcmc_steps'] + p0 = self.initial_conditions() + ell = self.ell + + print(self.simu_parameters) + + # Start the MCMC + with Pool() as pool: + sampler = emcee.EnsembleSampler(nwalkers, self.ndim, log_prob_fn = self.loglikelihood, pool = pool, moves = [(emcee.moves.StretchMove(), self.param_sampling['MCMC']['stretch_move_factor']), (emcee.moves.DESnookerMove(gammas=self.param_sampling['MCMC']['snooker_move_gamma']), 1 - self.param_sampling['MCMC']['stretch_move_factor'])]) + sampler.run_mcmc(p0, mcmc_steps, progress=True) + + samples_flat = sampler.get_chain(flat = True, discard = self.param_sampling['MCMC']['discard'], thin = self.param_sampling['MCMC']['thin']) + samples = sampler.get_chain() + + # Plot the walkers + fig, ax = plt.subplots(1, self.ndim, figsize = (15, 5)) + for j in range(self.ndim): + for i in range(nwalkers): + ax[j].plot(samples[:, i, j]) + ax[j].set_title(self.sky_parameters_fitted_names[j]) + + name = self.param_sampling['data']['name'] + config = self.param_sampling['simu']['qubic_config'] + nrec = self.param_sampling['simu']['nrec'] + n_real = self.param_sampling['data']['n_real'] + convo = self.param_sampling['simu']['convo'] + loglike = self.param_sampling['Loglike'] + path_plot = f'{name}_{config}_Nrec={nrec}_Loglike={loglike}_Convolution={convo}_plots_MCMC' + if not os.path.isdir(path_plot): + os.makedirs(path_plot) + fig.suptitle(f'Walkers plot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/walkers_plot_Nreal={n_real}') + + mcmc_values = np.mean(samples_flat, axis=0) + parameters_values = [] + cpt=0 + for parameter in self.sky_parameters: + if self.sky_parameters[parameter][0] is True: + parameters_values.append(mcmc_values[cpt]) + cpt+=1 + else: + parameters_values.append(self.sky_parameters[parameter][0]) + r, Alens, nu0_d, Ad, alphad, betad, deltad = parameters_values + + if self.param_sampling['Loglike'] == 'fullcov': + cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell))) + inv_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell))) + error_bar = np.zeros((self.nrec, self.nrec, len(self.ell))) + clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens) + dlth_dust = Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d) + sample_cov_cmb = self.knox_covariance(clth_cmb) + for i in range(self.nrec): + for j in range(self.nrec): + clth_dust = self.dl_to_cl(dlth_dust[i][j]) + sample_cov_dust = self.knox_covariance(clth_dust) + cov_matrix[i][j] = self.noise_cov_matrix[i][j] + sample_cov_cmb + sample_cov_dust + inv_cov_matrix[i][j] = np.linalg.pinv(cov_matrix[i][j]) + error_bar[i][j] = np.diag(cov_matrix[i][j]) + if self.param_sampling['Loglike'] == 'fullcov': + cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell))) + inv_cov_matrix = np.zeros((self.nrec, self.nrec, len(self.ell), len(self.ell))) + error_bar = np.zeros((self.nrec, self.nrec, len(self.ell))) + clth_cmb = CMB(self.ell).get_pw_from_planck(r, Alens) + sample_cov_cmb = self.knox_covariance(clth_cmb) + for i in range(self.nrec): + for j in range(self.nrec): + cov_matrix[i][j] = self.noise_cov_matrix[i][j] + sample_cov_cmb + inv_cov_matrix[i][j] = np.linalg.pinv(cov_matrix[i][j]) + error_bar[i][j] = np.diag(cov_matrix[i][j]) + if self.param_sampling['Loglike'] == 'diag': + error_bar = self.error_ps_noise + + # Triangle plot + plt.figure() + s = MCSamples(samples=samples_flat, names=self.sky_parameters_fitted_names, labels=self.sky_parameters_fitted_names) + g = plots.get_subplot_plotter(width_inch=10) + g.triangle_plot([s], filled=True, title_limit=1) + for ax in g.subplots[:,0]: + ax.axvline(0, color='gray') + + path_plot_triangle = f'{config}_Nrec={nrec}_plots' + #fig.suptitle(f'Triangle plot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}') + + # Data vs Fit plot + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + + Dl_mcmc = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2]) + Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.05, parameters_values[5], parameters_values[6], parameters_values[2]) + + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.05') + axes[x,y].plot(self.ell[:5], Dl_mcmc[x][y][:5], label = 'MCMC') + axes[x,y].plot(self.ell[:5], self.mean_ps_sky[x][y][:5], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}') + + + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.05') + axes[x,y].plot(self.ell, Dl_mcmc[x][y], label = 'MCMC') + axes[x,y].plot(self.ell, self.mean_ps_sky[x][y], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}') + + + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.05') + axes[x,y].plot(self.ell, Dl_mcmc[x][y], label = 'MCMC') + axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], error_bar[x][y], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_error_extended_Nreal={n_real}') + + + def nested_sampling(self): + ''' + Funtion to perform the Nested Sampling and save the results + ''' + + nlive = self.param_sampling['NS']['nlive'] + maxiter = self.param_sampling['NS']['maxiter'] + ell = self.ell + print(self.simu_parameters) + + if self.param_sampling['NS']['DynamicNS'] is True: + print('Dynamic Nested Sampling !!!') + with Pool() as pool: + sampler_ns = DynamicNestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound']) + sampler_ns.run_nested(print_progress=True, maxiter = maxiter) + else: + print('Nested Sampling !') + with Pool() as pool: + sampler_ns = NestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound']) + sampler_ns.run_nested(maxiter = maxiter) + + results = sampler_ns.results + + # Plot the traceplots + fig, axes = dyplot.traceplot(results, show_titles=True, labels = self.sky_parameters_fitted_names, + trace_cmap='viridis', connect=True, + connect_highlight=range(5)) + + config = self.param_sampling['simu']['qubic_config'] + nrec = self.param_sampling['simu']['nrec'] + n_real = self.param_sampling['data']['n_real'] + convo = self.param_sampling['simu']['convo'] + name = self.param_sampling['data']['name'] + loglike = self.param_sampling['Loglike'] + if self.param_sampling['NS']['DynamicNS'] is True: + path_plot = f'{name}_{config}_Nrec={nrec}_Loglike={loglike}_Convolution={convo}_plots_DynamicNS' + else: + path_plot = f'{name}_{config}_Nrec={nrec}_Loglike={loglike}_Convolution={convo}_plots_NS' + if not os.path.isdir(path_plot): + os.makedirs(path_plot) + #plt.title(f'Traceplot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/traceplot_Nreal={n_real}') + + # Runplots + fig, axes = dyplot.runplot(results) + #plt.title(f'Runplot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/runplot_Nreal={n_real}') + + + # Triangle plot + fig, axes = plt.subplots(3, 3) + axes = axes.reshape((3, 3)) + fg, ax = dyplot.cornerplot(results, color='blue', title_fmt = '.4f', show_titles=True, labels = self.sky_parameters_fitted_names, + max_n_ticks=3, quantiles=None, + fig=(fig, axes[:, :3])) + #fig.suptitle(f'Triangleplot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}') + + # Data vs Fit plot + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + samples, weights = results.samples, results.importance_weights() + mean_ns, cov_ns = dyfunc.mean_and_cov(samples, weights) + parameters_values = [] + cpt=0 + for parameter in self.sky_parameters: + if self.sky_parameters[parameter][0] is True: + parameters_values.append(mean_ns[cpt]) + cpt+=1 + else: + parameters_values.append(self.sky_parameters[parameter][0]) + Dl_ns = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2]) + Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.15, parameters_values[5], parameters_values[6], parameters_values[2]) + + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.15') + axes[x,y].plot(self.ell[:5], Dl_ns[x][y][:5], label = 'NS') + axes[x,y].errorbar(self.ell[:5], self.mean_ps_sky[x][y][:5], self.error_ps_sky[x][y][:5], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}') + + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.15') + axes[x,y].plot(self.ell, Dl_ns[x][y], label = 'NS') + axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], self.error_ps_sky[x][y], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}') + + +class NestedSampling(data): + ''' + Class to perform Nested Sampling in our sky parameters + ''' + + def __init__(self): + + with open('sampling_config.yml', "r") as stream: + self.param_sampling = yaml.safe_load(stream) + data.__init__(self) + self.ell, _ = NamasterEll().ell() + self.sky_parameters = self.param_sampling['SKY_PARAMETERS'] + self.ndim, self.sky_parameters_fitted_names, self.sky_parameters_all_names = self.ndim_and_parameters_names() + + if self.param_sampling['Loglike'] == 'cov' : + reshaped_noise_ps = np.reshape(self.power_spectra_noise, (self.nrec, self.nrec, self.nreal, 16)) + self.noise_cov_matrix = np.zeros((self.nrec, self.nrec, 16, 16)) + for i in range(self.nrec): + for j in range(self.nrec): + self.noise_cov_matrix[i, j] = np.cov(reshaped_noise_ps[i,j], rowvar = False) + + def ndim_and_parameters_names(self): + ''' + Function to create the name list of the parameter(s) that you want to find with the MCMC and to compute the number of these parameters + + Return : + - ndim (int) : number of parameters you want to fit + - sky_parameters_fitted_names (array) [ndim] : list that contains the names of the fitted parameters + - sky_parameters_all_names (array) : list that contains the names of all the sky parameters + ''' + + ndim = 0 + sky_parameters_fitted_names = [] + sky_parameters_all_names = [] + + for parameter in self.sky_parameters: + sky_parameters_all_names.append(parameter) + if self.sky_parameters[parameter][0] is True: + ndim += 1 + sky_parameters_fitted_names.append(parameter) + + return ndim, sky_parameters_fitted_names, sky_parameters_all_names + + def initial_conditions(self): + ''' + Function to computes the MCMC initial conditions + + Return : + - p0 (array) [nwalkers, ndim] : array that contains all the initial conditions for the mcmc + ''' + + nwalkers = self.param_sampling['MCMC']['nwalkers'] + + p0 = np.zeros((nwalkers, self.ndim)) + for i in range(nwalkers): + for j in range(self.ndim): + name = self.sky_parameters_fitted_names[j] + p0[i,j] = np.random.random() * self.param_sampling['SKY_PARAMETERS'][name][2] - self.param_sampling['SKY_PARAMETERS'][name][1] + + return p0 + + def prior(self, x): + ''' + Function to define priors to help the MCMC convergence + + Argument : + - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc + + Return : + - (float) : inf if the prior is not respected, 0 otherwise + ''' + + for isky_param, sky_param in enumerate(x): + name = self.sky_parameters_fitted_names[isky_param] + + if sky_param < self.sky_parameters[name][3] or sky_param > self.sky_parameters[name][4]: + return - np.inf + + return 0 + + def loglikelihood(self, tab): + ''' + loglikelihood function + + Argument : + - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc + + Return : + - (float) : loglikelihood function + ''' + tab_parameters = np.zeros(len(self.param_sampling['SKY_PARAMETERS'])) + cpt = 0 + + for i, iname in enumerate(self.param_sampling['SKY_PARAMETERS']): + if self.param_sampling['SKY_PARAMETERS'][iname][0] is not True: + tab_parameters[i] = self.param_sampling['SKY_PARAMETERS'][iname][0] + else: + tab_parameters[i] = tab[cpt] + cpt += 1 + + r, Alens, nu0_d, Ad, alphad, betad, deltad = tab_parameters + if self.param_sampling['simu']['noise'] == False: + loglike = self.prior(tab) + for i in range(self.nrec): + for j in range(self.nrec): + loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]) + #loglike = self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))**2) + return loglike + + if self.param_sampling['simu']['name'] == 'CMB': + return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - CMB(self.ell).model_cmb(r, Alens))/(self.error_ps_noise))**2) + if self.param_sampling['simu']['name'] == 'Dust': + return self.prior(tab) - 0.5 * np.sum(((self.mean_ps_sky - Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))/(self.error_ps_noise))**2) + if self.param_sampling['simu']['name'] == 'Sky': + loglike = self.prior(tab) + if self.param_sampling['Loglike'] == 'cov': + clth = CMB(self.ell).model_cmb(r, Alens) + sample_cov = CMB(self.ell).knox_covariance(clth) + cov_matrix = self.noise_cov_matrix + sample_cov + inv_cov_matrix = np.linalg.pinv(cov_matrix) + for i in range(self.nrec): + for j in range(self.nrec): + loglike += - 0.5 * (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]).T @ inv_cov_matrix[i][j] @ (self.mean_ps_sky[i][j] - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d))[i][j]) + return loglike + else: + loglike += - 0.5 * np.sum(((self.mean_ps_sky - (CMB(self.ell).model_cmb(r, Alens) + Dust(self.ell, self.nus).model_dust(Ad, alphad, betad, deltad, nu0_d)))/(self.error_ps_noise))**2) + return loglike + + def ptform_uniform(self, u): + ''' + Function to perform an uniform prior transform for the Nested Sampling + + Argument : + - x (array) [ndim] : array that contains the numbers randomly generated by the mcmc + + Return : + - ptform (array) [ndim] + ''' + + ptform = [] + cpt = 0 + for iname in self.sky_parameters_all_names: + if self.param_sampling['SKY_PARAMETERS'][iname][0] is True: + ptform.append(u[cpt]*self.param_sampling['SKY_PARAMETERS'][iname][2] - self.param_sampling['SKY_PARAMETERS'][iname][1]) + cpt += 1 + return ptform + + def __call__(self): + ''' + Funtion to perform the Nested Sampling and save the results + ''' + + nlive = self.param_sampling['NS']['nlive'] + maxiter = self.param_sampling['NS']['maxiter'] + ell = self.ell + print(self.simu_parameters) + + if self.param_sampling['NS']['DynamicNS'] is True: + print('Dynamic Nested Sampling !!!') + with Pool() as pool: + sampler_ns = DynamicNestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound']) + sampler_ns.run_nested(print_progress=True, maxiter = maxiter) + else: + print('Nested Sampling !') + with Pool() as pool: + sampler_ns = NestedSampler(self.loglikelihood, self.ptform_uniform, self.ndim, pool = pool, nlive = nlive, queue_size=self.param_sampling['NS']['queue_size'], bound=self.param_sampling['NS']['bound']) + sampler_ns.run_nested(maxiter = maxiter) + + results = sampler_ns.results + + # Plot the traceplots + fig, axes = dyplot.traceplot(results, show_titles=True, labels = self.sky_parameters_fitted_names, + trace_cmap='viridis', connect=True, + connect_highlight=range(5)) + + config = self.param_sampling['simu']['qubic_config'] + nrec = self.param_sampling['simu']['nrec'] + n_real = self.param_sampling['data']['n_real'] + convo = self.param_sampling['simu']['convo'] + name = self.param_sampling['data']['name'] + if self.param_sampling['Loglike'] == "cov": + loglike = 'Cov' + else : + loglike = 'Diag' + if self.param_sampling['NS']['DynamicNS'] is True: + path_plot = f'{name}_{config}_Nrec={nrec}_Loglike={loglike}_Convolution={convo}_plots_DynamicNS' + else: + path_plot = f'{name}_{config}_Nrec={nrec}_Loglike={loglike}_Convolution={convo}_plots_NS' + if not os.path.isdir(path_plot): + os.makedirs(path_plot) + #plt.title(f'Traceplot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/traceplot_Nreal={n_real}') + + # Runplots + fig, axes = dyplot.runplot(results) + #plt.title(f'Runplot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/runplot_Nreal={n_real}') + + + # Triangle plot + fig, axes = plt.subplots(3, 3) + axes = axes.reshape((3, 3)) + fg, ax = dyplot.cornerplot(results, color='blue', title_fmt = '.4f', show_titles=True, labels = self.sky_parameters_fitted_names, + max_n_ticks=3, quantiles=None, + fig=(fig, axes[:, :3])) + #fig.suptitle(f'Triangleplot - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/triangle_plot_Nreal={n_real}') + + # Data vs Fit plot + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + samples, weights = results.samples, results.importance_weights() + mean_ns, cov_ns = dyfunc.mean_and_cov(samples, weights) + parameters_values = [] + cpt=0 + for parameter in self.sky_parameters: + if self.sky_parameters[parameter][0] is True: + parameters_values.append(mean_ns[cpt]) + cpt+=1 + else: + parameters_values.append(self.sky_parameters[parameter][0]) + Dl_ns = CMB(self.ell).model_cmb(parameters_values[0], parameters_values[1]) + Dust(self.ell, self.nus).model_dust(parameters_values[3], parameters_values[4], parameters_values[5], parameters_values[6], parameters_values[2]) + Dl_test = CMB(self.ell).model_cmb(0, 1) + Dust(self.ell, self.nus).model_dust(10, -0.15, parameters_values[5], parameters_values[6], parameters_values[2]) + + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell[:5], Dl_test[x][y][:5], label = 'Model test : r=0, Ad=10, alphad=-0.15') + axes[x,y].plot(self.ell[:5], Dl_ns[x][y][:5], label = 'NS') + axes[x,y].errorbar(self.ell[:5], self.mean_ps_sky[x][y][:5], self.error_ps_sky[x][y][:5], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_Nreal={n_real}') + + fig, axes = plt.subplots(self.nrec, self.nrec, figsize = (10,8)) + for x in range(self.nrec): + for y in range(self.nrec): + axes[x,y].plot(self.ell, Dl_test[x][y], label = 'Model test : r=0, Ad=10, alphad=-0.15') + axes[x,y].plot(self.ell, Dl_ns[x][y], label = 'NS') + axes[x,y].errorbar(self.ell, self.mean_ps_sky[x][y], self.error_ps_sky[x][y], label = 'Data') + axes[x,y].legend() + axes[x,y].set_xlabel('l') + axes[x,y].set_ylabel('Dl') + axes[x,y].set_title(f'{int(self.nus[x])} x {int(self.nus[y])}') + fig.suptitle(f'Power spectra comparison - Nreal={n_real} ' + path_plot) + plt.savefig(path_plot + f'/Comparison_plot_extended_Nreal={n_real}') + +with open('sampling_config.yml', "r") as stream: + param = yaml.safe_load(stream) +print('Sampling Parameters', param) + +if param['Method'] == 'MCMC': + print("Chosen method = MCMC") + Fitting().MCMC() +elif param['Method'] == 'NS': + print("Chosen method = Nested Sampling") + Fitting().nested_sampling() +else: + print('Wrong sampling method') + +print("Fitting done") + + + + + + + + + + + + + diff --git a/sampling.sh b/sampling/sampling.sh similarity index 67% rename from sampling.sh rename to sampling/sampling.sh index a88cd2b9e..51fe25d7e 100644 --- a/sampling.sh +++ b/sampling/sampling.sh @@ -4,14 +4,12 @@ # we ask for n MPI tasks with N cores each on c nodes -#SBATCH --partition=htc +#SBATCH --partition=hpc #SBATCH --nodes=1 # c -#SBATCH --ntasks-per-node=6 # n +#SBATCH --ntasks-per-node=3 # n #SBATCH --cpus-per-task=3 # N #SBATCH --mem=20G #SBATCH --time=0-5:00:00 #SBATCH --output=sampling_r_jobs_%j.log - -#mpirun -np $SLURM_NTASKS python main.py -python sampling.py \ No newline at end of file +python sampling.py diff --git a/sampling/sampling_config.yml b/sampling/sampling_config.yml new file mode 100644 index 000000000..fc7ebc6ea --- /dev/null +++ b/sampling/sampling_config.yml @@ -0,0 +1,40 @@ +data: + path : '/pbs/home/t/tlaclave/sps/Pipeline/spectra/spectra_with_convolution/DB_Nrec=2_spectra' + name : 'test' + n_real : 20 + pipeline : 'FMM' + +simu: + nrec : 2 + qubic_config : DB + convo : True + noise : True + name : 'Sky' + +MCMC: + nwalkers : 10 + mcmc_steps : 50 + discard : 0 + stretch_move_factor : 0.7 + snooker_move_gamma : 1.7 + thin : 15 + +NS: + DynamicNS : True + nlive : 2000 + prior_transform : 'uniform' + bound : 'multi' + queue_size : 16 + maxiter : 1000000000000000 + +SKY_PARAMETERS: + r : [True, 1, 2, -1, 1] + Alens : [1, 0, 1, 0, 1] + nu0_d : [353, 0, 1, 0, 1000] + Ad : [True, 0, 20, 0, 1000] + alphad : [True, 5, 10, -5, 5] + betad : [1.54, 0, 1, 1.3, 1.7] + deltad : [1, 0, 1, 0, 1000] + +Method : 'MCMC' +Loglike : 'diag' \ No newline at end of file diff --git a/sampling_config.yml b/sampling_config.yml deleted file mode 100644 index 4838b1de4..000000000 --- a/sampling_config.yml +++ /dev/null @@ -1,37 +0,0 @@ -data: - path : '/sps/qubic/Users/TomLaclavere/Pipeline/' - path_data : '/sps/qubic/Users/TomLaclavere/Pipeline/data_without_convolution/UWB_Nrec=2_Sky_' - path_noise : '/sps/qubic/Users/TomLaclavere/Pipeline/data_without_convolution/UWB_Nrec=2_Noise_' - n_real : 20 - -simu: - nrec : 2 - qubic_config : UWB - name : 'Sky' - noise : True - -MCMC: - nwalkers : 20 - mcmc_steps : 400 - discard : 150 - stretch_move_factor : 0.7 - snooker_move_gamma : 1.7 - thin : 15 - -NS: - DynamicNS : True - nlive : 100 - prior_transform : 'uniform' - bound : 'multi' - queue_size : 16 - -SKY_PARAMETERS: - r : [True, 0, 1, 0, 1] - Alens : [1, 0, 1, 0, 1] - nu0_d : [353, 0, 1, 0, 1000] - Ad : [True, 10, 1, 0, 20] - alphad : [True, 0, 1, -10, 10] - betad : [1.54, 0, 1, 1.3, 1.7] - deltad : [1, 0, 1, 0, 1000] - -Method : 'MCMC' \ No newline at end of file diff --git a/spectra/loop_spectrum.py b/spectra/loop_spectrum.py new file mode 100644 index 000000000..02e6e7245 --- /dev/null +++ b/spectra/loop_spectrum.py @@ -0,0 +1,6 @@ +import os + +N = 1 + +for i in range(0, N): + os.system(f'sbatch spectrum.sh {i}') \ No newline at end of file diff --git a/spectra/loop_spectrum.sh b/spectra/loop_spectrum.sh new file mode 100644 index 000000000..51da6e4dd --- /dev/null +++ b/spectra/loop_spectrum.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +#SBATCH --job-name=loop_spectrum + +# we ask for n MPI tasks with N cores each on c nodes + +#SBATCH --partition=htc +#SBATCH --nodes=1 # c +#SBATCH --ntasks-per-node=2 # n +#SBATCH --cpus-per-task=1 # N +#SBATCH --mem=6G +#SBATCH --time=0-1:00:00 +#SBATCH --output=mulitple_jobs_%j.log + +export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK} + +python loop_spectrum.py diff --git a/spectra/spectrum.py b/spectra/spectrum.py new file mode 100644 index 000000000..98a291d34 --- /dev/null +++ b/spectra/spectrum.py @@ -0,0 +1,354 @@ +#### General packages +import pickle +import os +import sys +import os.path as op +import numpy as np +import matplotlib.pyplot as plt +import scipy +import healpy as hp +import emcee +import yaml +from multiprocessing import Pool +import time + +sys.path.append('/pbs/home/t/tlaclave/sps/Pipeline') + +#### QUBIC packages +import qubic +from qubic import NamasterLib as nam +from qubicpack.utilities import Qubic_DataDir +from qubic import QubicSkySim as qss +from pysimulators import FitsArray +from qubic import fibtools as ft +from qubic import camb_interface as qc +from qubic import SpectroImLib as si +import mapmaking.systematics as acq +from qubic import mcmc +from qubic import AnalysisMC as amc +from qubic.beams import BeamGaussian +import fgb.component_model as c +import fgb.mixing_matrix as mm +from pysimulators.interfaces.healpy import HealpixConvolutionGaussianOperator +#from pipeline import * +from pyoperators import * +#from preset.preset import * + +class Spectra: + ''' + Class to compute the different spectra for our realisations + ''' + + def __init__(self, iter): + + self.iter = iter + with open('spectrum_config.yml', "r") as stream: + self.param_spectrum = yaml.safe_load(stream) + self.pipeline = self.param_spectrum['data']['pipeline'] + self.path_sky = self.param_spectrum['data']['path_sky'] + self.path_noise = self.param_spectrum['data']['path_noise'] + + if self.pipeline == 'CMM': + self.pkl_sky = self.find_data(path_sky) + self.pkl_noise = self.find_data(path_noise) + self.components_map = self.pkl_sky['components'] + self.noise_map = self.pkl_noise['components'] + self.ncomp = np.shape(self.components_map)[0] + self.nsub = self.data_parameters['QUBIC']['nsub'] + self.allfwhm = self.sims.joint.qubic.allfwhm + + if self.pipeline == 'FMM': + self.pkl_sky = self.find_data(self.path_sky) + self.pkl_noise = self.find_data(self.path_noise) + self.sky_maps = self.pkl_sky['maps'] + self.maps_parameters = self.pkl_sky['parameters'] + self.noise_maps = self.pkl_noise['maps'] + self.nrec = self.param_spectrum['simu']['nrec'] + self.nsub = self.pkl_sky['parameters']['QUBIC']['nsub'] + self.nside = self.pkl_sky['parameters']['Sky']['nside'] + self.fsub = int(self.nsub / self.nrec) + self.comm = MPI.COMM_WORLD + self.size = self.comm.Get_size() + self.my_dict, _ = self.get_dict() + + self.ell, self.namaster = NamasterEll(self.iter).ell() + + if self.maps_parameters['QUBIC']['convolution'] is True: + _, allnus150, _, _, _, _ = qubic.compute_freq(150, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25) + _, allnus220, _, _, _, _ = qubic.compute_freq(220, Nfreq=int(self.nsub/2)-1, relative_bandwidth=0.25) + self.allnus = np.array(list(allnus150) + list(allnus220)) + fwhm = self.allfwhm() + allfwhm = [] + for i in range(self.nrec): + allfwhm.append(fhhm[(i+1)*self.fsub - 1]) + self.allfwhm = fwhm + else: + self.allfwhm = np.zeros(self.nrec) + + def find_data(self, path): + ''' + Function to extract the pickle file of one realisation associated to the path and the iteration number given. + + Argument : + - path (str) : path where the pkl files are located + + Return : + - pkl file dictionary (dict) + ''' + + data_names = os.listdir(path) + one_realisation = pickle.load(open(path + '/' + data_names[self.iter], 'rb')) + + return one_realisation + + def get_dict(self): + """ + Method to modify the qubic dictionary. + """ + + nu_ave, delta_nu_over_nu = self.get_ultrawideband_config() + params = self.pkl_sky['parameters'] + + args = {'npointings':params['QUBIC']['npointings'], + 'nf_recon':params['QUBIC']['nrec'], + 'nf_sub':params['QUBIC']['nsub'], + 'nside':params['Sky']['nside'], + 'MultiBand':True, + 'period':1, + 'RA_center':params['QUBIC']['RA_center'], + 'DEC_center':params['QUBIC']['DEC_center'], + 'filter_nu':nu_ave*1e9, + 'noiseless':False, + 'comm':self.comm, + 'dtheta':params['QUBIC']['dtheta'], + 'nprocs_sampling':1, + 'nprocs_instrument':self.size, + 'photon_noise':True, + 'nhwp_angles':params['QUBIC']['nhwp_angles'], + 'effective_duration':3, + 'filter_relative_bandwidth':delta_nu_over_nu, + 'type_instrument':'wide', + 'TemperatureAtmosphere150':None, + 'TemperatureAtmosphere220':None, + 'EmissivityAtmosphere150':None, + 'EmissivityAtmosphere220':None, + 'detector_nep':float(params['QUBIC']['detector_nep']), + 'synthbeam_kmax':params['QUBIC']['synthbeam_kmax']} + + args_mono = args.copy() + args_mono['nf_recon'] = 1 + args_mono['nf_sub'] = 1 + + ### Get the default dictionary + dictfilename = 'dicts/pipeline_demo.dict' + d = qubic.qubicdict.qubicDict() + d.read_from_file(dictfilename) + dmono = d.copy() + + for i in args.keys(): + d[str(i)] = args[i] + dmono[str(i)] = args_mono[i] + + return d, dmono + + def get_ultrawideband_config(self): + """ + Method that pre-compute UWB configuration. + """ + + nu_up = 247.5 + nu_down = 131.25 + nu_ave = np.mean(np.array([nu_up, nu_down])) + delta = nu_up - nu_ave + return nu_ave, 2*delta/nu_ave + + def synthbeam(self, synthbeam_peak150_fwhm, dtype=np.float32): + sb = SyntheticBeam() + sb.dtype = np.dtype(dtype) + nripples = self.my_dict['nripples'] + synthbeam_peak150_fwhm = np.radians(self.my_dict['synthbeam_peak150_fwhm']) + if not nripples: + sb.peak150 = BeamGaussian(synthbeam_peak150_fwhm) + else: + sb.peak150 = BeamGaussianRippled(synthbeam_peak150_fwhm, + nripples=nripples) + return sb + + def allfwhm(self): + ''' + Function to compute the fwhm for all sub bands. + + Return : + - allfwhm (list [nrec * nsub]) + ''' + + synthbeam_peak150_fwhm = np.radians(self.my_dict['synthbeam_peak150_fwhm']) + synthbeam = self.synthbeam(synthbeam_peak150_fwhm, dtype=np.float32) + allfwhm = synthbeam.peak150.fwhm * (150 / self.allnus) + + return allfwhm + + def compute_auto_spectrum(self, map, fwhm): + ''' + Function to compute the auto-spectrum of a given map + + Argument : + - map(array) [nrec/ncomp, npix, nstokes] : map to compute the auto-spectrum + - allfwhm(float) : in radian + Return : + - (list) [len(ell)] : BB auto-spectrum + ''' + + DlBB = self.namaster.get_spectra(map=map.T, map2=None, beam_correction = np.rad2deg(fwhm))[1][:, 2] + return DlBB + + def compute_cross_spectrum(self, map1, fwhm1, map2, fwhm2): + ''' + Function to compute cross-spectrum, taking into account the different resolution of each sub-bands + + Arguments : + - map1 & map2 (array [nrec/ncomp, npix, nstokes]) : the two maps needed to compute the cross spectrum + - fwhm1 & fwhm2 (float) : the respective fwhm for map1 & map2 in radian + + Return : + - (list) [len(ell)] : BB cross-spectrum + ''' + + # Put the map with the highest resolution at the worst one before doing the cross spectrum + # Important because the two maps had to be at the same resolution and you can't increase the resolution + if fwhm1