From 8189cded42f42624f8d7f5db3f9523585a5b373f Mon Sep 17 00:00:00 2001 From: Ben Sargent Date: Mon, 10 May 2021 18:48:44 -0400 Subject: [PATCH] modified original notebook (cherry picked from commit 980e24ae2a77c33ebb58187d94a413eabf0909af) --- .../JWST_Mstar_dataAnalysis_usecase.ipynb | 780 ++++++++++-------- 1 file changed, 441 insertions(+), 339 deletions(-) diff --git a/jdat_notebooks/MRS_Mstar_analysis/JWST_Mstar_dataAnalysis_usecase.ipynb b/jdat_notebooks/MRS_Mstar_analysis/JWST_Mstar_dataAnalysis_usecase.ipynb index 0f02674e..ca5fec57 100644 --- a/jdat_notebooks/MRS_Mstar_analysis/JWST_Mstar_dataAnalysis_usecase.ipynb +++ b/jdat_notebooks/MRS_Mstar_analysis/JWST_Mstar_dataAnalysis_usecase.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false @@ -92,21 +92,7 @@ "name": "#%%\n" } }, - "outputs": [ - { - "ename": "ImportError", - "evalue": "cannot import name 'six' from 'astropy.extern' (/home/jbcurtin/workspace/spacetelescope/dat_pyinthesky/jdat_notebooks/MRS_Mstar_analysis/env/lib/python3.7/site-packages/astropy/extern/__init__.py)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# Import packages to deal with spectralcubes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mspectral_cube\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mSpectralCube\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;31m# To find stars in the MRS spectralcubes and do aperture photometry\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/workspace/spacetelescope/dat_pyinthesky/jdat_notebooks/MRS_Mstar_analysis/env/lib/python3.7/site-packages/spectral_cube/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;31m# ----------------------------------------------------------------------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0m_ASTROPY_SETUP_\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mspectral_cube\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mSpectralCube\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mVaryingResolutionSpectralCube\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mstokes_spectral_cube\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mStokesSpectralCube\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mmasks\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/workspace/spacetelescope/dat_pyinthesky/jdat_notebooks/MRS_Mstar_analysis/env/lib/python3.7/site-packages/spectral_cube/spectral_cube.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwcs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mastropy\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0munits\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextern\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 18\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextern\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmoves\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mrange\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mxrange\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextern\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmoves\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mImportError\u001b[0m: cannot import name 'six' from 'astropy.extern' (/home/jbcurtin/workspace/spacetelescope/dat_pyinthesky/jdat_notebooks/MRS_Mstar_analysis/env/lib/python3.7/site-packages/astropy/extern/__init__.py)" - ] - } - ], + "outputs": [], "source": [ "# Import astropy packages \n", "from astropy import units as u\n", @@ -115,6 +101,7 @@ "from astropy.table import Table, vstack\n", "from astropy.stats import sigma_clipped_stats\n", "from astropy.nddata import StdDevUncertainty\n", + "from astropy.io import fits # added by BAS on 8 April 2021\n", "\n", "# Import packages to deal with spectralcubes\n", "from spectral_cube import SpectralCube\n", @@ -149,14 +136,399 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import other stuff\n", + "\n", + "from jwst.pipeline import Detector1Pipeline\n", + "from jwst.pipeline import Spec2Pipeline\n", + "from jwst.pipeline import Spec3Pipeline\n", + "from jwst.extract_1d import Extract1dStep\n", + "import json\n", + "import glob\n", + "from jwst.associations.lib.rules_level3_base import DMS_Level3_Base\n", + "from jwst.associations import asn_from_list\n", + "import crds\n", + "from jdaviz.app import Application\n", + "import asdf\n", + "from photutils import aperture_photometry\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# do Stage 1 pipeline\n", + "\n", + "allshortfiles=glob.glob('/filepath/and/filenames_of_the_MIRIFUSHORT_mirisim_simulation_files_here.fits')\n", + "alllongfiles=glob.glob('/filepath/and/filenames_of_the_MIRIFULONG_mirisim_simulation_files_here.fits')\n", + "\n", + "pipe1short = Detector1Pipeline()\n", + "\n", + "# run calwebb_detector1 on the MIRIFUSHORT data separate from MIRIFULONG data, as it saves time this way\n", + "for shortfile in allshortfiles:\n", + " print(shortfile)\n", + " baseshort,remaindershort = shortfile.split('.')\n", + " \n", + " beforestuffshort,dateafterstuffshort = shortfile.split('2021_')\n", + " #Since there are 3 simulations folders, each corresponding to SHORT, MEDIUM, and LONG band mirisim\n", + " # simulations, we need a way to identify the pipeline's products resulting from these input simulations, \n", + " # so we identify based on the number string in the folder name giving month and day and time of \n", + " # simulation creation. There may be a better way to do this, but this works for now.\n", + " datestringshort,afterstuffshort = dateafterstuffshort.split('_mirisim')\n", + " \n", + " pipe1short.refpix.skip = True\n", + " pipe1short.output_file = baseshort+datestringshort\n", + " \n", + " pipe1short.run(shortfile)\n", + "\n", + "pipe1long = Detector1Pipeline()\n", + "\n", + "for longfile in alllongfiles:\n", + " print(longfile)\n", + " baselong,remainderlong = longfile.split('.')\n", + " \n", + " beforestufflong,dateafterstufflong = longfile.split('2021_')\n", + " #same as above\n", + " datestringlong,afterstufflong = dateafterstufflong.split('_mirisim')\n", + " \n", + " pipe1long.refpix.skip = True\n", + " pipe1long.output_file = baselong+datestringlong\n", + " \n", + " pipe1long.run(longfile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# do Stage 2 pipeline\n", + "\n", + "allshortfiles2 = glob.glob('det_image_*_MIRIFUSHORT_*_rate.fits')\n", + "alllongfiles2 = glob.glob('det_image_*_MIRIFULONG_*_rate.fits')\n", + "\n", + "for short2file in allshortfiles2:\n", + " print(short2file)\n", + " pipe2short = Spec2Pipeline()\n", + " base2short,remainder2short = short2file.split('.')\n", + " \n", + " pipe2short.straylight.skip = True# skip stray light step\n", + " pipe2short.cube_build.skip = True# skip cube building step (for now, but see my comment in next cell)\n", + " pipe2short.extract_1d.skip = True# skip extract_1d step\n", + " pipe2short.output_file = base2short\n", + " \n", + " pipe2short.run(short2file)\n", + "\n", + "for long2file in alllongfiles2:\n", + " print(long2file)\n", + " pipe2long = Spec2Pipeline()\n", + " base2long,remainder2long = long2file.split('.')\n", + " \n", + " pipe2long.straylight.skip = True\n", + " pipe2long.cube_build.skip = True\n", + " pipe2long.extract_1d.skip = True\n", + " pipe2long.output_file = base2long\n", + " \n", + " pipe2long.run(long2file)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# B. Sargent, 10 May 2021\n", + "# The first time you run this notebook, skip this cell and proceed to the next cell.\n", + "# Then, when you have a cube produced from stage 3 of the pipeline, open the cube \n", + "# outside of this notebook and find the RA and Dec of the point source in the cube. \n", + "# Come back to this cell and set those RA and Dec equal to targra and targdec in this \n", + "# cell, respectively, run this cell, then re-do the next 2 cells to re-do the stage 3 \n", + "# pipeline reduction.\n", + "#\n", + "# In the future, perhaps that awkward process could be replaced. Specifically, I am \n", + "# thinking that, further down in this notebook, Libby has photutils code that can \n", + "# identify a point source in the data. That could be done here on a single cube\n", + "# produced by the preceding cell that does the stage 2 reduction, and the pixel \n", + "# coordinates returned could be used to compute the RA and Dec of the source, then \n", + "# that RA and Dec could be used here instead of having to open the stage 3 cube \n", + "# outside of this notebook to get the source's RA and Dec like is currently needed.\n", + "\n", + "all_files = glob.glob('det_image_*_cal.fits')\n", + "targra=# Put the RA you find from the cube you get the first time you run the stage 3 pipeline here.\n", + "targdec=# Put the Dec you find from the cube you get the first time you run the stage 3 pipeline here.\n", + "for thisfile in all_files:\n", + " base,remainder = thisfile.split('.')\n", + " outfilename=base+'_fix.'+remainder\n", + " print(outfilename)\n", + " \n", + " with fits.open(thisfile) as hduthis:\n", + " hduthis['SCI'].header['SRCTYPE']='POINT'# This tells the extract_1d step to extract a point source.\n", + " hduthis[0].header['TARG_RA']=targra\n", + " hduthis[0].header['TARG_DEC']=targdec\n", + " hduthis.writeto(outfilename,overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set up needed reference file for stage 3\n", + "\n", + "file_all_list = glob.glob('det_image_*_cal_fix.fits')\n", + "\n", + "asnall = asn_from_list.asn_from_list(file_all_list, rule=DMS_Level3_Base,product_name='combine_dithers_all_exposures')\n", + "\n", + "asnallfile='for_spec3_all.json'\n", + "with open(asnallfile, 'w') as fpall:\n", + " fpall.write(asnall.dump()[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# do stage 3 pipeline\n", + "\n", + "pipe3ss = Spec3Pipeline()\n", + "pipe3ss.master_background.skip = True\n", + "pipe3ss.mrs_imatch.skip = True\n", + "pipe3ss.outlier_detection.skip = True\n", + "pipe3ss.resample_spec.skip = True\n", + "pipe3ss.combine_1d.skip = True\n", + "#pipe3ss.cube_build.output_type='multi'# un-comment this if you want a cube spanning the entire MRS wavelength range\n", + "pipe3ss.use_source_posn='True'\n", + "pipe3ss.subtract_background='True'\n", + "#pipe3ss.extract_1d.apply_apcorr = False# un-comment this if you do not want the aperture corrction applied\n", + "pipe3ss.output_file = 'allspec3'\n", + "pipe3ss.run(asnallfile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "wlall=[]\n", + "fnuall=[]\n", + "dfnuall=[]\n", + "bandall=[]\n", + "\n", + "speclist=[]\n", + "\n", + "allch_extractfile='combine_dithers_all_exposures_ch1-2-3-4-mediumlongshort-_x1d.fits'\n", + "with fits.open(allch_extractfile) as hduallch:\n", + " wlallch=hduallch['EXTRACT1D'].data['wavelength']\n", + " fnuallch=hduallch['EXTRACT1D'].data['flux']\n", + " dfnuallch=hduallch['EXTRACT1D'].data['error']\n", + "\n", + "ch1short_extractfile='combine_dithers_all_exposures_ch1-short_x1d.fits'\n", + "with fits.open(ch1short_extractfile) as hduch1short:\n", + " wlch1short=hduch1short['EXTRACT1D'].data['wavelength']\n", + " fnuch1short=hduch1short['EXTRACT1D'].data['flux']\n", + " dfnuch1short=hduch1short['EXTRACT1D'].data['error']\n", + " print(dfnuch1short)\n", + "ch1shortspec=Spectrum1D(spectral_axis=wlch1short*u.micron,flux=fnuch1short*u.Jy,uncertainty=dfnuch1short,meta={'band':'ch1short'})\n", + "speclist.append(ch1shortspec)\n", + "\n", + "ch1medium_extractfile='combine_dithers_all_exposures_ch1-medium_x1d.fits'\n", + "with fits.open(ch1medium_extractfile) as hduch1medium:\n", + " wlch1medium=hduch1medium['EXTRACT1D'].data['wavelength']\n", + " fnuch1medium=hduch1medium['EXTRACT1D'].data['flux']\n", + " dfnuch1medium=hduch1medium['EXTRACT1D'].data['error']\n", + "ch1mediumspec=Spectrum1D(spectral_axis=wlch1medium*u.micron,flux=fnuch1medium*u.Jy,uncertainty=dfnuch1medium,meta={'band':'ch1medium'})\n", + "speclist.append(ch1mediumspec)\n", + "\n", + "ch1long_extractfile='combine_dithers_all_exposures_ch1-long_x1d.fits'\n", + "with fits.open(ch1long_extractfile) as hduch1long:\n", + " wlch1long=hduch1long['EXTRACT1D'].data['wavelength']\n", + " fnuch1long=hduch1long['EXTRACT1D'].data['flux']\n", + " dfnuch1long=hduch1long['EXTRACT1D'].data['error']\n", + "ch1longspec=Spectrum1D(spectral_axis=wlch1long*u.micron,flux=fnuch1long*u.Jy,uncertainty=dfnuch1long,meta={'band':'ch1long'})\n", + "speclist.append(ch1longspec)\n", + "\n", + "ch2short_extractfile='combine_dithers_all_exposures_ch2-short_x1d.fits'\n", + "with fits.open(ch2short_extractfile) as hduch2short:\n", + " wlch2short=hduch2short['EXTRACT1D'].data['wavelength']\n", + " fnuch2short=hduch2short['EXTRACT1D'].data['flux']\n", + " dfnuch2short=hduch2short['EXTRACT1D'].data['error']\n", + "ch2shortspec=Spectrum1D(spectral_axis=wlch2short*u.micron,flux=fnuch2short*u.Jy,uncertainty=dfnuch2short,meta={'band':'ch2short'})\n", + "speclist.append(ch2shortspec)\n", + "\n", + "ch2medium_extractfile='combine_dithers_all_exposures_ch2-medium_x1d.fits'\n", + "with fits.open(ch2medium_extractfile) as hduch2medium:\n", + " wlch2medium=hduch2medium['EXTRACT1D'].data['wavelength']\n", + " fnuch2medium=hduch2medium['EXTRACT1D'].data['flux']\n", + " dfnuch2medium=hduch2medium['EXTRACT1D'].data['error']\n", + "ch2mediumspec=Spectrum1D(spectral_axis=wlch2medium*u.micron,flux=fnuch2medium*u.Jy,uncertainty=dfnuch2medium,meta={'band':'ch2medium'})\n", + "speclist.append(ch2mediumspec)\n", + "\n", + "ch2long_extractfile='combine_dithers_all_exposures_ch2-long_x1d.fits'\n", + "with fits.open(ch2long_extractfile) as hduch2long:\n", + " wlch2long=hduch2long['EXTRACT1D'].data['wavelength']\n", + " fnuch2long=hduch2long['EXTRACT1D'].data['flux']\n", + " dfnuch2long=hduch2long['EXTRACT1D'].data['error']\n", + "ch2longspec=Spectrum1D(spectral_axis=wlch2long*u.micron,flux=fnuch2long*u.Jy,uncertainty=dfnuch2long,meta={'band':'ch2long'})\n", + "speclist.append(ch2longspec)\n", + "\n", + "ch3short_extractfile='combine_dithers_all_exposures_ch3-short_x1d.fits'\n", + "with fits.open(ch3short_extractfile) as hduch3short:\n", + " wlch3short=hduch3short['EXTRACT1D'].data['wavelength']\n", + " fnuch3short=hduch3short['EXTRACT1D'].data['flux']\n", + " dfnuch3short=hduch3short['EXTRACT1D'].data['error']\n", + "ch3shortspec=Spectrum1D(spectral_axis=wlch3short*u.micron,flux=fnuch3short*u.Jy,uncertainty=dfnuch3short,meta={'band':'ch3short'})\n", + "speclist.append(ch3shortspec)\n", + "\n", + "ch3medium_extractfile='combine_dithers_all_exposures_ch3-medium_x1d.fits'\n", + "with fits.open(ch3medium_extractfile) as hduch3medium:\n", + " wlch3medium=hduch3medium['EXTRACT1D'].data['wavelength']\n", + " fnuch3medium=hduch3medium['EXTRACT1D'].data['flux']\n", + " dfnuch3medium=hduch3medium['EXTRACT1D'].data['error']\n", + "ch3mediumspec=Spectrum1D(spectral_axis=wlch3medium*u.micron,flux=fnuch3medium*u.Jy,uncertainty=dfnuch3medium,meta={'band':'ch3medium'})\n", + "speclist.append(ch3mediumspec)\n", + "\n", + "ch3long_extractfile='combine_dithers_all_exposures_ch3-long_x1d.fits'\n", + "with fits.open(ch3long_extractfile) as hduch3long:\n", + " wlch3long=hduch3long['EXTRACT1D'].data['wavelength']\n", + " fnuch3long=hduch3long['EXTRACT1D'].data['flux']\n", + " dfnuch3long=hduch3long['EXTRACT1D'].data['error']\n", + "ch3longspec=Spectrum1D(spectral_axis=wlch3long*u.micron,flux=fnuch3long*u.Jy,uncertainty=dfnuch3long,meta={'band':'ch3long'})\n", + "speclist.append(ch3longspec)\n", + "\n", + "ch4short_extractfile='combine_dithers_all_exposures_ch4-short_x1d.fits'\n", + "with fits.open(ch4short_extractfile) as hduch4short:\n", + " wlch4short=hduch4short['EXTRACT1D'].data['wavelength']\n", + " fnuch4short=hduch4short['EXTRACT1D'].data['flux']\n", + " dfnuch4short=hduch4short['EXTRACT1D'].data['error']\n", + "ch4shortspec=Spectrum1D(spectral_axis=wlch4short*u.micron,flux=fnuch4short*u.Jy,uncertainty=dfnuch4short,meta={'band':'ch4short'})\n", + "speclist.append(ch4shortspec)\n", + "\n", + "ch4medium_extractfile='combine_dithers_all_exposures_ch4-medium_x1d.fits'\n", + "with fits.open(ch4medium_extractfile) as hduch4medium:\n", + " wlch4medium=hduch4medium['EXTRACT1D'].data['wavelength']\n", + " fnuch4medium=hduch4medium['EXTRACT1D'].data['flux']\n", + " dfnuch4medium=hduch4medium['EXTRACT1D'].data['error']\n", + "ch4mediumspec=Spectrum1D(spectral_axis=wlch4medium*u.micron,flux=fnuch4medium*u.Jy,uncertainty=dfnuch4medium,meta={'band':'ch4medium'})\n", + "speclist.append(ch4mediumspec)\n", + "\n", + "ch4long_extractfile='combine_dithers_all_exposures_ch4-long_x1d.fits'\n", + "with fits.open(ch4long_extractfile) as hduch4long:\n", + " wlch4long=hduch4long['EXTRACT1D'].data['wavelength']\n", + " fnuch4long=hduch4long['EXTRACT1D'].data['flux']\n", + " dfnuch4long=hduch4long['EXTRACT1D'].data['error']\n", + "ch4longspec=Spectrum1D(spectral_axis=wlch4long*u.micron,flux=fnuch4long*u.Jy,uncertainty=dfnuch4long,meta={'band':'ch4long'})\n", + "speclist.append(ch4longspec)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.plot(wlallch,fnuallch,'.',color='black',markersize=1)\n", + "plt.plot(wlch1short,fnuch1short,'.',color='purple',markersize=1)\n", + "plt.plot(wlch1medium,fnuch1medium,'.',color='blue',markersize=1)\n", + "plt.plot(wlch1long,fnuch1long,'.',color='green',markersize=1)\n", + "plt.plot(wlch2short,fnuch2short,'.',color='yellow',markersize=1)\n", + "plt.plot(wlch2medium,fnuch2medium,'.',color='orange',markersize=1)\n", + "plt.plot(wlch2long,fnuch2long,'.',color='red',markersize=1)\n", + "plt.plot(wlch3short,fnuch3short,'.',color='purple',markersize=1)\n", + "plt.plot(wlch3medium,fnuch3medium,'.',color='blue',markersize=1)\n", + "plt.plot(wlch3long,fnuch3long,'.',color='green',markersize=1)\n", + "plt.plot(wlch4short,fnuch4short,'.',color='yellow',markersize=1)\n", + "plt.plot(wlch4medium,fnuch4medium,'.',color='orange',markersize=1)\n", + "plt.plot(wlch4long,fnuch4long,'.',color='red',markersize=1)\n", + "plt.xlabel('wavelength (microns)')\n", + "plt.ylabel('flux (Jy)')\n", + "plt.xlim(4.0,29.0)\n", + "plt.ylim(0.0,0.15)\n", + "plt.title('Spectrum from extract_1d in Stage 3')\n", + "plt.tight_layout()\n", + "plt.savefig('spectrum.jpg')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "app = Application(configuration='cubeviz')# when doing Cubeviz, first run this block.\n", + "app" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ch1short_cubefile='combine_dithers_all_exposures_ch1-long_s3d.fits'\n", + "#ch1short_cubefile='combine_dithers_all_exposures_ch1-2-3-4-shortlongmedium-_s3d.fits'\n", + "app.load_data(ch1short_cubefile)# When this block is run, the spectrum will appear in the Cubeviz viewer above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "app.get_viewer('spectrum-viewer').show()# This just shows the spectrum part." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "spec_input = app.get_data_from_viewer('spectrum-viewer')\n", + "# This is the spectrum - wavelength and flux" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Before you run this cell, draw a region (like a circle) in one of the cube viewers in Cubeviz above.\n", + "# Otherwise, you get an error.\n", + "spec_agb = app.get_data_from_viewer('spectrum-viewer', 'Subset 1')\n", + "spec_agb\n", + "\n", + "plt.figure(2)\n", + "plt.plot(spec_agb.spectral_axis,spec_agb.flux)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Setup an input directory where relevant data is located\n", - "data_in_path = \"https://data.science.stsci.edu/redirect/JWST/jwst-data_analysis_tools/MRS_Spectroscopy_Late_M_Star/\"\n", + "#data_in_path = \"https://data.science.stsci.edu/redirect/JWST/jwst-data_analysis_tools/MRS_Spectroscopy_Late_M_Star/\"\n", "\n", - "data_cube_file = data_in_path + \"NGC346_K_2c_COMBINED_CUBE_Y551.fits\"\n", + "data_cube_file = 'combine_dithers_all_exposures_ch1-long_s3d.fits'\n", + "#'combine_dithers_all_exposures_ch1-2-3-4-shortlongmedium-_s3d.fits'\n", + "# Apparently the cell that is 2 cells from now that reads in the cube does not like the MRS cube that spans \n", + "# all the MRS wavelengths! So, instead, I have here a cube for only 1 of the MRS bands, which it seems \n", + "# to like better.\n", + "\n", + "#data_in_path + \"NGC346_K_2c_COMBINED_CUBE_Y551.fits\"\n", "\n", "# Path to output directory\n", "data_out_path = \"./\"\n", @@ -167,15 +539,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Some housekeeping if using the KMOS data rather than simulated JWST/MRS data\n", "# Define good wavelength ranges for each grating from which to make the data cube\n", - "YJgrating = [1.02, 1.358] # microns\n", - "Hgrating = [1.44, 1.85] # microns\n", - "Kgrating = [2.1, 2.42] # microns" + "#YJgrating = [1.02, 1.358] # microns\n", + "#Hgrating = [1.44, 1.85] # microns\n", + "Kgrating = [7.6, 8.6]#[2.1, 2.42] # microns" ] }, { @@ -199,30 +571,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SpectralCube with shape=(2048, 14, 15) and unit=erg / (Angstrom cm2 s):\n", - " n_x: 15 type_x: RA---TAN unit_x: deg range: 14.827541 deg: 14.830852 deg\n", - " n_y: 14 type_y: DEC--TAN unit_y: deg range: -72.158961 deg: -72.157927 deg\n", - " n_s: 2048 type_s: WAVE unit_s: m range: 1.925 um: 2.500 um\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ojones/anaconda3/envs/astro36/lib/python3.6/site-packages/spectral_cube/spectral_cube.py:246: UserWarning: Could not parse beam information from header. Exception was: NoBeamException('No BMAJ found and does not appear to be a CASA/AIPS header.',)\n", - " \" Exception was: {0}\".format(ex.__repr__()))\n" - ] - } - ], + "outputs": [], "source": [ "cube = SpectralCube.read(data_cube_file, hdu=1) \n", "print(cube)" @@ -230,7 +583,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -249,37 +602,26 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Make a continuum image (Sum/average over Wavelength)\n", "# Note: many mathematical options are available median is preferred\n", - "cont_img = cmin.median(axis = 0)\n", + "cont_img = cmin[:, 10:30, 10:30].median(axis = 0)#cmin.median(axis = 0)\n", "\n", + "cont_img_sub = cont_img[10:30, 10:30]\n", "# Extract the target name\n", - "name_long = cont_img.header[\"OBJECT\"]\n", - "name, _ = name_long.split(\"/\")" + "#name_long = cont_img.header[\"OBJECT\"]\n", + "#name, _ = name_long.split(\"/\")\n", + "name = 'AGB'" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Quick plot the continuum image now the NaN borders removed\n", "plt.imshow(cont_img.value)\n", @@ -289,38 +631,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:astropy:Auto-setting vmin to -1.149e-18\n", - "INFO:astropy:Auto-setting vmax to 1.301e-19\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO: Auto-setting vmin to -1.149e-18 [aplpy.core]\n", - "INFO: Auto-setting vmax to 1.301e-19 [aplpy.core]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Plot the continuum in WCS\n", "F = aplpy.FITSFigure(cont_img.hdu, north = True)\n", @@ -424,7 +737,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -437,21 +750,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Number of sources in field: 2\n" - ] - } - ], + "outputs": [], "source": [ "# Crop out Edges and take absolute value of the continuum image\n", - "cont_img = cont_img[1:13, 1:13]\n", + "#cont_img = cont_img[1:13, 1:13]\n", "\n", "# Find the background in the collapsed datacube\n", "mean, median, std = sigma_clipped_stats(cont_img.value, sigma = 2.0)\n", @@ -489,72 +793,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: A 'NAXIS1' keyword already exists in this header. Inserting duplicate keyword. [astropy.io.fits.header]\n", - "WARNING:astropy:A 'NAXIS1' keyword already exists in this header. Inserting duplicate keyword.\n", - "/Users/ojones/anaconda3/envs/astro36/lib/python3.6/site-packages/spectral_cube/spectral_cube.py:246: UserWarning: Could not parse beam information from header. Exception was: NoBeamException('No BMAJ found and does not appear to be a CASA/AIPS header.',)\n", - " \" Exception was: {0}\".format(ex.__repr__()))\n", - "WARNING: AstropyDeprecationWarning: Inputing positions shaped as 2xN is deprecated and will be removed in v0.8. Positions should be a (x, y) pixel position or a list or array of (x, y) pixel positions, e.g. [(x1, y1), (x2, y2), (x3, y3)]. [photutils.aperture.attributes]\n", - "WARNING:astropy:AstropyDeprecationWarning: Inputing positions shaped as 2xN is deprecated and will be removed in v0.8. Positions should be a (x, y) pixel position or a list or array of (x, y) pixel positions, e.g. [(x1, y1), (x2, y2), (x3, y3)].\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " id xcentroid ycentroid sharpness ... sky peak flux mag \n", - "--- --------- --------- ---------- ... --- ------------- --------- ----------\n", - " 1 2.3734571 1.7177399 0.62142129 ... 0 5.5538106e-19 5.2739665 -1.8053434\n", - " 2 5.3369846 6.8329156 0.66676136 ... 0 4.1796922e-19 3.8700278 -1.4692852\n", - "\n", - "00h59m19.2286s -72d09m30.1487s\n", - "00h59m18.9713s -72d09m30.1505s\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAFgCAYAAACmDI9oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd3hU1daH351GQm/S9ILdqwICV8VGU7FfC34X9IqAioAN+7ULF9GrgogoioBAVFAQ6UIA6RAMEAkdDIRQE0hIzySZzMz+/pjMzJmaCaQR1vs888zMOfvss+bMKb+99tprK601giAIgiAIgiDYCalqAwRBEARBEAShOiECWRAEQRAEQRAMiEAWBEEQBEEQBAMikAVBEARBEATBgAhkQRAEQRAEQTAgAlkQBEEQBEEQDIhAFgRBEARBEAQDIpDLCaXUW0qpX5RSSUoprZRKrgY2tVRKfaiUilFKpZXYNa2UbcKUUkOVUn8qpfKVUtklnwdXktmCIAiCIAhVSlhVG1CD+AjIAP4EGlaxLQ6uAN4GjgCbgbsDFVZKRQALgB7AdGAC9nPkMqBNhVoqCIIgCIJQTRCBXH5corVOAlBK7QTqVrE9APFAM611mlKqKZBWSvn3gNuBnlrrVRVunSAIgiAIQjVEQizKCYc4Dhal1LVKqblKqXSlVJFSap9S6h2lVLk1WrTWuVrr0kSxw546wIvAfK31KmWnXnnZIgiCIAiCcLYgArkKUErdA2wALgc+A4YCG4ERwE9VZFYXoB4Qr5T6AsgBckpilz8qT+EuCIIgCIJQnRHRU8kopSKBKUAccKvW2lKy6lul1DZgjFKqu9Z6dSWbdkXJ+0uAGfgPcAp4DHgLOB/oX8k2CYIgCIIgVDoikCufnkBz7KKzoVLKuG4xMAa4A1gNoJTqDnQPsu7DWuspp2mXI5yiMdBWa7235PsspdQqoJ9S6hOt9e7TrF8QBEEQBOGsQARy5XNlyXsgIdvc8Lk7MCzIujeUUm8gCkre/zCIYwffl9jRDRCBLAiCIAhCjUYEcuXjcBm/DiT4KXPc8UFrPRwYXrEmAXC05D3Vx7qUkvdGlWCHIAiCIAhClSICufJJLHnP11r/XqWWuLOp5P0CH+scy05Wki2CIAiCIAhVhmSxqHyWYheabyqlGnuuVEpFVUV6Na31QewhGtcrpToZ7AkFngYswLLKtksQBEEQBKGyEQ9yOaGUehzXbHPnARFKqXdLvh/SWv8AoLXOV0r1A+YB+5RSU4D92Gff+zvQC3iIkkF65WCXw4baJe/tDcvWaq3XGoq/AKwDfldKjcOexaIPcD0wQmt9uDxsEgRBEARBqM4orXVV21AjUEqtxj6IzRdrtNbdPcq3Bd7EPq3zeUAmcABYAozXWmeUk12B/uD/lsQ4G8u3B0YCXYFIYA/whdZ6WnnYIwiCIAiCUN0RgSwIgiAIgiAIBiTE4gwoxTsrCIIgCIIgVHO01spzmQzSEwRBEARBEAQD4kEuByRMRRAEQRAE4ezCYzZjN8SDLAiCIAiCIAgGRCALgiAIgiAIggERyIIgCIIgCIJgQASyIAiCIAiCIBgQgSwIgiAIgiAIBkQgC4IgCIIgCIIBEciCIAiCIAiCYEAEsiAIgiAIgiAYEIFcg/nwww+5+uqrad++PR06dCAuLq6qTRIEQRAEQaj2yEx6NZSNGzeyaNEi/vzzT2rVqkV6ejpms/mM6rRYLISFySkjCIIgCMKZY9M2iqxFRIVFVbUpXogHuYaSkpJC06ZNqVWrFgBNmzalVatWrFixgo4dO9KuXTuefPJJioqKALjwwgtJT08HYMuWLXTv3h2A4cOHM2jQIO644w769euH1Wrltddeo127drRv354vv/wSgPj4eLp168Y//vEP7rzzTlJSUir/RwuCIAiCcNYwcNlArp9+PRmFGVVtihfiDqxgLnzztwqpN/njewOuv+OOOxgxYgSXX345t99+O3369KFz584MGDCAFStWcPnll9OvXz+++eYbXnrppYB1xcfHs379eqKiovjmm284ePAgW7duJSwsjIyMDIqLi3nhhReYP38+5513HjNnzuSdd95hypQp5fmTBUEQBEGoQWxO3QzAH8f/4J6L76lia9wRD3INpW7dusTHxzNx4kTOO+88+vTpw7fffstFF13E5ZdfDkD//v1Zu3ZtqXXdf//9REXZuz9+//13hgwZ4gy1aNy4Mfv27WPnzp307NmTDh06MHLkSI4ePVpxP04QBEEQBKECEQ9yBVOap7ciCQ0NpXv37nTv3p127doRHR3tt2xYWBg2mw2AwsJCt3V16tRxftZao5RyW6+15uqrr2bjxo3laL0gCIIgCOcCnrqiOiAe5BrKvn37SExMdH5PSEigefPmJCcns3//fgB++OEHunXrBthjkOPj4wH49ddf/dZ7xx13MGHCBCwWCwAZGRlcccUVpKWlOQVycXExu3btqpDfJQiCIAhCzUIhAlmoJPLy8ujfvz9XXXUV7du3Z/fu3Xz88cdMnTqVf/3rX7Rr146QkBCGDBkCwLBhw3jxxRfp0qULoaGhfusdOHAgrVu3pn379lxzzTXMmDGDiIgIZs+ezRtvvME111xDhw4diI2NrayfKgjVgr59+9KhQwevbDErVqwgPDyc2NhYlFJerwkTJjjLJicn+ywTExPjLJOSksK///1v/v73vxMaGsqAAQMq6ycKgiBUDNVPH6O01lVtw1mLUkqDPcRAEIRzm6ysLNq1a0e/fv348MMPAcjJyaFdu3Y89thjfPTRRyilmDRpEvfdd59zuwYNGjhj/JOTk7nooouIiYnhmmuucZZp3LgxERERzjJjxoyhU6dOTJw4kcsvv5xp06ZV3g8VBEEoJ9pFtwNgVLdR3HXhXZW+f0doh9baS6JLDLIgCEI50LBhQ6ZOncrdd9/NAw88wPXXX8/LL79Mo0aNGD58uFu5Fi1aBKyrSZMmfstceOGFjBs3DoDZs2eXm/2CIAhVhYRYCIIg1GBuv/12nnnmGfr168fs2bOZPn06P/zwg9P7C/Diiy/StGlTrrvuOiZMmOAcHGukV69eNGvWjJtvvllEsCAINZ7qKJDFgywIglCOfPLJJyxbtow+ffrw8ccf065dO+e6ESNG0KNHD+rWrcuKFSt49dVXSU9P59133wXs6RlHjx7NzTffTFhYGAsWLKBPnz5ER0fTt2/fqvpJgiAI5xwSg3wGSAyyIAi+mDx5MkOHDiUvL4+QEP8ddZ9++ikffvgh2dnZfss8++yzrF+/nu3bt3utu++++2jatKnEIAuCcFbiiEEe030MPdv0rPT9B4pBlhALQRCEciYsLIyQkJCA4higc+fO5OTkcOLEiYBljCkbBUEQahrVMcRCBLIgCEIVkZCQQGRkJA0bNgxYpmXLlpVolSAIgiAxyDWU0NBQ2rVrh9aa0NBQvvrqK2666SZWr17N6NGjWbRo0WnVm5eXx6uvvsrvv/9OZGQkTZo0YdSoUXTu3Lmcf4Eg1CwWLlxIamoqN954I1FRUaxatYr333+fQYMGUatWLQCio6MJDw+nY8eOhISEsHDhQsaPH88nn3ziVldCQgJgTyMXEhJCQkICERERXHXVVZX+uwRBEM6U6uhBFoFcQ4mKinI+RJcuXcpbb73FmjVrzrjegQMHctFFF5GYmEhISAhJSUns2bMnqG211mit3bqdrVZrwIlJBKGmEB4eztdff80rr7yCzWbj4osvZsSIETz33HNu5UaOHMmhQ4cIDQ3l8ssvZ8qUKV4D9Dp27Oj2feHChbRp04bk5OSK/hmCIAjlT/XTxxJicS6Qk5NDo0aNvJZv3ryZjh07kpSURFpaGj179qRTp04MHjyYNm3akJ6e7lb+wIEDxMXFMXLkSKfIvfjii7n33nsBGDNmDG3btqVt27aMHTsWsE9qcOWVV/Lss8/SqVMnjhw5Qt26dXn//ffp3Lmzc3pqQahJDBgwgLy8PLdld911F1u3biU3N5f8/Hx27NjBiy++SFiYy0/Rv39/du/eTX5+Pjk5OWzZssVn9gpHY9P4EnEsCMLZiniQz0WGN6igev2PegcoKCigQ4cOFBYWkpKSwsqVK93Wx8bG8sILLzB//nxat27N888/z6233spbb71FTEwMEydO9Kpz165ddOjQwafHNz4+nqlTpxIXF4fWms6dO9OtWzcaNWrEvn37mDp1Kl9//TUA+fn5tG3blhEjRpzBARAEQRAEQagYxINcQ3GEWOzdu5eYmBj69evnTEe3Z88eBg0axMKFC2ndujUA69ev55FHHgHsni5fHudArF+/noceeog6depQt25devXqxbp16wBo06YNN9xwg7NsaGgoDz/8cHn8TEEQBEEQznLEg3wuUoqntzK48cYbSU9PJy0tDYCWLVtSWFjI1q1badWqFRBcLuerr76abdu2YbPZvNJXBdq+Tp06bt8jIyMl7lgQBEEQBMCVj7g6IR7kc4C9e/ditVpp0qQJAA0bNuS3337j7bffZvXq1QDccsstzJo1C4Bly5aRmZnpVc8ll1zCtddey7Bhw5yCODExkfnz59O1a1fmzZuHyWQiPz+fuXPn0qVLl8r5gYIgCIIgCOWIeJBrKI4YZLB7d6Ojo928ts2bN2fhwoXcfffdTJkyhWHDhvHoo48yc+ZMunXrRsuWLalXr55XvZMnT+bVV1/l0ksvpXbt2s40b506dWLAgAFcf/31gD3bRceOHWXgkCAIgiAIAamOIRYy1fQZUJOmmi4qKiI0NJSwsDA2btzIM88840wTJwiCIAiCUN44ppoef9t4ul7QtdL3H2iqafEgCwAcPnyY3r17Y7PZiIiIYNKkSVVtkiAIgiAIQpUgMcgCAJdddhlbt25l27ZtbN68meuuu66qTRIEN9auXcv999/P+eefj1KKadOmBSw/aNAglFKMHj261LpnzJhBhw4dqF27Ni1atKBv376kpqY610+aNIkuXbrQuHFjGjZsSI8ePVi/fr1bHbm5ubz00ku0adOGqKgobrrpJjZv3lzm3zlgwACUUl4v42DXYOzxxYsvvsi1115LZGQkF154odf65ORkn/uOiYlxK1fa8TLy008/oZTivvvuK9uBEARBqELKJJCVUrWVUh2VUncqpe4o+Vy7oowTBEFwkJeXR9u2bfniiy+IiooKWHb27Nls3rzZmaUlEBs2bODxxx+nf//+7Nq1i3nz5rF7924ee+wxZ5nVq1fTp08fVqxYQVxcHFdccQV33nkniYmJzjIDBw5k6dKlREdHs2PHDu644w5uv/12jh07Vqbf+cUXX5CSkuL2uvjii+ndu3eZ7PGFzWajf//+9OvXL2C5mJgYt/3feuutZTpeDpKSknj99ddlwK4gCAGpjjHIPmdkMr6ARsDLQCxQBFg9XkUl614CGpVWX3m9sIv7l4G9QCFwBPgMqBPk9qsB7ed1bZB1aPshFAShMqlTp46eOnWqz3XJycm6VatWevfu3bpNmzZ61KhRAesaNWqUbt26tduyKVOm6Dp16vjdxmaz6ebNm+tx48ZprbU2mUw6NDRUz5s3z61cp06d9DvvvBPEL/LP+vXrNaA3bNgQtD2lMWrUKN2mTRuv5QcPHtSA3rx5c8BtgzleZrNZX3/99XratGm6f//++t577w3KNkEQzh3aTmur205rq9cdXVcl+zfoOC+N59eDrJRqoJQaDRwrEZ6NgOnA+8BzwPMln2eUrBsDHFNKjVJKVdD0cW58XrLP3cALwC/AUGChUipYz3g68LiPV1K5WysIQoVjsVh49NFHeffdd7nyyiuD2ubmm28mJSWFhQsXorUmPT2dn3/+mXvuucfvNmazmcLCQueEOhaLBavVSmRkpFu5qKiooEIfAjFp0iSuvvpqbrrppqDtOVN69epFs2bNuPnmm5k9e7bbumCP1zvvvMOFF15I//79y8UmQRCEyiTQIL0D2D2z/wN+1FofDFSRUupi7OJyEPAE0LS8jPSxr6uxi+I5WuuHDcsPAuOAR7AL99LI11r/WDFWCoJQ2QwbNowmTZrwzDPPBL3NjTfeyE8//cRjjz1GQUEBFouFnj17Eh0d7Xebd999l7p163L//fcDUK9ePW688UZGjhxJ27ZtadGiBT/99BMbN27k0ksvPe3fk52dzS+//MJHH30UsJynPadL3bp1GT16NDfffDNhYWEsWLCAPn36EB0dTd++fYHgjteyZcuYOXOmZMIRBMEvuppnAAvkaf0AuERr/UFp4hhAa52ktf4vcHHJthXJo4ACxnosnwSYgL7BVqSUClFK1VfVcRqXMyA0NJQOHTpwzTXX0KlTJ2JjYwF77OKZDJbJy8tj8ODBXHLJJVx99dV07dqVuLi48jKb7t27s2XLlnKrTzh3WLNmDdOmTWPKlCll2m737t0MHTqU9957j/j4eGJiYkhNTWXw4ME+y3/xxRd8++23zJkzh/r16zuX//DDD4SEhHDBBRdQq1Ytxo0bx6OPPhpw1si6des6X0OGDPFa/+OPP2K1Wnn88cf91uHPntOhadOmvPrqq9xwww1ce+21jBgxgsGDB/Ppp586y5R2vNLT0xkwYADR0dHl5tEWBKHmYdM25+dqKZZ9xV1U9xewFHv8cy0f6zYAaUHUsRooxi6oNZAPzAH+XgY7qm0MsjEeMCYmRnft2lVrrfWqVavOKBawT58++s0339RWq1VrrfWBAwf0okWLgtrWZrM5t3NgsVjcvnfr1i1g/KMgaO07BnnYsGFaKaVDQ0OdL0CHhITo888/329dffv21Q8++KDbsnXr1mlAHz582G352LFjdd26dfW6df7j5fLy8vTx48e11lr37t1b33PPPX7LJiYmOl8nTpzwWn/NNdfof//73363D8YeX/iLQfbFtGnTdGRkpPN7acdr1apVGnD7H5RSzv9m7969ZbJVEISaSbG12BmDvObImiqxgdOJQa7mtALStdZFPtYdA5oqpSJKqeMg8Cn2cJB/AV8DdwNxSql2gTZUSg1SSp01bs6cnByfnpzNmzfTsWNHkpKSSEtLo2fPnnTq1InBgwfTpk0b0tPT3cofOHCAuLg4Ro4cSUiI/dS5+OKLuffeewEYM2YMbdu2pW3btowda3fuJycnc+WVV/Lss8/SqVMnjhw5Qt26dXn//ffp3LkzGzdu9LLrxx9/5KabbqJt27Zs2rQJgIyMDB588EHat2/PDTfcwPbt2wEYOnQoI0aMAGDp0qV07doVm83mVadQ83n22WfZvn07CQkJzlerVq14+eWXWbFihd/tTCaTl5fX8V0bvBpjxozhnXfe4bfffuOWW27xW1+dOnVo2bIlmZmZLF26lAceeMBv2UsvvdT5atasmdu6TZs2sW3bNp5++mmf2wZrz5mSkJBAy5Ytnd9LO17XXXcdO3bscPsf7r//frp06UJCQgIXXXRRhdkqCMLZg/H+Wh0JeqIQpdT1wDVa60mGZQ8AI4HGQLTW+u3yN9EntbFnz/BFoaGM2V8FWusnPBbNVkotwO5ZHgP0DLDtRGCiYya9QDhmiSlvdvTfEXC9Y6rpwsJCUlJSWLlypdv62NhYXnjhBebPn0/r1q15/vnnufXWW3nrrbeIiYlh4sSJXnXu2rWLDh06+Owyjo+PZ+rUqcTFxaG1pnPnznTr1o1GjRqxb98+pk6dytdffw1Afn4+bdu2dQpbT/Lz84mNjWXt2rU8+eST7Ny5k2HDhtGxY0fmzZvHypUr6devHwkJCXz88cdcd911dOnShaFDh7J48WKneBdqFnl5eezfvx+wpys7fPgwCQkJNG7cmNatW9OsWTMvkRkeHk6LFi244oornMscKc6+//57AP75z3/y9NNP880333DnnXeSkpLCSy+9RKdOnWjdujUAo0aN4p133uHHH3/k8ssvd+b8jYqKokED+5jkpUuXYrPZ+Pvf/87+/ft5/fXXueKKK3jiCc9bTXBMnDiRyy67jG7dunmtC8aer776iq+++oq9e/c6t9u/fz95eXkcP34cs9nsjBG+6qqriIiIIDo6mvDwcDp27EhISAgLFy5k/PjxfPLJJ846gjlebdu2dbO3YcOGWCwWr+WCIJy72KjeIRZlmUlvGGDDHueLUqo18BP20IQ04A2lVKLWemq5W+mNCWjmZ12koUyZ0FqvU0qtBXoopaK01gWna2BVExUV5Xz4bdy4kX79+rFz504A9uzZw6BBg1i2bJkzT+z69euZO3cuAHfddVeZYwfXr1/PQw895JzMoFevXqxbt47777+fNm3acMMNNzjLhoaG8vDDD/urikcffRSArl27kpOTQ1ZWFuvXr+fXX38F4NZbb+XUqVNkZ2fToEEDJk2aRNeuXfn888+55JJLymS3cPawZcsWevTo4fw+bNgwhg0bRv/+/UudNMTI4cOH3b4PGDCA3NxcvvrqK1599VUaNGhAjx493OJux48fT3FxMX369HHb1rjv7Oxs3nrrLY4ePUrjxo15+OGH+fDDDwkPDy/zb83NzeXnn3/m/fffx9fwiGDsSU9PZ9++fW7rBw4cyJo1a5zfO3bsCMDBgwedE4eMHDmSQ4cOERoayuWXX86UKVOcA/QguOMlCIJQGm4xyJzdAvka4CvD90ewD5TroLU+ppRagj2DRWUI5OPAVUqpWj7CLM7HHn7h13tcCslAd+yp685YIJfm6a0MbrzxRtLT00lLSwOgZcuWFBYWsnXrVqdADqb1dvXVV7Nt2zZsNpuXlzbQ9sYZwAAiIyMDDlzyFARKKZ/1O8rt2LGDJk2acPz48VJ/g3D20r179zJ7GZKTk72WrV692mvZCy+8wAsvvFCmejzp3bu322QeZ0K9evXIy8s7I3uGDx/O8OHD3Zb5+u1G+vfvH1RattKOlydlacAIgnBuYLyfV0cPcln6opsAxrlE7wTWaq0d00QtAC4rL8NKYTN22683LlRKRQIdgDOJD74MsAAZZ1BHtWLv3r1YrVaaNGkC2Ls7f/vtN95++23nA/OWW25h1qxZgD1FU2Zmplc9l1xyCddeey3Dhg1znsyJiYnMnz+frl27Mm/ePEwmE/n5+cydO/e0Z8+aOXMmYPdKN2jQgAYNGtC1a1emT58O2B/yTZs2pX79+hw6dIjPPvuMrVu3smTJknLNqCEIgiAIQsVg9Bqf7R7kLKA5gFKqFnADYEzOqYHA87+WHzOBt7HP3rfOsPxp7LHH0x0LlFItgQbAYa21qWRZAyBPa201VqqUuhe4GViitS7kLMYRgwz2lll0dLSb17Z58+YsXLiQu+++mylTpjBs2DAeffRRZs6cSbdu3WjZsiX16tXzqnfy5Mm8+uqrXHrppdSuXZsmTZowatQoOnXqxIABA7j+enubZeDAgXTs2DEoT5cnjRo14qabbiInJ8eZsmv48OE88cQTtG/fntq1axMdHY3WmqeeeorRo0fTqlUrvvvuOwYMGMDmzZu9JmwQBEEQBKH6UN1DLFSwbu2SEIpLsYdWPAS8BXTWWm8pWf8J8C+t9cUVZKunPV9in81vLrAYuBL7THobgFu1th95pdQ0oD/QQ2u9umTZg9gH4i3EPmueBbs3ui92z/HNWuu/grDBnuutGnYNlJWioiJCQ0MJCwtj48aNPPPMM5LkXxAEQRDOQWzaxpKDS2h/Xnv+Vu9vFbKPHHMON/90MwBju4/ltja3Vch+AuEI1dRaew32KIsH+QNgGbAJe+zxcoc4LuE+oDL7t1/CHi88CLgX+7TRXwLvO8RxAPYB8dhtbg6EA0eBCcBHhrCRc4bDhw/Tu3dvbDYbERERTJo0qfSNBEEQBEGocfxx/A/eXPcmUHFjqdxikKuhBzlogay1jlVKdcIee5wN/OxYp5Rqgl08zy13C/3bYwU+K3kFKjcAGOCxbA/23MdCCZdddhlbt26tajMEQRAEQahiThWecn4uthUTHlL2bDylUd1DLMriQaYk7MAr9EBrfQp4ubyMEgRBEARBEKqG+hGuaev3Z+7nyiZXlvs+3AbpVcNQVZlRQRAEQRAEQXBi0RbnZ5OlzNNKBEV19yCLQBYEQRAEQaggrDZr6YWqGUabbaUO6zo9qnsMsghkQRAEQRCECmDS9kl0+KED+zL2lV64GmE1ZMGtqPAHN+Fd/fSxCGRB8EJrKPI/i5kgCIJQ+WQVZlW1CWVm3NZxAHyd8HUVW1I2jALZRvl4kLXWbE7dTI45x/69mk8UIgJZEDyZ/zz873xI2V7VlgiCIAjAxO0T6TKzC/P2z6tqU84JKiLEYvHBxTy59EkeX/w4ULOmmhaEc4OEH+3v8dOq1AxBEATBzpdbvwRgbPzYKrbk9HBMSHG2YPQgl5dzd9WRVQAkZScB7p5p8SALwtmEkstDEARBOPew2FxZLMoSYmHTNvLMPkIU9/5Gcco2t0Vn/SA9pdTflVKzlFK7lVKrlFL9/ZR7TCl19g3VFAR/iEAWBEEQzkHcYpADhFhYbBZ+3P0jSVl2r/DAZQO58acbSc1PdS/4878xZx50W3RWh1gopS4ANgL/BzQDbgKmKKV+U0rVrQT7BKHqEIEsCIJQrahqT2PssVgGLh3oLQArmIpKteYPYwxyIPH661+/8snmT3hg/gMAbE7dDMDao2u9yhZ7hJmU1+C/iqI0BfAeEAH01Fo3Bc4DxgB3Ab8rpRpUsH2CUHWcZTFjgiAIQsUy+PfBxKXG8cmmT8q0neL0nyc55hx6zOrByD9GnnYdZSVYD/JfmV6TKwO+Y66LPRad7ROFdAMmaK1XAGitc7TWrwN9gA7YRXLDCrZREKoG8SALgiBUK6pLV7wjVVllsDx5ORmFGczcN7PS9hlsmjd/wtZXg6DYY9nZPtV0a2Cn50Kt9WygF9AWWKGUalQBtglC1SIeZEEQBMEHlenxDA0JrbR9OQg2xKJMAtnjmXq2D9JLB5r6WqG1Xgw8BFwJrACalK9pglDFiAdZEARBKAfOJM1bWEhYOVoSHBZtyGIRIMTCn3j29XvNnjHIxhCLs9CDvAe41d9KrXUMdpH8d+DjcrRLEKoeEciCIAjViuroaaxoqkIgu3mQAxxzf+JZodBas/H4RucMiJ4xyNX9v7M5fZAAACAASURBVCxNASwGbldKXeSvgNZ6KfAgnEEEuiBUR0QgC4IgCFVMuAqv9H0G690NJHKXJi9l0PJBPPLbI8DZF2JRWrMkGtgLBMxvrLVeppS6BXtMsiDUEKTNJwiCUJ2oLkKqMkMCjDHIWutKmZWvPEIsNqZsBOBY3jHAe5BedQ+xCCiQtdZZwNJgKtJaxwPx5WGUUHbiUuIIUSFc1+K6qjal5iAeZEEQhOpF9dNRFY5RSJptZmqF1qrwfRpDLMori4VnDLJbFotq+MeKAqgB2LSNgcsG8uTSJ6vaFABGLd3LT5sOV7UZZ44IZKEGEXMwhofmP8ThnBpwbQrnLsWmqrYAqEBBZzaBhzfVmHKt0FJYMfv1wLjPgCEWATzIniLZKwa5modYlEkBKKXaKKU+LJl6eoVSaqXHa0VFGSr4J9iE3pVBUloek3aO5/2Vk6vUjqApyISD67xuSIAIZKH6cuxPmDMIck8Evcnra19nf9Z+vtn2TQUaJggVi7aaq9oEoIJCAvLS4KOW8OPDbouN3twia1H579cHFltwIRb+vMvBpHk7q0MsjCil7gd+AcKBHCCzoowSyobxJLPYLESERlSZLfszD1Kr6eqSbyOqzI6gmXQbZByAf02Dqx9yXycCWaiuTOphf7cUQu/vy7RpeEjlD/gRhPKi+smo4AhqJr3EZfb3A+6+RmM8cJGlcgSyP8dboaWQWqG1nHHQgYStZ6y0teS741ic7VNNG/kEOAJco7VuqLW+yNerguwUAuApkKuSgkq6eMuNjAOYAfb76PyoKROFWMywaRJkJFW1JUJ5k5MSVDHjQ6xplM/U9oIgVDm+xabRg1xorZwQC1/TQCdlJ3Hd9Ov4MO5Dr3We+AqxcOBopLuFWFRDD3JZBPKFwDit9Y4KskU4TdwEsq5agWyzVe8T3pPPGjXkHxe1ZkdRrvfKmiKQ476Bxa/BV9dX2i5N1SROsMYTZH5U47S4lTHARxAEd4LKPOHnmWl0fFVFiIXjWT5jzwwA9ymvDSZ7hmL4FcihJQK5Bg3SOwjInbUaYjwpjS3NqqDI4rIl31w9YsUCMa1hfQC+zkr2XllTQiyOb7W/24orZXcbj2+k84zOjE8YXyn7O6cJDVIgF7kEcqAH7Ppj6zmYffCMzTrX0VpjriaxsjWN6iejKh5juENFCuSlyUt5bc1rFFmL3EMsSkIhfA0QNIZJeIZl+GsUOCY+8eWlrk6URQGMBQYqpepUlDHC6RFsiEV2UTa5Zh+e0nIk3+y6gPKLz55wC58Xck0RyJWMYxDYhG0TqtiSc4Ag44mNDzF/D9j9mft55vdnuH/e/eVi2rnMsyuepcvPXcgz51W1KWXn9+Gw8MWARVLzU/lf3P84mnu0cmyqAQQVg+xHJLp5kCswjPG1Na+xNHkps/bNcp9JT2uO5h4lJjnGaxtjT7Fxm0DOulAV6rVtdexxDnqQntZ6olKqPrBLKRUNJONjAhGtddlGjAhnjJsHWfs+KS02C7f8fAsAO/pXXJSMURTnFRXQvG79CttXeRKiRSCXF7XDale1CTUek1LsrBXBP1QooaUXd3v4+BPIB7MlRr28WH9sPQDb07Zz0/k3VbE1ZWPXpq8oUiF0um0Y1G7ss8zra14nIS2BjSkbWfDggkq2sHpQHh7PYlsxQ1cO5caWN9Lv6n5+ywXyIGut+XnzEdpf0ICrWzU4Y5sA0grSvLzBd8+526ucTdvIL873aadN2/w2CkJKnq3VPcSiLFksmgO9gNbAe36KaUAEciVjPCmL/XSjV7Tn2IHJ7Lp4jd7k6o7Tg2wQEknpJi6qpFmLahK1w0Ugl5X9mfuZsXcGz3Z4NqhBdC82b8ofUVG8Rjb9g6jf6EH2l0fVmrbX7XvMwRja1G/DlU2uDGIPggOjw+JsvBYeOb8lAJsshUT5KbMvcx9AUOE48/bPI0SFcP8l5dMzUekyymaFEO9maHl4PDcc28D6Y+tZf2y9XSD7qTPQpB2r/0rjrTl2p1fyx/eesU1gv0e47dNPmrcXV73IhuMbnN+Nnm6rtvp9djoEclWnpS2NoAUyMAG4DvgcWIekeas2+OviMGKMh6vIqSpNxWepQHa0dA3Hb0bcIf5xUSp3t2vpcxutdaXNanQ2UdM8yCMW7iY8TPHW3RUnFB/97VEKrYVkFWUxpvuYUsv/EWWXLstswQlk4z3CX2ysrcB1S9+bsZfX174OVGyP01mJzQq750Gbm6FeC6/Vxnhvfz161Rab+4xt/gRySJC9a8XWYt7bYPen/fPif559zoY/voGYN2HgCrjgWvd11jMf0+HlYfUjGI2D7z2F+aH0fM/iZ0yhpdB9ohA/zZLVR1a7fQ/Wg+wMsaB6h1iUpQ/5NuALrfWrWut5Wus1vl4VZajgH+NJ6S8GucBS4CpTgZku3ARy8dkjkJ0XguH4hWBjY9Ipv9t8vOljrv3xWg7lHKpY484yzkavmT+KLFambDjIt2uS3DK0BGLS9kn8vPfnMu3HkbqprDGdoUEKFePDx1+aKKuh9+lEfvATkJxzxE+F2U/CxO4+V2cUZjg/n+6AKqvNSuzxWLfu68rAauxdCBBDGqxANmZPKa/Ggk1VnpiyxLxJclgYerl3p7nOOvP7fq0wl3Ml0PghT8+skdCQ8m90FFoK3XRCsJ5ez3DPsniQq2OIRVkEchGwv6IMEU4f483Cn/g1PhQrMldykcXlnTq7PMgll4KbQNYBh1XM2GtPeVNWMVTTqRNe/uN492Xso9eCXmw8vrHc6w6Exeq6tvLNpV83pmIT47aO48O4D08r1V1UmD+fnW+CFcjBDNI7keMaUJaS755feVvaNj7Y+EGlC7ZqSVKJHyjXdw7qU4WuRvXpDqiavmc6g5cP5oWVL5zW9qeL2XDO7srYS59FfYg/Ee9VzuEBLA2jQC6v506BUjyz4plyqas03j6vCf/8WysWpSfAoVj3lWXMCuTLm2o8JvZj5SfEIsC0z0F55Qsy7Wk+15XeOwVQYC0oPcTCRyPFV2o453fD57NlkF5ZBPJvQM+KMkQ4fYwXj78QCzcPcgUK5AKDQC6opDnjy4MQx83LcCxDcIWiJGYmEr0r2uex8xf3fbZzquAUr6x+hc2pm8u0nXEmx+Jy6IYEeHPdmyRmJjJo+aByqS9Yiq2uB4PJXLoHrNiQtWB7+vYy76/MAjnIW3gwg/QyC13i120iAK3pu7gvs/6axbcJkpnEXzc42D3vTy590vm9yHZ6Ann5oeUAZb72zgStNWaLSyC/FvcBu0/tZkDMAK+yVelBBnvs7uliKjYFfc9eUtfe2P+lfl2Y6j1I7UwxXotZhVnBxSB7nH+hIYq6mFCBZqX78wdI3wcr/huUXauPrGZ/lssf6lO8jr7M206jFtFWN7uNT86a6EF+BfibUmqcUuoSddYFE9VcjCevvwu/oNglkIPNlXwg6wDDYoeVqbu14GwKsXC76L1jkBXaOVdIrwW9GL1lNHMS53hVYzbXTK/amPgxLD+03O2BXxrZRdl8nfC183tucfkMDi0oCHLIQ/J62P97wCLDY4fzzvp3gqrObLUREnGSyFY/kZhR+oCkYsNg2L3pu4Pah5GK8iAbHz7+vJpF1gI/y13lU4/9UQbr3FlycAlJWTUgU0YAT9cXf37h9v10cyGH+hgUVpHYtI0hvw/h/5Y+4VyWZ/HfAxK0B7nozDzIpmITq4+sLrec0qZiE51ndKbX/F6A/VmYlJ1UqvdyV0QtjoeV/39i/F1ZRVn4TfOm/YdY1CtIYWfkQKLDP/G7H6u2cSok8L0iNT/V7Xt6Qbrzs9HB5mBmiPcyTyFvtNtikIy+slhUR8oikNOBfwDPAX8BFqWU1eNVtdO4naN4ttp8cToxyANiBjAncQ7DNg7Dpm0cyT1S6o3EzYNczfMg2wxCIcRxoRpu4grt1S3mGLVtjEfNPrqtAq0sH2zAH5G13Dw6pXHSdLLM+/lkk/tN2pExodhWzNqja087m0qYKb30QgDT7oUfH4Yilyf3r8y/eGrpU+xK34XVZuXXxF9ZcGBBUPGhxVZNVOvvCG+wjf/Fv11qeYvBY15QlBWczQYiwyLLVL7QHFxsYDAxyEVW34Jo4Yo3nJ9D8oI7J9YcWcPQlUOd51tcShz/WfsfHpj/QMDtYo/Fkpqfyu5Tu5m8Y3KVT3zkkwAeZJOHqPSXMaQ0wlRZxs+fOY8vfpzY47GkFrj+3/AAszQG6x8z3m9Op6ft/dj3eWHlC14NDyi9S95is3h5W5Nzkt3e3499nwfmPcDc/XMD1mUOUdz5t/Pd91+K7eDbQxp/Ip5eC3rx3ob3yCx0NfyzAtwv3HISewxs23dsArsjwuka6n8w7esnVtG9zQXsi/CfN/2O2Xf4XZdX7J3Pe2RT7xSAbkJ+0ySsha7/P8sg0J0CuZqHWJTlKvyec3MSm2qPMb7Q7yA9q58QC3O+Pd9vuLfnynHBJmcn88PuHxi9ZTSPXPEI2KI4mmLlf3e/SMPaEW7bFBQXOZtdBRWY0Lw8KDJML21zpPS2uYdYeI5/cFzYY374xbksNz+73Gyy2CzkmnNpFNmo3OoEWFS3Du+c14RLFvdj3oPzvNZrrdmftZ8L61/ocxrQYNmR7n6TdjwUo3dF88WfX3Bdi+uYcueUMtcbFlSSfQMFmVCrLgBvrXuLvzL/ou+Svqx/ZL2zSKGlsNQMJBarjZBw+/+barIPoNt1ahdj48fyxnVvcGmjS93LGwSR2df05aUQlAfZKHb9COQiaxHhIeHO89Uoiv2JNrMfD/KI1JXOzyFB/g/Pr3wegMnbJ/PKta+wN2NvKVvAppRNDP59MJGhkU5760fUp/cVvYPaZ2WRZTPzwXlNeDgvH88Mx56hB6fr+Qw2hKE8KLIW+QwHClOhmPEtak8nBrmsjZ3Y47EsTV4KwPe7vbPHWrSFcGUQfPtiIKohtL6BYmsxd/16Fxc1uIjJd052FnETrFqz4IA9h/OMPTPodVkv57oia5FbiIFhozL9Bs+sDoAzZCUxM5EV4Suc69NMaeQWFFPPuK+Shoi/MMpVR1YxrXgL085vyY6Dh/3asTzP3nMzu15d/PWdBbrfBzv2wM2DnH0Ey65UqGcPU7mjtauBcbbMpFeWiUIGVKAdwhlgM6TmKVMMsrUYPmoFtZvAf+wX0KmCU8Qkx/DAJS5PT4gKYVua3Uv68z7XgLRfZ9XhqQHPuu2n0GKGEs1cWM09yHmG1q3VKZANg/SUDU9HiePB9fLBp4m+qDUAxbr8YpAHLR/E5tTNLHt4GS3r+k4vV1ZO5ppZF2X3TB7IPuCzzNJDS3l9zevceeGdjO42+rT35TkwzSEQVh1ZBdhjKvdl7OOKxleUbrfpJOMTxtPvqn6Eoii1fW489w1duw6bLDaL23VQaCmkQa3AifWNMciOgZxPxDxBgaWA19a85tXYsBi80oVBesuNDVZj/LZfDF7qUB+C1VRsotvMbhRaC7mkwSVc1eQqFiYtdK7356kqshWW2qdY1rg6x4A1t0a5KQMiG7jllt2Wto1lh5YB7mJ+96myh6mUN9/t+I51x9bxbc9vqRVaizm2TJbVrcOyunXw9Nl5CtvTzWLhN8QiIwnmPgPd34BLbj2tuj3xF0IXHhLmYyowO0HHIBtDLMqQPWnV4VUMXTU0YBmLzUK4YybJgkz4qY/98/BskrKTOFlwkpMF7j0exsah8b/xzC386upXWXPUR1KuMjR4tNZ8Ee/yfNu0zctLagxBGxk3kpBad/AvZwU2KGmIGHumjEJyZ/pO3zvPSILDcdC+Dxg8t/ke/1uBpYDX17xO/YjAE3oFO+DYOqsflHSCWRVY/NwwHA1tnbbHuaw6CmSZKqwG4OZB9nMTMsYgOx9WOccZ26gB34W7LvpnVzzLx5s+5tPNnzqXhapQIkO9u34vPDHJa5kxi0VhNfEg+0tRk1dgvHl7C2SFd75ox4PBZFhu8uNlOR0cg3LiUuOgnGK4j2Tklypspu+eDuD02ACn1V/k2cXs8CAbcyM/EfMEwfDG2jeYkziHoSuH+hSCXhgeItb8dHaf2o3FZqFhrYbO5cbrIBjxYra4DoIq+e8dIjuzyDsu2mI454ONTc83DOwLKk7T8JDPCDXz5dYv3UJXdp3a5RSZB7IPuIljsHeX+nrgFdlKf/gvsJ5yDiALBofny/i7Hpx+I9/80N3N3r6L+zJz30yv7csSEnQmZBVmsS9jn891Y/8cS/yJeOe1UctwLnoex/ISyH5DLBa+BEf+gB8e8lqltSYpO6nMntoTpgACuYTvdnznFpNa0VksjJNP+MO9J9SEjZJbls1KgR+PZ54hpMF4rzI6mQDf4hgwF7oal6XdHrenbyd6d7Tzu1VbSStIC7jNCovhHDT8Pkuma/yD8XlmTCnoxriOMG8I7Jnvtjg3RLk5EjanbmbN0TVe9whP/J0jnlhPJbrsRLnFHRsJKXFO6RUjnMuqY4hF0AJZKdVHKeV3ljylVLRS6v/KxyyhLBgvmGDyIDseWtm5KXzXsAFjGzdCl9wgHB4bY2qfEBXCsbxjXnXujfLOd1tkaGHnW7zjliqbyTsmc/3069mf6d1dll/oEhVWbYW0fRA7zrksxDBIz7ms5AGYb2iVWwONHi4DJ/JcD5Mm5iL4sDnEvFUudfuTlweyDrDmyBoyffy/p9Oi9+yK8yWQgx24t+XEFgAO5x4mqENsNbMrIoKttSKYnDSPPov68Hn85zSIdHmJjQ9FXwNPPHHzIHtMR+70XhlNMIjMwiC7JYsyXV59zzEEe07t4UjOEY+duPZxLLyAidsn8lX850Hty4FR7DgoDLKh98rqV4Lej0N4GBvuByIi+BqX0NiR5j920jNmffep3UzbOQ1TsYlXVr/i3qAzcjgO1n9eapf4zL0zGbJ8CLf+civ/t/D/SMxM9FvW4Q2tZajySK77fxNidhfMpyuQjUK72FrsEuIm/3nZ5yTO4YF5D7hlIAkGz8FZDsINInjsn2OZsM2VwcStIeAhLrXWDPl9CEOWD/EZYhFMTt1gGkYWw7G22sw8fH4Lnm1+HhTlUPDHeDd7HOSlu0J9TGbfUyQHIq/AIEjNJsh2v28ap172DK+xaZtbzLEvtPHYGISs1dCINh4/f/UlhYfxc726WNP+crc/JMQeVlmCv//ekz9P/hlUuV21XCFrVuWeucId+39ic1tyFgtk4HkCP6asQOUmbRTQWjN4+WDnd6dA3jAO4r51Ls+35LuVOZJ7hCRDXKBnd7AxFjIpO8nnBZIT4R0v6TYq1+yndVuJfPHnFxRZi/gs/jOvdaZC101nc608npt9L9l/TnMuC8E+E5BRTDgG7Y1t7PJKWlT5XNiDZsS46tz7m/3DH1/7KR0chZZC/gorZHFd37mJH5z/IM+vfJ5DPjwbnjesA1kHiD0e61Uu0DaO8yHKR4x7sDSNaorNkI94V/ou3wVtFh45vwX9WrXgq2P2TBbf7/6eBhEugewWYuFnsJoRi9U4CY+JRUmLnN99hUO4eZCDEOAAZsOD3tjATTOl0XtRb+6Ze4/7BgXeIRIHk1c7Pwcjynx5sgrLMoFQtneDyhcOYRzIexgorMRTKPVZ1IfP4j/jqaVPsfzQcl5b85rXNtvTtpM17S5MK/4Lexd5rTcyMm4kG45vcDbkHF3WxdZiJm2f5CaYHY2rIkPcQaG1kAnbJjAgZgDmE3sITXT3rpdHiMVzK56j5+yepQ5wdXgrf/nrF3u+2+zgJp3x1VgCCPfwYhsbA24CucD9Pp9fnM+GYxvYcHwDWQYBV2wpZMXhFXSe3pl1R9c5l684vIK1R9faq7IUYLaayS4qfVyHxeQ6h1Nyj7M/IoL1taOwmk4xKGuTc53Z0GjNz3dtk2S4jwQrzvKNv9Vmgc+vcls/cftEbvnpFjanbvYaT2DV1lLDTJTRDj9xx4E8yI7GwAMXtOLDpo1ZZclg5WHXGILCEAW75jrPjdMZiB2IDwwD9zT49SA7PP1F1TwZWlkE8pXA1gDrtwJXBVgvlAP/WzKEEb895bwQcsw5bheJVVvBUgTL34Ml/3G27lPzXC1Fk8XEPXPuod82l2jMLXT3TAQzmr7I4wbgmHrZQU4FCuQ9p/YwavMoN4+lTducAii9IN2t+zM7zzupf5bhZlekNGtrRzHGIHwVkGdNpcesHs5lIbn2rqbfDILTojSTd0ym5+yepJkCd6F5ciDrAHMT56K1ZudJ1wOoyKMteijnkHNaz0BdUfnF+QyLHcaWVLv39d9z7+ejRsfLZBPZx2DKXeh81zlRYCngwfkPMnj5YG+PZgCKN00ErcucvszIeVHnuWUTeeS3R3yKhU2pm7yWAW5xxsbzpdBSyKmCU+4CoTAbS3w0Gw4uo9hWjKXIJXKLsfLWOpdHPyKkRNhZXQ+9jWkJrqqKggsPMDYqjbGG29MMA6eOJ7g8ddneg3ESi045Z3QszUsFvgVykb+AU19sHI+p2OT+P9issORN2OMSpY6HeaB82DkBjtPuU7sZvXm0VwaEnad8x15uStnEY4sfo0ubC7i5zQUcTom3e/oM2LSNWftm+ZwB0zF46MfdPzBu6zh6LXAN3HKcO8UGj2mhpZDxCeOJPxHPmugeKA+vYX5xPgsOLPB7XzAVmxifMN6ZHQcAa7Fbhp2NKRvJMeew9eRWp0f8vaaN6b2wt//Y0BX/hRl93JfZrG7nqgNHhoILit2PsadX9byo85yf3QZrHk+ALNc5aRRdGYb4ZmtBBi+teolCayEvr37Zvm9zHi+teonnVjyHxWahx6we3P7L7QEzOjiwGLzpYQZbj2a49wIUpbkcQbnbfnR+fm7d687Pwc4Ud7iUWVPHJ4zHoi28tuY1rB4ZX7TWpYaZGAVyzKFlDIgZQGZuCpYUl/SyHlzrDL/zPE7FVu3sDQZYVXCUF1e96Kpfw5KVb3L4q46A94RA5YkV5feOogGb6RTz6tV1LTubQyyAOvgN2Qfsv7legPXCGXIsI4kZJzfwS/omtu63exs9W/8bDq3k9p9u4Y/IWkyrX48ZO+0ZA4yt/3QfD9jcQvcLLRhBY/FodeebrVwa4rqBHDBtIDEzEbPVzM70nUHfhEpDa03vRb35fvf3TNs1zbl8wrYJ3DDjBmKPx3LPnHt4wpDTM9dwkzRbzSRnJ3Mky737CWBTpKuLKATN0SL3RP2mY/YQlBYWQzob7J7q1PxUvtv5nX1ZSYvfVGziuRXPMW3VG2z/5TGvuOIH5z/I+7Hvs+H4BlqGurxyKdYCHjq/BT+V3EDum3sfL6x8gUVJi+g+qztTd071eWwm75jMnMQ5PLH0CSw2C4km/zdAXzekJhYrxLwJhzfCSdcAqdfXuB4mR/KOOH+j56hwTyx7FsDRLUR6ZovQGlNhtj05vg+7jFMuh4eEE+Jxq/I1JfNThgeeEXXSNRDEeB0czj1M91nd6TGrh2vwzoKhfBI7jCFrX7WnGSvyHyYRERoBO+dg+vgCzPtiMBWb+CLRNYh1deFxftvrHld70nTS2aDVVguFk2/DvNjlBT18YCkH5jzBnMQ57DUI5Fk/3UvxFvtofEtmspct6crGfXPvY+bemby9vvR0dCf3LsB2YJXbsgIV/PWZZStyipmEkwlQXAB7FkLcNzDzMWc5ZwyyD8/ZyfwTFNuKfcZyG4neHU3PWbexNWWLz/V6k/24aK3ZmOKaadGiFN/vmgajLoVcu4Ngys4pXPP9NXzwxwf8a+G/vOoKDwmHJW/w10bvHidn17mh8Tp77TDnZ1OI51kK8/bP45317/D4ksfdV9isYM7nm23fMGHbBB5Z8DAsfQfmDoHJt2FO9A4dOZh9kF0hFtZGRTKvXl32ZOyh84zOzsaH1/V3wqMR8cOD8GUnuwPFgENkN7O6P94LPcT+/APzndlIQo2ev+kPw9h2zpAA48A446yCFpN3DLMxU8RJ00nyi/PJLMoMyrPpEMiz9s1iwRHXuXzcQ8SaZ9vzuOvcE3zRwHdPWmn3MQdD4v/nKuc4BBYzaO3WW5BRmMGYNW+6bWvV1tLjsA12vL5xOPEn4pk49QY34aX3LIBf+jv3Y6TYYiXV0OtR4HHd7YisxX+aNeXeC1qQZkpzZvGoCGwqsAd5zr5ZxEW5HHHadApOHYC0v7zO0aqiLAL5IHBLgPW3AP7zjAhnzKo9rpP59612geTpCZp/KIYTtkKebtmcz5o04n9bv8BUbOJonktQZPjwAOZ6dJMFM0rZqotJzk5m9ObRZBVmkZV6iKvCXKLTRjG9FvTi3bVv8uhvj/LLli8h6zB62r28M/NuBi4bSN/Ffb3i+BxYbBb+u/G/zNo3C45ugcxkZu2b5ebRnbBtAtvStqG15ptt32DTNgYvH0yBpcBtBHyeIWb4xVUv8s95/2RB2jo8ORoeTnZJbjeFzd7kNnCyyL6ukSE21RhicargFGM3f0a3H6/j4PbpLDmwiLVH1/LZ4cU8ZtrOKwv68NTSp+wPpWOusJXDJ3dycWiy8/uP+QfYHxHBR00bu3nP3lr3lv3mG+97ylDjA6fLz118lnHgOaAOoIHNxsmUBJ5q0YwthpuXcdCKY6KJlxb04Y7pNzpj+bZv+BRPzEpB+l9YDSIVgOn/x1PTb+H+ef8kKzcFtkyFPPu5PG/7ZO6e45q1yqIthHjE/x43nDO6KJ88P9P+AszIcHl1jYN/Rmx0DRBxzMxl2jOfn+vb2/nT90zHZvY/ejs8NBzTr0/yYItGPLbmRbKOeXuw34wbidVmZXvadp5a+hS3/XIbt/1yG1prfkgYz/VhJ1htcQmH7SEWHszdwrDYYUzY5UqH90HTxnywYwJYzJgz/E+2MTJupN91RkadWMeQ5U9jKjY5G3OFZQgV2mfJxWQxYbKYGLflMxh1KbGLBvOf85o4rx/A6aX15UG+bfbtDFo2yOnxbmbxLx5OFWXSb5nvM0KbMwAAIABJREFUwZ35S14jNT+VbjO7MXnHZLd1yeHh5FhNPLH0Sd5Y+wafG2K1fcWgn8hOxhI3AWux97qF++0ZS4wCOabQ1agtUgqLn2j/Y3nH+M+KF/jzRMk1/8OD8Okl7CkJ6TDZiin64yuyd8yElG3268aD/Vn76RtZwHMtmrktTytII7sgE0rLNHBwLWQdgoUvkbv6Q3756xcyCjOc94FmFneBXOAjY8PTy54GvNP9nQwNZczip0jNT3XzlmcYQiUsJtczxhFC8pchC8OJTa4YZ39hH0aKTafINefywR8f8OWB2c7lR9Z+7FbOnGX3zp8oyX3sC5u2wZI3YNMknzl/A/LpRfDzY17jdP7E/RyyaVupAjkbb2FYqBRWw/lgA/grBjIPecdq/xXDznkDnV/zAwjNgcsG+l1XHljxn8UCFLEePX76j2/g58dg/HVwykeKvSqgLHmQ5wJvKqWWa62/M65QSj0J/AsYVZ7GBULZh5S/CAwGLgTSgFnA+1rroEbHKKXuAd4FrgGKgBXAf7TWpU+ZVQXsSHENnMssuei37Pm11O0WJs5164o55cP7lluU7TaK2xrEiGOLtjDk9yEcyzvGSdNJripoQoyPWNclh+1xeSN3T0at/ZSOhUUsuKAlpNjtuGfOPVxc53z+Zi7itgvv5KGb7C3vNUfWMPsv+41vd24et5gK+KD5eV71913cl6faPhXQ1vSwUP71cw+aNL6UDSn22cCSLL5vwvGRkVxYXMy2umkUa/eHjjUkFHKOu8VOGW8CmYUZxCTbvftv/DGC3hf/02375XlJkJfE5FVvcNuWn+H8FgCE/vkDdQxeVpu2OHNgvrbYtzDYMu12Lo88j7AHvuaQKZUhvw9x8yiUdqNfneydjSAjNIT3ahWwKcp/D0JmUSanCk6xOtt+vuzZN59/tPs3H+6ZCh6J6IuVgqxDFKduh5JVrWo3J3PPSna2uQCKsvjfbwO451AC3Ra9BI0v4as6BRDmujUVmPOo7XGjPXhyO1x4B2jN6z/czNLw4MIDHGEqnvx58k9ua3MbM+u7uvzOi2wKhf5jISMIYWmd2qSEhZESBk//PgTCvQfupa0awWNHXTMwWmwWvtz6JZN2TgalGN+oodc2vpgbVsyIcR0pzDsObS4IaptAbIyKouvMLlxzXge+u/M7CssQDphq8PDtz/gLzHkMLkl7aPQaHcw+yLa0bX4nidhyYgt1S7qE3z6VyUs+ru/SSA8NZcuRNT490QVK8UdkJFvyj8DB0kODRm8bz6bm5xFl8/amm6xFJB3fgtmPh7FAKYoCHMMlR1ez5OhqdvTfYRerQLhhwNSTLZqzPbIW6w8d9RmbmWZK8yk4lh9azugtpaRmNDZQts3g3+e3JPlQOEdyj5BfEibj6UEushbgOUo5qyiLz+M/Z0+WexjDq82aknAqnq2rX6F769ucywsMIXfW1R9CY/tgXYcH+dhfi53rU+InQbOmgX+HAUthps9Qqw8au3dkm0vEfGaAyYasVjPE2QV6dOwH0Chw+kcwZLEw58G+38i/7T8By1u1FUtO4Nj9HTqDrbUi6FjkOm6z67v/HseZaf2iPZRccw1K/rs6c/ryZ+OG0MCetu1UgAHRSdnlM6tlS4uF3NAw8jzOTRv+G4xagdXjv9PYXAOQS8lPX1mURSB/DDwATFRKvQwkYD9HOmCPPd4HfFTuFvrnc2AoduH+GfYY6aFAR6XU7VoH7s9XSvUCZgPbgNeBBsBLwAal1LVa6zIGblY8/zY155KMLL5s3JAiSwaWLzvxbf3SR55/7THCPd3HyNU/9/3K5Ljhzu9xfuI5jVi1hWMlcVaxKbEsCWJgxQdNG/PzMe/9J+UfIwlYkzidh5pfDxvGsau+K/PBr/Xq8qshXskTR2hDIPYWpUNK6Z6JfKV44IJWQCrkuTdAWmZvgjFXUnyBK0exsSmRneVqWx0JDyO7wPeo80kpq5lUIo4BcnMOUyekufN7kdY4ck+sPOV7pr4n1Ak6Zx0iLOZpNuT4TlEViDdj3/NalhUaSmztwOE1u4+sY1isq2v5aMYe/mGzccjHVKz/adYUUjZSbAjHOW46wSuGB+HiouMsbtGMGcdSmRKWzckw9+woBeY8Ijy8m1/siaZ5rUbcmp8XtDgOxLHds+Ha1zhoELj7sw8QnToQ/DQWQg//wd4I1wCzwz7EMcCxTd9Aq+Zuyybt8E6RGAzLLae4NLT8snMWWc1sSt2E1poCH8+yq+pcQMSpAyREuj+wTqTEQ0m8fqbV5Jb2cHkd9/9vxp4ZAcOrckuukXo+RGkwHIgIZ2r8WJ/rCkIUJ8PKNivd2tpR3J7v2xt7IHERxX7GqmeGhvj0/Hry3rq3+S/27lvjBDjbS47xn5G1fAtkPynC/Inj9NBwCnKP8Ld6fwPDpDVWILmkIbszfSe1SnpnPD3IVj+/ZcpO74l+HOfHjvQdNIxs4nO74qI8wF0gmw0iKbWMUzkX56eTn7y21HKTGtany/6F1C/wPyZGGxoqm6OCE2eezaS89d5hOW7ltcaSW3rWiJ/q1+OaNP/ZSubXq8NnTRpxsdn17DfeEXYaMkkEEsjlRbjWhNisEOr+/wXKgwxgy3Hv9dPA+5Fmjrdoxn/NmZzve7NKpSwTheQqpW4G/gf0wTUgLxP4BnhXa10pSSuVUldjz5gxR2v9sGH5QWAc8AgwI8D24cCXwBGgi9Y6r2T5EiAeGA4Mqij7T5ctEZ3Zm38YGu8hKySERaZUwPfNyEiGzb2b5Zf0eK8yk7P8p1ryRxppgP2iCGbUsYNHDMLQF1nTH6ahzUZSs6ZQxzuVXHlyXUEhm6PcBySaAsxZb1aKpbWjOGIQQ3mhrruANnTNKg2nDq50tuYDkR4aytIGrv8pN0gRFBcVCWUVx1Pugot7lF7ODzOP/O72/Y+TW7k+fZff4/af4mS6FBe4zda4Jcp7EOi//ZwXJouJev/P3nmHuVGd3/9z1aXtvdq77uveGy7YGBs3MNUU03v7gimhO0AgkACBEAJphPaDhITQe+i9l4ABGxv3uvZ67a3q9/fHqMxIM5J2vWvLRud5/Hg1mhndqffc9573vDrT/5+8dzN3Op3QwY5VD2/Qxlc/vUJ9zEv+4wSRdD/QlMJ1+srRddGQS8tK+NOWrs08B/jLMyfoEqIaYWVwa1scQY4lM5stZkr9fl0yurNhBWa7cXpKWyjKmNVJgnxVSRFuA0vJZpMp7pqmgtcN3jvrPTvwGFiCNZrNeGJLb+rgmVXPM89hZ4Lbg1VHevK9zcYP9nhnj607OzaxOb1nBTw1l1vqTsXduJr3SovZYrFw99Yo0a5v3YI19GjFRpBThfoIAsDbG97WXU9NlszuXbBtucZ7e3MHBzL+Lx/E9+WDUJm4P3kuJ5vnPriG2+q3Q2kxw9yeyGAk0u6QvjwILLelUKwnhM8cdh7LzeGG7TtoW/kaJJgB8Us/t/30hOH3YbycnUVDgnt2Zah9q1SzdeErJ4GfVH1Tg78dBNiDQTwJ+rXdgVVKXa1uEIwjyFIS8LVFZhXD+NosWW134E6ThL0OnTEp5S4p5flAMVAGlAPFUsoLpZTJ0067DsejhNdiwwZ/A9qAE5NsfyBQCdwfJscAUsqvgbeBY0MkOq1w8jFHMf5QxYP0M6eDJSXJyfHuos7j5a+b9U3Cv3bsPjHRw5SaapbabJpoXiIsaNZ2jmYpObYptZFznSdeSqJXYz6MZpOJyxO8BIMqHaBAsiPFzvmxvN3Pb52QW8c3q9cxoT2xvdj/tn7Bv774Q8J1OoIX2tYy6+UTEq6zztqxzk+N9oCXgI4N07M52WzvAnIcxnWf/4YPQtFzWzD5C/oLp4PGFDqdP6QwXdsRvGhg2bc7uLfJoCJX/TIsOuc+9tn8wuHAadCpfdu4nPoNHxv+dthbNisomW4QudXDoc0KqXEnuAYtJhP1XXiPrG/4Aa9BJPJrezTyO7slscqvwWzmS7td48Ubxp8N7pddHajYqR5qXLPsIX619R3eynLxg92mifCvbV7PylDSbWwEOVXsSnEwv031LjT73fj/cxrNqsS2LR0cyPgRCYMZsQiTzjqTK65/CN+5Wyxmjcd9Inxvt3N6RRlvZLl4IC9Xk+eih2+2fcM6d/wMpknnuflUJ4CQCOHB7VazWRNcCaduHNfcfTUJrFKfSAaFUCR2OpBIvDEJhBKBDOVDCHN60K9ODSmkgm1Synq5d7w5xqK8AzQ6ACmlG0X6MTaF7QE+0vnuYyAX6L+bbexyWM0mpvap6fT2eZ2IEOQEg52KLNxan1zKAHDpDv0M9uOrylMmVSeqXnbHNTXz4doNTGlLzYN2lXtoSuuFYeQnHEaTKiLiE4KGJJ1HuSfxi+CcxmhkfnZLKxaDx+3q7Tv44zf/RQB31DcwxGOcnHFRWUnCQUBHUOlLzTt3s7nzBNlHEE8HHBY6i3WeKPF5bHNqBvofJJGjAMhOen0WBAK61/uFFAjy0QYDRD1tbUIE/ZEIoxqxMwA3FReyNoY0F/kDlPr9NJtNLFdFRMe1a51c1kvlXs2SQe5M8b0BcPP2Blyq47lja7wEocVkiiNeI92dr1C5vXGVoYxilc3KytA5mNCe+DeuKi3mlMoyPnB3j5LvMJUELBavGkTHizoZQd5hVBY7BHvoGt2gCuiYJBxp28kr/qiUYE2KAZEw/EKRw6WKL0NR43xHAfaYEvPhI9/YwSh2GG4hOtQWNfI7OXOiRngPmw0Gg/kB498oNO3eDJdVSsw676kA4DM4JVJKdsZIlSRRQi8s6aFB3ldLTVcC26WUeixgI1AshEg0T1KpWldve8BYAiOEOFsIoe851M0ocBR0etvWQOJIVuGG2QS2aIsSeITA0okh0LzWNv61MbHH4rTWNgqbjJONjCxiYvG/tgmRvy1S4pKSa90XpbRtdvnUlNYzgoh5MWxVJ5eZTNQnIYZrdsxL+P2MtmhEbZTbw9vrNsRFzPt6vZzQ3BKp8JUXDDLIE5+BHoY6qt3P66WnR6g8i7To5/Uyc5fxy3XJtkYKU+hYvQZTz328Xg3JLjYYMDSYjW9CU6Drow39vT7GJCE5akxfP0x3+fgk+9CLHgFc3tDIu+s2Mj9JJNII/b360cbcJJ1xLHmUKB2gEXISdLwOKRmscx8aDfKyxl+A5bA/pjzoMgG1Ku/eYQb3/BcxZP6vWzrmVa7G21kuXk4wQGkKPVud1VOr8UBh1DRqQILnWQ+xgxU1YuUFYWTLIKM6MXiIld/EYqLOM+AWgtUxZG6NraMEWSSM9tpibrNw5Dzf7MCe10PzXTDU12wq6duhNoSxy2xiiwG5Lk4Sme+KeyXcVxpF1PMSlB/fXYL8g91mLLEwiiDLYFxSsCQayTelSZLevkqQXaDjh6LArVon0fYY7CPp9lLKv0opxyRsYTdBXcDD7HNxaq02MWCo2zhy6CXxTXfTsedx/YJRmmXfUo1j6FmGnZoRBDDI61N8dQ3gNgmqT36BvgF9/9pU0L5hEVf6z4t8tkh4uewcNrQPxbdrOJ76QyhrPzda1CEGI2uHpPQ7wzz6RD7ZpOCqmJd+rYq4DFgzC9+u0YbbFm+ewkDV+gLIC0qKmrVjt0p/tMP+ev5LPOGfiiMFiQBAvb+crasvgRX65YNv2tZAztYZ2P3x5y/Q3gNLe08e2aQvwdHDzdsa+M+GzQzxeCj1+7l7o4c1K29hRGMRw5rtrFl1Pddtj5/CdqsIdu92bUfk2nho7OodhkX1Kuy3aQx/9B8ecVcApZN7ab1xBvrz7vm4N2oLM7SuvoAKT+IBUpWOtVmxD04afi4sfCSlwYcejIhwbQz5LLVE752sYFCXPOpJLMLo7TOe9rdll1NeNjx+f8LEUxviB89Oex6MOinunCSa+RqqIo6FKhKgR/RmtLbxyKYtOKTseCS9g3jLm8gRNTmcFicjC6KTmJfu6HoF41UNO/h3KIjhCgbJCQZ5YHM902JkLskGeTclmY3K0uk73ClotZPBD7Qm2E+2XT/3o8aSiz3G5z98Nzwfkg3qRUQTYYXNyoP5+r9XqlOcRQ1niu/qRAgA/8jJ5twYC8Aw8hIMZMuaUnt/H79Lf1bKLwR68YtgUR98BhpkpD8uEVUSvQ7C1PkZx67EvkqQ28CQ7TlU6yTaHoN9pLJ9WsDmEFx24KzIZ+HNp2mNcbXv0px4zn/vlnrmtLRyTFMzk3r3whQzAi0tsFO24DfI5VdwUX18FENNgEtdpSzsv5DLRl4MORUEKkbiSPCi8eWPYXSvYp4+/WRePSreGD8ZvI3jqbSO54lzJ9J/x5H0bM1h4tzXmXPebXy5ZDZzyy/H0TqT381bxBcnfcGSCfGuDSNrjKci1Zjo7KO7PNUoN4DLPwRLU7TYpKfgcFbcfFjkc83WkRwb7Bf5vHrnXL4O9o58DkfyTK39eEClC68dvYj3pzzCtgtXMmLMJD4ffjN/989PqU3bPH3ZLkvxxswuTGtt46+btzLY66Ne5tOw6gqOWD1cMyvQtu40LvedR7O3mj9sCpLlN9GrfnDC3+vh8zPA5+OPm3axY+U1zHb/Dg823tvyC8bV/ZOPrzmE+7bfYLj9wPYT+Gbj4sjnxQ3NNLSOTOlY1YiN/PdzRX2Xv26fwp3+hXxmjTptVPv99Egw2JMBJ76maDvKPGaC7h70DCTW/rV44++/Le463qg4iy+zp2LN6ZgEKAy76vhO2hXNnbZIyRXrcvE2TKF5+fWsXnpt5Ltqn581Ae1AUBJnBa5BrwTnJCu7nNL+c+OWB4Jm+ukQa+FQCEbPcu0gvZeK1A/aVcivtzXw/PpNbJaFVG4bwph2N9dvb4jMoAAc3hwfeb9++w4KeyiDGCO9dFdgvKWAJ9uPSGldIylYhaMvb26IkoRav08zYNtdzCyfyAlZvRno9fHS+k08umkrdqkM+G0x5+Y321KXvehBL7iSSonho0IzZZeNvow/HfynuO8fyM9la4IZuiYDX+htP7bw4xZtX+YVgmMry/jErwxEeiUY+OlhRYLEPnuSe217J5JIYxEUgvsNCDpAQYJ7pzzBM6y+duYEA2W9q/mCdyteqz5Nk8FARKoUJt4P5+UgQ3sS3ZRQ2FGkRys6jk0oMgq9s1+FIr9INCe1SbWu3vagL79IK/hi3ClcDjsnHrHAcH1HjJiwfe3p9G7L5rZtDfyyoRGzSUTsd8KYUKlEOM+bPQmPjJ9aPNccnZIqc5WxZOISTh12Jlz8Deaz3kjY/t8eenfk78rsSt11Tqk8kpElYzikahGXNzQyRzXlPL53Dk+edwBjawv5z+Ib+Mep73BAP4VgFmbZuHPhCL654RCG91DsqBYOWMjj8x/n+Lrj6Zvfl/OHn4/DnlzPeW7+VMzmjiVNxOKthW/x7NH387/GYwl6C/DUH8LYXkVYzSZqgqfgb65jaeMRbCuMTtU/f+EU/tn/bmZuz2Wwx8OcUGTHM/ps2loHRNbrX9iXyTMWUFKsJA/+9pjhHDM2sUlO7s5RWLadiXXXfM6f1oc3rpip+X6Yx8vE0GzETrKRgWyecB/BJ20HUfbjmbSsuAaCLjbIUuZ7b+G0XbexZcWvadk5MeHvWqXkWM8SZrnvolEW0o6DC6f35YzJvbhoRl9Ksu2slfr3AsC0mtEQjF6ze9tOxRubCm0Az/YDCfpyaFt3Gldvj2q7vTsO4LNvBkY+B/1KR7OzLXqO2xN06EF/NkhtG6SQHDumB8v9Awy2CsEX74EspYWzHvmcI+/7kHs3TYosz205DpvJxuSSIyirHxW3nRof+6PEek5TlGCagPfaZ+KpnwdBJ0EZ7QKcUtKmEzNox7jzd3uME1ZPGnQSZa6y+C+kiUM9OgVNbNks3biLQ8ZoK5DNaG3jpfWbGLp5OFPqe3BYSyu1fj8TPfewI1DOg1vqOTqGEC+nnGNidNj/8M7hjWVKhDzVGZZUMagoOvD9ettcvMHU3HfGt7vppSOHWbEhi19+ncfjGzfzh63bqPQHEkpdOooB5aMROcpz1sPv1wxYYuna1rHX8NimLVzQ2Lko9ov+A+KWxQYWppXE38/XNezihRFXccrgU+ibHy99+NLhMIzagn71RiElTo+Xxpjxk18IvlfZo81riSfXqea1xCJW6hGLQZaOJ2jrJc5vU0k8nDH9eN5RDxnuqyRmhuZvw6IBCPU9Z/QGfGjTVkPy3KxzDQBk6/bIICkcRPOYTGwM5R0Jw1/bs9hXCfJnKG0fp14ohHCg+DIn0weH6wfr9eYTgCYgvg5xmuDc4edq/g8j32XhuHE9dbe5pvT8SKnUMIKBLBxoxxHqCnoDCwdyxTjF/PycA/vQszB+Kk2UjeGeg+6hV14vrp8Y9cbFYgOTmYDBfT6/5nDKsnQ6zxiMr53JI3Mf5OYDf8EpTc3cpvKHLM0zU5KjvNSEEOS5khOlwUWDuWb8NTy94GnOG3EeTltygtw3rz82S2KCXOWNHqgtGP9YFTuLKc/LYtXNx+JdcxXehulM7qckrfzx0POwNZzFhdMGsVM10B9ancdlC8bx1LZrGL72IFxS8j/bSK44YiLmk5/m+vG3clS/o5jXO17HbLcljjb9/ugr+Oryi1l6/RFcMbuOXJeWGKktt9YGlevUjoMb/aewMtCXX82byAdXHcSJE9T3m8CvQ6auaohKJnZk9eczOYA2ayGvLJ7CK4uncPkhA1gyfxBCCEwmwf8dFO0M7TEDk4MH9eHDK6PRXpujLw+frnkNGCLQ1pfWldcSaB3A0c2tvLVuAw9t2opn61ykrwh/a2/8LX0hqPymuz4ahW83mMptXXMe7eviK1IJAadP7sVLvmkJ2yS8OkVCZLSj8wSi39vdk/h40ccs//4gnG3xkeeAW7lOnk1H84gvOjNxnveyyN8fBwfx36B+DrNdSt4PaiVH38jePOnX6vSFSvPdb2c5wwxkXVc8bCLgiycwbdLJt7I3jpjuZ2PDTubf8z43PNHMc4c/x99n/Z3zhp/HiU3N9PD7GdSci7bLEgQMRE5/D85kSUOjRsN9u/8Evgoq99amJAnAeoQsFo9t2sJ8awkF9gLumhb1mt/RWKi5hongtOdi0iEXfl82WygCdyVDWq3M9NyGNcVpZ8172AAOiwP8KunE/KghVOwZvfD9fIZ5vExvjSeIU1MgjW0J1Y4KzhugdcH5xZhfYLlmEzXDFyGEoMRZQiDBYCwMu+q9VejQ9ldCSp7euBknHvzSWG44qnQUTh3f7t91IIFUjURynjsPuJnZE6/s8D6Tke7sGEnhOtlPdz2TlHER7gklIyJ/m1VE1SgXabTHg6kTY7cwQdaLsKdSyXdPID1a0XH8C2X2b3HM8rNQtMOPhRcIISqEEHVCCPVT+g6wGThTCJGtWnc4MA14QsoOeOrsYZwz7Bwen/84Zw7VdsxhQ5GzdsZ7EvcqHBRHkGXQgTNGhq2OIJ897GxybdEOzqkTbc3KqWBaj2k8d/hzDCiMj5a1GUTerj3A+KWgLjk7ukYhPw6rmUahJRMVWanJIxLB5TAuPhKGzZGDPckD61AluWWZcrhhzL0UWJXp6v4FWkOUVxZP5e7jRjB9gKIXqy3O4qslM7n8kAGMK5qHDDjxbDsIgEKX8qL7S2A+Z3sv4YmqqwGY3K+Yo+vmc8MBN2DR6Ti9OmViwziox0zGVmmlEDaziWc2RDPqw7rBB/yzmTImKh24ak4dvz1qKCdOqKEq38nNhw/l9Uun4rSasZgE0wbER657eaPXs/qUR/j4mpm8sngKdeW51JXHE6jLZg3AIpRj8gTcjHCdyohdufxydSGunHIqcqP34ZsXH8mB/UsSygAiUEVL/xqYR3EgyJetM1Ds4AXt686mff2Z/HL+YG47ehg2EY3s6EWQS5hMsL2GoKecC6b34chR0WMPChhQnoPHn7hKXnWujrZdRp/BYHs1/rZavI3jWLWtlauf/J5V21sJynhi6KmfQ8uKK/HuGgPePnh3jsG95TA2BqO6xHYZP9Dz1B8CQN62cfzBf6Tmu3WylFiXU7NK8+4N5vLY5q2cqXrneBsm077hRFo8Af78RnzBg6VBRa70u6n/YLwtSnoufV/5neVbm/lkuZmXP8/i9MHn8EPtqeyUWTwfmBiZgo20hWj063e+o8ndMQQZcOLfNYpF3mtYHdAO4F4ITuAi7wWYW2ojS9vWnU5Oq3awPqN6dly7Y/EH79HcMu9R3jjmDSqzK7l/1v30CC4i6Kki1a7VVXeYbqxM+pX30pHeG5niuZsVshrh0vr9ehvHYddxI51SlbjEPCgaZ2b9Ggr7wIlPwZhotU514miNs4ym0PXO0yF6N+oUtLi9p/YeEsI4LyYMuy36rPXJ68PJg08GqyrfxmSmbdUlSfej1jv/+eA/M6/3PF4/+nU+XfQp36xZTx+fH6fwEgwaz4oEZECX8BnJctR5JQdWHxj3vZHMcGr1VGb2W8CMXrOp6aCkI5HcAeIjsD6v/vHmBoOI2H2pHCTMqsBQ3HpE8wMMcrwNEU7gE1LGSXoAVm/vXHJyV6NDSmghRBZwAtAPpUJF7GmRUsrENX+7AFLKb4UQ9wIXCiGeAl4iWknvHbRFQm4FTgGmo3gcI6X0CSEuRiHa7wkh/oZi7XYJSsnq5EPwvQiLycLgonitpwzdwBc27mJOSxt9fD6uLinCKSW5uSV4g1rSVJadR1a79uWlHrnFyi1swXjSlVfQI26ZGnrekOPLx5Ntiyemj89/nD89tohf7dzA3/JzWdY+GpdK2xU89WW++ejfPDp1Ps+ve4Wzh+1+LRenLfoC6OWzc/zky3jg0/vYorL1ttlzyUtCkO3STCTFwFLIUYOnctTgqXyy+RN65fXSrNunJJs+JdrjN4UilGdMHMWG7X9j/lSFbFkiNnGC/wbH8oue+lroWFRlG0ssZtRMi1tmNZvoo9J6hl9ajwYOZqZTUL1bAAAgAElEQVTLypPnTWRDYzsLRsTvt29pDj/cpBCKj7/5lqe/in7XZ/ts8n3Rx9FqslKam1yusmTiEq7/8HouHnUxJYE5XPxFHe8Bn1qVe/KNY97AE/DgsirjXoXERTvwY3peySMfrcVZ9XhkWZ7Dzo42yHVYuNN9DK8FxrBU1vL6pVM5+E6lIpfLZub0ycr1OnJkFSMfVWZQ2mPuYxmwc/uMX3NL2zKunlPHmFolWjX04dD3oWdRBhLPUNTk1fJNDH+Qmuijmfa10Zmi/3yxIbT/eIIsA9lIf8jlRgg8m49W/rREyau6K5o/rIIXvtmMt2E63h2TeFKmViChl6M/K+SnSGlmV0h2dX7jLv7qn4e7vS+BlrrIuss2CHLqtNu3hiQyn6+w8Lfj3uCBr+/j/fd38pY7SmavekopXFSR58Dd40J+v+xggjqxVrPqmt8TOBK2AluDgIkPGYI9uBIbURJnMZt5LjAJsXkoJvtWgt5CpK+IbbZtOLKej6z35OeNBE1FmGzGFc3e8E1G5FVGBD7jK8ZTGADQRhqHOMpY6tZPhFrtGsf64Ico9baikAHlvvaoZmQ27fRrKvAG2ntye91CLvrh8siyvrZDybMn9912WpxQPgQu+jK6sGwIbF3KpmAJoESGZzgO5S+htBw9twU9AnHuf0dQPvhtWgPKzJGwRt+lRsVkbPZc7p1xLzd+dCNLJsbniijQfweXOEsiVQazgsGIS8/AooH8Zspv4tZ34sGnM1AMY8uu9qTJ12r0seWxJpSy5LQ4uf3A27n/m/tZ3qgUcLKUDID2DZptjux3JDdMvAEAl9XF8xs282qWi1+kWGo7mbOUP8ZCzWzSn13NtxcgiUm+U5FikyowEDs4BXgmlJPS3EHNcDhJ024gpjDvaxFkIcQBwFrgL8DlwGnAqTr/9hQWh9oxGLgXpXrePcD8ZGWmAaSUTwCHoThZ3AFcCbwHTJJSpr3+WA/hcq5fywH08/n4PljLb7c1cMP2HWTlFXP6kNM16797eXSq2hvqlNWk2Bzjb5nV96C43ywo1Jd0RNoUmUaBe2fcy6CiQYYvwMFFg3lv09Vc5b6Yv266h0CJVotYVDOIYcfdwPDKMVw34TpybLtfXMOqelmbpeD4uuPpb9NGauyObApE4lemQxWdrMiJRg3HV4yn1KWfWay7H6uZW48czqS++i/KEyek5oN98uCTOW3IaTw+//G472bVzIpbZo6RELzgn8jx3mtZJStxWM2MrinUJcdx+1H14LdtkPzh1Bv5VWmUIKeqLTui7xH896j/csaQM5jWP3r+nCGCXOoqVUrohiBjIqoH95yNjNH3/u6YEZw1pRfP/99kApj5WvbFj4W+pdH7KKiKZljMJo7qpxTqnNQU38GMrinkyfMOiJBjNYIhKledm7iYT7/yQdTFWngFk8ct9CLIFqKDLq9f/QoUmr8n9S3iwP4l3HjYYF5ZPEXR6IfI8c2HJ3d1GV8xjMuH3sVDB/8HGRqgWIHWbfM05BiI7FfTdq9yb7+0dAtCCIYVHM9bG0fErQdwy0vLuPO1HwnqdFXnTetD3xI9H2rVujGhrSNGKvew9OcSaO2H9CnXx7drNL5dw/G39ibQVsPqNQNoXXUxgTbj95sMadW3Nrk5+k8f8srSzfh1SOTCURcY7uP3r62jjfhjkHoRzthrHnDSao3q9XM2zuar/x2gcToygtMS/5s7j3uOT4/5DJ9K07+z3Y47RNJdOpG+2AQ8z/bpIG00q3zYTdboAM3Ilm11oxJRfeOYNxhdZuzsE4v/TL+Ph2Y/FPlcEghwfuNOglt1kiR7KlroNwMj8QeNJRabdrXxXbBWs+yxTca+6KI82o86LU5m187mP4f9J7LMpOOgZBZmRKhvfPqrDQiSJ/Op8XzBqQm/z45xudUxywGgXK8P1XgQG7+vj2xuoTjkjtHSQUIblldYDfZvSbH4THejI624ByVEswAolFKadP51T2k1HUgpA1LK30kpB0gp7VLKKinlperKeKH1TpVSCinl2zr7eEFKOUFK6ZJSFkgpj5ZS/rSnjqGrEY5a2RY9xmPZp7Jx9t8j3+Xm5nHxqIv5x9woWbGZbfhDxG4bSuQpUQTZ3j9+2rE4J7VqftkIplZP5V/z/0VNrjHJc+YW89/gWA4b2ZMHTul+Jz2hGiGHj7wwS/vydDhzkXmDSAS76tYvztp94q7G3ceN4MiRVfx48xzynKklpDktTi4dfWncTMPR1dek1IGuk+V8FFS2ddpSf6xNqqxlPxZ6Frl4/JzotGOeI7WqckIIKrIrItryu44dzk0LBpPjMDp+7avMZbNQna/1DC/OdnHtvEHUFMVHdR84dQxmk+C+RdpkoavHX81dB97Hm5sv41bf8Sm1HaKx7IdPnUGtZQ5H99WvNFhaVIVtzUlUro526CU5DuYOLeeNyw7U6LHVKNOpvHjE8H6M6JHPyRNjni81SZSC2qIsHj59HEXZdurKc7nykKg0atH4eEIY223brC5OGXUwY6r7kuuK3kunTerFNzfM4tXFU/ns2oMpztY+R/62GnLcM/E1KomHK+tb+GLtDtY1pG4YpCYuV86uoymrl+56tx6pJCnGRvDDOQtxCDpwbzqe9nVn07b2PIXYSxveBuXe1SfKJoJBydVPfcvnaxs599EvCegk/y3fnEhiYNKdn5aBHIZVa58Vz1atM42UNtplVDnY6q0ABN9vamK6F6oTTNvHEuRnv97IiN9+zINfNWukSC0+ByB4JTCWjwKDaFt3CodWRCPWZmBySIfsb+2Nd5si1xGqwj5SRUYrDZjaKQ9/Z9hWI5ikZEDpMHrmRq+NH8F5O5toaxxHMCg58f5PuPZpZTaC4//J3UVLuC+wIGEE2ds4gX/7p0c+9/V6DT22AV74Ovqd3sDDpFMVLhLMWr+TS/71PwDsSRJH1TKmz6zjE67rrNdK13wG+y63F8Q9359uiMobjFp0/fYGloTsOJ8b/09Dn3sjuEP9rggIXemGNUnxmT2FjhDkQcDtUsrn93BZ6QxSRFiDPKR/PxZdfjfjhg9jsfd8LvBeRI7TikmYGFoylCUTlnDL5FsAWOS9lqXBWi41KV7EiSLINnP8SDg7hSQ3gJwURUr/74xxnHtgH246fMgeH0WaQqPZ2OkdpyuP+oLoC2lM2Rj6F/Rn8aioBN6umpTLsqR2TlLFghFV3HnsCGyWzp2Py4fcG/lbJHBjeCYQzTb/wRt1QXB04HeF6h7xqiZg31r4Fi8c8YJG094RHDGympMm1hp+72zX+s66bGbuPW6SZpn6fo49DQfVlfHTLXM5qE6rRbWb7UyuOoAdFPKXQHK/5XD545ktyg/0Ks7i+UW3cf2kq/n99N/z91l/55xh50TWz3M4+SA4kuXu6P114MAs7ls0mj4l2YzsqY2C2y0mjhxVxWEj4rXLwyrKeOaCSfxqQTQKnO+yEhtBXjReS6CHVueR77IybUBJ3P3Rs9DJ2JgIudr5RZ3cuWh8DbkOKwPKcyjJsTNtgDapyr9zDJtWz8CuukeO+tNHbN6lEKzpA0p4/8rprPz1HFb+eg6xuGhGP5bmTOUy77lM9yj+798VzuR63ynM8vyWA/pEB+vlIRmPd8dk/M11tG9YRN/SbEqy4wmyWjseC3/LIFpXX0ibTiImwFfrG3lzWX3k82dr4iuD/uU1L+4tRraLEvX1CXqKqWYB9x+3gMfOjN4TQ6pyCbT1pXnZTdFNgxb+/l506r5ZKoR67h/e4/j1Ll5UeU1PqpzEP2c/E/kcO0i++PGvAXh56RaEihas3Ka07VzfJZzgu45A60C2bo46vpil5NfbGrDVT8a9UT2AjBJk96Zjqfb5qPX6uMMg0U1KG3Pvfg+A/363hXd/TF7M5f4t9RAj1QsnhUspWNPQyvsrt/PYJ+sA8Fpz+VP9YHxY8Af1CbJv1wj8u0bjU0lbLt4Rn9OjRtAXHYiHJV9q6MkbwgR5Y2M0yTFRBPnG3sdoSoG3J6kbIzHxREj+UJtdjcevndlwmpVneE7xaA09ParmPE5/9NvIZ1cgSvjlhGi9gaObWyNv961ZdYyydqwyaziCbJIm3RiyxZweLhYd0SBvBtI2cS2DaAQ5jHyXFd/gY7BbTRqyuXDAwsjfRx11LPP/M5C/naxEa9UkIjaCbNUZCeuNmNX4vx07uacwn8t8yUvyAvQry+GqOXXJV+wGhB/V2AxauyNH84Ipdhbz4OwHAfj3J3ewyWphmDeHt12KlkvvJbk3ccroqdyxVPnblCCbbbHvQixrVyDs2/Gr9KAdiiBboveIX3X/FDuLKXampq/rDO4/bAknvhG1FXRazVRka1/a6vtZYBwdiYXDauaIkVXYLSZejMxP6W99w/YGjmpuIc8bL6uZ0XMGAEXOIv7yzV8AyNaJiO/0ROMPZSq99j/OGs8BfZRz+Op7G+K2O0KH6FXlOwnsjE6qzRlSyaBK7SAlx2Hl46tnYNcZCA2pyqNPYwlqsxu7elBc0CsiuS3K0g6gf3noIMpzHZQU3s+tbz+Lb5cSnR9TW8AHK6Pa3jv+qxgGHVRXSnVB9NnpU5LFT9ui0ax8p5Unz5/EzDv9HB+KdJvNZh4OKFHL/541ge83NfH52h1MG1DCH44fyWvfb+WOYx7nrWXbGFadx0c/aTXFdx07nCNGVnP8uJ58v6mJ659TIpkXTu/Ln975iUAQgm7tYMQizexao+jCn/nKuFR0y4prEJYmpK8IX+NkLDnLsGStBKBHTg/WN69neOkglhH1gJ9YfjD3Hxb1pj5qVDXfbdrFlH4lLN3YpLETlNLKss0t5OjkgV7hO4eHSv/FsFwHP7SsZ+GAhZz90DIIqccSvrdVwYzl2+PviTd+2IatZDpC+Pgk8A32oI+GhnloBmKqCHLQU87LIbIekIJegQtYbb5Xu1Np4fvNTdQ3uTn7/30BwKpb5kZyM2LR3+NlrNsDMUEcv3qwoSKcX6zdQSAIbl+QoiwbMqBPffyt/ZTjUEXRjQrl/GpbA5e3Xo1UkW2H2UF9k1uTZxHUkZWECbKaCCYiyLbKUahj762eIDfOuJXHlz3Bil3f45faYi4BoM7r49kNmyi74CWeXha9Hr6moTRvOZynL+7HyOZGvlWd4mzPDDws49HNW/nA6WR70Tg2BT5VvtTp/wG8gSB/mvsIr/37aK6zp1aJMSy9NAXN+gQ5TSLIHSHI9wMnCCHukVJ2rrxTBt2KYIz0WgjBvYsS+6UuHNODBSMqsYfKfiaSWISdBdSIjTLH4uza+Rz37T/JnX9PwvXSAUYE2Wq2k2WPvp7U0ZfHN21hpc2K3zqIsL12skHD3kQyf35/Wz9o01oCOawdIMiq+8HIgqs7MLy6CBG0I03KdLbLZibLqo0Sqe/nC6b35Z43V3LugaklPd51rKKRfTGUhGfUcdtQbI/WCePqWWr7qSydwcdOd5QgD6rI5ZSJNfQodEXIsbKPIm6v306Z389/skcz6/Crcdmiz+fcoeW89O0WTppQw8R+A5n/nLI8VmseRqJr3NNazBHNLTydo0TrnLbo/d1eOZHrvj+N74K1PBkj/8l1WLk8JN/490devkMpWDKkMo+FY3pEopZhVOZrn5vHz57IT9ta+GDldv756TrmDaugLNfBl7+ciTU04I+NNA2qzI0MAA4bXslhwxWN7uwhCjOcXlfKwIpcjhvbg+PG9Yi898bWFtKnJDtCkMf2KsQbCPLXd1fFnY+JzZN4ya3o3//fx2sNz5v050Z0ygBBdwVkrcQsLDyz4BnafG3kO/I58pkHWLFrfeicaQcZv1s4HCklj3+2PrLMu2OSkmDoNvYLXy/LWNR+BW/OO4AXvt3AqrVmNjUuJSdEkL0+5V7x+oM8/ZV2sKV2SHAH9V1+vNsO4YFTx3DSQ2HH1Jj7Smj7Io+0Yhc+WnHS5rZD3CSbcj2/2RCN1m5v8SRM6N0y8z7KY5b9RBlTPYpDUosnSlOO+tNHXDRDea8dOrySlSvshI/avWUBjvJnAQh6wjNIanszfeJ6REsrl7h7g4iOHl/9rp5b//kG/zgrGv0P6Gwf7qvNoRfyZd5zucB6v+Gx2i122lXXZVd7gGc+KOXTHxeS3/92MCvEtMgfoMFiprpJGSz39vnBkYfXrxoYSjMEshhZOhJc9Rr6/8e3VgJmxrs9jHd7+GWpibBRjDQ4D75AEFd+DQvO/ozrHu5gYSNp0nUgsnZB8ZSuQEcI8q1AJfCREOJPwBogjihLKd/tmqZlsKcQ7iQgscQiNsEqJa/Cw+4hd9LFUJKkYEIaIHw0scdlMVmYO7SE6xSpGP3yowSyIBhkrNvDRw4LJ9SdwD+W/YPj61LXqu5pDKxMLnEYUJbD8q3RzOaOEeTouTMlY+NdjujvOW1mTMLE7NrZvLLmFUB7Py8+uD+HDC5nYEXnJB8OS+JzYkkQQyhwFHD39LvJseVoovMHVEzhw83vMbMmWrRFCMGNC+IT50xmC7NDhWM2Wqs4sIfWXurOhSM4a0oTw6vzafVHI8imFFR1Q4qGsLRhaXQbAePa3RGC7FINPFx2C48GlPYaDRpAKdwTxuCqPA4bXslBdaWc9+iXvL9SCUGP7KnVjJfk2CnJsTOhdxGXzuwfkX9YVbNh1g7KsAqzbLx8sb4NWmGWjXMO7M27P25ndE0By7dEKxAumT+I9z6oI6tgHSu9hwNJ5rh18OyiG3l5/T9Z0Hc+NrMtIlnLsUfPTWFWPCEUQtCzMBpZ92zVl/oEYzyntzS52dEqueKJsKV/9F47+e9f8OkVfbj+2e/41+frNduZVIRPL8kyDMWi0eiaRwnyP8+awKX/voGL2+/jKt9ZrNoiyQqNSz3bpxN0R2c+znwkWsJgfWMbvqCkKj8+4NCOjcbeh8YRZC9m1kmF5LZ6tIPUZ75Scu8P7F9CjhjB/3b8E4BAW1RyFPSEZn40EWQF64IGPsyqc/TdtlXAKB54f01kmd5QORg6P+GZySeDU/nFtFpYeZ/uT1RnV/NlvzOh8WkAmtqCERmKLxANpN9dv40FzX/CKT4hkmtptmklFqEZgr+9u4qzpvbWiY9Hr6lZxV77Feh7Kft0yliXByRbUpBJmKRRBHnfS9Jzoli7jUaJJr8OvKX693bo/wz2EmIjyJ2BmhzGRoyd1uiL6p1j3+HD4z9MvkOzBUrrkocu0wBRDXJM5NxkwWo28djcxzhjyBm6BFiaLFw17io+P/FzTdJIusGVgOz+cv4g5g2t4KUYAuHsAEE2mwQXNO5kZmsbPXypJRR2B8LE6eJRF0eWqe9ns0kwpCrPMKJqhFun3ArAb6bemnA9uzmxgOOgngcxtnwsBa5o53rX9Dv426y/ceKgE5O2Q6i8rwOmeF2tw2pmZM8CTLHVMVM43PsPiUaySl2l7CwerZkLcFmjbR5QnlpC6tlTezNzUBknjO/JrEEKgclxWCNRvcIsm4ZEx8JIO3/IYIUixSa0dRZXzxnIyxdPIdtu4cQJNRwzupp/nDWeoiwbbzeeiinnz+zyaLvNZy6YxH/OTVxBsirfSV1ZCZeMuYje+b0136mPrSJXX56lJsixaFlxNa0/XcLoHlVcMXsAP90ylz4lSoh28m/1u+TmNsGjH6+NI8cAfrNWSTlnSCwNVRB7vV5dPJUvl8zkzMm98DZMA2Bo1hFM7FPEp8E6Znlv50vZP2JhB+DbMRl/s75zyh2v/sik37xpGKVf29DKzS98z642HwdXK4MGb+OEyPfqaDTAuh1tFGfbmNyvmJy8ARRvPJistccS9BYjAzaqsmoxR4rzxkeQZ3pv120HgK9ZSeIOH4tLNfCNtVyDaF/d7osOpINl8RUHw/hqpYs1mgqj0XtQqsh8VlDGVcg8/M+fctury1TbKsf265d+UD5OvNDwd82maNvn9ZrPkglLeE7ll3+TbxH+gHJ+WlQDkkWk9l4wGfg6pAtB7kgE+V5gIfAMih1afDZCBnsVsRrkzkDdmcZGUoudxVw7/loKHYVxVYr2B5hCI+vYSLk1lGQxrGQYw0qGxW0HIE02hBDYzcb2QXsTpww6hXc3vhsXaVTj9Mm9Ih7AfzlpNOeEtIAdiSCbTYJzdyqRtw9NqVnSdRlUly08dakuopJMDpQK5veezyG1h0TuCSPk5af2fGTZLRFC5rK6mFAxIflGgFkVwZY6ybNqaJxaUpj1ybJm8cicR3hqxVOcP+J83lvWypP+aYASVXbZovf4hN5F/PaooQyqSExQp/QrYUq/+AjcuF6FPHL6OHqXdC6xdXRNAa9fOpWq/K7X/btsFm4/ZjgAb4US8ZrafTS7tQRyUEUuNouJ1y+dyqH3fED/smzG9y5iV5uPl5duZtbg8oT2jIlkbWGo5SfXzRtISY49IlGR/jwkeSwa35MjRyl6aSO3m/ZNR2OytCADOdz84g+66/jM2pjnJTP78/JSxeasONvG9hYvFpPQaNYP7F8SGSwNrc7D+/5M/E1DmXWIYg3qVhFBNUGWoSSw+xaN4vzHVJ7MwEerFFnAkmeWclLs+RNw7qPK+s98vZHTJ5/Ks6t6E/REyfxvX1lGLO49YRRWswmnzcLqpoOjX6xbwnPXzeXbsa28v2I793wcddWwhrpVDzZNndAJ7qhs0L3xeLy2hohEw2YxRSYZ/DqSuwhBVhVRanTVxq3XM7s33391HNf8sBRLXj3OMEdWEWD139khm0Ghivx+vVHrc6wu/DP4l69QVrPTkAm2eaL3ersvqOQv+c4C4DbfQv4emMe4dTtp9wa4962VkXVtvQ5kBh7eWPe6/o5DEAYR5I7ODHUXOkKQFwAPSCnP6q7GZLB76OoIsh6hOK7uuN3+jXRFJIIcc9yJiFVQCkxCsik7uX/s3sTlYy/n8rGXJ18xhIkqRwCHNfWXlVpW4RbJ7eS6C+HpfjVB7qrypQnJ8emvwn+XYDn098brxKAzMg+1W0gygqw+7lR9qEeWjlQ0ioCkhRaVnViWTXtdjx27ezMmU/snLyGcCGof6+5CrlO5j3a2eWn1auUzYXcZdcGcMH5z1NCEzjGglb0Y3aNmk2DWoDKWb23mxAk1OKxmHvxgDV+vj+rVs+zRez3XgCD7dyW3zvSYtMdXnuegKt/JrnYfD502jiuf/IZfLRiCEIJTJtbw8EdrmTU46v6iOIWYCHoqqchTBj5qgvzHE8Zw0VPno0RBlePtX5ZDXXkOy7bEFK0It8kfK1mKEsDtLV5ue2UFkLiyqsNqYnxv5b0WO5M2Z3AvbBYbo2ts2Mwm/vCxKoJsEHjagsriVFo15LzZ7WNI0TCWNnzD9xuGgv1zzbbV2dW8/O1mljwbJeJN7fFijDJ7P74L69ilftRYHU12hTiASSdqHd04emyt3gAbGtuxGzyCK+t3QXH4mPwxNpvKfj5ds4ObXvyeHS0qaU75MNj8hXEbQmgM5qW1xKIjBFkAnyVdK4O9h90PIGvIoF5S3v6M8Gy7iFEeJToPU713MUqsYOLAw7uzaXscuaoXYaxFUCKYBLwWGMVw0yoedJxEfGmZboTWMQvQXju9ktxdjp4T4MzXuv1nZFaUkBQFjKu9gZZ0dXaQsDzYA1Cy2bOs6TlL0p0IPw8bd6aWpR9GMnIcu06iwfhfThpNUEYTLa+aU8dxf/048n2WKknTvBuStnaTUokQYGxtAbkOK29dPo2glDisZl68KCrBuuGwwRw/vid9VZVBi1RWemG7vQKXjfpmD8XZNnIcVoJu7aDKZTNTlG080Jv0mzc1nzvT1anPjysmOXb+8Kh8wWU3azXIHSjgMaQql6Ubm2ho8XL84Jv45ItXWNHek5yQM57053LysAWcPPAMRv1Km64VOzMBxBSeUV9Ts+5yV1By29HDaPnwM9hh1ErtvRFo6w28QdAfn5CpJtq72n2amQx1Zb13lm9TZEChSy+EQKZg7douswwiyOmRpNeRt+XbQGrzfxnsFQQTjRpTRFd0pvsqwhILc8zoNWGn9X9HMuiQM1i4m1G0dMTRo6vpWehiaFXq+k6zSXCW7zIme+6m3pK88l53QyOxSFINcV+CWTUFKc2JiX8qiXnJ0KKyHXBaE0es90eEJQvbWxIV/egcUn3nCiE0mvkJvYv45JoZkc9Z9uj93eIxdlEBWDCikhxVxPmIkVUcPDCUoOZTnndXwBTRiNssJl2plRCCuvJcjY2omuiGbQrvP2UMY2sLeOi0ceQ44u9Xl83Mtmbjc7u9peNJkbFQt8tl17ZBLUlR8gLUBDm1/R/Qp4g/Hq+4Rv20rYU2r5lgew1qQhpor+KKsVewqTG+r25y+zm89Ld4GybjbZiKWVgYlq2uCKgu+KO6T1SOOW8HRlKd78RuStToWILch9bV59P606WU5doj1SaVVaPtfPILrduJ+hecNjO72qMEXyCob07uCiylfnw+XbhHR0Iqi4E3hRCXAn+UUu7+HZtBl8LIhqUjSORisb8jLLGIjSAnwuDKPAZXdk2CULrhjmOGEwzKhO4EsVAkFgIv1g4nwHUHulqDnC4wCcE8z6852fwaq8tOxFhZ3jmJRRxUHbJewaD9HUaSha5AKhpkI5SqKgOq3YjavPouKr8/dgR2i4k5QyvY2ebl96+v4IzJvegRSgKUUnLts07a1t7N1oa55M3q+HGrE0+LQ6R0WHU+T5yrJKGtrG+J28ZpM1OV7+THrfHf6SFZTzdnSHlENz2mpoANje3cEdKTQ3wEWUuQrRoZgh6F04uOCgE1RS4GVuTyw+amiGuGXrt3tMbTp2a3j2JrPzz1SlEZT/0hfBdQzdZIfYIsVAT5TN/lPGk141Ad3iGDy3j1u62624YRdPfEbBK8fumB3PHq8shynypS/dV6bX04dQTZYhI0ubUE+au1u7DqeHRr9iHNumG9VGZe9gQ6QtPfArKB24EWIcRaIcSqmH/7bJnm/QFdkaSXyMVif0eJVNi82pwAACAASURBVKaP9h8atfvoCDkGrc9uOlRD2l8jyBaz4DvZiyv9Z+NzJi733jWdjYogm35+BLkjiaodxe7M2hld24o8ff3/4SOrmDNU0ermu2zccNjgCDkO7y/HXsHazWfj9laT7+z4tTabBE+dfwBPnX+AbjXUXJ0Iss1s4lcLhnDKxBo+u/ZgFh+sRK4HVuR2KAcijEl9o57hx4yp5uNrZjCsOsrWYm0a81UEWTmnSSLIOiQzvO2xY5REyS/W6vkYCH733+U8ERONBUXjq/VMNvPWcsXK7dQDalFHfhfPqCPHYWFC70IwqSO1AofVhJr/x9onGlnZDK7MJcdhxWW3cJH3Ql4OjOUHGZ0ZbYwh9eqWevxBmlQR5PWNbXgapiGlwNrUX/f3AExi/4kgr6NLVK4ZdBcyEeTOYd72KQjLO0yZ8GugY6PGDLQwafSUe58ga6vn7f32dBXU57m7M76lRBO9+jlGkPUwpCqXs6b0Tr5iEqglMJ0ZxI3vVchP21rpUxqVwdxw2GCsFhMvfhMtN62UHU8OtX7ZyA0jGUbFkbIoYqPxdx83AiEEPQpdEc/vcw/sw/Ae+UztV4LZJKi96kXNNol6ujsXDieoWiHLHk9zYscVsW2aUVfOR6Eq0Fd6z2a7P1YuFv/MhSP4anKuh3veXKm7vKndZzgQq8zXDngWz+zP/83ox60v/cDSbVppitNqxqaymRwUlwSs/x6szFMCRNl2C88FD+C54AHYeCUSMNrRFkuQVQnZvgBufzAsQeYv76xCeifQsuxmiq1rIfdH9OCy2gnoTHaky7s6ZYIspZzWje3IoAvQ1S4W6TKK625cc8HdLN/SzJga5aX+8zjq7oFavm3Z4wRZb9pTTST3ni9zV0N9bm06JaKN0PlZJlVxjiQWdz8HLD64H4sPNo6MdQSpJukZ4fGzJ+APSs1AqTLfyb0njGL24E0s29JEU7ufUw5IzXax2R2dsg+7d3Ql1CRwUt8iFoyIz1VwWM1MHxBfrj0ZjhpVzZGjqnnhm6hXrx5Bzo0p8R47mD97al8+ClUAfzswGmSMjWCMxKI818F185RMvGydCHkqaHb7DZ/lHgUuYocFZpMgx2FFmBTiGk6yc1jNqOTo1FVoXV7mD60kt28tm3e62biznW83Kn7RBVnKOdHKT9TV+3wEgjJCmNUEud0XwKsiyEFfeFbLjC8BzbSaLJr9hJEuEouf1xz6fo6uSNJTRzB+LhKLXIeVsbVR31pTZqKk0zBrPHfT4yX3zIJn8Af9+xWxU3fo9g4Q5M4gtgjHHnEDSUPct2gUn63ZweWzBuiSrs5id4MSQgisBnKmQ4dXcuhw45LUeli7o02z7+7Ell2puYKYBJqocHig99BpY/loVQN/eUcpCR4mmOriRtk616pnkYvrDx3Ejc9/z5Ej4wm61kVBb9CivU4fXX1Q5FzZdapsehumYit6F+/2aZrlV85WpBLXPbOUJreP/Cz9d1SPQhd6NZlznRYC7grMjs14G5RMBIfVjNcR9W3LtlvoVZzF9tDnyvwsLjt4MKCUSg8T5PyQdlzt9qGuciglPPH5eo6z5YC3mc+DA7hpwWCWPPtdxMavdfX/YXZsINDaN7KdX1oNg04tbvQ1yPtaBDkMIUQfFE/k8NzSKuBZKWVGf7yXMKlqEh9s/ICpVVN3e1/JfJB/DjClycO5LyLdNMgAffL77O0mdDnU2nBbN0ssaoqyuO3oodwQMvlMl+jOnsbcoRXMHZrYa7cz2J0kve7A1hRJ6+4g12Ghye1PWD1Rjf93xngW3f9J3PIp/Uo0CYm20DvHkYQgA5w2qRenHlCrez9rroOO3ljGLFPvQ2/A6qmfi2fbwXGluyvyHBSEzkGz24+eStIkoLrAiZ6wJNdhpX3DSZgdG/A3DwUUv+f1lbO5b+mnvBccymMWM89eOIlJ/4pva5YqWlwQkuC4VOFnf/NQ2jecQKC9BwBXPfUt0xd/wiMvvsXXKwo4PUSq3T6F5gbdVRFSPaamgM/XNuLFipEjvscnCOpcnnSZve4QQRZC3ARcRfyQ6jYhxC1Syl92WcsySBm/nfJbXl3zKrN7zU6+chKoSXE6vKz3BhI65GSQENrp4vR4ye2PKFIRi53tqRsKdTZPoTwvozvuLqSbrG3J/EGc8fBn/PqIod32G/86ZyJ3vvYjV86uS2n9SX2Lee2SqRz5SmhB6DVjNglNEl84gqxeZkSQwXiwp7kOuuWQja+T4YyOjH+GaouzIs9ks1uRMMSiNMcRIvx6EWQr0leI3xedAXVYzEhh5ja/UtTLZBIaSYla8+5SRYv1Isgg8Ddrq8euaLazzDwAqFf0zhYTXh2v/EfOGIfTambQjf+K7k1KpPqcSxNBPYlFmgSpUn4ahRCnA9cCnwBHAP1C/w4HPgKuFUKc1h2NzCAx8ux5LBywkFxbxytyxeLnmKQXi73fRe270ESQ0yBJb3+FOkLmsqUe5+isBjkg9W3DMth97G6SXldjcr9ivrvxEI4eXd1tvzGwIpe/nTyGvqXxxSmMoJ41kSjyCtA6UkQJcnRZZ+QwWoKm0yOENMjDqvM4bVKt5iuL2ZTyu6+uPCfy/LZ6AwR1BrCluXbDRFw9T2kj56F+BYozyLQe0yLL1IOHwjBB1jlfswaVRWQ8TW4f7lBlQ6fVrJGzqOGwmBFCMLyHWr4YA2lJa5u3jtw5F6CQ42lSSrUL+U9CiJeA94ALgQe7sH0Z7GGk23Tf3oCpC9xAfq4w70UXi5/bVXvviun8+/P1cR10InSWIPuDiQtPZNB5CI1uPz2G53r2bHsbatIphGBaKInPriJotpB2WEuQO96PJc/nUc7PcxdO1v3WbjHhN/CiDiPPacVhNUeIpz8QJBiKIP/ikAHcHvIjzrZblHepiG9TsUH1QT2i/Y+5/2Bz62Z65fWKLBtTW0DvkizWNbTRv0xJ5ov1iAboVZxFvquKf3++gaZ2H+2hY3NYTTisJna1x7chTNQ1s9ISAqpu4bDhPQgui9kwjV7kHSHIA4GrY8gxAFJKvxDiceDWLmtZBnsFmgjyz5Ugp9MTuo9h77pY/LzQo9DFZbMG7JHf6gqHnAz0kQlKpAazJoIcfUfrSSxMGk1wJ86pThdQkmMnos428EGO/KbVTGsCglxXnsMjZ4wDojaNvoCMJCKqI8OJXGrUpZ/V0IvxOCwODTkGZSDx6uKpNLX7IiXC9SLIaplGk9sX0Rw7DCLIFs1MokpChETtNjS6ppj6GIKcLvIK6NhsshelUIgRckLrZLCfIF2mOfY4VG+Xq8ZdtRcbsu8h3XyQM9CisxrkdIls7o9INw1yusJikNOgjhaHyaReMZKOQG9A2L9MTX+SEOQkzjJ9S7MpzVFS18IEub7ZzWvfKxXvNLkckb/jn10jedWIHvmh/SRsRuT3w+QYtIl76jaEPbF3tUclFkoEWWd91bvfrEpZi02At5qscbH6dOo1OnIXfQacI4S4X0q5Vf2FEKIUOBtFgpHBPoyuqMa3r0NYojm3iwYu2ost2fegllhkIsjph84+31OqpzCpahITKyZ2cYsyyESQU4M5RoMchpqg9SlRiqUUZdu5/+QxEW/fjkJPYtGrOItvFEc0TMLEw6ePM9w+GUEuVhHSsMTCF5BsaVJi1HpSNdGBZ3d87yIeOX0c/cpS13iH4TKKIIcIclO7H48qgqwX4dZEkM0mCAXTfdIKREUICkGO7SfSp9/oCEG+CXgD+EEI8Xfg+9DywcBpKBHkDJvYx9EV1fj2eVQMgw0v7+1W7JNQJ4jsaR9ke/McPHlP4dl+0B793X0KnXy8rSYrfz74z13blgyAmAhyxvnFEGrS5TVFgxhqMqouq3zwoLIu/f2KPCeECHKB086B/UsM1zWqiHfo8Er8gSAXz+gXWaan91Yvithl6vggA5w2qZYHP1gTt3xqgvYlgksvIixEpGhMk9tHuy8cQTbrapa1ydqWCEGOlU9YTBaCMd1E+tDjjlXSe1cIcSTwR+CymK/XAadIKd/rysZlsOdR6FAyTp0WfW3TzwKZac6uwR5+01lbp9JQ3x/pz0u+8s8UmRmi9IOaNGQiyMZQD77d5mhktCjLxvQBJZTnOTtdGjsWQ4qGMKZsDIOKBrEtq5qBFbkUuGwK0wFMSa6TmrRbTAJ/SFx82cz+1BZnadbV8zHXt8vUf3avP3QwV86u467Xf2RSn8RlrlOBnguG2RQtO97Q4o0UBnFYzTG2cArUpF8tjQliAXyRz1aTlY+zpgNfRJalkwa5Q0IdKeXzQogXgdFAL5Qu8CfgSykzWRz7A6xmK5+c8MnP1uItg65DdxewiIWUIP35e/Q39zVkCHL6IaNBTg1GsgUhBA+eZix36AzMJjMPzg4ZcilucnyyqkHzfSKoEwNznVZ2tCrpWXqzanpVEDUSi9CfAbex7Z7DaubqOQMTtml3IIRgYIViI/v1+p2R4iwOi0mT1FeV72TjznZqiqKluS2qcxXACrSrvrPQbIlG/dMNKRFkIUQWStT4Eynlqyh65M+6s2EZ7D24rK7kK2WQQRIkMujvDmTIXwb7IjIa5NSgJsh740nvqSJ9sZX0YqHW5WbbLRGCrKc600tmVittwpX2gu4q2tacy/GjRnSk2V0Cs0lQkeekV3EWq7e3Agqxt5hNDKrM5bn/bQLgrmNH8NK3m1k0vmdkW3UEWcR4RFlNVoSQmgu6z0WQpZStQohrUHyOM8hgv8bP1r2ji9EZg/4MuheZHIP0QyaCnBqEEATcZZgdW8k39Uu+QRejIi8qO3RZE7/b1F2I2oZOjwwLIbCZTXgD0Ul4kxD8+cTRPPbJWi46KHqsgfZa7GLPR1zDEe3yXEeEIIcLtJw2qZbGVi+HDClnVM8CxvUq1GyrjiCbhEmT/mg16xHk9EFHerCfgPLuakgGGWSwf0GvylN3IsP9kiMTZU8/ZCLIqaN9/RlY876kT9WCvdqOAlfiHB1h4MNslLhsMQvUtskmIZg9pJzZQ+Ipl14RkO5GWJesTsgLF2ixW8xcPddY3qGuAihiBoAWYYljxOkUQe7IcPU+4CwhRFF3NSaDDDLYf7DnJRYZZLDvQZOkl8n9SAjpz8XbMI2A35F85W6EOYnbSFFWtMKdWhpi5HwZW0o6kYf8nuDH7/5iuibhMayDdqoIstOWGn00ayQWWljNVkwG7hzpgI70YM3ADmC5EOJhYAXQFruSlPKRLmpbBhlksA9jT0ssMhHkDPZFZCQWHUfYRWFP49LRl3LnF3eyeNTihOv1LIzqldV6ZD2HCIgnyIks5APB7n/R9SxyMX9YBY99oth26EWQHSlWKLSokhBjI+hWkzXOvi6dIsgd6cEeUv19icE6EsgQ5AwyyGCPR5AzMeTkyGiQ0w8ZiUXHES5Usadx2pDTOHHQiQqxS4C68pzI39oIsoHEIoYR2w18lGHPSSzMOp726rLSRl7PsVAfsxBC85o2C3NcAZR9lSBP77ZWZJBBBvsdMhrk9ENGg5x+UOtVMxHk1NC+lyLIQFJyDDBzUBlHjKxiVE0BH6zYHlluNiDIgZiXl16xjjC6yus5GUw61fycKs9jdfJhIqjJf+zRm4VZJ4KcPuhIoZB3urMhGWSQwf6Bcw7szQ+bmzVVrfYEMtQvg30R6qhxJoKcGvaWxCJVWMwm7jpWsWP7bPWOyHKj8U8wRjbh0im+8cCpY/jXZ+s5d1qfrmtoAqiJbZjYayQWKUaQ1ZHo2AiyyWTSKaGdPhQ5ZYIshHgT+LWU8g2D76cDS6SUmTqvGWTwM0Z3GtYnQkY+kByZc5R+UE8pZyLIqcHtT2+CrEYiDW4Y/hiC7NQp33xQXRkH1XVt+exE0EgsdDTIuY7UItkWHalG5DeEGYRWLpNOEouOPI3TgERXpxQ4cLdak0EGaYB0ekAzSB0Z6pccGYlF+kFNilOZvv8547DhlQAcNcq4qly6wWpSa8z1+5b4CPLen0lQE+RwDqGauOe5UrtXzZoBgvY7kzBhEdr9mNKo/+1KkWA+4OnC/WWQQQYZpIxMcDQ5MgQ5/aAmyHazfS+2JP1x29HDWDS+J6Nr0rc8cSysFrXEQH8dT0AbRU03gmzSkVikqoVWR5Atpli3DhNj8k7gJ/fbu9HS7kNCgiyEGAao6xpOEULobVMInA9834VtyyCDDDJIGUVZNna1+7Ca0ycCkXbI8OO0gzpJz2a2JVgzA4fVzPje+1YpBjUpNJJYeP1agqwnsdjTMIl4gqx2sUiVIKt9kGP9nc3CTJ61mLa1Z+KquR9Ir0q2ySLIRwDXh/6WwDmhf3poBi7qonZlkEEGGXQIfz5pNNc/+x1Xzqnb201JW2QiyOkHE5kI8v4MtQ9yogIgmm3Me1+LrknSC/2dqyLFnYkgxxZYMQmTRoIBEDDt3SIwaiQjyA8Bb6OkFb4J3AK8FrOOBFqA76WU7i5uXwYZZJBBSuhflsM/z56wt5uRQQYdQlBGo4eZSnr7H7RJaqltkw5RVJOOxKJ/WdTfOdUkPXVicGyhFJMwhc6PWoay9wcHYSQkyFLKtcBaACHEacC7UsrVe6JhGWSQQQYZdC0yEeT0gy/o29tNyKAbEWdzto9AL4JcnB2d4UjVas+jko/oJenFl+1On3OUMlWXUj6sR46FEMVCiH5d26wMMth7yLhYZLC/ImPzln7IEOT9G6nIKm4+fMgeaEnHoOdiAXDm5F4UZ9uZXlea0n7UBDm2bzULcyhnRBWt7pC5Wvci5ZYIIU4SQvw1ZtmtwFZgmRDiAyFEjv7W3QMhxMlCiK+EEO1CiK1CiPuFECUd2P4hIYQ0+Hd0d7Y9g/RFli1rbzchgwwy+JkgQ5D3bxhZu6lx4oQa3vnFNAAKUrRP627ElYgO4br5g/j0mhkUZqWWUOpReVbHJikqEWRt8RBDq4+9gI7YvJ0LLA9/EEKMAa4E3gWWAWcAlwI3dmUDjSCEuAS4E3gHuBioDv3+RCHEOCllawd2d5LOsk93v5UZ7Is4pPYQPtz4IZOrJu/tpmSQQZciI7FIP/gCGYK8PyNWd2uEmqIs3rp8GsXZ6eFkoi5wEkvyUz0mAI8vaPidngZ5X/VB7gs8ofp8DLADmCWl9AohJLCQPUCQhRDFwM3AZ8AMKWUgtPwz4DkUwnxLqvuTUj7aHe3MYN+E1WTllikp3z4ZZLDPIEOQ0w9+6d/bTcigG5GqcwVAr+L0mb1UR3s7cgyxUEssSl2lrGlao/qNsAY5PXXaHRF75AG7VJ9nAK9LKb2hz58DPbuqYUlwOOAC7gmTYwAp5fPAKuDEjuxMKMgV6ZQ+mUEGGWTQ1cjw47RDJoK8f2M3uOVehV6hkM5AbXNXlV2l/Q1h1iQDAoh9UYMMbAH6AYR0viOA91TfZwN7qkD62ND/H+l89zFQJ4TI7sD+doX+tQshXhNCjN/dBmaQQQYZZJBBMmQ0yPs34l0a9g2YdVwsOoPzp/WJ/F2doy0RHtEgq7CvRpDfBC4QQlyO4o8sgRdV3w8ANnZd0xKiMvS/3u9tRInXV+p8F4stwF3AeShFUW4BxgDvCSEO7oJ2ZpBBBhmkDTISi/RDhiDv39hXC3uqdccOa+dJflG2nTFlYwCYUztH42RhEiZsFhOSrolWdzU6okH+Jf+/vTuPk6so9z/++WYhCWENARFQQHYFAdlRMVwBURHxAirKjgIKCgp4QUEQ8eKG7ItBZTHgD2QX9CK7bMq+Q1hDgLAEwhYggZDn90edTs50Ts9Mz/Te3/fr1a+eqVPnnOqaIjxT85wq2Bj4dfb9URExCSDbfnpb4MJqbi5pEWD/Kk45ISKmkdIrAGYW1CltVjJ/wbEeIuLgsqJLJJ0L3AOcSjZjXk7SnsCe/WqxmVmL8DJvrccBcmer5oG2VpJ/SK+/u+ZVMn7z8bz+7uuMHTW2xy/pQzSEkcN7bo7TSsus9jtAjohnJX0M+CjwekRMzh2enxQw3lvl/Rdh7lbW/TGB9GDg29n3I4B3yuqU9il8mwGIiMcknQ/sKmnliHi0oM54YHz2YKKZWVvwDHLrmTXbD+l1ssGkJzRTfia3v7vmVTJ86HDGjhpbeGzU8KEQbbiTXrnsgbj7C8rfAC6t9ubZDPRARs+U7H1p4PGyY0uT0j+mMHCTsvexwDwBsplZO3KA3HoWHrFws5tgddSfdZBbUT5AXnBkVaFiv5RmisvTN1qpt/r9qSX1tUJFkGZzX4n6/x3vdtKM9UbMGyBvAEyMiOmDuH4pteLFQVzDzKy1OD5uOT9a70e8+/677LhaVYsvWZto1xSLd3JbSQ8bWvtZ3SHZTPGo4UPpscxbC61iUc2vBZPo3z+vb0u6Bjg8IqpNueivS4ETgH0lnZtbB/lLwArAYfnK2brJY4HnI+L1rGw08H5EzCiruzZpjeeHI+KJOrXfzKzhPjD6A81ugpUZO2osx216XLObYXXSrjPIb82sb+pPabWK8hzkVppDriZAPhL4IrA2cCVzd9VbFdgCuIu0q92qWb3PStokIu6uXXOTiJgq6TDgt8DVkv5CSq04gLSrX/m/NvuScp13I63AAWmW+B+SLgEeA94C1gR2Jy1X54fwzKwj/Pnzf+a8iedx4LoHNrspZl2lTVd5Y3q9A+QsEB4xvHU3CqkmQH4I2AdYMyIezB+QtAZwHfDriDhI0seBm0krX3ylVo3Ni4hjJL0C/IA0m/wGcD5wcD/TK14ArgY2Bb4JjAKeB84Djo6IR+rRbjOzRltribVYa4m1mt0Ms67Trusg1ztO7Zlikbtvm84g/xg4uTw4BoiI+yWdAhwKXBAR90k6Hdi5Ru0sFBFnMndGuLd6RwBHlJW9AOxUh2aZmZmZtW2KxY4bLsv1E6ey/TrL9F15AEoB8sjyHOQW6q9qAuRVgKm9HH8pq1PyMLDgQBplZmZm1u4WqMMKEI2w0MjhnL/XRnW7fmmmePjQ8lUs2jNAfhHYBji5/IBSyP8Veq76sDhpzWIzMzOzrvPpFcey3TrLsN5yiza7KS1lSH6949zyD+0aIP8R+JmkK4Djmbs+8CrAfsA4eqYxfJG0I52ZmZlZ1xkyRPx2+zWb3YyW0zOVov1TLH4BLAXsBWxZdkzAeOAoAEkjgbNJK1uYmZmZmQFlM8g5bbkOckTMBr4j6URgK2B5UmD8FPC3iHgoV3cG8Psat9XMzMzM2lzPVIr2n0EGIAuEH+qzopmZmZlZmfwM8vFfX5sf35a+Ht5Cy+K1TkvMzMzMrOPlZ5BXXXKhOV8vOv+IZjSnUFUzyJI2Iu1KtxKwGPPuCRgRsUKN2mZmZmZmHSY/g6x2T7GQtDNwBvAeaQWLyfVqlJmZmZl1pnwgnP+60sN7zVDNDPJPgInAZhExpU7tMTMzM7MOVnEGuYXWQa4mVF8WONXBsZmZmZkN1JAK4WcrpVhUEyA/C7RO9rSZmZmZtZ0egXCPL9szQD4N+KakofVqjJmZmZl1tkppFe2ag3wnsC1wm6STSRuEvF9eKSL+VaO2mZmZmVmHaYcc5GoC5GtyX/8BiLLjyso8w2xmZmZmhXoEyBVWtGi2agLk3erWCjMzMzPrOm0/gxwRZ9WzIWZmZmbW+SqlWLRSDnLNWiJpfUmn1ep6ZmZmZtZ5egTC+VUsWijFYlABsqSxkn4g6X7gVuDbtWmWmZmZmXWiTntIDwCl8H5LYA9gK2A+0ooWvwMurGnrzMzMzKyj9AiK2/0hPUkrkB7U2wVYCngTGA7sGxGn1Kd5ZmZmZtZJKuUaV9phrxl6DZAljQS2B3YHNgFmAVcAZwKPAg8BL9S3iWZmZmbWiUTxrnrN1tcM8vPAQsA9wP7AuRHxCsyZUTYzMzMz67fhQ4bP+bpVV7HoK0BeGHiclF98UUS8U/8mmZmZmVmnGjZkbvjZIwe5haaQ+wrV9wVeB/4MvCDpD5I+Xf9mmZmZmVknygfIea00g9xrSyLilIhYD1gbOAvYBrhe0hPAgcy73bSZmZmZWUWVUixaSb9C9Yi4NyK+T1q94hvAE6Q1jwX8RNJ+kj5cv2aamZmZWSfoESCrNXOQq2pJRLwbEedFxBbAR4AjgTHAscBTkm6rQxvNzMzMrEP0yEFu0Yf0BtySiJgcEUdExPLA54C/AmvUrGVmZmZm1nEqzSC3UrpF1TvpFYmIq4CrJC1ai+uZmZmZWWeq9JBeK+2kV3EGWdLQai8WEa9m59Yk8DYzMzOzzjJ86PDC8laaQe4txeJRSTtXEyhLGiZpd9Iue2ZmZmZmPQxTe+cgXwD8HnhO0u8kbS5pkfJKksZI+oKkk0g7750EnFef5pqZmZlZO6u0UUgrqZgKERH/I+k04GDgW8B+AJJeBaaRlngbA5SC5unABODXEfF0PRttZmZmZu2p7beajoingL0kHQh8EdgE+CiwOGmTkPuAB4Drgf+LiLfq2lozMzMza2v5HOR8gNxKOcj9epguIt4E/l/2MjMzMzMbkEopFq00g9w6LTEzMzOzjpdPsWhVDpDNzMzMrGE8g2xmZmZmllPpIb1WykF2gGxmZmZmDdNjBrlFV7FonZaYmZmZWcertNV0C00gt2+ALGkvSedIekTS+5JigNfZQNLVkt6U9Iak/5O0Vq3ba2ZmZmYwYuiIOV/3yEFuobC015ZkAei2kkY3qkFVOATYGngJmDKQC0jaELgBWB74KXA4sBJwo6Q1atROMzMzs663z1r7sPpiq7PFslvMKeuRg9xCu+r1tQ7yWsAOwAxJ1wAXA3+LiKl1b1nfxgGTI2K2pMuBZQZwjROAd4FNIuI5AEnnAw8DxwBb9HKumZmZmfXT3mvuzd5r7l3xeNs8pBcRHwNWBo4AFgNOB6ZI+pek/SUtX/8mVmzbpIiYPdDzJa0IrAf8tRQcZ9d9DvgrsJmkJQffUjMzMzMrkp81bqUZ5D6TPSLi8Yj4dURsDCwNfB94G/gV8LikeyT9VNKaxakXiQAAGSVJREFUdW5rra2Xvd9acOzfpFTxdRrXHDMzM7Pu0hGrWETECxFxakRsCSwO7Aw8BhwE3CXpSUnHSFq1Dm2ttaWy9+cKjpXKli46UdKeku6oS6vMzMzMukSPGeQWSrHoKwe5ooh4AzgHOEfSCOBzwDbATsDrwJF9XUPSIsD+Vdz2hIiYNoDmFpk/e59ZcGxGWZ0eImI8MH6gK2eYmZmZWfs+pNcvETETuAy4TNIQUr5yfyxCWjmivyYAtQqQ387eRxQcG1lWx8zMzMxqrFV30qtJgJyXPTjXr1UuImISzVsWurQ0XFEaRamsKP3CzMzMzGohFwW2bQ5yh7k9e9+o4NiGQAB3Nq45ZmZmZt2rlWaQuyJAljRW0qqSFi6VRcTjwB3A9pKWytVdCtgeuDYiXmh8a83MzMy6Q0fnIDeDpC8BpaXlVszKDs2+fy0iTspV35eU67wbcGaufD/gOtLOeSdmZd8j/eJwQH1abmZmZmbQusu8tW2ADGwL7FJW9vPs/WngJPoQEbdIGgcclb0CuAXYPiLurV1TzczMzKxcxy3z1mwRsSuwaz/rHkHaDbDo2K3AZ2vULDMzMzPrp7afQZa0cx9VAngHmAzcFRGzBtMwMzMzM+tsrZR3nFfNDPKZpCC4pPSJyssCeEXSTyLi9ME1z8zMzMyssaoJkDcHfgmMAU4DJmblqwJ7AS8DRwMrAPsAp0maFhEX1q65ZmZmZtaJ2jUH+ZOkXefWiIj8DnOXSToFuBVYPSKOkvR74F7gh4ADZDMzMzNrG9VkQ+8BnFUWHAMQEdNJKRjfyn1/NrBGDdpoZmZmZh2ulfKRqwmQlwCG9nJ8GPCB3PdTaONVMszMzMyscVopxaKaAPlRYA9JC5UfyHao24O5eckAywMvDa55ZmZmZtYNWmkGuZoZ3iOB84GJks4gBcwAq5DWI14C+BqApCHA14Gba9ZSMzMzM7MG6HeAHBEXSvoG8Dvg4LLDzwM7RsQF2fdDgc8DU2vSSjMzMzOzBqkqRzgizpN0AbAOKYVCwFPAHRHxfq7ee/RMtzAzMzMzawv9CpAljQYOAP4TEVcCt2UvMzMzM7NBa7uH9CLiLeDHwIfq2xwzMzMzs+aqZhWLJ4Al69UQMzMzM+terbSKRTUB8inAtyUtVq/GmJmZmZk1WzUP6b0JTCMt83YW8BhQtKve2TVqm5mZmZl1iVbKQa4mQD4z9/UPKtQJ0hbTZmZmZmb91q4B8qZ1a4WZmZmZdbVWykGuZqOQG+rZEDMzMzOzVlDNQ3pzSBohaWlJ89W6QWZmZmZmzVRVgCzpE5KuJT2wNxn4VFa+hKRrJG1WhzaamZmZmTVMvwNkSWsBNwIrUPYgXkS8BIwCdqlp68zMzMysK7RSDnI1M8hHAlOAjwEHwzyPGl4DrF+jdpmZmZmZNUU1AfKngdMjYjppObdyk4GlatIqMzMzM+sqrbTMWzUB8kjg9V6OLzTItpiZmZlZl2rXAPkJYJ1ejv8X8NDgmmNmZmZm3ahdc5DPBXYqW6kiACQdAGwJ/LmGbTMzMzOzLtFKM8jV7KT3W2Bz4ErgEVJwfKykxYElgauAU2reQjMzMzOzBur3DHJEvEsKkA8E3gFmACsDLwM/AraKiNn1aKSZmZmZWaNUM4NMRMwCjs1eZmZmZmYdZ0BbTZuZmZmZ1VK7PqRnZmZmZtbxHCCbmZmZWdO10ioWDpDNzMzMzHIcIJuZmZlZ0zkH2czMzMwsxykWZmZmZmYtygGymZmZmVmOA2QzMzMzazrnIJuZmZmZtSgHyGZmZmbWdH5Iz8zMzMysRbVtgCxpL0nnSHpE0vuSYgDXOFNSVHhtV492m5mZmdm8WmkGeVizGzAIhwCLAXcDo4FlBnGtnQrKbhvE9czMzMysTbVzgDwOmBwRsyVdziAC5IiYULNWmZmZmVnVvIpFDUTEpIiYXYtrKVlIUtv2h5mZmVk7a6UUCweEyevZ6x1JV0naoNkNMjMzM+sqrRMft3WKRS28ABwL3Am8BawJ7A/cKOkLEXF10UmS9gT2bFgrzczMzKxhmhogS1qEFJD21wkRMa1W94+Ig8uKLpF0LnAPcCqwUoXzxgPjB7JyhpmZmZnNa7UxqzW7CXMoonkxnqTlgKeqOGWliHi84DqXA1+MiJpMzks6A9gVWCUiHu2lXgA0sw/NzMzM2tm0GdOY+vZUVhmzSkPvW3oosCh+bOoMckRMoqUyTuaYlL2PBSoGyGZmZmY2OGNGjmHMyDHNbkYPfkivWCm14sWmtsLMzMzMGq4rAmRJYyWtKmnhXNloSSML6q4NbA88HBFPNLKdZmZmZtZ8bbuKhaQvkVadAFgxKzs0+/61iDgpV31f4HBgN+DMrGwl4B+SLgEeY+4qFrsD7+NVKszMzMy6UtsGyMC2wC5lZT/P3p8GTqJ3LwBXA5sC3wRGAc8D5wFHR8QjtWuqmZmZmbWLpq5i0e68ioWZmZlZe+ptFYuuyEE2MzMzM+svB8hmZmZmZjkOkM3MzMzMchwgm5mZmZnltPMqFi2jlORtZmZmZu3PM8hmZmZmZjle5q0NSbojItZtdjs6lfu3/tzH9ec+rj/3cf25j+vPfVzMM8hmZmZmZjkOkM3MzMzMchwgt6fxzW5Ah3P/1p/7uP7cx/XnPq4/93H9uY8LOAfZzMzMzCzHM8hmZmZmZjkOkM3MzMzMchwgm5mZmZnlOEBuEEkrSzpS0r8lTZX0pqR7JP1E0uh+XuOrks6QdK+k9ySFpOV6qb+wpBMlPSdphqQHJX1HHbr1X6P7WNK47HjR6/JafrZWMdg+lrSopP0k/VPSM5LekTRR0nhJH6pwTteM40b3r8fwgPp4uKTTJN0p6WVJMyU9Jek8SWtXOKdrxjA0vo89jgf2/7uCa56f9dkDFY531zj2Q3qNIemXwD7AZcC/gfeATYGvAvcBG0bEO31c43pgA+BeYBFgFWD5iJhUUHc+4CZgbeBE4GHg88BXgJ9FxBE1+FgtpQl9PA64jvQE8I1lh5+NiOsH/GFa1GD7WNKWwOXANcC1wMvA6sBewLvAxhHxUK5+V43jJvTvODyGq+3j0cANwC3Ak8CbwIeB3YAlgS0j4tpc/a4aw9CUPh6Hx3HV/78ru95WwKXATODJiFi97HjXjWMiwq8GvIB1gYULyo8CAti3H9f4MDAs+/qk7LzlKtT9bnb8e2XlF5L+R7lss/ukA/p4XHZ812Z/9nbpY2A5YIWC8s2y8y8oK++qcdyE/vUYrrKPe7nuB0lByt/LyrtqDDepjz2OB9HHwALAZOAEYBLwQEGdrhvHTrFokIi4IyJeLzh0Xva+esGx8mtMjohZ/bzlN4C3gdPLyo8DhgNf6+d12kYT+ngOSaMljaz2vHYz2D6OiEkR8URB+dXAtILzu2ocN6F/5/AY7v+/ExW8BMwAFi0r76oxDE3p4zk8jgfUx78AhgGH9lKn68axA+TmWyZ7f7FWF5Q0BPgEcHdEzCg7fBswG1ivVvdrAzXv4zLHA9OBdyQ9muWAdmROVi8G1ceSFgYWzJ/vcdxDzfu3jMdwlX0saaiksZKWlLQecC5pJu7vuToewz3VvI/LeBxX38frA/sC+0fEGxXqdOU4HtbsBnQzSUOBnwKzSP/h18qiwCjgufIDETFT0ivA0jW8X8uqYx9D+lPfZaR/rKcASwF7kH6jXouUL9fxatTHh5JmIc7KlXkcU9f+BY9hYMB9vBpwf+7714Gjs1eJx3Cmjn0MHsdA9X0saRhpRvifEXF+L1W7chw7QG6u44ANgR9HxMQaXnf+7H1mheMzcnU6Xb36mIi4GfhyvkzS6aR/pHeV9MeIuKmW92xRg+pjSdsBBwBXAmfkDnkcJ/XqX4/huQbSx08BmwPzASsCOwILAyNIAQp4DOfVq489jueqto8PAlYiPWjXm+4cx81Ogu7WF/BzUsL77wd4fsUHyIDFsmPnVTj3JeCWZvdBO/dxH+d9Jjvvf5vdB23Qx18g/aN7O7BQ2bGuH8f17N8+zvMYrv46CwCPAlfmyrp+DNe7j/uo73Fcuf6KwDvAT8rKJ1H2kF63jmPnIDeBpCNIf/I8A9i7Drd4lTTw5/mTh6QRpME+z59KOkkD+rg3k7L3sQ2+b0MNto+zJckuAh4Etoh589+6ehw3oH97Myl79xjup4iYTurvLSStkBV39RiGhvRxbyZl7x7H8zqG9ODuxZJWLL1ImQXzZd9/MKvblePYKRYNJulw4HDgbOBbkf36VUsRMVvSXcDakkZERP7PIuuTHs68o9b3bRWN6OM+rJS91+uhwKYbbB9L+hxwMfAIsFlEvFpep5vHcSP6tw8ewwMzKnsfAzzRzWMYGtPHfdT1OK5sWVKu9oMVjj8GXAFs1bXjuNlT2N30IiXPB2kgD+ml3geBVYH5e6nT1xq9+1B5zcL3SJtfNL1P2ryPFysoG0FaTD2A9ZvdH63Yx8AWpNmIe4v6sKxu143jBvevx3CVfQwsXnQOaQOLKaRNLfL1u24MN6GPPY6r7+PNgO0KXi+R1kTeDvhkrn7XjWPvpNcgkvYhBVyTgcNIy6LkvRgRV2V1zwR2ATaN3A5AkjYBNsm+3Yq049sxwGsAEXFUru58pF2I1iQt/v0wKR/xK8BREXFYTT9gC2hCH99O+sf6TuY+Ob0jadbixIj4fk0/YAsYbB9LWpe005WAg0k7vfUQERNy9+uqcdyE/vUYrr6P9wf2J83QP0XaJGHlrN6ipFm8P+Xu11VjGJrSxx7HA/j/XYXrTgKmR/FOel01jpseoXfLCziT9NtXpdf1BXXHlV3jiN6uUXDPRUj/AU0hPajzEGm9QzW7Pzqhj4H/AW4FppJ+g36NtN3pDs3ui1btY2DXPs7v6nHc6P71GB5QH68DnAM8Tlpz913gGdIGDRtXuGfXjOFm9LHH8cD+f1fhupMo2EkvO9ZV49gzyGZmZmZmOV7FwszMzMwsxwGymZmZmVmOA2QzMzMzsxwHyGZmZmZmOQ6QzczMzMxyHCCbmZmZmeU4QDYzMzMzy3GAbGZWR5ImSJrV7HZUS9JNkh6v0bW+J+k1SYvW4nq56w6TFJL+UMvrNpuS+ySd3uy2mHUrB8hm1lIkbZkFPT8vOLZRdmympPkLjl8pabaksY1pbXuTtLukum7DmwXFhwPHRMSr9bxXp4i0g9cRwO6S1mhyc8y6kgNkM2s1NwGzgE0Ljo3Ljs0HbJw/IGlYVvZARLxc5zZ2it2BugbIpK1oFwROrvWFI2IWMArYu9bXbgEXA88CP252Q8y6kQNkM2spETEduB1Yv2CWeBxwFfB89nXeesACwPX1baH1l6ShwLeByyNiWj3uEREzskC5JiQtWKtrDUY2izwB+G9Jize7PWbdxgGymbWi64DhwCdLBbkZ4huAfzHvDPO43Lmlc1aTdKqkhyS9KeltSXdI2j1/YpYjG5K+UN4QSUMlPS/pjrLy9SVdKumVLOVjoqRDsqCwT5KWlnSapGckvSvpuez7sWX1jsratqKkX2X1Zkq6W9KWBdcdLek4SS9kn/dWSZuW50JLepbUvytk1y+9PlV2vWUknSfpVUlvSfqHpBX78xmBjYAPAX8vaOcESbMkLS7p7Kwf35B0kaQlsjrfkfSIpBmSHpa0Vdk1KuYgS/ps1tZXsvOflHS6pDHZ8RWzcw+VtIOkuyTNAI7NXWOt7Gc8LbvGg5IOkDSk7F6lz7KIpN9LmprVv0nSemV1h2TXuD8bk29kn/EPBWPnH6S/lny5n/1tZjUyrNkNMDMrcB3pT8vjSDPGMHeG+AbgDeB4SaMj4q3s+DggsuMlnyUFgZcBT2Xnfw34o6TFIuI3Wb2/AMcAOzNvMLcFsCTwv6UCSVsDFwATgd8Ar2b3+QXwcWCH3j6cpOWBW4ChwB+BJ4GVgO8Am0paLyLeKDttAjAzu98IYH/gUkkrRsQz2XUFXJS1+SLgGmAF4FJgUtn1vgf8ElgYODBXPjH39YKkX0ZuIv08ViClZFwi6eMRMbu3zwl8Jnu/rcJxAVeSfjaHASuTUjKWkHQFsCvwJ+BdYD/gQkkrRcTk3m4q6bvAScAzwKnAZODDwNbAUkB+Nns7UhB/avZ6PbvGBqRxOJOUHvIiKVD9LelnvEvBZ7kKmELKH14c+CFwhaSPZH8ZgZSP/VPSz+QU0phdPrv2cOD93DXvAN4jje2OehDRrOVFhF9++eVXS71IeaUzgVtyZYcA00m/2K9GCiy2yI4NA94E7im7zuiCaw8hBXzTgGG58ouBd4CFy+r/hRSgjc2+nx+YSgqehpbVPShr16dyZROAWWX1rgBeAJYqK9+AFCAdmis7KrvmJYBy5Rtl5T/PlW2dlZ1adt1SeXk7bgIer/AzuCk754dl5Ydk5Z/tx8/xnKzu/AXHJmTHji8rPyErnwQskCv/RMHnHZaV/SFXtmz287ofWKjo55+9r5idOxNYuaDef0jB6eq5MgEXZud9puCznFB2jR2y8j1yZfcB91Xx38Ik4O5m/vfol1/d+HKKhZm1nIh4hxSgrCtpdFY8Drg5ImZFxMPAS8xNqyjNLl9Xdp3S7DKSRkpaDBhDmrVclDRrW3IWMBLYPnfOQqSZvSti7oN/nwPGkmY2F5U0tvRi7uzzFpU+W/Yn/s+TAt53y85/gjSbWnT+8RERuc92Kymgz3+GL2Xvvyvrh8uAxyq1qRezSDOxeddm7yvRt8WBmRHxdi91jiv7/sbs/cyYO+tKRNwFvNWP+36VNBN7RMw7C0/MO+v9t4h4NF8g6YPA+sDFEfFA7twAjs6+/UrBvY8t+76or14HPiRpY/rnFWCJftY1sxpxgGxmraqUh/wp9cw/LsnnIY/L3q/PX0DSgpJ+J+kZUjD5Mmn298isSn5d3itIwcjOubLtSbPZZ+XKVsvez86ulX+VgqkP9PK5ViXNRO5VcP5UUhpD0flPFpRNAxbLfb88Kah9oqDuxIKyvjwbEe+Wlb2SvS9WXrlAkD5rJbOBp8vKSkvBPVVQ/7V+3LcUjN7dZ+uSRwvKPpK9P1hw7MGyOiVFn6Worw4mzUzfLOnZLH/565KGV2ifSP1oZg3kHGQza1XXkXI1x5Fyjkv5xyU3AMdKWiCrM5sUNOedB2wJnEZKGXiFlMLwJVIu7ZxJgoh4T9JfgH0kLR8RT5GC5VdIwXNJKeD7IenP+EWe6+Vzlc4/i/Sn+SJFM67vF5Tlr1f+dS1Uumd/7zUVmK8sVzwvCmZ0+7p3X/ctHe9vUFnU173do9J1e/ssylW6WdIKpL9EbAr8F/BN4EFJn4qI18rOHUPqRzNrIAfIZtaqbgVmkIKIN0gzwLfnjt9A+jdsHOkBuXsitxFFlk7xeeBPEfHd/IWLVn/InEV6SGwnSWcBnwZOjoj3cnVKqQrTI+LqAXyux0lB1vABnt+bp0gB1wrMm1KxckH9es9MlmbUVwLuqfO9Skoz5WtTPAvdH6UZ+I8VHPto9l40o98vEfEm6SHPCwCUNms5HtiNnqtojAKWZm7aiZk1iFMszKwlRcRMUpC8DrAVcGvZn/sfIM3uHgSMZt71j0szkD1mAyUtTdogo+iedwAPATuRZo9Fz/QKSHnGrwCHqGDrZEmj1MtauhHxIvBPYPvyJcCy86WBr3v7t+z9h2XX3JriAHk6PdNMau367H3DOt6j3F9JKQxHFP0cspU+ehURz5NW3thGUimlpnTuIdm3Fw+kcSre5fGu7H1MWfk6pF8Cb8DMGsozyGbWyq4jzSBvTFoea46ICEk3Atvk6uaPvybpGmAXSTOBO0krHOxNmiFct8I9zwJ+RVr67KEsaM5fd7qknUnLqE2UdAZpVnhRUn7xf5MC+pt6+Vx7ZcdvknQ2KV92GCmHeBvS0m9H9XJ+JZeRlnbbOwuyryXNJn+LlA6yWln9fwNbSjox+/p94Oqo3U6Et5Hycr9ASnOpu4h4WtIBpNUw7s/6dzKwDKlvd2TuzHZvvk8aUzdJOoW0zNvWwObA2REx0KD1sWzc3kZaEm4pYE/Sahrnl9X9ImlFjksHeC8zGyAHyGbWyvJBb1FAcgMp6Hmf4j9D70AKdrchran7GOkhKVE5QJ5AWqlgIdKDePOIiL9ns78Hk2abx5IeLnuctE5x0cNd+fOflvSJ7PytSbPVb5PW7b2E7E/v1cp+adiGtGbz10gB1j2klTj2B5YrO+WYrOxrwD6kfvk0vQf31bRntqTxpNncsTUMvPu674mSHiP9krMfabONKaRfHnrLD89f4z+SPgn8jJR2Mz/pF6uDmHe1imr8hpT6sx9pDeoXSWtiHx0Rc3Las9nqbwAXRYRzkM0aTLlVg8zMrENJegiYHRGrN/i+i5B+MTk5Io5o5L3bmaRtSTPKa+UDZzNrDOcgm5l1kOzBrvKyL5PSK66a94z6ylZl+Bmwf1HOts0rmz0+nPSAqYNjsybwDLKZWQeR9GtgDVJ6yhukHeh2I6WArBURU5rYPDOztuAA2cysg0jaCvgf0ozxwqTNRK4GDouIAS9NZmbWTRwgm5mZmZnlOAfZzMzMzCzHAbKZmZmZWY4DZDMzMzOzHAfIZmZmZmY5DpDNzMzMzHL+P4YFYbLNmgy3AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "if len(sources) > 0:\n", " print() \n", @@ -638,7 +879,7 @@ " # Try measuring a spectrum from the background -> Use a box away from source.\n", " # NOTE: Hardcoded values in for box region - improve\n", "\n", - " bkgcube = cmin[: , 1:3, 10:13]\n", + " bkgcube = cmin[:, 13:16, 13:16]#[: , 1:3, 10:13]\n", " bkgbox_spectrum = bkgcube.median(axis = (1,2))\n", " bkg_img = bkgcube.median(axis = 0)\n", "\n", @@ -741,20 +982,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "name source_no ra dec \n", - "---- --------- ------------------ ------------------\n", - "Y551 0 14.830119062034905 -72.15837463495436\n", - "Y551 1 14.829047135765496 -72.15837513138561\n" - ] - } - ], + "outputs": [], "source": [ "# Make table of extracted sources\n", "source_extspec_tab = Table([name_val, source_val, ra_val, dec_val], \n", @@ -772,7 +1002,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -784,7 +1014,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -816,22 +1046,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAEYCAYAAABRMYxdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3hUVfrA8e+ZSe+kEAgQQu+h9y6Iim2t6Ooqq+i6u5a1rGX1tyrq6rq2XTu61rWwioptEQHpvfcOoYSSSnqZmfP74yaTDDPp0xLez/P45N5zz733DcLkzalKa40QQgghREti8nUAQgghhBDuJgmOEEIIIVocSXCEEEII0eJIgiOEEEKIFifA1wE0F0opGY0thBBC+CGttTq7TFpwhBBCCNHiSAtOA8m0eiGEEMI/KOXUcGMnLThCCCGEaHEkwRFCCCFEiyMJjhBCCCFaHElwhBBCCNHiSIIjhBBCiBZHEhwhhBBCtDiS4AghhBCixZEERzRbC756jx//fiNn8vJ9HYoQQgg/IwmOaJYWvnYnk7fey9Ti79j4/n2+DkcIIfzOM888Q58+fUhNTWXAgAGsWbPG1yF5laxkLJqlSZkf248H5vzow0iEEML/rFq1iu+//56NGzcSHBxMZmYmZWVlTXqmxWIhIKD5pA3SgiOancLiEofzGApIzy2m3GrzUURCCOFfTpw4QXx8PMHBwQDEx8eTlJTEwoULGThwIP369eOWW26htLQUgJSUFDIzMwFYv349EyZMAOCJJ57g9ttvZ8qUKdx0001YrVYeeOAB+vXrR2pqKq+++ioAGzZsYPz48QwePJgLLriAEydOeP+bPkvzScWEqFDwXE/Cq20/UqbNWF/qxxexV/HrP/3dd4EJIcRZUh7+wSPPPfzcxbVenzJlCjNnzqR79+5MnjyZadOmMXz4cKZPn87ChQvp3r07N910E2+++SZ/+tOfan3Whg0bWL58OaGhobz55pscOnSITZs2ERAQQHZ2NuXl5dx1113MnTuXhIQEZs+ezaOPPsp7773nzm+5waQFRzQrFouVRJXjUBakrHQwZfDr3Ld8FJUQQviXiIgINmzYwKxZs0hISGDatGm8/fbbdOrUie7duwNw8803s3Tp0jqfddlllxEaGgrAggULuOOOO+xdVbGxsezZs4ft27dz/vnnM2DAAJ5++mmOHTvmuW+unqQFRzQrOzavpr+vgxBCiHqqq6XFk8xmMxMmTGDChAn069ePDz/8sMa6AQEB2GxGN39JieMwgPDwcPux1tppB2+tNX369GHVqlVujL7ppAVHNCsx39/q6xCEEMLv7dmzh3379tnPN2/eTGJiIocPH2b//v0AfPzxx4wfPx4wxuBs2LABgDlz5tT43ClTpvDWW29hsVgAyM7OpkePHmRkZNgTnPLycnbs2OGR76shJMERzUpHah+4ZpGBxkIIQUFBATfffDO9e/cmNTWVnTt38txzz/H+++9zzTXX0K9fP0wmE3fccQcAjz/+OPfccw9jx47FbDbX+NwZM2aQnJxMamoq/fv359NPPyUoKIgvv/yShx56iP79+zNgwABWrlzprW+1Rkpr7esYmgWllAajKU74RmlpCcHPJtZaZ1XgCEY++pOXIhJCCOFLld1lWmt19jUZgyOajfzs0wRXHP+SfBfZ4V2JMpdz/vYH7HVGlq/2TXBCCCH8iiQ4otkoKsi1H4cEB3PVtOkA7OnWjx5fX2C/lpZ+kmDKaJOU7O0QhRBC+Am/GoOjlHpEKfWFUuqgUkorpQ7XUE8ppW5USn2ulNqvlCpSSh1RSn2rlBpewz26hv8KPPpNCbcpKThTdaKrxtr06D+C7yKusZ93nNWDNrP6kZuV4c3whBBC+BF/a8H5G5ANbARiaqkXDHwMbAY+Bw4BbYE7gFVKqZu01v9xcd8yYNZZZeVNDVp4R1lRVQuO0laHa5c+8C488YVD2cmDW4iJm+yV2IQQQvgXf0twumitDwIopbYDETXUswATtNZLqhcqpd4BdgAvKqU+1VqfPaXmYA2Jj2gGcvdWrbEQOeQ6p+vbQwbRt2Sj/Tx7+XswVBIcIYQ4F/lVF1VlclOPepazk5uK8lPAEqB1xX9OlFJBSqmaEifhxwJPbgZge0Bv+vTq7XS9IGmMw/moMz+w9AfJZ4UQ4lzkVwmOm7QHyoBcF9euBoqAfKXUaaXUq0qpaK9GJxot0mps0WAae5/L670uv58VbW5yKBu37o9knPT9kuFCCOFtzzzzDH369CE1NZUBAwawZs0aj7zn8OHDfPrpp/bzDz74gDvvvLPRz1u8eDGXXHJJk+NqUQmOUmoqMAyYrbUuOevyWuAJjCTnZmARcCewrLYWHaXU7Uqp9Z6JWNSXttnobdkJQHTrDi7rREfHMPqOV9kQc6FD+cb372Xum496PEYhhPAXq1at4vvvv2fjxo1s3bqVBQsW0KGD68/Opjo7wfEXLSbBUUp1wxh4fBy4/+zrWuvhWusXtNbfaK0/0lpfBzwK9APuqem5WutZWushnopb1M/O9b/Yj8Nial/sLy+is8P5BaXzufzUaxQVyYQ5IcS54cSJE8THxxMcbKweFh8fT1JSEikpKfzlL39h5MiRDBkyhI0bN3LBBRfQpUsX3nrL2LBYa82f//xn+vbtS79+/Zg9e3at5Q8//DDLli1jwIABvPzyywCkp6dz4YUX0q1bNx588EF7XPPnz2fkyJEMGjSIa665hoIC43N53rx59OzZkzFjxvDVV1+55c/Ab1cyrhxkrLVOqUfdThhjb8KAiVrrbfV8RyBQAGzQWo+qo66sZOxDm+a+ysBNjwFQ+shJgoNDa6ybmZ1N/L86OZVn/WEXca2TPBajEEI4ecJDoyCeOFPr5YKCAsaMGUNRURGTJ09m2rRpjB8/npSUFB566CF+//vfc++997Jw4UJWrFhBSUkJffr04fTp08yZM4e33nqLefPmkZmZydChQ1mzZg0rV650Wb5nzx5eeOEFvv/+e8Doopo5cyabNm0iODiYHj16sHz5ckJDQ7nyyiv53//+R3h4OH//+98pLS3lwQcfpFu3bixatIiuXbsybdo0ioqK7M+rTW0rGTf7FhylVArwC8aMq/Prm9wAaK3LgXQg3iPBCbexWsoAOKTb1prcAMTHxrLzygVO5aVF+R6JTQgh/E1ERAQbNmxg1qxZJCQkMG3aND744AMALrvsMgD69evH8OHDiYyMJCEhgZCQEHJzc1m+fDnXX389ZrOZxMRExo8fz7p162osd2XSpElER0cTEhJC7969SUtLY/Xq1ezcuZPRo0czYMAAPvzwQ9LS0ti9ezedOnWiW7duKKW48cYb3fJn4G/TxBtEKdURI7mJBiZrrTc18P4QjEHJsr6/n7MWGb+tnGgzAee2GWe9U4fyn/m3cmPBv+1l5cXSRSWE8LI6Wlo8yWw2M2HCBCZMmEC/fv348MMPAezdViaTyX5ceW6xWGrsqWhID0b155rNZvtzzz//fD777DOHups3b7a3xLhTs23BqUhuFgOtgCla6w211I2r4dJTGEned24PULiVrSQPABVc/+beX9/3osP5ka1OKwsIIUSLtGfPHvbt22c/37x5Mx07dqzXvePGjWP27NlYrVYyMjJYunQpw4YNq7E8MjKS/Py6W8hHjBjBihUr2L9/PwBFRUXs3buXnj17cujQIQ4cOADglAA1ll+14CilfgNU/h9IAIKUUo9VnKdprT+uqBeJ0XKTArwK9FBK9TjrcT9XrIsD8JhSakTFPUcwurOmAhOBNRXPEH5MlVYkOKFR9b7HZHL8jcCUtgxwPcVcCCFakoKCAu666y5yc3MJCAiga9euzJo1q17jWq644gpWrVpF//79UUrx/PPP06ZNmxrL4+LiCAgIoH///kyfPp1WrVq5fG5CQgIffPAB119/PaWlpQA8/fTTdO/enVmzZnHxxRcTHx/PmDFj2L59e5P/DPxqkLFSajEwvobLS7TWEyrqpWBsz1CbiVrrxRX1Lwf+APQF4gArsA/4L/CSiynlrmKTQcY+tOGFyxlcsJh1A59j6OW/r/+NLgb4/cgYLnr8e480iQohhPCe2gYZ+1ULTmUCU496h4F6/3TSWs8F5jYuKuEPQkuNjTMjWtevibXSGpXKcL3VoWwqy8k4nU5CYju3xSeEEMK/NNsxOOLcEmExVjGOiG3boPuiL3sWi3b+a24pKXRLXEIIIfyTJDiiWYi2GTMRohMato5Nz4Fj2DzqNafyMklwhBCiRZMER/i9kpJiolUhFm0iMsY9SxaVFUuCI4QQLZkkOMLvHd27BYAAZUOZzA2+P3nQ+U5lmTk55BaVNTk2IYQQ/kkSHOH3svc1bQfc1gmtOaVjHMpGLrmRVc9ObdJzhRBC+C9JcITf0zlpAKyIu7rRz8ifvtip7CLzOmxWW6OfKYQQwn9JgiP8X0kuAOb4znVUrFnXTp1YMuwtp/Ji2b5BCCFaJElwhN8LKDNWMTaFxtRRs3bjp17PyrgrHcqKCn23T4wQQgjPkQRH+L3AcmOPk8DwpiU4AJbEVIfz0oK8Jj9TCCGE/5EER/i9IEtlghPb5GeNuvIuh/OSIklwhBCiJZIER/i9EKsxTiYkouktOAEBjruTlEuCU6MdB4+TkVfs6zCEEKJRJMERfq+TzZhFFRrZ9Bacs2XPe87tz2xOiouLWfT8NH7+5EWH8sNH0ujxYV92vnChjyITQoimkQRH+LXM9DT7cUSrBLc/f7TeyO49u93+3OZAa83CD57kvKJ5nL9vpsO17C3/I0DZGG/a7KPohBCiaSTBEX4t68gO+3F0jPtbcAAKvvyDR57r75Yv+p5LTr1pP9c2W7Vjqy9CEkIIt5EER/i10oyDAKyOmOS2Z/6Y5DjQOLn8kNue3ZxEbnjD4fzE4aqWLG0prbpgtXgrJCGEcBtJcPyUzaY5fUY2hCzLOgxAaUQHtz3zotueYknPJ+zn+yKHue3ZzcHSt++l5PF4BhStdCg/vPAd+7GpLN9+bC2RgdhCiOZHEhw/9cNbDxP7UnvWr1nm61B8qqwgB4DQ6NZue6ZSikGXzLCfB4Q1fXZWc2GzWhl34j1CVLnTtfDs7fbj8uKqBKe0IIefFi7g22/neCVGIYRwB0lw/FBeUTGXnn6LAGUj/odbfR2OT5ksxjRlU1CoW58bGRHJ6t7/Zzy7/NxpKcs6meZUti5gEACxJccAsFrKGX6kqjWnpCCHC5ZdxWUbbyHzhPP9QgjhjyTB8UNL3r7ffpxiOuXDSHzPbC0BwBQU5vZnm0IijHdYzp0EJ/vYHofzjeb+tLvpXQDibZn8Mm8Oi959xKFOVuZp+/HpD270fJBCCOEGAXVXEd526ZlPHM4LCwsID4/wUTS+ZbIag13Nwe5PcMwh0QAE5R5kX3om3ZLi3f4Of1N4qmpA9aqEaxj5x3exlBqtZKGqjImrb3G6J3/Ry/bj3qVbPR+kEEK4gbTg+Jkd+/Y7lW15e4aLmueGgMoWnED3dlEBBIZFAtDXdJiSt9w3S8tf2WwaS/ZhAFa0vYkRfzC6oQKCQynVgTXeF1ya5XCutfZYjEII4S6S4PiZoh3znMpG5f3PB5H4hwCb0YIT4IEWnIDQaPtxP9Nhtz/fn6x59iK2PzMGc64xhkbFJKOUsl8vVM5/vita/QqAPhxwKC8tKbIfr53/XzatXuiJkIUQokkkwWkm8nIzfB2CTwTajBacgBD3JzjB4VEO52fyzrj9Hb5WUlLM8rnvMrx0JanW7QzONRLo4PgUh3rFyrmFLH7CHS6fufynLwA4tn8bw1beRs//XSetOkIIv+NXCY5S6hGl1BdKqYNKKa2UOlxH/R5KqW+UUjlKqUKl1DKl1Hk11DUppe5VSu1WSpUopY4qpV5USoV75JtphFVbd3Om0PXmhgW52V6Oxj8E6jLjqwcSnFbxbR3Ol3/xTzZv315D7eZp1adPM2bT/U7lkW26OpyXmqv+fDN0NJvO/y/tO/V0+czJm+8BID/NGI8TqsooLT53BmoLIZoHfxtk/DcgG9gI1Lo4iVKqC7ASsADPA2eA24CflFIXaa0XnHXLy8DdwNfAi0CvivOBSqnJWmsbPrRt6yZGfjWhxuulRfk1XmvJArXRRRXogS6q2HjHtXUuPvoiHH2Rsu4ZBAUFuf193pZ+7DATj7zm8lrrDo4JDtUaYBKePEICgNaUazOBynnbhp07t2LNrOq6KsrLIiTs3BwIL4TwT/6W4HTRWh8EUEptB2r7xHwWIwkarLXeXHHPR8AO4HWlVE9d0W6ulOoD3AV8pbW+qvIBSqlDwL+A64BPPfD91Fvh9h9qvZ6/ayH0HuKlaPxHcEWCExTivYa24vwcguISvfY+T8g9k0vSu/1dXsvREcREOv7TCqhoKXOgFMUqhECcW2d6/3esw3lpfja06dj4gIUQws38qouqMrmpS0W30mXA4srkpuL+AuBdoDswtNot1wMKeOWsR70DFAF+sLhH7WMYUrf9zUtx+JdgjB+8wSHeax0oKy3x2rs8Zfv3rzucrw0abj9upQocBhgDhGjXXaNlVLVk/WSreUuL8sKcxoQphBAe41cJTgOkAsHAKhfXVld8rZ7gDAVswNrqFbXWJcDms+r6Rj12b7aUOy+v39IFV7QsBIW6v4sK4Kc2v3MqK6s2S6i5yczNI/3UKQKy9zmU971nTq1TwY9HGq09u7Xjnl8WVdXIm3zTWzXeb5EERwjhZ5prgpNU8fW4i2uVZe3Oqp+ptS6toX68UsrloAul1O1KqfWNjrSedD0SnDM5p+us05LYrFaCK/ZMCvbAIGOAiTOecyqzlDbfBOfYq1Np9UZfonOqBktvuegbwsIjWRtvTPteGTjC6b7gUXewPaAv+tJ/OZRbqvVid0+puQvKWpzb1NCFEMKtmmuCU/nTzlXCUnJWncpjV3Vrqm+ntZ6ltfbY4JfswjK2HMlBuUhwlln7OpznZ59b2zZUzswp0YEok2f+qgYFmFg2xHEg7v5F73vkXZ5mtWkGWLcRqsroZTNacPZe9i39h08EoNtVj/NLm1tIufF1p3t7j7iAvo+toNcQx0mIWlX9uZsDAtgw1fVYseTlD7H6nXs4fvSwm74bIYRomuaa4FT+ih3s4lrIWXUqj13Vram+13z29zto9e5QzrhIXkY+4biTeEn+uTVVvDLBKXXduOY2Yy/5jcP5pIyPsVrrblHzN2fyHWfanVSt6T5ovP28TVIHJt7xMkkdu559a42KzloAcPCwMXyd5DztPJhyRhz/gKB/jyf39LGGBS6EEB7QXBOc9Iqv7Vxcqyyr3n2VjtEN5SrJaYfRfeViGonn/dE0h2RTBqPPOP9mHGA2sbR11fjn/KM7vBmaz2VnngAg2sUsHk/b9PRYfp7zrtff2xR5Z3Vhng7t3ORn5o56FIDvk+62l11x+185Ot2x19aqFYdpSwK5RL3Rl6yszCa/WwghmqK5JjjbMLqcRrq4VjnAoPon8DqM79VhGohSKgQYcFZdn4hQrmexhCR0sh932foPb4XjFzKPOu/L5S1D9A7O3+bcUuGPDu7fTcbjHWj9/iiH8pKI5CY/e9h5v2L3Lbu5aMZMh/LWSclk6CjO6DCW9v8Hu6+cT8aFswAwodn1tfPYJiGE8CZ/WwenXrTWBUqp74ArlVL9tdZbAJRSEcAMYB+OM6ZmA38B/gRU7/e5DWPsjeP23V6itUbVXct+FMs5tthfmbF1wo7AvvTxcSj+7NjXjzNO5TmV24KavnaQUoqeyW2dyoODgsmYvpIAk2Jcx/b28rXLJjCscDHhWdua/G4hhGgKv0pwlFK/ASqnaiQAQUqpxyrO07TWH1er/ggwCZivlHoZyMNIWNoBF+tqm+NorbcppV4H7lRKfQX8SNVKxkvw0SJ/aQf3kuKLFzcT1iLjh3ZxZIpvA/FzQwsWcXamnK0jaDvpDx59b+9OHZzK2l72OHy2mDbFB1zcIYQQ3uNXCQ5wKzD+rLKnKr4uAewJjtZ6v1JqNPAc8DAQhLHFw4UutmkAo/XmMHA7cDGQCbwK/NVX2zTYSp1/6z5bVO9JsONp+3lZaQlBwSG13NFy6BKjBccWFFVHzXOT1pq9J/NJIJhQqoaQHaI9MX/eSMeImsbVe07bzn0p1YG0VRkUnskmPDrW6zEIIQT42RgcrfUErbWq4b8JLurv0lpfrrWO0VqHaa3H1JDcoLW2aq1f1Fr30FoHa63baa3vq1j92CeUMtd47aApBYCefQY5lB/Z7fPhQt5TkQDqYM+vYrxg9CfM18NYa3K9vYE/+mXhj6S81ZlY5dh1eaTTNbTyQXIDEBAYRFqA0Qi7ZsEXPolBCCHA/1pwzi2q5vzSVkPyYy1r/tsI1JcqNX5wq5Boj79r8vmXYJt0MYs/eQ4ObLGXZ2TnkhBb676vPhO55iX7QojVjf71X3wQTZXTSZPofnQ/5217kP1b/4nFHEZxUByFYe0Yfee7HlvTSAghqpNPGl9SdQ8xBmMKbqWyojOeisbvBJQZLTimUO8kGCaTYux1DziUpW34ySvvbqhV/5nJ0HLH1rxlqc+S86c0AgJ9uxP60N88RYY2ktKu6jg9bfsYWLKaMdlzOLRznU9jE0KcOyTB8SFVSwtO9flV68d/YD8u3Fb7ruMtSaDFaMExh3mvBSUw0HG/ppCoOKc68//zAj8/cwW5eb6b1TZk/9n7xkL77gNpFeP71qbgoGB29fijy2uZ2xd5ORohxLlKEhxfqqUFZ1901RI/MdFVP7RGZM7xaEj+JLjcaMEJjGjl1ffOSbzHfqytjl1AuTlZTNn/FOeXL2LPoo+8Glclm9VKIM4rLZtDIn0QjWtjrnuQw7dso/iRLBb2nMnquCsAMB9fW8edQgjhHo1KcJRS3ZVSVyilflexGeUVSqlu7g6uxauhBWe7LYXhNz9rPzeZ6teV1dKEWo3x38ERzq0onnTV72eyI3gAAMcyqjaRPHn6FDH/rFoduPDEXq/GVSmnYoXns/nTbDOTSZGSnExocACTrruH1pOMFp3k/E1om08mLQohzjH1TnCUUr2UUv9USqUDu4AvgTeBtyqOdyul0pVSryilenkm3BamhoHERT2vIi666rfx8FhXO1K0fGEVE9xCIr3bggNgMxnjWL5es4djOcY2ZWmf3O1Qp3X2Rq/HBZB7Ks3hvEgH827E72jfrn0Nd/heSo9BZBJDAjlsf/0GSXKEEB5XZ4KjlOqilPoS2I6xTs0W4EngJmAqxpoyNwEzK67NALYrpb5QSjV9M5wWTNfQRaUCHKf4nr05orZaPBaTP4moSHDCouO9/m5rRYIzK+hlvn3jIfbu3kLbM5sd6nQq20t5WU2b1HvOsYM7Hc6PXPU9Mx54ngCz//Y4m8xm0sa9RIkOpF/Wj2xc8JmvQxJCtHD1+UTcCaQA04FErfVFWuuZWutPtNbztNb/qzh+Umt9EZAI3AJ0rrhX1MBUU4JjDnRZXunnL970RDh+RVvLCaMUq1ZERHp+mvjZrOaqJPMP5R/R/fNxJHPSXpam2hGuSti16kevxaS1ZvmPnzB+szHTa4e5F6vGfkTP1GF13OkfBp93FVt6/gmApJWP+yQ5FEKcO+qT4FyrtR6itf5Ya13nts5a60Kt9Yda68HAtKaH2HLVNIuq8OS+Wu+z7pjriXD8SmmBMfalgDCCA72/XJNF1TzVekn/f3Aq3tjTteCw97qpNs77kDFrq7ZfONNmBCMnXe6197vD4Ksf4rhqQ1sy2LNeZlQJITynzgRHa93on6ZNufdcoKttpFldUo7zWiEbAqtWNI4JbvmDjgvzc4yvKswn7++au6LGa+OvuB3V1ljxODhjq7dCou2apx3OVUCo197tLgGBgRyPHQ5AwSFZE0cI4Tn+22l/Dqi2H6hjuYs9xpNurdrwPNzW8ncVL87LNr76KMGJc7E7N8CKkW8DEN/DmMafUrCJspJij8djs1pJIsOhzBLs/a47d9AJPQFQmb6ZhSaEODc0OMFRSu1VSj2klGrjiYDOJTXkN2QEudiluU0SJ0gAINW2i5ysDKc6LUlpobFic4k53MeRwLrxH3CcRNYOeYnRF1wHQEqvwRxRScRxhgNbl3s8hvTDux3Oi3QwAy6/y+Pv9YSI9n0AiMyXHceFEJ7TmBaccuBZ4IhS6hul1CWqtiV5RS1cZziRo251WX5iwJ3240N+uoWAu5QVGmNwSn2U4CzsOdN+3GPEVNo9sZdhl1T9f1EmMzmhxqaShdknne53t+yTRxzO9457lchw3yd/jdGms9G91648TaaLCyE8psGJida6DzAK+BCYCMwFjiqlnlFKdXFzfC1bDU04IWGuf3BZiqs2PjcHNb/xFw1RmeCUB/hmdd7uI6baj6NCXe/MXR5srM9Tnnfao7GUWyyk/nydQ1lUykCPvtOTYtskk08o0aqQzFPHfB2OEKKFalTLi9Z6tdb6NqAtxro3h4BHgL1KqUVKqV8rpVz/VBB2thq6qGoS2Klq+4bgZc+5ORr/Yi0xxsBYAyN88v4OKd34sfOjLB76do11dGgsALbCTI/GknGiamG/NQFDWDJlHp27dPfoOz1JmUykBxitX6cOeG+QthDi3NKkriWtdZHW+n2t9RigJ/A5MAH4GEhXSr2slEpuepgtU0xYTVORXf9vGTD8PPtxT2vLHqBpKzbG4NiCfLe/0tSbHmTCxdfVXCHcWIBQFXk2wcnPOF51EtmW8aNG1ly5mTgTYawBWnh8h48jEUK0VE0eO6OUMiulrgBewlj3RgO/AKuBu4BdSqnmtViHl8SFu17QL6K165xQ1bI5Z4tTYswU08H+s4Hk2cwRxqDvURn/xVJeXkftxivIPGo/bil/BWzxRguUztjj40iEEC1VoxMcpVRPpdQ/gOPAHGAI8ALQXWs9WWt9MUarzh7geXcEey5YNvY/JLVPqfH6hlEtfxVjAFVWMU072H82kDxbcGzVbLeNC2d77D3Fx7d77Nm+EprUG4DIvP0ur5dbLOzauhar5dzYlkQI4X6NmSZ+i1JqBbADuA9j/6lrgPZa64e11va5n1rr/cC/ABl8XE9jJ11a6/VeoxgBkoIAACAASURBVI3rZdqMzWr1Rkg+ocqMRbPNof7bgtNz5MX242Gr/0hJaZlH3hN6umoPrDJTyxhc3qaHsb1Ex9K9WFxs2bDtrd/S66vzWf3On7wdmhCihWhMC867QCfgOaCL1voCrfUcrXVNv2rtxBiTI85WbRbV/F7PcOKOXXXeEhYeSaaOJkhZOZ1+yJPR+ZTZYuzgHRDivwmOOSCApR2r1qJZ9f7Dbn9HxuGdDC5eCUChDibuQve/wxcS23UiTbUnQhWzbelXLPvhYxa9938c2rOF9Kd6MSjzWwC6nvy+xgUxhRCiNo1JcK4COmitH9VaH66rstZ6rdb6t414z7kjqj1Tpt1J2zZJ9ap+pGIGyp6NSz0ZlU+ZLUYLTlCY/yY4AIOvfcR+PPHkvykrc28rztHVc+zHxfcfolfXltMYmp5iDM3rsuw+xq67k/OO/ItOn40jyZpur5Oocjh+0vPrDAkhWp7GrIPztda65faNNAMnzEYilLzpRR9H4jkh5cYsqpDIVj6OpHbh4eEsTZphP1/78WNufX7QqS0A/K/tH4iPap4L+9Vk2A1PsiuwN1GqyOnaMZ1gP07bsdqbYQkhWoh6bdOslLqvgc+1ArnANq21R7ZbVko9ATxeSxWL1jqwHnX/rLV+wb3R1Vfjmt6jW3eAY9CJY1itVsxms5vj8q3yslI6WI6AgrYVq976s7bDfgXfvAtA8tFv0PrvbpvxFpZvdEO27jvBLc/zJ+aAQIKueJ3i2RcQqqpavvZc8hU9hkxi69szSD3xBaUHVwFX+C5QIUSzVK8EB2N2VGNopdRG4DKt9YlGPqMmXwGupmCkAn8GvnNx7V7g7EVLNrg5roZr4A/DrlN+B++9A0Da7g107jPME1H5zMkj++igyjlJPG1i430dTp3adx9EgQ4lQhWTzCmWvnob4+5+t8nP3b97C10txl/xjt1Sm/w8f9Sl9yAOXvcTJw5ux5p7DIvVxsTBxnpPgV3GwokvSDzt+b2+hBAtT30TnIkNfK4CooCRGDOtXgR+3cBn1EprvRVwWgZVKVW59Oy/Xdz2TX3GDfm7xPZV4zCy9q9vcQlOcV4WAAXm5rFbdmhYOPrxdJhpdKeNy/6ClT9fROzyJ7Fe+Q59+g9v8DMLioro+vk4+3l867Zui9ffdO41iM69BjmVdxx2KSy/m27luykvLyMwsKaFMYUQwlm9Ehyt9ZJGPv9bpVQQcHMj728QpVQYcB3G2jzzaqgTBRTVMuvL7ymTidXJv2PEkbexnGh5a6SUFuQAUOKjfagaQ5lMbGk1hf458wEYteIWULD7mzug/6YGP2/F589zQcVxho4modbaLVNYVCwZxJKgsjl69AAdOvfCYrVhNqlza9FLIUSjeGMX8PVeeg/AtRgtR+/XMBB6K3AGKFFKrVRKXeSluFxrwvTXwLbGQmkjT37irmj8RnmhkeCUB/hmH6rG6va7jzlKG4eyaH2mUc+alPZP+3H6xFeaFFdzlhnUzvh6ZBdL533J6ZldWP3sRTJ1XAhRpzoTD6XUpMY+XCk1WWv9mdY6trHPaKBbMUbuvndWeS4wC2PriMsxNgbtCPyglJrupdhq0fDfRpP7T7Afl5WWuDEW37MUVewkHui/qxi7EhYSwrG4UQ5lJq05ciSNNT//t9aFAIsK81ny4ZMcPWhsXRCgbPZrEXH1Wz6gJcqPSAEgfPHjjFt9K0kqm5Flq0g/2nLXgBJCuEd9WlbmVewQfolSqs7pOkqpQKXUFUqpJcCPTQ+xfpRSPYAxwCKttcOnn9b6Fa3177TWH2qtv9Va/wNjMPIp4GWlVI1NBUqp25VS6z0afCMkJKXYj7NPH/NdIB7gDxttNpY1qoPDeaLKJvm9VIavuI3sv/XAWsPq05u/fZ3xh16i5ONrOH1kt8O1yNg2Lu85F9hiuwHQnSMO5XmnJcERQtSuPgnOQMACfAucUEp9opS6pyLhGaWUGq2UulQpdZ9S6r/ACeBLoAgY4LnQndxa8bVe01e01lnAW0AMMKqWerO01kOaHp7Lpzfp7n3mrgDknT5aR81mpsRIcHRw8xhkXF1Iu741XktS2Wz/xwVO5Wl7tzJqz7MAdNNpHJj7nMP1Vq3P3RackM4j7Mf7VEdOVjQGF2cdr+kWIYQA6jHIWGu9HZiilBoJ/AGji+d6nH86KyAPY/r2m1rrdW6OtUZKqQDgJiAb+LoBtx6u+OrbuciNHC9ZEJQAxfspympZLTiqxOiiUqHNL8EZMP4K1pXkkZw6nsT3nPPiXsXOy0KlL/+YjtXOR2ZV/RX+IeVhLj6HZw+ljpjCL9lvkNAmmd4DR7Pujem0yZpLeY4kOEKI2tV3mjha61XAqopuqsFAbyABI9HJALYDm7TWtpqf4jGXAonAP7XWzjv31axbxddT7g/J8ywBxsq2iSufwDbpBkxmb43l9qzAEmOpooDo5tc1ExAYyNBLZjiU7Td1IvnhtQT9LYEgZaUg5xQRrRIBYzr4yCOzXD7r0LULubi3hxoPmwmTSTHxkhvs57aItpAFOi+9lruEEKJxWzVYK/aX+kBr/Q+t9QsVY1s2+Ci5garuKae1b5RSAUopp6YApVQH4PdAFrDSs+HVoIkzQaKK0gBoSyamp1qxbqnLmfHNTlhphvE1tp2PI2matRHGgnXZ7SYSFBTEroCeAET8szurv3oNnogm4vmq9W2O3riCn/r8A4BMHUW7Lv28H7SfM0e3ByCg0N3rhgohWpp6t+D4K6VUEnAhsFZrvc1FlQjgkFLqG2AXkAP0AGZUXLtea13srXhda1wfVeGoB2HZbfbzoYumsb7kTYZMceuail4XbTFacCJbJ/s4kqZpe9Vz/LLkUwZdfg8ApcHxxmg2YMTWRx3q7jZ1o2fXvnTo2pfyK2cQpSEooGW0yLlTSILRmRefv5v533xEp54D6dZTEkEhhLOW8Ak6HTBT8+DiYmAOMARjevgbwA3AAmCU1voLL8ToEYMmXetUZtvpaoeK5kPbbMTZjHVw4hLb+ziapunQqQcTpz9JdCtjYGxewuAa6/b4v6oha4FmkyQ3Neg6ZDKZxJBiO8qUzXdhnn092uarhmMhhD9r9p+iWuu/aa2V1vqdGq6Xaq1naK37aa1baa0DtdZttdZXa63Xejves6Jr8hOKHnQcbGk1hzT5mb50JieLIGWhkBDCIprfIOPa9L/sLpbFXe1U/kub38rKvPUUFhrG7u6/t5931kc5tK/lreYthGi6Zp/gtAhN+OEWFua4hI8OCG1qND6Vk2EkbLkqxseRuF90bAJj7/o3S3o9QakOZFHPJ+GJM0y849xdqbgxBl9xD0uTbsWmjX83xzb8z8cRCSH8kSQ4LcDmoGobFZoDfReIGxTlnASgIKCVjyPxnPHT7sX6lxOcd92ffB1KsxQaGsq4219i+8DHjfMjv/g4IiGEP5IEx5fctJ+OJSTOfpx6fLZbnukrpXnGDKriwJab4ACEBTfvRNQfdBx5BWXazNCSVaz+8FHWzJ9NximZPi6EMEiC4xeaNv6iuMev7McRyscTwpqoPN9IcMqDWnaCI5ouOjGFdZ3vBGDEodcYvvJ2ct+5FJvF4uPIhBD+oMEJjlLqCVXLiEilVGzFlGzhJaMvuoH5oRcDxqJyzZktz+iisoTG1VFTCBh980w2h1Zt59DNsp+Vb/0eiyQ5QpzzGtOC81fgF6WU0ypsSqnxwBbgoqYGJurPZFIkDjNacQqDfLvrRFMFZ+0EILBtbx9HIpqLkq5THc7HZP6X9XNf91E0Qgh/0ZgE5w5gKLBFKXU5gFLKpJR6CmNtGQsw3n0hivowBwQbX3W5jyNpmtCybADCE1J8G4hoNlIvvIWVMZeycvDLLIm5AoDgA/PYt2UVa165gU0LPvdxhEIIX2jwSsZa61lKqRXA58BXSql3gL4YO3J/AdyutT7j3jBbODesgWIKrEhwbGVNfpYvBVsLAQgKb3nTxIVnhIVHMupP/wHg5JEx8N7XdCncTN7X0xnOScqWzeNYp36079LHx5EKIbypUYOMtdY7MFpxVgG3ASOBv2itp0ly4xuBIcbGm4G2huw16n9CbEUAhEZKgiMark1yd9JVa6JUEe0xxnMFKQvp3870cWRCCG9rVIKjlAoCnsdotTmI0S11Z8UYHFFfbpomDhBUmeA0aDN1/xOGkeCES4IjGulYVNW6UGtjL8GiTQw7M4+CxxNZMeseH0YmhPCmxsyi6g6sBu4E3sTonhoLlAELlFIzlVIy/bxBmt5FVdmCE9yMW3DKLVbCK/Y9jYiO9XE0ormKv+gvLA6/kPltbqPvjFlsip4EQIQqYXT6B6z84iXWLfiSk6dPk1dQ4ONohRCe0pjdxDcA5cBVWuuvK8rWKqX6A7OAx4AJwDi3RCjqJbhiy4Y2ZJCTk02rVs0vQcjOOEGisnKGCKIrxhQJ0VCde/anc8+qBS+Trvwb6/9bSteiTcSQz6gdTxoXlkOeDuXIjT+R3K2/j6IVQnhKYxKcLcCvtdZHqhdqrfOB65VSC4B/uiO4ls99XVQhoVV7Uh17/TJaPbbcbc/2lrzTR0gEckxxtKxtNoUvtUvpTrsHv6O8tJjtL11I+5J9xChjMHuUKmb/lw+QZS2lJGkEI3/7d3Jyczi+ex22Rc+QHdOPoPAYOk28ibYde/j4OxFCNITSDRwHopQya62tddTpobXe06TI/IxSSgM09M+rVpn74LUhENcV7trQpEdZrVbMT1W12uxTHen40BqCQprP5pubF37OgGW/Y2vIEFIfXujrcEQLlnl4Oyc+v4d+JesdyjNUHCabhTjlOFcikxiyL3iN7iMv9WaYQog6VK47rLV2GuvR4LEydSU3FXVaVHLTHJjNZofzbjqNPcvn+CiaxinPOQZAcUhrH0ciWrr4lL70e3ghGwIHO5Qn6Cyn5AYgnly6zvsNW5Z926j3lVss7NyxGavV1qj7hRAN1+AuKqXUonpU01rrSY2I59ziztYgF0pLm9e+VLpym4bwNj6ORJwrEq59hY1fPUh5z19hDYqkMPMoUfFJWPIzCYxuQ2nOcZKHXUbGlw8wpGgp5Wvfh7GXNegdWms2v/QrhhYtY0WPRxh9/cMe+m6EENU1ZgxOZ5wHjwQAbTFahDKBwibGdY5p+iwqV0oKmteSRKrwtPE1ItHHkYhzRXK3VJIfmld3xcuegM/PIyV/I6tevh6r1crQuz5k07dvEHDoF6KmPEz3AWNc3nrowG6GFi0DIOrgj4AkOEJ4Q2NWMk5xVa6UCgbuA36LbNXgE5tG/JOBq6vW+Riz6yngAd8F1ECBJZkABEVLC47wLx26DSCXCOLJJf7MjwBsmnUrI7J+AODI3APo1B0ok3Ovf+aBTXSuOG5XfgitNbXsVyyEcBO3rVejtS7VWj8LrAFectdzWzb3dlENvHC6W5/nbWFlRoIT2koSHOFfTGYzh0Ict3oYWJHcACTrdHatne/y3rL07fbjWPLIOnXMM0EKIRx4YkG+5cAFHnhuy+XG3+ZWDX3V4VxrzfqtWzlT4P/jcSItOcbXhPY+jkQIZ4XxqfbjAh0CwClasSb6QgCC591P1qmjTvcFZTvOuTi1b6PD+bGcIorLjLkbFquND155lI/efMa9MzaFOAd5IsHpBAR54LmiHkZefBPHVdUYlhUL5zLkq7HsfnmqD6Oqm7bZaGUzEpxWrdv5OBohnMUNuZISHcjq8Ilk3TCfFb3+Cr9fQ/yFxpiaLhzj2Hs3Od9XeACA/Wajo6rw6Bb7tT1HT5L+8kR+eOshAPYdOsT03Ne46dTzpB3cW2s8haUW3l5ygGM5RW75/oRoaRqzVUNyDf8NUEo9ANwNLHV/qKK+8lTVMnmB240VXYdbN9ZU3S8U5ucSosop1CFEyD5Uwg/1GjCKvHv2M+hPc+jYvT+jp91PYmIiXXoNZGXq3wDoW7KJvNwM+z2WslI6WI1WnVMdjF8yzBm77NdPrvuGYabdXJ39DmCs5l0p+2Dt/2a/+fpzLl00mfn/fcM936AQLUxjZlEdpubBIwrYjZHkiLp4qAnaMuVZmHeV8QqPNNK5X+7po0QA2aZWhMsATOGnWse6Tr5HXflHdu78mN6WXaRvXUxhykDSVn+NyWRmmLJwRCUR1X0MHH6N+DNb+eWjp1FFmQQmdLY/oyAvB0ry7Oelpw/UGku/fa+TpLK5Lv15mtNkAiG8pTEJzkycExwNZAN7gQVaa6+sZlW5urALhVrriLPq9gD+jjHDKwjYCDyuta7Puj4e5t4f6G1TjCXls4huNrM18jOPG18Dmt8eWkIAZESnQtYuei6aARjrZlQ6HjeKIUPOI2d+JB1tx+h48B8AbM2pWmgw8+heVGm1pR1yDtX6vla2XADCVPPdYFcIT2rMNPEnPBBHUyzD2OSzuvLqJ0qpLsBKwAI8D5wBbgN+UkpdpLVe4I1AvSWkYuPNOM6wv5kkOMU5RtN8cVCcjyMRonHMycMha7ZT+QHVkW7XzCQwKJg98eczIvMr+7XU0qotWlK+mEJKtftCC50HLFen3TwLU4iWpjEtOP7moNb6P3XUeRaIAQZrrTcDKKU+AnYAryulemqfTFnwzCtDQsPtxzF5u+3H5eVlnMjIYt+mpXRc/zeyht7H8Kk3eySGhopc/zoAltB4H0ciROP0nXAV6/fOxRYUSeigacQm92Hf/Lfpc+ndxCcaA+cTJ93NqdmLCaWUqDrWQ21Vmu6y/OjJTMosFoKrN5Rr7dbZmEK0BHUmOEop52kB9aC1/qgx9zWGUioICNJaF7i4Fg5cBiyuTG4q4itQSr2L0eU2FFjrrXiduPmDKSCwahJbmK3qQzTwmQSSgeSK865r7wY/SXC62SrGG7Qb5NtAhGikmOgYhvzZca+qdrc973DeqddA9OMHyUw/BO8MrPV5idaTaJsVZTKTk5PNjndvJy+iC4NPziaKMqJV1b/t8uIzBIbJ4HwhqqtPC84HGE0NDfkprAFvJThXAzcCZqVUBjAbeExrXdmZnQoEA6tc3Lu64qtvExwP2GTux0DrNiJsTjmfg63PjCFh+qe0bZdcaz1PspaXUblV6ICpM3wWhxDeoJQiIalTnfVCVDk/f/Ii5//mQTZ8/jSTC3+Gwp9dfhLnZ50gVhIcIRzUJ8GZ6PEoGm8t8AWwH4gCpgJ3AuOVUqMqWnSSKuoed3F/ZVmNC68opW4HbndbxNVFtoFL/wUh0XXXbaDMkI5QuI1W1L4fVWr5NninH2kkwQ3/pWO3fm6PpS57Ny2jV8VxcHCo198vhNcpxdLYaxiX/QWrh72GKSKejj2HkPhGV4dqQ/b/k7n/OsHl2e/V+riinFPEduhVax0hzjV1Jjha6yXeCKQxtNbDzyr6SCm1FXgGuKfia1jFNVdTDUoqvoa5uFb5jlnArFpmbDVeaCsY7JkuohJzRN2VqulIOhu+vA/zb96nfXvvriScudZ5YKYQLd3IP7zNwfTHGZHcwV62wtqH0eYdPF1+A48FfkIrVVBncgNQnHvKk6EK0SzVa5EUpdQwpVRzmb/7D6AMuLjivHKZz2AXdUPOqtNixEeF113pLINL19L+3T6ceqITR48dxWb1ymx/AipabdaG+3NjoRDuFRhgpnO15Abg+IXvcXXpXxl47aNsCXYcj7b72mUUaNctnCGLZ7J/3y6X14Q4V9V3FbhVwIWVJ0qpCKXUp0qp3p4Jq/G01uVAOlA5HadyKoKrbqjKMlfdV82azWpp9L2JZNPh3b4s+feDbozINYvFwsjjHxgnXSd7/H1C+LNrR/fkgyfu4eL+7TgT3sVevrbVxfTsncr+axexf/pWp/s62I4R+5/JHD9e+9RyIc4l9U1wzh7WFgxcB/jdts9KqRCgPVDZZrsNo3tqpIvqIyq+rvdCaF6lAlxvB7as5/+xOPLSej1jYvo77gzJpbT9VTsth8TKHlRCRAQbIwes8d3tZdZEY2zcgD696ZrSkV1mYzHP5daqHc5jVQFpG37yYqRC+LfmsY6/C0qpmlaEewpjbNF3YEwHrzieoJTqX+3+CGAGsI8WNoMKwGSuSnDyqzVrJw+9mAn3/4elI/7N/NCpLI9o+Mbvu9NzKCgpr7tiPeSfrFqOPmXAeLc8U4iWIDSpKnmJSBnicK38qg/5ptuzdL//J+akPMGqsPMAsGRLC44QlZrzQn+PKaVGAL8AR4AIjFlUE4E1wKvV6j4CTALmK6VeBvIwVjJuB1zsm0X+PMvcuruxaxgQ+MhhDp1MJ+vUMYZ0MWZajLvwarjwagDWrfqF3MWvcX6p84LOSz55lvE3PGI/375zOymzJzE/9CKufPiDJsdZmmEsR782ZirDopvLMC8hPK9TnxFk/RJFgQqj64BxDtdSe/citbfxb/mq6fey4ZMc2LcICus32Lik3EpwgKnZbOUiRGM05wRnMdAbuBmIA6wYrTGPAi9prStnSKG13q+UGg08BzxM1V5UF7a0bRoqDZh8HasOLSek7yUMDAmhU0pnOqV0dll36MiJMHIim9cuISwyhu6zqz5Mx+97jrLS+9i1/he6DRpPx9mTiVAlXFnyNSWlswgJdt0VVl+mbKMFpzyqY5OeI0RLk5gQx/7b1qNMJkJDXM2RqKIiEwEIKc10ulZSbiUk0Gw/P5h2mNPv38jJhDH86o/PuTdoIfxIQxKcqUqpyjE3YRiL+V2jlBrgoq7WWr/c5OhqobWeC8xtQP1dwOWei8i/BAaFMPKP7zbongHDjC6iJV0fZPz+qhVY1895gVF7n4efcRiNdfrZvsQ/uJGwsIZNSa8uLMfYSiIoyfvr7wjh77q2T6xXPXOEMacitCybwxkFnMjIYGTvTqz83yd0XP1Xtqc+wgVXGYtoHl84i7Fsg4xtlJU9RVBQoMfiF8KXVH16Z5RSDZ0vrLXW5rqrNR+V6+C0wN4sJzarFdNTVd1F+TqUSFXssu7Kdr9l1G2vNOo92mYjZ2ZHYsnj2M1raN+pZ6OeI8S5bue6hfT+4Ur2BXQnV0XRu2wbe6Z+Qcy8P9JZHyWdeJKeMFpLV71yAyNzvwfg+PR1tEvpXtuj663UYiWnoJQ2MTUuKyaE21V2s2qtnfpb69uCIwuUnENMZrNDK05NyQ3AqOPvs+uplXT582KCQhr2wZa2ZxMp5JFJDEnJ7vmQFeJcFBxptODEWU/TTe8FBf1/vBxzxfqkSWSyad0Kck8eonXBQft9Ocf2uC3BWfnyDQwuWML2X31F34HGpNX8ohJsKE5l59EmLpqo0KZ1aXvC2kPZpMSF0ToqpO7KolmpV4Ljz6sZC88Yf+Oj8MTzdVcEeln3wHNt2XX59/QaOLbe7zi1Zw0pwNHwfsSbm+2EPiF8LiwmAYBYnWsvM5+1+PrAH6Y63Vd0an+T3rvv4H5OfXQruZ0v55LC/4GC3JXvw8CR5GSdpujV0bTjNNHA0tDJjHtoTpPe527rdh7A8tmN/NhqLNPvq9/nnWg+5KeKqNHSDr9vUP2gb+tff8uybxm+2ZidVRYnXVNCNEVEVCw25xb6OlkzD9ZdqRbpP7/BGDZzycEn7WVRefsA2L3gQ9px2l4+rngBefm1743nbQVb5zLKvJPpeW/7OhThAZLgiBoNu+Fxp7KyR7M5fssmDt+w3OlahK7/jhf9F/7GfhzY1u8WxBaiWQkPCSav2pZ6y9rNYFXQSNJ0GzZGjKvxvpC8piU4YfnO9yeWHQEg9NDPTteO797QpPe5W7DNPtmWwrwcH0YiPEESHFGjkBDnfW+CAs20S+5MSrd+bDSnOlwrNtVv/6vjx9IczmM7uZqIJ4SoL5NJcUZF2s8D2/Si3/3fE/7nreghMyjVAWwKqlos8IjJ2FB3YOFyNj05gh1b1jXqvQlFzl1cCbYsrGXFJJXsc7p25vCmRr3HU2wl+fbjrPSmJXvC/0iCI2qVZmsNwNem8/mql+PM/5Ap/8fWoAFsnfwpACm2I2x9egxbVy+odbZZm3fsC0qzbsQbpPQcVGNdIUT9FJqqEpzY5D5EBAcQHxHMoPGXceL27fR7cD7fRd9Apo7i9Hkv2usO1LvI+PklAKy2+s8SLS4soIP1mFO5SWmO7lpLa7Ip0YFsvnYNi1tXtNie2tbI784zTKVVY5byTx7yYSTCE5rzQn/CC/Iuep1VR7fxq2vuc1r1tPfwKTB8irHreMVyiamWbTDvKpgHK1r9itH3fOj0zOqDH4deeINH4xfiXFFmCoWKBT3ada1aV0opRUq7tgBMuetVTue9wJDYMDYtH87AkjUAJBQfYskzF2PSNob+eW69FvA8tncD3c4ayLxPdaSbTiNr03ekAOkB7RjQuyfbMyfBoo+JPrPHLd+ru5hLq8YElWQd9l0gwiOkBUfUqt/IKYy89v5al3Q3mU0UaeeVVkfnfMOhA44faIUlZfbjlb3/z32BCnGOC7FUdbeEh7tefDM4wEyHWGOsTrvp77EsfhoAfay7GF++nLGWlexe5zx2prrCUgtaa3L2rgJgq+5KmTaz1dSbE1FGd3Pc8V8AyAlNAaBtD6N7rEPZIbTN2sjv0P0CyvPsx7Zc59Yo0bxJgiPcIv3aHzmjncfg5H52m8P50aOH7ccjr7nf02EJcc44EDMKgO9V/Tatbd2mPaPueB2LdvwxUHRki/1Ya82iWQ+y+F8zKCkpZvvmNRT8rSvbnhpF0u73ASjofR3LLlpA1Iy5WGJSAEgpN8bmlMd0ASAusQOZxBChijl91HFsjs2m+fGHr1i12XPdV9pm45f3HmPRvx81WpwrBJdXJYUB+ZLgtDTSRSXcomufIZT95RArvnsbm4axO4zWmYGWqg/LdfM/Y+CKP4CC3SH96Skb/QnhNilX/JW35sQz9OJb6n2POSCQEyqOtmTYy0xZewGwWW0seftuzjv9MQCrvuuNLfMgfVUOibaqGUeJfSfQpY8xju5wXGeoNofAaF7/qQAAIABJREFU3LpqEcFjQZ2JL9tI5v4NJHasWhpi/aI5TF13K4fXtcWWuguTyf2fC1tW/MjEI8b+yxtXjGDQuEsBCLFWJTihRcfd/l7hW9KCI9wmKDiY0Vffzdhr7mZ1n6op5nueGkrWqaN0XfFnAip2/TgVN9xXYQrRIvXp2IY77pvJ4B4pDbovO7CNw3lo4VEA1n/xLBMrkhuAyH1ziTiz26HuAVNHOvcabD+PaNPN4XpUu6pE5ky0cVx2fItDHeu+hQCkcIL0Y40f6HvsyEGOHnF9f96+lfbjogNVx+G2qgSnXekhyi2WRr9f+B9JcIRHDLz0DvtxD+te4t7sSytV9WFi6Vjz2hxCCO8pDE1yOI8tTWfjkm/pv8uYNblO9wKgZ+lWuhcbycnhq+exqvtDBP76M5Sp6sdIp259HJ7VpnPVYGfd2rgWcnIji165leXffwRAZO5Oe52cY/UfhJxbWMLsT95hX9pRtq1bSvy/h9HhvQEs+8e17Ny00qFueP4B+3FodlWSFq4LASgmiEhVzPat/rVOj2gaSXCERwSHhJFNlMtrOTqCcROmeDkiIYQrZWGOO5Yn2k7R9pd7CVblbAwczOC/rmRb8CAClI1QVUaxDiK551BG/vovJHd1TGjiWsVwmlYAHCeB6FZx9mvhycYA5F5F6zgv90tGrLuH00f306G0akxOv/nX8cUX/6lX3LvmvsC0fQ9w8L0ZlCx8lhBVDsDYwp+Imnsz1mqtMUGl2fbjqGKjhUpbLURRiE0rDkcNAyBr7+p6vVs0D5LgCI9p9dc09l/+nUPZwta/xfqHtQQGOc+6EkJ4X9iwmzipW/Fj5NVk0IogZaUtmZwhnF73/YDJbCK/42R7/WOByZgCah6+eXDYTI7qBPb0e8ChvFPPAZToQPt5gLJR8N4VRFPoUO+aHX+sV9wR6UYrzQVqNUNLHFts2nOaXesW2M9Dy6rGDLWxHOdkTiGnTqUDkE8YJYnGGKLQjK31erdoHiTBER6jTCa6DhzH4V8v5xit2WvqwphbnyU+sZ2vQxNCVBg0aCgnbtnIuDvfJiOwqrvqcNRwQkON1czjBl5qL8+N7FHr80ZMvYmEx/Zw3lV3OJTHR0ewufXlDmWd9RGXz/j520+Z/96TlJSW1vie0HLHfa1WxV3Jkdt3sbqVEWvurqo9oiOsVXUjKSLmlY7wttFNnmeKgrjOAAQXn6r1exPNi8yiEh6X0r0ftr/uRaEd+uuFEP5hYMdYAPJD20P5DgDKO461X+/aox/76EA3jmLpPNnlM6oLCTS7LO914wss+DCQgC7jCCs+Scq2f5Jhas2p5Kmcl/aKvd75G42Ne1d9F8XIq+/FZtMs/tctROQfptMdn5OQkEhsWdWspzVhE+h/62uEhYWT2WEQ/9/efYdZVZwPHP++21iW7bssXVAQEAEBwdgQEKPYTWzRGKPGGBNLokn8xWgUSzSJUWyJxhKjsUdRMWjsoggWpIMgSO992d7u+/tjzt62Zxtuvft+nmefe+/MnDnn3lm4787MmWH36yTuCc27yVAX4KzV7vSVLSRLBd1xvTpF8ekkp7sV25MrQisbm/bPAhzTItytn3ZbuDFtWXlqb/DWvss75IRgenycUHXOs8xYOZexJ124z/VnZGRx3NUPhxLOupY8IH3jRnY98hjZUhhRPnPFVOAaln21iGP3TAVg9vQpdL3gVrJ1N5Uax6LzPmf0gf2Jj3d/PCV3HwwLIbPY3a9eVVZEZ8oo0wQ2Jfenb9mWiHMUJebQNTMXgC5VbWu3c/Pt2J/TxhhjAIgf+F0CKixIOIQ+/YdE5A0eMpxxp11EXHzTf2306dWLxed+yquJJ0WkDypdRMH2dez87Plg2n7rXmXvdje0tZ1MRgwaEAxuALJ6eYsLVmzmk4/eZudWN6l4j6RT3PPIGucuTetLara7VT49YAFOLLEeHGOMMQAcMW4SC3t8Qc+8bnVuz9IcjhnSh+mzD4L1bwTT4kRZPfNF9tswLZjWK7CZee89wUhgT0IuPaKuM6d7PwIq5Eo+ue+fzdcJA8kD8uMyOeIH1/HW+weTRSGHfXYlAIn9jiA1sysAqVqEBgI2lB4jrBWNMcYAbmPOQwYdSNcs/yUemlt8bv/g8y9TjgZg+ILb6BtYz2ZymNXzxwCMXPkgAIVJeTXqSOrUie2SFXw9sNKtzFyUkEVKpyROOPF7DB9/Jl/IcObGDeXgcWeSlJxCmSbSSSopLi6qUadpnyzAMcYY0yak9w6tq1Nx+FUReUsOvILh595MiYZ2Oq9K7eFbTwWJNdLyE0PBUHLnFIb9/kOGXP9RcGPSQnF76RXlh9bMUY3cLd20LxbgGGOMaRPGjBjOSz2vY/qwBxh62LERecNO/AmpGTks6jw6mBbI9b9lfbe4HqgSTWJGlxMo1UTKhp4bUSY5MT7ibq+iOBfgFO/dQXl5Bf+983xeufNCSstt+4b2qt0GOCIyUERuFZFPRWS7iBSIyHwRuUFEukSVnSwiWsvPb2o7hzHGmJaTGB/HWZfdwMlnXkhqchIfyRgAliSPolt2JgD5fUN3d2UO8N/TbvXgn7FbU3l3yB855jcvsO7n33D8pDPqPHdJnOvJKS3YxZKPp3JK2XS+Xz6N1cvnN8VbM62gPU8yvgS4ApgGPANUABOA24FzRORwVS2JOuYaYEdUmm0+YowxbVDKibfw3qx/MvB7NwbThhx7PnOXP8/e5J6MHXG073GnnH0pc9edyfG9MxARBnbPqPdcZQlpUAllhbspX/ByMD1/43IYNrqOI01b1Z4DnJeAO1U1/L6+h0VkBXAD8BPgwahjXlXVNS10fcYYY76F0YcdBYcdFZHWq1sePW6a7a2t5S8uThjdL7tR5ypPTIdSqCjaTe+CUK9NVcG2xl20aTPa7RCVqs6JCm6qveA9DvU7TkTSRaQ9B3bGGNOh1RXc7KvKRDdvp3LPRnppaMsGKdre5OcyLaPdBjh16O09+m0qshDIB0pFZJaInNhyl2WMMaatCnRyAU7yljkR6XHF0bMamk9FZSVv/vVi3ptyMWXlte/DZRompgIcEYkHbgIqgWfDsvYAjwBXAacD1wN9gekiclE9dV4mInPqKmOMMaadS3bzdPoWLYpITihruf2pNi76iBMLpzIxfyqzHr12n+pQVTbtKrRb3ImxAAe4FzgcuElVl1cnquq9qvozVX1SVaep6l3AcFwvzxQRSa2tQlV9RFVthpkxxsSwuM4uwMnyNuNaGj8YgMSS7bz20A3MnPlho+pbOO9zPnz6DoqLChp8TPGGUHA1dtuz7Nq1s1HnBHjnhQdJve9APn7+r40+NtbETIAjIrcBVwKPqOqd9ZVX1Z3Aw0AmUHODEmOMMR1GfEpWxOsd3d0dWoeUz+X0rQ+S/fbVDa4rUBUg47ULGb/yz8x98rpay336xWe8+db0YG9Lxa51wbwECbBx2eeNeQsA9F32KOlSzDHLb2fLxrWNPj6WxESAIyKTgRuBJ4DLG3HoGu8xt4kvyRhjTDuS2CUz+HwvKWSNOC0if0jcWkpKSiPSqgLKS0/cw/Tpr0Wk79i6gb5sBmDwtjcIBGoOF1VWVtL/v2dxwqwfsnjebO/EGyPKFG/7pnFvQpU8Qisxf/3KHY07Psa0+wBHRG4GbgaeAi7Vxg08Hug9+k1INsYY00EkpYZuK1+RfSzZPfavUWb3zs0RrxfP+YCz1t7CyV9cSHFJaNm1HWuXBJ/nsodtm2v2pGxYvYyuspc4UQqWvgNApyJX//I4tydX1c7G9cDk79hIFqEhsW575jbq+FjTrgMcEbkJmAz8G7hYVQM+ZRJEpMYqTyLSB/g5sBOY1cyXaowxpg1LzugWfJ447PTgDuPhCqMCnMKVnwaff/PVAmbOX0ogoBRvXhZRbvvKmoHGjpWhe1cSti8FIK3c/a29PXuUSy/cWOM4P5t35fPCE1NYPPttAFZJHwD6VawmUFHeoDpiUbtdD0ZErgBuAdYB7wLni0SsjbBVVd8BUoHVIvIq8BWwGxgEXOrlneez4rExxpgOpGe/Qbwkx5MphRx95OkkJSbVKFO8OzLASdgSWhAw67UfcjA7ef+rm8koWBlRrmTLcqJVbFwYfJ5T+DUEAuQG3C3pCX2PgB3/oXPx5hrHVdtdVE58vJCenMiiF2/j3C2PgtfhszVjBIl7yukjW1l8+3cYdOPnJCbW3IA01rXbAAcY4z3uBzzpkz8DeAcoAV4GvgOcgQtqduCCor+oauNncRljjIkpyUkJHPfbZ0iIjyO5k/9XY0W+W9VYAwEUoVthaCiqt7jg5Ljlk9mkOSBuqGlQ4Bvidq4MTiSuDCifzl1Al20Lgsf2qVxH/vZ1ZFDBbk0j74Bh8CVkVPjPnthdUMLXd3+XirhOHHb9W+TtnheRL71Gsk6VPvn/Zais4o0HruDEa/5BeCdAIKD89bk3yUxP47JTx+7DJ9b2tdsAR1UvAi5qQLkyXG+NMcYYU6vMlMhem0/lEA7XUCBStmcTM568haGr/0mhdKGf+g8h9RR3e/fmvLEM2vINKQWreP9ft9B3zYus7DaJSdsejyifJJUs+XQaI4Ed8V3J6+nm4ORW7QBViBydYPGSeYxlEQRg2cKZJFcVRuQPGHs2pfEXMedvqxjNUk7a+wLzZ5zEiPGhDUeXr17LdSvOY6emUXrCGpKT2m04UKt2PQfHGGOMaS6B7z3Cs92v4/3uPwHg6NX3M271PeSwh74+wU2JRgZIaUNPAmBIyVwmrp3CANkYEdyUaiLzOrtVSuTrtwAoSO5BemY2BdqZFCmjYE/kXlj/nTGLVdOnBF/vWvYJOZWhnp4P8y4gt/t+9O6aw5DffchCcev5lCyeFlFP0Wo3eJEjBezctqkRn0r7YQGOMcYY4+PI4YM5//IbSM7uFZH+aedjgs+Xxx8YfL6oS+SSagMOGUuZ1t4zsj6uF8XZBwEwvPATACrTeiEi7Ih3k5y/mPUBqzZu4b3bT+HN5//O4Pcv5cfxbwfrSNoyl67spkLj2XXNBsb9PLTHdEpyJ+KP/T0AmXuWRpy7sjC0iGD+tnVs3rmLWGMBjjHGGFOH+NTQUmkBFUZc8W/+l3Eu2zSTPUffHMyryOjLJlxgslT6k5GWwqxel7BRujEvbVxEnct0P3YccztJvYYDECdujk4g1wU8G7sMAaDnnD+x8d2HmFj5MRO/upEBEtlz1LfA3Y21PS6X7Iw0om62oc9BbiH+3hVrqKysCr2PolBAk/LqJXS9vz+z33iqsR9Nm2YBjjHGGFOHThndg883xXUnOTWTiVc/TMJ1Kxgz7hRW4m7LDhwwnoWDr2FVoAe7jroJgAmX3UWvm79m5K+nsSRxGACfdR7LAX9YwBETTqXnsPERQ1vpA10v0IAf3gPAYF1N6saZACRJKECp1hW3V9auxG418gDSc3qym3TSpIQNa0N3d2nJ7uDzfnFbSZAAnec/0bgPpo2LvVlFxhhjTBPqnBkKcLZ33p/eQGJ8HNldXGBSdNZzvLJiKSdPOIOkhDgKSi/jgOSat2VXnDSFt997gL6n/Z6kBNe/0KtPP+ae8hrLPniazJzunDj8OwB0796LlQkDGFC5kpHlNfd7XqU96cNWEr2gp6hzT/+LF2FL8gFklc5nzbO/ZOvp9zJ66CDiSmtuIjqg7Cs0UIXExTfq82mrLMAxxhhj6pDbo3fweWlavxr5hwwdxiFDhwVfp/kENwAjRo6BkTWHgUaNOZJRY2puiVjQuQ9ErakDsFFzKLrwLbY+M4neATdkVZnZv9brL8wcDFvmM75qNkz9Du99+SvSy2sGOKlSwrb1K8jrO7jWutoTG6Iyxhhj6pCTncNX4m2fMPDEFjtvRUY/3/TtKQMZ1n8/tqYMCKYldRtYaz1ywISI14eseYLkcv9JxSu+fL/xF9pGWYBjjDHG1KP83Od5/bCnOXLCqS12zrg8/6ClrJPbN6swe3gwre/IibXWM/K4c5l22DPMOPkDNmkOuZLPsNIvfcsetfB6li9b/C2uuu2wAMcYY4ypxyGDB3LqSacSFyf1F24iXXoNDT5flhAaNqrqnANAv4k/4XMZypt5l5LXo0+t9cTHCaeddArjxoxi1QEX+JZ5v/PxwefbP3vx2156m2ABjjHGGNMG9Ro8mgU6gDXag50HnhNM1xR323rfvvtz2M2fcOIv7m54nYcc65ueM+5nfJTqht8Sd6+okb9i8252FpQ25vJbnQU4xhhjTBuU3iWFtCtnUPWLz0jvMySYHp9Wc6fzhuq2/9CI1yWaRL6m0GvQoeQcfp47b9HaiDJbNqwi6+HhLLj7VDQQ2OdztzQLcIwxxpg26oCuqfTvlkFKdug28Pj07nUcUbeUjFwKSQm+fv7I15l+zDRys7LI6euCnx4V6yKO2brgHXJlL8fyOUs/eb3B59q6t5THZ66mrLLm+j0twQIcY4wxpo1L7xq6VT2t57e7jbsgLi34/OITDuf8iWMAyOu5P4XamUwKyN8R2p+qcnvoVvW4D25r8HmeefIhjnr7VO5/ruFBUVOyAMcYY4xp47KzsrlDL+FRPYM++9d+S3hDVEmSb3pcfBwbEvcDYOWjF1Fa6ubcxO9ZHSwzsGolRcUlDTrPtTsnMzhuPSNX/+NbXe++sgDHGGOMaePi44Sf/uZPTPrlQ3Tp9O3W6F2eNwmAd6oOrZG3q4vbPPTQss/46uELKSsvJzVsTk68KJvXf9Oo8/XUrfUXagYW4BhjjDHtQNe0TvTJTqm/YD32O/m3PJZ8MXLyXTXycib9jrm4DT9H7nmLJX8+ju4VGwDYID0AKNq2OuKY8spAnfNstJVCDQtwjDHGmA7kwN7duPR393Lc4TV7cAYdNIxRkz9lxsgpAIyqWkAqxezSNLZ3cUNjpbtD83N2F5Tw/h9P5c2/XoKqhiqqqgg+jd7hvKVYgGOMMcaYCONOv4SFaWODr1cnD6EyJQ+AivwtwfQln0xjks7kjNJXWb1+PdMXbKK0ooq33/1fsEyKFrfchYexAMcYY4wxNZT3OSr4XMf8FFK7ASCFbk5NeUUlqfNCE4gXvXQnY6ceytQ7fsTxs0MrJnfRoha64kgW4BhjjDGmhj7H/Jjl9GV28tGMmnAmCRlu/Z34ku0AfD71PkaUhfa0On3vs6RLMefr9Ih60rSw5S46zLebim2MMcaYmNSte0/ybl4QnEPTKctNMj40/z1m3XESWZU7ACjTBDpJZa31JEsFpSVFJHfu0vwXHcZ6cIwxxhjjK3yCcGqOW2wwUao4svwTDg4sB2Be5nfrracwf2fzXGAdLMAxxhhjTL0y83rVSAuoUDXgeJ/S8MShU1mL22LitmfeYUt+y27W2WECHBGJE5FrRGSZiJSKyHoRuVtEWrbPzBhjjGmH0rJr7oFVTgLp+w33LX/xqRMpTUgF4L6Ca/nLc9N9yzWXDhPgAFOAe4ClwFXAf4CrgddFpCN9DsYYY0yjSXwib6edQbF2okg7ATA/cSQ9+g5kj7q+goC6Ia2Pko4BoCw+tO/V9Xmft+j1dohJxiJyMC6omaqqZ4alrwbuB34APNtKl2eMMca0C+OufpwNuwrZuOQTqj6aQqcJN5Cbmc7C773G10V7KUtIZ8e7U+h38m8AqIzrFDw2u4v/HljNRSJWHoxRInI7cANwjKp+HJaeDOwEZqjqSfXUoQAd4fMyxhhj6qOq9a5S/PXtYxhY+bV7ce0ySO/RpNdQfX5VrXEhHWVoZgwQACL6x1S1FJjv5RtjjDGmgRqyBcPiricD8LJ8t8mDm/p0lACnJ7BDVct88jYCuSL++8eLyGUiMqdZr84YY4yJQQefdi235tzFfufW3NizuXWUIapvgERV3c8n7yngR0CWqu6pow4bojLGGGPaEBuigmKgUy15yWFljDHGGBMDOkqAswk3DOUX5PTCDV+Vt/A1GWOMMaaZdJQA5wvcez0sPNG7i2oEYHNsjDHGmBjSUQKcFwAFfhWV/lMgBXimxa/IGGOMMc2mQ0wyBhCRB4ArgVeAN4CDcCsZfwIcq6qBeo63ScbGGGNMG1LXJOOOFODE43pwLgP6ATtwPTs3qWphA463AMcYY4xpQyzAaQIW4BhjjDFtS10BTofYi6opNWTlRmOMMca0ro4yydgYY4wxHYgNUZl2S0TmqOro1r4OU5O1TdtlbdN2Wds0LevBMcYYY0zMsQDHGGOMMTHHAhzTnj3S2hdgamVt03ZZ27Rd1jZNyObgGGOMMSbmWA+OMcYYY2KOBTjGGGOMiTkW4BhjjDEm5liAY9okEbleRP4jIqtEREVkTT3lB4nIqyKyW0SKRORjETm2hS63wxCRgSJyq4h8KiLbRaRAROaLyA0i0sWnvLVLC/E+62dE5CsRyReRYhFZJiL3iEiPWspb27QCEUkRkdXe/20P+uRb2zQB26rBtFV3ALuAuUBmXQVFpD8wC6gE/gLkAz8F3hKRE1X13Wa+1o7kEuAKYBrwDFABTABuB84RkcNVtQSsXVpBb6AH8AqwAfe5D8NtMPwDERmhqtvA2qYNuBXI9cuwtmk6dheVaZNE5ABVXeU9Xwykqmq/Wsq+CJwJHKqq8720VGAJUAoMVvtFbxIiMhpYoar5Uem3AzcAV6nqg16atUsbICJnAy8C/6eqf/HSrG1aiYiMAj4HrgPuBv6mqleG5VvbNBEbojJtUnVwUx9vWOQ04MPq/wy84wuBx4CBwJhmucgOSFXnRAc3nhe8x6Fg7dLGrPUes8DapjWJSDzwKPA/YKpPvrVNE7IAx7R3w4FOwGyfvE+9R/sPofn19h63eo/WLq1ERJJFJFdEeovI8cA/vKw3vEdrm9ZzDTAYuLKWfGubJmQBjmnvenqPG33yqtN6tdC1dEjeX6U34eYMPOslW7u0nkuB7cB64C3cHLYLVPVjL9/aphWIyP7ALcCtqrqmlmLWNk3IJhmb9i7FeyzzySuNKmOax73A4cDvVXW5l2bt0npeBZYBqcBI3JBH17B8a5vW8RCwGrinjjLWNk3IAhzT3hV7j5188pKjypgmJiK34brbH1HVO8OyrF1aiapuwN1FBfCqiLwMfCEinb02srZpYSJyAXA8cIyqVtRR1NqmCdkQlWnvNnmPft221Wl+3b3mWxKRycCNwBPA5VHZ1i5thKouBOYBv/CSrG1akIh0wvXavAFsEZEBIjIA6OsVyfDSMrG2aVIW4Jj2bhGuO/cIn7zDvcc5LXc5HYOI3AzcDDwFXOpz26q1S9vSGcj2nlvbtKzOuCHCk4EVYT8fevkXeK8vxdqmSdk6OKbNa8A6OP8Bvg+MUtUFXlr1uhFlwCBbN6LpiMhNuMmS/wYuUtVALeWsXVqQiHRX1S0+6ROAd3G3Hk/00qxtWoiIJAKn+2R1Bf6Ou2X8cWChqn5tbdN0LMAxbZKI/IhQF+5VQBJuUSyAtar677CyA3ALZ1UAU4C9uJU/hwEnq+pbLXXdsU5ErgAeBNYBfwCig5utqvqOV9bapQWJyCu4lYzfx619kwwcCvwAN29jfNjCcdY2rUxE+uEmHUcv9Gdt00QswDFtkoh8CIyrJXuGqo6PKn8Q8CfvmCTcFg+TbVnzpiUi/wJ+XEeRiLaxdmk5InIOrm2G43oHFBfovAPcparrospb27Si2gIcL8/apglYgGOMMcaYmGOTjI0xxhgTcyzAMcYYY0zMsQDHGGOMMTHHAhxjjDHGxBwLcIwxxhgTcyzAMcYYY0zMsQDHGGOMMTHHAhxjTKOJyNMiUtna19FYIjJTRFY2UV1XicgeEclqivrC6k0QERWRx5qy3tYmzkIRebS1r8V0DBbgGNMCRGSS96V1m0/eEV5emYik+OS/JSIBEcltmatt30TkEhG5upnPkYXbbPRuVd3dnOeKFd7+SZOBS0RkWCtfjukALMAxpmXMBCqBCT554728JODI8AwRSfDSFqvqjma+xlhxCdCsAQ5wJZAG/K2pK1bVStwO1Jc3dd1twCvABuD3rX0hJvZZgGNMC1DVQuAL4DCfXprxuP2CNnvPw40BUoEPm/cKTUOJSDxu88P/ququ5jiHqpZ6gU6TEJG0pqrr2/B6cZ4Gvi8iXVv7ekxsswDHmJbzAZAIHFWdENZDMwP4iJo9POPDjq0+5iAReUhElopIgYgUi8gcEbkk/EBvjoiKyEnRFyIi8SKyWUTmRKUfJiKvichOb8hsuYhc732p10tEeonIwyKyXkTKRWSj9zo3qtzt3rUNEJE/e+XKRGSeiEzyqbeLiNwrIlu89ztbRCZEzwUSkQ24z7e/V3/1z9FR9fUWkRdEZLeIFInIm94uzg1xBNAHeMPnOp8WkUoR6SoiT3mf414RmSoieV6Zn4vIMhEpFZGvROSUqDpqnYMjIhO9a93pHb9KRB4VkWwvf4B37I0icp6IzBWRUtyu1NV1jPDaeJdXxxIR+bWIxEWdq/q9ZIrIP0Rku1d+poiMiSob59WxyPud3Ou9x8d8fnfexPVWnt7Az9uYfZLQ2hdgTAfyAa5rfjyuxwZCPTQzgL3AfSLSRVWLvPzxuF2hZ4TVMxH3JT4NtxtxKnAu8LiI5KjqXV6554C7gQup+WV8PNAduKM6QUROA14ClgN3Abu98/wRt0P1eXW9ORHZH5gFxAOPA6uAA4GfAxNEZIyq7o067GmgzDtfJ+BXwGsiMkBV13v1CjDVu+apwHtAf+A1YE1UfVfhdmHOAH4Tlr487HkaLpiciWuP/rghrVdFZLiqBup6n4R2uf+8lnwB3sK1zR+AgbghrTwRmQ5cBPwTKAd+CbwsIgdG7/Zdo1KRXwAPAuuBh4B1wH7AaUBPILw36SxcEPaQ95Pv1fEd3O9hGW54bSsu0Pgrro2jd4oX3O/qJtz8ma7AtcB0ETnA65kENx/pJlyb/B33O7u/V3ciUBVW5xygAve7HVMTqU0bo6oS9XDpAAAG9klEQVT2Yz/20wI/uHkVZcCssLTrgULcHxsH4b4YjvfyEoACYH5UPV186o7DfWHvAhLC0l8BSoCMqPLP4b5gc73XKcB23JdffFTZ33rXdXRY2tNAZVS56cAWoGdU+ndwX3A3hqXd7tX5KiBh6Ud46beFpZ3mpT0UVW91evR1zARW1tIGM71jro1Kv95Ln9iAdnzGK5vik/e0l3dfVPr9XvoaIDUsfZTP+03w0h4LS+vrtdciIN2v/b3HAd6xZcBAn3Kf4YKLoWFpArzsHTfO573cH1XHeV76T8LSFgILG/FvYQ0wrzX/PdpP7P/YEJUxLURVS3BfMKNFpIuXPB74RFUrVfUrYBuhYanq3p0Pouqp7t1BRJJFJAfIxvUaZOF6Tao9CSQDZ4cdk477y3q6hiYunwDk4noWskQkt/qHUO/P8bW9N2+I5ERcwFIedfw3uN4Mv+PvU1UNe2+zcQFZ+Hs41Xu8J+pzmAasqO2a6lCJ6wkJ9773eCD16wqUqWpxHWXujXr9sff4Lw31eqCqc4GiBpz3HFxPyGSt2QuG1ux1el1Vvw5PEJEewGHAK6q6OOxYBe70Xn7P59xTol77fVb5QB8ROZKG2QnkNbCsMfvEAhxjWlb1PJyjJXL+TbXweTjjvccPwysQkTQRuUdE1uOCgR243pdbvSLh67JMx32ZXBiWdjauN+nJsLSDvMenvLrCf6q/DLvV8b4G43oCfuZz/HbcMJDf8at80nYBOWGv98cFJd/4lF3uk1afDapaHpW203vMiS7sQ3HvtTYBYG1UWvWt5Kt9yu9pwHmrg4l59V6d87VP2gHe4xKfvCVRZar5vRe/z+p3uJ6hT0Rkgzd/5wcikljL9QnuczSm2dgcHGNa1ge4uQrjcXNuquffVJsBTBGRVK9MABf0hHsBmAQ8jBty2YkbAjoVN5ck+IeLqlaIyHPAFSKyv6quxgU7O3HBT7XqL+xrccMgfjbW8b6qj38SN7Thx6/Ho8onLby+6OdNobZzNvRc24GkqLlS4dSnR6W+c9d33ur8hgYFfp91Xeeord663ouEFfpERPrjegInAMcCPwSWiMjRqron6ths3OdoTLOxAMeYljUbKMV9CezF9cB8EZY/A/fvcjxugu98DVtIzhuOOhH4p6r+Irxiv7uPPE/iJrn+SESeBMYCf1PVirAy1UM9har67j68r5W4L8nEfTy+LqtxX5j9qTkkNdCnfHP3DFT3aB0IzG/mc1Wr7qkaiX8vUENU94Ad7JM3xHv061FrEFUtwE1SfwlA3GKL9wEXE3kXV2egF6FhO2OahQ1RGdOCVLUMF+QcCpwCzI4aLlmM6135LdCFmuvfVPcARPw1LiK9cAvc+Z1zDrAU+BGu90aIHJ4CN89mJ3C9+Gw9ICKdpY61VFR1K/A2cHb0LcTe8SL7vu7J697jtVF1noZ/gFNI5DBdU/vQezy8Gc8R7T+4IaDJfu3g3WlWJ1XdjLvz6wwRqR6SrD72eu/lK/tyceK/yvZc7zE7Kv1QXBA/A2OakfXgGNPyPsD14ByJu702SFVVRD4GzggrG56/R0TeA34sImXAl7g7bC7H/YU+upZzPgn8GXfr9FIv6Amvt1BELsTdhr1cRJ7A9cpk4ebXfB8XkM2s4339zMufKSJP4eaLJODm0JyBu3X89jqOr8003K3hl3tB0vu43pxLccNpB0WV/xSYJCIPeM+rgHe16VaC/hw3L+Uk3DBhs1PVtSLya9zdWIu8z3cd0Bv32V5AqGepLlfjfqdmisjfcbeJnwZ8F3hKVfc16Fjh/d5+jrulvCdwGe5urhejyp6MuyPstX08lzENYgGOMS0vPGjx+0KZgfvSqsK/G/88XLByBm5NlRW4SZ5C7QHO07g7ZdJxE4lrUNU3vN6X3+F6e3Jxk2NX4tap8ZucGn78WhEZ5R1/Gq63qBi3bsureEMXjeUFfWfg1uw5F/cFOR93J9ivgH5Rh9ztpZ0LXIH7XMZSd3DWmOsJiMgjuN6U3CYMnOo77wMisgIXpP4St1jeJlzwV9f8qPA6PhORo4BbcMOWKbjA+LfUvFuqMe7CDZ3+ErcG0Vbcmkh3qmpwTpfXW3Q+MFVVbQ6OaVYSdoemMca0KyKyFAio6tAWPm8mLrD8m6pObslzt2ciciauR2dEeOBjTHOwOTjGmDbPm5ganXY6bnjqnZpHNC/vrqBbgF/5zVkyNXm9NzfjJshbcGOanfXgGGPaPBH5CzAMN7y3F7cC8MW4IbQRqrqpFS/PGNMGWYBjjGnzxG1I+X+4HpsM3GKA7wJ/UNV9vrXZGBO7LMAxxhhjTMyxOTjGGGOMiTkW4BhjjDEm5liAY4wxxpiYYwGOMcYYY2KOBTjGGGOMiTn/D1FAnySN683lAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Apply a 5 pixel boxcar smoothing to the spectrum\n", "spec_bsmooth = box_smooth(spec, width = 5) \n", @@ -867,7 +1084,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -884,7 +1101,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -898,19 +1115,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameters of best-fitting model:\n", - "T1 = 2361.46 +/- 20.80\n", - "nchi2 828.47\n" - ] - } - ], + "outputs": [], "source": [ "# fit BB to the data\n", "def phot_fn(wa, T1, A):\n", @@ -941,34 +1148,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAEYCAYAAABRMYxdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3hUVfrA8e87qSQktIQOUiT0Ll0EaXZFXXV/9q5rX9dd69rbWlbXhrquitgrWEEBQenSa+idUEJIIb2c3x/3zmRmMullZpL38zx5MnPuuXfODEPmnXPec44YY1BKKaWUqk8c/m6AUkoppVRN0wBHKaWUUvWOBjhKKaWUqnc0wFFKKaVUvaMBjlJKKaXqHQ1wlFJKKVXvaICjlAoaIvKoiBgR6VQb9Uu5xtX2NcZWsP48EdlV1cerqIo+TmXbXxNq6zFFJEpEXhGRPSJS6Hz+dfWaq+CiAY5q8ESki4i8LSKJIpIlIsdEZKOITBWRU/3dPnciMtb+0G7q77YECn1NGpR7gduBz4CrgbtKq2gHWaUeV/VfqL8boJQ/ichJwHwgH/gA2AA0AhKAc4AM4Fe/NbCkscAjwPtAql9b4h9PAs8CuW5lY2nYr0lDMhFYZ4z5u1f5JEC8yq4GOgEv136zVCDSAEc1dI8AUcBAY8xq9wMichvQ2i+tqiEiEgaEGGNy/N2WmmCMKQAK/N0O5TetgT3ehcaYPD+0RQU4HaJSDV034Kh3cANgjCkyxhxwL7PzCt4XkQkissQe0jooIv8RkWjva4hIExH5l4hsE5FcETkiIp+ISBcfdcNF5B8istq+bpqILLcDLUTkfayADGCn3RYjIo/ax535Jr1F5N8isg/IAYaLSCf3ul6PWyJPxX6ORkRa2LeTRSRDRKaLSGu7zo0isklEcuzhvfPKe7FF5ARf7RCRn+3yu7zKl4rIxtLaWt5r4iZCRJ4WkX32v8MaETmzvPZ6CbUff7d9jbUi8ueKnCgiQ+3XcYv9b5shIgtF5PxS6re2c0122I91WER+EZGJ5TxOCxFZbL93xle1/SIy2W7fcftnYWn/viJyvf3vn2u/z+/EqzdFRO62/10m+Dg/QkRSRGROGc/rahExQGdgjI/3vkcOjn17DHCCW906zUNS/qc9OKqh2w50F5ELjDFfV/CcQcCfgP9iDWudCtwB9BGRicaYIrCCG2AR0BF4F2v4qw1wC7BURE4yxuy264YDs7CGW34GPsQKTvoCFwCvAW8BscD5wF+BZLs9a73a9xGQDbwIGCCpgs/Ll5nAPuBh4ET7eX4jIl8DNwL/s9t5B/CliCQYY3aWdjFjzG4R2QmMBx4F13MfBRTZ5S/b5bHAYODNMtpX0ddkKtYw5AtAOFbuxnS7vbvKexFs/wKigSlYr+s1wCciEmmMeb+cc88HegCfA7uBFsBVwNcicpkx5mNnRTt4Wwi0wnp/LbcfdzgwAfjF1wPY580CYoAxPoL2CrVfRG4BXgcSsYYEDdZwz3QRuckY87Zb3buAl4A1wANYvaF/Bw57PfZU4GngOmC2j9emGdZ7qTS/AVfYj5UMPGWXe/87O90FPAPEYb0vnDaV8RiqvjHG6I/+NNgfYASQh/VHfAtWIPIXoGcp9Y39M9mr/D92+Z+9yrKB/l51TwDSgffdyv5hn/+0j8d0uN1+1K7XyUc957F5QKjXsU72sUfLOK+TW9n7dtnrXnX/bZfvAWLdyvvZ5c9U4DV/x37No+37p9jnTrNfl1C7/By7/IJy2lqR1+R7QNzKh1SivVfbdXcDTdzKm9hlKUAjt/J5wC6va0T7uG4UsBnY6FX+o/14p5XzXnA9DjAAK5BN9H4dKtN+rEDjOLDN6983FuvLQAbQ1C5rCmQCG4Eot7rt7WsYYKxb+cdYwXBzr/b9YrchsgL/FruAeT7Kfb3mJcr0p2H96BCVatCMMYuxegmmYv3BvwZ4A9goIr+Lj6EkYLMxZrpX2bP27/MBRESAy7C+ee4XkTjnD9aHwhKsxEiny4BjwOM+2lhUyaf1srFyVWqCd4Lm7/bvD4wx6c5CY8xarOCkWwWuORcIA06274/D+sb/H6zehyF2+alYvTrzqtJwL/8xxvrUs9v7B9aHdUXa6zTFGJPmdo00rN6lZlg9b6UyxmQ6b4s11bkFVoAzF+hp91YhIs2B04GZxphZPq5T4r1gD/v8hvXhP8qU3iNVkfZPxOrlecXr3zcdeBVojNWLBNb7NworCM5yq7sPqxfR29tABNZ73dn2Tli9dh+ZepInpgKHBjiqwTPGrDPGXG2MaYXV03EV1gf5ycAMewjFXYlubmNMEtYMHmdAFI81DDEJOOLjZyLWEIRTNyCxhv7Ib6mBazjt8Lp/zP7taxjqGNZzLs9c+/c4t9+/Aivta7iXrzHGpFS4taXzfh5g9RpUpL1OvoY3nPlBvgJhFxFpKdZSBIewAtxkrPfBzXYV5xT3E7HyV1ZVsE2tsHp8dgDjjTFHy6hbkfZ3tn9v8FF3vVdd5+/EMq7rYoyZh/XevM6t+Bqs5/uOzxYrVQ0a4Cjlxhiz2xjzAVaC4kKgDzDUu1opp4uP27OxghlfP6dV8LqVleWjrKxrl5qLZ4wpLOVQaeXeU3V9XfMg1oftOBGJAoYBc+3eifnAeLuHox/FwVB1Vbm9bny9huWeb/fm/YwVOH8AXILVSzMRa9gGiv8WO69X0fdCClbeTT/cekZKUZH2V+b1KKutpV3nv0B/ERksIg6s4bPlxpg1lXhcpSpEAxylfLCHM5bad9t5He7lXV9E2mANcTl7Co5g9ejEGmNml/bjdoktWEMVEeU1rdJPxuLsBWnu41iZvQ+1ZC5WsvY5WEm/zhk0c4CRwBlYH5IVCXBqKjAsT4l/d6Cn/dtXD5FTP6A/8Kwx5u/GmM+NMbPsf/8Qr7pbsZ7PwAq2KR8rCX068JadIFyairR/u/27dxnne9ft6aOurzKwcrvysHpxJmIl4JeVXFwddfW+UAFKAxzVoInIRBEp0YMhIo0ozpHx7m7vLiKTvcrutX9PB1euxEfAUBH5UymP3dLt7kdYuRAP+ajn/m34uP3bV6BSKmNMBnAQq9fEdT07x8j7udSFuVh/fx4B9hhjtruVRwD3Y61387vv0z1U6TWpgr/YM+MA1yy5m7EC2fllnOfsPfKeOt0HO2fLyR6O+wk4o5Qp1SV6Rowx+cDFwJfA6/Y07aq2/xesIbTbRSTGrW4M1grCxymexfULVhL9rXZPnLNue+BSXw0wxiRj/R+5FLgNq7fxY191a8BxoJmv10w1DDpNXDV0LwEtRORbYB3WH9wOWH+AE7CSadd5nbMO+FBE/ov1jftUrGnj87GWkHd6EGv68+ci8jlWYnEe1iyqM4EVWF30YCXYngM8JCJDsIY0crC+SXenOLFzif37XyLykV1nvTHGmR9Rltewpv3+JCLTgbZYH3DrKU7srSu/YiUQ98T6Vg+AMWajiBzE6i1YbAdm5anOa1IZyVjT+9/FClauweqBuN49ydaHTVg5Lf+wA4HNWO+tm7Be+0Fe9W/DWl7gJxGZivU+aYQ1lLeL4mDaxRhTICL/h9Wj87KIhBpjXqxs+40xqSLyD6xp4kvFWmcIrPfpicBNzkRlY8wxEfkn1tT7RSLyAVbS8c1Y/y9K64V6GysgOxuY6p7MXMOW2I/xmogswgo05xpjvKewq/rK39O49Ed//PmD1UvzOtY6HslYvQZHsT6Ar8VtWq5d32B9IE/AGsLKBg5hzTCJ8XH9KOCfWEFRNtbMnU1YuQjDvOpGYgVFG7A+pFOBP4BbvOr9A2uYIB+3qd+UMV3aPh4KPIc1nTgHK6n3HF/n2c/R+LjGWLvu1T6O7cLHFN4yXvsV9rWu8Cr/yC5/0sc5Pp9jVV6TiraX4mnWE4DHsKbI52IFJ5f6qD+PklOWTwC+wBq6zAKWYfXelPZ82mHNcNqDFRQfwgp6x5fzOA6Kp/jfX5X22+ecjxVkZdo/i/BaGsGt7k1YQVsu1vTyu7CCJ49p4m71heKhuNGV/P/q89+slNciGmv46xBWcOOzPfpTf3/EfiMopSrAXk11qjHman+3RalgJSIbsLYQ6eHvtqj6S3NwlFJK1RkRGYc1BPl2eXWVqg7NwVFKKVXr7MCmK1YC+RGsYVqlao0GOEopperCw1iLZ24ErjIVSyBXqso0B6eC7NwLpZRSSgUYY0yJ5QA0B0cppZRS9Y4OUVWS9ngppZRSgaGsdRy1B0cppZRS9Y4GOEoppZSqdzTAUUoppVS9owGOUkoppeodDXCUUkopVe9ogKOUUkqpekcDHBW0flqXxN8+X0NWXoG/m6KUUirA6Do4Kig9+f1G3lmwE4BG4Q6enNzXzy1SSikVSLQHRwUlZ3ADMGP1AT+2RCml6qennnqK3r17069fPwYMGMDSpUv93aRK0R4cFXQ2HEjzuJ+RU8CP65IY2LEpbZo08lOrlFKq/li8eDHff/89K1euJCIiguTkZPLy8qp1zYKCAkJD6y7s0B4cFXTOemVBibJbPlrJpH//5ofWKKVU/ZOUlERcXBwREREAxMXF0bZtW+bMmcPAgQPp27cv1157Lbm5uQB06tSJ5ORkAJYvX87YsWMBePTRR7nxxhuZNGkSV155JYWFhdxzzz307duXfv368eqrrwKwYsUKxowZw+DBgznttNNISkqq9nPQHhwVVLLzCks9lpGrycZKqfql030/1Mp1dz17VpnHJ02axOOPP05CQgITJkzgkksuYdiwYVx99dXMmTOHhIQErrzySqZMmcJdd91V5rVWrFjBggULaNSoEVOmTGHnzp2sWrWK0NBQUlJSyM/P5/bbb2fGjBnEx8fz2Wef8eCDD/Luu+9W6zlqD44KKi/P2eLvJiilVL3XuHFjVqxYwdtvv018fDyXXHIJb731Fp07dyYhIQGAq666it9+K7/n/Nxzz6VRIyt9YPbs2dx8882uoarmzZuzefNm1q9fz8SJExkwYABPPvkk+/btq/Zz0B4cFVTemr/D301QSqk6U15PS20KCQlh7NixjB07lr59+zJ16tRS64aGhlJUVARATk6Ox7Ho6GjXbWNMiR3AjTH07t2bxYsX12DrtQdHBRFjTLl1Pli8q9bboZRS9d3mzZvZunWr6/7q1atp1aoVu3btYtu2bQBMmzaNMWPGAFYOzooVKwD46quvSr3upEmTePPNNykosFIKUlJS6N69O0eOHHEFOPn5+WzYsKHaz0EDHBU0UjKLM/jHJMTTOS6a9s08Z009PKP6/ymUUqqhO378OFdddRW9evWiX79+bNy4kWeffZb33nuPiy66iL59++JwOLj55psBeOSRR7jzzjsZPXo0ISEhpV73+uuvp2PHjvTr14/+/fvz8ccfEx4ezpdffsm9995L//79GTBgAIsWLar2c5CKfCtWICIGKtaLoGrHruRMxr4wD4AHz+zJDad0Ib+wiKd/3MR7C3e56q1+eCKFRYYWjSP801CllFJ1wjncZYwR72Pag6OCRnpOvuu2wQo0w0IcPHx2L6LDi78xDHj8FwY/OZu07PwS11BKKdUwaICjgsbxnOJp4O4daSLC+sdOK1F/2+GMumiWUkqpAKQBjgoacxIPu26f2qOlxzER4dTu8R5l9361rk7apZRSKvBogKOCxqo9xwAY3S2OhFYxJY6f3a+tx/1th49z0ZuLNG9KKaUaIA1wVNDIzrfWWPj7ad19Hj93QFteu3QgJ7Zs7Cr7Y9cxftuazK7kzDppo1JKqcCgAY4KCimZeWxKSgegeXS4zzphIQ7O7teWwR2beZRf9e4yxr4wj8Ii7clRSqmGQgMcFRQWbU923Y5tFFZm3bFeuThOx3WvKqWUqpCQkBAGDBhA//79GTRokGtdml27dtGoUSPXsZEjR7J582Y/t9Y3DXBUUHDvfYmJKHuHkdP7tObik9qXKM/K0wBHKaUqolGjRqxevZo1a9bwzDPPcP/997uOde3a1XXsqquu4umnn/ZjS0unAY4KCs5VjK8ccUKJfUy8iQhPnd+3RHlWGTuRK6WU8i09PZ1mzZpV+pi/6WabKigcy7IW7Wsa5Tv/xltYiINNj59Oz4dnuspW7j5G1/jGZZyllFIB5tEmtXTdtDIPZ2dnM2DAAHJyckhKSmLu3LmuY9u3b2fAgAFkZGSQlZXF0qVLa6eN1aQ9OCoopGVZPThNy8m/cdco3HM/lB/WJVGkicZKKVUu5xBVYmIiM2fO5Morr3QtueEcotq+fTsvv/wyN954o59b65v24KigkHzcCnCaRVc8wPE2b/MRujzwIwA7nj4Th6PsoS6llPK7cnpa6sKIESNITk7myJEjJY6de+65XHPNNX5oVfm0B0cFhX3HsgDo2DyqUuf1b++7e/fI8dxqt0kppRqCxMRECgsLadGiRYljCxYsoGvXrn5oVfm0B0cFBWcPTnzjyEqd99IlA/jTm4tdScpOufaigUoppUpy5uAAGGOYOnUqISHWsL8zB8cYQ3h4OO+8844/m1oqDXBUwDPGcCTD6nGJi6lYkrFTl/jGPDW5D3/5aKVHeXa+zqhSSqnSFBb6/hvZqVMnsrOz67g1VaNDVCrgpWXnk1do9bhEhVc+Jm8SVTJvR9fEUUqp+k0DHBXwFmxLLr9SGU46oXmJsvPfWMRzMxOrdV2llFKBSwMcFfD2HbO6Q2MjqzaiGh7q4MEze5Yof2Pedt1pXCml6ikNcFTAO5SeA8Bt406s8jVuOKUL5w9sV6I8R5ONlVKqXtIARwW89GwrX6Zpo8olGHt74aL+nNm3tUeZbsCplFL1kwY4KuClZVvbNJS3i3h5QhxC77ae6+JkaoCjlFL1kgY4KuCl2wFOk2oGOADXj+7scV97cJRSqn7SAEcFvLQaDHAiQj33pzqWlVdKzYYjIyef/ELPXCRjDNOW7GblnmN+apVSSlWPBjj+lp0KWSn+bkXAKioybD6UAUBso5pfl/KK/y1r0BtwHs7IYfjTc/jLh54LIa7ck8o/p6/ngjcW+allSilVPRrg+NO+5TBlJHx3J+h0ZZ92Hs103W4RHVErj/HB4l21ct1Al5qVx9Cn5pCZV8jsTYc8ju1PDY6VSpVSqjQa4PhTdDzkpMGmb2HdF/5uTUA6YH/QRoY5aBQeUk7tqnlv0a5auW6ge23uNo/7eQXFw1QFhTp9XikV3DTA8admJ8Dpz1i3f34I8jLLrt8AORf5O7Nvmxq75ic3DPe4H+qQGrt2MFi64yhvzt/OOwt2epTPWL3fdds92NHFEJVSwUgDHH8beAW0GwzHD8Hi113FM9cf5II3FpKU1rCHCrYdPg5A1/jGNXbNEV1b8P3tJ7vuj+vRssauHeiMMVzy9hKe/ankNhVLdxbngmXmFW+0l1tQxM7kTNbvT6uTNiqlVE3QAMffRGDCY9btxa9DXib5hUXc/OEKVu5JZcKL8/3bPj9zzqCKb1yz+Td92jXhT4PbAw1rNWPn6+mLM4AxxvDE9xtd5dl5hVz81mLOfnUB6Tmln6+UUoFEA5xA0Hk0tB8KOamw6iOe+mGT65D7N+mGKCffev6RtZB/M6yztQlnQ1rsb09KVokyZ2/WjuRMZm04yJvzd3gcT0rL4UhGLgCPfruh9huplFI1QAOcQDHyduv34tf4YJHnB0xDXozOFeCE1vxbtXGENe3861X72XggvcavH4h2Hy0OcM7o05pdz55F99YxgJV3c9O0FfzLa5f1Z93uf71yP0opFQw0wAkUPc6CZp0gdTdjHGs8Dt316Wr/tCkAZNsBTm3MoGrstjv5ma/8XuPXDyRpWfmkZOa5enD+b2gHXv2/gQCEhThcwZ4vv2054nFfk46VUsFAA5xA4QiBQVcB8H8hcz0Ozd50qMF+qDjzYxqF1XyAE13Gh3p9Yoxh8hsLGf/iPLbYiyb2ahNLaEjxf//YyJKvxRXDT/B5vSx72NQYw7M/JfLewp0+6ymllD8FVIAjIveLyBciskNEjIjsKqd+dxGZLiLHRCRTRH4XkXGl1HWIyF9FJFFEckRkr4i8KCLRtfJkqmLAZRRJKOMcq4jHc4n8lMyGuaVAtv1hGlkLAY53r8XO5Po3TX/P0Sz+/PYSdiZnciwrnxmrDwDQvnmUR72YyJLbYFw1spPPa9739ToANial8+b87Tz23cYGvRq0UiowBVSAAzwNjAO2A2VugiMiXYFFwAjgOeDvQGNglohM8HHKS8C/gY3A7cAXwB3AdyLi99chr6CIv8zYx/KIYYRKEReF/OZxPD2nYebh5BTUXoDTvlkjj/v/9/YSHpq+rsYfx1+MMZzz2gKP6d9OHZp5BjjuQ4CnJMQz529j6OgVBDl9t8YKkg6n57rKMvMa5vtTKRW4/P7B7qWrMaaFMWYicKCcus8ATYHTjDHPGGPeAEbb570uIq7V20SkN1ZQ87Ux5gJjzH+NMXcDdwOnAn+ujSdTGdNX7+en9Qd5I30UABeHzAOKvxU7k20bmpy82svBiQr37ME5mJ7Dh0v21IukbmMMj3+/sdRp4d7BXUFR8VT5D64dStf4xoSHOkrd4HTg4z/z8bI9rvtZDXy2n1Iq8ARUgGOM2VF+LbCHlc4F5hljXBm4xpjjwDtAAjDE7ZT/AwR42etS/wWygMur0ewakWH30PxW1I9DpimdHIcYKMVL6T80fb2/muZX2bU4i6rUx6wHH9aLth/lvYW7Sj3u3SNW2lpApeU+HcvK55eNxftX1YegUClVvwRUgFMJ/YAIYLGPY0vs3+4BzhCgCFjmXtEYkwOs9qrrF84chiIcfFs4EoDzQha6jq/YfaxBJhq7koxraR8qX8MwuQXBHeAUFRl+Wp/kUfbx9cPKPKdNk0if5aEhxdtYPHRWz1LPrw9BoVKqfgnWAKet/dvXohzOsnZe9ZONMbml1I8TkXBfDyQiN4rI8iq3tIIK3YKX6YXWMNXZIUsIpfibcXp2w/qWbIxx68GpnQDn/WtKxrbBvLLxte//wejnfiUpNcdVdtHg9ow8MY7R3eIA3zOmTu/TGoDHzu3tUR7uNtPqihG+Z1WBDlEppQJPsAY4zq/dvgKWHK86ztu+6pZW38UY87Yx5qRKt7CCjucWsO1wBoVus1A2mE5sK2pLnKRzsqM46TU5s7SnUD/l2hs+hoc6cNTShphd4htz3cmdPcq+WLG3Vh6rthUVGeYmHmZ/ajZzEg8DcM+kBJ6/qD8Af52YQM82sbx1Rcm386VDO7LsgfElZk659+BEhIbwt4kJPh/7qR828s7vOzickePzuFJK1bVgDXCcy7H62qAo0quO83Zpmxn5ql9nxr0wjwn//o21+1LdSsXVizPZbZgqNath7QNUm6sYu/vH6d097r81f4dHwBksvBOKu8RHc9u4bq77gzo246c7RzOia4sS54oILWNLDlM5xDOwvH18N4Z2al6i3pp9aTz5wybO/M8CUrMa5pIGSqnAEqwBjnOGVTsfx5xl7sNXB7CGoXwFOe2whq/88lf5sL3Hz6JtRz3KZxRZeThnhq4kyu5kWrM3lYbEuepubU+Rj/Ax/NX9oZ94efaWWn3cmmSMYX+q587z3VvFVPu6d02wemzcF/37/OYRzP/72BJ1mzQKI/l4Lqe+MI+9Pva8UkqpuhSsAc46rCGnET6ODbd/u+fN/IH1XIe6VxSRSGCAV12/yPCahbLXtIIOwwg3OUxyWM176sdNvk6ttw54fWDXpYIiw8uzt/rt8Stj4bZkOt//I2e/usCjvEMp69hUxmm9WzHzrtElcnPaNi2eZv7chf2Yceso/nulNfR1LCu/zBlcSilVF4IywLGng38HjBWR/s5yEWkMXA9sxXPG1GdYi8rc5XWpG7Bybz6q1QaXotzZOn0vAuDckEUAQTlsUh3Hc63XZ1yPln5uSWB7zmtzTKdmUT7z5itFROjROrZEDlRYiIOF941jyf3juXhIB/p3aMrQzs256ZQuAKw/kFbtx1ZKqeoIqM14ROQKwNkXHg+Ei8hD9v3dxphpbtXvB8YDP4vIS0A6VsDSDjjLuM2pNsasE5HXgdtE5GvgR6An1krG84GPa/FplarcrQF6n0/RT/dyimMtzUknhdi6aViASLdzSkpbUVdZNiaV3Al9SKdmXDqsY60+brumjUqUXXdyZ976bQeJSekYYxCpneRwpZQqT6D14FwHPGH/tMRaqdh5/zr3isaYbcAorHVv7gNeADKB040xs3xc+y7gHqA38DrW6sWvAmcbY/wyL1go/Y9/8+hwiI6jqPOphEoRZ4YsBeBgWsOZpZKeYwU4MT6mNde0+JjSctAD18G0HG6etoL8Qs+evQEdmvLFzSNLXYW4NsXHRNAsKoz0nAJXDpVSSvlDQPXgGGPGVrL+JuC8CtYtBF60fwJCWV9u2za1ZrSE9r8YdszmnJDFfFg4kYPpObQuZVG2+sa5unOsj40ga9oXN43g65X7WL0vjd+2HHGVFxYZQmppinp1PfbdBmZuOFii/JFzevmhNRYRYVDHZsxJPMxZryzgplO60DQ6nOZR4TSODGVMQrzf2qaUaliqFOCISAJWT0hLrNyWI8B6Y0xwZGUGkx5nkmPCGOZIpC3JDWrFWOcQVWyj2o/DO8VFc/ek7uxMzuTUF+a5yhduS+aUAPxQXrLjKD+t9wxuOsdFc/fEBAZ2bOanVln+OjGBOYmHOZ5bwIu/FM9EC3EIi+8b53M6ulJK1bQKD1GJSE8R+Y+IHAA2AV8CU4A37duJInJARF4WkdLXdFcuFeoXiIhhd9wYAM4JWcyqvWVusl6vOIeo6qIHx6lzXHS5dWas3s/DM9ZTUOi/FY/v+2ptibI3LhvEOf3b+qhdt/q0a8L1XosngtUbtnB7sh9apJRqiMoNcESkq4h8CazHyoNZAzwGXAmcCZxl337cPnY9sF5EvhCRLrXV8PqgrCEq9xkwoQMuBuC8kEU8N3NzbTcrYDi3poit41ySZlHFj+e+ki9YQdedn67mg8W7+XF9yeGhumCMYdfRkvkt4XW4IWl5/japO09M7sOsu07h7H5tXInii7cfLedMpZSqGRXp+9+Ite7M1cDXxpgyp/7YO33/CWuG0kaKV+61nroAACAASURBVApWlfD0+X1dt7M6jiXNRNHLsZsTZZ8fW1W3/NGDA7DovvFc/NZi1u1PY9WeVEZ2tfZwOpyRw9Cn5rjqLd6ezLl+6DFJyfS9JmUgZQo1Cg9xLQ742qWDWLcvjXNeW8CCrck6u0opVScq8pXvYmPMScaYaeUFNwDGmExjzFRjzGDgkuo3sT7z/Uf+kXN6eSzS1jQmhp8KrTUKnWviNASuAKcOcnDcNQoPcSVyPz9rM3vs3pKnfvBcaDHxYEadtsspycdMur7tmgT0dPpebWOJaxzOgbQc7vlibYNb00kpVffKDXCMMTOqevHqnNsQlPYl1nuooUPzKGYUWXtTnedYRFZuw9iTyjVEVcc9OOD5b3DK87/yw9okVuz2zH9avz+N47l1v8P71EW7PO7//NdT+Pa2UYSGBM4QlbcQh/DSJQNoFBbCVyv3MW3xLn83SSlVzwXuX8QGoLRO+hAfkc/Sop4cMk05wXGYF9/zy7qEdaqoyJBh9+A0roN1cLxFeAWZt368kn3HireO6N02lvxCw/zNR7xPrTWZuQVcOGURX6ywhilHd4vjq7+MJKFVTFAM+YzuFs9LlwwA4NmZiSU2B1VKqZpU6QBHRLaIyL0i0ro2GqQoMf0XoAgH3xVaW291OjizrptU5zLzCigyEBUeQpgfeiaOl7HB57e3jWJ8z1YAXrvA165nftrk0Ys0qGMzBp/g3ynhlXV6n9YM7dScnPwiFm7TGVVKqdpTlU+OfOAZYI+ITBeRs0VEe4JqUKqPb7Z3ju/Gt4XWDuNnyyIoqt/r4dTlIn++/LzxkM/yLnHR9GvflP7tmwCUGLaqTZ8vrx8J5kM6W0HZxgMlt5hQSqmaUunAxBjTGxgJTAVOBWYAe0XkKRHpWsPtq9dKS7P0tXDuXRO6sdZ0YWdRK5qZVAp3/FarbfM3fyUY+9KzTfEeYJ/dZPWiDencnPBQB8t3H2P30XJz76stLSufvALPdXdGdm1R649bG5yvp689tJRSqqZUqefFGLPEGHMD0AZr3ZudWJtfbhGRuSJyqYgE3+Y+dcxtP1APkwe0K1EmItwzqTvf2snGRxZ9WKtt8zd/JhgDrh4agHevPomXLunPmkcmufasio0M4yR7eGjroeO13p4dyZ6PcfOYrgzrEtwBTqIGOEqpWlStoSVjTJYx5j1jzMlAD+BTYCwwDTggIi+JSO1uaRzESolv6N+hqc/yplHhfGvn4cTtnQX59XfjzeJtGvwT4Dx+Xh/X7daxkZw/sH2JzSudu2kfOZ5bq20xxnD+G57LA0zs1bJWH7M2dWoRTUSogwNpOZporJSqNdXOnRGREBE5H/g31ro3BvgVa5fv24FNIlKhDTEbmsquBNI8Opztph3rijoRmp8B236plXYFguJF/vwzRNWnXROGdW7OFcNPKHWGUpzdm5OcUbsBzqF0z+tfM6oTAzoEV3KxuxCH0K1VYwC2HPLPWkJKqfqvygGOiPQQkeeB/cBXwEnAC0CCMWaCMeYsrF6dzcBzNdHY+iY6wveHd2kTfk/rbU1ccyYbs+6LWmhVYPB3D06IQ/jsphE8MblPqXXiGtsBTi334BzOKO6pu+SkDjxyTu+A3eG8orq3soep/LRYolKq/qvKNPFrRWQhsAG4G2v/qYuA9saY+4wx2511jTHbgFcATT72wTnE4c2Z5+HN+aH2XeEIiozA5pmQUz/zGNLtWVQxfurBqYi4xtZ+YVMX7y6RAFyT3NffCYLlbiqkR+sYADYfrJ/vX6WU/1WlB+cdoDPwLNDVGHOaMeYrY0xpC4dsxMrJURXw5uWDaVtK4APw3jVDOEgLlpkeUJgLiT/UYevqjqsHx09JxhXRvlnxv9Mrc7bW2uOs359Wa9f2l+52gJOY5LsH53B6Dh8v3cPRWu4dU0rVX1UJcC4EOhhjHjTG7CqvsjFmmTHmmio8ToN0ep+y108c2bUFDqn/w1TF08QDN8AZ1LE4D+a1X7exM7l2pou/Mc/VKUrjUoY1g02/9k1wCKzZl8rx3AKMMa79qfanZnPbJ6t44Jt13PvVWj+3VCkVrCr919IY801tNKShev+aIRxOz+WUhPhSh6bcRYSGEBEawo/5Q3kqfCqyYx4cPwyNg3dWjS/+XuivIkSEly7pz18/WwPAvV+t5XN7nZya4r6QYKvYCP4ytn6M9jaNCmdQx2Ys332Ml3/ZwvoDaWw7nMm4HvEeCxrO3nSY3IJCIkJD/NhapVQwqlCAIyJ3V/K6hUAqsM4Ys7LSrWpAxnavfGDSonE4+47FsK3JMLqlLoQN02HYjbXQOv9JzbJ6cAI5BwesNYucAc6ynSms2H2sRrdPWLYzxXV7yf3jg2LPqYr626TuXPG/pbyzYKerzNdqzev3pzH4hOZ12TSlVD1Q0U+PF6p4fSMiK4FzjTFJVbyG8jK0U3P2HdvPq4cH8kr4QmuYqh4FOMYY18J27nkugUhEmHrtUK56dxkAT/6wkW9uGVVj11+339rr6rk/9atXwQ3AiK4t+OvEBJ6ftdmj/NJhHekSF82qPan8sC6JZTuPaYCjlKq0igY4p1byugLEAiOwZlq9CFxayWuoUvxpcHu+XrWfX4oGURQWhWPfMkjeBnEn+rtpNeJwRi6H0nOJjQylU4tofzenXD3thFmAVXtS+WrFPi4c3L7a1z2WmceP66yNVweWsvhjsLvxlC4cTMvhj10pbDt8nFaxkdx/Rg9iIsP4ZtU+fliXxNKdR+vN0JxSqu5UKMAxxsyv4vW/FZFw4Koqnq98OKmT9W02m0gOtDuD9ru+glXTYOJjfm5ZzThiL5zXrlkUjiBY76VlbCQf3zCMS/+7FIC/fbGGTnFR/GvmZp67sB+d4iofpOUXFjHy2bmu+13jG9dYewNJWIjDtdZQfmERRca48m1GdY0DYOmOFIqKTFC8F5RSgaMudgFfXkeP02CEhzq4asQJAMxvfLpVuPpjKKwfy947l+9vEgAbbVbUyK5xnNo93nX/wimLWbYzhds/WVWl6324ZDfZ+cU7xjeED/ewEIdHMnHL2EjiGkeQnV/IgTRrLaCiosqu/62UaqjKDTxEZHxVLy4iE4wxnxhjdAC9hg22e3EeXB4Fcd0h8zBs/dnPraoZaUGwBo4v/7qwX4myfceyqnStx77b6Lr9nz8PqHKbgt2JLa3er62HjzNtyW66PPAjF05ZVOpGtUop5VSRnpWZ9g7hZ4tIuXM1RSRMRM4XkfnAj9VvovJleGdnzCgUDLjMurnyA7+1pyYV9+AEV4DTMjaSy4Z57i2bV1DEsp0pvDFvGymZeaWem5KZx71frmX13tQSx7q1jPFxRsNwYktraO6a9/7gn9PXA9bU+b0p2WWdppRSFQpwBgIFwLdAkoh8JCJ32gHPSBEZJSLniMjdIvI5kAR8CWQBDferZy1rGRtJqD1scajT+eAIs3pw0g/4uWXVF6wBDkCH5lEe9zPzCrn4rcU8N3Mzg574xWNfKXcPfL2Oz5bvZfLrC0sEOc4tIRqi0nKPktI0wFFKla3cAMcYs94YMwkYBcwCzgFeAmYAvwO/AdOxppJPwgqEhhtjzjDGbPR9VVUT+rZvAsCBgsbQ/QwwRVYuTpAL5gBnQDmzna56948SZb9vPcLMDQdd9x/8Zp3H8RaNy18Asr5yXy36gkHt6NvOes8fTPcdKCqllFOFsziNMYuBxfYw1WCgFxAPGOAIsB5YZYypvV0HlYc2TSJZhbUQ2pBBV8Gmb63ZVCffDY7gzes+Zg/lNI0Ovp6L4V1a8Os9Y2nbNJLuD80scXxTUjrGGI81bWa5BTcAGw5YG1D2bdeEv4ztGvQ7h1dH/w5N+eWvp9CkURgtYyN57LsNrNufxiENcJRS5aj0p6AxptDeX+p9Y8zzxpgXjDFTjTErNLipW8dzrVk2j323kS9ST4TY9nBsF+z41b8Nq6akNOvDq01spJ9bUjWd46KJCA0hxt43akxCPDufOZPmdsD257eXcDAthw+X7KbTfT/w4ZI9AJzbv63Hdf575Umc2bdN3TY+AHVrFUNL+73Qzt6I9kCqBjhKqbIF79d85REA/P2rDTx/1N6A8493/NSimnHQGeA0Dc4Ax+mO8d1wCNwwugsi4lqsb+nOFIY/M4eH7KRZp2cu6EviE6dzavd47hzfjdZNgvv514a2doCz+2gmSWnZ5BXodyqllG+i0y0rRkQMEFDTUzNy8un7aPHU8BaksbTRHYSaArhzDTQ7wY+tq7q+j84iI6eAlf+c6Or1CFY5+YVEhlmTDx/4Zh0fL93js97v/zi1RIKyKmnP0SzGvPArzv+GpyTE88G1Q/3bKKWU3ziH+40xJcbytQcniMVEhvH2FYNd94/ShHVNTgUMLP+f/xpWDcdzC8jIKSAi1EGzqOBLMvbmDG4ALh92Ar62kzqxZWMNbiqoY4so/jykg+v+b1uOcCBVZ1QppUrSACfITerd2uP+ytYX2zc+gPzg+8PvHJ5q3SSy3m0u2attLDufOYubx1j7KvVpF8t3t53M5zeN8HPLgstdExIY1LF4ttrsTYf82BqlVKDSAKce6OK219GhmN7QdiBkH4P1X/mxVVVz9Li1D1VcPZ4afdeEbsy4dRTf3XYyfds3CfphuLrWKjaSr28ZxYsX9QdKzkJTSinQAKde6O+29srbv++EoTdad5a+BQGUM1QRztV+W9TjD/3IsBD6d2ha73qo6tq4Hi0JCxEWbjvKg9+s4/Vft5F4MN3fzVJKBQgNcOqBM/p4DlPR+wKIagEH18LuRf5pVBUlOwOcBrx6r6qYZtHh/PPsXgB8tHQPz8/azDXv/UF2XmE5ZyqlGoJKBzgi8qiU8dVTRJqLyPTqNUtVxsRerbjS3l28b7smEBYJQ663Di56xY8tq7x9KdbmlC1jdIq0Kt+VIzpx/sB2rvtJaTmc/ervpW6JoZRqOKrSg/Mw8KuItPM+ICJjgDXAGdVtmKo4EWF8z1YANHXOPBp6I4RGwpaZcHiTH1tXOZsOZgDQu22sn1uigsV5AzwXSNx+JJOpi3ZhjOFQeg4FhbpWjlINUVUCnJuBIcAaETkPQEQcIvIEMBtrY84xNddEVRFhIVanmmvhs+g4GHi5dXvRq35qVeWlZllDVPEx9TfJWNWssd1b8vYVg5l3z1heu3QgAHMTj/DwjA0Me3oOl/9vqQY5SjVAVdmq4W1gKNau4V+LyJtYG24+CHwNDDDGLKnRVqpyOddbyXFf2XXErSAOWPt50Owynm5vtBkbhBttKv+Z1Ls1neKimdCzFRGhDjYlpTNtyW4AluxIcd1WSjUcVUoyNsZswOrFWQzcAIwAHjDGXGKMSavB9qkKigq3Axz3BMvmXaDnuVCUD0um+KlllZOeUwBAbKQGOKryIsNCGNq5uet+TKS1H9hj323k7s9W82viYX81TSlVx6oU4IhIOPAcMBLYgTUsdZudg6P8oJHdg5OVX+B5YNQd1u/l70FWSh23qnKKigxprh6cCm90r5SHi07qgEOgQ/NGfHfbyQy0FwX8etV+bpq2gnX70thyKIOc/EIKi4JrGQWlVMVV+lNERBKAT4EBwBTgbqC/XTZbRJ4BHtWdxetWI7sHZ29KNuk5+cU9IO0GQ5dTrR3Gl0yBcQ/6sZVlS87MpbDI0CwqjIjQkPJPUMqHc/u35ey+bXA4rLy0B87syc3TVnA0M4+8wiLOeW2Bq25UeAg///UU2jfTrTKUqm+q0oOzAugEXGiMudUYk2uMWYYV5HwJPATMq7EWqgqJCi+OVa957w/Pg2Pvs34vmRLQvTiH0qxVjFvF6hRxVT3O4AZgSKfmrPjnRFb+c6LHqt8AWXmF/P2LtUx6aT4vzNqMMYZjmXn8uvkw572+kDs/XcXzsxLZceR4XT8FpVQ1VXo3cRFZAFxqjPG5LbKIXAf8xxjTuAbaFzACcTdxd4VFhq4P/OhRtuGx04iOsAOfDyZbvTin/B3GPeSHFpZv9sZDXP/BcsYkxDNVd4hWtSC/sIgiY9ibksUD36xn2U7PgD8sRCgylBi6ahoVxpOT+3BW3za6ArVSAaSmdxMfU1pwYz/I/4DBpR1XtSPEUfKP7oJtycV3Tn3A+r3kzYDtxTmYbm+0qT04qpaEhTiICA3hxJYxfH7TCEZ2beFxPL/Q+MzLSc3K57aPVzF99f4qPe6+Y1m8NX87aVn5VTpfKVV5lc7BMcaUuw66MWZz1ZqjalKe+5TxDkOh63jYPgcWvwbjH/Zfw0px2A5wWjXRAEfVjVf+byCvzd3Gab1bExoiOAQiQkM4lJ5Du2aN2JWcxYguLXh25iY+WbaXr1fuZ3zPVhzPKaBt00YUFhmOZeWVuTlsTn4hl7y1hP2p2RxMz+GRc3rX4TNUquGqSpLx3ApUM8aY8VVoj6qGsBAhv7D42+dvW45wTn+3VV7H3m8FOEvehKE3QUwrP7SydM4enFaxusifqhtxjSN49NySAUefdk0A6NHaWlH7nknd+fSPvfy+NZnhT8/BGPju9lHc/fka1u5L447x3bh7YoLPx1i/P439qdkALHTvVVVK1aqqDFF1ATp7/XQDTgHGAn3sOqqOzbl7rMf9L1bs86zQYQh0PwvyM2HeM3XXsAo6lG4lGesQlQo0LRpH0NMOdrLyCsnOL2TCv39j7T5r2a83523n6PFcn+c6tx8B2Jmc6dmzqpSqNVVZybiTMaaz108HIBprNeNUrPVxVB3r2CKKhFYlc7uL3HMKJjwKEgIrP4AjgTWSeMjVg6MBjgo87gsIessrLOJ9e/8rb5sPprtu5xcath0ue0bWF8v38tO6pKo3VCkFVHGhP1/s6eLPAEuBf9fUdVXlfHrjCI/7248cp8fDM3lt7larID4BBl8FphB+ecQPLSydBjgqkI06Mc51+64J3egSH83fT+vOm5cPAuDVudt47LuNJc5LTLJ6cGLtVZU3JRUHPEcycjn95d94/ddtAOxNyeLvX67lLx+tJLmUHiGnoiLDit0p5OSXmxapVINUYwGOmwXAabVwXVUBzaPDPXJYXp+7jbyCIl74eUtxpbH3Q1g0bPkJdi3wcZW6l5NfyLGsfMJChBbR4f5ujlIljO/RkofO6sn3t5/MXRMSmPu3sdx66omM79mK03u3BuCTZXs8Ag5jDJvtIarzB7YDPAOcuYmHSDyYwfOzrN7ULYeKh7PW7S9715uvVu7jwimLeWFWYPXEKhUoaiPA6QzoJ5QfPXhWL9dth4/p4zRuCaPutG7PvB+K/P8N8EiG9W21ZUyk7zYr5WcOh3D96C6uBGSnsBAHb14xmJ5tYsktKGLlnmMcSs/hqxX7+HHdQTJyC2gZE8GY7vEALN2ZwnsLd/Lvnzfjvsl5dl4huW75ObuSM8tsz5T52wF4Z8HOGnqGStUvVZlF1bGUQ82BCcAd1NFKxs7F93zI9F5oUES6A/8CxmAFYCuBR4wxFZkVFlSGd7FyBeIahxNS2qJkI2+z8nAOroXl78LQG+qwhSU5Z1C11BlUKkgN6tiUTUnpXPrfpSWOje0ez8iuccREhrJuf5qrd2Z0t+Jhry2HMsjMLd5LrrwAp6AwMBcdVSpQVGVHw11Aaf+zBEjECnLqyu/A215lHqtpiUhXYBHWpqDPAWlYu6DPEpEzjDGz66KhdcW5bUPy8TxMKf9UaYXhxJ7+NPL5lTD3Ceg1GRrH12UzPRxM00X+VHAb2LEZHy0tuQZql/ho/japO5FhIUwe0I5pS3a7jv2+tXja+HmvL/Q4b3dKVpmPl1+os7GUKktVApzHKRngGCAF2ALMruONNncYYz4sp84zQFNgsDFmNYCIfABsAF4XkR4mUPdgqALnzuKAaxorQFp2Pit2p/Dx0r3M3nSIK4d34XHn4n+zH4XJr/uhtZanf9wEaIKxCl6n9W7F4u3taRYVxml9WtO+WSM++2MvV47oRHM7r+y6kzuzZMdRRGDLobJnU+0+6hngZOTkExbiYG7iYdKz8z3WvFJKlVTpvagCiT1ENRW4EQg3xpT4iyEi0cBRYKH34oMi8k+sgG2YvWFoeY8VsHtReet03w8A9GgdQ6LbOhzefruuAx0/HQ+FeXDtz9BxWF010YOzve9dM4RTu7f0SxuUqivpOfn0e/TncuslPnE6kWEhrN6byuXvLKVJozDXooG+6inV0NT0XlSB5k9AFpAhIodF5FURcc8C7AdEAIt9nLvE/j2klttY5062p7SWFdwAnPK/vcxqejEA5rs7oaDsqam1ITuvOMl5bIL/hsmUqiuxkWFEhVsBSUxkKOEhDiYPaFui3jmvLmBvShbXvv8Hx3MLfAY3ACmZebXaXqWCUblDVCJyZVUubIz5oCrnVdIy4AtgGxALnAncBowRkZF2j47zr4avXfKcZe1KewARuRGrhyioHM7IqXDdO/ZP4Kfw2XQ5sgl+e77Odxt/f9Eu123dqVk1FE+f35f3F+3ihYv60b5ZFBGhDqavPuBRZ+vh44x+7tdyr5WSmUfbpo1qq6lKBaWK5OC8j5VjU5lPHgPUeoBjjPEeT/lARNYCTwF32r+j7GO+uiacUUCUj2POx3gbeLuMGVsBaXzPVuWO8TvlEs4/8m/k8/AnKJr/Ij/kDua8M86o5RYWK22Je6Xqs8kD2zF5oOd3q77tmrBufxqn9W7FrA2HPOsPaFsiAHJatD2Z3m1j9QuCUm4qEuCcWuutqFnPA48AZ2EFOM5MPV/zj50ZrWVPVwhCBZWcYbHc9GBq4SSuCZ1Ft8X30m1+Hm9cOZyJvWp/Q07nOh6Pn6e7LKuG7d2rh/Dx0j1cOqwjIQ7hx3UHASuB+cWLBxAW4qB5dDhv/bbD47ynf0zk46V7+Pb2k4mNDPNH05UKOOUGOMaY+XXRkJpijMkXkQOAc4EJ51ceX8NQzjJfw1dBLTzUd3pVTGQoGTkFPo89V3AJ4xyr6OXYzW2h07nhg1B2PXtWbTaTvW5TYds00S521bDFx0Rw54RuAHSJK17Kq2+7JoQ4hOcv6g9YG+l6593sOprFb1uOcHa/krk8SjVEFUoyFpGhIlL6TnMBREQigfaAs393Hdbw1Agf1Yfbv5fXQdPqVGSo7xkVn9wwnK1PncEtY7sCEOq2anA2kfwj/yaKjHBbyDcMkUSf19hx5HiN7X+z62jxYmb92zcpo6ZSDUs3t41zvVdPfvDMnozo0oJPbxzOgA5N6dDc+nLgPbVcqYasorOoFgOnO++ISGMR+VhEepVxTq0SkRalHHoCq2fqOwA70fg7YKyI9Hc7vzFwPbAVK1m5XunYojitaPXDE/nkhuE8cV5v+rRrQliIg3+c3oOdz5zJtqfP5MnJfVx1l5qeTCk8hxAxvBz+Om/OXOFx3TV7Uxn34nwuf6fkaq1V4VytdUxCPC11DRylXAZ1bAZY61oNPqGZx7ELB7fnkxuHM7xLC6bfOorrRnUG4EAps6y8HT2eS26B/7doUao2VXShP+/MtQjgz8A7QMntc+vGQyIyHPgV2AM0xppFdSrWjuavutW9HxgP/CwiLwHpWCsZtwPOqk+L/Dmd0acNi4cc5dQeLWkaFc6Iri0Y0dUzJnQmJF4+/AQuH34Cszceoll0OJdMKWCkYyMDHdvouPA+jo/9ka9X7WdQx2au1VaX7z7GzuRMOsdFV6udm+3NBUedWFq8qlTD1KF5FN/cMpJQh4OYcvJqmtkLCaZleyzijjGGjUnpJLSKISzE+j67fn8aF0xZxOgT4/jf1fVuhQylXIJ5HZx5WIHKVcDLwGNY+2E9CIw1xri+yhhjtgGjsNa9uQ94AcgETjfGzKrbZteN8FAHz17Yj9PsXY4rYkKvVgw+oRmPnNefO/JvJcM04syQZSz49DkenrGBs1/13Hn81BfmkVzNGVCbkqwAp1cbHZ5SytvAjs3oW4Gh29hGVgCUlp3Pwm3JvDFvG4VFhlfnbuOsVxa4VgoH+GFdEnkFRcxJPOyxBpVS9U3QBjjGmBnGmNOMMe2MMZHGmGhjzABjzNPGmBKLwBhjNhljzjPGNDXGRBljTq5ve1DVlMuHn8Be04oH868FYNzOFxkkW3zWvW7qco7n+k5aLk9uQSGbktIB6NkmpmqNVUrRxA5w0rPz+dvna3hu5mamLtrFa3O3ATBtcfH+VzuPFOe97T1Wczk7a/am8s7vO3SPLBUwgjbAUbVHRJh23VC+LRrFewWnES6FTAl/mXiOlai7Zm8qfR6ZxZvzt1d6avrK3alk5RXSo3UMLRrrLuJKVZUzwNmTksXBdOv73ePfbyTP/j9ZUGS45aMVnPGf31mwrXiDz+omJRcWGT7/Yy/7U7O54YPlPPnDJj79Y6/r+Der9vG/BTu576u1zNpwsFqPVRty8gu589NVTF9V7ybSKiq32eaZIuIc74jCWszvIhEZ4KOuMca8VO3WKb8Z3S2edk0b8VTqZfRy7GaYI5E3wv/DpXkPke/jbfPsT4lk5RVy98SECl0/PSefL1fsA+CkTs3Kqa2UKotz7ZtjWfml1nGuqeNuZ/JxoOprXX29ch//+GotEaEOcgusYGrx9mSuGH4CS3Yc5a+frXHV/Xz5XrY9dSYOR+AsRjhj9X5mrD7AjNUHSiy6qIJfZXpwLsXKXXkBa4NKAW5yK/P+UUHu1UsHUkAot+bdSZJpzhDHFt5v9TmDOjQhNrJkkPPKnK0Vvvbdn63mq5VWgNOzTWyNtVmphsjZg+N0Vt82rtst7ARkX7Yfziz1WEUstHuDnMENwA57CGzGas9ekSIDO49W7/FqWlJacTZDZXugVeCraA9OsK1mrGrAwA5NAUimCTfn3cVn4U8wKu17Ro0fBKP/5toB3Kmi69jkFxYxe9Nh1/1uLTX/RqnqCA91EBUeQpadNDykUzPO7teGXUeziAh18Pj3npNdnQt+frlyH/lFRdx7eg9aVWGZhp0+hrj2pmRhjGHxk1Yp5AAAIABJREFU9qMljq3fn0bX+MYlyv0lJ784qDmYnkP7ZqXu2qOCUIV6cIwx8yv7U9sNV7XPfV+bNeZEnml0NyAw53FY+wVPTu6DCJzZ1xq5XLMvjWd/SmRnctnf0s565ffi2/3aMMAOpJRSVdcsqrinpkebWM7o24a/jO3KJUM6cPfEBH66czQJ9uKBt4w9EbByaL5euZ/nZ22u9OPlFxa5Jgm4y8wrZH9qNrtTsghxCPdMSiA+xsqxW78/rSpPrdZk5BQP6e0/VrE1hFTwqEwOjmqAnpjch1W7j/HIOb2JjjgDljWFWffDjFu47PKvOPeRSUSFhfDjup8AeHP+dt6cvx2Am8Z04f4zepa4pvsmoK9fOqhunohS9VyM27Bxj9bFvaLREaHcMd7a/uHNywezYvcxLhzUnh/WHWD9fitASTyYzmXvLKGg0DDtumGlbvXibtvh4+QVeA7rxESEkpFbwK+JhzEGOsdHc9u4bvRoHcv1Hyx3PV6gSHfbtmZ/BRdJVMFDZ1GpMl0x/AT+fckAmkSFERrigBG3wLCboTAP+eRSYo+utcp9eGv+DjYe8PyDluk2pbyiCclKqfIdddubqmmU77ybLvGNueikDjgcwosXDWCkvfjn+v3pLNx2lKU7U1i6s+TQkruktGzyCopYtScVgDi3GZCjE6wtAH/eaO2U072VFWg51/JZfyCNQFpXVXtw6jcNcFTlnfY09LkQ8jJg2gVwcB0zbh3ls+o9X6zxuL/DbQ2O28edWKvNVKohcQYrHZtXLI+ke+sYpl03jLAQz1lN7sNORUWGm6Yt5+K3FpOWnc/8LUcY9exchj09mwe+WQdY/4+fuaAvP94xmk4trJXNf99qJR+f2NIaEmsZE0GL6HAycgpK9JTkFhTy2Hcb+NxtenlNyyso4s5PV3Hbxys9tqjI0B6cek2HqFTlOULg/LcgPwc2/wAfTKb/NT+y9akz+GFtEkXGcPfnVmCz0e2P5atztvLiL9aCgWf0ae2R46OUqp7bx3UjO6+Q28d1q/A5IQ6hbdNGHuvhbLWHkNOy87n4zcWu7VQ+XLKbA6nZFBnP6einJMS7tmxZtz/V4/rOAEdE6N46hkXbj7L5YIZHMu/0Vft5b+EuACYPbFeh4bHK+mXjIWasPgDApN6tObe/teN6utvWFs7nqeoP7cFRVRMSBhe9B13HQ1YyTD2HsKObmTywHRcMas+Uy4pzazrd9wPP/pToCm4AElrpzCmlatKJLRvz9pUnVWhrB3cdvGYO7T6aRVGR4Z/T13t86H+35oCrd8e5e/nwLs099qPrHOc5Q8oZ4IDVYwSQeDCD1Kw814rHS3akuOrsquQ08qIi4/r96bI9vPP7jhJ5QQBr9hUHXhvcEp3T3Yao1u1LK7GXlwpuGuCoqguNgEs+hM6nwPFD8N4ZsH8lABN7eS4e5kw8dhrauXmdNVMpVbp2TRt53N95NJMHp6/n2zVWj8cVw0+gcUQoiQczWGnn3cy49WRm3DqK968Z6nFuP6/gqkt8cfDjTHz+eOkehjw1m6vfW4YxxiP4+M/sreyp4OrKK3Yfo/9jP/Pugp1Mmb+d+75ex5M/bCLhoZ94xm3vLcBjz7yth4snOTgDmv7tm1BQZJi3+TCq/tAAR1VPeBRc+gUknA7Zx2DqubBrIaEhDv46wXcS8Z+HdGDUiXF13FCllC8dWxT34ISHODiSkcsny/YA8Ph5vXlich8muX1haRUbQfPocPp3aEpkWIjHtSLDQhjXoyUAI7q0ICK0+HiP1taCnvtTs8kvNCzcdpSvVu73WFbih3VJ3P7Jygq1+7s1B8jILeDx7zfyvwU7PY699dsODqUXL+J39HhxArazlyi3oJCc/CJCHcK4Htbz854UoYKbBjiq+sIirZ4cZ+LxhxdA4g/cOaEbu549i7P6Fa+q+s0tI3n2wn5+bKxSyt2fh3RgdLc4Xriov0ewM7pbHFeO6ATApN7FAU7fdmWvW/XsBX25dlRnnjq/j0d5n3ZN6NbScwjrni/W4D2pas2+NHYcOc7KPSX3vnOX4jZrLCUzjx6tY7h0WEdX2S/2TC7w7MHZcSSTGz5YzsPTNwDWTuwn2M9bE43rF00yVjUjJAwu+C9ExMCK9+HTy+C0p2D4Lbx+6SCuGH6U7LxCBnbUfaeUCiQtGkcw7bphAMxcn8Q2ewhnZNfiXtaRbj2uAzuWHeC0jI3k4XN6lSgPcQhTLh/EJW8toWebWEJDhHmbjwDWENGafcW5MeNetNaKnXrtUMYkxAMw7f/bO/PwKKuz/3/umez7BgES9kUQQVkV6gIoasUqdanaurRq1Vdba619q1atVX/qq9XWrdYW22rVVq2gtmK1iqAggggoi4CENayBbCQh65zfH+eZyTOTSQiYTJLJ/bmucz3PnO05MyfJfHOf+9znk60U7K3gtrOGEx/jDRIjKfEx3HPuMUwcmMVRuan86s01rHL157bgQLD4yUiMDWx1D62ndG1U4Chth8cLZ/8O0vvCvHvhndthfwF88yFOGJTd0aNTFOUQ9Mtq9JmZNLjxdzYtIZY7Zozgw6/2cdGEvkfc/5CeqXx82zRiPR5qG3x8XLCPIT1SKa+u4+wnFjap/8qy7ZwyrAeb91Vy5+urARiYk8wVkwcEdn5dNL4v/zNlMAMcZ2f/dWuxXYoyxrC/0lpwRvZJY03IMlReZiLZKTZukL+eEh3oEpXStojAybfA+c+CNx6WPQsvXgCVLQcPUxSl4/Ef5dAzNZ5RecEOw1efNIjnr5wYFNjvSIiP8eLxiOOvk0u/7CRG9knjxjBxseZ9uZeq2nrmrtoVyHtxyVYqa+rZV1FDnNfD/eeNCogagP5OHKB1uw/w/pd72FdRS12DITU+hgkDmm5u6JeVFDiQVC040YVacJT2YdQF1pLzj0tg0wfwzMnwnechf1xHj0xRlGY4f1w+HhGO65eB1xO5OFUiws2nH0XZwTqeW7w1kH+wroH3vtzLv5wdXWCPepm9wp5Unp+V2GScvTPsoaGlVXVc9dwyxjpLatkpcfxo2hDiYjwkxnp57P2vABjbLzMQ+bn0YB3GGI3RFSWoBUdpP/odD9d+CHnjobwQ/nImfPosTbwKFUXpFMR6PXxnQt8Oi1PVP7vREuMPNXHn66tZt/sA2clxXH3iQAAedLaB9w8TtTk+xhtkZfJvbe+RGk9OSjy3nzWCq08aSN+sRAblJHPGMb0CoqfBZ6isbWjSp9I1UYGjtC/p+fCDt2HiNdBQC2/dDK9+H6qKD9lUUZTuxYjeaYH7K5wdXP5YNddPHcIVkwcgQkCEDO6R0qQPgHpf02B/7tPWUxNiWXDLVP5z08mkxNuFjPTE2KDnbS+uoqCookk/StdBBY7S/sTEwVkPw3mzIC4F1r4OT0+Ggg86emSKonQiThiUxR0zRvCHS8cyYWDjjssYj3DRhL70zUripKE9AvlDc8MLHP95XJlJsVxz8iASYj1cPDHYOdrjkaBjIQICp6qOypp6Zjz+Eec+uYiyKo1u3FVRgaNEjtEXwnULoe/xcGAX/G0mvH0r1LYucqmiKNGNiHD1SYM485jexMd4OdHZnn71SYMClpaZx/UJ1G9ud+b1U4aQnhjLfTNHcftZI1h37zcDwfyaw23BmbNiB+XV9VTU1AdFWla6FupkrESWrIHw/bmw6Lcw/0FY8jSsnwtn/xaGnNrRo1MUpRPx+CVjWLq5OBAdGWDG6N6s2VnOwJzkIJ8dN2ce04szRuYelrNwmkvgzF5eGMjfXVbdXBOlk6MWHCXyeGPg5J/DVf+F3FFQutVGP37th1BR1NGjUxSlk5CVHMeZjhOwn/gYL3eefTSXntC/xbaHuxPKb8Eprapl7a7GWDnuIx+UroUKHKXjyBsL13wAp/0aYhJg1Svw5HhY8gw06Lq3oiiRwy9wPi8so7qu0Ul5f2XkYuMYY5j10Sb+umgzRnebfm1U4CgdizcWTrwJrl8Mg6ZCdSm8/b/WCfmr/3b06BRF6Sb4Bc6STcFBSYsjKHBWbC/lvre+5O5/reXpBQVH3E9NvW51BxU4SmchaxBcNgcufgkyB8K+DTYC8t/Og11fdPToFEWJctITrUvqJud082Py7Jb1bcVV3P3mGuav33tY/a3cXsqzCzdTXdd6seE+zfzRdzdQXn34luwXPtnK8Dv/wz+cE+G7MypwlM6DCAyfATcsgdPvg/h0KHgfnjkJXr4M9n7Z0SNUFCVKSU+KDXp92gi762rl9lL++vEWrnvhs1b35fMZrnl+Gff+ey0Pvr2u2Xr/Wb2LZxYU4PPZ5Sj3AaL1PsPqHWXNNW2WJ+dtxBi4dfYqthd37x2qKnCUzkdMPEz+Mdy4HE64wfrnfPkm/H4S/PMqKNrQ0SNUFCXK8C9RAWQkxTJjVO+g8uo6H1W19SF5DVz11095YG7wP1+7yqvZe8Ae3Dl7eSENvqb+NLX1Pq57YTkPvL2Oxc6y2E6XwAHYtv/wBIoxJmiM/uMouisqcJTOS3IOnHk/3LgSJvwQPDGw+p/w1AT4+yWw7ZOOHqGiKFGCW+BcOC6fvmGOgdh3INgfZ3HBft5ft5dnPtwUFBBwkysCcnl1fVhLyoY9BwL3n20tAWBHiRU4Jwyyh4JuPUwLTFFFDeXVjQJnVeHhW4CiCRU4SucnrTfM+A3cuALG/cCeUr5+Lvz5DJg1Hb78F/jUqU5RlCPHfZTDWaN6kxDrbVKnqCJ4y/iK7Y1BAF9eto07X1/N/ooaNhVVBtVb7xIzftbsLGty71+iOn6gDWDoFzyH4tMtxRx//3s8/J/1AIzskxZ47mdbu++xOBroT+k6ZPSFb/0Opt4OS/8IS/8EhUvh5UshvR+MuwLGXAapLUcsVRRFCWVAdjJnjMwlIdbLsfkZYesUhVhwVmwrCdzfP9f62izdXBwQGH427wsWPABrXA7Fa3aWU1vvY3d5NR6B8QPsMRU7SsMLHGMMzy7cTHJ8DJdM7Mcj765nT3kNr35mAxROHJhFZU09W/ZXcf7Ti1l06zTyMhKb9LN5XyUJsR56pzctiwZU4Chdj5SeMO0OOPGnsOIF+OT3ULIF5t0L8x+AEd+C8VfCgJOs47KiKMoh8HiEZy4b32Kd4spaig7U8NKSbeSmxfP59qbHOKzfcyBgsTllWA8WbChic1Eln20tYf76vZw8rAd3zFkdZNUpLDnI2l3lGAN9MhIZ4ERobs6Cs2pHGfe9Zf1+pg3vSWVNsAV72vCe5Gcmce+/1wLwjQfnsfi2aUFCpqSylmmPzCcjMZbP7piOxxN9fytV4Chdl7hkOP5a65+zaR58+mfY8DasmWNTRn8YfREcezFkD+7o0SqK0sX47vH9eGnJNo7KTWX9ngP89ePN/PL1VbQ2Bt9pI3qyYEMR63aXc/mzS6isbeCJeRsD5V6PMLRnCut2H+A/q3cD0Dcrkdy0BERgz4Fqaut9QZGcNxVV8MInWwOvPy7Yx25XtOXe6QlMHpzDiUNyGNknjYv/aH0VX/uskB9NGxqo93lhKcZASVUdxVW15KTEH9Fn1JlRHxyl6+PxwJDT4JKX4KbVcMovILWPPQLiw4fgibEw6zS7pFW5/9D9KYqiAPecM5JFt07jgnH5AGzYU9FE3LidkycOyAoqO3mYPfn888IyKmub+gnGx3gCy1Fvr94F2JPQ42I85KYmYAys3VVOWVUdt81exQfr9nL188t4ZVnjWVmfbimhyNmxdcPUwfzlBxPwegQR4YRB2Tx28XEALNkc7ItTUtW43La3vKb1H0oXQgWOEl2k51kfnZ+uhsvfgGO/C3EpUPgpzL0FfjMUnvuWFTvluzp6tIqidGJivB7yMhLJSo4Lyl9y+6nkZ9rlnmtOHhTIPyYvPbAqnhTnpV9WEqPz0wHISQnuw9/2mD62fKuzJXxQjxQABuTYXVw3/WMFc1YU8vel27j+xeVNHJgXrLfn9+VlJPLzM4YzvFew/8+YvlZAfbkr2NG5pLJx19dPX17JmHve5eON+1r8PLoaKnCU6MTjhUFT4NtPwy0b4LxZ1sojAps/tGLn0eHw7Onw8ROwbyOttjsritKtyHKJE/8S0ivXTmLW5eO51iVwjuqVwmXOIaA3Tx+GiPDyNZOY97NT+PSXpzG4h/WtGdozhX9ccwI3ThvK2P6ZQc/yC6JbTj8KgC37q5jniJiDYaIi+x2R+2aFdxTOz0wkJT6GfRU1AUsPQOnBRoGzfs8BSqrqeGr+xnBddFnUB0eJfuKSYfSFNh0sgQ3vwNo3bZTk7UtsevcOyBxgRdCQ6TDwJNtOUZRuT7bLgjO0ZypgnYH7ODuT/nDpWBZu3Me5x+Xx7TH5XDAun1F5VqgkxnkDVplfnDmcJz/YyB0zjmbiQLucNSw3lYcuGM3T8ws4Nj89sMw1fkAWEwdksXRLMR9uKGoyphiPYCAQRLBfmLg9YJ2nR/RO5dMtJXxv1ifcPP0oph+dS2lV0zO2vigswxhz2Cexd1ZETyxtHSJiAD3hNZqoqYCN79k4OgXvW/HjxxsH/SfD4Gkw4ETodSx49f8BRemOlFTWMuZee/jvVScO5M6zj47Ic385ZxUvLgl/ptTL15zAvW+tZfUOu938ltOHBTkRu7nrjdU8v7jRMfmKSf0pqarjzc93Nqm78BdTyc8ML5Y6I34xZoxposr0L7bSfYlPgZEzbfI1wM4V9gTzjf+FHcth03ybAOJSof8k6P8Nu/28twoeRekuZCbHMbxXKut2Hwg4DkeCoT1TwuZPPzqX4wdlM7hHSkDgDMtNbbafk4f2CBI4Ly3dxriQpTE/9/37S56+dGxUWHHUgtNK1ILTzajcDwXzYMuHsGUhFG8KLo9LhbyxkD/BSePt0RKKokQl24urKCiqYMpRPSP2zEUb9/G9WUua5F8ysS8PnDeaZxYU8IBzmOfKu6aTkdTUkdnPim0l9EpP4NJZSygoahp40M0fLxvH6SN7fb3BRwi14CjK4ZKc3ei3A1C2A7Yugi0fwZZFUFwAmxfY5CdzgBU7eeOt+MkdqX48ihIl9M1KCns+VXvituDMGNWbt1bZnZ/ZyTZmzXeP78f2kiomDcppUdwAjOlnLTY3njqUn/xjZZPyK78xkD8v2gzAZ9tKuozAaQkVOIrSGtLzYPR3bAK7xXzHMrv9vPAz2LncRlMu2QKrXnUaCeQMhV6jnDTappTImbgVRem69EiN57wxeVTU1HP2aJfAcXZ1pSbEct/MUYfV54SQWD1+LhiXz8g+afzs1c+bbEWvrfdx08srGNM3kx+6do11dlTgKMqRkNYb0r5lj4UAaKiHvWsd0bMMdn0ORetg3wabVr/W2Da1N/Q8GnoMhx5HNabE8GviiqJ0T0SERy+ygfrc515lf42ow73SEkiM9Qa2nGckxZKWEMvQ3JRADJ+CvRVBbZZtLWbuqt3MXbWbc4/rQ8+0hFY9q77Bx66y6ohbvvyowFGUtsAbA71H2zT+SptXV21Fzu5VsPsL57oKDuyyqeD94D5SciFnWKPwyR4CWYMgPd/G9VEUpdvSI7VR1PRMPXKB4/EIvTMSAlaahb+YhleEWK+HgTnJeD3Clv2VVNc1BE5Ud1t0bpu9ime/P6FVz5q1cDMPvr2ORy48lvOdaNCRRAWOorQXsQnQ5zib/Ph8ULLZCp+idVC03qZ9G6Bij01bPgruxxMLmf2t2MkaBJkDG+8z+kFMy2vviqJ0fdwCp7ndVa0lMykOsKIlJb5RBiTEehmQnURBUSX3/nst95x7DF6PsNFl0flg/V5q6huIjzn0P10POg7QD72zTgWOokQ9Ho89+DN7MAyf0Zjv80HZdit0/OKneLPdvXVgF+zfaFMo4rFLXun5rtTXSc7rxIzIvT9FUdqF+BgvL119POXV9V9riQpgcI9kPttaErZsWG4qBUWVvLhkG9V1Pu6beUyQwPEZu6NsSM/mt6WH4umgLecqcBSlM+DxWCtNZn8YOj24rLbKOi8Xb2pMJY74KSuE8h02bW+6nRSA+DQrdNLyILWXFUSpuZDivs8Fb2z49oqidAomD2mbUBTfO74/89bt5WfOcRBurpg8gHnr9lJT7+O15YV8XlhKmXOsQ15GIjtKD7KrrDpI4JRU1uL1CmkJ4f+GdJTA0Tg4rUTj4CidkvpaOLDTCp2yQmsFKiuE0u2Nr+uqWtdXUo4jgHo54icXknvY/GQnJeVAUrYuiylKF+dQRzLMXl7Iza98HnidFOdl+tG5vLFyJw9fMJoLx/cFYE95NVMenk+P1Hg+uGUKXk8gLg0Db5sLwKAeycz72ZR2eR8aB0dRopWYOBt/J3NA+HJj7BEUfgFUsRsOOKlij+PwvAcq90LVPpv2rD70cxPSG4VPUo6NG+QXQ0nZdkdYYgYkZDTeq4VIUToNh4pUfN7YfJZtLeEl56iIyYOz6Z1uz97aXVYdqPfumt0crGtgW3EViwv28+7a3Vw+qT+Pvd+4pO4/LyvSqMBRlGhGBJKybOo9uvl6vgaoLGoUPH4hVOmInsp9ULXf1qnaD9VlNhUXtH4ssckhwsefMl2vMyE+HeJTG1NCGsSl6E4yRYkwkwZlBwTODVOH8Pn2UgB2l1uBs6P0YJCQuXX2FxSWHAw6FgIILHFFGhU4iqJY8eBfnjoUPh9UlwaLH7/w8Quh6lI4WGqtR/77ukqbyguPbIxxKcHCJz7V+hfFp4XJT7X145KssIpLDr6PiYcoOGtHUdqT6Ufn8u0xeQzNTWFMv0z2OMKmoKiCDzcUsWBDEfsqagL1C0sOhu2n/GAdPp/B44ns75z64LQS9cFRlK+BMVBzwBE7JVbwuO8DQqjE1guXaMPfPfGEET5J9nWsc3Xf+68xCRCbaK8xCTYUQEyicw0pi0mwzuOKEiWs3F7KzKcWNckf2SeNNTvLW2y76u7TSW3GCfnroD44iqJ0LCJ2qSkhzcbuOVx8PqitCBE95S3f11baHWh1lU3vG2qh9oBN7Yk3vqkIcguhoGu8rR8T57rGheTFO3lxTfNi4q2fU5O8OLVWKW1Cr2YiGE8/OveQAuelJdu46sSBxHgjJ/q7jcAREQ/wE+BaYABQBLwC3GWMafloVUVROhaPp1EgtQUN9eGFT9B9pd2B5r6vr4G6g1Bf3fRaX22jV9cftNeGmsZEWduM+0jxxDYVPf6rJ8YKI0+sjcjtiXWEUmzjfWhZUJvQuuH6iwtp31x/MSBee/WEXmNUqHUwOSlNd0/GeoVx/cMfM7Pp/rM46/GPWLf7AA+8vY79lbXcftaI9h5mgG4jcIDfAjcCc4BHgBHO6zEicpoxxteRg1MUJYJ4Y8CbbneDtRc+X6PwCRJEjggK3LvKGmqtiHJfw+U1W1YDDXXBeb46m2o7xtGzTRGPSwDFWOEbuPeLI3d5yOug8pB60kI7T4x9dlBdrxVcgXtnbOJxvfY01g+b7wlp72mmL+dZTfpy54f25bWfT9i+PEe0fBrj9XBUbirr9zRaPnumJjAgO7lJ3d7pCXg8Qlpi47JUXkbikc37EdItfHBEZCSwCphjjDnflf9j4HHge8aYlw7Rh/rgKIrS9fD5GsWQWwjVO699ddai5auz4shX79T139eFlNU1tgm0D1Pmz2+2vet1Qy0Yn33tq7e7+nwNja+Nc6+0LeGEj3gc4eYJm+oN1DRAvQ/2V9WTnZpAemI8xQfraTCCx+NhV3kt+VnJZCTFU7CvitLqBnwIx868mbixl7TtW1AfHC4BBPhdSP6fgAeBS4EWBY6iKEqXxOMBj+MQ3ZUxxiWCGoLFkGk4hDgKLXddTUP4dr76ENHlqmManDL3vS8k33nt87nuXflh20SwL3DyG6zgbCUxNAqHdA/2SKtKyHLVyfYApTYNBvAbi6p2f60fgcOluwicCYAPWOrONMZUi8hKp1xRFEXprLiXg5SvT1ix5E4mTN7h1jH8Yf4G3l2zm7z0OJ4YdW5E32J3ETh9gH3GmJowZTuAySISZ4ypDS0UkWuAa9p7gIqiKIoSMTwerGmlfWXAt88ZSUH8eq6YPADS29HnLQzdxQenAIg1xjTZnyoizwOXAZnGmNIW+lAfHEVRFEXpRLTkg9NdolBVAc2dL5/gqqMoiqIoShTQXQTOTiBHRMKJnDzs8lWT5SlFURRFUbom3UXgfIp9rxPdmSKSABwHLOuIQSmKoiiK0j50F4HzMvYgm5tC8n8IJAEvRnxEiqIoiqK0G93CyRhARJ4AfoSNZDyXxkjGi4Bph4pkrE7GiqIoitK5aMnJuDsJHC/WgnMN9iyqfVjLzl3GmIpWtFeBoyiKoiidCBU4bYBf4CiKoiiK0rnoztvEFUVRFEXpRqgFR+myiMgyY8z4jh6H0hSdm86Lzk3nReembVELjqIoiqIoUYcKHEVRFEVRog4VOEpX5o8dPQClWXRuOi86N50XnZs2RH1wFEVRFEWJOtSCoyiKoihK1KECR1EURVGUqEMFjqIoiqIoUYcKHKVTIiK3icirIrJJRIyIbDlE/aNE5HURKRGRShH5SESmRWi43QYRGSYi94jIJyJSJCIHRGSliPxSRJLD1Nd5iRDOZ/2iiHwpImUiUiUi60TkURHp3Ux9nZsOQESSRGSz87ftyTDlOjdtQExHD0BRmuF+oBhYDmS0VFFEBgMfA/XAQ0AZ9qT4d0Tkm8aY99p5rN2JK4EbgDeBF4E6YCpwH/AdETnBGHMQdF46gHygN/ZA4ULs5z4Ke/7exSJynDFmL+jcdALuAXLCFejctB26i0rplIjIIGPMJud+NZBijBnQTN1XgPOBccaYlU5eCrAGqAaGG/1BbxNEZDzwlTGmLCT/PuCXwI+NMU86eTovnQARuRB4BfiFMeYhJ0/npoMQkbHAUuB/gUeAp4wxP3KV69y0EbpEpXRK/OLmUDjLIucA8/1/DJz2FcAsYBgwoV0G2Q0xxiwLFTfFx2GVAAANcElEQVQOLzvXY0DnpZOx1blmgs5NRyIiXuBPwH+A2WHKdW7aEBU4SldnNBAPLA5T9olz1T8I7U++c93jXHVeOggRSRCRHBHJF5HTgWecornOVeem4/gpMBz4UTPlOjdtiAocpavTx7nuCFPmz8uL0Fi6Jc5/pXdhfQZecrJ1XjqOq4EiYDvwDtaH7VJjzEdOuc5NByAiA4FfA/cYY7Y0U03npg1RJ2Olq5PkXGvClFWH1FHah98BJwC3G2PWO3k6Lx3H68A6IAUYg13y6OEq17npGJ4GNgOPtlBH56YNUYGjdHWqnGt8mLKEkDpKGyMi92LN7X80xjzgKtJ56SCMMYXYXVQAr4vIa8CnIpLozJHOTYQRkUuB04GTjTF1LVTVuWlDdIlK6ersdK7hzLb+vHDmXuVrIiJ3A3cAfwGuCynWeekkGGO+AFYA1ztZOjcRRETisVabucBuERkiIkOA/k6VdCcvA52bNkUFjtLVWYU1504KU3aCc10WueF0D0TkV8CvgOeBq8NsW9V56VwkAlnOvc5NZEnELhHOAL5ypflO+aXO66vRuWlTNA6O0ulpRRycV4HzgLHGmM+dPH/ciBrgKI0b0XaIyF1YZ8m/Ad83xviaqafzEkFEpJcxZneY/KnAe9itx6c6eTo3EUJEYoFzwxT1AH6P3TL+LPCFMWaDzk3boQJH6ZSIyGU0mnB/DMRhg2IBbDXG/M1Vdwg2cFYd8FugHBv5cxQwwxjzTqTGHe2IyA3Ak8A24E4gVNzsMcb816mr8xJBRGQONpLxPGzsmwRgHHAx1m9jiitwnM5NByMiA7BOx6GB/nRu2ggVOEqnRETmA6c0U7zAGDMlpP4I4EGnTRz2iIe7Nax52yIifwWuaKFK0NzovEQOEfkOdm5GY60DBit0/gs8bIzZFlJf56YDaU7gOGU6N22AChxFURRFUaIOdTJWFEVRFCXqUIGjKIqiKErUoQJHURRFUZSoQwWOoiiKoihRhwocRVEURVGiDhU4iqIoiqJEHSpwFEVRFEWJOlTgKIpy2IjICyJS39HjOFxEZKGIbGyjvn4sIqUiktkW/bn6jRERIyKz2rLfjkYsX4jInzp6LEr3QAWOokQAETnT+dK6N0zZJKesRkSSwpS/IyI+EcmJzGi7NiJypYjc2M7PyMQeNvqIMaakPZ8VLTjnJ90NXCkiozp4OEo3QAWOokSGhUA9MDVM2RSnLA6Y7C4QkRgnb7UxZl87jzFauBJoV4ED/AhIBZ5q646NMfXYE6iva+u+OwFzgELg9o4eiBL9qMBRlAhgjKkAPgUmhrHSTMGeF7TLuXczAUgB5rfvCJXWIiJe7OGH/zbGFLfHM4wx1Y7QaRNEJLWt+vo6OFacF4DzRKRHR49HiW5U4ChK5PgAiAW+4c9wWWgWAB/S1MIzxdXW32aEiDwtImtF5ICIVInIMhG50t3Q8RExInJW6EBExCsiu0RkWUj+RBF5Q0T2O0tm60XkNudL/ZCISJ6I/EFEtotIrYjscF7nhNS7zxnbEBH5P6dejYisEJEzw/SbLCK/E5HdzvtdLCJTQ32BRKQQ+/kOdvr3pxND+ssXkZdFpEREKkXkbecU59YwCegLzA0zzhdEpF5EeojI887nWC4is0Wkp1Pnf0RknYhUi8iXInJ2SB/N+uCIyKnOWPc77TeJyJ9EJMspH+K0vUNELhGR5SJSjT2V2t/Hcc4cFzt9rBGRn4mIJ+RZ/veSISLPiEiRU3+hiEwIqetx+ljl/EyWO+9xVpifnbex1spzW/l5K8oREdPRA1CUbsQHWNP8FKzFBhotNAuAcuAxEUk2xlQ65VOwp0IvcPVzKvZL/E3sacQpwEXAsyKSbYx52Kn3d+AR4HKafhmfDvQC7vdniMg5wD+B9cDDQInznP+HPaH6kpbenIgMBD4GvMCzwCZgKPA/wFQRmWCMKQ9p9gJQ4zwvHrgJeENEhhhjtjv9CjDbGfNs4H1gMPAGsCWkvx9jT2FOB25x5a933adixeRC7HwMxi5pvS4io40xvpbeJ42n3C9tplyAd7BzcycwDLuk1VNE3gK+D/wZqAV+ArwmIkNDT/tu0qnI9cCTwHbgaWAb0A84B+gDuK1JF2BF2NNOKnP6OB77c1iDXV7bgxUav8HOcehJ8YL9Wd2J9Z/pAdwMvCUigxzLJFh/pLuwc/J77M/sQKfvWKDB1ecyoA77sx1VjtRKJ8MYo0mTpggkrF9FDfCxK+82oAL7z8YI7BfD6U5ZDHAAWBnST3KYvj3YL+xiIMaVPwc4CKSH1P879gs2x3mdBBRhv/y8IXV/7ozrRFfeC0B9SL23gN1An5D847FfcHe48u5z+nwdEFf+JCf/XlfeOU7e0yH9+vNDx7EQ2NjMHCx02twckn+bk39qK+bxRaduUpiyF5yyx0LyH3fytwAprvyxYd5vjJM3y5XX35mvVUBauPl3rkOctjXAsDD1lmDFxTGuPAFec9qdEua9PB7SxyVO/lWuvC+ALw7jd2ELsKIjfx81RX/SJSpFiRDGmIPYL5jxIpLsZE8BFhlj6o0xXwJ7aVyW8lt3Pgjpx2/dQUQSRCQbyMJaDTKxVhM/zwEJwIWuNmnY/6zfMo2Oy2cAOVjLQqaI5PgTjdaf05t7b84SyTexgqU2pH0B1poRrv1jxhjjem+LsYLM/R6+5VwfDfkc3gS+am5MLVCPtYS4medch3JoegA1xpiqFur8LuT1R871r6bR6oExZjlQ2YrnfgdrCbnbNLWCYZpanf5ljNngzhCR3sBEYI4xZrWrrQEecF5+O8yzfxvyOtxnVQb0FZHJtI79QM9W1lWUI0IFjqJEFr8fzokS7H/jx+2HM8W5znd3ICKpIvKoiGzHioF9WOvLPU4Vd1yWt7BfJpe78i7EWpOec+WNcK7PO325k//LMLeF9zUcawm4Nkz7IuwyULj2m8LkFQPZrtcDsaKkIEzd9WHyDkWhMaY2JG+/c80OrRwGg32vzeEDtobk+beSbw5Tv7QVz/WLiRWHHJ1lQ5i8Qc51TZiyNSF1/IR7L+E+q1uxlqFFIlLo+O9cLCKxzYxPsJ+jorQb6oOjKJHlA6yvwhSsz43f/8bPAuC3IpLi1PFhRY+bl4EzgT9gl1z2Y5eAvoX1JQn842KMqRORvwM3iMhAY8xmrNjZjxU/fvxf2Ddjl0HCsaOF9+Vv/xx2aSMc4SweDWHy3P2F3rcFzT2ztc8qAuJCfKXcmDAWlUM9+1DP9Ze3VhSE+6xbekZz/bb0XsRVaZGIDMZaAqcC04DvAWtE5ERjTGlI2yzs56go7YYKHEWJLIuBauyXQDnWAvOpq3wB9vdyCtbBd6VxBZJzlqO+CfzZGHO9u+Nwu48cnsM6uV4mIs8BJwFPGWPqXHX8Sz0Vxpj3juB9bcR+ScYeYfuW2Iz9whxM0yWpYWHqt7dlwG/RGgqsbOdn+fFbqsYQ3grUGvwWsJFhyo52ruEsaq3CGHMA66T+TwCxwRYfA35A8C6uRCCPxmU7RWkXdIlKUSKIMaYGK3LGAWcDi0OWS1ZjrSs/B5JpGv/GbwEI+m9cRPKwAe7CPXMZsBa4DGu9EYKXp8D62ewHbpMwRw+ISKK0EEvFGLMHeBe4MHQLsdNe5MjjnvzLud4c0uc5hBc4FQQv07U1853rCe34jFBexS4B3R1uHpydZi1ijNmF3fk1U0T8S5L+trc5L+ccyeAkfJTt5c41KyR/HFbEL0BR2hG14ChK5PkAa8GZjN1eG8AYY0TkI2Cmq667vFRE3geuEJEa4DPsDpvrsP+hj2/mmc8B/4fdOr3WET3ufitE5HLsNuz1IvIXrFUmE+tfcx5WkC1s4X1d65QvFJHnsf4iMVgfmpnYreP3tdC+Od7Ebg2/zhFJ87DWnKuxy2kjQup/ApwpIk849w3Ae6btIkEvxfqlnIVdJmx3jDFbReRn2N1Yq5zPdxuQj/1sL6XRstQSN2J/phaKyO+x28TPAaYDzxtjjlR0fOX83C7FbinvA1yD3c31SkjdGdgdYW8c4bMUpVWowFGUyOMWLeG+UBZgv7QaCG/GvwQrVmZiY6p8hXXyFJoXOC9gd8qkYR2Jm2CMmetYX27FWntysM6xG7FxasI5p7rbbxWRsU77c7DWoips3JbXcZYuDhdH9M3Exuy5CPsFuRK7E+wmYEBIk0ecvIuAG7Cfy0m0LM4OZzw+Efkj1pqS04bC6VDPfUJEvsKK1J9gg+XtxIq/lvyj3H0sEZFvAL/GLlsmYYXxz2m6W+pweBi7dPoTbAyiPdiYSA8YYwI+XY616LvAbGOM+uAo7Yq4dmgqiqJ0KURkLeAzxhwT4edmYIXlU8aYuyP57K6MiJyPtegc5xY+itIeqA+OoiidHscxNTTvXOzy1H+btmhfnF1BvwZuCuezpDTFsd78Cusgr+JGaXfUgqMoSqdHRB4CRmGX98qxEYB/gF1CO84Ys7MDh6coSidEBY6iKJ0esQdS/gJrsUnHBgN8D7jTGHPEW5sVRYleVOAoiqIoihJ1qA+OoiiKoihRhwocRVEURVGiDhU4iqIoiqJEHSpwFEVRFEWJOlTgKIqiKIoSdfx/vbCMrC88mjsAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the spectrum & the model fit to the short wavelength region of the data.\n", "plt.figure(figsize = (8,4))\n", @@ -1034,42 +1216,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Model is linear in parameters; consider using linear fitting methods. [astropy.modeling.fitting]\n", - "WARNING:astropy:Model is linear in parameters; consider using linear fitting methods.\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Fit a spline to the 10 micron feature to isolate it.\n", "\n", @@ -1139,19 +1288,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Line_centroid: 10.722 micron \n", - "Integrated line_flux: 6.51116e-12 W / m2 \n", - "Equivalent width: -8.85904 micron \n" - ] - } - ], + "outputs": [], "source": [ "# Calculate the Line flux; Line Centroid; Equivalent width\n", "# NOTE: Where are errors computed with these functions?\n", @@ -1184,7 +1323,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1206,22 +1345,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the optical depth of the 10 micron region vs wavelength\n", "plt.figure(figsize = (10,6))\n", @@ -1250,7 +1376,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1266,34 +1392,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot the underlying dust continuum and spline fit\n", "plt.figure(figsize = (8,4))\n", @@ -1356,7 +1457,8 @@ "source": [ "## About this notebook\n", "**Author:** Olivia Jones, Project Scientist, UK ATC.\n", - "**Updated On:** 2020-08-11" + "**Updated On:** 2020-08-11\n", + "**Later Updated On:** 2021-May-10 by B. Sargent, STScI Scientist, Space Telescope Science Institute" ] }, { @@ -1390,7 +1492,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.9.2" } }, "nbformat": 4,