From d135184243d097f061e79dd6737f16f768adb613 Mon Sep 17 00:00:00 2001 From: Walter R Cook Date: Mon, 11 Jul 2022 13:59:12 -0400 Subject: [PATCH 1/6] Added Transverse Velocities --- .ipynb_checkpoints/Makefile-checkpoint | 155 ++ .../example_CoLoRe-checkpoint.ipynb | 813 ++++++++++ .../param_example-checkpoint.cfg | 149 ++ Makefile | 10 +- example_CoLoRe.ipynb | 271 +++- examples/simple/out_node0.dbg | 0 examples/simple/out_params.cfg | 64 + .../.ipynb_checkpoints/params-checkpoint.cfg | 69 + output/bias.txt | 1024 ++++++++++++ output/colore_node0.dbg | 1 + output/colore_params.cfg | 55 + output/dndz.txt | 1024 ++++++++++++ output/log.txt | 113 ++ output/nuTable.txt | 5 + output/params.cfg | 69 + output/pk.txt | 1024 ++++++++++++ output/tz.txt | 1024 ++++++++++++ output/wz.txt | 1024 ++++++++++++ src/.ipynb_checkpoints/common-checkpoint.c | 750 +++++++++ src/.ipynb_checkpoints/common-checkpoint.h | 618 ++++++++ src/.ipynb_checkpoints/cosmo-checkpoint.c | 868 ++++++++++ src/.ipynb_checkpoints/cosmo_mad-checkpoint.c | 520 ++++++ src/.ipynb_checkpoints/cstm-checkpoint.c | 158 ++ src/.ipynb_checkpoints/density-checkpoint.c | 1393 +++++++++++++++++ src/.ipynb_checkpoints/fftlog-checkpoint.c | 157 ++ src/.ipynb_checkpoints/fourier-checkpoint.c | 423 +++++ .../healpix_extra-checkpoint.c | 885 +++++++++++ src/.ipynb_checkpoints/imap-checkpoint.c | 316 ++++ src/.ipynb_checkpoints/io-checkpoint.c | 1374 ++++++++++++++++ src/.ipynb_checkpoints/isw-checkpoint.c | 153 ++ src/.ipynb_checkpoints/kappa-checkpoint.c | 181 +++ src/.ipynb_checkpoints/lensing-checkpoint.c | 256 +++ src/.ipynb_checkpoints/main-checkpoint.c | 154 ++ .../predictions-checkpoint.c | 173 ++ src/.ipynb_checkpoints/srcs-checkpoint.c | 763 +++++++++ src/common.h | 9 + src/io.c | 46 +- src/srcs.c | 31 +- 38 files changed, 16023 insertions(+), 99 deletions(-) create mode 100644 .ipynb_checkpoints/Makefile-checkpoint create mode 100644 .ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/param_example-checkpoint.cfg create mode 100644 examples/simple/out_node0.dbg create mode 100644 examples/simple/out_params.cfg create mode 100644 output/.ipynb_checkpoints/params-checkpoint.cfg create mode 100644 output/bias.txt create mode 100644 output/colore_node0.dbg create mode 100644 output/colore_params.cfg create mode 100644 output/dndz.txt create mode 100644 output/log.txt create mode 100644 output/nuTable.txt create mode 100644 output/params.cfg create mode 100644 output/pk.txt create mode 100644 output/tz.txt create mode 100644 output/wz.txt create mode 100644 src/.ipynb_checkpoints/common-checkpoint.c create mode 100644 src/.ipynb_checkpoints/common-checkpoint.h create mode 100644 src/.ipynb_checkpoints/cosmo-checkpoint.c create mode 100644 src/.ipynb_checkpoints/cosmo_mad-checkpoint.c create mode 100644 src/.ipynb_checkpoints/cstm-checkpoint.c create mode 100644 src/.ipynb_checkpoints/density-checkpoint.c create mode 100644 src/.ipynb_checkpoints/fftlog-checkpoint.c create mode 100644 src/.ipynb_checkpoints/fourier-checkpoint.c create mode 100644 src/.ipynb_checkpoints/healpix_extra-checkpoint.c create mode 100644 src/.ipynb_checkpoints/imap-checkpoint.c create mode 100644 src/.ipynb_checkpoints/io-checkpoint.c create mode 100644 src/.ipynb_checkpoints/isw-checkpoint.c create mode 100644 src/.ipynb_checkpoints/kappa-checkpoint.c create mode 100644 src/.ipynb_checkpoints/lensing-checkpoint.c create mode 100644 src/.ipynb_checkpoints/main-checkpoint.c create mode 100644 src/.ipynb_checkpoints/predictions-checkpoint.c create mode 100644 src/.ipynb_checkpoints/srcs-checkpoint.c diff --git a/.ipynb_checkpoints/Makefile-checkpoint b/.ipynb_checkpoints/Makefile-checkpoint new file mode 100644 index 0000000..01fbfb7 --- /dev/null +++ b/.ipynb_checkpoints/Makefile-checkpoint @@ -0,0 +1,155 @@ +########## User-definable stuff ########## +# +###Compiler and compilation options +COMP_SER = gcc +COMP_MPI = mpicc +OPTIONS = -Wall -Wno-format-overflow -O3 -std=c99 +# +### Behavioural flags +#Use double precision integer (enable in general) +DEFINEFLAGS += -D_LONGIDS +#Use normalized bias model +DEFINEFLAGS += -D_BIAS_MODEL_2 +#Use linear bias model +#DEFINEFLAGS += -D_BIAS_MODEL_3 +#Use new lensing method +#DEFINEFLAGS += -D_USE_FAST_LENSING +#get transvers velocities +DEFINEFLAGS += -DTVEL +#Generate debug help. Only useful for development +DEFINEFLAGS += -D_DEBUG +#Use double precision floating point? Set to "yes" or "no" +USE_SINGLE_PRECISION = yes +#Add random perturbations to kappa from redshifts outside the box +#ADD_EXTRA_KAPPA = yes +#Compile with HDF5 capability? Set to "yes" or "no" +USE_HDF5 = no +#Use OMP parallelization? Set to "yes" or "no" +USE_OMP = yes +#Use MPI parallelization? Set to "yes" or "no" +USE_MPI = no +# +###Path to libraries and headers +###If two or more of the dependencies reside in the same paths, only +###one instance is necessary. +#GSL +#GSL_INC = -I/add/path +#GSL_LIB = -L/add/path +GSL_INC = -I/astro/u/anze/local/include +GSL_LIB = -L/astro/u/anze/local/lib +#FFTW +FFTW_INC = +FFTW_LIB = +#cfitsio +FITS_INC = +FITS_LIB = +#cfitsio +HDF5_INC = +HDF5_LIB = +#libconfig +CONF_INC = +CONF_LIB = +#healpix +HPIX_INC = +HPIX_LIB = +#libsharp +SHT_INC = +SHT_LIB = +# +########## End of user-definable ########## + +USE_FITS = yes +DEFINEFLAGS += -DHAVE_INLINE -DGSL_RANGE_CHECK_OFF + +ifeq ($(strip $(USE_OMP)),yes) +OPTIONS += -fopenmp +DEFINEFLAGS += -D_HAVE_OMP +endif #OMP + +ifeq ($(strip $(USE_MPI)),yes) +DEFINEFLAGS += -D_HAVE_MPI +COMP_PAR = $(COMP_MPI) +else #MPI +COMP_PAR = $(COMP_SER) +endif #MPI + +ifeq ($(strip $(USE_SINGLE_PRECISION)),yes) +DEFINEFLAGS += -D_SPREC + +ifeq ($(strip $(USE_OMP)),yes) +LIB_FFTW += -lfftw3f_omp +endif #OMP +ifeq ($(strip $(USE_MPI)),yes) +LIB_FFTW += -lfftw3f_mpi +endif #MPI +LIB_FFTW += -lfftw3f + +else #SINGLE_PRECISION + +ifeq ($(strip $(USE_OMP)),yes) +LIB_FFTW += -lfftw3_omp +endif #OMP +ifeq ($(strip $(USE_MPI)),yes) +LIB_FFTW += -lfftw3_mpi +endif #MPI + +endif #SINGLE_PRECISION + +# for fftlog +LIB_FFTW += -lfftw3 + +OPTIONS += $(DEFINEFLAGS) + +INC_ALL = -I./src $(GSL_INC) $(FFTW_INC) $(FITS_INC) $(HDF5_INC) $(CONF_INC) $(SHT_INC) $(HPIX_INC) +LIB_ALL = $(GSL_LIB) $(FFTW_LIB) $(FITS_LIB) $(HDF5_LIB) $(CONF_LIB) $(SHT_LIB) $(HPIX_LIB) -lconfig -lgsl -lgslcblas $(LIB_FFTW) -lcfitsio -lchealpix +ifeq ($(strip $(ADD_EXTRA_KAPPA)),yes) +#DEFINEFLAGS += -D_ADD_EXTRA_KAPPA -D_WITH_SHT +#LIB_ALL += -lsharp -lfftpack -lc_utils +endif #EXTRA_KAPPA +ifeq ($(strip $(USE_HDF5)),yes) +DEFINEFLAGS += -D_HAVE_HDF5 +LIB_ALL += -lhdf5 -lhdf5_hl -lz +endif #HDF5 +ifeq ($(strip $(USE_FITS)),yes) +DEFINEFLAGS += -D_HAVE_FITS +#LIB_ALL += -lcfitsio +endif #FITS +LIB_ALL += -lm + +COMMONO = src/common.o +COSMOMADO = src/cosmo_mad.o +COSMOO = src/cosmo.o +FOURIERO = src/fourier.o +DENSO = src/density.o +SRCSO = src/srcs.o +IMAPO = src/imap.o +CSTMO = src/cstm.o +KAPPAO = src/kappa.o +LENSINGO = src/lensing.o +ISWO = src/isw.o +IOO = src/io.o +HPIXO = src/healpix_extra.o +BEAMO = src/beaming.o +PREDICTO = src/predictions.o +FFTLOGO = src/fftlog.o +MAIN = src/main.c +OFILES = $(COMMONO) $(COSMOMADO) $(COSMOO) $(FOURIERO) $(DENSO) $(BEAMO) $(IOO) $(HPIXO) $(SRCSO) $(IMAPO) $(CSTMO) $(KAPPAO) $(LENSINGO) $(ISWO) $(FFTLOGO) $(PREDICTO) +#OFILES = $(COMMONO) $(COSMOMADO) $(COSMOO) $(FOURIERO) $(DENSO) $(LCO) $(IOO) $(HPIXO) $(PIXO) $(PREDICTO) $(FFTLOGO) + +EXEC = CoLoRe + +default : $(EXEC) + +%.o : %.c + $(COMP_CC) $(OPTIONS) $(INC_ALL) -c $< -o $@ + +$(OFILES) : COMP_CC := $(COMP_PAR) + +$(EXEC) : $(OFILES) + $(COMP_PAR) $(OPTIONS) $(INC_ALL) $(OFILES) $(MAIN) -o $(EXEC) $(LIB_ALL) + +clean : + rm -f src/*.o + +cleaner : + rm -f *~ src/*.o src/*~ $(EXEC) diff --git a/.ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb b/.ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb new file mode 100644 index 0000000..b2d9d3b --- /dev/null +++ b/.ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb @@ -0,0 +1,813 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "31b70d10", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import pyccl as ccl\n", + "import healpy as hp\n", + "import matplotlib.pyplot as plt\n", + "import libconf\n", + "from scipy.integrate import simps\n", + "from astropy.io import fits" + ] + }, + { + "cell_type": "markdown", + "id": "1e7130ab", + "metadata": {}, + "source": [ + "This notebook shows how to generate a CoLoRe simulation and analyse its outputs." + ] + }, + { + "cell_type": "markdown", + "id": "04bfc9d6", + "metadata": {}, + "source": [ + "# 1 Generating inputs\n", + "Let's simulate a set of low-redshift tracers:\n", + "- A galaxy sample with median redshift $z\\sim0.045$ including RSDs, lensing observables and density/velocity skewers.\n", + "- A set of 21cm intensity maps.\n", + "- A lensing convergence for a source plane at $z=0.1$.\n", + "- An ISW map for a source plane at $z=0.1$.\n", + "- A custom projected tracer with a kernel $W(z)=(0.1-z)$.\n", + "\n", + "We start by defining the properties of the CoLoRe simulation box and the linear power spectrum to be used." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e8c2d567", + "metadata": {}, + "outputs": [], + "source": [ + "z_max = 0.15\n", + "n_grid = 256\n", + "csm = {'omega_M': 0.3,\n", + " 'omega_B': 0.3,\n", + " 'omega_L': 0.7,\n", + " 'h': 0.7,\n", + " 'w': -1.0,\n", + " 'ns': 0.96,\n", + " 'sigma_8': 0.8}\n", + "dirname_out = 'output'\n", + "os.system(f'mkdir -p {dirname_out}');\n", + "\n", + "cosmo = ccl.Cosmology(Omega_c=csm['omega_M']-csm['omega_B'],\n", + " Omega_b=csm['omega_B'],\n", + " h=csm['h'],\n", + " sigma8=csm['sigma_8'],\n", + " n_s=csm['ns'],\n", + " transfer_function='eisenstein_hu')\n", + "k_h = np.geomspace(1E-4, 100, 1024)\n", + "pk_h = ccl.linear_matter_power(cosmo, k_h*cosmo['h'], 1.)*cosmo['h']**3\n", + "np.savetxt(f'{dirname_out}/pk.txt', np.transpose([k_h, pk_h]))" + ] + }, + { + "cell_type": "markdown", + "id": "df2bd0c4", + "metadata": {}, + "source": [ + "Let's generate the inputs needed for the galaxy sample" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d430cafe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.04513716654216523\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Redshift distribution\n", + "ngals = 1E5\n", + "ndens = ngals / (4*np.pi*(180/np.pi)**2)\n", + "zs = np.linspace(0, 0.2, 1024)\n", + "nz = zs**2*np.exp(-(zs/0.03)**1.5)\n", + "nz *= ndens / simps(nz, x=zs)\n", + "\n", + "# Linear bias\n", + "bz = (1+zs)\n", + "\n", + "np.savetxt(f'{dirname_out}/dndz.txt', np.transpose([zs, nz]))\n", + "np.savetxt(f'{dirname_out}/bias.txt', np.transpose([zs, bz]))\n", + "plt.plot(zs, nz)\n", + "plt.ylim([0, np.amax(nz)*1.1])\n", + "plt.xlim([0, z_max])\n", + "plt.xlabel(r'$z$', fontsize=14)\n", + "plt.ylabel(r'$dN/dzd\\Omega\\,\\,[{\\rm deg}^{-2}]$', fontsize=14)\n", + "print(np.average(zs, weights=nz))" + ] + }, + { + "cell_type": "markdown", + "id": "063c53d0", + "metadata": {}, + "source": [ + "Now let's generate the input needed for the custom tracer." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "49e3c406", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$W(z)$')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "wz = (0.1-zs)\n", + "wz[zs > 0.1] = 0\n", + "np.savetxt(f'{dirname_out}/wz.txt', np.transpose([zs, wz]))\n", + "\n", + "plt.plot(zs, wz)\n", + "plt.xlim([0, z_max])\n", + "plt.ylim([0, np.amax(wz)*1.1])\n", + "plt.xlabel(r'$z$', fontsize=14)\n", + "plt.ylabel(r'$W(z)$', fontsize=14)" + ] + }, + { + "cell_type": "markdown", + "id": "9fb3ddd0", + "metadata": {}, + "source": [ + "Almost there. Now generate inputs needed for the intensity mapping observations." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ddb406d4", + "metadata": {}, + "outputs": [], + "source": [ + "# Constant background temperature T_HI = 0.05 mK\n", + "tz = 0.05 * np.ones_like(zs)\n", + "\n", + "nu_ref = 1420.\n", + "nu0 = nu_ref / (1+0.14)\n", + "nu1 = nu_ref / (1+0.04)\n", + "n_nu = 5\n", + "nu_arr = np.linspace(nu0, nu1, n_nu+1)\n", + "\n", + "np.savetxt(f'{dirname_out}/tz.txt', np.transpose([zs, tz]))\n", + "np.savetxt(f'{dirname_out}/nuTable.txt', np.transpose([nu_arr[:-1], nu_arr[1:]]))" + ] + }, + { + "cell_type": "markdown", + "id": "8a8cf15c", + "metadata": {}, + "source": [ + "Finally, pick a source plane for the ISW and convergence maps" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5a9fba94", + "metadata": {}, + "outputs": [], + "source": [ + "z_source = 0.1" + ] + }, + { + "cell_type": "markdown", + "id": "7c76c433", + "metadata": {}, + "source": [ + "Before we can run CoLoRe, we need to create the config file. We will use 1st-order LPT as a structure formation model." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "09d51cc4", + "metadata": {}, + "outputs": [], + "source": [ + "config = {}\n", + "config['global'] = {'prefix_out': dirname_out + '/colore',\n", + " 'output_format': 'FITS',\n", + " 'output_density': True,\n", + " 'pk_filename': f'{dirname_out}/pk.txt',\n", + " 'z_min': 0.0001,\n", + " 'z_max': z_max,\n", + " 'seed': 1000,\n", + " 'write_pred': False,\n", + " 'just_write_pred': False}\n", + "config['field_par'] = {'r_smooth': 1.,\n", + " 'smooth_potential': True,\n", + " 'n_grid': n_grid,\n", + " 'dens_type': 1,\n", + " 'lpt_buffer_fraction': 0.6,\n", + " 'lpt_interp_type': 1,\n", + " 'output_lpt': 0}\n", + "config['cosmo_par'] = csm\n", + "# Note: if you need more than one sample of galaxies/intensity maps/custom tracers etc.\n", + "# just add `srcs2` `imap2` etc.\n", + "config['custom1'] = {'kz_filename': f'{dirname_out}/wz.txt',\n", + " 'bias_filename': f'{dirname_out}/bias.txt',\n", + " 'nside': 64}\n", + "config['srcs1'] = {'nz_filename': f'{dirname_out}/dndz.txt',\n", + " 'bias_filename': f'{dirname_out}/bias.txt',\n", + " 'include_lensing': True,\n", + " 'store_skewers': True}\n", + "config['imap1'] = {'tbak_filename': f'{dirname_out}/tz.txt',\n", + " 'bias_filename': f'{dirname_out}/bias.txt',\n", + " 'freq_list': f'{dirname_out}/nuTable.txt',\n", + " 'freq_rest': 1420.0,\n", + " 'nside': 64}\n", + "config['kappa'] = {'z_out': [z_source],\n", + " 'nside': 64}\n", + "config['isw'] = {'z_out': [z_source],\n", + " 'nside': 64}\n", + "with open(f'{dirname_out}/params.cfg', 'w') as configfile:\n", + " libconf.dump(config, configfile)" + ] + }, + { + "cell_type": "markdown", + "id": "c4c19d02", + "metadata": {}, + "source": [ + "# 2 Run CoLoRe\n", + "Now just run the code" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "80697c00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "os.system(f'LD_LIBRARY_PATH=/astro/u/wcook/ ./CoLoRe2 {dirname_out}/params.cfg > {dirname_out}/log.txt')\n", + "f = open(f'{dirname_out}/log.txt', 'r')\n", + "print(f.read())\n", + "f.close()" + ] + }, + { + "cell_type": "markdown", + "id": "69c3b9cc", + "metadata": {}, + "source": [ + "/astro/u/anze/local/lib/# 3 Inspect output\n", + "Let's now look at the output\n", + "\n", + "## 3.1 Custom tracer\n", + "CoLoRe produces healpix maps for each custom projected tracer:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "532583ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:368: UserWarning: If you are not specifying the input dtype and using the default np.float64 dtype of read_map(), please consider that it will change in a future version to None as to keep the same dtype of the input file: please explicitly set the dtype if it is important to you.\n", + " warnings.warn(\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:391: UserWarning: NSIDE = 64\n", + " warnings.warn(\"NSIDE = {0:d}\".format(nside))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:400: UserWarning: ORDERING = RING in fits file\n", + " warnings.warn(\"ORDERING = {0:s} in fits file\".format(ordering))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:426: UserWarning: No INDXSCHM keyword in header file : assume IMPLICIT\n", + " warnings.warn(\"No INDXSCHM keyword in header file : \" \"assume {}\".format(schm))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:428: UserWarning: INDXSCHM = IMPLICIT\n", + " warnings.warn(\"INDXSCHM = {0:s}\".format(schm))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:920: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_over(newcm(1.0))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:921: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_under(bgcolor)\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:922: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_bad(badcolor)\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:202: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n", + " aximg = self.imshow(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAFzCAYAAAANJxyKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9acx1S3Yehj1Vtfc55x2+77v39sRuirJiRXKkBJYgQTFNUpZkNpuSAMUOkCCwEf+Jk/yJgQSCJEcDyY5IUYxsC/mTAAEMw4iUxIKQAVZimaRIx5RMy5MiQYjtGBLCscfb995veIdz9t5V+bGGWrV2nff7bve93XfYC3hx3nP2VHuqemqtZz0rlFKw2WabbbbZZpttttl7a/E73YDNNttss80222yzj6JtIGuzzTbbbLPNNtvsfbANZG222WabbbbZZpu9D7aBrM0222yzzTbbbLP3wTaQtdlmm2222WabbfY+2AayNttss80222yzzd4H20DWZpttttlmm2222ftgG8jabLPN1EII/3wI4T8NIbwIIXw5hPDXQwg/8C3u84shhL/8XrXxFY73SyGEz3+7jrfZZpttds42kLXZZpsBAEIIfxTA/wbATwL4DIDfCOB/B+Cf+Q426z23EMLwbTpOCCFsfexmm32MbesANttsM4QQngD4swD+Z6WU/2sp5aaUMpVS/lop5Y/zOv9mCOEnzDa/P4Twa+b7vxxC+PUQwvMQwv83hPCDIYQ/COBPAfgfsHfs7/G6nwsh/NshhLdCCP8ghPA/Mfv5Ygjhr4YQ/jLv6++HEH5rCOFPhhC+FkL41RDCF86cx18CgcO/xsf7EyGE3xRCKCGEfzGE8CsAfp7X/ashhK+EEJ6GEH4hhPDfNPu5CCH8ayGEX+blfyuEcMHLvjeE8IshhHdCCH8vhPD7zXb/rxDCnwsh/AcAbgH8o9/irdlss80+xLaBrM022wwA/kkABwD/t29m4xDCPwbgXwLwe0opjwD8MIBfKqX8uyDP2F8ppVyXUn4Hb/J/BvBrAD4H4L8H4CdDCD9odvlHAPwlAK8D+H8D+GlQf/XdIDD4v++1o5TyLwD4FQB/hI/3F8zi3wfgt3HbAOCvA/gtAD4N4O8A+D+adf9VAL8bwPcBeAPAnwCQQwjfDeD/CeAn+Pc/BuD/EkL4lNn2XwDwPwXwCMAvP3DZNttss4+4bSBrs802A4BPAHizlDJ/k9svAPYAfnsIYSyl/FIp5R/2VgwhfA+AHwDwL5dS7kspfxfAvw4CJ2J/s5Ty09yevwrgUwB+qpQyAfi3APymEMJr77KNX2QP3R0AlFL+jVLK81LKEcAXAfyOEMITDvH9jwD8z0spv15KWUopv8jr/Q8B/DullH+nlJJLKT8L4D8F8IfNcf7NUsr/p5Qyc3s322yzj6ltIGuzzTYDgG8A+OQ3y1cqpfwDAP8LEFj5Wgjh3wohfO7M6p8D8FYp5bn57ZdBXiqxr5r/70AAcDHfAeD6XTbzV+WfEEIKIfxUCOEfhhCeAfglXvRJ/jsA6IHEfwTAf59Dhe+EEN4BAcbP9o6z2WabfbxtA1mbbbYZAPyHAO4B/LMPrHMD4NJ8/y67sJTyfyql/AAIiBQA/2tZ5PbzJQBvhBAemd9+I4Bff/fN7po/Xu/3fx5E6P88gCcAfhP/HgC8CboWv7mzj18F8JdKKa+Zv6tSyk+9wvE322yzj5ltIGuzzTZDKeUpgB8F8L8NIfyzIYTLEMIYQvhDIQThNf1dAH84hPBGCOG7QJ4rAMTJCiH80yGEPQig3IFCiAB5pX6TZNqVUn4VwC8C+PMhhEMI4R8H8C+i5UR9K/ZVvJxw/gjAEeTBuwTxxsDtywD+DQB/kQn6KYTwT/K5/WUAfySE8MP8+4ETAH7De9T2zTbb7CNkG8jabLPNAACllL8I4I8C+DMAvg7y2vxLAP7vvMpfAvD3QKG1nwHwV8zmewA/BfICfQVEJv9TvOyv8uc3Qgh/h///50Deoy+ByPY/xvym98L+PIA/w+G8P3Zmnf8DKET56wD+cwB/2y3/YwD+PoD/BMBbIK9cZID4z4DOTa7RH8fWl2622WYdC6Vsnu3NNttss80222yz99q22ddmm2222WabbbbZ+2AbyNpss80222yzzTZ7H2wDWZttttlmm2222Wbvg20ga7PNNttss8022+x9sA1kbbbZZpttttlmm70P9qrqzlsK4mabbbbZZpttttnawrkF31QJjc022+yja7/7f/wXm+95wKoLmQ8B6dTOvQYudpOT26Hbdve80D6d7Z/m1W9xyiix3UFc1nO+EoCS1v1cHte/LfuIcrZL5HV2tEJwEjfzRUA6tutOV1j99p/963/04QNsttlmHwt7VZ2szZO12WYfcvvef+5fw+m6RRfjbenOwQRkiMW57QJKoOXTVf1tuKP17j7dshAuv5oxXbT7G44F88X6wOONA273665n3gfsny2r34P7adkHhDVuw7Jvj5s74Gw4ZoSlvQ4CKv21Ca6JcSqYD26djNX5pmPBf/hXzmmlbrbZZh8iOztt20DWZpt9ROyf+iNU/eZ0XV1Jw5FQxnRhgE/HKwUw4ALUy5OHuqKALAEY++eMXrhnmC7ruoe3Ce0cX6vt2D3LOL5W2yDHuvtE/U28Qcu+bd9wR+sKiLLAqfDmaSq8D/oUD1boeL3s9nkIXSBlPVjJAT3dd+brZT1tsmqQc8p8TtTQeOL7Ye6Rv7b2nP/mv/3HV+3fbLPNPnC2gazNNvuw2e//AtUczmNceUsAoJiw3N0bbfzt/hNBAQcAxAlNNzDelMbzE3JZhf+8Z0h/LwXDTV1YYkC6m/V73ieEuSKZ5XJowM58mZrvp0d0Inr8UMEJACy7yMv5NwuSGJhE0/YyBL026nEzIDBNbUhzvGtDkiWgvXZzac5ndS/sd9fV5jEqsAIIbMWp416TzfN6Hza0mRmspfv2+gz3dD9+/uf+5Nl9b7bZZu+bbSBrs80+qPaDf0BrEyMPbagtjxEoLUCxZsEDgMZblE5FPT1ih7eNh+aYmzBgCaH9bg5VQmjAQTpmxGOLwqz3Z3Ue+7bdyz423dKyi3rskMsK4JWEfi9UsO7eCjRvOo9BQRoALCNWobzxru7YhyfjqTSA0AMkD7jEuwXQNWu+p9Bcs+Kv0RAAA/ZWXjgfljzVfeV9wnAztauHuq+/8R/8GWy22Wbvm20ga7PNPgj2+d/75/T/PLpBdtcZdNmWfcTpUV0eloLdTR3w3/4t1ZO1e1ZWb+zFN+q6u+ctgikxNN4WAWZ5H1f7GW7bbe1AH3JBSbWNJVQgUVJozqcMQUNodV8GAJ5aMGO3bbqzHsgytvhrOoYGmOZUOVqHd3JzvsOxBVjWu0XHdoBsLup18uT84MGZAV8I7Qn452JF6F9xwOq+43FuljXHQRva/Nm//aPYbLPN3hPbQNZmm72fZsETgHYANoNo3sVmoMtjxHBTB8YGeJj1PFh4+x8bGm7R7p16vIu3FsTJcopyM9haYNR4ZqzH7HrXhMgaIFDK+rsBAvPFcHbdEtCo890b3tb+mW0LVl4g/W4ubYnO+xbRAEZ7DWfDSzs9au/D6XHA6VHd7PCNus/909IcIznw5YGM9W7Z69us50GY20fzzBjQFUppwqUegNnvzT0/Ls33sJQmDOk9cnY/P/uLP4LNNtvsQdtA1mabvZdmQVWYXAhI3pYYmgGypJa7ZAf55ZB0oPMDp3CWAOD5b0wNn+jwjaLhrt2zpeEyRcsjmlovTTxxO2JEOJk2jXXny2GobZK2Sn8R2nOzXUweq0SCDt68XRlCy38y5xIWrIGUvRTZ7RMEqnwG4Tn+lAWqeRcwH+i7eLLmAy27/0R7/a9/re5kvM3qpYrHGt6s58D/x7DmXsml832uxbIWbDmA6j1cq/3IZsFc49ACd+uJTPdzcy/8dbPPoQ3//twv/OnucTfb7GNsG8jabLNvxX7wnyJQFUr1BKkngAeqEoIOTGWIjceINg51OzN4Wp5VKFVSYL6MmK7q4Hb76YDhnv6/eDPj8FYFR8nzo8TzwoN2ZCAoA2lJAcFuYwbRMkQT5utoSnH7cooa4oxTXnnbLMBqiO5PqqcrLqXxutG+aoagELyXXawA0gE6m+WnICVLlmBdtzTettrW+RCVpyWZjdMj/r4DIl+myy8X7F5k3m/b7jA77tYZT1cJ4Sw4ggeL3rsl+5DnzYHxUIouC7k0wKi5NwZ47d+emn2luxmFwVy8mxtPIK3Hz4UJBf/8z29k+80+9raBrM02e8h+6Pt+vA5QMqOX7ya0Ymf41buD1WCUx2i8GnYBf+yi7kcG/PkQlS+Ud8BwS+vKwH7xlXv1TllwQT8UhCUbb0/nlc2d8J94mMakv+Vd0oHWh7WAlme1HITAhdrNyLWyuK9UICTn7bW3xPNjw31hsVyxQPdCwIUDGTlVMn1JYSViWmL1NJUUtFeTDMU8BJVnkPuw7ID7T/HyseDyy7TN/mnhz6X2juKpyhWAhVIM8KttUWA4uDZaEJYBRMfnCqF9FmV7WcV6vyJW1yCnSq5XsBatLEVtm9y/EupvksVYQqiTjTEqyV64cwoyywbCNvtY2AayNtvM2g9934/r/zrwyuCV60BVQusN0ZCNAVY+jBOnvB78eD07qN6/PtTjAbh/g/aTh4DrL9EAlu4zDm+S+2rluTBhyiYTrceZ6nDESuR2yyml2GS8Wa9IwyMzmYIl8Pk7gEVtkv221+EcZwmlfg+5tlkBiZxTMODBAAqgBVp5CC0f7EylVgJk9P+yqyBQdKumS+D0JGC+qg1//b+s/w/3pUoqhOpFDOZ8FIAt6xAj0IKtEkPT4zb8Lws6x6gguAyxBWcmrAug3mOn6aXJFrno/z3lfAGNFnDZ0LQF9SWYJAc+ngXOG+ja7CNoG8ja7ONpPTAFoPXqxP7oe46T8lDGVt4RAPEeCmvTVQUpd2/U/V5/qYb/ds9qOr4FU032mD2fzsBYd9BfZs+vyQq0/zdhRHOexiMCtNl/Dc/H9C8+LKhNN2HL4EBXzyNnpQmac3CSCJaL1HDjDC8/p6oKb0GYlXk4Par/T48ClkNdb/9W/f/6y5bvZLhxBmBY7905vSz/7GRzP1aZlZ3fW1B2puv217VzTW22qw2v0n7PHM/sdrhrMx3FFnMv7PXYwNdmH2LbQNZmHw9rQJXPjtMwoNkgVh2qPPqie7Kt/169XOrV8dlZZqAMZiBZzGAlAqIXb7bgqtnWDNDpzuggzX0vQtuGM64bab8HZgZsClgEsCK4axmaWENXLdCs/7egouUMCW8qTVkBI3mwzOF6ICv2Ad1Kd0o8M+FhkGXPTX8390AA13wwXK0DMD6r6w9Ga8vKZYxGZiPMuevZeRWwVQzvrzHrmLKnUtokAnkX2qQB85w1vDHbBvtMRL1n81Xqlizy+5J7Od7MdVKQgno2VzIeBrBtwqqbfYhsA1mbfXTth773z9I/0ZC5U6gkbzswRdTQVQqVXxSChmJKqqEXH7oRUGU5PUAFA3msA5Hlt8xXCZHDKzef3VFT5oL9O4sOfMPd3LRVOC/p1oErGZeaEFwbrpHz61rPExRj81tJTmpiF9fbGMsp1DDdWP9vyOHi/TBEeBUgnXMNpS3Wy9gBVF4SQv73gED+H1uAksfKe8pDvY81k9KAr1CPYT1axzfq/1Y+I2Ta/vLra6BVYj1f2WeTDTrldVYmWjBUTLtQ1sutlcgAltcJswnB2v1rqDe0y807IM9x3lW1fguQlouknkALvoiAz8Byqny63dun1sMq4doxViA6VemRn/v3/lT3HDfb7ANiG8ja7MNvCqbgBmKgAo4hth4rCQWZzrshsk9Zwcg5r0ixnhyh3uSCRQCXkRGwAwNKaba9+S5KXQuF5BYA4itJWn0JQUNnJVTP1YpvJWDEcq2ch0MARSil/d+Aqub/DlhZDtXlY0GLJ9zLciWQp6pdFeeq3k5K7vJ7bjIgG4+V3f/LQJYBAMshVTBgrjtxs+j/xYOv0gIk2qcBXIb/ZcOJL77byiLU38VLNl0B4wv+LQFXX5aEBWD/Dv+/C1qeqMSA4a7+r5mpKdQQqgeXnneHlgwf5qLXIZ4WDQOHJaNJfAidawzDhYsOfCkxvr6DeV+fFZstK57bdF9UriMswHS9DhmGpYbJl7E+n2UIzYRivK2e3w18bfYBsQ1kbfbhtAeBFbDmU+XqjdLtDJE9HCeUxL39GU+PDRsWCy5M6Gu+qOs0BGDxhplB/vYzteLxaGr+pTvL2zG/W2kFwx1rdIzmzrV4RRMtLKuJ1dbHowEz76IO0pa87kVCxSxvZ7CcJCuMavlXNovwWwBZutkZb5tXztffxzVIecjssTT7cF/Do+m+ljE6vl7XHe7qPi7epHOWAtlA+xw0nq3F3u9+OM9ar77l+iReYSVNjOgfqNUF6z+H5wC67HO4mTFfceLHnHF6jf6PU1GwG5aiYdWSQjeZZANcm31AbANZm3147CyvylqHzN1wUmQgCAHhKFpAhnNlw4mD4WXthpriPgTSCgIBEgEceQhVkPLUb58MLHef2tX0dzuY3tUMxLPAgwcwSwYPywMZhXy+PWs8c7thvTxUYFqGqn+Vx1gFQ41MQyOlgApqll29Ng2INEBLMwjnXPeXW49b9xykfb3wGfqDuQ1XAVDJiZao314HgL0rHW8PXSf6ed4H1dXKu4B0X3R/KgVxTd4rANg9g/aku+f1HHfP16HFdF+fj0bS4iXg+pWAlr4b3lv18GY9jp/l1vn7puHZfdJ7Pl8N+rzPF4NWO7DgdzaJIW24mdtqEwPMIcebDXBt9h2zDWRt9sG0z3//T+j/UTlUdXkT2lhK9T6VQl4sExq0WXiNxarjoyFE5WKZ2ThzUsTDk8dUB+5i0/FLEzYRfszC5WTyGDAZlfbhprYx3VfldRngeqVtmsHLgqxSWu+W6hH1COI25Jm6YdGq1yTgIyrpfTnE89yzwWTlpTZsF2YOE9qyLoYbpKAhkofGSmeIFhbtN7QgQHW8qgaZbcd8WflCeR8Q5gp24lQwXdUi1NNlVDC4jDW8afcHVCJ25PG7CaumKvMAEJiyshUC3k5PKEFAAFk61lBiWAqiodyNd9UbtntOILTxdIlnJwT1dCnfCmjDn/aR6MhhxDkrSG1C6EayIxT3jsT6nNAKLaC1ID8suQHO9lkNc9bnLCxZvadhzq7qgOGAHRLiKTf3VLl/p6yeMZiwuACvMBf8jb+5KdVv9r7ZBrI2++BYD1gBdQBrQhB24t4R9Qw590MgcR06IkK7bH8mzHG5q4dgz1XIpWZnnUmJnx6Tu6IMQcNm3nMl1gUfQ0DkGX6YlhZYynZNSG3t3Sgx0vVAB2Dp//Wc6g6qNtR8OerP1qOgJGubgHmmW1GPTqggpVFDt96YcxIDHZO2N54s04blYM5Txlsz6FtAZP9XTxaDZQBdoAVUEBUKkIcH9oXqwQKA42sMDOa63e6pfQ7quoMpRC1CtOe8gqHhlFUA1S0t1FmXzqlzD7KZ3FjvaEf6pCf8ut5uff+bclTn5ETk2S2lyqOcCWPayYrywkwbxuf1Im+Aa7P32DaQtdl33oRfda5cyMsG3NADRvb57ehdWSmCc/wR6cjnq9GsuwZCtMN1G09vVGAmGljjzWL4J1ZUyDSXB5t4XBQMRFNHsDv42fN9GUAZ1kCTdrwePC2HRjwCUtNv1YS0BhUCrHy71Vs3nxnUe4c4c1qq33RGkyvvLYhaPwvLzv6/PvBZSQK+fY0chbmldr9V+bz+ls3y6Vo8R/W34bYPthKDKRtOTMczz6XzjtIxOt4tu/xMjcfacCeBItapZNAA+ZcALvsexnt+3i3wHvoTBOUHWjmOMzIU4tmbruuNsM/dwFyuv/G3/sy6rZtt9u5tA1mbfXtNvFWN18LMjsOc13XcbKaTSBUYHasyxMZrA7QcJaDyrjSTLqNRNFeVdlOfTwbtkB3pXNpmn36JVqaIu8/Q6LkYAvUoHodiwJUZCOzAKGGzeKwaQs35ZFCIz4ZJl9J69JyVMTUSFd0wouFeyfW2XiAh9ZdkvIB2QLXnw4OZFd9swIqEqc4IVuqpDjVM2Gwf6nJd19YrNCFFS2SfmeOz7Ez2oQFhFgRVuYl1u6zZ5U1JILk1Y+gCNSttICHDHshLpxr+QqkhSvFcxaVytmzpHsACKtOsDvfqXDFq5f+dA+6dCY5dt5ep6oulA8L96oDwk/Hi6nPQZkFqwobhFLYF2KtnTc9bMxfrvuT5bqQmSiFPcgibl2uzb8Y2kLXZ+2/nwoDSQb8rz8zgOkygHSCWDv/KhsiEqGxT+a3A5s7GvcgaAvoZr5dkHj79R6vstwy4u5vKt7KhQtFcsgDLZpGpVIPxYvliwSvTEJfx6lhisqtNCLgwjABMUyJn6ZDdLSG5V5ZmaDIkW94P4O55x8PRy5TrajjBAj7rlav/WpAlwNdzpvz/dhubwaccLHtJzSMnniwLdCxYb3TW9AS4bcaz1VjvWphjjnfi2TIVAKRGYpMEYbbvTBR6nsamRNPLvFqd/TRadFavbFw/NPY5lOfT9hfxrl/tQDdpsn/XgKt9zs2EQN5v68Hd10mZrmcSDTbAtdkr2gayNnvv7fO/98+tNXMMcVlq5q3CFkb0UGaoSlg+DKSbZD0+x6kFEyFUz45mfZnf+HfLFSkpEsFWybZllb1FBN/2US+7qGVAlouEZ99DnfqBtY7iXIEGcbeKkoUBFmAcKjE5Mhk43U46mIXTvPb45FxBowVKtt5gCG3WoOGcFc6etATmPEQgtACzxNB6qQYCWPOheoIsD0vENtMJ2t50LI0GVnMeYrEtbKzHEywYw2pwLwloBDfFqzUGBxTq77K+qLQv+/qbAquhtmHZ1f3KeZYIpPu6DWk8VXL8sgtIp6LgebgrKEMFRHmg66PPwMLHXFrviZDjVbIgY5UNOR8qUEsnIsUf3qnvzngrmZr13fL1EpsswmASFDpgC6jAZhXWl3dQAJfX6ZJzi+ttVBbFVgkY1kXUg9GZi/f0XqwyKn0dzlJQdkMFekNseWJcVFsTKnYRWNrnVZ8t0b4zXnbpi8oYNxX6zc7ZBrI2e+/s87/3z9E/tmO2IQAhttrOsQOwVPTyYqxkWJ5tRgM8FEh1PDUlBfQ4Ri+bQTela3plTZT/E5VE+/y76XO4q14Fq3ulXoV5/brYAcsquEstwmbGroV+zX6k7Yak3szoZbn1nDR6VjzL39VMyzoIVUCQjefq+LiGDVfns3B4CxZk1rY3GYI9B6YBV3Wn7hOth0S9TnaTXsgKJK8AnAkRBiCndp/Lvu7XZk1GBpMSKlwO9TfrZUqmgLKYbFNS3af+FtHtlm0YUsCWaHL55Ye3aae2pI8Ke3a5WfU4veVdoFWwDjl3io2/TH+rS2aHSS45UwRb35U5r6U9zmTUalhRqzPYbIQ6KbQTrnpw+rAcRQ33lnqNNrC1mbMNZG32rdkP/r6f1P97Wj3q7rczTzvj7dTLWy7ItaA1+bIhflttonPgir/rQN0JR9kOVDrOYkupzLnxPFGDgoIrGYRvPh0VXFnPFeCyvVi6gDwz68FtuGHNrnAGYC31Our5WhFOAVk2syu1YZJQ+Piz89xJLT9bB0+9Q/Uaixq3LZLcpuLzZToV5rHl6qEx8hYqD3AOZLGHoemejLeKric0U7CpMyirqxeoeoBCOQOyRtC9kGMYoCVcKQTjiRLny4l+G+6gxaHjqRLa09GeGC+3z4TxVMmArfwuA3BpEG/BjgVa4okTUHV4u/KMhttc2yscLiuPoc97qWDynOeR76GCnVxeDraAZgKlXtgOeb5E+8zWd1zBng0dMjE+lKLk+GD7lQ6nU7y9VrbEKtL7EGTeJZN1LBeqvifVu2Wuo62xuBW23mwDWZu9W/v89/+EdoCtzEJANBIDPQ+MlQ+wITwd8G06ty167D1Xsh9D4NZZqtFlqmKInRMppc5KTVtE9NOWnclC/i7A/SfGZjfpWNYhMFTdokaU1Hlz4v2s4ZB4X+sT6mCxrLe116FRPTeCqlW5XcBVBUtyrVU4tbSeK9pXBagWjIgERTYeLMtdErXyOBfEU2mAV1PexXU7NiRYQ3M1XKlt2b3E+5UqZ6rxZMXafg0/c7vnC1RgbS8xt1uy/o6v1980DLkrSHcBy0VBPEkj6j6SeYQDt0vCqUAFPaTBJdeunlM60bXWAVyOa0KQCjQHYGHwO76ojZBSPcPZLE+5SOJFDlpLkwCUrFdBhpLGbRbiYraR/fXGEJt8AbOuM9Wk6wmd9mQ/cq59jmAtaYMFXWaCVvmHaxFe61Vual/uq+aWJlZY/uIY6Zqq97N6sX/u39+EUD+GtoGszV7NhLxekqmfZjwfCrDmClJoYWnCAGINZ0hkCiQUYQGazSKy4Ip/y7tBPTQAXqoDJGbd/jaz0YcelotBn/Lj66x5FWvKvIAp8aakUy3m2xb55XNrSPRck25MCrKUuG+FUD3XxXqxZHZuuWn2enfqDQppXUAWgEYVnc6xcq6my+pdEIBlswslFNWUhJGB2ko0yCNhx1crbsmhMvUUjBW4CFFdvDbpZIjiPZCkYbhSQ3+8j7AUBY/qqersY76oDT2+Tp95Zwb4TtahXLN0G9SjJcBpuIHxOvF6x+ppk7CleKQEZFHD1sfqZUIuh3qPpHbi5dcXPYaArXTM8JIKccoKsupEynqE+FCWAiAq/aaI9+q9s9nBGvLGOknD8rfkuTUApjcZonYL4uQ2GLDVDSU6T3gZooInmZgMT40b0njdyp5uYN6lejwHthRomWUWnG5g62NlG8ja7GH7oe/78QqCZgIQIRftoBTUeKLqQiKBjUo0Kz+XVAnKeYg0G7XhRD/rNMRVFR+U/nuIDVdDwny083YAsNIEVsAwLLn1fonnhIFJKAX3rHlls7aiUcOWc4xTHaCkwHOcFmrDnI2XqoCUzTtgymcwiop9L1ToQVZsvVpyzSQEW1Igz4kfe1KgAs5LJW4jkpelApwaxmvuKQgQWN5PnAjABUskjkHDhTWUKw1oPWolViAnGYFCCF/GoFynZRcIqBhye5oIuAg3bD4EDPcF02VQwCMAZT54uRBozUEbAjy+QS44C7IQaNlyqIT4+aog3Qtol/0UjC8C8lgw3NRzHG5rO9LRhC0hv7F3a+LrJI/oSL/NF0Gfx/kyYLgrmC+qB3DZA/u3af3Lr8lzRiBOzjkqZyxAiPB10kNArBGOdZ6tZlLjfjsLtqzciICtHlmeeZX6rgYo0AqGxK/v74osX7MGu9Iwct4pVJDFlQ1UugHscbbSMaCJjCSM2PMvIWj4PXPoMx0X5DGuinFvWlwfC9tA1matfeGfIGFQHfBNiRrbQemgbsN+zmMVlmz4G/yj1AMMoUoTOFAFoEnBltmsAjvTSSdTCDZMCwE46VwtB0P2a8qF1B/NeTnPz/H1sQKJY2nWt2EuXedu0eXp3rSNz7Vb7mbJBEDkWgkhd8n1/05xZF9zUfdrywWhzs6Xy7Fm4ylINffP6AiJzZcmm9BFbtRbNNNxk61DqADBeAE6NQ17AqbWS6ahQvYANVl/Z7uvamkisBEn4/mS7Uob7gSA+ar+X7Wr7LU3bVUvoIDLgOUiI57oE6hAK91FlEgerJDlt7rbyo1a/5buCJimU1HAawHgsqd7Ib/ZXlk8Z+NN/e3yK9S23U024dx6bUrkcKQPeQlmaYBVXWdFlDcTpy7gsmE9tM9Crxh18x7Lc2uOqcfKnXfMHasROTWATwWIX+ObL/fgfq4UBnmHOVsRANU2BR4YUtG0rSk3xfv7mf/oRx/eeLMPo20gazOyL/yeL65IqVS3LPTBlanxB0ClEGSmJkR1kgtow3zhNOvskrYNKxe+eF4AKR5rQxgZ4ZTXZThktgm0Hp4hAplqn608Rz50EALyPqHEWmfQqmmjlFrPzohfCgga7nj2e+Rz5CLUMoPvlsDxg8I4UHtTquFDWSfFNZDqyVaIRbo3cl+Wi6EPsnKh8ykt2Fn2oQuwqEZeYe5QBcnKRXMga6Vlpc+NAXlDXUYFl+uyZRQvnBy/bc+K6xWxkg7InM1XYh30fahuuqbPNAHH1wqGu4D5SsJQ5E3zYU8SZy0gGQwBDLxNCcAChKV6t9IJiFNAPFaQoucQTZaitpG9XvxKxIn+L6n+puceaH2bwUheQS5EjQqySgo4vE2hRPVoDSCvooJ2vh6nrLUQm4lFNt9dqSQCXo4kL/YQ2BrqMw5DBQDQcC/1Xdei7CYUL++LF+n1YAtow4GpzUBcLgYsu6jh7/Htu+aYiKZN5j2j762317axDJEmhaPLZMwZP/OffBGbfWRsA1kfV/vC7/4i/WNDVmJee0rMASslu06VW+QzdLoeI8mEC0E7GcsZmp6MVCCYO9eRvVXhVD1j2qGeA1Z8bhp2sFwQtL9l6zXjYs7zZarhLxuCNEahU97dcc0nq3yVpX8tLHi1XikTcn3IFBjG2AfCcp5oyb2N0GKpQKMMsSGJ07oB04WA23Ub5PyHIwGu4ZhNuKkCLS0o7cBVk6koIde58pSkPRIOXHYVKGkbHOihndR/lx2Fp/MYGo6WPQfhT50e1d/nSx70RzkPAaTt/uXYtJ+i3isBWoABWabGoYQVoyHDCwAsga63Aivr4erch4nbHU8VWOUdhS4F+GltxGcVNF9+mZbtTYmeRrMrtN995myzTD1J7brUrlZjq9sv2N96ArPyv9AVTAaxtoszc0sM9f0T8GYmjAoi+V6GpbS/mXaUIaqX3orw7p7SjdOJFAxIcwKoFnDpNbBVJNb8frUNdH2o7SzIeuCWb/ZhNwFYYVmoY+QBv8RY05yHWIU8h1i9QWcAVlgKAnOP/IwWXKy5xMiilgSuPMCanoyYnozE/YnkFRHPSJhLA7CKeKJkJtkhgOtgKLNln3UUIwGsACAQwIpLRt5FxJnCDz2AJedoAVYJrwawSghVjyq14dXmGD0tMTNAEK/J3K+wfpeD247W42W5KOiJ2ja+bAaECMDq1SvUTMBE2+YBOF3FZh9lMANax3tV9xV0X3kgj5WAgizSGm7AX5+w2Z87BHnlmFcm3rBkPD0CbHtgWoFe9V7oQCzPwH1APNHf+IIOvntn3Y0KsOqGOvX603XLg/GWmV1VT+N6FwIMQwHSMWC+LI0OGMD8MrYX30M/3r2xbmu299clPMg7WiJ7HQODfvmNQ73yl3ep+S7PMLXLeGQj6G8p5Ak2HEnZVsFWqX1ClVUYoJl/KSDkrH1FsBMb6Q+YD9Y8k/ZSsMc93U2I04J0zFV8VqRfUtJ3WTiX9f2vUQHhp+Yhkrd8n6oKvrTHyNqIfeH3fHF1bzb78NvmyfqImXquUAd+azrgdwbAXp25Hk9rZdzh2Lp54oa3npXTa+RGEMJxPBYFV+m+9RAp4ZVBH/1oR1ePiELlbTi5By23EUMjMqqbGv6EPX/yikhYdGk+rYCpvc4WZNGJBawK6qoH4CEkYTxYDqT17oWSx034tdUXo4+ZZSrkHkyXUb1MkmWn4pbmclvQI94NkS5QgCxORyagA2jI9NouDeuF1bX3GlahoJGS8O2SfZ0eBw2dqVfI8ZCs0vt8WfcxcZgw78WjWQ/gMwvFy9V4+8ztsPIL9rtVgLcgi/4x+7cJt7NbX0DjUPlj6ST3bn3PLDgbGBBefoU9Ws/ad70hvsvz2ehomXZJ2E4nV/V7LXTuPFod4nyTBGJ036Q93rw3C6gerXBcWr6i7B/QCUoopX0n3HFstQT6jCux1PSCvVo29Cj7tMK5u9bThWy4m3ItfHudbZ6tD5Wd9WRtIOsjYF/4PV9cD9zqDRGFQqxmTmGu/CebPSjaUSHnJkQlbngrQaAkVRt6FF2aw4hln7DsI/Iu1Ey0XJT7EDv1ApvOjkMGIRfigynZnbleHTmJEgLyYaicD3vOhcJowerfDAKk6qxU0rRVmiBSW0sIlYe2FPUOel2gEuPqXjTbWOukm9MxX+JoNtpA5F2ITeHrHg8qj3Qv5gsq5Hvz2Yi8qwBg/05pxDXVsyL3ZKAMu7wDBpZyWPYBuxcF00XAeJtxuo4q86BcojM1/IYjZTmqhIACiuoJ0n2I1MR1wCAEbwFZjwwgYm/b7jltGxbaz3IwQNCArFW48EQetvF5QBkK4jGgiCTDLYG+3XMqeQNUYJTuCjJnQc6HmvU4PQrKr4pHunZxZu0uc43Tsf4/3HHbJZQY6bilzlmw7G2YjkHzIz6XoaCMBWWfEe4oO273VkWuF18lj59kI1ol+sghfCvroABspusroqayTpxq+LiRfnCFqYXfRfsQzhhlHmfOIC5jlU1YTayMFpZk+algaVN/0U12gNZzZTz5dN6U3NL3vsq60leSZy3MVbNL+0kphzXnOsm75IzfUM/HJssIH029q9IXS3tDwM/8xz+2atdmHyjbQNZH0ax7eSWLAAewjHU5QAao9EJS1np6WHZmt1xTxs7pMY9MGnrk2eCx6lQ1JW2kXzVZffQDd27ToiEEPYeO+vxyzcQb29lLX89p13Y2LLUJB+aE5X1qwBUA1euJPnsQ6HraigNIGk7stNeagqyXAaxmozpDF96ZqlSr2Gjd3+kJLXvxufqbZNhdfrV9NtQjs9QBvuHnLO2nJ86nqTRFmoE2hCYeoR7IkvXEwyZZdb3wmbQzTnUfolFV+Wd1fQFZy4UBAcqR47bfhfa78WqJNtV8aEVBATNJ4P0tho/Wq++nYE2ETBnk1rBuXV/1vlDDmnI9xAM3PRbPMoEsAAj3tIPd24Zr9A6tv3+b9iPex2h4kgqirFfLCcHKMk1+MJyoVf1DmImLrDPXRBo11eYz2/ldlTXvqdIa2sxjaRf9Zo/Tgq1eZYrSmQB5bph60e1xBURaEVP2NMu5KEFeujp7jt7jBWxg64NrZwfNjZP1IbUqwYAm3CAcqJJS5T4YWwGsnOkvUSitBLNN5+koosMkXAPmViyXO/q73mN6NK4AlhWBFCBXQqiZOjyLDKWQN8YBLOFo6Hah7YABACmsABYdD8wXiZUrwvtpAFahWWuYS+WMZDSCiFraxosueoXpVEOTDVldOnX/uRvoz/A+rPyBl0Kw5UjofteMJ+XTGNkGGQhFquH4mJYdXy84vl6wewrsnrb3yopgLrbgMigMuOzIGyIDv6imz6bWnhX6pPOVBtGf3B9rWcjzqF4sIawvewJLApgs6KDzRKOmLp8loOFkaVZgrtuJKVFdwqET/YV5DTAu3pSJQwVHsk480d9wW9Trp0DqrjTHoH22n+lU6O9YZSCEPK/cqYAaoudzGl4EDC8CwhwQb/hZOtBKpzfWIP/+U3S+p0cBp0eUaZpHkEdQBF5tEkFo/0QSJI+RM1ft8x7OT9qY0G5V2dWy8+5YE++x5T3KpIJL6ZSUajjSJZ80hHcD9PR7zt2JqCWzN9wwoHqw5f01k84wLQr+Gg8WalhR+6lg3nfhyJr2a7+/2YfGNk/Wh8R+6Hvp5fKCnGIlxibLTkKBD2Wurcq7SNjLhBalE8mcjRePC/IQke4m5AONgIumQa9RmZTuQAw00xVMIinXLGYKVHf8YlTJxxvqlNKdqEsWChVKmDEFzQi6/wyNuLuns+5jYK5XNnX96Hvt+IebtuPzAqxxWrAKO1odLAnZ7UiSQa6ZZmFZ0VFxek0Lyj4hHCm9OxTOepIsSaA7q4b3DNhMrDFxWKzlosWlYL6IyEPA8TH9dvcZufe0+f4ts18HcEoiVfOwEKgZbo33RDhINmnShM+AOngg0HYhVwA03NfrWUVJ6TcBdJmBlHh8cqWdGf4QH/Pkfje1D2V72WceCuJE5XLGZwyspCC0zfJz1MY8kveqJNKlKrHy1HTwtYUG5Brt3H4StXe+DO3ADwCBVeJHrLhm01Xr2QPq/ciDATgjCaSWVBRkhWNE4NDi/q36nskxxEN3eDsjD8Stk/OTc0tGqFfOTxIswkISDtEXXTePl3q55vaaWW07n0QRZvrN6nGt6jL2ElLEsyUyLqW0XuZzbgbn4bLagFFqgroJVsMntUkTtm0Cxpoi2SYLmCUwSkDrte8lt3Cf9rN/+0fPnMRm30bbPFkfZlOAJR0HZ8OpV0X5APSi1sG95SU03g926TfK5DYLhz1iy+VI4pY8a8zMjzoHsGxafzxmytJZSguwCgGswirPeQw6YxbwE+eC8WZGmEsFWAB8Eeg8JiAGAlgFoPT/iDgVAlh5DbDsvoabuXbkJuzWzfrrWWg7TSWe92bvKpoakS9HItZejpo+DqCfkCDNEE+V6PXYkkWujmHm8OByETFd0zIpm3N6TbglvYOsf8o7Ag3iNbJCnqtTVG+MGQwMwNLvaD1OeaAyMTmhehGBbg8lwKxneXR/u+q9svUE6fgB4wsKCwrHS0DGcLu+EKKjtn+HPkX4M+Q60AsPywq2arvFe3WS/dHn+LxgvGlDb40KvGzPbds/5eO/OHcVLPAIiPeRwNVRvKbi1Vy3cWEP4c13scfzCXsnD+sbUbNf2WsaaKJUAr2D6uFKvMwWJkedVFFmIYOrKLIvwErnLUC9xE3JJjnumHTCBvs+SYau6PQ1kxbz15xc6+GKVrKmFMTTgng3I97NKsYsHrkyslfZPMeaZc2AKUxL1f0SXpfq30nbCHRpu11GonjVfuj7fnx1bzb74NjmyfoAm4ArwACsXqadsa5r3upHyaxLQIQnWQKqwj5ft1Nv4Q/Ml3WarjM97jCTCa2lO+EnnG+jcIVsbTugepcaz53jXyihNAYc36D/x+dS4ob5EMP6eoiHZ3gxNftteCHCuRC1eptY4K6xBTu1RI/bj/AzOrfH81ZsKCIsD9xvx10TgDVfrrV+RHLh/pMy8NHvOrg7AAK0HqPpUetZkPIyPakF5erIPqXpJmRc1zWnIwMSP17qyZKQoUz+Y2cb79VwHi5v6olTdXPeNYOa+EAtxsoj66wrmrIdb5vNqrTf7TUU75T3zCk/y7yS6tFi8JuOhmt2YCDFoClfrG/U8Ix5Ws9ar6Y867vn9bwE4Mm5lmSAoAPW0VYEOLXH9dpaocM7OjspavYj7lbzozwXClTZs+QrTgDr98lnAJt1etmDfrviOJDd2qo6+WVQ1cn0bsKmrl/wZcR6yTI/+4s/sm7jZt8OOzs73kDWB8wssFIhTh1MPTnU/O/7UI7lC69BOxrUDqBY13UI6oVJL04aHpR15XtOEfNlwvhixrKPGJ9POriH07ojr0Tutp0aGuhxJQyfqnIviMw9ckFXaev0qAK+8dnUlPWgeoUF2YXPSgwEsELQWaRkGCqh1apKS4cpAMtyskRsdaV0/mohvtU1kE3UWxXg6/35unJ5CFxuhbhteU/1CeeL2s4TeyROj3hQzFz6xeiAeUBiNbPEeyXrCBjRbTrPYhk45JVqDcIwM7iQXfPnMpKEwLLjc5FqJ7EOzApqTmUFwAACICFDFd8B8nppIW/xIN0XLIeA4bZQhuM9Zzre1ZI8XqG9Zypiu3R+E+zAbRVxVBVgLcB05WcfUJHSZWQPWWavmAA9E6ad9wFxAaYrasPMNRsFaNnw6HxNO1guJYxGF2VkoGXL8aySGApdozwCu6ekxzXe0nlokWsDrDzY0qzdjPr8yuOsYEvAW81glixGHzrsFbAGXMHm0h6b/negy/MqLblfZGlMiS9Vb48RYZpRjDxNsz/wBEl4ZaZCRhcoLaUpQyb2YGkwJ7dji2CLbYDr22obyPqgmxAaraqwmtN7Achr0eP6qJu8A7B8ZlsW9fUOwIocohNwJR4aD7AAkyEjHhUbxkq1PcB6wHowe4hNOEaipQWYMCWHMR4CWAI0JLOwB7AU0LFVPawW6HbFUNWb50Hw+r2zWj9FZSig6eihlBZg+WPxICWp9irNIMVqRZfKgKzTYxqwROVcAJJkxTUgS/af5Dq33hLAeC5krBKnQmq/23V0EDYATNqp10Z4RSr7AG2fBVhiC4MMCyZUgJR3a0OLEgJU71V2n1YLykkArICw+doLkaaJwaUBWbRSe97TVaTyODMakEXrcLu1liYty0MLsgDDV+P7P18CyAZwGZAlAEsI/gDJVQDWk9e2wSYGDOz9FNDqddMq+CwICz3bXaCFel2tZ6oHtACswZbdjm1RBXZaaTB9hsjF+GL3DWVC9+smjMZrZIEW7bidWKl0gwNatK70H7zJkh8EWs26BTrRU87ttMAWle/1vRtn69tiG8j6IJpIMDRlF5ypqCeH8BpugHdxu1CgL30DAJnBlICq4dl9s02zzhWnG0s4xIfQUF9kBVMeWLhMo54pgdZLNwCYr8fuNkJs371T41w6K+bPmdsvQMQS3BUYCgFVZr7HDiD119lr7NiOzahW045Cu20vs8kLcj7Ay5JQSlVaFxDUhm0B4J65V8fXeR0eiCX0Y6UHfCkdySYT0nkDhtXjKD+027alYcSr4fbvSO2NyQBssuxoX/y7ndgLGJSCytJekXQwml8aGhUvnPN6NCDLhfi8F8VazVDk/es5l9U2XnRVeXKcmTmY+pnK0RF6kStxY+Uy8tCev9w/8UAq2Lqy+6dPkboYbsVzguazZxIulpChlbeooKu9Dume+U1z5yI60PWg5pbf1HG9gPp+aHu11mYLtHqSCbEXXgQAO6lVRXkXzlcPt+kTuO9eRSJc+bLGvLfbCriyNbVcsb526HA2t+LU75ud7bQ34vt3yLTkjQNYodTiwpXMTJ/RphmX0sgE6PbuxRPLh0E9V0IO9QBLiJt5ZwikrhSLcotYMkDTrwPMQNSCMgmxSZqyLckjvAkBj7UuWsF8PVaAZ89FCfxy0qFmN50BWFWVnEiroUCz8WT2KMWeu8ryFsh2lKPpGgW9NnTQ0AdXZr9VU6kDsGQblyGqSQK7aECdtIE+VcX9sgVYXXOX2JZZ8bbiYMlxZV3X1ahEg3k+itu/SCyEhf7iZLLdRLtJQn1Tu1zJ4wygRC4hHqGFmX2bLSiK4m1ZyFsjHhsFTA5wnPO2ynkA9V7aQtjnTACkAFMBizpQ6j7Jc5VTqHIKD3iF01SAYIj8AqRuQrtuKEqAV1FWuafuU66l1oCMwMISHV5YFWCgV+rzKl5nq4GmJqdkwBWR6I1Mg/vUTR8Iu5+b2EHK9lh5B32WOxPFUuo2gIIrFVCeF/0M8wJMM/0BNZKQWzCEOXNN1rpfX4Tbnkdx7V0BUZ0sLPRnpCOkDVvpnm+/bZ6sb7M1ZW98kWWRFzgM5DY3InZNfUBgBQQUnMxr5WUFV8whSDcnXVd3waBhuSJSiu+ckgGDOph0gAYtqOdDGlgEYsK0kLrztKDLh2CCfhkTwlIwPdoR2LqSOBJ/sBdk3kdcfemIZR9XMgzzFXv+ZLDksIGAxMVeW+ljxYvlMokQ45ps6jL8VoKFD/HlPMCyl9oXr5Xro4WWTer3Lja6VWEhcCX7vX+Dlk2PaPBL9yzBcMeD5bwmL+cBzcBow28rgGUAAGDAS8er4Xk+PU6VAI1zHixfJqfXBgmbyf5tm5U/dJT9tZ6mpqSN8y76kji1NiR/FtB7WOg3K+ugNfB2EemUkUe6V+p92gUFxRbYxok4YmkiEBNPrZfQC7iq91E0xYwIrHq0GAxN1/qS0rW5resKEPOeLO/tbNoytddWPVyn9hoA1aNVPdg4aypDU7g/O7Nu4RJNVKrJPL+mH5PQoXqzNETJ+lfWa+YmfSuv1lRPvqFtALWPkGOPJlFoN7TrOJ2vrjRMJD1B4XZpNEMTTCS2K6FHBm5L1mP3vO5b2Z731M5OpTaQ9W0y9VzJy2tmI6EUBUKU+iud3APACqASOLmCK9kfAJTDYF5kBhDy4gqgAbTKvUgh0G/WJc0cAC41E6ZcgRPMLNLq15hyOFRuA826EI2sjDbzkd3p4oVCAKbrASg02OcUdGA6fINGclFpL2OktnGRWi2bk23bGHSOJKIqGZs2wcDz1soQifTK90lKfjQhQguwYjvTDhZE9kwEYP01km1YOyuP5C3MY6yDs3ir9gSslh15Do6v0/5Ojw3wYU+QeDaI01UPJcdd9kH1sOJiSORhPeiSEGXrxYpTBXRAHXxVef6C1vG1/QT0AQx+Cq0noAWo70Oa1vwvqjNZQQudC3tdJHRoFNXjXNag0eAO4shBhWxlsNNVfWYgg9ASqP3LGFbhvXlPulPLnoCAXBtp73RFIqA58Xo7ugbT47CSlFj2AePzgjKQ9474lzwgSxajAbDzgaUWRDj2CpivLLsfppQQsHub1lf1eTNpCJneRwGB4w1t60EsSgVZEgZNR5oESvav99xI34FY+xAN5WtSgek7hfOUS+OB0omg9nP0HsUpUzKBlOKx75sBW8FOBD13S0ROl6yeJd2PH0+lzA6kb48t8BEulrQ1xnV/aXcn/XSmiEeYFrp2WrBaZkud9gxuYighxA1svRe2gazvpFmA1aghe7XicxkowHmA5fhCfqZkswq9nSvF0vAghHQ6hAZg1c6xnZWuykPY58s/a37GpwMxtacHsGTAlNp4h7dOej0A1ExH6ZA7ZWzKLip4BAzI8mBWw55mY1cX0HuwfKhhFcLogC3NYDrzLgoPy4KsZU9AalaPEH0emYd1ekKbiJZST6LBc3uqoGVnPQFZAbDZYZKNV0sn8fEc78kO+E34aTEgykkiCMjyWXzW42SfKcvDqYWp6zlJKBJouU8ePK6eXa9fBL5WBgB6zpYvL+T3bQGerDtdirdSvHAMwqRw923BfMlZkQZkARXUes+eCpjyvi0HbhLv1lVWkAUAA5cTGp/SZzpSu72ERhOePMq2pWnP4DxatG6u7+crjCy9wtAAtF5iD2hp7UtHlhdxZK2d2uGt6qTMybdo2SXRKBSgJQAnd/o6XwBbvFrWu2U4VAK0GnMyFyp2zH1vNCry2mbxrvk+ZaiuUqkWgQz8zH/2xdV12Oxd2QayvhP2w7/rx6DFlA3J1s8kmkrwmb1Nc6aXWjJH2HVsixHrrGWgcFZJqSVnzxkhk0hemHMlXkonOZrMOwmfBeudKk2GmygPE69KRs86u/RaV00oMKKeg01TZlc4YDpE/jw9GhGWgvmSsv+mC/IADPcFp+uIx79yj+ly0CxHAVg6UzbeKhQAMTRFXlFK62k7l2otuxgjZ3dF9RpIOaCuOrvcUwuEl/Z6hULAKcxZvVaeKalk913ELKKvkTLTwlIwXQWkE5VFKYk8OMsB2D2rg200mWAiJSBFgJdd0Ky1PNK1EqVxX6/QhgLViyUDe2BvUajHC5lI13Gqobwqb0DbyGec6LqQl4c9SksFnzaMqNdZPargsjl0DXKizxKhnxYUDUaNvuehE69UyJTBGZcK1Og+m/WNB0zCqpIBmEfKLFx2lGk4HwLGOyqmvbsRLx9tf7qm5/v4ekDiAtHpWKjA9EzZoVL0GiDOmUw2ViAr0P8k1En3atnzNeF7KiALgNZwXPZlBbIQKqcry/0O7O00wqpyTXbPGCSfCCAPR7qG4w2FStMdvZtxYm/hUmATZsSDaE2LK5eqiC6f+kxP1ZtZ30dzj8xEIMwkkhxm8kL5kJ+lX/S0BGk/3B/PS+2bg8kk9EArFwI5IVSwNSRgXlDGQT3ldvK9qtFqpGLEqx5yqQLVmT9LAXqgT2xI1RufoVUnfvrv/K+w2TdlG8j6dpl6reSlE04PV2UPOSNfjAR6hlhd1ED1cjiviA8bCmDyIUfhLxRRNbaARj5z1pCkSAXkXWwy/HRWaLldy9p71bTdPkfWze5BhwMjJVX3OFJAPC44vr7HwEKmwsc6Pk6Ic8F8iMgjcPXlGdOjhMObE+bLhOF2QRkCkpb9mc0513MDqIOKx5l4DhKS4M/ARFS6jnxqRgW+ESxlrw6lnKOGlQSE8X1BrtdnFQIIhgQcKghEodl44E8E8l6VGHC65oy0J+KJq7pR86XRgzJAAqgDr+zfhuKWXdAMtDzQ4BTnOqArwDlWsOHlEgDyMgmJXXSr5suCeAxYmFgdj+KZoX1IXb505JIsJ/ZWlRo6FFV1AWFy3KYYc2FvFoNEqlCA6qXpeF7iVBRoiXyCaHPlQcBhBUjDsWC6DEjH6sVT6YKJSu3IvgAO06V6zPlCREPJIzVfBYwvigqLyj2w4dO8MxIapR4znqDXJp2Khmlt+Fb2seyBvAt6b2U5YHS2rgvSPTA9Lkh3Qa/H+Iye0fGWQRuD1ryr2YpynP3btO7+aeEEhUK1H48EsIZbkh5QSQedzJj3wmbodsYnD7J6plwu7gPE8yvXMCzsIS2FkmIKmlJAXQqBTHyB1ruVQVEFAVyhbXeYlxZocdhwXRSbuZ87TtrZDVoNooRAfFLuizHEpn/q8kkzVPi0Gz4ENAuypFTpEGwb4HpXdhZkbdmF76GpJAODK6onSC+IaqdIgWUjfhnm/MoACxltKnDOZqbPM3xX+86GO0ri7MEhIu/oz6bi2wLKei5AA7AKcwJeag8ALPFgibcg5KKEVA+wpsuIOBecHhHAijMwPUqY9wHzZcLxSaRw5lKqVlUHYIWFOAySRRhyMeHW0Hz2Ou9Vp2g8GHJt6LO4z3XIUndhAFbzu2uHgCgBWNaWPfFolos1ObkxM8gAFWCpFhLzqVTLqaOeISGlHsCy32VbyVhbXAmXPFKoq+H6yK1wGX5eJdyvvzo/eew16woKiK3EBbWj9XgoP0rCa2P7+9zRDfP7EjAsxbFX8gpSnoiPIYW1rZ2eFBw/UXD72bIK3wLQ+o41bNvfVxnoOHptO8+H8PR2b9O2h6/STZF6jtNj2ngSACj3pxOCnq75k0Gj1c4ST5P0Uw1I6mQBqldfvut7ZiZ8pfMcyLmLNzNV8G35jzXxIGLZRy1wTctqP6IZjgNzqqROLFC93NIns6eqFRW12zEAy7nqbIlJH3+agHlBPM0I9zN5qZZc25SqRy+UzuSvuQapHpfPp7GFQp5hIW9cmBb1mtkkrc2+edtA1ntkPYClRX9Brl+bLQiglW+QGltSgf0BC5nCgA1nC9CwlUoxjKl6qySUNiYslwOWS+I7qeyBzIpi7QQVDLk/8fYghlWH0szi3KxJK8zzdgKwvMUp819hgIXmb7gvmPcBh7cXHJ9EXH6dCkITZ6uS48FhAAFYGvrLIHDlPG29tlQxVV6nEOE0TkuVnbAFpBXc9e6bGfSL+w3oi4+CPW/MadndZBxfCzi+Figs2NOZQlt7r4QKZjxXRQBWF1CNBcue/vJgAFaHk0Pn0i5f9rSSyEcsO/rLY2dUtF4G4yH1GlTnZAuK2b65vp1D5SFgugwNByoPpn6myfoDqvxFlcOoYGrZB8wHCoX2wJAf0C2oyzu67hLeba6DNz4nkZkYtcxNPUc5hoC7xXPU2MNnPYHekoQKGWANzwOCCRHPFwTcxOMnIcVizl2A3PG1YIp900RJEg7IU3gGaHHNPvWUm0mieHZVBkbWY8BRTB9aUiAAtYsY7jirkz30hT2btl/Td4P7tjxEAjYdqRwFWtH/Ftf9YggqeYOU6E8msX4CppSQDMzE4Q1C0l9y06eLNX2IWWblgOjmxvqZ4rrvFhJ/KRvQeg9tCxd+C/aF/za7U22ozYhP9mYX8bRUnhZ7uSDAA3Ub9Yr4Gl9S7kHqXhl+FVBnYGEpyPtEx0tRFcFpW37BZ3qh8kjhQhH41FmvZN95hWQVXWQOgE07BmqnKF457rSEw9QMJJZkzgBtvh712NM1K82bgQ2oA8n+HVpv92xBSQHj85nbvjRttbphFvwKKLWmxFa5XrKqhBQl80j4bKZcj1y/EsOKVOvDsBbYAmg4ZRTiavcPAMcn9P/dJ2PrCZLHTjkyLSjRsKCRNshj3c6CNfE+5RFKdrfq4LWOY/upi8WLJSrjO3mguG0ykD8nT8P4nH4XYCj8H4DCYOcAlpCxhfvUiHMKiGRQMV/Qp5eO0Ot1ao9hQ3ynR5Ttd3zNeISMyGk61hBmlLJBpq0iqaDelNiCP594IGHI6ZG8b3yce+JmSQkcWyNQjzUE9UaG2XgcY/vpVfW9eVX/JoEgQzNPxWyx6eE20D0swMWbGaGw3hmvko5EtI9TrXrQgGHrWQ/1Wuk76wC4Wqjr2Qmd9TDqqllCxVWV3k6MVuKlS2neZy/tsJJ6UD6Wi0T4pBr+n/qWhIbioY2pIT0AyFxTtjigthorbFa13a/l+HpT2Yg1fxfYMhEfsLOekc2T9U2alME5B7DEtBbecaY4/5w1Tl4VnQMaQbpvEWDlXSK5hVJYMNS6rokULqR2GcCXHa1XBhr4zgEs+e0swPLfAeU4Ee9BxEcJyARJg5ZtCrR9kl3oAdZwX9QjlUci1FqAJYCSQpLVM6gzuw5/TEN7voyOrJbb5So4uWtnlXK9hCPR7KOT6dguf3guM1+2r2s6tss17OcKGOv+ebAL7NHoiY2KR0UB2JmuowrBut+9kKkmfLjvC69z5pLIvep5ompmJ3+PNPjnFJoyPbp+pHeNPtFsq4BQvD/uWRPweftZAfe8/mXnGMl4BDs9a5CkABY/9YR7BZmSmcd6VZHL4Oj9FA60u/9iChjPdvs1seCceS+XALvd87YNso+R25qO1VMH0GQAqAXKtV3ikcqVyL6qSVhMGwsaEWOgAxBle16vqaEYCAwrV25P4Gu6iJwsQp4pKUskE86smd9BvUh5NKRxr48n4IXDcJWGEOsy0bMSIJOSeve9B8yajBvxTlJ3+bRT7e+kLcV44IoHdnb/HtDx73oP5D5zv6eOhc1e2TZP1rs0BVdOewlg0BRRCYwhUEqtaFOJ2aLCMfLMqwIs5WkB6sJtKraHChykE8gDcatCNorx7DkBACxFPSWVdxD0RZXZXpxKlW2IAelEQEp1ZUzYTXVjhNwdUTudMRFXYEwkQio1v3YDwrQgHwaEmdzfcSa+AWlxDUApOL2246wjEi88vj4gTgW3n6TzHe8K0pG8HHLt0jFrmZ0GFKnHpY7oVTS05bfRiq7zMYWhkamNcm60vPDMPFedHwCiZ9OY6P+YMkSSOSUK11bRHYUGftWZGuvAM10GLZkjoard8+rhCBZkmRBf3tExRaBSSMwAsBwI6OaxIM4ByEA6BQUEeSwIS8ByKBifU8hSyNYhg7YVfafrgjgFzNcZYQnIA32PUx2M071J/78lr0KaSiPX4MO48z4o18cOmjZ7bNlBMwKBmlkn10AzDoGq+3SqYq3TNXGVTo8pkeD0pCAdA5Z9Ia9eqN4s4TRJ1qNkzUVDgLdipiWFpvAx1fZr79N0HZQDVbP2qoeyhFAzC481e1HWna6InE+fBfMFZzke6Pove7pOeU/PybKn81x21Rsn8hqqhj9RgkW6Lzg9Dhju6ToJYFbQGOr/8gwe3qptG+4KBhYklfNpvFlnRhtbz1DMiuRKwoImMIhen3i0dhxCHIM+r1KYXBMIJtHKYmJ8BlcFsH+ZQR+PARPzYk3/EqZlLaPg+xSxncRUrSstVpDW80Axz7cMkfrMEKDaWZy00/SBi5lgSnt85ro9Bre35zgQmaCf+Y9/rH+jPp52dkqzgaxXtF5o0NtKI0mF4cyPnXpSNcSXa1YLoA++um6tgCgcwEL1xqyELV2ldqlzVxxPRCwaDaHhbqkAy6sgSxsNqKQVOs+beXmb8JzhW4hXaHpUCULitp+uE9Kx4O4TXBLovg0ZiO7N+IyLVgsIVnVnx18z6cuN+aQBp3Ojobumwyy13JD8HNvlPbPSFcV4FHWzndwvFgjdVaAAVHL26bEA9HpdAAeyUAdrDbkyyFLO1IG2zQN7AE7sObyT54SXa6hNgDn0+PQPL58pc03kAaQXGV8EbV+cgYG9JCKrYM/BamJpqMt64OQ2pXbw9aWB8hgo29Eq25t9InJm5p3bTkDaRXsPBSR6oFXDbNJP8P4MyKIf0CzXe2Vejek61AxGp6QOkAbacCzN9bDPh4abLZ/O9FH1NzTXTq+JjMVSysiFbbUY9QVa432JrIRccy19pPd5DbQArMOAsluTTd0cS5rVi8vIJAbQsj4AMMv/wYBt86wNqqNVgZZkRAKoBeRnA7SWuoMasut7xlffBWh5r1MPoBmTRKp84DqzJvmmAVoqvur6br9f5+X3YUP6v/J7ga0eIttZkLWFC1/BvIu0qRXFsyvbeWnNKCFZO6vEdPpbERQNeb4HsLL7owVycGlD1j9qc9t24Q1p2MuJa8YpY7hbaieiWY5ynNACLPndZ0Ny2vGKJ2AE/driw9IBL+RFy6UBWOlU9E94FemYsRwixmcT8p5CpSUGAliRO5ZOJxUWd91Z/V5vQ0DNDHrAwpJX4ZWXms1mTNXjGI0XkT5d5y/g0pWYCW6g0WLKLqyj5F4eYBWMRFph2TOQEh6VDFD8XVL281gwX2WjOyXt49Pyx3cZab59Yl19JGPTBZWgkRCyWGZ+2qqgM9rv6s06w4NaJBzI5yngSkKNGmZMpdleOU4OTOl5G7V5wIQE9brxc3/b3l8Bb57/JuE7gL1M/Nwk1UPj450Kxtui68v+JaSYjlTrMRkenG1nOq3vSbP/+4L920WTUnT5ka5FPJFnJZ1Kk1yRB8qUVWFdYMWNBGx/xV6sgra/LICEtUXmg9a3+6C/dJ8brTWA+4BcvXECPGcpuD5SdCKnQLVCjU4VnWj19GgmH3B+wnlOyoXDi8VvJ4CGx4JmTICZ+PKYo0R+q6fFfUy38LyENeXPefGDyV4/Zxrd2axrmyfrAXvQe+XJgRkrl7ECD3ngVZeKldVFk+m4tFwhqyXFD30J0ILGeZeaGXGcMmlE3c3IQySyO4cPJWW4jHYWl0i+gUmyUmJFwkzjC0kbLq02C18D1aAxYcMSYxU+lTI0Am7MefmyNCXFpkOcr0fEUybtrrlgvhqQjgvuPjkqsBLyeJyyyjzsns6YLxP23zgCISDeT0AIWsuxS/6UNnHyAUKoXkEjiwEYvpvJEI2TA5DebLZUJ0VdNcJM57eYkG7eiVho1EHUZr6drkOVGOCBarwpGvqgE+AmCKgaAvKevi87A7bGCqJKKihDwfg06e9W1DHk6sk5vEmf6b6GouZL6LMvoGXZF35WA3tF5BrSZ7orGO5pYB7uywosSabcfFm9ecNNodCk554tUNJ+STUrUMRQJcyV7qitZZBry205BUzXGekYmmw8JYEPxEGS7wKYcmLtr0SgRwCU3Lv5QCG++cCiuk7HbBlp8Bdx2El4YgpCZFLBx+XtJaTaE/EEoHUtF9bJknI/AhSmS9HwIoJ/1V+Se0fZrSVSaM17LuVaT4/aZ9wKzMalerZUIJcFcYf7jPFWeKfsMWOuVlMHVd9j2U8tJWQTChoNraYUEtc3HNtSVnJv4szXKtd7QGK45FFXr9aUWc+N33+erOmkzkjyUKaeqyhhxhEr4qw8rcRAyjr8DS3CWpPBnmoGu5yrCKZS1niu6vB2vFlMPy3H0KxqcWdWr7t8V3qMAWYfY6/W5sl6t/ay8GAXYFkzAKuMqQ+wgAcBVpE0W6wBGgCk21kJ6umOs+pOS9M5ebf0fEhEeOcSNdrhdQCW314BFpPegep+FjE+VYW3HYqdHRmARftE7XxyRjxlzjiSmfaCMLP36j5Xjw9LPNA6mQDWW6fVDFI7AqCZAYopwEIFUt7O/j5WoNgzTWzoLC8hmPCre3a409XizX45n6INq/WW+9c+76Q2HrfBSQ6UBORDRrmidq3Cg8KjOrY7joZTRRu49kg/LQRux9dBhmaEAfWZrOGuCrDs8vlqPajLeej5DKEWjRYpBvkuAHCHxtRrd+G8hnK+DlzJ+ct57Z6LZ6e9P3K/ds8zhnuTNckmPDNb8qc5roAjf187CQzNfnl/w7F0n5k9K7Tvn/UnC7unAubOtat/XL3PGavQNWC9rwHTZWzeVYg3JogXkf8P/p7L+y7f20+Vg5D1Y4BUEagyIfW6pBP9n05FxWUBE8aP0BBkU+lB6QWg31xkgA609m7Zah/i2W/6T1kvhe5o3dRJzdnQI4puZ7m5UiO38bCZWrQN8JL1pF2AiWhUUGy327xaa9tAVsd+6Hvdg6KhhbDK3GjM6jABzfK8H5QwXUNw605Nhe/YlsOA5TBguqY/n/GV7iaku0ndxc1MNqB6wkxokDSl+NREf4q1qQRghSU37WsAlhDdbfMldOjBpu1Qhs5yKaCaM/Jh1OOGhbxzYS44vjEi3bO37j4j3RPAOr02UMFZTtOW7EjN7DOFqHuzwB7o0usm61gv0yXXeFSpi9ZDqNmh5Qzwkk59qRyutj2h6/EKlgvTmy+Fyptp98eHHSt/xpoVk+xlGsq2QAVY1B7KfBtuggIMr5Glz6kArJkGieTChR6QVS5UC7DU4+a5VM40nOcEQFdA67JgvijKQ1tYs0rDftqOCrTSMSAdA3bP6rXwQMsbaUPRO5Y64p1CqpZ1xdKpYLyjvx4wKqFyKc9lCfa4TVKySI7hLZ2KgjwJVdLvdTsfapU2SDkde1wNY041xDfetRO3PELFWyXxw4a9RJPLP/+N7pxcB5eprcaFn3tZwwJC0ikjnTLyEPSaU0kk0XgjzS0KIdJEVYAgAiC6WUWASZTfuD0+oUbXi1jxWksl2nurmbd8TV1f7DXE6jXgXUvGtRzXtoePrRmS1vh3TQDoAMGSAn7o+3581eaPs23hQmM/9H0/vn6oGQSsNFqE6yTeCEfKLAcpukyftkwDUD1ZK8HOkfhEst30SIqBkpBfumWP1b2bGkboCyOeFym0HErBfEk94rKP2jkl6bxLwXC/IIg2jGmbeq18hqQ5567eCrAKzRVLmIxQ0VNbG7BwuHO5IMAlnjspxZHHiLhkLOwWF1mD/dsThR6en1ZZlavrJJbRuLstoNJSRSHodQSIPBvngpwCxtsZOcUqd2G0uaz3y5LiLRdDRAWLpIsLEd6KIsIOajIA0feJ6xjOF2BhRwrlVCBC4Z1lH6ouFgh4KBjZAQjA9Kh2mMuTGSgB8YbC0/u3og6wklWYRwr/RKPoTecUIEW95Vhy7nSNoGKUdLHkgvPyE4U8RTG8WK9bpvCegIp0T9vp4K/aVlTvT4GVqM6zx2q4DZgeVz7ZSlRVQk9z0PUB4kEte2D3lMDa+FwGYgozjbck2jrclYawLxlv6UQ1/JIhUOeBa+4NoQEnUoBakh5OEopTDw3zpbSiAS9W71H7u68s4EFqk/3IPEBqa9H154taXkiLhZtztOvVHdOzEQqHN0sFWfMhaMaifSaG+4wwM1go7TtD5y6lkOSk+edkaoEa8CTbSGZvHttQnG2r/1/exePj2Jzn4e3qMYqnmrCkpXmUxG88/IDxAJVmgqlgx0o+cD3aJoNdxyGsKBA6kUxMWBdKRkANo065Lb0DN4EG1lmRmgl9xmMvhabZVCw1AH/jb/2Z7jYfQetNfwFsniwAwOe//yfwQ9/34/qQKv+Gyyh4LSQBWPFIvfsKYEnW3zcBsJaLcQWwUIDx+UThwdPcAiyZPbkiy/lQQdV8ScBt2UfNwhteUJvS/dIALPVemYKjtKNXB1hFNGHMcguwgtXXMgCLOqwFeZeIP6DghcKIxO2ofIfErnHhi6SbCbbgdHONgI5qszTY3QfXaamrXcCQhK8O7XOh4Haf+h6psj6WHjO6QXS1Ai9290HDvcod49+d+reKSUr/J7s5c7x4k7D/RsT+rfZa7t4hoUktSGzbIsRkF16TdZXLoyEGt72RHwCqFpWUapHvi/NKTY/a9YTDND0pvJwOmPf0eXqjbWCcvdcjNB6f5lyO9Lzt32obL8kYnvAvVhME5D2TY7tQnDwGyllj789tezzxNkV3rfUUnHq9tyZJwP4ealu9p0vCibsX1bvn99nbTtrSgC9UTpmem2zGID3vOYRsgZJpZ/e8Ari2q/BNWTvNENVlYuezqsVCRr0PfH/k3Gs1g3YipJNB2aUSz2M7gZN+cWCSvHw6IFPEwwV0vfCNLqNJDqDGsZdJZYbQfAogEk+U9ncyMRykk+D965hwRkNwJuAWTuwAMF76z//AT+DzP/ATq/Z/nKxXCOJjaV2ABfvy0HIV0xSAZZXbYQAWbxdPS/NQNsKiPUkDAKcnko4r7nfuUE+iMunabqUAQmgAFgANp/UAVihcid66hmfOKHmJeCY1ru0AVh3Cyj3P5y371he+AtBo9hGnrDPSEtAArOPrI+KpaMhQroMqM1tA8irTiTMEdaACrHoe1iMVFUg3/K2eThYASkSoHrqqFN8nt3owUst/uNUcUKtK47zc35oIhAmruoLDW22NnfHFug1AC0J8uzUUWdp1laR+BmDlHW3rAdZ0TSHG5aIgZCrVk+7Zs5VboDW+IH0r4DzQKkNBOJnnbA4oaX2ScarnEqd6Lf05CbhtJDSyeIVKA7rU22TlKZK5/6EPIsbb6uFr2mj0uPJoPXst0ApLWYEr0ZZaHdP8r2HMQOeXh4DxjkpbqahszwK6z810WTW+LG9L1p8vYgWj2STauPcpD4GLPLft1cPz9UdBI1KbTrmKjbLnla6PbMcJNuKBzuzR5KoH02XEdMk8BBhR2MDVI0TzS4AWOCkoMWizQGte6LOUBmiFZanaiPacpN+UJACxc1IPL4lUKdACefckcUnbJoR4IcfPS8vhkrbMpBEYTjPKflTtQ1r+YBM+8vaxDRcq70pCMp5Ayb9Hzk5Ltyxy6RTBy5ial0FDXpx5BpgXw4EWJbNfUs99ejJCagcCwI41n8K0EAhy7loR8KS6WNyhMshbdrF5uAVgKXDjjqAK6tVU4IbI77PwvEnYz5JWpR+QFzhWDpM//zLE9fUZIparnYqYttvEqgYP4wlQr1ZL/JRzKCmuftO2ygC1M3OOUMFr1RWLnDFFHYpeU95XTrF64syxyBPHSvE2JGmyCzVUaIi/AA18pAZNP4vWz3RJM3SdWYtS+yAhkzrw1wPSuapHaFdDStaD4fWshjval/KpRHctsKhjQdNDSBhYwmCAASf2OE2767HjZH7fiReRwdcFdEo+vohYDjUbLrP8xOGrEbf/yAwM4pLh87zl8PkxoIwFww0/l/JKJ5AI6zE0GYvjC6rBt3+nhtgFHOSBBlnJ2FslKZjrSdutvUDW2yQZcjkZ0CzLEomuqowDZ+QJCMlcrcFvB9SsRQ/e0lSaGof29xIqGV9J9yw6mgcu3C4eVPXcoEmoEO9VCajhVMP12j+vYEqAj7RRtKrSneu7zPPavNPyjuxqoWddxILB6nlyExVbfBqA1grV8F8MjYbddBWx7AKGY8H4nG7mcC99EIcIfcUOvffn3I/QDO3uMs8pszxYHzIEKGxosrjp2HwthSDv+vnm2M3EwIir+gxEXal1GuhE0sld/Owv/kj//D/cdhZKfizDhWczIHwHxGG5FcACUHZDE4cGoCRofTHhPFeowEMH9sOA+Yr+gPqSj7etAKgFWCW0AKs2mB9yJ8zYA1j0Pet3cfkCazB0ts4V85kagKX6LtxWm4UpnUSuaukakhTvmcwEp0XDsrYdYS46m00nAjseYK1KXrj75Gswriz0Byqg3tvhtu0oBSQJOd4L0/pOX/dvPFkr87waN0DovjSbjn732XIq39ApAq0Dlg/9SMRA9JpEbkBAhHioHKiQunm9unqRFcT9lM3X6lNyumhV8XIRvVRO2nXm9Xmgv6DG3n+G79Elv797z0EBwnTu/gaqEXhql1+86Twv7rrYUNfKAh6czXvO0cpTqRO/9rs8FyLqORzL6j7S/iqnyxcUl9/V6ynXWsoLuWem6nEV7F6sPd3DsajoqBp/PT6hfR5fa48phbgrtYDbwJOb5SJWsjYbaV+V7rsTClhmobZDvcXuWkedMLidqGdQ/ila/QKga55O1J9NjxLmy4j5ImG+SE1ZrzzE5l0HUCfl2jfWPrLEuF4uy4Qob4GUl4V4yYguVJTVen4C3SuAnSS82d6vlTnngkZJ+NqvEss+4vax8mRZcNUoc0uZE3kXbk4aXy4pNXIEZUz1geTU1pISwF4OgDs/AQ25AhmgAoB8GDE/2q3E7Ya7WTWgRNukkoJn9cg03KMYKl/IzF7ilNUTZ7WcbLFTzRY0gKPHtyoxttwzCyKsxorNOJHfY6Trabx/utwIgoq2Vt6PCKVguawqyGUIyhvLh0QhANbSAsjbNNwt1LlOVBRby/UYaQkvySEZj+rFsp5Mc2+EaB/mjHRPbvTALnQKx4q3i+9dMAKjp/7MtYy1A5Yi3T7BArHW4yspKNF/GXkgVA9XBVjzBYWwlguQKOQAKhYcjUfo2oSwchXdDLnqP+3fqnpOcj555LIxQ1APps8yazxZqqvD58yATgbY6Zrat+wp0y+eAubHC8Z3EpaLgngfkPf0u+hZ2ZqHIQPLVUY4ReC1E8p9wv71e5zuR1w9usf93Q67/YTjccTyjA4a7yJ5QaZASWGcORkKXa88Utagqq0zwX+4L6RSvwBWi0x0oLQUCyoAoufH3nS+HDN5VoIJ9amMBYN8z58jyZXqvdy9yE0h8Lyj0Nd8IG/mfKDvWkIo1H5PygwpeBZnC+9juCf5guGW2inHIQ8XPwtDvW7qUTVZrOlI69x+mpJFpiuajMk13j8l0vvFmxW8TFeREhcuyZs43Bf1EpKEC4BS6nU2Mgw2GlG4z9AMzKVeA7ondcISZzpXTUAwZYIke0+0u+jmmUztfdBz9ry74U6iA7VUmkrW2G6yGA0weUxYTxAwE1GgPvfqia+0k0Zf0X433izrqUovjisCvUyYhXBfEknNaHm0lBCPUx0PTEWMZnJryfwi25PZESFh3xg+Sl6tzZN11nulStsZ6eaEdFPzrEtK5CbtpP7StjW81Zj3XgnAihH5MGoJBGvpuCAdl8rt0tkCfQgfS7NmCuBTlWVAEzkGLS0jRYu5sPMKYPXOzXOpHLm/LmgBp/6vHi2qWai/2T9PppfrZQAWhV/NOe4JYC2HSuYXgKVNX5Ur4uN40rjy7kx8Q8IGbsYr90fb6jNw2KwXk/S+cne2bT2QVW9rDbDa9jKfxD4+pQ5sy756eyoBXtrSHl+9Nc4ZMV+bc5QorpLnpdNu2yXFjtXjZkJH3laK7i6kOT+m4wvokxCg8KXq5IjPU/hmO352DrT97tCy1vf7icKHg4THuY22UTJeqMRBn+BfVfJ5fblkL/FYUejX/eZpN/I6We6RUSKnZQRgfJhPQlzKC5Nn2XG/hLQN0L2dDwHTZWgAkniyRJtMzB5TsgatpWPRP7HLr9GFFQ+X3DPxbN19kjhO01UNhdt2LKPUG2TQFELXM9yowIO8rvGYEcWTL15U80f9ab1GdE5FgZZydX3JNPGmH2sFCvG2zZr1K54t6quaeqnGS2QTbVQiCGi9SyK34PW3HqpG4b1ezsp+rB4yAA2FwrZLwn7Sr+4tMTFqGxpRZtcuW36IltO+Pw5yDx8LkPUy92RTguF+Iq9LLgSwdMCLrRer1N+bfYm0w7IQ4XUmNfQSo3lIh8aLJQNzyEUBEmDA0WmGity59pICfDTggJulAKu036elanXlyhuj/Zoioh2zKcK0QVgvk+82w9D/bj5XnIAY1+E92dZ1dNKZ+YGt8VKe6WN8xqhYla+QFfkQKnvR8UqdeYvOlaOo0gz+mvWuV+sJEl6IAB/xYAlBXOz0WkEeqw6UWLqvz4jO6iXzUDSjHBEegbxi2Yt27qu3TrwNvo6cvwYSRoxeMyoA+ZD1/2bRLN4I/pzaaxJyu8Hl4YTXH93i+nDEd3/ynfb4HDqcn5zhxQjOTe33krAq5UMcLi5ObX83Xjv6B267sM5sC1DCdfOzXE+X6WprMgJYhb6H+7zW1zLeP8CEkSVst5d9tpvNF6EBZnSO7XF9tmRSwNee0HCLdRiKTcPCV3XSIMcHqAxPu36kcjdNGNHoR8H0lfJd+0c/wavK8frbwmHHXNpJl3qoxWPF3DHlaFLfZO9x3jHYkrCno1VUeoWAKGkEAy/HtWrAkdiZ/sY+G2HO5hkKFWhJf5zrOCHH10odtp1jgi0n15QDKhVw6m+8bxkXrX3Uw4cf6XDhD33vnzWCdcYVa0jQ4X6uRESfCTYYBM/gQ0M6op0lxEMJSRl5AjsTEHL7fFFj2mEmyQIwr6ikiHicaVY2ZaxI5cEQGWN9UbMJO8Wl1iuksBWdSlhyUy+QNqyn+jLNq6bMgxUdZRezBWc2tCjXQ/WwrNr7tLT74Rd5uRxNKBTqgSpjrCCDdb/SkfYvnzCdq4ZbwSE72c8+aRYX/QDy7rkM0zJwaHaoXjcvw2DDivrd/R9PVdjVzmiXfWSSc9D9egANE46bDxHHJ3L/q0fi+DpwfCMj3QdMbyxIzxNKKlTYOVeFdvE2VaI4/TZfFczMbxqeV02seApaGoaOT5/JZNyl+4J0AmdOkedDwoqBy700PKFgSNKDyR58XDAJ8AkMpDKV4EGh0JElXYdCpPgSAAwF5WJB3C24vDpiTAv2I3l+92lBinRu9/OAr3z9CZ37ixHhiuOib++weycCoSDdC6qidojuWDpWICE1MwHWqjKerPr7GjAVfoflf9FbS1PR76XxTJOXbBlNSKqUBtCIFy3dZUQmv6MAeU+f84Ge4fmCQnYCCOfL0BZ2FsA6t+cpgHG8LRpaTCd6hrT+nwzakUNv7lzoWWWv8QDcfioiG/20kGuRcAmjLvuA8QUT5e+h3qY4V3FWKV8EUMa0kvA59O4tD6H5Xd7vPHLfFMGTWXpnJYFJtrOaYzZUjFD74GUfavJJgnq40h3158MN1RccbkluxmafU51UeTnt5BdGjsGCvU5lDgE50l8LSNIwoHj3DZ83BkThHc+ZCO5cbaQM5pOvWUkcnYhcEk4m6/K8a3jSgEkrXlqK8s6W65328fG04Gf/9o+u7tuHxM66DD+yIKsp6tw8mPShJG8PsKwYHKqLtOEaye8MNhq+kyXHy2B6TT3KfMGyDjJgCxhyYb0VbyhV/lWT/cG8g+a8lgqw6KDiJXPhrdWM+V2ALDuDsv/7NGJ3zVau7dmRUw3I8uWHaHnUrELhgwgBXYnorg2W3N/UMTPLFYg7kAU3q1QAZGaCAFb6W9nw+4A64222AQ08npDrxSNV74qzCgVkCXlYMgWPbzBf7TIj3tI6w009VjIZc+vadK13xIIsAA1vCDDlX246xG8QcV0BpifAS58rWlYMsk6v0Xrzo0U9V0DlS0VDVLchtmVfUB7RiV2/XtPWHl/c43KkhmY+4fuZTvidG0IXdzc80r9NLpTdU1pPgZYekNsyW82vel62OLIFWYD1pEjbK/CQ3225mp5Ku4TobP1IOi79I1mGcmwBsaLyLwAtj6HxujVAy/HGfL1GkVyQ89cC0w5oNeAD7aTj9IgOcvuperBiSnsp0JIMv3OyH0HalBuPlLTVEtS9rQnufG3cO6zRBAusrJfLqs3rM10fzOkqrsPJoEmhZEtKYlUjmGrapLJBJvu6J9ugtA+ggngXdag6hRVkARV0aVa2jF8iLSGH4kxwoJLnday5E6ViaX/dxrZJxzU+hvb317tm3Pm5X/jT+BDaWZD10Q4XSh09J3wZlqVxKTdqu4L8rYqtkAtDqFmFPGOw2YNhMpwqAVhX1IFL9mBPckBK4kibQ86UymvcsUB9Iegkajq2hAQ1vOjV6Je6b/r+ipi5m83ilp8DZ2d0W6Rs0Cq8yNe7CcmKcQmjxYmB6iz2tiPbADQzueZYZ2oN0jL2yvlXJrgsQPk3rc/P2rKLWu7HWt5F9MKDQPVSCu9EwqKiOn18nQHKY1r/+AkGWE9m8mJc8HcOv4TMZN7O4eIJGJ8HlWvQ36WMjhvYNNzCniwJOdXBlZf3pAx4f35AyztSVZcSNgoiBGCd2s/xuQBTPuYNvafHIzXmk9c0Wo9xwT7NuBhaftZrV+Seu7iqtXDqQC5Am75q5iKH0ATUyv2UAbTWTVxf5JDbAVrPm7lWAoL88yDPs0gZKICbWkBTd0h9nVWUB6oC/XBfsHOZf+OLgvHFOiuxUdqHyTa0IbyAVRgR4P6lc77jLRWClvI7YlWklvtGfrZE9FSyGDX0yJufriLmQ9QJiNiyj7UEjucPlv690OVnwGLIdI9rbUTjWeRwYnTZ0FIayNeWlKL20yN6qKSihHKfVv1VBUxdGR2gAVcNid71f3o+ToPR6vYBoLFwXlSAVGkm04J4nBFPC0sHReSLUdu3qqhhTUrRJXl/zQQ4BCxO3PmjYh8pT5YPD9qwXTD8IwlfSSjOeoxohdCGvNjKEAmo2Bp+fCwA9FCloMBq4dI6oqsUjwsQKhhSL4uEuSRDT4DIGDW844FBScyHCexy1n0ayYd8fkan18UT2m2Ismcm5CHXSttt9FrkuhQW1pNrai1MFCpVD9JB5A8IgEioTgaf6XrQ8jFUSy4j3S3NTFBrnZkQH4AqVVCoXb7chs3ss6FEf91t2K8JE5rMnjwEzFephghuF+REJW4EONmMwZqNx/UaF+JahRmYriNO19WjdHyDr8VVlTjIu4L8mFHCKSK9kFAqlMeU7mudPTo+XYs8EMDII3kC8kgDSh6g4SJdbsJIEj5LR1I5F6JzHoJKMISM2tHGOkDlIdQSPxdVsuH0OIP0yQrCwuFG/axgMRTS+CojgaCSCsrVgvHyhIvDhDeubnE/D3j9cIfII+ovv/067u/ovfz0G8/Um3X71SvEI92TdBfUY0YZkHWADTN5AsNCumEhs2ZWoGubB5IvsKVobIjJlp3JyWakmTBUrIAjTY4HpA9a5WFRFiADMAFiS+UW5THwtaLw2XLBn1xaa7qgPu50TetN15RNuuzQgK5QKvAR0j0Azf6jZ61OTNIxr0YM7a8ATFcJp6tAWaW7gHRPZZAkPLh7QaT+/fPMobWMvAuIp4L5IiAuBLBCqRmOw73U0+MwquMIhtyvAyj9hYRZlWN4okluXLJeTxv+FG04AVlNnxFpArwcUuV6gYDp7tmC+TJRG0+m/+d7Z73ebciwEIiWGoxATSiykQ8JFQIUtmO5nLCUtf4WZ3bLWGMt3k91/0DTr2sIcUxmckHZ3JjzSgdMJSnsBETChzxu5P2AkiKWi4GqegCId/OHKXz48fBk9fhX9LubYTA/qFs0OKU+wJKHOaICouYgoQFYIgqqpWFE/K0HsCwBXXlc7N7t3Dp5sa3IZWMZ/LB3vEuO6K7nBlQ3rydlivnv5gVs4u9yOLmOrwrYzLF9uEElFIp06rlZz2tKrTIJ5TD+vknHmfoetgcto7uNCIZqBhx3LlKGxwKs5lOKGiuZvb3gp9doEJyu2maUoSDcJoTbpABLl6WyAlgA2ow4QEMtvpSMlokRgFXa71a0U5YLCPEmg5nPqEv3QE6VDyXAsOp/tcdUEVVRNr+iBRecUfjWDbmb/otf+izevL3CL7/9enO8r//dz+D26QVuv+ouJIA8kqtD5CLEGvkIkAeIfmivg4Tu6gSP9ytOce/5jJw558e/kQndpR5DLE5Fs9p6ph4hDV1yeMoRtEf+Lh4jOScrFirn4LNAxeYDhSB9UoD3fPq+SDxqcg5aB1JCfuqtE+8Wt43D07sbPgcOY8rxVfl+t77Oxcjb+PPrqcaLfIOVibDn5OUg/HqSJKMeyTu5vksLpthyIikeX12C2hh08tmlaEAmh+4kfFmfzn4BrDQJ82HUsRBwHtqldLUM8xCRDwNtZwS6m0iK5cQJGHTUDtEczBdnHroPmX1kQNbnf++fa25id9aiLlE3EMlDGNvB0S4HoIS+Zt+l6HbCvcpMrE53XMvpWGs6UYFOx8ECIKmwGjJzFhYiT3sBvnCaEU5c0/A01xCh50PpBsZbY8+tB6jYMweYT/didEFJzms+VmGA2nniJBOltqldLgBrJUPAgq0641NXPn8t7tN5Bkp84Bx6HZbdrvHm1d+na2rrfAg4Pqn30XuwdF9GaiGPNf37/jXaVvgrGiJkXKBeloXI6sNz9sZwBEwI61LcuDaEP1KbRWZL8EioLBpZBmvpZNptHtW4GK7Ocb1dTu09kH3k1PKgfNkZD+TknKT94Y4a8ewbdHFubg667ld/9XW8+Br9vrxZlTgPv7LD4WvUgP2b9cHav0Oh0+G2DaHuv0H/798qOuA3bTrWuoVNqNQ8JzZsJNdY7qeUyxH5Ag1X7vjd0IGcd6uEZ95hJ9RIBcMdRxPsgWQPlC8DJEArHQ0nypZPivWer8JgewJcQnK3+7VtFZCn3rHCchnHdv3MWmvKFXQhaJGEEKDlJy1Zrt3qnavipqsQ7SKaelj9DkC9LKvxJaDRxksiWszSMgK4BPCKOnw6UsJCFUWtEy5tozsH7X9EPuFMv6pNUwkh45ViIjydi9BKOrxj8GSZy+bQRZAVOJNzyjo+0XYCzAzQYgqMGocNNbzJXrrhBT0Uyz5h2Sca1z/k9qEPF37++6n4ZLyfNdQFoEX4kh0ooph2eUabDdHDJixYCWBF7sv7AZaALh6rEkJ98GJcZ4dkB7DYlPBt9bBQOw4JLTZlcJrzKdDaUo1KfFDXsJq8NLKucd/Szvl/+WSifxP2k3+zAXZyjVi9HZFedI3dK98ha7YKYGYu0slyeQxf7DbOBbu3T/V6+Bml3Hpuu7784tL3oc2y7lQRQwPWKGSwHjw1nFko47EkSjVXcvgthcDCXBS46iAwBg15UOZX1ME2ZODukwHpCMxXddAVcCU156hMiZ3Z8np78gyJV0JLx/AgKeVPhHAu57p7J2g4JM5A9GAp0J8djAHymkhINo+htneo21HYu+4fqOKpQBv+DDmgxKKZkdFkSFqe1HJRKLswFGCfKVz6eEL56h759Qm7X9/h9KkZl7806rW4+2zB1a8G3H8KuPyy4SNxm46fCNg9LTi+HrB7p6gXUDxDp0cBh7fLyrNRDCg4W8A4BuVhVcmEes+H21Iz+jSbj2vpcThMQIrekpnC6um41MxkQPulEqqnrD57nHV4GREWqPgnQP9P13Quyz5ozcbIgrZyr9X7udRrIMuozQxI7bvFz08eAqarqKBSMwZDaLImFdzMJECqSRiuX5wvo9YwBUw/azyvNjNTgQcDLelvBQTpvZ2y9iG+NJcKCHOoUWovSj3YMtC9yPu2zBbp5xXuF4lCEOasJcPyGBXM2bJf0GuR29ChAm8TPrRRAhNpsGOKHYMaMnrPC92btJv+82xiFLelF3pUr6KcgyHMi6PCCk7/e3/jf7luwwfHzoZAPjKeLAuwrHSCEqktwBILgZTaZaYgD6u8oENsAZaYy7IQgCWelbAU8lpp9XJ5ceXF6XuZLMCidrjmGjctcAZg2e9sXYBlzXmn6oZVKd3KI9TtQNcsr19CqQIfcm49dmJD5BfTcc3Eu6Q179xMsxDfQkmSsthzB5R/J9fczfzdeue0ts55wbyJpITX8tGwhRvkJCQowHF2s/+7T/PvV2sPHrWHPleeKrZ0H7pCmuIVWPbA3afX92W5KJUwf0ZKSkI75+whgAGsPRLe6ya6V/LpS9yoGYAPADixR/kZgfmr/5JQzGt/vxV+ev0/p8/X/qv+e/joV+j361/tL3/8y3P3d9FLilNZed8A0GAt3pyON2y6Xot/iilI6j0LPKgDQHQ6bpoUY0AQfbJHhcObh7fb7SqIZo+XU4aXeyyTCQX3/L4qmd+Hqdx6/nyk7/XPiBLYC/OuvC4Yn8d4wwlFx3a51xfzywjAltWzW8a47kvYonhw5tb7pSE4l+Tk20J0A5hEJeN1tOcnhxWAzIKlZ8v1JNe3uU/t26b1Cx7m6nE6p/OnZibjWlUDqNGkOSvnloBTW3LMFrvWsYTbFY8L0v2MeMoVcH5I7UPryfoDn/8ppLsZeZ8w3PCbLjctBeQxVd6Tin12PDUwL0UpWtw375KedTTCbMu+ZhbK9pKKq+USXOcvQKOEgDDNVX/LgMFQipZ4WSH+wC+mkAV9oVEmb69kKFb7cT2I51E5b50tt6ClEUAvc8i5cq7kz5yvmg2XHCQOFZXwnXeGPGnIl9PVAFKnjjowKOH9biFPixY55e0jl9+Rzm0yYrIAtHSSfQZ0IfQYq3AgjCdLtjWhhulqwMLK1LQu15HL633bbKdlF3C6Ji2q02MiTN99MtTiwwkK/vLAA0Sono50JA9FPKEScXMduOIE9oC0g8vpMTA9IQ21/Gip7eOw2+6diOGOtk9HGizSqYpFxtnsm4nbWpaF+UXikVsO7O2yYDXUNpVQifLzJf2Wx0KhxEz7VfkGc8tKIkC4cCbl7q2E+bLg8GbAdF1w8bWA+RIYWRZg97Rg2TGpeh8w3OXGg5SOpJeUjhnzRS3tAtC9HG4oXDLcLU3xdVo/kZ4Sz7rzLqyLPrMHk+qOGg7RwMCqEPC1YVYJhw0cDpN2yHUUYj15jOh+BuPt0HdMQtWsPA5Q2CsPRFaeD6nxlE/XCSGT5EJYiGxenzkKLceJw7wnqAeHjkv3V0CkeJ+05mWke14GAk53b3CY+1S3jxOBKMnoo/YSiIlTqSE9422m0jgB8UT3QcPy8mFLVoXaHgFzNMkuWrC+ljKq3i0FS340DDAhPP7NZe9ZzzftGHpcASNhNhPZYIp52wmh5axydvu5wvfnyqMBoBJtA+ldWZ6aD/F15XisTqLbr4Kl2LahhhqjJnLF07ye2J+TgUCl4fz8z/9JfADto+XJ+qd/8M8DgAIsjVuPEWWMyFJ8uMhfeZiAzSaeJFUDF9f2mHSfAPQBS3cT0t1E4M56a8S7syz05z05zFny6sTNjMP+sekMw8e3VydSsBJWtSYx/N4Dvrg2NftF12ul7TuzXeUVRP5rj6tqyJzyPF31CY/nPCsikeBlEtSk/FBvcQgNCFrvvF+EFqhlMxZP+n0Fmw9BswZPj9fbe4DVs0ryXS8TEORNABbAAMvZ+KIKkPZ4VXGqHB3rhbD8HAFYTVttfUPHuQLQEKv1/zO9k92XcNEA4PBm0HMQS3f1nu6cdwZoOUkShhOPFFD5PvR75dWk+/XFFTJzPJWVJwawAMh4gIylY8uT8zbvQ02qMGbD5L1nWHlZp2UlMwAQP2i4W5rSVM3yOwqZ+uSJ2oC1Z6lZnNC9lwrAFrTCqLJdRMNXWlkuGkZs9nvKej7pmFfhVal7mndV6qFZPAhN4cwD+NDrLn1kqZO/nvW5YkH7QKCzvUzwnJOANi5r4NPJDJQxqdntnE272z689t2GzN7r/y0vzF42bpcCY3NeeTc059u0ide38kYCcmX8/7DYhw5k/eAf+MmGYFiMCxWoyFcF3HJu1lPznoqx3d7/jmi8WDBCcg5caTkHH9KbZvJinfMcqkvauFr5dykuatdrQoTWiyUm0gMyg3rJ+XdfHHusDkDVAqHGi6WbSlZLJ5tHD7lLjYCfNSrl0d/W6qn09r/sI3kxzwBNLbp9DnQXdDst6xmcO5ou4oGyHBVrmmXY0RYCgNvPsPfnzECrekJLu/25Uixi4imaHvHy2R2f10931XPaHJfPa7z1v/M7yLfAZ5gpmV5AoD+sv3X+uCe3nlsuelmXv073YnzRLpew3+VXuZNeEac5xPSihvms7Z+2ITVv483M27exQR8S9KFBzTZjgLd76pfTp2hQra8r93lnQIAtodUz6bskMcfacLtg95R+9yFEgLxpSji/a9st3qdzWY/Wi9Wz+YLe+x7QDAvUY9RLatJB+Qwgk4oQvaw+gMORnncJACHU8j37tNbYYy+erwRhtwfqO7UuP0Z9pGTU+azy4PuiTnJQA1I85aXjzdKmzbnqYAnwkvWi8U4BRl6nFRit5XYcUE2x3YcbF6Ny4tjLKvuxMjr2fCZJICAtwB/8Az+5Op8Pqn2owoU/+Ad+sg7K7NodXkxa/qBxl59mvYFhym3oi00FQy9GChHacgw25GdDg5z90FVID6Hyr6aZXtolty+IfUl9eqx1wy4FZZ9qKRxDICdQ4wCQPTcDsLQkjxxfT75Aye58nqtZsNlnsdw0vx/jHq7nxotT0v9VKdiAn+Mn9kbZmH4XZWgKz+SVBytkKqPjVZhtaCEe21l7k52jGZW1U1WtGz7XsJjCzq5jzCxyKDwsIpMH/V80g6R9QtRd9hQCOD6JiEvB/RsBwz1wfI0BVKBrmE5QfaplT8tsXbk8ErmaMsD42plMrRpmqN4iAVp5AGauTViGgnzJivlv073ZPa3hyuG2en1q5lct3WI9DMotuyCQYMnvVKakbk9aTESsFm2m+Uruk+yvKLE/TgFlKIinQBpamTTEEKiNeaSsvzwGHN7OWMaA3YuMZUef8yFguOMw4X2mEPSpZq2RN6XogCmaTj41Px2z0TbKZkCsobbKJYw6Saihtsr5yfuAExdEFjA13ha9ZvdvRAVbyZSzkWs+3mTNcgy5YLhfmBsk7TOecENhyLsBcc5Erp7azzBn5P1AhPiLxPeF6BPTVTJE+PqZRyb7c0mdPIRWwX6p91xK4xTjpT1dxaY2YjrRNRIPogiRAgSCSwjMhWq9InFmGsUD0Qq9N6kK/WrC0qmGCIuE/+z+p9wAtEY6hp8blYOxoIfJ7UI3II4XvS/ynsSpKM1BvHcodaItQEsJ+qn2xarU7kjwtJ0BZ0KGN8+CygfJeUTyWCnQsSXQloKFE5eiOBh43/kwIA8RSZO+2useClo+tKWvMCdanCQElCsAk2PZ66njyJw/SDpaZx+8Dw3IEuR6esw3WjRgRItE1M5n89AALR/LWE1PDSyEJh4xftmti7kUCgua46wsBELb89Js13wCTakCD7JWIqACDDS+3wFYrg20nXTuJk5ul/vtVp4Q53Z+wBvV7Ev2Y1YXkJV3gz6GHmQB0Fp3AJWkEFMyMdcAq7o5pgOCuW+SIv2ijcdY0TzagbsWwXWQPUAJqIbN6THP7ByhXZ7LWiCZ/hci8P1r9dxOT+hzOaDqA5mQjBWwXPY0yB5fq9eublNntw3hWgZ0yfRT1fIKsgBoBt/4lM/BgCwAGETTyJVtsRmCdv/1XWrPQ8u+WF7angRJaTtpbz1Hm4mokg6GCC+hzfF50XAgnZPzIpX2ufYeBQuy6AffdnkOK8ii9rVA3IKsZrkel8+RQYWEqjT0a7w8i9F6UjkFA2DG24x4JE+3eNMsObsp06WhnP67LCALqH2jTGgXlhXxbV2R1uXQcklUvLY/fMj5SakoAVrynOyei8es9TQqmV/ERxdzntIEA5hWfCig0arLu9iALN0OddsVyJJj2lPr1C31/FwL9OT4tr1afNpV8VjJzzDQakDW6ho4kNUxX1aujOYBHGIzNumxlRfGtIOLsZYia/Yt55I1Cao5Bxn/+DnTfcgxJfzugZZOaOnzAwK0zoKsD0W4UOoQCsBadmfPBwBWNzz4gVRL3owNwNKBUonluQFYuj/beS1Fyw3UBuQaRisFPitFTZbP6wy8cOb3FcDyYMDrvrgw5EpH7GUA62xIzcyceqcXAkSg9dzsMo+pWxZDLE5F/4AKoHxIwHcEmmHl6jX6MJrMWNcZjeZlj3X79TlaALBeR9Tfp4u40sc6foI+52uWPnDRR/H8xBO49A19H+7a/YgnSwZnLfsig7YT8tTtRDzzWUQ8Buze9vvl7eaCZW8GUGPLjopGl0jZkj3Bw8J6XHngUizGBGRWTSgGYaIGryVciu7LmoQH92/JJIR/5/CeqqGf2kG6XgORBWgHNrtcSOUoWGWJ0TqZSej8bPp9TFn/AKxK3ozPaZ87/ty/Q8vFgyPAUQZR3/flHfG0VEvOh7OK8WAAa1oA91XxOHf7qVAKhlvykml90NU1IABe+03ZmJsQW65RzTKl5RI21evP28nz4stpyXv6sjC5Wi/0b2y4WYhQP5fV/QPASUvikWuXV89hbriwwUow2PV92R4nWrvyhvnJgNt/sbSQsFZubzSxOt2scq2Yt+r5vsGMbxrqc1n64bjQeyBDkrRBml4KZeT7zG8/NrFJ6FRK0eXLEflyXGVNyrVo6hR/AO0D78n6/A/8BObLAcc3xuZmHN4S9i2qxghrmgCGMzUtmmVTUlCXZ+MKnUnLRDJJ4imrgChKQbyf28zAUlpV+MwvmCOrN6rlMoNMkUKIQH3osvk+DqsOQUvTAHVbaxZg2QdZwo8hADlrVqBmC/I5NLWunDUDp923b0YvJBnq9V4uByyHiN1bhB7KEDFfDZiuqHRQnAoNIAx8SAaDAVYx/J+AZlDMu1hnf0tRgBVPM1RM1ep2gUC4lNOgtrQdm4rjFQLRNiy07KkWYR5CHUSs1yOAM8i4VMkleejuPkUrTdc0GCx78pwISJLiuOLJkow0+V9Lz4gnq7DkgTg799JhBd2PZhmyvhFlMZJH7PSkYHgRkHfA7hkBHcnwEs2fsJAHUcro6LF23stG5zo7j1S6N8CoAPefbEHU7mnA8ZMZ49OI0+sLhhcRM5fWAYB4G1ESbSPnunuH9KUObxYsh4DDN6QUi2T/Vc8nIhCP9Hs6cWjs1Hqg8i42YWYv8lkGylgrMVSvgQlpCB+yZt623uM8RO17tHzSnLGMFDKeDwnplLEcItJdxnyZlICuGlAXEadrek8syNo/q5OOdJ9ZCX4xGXeGmxX4PeBSK6sMWxvyVy0t9jAcEsJctBzMcoiwpZ/oIHSvqTRT7U/85MIDI8nwFN6ZJcBT2Sb6fzhSv5pO8t4Ufj45gUiyrwvMBBRKCZAyWFRLkACF6NNJG230osTqtRYTDl6YjU6hPV6QCU+sWcqoXqfaTzPwVO85auiQsySRjZcu12PE00JgaM6aQV9SbJ9HAKqjJV6nyU08fVjRg+/AZdDs/StGysdSVEpB3o96z5fLkbTBOHytVUk8qMoZiFHL9Kj3V3laXDqJyfc+yzMeZ32uQyn46b/zHQVbH05P1ud/gIRGj2+0TEjN/lkhZ3Ht1hmXKLmXMemALxZPlPm3HAhgjS/mFTEy3s+VtA6sULj3lqwBkrv2OsMRb5gjHPYIistC271ML8Rnn7g2hpVnx53Ly4w9d13PlRxfPt0MzGZFhVJ0llJDTn6W6wY74Uh4r4OTrZBBTI9/1k1+/px7rnegDgi+6KyYalDxuYgEgAAsMRHTFIFNAVjW4lyvTS978Jw+lrbFACyghtUuvk47VQXzt+l3BVi6Az626B7t3eKIhkvjlwM0YC47AnbitbJ2+m3UqNPr9A7Mj/uuiZEzCHfv0LEOb9Lvolp++XX2Bj1znhbnLUid7LmQyQMTp4xeokQyhdztvuox+B3yiSlsAnRU8dt9qvI3e93OeYvEs9UjlVsPXC/DVqkR4u3qVJSgc0FzLtKPysRF2lbb6rzvEs6dXrE/6dh4QxIOQq6XvmnW8Grr3aqhS5kg+XNqJ7xyv+X33rtchnDeK2aWB3/v2aIL8dXQorxUaM7Nh9PVu6Uh3v45xWlpvKhtI0jGqJbskg7BUUjEfLThTJixOG8SSgGWjHhsoz0qyp3i+ti6EvOwmGcs75g4SDREz22Qe356XUrXsQuc2/TDv+vH8EG0DyzI+sI/8WcBANNjuqDTBc1S6W9ZuZ4bbSRjgoqXS7oh8/WI+Xpc1fyTDiSeFvq7mxBdmFCRO3uGKlDqd7DnXL5nAZY9jvOKdS3FSnI/IzPQ3XevTbLYkBKbUKGd+bBL+ZweVrO/XUTZReKMuL7AhrSqyngND6pLXU7BDoL2cPIMdNLTG5mMzvVcldXg8JE+H6nt1AUsimq6dtL8IYPB6TrUenU74PhGwfGNgrw/fz/FiyVhKm/TY/bq3AjgJM9B9VwIQAV5cSzXdKk8JfE+jDftcjoxc8BOU2soT0Ct8VbBZDJeF8xXBXefXXB6fcHxuyZMn5gxf/cR+dNH4HN0suX1E/CE3rNaH7AeeDQSDRLClCzHi7fqesOd/b8NzaUpmwGP7y//Fk8sJpnRhg4tt4kJ1aLxRSusn/dmsHXheWp/G1IMpl3xxGHFJVdgxgPV+HxByMDueVbCNLDOOgT4vRWPreGdrtbrcWjkPTHnokCLB/R0z5/HKmeh18jsw7/D56zej/XDJmFE9YqNrf6YlKBSb5nj6ogEjx6rEwrMYyBds11Q7pm35RA1JLvsU9vPmOtlQ2pBVNnPcKqsbIwNQ0YH2LIPB6ZaIeOlJnjoHNDymXznqCGWWpJpP8WG/+RwxwnhOCHd0l88zjUiJOZKx1XhVvFAt0BLuLXCOZwvEobbBafXdzi9vsP0hGZ3yyV1TIIbPkj2gQwX/v4v/BQA4PSEgJGoaB+e1k4nj7GSm93LNbyYsOwT4mnB6Y0DhrsZ09WA8ZkBTYYMGeZCnIRCDwoAhGPruYJ/sO3swYq22evpQmfVoyQzFfdwx9h23p5/5V8Cv65IOcinbUsnqxHAmnO1mjXxoc966niDHjm+FMyvHVT3SnWGWDz2/jMXmA9hBaZW3BmnUk2ZNNw8Tr0uAc391QyYZdHztR3DOWLy6t5w5kseqBMWZXZLUJYyIvOeCzhfByADdyzJcHoiHSjvknlVAqo0c885MYRfJZl3eVcQJwrRpJObtcvjF4AyEF9p2VXekgAsD5LkmFoHMNP/caJzVFkK6+kqUK6VrG/DPBN7pJYnC8JdxP6zt7h/64BP/YZ3aPlMHexzrjG4PKWJVLqVma0AuIL9NyKWA3D5lYI9Sx2MxoNiM85EjJKudQsWmlJLMJ6PoT4HcclGiBeNSWaXSKr0TGugskf5nKejKwPAv9usRbHFivQ+GlQkNJQKRMSrlJxgpoIf15cE5g+tfrfhILk+pTRt1nDOPmlITTJO7fnU8LLn6JhrIZ6oVCcl/trnoYK1PEg2I32vMhsMBh0JXj2PgY8rBedZgmW+EC4b3WMKK5swKGp1hjgXDLcMho9LBUb37Vjh+0TlCAeoaCk9J/yzB3+RniWhHMB4zbQPdFmk/nnWsmzZXYfcgmIf9bDPqpxHIzwNA4xkW0n2kkn3KJVQ+PwPlL1v3zWxMJtavrL/oVZnUa+ehLAPI46fPOjvMumNWjOV9vUdKMHz4QkXCsCSl0AAlnaaCw2Qg2i8CG+B1192NOOYHo04vUGduBe3DAWNeKWg7bMAa3DudRvyswDLmnWNmpj32fIs6kp2ny8htrfHKPXTmnK/2n0qwHIzwbP2kABqrz2o115eBtHm0RJC/nKU9rNXRqSY0OBySKsQwSoM6lzfPnPoodI5wsM6O8uVDCmWnRBhUQVYj6VzpPXFC+XNZ2b1TPhbKxK7K+QrIcDDN9az53iqIcCel6EWLCYPnBeJFK+VaB3pcr48pzdop/nThMo+91u/DgD4Hf+NX1mfT8xYno9A7L8TF1+hnT76ZQdSHbCoRXj7z6eUuOoSu53nqiYyGD4TsPZI9LK9zr2beiyZrc/d9kTV1nNhONfsPYdF0/FMX/IuzHPJNByU3fmfoSqIB64bfudNlOzvQRja775kjx5DCmpwfz11Sg/VMj1nvDLuvmq49k7Oj5ZLEo7NcLY2X5J4ad47gWp7Oh64WI4YUEfdc7cv0/MW53K+rEzj1TfhTTmUgOIzY0FVvw+w9I5yJvs0mMiNFzP1moyqvSXeqXseV4Xz6LslK4VSSjspkWOKd/fFEfs377H/GlENRNNNtOOknxYc8UGwD5Qn6/f94b+gL9LNZ+kBHozi8uXXWUTvuCBMPONbiN+jxNKBvAjzVdQXZ7xZkG7ndkA3D1+6Ze2reyHTd8AVx55pWxcms9fQal11CPB25qgzVy48WoT07vcZQu3A/TL/AlpQZr1rVt5BQoHpzD7tfpTXYl4s514W3pvftgzkGr793AXyEHD9K7eaZSQg6+5T4yorST1ZoYKYdKRSK+PzRQmryyFq0efxBYnUaTxfkhV4Fgag8RAoL8VebzMIiDJ9HijFe76gQtXzPnC7KqgBas058TqdHlfNI+VF3dC2wx24ZhkfjmerMtte9vTbfCAwY8Nx8WiUtw0QjROBIvGKjS/o+KIiHjKFZefL2v50ovBeWMjbJhwxvc2lZvYJB2y8IWBF5Hlqz+m1guEu4PiJhYj3nzyi5IDf8Jm3kUvAJy8oLvmlF4/xaH/EL33lE0gD3ezpKbn7x7cG7FhCQjhqyx64/GpBHoHDOxQqG59zSSXxXE1ZEyXUG4XKCQlzXoXGLGlYdKFsOaYwMbl4WujdnDLyYailaubcvMs62JoyL3q/JGxkPA81mzma7SpZXCcRXDCYRJD5XpuCyBImkxJBoqAuoEeuTTxSCZV4WlgDjtrQJLxoCn+qg6IpJ6bXMKMS43ckzkzJA6HWGQ2uuLpyFZ1HCxVQ6TUJxrsVyZNqv1P/Qc9yKKSnJf3F+GKp4UudlFeA58nhSiU5kBbYfEml1OYLrmer4K8gTUTA1lC00UxTeR8pshxj9eyLl0myKwN/yuLgxFUf8pSOtVhyPC2cBJTRJDiBPWeB7oNkPVpJi8Z7eS5SsZTGc0Xl3HIbLfFjjIyRllYj4H2IOkZI369lzoqh+SylShWZa4ola9JZo3W5GzC9Rs4U8UpaEPsL/48/0b2W74N98D1ZP/Df/VcAANN1xHQdkROaUh3WdKa3SPq7uEploGOvCZdUkMLN3uKcaVbJfw1n5yHvlbVz4MRbKSoJUV3zbnZ8jvx+bnb2MiK8eVjVvPfqXBwegJTQebCED7AmNLIJkNHUa83oaq9tTlT3T/RyPJcCqJ4T2ZcS6WXydNHus2burNtWUmzDqT4EKuEQFdhkb6qAPxmXRg6VnSnqG2eSXIhTUA+WENAFeCnw510IgVw7eMurmmv4rjmORM3vAGRb3LddrqFCJtILf0r1qfYFyyX/HYoCLGviuRIiu2Q7Hj8hRFd+ttk7JXv40ovHAIDnR+ZQzAnTWwdgCRjf6kuAP2bF9gPLGojcQQ2ZtJOYXskYAA1fRj1SCsYYlAsoc5UadL37NnzR93rKAWmAie5Y2h63D8uDlN9DLtqm1JGO2L0zY7zJNZtybq+Bypq4kGU9/3rsklqezPrE2APhL68kGnmJDPc+yeQp2UzAM7YKFbom6b0WTT337kmZHC0HE8PaReAI6ckR++WaamkcOU+fCMOlefJ+ICmgIWK5dFkqZ6IIK3DDyx4i3AdJzpD2y7ou6SK6797DqnIaMZ5HAFpOx/WjL4u0pNj+zglbwZeeg3kvAirPC/0+mwS5+xzm8Z17+nsxY3wxQ0o1ARVXfCftAwOy0rGo0re8OFrc9SZjd5MxvJiUh+U7VF+fSkpljM+5c7QPRy4rgmHdUVRvT81Qax9aD47WnWhu/rrAywzw3fpN/qHtcb7k+8tI8hZIzZ1R+lzbYB74M+TIOgN1nzEiHBdMj3fYv7MGufNlor9DWBF4p0ueYYoLeB8wXXa0ph5zyNGQbrNkUEllAGmfSw+uYqSuYeyhyGNchWmWHRUzFnCi14B3KV4sAUrDbUCcqqin5141CtPu9ktGoVUlb1fg5nIWYpxo8BruytqbshTMps3K9WLAdHyDGjJdE7DyIEzaMj0qOD0pOH6iqKDpcs2DugiIPqb38/KqLXx4c087+fqXXqMfvrZHvI8Y37GF2LGyw9uL8i3UpF83YKWXIWuBhdX7ASrBdqV75DgsldNVZ9aiX1fDIS0Ao//z6p22wMYfz68nddvEqyRAwPd7mvF35/pDWf840/WZKt/M92PIpXkG864Wcm8+xTjL2CcPUfsIKER/LOXIuXPV55i9gipIa3S1pOtZ1tvGqfYXwrNchS5l0hbDCnBou0XEmMOH44s2m9S3Wwn4nS43H4am9qF6AeW51bGo25Q69hTaxutzxWmh6yo1B4EVFcKC6YcyqWmHqIlOdtxb0Uk6AMp+j7H9603OXeh+FX73YUz/7FlwJzScLGC5JcuL1Md32r7j4cLf+98hpCnp4MuOyMNhAfYi0PcmhfOaGV0p1e3ID/N8UWfE6chlJoSsOrd6ItrJ3prBIFWXZlNuQPkJrMtRSvsQadgs6vEeNBuiihHFes3EyyLaKvHMgy2/eW+MBUGlAMnGmqSdLQBZhyDNYHEGvHlypw/JSHrtzeeqonsJwNWXJ0yPEsIC3H6KSncIj0lAx+6ZGTxzzR4a1VVfcHxMIGjZBQ0jjzeztj2aTqbwTMkSX2tDC5qaZazXYj1j0zWX0TmQrpR6skSq4UquFZF0SyLukwdTCiY4IzAuHPbIFaipavpA6wvIEs9XNFpWMpsXnoOAuKSJAvRdQOzT38Ln80jOlT6H24jp8YJ4H6l8zZH0qcISasbfyJ+7jOGdAfMneedSR1E8WCkjxILL6yPubvf4zCee4stffQ14WuVThpuIZU+k9vmq4PLLtI/D23TPds/pc9lHjM8XluWoXA0rWRBEzVxeC76P2ldYkCT8yaU0/MMSI5WwYj0p1ZXqaArRCcSGi6kE310l/Eo/QNIQa86SDxlKX6b9UgHCaa4aQvuBnmPRAwRWE8WSIpZDqmEsQ8gO00ITn5zJYyV0BQP09VwK89hYY7Axe8gIIEbSnTOaUjnFqj0X6Fws8BfejPUyhVKwqGaWCetHcLYtryfvisx/+R0MCyWfSD1KzSxVD2WGqP5Ln6Dt8uFDnqBJ2Sw9XeslDNByOemYUYaA4WbWRABLDo/HRfftJ+RKFbGVJlzGXXBhunMkdimhpseyAN6MJSuZC6y9Yqqf6GV/5tyGBAENHSpR3qnIq/E4V+yYIaFoL7Uh7Tg5frSCsXbyLwknhd/BZZ9Yi7Hew1/4a+9r6PCDHS4MC9fCmuvM5hzAKgHq/aEf3L7mrJyt1Q1b3KcALIvE7fd5oQ6yo5PVA1j2szao90TLw3lmXfW2tC9sYw95rmw7vctYj/0u9uV37VOAJcwgnIDdOuwgKfa3n6HB9vZTnNjwWAaqdn3hM00X63O/f02SHIICCvrBDWShbV+3PJABXQvPQK3Nl3JfZaf80dkV1dkjINTzynggJR6jbsHcYoBVZ18KsBhwCE/Le9/kmDefO9sHYPoMvWP5mnaa9zyYjO6ZYC/V/CkvqmWOd0cn8+Ir1wCAL//DT3XXu/wSNez6V87uSkmtPgQm5qsYvMr7cK4sVnDhQh/aaNY1/BFrooTtQ3NnPRYwfZHvx1x2VSXir3dmvXPiwWqWCzjlxB6Rplml18u6gXg93fDhmeQYnyEXZpbJEBDV8abUMC8DY/ZYrsJyg+F7nTHlfXHWrNIKxJs0PtCXOhOg672GvrJEcdSF6dG6srWS5HctKDinoXW2hJnwqhzh3Z5T9bY6D5Puo/+s2XNbffeRiyF2f6eQslAG0mqZPb5mfvr3xKy7uk9OD3HFe5Z9nipve3hxwnCznE2I+XbZdxRk/f4v/FT35bt4k27W4WtHpOOyKjy5AlgZmpHhTbkVTD49C7BSbDlMLwur2YwMH9Kz67zEiicQelL5K+yjOZ4FTBbEZTvzeGAX/hp2OF2hlLMAy5rMCJV/JGPOGLB/njE9ohnhOYDV+23iWfDx9UjbAzi+lpCOWUOFQL1uPcDXqydnddeWfWQirMxsHwAo17V9jfI7f3pPwUPZg2JxNl4pcbSW6sXS69nR/aknVf+VwWu4CVj+a/eInzwCr5+A1yaUR8LKP78vKSINAOFg3HOnSJ6sJdD/J/bKvFgPNpIZuXu73o/KGSu4+EZGyFRWJiw1U7DL3+ldQ/OchqUQ+Zef0+Bm/ABeDZhlsFRC+yfL9HgPADLts+y7WdoMKgtmHqoTaj1X8bTQwKvcsXo+0sf5CUOzLwlxnmYK4TTaT7XtZyePnXYpKXvJLaHehWBX4V9jFmjlkcCTvkPR9A3qFV7vqwu0svE4iidFnqMzGaPAGaAVqIpDiTVDXY8ldIWOyGkXaFngJADD8aEeNA+0BGxYoGUI7g9liJcUqF+X48ot9327RF56WnEWaNnwbA9oyR/67/kqfPkQ0LJc52k9dqf7/B3LOPyOhQt/8PdRwWfvkhWtI8nYsA+aKrxKa3jRfM2lcsxNH59PymdQ4qIVFz3KiCVhL5kKiZuy4z4w+2orrbOb9Awxb5UpaBeNQ6thdQ5UeXcpsH5hPG/Le8rEXdsBW94FvdqXI5LrwKDChyZcIAU/+be7T9B9E9Vqmx59fEKaNMc3goYJreCgqnXz7RLPjHSkj369zsbHZ04rJ69naECd8Wl7pZblvrZL/p+uOIRhxDcBKMCTUKES2h3JnA7IbfcgTLIp5/Z71Q7i7U1zK2Dl63Jsf7cetjgVTSZ45/fUsPjrnyDxrLsjudLmicMjDI7CnYThzfN1ISGAoMsbW2rYxp6jCKSKWrtts2QOC1Ffng+t6CDEcNH+6YULz+hgadjNlpYx1kxe/GDiZsd1o/Y9XkmgmLbqu6fSD867ENb9ms3ss2334cjoZCWa89Fnpw0ZRc6g1smjgqe1CrzX6dJ9yXWRUKwcSzzFHSBWS6W0E2NfsqZ6ovi9Y15uU6tRLp16x9ptLf9G9cPuKSt1uMsN3USKD3vtJxnAbftEHkjoAQoS5fxlfJncsyjHMs+RcuVOznGg99iFKM941RpzMgddsxl5CqLi+jcBxF5GpKzHneb96IG3c1QXq7k2tM9hE/qHcZL48VjGsh5J3r3PWUq7MZ3o53/uT663+dbtLCL+jniyBGBpI7jTHJ/3gY1kvjQEcaf4rto/TEilGk9nTu80tQhZAJY+DA94saSj8YRZL8jm1m+++472oQLSD1nPAya2KmEQ6svh2qgvp56DeynM8cSLpftQZWgJMTlu1qp2mcw+6K8hlPIiGXQrsbnv3WpO71Q4xVuOK7PWdqZJtctiP9lAmiEq725GLCbihCLjMNyjvmJya2VM1Y5YLoBrt4YEq/Kz1YSzJrN84WCJEGj/JIiLJVpK+18lQHXxiBBO4QYNw4LDBQ3AwzVPbHYCTGRw5XfrGR0s3dDvw4v2M91TJmU8BRUUFVkIVWt/IZ88CN72mx8sD0fAhoYwUK+DnK5e3zP31AMo91lXrJ6ql3mRgwt/rI6dMxB5dn/mXW74KaWcz/CLkbKh7yvvUEOK6s2q4EvElXVytHMvkGgZTZJdyTIEneSeOHEBYAc6q9ekn5HpLSz1GRewEbwXTEOH9LdK+LCncGEmIqiALDqgT+tGTJcDJq78Yb3etLL7yv2Ulu8xgtfLIULFTc261avEO7F9nTFby29NaaneLKD2pySIHLtJMo0Z79C5yX7VqzJjkfckeRV99f61AK163VIFSup5chN28Wydez6YL9d4jGU4WXnCiBvWrOtNJlziteVz9Pjj/bZvuyfrB3/fT6p2TZgzlssBw42IgArKn5XEl01KrJ1t1EyYhIU1jIYXi2YZpheGNzJEYM6I9ydAuFU2biwk81yAZTGppWceFnb9lxQJXHVI8Grye4d/VWwW4zkdLLN+80Kcu2+W17XkdUaIJ+4H89CveFwScqmzc6+JJd/zLlHh5BSbh/5e6k4GyvgsCUAGTo8ThvuM208m7QyHo8wq6bvwtXxW3nQdeH8Fw33RmnXxlJvOkH7kj6PoKhXW36mFYWsZkuqtmg9Rgd2iQodAGQh8LXtoUeWSgNgm09XswAemMekIzpCqYNKuL+DO8loC6wZJMWoP6ryXV67hzffQCvvveYF5Sri6POI0J8RYsCwR02nAfEP3Kt7Qu5Hu2Yv3KGN8O2J6VMnq44vWM1ElNkifa3xOy6UEjnit8hgw3BaURPXpcgoKHkXJXWoMeqBaa7zVTjpwZpwWwz3jycKcaxKH9yavJijo8qiayYnZTzOb9invkQfOnKFFmIFmgpQP7cAvFRE0Y0yy5goBqxJjrRXnaQ3iodqR5l7Zj5RkcWJ+6Z3pFyUxJmdV6abjOS+BaIONlBxA2k7tJNaqeVuiuyYnmTCo1QrLQ0BcCskuqBdJJjmRamTuA72LEZwYVXQCJMK0yYXSVc/Kyq4EIB6J29R4lM4Bc85wlLYJfQCg/iNysermHXT9sijzU7ifNd5ObkJuCOlloLI5eYz63MuYFuQZNoCIeFoGAHtvljzLKaye/V61jkZHy0xMRBeuDJQ1jiHqs0DnbiYc0bx3fEz7jigxnt8B1Wz0zocQ6HwiSMOyFIR5aT2me4MPHpIlCqTNmC8G5IEKxf/cv/+n1ut98/bB8WSFOVMdLL4JArCaMiioN01LFogxwMq7RH9jJUXKw6iEzhQ0Eyjen/oI2rnNa0MfmC4or8K9LGd4VT2P2sq1vtJRMZ8WCL1K9qJYj0fRmxHY38WCeykFYDXnENpP511smnJfPQQAufGBOnCKe98KkZ7blxSPFRCkNcx25x/n2kZuxupc5B/66HE9fBhAyOYeYK226zx2VdZBzpvXfYgKqG07v19rEtK0dv/rRCJ7+g7pONzeUPanAKyeHb5EF+fq1+niXXyt/25I20VUtGfjczoJCQ3vbh4KcfDHufnEqmTIA+/FOX5Jz15yXVek2wd4LuuC0m4fdt2HOHaAVqQQgv1DOnnBCYoqyBmdR0smldOaBK/7Eo+ZeLsW1+/ZdV2WWOVrOe+5ZgGzR7ND2NdSQad28jV3kmEkiUSkSiRDsdbl4yZLoelDm5neNVeaZ3AE6rzjsUf7qvVAv/a+Sj/+wEPmng0JodZQdGgV+m3ffI7HJWHRXnTH8hmN97P+WPv1MGeUfeJM17Qup3amTmLX26QTfrRJJH6yn9HIKvU8pSuA5T9l8nU3I875wbHivbZvK8j6/Pf/RFNwNE4L4v28AlieU6SaNFIIuHO/5IVsAJY1650KAba4sj54StrjWZUtAm3b1bNzYTu7PASUIVXJhl4GhSGKrsJ2PiX3VexlmYNWvsC21bdL13fucxEc7Ty08yEhHUst/8Hu8VBYwT0GHN7JZwHWjgfk+SJU8CF9id/GnnIKWjZJ9F/yyOnq4rI24M0DLAlhSrvSVPS4MoOOnTFJn0tzKSwJPs70JwBLMi49wKpcrXpc1Rnq9M0qJiqeN5ZCkTZN18Du7Toznk+0wf0djUzH+wqw4gvSrUp3ASjAwB6p3bP1cy3nYbMf01FmtmsvltRqFJCsIpVTIW/GnlTX9V4B/flhr9cq9VMU2cnbHB4m+76bxJLuDhzQWur34Cc00m5pTmYF+anOzuNxqRw0mXD2+Di+v5GknXkxBGHep/B/JGQolSXgvBbzAsxGsLV33fxvOdM17AySPaAVZFAFqh6Y0EVuZ/p7sQZc4237vldtunr/dNLVAVoiUBlm8p6VYOoWal+xPl2Vy+BPAVqLzXZ0XZAf8KmodzFafb5/zavr6jXIBGg1pXyiufd2vynQNZbnzb0vJcaz5XPU3HvxkEgqhlj3GUIdI1wmoob2HqK5aCPlGe4sss4DfmYfPAcBZ1Nu5E8+//0/8cBJvXf2bQsX/vDv+jHakbngABr3pke7PvV+OdRZmBIEdYYgHTnXMjIIe3z7jtyc91Mr8y/H1bRtxynokFRr4/rLmuKXq6yR9qE7+6D17snLwoNiD1Vof+g4os0lIUa5Bj1tE0BfpEU4DuZ6ao2xaymNxA+2FPW0pNKL/vUTbafpmkHNVLB7XgzHitYXNXBZBzCgiU0y1XreKQ1bSEgwyHFrGwWwnLgty0ULLFZCooJZ5FKZCI16riS8IU6B1G5jj1tT3cHf6dOKuGpNwUhio3FuRVNFvX1+JNw5HgiZOyXFmYEKhoRPpR67DmVS7oPnhtXsSPYCcGKAAEvRM7LcRrkXGj6VviHK78IVM32GEaK11k0PP0cM9q+MpyJqX2U68zPiwd2C6cWdj/wsExXLlwqBPEfLGa6JT65R0vN6oCk7Tgi63DfHkwSgcL+W4tAJoBT59f11Kf3waC8rUrpRybiTvtdcOh28XeaYEOatzpFItxxfo2Wnx9wEeZe0hiftSwqKi+5aM4q5yYt40rRYcfNccl8nQIc/pR/ztRlt2D/kdl/DjZT9ci+Tm7zSNWCpmotWdFmrEzivIbV/nRRBP7T928qz+7LIDbCSLFl5sTrranvss2y8amVM53mR0kQ5F/G2WkCqiRv8Dvnn0Z4X71f17Hjdn/uFP70+j3dvZy/gt82TVSS+CnRTLH3RyWJnaEB9SFh+X1FxQX24+cbKgC8kS73gQzrrCoWLQ/fCVE04zKLxsyfNXqRXWVcshjWPymcm+bb3zHvFXmY9cCYAy8zMVkJ4U9vByLrTI6q39lBIK+9CLV0BrLwXWvtPxDXnojNJ8SRJAXHdZgxKaicegfGyueeEvB4PX58qkEjfRS39rEUCTiWZwcR534Zbar8Qe0MGkgAoyRJ0kwcdQDoeNPVk7dr2LXsGVld19p9uIuIxIL2IGN9OGJ7zQMFAavc2HVg4V+MLatNgasR576HcN/HUpQfCpyWSN0AzwlQ0sv0MIhJrPY6x7UDrc9MBz6aIOP3j2/zAffcz/3PvmX2/PJHehxRtcslMRPhzmY8AaLA4l0zTnIhrW6eWabi5p3PIADKQ9wy+XMKPeu9ZzqaIR8SezzdhYWZvlysH4wEWEZ9rLUqgPmvildJklLECd61QwJUWTk9onSN/zheR6xGeb6N6tcTbdEZXMC4Fw+2CsJgsWDnPnpfZP0uD26/xaiLnNTgylgfyLje1/+yn5VsNNbxGP/QnI438QWmV/8/Z6hm3u5PrJpPy0Y0huhNTqzO4Ej5uQq/LhkR/KVVO9apkkHECxNgF/5ZzrfzH99G+LSDrC7/7i1Uwj2dP4Tjx3+ldAaxz1gNYPSshrB9AD7DU20WhPZuJtgJf30Ln86C9KsBahQ06wOqcZ643eCQDSIGV69uazDaz5QeAARZa3lPkulsEUCu5VZc7dXQhrGqo0ZgQ5BVwGIB1ztQ7YgBWb3kZyLuW0xpgCblbAMlK0b1nWbapAOucKdH7DMCy65VE18gCLGvHT9C2p9dcqKpjF8y5OjDX6vB1+ty/s173IYC1WvdE71s8kafO30tpu5SG2Yl8S6dW37n71gVL2R+n/1yo9tXLyo6gA7ReYfKiXqCHhE2dMOPK22aB1uTqq57ztL9MhgZYh4teBXS6gbr4DD2ABjfbnlVorAVaD5kHWhq+7/QJ6t3lUlFST9TXNiyJgFpJVI5nvoraX01XIqXRAi2VS+mEbc8BrR7gkglFMBIzzafsg9X243HmTPlKbJc+rge0yhBrSaRmhy8BWh1bAa1zk5Seh0oB1hpolZEcHXWi1H9XV5GTnr0MaMl3qYsYwgr0lTHiC7/7i+eP8R7Y+x4u/OF//EfoQAKkbDhKvDyefB5RHzwJ51yMlMYq5SdEcM/UhZLsjTKEpraW8rSsC77zcKxiu4ZboC9cj2z6krhyrZcXoZl9QM1qNFlRZ4noYrIPe1xbGd1+2nNVAbnY37clamY0WVIrXSnJhhoTtO5VDJi4luAyVlAqmX/pmDk7L7K3iTqMOLWZRvRZjzVdBlVSDwXYcer/ibkYScETdcJ5oAFfBnApKpxOVAFASmGgVA+nkGBFmmHeU2Yh1U8j0CUAa0VMD6jSEfJ/AqyH1RZsJm4W8dKoZBBvJ/wNKasTaD9xInA33Em767npgHIRaj3Cy6KDYhbF9hwQFxIjzWNBugvqCZDjSfhy97xg2QUM9/RJ3Ln2mlo+Skl0TUQ0skTUrCtUgChhwt0NeTWGW8m0WtMF9F2bMvIuIS5ZM4JKCpp+HoodsEqT1bYqup6x5k2ZmTQ11txXaVY02/qSVtaYmGvDhaqfJET1no7eONB6LkU+iFdDwJVeJDNgpkTEdSn9VdwEy3oB9ztq38WO1ltKv5IFoNp9GsYsJuXftEH6gTKmFqiWzro8uIVSmrAhSe20vDSR68lc6FkSW8RrLRSD4b7g/vWI4b5gug5Id0W9WAL6d0/rRGW4p2c5nQqBlUJ9jXiRhdZQBuo38hgx3M307M15lTlNK9d+S59NSc5ikKHFu7kPiqeF+6LchuDk+cv1/7wbgBi0j9KM44V4jOL1KzFoOF111I4mVOezW301kdXvfPsK1qDeD4E+NC6eKUNS14iHWZWqCwjYEQ1H7kdS9WZ6iZDm2cp5pfVWDKez0f/S6Eapzpilivf+7N/+UXwLdnaG/23xZDUAy36aC1x4wD7XIrkocckEsNj13YQL5Xm1hWNzUe2QLoK34KYTv9VzyPVmvJRMbrf3GYYPEQ4FGD0EsGSfIbThFP95zqXbCz34TBifeefc0GHO2mkqh+lxO6sNmeqIlRQ0BFTTvPun11smgEvurRSUnq/oz1Zcl3WtOOFyiMqZqOTx6j0gWQcSLAwzASzalwx2fPwZqmUV59KQ0rXNcssNSX+4J9BfRUNlYH/gGpwBKM11SQyuOplWyMB8mQlkZR6QbnjwmeSzHmO4I0+iJBp4j4EXT7WljLw3z0pJxBN9WoAFVM9Vw82RAccpVscHMuga6yXFLKX2E9ZMUfMuwLImr/y5EljAOrwvq5RCtQKH2AdYQAVQcw3PKRjsZe/1Mqt8aOshk+PrTH6oAM2fjx7U7b+UBmB1zZGb45xX/e8qXKgDcpVkAchbNNxl7J/JX8Ges1Ol3qUK2j6Vd5ub2rmvKnDKH8tI603XsUqRuHq42YFg+uJO2WW5Ri7tRhMPfp69tMi5bEDBJFIm5p5KJtmCzypBo7xS7rvGhDymhzMntcSOA04PTMCb0Kn8eU+TTBJU78t4tVahUwfOdNKD5rxUJ7Ongn9mPJWwZ1MgW8SNvefrIR7ze2Dv695/+Hf+iOkw5OXud0iNeVrBq7gO2VZlJrr7d2DvjPdIQZoFPg/xI2QfLyOpm8zGxotl1/H76D1M50IWfhb/0DJPiDTmr7d6W/Ydl7RbR/YrA6oHJCHTIG51ogSA+HBA3gVM1+TRktCddHAvfkPL1aA2gENqAfFUVLG5eACaqPNfDjRDnS/jKowhnp4avuTfO52jFx5V8vf9+j4ocFFwIgPNalU1Je5L83n/4sUSDtZyKERoLwF5J52dtIU/hSx8ApBJWkGzGnmZz3ake0XHV2FUJ6OgopIzCGQeCYxKdpg1lVwRsrGEhzrp/Kpr5Muc9Ep7nHv1eyDk3MTOjx09gWKf9OILr/M6Yc7Vk3wuUYW1qADz3rl3flVR4iHRZLkuClyqN99bU6AeUODX5Yr5QfRcf2W5PgziVLFfIgwCOEz4LEysxyUDonQnktgk3L1Txu5FRjoW7Dn5RSYJl19hAPaN6sUC+oBLS31J2S7WwrKJL960uoX19rzMtP9rPXvdVUv7Tsl10uPy5NqW7FJpmp0bX6UGZYwsZ4QVoAqrseCB8zpDNXmoDFD1MJloyhnz/LKHSgv1Ki6cbfcZ08zXKeOHf+ePvPqG78Let3DhD//OH6GXyrqwJYxlgcpQb0BJJHan4cJovFxY862qeB2FFOLdrDdJXtx4Wmif0kFJG4C1t8fHrh/yXPUI9Kv4sussxfsk64ZQw6a6UanL7HG6A0TrCq3SDz7Iz8ez4qI80+zO5K3uSqaXsIRQ1YcFZEWqC5bHSEKkA3EdSgxa3Fe8SCXSSyjkzTJQqDB3UqHl/h5fSwgLcPsZUjoe7opyuSRUJiDo6ktU62z/DnvPTjSDiaeibdDiuYVDbylgPpCI6nRJ10RJtHycErldkWfHgY6ZU6gZfeJBM0BSQEy6Lwwo+btwv8QtzvuXcGNOoTqepZ9k0LlwmFWyBu8/UdtYARZQUkEZClAChltaZ/+NOnuPM20js/3xRR8IWRHWuJiOfDADVsebFxcwEKN7OdwTgJMsT9VEKlAxyLBkDS+UFOu7pwT2qMvs9WvfHd5Ewmzm2QVQxUjhtvPm32X15InL1CxTD3INda1MAEYp7YTOTrpkWw61qGzNNIMI0Y63OlQg0pyP/ZQJYgjAkIi3c9ir90FBFJcYC+zNLzFQdqHhsCi4mhbltyxcriQYAGXXfWk/5K4RbQMsVyNCAU6PR/IEcV8kz4+Qx+fLiDgVTJcR423G/WtJ3xWlHqi8SRW9TRNlKVONy7DO8A2g59fwQkuk42uGpirUZ+REgCeP5OUXoeBVqZrCHq0ik3fwvsx10jJR9d5JODmPLPrsPFh+sm3FT8XScWmLn5/R87JeHV+qqi5Yg7HMyWiipSWhe8/PikcSMI1zRh4j4pRVANXXlpTQq3o4bRH32LYFQCMALM9YMdGe4hw8JQYq3xersGpYFvz03/1xfBN2Fg2+L54sRYSrUFW/YxNJ/sBlKGzLqvqwdJRoviMFDSl4t188znRD7Mv+MoCljep0YGKOIP8gwLIgyXOlOmVrqOFu24dspaXV8bSp564zSDjzoqyr8gZ2Xa+q7snldj9CHuWOUlS9ZWbas8uv0hT0+ks8k9udvx43n6Vlt5+pvLBz21SZCCa8SiHo3WrVCvwke1g4Uw9kKlmABfSz7WoHxv9LM3XmTp9eBb9XRmc5VIBl29bzinlNLtGsEi9AzzyZ96GM0arKzp+mbNC6LS48pJ6ONYtevR5u3X5hWW6Ln6m/2oSSN37g3dO+5xUoAMrLdNv0QhRO/FIlZTryDCuv1rlJoPRNsq/7zsPIqtm+3mE3e0xAl+/velGGc+T6h6IBvJ9ZSOidQsu6ewZNh2/Q83L59fOCqlokXSRFuB+SKgPNflWLi44tE67lYn2O4l3S8jsPJF4FA7boQOLVevnz825MJ3u+BqWtN3vm+X43XqDV8RigFwaEAvYA4xDZV4cJiYkTKb3EdS1QC/zyPpEI6j6pQ4YafOb5yAbMrk6SsYRzSkg/8V57tF5SEe6bsyZdOQSSwh+4fIOdzaAO6mGhdZWcxyTSMGclu1cyWzsTWsaI4XZuZq1KdhezGlCFRzXpqB7ySslM0LtUTVYHzbbq5wq46cyutJ/SpiGteGr6m21bPLMfvRDVKyBt9+i9OZ8QmIgaGnAlD7cFS1ZbRGeSB+bR8ctUBprhJSlpccqQchZhygiBAHGZeCY4LyiJSNA008ycjbYg75OSO+Nc8OSXZ9y9wQBqBxy+ARxfC0gLpW6HwiHDDNy9EbF/mnG6ps/5ImG8mZF3UcnUlOEYm/PV4rUDSz8wiV49TTAkV/vm8PI40bmmI81SvfcKoPNW4n0MSHPhc+fbz/fUlpvRe6AK99zp782tvyxADsj7DBRTO1BAld2VPH484EgygXCnvCp+icZzBLc/x9eyHjINIYoTWUCVLfBsa7cFEgxExFqAk8t5lDEiHmeUISKeFuXUAeY+WjPP+Sub9TJZs57uIfH7RTo/CjLOeW8A5TNC+kIfppPtYzTctDPq7iyzIORfbdc5i9wPjwOV5hlTbQ9Q+2MQj0hBGf+ed4NeQ08XUCVwqxG4ej5MX2uub4mGq2PK+KTjAuwTSiagle4pcYY0qKoXOU6Flt9Ru3fPwBVBSLJh2UXlXKVTQU7G0zqJLAmFHZdDFT2Wd6wSpdlbtaP3Yrhvz1cuf5wL8i4iHRf20lB/GQxP2N8XFBbgzQWhBJzLRo3cd2lZIldex3IcS6T3rvB+8xjJu8UeMiLLd4j8cu/kHtkx+wygKSlCSOUoJLqq/azx2JVIkYOUMkUyThnz5YDhlp5H5LICWpn3G+eM+XLEcDshXwwctUoqbkrXhd8d0+auhMNEyRbp+VG9xmVMpE/3MpHWb8LeH07WNNe4vtd6kZs6DvRnORG+0KoM9qJ3ZaQUxBap6yVkQ1aQV3d7sz93uqyl0XCk2M5KQKS48pgV744U0qclf3rzM1pxa3q+1quaVkY/0+HatqyIfyarM6IlCzqT2ZF4gXztunZlPrQjMfdEQZMnhrqyG+267tRch/6QCWCfLx9wRclleoA8qyaOPgYzAlx63qvKqeJzMwWwz67L5sVZrS0XMvjJM0C/a33BjomXTTxYHtA1pjNV/nzgemjJH7n33jtjTT1N/P1MCRYAWtpFJk9aJaLHG5Ld+7DVQ6ResYcIwLJIsplehSt6zuPT6cy9QrwKLPb6gZdlITc7NuAQeLCEjlbZkP2fXCmfnr0b74fzvD1UkkikPDRhRd6103obmfhVgrmZ6DnTsKC+u/wOdLiTavrsywSzf8+z0CbMWCXt78r/CHgR0HnuWZoz1d89LbWP9F28+95IDxlSPGC8RJYyYtsk//tP4djl3GgcrmSQHH/MJqipqCtPcufLoV3XnpNMOsXDeUmu/HwxIF8MDZ2oS885Z55LOhmc8jLe9bu09xxk/cHf9if1f+vSbrJiYjTqrWg+Jb5feDZXDNfIAwhxPYZMFz8YfZ2zAoIhQLVczimw90KJvvM5x5l6BWBVxoHUbgfz57gPDSCyD1+PD+IfCtPulevfPYAlhDbGjfW104d4V2dFHiCI98J2XJJWrJ2jFAD3ROdZUpv5xV2Krrt/kxCVpFePNwXjDXF8lNjKoGt6RJ81bCbXEpiuByy7WDlg3CYBL7UYcViF2YJ2Du3nKpsQBogIB9qEUM8RSldAUvab6f9lV3kjtUg2t/+aGr5cZJShICyhDgiqQxWabeNE14YU9KVNpfm0xbJfZj6MGM/jng+H+T5WnMHdkNhL9mE/+e+lpXxCICL8aarZf/5d9wPfkts/wPDFZOBjb7TIOFjOlSPmNxPGaW7EpFfNNXQN1WtSjaQ2YlH3n1BiRN4PFA7aDVWOh/sFmchJSj99gfI56dgMkO5qgo1yMO8ye51akOND2OmYjfxBaT59xhvxTglICc1A3xV5l8wAHnIhvrAkNZypFCCe7TDn1XOmQNTwm+Kcu/3JCnhl2W8B2CMEy10CVvysJmnhJUYZfPR8eseEAF8Nqe4jiwzXa5a1LqMDV3MttxTdc6fVXkwbaEWRjlhf5yoLU2WdNOvXJ8BNc4NjvlV7T4nvf/C3/gl10zWgSl3DfOJS7kEyHqTS9lLde56L5au8L4eEZReRjhnDbVtkutmfJ3Z3+gl9iMVF7md65hqdrTvoAZo1FfbsZB+5baroYlktO2sWzNpsSEMwLVYnS8j3hlRpdUmapgnJ9UBex8UJECrB1BDYxxcLKFzm9E2coGudebC3yxGg7TrzoxHpdsbNdx8w3mTcfSIhZODuU0E9KwuT4YcbAlrXv0bhgcs3KRw53C5YDrFpg2pyBcpezCkoCV3Dh4YHNV214ENL0DygzK4dt2bptQDVuvm9oKpwy05c7Pn0xLTlCe1nek28f7TO+Bado4ArYF0aR1Pen4uXscCGS4HKVVPdL0B1wOSae6+ihHREDyxOBenUJiDYsiBCklUvltAGDBGaDhTqrN88282AZPoZ2adqBOkFbtur+zXLJISu5r1OQhy275iAVPf+2pDMOXBlvTleKiK+YPXangTEuclhj+8l4cALmiHkS+Jh6btp3v2V5A7vL1/xtqJVaIjVOvAVIB8SEZxTVM9jmHI9TzPBIz0xC+raAVJFNweabCvBPBcDsCRqwhOOqxFhypivBqRTxv0b7P0w5PeayVwnfELULgFYDqbWp5uIxYUoC3Gi5304FqU7VG286pEnAjcajb5zkRKrnxUk7IUKMm2oVsrMaca2PHryWFi/hobqBUyemQnZ50u2PzeRMM+qJ86vwKTZh4whSkfg/mb3bKrjgBsz8j4BS6GwoJHIoHePV/Vlq0LdvgSafHoeqC+pB9df/Lv/1V84c/IrOztzeu/DhR5gyc+dVGsluO1b93vP5OLU2oTy4PdAjePayOdD8dZzXqzeOuc+uw133rKHmvAKytOrthjv3kpuokfqNzNhWzZjNThwSm4eE/IQsexjDc0+0M7hpk3PXnHj7CkI2FDPlgt5Gtu9TfG361+lWhqXb9J+D2+t23L7Odr+rd9O32++i56v0+O1W6YmUsgP/Nk5RSsTAfQ5Vy+1B0CzEGyVe8XHm66tp4mWTY8YYD1eIHpxJRYMz6rWj5bzEY0uCWneVw/WQyr5tc1ojv3QlEu9etYbZ7ft7HcVOuolTsxu2VwHx3UbZDSUHx44xw7Aao7X22R0k6YH9u+L3qvKfDG6fefA1/FE3ifLzexxvvz/r6otZs7lQeMBSGoe+vtmTYnN+tmqqDemoVPuyyWMfloDAK0CIJdMvByd6gDDc0L+0mcc3qJ2756/3MVayennH/LjY57wXAdMlwHTRSDeV6jhOSHC6/PEgCAsGeeoL2JliETwtlne0r6Hnkuh10jTH3rse6FLoO+E8O+Yemc7YX3Xh1fO5fp6atKTHFqLpHcSX45uXHHl3F7FvPwLYDGCeT7fY17W+8PJclaz0IgD1cZRW6Ciy9jTYuO+coGna3pxh7sq7Hb24fMAK4W1J8kBrKam1zkSew9g+RfTAaxgXf0SVvQzYN8mz++y4Ugv6upFCR8gK3bNAKxzpvo43Enkkf6Gm6UCrGMLsOQeavzfnENXQb85Xl5lku3fos7z4i3a/8WbJN8QZuD0hNY9PZZ7Sfu5+yS7rHeGpyC32SnOW0AgBNJzAEuzAXMFMbZArDXhglhuk/zvAZYKq5r9TI/50wKsMzbchaadveLOEkZRoMVehJDptzSV1SzZhi1FCkLFWUtdRufbXtc8RvVWr4jAPmSR2QtgwYgPwVm+V+bvjte0en+j+zP7O1dkGjnrs6v6PSvF7HpOKu75CvwjD7Qe4iitgNZDXm4fSSiFCkYvWb1YYhZoqffEc774fLtAKwQlZTf7lfvOQCvvBwIQKaz6fwUj4qUwWlpRB2xuiivIXGKoKupuezEBWumYkY65y/Otz3jRz7gUescDeZPFo2yLs3vzQOuhUbYBO8V5OyVM3QFaJZH8AQK323OZDNASGQyS6HigzzXv2erd8+aA1krx37bFAK0wF6S7ZZ1dzpuId07ujx3bdRx4AGjq8fVc+qC5eZd7QOs9tPcsXPiH/ut/vD6sXlLBgg2O2RdfYymE6t7zHKwgnXR9iY+fJNe1DOzDC5q96MvVhPhcjNsXOZabZ6vSK+BgfR7OJtJ6SSmuXfgCmjzRvkdsDKF2ltk9BOc8UTaMonHkGnqx52StCRUCjTbZ6piaTcQE8WtO7zaXUPkWrIsVFnqBhrsFYc7kbeyEe/KY4MMBpGnkXko/U16KDsLyEp5ep3bdfFq8oMDdp2md428lb1f4Gj0jr/0X9Pv+ab02KkIo3AABNx2AKRwvAVqybbprvUt2mVgJBEwoU5I7L+lXnKdF6qxJVuPpEU0yTo/q/iREOF/yOzbQIDA8TQgAxqdBgZ8XHgWgae8SPhxZhd0DS6B60orzNNhrtJaYoH8kRLp7wR7ouzro2SLQYVpqaG8hr1wDNGxnKZm7EqKTjtKUgKKD180VQAnw6U06zoT6/DvbfV9k//IeKoH2gS7TT4aY09L8VgqFx1gnS/SyGhseSA53+5M+oFwd9JwkIzowqXqlA2aPJ/u54P6A+285X9HMAihcCFTAsAI+9tJIM91Eqk7Mg77zuslcoxolBsTbCWVMiPenleCl7W+nxzvEU0beEadpGYlu4iUUQi5YDgklsAp8Crh/TTz7vHszaRHCvOjM6TMvwqm31TOj3KxU+1A6p45HVkJa8ljKo2GoM+AyaCpCKttKqR1X1sYClKbyRQgVYJtxaZX5CawpOGjXqbzUNWjRPmRw44xJRNq/zWP5vXAvYrONBZQeMK6cFfad12fMeMWjeWenedU/hCXjr/+Df2V1Hh07i7rfc+h2FmB1bF3pvHPxmKQuACsfEvIhKSoWtL1ccdx9l9htWz1mTUZgqMUp/YuoxFDHGVopIjcn/IBny5/vmXXOzhas18qTEiO/DMEQDpelLjfesqqo7GanvUGFeS6+Y1wX7hRATZsOd2uvyqp0xANOtWaQD502Cv/ingiL4/MZyy7g8E5Wb9V8WTBfFqRfO+DTn3yGT/32ryPMAU9/Cy0XjpHYsmdxz5EG6zxUgFKLTstnUK4RwFmEsrviPu15oPPim/3Ls2YBlv20fK0uwDLH1aMUKpWzIsHORaUmciIPlABHnzlY5RsYNBlwWLWG+BmRASJAPVrivZIZvxBcVwr3/tLYW+Rmo2eznhZ61kMpZ3s0BWAvm5kD7Xsn+7efxttG55L772lzDrn+CdnW61/l0ogTKzdUPm1fmtLDnix3zTR80/EC6DudUrPNqhTYQGLReT8Q4dnweiT7sPBgL9zGPAaTTSbhVf6Q8OBxpjDalGsJtCkrMEgmWzzwvRbaSGQ+ruXYhOOMcMcCq13NNd6vkt3rcbyNDJgO73BbedyX5Bd59rVfmOidEqFTACZBy3lThvqO5V1sgZLIAnmAlSJspp48k72My/fEHggNrtdtJ2w+mSaY91k9lVwmT8oGDXcLlkPimpax7jfnlWethibLgxnxr8Rr/mbWfUV7T0DWH/rNfwyAmYX03G7OAyMve7e8gANfyytwtnxdum5NKJ05+g4QOptUgLWTeipmZmS9WEDNyBk7M0rnPXppRlGvnQ9t4935D5XYsPtNHLKVB9g9mJZ4u5Kq0NnH+XZ5l+5D3AZfVqO+nL2V6UPBthaTXrdlfkz7e7Ind81wE3DzuUCgQoQF9+fPYcXPehemHp2e8LcHMmMLRKyJTo9kTCrAulhfnOEFHWz3lLYZbwz4vZVO+Px9qN68FnD17oNIVOyf5+b7QxIQun9NI3+g25G+3HtsgbV3yL4fGtpzyzp9RnFh/FeR/liHHTuzdFcjrXoEHjjASUZtmVTWc2poFufa4zIIH+SSelJ9h/u02r94wHYdFVxvQlJ+qBSK8G4m9nrfTkbmY2k+m1PQdZznone+MtgL0GLwNNx0YuZsI/O45HO4Oc8lFQFfzUAU/N54+9trkXcJy2Fooj2BgVG3RFdq30Wxh/vTNnT30P1d1/l94Fl9N/jNcUcbgOUmVr32yTnU0kUP9dNugvhQf+1rNcp59zjDbmIi+OabtW85XPiHfvMfW1+ITqgtLLmp7i4FRrXwMxcdjtOiMXaE0GSzZfN/WAqWfSQ+yCkTd0e8LiIgt0vU8kjeHFv1vOFHWZe/Pxdx5Uu4AlCPT3fW2gFIJQQTX5e05FJdtDAuW7l25v/G5qWdHYMfhsxhNxubd20pg9SwSm2pEVgXdNTQXtlF5EQlc6wAoOU0xSNljVHx0oxwXNpwT+CaVjFq9o6UUtC2A3QPOLOnW/kdAGJEHiLKjkj4eRdxepTU63NiQuo7/62Mq889x3c/eYq37i7x/D/6FHbPgIuvVwFBmYmGTJlC6cRhOifemRNQBsNbyjR7DQWGy8NNDWj4WJqBKArwx+r5mQ8kg7HsyEM2XdE6i2QyzZRJGDLxywJI2b2EesB0X3v13TsBKMD4AgoOBViRZANUEoJkMui7SkzI6xCgHI4S67nYepJS3iieqCySBa9Am40lxwi5IB7pusVT1smQDnw2XGgHWeuFtZMceabte6ahIqy9UUDr+Yo8GBX2nPSeN6AeR55hOym0GZHg/cl7eIYULH2T/WzaKn0Mv+dBvF69wc9O5Gw91g5dofDkCgNzXiXs6vZLFTJKvQ4qulwzo0uMyIdBB854WlDGVEM/F5VvJeW0rJTL8JyzwaelXnvpyybalxZBlnGCxVB1bAAQb45o5YDkhWThVcli50lwZupDOC4o+4R4P9N5HBcSu+VjA/QeCJdsuTCJM3wOx8cyYeC+gzmh6VSQJjDvi5tjMhnjlOm82VNVOKlIQIXW8xSO2WzGH2ANwgs0M7wMUSMRsg8R8pRSNrShe8btmPgq4UIOUa4yfv14I02NoSthQ8lVNTISTrlGUQxHT4SK6XrTu++jBBZ8N/1xZyxp3vtlad7Xh/hqf/0f/qv9ZXzYcwu+dU+WBxp2kc8Wk1Tgw9rzk51kw0MIVtzPWhfPhDZsPUO7rD6keGmH2lhcd1hn130X4cDieCRnxeFsO61CvX8oHuKA6Lm0XrUuiNNEATkX1wa7O02HdqEIO/CdyY4JBRQOyFCwUh44lrZdwhHy2XEiXvwa3funR+Kf3P9GQjnH19eP+3zZepOKCddp3TOXgafes0id67Jbe6ke0pcSIUMJEZ46AqPHN+STLo54sHrCpaPxYNHBoTUTLRmf/mnbR6FSBpO6TJ7NzrFYr0x0y7RM0rHz/strptdEOsrOu6MhfPPbuVJRvXcv8YQlPrCOO5Y+mw/1gp5b6CY4zar+3ZH1S824rvId7WfjuZtbD+9D70MFnk7vqmlX23c1wot+Xa/Xx6At5FxVuKX/FqFII+lAg3pZZbh1y+N4rox4nm7XSr4Sjlxlk/fApwymJwklzkAKiHeTaimK3E9kLq+2Yao1/mpBa/ocO9mJIuYr1RKqp3z9UGnYlK+x3N9eabEqXeF4SOb8Vdvr1LY3zHm1LD5wz6snzoWHH3ov/Hv20PtmPFi+8LcsU1mX3hgy+DFyfYhu9OzsujKmd97Xc/ZuIlHOvvWyOj3Ctny1HqxSagHUEHSwbNaPAXk3IB6XKpMvy8aoQnAA9OW12W4BNHCXfVKED5hOxXmJtCTGyCJwKa09XfbcLGLvkWgf8mjxrGClwWO2a7xbAqS0IxLtGnkYHeleSMHWm2Xa0JS84P2qh036chaAzayqq2BsKVoAGjBucgDjbavEradkyMIaRhFXueM+2NTjkgJV4iloZqYoBXlMNNtJgTqmAuyf0Wzu+CRivAFefDft6/pAHfXXv/wEAHDzPRmP/n8Rd58OGF8UTFe1lI3PLso78vQo4DLjVmRPVgkw2YgFeQegAHEmgKbFnwHMByKaL/ugM+H5kgDQdE2zwumK7sV0VQHR6TX6RxTdw0zgaLiNKADG5/WeDrfyWaony3jlstG2khnesgPSBOabFZQELefTeL4y8a+Upycz8/uFhGlPRB5Op4L5INu311Qss5Dkso9IJy4TMi1rfRwHsMKS6dKFAMyg0H5KhhdH77OdfduZtHiiu1m88t7Zd/sh01AdlCOkukbCqSplDaDOhPK07JjlUXq+loAnKQ2WSx0M1XOV2OMXm33pMmlDCLVgNUB9y26k68DeLimJJsckKQnqwyPzsvIwKHhKNxPm6x15qVX0s2BJzBkN/JzNBcvFoPwn9eTfnWpbAC1aHXncKAOdcyioGY4xarhVvYSzeX6G1GoexgDsuag1P2cixhxy1qxX6rO4UDmPC/GUsewj6V8F1mErNDkb7ji7udAzd7oK2L3INHELAcNdRkk08ZkvE4abWcGsiI8KKJL6iIW5tpQos+i5k6e09usiShoW8hRmRHr/LVe39xzKs9FECoCShdsY9TlutrXjGnuUVrQCuaeeB2kSmLRdpjxQKKXxeElNQ1skXL2/AHlVYYA3v+erNvlxOgTW88t0np3aoDomvIrz4iX2LXmymlilv/iaweZKQ+gsI1ORSMOZ8EUkLTqVdNh0n2n2zA+5TfEUoqT1BDUzxhBaQGHW1RlDeqCz7RFv///c/VuzLUt2HoZ9mVU151xr7ds5p6/oJtAgRBFEWLRMCbTCCocdNMVLhB/0C/wL/GiHSYEUQVK29erwf7AfHA6H3gQQAC1RpCghKFG0CZKiCYK4Nk73uezLusxZVZl+GJccOTKr1tqnu4FuZcTateecdcnKysr88htjfKPXCRvaVGY9a7TnXaypAQbc2fPaCccOwFtMnPUJ8YOs3U+qYzp+3vCbWTtpJOKFInTChUy9AlA9iBTNLYAGN/t77/99TSV3btmHtxI5+Ox3MuaXGZ/8d1/BmiK+/PXXGF4z7c8mQklNsx4IfKQJiGuuzGM9Jqong1BYUdr0pBcAAlrrkSIVl2v6TkyD8rn0TWB+Th/SMQMxm7Q93Ebm3MpgmTJcUMmf+PqodATndUtjKM7ucu+eiYoEkJTChxmE+HziDG+jKG2RqCdhoXWyU4VwYxIUQOCzLKhfixkcRfSzB7DMtrBNnUXeDsCq9LOs2QEo/d5nU4jmfFvATc/LbgB7ZkEAVRouPl4De/y4JYskP1HkTCa2ZW0ipIu6eH3NrvyEOa9EIeu4wYDDyi2o2Uy0Dqcy5uo556UCmBaMAOgyE5vFnEfAVjjP5AyfM7CsdD0nQ6Cq4JcF4KwVqiQf6vFHgz+cm4GYEwFgYeCk7/uN4Tb4OQ7nVNTPzeIWgI7nFdMvfYXBfKONpQsBfn88I2v3cb6JlTXFztsb5sDqmUg/6QEssy1ptzr9Sn4zKvk1SWAWMB602ePl1QsoKvD6TvB1pY+oRYneo169/uK/9r9vvntK+f6YC9VvQQZK7kQCtI4jsorS1TRoDyn6FAR5olXv4bOzSjV4h2er9hoflspHq0TflRWoFp8M2ck7NPe6ce8eRHrlZrFfZwP0gh+sbfFS/+q7ZSaW5F4SO5ArqHSgbahf5OKvFQ1tvD2SNdE04kOwpMbJOJtrkYo7rZCqVbSeONb31Anjf0qSX/Ftmj9Y8J3ffoXvfPsl1lc0wN5/mY5fD1I/Yq2Ifap9kARwWIX39YSim1Pd6HZ9rBZLGgPWYzCO4LwTn2/hui/XNEOlCUAKGG5jSfjMC/6RWazprhw/skOumC72ohoL3V9MowIQxeQhbSETiVXHVudVEYUU073pAl7ZXqPJOqKATfSbMDW5k+RcI5hdcImdrNN2G2xN1BWQ8O+fHKvuB3bxJPfgAUs7MT3F7LCZ7xVozIR5Gs07bNgwc3yObnyYCWSEeSng48FJ99ui7h7cbw90ncuLSVPfrBo9Wp5x8S9K1XNQ86Lo6HGofrjMNeg0v3WL1H3tjI32Xn0RkCnRnj6KU3YboolarE2HYibvFWHAHz6IeHgVkAZgZqA1PxP/Lo6GNyln4jlhuYoKxkQPUoGmmSub+couAnwRYGGDQx4Rvq7GWs966Xi8cwKn7l/LqqTq+GhMtRR9WyJLG7O6mfPCkuk99KbCnXmikcEw2KSoDfSjQR9luDfKF3Z8/4s/9b+rzYGAWS2KzXmF1S2RPH1pGhp4J7L3QOnQUsY3D3oOKfdfpxnp8MbQxSGorT1PsR24zYSnn73j5dIfXAG0YmU7/mhVOo1B2L1YmTP0Bbamth5bBgsUOxEjvh6K8mPpOPKMNO1BvYrMI+UPA1DZqMWJVcOLzSohXsj2H9ZUUhyY+th0GUIFI6U6P1dndeTNLAW8l9W1RvFZnZUAvP3mgPUQ8OZnZoSrFXmOiG/ovuKFDjp8ToBquBAAGB7KNXs5+xbWyRLGSHMASuLXUHSnZF/1QZHnnQHSCDMvuliAjnIvwHLDpkhO9jzc0b1b06CUQawmM5kJw2KYpGxWbzAM2wAU+Qi6F90KicQuMYfb8g5IKLsyE646JH/BDOFRQGQwApIst7JQP1CT4115f5WVFudxz+xIXzHRvFZvTxx/FZxJeh1XtI9lGqQrfS7/DtnjZKEo45sfM4CyMrZmTmET/ETl+741Udi6AH3mzUUwB+8AbveROvM+OQb6v0ygHfBXzDKDjhvrC+rg8wtmrnj8sMDZ+hjJ4gKRTEuSekbYrIHH9nD3UNqFTbt5HIBhKGMXF/G1AjqA1PqxSV/QxTqfZxorvzcyC67VdfK1SSEUA1lcQqgYfl0s8dh4fmnZKzOeZUpjlcaA6Y7cHaa3K0qASmmv9WrQ92e8pQCR6V3RHYz3Za6Q/tdE3RtdKZ0DBbQYlxkNEOH3wBfru5wjsZk5xnIczNb2VWXRYv2dXGfveDUZUv3yVIK0xK/M3q9YwjSi0vnT5Y6lTO9vTWVOWnOX+bRF3uMNB/jN1dMXZrLUHHhicbqOjIGuNGVcnkvHbva1OYZQJr2hkzahiiICTWhiYhS9rLizArIOglXZXpxsA6yta2yB153w5ic54DUX6hyzZ6LYMoH2BlkJ6VfWkb4fzqnRZek6GDqnTb+K6NWjWT30JpdOOw0P1E+uP6Z6nX6X+8Gx7T/LDTNakvBZxEY70hTrwX0h+PVSzGE+f58t3pwYOgtrKYl1r9JBBgwGha8f6Rdybtd/u4ykVEcYO02vs336QU0iLcDa0wJTlkt8+JTR2r5WU3r9uzd+OJP8HhtbRbTaa+y90z7Kzuy/J8/itfa8E3r/INdAPVP/3v4777SeRiaRp6TgWcvkFu9qiQPRxxs67KSMz6KgribiPcVuX5+nqnAb81j1uTcGehOpMGKdidVqMQHg6EBh7/m+uA1E2qGqPi9YJPL58jzy59YfwZpageKftZ4GrFc76Yn0BHJ/BeA/WhqLQmcX1UaMlQ/vD6J4txly4jcBX+j3n80UVXskUpPybmehIZ+/gCr8FzcXhqArShXxHIZ6EALQROXI4ealTM6EJeyERiIcJxWY6wEsKerTsxY02+Q8cya64FB3Foc/27h7Dev9s3qrQt852GSYB3YKH4f2AZuBv1Jzt+e2/3emlKqKQ6RjBez46BGl+Ivi8xbAshOkTzpq710HDC/satvysRdC2i0XlqLNrl4AgwdJx3/B6OnLZwxnYjXUr4p3XTiptEQZZmabkFuAJaZIaxKzflqi1A5AGRv6AdU2zswEsiN7XNhECGA9Sn+S1bcMOgTmPKAT82F031egNwBxLfW2DvDVZ2a00miS3u4ALH+twE648ZLLKn2u37ci/0G+LuJkLMdTO7kBc4MxzjECHJ5e7dcr1o8FaM0l3lfrkfffD+rqz2V9o3Tnx98Bny1jawyR/2d3nQKaHIBYkzJ7SMTawCu7ezMb/1WTtGGPVOuKQZMFWpSSqbgelH5Qj0tpjIj3pNQeHi7oOSCryTAldH3C2Ozp77kZS7kNlE20+zqTbOW7dXZCp3Zyl/vqAK2QaBs1sIa24nupUcXPB+QYsJ56onp8zE35zQKtYOYaTSsFNEAL4DFbgFLoRK/7EunP+tL2XGw23zdvXgTMs3Gf/fxpT2NdgDpAS1xQxNy4mXaH26rLajv3JURmXcehLIwsw/wF8hp+IXPhX/gf/Vz5QSrn7qvJ0wcgXYluiWiR0EPMY9ROqwyWpCKofK2o1y6vqLdKah3p4KNJXzC8M2HAiV+eDVPZrj1bTVZF38p+v1usedLLJ5hBw0c/9vySGtV2c351jvd1cjoxPX2h3AkykOcjpkIZtAqoysbkWXdsm/JBO7VGpdUDGoDWT07uyUSiVGkk3L3nQINO4uhTWSF+/LN8KQuI2GlcnMf1ewNQxnuuMjM7EpknpsXpXS5vg5zG3E7DCEl38U7lKEyaDL7LVUaeMsIakIeM4yekG3Z4a/yljmjKkdWoJcJQSqOiDz6PAEneSmSdKrrzecRcGC/ZsFKpup9eUVFTExGERIyGDooCOMUvh1PsaJReCI3prQRxtH21SafCUUuVTo4eVMBvMKACMGOA928EGr/SIoVgxoW9oBR/LZ9CxnynwGGPoRMzIUcnVkxMzjRJOFAhwKGqo5d96AmjHg/lWmy9WJ8dMdxekK4mhMuChU2JtTMyH+98X2XSVHPhvRmvZczliEcZx8SMrODK3oOJ6iz3IYq8/PIYQdUG1C5rud+BJljV2XLJrgFw9HuJetMMB8/K3CZFQJUs5GwSdUnFM4qPly58yLwqeUHDSmx9vKzF19gBD1vKeCPuGuZHq4NlSmUOjDSmNgEu1QH9xU+39AgB83/VrkI9D+t9HE0fAPp+mDKX2PQ54qbj6uB1GslcKP/ndvVRh+b4//Sf/sfNHfovpHwxJkvCe23D2cXZjsJxdqyVNx3lGIA1Yz1yaHcuqXMkTc5we0Y6DpjeLsixoP3LSxkI6uv3aGAAsAllNRTblxAqdu5Jq+ZeSakBWMq0rfyXcu0L4lHz+zjejRTO7X2xKifyXqJeYRrGQCvTTG3TdVaWdCoZKqwHlAGsEqPLRrrCMXvqryX16zllboTSCn0u9Tu8WXF5HvDqn/LgJ75ND+V5rcdcRd4tzzxDwtXkrwe3Im3AlQUwMANDKGKM/txiorQACwDCGuqtPJaFriN1EVmHuFC0ZJxbgKfSE4IpXORjuc+sn+U8wmRZpXgVKQ1AE/HkigglquyDjzyN0ES3TWCKFJ9z0xcdaEW6wfummP7mAI6NpNJ9klmANYErfC3VOKpXtRTQwmzxBiO75YPV/G4Za1mkWmYKDEqXtbA9fozzE6AuLOtxQJm3XrECj+dLIysx3LLMAksqiO9sk4fPTp6ZEzOLZuKVWwhy3VVh3ivNP0FHkepuAIj8X8yeAjwswOocGy4zbG67nkJ5WDPna+WF/jve3vO4o4FBwOENLdCEKQcMADtFBlbb9yWMV0lPtA1yNMiIxzmJsKPK8GJ7z3XF+XttZlvp9Z2eNed9SYlqOxAAknfBvXf07rH0A2vl7SZahwGdrp5FPumLsVa98sXO8kWzVeuqpmf45Y04uYl6exel1zReHgLmF/SSzs/5pfUJqE1p/KV2nkfFermHv/uie38NWXU+pbNJ1Euv7D14P4j3UmFYx0fwy2PMcnaf7uXFF8vncev5wJhBIBsNE3v8XnvYfGTAxmqKizjgrqeIq08SHj4KOH1HVvr02/jQ1lHMe8tzOreYD3vUsqSokSJO7DYyT9P9dAQ3E5sf1Wyg12wvdviMjj9+VsBMWIDLCwvQdvqSzNfiFul9y+yuxoyZIyu6i6ySbDuPtwHT+sP2tRSsMwsQclGoxt6A7kHCFhhCcYbVPh54zLGD/17qF5/Lb8+Pyr/XElHYm2h613L3s+dLVsDKWsaIXgTi1nFeL6lXPHtoZR4EfEgk4rl1RhzfMiPl3DN6AMUHtORppD+JknysrlKesvDdivwUEy/QdbXw/rtNsutOObxequ31dxacPqP/nz7bnmzE4V3kinRR12uCp4CYPbLDSBYBpf/2wEkjUNt7Nk/of+9DEtjFT1ez0u/v3lEv8t0rPgJZTbCP1fU9CZYvDtV6QMCmZpHKhKAMVDqNyEPEeiRHvobFcj5Z2d5wrpNATp+RXWd6J2AMKt42vzjQxD4ZnydTn17J5uFkEwlp74tQtDvQDqhucNX6qz/TEzqZ7ZApcQREYkaE2/cwlcnF+yH4AYdtzNVgKasUu28oDIVqZQ0kNBmXhHheW1Ve9Uvhj6zXY9uuhI/zrqnQshbo2dB464OxRVer9on1MeBdLjd07fOHGcOt6OzQb4fXAeNdQDwDkecDiToUoKXJX3mfeCkmRQUtDlTRfYTqtzzQXxqNuY8B0szs2fyifocOnwUFWFffoX1ETV31tFD8xdYD632Za0iJa72v+FqElf7iUkCm3N9grDYq2aDAnP/s83WJpEvqDI7azQCYDd1M4Ao04Eef6xDLJOgHUjtRsP9IU5/eIBvNez2a/ip/9r6GeoKRPr5eTVivJL9pvZDq3pe8h51xoinCuAnDbd9dy7o48OOPt3pCjaO7NbP5a6jf2va1BGiFuwf6u7+ooKgKE8u413l3NY8lL4bzaUI+cXtqUJWnZh3TD5hnaRTvOSpRzYTVORKZPKN7Znb89OyG13iSNjVJq+OFkhuPdwviecX4bka8rKTryG4sV98hxu/qE2a3VvpbTkEzTlyeUX3mKxlLpD/TdW3+Q3W10YY1TK0v3P+sNmUD6K2FIZS0T1UmCGkfe61s2kfMbpLCzucJ9q4iCepfpRG11r/M60eu9Vik71XnPmxS+ErGhOdW5FybJtVVxbnmyDFPXDj58t4g6y/89F/aOJMDTEbxe6vYcFjJRC6l6GR0Vhf83eFjiqkXoGWdBPUaB++cL7n00Nx9lzUTnyXn+9EdvHU1K7T4to/Xbtl5kN0oJX/O0a3AbZHBckN13hZlHextbKUD6RyfVGDSm14sMHEsgd3VM3O77SLsBV+CwUIeMgZRABFQ5ZzVbZlfyOqmvYYMeD7JdDqEEijgTHS2qA8Ws2UCtPLY7nz6hBcTIjQqeOKhOMcPHWZOijicF0f8zV0bgJVGUm1PYzC6aL3VI2+fkFi6HMTbIbDCf6xNxUCfWdZ+Xzuq9liv4MA/xD/QLoD2GCPfz/ZMOGLuEvmIwU16Ty2WpdoqVs3cKaM34MmUxin+fXxpUjLmtnry6dVVdK3U/7I3pkqiedGIui40a75iaYhnV9W+u0WuYX3LnmJlUNcIA9B8cUEZkpan1qzi3+a2PQaWXJB8jadPGGh92ol65vFkOdbjzHIVy3uYZSHYc5Z/OmOUfRuYeSQ/hVWVx6t+TDvXlPfZmOzDUs/v3aTgDlg1QWy2RPdeD4HmHSZ5Hi2eEX4ETG3ioE55fyar8sNiCp4Tp2a5IQGQVqNipIiI9WqswJQveQwYHhZlMySXVJhXinDJxUEWKGBHqNn5+UiJd58dGr+LyswXY/kTU2BEWd0exibyoACsPtMGwKwCHdAy6D5wBnpF1L3OLKBQHP6krW1bNaaToD4WlAbDrFBNHdWUKu0hnTfS8wtLVr8KWqklZSTKxemvUt/NGYioFXrlUUvVdUB0LII8E/tCJtKUscETCHxuXsXlsYDz5TpW1xIwlUf6E5+m8YEARcjF0T2ey4pNb5GPsc7mSumfZMv7xuITlSY6dj1BRUzXE7WXACzZV6453QYc3gQcP8tqItSQcN6MD2RiDIlWwOspY7iQIGlc6Z6i0aDS484Cyvhv5j/+DADTfXm445lMeXEhoCW+ZVWwgYxb8gr4VzrxH/eTZlEi6TNSpqTfAcogY4yF0ToYsU1ZMB1qB3TATNycikPMg3TuUGeW4KrodYWBtazoBvsczwtHqYHbKNWJeXPu+2X5Yt7HJtQ+hNqROyVgYfHMeaa/ZWnBj1xT3vl1Be75AT8IgjaOw3b8sv8XK0VvXOuZjOYF4eGiYE58tOK8GrMcNOhBZBDIPANqy+OkY126oRdOx9khVFaTitW3bd3LcTkMZZy3TIQHGdYnLMaiwC/tmTMrwBOY0nt5WNiCwuyU3NuaVX5Itwy4jp9R+xxfrzi+XhGXjOFS2sLWS1iu5ToW1pznq8RzlFhfus/HqtlbYJiNXyq/b5X1xrB2qlvlfCc9wAo8N4eUEC9LPX8Lkx3CrmUnLImDcNyzdO4lYS7+j2Lt0bkoBAOgO0ylMGh6X+5aEo1v29O6KwztXLxX3h9kmYbZYqvyMDSVkAcysvhgOkTtjD5P0PKs40tk6e41IfCgcfzdd+Xh8+b8io5fXxwIIUcU5+q9xonufgK9zHaC8aGyFbti/TL4eF+atDnenGDNI6qYP9X72uOlyGASjNNob6CfxirbvIJVFXUzzq5qFuTPOxOHgiq3ykhDNEJ4cuLO6lYm4co0G2sHY+knrj4hZaSJ2JeZTYUPX5LfyjWU3ZLTXWjCHR7YkTwA0xsPZPm2juU4C6YAYsNkP/ud/QwQ0AoJqoMl5fBaTFTmu3fCRNF2vM2YnwHjfYnaPHBd1Twp80SgNooitIvCaPWKmgzXrIAsLuwzJeSHf3bJgOknECLBLYpgctppn1MflKz7ACi564C6f8juBmABZuJ0JkMBVfRdrLZPKVZEV869WqY7FWBQDcRP8bNayYyFEFpHbI0G6/imeMkcW0R2wW97IGpvBa9mlE60lTLjPH4wsza8PevETHn1cjN+NA7ycAvAISAfxpYhUnOxY/WtNcW7TdjiJ1C59jiUOUDO6UROKZsIg4mLzEktWPayApEXq8PdjJAzjp8bQVU+TJOsBygAFZO/uEBoxDfa8diatrMsWDWqvW6CrlXAWhMkn6JUSbIs+MMMO6XReZLMu6dnZV1FrJkxoXVDsUUypjgrVJdh33jd8hBKHfW9q/tWtuZnH3jzVB80V94LZP2Fn/5LtSjfmmvFZW8W6tB6ovUR56QMhEoD8P6HTzlKRTqxMFhraqNozCUPb3glJeHm9wvSaVLWKAuKBTYHF8teNSgYKIO8cxhsABZQqGYFA+blbnynYv0n39mtNREOboDh0hOFLXUnh9J0nIhR41UD0HkhUhk4ZJDsFY2YlGYQE2Gkv7im4uPlTHqWXSgnrDtytYp1Ie+iryYJjperqIrnp4/rN218Vz6L6SyPzAhdkUkxXkrUns9hSFpd9DlH/r73Mks3cJILyzWY7cpFMX4uzBAAnL5LBx9f5wa4zM8Dxrv6eKnb4U1hqgDQ78wgyb7DpQBS2qdcYBDT4kyDJW15pScmQf+oYjkXsY0GaNuiz7peSIWlMByN06pnkHnSsL57mmze9KGngPgGVMlruDFm6mTAfdEHYRSZEqqTJtcF+uDKAQKdmCWXoEkt4521s/hSrglZI+PMeCj+VR48MBDKHqR1b9iNZ7aMo2pOQRgAuR+fA26MGO4udH/iS2XGFCnah1xTpeOIdOQFYScTRVPtHqsvJfbrWCpB43HPBNhrDwv6dEwX5lbGUdV8K5/DTGzLcMtMFgOtw9ueS0z7+fxyoKTbKikhAJ/7kq1jzgpM6HP53vpYVnW0JZXE09XxTjl+szCQL3IIBlzBtJv3uQL6gL9nxUkZ6TiUdnCL8Cat25Ia2SZbmnvyDLMzRz/VZLgzI3dKw57Uk4RQj6rFEsvkna4I7KQpKgWphSdjK1CqHVl1LApAUcG4uwek6xOO3ybHlflL1zh+NmN+NuLyfMLpfilRivbFWusOWJxaaeComLkY6rr27MJbHU6o7OCSTsv/xTwxDCpxEFaJtpL6slaJRNzoCotXsSl19XDaujAgYY0bDVUFda6M0IhBVhMPm3cCcgvsQp1uIo+8gk0EhIYzr9CRaT+DISyLmQfKR5XHWLMGHT+4LLIQoKTF882AOGc8vGIm68t0EQEyy7OM6c4ALV6krcI8HQh8jbc1OwQoFiDAEngA9M2sLzafb6K/kEoUodXeAoiVwn1QB3cAOH1uAA+KeRIoDuzii3V4XQDheM91W80WxE5hpvYSlirl+hr2/8pqOZNjNejTo0Rin5Gw0jOnZ8fsl7JSUh/pP1AWzEp4QBgxbxqU8yw8uadEGkW5jDvev4Q+ONYkQ99HMuuh+HGMkT7qQonrn6Dvrdfr0cUESv+M97P2XX3XfUCKvMOS3maIJVqPAVO2g/uagGxMZXpDEXlNCPZdlGsxY5UNI5a9k7wHosNQt5n/ndsex0N9jLBjIgWxrmQ+nIF8dUCYaZElTtTyXpfo8RZohUxmWXlWojLfiKZKvQCI0GpYE9VrXcukmBIQC0vVjJH6jGMNAIW9gdBJhn0SoDINNUAIAZjZ1KhZMfg8MSJcFuTDiOHdBeuzA46fz7g8n3B8w37FJ8vGSf3KGHl+OeD0yUJBSZISKK3kegHUTI2dc+QZmfpXZupOe8o7piKfa6I5vZtrVwC0BE/I+QI0vV5KdEtbLJpnVnMGBGDn3MwH62nUe0ncp1SfUeYHG3ilAK8GfpVmpe0bQ6yB1sJ9ShjnJ7JZ728uNCq8tqK9Yk0E4bIgHUdNxyAsVtc/q5EH2Kb2xWxokxuPdysQgIevkgOMaLF079Y3VC+Ni0a+SWfrvOxPKZ6lMf5J0nFSR3qikYzohWJv0eOGGWscAHcc82kFakwKHOmov22U5NjM2FWgl+daXgBNIK0TZmsWas4jjNYYMJwT5uugjM3hc/pNFdR3igAqiTKsijRrov8HBQ0GyOylymHT4Hoq9fDZ66U9Tp/RPsO5CIP6Ff5w39ZR/MqKAzk0GkmOjx3TjN6iCESubl/bXd1rkaagz01lK0zOwq1Spc2yTrdo26O6Hg+o8n54mYb6Iu29amRkdH2vV0eXEaFiz5yQo72+AsM9/SFXlJnvAay8/Z7pb94kuayFJVNNrO33XNmtZacTixlqJPAiPmyQ3IdAX/7AJVe2UXlbxTNI4bzCZxHpBgf0LANStsCVLe8zjtvLCqAy4+Tuvig+a8M7Ao+HtzPlJwQw3rF5UUGLPQEvGG9qn+BecICNss0xVGbuJrKyU5q5du++vIgnUNrTZ3PoHefnMWPp8XmHq+O5jXQscG4D9CVtojdlsu/Ye8s22MXK9xtk/YU//n9oLmhfIkm4Gua1+NJgf8CR31aTs8kmwKTvZMUgK9uazbB30TNX3P7EM/pNojGEJLKoWYpS+J3GE4BlUe9j9LvVYnnKAzGpfdSZ0R/nbdDsu9R8Z84HQNWq5UXI1QqwruMeiOqmJmBRUwXMataT34NOcH6S65qY6gVglULBO6xaCQUpDx/J4CMVJHPhfF3OKbpRkmRZv5+gps4KYG0U9VliEDZcoKKeEjUoACsPhjli1fnpLX1Wk58R/5Sw7vl54N/K/Rxe84KiA7CaOnL940LPOM4FxHmA1TOBNn4PPVyjDJ4Z3I0DajrEcs2uH4U8T1lQFUmG5AbPrj9VDDoGPVaqMUSAVwYlrnfvfhfwOYC3nsY2QrLHlgBQp/YYG4DVr6xjG6xJSJiaXtL45vrF1Fi+StUW61omD/mzAGurWKAl97W3v6mfFQXe0+lrgJaNdFR3jCeMseoe0U6S3XEvG8fqZTXPbCcKtDcvKGiqrylACwDGWzrnJJkWJGXPJRf2m90hBGipFMbEc4X4LKG/YNfbskBLTJ08VzWLQPsKbOhPVUCpJxMCBkwJ6qrSHOeLA1oqsLpmeldNPdRk2EkftJsr012rMVU+4uRe4aKN8n5MFrMilY6URObJAxKT22DsoHxsWBNFD55X0koZjQaH3hSJj2nEmc/AblgcyUUV7i8I5wWH797i8N1brEeKxCgK3aH9k44FlBeVt549UOdr96y8HhhCKHkI5c93PvkDgzQBfNrG5U/9O5I5Hmb/caBOYJ3mpajT/Eh/E+WVzAPR22Fdtc7a+e0feJszDRAGzBUfGihAW4+x+F3EQBFwS66eq+0rHnBVivCdLABEVYdiVtRUPQxkjpE0Z64Djq8zzuz4Lqa15SZjOLMZ70DgKA0U7RcX+pwHHugj7bMeGXSJ/1WGioLS86O/kqIBmr8wD8SMxTlgOAeMtxFhCZjeBnLADxmHN3TckQUKVaE90PHjmRz6x7tM1x4IvI0PVL/xPhOgW7KybHIPUjcFT5n+4kK/R5NbcWAfrHhhALZkNemLA65n1sQxXlPzxMDvXECaQuW3Rs+LgJZEg/rclrZfSbCJRpHJSjyGck23FVBQRbtulJAN4DeuAkH8B4fyvb4LMrgb84WUeFl1kqvU550vEjkH88L0MlcrdgDIy0JgKK30JxGGPmWWZaFiZPNYGVdU2VxdLGpGS326UqZ9U0ZeFv0+5wxNt7YsHMlI59egmhAovY64Mci9cIofYbnCutamK1t6Eyy3syipg6PSNR+tN+eZqEFl2Lh+WrzeEbtKSF8R9fzc6YvVIlkW2hZoranUNdVAQo+zkXFiqn9YyIl+XjHczkouTKypNTxkhIXM+CFnDJeE4ZywHgLywBp2AUXTaknVO1O9SxI5qwsRM4/q/Eztk6YBeYhYryfVt9Tz+BRWMADG+c1WRdpQ3GZQg6BqP30Apf1yCJSjlLFFmghLpCkqQx2XpJINdhFo/c8si4Wcaz9IjchNBUCHsH0/PXJjozwdZPkTJm7s3svDvwNoqEwRtBwfaJLPY9EAkXxWlQ+O2D+rcxcKUV80U65+h+gBGkSBu29ew9p0S2Wg57HbRjzPRCX4gSH70GApnr72qyRPo0pn8qBbfcDc9S3itiHKArwAZa+a+3Ul+2cbN7YMQCWEXY93JkKJGrIaLDoAGP8WoKxey6AQIKkRqjpyeLxqbzkmS4QzD28zzq8Cjp8ELFcZyw1dYBLHd3kczGSJRpTUI43AesjI0bA9OtHyPhOBF8/qiZO7+GIpE7ZIHQNfM+Dwmv5//DSrHo74TMniQIQJlytZkfH5B2B6Q8+iOLRzFYUUcatQfceWTObIlfatnN4BKBNmgTYDSbv4WA9RQaetcwkYCKXdMj2nskCSdmqBlhbpM8H2I7lG6G6fWuqVOYpm1zS0+m/SD3nhGC+FdRIhyjzENp9cEyGYzTtfTHrqmyVs1hZzbQGbjFNjC/gAFPZJzfGWDev832/5OtmPWUMs4FDuA6gXwtNI48PBSM/Y7Q7QkrQoyqzDtGfHZUQT37uiybOBPquUeIL14KkZ9zt15oVvsPOSMmnO2mEXrJ3ihXMHjrwf76luJVcs9J0RM6LI1ahvoHMFoYWUubgjM6yritYV7hjQM0mHoVgenPBuHs0z2FrcuGehqfIMC1nt5xnGlOgd3cmjuE6xSvNWlRjo/Qxh5/1086sV57Xf+3l9h+XSyz+6h6koAKO+zDdtTVIdpKu/OYpd1MSVBQFU6V0bUxOwpqbhvdnIHie/zddBQ1/v/sgNDdyaSPYJ92wGNgUSaopDtZUIKADwKtF7HakIv5V2fcqDU6aKw9sz+3XlGBtq3eZbU3rWX9e0h1La8r75to5mwtwxB6s/lpkcm7xU4vi+Y6IsL7jpa8oeUT3ECXu+Djh9knH+KJNjubl+k7y5810eiLkhnSs+9xPCQ0T/SoCWlWMQ6YjpHW0PrwncHT7PCkrEbNkzf0oRUDe9y0gTmyZ1YYBqa4vkH1QFd8MCFnNnzQxaE47+30V39kodyCAVp8/qu9Xxw/R+elZU0C+GuiZrVyftn713yfZZAZHMOmu2iR0Bw1aKIKn5Au4+KvV0L8UgUX89c+HWhGXY8e5xUmQMyGby0LGnv+CjVfxS7ZP94s4USRRdMes50/eGsQCAntlVTbMW5PBCs0mLsmwwWU8tVsg1Z2rHLe0ve4+x89vKrJeL/tR23PUjNfOgABtJ0WMWpcRUGTFgeU/3LMtufJS0VbZOGk3urSe2iDzJyUTu2YArGFZIFh1PMdUCdeYCYY3mpbBKG+dS16Qd0dNmDFD3l6yEkL7Xe1H4vlj8IVufhWKnPP1KIVSyBRkGVMi9JVrVUURJO0hR5FwgaYVnB51gwkoD8HBHlGcA6hWARLaEAICyy2uSUQdgJOT35jfe4fOfeY7Li4DDLTDcJ5w/OuH0+3dKr+phCkp5YJHoNjHDidhcRLFdA4CMY3KryawQQui+tFLPpm2B1nRoVxVDDYpCSuRom000XoxEq491uLu0sb/eFoOVU8uoZQd05OULwi6lwvx0nd11IIMeR8J+Sc+vE6M9vGEOy6CdgcrRPiTSl3rzExHHT4C7byTj58GndkmSuXJAyOozJc9TTI3RpGhTECPboQA1ERwVc6SuPiUtTyhK7iK3kGPxsyC2p/hiCWDTa4bi5D7d0WdhsoSJykPA+GBWwFzizKbFC5nsx/tE0hcLmyXWrBXWXiP/CQFxTi66021lbEjEtA2pXF9FJ3N5zirpIC+f5jIEmwNyDYYiKn8pZUB781mmumsE4lMWLZHehzBT9GI8L7pY8RMVwGOZWV3Hh1ozya6CxbyUY0C4P9O7fL7Qok8i1hTMGBOf/b8UCRiQ76y4qN32QuLl/yGUcwuoWsy1Usd6AGh0nUbd3Vyp+VBNaGLetAnjnf9MfJDIQgqIytNQIsvFVUJcFNQ3LCq4KQxpbqwYTdJn2w4aCTmUSDExucope9GgfrwW1xedf0INVIHuJF4BzoQK3CjQ4jFwvZ4wPKxYT4OKAtM7HIoEjbD5ZgwcHgqwkHcqLhyRuyRaIDvNqwBTFwNMyPcpIh0GjMZ3rDK72Wdk5zz/2QKn2bG2tq8JQ9iTT1gzwJHrstC3FgN7negtT9YsHyOxY+NA+2sUame+7jGh8twf8zvk8nQmS4pH/VtAAg4ti4MtD0bTW8591UGmjcipEQVTB3jpxJ3OLAPfi9+gmez1T9I+EsHxaJFVmGqv7AzStlP6VcIepei/6z2JvaABr34t2066hWBXjL7TPKUHeKBjmIhVwVbnuK2FZq85etEn/gXd6WsygJ3ZSfzhS1mdywuw61RxEnaGdxUS8qldxYGNxtxmigAr8smi/wvAkuOX4/YzlzqJkn0vYnC6bR1yBw4lFyZreKg/19forCKdsnOjmWVKct1PfEDo/7TtAqOhnjA0Vc8TTYHNs3XsW1W8kzqgz+tJTJaMZTwxWhOilo6/hgIRAV2zpCTYYQHCdmOHp4DH9qDy/z0miK+rEYo95/pO0XFZGVZnlTAlstSPpKoB0LqZ7LFCNict0G/HrhO6k2TYi5zrMaLevLg4Rsse70yJdd14n146HjYdilp8YbS2+0o0EkgKoHQRMG9eS5+V9OuzyIuUhe+uaO/W+LzXr811H93P7KP9IhfXI7+PN3kChgnz4KtnZdorXqD0CeXJe6rvEQwrwUVMCupEmA3gqJKMJt0fAKZ3MlsEdW5VgCU0pSQJPRi7zuBuNAZ2OI/6nTTqy39JHebNt0qOscY3i00SVYJZH9HEToBVGhjXOWHuuzSOMR+Ic7rvsAom+BBOPErHoVxfTIJb6X5kgpL7sD4BvQgLZ/KsvldfFFdVmQwPsYkmVKdjmxh0q0jdCoFC53DpE8qF+6fpietZE+Ag2ljyPnOKnXSARhhKFKBXa1eZhkAAQRzL40LiopqwWZhjNguOnG9Q09icy282b6L6U/G9aU7EQ8B6CEgD/dk28lGE6vgOYLynhzW+W+nvnv6obrJN9edLwnBJlAicwVi8cNJb4xzfRICF0qYA1NEegDrbZ7P+KQKsvIo2kYPlHZN3jvuYDzvvTLg9R3cvEFw5OPsJofIJkr5tTH/iI5hS9V4KsFIGKxpAYZy0VQrF+3yonpCbKEIswMqqx0vxoNOnjOkxLz2gYhcwvYhloEQvyiEpkbM9RyGGhzP5aMVQpcXx/lTxljr/8PaM4e0Z4TyrlmIRdzUDjfX3kfPZ59RzcFf3C24Daw7cSxPkAFIVSejBk20r7wRvTYfsb9T0Byf/Qb/xdS8LwmVBfJgVEA3ctwbNl8jNs9C7KYyvOt4DlUO5FxvVRcF5ofRQc9Gm1IUUb4f7uQF6ur+M73t9zfY5b9UxxwXrp2jbunfOyjLD96T1d/PGTpLqruioZT6Te2e36tPzxe6U92Kyqge4l85BSioDUljX8neeW60kex0N1XYilLto2qJ42n94S9TBze/Sb2++ddq8VkUn+vDQpyQp1YM7nWTnO30RvR+aPc75pNh6d8NsfVnMy53K592knva6Tmerao+OgrgvzUvfaw7r+M7HNCrdOx1agRZP7IfXAXnISIesTu89nyzJPSi/Lde52Ve1amR+NLkME/9fgMWBJRmOr9trWdYqskAoRbpZgLV5i0ZglK89FF0wAVixw07palhA1FIPUNU13PPshdjvSVpMd8X8G8/EYunk0LmeFJVpEP08F+BAH3b6qwH6VemyC/ZDbQKUIkKHvSIAoZh4LNsnE1KH3fKCoH7bK9YX1puynsJkWf/QxgrRW3g5gLU3zsuC9sHY02U8uydgFe5oG1/ftce7hTiZcB5/1zdLKKawXYkFD7Df5xigAC3/rHd0BxV8mWfdZAsxRQHRQ/3u2r47PNTAxM4BOoepz2sNfKviQYi4yqAwarqY6BU/h9vou70x2/vZ9dJHyfGprb8udHzb9IIhrKlWTJne3/ApGRH2+shGeS+QpawByyy0OwRWBi+rCH24ksaFI3KGt7y6uasd5xq/HDXdOaAV68ZvWDZ3Z0dW0v78jz+jTmTzocECO/Iv6gIr8QNLqO6xun9T58Ye7e32rlR5DTmfU3XeiurPu6YUMV9WKSAs0+aB1tbL4NgynWjlOB34eeOCD3wdKx+eXGQbGtOg7lerMAMgVfEMHlSh2kznV7Q9fZIxv8iIC8knSIShmNtWFghVQCUpcMTRnX+fn8nNSl3keK7qAV2neGW0HoDxzoA0+Z39s0iRmNrEgwOKYMwK9oQBG8WXayAmLA2u/c1ql7ZupbfW71nDAnn9GsOi1fdohE5XcNRieU6DgL6Z3nkKckFVBwCVo7+PNvTBET7DhBYFfx5gyXYDnHVM9naVuzw7lOAeWZy4d17fKbf4LLk8+eF70VHxhdIxw40JOs6J42fu7+8ZMl9SRmVy7O2n7cvv+OQiAzkXbfCinkYBHYDeo06eAr7k3jmvoY5/fuyOsWbc5fvDWHx1tli5IOMJ17Fn1rHH+vbc8uXqgWVbdJHsjrMO3nKv7Ngv43xPSNcGk/nf4yVVUb5qSTDzg0id2NKY+jy41ewqpW/oAsL+bv5vM4ZosXJCfkEg12Udts2gBfGz650bZh5yxzdmTXfL1oVHVRG8T7dc3//5ejwFjNXXfoTN4Ev/+T/5V6vKl0So9cQPGLBgHVVdxRJTy/OHJ7MP7S+5nZTKVGrdTsYymxigJA/GAYNP/g0SJL3+Tuks17/1rr1Jq+wMswowg3eJeERdN6C193qEbovUW3zMXPSHrU+1v4DOZqXSYafMgOVXTZ4t7MJtScWjq8tiSpHJUZWJrS+P1pGPN07RUhed5C9tHf1qS7SJ1uuCaJIzLQHA+SV99/qnaCsgarqVCbCcc74RMJer3/KQEVba//gJnWe8s8fxf+Rd5nlDTITKVtlHZ25HzYbcXtI2AtxsHYtzeG6On+7ou8NbNvsJqLnsrLTswKW+ZG0f90nDNTqT6zo/L89BoxKNiKoA8bLCrAHdahx1FWR70G6+061zN6BKyT7tb8nVv2KC5b+azaGuj/X3GNjcVQXL2GhgU4L4vpwNu6MTrlF1F5AkY0RvUtrwxwp7zG6VPmwt1wPaa1pgZ68lzuynY72/Z9zstbwT8LJuRnBluy9fKzu2XNpVTI0ACuDZAUvBg5vKL7iWgwBQxmbP2O0xab3FrZOoqICNWyT7/LLVmN+xqCTO97s8o7ZaGVxNnD2lK+4bg47J4mMl2z1xzmI9aOcFb1LcZZY9iHoMmKhJUAZWB+iBxk0GKHODfOcDUSrToJ9f9kyUUnq+VxLZz3X+hX/0NwH0PI35FNtn3967Zyps6HKbfNg1MCmEy+TAA4/0w7nkJoMHAlVd6qoXpsswJHzdV/+clv9vv0nnmd6a1UnPnDCvQDKqtM5pv+h1pOYFUpoUaMyb1csg0Q05d1c0tI8cGMox4AHJM1nS792+gOtoOhjRiqmA1s41s0R8ObYjZwze9OMmUorgNEwLCuNUHSYvh2eyeNVqmaySRqFlNETC4fxBxOnTArBCApYrmYhp38sLOt/6bMV6nSpgIyVeguYcFAAkAEuc5eMZQOaIP3k3pBtUk73cbNmmgQQ7hc0SfSuNmpMxuwOwxntikaZ3qesfSfed9fOWkjYlPzb/B5o+p4A4F2CoUhDmfHKN4mRPIpTEZNV+U3KeKlrRg5WFrrlr0jaRROIT6u/RAvrGrOJN04bJypq8vgCLbqoniYLzE6js4wBWU6wZEFCwoxpYRjYFMZAZT9n6DkPlTJANwBJ/pa3CY5ayWSKr0E2Z4iQozpfCVkkRvSGjO9SYUg2zEoX9knf9ZOznrv1tPls5j4Ibv90DpN3MGjtMYc+HTVgPv7+f5GOo/ZTRZ7QancAYMNwtFBHM51yu6oErbbjTpONI0fgiY+ADqvS9KHNY6Fiitnyym7brsVTeR8tu7XOV/rbh69VExAMokYbUvnEpZmc/H4YL66OJTlqv/rZO9v0DCsCy0jKPlKeDrF6k21A6N2DAlB189xCstK1GLe2tHjoUqv+udzdcl5vfoxf79mvUSPOrUzsgdwZ0FRkU57+eY7YOsKXTa+Z4GXR9iPUjJfuOKC9CL2rJDTbF3w0NQOoWt5rvRgXKKQ1TIj4BhXHsMA0bJcdQ2MAewNq4vjcNkQp3AVhbRU2EbBJcn7eMT5FwKDcgYO38io87GYDlynCWl1buq633XilMH22j6Y8WYDXXvS/ABjA+V70VqwfVO3XrAhxhvpRBKPctAEvyk3aLEDc9M7Wcey/C0QHGrVQogLt/f8on5BcUoJUPYxd8NvvL++8Hb7sa343o43MzwBHGKvQmTztBydggizBvkuwVP9bmVADWHovjGfEzdcz8xlgGBFj2TG0yRrBfm5oYHzovlAVa0m5Og7DL4mwBrXFsgFp3PFaXCudr9VQz0c7z3zwktAroGjhwbttRmXf3HBNnSwCgEbrd6/msGh2XFKsz1Z7g/e+xMvdKu/sIQBYWnAAA/0xJREFUUVscK1nU5csu3TFu6/I9f7QeiFaLmBP17TKYj1/3PRS5AESS568GKMt4LBmiaVXMACg3YTpSSYhM28jMzF7+KmWpEPpAwB4nvw+yGh1x/XHCw4cRn/+xIz78x3dYb2iVNNyRI771T6qAgvELI62vqMhelMhFHyzdjOWlcMAqXx2BeUEWGt6CVPFns53frBxUF2vNmiy3mmBsSppEPmeU8Z5XBQbQSHRkda0INcdmrgsABDmQtbjSNJDOmQjHuuSvLDlVALQyJQZMh5IeRzKn6zlYl8zrcnFlqKoz662tlHZmOCcsVxGnTxPuP4q4vKRdSS2cD10Lo5Wu+Z6OtE0ZpNeU+BoJWE8J421tdpxfJsRz6RsiLirAR1PqRKheFDKbC0MxLVqWyTxmqmuitotrOY/4Yx3eEet1eLOSHtadAbwaAbTSao51rYI1R2XepqTmhIZJtNtg3jM7UlhcdKE6SRRjfFiRx6gMteaxFJ8K0XSbIoZLIgkQ6Q+Rdaekr8g21+3li2YhMP035PIOqFCoN9sY8Uf6D8p2zZSqY4yU0NdoYpVGd4urnOn9u5hrDZEmiaHsE0JA1nHR+bZsLDRDCOobVcaLtYxNfusBlqbW6UQzynVzbn3AZCtjmWFh8jxXLFdmFiscD1TXdUXOmXy5PFsBUCqbaaRAqBiAeUFImYaOGGmcS8Rw5dOE4MCGsNyq+6QJscs8pO0VAwG13mTeyNrEGlhZpkvOWS1S3HnHQXW0ZJyrXEhCQAipzId2opZxWnQP5xX5OOj7vZ7FXWPQ9zCbhU8aAjJCYXa5PeQdiAJOLwvSaSTrzBaoln5mPwM6V3T3p4vQM/bHb/hZNcfbtDYyfs0L8mGi8U0i5wNbAxx4ks+U73ZFUR1IBegFtiRJnk3JwiB18P5aOjfJA3q6qPnTmazeCs6hUp20e6sDd3yYV+RpoDBVZUl2bMUNxfjEu+DrHV7TAHD6NGG6zXj7rauyi1Mh3wR4gPFlCrWzPFB8kI4j8kiDRB4CyVCI79X10Z/ZDMhth2xA6U7UkxZ21O0lmC4TivleJ7EOSyfV0Yg0iXZZm7D4njieHi/vu4yDkfMV2n130qQoqMuUiFpy5AHAckXnuP+ItofX9TWBsvJbb9o+FipVPmh/Wm7IlJiOwHot7Aj9NjiriP3NShlETomhAGvP/CXXT3RMWPm4TAALIIDlz1MBLPNbdS35r3N4l0AUzbeGbTADQCMEKcchPavxbqV7lEio3opRblGjaAnoRUkub39zMhXNooe/A8pES/V2/Xh29bHgfY+tEWJ35ElujCWgh0sjAwMUMOcj84wPUsMSWV8ocZoXJXjW0co5VyCt2oagwEoTPKvJ8Amr/Jzob10LwJJr9Y73rhs5E+Nj/buG+jx5hwFSJ3krr8Hzh7hn5GGgPiEpwyRfItBnl3pmKKCe1DtuFVr8dzakfw+QuOML227O5+axaqyV+dsHV3TYGkkmvZ7KPQlJoYu3pfQRX9ZrIhhkjlLZnt78bj97i0oXtG5cV8CudYzXY3ZY9xCAgV2Mhrr99qLqRYdNnp1KLwHlnfTbEFr/Qg3G6wyMT3jFngyydLK32jX2Bk0aBPJxcPIL7jyIEfFh4VDvelCWPEPdGvbMHT1/ot6xAFYWexwuGXc/Rk736Vj7UShoCm7Cty9IJwLCOualI1HT+TghD0OdEd2kwGnOa+shCbire6qvaV/gqq6cWLUBvAJyDuaeOSlrdV4duHmgsCq/oBc5zgkafeYmwiohKTovQ2DH5GTa29GyqlVmBFaXq4EkD46UkHg5RZ2MR3YGP39En8V3SkDP8lwm+IDh+YzhyJPZFW+duTCPGcuzFetNQmIzobBaAFRnS6UVZKGtgIb+HxcUAOXHHTbpVvIS8sj5vIfbck25F3F6HR7It8A+F1u8ebuKGuT9e75MTZHXzvgxaT0C1cODmxKJlLvAKzYm+I2676SYiTa1l594zSAdlzonXnUd75Mip18KGwZ33zrZ8HvUjUa2758DXl6DipTWc2H+NNptIXDIkXzeFJgX8h8loJNLQmcpWybDxq8otpGPO30i95zhJRWPE/kMdlyz57Qh9BYcMiNmI4/zNJTUZT5frdes2uoH4u9ji+07fkEqumD2N+/879uoE8Cg2l12f2MdKcfWAKsKquLxV0zxEllo02JJH7fuIvIbwO3I2nRaEmqfZ9s+WwFb/mthJxUkd8AVUDu175lpe/0ucfJ1LzehmQLomvFh7oDk8udJCxXx1oALP5a4uugi9T3MlE+NLvxzf/qvm6M68HFJ0HQIQOn4PUV3GbA4wrDSpJHncN+JnJCGfYIdtsrJF6OmBwCAtz9ObNLVd+kax0/b6KFukVQfjkKv9En4Iamt2J2zF+3Q7dgud5cCQXO4FUIsZh2hYaT9O75Haqodq7qGeWVTS1m1N9Gctm5OT0xT7kwFtFm/AB/JVhiMzopPmkNAvUkTJNE1cu7Lc/p895Xy4t79WOa60Ha4D1hPGXnKCK/YrMFgan0nIesGzLBAab5nmv2ezn38lLbjPTAy+BmMO4kqxjvgpVGYdlErFgl+tMupTqoMlGhFYbBs1oLC/JiB2TuO7jA2qrHW04oL/Nkwj1JU5Z+f3/hWdKN6Ofh468R97XW1j+gK3NzPzvCkgoTyHuxE8QoDnKbO4q/TRDJ4D/dOKdstNqtrjBHD/UwToqSg8dFuYlqzde2ukOvrFXPfzoq/dx5xoE/19av91amX3RDE6X2043Io9yH38PDQvVY4lYhxYeOKI79pNw80BXgci7N7vuL/+8AqcZDP2fhrdZgqP7/5tqqew07bSlF5Cztmd8CFl/LwC2lz75oqzY21NoJf9lmflbaRKF8x1cs4KpaESoZhZx4WJryZsztjfjGj8nmf0mZAaSMPYgBoPsneWKX6iU7NgPdV4WAYBk/e2ZTa3LyuujWTWM+9VeJrJQCc1Q7AL/y3fwPojiL1pR8vHce4YkMtk3RVOXRWfobJCvNKkYT8AHqJY5vrA5Xieo4RTZLl3uHmGjffnpEG4ParHBp7PbX35u6xCV81E5kXa4zzquyCZhzfA7MekCX6v00iurmah2l3TabaAVjK0tUAC0Clag+4CSSl6ngpOQS6TjZRmMaUuFlXr9NknZyfIGxK+f3Ez4EYrSLISdv5Oe27XpV+KOa+fM1g5WgAwSQvF3+8kUwEGeFmQXyI+grtpd3xYqceYNF9b96aOpCHlfYb2N9puk0NI6xh2fNa2lJWdb2+5sGyDiihpL7Z6WN6mlje5xxI5y4Pgfq8mmC2j68AofQf8etz9d7r81acsJt82NZ5CLSfydu29z6qlMyZ/DTIT8yx1z1L2n2dJod8DNlk70LTd53LvQo80AdX5lrkn5XKH9AyCr2iICC24ox7TJaPIhyMCc8xYd177YEPzdbBxwsQybS4DTOxepiX4n/VE4fcqr+5RiMV4O+ld/w4touXnilSrTgdk5rX0ZKqdRazvUAyPY0AqcW8+8y46firC+X2Fm37r6eRMi8cRlS+ur6vWyCki6/OPW4FF3TNtTuLQfOMQs60UBOfKjnNjklc72MITb2b9rbznG9vD/RMfffSb0l5P8d3b8eWiRamQ3ika30HPG0cgvpmSVENHV7eqy+QNQskN+kkbtCE1i8sJV2xDw8L0uGA9Rhx/d0VD68G3H804uWv37Nvx9ofWNTHZVXTWll9U8eW2qhfWQjFUZ63jQ6UvdZFEjwLAxSLs7sUWQzc1WHOQjPnYTD+AKkGplZPbBqYOpY2IvHVuCTk41AzeonasOqoQMV2yTl0G8wEKeOEOF6jBVjVxGuc46Ud9BITTVjrVURYgPmGfrs8Y0brBa/MHoDzR6R3lW4Y+N0NSM9qgDUMdN11mYAAjCc2l+SAm5eUifn27QnplBAfIg6v6XrTLapiwdV6DASWAn0vop2D0W2UZM6etVoPdGwaA8ZzRhpIQT0PwOG1MQ9KWwlzFDiAIITCtkrx4qKA0QsCSmJmERGmVZsmV5Yq2mef6J7inJEOA+Uh5XdZ9vXOqJrvcCjJdSXRfMhAYKHFgFwmBakPAHXMNt91fc+kqOtAVgf/eCmLOgJc5f3p3WOaIoZbw5iw+U8XdRKNZ+RMmggmP6kKC7QFYDzAshObB1o9vavHimXEVAupZrLoOwExbjURYx9gAerTlXMG5tLhsxkfq+tZvzrxlxO/MEndA2GydiLDtI5G9sL7T1kwJePk4EyPdv9hqO/dpziyk31H+DSL31iPUUvc9gL49aC2T+g7wv1q4ETN6YMThnMq7jmH4hyPnDE8LNqu1UUeX0ep/2ElXyJzgk/anmhuISkafh+8tFHONWDWmwtUIdmnkyopD4OaiwG0FhaU91C+qfzpPYY2gLEFWpnOYp3eHTnRJSIeKU/fs9cBPMDqsF1PqVRXSNNfXjtJbq6jOfs6DtdiZpOHIzbt88uiEfXuj7Bv1l7Dbdn5AWPas4CA7nthene96uR0caWkhmnroWkO7ufmt6aOesIaGG1fmDZ6/zvPur7vum6Nb5Wtmj4z853qXdUrrp4z43pkkwyzncs10+fHoAAmdpzRpaSXtNPhGe10c9WGjK8znfPZTTGDjBMPbvdUqcMbvlYvOv1E+0iKHEmdA0ATJ/eSOktRRo4ZLUlRM70rbE2PtWlU2rVC24xWBShEB26xg81+kWOGh6WkwJHnuOP4Xo43iyf5Ti7b6386RrQm0qcUvUdhzXZS/KjMhESz2ewLUjpDRTAO9vX5njKzoc9gAfvMpAVYT70O0IKGOOjxGqHowRSAfEeLj6JY3wEoe9IRfvLaCXapzDbiaiCSD3vP3+midcdA7ytni5/sezkke5YdLg2DtctaGhDuM4LIorzzHk+vH6rfNGWVsNJAV/qhVNK1UW/M3hlrtDwFQTTAymyd/lR97to01wNYe5hB66rmzyfU1dRNmSvtB0+YSzvl6SALoMbyImVbqWWG0CivSyLmmnaUCUk0fij5pYafh40XyqyC/DYPETkUStXvc/y0DB4N0Dq05F4DIi3QcpRoHmJRKGdg5T9XTpwChHovq6+L7BJCEXsVoCMASZmjzoAABqLJsFhuALeaY8TcdSZvwyR2pRaAEjSQoCJ5XRONOsbX9x/WhHwgIKwAi6MJ1dnTnM4CrcuLjPFtQHq+AENWc+DhJWv6MIp7dv2A+TwiHFeEQz3BjTHh/EDPa/qM+u96dG01SHqfArB0gDNYWH2v5J3N1M8lomowaulxB59UQGtJoPB2T213BkbvvCvFApwtoJWgkaAl+pGfmX3kJkGtHFduitlfH7Ldi77Sm6XUG1Wyebe/+pTZfGS+GBFF2ar23UqRjWHJ2pbaDjxB9Xyvin4QTf75OBR/NBMtZ49BjK3TtGmDTYBl2qP5/x7A0rQ7JOkBK25q8yECdbvJszWO9Xme6Y+1rBqAlUx9OvcRQqB79xNsx5+niErGZp8GYKkZakAlu1BfnOvWGXss0IqB2kPaRJ5V14zVqsPncdC5p3v9GOsIynXtmw490JL51lpB3CU06XoHKJFJHpDgJMSAxnvIA62hFUzddXkxJriS7SUVX6umUhtAK1DAnM6LXJeqjp0y3M+QhPXD3UXnRwBlHLIuGzJW+HPGUMRGvfCtAaVbATRb5elpdf7UXyvIVjBHD2z0fHfKxcr+vC9FQzAwGoKyURp5ZCcCa7/la+YAfUjitA2YDmfrw7+Js9znP0UO8Osx4NnvrRguCaePH6p9cwxteh9xdD20LJ3Uf7kaMZxXpClSmPqciuzB3krf2XrX06jHhJQRTBSXTyNUfefLGHcdnZHYd2zNwJJa8Nxj7kRviynryoTYEcRbnR+BTnYcmSJO23kI+vxWTikhQEu2ALBc0T7zDW0ldyEA3H2Dn9lX6Hk+v3nA3cMBN1dnDDEjhIz7C4God5+TnMd0MqY4doKfv3uFcAk4fSciLmSKBAMrG9mj93gUxotZqXsBL5kjMg2g4nZYNQcZVBtLHd9ZaHQS5/KHgt4qdlHeCdGyg1sAWTAm+Nr6E5j317Z/0beSc2YFzZEnAk2DJUAjlWtof5YonqHuc3Qix2aYfqn+JdlkOLCmvpT6jrryX7nXyonYLQzkvTCBGZouyPlZ6XnM+1SlK8mZJs3E+k0502QjoKUyTXDx6W7WlX2cEiodK1+cqnuw716ILL4Zqn0rE+PA7NVWRNVjLFkMNeCQa9jvxBleQJ4sKOVYMS2JXpHsI03jU/NU0XeJPm8xV7G/ePXXaM4t79KayrPw49rUMa0qMIgFYLg5z2t6hTWVNEMKdmI5j5xX3iMDPtbrAwUEjaxRmd24ah6ZWika6QRaPCkTZsb+irVybatkRAQCZ3dAcv1YymBAkwe9SpZ0noeZ5627kQWAFREhi6h3D+XegEqlfVdCR84pUa07abRUX3DN+IX/5q8DLXTV8l5Mlqz0KsSqtXAdvVd529COiVIzwFx3Qv1dTruFgs01bLqQ8n05Ps4J6RDx4rfKhPXu6/QgHr5yUhamSW4sgwdrbjRJfY8DcgxYriSSqfbZUFC2IY6obcICpxJ16Sn1njpwVYbQZzQyt6esaqrfZBKRa7mBQ5m6Glj6BM+NertT81dHTc70HtxEa52G05H8ZyywkjJfE8BeTkHBzsDv1vwMmF5H4KMz8hrwnM1/YiJcE13r6sDAZaTns8wMbFe63vxdAl+n7zColvdZqjqAxTL5s5ik71qA5UtYy3OMc25f0cA+T2PA8LCa5Mnl5a5WYx0z4BcqPdYo58a8Fhj0xDPpSAXr+A5Uvg+S+LcZSOWZ6yTp6tDzXQSagVLP24wNch12DdAcmuXeqjyalmkANJG8nLObTizTQK8D8lJYsqouAjb8uNUDWHarjFQuf0BRU08kbtqcV4r8Po7bPlzCOnhwtacPBLSMjo6P8k5zFGozljjgJ89XTGZ7OeU20qooE7XVDkC5T7lW7xpyvFeYd+Naw756dXkP+EIokb/8/9oXtejFbYEVC7AAM9EbPSzyXZb3ypv2OgALaOdKCfbolSxWppZRIzYx1+OAYfYyLwDVioPOeCXyDlugzBUZI8Q9RzMJOICldWB9S4lW924YGmyWgG4gncmj+hTABryvubBX9kCVVSFnzSd/c73IB59RWyUHbNqaoR6guxnN3QqnoXIB3Py+0+iaM+ZXxHApkDi2g6svKl9glaGlbj1fL1/fEJp95SUUP6x4Z1gMTWy68ULZIjIQbjVjM7r32qaE2Es7iPmzbY9e+ytIVeZT7qsHOtxKaRrK4CF47bTdXbP76fLhivz5Ad/4yud4fiJw9eLU+mFdLjz5CXP1QJ/nj61YLW2nt7S1bFQR0uV9WDRUU+yYog7vhgELKSOPduLfvMXKhAdATYa29CQ7vM9W2PNRCPV7Jfo7QFks7CahTu7/gfOgjSaoo8si1OCuF2LfjBXW+VUXbYVposo+8u4Ji7qkBmRtFp9n8bKYSKadIXVwoENKx1ya/WLFRA2qZtaeX5IsTjnXofpXWYDVM19u5T7slV5kmDJvrUmtKX4CtWyImAY7fmHN8bY9tzSabJlr024Tuv/Y8b6vbl3bn0ocquU+dTHRC1V2QKtTDwmAUoLCLhDc+1OsH+2lvNxQJcWiFp2dfi0/2TkohBpg7cyBXmi8Gh88GWC1w9ycYYkUX6qAOAZ5mc3MXoqoV54sVdEpT44utE5napbLbrCOnZcuApqaQL8j+3m5udZ8JdReOg2IF0oaLVFw4FDsNNZqz13TJNOhZfJmU8cl6fbmY/rt3depOV785oz5xQHj3YL1eiLnXmanJGddT6Q0LJwyIxL9moO5jnfCA0z7Ufuo+KYBk/IixTvRDTMP2wMsQ63SQXYSKodpZGcuQCtkc0+igyRq17mkX9Egg46Jskx05jny5Kq/ianHfAYASVcEMBjkOoopzftlFcat3FYPsH/nzTN8+cU7/NSH38V375/hMNJLep5L1w9DRk4BeYlAyMifUbDC8TvUDtMb6LVEt0pAVI7AcKE2nO4y0ghMop/FvlZWwiHOuWFI40zpgcJaR71ZEUEtvcALMc/xtmeOloifxq/CP4cMnUTU12OgFXIaI0UBDkZAeA+U2HFV+rjrK9EM/iKmGJaSkgSAiaLlKLUq7Um5hJVyoehZiaJ1k3kwaXxyeTc0EljYAM9G2H4dyjbwufMQECwA9b4uay4mMr9PL+ow1b9Raph6P9kqk2UiBEXwVLSqSNWd239NCENU/yrLhOV5QRgGZElJslUs+6xjbzbO9BuTlgAHq9zeYWXFhKhAy2tPyXFA6RMh1FqG9nriSxYj/X8cOeVRGW+aZ97zhQsBEiFI/Yiv4VOx2Dpu+QzK9QVUjmZOlHlzWakdRPdJ3oeR5oc8RGVddZ42l7B91ZYq758PYpN6yX2H0MgVhN5c5ov61pnjzL5yTxKxr+MDmwGDAXyVGTOYdwrgdwPl+7EFTjoeGCwD8Fg0DAjruhFxCIqKlvb38+wj5b2ZrK4/z0bp0mmN+amDOtXuG6stYmHAkmNZ6mvU53nfcvtVYmyWZ7Sdnz0hMpBDvoEy2Wt6ld7K33XK3n3sRYdsPoct5WlAAwm65+t834DfzovUi/gox9fAVlPqdBKX9lLxFBMZV+MJLMNIwU84fDrg+LU7AMBXromCmob2OYwMuiKLj4Jzg02fP+3VEBOlRASKiXDsMVliKrWMifQVGf/n7XuMfiB0MibAxjvnyt570esHwoRpAuo9Jiu6rQXoutLsXEMApUuF05dneJy13Y1q9mlPsnlnxRf0vH2Pjb9aJ1hm1+FX99m5j17psHtbJRyZjffSBykrO9Vjqcpvrebhk8oWk9djzTxLZc1E0n47TFbjw9cDhL0xw5sp9YQ7707lk9pZ3G5dyxdrjvRO7nY3/6zFDN1jveSYuQfwXZv03n2dH9bqWlW99liexd3Hlm/WY9dV8LjDPls3BMUJziT4BMtRT4Nsd+z07jDvgS3eM0G02a4oq4cIRet5YMTdoesLq1GzDoouO2g/h4C4cqLjBB60AySZsmju0M5lNWJ1mQACGJKepTBx9Nvhc+q481VR03340oTTpwsBvJSxXI/ESPD5w5LqyWOgeopTsNzjZvRXgibLTaepiKVKIk92cLfaQwAq2lZW7Poc/KorQR1081RWjZUujTW5+JQ9KZeEvuw/Jd9RZTNFonh/Lstyeb+2CPJHGvn5ZFp5hiUjCVvVCZWmiNMCQkaQj1QaQmGzErA8Ix2r259YgY+vcf11yuL8fDrj9eUKY2TAcKTB+7Jc4XiccX44aH/IrBKfhozD6wBEYGDwpGBI9BZjYayGC2tiSbRgKPUtAKsDZDLvu7A+jZ6PWVAz4VeBIN5vQhhKUYzu9JUsyVXltzUb01oALAA0mlvhvAJjRLyQ/k4DtOzkaB4fabehyKuo3pWpsxRNj5JgEzIra55DYSssU+V9sAzruhWpVjEXjpGP54XaS9pd3lm7apbTjJQYPh8nWnVPI7ESPtXP1oQTArAhXtQNSnKgRxmoyam1A8XJ3voXrSux7X6Rt+f2kXN1jF4zZXSdy8VkyE7jeVkRxqGRhAjjQMr4h8mwQKHRFNN9EjuJm76Wx6HNcmDvmfdrxsee7lXOfaAkvwmzt6za3tU+QBmLNUrRXLfLQhtWRtpgiz1cyO+xAVr8yPNULDukQ+eqyK8Q2A9RGdxswIMNIgn8LDIzyCGoZYPqYXQl7TMLobSVMHS2ne2zMX7GVJdc3gavdeb6aMgZ6Wqi91XT/ZHeZeWn6YiAsK5a/zzGkuNQo1ZpHNQxYkO1/6kkztOZLLMyBQwDZVYf3inalirc2ny2piRtDCcymIZiZtABz6VysceXrVwcGiXozRV75eHDEWkIFCHociY199jR0ingo9MebqWdIynv5iHspwmRIu+rebnzYawnDXGMlL4ZQhMttofIG58sCQYwDrjCrnR1blwJCcUsKXVSYNZhtyR9jvYL85tkGZJ3V0Si3wHLNZn6BGCdBvrxy6d3zTVe3RD1dTyJU1XC9NmAPIIAFgrA6pXRqLQDpa1FrBNA4/guzInIPwCGVdnTirOrSZeweC/wpOnz0mbZASy7NdepBl48xmQZYGf8o0LGvjqycSi1n6t7cpOUplixwE5Wt3tMtz9vYEmUZCKr9pJcO62uNMVi1vAToJ1ABfwmA3ret4hjMAzY6RSVWbCSCo8JoQLvx1y5YBX9f1rhnecbRs1+J7kOZUKcxlZCwacpqk603fe7jI6AgMBjWTSAyBc/p1jwYeU5gK4oaWVF8HX1bW2ZoJyNxMjjunMAKqbfaw76ADM7XjdyB7Y45qbRSxTQJCZU+9tT/JiSWRj6d9W241agnXEz2dS+6y3kfAYXXyfAPHND3jjNrqeU9zYXBjsYuhXCo+ljpMLgDpGZ1eo47un19pxRZbG4N8EHQBWsp1jV0R8nuQyVGcnA5cWAPATMN3WkX+Nk6OlI6eQjPRwZ9DV3mohUslhquhqBIZBJRgIFYMFsfc9lckQJJGAGL7vBr5jrNtpJBjfnn6PMjp2A7Z8cvpHIN4nYaOS/sRPNoWKdVMd1isgRbYqlDIrm43tSRktAjowTB+DwOXD+cMXdbz/Dv/m13wEAzCxS9ePPPwMAfHAicPXAvlkP98Rixtcj1mPG8RNzfzJO81wwzPTd4E17mcBWjoF+k2YMdXvq7p7E8OOPtJ9IJoicgNWo2zJ5bA0CCYYJMgOjdzg31wgpFXkPLvr+W78GW2wqDDDocf3DA6parqUdX6p7cKWJtkRpt83oQztxCNDyQQLOf6Ri6WRwT7SiBmB8QRyTtZQVfgWOlFEpkcvV9ilFWKwD9WEFceqDFAj0yNi12Tf2rynHKUjzJsBlYf2n3PpB+W2vGACJ07H+TRfwdbRfV2NNJn17TwJwc6b2kTRA1o/K+5L1wJv45IxD+6z8u8D12BRO9aZRexzLgEgbB++kr+3iyAculqUCzKLBjUVqmdDglo1FwqUWwS7AjPuVYZ2eFDyi9TeLId+eXqLGmAqrupxXev+9C41fhBpLWTNe7QFZW0c/Fj0BQT09QfTP/nw5yK4y3UP3iRyrid2HbNvjRHNJdpfG6DAc2kF83XtRawYAyblWNRuiqmM6lmvdf0j7iIOzALDxdqlS5AColOK9fVgVpr2Wi70uHxPXpPeg2kN7NL6bPKrViTM/emd0W4Jj6Sqa2a9k1qTmVo0Wk8TNLDmxnkwUqPpT1ecrwCUZxXB3X4AClQLYuM3YAX417nILC4LefZ22D19Z8cFPfoY/8dHH+OrxDQDg0/kGAPD798/1uF//zkcAgMt3rgEAV79N9T9+JoCuXEPMhFZAtPHBM75XAKo8h/JbZTK0/8/lfCMnSZdUGgCKz9Cejpl8ZZkSx/Ron5nqdwEwix6/alX3gDLYNAlYgTIYOvOxLlAsmLIpadS89R6DtFtZZidAXDm69nxf3iPJtC4MJopKSlMRnxxfE2gPDx3GZa4BRgOCUka+mPQ9WjlZ3Lj3VeUCWj2qSnvsMhvTRyqs0hPMkP7eeyX0/K/2ruGPmwgUhnGgezlMqj+lzu62HT1TtMdgeYkGC9alXaXNrGnPFw1acBP+OJR+wVHX9n3TviwMnBwvfcECVMuIWTN2554rqwi3VZLrO7/Wrk6WvTUBVmfps66O1c6OrbMWE++LpRWwc78DsN79JaJ5z+icci+yWKmvsT4vYNxHSXYjAqXIPGQZaxuQYfZpJJdQz6G/+Ks/D+D7oJPFJ2ouQGehFUiTKRtozQ/VcW4QtrsaNqkqWwAL6K7evcZUEr8w40ugchLi92d0mc4f0P9vv04deb0uaXq8CVN/GwMJxOWsTFbPobipq/gfXVZ6YYbQmuy8ir51FrURYuaeq2t4hsz+vwPWfFEzzBCRDgPSSKbcdBwasVkBQghAHlBU4EG+VIAR4twrmZirsBoTHG+Hud39+Dn/h099M57xbj3inCbcDDR4f4lNh2/OpPR/fkcv6/RpxHKdcXhj+sXOnK+yFLrNxcFfHaT5t16f3bl9n7i7Ylk22Yida3iAZZgsBYo+xZU1gy8bgylQ9tEJjBdNFgTpu9se7p1fNbG6NeH59jNRgyEl8uNy99+VFrGh5RKZNUZmDx4HeMGZyIeHRSfa5h2yDuQxGj+poiuWH2N37LXtJOv0qKqJ+3x2138CwJKJ006g78Gs5XlBXldymrf3CZRchraO8wWIwQi0uknOll5C5w1mslu8VpcHWN0bMoxcTx3/sTIvxGRZS8fe8R58233lHXD6axakkO7b/nglxZov82EsTLDN5ag7yzzXYXI6AGvb8uSYJZj3fq97yXgaOMLR6ECq+dNjiCE04GhXhsI+Z/XFIlzjSQj7XCwueqT671+qVd2jV2F9rMhCZENsAFZVfJ6291jYetMX0DJWzf7mWgK0ptuM5bpmTQRoLc8LfSLszfySf7vebg8PtELKymLtUayJryHbraACwLxgdvUe6n1EDmFTZRemrULg52bqvwfCJCJ0dM/QFA+0FHyFVgC2pxs1nJl9sEArkOlwZRX4h6/Rgf/2V3+rOf7lRKzD16+I3YosdREfehNyAVpxpevEJRdldgC7flQOaAnYpAtuHBMKA9qwOk95Y62fgwdYO6UBWNUg77YySHYm3z1duQIU0WZSMACrrdva/623b8/tIGcah5z2Xrf448VHxoSOCxturx8kGtgzLHvWAstWWXAi320e534Tc05OBF7k/3bbKz1nbF8sUJQ/oIpOzDtaT8LSlW1nZTSKmCTvc3NVvu8BrK2iIGpo72nvHej5TD1WEgddsX9W1Td77aFsjFf/N8/Hi9Hu+Ymt7v3pVXGKDYvV+Ic9pXQA0m5UZOM+0Gn7xbHyyY0/QAFYnXkkXU/VuYvYdwvErbyLACh9nz2QfkLZFGvtlPcDWd5CYcBQFrHRicBUOgxIk8nnFCR9jgiSujxPIVQIvEkonBnJGp8jq86qWkFbd6STQibQxuxSmgLyCKRDwHIVsR4D4poxXweMt6R7dPe1gIeP6O/2qxPuPxqxPJ9w+ZDo7vMrFukUE9YhYrmOWI8DmRS4bUoCXP4LpD4fXWdNh4E0T8aoHUd9tw5DJeiaB2prAa/J/jYW7S3f6SsQFOQZBt0CKG0d+LlOka9PwQBpIrC8Xo1AQlG6F3YqE6hIU0ASfyx+Rnmk66YD1zeWOnlQHRIBmzgnjbjTyLslMygB1omeGQCcvj0gTwn/30+/jlfTPX7s+Bp/4uZ38SdufhcA8JPXnwAA/virjwEAVy9Ii2G9zphuA9JEyu3jXcZwJhZNGDW6PucdnEu/algUBTh0D+rwH7gNAreLNfNmILJek9eisixk9osJy2ZqBF/orsKUhbXHd00uhXYn8/Ba+2bJNXJu/CPTWAb3Yl4udH6Y1xI9m2A+LzTYqk9KaurWREJJESf9nBHnFWFNKgVhF3fFzzEYk25ClbvOF7nXhUz6w8NStV+8PVfO7Y1pcl3rCTRnAkaXmY4RpscyLilB1NzDEE1qGmd6EVC1JuTzBXlNyJeZtvNC25wLi+XAUgNeLAtl5Q4cw6WsmjiP+30AlYKorg0CaHlNxLitq4KSfHWkcSsEpGfXdN5hQD6JQHRHK2sLTE1jeUbi7zWwaVIW+lJfG2ltz23vUfqHKMtHjuZj/ywZ5wHQd8GcX9qUn7MArOwXKVqfWPqE+PNltsCYZ1cxQUFSnPFXNqI3FHZYfZTN/FAsI6FlLU26I2WDfPQmCsCq/BEzO+5LRoGU62TYOm7xudTp3zDosp/ppjlyVK+w/P59y2UsqAJ+Io81l4XqYX3dbLYBeT7BjBd+rHwiznovkPWL/+DnW7OA+X/DFPUWDh2mpDij8T5+8AzQTuJLl40xq/cSxUUyAdldPzj/Gfl+us+YOKpMtJCA4lMjgGq5YRA0Bsw3A5briCxjoROTLBF9QBNVJh3LgM0mnY6swqPN9+hNt9urtbBmpEMJ7U2jMa/IYcp6FUCUpliZXazEgqzoFxcYAAGwlZmobmPvBF/9n4FoDraN+BYXAToMuGYCw8MlY+E8hvd/pF4t36Uiz/HHrn4fAPDNq8/w628/wldfvsX9d6+x3iRNoXN4Xfe1uBCgCpkESUOCJnPuJXUuJkO5L74fHvD0O7TMS44Evu2KLA9MW8fYvtw9U4QMylsDRHXBAsCqPICxXWU2q82UdLHTjaKV6/bMeHINr8/TqL6bwVlubwtoAcWPQ0VVVwV5JarZmRn2ohClDsuq9yPJ3vXnm2M9GRrAVTl7q/nMMR2S5BjQZxUGM/EBqJipnGoQBCALYPEaV37S9MLQ3fvdmUFyprqZKOPGCT7nxslf/9/zJRNfrHs2c7JJKD2/Uj8tD7B6c0i3bJnqKqaWxt4GZNuwfimxfi+xrOQqYyNx9TjzTOeFAKNNYeTOV67r2nNeCmDR42T8FHNxAYl5Gqp2sdHLTVoqD7SsuVakKiSiVd472047Y0qTXsr+zqa55t2TOtvz+oWWRDrfzeVaqq0nbV/vi4Tie2nB1Baba46r3HJAIO8X/8HPt/fdKe9vLhzcQG6KAhqzQvSmOgUazGZUZqjeNeCOj/SXhlipYwNoTBrW2TysNKALaxQ7g7M6i4uD/BRw+oQnVJ6zzy/pt4cPqCPODLLOLwYsR86nJ8mMRa3cTpZTPZAW342sk2Jyzru5Ex3YADA2x+pqx7YdH58OtT9ayDBO58xAmLZPbsAhVi4o80XXR7VdrvhaU1k9PUUcVkyYHnBYPRe9H9en0kAAaz0GzRt4+l2aBF8eC0L+2vgaADCxDfK37z/AH33+Cf7V736EcLXg+PsjFrZSCCazEYTlulw3ZXSgZs3WJMxbcbOoHJvr+whmXqsU2KUdZDDaCiN2k0nuAbKd4hNOW2X+Xh47XRQI8NJ3vrfwcYM9RyNV6s1S/KDX8xHS85b9NCLQO9ALYwY0kiNdqQbvf2OcyQUQSjCCvAfxzb2yT9Q2qfUD6pRsmaJH9lVGk1kgZYPAAMueD2gm6iqq0EbyVdfosFtNRNuOS4QDeNYHzLNZvSjHfBAnbmbzY0S6ZudmN+FrsaysNb/aY/z+VKHynYuYrvyQbDEO6DrO7viQabQe+2dVplIvOGojIKVuszOtVs9FgAy3+ejmjbG2SgBmDKuyF0g/N89ZHPu3nNrtuxk4glLeP5+/s3dcjEDKqqPXK1aeyC4ubRRwF8EISLP6ginV+llu3+qzRKeq6XljvH1ieT8xUi61ecNN6PbhOWCl5oMDD0zscBqWssKEmAAlWKbHcgDqEyPpdzRNRicZr5howkKO6CFlhEtGVgf3wp4Q0ufEw3zO42cZ5w9oux5AJsUl4+5LHP7/il6y8Z5+G86Z6j0AYQ3skEuXiGthKKqHNko6Ebqf9Tggzkl9vvRJ8QwvSa6pkaBbFRo1YM22OQC9LxEYFTOW7L/KxDHnAhDNS0pAKwBTYWOQ6d5DoqTG2uYr7RMvkli0AOXmmY5ARkBUWYay+tI6JBLG0+TSU0BcCWjFBSRQKqb6GxrgfupEJsFXwy1eDbcAgN+7vMKPX32K/+Rf/Rt49cEt3vzzD7A8SxjfRQxnaSfqf9GAqdKG0DYikx/0nq3Ybo7QvIaWNWyFX90+QGFZ5ats0r4ModbKkoHFMgeWKjf7oMdurX7Ap/5Z+Xv4ScFGQ8nzHCO1g4skblbPkZJK07YT2eeBlpheEMrAnjMyzD2I6TKEAp7kNCwumicSUhVhZFqhZt0HYJBmIiirwr436/VUTMQpIT07KtCq2Aavru4V1f09AggCDARUWdbLY8IYTS7Dtd4/BmBZyMwosgW+fbf8eVJCJT4qbSJVXteSesffTwdgATDMXNTffbAM1SkDE5CmAXFdiE1/dqRnOky8jcC8KChTqQPrZN4TBtUbMIuGLrgy/cqBOmVsDYjW9DA9fyUXXVraow9kRfg150x5LteVxFg9EDf1EBFPtdQImcFuCnZxrcOJjPOXFekwIN4lEvgVGQ5zDWHLAjNPmhDesmvG1NnIGtm66/Ppg5ZqzJK+Qmv2Kq9ivCxI14fivyr91abiMaLhgFlU7fneCcPWyeSg5tIdBXxf3pvJ+sX/+q91v/cIsaDp7UuolILYhquHQpvdSAkPQnvIWdks3od9exCMX89uKhP67fpj2vfwdnvfy4vC7qyHQArgAjA7rJYvksZHmbRju29yufzEV40qy18Zk91mUTpXJph2FxUD7Si4qyO3k1SwRRzUh3vedtq7JE2m7fDgmBKYPrATHLAyiFzY8X1+Rvt+9eot/svXPwUAeB6J1fq1h2/qcd969Skdf8N1ZOIr9PxWXfix1jPlItuw11/lPGoer9md6pwqyOsGEMsuvc/b+5RVmPM1ELbpqcWbgfeuodGAJp9eY2Lo1s2xIXtpd8wAWkRGuQ/uCKo2fow7Jnh5v+Pbh7Kil+N48mn8bqoTbACsvX0ts+dBTk8eRxytZZL3ztXVJQpb1n5XRwqq7MROEdAfOuxXL99iuS/aSrBPr2RhuDoioGWB3xEItX5WQN+5XIpjI/V89n4ck9otNv8k0Je/cCVYsLilk2WL+hFxtfb6rVtohZSRT2P9zneOTww8FHQ9wYm+8Z+zPmV777FqSwqY3LxEM+aIzJLoR25ewxd5zvJ8e+PfEDZxUK98ISaLKsETsNQtU+4+YlHEfgtF16qlxD5BymSwE+dwptQ5wjYhE4sQcmnA3mSbxoBhLWxMNWEpUONBQvpnZPX3KWod1ymwc7IcU04z3SekMWC6y4hzxgLxwyHWK41Bo9rWic413WUsp4DxQdiHjPUUES8J87U4bdVtalOuWDNcOhA7kA7EkhXTGoFFMqkF7VRhzVhPlG5iuWINLonkYrYuj6GOkGCWKDlgJ88nC4hKbHZMGctVRFwyPdOU9X4ETOlzDYaVSuITUMyKw4O8qHT/As4o0XZGcRxvQUwyY52Y+pQ5+r0TfvX6x/GzP/ab+PHpE93vZ06/jf/ksz+ln2/vabAeOLpQTX9KFMpAVD8X+1l/H5iVCmj0sugDHz+UY+w+0epGeZ0qWzxL4FdmPZ9J539U6VVVxz0yGPXYsa1dO2a+7mQkTIRTU6+ArbBma2KWZqXEubJQqLJFm8naD8CctqfxWTLPUt4jva6Edjv/jzyORj3agBb5vwAbHnz29LA8wGpMidJOTieqAViqtl5Y6LxQ0mfMM7Ffy4IqvY4xieZlAQIzKCICaq4VQtDjN5kwGIC15RNlr3uZkZ+RTp34BsV51eAp+oL7L8tlhPOM9OIK8e6CfH1EeJjVf4vcJvi/h4iwrMing2FN3fsiCZ57kWZbAKsCa4YRk/ue2bnat5EHL57lybk1pUq/n0a6l3HQ/o9EDuDpMOpcmYZYJIRgQQNvZP5biJUd311qEB+DYZECp2djpjgB4TI3SvQNoPXMtDCLcp8cNKCJlxNM4AAHzsh4qSn0mJXr6D+maUCcV2bjlobl17qJWv+61uOKmoJN5HAIDYnxvuULHdZbrXuHcgBNOH+JaGuPL6xJzcJ09aWcfXk9xmI6UxPIzg3oQFkzKz02R+oRl6wClJoMmFmXqZN2RdmoQ33vjZK5rVbnJ5VdYF+n9dRpELdyUYmGnk6WuR/5rHVlQLarXeXYMs9o9UrIdD3rdCkTUzSAzJdBQ/wZgOysROTZxCXj4UvA9C5gfUkD6jdOnwMAviZ2QFNuZwJY4SzAle+nl/NXrA7sr5VGMn/KH9UVWo+t4nWzQq8JtP/XA0VPqK9bnNnjUcduPiYsSfWp6EC+j55Tu18NP4V9ttdyqWh6gr26+1by2T3NLilWIV8r/3glq9RhdmuKRIBmk/cUws71tKF82WF6mmJBIf9tAqyd45uIP1PU1CjnEdORWSjsCo16n6inFAHY92cgRsS7c6OD1D3sht7d5QVp3eXTtLmvd54HgCabQI8p9/OaF9XsVszVWdTl37NsKuujwyCZhZQXxO6eW/1+eey/Kb5wTdlgprPRzco9vzRfnqC1pufusHG6sOnUsajs5/pzD9hLXQWQmwATBelKAvXm2/2FpS9fCGSliRFmQC0XMFCYfx5DAyY0qsdFszVmRvYVUg0l5+NlU7yImbEZ3BtH2r4ZIk+R/J6OEeNDxnKK+mfrvRyLT5UFXUBxjD59Sjt0QRCgMhFpCkiHcm/kO0V/IdWTYUnbUbeVKNN31fBNvddjbNpZwU7KKhUAtMBMgVbke+6MEcVElvm8cnH+XYVDU8XmaF9YCoiSOo0Pa18nyTBhck6gtP/lOdX34cOAeAEevkET3L//R/8RAOC/ePevAwD+2PQa//T8Y/jj19/GP3v9VQDA/O3r6lre+d2zm6xnSsDOLpJUzsF8d6nvxctUeJBaBGllAVCzGcU/zfgZOCdUXZE9AqyqoAsAWDhSsMOy0A3HOsWE/Z2vaZk4pO28pFgSR2QZX5+N596YUz1rt2VysK+7Ru7m6rcqb1vPStlJ1ZHHiPgwVxNtuDuXSUcchsd6ENcEyd5EqCl1zDsi7bLl8I99sKNFzFMyCfeOUYf6DTDo8hAWE2Vdp0cBlvFvKpGG4uPC5qfbeyAGksSAee8dqNA0Zb0+HkMrt2CObRgX3yYOUDUAyxa7MDBRg8qYybXGsR8EYIs1A+8V13biOyRjBQXJBI0Kz4HmYyUyzBybtuYQN4Z4FwcNUBgd0yhs1VMAlQAavyBkAGjZ7HheCFwl8NjBuENlhmgczMehH8zyyDOWUkliiI9dBFSR/n0WD3LOp6bV8V/82X/3P0I+1J2wsFnmQKfEKqZAvjhthQXoCHyVlBy8T+NAWzrJeM8RRJJ6RF6qQahGg7yNb9TCaWAuL+mhX1gGQNgRqyruoyYlfP/8om18ScnTC/EXgOJ9kqoIM9tmKJF7063cpzHBpHpfy0bJuaV9VLHatoGwWM5cqKY/2+yuN1jHbDlGo7dsvjs3QPrigZQt2rc0hQ+Dqg/Kqubuq/Td+YOM+Tmd42f+x/8KAPB/+cn/BwDgwh3p//qdP6PH/af/5GcAAMdfpxXxkS2Lo0h4GNcTeW7lN/GDCA1DW9gtM7gqs8S/yVgsz8bsO9y5lBxyXjuICFjosRIbWQIUyFlzIbNKzQDVWbX1Mtxn9Z+oG8GnurB1VSbLJ//tXlMWHMUdoUT/FN9OLX4okZ96g6Qfd/wu8vNQTOzJSDgoK/vmjr6QgVqENR9KhGsj2ulBhymNudBMXI2Zr8dgeT0tXypQx/1vj6HxxaaR2QJYUueeT5ZMspJeR/IVDlHFSCvWwoHTVcQoZfFzW5jqZi6RPvfAL7M8h8qU1N5D16fL1gUo9+jAnAKtcxlA1C9OQKVlSZlZawIGbB2PnJ9SQA5/lvQyl1eFUfXMvxAXOmYZAmN8R+/g8KZl+1WLyr+3HcHVxszfe9/M++vTcsm1Usfp3D5fAEgnSWdEBw+S29UCPP9M9nw4K2kOmW/qLDZpGvBLf/evtOfAtgf0F7QyQgEWYECWhIyacFgPFPSYkZ2lcwFQTfJgDUlFYc5GM8C7IkAhiUO90ZFqBmbBDt5ZN2cc3iXEtXyXnO7VYnIcyv0d3yQc3ySkofgJ2QTJgPEfypn+n1G0qpRxclsBWCdiGOJSfLKq6MGxbm9b8hDIN8rLAojJ0DjKD5dUROvsb1zUdDcnZS2UVboUsVCvEabAzjhavk8iUXVi1JuS+liQXh9z/UfeAgD+Nz/29/APzt/At8Zr/OsTAal/69lvAAD+0Sc/RnX/Ng1S4ztgPRKYkijFpJGd4Ps1k5NlM9ayShS/LDqg3opmVpypnYdLMpIY3D5+krCAxk48jtbODvSIXk51jGeRhQkSOQW7on4PsxqxylnfVaqPuw0DGDSVjTfHda4d1tRntGyqjy1gZX/zZlCXEFr3tVFQHXNJYL0dEQkOd2eakIWtWYo/kzJZGwCLqpO721KnHYAFoFGAr44lH58GyHn9LQD5Pd5JvbQHWFUE2RZbFIkJC7EooD+4Cd4+o8X0UQBICcO7c7Xg09RGpWLuPGsBTd685f2+ehqEnbqpXIFh3ELiiDvn2N9Ln5Rd1KaWjmSKZVODpOy5zMjToPpPPQAF0KI7c6R0yW7iFvjStqxRZtPXVHX2elq53DtgxsRpbOVQ/L1IsSyR1+QCqqhCAJQKSGRt5DF7M6J//gl981+vPlXd+DRj7C5mHytfGGTJBL12NJykKD3pAEPPJ8vrd+xFKPWAlgAHSU6cd32f6nPLpDm960TbOKBFFyNfq8uzsrr2Zb4x4AjGj2fPdO2A1t7TsUBLnNXLd9vt3DCB3oxj990CWikrcyYMzHjbDiBi8qry4KHfXmHnt81idj2/onufn/FPLN/wJ1/+TnPYiSv/ZmZfjovQ0+0lPNBKpj/s+V015QkEgTela5qInj/UHtASxqobgrxRkb3Bw6+sTYRjI3Zq9/NAZkscc++aT/XjaAZtVwdbVCS0rtduPlQDJFVTzgCsraImNXUsd4Cy2tf5SnUciJ9ieXgKUFJgtOfDpTv32IihPs9TzChPAO4SGCCipLZtLcDyJbpFib4fe+2lpsrtZ1JOaPqjLkpagNWUrWexl69SjrFRoXs+Rlw0d66yLtv7lkwHxdoDALkTzdkVBXXbPd+5Rqts6Qy0rsjzjPPaBVhb+zesYqd4q8h+Rdyx75F6Z+MUTy+/9Hd+rjygQBN8juRbJFuqVGEulAlY6P9hQVHAjqhXQCGoU7bYlYUlyKGkDugxIgq02DdMGLZG+DTR8XFOGB4ShnPCdJsw3lMqlTjnirVIQ1BH9vNLNk29MGaMABzeZTUvnl/xviLtYBguSWejQEZs52P5Ww8RaQyk2ZXppVlOAZebiMtNxHoVMTPQW64ZYB3qVUAewJGfbfJcLYbZCktGvGQMD/Sn3/FfyEaaQZgsXWXy/ikXvTL1ZWsZGnl2VtTTtoX/Iy2uiPUYcXk+4PJ8wPllUIHYywf8/K/oRLefksnhH97+BL41fRcLVgw8YbxNBLC+9eJTar8PZz6WzLui9RUX/uNnOsyc8mYtjJQt0k6aOqnXzsy+kQ4VKlFdfW4TC8cOUTMW2L+G6ZI3Wcx2Jg1TOgy1P6MUN/FXg86a6jQTy6oMVw5BxXN9PXII1TtZogV5QjJmSUqpY/w3tvK1uTQwRdHZTY5uNCvAnZNMW78r7wxvgFbIuaskTxpgGYg0iYva9PrhDZlv3ESswpPi2O90orT0VNr1ooY1tQxWw+oxi9B7x2OowJkCIy9WOgxUR/9XXSZXx6pwpn+OWyDZO3NLkMCyFGbt7IDW+UI5DecFmBeEM/+tGePre/JF4jrkaVATT5VtgMUyK00noA+wwkZSZwMswmr6pDy/6i+VfqwJnx2rdzGBERqUIP1xrbbZvocms4BE56XTCGRgfjaQ7+9BMpygaAry/Fd0pbha4ize87fUoJZcvkMBOvl0pL9ppD+JSpQMBsYMWjHklXI91MfKlkrrLkEFatNhwHoai4Yk6PgwG1bcYQkAhZWz13KgrPIhdcfnIeKX/s7P4X3LFwZZAOlchVTMVqs4ZMt7qSYDEwZpgdZW0Qdrv0N1fBPBpGCFJu/1OLS+Pz3kKuO1mLwYQEy3Hf8wF3a/XFHew7svD8pwSBuIntb8jD7P1wHLMdBW5R4eX3HotXtV5/rMArCk/QXkhtLOKovg5DCiibBUR/UnMDTeHNg1zVQ3UF5SAWL0vdttbwWy4+ivoE7eo9cjfuLHv4u/950/in//1T8AABwD0VI/ORHd9W+//A382ne/ig++8hbTxxOWq4zpHd8Ot0UyfXlw/nMWFD5aAipQDVi/PEez8/0IPd1Nst2LAhKAJQzYXrX03YQOToVx9Ca1GvzYxNM2nyJQ35+muVCNqtonsFuyqcNG+hFdTRqApHlM5do+Z6MtMq7uRSpuRVRNJBkRLwsS5+qMov7O/jFq7hgHmmCfEjlY1c/VJ8a+idAWnsBDDK1flfiRGlNkzrn2qdqrYw/Ahdivi30m62rq3XnmPsXQZS4+Sk8xV3O/jLdnYGXA70C01tFMlHQQAwATKFLu1ywQ/Lv9FIbVvj8sApv9O2WkK+R7Mh2GArCkiIyOASaaYojHgfWqZrGqKgvucOM6RRELo1XXrwrAsvO3PW+vz0hbiimxl7JGfbcdwLUmfZ+1wRUBwSK+3a1DdYADWnZfK1UBM6aZbZqG7XfvkfI9gay//Ut/qXyQvmOYGKAFXCUSipkMu1JTIJXrY1E6yl7xOf/8/wMzMfYa3tk6B2B4WLGegk6qPnWMmALXE3B5Tv9/YHPVcClSD7L/+QPZv9Rlvqb/SwoeLxlQiXyGwgwux6CmK3GEV2dwA9pUxb0jHeHzt9mIsDi7dvH9V0yAnCi3StDtS+fFEiZAv+44xu/Zvb32lADehy9x+1xlhCUgf+WM3/r9D/AXv/6P8bffkWP763QPAPj7DzRY/cp3fxrffPkan/3uS8wfrjh+HtQ8KG1aqT50qmX9Be0+mwuNbPqaWDQMK6vnZV+9PHCyXA0AERai07a+bjvRhZZpyqwZpQP0Vjh2pNWzTdfj/TpgB+0t8GmjsHR/J0UgkWFeyNBuneJ2lbzaH+PqErYmSTcpZD/pJ6ge0fCOU9mwE3y8Ywd3SXa8rE2EobJIcp3ZOOvuqK83Zc/R3RcXYaiMVcqGXeH32gt18j6PmSD3fMoE1PmUO90AhweScdBgCGEBt0QvO2PFY+bfLMmbeZLeMqFrMmYpPYdqX3r11AAGZzoGKmkUUtbPQHTvH4OuYMyb4TKTZta8Ih1H0rlCWUyr7+yS6Tt5raxkjl9o70TaBit34X1D5RZsVCcvfBSImSTT8jmkpAvDaoHk/e+kusJkHQf1u67GTKedVfxcI73HHV9BD6zAouhNPkdgy+H90fKFxUil5JGc6ZJJHaNmMTEZiuM4m0hqx2FzsgB68GIOTEA28jPKJC2oUpfYYr9T4TJJH8PHhMzHy8pcGIVKRJO+W44MVjSqje5jQDELCri5+zLdjEQTzi/A5y1q8HGhW4yz+PVAU7fkUe6fBghxiidTDwGK4ntWN6CIhq5Hc/9BrsnmwiWUZpa2EKBlVjDhQomk45yQWOYCMahSftSIOmj9ykVphdFMiHZQchOhgmNd4RiQrJQtDRwSASrm2svLAobON1kFQvPrA8LLC37l4z+OP/OVf4bE7fR7yzv8xAj8vy6v8CdefBv/5M3XcPOVW9x+fIP1SOexvlnrERhfF9A8WBAqAMqYDcNa/l8WCaE+JtfH673G2qRr2x4pI4kgHweWWOmGPAzEek1DlZOyBwyDXWCI6TFGlXAIkoqkNxnYyaOXm09Mn9IHHBirWCNllDJUrsCOB9KXPIPlQaA4m/P/w5LrerKZIriBta5PJrPaUDME1eB/XslMeFnIvHGcKADkNUUV5nEgs9YQgXVFGAfkeS4il8NQi5GysKhG9oVQxEZFKLExt5nPMWi9u07wHfAgKXJyNscZcFbJMohJ0AMsC+asiKkHWFI3W31Ox6Ofcy73PQy1HttlpslYAJeOUfy7siWZtLXGAUEjmrLbJwFx7PoDdd0oMg/Eep8CXhzQqsCUZ6tSaY8YAAx8n+a8IdZtLs83hFoYNSfkHIB5Rpiuyu7GPSDOCfOLoRMgwqeRaHQdq+oFLolmy28l0tf7ZClgEQml84x8HIuOlTcxS6qecSiir6buJRiKx4Q10/6cESIPQ8m/a8FVBLAUmZiQk+bwJTcZkG+29ku927IIHECpuUIAxtCwWPaaX7R8T0wW1UBess5v/lnLONhZBChAU8ZLfti59sYq1Z6nbN1KNpvjOkyCFAFM1scJqCdiX8RkWExP7T4iZCqsV+nc9f+BYrISJ/rEYCzOaBiTXmmSc8shvfvldCMDO7QPzPr0REMbZ/Uexf8UU5rzR+ozRsFdE9W22lf6Il9aEkKfd5x8w4UBqbRpKO0lfnjyrBrfsdjxJ9ixJmh5wj4lWES27YvmV1026nQr9ZSuEiX/Yc5l8N9xAPYhzUW6YYei33lPy3ljs82SpHarWJ8J6+9hSzfIwvi3APumH/XdoE182E4l01MTD+PIILCwSLZUAAuo7lfT4fScisU8ODhAtRNl2ICgHZFUq5n1ZFmHnq/Y+xQxS/acwv0Ys+cIvrjnK2C9Y/5rGDLTj8q7stb7VieQ/uHq95SAjb2I0F5ZV1ooSBTmpZZ4EWvF8JCVJGjke7ryOFwdMef3dKZ8+SLIIUZygheQZoqyj5a98hIUns23xzszp5eO6hZntuwx/yJJs5cO77HyPYOs//cv/iUgkRCl9bOhzwQYbGh9jnTVHABk41DNEWvCMinTsgAI4CS87BwuDJnNeWYemgVYeSgTIYbQAA0t8jXXb7hfK0d1gB6kTMJ5oHuc3mUc3yRcfZpw+pzuIV4y1mPAeEc+Poe39P3Vd6mdDm8ykFkpPgDjXSIxzsWsLnQiJyYqx0AsWGwBRjTUsGzjQmKjqpUi+17WaiuO/5R/j1mt84qwJMRLQrys9HwWopzDnPTZIUAH1m6IvbWDP9bT5N2SZyeCeZMxlbJEhwQbSGBBmugvJANu3Bj39+7+GFcl4PMU8advfh2nOON/8uq3sCwRh6/dAQmYWZdUZTtkTE/cBwM9AwpekH1rINQA3owCHJttrvap/B9MWwBoWQHJ+QmUlV5nMAjNpFG23QS9togcS0W1o7rfpDQ9CxIHM7jpwoq/sGrL4izr1LhlqyHhNpy+x575e/B+L+LfxY7TAMrWmbDE8b2Sf3E6QWUST/RnfUi8bIMmhl6JjVgWqK+On4hdAubqeAEwIRaAJSv4LfBqQY+YqG19AAI29k++M0WYLPX3MhI9TTGmyeBMYZWMxFbdLUhJiYCEDyDYik47X4omlX/OFlB7J+ytLaAO7sEEflTHJjZ990C++OZVeRM9CyvPd219sez8Ricq55gX4DBRAuQhIp7pPqc3HO19v2A4k8zOcF51C0BlVkizksZ9CUQJ84qwSlAKCtCp2Op6sad6VceJFmEdCQiv0WdzFWugiQ9GibSoy8cBiIGCeIYIsixFFhiuAVZmkXIE2h/msw9uoP0jMXLToONp5pQ+aRqQpoh1ioRzvmD53pksoFRA2qbjOC1Aq0mku7PyKcrg9ef+zvV5uillNhid6hwyvvC+I+fVS0NQJqn40NB26CxuJ3Z8v+LE0lffoc97CaY9M7QnZ7DF5PR1sqD3UKVcSBmBXzx5Se015buBNVgsMNus1/ewkC0nab8qfmS8dcynLfI88qdka/6F3/8ZTGHF7y4jPufjTnGbkVCdsyewxAIAV2ca78lnKE1vzWTot1ljOlWA06OB635Z/STAecfZXJkd7yy+s2LUer6HeGUDtKoTh/72MfOknnwDYPXAo2OwggUy/rQCYsVksDdeqXDlDsuyVToAa+9aTYLhPQbJay5tmQHNtYW9epJullsEbII+oNynOBzb/uMFOquKucle7r8rm8DP1QOt90jrsutw766jpQIi0f3UYbwswNq6vmcodwMUaDO9JVC6lwS9JB3uM0rdurhCivL8Ibr3xL7HkbaNY/nec5bF2Y6pzs9DOr/35n5nCah8sJp9ZR865nsBWMD3CWQBZsLwjsl7nXWLatXf6TyScoZMfFAUnoXdiiKxTyyDT/lj2ZAcA5tI2uuVqCXajHc8Qe3kzBPToEycxzd7IArVvtpBO2NSNFIBgAGuzHhEEQ4+Ezs2nIktGy65Zk74GEouzfcjYEkc3oXZmFeKnFpSYT28g3LDVm3erpnwZN+dnY2fUBqCaRsGMSdhrygp9fkVMXvrCWoejHNAnKkfjLcR4cML/n+/92X8r7/2/wEAXHOjDYxq/vTNv8B/9/k38dNf/Rjz79zg/KVUHN2FtGBgrQCb+5owq0B5jqvXJ9t5vg2wcvv0hDelz/pUL0VQ1/hhZTSOoyGb84qZUKPBfH1chTpOvyUtkjG5ZImK5F2d6aHJKebBgmWkx6GfE+0x9m2vbByr97CsSIeR3g3PJDgGJawr4nkGDlOpt5UmACjCECgRZsNQ++r4klKH3fGMV2iP7QiLdkvndwFSHlB1P9tJfo/R4kKMlgnnB1qgEAO3SwbiQAEDnmlaCmDKQyzAKdbtHoRV91INtk57AHz7RurPzVxl+rX8uSCKwuIZ/0YJApE/G1Wr7GUAciJgvSy0SHHRhQAwvrsoW1UVz2bq+/sUAL1xv53SaOZ5E7hYNMSvyxSVWZHPnHYrnFdilcao87tIxGgUtZGn2Vv07ZE0DQibaqD1vZQvnFanV/6Xf+4/pp29PbSZQMz/VXGZPheV9JZ1Et8YzSF3rgeMrq3WmdKUMp07g5F5kcS+fX5FVOj9lwR9y8XKYdMdn1vIkSf4ilnTHoCS484cIsCi+GLVk7okqqZr5+p+FchJ/34o9zu9Y2bqYa6O6QpLykQunXDDlLXHYHk/u25nlxUPiu1dUgOJNMViUv7cf8TP56P6PqVe5w/pOf/Mn/xNPeZ/+81fAQD82PgaAPD/fP1vAQD+b//4ZwEA0z8pOQzHW9pOt1Tp6V39fCo/u4bZFPDB3xuQ7llevyipfnMgNbjBso7MDe4Yx5JVUVJSL+N3sxWV1xsfeICU1BdJ9Gq0HcoxjZ+HX/z3kjb7SXAHiDXvmq/v2jm//yyrcJNgWAUPJXjk3UO1byUQKgyM03fSXIXnEqKq/kY7rErjM2V9d7a0ztRhemfdvKOl5f2u/D6hwzjpbzJGCJiwv/uUJdJPnVm1esYbbE04cEqZk4mGkvNpYutOf9jJjbnZf/bYUv9Z+pg9xmm/Nc+06+we+5+t2XVi09wzGqvyNUU6qTnOPif5v0Yz87jKcg9ioQCgkbKB5wQREC3sszEPHmqAV7Tw6veW9P82FnGAjvc6RrDlJBvx0vSMnvUiCaxlbSZRlLafmusCaKxllU+dbxuVoqnB1a/88l/uVLxbNtHY943J6p7ch3d7hgVoBg2J/pM/e4yfpL2+lDJZKIBEVdBFyoBRceVjoifIfF4GN1cDhnPC+WXUSbWYPWlbgBWwTqhexC0WiCLywJFwoUkiDECTSFfRjRnMNElnkrrsAyzAAKhOKaJ9m7uUe8r9Z1mtJuRShp0Kxm9Bny3Q6JakoQ+w6ES0EdmM+blcW65X7mF6S1/+99/+MgDg33z12wCAD4d3eMgDfvX+W/jxwycAgG9++TMAwPlDOljYrLgQUxnnwlhaxfe63uX5r1PoBkbY5xRW9oXLGXEtvlFNigs7FrtFy54+l5cq6e+089y3HIsN6A7ryqKpqfhtAdhVRXY/edOBOtZLOLiE2wMFDLmtOtJavwtvmrTpPbbuTV0FzKScEukwaVttmBbHiHxzokg4TvUTOL9c8c96gkPxU4o3/9nimSrnb7Vn/sspV/5X/rduHWDAVdNGG6Ynq/vli/E3U0kDuRbLXQQXfBCsOKfWz13bskrer8rWzX8Wf9/HmKzeb3uMpS8WHHuw1fHJCvdnlXDAmjXNU+P2YeacOJPwqxANApZEwqGk1YmVjyIAEznI77j6WIFZpqDzps9fWjFZzldLxztZhMkcciRfLC86SvfCW8egVyyid6EwbL8fn8oY9L2zVr3yfQVZ4mjdy2vXTcwoyPMpqXS8v6BjUmwpAKsPtKqy9fL0FvAbQGszkzlagLVnetw6tlc80CKAGbr7SMlDUCd6SNj81kQDVKu7sOb+oO5KA7Se4tOhL0TN2NmyMKsnGmWJF7NdVkzuwfWZT9Znza7/+M3XAQDr5XEBz02g9fRHuls80KqiazyzZICWzUJvj++aRZQV21lh+uJEA3ffUxloVRiVV8Q98VTpuy4NUD520gFxXjrdx22rfb2y+pb0A1AAkAAicVbeE0yVaLOzMME74EneSamTNSNtFAUrcowFTj2AtWUifErKHN31PTrxnq+YG080ovEpbSQgond+D7T2IkO9edcn2u4VL5r5VP8tMecJyPPHV+yWeR/tWL0luTEM7+WTVcR/d0C47CvzUQ9g+X39PD1tj5VNBKAFWP68HmApc91jEaXe/hw7jLBYfjqyDGUftygDgLg/975v+b6CrF/55b8MFRnl1XpIMP9vGQ2JIvQTq0YY6jH8f7n3QJNdHmoWpTnHQJNhOjAjxEKpmsxaCr8olMaEdKIkWk0ERtcDXXd8yIgLmQlDAp13Cs2frYdEpgHQ86aR/44B6WjqE8BaYOSTRX8SLUifp3uqw3gvEytfy3XQuJCSu03d4qPDdFWRc+ngnj73phzATCDyQpm2hHnRsjkfD0YFhNXPzIJSeWZiJrwwwFKznPGfCisqhkxA+TRRw/zDz78JAPjnl6/h0/UZvjZ9jr/92U8DAL7zlsBXPDN7yBpkaaRrrQcgTQRkk8lBG1dQP5xoux4D1iP1xfUQVD9L2j4HsIYTs5kWXHJ0jSaYtUyUYQRt+4LBVdVulrKXqB0FybKvmDJy/VkuyU6qNgJIAZYBRPk4aZoL+z4p0+ykJURMsEo8688r2+Ok51dpCgVhbl+JCrLOtZ7Rsj5gwpDZSEegGdzDmhHviyI3VYLbTEyDArTOM8LtA/LpaICQmMoChd8PA9R8JX/irwQDSOy1TDShll5EoOzXY0T0sNyXY3BRhcpodViw6nuJLPYLNedv06i+W78zDyLkWmKC6rGiLvqU+rmbqP0CY4ul4nQ71T5e+kH27Tlqb5myu2rori+OY2Fs/XMREds41O+73P84qMim+DNRBHim1FVrRjwvNJ4YIKLzKs/J6TCQPp6kjPImz5TIDy5Q2hoRb82jGR943sxDROZE1BLZl0ykXgNGl8R1TaqflQ8j1uuD/sncrmn5ApjEWWmcXJJiBI1qjqjnImUu20fSMNvyDobwPqbC3fJ9Nxf+yq/85YI6vabRmmtTINotwIBLGiugkWzwGlo23Y0qpUuUF++zmnMMFxJ0LKlYHCgwPjCXFwPiAlw4PY6AGvGB8tpJ4jdmS8PUBTDzQNdeD7GYl2SXLCsNnpxXulZciqK8qrO7RWKaGFDlUi9ZsahflyTvNii/i+pNEQVyOuEGwDKdO2TUzrG+nW0b8TNPB3KaLv5oMvjyJlCqopCA5YrYxWZ1w/uObDL8l598iG/dfIr/8s2/ho8GEi/7v3/87wAATgPRkdcvyOdmuc4YzgScxBTsgZsmjR6gz0aeu7CdwlhKtGGayGG/Ypxk61kT/d38eYBVDQwM1JIL6JDTSn/OnGFBBpPYAixfGl+8jXpWX38PmjI/FEXu6+L8fHqrW6e5FUT1XcwtMjFPI7E5HX9H3Vf8i8RM1q3be7BW7jsBWBXQ8rINX4AVa3S8OvIU3pSYJWehRlKuzTUqoCXyFyGQTpS0lc9j6dvuKYyEdzz392JLLzdeucl6uxctKarusrVASsdY+c0xfMuKfHNVv8+uLporVOQZLiZSXNqOz5eumSWeTF18e0iVxGdLustAZsI0xdYVwNVJ09zFqFHtCmj5njW36ZLU/FjGPj7cBdOEJRUg5lkw56dl65Z9X1G/uUw45vtUfiCjoaBkwKyw5V4slemjV6QdZFKTQSHJX5vzrpcTkXS3yuSrej48EcrD22LA5B7kfFL/kAtbYc8vwqIK6A7EZKwT/VndoC3T4nwdMV/Hqk4+MrPkuuPk1Uvxz7JpgegeOwOAmOMGZ9IxTpOkRWaehW+XPYdoVxpBWLn3Xn4tZ0PfFfPUZ92/Xq/8+jvykP+vbn8KAPCNq8+3Ty9j2lR/7hZXXwFbvX4lfmbNiuopTrZ738vhPsKmV29//JbDuD3EC/z1TH+yrwas1GC8K6LqzISS1FpMg9W+W35UnXo3Ec2OjauKsCLO90QBVqcIi6VikO/uN/fNPvm1r1PvmKf48DSV2umkHUaL/7O9r//tfYUzt4rPVydlz1dMzUjc7w5t/2jYqC/ShnvvwFDmDAD9vgTUi0pfFCzE7X21n9fvTxgHilQ9THr/EnDSpIaRU12WCrTU9TR12jJ5uvbIAyffZqZoPUZ1xSlC4w7MSDJmJhbomuK0XptU0/WB/k4D0skou6O0e9TAtbWNXPbPSNpBLGkCSmHGCP+oeuD5eyzfc1qdblHfEPe1TLJ+pRGLKU38XST3Xp2yBRBZB3K8RblOqB+IpPrRh2PqkgZyZs5jyVROrAtAucnoYa3HiDhnnJ9HxAv5Aa0HYjjWCRhmAjyU/oYmWus7tpwCxofi5L5OlA9R7lFMp8qCLOWY5RTpHqbA6W/ouOkdM1LMVuUhNEg/DaCUBIZBTGOofLTEhKVAC4aCj4UVCQjVyxYWynRPQCEDKYDEZes0L4VG5q/4WhFJt5ruKNKxK5uBJJrSAq3litmra9quJ5j7o3aXlDoIZPpbniXcfXKNr37zM3x6f40Xhwd893KDcxoxIOG//4yc4m+/S5E6V+8EENAzlkAK2wdFSVnBBOiFjUtWgVIxfw8XP0gxgB0DBkkKLavK95kTelE0gSsj/nY8YHYlVLw/lppwNwZ8gKKLciZAlFIB5moi7AxMfN40RsTLqua+MIifZkI6jdQPryfKw3ZF6UEUyJnJoQJCMfLWTCA6cHJqoB5r1ANr3F/DZaHzXmi1LyZHVaO+GIfrmRmBhevy7q669WwZEHnGw1CzWe8DBN7Dv6pETjnT4WNsVe+3J0QrYhig6XFQg8RGyb7H1iVOoi0pV9JKLE5ay7s3DHSMmO0sg2P9qTaYCQlGqBzkez6LUkeelxDZUTpGZCTaHiJdMw7kGyZpk7w5MAQy+6WEECPyZW7AU1PXTlGTKZsQ8+nA90om9JAzD8fcNilRpF4MwLxQ5OU0It6ekZ6dMDwsWK/Hwv744tslBITzgnw9KDiThXoeA1aeR5eBAsXyFBHmhHQcaL4YI8JlpelijJRNZIzAJZGpfll1obVek7NtWDICCuDLh5IuKBjJoXwYgUAp3xbR1MpuPgKNHW3Wl5LtohI2/z6XHwiT9cv/+c/Rf7xZZOvdtj4oXDxjpSXTpBpNlJ3uk+pjVfE882QpqBqFVfB+JKpGj8JmCVMl+pUrO12vE9SZ3Mop2FL0lWjyXqc2CbE2A0Pe+caZyjplcGkSNHrSM1gwDN5Y6gKgb9bZkmTodL5immWg5oXeTFmv6ebmG9ouHEa8l65gvuZ2uOJndtrcVfuASoFM/OyetTmNfo2d3b/27C0AIF7Tam89tvfozc7yPG2OSCkC+ldlwAyY9tU1g6yAr93iGNveub4IYOvKdvh9hMESn6i96EF3bXm/KhFcLqIU7UPCe471RW29DLBAeUe7VfH+Wb0iE7RLxbJ7jDBZEp5/2Ra2bWQY9uQEBNQ1bN0XAVj+QRS/qs3iAVUHYPm0QLuO2N4/Scxne4KaYp6aa7awWwwIqLa9sgWonlLkvFMnyGJy7KvcW2ff4MVq9YdOX/PJpPf6jRzC76kyPHOfjZW8wN1z+f4hQDaGLsBq94Wqrueh5AIs4zODpoHOmw4j8mnCenOoABaAkvFhIj/peF4xPCw1iyXvuBAXNtJe/MDdfe5qd8Lgl+9T+b7qZPnyZ//n/0d6oKHzgJjdqXJwihnPUouhoNLealkfWjDOcYCKkNJ5aVsylNNxYSFwJ/5K4hgPAOkY9VyX5wNvgzImyOSfpWwWX2O+NpMnAytkZkdUGoBB21L2A3gC530P7woDBhgfMNa7igut2jKnCkpTIEV3ueeBjmlS8MxGPiBx+2WoAyHtYwb1jvMngVVm+5jWlWcXLwk5QpmduBJDFVLGckXMYDoEDA/1qkQCDZYreqGWE7X/cgraFxbOi7oeqD+lkfpHGkobSj9brrhffItMOd/66ieY4orX5xO+fHWLSxowRrr2P/4tAl3jvyQUN92aRKncR8MCZTrjLP5xpU3pOQpTSRpmIZX2VhPnWto4DYVdpBQ31N7StrtRQsz+avCIBIesqdHG8vo1lc+WEAziQ2bfsQh93pUiueA9dtjNsbCZdDI0gyokabQpNmm7fuc0dyqTACeQVZbKMxN6EpOaiJ+Z1kXrIy9EaNt3iBXICvNC7MD9uTH7WcYqhKCMTrbO2OqgncjPSFK7WLbL6W9ly8rkVIGjEEMrtbA1URsGqwFYW6yVHGd/6qWDCfT87X1L3RuAtQEgu/tagCHfMYujshjeZGj7tgVUNtG5BaD+/3YrrJcmC5fACG4TYa2YxZTk1kGEUk19NB3PZaZ3aVlK/9D3e8OUHCKxWAMHaXA0eLrm1aZqO9H+8YH7qUhcpFTugUHg+rysVGVxI2PHwEEe4d4kMbf3HQISn+fy0anynbVWKx3TeU4YzjQnTO9mCua6lHYqidjLMwrzyo74ILMh/zS+ZS0vMyZo2p2UkY4jwkpphpocrd3AOJ5bQhlLf+nvfGGAtYnwfyBMlpRf+js/ZwZ8vqAqifP3nfmjYbW8HbVTvI11d4Ur77KyP9KJ/Enpz+YA9A7qwlrEmQZwmXCBco+rYz/SGFTVXJiS5SiInD6Lo70AlhwZJIYC0jx69/IQPSf8AjwF0PJ1OuyTFrdi3GtbMbUqWLXmX3P99RQwP4tIh4j5ubBcjsGT6mdiD62DubSbpL6xOQvTRABo/vKC5XbCt75KelivzzTAfOf+hq6TIn7jsw9w8+wB+fMD5g8Spls3CciYKQtTGWc7bVsYVHdsh5lRTRnx09Lw6Ce8ktLHHXtXZB2wDbCaitBflTNRikyM5nmnMdZ5/RyLZutoF0Dd8Gkv9yGH9hLUOt2evVD7CmBVP3TaQKLL5G+LpTNq5Tkl/atPn6stNJowGODgtvb+NnSVtpTYn5S4+SkMli9P8b96JH9iNma9wKa+rXQ7lVDnuhY/IVskWbYwW5e5fm50Itp6yY4YCvjy51Ufq1Afu8e2NfIEwsD2gG6u9m3S6+yU4O+D+0e8e+DFQ6oBFtBoiKkS/nkGQiiO69WFeEwVH6+rAy2eDlOtL2cPkSbvjRuueH+tPSa8yDmg3vbOO9QArSzQHmd+vY9nSPl7AVi75QcKsqSUFXn9uZgRa2kH+pIP3mpky3ZJ8e+POIjzXzPZJQIBYc2Q5NMe/IlZUXylSJKCTIclMfD2vUu0WQE32/siE/hYXSqXBqgMQf3N1CQlWm4ScShjuZGFAAyLJvooJvRfJ07XTjZlQQ7O9CMvmwBXBSWcaNPmt+KiDuD2O+dAKcUmaKb6u78ZJqJP2iDg8jIj3A346jc+w9tzbdt7+0Cf7+YDPry+x/3dEcOHZ4xvIy4vBcDKfdTXJxBH7ShmY2nbgeuhrOO5tK1XyO8FQCj9Hut9u2ukbEKW9TupKzE8FRjusViAOoNap1AtMumbDA6PDmAK9AISh3sTE5gakFPJTqTMSWlr8PTYAO5LESiVe7A/8rn3kgVLlKBzzhVn9zx3JinHbmk0WcrsW5QLKPEaXr7+X8ic9QWG8SdEI5bTbzyD2EnvI8eIr1QIrUaWjCeP3Kv+LpIRe47i/vOuIK4DSR05Da2Dgi7zfWBmV8CPlwJRXz7LxDlGzmu2eZOnmh2NfluMVUJ1BQgSqXc2DNZjUcNiWtSF2h4pUaIO42UBIjB9/gBkYLzzjte5Or9EjOchYH5RT37rdfkcl6T5VUs0NwPI84p4XktAnXVOl8s4UCaYohK+3rIM/AD8sGz5gZoLpfzZf/c/Ki8Wryoov5lxOEMBE8osuffEDrgq2+Bz+/UqH2kSV4f5lB296YEHd4xI/kw5hMKgaPh+qct4LrIKAoyAMpGKmUuOER8vOcZOuLNhsKZ35byauufemhigJp8cJZ+eXWWUeoznpM7uasZaUmHonB3cR6NUqw9h8Xjls17VrEaZPOnaYc1YT1FNhqIRJvtIW4gzv0h4pIFetOQAz3oov9fflyoKWBr+KEk2fO0V+V/9zndfAQC++uEb3fd+phN8+p0XmH5/QliB6W3QOgp4G84ojOwiIB4YeCv3ARSwSwCDQNZWzsp4MSZgmMXH0hkUfAShFD5GByrRzFkdiAAqgNUr2Zj3VcPJRaJKPYSJq8CQWyApw3dxq1SgpffnBETDnllznP3OOo+7CcoyWYFzNIbLXJ/Ls0N+xW4nQfZtUed2mUgkRY6PBJM2Uz+v4hvTpNVZ2eRkWazGJOnAaQ/0+AhCD2zex69LAKG9jgdyPoJrKGxLZQJkkNBjsfzcs7dPEN2ow0T/FzAkz8mey5qSU+qzVy6KLA9Rg3DqfR3I6oBjtSi4PisaapXf3xCL6fAyQ2UsOu2r9zmNNGeyiVTSP+kYbRJgh2XtJs2WVET5hth8BThCtMm5OoEmyJlzCQrbTm2+Ssqbq1HbP2SoQ73N7ypj2/R2xnIzIl4S0iFivGUfK1tnIQjYb7fk2u34SzoCQl0tHlkMypgjZslf+rt/ZXf/J5TN1eAfCJP1S3/3rxRKjx9ivKwIcyK/KJ/P7X2obS4ltUr/2OKPVZgKNWk5aQfV5eIIxjxYX5r6vJ4x2pMeaGQWhu1j8kCAa/VO6160dSxibcMlYTjnJk3P4S11TvXncmxXdT5Pn++UNgt6fQ4BwutVBAI5sudAYMgzVqqm7hz3e31B6l98oni7Iyr9sPALy5FtwmZJef2GTIjzBysuX1pxeZWxPKPriMO9z8H4KNtq6/+ELu01qZrcn9H0gYiiTwO0ZsYN0997lc6kF506czE3u34Z6v4Q59ScTwZ2OWfw6tO2bL1XO36aGoUkwqG9Fazsy6KNYemvzNUM402COyX0WBBfLFMBNIDgSQDLl/cBVO9TtpguNYGl+rP5TssTWazdfXosjRef3SqWxQpFRBOwzHF/AfOkjBd71xcG6sgO3gyaJB+hlMBAMl8diyivgCTJrynXkQXAslLf9f0XaJi74may00+MRQIopkQtcuiaMb6b1VoEFLLCSxGlKWC5GXF+OejizLsGCCunOpGXnUHdBe1Y9syWXiodBZXfH4C1W/5AQJYWax5wJSy59n16rEMH+stjYTK2gJZqXl2M2Ubs0BtAqwfWLNAa5oyBO5UInVqgJXICOQLDA/3Z++oBreWK6ipsmSQl3gRae+/IJWM4ZzVZRc+woLRDxVxUJ+kMGLwKFJOhsFhN5KIwazum1Byhqvf2WGV4hEGaS7t7LTUBPBZorVcZwwVYvjTj/OaIV8/I+f33PntB+xigdRwXvLqihzMc2xe6AVrufiS9TxqhvnNedFTv14C0bORFRIC13ncDaHWKBVp2MNH3zIbRh1BWf7vRWFIRNrNXTEH5raorM6mPR0oaxi1tvO/WMdz38616mzqqBo/48FjXBKvy3Svi+LwBsMp+xlHbsVh6rANaysiIicoWG1yQ8vv5UZUDuR6h+e69zpFTzYY9EWBVxfg1ZfFNk//3Lmu+b/zShAGU57kshcXypjbvryfPcg+gCrPl+1Yv+tQzw1LHHhM3xPq83rdJTIsDObmHngaYlJEkEXoAC0DpP/LupPQowFJFeG0jNACrEqkOoQJYvpQAGmhuVqAsnsUt5PxywHjL+RYvK8J53QRYYUksOMoBKTZjxBbAYtNyz/+rF2jzgyx/IOZCKf/ev/M3mo5emQA135kwStIxevuWz2L+E0V52sEMuNZSInkNjTyCTArRgjEYRsaA+MT6U2miiWc9UOobL6KpeRMnYlwaB2pAJSHU/MYT9sLpYyxrdvqETjyeecWQ6TgPWBVQzpnA2EZkGoDGTGop33K+sipphCZBSbSBAlLrytSmUFXdl7FXAJKQIw5c2ZJG2l8Ap5hgi5o+7bMeqY0fvkT1nr5W9IuOx1mqBQD4I68+BwD82m9SdCHetANcfKC9D5/RPU+3ru6c2ihwqqMcJKqzNKIGKgiwl7biXYRhBNBkl49zqkBL9Y4kNruzQ29cMg1YAlxklejNg+povPNaS3/V8Pv62YupWJ6/1WvTyECX8UEHTXNdNRMKHtQ6bwx+yQAoey9AO8mKf9WytvtuHKP+LjLZLStFF65r0XFayEG7Sf1iTGYAimO8fQcFLIj8g0Yg8mdrWkxZIwmrKMJHQFMXnDWJox0A75We2dB8r+PILnvDbI20kWfqVgcQ+Hw26bT+Xxigk0TXDcjj0J8ot575KPpuDqDJteVc1iStE7kxTXLi8iqgw1QjeHCm7Gqnf5s2ycepLMTVxyuU/UYOpgihiOFaqQYv2yASEzc0YFaMlAX5mgKqfJdM9OJwJnAZLgvd5xCQrsp4uYhqvNPCTAyq5psCuKdbaoPTt2lsjvcz1VuAoLB1HDwhJAClvKtvLztz4a5VwY01OQB/6+//h9sHvF/ZfAn+QJms6oZ4YrC5ldSU6Fa5Nj0MUAMV/U6BGH+xudp1f4ABOTKBRKSJ8yJaH+/OOcUHx6de8UUctYdzK+VQ/MoIlMRzfazIHVR+Z9KnOvnWqs/Mqg1zUgHMYHx/4oVfHqNV5oXZnuR83NvFtbMXayVGo/zu1evtZ5/GSNqwx3iGBYiXgHgJuLw74PLugHFcsa4RN8cLro8X/OQHn2Lk2T+ODGDf0fOP98Zp8yoDOeDyqma0egEMs+h5HUr+Ss02MAXkkSIoVyf3sdzUqzBi+ByzulO8M33mMGj6kk/dAxi9lEjRfo6PaspsllC0cjToQ/SwXOBDHii/WRVU8UXMm4ABkDRJhrU1U9o6UsWSTlzdSVCAQG9VbIUiLWOImqWg70O1tRF4xdxlwIayYx2GZIPlei+AZf//1OfcEdPMOeuffKZ9XHt5gCX3vZXr0F7WA1lR6hfhXXsP/hkKSxOC+itVZmH+vQvWfF32wKm73RxjidBjUAYUsCZO7GISrI71Ols9nS9vIvX13/BVtBlZtkohOFzbmiJ5PUVMOmSWBtIcuW5uYmf0w+czDp9Lzs++eX5v7qnmPBMxatk5+g/0s+aENX3w+wiwdssfrLkQZnUrfVW2Gw7X3eLAUfEBks4kvxO9uWu+4HOpk/qx9stq6p+os0RjLlQtqg2glTqgcBRHdtVYou81+s8ArRyB+SZguYpIQ2HJFFg6oDWwI/XgOzAKU6LslRugLNCq0g7lPqABzOpF2727G1+Xd/GP+RGgVZ3DMSR6ip3e/HBPq+DTSCu9xJXcBFrn9ibWa7quBjII2XHavuHlGLAeo/YrPRf3r8tz+v7ykh7m/GInZY34DLrs8u9VmpW9dLydYxQoDtW2OfUT/IUUaHlTRO98PhLvPfyy2pO5+947xk/WvsgE7yLGulXzQEv27UgENDkAHylfzJzYA2H5aW34hCjGpwKsp5TgTaz6XDoim3sAa+8avWfszY2Pnavr29pvq+K83qoZZ9a/2gRYtrDZUuu/BbDke01ovi2PIpp4HmBV1qGEMlaE7bR0Gr3oxvOqiueVGL95qU34Hsga2Zg8hC5AFJZcfUYNwLLbP4zyB2oulPLn/qd/g+3FkaIZJGWHsaGmo5ihYhv2HlDSnQSwGCNYYJR3sSYJlYzgmwnOlyiX8+UB6uyuLJW8YxEqZEqgg/ZLrCSfBqqbmiQncEqccm2rUi+gIGRiQSg3YmG2cixJimXf8SEXBXo+VxoohUtgFXwSWeU66oDBjcEDqgVmEoFWrQq5nUJGeckFb/FLuE4s08DRgJLSppy3ZQLXAwlwClDU6MK5CFNKO1PbFBFaaWugABtrNlSx0hMlel6eJ+QpI5xWhDHh1ctbvDgRen1+oO2v/c7XcDgsWP75cxw/4ed2BBCBy6uEdMzIhwSsAYdPByAB4x2xUgOnrBtNRpXpNiONZNaV55IHApfLie79/Irab7hQMuocoBkDRjEdZjJbS0CDRuyY51YGsiJAKrm9JLCEPpj3oWdeA8pAK22t0Vv0biarxh4C0kGeOzFV8VKij2zezzRFEl4dOTF7CArw47zWqT3UzFkGRNXaGiOnRwkIDwswUlqdPIT+wkxMhWI+ESBh2SP5EzNgCMUkJObCNanIZFj5OcwLnd+IPaoZx04WbnJWAcrEUhU5Ic/efNibsdvveuKkVqTUlhA7Mgq2PYDy/xC6bFrFYHkxTynmNxtd6MVK62oY8VZbZ432jK0vlcggXJkUENY53YMjny8xJTKjyXOX38REqJGfiZ6r2a/pHzmbxQAUhGhUa0r1O+eFUe13kp5H7seCXy9NEULxyTLRhXq8HcePE+m7TZyCZ6oXOlo/ER4Gz7/sfhPWxPIqQJC0UOzLm4/im8tmycgJo0d6z1XCJZV5+PDpg7oqRPF3FGFXQM2FeSSWcz0OZkxJhBkM0KMK2H4o21j2ZROnvP+/+F9931msHw5zoRS9QbVbO/OgK0XzwiR4VNDAG+PzlMeW3anOl/k4x4ipLVyi4jjRsziw07GOvRIwoJNYfS2bJNn+2XOImakoaVMdt6LlllPAcgpYD7GYOL1zvKWIXRh/o4Pl7dq2nYAyIGTeZ82aDsc7vPv79/krrYbUcK7p28JqunNIm+8EmhDAhEYcjnc84Z/E14Uq+ObhiC9fvcNpmPFrv/M1AMDyz5/XdWQW8fA5g5gLs00f0rkWZrTWK+pr84tybBFJZcDmpT9cFJ4I1C5HAvuLyTTgk6M2z4cdQnslHQYCw/4N7zEWOrl2AFbnGPGZtAnLARSQn+1vzKpexB/CTaaPMByVkKn0W5eoOo+xqn+3OFNes1q2ZiTJoyf+iF54dXJs1JYDtjHnKIgQdW9xUPfnekLZEifdAljdshVB5x3O1UyVGnNnw7AISHbnrsyITutq058rxD7AskWekQVYQAuqtH6pBlD+N7uV3x1TFJa1ABxPUOicIHPEE9gT0dvypmh/7iHqQmDX/G3Mkvo1S0lU4sACqreYR/WrlHbhammwRxmbvNXDui0AZZ4b7ldKB7dlqkwEZkVjEYDms9WymPokrufW+Za67lLnHwDA2i1/KEyWlD/3sz/fpvOQlbL4cxjhy0ZNXBypO1Cx6D8JSEPbcQGcP+DQfp4UVpeKRxyZ4wpNAxJXVFF6amoUZXeZWNmRXTWUzhnih5QjICl0RO0dAC6vQnWMmBV95N1yCji8JUHM6Zb2me4yRqOjJfpLXvxVSmUKFDZr60m7SUnS6aiI6FCehbITAcos2rrrKZ8yr+RyHL3I9H9pM21zBqoXxkviQ5V+jCIHD6cFOQPPr8/46PoW/+w3vo4Qud1+mx7U4XXNrsk5zl8Sh+0ApIB8WjG+HrG8WDG+GRAScPg88DkERNI5BPSpuC2DqvGBgiZOnyd+lgnrMWC8M4zQhpJ/GcSz7pemaNq8gNeiP9U6ndftbBgjQAfdNEXup6GAHB1wPSh3517JMT9eiLEazisxW5e1zbPm7k2rZUwGibX1dDJnAeNgtcEA+IgwG7xBX7CvlqiLSxmHEo0k4MdLKDyc6++tGrewKJYhAlqW6hHnd6AAE92nib6UGT32P0t9e+zWY9GGvZyFsWa4uumI5Hug6GZpvkJzrDBhAg6zYZ86xzbFRtAej9RG41i2wLapT+cZB4xzLil4Ns1WLs2OKso74C5pdyxT5v3GPCD3jvJ6gwU4aXorkcpg9fZiMhRTKV/DmB3z6VCdw6fKasC10zy0QKbKPxgj0mHAehzUOiQ5Z8XiIoKlwwOz7EZ1Pt7PFLwzr8jTgDwMSKfR6PLxue5mPrY2FVufrSD9SBgsnZOKS8Qv/urP4wdUfriYLCm/+Ks/32eclLnIlbOa3xb/HUbLvVNZeYBOKK2YZ9aJkLhPiVKdS5D6AHVspnPx5j2gqGXCtP4ojMfDRwTw5psaSPb8f2Sf+TpgPYYS2Sj+ZWrOq1muXtn0XwusKRMD5xnsM4r1yfqf5ZlqlGTe2L9XDVkVWb2ySAB2uSqgRkBOumv9ZT65I02snALvGxQkxRlqBp7eMnD6bBsNLi+ow1xeZZXpKE75LTj2Omu2WIX4xwAW3cD2ubq+EuKMLlS/rGgfK2YXK1obL6uqMcfziiCgvuNHJ/6BNi+mOM5KwlcySbA5QJ1Yd+hLW+zEaCdFawK0k7ZGtXXu3yp3j0P5S0l9ampzz9P8PcIQickSAcrvpQjTs7vLE55trwgIs2Dsqaryic2CBuQ0bNVT6hVDCwbXtf+dLxvO6jlnivh0ALZhwmzpPFs1zy0GpFuAZbe9YgGXZdfULSN056rqFKrzZOo8GBZL2FdxqvfsqilqWZGsDM4/d9NPunMuAVg2+Gfz2FgYq9zx81xuRlSZXbYsXWLhcpYxX36AAGu3/KGCLCmEiPu/2dQ7us0t0CoH0EbSzgAWXMg+faDlJQTETLgegtFyYgDjGK8SobgDYJi9ktJMoNw3br9B/zl/RJ97QGt+TgmrLy/712uAllfGtS9uaFkJ2gfVMRrWL1EqG0BrzwTkxTnVBLgFtHpYwQCt8cGorTv2SD4PE13k+uTyegE4/QuiluKKijWTIkBrfMOr2Gs61/o1FwIKsISESc3kijy/A+ufXX3CocyfthOF7xvN7wJCxL9JNWXcitQnYu3Vy6341C/SRzaKX8S543gs9RKtGwm+eOjvG+/oWQjQ6hVl33zeQqm3E4/cXTywmOMmO+JYibxnvvNmQimeNXkC+OqxWFXx6Xi6J+mzWJvlKfttsV1bpsJmPzZt7UWJboEtGaMUsKx1+3Qc3zXd0RbAcqBH9++lSZKy9fw8+NlyPtfzmDp5Rmt1AMv3Ka1wBmJEuCx9gGU/C+PmIxatDAszUBXAsre4EYjmTaBpJJ+pdIgVwNotwpI71jwfRqTTiHQcCGBVF7KLy5ZV07FicWPF0yx1P9Dyh2outOXP/6m/ViZ6u+I2ZorVRD3kSMDMOkXb1bt1KqeQ1QLQ5HvZT4CI7RzCKK2HAGRyzLbsE4lP0u/jOWM5Bgxzrkx/cg7VCZqpDpHZKzHPyXUvz8nX6v5rGWkih+nDa6rb4TM+qQItVI7xIlx6+pTNVXMu9y2MoEySZgLPIbRpXLwz7BCABOSRzIDrcSATlTHfSsoin8uwAhza9uU52MTRYu7Sff27ar6zwQYCKC8vZAukA5lS8wCsLxdML8748MUdLsuAzz4mm+Lxdw6ICzC95fOa88vgsx6LbMN6zFg+YmdTFi6d/tUR6wl49psB6xG4/pgEScf7rM81D8xqBdbSEpcnNu2qYOxMpsI4p+IwPgQMc0IaYvU9IgGshrGyDq9GeLD4G0bEeUUaI5nvxoh4WZCnQSOP8hQJlOVcmw0EXPcSODuH6CwmuVgc08NloXOsWfuxDuJiWhFTC1CtdBEC1YkdWUWcMFg9oyWVScD6mvgJzUZliXkhZ2K8QiC/kGFAPo0lPdG8kmZWT38ppTqqzabJYSZH9a+WBUi5dkRfV+OzlXeBTF7XbROg0bXac4TX/W3xZkf5Ws1qsV8vC/C8qRCozYVyb6z1VYEooAQS5FyOk/HdOMhrtOEQC+Bd1/K9bFeKwNPr2PqrT9zUAm9hRWxwgOQ1FJOygEh/nP+/HJtzCY7wJknpo15LzIEmrKkCfmF1fd2wuN5BX82EY0Q6Fif1Qdhkfg+zcwmomGQTOJJDIM2tGDA/n5DGoAE9Mu5Nt0VY+/h5wuEtX+siJweGu5nm8IHm/PVE7JX4Yg0PK4aHpTje2/cdZiyyba+YgLa/8A//Jv4Ayiay/KFgsqT4CChFo+zcZs1qni2RqD/vmG6dyekH+ntUlTqjQEtldOpzCbu1qPBofVJb3+b0ygqhdtiWyMGZAcNLOsFyTT5eaSSAJWU90N9yHbBcB8z8V11rKJ2OJnv3u76YgeQYLKs1lN+o3vXncj81o2cjJLvF0sC+PJHVkv5SQErG5QX9JsKu60tq2PkNMVaHsQYIKq9hrilRkquLsh7OAVjo7+b5g37/7DcD/871EqbtwtoxqktW/45QA6zuVoGx60jmPaiSofYm5jFqtC7dc72STAcedI8DRQs5hqicKCtwaoqPEPQO7hcT5cf1DzNNgnsmlkrh2vleVYBqT/pFTC8yydnimRZh/li00Zszcu8cXjZAJncBWp55se1nAZaUlPumMWDHkT1Wv+9pbG0mh94CWL5usq8/jwD5HiunpjBuzx7Asp/XtQBV6zjvi2e5gJbpEmd7o6nUPQc/N75YvXUs76MSINap/KlbKWJClD8ThCEliPL8Y/ISUg9hj449kclcXAcS+gDLXKPkBuUFsvhIDwFpoMXmeiwkQ3VrY6zG/jL3SLvyqeeEOKeWCbdMoG/nXvmienvfx/KHXwMuv/Df/HUAwjqZPycgBpTJCskBK8llZ/xZ4lpW401Uncwl4iNk0vrotRSsheqYwsDQZwE7u2lkBJwp4KupY1GAH+5l0g7V9wrE7vmvzPNNWQ+h9lPTyLGNurnBOE9R8yI2mllyDaPXRRGd9X02ANO1nT1Pjuznxv5jLaDirX/GImPBz0GYPTH5xtv6gXz83RcIh4TDtyfkQdid+lpqGnbj0fKMbuiDb7yma/3eUYMbeiVkqk9crBwIbadb1zgKwGpWUYMXLhRJKA6gtmhiczWv1X1YmNr5BVVW5VFOdSh3YufydBwK4HbFD7CbW5VjcI7t3tdqL8VNqu+rKfKuaiRUf7/MrKeyCYA6LxdzqnN0dymJvBJ9L12HAKucMwEre4+ATv4NwOgVa9L7fuYi/CLn8lF+3tzone23AIj4Wa3r9j6uZAfCgu9/W2Up0X+PXSt7oOKfi5dPkCLgTf56kX9bflU9gLWm1vHdlpQq8e7GLP0IeCvCyJzzdAeghJQqwNVsfRcQAOZcSsoOxjyo1+BrD0HHHvv9cM9WgzXD6nM18zin29E/ed9RcMUfZvmhAVkAN4il58WsxCv0OCc1e4XMYIs7Qsj8/YISSr6imAkBncibqCjHOEWTnkc0uIj9Ii0r+o7BW6YJXusDqFJ8XCzzxr8xWEmDMCYFaMWFANX4QEBreAgYzoFAVgDimSfsh4zhIePwOuP69zPGBzr/eJuxMIs1XxnHQwO0RIeKrmnaJlDd1uNAHZ5fRAVYQiacBuQYMN/Q9vJiwHokXRTJVSh6YyWPYbmemOVIT6XObah+Y9wmpPkF0otas+pGhYV+04jQY0CcgcvLoCbUeA4V0AqHhLf3RwwsOiqgTDSu0kh1u7wiaYaHjzKWq6xAKx0z4hzw4utvsaaId99+pk7vlqFaJzrXcCkJUwVQHV+zifGWUt+Md9SfBUjp9kxZ6eMDOdYOd0vxwVoS4rxiuLsgnhf1j9LtpQZakhdxZh8H8XVYnk36eT1GLDdTAV92MOz56imb6Vb3HmD5yEZ+p7tgyDoB20S3LkpM2SuNHvbf16v+ZkAeI+nwDLEk3RXfFQFgh5rF8hFh6vxesQ21+Q8ATfTnM33mFCiPAiy/2DERiHldt3Ma9pil74ePVoh1ZKDVzfLO9z4YwDjAV+ZQ+WxNPz3GwYGIEAKb7QyYMfXwjFdeGfAqGyX9c9VjM0eF5oUZxR6zKObHsJFBQMCVyCwAFDwhPmnBvBdiKuS/ohGXiolSGGPblsKy2T9jvqvMkLxwsYstC7CUmAgB6/WBWFohklKi9zMbySQx0+0BLJ5XMrvwTBwVf3iXcHiXML0rjBSN4dzux6GSYKHfMob7Ref6HOiaIkaq9xsCqlyG1rc7/YGZCR8tP1QgCwB+4R9xwwi7ozZX2jR50QyrJd+HBGXBgJZRyRGoEmEKA+Pfney+D/X3RRqiw9rIIUmAnq9Dn1man9P3wlINDwQglM1q/a1x/e1EAGzmdnH34SM8fLBAk7R6I5WLioUGNOYgvZZJkg0UBqrR0cr1/nq8A1q96+h3wTx/W0+Z85kJTGwyvL8l+58HWkXbqj3X5VXCeiwit74I0Dp+zoDqrmasPNCa3j4SVbZDNEQ2uTWqzTIJPSLXkDiBs/ogeg0aFBC2ThFpiK0GjfQRZ3LcKsGBoao8psLsVuweYOk1HAjqlhgVPNmSrxhoqRI3b49GfBUoYeCSP8/niAuBAJT1vfLXsgDrCWaMLf0rNQHusVJilnvMQX0DYO062teVfNp+QA2w3rfE2ADQ+vdQnXtTPd8ALFsnKY/VTf2x9oqXdignrz5WAMuWyALc04huInGgBqchGAZWxoD+gKXJl80YkmOA15Kq6/nIM5Z5UvClAVgAcHgtC8BEC0nf5oZoCEsNPou7jwzqbruhh6k44oegbOeD+EMsv/Df/g38+T/116rvQs7FRYpZJNWtSjzxr9m8iLIV5V3UrIlRjw8LyNxltVvkHeQEz8k4L1N9aBuXTI7f8nnOjfJ1qP8pRW9IgElmMEWfxa9ItZaYBVKGhi1HcQWOrxNCIhkHyoEIXJ5FBVTDQ82mibirskZc13WgFYKAHV0wWm0m8fcQphEFNIo6Oe0rx6Lsn2jiCjkj58IM2joAJv3PktsoR9OU5+claagAofOHGcM5YH5WghVyCggxY10i8GZCONA+aaJzxZmSSoeF2/6a/h8ytzP3k7dvWFZ+ohN/+KsTrj9ecXkWcXhDFRnvS1tNb9fK7JYDEJaM8W7FeqTnI7m/NGWE9oeOv4W0kR/32Bym/XNekY8jif/ljBxGqocOWnSOPEUyqcOA7DEwW5zJbBxJ0d1qXJHjOU9sQwDsMxZn98Ad1ppMLKNRffYsTG1mCSsnPGen+UbvS87FUgvinJuHoQzEIQAYqG0Oxjl9qKOx1qtJ9bjCbFbw6oC8EqNiBClzSuz3A2KtYuhP9MLeCEPV88eiE5bvnFN7t3iwJI7d3vndJ5ju+X1ZZ3f5LrSq7JXUQ8VoGQZQ2KwYiZUzQQG6jxTr9O76Q5X/URgtoDi7xwjMM7V5dU920Dd9cUtXzAJ1VXKXfu4pHMc6Gj0moCx24Fkp2X8ciripPZ8XHjVtVIGNwNkHbBtKXYVJk6pyXTT6d0nANBCJ0Yt+7GWI6Ny3WDvWY7EcHN84cPWwIi6pmAPNKZMFWCbyXILeQiY2Pp6pncJlpXFKHfQDiROzLlZY0g+FidCWHzomS4pvKKtQW4ktygSrjFa9cm4kAuSjG6ysxEGOQc1f9TFQs6A1MVq9Lrpm/Vk6356iPf2H97+QaWy8q1O2aF1H/psKG+PV4QWYpTGwhhQzDxKhaYESADHhWSftkM1K3qZzGQhMxrkEI2zem/Gv88DAO4QrI7jBKNprWHbOM422pC9fEMaEMCb4ROMAsDzLfD4+10gRhPkq1eeWOnxyAN5OCOcBX/4vpqIOz6u24xt6EMM5K2s13C36Z2nzcn/18ycz9P7gpsUwsnVkYSy6N6C2Hh7E5Oja3d6nKT1Gs8o9aAVK9Tyh/M7AESnpZzqJvXDeBlhA7aPiWOzNIvkC1ccmV6LGJHrI0YoxUm60aaC0T1dCb5prjGUfyQGHHlNg2KsuwPK6THCTOlD8lnxhc6CYDOngpw3fXWBmzX32PB50WOHPPX8oGU+MibAqe3IIPV8mu4v4y4VYPZfgWI1smc+ef9VWu2pVeu0U2r8tkGjfxRgJtG+xXluO9FvK78JoDUNfhoS13CTptL2GivK6wJGojDd/b96X5t7M/ekc6caH8T5jvM8Y7hOG+4QwpypFFgB1e/BFxyIXGSgR7EWmhesr7eGyQfywASzghxhkAcAv/tfEZjUmIzUlCpDqrwYldD0uuQsCyDcqMIvFrInv47GYk3qlsEqOCnZAy0aU9Yqwc7Ezdo935K81vcvEqDhAJSGzw5xJ9V0jFAVAMDtzqjtuE/6vjFD9IliglQM2TVpkQweGh9RhGsx/18KA+f22JtCS4oc2DQDmj5cPyJ9ufsEg6dKj2rH5HOzFvIlXPh8+oXOKM7tIMTz/LUJcz36LbL3aP90tHT+l/cY7Nv9t9E11yu6Z5Cp2ZudWJAKT1ZbHWwZ+DLhGUWH2+lp8zYWd4+fn9UuQxkC5K73De3VxZuZi7DuvP2aGkN8lR9uWg6+5XnUP0m9dwttqH4mqAigk3Rd1KQgId+dtE5A8Qwe+dOLeiAL7QqazjfKY+GiTh7Ddof5spDSetL8etzOtPPbMnY9WBbCAAoq8T9ujfWmjnbfa3wp79o7JedNJXccwqZNP+KymLt5qonFjZrTX9vUQlot9uLpBGOI3uAGwSu5AfrccwGpM8Ap+2G+TFy3L1YD12IqOWl1LAVY9gCXMd30Nmad4QScAXsaQWL/PMvYLXvhhKz80Oll75c/96b/OiYhLZ8ocCmp1fHKkQT2NgUwggcwjoquVI/9/MMwVm2jSRNvlFDWBsThDp6GE54+qyo3NiVp8exRg5fKdROTFBdqqMllfnoXqnAL4Tp9nXG4oBYscf35BzoXzTcBwpmuND1mBjuhOrVOgFC7HQOwTt8t4n5AHSnlAZqDEeld0X2qiG2OjWm5BVhItqBgU1FVg1facLltiGUQ61gJWmfzFH2w9kOPmfDMgpIz7DyPiDNx+g84zvyBx0uWKNcier0BkcDolhE8PlDT6Utp6eAhII+mSpVMCpoTxkxJ9OL0t/W56R9vnv5UUfIuY6PR2VsdzAKT5AjPgzKthLXkgmaKCgDRGMosNAfFMZrk4l2iiPJC5Lo2kdSVmuzQNlLxYkhgPhcmpogE1AiggHQdK6mykOWQQlMTflXhuKIOa6q1dUpGYuJROYYUMdXDn/GndtCVsKqiSRXOdSH+NJxWbrFdMUaYty4GZTDdRWKtiarKTjY+Asuk8hrtWuDa+fUA4m4S2cjl2asf5zJevmarsGSyOQPRFTXIsk1DlDZTjrcO3PXYr+s8wNXvaWr3zhHEsgMA7sG+Uypery7zGGnBaUJUSwjA07Ue5JNcyGY+U3DlcXyEvi5oMM5tpqb65vT/7WX2zQqPJpQ7r8n8XiVrdm2WgDHOUjyPCeaE+K3ILohUm/VfaQnTaYixuA6IDNy+oIhcrli5Bk11rpF5Us2VISUG/+h4OgwaeqDbWYdRzNnpZoPddZF7SaSR9wuOAy0v23zzw3MJjtwSeDfcLkAlcVQyUPA6dg8uiP4+ciYKtRshF0DgsqV3MsTLADwHA2lzh/FAzWVKkARsknFFJPDTpdqTjeFbJMsgB8CYxYUniQv44W4marfnJmlviSn+qGD+18gdpJJHL9QQsVwHLVfuMprtcnAglP6GapfjzrUycXA++jgCVQbYMDgVcivlwuZaVSazOU8yijwyqytTl5ns1/e30Mhsl2Kj3uyJ1VpOUk9GQoqY/BYW8/8yDzywIEggLkEYDnAFA9lsDDp/FTaf3uABXH88IS8L0tpVWGB4WDHeXkjLGFsPGhiXrAkL7oET6TRFpGjTLvTqc2+TIMAOVW9XqitQ9n+KbQeZ3C5Loe3mwBKS76THEZJD7pkWAn1VKZGrzfcn4Itqt/uwAqXeEf5TR0vfdreJlt5wpmiol8j3rOdEm+otv+3opeeFJsAOw9LMVRN1gXArjJffsmJsNf6gQwzbAMp93RUnNuZoi9Y1xG2Bx1NyjzvKe4fKslTte28SzVrLouL2l7bKU51CdoN8Wm6VntgxhX1ZBSspVVGyQrAhyrLyXGw7c2bMz+rsDc55hEgDIZsLs2/gwFVYLaCJ7s+T5Y/Bm5Q+kfnmMpMTOi8bkAmbiTDlz7SKbTs6bAFWZ3ytlwSdfuB06AAv44WWwpPxIgCwA+Ft/768CKJO/FulzmlMt1+YoN4B73S1lShSkmIdsihUM7ZUi7WCBR73PegyqpwWgFQ1lrSlx0Nd0MZKi5JKQpqBASxNDc+RaAUgygded3iaPBgpomW/oguvVQH+SimeSFRHXj00r3cmIr7sVdYgIbJnpcgiNudWWKkWSE4LVfQ4ZD1+mSEC7n9btYcDw2aiAabwVIM3bC22HWwFYtJ/kSFQNM0ndMwuQl3twld5IU1EYrAKigNI/5fMqavqH0hnTwQABGXOD+dxr30Th4CH3TeZxXhHnlVinSwsARMCWmKzyHUDPRZi3YPXo/GAY2T/M+5+oeaAPEEslHJjy0UkyQTlzQ4kQ5PPKYkuEUcXc4syxduUcUkJ8uABDLCyWpkJJ5Bd0PnfNpSGE4qPUY3WMOGbXqbzKHdg5/1OERrei/za+VzDmAE8jMOoBsaqVO38l61NU7T/QH4MEdWCXz1umOs/uLUvlC6dt7jWs6pss/98ChhZwbZjCGzbL9lObk9D3W9N/qt/l3Za28kK41kVgWdv3SeYwFhVeXl31b00Wfd5v0JgEsyjcW6f7kRluBmLNXMrRg3GhP9v24jqRxkigy+Olgxn3zHHWZ1jb0Lw3f+vv/4fde/xhKj8S5kJb/r3/2d9EmoZWKDGj9ueRDicmw1DEFdMYFEiIdpbqXSVmsuTZDmTOo/QmZH6TlDV0fKE2NUpuKTS46GFlVsINK+UijHPG5WXA8EDgajijyE9wtOPpM4oWm24T8mj8vhI0Qm89RMQ5Y7miyTBN5OgeMskO5AFq2rQOz8uVmFuhpj7x7YoraTilQ8DwwObXJRfgklEi4vTFNCuYVLdHo0smUYnyuBwLp/pdgeouJtLlRDuODwnzTcS7b0YMD8DbbzHInOT68oKimAYBjO9ou15lksa4CJPCl+Vxfn6WEC8Bx8/LM5Ry/JxAxbPfWXH8XBIcW1MZ+yAs9juOJJsGYkbY9J0de6X5L49kChXWUU1yc2L2LbFGXOnvIecK3AQzEMlnzXbPZkcpidPHpGlAyJnESEPAehIgSANqmgJrlXF7BWbiMrPMicBk0a5ivTsGGtYRn05s2B0XRUXtlrBroolBfUQwBAJRNj8bCsCK54XNL6Jtxk75gdJ5pMNYojtRzIWq7fVw4YmT6yjCog9nmrQ9gOVIZZ+b0OtF6b5SZD8xd0mxbSMM4DC08g4WNPRMhTaqbiMBdOgAnSo1jZzL/1+OsSZB9T8q9QrGBOfvCTlXfm2N6dBcq6o3g7TggHo1v1mz7dgBc2r6GyoH9MqRXMx7NgXOyJGmkhZKrmHP2Qtw4O9F60nNhRNFwKbTiHh3QT6MtDDg3IX6Hk8DmRUPI5AS0mlCWBMuH5ww3i24vDzg9J17pGnAcEurwyKqK8Au6jsA8U8Uc6VZCNr3MB0i5ucDJFApzpkXJHxrK7Hz62nAcL8gHQZizo0pN7AvmQher4dY5u9IqcVyCBjul8ZNAYHGFiFefkjKxqrgR4jJkvK3/t5fBeUuKyAHQGcFz1+LydAN4CIR4B3Svf+RMBqRAZCY3/TBGz2PigETNklM/yvJMygTo87o9FlSuCgbtUj9GSh5WR6ZDC7kZC6yAQLEVGdKxFjdHCCsVkj0f28OWq4jllPEegpYT22kpfh+CUPinfHFh2qzBHSZFT2+I1Yq5e03RsxXzAqe2t8VPC0opkFTTt+Jqj/WK6fvRoz3obmn42dU35f/Yu6aNnsgv/pdtGk2ImzkmQ1eB0t34PNsNdvG9xqdyee1AAuAJmkWHS7vqyTvyviuPq7ImBRQVVUnmokT2J1o6LObILcirbaKj3Q0AAtAa7KVBQJPJk0Qhuwvk76/v0vrt1X9LgzLlvCogBx/3sZ3qn/f3fQ19rxfoAQLnHrFgr+t62+ZRAcWNvUAS8pl7ouBAoWdkjr0yt59WzHPbuVCN3IvT2OVt7AxeY0spsn5Lrtli6EFiu+gsLECbCSt02Gk90h+9+zWYWRzHpkELx/QgHh5ydkddhLD16KuAjDLOyGi1LYos55pblFG3wAsAFhPLFItUb3u2Vk/LAAVwALQsNKlnkCe4g8bwNotP3IgCwB++W//BwDYXMEOsxSN5UxZ7E+hqvGNkCkzPmLik/fPv4fZfSf/Z8rYmzBV/kEkJ/y7H+o/rwNV6lMPCk2qgi3gJPfl/UNc+wzOfCj3sU6hycMo9ROV+93iXSGS5NYrCsLV7+wXVOpZ/74eI6mSn/qLBW3/jd4c54A4B01TVP9mgHRnzgxrW5/mvh6TFOjV6WEpDu0dc0Sck5qJHys9E23umUkAfh8Mg+TPNa/qrzXet/ZxFRREiVgEUD0/ZTUcw9fWZWfCs9vmuP12seY/AVjA9oJLjxPm0OdL05PJRJH6AMu0tzrD2/NbWYEeIEgbau57kWbNRTom30f8KvW4LROiRIBtRS9ufs+m8HFsGCYA9Pznhf467YUYivnvPYsqvfdyG8ahnLfnhzXEWgrBl3EoJjVfeucz5xWphU2R0b17EpbQC3ICasob5oSB37vxvrC2jQyFPS8nZ6Zgl9Z/mHYyc5ElVf3YDlQBaukQyc3BzHNWqkZcUKqsKykXtx2ZY5ekx8n8/6NSfuTMhb78mT/zf1YxUDuQV8mmnc26qFWTCVHMUJrockSl12RVy4WZ6iaYDuLkTh+V9ZLzsClyYVO5qLsLo6KJhdlJfXrH7NRSgKBEcezVofm/NIWzcxcNsUzpV7jN5mccnnsk0yilqilslU7+qYDLisUz1w2pZQdtcmNbhDqWSE/NZcjlckMSF+cPA+IZePgyMD8vDto5APmYya9KVlZCQhyA03eJ/RrvoDkHrYp9XAvQkmeRppKT8vg58PJf0sOa3kgSRVTqySVnnwEYKRXtGVkIDpTKYr3mFacEHkhXFR+nTO0y8IAZvZq7Y4l0gHNMoQ8rJ92yVFbIZiWrTvWH0o7K3OaMZMyNReOM3jN1MpfrmbQ36nhuQZJEG25NTD32wToFs+ioRBLqYcJiXdjcZ6IJxSSDnLFeHzSoYHorkYOJWL2cyfdF2kwjJBOBKIlQW9vnn83kXo2xjwCebAHYlkO/fjYmvp4JzYGmTebLHScmRwFGjYnTmhyF+eowYGGICIcD8rqSCdKaFkOkyEBhLEzdAqfOyWvaZrD4HFWJAWGatL4hBOTZgLcQtM5eY0ujVzlQQQFWCJXvk31PqvP6nJymVIK4Uux4YICP9b/KoUT86vn9wjkEpKsRg8tpmj2DpX1YVpS8n0QNOr8viuyzaIq+X64GdSMYjHq7jAPqhjMEDOciWDzeLwgzf7b92LiKpIECaeKcdDwc71YSQI4Bv/yf/xx+iMvmSuBHksnyhfIUZmw5ZOtArRNvKsctGeNDopBTdRSX4wjwbKXnkWLFNGU/mpxl4uMXSNwH7nm/pexvfxcWSZgbC/6SAXHdxNnZ1FMZt7q+jaZJJoZCtJNERFMkIHKge2kYnQg1k3bbJjvw5UvPmVfpZG6DY72PiLDefUOAoiyL+PhzYQOBNsn29Jb3M+ZYoIi+jhzNqUEDPHYdP5fr1zR29Ka9rVV9zy8NxcnaskL2fsS/oSle98aVOKf+itREMTUDMQDkrECuuTe5lQ7DBaD19/Cn9o69euDOe2t/70V+2Y8aEemYNJ9eiCeW9aaf3XszIbWUTTMZ912bHLrzO+3UYZx2E0ZvsznBAg7Prjw1f6EvYrbZiGrUsrpn7n5PHHVZgU+gmFKb63L/tD5g9vLCqm3clwVYVRlHlqTotKOwS+b6WizA6iQm7vkSagaBw0iMl3vPNAJQ/KC8KZABlgbLeN1CZ0pTgJU6ixigfY8cwFpN1GCeIhp3BAOwqiLPlJ3ZLcCi+6S2Ge8XlmVwbW8AVg5F3DQdItZTxHi3qvzSj3L5kWeypPyv/hf/p2q1DZOepEHkOZOjIf++HokmTQfyw0ms+6GMCutHpZFZD6M5JJ/VbBkIBJDJEJCULWmiiV5Ax3JFzuTridgKm5YHgDraazScCIxaMGgAYG8Q7rFLFB3InzNfL7PPmURlBorySMeAy03U+xsunJhb/LwCHU90b+0QDaDSPrIvS6VwbxhIBVZXkZzdc0kTBADLdWH/lisgHai+KuGQ+TaFQQvA9JbEZg+f037DuTzH9cCfJ4rUXE4Bx9dZmSsAmJ/Rczx+Rmldnv82ab9oyojzqilY7ABeTdQJjZCmmho4JUS6pptIU8TwsGA9jRgeFtKzul+QpwHxYYYIe9IgvNaTAkslUEqdCVhImiDMqaSekK3tGwn0WbYyiEsaDEnSKt/J4zPaXL2iq+FVzMSO5dJJwTEU0paiiSVJeYXxkq36dbDDsExaoi6fWsCkPi/MXl1eHiBJ00+/f6crfZuvLdyfqa6XuTw/y5BYR20BD6KF1QOc3uHcO6hnFyDwFAZLWCUpG4CucajnYysmbMu3yIJAW++eE713hLf3IWZEy2JtfKdsmjCk1mm+F2wQBwRhpGBA1+HAzORS3+M4lDQ+0YrrRu1j6jc1DAgpIR1HYmWmSAEVhxHhfka+mhDuZ6TrCfG86H4YY2GNl4R8HBAfFgo4Oa+6AEuHoYyNySSJNv7FXr+KfreWhdz4bWGl9FhhTbrAAGi8XZ5NGB5WLNcDxvsV64HBzciptA70vs/PRuSBxmbSWAwY75IGv5DJMQAJyJKWi9l4MVvSPTJTNQQMc6L8qIBqbl2e0bt883viJ5rwy//Zj4R58H/YTBYA/PJ/9h/Ufkicyw05F82nLOCggLGQWTxtTogsCqpbThsj4ppRmafycmdjlilJgcH6T7SPJiI+kIO7OLlbhkts1tY2vU6sRs8MlpjPrL9U8ZPK5W+n+JBYYbUkkk0FOi8J8ZxxUHmIoPdrP/f0k+KaqzyEADQXno+CA6C+YsWcKQdJO9XX1Ouwg3ucud3ccT6noeZ6lHH2Un8vZbigK9mhjFJwdakGRkHLzonbmCcqXw5hVe9mxPOC8R1VShgu1bNSlsiZDSRUXL4Xc+LZRT46swNFAppnlMxWJqalo9wPAlfFLLgDsKRYBsvuXpn9rAlBOmGst57R8ulA5L3eCixwjII4B9vFiMo+eEbDAIUtFkaZKCs2au+r5/e09XmTvdtyPNxiAzttsZNG59Hi0/C8T132SkqN6ZDkL3INsHavK8BJ5CAmhMOBAJYt41jYq4b5C+XPFFU6P4ouFQMZBi0WYNn9NO2LsFWifyfs0WlEOgxV2idA3rFcjZtNPaUklAUSQASD/VMQJ9cckE4DlmdUV9FKtACL9qcTWoBFbVHmAgVYMRQwaCLvQ8rsAB/1fElyEo4R6xX9XZ5FBVhA8cP9EQFYu+V/MCALAO6/VL9MIpqmImd2m9pJG+AOwgyLHXwlNQ+xOBsVYEYIMBO6MLmiMeTYnDzwhBTq/VqAYe5rDJiviWlaT51HuOVwL/cyl5cAgKq2qzYTt5P4XqlDowAy2Wp7Mtjz4xWD2l40nFDETc5sqZMODHU7LBxNmFiuQfWyXPv5yMDGhMpF/N/iDJw+baMkx3vg5vcyxo4WZbys/fWLj6CRAVkmeWd2kKg+jfLjbXDmurDmVgYBIMDE6uoeYMTLgnhZGl8RVX0WECefN0B6AaziY1UvLPx+XX9BYZC3zPpbUVhqitrYLjUA1bpsmP3yFJGO///23j3YluWsD/t9PbPW2o9zzj336nJBIDmSeBoDhhgDVYkTP2Jxb+zCpMpJJXYqVJKqBDvEDhJIIiYOhYuYl4FKQezKw4lTjuO4nMQhtiWBY2MnjoXBtiRDkEEGI7BkrnTvPa+991prZrrzR/f39dff9Ky9j6R9H+f0r2rX2msePT2zZrp/8z1+XyclhYp9ppAnRg1WzvaGBLH76xIX4ieV8VezxB+CIvtlO+n+q8VUAbisHI+0WSNXS4TLSIjMdmNCZV1tQk4X2l2yslkJh5VRKF718a/vYcHZe3Y+oIFlP8qyTvm5TuSEiVMiWNNp+jwp+6CFhKfjfpbIJJUaavdtmBeQB1DEgtEUZsKp9qXWp3gqPvZwI1urgTxH+i7KKgyn8XoxwWJ0Fx66CkRsJP75dfRCjCdM0uIx97eiIPH2dfG6XHxG/Dx7Jh5j+7rYFlfQsMd8reKRcRda/MZv+kE88UsDdk92OPm1AcONDps7A4bTHquzUW68adOh200Yj7tCJyd0pcq1fqPXTJ4zILQoo19FV+C4iYx9OIlkwvcAa0wByDFNikh1F5qA5f5oywpNsa1+Fy1sq7P42V9EbSu3C9AyFzFgMx0vvV2w1hYA6S8QiZOQqzHIQ7d9MgXDJjdcNwDTKvbBd4R+l3RN9jEWyO3jG060AlKh+yTXr88Pe5fK+gAx/osfsP3NXGplOCVcfGbA6j5h98yE1R2H8UaA2xLCKsANPEAAm5cI01HcFogxVxLLNkFeL7pdQJcIlBtDYV3MSvQQRf7jFyb053EQ6LYpqDpNKJpgyIBpLD2FKKmUpBkLZWgJfnUONE25FAbr9KRsm+imTeU3bBzG5HNJj77LrnQb3yHWJD3QOgkMLzKY2Lgiooqh1KdSg7+28PK2hctUW500cam9sU+KWFqXIW/TZd0xdssUUDFowZFMhFxOiAYPt5/y9Rk9aD9EC8swSh8KWYYpWqYClzdhF5XOaFOuNJ3lZ4lNkQFY08cqMgxTm4okBV9RXFcB47m0j7kfizI4qb3OqLvPJCXysavf1fGztpUrytfkYHqf1+t+6XsphEieyJUllUIQ6xVpeQVroZLfIt+jugSVfMp9PYkLMWzWoP0Af+sEtB0wPnWK7mLAdLqOWlbrHNRuderEihwgv8V0FF2C43GHbhfHPC5t1p8P8X68UKSOzzM9i8TltIZJxgeoMSVreiHFg+V4r9BlSYbdUz26bUhhK+mFOkAyh3nuGU87uDFgf7MTr06MVfbCCvwmJyi5MY/zALC97XB012N300n1EhBw/w0ORy8EnL+e0J8Du6cCjp8n7G4DH/rOb8ZrEItvKgdKH7/2cffN/CaxwurMY3d7BTeEyM759w75TUQHz4sgKb9M8o0TkJdTIh2dIg6mNI+80RtXFoOMh286BroLZe2ivK/v44TP1i/O/htOCf1FwHjs4KYAn+oUhp4i0eJBKZmUbY04FjMFShcZZ/sBkYxMmxR0HyLBAmIf3AiMG4dun8RRx5ytyPFslwUvTmuXr7WdgMQ1Gb8PNxPpuu1BI8Efcb3GSLQ4A7Tbkii0F+2x9bACzuTk683oLwLW9ypvmJR+IJdJU3ksp1x7eiKNRJitVkWTegB12cpkFaIlS1QTLE3qmLiNU3SZVixFpOI59ETOg7nEqiz9fCIQaKwAFSuGkEHr9jHK0jN0Ltd/A+aEy56XcalaRXe/7kCDL8qDhJUD9rkeJLGkgC7mq60EMrGlYDZNsIqTnhOsAuTm+zCJqhEs1Wb+evk7MHXdJYH1l1gRF469aKGryodw6MGCK5a7Yu+lJbdx3+csQdtnZ0ic9Dc9M8bdXRAstR/fB7QdEI7X6NjKrLJ8c33QeVfi8vJ8OIBcEpqYCNlrZiyZIowrx1a/p5TrSbswyeQwD/OMdBLjmxbYd5spwG9cLlHn45jPnplpk8c1Po/hmD0hqcl0yN3N+M/2qbTdafw8f3383D0V4PaRYD2KeDTscRV84Ie/GXe/ON6E997kMJyyqZZw8XSP/a0O+1tdIa8ARCvKpGq12cxAKS2SCFZUJc+BwdM6Lh9OCPub8W9KWYLiOlzFPztxiauKxxJ+yRsywbJgTavxKP6Jy2+VH2CvMka0WVhcowrDSWyDZS20C5Cm9Ge9Vat87YCcFcnmYuvLFwQmqPPzkmOaQd4fe/hjD9wc0vep6OeS5lVU3S+P1V1Ei56UHWLpjPN44ddSvijFTak3Uzfm4sq5c14sW7NYpYUEhVmNMkOgrKZY7XgC6zbjTx6MOUCbt9Pq1CowvXacGSm1hHKJJNUsU4e0hPQ6E3t1WRai6N+lcjgIYeaSicW0531l64EljUK2krVqNqlPk1gXLwNbr6wVa+auqxGXpZjLFOd1JZdfedB6rUEdsL5EsBYkImwbM9TuEalbWH7O3IKrdT52RTQUQBGbWC5Prsule5R/O+sKtuv1Il+WlJF43L2P6yr1+6ajbFEutKL6XI2E70N/3It2FXtKBPo+YIs1NLEqCZeG208iv8JzxObOgP5iQn8xZev9lPs/nHaYVrGW7v4GexgScbqdXIFp+bRR8xtLISHV6U1za+hzGMh0FDDcisfaftb0WrViHcQj6y7UeNN/9f0ILqB/EG+Im78ErM6A7ZPxJuMagP02FmTmquIc4MxuJHZp0ZRJFwB5YKY1YUgWoX4X27n4DML6bsDFM4SjF4GLZwI2LxGG0ygnMB1n8qXjgdweRfA4jck11+c6f26KlqR+FzAcR6tWjAvLNzcTqRx7FBRhpEJmgnzAcOqkxM7mXjJn7zzGo1S+R6m/d7oUj5IZoCl+n9axbyzD0A2Qcj1uH1I2Z3LRpWvNLljJ7jvNkhW724TzN8WLdeOZM5zdOwJ1Af6sh7uIO6zuxdiwo08QfJc0sTjRYJXJF035d18/CPAdsL4f+9af+1SeyEs2zbR2WJ2N8B2V5xoCaG8CwRNRiC7aMh1bBuaQg+RtUHseLFEGtKb/q9l5bGmpTBSa8IVURqNwBc5Sq7OLQT41uZABPn2mbL5YasmsT+50qRtoxxulo1VAv8VrMkgUz5Fdoas+L68guOx+FRVtrQXE14eJsQfceSpBwtmE3IdpQmCCussm0jBlK1sYxoJ8BB+yO++QizAvPGzV09eHz9tmBwIoNKx028lyRqs+u8WmKW8PZHdeZV/9vTgnqt9LRXYhMCNHUrOwRuB8iNv3fT5+8IXbUdx/KnAefZ/vE7aSdg5FBvAh66l5CQiblXwKaecafkQmuYHv0dw2P0fTcZdDUNRzTVPUkZo2HfoHQ4wXvL+HX3fozvYIzsHtx+KFgaYpZjUmq3cR78n3oirKHjonLsCwdqC9hz/q4LZT/tx0xUv3cKPH7la2sl08k+6PEdjcDRiPY8wqGxZCB1iPDY+x7EI8fz1hPMlhHBfPBPhjj3/yB7+l/lu8drD4lvPIWrI0+Accb8QB8v6bgQdvIIyncT2bL4FoyWE9qv1p9tNzbJE2nzK0Su4qlbcZN4ThBqG/APZPEMYbAdun4va7JwP8OmC4Gb+zJSh0yEq3QOHbjubaeHxtVRDrywXPGNwnbjMu4Pp/vshMLMliTLcNsg0/YKMUjC4Jlc5y9Mq1yN/Jz3Wu2LrFwfaFGxZ54mP3JZ97IWqacHorBlO509LEl0shYXaH+3V+i9JwYgHLZBTIKvpdReUcQKqJaQ6i5D3iZ30wtxlFkjZeLLM7VZuaBbxK8kMtJsxauuxkbwPIddyUPsTK5SB+nuysUcbWklsiQ+s4MYbVXFdIXCEcb8Jv7sds3TBtTn5e/NZgZplL925BsIA8ES9k7obachNoXiNTiy6+qwa5iytxYQiv1VPk7vF1ZMJj2qi+eNttrqIiD1zqCqwegwkX90/EWSv3oPc5GQEoJDTiAn4huYLl1VpYQ0BQ6u6aYAGVe3npWDUoggWo4Hn+XKu4zCTZIofZdPl5WffzhBo+D5OAIy91aSxzaSxz2wlcL5Ax3EiSCrcI+1slwQKihA5NkWDFYwDr+7H9bh+lcSzBGo+B9Z2SYAF4FAjWQTwWJAsAfvkbvxVAvkkuPicRrrfEG+v+m4H7b3S4/8Z8SfpdSDpR5QTPEy5bmmbxJ8wbWKZkA2xeiERr/zqP/evyzbx7Ksjn7qmQaxjyPBPK77ogtS33U/jXQ8XVxjIQihx1+zBzpXmO+TomDCeUXIhpEmKjSx//hMw5/ouWJOtuZSvfcJxdm9KvnqUpINuuHsQ4sdVZwD5pY+1vBxx/ZIXVEzs8eP4UjgL8RQ9/0QNPZ8uC25UTvrhylZ5WcY0Vum0MfrZkyu19ca3JWGZkUNSFZQmoZlmZt3tOrdaK5EuYrau1XcPMzRSyNaQGrVLPGM3ExU11FAtem3pkMhk5UjIOaR/KxWiLtkzR7KBjooBMsDiIXRTuleULmFvn+mSpscu1y4ezOW0MnCWwVsLBupsWcCVi4io35ZJ79TIXJceD2Vgs3Y/L/j+QFUldVyV5s1I4fF+bzD75vhCUDyDrpHHyQxetM0SUBUunKX4fR9DRkWiYhf2AMAxZ04y117gtbSWd1ItHei4Wy+oARekYaYsISz6f6bgrZG/0OJzH0BiqwSEfTon+hk0nf0XxZh53NuXzIGVyJBlE/x4o7S48PqY2drfjQHnvjfH8Lz4zjf3pMnIlEgDot/FvfT9gfyM3evRS/E3X91PIBYdgJCLWn8XtfvHtb6tfsEcIj4W70OLzvvsHcPIxwr0vmrD5eIfdkx7dNrulNi8ShlsBp79C2D8BrJNK+Ok/mzAcOxzdmaL+h0geJFJyFK03fLONxwQ4YDiND9J4Gl13460JNBG6J3eYPrFBt00Wo9sj3Fm80Y+ed1g9yG86LEBKY3IHTkn/i63sPpIqXSZGBrckFCrK7PwSrAbVaZ0tUeMxiRTCtInWMzdkgsXyFuSToOegCE0HidvyLHoKFC7WomSRj67M4TQSqu1ThPW9gIunHTZ3Ai4+k7B5KeDscwj9A+DsjT7qY332Fq6bcHw04P6v3AIArO7l32N9l9Btc39AUf7BTWyej8ddnUU9s9WDSQohB0oB8IlUaEsVjT4L0vLl6Li2FsVaeS5l//XKReHLyV+SLDgLiV1YSc5hVsGAf2edlcWZd0BpcUmfM/KfJoJCcBFIpM+4lhylbZXQZwgiyMguRHGJMglKbje5Zsolp12lxfmEkI+jMmq1yCKc6q/3ok8ExOSB0FGZ+p7K7YRVB6RCt/JGr4iv1vxy9y7yteOMQkBIVZh8/F9ZiYTAiJSDT5N5+n5Viw+j5i5cIsPJVShfD7gjiwxE65q7rD9a6DSJmUpbOoYL0QpGRHO3YCqrI+KglmAtxXHpdlwH+Cl/8v3fufi7bDbZ9TmOwHoVCdhqFd2JfP+sV8YVyjcpRRLPWYUs23G0hj9ax/s+ueim4xXcPgmOMumRuEs1PhBhPI0xwAAkKHx15kWHEchjcaCUuUdAdzbkLF9ABE7dfso6XPoap/uVS+T4lSuKzfu1g9vFjEi3m6LbcPAYbsaEsItnVtjdyi/Hw60YS7V5ATh5Pra9v0Hohkiitk92OP5Ekp8ZA/a3OqzvjDEjMYWDBEd5fkzZ9tvbDh/44W+u/96vXTze7kKLD78rsudbH4o34+aleBlO/2lykyXr0tkb4+f26bjf2WfF7be3O4zHDg9er7KTKE7awWVXGIA8mfBLmlhRkmn16R2mz4x/AOCTS3P7jMdwA9g/EbefVJu+S6SISgubFgzVqvS68HT8x3wikg8mcv02xDp+U3YN+lXuu26r28ftc3xLvh7l+ULeoNgtCkTiM6UMxeE0ZgPubxH2t2MMFgDsnoxpvuMNoL+gqPQOwE8dLi7W6J+ObsPhVposOYb5qDxPqTuZfrY+uVhXD8o3/W5XF+EsYD2ErIHDYoX2DbIiwMrbcaxQrb2DuGqwuRxzybVUsbaJDlaKmRLylzKbjF6WwCWXX+VYUrdsIbBYyoUYAUepOcpv7SyqKNbDhfbUZGPPzY1+5kqN5zWBRpUWPzsJ40pdkk3Q2ywQiMVg9SU31LyBWZ+WSN1MI+sSSAC6JWJp/2rQPC9f0rLibaxW1VUIFgCpFemneH8mCQ1YWY1xTBawGHOm3YkxBk1ZsmwGp4j6ZoKFyUtWLBN5tx9BQ7R6B473Mhai6ajDtHFCsHbJIs+JNDWCpZORtNvcb7o4thAVBIsFPjkmkgkWn9e06TBtuiwEKs9Q/D7cTJpVz2RNr9V5wHArWps2L0At9zj5xCRWKiFYybOzvsPfzbzDlzh9PoIE6yAeS0uWxVf8gR/AeMJ3dvzguB0u5iwTdfJKca07N8Tg9fU9vrHS/iuKlpNRTfaI8gPDLR8DmG/FKOzVJt6c45BqSZ3Hz+4ua1MR1i8R1vdSV4zgKcdj0RStUEweBJQC5DltV2WOIFltivgCikROB8ZL4eIUm8axYHaQYgtYTk9GsX+UzFDZfy6v376OsDqLlj+GX8f+aDkNIGaljDfiGx9STBbdiQfrHxBA+ZNlHGiKqct+Fcvn8OC2vu/R7aLqP2cGycDnojVSXHnsMrNuLl7PbkQbC2Umv5oQK4AYF8Fp2ubZ5HRxW6InXqgwj0Mxx57XDruEyElquiWInViWiuD4dF5BaWbZgP+qlQrIpNXlSQNA4bL0J6ssLZHOx+2nWG4IKC2PzmE6TgHLPBHxT7ct3X3uLMVhXaQbZZxKlyC/rIxjnth1YPM4glXexaJjXIqW/DDBmpGipeLQsqN+Tt2M9CzqbS2V4tEwVikLOafafj6UmYEcVM+lcbQllxIBcuZcdJ8lIJ7vgykHwluiWFvO2YhuoRi0Tpaw58tu73UavFalO18SUsy9z2VxpuNeysQAwPnrOmzuxxfwzUuJiKQX2m43xaxDeRHMz2ot+9uGFNCQyF96zuRFu4+WYXYBstcFiC+1/dYXYp/DscPxiyO2T+bYMx7jNy8OmI47yZicCRPzI51eZjjuVubCnvC+P/d2POJolqzLsHkxEZA0+W9eit9vfCR+nnw04OSjWfmbM9amRML2yczKQfSiTJ7ilsTi5PNn8ITgCX5y8JP6KSYCplxSJyTNl91TcfVwIwbVD+mYuyfi5/4G62VxH+KnZPkdlctZC4yz+3J9Q+WSTH/dEP84C5HPiUVSeTsdjxa6HLslMg+bVC8wBaBzQP50RDh6IWA4BcaTgPEkvYkdhUywAiSmDh7oH7i47qwH9SlmKgDjjZA/E3SiAg9wQA7OjNuoiXOWrZU+mVzxXMjuNz5vJeugEyJmatKhciwd3KreYmdWtYUgbFm3gJp21ZXaYPdaJUBelOZtGaWU4r5Eri61FPK1YIufUc2f1cHk30NNePo7Txxc/FqSE7j80MUukSuT2LCkQQYghOT+8vPls9NxVJVwqFqzyC3HZlV++yrBsu0dOh6wbE1yyS18WaB9DSoWrLgmS3pdmmCJrEioEyz53c1yXfZHnxMnldQIljN/udNzixeQCRZLRqTyNUywZPcUd8gE6+gT8V5bPUhF4RPBclxayxAs0VwU0WhXyD0E/SKTzk3GYe5DGoN4LuHxdp9U2FkC6PjF2KeT5+PnjY/GiXDzYuxzf5YseEN+CWB5IABSeYSJm1RHOSDN9rigWbIUvvLf/QEhSew6O37BY/uEE5IwnpYWmtlNxAYeNRaRz9as8ThuMNz2CF0AnY4gF9D1yZ/uHfyLa4RVQH+ngz9i8keAB1ZnMbC8f6BipBAtNOMJYX0nFLFTQCRlHJi4Oguz0j/TmrC68LMCz+MxRRHSNYl6u14vop9JqJTJixCndSSD2XzMFyRu0+1igWzuR3DA/ma8Xn4D+C6IGn63TUTGx/VMwsbkIgwrD3c6ovvIEabjgP4svY2dU4r7igSN+7g6j+ZvmuIyN4YifoHV7rXqffwt1aTOFi4hp6QEQkOWLajo6cTzLQmYFAnfJcucis8SLAVXJxcITb5UnuYBWGHRbScblNbJYjsVq6XjpArXBgeZ8/H1OXgfrXSuJD/aklXEZSmXt9/0EncIxGvp9hOILVNsDEnuSnHdpkmKLVjyBs7ljO6nWCwRbx2jVIONN9qlNzCOt+LrNMTC3SLBEcIykagUUw7TJDFTgqUi0RLYn6zcl1nEDCm6zIqlz7dQ+2eicwiO5law1QospUBLsX/cH51VyLFV2mqo4sK01bBow1G8NvzbsUVM38uaZLn68iLofdVXBFTTp0/3G1uMEsni4HG/Ihx/fC9ESRdLdrsR0+kKbjfJfvrZdaPHtHKwBLjbTfCdE8Izczcm7a0xtdlfjNg9uUL/YML+iX6m/XjyawOmYydjo2gpynOGYvuclFI+u2wtExFgIvzt//XRzhxUWLRkNZJVwW/5Pd8nRGF9Z8Rwq0d/FiuVSyxRshatzgLOP8Nhcy9gd4tkolydxe+rsxhbJJacRLbcEGO/uh1h+8wIx+KaYzxA9+IKfh3QnaUbN/WNf4j+Ik7u4nZLKzr13a+gSsbEz/2t+LBs7gLDDeDo46HYj3zA9nUORy+Wk/l4lMjdBbIQq+pYv43nu34QsHsiK61P60jyun08tttHC5YE9O+QNVbSJ7to3RSvl9tHctqfU5ZfCIDfhHhdPTCdeoR17NTRx1aY1gHrexQD89O59WeQQPduH4Q0svpxt+eq8qkguHar8ulK4DnypJ60sPh6kA+yD3GQt0um/ZCJB084HDQbOqXEH1LcxxRiiRcOdK+RLCIhCDSWlppiG4UZ0aqNAyGULhaGo6zlZbMA0xt+EWQOlDpZo8+TlJr8ctWE+cTiVRahXD99jaAG/1WX3ZYdiZuDyauUM3oQyVV2E6oA93Se8eChWD+rV1hYOVRxaBsHZS0san3VzWfJrm4DiTAlIhJSQHoBFhxlbaklksTER5NKnWSgY/Z4W3usJf0r/m7WC0myxMnoWdni0DNypa+pCbgnoux2tOSPz0OX6SnuxbR81c/d6ilRA0BMqkgxlWOqVegmj/Goy1noLJWgs3NDyFZZVYLLrzroDFwAhdXb7aYcd6X6E7czizmze+XQn43YP7XG+qU99k/GQbRL8jTaOlW80FEeJ6QItGqXy6dNxw7dhc91dAPwt/7KO/CYoZGsh8Vv+1e+G8CcvTOk9uGRE5IFZPafCxYTdrdJ3FLiyjuJ68dTYPvMiO48mV1P4g3fXTj4dcD6JX4AeTJU7RPElSileEIkcMEhlZrh/ua+r+8Cuycz0QJyjBlNwOaOx/Z1+YEBYjvre6EgWkCOXaMRWJ+VRIvP342hIFoaclxFtLSOVejmRIvPJ3Ql0dK3eX9BBdHa3Innwr8D19Hqtx40JqvIqKwkUx649MAzU2J3c5IVzycSLU2yAGSNmtFLdmGRmcQJC4pAsMUlnvjCo8huOVZ1X8pG42YcoSowqiFWE1cSLi1T4dycaGkr7hSk1hoq1076ZUkWUBAtnTKvSSxfI02wiu2JUh25qbAuclFuuncW+zWOmVwBc2ISfOkunKarkawK8bEkq1qKh1wO9K6QrBlpmaaZhUy20ediLUnAnGTxftoyp1Gz0mkx00oRZrFkqfaq9QlVP+J5+TnBsta4hyVYDE2wUh8BlASLiZiCJlihI4n94+dgPOqwuj8UulPqRPOnSfTwqyTPkMRC5VzSPn6TsgIXYiVnx0gYT3r0Z+OcBvDx+XdjEshTjbLy6fnvshJpf+Ovvevg+kcUixelxWQtQG6UhQwJfkvpzyecfNxLxsjqIr9lA3ES39wJEowuOiGJXBx9Ajh6vsfxP4s/xfE/TcHvx1GqgMkVu9Q6HXgfgNWD1D8J6s0WLCZEej8gZiyGFbB7QtUBTMHmoQN2t52QLxZsnY5i3NlwgzAeR+sUAElJHk8J+1PCcErY38gB8xSSWv42WrX4PFgnha8Lk8JuH+D22QLXn8f/+/NInPi6dfu4fX8W3Y2rBwQEiJvQ7YBuH7dnSxZfew0d8O9tlhpj6fHhyWKctwsoorZgQWBdJg7czitKwjAT55QOP+S7zyzWamESCKbfszI9Zj85TxPMnmCLUhcK9umYoea+tMHiysoHKLeEIVhBWSRo9FnawSrss/vP6l4xWVnSb1qaZPT1XCJYvO7Qb7cQ98TkZ5bZZy1ldn/Zb2G4v+Q+YpKzKCS6KIiqSHpNzFa5XbmMjyaowSaP1Cx6rrxvljS6ZhIn/H/tnHi5D/P9lHu7SPDg1XtfEqxRPTshkXx9XH7WpigZ40YP2vscp8V1CkcPt5tm+nziTu/L9jiGkXxAfzZKzUW5LL7cX6y8CwTLHtex7In5jR5TgnUQzZJ1BfzWZ79nFhfghhz7okvd+BVh4lp9VBKRVSrXskspvRIcnwhJfx4tKeefxZNGXL++E4lRfxbJlMSDpft79SBguElY3c+6K+MxiUtufT9gfyvqT22fimV+tp9B4rqkAZhSqYNAkZT4VTpWH61Ioc+WMfKRLI1H0UI0HkcLEUsxBIfUTiRYcR3Edcplhk5+LWD7ZMz044B4LtHgV9HFOR4R+vOA8TTGdnEdyGglypmK42kkYkwOY6BpvG4nvxYtaZwB2u1DkYFpYxHcFIo3aol9ELX/vK/WI4suAFdYTNiSEtv38H0snO1GnwdgnhvHpP80+ig6mCw0uoi0WIRqOj/qWebYLJqi6y4mK5SFwXXweOjcfB+O59Jv3WJlUlatEBbdh1QJDC9AlEmkOpZWjucJjF0WmfwpRXtS6euccBBCLug7+pIM7gfQdh+FKnX8D5C1l4oAaWVZAhD2Q544axYfbQE7FCyuC0jr0jGyPvZBiJUtl6P2n5XvqZXKsf1j6HgqbeGskiM/t/RpK5Y+jrGKCXHVRHHKMXrU90U/C8LE7sEiK5GS1c5c45o1jbdX/a1asWxQPFtaiWCzav2mj88LUSREIZIlLvAe2DqlrinrzNEUrdg0TGWii9J7Y3263L90nacAv+4QesK0crnOLbtX9x7d+V49t+WLCFI8o606wd+73ZS9FZs+vxhNQT3j6ZOokasDlqxGsq4IIVpm4gXypOs7V6ipi5uJyZhRW+eq5bqEzPYpkszGHMdVkjWxWrE0weyNPx2W46ysAYOFRtNxd0+k7VkXUL30sAsvNqSWqbaYaHHcVy2Tr9vl9dUJVI/renzkbT2EaMXt2dRu2jSfIrmR4q7kM5GsblsGj8q1Mt9ZC2YuxQAhMLHB9KldjFMogkEZjgOxdVkQPcGJoGeQgbdwHZq30ZmlauHZtpIOVdHS6o6GaEkGIE8Ac6LFhZoXoSasg1YF5ImiUGnn1PXOFRMV3w9Mstz5XoRUAUQ3IYCw3ZbHsfFYbKlIk7aoiW856NAEwTOunMmZ+r8UKJ8gJEuTk0TManUR407sWnTz/pk+FiSlJu2h71FzjYQIiXvSWH3EOrVAthXBipuHst2ae5DbrxEsoE6yLGHjZVKrs5tvm0hXIMrPIzCTLikspvEk5sdc6ssB5ILS5SeTofE4WSnT4brzNKaEULycBakqkdt2e1VzU7/o8D6EQi5FoEhWI1iCxR+0uQuviJ94zzvxEz/2LnTnI7rzMWopGTfR6v4ebghY3Utpr+mGX92JA/L6xbh+80Jcf/J8/Dx+MT6cq7OAoxcD1qlsAbu3mHRt7jAxKPvGD4CQqjH9secy/fz9NqDfBmzueWzueRy9EDfY3I3rPau1p/2BRFL4LgmRgMWMvLioG4Dd7bR/D7FkMYlh997qLEQl9gdRMf3oTjznzb34WViWRogVjhRx68+C1DHkoPX+vCRDq/sBq/sB67vx7+hOPEcrX5EPFl2/UdV+/pvKNe7NfkaawI35DVIv54xFdpk58ymTPi/fl64rHrilTMZ6YfJgMlObIHX6OhRJ4nNzZjKUFXUSJ9YjW+Nwth2LR6L8tGAXpZSxMRumVHmWiwBQyEMsgXyA245zMsvJAbNYqMPt6TIute1nbrWryCWQq0svsBSBjq2qYclK1mWrXoHF4HdjoZT2K9YtZFImfVutMANnWXq/TCKNBWtGBm2SQNGJ+bmHELIERPU8SuvUjOww2Q4hW2kpZw0DdYI1uxemMG87ST0gJbPM7nNeNprni9sxGbd8TThjcXU3zjPd/V0kWCIJ4Yr23PkQs3J3Q9GuZDMPk7w8FufEsixp7vvr/9e3NYJ1BTRL1ieJ3/EvfVfSOenRbcfo1jnfI2xWIH6DcMB0Y4PubB/LIZwPmG5uohkX+e3Crxy2z0ThrXHjsE7Ew7OmyamTOordPogyOtc5nDbRZ+5S6Roak3tvjH1w+0iA+m10P3G9QjeogGEHDGzZeirLKoiCe2Wc77YhZzMmbJ8ibO5Et97qfoBfR3fmtCaszzx8Oj4oExE+hl9HzZYoGRHJlO8wk6TQultADmaX4tJHqebhjZztefJ8HuSHUye1tFjPxaXMP17GbimJRyCABp8C4ZN7YIzuPw5ip2GCX/dwQ8wAspN7WHWZEEFZOkXUL+RB3vu5ZUgP6kgETGUWYppysK6j7PZiaA0o7gcTA12eR0809o3cTEyxLmEnNQUBbXECRLgxnV8h2WAnOUXSgg5i5uunLV5mAgtdLu1Dk8/xbmfbvE+6JjSMwHYXjzOaRAETeJ2Pl9x44xjjhXQcV82ltmRFZLddLbNQuRarZXAYtUxB4xa8insQPuRi0drqJCSjy+emrVEssSAuY+USNEkAtWtxSOZhtr7i+tQaYkz2inI93EdgFrRuLUJ8rqHvQOMUpRu8j88RPxMsRrrq6lZXr55HQESD4//K9cclqdjCy8fmklKJzMWEmHg8mqa4H7dDhOlkje58j+nGBv2dC/jjFdx9TiMnORZbp2iaclyk+S1C1+Vj6hex3qU6tKlvjqR80F/7v/8IGmZo7sLrwFu/+jvLBaOXG1p0hIDygUyuI3kbWveFWZarsI9HKUtqw67C+DnZwsuJaIkrkX+pAMTsw+SmU+N0xxxwDBhOYjbg/gZJxh3Xr2I3pSVaIth612N/k2ZESxeN7nYxxolSiZ5IUvK2OV4JScA0E624Aqbxsi9srVs/8BiOM6myNR/Xd0aMJx26bRQAFHei1IT0Uv9xCTT6aGJ3VGg9CdSbJ+1HIQq6NE3YrIq4CgBzkiUB3SXJAkqiFZzLli8mUJdk/sC5uC2TMGud0ucB1N0eWj+pT8RxiWQp1Fym6Ci+SXPsiT5msTPlOm4qPiVOaNyv3O6MZKXMNdqnm/8iLp+RrBrYjdg5IO0/I1kc3J0+q4KkPIExydLxWHo76x4zcVdV65WVX7AEpxaDpS1klvgY68eiC9DGXPE6Pj7XctTnZ4gg9aVMQmEJ9GFeXie5AmcES1cLYHehJlk2IJ5/r3HKNQuZdHJbmmB1tPjMkwpQL66PzuhcSjzQcY/65cpubn4jOZZ59m2iDG2HeH4zK+Hc/QkiIVjF75bunx9/3x+tn0NDI1nXDSFc7PbZDQe2hkwWgQjoaFbwk0K0cEU9qBg8Od5Ywe09xlNOU0+Ea0XoLzx2Tzj024Dtbfajx7bcGMkYTRDFdiATlGkTleJ3t6MVavs0iQI+x4tJnNdYKvnmUj18Xkh9AnxHQgKBKJvgBjY7QwpZ67Z1v8cjh37nMW54AEhtd9GCwm9/6wce05qEUAGRPLmBA+9HTJsO/YMhK4HzeNxHUT8uCi3XP2X7QAWCA/ptNVujCneCdZmlwtEYUj21YQQ2UaNCk5FifzsxdnnyiIO9mXRcJBX85gvnIqFLQfQa8sbMQbkcR6KsXDROeRKyk6uRfQjrFSTdnRerWDJ9PWdIE4p+uy8ChNO5cMCxP1pF66KKE4nkWF07tobshnjt+VzS8UTigj+JosjooXI2TIjYgnRIJysdR8PGGFmSlU9YBb3z/1oHC4qAdV1hrToUtF6zaFHnym0XSHTtfGYEa5oyUTDbzzTHDHJAf+5/YcnS93rwmWBx/JZ6OaDOzcnVUpyfCdjnYxf3dCqrwzpYMgbIuGXcbJpgcWaiJlD6eEyEmcDbQHyiXPSciSCQSd04RSvTOOUXnVUf72t+4eFrw781P2/8sqOJFQf1c5C/erH78f/3P5tfwwaLRrJeDrz1q78zPnzDAaJVMdeio5nGUDTTQvR+pMSCygbxK0rWGY/hZlcQLSDWKwSyAru1dukgyBrRqqHbRTchkyx21XFQO5e/YXfe/qaywqQB5PgFPyNasY1QfOokAb3/tKEq0ep2asC1HpbdJEQLgKQ4+05bv0piRNrCBKg4LOPu40nFuUhqumRaT59CsvS2PHn03TJJ09l9Uk+tQmYwJ1kHYbMah6TmrQZw7daMC80kwH1gcqUtWX1JxABDsrTFRwWjz2Asej6JPer23b5OdCTo11joaBjztWVoEVJvCAOQY7DYgmSD3W28UYVkWY2oxdioq5IsZKIhE3ZnrBWKZF1KyMyyubvRxKPZIHd9CtMU99fXuEKyagSr6F9xnJJgza4jW/I4Nqw3LyLSOUWA9LGB/IyteiFYQCZZuUpB2lW06UxSSo1gCTG1BNY892w5UwSLzrcI61W2wupzgXoG+bz5uvfqN+KXFSBbxrXbX7kLG8H6pLBIslrg+6cRP/aT0ZQaVi4qAW9W8CfJasHZHfxZpDAH8blbS4kbPdw2Ci522xFuP0l5kP58in8XE1b34/+bux590uxaP4if3S4TITfEQSI4SBA5YzyOyvS724T9E3Ef/pRagpvoRhxPCdOGpI7iqKQVgHgc38VyPvzQDjfzcYIj+D6l6qc/JldM4HSNQbePblY3BHS7gG4fkoBoJEGxGKqbkSseCKdNF9OSk8QCDR40qhJDLBKa3Ey2iDCQyek8awrlb8dvtjvjytNt8YC5H+LEb7eZaVSVA7pFOOojWa8ExhekB9mdwPeguBe4Tp2VadD7SiYhx+PwxFN3VcyulZyfj+67aZqvs1jQL5u5dmtWC+6j9/GZsseyVhkrYLkYKF45liYL/AfMCdZVIJa1HKdVoFO/mf5euQaatCxqXam2Zts8JMGKq+brin4sEKwCmmBp6ZHLCNbSOU6+/nvql5jV/PmReoAhzAjWzMVd09ZiolXEcYU5wWLs9lE898EF6HwLDGMcL6Ts0yQW77Dqs3WWzxGQ4tZcLF2IE19meYFRpMq8XDSC9elBs2RdI9761d+ZTcLqzcmKIwq6uB3rI3GgIY0eft1HF8+6z/ulyXM66uM2my4/MAGJdARMRw5uDFIUdDiJelbjCXLBZQ7B6KOFaH8LscTNaXTx+RXQPyD4TcDmpaiiDkCJg4accbhX5xWiizK4XPdxOAVOP1parYAcP9VfsKWI20iBlwFJ6Z3S+ZGQRSCTydADq/uTFC+N6+L3/mwUN1OWpMhxToycLTjK4CgxQem3Iy4OC2RrjKz388F+SqrjOuh1lXR2OOBWCzfaZ7PrSrV1Jku9i0TPkhHtplAWJXmj7V0u2cPrpfRMtOgUsVpIkxATjHFC2Kyjm49dk9ZVmPpQkEMrZqpdKBUSJC8qtaLZanvW+Jqp5AOg7T6e07RwbYmyhWoYIrGReC1lXdJdG4110rlFq9bBIHQNR6Vul5YtMEH51HXLhEK77ky8WD6WOh+OH9QWLO32G8dIkrSLsBb7ZeFDETtVtGFcm4VMhS0EzZYliQHL14KIYvB8CHMLVo38WPT8slHWKwTiS/Es2F259GlIAqG6nJW1ktkYs3S+sr1zoGGM3ovtfn4c/buJNcrFeznFWoVU/iesV2Us8MI5h66rxnz92N/9z+vXqOEyNHfhK4m3/ubvgGRa2eBLQLlpys/iAeGJXkqPpIckDVTiVuQinWPAtOnE5aYlCMZUY2o4SSSNy9iwN2Sdt909mbq4Djj5WMwePP5ELEYNAF2SXhA9KUu0tNcltctka323JFocJ8UWOL8irB74mGnIBZs5NCGdl+4rkImWLsTK4LdPt/eSIRhXoOirszEW2qzOA65SDy/cXZpkATOSTRWrViGEqFF7NqWkR2mFEnfzkmp9McmnTw6i35fB30K0NHnwaUD3QYKEY5+7oq3Z8XRsGkOTLNWWnJuKGaHRw6eyJTlbSpN4vndiJpSIjxqShcmDtjsJXK+6yphkqULRcYEhWWqyZPJxmevwUjcht1vbppI5KOdwGcmyqJEsRbDKvqa+74cYm8hWvoocw6FsyvJcUp9NYH0RhG+vgyVYpv0QQrRiTdOyCOklBAtQJEsFuwMLz1YIgE9jhYmXSh0rP20/1LbyIjOM8Z5bsu7prEkgW982uQ5ZODLWPNFqTOuL65z//bGf+g40fEpo7sJXEnIDe2SdFI1aEV4gTkb8AEoB4DQoeR/bSxpCLpVkcBcj3MWI0BO63ZTca8k1lmKWVg9iW8cvxknk5IWkWXU3YHM34OTjHicfj9ve/Ejs68nHgPPXA0cvBlw8HVXYWaMq9gei1B4okp9YXDSv29z32Nz3uPmr8bislcX6Xd0QMx/HY4cxVYUfbriYedjHQr8xAxEi7EohE7x+61Ns2YTxuMsuQC5XwdpmrHCe3Ixaf8klWYSCFFjSy8TB+zmpuUyE0hAJ/UnKDaBRzXjk+2Gof87uMQ8U2X7K4jQTIuzN96L/ZgLgZniCXpr0tbukc/lPtSVt2MlFud4s/KqbF8xNv1cmxOoZ0tay9OzUrvm8/4pgLW1Sm1itC64ItKbyrwYj+HnQ3cc4dC6aWPFfsWtJFkMipaTivcLCJ6MobaNdp5oULl17JrCWYNl2sUCwuN2H+W2xTLDqGyuCpZfFTpV/fE56GxX7SJOP5EoRrOB9/BvHaC3lc9ExdwtETFybMC82UATLoRGslxHNkvUy462/6TtmrqXCGjB6KUXCcQAA5jE7KaMk9HHgsjonRfuijs5xB+WkBkAyFbOlrLTyjMf5qWSlerY8iUK7+e72cf9uDyBEi5WbImlgixOLf4aU9Titk4tzk4/BCvV8Hscvjtjd6rC5N2F/s4tWswCs7+VBTxTaOUbB1KCsqYbrEi0iMFhz6aZtYsOhiKmruaPILjNxVrMyIUCpPo1MtAprl3NFWRt2J5MhGVK6Q+vzwEwkmryzQj2TvlpmFLAcSKvHlEvJi7ISMiFhCwpbaY8WrBNQltv0e3f3oyBjSFIo7u55PtRZLOQZeJKT/s9lCMSaxaV0bKanFibVli12o2lrjw5A77oYGM6fNsBc9gmi1E4V0lbtd80FKicU5ss0dLviNk0WXSYgCwkKhRyDnfwPkUK+RimWqkogVz1otZpfo1o5n2nKGl4sSFpzmZmXiYJgWY+BfQHhGE6d1GTd34ya1Yrjp4T4q6QLIFtN2bqoRWJ5fDeZkzJWcFYkhyIU90p5bUPvGrn69KK5C19t+Nqv+KPFwGff3qXmG6fjOxeDH/WgoTJRJP141WXdIT2hKpLhU/B3lIYIErtkiVbxPwHT2iF0UatLtjXEav0g1knsz+Pn5m7U4gJyGaA+Eaxu75WyuzJre0g9x2njsqRDypIkH/vjhlBYsQIRNi+lMir7iktDl5FJcUKhc3DDJPE8cv2Z4E4BWlCzlpmjiXEt8HVGsvjtWluoqinc85qDgdWqgdIqxjEanYvkaB0FHpl0hd4tuw74XvGKZA3G3cZ919YnPZBrvSt1380mOM4qZOK37rOqvSFZ08kabjtiurHO2ZqK9Mag3nhN3HaCGyZQSliwJIuGMWtcXUKyAv+OQCRZ+nfSJMu6tRLhCpOPpINdP4cyPisxTcQioEwY+JOvX+x86XKrjeOWZNVcV/ZeekiCJfsuxXrxeMXXga0xSUuM1usyHkuDhXXXq7yvFm7Vp9r38bpLQkY3j0fT16QWh8XB4umFdRaLpYokS6ymfvmtxEBmHS2VBMPXgl+CLcHSNSdtYoOWZ2Btr/WqeOHKY36dZL33H3wnGj7taCTr1Yiv/fKUvVGL07IYzcMKyINo37asHEQBJeQYPxPBUkHifs2WChTbsnVpVppGgYPQZ+KoQK5tqAsxA3OipcBkiy1pQrR4zldB9n2qQ7i+Ew9kiZauvyXp16pMS9yoYmqvEQWFIqhbB8ACeZCtBVwfCgAHqvdCsNvMNlDt84BsLU8H4jPkemzr6eIA5m/SM/depV/GlTaryWb/h4oztMH0RYxc/L+/HxVxORaLz6178V5u0JCsQjMKJdGRyXw0ZLMzfdHbmmDtRR2t4iRLknVQIPSQq8jGST2MW9EQgxnBUv2cwYqW2n7pdXwfqr6SCIsaklVTbDfirHZ5UcOwFgumlx8iWfa+Y/KvnvOZvtzM0laxXpnYLbGW6vMxbmkhWbVYMx7/jzbFd0bxfKfnrRGsa0MjWa92fO2XJcLVVSYdG1fALzxavJHHF63iqweaTlnAbLB8nyxbiVxNaydEiAca1tqK8VGA2wVMx+VgKuRJSS9IfEAov1fvqIXbVMjdydxlyVaxzZ0Rw2mH1f0R01GH1YMK0ZJ4kADW8wKlbYhMMOrc1K9RK/syU2DWulOyY+XErVvDThDaulWxeOl2tTVOrF4uvRlboqOD+PntnSjGmlg39VVcT0xW9CRr5tssH+GKz9ie6jcgbm3+nWgMRXs0xpR6t59mhFpi1FIhaAD5txQxUZ78Kzeedf/a635o3CSK5KzrEPZDtmrV9u86YBiyhafmGqwlVtSOadfXiNYl67mfVHGh5iZKQsik6SryEOwiFXdYzYKlld6nKcdlHbLWmeD96rkba5AQrHWZWAFgZsUSUuW9CiUw14avixW8ZbFWzAm+nCuL3epzsL8BuwxXfXQRhjC31Ons47T/ez/4x+bXouHTjUayXisQsqXRmQFUkSyGfeuS5ZZoQU1i+oGsEK1iW+UetESr27KVJnVBuXQk+Hww1gOOg1J3VjC36Xhzjf7+HuPNNdxuwnBrJeRHW96ASMAuJVr6WtSIFlC3ZGk3m0+f7OJ1yIKjqLzhAjJhV61ZFoeIliZZehsmiER1kgXMg9kToRI3X0eHz+Gy/tpYMRjLGceJbKIbUyocKOIbegeaPKbjHm4Xyx+5Kch9Rep3YKsn99Xty/gxGqaoL3SxywRpKQ7mEMnS58iY/Tbq3I1yfEGytAuL3V9AGVNVs1JdlWRd1s8D+xfWJSYE/CyoeCsukyMEy7qVYSxK6lwswYrbGpJVI1hLFt8KwZqV2HHz+3KmiWWU3YE8NsrL4TDNCZYNC9DPiyFYVXLF3y3BMoSM+ppLs36Ndbbke37mu9DwsqGRrNcinv3Sb5f/ravH4qDcAE+oen8Tq1UQrkSwfMdWrNJaVoiEDuUAWJCAUG4jAp960jgQ6gEgK6FDuZiMy3P79BHWd1LRbZYlqAYTc6dT20PpKqwRKxGJZcuenriMGr/ezrp3ySq+a9iMQ62Jc8BFVMSYHfgOYO5+4d+/NhHL9alYAW1/akG/bCnQciOAxEl5JfdQkGypz8mxWak7iQDXfich6yYD1D1INQs1WVpSeQfmLsOKTEE+aOnSqULHcXHw/EKbRWkY83vMNKuq97WydPD/lrzUjl1x3836Lh0xE75zM4I1I1fqGLN+HRJqZXIhxavd/Fpba49qa7bOvmgAEizO8gd8b9bILRd6hz5fGwYgLkFD4GuoFfyWdpUXgPvbm8xHSzJVn9/zc398+bgN14lGsl7LePZLvz0KP0rxUrOBz8ukOLXejq0gRKVbsfLb+1UHN3pMJ/FYlmhRAEIX1eYBRVR4Lli7GEy/dnCjh++ckCttUYpB51T0V+rq+bKWna5AD0D0k8K6B+1H+OMVaDdhOl1JX/zKqXI4fM75enE2YxQVDfMSGYpUkZ6EuC1FFA6RLACi7k41PR0gT3Ym+H62nR5UQ5KhsGKhKVhevrv5ZITOzUiWLt5MIYvhzlxYyWrGIrkzcEAuIAK6/mgFGjymG0nPRwd5+6B+15JkddsJft2hP0/xYXoCkvtOWROUy/dSkqU1sRzNJ/slklUhWLOCx84hjJNMkmLF2O3mwezklIvOQRcUnmfUzYnWzFW3KAdTJ1lCsKz7KnY89m+aQEonq0YgZrUQ88XJgf/sui5Wm+tuCRYQrxW/cAiROhCHpaUiZFk+ttT6A7IyuiZZKTxD4hNtEfYQyufuYQiWLtukyaCJD8xu/kQwlcp+0NuEaPVr5OoVRyNZr3U8++u/DQDKQE09XimipWvo2TgsYG4RmpEt9vUjlqMBIDUTY/maDm7wipiURKuwoBirkVglBhUHtRBfNOsTg5SLiz+Bglz6Iw5iZbN82R8+h6JvYn2aZB/ieDhL2HRwrImXk4lfBukcRD6LzzIWRdLZiTWr16GYE7sNH4YHaT2wMwEwJKvckQmHL4mZOucq0Urb+VTixx9FVXt/3MfrM/mq1S1bXtOH/V24LJJYIP3sXIUknyeSpa+hdteaTMIrWbK0W9CVmk323DWEZNkgetfFZazyrsEkS8fbWOmXiotvltmnytxYmYWDKvTJ2hISEXRKr2pGIpT7UI4rG7M7uS4kWvRDnR/x8WoB38myNbNc1QRmrRubKFuxLMFS/Z7VI7QES2egDimhYhaj5fM9483vW7y4ZOIu7kJNsNS5zdyEAN7z8987W9bwsqORrEcNz37Ru+IAptOOLSpB8GylsOvzdnai57bS13WcMNlqxJNlty3jjiR2Sk+cHP805HgGITQzN5S55VRcTwEVnyY6UMiEiwfQ6XiVBtjyOvmO4uA2plqIUtxbqaAzqUvH4X5ymZ3CAmXj5UIWBwQgb72WbEkMSOFmStdJZz5qqQYfZu4/3SZbMOP1MG/56c1e7gvrorQWNU4R10QLmMtCJEkGjrmiKcVfpd8+rFwSyzX3Xoj3cHc2SGxMdzEU19jtxuI35pcBOYdpkqxIGsZyIuTz0J8hxImRY2L0tjq2ylhPgAULir6+vK8+HrLlbFEiItXpC7WYMC1JABSEqTi+OV+Oo9JWsuIcFyBWsvW6iHfK18AQqwUyWMSioUKugIJkiktSETtpByjjrWryDNp6pfoVVFxiLEODeH+ZZ1ZeHIyLP7v8QyTHTHbl91HX9dC86thqRuX58DnJ+dWtk+/+8Pctt93wSqGRrEcRz37hO/MX8dfzZO1nwfCzuKwFGQApgmqIQ079z/v5Yy61kW8RsTxYooXcbhFQKo2pid60KcefTWCqXWP50RpOkiWZ6uBJnJnuF4e2KCudkK3ZxvmZml0v1S8b06XjOqiW/r3k5qm5ICqukNyp0oJZjc/SgqeW5FrXpnKxFOduRQ7XZdzIjEyhtH5leYbU3S3HsE2ltRCYE3JA4r3kOu/GbDm051AJIJesvxDy5GeC1w+RLHYPxs6byb5GsmwANDAr3xN00PQB6MD04vgiETDC1lssG6iTrKA0nGizWdy9qDWojluIsVZj/kyflM7XIsFSx6Gqdcvcm5Ui5zncgmZF0hcJFtRzqmOy2HplCZa1WFksEayam3fVz5Y1gvWqRSNZjzKe/cJ3zszyYdVnouWxGEO05H4qLFp2LHaQQUGy/CTGJ5OsuEFIcVxUBFmLxUsFzgtJYkLC7kBkS5UN3C/ie3TRYGXJkSw6QKrST0d9FmFNdRClWHVAdiX66B5gQU/9CSL4lBEng6Z1NQIqSHaBaC2RrDDfvpj42a1rSVbtmebfh61RyjLFcXCyL8elsFsEKLMTzbWXeyzdF6F3WWsoXRebIAEkcupICnaHzqG7vxOh0njcuWWmaEORLK65SPthTrA4jd5aH4BMcmrXXlsLAehYoBnJ0WrjnE2o+xDYBcjuZEOmHJXB5IZkaZdfcdwFCMnSbitZaa6l0qBikqUJ1uy4WiTT6GBhmubLGEWQd0lmC4JlCe4SwbLxgnIcY70CypI5FLODJRwAJfkvnlErycDyHNr968OyS7BCdMlaoLUFtJIJ3MjVqx6NZD0ueO7zvlX+LwYY82bH8TKzotUorR5WpLMAx96IGCrkTiH7hgdlAePmVZOOYyBEa0qRr5pFQNfhUn3RfZXyMjqw3mS8ARCX4v72ptjfjSFb5bj8D497+nLYQG5gFkCvz4kMeaoWjdaQmJ4Dlq9aZtcBK4LcG303rzZQs0LYos62H0BhOZ25pIvfjn+PfD0lVm9fEh5NkGvWS4n52415MhRLVgpEVuSgGpR8yPpgU+4vITYzaFImpEpZmgATNzbvy8xaciirUe0fdKLA0j6KALB70NWsSDVJCWt90X235Mq6VO32TKL42IpcCZlcKv5s2+eYK11uBpASZADmbnKoFyT9XOq4RCDfU4W7n83WB6yGQKlGX5xj3fX87l/8Ewfba3hVoZGsxxHPfe63AFBm8ooJXchWLaYLmXDlmn++sAjomJ9oJQEQsqUKLpdCsSrzOZ5JuRo12fK+dAeqgGUr45A3MmTLKysYgxMChHDEz+HWJl0TB99Tjs8aAtzkU1uh0POS68ITeSpuW62DyOel+6cGaxonKaGjS+kU57wf8u9oY7Vq4N/KTHKBrV/8+6mEiiJjT7czTmUaPFvA0jHEesX31NLY4pxYSsXStR0A50C7obCW6fqIQpqV5U2sikDUxALiJBkCME2Hg7tl+XR4G47ZYisVECfbvleljMZy//VKWch4ck3bqYxCANnKpoLUgWypWhyjOcZKg9tgsq/WBx9KsmX0vWSfVV9aybQ0ROpPUfpHP5d2+5olS7kHdcwUrVcmztBFYmJJlr4exi1eECznygQPbc1XcXwAimeUa3YSl8BhsqUU/IOyXsvl5N9LlfcJk49ZpiHkeop83nL+ilj90g+g4TWJRrIeVzDR0lk1h8gWpfR8ydrTQdk897IrUUFbvySGhgmHTtPv1OTpqCQsohiviEeybNAUZgNjEWtmOYZ2adVCT1RGoli4iOA3vWRUjiccrxFEcFXcXtp6ZYmWtsJZy1atXI+2UNnnUZEkmqJLTWKOarUPa6gQrXwvKNKUiNYiyQKkfmDh+tVuwxDEHTNrQ/qa7o+LASEFucvvPFR+W3OcapuTj9clhEiyvK/HP9Vgi0Cze60Ss8QTaJw8+7y9tFVam8Iwxvp8arswjPH8hqFKYOR8D5Es+9tXLFiWYNllszI1umaetW5X+jUTGTXbkwl4P2RZLdyAfY6dIudKCYd8gNxmxc0WxDWoLPYqSQJQ44hP//tMpA5JNNjrASD2k4mUEPDU/qFSSY1gPSpoJKsh4rnP+1YZoGSitdksPiAcrRLBKt1yNKVJlC0JyoKiSVhsv9RsKgQjrasRaQJXLiTW15IJWAuucpaWiSlbDO7XcVrpe+g60eYCkN90fSQzHBz74I1HCAT024BuF/uwOuM+RctWViOn0pKFkpDO6p/xdpXac0KqJnWt1Tkc1NSyb8ym7cKSx+2ytYYnJta8Ssec6a95lLFuyL+RDlaXYtArjp9icmncp3xuTPQ1PKI7UJMEQ55EtmEcozvH1oRbyqzjOClde1BtO8uC0wWbdUySvr/UdrRel2V1DlisNFmpxV5VZQLk3wqRQsWCVYN1delrZaHVypngSfxZKOPVagRDvdxRl0iU68pgcL1fYY1U1jPd1qrPUiUA0DlxD87c4SHUa8FOU36m5EUmW7gKollYxtXLKz8zSyr1Co1UPVJoJKuhhLgSdXxNRcsm2PIn6n9x1XlInTlt1RHXl5mAeSK17QrhYhcSl0pBhWixKR+oxjTMiBOfoz0/lYEoAffs9kpN7F53hP0TsW9dqpV49OJejlEEdS+VDVJutVkRZutu4VOpTHLivh3GmNww+XwdJMjb50nyUKyWnryVblX+3eaWz5nVULXF98PB4trIJKvmCmT4k3V2HfI9sJTpmc6dtvtI0HiCrFhoqiRrieiiQrDSscQCpUQiZR0MYarJKtQsQ5VjzrWktDXncoJ1GQoCdtVMxFqhZlvY2MYdAdlqpe/JVbTyURE/Won5s+5I9Rk2Ko5LB7cDRXZrkRjDCTVKpoHGFLDPlmVDhuNpmrgqoC6jcqBkUyNXjyQayWo4DHErQlmndMaLFO2tDJ6VYNLC5QhU3Y8Sr2UD1bt8LBs4XkgihFDWEKsFkNYCqNPyGRGruccIxUC5ezLGbfUXE3ZPxsH96MVY0qd7sI99TqKZQCRZrG7P56jjiACALvZpXRrkeYDuXBzwO5ffrPs+btMrXae+y9vpgs7aVaNJBluutJXP/p5sveJrqtLJ5R7Qyu96/9FDajoy2BqQrIdAdFEXyQipXbcdMR2v4EYfiVY6Lu1HQzLiPSDWh10iWWzlxNxKJJYgrWWkC0az5YIn0QPxUjOXkV6m3YZJ0FOOawsBy+kY60+FkNVIlhClBRdnDUVQvJCaq+0rsOeh3YJGEwvcP2357vu4rbZMAdUXDmmfqCT9HHuF6Bokjg2sud2noISCp5JYAfG5S5mV8lvw81YjVVbMmS2ihlg1UvVYoJGshqtByFYI87gdDrD2YW7hspN2gjXVAyhcjyw8KdYdraHExIRdlOoN1O1VZlbNrVHJBpsFv+tlqkDyUiwSw686uGHClPrudtkCkvulmpCB3YvVJhhiR1MoA7f53LT7CUDwvqgfN0MtbkUHbBvSrMvgFMTUupRVWr0EtqP8jQT8W1Z0qfzROpLOTRaB5PthvLkRFzET4O58n68Ru1q1K1ZrGHHml84Ys0SGxUf5k5cBZUC2Ro3sMLSrTLavEKFpmulK1WKuCvfaIZJVU4mvkKylDMPgQ3msqxIsq04OlPdh5dzkftUEa7Uq963cK6mhvB3/XxD+9L+pl1lUwGCDJsddATmuUbsLdTKCrrFoX+Iq41zhHkzXuZGrxwqNZDU8HJ773G+ZxT2EVV8QLQAqm0cNRrU4IL28Moj6o75KtMRawi4mpTQuAoJ7k9mlUQT6VgiXIk+Flc66M0kF6ac2mWwBmWT43qE72xVdCJ3Sfaq4xjTo7CJ/qRSVZgIhb9hA6T7RulBAmRVnn3UdO6LdNbUSHiqtX4ixjs/jy6Vjzuw19B7+KAWBqwmQ2/Mp4aDbjiXJ4va4bZVaT9u8fiYQiZJkCZlS4p+2yPGS63Y2TmqCU3OzaVceW1+7bu5WU9YvmpE1Pz+utpQcKOQc/60TLF5XtWBpi1vtvGxg/ALByueU1qvAdiFYev9qGaNsEYOOH2UCpwkWW7D4luMXAlK1R2vaV1qKYemlxQbW83L9qchvI1ePJRrJavjU8Nyb35a/aBVlawUBshAgD7rKJcSgKVStOUW5lt6J6wlAmSWo9hUdLD3BH1LL1m+n3HfVDlu1FrMWNVkkKtyBvA0NUyZT2iKlB2UbL8XuBiAHcYdQimWyG09ba/h89G/A37VVka+zVZm2/1udIbWscBcmkkVcABjJNWquW9isQLuh0CZj1/F4c5PJdQD8ymF1Zyu1MrsHu5nie0GstpHQ6ush7jlNFLR7UE22wQqRKpJ1aVbfAetPleAcEqVkOJeyD83zUnEtztyTyn1YHFcv67p5v60FzCYJ1PqZ+lp1Da569RLWZ6tXjZjVNNlqrjkfcryVHnOUHIwkxBjrL6AsnhxiANT13szL42x9JTbu3b/8g2h47NFIVsOnD0K4NNmyhViBcuBU5vzCtYRkneJAVHFT5WW5XczlGGrxF8CsvYOoBcQrq9YsYzEtL5CIFVC6FoVA7JXF5DLpBRZD1GRCafTIm3zNLbZkRVQZUoVCuT0f9Tvm9PcKAeOYO6DI5KxdAwlM1ha8tH68sZZFnEDQnSnrlb5uaaIUtyqAsK9coyVcRrIqweszXBJ4rrGoScWLKsQlVNxONWX3otCz3ueQ228psJ33KVyVxhKloaxJhfVN7pe8bCbACdRjrvQ9Von3lOxB3Vannn2lSzeTYUixe8Vx9DL92/XGmsjb6k80V2DDDI1kNXz68dyb31a404Arki0dkM2kQSQhuixwmcDik0VdRta34sE+uQsKCQFN0lxpKdNxUYW0BB+z5k7UqeeKDBbHDKEI5ucyPposzAK49WSs4oMku1Dr9GgxTJdFLWfEiYN1taZYTX4g7pyPTwRdpifYOBS2HuhA9lS+qdC44t+Ts7w2K7kGwTlJDODal4EI/Vl097nkIoxJBCrwnUmnjb86VJi3Rjr3Q07k2A/zbbTmlLUYAbMMxWC+RxHNrvhucZBg6YoL+jkIYUa4qsWJayV0lMSCHEOsSK6IsWKhzcXi0zruSmKXSO5NqpGkWuyVXl77ndK9qIVyJUier1+yXLGQL4BcDkyTI03ieB1RVt/frMpMXW0ZVhIdjVw1LKCRrIbrx3NveXv+UhloQy37b0mpnCeDpfW18iidGUgtCjen+l+Rt9y+cpVo8sWkqzaRaNemdd0BhQXPq+BxiS3TxbL1+VUEEkUgtrBizGPdqq4OjVpcj1bZ1pO8nuxqbdba1/unuK7ppio6rAhF9yBaqArrlQ5y52DlrbJkjSamyvbFabePulZM0nRMVs2NtSAUapXVAWXV0a62BcJUa/Oq6y9VsdfHrMmyaDfakuUTuNxipeOsas+DxiFBztm2dTd2QaIO4ZI5LVTGlKJNbbH6x99/+FgNDRGNZDW8vHjuLW+vutSKrDX7hmkHPzuYLsUw1Up4aFdCDaq+nmTLTSFnPo6+Tr70223NRcdWMYe5HhRQih/ytThey7HcbpD+0MU+pqVvd3myG6c6WeX1+yErt4+TxK8U9RH1G/6BZIQaQYqd1OdbcdHpttgidpKJFQe6xy/pGqw6dHdjHFpxjVTwPO2SJWuXXYRXIllW0R2YWatmqNQTrNY9BIoSKtWg9Irbr5pRqC28+n/Vp4ciWNqKxJZFTVqXXmAqWlA1t18RwL5EnGzguo5FrJSmKWIe9XjRZWFjq+nG/8eVC5bMEKrkSjZT+zdi1fBJoJGshlceung1Q5fjqboOlsQVa8Vya2+jV2iLA7KDmvyrRbKXoCfMHQdn73JGniYieqDnuJfdPlv7lLUoHJliuQDoPFtxCsuWjVexx2IrEAyJYdQyqzQpWLAu2Dgmux9PrpJVaA+hrSqHJBqA7DYd8rkUJKtiabL1+QSX/Kba2lMjckuE6dL2a3FWFWtT3Db1XZ/vJeN11TLVdXO3sm4/rpgtL0rd6GeH3YK1ewYoMlGrcgc1Qq+hr20lAH3J6qRRJVT6OUr32Ls//H3V/RsaHhKNZDW8evDsF7yjvqJmGapkLRaoBAoDuHQS1dsWWW/ajcjK745mJYMAZDV3oLBgcUxRkTI+LZAQPtaqF0tNWK/ENRaOtWtNnb9uOxGRoMoMhU0mNdrdKVmLNuOxZr26ZKK6dLIEZMItkgGW3KKVAOMayQqKMGLRklWJh7pMC8pnEcpF3aYlocxaF2qB1Uv6UpoAMOkPoeq2rCnIAygFVLmNcbz0eBqFlldFa66wZDEJ02KdtcDxeDKVg2VLVTVj+bL9URKuUHuJWrhf3/Pz31vvZ0PDJ4dGshpenXj2C95x6dtsddkS4arpYk1+7qKoWcJs2Rgl9SDK5ul/jD6ruqcC2Dqw251tpZ+cDRf6LtXfU2/3HJAOlEHpym0SjtbZGrZele0ZN6CeoMJmXWZXcnaeJilG6iH0XSaERFJiJ56XubZLrhlWoNcWDRUI7x5sU/9WoO0+W+8S8RPS2Lkc+N45cRMWdQmVqGhV8fwQyVL3wMwVyHFybAViEqGsSnFf495TrmvRxyIqXIlEdNCKJLFXTCBrRMoSP/2ioC1gh6xVyiVJnPDAxyhedFzZ99l6FV+pqxVcbW5JrvsDAfDaKq1eCLi2Z7FN7VzT+kasGq4RjWQ1vHbw7Be+s76imrVUd39o2QUdcK4VoQvBQiYBKWuxaAMoMxmVLpRGUdSYJ+mL7AqkYSxFTmsuzVrcz8NaByoxakXQOrtdhrGMWeH4LV/Gr0iBas4MPYQlC4gig0LyrAVNSPFU3U9io7T1asmSpUl0hWhdFl9VLlRZnJ0rg+UtAeD/GYpEU9/nvi+5CJXlqijtYo9nj3MJagHws2tTi7sqXL+qH0tkqBazqGMvdVF3tbywXi1ZSw8tM/u95x99T32bhobrQSNZDa9NPPtF7zq8gY25UpN2rcRGQbgeYpICSrdbQTZqOjt624prb7bNAiFZIpGLcV5L7WgcCADWx7FESybCJaJVWFNUP/T574b6NksusBrJ0gTpMnchUBKJhYB3svdRbV+ti8XnZJMHKq65gxl8MKSxZrXitnODqq8L102Bln6XGsGCInVLcWNLJGhpLqm9JGjldnv/XpYlq6GJ1Ye+u75NQ8P1o5Gshtc+nv2id9UnNP0/UFhSRNvK8Iqy1t5U7gfM1cllRcj7FxloykLl1ETLk3Hfic5T6FwplKjbpgo5sW/5vM0w5v1748Kx58bgPq/6umuHqFzOXVstWDFqWkT2t1giWXqbGoF0lAP2dYbcOOWMvt2+zOiTmowTquKbUy4eHSafLVc+KFec0ZUSTaa6oGyoiaAqtx+AarwUbHC9tuRx5p6NDVOZiJo81fpA2qoIlNejYm0ka6nSv6eOneL/9TEvExPVL0BLIsZ230qWqhRHB4DJN2LV8GpBI1kNjy6e/Q3/6XyhrfGm/9cWGT146zTw2gAPSGFsGr24B2eB3JVnqnDN2VIiNbcKfweWrVY1XSc98ZoYKgmmT7FStB+K/2dEYGESreplGQHZwm3Ei1RpEy0zAaRYMCu+CpTEplLnLtgYKelPaksTyELIle+BKf9/WWD8gnWysIj1/Zyk1RIydByZ/u2umgGp4siqtQKlQ8ZNV6mdWKDmVrTPifTBEKuaC99Y3WZxfTCxVbbdtP17fva/mPeroeHVg0ayGh4PFIRLT1I13SFGLStpSeQTKCd7LdOgLU4L+1c1oABFwPyyO0+3yTpjuj8GtQltdh6aBC3EKRVtXiWgecEaQYqA6hicQu9oMGr4tWMtkSxlqaHOVeOfJAi9hiWSpQmTVwRZE8CalcjisozXQ33Qx1kqH2StVtpalfq3qI11Wdkb4HB24pLLWiV5FAK6S1ms6hjv+bk/Xu9HQ8OrD41kNTyeKGK6FqxTi1iShLCTUK3dQ8KHuibhUvzVJTpLxbEuwxUmtKK/SwTzQPzNUiq9zkysKdbbfQsCYa+BU0SUoYhO4f7DcszVIsm6CvxUkoileoB+4TyuQsAOZUheBfq31ASzZiWt4SqSD0uk6ipxjgv3YwtWb3gNo5GshgYNIV/WzQWUcSc6LR0oYpe01ACwENRu9H9oKRid+wKULkdtMTGWp0IiAZi7yLjf2uqlt9PSCUDU1vJqn1FZbWpuP+6TjjOqZTYaYnEVMcnCdWrbnBTRscKqS/pWKElXQea09MOS5AM50IEsTyFuunagdhtad25B2g0hsxl4S6ROuzqBugvQBI7b8b5aWNxViLh+HmryJ0txWzoRhV1/TUqh4dFDI1kNDYfw7Be8o5QqAOrSBc7VyVUtC6qWzq7jsmrERAeS2+D4JTcRENvqnAoaN269EIqA4VnM1KrPE/F6lc+9Ug+yCNrXRY1r9SYNUSqIpu0jUEzWhWYXVMKAvl6qxE4M2jcFsbXVxPu5BpWFiVnCNJXZdoY8hJol0occmB9yUefFkjiaZFnCb61Y6jpT53Islj5Ptaw2vs/isHSQu10eG5wT3r4rEyTsby+krGuq6g2PAxrJamj4VPDcm9+Wvyy56ewkXNNNAubWM+t+rElC1LarWdis5YE/rTXI9sm6PLU4pJ7AjZVFCFMt4F8TuUOuTSYkSqcLSAH2NQuKiWWjXcX9apMMtOgrMKvhVyMr8RTrxEjvA2C5xExsZLnNA1i0MqnEiaAtjDoA3vZnSZfL9tHeY0vWRNWnd3/khw633dDw6KORrIaGTycOki62XCi19Nr3qgSEtHkgPmsprse2YwPQa1a2WqyNtlBY0rEQazaTZrDjyhLh1ATuaJ2347JATJp0wL05R9qmeo6idD7mfbSlyWbGHbAMLlqddFmcGlHl315ZzQ61ba1NVHPV8bF0f7vOBN5XXN5L6xiHLKMWiqQ1UtXQMEMjWQ0N14mCdFnrzwGxRbIWoE82KPtQyRsby7VExA6JlB4gW7MC2jpOyhId2zddBkgXxz5ez4RjScesqfa5zJC0r8nDoSzRq5KsCpaCyBdjng7BWplqblR9LNvvpXgqvdzuY2O9NPpSouPdv/yD9e0aGhoYjWQ1NLwa8Nxb3p6/XDYBW8uTVZm/SoYYYymrEIjt1sjIZQWiK98XyVfNlWhcU7qodTgyQf2KcFnl/ZkVbYlk1frilayEip/i7wUeouj4zCJ16Lo9RNHpmevVV9y0S8cBmkWqoeF60EhWQ8OrFZcSryUVbGCu6P4wGladm4ufLsk0XIUQWtX2Sr3Epb74k6NYExKAPymtWLE9redVZuMVBa+5XbamOZoTSEvuLiM5NhZLx3OtV0UQfaGaPouLMpmqs1i8CoE6hMIi2M+tVY1QNTS8XGgkq6HhtQZxQWqVeqAe33QFS9GimxAoZQO4vSVdJetqmrnhTGD/OJZyE+Z8wslR/OR4pk3pPhNFfVZZsLINZllwNN9mqbwQ73OA0JAlMKvVsvJ5zfpnidVVZSb4+LU4LXv90/dGphoaXhE0ktXQ8KjjuX/um+M/CzFPM2j5BY2aHMWSq8xmMS7uv5BhqF2ETFCSBSysU+mdi5Q9yOdSUc2f1YJcqg1ZQ5HBWXGVLsXJSYzYJx/bBRyO23r3R3/40v0bGhpecTSS1dDwuOO5X/efzBdqvaNDsBaamjWNNaxqMV+1ZVZMlWgxe9Eeu1oC6JDlTvfb9sVa8fT+enxc0NZ6aEkGhUaiGhoeCTSS1dDQcDU898Y/PF9Yiy+yY8eSVlTNlVkhHFYZHkCdTNXGrBCuVhtwCUuSExUr1VUyCBt5amh4rNBIVkNDQ0NDQ0PDNWCRZPVLK67aQENDQ0NDQ0NDwxwPWd69oaGhoaGhoaHhKmgkq6GhoaGhoaHhGtBIVkNDQ0NDQ0PDNaCRrIaGhoaGhoaGa0AjWQ0NDQ0NDQ0N14BGshoaGhoaGhoargGNZDU0NDQ0NDQ0XAMayWpoaGhoaGhouAY0ktXQ0NDQ0NDQcA1oJKuhoaGhoaGh4RrQSFZDQ0NDQ0NDwzWgkayGhoaGhoaGhmtAI1kNDQ0NDQ0NDdeARrIaGhoaGhoaGq4BjWQ1NDQ0NDQ0NFwDGslqaGhoaGhoaLgGNJLV0NDQ0NDQ0HANaCSroaGhoaGhoeEa0L/SHWh4PPA0fVbYYx+/EIF4xfwfgPT/tfXmu93OrKouO9gGEKrtzLertR+q2yztC4Ao7nNwG9P+Fbcttn+YPuHAeVyhnUv7eNmxH+a4i+vCQ/4OZl+1vNoM8UeYrzJtFV+L9kJl+9ymvU2L5bI+qPVmO9nX7jc/btl27jPN2g+zdop16rro01pqXx9jqf3ifGttEMCjit02/q/X5fHn731w994QwrNoaLgmNJLV8LJgjz2+2v1OkCOAnHzC8YhMIOfiqC+fBKJkbHUUl+n1lPfN6125rVkfiKL91qy3y+W7Xk/pf94OiQykdbyPbKvWx894HvJ/ZX3xHWmZq6wr9p9/xnVULputx+H1mC/X66/SdnX5oXbTZFvd364v+hDyNlDb2vX80xXbx/+FTPD/lLclUuSB8vaUvuv1Tr6HdOsFaduhXKY/8/r4vfhLZKO2PP7v83q1rJPveX2XvjsKab1ex8s9HNJn2pf3y59e9gFQ7oN47LgN7+/leB3vn86r43ZlXSjblu/c/7Qs/dwdAR0IDkBHBAdK3ymtJzi4uJzifwDQvf4XnkZDwzWiuQsbGhoaGhoaGq4BjWQ1NDQ0NDQ0NFwDGslqaGhoaGhoaLgGNJLV0NDQ0NDQ0HANaCSroaGhoaGhoeEa0EhWQ0NDQ0NDQ8M1oJGshoaGhoaGhoZrQCNZDQ0NDQ0NDQ3XgEayGhoaGhoaGhquAY1kNTQ0NDQ0NDRcAyiEed2thoZPN4joZwBsX+l+NDQ0NCgchRC+5JXuRMOji1a7sOHlwjaE8JWvdCcaGhoaGET00690HxoebTR3YUNDQ0NDQ0PDNaCRrIaGhoaGhoaGa0AjWQ0vF/7rV7oDDQ0NDQZtXGq4VrTA94aGhoaGhoaGa0CzZDU0NDQ0NDQ0XAMayWpoaGhoaGhouAY0ktUAivgviejDRPRBIvrnF7Z7MxH9JBH9AhH9L0S0vsr+RNQR0T8gor+sln0fEX0obf+/E9HttHxFRH+GiP4hEf0cEX2b2uc9RPQBIvpZIvpTRNSl5d+Ytn8/Ef0/RPTF13CZGhoaXiYQ0bNE9I/SmPKuyvrFMYeI/jQRPZ+0+ex+/3Fq92eJ6HvV8i8jor+Tlv9DIjpKy7+LiH6FiB4s9PP3ElEgoq9Uy6Y0Fr2fiH70U70WDa9tNJLVAADPAfj89PcfAPiTC9t9D4AfDCF8PoCXAPz7V9z/DwP4ObPsxwF8SQjhywD8PAAmU/86gE0I4UsB/CYA/yERvSmt+zdCCL8RwJcA+Iy0LQD8uRDCl4YQvhzA9wL4gauddkNDw6sN6eXpRxDHlS8G8G9VXpwOjTn/A4BnK+3+NgC/B8CXhRB+A4DvT8t7AH8WwDem5b8VwJB2+z8BfNVCP28C+EMAftKsugghfHn6+7ornHLDI4xGshqAOPD8jyHifQBuE9Hr9QZERAB+O4C/mBb9GQBff9n+RPQGAL8LwH+r2wsh/FgIYUxf3wfgDbwKwGka+I4B7AHcS/vcS9v0ANZpW70cAE55eUNDw2sSXwXgwyGEXwwh7AH8ecQxRmNxzAkh/C0AL1ba/QMAvjuEsEvbPZ+WvxXAB0MIH0jLXwghTOn/94UQPrbQzz+G+FLXKlk0LKKRrAYA+BwAv6K+/2papvE6AHcUMdLbHNr/hwC8A4A/cPx/D8C70/9/EcAZgI8B+AiA7w8hyIBJRO8F8DyA+8iED0T0HxHRP0Yc9P7QgWM1NDS8unGV8egq21h8AYDfkkIe/iYR/Wa1PBDRe4no7xPROy7rIBF9BYA3hhD+cmX1ERH9NBG9j4i+/rK2Gh5tNJLVAABUWWatQYe2qa4jot8N4PkQwt9bPDDRHwEwAvif0qKvAjAB+GwAbwbwdiJ6izQawtcCeD2ADaJljZf/SAjhcwG8E8C3Lx2voaHhVY9PdTxaQg/gSQBfA+BbAfyFZKHvAfyLAH5/+vzXiOh3LHaOyAH4QQBvX9jk16USYr8PwA8R0ede0q+GRxiNZD2mSJaf9xPR+wF8FMAb1eo3pGUan0A0yfeVbX51Yf9/AcDXEdE/QTT5/3Yi+rOqD98A4HcD+P0hC7b9PgDvCSEMyZz/twEUNQ9DCFsAP4q5CwHpOF9/8OQbGhpezVgaTx52m1q7/1tyMf5dROv602n53wwhfCKEcA7grwKoJv8k3ESMC/2JNLZ9DYAf5eD3EMJH0+cvAvgJAF9xSb8aHmE0kvWYIll+vjwFi/8lAP9Oytj5GgB3bRxCIkF/A8DvTYu+AcD/kf7/0dr+IYRvCyG8IYTwJgD/JoC/HkL4t4GYPYRodfq6NLAxPoJIxoiIThEHsA8R0Q0V59UD+FcBfCh9/3y1/+8C8Auf8gVqaGh4pfBTAD6fYjbzGnHssFl61THnknb/EpL1m4i+ADGu8xMA3gvgy4joJI0t/zKA/2+pkRDC3RDC0yGEN6Wx7X2I49hPE9GTRLRJx3ga8UVzsa2GRx+NZDUA8c3tFwF8GMB/A+AP8goi+qtE9Nnp6zsBvI2IPowYo/XfXbb/Afww4hvhjyeL2p9Ky38EwA0AP4M42P73IYQPIga0/ygRfRDABxDjsnifb0qp1+8H8DZEAtjQ0PAaRIr7/CZE8vNzAP5CCOFnk1TLN6bNDo1Z/zOAvwPgC4noV4mIs6D/NIC3JGmHPw/gG5JV6yXEjOSfAvB+AH8/hPBXUlvfS0S/CuAktfUdl3T/1wP4aSL6AOJL6XeHEBrJeozRyuo0NDQ0NDQ0NFwDmiWroaGhoaGhoeEa0EhWQ0NDQ0NDQ8M1oJGshoaGhoaGhoZrQCNZDQ0NDQ0NDQ3XgEayGhoaGhoaGhquAY1kNTQ0NDQ0NDRcAxrJamhoaGhoaGi4Bvz/K+gtEluTx44AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "m = hp.read_map(f\"{dirname_out}/colore_custom_s1.fits\")\n", + "hp.mollview(m, title='Custom tracer')" + ] + }, + { + "cell_type": "markdown", + "id": "012cd628", + "metadata": {}, + "source": [ + "## 3.2 Source catalogs\n", + "Galaxy samples are stored as FITS tables. Below we read this catalog, plot its redshift distribution, and maps of the galaxy overdensity, mean redshift distortions, and mean galaxy ellipticities." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bd3d1ffe", + "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" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAFyCAYAAADGe88vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9W6w1yZUeiK2IzNx7n8t//lvdSDbF5kXsZl9kSYMBDBh+EAwYhg3YT37wk+0HAwMDss1ujdya7mmN1d2DdktNagYGDMMwDL8aMPw2fjQMQ7AxI88IkvrOJptkk0UWq+q/nNveOzMj/JAZmWt9a2VGnlN/sS7MBVSdP3NnRkZGxuWLb91cjJFWWWWVVVZZZZVVVnm14j/qCqyyyiqrrLLKKqt8GmUFWausssoqq6yyyiofgqwga5VVVllllVVWWeVDkBVkrbLKKqusssoqq3wIsoKsVVZZZZVVVllllQ9BVpC1yiqrrLLKKqus8iHICrJWWWWVVVZZZZVVPgRZQdYqq6zysRbn3P/MOffHzrkXzrn/h3PujY+6TqusssoqS2QFWausssrHVpxz/wER/XtE9N8noteJ6AdE9LsfaaVWWWWVVRbKCrJWWWWVj6X0jNVvEdH/KMb4rRjjkYj+T0T07zrnHjrn/nPn3JVz7lc+2pqussoqq9hSftQVWGWVVVaZkP8WEW2I6D93zqVzjoj+KyK6IaL/HhH904+maqusssoqeVlB1iqrrPJxlSdE9H+PMf4PJ37/CQNfq6yyyiofO1nVhausssrHVf5LIvp7zrm/S0TknLtwzv0P3IqsVllllU+IrCBrlVVW+VhKjPH/Q0T/hIj+b865KyL6YyL678QY40dbs1VWWWWVZbKqC1dZZZWPrcQY/1Mi+k8/6nqsssoqq9xHViZrlVVW+USKc+4/I6L/NhH9H51z/5OPuDqrrLLKKkrcyryvssoqq6yyyiqrvHpZmaxVVllllVVWWWWVD0FWkLXKKqusssoqq6zyIcgKslZZZZVVVllllVU+BFlB1iqrrLLKKqusssqHIEtDOKzW8ausssoqq6yyyipaJgMkr3GyVlllFSFf/Z1vZq9pd5Ha3bK9V9yERdcV18uI9bBdvueL22XPdtt2WXk3Jbljvp5/9fd/fVF5q6yyyqdbloZwWJmsVVb5hMvP/+/+mXl+86wQx7HUw70+l+cmwYubmCqC3OgVNxNABW+PeoMYK/sZsYDzE1WJO6h7mNiETtzvTht52bHQ19xAm1Z2e3333/v37YesssoqnySZZLJWkLXKKp8S+fn/fQ+iMqRM2QMcN3FdYqjaswUsUNlf086nE/Q3BblMcf7QlREq+/eE3wIHgRNYrbjpymrO8+8QN3ec3uYu93G2XsO9zbL0iysIW2WVT4SsIGuVVT5p8qVv/CEREYUTe/gVl+NKbo3wBFqIbLARGLiw2CG3G1GYZ0xMe2swN+ycMwBEsWfnMrNJnDBiiD2AEb9PYChfd8+bApKRgaD2VBfiD+MF7QOjEH5LTns4xe4l4QzcFKuWZAKcubqrxKqmXGWVj0RWkLXKKh9XSWDKknASBZhCKQ7Ti3JzHgSQQolVFEAKxU+ouIg6oOUMsJXENU4CK/XwmZ/KEVBN/T4rYQRZql6tBFgo7WkQAEv9/qCdBHZE9GoBF8ocAGvcALQsWcHXKqt8qLKCrFVW+TjIl//ZN4Z/I5BAwBQAw2yfMWbqVP5WXY//vv68Bk7chspZhuisLptd3T2j1mimBaNvdyWv4SwWgiyuLjRMrai8GU8eHxnMW1Ijsro6Q03J27W41cCD16sFI3rPzK3aLU3+RkRUP9TtnN4/LlBpjjcZ0ytnFrEpOBBDYAUgTX0f9vN3/hcr8FpllVckK8haZZUPU778T0fwhMPNH2nyNyKizfPxJGdZhKrLWKg5CLv5Yi1/ZODDnaGh9liYZ1511VZed7je6IemMm/GxdsdwaidgRjLDqu8Yu87QYbtX58GgtzA3QJZQtjMVV6x9zaYrsCAjao3KweZNA4YLdXj+FB2DzJ1HBxZCDSJBZA58OVekvy84czgX7AXQazGAO+3fuPXpuuzyiqrEK0ga5VVXq0IUMXFAaiC3zig4hL9tP3QlCE4UQ+upoDGjLrPT4QsqLbNYnDFpXxp0zUJrHBgxSULsgy1ofIiTM/KAK5yQu2aAFeY8FqctOvqm8LCREvBlipz6pvNAa852bYSbHEpowRaXLwEWlxW0LXKKkpWkLXKKh9EBjWfMRISc4OLfwIY1aUef4cn47Xb9+Tvc4t3Alz7z0jWyfX2OnECPO2+1wGn/Rc6BOg38rpwyZDcCZRxYEbtAGRcr+K0bMNS/Tcv5G8tM+T3R31f8m6sHwLg6C8VQGQCWFmAyzH2ClWZiUGc84BEsOXZM5qZmGEKcKWGSbq7qWgWqT8B0HSNl7+LH6N8RjrN7MyiYYeX7LmQlUztYX2n9D2+9b9eQdcqP/OygqxVVpmTL//BN6bDAezJRDy797q/+9f08Cj2juoHxrDpT21e6vJuPtvS9l1N7STQ0QDoiMzAZvcjyUjsP1+P4RWIpo2mLSNvR+aUkYKFWuDP186cJZKdlRV7K1Q2S9Sc9mpBw2g/+jhvHJ5eZ8Lw3e+N9/XptwnANgO8Cgt8kA26kgdnAPJI2Kp50jZa3DET2nEAk1Ohvkpd+SGY6lSfMMFb98ffGuA1uGm2zxH95T9cQdgqn3pZQdYqq3D58h8Y6r5+7Sn2cJ6higSsiEZwZXnRDQALRg4HVzeflStTAlgYST2BqwiLLwdW+8+DTRYurnOeaQlo4SX9MUZi5yBL2Tb1VSxB1cTBAVd/8sU5gavhnh5kzdovoSCGWgK2PP726sEWhsjgQAvLVd6P/Ltjc/ftqpi7BaBLRa6f6yOpzfm3Z4DLwb3pu1qAfAVdq3wKZQVZq/xsypf+cARTfEHnnmJTi+fu3XHc1OfTzxCMVf9PvugenkgwxRckbvfSMpARmIFzcT2yW+0jVnFe77nUNdwDbcozja/jbMHmsbas+FdDsdzYfcJgn3vy8TZvJuKAEREFHp29MoAr//ecFx+/jr2HYyiAqxMd7x8z7y36DruMq0+PjIFUrJVVVTzPQSYHM1NhLqaqu9Ssq6+jcDAAL0auckzqSyK5ESivxn7LQ4lwEMvB97d/bfV2XOUTKyvIWuVnQzio4uJa7YJPNA2w5mI8TakBp9gMKxzBlIRNEKCKS3thvADRNMCaips0wVhMgYm5nIJWO02Fgmq30WzvWZBlBQKdunwORFj3NE6ALC6mWmwObE2988L8jkkmY3jNxA2bFKu6d7WfD7btl6u9adtFRKadXHlVmDHb/N6ZqmSiFXSt8omSFWSt8umVIZgnGvv2awCCqylgNRUlnMdL4gtFiluFMavS/YenYENV2KodN6HSSs+aXMxELCb272SojgbT9bTBtDt4pYbzgp2ymSquLkzleguMRDIX2aQ24559fNGNJ6wNLSTDACOP/xU5wBzy8VieBM72SkwG39ygn/+znjgPfavdRnv6Ta+CWr7+fmG3xb7jVB8aWDxUPfbx0ZRqMBW5LCc3xeQMwdWsJxPhIohG1hFs4BKoxT6fhq4HrXdiff/yH6wqxlU+1rKCrFU++fLFf/6HJkByrW10TURUGOEUore94dAgOQkP9JnkeBHNMo6P7CjrrrYX87AL5uIft8EGFdGZoRncvrDBU+Ps4d+SaTDjj858ruldRjZgnYq2HspIwYgO4QJRM5EnMZ5mEjHy525biq1GDXGqfwQ3zeoZ7zDZBgaoDJtoPjMWEyEhJkJ4hO1UOdNT8hQ7Z4aHaOx+Gcuo7KyGMizmaYrKs+py9NPhNiyA7qMZVLY9DfRX//N/YJezyio/XVlB1iqfTPniPx9TzvAFXUzSGYCFKpgEjriaagoYcIB1vBivFzY3TB2YAJaw72F1FTZGbBHjEdn5gsVtYYRahS2Ybj+qF4UdDV+w+OulxZwtgAJAuAnGrb+vZKo0bmc1B66GfzOQJeyyloCsCbZm+JmFr+BgK071FQ4iloAtThxOxNZKYEAAbf7P/lNN2a3x82E7VQb7xuzdJuOHLQFdje6vvL9xwCXu49cUjEnk7TkBtEQdc6BrIoo/D4+xAq5VPkJZQdYqnxzhwIqLuYhP9EzL/qo4ONP+Zw5gcWDFy7HsrKy1xLVOAqskwUlgla43dvJTNismA1FE23bIAibRTcQ/inacqVYCrCTtNtoR1CfqbeUenARZ55nkzEysAKux9RJkJZla1A2w5SbCU/jamQFMi1tv54yMZAZftUgg1wLISkVM2GZN9QX9rBnAZfUb61RwNitWRgG0hrKDswcHkRkodRJwWd994tIVcK3yU5YVZK3y8ZQv/icMUPW9TNn0JO9xI6Yj2nCkro7XDqpANGUx1GOJ+UIGLC16uLC6xunF02tGi4gonAYV8DEbjJLXG+NzpsXLVIfZ5SqGqnHT4Qmg3Oq6u7c+kz+UtxrApm8TIAfgwIhdy3rs32hVWwxMFq8fLtj99/NouxaJwnE6ibWQ1CZzYQzS4/rvV4C9UbsLRBaIOhrG3f1zVLs7HUKiPe9DeKgy+r+CCXPmNRhCggKpdEt01cXWUEAuku6jaUwCSBpstzCeVxHIQbmh7hoLz8fEzDocZ1738zRnYN7P5HDA2mNNkr3KhygryFrl4yMCWDGx2JCpIIfO8hSc6KVWWhoFztK1BsvS7qLNJlm78yJqEEXTbJQFsOIm2EzLRBGW7cxSgNWdm2APPuCoj4X9TSojECsR0f4tg4myjP6nPAJPdKcIh4UgK8mURyaIO3jTJq81GLnobXZxylsRAQMRUfNouW0aRbtPTKoTjXaL+8IGnFaVA6kQD0RE8YHtDesrm3G0JBrBcq1nEdnxzaZSUq2Aa5VXLCvIWuWjlxRegQMOHgIgsUEcAAk2iRM7yXOQ26SwHXFawHgKF/ks7rHV/2XDhLveC4A0MErsYm4jwwBWTOoetqZwRkEAm0RIGSljhD0MQy3+aNhriTKNetPYNhzA3hdkDWwVW8w4q5eqwG23dj8Z620CK97epdEeDHhFxlQ5lirI9d8k8AV5AUs1SAZs8TQ1HGw1F10dXKZfTnkqim+S+vADZus0F4iVyPxmov9sdHuKaxngiszWT7Sd5ZnITQq5HWFiInm92bVJxRuuxw4kvi8Houn7c+DFWbyJdhwey/poMif49tdXsLXKK5EVZK3y05Wv/ME3KACJUBy1Cs61ZHbPWJBiY3ztNDMyZZ/T6F1sqGx3estOK054hy2NPRQL+36TYZhIFeMOXjNdjdEGNEHuTNTBYkpMz8dtNNkBiwVsd8bzyQ7bYL1r9NFWmxov66ZCWljiyLbJ+oCAyxkMSzxvbHBm2lzZLJEVnytMxBFTgCuQbUPVOhucWeyqj/Y7WJ1u4h3McWMl346kwoz4bSsAl3g+vsPRKzbQBdt+zgJdsdDqWte6NVzEKveRFWSt8uHLV1iqGg6wLC+/YdLjG2QOylKcIr47jfp3LtzYPQEsYT/FnsXVgumaOOURxtmnflIX7ARDOMNixh9rLeiWtxhnxKzdemO0BS+Hr41GPbgkoMWN0Dn4SvZnOZDFmcRkp8UTYotYYUZCZGH/kwNZKcaSod6aFN6/hJehYcvGX9VqtwzYiueNvo4zcem8wSry8yJdDfudM1rDM9N3nog8P4A53owcXBnpcgbgw9+DM2BpTHJkP/H84bnFxHceWDHG0DIHBgG4nB4n3HB+YGgt1o2mgVZ3D79uvH8FXKsslBVkrfLq5StG/j9/0Ea+yYONA56kumvO5bXFrTNCLmhbqc0LouZMnmtONFM1ZZPRngRtZD0V/8fasVubfSsmlTVyQv8siwgwPQP1ueKgPdtcywx+oTzBZCSja74A9fgAPf/Ka6cYSfI6N2Gzi+ocEdHhNWNl84ZxtaOZaQpk2ypjaaLOi806bzKNjYXoDJma+RBwWbHL+jaP1jdlzx/UXIZxeXEFxvUn0WSgMK8l0QS4Z2XLi0GVSETu6EdDdrhWycGr867Wc4ELzkxabY4F4zuHY2F7QaIzR3Q64GlflgxXkn6TxZn2oYHoW2vexVVsWUHWKq9OpsBVkjSx8sksAQJuF5UAVsF27mmyKw5j2QlgbV6M5xLAEqo+vrE2wFXLo4dzNiUXXLGdWATJZiJynn6WjZdYENO1E+BquEzYd/XnGMjidRsZD82GcScCDrKS958AWZyk6UFVw56ZztUXOnaYyWDxV8yBrFRhBgb4IsxjM90VbJnl5GY9DrRmQFb3nGmgJcCAwfJwoMVtDGfBFmeNZ9IB8ecI1m+jI8UPgIuXl/ogZ14Ne7PJmFsZwOUYq5W+kfAYnQFcVl5KDu6H+Ym/d/8aUyAryQq2VgFZQdYqH0wsYEWk7XtiGVXspVBFleOuOY8CXBFRH4ldlh9KCa6S7F/TXdKKJi6A1VDpBcCKqJusc8CKaNoOxXi09VwzdtFUHkF0Va+iUoOEnfZmi0VUoM1FMr00zWj4Bmgtb5wAWOkcB1hEPchC1tAbTN7UNIXfxcjV6HyUATDpbkBLhRGYsO1ZKs6yO5sAWiq6vCf17OLKS4BFZNtUkW0cnwVaw82k2ihugh2qAcusogRb1JWlGCUjmrwJtsi2vzNZyAmwhWPL1U6xqF0YF3iGzwOtJCvgWoVWkLXKXeUr/1sGqvruI7zzhnPjZQnkeJbKhttZJY89PnnxgJUp0KWw+TkSHR+yZyRGjAG5umfEOOUfUqBPvkvlzA/PuZcWba5+s4IkponcsuOxvPr4BM9ZjRRDK5XHvfE4I9ift0APb6PkuSciyydvPs6gGd6bw3PZIuUTKzbBYPHXwqCZA6PGA2lawMawQxtAIF8EjbYWOQq5eRE73x41Q2VKKpMzWWkR5+dqT46xVTw3omdejQPLwm32UrexIs9z9u2gma3BTnAqQGeSfhwJtaHBig3R3C2PR36P0e5WpHmhTpxRdU+CvMFmyzhHNHrbGuyWANXI+ppenAY44xiOZ0DoNx+lwSLyOSvNQ3zO+/PfWkHXz6CsIGuVZSLAVS+4yEcnwRVRB7C8kSewOTO6jnFqY8ROak7gGVUU4IqoA1hoT0FEdpR1Q+KZYXNiASzc1TrKL3xJgFkw4yYVEmARdaAoB7CSWPG9rGjkZu5HqItvybTDsgg3i5mzWUK4pojaWyw45W1mMSvOYLJilCCLqANaWZBFE6zTQu/DWHsBsoh6oIXJuR1pL0ej//grHdfLihJvShm1bZbBirlWszkmCLKawBlMmfE9LMClklSTrhsR2bHjqqD7wbbV38n6blaoCgtwGXX2jQRaRB3YwmwG1ZW+dwVbP1OygqxV5sUCV+WNjmRuAaxYarVTu9OTcXFw1IJL/+49Z6qiEGBZHuShivK6/iIz5xtqZA6O2idQact4t3VS7bfU9d+wjUmyea+g4+NxYR7y3QEoqi61iqjY24sugqzoJ9RGPO3cdffcFtK3xNJSN+pnxipK1sHyVBsezO/T7IQp3lBxWgt6utywiwoIIPvFkZ8ve5DU8nyHVnodFykaSNNhxoDo7LARRFkQ4I5eBbON26gAgIsG6HVG0FwLOwWnwJgLbqwHz53Z11f0pUTU8v5qfZeDV0DaGWOMlzlcl5gyGBNonE9Eyh7OBLS11wA+6OTY7qgdb1wkql7kgZY/OpWQPhZEf/GPVrD1MyAryFpFyhSoQrEYEswL6BodJykWUbEw1aUuyzRQN2IuIQBpTkghr7CNqqeaufnIiMztSMcuWmrHYiHACXAl6rDT96Ht2lT5FuhpN3iNPWyrS105zB3oGqftqJyx6C21e5oBR0IMdmsOWHFBkGVNbc6om/e6/KbWDWyBKesaPL84TlfrNNuDl03FSbO8LU0mE1lpbR9lMj9Ln2kxw2CntZg1i3pMWu9k9S2T7dznKUHXOg1yvX5/c14xumlx1GN1BV2fSllB1iqdfPV3v6GATXFwyni6OZFJfxMgQFq83ehJ2krOTCRBVmKgRGyrklQIgVCSmuHajVZJRTRmT2Y1HLRERy0kHHat0+xV7UyWwLSxwom1D09geQtunsnZtr4IarJWIMtY3RKY8uxVQklabeqjTvMXRgYrSSyjYLMSCOOq3lBGBbpcq8GvPzqV2DiWUbIIqU74aqUGyQ6/c3BUpCjhoPJRTJbTxvBFn8A4BBZCwUUFoNrWazYrahsvV0QKmXAQzkdVV1dEYdfVnSRyN7KPxE0wVVsqJ+ZO58REQGL19aH/OnmuUynKS9NYVew2Og1sova2bJ1m46Y2MaIuRl5NZ6ikHZlJq4X9XgKw/Lta9pNE5G9hjBQGGE1kNfsWvjZU7c6YEwPRX/zmCrY+RbKCrJ9V+ervasbKip+DajxfO8W0WDZXVlk4oVSXWv3nG82SWQwWqrKIdBTxaAAAnCSJiILlaejA0NiRBjbRmVHKUZSdS3AKhFmRvi32yoyqjt6TS22knFYT4nXtNiqG6/jQ9sxUQR2RfNoaaiur/SJpD7kor3VOq+6KrWZLQu1pczp20KYu1XeMwQ0gS5xHDzQXheqQSLNRzkfTlssCXDoxspfhHeoJFZpl14RgrXba/tDq5pmAuN1F+l4z1yUmardUyT7K4L6VnY/T7ecB6lgvrS5Vz7RYLlQlbsIItpIEZ495rIbBXmH7+NqpsWtqA4y5dAVdn2iZBFkLI/Kt8kkUBFjttvtPSNAAa/ssD7BccGriPn07aoD1UgMsIjnxuGBN3FEBrLCNGmBheIBIxqIfNMBy3U5aACwf5WTr+v8KOAcSi0hxq8vP5pkj201cG4kvM362HACIdNtaqW4sFaJZFuAbc4GdSoYtCqIswCKybaN8oUEWslhl1dBmIzuj85G8AbJQLDWgUkUGl2WwpsRDuAJXBXILA3SiWA4eZkiQJdvkCacI7KNmaqwg73fBkecAqvYdK4WhIHY6KLCaWyJpwOxI2YG6WrNl/rogfz12UgWwiDqWFU87g1U15jwc46GKisnyjR43vnHkoa5/8/fsMDmrfLJlZbI+ZfIL/9E3h3/zxS6BqxQmgU+ICVBtn3W/8RhUST3IgZgFrpLsX+9+q152x83pdF354p+uS5NWAmGmETuxxd1IH5Mm9yGMQ5pAuZaALRxl/45DfCf+eg7+psfxyZWDhVTuxLOIxt1vWrzEBMwuTcA2vWuavHmbJHXjsPBNedOBaiO1vVhAkwa0ZwSaU7usQcOSUpL0i52yc+PvY6kL+fn0c2rXA1upUmDMHoiUDDyFtruuKFnQyr6Cvi/7eOw6U8muCZyp6q+PvQqRv3UCeUMgTCM1DgdNiSmrD6W4T0h6ZQMMiRhQRkqcocp9PXCRF4mpuQF7C/0S1YTGMzyzpeIYJ/UPtTES37U/l0JL8GCkPEguBj1NQ5AHLFUep1I9N5wu4ef+mZyBCslmzAoXgm0j1Ir95f3cIkJgWF6ivT1qUunztknjJtnACgN6dt1f/Acrs/UJklVd+GmWr/3mN5WdVbkn2j8dP1ux13ZXvtaqveghqGfQQT6LA9H2fVQ3GQtGKVVcsdSMWP1Ady0V9sEZ7L2V/NjYeSoVQuNEbj0iohrVYpYLuYt6GCHLRdStRoZKRxRfa68m0h7qZq41C/jwRSvstJ0XkTbUdWEeYBF14FuxY4ndAwmcybOmG8vTcdsKZsHvWgpXsiO7k0aV54uo2KzQFgJoEREdbyo6eTBGt23qwmSyAmwaQltIVBG1Oqk9FEpduNnVAjhZQCvUXjFZJtjqmZ9BXNTG8pYHpNGvTMnN6NGpPhOrSM5I0q4Y26jZrogMdBF1XZ2ulxlU1wKEKgCyvkYxuheNzs9oOSkYSajVmD44wRBb6cFiYZgBODAXcKS8FssbR3/yu1/X9Vrl4yQryPo0ytd+c2St0qRS9uEVEGARjYt2GugcYKUJAQEWP5eisXOAFTY9k8LX635HmQBWOuYAC5krLgPISht53n2RueITWf9+g9s5B1j9RJkAFp+E21NgvJgMbIAFsLBO6Vo2cQ8LicEc4W/iEanI9A2shNepHABZRGzRAQaLlzkHshK7KRYKZPWYWMFfB0G2hdlUJZDl+8jeHGQNiaD7MosenHBQksCWxWgdb7qyEtDiHoMJbNU9y1UIlitRdKmvOXlMHcgiIgG0Nrta1G8KZBFJ9ismVq2/bjCItwy05wJwpks5UJjTjs7N6v07DEypEch3FmylpkuMFlehpZyO/V9RX2TWQAUpnjMDtsycpRazdQFJvZOhvNWGPHBsYjj7tkjMFQItIjmGVEDg1Lf3ug0S2OJe3yvY+tjKJMhabbI+ocIBFlEHrkqIX1Xs3STAShK9YcvD7CsQYA2XbNwAsIg6IBWZdyACrCTN6bwKsTmLgi0Z1lMMXulJASxuMzEsCo0TACtUBsDCsqgDV5MAyxK+4lShcwVfEqyUR2RP/4PFg9fXsuGKZaSwC9o+Z4GKx3oet8cbrl/UBsa5GYBF1IErD6lT3EkzAqxUzETalQEQ9dI2BbWNPHd7uaXbS2mMGMCwHe8hIk2fRk2pJoP4BLCISId6CE7ZliV7rsjrgaDJx+4/EcXdAFtY7SL2aZQmL5kX9o6W/R6/TEb/d0otmewtBSvbui5cRYqFlepLNPbFNAdwgOKjVB0arGrYdHabluPIUM4mKmZt8IZMzGqabwpoe/Sk7MdVUuH7o2YALZvTYUz3xbW7qO1gDbutr/2WnPdX+fjLymR9QgRBFRcPaqX6jP3Ws0d8kA9z9jDA+/M8nAKAq5N3uoubUzYBJwCVdl6V/Es0TsIivc5WGsgnleGwWWeqp2EiTrYbnN4PchccrGv6SbK4lgE/I08FUztxP1GvauRebmlRSzYWG3k/Ty/ibhMT0v9hk65YfyOplCZ8MUoLnHjHpEpIbd4DK15Oup5/T99IdXG6PvULPsGnNkqATkz+iDsSK2EwbGKBKqIw7k7gxAogmn5LLJFnC1vbMHWbWOEl6xRSv2Ftl57FPQzRi3BgnThb5nXYhxikJ2GqU7XtGv14wyjhvswEFBtmb2bF7cJ6p3ZTIR+4/ZYVisDoX4IZMhKIj2l32HWBTACdmBruxBK2gQpm8J76K59/lO0UMFvdDSTq09Up2sm006vz8ZreLV3DNzwYFiSNXf741Oapf6T683LSxiWN9/6a4oa9fz+GU1sN441h/jQuBZY+SrVscgLipg4pndi3fmO13foYyMpkfZJlDmDNifII5Jvi2IErBFhhI1WGJ+/EAWAlCeU0wErCd7kJYLVb6TFYP4jKJgsBVtwEDbDAkylsggBIRCR2oQiwhvJrJwBWYsI4wLI8irAMonGiHSbcOWHs0RB+wlKrgKCthulZhi7lbDc8GqrnaSnFmBmswRLvScUGEE1HQ0+PKuzwCC1681l+/KKT22UhsLIroctOYCsmdWsZlH1VUhHOSdmzeVMAi4jM93cISCfYva6S/Z8yyhAnBmtrPj/Iv3PbbN+Mpgf+4KndheG/oe8ZjPnQxAlUG+yvYLmoA/MDoOcsqwNAZoUQmeivYlOE3T4B8lR3qz+ftGKT1Z6GwQQhsVrtSaT2ZLRxLA5aO7CAODXnzK/8/uqV+HGWlcn6GMsScIUsVmvZInitJsRQDpb7//n35Wc/XuhVAY3iVSwn0sbamCqGiHTUZmuRgcjRdtoYoOqtyMyoGlyQa48MI/QlKjTlWbgghpH1XpZXPoal8NA+ZvwtiMI/pw7igt8M62gyWfhNLeBiMFkoqGpDYGPJknhVlljXeDR6XxC6IRpAroAch+1xASBH1aOZ5NjqHNjv9DXm2MjWR59KLE0SzB5AZAD7BWPQHJdwylLJm/HqVIXgnhM9wB04SZhtj8DxWn9TfPfyWh63WzKdXDBjhhqrRvOsrNZHJpODaQVZHzP51V8fgVWTWCZDE0AkAdYAmtK8wAa/ryWlnxiNhi2cxcHR5sV4zeZl91t9LtUHHCRwJow/m3vrJZAx2C4kVUFirHjPSrY5/WQmAhU66mLqJBlCEcBiwic0UCemOohJ2IPaJIEFUOuJf/N5NJBtFGwYzqKadriHvQNn+nwjwzW4oxNqygHosPfxt4WwCRm+F2s6X8sEwRGixVsqxMFGDgGgN87z9i2jtA0qolBz+d72KtyW4txsgmb+qB6k8YjqCNwS4PKcEYkSvDkfhVpSfPL+W47qvt6gfSbmFoIsXicVXb4HW1gfIcYkEBsnp3Y8NgOJpg/ZH6fxyVVtEypDDgRiSaKR+LwwGJ+DGtFkUJUHnuxzlgpxbvzgbzjWicbxnkAcmiQQ0bjJ42rbTavbn2iIKj+E3+D37KWXaGonDkxdsNWHqb78WgRa6bc0Vgs29v/st79Oq/zUZAVZH3fh4CqJYpsMkKWCi4IgwCIadflJLICVwNWUKIBFRPWDPMOgYikZ0bvdpaxwNCK1I6tFNA+wiCDMAJENsLCn47HlgQjAw0MUa2uXai0UKro9Go1bIAsW4/KFbDsHqlWrPhbIQiNck1XABdJipWZiHE0JGscrQZxXhXyKHePZAfqHZVyP11gMlQW25kAWkQ20EFiaQGsOZBFpYIWR6oOzZ3PlEAHsoWFIjqptZGn90eWBVm48IdCakKmUN+JULkjukucA0CIibQzf+FmgRaTZLARaRJr4LW7dJMga66LrvIKtn4qsIOvjKF/9nQ5YbZ+P566+0M1UJz/qRsuQp86a5AZPPrmLwSCRRCNDkmynUpDR8qa/1giImbwA0zX1uXwu0ciGDRNY6il9GVaAymHneJqiWPY7wj5vm0gymyanxAZBMEhUx/Fzg1G2MbmmSTnlNmzP0f2HX2z/tSb/ZP81uGof7F0zEdtlJ2NtVAek+vPAh0GWl2Zi1++iC5aXMK0Fqe8ocGU6KERRf/Ndp9oBA4uydxjYq7mFrL8/2R7FFCahB11oEM+flc6la8reAJ0bq4eeMUqAJ9lWpZAL5xe3w7W3N9v+fsn8JFaM21NNMVoJaHmuJjRS+BARtSm4qAXiUmiH9K6pSrwpU0iB9G4pGXKUv0v2KQ2i/kSqpoN7iIZ+poLfpiK4YbsTt7Dx2F/AGcP0iDlGK52zWGYuvLoDGzfBVs0xpRMesZEHyE3vlspDoMXBLTBcaYM4hNJh7FNqozH0Rd/ujXyf7n75LRJwa/pNNA/9EPpy1tQ9H5pMdqjV8P0jkgSwklx9IQwAK4ll3yR/jyolDu4u0dicSCd5VsmhjTALCWAN15xEoW40QwEAwDLDGiBTgACLMTEIsCxZCrD83k0DLLNgXsl5gJWE2z9NGptzLza0kZkwEBfvBIt2anOVGDpDDhEZ72Q9HgkDIxClkMZLLzhLwDU+Hgq5oBFNG8vje4Khu/dhMFhPopI1GwmiT07BKhnfe8G2c06dOJYDY3EKsEX73+JerpLctfJbTNmj8cejOVG6h7VN2ECA2pl2SIbbCRy5tu+HXH02Va0554ipn3gboc2gUnNrFjgnbtsqltVM04OCwWeBUU9hJ8SzcM9XRu34AnaQGMS5OY3KHnZN3fPTl5XJ+inLV3/3G2oFxIjjm2deq0SAyWrOo2RbvPYICzCxoCFldanr15zJY8sgHr1bcAJToMVHGVbhvNZGpMHJHaSVHBcW61hEqZqzNEQwMXH36sn6tk7P/hlDXQRYJqjChdq4ROVmRLUX1MPvvbAJ87fOVPUIe5pCl4MTOMY3W2SYbGbthZe0FjsUZBkw15/l8ADlYPR3IqJmD9HkAdCcPYBAc0R0fSV14hqgyXKcHxmyqfrG4JRnYcDI5odChBpwPmaBnXqO5emK6kOzE8Ixfmbs285msrhYWQjQWcLMgwmehfoC4xiHOF5TRnnOkd7QZOK7DUwhvwbivZkbA9g8FFdoWqA3wKi6RwCG91RXTs3RHvYM5In+4h+trNYrlFVd+FHLkKzZiB5dX8QOWCVJrDibZItbN9DARNRNhMK4vWdlePymlsSnx9Q65Q0wVknFx2wDfE20f2O8qbj1NpXP5o5wEsTiOQCs8z4iNqYMGVRKMMEYoGqo195Af0GGNXCNDL8wMFeJgUthGhIVzx9vAQZPYjJOO9LyJUtAW0AsHycBctjISTIU8jtboDZWAfK99SoE1gaxih3AGk448dz03UeVDclEtil/3xJwhcbEKvS3BTDhnnSYvikCK6Ge7N+3TEbuLM6UYUflfBQ5AMs+UCiCrOH6BJJYFc7O93RzPQKsGOWiOeQ0BLWh48M4qSOZCtBvWvPeJKFxksUrowCQk9M1a/MhxhNnWVoA3xD7Stk0wfxiedc6sAlL/RoDlBKNYxdViMmxY8xswOYNTIuVyrfAVpIIfy2iKdIIYNN1/PVxk9WX4Xej/QUykHFfjAFNaQS83BO2PRQSzDVeACR/64SjS9oQ8jnbAlyb5+NLJnDFtRWTgKu/bQVbr0RWkPVRygCwJsSKDYMyFz+JaEI9xM6hoaUlaMhORHR8PA+wsF7hTM7GlhEzqoL0TlnPjDnjcoyT5Q0aH9PzqLxo2EQLmBlkBxULACALQQwRKXWuzhcIv2+iNq6HHJQWc4CiYpshs5ADWESamVId0WhD+A6zAIuIfAV5CmuDRUCwhYbGu3oSZE2VkWWbDEZKeTYi82WBQtQSX4PzAvRtc8rGdsfHWCpbjmPnbJSGislDU6WHY9mY20RayAWOJKjGXBSfDd8fn3OPMvypHGQKaBntUcD8197oCcCx+RCBFhFReSkrj0Br+77RiFAVK0csn5dWoPWBZQVZH4V85Q++oQKCckmLHI9n1O5kSoh2g6EaolrYI2MGVG6s/jmb58wIcqvpYwRYYRupOWU7s+DEQo6Gr0QaYKko37el4W3G/p1IPrYwaTuhSP5WMkd4TQcG+98zpApR1/6hkKq6wWOeM3KNE6CyvHEa/Ab5O5Es19dOxJyKTv4eSwN08AonpwaMvwXR3XMpVbIAy5FYiBS4Iuq+V857MAeyUE0caIikTdQbjUMRYV9qdQ7Y2DgXpRG5l+2KRuREGgDF4ETYh1D7PPD2UYeKYADHFUFNxwrM1V6wUApkDQbrHK3gqgrtGp1kUTDhdCoylwpqDmilf4LTiJXkmVc9VDJZdNgF1b9jGYVqU80LZZBAMv1uRYjnAlkJlNqQtaM/6wcZr/tVRe5sHHybXU2Ha2lMq4AWMlqtExtLtCstbryyqQyVbIPi4MRGujmP4ngI28NstNAEJZREf/nvr2DrnrKCrJ+WfOUPJGvlj3KXGH0UC1yxd2Jn4mtt8N6FapADCo1P+WLva72IluDq6w9ywEW4vjkNot6usRiW8Z/hrNULXxk6YDU8NOqexOfo2lBFwqLmbwtpp1FEKm45KFu2znNgy9VmYRP19QBYYiE9d2IhQWuowLNnE5W9XHsSh3omkCWYo+B0xdFlvpbfh4hErjPV1CEProhY+xVxGlwluQ/Isuy0eBtXETzypMpN2fMVUqVGXhqyx9bPe39RD3Q4SPNRhFTwRZSs1NR79WUkoCUM1hsv7cAc6XhgfK7ogRYHWep6S1XL+1oaK6nNLXvDAGq/OwItogl1Iy/TAFriGFhT1zqp+q+duMZFZwMtLo0HoAmVthhULLNl7VnEEWixMkVS87NG5LEkIjrejr/7KgzJxccLkJX2YmzHIgpbUtfKcRwLvfEur6V5SXktN4TNqZyLfaND/ayA604yOWhW78JXKF/+pxJgnfxYp2TBRQ6pXwRYsZTegV0gSXaBA5WdywOsUEivE1WnTdRRyPkzPekuhZNT7SXAIpKTXBlVGTmA5Y4ahHGAFcr5NT4lzJ4CWNYzLeEAikizgpuXuAvXZQjyAxYQsx654OBRJ5NFuRPAohn2akYWJcUWN0QFYv0GDYgz0xQ+E+NNFcGO1s2fgVgFY6zhMzIUaWgdtbh4IgjIdDW3CcLOx5Rc3LGMQTcR6Vx+uYj6SzJHYQqrjBrRZLs40FBMq+43SiWK74HMK/bv1inAI9qrdRReVrJvYLe4LlWy8ZL151B7Hf8MmcoySAZdqVxJ2HW61imApDwN4RjnsFASVTBvffmfrZ6Ir0JWkPWKxAJYx4fjsRVKQSxohbZvUsH+DK8edcweUd46DbDYhBqq7j9+RbuJ872CGy0TyVxiSXig0Mj+GyoGtDy6U1ewuFhJvAjiy0CdIYWdSjETiu4/obboDdkFuDDWG/Ud2QSH7W1JqKIZ92wsEI+ddApoyU7zM1fEgoURRSSdNnI46mj7loGNk//OgQL04kSwH5zpfq9AUSZshHOgKrRYVgQGqE5sfRYAok1WFCpL3Razke7NB5AGUnOG4USLZn0OtBTr5KLeFPDhaoRPCWVUY9IEWvj6/DFW02BfaEEtinMPYxu7MqOeLBCbnTVCJRivS5nA+6Qlx9LyNC82Amj5IlC5aQXYcldgd7cvyDGPxbgN9iaHCU8WTTQ9xyU5PIb+C6YW9UVcgdaHIKu68AMIAisXO3CV5PaNeabARb345eIbqTkIN283eiZS8VXY+HZEKtZWbhLGCVZNBlgFH+Vu2epN/J5GL8baBkkzbXOgikhOOJaWRSSnzrBCyuCd5KQXSqIWYtQUt054T6m8jydBLwgoPPlxcLpdMOBozmHCYrNEyh3NavJvFcsw6wVqypTnZvoZnSWCk+DDUvtgH+RBG8swBCIdnpFhTXWdSTAQurwJuyl+Daoj0XA6kwDboXrRIpx4EWiXRST7FHoQEml1Io7D1nUsUnqc4eUr0kw1Tn0vodJ2Boir5FyRjdSuAB+8wxQ449fjI9D04Y6MIuapLMqWAgPkzbvSCDaeN+ReAtXscP6Qba2cmeAQM3v4VqZSszZ63Mu9vtDahr/8B6sKcUJWdeGrFgWwggRYSqJeM/kCGL22f8EFE5NBI8CyBo1irngOwwqCmXrK9gj04lN1Ptc2C3cCWEcvGqq4LAwgwRmW7n4BsG5gIQl2uAJRzUwgTvTWQ/CC6S0wUOASweTNKDo+zvyxMrCO5qvPPE+zV0q1hwlxMQyHUuXBQ4Kb7XOx8YYdElyUCSwZGm/GqpqVnOcYeny2Xg9wEBGKwVrY0WM0w9blPOQcppFCsfpoRlWIqkRuN2UeG3VQDibIXvIyXN+H+DWYeByBnAc2PpLuM/z7e2Nyxo0DeolmQHpzWVFzOYImpUJ8bU+RzZXuqqQI9l4RHIlaSC9WX8yrn4tj918SNI0IFc322eqlU2sK2hyvkpeVybqjWOAqyck7jm7ehAmE4wsvF2cXAaSoXaMEVrGA8goJrFQw0lIa2Q8eiClRsiNzgeNAyh+9OHbBUTxlldp7AazidSl7yzbM9x5H0g7CdcBqqMsuyIU6pnr0hwWAqlTUEHeH1AQoHA8ObgCiVuobihJghU0UO3HXSoDlG7lbjBUkeIX8iGEr+0DY6AlfBHoswIg+xVwy0iIN9wDLp8A+2rt4yV5FleSZyDFAGLdRgKu4ld8somE7hm1Ao+dtq1kdolENZBkzIzNB8jxXDcZWqqWcN9AnUM7CCB5zJUYnARFcTyTjJVmgMYL6iHZhYMeG69EbkNe5BdYK6hQbACp4PTJYGFeLjOfx99t7aagO8bH83kvD9TmQm8buA6Ze40F302M42DqCkbsjOQ6QtcM5yUcJrCBPJJVBtL/btgJoYZ+i4ChCftXyQa0yC9T78bu7q5IiUzu661ICsetCjNXypXQCql56Edi6eukFoEVP9eYkys2ji1Sx4Kiulmx8mjfTfPStf7iyWkwmO/QKshbKl//ZN0QrIKtAZMxJGLoHw/RkgjgWEP5B2R0hqwAgS6S9IUPNhzsb3CGi7PTvIkQDLhREeteJwhar4krrtvikEsuo2J4c+4MR1PEb5NgfVT7axe6latFisDgoQ9UtEYmQDqqPkPzOVr/D4Kf6AnmYA1koiq1URspwA/YzZfU8f73p4TX3O5EeS8r4fZ7JUulskMnKzIAYhgGv90Z4CHF8bcRP4nZAFujM2OwIYJlj7qxhmlFfTqV9mqwPspyZOqmQMPC8k9du6Pb5bvJ3Isrravgr5drIaG8eO8tqY4y6X13ISZ2DLCLS74BFgmE+ZprA69FsQs35cFyBCtKaz0QZgehbv7GCLVrVhR9MEGBh7j+0590+d7RlcamiB4AEepvi4ISND9K86RlJfK1VgypEQCbApRUEkItS82AXihJg6VQoUQAsh2koGi8AFk5g7aNmHmBFCYDU5FFJgBV9N8kLtR4a8OIrNzoOVs4YFb8DGsKjpyHabXkMKgrfGQFSDmTy+GjW/WrhyGDiXL/Ihb8w07jcRZKBOj4HvcLQIwu9C/H+nKoP3xMvR/upXF483FA9lB/aYaiAufhyRBpUYn0RRGbSRmUdFFDQ1ACZJE9DpoL0eyy0Ab3I6nBdkOMq1EKywLfvntLJo738HQVPzQFDS+2MIAy9xXn4Bh8pQrBRbhBPRNQCcMUYWmj75TA1EtRReQyDA1W7i8KDHY3hUerzQDVLM+ZrpzemvGt6oq/8/qpCnJOVyZoR4VkRJbhqTqOah7awoB0esUW+IDWxcWDVbuaBlYocXswDKwXsfFShH7iEjaHi4deA2s9Vkj6PNzLXGvmogFVE2yxlrMz+eV2I6/3Bief7owRAGDuGnHxftKlqeaBVw6vJgUoQFwPuYGAZyXOwFCojHUbDAFYkE8QO/wQ1MVF+h4rg6vAE2xrZJv4baYnwbwUy2M9V1GCNa9csAMLbd8liyQXbfxNGAG9ElHdVkN5hln3NDMiIEUCMxUhzBwXjfUWqHVhY2xcywKViSCxmL8y8D6tjbI2AqviumSTuJqM1p4qLJB0baiyP/bOR8a9cK4/jLsjv7TpGK8nt8x0EXYW6OHifHBhG2zlrk8JVyee1BF4YJf62EOxXUQYKrP3bQyHVvLWXXocnrXz/4MjxwLXYlZGpRzV2O2+vWl15HcCUz00libH+M8xqrUzWXQVdVy32Kolv5gFWcaRZgBXKDMCiuzFXoZxnriwWaxZgEcmJ5uht5mqogJMAKwBIcXI35hovJ+ED2G/UTk3cIlfiJuod3R16dkTvSpD2JDMRZzb9ykCVNIMlilMxmeQhz1VmieVZKcrPsFWqrWcAlSm58lFyC12OVUVROfvkz8hqKRCDqsIMS6QScmc80XJhH9zpfHwOh+pVbB/l7cvGEjJalGfdMPGxkpyBfY4156FYDGaL24A69GaMRAV7p5NHezp5eit+l+FgSNvv4fecA2ERxqfFbPHHGcwW90y1mC2edmwRs8Wrh10ZgzPD9QE3/1BAfR5kYOU5VotWVsuSFWQZ8qVv/qE45h0J6VeU+ixSfTa/gM4FbAyl9AD0tROACj2+2o30EMSgdOEkdAmbeR0ESyJjpSDAwhgwdPTiOKJ7fXCS2QkSxOhQDJ6iUCuCF08tk1ojQxc2Yw7CsA0UtkF5CoZdoOaCxbG50IuGsEvKLeIZVcpc/yDqv9GE/UcumKcFsLgK0gJYzflMfSzVG//5jlqjO2sDZ0IvENF0oNHcc+Y2CcaxspHK/K5klvlyZkysqWdheWjPRSSBlhleYAY4ZVWZud9zIRXQAB0EVfRxEwXQIkci/p67KaSzzTYIYHf1o3MBtJQcvQ7qyo/RaB3T64DqM3qZBsg1MOd5UkCLgy38XqHxKq4bB1rxtJXvD7HA4jYMyeq7EzQ/po1UZOJ31IKgQHsg8Pry6oEoZFUXMuHgCm1dlK1J5phf35zG2cUTUxq4VjNViqGfMehWoAqjxFvqC07Rw04ajTfVzhUjW/Od6SZq9QBn1TZBAisHQAzX4NpJWyuMZwOqI+7xVL4sBMBy4HGlDHPhWURS7VjekvJEFPYPW32vAMFox4O7YljMEGAJ8BQNFSK7v91IBiuWUaskRWUkbsixX2pSnlEFR8v2BW3j5sCmyi5gXDunvnIk2x7rPqNOywIUF8ljXDq+IGNORSLpPGIYmwv1EbJgOaeCucXWSHAdgaXhgCDui/kI9LU3bPymWVlU0+O8oeJjsWe7m0KFODh/PKoN29bT7Xsn8n7uhIP1qsE7MRP4Occ2C5W4BVjYu/hNq2OmcU0Aet/eFLPlu4OX49XRLLvswLMUx/LmpTyBxvCYpYRviv/yZ8cDcXLCWkEWdWEZhP1P7WSndHKR8bWTCyDOcxAMr93eoTJRB7oMVaSin4DaLSyOkEomnGJASwLXb8lU4WJLXqoHFMAikiBrBmB1J+BenHDQHpdNbv7otHcLLPwBAx8yiQVR5IsC7DC7MuSOVNyPrxKgfjXY1XGVbUUmlS8T6kqaXjnIsT62eeFVP0OGihv1tycyqjwynNh22sBfXz8ekLGo8N+hjxVGcl8MFimSROdYI5ILz9GwM8JwBTPpVFwJIRcyNks5oIXqwjuBLAydYOVhRJkJvBlbN1nf2BopXnwc1KkeQ2m4CMmuowRlFjCeCyIbYWPROmVDFJjtJBUSnG/Oj3TkyZhdpPNHo6rw6r1TWSf0dD56ZeYgZAZo5aLTxyrIZ2+DdPSBPoJAKzZePh9if7nLcpjbXOtMD2HPg5fm9gYwvnHu40CrPosy/haYp6iAyGWkb//ar89X4JMvk5PWqi4EQQZJufTD75gvTuX8m1m8crRsqKIGWLwsVA1aAEtUDu9nAAu9g4ioOjGimyaAhekrILlq3AUZVBDE3zry4HmXAIw/OmWo3l3A/slAgqWCjQVJCn1CMLr58G8DYIn6Q9PgtyEi6RiAix/ENLKuSbJ5IT+Mb7QXoqgLhu7wlA0DgdcvlgWqibnjWXuYqecR6QUwZ7ydAW5zwMn5mGew0rVFoIhAHhlLptoqNi35GRsqlGLTqmji/N056En/nlN1it+Md8RUQup4LiDqHMBCGeJqwfOPbty4tU6Uebza0OZMGrNePT+hq+cdg3X+9EbMSeZ3FOmq3KyakPf1Ye6cey8+Jx4MlSUI7yeuDEYke7i+B20pz6PSGIiLaQYG6HULuyCawCj26q52mD9D8jPLZFkpcYTwzWEwwBe/FH9yUbrRQodE4ci/OMyzN1YaHrHbw86Om3JIWYHAavN4L46P77M4NNswvwhitSEYH6pgUZ3GM81b8VkE8ZMJSSEAFgYiTOdSuSoHn5tVlWF0dxTtVj2zgAeS6ijUokHcGg7ujo/mh6XaUQLYwja2YnSJeuJro/pR3ADvnVMnwr1K5l5VBfeM04iVSEU15/ZNEVOyEGlD9xmxDMunJLZeAaaWsx34Wi6SZ23aQmqfuak85+Go8jLWnjwLL6CizaN6C0NozKgJTeZ/bl7BzSEzh9hcyOzsx+uNvB7zIwLQiRhaZq7fqE2rZr/F5QiqWjfrJICJ0UPN6tY4zcDy2GrImsPY9rc4QcKzeTBhH42xPv2exRGYclxzYG74lLJaK5PF5Ut/CAALdwiYzkYZa0+X3RkV8mszO2ikx9ngKI4GJc2k3QUBsDDlhc7HBcd8Pt+1AmDVh5LqAyY5nFENqGdNA8VwEiXAihJgWYbjIn8rDOgs83LHXj43z+YAFrKLuTw2cwEZFQuEKjwMpQQeqrnyuCDgVZO2yoE38yA//yyt2nvFe7gPEItrKWM1SCZv55zBOwIbVTT8Xm1nJh7j+rl6ZSV3/Vy/zqRisjY1s6Jo4PGfx5dbahlY3JwdiZjROBqxxxrSNAEYmXU8caTtRXnZmyCdeGovN5poPwoAD/NhijYuo1Q3ogSpMkRWS4Eu1BTApjNnQ8wFSQQ1l8D3+1lLzfMzxWRxcOWC1kMLwMM34f0kkBa1WEp7GYzlgjucxnDX588qmcFyuxnVg0SdGkrYHQVHbVLDFak+bGADe8SBlZXIOdlfJdUgB1bxuhwnW/S4Se+bBnMp1YXuphATtd87CkmNlarbH6bEpwlcqZx8ERwDwnivYvbQBmtOAimbEC58MkkARwYz5Q+WAEuoISfqkfpVdIZNBGvLkqW6KPqNe0r+mp6ZAFbYkGJhef8RjgPpc/BJkSdbBlbHYcwgxoQO76sM3Pl7yTHSXc+exQXn+LswWTlBMNLXsUvarC+fZbIgHMAAnKIEWKgy7E6yYsD2qjkWg21X8jzb7LoxmvLgcSaLM2iYqzG2bjxOf1Kb9XWcMr73m1azWMOFhjqykSo9ZdvKQYmP5HsGLDXVXPonYZwN+Q2Ls5HiLYpAx2c9A5/YuMS0pXbo/zoPNnK1EwnPkyqOaAQqwkC/imOcqiJKkJXOpy6xDcO55C0oYmDtWsFmCY/D1Bhpfq+kjZc7esHeu9opJjmtSel9kmYhbCC9DpJeSBzUbpgb07xcMEKxYapFf4CAzk6mJfsUpeaZnCV+ZkAWsleIxpVOmb0xem3lXPRxF8BBFgKIMhPTiEffJSLpWQfU8xzAItIgS4RmQObiRqf5kBWBYz7A0VgeXxEjKBg5G4efsChUgc2BLKJZoKV20DMgiwjUnbi5zrS1SubNn52h1znIItJqPqkCxHrBDhY8JtF7Ut4sD02PKr4OYIwjjI3GBZmujwHI6p57R1UhjilMAi3Kmme9MAwBD1JZlrLjH28kfYBqytmQEahCQ8YUPBznVKDKEF+pDeXhXVisOZBFRMrmszgfgVb7Eo2GoO3RCB7nID6HZUwwlOoUoryj97QQZKch7Q6GdiBUb4qb4TjT9sXVzOSInxHmCWT0+bzcgP0WfmMPc/inBGj9bKsLv/o73xTHm5fQQbgDy43crWPkbAXGcG1gE1h7EmcBFkqAyY4DrOjnF0SHkxuuhzz4ZyZWF13CSo3vzI/B4B0FF95Z40wyQBJ/FADSOTu5oW4TosI14DGyaTOLQe67qmCVc+qRmf5EpAH+nB1VLLVtRXPGGA/sT5nYOHMgSoHKXCwltdgYLNeU5LZ8cyq/O6oD+R7U3I/eFeD14nA/VLazKrjjrfzQWzD4Vv1m5j1VKpeMSnv2e+Ct2Qjqy8vSdrIwRnHOY/LWF96DwuACKxfkXL14XbCt0Wbz5QwQQsmY8M06FqCobwE/w5hUDjKQk1DUAzacuKnk81J57ahkwbvVc2HewfX50yafaiYrfbzmNApg1ZxGaVDM3i51vASu2p0cRM0pLFxRdjh/dEMZAwU+sQiXeyeAlW+djLNUytQwnUcLp3X5CtD/5XXjr1hArK7zRiwarogCXMUiyoHGB2wgCWDKKLx0XA0R21vp+SIW5KRy4HFj2OQZnQRXicVJAAtBR6yCVFsySj3VaQpgRVAZuyivde0ITNLz+fWBbZ6jl98qMUoCYGFYhInvlXaN/F1VGiFeVICJLUpAhWxWd5JdzlWEqb7Q58dnORWzRwEsBOVT4U9ygUatxQ5BzpT6kf+W/o1jZQZsOCdBlmC4FgA35WHI2zv2IGs44YSdEWeeNie1ePahD2HA1ZSiH2EaFcbitb3tEj8Xo5NhGjjr17/CoMasPYR4IJXyZTJES7qtfzeXATIyxViqCPsdmKm3Pv/+8O8fffdpf/0EkC+Dps14qprWSfbdTW+6opfOKe1FS/6GqQQNo3IRPuhce3SL0A5cw2B0O85WKbtIcADimo80x6S1zLVELduQFbcePLGlXVc3H3W/D/M1e3xgYYyik3Urjm7QEvz5f/h1/VKfDPnZUxdydCzUPmp3JA8L6awiFk4ioEIBYBHN7wZQVPJfWDRbEXTTKmDms2Q22BES0Do2eKO12MyoVHThMLFDFPepsAnD9WyCyyVAViALUoC4OWNRgslShWkANQBMWsisCZBlVHs2eXJuYw33zhr7G/0izEW0xx0vAoKckwOISFM0o1Y2y5ozWrfG09Smg2gagCXBRegOLJdSI+ZS08yALF/oXViyuyLS6r3tqZw4jod51T4HWmgcb9lbca82NM7H+9tbzHiO1ClbiC1gwu3WMloC1TVQzcmAFgdZSX70/SeTZau+kIn/l8vMIEweoImUQwvMgQi0JkHWcJI9V4UQyvRL9ABn7xlQHQtASz0LxgCqFAPEi+R2zdXlWI9PKND62VQXuigBFqc8i6POF8gBVruTi2bYwCIK2c7xWHksIqXMwEMsCYymM4so0d3UKyh3uB7T+Oh6wDHsKHFyKq+myypfFlTOUO1zoS26Y1jIZtQJubgy6H3T9SU3+bvyKuT3tprN5AsGev6EMooJCFknPOb3h03UqZVmbAjjSUtxO6PvVEAEf88c82Yqoo5vdRdBO5oPolb0cZY5yXkoIjiZNA7v6zEXq4oDKiKi+mYjPM1Q9dfis7mhNqa5IpLx2nJxyDLS7kv57zuCzTlRKnoVkxAeNbMB+/GPH9GPf/xo+lkYawzt1LCN5+YeYKHVs/C98FmY6QGAVFmxLBWnDZUX027EuZQ5GKsL7cf4e/q9Fxvk9iQIJ5mwiWIuUmsFzBXljRN5EPm/6wfBDNvzaZBPFZP11d/5pnRgaiWwioUEVm0lwY8ysg4AtCrmZWGwWOme8QZWtjciuW8kUBI5+coIKhx4ENLO+IUUAGGXnhqu4HzgH72knVUMJFk3CiQWQHcJSVGD1NFzENBctApYoaoRveP4u7TbKMAV9+DpHgYNUUCaHzdO5oNKD/KoCewmXJ1TfcmUUMAE6+V3dK2c1FwrMwn4Rqr1/MGpPjP8s38H8Tv/bq1uVz7BukMh7eEaJ9WuRy+/eUsaUPUyTPK83TzUi4MtFR7CWLE4g3L0sn9zj8ihfv0F1uKHaX0sllZ8qGmGzBVRqd05kHGFBHMImJyXakgOrgZPM/Z7wRbcooiDupCoY504wHJeRmjH6PEqYjuRNGS3YmtN2TKhui/VY/irmSx+HAvJ7McCfq+iVM2XEnSFbRQsNibRfvPN5xJ08TkDQyeQ3KBF/IY1gAlQ0eo4YPJYO+uwuhgppyoGqpq6oIKNheblRo6NWo4N5fmONq+QComrNq1NKGe3/MGJuU9tPH2Ua17oTGKGup9GEXamOY1CO+Br90litX42mCzlvANYQqQCKAx6mkksAWCBG6sFyObKmwNYJnOV+zJzG9K7blYzOyslGfZKXHrwWfaKi2JtXiF7RaQnDn7sGx1pfk4z2u5ilsHioozDDQZLHGcYLCxr9nc0WkeVRc4rM8dgMXGtm9+WoQr3ruzKXdgT66e5ukWXZbHE5ZnI8jnmCKPDi6KOxWxd5xitruz5uoWMKh1l1kDe+iYzrIa6XbE9cHxXVuuFtL3IslpzIcbuwmoZxyq+3Qxx7IIMIYFSVi217HfFaiFTVURyJ6yx8JvjuGevxpN0J+HMVthG0W4WsyVvlvM5Z7Ks408Ls/WpAVlf+61vimPP43acSi8/VKfEElR/qG4porSXwjFmDRrOePCd6sZYDPmmKEf3EkGeN/ksO8YJXM8Fwy3kvG4Q1OAgPUyvvjkgiu2CkxtGP8+JAlQqdMTMvTSvQbIADZ8UAqqTM9520csHRlQJKvuT+d9VSg61CMLxHXIHRh91zDWsC6pT5sTTLLBxqM7ES+fAxJIuw/skMjLq2nyB3F5LJ2AGIJTJi1iADVQNXoaY+ooDobJqqcwEMOVALDReelMaANFXcwiB5ts7C8znNzjKpgt/v4aJ+8W06+3u7Eg79NDkRSvbzvlnI8jLhZrh5YnUQekcm4fb1gtHCARafteS5/UFNiyC3ZwrovRa5EP/rM3qrTjQilVUa4oIEVNpBx3u7NXuonTogbJwXf8kyideXZg+QthI5gpzyW0unQBXStUXJbjiHSFWNN8C1sQSxknCNdqbSybUlYukpYYU8w96/hHJCSzK8hx4+cTzRoKrTRDgSiVKLqVKzoHxcowkwFVxKV+gOMjBU18wenqv24YbnIcqKnDFDShbIz8iqiHEhOdIT5Bg/D4HrriHYbpXBfss5PXS0w/0j6Amxp2ja3RQQfG7EXRQ1B3BUGTXlMbL8vxwLirHAQRzMuG1AfbExVGDKRHEV//uMLWLCNBIwJYAe4JqnFysLouRQA9QLviqRRxAVYwaYPH3c0XQsawAwHGA1DZexUzaMAP4+rZS8ayEWulQqvJQtcjLV96UhVQ1ipQvRLotIsk5BQFbS+C5Ow+weMBeldSeiMjpzbOQh7UAHrvTEWDtrzc6vQ5Xre8LFdsP+z0HWWEblZkKwRwi7OQq+T64gXIPJRgsikANd06AMR72hexLwUk2C+N6tW5U3zsif63jHM7Zr4ZdkL9zjbORg5YTIL51KhYkN5iPBVHVa0L+5Hc/1qrDT7e6sDmRnRrRcHkrARamH4kFsFfWhMEls5l1EPJmFmBRZmEiY5N/B4BlXn8X9irSrM4sHv0se4UACwVp/wIN5QFgoQemKk95AcnfdaJnuB4LnNmlEelvGaApVIoJDKiYGYHZvjEXo8xim4QLt/Hd+MJ7R3VSloHNSe5xqArGx+UCmqLk1IIZ72AltQQpc89TQTyJZtWeyGihmMncmSCjheVh3C6198aNCTJamTkSPVazMe7Qx4EDvsbpWHNq4wTlvZxGYLuz42xfiLt2vm9G6eX8QVgtoo7Z4s4o8YV0cW9bL1Ms4bsDC6dTPwGIA1YrnM5/Wwwmit7jMqyN1tygGQ56IfI53rU6uOknTT6xTNbf/L0xgnuyd0oLaHMSqTRyzCVw1Z6QSlVDRMNbhjIKA72BFUunYMOtNqx9J0s7tbCR6pN0rwzmyAuQ1ynpB0mqt9oJFbK+rnYyOjxOUJ7AoFu2R9wEueCeNzIhbHDkb+SulXtqIrCpL6Kw00qq3ASw8L3Td0uDL3q5oA+xs9L9Xj4ztS23afZg/F6wvNhhQ5L5K/D7RB2Pho+Q6MDIXE6sqX8kAOYaR4FHzE/fNcX1qp0ykO8eE4dj8/epRdvJnXjctbJPRKfZzDkGi0irQ/mhIzmxRydtQVJbpme0TiwMSSUd0+aA99f75ClExw0rEntuY4WG+xycboI2fkeZ+jZ9OTxxtHNxYCuON90g2EAYh+ShONh48eoVYVAvJXBVMy9B5yN59v3ao1eR6/kxpqKJGA/LkbSzg99ddOT3cqxL5xI3LtT9YwRbfHTD9WjH2F1LKu2LeMCjmuhl1467t66JiOj23VNeQVlgGVUEeDE+GBttxYji8Q2H1DwIMvv2TeWEByOIcoeCqA+5k0JqcI/D+lCOLGNqT/a92qtqGG/pvPi+raeY5vf+O/n0vukyDnJbNwCtYVPJHQk8m2uNfZw/uqG8YW7nzbsZU++41M3ZeP2Lf/RrutCPXj5dTBbX0xYHp2x9EGD5o2SvlEFdJNGJPFLbjkyQNCWucWoQiseVcRpg9eXPPSMbVgHqe2eB9lA/Z4zLMdYYChrCF0enGCzxvGqewfJHbbDOxcVZMk4ALPP5d4xhpX62CCPuCo2xowgAuGEAypkBi0Gas5nKxvjJJjXPdK7clsyK6i9Unsb7TKU5ycVssyQ3gD/gljI3PmbFeHe+ICK40tfqc9yepzVY67nwEvj8+/w+x9DlxqayOcWiDVaLeyn6xmC1no+Tyf5HZ7T/0Zn8Pdc/Zj4v2hih5ELH5OxWY+OnPTyJzLmbpxuyQnwINbMn2ICQXr9EAG3NbPH6W+FrZFovyWwRSW3EMPezMj9pdlqfOJD1pT/8BjUsHQB2SGXUrjqIPMYFQ6kS7xj3BaliVBepHHboNZMz1kZ57TC7KLjWqRyH4vfTec8aivNqI3f0gsVCmUv7QkTUbud/t8CiiD9pxMoRrJEBGOYA2SLJxVDKGLkrFSLen1MRznhzds+/o54LAhJ+YLUfSm4MZYBSnFFHL5Lc62R3TXe73+H3wbAN+H2wfioulvw+1W65MbslIcxP+34mtdWS8rOx0LKbkkx/yKVsMiSnnpzdODRuvg/EeWDkGpffC6g+wH7atspmjDOR1bZR9noqPyXUP+xxoYTn58wq0MzjgOsoMN1oN4Z2ZxhHEjwN+Sa7OYsqF/HHWT5R6sIv/eE3BtYhMTnFQQKrtGsRCzHrEEm/yweVYLn6RZ93ChGE1KgXdrCuHJupGmIxiTQz4+9JNTmbJDlSB67S78/lViCWMoVOrKS6L7rYgat0fFPMR/VGz7dKxqJyR5lpvbp0AlwlZuvpv+lG0rv/NS/AVdoJ6YSw/Z9+AAp7Jx+lsekmimf6mnScHVARVjx2VxXljgp2lAgGlY22i+o7CRVe7XQYBUwvI8oDlV5aeNJfpW5gFRveQfdLoebk16ZyudrLeP7UYjS8Cw4QK2ZWEjRg9sZ1woDXevAdFnRHtppy+H1avWqWl9qC27mx8tNCx8+ZCaSxjr0k1R7/uSjGWFiprIqpjva3GwrcoFzFIJNsV3v0AlShwXtsZ9LsEBFFJ+23WidVhY7UN+R90B+cen8xdx+d2pTwcZnmUVQbDipzU50Yx1RaabHn8xuq/32UYRUiSfUngDBMreMaJ0GTk+xPKEj2PUfUPuZBwEg6Eeyk0W+1awY1MhGpqPxEJNW76VZ8J/Z8IiLPHJjQGYkIQi6wf6Y1jN/Dc6aiOQqRtL1Vqlciak+Z3XV/ut0QffvXPzaqw0++ujAhV1SVWczVFMAiomxy5Jx7ek7CNs4yFb52s7sqi14VvwPAssuAXQcwUQ4MG7NpU3AtOiLzIX+32KsEsIg0YAkFAhZSkxYalCvGEJ6pAh9Cm1egskTKem5nSpRnSFHFd+eEySaaZydRhRgoywjNqpi5V6F1b2bcuMbZdR4uMM5ljJdfuahYYAseOIfhijg7g7oi6hAn/HeMOg/SNl774HCQbHyvgLZ0OBdAfQtg3XDPjSBNqapyHpszDA2Rwepit56J/UbUb45mxpbJZEP4BHVPJvbZXO5BIj13qN+huqhuy7VZ3MsJswZWKhieqOL5TjNb6vkzzZ5bw4qD08wW5K7FNZYbt1sqU8Fssfp9EhitTwTISg2JwcqUl8SMRwqRBmS+liyW8hSr9OLLpdw7KvfTnc0f3Gzqh3YTVUZyWQDpLwQAK74PFVSzMhzjnI+xZDCYYg4cZBb38mZ+cc6JNeBwUkKAhf0En445IxvMRg/Xz7qGE3U73YzKVZ3iITYyAIZavRio2FFomI7AOpOH0aHKS8WeMuoF8aVm4xgF2P0Q6b49k/fuXoIpniyQNadaxcdbIBS9RTPpdjTokfeXG7kr9FD+BrwEK/Dy26CXocur9+YW3BjcLFAkIt0uuAHAILzQ9xBo5TyEMU1UzkZV2ciC+Nt5k4dscGbSa4e+IHOMdUJvSMSioD7cnh1pOxf3q3XzgXFhY6vqY9m2Qf2UVyVnHI+OCvBCVGsjTjmwNqKnedKQfNyB1sdeXfjV32UNiDGGCAZk1Ou9a8dFMpZ6gaUoB0jYSrUTxsqJngSw6jzVxt+b86g6D/6OwIobfbcbvTvGZ8S3DhJcoZoFj+Ed6EEjwRXGF3JR776UCkDW0TO7njS4ONh58sctvfjyODHsn2qAzL+Di3KQhgLAVdDgykMoGJwzHGvD4ug0uEJ7uYZUbDVF83P1D6pVjXg+YoFxetes4pvhLvcRJI+9KmX6GyOulQBYBdQhaIAlC6B5mz1DxSfKT/2I9y8Vnwr6n7WTnwWxRv05wDp4cpAQXSw4adcPKhslMEZUHUSqHujfmJoFjmNwOnAoe68QHe1280bvREQNYzCOezlAnI/zgCqS8ooUzFntlboQ0/aob4HgJkjGE8GPP0hApDMVkIgj5fdygxJ9pPZ0rGMJMfvQlCLgcbqX18vYaHJVu9rQBA0Mcf7E2H3IxomYjReNtJt0JJJIx9YpcH243ggnieOV3IyrlEoIJCOJNvB7LxzKQklUvWTr1kmUyaUNW2Rk+9tdoKIHt2EbNYkCzY4gqzmTMRT/5Pe+Th+hTI6sjzWTJQAW0TzA0j+Tr8FeC+Yo38iFtTmPWtWFMbeAuVJlzqB5IlIAS8V7scLnsGeEbZxnryyqN8degSiApSbK2dvNAcMB1u1bhs0AaiEQxMH6g99JpX/IOAxgsFpLkMFShB0upHeIKE+k1a5KlmxtMkbCypMJ2d6cJ2HOSSBnY9/MqyG7MjJ1wGS+IMWDDPiYcfwgoj4oa46xzbzDHZ0NkJHKeegho2XJ0cjBxyWXRkdFp0cvNJWCJaNWsyTXX1UgZPhdsdia1eLSPADTiMaJPqs8E288Fdd3WxaVehBuL7G8BayWSPdlsFoF8wi0QoTMsVpEmlFVLDJ+Wgj6rOIboke/sQ4qJooxW/7gJm1yk2C8LCzva7/5Tfo4yscWZP3ifygbTHkBzrBF1rECYLhpzKmEqDPoHq439MrououDrzmfB1h3DuWQocGJqJtQEISJShisAjxjVjKVbE8itSeRjo9mJlfw41YhCzLrixXiAG/PLVHZNcwEvzPsC6rPQh5s5No6YpDAF5V0QNjrXbuIHo3zqAWguEGvperGb42XYDvhsYtKzaiEb/oxsKL1TAKghX366CnejAM8Nl6+Bx5DGdVpTdU5LFrWt8x6UcrDDfMS9EWkCF5/HIhtd7XKHdhkUmBZBtCiOg6iuLcG/cskNl4FUVULvJpoM2Oz1Ky5voYVb7Q7Zn2oXozjoLwqZt8peQbOBky+AXWiBYrUphABBTLW47/bbcyqG3NzfX0oqT7IRQy9UlEKHFuZHLYqx66xMUYVIRIhudRoOAw3L+QJZXsL3wJxw8dBPpbqwtRQaheDSUHRqF2xRvIjWDrl5oRdb8Q34ZQoUQcaRB2OTkb7NQwC+T0tC7RmSdhEPd/Xkn5V9jUQjHSResVKt3JXYRXFzr555lVbKRCaAbq4O7JsozjAsgYwN5j3NRk6xOnrxxvZ5Ua7cqo/lqTVZ3x+Bk9PIkPzhKoDzKO2CfO2dIWh7s3kXrPAEgdZKtaXi/IeYz5XrvhW0M85iRJkWaEcCqYGbC8r3a9xUcbwCi5KLysDmPCQCfXVRrcdeixaqkImW1DtNJCixvlAGwhGyiVGpwBWwOTPANhaaLtiE0S5Kn5WJKn6NgCdDGhpzCnKoWZelVi+0N+X21+5Ri/8CLCQNVL9Fj8vVtEb45HvlU6D+v44tpTR9wHrLMeO8owM8qGx0vlsy9fG4H5t61Wdqm1DTTO+fHurJ08OstpLrd0QalsfBXglMmyksd0WRF5Bkw2cX7fPgJk8kb8XuPfpn/mnv/NTVx1+ctSFA8BCextgpoqMhgBT26A0J/qDoSDA2rwgOHazgeeILBUl7nDk7ziYioN2YUbJpdGJmN9PeQRkJkP1wAzFRhqMqgB5RkT+O0tml6xS3KCKEW0ELCeHOxq0qhhc+PthvsAlMaoU2MCmzBEqCxwR5gImEhmMQi6emyV3jceFVcL77xHfS8WEUu8lj89fu54tz4zuDlJj3j+Qh+dyUrg4kcc5hoJIq/pQvAengAyVm0vbo0I7EBnAfR5kc1sqS7LG5WRvlLmotFjwvZTNLoi/8XnGGY7rB/K9VIwoY1MmzAONsdW8uxv+XRSBAoCo+oheXrlJIaPGDXqtw7VLzfm4gTVS7OgHycPjBbRVmP894YaPE6P1sWKyfuGfsIbpn4jRe7kozQUYHLZ9PxzS3EQbWKUPnwbxHLi6fSsKCvPwOBoBRWX5t2+OPSPtcngHbXdE7YncDfPdkPiNxgWQ68mtgc/Bldsjt0vakDfCMdF4Do/TZZD+Amlx3nPaEyNPFd/RGROkmmCAKcAE0MXe2WxUqmaKo8YDlgYJsFxLmgqfSTIdqqhAh2C3ivE5wzlrxwxG8eK3tOvk7CECNmATVGwwImUkrNID8WuCUQ+ot4ophKEsLDaL79yHWFPGuXTLrqXI7Y0iCUBV7Fpqb+SiIuJVYfJfIqJNIM/YonBbasN1Vo/qrKYtMzy/+smZGbmeJ4jmx6lMrsKrqpaqapzUbm+29OjiZjw+VvTw9FaU//7lGJ08PaNkZR6PxZBih4j6FDhjJULjBTOXklQH3i+MkAUijcttRQXzbg217BQRVePAig2/cSN72JwUN15mPShJ2VKp0A2czO3noTnbS3/E9FdOjPPErKf1AdNbpXuHFEEp6xObux1JO9zq0lN9Mb6IhwTv0RlmJDyFmAFSytf2VF+OE5g/aaTK3UfJZKYYkyfAAouHOhVXkB8Xe0fb99katZMAt7h1Kh8w1t0f3XAuzdliToxy3t28dCr8T0rJln5PdUnyZ7/9U2O0Pv5M1ld+Xxq5+zq/q0DRHh3yHAKs6lJ++OqlW8ReyXrOAyyUYm/tAORkrYKbYmiJXVCGiCiKvULJsFeuBbbKYK9Ee4d5gEWUZ69QfWhKxth8DmARdSrHLIM1B7CItLogZ2vVWjYbUGQmvpCD2DimYNuoKM1wjIbNGErCmB3UhhePc8b/+A5FzNvtoEE3tFVrgSgmll2XR2N6bH8AevW1XITOX9eMFgdUZiwiaO+HZxJAnZzK8Cwnmwx75CTAIiIBsIg0YDp7KCcf56IAWKbgOIbwIcgGKiN+i9HKPBNZLZwb5mJjEeXT2xDlWS3XyGvQ9hPtpCzGKctqYZkZOsOyc2rekQsbsloKNC+KDzc/H92H1UJNAm9bKz1PjtVCOV5EdQ3iio9CPjYgazZ3XaEXRsvdngt2eAQ/1eUdK0hEx4fyeP/6fEesH0SqH2QWEHwPaIf2zNgt8x1gdMIF3zIkVYwHblQVaND1VO2J9nH4/dDgXhWo65F7ZtY41FBx5d7Neq/ZYLCNnvBVe+EzlUEpXB8MQJQJEKu+KdFse5oqDgsw8XMWTsd6YLk5TSSAAldEcjMLpj9tyGMaGVw0jn42ppbFZIWrTL4nAIPFiewUVz85I0JvPdbZyl1NJYRciIZ33+kMkDo0BV3u5db9/EQCMbTNKsq8owB6NhbwTTCUhIfvE1o3C8yiYZemjgGYWQBGjXc0G0OHl9x8kjFwJzKYogwesQJXo3kHbppzHpLtNkoGDsclGZ71twCun8HOMZuv1Muo9mQ4l8EzuYaGqNtE8410eaWfkwsanYtJmFU3kpyf53DFT0s+cnVhQprYGP6ogVXWgxDm4nYnr6kfaHBV3o6vdnikP8jmhQRXxVGDKx6N1jekgJXFbolUOmj81zoNrtDOqogSXFmZ4/lCjJQ95Rfy6OWEEAsDzCI4gHpyj0wiovoiinpEIu1dZKio5p5h1oPPUc4AV+gksYV3w64QZf+K5UQ9Ixzz30sZtDQWpIEM3qPUbTQvxkjNeoiC+tOKg4Ypf1R/VAEoYQFC1ZojI5o41LN15E/HRlf51oiy8YxyiwsRSWP4SArEFaey05+cHjqQ1YsKDBudAFjNvlIA683PPRPHP/7eE3H82s89pwNjpR7sDnRs5Ptf3kgAhsbvyGpRJDphrv3Hg9GebOA0h1IBLO+DMNT3RVQ7GaWayjkj1NJw29/quFNC9RQMUFY7OXaMDYRS12cAl3b2MK5h7+YhvRiRZvcRUEWIW+drZwbNnquDynpy0qpNWOSbhCKqb6A9kwMVLMYYrhVhE8XacPJjr1R5yG7t39DrIsZEQ60ClpELME4kDfJjOaprv/UbH2oKno+3utCkWaGzVi/lcTGfWYbK25hlr3LeD6HKs1dVxsUUkXe7yTMy6DFjLXizASSJdFJnAzTkRLFVCLBwF5Kh5616ZN23jW8kgpY2Oqu9Yq/u8a4oyrPV2iHFiX8PZczvDO8lihVDRnHBMxTzdrfr73ONaSidk1xsnw8aIZ4oD2KJ6PpFxmMGQEWRifNFRPTkc8/F8aaUHe75deaZRPTGI4M64PWA6PD1CyM7O5tXVHBUGm24huPcZ1yimsKI8GYgS47CrDLkoZpj7zjvEOkNTi7dmjX/4QZabRjvyNab2SPOgZl8mVnYWtexv7wMdLi60uFguFisVs5UJrdWusYpUJWV3P6xMcxYfsrykYKsr/z+N+wJnW+AX+YBlqVOROGMVbqHS3PqhDuolX+Px7mqXjjVaXJpAZYI7nRyLsdEJNoL1YfDPc6+fkpU7qijzFe1BGCVYINVP9S0+BI336xwW5gl7wZ9rrwGW7xIMl7UEttAM8rzgvv49RYwm2MbF+KUJV5Zs2LdD8yW6A9WH7UCYXJjaYPFupfwcu5bBl9wIlF7PW6XrYCeGDvKkvJs7ETbh3t6fjWCpnrB/UREN4dxUgqR6IypDl+70DZiu5P5gJREE0Crl7YpVC5DS4Rhfe2lTVbjZYgMokXAiwMtKw7eEg9ZETql0J5tueN0nywT6pXJWZqvl21OILJdLFhHEGipYKDX+UCQOdYcTVGqK91vReDsDam0dBpoZYCrUYYSWN+Oj/XEWOzdR2af9ZGpC//m74GhO0yym+fGTWgADkBo83weSNXnhs0OfI/6TF0idOzllS4DOwH3HiGybYU4c4LXdzdlji3JsVVKZWa0h7Jlg50rAknDe2f7nvxQGKnX8vixvHrkg6FeVmLXDOhANgrjvFj2cwo4oRch0v9mvCgoA9WyOJHnPPSIDHVIhtlcAMhU5GoLAOdsVJQ6xGhTUL8pW6VcfCXzwfiQ/C1KMIYWOgpgMmVr/ABDh/ZOls0UB0u7SrNHyGLtDDuuE7jvGdyDYSPq5ztxXD3UqgEMFeEBHKFdltUeymkBGUyVYxMneVXkMoDFLyni4g3JnQTHB2IUi1ldsmnmRaoQE/qG9hEwWc/0BMrXyoj93KjHkqj31eV4TXGrf1fzmPGuuDYoezVUH0I3tcgQBKXVC/kuf/YffV3f9MHl46UuVJ6EmUFT7iOVe9lwmxdAbwLNeLxwVJ9Nl1tdRaquZBn1ubwmVFEtoiV0pu0z+fvx4TzAsowvFdiJbl7Ng8wUGccg8bSleJ6hVpRROEyiw/9GQbDjgZqtIcp9bucyPggkN69mAKaKs3Z02Sj/OKGp7+RiNiAuVmsJHT6b92yqYPX7HfdFUU+CyrgW13/stksWM0zavCRKeu6anJMFGb9nDLFdEbStFbYpMhAFolSiFkADMk5bSAj9+sl8HC4LYF1eSUD11tlL+tobPxbnTsAIv7yQLBd6T+J3KcqWHMbWQm+8JXHKkNW6o0oOxXL0MVWBOSN6vAcBAnoi7gJFNN5HEJ6Z6zA/K5FhUgBzUHntZqOm+8tSzWtaRWkkpIe+jZoJZV8Kx/V5VHO9Mvm57v6bkurSqY0vgioFMiNlx355I49/2ozWT53JSi/oWg2uBHsVSQErXCj3r0kdbrGPdLyQZVbX8tzmpX6V2zekqgiBwO49WWZzIsHV7ZtOg6soAZZleM3Vj9FKrmpNWqj2m1tsI6lULA507S44tTAiq+gwyDFuNjdRgKvq2qkB56BdF6mw8N2wnrWTqsKWNLgyYquhk0XOo8Wu2/gg835so0IDrMA0NRbjk2W0FqlG784C4fcPmyiN/gvSAEvEmDLqiuCqDGohR9fzyfhK4iZeKOUZLQu0GWoSBZhEvZxk34o4fz0RFVWgN5+Mdg/vvjxTAOuLj98Xx7eNBD5//fyhAlkIsP7Wz/1AHP/JO29Syep2A8byzcuNYpc2DyQAa+pCMHAxeE2kIsOLjBSCqzLI79k6O61LxnP3zjRBgHuCBliucRJktRpk8T7kaq8Al8rqUENMrqOzg5DysYfjo4q0eT6W25zFbH5VB/l5Y0Ea2PK6Rw3A/F56erqg52/U8FRXTrBQpjc/u+X29aicpJrTKN6n3XblimuMUBF8Gd29i2WO4SdesSH8x4vJ8rVTAKsEhJszRG43NnvFpTmV5ywWIZR30ytEn2evir00xrZUampwqETRxg4vw15h+hVzR5dLMwESi5jP+wffylK75RIyq53SEtsG3EkvUAkgwMJ4Lz5vxqL6Uc5NuDO+lOd0IvIF/XDJNfy592HAzHLueMMSstJIkaMfnCk3d2zJEoP7nEoUw2fcYwuqInIT0fv709l7bt6Rtgyvnd5MXDkKgjK00yovjvTaW2D0ioL4IgMoiUjHCMPVP5N3kYiUx/SibAg4b6JXK346yw4LVd6ZBOOx0qynYrlUmfq5yByrpMsWqwXMD2pOlD2XaXrAd6pRMXIWq/Xg2/PfDzfZ5Y3RzuyxJz/RE5PFamUj8kMbbi6xHmPQ0p+W/FRB1ld+/xtGRzEAFoZqOC5b/Lg0MF+pRa50GmBBPwhbyTZYEiroCBlPBpVkk8hw47cnEz7pqAnISqTLxN0WKpYKuYVgxohyPBznPG6MVAoBcnFNASzxLNyw5OyvLLVsIzO9TwEs3tewnEXqPqtu7LkqvU/6jUdfx3AQC+aFXFDUSYDFN88z0aanxLS7wh25YZDOmatQF3YIhg8qvMi08PE+6ygLXs2I8XgNAw2+CiJAZ9H/+8fvX4h7rq5Gu6iHJ7pjfeuHr2ef+8U33hv+fX62p28/ezocf+d5FxaiLOTcwIEWjzCfJCwwxC8Y0KqqVsTeSm0xC7SseaOI2dRIc/NP+vcc0DITUnvKr4QzwTmVWtl6rouqXmEXsx7ZCLR4hHPLHolIA60lnpQoSvWZC/56Gqk9lde0MO+XN1GBrWx85ZwHtmE6g3HJNpdRga3Ny5+eIfxPTV341d/5pjiuDG9j1J3iB8E4HEREYSMb9PBIX8OjtlsL4OGxPG4AhZ/8SH9oBII3nzHYG0wmDR9fRRxeYDSsBHdZhveTYjTuGGeqq8x8NawFXseEyeyiiNQkq4N0wuUYHZ9I77yNgaoCBt7gxKSL5eDLAt+5KNTdNfJYqQSNMrQ7ugFqMI2JugALlYeWQa32rNLFZkNwqITMcIF1/308DZfMUFgXZYSGbMuC50L9eaqSJErrDWPlc68/F8cvbnd0dTkCMCtw6le/+kNx/JNr7bGD+QgxzpZpZP9S7k7RuL2oWgGe0BieiOhwLa2Vleeo1awfRjgOpV6/Zz/KbCStjAKCqTXeBT3Ai4ynHpGxKTTGLM4vAdeHrC2aMbdASraLP9ebjqufB20OzKfn31e3CEc0a21XcTIN7dYRPNZxrj/7odE/H8tr/vg//rou+O7y0asLeYfZGOz0yU9kY5z/UHZc/AjVTfcfFwRYLsr1qDnVxu14jFm9LcFYWbj4qJQOBtrGRd50U8aAcZjWJjdpBNJBI+9qEE0GMCg1CFFRi3chCxJ1xGYAWGgb1jg1Uaok0IWsb/R6csIdlzVZoeRS/gTI4We1ER77Rht2LmHo9LkMwDILkocIEPHYtMPC77uIEYDjnOYpkl7k7qMmRMmpqyLlF+lN0Gr9jG3SZlsrld17V1pNeP5gZLaqx5rl+uFLyYph/Kr9UQKzEDyVmaTQlzdb5f3oM2O4XQKAMzGrzMTfGXCw6Dn4vZb0E6su+DsWm+tLBkOH8/CSNECaZZa/o0lGNHKq6kJjFkRGyHbw4peX5D/DuoHN1k2k03fGb1zeaJJFxZws9HyPafBwfhT21r3wOfde9rh3lJ8KyPrF3x5ZrASwUmOc/CTeGWBZYgEsLqg+rM+nAVZKfJnyJx6ejoUtAVg5WQKwdOobG2ANkXrTYDGo6zSgh79LGLJU1wWdUA12CKYaq9i9o4djLumD9bcOAMuaI9K7o4H2AjMfBFhjHft/9ECBD9YEsNK3RhYrzLRnAlbp7+yUt9CzSqRVWmqnNVd0avoeWKW/cxjeBFh4TRmlKm5qtkGgZXqHRVFX9fc+wgFC41SARiK6Exvi+7GXgFYCWOhhyCUBrgS0XtzuzOs40Dp/yw46ikDr9jAdYCjlRUxAC6PHc0lAKwUzTcqP9JcDrbouyG/aITekFdahezAcW9/8LkDLT/y1gFauz+RAoCEItEwV4hTQmmDtQjUCjTR/5ICWqbq/oy2nJXNA6/LLQcSqRBYrSbt1CmxxoEWUB1qWLAFaCWw1p91fDrQ4Pvkw5ENXF6YXiKX0MHAt0RbiWm1fyNbZP/YizH55q8HTy5+XDexrzRiIXEZ943LgpgGZDJJ59n2iqy/Ia1CFePO5qNVFSM062QGiJ72w3meAu0jEBwHaXp208pwzWCJTXcR+n9D0iQ4dDfrZ2MVy24SOnYJLkMGzchJayUQ5eWgEU+UAuLzSIRywzHYTlY1dxN1VCQxWQdmtSyRJfYeNoZqDHbOZBiSjAjSF37NkwSEyomkbfTZ3DfaLQBrAYLsdvex4yu2cZP2rSJRjJa1vg22wa+WzgtN2W7CIOh9FCIMYdL8utw1VLOp6XRfimIiEJyBRZ6v1o2cPxsdCFPYQHG0Y+xSioxrS6TgXxTVvPrik92/lrvPltQR3ITiKYWyssmoXsVYhyAZuMRVSJNEHnY8aiPF2C05/d2sc5KqG33gp7uD9uIi6LtiHgyMHEf6VTZ/RN4Q3ootUsNRC5a1Tm3ecH1xjbPAVswcbekfaMQDbpXXaWQSZOxfJs/WluHWK+T95ZyzY110dNiyE0u1TWWaoujR4XNAuOxZSQxZLTXrgnHnyThyAFlG3MW/7rv+n/+QDqQ0/WnVhbjELpWZM9o9l1TA+1e3rjm5f1wCLS3UpgZ2ViscCWJacf3f89+a5Gz4MUQewcrLEHEBN5Jl7oota/WcBLOte7k7cOPNZc15l6n0iK4tfxCelJW2AgwQWTZWt3ZhgfS3rPuX9JyaCKAdoMtrkE5cJsCxhA9sfnLDFS3fMMYRq822xRLko7JOF3+OeubhuU0QFXiNAS/+Xn8MceBartET4IoLqS7PNQF0y5UAijOWjqF8KRREtENgLpqhJwUF5kNBt1VDBVHqWMTyq/IiIjgCqKitJdC9vPugmxCcnI2XQBicCoqLNWJJCRMJ35qTmWf3CsZBhOiaGC78GwWr3YFC3WaDqgzCaRNNqM2wLXg8DYBGRCMBqAixDEOy0J9pjXTlVYTPB70u8gnX6NaMNOKgyAJYlfM0vb50CTERERx4c3DA1UGnwKmMOxtQ8SH4aTnNo633nVD53lA8VZP3ib39zEcBCyQEsS3J5Ci3JAayz73f/cdk81wzWUAekffsPbi2awyKZdslp8KWJ+j4M7xKAhevAAgNT5VizaDGfB4yucVolmNSJPXixANZEceM1rB+4VgKsNAnxmC6uIclETYyIJQBLGWpaRvkgKZZMUgHOqug8/P0gWgBe/XuUo1QQU7ZiS8rGxcoCWFMAxirfSFadFR8lwEp1MgLQztaTQEXmJMDCyOtJtswIvQAg9dbjbjI761WLCWhNgSGiEWgldSACMUs40CIiFXyUCIAW0WQnDAxoOC/Z3mFDBqBGgK0pFTz2W2Rmc/fkZInK/g7mFpNiNFsOaA3XwTsLTU0/x6Vu6loS8QNdbeR6TUArvXsyZhbq9PlBFE5aChMb+iQW0FKSAVrmszNAi2gZ0Pqw1IYfGsj61a9LgPX4T4MAWGdvB5VP8PLzhQBYu+dBAKzmhKg+JcFgJbupJNGTDloJBsaHJzrImcogjnn3zh1tWVDS/euBrj8PgwJtrQoDayg1l7Frm1toe/ZKMFiOBMBywWmV21mjJiSVb87YpPDHxCLasan4NWWUL+3iPBNCpCZBd3T6HmNew2ZSgfjgOe1G10WFUyh0lH+VOwvXGWOHpXKH1aRyIGZzcqE6z0cd7kI1gnGM5zJRpq3wF5Yotkq1Cw5EzRZ4ZI4wBpWlqsNZyzK4v8fM5q5gx9d4+exIui7ABITaK0argZhYh4PsLMdDpYKKeujMm01LdTuO8dIHujgdt+BN8NSAqg5jcXkATQ93e3q4k9t4DJBalK0yhkeg1QJwDI3POyu0ENA1kPZCtCR3CU5axj2mjZKwHTQYqjlGK5XL1ITxWFC8Lec3m8acGzdBqPTak0A1Sz1T7J3KRIKvXOzdIq9leQGpjcyDtwDhBGd8V3lPuGChPMrOw/7wZOx39QOi+sF4z/Hc0dXn5j0rq0tY46ueKePkeAXmLUFvhH0tPQvLmygwSrHvcMurlg8FZGFFH/+pHNxnb8vj5tQJPSlRB7DENZCEvt2QsNci0iwENxwk6sDV4QlMEACu/NEpN1DMebh/XYMrC2CJcgEMEpENsIjutvOCHb2Zj7AfGEPOuLRJt4LseVm1BAotg8pkV5SuHQayhYgQXA6GqfrSJOmZQ/kzvTWBgsHAPFH3M5OyBbB0ufOA0BKV79HaHbN3scCrvj7Kv7z8KaBlvXuUfxPAmo0Mf5dZIn0rjEmFgIuI/FnXgYaYUkm1YjUFsJ2z7zhlw2MBx+RE0bNSA9CaC5aa+kT/Z0lg1QS0ks0S2i4RjdHbkwH75b6bnN6/1t6HKcgoB1pEnU0Wl+OhoiMDdVaohyenUlWAKXgswZyMCLSIKA+0DElAawCqd0mzM3ctzI+z/X2KIZxxYEg5KwegZZUfZb9RfZpf2oMo3286EtA6WnluU3H96yfnnizQwk2cUe8Hb11qsJUBWvWbNdVvyj7EgRZRB7Q42LLWc1wvXUPayxunZ5WvWKf7wRAOqG171UDrQ1UXnr4dBcDaPosmwOISKgmwXNAACz0Fd+/rHb5aQKEh250NsLjcfDYPsFREXW8DLC4ukgQiS4LwWfZXORbj6DUlf4bJ9vR9/DHB2owFNNw2Avyp7RXULdr1d+wbxEIzaSr3oSNtfM+eFX2kUEQRGM+10D8stsdJgBWKKL0I+wmK96vq0gmAZYInYF2WMEYqtIXBNN2L0VLPgWsMhki9j1FuREPZBcyAClxZBm1wmwOiRmqWRaodnAVR7W6VC/WPtdeJrrF6yPi0BYVWnrsCA/Tvf0cGJH3x/JRePJcTIHoVFj4olePpdpyEfnJ9Rj948VD8/mB7pAfbUadysqvpsywNUIxEJ9sjnbBrmmNBDVMLtnWhwSOyl7g+114xWMq2LecclEQwq8Z3jyTmUNc6yeIG13n6zaXyqb0GW8EJOyw0fKfoyClbJniGJ+0cgqQpJFMOlQ70jN7TsZDe7LGMFHY4eUBdrBRHGP/NAlpY38eyHQ5PgkoIjeurBbQaiAJg2pWKTat2ArCAFvd0jOUCzcI95UMBWVZC5wZcN3fv1bR7T6KP4iDvOZ7J6u1fd7QHY/fd+0AJNqSDluGYxSSchnEcdt7rL7R0/QVGBxtxkNS4NqhrFeTSiiGDi5YFrjILpuk1gu2ANiXWzgarZ+S1y0omW711DQJVSxSztaAqmB9rSblLktZWL2ChMBZ3DP2wBGCZedVehShglH/H9E5zrNvQ7zI7ZCKicNkh3SFCeLLpMFgvYS/Cy5+rdqpnAubWbJfeqV94hndbAn7vwbYoAGHINYRTuH5Hs08/fkeCpHZBlHYPj/7RS20k8xhYrbce5Y1i0DvQL0lddMdE0ES0DDAvCFeA8+miMYWPzgBqSzW+KI8ovKMCRIZMOWvJh8tDnQfVqZ3a5Y8lunHbdjK6/VgZAE3ngdpz+Q7HR9guUJUFMQYXSUazRaRDRjRn3X+vUl45yLKoNg6wmp0T4OrJH3fGUhxg3bzuBcCaytzNAdbJu1GAq2GhnANYyND0H5sDh/oiCnBl5SEkklgKMVEqj3cUF9yi1s+yV9Y9PJ3DREoQE2Clf6Z4UDP5FXUU8onKLABL/Jq4leEzkhqWTwqhkszlFCAToSJaCbCSR4mVpHUs1/7WXNfvagmwpjxV5tIzJfZLOUjMpBWyZJEhvCfxrabAlZrkrATWGLDUAkefZLkL0Jo67oUH/oytXNASE8Wvub7Z0vO3x4CjFtAiInpxPdL8beupYil0Hpx3gAlT5/DI7xbQIpJg661Hl3S6YyzX1o7YzI3VEWi5FG1fMKV6E2oKB04Q9Hfy+jtGd3fIYAV9jRIAWonNEupjH2VcuymghaEieFVwAzAUNv5zCmiJMerk8bBpmtlgIdAaKzXDNk6AVp6dYwpoiTW8JDo+lsemIMmMHsYkHaBCJcEVAi2iV6syfKVxsr72m98UwCeUjioWC2Nz3XWWzfOxJZvzgq7fHDtls+saI5Xz8ov9BMRqUN6QKDdRjkGAGBKN36agbv1frvpJiShTRx102/3C2J4y9WVSB015ofEP3heU1JBDYMp0TaqD0SfVbivZGKHKyrpfxKHqK/pgBLbuvY28B9oqGf0LatfJyWIAIx7egU9UE4HyBFirgqDSo4vCrRhtw4bzxmTF9fUuyrrEQoKslDqJq/faXYSYat1vmIOLS5kcJFKf6VMpCRDaX5J2UYk1Vf2B2AQxeBJGcZGKs2bI3LqVykvtN9iycXAJdnnD4y32Ib1++o33z+DEcVpoI1fHbYNQacfbQjJZzURleFWsOT2SVL/UsKlJP/FrMGYbbsL6jYlKFWTUd7B/pJG9SsAj9NcUfTkcXGEU9vpFNwlVD7vNKFfPbU66MZ1S26R7k6ci91hserXkofcyTMBuf9vpSD732vPh2mTXlYzvf3J5Jsp72duO8Wj2g90n+96bTUP7G6aDSV2Zq85aJ/sV9Blxnt/Dp6Y0N2JOSiaudWa2C7S5nCtj8jzv46mPiD7hRDBpBZYSIAVHEp7OZpgzjc381IZXPGeKyQIvWq4WHDbo/b2JxRq+H//+/X0DwEztmMYDc2ipeu/u5AlZMPLUN3LTfPXz3TO3740nQxWFac9gN5zm0xRShW/eHZur2TN5hpeL7zb03i/zdCFEf/J7X6eFMonqXzmTtX/iRPLlBIASwOLSnHetcPbjrpUSwLIk9dGEOlO5qNMlYgtRWvgWRI3FnYAVZd4KipkTtPNatMFasrtbwhBjFOL3Nh3ASvfztDtpzLGOWF47ofIcdj5zvSb9tkTd109EyYZniEhvMCJLIhsnGZovAZX+3vqBvieBmqTDTwPVzIkIUt4u+JhKRZu/ZS49CIZxsGSqj4lkupaXaK68JZGjE/iFkCQOgQnRENE7qZsG8GWpYlIlpoyHxbX937QwpXFrvWO6BsOJzLyqQxZ4RnWE6sHAxmS7IBZY9fAwACwiorK390kAi0iHcjjUed0KgrkfvPsoew+W661x2r/vpvdS3J2mHYVRIPYVDGMjHhblb+mP1ScNgEVE+TRkvLy5S/Fdehsm3i+GjWIy5E9e4XMqT0zRtAuDGnsseKZeU/UzRG1SF6hvlYOH8f2VOnGB6rjtydjBkcrQSB6edifTfJ20Q3OxwAbwlYb4iX7HZAN28d3u4U//qKGnf9QspJWWyYdq+J4EAVZzXgwAazgHAOvlF93AYiVBWg8BlmUQjABLGTCTBlgqZ/GNXwSwVL5ZAFjKM6J1eoeR2W052MV1N8Fx0IaWA7iaEQxbYYm5a1I7O7gHDMBjFbKqpViFrCZBRUkvDfUfeps8iCoBuIqmDGuUFcxUASwnE4Ijk0pke8uoeR/tY41FZBbkTohlV4ZjxQVgtJxRP8PbUpWN1ygj2lalTFFRv2uvY/NkYq+l+shy4KJgXLMggbECVihQ33hTzgKsJAi00IjdkhINq0mDJgREZdEOLFaSxGIl+cG7j4R3YohuYLGmyvVVUM41GwgDMQCtVNcyZB0JTKA1E+yViBbFZXMRWCUfVf9dlIZmCZDJ2W1Z4qN+L6N/CvMU02s2c0xkZFyAdti1en0ygFbWKB6AluXx14Jz2xDfi0kCWknQHtjyPsQympOowBYa279qeWXqwq/95jdV4ufqmlHHV4HazfjFqpuu4Y/nY0fE0PrHh93fROnxRarpnXDKZAOTqNO+D3APxNTwuJju+rhX+6f69ZKngbLRMcYNB2BhE8WHdQE6w7ATZ+cKWKiSioxPuAgeEj0fJVVuThB9fYaAl0kDA/UkGoHh4AYM6iV+vxC0lRhYpJkB1zoxEaVneR4ryckyBtVrX53Bxo5HWU/vlVRhKafWQX6n7lnyfdM7lCz/VhqUqb2G3/o/x4uxfqmv8owAviaRVzHt2BK4TypL0U8U+E7njb7EhaueTICW3tOJuiC1bsqgu9U/TdqL9GDacVsQzALAgUa0yxcs1NTalVtYpt4rwu9Onh/akS92pRwfQxmpbryfp7ZJ75nUhGzMF4nVZY3vfRjUhUQdqyUCdvbfo2TPilGCpzeedpNyShjd9uVzQ/njoaLXHo8G7lXvmfjj56O9VgmxslKsr3S+PnBbje7Ptg8Fsb/q3yEx1bxfTgARznwO/WVgKHsVFICuyFS0QwgOPh4aP2mGIU+yMicYHn4fOksM8/agzmN1SHNwMgtI9Ull8OZoZb/zSX3Ih08LG8lhHYS5JIMb4yZIUHheS3tei+H1UQBfZLGEt21iE/sy0ya1vO7+VjwdZxou/fp/eE2qDEWMsNQ2CRuw+nXel6zcpJVlxMvJj51o88d/1vWhFz/f9efmdLHKcLKFXxmTNQewpoQDLLPMF1JnGqoOXDXcyzmSmExdq0M8WBnOE8DCf3NZwhio6LkLUhkoj0OLZcjsaF2QOzIrACm1JOJTKeYnzUNsPQibKNyAP0gC4lmANSEeglFiGWETpQ1TGZUaKBQkzk19Ex4wtLiRDGECQHzXEwsJvqa2Hi3k+LUSVyN7qrw0EbNEUv0mJzZ7JempxVnoBbhb8nA4xPhHSZAhygGshc9bTPfPATGsSwKKJYwPXsZUXfl7GqFViDSLxQGWdRyjEwCLSLNT77x3IY4Low9ttpJirY0YXijbbS2AV5Wi2rNXOOyrEWARzaB3KahadriBK0PeUy/nBbdQFs9/3FbSyfpOxubCvJxW+BEG7MMu6M0Xzi1L2N0lcoUxkPK3IMvlkraCb9B3rdACNGdRhXUgNwIsIqLtuwVt3x3L9nUXKoczfKEiQ3OAJ/Lv8OwXgAE2jOLvKq8EZH35D74hjjGuFRHRO39XPury5/KzO1KISxaEJVm7sfGPF/oaHd8oqjWOp2eZEjUIFrghL7EdUINpCX0dnACOxcHpVECGbJ7Lb6dCZNxX4D2XvLffQ10MVZ6H+dVFXeepTPFcjg/zqztnsYiWUc8qRISVouceYSQWBSo1RHmRLpmU1XphPAhB/QIbJFQ9nL1huBbfJ/aV+TA4Nr6DWmTvk1JlUWJlfc32yYJ8YiC7E2309/5LUPkd8pMkBjVVccwMqbb5iUGByzKqdleqYyIDXCz4DgDWXp2tq5s9Nu9BlXntltk4YtssmQeW4ELENUtUm9aag3ZkaKZSBZXmas6RKMkS21XcPGMcMUtwPcbg5EREL74kJ0TEN3eVD6wuTBU4/75T4Ork3UjPvzoeP/23kfZP5j9mKBaAq0hU8Bx1jQZX7Q7UiydRgKvEvHGAFaoo7Gq6ZznRkWKhwRXegxnSTTVjIBm6wEd717RE5RHhdyOYnqC3nTbsxsEbS6Lq5XhN/SAq3X8oCYwDyA5eOZPFXeUvJOoCkhqTKgdYsYgKYCG4ogDVa3V2+FhI+jnZY/FzHupTvXR0fJgZN55MVoO3YbvTwN0CPGpitQCNFfCRM52ZIszYjW7iB/TSw29updMBN3wH18SbUno23XYNwUHW9Y/O5IRt2ScSyb4TdP2USjKQWghMG6zMOFPj3GJuWye90aogPPISmCmZZ+Dh/RPy55JtKquWqgrUM9AWDdhgne6OdLMfdwFl2Q6eiUnOdwfBdv3kRefCz58VI4mgo/hcTOdD1C2+roBAzo2XHbFxGuhaDCWfP4w+EM/A2DHN+wh0UG2Nz/LyXCyiBlR4jTWPW2OLv6eP5CwbxRbahqTmRLGo1vLhjbXHWlNyINYCtSJqtdPXYH36uvvrsV8WRyc0CtvnoKmiznSHh83xrTPGnkxrV13r1EJoixW9xAjb505nZQlEN5/p7vvLf/hrNCMfvrrQ8sbjAIuIsgCLaCF7Ba+DAUmJtJExMjb1mWawFMAiUkh9CXulEb/V+/MDUe02rB0T3mcu7PK+RZ5z13k1qDK4tIrNqAhjGfV9FoZYwGCpe3BStapiTEBWVHku9YX1sUAyAMsq15K52DjjOeOanLp5AW5bRGkt2QDjwmmpMU8l+nUnjWax8LuYE/+C+i1gsLJiPRoZKyupLrJ7GGspSoBFRMK7cCgGAMvxkKf5MZo8gjAioqu9nMhff3ilwBxGdUeWq9o0qn7mXj5jyG7KAkbLXUNbVHEeYBHZQAjttyznJ2TN7xMseCYV2iBl1M+3ACiI8m632O5XEd9uCcNWRT1m4dGHR/o2NW9ac+s9WC0s9/BI33Mw7LXvKveJoyrk5B3dQdIi5JsOJJ2+3V0TXTdvn/9gbJGrz3UDvegjxBd7ov1rjrbP5Mvdvm533pN3uutOfxzp5k0nGK3UiCpLdzv+jcV4vHnm6fgYITIRuXGAhbJ7L7SpcdHydmDqubSDNVQHQ+gCFzu1C69CInpg8G6Yjvr4tDXv4YaXLozZ14XtfUxt4YYJK4Gw1DYNNwp3WpVFRONilq5Jg6nxI9DCV0+G6f37u+jIcQDo2eBhbAgmBFcMFmmVsOfxzQKphM7pfYm6iSlsxl2r2V6RtQN/FPQDPslFP/ZJHk+rS2aq6zOZTiS1BdpJ8d24iwI5Wf4W/BIzAbcVf8iqz/CM9M1HRiLZ17hNEOrCZJvliihsOdympdgvktfXJZ291QGt62cnY3sENkY4S8bBkhV/yRIv+3aqv+lIgmwHG2cDM5HKGYLtOduoOYzgMzZ+yH0XG0/HpmObNqdHCr2BegItbesHg/IQnGCi6mNJVe/Zx1WCRRGGckLryfdl1fuS6n3PGF7sh7hYl/stPdgd6KY3lt+UzRDAlIO5ogyD8X0CWiE4UWduYJ+8K30ZKKRvnpjGNC+y9hLx0/i8WYXRYD6Q+FYxZQ1I32F/Px5hDFcDzNQwvti/0zsEOCbS83Iab8kAvrc3izdde7jTPhYVZ4ZaR1S7oY9NAjnErD1W93tHgdkkD/EKWzfEfItlF69wUg3L2x+Y6NgAi2WF4ijiaHh+0ZB/OfajUI1aJhdpCNzsD6NmoTi6STVjcUh/uzIOj7vrmv6dyz4eFycOmrMoPcBjt66ne7fPxmuLJWF3ZuQDMVm/8g++qc7hLj8BrCS4Yz7/QTsArCS7d/Po8eSdOACsJJY9Fuao00Et5fHmmW4S3EFYC6KVXkaBkRmANRaEF8hB5WonABYR0ea9Qt2jde4LWDDSLJeKJIzlts5WEYpCvJwAqmDvRhYwbIqhzAAsF1zWANK3mlpexBoSqYkN+wEeR68Z0yzAMuj8RTtHAzlZasIcYaXUH0Z4CtWPG2fHxkI1IRjL8hxwRJ2K8PoZ0ttQpo+ajcL2WdJekVQ4BwUwrW6RU3EZYwTZvdh4Zc9iyRaSN4fgBPCpj6WyucKUO6H1A7hK4uH7XQKjtSm1vVVr1BfVj0URRNBSIhoB1nACC3Y65yrOKUvYl6m9wZL0NrwYH815WcgCtmUJ+xlvCiOcCVxTRsOI3ngeE7831h4VAmcZo4WqfpOptuYMfnjRDMFIiQztAZHKklEcnRlOJyfNTn+/nFYhgS0uX/3d+9lmfSCQVUNGBvSqMqNyw8th2IauXHnf8YFT6UquPq+vQVmS2w4XPFNlmJHi4Ki8ynhJGbmsFnlNLTCAPj5F5DjxfCYVqAOrS6cM3JeImZLBakIeHXhfKENp9Cr0jdMqwQXqK1TnRq+TSmtABV6DRHpXaH2rBeNd57NcoOosoih7MtH0KxArHg2KCTTUpGWMPzQQXuLxhQ0GHlZEZMdYwmuWDGO1wTG+C/aDo9MexblnF8Yibdq6wVxkqPOsOFolU+e1rVeLtAI5wSnQsl9gDL/fy2t8EUyDffksP0S2H0Qx2vm+Y4qyVSRyN9BmOC1jVP8HTfdfpj4oi4AapE8azs1JEXVsN8s8MAfsLcFhbCauVhfpcws2LMVp3gkCN6DFvmOvuKhNIcbBCppcsYJEq1iIVpvCuRoyCt0VnA/33dfw/Rf+Nx2LVV3qkAm4iG3fl4vU+Q/bReAKXd/RXouIaPNcHnPXz6E+2I9aCaaKW6fAlbWooudY2ETN/DyAGy21xSJPMXz4gmuQYYiGG2twAmA1J1ElTT4+yqO/WJDOi5WzH6rCECdluAQBR9T2cxawxPdyQQKssNX3WUCAD9rmNKq+S6RBiHUNAjk1V9VOtQcOfCLSNjv4DpbxVEvquytRnpzyvax3MtWE+HiL2dnJBnOlnKijlVuudbLRjl7bb1iTHJ7CkB6OJsBTzF8D4m/BfsryCrUMhvk5T8oA3AIdBQs46lykwmAZVABSAEHORwWwEFzF1lG1kyvXFkI6lD4MqXSGcxA3CxksIqKmLoT9Vnv0up0tRobHtiqjZnYMAOYw9Mtpq2JwqbnGkQRYl6WqX5f2C8YOsk+LPFmj7PNWLlAPfaWKKsSJpZGwgpWqslX4niiDsi5hsaJTtpPxRtPwxQPZf9obHSW6eC7v274HG4EtqY2JMkonPW9Zxu64lhd7J8JGuKDneFzXQzWyh3/2j7+uKzKz5f7A+2EEWJbgi7/8gp7R0eZqiev59j19blmcqgXXgKjYR9u4qBwV7uA+RrZmwcY5aNbTH+h2RkDVnuQHF4KTUN1zJ3UPN2Ez3uaCKOjFEu933KBZExiuh0b/mkuweqdrUJW2MFxARFX1kv79irrhEjYWQzdY6ViUCmJpfCKUBQbN95IFqh77vnnVjyXKC29hfCmsY3udZ6eKBWq35891cmoV08vwKGxqVAsuZH/4c5ZGTYfLdhfaWUCJYkmM8W89/z5dE7/hEiccM71Q/lFLspOovrugL/vzWhvkL5mj8JoF3/TiL3W5JwvMiHDORI0NEVENoXmWgOSlQ9CSDwSy1IJjqKk2L+x7eUqcKaN24e4OLJYFsJDe27zQz5/K0SZSyjgJDAeANdNaltrFT9kY8XKMNiMiOQiRoVriMWVI9ULeeHjSVXj/RsvOBdHpJhe73IQ58bMYBI1btguEoKtLhRs6VldOBpaLqT7yHm4nMNVXeAwXEzw5GLjDs8ZrFX09tdg5+W8VamNqklOMk9y55WTS2N06zQMxFlFOohPfy3OmBtm6nu0UC5wn27vQSui7JD6FqhAvB1Qk1u39I0QmBPSUnejbPJJ2bKUtVmKnAix6NQIWkkDncGsDKm7j5nwU75LYp8BstsqyVTZcRCRSAqHn4FBHBrREYmgiavcGVYqqu6mxbQXqZDIV42n3dNxpudbJTejEt7FT1Nxt/lli50hEy8xFrPHN5+datqEzQj1E+O6Tgm1sxDDjMthT8hAkJw0FBlZbtL9L58/ky1dXEPWdiC6+Mw+0cO627KKJpPowbO1rUOVopd8J9yRI7qUu/MXf/qZRkjysLvUlKGEjVYK+1TrXRm+iFMCyVIT4wdqdDDMRC/2sFo28STe+ZaCH4Q6ac5lah4KjcGp4LaIs+RS4UfdRqZBOvyd7X7vTZadUBUOxxi4O1XbtLugFDBf9DVxjGEEitU9kMEaB9H2KeZJgxjVjhvepe4h0sFwL6Cl7gYMTOS/bE5vJtFTTolzLq1HFlaJ79YWsi/dQp3n1gmmDlalPNMaFWiAikT8DdQPYhMTbQqtjIIaQbVS8AFjl4ov1dVQC/RDtB8Mm5NWo1kJntJmHcAmo3sNwCkQduIkc6AanHAj8TtvIeCgbI7/fXhtxeSIJ9WJzLFQ5lkG8YqSUHdsEeBFea2T0eSi3Jdp+RobpPrxjqFuw6Vsn5yCX71Ku1U4ri7odXORrp0BHF0FZ1hff1XIUwrETcOxA3MdUNt8suuiUyt8b9pThVr68g5yanboak8c6MZ78racH35HvtX2uGxE1STdv6nfHObvdSCbLMoMx2cuMcxwR0V/8poqZ9YrVhay448PY/ce8CpvTSLdvyheuASyFicjYPDnv/jWJJlMCSA6qjo9IvR56JeAHsp7VnEG6lspeEJGdQhUTJh8errthTT21YGUnanm4JPqv9e7tSaTyGhY33HB42WlbzAZPpCaLaHmTEWkgBgPfBFggyBhZ+nkiUolHEVCFglQ0YWxH3O0k/TzG3VJBEHFSthYF/GQKOabzNC844TdOg6UFkZWxrAhG93ZcLn1e7fCR1emfEVgMo7AvhIFzvDXYml2r20gFe1zIblorIC/LshUz4tkFq5/zoi2AZZ1HUGwki8ak0kfwCkQ1XbJfwgUPJYAqMQSnUvKcnKEVsjxseiCHrJuK/YVAqPbL1GeW4Cc0Punh7RFU7d/fKXsjxf5OsGSquxh15OYgJnu1ZENARMV1finW5gTyd7U56b0Q1abKCkkBgrazKtk5MlRl6MA9bkj4pmBCjXn5Rfle+6ewpp7KzevhYecIx53hXJBaiMVJn3EejSTW2ZQVhRMOd/VwfEU+SqNwl/8EtBLASn8tgIWu+PvX8gvE8RE76N87AazD0+n7lHHcgsBlFGgYMAlojYl9Z56xIPqvEr6Ipb8ziy+6z9/8ja4xpwAW3DwM+qHOc71iSBLc/01/rIWHg5cJoDWruurvSQDLYhGHarHJrj6PHXPZv38CWlYOwUQBJ6A1AKyZcSTaMIomHNrDBor9b+n2FGPoLgEM4/iMuYUpMUuLgRbB4pMD/PzckAOzP7GAVg9cZYaODnPRpYeE4P3fTJLsO/02VADKhm/LRQGuu82/48LTAywEP6Ja/UJ33Jd03JcCYLmZMYssVnpG81JPXBbQOjk7iHfH8A9cmp7dSMBq1qYqtW9awNkcO8icmjCB0lS3GVyZgNYQ/6qM3bySSXw/THeQdH6R7S+7Vl0/B7TSQ1NbWF22kXP2nT3fUEuQ1IxGvYYYbv0zBoBlecwbguzs3D3pfRLQ4jbfS0xLCghVMReUdGD+YUnr6ph/1lK5d1HljU6eiB2pvHGCwYqlVu25qAFWhDFs6UfR4N4FyWD5Q2ejhUADAVYN6VGKWyfts0gzHbGSKXraXaD6ImgWS6nJdMdWC6zlfYPnnMFiQRseIXrt4c2WDm8CBQyI3GReGs1iIROlANaSwRf1fTxYZxKku0MlQzLEQn9TK9Boa6h950AbUTdgcdAiS4p9tTs5W6wpZoJv3GVNpV264/OskBCLPAmtsnJR2A27jnCpP5ACWrtWqSyWGOfqgvU96CXYBTfNjEPcm1hhNYwmPPsrUKnUXqt9LuU1oS6EmqU9FKZtC3oXKhbhpCEPuSBRtRejU0bsVp7Ck3PJah1fyoHQ3JYDwBrKRrXh0euE4JbHL37n2gkWxGxDYEkOb5/S4YegPmlJexiiGONJeRdDEb7RzLozCNgl+F6n7cG1J5g5GC3vQVHMwSs1dy4Ho9sXRLUfUlwR9UALzT1w7B4Lpa7WKYtkkNfLLwaqriJtXowX7p86qs9k2Vc/B3280c5luH7XRhJqFd/R+O4492+fO9o+v/scdGeQ9Yv/+JtUGjlbeYRUIhZ3aG4j4+XfpZI6dFL7pIUZY2kRjTrzZI/FBww2vIqVROPik9iUgSGYcsElGnZk/JpFnmI86jH/awjfceDgKF9ON2hz0TVWAhipLS3mJSVR5jHAkBlR9jJzwqNrTwi3cciBIHFf/30TwEpsU1Ix5yQN+MRS4kAlGlnaIRJ6qusd++/Ies2MEdjFpmeKnebMeE+LTnZRIdY3WXMX116qMIxPEYEFHNQZc58tTaxzDIflBJAW7IHZtbafqWLTKj/fx1FSQEtcD39nujgHBC7ITVMCWGffnmanBiP/tHBNqdxJGp8nsDQYys+xoamb9feUF/kQ1nNAKy2gYYbRUkz87MPYP/tv5Ti7teA+ItiEzKiQ05hA21CTnZp4vrDFSl3RmGeG7gkk1RziUnZm4CxEpFWHRIylM8bz5LNaaLPGMZbMWOOSuj+1XQLNlmMDCrf76vty7DUHT/6NtfZ2fxPQuv5s9xfjcxLp9WvzwtHmRf+d+3OW9/hwP455mjimjlz6xX/8zcmyUO4MshBglTdOAKzq0pmBHYX904kGVqjKKW+dCipWX0S9Y4DGrV7qgGaYVzF6CbAsOjf6qHb3yLgVe8NWyYhGzTvrMMDZpOj3zgiwqOuD0gWTY/e1EmC1u0j1g0CHN2TFEbykzsjroyIEFxJgxU3UvcdTflKFgRu2gcJWejRqtkqzBu02Kps5xWDhWus75lKAa6cZIuV8cRp1GiX8XvDuqD5M5ebMh0x2E6+ZKgR3zlZcIF7HKmomKkr7kOLam4byaCOX3URUUfcNXEyqoAFWEe0cgKI+UU+GGAgyugFgDbdZYw61fwZIxUWwuC5EH3KNUwwWX7xSfVTsMoz1ZESBj9EpNkoZUldBhcl4+FCqHcqLo4hn5FyXc/DkdARg28pCDfIw7EvNTOJ3dSQZrMj+mxEzzIAV4JpnxABG2O2Lru9hHLtcmAMjdhKy5qHUhu8mw4n1RYVHFSlsorAFdbWXDLARlDdWQQNDw6id2xH7Y2fgz9dN1xqBn/FZt6XwiiUi/Z33BRFjXFPfEP3DyFUbwQZ28yLS9c/J/ouMVv2AqLqCNWEXldf25iWsbTVoJ8D2uKvQSDCkY8QrqMWbkw+keUTVX9h0/wn1TUL5yPxzT7877naIqKs5qJcSs1UwkLV7P9LJT8ZGtIzZUSwvBAxOljwKeZT0Yu+FgZy5yd5IZmyoOwePE7ucWUP3ovsvMVVEjK1iYNXvnWhLi71Dafq4ImLXbmWjJ5LfCdWGM4+6T5JS3h7+QORYG6aBxIFX8yC1vbxO5EJcwjhal0yte+ydVd9bpD/oi+d53Kbuc/BvDBUyJfy6gqhlAXWDFTCVYAHEsq1npf5SwMKxJCQH92wa2CXesBNlQBgUrnpO49C0ZcFvKdJa2VMmZ8bc0dHtG+Ozrv/GNJXKmeB43ixiH7j33kCULBg/D87HkAYhOJG0OSWlbgDUWUBLRO6fAiscVBnexFPC+3b0BjC37pkLM4DR3LmwMYUGz2h6OidL1hQR5sSRXPSMDVksYwdiZhhfP5GXkddZJYieaStFYByMBpkLOJ3+vUCtz+f78qWnF18df3v2y90zbj47XlNfkBkaY2N4IqJUDGgpb+++PVoO9FwXaQCjDRwv+AtkHzvInUAWz1XIARYyRUsr0m5lX0tsliqPXXOXrNi798drT34imY+kDkLWKwewUE87nmdUPuq2E3trGCFz1sTXJHtRShw9o0LAAKRzItgpJwFWClLKdz3RjwBL1jm/6MwZvQ87NOtTzsxqY2JTeBT7hm7C6zABLC78W/paAqwEUJVTBH+t1Fb8kqn1fm4ithw3g1NlRR8lwBo2MAZjNVRy4pnWeR4b7kEQAGtgB/i820IdLbAzNeFaCWXnrtm2ur+gLdUAwPA69s8p9bb1DbgdUONkX0/qZT7ub71gvjjQGqo4sVGK52wiUCqLnv3mIUQar81cgMFK8cceXshtN0+FMxXBh+cqTECLh3Rw21YCrLQg8zY6+jsBLC5xZnM2jAEEJUzMDe55a5a3xODZyojAJVTSKzmxI4JAwAg4d4lwuaAdcengAGvOUH/2t6nn5jZwfVLrQVI53NGgCkLzwoFWTk7fHl8WgdbgmMQeX7104j0t7/R2IoYW//YcaFm5my251wiorjULw+m06HoqlbMI51F4ZVmGx9EbBsrw4i4QHR/rc5zRil43IgY8dW2XhoXraWNBVF2OL1JeexXqwLU6LpaOmxNFy4aq92ThFO0SjzJH2vAR6OjoopxgYpfaB9P75JIvp6zkXH3kolQ/WkHtTAbKYjb4gpkWZ7FRctorDdOQHZ2eEILsZ106HfaoTa8eRNt83OGh+rrqbbB40zro535C7YCLAmaVwC3ZxChE8KQM3xPGm/MKtMovjOvwmhbYM25vyKuQ68et08bOmwCpZqK+x7oPBTfVbadqRdUdP/ZHr969uPZUgI2WmapE5R51UtXgo1rcb9/S3ofKSHkT5LsGUIs1rjNABnWN97LsoggiUGg4FhQbT8/fH6M0RyIR/LUoW/KFHFSFD9QG2R5FEej8YmTC4tFL+7FN6ArH9Cy5ac7paxQQxXQzE2UrzOIjuWsWjPWq/3eU1+TygsYq5h15QGXtUtL53AqLdY7df84CKKl6R9/1Y15MIDUe0CDct0AYHNwQomCstwZdk1oLfk0rzRxc66TdcHRdzlrYlKMt9+GJo9O3mcnLtvuPb6TPvx/Vu5lAEYcrhGV68G2ih38+Pv/kx542zx1tWJ3ancYpGPQ8J3cCWdV1HADW2Q+7v1Pxirhwr7v2RFY6MQVikevHaWKV0kS2LFL1+O+UNDoBrLm6IvvEwdXg3mp8yBQeIPWnqaizXHhnRO80K3nwcP3Ujg7+La7xY5vgJDQXuoIXV770csFdpFKz62w/i11UTPy17mPt2O0kx9/QhopL0rej48Vc4mZh3uNlP5sDGmoHvCgUNLu8X2xNw/c7FbTgmlS1Je7pvOj0/gscG5S6cEkeTyJtWBvhr1UvDraCEwvTnE3OAG7TJYIZXDC+0yVDv1pgZE/UAS0OpGfULuWmW2US0OLgaioiO88/iFH25xI9NwxwnV/cyjRJcyz78LD8JZMhajz0F5oYA31bDdE3uB3sdZ7u19552VtGyWUHmCpzSd+fDXHTP95yWkqamt77jrcYmr5YMqx1qc1n1JYCXCktzvSzzr/VIZ4EtHbvjtdyoDUlCWilnMdJGyOclvom5t72oSI6+/54CQdaU5IwS2rr+oFtgG/J4ojvX/3db9DZD/QPyBCpCOkGBYeGxbEkKjFJ8RNDbQeqOjTYtjpkqHTnVt6MRhvrawDNXkRzokZD4rsmKU6C7WZG1FZBPKHs1mB+KL/OW2CjfoTbG6Mga1zgRIKD1cfZATxcBk4QJrDBoo/6O06pe7kg+Fzq/arsHcx+hSxGzLNBC8pZHCfH2jmj5NZNoz1MlTb2R4v1xOc3XverBbHmFqU7WRDdeekmCfsE7qzNJOJLPHEtmxk4VRl5+dAbsKpaunk5xq/ZnB6paeaZMCKik53ciVqtcfmukYYDBZ0VrIKsT4bXWQ4/WLY5FyDlnn++NYbMDaVilI06YqLpOfA4IyoUgwHYcf2w5jgz1AxIi57jxliwbLqWJKhGOfuu7Is3nwl09tf63TCoKLevJiI6PNYPQ2cE1HwRdSwWyvEhYBAM72SA01hE+vPf+jWimbde0PSjXH+O6OwHRJc/zwrovQ33LAbT5v3eLbkdWYP2dFTZ8HhI6eM3DyKVl44OT5lNQdJQ9NeE8zikTakunSgn9IbfRB1jZdnApGtdGMvk6WW27xVUM8PxFLqgCw3Rv8dJpLqPbh8rDbRc7QZA5BoiR0ylwFQFHZ3cl1OM9j3teRBldW3EqGgObgoad7u+W3iHDp92doVeSKLrVYFM7ZmABQKspOL1Bz8uEumSVBCRXByCEwEQQ4qZ4qjb+aaJgrn+u9rLiTCRCUfjPdwIOl3txIKWqoNR3Ynk+8aClIo5GTq6aO+IVUqKfiLlC/NQZk/7d5Vh9QtuDHmwJFDoFHsZx9+E/VaEe9LlfGfPFwAnrxvqizHTjHfhZSSgHKsgGZiBDYrjYlhGuVANgUYZ5ZrOQVmCBS7ivAE+ryLv195mpaNjY66COvo0phOzOIJvF0dQlcpNfzuPtPHe2UTh+Furn+9PG2p7sFSU7ZB/kIgoRmem3RmKL9sBaJ2cjAPkcCgp9GzV9c2Wzk47ENewHIaJHTscKto86O49Xm6oOBmf16aI/dGNjGULY6Z1NGuP54j1NQRKaS5g372lsa+kQSvGLJEJsKLrzg9qcDeS75FtYnA8pXoNzDKrlx8nDt6FxYZoUHnob2sJXyc6cJ8YFRnPcdAORTfYNA8OYE72R3OebYjKxrEwNUSuB2vJNlP1XTa3yFAQY9li3mHXXH+hqxAHW8mj8OyvvbTL7os4/XFfj75bNiduCNuU4mFyVV6xtwGWPxJd/xz1zyK6fWOsF3eaSyQOgq2hWks0OnQPm6zrz8nj5iwKgJUkFxE3eo2uOcAiosG2C6VirFf0OvwDAizX2pQq5u/jAIuIqDkPKvZWfSEb1mSYSO4u/NGpgYofKGyjAFjDdYodgeMiiq+IUYy7Z5lVFFJeG268IP6g7Vm6m2G3BRGm/aaV922CtjVDlsPa0Bu2RIqldBJgpe+OdnS5VD7dwplpe2NyjN6uu3yWk+Ewphbe3I4wGgwO3rOABTPFYnsnAJY4RFYy0gJmyqqkU/1YqSIyaY6G67BfW4QaVsEITqqeH/KscNa+JUkuSn5w5E9hXCGbCZU5vegmrw0Ly1CWrQBYRETbrSz3+mYrAFaSw0FOrBxgDceZ3KbKtmoqCG6mj8Yi2mrtBQFipbeVU99a9QWrDMP+Dm/sbDiXLcRzgvZORLpcKwZUu6U8cx3lWmV5m/t9ZnNAywCHdc31F1q6+YwckJbjWwJYRPZaXuy1rZSV8cTafM8+mzqwhSzWUoBFdA+QhYsVkQxWSUQqVkVXKzgsjM6Mc6bxYZE+nLO9SVIcJUIlstWY6r69U1HcC+iEeExEKr+hqTI1FggzrtESAZsAVN1YtmjIwGGOPyKtOonlAtWWIeFQyIUNvdKI7HdVscKMa2Cywe88WTY+Ct41GHGdTMpdqYONa7Dv+3ivb63s7rwe7GY0aPS8WhI24Z5rg67jwoJQDWIubHBsvQbeZ3wPtL/swOp89SyxFjadIFxfo8YQRrYnUujN7VoVM2u7yUfZ3Z7JVaVtCpU657DXtP9uIyeN41F3/h2AtfbGGCBLvj9esgk6ebapooa+b6msjZysHIjFKtwrfAxxtouVpa+7x1hD9m3hEMIAyr7Vm1Az3Reqvo1+rear+5orgPi9U3Wygoq/93eBgDH6AxqoYznOaI/nv6QbBJkrC6wtCX00PHepTdYv/aNvyoo8MiZzy+sA3yGSUu8o18moFwb04Nu95xTAsqJ0F4BcD0+MeismLAq9dnnlqDZCAOTKiUXU3pGKZYp6EFkTSo7RSvQ3EyvpaPRSJVgcDYClPBr189WEYgBiv2llIlFPi2KoOIj/ssQGhoJTAAu/R3nlVJ5JX0uAFTZ6sFpMoI63An09kgkkTZssi2rn11gLFX5aa53Aayzmy9zpG+dyGyKVQ4TsBRbrhBM6MoGRtPHskjo7Um1SQL+yxl70xsJkLIJ8IQobXY7JLJzAQlFGDbAsUIYguQx0fi5XkJsbuQXf7mpqGRsVIw1qxiS7k6MCWCE6evhgDPmwP1aiHCKiEj0Iiej6vVN1TjRccHqOaDRbSWi3VjvD8xUYxaNTGoXJFFRQDp/HXO3VeqUSphvluOBUDkvF6HIbBH4uJ1x92ovyeDewNgZmnlKPi2uC1gJhnyUiihiA20pCvQCDYMDr6InOvi/f7epLsuJP/0uvtFvcfImI+oCj8tzxcRRt4FqtuUKyiMi2w8J15o//468TzbzxvUI4ENkfFgUjthORCvBlfnwVhVqXU2OeQEP2r4P6z2BrLEF2akony8VUE91jF7M4oe99sthHPRgsYKpuQ2BgUcfGpBZR5XBfdmRBLw048En3rcJg9BYlB18gar606mxpRu4TR8j6ZEs2VvfbbN5vl5pT03yQZy1ZmxYwribLtKRsVAFac5ihTlDq+Pt+jyULGBi1/93P/bW+xnjZZI+VZFPe0dW0F7eBPKknxoIBbeROG3LoGbkgtVZOlTV534KN4pKQKItUR1jOwkCrr0wWVFEZzDu9MbHkPgCLSG9m59LeJNm/pq/Zvi/PWdHYVU5cSytxD43HElnMZH3tN785ui8ygBNxB0+6sRJTNRpRd78jG4HIsqNNx7L8UbMVLpBiJ6oXTgCssx94BbAsL0gVyNKw91LfIQAI6C8QaWJMAOBMVkNcg3p4cxKI2jgYVC++JtGOaVHg3pmHJ1EtFhFjmfkJRg03bTB5xQbUgxgHiIioiLLegV0LjxNlwwRXvUC2ovur4rE8xgEu+1Goopo8LMbCBWA+LAZrqs7pm0wFZ7XYImf8nmF+sI2WRDmnaLCuCxYzxbrhu6ZzlkqCXWPFZHPRyc2EscsnkvWOPqoYWJNxmdj5UBpsqcFg6ETbedVj2EA6o21LdAsTDTIjfdvzYKNnZ3s6gBpvAyrEuu5+/zuf7UDWf/HdLxAR0emppVcfpSzawRieiOj2UCkmbLurVTDTm/dPBcCKtSe/lRNLwOTBR08O7M3UBo1Izxmt0R+IhBerOxSmJ646t2TTil0WnEOUAThRN38ZzjLi3NSc4eAYpLz2YtEvbpxOLUZAiDgZAZ2oIxG4+mvQ2rDL2l3QqtcljDdp0xTLnoy328mPHDVAjO7faunse7ICm+eRjhdyDcOIA8rwHaaj9rT70MgO4oaowxljWckuPDqiP/m9V8hkRa8ZpCWMVnMeZCDSrQ4mZgqq34xJHgEWkWaw9guixKMdFZEGWJYo+7O4jHlBWbKAmbtzRZ3rh4cTWAgKHf7C2o2rBM1LVFKWLJnArFyAyI4t2DFif3CtBliLxGDmLMcAHQcrX7TDvHqNW8byWROxBUTUffj977Hzvq/guxLZqVgQB1nqHsP0QF+D/ToPKK3o+ktiCVm72kWx/LD9rXeFcRwbp1Ln1E1+gqqqZgBYRET/7he+mwVYRETHRoK3k62mgc39ec7JwZIlsbYsscI04AbPck657/MyYo49K7AqnrsnM439D7VERDo0krWm4VpQXerxcB9bXCINsCzB97h9S7/H7ke64mEjy1YhncwKwX7vxi96txbW0PpBXByw/05woLztbKHmpD6PdHg8duLD0271FlHKy0g1pGvB46mazaU5IdKxPob7WAdsdzrKr0LXjU5QHSABpfWs5lFL7QOJWHJMwgCwWBO4gze8BBeAHhQDvMUq0v5N8OgAz8aE8FGUAaTBSIlnJduETGwZnQxWX4OCbEdiLDjQciGvWp4KUqtMgbDrLxnTjQFgnXw1FycmMb7ZteybDJAVwV4Gj4fzmf6vrr8Pi0Vks01Y1sRYzwVeVaA3jLtLcRoZYqxPsBcD3idTEl8UZc+Jxtjwu2XjQkTaFskw8m8xICtJD0Pvo4qFtd9X9C+///nh+F//+LMqmvvNzVbYdAWj3b0PdPHgBs7Jd715ZttjhFsJ2NzNPDg0WazaLZvvVCT0ZRu1yXygQ0FwzEO1cMmtqMaYva+oDV5wAkSVVnBO0iw+Gna326jSzRGRzhqSmQ+ji8pWTdm4Wbi01qAGbayWJmiuAHhFT+IbpfHK7cKb80DHJ/Nq8uhokZ020R3Uhb/6a98UJyx2CMMbTLrnZmsFhwaDYAVcQwN6vGZyl4nVhgXv+Ni40TqFwMTybIJJADshFbHLHI9VxOtwM2QF9LQCxyF1a9pX6VO6PnCftTtU1Lm+RAUWJNKu2dbEZbrxejiWv6cYa1wQgC2125sK3ZFkiuHNBQW0vofJPOGpu0Th52J9kyXsAxa9ZKwvCewY8qobi1FEGwtnLGZmMEE8YXVHS92Pbv8LVLJqrBMZht5GBYCdOXlouF8ZgsmeN2AnZXkVEmmvQZ7HkEizXEREV2j43njtgWbYH8ZTI8gxlwVpq7rnwVxv9HXT+y8XFsR6njU/KsBjXIOdbekws5hXfmy2UaTNM9neCAosm+kA849lsxoXeOYjaF1q11m9hD5raCFKo/vXEB/X0iah6hDflUjP66hG7G6Uh9/6jflgpPcyfG9OtAsjomFfaxVcceOVx5uanAPJRba1F5nmLMwexyqq/H1Ww6OHohUfSQUcNQ1d9Tk10OH5YRsWDbSIE/EmqMkZr5mixHknKm4dlZfwPZDhqKKOYm+xhXjKUoFZE58ysoILLCbEWs8NYKBcb6FJbt4KixwocLFQbIWhEbP6AwIs6z51z1TONuU5aLM6k78nyYUcsHbe5pyuFzkV9NSIPZUVy+Uc2aOFIZVxUsVd7dK+Ztp0IaCDBcy01/GkQRWOBwAG2wcHMwXO/m25ykT4Hp998pJeO78W537u9WeqHARYTVPQzV56LlbFMrAmJGgPQAWwLFvNJU42wWljdFQbGvOhw3NeL7IW42tmdsDilfcvDPbozP6vGG18VGvMqwvCZLQneROd5kSXYxqjWx6Y/J69U3aQpiMIGtVHohrW7MNr8r7tM11Ou5HaiOLQad1E0TBHWCF6XOtUnXDabDfRDlE1I4tBFiJFohFopcUs7TCX5DMkGgHWVPJZcS1XN8IHSwDLYgHmgJYFsFDSIpyA1hDRmatyUrRntlMbcs6lr5S0ZsaueJAUAZ65dUeMsm6BJy+vTRPK0kB4CWgNEegXePQISRNaum3Odoz32qlgknOeeekvX78XLNaDsWdf1RtM3EsTLFZqw/5vAlhT8TN5HTkYWJLWQoXJWJAUt6sbVCDA35z09w8gANvaev4M5T+r5pur2wIGNdUxte0swOJ9pE3Xpzln5j4FmNjFqYlm2MUhU8Stm77Wev6Qo7S/fiZ+EwdaCWClvwlgFTPs5usProhIAi0LYKGkshPQSgCrOmOTfmLQLI/jfm4xAdaU8HGxpI+nb4ztx/tDP0c6rAevY5oPcZ1aKukbz70bJDPnf2fViv1vw4af163vP6YGphdksRLA4g5hyeyCA61hbUhTfiHbak74NQnMDKDGGk5990OgVdyOxxg3k0sCWmnurS6XzYepTsVNvy669CxdSStuqCpv0VN7uX0jZtUpqJLxh84DJ1WYiMgK5OYR+bpoxt7hH6o5C4rBItydksEgeAmwmrOodMBd+hq4DxmuOO05qOrEJJy2FPjgdqR2bHHX2gwWl13o/uP3nYGXjo/KLidsgg7dYNiJ8UU/MVqKxcKJzNqJYd+EHevUt86yfE4CrLCJiq1oN3og7iFWWn0etaqbSKs71HtQFhh0McbgHDJYVhtZghNZGfOMliVWrrWcatf6HnDOGSFCXHAaBGfA39AXcm1rMWoBXi9q5tm0rUOgGEh8k+LWL2KdMdYOjjPXOqpeoKGWweBYO39Q99XHMstgOUci5MPN5ZZuLiUz9XOvP1MACwOWxuhU2btKzjXVWU0OvCTd3qvvreY1I+eqYsLLaNAK+Q8SqyBZLKfvKx8dqXwk3x+ZLyuMTSw1G6Jkwfh0jY7objLRuXhxPqqx3Z7ItW3JtBoqfZGp0bCi68OYQTOWWETFFqHGqzmNigA5vBYFi1XcRuWBuHkZafNS3nf2Q3lcXTq5RjiiLs2WrIPAK6Q3Ze0uLgJYRHcAWUk3y/W6qSGS7UsK/MltH5IBdQPG4Pylij5LOgYctUSpIDKMRtqF8oUuVPL5SzyCEpjiqqIpI1bBum1bIg5yrN1Qul5N/uzauajECL6qzPOIqH44fo8hX9VxelcxCP/NRzlhzU16SzxqrGfg9fw+lm+sO+7/GIzmvt8Npb8ectmZwneZCB7m7CJnWJ45DMTV0moCm9op3tvukU28rZNtMMdkcUFw+IqctpD9FY9M7ZAIXr5XmTBG5hOkYutm68HKKKPoM5aNiWW/ETbyPivgoRKDAUGAlaR4ehD/buoR5FhqxSTf/eHT4d9vP7ugmt2HAGtOHj4Y9TLNu0ZobCLIG9k3amq/uaChvI2tdE38L5c5lRv8VljtOuSGZTdugqlFWOSpKxb1BYzPHTZO0Rq3vVh2y0k48Gq3UayBSzz/l2g7EsvMgZbfe9lmzpiPWb34v5/9ynh8eJqf5BIoO/8euw/ZvTQdsPdReCBNR6zvbN9bzk/dOxipirYOxmhTLtDca821bgBYXASD0v+bAyjlcj3R3io+Dkk6FCfKMTnmeL66doqtCpsoAFaipfkOLRaxA1hJLC+vRa70E9dY78yfUQWxACc2CxkjpTJdkt6ESC7u1k58Snh5OBdO0fEW88C+0eQcBE2+B9oZB7Y5cQTJzlj92lIhD/XMiJnmYg5ggfpS/Zs/21AhzHp1Lgygqs5Hkm1tGdMv6R9LZyOcJ6cAL7suGrvV7gd9Cj0/+Xw0ld9zCmBN3Vc9S9ns9a5aFuIEwKoP3crFY1YVTw8CbHGgleTtZxdmvfn5Gu5L5ZxsdcK3gtX74YNbAbAG04pMKpbFc8YUwJo6tiSSAFgR45IRUXlx1IO4iBJcTYV/yPXdiYwdKsK8AE26fSbV3AvawDJZ4EDGBQmwktkPeppb8yRn4qZS1nEGa1GwXqOOz34lCoCV3qlkKsTioMs+/56MejDVXlMAa6jjPUJZ3M/w/VyrKdDIuH4YhuzdwzVn0tA7VlGFO/C1NJrzR5/15ImFNkYsbrxqSAxAikk+UxywIwuKenjS6g8CairahE5NV8Jg5DvoMpLDFBpV0Gk1cMdURs1MGbSwO22kIacjrYIsg1iw68eGShLFkwYLlSyHirgcMGIQPv6zadRpPB/ezbWkFt5Qapf7EtM4FLDwRq0mDZsoBnn0UdscOq1ecgEWf2R9iIgMI1plRA1gmRx1bY2bDIu65300TdgzgUqj06FNqCBj4Yd3sb4ZiLnjh37jWmen0MFXs7xmEWgZk6XpsCBYLrsvCePfoI1jXeOUZ3Oo5HcMJYnvUT9su+ewSbt8v6TyPb0Shv14LkZHx31FLfMcbGtPLWcLiqBYLOci/ej5A3Huu28/pSMzWg+tF0bsFw9u6HR3UImnyyKIc+8/PyP3eARisezeXS3G9/BapcYp1lV51zVOe9hh4mecD32kCJqT5rbUYKh1MixE43X/tvo7gjUISdO9B9xj+EDgu/qmn1vEpkaqEn3jFBgIG11+cxYl8PKg8dkQkZNkRdwFPdeUQdgRu1qnQXPBCVOTYu/UPBp2GlcUt442z8eTm2eeGoY1ouvWdR6UlCJRsZd1fO9vyzkzVpYDg57/Ns9lO7a7cOcMA4tBVppoRN/x6cH9355l5jGvUidRQIkNwAFoLTAstABWEtNFuv9ZbQpw4co+WF87aXDN6+FJ5B5THi1EI4iqAKQt/JgOWTJerakyuIkcAC0zHEQqk9cfwdUc0LrP7tN6PrzbrNqOX9oDrPRX5M+cCJgnVMOYg3IGm2KOLARfUxL4d4i0SO0r2mOIrj79jLF8qZrki8IwiVjhjHj9LeC4VJb0GwSp7K850cE1g3CMlBwX7ri99LVctK0+k/qICOIbpXH+koT2OaAlnllLsOUxLc2UsOof9xUFFpsKQZWoG5T//vPRJowDLS7CjnNJ7kxn/OYimHj064rFLOC3nZkPm0vDMzJdwzdgRz8a9LNnmKEi+vYbxtSCOWquP85pGMX7RwmuEmCyAnbz58WS5How4UwichamMTsRh4+IzXV8I7eReYETe4WEDBFJcPXci5AUja2ZFpLsx9/729NrfcIPPOROOpeCmyagxUO57N/sPqrVtih3m2q8XJyIdBwNdImPvXEuGlGjIKNlSQQ1kT84w0AtKrVTi+EdCojWiu611DFYBwhIpgz/Tlod52bbapYJOmJ5XlN5PsL4YhOoAIN154gcGtorMGUwWgDiypOGygewZSj0ffHEiFeDC3gZ774btRZiVIsYzgpqJ0qk2YkoJ/DEQgkmaquTdCOjUV05FVOmOGonDgR01o5RzbnRYFkg6nPcGA4FWI7F8iUD4TmxVLmYjoRmNgzp99pgC+4pOvCs8Z0D6TbIRHPvdv6ya8dCL2CYySBg+ihDoteLnd87leQW46Nh/3BRB1rc/KSkzU/QOwIqUEQKoM5748lL+sybz8U5VBVenO3p4my05fBVUJHjy0rPvXNAK8m+lnWOrSO6kHNNLKM5bsWzIO3OkDhaeN7ppQr7oz94bdcLTjbu4LWZyG3ZsVgzgmDOZF0NRxhtHK7XGlTTERl97eiUOg0Nr10w5h8nvf2tvm6FKcDNQKyizi4C+SgtZyncQBVXXo9HmPusdz280dLhTekshk54+yeO9k/kfQJgpTrCJih6rfWYI3O6E472byzb0CwGWZaeNbl9pgoMFb1PQlnSYIiLAkVMEtCydjUpknkKFCrVI/LaObuRtAimTiRASbrNMujr7SkSQDINLdPtya2Ys2UJaff3OytNBHb+fhIt2SBQQIuLl+9077QTi5L7smvQ1GJwDzbKaeEvHycLknYee3Y1qYIt9VXaOfEYcAlopXMDo2u5pyfP9TRf8+7Q13uOah4m7VR0Yil4u1qfJvX7Fu63HmXZSzXynYZxZNkEL/nGsyxf/4yjfrdZI2JQd6bFdHbM8hAaQ5iLBc/CfslViv1tFoOaFr3kUZgAlhX0EYMSExH5vszmSSPqajF9n3nj+fjvHmiluSIBLQ6u1LP6+cQCWEkur7QredMzXrfHjgE6PetswfgcNOQhNFkqybYmEwoFtPgtcwGLjWegp/pQDg+xk8aWNR5T/x9YjtRnl61rQ59MfkQz85NlcK4crY3NTepjKZcvL2eYRmZ4iyH0Qn9tihTPwxQkB6LmghWUxm9a1xJgt74R1pk5faQx1aRMI8ackYDe4Y3pgLUqFiKTF79gED53kMOTrlKHp91fK2bY8VF+rbyXTVYsdOAyNWm1TtublIYeFKQ9C8KoPGyCadhsBToV5ZwElSrGmlgtoKXqjSh3YbZ29AhSjNa2HYDVnChGa4FaFZM0ExlAC22kyGC0IulJ3gRBxjmspvkh4RJkFBqnF3srGKz1jeBxxwvdH6wo8CgYeBcHmzdsEEyDamvSm1NtENkRwMGWh4h0+ysWiPREFowdunKnn1anzooyTjfCOxhAQ4kj1W+QrehYhQV1ws1oIW0wWsMmxKySwTIgq4AMVnmr6+iPnjbPwNj8CVAaWOfGC4A11AljBwKj9eD0oOJezQGsJJdXJyp0QwJYSRLQmpVAuuEsRgv745KMEHFCbSju0b+bZhFYDs69R92PiUiPLZzXNlH046lE4tl+HJwOC7JgT+xrg51BIs4wDxAAKz0P1zVYa8JJUPN4YXjVqjkzkApWjgBLsFm9tDupkt8/dQpgmYLLmgGGE8BK4mvNROZkYazkDlSlHVkoR5fP6NmiU48Jk2MVuo7H2qzs48M0ffgAJ/THUTRwAlqOGz6yl0tG7L4Gli3907N/p41JvxNJaD3tdGPRuVmnjuHCmKU9cgPW9HgXu8GYwJYBelwRKSZmwEcxoSX7B+ciORdFtvvNaQeE6tvuBTlQC7Wn3dlo93Dbx7vZnY/nDv196XlpgmyuqvEdeHX5u6X3K+Mw2bhejRkPbAQGGoFWGaX6i09c+Kwh6Ox8J43bMOw6eUBB1zhzEUw7V27TNHigpufjAtf32eZ0zEAfNlEBKqEej3Igpsk2VHI8dD/K5w73Rfabk8diEuT1bh2zt3Ly3vSuQ32jzVbxCT55NvEFBdW3wjMvDs8QhvnImFnALu3m2RhxwY0hGHgk8NDVzbGCxBzRq+yGcVq7WTtO147fj6tMIpg9JPBbWAnAp97Dj3WLZaS2n0mLW0c1292W135kB1g5Cbi2mzH0Tf0oDAt/rAKdPBnDI9y+TIavjn74/S78wmc//x4REf3wB0+6KgEb9P7zM3ryqIvy/iuvvU30GtH/+9tfJiKiLUv4XB+7yqc5IwG0NC+9vDwd8ha+cX413PeDFw/p+rKvF+uP8aZU52RAURpsO2Prurnylnlb8v6cGPwhwCmJfsfVSsM3daMnW9iNjiNxEwdgbzn88HRmsQzjJiC9x1TKxdRH03NKOUYGUMbn1TDOFWnuSMRBSvQ8qJ7dCNB4JPO09qa+Paj4opxmiLrb/cGNa2Uksa4KUJTmsu1oBzfYLu3arrBkd2aoWQfGsL+nuPZqrkAwyb1zU7u0J2EE1MUYNLs9iSPQTHNnReT6dnCBaPdOd+3+jcA2QG60F0+PE/azrneGkvVI9Q1ztoUzcicmqznRwR5Rir2TkXb7f5YsAF/5otA7aIxfMkH5oig1piPzrXj6mOLosoldxeSfhHdMokl7GNxV4o4RjVO971WJ5XhddVIrJgxtKU4e2DtI/jzTtsKqNp6D7zzQ+WrHBuVPRVm+IxkSt8HONYaP556oSYWEXkWZTc2UMbJKjePwd9uWR9hXOGOHpGZAg2XFek/kVNOBPvVllmR3/kplZrRRJBuwQ33M1Fm8LphPE9Q0w3XYjBN2VCqbFRK4ym5mBmAlsd6DNKtdg/pABUue+D54H7IsJxd7sw8kgEVEFA4aBbz//KwDWL38N7/0lwJgERFVm0bMGRbD9fLyVAAsIhoB1lBpdVtfILQbBvpUwZv15jWWIdu3XWvUAZl61BykjTDki1Us69S7oU0mvit2mTKazBPXzBQ39sMwVQwy6uWNE89LzJRlJypEUaxk5icU3vHRzQMsIqLWKWaKnHycFfrEBSMGJXRJFTyc3csFGebqBXiHpmwtwmzBYNlQ7hD9/04gywW98Fg52tRD9l6Aoein9ebieUtouYmJXZSzQN1hUrcL1BlKJWjkMYsG6kUX67LSEeAqmOzwmKhTOXJ5cHGrrkG6fzBix3Mo6HW4APSYsgT1W98Rm39BX8MZpbh1kzHbuCDQWuIFRmSoDhcE8nMBIjzHZX1UGcxaKhDrHBqM33dcLZ9XxlsKYzwssflbAsqNYhD0mnsMdIs/OqUqWeR9aDnhLviOCKit1CB4ze3znXoZDrCm5OnjK/qj994ajs+KI/29v/Gt7H3VRnbkM8O+6/Rcb/I8zitL2tEyal8wZygbmaidMzACvSXuZsE1Zqqw7G3mPWakdJC5QKJjneSxlYcVz5lRyjGsi4/63Rbp47UsyfN39n3Z/ujJPSU4RpdgkdpKNbTgPvR+dI0OwTElLsZFLxS/+J/8obyxJTPulLipiMrA0x+k/Uowoqb7g5Mv1ZIBxyn/4b0cHMVex7MxxcnHWYuCP5e7wdBPFMJeyuldYdvK9iiKIJitGB35JTZXLg40P1H3nA0AtetrudNsr5NOA9i4jGeVK4Ok8A/eDsqHk2VSdSUpogZc1qMNtRMCA3+jJ2ahyuv/ye0X2m3UAe9wE90YgXYNkGZ5rOXi3sQiqsVDqBaIpHp6oo5ENpgyU+HMHVs7f4v5i7jTi4tAkMnOYd82PLRE4OHa2c8yHG05wLJUy/jtrf7gW/3d8Lt25hJcjRn1t66i2sWHjfRsUglySXtZn7x20wEsUbhWkyom5uGRnj4emadffvojOitkiIX/5/e+QjfPpXH7ycO9YL8P+40CWG3Q9cYo8e3LSn43zA5B1MUI5HNGUiGzc7EMitVDe9yOUZXnLPsa3EjGbejS/gwF26wqAqy4ARBifA9ktFxwSjXV/ZVVVPGtIJ1Qeavf//jIYJ1ayfaU105tANE7L1bgmZ+YMLAldrD5jtj3rMwthgasfOlp+/74LocnUa3P2I7ljVfv7yKJ+cDXRPVDBEUTAItfc9TpjcIpDn4NuL/zv/x1opkZ8V6G70S0KOGttRA0D/PwHyPMLmIwrOfDgFmcPRsevyTdjy+DNkhfsBsLMGEtcZ0mItpfyfxj7RLvjrOGPLjdTkYwZhJBDYGDjIhsA221q73fbmgJ8xJw4DudN273rq7jkh3jElGTpcFomMAIjcEXMVrGuSXGrwhMzSzX+XIWifUaS74/LoSWeYLxrsqBZcGjrET23g71JESpOIx3VWoS0n2iPcvPhbfvnuqTC17OQZ3+X//FL6lr3np4qc79/NP3xXF7s9hsVz4fHWgsJggW525TDPPhgrn3rqYIU3VyVjaHJQzWklQ5Zr7Q7G0KvGNwzClBddqSeU6pw1sNsEyBa5Z6p3OARbRQK2ZpJeBxt58xkn4vcUxaEM19URolLHcxk/XPeybLkejUw+QGRrtoL+H3XqSnKS5740pgsvhLIPqXDxzewDwnFrT+nyI/0dHpxLET9CMfH2EbxPv7s1qr42BnVW61DqltvZgIk7qQBwUsjA5+uJY7xhQSIoGzkz7R68v3xyCBxbaliID8WMhFLzrbQ4a7ZhvqwhhJAyxcGNNEie6+/P1qO7I/ApPdD+VIPD6KEMSzu373k7FOzVlUGdhbiVGp3UWx0xtSLLGB51tNZXeehZK9VIupZTdI0G0tAGIwYTKwab8b5sa/E56vXD0fToNe9MDgmAy1d2cYmlEHRZLzQ3qv3H2tEwPN1T77fAuQxjKK9o8F6U1TA9/MMCpud1odo77riY4QHZ2074pECgS0p0HcV1wXascciyhzWSJo6ct97c2X4tSzFzJh9JNHV/Tut0e14n/3v/6viIjoT168OZz79nffoK996Yfivu++/5hu3h8B3sXrV/TGA2mT9faLC/rqa+8Mx//6+z9HRJ2DzlDvfZFnWMtInqVXG+Zp/srgjEFkbGSC4RnuiazA02j3p/qStd5a/Rp+Vwb1EN/ONYaXbasZLKLRQStdf/q2vObms0idy/dP6xnPsxfLSPUFsDy1U5tUJDZiKdc9twkUeZ3TnM7f1TK3KWW/Pv1Bb6D++nhjKPW8H7ZBeeLivFreODq8xmwLb7zoM00yeue3Gd/Z30isMji9sPnJH8b56Tv/q1fNZOHEF0nvPg20F05BbfagnQVYRHZHVujf3I1r0KMCiS5IcOl0XFHVlOFaRwxGG6zmoHeDBRi/N3UpANZSaY+FYL9ubzcCYBERtYZBrFYT5RmDaIYTWLCz2gZpEF8GHSnYAHBLYjKpycFFAbCI7C6Cgju98sagjq1mNNzJs2LtCxbsorA9oo+LYvdg2ZaqVQd+NQDMotRJcBhcHmARqXaznB7U/GA5HSg7Hf0o5bzjojIqRoBlCTKlRNqA3vo6+B6YG5VIf2vLtggBliUHCBj6n/1//7YAWEREX/rCO4TCARYR0cu3H6hrOMAiIvpbn/9rAbCIaBnDegVMeW1srheUY/ZPpZ6W10VY9KcEx7kZJ89i+LGrGffNASyirr4IsOxKoopSJzJGgEWk59Cn/8oyNpSHEQFUGfQYxpRxJB3QiIhuPhcEwCKy530EWDyrTBIOsIiIGti4lC/0xs2aH3Q6KIOJvAOhdedVXdm0xAkVx5JBkfNUvPETahf272gBIUPlYBnJgvoQ381FY3BhfYqo1GlEPcOT7imCUucFWGW3u6MyNrUEAdzDx9d0diqTw2I8riVxtTq7AjiHTe+j9gQi0rFkrESw/H2taO4LAJWrHR1eB89MI2YSj22SDD+PMLmgzYaKCl/pfqVyxxoUfCyMFDzoOXtwIkBlsvlRQCsD4Fyjd+4W+4Ni2auofm6Uo3fgRhR4rI5li4PvaSwyi5xODJsmE1Ar4CePi72Oc2bNOypSdhlVH8CJHduj3UU7PhPedgrRtM9aNT5vDnKD9xJsMJMt1YPPj2Bs8+YN/eD9h+K6EhrktDzSv/OL31FV/Naff0Ycf+fZU3H8r77zedVxyksAUGhbaXxD1+r2VzZOjbO/NeJ5w36L91l/8Kpd0QbTUutZdUQg7PZ+0eYJzViil8DLN45u35LXHJ4sW+WPaIdkEXBsLjYBFpHus7gJii6bBs4KyhuLqDwJUY0etoGOj8dzFsDCHItE+vvUj1qbgeTFWFjG2eB4qdxJXWhlyVaLE6J506YCOmej1RAYXJTImEAXuJlbwUVx0jUDpWHqDQx2aaQMICLF0HgEPMY96FJNpG219pdbdc2jp5K+f/FC7j5j4+0I8bkOs4SwKDTgst5NsV94ibEIL0mhMaUq4rJ9zyvvGtN8AufhJWYgxsSLk6U1wXq4rzmRBvNoCN/dZFRgwY7M3G0j4FgSIBWBk6HGtTZMpuF7TnzMAiwTXCHQj/o7Wu+KIMkEpWj6UOs5pX4Au2bDJkt5rFpj89zYaMFHO32oPYgx0GjbFMJg/fL7F7R580Zc84Wnz1Q5DzbSyP3/92+/pK559FnNoL14Luee4kdgM3pusHWGEwp+I+XKT/b3V2WjecRWjyscHxYzqYG1rmOwzNYUq5Tv/BbYR7FsBhVIW2rDDFV68q/liff+HYNNroIGWDhfGxioeiYbCUObFLeemnMj8GkmWLJlo4Vj0x8c1Y8gCoDxPZSDAwL7Ca3BK1MX9gUJUUkdHel0EfdI+kxkDy5xT6lzFFpbGwRLVsZ2pUo0FowlRsvWuwblcbeAsXFanYgTq7fCOQATVp3MpNJJ0rh8/jtDYuPkpOUjIV5XrJcRYd5USxnUrJU9ICeYV7Pc63AO6NIcjH61xEDV1yTsvs6/6+nsB/n+gcbX1qSBg9sfdG6vRTrRACyw9V64Abl1GohYE5QaC8BaeF22JSbLA2KqDe/hzh29BD5m+AtLnYCeZF6DKp0LTTIkbmkkfXQ68ZFuIT7VjWEc/+bTF+J4+9aNuublUQKhn3/wHj3dXg/HITr6O7+sGS2UF38tmTH3/saODcdk98OCtuCIsihswZK0TktCazjdj5RnWwF93QgRYdbRYpPhXGlkmsCu1hpqZJQasli41pgbDFGbktrRs6+ROifusUL4WN8DNzewBkavWSczd6jaJOl2VODdqE5jAHwlOJ1am0ajjhYuQrmTurA9iYPXwgCwFu5OB1niwh/T86ADLSHdrNx4/ak56tYMPJr+aQQsG2TIU9XfsCgm1HhNbB3tbza0v+kM2tEriIiGYKUItF6+HH1wr2/tdODltlGG9wO7dQ9w1VV65qf+t4jtMie8GinCMOQ4s57PB4KLkh6em7DTYpcAVprw5gLtCnASZJ0tL7UkCLT4ZDL1PD5JYt4007smCetX/uikXdESh590+5Jx5vS/MWdb7j5UQS5ZQNPEP+Rem7Ot5MUBs7WIreyL5nZWywB3358gs4T5DG7cXkUJqixbyl4S0EoA6/h8BEyvPbwy7+Fzy+MHEnT9/IP3Jp/Fgdav/tL36POPng/HCLC4pPcfctL27YnOK0TjmEQVD1+Mh+jjc988GSkz4mRRzLO+iglozYJ0Abzk+J9do/rf0nyT/lqJxpNwoIUsVgJYlvo/zSGuccN/QzUW2Fa+/7e6a4bxNgewZl7aTIvUS/q2qW7C9GPBN0v9YABaOA/RON9idgsBopYsg2nNqcb+sZQxvFcIB9XJnay0P/qu4tyV08eszpaI1DVIxTpgNaKPKgfZEvsi13uF8UUrVpBbMepFbRGjFZxY8ELjKbaeHK9TdOrbJqCVpCgC7TYQnfn0KFisly9PBNgq++jNKmoz0tcIfhpHdDQMA1HwXSMpYKmMItFTzUfdsR0pNgYZLYu9dEG+Wpdmgi2Kkcg3HYvFRTFasLOMPlJ57RTzI9QQTu/AqkvNlrlIAmyGKkoHl75c/ixvxGxRjNax31nzuFKwk3UNaTuV2gALhoqQq0+KveuYOgRX1nfkhxNjEcGVitJvDLOpyPDqHfjzHMkNk9dMXNjocY39rEBv5ND1Gb6Al9fahhQBeHFw9Jl/QUrEnHoourGY5OjJb1o1ZpHBOj7fCoB1vjvQ/lDRkRm/H643AmC9PG7pBy8kUPrO8yfKZrR6vKdf/aXvDceff/RcAqyriuiqIvc+xMvCiPfwybbvem0LC9+iuPU6jI61MKo+LL/PADYE0CdtDweLp2ucmptcLVkVX8t5yIVuHsJ3wXkGj13T/SfAVa0BFqoIy2uvbSZR/VXJdTL1cT6u3vvbYQBYw3VW7lpcBywmmwGs5kGg5kHQKnxLHcg3Q5vYpUPicfpcBmhTpx5W7JgnPTdwvNyv/4gBVI7DBQwjPnax/NXfH6kxPuFMImOL+kfgxe9NL4f2UAxombTiAvF7OUkm2zGlljQGL09zsOhdcaHpj5XnDRF5Vt5m14hgpVXRVXhTyhWxWJDY1RQ2C8TgJKBNCw+vY+0nEhTznjmxDeCDTgGztOUw7uPNOJEyZknEZBSLNeK73eZMuv5XvRcMZ8SinFfHLPVM5RRsQlGCiil3cd6sBan2iYUcC0MzYiiSwv63eKQ1T+C8ySbyBBaql4wtgx34Irss69qpnSS+vzX2g/FvKxRJ+ucEe2ul6Qis7seHgRpm35dyXPL2wPAdVnTtN/6l3R6iT8DmIgU+Vg4tYP9aPTzQT56fD8fvvuj+jdklfvSjR8O/L28h0Gkv333xePj3v/1hZ/D+p2+/MZz7o+99htyFNhDiidqXeHBb3m5EcrxMLsycnGhgczGj1lP2nRwsTaVKW6Bmt67h48y1d4jVaJSfBMtInnd8rmpPgrCPtoJ+D/lI0VyGbwinAAVvJoOtqn5Sdt58IBx0t1sZxHdJfxmfyTaAYFM9xNnEsvmUY5ElCx7P5zOOh+bk7t6FTAWhJ/cOKQvj97RI45NEZNn825nGhUTyY0/E5OELwRK6P5XJBy3mkzIHce1BRaGvSUALg45udmPDYlT4ofh6XDERaLV1QW1dmM9sjjwbbpSG70vYxfQNecdEAJQGGgdlrZu/hws6QyxJq8F3wIi7BhUve8QE0OK2W5ZXGZFsVqvF0Kg5eQPdfJapNMEbb4nn0RjXZzw1NRaEAT3S2XOPwt0dk6lFgY8ppepYOFfGEhjNBc2RBVpTYnhs8b/iGcAYHZk3U2OkLiEiueDXTgCsQmekGZ/FY/fVDuiQfEMmoFU9tPOYctlfjTuAH/3okQBY/+KvOwP3f/njz4t7EsDi8kffG89ZQItofsHc98EiLYAlmKdWM1GWiO+aYcXEfRyUxQmAhXtwDqQMsDcl/D4cU2lN5eO3vPJUXfphs2fdO2V7xYkD5Yjm07OMtYldG32UACtdj2t1A/M9dQArJy2k2RPjwPgO4aRjwRBwW05rKKIvTnVLPG8wWIIFvEOKuTuDLJzgoyMIYmh8wNYR8cUrkLYHQrZx75UXSdgYaiZ8A8uI3nCr5mWH0nivQu9ul8TO0R/LCVATI1F79NQwewtXRAGgiEY7rPE+RyXGlgK6k0hGfm9b3wU9vWuUWovBqr38zsHpHUzj9ffJhWqwwjk4YEAQrFE3aSkD6AzDFUqiZhep2fGFTVP2aM8VDaNtZFSLAyQdD0S3b0TRZ/xh3n6LSKs7ifRa66Kh0ljATKEUR6fiOimj+mgEYD26exoagEQANIH0+DH6uNUeUxs+/izlJQhzUH0RlCGxB+yyfd/rWFhN14+G16iicrpoz4LYxccqaiDyACaY1mlV1k1BEXLtnb9xLY5/+PZj+uHbj8W5L7/+rjj2VaBbME/4F3/9JTrUY1iIf/Wvv0TNuzL3yr/9N18Qx+GyMtX6XNAmyNWODq8FYUtkrGm6T0e9ucVvGJ28JmyiaT+DjgpYbvOwoeah/B6+hT10QVqN2OY38spDru5CunAzg7CRKWaas6gAfiw0iERD8FhGERIhVoHiNlBgwW1jGXXMStyQWmu2Nd+ya+rHbZ9yis23B6c3u0ucmqz5DerTXLTUXGQaP0JZVsfD1zLG6hIHnSR3nir/6u//ur2TnmIi5gyfUyOlaycWUyXpkjRwwMCdS/rACWhxJKxAnPFeg6F/PyEkGy1zp5bQrYWCFzAzCWhVffT31mClEtBqucv2DNBCiciSNQu+E5e7xLcK8H3TI+Y2AXxdVIN4+llpYI6RnPvzxu7HkgS0Un8z1dLpNdJvaXMHXmM5SUBrmEyMRyWglxaaYbfLr11iYJ7+znze9Cxuf+iPTtxjJZ9Nz09OMHfZ2Us7qXlwzMscDHrTJzCunXNiWWJukBazpBLcvdO96Pb9+bAMrpblJ6B1fLpg19sDLDNlVS/h5QiAEtA6651htr1zS32rgyP/zTd/QkREv/zFLqq7X7ALf/bdEaQloJX+xhcdOAuX+lnD2E7fZwlbyz9JsmHu/84ld1extJb0OxodGdL9A8AymqV53H8XOC83VDPzUjLET8x6f+2UWUH3m+yjHLAnEwfLDOCYgnEOOQfzfV1c0xuED+esbpJs49KY3fbPXLB8OGueLOVcakpaVmf6rUrXF8b7hu+7ZIkzABaKq/1iVSER0f0SU5ENSFztKDL07YLr6pw+SG3sgB11iJgv1kbATyKSE3MZlYt4dDpxK5ehY/J+tfe2DYuYmGV1/MFRuwlyVFsdAFL+uCJQZAAopCShDEyg/UQbHZ1uahG5OQZP3kd5rZN1boFVMkGeFYJiiXekBbQ4ILLKCE6uiIH0rGjhmqNkiJAit2x+rKSu2F/TYlhwj0TYZQ2TG3tEeeuo5gPPAvYuqzXOBhG1zvnGmFyx7CVrWipjRvVPRFRdOQGuVEJ4s3BZh8EjLMemTu0m+RBH1g3iVZneZ+AJmuoiGABr47whIuaAp7xVrXY2zqEa+Yd/r5snhLfXNkitaW/0ntosYI6/Xs7A2zhCbL3ayDRRgd3n/+Xv/J+JiOh//F/9T8dyLJMDYLTi841KpYbi907YPSa1sphvve57yGCl3xNgsVT6S3JXutapOHWKGbPyWTYk3gOm2qG/CdOEyoolR+SYdjUBLf5M3BAqdX3Q1xyftrqPY6J5a0reBdkPcbOTnsO/xzboDfkmjOCLiFqMB0ddMmjOzKXx1PSJnH3vZKNCMmBfkEuqnQgcUnSRIzMWZzbWIBwvCh9iyKsg/YVwtDp8tIHV6n+wdpMLUk2gcJo6/Ts9czayKw7IJXZa0Q1ft32QrBr7Z1gAKz0fjVgXJNw8HCo69NGcT3vvwovTzrCjPs7gYrXdsq7BnsPu+wBRbbMR2yNJ1eCCbWfKt5e+z6yqjb3W9j1P1ZWjqmen5pisNCHEHkAk9cPcTrN6yZwTLr1Q8YWZnWbbm8BYRtZTImzBPEmW9C47syXgiwGWAtRkJqOQWLZh8ZzZAaMYQGxOlJdvCm1hBXzFYJV8vl1QtwTmjo+6G5PtkAomSjqKtQhoueD7pFQsg0fu5cz4Tk5DZSQqI139ZEyftZ8I4UJE9Me9DdWf94brKQbf//W/8X/Qjyg75P3obzwf6pf+Gys9XcWBcTyk70Pir7i0AdDVz0ViEV3Cxizo2+mbDqmxeqaD9wcEYP//9v476pYsPwuDn11VJ735vblz9/TkkUajUQIZIcIngvhMWAIj2xgRP0wwUQskMFoyliwkC8PCpCVkYSTsTwJkYfgsjEEgkEAgNNLk0cz0TOfbfdObwzmnwv7+qNpVv1RV597uO53qWeuu+9aptCvt/exfeH4AMK7ii1Qdy44xI0zg6u+B9rEdyGa2Rdgcn8L8L4yl4b/I0I+0IDO5u/YJn1N4B2gfvsLNHx3wzrBTXkfGWFHP0wpVIFRBceNUtXGma4K6ehfdi1eNZLGAwIXTD00O4G1mexprNy1Ytkr9EdIANOd1TMCqri8CVaewOpfsxGuCVW+32rmo7IIkWj538LnTAqRCviEQrfo4K31Mxm/O27FRrxRtg6WaIVimne5Dr0SEoWt1WQRLdpBeWipb4gUTkfwgg1KV+yLW1p8+ghU6aCWMaEgsKPSRbGmArM5BXVw+8YxgjQzRRDvtXc+4+T5Wbyd+t14f306w2LIlkEqfh4dIDNBWymiphRwD0QrI1nyviGt87vhxzwPZF89UuAal9InLHc/GBlT8CiVaAJBU7hsZh/kZkhkIaLHjv/ulf6cmWK3tE8vh2fWpcEuC4nKDHEtLTEtXYsVgSdAuOTaEe2UN0jbiPV4hgJtaTcvvXXpPhPHAsrygIVidkN9ch1scQPl9eadKGTGdxjYSK/sb6caW39ukQLTQUhuUYLW5fiNDaV+2hRIsV33LjCCfR5xgtbxA6l6oDcAnZZVMDutL7pJfrFxWR/7w+P/8l+q/w80Lsw7PMgcIm6936CdYYcCuP8bg25YXaLFPYeakNzZoDVHyFqxv4YWrU1vDqclHGixsPnR+Y8HurdI+NPAvaJOE6wmxBxUJo4KB40rBfX1S2pgPT6vYiCp2S7oWywOKReo+lVYkKitQWeN8i2uCPZtwf+/CSmK1TYrH1botufG8qmbV8Ux1lgxpFumAQ2p9Xmk0BkIRi2cNNNaH2iVQrQruQnqOsG3QrSmq49Ng+vq6gmGH3NKQaRbIVm0Bq2ek5HnFxrcDTrhC2+r7QZsh3CxqW0oWxKsRyFW4B+wboK6TEMMWRBxlnJnhfg/bBEtlPVhYArbCMkKz9sKzbQiTce/kOVP+PtFjS9T7hDgwcr8SJusS2lNZvnbKG11b+KgEjRysqnbOLpSuv/lLDWmq+5hqm9FG42tKj6qLr77bQK42NxoX4sFBdazqViTjcptQsutHvrqxZP32n/n/AAC2qv1p9vPey9vlb13lbMQtDNce4vVYhrewYIXnX1u/qNuN9NPy2dXvXgK1nxovqncjnCtki5v7UN4vYsSChZt+07VAZdjPiX6MHi84QQw3uhPhNGEdzWwP32P9/gZRXmucra9Bn0uh4NsC5FsO+0Xif3qjKoIjSVbdtxr3lLoVAxG35BcCgoU6HDO4UuUElMZuWZUoADDNwbr/sci2HOsK1xaP1ToKvqruwihzaqbxigor0mMVK1io5KkiqCv0LTMJJXBKT13t0+nCjPzKDJeKkrqIyzEEzjsmJXJOF+OaYAHQQqMrQgmQhiBx+lIaldNN+Ja/7wZeEKqWd4XJFwjLUFdge06qhsQLnr0T3i1Vr4xci6VzBIAJA8rss3AMpr0T4lGJITI+51mEbdIRXQTLXK6JKzmEmPW1zdzpO59u8Ay5+hswJve0fqmT5ZZaXqeIKnnLaw/vAf0GJ149j3ghBo4QMtBCsIDVAt/VPkafEVyH9N2MF64mWAB02TELuasJFgBMHygzBb2wYFGCBQCjrQULU8ja1OFJE7JlzGqi/vZ/9wfK/yuCBQBHJzMlLwP0ECwD8tpVcgTKd5RaY2Qd3AAz45YK97ZkfbPxwvEMMStuCGixjNGJnK1YwffzQoQ08B8jA7YPUjqo3I8s5MJrZBwyCHb3QfW/se+WVwrvCSFWchLRZrmX9z9fK7QKgAEpkLySmj9F2ynk7wZ3uFdvzysmWavEOCg2ae0jn8Xdyg4ErHBFkiytkoUhO1q3jNpt2nQ7qVC+wnWtYly0iJYsyWMFsKrzrxAjpmCk2q8k7rbCdalgUWOAswKw5X7SzWNBWTCMWyEHdqvTkK49C11aSXV71ECy2ketSMUKu6lrX+HZWGSjbWCkcOJcsVE8WRVfvVfiLmB92yoJYoVrsK591fqIDCs8m9EVUQB6xV6aWrEA4N2PvNy7z2/7//03vdvEa6to12io+7rCtWsNKaMPM4i7+m2VvkZ+7yuMS/lUuxtX+d5WCWGRfYsZVbFq8ec+SDf0KuOtgzYkyBgoA5mQRaE1XlthNMcq4K12E/HRZmKUvIZV+tlXYiy6V3chULoMGctPHS9qGes9SwFCOs03ju7B3rDaZSRFxSKxj3UfqJVmHhtlWZyabcuOOT4TUg8ToZsR4iDIsX3htOUIIn3akmgYiSLPo5yRpTyPlJswS2NGsIILkpEscX98FrHnEPZvdRcGyI7I6RmQjz1/pmF1wZfVzMl6y5imiVOdqaUpRQe28GHyCgXa0gOIAVE0LXSA431iZo4MQUVrJmwE7BfEyiavqXZ/BCu2mb0EqHhA8T5FmR7kXcEtR6ZKeyQIXuRZ/FkaXBY9kxOZ5enHXpE7FS4SQ/cPAuO9yAxCl+5CncGp3xWKaGHMjCPP7ldEpEECknPHiHa6U3DSWEtdiOBxMQDMLpyzzL/lwUTFro7WlshuNVZtv1E26PKVIwBAVu1/bfO43uYXn7uG6XpjgllWSTUFKYETXVyoOC0mE1Nt76e0Pw2JKeJ9Mr59+txd6pSlS74HyakzLAli2YHFe9WTL9rPiUzSQPxqbTzrNYr1N+l8k7gS2qsm3i2TSjrQy1I7PvaM9MvQG6C8F1J3zceaUKh+WLqmZYxfiHOi40AacStqOKS0GCuNRNH3LCI2RsbHEcaHfJv51YLHV1vhEQ7sGY0OYqS7zcMJcVh94qAu55nI0TwyJkC86kcx8YqAdUg33B93oZwJqNmeNeOQMxPr3siOd2wI993DDNEbrrB7CZJXVoBFrC1WfQQLjYRDF6RIqewIAW3VcpFhxZKLMvjeoynq3IVVArCtzqbgy6u4keWz6RPyBHRnnc90oLIy26+gpRWfO0awgO4MxC5QgmUhygTPSC1yae0oXDSGa6+vdhhgWZ758ujUrWT9XelbV+cWP1jaRT0EC1jNOi3fL9OiJescJvoeSkvm6EBsUBihBpZostSwM74RSrAAwJ0kNcECgCQuGMECgHc/yi1a40nKCBZg9ysSbpf7yvy06K2XZyUurORGXWFkkt/66NTpfi6Xg7/j4sPWpMgYt3JRfagtgJ21TwriGu1RYqITrzIqJcEC+gmWCem1GBeKGUo3tTUZsMro6PbxfSTBArSVyRX6+cmxJN3hD8dPipXU12V/YCZEyQn7KhpvK+AVkayn/5hmdW315mrI9yVC740tD3x3basha/H1nMuPvborsshpYbiMlMinAUurShItaaUqCoclKYuT55HKKlTHdV5LRVjZVxbBlC9sj0ndzNbocRO6wq1GzgwoE7+yhOgU5tZSKBWiTMd1rL9oDIIz9ZNKR06EKdxyF8m4DumSLEb8GqyJwEqaVU538rI9xdjruK4eJf3lVqGelYopczB7FxkTJZ+nKrC8dKpsjxmX1zOYKVhxRzl64yqndxwmgmz3uXBc7hAf841UqvmowPJshYe6zdm1H3ncen63Xt4/XMdnRSbhL36cl8qhwfUB6Zwz8gcvHPLzGLdFXQNa3lVBSGS23+xlkZF2YkwqpAV0hZHLjNXyfPIRZQ5RS3B0vUtiW7b4PvI7MybZRtxlLsh3lBrfhIxzzh3i05gtmx6jzgajX8EdQLyub6J0H7uxmOQb7Tl/iG8zvyoIuvW53uOYr8Yk6zhKE0xbCiXuRoCUt+cVuAsB4G1/ucwytEqPdGYChm3kDE+RspZB/G4fwKjghMvDJnzWuQisGYOfiZfMmBXKWCgXeRRkRhDFHlHcHXQ+HudqtivV3QurXuJSvDHGB+fl7CSNdEahMWGQL7SU07DQ5ya0/OjSZWs+B8sVTCDL5wTQzrhIgPXr/DinD/cTSZmmnm4bnawgV8VYFBgGsNzRM1RlcZFjsfP9ExUrPu8e8ifGR1FJsuqD6MFDzfIL3ulHqU2yVTyeTH83Y/HkD3zRDPj1jrtICj2oqwoWeUmwAha7xj032pMLq6WVPBNcfjWky35SKMszDkfMWnD5kX3sH3LylN/hJ58+cKoJ1pY2iT724B22/NyNC7y9B4YJt2fyEy2der7F2DOCdfZAoSRDLGuCshwaCSoytkvGUSWGVpNKiijAMkN9rN9t78AGaCcD0WGTK1XiyahDqNx/0kq/nutvRl5D7LX73bA2SoIVz/o7h0Iex6oAIDB7Mcb8avOy+Fh/R71CzS1jv7oXcjxYwTKljuGa8eHzf6KTZN0fdyFrzCoB3asE160agEcXrcwsOdjLWkPWTNuaxcrnvYJpUgWXW7dfxs9EBjET+y0FWSpa4r50e8RsaZWi0Ktc570o4BpE3DQbC6jObaVsme5jmPvkwNnV7o91eovvk5wBsSBQk71Xx9TcZ4kCYH/F8vTie7Bm5ipGyeiUpKtuFaImO81VgsiLiWcDHKCfpwqgtboBy42yorYdhbSKWMG7yko4Miyvfe7aZaT7IatbEoPglfUTvZHAQpTciS/q1FgZ0nB9b1uFI2griVjMndYXnBn9iTiM1KGzIN8diyxJguVy/X1qHUfjXIIgm5mH9zBRkceJjcxN6bo2zy01w6x+XX7TVmZ6jyXPQi6yWb2cyLdAWrTUGGJ9mjJG2kickbzBr5LQtULoyyqJfX14xZYsoLRmUWZuzb4B/hK43OnAPCvqvyd1QxIsPzJGi770jwLqQZbq5PRE1f9M1yRScV7RRHRIOfczu8gr8qQIltPbyMcUx7ysji+csmLJGCufR6wTrWciNGDYIk6LiL+QhfFxKCkB640Vi2LW58S9Cudip1mK+5k7FZ+UTzwjCHU5Diq9YM0cRf+zdsPj5FH+2+wG329+qSRZ9bnHUGKnVt0/Gs81OnJqEDi/UvB74fUgrjIvV3TBmnFYZLty9tb9zRSJF7IQRuHXqN+aLdsSLZ2QhNAEzEea5GRrhmWpz7IOTsLK4r56JkvFWceHTsW6yUzWKOVWNx8BhUhPl9mUxU7aBCLXPzqdBSYvIYvwvnc/Xy9++vpVZcECALfTvGD+YKwIljzsI5f3cX1vuzlNGqM44SRN9QHG/ZMp/clJzMaK2Y3ympfbdPyADksoHC8o7TTBsuQ56DedjzXZUuW3Jl67o+V7NPKsfd4qoRN5rhkVKpGQzXziFcGSZDQ+j9T55T1V1ithXQOAaMZnCcV5wi1a40JPAIzJOSVXYT0lWG4R6XgxYeCw+h81mRx5bV074h1Bvl7w8XgZKXIVnQoyOPJqLOsLZ3FFrxULuN+WLNkAy8qgXsKOQqg17kHGwbRq9SFCf4qmh1K9lbNJe78VmLpAvMJ15zKAckWLFnVJRolXM1dTYkL+9mrZP3sGRQurWLSksrArtKtuFWPGYneFBkmes0I1UBnHZZGw2U3D8tqHFSym5m4rWLAkYllD8h5KeVhQz9e4n2YK+D28S6t8m5IwZ0ZcnkS6yQ9kBf0qWCVDJMEyQAkWoF2EAPBNv/yn2LIK0bCak/PB6crFo5YtCVa4TDmRWex4RrAA2FalFSxYfbDcihJWkLmEUrA3xhwpygnPX7codaYFS6KPYJlYxYqzirdFQMYPu9grC5YXMVySYK2Me/B6rWK9kuOFJUQs7/kKBKsTr5q7UJnl78VboqwYrjcQ1Y945qGfFPo4ScFfPGOmZGKVuyMve5VxWWbWGtkaMrh9OuXmmtEoR5I0PVYcF0zAFCg/AkqaYmkqrkbXiAQuurhgy8p/H65hRVFHvtPd76Lub8ELRsPrGI147lgwuVU3DeDkQnb+YcZLB/T43GG51Wwzv2gfV8bhWDEZMhZrfoFfw+KCHHh0TIvq3OX9bRN3pRblVZ6J+F6CBUsLD5MFZYp3Zpv6gu6td0a6g9Ktonc/vd6xZjXtERYVgrr+HbF0zK8UjACogr4Vpi81L21yGK2k+SOJlzsTwfPnMT75MW5qlQRKEqxirlmrzES+esEmVNcea2K1XCos/UEGhXkreCzl6NB2KTE18BwmYWbfpwdyQbpWFZllhxXv4vKCxe7kTi3nEffCEslVrieySTHy5jXQGD6fGBYzac3uqqMbjrmCa0/FAK4ynot9LIJluThV5t9M1LjzYPcqXy9KKxa5F/FhrJJLxrf5u75KPWRdabx/lz68Ku7CgCf+ahUEL2NspEl23bAAyU7Qclv1WZssQiZ/s2aMq5CpFWaVsXAVFtZL1pMqPZ5qRjAS2lkq1Ru6o1yKQtJWzBdVfwZsV2FxJjplqTVk7NMX/G5lJHrnewPirXNJAjU+FOZ3Iy1f1dAyHol0KygBSyvG8x5m8tKKZR1CiR9a2laWu5sdWO9jkb9VhIPVXEh2kpZ0xEqWOHEvVLq73kVpFclByIpTkbX2DDkMSSCl8vZy1whgF5/l9Jb+Ti35ifSieIll0P0KlkXLOvW7vvLfsuX/9Wf/E7ZsiYxevXjIm2I8uBtPXepsi2UdUHU9xSZtqu1sH6Of7pskWPIngHZBy4QTmdEK6HdplQxHSaysPkxbb7vHTwAoZIzbKtarVfqnVWJxJWmT7sBT3QGYLkJ5P61qI0qtQHyXsqA0dP++3NXHVdqXoj8P79XTf3RlK9b9dRf2QTHIwumbJ1++qtI8gzJx3oNpxDquhHShTXPtjpMDQlzobAuxjXTNWZAlLaKoYKTKodTCoUgFoSoKx6xcAJDci7K72UDZ0axQ9T0Ce9Osot4Kxure83iHpRAHlZ1plDn1m2yKykwySIOUhcinnhG6ItF6N7JTzjZ8b7+n4pyM45hY4duwik7Te1wkXg8AYrZdjLyOfZLXbX23sn2GcKgKJJcClmJ9tIgMbS7jDstBQkoMpN0EqzwX/y05cywzbnozUu+wRSQkIY3O703SW5W9Ef3pw+M9/Le/7J/wc4ls5vw8xvUXmkzCP/TEv8YfedtPsm1ufJ4TLOlJAIB8R1jUxTNJTp3KIjRFcxVBEcvy/hoFviXSTc/duYZXYyx0zkxrywqPSYYFWJDfxuROhOkNoY1oWD1ZWapZpsmRpWUluwRpBJCfYO7UxDuSLros0vHDkiypkArjfko3qEM/KRTXPN6PMN7n15RuyW1ijPeFi/M+s6BX/fClojvqGxRupmmq6yNaFGFVrQor/rdwD0KjNQxC1Ee0TEgytsrsZ4XjSqKVpXFdOLrexiBagWxl8xGKZVybjk0r1jK2SWlH+xR56rjesG39f1141NoYfJvws0GAAtGS9eW6SnSEZgeCJcmahT79LUCTpJX0rSTIPQ2EgHYMStttlddylaweec5qMO1yzQQiFL77ehCxvsVwXXUh2tAWY9Ybzi2KwppB/KEAcbgnXRbwqg3hGmuC1XE/wntVF63uyooTxxkTN3Fb/B6N57knQcQVsn5HmzzwPV+B3FkESyLEqQaiVT8Lo0mBaKnC5dZ8MHT34nu1EIiWLCgtY+UoxnvlyQPB6or5qgmWI/8LUhAIVmhLqJ1aVwwwhEond3hnmRxHSI7vYYheQSy0j2BZsAiWwl30K/UmgWDVhVe7GlEdsBqf8912E2ggWKGvk+QKIO9cGCqreo2riBmvilfVXQgAj//17+U3yRkWCHkTR4VtyZItoJ1l5HW8kOHLZ3o4iYeX7sJRAdB0VItcSfdnXDCNKzPo3IHfNe+UJUvGZq1tLJjVKo4LJU4qydUyTVhM12SaKpV45zhxy9IY2YL38NKNWcwTPjCmke7ZvOPXGPn+dGAPsQ90JtEKH6p0Lboc7P2wZsIqID7ll5QZIrPO85nkctfYRnzn8dKhoOUiEp3NWIy5BchletC1LGFsBh15fX9XyMWw7i+7V84ITZCX7cHa750RH1JAf5NhX3Iudg1t1mCyjRM6W3XbaZbsiBd5l1pi9eBPs5MyZydNkN/ymdeuLimcuXTsnZhfy7H2Iv8mZcxdkehn2SdTEl1coBCB7pL4PPLELXzToz9TL3/vx79OJc2MRjnO9puI/t/7lT+NJyZcp+TP/4vfyk9eGCRLWMtHt0bsXiVzp74V6T6NUqet5fIdsiI+pAVLLqZcu272skO60X3cbNpvwfKR/nak5VN+O9mMZ+ZKyxlQTsbYZCbSoQ/+glDgP5ehHdDjmSRGMo4q8Vp4NndMNys3Kpx4GZ+5iFm/Hi10KaVo7pBv01ph0OO+NWGgccYHSU2QA+bXtCVtJMiq1dez/ssDz/zhb9bnbscXzl1oNcxJckTfuvASxOI3GfhmIeEvoap5BKgv1NHYKvkCtrjzqJWnL6aKnbs+QPkD8107HpS+tqE1awAeAD9OckTkvizT8qOKZedGAtzbAvGTSdPbmQQL0BYAln8sR5pgjRDPhO1vt4VtF3te2qFlHy790LYNPzcNlg31BLtihVYxVBaJZ+5FmXVXb0fOreKIMv4/UHaotENvNWnTR+ex0hfNBu+Wa1R82jqunDv1uGreaJAk3SoOLjMH29xVZ0Qf6PSxDNlms1yTaZqbMzaC+Q1EQoqBJkM88kRJlP7uc7+UbUOzl0eWbhKApxeX67+/46Nfj8kVolPS1gWSAXx0i5tsg2WITiTymVfloyzQbYqRjlEE+DeVrXk2iFq1QwFgRKTFfMLDHrLqm5aWRFYDVX4T1aY5IY7FhPcP1uAuoazd1XnoBKDYzODJeKIIVgAdc3oIVgAbM1qsorTKiF9EbDu3sK2iNM5NxbyFptD7nUb9cdjgCQvzKwXfp7rd6WazjSn3InCXBKsT98cbKa0V0JYHMy6jL+Yq8trtYAnjtZCcehMZxD7J6yLPbZD+6SgpdOkaCaMtKkhQaoHEhaojJjMNI+cZ2QK6iRYAeO9UcDwlWivj1ci+sPZRGlArpOP2lEawILOSVoE1uKpt5CxthQDXlUzpMn7Mek3lrbpbooWeuAQntulod020autS/3HNDlai2qYmEeE/4zUJFpb6Ewl/WBbR6jmFwTRYC7pECMPhAsFqqyQA6Fn16WP931yxwrsvydUq+N6Pfx1btgjW7/3Kn2bL3/HRr7/r80iCZUF+U20Ei2IVV7sSyzUI1uxlfq57cQ31xfEUE68ERSXBGh9EyorVRrDq9ZsZik3+DpkWLHlJK1iwXI8VKV/ETCfLL6KSYNHjCIIVLZyKX2wlWAFppN2ZAvFBgviAX/f8ijiQtCCuebvuqdzn7l+HTqyg6nPvCIOgo75WWdIiKbhvN/ZcusG64NQB9AUOrjnpHqCEQBK4xPe3JbRBiH5SU2k85gHvwSXISuaMCp1pSM49maXI84iRK0m04rhA7h1i0t7t9XMcnjZm/s2Ncyyz5pFaViwzMzGPmDXLjYpmllQ4PeOJgNI0RJ4rdY8yS4l4BnIfeVxyX/y4KNOAhTkeIOfywmQf+WpdNXOmxsO8aZIfN9pZZiHlpDIMVZ20KgZdnT9KXW3W93HZkSaVe7FtbI+WRFhR8i7jmRUjQa5WqEyg3LDyvoXfqJWg+qa6god9xNsSxBMjGngt2yJd59bhW4Ka2f3ou0arvbOcB4UbM+P4LOqsBmCR7Ks/V2D/Hc2AEqwr4UzKZQFNkK33r896tYp0iqXb9Dee+uX134uqRiKzeIuYrP/l338NAGC6OwcAzA8n9UQ0bFu7XKvBuVTi5v2L1hmr3rFgvc3tOTFzZMgIj4rUyudCB9Dxgf7+R4cOyTndXhMsH3nk5FtXlQgMoudHnlm8rLqL6ruWwtGG8SfbKJCQLDgVC5lFOi4q9nyy4sAJlmWe9/wDdUkBB6AgWmkqqUuFHDg1SRodRczFGQgly+TMxcNWfYXXY7sI+SkmHvMH8qZNsdG3yuZW37urCGCIGb+nKiY9uC+WLGlqU8HQ0rKUGLW5+syEi6j8x44rthHWMu+h/c2rtKWnIHOUeFWqRlq5olGhswvFuS0C1IZJJeuwvV72GmvTcmY7TtpnyiG+K5BEGZcFoC50XWerhOuwLH0yqLnrkUl34grvcq2zEm5Lxz7SyrKKq0USJ7vGGF+WxZwtyBmrKRFAiIyPdScriU5Ybw6ybU2yXqfaAuTYNp2Dt/x8O2Kk6+OENq3w7OrjBz0hqynBmpZ4sWxsWj3HYq18Z2t5A4PBhlk2DVAGui0VVz5UHm/3s+XxlZimgfXnypu28fmyweM7RhBusMAF61pHh58flS+vjMmSOF2OcLpsXuKFUYT6/DoPTgoEqxOiaVapE2kNXMVVFibm4VF1PQeZdbeKDEQQk83Wqn2MCUWQb/EiEcO0pFX9THgvu8rshGD48FzDe2N9T0F2IKsqBQSCFR922EVCn5e09LFmTK0e/9jyqNCZixbBIhgdRBgJC5202OUbBfINclxr0q3Svp06t7QWmiKrLQSrPoZIyns1XYUAXv3Ad4rH/8b3cpdO4jl5ij2v4B0EAql/t826FGZewbROj+ug2THdF5V1iYiyReOcndefJ5pYeMfjl5zOuFBBm4XjFiVpYQMwnvBROEly5dqTGYd5HmFz1rgMzpcjJCQl+2zOO9+QaUj1s+K4wPyEbGeYD3whZhpSfiN8lNRSJ2dTsdfPR2ogTXN4URhXZVZZ/IJu43XHLgeqKNPHlR2jVQiWpmP3mpxRdrqUkOXT6jjn/DhsYPC8ww1EkXXuqlo81xfzidf3zaE3uUCRUlk02bKwzQp+3EmhBDNlaSAT9FNt0UpjBaYXjpOrMKZk/D5QPb7oLOafXUStL9X+on3rLzqcPtT8mJw6XPhF/rJc/1pBMByQixI6gWAFnD6eY0RSzbMNnWkmn6OPvSLNzGK1XfUhh83LsvHIEUakT9h/ZpcXhD6y/W80nd5VE1lW3SITUhm540XWxx6jI2FtkEkdE88EeZe7hRqYtRCxJkXSmuUjLvQb5UAuNZAK8Z0lYONUMRZxX874DnuUw8Ozof1RvubZMwtZqaw8VQ7MrzT3enQcsVCEfFboyZM1oZREyCJY8hpE6R1Vlk2KmHpoTbelq4PMgwYg1YubP5DbE2AaY7uIWLiIq8b/8IxGB2U7sk1B0pj1k09YynOI5tdej+oQhcMzf+ieCVbrjOi+KkQ884e+WXeacpAw1GdVNt9KxR5X8LvIXca8w1QlZRYxzzxEY+kJoKUGfAEWuxUsXorHEgtbnOTI86i2YgUyRElVUThm5WqzeGV5h4mhglSFn7YE3DO0Bbl3QdWxM2Yc1f12la6KE/oqdGC1CkmbTWXB7lxrqU6florn1NPVcgvblLy7sEqJjnrwCUShKzTQIFgAVGwac4G0fAb0XsrOZpVgUyWGWA3Mfo1cgExGacMqVs1qUA+DWZ0kYHk/pFVZEj8D8YJrLK2/6Nj/AXvvbo51/WtbjkVVzo8iVtvw9HH7AdPBoFVnTBrCO6yPG48cAQDSqk/Yf2a3dds2OOkpAHRsT4u1jekTeW7NDdaHVMikpDti0DTAEkhGglhH4dzlNsFVGVfntjKOVUavDAuwsEJpFolcTMws2Q/57cuMuBosDMDbLvOWCgeW9ao+bBXbZeljmQSLNmPpehNf5g/0pz7Ld86tIkch52WmKHn3Nq+QYHXivpKsgFWIlnyIvURrlpf/Oo6rXihj8IjGuSgr09JxsSLKEXuwsqZTuY14SVcYoyV5sqxXFMfnExyfc4vVKkQL4DFf042FsPxVg3eX2q6811aWaOL58ir1FTuIFgClL2MK24XYLrpsnYvuJuQRLDdCPl0hcFK0OVv3tRULaGbeXcdRMR0t2VFd56316uqDtOxDn4n8fKQeUAVGsNp6EPq7mGWacEY/cQ9gFq/TmBGs+nmTa87XC5a11RaPRq2Se++OGcHK10NUPt+HWnNkEem0UoynWmsud/oZroJt/oIEgmUiWK9arFhAC7kCGMHyiWcEK0wWKAlKtwr23NveY6qen+4UpgWLkqNS3oBvo4RpVykrSwhWWYDa2L8vOcsAtVb5iBOsNmLcR7DyWaGKR9+TGHcPLL3EToLV0qfTShbzy0UvwXKLqJdgjQ7i2orVbCSappKhsBLBup+47yQrsEMn3Uxy9gzAxQUPwI49Gyxd7CvNJ7KTvImjorvEgAhcBzRzd7GHo6bTRQyVdSCWozhXtQFlpqD3grg4r4hTUUSs3I1zXhzDqWzD/eM1tpzmsSrFk5CyOuNxpoRL/SKGp5kjuVvNusGCKo3tegg2Ys9SkS34caEsY4pY9ZAxON4x23E/4uPLDcIj4j5MgieuWQasZuvdEiXFmLc9XyvgRzylX7mXYv09WS4oNoiPfCMAGiA7pIlnMQw+9mzGGs0jRFJ7Tpru1zL4DepPctrtLGsaGmKN0mKgEl0NdxId1EaHZTbXeK+56MmtmD3jbM0r19bsZYfRcbO88YLHpQ9REymQb/I+Z+cT/J5c/JjH5vNkYnM9VjFFMt5Pu7UdG8Drv4mL0G9kON5v+oOT57e0FUsQLIuUqQFP1k2UZDTS1QFiokoeZQ5R5uqkEKDUk6L3enInxkTEqiVnjrnqlfq5893WXwDzS55pZFmQkx7vtNWLkkSXuvpfDfFOO2iDXHLimBWrGPP2Ly4WypUv447cesbHp5GYzBbQ1i1VYUH0QUa2vy+cnmjTQ6ZR+U+8C6xUWOz7ianst0RYkewL0u0c6XbOyJJ3XILDeafKt/lxIaR/XE2w7pcVC/gCWbLYBVgxFwbZ4tuswDTllfS4GE2TaHDzhcDTWfUy08A/+b5IztCiO8N2EffAcv/JuoJtsg5ZVnZK88UI88XINBhMx2XvEIjWYl52spJoAWBEq/yh5SIopEnXIlqCXKoPuiJaMi7LVgqv9pEEZ4XMq7Y08Prjq9rGRCqDynT1CKTbscviEGbYdQbiK6lCEI65SoV6sW3neWPxf7iejuuSHWt0bKVolgSrXtxoiUwObvXwXI3rkwNpeI6WlTIQLS+U6iUmt4iVK7eti1KTaeOF9nsSAnk3ny6X158v/7/4sfZ9JlW8SiBYlABS0IHXyh4EtBXi5Pmt1vMGBILVaf0Kn0Z1X+tnXwvFanIVCFab+00KdkpyBWiXWiBY8VwfT1rJFpVo8PySnIw0FlqX2Wn9K9XZs6v0FgAAjFFJREFUlJCxScYmQeqjjrWs3k8rrCBb80i3C6TbVdZbSFpaF9+QfLetYc8iWD3oIlcAePFn+ejC+YyJYG8h976SXAZkYp1JrkKMV52g0GxzPwkW8AUiWYC4edYDvEuipSxagE20lB4IX24jWp1YgWhRsmVpX1lEq00YkB6HQlq0JEajrNOiBdjleBSs08hnaBGtvnvZQrRaIV1gBuSA6mOv+ph7KW3TN1suxQzpSYzae7JDdF4NDl1SAsAKnY6x2rJo6eBZsSw7u7HuIC2iJaUAFHosnXKA84m2VFiuImXB6qm52EZmAo4f870E69KHInUfA8EKCEQr4NpPOUyvC2uNkbHKJQGM9bLgstiGWrPaIImVSbT6xrgVJg19xbZl6Zgoc5pgzeUyet1lFsHqgo8M66hMnJk7TXJ7CEly4pSWmvzOFxcLLC52k59egrVSjVDD5Ugz8HusV4AgWG2wLO0S1Npt1ofky8GCxbZZgWBJ3A+Zhi7c1+xCicd+4LubwTg8bJl1BiCaZmw5ZBdS6X4pnOYL4d4KH3+wjISbHbIOIv5i0d/UMvVJS39uUjD5hlB0NSfEJU4KpOflyMCC7cMMsXqZgsDouBIJpY9GkTTvGGE6m5dTxrVpU2ohJwKkdNu8+m1+Xu6TVOTufK/Kb6b3tvpztF4eNz0dC7dp9UzoB5G79qxDcsxGjLK639W9YeJ6dB/aruDOoBZv4uIMg5ST64E6aDqos9ffJU02qJpQ11ULy0Fri1xWMfbqnkhXJd23/rng7aHnCZanum5guHbasaauea+B8l7TQqvBjRfe2XD9wbp0QtxM4buorUrVcrg59PXzYKOR88JSFu5NuHeVeKIL1i7aEcqsOPl9Sf0h6p1J7CK89T0LWjjVoDg6NDIJqzaGxIZA4ILOElAqg9MSLBsveozOmna+9LXl3xc+XFlvgmZW9bzHx822L1fi69Ob5bbBilFP/gm5mF/LWeZiHfslET6F8FzDcyaEt5YYEIQnEKvj2+v1b+48VuWGOrNExXdMY9zCcUKMUbAa1d9g2JY913KbRLgTw4SEfXu0KDsh3+EdCN/86DgMJuV/ITaSEXZ6XaQ98tso99NZvDHJIZIB9fU3HppBk23CJzbh/UhtiaXPYi2rRaTTs8pMSDu5+psPDeXtMCtyFLBdetKdT62pKpyk+j30H8HKH75nlpCkT8XAxnGI5AZvv4vhNQrnD+elY4YQHvbTHM/+nj/T05iV0crcvmCWLADlBVkaVKJjrcu6VDC1qwRU/UDJxkXciMXYreU+Vi/F4IqewHNalLk+hmDWS0O/SkIGxVNyZSErImTCBTmdLWuCBQCzC+dyNwANwZJ/lw3p+WJGhS5X5MBfSTmwhngDg6jUkFXbBdpmRqx0jVJgL0/CxCEj3mH2zYbLtup70mUJq4mVCsQVA10frLJQ9N7KjnSjHLVYbEPk2exQadwZMN0rNFHsOGkIFtDcHxqwvZ2ulrXaA3bPltzqULteRCdOM0et4GxV485AIFhASa5o4PVys2zDy7y6DXMTWffQ0p5SoCGRZwkbCIPsQpc723Ip3o07utwBrL8NApTyONQt5xNdS7RIvKrXqU7VcUsa4WB+jJpgAYAzxGU9egd+VSv1Lgt3+wSqD+tI9Gu2EfeQVukYrbX0+X2vjREMriDHvR7rjyucukcqRGGF+6w8Wn33WY4l1nkNfa1XmWB14gtKsmokRW9AtCQiEj5zplWJH0TM9GWALgxi1ZcyWjilbCvV3Is8ZjpXuXHMuyVaeR7V8VcB8yX3m0iilab9ZC3EZwUoouWAbN7jX5NupC7h0ja0Ea272GcVKQA5w2wjWp3HkI+zLztlhTGrz00IGO6Cvq/XMpWv8WP4VeRRJHo76P5DdJWtqU/TU/S3LwnBwirbzG50P894ISd0vYfEwdtFtpgR/yXdaApy9Sq99wrfBLVivVrn7SJYABAJ5RhZ/BjQEg/nD/bHu3YSLBgue+vZyU2MtlFEObdiWZCFsc1tlF6fOK/IvE6PJnpCJ5+N7M+sfphayqSmIWAs467J0irZxWob0X+pjGnrtPL6pB7jLIOf9r9Hrya+oO7CgMd+4Lt1pqEhhlivrgZtVpRyGfEahEI00yJLVLm2JjV0O0n+rJl1FvEPM+GFnqNRwSQdpMWpMOKfIpmVGAY+sm9CBsOgpUVJ1HSc4nzRkKHZJGUkLOxD3YZHx01JHgCYTFOkRKw0myfMQphMy6liTsheMY/Vh03Jrs/dSrpLLCtnnPPnF9bReylnVrmYSRV89llmCpLl4JGm1nMxs86n3ui0jKZT4uZ4R2BlKXHtLsczXqo208HCR55ZfWr3Nb0HVukjGjviNPllSQa1Ajy/xyzGoQDv5GRJjBYwXbLMcU2o3RQ44sw3Einwof31MXJ7hst11cRKx2OfaDkkoHxOkz1qjSn/v/zRZnS89f4E259v7nOUAy99TXOMCx+NML/QHGO6V647u0pcgJeLuixMOC99P+Jzp0vyWO6RDqLjQ/kb8nxLK277d+hnOXcvxt6OXaE/FUBMShblE9+Z3RnWUYIVZY5ZEl3OJ0LxmcPiMr8fLJ7OEAotxp5lIQaLGXvesUhqkIN8BCaZEJ9HbP9at400zWXC0u00uWIiqMF1KN5bpUFHSMFoVvYD6RGR7mH9gNe/Oc8JS13mTkxsafayLM6cO26dLhwikj0annNXBrQlCg7ZvwCsrW4e84mR5/16k7BEziOJc8Qn7T6N7ocVq/Xjek1IFgA89v3fw3+Qrg5jYFby/hLSKCGIlrW/yqYzhczIb4Y1zEnXlbTKGAMRJVuSZAE6SzExLA5SFV4+SpkYELIMAyTJAnQwfS71y0Q7LIujSi5YJVCyj9zKn8xgYKmzwreRA4B0DVmigsriIOcC0li4QtslAegTSPS72i2gisJaFilKKo3Zm8rkFDCFAOXl9X2ShuUoEvIASqpBBnXLT9R4TqaUBoEl/igx3ufbXPg0HyGXG/ygN75aX9vaC7yxMkjfLDZOfgouTQbZ9FU8VXdrSVgF0ihyJp6j0S6ZcJAIy5IqiySOkRlxaDJpwbICU6tQvHDKgpX3iI5a8W86Bkv6qdrbUG+iaiGKdsnzyu/W6kuVurvexCyLRneRgepyXDQyWuNTMtmeGuOTJFlm8Ls4ruzH5BjeV6kCUH2S9AA88199q97nleP1R7IA4J3/8C9gcVApNTKVak9ofvNzXLHRUHy5llqwCkICSEiQeXo2YuudKMejiIBVoDr2jQK8FXcTyFZYZ00EDcsW0warA/OrZlSB9HFQR6/2p7IPlBhZwfJSDiKQLdqWw6M1M1sx/BLIVDh+qMPYyF5U56AD+4SXKqoD3KsPqSbBtGg0oCyFCZmFZGdVrxyeeSC91ftSd4QiEFO5nsg5wmw01FYLdbaCanXIjqJ3pwz2bpbD33VlovC8qs4pkICCztqXTlloaEmWoD9VD1QhhkpYsqYXGxfv/HDCLLy+sk5EVUdTP6/wHofm0M5OlH5SFo2Wa5RFqGl5FuSOWV/CLLixVNlESxEsGuju+CBV33tJYqvnF2rSsfcrAsv8qol3dYwLnyrv280Plu/dzmcK1a6bX+UxIxmDrgCmt5t2nT1QHr8O+q5WhfcrBORTwqHIhRP/B3j+u9QBMreVEM8tuVRqJGS3y77Zk/JE7ixmJDecQxYKrwc/gxMkx44J9EYZ9HWheQXDN5FUMWrh/NQFGWV80tRIp5T/B3deqF1YJ7BQo1jO2xuuKcTGBbehJFd1oe9wLvKOFiORdRyek7BiFZbcSHiW44ITqTAh9WK5HrOqZWpUiDyrp1tkEaulW1cnWYFchUmSy3iCT23NCtfQFnRPiVEWaWJF+6KcX1uYSNdhDnTb8NsyYnwiWPDHsxSf+a3fpq7nVUIryXptYrIqfOa3fhsmO4boiecdqYrFMGQY+qQXRmvcbOGFRUpZuSwXFz2HEbXo+wpWG5BWLBkjJgPppfUKQF34GYApbREJ2QYZy7UKonHOCJyMQ1OSG+i3ErpEdB4r3K9kzQhuoOruyqLRf9Ai5sVrlzsFKwvSF4wLlAOr5N1MOHKFQFkrqJ51uicjnum6YoByRGZyLvb8uaxgFbFmi6pzpcexjmkZxVjGkXjvV9A8s9BGsIAW64VliSPH2HtPUhMsADh4p76Q2fVuiyAggr4dLztjWq8stBEs+ffdoOO5JZfmjGC1gbrViikXzbXuLyVYbaCvg7SYAavVD6VWxHzSEKz6HD1CvIBOPmgjWPV6I9tVgg1vmdOWOJkMZo1t8vLbKnCE1atoY/UQrGgRMSu02S/0fbdyn752GYlxKo5USjUZ/fV9JlideE1JVsBkZ66zA+V96iFaFlKj4jw7hVKqlr4g4+VuqwkVFntmjxZJUpBGF4No9WU9Ss2tB3cP2bIkWttbZ7oZ4n6MBVFdhWhJJH0B7ZKo9LmIx5rdKKK1wi3v6xxVUKqxOY016Y1ngU2qKAojcF2hZxsnS0+tgp6OciVB1Z6eZZUA9ELUi4zkM5Lf1moVpTqx3O1v12Kn+12RJGJsyE9JKLeZ2mCFY/Q8Fyfczt54N4IVCwDS0/7JmCr1ItBWpogdY9r/vSaE7JiB6LLPFE2XSRLZVv930UewZJ9guaQl6bd04Ngx+yZj3vUTrB5475gVC9AEy815w6WLX4U4jPxdEyzZt7tR0dtZmwSLbSCJgsd4tmJdsvuE19RdSPH4D/7F5mRS8ypYDGmNwYi7NPJlxPy3Mnh6tJbanQYdDOlL0BIcqEyZsvYbNVPWAez8EJK8sKLTjgfSB6tUUomKhuWQsRjIaSj8HDIQQ6A7UFq6rm03dUGu72/jiUt36uWXjzfrQrJAo5/FilR7x7S6lmcjbjFznl9HuK80YJ/EBeTB7CtnTxSek4Q4KRp3IVA+L0qUDRezS7nFMV44PpPMeYcROnwaF0Q7aClQWR6Ez2iLCc9qStd5B1QPEsHdHSzfNAA29kymws1jpp6OLGLv63SzZHjzwyYglnZi4Z1iMXSZ+M7CjQnEbcmTPEIQPJN1EJZml3IXqB8VcOQZ+ZHXpUgA/h3Rz6Halg3WBd+mtjRSdyQhZIF8xZRjFMD4kLp1eB3B8SHXaCpGwOwmWV9pX9GB9ujxqFY4X6+ES7P15hxn1zwj8yGgmyrPyyBvhQiqN55eO63/Pr+1hkfedqtefuGzV8p27pQX7/fLBlKC5eYxO2Zyac77ygisrE5w1zELDH0HlvqZFVMuZhvNI/a+xwvHvi0r+1TNgWMeeB4teR3E+Cxi326wZObEOketZCG0INtudkr2Ex0Sl/O/rUQNGvCerXNLr3f8Wy/GYr0IZamtUlKzjupc0fVhH5o8Ns3YBN9Fno2PIVyGkisfe14yy/Pn4h23XJluQkoig8uPuinTiC8vY06cZBiPGGPNcAcP1p98gaQaXp/uQoox0fwwrVryJ2HJiWW6pwjI7rNqKVhquRJt2ROhDVnULwkh0RPM7j2XhJBaXkmSM4IF6GB2adW6tnnMlqczHWgtxVClVctMFe6wNsajAnGflUocUklhqIBPr6cDol0yVVxaP+K5U4HXFFIDCdAuA5mePhKK3qoGX2TMaA1dFwZxb+fHE0awJEx3urIWe24Zk9+U4xpa5T7ikD2zWaWWbbgD5PGUNUSGT2ausydzuSBY4ATLgkxokEkSy02nleiJO/L0YccIFgCsvazPSQnWSuggWAAYwQKAh99xsyZY9SGkBUscU01GZSTFWNcpZIcbG1mGVtUBekxZzWuFblN+h5RgWcjXc0awJHzkGcEC9MipZRb0cZRcQ4/1Sp1EliGToSmWzpXsf6U0UY+FyM0jbb2SITWG9YqfE+0EKxzDsl5R9Hmo5DEtsTHSn0y2erQ1vgB43ZAs6S91o6LXVSTdVaMN3pmM1lIei2XVRJtIar6Cb4lCHnKV2BtVu6F7YJoI/asoLhD1uOZGMe8NbhxtsuW1hB+zEB/lZJrWyvNAS/kdGXAvU4LFZWYruB96Id9YVapGrJfkxevOQborJBQxk5OrHlfPcrvQblAxCClSpTowp0sXSfSI625tCg00q6M2smcZBPFSblGl2C4y0KwBpueTkQO6WRy7C5F2H6nwA6XGz5elyy8f60YvLhFL7czj7EHerqN38JMogiXnKUYsEsXuY/uYTfh3/MJnrnQuS/SWQQL6s9eserQd2yenkc7Mk+gJH1GFogUmt+PejFKaHQdAiWkmB4kykLAmxZxkRanWy5IkTLsL5UE7mwy3iFTxbvV85DFk37KIUcjsZHkeMRnqkqIAjH5AfOfRLNMEiyZpRL5fUHwVrUVxjNcqDovideMuDHj8h76rOiN3xfk0Yh9rJNyB0ahgAd7pyViRrpQqyQdXTSLOQWGRHzVj6LoalC8bfZmkX9p5Phh6pyQQqGXJLCadR7W2VpLkimClQhz16tYxdidNDNZZNsaze7v1chR5RQTPz5ppejLKkQqxVB2L5njpIg9GEpL1FJlQ9lcEVX508tKF20gRBC86zszxMjspz46J584OPqduDikv4Phr4jLepnjuSpJVb2DweGqRj43YBitYlN7vCPzeGbpzOxcai8fBnQ1TZ4xBxnrJ93wZMQ0tH4v3fMm/VxSGtU6Ua5HxKNK1GC3583K5yG6Kjbgt6kJMebmccie+zXLbM1evjzjBcrlXBOv47c33NrkdK5kGmSnYR64Wl3JGsGjGadh+97F99tP+M7ts+eF33uwkWFIXy1rPMoX7pANibUWOT/k7kK8VLLZK6mr5CJqk0+QRaHIlEyTS7QKT20RaQLxzy4s5J1fOsz4i286QHEgNFb4Y5ZxkyHeqEOQrn3lO1hIvqkjoe+dH5Bt2UMTKTwoemC7dyInnz28t03FX9JjeIFbym3f8uqSWWjEuTHJVby/K1Vkoskjrc8n+T5ZqEyE7gczdJ6mGNrz+3YUB9Y2RVhHBgqU+k2XV6ix8HOuBSGEVq1bfNmLgUPFYYn9aNiEgpXUQLQsWOWaWxSy+CtBWreMFdyv1WbUksjRm5XgsyA/pfli1eoPila1f3PsVLFp9VhIVJyIy2OQx+7LmVipeKsmkuA1Rj6LxzsWT/nP0QVqkZAaQJGlWT9NzqdLa12fB6lPVtgqDy4BoqRAuB5pi1N3ox378uHP9q4IV8iFesQXrbsMczJPwxUQEkqvC2H2B+yvEL1OCZaHPejXa77HwwHYRUvRZr9R7KC87Aldht6zLMnNZWcoFKesJbFdufAmvJ6CrWK/Y9pa1im2AfutVm9RSOMRrQ7A68bqzZAU8/kPfJSwhjgdipzEb4ZwDYhoYX60LREuSgmDVqs/hnS2aSTu0mMwOwqZSWVfqDdFtk4JlRQaCFYWg5Mwxba9gtYpJjNVolNf7BTJESVEcexaTFQjW7lrpKrpxtIk14mJ4dKucEX/q5lVyDJKSXWls0Xt/djqptwn3NyIfQ76MFKkCUFvoivOEBztK3ZecWzjUfQw/V20IAffsfSFCm3VnQANWZXKFN6xUBsGqZ95h0/B/eI2qNobBuyZZ1X+yHqHnk2peR1DGvcRev49Ac18yh4gEx4eJR7Cebm+X1svD/bKMSv2+U6aYRf1WLCoZEo4RLnNcIN5oRsNinxP6+voqNz0NqK6PSQcNcX+BivhY4rVh4i8sluEeBwIVVwl0Ta071QT4CBgFvuSa3+r1DpgcNCe5/eXl9bzzB8t7/Plv2MCFjzXrb/6S8u/Nz5WNWW6FtvProy7H+CxqsveM+7D7xL6yYL33i5+r//7kxx4FNslAd2wTiLWHStJ99mJZpLGefNTCY5UFIhPfaXgGLGEISkeLWuKS04iR4bogdxUjt7hY1MWkASCrE1HK5SjjsXB1YW/yDJNTV28fpFki0k+n6752D9NnWiegCOu0fBXZj6Ttyx1iFT9zTSJFdVxq4XSeWHZlIDvK74hZD6WlK+IK/uGZMTV0auUJ3RYlV3SoMpIVfMLHs/ocRGOsoOE2QgcrJKqF8coS5abtKAIR7BKmTiMet+X4Ni7yrxXBeuNYsgLkjZIPSOlLyZdQTB+kVWs0FVPYFcqDcEE46MFHOdyl+UbMHuQ1iZlAHBe25SpsH3lTQJQizeOaYAGlq5DiuaNduYs4hz4/bVMyynutWgA6C3yXmaL0BPJh6veXCbj2xKf52PfH7axgQOIHFfvI2WoirFiu/xy9hlPLxUdfKTmTHBXMPX14uMbWm5bAu6xl6Ec83kzOoKNdHqTiCseyJv2aJYvd8neAZWmlg6JKIuAWqnzKA9ll4gJACFZ1bBmHRwlWQCBYABjBCggEqzkxbSQnWICQR/BQ90ISLH3CbtPe2kMnNcEKy8pVLTXo5GVJtX5Zmkq6OgXGh643CYE+K0uzTpJkun1y7hjBknBF8691G/R3D5RgATxTFdBK/+wdtQLZ7xJWgWZl5Zl3n0QlmIgOqSxN1iwXstKJ8A557/oli+TqvhJsqnwYv8bXkwUr4HVLsgDg6f/yz7JlL+KRpFaWLAHjvWMWlvSYf42jacasV25sdPirFMvsgswWlNXcpQK88VJ6otiepjEyRdaav/PcqULSN4832PKlNZ6RlBX6vlFIomW1kSIeF1qHhaYTz7K6DmKAHPClqVnG10mroyJaPaRqJa0n2ef0fS3SddhTWLa3516B73SRVwAqVu74dAUlyLtpQ0+nWNyZrHCMnvVy3O+oc7rK/hL5tP/Z9q2Xmkp9WFzhfU3xaoQu9GB05bxz/fkp7x9VmSqV5em71xuwSs1QrL0o+vgeF6EUcpVJKom45GzmWZKDuutFfxtlXJgkWDox5u76Ir+e8Xsvs/pkHUrLfSndh4JgxefiPsuSYz33QIU99PZleoOCjGPFMtbbKPkksVpY3J/9pm/pacRrg9etu5DisR/4bgBgQeqAHliLjLup4nHOCEORO+ZGGm0uWbqyGxVK+qEzWzB8HDIIWYIMhEy7KOiGtHSwUfWScX0Tfs1JUrBgeO+bEjzlev61XNk8wSRuCMzts3U8uNFE9n729iVmHXPOIxYvOx2oQxsnhDSdnzUuojpWjhaaHpOsxflIraduv5AFM9psLCLp2ZjrN0mLjHT9ykrsPZl90dKpoqSy44ytAYU0IyOK3mF2T+Me8rWiPq85gDvftKFlPdUQ81nEOqVoVLA4RReLshrLmN8j53knl3hNfiwyE4JZQ+khEg8Wr2UlyaLXQG/rWg53QtOzYLowGKjVzJDwkEXBmf7TOXcRjyojThAPdUVTGBoAJnvVJY6a9esv85uSzhz239MsP/mjJ3j5lzSZvNO9onYVAqU1SwbKU4KV7hQYHZBJ1XahQxA6uqT3fvFzpZuwPmH5rdWFhW/OmPUqgBIsf0j+rt5B9izk+R1f7wo9wRgdcddXtt6sn96KahcuAKRbwmIlusd44TC/St6zijBQgrX5THO+5Xb5P63qwN6j8Ad9tMY3R8mVJHOIDHJF+zEZhxV7VRje08oMZwlvj9OTC2W5AoRVWbv6KLlimlfhMqgrlnLuqq2syLYMZ7DkGej3GBeMWEWjgsdWy4LzwhWI3CliFQTFv0BaWF1o/SrfECQLWJ1oKWuXePD5KY9LcJOcDzbWjLFXhZee0FjfQrLa2ihBz14UjsVoATDK6IjZnNj+kZ0DtjwW05bP7V3k+wtiJ60hM6GrRUlW2Z6CuWspyQrIls1zsYIj5TWnJ2LWLS1nkizfJdFSmjDiHiuSJbanJAsA4hMjK5R01BbR8vK9kDFposRQX2mpWBSJzWXygbztfSnVclla1dKIz7it5rEYM72aPSejF6LPzfL40/gfK6WfBb577Xoace86Nq7za7z5QX7M9Rf58tE7pTaEOP5+twUs3ZKDuej/dpe1wGgbqAVLVoIAtAWLkiwAmmxLbitjGYWVgxEs6JI468/z9YsL3RaMdEfGDOrnSknW2TXjxaA/OcN6JSdVwnqlZF1kQqJ4TpJkqW9baJe5E5G9rfShwLJ7zW+DfDuRMYbRPs6y3lGSpVyDECTLGMOo8cBL4W5Ad6ryEJJUysSX1w/BAt6IMVkS9Y0UWhiSVPnMwZMXSmUdbi0wIgJlSnG8L+vQiI1gsGK1WPt6BEqtmojk7yjyyIU7UC6ny+4MmRsn3H1YiPfjyiaf6eaiPZvrvN6kdE+ODBJF47Z2hF5THHtMSOmDYh6jIBbH8SRj1jlA1zBU1sAed6AX5UDkLFGKUfZmFIlHKgdPOfDIkjGKIFguBtpko5xOm0U0rCs63js3yeG6shJlarVsT4FOjS0/8nqg2BK+IKlUIAbvXm0lObEWsT5yoHN5txcuPufvgax9d/D2COOj9gMogiUw3os6Q0HTnUK9x0yhfNcIJuvB2Uv82w/B7gFbW90uRUX0e/TdFAET+4/Fd3LyhIxLE9cvJDqSk4iR53jh2HtyftlrAiEIloQqySPjzFR8FcR64WGxahPSJvS4u1WmriBYqtTMK4TU/1LrE+NbprAEhpnMgh7jlBVRJhFSQwXJUnydEKxOvGEsWQGP/cB3c5OhjHGKiyZLAZXli7pREo+ISBqkR5O6SjdQxfrQB5w7XcRYfqRddycCH0Fjbu53ScFF2WKv3QPidCybMMlZbcM4yRnpGo0zZckaJw1BubpxoixVp2kzhbl5vKHixqj78Ph0as6OA9JlomK6dkidxIPjmSJQVLk8muZMFBUo485CnFp2lijJAp+7hsgWTlmxyosg91zEJ7jcdcbglAripJOT60VcR76mBx5Jslj7HRjJUirrERjJknFZPnfqHaIELEq4md6nEf8G5jGLiSsWMU/akH16JH6Tlo7MscFXWuBwMOLfhCGuSAdXaUVwuVOWxxEhP9m6V5mj1D3ljIkTfX5RpgkWbe9yy2N6h3yT8x6C5UqCFeAdjy0aHUbcWlM4fv1rha5D2GPNon3a2gMnilxtP3pY/334/Hb3sbxBrqTVoYMg51OvyBUtJzQ6jDS5OmvuwfxajkRYhrM1z85himd2kCuXc3IlrZ6u4OTK6h9UogJrgLDkyFd8XUwaTxJOrkQ2tPOOkSsrfo6VLZKSDQV3/UmNwCLmhNlHXgfrU4z4hMA5YVkXZfAA6Mx8lgjidX1isnkxj19vBOuNb8kKkDdWDzDaskVRiOWRkN1X7rye0jm99FMOSLJzkorYhqgn/U2ebhWr1mLerkl142QDLxy2d6pXNjUJo5BWLQnLqkUhrVoS1KJVg3ys0qIFgD8jy6LVF/TeZzDpLezcffy+jCs1c+2BfIeUu1VYa6XGXCQybWXSQZ9mUp/GjplBSNevUCz6laArcwzotmaVB+heLYOEZYHo6Q0pnCQOLyaKhaiOJK03MmhZYvrAaed6SbAkepNCeiwv0vIj0VcEWboTAX4P1P3E3Vs5JSwNtYB84hXpY+unRWehbD82LDsEbltbJFkfYImV0nHP0N7r+6Zk4LrS9pLr+75RGbxvjGMMqlKEWBTjuqMRPYV7vRGsTrzhSBYAPPM7mjRNX5QK6ZRsSctGMsmYyKeMYVIiaZZvOO5g8Q7dHbEVy0J+k24c76EkKVhz+qQd4pxZ6yROzqY4ObvLLDOCVr2TCuMRH6THk4xZo47FuafjFNNx4zq6dO2IrS8K1yuQ2gU37XaFqQBOiZ5Bp8sqVW6g2870sIzj+45ZLwDmmrMkLLpkLXolL/pYR08mXGIMGuz4p9qdzZTbjdMrOYzwp2GlZFYfY3DsU2vpyyS05Bso0s3u9VFHKr20OADt1x5QHDUMoY9grZKxKtFHivpIWVc9y8XlvLMotstc5/mTM6esTnQ5vZghvcj7IzoJsuRdpECtRFdJH7ezVLUiKfy0gJ92PIRFrCZFDIm3QwnC8S25Gk+/B00I6feWbRTINkiCzLgoldwp6PGtGr+szmI3wURSqFhOJs8Tlf/oeEjH/zcC3nDuQonH/15ZhocJUWYRI10yaDpbJEwnK5PSD4XrDobvqxWl/EdiWX4k4iWTgfDOAb76ycW+zugLKAreMSuCJfVOxEu/PuPWPKqrBQD7Z9JXQg7tHeZLPg2kJGuZJooQ0mzIzbU5UmJ9my9H2CDtORJB9mVMWrO/VWaIyWTIen7zWJvtyfOUA6B34NvL+mbnjg2C0k0Rnztm2bACSNn5ehThlZtDWp3osfJIxUlF6ylbrxJHaCar8yhkcLx0X5Pj+9gjEQNMRmukpVHnt+Jyp+4vtULFc36vpdtKDrbRkpMsGfwrC3lLRCm3UsVz3vjTh/n24wPHCJZMi59fzdn7Jdu73M0ZyZJuUWmtyTb4dz67csaW5y+tY1VsP3qIgxe32G+0QLAXZVoAQGaCSQsWTexITiIW3zY6doxcqZIuXpM7qnWWrXt1/1gpm7Fn5CrZT7gQsPwMvWPkSpWXBSdXi4s6oYGSK/XdSCInrMfmdxa39zvwqC1Y7izW7loZH9lRrgjQE01FnJngrNPEasS/y84g99xpYqXqGJJdfdmnv87J1ZvHXdgGJjsg9bOymK2XpWsSIfUgSUgsXVJypmC5FOmdlS/c3WQrgrN4nzvVPhnz5BXp4uunEx5wLEnSrRPeOa+N28VqnPO4sNk+ex6PMlzebC/jIq0mU3GujTXujiwK/oF3WfQAw2wt/fx9nEauFwQ5E64/aQVR2WESr1SEsMsNYZZgav6UWmUAt1L2WrTuEn0WEbW9csOJgUJmdG6I795wO1F0uYgAYLl7d3NLSqYvfUTf+9EhIS0GmbasWDV6rEWS3N4tJMGy4uK60EWwAJ1I0vds5LtCCVUx1gQrFyRBWq+iJ9r7KFe4TuuVT3yn9cpPC06wRPFlaUWP1/l3NxLj0Xh33k2wEs9IjbJcSZkDMbFTBIvWI4y8JljKcyPGHxFPRt/V8VqqGSvtgws9nlGCVeROaUu+0fCGt2QFPP73vqsukgxwYhHkA0J8UFE4rBPZgbP5mBU8ds5jTGYa88MJYpJim0sNExnUKMvCFGg+GqsUhSXrEK4lbF5dT55FrPROeAHDtafLhA2UQVcrkMwij5jkwnwxYkRlOk6REZJ2eeMUi6y5N2fLESNdZ8sRZmR573idEaXCO1xYL2fYtypR1FkLactCeZyq/XHkUZDbdHI25W5U8fFKq5a0SLrY8xi9wonCyoYrh8ayjnzT4YT96L0uXL19IABhIA9WDWbJoqeqfq5nlNYXR3+LhFWqcOhKmPDnCSJS7gYeiEnCQk4kNvrIlQ917+hm5D6GAb+uTxl5VivPx1zPKgT21wN7wUunWHNEtl58f8lJ1MSQhP/IvY6Xjj1XS/CSKXaTbdevl/8fvJd8MzdJQeJq8Aska+89MSOH+YQTrNFhhOUFrvnE3DkFv7b4PEJO3E0+4dbD0Ti7KwsWoAfp8BxkAW5TLJJ+PovwjrdY8wrHLIPZelFnS1o1PaOUuwJdzl19UeoYuYpyV1v/0gtl/z3eacyV+XPkvoR3Lui85bwNLuOB46PjCMtdct8jz9x+0Szj5KpwjFz5NGLkyueuJleLvdJTMN5tJpRLKpwd7rv0gIRvLnw3FbkK8g+MXJF3KKq06WpyFfcQKydclJljxKpYxnUJHaDM6B+vNde6POW6hmV5sOq+W5mR4jV7nVuwAlo7zTcNyQKAJ3/4O9mytOBQ8jGb6J6Vlh2hkgKAQbSEjom6xW3196ztHbTLUCxTAimJFsAteVZhbOoynYhg9FQEy8tsxK1pt19Fvhxni6aDoCQr4EQUqKbI8oiTxA4h1PLk3USrkPENsrHUrN5DsgDAT3hno9xntJ6YrKKydO0kC0ZwaY8bOtrk76hM+mAE0Iijou9ELt6ZXqIlExKklUqm8i+4W1GlrVPNHiuQnsVhta8LoHFZpsZZB8mSJVHkOyB1miTJklasW1/aXLs6NgxLRBekEf0S/zbzO+3flnm4FoJloqdsiwVKslRtUPkKiHdmfCgmTVInSRrbqGf6QsYIFsBJluqOc5voWccGgKInmUOKZkaiv6Z9rPWtMZJlGTiZ4rtot8w0TB0jXLI4eJ8enzQCRCQTWRIsgMv1LI+NrFf6LXdkEAJvGIIFvBXchYAek6QoJ828O1+M6kK5FhbnIyzOSEDp9oJ/mYZ2CXvZ5YuvaoKJv9UskS9SwhgnhSJCFMkoVwSTIhOD8UgcS7oHZXah1M2ap+26XJHznaRqfczdHIlod9wjYCfrJkq5BwVluiZEJHV3N+Al3i5pUYHGkAD98VgqLkXGJ3UQn+J0pIkPXX/EfWNSP05KAMQya1dmGHbcJlc4RqrUekmieoKxlTBsX69FrWQR1Ldk1b8LSLd85/ElURjv8Xsun9mNr+IH23immzjcDdyFjvg3A4+9+2V+bulG6nDLuNx1JgzIjEeXOvac5X3rg5xwyIxDalUCdEamJFjLvfZEH+96CJb4rBTBkpcma4h2ECyJLI1tYhKQcuu7JHMyO76XYMk+iTxGN8u0ijt5X9fWF+za4rjorGM72liyezVa4+NMLMncq6z/9VrhTWXJonjbD39naSAiD70oHIqKYIRZ/PKseaFj8sLkGQ/SnVQvRBpm/N4hp1aQZcQ/LlECwM9jTsxS1xCv8NGEF7giFjQAnkohFHnEljMRcxaulW6/QaQWzoWLMIkL9oClOxAALlTB8FkRMZIVO49zQrKmoww5cTcu0oQRp43JAnPifpyQIP3TZfksFoQMT0kQfV44HJ+QIHznkZAPMUtjRg6Wi4Q9w2KesH3LH0mHRYhBGYQNhdqdpyyXfJBKTpq/62BoS++qPjD5s652Xx7DR9q9xsrHbC/rwNngoqBuUTcqeEYfsciGcivZzea+UutILsRzXVI07kKgDPjtsFL5SVG7M2orH72vcm6hiGbzt9Q6coXenz7PeMkJGdO+Cu7b6l4nZ47Fz7kCaiJEicLics4IVpTxwZiSglCAenq72f/4yf6i6gxUuPVwxAhWFPmaYLkzm2gHgvXsL17jA2v1TBjBUlYebhWs713lLqMEK58V7Bma5acI6LyhEIK1kzsxu4/xgpOr0UHEyBV1swaVe0quYlLCyXkx33K8HqBPPCdXroNchSaStq9tN8lDi8VIEauCTHRd5Jn3oZjHOtCcfhdOkCua9HVWvQfV9uFZM3c9ff4FbzcKx5JpfBYxYuWSAmvrZf9wdlre/JhlAzbbLo/HrOZsWlUWCOQqW8aMWOVZhCgp8Plv/HN4A6L1Re+e+rzB4VGSoiCWGUUeRfWuSz0poCwwHYhWGKzzasYfrFo18XEe040l5qG8S3jprZgrlIMfC+CjMycRP9KrQxOX9QrDy50kucowlNtTzCYpluT6M3IsCcuqlRPxU8uqNSLHmgjSdbKYIGmRlwhWrYVSfiyxilWLmt7HkwzLecsr3ucOM1xaLAPHg39WMVotMsGi1RsEX8Gljs8oeyxa/nBcv0N+HivXsyymTZGej+CO27uBOClYQXKlySUsVk66yXM+cK1SRLgV8vFHgrfK59VhkSrGnh1PaTPJRyWaLS1YXdppxRhYu/4Krlso43dZsPxarogWtWDdjfUK0O5D5v6ba8X6Ps20LrxS6xXbtsNyBejPXwba35X1qkdDqotgAUZ4h3L/kQnT3VrD+yxXskzdjKdYMsvV1pyFb8gxQwawU4IFdFuuPN48liuJN5W7kIKy4RGxhiSjnFm34rF0N6UYk3itrky+NI0xFS/SmCz7nAuJqiwK+ZJ2pLWWAe1oRRQVrG3SspXm/GObCC2rNOXB7V0CpEtBUC+v88ydK+s8m1C6JykOz6c4PG/vEA+O1thy4R0K0kMuRQmhTj0tqckiJAN6BfhYsgMUqWIFYQVvyTaMOCQCFQvGyINxri43kxxAZFyaisloP1Z2OAY6XH+9khN3sb2PfW0dAfQArwyBMg6MJSGs4Faku/YQtMle+7OLF421yjy2GJ+P3yayzc74yWStPwbh9vW5Y/3G+m5PWRzaroWW1JCF0SWYCrgkRVvt1rkiLv8FpDs50p1m+2yH90ejY34PqIBvchIpxfcul7N0XfZB6t7d1TueOWbFmp+JupCC3UmCxYq6S/1GgbI6ibZi1ctSj6ur1I0D6zdkzK8kWOuT9hc+SXLtEqUC0mIyvLnR3K83qBWrE29adyHF2374O7G21rhAUhFDRF/0fBljtkmyPBYjFHQ2XjgmAVEUESsrQwf5pSxiLLPbIk60pG4RdRf6wql4I/oiS3JRFBHTq6LWpFFlSaIfzTkJVh+NMhbsnhURi506IKRoXLVhe9LcszGxVN083cCC3O8kLlhZn0LobG3P5jgmbaHuwZ2tM+wdNnF0kfOMcI3HGQt8jyLP4uqYJTGLuO5P5LnrMHXcNSWyjbiqPADSp7jCISKB11HGA55lJk9ESEwxLaCSImhfGfH9Xe6ADWLelyWgwEkWK9EzywESxyXjN5hlKPxOj1+g7jzVIOa6B2xz+4o4RvOIEyyRxeYdJ1heKmL7psyOKzjhjY0cDnouaeFyRUOw0g0gITkc6aY+5pJaKyNOsGY3XEOwHCdXgURQgpXSIuNbKSNYbnfJK0FkESNYUtVdSgwwC6R4VurdtzSawiWmjpGrSBDGeOkYuYpyMHLFiPEiYuSqSHR1BEquvLAe0239yPOYsEWEfJNMro9FLF3OyRW9H2YFBnpPxgWLk1q7eMbIlZUNTsccT8NOYk6s/Dxm1itplXaTnJMr6to745qAfuR5jJWwOrtxzto6ZgLenhEr2g8DJSGk41GaxqxcGh1r0mXCiNXRyezNQK5aWfyb1pJFIR/gSFhxpGVruWg6s7HIQuzTqKIWpPHGUlm2GGRihbBsyVlNamQNWue12hVTC1weK8sWhSSh0qq1MyMkNIuVZYuiz6olhVXv1qpFcddWLbaxsGTcTVmJDosWoK1a92zRss7VY9FSVix6HXdh0cJCkFKAC5F2JXasAHrdhZyBi+esLFiSwFGeKNqV9yXfiWMxC5Y47ejYJm315j0WLIr4LLprCxbFXVuw6LH6slo70GW9Arj1ChAES6DLegXgrq1X7FibPe3sq9rANhYvgngfpfWKbZrG7QQLhrejyz2Yu1aCBUBbrmQWIY1e2Vi2Eiyg23IFyAl/1EqwAG65At6c1iuKtwTJAoCP/8a/wJbXhCzBRkcNvgu7p7iw27jEVFkeqUkkO+rN5lzRNOdlf2RckTDTTgTJox9olsXICMGRREvGPo2TjFmRqB7Whc1TJip653gdE7LtscgQjFz5r16/bNYv8xgvHm3Vy4/sHDBCdL4c4ZxYr05Opzgh0gwZIYCbG+dc/8womN1GWSwpC34RqxMnVzhOjnqyQdmhJtw6okiYIhXtx3KpQ3QurBA0q1AqPXcdyzvDSiFm6BQd6f2mO4ZaQyRB6ymXomQaWq6jt84ePabXLkeami/P6QpgcaH9+OdXvVgmQbzrIi4u6qk5KE6T0XJAogzXA++4hQeuHrQe6uxEMMntpg8ZTTKMrzbmOL+e6+dMMH2QhwJQUl/spMCkm7xQyBqP9D2OjxLkLdwkOY2QnBJCH/HX1I88t2KR2Mkn33cdT77venOe0wjxKSf0XRMq+n6NNpcYbQqyQd+/2PPC6lnESqbRrEG/iOG7yucA7CJ9GnErloy9ErGO0ak4Nl29jIR0jeiPxJi0LSqAUE+FDN+QUHFb4gP88P/7O1r3fbPgLeEulPiif/xttcsMAM7mEyageXI6Ze7FsfAv7+2vMzJEXyTvHXIah+X4i7U4nnCdkXkMRz5q6orMljFmGyIVmVjZZLpskuTMXTYTs48sj5lFi5KsJCqUqCgAPLh7WLY7S7Ck5GeywNGcug35zGdzvMCt08ak/NDWEZ7d3wVQEiWmWTZOcXOvIWUb63P24SZxjrN5M3DkWcTWy0/cg7sGvaUaTDuswvEMqthzHSVqsbGqydNOyvPgYJc5Js5oWp7a+ijJIAtOZooZdy26ac4y/5TmkQPTxHGpuC7mpvTc6rWM+PrYw3UolEvriLy/dID1iWcuU0l2fAwRb+XuilzBc/mBaMnJVSzVw6eeWcNoVmFyysnVZN8xchWfO0awkpOIxXdRMhCf6ZgoVldvxF3YiDweeMetevGlGzvwJOh9/cqpJlgVnPNKWXxBt11G3NV0HjGCJQVOXeZKkhWati8sbYS4RPOIEax0J2fPv1jLER8111FMC0aqygOSODnPj1+MPCNWbukYsXrqsw8wYoXC1RMb+Y34RAtzjnZJqMnhRE/Ogpu7GhMosRqvpVySoUMwuPyN/Bl7nbSS8r6FtX1WMHLFyOIs58Qq8ew6Rmsp61On05SRq5i09eW9LUWsqMB1lsVsTCwKx/r7ySh7M5Krt7a7UOJurVpXN47ZMrVqSTjnWYxWl1ULgCpmnRHl+WScI122Z35lKX+ZM+G2o3FWgLZsTQh5zIoIx4TISMvWJMmwNmo61ePFhH04y4y3k1q2ADDLVuEdixE7X46YCfnkdMo+4iyPWXyZ0nACh3rbezIJlZWlI0i2LxtLnbqven1X2+Su8muV4owdOll96LRoWeu7RCvB48zUuQyrFltW24um9RAsdbwO65XembsbJaT1aiFK71gWrDb0amRJF7ZwHXmhi9VGsADAH3RoLwH6XeoR26QES0LeP2mpjYRFLxJua0mwvOP3kRKsfL1gBCs6jxjBevrDD3HL1dhryzE9VxfBOh5D1TGllj1huULuGMGSfb2C/ARTfixpvWK7Fq6VYAHQFu4O69XWxrmyXrVtC5SEjGKwXnG8JS1ZEl/6f/05rFdWnEA0dqqXbO+0jAN6ZOcAAHDjpIx2DeVeTs6mrMByCOIOL1aaxhgTq1eWRVieV9tUH2hbQeNg1Qpur1mlTxLIVEgFnlQveZ5HzHoV2hJeemlt8t7VsghUmyoEvXsAU7FPIEdnaSVpUV1n+D1YymIRxxUES+vzVctBbX46Tut7dnTcxF5NqxlS5Dx7CdM0qe9L+J12cHFSoCgckxzwHryzCbc6aAV5V1uwwgAY5BJq4lWdrO70QwcSjlUt1tYsx7dn+4XOyipAHREXY3g0IZi7aktBCwTT8itBl6rgba7bEqxZdUkRxwPi5bUlHo4QOB8TKYZw3bTf9Q2RqgVYw22qzhlKsNS3IOj6RNytJJrOhETDPiHuSuochdit+p6H+xeOWZ2nrrtX/VeMPCssXcdKVT/RItBAOXBP9iupF1k4GKXFqi6tEzTwqnOGNgdyVusbBSJRuNIKUeHBR+8AQG35zY7GbD9sp/wdCjgsv1fqKgyWLBfKrASdqeq5z3bKyWawnhd7IlOuSriIqmOrklITX38H4VnRmKzovLGOhvZHOYRrvfw/Oa323y6YZZFaxd72/hfr3z/38YfK42VAvl22M8gZvPuLngcAfPojj5bnEN9F+OaTC+X1B3mcPGjNhfsrviMkBUZVObaUFHwO5Ko4J7p94dkEIhVcttLaVJeaKv9TEwhJxNsC9sNxAtErHDYvNpPos7MJtqqJbvBo7E5JcPpiipNq0n5UJSMFchX67YtVZY/bVe3bMN4s0gSf+i3fjjc5BkvWqtgUVi1ZEkZatWQBY1ngeKRcejSb0OlgeIJskSBbJLVb8PxUxEVJdfS4YNYr2RZpbXLOI68+0kmSM8sWYL81gTytjVJm2YqjghGrvIiYtWoqkg0mo4zJSMyXozqtd2vzDFub/L4X3rH2jEZZfV+kVw2ohO1WcSmxWobNn8qNIMvEyMmwdSpq+lfbG8S6LeZLWnJGvjtI3SpYTtsi1d7l9gW4+aersLNH5xRMWrSkpUDpLLXH5pbHy/igXW8n2qiC4+VxVyjNU6PnGgPBAkoBTQlZ2JoWU/aJ19avjmd7c2+LudYBYXm13qFD7spj+1KBTiNmjIYnWIjEsZmblVxnl6I6UF6zJFhASa5WIVgBn/v4QybBAkpyFQhWfV7mvXNMg64oIq4/SGPjRoWKlRtNeR9H428ZwaovQNzvNoIV2tdBsHziu63m07whWAAjWABqghVACRaAmmDVhxPWq4tinJQT+rcyBksWwS/753+6/ltaYtZHPL7ppeNNtiz1TxapJDT8XGfHhDDJDt6jM+4nSgplkqVkTr7gk1GGE+IKlOsf297H80e7zfZy/xZrVsA8a/e/FN6x+DeAa3Y9urWPT964Vi8v5iPsbDcdgCSGi/motm4BwPkZJ575MrYtQyglMVjNSQdeosKIz1BCoCreisTfnEXISMyNJAJR6nhAcx+66l1CuI8c1FfKYq5iz6/PC5eCIiGOzYSdLKsjSYpYLQeEghzLCgB37Dno4zFI95+4L9bnJDeIyCsdiaBhJp2AsohzQDIHzi8Ll9Jps38+9cgEaWLvoPCy+aTbbehnObdub/ADqFqFm2JwE0Kz1JK1vLGm7yV1EzogJgOztGSpmL/CmEyITSihHB3w4tnxOSENDqw4NADkRJy0iLVLTKr7F1vNvYiOErzrS5+rl3/xo49CgVpJd3h/nx8LsimemRTepLGxJsHKeb+j3gFK/qSArxMxjvI+jHisZjTLmJV/c5cTojRNmAfkwa0jtv76ESf1sk++tMEJ2xEZa95CrsHWadpAsgz8sn/+p3HnpHFZXdk6qYO+A8OnROH22VodHB/I1QkZ/CkBCmSLyjGk86R9ZAgjiHBLBXXcQLYs1yHQBL9TqxElhGm13WPb+wCA5492GQkLWybEDZiQnnSRl9d7YVp+aNdPtvH2ndv1+qcOLjEf/ijOWXbK6XKMR7f26+VP3riGxbzp0CjhApoPPGwznS1r6Yag4p8vqTCPrwepoDuWn4j7LcoauWXEdYMKx61cIjOumBRIiD5QtlawkT/KOOEKRCs8Uu+awSkMFPGCDtzkeBWBZJ1y4pW7ksKlEdve5a5xe1qz36LpxAPR6iNZ4X74seeWmvAogvdrUthZdsF1WQgrk3D1IWqO1Ueu6jYYG0QZudeVptniEnFlLRsrRVDsTyqj9fllHtcTrFeBMGTrBWbXSZ3Ua+W2lGDRuDAf65IuABo3obCYJFvlN00J1nu/uCEQn3zmwfIPSrAq1fhxVUZpeYPIoXjwagYJH6Tjaa4IFiMBmfg+CqCo3nGqFxeQrxcYHfB7Fp879jwDwcrWm28lyEGE+0PjwtzRiL03xVaGiATTv+tLn6vdg4ARCpl45paNJ3lTem2/TPBxhHD6NEK8VrlLq74xJbqI0SwryRVA+vLmdHICxNZHfPvaUhn+C674yl0bXPl1GEDoKqpMxyKLmJUtTFKDVM9sssQuicGaJeV9/dytS/X6sznR/arGHuom3D8jZbmi4q1ErgIGd+Hd4Ke/7nvY8s2jRthvfz7D/twu+wJoN5iE91DB8J2QeefCdZHnEZs1UYIClMHvMgD+lAqPxgUrg/PI1j6bqUhPSV5EyMiUcRJnmMTN9T64cYinDi7Vy2/fuc1kF6Q+1/p4ieeIFe29V3kR2wMheidlKObnY4yrOo5xUnaM4zUyq6xilaiwa7xhPB9CQkzxQYK+YPbkrPuzSs7bi+2aQdeWa5GCWo2M1V7q49Dz9UkpyIBZQFux2PbC8ifT9jsC4gHoQHHZ9EBGVyRYbRvI81CCVZ6H75CQqIDZLYM4dOgsRam2YLGmGfefDvjWM1cWLImWUknL8xEnWGaDulf3rS+ItdbSnwoECygJriRYcCW5sggWUJKrLoIFoJNgKXQQLKAkV20ECyjJVSvBAnQnaom7yttEl4W7v9jIaoIFlN83/cajWcakJCTSNFFaiBSfu3WpJlgWnMgOpwQLeEtZr1bCQLJaIAP1JDk4zxoyc2ntjBEXALhILDBpqgs4U/G20TTDWPi4ezs6McpQ4c3FfKTciZTobEwXyp1ZkFHnka19Zm0CoOKtZMbIWdZc/4Mbh7gwbq7/7Tu38c7dJvX8dDlm7VkfL3Fn3pCpL33seVzcbURMDw7X68SEAJqNOD8fY3ONx9Kxckl9GYF9GYBdMUmwB0kKq64ddY2oOCS5LJvXV2+uo1YhoOOi1P7KRXqX3YTc/y5rIUdyfOjWJjWyScm6TG8g768kWNMbIttNSOjJEjpdMVcWOrMb0e0+BDTB+uAHPsc3EASLupVl3BAArD18on5j55OuMoGiZ1JCZSks9CT/MoIl36X4DidYXp4rAidY3MgMv5lxQps7RrBkjdvRLGUESyF3nGDJ2MFUVjMQ+ydevL8ybEQsiozFSLTN59yKJTOz33HlFrNiXd/fZut3Ns6YFWsmdBtPj7l49MdE5v6AwV24Et7zY9+O9WnTs47inOmGzJKUxWgFddyzinidV9alSZUtKJXIQ7ZgIC7LavuIpQfrnihiZV48y1KMIl+7DoHS4kUlGWQ5m8kow7X1Jqg/cgX2F82Md5nHLNMwLyJMk+b43nMtlLVkiYfXDurlveU6XjjZqZfP0hE2Jw0xKrxjFrGN0YJZuO7sb+Chy83xTpe84z8+mWF7s+ksjs8mrIPMl3FtzQplkpTkQTDPV66xQEacEO5jMTwFj6eIl9x1kq17RpLiuWNfUz7znbPYKHNcO0lOgkcFj8+YFkKJveABtCJ2y+WOF3GeFLxj9+CkKfGtrkJ2zPoC+PX52LDWSasRibktEj6w+rixQrHjEDdiubIiWOE4I31eei/z9YKRq+U2f27T246Rq+Mnc3bd8cKxzMfJnQhzop/lMk2umAtXxPdhXLDivn7kMbvUxNLMX1pn5Gqej3B12ny//+o/vo+RKzfJ2WCb3pxh7aGGXJ3eXMfVR/fq5Rsv7bDAbJfy91xqlQXF/mJN6E9VTQjfTHB9tXq3DYsjff7Z1SXiOyO2Xmpkdbn6fcwnLcVWxt7/8daC9RtFGmE0I/2oIF35WcK/r9hzYhV7Pemhn5fUo8sNyzKVr6g0FuuA+tOEWdmCYryvvBshQ90iVwBwmpZjVMiiD2PCzkbzru0frzFylRURI1ebW+cDuRpisl45JNGS0gYAr+kH6Lsu9UUk2cpVdXZhbZIZVDLgUTyl2RqfckvtkzNhfXtsZx8Sh8vmmqTaOgCMpIyzwDu3btZ/f3TvIbWeWsisY+2dN0RPEi1Ak61I3HRZiicXsUWSaKkOUWWtiQZKkmXFoJCAXWrBqtdTS4j1pdFO1vqUqWXKMDr1Wq6kpUpaUpSoKV/fSbKM7fWH0U6yAINYWnJg8pSWoGnHMUcn/Id0i7d57Tpff/KY0AKS57tLa5VlvaL3cfqA1uajrvXtka5Y8S8/+p767/G2rv9DY0U3pnr9jecuNG1JjeBsCcklhBUnlgKjEvK9EKezAt2Z5cowqLF30woFXCduQsNC1WXVAoSVzzp/T2UI6cqXJY/UPd3mfbrKThcv9mSdbx/IVcDzBztsWWakz5fainl42PSpA8GqMcRkvVJ86rd8O37u1/8P9fJLd7bx0p3tjj2Ah7YP2fLWjHeEMuNwMuYf+Uy4wKbig5GQLklZ6/DgdIaD08Z/LknVswe7zDoF8MzBwjtFtGRdQ+lmfOr4cv33+y+8iCe27rD179m+0bS3iHEiREy/8koT0Htx9wS5d8g7/AvHZxMc06QDcU/ljM5RV0cm9KIMqAFeivoJd0UsXEfKmiKOJzMSk/MekueEJczivGJw1PIUslHGOehiH6kS6CMcLtfWKr4BWrswZ2S00XturZdZa2/7lp9R7aGQ8VTpulgvnjFV+AcMkijJglWfjmwTX1woUWL5rVNCBQD/+nPvYMvLMz5YygnZzc9d7FyeXOMZaeqZy5Ek8vZ1tUHEZGkyQqy5UT/BcoWwCCmi7hnBkhONDzz6PCNYyxM+Ic2PR4xgKQFjIzOZaVjFXpFWNdnpIWSqioVYfOAa79/HIlb41hl/ka9scLfxHREPe3wyw/FJM3488zu+dSBYK2CwZN0jvvyf/lnsk5fwgYuHypL1MCFZLx5uq9niIQkYDI8hoeUIRO98fjZhBastDRvqsisKx0rvjEY561x31s9xedbMkJ89KN1z77rUWJ+eJS47oLTgUWJFXXxAaUqmRGuZx4yYvX3zFo6z5j49fXQRX7T7Ur38qcOrWBBitzFe4O2bTbYiAPzszUdrWYjYeWXNAoDT85JohVitUxJXkC4TnoEIlIVaqYyAd8qKRbmGslw4PphHS6cI1nK3qDV/gNKFRVGMuCtSEqps3fMMqkQ2CvxLjUXHHERKg7s01q5Kl0YNcXTQs3PvOCESJXGUVAT4AGnGSEmpC6oikOsgdR/ZZJXeb1UfcsTJVbruGbl6/r/9anZdy13PyNX0lmPkanGpUOTKJ74mWKXAq7hOTwba8N+Ek3xKrtwiQnyx6TNG44yRq3dfvoEPfeoJdo54nbj0TxNVFJi6vsbjHGcvbrD1V568wwiWH3lML5L4x1szXYLKIFj0GiSURUuSqgJmwfFa0Hfs+61GhTim49ZC6VaPdpb4wKONhtbHrj+oiJXUtZLvLXPPVsdmrksp1RB5Tqy80WZp6WJ1b6GJ1ZWD+u9QGo2SqzVRam2+HDFy9fStC2z9+mzJiFWROzzzO74VAxQGS9arDWrVAkrLVlG0386Htg+xPeGWLOq+K2sc8n2k1UhatsaTjpQllLPd9z3QEJg05QWlD05nmOcNoXlsZ19Ztx7b4stSE2uR82XLsvXB3abzopYtAHhi6w5OSWXY92zfwB6RzzhZTvDhO9zNSK1buXeYjjLszOwC38GyRQmptG6VDRedek8wu8yakgYwK9g3Oek+JiVgq6xXVi15SmnVimWNQH0+1ql7GFHmMshbDDz3YNUy3X9knRQWVYkBuSa0bH3mXrH16vQRkUhiWChZjUqjOb0WLLGeEixA1w+UBEuhx70nCRYA3HiGD7KUYAErWLAE+pMAfKfVqhh7VVant3i7IB8+6bcaUYIFaMvV3RCs+pwdBMtljsdOTgrjPnQQLKCTYAElueoiWFvjhbJeUcSxZwQLwECw7gGDJetVwpM//J0AGp2qKCqYUOY7HiitQ7/h6sfq3/73576i/vvwTMtCxFHBilPP04RJNAQrVfCjHx2vYXursUyF8jRf/HBTbuITLz2AtSq2bFkRrkd2D+r10zjDmFinAtFbj8t9Prl/FQ9tNBa6w2XZ7u0xme3mI2xVMSInWXMP3r9dtuPn9x/B1RlXzgeAF053AADvquK4/uWzpcvjQhWE+b4LDWEcuQJH5NifO7zE4uQOzqe1NSuAxrgFgjo/mTRmd1LwuHY1eMcL5wY9KFYAV3TwAqPjiCteV5sHq1W27llQdbBw1dJo1SsQRDKleGa5D3dP+MjDGzXaorNKUyfxvNh0GCSohyVzTbxU1RjqzvTOJlVFVZ6lVuOu9g0ES2Ubkna7XBjnCn7OQgxc9d8eGBPv/GKXa085z8nco9/+7wAAz337V5dtFSFJ2UZ5HhovN96LsLhEUuVDaZzqp2yzsDM/ZckiacUSRaDpYBonBcsmDMHqy6rGaRpq41X3Iq70sHIaaxh5oIpFHFW1U7NbvL9ROmqkfdPdORYvG7IPgsjUJYEI4YiPqhJgE19bsGRgOr33+ZpnE5QyFoye0zMGW99a8d2FCU26IwLxwb/dD76/SR740MfeVv4xKZAQCYRQuggT4l48SZrrCPdOFFRXFj/aDi8sX9VkRcrHBMtkSNbZ3m7ctoeHa9jYavrdzemiLl8GlDVfAU2uArbG5Y1/+iZxDTuPuGprcFF//j//s+b+AxhaZxMDyXoV8eQPfyfL6JNECwD++Ad+gi1TogVosjUTgYiHx3x9MspZsKIkWkAjNBrw9D6Pt1hmcSfRAoDNpOkJJdGyMDaC2N+23rj9LKIVSFbAiyKd+Gse5anqkmi9KPYHgBf3+DFkMsF4kuL8iLh551Fv2rT8nJTgovhaFMmCECcVJAuosuHILkpFHJxsSZIFAIUo8hsIVls7CzGbtqQbrMB/iUCyAFuMsi/wXZ5DWqksK9HkgC8veUEGRbIs0ME+2/BKmkG6La0khqDtxE7MlvmiKte0pmMIKclKLmmLbXrQrI+3Uk6wAEayAMDN9XOVJEtaZpTbT1669O5NippgASVhl5Y8SbACIWKg74YgWOUx+ObSWpyJOpPyflsxmIlQe88WIjmGEiwAkBZJg2ApF7qUvTBGWOr6LXLHCBYAFZsqK2uME90HU9w5EJZMQrCAkmQNBGtlDO7CLwQ+941/ji0XRcRiogDgH7zwZWz5vbs32LKcdZwvR7XFCQC2N89xgWhwZWmMX/LAs/WyrPkHAM8e8riqJ3bvsPPIj3GeJ7g25aUV1gnJeu/uDWyP5iyj6dqUE6ZlESt358/vP1L//cHd5/HQ9ICtn4mg+4d2OZH7qeeexNvXmnix1Ef4/GEjmvfQ+oFyZ9Li3QCQjDI28Mm4tmiz2wUL6HifvsHbEqpMN5tO1kd6QA8q43W7etwuKovJgPL8Sc2hs4jFy1gWMxXD1bO8Cnp1oXp0liSBXW7r9X3PSB4jF96i8YHISjW01WhRaSkQCUBpOPm17kHQnyTIDsad28j6pbkVPE0e/GxXpG7CIG7b/Bu4/NABW954hPcNFuJDodVFA/kXpQBpJ8ESKvdOuK7NhAZJsDZ6CJZ475KdpSZYh+T+n8fAPOaWOBlPeJQoQsWWixUIVuE4wdobM4J1cjplBGsU54pgLVLer8lQlaMzHj88nmSMYAGDBevVwmDJuo947z/6diXLcHW7ISO/7eEPAQA+fNyI5X1y/yoTPj1bjJnMwTjJVV3FvcN1/L/e/mkAwL9/6TEAUGKhx6fNR/VFD76EG2d8qj8Sx5wmKZNfeHm+xYjXacYtdIfpVBGtl+ebmBKLWOEdDpbcEkfrID64XpKqO4sm9uQ8G2GTkLlfvHkVv/vdTTzNU2dX8Im9B9gx37Z9G5+ryFdwIdKkhNPzCYtNg3fIFzEiQoj9ftm5MpO+LE9TONXJOiPci1qtXM5J1+g4YoQrnjslA7EkA1CI+2Gky2mip2QbpAXA87b6mJOufL1ATIoHBxcOi1US7kLvNMmy5CNYjTlhnHC56401i1KnSNHsluPkquDEKRKB6KGddBtJrBB5Rq4WFwo2wCbH5TpGriIeS+Myx3WcUqfJlRRvneTwpMamyx1mDzaxM8GNQwnW4lQ0vnB8bp07RrDmL60zcpXul9+zI0rily7y7/n25y8wgnXywhaPjwpu8Ll4wBDWyAIoSHPzNe1mVe+R06SKvhfJqeOkqjpcYbjMaTs6SRVQFlUOemXBc05d5hs5U5f3I69jIaX1clpwLa3Es+uPq4leKGW0/eghTk45KZqtLTqJ1eZszojV4aLcn5IrGQOc5xE+/Q3fhgH3hMFd+FriXT/apLlSkhXwjm2uXfKR2w+qbaRCu3QjfvDyC2z5UwdXWaHOY/GRAsDlHR70KIkWUMouBFwcneKOyF+XZGsW83YdpDrWbG8htKtEwoAsSP3w2gFePuek8Jde+Dxb/j9f+BK2bL2wNF5hvhxhIaxYUnOmODOitKVrSwZ+C4LgE+5WkuTAgrSaLOUs32AzSuiyh2QB3aVe2vZRcg49FrQ+khVlXMQT0O7BVXqfWFjdChno3JFOH6CsV0d8n/kV4X5dOuVCLKTrSPoKrBJH8h4K4r52lbv/zw5mmGxyC60iWeLZzba0mzET9VOduGeSZM1FH3Ty3JY6pvweYqmOP+ZkybLyKmtoz7Lz2pVLXdYWQv1HCkWw5HlkGIGcZFh6dPJVtqy2ffpiIgFCeiuk1QoAHt45YMvP7+/oppHTfPI3f7tu14C7weAufC1BZwfP39jF8ze4+05KNRydTnFkkCIKSbo+e3QZnz1qMvfes3MDW0QyYnN9jqko3fPSjR22vDM5x86EuxOo3MKddB0XR7zDvzQ5waVJQ9bOc/7B74zOsSxiLEltDGohA4Dd6Rl2p03HEcEjIj3cC2c7uCbit37qzjvwU3caLaDf9PBH8PDmQb3soN/6LI/rYNDpOMVkUv6z4Auns3nkwJ1pgcZ8o7tzV9l1spGulHrgO1luux73oFgfZTzWSVsFXG8moXneHikkqzai1ALryx6MUqf2qbcVGluAJrKSYFHLU7m9IachLCAy1spypaq6i7HX95CqqJ/FcCJOzo3FxQgyeHagJy2LIzHR2VwoUiXLbHXVVwVKkUmKvYMNnIk+SWVHunbLUT7mBEs+t2jpEC15TU8vqgVYNf4sgsUbqfdhFRnOk/IfIVgudWwflztDYFdbceX6vrg1l7tOghVfXCiCJd3HZ3P+7GVtVwB4+haPwT07nOHssHmPBoJ1fzFYsr7AeNeP/gUs53yk/RXv+CxbjpzHTz37NvabFCoN29XrRxkrUwOUmlUUd065BenkUHfY73/8Rba8O9ExXo/PuKDoWcE/fGndAoCbiybIchzljJgBwGeOrmBr3AwM+/M1FaP14BqP0Xr5fBMZ8ZOtJXp2+sLxDls+nuu2ZcKlOz8bM6E/P481wTrng6OM94iM4GKJlWr69cVaOa+tWKrD9yJDTxMZPUvvt4Sp9luXLMdcazCSh5FlPEXbTIuBHKwMCQ5JrvR6TRASoekkCVwQxqyXR4WWTlDy8gUjV35aKHLlTxNGsNYunmmCJU4z2+kmVoCWWDnYW1fbbO3yb/5UkKv8hL9wbhGx52i9+5bVVBFbQ7xUCd8qd7Q4xqzg98VBvYPJzhIZrS+4jLSYaF+Io/VdKuuxsV9P4oNpYSPE6sIjB4pYzUQc75WNE0WslsLSub5zPpCrVxeDJev1gk9/w7fh6f+SBxTemHNXWOEdttZt3ac2LNIE1w+4+X59xD++i+u889zYPlcFYz/6DNek2l+s4TMHXNvqX914J1teE6lx68kCi4J3xFcIqVoWMa6fb2Nv2ZC+d27dxIVx077d6ZlSn1/kCdPlujY7xuPrDeE7y8b4yPWH8JHrzTVIhfjN6QJP7DY12gAoNe2pKEcUrxAMr8iEMaEfHfX13Aake065TvrdgKrgs0e/G6PPUgbcW+8hz7vCaSzX3t22Y3lBmrv699n6rCDSsl3GeZXFwxqMpeaSJCXecVHSaa4JlhzQe/TJAOD0Bd7PHLy8qbZxgkCdPLOttpGIz7ofQCy6Mh93E6zaqiUkOJiVyzC8elG/spQgIcveAZOCESx3GnOC5V0vwVKB7QV6CZYTMXIudYpgjUTpoyguei1XqpTaOFUE6/I2n9A++7v+zECwvoAYSNZrBItoSbLVR7TWJkuVjWgRLUm2JCTRenr/Ap7e56KEFtGiZOv5s108f8bdoJJoRc6rjENKtAAwogWUAfiBbIWAeCmA+vj6nZpshdpcgWgFMVVKtG6fr+OJ3b2abM1mS6TLRJEtClbXLIt4mY9AUDqI1koES7o2WrgFG2yka6xqpiRafdl15TavPtEqxl4LsxpEiwe/aytZK9HqOf/yQt5LsIrEq7iweyFYaqBdIeNToboRTmSgORrL1VKL8vxOQ8SWywTn580ALQlWsyFxX7YQLH+rGdiLvTGT9kj2O76ZefkvvHs+BivwbSG4Yesi4IbHtX5Xqv+bMjs84YDCKVc4NJnqed8tt6FZ7FxOauSysJqNthcmweprr0WwKC5vn5gEa8AXFoO78HWCr/83f1T9dvOU65iM45y5u44PZ3jg6gHbhtYmBEoZiScv87I0z4mioI/uHOCzNxoSNR5nigzJkkCxQZhCdiDFunDhHQtX4lilkgEbYh9JxIBGHDUgiXJMyLH+7UtPqFkfrSwPlDFaD202bf7Y8w8qF4uMl8uPjJR6GUMkLBOy+DAA5FNobaKeQs7R0inXoCQwMvDe5U7V0pPwIw9H6/15rEQQVpFrkORFxl9Z45osEB2lzgyQbk4CRbaCcCuFLOci793mM3r0P31QxG8Z91IpuUtCGHs98Er31Faqb4Z8Hw5H8CT7LxoVKE75CyGtrsUdYflYy81qBlITTek6GQHb8n6aLkGRRahciX06YsI6VbZFn0fdK4PI+Rkn2+5YfEzG96csk1aYotLRE8LAiYcTMXzxA/wlT89GGG/wPm25x920o50FI1/rswWmIrbO+mr/3a/5buPXAa8yWjvMgWS9zkDJVrDYHM7Ljy3UBAxE65jEVAWyFepVRST2QhKtUIR5jwifWkQLaOK+HqmyVfbnzT6SaD25VZ6DBr9LkvW+jTLm698flDFnVOR0UQXH/9RH3g0A+PVf9tF63f/z2Xfjyx9ryul845WfBQD8kzsfqH/rI1rb62XHRuUtLKIF8HgWSrTykxEbMKN5hILMoIPrhMkUVKtDaZe86juVCjR4vFFy5pCtNcsWyQIEWfDcChSOLUu+SGuYIlmAFoIMO0P/zIgmjVFyfICOUuGOCYcl+8QLbiEI8WQm0QrbibIrVHcpDOzsvhT6eJRkUTHTtBK0DLw+LNfXRb1NlsVNkqxxAXdKmEKl0k7vrU8jOKIwjsPym+oiWclmyjpqSbAANPIRFdGyBGd9VTiZSRNcWNZtqC+LaqrdJcEKz9e6h/U5JcEilisGWiuxkmTwYTK00TTMV7GX9b2vnomvElxUHUFAl+sxULen+hi6CFaxWZ5rRAiVJFhF1c4QjD/aafrIQLKC/l8gWaGPismHPZCrLygGkvVGxK/+V39S/XYu0nWviwzByZru7aKoUHUVpZTExljUFQHw7D53/z22u6+2OVrw2ZaUowB0DcZAtCg+ccJjwf7FL7xPbROLoNDv/Yp/qLb5p/tfzJZ/7sYjapuRFHA0ak7uHfCAYEvOQSmoQ1uS1PoVLEQyhgWoikELKKuWDL43MuAUUTFIganS3hMLZgXxS4uDcq20QA7YUtKhT5wUaIhs13HL7fixJnf0uyCtV1JSQxUzBuy6gVLx3AhM96JwuYzXcrva9R8ZFpjcsmAJyMzGQK7q9YnxwA61XMBISI5Yyu0ybktZ/1YMXJHbuQu63/LyGzvSbZaCoFYh6746nIBh4bMsaErWg+8z3ljWxIqdX/Sbmxvc+mUpuv+HX/sXO1o74D5iIFlvZFCylRUREysFgNkoxedeaKxQuxdKPzy14oxHGZZE9uHB3UNGLoKw3USU05FE6x0Xb2FpjPiUbF1ZO2Zq8CGW6vK0iQ+4Nd/Ar7j0aXaMn7z9LrbNT3z6XfCE3HzZ+0ptrA8//3DT7lGO7/rAj7Hj/MNbX84U6j99cBUAcLxoptaX1s5qgT4AuH2wgd2txp14cFS6KAtZqqZqj6uCl6nbx6XcRFTXgCMd8e4nHA7eg04EF1twM9YxLdSwJAQdgwWMEhuXOUVsFMkK7ZWVWAjRsoQgfcQHoXo9OXy2myEm1pB6pk8HLwfVu0gyFIKkw/2gJCuQVulqlSRLiq/Obpb7nTzaXNjoOGLljeZXynXjw6a96ZbXbt1IDLYOdtwUDWY3CNZsY4GzPeIar+4TE7+cFohIXb2gdRQG5FD8XBaTViQrNTLqwIlWvJ+guExuyEEoqln+J8lVeE45KQGVnEbsvVXkSsRXAeU3sv8+vl1y6moLItCQpIhYqorTERy9N5GHl4r5hastV/S8lMxGKdc/C22mcV7FpFi5/BYldJceOMTtG03crEsKxCTe7qFLBwCA63eahIP0eIwLD/BQjLP5hIU/DOTqNUcryRoC398A+Ilf+T+xZauMwpMP38KTD3Mr0pqIo6JV2a/vbyOOilo9PhA3mcG3WCRYLES9vyhTsVRbomzDYTrFYVqOdBcnpbbWrfkGbs2bOLOfvP0u/OTtd7H96Ppf/a5Pw61ldT23D32idDF+4JEX8IFHGvHVb/3wb8G3fvi3sOOcZpNaSuJdO2Xpok2RJLA9aVSRL+2cYP9orf63UxGuKPKmpSAgWDHqAWuFYPGdT5X/wuY08FvGMFHI8BVZ7xAwAsaJxEBnXJNAYdTtC8ep/7esNeLy860M+RZ/V9R+IqjXJ9pKBwCpKJNiWQWLSfmv3sYInA4EK2B0HGF0LGQ8rmgSlG4Jd1CE3rqWFiTBmm0sMNsQFhnDiiILfkvFborpA5We3XYKbKdN4HwaqexGC3EV0B7dqkjKgbYGBVCdsXy9QHIa1f/Ce+0T30uwdj/hsPsJflHJqUNySkjmuFAEqzgdmQSLN1IEpJN3LhAsS49NEqxiUphSEwzk2KGtlx44ZATLJYWyFAaCFZAej5sC4BXO5hMVazoQrNc3BkvWGxRf+xPfzJal/s3TNy5imygD790sP+6ti42YaF5EuLrF3YZ5ETECd+O4JD3zedPJ5mmML3mMK8xL61aI+7o0ayxTv+bSJ/HjN7k7T+JLd57HLxw0Lr4//+g/AQD8tp/6r9l2H3ziObb8qZtXmUt0VJHJ9195qf5tEmX43NEltt9ZOsLutDHDB2XkJck0tMayfL/p6HzkWQkaQFt+gnVmi9S4PnyHTmWXBCRaOsha20WsiyhrCxVUsHUxKTQJVMrxXmdiZU7FM0m3TZQ51kuEODFapDo+StT5lBK7g77ehBfYlWWHnAeLXQNK16kcMNeu8+X5JX7c4G6lwqNRqgnf6DDC8iIpwRR7/ZJYQdSLqIm/AuCzCGs73AV0djhjGX8AtOsxKRALd1cU50jEoD0/4wO0P0kYKbQsWYB2M0dLxwqUS9eflAQJ7wp7J73tEtz9ZLPj/heV29MahOmm17X+ZLOr+xORLOnidKRcgDLwfbSXMBd7TQh7ahy6wnFpiGBNpcday3DpMu9b7+xtsG/EV2T3sUebeNnnb+yiOOcv3HSXT2CH0jevSwzuwjcjKNF68fYOAOCxK6UswdM3Gq2UQLYk0aLuwkC2LBeiJFo5KccRyNYa0bQK9Qkl0fo1lz5ZbxPIVkZ63qRiJl+68zwA1GQrEC2gIVvvf6yM60rIiPypm6VbMJCtEcm8CWQrBMZTsnVWxbkFskVLUASyJb8gSbIANESLBuJWM+A2kgU0RIsSpzzUKKwGvHCZRDi/3p7y29paEBpcNDPwZiOjP6jITz1zD9tQraKqDZRAhsdXZw1Wp6fB+IFo1a5DKXhEfqJNq685tKkiRJRkhf0CyWL1ClPeprWXmv3ml/gx6X6BZIVnFkjW6JAExlckS7kJAUWw2GBfkSyfNb8FolWrcAeSRe9T2JwQqUC0ouo7DSSLSjm4iljUtRBXIFkAee+q/y2SVTcvWIRo7ctAsIzEhoBAsAK5AhqCVScXGLIMNZmhCRUVwSpOy4+pvudkm3Cs0V7zwYTnLgkWI9/VfmxCEJTrBcHyROolkKw7eyRLPNwPQbBoFZBAsi49WLoIT86bvmYgWK9bDCTrzYyv/YlvrklWwGNX9hTRCiQrYOviqQr6vrp1rIhWIFkB8/mIES0A+KVPPq3adbCc1UQLKMkWJVoA8I9vfIna7yt2n2XLv3DwCCNaQEm2AtEK+OxtbqUqiogRLaAkWxNhBvrYHV5gend6rmp9LZeJSbRkfE58EqtBltYuBEqiFQhW3daRtk6tJFOVGSTL2E/VTGyxaFGXjvNOpfu73I7PYtIM3pKWaCF23rUtAiiJlnShJqeRcgFma14H/ovyKGsvuZpcyfazY617FhfmE06wgJJkmW7PNgtWwFbKCFa9n8Qy0iRLWKpGMx3Jnx5yV5Kb8WLT4VhdBAtoBEEpsvUC8Zm49067qPOpVyOGvMe7n3SMXAElwaJxV2VDhFVp5JVlL5pmNbmqm2W8b8mJVu9n8WIjbwa7q4zRwrDAjrwiWIxcAaU1T7hqH3v0tiJYgVwFnJxPBnL1+sdAst4qePuPfEf9t6cp4dX/SZWRsjhuOuMLV47K3yqLzqUNXp8Q4DIGB+dlrFVIFz46ambO65ulaTtYjj69d6VZNy6DiP6LR35WHf9iXFq7/s71/wQA8NVVAeiURHK/fXqj/vvd4/L4/9lP/wEAwBc/er1e95HPPAoAWLtQWvDObpfBxJtXG9fl8a2mA/xVX1wGSH1i75q61jSrYtWqpIGsGiA9IaKs7lnVSUckIy4cLkg4BEISArint4mF5TIhObUlp/x/FWsWGxDoZy8sTPWMnbimanmAQAoIaZGZaEBj6akHJnq+ig+EzDyTZMG2YEnUUhfVMUdksAwEjLr4Rkfl+mBNCftTC5hlWQlldxhpqBoWnt3icnWPjHtbbsgtiUrNHU0QeijNZGX+AWgKRYdjUgtpdU1JFeie3Sq/QWb5oc9WurxEUD11dY33ynYpEdl63/BH9X91Slq2qI5hGgfLaLM/Tc5ohHyFRdOI96tj0lqy/mriGP6rSCItHi4zU5lVNnxDYXNqBQsuyerbKKjrMdzzeXNhbr18Lj6U3yLH2rlc9kOh36SZy5ceagjWh77+O/VFDni9YiBZb0U8+cP8I5VECyjJViBZ9W/pSBEtKcopiRZQdhqBZAW8/8pLjGgBwO9/8qfN9gaiBZRkKxCtgNTHjGgBwLf97G9ky4FsBaIFlGQrEK2AzasnjGgBwNWH9tlyuOZAtICSbGXCEuGLCNnhmM2CA8mS5GF8xPfNx56RLKAkWnSglySrOTFfLBJj1u2M7cZeyw7IuBdAC2i2EK2VBBsNAckVyiOag+34KDITBGQ78qlX+8dzpwiWVdNQksLkzDUEq94I+loNOQdJtPxarmtfWkQrdVr2YcSfkyRZQEm0pP6VdR+lMGh4JwLJAghJks1zYHFJNUGVYrMqvsloSyEKQ1sJFcaxAMMi58B0qQLB6iJXQJVsYcR6MY03i2BV7WfHXs8ackWOFcgVYBMsAHj29/9pDHhDYiBZb1VIogUAsaGvEsTtAi6tnanyNZJoAXbB5Vxs94GrL+JTd66x377q6rN4/8bz7DdKsgI+PX9A/fbYhCvYf+LsIfzIx7+Mt1UU4S5/1D9h5NnM+D1vfxF755yQnS7GKrHg9Fwrv2e3udq+jz2icz6QSZIFAKMj9RMWFzQ5UGTA+CqtDEIfi3iZdX0jXO5UYLCp+l4Abs4HEBmInm3nSA4EiTBIlhVU7nLu/hwdO6VLFaxKfEc+wLtcq777BIiNfeV9dQXUtedCQ8okWIAmWbHnwqN0/9CuaW7neRvHlyTL0q2ysArJipZOaZKZhEf8lO4USv09Xy+Yu9FlDvma/d71trVwSmvKcnf2uUDr7WQznNahU8H2gC3LIb+RSdFYICvsXOMB8IBdN3IgWG9oDCRrQIknf/g7kYu4gPEsRZ7xgWBr8wyX1prsxEC4zoQY6jTJcOOAdxhPXL7Dlq8flbFgH7jaxFAF0vVVV5v4q/dvPI+bKY8be8/0Ov71EZd5uDY+wo8+y2O5/uQ7fwKfOGsETQPpetfDjeXrU089hOkOt7TN96Z6YMwd3vN2Hu+1d76GU6KzFUjXwR1uDRutLZHdnvEZcEW0pJVpshcjXee/ybgsl2sSE0gB18QCcsl3ndeCoHk7yQqoyRZ9T2KvSKqbx7oYde6QbXNCkhzErSSLwifaYiLj2ZY7RUOyZPyWIAjpVqFIXFyr7nO3qlWDTrrL/KjQXakHjxEKt4yWTGohWUyvqdpXSg/43LFz1mn/Brn64Ac+x5Z//iNP8mNFvtZ3q49XNYESonjh4GOvhT/Da0FIb3waqfdJFncGSsX3yS1+H5YXCm49CtdOFdMnhRYKjbyKF/POEK2dGOQZYPczkCtl2RJEz1uZuWETSgBTh2iNf8RbW+c43Be6ZYtoIFVvLgwkawDH4z/0XWzZnyZIdrTw0tuu3la/0dI6QCncKQeHPI/w9mtct+vKTM/othKt2Hxtcqh+u7nkRO7mYhOf3eOB7l9+9XlcHHE354cPHoaFp2/zSvWPXdzDp5/hVrP3PHEdEs+Luo8AcLKvaytCDAxuPVNaQ5GhMm2UcmQ6QQHLnULVASzEWG5KCwAopv0WBbM8jIcO6j/WBCLfMBS/je0sBXbZ3tGRUzIXZv1Ap8no8oLlAjVOaRkoLIV9ad2IdYA3IqjAbItkKashUJI9ObhLS4nzqpAzoAkWoEkWABXPJEksYBBOANnmanL9Ut4hXmgX4uLiitL/RiZEIIAUZmUD4x2xnrMkkj4yNvTakma516ORfqb+aAys84/6md/5LbohA97oGEjWgG48/kPfBS+KzSY7S2SiIPI733EdLx5us9/WJstaIT3ARR65KBXx9mu38NRLPD7rq9/2Obx0xo/3rq2b+LfXn2C/fcMTH0YkXsOXl1u4uWjIVyBdX361cUMG0vUPPvVBtu87HriJv/+O/4P99hU/8/vx2MU99tunn3kA1x5oYrWCzAN1pd6ssi9P7pB7EC59EdVBsDUORiy+JEg/qFq5OdSXl5xp91mU6QLKLnWmvABTsg6p6dLNEhkky+oBIs9ch2bZmopwjfZJnE916yZ7giQKD2w+9RgdiW1GDcmShoV47lgAfLl9W/A22TlIcBBXYhAeVcHPKwiwIvbqYVrEqCZa1FIVe5WB1nY8SdS+7F3P4Oc/LIhVODbdvXCvCrmilkOXO8RivuQyp4huW/WAtgA9ap2yrGvx3CkraWFk2JYVEsQ9zHR8nkXs/KRQmZ2QdRUBROO8qZkYsJ4NpOqtgYFkDVgNj/2t/1H/KDqiSw8f4HzJzQvnZ2NWVDnAiuOyIpyfuKYtZrdPuIn9YG8dv//LeND8s/MLOEy5ZQ0Atkfn6rd/+dS71G+/8Mv/lvrtt37mG9Rvh6JG4+70XMWsAcDnn7mifnNi1ruxdY7jl0RMRuKR7MvAEO0+k/IC9aaG5cWy2sgByc9ynQG3ncILQUQ3zXUwL2AWGLbaJ4VBx4dOe19io32xV4RApfmjDHDOZGxVrmPUoqUelK1akemuUVfQsF64caFJUeoAQYCipFAlXsxgdysOzqohuIjV724Ra5duri0/AFQM1aoEKz6NFAG3YuRqkkphJkQYbTMyMi1ZkOTEMXV/wCbVplV2hRqiAIDIa6tjbiQkzPW38cwf/Gb124A3LQaSNeDuwMiW0eddevgAABjZOq8UpinZSkkAejwpO6sgmAoAzxItrws7ZeD79rQZ9dI8xuF5Q3AO9kriRcnWs/MLAMDI1q+7+HEAwM8cNTP796w36u9//SO/ov57d7u0dv3LL/mh+rff+fn/FABwlpF6h9Nyu88dNm22LFvX90vL3JxoFlGitbFV7lMTLdJhM6JV/UyJlhTKBJoSOKy22mZpPYsOm+Otv610w54821gOwwDCiNZ2JZhJiJYj8UOMbMWeZcpZgqVSqBRo6gEynaKY/1/+TSx+FdmiJIum51OSZamOB7cSPX5wndI6fHXMEe02PZjLiD5PRrICmSQDc1SRIVVHD5xohXgrWiQ6BLqzbnpRrScky4XfqBJ5zq1AFJRk0WfVRqwATlbCs6AGqPq5UMtcFs7f/MasR9UBZi81Gyx3aaph+R8lWEGwlBIsab0K19QmQ1GTLHpfDOsmI1hhPdWSCxm35JoGcvWWxECyBrwyPPZ9loXLK+G82y/ssKKtAOD3x40GU4XpxhIP7vJ9n37hMi5d5ql2t25u4bGHeCA9ADz74kX126953yfVb790S8eqvLC8gA1hvvi+T/0ybIgMy1s3t/ClT/LyPfuLNTy0ztv9H59/FE9e4Za4p16+jNiwQEhxVABKSgIAkj1tmspnRvBtouOCXOZqklUjjbApspyOb22YX7abGBYWw/ro51p4NTrRM3qAkyGgdBWq0jxLIBPhbeMjKAFRq2bh4mKO5FhbZ1RsVVTdR3Yh6OgiyWbjAs6oW+ctaYtNbc4rzhJl+YsvLlQiil/GKovQn8VqshNtpPCHmriZhZ9bZBEsWJmCshh0tqnfOx9pK6YrnBmAPr3Jj7e4ZBRchl2fU7qEgaqos7AumQTLMqzHXp07urBELly8LotM6/Azf3ggVQMGkjXgVQQjXNUgS8nW7Rd2ylWEbPn9cjCgZGu6UfaglGw9/cLl8niEbN2qlOop2UorMdDrL+3Wv73z0SaT8PHNcttfvdMQrzMy9X1heaH+OxCu7/vUL2t+I4QrnJ8Srv1FyQYo4fqPz5faXJRwPfVyeT2UcFGitViUlsDlEZmWVzPm5LAZvGtiQMlOomf8ljULQJ0pSIlWTe5EvE5AKLgbkfMUhBD44CIhRKuNZAGcaIV4LEq0woBKidaYcO66FA5p44LUEKQkq7Zk0HGyWs1IVmh6D8mq49coySJmnDqekdyriBQsDnpIlGTFF8t3jJIs04pFSRy9X9X3xYhWMMJ1WLHaQMlVyBik5CoLlir62oWySoRc0ecTCBa1llGCtbhU3Vfy3jKiRs6VbejzBzc0JVh3Q67UuS+ULyElWC7o4pFrGIjVAIGBZA149fHY9/2PypJx6cHDmmQF1IPBfjMYBLIViFbAg7uHNdGqj3n5qCY69bkfulMTrYDrL+0yogXYZAsoCRclWkBJtijRAkqyJc8NAI8/rGPIHlo/rIlWwJNXbtdEKyBOCoxGWU2wKJb7U/WbM7Kn4HVcCLzO5KqJFhnIA9FiFrRwKCmsOMsYyQJKouVlDErkOwkWRbx0KujdR9pqka1xkhWwuMDJVUByHKnYoiKBsgCVFkGjYS3dpIzFcpNCBWr700Q9j0CyqOBkIFmBYAENyaIECyhJlrKSRVCWYoB/W/cCS4phdBA1xIqey7hPUaotjPnEq+cxvRnVxCrAZc7ONPWEWJHfZHyfT/zKxArgpLOuLXqBv3z5SdKQq4BiIFcDWjGQrAH3H499//fUf1OXkwyiBhqXxuTamVoHAItTPWjsXGjESvcrfarN3Wb/zWkzcL175yYA4IXTnfq3b3jw55tjxY3Uw62sJFH7WRNo//+89J7679vHze9/6n3/AgDwHf/+N9S/fc27P1v//fxJaVmbkYLZn7tZZj0+eqnJUnz2ZkPwgvzFdNLsc0TFCisrGFVcr4vlUlcMyWJ0lVxEfLVJAKB17Zr9iYVts7l/6UFF9sh4GFexWsUdQpbp4FZZXmgcmGVRmd5uBi8qWTG7Wa6fX6CWEHL46pEdvaN5t2gsTygSDTTB2Msdbe0DGmsWJaU049MUo6RWvkoLiRGjYE0k0hxWmRuLYLFjUQJHLF91KZzdhhDUcV530UNTyQOLnNTnMaoO0N+phEhbFmeQH7FK7gCkCDfhM3TbyR0SKxeKRpNtqRxJXOnRUdHT0X6z8fKSzuaMK7duTjKrqZbYEF81YEUMJGvAFxaPff/3qNieNrJ1r0QLKMkWJVoBm9NFTbQCXjjdYUQrIDWUMvezdUa0Ar7p0Z9Rv/3rg3eq354/2WVEqz6XFLMC8NztXUawAo5e3tQZZGexGbviL+j93cGIkayA7I62liWX9HbpwdTWlbLOLxXRK8R72lo32Tdib7KGZFGcPqC3PX8wZ+SqC8sdHTsE2KSgaLkGO+PPzp5Twplt2DKsUctYSxkAqgQPUBItFUjf0UtbWlJtBEuV0IFtvWobVixdN6l1BlSK/0aJI0qsAtJNLd9QTIuaWNX7rxWMWAUsL+WqvfFmysgVUBKsgVgNuAcMJGvAa49aAPWk6XFZvEhFKKbbzUyfxkbdud1Yd+JxORJsbjTk4O0XGhfeL94upRQmpITQ+y814qIPTJtYqkcnpUvxx29+cf3b111u3IubUXOO73/2awAAf+jxn6x/OyWxXh86ebz++6TKTPzFvav1b5fWGgvap4j46dsfLQlh0NwCgOPDqugvmVlHVCX8ZnPe2qJEYt48sSKN1ppB/Z0PlOf65MeJa5MM+qEeXm3NAjjZou6WQCpoliDJmBvdLJ81K5Vz0h1/s/5Sc/zFDs0eDCdtdpndaLY9v9qsOH+gbAMVx1y73qw/eay5oGK7umeUPFISVl0js3pNbQtgqCHIrE2Gm5yK93rqlrK8XgbJKleQP43YpECseFyaXk/RVqibWh/nl3X2ZUKeKc3otIqHO5qTERL2CDGjFklKziwxURpUTzXVgoQEywglbsbw+7O/b1BdH/CqYCBZA14/ePxvfq/5uzey2i5dM4JyACV+CgBf+ujzxpbA0wc6E/HXPvwpc9uPHz6ofvu6y59kRCtgbEz5T4sJI1oBP3fzEfN8VrzX1u5ZTbAopBp4gCkNYCmKA3jfky+q3z758Udty8qZtjyigCnIaell+bW8JlkUUpk9wMokS/Rtx+jYvg97H9Bmt82nbIJy9H4rbc3ZBZ4txfZpwchVgCxPBdjZtQDatZrugmiZVsXEm8e2qgkAqxGrgPkVfY+TEy2GC9hZoABMS1nbCGPpv1lq7q2w6g1iiK0a8KpjIFkDXp9ghCskD8mabhUk4TpfjrCY80E8q6xkX/Hez7PfP/R0abW5sMvL7hQe+PWPcML1b268vdx2yt2Q/+gd/wwA8INHvJzP33z6a/HH3vYv2W9/+/nS4vWube6y/OT+NVX/8fbny/gsORAza0c1YEUytT8MZEf8mH49UwNtdFyOWO/5wLO8Tc88aA9GRyOVFr/zQPkMrAK3kmgFRXAZqBy0mGQtu+RUu5VCHM7sJrHKCZJ1VrkU51eFAOjSYf053qaj91T3eKTdsIB2e7q4UPc2uVTJfwjTymya4uREu2J97nR5nKBrJQs+p5FyEY/WSwKc3ebHrq1ERrZfs43ZVBRGncgwTExv8YNYxCroZEm362Sv3JfFwqGFWNWNFm0b6yxSAPCRV+9HCKxXyu0B5L0eiNWA+4iBZA144+Dxv9Fi6TLI1/oFw9QB4PS2tnRtXjnB6bEeBIsswoVLuq7i8ckM1y7YlrR/88U/pn77pR/RSvGjqMAo1u0+S0eYGL8/9+mr6jfTCgLbsuUiz2QWAiKjoPDWEweqcC0ARLfGKKSWFAA/KrBzTd+nNI9xekvfb6teIdCIp1JsPhWb9QIXF/S2lsI4ACwNlfZi5HlwfgVLSwqAadEbz1IUub6n2SLB5o6OBzy6va50roAqA3HFkC23dEguayn6/Ia2cAJYSd0fQCke26KjZVmerPI78cKZVkd4W+m9GOuCzgBMRf4uWNfTRq6e+W/+1MrHHTDgVcBAsga8MbEK4QolLdYe5EHxpzcqAiHIyOaVcjtKuAoSF0MJ1/FJM6itQri+8hd+W3nKiMTs0L8JsaIWLUq4nn2usZRRNxElW45+0mS2Tq1fjGyRATRYtLaeOKh/o2QrulW6HyXR8hVxoEQrzZv2UaJFM7Qi4h6kgzYtXUPdepRspcRgFqwmlGRROQCWDccyBe3ui5INFkNFYtnGs4Z0UaKVLcpGSpJ1dLu8j5RksZqg4RDUWkXePSrXQUlWdqt5VxkZopJf1KpEt6ExdDQuif5uHJPWDaR/M4JFTkkJFg2qpwTLUuIHGrJklfcp20oWaPwf+XsgVgNeQwwka8AbH12Ey6odtvbgSUO0KGJfEy2K431tjQGA0VRbkroIVyBa7JRRwchWfew4V+5DoCRdlGw1B/KcYAVEnhGsgCKN7Pic44SRrIDD/fWaZFHkW7Y1bf2ytuSc3lpjJKs+59wuTJzuFmbsVJFwklUfJ4XSWgLKAdysXddBsii5qrfPHSNXAcszW4vKG3FRblSogusASpJl1SLMIlMPLbk8ZwSrPn5h1yRE4eyYOVkwnBzHsoLFC8eIVd38JczRwHoegG0Jy6c6U7Bsi3mIkmC1SMUNxGrA6wQDyRrw5kVNvmQnXXXkXpIPJ/6vUIt0tpAtANi92JCzk9Ny8Lu4wwlbIFMnCz4oJ1VNx1tCrPWRx8usyJf3OaO4WNVUvHmbB8cXVTyPI/FSNOYnqjIvldswbGPIDOw8dITD57bZbxGpZ5hfJKSjxdUWCJflqnXLCMmJPq+rDluQW7X2EskSvEYsItWgn27bozF9zhaxmhiu5XSZYDzRBNLqFhnJoueisWjynnuuFVb/HGpGLgS5DNY4ehh6uW1deQjPEu96CIyfivi3heFaBYDxUXniVNQwnFRB8Mx92xJUDjTkKhdFu9uC7GuFfhlzVe3+9B8dyNSA1zUGkjXgrYHH/5pt7UJkkC2UA6C3hBSt+n0oFepnE2392L+1iWsP7pv7LFLDogFg/yUjs/DqCc7nhqgQgDxtiXFq+d3MeQeAtkw1gwwA7RpYWEb2OVq6m/goZgKW9fEjtPYwZtp+SxwPFaaUB5ns6vimKPLwLaO+1S3OJikOD20CblqtYGf/lSe3f27taduy79pK5kTA7EXdpjZy1faqjA8iLI04q3gO5GurDwvx3LEC3s2Jh7iqAW8KDCRrwFsTjHRROSIax0RVySnhoqrfZBSSpYAo6dq/VVqjKOHaGovC06eNC9OR4+5dbyxJW1cb6xglXdmdJkbMbTXnVUSLaT4110ED4At6feS6HbFg0XqA6TXhQqMWHHIdtByJJ+eOj5o2UrLFBllpdKT8LtQeJCSLZj/KTEjaJkqyImqFIiSLPouCWAZnRChWkSyynSfk1RH1fZB7Tt8vRmq7rFXeXscmDeQeUnI1b4lZkxMLGjc1ruoVUnIl6qlzgkXd0RHdh2qcke3ZNTR/D6RqwBsYA8kaMIDCiu8KMTFyAGojXkkVq5WM2vPT57TwM4B3Pv5y67b785JA5SKGaqsqF7R3ygd4WnpHWqG8zG6j7sQ5Nx34naq2pHB1RVV2oNS1oi4gGRwfMgqLNf47DX6nvQkNYs9F6FFNCkTvk21pa8y4kg5YXG0RgwIwu9i4CymhktasIICbCs2r0/PGXZgJa6Or4qyUVENFsJS1lHIOae1q7a4NIlk9Z3fCrVZBE0uqulNxVioKCwDpermtVUfQV5fLChaQeyjjt/JQ7cdQxn/6jw1kasCbDgPJGjCgC4//je+1CzGjHCBNl2JFuBIjML6NeAXS1Ua2AtGiCKRra8otYpR0HQndqtINSsiI1MyqiFYgWBQ+jWqCRRHIloyzAUqyZUk2BLIVWQKk3pZjCGSrTbQykKxArCj6SJYz/GKBZNHqAgFpFjNyFRBIljOC2H3hmPWq/j28Q9LgRkmWdZsoUZH6XhW5soRGi7FnpKo+REWuAqmiiNKGULFjhUdr3L944WpSZbV9IFUD3gIYSNaAAa8ET/yVvwTAsEjQ38SAm1RFhMdGXcKiaAa/q9tce2oSl/t99nmtmXXpcpnVOE34qBokI5590chIBOCN7EsKRyQxojtC2JR6gwQRLSr1bbNES0g8ENYMmkUWGyQrjOPymJlhaQlipXV7Qkkfo8Dz2paOywpYn5au18ggEXtVdYFQMqduJ8lMjES8X36HlDyS6vuVxdAqOUMRZEqk2ntIADBj6AKPk/ecylXYpwNgZGeG4xmvTyCHn/9Tf7LjiAMGvCUwkKwBA15NPP7XWwLsC1eqrVvIHdYu2cWw33f1Zdw8M/QKADx3XZcFChivLXFlW8tRAMALL11o3a+NdLnM1YM42776ySJT5Y4tPwddJCvoGbzmHUWwZo0P9frFxbYA9/K/Ytvwd6GdZIWsz9nY3u/m5+z773YqYmYEnxe5q7NA1X4tvwNoTwBInVLOZ7u1BcAXDlGLN9tl7c8FvkXMFIO7b8AAAwPJGjDgfoKRLlkOhJIuw/pAidf7rjZuREq6LC2t27ea7MTxGg/Gp8RrVbIlY4Mo2ZJJeJRsFaKWnCU+SUEHduYuJNxJxmcBDeFiJMvo2hjJInFmaxeb+xyIFQUlWXuiNia1YgVyFUBJViGeLyValFyNLnE5iZQeX5ApSq4s3alsw3YLU3LlDN7PCJY0YBGCNZCqAQN6MZCsAQNeD3j8f/5L9d8yjibfEIxEhNN8xXuaeowff/kBto7GE52c82B7gGfLpUud2u9JRiBCELWVcS8JQIv7EAAmd/gFZCQjbXRskQWasabPHYgXddkWE0tJk2TwGVIcm9sNwTk95WwuIsr76SkPNAr6Y/W5z/V9jGZVMgTZNr1pFPsmhNayUFEyJUksDT6PdRgZQ1fZms//yYE8DRjwKmEgWQMGvF7xtr/8l1rXeQcUm+3Zi7Ndu3YjUBIvi3AFFIUzCVd97v2WaGaUMT/JYbvba3TqOnuNroLBWY/+0vJSV7VhAOPCDEgHyrJDrqN+YL6Iu3u7oue6DKHXet3OEtFLhomugndode0BtjWq3je21e4DBkI1YMB9xUCyBgx4oyGQrzaVbEq+usgWYGfOUQJWGKV3KAGjhMtKy6eEa3TaHpANdBMs4C5JlhHgDjRZf1apofL35u/cipGiuxn3hl0PIVbSlQiAESvrWTK3XktGZf1nC68NBGsgUwMGvCYYSNaAAW921BmQ3YmEmD5UxmstF7ay/IWqTNA4bmdDt49KQdVFJY7aqmweznkz7rS0AI2LjLkNKSo+tXywiZ1yZy3B5RXZScbdjG55OkbUoXMGAMW8kkkIUh132q2DwZ3apqAeMiPbiHNzoPK/p/7MkLk3YMAbAAPJGjDgrQ4aD8aw2x7IHTBb45aw7ZmdqXf9s5ftc4hDBlVxCSl8mhlaTqkhRlo2imcHjoyahABQ5JFYbukf28iUOL1VKkgVO25p8lPfMpCoAQPeBBhI1oABA1bD43/vu3q3iZMC05l2jVk4fd6WppCYvdxjgqtw/u52vSuJuCU2S6J4uT1WimJ6K0K63d8dPvWnB/I0YMBbCAPJGjBgwIABAwYMuA9oJVntqUUrHmDAgAEDBgwYMGCARkcy84ABAwYMGDBgwIB7xUCyBgwYMGDAgAED7gMGkjVgwIABAwYMGHAfMJCsAQMGDBgwYMCA+4CBZA0YMGDAgAEDBtwHDCRrwIABAwYMGDDgPmAgWQMGDBgwYMCAAfcBA8kaMGDAgAEDBgy4DxhI1oABAwYMGDBgwH3AQLIGDBgwYMCAAQPuAwaSNWDAgAEDBgwYcB8wkKwBAwYMGDBgwID7gIFkDRgwYMCAAQMG3AcMJGvAgAEDBgwYMOA+YCBZAwYMGDBgwIAB9wEDyRowYMCAAQMGDLgPGEjWgAEDBgwYMGDAfcBAsgYMGDBgwIABA+4Dkte6AQPeGrjkrvklluWCc3Bhhf4DcPRva71YltuJVeZvnccAvHkcvZ11fG9u07YvAOfKfTq3EcdfcVu2/d20CR3XscJxetvYd+67OW/rOn+Xz0HsS343D+PCf16vEsdii+x43ti+OaZ8Tdnv9XpP1ovt6n3lfvq8/NhNm506vlfHYevIfaGX1XZ8eo6247PrtY7hgNCryG3Lv+m6pv/50EcX/8x7/+swYMB9wkCyBnxBsMQSXxV9HVzkABfV/yMKPbKDi6Ky16//d3CuMrZGrvyNrnfNvs36iG8r1nvnSvutWC9/r5fpelf9HbZDRQaqdWGfeluyvvy/vI76b2M9W0b1W2SsY/vr/8t1jv+m1qN7PfTvdP0qxzZ/7zpuNdia+8v1rA2+2QZkW7k+PDq2ffl3TSbC367Z1jlCHlyzvauW6fqoXvbVq+frY0fgv9H/m/XlMvtXkQ3r9/LvollPfovr5WZ9XC1Hzlfr6brwe4EI1f/VvmG/5v+i3gcA3wflucttwv5Ffb447F9dVxyOW6/z/Nj1cmh/9Vv1uGMHxHCIAMTOIYKrll213iFCVP7uyr8AIH7gs5cwYMB9xOAuHDBgwIABAwYMuA8YSNaAAQMGDBgwYMB9wECyBgwYMGDAgAED7gMGkjVgwIABAwYMGHAfMJCsAQMGDBgwYMCA+4CBZA0YMGDAgAEDBtwHDCRrwIABAwYMGDDgPmAgWQMGDBgwYMCAAfcBA8kaMGDAgAEDBgy4DxhI1oABAwYMGDBgwH2A817X3Row4NWGc+7jAOavdTsGDBgwgGDqvf+i17oRA968GGoXDvhCYe69//LXuhEDBgwYEOCc+7nXug0D3twY3IUDBgwYMGDAgAH3AQPJGjBgwIABAwYMuA8YSNaALxS+77VuwIABAwYIDP3SgPuKIfB9wIABAwYMGDDgPmCwZA0YMGDAgAEDBtwHDCRrwIABAwYMGDDgPmAgWW8RuBJ/1Tn3lHPuo865D7Zs94Rz7j845z7rnPsR59y4b3/n3K9zzn26Wvct5Pdvd8696Jz7cPXv68m6b622/7Rz7tdWv6055/4v59wvOuc+4Zz7i2T73+Wcu0WO9fuq338l+e3Dzrm5c+43V+t+tXPu56vff9o59/ZX+bYOGDDgFaCt7yDr76XfueCc++dVH/bPnXO74piPOudOnHPfTH4bO+e+zzn3mar/+Ybq93vpd5xz7jurY33KOfdHyXl+RbX9J5xz//pVvJUDXq/w3g//3gL/AHw9gH8KwAH4JQD+Q8t2fx/AN1Z//y0Af7BrfwAxgM8BeBuAMYCPAHhvte7bAXyzcY73VttNADxR7R8DWAPwK6ttxgB+CsCvr5Z/F4C/1nONFwDsAVirlj8D4D3V338IwP/6Wj+H4d/wb/hX/uvqO8g299LvfA+Ab6n+/hYA3y2O+aMA/gHtmwD8dwC+o/o7AnCp+vte+p3fDeAHAUTV8pXq/x0AnwTwKP19+Pfm/jdYst46+E0AftCX+PcAdpxzD9ANnHMOwK8C8A+rn/4ugN/cs/9XAnjKe/957/0SwA9X2/a15Ye99wvv/dMAngLwld77M+/9vwKA6lg/D+Dhu7jG3wrgn3rvz6plD2Cr+nsbwPW7ONaAAQPuL1bpO+6l3/lNKPsugPdhqKxNnwfwCXGe3wPguwDAe19472/fxXXIfucPAvgL3vuiOt7N6vf/AsD/4b1/Tvw+4E2MgWS9dfAQgOfJ8gvVbxQXARx47zNjm7b9+477Ryoz/w8Qs31vW5xzOwD+UwA/QX7+hupY/9A594hxjd8I4P9Lln8fgB93zr0A4L8C8BeNfQYMGPDaYJU+6V76nave+5cAoPr/CgA459YB/BmUVqsaVV8DAP99FV7wD5xzV8kmd9vvPAngtzvnfs4590+dc++ofn8ngF3n3E865z7knPudxrEGvMkwkKy3Dpzxm9Tv6NqmbV3XPn8TZYfzAQAvAfhLq7TFOZeg7LT+qvf+89XP/wTA49779wP4F2hmqmGfBwB8MYB/Rn7+EwC+3nv/MIC/A+B/Ms47YMCA1wavpE9aZV+J/w7AX/ben4jfE5QW83/rvf8ggJ8B8L3VunvpdyZoyoj9bQA/QM7zZQB+A4BfC+DPO+fe2dPmAW9wDCTrTQzn3B8OgZkoXWV0FvYwtPvsNkpzfGJs80LL/m2/w3t/w3ufV2bzv43SxN91rIDvA/BZ7/1fCT947+947xfV4t9G2VlR/GcAfsx7n1bXfhnAl3jv/0O1/kcAfDUGDBjwekFfP9C1Tde+N0IoRPV/cMt9FYDvcc49A+CPA/izzrk/AuAOgDMAP1Zt9w8AfBC4+36HtPlHq79/DMD7ye//t/f+tHJH/hsAX4IBb2oMJOtNDO/9X/fef8B7/wEA/wjA76wyX34JgMNgUifbewD/CmWMAQB8E4D/s/r7H7fs/x8BvMOVWYljlKbzfwzUHVzAbwHwcXKsb3TOTZxzTwB4B4Cfrfb5DpTxU3+ctk0c6zcC+JS43P8c3GS/D2CbzBS/zthnwIABrx1a+w6Cu+53qv+/qfq77sO891/jvX/ce/84gL8C4H/w3v+1qt/7JwB+RbXPr0YZoH4v/Q5Q9rW/qvr7a1Em4KBqx9c45xLn3BpK0jf0SW9yJP2bDHiT4MdRZuo8hXLW9rvDCufcjwP4fd776yhjFn64Iju/AOB/6drfe59Vs8F/hjLj5we89yGo9Huccx9AacZ/BsAfqPb5hHPu76PsyDIAf9h7nzvnHgbw5wD8IoCfL+Pw8de8998P4I86535jtf0eyqyf0P7HUc5q65Toql2/H8CPOucKlKTr99z77RswYMCriba+wzn3X1fr/xburd/5iwD+vnPu9wJ4DsBvW6E5fwbADznn/gqAW2j6x7vqd8j5/zfn3J8AcIIyNhTe+0855/5vAB8FUAD4fu/9xzHgTY2hrM6AAQMGDBgwYMB9wOAuHDBgwIABAwYMuA8YSNaAAQMGDBgwYMB9wECyBgwYMGDAgAED7gMGkjVgwIABAwYMGHAfMJCsAQMGDBgwYMCA+4CBZA0YMGDAgAEDBtwHDCRrwIABAwYMGDDgPuD/D2D+FollmnZgAAAAAElFTkSuQmCC\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" + } + ], + "source": [ + "cat = fits.open(f\"{dirname_out}/colore_srcs_s1_0.fits\")[1].data\n", + "nside = 32\n", + "npix = hp.nside2npix(nside)\n", + "ipix = hp.ang2pix(nside, cat['RA'], cat['DEC'], lonlat=True)\n", + "ncount = np.bincount(ipix, minlength=npix)\n", + "goodpix = ncount > 0\n", + "nmean = np.mean(ncount)\n", + "delta = ncount/nmean-1\n", + "dzrsd = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", + "vtheta = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", + "vphi = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", + "dzrsd[goodpix] = dzrsd[goodpix] / ncount[goodpix]\n", + "e1 = np.bincount(ipix, minlength=npix, weights=cat['E1'])\n", + "e1[goodpix] = e1[goodpix] / ncount[goodpix]\n", + "e2 = np.bincount(ipix, minlength=npix, weights=cat['E2'])\n", + "e2[goodpix] = e2[goodpix] / ncount[goodpix]\n", + "hp.mollview(delta, title=r'$\\delta$')\n", + "hp.mollview(dzrsd, title=r'$\\Delta z_{\\rm RSD}$')\n", + "hp.mollview(vtheta, title=r'$vtheta$')\n", + "hp.mollview(vphi, title=r'$vphi$')\n", + "hp.mollview(e1, title='$e_1$')\n", + "hp.mollview(e2, title='$e_2$')" + ] + }, + { + "cell_type": "markdown", + "id": "6322ae20", + "metadata": {}, + "source": [ + "## 3.3 Density/velocity skewers\n", + "The source catalogs are also endowed with \"skewers\" containing the density and radial velocity along galaxy lines of sight." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "66d7a6c3", + "metadata": {}, + "outputs": [], + "source": [ + "d_skw = fits.open('output/colore_srcs_s1_0.fits')[2].data\n", + "v_skw = fits.open('output/colore_srcs_s1_0.fits')[3].data\n", + "bkg = fits.open('output/colore_srcs_s1_0.fits')[4].data\n", + "r = bkg['R']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3e0b0bd4", + "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" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(r, d_skw[0])\n", + "plt.plot(r, d_skw[31])\n", + "plt.plot(r, 0*r, 'k--', lw=1)\n", + "plt.xlim([0, r[-1]])\n", + "plt.xlabel(r'$\\chi\\,\\,[{\\rm Mpc}/h]$', fontsize=14)\n", + "plt.ylabel(r'$\\delta$', fontsize=14)\n", + "\n", + "plt.figure()\n", + "plt.plot(r, v_skw[0])\n", + "plt.plot(r, v_skw[31])\n", + "plt.plot(r, 0*r, 'k--', lw=1)\n", + "plt.xlim([0, r[-1]])\n", + "plt.xlabel(r'$\\chi\\,\\,[{\\rm Mpc}/h]$', fontsize=14)\n", + "plt.ylabel(r'$v_r/c$', fontsize=14);" + ] + }, + { + "cell_type": "markdown", + "id": "4c9710fe", + "metadata": {}, + "source": [ + "## 3.4 Intensity maps\n", + "Intensity maps are stored as HEALPix maps." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "89d171c3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:368: UserWarning: If you are not specifying the input dtype and using the default np.float64 dtype of read_map(), please consider that it will change in a future version to None as to keep the same dtype of the input file: please explicitly set the dtype if it is important to you.\n", + " warnings.warn(\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:391: UserWarning: NSIDE = 64\n", + " warnings.warn(\"NSIDE = {0:d}\".format(nside))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:400: UserWarning: ORDERING = RING in fits file\n", + " warnings.warn(\"ORDERING = {0:s} in fits file\".format(ordering))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:426: UserWarning: No INDXSCHM keyword in header file : assume IMPLICIT\n", + " warnings.warn(\"No INDXSCHM keyword in header file : \" \"assume {}\".format(schm))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:428: UserWarning: INDXSCHM = IMPLICIT\n", + " warnings.warn(\"INDXSCHM = {0:s}\".format(schm))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:920: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_over(newcm(1.0))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:921: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_under(bgcolor)\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:922: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_bad(badcolor)\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:202: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n", + " aximg = self.imshow(\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" + }, + { + "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" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(5):\n", + " nu = 0.5*(nu_arr[i] + nu_arr[i+1])\n", + " m = hp.read_map(f'{dirname_out}/colore_imap_s1_nu00{i}.fits')\n", + " hp.mollview(m, title='$\\\\Delta T\\\\,\\\\,(\\\\nu = %.1lf\\\\,\\\\,{\\\\rm MHz})$' % nu)" + ] + }, + { + "cell_type": "markdown", + "id": "00068d28", + "metadata": {}, + "source": [ + "## 3.5 Convergence and ISW maps\n", + "Again, stored as HEALPix maps" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "bd879861", + "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" + } + ], + "source": [ + "m_k = hp.read_map('output/colore_kappa_z000.fits')\n", + "m_i = hp.read_map('output/colore_isw_z000.fits')\n", + "hp.mollview(m_k, title=r'$\\kappa$')\n", + "hp.mollview(m_i, title=r'$\\Delta T_{\\rm ISW}/T$')" + ] + }, + { + "cell_type": "markdown", + "id": "68f03984", + "metadata": {}, + "source": [ + "## 3.6 Cartesian density grids\n", + "CoLoRe can also optionally output the matter overdensity boxes used to generate the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e5174ac1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ngrid = 256\n", + "Lbox = 874.993 Mpc/h\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAGQCAYAAADGCZVmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9Wext257fB31+Y4zZrbX+3W7OPud2dauzjR1FDjhRgAfSWOC84AdE8INRiBwsQaTQRCI2D0SAIoEUgngAoRJ5SASkISRKQEQOODJRguMQJ26Iy459q27de0+79/43q53NaHj4jTnm2teVStW9u25zav2krXP22mvNNdecY45f9/1+f5JS4mIXu9jFLnaxn3YzP+4TuNjFLnaxi13sfdjFoV3sYhe72MW+FHZxaBe72MUudrEvhV0c2sUudrGLXexLYReHdrGLXexiF/tSmPtxn8DFLnaxi13sJ8P+K3/3Or29D+/lWH/+Lw1/KqX0h97LwX6TdnFoF7vYxS52MQDe3gf+vT/1jfdyLPvRX3/xXg70W7CLQ7vYxS52sYsBkIBI/JF8l4i0wL8FNKgv+pdSSv/4D3PMi0O72MUudrGL/ThsAP6elNJeRCrg3xaRfz2l9O/+oAe8OLSLXexiF7tYtkRIP5oMLalM1T7/tcp/fijpqotDu9jFLnaxiwFzyfG9ySG+EJF//+zvv5RS+qXzN4iIBf488AvA/zal9Od+mC+8OLSLXexiF7vYb4e9SSn9gd/oDSmlAPx+EbkF/hUR+VtSSv+/H/QLLw7tYhe72MUuVuxHBQo5t5TSo4j8GeAPAReHdrGLXexiF/vhLJEIP6IJLCLyEpiyM+uAPwj8L3+YY14c2sUudrGLXezHYR8B/0zuoxngX0wp/d9/mANeHNrFLnaxi12s2HsEhfyGllL6S8Df9j6PeXFoF7vYxS52MUBRjuFH5NB+O+wiTnyxi13sYhf7UtglQ7vYxS52sYsV+1GVHH877OLQLnaxi13sYkAuOf6IUI6/HXYpOV7sYhe72MW+FHbJ0C52sYtd7GLFfvS06vdnlwztYhf7AU1E/nsi8pdFZC8iWxH5syLye3/c53Wxi/2glkiE9/Tnx2GXDO1iF/sBTET+28A/AfyPgL8M1MB/Fng/434vdrGL/Zbt4tAudrEfzP5u4DPgX0kpfZpf+9M/xvO52MV+eEsQfnoxIZeS48Uu9gPa/x74BvBdEfl3ROQfzhI+F7vYT63p+Jj38+fHYReHdrGL/RZNRBrgfwj8U8AfAP5vwP8K+Od+nOd1sYv9TrdLyfFiF/ut2z8FkFL6E/nvf0FEHPA/F5GvpJQ++fGd2sUu9sOYEJAf90n8wHZxaBe72G/BROTrwH8H+C993z/9B/m/z4BP8nv/DuB/BrwALPAI/E9TSn/mR3GuF7vYb9USEH+Ke2gXh3axi/3W7A8DE/Bnv+/1V2jr4GMAEfmDaJ/tv5FS+vP5tb8L+OaP6DwvdrHfcXZxaBe72G/NfgZ4SCn573v9DwH/n5TSQ+6x/dPAPzg7M4BLZnaxnwa7lBwvdrHfObYFXorIXUrpAUBE/nPAfw34b+X3/JeBx5TSv/njOcWLXewHMx0f89Pr0C4ox4td7Ldm/2r+7z8vIn+fiPx3gf8n8C+llP6P+d/+VuAvzh8QkX9IRP6CiHxPRN7rQMOLXexii10c2sUu9luwPGX3jwI/hzq3fxSF7P/Rs7edvu8z/wfgbweugV/+0ZzpxS72g1lM8l7+/DjsUnK82MV+i5ZS+uf4jTln/zrwJ0Xk96SU/mp+7Q8Cfz2l1P+2n+DFLvYD2k97yfHi0C52sfdsKaVfFpF/CPg/Z37aEfgUzeYudrGL/TbZxaFd7GK/DZZS+ldZ+m0Xu9hPhSWE8FPcibo4tItd7GIXu1ixH1f/633YxaFd7GIXu9jFgEsP7Sfe6psumRfPSD7fJAOuCtTGk/KNi0kwon+LCCHq6z5YUhA4i1jEg5kgmeUPoMJGCRDAqHaMsZGUhJQk/9usKSOLHLU505mJ+X35LQBiE5UL1CZgRD8UkuE0VcSYz23+zPln559rI7ULVBIISfBJBeFTghAN0Rv9XvL5RUFC/l2VHtBVgcromK/B65Ipn4tnPwuQCMbrucQq/6w6lfPBJCT/f0oCJIxJVHYZI5byPQjBLNc+Uv4/XwYk6PckC8klsPl8bcSYhA+GOJnl2pp8veXsWp397nLNTSKls//3egwZ9doIy31PRs8nGT2P8+sgXg9d3mvPltL83++XGUpn/xzzcc6ky6M7+575s+e/S5ZrIJKYvINJFjyz1YPJsqRJ3mDGs3Oc3ytJPyfp7D4I4vmb1mkygEs4F0qEX9aI6Pe6/N1GEn5ee+c2r3+b3n0ugiCTLNch3795nSW3nINEPUTKay/lNYwX/RlnP42Ur10+rpnvV76m5b7J931mvm75fr7zuuhaFLesIbzRZ8rqNSrvjZT94vx+lOP7s73HJlwV6OxEZ/VmpSQMyfHml+/fpJRe/s1H+J1nX36H9uqGn/0n/xj7XQvoImi6iZfXe75x9QDAddWz9zWfHm/YjzVN3lyHYHn7tGY61OV4ZudoPzdIBL9O+E5fj3XSzS4uD0JcRWTlcVUgeEPs8+WOgAGpA6bSpymOFnmoMIPgbwKyViGK1WagqSbaynPTKEAuRMPHTzecDjViQPIm5k8O6S2pikirv+Hubs/vfvaab67e8nZa8+3dcwC+2G84HBv84EhjPmEvNG8s9iSMd4n0NUWf//yrN3xj88DT1PIfff4hAP13r5BJiHUirQJ2pecbdhXtZw53hPFGz2u8C9BETBN4+WxH6/S9D8cOI4mm8lgTy28DeDp09PvlujMZZDKQQCZ9yOsnAxHG20h6NrG5PQLwfH3ESOL+sOLx9QYA+1AhAUKXSM2Zh6gjtvWEQ6UbP0CVkKMlrQLV1VDuf/1pRf0kRAd+o79tdgD+xmNWHpnvfRDkTU3zsGzasUpI0A0+5Q1bvGBHdf6xSphBz8FOGjiR1InpGtM1F2qot4I7LK/3zxPhKkCj9/367shVO/Bmu2Z4aJH8m9c3JzbtwOgtT7uVfv6+wW0NyeVzzJcnGYirgFl7JJ9vnAzsK2QUzCC4XvJ7E+NNovrwiM2Oqz/WJVhaXfdcdbp+j0PN9n6NHPQaA0gVSb2FIFCf3Z/J4LaW9s0SuMUKmodEtddzDE1+65UQGr0ecXZkCdxRaN8kXA/jZvZO82cg5GVW7/SaR8s7Dm0OVMVnJwpMGzh9GEl3E+lo6T7Vm5QE+q9NtHc9Y37e467CHvVgsUvFgdqTruewici1OilXB6yNTKPDb2tkyCdhElxPXN2c+PlnbwBored1v+Hf/Hv+17/GezMhJPOf/rafUPvSO7QQDae+Ig45rA1CPxo+GR3X2UG8aPZYqdiPNU+HjnWbF5cNGjlFKZFvvJnoU0W1yw9Pq6sz2QRWsHuDO+QMrxemKiJN3uiCvm56Q6qSpve9npcM+jkzCrExkDfMGIXDqeHYN5xGDTt9NJyONXG0mDpgXH54TSK5CC5hnJ7XFCz3w4rb+oSPFp8X6+gtMRr9fKNP6fTYlA3VbwJXqwGAh75jOza0zpfNKl57xEVc7TEmLZtYguG5EGqDHbPjubdMNwJNQCQV53XT9XRuYoyW01SVe+ZMpK0nQiek7OCCSaQomiXlbNuMZ1H0YNjdrwE47FtEIJwskq8vRrOMVEWoIsyZW28IfY09Gsy4ZIDuIPi14Pd2SRayc0mOJaoPMG0S1fWIqwI+Zx2uSgw3hkEcJjtKCZrxkcDm6+xOUG8ToRL8RnDHfA2OKW/Wgle/g1/rZ6uDUO2gfsprpAbfCWFDue/HY8Nu25EODolSMpVxdIR6wghafQBSHZleRGQ0mJMhJwD6nckSkyCdrhFbRdLtSDg6zOgwukSQpA5u9CvGq+yk6ki9GrlaDVy3PZ9vr/T+fLZGJkNqA/VGv6yqAr2tiZMhTQY5LelREgjVkqnaHrq3CTMl+jtDrHNG6MCvEn6VyjWvH4XmIbF6HbFjpMqOJVRCdPrHr/TaDLf6nEvOQmfnZQfKHPI5O54DGVNF4gr8Wv/BDAJRGAdHnPKbq0RsEm5ncMclFTM545+CYWr0vc1VT2UD41CpI83PdpIEwXA61Xzr/oWel4mM/v1u4ToP7afXof30nvnFLnaxi13sYmf2pc/QojdM9y0ml9XMKMQqEaLw+V4jxpXTKNFIYhodD0OVPyukk8P0Z2WjNmrkXL/bG5Kkdf5qu0TZsQKikBIYE+cgD9MLaRKCPaunJyE5SEGj9ylnlN5pk2qzGrjJJZtt32BdoGknnAt4r++N0ZCqSFUvmZSVxHGq+ZXdc3pfcRiXMp514Z3sarL1Oz2F41FrObv9BhJ0z08le423p/y7EjEKU45GUxRSF/AC6aDXLdmkGaw37E4tNme762rEmshpaHk6aO3WucDz9ZEXmwM3XV/O92G7Ij4J1ZMp0XeymrUklzCHpYEV25wl7a2W7dD7FZqEvR1xLjC+1rTH7bR/ZMaz7OiUMD7hD0KopfRozKglqdBQsjnj83l4g5iEH/XNYhLiInETiDkTkmnuEUEopTqDO4IJZ30q8ve0eQ2dZYjJQUyJ0Agx30o7QPMIsbalahoBuzfYQbR0mDOTcRKe8nUu62AzUdee032HOaswmEkPNF4l6k4vpAh6ryfRf597aKLZpvvEaKYDjK889a3nttPS9XGv66m+t5pFbTzrTlM8Hw0pknuBSXvS+UfLIFRHqPap3J/mfiK0Fr8Sxuv8m2u9RmaUkmWaKWd2AkmEap+fi0oYrs3yA4DYaNXEDvrqXOolUdZRaaHl7wmDBUmEZq6HgjkaojhMbhu03chp15JONdJL6TnP/WbbC36Ye9tCW3n6dqSP+jzpcQXjItZF3Fm/eRze/xZ+AYX8JFtC+xbnm0L2Tw9b3dROY0XtPCkJMQpxpw6terTYQQhnjssdrG5mApxEyxHoJhea9M7xkwWC4EeHdbGAFsIqktpIfTOU05wGx9Q43JPVjXOnt2YC7MrT1RM3tTq0zk18/fqJ582BQ6j53u4WgCfblp5UmhvzCXrveDy19KeaOJfwRoMIuGYRjZc6Mt5GzCTIZIj3ugGZSYhtZBydAlEA7y1x1Iew6iZs/m1+bupfTcTcQ0tJYDKkBH1fsc0lx9PkmILleGgJp1x6dYlpsjy/PrCpRrzLgYiJBJcwYQFvjDeRcB10c9laJJ9bOgN4lHKfh8kmTP5umUt+OwUb2GHZMKtjKp+xNYRc0nJ9wg75Xld50w/aYEm2ZdpEBaeAln4lX4tcBkwNkARxkZSvTX9rma61LBldorlfnMl4LQx3Wq4C7QsllzCDwXhZzuuUWH0eqXbC8aO8bq4S9qROJzkK6CM2huBt6bsCNM1EW08MXYVfGaptLp95BVd0dye+fveo1zxaPn+6ok8NyWi5tVgS6i00D3peobPs2w4BahdKPy10idhFmsqX8xiGSkt0CRhNKfGZwdC+FjbfCzRPYf4aJMF4bRivKSXDuV/2/RZa4fTMUB1TOUZ0Qqw0KCg9bzuvA94BNc3AnmSXkmN0GZTUGyRIKdUbD/RCqgz2JvczVz0icDhZ7MlhslZMMkvvdP69w+CIregz3GVgFDA+NsSTZTIwVbn8K+m9Q+xTuvTQfrLNANdT6aElYxVV1Btirxv2kYajhdQGmAzVU65nP2iNm6sFleh6MAPYIVEdwXh9mE7PDacP9WEtu2nUP8kbAgoCAbDriTpvIj7od4VgCC4SWn1ACqIrCcZEahu4rjXSfVYf+ah+4sYe+c7wnP2kv+M0ObrK40xkyo5rChYfDCEYYhKNgvNxU+JdiKK+fIZyyz+ji5j1RFUFQs42wrbG9IbYRkIdSPnAYhKmirTtRJ3BH6N3jKMt2dx+q9nYDAIwg8GcIdjGneOzwfH82b6gH9t2It5YBi8lOwqriNSB5A2xTUjetN1ewSISlo1ckZvCuG2QJmD9u4hJM1GCE4nZYYl+zo56jcwI7hQ1QOqW8zWj9k7SdcKsNZRPSUjeYFtfMq8wVwlsom70faEKTDbpdQ2CzxH36IVpA/46knKkTxIYtddnxuX+hCpnadvEeJ0DjpUCNWKtmcu876U6YWygqT0uO9pVMzJM2vMRILT6e6crmF6NfPVmxzc2CqCaEcHfGZ1m9PNlCALGIEmwWcmyfjL0bcXBJsbaI7kSEK4DUsW8yevaHbeN9pglYY+GaqfXqtrD6rNI93rCHfSa+U3FeOOY1lKQjXrf1IEbTwFr+bVmuqHVAGAORGKlr5EoGWkyCTsI7pSvlzlfO3ocv16el2QSZjTYXrD98swbFDU7Z+uP+xUiCekCydgCpPFtzsJrvS+gvUTQjNWYREpzcGWQQQiNpTd63Zt24mLv2pffoUnCVhF/0p9qB4XCFmg6YPOG5DeG6JYF7vYowr5aNjsz6GvVAbp7XxxdEoiVwUxLpD/eCqEzhAyrNrNDc6GU6Ga4rjFRS5AmaeSYNxXTeZ7fHPi5q7e8aPYAfK1+ICB8Ot1yjDUuP9EaXQkmSUESts6z7VusjVgbSfkLm27CmIRIKlmXqQNhZYkJ6mc9z64VRjd6Sz9WiEA6j94SUMWS9QCKukQd9CT6G2vnuV2dcCayG2qegoI3ghfswVJvlyhzjr4H37DvJl7d7AC4bgesJHagZR6AIKQpQ/uDUO3zfTsqkABZNru5fCQnq9+RfYTxeR3InG1lh9ZArBXRWMrKIZGMAglCs2yM0xqGV571BwdebPSabfuGx8e1Bg7z5RkN4g1xbznVOfx3MdMf9IfPG6bJMHN7MIRc8zSj4PZaoqz2ChwBdbihFt24M+IvGQhXScEgS4UKaQNVFXi2PnLXHMvrnx6u2dctsTaMt3k9bQIvP9jy0WrL2ukDEJPwjc0D62rk9d26BGSHvuZUdSTjSpYpQZ+rcHAKfspAHJmE5IU+NpDL+W5riXUiruK7NI+kgJfTywp7m539xjDcGqZ1znCyXxWfSE5gWp5tv06ZaiMYn8o6CK0QrT6rSwlQFprFWZmxrMu4rBsplZ9cpZmTRJtRkgCPeo+Hh5q08YhN6kjz+cZc1UkzNSLb06FjOFVYF6nnCsrVRHQ5GM8opdp5JnfGFXlPFi8lx4td7GIXu9hPuyW4SF/9JFshLBZujcJy09kvN2MuMzghrdNScsuRWrUHe1qi91iBnRLV3uPean2leVtRnVYko2UpAEmO8Trze864NcOhBm/gauBmowX1m9WJx6rjGDvll3YaVm82PV/dPHFV9ey8cunuzZopWb5zusNHyy6XHPuxwkfDuhn5YKWZjTMRk2vtu6phe9BjGKPw+RBNAYU8uzlw6kZSEr757J5vrLXM9L3jLd9+uON4aIkzQd0m4rWnu+lZtyNPez1uyP1H7yKSf/P6qmddHbiqe0TW7I/5vVJhcllwKbFmLpAzeG8wM1HYRFbNSOUCUwbB7A8tvncQU2mug0bRsQPfLZF+aLT/lGrNgudn1vgly5pvvOsTsRZ8qyWrZGfotCgAZCX6fuYMIfeB+opDreF3SoJIIuxdoQ7YSSN4Mwmyn9eYLWXe2MUCr49VotoJ7iAamaNVAtvrurRjon1a1tTxhXD8UBiez9mVxzQB5wJhWqL4m5sjN13P8/bAB62exBAch6mhvzrh10MBGTkXeNYdedHs2eQSxSlUXLmem+rEy2bPzuva++xwzRdRGGKHzdUQCcqzI2gGajIwxQ6aQQu29J6SScQGcJFUQZ97kb6zDHdwHG2pkvgWwioVYv3MOdMepa4DM/fgRv2+aq+glTk7SiYDMoYlOaq3idAu93aG7SejnMrk8vUHbO6fF1L1XHG0AFoBqvamrMfThxX+2US4ipxy7zO5nEELhSc4DBXh5GA0xDbgcgmyXY301Nqjn7PBJNT19w9O/51tX3qHlpKW+OJV7lk0NisPGGyu0xcWv+iDNfN+enTR1o9LWSJmPoyZEjJG5PU9ADYm6s03OH5YMe+WRS3Ca6krzoSmyUAQgrelz/TVzRM3Tc+bdmR3bOkabf58eLVjjI6/sXtZGsCnrqKzE/upYTe1bPvsIILRTTQujuDDdqubT71nHxr+v6+/AcD9bk2MgnOBl7lM9tFqy9FXvDltOPmKb++fAXCcahU0MBFmkEYzUNeBppoYvWXKJGj3ZAldJGknQa+DJG6aE1/pnhijI4az0hPaR5hLOdqX1D/DsebxpL/tuh2obaB1Hpe5f8ZEHuOaeHIkWQAKyShZNbm07FY5OCEIZufKRkrSTWi8SwwvUjkvSakAA+bSU6zhtBL6l7GQs2UU3MFQv7VMQ8tDvkd1M6lTmwzVdgYMCNMmaa9m5tINWubyq4Qks3CtjroJm3FZe+6ojntaq0OYOj3GtBaOHwn9K4+71XVztTmxqicqGzhNFWN2UnerE3fNkZtqmWJzVfV8bf1IZcM7s6yMJF60e+6qI3eZxf0kK/6j3Ud8sr+hqyYaqzcuJqGpPePKM10vz1VsclARF2SoO8rijGZS9DoVTqe4WIA0fiZIQ0GyJqOOwO4tdlwCmbl0HM9AMO6giEd3SpiQCoLPjAmT2w7zN5hRS7Z+NTsvfa/twY5C+L5+s+Q+rf43B14JYq9laXcWBPuVENYW1h5u5oA344aqUAJvPy2lWdICCmmaiW49vKOqY01if1z4m+/HLqCQn3DTKGZeMEMSUrTIJO9EYKGF6BLGS8nQxpuIO+YoOUd201qjOtcLqTZIlReU95gpk4tvMyBjI4roapTwPJNexak+j3WByixyQM5E7toT63rkqtZwdOMGPj9d8XDs3kGmvep2GEnsxxp/tujnhHQMud8QHT5a9qGhklCO+/l4QxgNV3dHXnYaqX/UPrH1LUdfc39acZ89uzGRrp7YtMM7ik2nscIHy/HYYB8yMnQnhA6k80UFpa08tQk0xmNIhEw+tqcMK7dpQY9NQqwycm0Sjhm483J9oLaBw1QzzL/NO+JgkaPVvue8KVxFVaAYz6SzgjoqBRzIAudvYbpO+DtfQDtp7mkNRjMMmR0HTDeR1df2pW+4u1/D0WAGwVa848STzwi4mVA/6mauShb5OlolAUvMUX/2M67XTfIcGi+zf06KPjy9yAi4G12r1LGATVb1xLoaVf4q2PKkO4lcVQOvmi2rjG2vJHDnjgzR8Th2uPzbrqueV82OG3vipduVtff6tOHj7zxH2sDt7aH83nFS1Zk0O6YuZDiiRYJZ1s6ZBJjPveJUJ/UGNpV1M18faxWuPjR60VJvkcEUWsF8fYnqQKcrzcZgCSrtkAp8H/QZTkaDlHkfKFJqFfhNlvMB6ieldPiVlKBpukokm4OOKZVj6MHVqY43c9CSCfRvLINNuBt9s7ER7y3B27OFo33OlKC7GthkWsOqmvDR4ExcAtupIob320NL/HQTq7/0Dk2yRuO8iRoXVRawN2WjmrUAo1Plh7k8KVYX/LRZjjddJ3wECQZ3qrH7Wz3urkdiwo6pOLQZEpxWge6mL1kX5E3eqkYjwPd2txyGmpgEZ0OB6K/dyFU1cKwqtrlU9zS0fHX1xIftjqex4zAsZS5rokba+cn9ot/wttcaSm0CD73Cv8Kuwu4Ne9vx9kr/fQwWnyy1DXyw3nPyuoEcp4oQDQ7KZtd7x2moi5OVucTjtVlu61Aa2pO3vD7pRXx9WhepLUlz2Ufe0RKcrjIsejQMOQLdXzU86448nlq2WbLJHx1m53B7RZnN/j45g4+CPS1OLrm0BDFnkOxpk/DPPatnx6I1GJMw9BWTV+mmGaCTjG68IaNGdY1E/Er1ziRAeNR7cWwtcrKKuMufl3oGE+iGCJCuPHK0VE8Gopa8ynVYCXZa1mO1VzBSrHWznKXF5t+CNwVstO0bxmBJSRi9pavV0a2rgY+aJ37f6mOeWw1kAsJ3x+d82zzHSKLOu3NlAofQ8Cunl3w63gBwCA33hxX2ycHW8pSrDtdXJ0IQ5GhLOde1EzEawskho5Q9e7yOJKsOfEb8STJMJiGVBlDzRp2iEI0ognGmvbikfBYDBIqMWGxgylB5XuvW1jxC85RotjGDSeZyX16zQpEQs70GEFrmlXe5hjPEPmeUMZcKFWwixPzr5pJlOCt326NmiWbMz0YObNt64piE8VSX97rWk3Jg1TUjV406tJv6xGFqeOg7dnkf+O3goP2025f+iqhAqy0ObdY+jHZBPEHKNf28QGfOzqgctFizbIxWeybDM0GiRaJu1O19zXhVMW7Mu+KxoujBZ5sjLzp9cpwJ3NUnYhK+c7gD4OHQcTo0pCC4JvBZ3lzHaGntxNevHtm3+jS96nb8rZvvcYw13zvelsjXB6NIx2jYjTOUf8O+b0rdvWzEbSBYdfZf7PQ33NsOI7BpBkXA5eszeMd+rDhRLbyYoSIGoW4njI1Mq0zO9irrZWwsEleHU813xjs+q644HBvtH5Lh4UmvuR3mnonkTBnsk8FP6iA+r64Zb1R/ML7V3+aOBndSmLikpT8C6iTtIKXkGJCCWI1VKtD0VClxfZpsyeJjzILSkrO6k/5DtRNiZfCPG8Jq5pZFqBKhS1RPhu57meTeWEKr3xPu1Jm41jMdKszOlpJlezUw2IrQ14iX0q+by+Cxi5jTHAAI1TEVvcGZzGu8VhE8hkn02gRvqW4OdJnr9cFandfPb97w1eaB53bPL1ZvAWgEKgLfqj/ASaTJDm3rG/769iWPp3erA9v7Nc1Rcs9LN98PNns+idcq7J0dsO8r0miwe1OyUADf6jUzW0f7Or+20msb6ghJSqaZkqgOajCYXGrr7gbijXBctZjHqsiIhTqpoPacsaHZUb2PSEz4TvA5OA1Nwu2lEOOB0levtlBtzTu8xGklpdQLc9tBA69po7w20IA3Vjnrzr411npsv0qklS/ZvY85MPJL4BWjUDeem/WJ2gZ2g97PwTt8NAyTW/Yy0SrP+7ZwGR9zsYtd7GIX+2m3y4DPn3BLSTjtGujPas2iqf8cZft6Vo9QnpDMEd6c1bTpHQJuEGG6iUrWbDMi7NAVEmeRyclcqNg7nk5taeY+bw+s3cBuaksENg4V6WQRb/CD5fPTLQCvmys+eL7lZ6/v+bmNRtQva+1n9LFi5UY2rZYl+imreyehz6Klx7HCe0Uy1i7gc3nm6sWOTTOw7RvtsUDhmsWkhOw5Jj8ONdOkxOhZfDccnJYEJ6PKFxnp51eJVC3jWwCmU8UUhJ6FPAuK/BRvmK7mi5UJzr320Wy/KH30m4pTV5Gi4DKYp95qFGwHjbLHXMYL+VzMmYhwcmlBw9VnBOhJS4P+sMLPKh82qWq9VaLt6rPM3XtISFIh4dOrfM1eCOEmwGZgosFlJF/9oD1Uv47cPs89yust33u6YWfWZW2Ng9M10iZVkJgVXmoFScjaE2xW/1g77EmztOYxkey7G0+qtNwKwFqBNC+7PU4iv/fqUwC+Ub/h2vZU4tnlWmUwnmvT8832DR/LHY+5d/r58ZqPH24Yh4ouC1WnpL3F2CT8JnLVzpJYmdPYBcwxK428rgvHE7OgESUKaUalnvG3JJcsJ2DzgZbcaxd4OnS6/vJj2Vae2nmcjWzTGh4zqjKB3Vot8eVeZGhhuDYM14bxSoqYsjsIzb0CQ2bu3pxluV6vb/uQAS+VECuH6yHu5hRtUQmK1VJC9nfKTZWdfUeUeh4rQxD6k5YS4mSQo97TkiXWkXrjebE6EJMUUNShrxHR67zO96KpPMP0pd/Cf0v2pb8aKYHsHfawIA9TJv/6Lj9gbcA1nmnXEE8zHE5RWZIUgTWXNaqtlsTCtUeawD6TPcUb0kpVIdwb3SjMkMtqVsnLT/PiHGv2U8MULcfxDKVUR1IQ1Y7MZaa4EXyw7H1TlPLfjGvGYFm5CWcCm0prpIKWMaZgqHLpqs0yOc7oPKo+96RGSXTrCbeK7LNe4mGomSbHMTTsDq02q0HnZdWBuvb4Xj8vo8nahBaMLbJe8SpQbUasjeXBnWHbkntnZXxLpJBo54ffjlA/UfT5zlEoKQnWxlLKsQOFqBo6LfeU49vE1CxIVpVdyjBpk8ooH7u1ZWOdpbOiA38lpDpmdJ4e107aI7UO/H5BGMYXkZubI1sDY77HzUPepAylN3dd91y1LYemJR5z8DFYxCryMTlZMNmin02TKddgfBaVWvJGMpE/X95ZGqtJJbBYrwe+eXXPR80Td9WBn6u1tndrtez9GNZ8a3yl7zUDL+2WW3vkV+JLvrVVNffXhzUpK9XMJcdpUnKv7/Sch6yGcZxqrtqB4bZi6tUh1gd1IJIyUX3ebUTh/KmC4S7/hpUGjW5viJOwW2mvt1sNTJMlHKqiUvPmqdH1JiA7V6Y6hFqf03Oi/nSlZWzXK4m6yv0yM0H3NhBrYfv1uUysQUvzGKl3USM7wLeWafUu4hU09kgZAFL67qPCJuWs7BnajFSNggw63mlek/oMSXnN1oEEfHHYMEyuqOpI1lyN0bBaq7e+aobflunS8YJy/Mk1mSOjWcZmyiCEiQLdHm2lfZvW428pvKH6MUeQkgrKMVYZfCCJthuZcg07eEvbKapsT8b9R1g/O/FsfeS66dkOutnt+oa3xzWDt5yyAHBKkkeL6GY1b/qm8wze8qv3zwrEv3aBEA3PuiMfdDtumlP+rSpELJKoczYYoimcKKBsCvu+5b6eNBLMckA+qPTRODmmp6bApE2CsLKcalectTuKzuaqdGObs65qM7JZ94x+qfVj1alzUm3MNAMB5vElNjFtck9KDM2DgnN8R9ExFG84vF1BEOZWWWhyQmMzZD9D1m0Vi2hzSHp9dTinlA1/Hk+i4z70eO+MeUmGZA3VXoq8WbQQV8K0EsarfA6rhK0D1uh6OHyox/WbPB+rjiVzfhw6TmNFPLmlz2MTqbfY41nvlcylGixhJYWTmG4DQ2uZNoZUJ5Vq04uGDEbX+TxfLwoPw4or1/NBveWQF/D83zf+ugA9VnbkUDdcmxMf1LuCep0DqBN14aYBmJUnGq1oDHlW3KGrSvA0b/oyUfhgM5UCgM1E6i3T1dKTSk4lr9xMY/giPyutcq/sweByUGr7DNCp9DuKraHaZ5HpuSeVx/2YER0h0y8ISncKDHXFeKt/96uE7YXqIAy3llDle2jRQOL79vnQKhpS59jlgDmfv+2XnuF0rYLm4vOg0lwJcN3AYJLK7V3p2u26kcOxYdevIfcfQZ8Dfz2BLH3wmOSdwbjvwxIXYvVPtBkTMVdT2chJRmHiZkHF2YPBryzddQ/dxJSjzqGplQwqFI7MKBnJd3AcUrdsTAmOXhCrKusAt7cH/vYPv8NXGoXD/6rR4ZrWRB6PHf2pVmIw6KZqE3QB24TS7BVJnI4NfrCsbzQye7mewSWRMbrCOdtUA0YSQ3Ac83yxw1BjJNFWPnPJctSZ0W/nEd7g1aG5LCQ76+mZCcJJSMZS5ZKLRH2gy3TsnN1Mh4pdEoxdonpTaznKNxazs2XygSSFVIduKdmERknNqiy/ABHc1oAYdSo5Mxmv56GqQmxU4mw2PzmMDaSbPB1gX2k0/H3TqafbAAbNimdkulGnVm2F6vCuxuN4JYy3ykUDSM9HLLA9tDgXuL5TOSl/bXRI42gZclb72q3ZHzVQmNdTtZqYtuoU5mGfoAjAZCCsKMNT69oTVwLP0CGQGdHoR5enLGv2CXDatfzH6SVGIr/YfcExw/N2UR3Fw7Tmfszz46xSOtp65GfqN6zyNfvl6iP+ov8Ko3flXsaoGWV9PZSNFeDYN+yPLeOupvILUjOQeYUTCn4AjUJcIqyX+zVD7qPXaz/Lz4Vg1GGMQqOUT6q9ThuYrnTtzSAuBQKBRIXU62vAqGVEMyba1/oMmaN+KNRXmJl4LhokjZsZQJTL4OMMXlrQvMnomg3PJpr1yHjKlIJxnkSwBEoqapwySjaWaRPWRlwTSE2g6/R8Tn0FH3es7rMDnSW8VomptUgdynXfDU159i+m9qV3aBe72MUudrHfnCXkgnL8SbbaBm5vDjzmQMY3rvR7GJYIs+pU/T5klWuY0+9ao163vBYxeaaZK1JFyS0q8zPn52dv33LtNCJsjOcr3RZQsvPbtMJVYRnncsi8meuBrz9/LDobT0PLvm8QSeW4L9oDPhm2Y8vj0NFmtYYxWvZjw2mqOPQa9fvJUtWe01jpeJwc3VWNZ1VPDMFxf9AS6X7bYZ3OU5O4NNYVxa1Ra2jfvb4y6RTpQmsIgjdgW4+t5ixTM8N0PeL7tozPQJS0et4Un6dRz0r3898l5H6bhXCVs6Pc45qzw/hUl3PCQLoZyzlE48BIvvcJMiCoW2mZ+PjYEYeZ7ay3XEJWhIlLX2sm18b8eVtFwmTwR4dvA91qXH6zjcCiovIYdG3FNmI2ei+f3Rx4tJEhdlRPtmQmoL2XVMcSvb/YHGisZz82hXsI4FwkNHkd5dJg6DUzPEwNx1jTR83GhujY2OGdyP4UKt5MGyoJ/Ez9hqssl9+ZUcnrUTD5UZlGR5wM3e3IddeXicnHoaLft9iHCjcDJ3JZkKBlwuYhUz5iReqULmHmsUHTQrC3gxDmZzD3Ic/1ciWpkLREyWCSfB2OKZeqF/mq+d/n8S8y6rMijzswhmrbsvo0l9EPQnufqI7KWSv8vrPE8rwalyzYJrDuBq5zX2vylt2hxYdmWcvknmGWXQuHzO8cLKZSAeIwT8d4bNm81inbvpWFAyuAV1GIKV+bg625W59433YhVv8Em5XIup7o80ZjNgPORA7HBm+zRl4Vub0+UtnAw35Fn/sCadbgW/vCixlOFTFWRZ5mLotVNwO/8OFrPuq2ZbPo7MibccO3xhfc1D0fNU8A3NYn3tRrBkk6ah2QSfkocTPSWI/PC7x1npubnsNUl03s29tnJBR9KHn+Gfnv46TloRmNOPWOaVdzNLnUlvex9lnPbXvioe94esw9v6cKXyV87ZQk3M0croWrM12d9SCOBnvSXsEMsEkmqQ6dscismwekpH2t8XbCT2cPjDjcQUr/ygwoSixpf2vmBoVVUgKzLERaXCzK42m0VJlMW+0Ev0qMpiKtl90oVRHbBYyJtNlJrGqV7jrZBclqe1GFdp+HVmaOXMx9lHjGdwsnh5ws9mSIneUw/7Z5MKMXJN+LaCzr5wfamwPrOvdM3MRprBjqSMKWIaOwBA9zb+qr6yca4/lOuuM0OVwuq9Uu0FUTY7CFfB9cYNWOVDbwK6cXfH66Lsf9xvqeu+rIs1pL158PV3zW67+/cDvu8zSEv7Z7xdOuI4SzIM+r+orP5erGLRIZJ2l1nlgGXsRaR9uQ0LJuLg1WO8FHQ6zTO+r1s3SVeEjdfIyI6VVRZr4eYSBPPeAdM9PCR5wBQrFKiFcCd6wEf6Wl1yoDV4yPbD7JiNfPhPpxBCPIBw2xzvfNkVVb5AyIA/4mcLUaOA11uT6rZqTrRvZthcljqMyYy8d1ysCQ2dFpOXWEoqcq+b3TSkuq410eubMJUKvakMvE66byRbP1YmpfeodmJOkfs6D+fDAaNedMrbkaWNcjtQk8SkfK4qrmpPO+2m4sY0EeXMd2sDqRwyZM7m989cUjv//2ewB8r7/V9443PI0du6Fh17RMea7E0VdYE5VYOfeT8pwvPzoe+3nYlpIcN/XARgY+v9dN5/GzjEiYAZl58xQvqoix8oqOA+yjw+1NIezO0WZvGz5prtkfG+RBd+jqaVY40Uh5hjPDWe9g7mtVieC1zyYR0jzo0SVVyNgbQrMAI6SJ1KuRejUuE7YnQ1gZzGjK6JfzrNBMKusEMF0H2peqRjFtM9Dj4LTXNsPBz9CPKkCtEPD5vEzncZUnBkOf+1ohGD2fp4r2dXYQWyUvV6dEvQ24k95j3zlOz5b7BSAnR7XNmUdL6alKb1UIO8lZ70j7nh9udrRWz+xtv+Z0UkWSZFlme4WMsh3NDLajy5/RmWR5aCZw3fZ8tNqynZb0ubaBZ+0RZwK/snvB25yFd/XEV1ZP/GzzmlXGsP/H7iN+7fScG3fi1h5Lv20/NkzHCoIsOqQCGCWi7/uG9Zn6TRrybLAcAJhJkGYB75RMqvTHpAQnyWRwUTob4ZK/z4yKliy90xt9z0ySn3tdyWoPsmRW8yFSDpQSjHc5WK2uMUNAYqJ5O2P8ExICsa1wp0iVz3O4FpJdUKug/T5pA1ftwJunDafXGcHcdDSbgWozMmX4UtpbzRDzvMV57ZhREGBKwHV2ql2kf66yXtNtoLrTe1RXAWsjm3bgrtWsrLUTH3bv16GlxEXL8SfZfLTcZwAGKJpwHO2CCkNBGjd1z8qNjNeW7+asKUgFVSIlCniiqTy2U5UN0LlioNHzlCxb3/LFSR3OY98x5KnMu1PDJ4/qkETAe8Owb5D9EsWBRsC7vikqG8e+Zt836ohzqaL9tNIHvNGNoAjtGhieR6LYglCstgbbK3w5tGl5mLaOx+EWGYXm7czrmkt7Qv88FaCGBKh6o5tIRgeGxhPXgTjm2XIZkCH5oTWnBW4eahAb8zy1ZZ6Z7J2WLCPLUMhd1nVMINUCpQeVClo1I58czhxwmsVk05LNNeoYzKjz1kAVN+gULBL2bgGFGHXA3WeG9adZveMhYIeAGSOkhPhc4lw7BYxMGaSCourMqNc31ZoBQlZb8FqONRnVGZzlcGr4WK4Lp2rwVgVp0WBhyhll2dSjlLL0t/fP2I81w+RISbjpdCP+hevXvKz3fD5cl8z+RbvnWX3kaer44nhVXreSuHI9X3EPfNVpCfzWHPlG/YZvVPe8tIcCHIlpyejnyQnGJqIXojcMfVVQdqPXqQISFj7XrJ04Z1ZVnjBge1U38eMCvCga0oNmaO40gzocticL/GbqwDUQVU91FnbWYyy8RLbzOUgefhqJlTBk4WReWJ1Y8BioH7MzEUDqgmhcZqoJfpWd57zGOkX2Ph46xkONy1O+w0pgo+LQfVbCP9WNgkWCIm2LSHOpbpgiExdcYJqEGAR7M3G10QfDGkUuv+gOZdBvTKbomr4/k8s8tB/GROR/APxD6KPzl4F/EFgB/wLwTeDbwN+fUnrI7/+TwB9DK2H/SErpT/1Gx/fJ5N6R3qTDY6cbDZSHNUSDT4Z9HoUxlwyDTRChP9Uccv/KCBgbCFFVsX2nq/7T4zWPY8fKLRHr6K3+GSrCZEp5zNUBP1pk50q0OksdBS8MoytZTNjWDMChDQVqTtRSWBrBt0tZTjMrjXILBD1L+0xXSYcMZtKr2xncgynoLaAM11Q0lxTF83nUhpm01AMQW0uyiVCnrDaeHfJkoAvqKObMJIoK/gIxGOybPHH3XuWTZsVyyP9NOaq3UkpS9mB5elwxrBfIe8wyZKlWFJrPqDnxpmyIhTckQtwYbDURnC3UDBlVB9KOyjMDcPsJ4yOxsUyrJdw/vXDv6HrqNdfrIwnM0ZaGungVQnaH5TckJ0y9YxtW51q0mmHbRFwFhmfLelDIaSrB1H6s2R5bRKCygdtM1/i57g0Ar2XDddYAfdXsuHEnKgkc1nUpDd41R77RvOVDt+Nred08Mw/8fPXAK+s4psghZ2hTNLiVJ0YpJTFjI16UFzZNhkNe01PvygY9Z/YSNZjx60hyy9ppggYBxvEOFN54CtKwlCf3lGPO6vexTmA0CDKTqIMj9+kelSs4ryct9ak2o2/UOcH8Hfl41XLNJS5DXKdVRu5eqdMMXSRt9DraOhIHy+njDdXBLM+QE6bRMVYLGjFFQXrlbSaXyrihkJ+1VMei8zoFy2STZsVeOJ31Sq2NnCbHutZse1WNpX/+02gi8nXgnwU+RLvhv5RS+t/8MMf8seaWIvJV4B8B/kBK6W8BLPBHgD8B/OmU0i8Cfzr/HRH5vfnffx/wh4D/nYi8/5GtF7vYxS72O9ASWnJ8H39+E+aBfzSl9J8B/k7gH857/A9sP/YMDT2HTkQmNDP7BPiTwN+V//2fAf4M8I8Bfxj451NKA/CrIvI3gL8D+LP/SQe3EnmxOfBJ5pZN2xoZRUtQ2Q6PHX+tf0XdTIioVBOA2TvMKISVZTc3bU1iOlVI/rcJraf8WnhO24189eapRMPWJGLMeMU5/UF5XsYk+o0lZpSYncfUVI4htUhGYFYHVXGPlV3GXMTcqI45ep0RmIa/KQqMtQqwSsqRYs7c5plUyS0N9OGORaoIirqK9ilSFm7O0ewgYKWoqczrNwXlGCHLcRgFrhM36xO7U8Mw35tBibfxrF83ksfH5DZiOhuzkk6OUzBIk4nG35hoak9/rElHV0jF09yHOevbmFEIvSXVQbmCZ9chZoX/eUqCHWrMpFyn4XqJl3yHlkLTIq/l16oCYXpFa9YPrvy2834YQOj0HHwwSynPJsRGbJ1ILaWULb1VAExzNtA0NXhvcS7Q1lMpPQE8+Y4xOtaZyLaxAx9UW36h+Zxvtm/4zqAcyCvb83uaT3hmPBo/ghXhEC3f9ZFjqopSxMvVgRANh74u3MzgrSpWVJE0GMYnvXF2Z6meFBlbCOICsyB06gJTNW9yRq97s0wiwOR1nTlbZZ3FZZDmzNGLvfbeqoMiG+fqgB0S9SHSvpmoHvTahFXN4esdx5eG0C7rbEY/KiIyl/09NE8RE7S0WEqnmX+WqkTVZpSkSYSnivYLnckWZ+kqgem+Zn9yZZ2K1ZI4SXtkKVc+YhAdcVRF9oezMu+M6txW9Hlgro4IEY4J7q/1HF59+MhXNk+8b/tREatTSp8Cn+b/34nILwNfBf7KD3rMH6tDSyl9LCL/JPAd4AT8Gymlf0NEXuUfS0rpUxH5IH/kq8C/e3aI7+XX3jER+ePAHwdYfbhhXY2l5MVMrE8sUODe4Iea0FnERsxWL0v9aJTw6aRAr/GCPah6OAnIm36g4jgZvrCBn7l9AKBxnt45Vu3AMFWFYDsMFVUVlFRbiNmq/WZHMPeuEJhtvyC3CtI6OzLj1SGZmciaEkkExLyjemFGJQmPZukb6gTetEzNnS/L3iCNHrt+1GP41exgzt7XaDnWDgYzUhwoJiF7Rf3NDjg0qSilh2AIa/3/6cpRb/MmMDtVp+oLqY3IZIrjiXXUYzuVmQKFscckfHe6w3fQrDIS1UWmVKtSft4Ejdfy4lx6LgCSXqBRhz33r/pbi/EpT6eGaOfNNWEHdUzLlORIsonY6kTmuYTsTvm6ZfUJ/U7BnCwxxAUKnukeYiIp2F+3ZtIfc/93Hgy7mRgqTx90Pd37NadQEZJwk51cJTqsszUT6zRwldE2L9yO5+bIU7T8xfEOgL8+fMin462Sq83ELje9busju7rh0Nel7BlHCzW0G50SEPOGa0adEq0k4vzbMgleggZTc581dMI8iHMB9OQ1XCXixhPncU/BYt6qU5vpUbPGpzsmXL9MmE8KwMQMAbPVNSKnkequJn1omDYs0wy8ZOCTlHshSYeAmjExbgwmD+1s72EaBZIlHHOkZaA6SRktc67yIl40sMt7jqkDodKht6b1pe8uecpDjKao6sRDpZqymV1S0L8jBVF8Et2fDnc1fv3lKFCJyDeBvw34cz/McX6sDk1E7tCs62eBR+D/IiJ/9Df6yK/zWvqbXkjpl4BfArj+3a/SfmxK4x2BeOWp1tPCAestcrAQdPJxndF+bp/HQWwCkh/GFDRyVvHYVGSJQFFe+0PLbp0Fh4NlHBVGrzOe8qawrwhVLMeELG2zzuiwcRlQ2Nwn3KCCuGUIZt4ojM9ou3wFpo0Qm7xZzlclR74qVSWE29x8vvKITRibSLO03L7SAaf58/OcKIlCaLWpLmcl+zkTlLhIGOFNHtzJOxtN8Jb77YrpuMx+mjYpIzOXadOxi8jKK/jg6GBWozAKTHBVoMrovsE7TpOOtLFVpM19zuANUxeglgK9Nh7SWkfa+7hcS+KCupvReZKyqoPRazuj5iTqcM5pnYrMVt16xl1GKdaJ8Tb3RzrwG+WcuQzfVl4dSHWm3beeaNtJ9Qp7FUrWi6ZAG9MEYl67crDqAPPQzu2ojmfoHJUEKlnWk5VInyp+ZfiAe79mn1OTkAzfqe5oZeLf2f0uAP6tz3+BXd9wtzrx4XqLy8d506/Z9g3xbAJ68EIwhm4VMOvEYQa07K1mP/W5Q0s6jTxptn8uTjxnunxfgJFswjShoIdHqTBThTwsGZrt871KMNwIvluOEY5CbC3xRqkHMnqqncedHKcPljVZH5Y+3azVWR0S1S6o9Jy4kmG7k068tsPyXSH3fpPJoKQzv5IspVoACoKS3uL2Bu+FMTvV1Wpg1UyIpMIbPY4WOSpyONYJnyXw7MmcBUZ63MO25dtyx/u0hLxPfcgXIvLvn/39l/Le/I6JyAb4vwL//ZTS9of5wh93yfEPAr+aUnoNICL/MvBfAD4XkY9ydvYR8EV+//eAr599/mtoifI/0YbJ8fGbW+XPAHLluXu25/n6yGdbRSPudxuVecqorDkVmq6zJFMVsZn7IY3HdxbjEqtuZJWbudtDy/DY4g8Vnzwo1jwlJTbHYIhBSFniqNoZkrH4zZkOWxRCl3lWVvB50GMjYMeEO8WiKZiMMF4ZQqVlTJ8XYGgT8dpjO1+c5/imQSaDHSnZDlAAKnEyZeCmOWkpLDa5MT7D9lPezB3M0nF2bwirqA7tHNQRRM+jOosuJ8FvK6KpML0pUXm48fRtbpyfZ4lZwFXOIM6p03sQo+HNW71vqc+Tfl2CJnDMm8K0rzVUb2MJOEKeChCjIZ1cEZsGnQ5t+0S9ywFFAOMTxkeMN6X0FGvNlMnTqEFBLng9z9RFQjtrexqkDaoK1s9Qf82ok1UKAcB6NbBqRo6mLqVuPQn9Y11cqgtYqCMf3O140R10Zh1w545YiQRM2Yxu7JGvVA+89tcYibQZtfDkO/7D4ze5cUe+c3oGwOunDX7U6Qqtm8oQ19eHNaeh5mrVq8o+8BBNmedVO0+81szvlCA0el3noCfWSfUbJWEO9h2gkju9GyzEWoMIezAEqQkZxm6vJp3o4C11rq7ZoKAQLU8uc8eSU2my4wc11ToLFdwPmClQbxPusOhlzlw5kt5/gHobMUPAr51m49mB1PuYCfa2oG7nNZ8MGHeWsVeatZs6EDMq2ZwMbi9Ue8H2lsHog9WbyOpaHdoMurGd10GpkyFJ0vluQDBRqzmRQurn5Nj134dSeg/2HkuOb1JKf+A3eoOIVKgz+z+llP7lH/YLf9yEg+8Af6eIrEREgL8X+GXgXwP+gfyefwD4V/P//2vAHxGRRkR+FvhF4N/7EZ/zxS52sYtd7Ie0vOf/08Avp5T+qfdxzB93D+3Pici/BPwHKOLlP0RLhRvgXxSRP4Y6vf96fv9/JCL/Ito09MA/nFL6jeWmgxDumyJd5W4GNs1ITFKU7qsHlRzSCHwp/cUuFnZ+lTklTeUJnapc1y6UUkxde6aVJx4c/aOWgiQDEACiX9TC60fluUi07wiY+psILhKswWfY+XgtRGuojklHWgBmjKp8YLMCwaygsNHIcLUaSjn1cKiYroV00AnO8lqjxmiz4HIClzMIM+Ys70Z/6+CziknQPpgkIGc27iBINKU8We7pylO1nuANYSZsbw31gyVahSnHJmeUayhzombi9yRIyECawBJymTxvKwrk49ZbIawS4ToQT44xE+LlaMsk6qIkEgV2FcEk3NYWIvdMU+jeRNwplXtRbz2mD8jzRjNhYJLMczoJkq9N2FjNTi0l6wJIPhWh4DjP2xNTXnvnmiXhqh1wzwNPGZIdjkpPCN5g8toNq0BzPfCLt6/5vZtPaHMqtDIDfarY2J4hpzzP3J5vVvdYiVzFhkejJbgn3/Gt4wtiMnye+ZLGJFLSOV27tmFV5ezIJDbdwDdv7su5zhMfRu/wwZTMwnWe4CK+t7h5PtlcTmwi0aVClTCTPmvusGRHvtXXJIDxhmme1bYOYDLIKY8Uj1YIay09tm9j6S0PN1KOFeq5BtjgjgHjE+19KtfdTDBdKX1nLjW7YyA2luHW4VeyTA1ICTsq0TrmGXRmWnBe1QGGW/3u4Vkq5UZzNtEhNhByybmaJcCqhgeBaXAl4zdVoHt2IkZhGha+ZFV7xlWl89DWWhU6blvYv98tPMGPcnzMfxH4bwJ/WUT+Qn7tf5xS+n/8oAf8cZccSSn948A//n0vD2i29uu9/58A/onf/Bcosi+d1bR3faPSO495wx20TOZXidjpmHSAejXRNpOSqc3y+bn8YiUxZJRiSoKrAmNtFgV+0dJeIj+Lc03+mB+GM9Jw6Sdh3nk91Nq4Ds1ZiWxQZJ7rI8YL0yb/mxfiybEPq1KmMrmf5Y7QPC1SQ9NG6DPyq7ReEsQu0V4N1JVnK1kSq7cqH/S0KHqYEeyoZchkFlBHsx65Xvf0k2M3ZlLz0eB63SDmvhyA31tClzKKMr8oGaQyg1XmcGUyilD1pgBmzCR4k5DRYI6mjCohQnK2lPoArNeGuhmEarf0KEGVQdp7j82KIKkymJMnWVM4frOZoL+7KKbkgaXJqbSXFIxPLGN7pqyzmPKa4Oy/TaXDHH/h6jWN8fzqQdGI3356xvagnLM6S18NlaOpPU4iz+yB506ZyofYsPMtlsSN1TLkY1jzV8dXfG98Th+rAgoxkrgf1jz0XRlrkxIQhelY8cZs2Kz0vdYkWudp7cRtpRfsyqkO5HcPt3z34ZbTTqOpFAWxEeVA5ms1ChIssTGELqrmJ2TUrjoo2+cgQqRIikmQpdTsBXIvbka+minz0gblDhY0YmDpzc2PxMoQK2FaGy1pnumIJqMlzxkMVB0ssRLGK+H04vwZtLSPOunBltl4mQOae60zuTt2UVVi9g53xpuLbcJMhqqXEhSavWWMrTr+HNCZ1vPN5/dsqoHvbO+K3F1XT9irI5WJdE4v8PcSHPs179eE8CMiVqeU/m1+fVzED2w/dof222554c4LJiXhcKrxg9PRMOSs7Eb7La71Redv0w58tFZtxs8Oyt4cvKN2OorlXMfOB4M3Cuv1eSNPR0dIQB1Vw20OziWTSE9LD8EOgrxVsvIs2guqnDFeK3nUZEcZBlnIzj6V5rY7CHF0uunmDK9+gs0nkWrvsUMkZuj07qsOnb2W3l1RXpgmS115qozGmgZL9ZRJwtn5max1WDaaue84Og42iwTPQJoqESftcUiQM7AJxZmVa2OAJlKtRqZYY/ZLX0nnTCnABc6u3c7QPCwThH2nWZYdF7BKyMjNaj9nATPaTYOG4dbRjTmyHgLJGkLnCNWiGTj30GK1IOvIJFiSYG0qBNlTnvItULL0ebgooCg4VMzWScQSeeYOOh4GdTyvmw1TsEWN4/HUMgXL22FFn6rC9anE08rEG3/FU97134wbbqoTKzMyJcsqX5yYhLenFffbtY4JIusImgS9ZXxqeMi9PFsH2m6kc9dsrvV3vWq2bOzAKVR8OzwjzSAWkzQYOwMpIXoPbKY0lCGufUY4ipKe5/tuszxVaFKh1UgTSV6Fi0MGZEybRMo9Wn8W6EU3f+eZ/qaF/s5w+kD7XFVWEHGnef0t2VWyVlGstTqoufKRnDBdzcCh/NOCSm4lC75VAJC+N2GOhubelN6e37AohOTfN5tMQloFXM7ub6+PfH39wMt6j5HE50fNop2JrN3Iyo1F4qx2gdNZVeBivxMcmo2kNmBys77tRkIwTHtTdtGwAnM3sFoNvLra882Nllga4zES+WK4KgoQIQqViayqhdkPulGIJIyNpFMuZd4rItKvTJZ3yg9fltUxk852AhTjKWh5y0D9lEuZe+08D8+kRKJm1A113AixXpTFJWVE1kGKzFB7H1l/96SllLuqbCCKiFR18pkvFhrNjMLJse2dcmRQAIjNMkMz38Zkeao5Q5s3q7CtOB6cNrNnsMk0bxha0jQFip8Iq6gIxhxcSFLIsx8dZDCLvlnpCe6woN2GO3TQZc6+ChR+rjal5f/tCNVWI+xpvWS8ySqF4XS0+FbvW/c2YKZIdFlhYlaM2CjvLFrK2pFRN6o0Gca1o8rZ1Ng74qEiuLhk7EHLtOXvwGMU+rHiO0+3fOPmkTZH3w9ZPPe66UtZ+zhVTMFy36/5zvCcddZi/Ip7UIh9bPnu6SsAfHa45htX97xY7wnJcMwox8dppeu3HQsqNCUhBMMQBAYLmbbia8sxCvfVisbdAvDGrmntxPf2t4zH+h00LaJDR/28+Z90jZusUzpnbtUh6zDm4Zugma/bJaLNyh9zMJRABgWUzNy/MGdDtVIFTFZ46Z8ZQqfPR+GsOUUmThutBMzVj3NqQci4itAK9ZZcGl+AHtM6qUKMnGmNzmvY5TL9PIVdFLAi4Yw3N+Qp941y5uZArAybtYnVSu/lV6+eeF4deFVtYU3hFb4d1jgT9E+OKisX6DYzq/P92I+45Pje7Uvv0EQAm0rW9ZXrLRHh17xhmicqm8TVauC6HbAS6fIiuquOHENNbTw3ja7k3la0birDNMvYh8ZwpGa/a4uumx2F8UYdKn7hgIVakEofjvptLtU9hTKmJBlRHUFy5HpTZ408Pd2Z2xMrFe+N+bhKfJ6jzxkirUiw/kXF4ZUtxxjv1IG5gxS+2HSl40qYDPbwfTDh3Cuby3ohSz7NBO/ZKUqweczGQo51R8kOSc91Lh2FBn34h4W/pVmcheTe+c16nBwAZH8QHbDWnmafqiVzs7qp+I1uNgBupz3EZFW1fY6+/Srh7zwjKj4McHpTUe1VPmm6WkZ4lFElVSqZX7UXqp06vlPVsMsDW+2Tpe4FvzLvjBiCs8AG8JWlDw29rQnRFH3G/VCzqqfCKwO4rgfaXBX4+HTLi0qFaVuZaM3EK/fEB42+dvQ1lUSmZDEkPhu1whCT8PM3b3jq2sJj248N625QndMgpHlDy9MMRm/5dKefD1EYvePw0GF2jtTOKXtSZ5jH4wDIZPMgWL1nc0+NBGZQZ1cI5jHhTro+bC9Fok2iUD0p13Ge/kBU/mC9hWofkTSvde3ThlYI2ZlISlQ76Kyq7ZesaaXHMyPvjCiSkKhOWg3ps1TXeBM1Y4yUiM6MlP6vlk/LbSI2kfFmceChW9CeybhyDjJqhpe8lJbGq27Li2pPJZ6YhCnfi9pqqXmMrmgtVjawas5Hdr8f+1GVHH877KfXFV/sYhe72MUudmZf+gwtJe3lXOdG91fWTzyrDqzdyH/sXgLQ73OJ0AaOU833jrcAnJqaIVoexxX9jPjL42gehpXOg8rioK9Wex5tx+HQFjWCUENcBdpnPSEIY9TUJBlTeFBzCRBUFNfuBwU1dFlV5Hlbem5zmWS8kYw8BGTpKc3qISpInMtkKx2ZMa2MlnjOJHpImhEFOcsgJuXAwJIdiUV7bV7OFMiz8ngmbs99vJQWwEtBuYUspiwqDlt6CEmzMzMtABkZc5lqmvsTS/8ptLlUOBO2K0UA2Cbir8/kGtIiYFs4okZ7HeeitaDvk1Gz5+l2zjZMKTOeE2bNoOVc30kpe81ZsZl0gGU4nGWlUJCzALL2pCDEqSpR+nxurlHE7Nu9lhpPh4Z+NWIklfL2y27Pi2bPZ/01b/o1v1rp+m3FU2W0zwe1Zmj345ohOva+oTGeId/MtRvwyfKpvy5jiqyJPFudqGzkPkopp9Z1QPL/+0xw78eK4VghJyV5Sy7lpyDYndXPzpX1kEFN64AZTcnio1uyMwkzsjSvi5SFBY5LrF3tFA3pp2Wdu4PQvYmYKZLc3JtL2FbeyZbsqN+hRGUKMRrRZEsEXK7aKYEa2seAbwzTOpfBN2B6k5X83+3BgZQMdL6X2Ii/ZWkMOyWLWxvxo6F6NGWN+LWW+ftRn/df2b3IrY7E39i95O0pl57rgbv2yNHXBYgWomHw71cpJCW5lBx/ks2YxKsPnvj61SMAN9WJ37v6hGvXc5/7FF9EhU2/7PbUJpTBh52d+Ph0y+vjmqdDfvhtpLKB/bEhRcOLO91A7toTT6dWR6Nk4mOsBOqISKKqIv5GywOjdbht7gtk8vLphSU0DS1gxoDf6ALvn1n8Sh3Y/HzImBvqDci0jOWY9Qdjc7aRJ8F3BneKuNYUZfHmESQanYo8V15HweR+WWzORmXUCbHar5iRmrFC1cdXWk5tP8sz5Eay/FEqyK/Q6HkULcrs6NykG0SsUinHzU4z5JlsZf5UlRjvAsksSvoSgKdKCel1xL/MJzfloZppKYXOPUAgUyYor6dBN8FCDvdC6FIpMRaCuM89FFElEMiqIVGod9qj4+qsHym5jDX3W7w5ky2bXxNS1I3k2NeMj3niw8ly8oZ7k5jyRIePVltiEh76FfenVSFAX7m+jId5nhnDr5otr8cNAfMOUTYmg5NASIb7ra7/dTfyvFNy9jC50lurTGTXN1r6yr3icXCkk9NS/trj2gwc2qs2m8QzNRkD4SrgrkfCaBnn5pExWnIMsNSP9f/NlHQ9zxD9isX55OPOI3tCJfi1LU5xDuaiPQtYsrxVrL7/vr/b+wV1tNFmDUehDFutH/Na8suzVh1SQUjGJsG5buOU+/MzXWOm7iQhtRG/WYIe8UKMUoLqbx1f8vHDDePoCNu6PCtvn/X4l4bG+gWMNiyI6/dpl3loP8FmJHHXnjh6Rd59crrhq80DlYSyMLpmYlONXLmBq6qnyTvvrLowesuQkV8pKqItTSqSe8yw2sf9iv51hz3YolWYVoGq9ZlTUhVFDomiyD+3IOhUGcQQqzxxOGdupxeG8UYb7M3TzJeZR7YYYkNRuLBDor8T/GZxaHac+xNRoct2PoZCpZOR8lo1aBSaJGceOXINnW7Qc98JsppInRRskwLTVQaQHBfgS+FhOVVdsScpmzzkKD33VmLO2vwqw/WTZoxFey/m2WLTGSx8EEwrhI530KnD4PBvOux+0ZOU7IyShfGaMxkmfU0pBcvmMF0tPZuCbPPa+wzNu0i12AA7yXDy/DvWCXeUd5QzQlRpNXuSEuknDL5OhFHnjM1cLXsUiI5DWIEi+Xm7WvN2WDMEx3Xbs6n0xB6njlOoqCRynYldd9WRre/4rL9mO7bUufn5u68/51W15RTqopRz7Gs+3l4zBcvp2BQAVONUDzJmjhpAeqhVcaNKxM1yDbDaJ5LBUM0OXIBKAzqxkXiVJcvqhNtp4DRfLztowOOOOruszmjE8Vrw6yz1ltdNFEWynl4KsTI028yFGxJ+UAc2Z9a+W0AYmtnNmbWuqXPnN13rZ6crq5n1LGQsCmSxJ3VkoMNfh2vJY3EStsyLC0yhUsm2PPePlaeqvQo8m0S80gUxVZmHOgkpByQyCf1jRf1oqAfB55mEU1fxeGq57XqM5MDY2zKi5mJqX3qHFpMwBFfS9Ec6/qL5Oo3x7Ed9SEdvGaPlFCqG6PB5hftoeBhWjN4VXlc6uZKlUAmHTM4OTzX1Qx5wOGvLtYG68XhviIeqgEWqrcJ3MRQOmZlBHpvcvM57xZhnMYmXQvA1laL16l2C3cKNmVbCeKOb6ZwBuGOOSiNZcHeu1yV9OGVB8YFu9KFVBzBv8NU2O44m4W91VzHrCWsV8u8Hi9Rz6ShDl0+mOLeUo2yEZT4ZWu4s5ads4dZj15m1GiFlkIXsDc2Dobk/K73eKqm62owgiTErwvvBYQ+G+knKJqhlrFTQjQVplgWa5WAWKH7mJ83QcZP1CstnzJJh6Yw4RUAmWRB4OM1WzAhi5nssyDQHGfMFF8ASOkOqI66AazLt4GSY8vfvRl1rq2rk9918yl1OId5Oa3ZTi7WJKkcLV7bnZb3j7bDizXHNB2tNLW7yJFUjsQBQPj3ccP/mSlGpUdhn2smpDhgbicEQDi6vJ+UUhghhtMR5sKtoVi6BwhOMFfhrg7dOaQozfaENhCkHc2Yp3c4l83NJLB1M+y5/MdZ5Plmez2dyibzZBlZeSkYLWdQ7LkHUAkJZ7uXy/4nxRh3bXGXQeyGKvrWLKMAYdOjntInQLsILVeW1KrJzpWw6RfAuEiej+qn5mkWXFhHjWb6r1jJ6rFT6asrP2+3zPbddT0zCdtDI8tjXjP33jef+IS3BZcDnxS52sYtd7Mtgcik5/iSbCKyrkatcnjn5ik+P1xzGmsd9V94zBsveN7R2Kv2Iz49XvH7cELPCPqCQ4ZOOZ4kHWzKp9ih5jAqLnJU3jKMlBosMhvpBD9J9oR8a7rScom+Geu4zCSVik5jBFJtU+goSNcq3o/Z5ytiTF8J4p5DymS8zj9dITrBDWpQZTG5shzxyBvDrpfyiIsn51DLvKnQJlwm211dHjMBxqPBHVyLfuApU1wPTY0tz78rnQ7OolMylnHmSsRmX0lN9PXB3dSREw/bQMvbzMc5KfNXZf13EDzkDmOHXoznLgJbrOP+x/cJ/mjqlKngoskYSyVMLEnZvcfvluiej2V49k4QHcqSelI+UxZBlMphRVJHkjIxuR70/83W2J6E6aJYc64WMG9rEdB2wtyPrTtfuGCwhah/FSCqCw51d/vtzjep439ojN/bAMdbsprb0wP7q4RVjdGzHtvDbrFPpMESBK/N4E1Bx7TBa5lEosUqEcxrHrKBTCSHTLzKbAL8Cu7fESaCJSL42yWvJUtdgrgLscw84Azfmyd3DsyVLirPocQY3jZtIqM3CuXyE+tFTP1IEBMZruwCvhLO+8AJwmp9hMwp+FZWKMo+HyjaX3ENWMylTLW4m7m4PuHmitySmyTHl+WcAbm8JqQGray2Mc43TaNYqCXIWL52n7ibGtkJs4qsvngD4W59/giFxP6743v5Wz8kv9+Vial96h2Yk8lH3VHoLH59u+bXdHY/7TpXSga4bqW3AR0NdBW4qfe9uaiGJKtLPpYqU0XtJm7qzhJJEretPV3EhQ+wcU+bT1DvlzYDW+qOV3FheFqSZoHmM6oTsjJIzTFfkkRb6vmR1nHwZ9Dk/OAeonZ5b8zDz2zJZ9e6spMbyGVXSz68FcKMQx7n0mPtBm0jaBK6eHfjm3QOgm+tj36m25fXAWGcv4w1+cAX8ALmMRB4Ts0r453kDvu0RSfSnuqhWvLrdcd30fL6/YjxWSNbDs70p/a+yEXlwr2vtXdWL0zNnahXnTjllMrg7nqFAN1rySVUiVHPdB7AJmQz1gykq7+eE7QLQiTCtYboN2JuJNpee+scWxOo55iBi5i5Fd9ZHDIk4oDf3SAmckhEwcHN15Gqe6NA3jN4RouEv8lU+WmkPbG1HntVHfqZ7wzOru7vNF3+MDh8N+0GjiO8+3BKjsGpHNvm4bTupck4VeXm349UqS2r5ms93Gw6hLUjCuE6kWsEtZuVpGv29p5NRPuFJCkhDQlZvMYoKNXmwZZgyJ9OlMvdMopR+pva69DpEK2XI61LynXvIuaSdz823olzF+1nfCiSt6J8pN9KOCZ/LkbE+e57KNc/lxRz0zM9mdDlQTSycwjqBizTtpPzV7Nj73NrgbMiuGWUZn9ObJcgKOu4puVT2DNd4nl8fqG4jH6x2/L6rTwF4Ue34YromInwiN/p5SQWU874swfscH/Mjty+9Q1u7kb9t853ydyOp9Mj2vT7kzgbGYJmCxZlYQCE39Ym6UaHdWaMvtoGQMkDAU8jDyagzCze+PCHmYHUYqIf2rRTwhs9N6+qwbJKz2ocbEs2DJ2T9v2qvpF2JyyYaa5isZlxmXDbM6pBonvKG0M/N9sh4ZRluFDxRlD4msFkiaj5udVAn4Vf5O57prnv94Y6v3z7yzfU9Hza6u//V/Ye8PqxVWHc10GdnsH9YwbbS/s+ZSgdJ9R79TeDZK/Xsv/vZa5wJvOk3TPnEOqcZ8mmsYLDYrMdoTypjVcjNZORiyA5zswQBs+RVPGsvRAdEwY7aX5zBIu6oAQtpAcfMxGBzUsWVeruAW/xKkanlXlQwXUdk47m5PtBmpZDPekdoHaGRIsBrfJZLMstvOBtk/s6gyGS1bzp6B9nxjN5xOtZ/ExDgo9WWb3T3vHJPPEZFLu5Cx7f6D/grDx+y7Zvy3v5Yk4IgAquMZlw3I9PKqfAzlOejMoHGBYY6zMmvbupJSKPBuVBQdnEyuL2h2p2Bl7JTSBaCTVR5jQiQWsFVnimPeRn6FomCOySqDHrS6yuENDuVpbogIfd2xyV4CbU+K2aYSM6Uz095oCjCu6T+BPWOJfhxGfUoOVDJoJdwE5AkVI+mrMcpQryNxCgcxro4tNNYMZwqZDRLv87PaN5Z1iv/jphBTy6V+W+3Vyeed0c2bmDtVLYM4MGv6WPFEBxTXALxr9488S3er/2oJlb/dtiX3qF1ZuTn6i/49qScnZiEm6rHXUU+MRrp7AZVaRBJfLq75ouDSkNYowituvWFj3OacnQ6KlJtlreRkPA7Q6xtkbTRqHBWk0hFvSM0RiM+SfiMHJw2OoOs3hpqQ3lvvU86XPAsuuzvhFDPskLnmVAqZS07zDtCwrQGO6oW3pRRU5IoKiEzPNkOKW8KWvKay4s3ncov3Y+rcl33U8NpqIlRqOtFT85UgWgNySyUhLnE51cKZbYZCNDZibUbsJJ4O6hH/3R3zXGoGPoFsgw5S7SK/isNfpNh9zP9aS5J2VQQijN4Q7xmAYgUHUEAt5cCwZ9fjN4Sq0T9aAqqDdSZ9S/zrLdxzqCTIj4Hy/7Ycsqlp9g7pEr4zZmG4bCULeNcBkvz/VdASQlwbgKy1nU35HLhNFniYJkExspznzlKIRk6OzFFyzbv2EN07LxC7lf1VMqLw9op2g4KUKqrJjbdwHGoOA41QxYtdjYyeMuqHXHrnIFMTlGkSS9iQT+eHHYUXJ9KMAVaUoxO8Ac3a/KqVFkVqVaBJq+d7VcM0dVsvrNkeHrjWKoIaXlNvAYjSThTcjHYyVE/tcRGr9lwbXI5V7PxEjDkknu1SwVUZQKM6zwItznLyF0iZeHjuZQfKyG5WLh6c1YzjI7U68T2Mi09ZMRwEq3gbPLEaqsTLKyL3F7rQ/iN6weuKtXK/PR0zdOs22gCnZ3Y+aaUj2+6nt91/QV/iovN9qV3aAHLZ/6GLyaV7vm0v2E/NYzRll5ZV3k2tfYp3h7XbI+6iNp64jojwWZ4/im02KOSgZNbIr7mAdo3INEy3iyyVXOZK1l9uEDlqlKO9uP33YFQw3i79KQkJKpx7i8sm3TKZavqFHGHjDRLMK11IGWBmkdKJqcb6QKDh+wUZwXxIZPBax1Fs87ljDe7NZ+8uQVgtdbrIcDQV8TR4lu7CN1WAblNkISxzpud0XJhWEXExaLyfgg1V1VPbXzZXHfHhhgMdTMx3ICv8gWqIraOTL0tWojS6+BHKh35U4YsthGpI6m3SJ4W7QZFjvpupgboYW0vxcnMZkZ93Y684/xCk+XBnMLO53usOHLRydVpObckSgw3sxbkqKVEv14ytHnop98k/HUskx42tyc27cB1PRTU2T1rmAzBCwdajtlJPW5XvNmvuen6QvQXSdw2J75x9cDRVzyNulCbyjNNSkOZg7TGeZwNiFT4YBjPVPhjFG6vTjzrsop/33E61aQoxGiIfnHMoU2MV5kDiGavSaA6Ap9bwsNcK9bfuw+GaqW7/tXdkb1JTA8t9VbeoVvITPCfkcYsJH91PDlQbPW7o12Vvtl4LaX3NZczy7mNuZc6O55p0Xp8Z+q71zaDapHmtdAlmm7iZnXCSiqlRmsjbjMRTpZ58v3s2ILV52IeFePqibrxrJqRr2y0avGV7gmfLN/ePWM/NLzM6NSVG/HJsB1bpkymvmqG914efM8Tq3/k9qV3aBe72MUudrHfvMVLyfEn1/ro+H8//h5OWYh1jJbHoePp1BZk0nXbE5JhP9bERFFKuFuduGuOPI0d29McmimBdlbTyJqvuGPukYkwd3hDu0SSfrWgqpKbI/uFg2W8cqZiDcOVwU5zYz1Hk93CF5uRdu6U5X6ykLHvLOOVyTOa9LhzqXImmM5CrO6kyvVm7kFlOx+LMkfww6mGtw3uIBwbrSPGJmEGwSYhPAezWvhIq9XAuhl5ajQrOLkOc7Qq8VQFbD5u7yvuxxX3w7qUz5yLvLjd8Ys3rzn4ml/dPtP3jhVtPXEYaqacQfTbhnA0IBDWsag1NGtFBu4OLX7KCi+DAVR13V+Hwn8KR1VsIS5A1jlDi1ZlxuaS7DxnK1VpAYVkLlS0KnxcxsPYhD3puc2z4mIlWqJ00GTEqw3z/dQsb+Yo1c6zqUdednv6MEf/NzqGpDeEIJBRg7YJTMEyRcNtFqtduZGvr1RA4FcOL3jIUXfKY26ii2U45ywwkJIwBcMw5SGwuZy8rueRB9p3DocsMuAiKZxlXV1i2qhqiq7pjOo0eUrCMIM3tPLAJITMsXOrgdXVQP+ixp5MKVuGVnmVygXLXxUos890Fp2+HkkqJn21AKDsoO81AaIugXIvo1Wk8ZzNhWNivJHMfVtAHTIZMAm/jkjmmMYu4FygMpHjVLHLVR3nAlebEw+HqpSV7ahryXcoqvEMmWhMpHWe2s5iDoa9r/liu2EaXRmoCjpC5mloi0zW0DgOfumPXux3gENLSfj4eFNABwBvDyuGvirKEk7iOwM852b5TX3iqhrYje0iMTMTj5OWuUIm39rR0TwlmsdlPMp4JUW6x5+pbMxNbdcvMOLpOmVdQMGMqZSkopM8c0wKZHieshwdjNeG0/MsS3StyvBaVpnJplHHYYRE/STLgM5B+3PnoIQwKxNNICfD/j73zEZDdRLqBykz2WaVfb+C09rgXSZASyJFyRtnvjZXU1GfmIdeAjyNLff9SiXDcvm3dp7KBq7diZ/p3hZI+re2L0o57SmXXMTqpmMmQQYDWVewaybayrMDUh7rMXyQFF2Wm/BkMq4ERc2ZIO8ANWKtxFdFJS5lqGSTqmLke2FH7atIMoSESoGh35Nmp5nBBdOLCC5Cb3F5unZ054okgt/pTXhMaw6nht2mKZMemspzagPBGKQLZV5d20ysmpHKRA5ZEWdTDVzZnilZIovm6IvNgc5NGBIus85b62mMx5nA56drPt5pbzkmuO161tXIGM40A2eCdDynSmigF+tUaCS2157sXKqb13rpTRmKLNS8SccMj59LfzGT721ceqRuVGpAvUtFTEA/q6o2M3kdFhWdUMs7sHvIpd7mLIgTfV79KjHdhRIgMVhMLiHP91S84bBtiVHw3jJlegkrdTxSB8bbXJa2Ohw03E1U6wmb0Z4z5aFxvii5nELFduywNjJJ4jFL7p3y9dntO3wOKN4Cu837dWgpUZ7Vn0b70ju0MSq8vDRtJ8c4Otpu5Pk6N2I3D3ylfeRhWvHXnl6xn3TVH31Na3WDnYcsmioQboVwA9IugxamjWVaS3Zo+pqKoSqqbs609HUdkTFPzAV9Xz1q78CcDaD0rTCtsvzPPDtqmrk4wsgy3iQ0ig5zx2UQpztEnICdDNPKMGZlEklJ+w+ywJNDmyWgTtB+YUF055nFkc1EGVdvjCol6HcKKStJyGAIwKFqdWwO6KBPtwQMY+43fO/1nSJITcLkjWKgYrtbsR9rfv7mLUbmzC9xmGpGb8t7Z09cFB2yA3U28rBf4V932AzemOeukZ3UPNx1luOyp+WaJbfQFpJZemig2ZlpPSFrNppHi8t9OIkGX+gQkmdfncl3NQHrIj4Jw7NZVDCRuqCOIS0ZXuwdw6HirbdcvdKG6NdvH1k36lyumqFMLm7tREzCbmp5s1dwzeAdXX79ceiKTNaH7Y61G1iZsQgWP/pVcXCtm8h4JIap4j4adq4pPbRX1zvubaAfK/xk8VmqSyXJFHHocxw0rVUTU+ap3t8njE2iDDo9bVvwUlCEhZoRlwrC/N/6MdHdJ9wxUreCyT2p8VbBHO9UHc4AUzFIydBipUGJJIrWJhFWn6tk2V4s/nm+EC4i3mD9AnQiQNpWHKNgm4CtztbpsSH1FnIwNWad0moz8tXnTyW4OE41IQlrN3KdqUKnUFFbz+96/ppPD9fFoQ2T47RvkPtap14Dfej47uaW922XHtpPsIVo2J2aIh/kXOR63fMzN/f87PotAL/Yfc7vaT6hjxWN+Vv4Cw9fA2AIOnto5UaaDMd2dcCjkWVde4YsPZNsYrxSYuw83Xa61qF+ZsoQ40IZkQIhngV850nO7pAwUyqSTTMxWgcOLh+PlSrp+3UqOohur5ypap+oMlCkoB0FVdzPD+S00pKp+GXxJjfrD6KcuXOwWdJNJrS5bNTBeJfwWZ/P7rOs10FIJmWUYy69rgPzAMgwWg5Z4848VJikzmaWUMIbJAifT7cMk+Obt/cA3NQ9v/Z4x3bbLTJkvcUEIbZR53Ll1x+3K/xTzfpjW1Bp47UhrGZJoUUNX3lTWcJqzhwCkARTz4Ta2XECLpbv1xfJ15ms25gBEXM2ckawTYOd+fKka10MNqvsIwnnYoHOD9sG8QZjI3eNOpMP2y239ZHtqA5qFtGuJHA/rfFnowEeTy0f1zfUJryj/NAYpUV87q9LGX4IDiOJMVoehtVS0uprjpPBtVOZw3bd9Ao+qTzHsSrz3/T3JsQI00x/yALXZkoFDg9ZeLrW0lvM2YZ4Kc4ndIv4c6xSyaLTLCHmoToEkixDb4E8Cy1lBHDOEietPPhW3nneYq2B5flkCqWEJOodtPfCyWZV+2cT4SYQx0UL1ZwMpjfE5AjeYPLk6Gl0+JNT4NJcEq4jKWVIfntY5tANNVOwbKqxVJAMia90T9y40zvzFkdvGaqKWCVMlhar31peX11zscW+9A7tYhe72MUu9pszRTleQCE/sZbQXs5MRl23I89XBz5o9/z+tRKuf0/9KZVEHoGvNg98nhUY3vQbxmDxyVLnkuPN5sT905roDdIkXCaLjqtI/0KysGmOAjNkX6Hzi2q7jp1Q6HLI/B67VyqACVAdE+2bZcBYrC2hMUwb/Q3DreH0QpW4fZZu0gMrN84dlzLicOe0Ae4kq+jnt9Yw3iRsv4gQi9f3MKuSzyAWoUhsnY9NCXeTwuNHAyyzyGbB11mk1o5WI+MEsrNLJiQ5AvdCkvxlEfBK3PXRFP6UkcCxr5EvGqr98sDFKmnWGQT2OVs+GjafC1ffjYVjdHhl6J+ryOx55mmHRYU/zOCCHOnHrPov8ez991WRI4Oc2QmkOoMPcsYbmqQqEKuwgACCwGOF640CUwDqqAAPUcWO6zbTRwSGuqJtFg7ZnIHNIJE5QxtixcHXOAmsMgl7CpbaBGrrMXnSMcBf33/A4B2HqS7H7dykfTWJGFIBRTWVV2WSYAqZdwqWygamaAhBy8UAqY5EEZ3mXc9payqTp0O3jAhKTdTS6mSWct+8HprI6KS81wxCc2/eueahEaa1Tqc+vTD0L/T14ZXHbCbiwWGHqtxLHXWk5+BzP3NW/JAgBfwx3AnTRp/DUC29Zaki7WrUkS6592m2VufjnQx+VPK3rseo5eMq0awzJWE1MOa+79t+zSGLoj/eb0i95QsTebVS2H5nJzZ2YIoWJ5GvbJ4A7XP2t45fXT/nKWnT0O0N4fj+t/Cf5onVX3qHBvDR1a4guV42e4wk1nbg1uqG8DNuok+JXYy0MhUggpHEtx+fcexrXO4BNZX+W+otp9QUVJqsPb5KeK8yN6BIOTNmR3U2br78PW/eQNFwVMJnxD2oppaME4gwvdwQWq0XStANOOXPzXX9cOs5rQx+ZZgyB8YdZ6RZRtnNd1wUqXdOrJao/aO5BzFzbqa10L9ITC+nUhYiiDb1Te4z5Q1CR31o6XLW9EvzYMdZlST3N/w6av9oNDocksXpj43gTOTNSRuEh7Fm3NV0j6bIIvm1llz1Oi0DResnoXuTqHehlKl0LEiiOkgpQ5brTj6vM+LuPAnAnaRoOZK0v2imMzJvRqyO1wqTnEuZ+mPy4TIAxRx1AkB1gD6XXadRr2Oyid4FbjPv8dXNjkNXUztfRh+tM9JhCI7jtKAbTr7CJ8O6GtnkYaBVG9hUA/up4Wlsi/TVoVelkaoKBQgVWqFzEzd1XwI3IJO6HW/2aw6Zh1mZyG17wkrkNFakjd6w3tSkk4U6UrXL+KV0sNhBmKpUADOmDsSDQwZDmkvNVVJgTxSdcjBrd/auPC/noJLhRqdPjNcw3uXjbibabmRygTGvp2pvCpdQgpKhAeX7jYYktoBypquk2pq7vLZnkNDJ4iv7TjM1OkWx2n4m7C83PVmQl6pJOttxqJh8Qz85fHZu6WhxW8t20/Hx+hagaM42xtPZiWe1HuNlveMYa/pQsXuuD+ZkzxAu78kSlx7aT7QJiZvmxIftEgHNN+y11/rzsX7DSoRWPAFTeguHqWZ/aJmeGsZ5Mu+VQnNjbUmTwdT6+vrmxPHY4B/rpX5/kjwxNz+M+WrbUbUW653kOWi6obpT7p9NkbjK2cZVg4RIrJf+iPGzsLBCxf0Mh14vqcfcbwsteRrwMkoDyIMYc7Q6E1fzKJQZWTZnedMGppeeZx8+sc/w5PGhRcVpE3FaImp/MymM/L7BDMs5h5oyjsVmQIbpDdGoxFT9+G7Pwx4M+0PL/pAf3lOF2TuV5spZ4ngTlaydtG9X6DNJr/m0Nhxf5dErvxDgZoJPFQkza3CaMWmWNqWCAJ1WCnCwK5U3q5Z96Z3sDnJgIdorS10kxCVTlVGQyS0DL8/OrcpZsQmW0GqmHYNlnx3Hqp5onBLOP93pOj1MqmjzZr8mBMNphtcn1bYdvCtDPzs34ZPh5CtO00KibuuJ0avMVciZ3slE6ChqI7Pdn1bsT42SsO1Mwg5cN+r4PtjsGfIx3tg1J6tOc0YEC5qc2qNgT1LAQOFae412EMLcvwpapZAIXgTy6xI1cDHDUl1IFoZbYbzNFYqZUD9YTrHBOF0XANPG6CyzQbO0cVrQtswjYeYKRxVJY5XHxCw32hwsk6sQF7F5HwgCEw5JKnE1P/Pzs56g9L/ma5iSULfTAmoymb/9VPMdo/SUj54/8arb8mG9LYHBbEPU+9tldPYpySIOfTHgd4BDQ6APVSnXvBkaIlJmnwG0MvHM7vnM3/Dt/gUfH24B+PjNLdNDgz1Y4qCL8ySJdj2yutZI+sVG04Vn7YFvm2c8PNZLicq868jmTbR5SDTboAodczAkkEQwU8T2Ab/RjW145pTjdKbzFy1F+SNFaO5zZrLVkmG1P1NEyAoJ+uCencNbnW01Q/Uhl2aaDLGuzgZpen2oHx/Xy5ttolpNdN3IzpuC6NrcnLjuet7YDb1ty28zm4mm8YQgTLucaR4tMopmsrPKfKUO1p5EpzfPz/5oytSB+TqEVVRZotlJnwMBGp32vf8Z/cf2o1yeq2pggejP2ag7JSQt8Pm4W+gSZZJArc50FoWGDO1HA4TkIiFnbtJb7El/1xzwxjoRVjDFd+e0JQNVEMaqYivZW2+gqyeN7LNU1WmsynRjcRG3UU970/TsxoanU1scl4+GD9dbXq22fGX9VKoOAJ+drvje7rYoTnS5xOgk0BhflElCFMahIh5dyZhObcUULJ2buG2Wwbn7qiE0hqGvCMcZzgvWQ6oyTeRxLlvOsH69r3odVDdTAzDzznMxXUVMLSX79S7rpt757FnymwcDJ0swCdPP9fIZaIVKyz3M5+AQLzrbbeahdQYTFDgSmzMwTy49I5TrW3UToQr0a80055tsM8jI7yoeRJ+X4A1sK6ong2/r0mYg5pL7IPitXsfpznBbnfha/ZZaAo9BIaNv/JXOvRsXmH7dTHTNwhF8P3bpof1EmzORlRtxeQdb1yoX82vTM/7a0ytAexO/0H3BMdZ8a/+CTx60Rh0+6+juTRngCBBOjtElutXAph0KnP++X9OPlYoWz7JGc8nCzv0V/bsdE7aPVHuPOebyZhZUTU1FdKZkR74RhluTuTn5Nx1VLy90WkJscmnP9YoIa58CMUe4/TPDtJph5cs5VQdFc/kub9qoE/BdIqwivjM6iJScPe6EMLUlE5MqwVWiqyfSNcQcjbaVR1BuVLjOgzEn7bW09URbT2T/yzi1Cp9PMGbysd9E7MnQvhXcwZVykF8l4lVgMkvfRZKQ5hEoB7NMnI6q29e/SKRnWTdPEsNQlbElRTNxJRATdloGqPpuLsWmUt4FCEG5gLE566HNJeMRVY6fIfp5A0xW+0CwEIuTAZnlllKe1jyBeMcwI+OuFeE2ja5UFEIw+MmSguCaSJWj8xftgdZ69n3D6bSUob52Ffn51Rtu3FnpKzTlWZizuQ/bLTEZYtKe5fM2oydNYJgqDr0tpfFxUORvbT1OYjlWV00M3tL7BpPLfTN9JMxoxzJ0Nk/xThTHrqU7GFtFlS4UikRqI8ELIWuZpiph7kburo7sDy3+bSY17w1mONP6JJeI/VKxWEjyuu60LJ4z86tFQNhMUjhnsdYSaPKm0BSwCdMEzNoTxZWycnLkPUDwc4VisLSvLc2DPmvjTf6+26BOWVLpRY5eBw1f255bcyxCwZ9Ot7wd1vTnWXg9cdeeeN/20zzg86fXFV/sYhe72MUudmZf+gzNSizNdICNHWjNxD40RbD1rz19AKgy/xfHK/p9boDP5YNVIlwtChDh4Dh4VQjY5bJaf6oJR6cSS+ksEg8afdqR0rOSqGr4pp8wuxwyvn1E6gq5uYLrDkTPIdSqhODXSsYGrddXu4Q9qXpC+zirleRyyHYJUWNVZTCG/haX1eONX85vtmQoIY58H7oP5vfm3+aUDG1N5Lbri7rAFCy7vmGcXJkhl4IQBstQO1bNWHoI4udyozDlnkeqEuYJVp8m6kPk9ExP6PBVzZSNXwjQMapUEOfkWDQaV2Tb0gc5HRqIQuoC07UQujmzEpDcS5nnaq014+rGRL0/60u6BOT5dPk6LbJhmkEUntKcjcE7kk1kIM4MfrGDcqFirWVLm9UpbrsTu0Hn1MzyUtPolByMDt58u9dyVOM8nZtwNhQVinUz8kGz48r2HENDlU90Soraval7XtQqfPvV5oE30xXfOd3R2YkXGT0JmgUMXVVah8ZGfDTEJBx9VUqOUzT0fUU6Wuy0rFMSWhZ2WZwXBUuRdLrANI8zylMjpuukvc6ZJF8FqiowTXaRyXLaR2oqz9Eui9SMmnGdA5rKdAM3g2+W9xawyTy0s07L5IZBifLL6/kKzLzNKERRUJQ0i6pIWAlhMuASNvfmwmAXCa6z8WWyCtw+27Oqp6LE0jqPT5Yrc+Lnqi0/V2nvvxLPJ/0t+6bhOgupd24qklnvyy5KIT+EicjvBv6Fs5d+DvifAP9sfv2bwLeBvz+l9JA/8yeBP4bSX/+RlNJvOD1hivadftnj1PGy3nPtem5qTde/s73jL779CgJ88biBcVnIw7MMrZ/RWLPcT18x7KtSliiDGV0q5OVkc2/goDO15o3YjtqvibXDZDX58LSFGHAicNUugz8FZlWFWU1+vBZAMF7Lht0XGXnpDMOtpX/uqPYzsVpnpBkfiZUUjbxk4PRMlfnLPK6sRl5tDdV+0TAMNdoPbJYHO1VKBBb0wZrLFG+GmtOpxo920flLgDectq2qS4yZRJr7Z6TFAZAMJgihTpiHRPswI/EsZjJFlgoycm2CVCf8bcDPvf1Hm0nOAttliadVQFwitksfLmaUork+I76LbniquhIXJZVah7LW+0VCKeTZdgiE1izz5uaA4TwokBzg5OkJoL07vfY68XyGhT+eOmKizOHTzyf9+95he+F4re99W3l+7u4trzZ79rkfdt3oyJ9Z+uqYobBb3xbQ06e9lta/e7pjO6r82KvVlkP21m/7NYO3iIlURa4pMQXLGB0nX5UpCcehVodjFyI6ZGfgEmaUEnTEOpEanbc3jyiavCIc69X4DjrQB0uIorqrZ8Msaxfwwepstuw4/ErKgM53VUmWe1QmuZ/y8ygUjdToKM+xmc76rJNoHwyWoaJ5yqupA+vVUPqQ63okJuH+sKLP1IFQW/rnSSd4n5ZJAikK1iQ29VDI7z4aQhJCMhjga057Hbv6M/5t+7sKCAegSoF+PNPUe0926aH9gJZS+mvA7wcQEQt8DPwrwJ8A/nRK6X8hIn8i//0fE5HfC/wR4PcBXwH+XyLyu1JK4dc7PkCMwnZqi/RPZ4I6M3csD/Tu2NLvMgAhC5GCjlABdOHuMv9kyIMgkzqCedGHLhGvPdFFJC+66rTwZ1TCJx+3MZxe1NqbutGdsYs/C28foG2IjQ6GnK3ag8tiuZABHg5EBNLiKImqzRg6U3ZCiQpAccfAeLOMpYH8kGehY31vjiLHd0eqSMwP+NkOm2JiHC2nytE4XxBd/Vgx7WtkWIaiJpsggtlb/M69M/J+nnNVHnIj+C5xeiWYYKl3GdTxNgKG/hlMeTxPXAfd5F2i7hb02LCq8TunIreHRUopGEgmqbObNybRaD606Z1MSoIwrYVo7eK8OsEdE81jLNnccKWvJ6O/o6A97XzPBcltDjuitIdfJ/Od1VnCx7oJvvE32I32V2ZNTGMjw1BTHRUgEbMSi0jieXPgeXPgY7kFFMr/WX9NYzytmXg76sb4mMWafTK8zpSIY0ZLrjIlZe7Z7YaG47EhDBaybuQ8SsZJ4DSt2OXhocPodL5XE5HDzFfI98glYloyt2QzGKINNNlJpaS8tw82e1Zu5GHQ7PNp0gnd1sRlmGiSQsOxVkcFAcTWMFqlT9hTzhIHyVJmeq/zTyzKN+W+oHzMVJHlyij8tFgnMAkZTaHkJJcIVcJ0yhPs8oG/un6ksxO/Zp/x7TeKXCRBuPbElaF6MMvzOhoGr0OFr/MU2O3Y4qPlV8YPmLC8CU8A/KXh63zn8IzHY0fllh7oPALrYmo/SSXHvxf4Vkrp10TkDwN/V379nwH+DPCPAX8Y+OdTSgPwqyLyN4C/A/iz/0kHFdGIsssPzkfNEy+qHZZlMrVI0qwsahlsnpXFDOedDG6Wm9mpsrpfZ5Lm3LzOmzbeFDRWvc3nMOvJzQr6UVGEoVpg+8ne0dx0xWnMGVYyS6RYoPi1OpfQSSYL645b7yPGpzx7bfYmQpuPM1zbgs6TqMeJ9fJghza941xmc0d1AtXOLJD5O/CjY0fL026lU5+BNBnsk6XaG3y7BAbJJWIbES+LjmKvWQlmKXMkmwibAGJziTXz6TKlITYsE6U7T1X74shm8rxrPB5IQ1Xg1CGj1uzBKtJzLqtIKgLBYT7uYPATHL9vUrh4CgduHkJZH/L04kqFpX1GsKUm6mSGR1uCiBlRmtwiIRataFkz0zZm+kKsnKIBm0i0JQpBDpqdiV+y2sOp4WFc4UQBUKDixF/vHvhG85Z9aPns+6Luc9L6y9WBjRvwyWAlEfPrIRriaMGbAvqxJrJxQznOfGZVpdOrg3dzPEjKTiDN4pDLktQsLQjjkCcJOB38uh+bMnkBVPdzHC3pbOPuVgPORLZ9wzhUpbSNTaWacZ7azkGlXyV8BneZSaXm6qdUJpIn0fJ+tPlY81cKWpmJC4iFoBy7KTU89RWHDMaZguXD9RZnYhl8O5gaHKTaM+Ew/bL2BHjWHPha+wjAtumICH/l+BW+Nz7jcdJr8ec+/xm2hwXFCtpOmZ3b+7LLPLT3Z38E+Ofy/79KKX0KkFL6VEQ+yK9/Ffh3zz7zvfzaOyYifxz44wD1Bxets4td7GIX+83aTzPK8SfCoYlIDfxXgT/5n/bWX+e19De9kNIvAb8EcP27X6XOTaVv8JeevspfkY/4+c1rPmo1nf9dL1/zV/wrpocW2xvCnFKtImIS0SSSnfs+WpGcR7AXJXUvyGCRPAKmnIvo+41PJeuq9p5YG8Zrd1brF2LnICQkJqqdZpR+peVDBXzM0XvSacoV+A30z+fv0zlSCpXOII0NjDcWO2ZY/vkYm9w/WuDJQNT3qep+Wn5zSLBVeSA9rva+/OjgqSpk6Vjlfklgkc5qA6YNWBvxoyXkJpg7aKP+jMtLcgnpAr6OHJwrcl+uV3L4dBOQbs6s9TPj6Ai7qggDp0qlld7h7rVRQQFBVdfNDMroBSP5WlQLUMQMwkzdmpMbd9QsWGIitLncF1WqzOQyZXJZTNZphC9pIekWoMIZFcCvIb1RkE+yZ2CTSbPJGJYeESjE3/Zaopx7e/2u4ZP9DddNT5tP+nlz5JvtG75Zv+bj6Rkva/3ymAzfPdwyBMfLTkEhHzR7jES+GK741e3zoiASE4iLBdQD2is7+pqIKN7jjNgbrMF2oRCV02iQDHNPVx7fLj1Vs/JYm0pWHaNhqDynsWIcXBntBBCDJeyqMrHBrnsqGzgNtb5eiMpJlXlGKRSJWWEk1jkLv51lagzN5456SxHyVgFwg1/pkzZTK4iGmKsNpUc6zeAWS+qNTlIHPhkcj1cdTTWVzWp13SMCxkROTVM4Z0TBB82Kf779AoDWTPzy6St83N/yZtjwl7/4CIDD965IVcJeTQz59+7GhufdOev/Yj8RDg34+4D/IKX0ef775yLyUc7OPgK+yK9/D/j62ee+BnzyGx3YmVgkgAC+ff+MEAybauA/f/stAKrbwOfHDZ9tGy0x+aW/koKBIMum1GTOUAKClE1VvPbWkklMm5k7lTe8veRZZPowVZ9vwVmqp7rsyrG2mMEjvQcr+Cs932mlvRw7pALoAMFO6UwlPiPfWnWMdkrY/N5po+NlJgPRplK2FLSEpk30+dFTAExsBDuY0luzU1bPb5fRILFR7kycrFZkZrUGp+Th0CXiRssh1y8O3HS9jjI5dhxyedL3lfY27FLW0xNLmDqSniX6qwV2aVeeq9VQmu3jribsHeIN1ZMppVm/EdUTNN9HfBbVV4z1olYCpvRC59ckI+7MoOdWStAGhmujjnHuvwxAUnmw8WopC0sUHTEii3J8uPaQBLe1pQztV4nhVkiS53XNKvPzk6nASj1mHQgGxjHLcc2vnyxfPFyx7ZrCizyua17WO6ZkmZLF5i/0ybDP5NwXTZZ+697wZrribb/mk/vrpRwLxMGq5mJWyGj+/+z9Weita57fh32e6R3W9B/23uecOtXd1ZK6pLYk5JAY+yIDDk5CCAHdxMa+chKBQzB27iL5JsEQga4MhpALkcmBOLYIAfvKBguUgdhWLDuR3WoN3VWt6qpzzp7+wxre8Rly8Xve5127NKt3d1dV7wcOp86q9V/rXe/w/Kbv4IR4PXrL5C2XXj4rBI0xkaadCkDi3NcMusbUAVf50l6Mk2GR7izOBSoJwCMJEfl8lBNhK491nuCuVGeStMWUEh1QNa2ADXfKBqNXQKew6GxOV+COnHQltSZ/Sa0tZjOuSU90EBagyVVKrUeFmqV9HLJiUBoMl3FDV8XiV7fbDNxvemrjeV9veK+k7zl3jnk2XHxFkxFJL8wZpwKnueZ7jy+4/Eh0Zc1FE/ai2r/MVG/qgRf1ikj9GCvxSfrqY6x/jrXdCPDvAv888Gfyv/+dq9f/TaXUv4aAQr4L/MW/2wdrxBZjEXSt3QxOtNIWNI888CmbMq6zifhQSd88reim0C6yUAKjX16X7C5JFrhZ4IzIXC1p8R7LQILUVqjJo58ucJIb0lQVqakgJeJ+w3QrWdy0Fwdd2yma5w/RBG6OGfIu/71A7Rf4PohWYKjXQfey1EzxabtWFUFLNTMfFD7Pc1TKgXUvencgyMJF3zJuZbMFMDqhdETrxH4jO8KrrQz6b9zA+3bLXwvSQR4vVgisFuIicusS5EQiRVWyctd47m8uNNbzel681wy6Vxl1cxV4EBkl26myscVRbEXCNqCiKrM17a8QcUul2krAipV87jLDWuD6QrqWvzeDvDa8Eq1LdSUUrR6cuBXn11Qb8uuG6nmtoGOdmG5lLrv6d+VzoSkbtt54bu6f6W5r+mNd0Lg0AT8bTpdtCXLD5BiDpbUzh2oom9Rxatg6ccL+TiP2SU4FnuaWh65l7h30642yuDWrDJByJqBJAhm3fp1f5WAEMGYFkhgVpvG4LOAdp4VorAmTztJt+brXgWmyxKCJo0EtWpeNZnPb096sApy1DQVdmXSiPubuyRKAzHpPh1rua9ND805hpvXvbL/e2yDXOzqpvJYqGCSYqZiNShdJLL0+Q8mmQqdIWZA8eUXI58EHw9ZOvKgv+Kg5Z03W4DUpCjjnL3eSp9/bC1+NN/zwdMvj+10BNcUmoW8n9ru+qBP90v4tTn3cGRp8Qjn+lpZSagP8t4H/ydXLfwb4c0qpPwH8APinAVJKv6KU+nPAX0Ekbv/FvxvCEWQ/e1lfSismJYVPmkuo+OF0B4hGms4QXIGH5408gJqlfVEU9G2CLCVlO5HrWd6btMJvVfFcKiCLrDow3mZ9Rq1wzyNqMGifD38Yoa2JNxvGly3DXVYprwRBN+9FpgckYOmQ0FMiOlOs3lVIGFbk5bKEbyMPZLrK/EMtyL6CCJtBd5pYid388Fl+IC9iMDrvY+HjqVoQhsYFNruRmyyqu1QItfEcKnnNR80ULVYHDlVf5HqGqiVZIwnAPvuDuUgMithb2UTq9cf0k6PLLSk5j9KGVXFFpC2/zZ0U7Zt0xS3LFWYQsMkinKxyi7VAu4HYRvwm4G9zwrJk+zYJfWPUxKcsplwrQiMOx5u7vlTs3bHJSLq0thFz+06OPR+ryq3jNpLM6lBgO0lEkkmlKqjqme/cPGLvIu/vtsJTAyoT6CbH47u9yD8B3XPLD/oK6wIvb84FwTh6W67Rj8ZbAC6+5q88fs7T8xYmXToUy2+PbjVgjUlhdaDSAcW2JDXJJKwVb7dFrWTuHMpFoomyuQ9Lm1aeB92v/nHJauZOULgqX0P5EM3QV1S1p3IrWqmbnLQrbSIs1z7lZ+8Knr9UuvYsCNXF8DVpAdZI61beswQ/6Vys9JDQ5GclUPYGlMhjLQawC9ApbANq50mzBG2AwTqep4bKeMZgC1oTBJA2eMuvPEtr8bbq8UkToka7iL/PaM6N5/72/IGx6xgtXl1lqZ/W735ASyl1wIsfe+09gnr8273/TwN/+u/3852O/Hdu/4vC8/h/Vn+QH1zueBzEpRfgs+bEfdPxpt4x7gw2K4hbG7m83aDf2g+rGGSuZIaVKGkGeZBUWmdofpvnUf7DuYm4RBuoLTFrNqo5EGuL38jcaEETLiThebvavFTnSHUU5ft5Z9YZlFPFUXppT1ZPiUpJ28VvV5PQBa4+b9P60F8U1RPEGqYbmG5zm6pREnRuZjb53MSoxdjQRG7aodhcgDh9W7VCiofg6OaK01STkmLMFRZVZD6A2npu7yTrVCrx8PqAzfJJIcezYiqcFClvgjhpj6rcAl4Cc7HQsevvVUFmYMqLYLTJUPpkZVNLCuJdrhbagK4C1gVSoiDsEgiaczAlMfA6FQL30FelhaYeBWEZaoqdikpKkIBNWv9+HwRNGxTmZMo1NiNUTwq/18x3uVVtA52v2LmRrZtK1bWvRnaVYfK2GM4qLdA+5wL7auSzViL4m37P09DyG/6e/3yQTXT2RvQik1wTlSs0FfL8z6Tyu8bZ8jyJA3w/2xLo2kpsmSoT+JtIojhfHKmzTLNwzFyupJKS3x0dZDYNetCEWSx74mIACqATcTCMcW0XDjoRg8aPRo51maXeRNL9LNfsXX6ucjt56V7YTJQ3U0aWDmmVmWsUaQtKy7OxWM3MhyBSV70pVWBokjiyuwSTRvdL1oI4UAQlfX4g1oE5GI5Tg9WRm43cfN5rrI1olUobeA6Gm1qoETFBV8vr1ga21cRd3RUy++v+wKsmZ9Qfa6VPKMdP69P6tD6tT+tnYCU+oRx/opdTnu+6t6Uae7/ZMUXLbwTHcRbk194NbOxEW88Eb8rsxwddWlFLFRO2UbJNL8LAU2YFmGXeYleipvIKMjrK9YkqS1KZIZAqTbQrDC80olZupoieE65bWpxSZSRNyURVSOjeiyp5WsEioc7iuXado9WnKJJCG1VmBMsyo1qNLJFqRYVsnTKAv8mzj41k6cam0i6pnGdWhhgVUzAFdBOzysFM4nnMVjPeYE2kMjL76C9XavtekaLjWcsg0NgIXjiBUtlmAImCUAcRcS3EMCViwy6hgsLkuZY7SVXbfZlK68p2GcyTOUlLhRTqfF7Vym8z2bajqnxWvJeMuDvVpNGgEvjdIiMh58weDelkWOzE7Fnmk6GBLJhOiiLlFF6NBd1nKpF2GnsHz+vjqCJUJ6nqQp0tcI4tIWpuNz219cUoMizqEkGz30n2/2Lb0dqZxsx80Rz5dv0EiEVMSC85jTXnU0Y+dhZswm0nUtAfKHpwI2i9mBVMjrrFR41Cno+lQqutZ+dE+HvJ8NVocE+aUBliHct8UCk5b+kwM2Wwhz0ZmVvW2bB2AfPYKPPUzjIv7TUjZHpGU+TgQCphZWQ7XixldObsLcCj5VlZBQ9S6WoshPulNV9amXVE10FAVZnHtn954cW2o58dj6cNU5RzaS6aNNToRCHZL5XloRrY25FLWDlrzgQ2bi7djIhCq8SX22fumo7XnYBCLlNFa2c+a848THJDDd4VLu2nJev3QEAL/Pr8gr85vQLgr3Vf8GbY0XtXNue/3H/JMDn60eEHy7vLDQBq1NQPGtOrArn2hwSbIJt5tbL+kxW5pus+u5lAPyqa94nqGNFTBlHUBt8a9BwL/Lt7JcaAmzdQHX0hYQu6UTNvV8kcv9HwskEFmYFVp4yqnDIqz3wYuFQQ9XCd0YqQlUZm2XgXqa5o84O+zH0WzcU6YLL0ly96egGlxMPrMlT00/qFlfU4EzlnFYkYFXe7jl/YP/I0tbx/L7uCHiV4qrMiZp8138pmFtqE6lUB3CUjJFStI2pxJ9EJqkDVCDhhnsWuw3fy+/02lfZvXAxUlcgELuof082iBE+xHAnaiTdWI+3RLtvdpF5sVFITsBu5GNpE8YYjtzXzDMx1MouxAyyQvtnXzLuA2c7YjAQ0V5qF8y4UB2I958QoUTZt/1jRq0TtZvrZ0udAe0YIxuFi8Tu5Pl/sT3yrfeY0NzzNbdn4pijq/ZNfW3UEJRByJ/qbMVsBpSay2Y4YE7nk4KdVwpnA5C3zZKlq+dzTUPNw/gLvNT7POHWncSeF1TAfdEkiYoaf3xwudPkeGVSLmhVp52XWuLRudSJdNGrWYgYLEgxHafMtQVDeDHHIVjfbjDpUBoNi3i3PQD6GYuBqcAs9JZ/zxR4oZvRjnDQxAX5Fe962A7+4f+B1v+fxtCngMNNLYktc0cdzZehny5CpQ0vw+mx7ZudGjlNTQC5aJVoz84d3X/G5feb1jexFf+X8JZrEL7VvcNko9QfjPZsrndqPtT61HH+Cl0+G//vxl/nLT8K/7mYnVUTUxQ/qfGnyPCiBV+hsG68HMSa03aqeMd9o0taTakXQFNa/1hmMcQXTth007xJ1lm+abjJs2YkOY0TT38t39a/kYdu8Fd3FeZ8rt1o4aHoGO65V23BncNneZMk6bZ/Kpr14PK06hAItH5c5kRFX6WRYFTLmVQdvkfsBsFWgqj0xqqJUcMjWOSErThwXCaS80Z4XHUfESsaoxBBExmixylBRZaQoXMlLFERmaFbzRkwqNjSLAsOyto081O8y1cGfHDqoXJXljTHbldgB3Dl9oN8XawELLHY5YbT4myBWKVGTFssQnc9J4sOlE9HKMZeZ6rhSOpp3qvx7eKkYX6pyzpVOpCSAETLtYzk3izddmb06qT66oSYlivNxuDj0yVD1Cp/v3R9uZCM8jg3OBJ5yVn8cG96exCB04XoNaUUgmioSb7M/mo0cNgM39cCQ5z61Edj+188HmWfmc9F1NeGxRo2qOHUvAVnPstEvBrSxjmzbiT9w975s8n81fMZ8XB3gFx3QNIN7luotvVztxeO5LkjTArQZFWFHrvDy52wgaE2ssrZnvNqsM0VkiQmuS/Ce0tHw2f5PjxoGSWz9Tv7++bbhtKk5TzXTqcKdV+pAaNKHwKykuPQ1P0LaOU0Gt3xn/0hrZn5zvOW5k01jU0+wg1f2xC/XX/MHK2EyORX4jeElN6bjhZW52ev5QLdkZh9pJT4FtJ/oNUTHr59fcc7tGZM35NkbumG9GbZ7IWuOjWXey2nxo2VSlZA0lxn1pPAXQeCRKByuRYg2WgoPzYxZ+DdJC2Pe5LaCUbg+ElpViMp+I47JwSnmrWXKhOJ5q3LmmIrcUlLZqbqRNsqiEWlGGXBPO10qSiFOi8TVdHPlGuAi00ZDFYvrdnyuMpBB2j4qt0zqZi7Ba7nZa+v5R25e86o6cQ41f+MkUPxvLnvOQ808aUyW5Wkr0bv7zeMd574WbhNgZ/Grilct3egkk45KpLKW1lMJeFCC6jg6wtkx1BXNdkJnRGSsHOYEdlSlCgm1fFd1FAX9AsluFPNWqqBrI05sxLqA1h6VW9DzbBgvFQwG/5zvnToHotz2LMeYKAHO5Qo6abAbRXw2pOOqd5gyP9BkGDjI3/oW5kMsrVCqSOwtw9lBHVF501aZTKy8KmCX0+OG38wglJtNz2WW4z0ONeNQoU1g267I395rUlDU27EkCJUJ7CqRmfq53RMAt67nP3v/bS6PsgHPmVitlAhX6yQgHcgE9fy/bX/1rChDf5Hj+e5OKKbjK8v3ucePVoKZWlqO8mygU5F5MibSV/l5HtZnU0UBWoRakXQGoFS5hak1sU5XLgsCvDEjuE5+Q3X0jHeO/k6L591yiTKHzZ0UOncoTocN7zY75qjl+i+dBJuKgecHDhBB44OhsqEgTq0O/PByy7vnHfNgyz32dXvgP3c/x1PY8KV7BCjw/Hd+z3PuYb+dZHzyaa3r09n4tD6tT+vT+rTK+lSh/QSvBIVUDRRB1nDVLqnqmV0z0lhPalQZtl9cRT+IQvzCa6meFNWjFaHT7doi8hukt2/TOlS3kv1L20sx3OUZTQ3TaIiVkHWBUknMGyXcstx/F8fdlKvB/NYkVc28kQpwmbEYl/CNtLWWGdqShepZgBHpaQGhaGITMY2/4kYl5kNAbQLaRFTm3lkdqWxgDokhz8qe+oZ4o9ibgTFa7uoun9/I0Dq+Oe0LPH/yi2ySYxrsVdWUJJtWKy8r2UTUENsg8kh2bc0pJWTuIpf0rmbztSG0lv5Lvc6E6kSYwF0Ui6ZtdIk4K0KthKp19cwmI1V1OQaXICq0Ttxs+lV9PjXMNpImV+D1sRbenpqlvamXKi0t53ytLMc7VWZ2xQ9tyD3iRX1kuQ/2ojgTb+dyHVJnsc8CSpkPQOY7pjrgTSKdzCqe2xvOcSOuyjrSa7lux9OGcHSERuOzYHeMGWKeBLCxuCD7pOnmSjzvstXSwcq/1dmCSoQqtyozeVrPaiWHz9KZWGaUix1RtIpxMnS+Ko7Mn2+OnG8rXr+/IcSEa9YZpXci32GvhHhVE0jGiEhz7kTqSe7x6NQK4mrE3UJFBDSUL4f4zwH9es6jUfhaibrOlkKHUV4VV/EisDyY0mavtxPj5/m9RydAlKiKSg0u4ipPAkJURbXladrwOLRonWi2UhVvm4lurvjLT9/m++4F392/BWBvBjZ6YoiOU8rz5mg+unfZJ3Hin/A1R8P7biuIRaDZ9DiVUNQFoWWNcEEGb8XGvssggIj4O7WpaMPZbiEuZ6uJD/yvMocmK4XMO4XtFb5deV/yetbw06xakIsSSZ3ltRa0XJdV5p1a52FZLio6aSVmLIQ8RBVM+1T4cmaE+lFhhoTt1VWLNJPAhytxxzZg9nOGfyXqWja8TT2xcxMRxTlvKk5Hzr7iP3n+Dq/7PVuXVd7tyF3e/L7/TuiFx9MG60QVv9lMqHy8F9UyGivAjUUppErQzlSNp6nFtBIoau8xqcK1knYdq4/VuGoFxko4bMssY5lv+s3qMgBZ329B1i3XYhLe1Dwbjn3D5SjnKPXC1apOqih9hDrPhtIKqAG5NrbL37nNHK6XifnzCVsHpqzn1/5IkiUhh0tbGKTNlvaeejsV8NI0mNUJ4Qq0o+vsZjBq1JLc9Jo4a6ISrcvLopCR28rxWh/SRCGMD9IK/EZLlrWYtB62AzHPHJ0OvGg7vmoC+mJI+Xd4wJ514QIua9on/F4C/jKrmneJajcxBst/+k4UMuaoSUmhTSBqVVqOxkRM/sPlHphGC2eLPa3neFkqIEjTPMdWfUa4+hxgl/eq3KK3cMkCAuqlKbzPtHY90aOifi+z6im7WOheczy3AuJR0BwkQxm8xry2Mku7l3PcHEZe7Dqe+4Z+rBgauX+tjtw1wjlb7K1e1BcuvuZh3HCaGx4meVjuNxdeujOv5wNfDzKLO2aD4k9rXT/zAa3MfPIgdiEmLiaUAHXl2bmJ41Qzz0YCGQjSKldDS8VzTUw2g1r2wAwNFhmndC8PoD9o/Mlgu7UCAYpGok7X4I1ErBTTrZKKKltamBlQMlu7nv/aIaF9lqTK1IF5L5tzdBRB2zhqVFRYp4q5JGRo/6jKRgpZ+sdLpm6ryN02Z+X1QKUDlfHU2SFXiKItP3i+5elxS5XnMdt25H7TY1RE5/lKGEVk1zrR9Fu0/sx95FI3+GFF3FXbiW07ioSWSiURWb6zv1RlBsc20H9b5iumCcSFEOxVMZlclDdcrqhCA8PLuCI4g1S5qYrrDC66QiYeBwdHlz9LUHWLQDAs0ll5nhrWTdBMGaSTIGUUqVibKKp6JuMD8E+mAGOioajMpJ2X6jmpgvjTrWe6l++q7gaanHD4oJkny9xokr82TwWfLGOiyGSZQRG2keYwFhFiHzSmioSgiJ3lmH3SQBCuQ+V53ecgFw3HsUFvPDEokcYig2ESBfghJ1Kq3aQAk5jyBm8OM9YGvn4+cHnOCFEF1UZuTqVTcac2JrFpRposXAwS0JSX+ahKGfDDmiQu10auL8WsVUXRJZX7IWGmhG814+06t1RiQYe7rPJmeob2fcRdImaR5NppxqrGXjRJJ4ZlxhsyzaYRIQKAXTtSW0/tPJUNfPdGqq5X1YmA5nRlurozI62Zi1/d8rpWEa0iXw8HfvX9F/JVUXGXwTofc33iof0Er8UMcFEF1ypxmmrm5xqVM/qLi5ybkZCzxIKwikog5LvIaPJrLmUhW4WZVAlOKJg3GRyQd7VFDDjmYLQI+0prRDLEOaOm5r1IXIUsvVNMB7so3llKrUExCTBE+4SZYdH1DlU2JdUfbipAMZEsbbVKgugi6wNS4aXOoppQWn2QXb+9w+rInK3iu9nxzbznfGpIo2ExGAje0A01zq0+ZdoF4mDxUdoZc96stu3EL33rzQefa3Sk947LVOGDLsahlQ2MsyVmV2T53LiiAtXqpi2/5W9NIhYof9p5VEbTxUmD15gmlERGDxLUZ+2wrSdlmHTqtWzccUWWEnOlbDLke2l/BblOZlr5SKZXzIOmN3VRO7Ga4po93yTUC8nU725EOeXS18y5dattZPfFmcZ5XmwuzLk9cBwagvN0JjKS4fUPFnsR14AJW6D4sRJjzdtdV1rB/Vn4ddgk98vSNq2jSJFFzddPEoG/5iCiwBpwiZRvsKgVtEmcDpbLoOSzzEXktGLWAdUmiKpKUEU3MmmYtJN7e9allAo20jpP6+aVGpLWbsh0WOks8zYJL9Cvz6We5TlbNBazjyZmli5FWtDJrFW8CoKELfxOlwFDig8AKCob1OpJoV5X629WEJuEdYu+acSoyMvNhZ0b+X3tO3ldRR78lj64ErhG4xij5WlseeqbMiL5q/pb9MHxvecXPD5vl9v64xt8pk8ztJ/o5YMRjkd2uH3T7XnzcPhA8Xw+VrwzO5RKTOeqWF5gI2bnUY0v5EhAKoFoSSZhMq9LTDsh2bhCg01ivomoqD/IXlWVIevTCvN257UdYqYV9ec3mnmjmPar0aegGWUWERpVfoc7KVQyhCaW1mL1rAVhFigBUw5CvsPfz4VT5U8ONWqSE5mhZUYwhUVkdQ0wszcM55oUFe19X5Bx/eQYB1ERb/KMRptE9IqUNCFB1Dmr3w78Ey9+g//K5vt0mQz3l7uf5//z8B26scJ7zYuDbOwbNxMT2PvAJld4IWpOXc08Wtlnlqp0I3Mc5VXhPi0blx4VajBrIHQRqoixgemYtRFPkv3PxhCrsFZuzlI9apqHRPOY28qtlhGYz3Ja+TbxrWyYKq5BVsi9inSxhfOm/KoV6F9NvLyV37utJi5TVYwzQbh/Xx6OfL458qo6cw5yvG+rHc9TizWRhxyk0qOVlrbNgX6xdGkSxkV8MIXHxtmhJ7WiKa8TkaAE0bhs5C6is97mNcpXzUJyJyiBuS+/WeW5WqIkV3ExDs0tfXlRkXojfxDX86hNFKuY2ZX5bZwMJqM6Q52Yl4JS5baiAbV6kOI3KmuvrpSLaHOg0qtNUtK53e/ltUXcIO0U/UtN94Uu7f3pLhaXcntRpTL3myRt450vAW3yhm6uist2l1si51Dz14+fEaLmRSPX/ehrvu5ueOhaJm95yHD+fnb0s+V0botGJEFxXpTJPy3g90BA+7Q+rU/r0/q0/v7WJx7aT8FaMiOAN887wkNNNaxVEEkUMFKU7F33S0/dEFyi3o3UudowOjI2ltHWhFnjc6/NXjJKzGtU7oFUtwN+Z+i3lWSwi5yPFyPBUK08qcXbjKWKyq3IWIFvBViyVHM6IIoOVZ6rLWjNU0Z5VasCdwalyW/VfIBAU0lUvA97gZ899AfMs8bbRGx0aXUZlbBGxIaXasHZUFBynx3OZbb2Lm2YZ4OfTWktahNRG1EgZ9LC3QJa59noiV+u3nLKw8m/NnwLTcq+WKZ081s7c9sqbqq+gE5OvuZNtefNccc0upVPp0B1prQHYQXkJJMgUIRjk0nl7/AL8GeRO9OEVBcunOsU7iIzmkXFf9qLCoXtFSolwiJ0m22G9LyS21Nu6WmvV2TqJPM+fxto92NpV7+/yHl0LhT7lV0z8uX2me9u3nBjO97k4alRic5XojKRydLn24rkhHuVbFpJ8nXA2EA3OobMBROeZJJqy68Vf5GwCkpaiXlFr0m9QeX5LOS22yTVVXVckZ4CmJEKxufOx9LR1K0XMQPAnx1q0sJ/3IRCvq8rX6S9Fh7aWAdia4i9EOIXAJUeZfalp1ReG28V0yFlft9aMcc8g7PD2lqMVhGcODQkvSKFQwX9F4n53q8VpdeYk2HhmJa5u4HUBNrdWFru3VDRDRXWRvrNqqjT+YrX5x3ORHzuj4/e8tw3xKio7FqdX8aKfnTM52pV6laQin/Px1u/UwFNKfW/B/77wJuU0h/9GJ/5eyKgwdprnnonrYrs/QUyM4nZTEvPqthn2A5mLLMLtLVsojftgNlFntqGS18zZcTdbAXZlKpInSHHL/bSRnhqWvpLRcrkyWQSvon42xXNpbxo6CUloIMqe5FxVqUvXyDDOgNLcpuzQPQned2dVnCCbygmmvL78meQwRMnV0iqykUhhbaBqp4LPP50adA6FpQZwHYzcn+QQBiT4pjVwn0wRRZreRiNiZjtJPJMoymb6+gtv9Z9xl+w3y2b8196+gXeXrbEqKmbuaAnfVYk2di5DK2PU4OPmraeMCaW7xsGR1hkrBYrnyoVEnPa+2K+GLwkMjHo0pabb1JxRxBPtSVpyWjFW8Ww2NJkM1O0kKKXuZ0ouHw4t4TcAnSJmAFqfvHT28283F/KzOTUNfhZ5KViDgTT1vJ2s+MPbN7SxYr3k/TafnC54+ujnL/Fxkd9kei6WgJ30EWBo6pnjIlMkyVlUJSQwMUs053X+z/MomiS8txtuXHSaNCdgFmu76sFZFTk4NTyPMl/2yVRHKyAdjYebdY2Z7IJs5up65kxm7heupquqzE20GYQTN3MjAn8XKOfVjJ58y5hRwlIuRubvQAlCYx29T5TUdqK14IFSoEN8syEWhGWGJ4lV/XGr4akvSljhlmnspcAqFHTP7Qr+lInIcG3M6O3/OB4J9fTG8bZcgmapwzLjHF5ZhLWrCjfY9fIXjOvLV0RHlgTjZ/C9X8E/tfA/+ljfeDviYD2/rQtN0qKitREYkPxMKqeNaAlU74y6NRei3JGUgUleahFyHjrJn7EYTXxW9QCIgznrMrgPJtqRutYnK8BqINIHUG56bVO7LYDWkeOpw19ndFfUePOYPQauEKtsH1CDWIMWTbtVlBs1TNFrWGBIGufxxOLIkclkk/X7sTNZoLNxLaZmLyhfy8PmXu0IkelIbZZxssFdo2I0V6udBz7weEHJw/xAsVPUFUSJFO1ziPPfc1vXm6J6ffzehAU3VfHA+euJkWN1pGHXmYEMYlk0NfpwMNFXjtdGpwL7FrxY1tyVe81wST8LhZAh7Ji6aGrwIu7C6+2Ih/0zWnP83FDDAqXuUCx9eXSzCeHvqyqHr6F5MC3C81A4P4hKEJlCsLOnRXVk2yYc4btR4Nk+C5iFti8SmiV+OzuxB+9/5oxcybnqEVB4l1L9ZiDc2v5G/oVjZm5cQOPGbb91fHA5SKyMdf5ulZJznWicA2n0RGjEhPNZRYTFdor3FFTHdcArDJBMJhIWt6b/dL0lG2ScgC2naAqQ7NSDxZtUHeUKmqB9It5aq7MchVPUKDlXMSoCeecYHaGqBN+E1A38lZrA8YF5ioSjaLK1W59knvU1yt6WHuonhU2Wz2tv221DVpUeaKVSjK4VehbjlfhnmF0NaldeJFZvLsO0nW49jibFPpiyrOiG48ykuBdhqokXptmZFPPPJ9X6kxVCW/Qe8PoDSHvWzHP4dGscnD16or9sdbvJA8tpfT/UEr94sf8zN8TAW14rkXBfVlaMs60QGKz5lw0wGbVD0yW3FReNQytCgKrjbpAy+XNCj1oMQPNX9XVgUMzsm9G+qpmoYVWm4kYFWE2Re9vsxn5I6++4b668Gu7V/wNREpqPrZUz5LpfgDoyIrg6aqNKGaR6QMh48Ww0J3JLaD19ZgNK5dgvW8Eym115IcPt9JSQTYkv8nVYK4snJNW0KKkvzykfrKoh+wFlqHz884T5oAyic1mxK00ssK/WVCOPuriPzbPhoduRY+1m4mnBN17CWiqNwx7ESbujCvnchoyuKVK1IcVHTBeKpRJ1NbzMvtIhaiFbNzZguy8v7mwr0cGb3lvt/isq6ltYBocaTTYbZaNAkJnUVWUPXleUXsLp3ABLegA7p2VTTMjS8Mu4l707KqRkBRzvnl2buLZBeZwnYQk0mz44emW927dyHzMDtBny/kxlyZbTxqMuADoRMwB2DsBLanpw03L9Ir6CexFyO7Lb4hWOrRLi1ZPusg7JauKu/sCjw/1GuxjEzG9FpTusMLpk5Y27Hx0q7SZSagqok2me+SN3J4UKmrmoBhzEhAqJfdZEjJ7lSkuC19TOGe5TXxc2r184GRtxoSKiXmr8TmeCNeTleCe1qDozoDSTDe5et0GzGGiaWbpCGQ4v9KJZMVt3e0lQfri/ogzgW52+LAGqcZ5FPDi5lLksLZuoveOb457hr4q96TWEW0ToYqkhWNaB4y5TmE+zkofL6C9VEr9J1f//WdTSn/2Y3343279nghon9an9Wl9Wp/W7/h6l1L6x34nv/D3REDTJ7tacGyy02xU8m9gvNMyM7F5gL1YjpgMd+8MT+fs16VScWAeZ3vFpM38tH6tTJSOfLl7LnORxU7F6MgwOYI3QrIFXu4utEZEfLu5Iizq5wvnbEq43J80C6m6URmqvGbJQJbUyllyLar6PEub8to+ZsnEl/lia2daO/Ou3zL2rowFfJuY94l0mDncydzs2zfPjMFSGcOhHorj7oNOWTAZyNl7MIbUGxJwCYrtXlL1pWX5G+d7vnqUftKcFS20CWidSpc2zlq4S4kC3tCTIvaGcWqzj9V6LbACVV/mLiEpxseGMGne2W35zd3kCCeHuWjmLA/VN44QFf1YEbxhm8WJv3U48vay5elp5QGFi8McjcwedSozpdAmBp3BEJuVs2avhK4BYiMUiffdlsE7xlypjrMlRkXaBvw+O1Y3HqUTz5eWs6nZ53lZjBp1sTSvr9ybbxVqVtSPStwZ8r2uM0UjdrZUQULpWGdL5diybJWQxtesPbmIqiOh1sLjQypTFXJHYLkMF4PtZK4W2lW8WU95nqYMfpe/cO+xlRcHZ52VSwAdrKjzRM2YS3u/zxxR9aHbhJmi+Mc5jZkWYJdUnPMWYg1Wxtq4CySjmDequGMkk0UUarlWxddwFFFrtCpc0pgUxkTaapYWd/aLS16DjdSHkZ9/8QTAHzq8QavIyTdU2hdB4a8uN0zR8IvbZ17W0jHog+NH3S2V9YzKrqOSXLnbxheA2o/PtT/W+kSs/gleKamsRH71okZmAkt/uo2C4goKc1n5adElkgMUokEIvI073qkt3hui12vLUaVC6FyUN/xseBw3GCW3yNLa6yeHnw1xNPiM3LpMFb/6+Dmjtzw8bYtlyWIhUj+tbZTS5TTIJpk18kTRXKS1SkC78cyVYTqbwkWDrJowQThbzlE26O+PlqaRgXyadJklhh1sXl34+bsnfv/+fT6FiR92t+gq8kV74o2RvtqP9G0JOEXLLs8WURDnFbloVOKr8w3vnnaEp6pcG7XxaCMGm0sbceglGFHFMoBPi91KRL4z+2VtbnqUErL1vpFg1M+OkwZmxTQ4jtfkcxtJRhf+4fndVnhsgyFVkSEDF95etpwuDXGwxGUEtsyWTMJs5+WnSwtwFu7g0sFRUVB/cRsgt7VNHbAucOpqnk/tB3zHqvFC+M6HGoImTUrAHBH6rZyzOBrcSfiGK0hDtATnvdjwsMvI2+xfNuW/k/OoCHuYzya3ivP3takgc0tbOwroIdkkHL7M0RtVEiNSvWqLupMANvwGptu15ahn+bikWHVPO8PsFbOR2ataLJzGjCpdgbvirKATnWpI1pbfLChFtSZUwFzL8xDalH9XTrJOZIuilZu5PPfF9PYk18Kdxbpp8lcbfQI/GZ5Tw/zUYJ/XVnPcRNhO3GQ07q3rGKPlTXCEpDhYuSdftWdaM/MHt9/wuX0G4LW/4TQ3vLcbUtTMFwniahJFEnszcZPVQULUHLsr6bqPsFL6BNv/CV+J0Eq/H7JixqOVh2rJpjdRZmqj+WBwnGwSbyeVM1pgOjkhx5oklUC9QL417izacst3TRfHDx9uqZzH6LiSkvOcRblY5kWnvhYn52cnz9yiZOESqJzlLhtNrUDLg5o06EX9YEiZlL1SBHZ3HWPrmC4bVFIfqCKYQeEMhFwV+UFzck2eZ4QyJ9rvev7Yq6/5xfY9nzt58N75Pd8M+5Jt3jg5CG0icZnxLbNIk8+jTpjGi+cT8uA8njaEp6og61IjShN+tIyKspmLD5kq4AHIABWTUKPYp6QMb//y9sjeDTwMW7o5V12TE9LvpImdJS40DBMLWGc5Bj0Igk9PQlyfsvrGw6lC9QYzXBm7GlGsIM8Hm6zwMXvDkBOXkJMhBgnI+5cXtvkchKgZZsv5aQMXK35iyGY73ioBEyxZ+qxh1JhOC6LyyZZTAwJYWaq/UCfiLhAO+Q35t42dQ9skxOb8Xt14ktPMO4HhF3k3nYnTaUXx6UnhHjXhpJlvYzHdVJuAtwk1a9RpAVmAqnPVFvIcClHhmPeZjLwkWLPGPpmsM7kas7rzqqiTthKlts3E6E2mriSGe/kQX2flDr8+2/NOMd2ufnU+V2PzQUAsC2BKfjBFBSgeUqmsxztFUprorlRFvCI9VaRO057Wufm8FyK7ny1/8/kegMdxQ2tnxmAxKmLy5x7cwO9r3/KH6q+5NZKVGpX4S3wn61pGVJ8r4FET9mFFhSIJW0mofwqXUur/AvyTyKzth8D/MqX0v/utfObPfEBTCtLeF3a9OVqqRxkcl8wMLV5l8cPXUx2lRROEdwNyYyWbUDtPuxupcoX1HLeoaLFDKgGtem8Yw4ahFodjl40pY1S4ytO0U/Fn60eHeqiwJ0EtRrUM4QXKP28V460c13yQzDk2KbdHM6dKSUCNFcVksbJiRno5BFQ0ZUi+8NP0uLbqIggM2Ija+ee3JwC+e/OWP7B5y43t+CIHtI0e+b57yethzxgsJ78IOsuGZPoVMBBy8FdVxLlQWrDHoWZ6bDCdJi5t2ioKvH7WorW5VDcuglEoE3H1eh7nU409aWyn6HeyE5/GmpgU785bunM+rs6iOwlEutNMjVxkXQUIco6LEkuvcJeFj6WI56WSEdDPtXnjEmzCoOkuDWxXIUFrQ3GkBvBTBZPmcmqKFFtKiq6rSYNs5stGjoJwduLKXYI6mE4L6vEaWKdEuWK+CUVbMW09bjuLmW1vC6hjoSYULhOilG/bOfuAmfU8DEo4mVGX6+AuCncUCoMZjLinA/4gdA/VTvhtTtxGqXqX5Kncc9lsVagRa9JjRkv9mBOyq4ps3inG+0i1kSREKaEkqKNIZfWv8gn6LCdpF9bAXpE9ASnfA8LtTJq/Ra1fzwkdFMlo5hs5V8NnEb/JgK+r4yIjJc1ACcyhFRBNDIqno/Qn3z/scLXnsB1o3cz7UToinzcnDIku1jxlj7NfHz/ne08veHjeCi4lq7fEg+flyxO3bY/LJLvFqPhjr48ICvl7fE/65z72Z/7MBzRjIvu7Tjg5ACeTKywK+dIdFco7VFC4E+icxYWtpn010VZzuTm9k9nDdj/ySy/ele/5flKcXzn0rEufvn6vUN4QK01oLH12AtYuYm3EqFRmOeOlon7WaC9tqSVTFzkrmG5g+FwO2H7W42zEmEiMim4vB6yPVigIiTIHfD5us4isygLKcmzzZm07Lhn5guhEyUY952N7PexpzczGjDSZD7CxI5/XR/rguISK7z+Jsv58rLDF/TlXBQrC/Uy1mbA2lFni6WGLe8x8ngUGn3JLNT9Ti0lonR2zU1K0ubqZg2G+iHq8CmBy4Hn9+kYSmcEUvU7Xye8KmWhcqp6ooI6CiF6QfH41plzg5SA8K531+wq3TAm/TUVFuFjOuQRIXktVpMHkSlc1AfXoUJeGx9xKwolNjzlMsFf4szySKv99ddYlwIRa7ofqJG28pYIINfBi5P72gs8zuGWj816TKlU6CdudGNmebVPEuY1JNNWMepkY+koU5AHlLVWXA1vhksmmP2+lwimVtdL4KtLeri2xyVsejxvCscJ2a0UYnRxzut59bGI+RMygy7kHCRDjXSK+mmhzQuiDmJGqKOcgbnOVWEemUTM/2kLu1gHcs7RRY7Vet2ilCtTxquoKmZqSjVmX5CJm8YJor/hmEVCqyJ4tNkF6UqhgmA8KX6+EvKk3vB8stgqcc6v4tuoIKL6a7/jBKNXcXz9+xlM+Z3Jx5HPr7cSLzYX7uuO+Wq2afmDu+Ut8zPXTbR/z8cP7p/VpfVqf1qf1af0urJ/5Cq0xM79498hvcAfAaVcx+sxVuVIE2XytsJ0QYRdSphkM52qD/vxchEbTZiWpDsGW8jwBcS8W7susQIAcMofxW8Vo5HRHl+jPjt7Fld/Ta1FsUHJcpe0zS1skNdICBYrob20Dt23PeSNtrvfbHaNtigwXQMiCr2J5sor1huzhZXq1KhqkjMDTiZgUp15mR8PkaMzMH9p8w15L9j0kx8ZM3Fcd76btqoQepbrRfh2yK68gKVHlSFmVA2DUeUa4ggPSYGT+pxK2CvxcRop9a3PkYdzw9fHA82mTf5tUy34bKegRQJ1szpSVkMe5ajm5RGpXaaXY2zJfKuaau0So5TfMh1hmgXFWGKPR4xXJfR9XdOUy58u/zR2NzG6ycowyMSNpWUEWOuHamZudnNdnmyu8qPCTwceqKJSY8Wrew9oa97ee/X7g0IxFSNoouYaLwLTNfKZ9M7KvRl5uOt6cBchz6Wp6Ku73F6Z65gFpicXOkM5C1K+fc0s4JAGR1BCu5k+2U4TW4G/0CvrR4jMYw0LCzsfbqsKDTFfAoVgJcOO6RRjrxHwTcFXAZxGDeTakoKUdZxLVzZh/Y2B0FT4pdH6vOy8+bApYfQLTlbrO8qwsYtLuIlJmRdnEyPMYqhXwtZDEzQDVc6K65HlbQLhqP1Yq6N6gTgbv4OlGHsLvVS+ZokWTeD/IOX/XbQS1OitMp8U9I6/zVBeHBYBvNc98uXnmY6/fqZbjb8f6mQ9oTkV+bvPE+6w4MdxUzKrCnA06tyVML7BcO8QMX5abszpC/Y3jlParxIwCdKI7Nvz18+dF8SMFBbMmWbGCgRwfrLT5kk4SaMjyU0llJXT5WGl1JMysPmi5RCsB7RpJG6Mu7bfOuuIMHaMm1VE23tyy5GSJm0C48wyVKbI5BdRg06pIvwls7js29YxSiSZrYMYkbYjn0HLKzGpNxF0Nk+pMDO13M74XrcJrV+ZwsnivMLu5wOAnF0gvRH5qQTmqqEjIzK2qfJG+qrUnJiUk4tyOMWdNOAT5Z6OKRqRcD4vp17ZWCWxGAsqCItWdlutTxXU+YhK+Tlklfm3XufuJebT4s0VlgEK7GxlHJ8oWSZFym0qPWtRajBIABkg714l9jc2fucnnIkRF6zx3WVdzW03MwfBuu6VfPMPOdjWAna6CW1DMs+U41Fz67KJceXbNiALaei46iDEpQtIYFctrkFvz1Uin1pldcmJuG/uV1K/nxSX9Q4mpxUZl6h1vogTKGAzh2VE9itrNIjGVsoFndECzHoPyRgjp7QrICNuIagN+MgXxB4hQwo/tu1onjA0EZwRxyaqQE+ok6nFXmot+I/OyRTpLXleYMQlNJo8OQkUBsSz39HX7Plbgc1I0HxTjywCHuXjQqV6jRwmQagafxQJ+NLzk6+0NtlrPQYqKMBjcRQtRfbWm4zJWnIaay5SViOamOIl/rJX4hHL8iV5WBSrtuamlihl2lsfZwNkUz6ToBDEYnRZLlSxVNB3kQTBnjcqZb6xSsckww2obERoJRgKbzxm9XRFrsJpN2o7yPfMhlvfUD5rqKTFGVaxmYkXWYkwFIh6CxtpACJrX72+IORjoTqOtbMT2vARrxdBGXn7+TIiKp8fMoTqJpmWsKLYh2xcd3755xpnAGGy5sedgeNfv+Kv2ixLEbkzH19MND9MGqyIvN1nXMWqeRkPoXKks3AlQijkZ9H7is/25fO6C/vwq6xr52dC0s8gzRcUPn+X1H3LDuavxg1urOZ1BJFmxZVFVmAep0Gy3VgXTi4DezTgbCV6TLll4ecwVnk6rl9mkSFZmjnpc9f+aWnQGe1sXgI/WSVQiglSE1/5zscpIzyWJSAq2nt1t90FlD7CvJz7bnDjPEiFC1EStuNn2ZWY43Dr6S014clRPutxXKinGS8U8m8KHGkPD0Qr9wLSBJosWGx0ZZ+kshEWj0gU2tThjD96uoJsXgamtCLVl3i0ycYJSTFnfMC4BzUs1NKsK3yxQc0XzLMHMXdZAGZ0gdlMdi8akMZH5RjErcQVfZKPUxqNUIp4cJiP+YpWTkqwxucxDh76Sr7iC1/tNwu+DIGxPpiSVSzU4kaiv3j/dSNCuH0B3a/WYTK6I81t1riKTkYpssZUZPktwM0sHICdN7llAS+4E2iemBVUbDeFk8EuVCuJb5xKhEjftlO/p8VLhZ4OxoaCEGzNzcFdupp/W735AU0rdAv9b4I8it/z/GPhrwL8N/CLwG8A/k1J6zO//V4A/gYCJ/uWU0r//d/v8gOaH3W0h/nZDLYi3Sa18sV1inhT2IjP+WWQFGV8Fkk6Yy6qOrkv7YuWDgSAM09rpk9cyT2yRELoGSIEEy7DNBNJOHvz6KKTpMT9kfisZq+kUzZtsyGhbqvuBebDYr2vq5ytkXIOkpMtLUUixISoOzUi4yTqKOgMjkioZ4v22KzDgrZ14nqQymKPmMlbAXQlyWiVe93uMitzX3ep+nBFxoUkieYQE8OpZoaJi2LsCpd+5idpK5bVsuJOx7DeDuDAHwzmDefxkSZfsVHzFH7RVQGmhPywgB3qDOynxmLPLDpTY7gds3tC7JdvvjQQir1fY/qzAi/p8qFOB9S8iuSkppiyeG73KQrUKc9YlaVkAC6Fh5c2pSL2ZeLHtGHymSgTDoRn4I7dfc7ADf/X0OQDfe3xBZQNWRw6ZS/dqe+FtteXBH5ijImadyvp2wHtDODt0BsaUdpmCWFsut3lzzUjBGHUB3AA8n1u67I+2kNE39cSwtRybDUOuikNtCiF/eX6W32smMKMuVZsZBXavfEYW5sRgukn4Q4CYW75A+6LjZt/z1Gzwgy0tYaK4qC9UBaC4VftKBBLm8/IgK0HTzrpwGXwbUVufKTmr07gKSmTuLOV4k5EWs+2UkKivaDLBZRFqtb5XhI8TfnPV2r6faLcj41CxuN6aXipqFeSzpkNOVp20avV8lXjdQnCBePDoJpQqeu4dvrN4Y+gWtPRW0RaH4Y+0Evw2CPj/jq2fBFDIvw78eymlXwb+UeBXgT8F/PmU0neBP5//G6XUHwb+WeCPAP9d4H+jlPrxOPFpfVqf1qf1af1Droj6KP/8bqzf1QpNKXUA/hvA/xAgpTQBk1LqjyOEO4B/A/gLwJ8E/jjwb6WURuD7SqlfA/5x4D/8O33HECw/PN1yyrOF4bmWuYmCeZ+VMDYRezYFprsIxyYXy7Da516Syq1G20uGNmWuygIcMJ0uA2Od3Yj9RjLShZ9jsvxRdGsqpFIeOlsl7ZlyPwifa+nnA/jWMNHgng2bH6kCGY4VTAfFvE9kWpionZjE47s9l23NtpVsf7uXrD5GVfy2lvnKves+6M0Pfkd3abicG/pcXVXWcxpqbtuBygSeR0lnu0sNURG2kVUWWKpPewHVmwIg2biZ0yQzge4if58SdFYybu9XoeJ8KqQ6yyAMvZ/ZbQdR/L80axuxE6i7ugJf6Ivh9NVePuOqxeN3QqxWV6CF6DI8OyW5F3LbJ0wGfxaC9vVnYFKG/V/x++YM5d8k4q1k1LYKbNuR1s6Fi4eb+bw9cbADL92JLxqZ9T5uNjgt1aDLFiKNmemqistuZDKRNrsD3O06ni4t3XNVKjM9K5nJBgFApQxImhWr/1tewRvCyTFvPDc3HS936802eUvdzKhcgc80qGBkHhRY27SBwstaljtD85D/bnOlQLIV2xN9tsXPS6nEbduL5JirimLKPAiHTmcVHpCKR2Z2hnmviwhBqYTrSFgEsBtxtgidFQ7hMh/MLIJkVyd5yHy5ixLZrzZXok4I02ET17anFTCOagI+aEwG/rTNOgBPmfIhlZ3Cb/nAzcN2GncRmoBfxhR5T9B1YLMdPxD9Tkk6KkPuDrzp9jTmWgLp0/rdbjn+fuAt8H9QSv2jwF8C/mfA5ymlrwFSSl8rpT7L7/828B9d/f0P82t/xxWSpp9cUedAQ6plo1pUDkzj8VRFKb0EGi8bV3KpgNIwSbTflP5g/oQWpF5R6ob8xMg/KqxKB/E+B5DZlA031op5n9tz5xUspycBrJhhbY0sOnjNO0V1WmcTfpPRZ/V6XOp2Aq/RT465N3SZhHq370iVKoASOVcKTcJmgt5dLXOxp7Et71lakk5HnAnMUfPmsuMxIw/jIPMk1Motm26SGF5Wstksyvo6H/jx0ggaE5mJhSCgFz8b4XOBqGSoVJIM+TLF+dLIPOhiC+DF9AKsiXadX9qLwrwXpft5l/A5mUk2awwmiganHIjMItNV0pEmjT4btFdlU0pZM1I1gTkTcgHqR2lv6VGJPBfQthPOROZoSkAbvWXI88ov7DNzm7Uco8XpQEiKS85O3g1bHi4bvDe4xpfZmlFJCNxXIMt5m4ibiB7EFqZ+mzfGzjHfa8x+XiW1eiNzySgmmi8aCWiDd7zxO3l2lg+OYkq6qHHEK5yGzohclW8pPSWqUxQwSDJFqX7x9otNLPf/ODhOdU3tPLt64pzbn0/TFjVIy1/nYClcuPxMGZjv8se2XmbIOn4wDwjeoHtd/n65vsnIMaRswOqOSvhrSebn0+2arBbVm2n5XAkuKWiYNCEr5nSzLlZRC/A2WUmK50MibgIqe/W5Z7lPh/u0ohmDglmRKsU0WeZx1YhURu795RmcguFh3PAxV+ITyvG3+v3/ZeBfSin9x0qpf53cXvw7rL/dmf5bOr5KqX8B+BcAms/33G87zjaTeXVipIZZYXNWtdmMXJJisjIvWVx4Vcw319XDkVzE3U/EV3Lh69zjtjYyTQY/WfpanvL6waBHaN4p0pNheJUP/1teNBMHh++vLoGSmc+ibgCZtxtES255QpSXBzopcUxeMt95n5huI6mNqAVFtxuFLKsFTDH1cmxD7cR1OhtnAuXfMWk0ic9qUQrRh1Te9wv7x/wexVuzo5sd708bpsfFgwPJlE0i5WPwTuZqZjuz34zlnBkdeVX39POqrWhMLCoakzUMvWxsKXtOqagwebDPycg+qxNasYrfFi3JlTRrkhIKRIDoFCFn32pWxaG6VOY2CVoUmd1wWUAdFA+wWK2bc5o0ahuIbSAs332WgGZ7xbwANeoVaLMgSENScr5VYkiugG7uqwtOBTZ64te7V/Jzp1qsSnqL2U1l45mjFpFadYW820TYeoIxEtCe5XXbK5I1hEZ8t+SEQWqlkjl1DT80twC0TirJFBVzvm/ck6F+L38z3nClq4m4NitwJzmP9TFhu0CoNNGpVdNykg0bKBXPTM1br7m56fj85olNRreeLw0hV9pFXmqHJIlxCaL5WuqEq3w2e6WsMJuC+i1WPFlXXCgl+TUnyY4KMjtNy/2QBZ0XOojcY6AeDdEadIDQ5Mpt72V+F9bOgm8Tqpb7SneG6ikDbE4L4IsS2G2nSMrgFUyzRo0LoiyS0OtsESGYL/55H2/9dBOrf7cD2g+BH6aU/uP83/9XJKC9Vkp9K1dn3wLeXL3/56/+/ueAr378Q7Pnzp8FuPnlz9PWrQ9/PzlGrzAng88yQJu7Ca0Sx9gSJ7M+DLnSWNQzAFQd+M5nD7xqzrzu95xGCZQ3zcDoLY9dyzlXFX7QVJO0ECUAyet9U9Ptcia3HPMispu/e2ndiP7c0gpdh/GLsGpxTCbDkF9MvLw70WYYvdWRvnV8kxTh6Ary6nhqMSbiJ7MacQL7asTpwNHXpQ/+c+0jtfG8G7dMmQdznBpiUjgtiiWF1pDVxnUdClpu6h3JCzJz34ylQvvh8w11drf+7HAu5+I0VmgF1qxq4sNoVpX93NVZWrtocThYoOWxEsNNPVM2cjl/S1s3lb+1vciFzdv13Cer8NtAUhF91AWtCbkiUQpXgDjCbZpVgqjKe21P8Qhz77MO6LBhuplJe8Xs5He1zoviQ3/Hb3QvGPIGtbETOzvRa8eYd2GjEnU9MwSF1gmbZbVCNkNVbSAUBGjW+auibNKLoofNaimJ0tZTJqKcVPrDueKbrO253Q5rxp6rCpt5i77Nrbp8C9vzKsS8uqUrus8d0SimnbpC+2pmcpt+ARLOmvRU8eg1N+1QRLD5HP7a8AVzqApNQe79iApL2zM/F4MVHEaiIB+b7UTVeIabQLoat0cnFbjp1SpbVSfm+4AatZidvs+o4lNFcklQzUu3Nin0nDL6ca3g0AntogSFLLCsUv6tUfzdFiUhM0jnpXmvioSYztWv7bKrd77N/A5SElrRNGRAUtA/1VqOvx3rdzWgpZS+UUr9plLqD6WU/hrwTwF/Jf/zzwN/Jv/738l/8u8C/6ZS6l8DvgS+C/zFv9t3xKjQKnFby3DjMlVcQraZzxm90xFdT/S1Q185wPrZiHvuaEj5rje5X3+cG576hjHPlLRK9JOj72pUdjiunrK2Ys5OF1X8+o1h7hWxyS00VuRWMsgsIivrhwCxUsz7K1v5Non4akxF9kk+JFHVM7//5j1bKxnu89zwohEn4B+l20IKJ4lMle5MeRjPUfHWCLLuMlcFifedwyP/yO4brAr82kmqhfNUo1ViV418eRv4JgfFy7GBpGg2E5uMlnv0hoio5xuVOOc25+ndltOsURvPZ6+Ocn6ztY41kZt2KIH5dVRMsSaZyHKFtDe40wKfVkXdPxrQBtS4cp9CpcomnIxkwiAcRJ0rt8WGJyUJTqqKYmq6oODyb3RHRfMg/9v2ieGF5tgYkknlc20nm7VKag28aObWFA7hct9c5pp3/Y6Hy6a0xg/bgfu2Y1+tsOyNmxgamaXs2pG7JktMRcN92/HgPG/TQd48adJoQCfCwTO6pXSDtJFqLC7K/j43fxeyeSb7j5NFKXmGlupXZs/SRp5vQqmwVFBFFmuppPrPFL5ReZ64Vlh6zvf5YV61HGexwGEwPPcN+3v53X/kpuP1/Z6nebWqSSahdzPaJPxoRNMRME8WnqxU4Yu5rIu8uD2jdaSr2pUbFhVhkbIqrcGI3npicsVpG6AdZLbt23XWFaqsp3o7Y6pIPOVjeBB9SeVW6SwzAkqeUz2uz/G8U9SPieZdYrxdKz/bCccv1qqIKcdKnAQwsTzDc7D07gpq+pHWTzPK8Xe7QgP4l4D/s1KqAr4H/I+Q2+zPKaX+BPAD4J8GSCn9ilLqzyEBzwP/Ykop/O0/9tP6tD6tT+vT+gddn2Zov4WVUvr/An87V9N/6u/w/j8N/Om/38+PGeiwSMRUxotdR7VB5ezwPFYYLYP1bbPyOs7UTJOCuM5nwsXxN9/eCe+pW1XML66VrL431I+5R/4k7cHxVrLSBalYPQNJ431i6XeYzFPxm1wxXNm/61PKvX95rXoUi49lIF/4OVHhvebtsOOY0U/nqWZXjdTW026mkn1pnThPJiuFZKRZUlz6mq+ByoYidLuQfX+xeV/mbL/69AXnuWKOBqcDd4tHU9B4r2mqmfs2k60TnLtGurdXD4uuA9FrUm95Oq/AE+8N1Xbgtul5Va+tyB+OQrpNeQ7um8z7UhnIs/w2L62+pGG4X1tt14CdpdqKThVD1CLDlG1qkhUEbKzX2aU7atw50TxJZV0/zFQny7yzjPepXJNpr9BBqsUyZ9JAUISgMcv3J8Vxqpm8YZoM8ykDQJ5qHndbvnjxzBdbqV4rE2isJzWKz7ZnGiO16vthy85Jj/q9yyods4gbq6BJm0C6X+9rV3m0TkxZ/ykNMptMTsAtyxpPtVQ0OhWVfr8VNZzQpg+RnoCK6QO3Ct8KCnipfMu5V5B2ns1uLM/bua/po8yzfNQ8THKRd3bC2SDCzm0msxvpOCid0G6dcZtJOi9JJ2Ie6SqVeLm5UJnAOFTFMDZ5BW1CV6EAjxg1MXMdo1uP1/QJg1Rpywwu3M3oJlA5EThYyP72Iqhkv13vhaXaqx8TKiWmrCRUgK7dqhh07TSgflw+zohM2iIg8NNuH/PbsX7XA9pv94pJ4ZNeVRFU5Dt3j/ymSvTDCtGavGGeDedUM+UZgsgZgfJabDSQvvWsskxTZ0rLBcw6qF72Dp3Jp4pimQFLe4sPrEjMJBuBkC4VOpNRF31J32h0bp/VkwS+/lV2x142TJsIs+FHjzcfSB0dh5q2mtm3Ay4DAbRKNM5zGaqSkVkbiFExecu2mnm1kQh8cAPnULMxI3e5bxpRPJ43PCLBcQEYCEJRfwg3d55LPt/x6vUX92dOTcNwrPG5DZmSkG1PSfHG+RIAB28FGDLpAtuPtai+q5j9vzJMWnVZgmyTmO+yEvussCeRE1LXavq1oNniwa/wolmXDTyZ1Wl5AQvFSjHcLvDtiqQX9RdVNqBFUT40ibBZNx09aObe0eXro5Rszs6IA8OcNyg1WOKs+YYbukxzsCbSjRXea2wObrCYlzY89BviObfAy30pc9/7W7mWPs9ttY6reWpQ0p4MSgAuS4JzEePQYkoK+JtA7LUoWgT1QbDyGZpfZpkuiZNClYgHLxZAZMSeTkI+zislhbkKpk/Tit7buBlX+7UVllSZ/8XRlN8RLYJC3kWRngJu9j2fN6dM+E+scOX8N5MpbUh7FNRxrOReWgQWzCjzMlE4yW3n3YRzge7YoM62AJXMkMnbWuHzDaWiJDd2TNg+YbNIQ6gy/WBOZdbb3yuGl4pir5MvoxmUyGspcUZYruEy8vhYK6VPFdpP9EpJcRwbei+zn9FbWjdjdMTkjTFETYjCeRoHUzYF+yxBKmVzSkDkPvLkO9URv/BGek111KLxtjxgRsRLF3BAMbf2iea9SF8tagQFkGBWpBXI35lJxHIXcIi2Cd9mIMS1q/DO5wdfMeagvDg3G5W4qYeCILzMFS82F3b1yHMWIQ5R0zYz+1qAIYvQ7aAtD9OWH/W3BSb80LXFHn68SgyUTsXJ+9ubJwDu6wtzMJy6hhgVVUY/3tSDHGvnil8dgBo0sa94m/ZZoSSbomrkn7A+cNEl2aeaRMobotcQGkW8mYu0Unquit6gmSgbm9/KZnu4vxTLlWFwaB2Zuwo16+LrppJUJr2jzDyWILdoRqpF6y8j/kKbCHs5Ln0RVKZtZrRe7j3Fy92FjZ14Z3c8LA7mTUN6qojvah4zv87tJ+EKnh3fnGpsu6J0KxPoRlcCmRmUzFr3npe3Fw6NzKReH/d4r0XfMTuoh1Yxzxp9MVKlLJQPI/ej8hQbnuSiBLMkepXl3MTsPWbXTVh7hery64MR6kU+kSlpwmDoMorP1CLPpZRoLo55ftu2M3/gIDZNi8LMOFsuXU04VpjzKgEWdpFkI+2Lns9vBKH7qj1TG88YrLAFFs5aysF70Ousa5BOTPQUWSuA4aXwIWKdikC4tZGUFKqz2Ky7mD8WkC5M9bzepyp+aECa3000KuvHris6CZ56vnL/vkB8NsxVRbdUjiYyTx9/C/+EcvwJXikJrHkBOISosDqyqeaCEgNxGJ60IY7r5hzrVISBl1ZDcqLwXRCQC0LQiiuu8ar4rGWB7w/EhkEQcNU5Es5rpu93rG67jiKP405gZkWoruD52+zvVAuvRWd+W93MHDYDSqXCL0tJsaknDvWAj5qnQVp7ISmsi7R25qgy6Xx0bOqJF82Fzlc85veep5pzVfM0tDxkXzhSNimtZo7elIy5bmaSU7zaXviljYBTz6HhTb/HaNkEqlyh9d7RT440rQhGFUVlHCXXammpGBOpdyPBm0J1iIBP2XD1dlrpaUnBIbDbDyXY+iTXUOvc8lpcmQ0oG/n2zXNp4f3G072I/PpccZXKIG82uxV9lowgCFV+r64XUEhG/f34E2YTVRVoc5adktyPezeysRMvWwngP3B3vO1usU+WmBOL2ThB0XXiqO23WQpNR1G216nIYSVtSG3AtKKFuCBLlRI35VGn0u4zbeJ5cKTeZC+6fE+3ER+yWEBGb8Z6EdXO77lu3do1eYPFHUBeT+/NFew+ix63Ca6ewRhVSTJ9fnNMmq0d+e7N2/K+x6nlr8bP6d422G4FTqT7iZcvzvzRl1/zrVzyPPkNX3U3HIda3NSLDx4s/NClytSjKklPaRcj7WhxdFjb2tNkhR6QSfVLDJAKTmTXTOasLd2ZUEsr0yzBL0vijbcav1n+Xip7FXJwXUwssus3oya0ec+YDPHycSu0n/b1Mx/QPq1P69P6tD6tv//1CeX4E7yUghdtV1SptUrU2lMbX+ZqF1/zdXdgmBxzUmX4nFqZ56hZlYx0UXdPSeY5peXURiabsGdD9bS2YYTIm7ljZSiuQC19GfnXItWjR/mupT0ZK8W0y5n+ksxmO5pYJarbkVc3Apy4jBXjbGmuqs+UFI31+Kj5+ngosjk3ux7XiBNBk1tPY5bA6nzFeap5OImE+DxZqnomBE3IPlNaJ2LUdEMtFVNuJ00m0W5GGuM555JyiI7P2hM7N/J+2Bb5rHG2hKDRjRfVFCCN2RcuyfB/Eea1OuKjpp8tJ51bpJUhWouqItvdwLDwc6IlDYZO16vSiBX5sWQMsM4uVaC0wr5sj+X3fxU1fmNIkyZePeAqIW3oPGPDyL2gZpl7LJzAWCVpxyWKS4Jk2IrLY8vQLiWiIia4fdnxc81T4ZzFpHg6tPjpSvF60uhBF0HbpDMp+VJxXCTCcvt5ab+GzvLO74ufX1V7tI742TDa1TtNWWklpqvPYNJ/q0N3knOJjTBo9BWcX9rjfDAX1nMqgsDrOVRMig+AFylC/9iiW8/97YU6g5reDjuGYKlM4FutVF17N7KpJy6bwBxNqUrv7i78l179iP/qzd9A54flP3j8w3zv8Z4QNJtmoldrReNtJFSx0AGitdLmmxT6AjYfd6wU822Qzsw1qEknqANhr4gFoq+IUagNCyewOiYRytZCyPeLZZQRRZL5kPA3uQ9ZRRgN9jlb6eSZXdhk370mlmOIgy2t4I+5Ps3QfoKXUomNnfj5zSMAjZ7RJJwKPAfpVTgVebJCNDaNLx5VRiWe1YbUmwJEUCZmlXoybyy3FRpPcgI+iZlQqaeEHYRv4tt1UxjvxF8pKYpieazEEn5p4ZgyOJZh+3XrSwbJYpoYg2ZXrZv+u/OW4ewKSMOayGWqOA81l7froL1zgbGxXOaqtKOcEWTj09Dy3DcMWf1D9YZ+Z1B2fZhU7fGzwXcWdbFlLhCSo1eJby577up7AD6rT/xc88Tbac+7flfaoZM3OOfZNOOKqDw3hEzibRqxVAFJRE5TQ0iKeiFsqyywbqSV6fM8QV9EQT9Oeg08LqJMIm49w8HIvGi5R1zkod8UpGBjPPtmJARN71f+EwsfK7DO8YKSWZJXBZRS3hsF9bYo/qvceg7Rlpmh2sjMs9aBb1XPzGmRvnL8ze0dj6Mtmz4XiztlW5wEy/8RtoYA0o7MOo2qkWBmnqwcW571XvYBVQdS0MynfPNd71+RApIwZ4PtpS0WslSYOkw4K4T86w1XeQrx+BoYs6D20nq6CU7aaaYHv8nPynZGN56q9hyagUPm370ftnz1dMB7w5u9IDjvW3F3sNsZbxJuIz28z3ZnPq+PTMnyLiM63vR7hsFR13JN65y8GR2ZvCVEVRCnz4eW+bkmPRlMr0rL0bcJtfNYFwrRv65nlALXzqQ64PMsUD041AxJr2jFZGTmLvy7VGylYia5+0PA7jPQw0SmSVrusUqrin8VMfuZ/XZgyCChcHJlX/pYK6E+BbSf9PXV+YbnrEdYW8/GTuztWPr0r/s9Y7DsGsn8bvIA3SjRHZwqsw7xM0kYm0gmFOi/sZJBea/K07vMznzzYxVWzk5l8LzekLGWOZy+kuMJrXycvayZr/bL/9YMO8fwMtuxVCMPumUYHCqb1cwq0XU1/uw+IFGPg+MbtWeejSh9IJlZPyqOqWE61tjHxTMM/Gw/GJT724QyCTWa7FCd5xDPBh9q3gFvM0ryZXUmYnicWmJS7HPVNQWD1ZGX7SqG+5vmhsesW/di1xXx1aepLTI/6xxEFQuUy6lBv5ENunknvnaTVqVisq1Hm4i1AXMjepHLb66dZ/KGH51vAEHV7dyE20fU4VwqyndPu/U7F9HY0YrAixZzVZUzdTtmk9W4zuvk4OUchpxbtLuRQzOiVUSrSMhDtz44xtmRoiomsktAXZC0y/0QrWa+A307ccgGoUolHqY91aOjeUiEOldzW818EPpDsbpJAo4JtVjmLJ/rjiKKPW9hvs3n0S6zJCWgKLME64Vmsm6Gi/N0rATkUISMr96jcgA+7Hpq5wtAa9H53NqJGDXTc83rHICPtw0u2/jgFSFX989jw69dXvF6PPA+g5fenHfEYBgHxdMVxF0h1JTKhkLeD1Hx2DmSMfJ85tmcPwSMjbjKUy1Sd/mZaauZmOCSpfXGqIjOiN1NWM6DIimFHRLRKaaMnox1wu+TeL4tCagNpMPEnLLE2wLbHwyxDXy2O3OZ5Tx8damEfvBplfUzH9BSUrx+OJRNsN1M3Gx6cefNN8a705baeW7agfvmUjbRs6+52fSYbeKSs6LTpUGjSRnYsAQD5wJGR05el0zdb0SseLoTWaZFzqo6KuxZgty8XYbtIl2VtDz4RcsxZGDIsOoHLlbwoU24w8TLduVqgUCRiyLIrEWYVeUNZlEmUUms7NMqohqCws+W0BvM0azK7fm4QwNhcege5G+Lq/P1UqIKUuWy7Wne8HrY86PjgZQUN60kDF80HTs30pq5JBf2NvBy09Hambu6K55sby87Jm8IURd9RzmQ3CI5OuqHBeEHcZv1+vLx6qzvN46rsgtQWnHnrubpQSqAzWHg9794zy/sHtnakedZdrb/dBLawXdfvC3V3K8/v+Tt4z6bL4qqO0AcdD64FRiSFCtgaLlWGbD0PLd8Pd1yzjISb8ddvk4Ux2sVs0qMW+8hkACRtCYcKGCTELP2ZSJrSi40ELCD+oBekrQc3HIZF91Dd4HmfaQ6KqLLVfWkiW3A7Gd07ZmLe7jFdlJ1FcFiy9ouVSsiVMVMZ9jGorzjo2Yeavq+4uQCjZXf8e3NM7e7jm/et5hjBsFMG8bDTJwM+mykgwK84VD85RaknjUSiKbR0nV1UUdJXuM2E9t2KgHNR43qjfBBtysNBCMmrkNQpKIktO4XU7S8yQlv7wIX1xBwxb1ckldFvIhOa2lLW4ibQN3MZR85bAY2NzOXm4o3b27Q7/P9Oih8bxiDLce7vekLxehjrp/iEdrPfkCzJmBdYBpWnlM/CbrumBXiw2AIu4naebRKtBntNgTLvpJ50OBFUijMRjaYJPO0xXolJdkktY1F5HY65ErCZBRkWgPE9nXAN4poc/++WvgvEX20VDLOwZ0T1SWRVBaDzZ87vIpwM/MLL575fVvRvTv6htrec7GRtKDaZrG7WTLl5WYNQZdNWGXDQD9b4mOF6TW2X6W69CzotljFMvPTF7Mk6gJnz785Hjz7Fxf+2Gdf8wvtAwBvpz0P/YZ+rD6QfXrRXHhZn4lJ0Wfy0nc2DxwOwnt7N+14XGgCj9sV0bW0XtuAbWaClwBeUHR7UZtP1bphai36hX4St+qljTjXkXE3y9/necQ4OKZgqLXw4E6ZWA5waAe+bI9F5zLmE+Bqj3OByyImm8n4SaeVjLsLUhpEZBaSV0yKwTv+6ulz3vUSyBYqRbsfCl8rRMW8CbnCd9R6DRAg897Hs5wvawMkSZKmg7qCiovclxlTCbTzbp3/hOxEAYLKm7fC2WuytKL2mvEe2Hn0VaVaPSu2XyfMmMrn+Sbfd7UiNBHfLrwshJs5KcJb+Z2nqpKgNykGl/h+fAFAd5sD5n4mTtmZfdBEvQydWSW7BsvTccOpq6nyPX1oRu73F462IQTNmKNtmjTeWminQtcYR4danAQshOyaTRVLlbwEkBgFPbxzIz56jlZ+hzNSOXZRERancq8JGxgjJJfWwD6unZhFJq42gdbO1MZz2tf0p9xGz3/z9rQtwa9xnrtNz6/xEddPOQ/t408UP61P69P6tD6tT+t3Yf3MV2gKaQsatygzSDtmyaxB2lIhaJ4vLa2b2ed2klaJ81TznJpiT5+SQpm0tvTyCkEzJoUxkemQCb5eFft1SavzexsYD0IIvUaPlQOOUpkBbN4FzBiZt4aYFdqn2wi3E7b2DN7y9SClW+fzLG03MFbZssQ3otKf+VcqI/rSc4UeJCM/uyyserS0Dz+GamPl47ijwgyLQGyugmqpHhek2cvPj/wTn/9N/lu3v1KQZv/e0x+Tdo5KKKUKujQmJXYpioLu29mR31e/4bW/4fW4L5VKeqipn3RRcQDJkr1Oojyh0mrUuKANdSLkyjz0MjcqII7FTiRqorLorcfkwbzSAhL5gbljCoYhn9faeZyO/KC7420nCND3TzuC1xgb8V4XtKcCiudW9k4zNxPGRGLQVDkjf7HrONQDlfH84HjH+6ddOYb9duDQjFwauffOdV0QrO/djm6X70mVoI4oGxmzzQstoLMTwH69v3SQ1ncyK8fJt3LAoU74m1iASShDaFQRBwCZ37qzZnpdM+uaKvPT6qdE8xjQc0LFFQEyHRS+TcQ2FFmt6DX2vaN+WNuc40sI+0DK3eTFB+zhsqGtZjbbgXN+5uLZFlRpsmkF/kTwF0dwpqBxaxvY1SPOBKbJFuFl5RVpMMw7UwQEjIlMTRReZLmIoExCmyS+e/3CZ3W8jarsJcv+UFnP/VZMUpd79/l5g9KptLdjnt/6i4NZMV6qUnVN3vDYtfig6S91cRLQQUYCQ1cVgHRoJmr722Dw+VPcc/yZD2hzMFyem4LcmqtItZnZNBNf3B/L+y5jJfI4UAbSWiW6yTFMrszgNjsBjvig8VFjFrM9b0Qrblwf5lALdFt5dc0fJTSiRA4fzsoE2aiJdSqK3NHKfGS80Qwv8mufTWx2I/NseDq3/Lp6UY53W00cmsjDRVpPU+uIJqHrAEGXeYM9iVcbUWEW7cmTBN9ohfy6tKT0JECB9p0qXlfzTglaKyM9zU4erG/tj9w66VVWeReco7hUa51oqpH7rPt4V/UcfcPjtGHKgA+nIi/tmZhPzILAFPMqQYIuyg5cEuFSQ8r6jRmYsMwgg9KoRen+KmFIJuEPcX19mbfkDWcaLO8fdpy6Bq3jB0CA577hzXFXAkf0GmUSfjboqDGZ5D67CH1WN8nKKFoLKKXZDLzcyDnaV6LeEpPi1Nf4ZSZ1mNjXE9/ePhM3ud3U7Bi9pbaedKd4XCTPkugzwrpZap1EBd4lFqX35dyEGuaXawKQTMJctBhZtqG4L8+VFQWRXmPPqtwj9XvRtAw1VwjJxLzR2DEViTblFX4jclmqjoVCoS6G6lFRPa/tyWgRd+kFNZxn1JX17OqR3dr15eS30BsJ5DatKj5eFxKVz4nMY9rSNY55ssX9GjL1ICq6c82UA1gMgo7VkyRspTWopFUfpjVhIcJ8rHkzWpENy4Gn2wTCbccX+xP3W7nGw+Tws8HaIDJxec+4AOG5gnH1/SPlmalXqFEX9wYVwJ4NYc6yY0DX2Q/nyR9p/TS3HH/mA1oKCnV0xVQvVonpzpBu4XbZWOuOIZtyNmamz6Sw81yLJNYVcKJ2M1/ujjR25m2/KxI9WlvmyRJGV5yTS1Y7ywa7bCCLzt8HKhQqq1A0kakGMyyXRj6r/0wx/KJM8V+9OJGSYhot3huelASv/Wbg2ztRvFiUUc62oVg4XdmAKL/w4xK2y+fGgD+QA+rKuVFBAkmRAVsOOchmGLZSTYAgF//K8Qse5i23eQj3vdML+sGx24y82l745ZvXAHyreuZXzt/icdyUJOLNuAO+IKJ4GLfrdWwifiPVwgJaUF5ACNqv53g9lyrLgshLsRZ1CzUrFIrUrFk9SZG8LtVBSgoeK0ZVwcGTdlKxhxTouxp/citsvw1sdiO1mzE6FRWUkBTHrmEaHT5Lqc2xgu3Evh2LAsppamjtLAjHK5HbcHa8a7Y4E/jFncwi7eaZrzupxivrSxATmyO5R4vp52yEb2aEB1a4YArmCuZ9RN3J/aRNIlBjLhrzYAnZm4smYg4TwVpS5vjZTnhVvgHUaoUy3irmndglmTEHlTarh0yKFA32nOkhR7GaCdUq9qtnCKPBHEZ2m5W41jjhjGqVimybdoGYXcZVFQvwJ44ieK11wj/JxYwnS9daVBNw7Yzdr5qj06kiXSxzt+iWJXRWDkmREqTiUt1DCZ5qluCWEqhRl/0lKcPp2XF52VBnJZZptMTJUDczjfNFT9OYSNp/KCMUOyufncB2qxefGSEdpbKe82w+GoiV4dNa1898QAOK6zPIg6MHzXyqeWgkELxoLnyrPWJ14Hlu+cHpDoDTIE9r5TxT5k51Q82wtTR2JiZVEEe7aqRxnq8nQ/ILzGtFOc2HSLjLauFVYO4syq+wXBYEoovgNfNujXRJw/ALE19+KRvbxs18c9wLF2jWJWlkI22881yXY/edhagkmI26eHOpKOg706vVkHG3mmSqsA6so4W0lUx/0ZMsmbkCmpWf89XxgFGJr8435dy8O0tgWjiBdUYozMkwBMfobXEoBviqP/A8tTx2bRnC640nJFBxhc4pJ0Htx5GDAhdPuTrJv6GOoMBcBE7tM60hWfGkS1GVNhVpEZnVzF4xVUuFlfAXh32yhX+VmkjtZj7fndnYic7LCXx93hGCJENL8FNVpK4922oqFIS3px23m577tqOuPGObf4zX9F3FU9Xy2grO26qQASSWyVuqhVNlIsPgBN26VBVanKZ1VOJkfrOen+ggVakkaaTcRRgVqleFAzndCyVAjaZA7kMtTgLRUSrj8vpGNEbNtG64SUvCJJSA5d6SLkU0peufgUuGiRpfz8W9QeW2/xSMyJGRKxiTxPOtN6TFDcGIAn+YNfZkyufOEVITaJq5UEYA3qYd81OD7taqLenEfGVcCmBOUrmFTSy6qTor+/tKpMCW7oDphZg9xpquyQjFUYuB6m32+5vXbdcYoUEsHEo1X+0JrOfXDJnuUVHakJgPj/NjrU9KIZ/Wp/VpfVqf1k/9SnxqOf5EL2UScecZVc6AomSNxCsrjWzhcfE131wOvH4QiH4Mis9eHvl8c+Z1J8P69087fvR8w3PTFM4LQGuDOF+7SNiuUP4wOaJLmC96fu7FsxyDSrw7b5lnsw6IJwO9RXVWZjw3uXW1FTCJaX2pus5DTYwKW3uCMdIeQegI31wOdJPjcspKxl6DEvV+M6z2JqGVGYLr1ps31DI3WxQfig1IG0uVsZBizSjSRn5W0IvMFIBrBL5+vjSF9LxtR17uhDwdk+Y3O6mAfdL84HjH07nl5UH+//u643He8Oa0o++rMsRPUaGm3IJZSOdNIlWJsOEKfLNceD6w31gUFfS8CgeD2PBEpUlEfK6s1aDl942QrGLKc63LaFCDqDiU0mLQPD7uxHKnnphylXfuavxoUSbRvpLW6+c3J7ZukpZwbmu/U4l+tvTOcb/tsLllOXnLoR24qQfe99JJOPYNVQYBpKQK3Lw713ByJJVQeYZnXMQPllhHxp+L2DwXi1ERZ7FvKbJgJ0vzTq/n9GpXSKMRf7DcWuw/S0X+ywzrOVcBdBAHiEVot7SnlVTKy7WIjiILt1TXKogLgjoaTnXLLldSn29OPI4bjkNdnhVlpdpOU67Enq+qbeuwg8Ke1k5EqIXDdVFNIdTv25Hbfc9j1PhMAVBNyOAicfpm8Uk7inhAnNQKFAlCZzBnkwWq5XV3TphR5t4+zz5VghjExUGpxJgBL3PvYDAfgDBEHFp+i9/GtdI0ubK2a7cpGYg3P6Z8/nt8/cwHNGcD7e3AmMv/OGsICred2bfy0Bynhq/ON7w/bRk7Rxryk1hFahP47v4Nv7CVdt9frz/jfbfl+dISgi4bEIhnV13P2M2KkjzWLUrBbjsUfTqlEi+2HWMwRQbqTMN8seheEVtQN7JTpJjnO0HRXTI3aTNyt+2xOvLQteX1cXA8ZH5ZCle9iKBEj/JKqijtPepi4GTKQyrE6ySE0Ljym+THJJJZuV6LUkWoFbHSxGadCyglrTmfI6L9LFJtOs5zxfce70t7MkZBbREVfteXc3ZT9TzYlnO3wTznluMsiFExR5VjmIMSHbw2krTGFmOs9f2LdNC4UeCiSI11lNZrrCB6UIIiyb9tQQDmILi0pEZNchF/54vCBV7aXudxy1lvyrnUGWDiKs/P3z0B8PnmiFEJTVqRtPfShm3NzBwNn+f51XmuaYwgbvscaMdRtC+baqYfK4ajRBn71mE7xXwT0ffZeaH29EBIFtP4oiCilQCYYlKcn4Qw3rwzuDOMLxY7onzNrSR+2ERYNCJ1EpToIMFrsT7RXs570pQ2mBkkyPlWTuUHrhNK/lkAkUknkc1S4s3WZyEDvU20dsbqSN3IB4w4fGfRg5bvmJbgJQmbGVkRxa0ETd0bYlB0GQAyT5bbQ8duOzDmWWRbT8zB0HU1JEUs7Wqd+XRxDWhZlV9FUf+4nt9qn4NaMe2U8xI7y/lYFf1FHdfksczXb2fhvC0+gIsHXy3Godd8wriJ3L888QM+4roCSf00rp/5gBajYrqyhNEuEidL8LoYJ56HWrLcY37flXPxQ9fym/0d39lIQPvO7oHzVPO+28lGnC08XD3QuhmlErsq23KoiNaRc9fw9LTllF2ZD/uOQ9YvnDJ4w1Ue9SIx1bLBf3BL5Wpg0WdUeUDuo2aerQzIgThb5t6h9Ir8UkFhj7kK3EdShtcrG0lWE10qArOxjaitxxuL7lafKDUrYhuFmL14N+UKyPbi6xYXy5Gk8F7MIhdvrv5S8c5tuPQ146UqJFWlM2hHr3Y3x7nh4AZa52HWuOf88GcQy2IVAjLz84cAxZdunYGhhMBeZKdqAQXMClBuDWhWNlI96qJ3mFzC1yn/RlXmJkknMAm7nWlaucZ9VxPOVgSIE+X8NptJrGFsYMq79o8ut9TG80v7txyy8u1n9YlfqN/zyh558Du+nm8B+Gq45XmWROXzrGfZz44QJYk6nVtsVpGoH6W6CRtVNqN5NsW1Ok6GPsPK23pi14wYleivkHXJ5rlWm0iL1JZJguqLsOzuCtlY3UUg90U8txFQU3IJm80uq2fZgJUXeshyU4dNkgA3rRu0SmRhTjnHC7r1R+cbETu4Etwe+grzZHEnOefLMehJEh53SVcgDsW8FaUNFXQBSHlnmL0RpPKV9FuZRSZWCkaUmSNKrHTku5bfK/eQz/glPyjMKKCr5R6jQYxmtXgsLkAPlUAMRSmDK1sH7m4upe13arKkVt3iHgzV86rLmWxcUcAfcX2aof0ELz9Z0pu68KRQwrfibDgtyhPZ30wF0acrMOCguJwa/oZ5uUrpXJUtysQCfFjksoAC/38YWo6nDf4kOoo+I+tOalGqr5guGaZdB+5vz4TNwLlryk0VowajikI6wHlq6bpaOFbz2gYR/678GxaNyV4qFb9NcFjt28NowCZiDeaUf09UNJtJssLsSQaywWMjsRbjTFjVJaJB0GYZKTZMQnjTvS7D69BbLrW4Uit9tbFNUhWloDgeJVJ9LxhuNz39bIVHtTy8RsR/o6X8vd9F9F6CyzxZZrNCmM1uJiRVzqMzoupiD4NULqcV2bagyRaHYn/rwSaUkfO4qE5onYqh4kLj0Dqr1CdphS6tvRe7jtp65mBKa/Chb6SVtoebRYYFaNTMC3PmC/vMJuuMzdFw8RWaVBCglQnMuT0eg2K55ZIRUEY0q6SX1gKQSEYUUhZwjbMBlRVx6syF618GQqMlFnoFWZ+RSZ4JPa5AEZ3vN+VBKfCLCkot4JrrTGxtTQpQYkFEzpWgaHWV1k0fIElAVCYWH7u+q0ElmmYWk1cgnC0uCy77nXDcANRgpNLW6gNZLzNKwF+EkiEDSFTKDusZBDNJQkhS2MYTFq/DpXIfNO64IpjnQ9a/TMDy+Ocg9UF3g5wYJT7gd5pRrtm8j4WrqJLC6MhNPYg7RS2R8jdnS7yIu8cC5U+PlvNww6e1rr9nQFNK/bl/yM/+n6eUfuMf8m8/2lKzcGaWbkfScjMqr1D5AUEjWaiGYJXwW0DabEHTjxVvsyTRvhpF4DhDuU2umnrveByEELlkTZfnFp4drsvK+ssDfa54GiwMYhMBEDaGfuM4tAO+nguq0piAc16kqnK7JPWWeFJZw2+F1y+IxTiuWZyelfy+hBCQl+w7KXTj8XuFyS1WPSiGc00aDGZe2yjFEfvHqAcgsP1k17acmTR6/rCNsmwMqIR26UMjzqX1lOcV3akubTW98fhdroBP8vuSXTl6ycgcMC5E+fw9ugncHToq6wuirBtqvDc4F2gPA0Oe+aXBELzMQBbCtm69tHqjwjWebbu0kGG0gaGvpAoF7m9k9vd42jAPtnDZdtXIy+aMj6a4fPezozKBi6+LGrwh8qPxju+Pr3jpTkWaqYsVVgfGaBkyIjIkxWWshHvvNSq3U2cl1zduIjafgzrfM9O8koZBpOB81JyGWtq95POfjSfdSQvdAak8YiWtwuq4UCXy3LHKlI2F/qBATzkorrcYJs/JQgVpNXvInw806326BIF0scxL218BLjLpuKIy8wo1xG1AZ7snNp6+doydLjqk9ixUgmRz668gOyXxrJ0vz+s05jeoRFXPzDq3J0t782pmGJcWqszSlorQt5mW01y197XsNykq4mYVxlZJESpxTK8Pco/FqHg4bgk7zcauQ2FjA9MmEp0urVt7WRONj7p+xiu0/wHwnwHHv9cb81LAfx34M8Bv/MMd1qf1aX1an9an9Tu/fm/Yx/xPU0p/8e/njUopC0x/zzf+Di2VpN+9SB2VNppZ2wJqkpZAaJK0XHIqqOqIqQIxKt4cs2isa7LthM+Gk5JRD8rSjRXj4D6wN1Hk7zHSsgBQFzHx1LMqmWSyinFwdFmZwl+BOjbVTD85bPYBCyYRLzJpVn5tQVTPuTJqVeGxmVEyVNspBu0Iny8/OmGrQLoLTFHafbpX6Pcu+1etrUHJLjMwoiDVpD202NGYXAkonz2xrhCGpg1Ulfh+LaCRZcWgspp8buu4IG28QurOn9ELGddv1OrBlaRdOXYOTq4gMNXG07qZOeoCQHHO473MRppqRh/kMwZXEVvFdKOLFZB1gbmrUJ1hioosjkKTQQkpKVxGG365E+TqZazKZwMcqoH7quOr/oY3Z7l3uqFi9IY5GN630kra2AmfRHXG6s9KS3sRyJ6iKW3EfTUyecswW1EBeZGV9Qcjba7NClCafJZ/mjRq43mZTWArE3i4bDifG9SbDCrpVAYzKOxAcVdIVtThVVyJ2UktyMEMHlkKqVlRPWn0uCIX9QzKJ5IVYMgieqzi+p1+m0nRDtxZPiM9a+as5BLuPYe7rvDSAL6KNyIynedtS0vQuAjbmYgjLka0PtsfZU5cue9Gw1xb9vtLudeewoY5KJg1g61Ke161gZjA9AaTdzaRA1OCOowrIjg0iZAr3gWpLJsQuP2I1onRtPlcGsI20t4OfHaQ6/PQtZyPLc+0aJUKOCZ4QUP67cp5i2b935+WrL+fgPavAj/8B/jMkP/mq3+oI/rIKxmY7mNpJ5leZkNhc9Xvj3kDrzK6aOmwVQFtIvNomfJNnzZiCJiSYhxdcUmuKoH8Kh1hMczcTMTGM+1sRhrmgNaJfNN1q4KkmDtHbyIvDpey6Yco5G2rYzEnHGfLcd6I1YVfIeh6zooLFeXB0+O6GZmB0rYkE2+tC8yLNNOzoOWik4C1oNXsWcsQvFrbcuJxlc/ZpD8gNy8AgGUDS5Nm0LJBaJ3KbxNbDydJRG5rbjcjbTVzGSvixdGcllZmRoq5q8+tVisbfdUiVYjqeW19AZtYlbBVLH5bPrc4XeWptuJzdX3On6MmDBrVGWYvG3/wRoi7oymIu8oEpiBBp6oCm1pOfEyKi695P2x5PkqvLY6GyTmGvir6gV/sTmgSp7kmJsWrbAX0C+0DjZ750XjLwyTB7zzXVNZTW8+hXdU0Hs8bxsFhXaDNc7FuqAjHrFqzTWzyrDcmxTRb4tlRn/O5HTMwIeaZ6NKJjFCdJCgV8n0r7XPtBQi0KJvYi0hiNY9x9QFsRa3ftwIEuVYFUWmdv8oxKNxRUT+ljJzN81eV2DUjjZ2LpqarPLzqhejuTdHr9JOAkdSkCoxeBbkhxPGCD5Zzno2b6XJSmhIQFOZiCBrYZQX87YSvDGFsCPm4xJJHWox+uyZvKs/Jkk0ikoCol9TNzGeHM7Xx/CgHyq5psM3Mz9898flGGmBK3ZV7eA6aMc8+w8mJy8DybC7rKkh/tPWz3HJMKf2r/yAfmFJKSED7iVipiugve+IyUF44JzdTuXApKlwVUDoRr4bEbqkWgkblHdtmbtUcJAOOizxO1FSVFwPEvIxJpCg3dFV7Qt5EPQ3uKffk84MXKwhXwrbbjJRcYOxTtIWPZLTYWSQjCL2F9+PbdeMv5o8VDI1kp6FNBTGpnAAZpskWvo3tFfWjwI5DvYrXupO47U4HxbzPA3RL5uoozFmXXn7K2Wl0aUWLjoY5KfRuxFwF5sZ6nm3Dcdyu1yL/9pgU56tzqSLMG5juImmfuVZ15g1N+gMZsRQUd3XHL+9f873mJQBfXWR4PnjL42nD1OXNsfHgoHVzUSt5n4WH0aAvGp2DaugNYRNQVWSfA8rejrz2e9H29CsA5HHc8KbbcxorAcKQz9ePbRYbO3HjehrbMnjHy1pmct+p3/GlfeTOvuL/Nf8SAN1cSdDbXPiFzSNtzlp+pf4WD/2GxvpCDfnBdIfKVYy9QsNdporhXIkcVb4+cfFCMzBf8dD0DPV7Rd2tnLJYZeRoymoqufNhRtBzwg4J7VO+H414fmUzW30VZLRX6AQ2a4u6MzTvEq5PjHvWyiMpzoNI0C3SV5t6xmT5sOdLS7+4RXdWkLmZAgDyvb4RGx2/W5U+lIvUNhQAF1BabWEXMict/+aoyp5QxutenKf9FsaXoXRf3EkS1aTW55k64Kx4vB2qgfqFnIiHzYYEvGrP3DqpQN/ZHftGKnF/tRdhErGNggqel65Owt/+GPrkt7oSvydajj+1q3KB3XYokHlfRYEMX99wkya6WMwRl4H/Ii2UqhXBOE0iCLpc9KUNCKIPZ0ykKlJJkfFSkQbD6DU6vy6VhS7DeFgzvOANT13LTW6x3NSycR7HhqfsdRW8Js5GtPs0xDyY1/uZOSrS2VK9vxJJbgWNla78zEjgeytCsRm5Ja1J2ZSSXqWKXBcJlcK3Zq0GA4QEpLypLajMWiq32Eap3pDNQ1tBGVY24DJ372V75mV75teA83Nbzq9Wic+2Z8aXlvNRbtHqSarApCgBIkXkQpIH/jkjdi5Q6cC9vXCsBfr+ut+X1p1ajNyQrP40t1wuTRHE9YMjTVpQlnXE9mureHYa1Xqa3HL0STMFQwiaEDRzbhWP3grwYnIrIGMbcC6IMWQrKMefbx/5I5sfEZLmnd+v91myPMUNczL4DPufo8YHw+gtrZn4LJvmPW023NcdL+szUy6DxmD5KiiMSdzuugJe6kYh8+pRF4BEqMVYtuiJZvFb5RX2bIo2I8B4kwFHCdygVo1IhJM4HtbPHV4KunZxq15awrFKmPFDF3YzJVwXMXPC9RqXxZDH3jBOFmtCOWfUWfB6djgb8Nl003cWNciGv8hvpRxQ532CvS9NGWMjISqeupYht/WmhwYVFbtvH9k3I+dFyODcEI+O6vwhenI6wPgikDZhVas6G0wnATlkbmbaKEkakuJlfWGbnX5/NX3B6/Oeh3FTqB3HseHYN0IHGU3hMza3A0olpskSMtGfKnL74vxxeWg/5esfOKAppf448F3gHfArwH+RUur/7n/1aX1an9an9Wn9VKyf5Zbj9VJK/VngTwDfALeI61JQSn0P+MvA/y+l9L/62Af5W1kpyTxhUTw3J4OaFWHQxQXWdIrQG/rPZPAf8pD5PDYycE5KOEkgrctZYXaeqp4LCGAOhmmy1E6s2UFgwWedB8CjJizzgo1nulOYyqxtnzaimkDwmmm0DNny3qiah7ApJHCQSlB1Mj/7wLdskhmPmvWqSB8zwThzlRYFcS6O+sFQHSlZp+0S1TlipisCNdJeQYHrUplt+B1FSSJl6P2yVAR0otrJB+82A5UVJ99xtsTc0+p8RWM8n+/PBcrsveGpb6mtp61mjjdZyHhXieLDpAiLR5TL1VYl7Ve7ya3MZuZh3PAr5y95Owog47FrV3sgnUrmG0eD6gxMqzKE8ZnzdvCkNhKGhb8g1bW1kUt2T/7155c89w0xKtp2YruAQuoBrVLxgQNxT7Y60tiZV3WeldUPfGGfeQobvk63fDXeAvC1vuFblQBO/NVFNjpymSu+f3lRwAxbO7K1Ixu9Cj//odvXfLl9JiJu2O96aaPOc3Zb/7GZZ2zzTPkDdZgMqpikBQ3rDDNpqUKWeZm4lsOkVwX98S4RdlEqpl7h8/w1tBE9GepHqdQgVzx7UeRQEewlA3ROmvlgSc2KM2uyqsqy78aFXLw8X9NVJWWk3bhIZS0X2XvF47CHYRUy3j6I8gzfXjsjAKenDabTq+oJMN0opvtA2nlRmFk6FE6ekR9/JubZcJxqtmbkpZNr33vHOQsuz21uvRrpYJxHgzpZYp0pFFUQ84grx4yUVrGFj7t+77Qc/xngf5FS+tMASqk/APyjwB/L//zzwD9QQFNK/QZwQsAkPqX0jyml7oF/G/hFBPr/z6SUHvP7/xUkqAbgX04p/ft/t8+fvWH6ekuTzaPcUeZM89bIIJzM6h8Vo67pDoa0SNP0ouqdnCC15M2gmsB+17Otp9LGOo8V7W7mi92Jg5OH4WHc8LCZ8JXHmFRmaEon9F3E70zZ7Jb4YWxgvx3KxtjPjudTi9KJmywP1ZmK7qlCj4L4W25wTkJG1vPVADzIbEwlUU5f1D/qR0X7RjaUZb9sngPuFIhOdOjmdtnEDLaLVOdIqBeYo5BTdRPwN5qU50x6BjsrVLBMOVhPlYAuYlISVHJgeX3aE5LCmXVekRIcL404CQRdArDfp8wVTMXbLpiEqQOu8Rgb2TQLl0dzmmremy3HUVqOczB055o42KyAsfTbBKBjRrXKMGWVfnUxxRMLBEhU3wzsN2NpOZ7Hiq6rUTqWVuqy7hsB9yzt6ZcZ8OGjYWvlWF/ZI5dY8/8+/RJ/6d3P83SRHfN22/Nf+/x7/EL9ni/b5/KZ57nm9XnHrz+8pMpz3d+/fcecDHMyJaC9cBeMSoQk7a7uGi2nZaNfZMFiG1Gtx9ZeDHDDMjO0RGuYN5rxdklkUrHiCaPCnRaQRCoODTHLiMYmkbae5DWxVrCAGYK64nHJmreKeSfH5U5ghwwcOir8ruLsAu9yUqlVYs58z+7SELLCz5LEJUUJqqERTUQ06LMpNi+2QxCdc1rRuKP8htO7LT+CMg9NWbAgulQshqLL90l2U1hEBMwoAd3vRGcUII2G8Wz55qHlLwTDi43MSd+et1TOY3TknBMkrVIGl2UgTn5ep86JsXBny7w6estTtVosfVr/4AHtDPxHy3+klH4d+HXg//ZbPI7/Zkrp3dV//yngz6eU/oxS6k/l//6TSqk/DPyzwB8BvgT+A6XUH0wphb/1I/MKYpK39Pptn3AX6d+H/OAlk+HJ3jBfKWSolDdSF0tmpxvPi7szP7d/wurI87hqMd03HS/qC5eM4X0eG1JS3OwGPt+dOE+SjR2HGqUSfYb5Q64UXORmN3BohoK8ugwVfrQiehw/zJy0B3pV5J2SkQwxNCuq0z1r2jcqC/KumWv1DNU5iddZPnv1+5noNPNW/pkyAETPiVoJwso360A6RYWxgbif8TpXlJ14etleoV5nabGw5VK1YmdSBTbbHHjyXKEb6qKCkrK6RzwLQq+IKTciMr3YhkBODHTEmMR+M5Qg8/68oR+39JMrYIi+q8VrKhN2U70MCBOxSaioVvTk1sOkcc9im1LukzqybUe+vX+msbIb/zDdckwbiELAP2ddzcem5Tt3j7xqz0WI+K7q+X3tO7pYFc+9r+Y7AoofXO55+7hnfs4Z+2QZX1m+sM80G/mujZ74XveSr+OBbqiKVc2y5mR4aSRohqR5P285ZfmsBYhT1Z5h1qROr4R5k61mdCoi0QCPl5bxXugQy6xXTwr3rFfqRD6NthMidmhWIePYSrIRkxJlmjyz1p2Qg6OlVH7DS1HMWJILXzIcqB4087Th7W3e9KtQoPppXJOO6BK4hD+sCEOSQtVBqtI3NVVWxameEvUpYobEdMhzzxtFaEGNhtPTZkWAeC1AlnmtxFRMxEr80FB8MJvGkK1m8ixy0FQPBjPA88ML3t3dyu/Yz9zfCm1gscYZ+qpot6Yqoq4AGiko9KA/MLINzx/f4PNnuuWolDJXAePfAP57wJ//bT0q+OPAP3n1nX8B+JP59X8rpTQC31dK/RrwjwP/4d/xk5S4E0e33BgaFaQyyZU/2i+gBzCzKqjBeZtQh6nwkkBK/soENnbGJ12EY+co//vreKCb5b3HviF4jQ/C+l+Y/7XxTFF0HBfFc4JCt5HKiiyRzxtxjApTSbvulDdLP4oFfbQSWJZsVCUEvVatG3asNbGSm786SlsRBHKsQsL2ieokG6Y9jYwvW+atJrgV2RaMYlRZtXxJCBMwaKZQowZdKqywzy4Bsy4gDVyEoxX5ozuochvx5aZjiobffHtHOOUdM7dqVFToKxTdvI+CFm18kZ8yVkAW3mtmv4Jg+nMNz44pbT/w4LJBUKXRQIkFNpIiIjDbZJfk/UTwhhlwR7N6fgH7euIPH77mxkq1PAXD64cDwYv32eJYHoJmPFju6zVAtGZibwYe/YZfPX4BwK/yBYdqoDKeL1888xWCxnSVx6nAC3Nmm4lh7/weTeJ209NUcwmqRkVc9ko75eg7J8Pz3NL5ituq41tbAZDc1ANP25a3br/6tCUlvnqTxUddELa183T7wBBMSXpMpwQMkiuR6+6UmfP9uFyKSry+4mwEiLLwMINi3iaSUkVNZnrlMTtPeKjw/ZVgdv63nlRxW4+DSEClRtCIerfw8ay0j6vI5lauzzwbUhS0YNxE+s9za7sRRfzNHEr7dd4qppv/P3t/HrvrluV3YZ+1936Gd/oNZ7hDVXV1dTftEdPI2FaQCXbEEBIiIqEQMqCECOQ/QghhCIMJQxxZdohshwTkYEVWkCLHcUgcHEIAO5FpMxnbwmC7x+ru6qpb994z/aZ3eKY95I+1n/28p1zVfW/Vqe6q6rOlU7fOe97hGfaz115rfYeolYDDmWdZr5mo7Zfz9etsXnqyr5X9Zy++5BIum3f6uxo76PNnR0HygzUF4QZo2qmgGeNB4flpFcAlUtZuE5t0HfKmPJjJpuUZe5PjezmgAUcR+UuoWsiPA/+wiHwZ+Fd+wczok48E/Huitbd/LaX0h4B3U0ofAaSUPhKRd/J7P8tZhojy4z77tV8oIr8D+B0A7skl7lFfyn1DbBEvtDcJO+Zyn1fF7JlAWh7IbaJZTayakf0M6Q2G+67lq/aSXT2UPsZpqBkmh/0aXogYFVr9+HhByO8dvcMaDV7TWhcPX1vadqK2gZWbGHIPTTaq3TdMrqCxpqABJDbqcD3rNtIZ3MFo3+Aqo/AuAl20uJNQHdXeAqA+RJIVJCWiyyWmdaXK+RbckMpC7ldq6jheLpBuOwjmZX6wZJH1CkFIq4B73HG57fO1qThNa1K04JfAbAT6yRFvmqKRlyz4XSA1gTgJbtYQHAXvTQ4c831OxChMg7qFm/na39W0z81renqhzSW2qHJM6bBsGJJNxE2g2uWFvJlItaeXRBhampu5j2GpbOBv2HyJNqe6937F/t2Wm9NKFfBncrfR/tncJwQlS38wXvNzx8d8vFdE4zA5nI1crzs+t73jvRx4Vnbih1fPCAjHfHHXZuRJc2DjRozEQr6+dkeu7ImfH57wlx4+Ayht4DRVXLcdn1/darcbOISG580OZ2IpQx67hgkVtQ7RUOXotaonbuuooscZ6WkqtIx9ygjdhaevvbZaitg13hC8JR0d9Y1dUJXrhK+UJBwv9NpcPT3QVJ5n3RV+ZUpyJCH37dZxWbxjlqczUDW+aG2eghCN6oMO/VnmIkkrCVcj8UpfOj12xKrC+CUgzXyy6k5RlkXZPs12SamcgwQpogXRUXRAyZtKmRaovz3aLGYM02aRxCJCPDq63Psun58EakE2HnOG3F23AycX6WnLeZnmTSzB3zvjkwS0vx/tj/31wN8JvA/8AeCfF5F/nwwGAf6LXIL8tOO3ppQ+zEHrT4rIT/wC7/163cq/aj+Rg+IfAmh/6LPfxfuNt+PteDvejl/Ckak4363jkxCr/yjwR+e/i8gTNLj9SP7zdwO/E3Aickwp7b7e9/wC3/9h/u9zEfnjaAnxmYi8n7Oz94Hn+e0fAN939vHP8YsokogkdtuO+wetlSWr2Zi2uXKje2UYLzTL+Np7GaNwteq5ysjFl4cNx1PDGuLedAABAABJREFUs2Bw15GLjIZqnOeU7T1mdYq+q4lBCN7yYVcTcslEXKLZjKzbgXeyJNGMiEtJOE6LkgQo6XdVTXw02+B4WXaKfhFTTvWZl1VuwIsLeJMIG0NsDHZG7M2kUWtKOTY0hmTnstwiFitpKT8u3mlpMQJt9boCWATfiGaQ80Y0GqQNpMFgjpaQCeIv21btbQ5mKes5kK1nd9FxXDeMeTcqAeUL1kaVIqDszDvfQG+JeZdbdUJ1yD3QnJmEJuGvAqZTxXTblzRPlfzbxc1g36+VbB7BnXHsxAtTsLRmZGey/Uv9wG9+9PN8qX3MX3nxHj5zDbebnsu6Z+1G7LnUVxIuq57Hm1OZT6O33HctV03DdaOvX1Ydh9Dyl/rv45TVmIfk8MmysiNDdKU/dqhaYjL8+OE9fvKlFjOciby72/Pbnvw0f9PmJ9lnebOfGd/BR8uLavsactZUkbr21M6XjDJVqjrv/ZJthJgnQdIsbeaozUCMmXMGYB8sIWrGYXtZEJSSkZXrSJ2z4stVr73lwao6fkY/kmC6TK9vZZugfVQvTL1ToAvaDsAl5Q/mTDkFFeSuVoGmGQpwZ1pbDmkDVEVVJ9YJdxTWHwvr5wG/0melf6yAlTDJosAzzpxNJW4X9O9aJancwcBB70+1FzAwbWG6jKUsjwAuQm+LR1pBaBoDV5FN9lZMaH+5rSd6p9mnHBzfhoLjryz7mAze+FP5DwAiUgF/LZrJfeIhIhvApJT2+f//7cDvAv4Eipj8vfm//2b+yJ8A/oiI/H4UFPLDwC+oMTn3o8IxSyBNQmjh9P6iSB/aSMrILaBMLkzCT45dNRSDz7+UPsPh0DIOFTenFRcZWbdyE04ina/Yn3Kv61jpTKyyUvjsEDxB7xUY8nSjPZbaBm66NTenFd7bYvdBEk6rUZ1ub3RRap7bRY3DCyEjMGXt8SYhgyk0g6rx0GTl9aomZQXx8cLQ3CWcE/wcuGI68x0TzLTM7PohUT9Q0G7Dk4hfLSrs5+r7koP47MGVErjaM7UW2zncYf6MFNWJGXjhH018/3s3fGZzz0/fPuVVvmax13JlGA11Bm9YSVQucHSR5N0CFQVt0gcKkjWstTQr2dpjDvzJqc5ntbf449LjmYO1mXitR/L8Ycuffvi1/FCre6whVlQm8Krf0HU1q+yT9oPXr/ih7UtiEh68ntyl7fjB5jnj2vIfmh8GFH3Ze0dMwotuU5zRjSR+qnmH91cPPMkQ/0oCKzNyCA2vhg33o86HF8OWmIQv3TwqIKN3Hz3wG64+5L+y/TH+2irxQdD5+yps2bgBw+JBN3UV6WTpmkwQz+i+2qpkk0jCt7nvc1QbE5LhzAEnq4HoZqi51ddsb+ifCmETMxo3v3nejE3CmEEwH3GBHy3VjaF9RdlwhFYUYZwMYUbd7vJzOhoYDGEuua9C8XCbQSMkIUUIlZaqZwTnOKocnUL6F/pOddTfnjaG4Vpf795NevyT+sCBgspcJ8QzWTDQvntsIs1Ly+rFXEZUsIyq+oi60IMidqMiKAv68qjzcxCYznrDMQrB5nVk3s1GQdx3cfQBROTvAP5lVBX0/5hS+r3fyvd9ElDIR8D/O//5kymlw9e+J6U0oT22/+xT/v67wB8XnVAO+CMppX9HRP4c8MdE5B8Avgz8Pfl3/kq2s/kx1IHoH/rF+nghGh4+3FHfLFyV6TISL/zCRZqUi2SPRmv1MwLOqJeUkVgMGTfVSJ3VQdrKs8qN+dqEoshcZURZ2A340UFG96WZy+aNPmhJuM+w8hAN+1PLNFmlA80qJkkY7WzvkqkHB80w/RowFINPMQmz8YTKYPJDnhKkaKiqgFyMTFn6K9bqHRXqpf8VbRanHfU6FXfqkF+TJRCEa4+YRN+o5cZsbEk2Fz3nx8SgvS8mwR2z6zQQGwXgJFFvM4D2cuCHLl6ycQMf1pecMiJysDXhpL81Z1Lb1cA7mwOTt9wdK2zWJpRJMzMzLXyram+QW+1lpDM9yNhEiJq5Fmkmn92WM/3Br5ZFo3ux5j/Y/CAPj/W+be3AzbTh4/0OYyPff62r+W979NN8f/2Cr0yPeT5dACpn9RvbD/jQ7/gz+eLuh1qzvsozescx935M7mepa7XOvc+vXvGF+gU/1n+Wo/8+9jl1fNWt6SfHOFrqrOV41XY0xvOhv8ZyQ580+B1jw8thy0f7Hd1ezyH1Fre3pJNhTHCYLXDagdoprLwTnTceCOIQL5itEMcFjWhz1lJlDpkddNPSV6Jiw/OUNgkZDe5oSHkTMU2GJKm4Tn/tdySz6DOG4Ii1bpzEg+QgFUfNqs0oxHamJATs2lPVnmmyDNnl2+wdzV5es4Sx2YXdb4Rxp35noLw5rAJeFqksyRmp0j2mDJaK7aIRO3M5JSqVRvpEVcvCLWsSaRX0esyWMF3u4UdInaXLmyGx+XsTpWKQdp56dW4D/obGL1GMFBEL/KvA34ZW3/6ciPyJlNKPfbPf+UkytH8ERTb+QeBKRP4MOcCllH76m/1hgJTSz6Jly699/RXwt3yDz/xu4Hd/4t+YDKuPXJm0YQXJRCUmZ1FT53MpIQlhHamvdQGJwWBsJCZTYNaPmiM8VaPPz63veJpxwEN0fLl7ROcrdjlr2zQj+65V/tNol6xpNdG2E40LRV7neL8i9RZZ6SSdfbVSglWjbr2vrvV4x2NTPMdIIBkJGHuLaQNik2Y0QBpqzWwuJ0ytqDCAWEf6WFM/SFmwk4N4FNqXmZNzVs/QhV3RaaAPmK0i8ZG+qT4rA8aoMlCzAPB0qpCTxR0zXHvOmnKWGS0LzaDyvBo2fNRdcBzr4lIca0/MZqCF17U+8usvP6I2nv/8YYW504ffjkqQTUIpXZm5gV+Bb5XwCyArTxSHj0tZ1UZVUQ8Wpq2WKoFsdml4dbflr8j7ei+C5djXhGB4cnHk1158DMBvaL/CzvS88BdMs3RVskzJ8BBbhrjQFIahIkbz2ibg0ebEO+s9zsQy93am4wvulq+Yx4zRlvLZte3wtaGysUhc1cbz5e6aQ2i4dicOuWx5M274mYcn7G82mCwrhlO5MknqJTfrVLbOMwXDOLmC8p15gcklpl1hUJBsdqg+20SERoqkFpcT7QyAmizTbUMalrK6PaoAthl1ozbzJe2om4tQLzwz44XhiQYCN5jiAD2XQgH8DGjCEqrEgG4kJVdqqr2Sve24lEiT0d/2q2y6uZlPROHyEnkNfWnHTENrzkruXYb4+6XcnZy2CFx2jEgZZOS3qegc+O1Mg5ivL8hkCsoxnSFKZ0/Dql1k997o+KXrof0W4Is5DiAifxRFsn/TAc38Ym9IKf2xlNLfj4JBfhvwHwF/H/ATIvJTIvIHRORvzWXHt+PteDvejrfj7QB4IiJ//uzP7/iaf/8s8JWzv39d1PqnGZ+4h5ZV9P9s/vMviMh7aOb2dwL/d0BE5E8B/1ZK6Q9/Kwf1pkeslPMCuvkwg6HKdhewyPbECqbeFPh3ilpyvB9bbnJNYetGfs3mGe9W91TiqfN29MPpmju/5qFuCzfNSsRm5n+MuhMH8KPDu4j3lu5Wt3HVC4ckGB+rzM0uq4I8WZ9YuYkxWvanTLpd10rsdMqRmf3QQqgIF6rIIHn3a4+6YwyxIjRW+wxoljhdGKawTIFkE2GlmdgMU56vj0ft64sNTxVZrQdiNIyjLQK8beVV+QMK6ODeW9LBZZBGIlzn+7KKfG1X+3C/4md5VLKwc/WNFASxie1GM4gn7YGd7fn85pafv7rm7uVsZQ3TVYAqEg7zjhyYFRYsVJeauj26PHJ/XNHXTVEPsYNTSHWT8JcBe6GZRRgsHBzTqeKV0/kwdBWpt1S78bVsqk8VawZuwoYvd48A7Ytd2RNjsvz67Uc6F6Llg8OVulm7RfT4V18+5936gVfThiETDW/ClrvYUEnASKLNsP332j0XruPOrzlkgt3KTtxPKz44XfGxuSiO66ep0qrAtACLtJSsWdpmPXLdduV4704rxl5FrAHc0SCTZhJhlfAXc003MlQO403JePxaIfozgbu4LNQTt6eK2C8uDe6o5e4kmu2NlzNdQ1VD3EkWwNMMbRf9XNZoLjY303axn6nuhdhVhFbn3+w/OCt7xArSXHJ3FHGCtCSPmMFQ3xnNruYsflAXCrW6AcnPIEfNzsy4vNfXqDpLzkDnqkFo9TxSlbSXR+ZLnrTsmmxS0Aj6eTGJNBhSLlfLalGheZND3lzJ8WVK6Tf9Qj/1dV77ln79m1bbTyl9DPxh4A/n7OxvRoPbP5lf/84YJjF8blpIpIMqJCRnij+ZNoK1Z1LfGoZKUXjJKNflmYtF4upxe+T721f8cPMxNYGfmRRV9nLaYkg8bQ7cGy19rd3IRd1z0fQ4E/nSra7k+5cbrY17wT5kDbe9qjHIJEzHijH7bb27fuDCDXxx/4Rp0NuVqkTcqExRDBX1/dJQHnCER1NRKQitPrwStQcXZ/uMNdjdhCdLfKEPU2gS47WqIlSZhG2mhNQLkRuU1CxA31eEkyPMpGQX2NQj182JfaXX4dg1TC4p8EMopqCpCTCZsriA9nP6pirqH+9ttaT70f6CEISqWgLcl/caKKwkRu/KoxBna5t47hWnvRIDjIkC3vjM9h6RxIvRESSXgnbqhpAMClg5LY+JBIGjxWftPTGpPIGnqeKD0xUA/4H7Vbxf3/GV/hF3GbxxV625C2uu7IknTs/rs6s7jCROvsInW2TT3q0feLe6pzUT97l2FZPhY3/FTdhQG8+TWlfGzzR3fKa+pZLAXdC5e4o1L6cdXzld8+HxsmhPWhOL/iXtWfv5rlYwQl+VDdkXdjdMwXI8NWRHGNxeaO71unTvLACHhCE2kf7xggScCf+2M0Rfczdfxzpibx3tS4PNsuYSdf5JyvzHuU80lyxlkcqyA4S7rFaSFkCSm/Q5njYUwJfxSop2h3mTthxbcksQm4fttbQpieJy4E5Cc6cczlkpx04JO2Zjz8Rrfbj5++fSOkb7uvOxzoF5kc9agkhoKK0E/cK5xJ/nc784XgxJMG+67HjWo/slGJ8atf6LjU8rTvwjwGdTSv/2+esppUlEGuD/lFL6x76VA3rTw1WBH/mhrxSB11fdmmFydENNt9UFd7y3VA8G1+vDsvpq7m84RS3165qQ5XFqE5iSpZWJKzPyE9kwM2BozMQx1BymLGMTKlo7cVV3+GRospfasQmqnuCXXefwKGtG1hEmwzE37L+yvWZXDzzb74qnG3VkfdEzTZZAtdi87AGErnYL2TopJF2iqGt3frlp1DT0bjJwyqCTQbOwZBQoMq3nor0wXAvDVVoUSKLQD5UaDx4tKX/HXec4XdSEK0Pvc89vXyNeiDuvKiBzAO0Xg9KyqEyGad/g60BdeVx+ep9uDmzqkd47bu41O3rYr7jvWoyJHJ5vaLKeZHJJBaYrRa+CCtTaQX8rniHDYlKqRMwi1ACpiiq+LNrHMKfcxF/lbCMuQBxjE7LxrFYj62oqyMMfffbXFMDQ+bgLa/ZhxUfjJQBdqLmqOq6qjrtpVebpg295v77j3eq+fPbGb3g2XfDV7oqYhPca/bfvb15SiScmw5Qv5BArYhIa619zCLcm+4DthpJVh2DoOocMBn+sGB/pd+xcz65uaFcj+0rntERd2F2XiJUhVvmaZwELSYt7c2xiFjCWDMXP932yrF4IzW1CMrdDEZJqXVTfe8ykxzbtHPvPOUXUZtkqM6asT5orE/n3bAcmJFwH4SjleN0py7c9JJr73EOuhGFn6R8vgsNuUGm8JFnfs5/RhBS/vfl4Z9ku3+bzPqs0TBtKDxdyPHYQ1jlox+UfzEnBSMUJvtYqydcGFZGkEmUuqUkxIA+W+N1NrP5zwA+LyA8AX0VlDf9738oXftoM7Q8Afwb4t7/Ov/1m4B/nG4A5frlGZQNf2L7iea/0uIehxdYTF+3AfRYA3q9X9NuK+qWlvl84MH6lO6iq8Vw1upX8wvoV71QPWBL7WPEie1j5aHjwK170W/ZZs3EKlnU1sa0HjCRcLp81q4nRJoKviDMQYJOQKqrQaWdKw/zlYUPXVKoSMvt51Ym2VqDIwy4wlFKZIgglmkX9YJ2YHikHSLyUJL+ygRiNItz65fPFGNQuEP3QKBfIbwM2y/kYkxiONfbBUR2WzyVrmS4sH/SOlDNge+8I64hbq8mpzGCEnK0lWThv9mSIkxA30A8VH+yvAFhXKvU0nPHzkjfsDytFop4WiaooumikJKVZ7x95/KxNuZvKevHstOXusCKd3KJ6ETNnyio4Iatc4cm76wgxb2TsZiRFQ9fVJLTkCqqAspeGdbOU8BozZYkqnSsAx1DjJFKZgE+m6DPeTBtu/Yat7bnJemM/d3zMq37DQ98qN9EuAXNKlo+HC25HzdCMJHpf4UxQZG5W/xiC4+AtxizlqhAMxfnYJuo8T++mFS+7rf77jDT3qqxjx0Rzu0Dep7WiR4nqvwcQLqJqI966YnoJmvG4U0L913LgCapOUz94bL8ENFLCdZlekJGE0iovLDYJ8RTvNNdDvY+4TqizaHIy2WE7JOqHSH0zE8kECXUWKZ/BJmSNyaSBeKaLBZCQstPAAtoI9cLBnL3eQqMmtPHJqOLaAINZOGdBlG6AVkyaG8li6frWsUqKqgQwqSiIGKttC5nU2RsgWaF79KZLjsvG7ts9UkpeRP4nwL+Lwvb/cErpr3wr3/lpA9pvRLlhX2/8xygi8jtqhGh43u+KY/HL/YZNO/Jkd1/Uzz+orrh1a6awAjGv7Zbi44mnF0cu6my46U60MvJxuGAfVnzxpCXHjzr9fiOJbXY+PlBzmipOU0VtA8fMywrBsF4PxHYqvCHfOeXOTFoSlWZGOQohW5DIDMWfDPtjS9N47GYqPLJ+dKxeiGZqpT8ixNxHi44i2no4tYtl/fz8jLrTjPODWq5DhrlXKmIL2QS1t6VUOwcT7YEIPtWLC4Do74pRvtgcw2OtsGUxSSHXoD2CJuK2yn+62+vC3zUV713suagH+rVeswdvCEOWDTIQZnXzLM9U+IQAK09zNbFb90qXyN+7v9kgnSIw5/5gcgoJN70i4eZzqw6q55cEetFHx9sER4ccDIdVy/GR3ntrI9ZF2npa9D6TpZLABExzxWDYYEhc1B2GRJ1/bAiOn+8fY0i8HHW1ux3WhGgIUVSAeVKZq6+uL7moe5wspfGYhKOvMSSu2xOrXMJ+0W95dr+jP9QUv5wgeq1EbXVeHTUo3netlouHZZmIFYRaVOT7FIl1zl4rISaKG7W+pnxJ27++mTI+l+TOVh8zwWAMyThcbahOSylNy3uLxmqyikJMdcIMi96nlg8102tvM4rVJ/zakixLkMxDghKjixt3RvIqanHJumymrYRGA+l8DOU4ctlQTwTYeta7YbFEyhy+MBmSGMj3IlSOdO90TuVjmJIikNWaSUpQjBm5XO8Fd1zuhZw+7RL+CcYvIbUtV/u+XoL0TY1fFOX4NcMC38ivYAN8G6Sf34634+14O96Ot+MXH582vP85VPT3j3+df/sdwJ//lo/oDY8pKIrsJu86h75i1Yx/1fuMSaS1Z6wMUi87uXo9clEPRb7oEFp2pmeaHB9NVzzrlDR7061pnOdxe2a/0a/oxoqUhN5EThmlmKKwXfdcbE7cGD2uvTfaXG4DdTOxXWnds3WeKRqcWywz7J0j7B2H3VlahGZV00aJ0EXy6UyhIa6X8xpvW0xvsAHOBWZjDeNlJDapCAbP/YRgTDHnxM0loyyHlHd1EnM/xWVQDejO3Bum/Jvze80opOCU3JyvuVyNtJks2h/rkhGShOeyZdcOpSc0+6Ulp01zn3fPsY2YwWCPsuy+LxPOBUJUqw7/SnuU7mRyb2ThEqnqvkV6zcjmRr86NKSsipF3332toIMj+LVlyP1TXyemNnIThVMmO39QX+GTpQsVH5103uzHhtoGLuqOR/WpIBp9Mjzvt4zRMeRepI+Gq6ZjCJaHw4oxo2ZHbwk7w6++eM5nmjtAQSEfuUuG6LiquvK9U7CMvcPeVCUDn/3fUhMRFGkKkEaLjAYZpFQkY62q9NVJlWRmMIQZKL2mudImXlGpJClZGWQu4CYDlWZ+qIVhA723bD6WkqElUS6behZyNgx+nb7G+0w9/KoTZUJKUqBJSgr0SG7OKHM5fEj4WaXmYlH/N34hckugAFNK5cMs/031IhAudaRqlIx+ziucJkvyBqki2wut9qQL4dRd4E6mVPmS0e8Um3tmw0war8AkwjrRP80/PQp2/2lzkk8wfgkztDc9Pm1A+xdRD7I/i9q6fIzy0/4HKEH6b3ujR/cGRopSVO5B0XmzeeZ+1Jm87xr6faMsURcLcZGkROHr9sT7uQH/A80LruyJj6dLfub0lA8PujANk2O1m7iuT3w1I91u7raEfYXdTWw2fSkHTaPjYb9mClZLd4BxkbadeLo78IO7V3x+pVJFp1jzkw/v8tVwyX4GIkxCmgBcJg/nHsJBia2hheHxQgauHrL3VQD3oi7vnZUHFs8xLaGEKwVvxFlhfVB4NMlQFIUqj6w86WBwd0sZREub2Xh0JokKuAdbCLAzkVuSlppCY/HX+tpqozJf3alRv7Uc6IyNdF1driEouVtlkSjQ83Kfs+XHrPYghlxqXBNvG+pX+bpP2vMpiDN0UWJQNJkJy0JaHRS0EOICFbeTBr3mNhEfwOVrNm1hvBJGGmZ105t+w3FqeBibIjvlrAaRu3GNj5YxI+tOvqbzFZtqLOCSrq+4H1tGb1/DO/tg6KYKI5EnigziFGuG6Lib1tyMa26GXEbMHn2qiJ8DOHr9sFrWnjcR5qD3zPZSFOJDndSlIWgfrT7q/UnG0D8WhuvEdJU3J9cjxiTGqsE9nCmxjAv4KDvjECsYL/Q+SDRURw3WxieiE+yYFhX/XNpMovJ15gzo51vV5pznnkTwjc71ZMDlEmlohegkW8boe4fHkbCOutEbVE4RwGf7aTsuSEvt04LthNgIZrP4zYmoykuf2wkh9wDFRa6ujvy6J88ANWv9L+5XBTQFuTQ7CQkNfsUUlYRtPQFKBLcDhbLzRsevlICWUvpREfnbgd8D/O+hmLb/WeBvSyn9mTd/iN/ikISgMj4AoTY0zhORwnFaNxNDUxMkQRDiIeOAbcJeJB7Vp6Ld94XqJWOy7GPLh8dLHmYrlFkY9wzuFA6O6kZ9tcbaF6sZOVnC3rFvKySjBs2Zr9Gj+siPrL+s35EMMQljtByzwWEHSkMIgjtY6lv93uZOd8zDYylKCxJFaQpWOUT1Xc7yes2iJC473LFVN2KCIJPBdkuzfV71Zufu0BjtiwUNZjNnLdS6eJhRsPkYTJYUsqOCB855LtpYT5h1tlipJ2ICt42sm0XYdwyWbqxoqgW1N66tCkD3VnlJc6YZdFc/XibVcNRpwDg4wkNN88oUw1fQc0tmcf5OXs+9Ogg2+8aBLoihEqa1Nv/n1+b/Ks9pRsFlU1Xv8DnIfTUamnZiHG2ZL9e7E6tq4jjVPAwtU5ZWmoKltoG2VTQqqOfe7WlFCEb7kfN7JxU3/ri/KBJtD77l+bDj4+MFvXeMeeMUosG4SGjOAkEQBYUEwbkAGY07NI44WIxdoOahTviVqMVLjEXeKVYwXiWm7xt456lG+009cntacTtYwlRhz+glEgCj/TGdJHrPYp2YdsLh/Qy6yXwurTLkOdZK6c250+s2L34tKH5qQSiGVu+NX1tsN2dges/Gi2XTE7YRmkAEJCyebKFV5GF9L+V+FzNYC9i0CGZXXgXK+4rwkEWEvXq3uTrQVJ4+cz8jgmsnxmtXkIvzw1FtRzbroRjUpkRW4Klp8vPujme2NW8H8M2JE/9p4G8UkTVwDdymlE6/8Kd+GUcSRZ9lwupD3/Dh3QXWxoJIczbw7uN7Ru+436+YTovoyTA57sYVfbaF/thf8hBXfHW45jC93jI8TRUvxw3DTFau8o5zMPS3bXlA7KCW7cGYwgUyNtD3FR/5C/6S/QzbnBas7cCDb1m7kXcvdff9Mmcr4eQg2iISWx0UKebXUlxtkawNZ3IQmx/INoM5RkogsL2QHgyIgkheK/Ek/XsqO0JLclZfMxR36/5pwu+CcvzmZ3RS0iwm69fNG20LYRuQtcfOi6hXSadNM/JodSqAijFYaqcmlnOzvZBK5517kWFKhJXSIGZiqs2oPtMtgXq+DtFpELQZLReguHvbYRGfjZUumP2jM4J5p4vrtJMsq5WPwelC1u7BfKyLUn+/4vikBpOwW517F/XA09WBF92WU6hKBmpNxJmIj7bQQEZvEUklGIaMIk05q7sfVnzZXgOa8Q3e8dA3RSQaVFqsVM2mOePP0ks2EbylyaAFfznhBWJ95k+Wy9LDlRDqM0fxRgiryHo3sGt04nRTxf6wQg6O+s4U0eLqqCCKZJfN1LTVeWR7RSXOwsAz8vAc2u5b9VKbPf7OOWuKRFzea8f8uoG01Y0GQH1/Vg6fR1TQZhJe48LFWgEaKtqdUbObVBysZTQFONPUnlU9kRJ4q3M3AdVm4uriRGUiP3v7GIDDsVVZOENpCxAFqkS7Glk341lAUyBTdbeIHktQEvkbHYlfMpTjt2N8K8TqE/CdG8jejrfj7Xg73o5PPd6gUsgv+fjUAU1EatT087eg/bOP0JLjv55S+qvRFr/cI8JD11LnDO3U1/jJgSRO6M53tRr5oUevMKIqCsdad7TTZIlR+PL+Gmd+QN9rJ/ZTy0enC7qxKqK80+Q49A3P7K54ma0uesYmkB4q3I0ru0FJS9Zkct/Hucg4GmIw3A8tH/S6026M5+cPj5asDyVZplxyTC4RmwW2HPLOt4A0gvZ5ZjWCWWIHoN4r1HreJZtJyyozCKIQZK1WpHS3O3NgIE3k/gr0T3IJ5v0eZxK+c3g3c8ZM6TXZXpYavSSSNaSVYHNTPUbDkH3hjKzopgX4MHvGzSVHkdzvyeTx0pjvDW6v3J+Zeyabiar2nJoav5by0E7bRGoS5mSKFc7M4wuNggNmGx3t2VD6P/pmzS76pznrONvcqvrFGcduVA5ScXPI5xCT0HmVpJrL4M5GTtHw0DeqgoJyBx+tO0QSz+53TPeZqLwKfObRAz988YImN3liMhxoqF3g2AkxZ7XWRvxgcV0m2s/3oYqYOhBGy5hLnMZEglMy7+z0kKzKNEnU/tP5kEnou5qbSkElh1OLP1bYUYWh3aygP6rwdbQLaCdkeSi318y4UEbmYslZrzeZDLFfp9fAG3PG57cLEKreC+2rpPczlypBQSnJzH28XIY/WtJocFlOrthLzd9dLzZHsYlIMFpWTobJZWrGauJy1bOpR17my9P3FVcXJ75weYORxM96zdCmfa2ctLMAkixIpbJ4d8cVtVuI01NX0Q6yPJfVmRrJ2wF8eqWQXwv8O6gX2V9AjTf/WhQU8s+JyN/xrUj/f1uGUc7UbFA4DRpYmmbpxVQ2UFtPbQKPVkvS+RBaYhSe3225OWhT3bnwmjJ64ZpMluANN1AI1E92R8xF4ivxGu5taSiHRpF4yaZipmdMomkm2nri6fpYVPwDppShZp+qcXRK7M0owxnRODwSXXRrXutf2Z6scUdBcUkQQq+fnRv+ZoLqQagetOc2619KUt266Bb1kFkGy6+BRDEtrFwgRaN2ObncN9WWZByrZ9pvm69DMloa7Z1jysaYMQrW6saim6pipxKj4Fykdr540MUkfDw6fCu4RlX+AbhrFYBiUN4PMFU1YWPAJS2vzS2WrUfqSBBHzJwed8yBy8wLar4OQf9Ue5i915LA1Camy6BAhDMZLzPBZGB4moP1St0OjE00beYqjg33Q8vNw4bxUBdAkqtzefVQlUC9e3xkWw88ao703hUO42ef3vG3v/fjfKa+5SZDPR/8ipf9RvmLkvCZqB/zRmgumZZhkwJnAoRZkQZ0J3MWt8IqwirgLzICcv6amVt4X3Ez5sbOaLJUk7zOOcvkbHEQ8vVynfZ76wf1I5vJznOvElkyBztB6jTgjJfpNUJ8aBJhE7FZ3UUiNA/6huHClCAc6rONyXx+op5ntpPc9102b1pWzoAp0Pk96MFFSyltt/XEk9WBMTpi/q2Dq2mdZwwOZ0IhrksTSKIBbGrnXoBQNZ62nkhJiv7l/XGFHC2+TRw+n9+6jgXI9EbHr6AM7Q8B98B/OaX05flFEfk8ainzf0A1Hb9jhpiku9LZKHJSfZ72YuK9nQYNZ2LpU4S0OE6Pp5rkRSHn86baKoBhs+sRloAWJkOKgrGRJiOeVm4iIkjuHfmLDFDI/RNmzzO06Xu16fj+3S1PmgPrnCbtQ8tV3VGbwE2vQdX7TIhuAskmpryDn+06JLEAOrq8sG41G5mh+zIYJU9XCyE5Ot3tuk6K2Sfozro6JfpHBp/NFcNK5bT8RnfD8w5+OtZU64nVZnrN+bZf1ZxMQ32/ENchZ5C9wWckWHSaFRiTmCbLmP2rCEK8HLhad3xmc798r3cMk8PZUFzJi/hrk4raQ3XrCEeLuGzkega7FqOSY7PChfGqFmOytUgBfuQF0I5LtuDb/P4MvS5IS6OZogkQZv3MVknkIsu8eX67ww9OrYMmIdm8QUoK1JDelO+cJscULBdu4NddP+PdtQoD/PYnP8lf336ZL01P2OcU4n5quet1p7NZDaXfaEyi3vWc1g1+JuV6zWZTBM4URGaYOTvtywLYNrDe9IyjY3hoSH5OpcjyagYpwUT978yoaNFZZWM0mp3NKiGgCNL6XvtrdoKQF+ppI/i1btLmoJhkhvsL4+WS7bou92htKvds2kB/lW2LznQbJSnCMsnX3N8qEkeDGZfM2h10gzM8TmyuFXJfO8/tyREGp/NpBnxJorUeI4l6lfukjeM41Xzl4ZJuqJmyea+tIqvLjnd3h+Kz9vxhS+2CZuhDXV7vD7X6x1kIFzmobvxr2qZvx6cPaL8J+O+eBzOAlNKXReSfB/7IGzuyNzjGwWHzDqrOsPBtMxb02BgsHz1c0A8VbTPRZ35PmswCOMhlInGqAGEl4WxkyJMzdSqOGxpbMqohOPZDTegtBpVcAnj86MAwOcbJUVcLuu8HLm74Dbuv8nLa8lNHVSDxUb/PSKTJZdPVaqRLgrEBaWHM2Wc8WVIdMwQ4L4xeSOssXfVo0gUKSDimC91hF76NavISa7ICw1wiUvSi3ywPvxlVoUEzmYTLUkPBO9LK83R3KFqOD6cW6wL+ycTgqvJ7ZspOAYkS3BMQBuF4UDNP0y3Rb6or7tuWu0YX6rXToD95y+nUEO71vrmg3LTzcow7CtW9lkdDk4oBZPJCHCv1u5r5elVCTBazHVIpsw7X4HcJ28lr16x6ADNkXpRbdvU6H7ScpwdqSKNBojDkEpUMppS34iqVbMxUmqUGW24ldaX8piE6ftXmGd9//RKAH2m+yoThJ4aK2yynMQanQsSo83SVdRvf2Rx4f3XPT92/w1deaFk75LkbvdHgNseIKtGsJpwL9F02HrWzgwTIYHGZqyhBgTDRLpmUGVRHUa8DxMv5bqhSf5JEfT8jdMH1S3Cay96SsgpJtQSj+dpKXCoReuN0TpnBFjh7dSBzDHVjNwepWOm8V2Rqvr53Br9KRcMxzsr6kwbkaRTGM9UUaSJhF7UmmQE2h1PLzWbNRd3T2qXN8dA3HLuG4VgXE7nqcuD93Z7Pbe445jriXGIfJsfxvi3+be6otIcoIPPm/OSKesrboePTBrQvAe03+LcWdZd+O96Ot+PteDu+S8evJFDIPw38PhH5uZTSn51fFJH/EvC7gP/5mzy4NzFSEGI0bOoFgz6n8Q+Dxuab04r9q43WqK8t251yearHgaGvSMB6rZ9vstpESsKxrxnus0vyQcsBcScl8/PRcOwa8EJsIm22elhXmqlZE3m80Z7d0/bAj1x8hR9pv8xX3GMeMv77xdTgTGSMDpu3l5crtaOZgmUcz8R6K1XcSMmU8kz/VDXvUhWROhbBYCKkRvt45rjYx4jXf5OUSi3dr7KIbKJw3iRmrteVctdM6dkJPv/GzH063a7AG2TttY+Ud5jJKIUh2SUzkSpCV+EOJgNnFg6YdJZT3fCRUTJ7W08cuob+0JA6i8k737DSYw+rWLIb21mFeAOx4TUStntQLt9cqpwzgGqfqI6pAAmmCyFaSKullFnfC81dYtpmjl6/fIffJsJFwOYSdOitknbHxYvMTJo9+q3yoCT71bnKY0zCt65oLq7qidoEnvU7jESuM5v9RVxjibxX3Rd6yRi1XzNGLXfNHMiLqudpfeCr1dWCYAmicyOBdAaT1SnCLmCM6kPO7gJhrDjGpaFV7ZdMKFkt8S09WSkgjZlsDWAyMMh2yzW3YwLR6xtq1WMEqLpEc698x2m3cN5m9XslfucvTpolmoliS7N6FQm10D9Svto5ZUSPe5kHdoBk9dim3QKKqk7zMcJ0o8/lVEXlYW4nLRfPWVMwDMERk5Q2xk235mG/VmFuWY4hBktEGKIrfnUhGrbNQDdWyMnRvJylbpZ5bXIGGURK3/eNjl9BsP3/BXAB/Eci8hwFhbyT/7wCfqeI/M75zSml3/KmDvSbHgJPHz3w/RdKgnl22vH8YctxrAq4oK08xzqQDkok3T3V19/bPPD8tFOLkvwA+6AoOx8N3X2LnZFmXoiriHOhlAanYAs/xewmqlxePE0Vw+RYNyM/uNOy0Q+uXvLIHmnNxG9ov8JN0H7QR90lzw87fDTYHCjXlZJtXx42TF1Vyh0ADKbYwAPEVvtDkktYs5SOe7DEJilaay4Bjnq9/FoRYee9LhPyQpEXD+O1r5Js5nuZ5TtSb9UlYC5T7Z0GulzSnCWmsEKokwIUcklYJBFdUuKqUOSzzChIJ4TacXT6vT6aAvbBJWIO+EmUa2Z6UwKiBAqqLZ0fQ1R1FTMtvTeJ2hd0PVSnhMnqzxKtLtLVAmypH1Qxw2fe2jyi5NJlExYAkVFuXnQLiXvmgiUh86D0uOras2lGUhKGToPUHJTu+hUvTpuirP/84oIfaF5giazzQXyuuWVlRp4NF3S+KsjbL9494aPTBfuhWdCidaRe6+fGozu7DpaTWWPWfpEgQwFQoPdmBm2UzYA7QyZKQlL20atiCczJSBEVnsvaElWBZAZgzGXe6qT92ySitipooDFeS5qqNrOAmrQ0uRzruBOGR2p95LrX79EMGDGZOB9qQzKJ4VKUPL7NHMbBZM6mUN0tSiPhOqlajVDKynUzMQXLyddlY7upR6aNZX9YEY4Oe8hBam/5kjyme1Rx32mgFEk83UwKLAuLkgpAWKNeiO3Spy0tkbcD+PQB7S/nP981w9jID1zc8KjWbdbdsMLaiBHY5azt+7a3PF+d+KJ9SuhcefjfaQ9c1x0/LU/58JU2AKaHGrPxuCooimt+SKtEagPGJB56nZynoSKeHNJEHj86FHTT4B21C1w2fSFQh2R4NulvtGbip47vAfDVhwtOva4ac7+tdeoK7b2BfslMZhmsoj0HuIOBo9HAsY7lvWYCQRBvS5ByJ+1tTI804yoKDLlXIR7O5Omyvp6AmAJ9lgREhW/PFisiLECMJsDsi5VQR+M6lddiEOxuIm0gjhbp8+uVZpSm9Wxztly7wN20KkF6zhpsL6U3My9uc//EThDObcpsYrqIRGvKZ+p9XmiTLrTzglkfFAhjR3CnmI9LFz8zae9l7mnEOhHbSFWHYgECGgRSJcxG3EX70vCaIv2mGdnWI2N7loFnxZh1NXKaap6fFE3489Vj1mYsXmgAn6tf8aTa82Lc8uq4LuTqEISbtEFMKgTqettxueqZguWrhwayoofaAjn8pcFe6zWvas84OkLvMN1CrB6u8gbELhlaGgV3gOZGcKdq0cqce2GOcr4mQCSB0+tb5evrToFYGUybls3UKFSHRNUlVZo5s39BYFwv2VUywnSZCK3upqws8yE0MFwa6n2mKUxq4OlbWXRIUWRw9SAFiAIZoBKEOFiIgmSBhGmyvHzYkC7gs1sFL33+6hZzHfmLrz7HB7fv0L7KAJtBOIUVL10oZHmRxMvThmGqSKuI35jy3kIgL03KbxPC8VdKyTGl9D/6dh3It2sk1DLjVZ9NIceGtlIU0iz6GiujjfMqEDpX5Kx+dv+Yq6bDR1N2peZkiTZhGo+sghpJkrksg2G0Nfcz8jEYsIn1hTovzyXOF8cWkcSmHvmZgyqN/pw8ZlsNPK93fNxf8JefvQ/A8XalZYYmFEPGh74lJhh7BTPMu/xYpSLhVMwFU9Y1vBdiYwqiUaKQYsJwVjPPC1JsIhIN9mHmHs2L1GJIGnOgUBSbFNNMv06Y3UTdTHTTEmhTmzDbibrxDJKh+KCZWXbjBRCbcJVXXp5zJfkUF7m40IV3ne15el/pQiAKrpj18NRvKwfMc4mqjGyTQAH5NNsBLhU52j/Pu+RkMKN6a9k+Ml7k0ulTpUo0d3F5cESpDKHRYDbLKGkwVFWTOBuadgphV8d08vUic6Q0sLt8jw99w91hjTGxbGRigilaPr+5xUjioyyM/WpY81F1ybU70ebUcWNGTr7hblxz6hdk3bxY2SoUztu2GXncHtmPLaYO+HV+LmwuzSYK8tHaSF17JiDUtgSpOSszmZsIeWPxoIEiOilIyfEyEeuc4dVLhpqM4BvRMuNtRvINAb+tMGfixBISzUPEDpFwbcv3Emc1lwW5a7wGAgmSVU7y8daQnJqEzkLTrk/4Roqzeimjz1n0eWafFMWqb6BksDFYjPFYSVznTfRv2f0M77l7tnbg//bqkvFhVb7XXwSu1gOrauYPCj4aaueJ1x1dyu89WuVapjM6AahI+Jsev1IC2nfjSFH46P6i/N0YlbwK0fCQjTiPU83daUV/32AOjjH3lH7y0GBbT/SKTgNIO09zMbBqRvxkC3lYjlrqCy4RsqK3MQm3G3m0OTF4x0e3ehz+ozWxjtw3U9HuAxhbx8t+y8++eMxwoxNZRi26R28KVysl6LualEm6cxaSZm7R3pYglaw+3GZ4fYf5Glz57L8SUNmqxCIllUuAsVoWLomCTFA/aJYxC7zOPLdpdKS5v9dEZO3ZblWgeS6hkV14TRWL9FWMhrGrmKyaG5pq8YXzQV2w5/LMMLrCK0RY5IOSLlhzn6XMhXlNNxS+mPeWtp1YtyO3fVak31cFJZesMK31Qpw+m5gulePUvMpk5wOMF3reodHNAKhRqd0bUtfQnJa+Y2gTvl40JmObe4hO+30+X7Opd8pJ2o6Fi1RZNQJtrGdjB1702ne5HdbcNWueVIdCrP7i8C5/4f7z/PztNdPoiBktJ97AdkJE0XegpfF5IbUuMG3zvVjJEpjz5ztgtR5w64GDN0xZ/m1W7I/TYvZqezXyNCFnpnbJ4pNLKsJbCNRamoy1ZpHTLj9Xa0uslEYyIx/HnRCdoeqE4dLQP8o3OM+D0KTXHKSLeLVZUI5lgzMudAK/ElyfqPa5pJiDhRkoot9FhMBDypSKdMbpW60HnmyPfN/2ll+7+QiAz1cqNL61A597esvz7L4Qo+FRO/B4fVz0OoPFJ8OTtfrofZS/d9w6VrVn6CricZHm46wU/HZ8goCW4fifeKSUftc3fzhvx9vxdrwdb8cv5/heRzn+i+jG7EipeH/DkVC043fOSNrPKc32ZmISm0U/c7M9Cv2pRjqL6aU47qajIdYO6lRKVFQRPzkOUfBDVnkn7zpz/yjmUlu1GXl8ceRz2zsOvinyQ4oiVFubcJahPQwtrw5rhlerpazQRkWheWHMosmhtuU3MCxqAU7BH4Gc2aH8KJO0FBhaFQPW9yYwSQEbhxn6pcizSnRXvshnqfJ8WsBtSAZRNHeJZh8Y75c077Sqsutu7oNsAmIiPhjGoSLl3b7pFdSRBPzci8xNc80KY5lxEoTTYOmahtQv5V8zSj4Xyntjk/CoIHK1n0tiUkRrJYK7y2T03nBcVXQrX7I2deiGcWvwK8N4kXfw64h9NBAuDL3JwJS1YdpF4kozt6JQka9RdWeKtU5odJevRFyWuYCQUs6Kc/9WWO7rXIacd/F344ob1hx9Bt3km9LHqvTRfmz/Pj/96inHU0McbQEimEGYxOHPCdRR2JtGQSfnNxlRkebOIHEREBhsYLMacVXAZ4fuZq1E+rGvCvLOd2rNUt+rwHNBLu4VFCJxyZofvt8Ul2i/gnGX54jX3pmdUlGpGS+0vxtWwngB0xm52oxaAp+zROPBGkHIIsdnACrXgTstpPGw0vdXp0Q4SHkG3Sn7pm2kiCMw94VBwS8zeEkSKzfxfvvAb1x9CYAfdAf+8viYD4ZrLuue66daijz5msPYZFk7zcIPU83oHW4VaaznnQslz8e8XrzwW9IqP9tVXNaBNzm+xwPazwKfR6Wu/ijwx1NKD9/Wo3qDQ0wiRYosUqpF7VhGqwhB0LTdCyKKCqRfGsduNMQqURwqvBAGS6gz0qv0jlSGRoKQcs+EDby/eeCdds9qmrh5pJft46QPmDOR05hh1qMjBsN03+AeLGGzBFCS0Tk21+mnTICd1D6moK83QB2xu0mV+PNHUiV6bJcj1xf6ML2322Mk8fO31xw+0tJVfZP9rzKwZIa520FtafxKGC+Xa2sCmJCo7zy19r/xq4bhkSU8jmpSCKoCMhmmOsJocA96fVwnhE4Igyn9iupBfzvWr/taab/FEFv7mjZimsuN06JBmayWAJNbrpkkyoLpjlLQY2YwpJMBHAVSEfPCus59sdk4dOdZr0aGvmLKCLiwjqWPIWE5hqhyoYVwDFl7zyWQhM1lbe0/ZrTeuCi8xCYxPoo4FwvNA1Qqa4paIpw3Q0OwfPHhCXvfUGckz0enC059BuaMpizOGD3O2LsCKnDrkVU9cegbhZZngM65jNf5iNHQjxViEuudXsirdccYLK9GVz6XDBkkIwVlCqp0rxB56N7R9x4/77FXo5b3Tw570Dc3N4b2paIlZ2X5ZBSWr9SSZeP1mr/fvHesNfCI57VAB7rZqY/p7P7onEuSqB/SEvxSRl1GSJlW0ewGvLekIFgXi33Mth1o7URrJq7M4lH0M+M7/OT9O5ymiqdrfbBSErrJEdJC9Rm94zRUDH7H1arn8ztFZ19VHR+crtj3DTG3HrbtUFSN3uj4Xg5oKaW/RkR+E/DfAf5XwB8UkX8H+L8A/1ZKqfs2H+O3NIxJGJuKRl7lgorc9hVymPsKulsMmwi7qcgw1S8t9QOqaZgbx9MjrwtYWSAycmujxqBz9gCwbkcuq54uVOx9U3Qi3dPIcaxpnOchIxjHviJ1Fndncb0Q2vz9g1W1DFFQgP5YFtfNwrfzspNGQxyNZkdzD62O0ERcO7Hb9MXc9Ae3r/jB1Qt+cv0u/2H6QQC6cVcWPhtUUw+gPqSyIM1mosno7tZMqfiFAVldI4sk592jdNlbyiRow2Icei9UDxqRSuYXlj6FHc44Rkbwq8wPmgViK4X8SxCV+MrHFtYJfxnxTwLjdQ6ee1VacEe1HDnvBSbDayaRs6qEX8Pp/UjMWW1zMbBpRi5WPeNOp/3DsVV5rqiAA/maIBDq193DY62L8JzZ206QWhfV6iBkf078WgitYRpVbQagG2rG0VHX/jXX9Yf9mjAZPl5fsJ51LmcRZ6MB1F/klbwJ2DoSRlMUK/xkGSanyNRjVa6jGRXAgkkFuchuKoLcKZqiIPJihvLf1zTP5w2LXstpSzFLBYheUaQSlp6WRKGqAuvdiXQlPOwVLjpNLc1t3iDMe7wDtHdRHa8nSvY49zHHy4V/qBseDU7pa5IZdxKmcZlvi1JMPt6Mbg2NlM3QHKybWoFLMQoX654nOUg9bQ98tr3j168+oM1f+PN+zc92Txm84zjUNBmM86g9MjT647PT/caNPLNbjkPNXdfyqNX14aLqOWYqwHyPL5qeof6eh0F8qvGJrkZK6c8Dfx74J0Tkb0aD278C/GER+RPAv5ZS+tFv32F+KyMhJrLKEOV3dgcG7zjULT4LgqZJ0U5mM/Ho+kiXs6bTuKU6WJXIOfMrEhP1M94UCK00kar1iso7a9R+9XTJFC2nqSo77UftkYumx0kom6Hu1ODF6oOYNHsBNMj1kpvqedEQJVkWMMd8aK2Sp4lSAq1pFR2ZolFeXNQTuZtWTK3lwvUF7dahGWfKJUc/q6mLQvSTO5Mk8ol6n6iO6hod6oUsbbxmvEXfzguxjtgM/sheoAy+ZvVMIdhz2We6yMEmL0Jz4Jn5SZqxpXIvTC9UR6F5tZS0hph388KysBlduKIjl1ZTObZzd4L5tyRqMIoXnmqrJx2jsO8aLtY9VysNaKO3jFIDWfE/3xRzJgtWvnsui0oqaLuURXCjSwW+DxQ35OGh5pBLjjEYojcEaxQ8k4nr/r7GHiz91jGss/xXHahqT7Oa8C7SrvQcHm9O+Gj4+OaCkDOx6Vhx17vs0r146VV7JYtPu6ilb1DZNxupbKBLgs/l49BZTBtIsoA3jNcKalHUz+cWrjXbtwNFZssdDL1bMbR1Vv035ZIVUMgsxdZnn7qo3YAZ1BFWQrKxPEP6BcqTjHkOLLs/6N7XP5IT4OqomV9qMrE7f0doYdoo6MWc9GQebjbY1mNMZAqG1uqXfLa9469bf5m/ofkqs1TlV6bHDLHiqu2471pe7DdlrlU2sHEjl5XOp0f1CSORl2arpq1HpWbc9Gtujmu8N6UEHZNQmbOU8w0MSd/dPbRPXYBNKf1oSul/DHwfKkb89wL/s2/lIETEish/JiL/Vv77IxH5kyLy0/m/12fv/WdE5Isi8pMi8l/9Vn737Xg73o634+34mjH3Ur/VP78M45vxQ/utaIb23wJ2wL8B/MFv8Tj+EeDHURUSUImt/29K6feKyD+d//5Picivy7/961ELmz8lIr8qpfQNtykh6G529hV62h4Yo2UMln2j6Xzf1RiT2G07nm4OHCp9vbuuGQ+t7lTnCmNntPRXRRKx3LiUlBRpXSwq5nc3W45dQ12rVc0pl46qi8A7qz2NCdyPWo+qao/sEpNNROcKl6feK7hhhjVDzjQqJTnbXoodPC4iJmlTfoYnV5GQDLF3HLxRCxXgi+kJL7otEWGfeXe2l5xZpNKcB+VZuU5lgubyYjJCqLTXNVYOv8pyVzvNJu3eLuU3o/8TeovdBla57zI2gZNrqW9Ngfv7Kw9B1ev9eoG3ixdsbzIROWdXMQMLZIbp52v2ACYY/Lo+y6whVXosoVlEbSVna+Ip27tQZ6+smSs2C1AfHD4Kp2aNWZ3VKNEM3bUTfpV7l7c1MglGFl4WHqI1RLP8VnSaWcp8X+vldQBzMkyZF1Zly6PNasg+Z/pmmaRQFGb1+2lST7mmnbjanopSzspOPOt2vHQbwqzO0im4prhw5/5idVzmwFxiDydHbCaa1uNsLCoow1DhXGAw1TJPbS7/rnU+zX1SIDumn4k8e6huLWC1dDtTLLKc1rlKjRuSgnxq9Qabyey+1dLtPI8B/DaqBFrQbL78XoLpImIejSVTjc8rapFMAVlkuUKtotSzcAGAeVkRVpbQROJqZFctkh59rHgRVhyT3p+vTI8wEnnaHnhYtzy/16bscaz5oeuXvNc+cJ1t559Ue57WF/ykfZd1NbLP1KKb45pxtIioWhHAaao5nLmRvx2fMKCJyG9EA8nfC7yLeqL9o8CfyM7V3/QQkc8Bfyfwu4F/LL/83wR+e/7//zrwp4F/Kr/+R1NKA/BzIvJF1Gj0P/6GP5CkEJIBIsJ13TFuXJGSejAJZ6KSdt1YJIbW24Hjtsb2tixAEnJQq+KiGIIGtIJinHvJvWWcDPUTz64dOPSLtltIhsu6o8mK3GZGneXYNPd06n32h6q0TANAs/hHzb2b+XfjvtKFIb91yiVEs7dwtJwyYKVrWp6bCy2h3uUy1VFloCRp76ook7tZVkjKApccYIToLKGRshCHVktl7rgojUxbGCst4VRVYJt7AEPleHgiDK4upperRx39qSY4S3PV82SrpZgXNzvSsyYHtryJsHrufhPxW6HKRPDmFtwhH08uWYaVLnbuqAtW6aF5RbHVx2WOjFtD/zhvFM44iNW9zb1EQ5gVPATEgDweWLUTITfsO5sIhwq5t7j5Ccn8uLBNpHYGkhiSkYwCXBQuNJiruWaaF1y38PVCNCXQShRik5CtlhhB+2IiiXG0jJUt+qXPxh0vjludq3HplZlBN22pXkrZ0WXuVZ0KajYlg7UKVHno20LYTnExEZ3J5aFJpHXQ4C8wzW4IDzZvLBJmVrQfdC5jwCfKhoykxxBaKT1diRDyXJz7W6A9upAr0mbB0WgwGxafs3nuJJtoVyMp92RPQYiNzb251w1QzaDXeH7WtA0hStc0sSBOf/b4hC5U3IQtp8zqP4SGC6eqQPt1w6vsrWhN5El95J1qz7uVoqp+qH7OznTapmhrfvxOFYNu45pVO7FuRtosrXcca+7vvw1y+9/FJcdPwkP7SeAHgP8f8C8A/483jHL83wL/JJrtzePdlNJHACmlj0Tknfz6Z4H/5Ox9H+TXvvaYfwfwOwDck0uud6cSpF50W3a7gcfNkWMmhXY2YE2iNoHD1BR36G07cHrUME3N6xm0AWzCVYHLvOAaSRyHmmFwmNmsEsAkVvXEr7p6Ub73Ra9yRPuhKZNzHBzhVUN9Z7D94sUkIWWAAMXO4txl99wniijYo8EdZVGsqCL0liqDIuagGFapwMLnnXNoEtNWF7Bqr1B9WPpm05a/yq5i2kpxMAZwR2gyTLv0+EQYr8CuAjEK90eNisEb4mRzYM49tNGpG7dTi5K5nxlHi/NqNzPv1EOjHlWpSuqfNfcuJS/OJi0UDJuVL8zcn8rn7hUSbruIZNRNqPV4jNcMqRTm5/ZdRlYC5V6NK0dfVUXCyLpArCzIAhLyq0w8PwftiAGrC6QSs3OmusnmjSYV+kMMgh/Ucb2q/eJFZpTc27QT714qqmSKhrvjiqGvubvf8BOz8/domU61Ts6ZGmJy7yQqCnP2hYsnUUj6GYUjVYkQDKep4v7QMt1nKZYI0Sooxl/mnUylDRlXBdpmIoNmib2h2mu2vczzmS6RFOwzVx3yb0cnrwVaPZgZtTp/R66kmKVvZzvBTBZ7yhnXnCw3el6nfbP01SQpAMgkQlB3cQDJVkniKRUDWsBF6t1IW3nuB53TKzcRvqaTs7UDj9yBtRmYkuWjjRaittXIVXXiSbUvn/nS9IQbv+XSdVzLkf2mzZdXsBJxJrLN2eArs+G4fvMZ2ndzD+2TZGg/jGqI/w3AbwT+JZFvXB9NKb3zDf/xa4aI/DeA5ymlvyAiv/2TfOTr/eTXOYY/hJqRsv1V76XW+bJDrUygMZ7BNwX23FSexgYiwsv9lv1BJ2fdTLSrkdOlVZj8PJpAsxlxLjLlxnxMwjA4psPid4RN1Fcj123Hxi6N38Z6TlPFzX7Dq4wOC68aNl+2GSCx7NSHK2F4EgmXXtGCQHWvQauYeRb1bTXPHB9F4hONQpvdwJGWZC12L6UMKBmKbKal3B1r8JcBmsBoFjUCiVqGVIv7vNg1iclLgaUXpGPUY7NjKuUdd1KAwVjXdPZM5QBdLOp7KYCXcGwxAnEV6UNLP6MuDznQv4aM4yxzPlPLN0kDRwI5zf+OmkwnVX5o7pfdfqxg2poFhWdzoOuWBRIo3Klg0lLKlLzRiAtPEIDJ6P2KWecQmJ54zNqrbmWeT8ZridbvNBsrq4lLSiUZTZFVSkeHOxnCJpKeeupN9oMzFcZFNquhyIKdppoQDOHgMCfLsanK8Zo+y4SdORnM9AdcLMabElSH8bwcOYmhP9VMk2U61sXY1fRKRYnVGSJyEmS0jKjY8uzSfVpVsDdFDBvmjdkCjEl1vsl1JFhHvD/TtBQFiUgUnXezAkmE5k7K/ZtPOLQ5o4pLoJO8+Ut9vRxDk0irQL0dMSYV77M4WNIpc07nKvp2YrvteW+3V9Hv/BC9u3rgC+1LruyJK6uTzxDL3z8YH/M4o52v6hNrM3KKNc9HDXKH0BCT4ao68W71wG+++DkAfmj9gp85PeXVsClr2a7q+cwV/ARvxzw+SUD7X34bf/+3An+XiPzX0T3PhYj8n4FnIvJ+zs7eR1X9QTOy7zv7/OeAD3+hHzCS1OgwLxRXTcfKjnxwuioTY11NbKqRwasjcMiBY0iqXYcBs9EahquDKupX2s+YMhG272qmhxp35wpCMbSJaRV4GBt+/P7dUl7cVgMxCf2hxt7oQtPemdyjyotvfiDHy0R6Z+C9Jw+8vNUkNuWAi8n9pLMwH7eB5qrns4+0hHFZd/ycfcz93lE/2JJtcdDF2Q7LjnfaQawNkXm3nr+zjoRd0N/J3DK30vMPXpF3dGfE3Qsh5aAGMwxecPe6Ky/6ilaRjLY/K7WOgl8l4hqIFINPd1JIuwlLpqplxIxGCyxZRF6gU52Y5nVwzq4SxOaMJpC0fDWru8Py/SaLL8+ZgR0z2lWW15JR2xdsylbMuYyXDUPDKpGyQ/nu8ZEYDafYaOYM+Er5es1mJEZhPOadzKhBx54W5wSJek38NmlfdrntpCj4YHl5ypqlx5bh0GA65RbOQtGxVhFld1wa99Mu6RwfhXiyixOAV2pGMsL8a8mo4LK1kdCEwrm0gx5n2vDa5i9VCeMiIZjiGi8+Z7/TWTaQlqqDX8NUZdRs0iDi16nw0DieZd5GGK6W+eAOQn0PzX0s9/f0jmHawbhZOGdkyD9+mXsShAD42mJdLBsJcREulMQsOdBe7Drev3jgUXPiMDWMcd7YGr7SP+KL8V0e11r3/mx9Syv31AQq44sx7VXVMSTHh6crPjjpSXS+YlMNrOzIznZ8xmnvc2d7Ph4v+PLxupiArqrpjaMc9aK++a/8pRqfhIf2bQtoKaV/BvhnAHKG9k+klP4+EfnfAP9D4Pfm//6b+SN/AvgjIvL7UVDIDwP/6bfr+N6Ot+PteDt+RY3vctj+J+mh/U9RIMbzX+y9X/OZP5JSevlNHtfvBf6YiPwDqAv23wOQUvorIvLHgB9DtWL+oV8I4QhQmchl3XHMZnu9r/i542M+PFyU/kyd+1iN9TTVRNfqLtnaqD0EF6kafU9d+0JaTUnwc8kxalqQ5qwJFHV2cDw3F6rukXd81WZk6irsTbXYvTvoH0su31HKdaFNVI1XK5Gdliput42CCVzuOazmGpz6bzW1L6iry7qnckGzOaHYv7ie1wSKIcv+7PM5SSrlmVgnpIm50ZLfayNtM9FUnn5y7KNmBrGyKjEl4NPcm4Npq3Yq9mSW7CiXLM+b+CnzluxuomlHur32ELyvqe/0uqR6ea89maLsUdCEkoEDrSjCjVzCcolUW6aDxWfiuutSsR05B+TYPsHs5TUj7iRfAk8RLw5Nwkvuc42mlOBsp1Y85mnPD7z7CoDPbe740v4RzxOlRBWjKtRcbjpEEq/mXuJUF+LWeXkzrBT8Yc+qA8Ykxsly2LdkLIzamoxG78M2LXNStNxWHZfvjY2WuN0gSDQFMKMes8K0gTEbdLqnPe9e7RmD5TYYxlklJYNaJFGuQTKp8NdmE1bQrNevtefZ3Of5eNJM23gYroVkF4DVfA+m3GWPlVA/qPmqBIo0WWgUAOV6OQNVBUKlvMTQJs2mASLYo1W1mxm5OCQkGOLQMJ2Zw1JF7MrT7oYCaLpselo70RjPo80Rnx+WKVp+5vCUF92Gy0abvafLGpvLjofQlsqQT5aDb3g5bgqoZPAOnwx305obv6XNJLljbLgZN7w8LCXHxi3Z3tuh45OUHP8AiiL8RAFNRGz+zH8AfOKAllL60yiakZTSK+Bv+Qbv+90oIvITDSMRnyz32brltl9RWXWdnuVmVpXnujnhTOTWrYqMzYzacrVnbhueTg0pCrLR5vg4ZNCCF+0/1GZx9201AMRDpWCNLOfj1xUmow/Hx3lVqaKWPwzarJ9bKZcj71weeNweC7DlZusZKwt1pFqPPNrqgzN6yzA6fDDc9Ire6HzFw7FFvGoZzuU+yDuxBdyHXym8WgLacJrRmk5h5SlKARKMU02Koqor3pZ+TFxFfDKwXgAOqUqwnWjWE/3dYorqTlr2ShbIAc2OGoyMC7xzceA+K83fhh1jVxVpKAB7khkvQXVUSSWYidkK7uif5JLwuwmz9sQghLUpaM3qmKgP6oNVztco0tN1SYnFc5yMWvKUpBVOAKkyGMEbZDKvBZ/5Hj5tNcy80+z58uGaabL42fjVJeqsvr6uJvysQGIS46nCd7bIZM1AmzQa7u/WRRNTLVByz/CMzC5JyfbJpkXZRpIG+noB10gUkos6N2RBzfbvKUk/VRHJrtvtamSKhkPfqCNALkGPl1Hn2C6UPq09Za3OyWC6pX8bVgr8EA8xA4+agypzSMzXLj9woZ4VVnRTpPdXcJ3g+kjVJfwmB5NLnUu+XcBPJhimjTBeJlUCyiVDUwXiOiiVJD+XJnv+WS/Yzp4BYSzTtSCrkatW748zuq5MyfBOvecyW2R/qX/Ml/yjslkG+JnDE2ISrqsTHw8X7Me2/NvJ13z1/rI825XVdsZfevU+H3UX/PpL1dtvzcTLfsMwudI+AV6jC7yx8b2coaHT6/eIyM0n/M5vjBj5ZRgCbN3APnPLxmCxkrAmsckGn7/66jnfv3rFvV9hSEXR4/l+W4SNU1rusojy21ISXF5wpVaotPdGfdDQQIBNyKjBrMrbZ4mKQgyXnvW1PggpCUNfESeD3QQ+9+QOUNfsebLPo2o91UXP9aZjWw9c1Loy9aHi44NuY7f53KZoS2AO66VhH+uo8PyDKWCKBZI8IwNnpGTC5Qy1uBV7o33AsWKabNFtTG3AO0XyFesXb3CV+nr5zYTPEcKMtrgezz0sM+kufdzXvGoWSKVbecbHlupWQScA1UkBHrFS5YgqIxdTrwu/s4mYrXxiZfGDQTLwILqlB5OM+nWVnmGl2Z07JdwxlWOLtfbXzksyRWx4UjmrObsJG+05ymT48Hip1y4Zbk8r1RCdgUNbj3OBh1PLw6llu9Kb8e7VnsOq5mG/LgK0RYoqChwqVh/njKfTYx6vZyNL3SxIgMkqtLz0iVaBUCU6u3AdQ61ZfhoMMknRJ+ViwthEDIJxC9/seGiJh0o3Q5luEa8mTBXZbXv2t3rfoldTT5kUWFL6jlVUiyIoWZDr1fk7OimZF4BvtSc7Xp49f0Gv+7gzGL8YsK6eSbk/PseM4dJyej+R3uup68D8GKuanWd0jjCLlM9C40F0szRbCE0QrePg1nyQn8VtO+BMJCbhtl6T1VaZkmXjRuJaynP7/LRjjI6ruuMwNQVd7ZNhPzQ8vNoUGb608di1JxwqnjcX3L6rO6/LpufZfqf2MZnG8eWhettD+5rxSQLajwIWePopvvdHgf03dURveMQkvN/eF0Xyk6+4H1fFU2t+D0BjPL96+4x3Wj30vxg/xzNvmSZbqg/WRvxkmUaFTu+ye3JKwn1ooYrEWZHbKvTc3jlWzxdtRBAlhq7PMryou3xGQ3KRR1nb7Ul95Muna15164LKXK1GLlc9n9ve8aQ5MOSV+NWwYdcMrwVAKyp7tG8bzLAYMtJGpA74lSXe52xhkOxdBX4VX1Pxb9qJVT0tMPpcKksJ6johM9y8saSogq0xl89Gb/CHikMQUjAK5wampx6pgwbHBz2GOQMzB8feqLzQcqOUR1bnmVXtEyYkTu8Y/ErwGdFovCqzh9USYNxRwSdhlYiWIrIsySg1YrXwmVKGfSfR0tZ83/xK8BcKSIj5HPyV1+x6NHq9djnb2g6EYJiGxQfvvms5nhpFOZ4ptR8PLem2hij017rYrTaD+ulVniEjFKMRUhuRJpDCEiBcB+ZBycZJcsmz1wzMeKvgpCtd+KrWK/oxQmzPtNNMIjYRk8wC558MaY4sM4BkcMhNTXVSXtac+OESUiv4Y35vbCK0gZQUxVpKe72KUbtOSlbt+ohvDaFS2anZRbo6CSYoBDOegUj9GjqjMl0zt6y50YqIX6kMFkD/JOGvPfUMZJk3m0nnMGnZwM2ScanK13K+PDNI6MFxzLyV+FjYtCNDcHy1v+KjXidUHxwR4bLuSgXodljz7LDjGTsat8zn3rsiLjyX3OPREUaDGQ3RCy/ulIR9WtXsj7qRqAris+Jn5QlvxzI+CSjkt/8SHMfb8Xa8HW/H2/EdML6nQSHf7eM41fzk/l1edbqz6scKHw2nY1Ma6D9TPcFIIibhUX2kyrvSygbqypMShTAbgvqdRW/wvStZiPeW8FCDSdjcb0gJ0m1N8yrv9GdVXgPJqpq6nxEOVcKuPeSd5O2gx7t2Ez4a9n1TACgA+77h0Da8397zMvubPD/tuD2tOD60mgkB68tO2xFGVQ4KmboKrNYjvjaMc7P+wWD7DCJoItLqdRBJZbc5D2e13GJNYtcOReD4oW+Yclm3WFtkkmqMlULC5ydmFXKpMhZgiwSj4rhJPzeX25I3VLls29zqe9sbBbuMW4Xdz9y9aSvaQxEKtyzZM3BHlRiv5wzJYActVRU+kst9G6ei1cWeZ5UU4i6LWG+10/TAWwttKHYq62Zk8hbnYrk2kueYDKZYzgTrkL1TeTUDacjgpaomrgNm48v1MoOB0RIro9JdZzQFyBSMenktVqhvXRKmRzkTckHLxmcAFj24M5DOLAFmrc5vSUvPcFDPwFmlpdj7eIiTYZBq6cu6RLWa2KxG+l1Ff5Ml1va29GpnTuHpsWXaaZm3OnIGHErFdWEuCYcmg5PiDMKaD055acZDOJuu4o1yBKPAuX+YUa5fdZjpBJCczgU7LtSZaHTOJJvKtUlJEEk8bo+80+z54l4LWM8OW2oX+L7dHe+1qj/ho+Gj+wvGwfH46sAPXGj35uRr9n2jYswZ2DKTuePOI9VyEqe+JpxccWkArToMH694O5bxPR/Q4mj58Q/eK3VnBqPlnjNO1Yu9Iod8NKyqiV3uP933LQlYNVNpxPZjBd4gJ30oS0s2iBpW1pEwW8h4wR1N5tGcPaSBomhvhjyBUa7ck+s923osCLZn3a4oBJyyrlscLWPteFFviGkJ1vfHFd3LNfVLWxbvzkZMpVp2yaUSpLa7nstVX2R4QHtByc4wRtWlLNcxCaeh5ng/e7cIUkWurw+8t3mgzxpT911LSkKEEuyxGiCRBKPF5oc25TLdueGleA0gcRu0tDZb0JxUdio0FGX+9CC4U6C9Ta8BXvxKCodq5t2NW/VySwZFPuaAMk2qAuHOTJBCk4OfgXHHors4K//Xy6alqrWE50AX/ryR2J9arI082R55b6ML26t+w/39GndaeG9ekqqfDMK0WdCIthMkWMIZoKN6MMVHzPhF3qs66nx2HYUUPfvBFR+yMyWWOFjqW5ute+bzTaoYIwoOmucDQZBglr5KVPK9rBQdMwNT3IMlTEK8AJl7cCTqOvBoc2JqLR/NIgKDblpCA8f3l+NFEpsP9NzmTYRfmbxBgeFR7teto/rfdbZY1EB+xoKeQ+YpM23z/JoMMizALAUk5fs8T3MDKSYMWn6fFUjilMvNVwGb+ajWRjb1WILWs4NuKu/uNlxennivfeCzzR0Az4edcmFNwkriSaM3zrSJo6+5r3zReT3erSCp31pde04nndThWGEflNxdgEeJIvf2duj4ng9oJJYGNhl5VSe48EWiqu9qPurUDFGcLtJAgeWP2atpHlIHXfzPsw1Eezx7S+rOiKUWxgsFFszw4uhQ9Y9NXJQ7ouB7x8NJA8LNfYbBR8Nm0ytBPGtSJqfowFf3G17db4g5+M0N72mXSDtdcK+vj0zBcugcCYPJ37GqpwWheOYDpc0F7WEVIuzKk9CMtZq1AvuKFITROz4+XixGpd6pc7F3hDmjTIJZKVI09naRMKoz6kwoO+dZY0+qSAqCZISfzdlEWMEgM5LPsrpR6SpJC9DDDkqstSOv9ZliLcRGlE4wG4oesqNyyJJX890MmoWElYrezsdme4HeKlQfGDN9I3rBuESYeyGjZXPd8d7mAZfTkPs+90DGpQc3/84s9zR7r6Wj9juljgvEv05UR8GctE84g4xWr3JFQFyxUvFrJSPrdcpZIRnUk/Uw5wwkGZVWOpfAmo8NQRVLlhhFanSTZF1gnPVLD1aDVNI+HYCYxDRZXhw2VDawyv3m/doRguB3kbTW87WtJ75SS3E3xEJb6a81OMVaEZsA7mIkBmE6tUp8n+kl2TPNrxPTdX5W1qE8oyku71W/M/XtK67onhJJXb+oycRK50ZYGUyWlFvVuvGNSbgZFzsYVwe2zch79QPXbumD/9Cjl4zRsa2G0vO2kvjC9ga28KxXMNfHzY5hcjgbiNEsgKCjEuSToCLbzGjeb0N98G3J8Tt4mFRUPgBiqtWRdjXRZrj08dhqVjUZMIk2Ixdb53keLOO46KUZo4i/ulZdwqFfQBKLS+6yw9WAZVRWKi8w00Uk7Ty2jgr3hwIIOd2s6eoGHpYO+FESm/VQjneyUV2Tb1rs0ZYyYmw1QGzePfB9V3cAXNUdd+OKLyfVrZsXx7vDCmMSfrKkfLxBorpEB8lW9nlHPQlHk9juer7/6W05rmf7LadTw/F+KXvsrk6s6ombh3XxtALNZKyNnDYG8qJQNxmgcFZKSU4Rd1Xj1ZU5Z7u+CuobdjDMK9C0EyRa6mPE+AWNaHxSyL0VplnQWVBH6F7NPucNTn2vr/k1+OxMTSIDKlJGZGZwy4UiQ81E8cXysIAgVl6zYSiGsr2veNnpgvfy1Y7q3upCmhPdVCUCkSQZVDLrNtZSIPjnjswSFNEZq/OgmLBDxI62eJkZD9NKy8axt6W8GEcF5XSf8Qs15GALKhKWgGaPpvjjzcocyhvUzFHWqWxw4udUS6S2EefmEit0p5rxvgGTisoG3qh338bzKG8e390e+Kn0LqFZ4RuDVMsmQnU4U1EwCV4zxrCOjFeL27mkpfLhHmauF3ChlBHZJfqsfditqyLIPCvoz1mbOlSrc4TOyfyn0ucQYNvk4OxbfDK8u9XzeLTu2FWq6vF8Js4BP3L5VZ5Ue2IyfDBeA+pJaCRy9A2D16X4nc2B2nhueuWcnVNnYi2EOpXn1WIW4NabGultD+07eohLfOH9V4Wv8ZWHSx72aw1Mubex2fScpCHWuVyRJ1dlFBWVopRsY5rLP6uR3eaMDrCy9E1NMonrTID2wXI8NYRjRXJWUV+AvVTScAiGaGZYeST4CiRhqqiwb4BJsqyRKVw4YzRbS17NLWfB4LiLNNuB63VHnZtHfXBM0Wo/LxhmUtVwckoYbUMJ+LF3hEoyUXnhDQHEztFVFUO2R7EmMo6OcF/j9lY5PkDz1PPeZk9Mwn6G8ucHRCkQiuADLdsc9+1rUklxFfV4JOnx5kVwzthCdLhZZmuakZVZY7Ge6QY5W5OlpyRBM7l0lGyoma+lT0SnfbeZ55QEnFONSXdKxT08rqPSHQ5L4JA+48SNfnCVjTTNOjGMjp98/s6iSH9yRdqsBKk6kkRIPl/30+xZkzUUQ4XN2ZU76PE0D4lQUcSUk839Qk9B/NlOVCF/pWXmmO+F1LpZ2DwZilHki48vcccaM2aB5OLmDaaT14g483mnTikq1ZVSRn7N+8+5qHo+PF7y6qgT0nu1O5HMQyvXzGs/MuDYV7oZ2jUjq/XA8LilOkkJXjHPR2QhQId8jUy5j6kcmxLsoc7l1CEapkt4tDuyribuWv2941rdv9NkmLJD/XSdz7E3TKMU3VJEA4qsF4TiGNTBYAiOu2HFIbcDnInUbWDvW8Ks79jseeSOXNkTlXimnCa+HLa8GLa86tal5Hi17jB1wkdDShT3hMlF/NbiGq8BHfC2gvbbANv/Lh6fqgArIv9+tpJ5O96Ot+PteDu+F0d6Q39+GcanzdA+AP6siPwR4HemlL76bTimNzpq5/nVl895VGk9e1sN/Fh6l4f9miHvUK/WHc4GfLCMk+MhG17uT43amXhDmJXJc3bgt4ZH7ak0/A9Tw22/4t31gR/avgDgZtrwrNvx7LBlf2yZMYrWpsKJ8bmsl4JBequ9oEozLSiCCYWvBuCqoL2wbDsyc8tc7lN99OqSD1FejHNhQWCeq9OPAoNT5fiZE+Wi8smiZoWzD5hk1ffpvuGrubEvRlFtmFTIswCHrmHfqC3O5kqvTYiG5/db4kOlv39uFJQRmCnz2KQJWBcJ3iqQZ84OokBncSdTshAJmk1MG4OktIA2nMohydnmtQjhxoTrKb2mGdUXqwVUEmtVpkhW+YKzmkvzqGOzGrh1W9Ir3VG7o6C+cJrJXa40Y7lqO774/An9q1W5NpJy9lgtpyUmwUoRo5yBYxBBekt1bxaz13uoD0kVMmaILkCC8cLRPTYMj+frBe5kmGqHtAuYoWkm5UaatKAvq1hQkX67HEO1P7NcOVugkgi2M8QpkS50jmyrgcZ61tXIlM1eH7qWsVezWdsJ9X4poYZRmLzgc+31y4PaBtVGs+Uiy+Vmw1EppUU7SPHoM+fiwj6DPOziVpGc/t4ULN6G4oF4uek4uZrjqcFkiaqnVwesJO66lr6vqPIz770ldg4mU5w4pmAJ0fDytKGfHDbX6S5XPSs7URtPk5uUWztwijXB71ibka9mNeUfu32XQ99QO8+60UmdknCcanw0GJNoM0BttfMY0Xv28qAl7JNNrNdvlULOx6cKaCml/76I/MvA7wd+SkR+H/C/Tikdf5GP/rKNxnqu3Im7Scsgd+NiDdNkRZBVNbGtB2obGIPlxVEnTDfUGngSBfEXTCKOVoNRMrxba3lx5wZaO/Heas91pa81xuMkEqJh9I4uI5b8IPjK6kYm94jcvaO+VWLziZqUG+vXuyNWEg/90v8COB0bZMh2KrM6uo0Eb/D3NfaQS6ROEXDWQ2wTaYaAj7n0lqqFbF1HVX4wCVsH4uy+uHfYo0Ew+BlWvPWqHrFS7yiTX++PNc/Mjqt1x2fWyoCOSbjvWnLlrJTgpFGD1LDhNQUHMYk0iaL73NLQN73BnhavOL/S61Wa9jkghZVKWVUH7TfBWV9o0lLdvGCaKQNH0rIx0P+qmot/PLHJai6X607nyM5xOM1EcKvWJGhA+sz2HoDPrO551a35+LZVGSVU1cQEtWIppN2kpqe+FcTFsoGJt+q2fd7PMD4DUbbaQ3LDXGrT18ZLBSCV85pBpnUo8lohGIZ9wzGtME0GoBycgkGCBp5ZOWZ2YkhGpcX0zdpvjE4pIL7X6/DjL94trhar3IN2JmZS9aILOh+bll0FyRcieNU1bV9qWXWO+O6o905VWnIZspGiBJLMQs2QCONaS8jzohxbLV3vT22+3nlzIdpyqGvPKgeT79vdsXMD95uWF92Wu5OuFQ+jQ3qL6dSNAOC4tRyntbqrX428+0g3bxdNTxcqPjxeFmT0O6s9lURctq768Xs17Xxxu1PA1CYh+ZoNwZK8yltdrHrqvOl43B5ZuxEfbRGJuK88l23P27GMT91DSyn9p8DfJCJ/L/B7gH9QRP454A+nc32o75BhJREwfPmkBfKfffmYaXRcXx65zrpsKzexrQYqE3ASuWr09bthxV2/4u6wwuWAZkzEe4tzgVfdusDrZ65WFyp+7qTs/fupZYzqjH2xWibe6djg9xXiTVHGcEddSGKFirrOfaexwtlI40Lp+T2cWuJDhQ3CtEulf7VqJgUMduqUDNoLC+uoyKi0CMeaDP81k2jvEPA2kbxg2shmPRAzoOLQbzWLEUoTumoVtJEmDTpx5qkFQ3eqWTeL8/fJ17q+uIj0lulOI8/UVNSb3DvJ2oZ+dIhkmHiUjLrQ/+/yYjsHg2mXzUdTlkK6XGDdsTYka6iyTJYdlQeYRLJdjH6H8Wnx/5o1CINkeSVFW867eiuJ3jvtBU5zj4fXos65SstFPfB84yErsdQPS68vFufkimllEa+BbqZVkOaMKS6Zyah+d7NL80xJcMdUwBNzUPbrRKoiZuWpsqA2wHBocC8q7AjTLgfloJ51zaukWpVz+3YDwyMpWSVkbcVVBiYIzLuUh5uNapEKuJwNislI1XVgAtzc+8qbiLTgezSDuxPWzyP1Qyz+ehITsTKMO1OCWAwAGtTCOhVg1axNGZuFb0kAOVr6qVUX73wvg7cKoz9zs7/t19yJBrFuqjjkSk08VNkLTzUv9dwS9r7CDNo/n/vuD0PLi9OGl7e78lvDY8fj9oiRRB8qnu0VfRQ6BwKdrc5xPzSV57rpaZwvYJGYBCuJxo34ZvZZS1y3sx36mxnCr1BQSErp/yoi/0/gHwV+H/APi8g/kVL6U2/q4N7EGILlL958jo/2Wufq7lvwQr92DJWe/nGquR9bLuueX33xjO9fqTr6V6prhvAOp7oqyMfaBkIS3Xkm4WYmbGcS8WHTlFLO8/2WBFytetbVxDabL34QL+lua6qH18Vsi6PxhaIoAYbJMfqEMYl6fkaDcunClcdeDFyv9UlOSTTAfu2MjDl4DUt5JtllQSkuvAblq0XV/ys8sowoS6tQqA4pCaQsZXVGJjfzghGlqILHJIyjQwYVgp394mKVGN8V5DKpviEgR4dvg3KZIpgzhfbqQXQhzijp8TIVaFusE2kmgjeRUEdia4m3WQqqU3RiyDqNM6DEeF2YJS0o1WSVw5UspNHQdVl7LxiGoSK+bHCnnFk0WTJqMMjR8ePP3wXg5W7L7WlFPDqqWc5rXIAbi4yTcqMk6OLsNwsqM+wC0oaC9BwmUYBKLh2PVwsYwva5VJoJ6mabdRgnQ/fQLuLEQTKycgnqEjQTWr8MmCkR2vncDO5EcfmG/P8nFEVoWIATh8wJMzDtchl96/XaVoFUmbPyMbryLNMRO+pmRSK4LmC7BYARWodfLajP+VhUc/M821YNRr0nOSD67NNmlRYzB2DTm1wmjuznZyIJzkZ8MDwcVlqmJ1MrXMKvI6snGkCcCxz2Tjl6kyltin5yKj7du6JlehgaVm6iNoGHoS0CCeIiaTKEyTLljYgxkVWd8Mlg4wJxuB9X+GR5t92zyQr7MUmhhLzR8V0c0L4pVp6I1CLyW4B/EPg1wAPw1wH/roj8v0TkB97gMb4db8fb8Xa8HW/HLzo+VYYmIn8Q+M3AbwAq4B74c8C/DvxZ4AXwzwL/hYj8t1NK/583e7iffkzR8nPPH5cMYLZoGYaKe1l2RQC19TxyR0ze9Rx9Q4iGtvJFgV8kMY61yhqdlSu8t/jJ8mADF9kzqetq/KT9NmNSyXhOdyvlvkQWDlOVSC34TVQpnExYHXtHiqLcNzf31U482EhbT/z6Jx/js1vuf/bh5+hvWszJLn0Fr6rhyWagw/kWRnKJaj6NqC+mznJyi8+MZDsb24ZijePvKmQyuF49x2yWgGqaibbytM4T849d1D1N7RnJUPBcKjOT4PeWwdVIVpywBxVlJUF1VOi8vjfzr9wZkbaJWvpyEXGpkMYRpTakOjBave/GO6bdAtdv8veGJv/WYfHb8g5SrSU7DExH/Y7ptil0hnjO/ZuvYxBOt1qy+mCoCMcKd+sWm5aknLE5Y9Dj0j5aym4lxUusSnAx4arAlMm1sU74pNmMnKlphDZnqee9o84hvcGdcpkyl6XTKpA2U7F1AUh7R2hguLBITAUwM+1yZj8uFAHb63lEK0wXFEqD7aHaK7BmLpH6viJsVUxZmkBo8z3OlQLXsUhn2VzivBSq49Jwk5AwIeK6VCx/xp3+tl+rDc0sdi0Zzh5XSw8OFHLPKmDrSOjPgE4BohhCO2fADmdVpSec3OI64ZICsNaei1wNiUnYtxGfj3+m9Qz57+1uoK0X/uvHuUI0TK5wV9NgkUFl9IbZ+85pS+NV2GJdYJPdF9pK+/FHX6s9Ux4+fVM5yTce6VdWyfFvBP4T4F8F/pOU0o9/nff8XSLyLwH/O9RR+pd1hGjUt2lGJLikKvOjpROdWBebnoum57o+EZIpKKQX3ZYpp/2nbHseotANNUNXITYVBZEYhar2inJyy0ROvaWjyaoXWSbomE0uDQUNkSz4XNZLQRjzyhu9gcEyRWHI5b5V5bnadGyrESuJLx30ePuXK5oXttheAMWUMtRCahdpJeOzfmGiyG+lkMEKUVVQXP69sApIb4mTUb4U0Ly0RX9wujCMmbAag6G50M/ND9vGjry323O8bvCxgcy9mwEtcnSYjOQTslL8SagfsqwTC3BDzsAFEgRGRd257VgAFX60GBNp1xMpc95O24Z4cmcSZXnDsDN5YYX6bi4NKictuITYQBpnNwKjklxXntn/TSZD6i2pScgqlMUgHCrMUVGrfpODXyWFK7XINeXypsmbmhmYUifWG+WKTf0sQmmpDqouL4kCgfWbxHgdiU0qi3B1Y6nvddEerpcgRYK69Ygkur1uWsQLfgOHRvuU8xo5Xmowq47aYwNFWZpJvy82ZuHurRSEUx0X+TRJAmKIl+opOF3ksrK32F5BJ/PtHHeJsFHQjOssVe7rulPEBEWQjlt9bbxKjFd5M2NTkbCbqgRVpNqO+Jn7Z6xqSmaQ1SxsMkuuJZtIecNy6hz9usZVQRVa5nnmknoBJth3Z4aCGUjDaAjWlntsnW42Z+RiTEI/NfRdTZgMaQYUHezST6xyMHYwicqQ+STcbDSK28uJ07bjYWwKZ82aWDbPb3T8SgloKaW//hO+9d8A/vFPfTTfhlGQgfNCvsrmnaMl5mBkJFGbwKthw0fdJftMkkxJqEzESCpN3xgN3huF8SYWCw4BaSeOY80hC8zGJApJ9wZ6U4ihEvT90VLcl2MTSbn/EY9VUYxAMsTeO04mgykmS5NRaz/38JgPX10CUL9Ufb7qmIo24bTW3WysE9Gl1xQfxOgDVKSBXNLdaBWp6sC61QfS2kgn2nuUjPKqDkJzkzJxWYguB/yj4+Vg2V2fihliYz0R7bmRlr5LqnPW4oWY5aWCi8igUHUzUSSQUpUh724BLZhRCGvdoVdVKA3+qgo82R55sjoUUeWv7K94cbdlOtYkL/icsYRWr48ZNYCCwuPNKIzBEoIsrZ82Uu0GHl2cipXPzd1Gidjbie2mL7BuXlrcweTeSz7fnUp0mVGKmkxsFVVaAmQmklfZVPZ4agrZ2kyqOdncqHblbGIZmkTcBDAJd6P3YfVM58FwJRnEkefTZBgHp2Lbw0xQz9+xBb9Zgu10GZDJEA6COywZrYJrVJJqfLKAWCQ4mtslg57tfsYXDVMTiyKHxEytaJe5F1q9Fn5tmNZQZ1qCCYloFcgz9x1jzqBl5XHNYr47SoVtAm07Mc4O3e3ExaYnJeHQNYRt1mK8CtR1YBwc060+V/ZoiYNh2nmq1VS89IAiRjxXTmIwUEWS0+c6ZIdtmeX0xqpUfkCf2TCpSEMBwowUb79Ztg3JGxunPe8q+6T5veXusdVAO2vFmsRxdxZg345vm1LIfw78175N3/2pRvICgy0s/822Z5ocQ5DiGny7XzN6SzfUTJOlbXXSf/76lrUbeX7acewzMMAbfF/pLqZKGLdsZ4xJHLqm7HwZtXFOTLnEsWRO0WWJLLsEE2yCwajkUH5AZv06PZecVexrxlPFwa6Us5V3mE0nVIeEHRYVDS1zCe6Y5axy8ihxFvo9A4VsPavtgHOBxgU2tQa0qTGIJE73q1JOmr9jbuTPuoDSCd45xo2j83pcB18zePV5cr0pQcpvoy5+CbjQA6sbz/jQEPeCRnN9b2iE5BYY+XxuqYlcPDryZHssDfKVm/jM+p4rd+JVRpD8bHjMdKypnldFlBdU99LvtGwocQ7WGZzQa4YRthnZtvasWhWqPp3xAqvdyKPLI6O3hAxiqU+CO8G0pUgVpY1X3cfRlA2LXS2Q+hiF1QyvT8Jx3xKP1XLNRY0rXZuRkmf+YDKYnG3r312vpU2/hvDIU62zK8CoJWw/mWUnbtTkM1ypwvs8p2sXmLqKsbKEenaFnkEkoiLGRc5KEbcYlWeC/L5OaF4ZQiuvQfdDk5gu41IaDIuCS1gtWaIdAmINJtilFDbTLKJukuZSs2uUnzmOi47oej3wg1cK8vqp+LQEmae7I9t64Plxy4vTXALMlQovGRGZN8GSaNqJ2vkCxZ+Cpao9nWlIr+qlVLwyJBOZJsuQy93dqVa/OwHZ+qLuESvVNdXNZr5vnT6nvlZgy8xBdCch1k4BSP2yiR7P3QPe1PiVkqF90pFSGoB/79vx3Z92SNCeh6sXbsyYUIRengyjN4yHGumzg/JZ5lY4VLkHF09OF491YHt9KohG3ZEl+q7G3M9byVlfMWEej/i8I5aDPTNqzKirOmj20hvEL4EHUQV/qlT0AUkZiXi0BC+4LIZsB+XkhAambZbHybJYzZ1mbbGUuqRweFKGoIdR3bZjFEIw5eFNSRT2nSWIIAfDjXK/hkepZDwIpDZQVYH9MO8eL7EmUq8nprVy2uaRJC2ahfPIPbu5bwN5B5/FZ4u+HYBN1C6wqUaeZhXz99t7pmT5aLjk5x6UafxwbGFSmsS5Qvto0GAqMJbAkYPufLnzAlS3KtL8cGrpjnpuVeP5wpMbPrO55y98/DnMPpeVOxX/NWEJysblftuZi4ExkcoFjCTlcOW+Sz85mtWErwJTndP4e4esoUdUG3TuixkgZo3JWZrKpGKZIzYW1OxmNeKj0fJXPq4pAavA1aMjbRatBpWAu08wjWahA7QKiZ+2WjafM3bJpdRoU9nczBn57AIQVst5i1etyDlIKS9S7+20hiETtl3niE4YN6LOB2gwlCAqhRZMoUpYGzFZEHmeUU3leVSfqI3nw+ayVGy29cBV3RGTcJfLetNkitP6OZxfjN6XTT0yhCUqr2slqZ/2FTajXn2fs/oq0s+9spua6t6o3FdlyiYg2QQixa5IL4TOO6XaRMJxqYjYThBvF2S0oeitvsnxndBDE5G/B/gXgV8L/JaU0p//JJ/7NoT3t+PteDvejrfj7fiWxl8G/m7gRz/Nh773xYmD9qDm8uLdqL0vU0WYQQ8ZNCKTgKNkJsrMNyTAzuAPZ1G4HmUnC6p+kYDQWez0esZhmsDnnt7SWN26fuX2qpSXxlwa8d5qmUQy4m3OjkxGbCVKMxmXNLvLtiBzHV68luam7YKAmxXIjYd6H18T8PUb3R0WQvGDZUyNmgwaGK+z7M56QCRbmZxtCGOlJbUZZacnq/2gabK86pRA+ootVe2ZelXVn7PPZKWQtedLOT40mNPcIJdCsNUSrZ7j3H8Km4hYLfO+sJuSoe1sz08c3+MvPvts6WmlpMc27RJ+nUu8KNerXU+EIEwZhRc7QUzOQi8Dtg3lO/q+UsTsrP6xmvjC7hVbO2hWkM8jzf3JiCJr0TnTtBPOhUJ0NkaVZALQVBNVLontNkfqiwdiEr508wiA47gheFvIz3M5KtlMdJ4Wm5dYySJe3Dm6uXy263FZ0aO8uY1sLnve2R6ICFWGyN7ENWFSJJ7N2WsMQoy5FzgI7i6fR+bY2X7pcUY3l7yhMhQCe2wSbjRsPlTPunzF8Gudu6E5U7o3jmkjTLvMO0T7zbiEW2elmTNxa+fUlHcGZDxenQhJiElYV2MBbP01uxc8qQ68bLZFWPiFTfp551lVvlTe+skVXuV59nrqLdNktfc8X9+TITVa/ZkRwbY3WmFo9DkpajBNyhmslNQiVonYJqonHdt1z92dlsx9bLBDzsLn8r5fVF3e6PgOyNBmwKGI/GJvfW187wc0nxvTebGSIOrGXE2LasBocHvFTfsm0sz2MXYCq2XKMM1YcSWmItCf9VHCaHUx96Y0+JNFS4UGpmj43HYR4DtMNZWJ3HdKyByHijBYZDSlaV6O1+nEL3X6My+2WMdieEm2Non1GTR+1L9PW4FkXuuhJcnE1LnaMYhC/geVlJrQB32wkbpWqauiBRNVNSJZdRRedBMFP1YM3ixk3gi+qpDeZPfhGZgieFES9Nzorm5dNrfMmodpXthUocKMlH5DWgXEJMbe8WBaPqiv9Hij48v7a/aHFWEGPtQBs/KESo0W01yqSUqN0B+fAQr5vxfZZHRuE3mnF61fovqqGakk8mLcMnlbAn5yIL0iBMNqhsFbUuNZ11NRHxHgNFZ0Qw2VSicBvL+658L1HEPDy5Muake3QpJKbbnTEtBCq/MgTbaYc4oXahQR6R60NA1wCAaxkbhX2oWeRDhTQ1lKbfuuId3XuP0iAGC9wu6N1x7hjH4Un4qX2lzWFqN9TzMmVi8WOH/3ni7c4oUqB7RQSe7pqiZn/45+Ryfgd0ENYmeJNi8qFiCJtp7wZ+CNWS5qk0UMttVAFyqsJK6ajjpHg1+3/pAfqp/xlekxz7MX2RQNrfM8bo/amsjlxZ+/v+ZwUgrPHCjH0TG+anF7S3VWBidme8GGBbkbIGwVwYyhWAyFjWfaZa3OmSzuIK09F5uep5tDEXT4KFwjz2pFAM990hNU+zccfRJvMqA9EZHzUuEfSin9oTf27V9nfM8HNNAd0MzlSW0oSLJ5lyxBygIPiiwD+Ikb1ac79TVxDmhBoI7Um5GqCvRZRaII+Y6yZEcBzN7Cg+XD/RNun2hDa9OONM6zH2oe9ppBxNHCaLRW3mdARB6hFvxmUYEgZb5WpefjL3Om2Rrt20xSoPtzhjZeUPQN5+HX2Ul6Rj6eFM0mSb8jZU+psanxjQq02hnUZsE3ifFRJNURk7Uj3VGh6TFSHgzTGxi1z6LQ9LnRrbv22JpyDO6oHCs0/ha5o9Am/CphzaLlyKQcqwR0h4YXlS78jfOs3MRqPdCJ3h+TjTjFBqVCzOfshSgOaQL1ha4Uvs3CyAbVOZy5S6D3QCggo1U9cTOuedFv1TxzBgmlDJhJi9+WP1p6qTEmUmfPsJjUGigEwUjeRAExGW7GDfvMhZwPIBmV6goNy+ZktlqpY/GEwxiM12slgbK5SCeLDBXNfgFpjNvErh143B4Zo+WD/RUAp/sVtjPZRHPuoVHmYbwzJbt3XjPq0L5eHQh1no99LECP/h2de8MjOVMl0V5s2ATtYzVnytJBjWlnEe2wr3APlik2HKGAQupaPdlCNEWSrm48KzuxsQOmTqyyXthje+D73ANXpuPD3TWgjuJjtPShInrhNOnc2R/bwmOd1/qpd1R3luZGe6SzhmZoFQSU6vja+pKaSL0biWEx2XWVZ3gsxIMr1yw1uuE6dA3OBrYZmHV5feTuZHFHV5y0q9NZv/I7c7xMKf2mb/SPIvKngPe+zj/9symlf/Ob+cHv/YA2b95y1lRfDVgbFXqfy32pDfjtpKgpb5gy6ullZtomb4qPmPqVBUSUKD3ryBFU6420LBS2E9xesrCroX+q3/fyHY/dTITOlaa6yaaa9b1Q7RezyujAWf3u4Xqu1Qn2Vjks0xokl0OTScQxl07PdozJakBIRgrher427n7hrblO3x9rfX9pVCchHivs0RTQwXQRCZeBi6cHLlc9H9/quY23LbLx7C469ToD6BuVreoEv9Wmvl7LLFll03K4VcLObtHtIhHlN7pIBCeLen0QUgKptIQ2l4pbO3FVn4gI93VbTvc01HTHWgmtZ+aj0gTa9cgm0xS6quLoWxgs9mRwGcSSTGJcg9lMSP74q4cN+75Ro9JgmN2/zahI01hLWQXtyeAry9DXdDNpt1M1etpIVwe+ergE4CvpqpSj54WxWk+6MZN88+bjDyC9IdWxwPM9YHurGUObijM0eZ4lWa7tDDbauJEmmcK1kpPVBTMtWXFsYyF8j7Yp+owSJM8byvnOWfa4y6CPpbpIssolGx7ll2Yie+aVzcErBXV9SChMXl/UjMbtLZNpsBd635zTrMoHU7Krp6sDF65nPQtf5vHhdM0XqpdcmZF3q/vy+svDhhvRjefkZ4Pb3BYYHIeZ3zYoQjHZfP0zoTquAmw9xkZSP3Ny0MpOAusWwIkI+FUgnAGHSJCCwblASkKX+a+SPffOEcWhXkSa3+T4pQKFpJT+1jf9nd/7Ae3teDvejrfj7fjk4zugh/bNju/5gJZmQEXuj1zvTsQkvHy1KyALs5145/EDlYns+4Yu98b85LSvdbQFlhsrlduZUB5MGpZejMJwFxh6tLorrY4J8f9/9v4kdNdtz+/DPqt52rf5N3vvs09zu2qksiQrkRzbMckgJjLYg4AJxEaTIIhABAwmkIGteJCRwCZgCAkZCDJQwMEWcYRNQnAkBw8EkmzhOGVJpaq6det2p9vNv3m7p1ldBr/1rOe/S6pSWTrle+poL9icfd79tk+zft23WYmwbmuIF0M1qMLJWtpoysvcRfvcZ68FuJGMYlqqigztNbPCj7oASMgyVmZSZY5Bk+1UNhGLhuxJpaL4XdmLqLXLb1uBIm6biNdZ7ssk0iAZqc+cLPNs4uc/uOOTzQMv6hN3V9Lu++GzW6yOVDqwmOUdZkM6i8I7J4XLw/15H8t5KSCYrOwemiTtsuW4JFHqSFrmRQB0gf3NhZt+QKnETVYhv6kvYrNB4nkv/ZnreuBHxxvGsRL/r3o5DqLssO2mYtVxGhoY5ZybURXpqtBJq3G/HxhnuUbm0TKPFUSVATH5R+eu8aJwUs5xgjAa9GFR4Bfoutskzk5x6aQ60kYqTluFVfA5z2fDJr7Da1y4himpUiGSVKmEYyeEcBA5qnTWRKUImeOYnOb+3PFpc1WI6Mta7GQK5y1JtaB0AvvEFib/3mgpRPKlGxAD+EEVKx8zKkInLhAqV466ioRjhbm3oBOxWZQ+nsDZl4/qPV4loc+wgrO0jus5HOU4/sbjM14PWyIC6liAWW/6Lb2eeGEP/J3LxwA8Tm0ZIagnc/PozEqreQKTD33EeZ0dK5brN4FXJL9SB1DSdvdjhalD4chpkzsLbSh92uQVVef47s09AK/OAqw6Dw0qKEKbmG5WkNFTz79v0lJK/U+B/wPwAvh/KqX+q5TSv/gPet03PqCh5May2U7l4dQJyuixwuTZSMgbZGM9g6nKBRcms3Kvlmsoo9ZiMmU4DcgNZ6OAQlblK3yfGG9lljE9yxtIH+RmjKstPSzBLFEfY/G+CrW0I7TXhDZvovuMMnNgBo3P399sPdEkvFMsUKqQN7aUA/HyQ7Rf5jtp3XiqJ/YgNsEydwwyiIt9wOzkx728PfDzu7c02rO1E580DwB81Dzy+XTF63FbwDVV73B7A8jMawEupDpCG7BNWGcTscFctIAGnszhYpvQF43xqrRCYxfynGHitjnznU42gV7PfDZds6tHdpVs5Bsz86XdUVWBoBJu0RDMQcPoSMibindi56Iz+KEcnxz8+mYuQcaYyHCuiaOVlphek4N5L7OuRfk9ZjARbp09gZChu4siHCrcNiMtm0ToAuxALz5goxUwROcJXqH90grNgIuo39n4QyMBR/We652otkyt40gvggPLV8io1E8fr2T+tLTVbCLWKc/i1gRgWXbjGF8uH2jE2sekIgaQMjdNKYXvKPJboc1E4iZiFvcGZP5cHRXJKEIWBojZpiZVCb3LrdHNCHuYZksMmrrJ15kJfLx9pNaBv/169Rx7q7bYKhCjosl81Mep5X7qedGeOHsJYq313Fyd8UEzzhVx4ZwpcbtQOspYAkjBgJFWuHar+g11vgacJuXj4Os8d1WJmN0sQNRg+nZmcrbovGqd+GB/4qPuwA9Pt0XFf75UWUMUeOLS9XvRHvw68NBSSn8J+Ev/TV/3Mw1oSqkW4Rk0+bv831JK/1ul1C3wHwDfA34I/Ksppfv8mj8L/GkkF/3XU0r/ye/0GUnlDeOVXDAXvSVVCTs+AW8Mhtf3O07dzDRW+NNCjBYASOoCYcmyF+PJqNAXXSqIsBVUiXJqlbjK86v5Jom0ULeWG6kPgkvIwAt7lllbdUqolPDZ9TdUUA2J5jGS8uDGPFeEOgegLlLlGcImw+tPbcN0LzeC8krQVQqiVwX6LIN+2XQX1FS04PZiqaGiQj8u8xFJCgSYkm1tvOUn52suruaD/sgf3L4CJFu2Kgq6rMkaeU1NfD7hc2ZZqlqvqXvHx7ePBU790/6K4+utHGOdytxEmUSaauxhRWr6WHE3XfO42/Dhs0e6DKi4rgYiiqtqZGPlxz24jsPYolQSdZU8d2w6x7abCFGvajDnSoAcCtx2pTqgIDjNcWxKLOhqxzRWgjoNZkW2xUVWbM2iVTYpFZTiCoyxgyABVa9Kpu4DJKMJThc0rmoCyWm0TYQmEuqFfAzmoEhWFXBC7KSK07MiXCzuSo75R/sDH+xOHKeGh0xpmDMVITiDNqvIs2oD7koRqxXlmGxCa4HHqypwyQToeRBAU7IrSOXp8pv0JBGRuanpfFFJmcaa1ESmZ5nWsVQsS0GUKEnErp3YVDNzNAyuwmVxgrbyXFUjnZlXNKI3PNuKs/zF16WaO84Nv3l/y5fNlm/vHgD4cHOgM47HueX7d88Zz3kGNotjfdXGoh4i7kkJM0sVn7KmpW4C2+1IyBJ5ILllSkLtiZd1y42d0Am0TiX5+2h/4A/uXxGT4tP7K+bXMs/TsxJ06aSKrJ3vKCLZX+n6GgS0f9j1s67QJuB/nFI6KaUq4K8qpf5fCKHuP00p/dtKqX8T+DeBf0Mp9YeBPwn8EeBj4K8opf5gSum3LbxVWmWAAEgKtxV9uyL5lCC+bTj1FtN5qqwcb2ykqjzDpSGcVgWIOBtSlbLe4BOAQobXv/P52RZefKTyTRq1tGtsZIF+mUmqJrdRxMoUC/nQKuIhm1MWOSAZvru9DOi3G+mJWRMJUYkDcr/0MqHfTHhvcKZiXrQnvRJEnk6oRd085ceifO9ljr7wXcyomHM2+8bteVttSV5zd90XMeV9NeKT5qoaih/aQ9Wy60Zu2gEXDV8csjfdUNM2jk01F9mqvnZcNo44G9QTZJsCfBcJlxX2X08K7jShN3w662KG2FWidnHdDEz5e316vuJ4abKtvaPOG8hNP9Bax8XVHEJbjk3S4HeR1D7hOUWyEsWaUc/OStBxAnpZOIHVOaMQk6jWy7mU60MCzXouxZFZOFiliu/EC83YJ2g5ndCtSGXNAI+LioTGDIJkfeq6rZyiOivMZHiosqlkUtz2A631BZyQgoChsBFjQ6liUlQ4rwi53Qs5oJkMWDjXcFiQJQm3T2sVCqI87KTn77pE2obyXGZNdBqn1i1I9x42XoSdi+tAlKozq/YsvyGiiupHtQRg4PW4xT5BPr3Ynfnv3H7KL/VfEJPmIuKjfP/yAX/Lf0ilI88baUt/q7mnNxPfv7zk82bPpcqarjpRt15AYAvFQyfhrKYnyQuw2Ux89+aewVe8PUswWnwKg0/ExJq0OCveaEmh8z1821z4XvuGT6cbYlwBUDoHs/pASUBDjXievF9l/UwDWna4XoDkVf6TgH8Z+Ofz438B+M+AfyM//u9naa3fVEp9H/hngb/2236GEmh4NcqN3twL2i+0q0yQdrLBTCaxeTZxu5FZzK6emIPhh/MtYRHU1SJpFNWqNweIPqAWeP1TLTvtFCoHg6XVFrpEUlnHLr+HqO1D3ImJ5TJbQ2W+l1LludqtquokVWDdKSnGuWI81bJBIVm99watE/1+pMk2OFqJWvfsDQ82O2Y+VtijJpqsL7e0jkzCnASiXB0WCPkqmHt2ik/z+567mk010xnHyWUx5WDoKo9Wic46vn39AMBlUzMFw5vLpvyG8yiwdtNJe0c/RYTVkdCYMtOygyQBYVbEquYNEihNE1DAcVfT5cD1+nHLfKmoOsfNduZZt7r+Wv1b8iEFcSe8NZNbTSAouk07Zy1H2Rgvhxb1UGEu0i5bBI5VyEjVPMNdrkXS2u4t591KgjJfR8wL+XFLkuKCWakhXoOJRSB3uQYK13C/njM1i2iu8lCNCr7IuprDnvNVS9O5YmOykMSjMsxxDRRAnjdqaTsjsyB3qnEmoY6W6rjeBO5aEoCnSV2qdEFxVp1cI94ZMcgdbKmulJHqp6o9c6dIIX83K7M61OpskZLiNNeEqElJsW1kh9/VE+esG7qIibftyNk3/Hh6hiESnvRk9/XETXvh57rXAPx8/ZoX9sC1EYTsDxqRTQtJZm8/ePOsUDjS1lNtZhzgByNdEKRK7O0saMt8TT+dyz2dlwlCWhVeGsDJNfxgeMFng6BdY5PPZ9CQbXeKc3eTyuzuK1uJ39cV2s9c+kopZZRS/xXwCvjLKaW/AbxMKX0OkP+baZZ8Avzkyct/mh/7re/5Z5RSf1Mp9TfD5fx7+v3fr/fr/Xq/vilLfYV/fhbrZ91yJLcL/5hS6hr4S0qpf/J3ePrf7zj9PflEZqP/eYD2W99OoaFk9QuKjizoCqCyqKseNbOzJUM9u5r7SyeyVrmF531F/ZjnTkkVdXMz5xbAE5BYrBKxEaSYdqBz0plmRTSKVMXSAw915l41CTusmX51TKuawjKQj7lFOSniY8XxtJf31YKw1LNaq4JRM9cGs/W024EXGwnwWiWmYFGqWtt6TqGcKGRUNxO2WiuXgZ50sGLXAoRtQF+McMs6cSqAzJnaCBfsbpCWyzxbUjsxBYuPml2dTQutw0fNYaqZMrJ0AeTEoEijwWS7jxRkpmem9Srwvfw9mQzWySCWeieOASJPJFXifKph0nidcMEUArNWiZNrOM1NkSQyOydzzqiIQdFmku+mnalNEDm05fhOGntRmHkRB87HpxGPsaSezIEA7VW5HpBLSBQytiJftRzzpUvwMKzIuxQVyVlmJ+3YRRU/tHmm2qSi/lEdpf25iDkvc93qUeNSzRh0EefWC3dx0DJX3eWqycbynCKwPCmSEXHttPPMNrc9H2V+GDGFC2c3uSKbDET1jkTVwjczzdqGTFHmSdurgXGRpQvCnG/7mWdbOSYhKWZvZR6qY0EuXtcXoOdxbAWpyiJbpfmpuWaOpsxqeztjdGRnJ17YIwCf2HtuzQj1K8ZNxc7KpvH5uOfVsGOebZkPpqjoWkfXOsapEjsZZGb32elKKrQnPEJtAsYkgklFeYYEpoooHRmymMOvug/4QXUrguBBl+O+dINCS/GgC30qKOH3S9bPPKAtK6X0oJT6z4B/CfhSKfVRSulzpdRHSPUGUpF9+8nLvgV89ju+b56zr95RmThcJ2Lu6YetKgrw46nm8ygBIgQtMF29GgS6WRPPluokw9llNuf7rLyhWS/COuFBgpxeJYFEj01nk0S5IKcXQeYfGnQw0mLMS+D/6wwt2bxJapnpLZSCZGRTk000t4gGDYPGA3NrCPlNHqeau8MG7wzxKMGkHnNbswt03cw2mwdeppoB+X2+XxGVAQiTbJrjSW7IIbaczi2vum25SZf3GJ3FBVP84oyO8kcl/LxCpHEKfRZNTP8EVVcPMhhfwAVuL/MVfdGCRMwb/LabSEnxcOhFkmxZWiDqh3PLoZO+zQfdkZhaLnNVZkrtdiAkJbPT2RTU3yFogjeE2RSrETVm/U2dSFYVGbLQZpJxpOhGxjpJMAvrBuV2Cb8VsI3uPV0GM1zVA1ZHXDA8Lt9/oW0ERdKrfcx0nQh53qfyrLeoqSjZABcoffFjO9tVSmoh66Z8PS5IPqeF+K9W+Hxo5T1VFXn2/FiSrPt6hz5a1KRI+ZrebkaUShzoiPcNcTlmG4/pPW23gjecN7hgMDryfHvmnF0H3j5siVFhTSzOFuehZZhqSTCsZ8w2RYe5o9aeyoSScISgubiKKRjCE9j+VSUI2L0dOEe5Hs+p5iWCuNiZke80Yjvz4DouriYFVVq69Vbuj0pHpmYuLXOjIy5qTmOzgkoApTTTaEhBYbIno7UBayOXY4P5Ur6DjzB1ibR3mDo+6U3LX0Mjs13IaGnzexDQfh/HyJ81yvEF4HIw64B/Afh3gP8Y+FPAv53/+x/ll/zHwP9VKfXvIqCQPwD857/zh6y+X7BuLsmmAv7QJjI1jWwYTjM/ZKWEJtJs5gIggCxVNGnsWbQfs92WoAMbgbuXrKkSmGP0maeSN5n6MduTJHCbHBGX12Qn6cVuHrUAMp6oZvTiPeW7VNCK8lzhu6Wa0lvXk/Co9EWEVB9H2cjf3m9JbxupBp9qzrUJBsOpaktAUyqV3voCDogPtQTzCPakiHO9vkdnOfVVmRWoNnA4dpKB20jMfnNlnqcjOt+YcUZUV1LWmWzXKtF3Mt/z1xmheDtIgAkN5qgLuOXt/Ralk9AuFhHhSSxQkla42fLqJCAJm8WBn86NKhvYmMCmmZm9wWf49unUEg+VVDQLPSqLLaso0PQlcMR6gdM/qdC00CaiXV2s3TMvgax17PuxaCreTz27enpnc1ZOletXTboEJL+PmCuHsYFFD2OqNeYk80Z3FdG3cznW7rER65ZcMZlR5sJJSbJUftzSO9JrgkQliFlTyfx1l68R//zM0fQQFNVWPqtvxFF9cpaLrkt1U7WebT/SVb7MmVwwpeJywXCZl4pdY2tPiJpP72SuNJ0acAq3s/g8awSYgqExgePYFNCOUlKF95Wj0oHeynd72Ry4qc70eqZVch26ZNlpxR9QJ1wyfOau5VzMPS5qlBFTUYBNN9FXjpgUydsS2CuTCFGLdUxGS6cmiCNSgmoz8+GNVISddTxOLefHtlTsJidtMxWhiWLuSwad5UR1ORdV76jqr1776usA2/+HXT/rCu0j4C8opXK9wV9MKf0/lFJ/DfiLSqk/DfwY+FcAUkp/Wyn1F4G/g6j7/Gu/E8IRQAjPKxco6Yw+M+vg/cXmzJuu53Rpmc81LAZ6SBbV1a7IKjWV50FHhqplGvQ7Jb/yCjNqYlY5jzZzaBYwwLxCtUkQG9a256DLhhXbxLy0IkdFdZAW5RrQcjVYRXwFoV+RUPac241LpyhRhGTnU839AiC5r7HnDAV+ogqkvFR8oTEMeVPxUUsr00mlCKCDuBAsnltLBq8WaSWr1+QhKOHtAFXniueX0bEQeZdWmz9XUs0+c3S7kT7Dug/nlnmriTqxey5t0107cXfc4DdBuo0LaPVtI9+nCyUAN3e60BQicNCLCr+irR3WxBUW3kx01tEah4+G14NkLZdLI0F5WgNL0gntJEHxm0RYgD99hATVwawZb74WQ5dwWX+zux3YtDNd5eiruQTat+OGUz8RkyArAfzWi7ByVHC074hVB2OJrVqb8k0UdkmvqJ4PPL8S7FVMii9Gi3o07yAyFyksPVMqQdUHuFo4Eit4w9aCvpydxedz2dcOv5vwXpfvOzrLrplpa8e4c+Xxbz174JPNA3O0fHkRIM8py4cplaTNmgErxkZ2mxGjE2+O8lz9YEVUYNZcTCy/zajE6+OGy3238kN3Uj1VOvBBd2SbA9pH9SN/tP0Jt+bCJd9YWkXGlDDAOTb82lm4bD98vOV4aYlOlyStqTw3zQUfNQ9DW1wdxhxgotPFR6+7GoXmAFx1Ix9vpea+rS98drnirutxu4Uio/M+oghmPZ+pkkpefALlQTfad9u479fPHOX4y8Af//s8/hb4E7/Na/4c8Od+j7/a+/V+vV/v1z+e632F9vVdSro8ZSgeq5RFRRMmZ4yN9Xx7/0jcH/jitOPN6wyymDXnx46xrrm5kqrgF6/fYG8Dnz6/5svDrkCf/anCDBZ7UYSFAhZM6X0T1rlG0pm/4hXV49ISE8uU+ToSr1dcdzxakhYy8QLTjlUqTtzs/WpHcbYob2Uekudqiwuw8grzYIl5xlKdVVYeSCxoCD3L85MGXYci7zSNFTrbViweT8tAOrapcJ5gpUCopAt9IZqE7jy2Djzbnblus2pFsBgVeXXaCtUAaaWlJrK5Gvi527vSIvr19JwHl+kH9SrF4pwc41SvrgHmrEUmSK+zqqJOYhNUsUgYnXXN7AVGvszQXDBc1QM39cAUDY9zJqmrVFo+ReqoSriQK2MlHm0g7VDvLD6pVb6pjjK7dQq1ybOczcCLLM81+KrAzb03xCQwcHYChpjaimmsUCrhJoPOAF49KOJkCZ1Z52IakhJBZ2sDh2xTNE0WsrBu6VpcVgcD7RQmt25DE6VFPJsizp2ShlrEuUPQTC7zM7Nb9OKMDauostGJfjOVFnZjPHfThinYQnTedWNp7/qgMcsMuHLc9gMv2hOtlWP2qbnG39ckm6hrz3d39wCMwfLqcYsa1rlp3GguU4XRHbfNhZcZbfXt+i3ftQdempovg1yPr2PDD/yWu7Dlrzz8Ef7LVwKgPhx7aXpUYqME8O3dAx93jzy6jq7ynJYq2htR1K8izVZ+74dXR6yKBRT1WRagPtQtg68wJpXRQxg0Nq77VmqecAUBNSvMKVfmQ106BV/peh/Qvr5rOTdFobrPc6ImMGUU0t3Q87w786I5cV1f+I08fH7zuMWNFj8ZjhfZEMad5VvNiUtTc2yaogbgVSUbnX2X3xbahN8tavjy3MmKeomZVy3HlOcrZs4K/ovG4Sbg914Qf8f1Rk2VWL/YOhS1BdXNnE2HfV2VHx6rtLZd61QAJNrlz57XzUxFoBaVib6fVyPC2WBd7uHnG8hdB/TGkWbRJWzeZtWKiwSR0EDa59cDtg707buK50ZFXDSchwam1fnAdIFpskze8r2NDObv+57jWbxJFu5SiALaUed3L2MVMj8tCl8IwHUKbCq2P3MOaErBcG5E1zNvrueuxb3QXNUjPpp3eH4Y0VJcAoeaRUUj2XzuM7Lv+f7Meap59AqbE47ddpD29ZPv2uRNurcz+2pE5xP32m7YtxO1Dow5aDhnCE5jqojdzziTldgHLbqTgyouDUln0nZQjOfdyk/LljKxj4TNAjgwNPcCckrTOvMLs5ZZVFhRs0QJVOPFkC6Wuc72PFVAaZFzanPCoXILcLys4AiAca44Xxpi1DRPrgmlYJ4NMRjMYq8TZe77sjvyx579FIBfuHrDbzw+Z3AVL7dHPukeAPh8vCptzdKOfd0wVDXDtmHXTPx39/Iet+aEUTAlz3JGxlTx2u/51fEjfuXxJY/HTIwOiqZzVDYUEMuH7YEbe8EQ+d7eFP81n4TgH9LK53PBELWogpynmlOWs0r5vVN80ipWcowlsUzodiW5p7OletQ0D/Jk34Lf8X49Wd/4gCaorncfi3WEqLicV+8FrRJjsGyrqUjhVDry+f2e+Vgz3slzf1V/wN1uk1FTa1aPkcBhBkVG++J7mPuI3ovyxQI8i4DRWtCWm3WjMSMoj0CvM5y56h03uwuP544pZBmcQRHriN54qtoXby0QqHVsVwddGejLhpvqWOaDKlDAJsVhuBbUneo9m6wxB8i8r074zWp+afczbTdzeugwgyJLOaK8OA+j1+diEvOlYr5UPOqeV3WeheRjF4NGZ3h+0zq8F/Luq27Ld7aSfe/qkW2fdRnzhnkcG9KsMS4DZkp1IqT3VCW6KzkZlQ3iDB1kYB+G/NucRo8aOwplASBZy5dc0VrPHEypbmwViJ0iPYW8DyJO6zeRsAtsc1Z+28l8JTmNz8+1V5H/wQe/yQf1gf/v43cA+PX7F7w5bfhof+C//+yHfK+XAP5rzQc8Th1fHHecsg1PCpoUFN5rqt7R3UhlEfaa+VSjzqYAL8ygqB9UQdROz/JvU3JPxCYUwM0MVCdL+yiKOovmonJKvO5aX/QHF03CNFrso5EuBICu8LvIfLVKVIWgmV/3NF+Kt9zpQwnAze2AGyrUYLi0ply32mYgz6xJ23zpmMgwVzzMHU3OSpfKLkTF2dV8OlwD8DB3AvPXFP1N+6BJFsZ8bWwzf6dVjteh5o7EIQkI7CfuGXd+y73vsWqtxrROXPUDMalyT3wx7rmpLnzYPPJBfWTcZKSlbzmFBh8NbyeZvd6NPa+PW5FIS2qF7YP47ilKd0EARvkfc5UGyLHROREtMmQrcvorW4n3oJCv+1JplaZRQXyp0qhL++30UHPsNpjW07aOXScX/exN8UhbWmrDqeGLIKi4JRsEisabeSJM7HYJrgSJNEcFGQGXvPCbUhVL4NJ3FdWjIBbdE+HYvp257S6CnMpK7DG3pVJWdbhkDcLgjTgx61QGx0lJi9WeNemyovOUX+S2UrmBohIEntKJ0VnmeZX5SU3CmyctEKc5uxYGg4oUqS5qEeR1m0TKbTVlo4hBD1oC41J9VhKUN9uxoOUA7k89vha029tJgvi2mrjqRs7zqsenVAIrEmbqiUxQrBNxF1Gdf+ccDee6+LrVQ95AvCLUSTQIl83DAceKH+vb7Awuj2/3ouo/nuui9C6+Xom09ZjOSwsU+M27W87HVqrH/H0fTx0H33JjL5x8pjnktq7LO9O36jsAvqz2/Mb9Mw6f70pbOtQJDNlXzuD3crHVraPezszUIjoMaGeJ1eKgsCqIEKWtKwjHvDN2Ad8vvnwUxJ12Svxs2xVJ553QFvTJYIeVhynvrXGNIbXv0kUXea/l/BgTUTaiJovOUlJhF6By+WZFVFGQKsV7w/3Y8TAK8OLu1DNeatJoOGx63m6yf5mzzJcKVCr8ztjItdncDvxTtz/hn+l+AMBGeX7DPeO133PJsP1jkGD06XDN3dAXpOTVZuCT7SMxKe7z9eijRpMwJKZkuFqsu5HkePkDcPa1+OXNsp8s3DtjA9GIYPFyT2uX/RNV7ig0K8Tf154xdtJaRq7zp2pFX9l6H9C+vks4aCsKjygbQrKrk3B9D2CYr2umTeLSSXqYKqlWzH4uHYGlveec8JPiokg/ZhPAfjWw9FeyoS48JpsvTo9drWaWxNcpmgdxI461Ysr2GWNX8Ti1zN4UI8ZU55ZXVCIjtPxYlVBNgEkXkVyi8J7qR4XbgN8s/cVlHrdmfJA7Hl7LZrxoR9aREIPA6TNpVlshiKYqCQQ9fwl7Ecj90yxPV5FQJdK8zi/lYEaa1rFrJz7JyC+rIjEpYlRoHekzEfbn+rfM0fKD+RmPuWI6nlv0wQpVQa+fGfaB7kaCz1ItxKSIWUVfeVHRX66PWEkFW5KAJHO4NDZgIGaLk7iVRCZNpuhJJittTWUj4VwRM6HXO0U1yOcs87v5XPOrDy+Z95bDJL+hMoHn2zNX9cDbeVuO2etxy/39lvqNoTrlFtNGvmv9oEgHw5Sv3/mZou7nTITOav024a7kuPhbV6D07ixBL+n12qtaj9tXjM8zhH73JFEbsst2bptGp1GHivaNpn6kBHu3zfPKoEoipAB2juHDPO/d5fZqI6jSY2IV67VyrqIRo9LlZPrREoMqQtcgM12iQjWBqvZlVhd8htbvHfo2V59jhTKRT66PfKu+p80X+6d+z/enD/nVy0vOObnYVyO19lx8zWVaXTcmZ7n4mn21ujfEpDn4lrduw2fDFXUuCWM+ILX2RfrtODVi2NnPuOnJnpFgsx2pTOBgJFDGN1aoNhUrUhPYthPbeuYLGzhlqbqnJrXvl6xvfEB7v96v9+v9er9+9+t9y/HrvLQoSixADXtRECHYVAAZ9TFRnRPNQ/avqiQzG5/B+HOBlx8ciphtTIrD1HIcG07nlrRwdjLHbL6OJaPXnZeh7yCSOa5ZlR5UUiTSOpsAklbYIdG8Vet3qBsedJSsNnO1XKVRdm279Z1k313tOI0N51mThjy3mWSOEjP/qbQonrZhl2LOyOM4LbOWDI7RKhG0zvy2jAxtZ1JSTADntWKpD6BCysc7t9OuRcInbMXSZLGEsU2gsoFKxyJFdV0NfFntONee624sljD3rsdHQdUdH6X1pN7W1I+5jdmndZ6Q7Tg2zcy+WVXMP9/t+fxhz3BoCRkJl5QgRu1Rl0ooZUJxrHmn+hyHmjCad1B0SSeYNJws9Ulh83uoJBVLfHqHBcVnb684jE1BMyqVaIwvaM4xc6IiiuSlRbyIAsw3YoiqnSmoXcjcMBtxJj21yhJZrTZS72aapbMwVKRaQFELt9KNFp3EZ29BPoIQru1JEyuZQ8lnJfQsABJ7ScSC95C5qfKa8PAEBNJGUpc5eblDUVvPs/7MJ1ePTCF3Irzl8dLhxyrPo1U5ZjGKisiiFNK0K0BDPxGKrjeepvK87E/leP74eMN5qqlM4KfzDf8f/gkAfjLecuc23E89Pt8UlQ5szMSL9sTdtudNkkrodGn4Sbzmw92ROV9kh7Hh6BoqHbi4GrcgOlWisV7sbfJ8cQEVWRuxdi7I6ARsGhHKXqrMk+mkY6CzEHSudn0wTD6r8y/eaU9FFb7K9T6gfb3XU9dgMyCba7+CFua9KCXIPEmRZnl8ulYok6hNyDpx0mpojZBgfdSccstEeWFQx361n2m7OSuDb7APhpgRhmEbYOtoe1dmLqmyDC8pVi2lDegUzhlivQa02K9glLr2q1pD1AznGjWagupMOuF2WVdyuyqhT4l31NpB5knJIO2fOrwrnOk1atYFPjykBpIieYWdVyCMCilTEqTNKe9vmW8CqRaXgGWvqmpP38xcNwNVHuT5ZKh0YN9O7JuRH59uAEGiLioaCyDDzkI7ECPL1YEgTZrLWGNNxOXEQKsojtbXcGjndXblDPN9S3Va9TOX2ROsc0+AcLLYR4uenwJeZOOpTormTlEf5PFQw3QjNkULylW3Hj9ZHuYNJgf17UbaXABDqIrdTUwKZaO0yxfHgeuZ7W7k2PSoQ1U0E7WiKPAXEEEm5yYjKLqi0K8gNUEI2jnw1A+iRxkrmcuU5O8k16LfKFxGRKqoikDAYp2yrKRl/mWXgB/FPw4tFI8FBFRp8cv7I/vP+ah6AODvXD7mr3728wwmQtClhU8C2kiMqhybebbr70WMPkHmzS/6M394/3mZX/mk+Um65mHo+C/vvs3L7hqQ9uJVNaBJRQ7rW809OzPyvDpx9A3HcZFus9Q2UJnAkGW2LmPDOFe0taOrfKEUWB3RJAk+izXUExfwpnKlDZ6SojGBmBRD1jI1kyI2klwklUEjiAvF/aEn3jXF8cLMqwzcV7neV2hf55VWaR+AYueRKNml7yST1kiFNmf/qulFpNuI+eMPHp8DMGT1g76auepGpoxu8qMh6ojZOpos7dRWois3bGrSvV19jLbQbma23cTdo2SBoY/EF56q8Yz3bVG9UE3Ez5YHtymb1QJpTlHhveHhIhXL+b6j/rzKPm35sxqB2Kc2ihXIMme6Siib0FVkzhuQfVsRbUJXgehXJB9a7O71qEDljeYo6KzYZFrAsr8oiNmeZwlcdgC/VYQuEtvV4ywlhVGJfT0UI86jb4ve5JvLhjf3gogMF0u9n2gbh87oPPccTBaNToe6fKBKivmh4c255rCRWdWbdoNSiW0z82JzKjOZN6cNs0klKwaKsosKixFnDoqzon6UmePiceZVLF5o3etIe59nN3tD6BTzFYVztt2Noq7hTElOmsozR8vDbBh8xcVlyaeoUTqDOZYNJili1LTbmUkhcHoExJMSv6XaT0WIu238uqnqJLdAWOeIy8xTe7lXCo0jHwPt1k1OhYzbyEZPhXayfHR8V3kmIDNfs/VcbwWVed0M7KqJj6oHfr4WmdbH0GN0EiTnxRR6SdgFtteDAIIWy577jjBr5qoBk1ZAlom8HXp+OX1SKrTHqcMHIxy3qHneiKrIP9F9TkDzY/2sBMreTOzMgFYiWrzJEP2m8tx2F67rgbNbq88YNT4YdO2K6PF1PeCT5vWwZcxVuAuaygSaSiS83KL/6g2f3+/ROjE9ynXaj7my7pJ44i2qK6cGjhZ71KUbwhOe5fsl65sf0GwibCPhCQigfpQN3+XsJlmBeYdKqrXzt+SO7r5z5MXuxOAqvvzsGgBzX3G392xeXLjdXLjK1vZ3XpO8Jnot5FWknaQzMCHYtDpZz5p5thyiKgRfmsj19ZkPtic+b/acs7BvillIdtYlI0+NFjRbVLgqlo2telXRvVLoORXYsuvFcTj0inCdijCqVqlwho5ZBio+WnE4fhDdvUIEz0GLtLpbEzOYYhMJXSRp+R31MWGmyOT02m5Loj8ZskB0ygF0UhVzbzjMHTHfmZe8qY/OMkw18V42EDMpXG2pa0+/kS+xfz7y3d09Y7D88OG28HvcpcK+rVAR3E4+66Fu0K3H3EhL6JCz7+HSQBDgxrJR2AuoSYAOelY0GRFpBzBTIjRrgmTPSuS+MoE9GVV+s/ISJPy09oV2/cjh3JZW0kPqBPCjEsNUMxxWKslSnSzRRKuE9xpjxFtsqVLqWlptWieGBR1otchwXTmu+qG0OMvxTyt6c76OuN1qnLqsaEXvuX2bisN2aDPHcNlMn74kqQxnfNq6TVAlun4qkk/f6h+4qS602jEmCeC9FqHhlMhmufKWqg3S8k6Kyi6VbhCCf+Kd+0JndO5vnm8LurW2Hq1Ecuqj/sD32jf58ybe+D1H33I39+U73HYndnrgF/tX7LM19BBrNmaiUoGDa/P15JicZZpFcuy6lud+1D7y4Hpesy0Q/8tYZ9dqgf0v6EmtE26shGN6WAQPJGmYZkW8flL+Hi1mWDmPIOCddPtbOEn/qCsn+79f1zc/oL1f79f79X69X7/79T6gfX1XWzuuv/1QxEO9aTCzKS0TWGdI85Vi+CChPpAK4MXuhNWRh1OHvcsWK/eKOVjcteHj7SNXlWRmv1J9yE8/v4XHCmfyIHdrmZoKd64FZZ+7FSpBGCxqUdTPD7pguLia2gbGRYZprko2rZa5gheMunIaRl1mHvVBYS+ZV7b8Ni8yVzoowk49cf2VVsqumTldFgtchb0o7MWgHSVLnq+iEMB1Qi8gGM87zgXven5BdU7rXL9eZmlZzUItPyNxGho+Y0+dB/6Ds4xzhTWRtnZM13Jyotdc30gFu83Q6atq5LqS2aZPhp/kN344V+Iw4FRRlAeN2xnOnWN0lnOuhNLZYs4GBYR8Pswo3z80Sh7Lx1IoBzJnXFptSonlytSIor/J11JoVjHpxeX4fG7x7cx0riGfy6AqpqopChF6sX9xSrhZzdp2SkFAAtEItWE5kCFoqKBrZnyfofezLkCMmBQ+V3NpMlR3Vs5vPmfzTSRtA0nbtTWfVxhF2NpMmddlFalb6Q6xXrh/rPzH5doLYEZNUHCpGi5XcgM02lOpwEPoi3XLJda01mPqSLxyhaJiVOJyaRinqgBb6sbjlMiwJafLc7VKouAfDHOujkLQVDawb0ciiscFYQN86fa8mTY8TnLiPzdXPK9ONNpxY8/8k514Cbtk0USOsSvtycFX3F06JlexqWa+3WcBADPikuFlfyzC27O3TGPFOSisjaX1umsmvrRbTqlfuyEqU0HyOGCZoekgyj4qqkJ7iX3gk5cP/Ij3a1nf+ICmVOKmH4pNxXEyTMvsYaGmVTA+V1w+ilQfXtj2gnAIUfNw6ZiODXa54IzcqCFoOuP4sBEkweftFT/VAkyw2ZY+DhrXykyLqFb9P5NQNoryRDHtVGWQ3VUOlU38jjoxW0u8WPQpqyrMYoWiIphJr6rpx3VIX+aDPcxXSYbHCqZhcRmVVtXoLS4/Zp+oFJgJVHHm0LiQgTN5w1Yxk7PPGj2vXLbhheb47RzUjsvghUx8lteV4JcUw7ERkmw+J0wGqojtxC+r6+UDjY58sD1x21zYVfLF9nYkJkVAy3/TeiwXcI1ZCNRO5mGXuocqoo+rpqUZskRZbkHrPoNcFPJYSTykVf0UtDNX2XBRJXhtisEnTU5CgioJRzhWjCkDMxZ3AqfRZytgGb0efxUgXbT4ri1E8iCbmWsluVgcFYwVtGhKijbPb80z4T8aG/FBUIIgpGp7UbkNvEQe0e6MjSYqtYwMC5gqVmt7UmTUErFR4jG4YFFiBhllQ9Hl+yqf0KMmHmp+0l/Lx6nEtpq4qS9c54RwebxuRJW/ziALFwzDpRFlkXwcrI2oxhGjwmlbAmiIIhxmTcBlDtk8if7lMkO8rUWPrTcTvZ65qS+SHABH1/CD4QUfNo98p37DCyM2LxvlCShehw3PKpmlX9WiHOJqh9GRH11u199BYmNmNps8gzOezw57JmexJnKbEdMvuyOaxGdJccoJzhCMzCjbhNapBOu49YBFnShqMMrpsq99VWvpEv9+Xd/4gDZ6y49e3b4jdSTETYrczPQsEjeB3Qcnnm0unLO31+dvr/CHWjbtJXNNsknOx4qfnq/LJnqcG7SVeZLJF6dyCpqs/VetYAh0om5d0bxb1idXj9w2FzZ2Kqi/Xz18wG9+8RxzME/QTYidTCNzn+r45Pc+zxf7E+NRdx2giQIeWCoWpzipjrNqSZeMtLRyLFKVMCdNdZT3Wty5k3l3CL0osOhpfXy8TbiriL1ool1fb0aZv/jNE784k2A06IumOq5v7HYR7zSncb08lY2yUUXDwywR5ra5FDLsaW44H9dK02/EKy7HPvSc5LhVltCmd9QwjBMgiX9yJ4dGiOhht4Iy7MVgpoT2goCFjHbUIs4cq9XtOdpc6RnKTElPBh8U+mbC5kA9X2rSXJUZ3FOHYu0V+ixWPfJYItQSuFMdi6FpSkLQjkmVQGC6kYehZZ4t57EuiYyeRBkltBCyIK7ZOVIEexBLGf/EAsfdJkKn1sQgKNw+EZtAaA32uCJl9ZwtdJYx4BOwCaPi8kaqo18ba+pG/N++s5fK5nlzpjEyCwQROwZB7kYngd3XiwO0BO7GBgYbCwxea5HJenzsicv9HhXoxEF3hKh50cl3+EO9F8qICryoBSjyg/NzDr7hF/uRD+yR65y9vdCKQOQhBu5zhXecW1wwaJV4nFp+fH9Trp1tO3HVjFw1Eqx7O7NvJ954yzBWfKEF6DQFy/2lkzluTmSWxDOZJMCsBZ1aRXg+MTeVmPYiVdzh8mTm+lWt9wHt67tS0MT7pgAyFlg6kQI/DtvAzYcHvnP1wNE13C/Iw9ct1VkqK5cHtKGRjd6cDD+9u+YuIwyHqRYvxK1jSdJVUKQuiO5eN5frZJoqYhSxUpsH3UolpmCJSfGsOtPn3tWP7Q3RK6pJWj8AdhTOWJxyFZJpBvNOMd3IDWEuKzjBXDQBUDu3GuCea9RgpJu5KIXvAqoXVXzXVqQsfmuHFQSQcrWikhzL1ESBWD+Bi9uLlo0zb4yxkXZJtIl45Yr0Txgt5tHQvdLYrBwvqi4K7QxJG/GUQ8R0x03FA5Rq47Ft+e7uno2dOU416TEr9kfwVwEVn2gbKlEwWRCZi4Fq2keqg6L7UtHc5cesVO2hSyS7gm5U5J12LkhAtEcZ1vsezh+vG/wqM5ZBJdmFYLYVabMcsETsI2jx1isqKkkSIj3pIi+VrMAvVVS4ClRWttdaTCWtjiXBUggKbzHDXFQlRMdRjueCvjQ2MD82tA+K+gFClq5ye8N0E4mVBGfITu97T9U5XFOR9NqKh3xNLMfGUFwiVACbRaTDg2Xc1AybpgAn5muLVZG+mXFZJxUECZgSYFOhqpjsXr2pZxrrOed2dWWDgC4uFpO7GclAbMUxYFA1Pz1eA/Ar9Ue8qI/0euZ5zggf6p4pWq7NhQ/NgducY211QyRiiNzNsje8Pm8k2EYt/MRM3zG9p6kcPumiFLLw0CoTGGPF/RsJaPfjVQZ6qLIRJyXUCWxOpBZciBEakN5MpZOTYJWne7+AfwwCGkGhL7qg/uQCyS2yhed8k7jqRno789lpj18qgyrirxTsHFdX2cLDWcYvNhClfTdnRGN0uhCU1yw7oYygCZvKc8qySPN9iwqK87WhzyajRiWOU0NjPJ+bK84+V4lHaZH4LpUg9ZT7s9i9QG6HztIaXNCIMWv/JaNJG7U6Q9cRdTbooIgLl0VJApBS5KlLcWhFKukpqk15BSqhM/Jq2cWqk0gzoWCU7gy+j5BkJlR1rpBImTXVSdPcpVUguZIW3WKOumgQds8vfHx9YHAVQ4Zvj05EaisdqG0QbUykFUMd8bt1hmYvgkR0u0S48uuuGzOJPVG4dG4rf3yfJPnJQSJWIrxsh1Q2eJvnSKFNzLtYjpmeBBa//A5Y25/maIgLGjEH96SAjWd3nWeC3jA8tsRRk5Y2b4A688X8VqGXYB80bx62aJUKZUSpJJzEoxVu02IYu42ldblcCyFoyBzE0K0tYT1n14JNJCzuBBEYNW5qinL/cu2hAZXW2aoy0m5NQhNYrkkzgksaHyoekABR2cBtd8GoxBiVOCsAfrJFcq3NM7SbfmDfiDPBHFfpt8tUy+ysjsR61dpcxAAWtXuAzy5X1Npz1Qws7/Bh80ijHd+u3tJrz13+ba/DxDFV/Pr8IS4tfL6Ec3aVv1tayCpRmciumgoP7YvzpgRurRIhz1S7zy1mkM7FMo4ItSSJug3Shl+uJyuallUV2Gat2dFZztNXX6Gpp+z832frmx/Q3q/36/16v96v3916D9v/ei8VJTsvGfUFFlkjt8nPMZHGeMZgJZNaTmgX0E2grj3Pt9ITMyrymQ1czq2I8y7tqGwfky4Wc87WIl7hk8J3Riq7s2SH9iAVga8toc2otCzr1FrPFCxfPEpb4nJoISrSlWfSWWX/fs0+pQ21coRUEDWUZebnbpOIzZpEulhS9utqbkYmWszJrG0uG0v7kbAqQuiQs8guorPKvAAjhOskrTl5mRmkNar9OrxONhF7j9k6rI1My4wxqLW6W/AcVuYIfitVosoyYs93Z152R+ZmhVOGpNAq5kx75PVOflu4WBHqtVqkq5DzLci+9I7oqzkL8nK+hul2Qewl5utI6sM7z51vIqHVNG/X9m8yUsn5XYSttOIgtwGDQkMB3aTHLGvVRsjcKWWjyKPVkc1+5OdvpO/5MHX8dLb4nXAIQVrHzV3++6Dxh2o5VehR46tEvF5nkXGwQqI2qcixmZ2TeWgUpRaQmVSwiekmMj5fW6V6ljkt1VrxVEdF80Z4bE/br8nK382oCe3aQlCegqgsgKUFuBsonMS7x03hdc1DBafs9TbJHFo1odgkfbg58Lw+c/ANPzw843Um3/s5fy9FEUJWKrfgrQhhL35m22rieXVia0ZaJY9dGbnHj7HjB85yiFL9vPZ7Pp+vuXMbTD44L7cnfpTVZprNXNQ/lIJNPfOyOzAE+ffP2OO9mNPKUHE5DqmIICxC6bqGsFOFJN9kYMn1duA81QxDzThkd42LRQ3vmdVP1zc+oAEU+1fWOUhoKW0YkuI0NzyMHeNUyQAW0EaI0SmpgoRqTGTfTuL1NFUlGFgb8N4Q9KqXmAC8EtXuxlHnzc59lDUco2I4ZwL1yaKi4qdnUTYPCxk3tx30E6uZqapRuaWl3dpynK+izLmsKsHE7RNp56XV6nRR0N/1EzFovG+LmajpPXE2+MGKxciysU1K7GGaWPZ3AZIk/D6gt46wGJ2OBnfR2EGt0lqTIrZCIg8mrooWSYLX8MEaNPw2yWcZSG2gyi20wVV8ehZV80veSIap5jfUcz6vHKe5LpsKvaeqAlOCmGHWqVHESYK0irq0WXWe77htKjO/xTtOnyz2qFbE6I0n7B2Xpi6yXkUhIyEq9vmY3e7O9JXjy+N2DWhG3nfz4lIsii5TzUm1KJO43VywuTdudKRpHOFZYNNlFZVzy1D1mEHmgdV9vkaUXANBsSq5+3VuFuuEyrY/1ga0TnhnSou8rgNp64i9x5pYCNv+YgUxOppCrDaDKkhVM6+/P1aiG8oZ/Ca35YLCzJL8RMs7SUsyIpFm8oYcTMVhsKiTzWT1fFgr8E3C1oEXGwFvfLe/o1KBL8Ydd+ced8gnaDF7MwmbFWSa1lEZQYEaHQs9RIBXgXu/4WUGorTK8aP5Ob8x1VRPLCguoeb1vCMmVWg6Z18ToyZFqCtfAuVlqhm9pdG+IDgfrnpe2S3HocG5ar2PX8ixMsMKukkG0RdFkuTFk21Ti1xbOFeoDOKqzuqd8cNXtd6jHL/G67fax6gkAIXQsgqxni2f/viZ8KyaQJeVKEy+ua2J2HzluCASOk0lN3/h92SAh94n1HXeLHUiOUMKimm2xbH5g+d31Cbwg7fPON8JOmEZDkdfE7qAyU7L2gRC3nzaLEI8KoGAq6PJfKBchWwCzfWIfy6WGwDaRizIDOSsy/DabzVXu4Gjifjc309BwdFSH7RYrOTZjXFiXWJaj+7zcVCisFHfjPTtzOEovyMZTdwFXKPRxR0b0bKsNXO/ogYU4K4ivnt3FqNnhZoV6YmO4vHS8HDoCf5dnb83UZXjapZ5g17pEGoBSUyihGGmLEC9zCyaJHSCsGbJASAaqoNsNG6xuU8yY1Q6CWQdioGsPWqCVyy41VPb0FdOhvbTGnioI9f9wHWbzTmj5mwSVRXoq5k5B+DzXGNM5MXuzLe2DwAc9i0/6a45HDvioaJeAlqA2IuD+QJgeRqM/W0owsDGRIyJeGeKjqhSorNYNwFjIlPWFXSNIl0s9qCpDmu1Ho0EqfqwJm8qQH1KRKMKAjTWGRzjE0rLcV/OMSkb2haagkXFBS25KoW4LpKaQNs4bhspi6/MwJQsJ9cwjpXMTEGuGZtIm/BEWsyxqUV7VatU3mNvRz6drjn6lsdGrt3ezHwxXeGSptG+CGMDdGbmk+YBnb/wF+OeqvLEqNi2Ex9thL7z43jDYWj5Ytzz7U4QnNf1hYexKw7WxQ+td4QrzXys0MN6TdOFTOnRgoAEfnRuCYeK9gtbAFSxekK9+CrX+4D2NV4qw5N1bpWNCp3AbaOAAwB9tJijJWwiqYps8gb5vD9zcTVTMEXDzeooBFAtBpRjJmXO5xpdBdp+5oO9ZJK7euLz4z5vxIYuw/T/iasv2ZqJwVf8INvTx8FgBqkgFrIqCFItei2UgBI85eZVgaI0D6DqyK6f2NTHIrh6cjVfvLmCs2S+IU/8z5eGtpuzJE/+rMlQP2j6zwXUsSAByVSoBGyWoGoS01ARg+Z4bom5/aVnTdwEUh2JOclVQQuE/qRIB134XrGVVliqKRQK5fSKJpzM8rDwcTK4YPFkqzrHy+sj1+3A26EvcmFuzEHkCZJVWjsC0hB+Vc6Ia+FU6YlVmiwsVUQ2x8zBT4js70pExUrU+s0oPLK4zZWxNzyOLd6bYgaqEug6viNya3Sk62YqE7A6ruK3c0UIWtT4c//4O/093+of+PXDC37Ac/zyviEnZzZCrsrqe0GOztdy4vwSvHRi34+0leeQgRfjOetgdpKYzbk1zqwFGLVfwTX1o8K6nKSsFDLqU6R9NZEqTX3OFfSNqPSHWjHvpPqG1YFAz6pUA2YQp4ZkRForrIcYTKK2oXRJpmTRCJdNq1SSNzNKAI/7VNDDLhjOcz7O1pWAFJOIHVsVueQSvNKBb7d3NNoRk+apPPdkKno94/L9M/oKoyQRUVBI1MvesLHrc++mjVAoJuHSbTMQ7LofGL3l0LSMyz7gNd1uwvucfC4jjUlTHxTtWzCjHLTpdiXvv1+yvvkB7f16v96v9+v9+l2v9y3Hr/NSCbrA4jbhszJ6rCizMnGPluoonC3DXtKe25sL+3rkh4+3HDPct29mWutxweC8wS1CxIMhzprJpKJ+f3fu8UEX9YOXvfBd/mj/U75Xv8Ylw6ujuBQfThXquMz4VJmhKS1q4rYOJeucR4t2AkNPhkJU1nXAmkBrXZkVnFxNdLpUEMvMwz00uMdGsvolEfU6E40T0WaFCCjtn+h1EYi96ka+ZMd416IvRuYn+XAnrUn1Ct8O20iyiuqoUU44YctKVSa6P2ldoSSLV0FBloKKbaDZT9Q7Xwbzz7dnvrV5KPYr9ychvbrHBuWyRNBS4SWpYqKViqqoxJhcgUWFinmWOGcQUQQ0pVWmluF9WltlMsfMz0+KkKWn5r7irJJUlMs4RoOtfOERAVw1I631zMFIlZmvM6nOxHfrcyvUjZ/fvuXailJK188MmRYRoyqE+QLE0QLBdzs5Bgv4Yg6KsNVctWOBkk+nBmbNPMkFsraKFWErgJVFWFrfKZr7VLiP0ayzxNDnC2WZvXqIWtr7brd6rWmnVp5ePo52yC1MI9B175b31YR+sQCS14+xotWOOYqNzFO5rtgmbOOLUj5QOHq1Xudijfa4ZIqUFcAH1YF/rvsNXpqZu2j59fkDAB5Cz5u040u35+Clqr0b++LRplUqnLO+EjuknR3xuULzUROCFi+9KnKV56cvuhOvLjs27VwI5S4YrI6M516UgQqpT+71eSdKNiBz36f+dV/Zeh/QvsZLiZFkzBIyror4ixG5nxzQQhtRJ429aJRTXHZycX66vRLeSJbUAbk5FuM+reOKcoygkEB0VvJ67wzaJNpuZt+NfGcjPfU/1v6YP1TBeftr/PrtCwD+60tDPHYyV/CKNC7qEEAlQIpFxT/dNTQPmlAn/DaR8rzt+fWJjzYHfDLlOw6z2NWLykcqG7F9yDfbVq0BcRAgyHQlAd/t86ZVJWKbqBrP814a+B91B3zUfHpsSDaVhMFMSpBuKRVeWKoiUWm8F/WOQjjOrVOiHHcAO0jAEA+tWHQQiYpdP3HbXYrNvSbx0/M1u2pkayeuNtIDG881apNQCnEqAAHmZPCEdqxzvDYQTUJ5U9qeSSfsWVGdcp81f958leR/zfp6O8jmvMhhxccc0OoKpyVZWI5vqkTO6OIq+kraz9tqojWez07Sml44el2fgSCndfbS2xnXyOZ83Q9ssw/eZa443m3QB1vaoaFJzM8j9tmAMWltOarEMFfC2VqSMRNJaKp7KwCg3BJWAZrXBpJZUcJnCWZ2TLhe4SQfw/eaeatpjrFod8Z6RTOaWRIFEGCJzm3d9TgmqiESjfAol9mcaYVcPswVXw6CZrybelw0/Oj1DeltI/qRiCJO+2LgenuhyQndFAy19TTG86I98XH7AECjPAcvLg9LK3NpM95FyzHWXGfUI8CX7oo7t+GzyxUAj0OLznJsz9pzuSY3Zua2PvPg+oJybI2ntoGhkrb5YhH0dtxwd5Hzu5zL2gaGuRJzV1ZOYGoisQX3LJX272Iq/H6t65sf0BKrXiJSlaVGNs3i4qsSfjCr11MmVn92Jxdv27jiluuDJiWFUokYVzJ1qiOqDcW4EQSQoVWSvnk181H9WP7t8zDzg/kDjtmOIi0ILa2ElLtA24FQa9y0wnO7V5r6COePwb68cJ0tbG67Czf1gNWhgAuOc8P9EyTeksGTK5bUxpIlqyCow/laAthC+lVPftPiMHwONV3lsK3HT3q9uWJWhwiqCOUmHYvGX7Ipoy5k/hf7gB5McYtedCl9r2AfSpWn6yAbk/UcZ0kY7s4902zZb0au2rEoMmgr8OjodIHdxy6rcESZ6cVOflPTz8xjRdKmFKqhFfKvHaC6LNQIcFuBscdmrWqTNaXiD03C73IwaIPA4meLqxddI8Vw1zEcG0x+7H7XsW1mLlNNTKogNb03zJMlnioecuD5qQ3UOtAauR6XJGvfTox9hT8bks4BrYuw8UXbsVqQfJXHB83p3Bb05XL+F5UKv8/nPSrMa0NzL4EMBBQy7RXTXuF7JTO6/Nz6MYOC8tuGWmGmRHVKJL0CPcwkn5WqJxQBRzbYBbfRzFdrEhFbmR8/DNn3b6wZjg3qmO2OsoRX83zgw+sDjfFc8sw7JcW2noqg9WfjNSBmqnM0bOzMEOS5v3L5iMfQ4ZKhUb6IE4+pwiVDp+cieHC5NNSNQ6nE8+bEsyonevUDGz3xm9MLfjLeAPBm3OCCkW6LoggsjM4yzxat01q1q8Q4VSLRpynEatV5uu1EWzseHjLf6E1TdEK/spXetxx/f6xlA5qy83IVS+arjXCOnNGChsyISDdU6Cpi+5EubwjHsWFyGu8NMaxK3+12oqk841wVr6sYFKaRFlNnXTGu/C+Gn+NLd8XfuPseP/zymTz3oUYrio7essFXR0W0ivlKiSYkshG4jbTybjZjETuNSQSOf6n/sgy/NaLi/8bsSE98uUJUqDZQd05AFEhLMWyjIBcbhyuK5UraaUHz+YO0v7487IS/NBvMWRedSVj16JZWUNSSQMRaNrbipq2QVmNaARnaZ56STVn7Mg/xR8Pr+135jcvvtTauOoaLBFLtGR8bAfvkG97vA6rzpEXjLwfpuva4STbGRSl/MXyVL7m6BiQtSFLd+1UuzFT4rVArVBMxWY6qbpw4Zqu17WlPRvQx04pOe+wb7jdBNq5IqXSdU6hJY5wi5srxcl3RGM9VNTD3lkveXK0K+Kh57Q2+X2Q+pFXts0jvIhsFYHTCVkFUOBDkJjbirxAAxl42/6oKnJsOqHlKe/FZTcTtEvOLzPcaNXoywIpmJAmFpDokmsdUjHN9u4A/UkGWxgrmrS7XRWkJ1wnagNaxiBOnpEQD1OXuwtKuVvJvWqWSgG7rieftib2duJt7PjtLknqea5RK5d5ZlotGrisdqPKF+uh7HlzPdXUR13PgzWZDZQOjr7ibN3y7Ff7g96rX/EJ1zx+ov+A/DP8MAP/Facv51Ub0PvvA+MSYtao9XTOXin1wlXQTkHORMt2i7R1N5QUklqtt+1UHs2W9D2j/cEsp9W3g/wJ8iOxcfz6l9L9XSt0C/wHwPeCHwL+aUrrPr/mzwJ9G8vx/PaX0n/wDP0cnuozOmyvL7FuU14XonAZL9WAITSJ1qZzQlGRjuu7Gghq8zBWzs7jRkrxG5yqmyz177wwht7kICq8TzXZgW02c8p3+0+mG/9/bj/nss1vM3dL2gbAPUkF6RchtCXuRrNiOIl8F0gIMjRyx+/tt0TZsbKA2gZfNgTar7+6qkY+3ByZn8UEXBGeI4n6sdeSiMzrQitr5892ZyoTSGvHBMHkjNh6XhfMDaTZr5ZXvwdgIKVpPqkh1mVFannGpnOyTNu2oc4tRXu9bQcOlNmJtoM6E4OFS42fDearZ5/bMs81FUIDGY3Us5+g81Uyj8LXSkys8DRZzejJIRLTwojNy/FczYtDSep2uDOMHeRa4k8CTgioBTfcepSSIKrW29qaxxplADGsrs3pUtG8lqC+tQT8qXJCKSo/6new45Rbp0rrdtVOhjzyFlIMgctsnxqUP9xvSaPC1pml8QciOTsjWWqcSfKPJrdEY2exGfuH2LSDt0N/onvGFe8ayVagn7cDQJuxWvodXFWBQHuwTd3ipXAU1uwQ6t5MgpOcVKakdRKveNQ9FApquIt4bzqOcoIVuEG0+NvlcVJWnr2amYMs9sThJH3zDl8OON6es05oRpCmposS/aya0ilRaDEV/lIeUnw17Lr4uVR7AR3uB6R+mls8veyr9MSCUgl+o7mlV4OzlB5+HBn2Rcxu2CZu5ZVUVuNkMbKp3TTqr2hMqA96sFVo2gHXuSWvcpKeX8vtF2UZ+ZssD/+uU0h8C/jngX1NK/WHg3wT+05TSHwD+0/z/5H/7k8AfAf4l4P+klDJ/33d+v96v9+v9er/+Gy1Fnm1/BX9+FutnWqGllD4HPs9/PyqlfgX4BPiXgX8+P+0vAP8Z8G/kx//9lNIE/KZS6vvAPwv8td/+QxQKETQF0JvEaxsYLzUx82WaV4bmrSK0CrddkWrxmVi8WBXZ1zIVn3rJ/kbXgNclez5d2pLxlZJ94dhoMWRcKrQfn2/47NNb+u/XJUO9fJzQGyfK50NV2oujUYVDVQSHa2nX6EmjPm845orwvHMMc8Xd0JdWio+a1+ctIWquNwPf3QkwRavEwbWFXwdwTtKyOU0122ZmW8/lPSbfC/LySduyoAC7uHq9tRFVB5Krqc4rAi7Wgm6MNhXljaRl1mYv62/z7btggcUOhR4h0SLSRwAfd498Nlzx6emKvnLvoAdTG4jjqphiH00RpPbb1RJmOtei5rILpQ2J06hkRIarWW1WMCmbrBpCVqIwdSQGxXiqZV63EOeiIjSmtKRBKm0zZ+HjDKaYr6PIUkVVhHzlySI1xpXj9kZ4jc+6C58Pe+7HjsPQlt/7we7Ey+7Iy/bID7X4cj0+9iSbaBqRbVsqljmjc0dnSgtPG5kzK5XYNDPPGpkHTVHEnzGpkPeVkn5gylV5KRCS/LbmIaF9bsd20ir321x5ZxmyZJMgHZ3C5Ou/OotyyLzXTLcw72O5nvCaeTLM7okEj4K0d5g6onN78dnmQmsch6kth7HWnjla7seeN6cNQ+4wGBvoWk9tPdtcIX1v95Z/cvMZl1gX0jXA49zx6rgtlSFIq7oygcvYEKPi7iwI2ylYWjXTaldAIU3jcM9mlE3c7C7rXpRHET7qMv+1OtK3E8FrnNPoXEXve0GlhqBIXZYsGwXI9pWv9+LE/+hLKfU94I8DfwN4mYMdKaXPlVIf5Kd9Avz1Jy/7aX7st77XnwH+DIC5ucGPlsdBLs7bzYVfeP6WyVt+/VN5WxUsdkzUB5ldjS/kNh2vFCFqIqpAwzvrhCw7GJnzLPO2yQo02qQiJSXq9YpxrniYuzLz+NH9DeauKrqSIEjLPg/wvU3ERZfQWope1fK2kaIBJ99/BXo4Z3h73PDmIK2VGLRo3KncQs03f2cdU7BcXIXPm10MYoexgGgWK5LZW1GPCApdUId5w20CBFXQnrr11K1nOlXvzp5qQQ6acSWDzlcCCvHRoP0yX5GNTY0GpxruT9kSpop024mP9gd+biMtse+1b8SPau4wKuLiij6tNg4/Gcx5RdaZSWZXyaZ3ehOqDUXrT66fxLntCI+VEMIPpvyOxd0g5F5mmGT2ZQaxzFkg+irBfK3gOhY9yvG5Rnkt86dt3rCvRRLNz4bwxMwz7TzNZuaDq1NRCjn5hk8frzgcOuJoUc2ihuH51uaBxngm/8RDTifm2ZKSKklATIqja3kDBbbvnSFOFjUa3pgtv24EeatV4uHcFZSsXGspJ4lJEJFvJUmzF42ZwI6RBSkVanB9Bh+pleqw7JfJ8G5LOEP8p5soVA6EUMwkxPynFlD+2lO1Hv1kNvg4tJzn+p024hwtrZHg01SeOSum1JUE+k01l3v72+09v9R8xg/dC340Pivvu6lmnDNMx6Y8NlcVxkaC06DglFu6fyt9yBgsv7B9UygBm2Ym7jRGR55tLrzshL4zBlE7Oc3r+4akuO5GXm5P/KS9Lgndh5sjZ19Lcpmf67pY0NDvl6yvRUBTSm2B/xD4X6WUDuoJT+m3PvXv89jfk06klP488OcBmu99KzFpDveSQfmgaW48N+2F3T7rsu1q/EFTxfTuO3rN5dIwtFOZWdTaS6aWQHWhbIJutnhlJEsvr1ckZRjnivuxY87D3vOxRYNkotlnrf34zLaduMwVdeNIGfo8TqYg9RZ4sh7lO4ZWMucFCUjOso2JImoMIhOVYfAX1/GjrB2ptMwKU9Ao80S70gS8MzzOPWPWnmwqjzERVYsRqjw5YTp5fD7WZS6lTKKqPNPGM1+vgThVYhFTHRV51IXaKXTvSU1g7NZLUQ/igh2VLnqQsY88+/Cef+rmJ3ynkYD2wh7ZbMR5+PW84+2Us2RvOSIzhqVytCfhikUr56eIMOuEsZGq9gU6bXVkni3+oaK+V1SnfHhr2aRjI0hJWGc9OuSguVi9eIiVJj6P9BmCfzYtk2+pHlftvjAa7G5E68RYV+XauXl24hdv39AaVxKhL047Hu83cMqiw/k3HM4tv5aD0CLUG3MS42fD23PPxxtB2H7UPhLQvOm2BQb/6rjFHWrqtxo/tnyZr4e+nUUIN1Kg/KHOEPyLoh6Ah7VqiRZ8p8sxcTtVeHDii5aPjVZrEyO/fLpW+Fbhe1EQWfzMzChSdU/v/Ggh9Bo/WZJXkCu3qWno9iPbbir32penHVNn8VEzuvUasyawqyaeNedVRHi65m/y8zyGjoe5K/YvVgWsjbgmrDqkyKlqesfVZqDNgecwNvz0eI1Ppqi+zN5gdCQhPLNLfnwMFce54TC0ZcYZgmb7/J4/uH9FrUNBVS7fpX3CY2waz6Vdg+FXtd6jHP8RllKqQoLZv5dS+r/nh79USn2Uq7OPgFf58Z8C337y8m8Bn/1O76+tGBnW7aqC/vlhz0PdrfyTNonyflRFTw6gujN413De1EV+6FlzYb8dOAC7zcjtJvukectD2zFc6tUtVwM6EbwuVRBAt5kYP0pMThc17UUu6zg0mb+2SJNLiyc0qpBZ8eLIHG6dDMQXQdrBMo2GuQ1yoy/HOORW2CTV6LKSlaC2mGiycxgNyWuS03i7CtqmJECI+irL9mwHjI5cphrvDClkOaoqUJlAtxsZ8+sXIea5sejJlPai8oJeVDZBRnMpE4naCNfm6Y2lBNq8NRN9drwMKHo98b32DS6ZcvNrlStn8+6dGessVeVVIRpTR6JKhCBcJ5AqZgF3aC8cKYDogJRJ+UXWSwKc6yPRaMgOzjbk3+c1bUbIpu3EeVNTPZrSjg29ZtzWxNlQPa5E2uFFTWscnXGMecNNSZH82ppMWc5tCi2fve3kPC8FSxOpryf2m5GucoUn1RnHy+rA1qx+XRdXcTAb8TdzWbUeOMdGzk9SQlUACU6zoX6E5jEVNOi8F0DHwmEEGF8k/DMnwWjSxalBOalkk1odL9xGFXRr/bC2oEGSBbddg5+eoXrQhAwSWXh+MQf4TT2XFt7gKh7HFucN51NbOgnbbipI4GX96uMH/LL/uMiQmfzvIWlq66n3viCjJ2fZtDPP+jMf9YdCZ/HxhslbPj3suWSAToyKtnHs2om+mon5uB+mlodztwKtgKrxxKSYo6W3K03gy9OO2Rv6Zubl9lief+hbfshXuBK/r1GOP9N6VUkp9n8GfiWl9O8++af/GPhT+e9/CviPnjz+J5VSjVLq54A/APzn/2193/fr/Xq/3q/36+u7ftYV2v8Q+J8D/7VS6r/Kj/1vgH8b+ItKqT8N/Bj4VwBSSn9bKfUXgb+DICT/tZRS+Hve9cmyOvLRBw+86GTQPUfDj+9veHO/Iyy29MhsRXvxuVqyw2QUoZM23lLmd2bmW1ePHNqJ62bgOxvhn8SkebXd8unpitcPMvF3QwVe44aKofG83EtmdXN9xxgqzq5e39cK+OT+0jF6vbo6qyQZr4mQSbPKCVChv5aW6eVOWm36orEXRdK2tIik3ZNFeeuEHla+l+/zXGiZbQQt7dRRv5PqxKjFmXcy6Fzp/vzVWyKKH6UbwlYVK/gYFT6I99P1lRzzrvIcx4aTaZmHVrhYyOfq48K2zbOjPn+XLqBsLM7Ougocxoa/dfyYLxrhwm3NRKM9B9/ym+dn3OeW4+BEBBYbSVW2QtkmfMoVmlOYPEyPjSZuIVUBl9tUhUe494xTVcjKiwdaaJ/IOM3iBp2aSDCgc7VsR4UdFP6u5q3OCJAE9qxpHlaH7lBrxk2F8kJzKC4AXvNm3HLbXNhYqeJvuwsPfY93Uu3o5fodpAWooip2Rm4v3LOX2yPbaoX7L3OdIVRFrskF8RELfSJs4ioWkNQKG18q/qy0orNDwdK5NbPw0+Y9xYbHP3f0V4Pw8bxhyG1wfbDimq0TPldoKauv2Iu0eJdqzHfgK5hehPLb6rfC57MXoQC4XSzX0HBseKUSL3Zy7SmVeDh2YvUSVOY2wr4dqU3g6JvS0n113DJkwvTLqyNX7QreiElR6VBEiH3UbKuJm3rg6Bu+OO/ztZcBWkMjvm6IIpFWib5y70D/gXKfm9zN2HQiuHw39/i4qpgMc8U8Wbra0efrISaFr776muT3wpLmv631s0Y5/lX+/nMxgD/x27zmzwF/7nf7GUZHbtpVFtxFI0rWk1kH8E3E3Sb8VtG8NaXl6PtEup35YHvCZ8DBwTf0VgbJrVn72T4pWuPYVjNjVtM+JoU7VzJLSysn5qoaaY2nNSsyrzUOoxKf2iviLKATyIrkIfO4FgmlLkItxPDKhidKHkI2tefM/UGG7tEm/D6/ZnhCXg2LOkhuLdYBP1pBT0ZwZlVbWAb5S68/omRAnXlNy/KzYVKJrhHbDkBULbJT/DEpZpuRZtkzTQVJHqCMC1Gbme12Vf9QKjE5y6+8eclVdwUI2rHWnlfDjlenLeeswBC8QeuIaQJhAbgAelSYOesI5tZTiBB7IWivqL9I0wbMNjJ0NecP5DbRD5U4FnSSHJQvnAS8oN0q65WUcKzaLzXz2Jbj075W1IdYuHjyxmKQGrpUEhGjEm8uG1w0hczbWE/XTxxHi7qscmHJgA6K6kgJvtGKX9/92NHbmeta7oGYFJdYcwoN9+OqvAHgrgJ654pNUQha7HpUwkwLBxJCnxg+hPlKYbMklvJgx9/C5Zs1w7Gl7mfq2qOzpUuqDClAenLlJC2tYHuRFu/iOBEamDcJdTUv+Rz+oqmOQtA3syIsSD+lUQEuTvM2R9p5trj7VojmTWTpp8Uk1+8cbZl1WR2xlcfawE1z4Y/uZZpxZS/82uVDHuautG4vXpRdzr7ms9MV91m/deG3KSX3EwivrLJCfr/4NYnd1hPVtSRq7slI4u7SMXlLX83l8XGoCceKu6w8tKxK/x5En9/HLcefdYX2e76W7OqLiwzAXRZ9rfqZbkEV5sdC0Iy2K6i20Ca67cS+HrmbJft/PW6ZvJWMzYQyWJ+8QJynYDAL0bP2osKhJRM7TLKxDb4SceOoi9Dupppl0/YGnEYPqzWIisjcbLEx2Xq0SXgviMSiSbkJhFEJmjAngkGJa7Xdz4TZFMmn2ANBXJD1Oes6JvEhW5yIdR7M+6Cw+xnd+XIzfXnZkZLiMtZS0SwbedDMl5oY1swxZtTZrp0wOvKwyFHFrDNpV/BGMgnlNCkKcGCRgjIqcTh3XC6W43YNEH018+Vxx+NDD8c8a7KJ6tlAYwPned0ozEVRH9f5jSyFH4VkvwBFlBa5s6tuLBBrgLubjuOrrQSxarEhkZmQnrSYrS6o/Rr0kKvQjEY1s5yXUCvmvTzR7ZK8lxP0Y3EPT4rRWULsGDLBfVPNUiEE9Q5p3F97YqMxoynAC+3BOdEDbI0rldmD6xhizaNbvIEQv79MGdlvxqKyMcyV2MlMZtUUrCJhFwm9xh4MMc8Cm3to7jPhP2/6SRuSNky3Gn07lA3ebTyh0iKafcwVyiAVrb0IcCcuYhlZJ9Pd1ytB/STXqICMxCUbpJoLbQKvuJzy/Go2VA8ym3Q3AXMl30GrxBwtx7nhNOVEKCm6POv6Vv/AP735AQA7LVH7+7zk1STVtgTBim31yPPuVI7l6G1JouaMOE1JEaJiU83sq7EExV/a3fNJc8+n0w2/cvgQgDeXDffHnsfDhqady8wuHCrs0eB0w5slydORq+3I+7Wub3xAS0kVOZtltbVj08zFZFGrhFWBz897vrxUxaQRLTD4z05XbGuJEKe55vHcoXWitp5Lzm5jVOL8m9Y2QggKbaNs8tNKHahtwAeNC6ZA5N+mjRgveg11JOQulZ7EXFHPqiiem0p0Auepwge1wpKMZPrzdVqh/CoJMGU2pMuqV5ga4T5x0TRv8w3yRhPrzAEyUtGAgAC8rtC9J2a5pE/fXrHbjDS1J3jzJKmLpMea9Krm4Sb7TG1nqloEWpVK1L1UAFNUUol6VZCaKshmFWfNNFXFrRkgnirsg8HnY/am3dDVNZexFhWQxaCzFWeCYajhcfFpU+igJOCoVZZLz7IhJlevVVuTOObW4Ye7YwniRrVgE6RUWldyjgTdqIIqABvfJWKl5L9LNadhulFMNwqXOVmxizAZ0cJ8khlrE7nNwXTMG+PJ1QK1dxLMfG61dTcDYa+5qA57XKoVSLkl6aPhbpLe3mFqed6d6K1jl6/pkFtbbSXw9iXrr7tRWnazIS2AjqhITugb9rKiOu2YqE8JF1QBethL7ixcDG77ZKtRCdVICzHmKlOlVZQ41it61A7Qf6HwB/OOKkY00u4045MRgRaHAeAdV3R5H+GXLqjkSgfeDj0P51X8GcBUnm098b32LZ8YQYY+RHnTB9fx48MNIGo0Xe34pf0r/ujuUz6d5PFX446HueN+7AoQzJjA8/7CH9p/wQf1gVOQfeA79Vs+qe7p9cyDk4T5fuykMj5WXM62tHz1pLPSDqv/22+PBv9HWu9Rjl/jFZIqGS7IPKex71p4XNcXKhX58rLDVJF0LXepVomudVgdiw7jcpGq33rWk1r5W4tWm4K69QVKv8DCAaxR2BALsm6eNcYIYTN2Gq/zHEdBOgspeBHunS8VVe2xVRCi5TJvi7Jh+z6Vq1KcpxUh27aXWcjFlMoo5LkVMeso5jnTUlnokOdyURX7+KZzvNicsTpy6psiufR46FFOyNKxym3Tq8iumwhRM85V0RU0rSc4BXolQKugpJ2n5BgvMlfnOduqdDIbA7gcG+baUtWedDXhajmWVSdcwfimofsit1iNHBe3SxBV0cpcNs7qoFm0o2OtmE81h0m4QzZ/34e3W8y9FeHmXKEtGpB6VjyVAEsZ4UoOoABuF3FXGV2ajyNOoy8mt12TKPnna2ffjFgVeJW7C+epFpPImK2AlopSJTbdxOkFuEo2S3MWlOjDpaMyoVinVCbkVnks94DRkU0zc9VI9bAkf6O3jHNFnAz2lGeDF4VKBnsWMnSxinEQKpnL+mUOaoWrVh0UU/20Fwm0UmkWax2ht4mbeCXIRjm+OVCOqggW+3blr6mKgqr0mySizHVcS+XM+xPD1lTI0b/5+lkxMu32UuVsu4lNPfNJ/0ilAr/mhKd657e8mvf89HTNq9cyK0ujITyThOPKDJDR88+rE4++41fUh+X47uqJX9y94ZPmnkqFUvHtzMCP3TN+9fIhPz5JQLw7bjLlIonm7DKkjFmBY9aF0tN1M03RGfuKVuL3NbH6PSvv/Xq/3q/36/36Wi2l1P9OKfV3lVK/rJT6S0qp69/N6775FVrUPA5tqahu2oFvbR54O22Yc6N+DBUjkkjXjchdAdz28lwXDZ9mle5hrphG8Suyzaq6rk3EmIjVkXZBqkVNn5W0l1keSOa7rWcqHYjZrK82gVp73o4bPh2rwpeBNetfyLjqbJg7IWCHYEoLAqS6SvYJ2RoktVsAJQtJ2ysSidhH5sXyZFqJzCqoUln4LhE2ola/u5Ks9Odu7njRnng79TTG0NdZ/LZ1DNeasTHlM5WS4+a8YTytRNDkVXY+WCse0dJilZDKq7Yes58FqZYfixeLRxBi2kRMu2ar47GhOq3mjzFXT7GVlqFbEAYptznDyj/Us4ArQms4nLpiwcKosSeNT5Fg3j0/sU65WsvzQZOwF/H9miWpx+0TqY7o3lNnxYrpXJNGTWySVF71yv2bvMXr1YtvzDOt1AeCWon2w7ElbmQmbJ7Js0c6lNOcX/dMY1WAHl3taDKYaQHc1CaQdGRXC1hpIf66sBVVnGnlzdUPrDNWt1a4vgPVKHynSpq8FEn2ouC1Lei5WCfclcKcNc39cj1KG3gxAy0t4UmAJ9V5RYZWlchqFePZXPyFRo4vimIMa8/5GlBSTc73uYI9aQwQrkIx12ytiFxrFXnjt/wwq4WcQsMcZW6+2EOFpKStHSoeQydVGvCsfg3AR/Uj3x+kwnPR8HHzwE6PXGJDlcvPO7/ll8/f5m/dfcTrg8wYxmMDo86diojqsoC0tiJwPCmSFOxs2+n3BL/xNWk5/mXgz6aUvFLq3wH+LCJ/+Duub3xA80Fz+nK7tuCATSWk0sUz6eJqKhMIScnMbTHHdBVDqNCkMv+6HBs4VqhZ4faqqO0rLdJRoQpFeb+24mZ7cRWP547hYQUz7J+f+eTqkW9vHgC4rUWx4H7q31FoRyVCnbB63UBVlPbmNFWEQ43NIBYTBdEY24Tq1s1dVxGtI36s1haGAVpBAsY8L1Jngx6fgA22y5wnoDeepnWlbRpRvB63PEwd57kurY/b7YWwGfDBcJlyO3WqmAZRwSjKJUj7RAVIW18I5tOpQR9ErikGXY770rZ1fgWgUEmfarpU+RzkREKpdc6U5zkk2TD1nZbjl5MO7TIg4QJmWu/kMAuM3r1pOOd2mR6zNFVST2aU0upSAepJYRdVkUreU1pxCwBELHs225EmO3+72RK2gTr//iXxqq0notgYV9pZQ27Xmk3kcmnwD1kW7LFinDThasIu2pFVRB8r1EkTnOaUEaunJhJeKF5uVyDDHAzDLFSHF92pOC3PITuyhxVhq4JCB7GCiY0qRG7tRRZLJdbHksxDF0RtaWHPChXERX2hQiQlbUTf5dlgDtZiJaPY/TTSvV4dBqYby3iriUattBOtSVaSumWWKCr+kCqZlcaQr+kKUh/oby/F3Xr0ltFbPjXXDKHizShBZgqWSotgwPMbod5UOvLx9pGXzYGPqwd+oRLth13Oiv5w/QU/aqWN+MP5OQFNqx2tdpyjnNBfH17yX3z5Hd683q3w3kQGGCn81tNv5X4bbSRQgxLLGRC6xeR+D7bwr0FASyn9v5/8718H/me/m9d94wMaC5cmbxTnc8v3eU6MWgAYiLrFvhtpTKCtHaeLXHCXc8vdqceYyPkxT5tPdt30n8xHTN6gxktdVCbabsYHzTBVzF/0dK9XTcBDFJfaRdft6FumYJm8lRb2AjpQIvvkJ1UQbElRrFv0qNfKLULcCwhkSY9TVBl+Lf5aOixw/kTVOerGc8kmo0ufPmqIbSjqHboOGBOJUfE2a0TeHTfY/JunyZYq5sX2zCebB2LS/OZBhHJfTVLRyoFK7wTrVD+RoUL+noxk036yHOPaFQ+TgVmXYL25HlAqcTk3MnfIO6m2CdUGfFJEm2c/Z4U9yVwwGQoSTc/Qvk10d6tgses1Zob6qGjvVuTgsuZrcLk0ibUYfpqTSE0VfM5MqVQW6axkNZOpOOuEyxVaVXv6zciunYQPmX+vC7p4vC2zmH07MQVPaz1d7fjyKBtm/VoTa4X3GrckWJOR2Z4T26Himu0Vx66jtqFUaJOzXC4Nl7HmMDZMeeZ8OTaks0UpcDm5sTupQuebRDJiiQPQvUmYcbWIkQ/LII8mEdo1oNmzKvNg94SHlqwcz0WxpzyuwIyR6pTfIIoRqIqWWKmSMIjZpSbWqXAdAeZ9EjFvt4KP7IuBbT+JQ3QOCpOr2LYTU7C8GnZF/WP0FqNsnmlmq5l65I/vf8Ifaj/lA3PkNlt69ypxjJopGa61ROvv1W84xJZaBcZY8cpJyf4rhw95+2aHOlTF94xMX1ARmTEuc7jNyFgJ6Ezn+2Vylvn3IqB9deu5UupvPvn/P59lCf+brv8FYif2D1xf66PxVSylE5tnl3ecgJ2zOGfKYzZz1W6bMz9RNwxTBiB4yaBHp6WyAGjDCqJ4Ups3jYBHHmdTAlpqFT4p5rFCz6qYOgIopzmNTblpau05+kZ8vVqHe9LKDEHjjIgDl8+NCBCliQX9qB3SQhs1ZB5bdZFAqIMQgBcDUVEsz1m3WaD8kWQzKKOO2NzCUzoSvPyuEpgimE4svsOpKu7HVkdedCc64wpaTqmErlfdy+JDtxzTqJgecyU2afEFi+B1EvFX5DcVd96MEHy5P3LTXPiBecbjY5+DmlRXaIHDx9xO9cqIB5mWTXfZoM0MvIX6wT8hlFpCo1EeqjM0xwz1noUfNR4N000G6FyJS4M9Z3RmBigslUG0KyG7fZ0Ro48t43M5tvuXJ276oWxcTdEEbBm95TC3BdBhdGQaG8ZcTRVjyyTnU4+KlEnh0kLN4BEjrs8Aqve03fwOsg+EyO0vViqypVi4WFRSsPPEjJicR/md7ipmikW+1hXokFBpFTJOVirXsEh9PqFMLYjGBUASFkdxELTqks9lF/l5b3DbLCDgEyqIqr8dI7FakJKaWGl8t+pvgrR8UyWJ1PIZXSsGrIdLW4j0SiUmI4FeZSI0CGVk34x8b3tXdB81iZfVI9+x9xxSw0+8BKmdHvmhe85vTh9wyb3QkKQ66/XMMbT8cJBW5uPUoqtIqGPhFBKla0FCAC35PG2ambZ24vU3rVJoT41bv4ql+Epbjm9SSv/0b/tZSv0VxAvzt65/K6X0H+Xn/FuIiMa/97v5wG98QHu/3q/36/16v36XK6X/1lCOKaV/4Xf6d6XUnwL+J8CfSOl396W++QFNpez1tGakIqarMLkNU1kBZPhoOM91qdzqxtPWTtyec4vow5sjH28fObmGHz9ccz5lsvSlEYUADVXO7NrKCzl11sQ2EfaLoi3SUguaXSWtiu+2kv1t64m4U2V2NM1WWqIv1yz+eOqEsB2BJwoiJFU8xhZH5OZ+zXZDswrHRqSlp3Uq7jSqDSStUU3ANr7w6fyxQY1a2jVPW6Eh91yjKj5ph2PPD8wzahN4e8zuwF5TNZ4P9ida67jrMufmcUNwGm1ToTqgMpl2UMTalFaZOWvsIECVsZcfcZ5rbpoLfe042Ugcc6a9wJ2NtB4Boo2MxhZ4fcyKHNqvLtFmkufai0bvtBwrBdrlNtUQcMZSXdZ7y4yichIamG5TOb7VQeD80QjQYXmuvchMyPd5TuUsLgoBWqtEl7lhm3pmCoYQNTZLHblguIw181CJS0ImFIfFnsWvgBmV515ul0g7T7uT9315daTP/l+LbYkPGlt73CzC2jp7vWETiUS/G0V1H/AbsUhKXRAy+AKZ76Vy8x1FFowIxqnCFSut26UCfFIOrO7cCT2xztAszDsIrS4qJGYCe5aZZ/sYqU75fk2ReSvAlOKC4GSul6pE0CJUDnJLHM4t86UuHQpjE5exJniBzV/axW3C8UHvqLUvHZUpWj6bb9BE7sKWN06QGr2e+Wy65genZ2VG76OmqxyaRGSd0R/HBm0CacsqaB4VvpEvqLeu2Mf8VqoRSOX499CHviFLKfUvISCQ/1FK6fK7fd03P6AlJRpyi1h4LRJHKWgBKiC8MZ8laxaFbBAtvE0zF0V9gJ/fveW73VvGWOGj5oe5XeEmS3QWXYXSBjheVj03do56aeHlIHu9GfiwEZ+ql9Ujb+tNUVZfyLTnS4MCtvu5KBLcNTOfvb2S1mYlahXyxkZU0XVC5+8ValFP0F4kn4qiRyOK9G6y682UgCph6yDKKZcs+XQymCmbc5bNSqEfDWEXsPvVQt7YwOQsx0v7DlijqT1GR1rj+TCrhWuVeDgJsdXu80aTFLNuBejypE2lkHmXDhQQzJuHLcNcEbMTgF6AMG1+6WhJuWVpOo9qAv5iMY+CGIMsvxUSyWpSBlTokLCjOBxES2lpLStaipKFtIcSqVPZEDQHyg5Q+fX5kkpaNuJkKd5e49uOz4eKpnPUT6xBlEo0JnDTrtfecWzw3kgwuxjMsJKo9dKmKhBQ+dy0d2yuRq4ySXtbi66jT7pcYz5q2tYRnJGAltvddj+RkqBUlzln3HhMF6gbx/DQknRWk+nkiyzzKpDfmBTYCepDKsfM7RSLpUx1WGeZoRUO4NOZZbKCevSwXrtajquZFdpr7BDLuVBRjsHiAqBdtqAJitQFtplztmsnHqMmNqunmjFRQDqTQenEkIPqqCu+H0RgYfFZc8Hwetjy8eYDpmC5yzqivZ3xyXCY2pKUDkNdHCtSogB3vNdYG9n2E363zopTUmiV2LVTUW1xwRDy4wuIRatUeKxf5fqaxMj/IwKH+su5GPnrKaX/5T/oRd/4gKYyXFdnGG+sI2rvpHedN2znNKONNJVn200l60lJ0ViPVbE4O3//8JxPL1e02R+ta7IRpzdEJ1I7I1k9xGsZ7FaRunNF9aK2gb5yfNQfiinlb4wf8HrecvE1g6/YNfJcfZ04Dg0u6mLO+UvXX9Jax9vLhskbXPYSmy4ihowCv5Pnhk6RtgFmjX00QjwFUhfQJhFGW6SvAOJOLDLCrMsxM2OexVhWB+iToj4oJq+IO1cAIsZEZmeZLlVR0+g3E03lCVEzR1MEWjf1zLmqRWUlv17ryDGB7yqhGOTPi1lfUnlKkAuHmuNdQ6ojZuPfUYewdUD1npSfW9fyuzy2uGSDKFFEC24r5psgaD07RkJlUDG9s8Fql+dCbZ6h7VeSb3VSBYyQNMxXkdglTCYlL0HMXhJ1BlPoYPCDZnomajNfPhny9+3EB71izlXB7E224kEsWBbgBAKe0J6VOA8kHalaz3U/FFHd+7Gjzdn+shleTo0EASdJhM2ai1ebARc056Ghzsg60820WZzgldf4XJn7SWcx71Sq6mASsRFQivKqBPbxufj4NW80dXZCSVYqfj2nd0xgg1kVHxclGO3XWWWsYLzOczyjxINtn4pWZrIyu05VRNmIzwLUw1zRVI5dN75T+ZxMQwhaZsVL7uY0x7sNR5Woe7nfrQ1ZJ7biMLe8Pi9w2g27ZqYyYRVaGKwYwmaAWqjXe6WtHft2KmCgxb36trtw1QxFcPswNlxG6QJtWgloT0n/X+n6GgS0lNIv/sO87hsf0FLKLbelrXTRBF2JmsAyiG0TXTNz2w80xvOQRVsvc8XoLS4YjpfcAhykhWh7z83V+Z3gR0Lcm/OFbDPiTJtI1zi6zHexOnLTXNjYideztCru547jLJ/RWcc+tyLp4Ef6BqNSMRn9bnvHd9s7PpuueTNvmHML4+wavjjuGKeKWeXB8WAkKDQB/0Eouo9ERRgsajClPakieCzeyQbU3OUqZobxeSRuvQRMgLNBT5JhD/cN04JUXNpIGmxuc3W1I0TF3aXjbGtClzd4lahMYE6iSCHHUTLY7e2J2dvS6oqzJrRGxHE3601sLproFcGrUrEkA27v0XUoav3DsQGvUYNsVAvnrD4k7EhGzcljeg7oWmOad+9s3xpCp8WIMoNe55tE6KMoYhw1mY5E6CD0EZpIWpT9a3A72ZgXJQxiBk+oRIqqdA3SaJjamr/jqoLGXTZjvBigLucN1vbdUkFHA2Eb2fUTH24OhQN5dC1GCV/yw+z+8GnQ4skVBEyzJCdLUmV04qqV6/GqHnicO05zLQr2OWkJfRKUZ1TCI1y+V51wVxEV9SoLtpNkw00N9XGt0LQFnKI6rxWWCmphSpTKIbSLA7YEsEUXEyWoSb+L+CwdNztF3Hls7wleMz5KVJ1by2Y7UttQzDkbI15k41QxO11cB0wV8U6Delek2weR1NMqlfb8kAEbbeXL66veEZMqoKWl2l0Sh+mJMPHsDbO3nGzNs/ZcUNCVDrxWcJmqYl7q/G9RX3m//jEIaE6jD5b6sGTJEI9aZHLyxlhtZq67scyzFhv706VhctKCmfN8hkOFGQUifbCBPmdLbTdDJxvyIq+ToogHKy0Cvcfczpyd5e25F2Jk3mhOOfvadyMf1YdiGTKECgWFJwdw73u+177heXVkimvL4Uu357/U3+bH9zfM2RqkejCoCPPzwOaDc+nJPzxs0EeLPavS9jGjtNfcTuN2sXC1CslaU2Zo0S4yR4mkUiH5SvIgpFCf257HS4t3Bn+xHBU8bnLgbh0+iCp8yJu2rQK7fuCj3YG7oeduIQ/3ukgfpW1u3ZokdASvMGdTdAXdLsKs4dFSn9bNrijZT1KZyW+T76xiQs8LmjEAFa6XecyyYaqQpZmsKvD00Ej2H7ITdlhU4tsVhRi2WWXeaGytCJNayceVoBAJGh90aZGqoOBgGV/vV6uZ6wB1xBwN9cMaFH0rgSM0EHLrVm9E4b2pPFfVyMvc2gY4+A6XdEmQruqBV5cdx7EhJFXkxoyKuGjY1HNxitAqoUmcxoZwqIWbh1SG2okljFqCURS+YlLyGxeUan1nSPeG+lFRnVJ5rr9QWpFFg7FV+E3+jcup9Nn1PGXYf36uDhnmr1OZlZnas+9mmYMPbZnNaZ3w3nBKTREIv6oHtrXhWLX4yhQqzrafONIRnBaOKBADTN7zOHVCt3lSWVdG5Ie7LNCwtHsXx+wlsU3AZRJt2Cp/VkxCs3m8dHxpPb90Jfy2l82BWr/g+/NzDvcZ7Xlf/Z5YvXxNWo7/UOsbH9Der/fr/Xq/3q/f5Uo8Gcr//lvf+IAmNhOqzF3sCDGbW+osQnyzu4hE1tyJHNVyPpNC60RXO8astOBtIlxFVBNws8XltkFXO/btSKUDP3orhOLxocacNW4T8b1dOVyjBpO4bJqi0sFgUFvPtp2ISfGYyc6Pk3gjTd5yGIWy8XfVS350dcu3u3v2dsRl4s+Phxvux45xqNFZjLi0pUzik6tHNnl+9bcuDWlqxGomdzfro8wbk1HMzxJzn4ftky6STIujY9hGhg3yeBVXMAJSFRMh5RncOBiICnsUlRCfHz+0ASoBpyzvq3QiJqmS37mtolQ1sRF1E5BqwVUGPRrJzpfvkBR6VNQPmirPaPwmK58kAYJUx9wqNjDvFGCwl6W0EBWM0MJ8RfEYM/OiiPGkPekgJVGCj620H+UfABuxnSdkcnfyFSHzARfFlgVJmQYjyilPDDXrBxFMXsjH/nZBW0J7l0rl6LeJ0EZSE9G5MtluR8ap4uHUcb/t+Kh9BASFdwoNMUs5AeyqCb1J3LaWo2u4ZGL1w9jhgsboVMShF8mscagxJ039uJSa8kcbiEvVoETlXs8yP1TlHlwBSss5q8YkSMgo1f9SJQgHTZRdlrmnmXJlrbLix9IcyBJkRZEGCCoxWcs0VKiLKdexUkmEnlUqldQYKjZ2LhXVgnbeNjNd7TgMbZmLWRO56kTM+fVxIy1b4ObmxFUzcnY1Ns+8t9kaauG6VvlAfDnuCtjjqfyW0ZHBVVxcxcOce9s1jMEyXGrMWzk/zZ0uaM73S9Y3PqAlA/HFzLjNrYImX+gfTvzcy7eAzKwOUytKAXUqxpSx11R5+Lv0u9POUTeOebaEx5pTHopfmkDYKz7eH6jzxTllF+KkNFGbddOOShTtnypkBEXyWqxsdCxkWhBY9Xmoccfc54pwGho+3V7xrLtQZ+G7V5cd98eecKyw85MIk+cru3rkF7ZvAHhzs+WnrzvS0RQtPN8J4g/yrDHPY0TOSGxDynGtxUPLVgHvTDk+C81hPNdwWCb3q+eZnp4o3Z8tfhvFsDQfCxcr7ifL8Sw9Jr/MHQYjraQulBlPyLMEe9bvEGntICAWPa/ggXmfSDczabCALqoVaoZQCdx+3sv71VBI1cmsiEad21wgAQXATJrQSivS96KNCZCy8apSiXTO5PkHUX4PXSq+dGgh/NqTkQ07P2xmaQGTVgmy7nagsoHT4Qp/rwsdILRRgBhVKudhQeMFb3icO75/fgHAyTU8jB0JeNYJgtKqULQKR295OElLSymZp7mwzu/cbFEq4SdDc36SMHTgrlImcudrxCRJmAZV3A7kOCpBogZKq1oHsaDRIREaXZSg3FYxX+fZ4NJanBU6+6ERV1pEaCSgKaepFo3IYPF1i6rEWmmJfn6yYomTjXJBtFfbeuSjzYG+ciWw99XMB92ReWeLy3drHLtq4sthJ4ExX7/fvbrnWXPhx6ebohW7q0d6O2NU4qoaMPkkn0PNg+kIURVgilaJm+bCyz5wP/bFb/H1uOU4NdIq3WakpVPvJJJf2fr9W6B98wOaspHnLw7FlXfYNBgb+fj2QGMkEHx+3HEZG7SOhKjfQT05bxhiVeZiYTJMCeJkMCeDyndvrC2PSeSJFsReaoOgDOvM31ru0iAyVMGuw+DURpSJnMaGV3pXNqTD2HK+NLhzhXnMdixeMaiOebbcVZuiHTk5y3RoqO5MkRYyk2ww6mL4jbvn5fO0SqQm4je6zIOiVaL0oATFuGTEpEWgeD2uySSB21sJMO0CeDGhDK0XwMCyaSUtckkLf8qOgNZ4xaqUoCD2ARcywnG5YbuAbkQHcRxlo/GHGnM0NPfQvYllfuU2Ul2FWgSBAcLzmd3VwEl1xMaWQNccREZpeKYLNywahR0j1TkCmsykQCXhW4UaslUWzYNUSnqG6qxw26yocaVIVcQNlvptDpQHmQfFOhULHExCOYsKYIZVVUS7RGgVbg8+B8nbfuTj7SN/1xsOTb96ZfWeqgps+7HMvxZU4+wt57nm7ixCueehRuvErp9KItTbmTdjxRfHHYdTV4A0S3CMURXDVn+xAq4Jy7GW7+t3CXcdSoAGkWUT7UfwzRP6QpWINqMZcwdhulbMcXEvXyvg6Qb8rUfVgblZKmhDfVAyD39iHxPrRLQZqr9Uc066MXERwF6QoeN67/nltyWNz/f/xs6Y/CVumwt/cPOKrRn5tYt0SaZg+ah9RJP4aX9VguJVPbKxE431JTncVRO31ZmA5uwbpkUU3Qv1Z/aWY056YjDcbTquuzE/J3c5nMXqSNdPLJaz3je/JwHt/Qzta7yMEVmrRbtPqVWl+gevRYLGfbZBeQg3nqmt0blVUOUbehxq4ilLOz0aSJV0lIbV0DHWwnt6fdyw7+Vi7K5HBtoCpV8g6NpLGy9Eu8oXeUX0ikPYcDq2pfVkTJTWkKK0F0RGSBG9ZnKaKUtJKRPBCwG5KhtjRgsPmoe7Db+cdSrducI+WIGkL4rpvfDVzJQD4ZN2hjHCEXpqxBkullEl2m4ubdrHc8fwpheoer7ZYi36dPakJWN363eLlfywZQPzXUL3HmMjfrIou5LclUrMs8W/kTZM/6kRgMclkZRaFdp9wlmF367ZrK4i01SRRlNIvCBgkGh1kWACqQBiJVVcNE/krEJ+nXoKG5fgqWewp9VYVQWFdmKYWlT8M+UgaVAZbWrrgJs1JKneXEbnJa0EuNSvMPjDpaWrHNtuov3EFWd0awLPugsfdQdeZBx8QPOT9oafnq45z1Uxog3OUG9mfuHmDf+9qx8BUKnAX/W/yPHUEUZbWrpV7fn/t/fnwZZl2Xkf9lt7n+lOb8ihqqurG2gMTRBDoEGK4mjTlEhRpKEQGDZFNzWYsilTclDiEIqwQDMoUmZQRlgOhkwPUkA0DdAiCUMwZYKUBQiACBKSxQEgKaAxNNHoobqqqyqn994dz7AH/7H22edmo3pAI6syK/uuiBeZ77x7z93nnH332mutb31fXToOXZUjZbPR5vRQRfpb/hdtWnLjPeQ2C9ON/ju1YJQRQ0Jpppf3FzAstAnatlOLQ38eklI6+MR36GeGuNXnLXHij3SLQFx6fGfo4/RdGy48snAYE3OPnWRaNh4T/50XPX0oOLgybypBNc/eW15xVakH37qalW0ZastXXFznJvXNUHPVzXl0mOcess1QK1VWvWYTGz5+oxvLm5TCNEfcq8ELu03DftdQVi6nPUGRk1Xh6cceU+FIpeJk8GXg0E52spOd7GS/BHsXC3w+9w5NiLhochoQtNdjvV0SrlI+/L7BeDiYAu+E0IypNlXvDdsSuxnTfelPFoazMIEAKmVrH/qCJkGnl5c3vOIN/bp+LI6PRneuxc5MzaIdhNIoVVFZ4BOZrDnvmM87htLTplRO7IwCDkqvWmBmYjrYGxgWNjfYmiL1+DigswwJhGK2FnvQaCxD0BvVUZPUvDs2DGcaoV6yTpvtIW4NwyBsD0WOKGNvKK8s5VqmdN/ss5gcRsYHIUeeY70unDkWSUrFO/MY+ephUyObgurK5jGITzD6ZtLLiqJNvMOlx65SPdQJ/b5OJMfTcwSlUKrWkmsxbi64uWjkZ7Q5FyDGSLmJGD/1SQ0rjSxMpRHHCDZRaqZEXjySzxz1usXEzjKkdJfW8KIqcgOIRrWmE2w7pqgWvHIomS167ix3efwhCpVxXJR7vqLWuvDKtnxF/ZCPN3f56OZFXkt9Uq0pmVUD759d8XX16wDcd2fsXYWYQLPqsh5gYYMSIg+BmAAzs/uqL9afwXAZsyJDbjcoAia1R3gvxI2haCPFFbhUb+su9J7Ydppj2oQekF77Q8bMRyw1VX/cZB9ThOzrlF4cVWViek0Ev0h1VgOzO3sWTY81IffWATzczdnuaw4phX1tG1blDBcN675mWek8vKgO3C207aFNofkQLRvf4ILhojowLyb2jk3f0Hub238Gbwlz4cV6zcGXvPlIiYzdrqRcdcyaIUvCLBctMQq7Q0WMKr0EGi0vqp4ilUUAri7tEycnhlPK8Zk2HwwPtouMIqoKr7Lyg8EcNRSrZpPolycBPQZvNI1nVSIEIMzQRdhGynOdjABdWypHZNJUA7is91wvZlw5i28t0k10S7ZTLaixHyrY1Iw7QDAT44P3BisRJ1MNzh4MHhgAc9Zl5gDnjXKL1hGfwFEuNaQqmi7mlNCY2rH91J8VSk05jnWIMZ0UKrITyn0vQdFqKqw2SayEUl8b6uk9pjtiXaimWop41RJzS5/Tk1KFxI8q2CLkhtVhXWKvC+xhSi26RsdftBECuGZE/amTKS9aVgtN/95s5vidpsuMU7ABgK8MRQu2jYyDUHBBomE6ahImCGUfKLrIMDaHD+T+qmihHsEifaRfKB/k6PyY6f0RL5m+KxqVO4nl2JisLx05Esc0JSifpWsK7KqltD6DFnpXcGXm7GZ1rv+uzIFGBlaLAx6TU2KFDdSF40G/5GfblwH4dHuLdddwsTpQWZ8X4hAVVDIMisAcrzeTFOwMftxE1AEKpU0bqaTiCoa9ITw0lA88zdWI0rS0txQoMioXxSKmhnzB1xEZ2yuNfl6MaFM8E3ONr0d2FH1puRYF4Bz1HIaZAnPOmpaX5mvaxLryxu6MfVvh2jIDkjY0fMJb6tJRWp97Qb9qdp9vqF/nDbfKjB4b19CFgpB2e1+10I3EnXLDx8oXgNtsj7gcXbTsQ8XDdpHZVaQMnC9bqsKxTT2q57OW2jraWcmur7haay7cDZbDoDRvY426rof8/TiZ2nPv0EIQDm2ZgTsXs5ay6TjMSvpavzWh0sXbLzxmOWBT7awogjZV95awmNgtvDcUNnD7YpubMtcS8ZUhBMPVfpY/vyoci0XLultM0digu8jxSwlJ2HAeNUoqY3Zo4VCwNY3SAh0mbS/xBh+EzsB1GPPvlvioojmC8/Z3PLFRp2zKiTlDvCoBE47g7gJEdbL2oJEK6LFYxKRZlXbfRvJWTjwZQBIt9OcKIx/Vm4udKJdkx2OLjW/AnakSdkw1mjgoJNwYZc8Y6cns2lKujdajcm0OolcQR5hP9Se3iPilx+8rHo3I0EGZREyv0UF/NqIUheYhiIsZnWeG1ETdMEkFpesMpeCj1t5A71U0iRrMTNGsr4T2lnIbjhp00pMj4vGzMrtGshHMEyrBNwG3mBZscaIk0ah8yUhy2zmL8zM+Ki/k83xls2BpWxrRDde4EB/6ks2+5mo34yP1S/o3bzAmcGe+JyCZecYKDM7ghyMmi3NFC7p5wO4NZSIscAshzJWvcKw9WxvYn6kQZ/NIqJIMT30DvrT0F9PmpNganW8ZCUx+bhFt58i0awdtNSkO+tzG49WNUmbFo1UtGsPQFxQSeKm54XrQB/rxq9tK8jwYpDrK3gwF1gQWVc9ZpbvN95bXLMTRxhKfCs6d1xYHFyxn1SFHxh+o7tOIY2YHHnQ6IV/fn7Hpa17ZXeKiYZ74JOf1wK3ZnpuuyfW6wgTOKnW+D7tFBrP1fcH1dqYUe0fN4U+cnDi1X7xb7bl3aCIQE5s5wPuW16zKFiMv8umRWLhNaKE6cHZ24OXzm/z+dddwJbMcdS2bjsIEllXHvOjZDROZcWk9h2Gipmmdfjms0XRk3u2LRlDRSgYM+FoBAKEOmNZQJGh76AvcIFAFZOTIm2lqKsw9YlWJGoBdwex1y+xexC1SUf1SkMYpW8kw6aRJ6tsq26iM/IDxGpGUGzJ34zi2UEViHadoIUHj3TKkNGXSX9toGtMtpustdgnUYvXYyGMYSl0IZRFzKtPsLEGgOT8oHPowRbXiEuT9iIlCrCIH+/MpXRcTam7LgCUAAFirSURBVNKuy/xZY1ozlqqFNjpmGPvQJkRlfiazxDqSxUAV4TiqNkNKeSW0ncTJoWkaNF1zynKVm6g9bVHyWJUTMqE/nVBdH4EZVlY3OEcpX0EdfjcvMhdje1A+zN7ZDHD4THXOvOgpjOe6n3OdNlm7ewvKa0v0cD0y5S891e2WWem0ZSSBGVxQkdHgTF443TxtbsY2jNFZO8nRf9elCC9oary/CBzuHE2odLvHeQgTTyNI7jHT+xMJzmBqT5inNGJqBdDnOm0GbNrsBKb+y1BFjA2c1wfmtqdOHvRyfmC9meM7iCntG4NBCuX8bN0E0f/McMF/G4XXh8ush+aiofUlhQRuVXtWRp3fhdnzdfVnKMXxC2mD8aBdcH+3wAfDsup4/+U1oM6r8wW9s3lzsu0rZsXAC/UWU0fuLxSE0pbaM9cNRW6hKEv/xB2aAHKqoT3bJkdIISORs6JVfru7OunvVUvdxZnIvO4z8fBVN2fbVXg/hfUikfcs1pyXLTdDk3tN6sIxKwZilMwN1xQDnS942C5gMHkhHqOw8sZgd+M3O9WchCRXnxaKGInW4OuQKZ+GRneVI1dcTOmgcq1kr+VhmpDVI0NnNR9frie4tXHqEEwPTTcuzqrELSHiZpJFMN25h9qrmnQ/Uv8IYiEuvJK+bseeMF1M3DxmuQ8WSsuEiRRbQ5VYmMSRxzM6ShWljEpm7E2mBYxG75tbTUKQxU6RlKHQtTJHPUGvpdxKTgEiWrsZzhWmX2wmNGKY9iT6WXaMNAPhzEFKFYd1gW8EiREZsdNRIfa2U+dWbSfGYF9afY7jc7KCBG0QNikCL7fq/Nw85jQ0QHGIFHt1+InuE9B72+5KbuZTk28IQtgXtBEOs0n88cFhwb4v6V1BP/bzORUjHdGveg8sfVXxhjvHWE+VIhbnjPb6eZnQm7o3077JOjKk2me0EdOoiOshNRmHTQmNVz7HBYxwWtPr/Sq3MWcB/EyvbWzyH1PmodSWkzCYVF9Lxyvoq0RUPOrE1hCO5I3GeWNtoLGTwCaktpXIJJoLuE7prhZ1T124nE58rbvkXn/GEC0ufdhNN+Oma3jv8oZvmH+GX1G9CUAjDm8Mc9PlzcV+qHDe4qOjMj7X2/pgOTitac7QNaeynmXRcVYcmNmerzl/mF/b+4Lrbpah/D6YvHk+mdqXhUM72clOdrKTfZH2Lu4EeO4dWowcFYng/mGpqEfj+PrLNwD4ilXN6/szdn2Flci9vW6Jrw8NPumkjY3VbV/iguXgS+7tVzxMrAojRVaMkilvaqspnBAEioBPNR6ZO2Xwdk2umSBoyqb2+DBFaLbTtKR3glmMJLeaOw/OIPuCMtEPze5NyLyxNlFfgXFKOVXsJ8n7Ebxh+5hRYuKVZmhYau1nlKDBROjsY6n1WEZCE5EiKIgm1T7cQu93LKNGN6RNsKCEwUHoLtKufB4J5wPms+pIsVPJEkClb4AhURpRh5zjH2wkWKu79CJOuX9J9SZHJvANKYITB0UnmSlEG7A1OhrrNr7RWmZYOU11pQgtmoSuCzJFN0FrOUWn9z3YMQKO1Bu9t+2lHusuJsTkONZqo8/FjHIwR/VBcdpj5+sEdpmnSNdGejch3JpZz761hF3JTZNCm4WGkN1QsL+ZZSaLOPN0t2SqR6Z7gwF/sHhX4pd6c8pKe/+kiEoOAJAEUmOpzeEm9awJWueyJuTMgQxCrCRFsRqZgaZoy32Ew1GPXieU+4gZtFG9Z0pl2lab/8fnI14SylGRrSOAJhQx9QgejbdQiZbaeDa+4ZXDJQCP9jOlorMTUIreMJQFi7Ln7mxLmSbPwZd8pj/nYbtg0+m8XO8ajIl86M5r/BPNJ7mbmLE/PpzxyeEObSgzQGeZRFtL62mKgZdn1wDsfJ31D283ilr9xtXrfG3zJqU4rv2CpdX3/sL+Duu+QSTmDNDVfkbbvR16aKeU45dkIvIXUIntezHGb0rHbgH/L+ADwCeB3xNjvEp/+2PA70cFKv5QjPEHv+CHRGFYVzn8fwO46Ro+cP6I9zXXANTGURtHQLQQm9BJq6bDB/MYk3ZhA5VNr93O2d/XHLc0nngm6mjSJOuGgrp01LUyOQypZicmUpae/YXlkOBcEhNSLAqUMdMEjUVaaW0mGpFO0y82pREbzUowexCwfUxQ+DH1YpRqy2pqbFxtBgMYXSRsl2D/PURj6c+0KTkzUeyt1vTkCPTQROIi1QaTo4JUXxr031EtmghhWyJOiDYynOthd+YxRSBsS00fkmpSG0svNXbhKOe6UIRGGRzERPptaiSP2uAbqnTvRgTnwWB2ouCWVL8KRaqnDEK5VYQkgGtS/cpPigG+jvjzSXLEdNPYxOm5RlYSiQro6X26xy7ds0STpU3qeqy/FPrzQKxiTp8Ve0Oxj9CoQ7Np0feVMFxMDdygDtmde2ylTeKjQysKj515gguZdm2sg61mHcNgM02YrSJOwLkSO4okz5QfM0aIIbBYat7v7nJHbR3bvuaNBDUf9qXuUMpAUU81HNcVhE7YuCPFAFCYbdBrK1I6Ufy4wZg2MbNHgdm9AdN79u9tssP3M8F5ySwzeh8iEpOszNH9kaBAGs4cRUqbBi8Y0daGR8OCn79WCrBH98+gNcjSZUYUN0wM+60vWCcIpguKEt20NbskZ+Sd5eJ8x+1yxy5WPOx1HfiMu+S+WxHixDh0p9lSGU9hPC8313xNowz6rw8XPOgWSndVaa7562ev8TXlfd7wZ2z8LPO0vra74Go/46zpJlqzYB4rhzwRO4FCfln2Xagy6V88OvbtwI/EGL9DRL49/f7viMg3AB8GvhF4L/DDIvIrYoyez2cB7NZm2P1QWYxEFdJLOf2Dr6itY1W0FBIgLXZX/YyH7YJZOWSarMp6Cgncb5ccdvVUk6o8s2rAmjBRP0XBeUthAg6TUYHBG6RyVPOe/lhPrTfIpiBWQSXuAYfqlZleiGly271QP1LwRZFIXWFC2ckRAMUMEaJMcPHDWPPQKMPXE6tIsQ/MHAzLArcQYpLMKXa6IPkayEwhCuBgr+Mba1LlNnHrBTK7ivSSSWxDSZalQSJhV2b0pg5MEZPRWOLMYcfXpl2jdxazScjHxBHoZwGzGKhnQ3qec41sjyDmvlE4uO2UVSTv9oEoURfXY003Lwqv7myWHioO5JpdZlcpx/pdcmRHIpTj/Sj2qea3VyRmKENezN3SYFLEEcopMvd1EsKcBeoHU/0LFNwTnWT2m95E7NyxOOtyf9qq7OiDxQeDvQgZdGBNYNdVbO0Mn/rbpPGUlWNW99xe7HlprqCoi1KjvJ2rqVNUcNM2WY3ctUXWFCxulHXGNxHKEako0GoE7RYwZCeuz8AnlW/QeVucKZ+lGSKj2s3gFfjhZ1P7g02bEl8p8GbUgHNLj73oOV9NKt/X1wseXS/4ueIFVlXH1SbxVO40ayEScw9YVbvsLG76GdcHjXY7Z6kLz6qZetgGb3n/2Q1L2/FT7fv5ZKvsH6V4zosDRgKrVBA8lCW18by3uebrm8/knrZNaChE63s7p5Hfx9r3YIl8vL/Lpw53eHV/AcC9zTIB07os5XM+P+Q66snUnqpDizH+bRH5wGcd/jbgt6T/fzfwo8C/k45/T4yxAz4hIh8Dfi3w333eDxGd8EWtk3bR9MxKFdwbocwX5R4jkS4UuGgwaRXcu4pdXzEvh8yNVxmHi0ZTFrsiRwV1PTArB16YbzKx8HpoeLBfsE8RW6bdser8lk3HjdEvTd8XeK9IMY2oxmYf/d0MEEcgwUaYv6mqyq6ZSGpdIwppHiYkYL8UMArDH6M3mNI3oZj+b/eOYhM5D5FyVzCkgn20uiBFM0WO0ZDZ7ItW4dOgKT63SNFKErYc4ftmEGwPY09zmGnUF2aBMBLX7pSH0vbCsCtpxzYD0euX1lJfp4ipG/vdDN5UTEC5NM4waZn1FxG/DIRS0ZnjRiSUCcFpJmdiBkFuipzSGnsFi30klOlZZDQj+ELRk76KcPZ4ZO3mhjKllYdFWuS95I2Br3Rxtx0MZ3Bo8iVoJDJMSNhooFhb/KBR/OjgookwUx2tdasnCFHynBXI0YKVSFM62tqNlIuszg68/+KaF5sNL9brjATch4oH3RIjka9YXOk1zA2fri751OE29qrIDrxaa2pxOCILJgomasTb3Q7aYInOxXKv8H9FmGpf4HBWUF1Hql3MG698j2tVKRjnru0eR6MCyNzTNKoAfUg9euGgiuyf6W5hZy6LbI5RXugsndGoq6oHVrOeF+drrMTM5XjdzhROX7cZkDFmfB4OCz6yeS+PkrL0+xfXvFTdcLdY5w1zKZ5HbsGvaN7gV1Zv4NOXsBHHnXqLi5Z7rdYj/tH6fdwbVrzRnnH/sMwtQIdDlSPyUfHdSMwaa0/OIiemkCdrL8YYXweIMb4ukptrXgb+ztHrXk3HfpGJyB8A/gCAvXXx9o30ZCc72cmeMzsxhbwz9lax9Vve+hjjdwLfCdB8zcuRpcs7qs5ZRCI3/Yz7pe6KzoqOLhRsXM3DdsGjtCvatzUhCH4u+f1bqSmtJwTzGJCh70rapsgyHKDNl9u2pt1XLFct77vQVE5dOCVB9Tb3t135OcWqgxUMXZGBLLGI+F6orya2jeKQajUi9KuJsqncRoX5C7gEJBhWuvuvbzQKGSOWUGhfVHMdKLdj564QC6HcOOYC7WViTFlI6veZIO7RaqqzvoqU+5hrStHqzrncfBbU28ZUI1KYOmgKLVYBmSmFF4DzQhhBLGtLtAmQIVD0Si9VJKkY4zXaKxAkGoaRXqKImUorM0acOcRGgrEMlUw1xqSCYPopDWk7UZoqn3rw0mmjSYwiUe8raGpQ5WAisfHYWVKMNoHhUDJIyXCW3j8CW8qpt63YC9VGI+ru1jTeMVoEJWwGVVkotoLpDG4VCVmjTtOQXSgzVdK6aFjOWxbVwPV+xiERWEdvtOevNzlKnFUDX7u6zwvlhoCwT/0W97oVN33DedVOYwmW86qlqBwh1FN7iUtpVplUGkYGnv7yKM2cnpvtHwfi9OcxNcZrs3UZptQ2MZE/j03npdZAR2BPzmZIpGtLHpl5/g5KlUBZvSEc6um1BqIJWeIHoC4d33z7M/z2i59mFyp+rn4vAJ/c36b1yna/SHRYg7N8ZnvG/cMiK9GDMvOf2x3vLa8yTdYjs+SGGRvf8IY/o40TfdYHmoe8OZzx0S6pIfQVN52uP60rplSxDdp+UAysCo3Q1n3DyR63Z9GhvSkiL6Xo7CXgXjr+KvD+o9e9D/jMFzpZTBG0T3Qzu9CwAx6y5LVK0QkiysEYvNJe2fXY2CL4lWcL2fFYE/OkjvaI0SMIg7O8enOeQSTeG7qbBtlbtgLlxTUAX718QIjCxzZ32XWJHqe3NPOe1axjV1YZVWlM5CA1cV1n7Smi9lSFQhiW045KAlM6TKbXErW3bGSGh1Sv8VDsQk4XDssC32hvV780GTgRisTo0E6MIL7Wn/5ClCZqRO8JYKDcSma4iIWi/2yfQB9p1plOG5UJgtvol9zujaaWImnBmxZ20wn2MCEXXZPYQkzU94wvtYmTcn9EXTUY4gCmNSoSmsRdi8LT7yvCIDl9pvcr/beOuEWq0eyFah1zD99ooYrEuaOcDdi0YLrBTioLyaRTIENg4toUz5HemrKQjM8yVhE57+lXaS5sC6orQ7XR+9Inwc9YeaIXYrC5r8qLZe0Nw7yjPVTwMFFf7SVtMGC4ow/ImsBmaCjF04Ui13Put0vWXcPejQ2F4JPEyohklZHVfphosUZgixm0zjXOu7H/sNpq6tfXU623aFW5IpTQ3hEOMhEAIKlp+shMkpkJ9cQVapKk0W5f59u+vNhz1nTsuorrRwt15IDUASkCzazP1HHvWW74+sXrXNgdQ7Scp1zzy7NrXjtcsHdVRiMaUdFTn0gbxpRubR0L0/Meu6McFTMksLIHrv2cn2rfR3nEp3Zu97zWXWQHHKKwGyoWZc+q6jK4xweDj8JFfeAsjeuhnb891FenlOMTte8Hfh/wHenfv3Z0/C+LyJ9FQSEfBP7eFzxbENVvKo/kIpxyvvVpJ2p6FeIsYlo0j+U+KOjPl1y9qKu7PRvwq1R/kwk1qNIUgc2uYbipH/t8iRD2Ba9vtB2gsVrDe2OzYrdJXmNTcohCYQPDYOkT+4cpArZStoVcg+i15hAq/cInxRBtxu20rjbW0IqWTKjr41QPGoxGXu1ti0+8hKEQXKNOxs1lQpUlNCRB61aQ4OuzSFvr7jlHPDExjgwZN5FVhcVrFDnu6kNhFFDhDDbV2yRoTY0AsZd8El9HrNHI75gXcqx9yUBGIwa0VqWN42lp22lTuXhdBBdzvZBl03FlIofeEPfjfYhQkJWls0RQqY2/9dojaeesNTnDQMEAquMGmE1BeZDHRSx7nTKhIteDQg3dpWTOxnHu2YNqoc2XHWalr902Df7QUG51HCbpyvm0AdAbmP41Sn672ReYTUH9MNUdnT6LUGm9C1Rr6/XDGfe7Jb23ufE3RKXBuj6c5YWztJ4QheFQasRbHn1wmifHzv644X3cePlSGOaCr2SqT7YqMKuRamQ4T6rkrWH2pgq45haMETxrYVgGirQ5OVvtGbzlsK9z1HV3uePX3H6FlW35seXX8qmHCtu3NlDYwLLp+KqzRwB8YK5w4R/ffzWvdRc8SsjF1hfc9DMGb7mVHNqi7DESmRUDfWMZxl0J8Jnhkg9W97ibal4fLG9oY8lP71/mtcMFs9Qno/VKrc+PUfDgLb23zErhffMbbpWTA70e5tyqjkmpTY7gnpjFx5/fu82eNmz/r6AAkDsi8irwJ1FH9r0i8vuBV4B/ASDG+NMi8r3Az6CZpj/4BRGOoD1J1UR+i0TKxtO3dkrrJWYI0yq/4Vhstn3M2kySSE3djeXqvIQiKtlwWnBjFPZtrbx3R+wDlBF7cWAx6xlZeh62Cw5DyWY7y0TI4jQ6bLuSoSsyu7kvghL2zjy9fhcp9pLYMVQROFMzeUUqmj4SZVQHCFSbkGD7Bjui6CqDm0F7yxDH3eXaq7OcKaP6sJhSPKGAeCTS6CsI80AsAtLa7DiMA4YEajhOEif/r2kp/bxyqylON5/SRxhyY2csjxZMmxycTF+4kdzZttq71KX7MxhBBk15ZlXwpCCg0PtpYD4Y2m2N2dk8hmKvmxDbC2E/9ZwRtUcnGsnzyXZK5SXR0FPk+1A/NBQHHhOgBB17sSX3loUq9cKl2zJSno3jNKLsNaDAAHETIGKkfeqxxFIZVGJC80rjYV1SXhvMII+BeUbF8JFweL2ZU1qlvLKJSxDgzLY5bT4yjQxiVewzkPk9xzkyUlp5OQITzRLlmJ3EQIud5PkwRnOgDs3PIm4WkYVGj8FYfGMy1B9UtDXUulnwy8CLF5qDfmGxZdPXPGKKmGbFQCmey2LHN118JmuUjY6gtJ6XGi0F3Cp2vN5f8Kn9razsDWS2ldL63FNWGccwso4QM/JwCJZfaO8yNx33q/sALKTnk/1dfur6vTzcLzJidLOsGaLlUb/gJqUPx/TlDQ2zYsELte5Wz616fhcMj9KNvO5mOHciJz62p41y/L2f40+/9XO8/s8Af+aX8hliNBU1Og7vDKHQ5H5MfVKxFIg2ke9OX3jQaGVYHkGGW0G8zYtcJtrdFnibnGSaY+KEGCJ1M3B3uXvsS7brK4WFj5IYc0911nHnfMu2rTmUqd9lrHmYFLkAjkQ+bCMuCDY1S7taVG157zF9WtgCFNueWBjMssQ1CaVVppRNebSDDtqPVYimJ49rR77WhWS83uPKsRnIfJDFQSMxNzs6r0vRidM04fjWcqfRWqimWkoowR4sodI6WBYUHVT2xSW1A1CarfomKCIumlzXwqrjPF70MemZi0ZymxtdrDbMsG9UykE5jM94bHdIz7ie0qn9SuguTKb1UpqyMSKc6obGj58PMb02349ikss5jmBGRwpT9Nn1RW7Ud13BfCvUVwn2PzqOUuju6ubi2GQQVcmeTelFaTx+PfUEgvZqWRN4Yb5RIoCRsslVDN5SWo9Ptcy+LbTVYq/SR2Vq1yjaKfIbg5VYJC7GOibqsmmDNNbGfHnk2OsJdRvShk6c4KuoPJpp7rlVwM31XpXnHbdmCtOvjMOHGfZIYuX1zYrd8NW8vLjhxXrN158pmcKjfsHG1VTG5xTgjZ/x6f0l9w9aWx+/r/NqoCr8Y2r2o/MfvKW2LiMPQxRe2V3yoFvy8kzVrb+mucfr/QWbvmbflXQjW36xIEThYbvgjevU5zdYytLjvOENVixTvWxX1RRGo+P7CRE5BMOsHneCT9BOKceTnexkJzvZc2HvXn/2/Du0phyomoHuMAE9YjDI3DFf6u6nPVTErcXPAu4s4quUjtglRvlFzCitaKKmSxJVUUbGbUZ9KzLtjjiBqOzou7rKBd6QNNNMGQi5SO05Xx54eXlDOyu5V+ku7GozZ/AFmIgkmqFgLQyiu+xi0j7LDOX1lIYYqZbsuiOWhmgTeW2KzlyckI9gsb2iJLsLoT9P57CRYRVzbQugvNGGanGWcgf19YRKizY1w6byYLFLmmWkHXhKFIvXiNCsJ4YNNxdNkTUaTYUUHUnUHb9bTKhDovarKbO9TM9INLryDVp7BGIdMHuVjykO4O5X+RkdR0Ywpli1Cd2209iHhdCfC8FOjdPVQaNZN6ofDGMzOtTrwOAnIuIxch1WGpFAYlyZeSUAdvax/jbTC/29OV2hD7h8ZKmvo7KTlGTQTXUDwRplYBmjwL2lfqhRbVxGJCEiZ4uOoXLKHJKyFrYInNct75tf04eCH7+n2KsHD1bK+mGYwBSdoTxoI73qyKWZ00V9BuUUoeV7OQtQe9oypcH7gmqd6rBpjowAkXI7oiSnmmpMaeYRtGO3hlBHQhOQYHh00BTFoSxpXYELhj6x8jhrlBg4GIwEXkwpvMJ4jESMBNZO76+RQOsLauto7JDBMPuhYlV3uGCyVtxuqOhcwbLquKgPvJxYhx4NC948rLjpZ5i0OMxNz+vtOYO3VIXPgry7vqJ1qpowScIEisJTpghwmwA6Lhq+cv6I8/LAG4VGc6EWvnJ1xU9ystGee4dWGc97Lja8msJ8vy0hCFUzTLWJfaWpL9QZ+UWilpmj6coiKtQaMLWnrB3GqC7acEhsGNflJDx47PxE62u9s8zKxJFnPLfnWtx90OvkjF7Y7Btes+fZ8QFUlaMovKYeUyrISYQGQlsgWztBp30kVEJ7UeT0m20jZ6Gm7hPnXoJDm17yQjE6iGEphHY6NkqcuFUgVgGcZOBFsRPKnYI8qrWCUQBcbbTYv58YTGw3LUzFMDmvUKS05hHnojq5hIbsBMTk4zHTdU2tB4e7SQPLxgxvl6CqAcM8wHlKyXQm17eiTGhN28qUKhupoEql07KdglBGBnzfqHBotBOEXFUJkq5b44mj6sAB5vccUXiM4qm9ZdkZk9GB0aaWh6jcliPKkZhg+huTpVKqtT7jYSG4mWQGknodqa6F/sJmTTgzJNaWanKeoGCIy8WBwgQebBNtm0R8MOxcjYuGzT7Vhu7VytzRTw48FPp/5Z88esaDjqU7F4bV+ByUf5JaKc5Y6Rw5vCSEUmuW2bHPIsVGGUDMEKdmcguhSowiozAsqJRMFfC7gjf3Wjw1jcPYxzXCqkrZP3Z9yZv7sywJs3cVXaqLj2nE0nj2Q5UcXcw1tJvdjHnT0ZSOXa8DboeCEAy9tzTWcUgX0vmCXV8hEunThAoIMzvwwmJLiMI+UevdHBpNWZYDl4ndJERhXg6c1S3Vkaz6um94065Y2o4X6m1+7UV14EnbicvxGbbdUHFzaCb09EgXdCgnYczeQmKLUG2M9NqIbhSPwA0xqIDh+aylMIF2pbfwQbVk2JVI7SkSlc5wUHhfVQ9czg+8NFfcspGAlchZ1T6maeUGy/2rFVXtuJgnccGztWovuam/rXcW5y17W+OP1KDdHNzM0t4RZWYgLbyxpFkpwjKOqMwh1TJCqkuhtcLiIBS75FDSQuoWpMKX5AjCzRUcIV4Rd6GYkJLKxDEhKo2LGnEZjSrGnrUwtdtNEiApglPwyKSTVez0d19OSEAJ0N6NDGdeGVUSICK2ViHgdZgenU8RtU8cgCOZ8iwJlx4h7EMZ8fOAs5H+YhKx1F61dJ6jWpefRaQ3RClG/0t3IdRrS/3IUVzpqu/nJXJhIZCdpD0Y/Nbg65i15UDHGYBimByq6UcYPBlRqK+F0kVV0k71X617qrP1dcz8is5ZllXHrXqfF/5tV3PTNfzM8CLlSKadHnm5HUVMx3ujz3C8B3nNjekz5xF3MSEUY9oIhkORMwz2TkfblJSPCux+fL7qzOrriHGTBpxrNCIOxdE9t1CsBsrK0R3KTLEWNiVh5pmtOmZps3prfqA0npuu4d52iQu6gez7Atdb4qhKD9SzQUEWUaibgS4hjYddSYwoj2IaxKEv6dqSYbA0hWOTHOWD7YLdvqauB9xSL2JpW0wVedAvcMFkJiEXDJu2VkLzFLWV1nNetXxg+ZC56fnk/rY+o77GR1Wv36XI8dXNBa+sL3nidnJoz665Q8H1Z84m4tpB+2dibxm6MT8DYeHBRGVXTz1g9mGZFYbDLC0UaOF2IzWzasgF6TvzHYO3nNcH5YMEPrG+xc1uRlMNnFeHzLINOplfqm+o3qOT+7XdObu+YntQyPGIhFpVLS5Mwo0A53XLdTtju20UbZYuY1jKFOH008LWXwjDmU27/vT58zGVysSqL1BeacRX7GMWSSw2RumWZFrY/Ez7s3yj7PyjoxxJaKubmLXBJERCYZUguFDCWQBxkXodKfchgzfcTHIqaoKEa5RjBgVUZEb6IjlCA2bhmC9SAd00RFdqpDYKmg5Gx7bX+9VfpPuwUmdIBBlptsZ0bqkRXl/o16R5s6C+1taFMSLRPj8dm29sTnsOK2gvDGawQJWOWYa5KGAkOXvxkbBXii7fTICiET5t+kkZQGHq6kRHBCVAn+i8bDulc/VeJmcbNFUIcFg3fMLf5hV7manYrAl0fc3QFbnBHRJwJfGAjj2Jxunt1z5EyYtfNEJ3Kbj55O3tQSi2luFMiFXEJOe2XLTsbcDt7dT75/V6hoVujkYld4n6WdEcbQJaGHpL3Qw0857DGO16YXW5571na+6M8PoEqpgXC17xl+w2CWw1WEJntT8xfYEO+0I3vBGGWaFRJYCNSrAQTKa+2m0a7VmdOzZtnflbD9ua6A2tFz5+dTt9dk9tPPcPSwpRsVGA9yzWGFk91pi9KHsq6zgvDpzbAz85KBnSg/WCWT2wH0ruX2sY7h7MsNsTyvHYnnuHdrKTnexkJ/siLcJJD+0ZNjto1DHc1tAkzjxSRMQG4jFTdRSkCMq8nYiMu95gvAWJmf2+mGlBfe+Utd+k/p5b9Y6L8sB7qjVjomvvKnpnafuSVzcX3G009/3e+oZX+0tcNJyVWlV3c8O6aKisZ9PWmWR28Po5QzCP1dYOfUk4FNjOTKmnoE3Ui9dj1hzrV9og3V3EzA4Cutv3VSQsPXbs+RkMoTSIE8rtlPaRoE2wfjbB9pWNJOLOI8PlEYS/M1RXhnINxWFsKIvISnO3xoPZpDqei1SbQLlxuMXYN2eSrtgIAx/zTJoOdfOYI7RotFdNBiEMJrOrxNZiu5TiHKHtMvUb+kZTigBmNahkSBRcp1+HuCmwO4OPYO44QlIKl9cKZveDRsFH6S/bauuB6bXRGlKbQlCAznhsmBvcXDTaGQEzrWAPEeNS5iCBN6RXajVxCoYBGBolWdYXSNZeGxvfi6MIbQQsFdsJnAMQfIFbF7gIYaXXVS4GTY93htB46kViwpl53NIQbMz11GJnsO3RvTwC7XS3A2EWMPsEqlor7VosDEPjMrkuKL2b8eCWKSVZRjrRVGs8el25NomserrnxUFwVyW7qMQDJmVfVud7XjpbUxlPm+pjMztQG8d7Zzesyo6fM0oxdb2d4xKziB+j+NYiKRMR7KSMjheGq4ZPb6ukuzQpePjCsG+rHO0WlccNENcVNw808vpvrhbMlh3GRC7nh9yztiw7XphvWFZdbmYf05EAHpkYSCpHWXjWhwb3QGsEzRs2s688KRPiqYb2rFuxE4a0wNuloygdRRFyk2Xbl/RtgRid4OWoj3TWM1BBESjHL3kw+N5iK09hA+tOV4t113DRHLJsOyjDQIxCe1Aqq5sLnYhL2/HK9pJ1X/OVZ1eAFniNRF6YbyitZ5uEBDdtjQsqMjrm7wsbOLQlZmcptxMbe7lVpvJq7TFJJ8lXVutMlwnYcaRbpieLeaWISTctlEf9W5AlaYwT4khnJcoyL2c9lxe7zCSxXs8YhobhTOh2CSDRBk1JSqq/xAkUMiwMoSxpz1Of07nkJl3jJgcRS/AxMpwHFZckoUgDWk8SMruK3ViKhIQbgSKxCgqssammNDYgx5R+Giwk5g3bGnX8e6OUXCPt2ZDSuZ7ch9YvFYBi+pTyG/2N0zqkqycEpU8ptfbFkGt49QNL7SQ554BJXJDBlzlFPKYWfaPpw2hgWAVYTGleTUtO6UlJKUvbkfvVAIzuz3TDkNC8Q2+wB6ObBxMpUqptmDm6O0bvVRpvKAvsQZlNfM0km+MEf3ugnA24sShL6rMz6qD7a53TfVlhHxUUO0N/Ky3g5wNlrZvFOBhiOxZVEwClnxy7+ATm2ReEIlCs9KJXTUeIwnU3y6nB/azixdmG8/KQGToAQhAiYAuPpE2pCwLBEJeect4T05x2+4LqgcX2RU7v+zoSGmAwuMHSzPRLWM4c226O3ZgMPBp8xX4wVKuetio4OH2gZ9WBy+rAC2mjC/CgW7DuGz7KixQy9QRezg9YE4hR2Ka56xuD74425Sd7/h3auHu1SXMrLCVD2ZtKJ3hdOm6Y4ZIQ4iiGGJKcCwZcWixjp0VjKhU33CVQx76tuTk0dK7IfG/zoqewquBrTMwIq0+FW9zbLmn7kvNaI7SLVHu7TJP8FaPF3jfWK7oUOYzjKiunrQdJWiQvohpo0N6yuFSn8k0CcFQBqX1mzgjOKGxbYoYRe1FuSkkLtkvyMW6ePiPRX4GiQWMVmS963n92k6PST0ZhsymVUiu1D9RXulPXBuSY2wSGlWTWjmH1+PNSlWPBZD00kuK0soCA7tSjgDsLWsrJ9TK9BnvE5RgKCzKhETMApLfgBEmLOqTIqlJnUj0oJt5Fp3XKEVADWtuzB6jbSNFOUW00QtFFbcxfTNHycB414stsMjquUYMtZw1MnJrNj7geJUCoI95qrziM0aAcObYRHZgcVzGBazJS1EdkPV2v6VTU1S0ls4IYGwkXOoeHfbrgBA4yg+AWIUd5IQj1omcx63iUiJBDpaK0oYgUW4NNTso1UXXoTMwbLKJ+R1zU79hYGyp36jyjndTWfTMCiiJUIeuZHQaF7e/aSvkrgeFcQRgHX7Idah5c6UQbNyq+9pRJR88uHN5amlVHUfh8DspAqCwSp5YRtwjEudbdw2AYRoLSyqnM0WPgMkGKiDGRXVvlqOu9ixtuVTtcMHw6KWm/sr6kdzZL1oy270sKG7Am0FzomtH6GblP40naKUJ7dk13sxOJMOuSvrQMdcgpqnnT01QDh6joxzjSyYzaVYMgafduEqTdtQU3dpZTDUNf0HcF67rng2dKeTOzPa0vaYcC7w1vbtOXyRvWmxll5fLkPi8PLGzPzdCw6RtuUspRJGa169EZWRuyczPDlEYc4dyhmiKIOMLcgxAHk5FmpgiEQZ3zMcGpcVBtIraPdGZ0irpQ2/4IFLIMSIomrrtpR+6c1c8ThbjrGCTvsu0wIS2jgF+owx1TT8DU4+cnVKVJsP1Rg220YQWhFehKjhtCQxUp9hPzeyw0XSczhxgVFs1WKLrwsV7DqIv2CIzR+6BcjbaPj0HxzRCpbwLlLtCv0q4+oTpdLbS3kkO7iPhZ0B6xJNq5fFUBKW4mGiV5HVdxMMqsf0wEkZ5zX6EI0DS2cjcCgSZ1bDcXhuWkizdaLDS9KUfnDRZdcHsFQg3LNLeWmo41Jj62OOs9UsDK2EdJpRu3GAWT1KKHs6COZ+azECykqHgWoZ42Y/G6ot0VmW0lvzY9d6XO0heP6U8E5mctFwsFWRz6kt2hob9WKjOA6wil1Uhne6gzCbY5WO3j2xmGS/2s+fkBuwjMq4F9XyLJodjG4+6Cc0IWkRN00yEQB5PT1SEK0lml6hrnk00ljqiqHPuUUt25igcseW1/zsffVIHQ4VBSLzuq5SHTbIE6tO2hpi6PUrdFIJQnh3Zsz79DKyJuFSjSjq9+YAmlYVhG+pF2KkLTDBRFINQOJ6mWsi+QxB84yb+T6xz9vsxOJjoDg2G3rBjSKjxDozRBJ7Ibe+GcJQyGcuGnHLlxHHzJzz+8y+ZmlhFh77tzzVnd8sZ2lRWKSxt42JVK73TE/B6SevJxY6txR/yFzuZ6r5353Fs3RgW2CppKKXRRyX1ZqYk1JrojSGhRa9lva14fbHbs7VVDOfZOHaER3QziSseR+FYp9uADGdEGEJdOUWX7Ars1R6Kb+vcM6UfPGcqYuS3DURARC3WU5VHPmm8mpN0xnyNNJDpy5IdVZ2o7Pe/Ig2icRjohHNGCFSCVUBwMxkeGhT77YS4JITs5ZUSjzuqR4eJjqdH5/oCbW2KhnIVjCq9cawN4uZ34EhUJOS7w8Yh7kox2HVO0bpZQrE3QLMNYDxoMoTNIRW4RwOhzUJJnyaTHwRSEwlLO+xzFhMYRvOB2pUbr6Rx25ilLR1V4FiuNIHYAUbBWpW56pk1EqIM2tY+R2FpJnvUaJgJr3dikiCy9PcyUNFrmjtWsy752s53h1hVmP6X7+m3JdqFclMNNnfkro2gmNlqQlGJdzTpm5UBl/GPRkXMBO+8IQThsdbLGQ6H1tLQWjGjasCso1gbjhP4s/a1Sx1dXjmre5X7Uvat4ZX3JvftnFK/reasBhq/yLKqel+ZrfNpAXLcztvsaKCiK1FNaBfzRRvBkXwYO7WQnO9nJTvZF2gnl+IxbqhnkX/uJJcMlRvohUciXpddd2yhM2RmKg+o0+bOUqps7qsppGnCwU9QVRFMQkCXs57bHBcvhUOEOBXIkRGgKLfA+2CtbgwvKBNIPmlocgSnLquNurSziI1CkdxbvDFYUZDBGaMaR024jsm0oNUKNhaIBx5SRiEYrMUyM9HU90L8nsnYz6kfyGMCBIhBrQRJDRrE1eCfEg6FfTM3d5aOCcv04LZhxylgyLCX3FEFKl7qkHlClVN1Sr8HuFC052oiqg6N0qtWIyfQo/VcasBlI6gJHPVwJkOIPSiM20lHFlDoCMuuFccrubruRDHlMwUhuRs8s8ylyaG8LvrH0R8KfRatjK1P/1EhgPLsfmT0Y0n3sgYriYBIyM93fVsmbq23Ika5rrCoT9GAGlVQBRbaGCvpGcrTrmzQXbMxAE1AE6KgxlmuDMUXhVdQV4YgQOhpPWSoACpRVw5gAFxBC0kZLx6vCMysHLhpNAd7UPY/WC7yzFM3AME+v3SuasNgZZvckX8MYzUY7XcdYC/TNlHmIRtn4q2bg0JccUn3bbZV0eQTOQAKjdAWuK7DrIkf3CuqIsHA5olxUPYUEXDTaXjiCgWxglurt47EWEBOpZwN9XxCudMB2o3PHzSNhPsKPtX62ajruzHa53twl2qt4KDKNmUQ970vzNR+YPeQX9pqK3LY13lnq2nErkS5YiWzslO5/UnZCOT7jJkcL27jw2k6Iid3CFZEQDCEondXIcWd6RUKFKmLmCeKcnNn5rKUrC242OqF8FKTxrJqODzSqq/RiecNHixcVqeQkp31MGShLz6wackPm6+szLucH5k2n6rQp5XHVzji4UgEnw/S4TBHwq0BoZEodBRXItJ0W7AGFp6fPjc3EB3k8ZUdQyKLped/FDa815xxeWdG8qfenujF0RhFe8QhxF8uIaYWwLSahxlTEP5Z5MR1U64h4BYLk9GGIiFdmkkwZEiskqCRLsZ8kR7o7gVhF6vt2YqcQMHt1lr6Tx+pa0Si7SK4pLdRpGldmyi9IYIPeJFHQdNrDVLML5VR/lZQeVfVkfe2wAreMufYz+j6TADrRTlB6lbtR8Iibj6tzpdD+QjdZmSFjpvckisk1UuM1FVdEbX8oDlP7AyKZVxFIYqqGYRDC1k6SO6k2dTwuCeAHUadWTw4UoD7ruFgcMnv9tq0xUXhxtc0MHKAyPCExXnzl8hEA/bzgp8N7uNnOtO47mwAkdmNp7gvzN8I0hh4YG6ntlDrVJu6Y1SZk7qhnA2XpGJzN9HOjRJBC/9MFmMiwL5G9TVJD08UNC6WxGzelb9ysssNqqoGz2XRDQxTavlThVlKaPoqij23Aj98xq/p0fumxCX1pjH7fCxOU3/EICW1NgCKosC666Qm9ZTvU3O9XvLK5BcB+UysZROUygrMsPNXbwbb/Lrbn3qGJicSLAZeK7SOKLk7BChSRGIShV34dSbIy3kQoIuVsoEgRU3co8c5SFY5uKNUBgoJHCui95fXE6js3HTM7KBdjZXN/T1MNFDZQF44Ha12xh76gTjWIkNRpAR6uF7iR8LZMkV/TU5eOdRRigPlikvPdPZrhd0WGpRNRrS8n6txSDWmMAIe+yPUvH4TtUOG9qjqPUZNtlTTWzaMyQQCcDxrd7Sqaa8lpipFKK9Qx8x1WN7qIIwp+cMlJ+UpRiNWN/oBuNGyri7drJOuvxcuBetEz7JfUj9KufqtO0iYwxKitFQoFxoznAd3lm16m84/chKW2bbhFzLtkO2g04JYxUz2NFioFhIyExW4u6uQFin2kTE7GNYKba6QxOppyPyEh93dSS8NK++5GJo5jiqn+PG0AjngNs8pzOKIQO5cMjx8XcuOUtqrcaA9XZnKJyu5ytKZqvW2mPYlm5ggJOCGDZIaM0aF5b2jbkk/3BW4oFFgENMuOphqwErgoJ+2uVd1xvVEE8chCEhuPubJUmwnJqbBHjXiHxVGEZvSeu2XE3NIQerVoVWTUWdptnTegMgjl2mBbob9MnzX3SGsp19rXN3JHunnELBzGBvoR0HEoFPE6d5zN24xA3g8V+6Fkt6+zeK/d6CZhv7dI4pUE8JcBKQNl5TOUX4DC+iSO+jizR2FV73DcREgAuS75yU++zEfKl/Ajm5HT3pl+X/FmQpGKiRS144nbKUJ7dk0kcnFry6bSSKpPxVzx0yJMTJM5gF0N2fHYM0011IVjnehpDkODGM/uoCkAmwq0ZhEzKupTe91VXQ9zrro5VaW7wHGehLSz673Nzip0lusU7cVgcgTlNyVmbxWUkYhnXeVoSsdqecCYQJXGsOsqTa/amAv7xU4yaXIUQ0zs8/Omo3daYB6BKbtDzfX1grApsXvzGPM7MWmWjT1rnVJpSSBzP4I6DreIDMsjZKmQlLBVzHM4G51MTEjGSQ9NgqbafC20dyP9C/qFvby1JUahqwNulpwBgonq1OpdyMTL3ZnV9FQNkpzJGDUGA/UhZnUA1yhbf97Ro85sbHewrTL6Q0LZmZg4EiVfr+mTkzGKeASou6gR0pKcGqx2QXvv6qOFlQlub7sJsWq6BGyZQX8+Os907kcqwDqmlUOp41CHMKZdNcKt1pGi1ahhfBbGKalw7qU7B385MLtoFVq+G5cFwQ+WQ1/mlFtReLpdRX9VY/Ymp9Fd7agXByrrs9LzxtVsuhrlM3U567AZEsJwaoHUTEiRrsOQUwhmAIwQas+ds6R7Vjhu9jO6Q5lJwUE3NuVGn6Vf6o2sVx2dbwil0TaD2VQ6sDbghmJCNfukZycweMMbSWF+vZnj9wVmaylHOri9JGdrCDOfkZ2hV0aAECVvdkUSvZgr2PYVbWr1ccHouuBM7gsVD6YVzKdrxAsm6eYNtx3lssf1BXK04RjOj8LpJ2LxXe3QTkRgJzvZyU52sufCnvsILQTVHrudZNoP85LtpiGuq6mRdmOyZIorjwAZjUJsB28zS0eVorf+UBJ7m2tSRekpioAPqkALKvnQeZWZCIOhWyeJiQjFec9y0ea0hCsN3llcWyBFyMAUu9X+HSeGkJo326KiMEF7UpJqLsAwaMrE7swv6uMZaxDjtXVDSd9bZs2Qd85uKAibkvLGJkaPdBMTU4iECdpuepubYvvzo3qM1+jAdlO/0O5lwR40EnGLmFO9I4HyKDcCmnIUL/iZRiSjjlfvCg77Ctuax9JRlReKLlBfDbgmAXQqha8bF3Nq0fSaYh5WCggZASB+BByUETFTz9p4HVo3SynZldcaTyu4Ybq/5VprWm4m2EQCPLvvqK8d/Vkx9e6VqvPmGnJzPynCDFX63DTech9xMyEuj/qZZl5bSK6VfmqM8lT6JuboQq8hRbm39djYglHuYPGZQL327O8mzbAZLG4dmNc9VzeLTNIcq0hZaa13ZOYvraeoHUNr8QuPJFqwu5cbXlqsMRJ5/XAGwMPDXMm2TWRe9zSJcHuznikoJ06N6L5KJNd2nAdpQqS6omkNm70+eJGa9qrB3hSUO8nRnCo5pHmXItVZPWBuRQ5Fg6k88/R967uSYVvpe8upryuKgBeurpaZraS6XzC7lpQyJz/3UXWb3hASbN8eDKGMxMuQiRuMKJDr/npJu6khzZExS2TcVP8UL4iN+fvi0zowXEgGrY282KGdvoNPzBQN82TP+Q7ac+/QCMLuUOUvpJFIGCzljcny8TaljPoz8EtLSMwORZJyvzk0uXBclh7njDYp9wYSb91QBdzCIRLZpxTgee2praMuBw6mwq5TqmwntAL1xZYP3tYm7N4XfHp9zsY0FEXIAoWhKBGryK6RXWLYl6yj5GJzroF5RVqGOn4W6kMX7FjEqagdtR9uczNNgdhbiq2l2KaazAhiGVkmhCxeGlJa01UQbztI9RHZFZQ3uuCOKbLuMlIWKnQZzZSeVGCOMkeMjqc4pPEWYHvBX2t6ZdcZCIIJU/9UMKL1n1oXNZs02Yo25rramIYMRUrteUVEjlyXkthPbCuPNSFXa2WpUEmeEfWnfIvDMmYHXj/SOuCwTPXZlGYt9wbbB2wX6FdpjqSa2oj2BJAoWb4G0VQjqNMc5XZG+ZpoICw8oVYQik2M/b4Cggqcjtcg6PNTXbuQn2V8YJm/qa8ZGUz82cBq1mIlKjvOSCdYB+p6oDBB09nJzlcHDimF+P6LawA+sFAgyBvtiqukI7beN3RtmefnYUh17H2BGfQ+HF5I4I+lcifag8rIlNvpuUWrwKQ+puKrgebaUN0kerHkZHytzj9M7W6A1qxbWxF6S5uUD+J1RXVllJ80cZFKGaBQtpa4s9hR226rwKVYKH2ZnkBBPlVpGML03BU4FShKT5mQoT4Y+qGgvWowW5s3ivYgGUQ1KglEo2oUYUR3zqYv8mGnm4Oimmr8oTvKlT8pO8H2n2GLMGwrrlPh15YBfJpE467IKa1OfxlgNVAn5FDvLT5oLnxIDsabxK+WkItjlBHMEeIpFdD3Q8VZ3XJnvqftS9piXMX0PRfNgW8+ew2AIVp2rmJ3qBUGnIrtsQ54kcdERqUI+G2JD4KbuWmCO6O78SYQy3GrnhySPPbRrBYth67icN1MNExeMN0YiYEZQR1rFQ71DbhxDHUg1IGi0VreeM3rYUmwBhGyEKdtSXW0+BiCzqeFGSbUYblNt3amz2UElvghCWIJDMu02M09pjWYwdBcF5Qb9YrNQ41kQin0SZNqWKVm6JjGcTECVqC+grAXDndTPWgWKTdCdaN1wDHardaWYZGIeuO0gLkZDOe6iRjrbe2lYZhVIFPjuJvpPezPI/1lao6de6QIhE1JcWMpU+RnB619GScZMOJrIcwEtwq0d2yuzY1CmcfcihJAjBCN0p6VZxqZdLZiuy/pzg3b9+trF3f3WIns+5LozaR6XSrfaQR2iQYqBsNqeeDWYs9Fc+CDy3sAvFxfs/EN18PsKGNgCa1KH22rOjs20EjdLaC/rfehPO9wXYF/VFJuzOTQSr1u28J8lxq+i1RzPGgtMIN5Wq3H9ufg7qRrSOKl0RnsoxJSc3e1EaqNOvUuyQOFlcNUnuhtbsAGCPVEu3WMjg1lqp86yQ3Oce4pGkdV+bwJGAatlZut1dpbWnWLnVBfRRXK3af3W6FbqTJ6N48MSVvOrgZiQAnEk/6bdOYxMdOTfTk4NAE5WGST0itnLsFkp6K4EV1kzIstF2d7CjuBLNpDhXdGuQ/RXVrorCIHe8kks7EKzOY9TeloE9Bje6gZguGDF/eZFQM/k6KjdlVTrjoq6/Ep57K0LefVgdfMOaG3OeVIGYhWkHpiYBCJbB4ulM7KG4a0k5TeQKOIqzh+IU0keE1bxlKYL/QcL602PLAL+q6ckFRBUYV9rTRI83WKVA9Kt+QrYAQXmIgtA/N5R106Ht7o7tluLEUruGZS/o72yBm3045SOgUuhDrqQ0hmuwQoKSaR0WKrX/ZQxQyGMMuBUBuGs5r9HUtdjUg+jYa6M5Nf6xbKBh/rBJNOwAd7MJQbhb2Pa4OiObVnzB31+VU3ykri5pLTpq7RFgblnjyC3TeSoPfkBaw/SxGEVUcG8MILN1gTuG9X+HYGSaAzjFyNkSMIOlAEivOBtinp1wn9uj3aFIxckgWYA5QbQ1fA4j1dGtfArl9R3pgsxHlRDbhg2O5rFQJNz6qeDTSlY9vWDNeJiq0zXDuDvRW51ewZ0uA2vmEfKkrjc2qxqjxh7vCtUr8tZwn9eMvQMcMcHi/hN8uOFug3taYS0X1DKPXHjunjxKXp5oLxMTPP2CEgPtLtDMMqcayuJiZ88YrWhZQJCKlHMs2x0CRB0rGXbcwEWPL8HEE73kB/qSwuoY7EhIw2lW4A2kM1bUqdQBDKXvJnwZgF4DFBU9sFZoMQSsPhPVDd0u/r3fMth6Hg6uGK4npsK5o4UJ+knfrQnmUzmmqToygEE3FnPsPSowCXPV9x55oX5pss4fCgXfBpf8Gwm0E/0gFZzEHTlWaYep9CqXl5a0NGN7nBsjk0cAFfd/am9qAAb+5XNIUjROHndypncVa2bIdaU4K7iRA3zjxm7jhb6a4YYN027Gqv0vYmZn46gHLRY22kS9DeGCF6QXYWPCySkm+Iwr4vCU6mCK2IxPcdKEtPe91gUoooFEJ/oTWkEc0lAkjk0JZstw3yhoYhszcNtgM7F9oUJYY7A8vzA85ZDqbOwomhLXCiMhySIrxQ6m7cDrozzrvZjToqFwQ7OqlDAUWgPw/Yg8l9haCNzt3ltFCEOlDcbVnMO3pn2XvdckdjVKR0cdSwXSbx0lro73glwQXc/WKKIMcocRQcTWmnzKxf63HbTpRcwyokTkyB5FAfrecQhWFfYo/ouPrzCfnpU0rNzSKm8SzmHa4ZODR6z4eqwu5MHkO6Ckyv6bsRkQmog5p74tZQ3OjC+HC2pGwcrlNV6Wauc+RyuacdCtb3ltT30qbJCa6reRi1EfluozdtLZ5Hw4LX92c5tei9URTtLD4WSVgbtD3GaT8awFCUlJdOG7DPSw79RJzsZ1Fh9vOxfqs9c0PU+TIiVmULhdMSwtjasV/OMMsBsboOjA6teagyKb6UibjZWpzeOnVmYaqp+moqTQCInejUkIikTWFI8Hq8YPdjd7fOmTGdmm9FTJmIox6i4hCzyoRbOt57rmH4B84esXclu0PN0KT7W2kK+onbu9ihnVCOJzvZyU52sufCnv8IDaDxhGaKLGKnfR8hpX2ay5b3Xt5wXh1YFR0vNTeAUlg93C9omyl9YFolPjW9PJZiKnaCjw2beYldag1OgLYt+YWbO9TGsyw17bMraxZlRx8KXt1eANqTsm5rhm1FuZn2GUMDdTNwa7GnSFv2zikZcFF6jAm4tDuMRaRpBkrrs5KAHg+KjCoiLtU3HuwX7HeN0u6kuk9sNIXYlA7vhe7WlOvydQQbJzLmIERn8K5AtgXNo0Qyu43YVmtTRap57HzNJohGdV6wTWIxX3UMtoJ+6sMZayYh1aZCQjmGIpEFHxf8vSBVxC8DbmmmtGXQ3bNEcnRFFNxgMSZgrSAJaWZSE3W0U7M1B71ef+lp7ip7C8D12YLhfq3yOiMprOhOXnqjoJvFUe1ygPqo33GMBOxeJimVzQLbw6xL4qdjE3UiW47mSLVgprI3I2PMuJGOZVBFg4OZ0IFRo8WYerrG3qei8DpeB3UCRbl9Q3crEBeO5rzjpYs1ALNi4B9fvUD9ekl9rad1jQJX3K7g5tBwM9dwOUThpm94lJCNoBkKYxUg4ZzJfZbDpqa8Kig2krfUzpcc9lbVACL4kRC609SvGZjSvMuAP3caQUlBSIjRYanXNaYoQVHCvlS2HAkT8CcaTTuaYYriy4Xg56L3s5pAWNHaDNzJ8kA2PasoGmGNU6+YGGdGgmRxkhrvNQIbCaT7c02jj+QAQK7ztncj5WWXRX0fdXNCFKrK0d8aXyw52/HELALh3RuhfVk4tNmqmzjYthVmZ1X1dtQMWykTwr39ijf3K+7PtIP5up2x/yxZEkgL4FyRbpkKqoq6cAXJbNjGRNpdxRsPzmmHAjsy0g8Ft+YFZ3XLrteUzc22UUkYSdyLqY5hl8o0MnhLm74p3hvqZqAqHPt2Qp+V84FV06ma9eiAy8DZ2QFzsaN3Raba6voCYwJxOeQiM07Y7xqGpLc2jsE3qWYkMTPzh84q23jQL+5IBWV6sH3EDomSCZBoaPd1konxmeZn/Ewg19taDGaV4P13+szQ0s8rTFIJznU8J8Rdoe0XYUoZ2l5/QlpwIG04uppHvQED9XWi9UqUXIhkNg3fRIZbUdWsbaBJDC0X5zt2lVMR2CPZIL8pQSL+witSDojeYB8VcD1RfRXbtLAdyLyE1Y3QPIwUB5+ZP0DrQ10SO82sJoMhPqrofK0s+pnyTDL02xzVmUAXYNsJbWK4MLXX+u8wPbNiq6nXXixubjO10oPtAv/GjNk1+TvglpHhLMDM01RDFqB8ZXfJpqt1nid039i074MhBkM4gphHeEy/rdgJiKU/U60xl5x4EbVZuthOyNDudsTUnugVIj/WkYYzkrqEEI54UxFl1fB1pL9Mt6wU6uvHU8KxQFlMGk90RrUP0VRhfTU+l+m+ju0pejHpvKkNJJqpzGEG/bsE3ZhNgq2pNcVP98HNFLHb3/Kcz6d1643NikOnaO2qSaC1w/Q9f3L2bDRWi8ifBr4NXVXvAf9qjPEzX+h9XxYODaZ+DvokUWHJBLWut6zbGhGNYPYJnbRez4g3FeJk5K/V/p5Vcl4GYuJ4FBOJhwJ71vPSpe5wW1fQ7ivCruDR4XwajET8pUkIrLS7PJRZoDLWnvpMt9qzhLi8PjTaZ4bOt6pydEOhKs1pUstcyZEHb7PjiUGoS8dXnz/ERcMbO+0RuqHJ/UX3RY+Fqwq/LwheHmMvyAKhVZgEKHutwRR7oVpDfTMV3o1TePO4E7VtVHkQ0R1w2Ot1mJ3FOsGvPPZSrzdeCP1OazmzRZdJcZV5QVR3Kx2TbaXQf7QwP0qO0GkNq7+Y1K2rR1Z7ex6U+CpOfXpBC/u+mSDSoUxAliDst3WOdsc+oLJ0eaFxoguXGUTpyuJ0f+whLXhHLCi5Jyy9zG4jthvbFmIGHUQrqfVgQk4OnfYH2g6VQFod1fFCWiDTRDVOHVa5jUgUQp3YKRb6zMww9aaNMkTF3uCuat4IOldDZyk7YZhPPW/9HUd53rGY9by0WGeZlW1fsd5rtDb2XxU24Lyh61W5fXR0shhwXrlUM4L0Wq8XUdLgEWThfaH1ag9upL8sHkeZZm03gZEtXkY4b9QfU0T8wjGYVOsqDMbrG8YaY38WsnTRyAsJCZ5/E7N8D6jDKrcyrQPZr8ikkj62SiQmnFCAKSaQkRm0XhuaSGJoo68iVIoeBhhGDs29Zm/qsy7fx9jZx1DDz5n9BzHGPwEgIn8I+HeBf+MLvem5d2giuovOe44qQONxK4OMCsdpEbiYtRQSuL9TxF7YlDT37QQ5J83xqLteX0dMopIy1uMEzld7PrDSnpzP7M65ZyIxiqb1xuyA0Z6SN4Khb9MjOFjsbiwsC32lC9Bi1nHWdPTe0qb0Q1M6fDA8Ws+VPT3RXPW24l5cEsJESRS9sOsqauv44OxRBry8ZnTR2vVVRjmWW0PcG3xtHyvix8YjM68KAWMaRvQLWexTmrEfPb5Czl1jMvN8LBIHYWohkOTQqiv9+6EWZnN1aKX1bMyMqnbM6/4xQmbpDGZnpoW413RNqCOuIfdlgdDd9lQv7ifH084p9mSm+ZF+S7zSULV3kgIx5KgxHgrEC326P30RFBxkNUIAFGxgdYG118XUfrDRXb1tI342Lb7ayzc1DkcjtLdQWrJiIlMOpS6eI7HzeL1Zgb0jA5L6i5D4MaM2XwOYSPVmSblNZMojEtInJyITQk718jRKEm/oJYUQhQqvDudx0j1bDFgb8VF4cFhSpjnpvKbBrQk5E9ENBYe2xA+WMFh8JppUoVVvLdGmhuQuUVZVab6N2YF5UICMnzYcsYrYcS7GIweReDq19y7dx1nA1J75oqU1FcNIc5WcXyglbwxiHZFtof1pVSL2Ts/NzRUpOzqrYq99gKFUR5W1A8uxbSYy5lNLJ7lFKBRHwJKgry3O+kyhV1eOWTUweMPglXYMtF3C1J6zRcuQPPu+DHnteqL2DERoMcb10a8LflGe7K3tXQkKEZHfISIfFZGPici3P+3xnOxkJzvZc2MxPpkfuCMiP3708wd+KcMQkT8jIp8G/iU0QvuC9q6L0ETEAv9X4J8BXgX+voh8f4zxZ97q9cYEVRju004w7dacsxzQ/EFZeebVwKrsMBJ4ZFKifEwlyKQabDvRon6nHf3tIqXPzj31bKAqPDe9nveqnennhpR+GDEWARgM7aHJbAQ27TQlqqaSSzmeXVPz4nLL3dk2kwjP7MAn1rfxziIHm3tbvIVBRtbbKeUyzCyd13GelbpV3FY1rS+41y4V0o/uHMVp1OIbhbrrDYoYq+nMrHxcBnxjiakOkyVSuoDpFGLt6zSume5MRyj0CHywHVpb8JKpxWalIy5a6tJhJGYggd+VWV9sDCAURCGMvV7jTn1YhhypZELouaef67XY2uPGdOqqJJqIWWrkAeDaAlqjqeZBiGnuxMoQJWK3ljA24860udt2oq9P11ZfQ3OVKMXmU20uq3OnlFgo9P7EQvvTMqgD1Tgr9qpcDUraHMqkWDCD/jxFMbeGrMS9WOgJChO47s8oN4W2GYzAEqtAmVBHfJJjKW8s9UMBr1HIyBxvaq8aeEIm8PXriuCFDthUS2xKuRsTKCuNqsc67Xbb5PSd9JKb6MP5QD0f0JGmrEQZiSII2qs49lFKFNzZ2L+QosxB8PsC2VuqzVSTCpWmnWMRcec6rtntA5dLbRx/41BNquSkFO1iujfSK3NHuRVYRnwiA+8vFMih9GJ6rNgpI41Da3sjK04s0PT8zONTzbvYayr6MaYRtB5pFgMv3b7JGnKdK9gOFdu2Zr+p83Ot64HLxYGvv3yTh52uT5/gmbcHMcZf87n+KCI/DLznLf70x2OMfy3G+MeBPy4ifwz4N4E/+YU+8F3n0IBfC3wsxvhxABH5HrR4+JYObczxj+nFYANnTUdhAo9SmF+YwKwcaAptMB0bq2XmcAutJY1NluagDANRtK5gkjNwdUmoPA9vFpkhQADbOPxQKh/iCBgIKVXSG20qBm34HQTTm8e+dM5ZfDAsij6jHA++ZN3W2uCdUmiPWST30FAFZvWAi4ZP7G/zqEtyNd6y7msO2zp/3rBUOQ/Ti8rGL5IGXKOipiIx1/FCbwkzZb73teCyLJOh9CGz20OqZSXHpbI002IeLYQLBbOAIusiShe07SpcYnjB6TPwRvKiYg9CuUs8gKvJWfiLxEzurAp6gqLRZo5m0WNtyHWxQY7qMekK6mVHb0viYPCQe4zszmTuxnERdQtRQdOYGEwyOEAIVrRGN/bCVUpDxREqLlp1LtForWvkeByvUTXZxmOpN+5CkY8jkMYUgSrJiIzzfVH37G+3tPs59iCZD9LPg15oEzAJcON7rSfJpEKknx3SOIPkPsxibdMCDaEy+Gak9QrEc8EsDpkpJOwKFfMMaF3sTCfJ8lwX7zZUeYPk5mR+ROmFmNOLKixnNjajf6OJcG2orzXF2N1Kz71JlGe90N9K6b7CYyVqDbotOMqk4xZx4sAE6gfa6C8BgpXc+B1NVGHVAYq0eRy5O8d5kMG06bsnJmZQVagsvtH5kZ0zaJ+ijRiJHFxqBB9KNm1N25awLrNKQrjtuTPb8bXze3xt2m/frvd0wfKTPEF7B1GOMcbf9kW+9C8D/wXPqUN7Gfj00e+vAr/u+AUptB3D227zL/3xjxz//VNv6/C+oN0BHvxS3vDL3Ym9Ap9v0v+Sx/N22Cv6zzMxliM7jefz2y8az8ef0kB4F9ybz2Vf7D37x8Bff+s/feUXeYovwiLEp0/mKCIfjDH+fPr1nwd+7ot537vRob0VruexLUWM8TuB7wQQkR//fGHvO22n8Xxue5bGAqfxfCF7lsbzLI0Fnr3xvAvtO0Tk69ACzaf4IhCO8O50aK8C7z/6/X3AF+xPONnJTnayk30R9mygHP+nX8r73o0O7e8DHxSRrwJeAz4M/ItPd0gnO9nJTvYc2DtYQ3s77F3n0GKMTkT+TeAHUYjUX4gx/vTnect3vjMj+6LtNJ7Pbc/SWOA0ni9kz9J4nqWxwLM3ni8Lk/gMhJcnO9nJTnayp2/n1YvxN7744Sdyrh949c/9xDtdR3zXRWgnO9nJTnayt9HexUHOu5Ip5GQnO9nJTnayz7bn2qE9DYosEfkLInJPRD5ydOyWiPyQiPx8+vfy6G9/LI3voyLyzz7hsbxfRP6miPysiPy0iPzhpzyeRkT+noj892k8/97THE86vxWRfygif+MZGMsnReSnROQficiPPwPjuRCR7xORn0tz6Dc8xbnzdem+jD9rEfkjT3E8fzTN4Y+IyF9Jc/upPasnZ0+I9uopRXnPrUOTiSLrdwLfAPxeEfmGd+Cjvwv4HZ917NuBH4kxfhD4kfQ7aTwfBr4xvef/lsb9pMwB/3aM8euBXw/8wfSZT2s8HfBPxxg/BHwL8DtE5Nc/xfEA/GHgZ49+f5pjAfinYozfclR7eJrj+T8BPxBj/JXAh9D79FTGE2P8aLov3wL8E8Ae+M+fxnhE5GXgDwG/Jsb4TSg47cNPYyxP3CIQwpP5eQr23Do0jiiyYow9MFJkva0WY/zbwKPPOvxtwHen/3838LuOjn9PjLGLMX4C+Fga95May+sxxn+Q/r9BF6SXn+J4Yoxxm34t0098WuMRkfcB3wr8+aPDT2Usn8ee1r05A34z8H8HiDH2McbrpzWez7LfCvxCjPFTT3E8BTATkQKYo72wz8K9+bK259mhvRVF1stPaSwvxhhfB3UywAvp+Ds2RhH5APCrgL/7NMeTUnz/CBXt+6EY49Mcz38I/G+YhH14imMBde7/lYj8hEzM5E9rPF8N3Af+Hykl++dFZPEUx3NsHwb+Svr/Oz6eGONrwP8RZWx7HbiJMf5XT2Msb4udUo7PpH1BiqxnwN6RMYrIEvh/A3/ks3SG3vHxxBh9Shu9D/i1IvJNT2M8IvLPAfdijD/xxb7l7RrLkf2mGOOvRtPkf1BEfvNTHE8B/GrgP4ox/ipgR0qhPaXx6IeIVCi333/2hV76do0n1ca+Dfgq4L3AQkT+5acxlrfFTg7tmbRniSLrTRF5CSD9ey8df9vHKCIl6sz+Uozxrz7t8YyW0lc/itYUnsZ4fhPwz4vIJ9F09D8tIv/pUxoLAKPEfIzxHlof+rVPcTyvAq+mCBrg+1AH97Tnzu8E/kGM8c30+9MYz28DPhFjvB9jHIC/CvzGpzSWkx3Z8+zQMkVW2tV9GPj+pzSW7wd+X/r/7wP+2tHxD4tILUrl9UHg7z2pDxURQWsgPxtj/LPPwHjuishF+v8MXRh+7mmMJ8b4x2KM74sxfgCdG/91jPFffhpjARCRhYisxv8Dvx34yNMaT4zxDeDTogSxoHWrn3la4zmy38uUbhw/950ezyvArxeRefqO/Va0Pv20780TsKjUV0/i5ynYc9tY/SVQZD0RE5G/AvwWVK31VVTD5zuA7xWR349+Gf6FNMafFpHvRRcKB/zBGKN/gsP5TcC/AvxUqlsB/G+f4nheAr47IbwM8L0xxr8hIv/dUxrPW9nTujcvAv+5ro8UwF+OMf6AiPz9pzQegH8L+EtpQ/hx4H9Bem5PYzwiMkeFff/1o8Pv+POKMf5dEfk+4B+kc/9DlOpq+U6P5YlbhPgMyMd8qXaivjrZyU52spMBcF7cjb/h7Hc9kXP94NWff8epr57nlOPJTnayk53sy8ie25TjyU52spOd7Euwd3HW7uTQTnayk53sZGoxPjWWjydhp5TjyU52spOd7LmwU4R2spOd7GQnm+yUcjzZyU52spM9DxZPKceTnexkJzvZyZ6unRzayb7sTUR+VERi+vkj6difSr///Od4z8fS3//U2ziu3yMibyQ2CkTkwyLSJTqzz/WeP3V0Ld/3do3tZM+rPSEexxOX48lO9lTtbwK/AeV1HK0FvkpEHmsOFZF/EvjK9Pe3074V+P/Gif3gQ8BHEn/g57I/j17HP3ybx3ay59Ei72rqq5NDO9nJ1B7FGP9O4jAcbQf81yjX47F9OB3fvV2DERGDEjf/F0eHv4Uv4KhijK/GGP8O8PlUFU52sufSTg7tZM+Nicj/KKXafufRsa8SkXsi8ue+xNN+D/B7jtJ+AvweHo/kxs/6LhH5cRH5XSLycyLSish/I2+hlC4iv1lE/qaIbEXkJqU9f9XRS/5J4BL4oaNjHwJ+VkT+fRF5Lb3vP0nO72QnezIWw5P5eQp2+iKc7LmxGOPfQlOHfwJARM6Bv4Eym//RL/G0fxUlDv4fpN//h8BdVN7lrewrgT8L/GngXwTOgR8UkWZ8gYj8FuBHgAFlZf+fAT/G46KP3wr82KhfJyJ3UXLnfwuYAf8qKjL5r/EOKLGf7MvDIhBDfCI/T8NOsP2TPW/2J4G/LSK/Hfi3Uafx4S+V3TzGeC0iP4CmGX8s/fsD6fhbveUO8G0xxv8fgIj8BPALqAP6j9Nr/vfAfw/8s0f1sR/4rPN8K/CXjn7/lvTvnzuSAvohEflfo3IkJzvZl72dIrSTPVcWY/wx4IfRCOqbgH8uxrj9ZZ72e4DfLSI18Lt5i3Tjkd0bnVkaz6eAn0DFOkets18HfHf8HFIXSRzyV/F4/exDwDXwfz56nQAXwINf8hWd7GRvZTGeUo4nO9kzZh8D5sCfjDG++gTO9/2o1tWfARbAX/88r733OY69lP5/CQjw+uc5x/8Y+HiM8aNHxz4E/K3PQjh+DZp+fNt1/k725WPv5pTjyaGd7LkyEfkDwP8STen9a0/inDHGHVqL+6PAX0+/fy574XMcGx3YFRCYHNxb2bfyeHQGmnL8yc869qF0ro98nnOd7GRfNnZyaCd7bkxE/hng/wL8r4B/A/h1x4jHX6b9R2hk9h9/gde9ICK/8WhMXwH8ahSYMjrHvwv8z+UtinBJHfq3ceTQ0rFfiTrpY/tmNJJ729oHTvZlaO/ilOMJFHKy58JE5BuB/wz4P8QY/2I69sPAvwf8l7/c88cYfxT40S/ipQ+A/6eI/AngAPzv0JTjdx295tvROt9/KSLfifaz/Qbgx9FmbQP8raPXfyP6Xf3sCO2b3+LYyU72JduGqx/84fh9d57Q6d7x2u7JoZ3sXW8i8gKaEvwhEmQ/2Z8G/paIfGuM8bNTeG+XfQr494HvQCH8Pw783hhjZhWJMf7tFE3+aeA/BXq0Yfr/g8L4fzjG2B2d80PAHkVLHts3A3/x7bmMk305WozxdzztMfxyTD4H0OpkJ/uyMRH5UeAh2g/mPxf68Is4z3cB3xRj/DVf6LWf5xz/GPgPYoz/yZf4foNGeD8C3I8x/u4vdSwnO9m7zU41tJOdTO1/gvas/eGnOYgY46/4Up1Zsn8XvY7f/ISGdLKTvWvslHI82cngXwdW6f+vPM2BPAH7TjT9CvDoaQ7kZCd7p+2UcjzZyU52spM9F3ZKOZ7sZCc72cmeCzs5tJOd7GQnO9lzYSeHdrKTnexkJ3su7OTQTnayk53sZM+FnRzayU52spOd7Lmwk0M72clOdrKTPRd2cmgnO9nJTnay58L+/5+itM+CNy4oAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def read_grid(prefix):\n", + " f = open(prefix+\"_0.dat\", \"rb\")\n", + " nfiles, size_float = np.fromfile(f, dtype=np.int32, count=2)\n", + " lbox = np.fromfile(f, dtype=np.float64, count=1)[0]\n", + " ngrid = np.fromfile(f, dtype=np.int32, count=1)[0]\n", + " f.close()\n", + "\n", + " if size_float == 4:\n", + " f_type = np.float32\n", + " else:\n", + " f_type = np.float64\n", + "\n", + " grid_out = np.zeros([ngrid, ngrid, ngrid])\n", + " for ifil in np.arange(nfiles):\n", + " f = open(prefix+\"_%d.dat\" % ifil, \"rb\")\n", + " nf, sz = np.fromfile(f, dtype=np.int32, count=2)\n", + " _ = np.fromfile(f, dtype=np.float64, count=1)\n", + " ng, nz_here, iz0_here = np.fromfile(f, dtype=np.int32, count=3)\n", + " for iz in np.arange(nz_here):\n", + " d = np.fromfile(f, dtype=f_type, count=ng*ng).reshape([ng, ng])\n", + " grid_out[iz0_here+iz, :, :] = d\n", + " f.close()\n", + "\n", + " return ngrid, lbox, np.array(grid_out)\n", + "\n", + "ng, lb, dens = read_grid('output/colore_dens_lightcone')\n", + "_, _, densG = read_grid('output/colore_dens_gaussian')\n", + "print(\"Ngrid = %d\" % ng)\n", + "print(\"Lbox = %.3lf Mpc/h\" % lb)\n", + "\n", + "\n", + "plt.figure(figsize=(7, 7))\n", + "plt.title(r'$\\log_{10}(1+\\delta)$', fontsize=15)\n", + "plt.imshow(np.log10(1.001+dens[ng//2, :, :]),\n", + " origin='lower',\n", + " interpolation='nearest',\n", + " vmin=-1, extent=[0, lb, 0, lb])\n", + "plt.colorbar()\n", + "plt.xlabel(r'$x\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", + "plt.ylabel(r'$y\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", + "\n", + "plt.figure(figsize=(7, 7))\n", + "plt.title(r'$\\delta_G$', fontsize=15)\n", + "plt.imshow(densG[ng//2, :, :], origin='lower',\n", + " interpolation='nearest',\n", + " extent=[0, lb, 0, lb])\n", + "plt.colorbar()\n", + "plt.xlabel(r'$x\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", + "plt.ylabel(r'$y\\,\\,[{\\rm Mpc}/h]$', fontsize=15);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6709bf8e-92dd-4af9-9964-e79413199de7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Bacon (BNL Astro Conda) latest", + "language": "python", + "name": "bacon" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/.ipynb_checkpoints/param_example-checkpoint.cfg b/.ipynb_checkpoints/param_example-checkpoint.cfg new file mode 100644 index 0000000..9935fc5 --- /dev/null +++ b/.ipynb_checkpoints/param_example-checkpoint.cfg @@ -0,0 +1,149 @@ +global: +{ + #Output prefix. Output will be in prefix_. + prefix_out= "examples/simple/out"; + #Output format. Select HDF5, FITS or ASCII + output_format= "FITS"; + #Output Gaussian overdensity field at z=0? + output_density= true + #Path to power spectrum at z=0. Power spectrum file must + #be in CAMB format: k (h/Mpc), P(k) (Mpc/h)^3. + pk_filename= "examples/simple/Pk_CAMB_test.dat" + #This redshift range also defines the size of the box + z_min= 0.001 + z_max= 0.450 + #RNG seed note that output will depend on number of nodes, etc not only + #on the RNG seed + seed= 1003 + #Set to true if you want to generate the theory prediction for the 3D power spectrum + #of the different tracers. + write_pred=false + #Intervals of redshift at which the prediction will be produced. + pred_dz=0.1 + #If write_pred is true, set this to true if you just want to generate the prediction + #and then exit. This is also useful if you want to inspect the memory requirements + #before a run. + just_write_pred= true +} + +field_par: +{ + #Extra Gaussian smoothing scale [Mpc/h] (set to a + #negative value if you don't want any smoothing) + r_smooth= 5. + #Do you want to smooth the Newtonian potential as well? + smooth_potential= true + #Will use a Cartesian grid with n_grid^3 cells + n_grid= 256 + #Density field type + # 0-lognormal + # 1-1LPT + # 2-2LPT + dens_type= 1 + #If dens_type==1 or 2, buffer size (fraction per particle) + lpt_buffer_fraction= 0.6 + #If dens_type==1 or 2, scheme to interpolate particle + #positions into a grid + # 0-NGP + # 1-CIC + # 2-TSC + lpt_interp_type= 1 + #Set to 1 if you want to output the LPT particle positions + output_lpt= 0 +} + +cosmo_par: +{ + #Non-relativistic matter + omega_M= 0.3 + #Dark energy + omega_L= 0.7 + #Baryons + omega_B= 0.05 + #Hubble parameter (in units of 100 km/s/Mpc) + h= 0.7 + #Dark energy equation of state + w= -1.0 + #Primordial scalar spectral index, used only to extrapolate + #P(k) at low k end (-3 used at high k end) + ns= 0.96 + #Power spectrum normalization. The input power spectrum will be + #renormalized to this sigma8 + sigma_8= 0.803869 +} + +#For each galaxy population, create a section called srcsX, starting with X=1 +srcs1: +{ + #Path to N(z) file. Should contain two columns + # 1-> z, 2-> dN(z)/dz*dOmega + # with dN/dzdOmega in units of deg^-2 + nz_filename= "examples/simple/Nz_test.txt" + #Path to bias file. Should contain two columns + # 1-> z, 2-> b(z) + bias_filename= "examples/simple/Bz_test.txt" + #Do you want to include shear ellipticities? + include_lensing= true + #Do you want to store line-of-sight skewers for each object? + store_skewers= true + #You can also store the Gaussian density field (instead of the non-Gaussian one) + #This is false by default. + gaussian_skewers= false +} + +srcs2: +{ + nz_filename= "examples/simple/Nz2_test.txt" + bias_filename= "examples/simple/Bz2_test.txt" + include_lensing= false + store_skewers= true +} + +#For each intensity mapping species, create a section called imapX, +#starting with X=1 +imap1: +{ + #Tabulated background temperature as a function of redshift + tbak_filename= "examples/simple/Tz_test.txt" + #Tabulated linear bias as a function of redshift + bias_filename= "examples/simple/Bz_test.txt" + #Frequency bands in which to output maps. Should contain 2 columns: + # 1-> nu_ini, 2-> nu_end + freq_list= "examples/simple/nuTable.txt" + #Rest-frame frequency of this species (in the same units as the + #frequencies in freq_list). + freq_rest= 1420.405 + #HEALPix resolution parameter. + nside= 64 +} + +#Include a section entitled kappa if you want to generate maps +#of the lensing convergence at specific redshifts. +kappa: +{ + #Redshifts at which maps should be generated + z_out= [0.4] + nside= 64 +} + +#Include a section entitled isw if you want to generate maps +#of the ISW effect (time derivative of the gravitational potential). +isw: +{ + z_out= [0.4] + nside= 64 +} + +#This section is needed if using the fast lensing method +lensing: +{ + # Maximum Nside used for the lensing shells. + nside= 256 + # Select number of slices. + n_lensing= 11 + # Select spacing type ("r" or "log(1+z)"). + spacing_type= "r" + # Set to true if you want to output the different + # lensing shells. + write=false +} diff --git a/Makefile b/Makefile index fa7e3ff..01fbfb7 100644 --- a/Makefile +++ b/Makefile @@ -3,7 +3,7 @@ ###Compiler and compilation options COMP_SER = gcc COMP_MPI = mpicc -OPTIONS = -Wall -Wno-format-overflow -O3 -std=c99 +OPTIONS = -Wall -Wno-format-overflow -O3 -std=c99 # ### Behavioural flags #Use double precision integer (enable in general) @@ -14,6 +14,8 @@ DEFINEFLAGS += -D_BIAS_MODEL_2 #DEFINEFLAGS += -D_BIAS_MODEL_3 #Use new lensing method #DEFINEFLAGS += -D_USE_FAST_LENSING +#get transvers velocities +DEFINEFLAGS += -DTVEL #Generate debug help. Only useful for development DEFINEFLAGS += -D_DEBUG #Use double precision floating point? Set to "yes" or "no" @@ -25,7 +27,7 @@ USE_HDF5 = no #Use OMP parallelization? Set to "yes" or "no" USE_OMP = yes #Use MPI parallelization? Set to "yes" or "no" -USE_MPI = yes +USE_MPI = no # ###Path to libraries and headers ###If two or more of the dependencies reside in the same paths, only @@ -33,8 +35,8 @@ USE_MPI = yes #GSL #GSL_INC = -I/add/path #GSL_LIB = -L/add/path -GSL_INC = -I/home/alonso/include -GSL_LIB = -L/home/alonso/lib +GSL_INC = -I/astro/u/anze/local/include +GSL_LIB = -L/astro/u/anze/local/lib #FFTW FFTW_INC = FFTW_LIB = diff --git a/example_CoLoRe.ipynb b/example_CoLoRe.ipynb index 2a66ec5..f189c81 100644 --- a/example_CoLoRe.ipynb +++ b/example_CoLoRe.ipynb @@ -94,7 +94,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -152,7 +152,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmOklEQVR4nO3deXxU5d3+8c83e9gSVtkFBBdQQIgBQm2rti7toyggAiqgIhK0/fnYVu3TRYu2fdRWqxWCIChaFSigpeojdalaCQECsiMQQAGRRfbFsH5/f8xoYxokA5k5meR6v155MXPOPck1IeHizDn3PebuiIiIlFdC0AFERCS+qDhERCQiKg4REYmIikNERCKi4hARkYgkBR0g2ho0aOCtWrUKOoaISFyZP3/+5+7esKx9Vb44WrVqRWFhYdAxRETiipl9crx9eqlKREQiouIQEZGIqDhERCQiKg4REYmIikNERCKi4hARkYioOEREJCIqDhERiYiKQ0REIqLiEBGRiKg4REQkIioOERGJiIpDREQiouIQEZGIqDhERCQigRSHmV1uZivNrMjM7i1j/7fNbIGZHTGzvqX2DTaz1eGPwbFLLSIiEEBxmFkiMAq4AmgPDDCz9qWGrQeGAC+Wemw94D6gG5AN3GdmdaOdWURE/i2II45soMjd17r7IWAS0KvkAHf/2N0XA8dKPfYy4E133+HuO4E3gcu/6Yut33GAA4eOVFx6EZFqLojiaAZsKHF/Y3hbhT3WzIaZWaGZFe7+4jD9xxbw+b6DJx1YRET+rUqeHHf3se6e5e5Zp9evwaote+k9Op91n+8POpqISNwLojg+BVqUuN88vC0qj62TlsykYT3Yd/AIffLy+XD9zojCiojI1wVRHPOAdmbW2sxSgP7AjHI+diZwqZnVDZ8UvzS87Rt1bpHJ9NwcaqclMWBcAW8u33LS4UVEqruYF4e7HwHuIPQP/gpgirsvM7ORZnYVgJldYGYbgWuBp8xsWfixO4AHCJXPPGBkeNsJtWpQk2m5OZx1Wm1ue76QvxR8UvFPTkSkGjB3DzpDVGVlZXlhYeFX9w8cOsKPXvyQtz/ayojvnsHPLjsLMwswoYhI5WNm8909q6x9VfLk+DepkZLEUzd2ZUB2S0a/u4afTFnEoSOlr/oVEZHjSQo6QBCSEhP43TXn0jQjjT++uYqtew+Sd0MXaqclBx1NRKTSq3ZHHF8yM350STse6duRgrXb6fdUAVv2FAcdS0Sk0qu2xfGla7NaMH7IBazfvp/eo/NZvWVv0JFERCq1al8cAN85syGTb+vBoaPH6JOXz9x15bpQS0SkWlJxhJ3bLIPpuTk0qJ3KDePn8PqSz4KOJCJSKak4SmhRrwbThufQsVkGt7+4gPEfrAs6kohIpaPiKKVuzRT+MrQbl7VvzAOvLufBV5dz7FjVnusiIhIJFUcZ0pITGXV9F4bktOLpD9bx40kfcvDI0aBjiYhUCtVyHkd5JCYY913ZnqaZafzu9Y/YtvcgY2/MIqOG5nqISPWmI45vYGYM+/YZPN6/MwvW7+Tap/LZtOuLoGOJiARKxVEOvTo3Y+LN2Xy2u5hrRs9ixWd7go4kIhIYFUc55ZzRgL8O74Fh9Bszm/yiz4OOJCISCBVHBM5uXIeXb8+haWY6g5+Zy98Wlvf9p0REqg4VR4SaZKQzZXgPup5el/83aSF5766hqi9NLyJSkorjJGSkJzPx5myu7NSUh974iPtmLOOo5nqISDWhy3FPUmpSIo9f15mmGWk89f5aNu8u5okB55OWnBh0NBGRqNIRxylISDB+/oNzuP/K9ry5YgsDxxWwY/+hoGOJiESViqMCDOnZmtEDu7B00x765uWzfvuBoCOJiESNiqOCXHFeE14c2o3t+w/RO28WSzbuDjqSiEhUqDgqUFarekzLzSE1KZHrxs7mnyu3Bh1JRKTCqTgqWNtGtXh5RA6tG9Rk6MRCpszbEHQkEZEKpeKIgkZ10ph8Ww9yzqjP3dMW86e3Vmmuh4hUGSqOKKmVmsSEIRfQt2tz/vTWan4+fQlHjh4LOpaIyCnTPI4oSk5M4JG+HWmakcYT7xSxZU8xTw7sQs1UfdtFJH7piCPKzIy7Lj2L311zHu+t2saAcQVs23sw6FgiIidNxREjA7u1ZNygLFZv2UefvHzWbtsXdCQRkZOi4oihS845jZeGdWf/wSP0yctnwfqdQUcSEYmYiiPGOrfIZFpuDhnpyQwcV8Cby7cEHUlEJCIqjgC0alCTabk5nNW4Drc9X8jzBZ8EHUlEpNxUHAGpXyuVl27txkVnNeJXryzl4Tc+0lwPEYkLgRSHmV1uZivNrMjM7i1jf6qZTQ7vn2NmrcLbk81sopktMbMVZvbzmIevQDVSknjqxq4M7NaS0e+u4SdTFnHoiOZ6iEjlFvPiMLNEYBRwBdAeGGBm7UsNuwXY6e5tgceAh8LbrwVS3f08oCtw25elEq+SEhP47dXn8tNLz2T6h59y87Pz2Ft8OOhYIiLHFcQRRzZQ5O5r3f0QMAnoVWpML2Bi+PZU4BIzM8CBmmaWBKQDh4A9sYkdPWbGHRe34w/XdqJg7XauHTObLXuKg44lIlKmIIqjGVBy5b+N4W1ljnH3I8BuoD6hEtkPfAasB/7g7jtKfwEzG2ZmhWZWuG3btop/BlHSt2tzJgy5gA07DnDNqFms3rI36EgiIv8h3k6OZwNHgaZAa+AnZtam9CB3H+vuWe6e1bBhw1hnPCXfPrMhk2/rweFjTp+8fOas3R50JBGRrwmiOD4FWpS43zy8rcwx4ZelMoDtwEDgDXc/7O5bgVlAVtQTx9i5zTKYnptDw9qp3Dh+Lq8t/izoSCIiXwmiOOYB7cystZmlAP2BGaXGzAAGh2/3Bd7x0LWq64GLAcysJtAd+CgmqWOsRb0aTMvNoWPzDO54aQHjP1gXdCQRESCA4gifs7gDmAmsAKa4+zIzG2lmV4WHjQfqm1kRcBfw5SW7o4BaZraMUAE94+6LY/sMYiezRgp/GdqNy9o35oFXl/PAq8s5dkxzPUQkWFbVJ51lZWV5YWFh0DFOydFjzgOvLufZ/I/5Yccm/PHaTqQlJwYdS0SqMDOb7+5lngrQG0PEgcQE474r29MsM53fvr6CbXsPMu7GLDJqJAcdTUSqoXi7qqraMjNu/XYbnhhwPgvX76LvmHw+3fVF0LFEpBpSccSZqzo1ZeLN2WzeU0zv0bNYvinu5z+KSJxRccShHmfUZ+rwHBLM6PfUbGYVfR50JBGpRlQcceqsxrWZPiKH5nXTGfLMXF75sPRUGBGR6FBxxLEmGelMGd6DrNPrcefkhYx+t0hLs4tI1Kk44lydtGSevfkCrurUlIffWMmv/7aMo5rrISJRpMtxq4DUpET+dF1nmmSm8dR7a9myp5gnBpyvuR4iEhU64qgiEhKMn19xDr+5qgNvrtjCwHEF7Nh/KOhYIlIFqTiqmME5rci7vgvLNu2hT14+67cfCDqSiFQxKo4q6PJzm/DC0G7sPHCI3nmzWLxxV9CRRKQKUXFUUVmt6jF1eA5pyYn0H1vAP1duDTqSiFQRKo4qrG2jWkwfkUPrBjUZOrGQyfPWBx1JRKoAFUcV16h2GpNv60HPtg24Z9oSHntzleZ6iMgpUXFUA7VSkxg/OIu+XZvz+NuruXfaEg4fPRZ0LBGJU5rHUU0kJybwSN+ONM1I44l3itiyt5hRA7tQM1U/AiISGR1xVCNmxl2XnsXvrjmP91dto//YArbtPRh0LBGJMyqOamhgt5aMG5RF0dZ99M6bxdpt+4KOJCJxRMVRTV1yzmlMGtadAweP0icvn/mf7Aw6kojECRVHNdapRSbTR+SQkZ7MwHEF/GPZ5qAjiUgcUHFUc6fXr8m03BzOaVKH4X+Zz/MFnwQdSUQqORWHUL9WKi/d2p2Lz27Er15ZykNvfKS5HiJyXCoOASA9JZExN3RlYLeW5L27hrumLOLQEc31EJH/pIv45StJiQn89upzaZaZziMzV7Jt70HybuhC7bTkoKOJSCWiIw75GjPj9ova8sdrO1GwdjvXjpnNlj3FQccSkUpExSFl6tO1OROGXMCGHQe4ZtQsVm3ZG3QkEakkVBxyXN8+syFThvfg8DGnb14+BWu3Bx1JRCoBFYd8ow5NM3h5RA4Na6cyaPxcXl28KehIIhIwFYecUPO6NZiWm0OnFhnc8eKHPP2vtUFHEpEARVwcZpZqZq3NrL2ZNYxGKKl8Mmuk8Pwt3bji3MY8+NoKRv59OceOaa6HSHVUruIws9pmlmtm7wO7gSJgKbDZzNab2Tgzu6C8X9TMLjezlWZWZGb3lrE/1cwmh/fPMbNWJfZ1NLPZZrbMzJaYWVp5v66cmrTkRJ4c2IUhOa2YMGsdP3rpQ4oPHw06lojE2AmLw8zuAj4GbgbeBHoBnYEzgR7A/YTmg7xpZm+YWbsTfL5EYBRwBdAeGGBm7UsNuwXY6e5tgceAh8KPTQL+Agx39w7Ad4HDJ36aUlESE4z7rmzPL35wDq8t+YxBE+ay+4D+CkSqk/IccXQHvuPuF7j7A+4+092XuHuRu8919wnufhPQGJgBfOcEny8bKHL3te5+CJhEqIxK6gVMDN+eClxiZgZcCix290UA7r7d3fVf3hgzM279dhueGHA+C9fvos+YfD7d9UXQsUQkRk5YHO7ez92XApjZ/WbW+jjjit19tLs/fYJP2QzYUOL+xvC2Mse4+xFCL4/VJ3SU42Y208wWmNndZX0BMxtmZoVmVrht27YTPUU5SVd1asrEm7PZsqeYa0bNYvmmPUFHEpEYiPTk+K+BD8ysbcmN4XMSF1VcrONKAr4FXB/+8xozu6T0IHcf6+5Z7p7VsKHO30dTjzPqM3V4DokJRr+nZvPB6s+DjiQiUXYyl+O+CPzTzM4osS0TeKucj/8UaFHifvPwtjLHhM9rZADbCR2dvO/un7v7AeB1oEukT0Aq1lmNa/PyiJ40r5vOkGfm8vKHG4OOJCJRFGlxOPAI8CSh8ij5spWV83PMA9qFL+lNAfoTOjdS0gxgcPh2X+AdD63zPRM4z8xqhAvlO8DyCJ+DREHjjDSmDO9Bdut6/PfkRYx+t0hLs4tUUSc1AdDdHwLygPdKXCpbrn8lwucs7iBUAiuAKe6+zMxGmtlV4WHjgfpmVgTcBdwbfuxO4FFC5bMQWODur53Mc5CKVyctmWdvyqZX56Y8/MZKfvW3pRzVXA+RKifSZdW/Oqpw99+HL619l9BRQ7m5++uEXmYque3XJW4XA9ce57F/IXRJrlRCKUkJPNavM00y0hnz3hq27DnIE/3PJz0lMehoIlJBIj3iuAfY/+Udd38QmAD8vSJDSXxLSDDuveJsRvbqwFsrtjDw6QJ27D8UdCwRqSARFYe7P+Lu+0ttGwk8DmjdbfmaQT1akXd9V5Zv2kOfvHzWbz8QdCQRqQAVssihuz/o7pkV8bmkarn83Ma8eGs3dh44RO+8WSzeuCvoSCJyisqz5EiZE/6OM9bMrMWJR0p10vX0ekzLzSEtOZH+Ywv450dbg44kIqegPEccs81svJn1ON4AM6trZrmELo0tvXyICGc0rMX0ETm0aViToc8VMnne+qAjichJKs9VVWcDvwBeM7NjwHxgE1AM1CW0UOE5wFzgTnefGaWsEuca1U5j0rAejHhhAfdMW8KmXcXc+b12hJYhE5F4UZ61qnYRWp22GTCc0NyLTKA1cITQYoTnu3tPlYacSK3UJMYPzuLars15/O3V3DNtMYePHgs6lohEoLzzONYTKohH3X1qFPNINZCcmMDDfTvSJDOdJ95ezZY9Bxl9fRdqpkY6rUhEglDeq6puAboCK8zsZTPrGcVMUg2YGXd9/0x+3/s8Pij6nP5jC9i292DQsUSkHMpVHO7+krtnAxeHH/Ne+F34+pheoJZTMCC7JeMGdaVo6z56581izbZ9QUcSkROIdALg++7ei9DJ8AWEXr5abWa3m1l6NAJK1Xfx2acxaVh3Dhw8St+8fOZ/sjPoSCLyDU52kcPV7n47oaXPJwIjCZ0HETkpnVpkMn1EDhnpyQwcV8DMZZuDjiQix1Gu4jCzUWb2gpm9amYfmNkSM9sAfAL8htBlufWjGVSqvtPr12Rabg7nNKlD7l/m8/zsj4OOJCJlKO9lLLmE5m2MAwoJvZXrnvDH7hJ/ipyS+rVSeenW7vzopQ/51d+W8emuYu6+7CwSEnQqTaSyKO9LVVnAK8BtwNXAVnd/190XuPsad9/m7lr+VCpEekoiY27owvXdWjLmvTXcNWUhh45orodIZVHeq6oWuPtAoB2hl6dmmtm/zOzKqKaTaispMYEHrz6Xn112Fq8s3MRNz85lT/HhoGOJCJFfVbXB3e8CWhJ6e9dRZrbCzG4Jvw2sSIUxM26/qC2P9uvEnLU76DdmNpt3FwcdS6TaO9mrqnYDfyA0KfAF4GHg44qLJfJvvbs055mbLmDjzi/oPXoWq7borV9EglTeq6peK3E11Xoz201onarNhC7FrQs0jmJOqeYubNeQybd158gxp29ePgVrtwcdSaTaKu8Rx1ZgHvBXQkcadxA6Sf5doCOhl65qV3w8kX/r0DSD6SNyaFQnjUHj5/Lq4k1BRxKplsp1Oa673xTtICLl0bxuDaYO78Gw5+Zzx4sfsnl3MUMvbBN0LJFqpULeOlYkljJrpPDcLdn84LzGPPjaCkb+fTnHjnnQsUSqDRWHxKW05ESeHNCFm3q2YsKsddzx0gKKDx8NOpZItaA3QJC4lZBg3HdlB5plpvPgayv4fO9cxg7qSmYNXRkuEk064pC4N/TCNvx5wPks3LCLvmNms3HngaAjiVRpKg6pEq7s1JSJN2ezZU8xvUfns2yTlk4TiRYVh1QZPc6oz7TcHBITjOueKuBfq7cFHUmkSlJxSJVy5mm1eXlET5rXTeemZ+YxfcHGoCOJVDkqDqlyGmekMWV4D7Jb1+OuKYsY9c8i3HW5rkhFUXFIlVQnLZlnb8rm6s5NeWTmSn71t6Uc1VwPkQqhy3GlykpJSuDRfp1pkplO3rtr2Lz7IH8ecD7pKYlBRxOJa4EccZjZ5Wa20syKzOzeMvanmtnk8P45Ztaq1P6WZrbPzH4as9ASlxISjHsuP5uRvTrw9kdbGPh0ATv26z3HRE5FzIvDzBKBUcAVQHtggJm1LzXsFmCnu7cFHgMeKrX/UeD/op1Vqo5BPVox5oauLN+0hz55+XyyfX/QkUTiVhBHHNlAkbuvDb/d7CSgV6kxvYCJ4dtTgUvMzADM7GpgHbAsNnGlqrisQ2NevLUbOw8cok9ePos27Ao6kkhcCqI4mgEbStzfGN5W5hh3PwLsBuqbWS3gHuA33/QFzGyYmRWaWeG2bbqWX/6t6+n1mJabQ3pKIv3HFvDPj7YGHUkk7sTbVVX3A4+5+75vGuTuY909y92zGjZsGJtkEjfOaFiLabk5tG1Ui6HPFTJ53vqgI4nElSCK41OgRYn7zcPbyhxjZklABrAd6AY8bGYfA3cC/2Nmd0Q5r1RBjWqnMWlYd77VtgH3TFvCY2+u0lwPkXIKojjmAe3MrLWZpQD9gRmlxswABodv9wXe8ZAL3b2Vu7cC/gT8zt2fjFFuqWJqpibx9OAsru3anMffXs3dUxdz+OixoGOJVHoxn8fh7kfCRwkzgURggrsvM7ORQKG7zwDGA8+bWRGwg1C5iFS45MQEHu7bkaaZ6Tz+9mq27j3I6Ou7UDNVU5xEjseq+uF5VlaWFxYWBh1D4sCkuev5xStLOadJbSYMuYBGtdOCjiQSGDOb7+5ZZe2Lt5PjIlHTP7slTw/KYs3W/fQenc+abd94DYZItaXiECnhorMbMWlYd744dJQ+efnM/2RH0JFEKh0Vh0gpnVpkMn1EDnVrpDBw3BzeWLo56EgilYqKQ6QMp9evydThPTinSR1yX5jPc7M/DjqSSKWh4hA5jvq1Unnp1u5ccvZp/Ppvy/jf//uIY1qaXUTFIfJN0lMSGXNDF27o3pIx763hrikLOXREcz2ketPF6iInkJSYwAO9zqVpZjoPv7GSrXsPMubGrtRJSw46mkggdMQhUg5mxojvtuXRfp2Yu24H/cbMZvPu4qBjiQRCxSESgd5dmvPsTdls3PkF14yexaote4OOJBJzKg6RCH2rXQMm39ado8ecPnn5FKzdHnQkkZhScYichA5NM3j59p6cVieNQePn8vdFm4KOJBIzKg6Rk9QsM51pw3Po3CKTH730IU//a23QkURiQsUhcgoyaiTz3C3Z/PC8Jjz42gpG/n255npIlafLcUVOUVpyIn8ecD6n1Uljwqx1bN7zBY/260xacmLQ0USiQsUhUgESEoxfX9mepplpPPjaCrbtncO4QVlk1kgJOppIhdNLVSIVaOiFbXhy4Pks2rCbvmNms3HngaAjiVQ4FYdIBfuvjk157pZstu4p5prR+SzbtDvoSCIVSsUhEgXd29Rnam4OyQlGvzGz+dfqbUFHEqkwKg6RKDnztNpMH9GTFvVqcNMz85g2f2PQkUQqhIpDJIoaZ6QxZXgPurWpx0/+uohR/yzCXZfrSnxTcYhEWZ20ZJ4Zks3VnZvyyMyV/PKVpRw5qqXZJX7pclyRGEhJSuDRfp1pkplO3rtr2LKnmD8P6EJ6iuZ6SPzREYdIjCQkGPdcfjYP9OrAOx9tZcC4ArbvOxh0LJGIqThEYuzGHq0Yc0NXVny2hz55+XyyfX/QkUQiouIQCcClHRrz4q3d2f3FYXqPzmfRhl1BRxIpNxWHSEC6nl6Xabk51EhNpP/YAt75aEvQkUTKRcUhEqA2DWsxPbcnbRvV4tbn5jNp7vqgI4mckIpDJGANa6cyaVh3LmzXgHunL+HRN1dprodUaioOkUqgZmoS4wZl0S+rOU+8vZq7py7msOZ6SCWleRwilURyYgIP9elI08x0/vTWarbuPcjo67tQM1W/plK5BHLEYWaXm9lKMysys3vL2J9qZpPD++eYWavw9u+b2XwzWxL+8+KYhxeJIjPjzu+dyUN9zuODos+5buxstu4tDjqWyNfEvDjMLBEYBVwBtAcGmFn7UsNuAXa6e1vgMeCh8PbPgSvd/TxgMPB8bFKLxNZ1F7Tk6UFZrNm6n96j81mzbV/QkUS+EsQRRzZQ5O5r3f0QMAnoVWpML2Bi+PZU4BIzM3f/0N03hbcvA9LNLDUmqUVi7KKzGzH5tu4UHz5Kn7x8Cj/eEXQkESCY4mgGbChxf2N4W5lj3P0IsBuoX2pMH2CBu//Hmg1mNszMCs2scNs2vQ+CxK+OzTOZntuTujVSuP7pObyxdHPQkUTi86oqM+tA6OWr28ra7+5j3T3L3bMaNmwY23AiFaxl/RpMy82hfdM65L4wn4n5HwcdSaq5IIrjU6BFifvNw9vKHGNmSUAGsD18vznwMjDI3ddEPa1IJVCvZgovDu3O9845jftmLOP3/7eCY8c010OCEURxzAPamVlrM0sB+gMzSo2ZQejkN0Bf4B13dzPLBF4D7nX3WbEKLFIZpKckMuaGrtzQvSVPvbeW/56ykINHjgYdS6qhmBdH+JzFHcBMYAUwxd2XmdlIM7sqPGw8UN/MioC7gC8v2b0DaAv82swWhj8axfgpiAQmMcF4oNe53H35Wfxt4SaGTJjHnuLDQceSasaq+tIGWVlZXlhYGHQMkQo3fcFG7p66mLaNavHMTRfQJCM96EhShZjZfHfPKmtfXJ4cFxHo3aU5z96UzcadX9B7dD4rN+8NOpJUEyoOkTj2rXYNmHJbD46503dMPrPXbA86klQDKg6RONe+aR2mj+hJ4zppDJ4wlxmLNp34QSKnQMUhUgU0y0xn6vAcOrfM5Mcvfci499dqaXaJGhWHSBWRUSOZ527O5ocdm/Db11cw8tXlHNVcD4kCrdcsUoWkJSfy5/7n07hOGuM/WMfm3cU8dl1n0pITg44mVYiOOESqmIQE41f/1Z5f/vAc3li2mRvHz2HXgUNBx5IqRMUhUkUNvbANTw7owqINu+k7ZjYbdx4IOpJUESoOkSrshx2b8Pwt2WzdU8w1o/NZ+unuoCNJFaDiEKniurWpz9TcHJITjOuems37q/RWA3JqVBwi1cCZp9Xm5dt70qJeDW5+dh5T528MOpLEMRWHSDVxWp00/jq8B93a1OOnf13Ek++s1lwPOSkqDpFqpHZaMs8Myeaa85vxh3+s4hevLOXI0WNBx5I4o3kcItVMSlICj/brROOMNPLeXcPWPcU8MeB8aqTonwMpHx1xiFRDZsY9l5/NA7068M5HWxkwbg7b9x0MOpbECRWHSDV2Y49WjLmhKx99toc+efl8sn1/0JEkDqg4RKq5Szs05sVbu7P7i8P0Hp3Pwg27go4klZyKQ0ToenpdpuXmUCM1kQFjC3h7xZagI0klpuIQEQDaNKzF9NyetDutFrc+V8hLc9cHHUkqKRWHiHylYe1UXrq1O985syE/n76ER/+xUnM95D+oOETka2qmJjFuUBbXZbXgiXeK+NnUxRzWXA8pQRdui8h/SEpM4H/7nEeTzDT+9NZqtu49yOjru1ArVf9kiI44ROQ4zIw7v3cmD/fpyKyiz+k/djZb9xYHHUsqARWHiHyjfhe04OnBWazdtp/eo/NZs21f0JEkYCoOETmhi85qxKRh3Sk+fJQ+efkUfrwj6EgSIBWHiJRLx+aZTM/tSd0aKVz/9BzeWPpZ0JEkICoOESm3lvVrMC03hw5N65D7wgKenbUu6EgSABWHiESkXs0UXhjane+fcxr3/305v399BceOaa5HdaLiEJGIpackkndDV27sfjpPvb+WOycv5OCRo0HHkhjRRdkiclISE4yRvTrQNDOdh974iG17DzLmxq5kpCcHHU2iTEccInLSzIzc757BY9d1ovCTHfQbM5vPdn8RdCyJskCKw8wuN7OVZlZkZveWsT/VzCaH988xs1Yl9v08vH2lmV0W0+AiUqZrzm/Oszdl8+muL+g9Op+Vm/cGHUmiKObFYWaJwCjgCqA9MMDM2pcadguw093bAo8BD4Uf2x7oD3QALgdGhz+fiASsZ9sGTLmtB8fc6Tsmn/w1nwcdSaIkiHMc2UCRu68FMLNJQC9geYkxvYD7w7enAk+amYW3T3L3g8A6MysKf77ZMcouIt+gfdM6TB/RkyET5jJw3BxqpCRiQYeSChdEcTQDNpS4vxHodrwx7n7EzHYD9cPbC0o9tlnpL2Bmw4Bh4bsHzWxpxUSPmQZAvP13Ld4yx1teUOZYiLe8EL3Mpx9vR5W8qsrdxwJjAcys0N2zAo4UEWWOvnjLC8ocC/GWF4LJHMTJ8U+BFiXuNw9vK3OMmSUBGcD2cj5WRESiKIjimAe0M7PWZpZC6GT3jFJjZgCDw7f7Au946G3IZgD9w1ddtQbaAXNjlFtERAjgparwOYs7gJlAIjDB3ZeZ2Uig0N1nAOOB58Mnv3cQKhfC46YQOpF+BLjd3U80XXVstJ5LFClz9MVbXlDmWIi3vBBAZtP7CYuISCQ0c1xERCKi4hARkYjEdXHE49IlJ5vZzL5vZvPNbEn4z4src94S+1ua2T4z+2ks8p5qZjPraGazzWxZ+HudVpkzm1mymU0MZ11hZj+vJHm/bWYLzOyImfUttW+wma0Ofwwu/djKltnMOpf4mVhsZtdV5rwl9tcxs41m9mSFh3P3uPwgdGJ9DdAGSAEWAe1LjRkBjAnf7g9MDt9uHx6fCrQOf57ESp75fKBp+Pa5wKeVOW+J/VOBvwI/jYOfiyRgMdApfL9+HPxcDCS0mgJADeBjoFUlyNsK6Ag8B/Qtsb0esDb8Z93w7bqV5Ht8vMxnAu3Ct5sCnwGZlTVvif2PAy8CT1Z0vng+4vhq6RJ3PwR8uXRJSb2AieHbU4FLSi9d4u7rgC+XLqm0md39Q3ffFN6+DEg3s9TKmhfAzK4G1oXzxsqpZL4UWOzuiwDcfbuf+Kq9oDM7UDM83ykdOATsCTqvu3/s7ouBY6UeexnwprvvcPedwJuE1p2LtpPO7O6r3H11+PYmYCvQsLLmBTCzrsBpwD+iES6ei6OspUtKLz/ytaVLgJJLl5zosdFwKplL6gMs8NCaXdF00nnNrBZwD/CbKGcs7VS+x2cCbmYzwy8B3B2DvF/LExZJ5qnAfkL/C14P/MHdd1SCvNF47KmokK9rZtmEjgDWVFCu4znpvGaWAPwRiNrLw1VyyZGqzMw6EFot+NKgs5zA/cBj7r4vfAASD5KAbwEXAAeAt81svru/HWysb5QNHCX0Ekpd4F9m9paHFxGVimNmTYDngcHu/h//y69ERgCvu/vGaP3uxfMRRzwuXXIqmTGz5sDLwCB3j/b/eL6WJSySvN2Ah83sY+BO4H8sNPEz2k4l80bgfXf/3N0PAK8DXaKe+NQyDwTecPfD7r4VmAVEe92iU/n9qcy/e8dlZnWA14BfuHvBicZXgFPJ2wO4I/y79wdgkJn9b4Wmi+YJniifPEoidGKtNf8+edSh1Jjb+foJxSnh2x34+snxtcTmJOipZM4Mj+8dD9/jUmPuJ3Ynx0/le1wXWEDoJHMS8Bbww0qe+R7gmfDtmoRWVegYdN4SY5/lP0+Orwt/r+uGb9erDN/jb8icArwN3BmLn+FTzVtq3xCicHI8Jt+EKH5zfwCsIvR64y/C20YCV4VvpxG6oqeI0JpWbUo89hfhx60ErqjsmYFfEnote2GJj0aVNW+pz3E/MSqOCvi5uIHQyfylwMOVPTNQK7x9GaHS+FklyXsBoSO4/YSOjJaVeOzN4edRBNxUib7HZWYO/0wcLvW717my5i31OYYQheLQkiMiIhKReD7HISIiAVBxiIhIRFQcIiISERWHiIhERMUhIiIRUXGIiEhEVBwiIhIRFYeIiERExSESY2Z2t5l5GR8jg84mUh6aOS4SY2ZWm9C6Ul/6KXA9cKG7FwWTSqT8VBwiATKze4AfAxe7+8qg84iUh96PQyQg4fcHvx24yN1XBZ1HpLxUHCIBMLNfAsOB7+rlKYk3Kg6RGDOzXwNDge94bN6QS6RCqThEYih8pPFj4Cpgv5k1Du/a5e7FwSUTKT+dHBeJEQu9AfQuoE4Zu7/nlfu9zUW+ouIQEZGIaAKgiIhERMUhIiIRUXGIiEhEVBwiIhIRFYeIiERExSEiIhFRcYiISERUHCIiEpH/Dx6GdebYOFfoAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -287,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "id": "80697c00", "metadata": {}, "outputs": [ @@ -295,7 +295,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "MPI task 0 has 8 OMP threads\n", "MPI task 0, OMP thread count starts at 0\n", " MPIThreadsOK = 1\n", "\n", @@ -315,7 +314,7 @@ "Reading P_k from file: output/pk.txt\n", " Original sigma8=0.799990\n", " Sigma_Gauss should be 0.875326\n", - "Node 0 will allocate 0.596 GB [0.190 GB (Gaussian), 0.302 GB (1LPT), 0.101 GB (srcs), 0.002 GB (imap), 0.375 MB (kappa), 0.375 MB (isw), 0.375 MB (custom)]\n", + "Node 0 will allocate 0.597 GB [0.190 GB (Gaussian), 0.302 GB (1LPT), 0.102 GB (srcs), 0.002 GB (imap), 0.375 MB (kappa), 0.375 MB (isw), 0.375 MB (custom)]\n", "\n", "Run parameters: \n", " 0.000 < z < 0.150\n", @@ -336,15 +335,15 @@ "Seed : 1000\n", "*** Creating Gaussian density field \n", "Creating Fourier-space density and Newtonian potential \n", - "> Relative time ellapsed 193.1 ms\n", + "> Relative time ellapsed 2257.6 ms\n", "Transforming density and Newtonian potential\n", - "> Relative time ellapsed 132.9 ms\n", + "> Relative time ellapsed 480.6 ms\n", "Normalizing density and Newtonian potential \n", - "> Relative time ellapsed 4.8 ms\n", - " =7.209E-11, =9.024E-01\n", + "> Relative time ellapsed 19.6 ms\n", + " =-2.325E-10, =8.941E-01\n", "\n", "*** Writing density field (native format)\n", - "> Relative time ellapsed 45.7 ms\n", + "> Relative time ellapsed 241.5 ms\n", "\n", "*** Creating physical matter density\n", " 1LPT\n", @@ -352,73 +351,69 @@ " - Computing displacement field\n", " - Transform displacement field\n", " - Computing particle positions\n", - " 1st-order displacement : [-1.917816E-10,-9.003913E-10,-8.091001E-09] 2.940215E+01\n", + " 1st-order displacement : [1.738749E-10,4.895681E-10,4.054534E-13] 2.882436E+01\n", " - Undoing padding\n", - " - Sharing particle positions\n", - "MPI task 0: [0.000000,874.992798] [3.417941,871.574829] [871.574829 874.992798] [874.992798 878.410767]\n", - "MPI task 0: 27053260 16777216 10066329 134860\n", " - Interpolating positions into density field\n", " - Normalizing density field\n", - " Total density : -6.073788E-04\n", - "> Relative time ellapsed 693.6 ms\n", + " Total density : -3.546011E-04\n", + "> Relative time ellapsed 2258.7 ms\n", "\n", "*** Writing density field (native format)\n", - "> Relative time ellapsed 44.6 ms\n", + "> Relative time ellapsed 189.3 ms\n", "\n", "*** Computing normalization of density field\n", - "z=0.000E+00, =1.132E+00, =1.132E+00, =1.132E+00, 00000000000\n", - "z=3.771E-02, =1.131E+00, =1.131E+00, =1.131E+00, 00000349448\n", - "z=8.083E-02, =9.720E-01, =9.720E-01, =9.720E-01, 00002350328\n", - "z=1.291E-01, =1.058E+00, =1.058E+00, =1.058E+00, 00006084072\n", - "z=1.512E-01, =1.058E+00, =1.058E+00, =1.058E+00, 00006469528\n", - "> Relative time ellapsed 210.0 ms\n", + "z=0.000E+00, =1.004E+00, =1.004E+00, =1.004E+00, 00000000000\n", + "z=3.771E-02, =1.004E+00, =1.004E+00, =1.004E+00, 00000349448\n", + "z=8.083E-02, =1.026E+00, =1.026E+00, =1.026E+00, 00002350328\n", + "z=1.291E-01, =1.121E+00, =1.121E+00, =1.121E+00, 00006084072\n", + "z=1.512E-01, =1.121E+00, =1.121E+00, =1.121E+00, 00006469528\n", + "> Relative time ellapsed 1501.3 ms\n", "\n", "*** Getting point sources\n", " 0-th galaxy population\n", " Poisson-sampling\n", - " There will be 93329 objects in total \n", + " There will be 97421 objects in total \n", " Assigning coordinates\n", - "> Relative time ellapsed 222.2 ms\n", + "> Relative time ellapsed 892.7 ms\n", "\n", "*** Filling up intensity maps\n", " 0-th intensity mapping species\n", - "> Relative time ellapsed 1188.9 ms\n", + "> Relative time ellapsed 6312.8 ms\n", "\n", "*** Re-distributing sources across nodes\n", - "> Relative time ellapsed 2.0 ms\n", + "> Relative time ellapsed 3.0 ms\n", "\n", "*** Getting LOS information\n", - "Communication 0, MPI task 0 is now MPI task 0\n", - "> Relative time ellapsed 399.9 ms\n", + "> Relative time ellapsed 1958.9 ms\n", "\n", "*** Writing kappa source maps\n", - "> Relative time ellapsed 1.6 ms\n", + "> Relative time ellapsed 13.1 ms\n", "\n", "*** Writing isw source maps\n", - "> Relative time ellapsed 0.8 ms\n", + "> Relative time ellapsed 5.1 ms\n", "\n", "*** Writing source catalogs\n", " 0-th population (FITS)\n", - "> Relative time ellapsed 67.5 ms\n", + "> Relative time ellapsed 421.3 ms\n", "\n", "*** Writing intensity maps\n", " 0-th species\n", - "> Relative time ellapsed 1.6 ms\n", + "> Relative time ellapsed 20.4 ms\n", "\n", "*** Writing custom maps\n", " 0-th species\n", - "> Relative time ellapsed 0.9 ms\n", + "> Relative time ellapsed 5.2 ms\n", "\n", "\n", "|-------------------------------------------------|\n", "\n", - "> Total time ellapsed 3247.2 ms\n", + "> Total time ellapsed 16702.8 ms\n", "\n" ] } ], "source": [ - "os.system(f'./CoLoRe {dirname_out}/params.cfg > {dirname_out}/log.txt')\n", + "os.system(f'LD_LIBRARY_PATH=/astro/u/anze/local/lib/ ./CoLoRe {dirname_out}/params.cfg > {dirname_out}/log.txt')\n", "f = open(f'{dirname_out}/log.txt', 'r')\n", "print(f.read())\n", "f.close()" @@ -429,7 +424,7 @@ "id": "69c3b9cc", "metadata": {}, "source": [ - "# 3 Inspect output\n", + "/astro/u/anze/local/lib/# 3 Inspect output\n", "Let's now look at the output\n", "\n", "## 3.1 Custom tracer\n", @@ -442,9 +437,33 @@ "id": "532583ee", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:368: UserWarning: If you are not specifying the input dtype and using the default np.float64 dtype of read_map(), please consider that it will change in a future version to None as to keep the same dtype of the input file: please explicitly set the dtype if it is important to you.\n", + " warnings.warn(\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:391: UserWarning: NSIDE = 64\n", + " warnings.warn(\"NSIDE = {0:d}\".format(nside))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:400: UserWarning: ORDERING = RING in fits file\n", + " warnings.warn(\"ORDERING = {0:s} in fits file\".format(ordering))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:426: UserWarning: No INDXSCHM keyword in header file : assume IMPLICIT\n", + " warnings.warn(\"No INDXSCHM keyword in header file : \" \"assume {}\".format(schm))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:428: UserWarning: INDXSCHM = IMPLICIT\n", + " warnings.warn(\"INDXSCHM = {0:s}\".format(schm))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:920: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_over(newcm(1.0))\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:921: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_under(bgcolor)\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:922: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", + " newcm.set_bad(badcolor)\n", + "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:202: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n", + " aximg = self.imshow(\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAFzCAYAAAANJxyKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9abA1SXoehj2ZVXWWe7+tl9lBEiAFiRAYICkaxEKAIIBZIIZoyg5Tq+VwWGH/sSLkkLmIEAENsZuLwn8sh5eQFSZti2aYtE2bxEKYi0gItkSQlCCRBAFiH8xMT3d/y733LFWZ6R/vmll1vp4Bume6e+qNuHHuOadOVVZWVeaT7/u8zxtKKVhttdVWW2211VZb7c21+IVuwGqrrbbaaqutttq70VaQtdpqq6222mqrrfYW2AqyVltttdVWW2211d4CW0HWaqutttpqq6222ltgK8habbXVVltttdVWewtsBVmrrbbaaqutttpqb4GtIGu11VZbbbXVVlvtLbAVZK222mpqIYR/LYTwX4QQbkIIvxJC+CshhG/4Ne7z4yGEP/tmtfGzON7PhRA+/Pk63mqrrbbaJVtB1mqrrQYACCH8OwD+lwC+D8D7APx6AP8hgN//BWzWm24hhP7zdJwQQljH2NVW+yK2dQBYbbXVEEJ4COC7APxPSyl/oZRyW0oZSyl/qZTyh3ib/ziE8D3uN78nhPBL7v0fCSH8cgjhWQjhH4UQvjWE8G0Avh3Av8zesb/P234whPD/DCG8FkL46RDC/9jt5+MhhD8fQvizvK//KoTwT4cQ/mgI4dMhhF8MIXz0wnn8GRA4/Et8vD8cQvjSEEIJIfybIYRfAPD/4W3/fAjhkyGEJyGEvxlC+Eq3n30I4U+HEH6ev/9bIYQ9f/e1IYQfCyE8DiH8/RDC73G/++shhO8NIfxtAHcAfuOv8dKsttpq72BbQdZqq60GAF8HYAfgL/5qfhxC+GcA/FsAvrqUch/AxwD8XCnlB0GesT9XSrlXSvmt/JP/BMAvAfgggP8egO8LIXyL2+XvA/BnALwA4O8C+CHQePUhEBj83yy1o5TybwD4BQC/j4/3J9zX3wTgK7htAPBXAHw5gPcC+AkA/ye37Z8C8DsAfD2AFwH8YQA5hPAhAP9vAN/Dn/9BAP+3EMJ73G//DQD/EwD3Afz8c7pttdVWe5fbCrJWW201AHgJwGdKKdOv8vcJwBbAPxtCGEopP1dK+ZmlDUMIvw7A7wLwR0opx1LK3wPwvwfwP3Cb/aellB/i9vx5AO8B8AOllBEE0L40hPDoc2zjx9lDdwCAUsp/VEp5Vko5Afg4gN8aQnjIIb7/EYB/u5Tyy6WUVEr5Md7uvw/gL5dS/nIpJZdSfgTAfwHg97rj/MellP+6lDJxe1dbbbUvUltB1mqrrQYArwJ4+VfLVyql/DSA/xkIrHw6hPCfhBA+eGHzDwJ4rZTyzH328yAvldin3P8HEABM7j0A3Pscm/mL8k8IoQsh/EAI4WdCCE8B/Bx/9TL/7QAsgcTfAOAPcKjwcQjhMYBvAPCBpeOsttpqX9y2gqzVVlsNAP4zACcA/+JztrkFcOXev99/WUr5P5dSvgEERAqA/4V81eznEwBeDCHcd5/9egC//Lk3e9Ha4y19/q+BCP0fBvAQwJfy5wHAZwAcAfymhX38IoA/U0p55P6uSyk/8Fkcf7XVVvsisxVkrbbaaiilPAHwnQD+VyGEfzGEcBVCGEII/3wIQXhNfw/A7w0hvBhCeD/IcwWAOFkhhG8JIWxBAOUAIPPXnwKF9yIf6xcB/BiA7w8h7EIIXwXg3wTwZsk8fApvTDi/DwKVr4KA4/fJF6WUDOA/AvAfMEG/CyF8HZ/bnwXw+0IIH+PPd5wA8CVvUttXW221d5GtIGu11VYDAJRS/jSAfwfAHwPwCshr828B+L/zJn8GwN8HhdZ+GMCfcz/fAvgBkBfokyAy+R/l7/48v74aQvgJ/v9fBXmPPgEi2//7pZS/+iadyvcD+GMczvuDF7b5P4JClL8M4L8B8OPN938QwH8F4D8H8BrIKxcZIP5+UMak9NEfwjqWrrbaagsWSlk926utttpqq6222mpvtq2rr9VWW2211VZbbbW3wFaQtdpqq6222mqrrfYW2AqyVltttdVWW2211d4CW0HWaqutttpqq6222ltgK8habbXVVltttdVWewvss1V3XlMQV1tttdVWW2211eYWLn3xqyqhsdpqq7177Rt//5+s3p8eRJwe1k7vOBX0x/p3/XF5LdYfcvW+dEC3tO2CnMz5QYf+UH9+88Fu/tMInF6Yj3P3fnm+z+5csHmW6s+OdRvThs538+RcfZ63HeKx/u34cIP+UJd8/NG/9u2z46622mpffPbZ6mStnqzVVnuH27d86/cjDzVYOr7Y43y/BifnBwF5qH/74GcboMS7Ce7j8SpgOBR05/lwEZc+m+rPSqz3BxAga23aR+R+Dqhe+4r63Kargv2n6+32rxTsP1ODpP4u6fmIhQwgACFZG+X/kOt2x3O9vzAmlL7ZYSlI+7pTQyr4q3/7j83OY7XVVnvH2UVP1gqyVlvtXWLf/GEqnxfcM318kSb2PNgYcL5H/58f0mtmf3bPZZf7W/r9cGf7Ga9p2yB4gncn3isPjjIDo8F5oNImYLixjaY97WC4tc/SjoCJALLC7ZJjChCqABb/e2RPm3izDu+bD1nDLX13/+fsu93rCYPzaknflWDHmAGwIu0q1SsAxNNUbzPWAEy8dRUI42PlYY4oVxC22mrvCFtB1mqrvdPsw9/4vQCAtO0wXdsEnDahegWA4wstEqiBRn8XsHli74cbIDpwcHgpKjAAgM2TUoG1zTMDQ+N1xPaxgYfpKlYhwfG6q7w9rdepRKC4j7qRt+NTjFOpfjPwvnPHQG9hNEoORKZtwOFlej8+4Dbu7UelKxieWn/tP12wfWrfb19PVUpQPGXkjX0Qcn1O/lxDKpWHLqSCOGb3PlegDFPjulsyf2kjvfHgLe96hBO9/+G/8/E33t9qq632ZtsKslZb7e1qH/3qj+v/48Nd9d103VUT+uHFGkyN95pQ3wv2//5TBXFsDuae5LQP6Jy3qT+VCkx5nlLaRfS3bmLfxMp7VTogba1tJdYgsAVaIZXq+/5o77tzqTxvAHm8ioAsH8IrCyAuAIeXqS1pax4xADi+VDA8a/b9zP6/eiUjOnrVcJuUnwUA3SlX5xnHgrS1/XmAFcdS9VEcM6IDVWGsAVYcc8VLCy0Aa8dqD9b6iHBqLrbzxv3gT34vVltttbfMVpC12mpvB/vYV32H/j89qgHV+KDm7Ex7m8yPjyI6x8E+vhgw3nMbO+x19StlxqnyT7CEBcV2j1PFmRpuCGVMVx26U0tar8eSaW8etrwJFeDJvQGtkC1MSW0omK7rfcXRNbIZcXaPC9KG/vf9EFKZgSzPMZuu6u/SDggORE1X0OFxeAoMN86j9cyO2R4XqL1xAHvgGBx2JweWcqnPDaj6tfJsYc7xkhCkbuvBVxfqkOTU8MOa9yU64PVTfwKrrbbam2IryFpttbfSPHgCgHzPZufzo63+XwKBEbGQgeC8H7cfWE74vXtfwPWv2HZPfhMqYLX7jAMwt6XiEcUJFeh68HM2afvsueJJ8algvG8/mq7tu/4u4/TIwFUcC04P7PvRE+kLcHrJc5YCzi86D9mV/d8/sX1efTIgOQy6e8U8Rj7bsDvXIKsbC8a9vfdtiR6cldrLN94PGK/svc+cpP504cvbgmnv9uUxz7nuaw/oNreu3R5k5RpghlwqAOfDo/Gcq+E8HlPtHTvYSYVTjQpD8q7HspjNSTuNKxhbbbXPzVaQtdpqb6Z922/59/T/fGWAqvQR471B//cAoHR1lt35oYGKsfG4PPzZk/5/8yHb/+tfEZC2to/rX45IjOE2j0sF4Lw35f4vTEosB4DNE5r9u+OE6d7gfpNwfImO1x0ybt9PoG/LYcTjI9rHcFdweuB4UPsGWEnYkhGCAKbSFaRrN9kPDmS9MqD0tP3uM3Qc4WltXzfw4qUi4tmI6RLmyw6nCrmf2mL/dgcCS4DtVzIZDy+HKsS4fc3tIgF5K/tgEjt79+JYdB9xqtvRHW3/FUgc6xBj57htoZi3LORSeRHjVJSjBpj3kY41AZn2E06p4tbh7EBYyhWYClNC6Tv7f3AnEO3e+cF/8P1YbbXVKltB1mqr/VpMPFUh5wpUAcD4gGbdEi1rLPfBJjeeN8d79F3pQgWqHvy8eRxCLpiuaKI7vtDh7r02ud19MCM9oPDP9T8ZLNMPNIkDUPmELZPcBWgJOVt+098ljA8M5E0OgHXnomAKBZVHKY6WGRhHC/mFDJxe4PNlZFAig5htE6K7Z0CiXCfEp33VtpA58/BJQOau3r5m7ei8l+loXp84wrx7fAhpX+6h+6L9ea+SAR3huEnIcboG+lvbTgBZKLVnjL430OZ5XR5sxdFAYcc4Wo4tCQDyXr1bbvQNyYB0HEs9tGegO9OJx3OuPFc+5BiPrnECugREpQQIuBonYDPY/wDKljoxjBPKlrb7ob/33VhttS9yW0HWaqs9zz7ytd+lk1JiECXE43Rls2TugxKKBbikTVRANXIW4PbxpPycOHogwGCnFH2qJHMtpILHv4m9SGfg8T9N3+9f4Ql/B5NOOKDiC734jyY6DnsmwlQqT1nIzuMzGslc9a4cgXy8Nu/MmbPzUIDxAU/+Z/5tZ+cQp0DvAWyeSPYjsGFS+fk+uF8Kji8xiLoBDu91xPtDwHRdEE/LWYTdgc5fwE0oNXgLySQYQmLQ6zw1eev6LBjIGZ4VPr55ixJji/PD2qsl4G3Dv8ldwO71rPsECKROOwOf/n+AvZYXhuQ4+T5l4Oi27Q9Z76v+WDSrUr1hwf4vIWjWp3jRukNG4evc3zDACgHxOPJ20f7fMPg9TigsLyH8rzJ02td5Y9mkssiQZ6fEgB/58e9cPtnVVnv32AqyVlvN24e/4XsA0GSQrmhGFQKyT9cHmnR99yQoiBJ+DU/oaRuNc5Mtw8wDK8ADGZrMRFU9jgUH9mDtXi24+RIhU9dekZd/0oV+JgNYccyYrjsjzhdUQ4CGoMRRwpuNVyZCmgcj1sfJeamAyoO2ezXg/ADYvQo+d3rt7wywxHOpREV9Nt543z6PZyaiy7kKICr2Ge3b+kE+82BRieRtMp4LaSajyaG/o/bKb8SjNLHnbLwXMO3tcwCVHMbGyT+EbNIYJdg9IveAAK7Rkf5Dsr7qzoVCknwdfJgRqD1kIZXqGgrHrETiptH/zusF83QBtDgYOGM0dwGbp7SDvInobuX/jtsx6fvYqNvTBsEArQO2yPOpYwVdq70LbQVZq31x2rd+0/fp/63auZjXOfKZXXlrs5sXpzw/qsnpw1PHh2FwlXzWXZOR54Fa2jnAcVVnE4p5DpIPLVaArcmwG+/Z8c+OtO61sby2lA+ldSf/v49V2b/DTcbJtdHvy3t+lMAd6n7w5PBqe3eJ+rsahInXqsoudPSutKnfezDoP5+u7f/c23bDrX3uy/7cfcBzn1DJXuxftR0viaRSe217T2j3Ehb+/1YxP7rz8L9vkxv00O5+rjx5vd8GF03Dl64dbdmhVgtMPz9ZY+PZN+rCHOQ+/+H/7wq+VnvH2gqyVvvisG/5ViPl+kmdMrhY1HKI1cpc//egyk1O47ULF24C+jsmFU9ZJ6s41vpJ3qqwl/tfuFfnB1E9DXfv6aoJzMstPPgFIyPlLlbnI+bJ7ScXLvS6U5cy14Y7x+Hx2W5ukh/vRVVuPz2KCsK8d6rSx3JgKndBvTLEX3PtEMdfT+DKPnegkAFpJWTqAJcPn9bh0ZocbyT8Gnj443pyuvCz0p5AFkBAa+u8WZ3rr2lX33fWVvM2eoBUAVQPMh3A9f3cO8Dj71P/29wFBUm5t/PxiRE+C/MSkItTUSDUnUyrrL9N1X3nPWSdB1rs9fIirKWPltkYQgW0PLn/R36szthdbbW3sa0ga7V3r/2ej1I5mZjcJBaA/o7Jul1U4m/po3qrKPtPWMihXvXzBJI2sZpAPLfKysDUQpkaLorBJpYYFDCM92hmj1PB+X5UL8Tde9oizPT66GeOJjzpJiQf1lRwVWDyCsWR1Cc3CUv4zYl+bp8m9cQob6zyBDnviJsIBVCkbahCYvK/hOU8NwlhntEXRzue9555crmQ0j1wuwSyZJs4GpiLElrsoEOiDxuKBy8kO25Mxq/y3r79p1248LZxC7l+LyHo/ZA2QUsVCcDpT0WTIOLoiPXJ2ug9mVXfSEiwd/+7+yPtbEGQthGbp5PqmvV31NnnR716qY4vdBXYkvukDT+q58qD3aOR8LuTAao4Zb134zlZAsZkwqulj8p1Qx8N5MWgz+eP/k3L5l1ttbehrSBrtXe+fePv/5M2eJ+zcj/6Z0aWicdJM8x8GCPtB30MSgyqCRXGrGRdDx78b8Xj5K07ZiX+xmMykJULSidE9mz/51KBK/F6hVTw7Nez5EO0yXm8B3zwb7s0OmnLrtNJe7qKCkymXdA25B6Y2LM03JlmVky1R6cSyJRTd/ytViRTrPKeKEiqz0nOowV65wcCRi1sFybLGAy5GNhx/KaQDKSV6Dxn3iuXDDSmLfQ+GK9dOK0YmKokFk6OoxbMAxWy/e9BnOdhbZ84L47rUwGtuQt1EW5puoumdaMnsdccMw92FHCFZcAVx2yJGZPd2/1hQuJ7fvPkrIuI7ukJZWcE93R/y8ctGB9s9DzO950uGl8Tf3zvyfSzhXjTQioaSg+50PMLupfUk9xHdKzzlfaDJqLkfa9acmnX6f7TLuJv/r/+MFZb7W1gK8ha7Z1p3/j7/6T+3x1smd3f0sAcx2Reni5YRuC+ljz3niYFU27VX9Xacx4iHxIJlZ6R55ssNLzyKLiwnePtPP1Sa+PhPfb5e/+OA40O6FScJh+ea+r2aRO8J8rjKQ1xLj/W0hc+k607unCo5zVXCu9zDxdQhyo94bsmny+HSCt+Ev/Uh7k8p82DQl9uqCLXO/J6JYHheGjePNepDlPSsbZPislinLIVs3a4fHJhZAFb1bHddfCeqKVkBTqO6ysXOvQabFXpIfd/50r5dHdOSd6JmIp5Qd3Ti3axPODyx/fnVJUa8pwtbmN/l/T84tnpdZVi7Y1BifN5ZxmM2RXX9iH6FXCt9gW0FWSt9s6xb/jvGLAanjlgdeez6ebM3TzMPU6lcyG7Lqg6dh46CyEOnYYu8tZWynkTlV+Su6jHLyEQuEPt1VkiHE/3N3p8PyE8/dJBvRUeYL34D+x8FWB4srQDLEvAabwKyr+pMiFd1yg/ZwhG1N9GDRvljaX+5yHo536btDcvmg8VVmRuN9F6gChZi9M+KOiJo2XKVSBrgXjvj+FV2n3oUMBc2prHrEQgs5Brf+vI7K52oQC/OFr/hdTwlETPKxkvKyQCWbq9XOpgwCltwiJQ9EBOrrk/R8+1usTZEg+XJ6hX5HSRdYhObT4C3VPutD4i3sw9p16EdHyROnu832O6ErHYYLpeFRnenodpHyuJif6Gn6lN1LClL6J9iTMoi5/UZP+23wPAf/r/+EOL26y22ltkK8ha7e1pv/tf+BPq6dhwll48GXejBANGJdigm4dIobhigCKek72f8qL3qnQRoQCJQyQoxfbv9gfwwO/BXDu2tzjPhSnFkxanjPND8gjEVPDqV+50EhGhy91rFjrZ3HjFb2rL+dp4WyXaZDbcWomVMJUqw5DAUanCeSonMJm3IE5UlsbzyORpF8kJ8yzUoDJxokCJtbcq96EqEF26oOdcOsepKnI+1oUh2/s0QDlM0y4okMiD8ds8/6t05qlKW7pfxgcSsgNOL2cD0LuC/hldsO2rwfq34zZ21h7qJ3r1QqjdybxY22fkxRIAUzrrx9JZP4tJJmnI1k/9ifTUBKzlngCMbpvMQxayAW4P7kOpPZVyXeOpcCjWNL26w6TXs7s9W5jx4IluqQJa6CIQIzJraOVdj/Mjur9LH3Bmwd04FfRHO17uA4anJgsxPD0hs5hpd2P/x9Ok/4eUSY9LpVW6OlTdBwVcvr9JP42OO7ks27/1F1bgtdpbZivIWu3tY7/7X7BaaLKSBZx8gndeONXq4sIEOjm4TKaqUK4z0foZH2x00I9uWz9w+xW1AqwuGPi6kPougKiEAHA7fbmaz/yW3eLvto8dgZoBVnc0gCjaWYBNngCwfeLO2wMkBXqubd7DJiGasTgVeANo5UIItTo/AYn75exFAQ25D/q55z9dkhJQsBSWv48Ll9fzpKrwGveDL6tzeJ+TW/CliX6u0/3L79pMRTHNLnRE791jVxrIZWh63TLp35DMw+dV9r3HRlXbHTD2IccqXOudt45Xp15Bp4jv29a70HvnFOAjhw3D0YUPk+t4D7hYGb4MnS4qTi9bWNGHjP39KmHK/tlpJnLamoqbpqLb6gIJqBYW/n6Ua9a7sP7pBXseV8C12ptsK8ha7Qtv3/wRzgI8zQGCt6qQrTMBS4ADV9Pc8+O3FfIuUE8sVXFccdR4r5X/3vNksrgJ3GTjf9dZmFD2++l/zgBWJeTJpV02N1kndz8RCu/KT7AbFz714RkJx1X8FwcYfYilIkmzedJ/RYJfML+thEB9KNRPrp6srrv3Xb8QGqrCYx5EuPDd0vfV/xKic4Wcjy87ztYLtpPNq/RDX2TbgyzZ7+aJfeZ1tHZP5iCr0qFauJdy43Vcss6Rw7VdLgS7pIG1FNb0hHlfG7E/OuDjwIiU3ak8Wnnhmeyd5MnWFROviqPXJagAYPu67be7ITJcBbJcf5XOx7nZa+VoAdO1Hdffgyo1cfCLODuH04vUrjWsuNqbZCvIWu3zax/5+u9G7uOsyK1YmCg7MJySApNwnGwg7UI1mOpvvL5OKcjbXsHCdG8w78EpAYGJ8O74+v056YTnU8bLgmhiBfpEIsLLQrjJ7vQSAarzgw6Pv5wzuNxctf+U9cH2Ke23P7h0du+NmgrSPnJZHm73ZB6oEoNloTm9riVumAdGkkAQsnk5vJfw8nDB23pSP6vKq7o8GtJ73/Rxs38fOlTw5QVGeV/dsWC6kvAYqnCyEqI384Z74HV+aP8f3ztXLb//0/3sM8BU6D3IkrI6gHkg42jhQy/7IeRt/ywgzvsoZANc3SEpx8hqGWYN0aIUTcoImTI741Scyn+pwJvcH57j1jvAFbXmoYXqvbK7CIuWEBDGBcV3sS7ac9VHLc0jIfO0s3I88ZTVs9w/Y7B1ngB+3sI4acFq5Aww4JLC1SFnlCieroR8bwfkjPHhzvqFk07kXo9T0UWeHw9KHzFdkUbdX//BP3L5/FZbbdlWkLXaW28f+XorFCvSBfTGeFJiYZSB1IXtvBiohBEWCO6Aeaq8gGhwnhnxkHnv1qV9qYSDF0V0nh+fVdieE2BAZrw/4MxFlz/5u+z7/a/QZ/d+2QEsHz45CWCw3VdAyYWaZs3wdJmTO/+Fcib+KRZg6gGigLuK97IQPvQE48mp1Iu3LHkB0n4B+HjRTLetART7zHuUlmQbatX7hWO4bT1J/vg+PtgjC4vt/6F5HAVQae1G1GKl4oX02XUmV2D9W2X5yfrAZ7I68NvW/QNqz6SY90oa13DuPQScl8ztpiLMs+etDrs7qQX536u3y7PlvVt+IeKefXmOp/suO9F5tzr2pm1eN7JbdJmO4Wg3g96X3ru1MM74Au7+uL5GqP78YKLE7XYAVsC12mdrK8ha7c23D3/D98zSquNk6dgyWagnKBOoCqVUnpN0bzsjnFer9F1PNQZ3wp1hQvaULcSXC00O4tkZmbCbhYjc1cdNxbxmwlM6J4yPeBXsPUtCx9pEy9Ji8HB4qcfd+2g/T3/zhO7BGV/y8mN85kc/CIDr4h2LEqY3t5nIzQcjYV/y9s08bQFGplbgZQT27pTMU3dMKJuIICEnzqwsXdTrYerjwY7F2Zi6/6lQn2Y7bomhmujTPgKl4V0JF6tbBkbiYZL6gFURZAYz096VugnGP4rJZQE29Q5Vn8uFPOVYAthKD5y52PX0IAP3aVKPn6adbl8LetzcMzjKBpK2r5M3sXfgOLpsungus3Ah7cPVscyl5rmBAGnIdu9J3wvokWsngIDqbvbaBoA8aNNOuEv8DJWiIWcfqvXh5u6U9RqHXNRjKvd7yEXvm+ABWRV25/+9pIpk4cqzth20remKtOv8/dQfkx6zO04IhxHhzDyxKdHzXCnER/JI9Z162ErfMWneVWq42mpbp/tbhJSR9v1M6sIKXQftRw3bhoC/9lf/Xay22oKtIGu1N8+kuHILhtSUUO08KzIwR+ggme7RpEbij/UtVkkpOG9IdAMwwGBKJoe04Opx3KnaK+MZ19yea1sBL2llqadmFzSz65PfRPt58P5neOGKtAce/6UP6m+F2D5UpGPvcZLXOTm9mkwqnlINsABgYN2w4MNUzoLzJuqEJ56BUKvdP8+0X4rjY7nJXPqlkiAQoCXct2TbTc67JJ4qz3canPdIRyHX1KqWny9CLYDKe4pcSR8prXP3JS7Zgvcvnsc4mXfN6huaWOqwcB29hIJeWw6N0/9uMZFs8tY2LiRhLHEUw2Rgy3th5Dp7fTfxNl6SPtBnyntCnSyDgUdrj957LjlEPXBLc4q7V4vTsBNOVSUE7J6F/oYB1mlUMr6ALnoT6tcLXEoBXGW/0e3kea/6z2XSio0MZBHs+q5ga7XGVpC12q/NBFgBNvjnwdXP0yygbGERCTGkooOWuPJLZ+UzdHVdioX/CvM3fOjE8Sm0+Gy2kGNYyIKqBm9ZVW96JfWWqy3CmDA92mt2o2QF5iGqJ6Z0QcHV4WXa95OvnBRcfeoJKV5u/+Z99AeaiFXU82iq66phlYt5shxnR+xSTTppi05EBdg8GVH6gO6WU+SHDnHKxImTCTraJOh5KEuFe8vScKFq8lHb7UGWTO4XQZYDWLJdKKTGrp6cDXmoNk8KEnukdq8WBUwSRqwKEkv+wzaoZ2m8CqQQv4cOfcpfC9afaQecHxZM982riAIMTyP6W5N1EN2rOBLIAshrJqFCL0GhJYmqouN2DXQBIh/57FkHdn3mp/AK9fr1UUGWbJd2vbuP+LOtyR9I1YJpX8uU0A/C3KsFF54uzrMlwK84sCULlgwFW3JNQ87aXg2HnpKqzHug6KsmaFu09mFBOLHHUfS82oVSKfTcL3nXZDwYev1MAFe63phHXsYfj2v5fhmver2f/D34N/7KGlJcbQVZq32O9pGv/S7lVUXn8g+pVIrLSmK9M50dP8h5foSIhXrgI56REsMsZDbcTEAudakcAVRjqnkgoHCChgjEc3OBpFs2vJrOGeWa3BqSFRVSwfiAvheOVSjAs19H/9/8DvJYlVe3Coxe/gnz1qg2kdO20gn5VBYHajuJhWd1YXXe307mYZAVvvcWyDXy0hNy2aJ9ZyWFvMdvoQkL8hmhFJrIc3FZhtYPArRMTiBbqRlXJ3G8Fk8Lbbe5KQpkl0RU42Q8Ns8vUrV1p9t1vhZAaeBK2zCYR+v0Ei8WtgVhpO+3n3EZmZMcl96LthmdVx1yaq3ybjXfexJ/m9WpAAvmzbqUeSvXTzSmZt/zOXuZAyHJl2jXSD13uTgvHvf7WBdEl+2gni4veFZ7mLwosLfsEl3a33p5BgF38Zzsf+FrpWzPeTufXfJsCaHe8buK67t0bVwubZssuMTzvY2a+BFPBq5X0PVFaSvIWu2zs4987XcBoEE7NnyKFmABQHcrheaCrRA3brBymjayapUJuS3oDNAgNdywKKkovEdoZqES5WVQjZG4Gq3Jfe2/k2PttsbV2tLMPj3a6STgAZZMPjcfoLY/+5qDgqvhCZ3Hw5/2npXaUwEYIAilKMiKTVhvqW4iFbPO+lvqu05LCnV359lvLu1zpu8lE0YfdZKUibp0weQUFvSz6uzAuYSDgKu0MQ+JlI7JfUB3ImClZX14f8dHEZsb+uz0QEBB0MLMKvzptcWemWclumNQ24LyxEQBvsQaZAHA6UXu231R/aztp30IiV57J0S6fd28lErY18LaLotVwm7nOdBaChV7k+28jpX33uh9IqDEhQjznk88230gbZLwrs8I9d7S2IAr+t8+E7ClIF8STnJxHEk5uZrvJ/to21SB/IVkCcCkXxR4jpk4nskWXItgy/8vfS33uuNtVZIUosnlwJaOH32ogBYAjFxqqL+17N4VbH1R2QqyVnu+ffRrvsupchPA8uEIdf9z0WMFV4ACLA+uRJ255f+kbTQV6A2RViUkt2FFaAFXIZnMQpgyDdzJBvEwMbldwoR+9SyDvGzPqeXe01V2NIBKUVwEyhBECBjvGSn+9v2dPkI3v4FTzm+iqovf/wXjr+Q+oDsXndz7A5Gdq3InLuRC/W1As60zlzsq7aPp/MeE0keaePM8g02shFAR1luSNTxXKRKoUgAdqA/9ZGfXvybFpz2FpKYrF5raR+Vd+Yw72beptZPsgAmWspfumHH73g6bm4KbD7EMxpFAUemNGN/fFXSnosfwZYjknhIifO4D0tY8XCVAsxEl6zDtC4Usr3IFsuIIVaYX72QcgYEBoYQQEVwb3CWJk4WG45iVBC8AbHZtpKtKATIQT5N5mkYqRk4hRPMclxiB6MBKDFXmrQIxD7RkHXLVeJNKMaAlIciq9E/Wc5FzDVOu2kjn6JA9e09J1sXONxRauIVcjNC/II4bSuFKBdkyY4MBLe2vcaLFmCyunge2tK+cNzeEmQwFYqwKzCMEvn/qBUbpA6Z9RHe0rMz+mPCjf+3bsdq73laQtVptH/0a8lgp6TMXXamJ/hMAC7stTeQLISRZAQpfK207U3LvBGh1Smj1gpjC4aqkFiYJDwoHi4GW47d4zSENhS2Ihha/Ur0iYCUp3qSxRd+dHnJYkCf4wweykqb3n6TPrj9hE2elYC6hMQ5tqXiohBFzmYErwIVkvMyFTmYLnjoGklWIUPbH3Bgky2CrJSdkcoH7rUwUXK4o1hOc7reUymup3sldNMV27+yUeTvMz1WP3QclWovW1cilhG7fZzUSRefKSzxsXzOANRy4XJB0g+PTyTU6c+HoyRWqlgzHtPeeGwt7isq7AKxpT6CxOzsvF1/v4a6o+KdqmPli0EebfPVY8gy4cFSl5wYLk4VSavFb6UPRlPOheAnPb+LMk5kHAjvTzry1Vo+wPl/6X7yd0CLPnmumCwcBji7M2YY4vf6d3hfeO7ogp6D3TIFq3LXh8oqfKc+/owsEt0CzDx3FQcCWjCcbI+gX5XTx+La3h16enUoMtRdQGbSqhdQ+/ZEf+w6s9q6zFWStRvbR3/nHdWBpAZaG5zj1WjhYwIKr36+iuwjEUGtjgQa/5DKJ0AUCDgGuhI4blAUUKJGWv5OBUkOECwBLBsG+o+wjr8geuG0xouw4mylGpOsB6ALGaxowBVzlPuDufUGB1eEDGaUvuPqlTjk5V5+iNk5SHFm6gwnS3bloRqGF/HgSco8jeSXss+hCITShTJU3r/Rz4rIPv3i+FUpxk1PR86bt3A4iJSGUoakNJ9e8kBjqYlFuJS4Lfy8jbd19088FXnXCZq+Wcby42HSyCf+OuVn9seDufdTXcl26ExDP5lHyyuveQwqQB6tEul4AMN4XAGZ1DiV8WPrC15G2kQLSm2cF0z4gTJYVGUcGI4E8a9K24VbqENaePBIsJU+HhpYdv6kK+XUEhMJoUiVRQsSZPL2qiB5B/7v7wxdM1/vGP7fuWCJyql6tCJOFYDHc6MKh9A+XgIp2TdVT6TMrwZ6omaxK1Ge5GjsChT4FbJpXq05+of3y6Z9TveiYcp1BDNiCTbxcOdf8RJaDoPN3z1PfsfdKPuO+lgQKGeNCYEBv4fY8RPSHCZnPT4BWGBN++D//OFZ719gKsr5Y7aNf/XH6J1joTomq3mPltG1kVSchJ8ve48F7Z/oyPotITMi3Gm4UsNBYSPWqPPgQn4IvHhDbQrX6IwN3YUo2WIdmkERNwpcMwvG6Rx6osG3ugcN77Vm5+xAd+/7Pdui5UPGOuTiekD1e2YQNAHsmRXenQhNTKbUCuJjMSz58wv2hPBwHlDQEuESOd/2h5sKJfoLQfoELETaFdwFUgEt5Q6morpeVwRHQTpNUJZa5wK/xWWseYFF7AoeOAlCAw0vW0ceX2RPqcHt/4OaPBHKkoHR/Mk+SlwCR7MfzfefJYsAk3K/cA9O9gngG+lvabveqhPao/VSYmj5LO99P3C4OIfZHC71J8kOYCCyEibhNlUr/Qmkor0XV3RDICmOqKiCUobNrqr8zoFT6hWdH+nxHz+nkvDPK15Lb5mxtUK+rjAdd0PI1PgNSajaGia6zkvcruRL22LlxwNMWigrckqdU7iepWuALvOsiIJg+lz4DEl71850DXaJBVpoQIv0v3jZ7bRcOZUv9n7bdXCLFWS/XT5qRswLSH/47H59tv9o7xi4OygtP3mrvFlOAFaOmUYcpIx5Hy0jzHqQIGoSyA08NwJJJP4xpJp1Qhg5521PIiXkWccwzgBVSqVO/nRVJwQ6BBr/oQF+12g0VwPLeKh0g+w7oadDLVxvkPiL3EdO9AXmIOD0akIeA46MaYIVCACueA+I5oL8r6A8EsMhDQqv7biwkF5BtohV+Tn9nq2ofGtLmLymCtyHDZNeihGagX7JKpNFAphatbjIJK2K89v/CZz7UV0D3wAIouETgrnf2nGPxfkOutwPqkFsldSH8bgZe41VA2gRM21CV9GkzJpfaKoKxEibLG2B8SNudmYgfRwJS/bGohpcvVSNmRaDdNdHJWtockbaRpEKGZnEAux8Wr4l6sCInf2QLt4v+1pL21ML9I9If/c2oYXzRcqPrQaBX/i9dQEzkKQxTQRTP3JjV+00yDi58mIuG+CrwXsiLm/ta0kUlIjRxgut7CrCVLMkQyGOXi3nrFhwHMiZ5Ir4svop4qvz4kvN8P/LbUmZeMtEB7E6pKtujHm5Jtth0BIKnTH8OzH30d3x81u7V3vm2erLeZVY9qH71Kp4hHYjdJKnK4hISdDNak41DGxjXBYAS3j2Xwkix7taR8Ei1/7r9Ghr0ZPbn3aMySHWxJrm7diXV5gqqkC2hQQA4PaDtTy/R+Rzey7yZu4CHP03beDFRADjdt/6QmnoAsH1M2+1ep/YPz0x+Qs+1XJ7wPP/KK2vTeS0ArWZfSzwvb23tvNJZeMl4WfX9AKDSc/Lli/zvKgHX1hvmmlxxt6T5DQhQgnoHHPlaHfn6JKt+UxHRo4iECtBtyhV5j9Z4bftIbRHrAJweiYeIPtpy8ej9ZwQ02O+rfW0MjAFW47A/GdFdw278vipi7It2u2w2ALUYaKsXJyFCF55va38Cdq2WBIPl+RUvr/fQeVNO1tScx90437/y+dy9KN7LhSxDCy/SpmlrnDGp+OA9pZqJfJpzr/T+v8TBQvOMtJmJ/jlrPVwL0hBVFQsec1SR39cOvePs4Fsnqiq7cvv9oZ/447PvV3vb2houfDfbx37bd9iDLgVThUfjM2/EvLxBq20lr8Oy3g4A5K0N5EIA1SwkDxI4TKXhMOF6dZ2tBL0nRH47OYAlr6UsAqla+8aBK+ZYyMpR9GzyEDBe0apZwNHpEb2O93myuA14+E94ZXqm1WiYaMIPGTg+okKyp0fEwRhuij4h+1epbNDw1A36rm8og6nxTnSBODasOaRAqxFSnJkDyFXYT/lX4aJ3STIKSx+M0C79Gefek1aEsv2+DESuzptIfSG31UK4SsFMAXtPYSMMvxcCfEjU3wBwfmieqeQy67Vd4gDcApvHFNYcbsnjEqfag+KV5rUUj3Q3l+2ZdkC6Im+iTPTDTcDwrKC/82Rwa9d0RfspvecwESE+TuDwFh+nkXcIqZgQqGb1Qq+JXCflZ3lpB/F+unCweG5Kx55QOU0X/lJAor8PdC+FgOnaMnHzpuZndie6B6SUU3SF3ru7aV6VQMJ2Y0IZOs4gdIAlNt68BgRagkVnYcrBeIAlBnRH8663nE/6sQG/ws8chF/K5Xr8+IUlaRjZZ9/RWCTjkB9Lh576vBMZCONspf0c+A6PT0AMBJzj8uJoBVxve1tB1rvRPvbbXJZKK/63BLCWtKPE/H1wAWAJuPKZNZfAVbVrn/UGEMBaEC41hXjjVgAwToQf1BZWj+K5kklExEXTPjpxStp+vOe8GvcEqND7h/8kLUoPAMCZpR0EmAHGC9p/xvpbQFYrJrmUkanEdi/sKNyWNsx14UlsuVVLavqz4/pwoefkuW1aLla7L92neLN0ooS1I9b7rM5J/i/1+7wJllXIXkPhUVVq8jJPS+WTbABMtKwkDOi9TwKy1AtZUBHqAeD0kE99R/vZPLPj7j9l3hzNOmTPz7Tn4/E5iTcLMC/Wkkq8FEsWz1ZVXkluG692PxlwAVBxkqhP4gyEL4l+hhbQuN+JUvxSaNk8cy5ZAwC6oN6aihMl1iwefDKHiqnKs+/5W5Kd7GqYeqAFGGDtbo271lq18NPQYe2hqn63lJUo1o5jDdACgOIWpaIbKABWhZefcnsZaNHxeJerd+udYCvIerfZx77qO2oStLx6IvmS90pI5eIdkgF5kIfeEUS9p4QHinQ9VCVhZDXtj9V6r2jDyByEBoTleqJAcgAMcGGtrs6mkmNtHTdj2+t+BGCNrNheYsC4DzrRCrA6PwjkORmAzdOCe58QnhnvVjR7BJ9y9tXxEWUfCsCS8ODmiYQvXAiI+Sl0Ho0nq5noPMii1XYxkOnK7wjxXCYZTyAvfaDJ2KW5C/G4DBFgL4LoMNEBq26de8FakNWMCKQnRBlxXkFcMq3UIwMBXnYcAFaI2nvBuBTOeE2k59PDgO5kyvBpSx6qtGGdr8EAjoAYAVqAXSsq2QTet/1WRUUZZE1XRLIXkOW9WZvHhUvr1N+Ne2pz2kIJ77I/Kk1D95QQ6AEXPswF8ZwJuI15Fi7UrL1SZh7FeJrYG2rPjwJ60XXy916ryZXLrOKCZB9KoWQq5+R+47xfkbOGAQNb3XFS75B4sf3vSAgXQG9JNoABrcrbCgfSW7AufaBK8AmSLa1ZjQAqWRc3BmrGrQOilQ6ZLpScp91nai4sGBGCJdwIyBJdrQtAqwRg8+RslTYkBOo8cCgFP/R3vwurve1sBVnvdPu23/LvAWg8IZ3LPnJZKpXnaoFf0A4qYmFM+pu8Yy/QAy41IynaUuYG0JCf7q/xgtA21paqqGyEZUfNVJgdkNIVrawm6TgiEpg3nSsZ4oRGxZt1LVl09H50IUKZ5PafoX1fvULnlZnYK9wPAVYATfTUH9y8QqrjcSoYbpKm52t/wrw89P/ckyD9pGKkjXenBbAAgGYCFlDl9a103wwUK7kEBXW4bC2pXcE30IaevPBlXsooLG5y7Fwb3cTefiaepYn1h6Y9XbPsyO5aSqdVdpdbIZp46cAepZhoQqNaiQFpYx4xBWLuFE4vcDuuJbwHbJ5Q2HC4KyTZwUBpWiC8t8KePlyYu6AhaQAYbiTcZSFEX5QbIHI1vXfXZ1Z+p8y9pjFUAKv2KLb3DAO4jn5TFZde4BJqqFtDoHXYrvJkNd6tGcgJQQGees1TQbrq0Z0Spj2/MvjTzF03S6kY6LOT7jOexnoBKefSUhBgY5AKLLdew5RmkhBVZnOziFWS/WbO0RIJiPH+oIklCAHDs5HCoIfRFmNVOJPa9EP/5XdjtS+4XQRZF8geq72d7GNfRWFBWRGVoSPPTnG6UktZZz69m39fYqT3fazATDiTUnK+3iLvNhhf2GF8YYfcReQuIp4T/R0nOu4lgOXCVuTx4lR1kWtg/ZoKYHVxBrA8n6Qq0SEcCtF26mkSmPY9FXDe0fu8DZiuI9IQZgArJPrrjwX7z2RsbjKuXplsJewAlpVAKVjiN21ueDC/bbIwF7ataqA14ZeqaPMF84KhgAvNSd/AwIuvEah1BYfP4XGXsEmBeS4bbbKysD/z2Nkq3wMs30YPhHJPnsHS0fu2KDbgvIvikHC8YfEWDTcFw01Bd4D+GS+MXlVs8wx0x4Lu7AROBcOe59evO7LH5CxAlcBUHuwYArbkdclkWwl75t7a1CYMVIkMjmtHx3/OMQbz4ArAoh9dnAvq3yuBnV6WJUgMrEhYWAChL/wMNPe1YCIp15VrkdWgWaYF8TDRAo+9umnbsbaZI8RvIj2vwe4bDdUNHXHAvPdevOXy3tMRphoUKoWhd+NTH2mBO/QVtULHCDmW7+uJSv+E84RwGjVDGwCBKADDM76hA3nSxvsD0r5D2g9IVz3SVa/n49sk88Nqb09bPVlvY/MPjz5YslhqRCbVpex4A0oE3w5zlWgZ4HgQ8SVxxvubatPhWc1vqLwxWpJiYXXriznDrWaXMnOGhcHY/8ZtqyRYJpTmIVbeJgAYpXBr8p/R7yU77fqTHOJj/pT3AAkwEU+YcLG6s4lcDpzmvnlsBBslLrtQCu1bNnD9dMGLVE2eLbBZEAttPV9LniSx6EBjZb4tDmBdbEeTgeiPqSrdzfkpgPCUv+eNLBKtEZC4kT64vK0PJbbbioYWYKBMthdulgI4B7KEGH9mj5Z4Ma8+SdvsXvf3KP9mQbrBuE/1ttEBsuFWQm01AV49fpNt21YC+KyzSZvvWr2zJVMJgsEWH5fuM3kGgOd4tNoQnK/M0IwFWoUAVuA6Sykb7zVvOGLiVetvpVyXKxUgvNQmFL/ETc3ifXKLCj0fydY+uBquQF0TsbWmOobXMPTizcI9k+3Fgyl8N0sUsv5evVpfMLv48Kwg621mH/vt36n/e07FktXkzNprVbacwRNooE7Xgw1CHOuX/Y/3BsqGYQ5Ed0yOSFoDq7TvEU8Jad+jO1JNvaCDGg+cXpE51R6elmi6RASXiSVvOnR3o4qaegXr6T4NRiLFMF5F9MeCaUehPhTJDAw4MWFaJpPuVLB7PVXZXNqNAq6u7FjiAetGDlUVAm8WHjQvV0s+9uYV1OkE68+r70CThmT/UdFmLtCtkyLvZkP1IIX/NF1FxBNpG4mGU1W+iD1TmoHquVmAgawlb5yEccSr5trQnmfi45ceHOYLqrO0KMTqQ5HO+6UeH1FkX9KNilC+E93HhdT4iwEeLVYtZTcdMCPvWTAw4wELfyZaWSJauvuMgCwfVq3blTaAD6/Gkf73YrYqYHqikHp3JM9vnIpemzZbT+6zKB5hztCjvuQde0DeeLKemxjRLaFYaCha6w16CQZ/STzPDkBkvaswJvL2+CQZBV0uBCrVGZoxQos2M6cp98E4iZzNWWWuovbAqXQCgy31Ui3J1DSlgKiiRUfh06Gj8ZbPPbInCifer+qU0Xn4Wojazy1FIkYOzUZ7xkTUefBjJP+Mxy09l4UF7A/9vRVwfR5tBVlvd9NMQb+ikwdTABBzanwYblYix2vQtACrySIaH5h+VAuwqswm2Eq2BVgADGTJqtVr1miW3DK48iAra/ignkjaMBm1nQagu5fp9XkAy5c6AbAMsAKFHdo6buJFUSI372v7xCYK9TooFw5vaB5oCbG+xFDpUYn5GoICsgh8GV9HJl+RqqhAVjGujN+2aotgQ0eA9uftP9Nr19VeLJXJcKAxtuBa5hr1yLpjNaDOg6xQDLB4UCrgSvanXqEmJOfPQTP7Gu9X5ZlpcIbsXzSxOlcf/erTPOGJKKnj4yyCLBivDOA+LjXIov0ZvwpgoL0EsgC0tTpnHizPxRLAVS7fEzPP6QLuaq+prxUp5xX4ebwEtBQciEaVl2txQAuYgyz632qlyjHrNtr/krUpni31Qi1UozDSu2QvyD3fAC0A8XiuzwEXgBaAmc6Wy5j2QAuAJvXIuJg3HWLKqn4fRxaXPs/HW3+MFWx9XmwFWW9H03CgG8CEzC4PmA2IvKl7iHRgaTLTZDCqCrPyd+OjWmBIXNBhUQSxdsmHBQ+HZhLd1QPXksbTDGg1g6YOzksFcMXrdp+2vfmgnKNtIyBKTEjq2yf0+f4VI/F0jaCm8JWme3PBQzkXmbC3TwVUCriaNdeUrp8HvJrJybwK9WZLpWm0fXJ7CKfHAZBeaidqbbx6H5XA6FQftPUqeu+R3HcqGCqJB7vau0XHkHbVx9aacx78aTJBqfafhnry9gBFuWciv8DznXCifFuUryNgQ3lQmG2rgKvpetk27e0zyWDcPhbPDb1OC2KeUkjaRDil3exlOzjPy0k4ghKCrp9zPxbM6ABNEspSqRflRE01mGu5X9TeFnWKJybMttX7o6vvIfEqRVcBQQCCeL/Deaz378JuM/6niA3LWFnVfWzPm48n3kwGXJ3TGlPQ1erULXHfmoVfOAlgExQ9pzkUKTjdhBKrRBU5haYgtfIKq+LaTZOOTTbigujzGk58y+wiyPocmLCrvZkm2YKays6ExjI4d/GFMihp2xHxk8vkAHOvTzswTPc3mJhrJcBKtFn6J7Qsj6cJ8TRVJG/d/wWSbUX2bPW4FPxlIDPhPWcrKQE4bkbmc+ZzvDIV+RZgabhM5sFMAMuDiBZgqTp1rgFWCYEAVgyY7nVWwqYBlAKwNreZRUmL8VSaV0s1p8FeCt3SDlG9elBEafauIO7MmyKeHeZv7IJyjxSINJOJcrCet0yS7vAk5gvWggPNLhzmfVAiJR0QqT3MeHtKZJ/oT0qzSGKCfAcYQAyJZRBaHC63fU9/Qp73+xIvUnsvt78BHIH93LxK+PWMmUlYecZVek7fSz3DdhvxulQaVKWQ2nu7MNZn1F4lU7itF6j3gfOOouOCxsofbBY74qDjZz0kqrWoBc/dNiUGLWOkXsxoGYolBuRdd3FKUiAiz+A4aehOz1vuaQZF3YmScsKYTSdrrM/b36d5CEwo75B2vS3yBNDIa9dxIehQ/zkz6Rkn7zAlGvsanldVmNpbxNxzqtqCtpALBdV+QwO2Z0kzjnwvffdtX/ntWO3za6sn6/Ns3/aV3+5CcM1qhWtwpauBan8N0Q1i9SXoDlTCIoxZw4mli4hTtrAb/2ZigrgqRUtJDreKUy+B06jxbazLopR6P4fGi+UHly5qBqFP1VbCtC9Ke9XrIJa2Ef1twni/w/CMta+EJxWAZx/qEHkCjRNNfh6UyIQnXqfdq6xfJW58t3qUkNt4Le55d66FPRJ8Sptb8Q4te6gUDFSFr2VfzeS+kCwwI+I2YZuq2PGO6vQRF4XCyNQn9FutP7dAiDYQLaveXB1HVOhLHxC4Jp22uyFBZ5Et2M7XbEaqRtUWK4djbVPeWEOmb0nsAuiAOV9LQJmU1PGeTmt/vZ9pN98mLvwOMI+ZEOUV1CZSmY+JAFkawqIXszsXdGcBioXaUKzffagwZKME0GvjRfaSKDCQJbYUatMFWxMGrDyZDa3AiiY3YUb/DAk3qgu6WKiO40w8Wt2hLokz82YBBDJEG89xm2Ze8Y7Gv1CYOpGLFZfe1t7p0tEiJPcB/YGoEf0dgVLxBhl4WvAKNeeu/THKeTTlcnwfaKSCb9hLiUNMhpfC1QKYVO8M0DG5qijBavqYsupqAW48knskZfzgP/wBrPam2Rou/EKbrCAqd2/XIe96hFIw3huo9EfnRCDFI3+ciK8jg9GUCbBEe+Ba7gwVag7on51R+oh4nEgr5kyvIaVaCyaEmSp0yAVliKYmDgJqYSqWXcMDirjLEUOt2C6EUaDmY6WCvO8pVZlDmEkzhqR/AoabZJ93wN17WBuHOTEiBkleIwCBvDpxIi9ByMD2cV2vUUQu5TwFvOWFhKA80LYSilSPmAMulZfKhcFkNV+CC4sV2mdIZZ556PZV8W+KeFkCSu/Ax8Z+HycoyELhUFOwSVv3H6CyDCWEWY1JESnNHb8OEfFcl9HxYcISgvaRF1mdZa7JnD6RB6St3xe5aLiQqUMumPYdySTs6/si90GHNNGloiLD1A8lMogrvN9sx5bf586u/3hVn5cQ6ONI4CmOTvBUAJqEDbcs4dDTPRkm8p7m3jxnnocWx4L+VCiUK8+qiI0m2jZMxBeM6r3ywMo8GyKbQONBcEXHG0CQoTIGedOpiG0lYOu4ntQHtTfaxhnWWhOclbIuDrNyiJx3tgnX0RsHtJiMHptQnUq8hDAvs3Wh6oOMibTDOhoAAGVDY1naRC3bZP3KntSp6OJRpBVmpYGS89qnTF6sGBFOZ2sjA65yOiH0PUopCMOgYyIdoKN+7TtdiCJlV7haFjEsWlqgfVICKlrIYvmi7VALsWYG4r7twAq23hy7CLLWcOHnwb7tn/kj9E9Tgy6zm3rkgqy6min01x0nXVl5gEUf0MAn+lXios/bvgJYYcqkbTUmG8gurMpEd8uHCy8CLFklZdCfuNK9sF8MBOBYF0pDcQ15tzskdIeEOFKmnoSWlgBWHN3kBQvx5B40yQcCWMMdAazNk0n7BvwnAEs1hBoT17xMui3Xq964eZV2te/5nHLDL2q3QZh/tyRZ4AEWgBkwN66W1K5bBnN5iByiNJKxZA7mJR0slWGQ3zuAuWCqdzQtFEgWr1aq37fhPA1T+TAhPyNLoUN978ANAO2D4I4XEgHTyADH9xv1Bb3vtCgyqldvUs5HQtV5gGpgqdjpyZ0bn4PvG7l+ct9/NrpW5hGXZ8UR4BovqnLhxrys/daS4zWRJs88cwr4pF6geLan+fNSPWvulEzrj9qqnFRX2gd9R3+ip+c1rgBHacg2HjFFIU7Zsp4F2J2z3jca1h4oU3Had8hb+kv7AWk/mDZVjETGF60+wACfr8VaCgEvHmfLxIBrFL6WXOREXrsp0e+FBM8hxzDSn9A4fNWEGcGfn/OKQjLzqEmnh+q++uf/qT80u16rvXm2erLeQlNw1XeVW3h6SKzZ8R6BLOVdFCJTly6gf3ai1acUDV2Iu6tnZuhsVSvyCV3QVXA4U3kLiBs+RpRtT68aRpBlNSlFqwerAAgGsKoCxnCgb8rm5m8yccDgKmTywIWcLT152+v+BNCdH3G6V7DSKbkLON+PutrPHTAcSuV9khBCTAXdiQsEP530Mw3PxUBcqc68MEX6SxaEjhclZGWZ6CGeIPa4kDSBNKK+NnJd5fdZPJUhVJl8Ih9Q6f7IPtykJFmPHmR1I6jtDnB054wSgqWwq0ciqJdNsvIkdCKeVM1exJy87MGneLEo65H6IPfUj1ruJRWERMfRepCTnZd6BicGUs5TknYdUAqSEurtmrTePN8GyTiUPgxFPFt2fT2HbdoFILpC0SDPBmVmApvbgszFwSV0KTwuwEo0FeZ1Dc/o3IYb62fwa3cq6Hgx0WZCSp8K6OjOxDGKYzIvtISPAHh9JQ3xjQ5wcAZyieSVbDlHeYjGWfKVBBpvFnm+84yzRf3UhBQBC9MNHL7reQxgpX/Zb39H5XaGJyfyth9GauuYXBizJd/Jga0toZTamwWYHp0PaapnqEPpAtIumlc7WtFrwDhxgIFHSxJK2rdVPdicCdjEgHJ3RJBxcHI1WTcDQgjAIOFC7hshw0vJH2k7e7fKjhfim9rdnntazIKfnXic7LpLeSDYvFHpKzaK9SgFf+Vn/tRyf6/2RnZxNbSCrDfZvu03/7v0TymURVIKxd9zxvjSFcJUiMDNIZ0Sgf52Qukj+qdHCtecGk+TABVX/0tCfGFMyLteBygFV2OiB4yBj9Uj64GeVmYq+wAbeEWXSQbgUIrJP8i4Jdyuc3LlJiYbKFoCplNbLjFW31N5Ezr2+dEGIRVM13GWcUeaR8R1SVtgc0OARerBIfDEyJNXd0iW2r/AayqdhZ1khSglbWTg7U71be/FJPNgdfPiZJyokDDTnZJwHzXCPpO+WRSBZAAioEwAYR7CooikeYFg3hhxBBxowJWwXxwzhQH5VfYlYL90wQFSbk9zPqTJVTj0ySHQzFwk7vduLAr06LjiybLjkFxIMIDlZAFEUqM6xmQJB2lD14/4TwZ6NJzlvFYxcd9IWNTpO0176tO0pXCstL9n8dLt08Ik+lLdO6rSzmuC8ZpChwSwrL8UpHMotz8yd+vEJH/RDvOXP5uUQ387znhS9MaAxMyjCSAcJ+NpOdFfLw0DOE+YA1oSVi59QOCFH9XTjDYWuMejBVtlw5SAbaegvcgiIhrQ7u8YwNxIWmiwRSE/R8otctIYMpZ4gOW1qJ5X6ovOL5DHahP1uUKZe1kBl0RySsZrFT5rKVTXU8JwKSOMEzAllAPXaHIAVa/j1gk+S7v5szL0FIbtO4Qp0bgq591FlA0Xn5aqFw7gVrVkhZc1JQNr274GWsmN3zEY/wvAX/npP4nVPmu7CLLWcOGbaN/2FX8UAChDZuiR7m1RtgOVqHmJiB+SISfp2f3thO7ZCf3TIwAY+VPAr7jNOWOobHpdzYSRQI4HWOE8WRy+BVj7LdB3yPuhqYHoboMMGgQbYrQHWLKaLlIeprOVWHGKxWoagrDj5MEGCAnbyMPfAqy0of443yOAlfYEAqYrmhCl2O5wl12xXT6QA1hUjoMnySHUj0Wpjx2fUxZFpQU29QCuJGuZ15ZUpBf6JjZyEgAsS4pfzXu0sAsp3hyw+Ki3JGSTYBBCM72kbWTw0AAsfywFiQ44wM5Vs/A0O69JFIBt34asZvUM1SvIr00Yqj2WhPBmoVOAJ/jnnQ+qdgowsvby9zLhLoTENKxcgPN9+gOcp0tI8yztkBZUy8XSNmq5mLTvZ99fOo92X1pGqy3E7n+7kBgBODK7lMpxJbPohwvtkEm7rSfI2YgxEXAqkRYnwodM90Sqv3lmIt8XvMgUrzjEg+XoB0uE/Fm7Ulago+HN0ThywtXy96tSMTYdpquBMyT76lgG6qLyrIJ4qwofMxf6v2SU0xmFxUu13SJmOk4UShTv2DjR//LMnSdKNsqZ+VjZwLcuHtxr3xmYOjVxbg7BFi4RVDpT19dIzGq/JltB1ptkHmCFnJHubRHPCcf3Ebiadh2mXYfh2YThGd3oUq4GgMbShaNAD0e9wlSi43mi1Z4vsCorQADhcKa/KVnxUk+m5JWhPlDe08ODmrTH+Ewy0EUKWzBPQTlg+wFlP2iGi7Q3b+yvbKnuVx6igjUAxicoUFK2hNLSBhoGS/uAtA/YvlYwXZEukQg50o7sj1a4tnoW70PLw/IyEBoidGO0SRMQqEqboP/7kGK7Al6SvAgefBX3J9/rRO8ItnxdogMUmqHm5Ala87XwxqvIaevRNLeUIAw9h5n5U3AATvtH5rQG1BjHiu8pASgi0bDUNzpBwrh71bGK20dxXrGm37lPZjIHS+fmQBzdZ40XQ5wPktTq7zPYfdkfXGHpxlqgJbyttKG25yFg2gcFXkvaWgCQrgakqwF501OZl4XsthZoFVe0u3QsT9IF42ReAFfVvkIwdf8hIrMMQ+lifX8scRuTJcgQuKI/eb7TJirQCrkY0GpNxiRJiuDxsQRb5GmBdG1/MQ8Ye4FoYRgVlMQx6T0p0iHa37uo95lcZ9ln2vV1WF+OJcZgBbstAa2+V3BlF4THbuZplSmhTImAlhDomVBvBbWTSUQAs9JdIWWqiuEWv22NVADKV6u4WUK+l+jLCrTeNFvDhb8GE60rX6l9erRDPCeMDzY6UPUOTMUzgZB4eyJ3d/MgtbyJtvq66WE14YVjLYKnbuYQ6KGvshpd6KBzE696f+rzLO3KUKINtyPJTbTAwhFS86YjWYmho0GOleXFNL16HzFeRQU7SrxnkPPs19VZSg9+znhsADDc0EpUAKx4CbRgrQCiDqrlI23WVfWOSPO+0Cz9SLZFxcFSbsmxmfBzk1HIJuCynayVmM0AWDxTSr4e/ITq+y7qMcVLMtOtkkIAPIFQ6JAneJelV4d+rF+EI1XXU+TtCh83kwdAzlc9e20tOfU4yO+b/lko5yJA2aQfLLyaN5E9DEZe1r5xJXgCh7dCsn5oizQL+JF+lOSK0pFXi6RC7NgVGHJAfbym5+X8aHYqiGfiacVE+xThVPXgNt5KIclL8fHuRN7j7ihEc+eVcF6c4iZdTbZpZR4EpMi9p6KXgcJpEpJVb6d4eHKVlaok6+Za6n4CTGJGvT7WX3kI6O9SdS76/6W5qSHz+2Lk1au2Y3k3ftu87ZE3UWsjaqmjW2uLKK7TeYs3jBe2xyapyKu/n0ZgmghQTQsZE8EWuog2TodNLfNgNQ95vuHv8zXdvOJp9NI8dC52rUofaa5oPZ4uWULnpPOomY5iP/hff9+8/asBi35dstWT9as0UWvPrHeSrgZMj3ZACFquBgCG1ygMGO9GEsw7T4i3pD+gD2TOlrniq6wLwFLeE3ulGtDTAizaT69V4qsyJOJyXwBYpafBtfb01Mea9p2KoS4BLM00OicalM4JeeiIvBuDKwNSKoBF+wBzrMhTk4eA4S7PAFZxXiUULqrrAJaFsopmHwJgkrtxaeQzABivBYzx5zrJ1BODptvz+C+hKtWbatStvcVzNqCxYBo2W1p9wrxWMx2sNnSnWWD1sdIAnB5ETBwWTJv5cfS8d5FCq+1g3IT01EvVZMdJGzVc+Jzzfp6FqVQAy5+fhFTj2YjkS2FeEUUtnYGvdkg0fTNwu+s+bcOEAqzrAwHDLf3b386/nq7Jo3W+H5CGgPN1mP0ecAWpuSj5eF84i3Rznh/ymLMUmgcsdBQvD++X7rHZvtSjRa/6zMoiRtTWxdt1IRvSg3QTKQVfs4S87a3qhHoSn99GFU0VL9aF+76qy7kAxGibgng2KQQ53+nawoIieOqrY6iuoFatEAHTWPd/3yP0PXm1et6nABsJJ6YE5KRArEgikQCzlpcnHi3OIpSxNe8oo1vEn7VMj0RGdkO16AYc+JZzCIFAnPQTH1tFtFf7rG31ZH2OJuDKF2LWFVofacAYOvRPDihdZ7pUTgQOgLlr+w4IAXk/kJuWNWfCKKTF+kFRYjsDqzYc6FcehYu4yv+aVSSZfZs4B2zFsvDSvlOisSdWB3b7a5HSI6UXx+OIsukRzhPybiCAtettBZW49l6wUjppSwR7cc8LoTwPAd0h4/GXb7B9nPH0yyL6OyvK2x8L8gBsnmUFSrtXR237pMKidn7ZASZPHjedItr3tA8KtvoDLDMuuEk3GSCMvghzJIK5CEeabpR5VLw6thZDdqHKqhiwZCG2QpDyewGeeg/a/r2Yp89i7M6lAlj9MWPaRQx3GdMuYDgUnK/pfe4D+lMGigNxch7ZTcIyn/D5RAZHkTWcfP2+9n8to9NFzAjVPpzqPINGfjfSs3ih5LM8BK1LKMWiARau7Vw/FJiYaSbv3+aWMleHO8u8lAxDMVKzt4xDr4uVtiSIm/ZA2gFpZyB09wolVuxepc8kexGoMxyFYzZweaTzddTj71812gGiI457b7SE+APUM6rP4sjeiilX20q2mmigSbZp5uQC8QJHFqjtjkm9a37BNvO4d+bJamtlAuzhl/teuFLnybijpVQef3+uSq+Q85DizfIbbocvaC0ev8DZ1GHijOdcMF33KvFC90um2osu1F0tPjgBKRS4RKBkHiRf21DDg4LmOwNRM2kd9nAxKAuSedj3NneAPVsdL9A7omWEMWm7fDsBHos4gzOkYn0aXJ9JYoGGlo0QL9njP/iT34vV1C6uCFaQ9VnaR3/nH9cBCkBNHHeDR7xzPKuWkJlyPUiw2zdfbXSfYcqmI9WSVGUQOkjl9QsAqwFOqn/EK9/pankFnN3k5K31JHQuvbljDa7qvHy9Qpf5I0RaX+C10o2S8c9Npof3cCHo90X0rnTOcFd7FHav0uB1CWTlxiOloq1NCRSZbAVkieipeqwk7MbAqjsSANGQWFuzEDCQ0VhdRy7M2uPFSJGLhV/a38tnoQGVjWL6osK8s3YCEW+OlH5pPWXyvgJYAHwWoYieVu107ZeMzup8WpBVZL+53g7+no0KsgADWhLWG68C8sauZ6tzlfsaQMl9JX2gbW7OwUjsNdBKrCJ/fIm9Uo9qT9/2Vfp8z4sGyWT1IGvaB3QSim7KCwHA5obEMzdPxznIAurMugucKfpNrp5ZyfZV4nuUTFLu6yYxxe59WUDyjuQZaMjYvjg6nZMBLcA8M36BSB/UCw3ijIZ52NC3IWLRo6eUCc9JdeFqCRvmIaI/koRGVeewBVvs6dLvhd4hPFkBWodjdQ46/wrQkjCjEywFYEBL+kBI9QK0djSHZH69KIHh54bJaZ+1pX5kWz93tdZTybO1ADWA54CsNVz4WZgALDW9MQtEn6RacbOIXLV9Q4zE0CNfbehv6IiwCFA6sOwvYkZQDoezEhd9JsjMDS7kxobrJccJuaA7JdV+0WLBLtQGGODRYrUSojlNFcCyAdvOWUn2siKGCytEqPK5aDe1dnhPj+5UaoAV6G+8CuiPxKPavToiDyT7IKKawu2S4/iwoV6WTlbn9DftDVyJpa14N5aBAmCTzCUTeYLq96H+ri3iXAFdn5Yv/7bARd6qt6lpRNO95vXhVwYFStBuOcgtQAocgrtwfO2TXH9vWlf1q7XLnVe4EH5qnyfA5DP0+MvrQuFeqcp7t7gZjIcngNEBXmcKwmQu4n7TGog8p0qtw7SnDY/v5dcXa3AtYEs9jw3pPi+sj84PhouhQz2HJoNTnsPcR+RNTSnwx9ffXzBKTiGBzuSJ9n0gcVS334q3xarpolYPMLibsmYaly7Q2CJ6VF7iA9DqBFJr1GcoVyWGlgCE4xWCFwJeHsPX/px23YzwPg+jQxN8pG3V69CTx0l4VgyegoCnYSCSvPCt2j5ncdNSCgEzETaVDPLjGeF4RjxPJDp9aUhqn5221mLKNaBaev5cf4Yp42O/7TsuHGw1YPVkPdc+8vXfTW5kJm3H40hgxZFLEQO6JwdaLY1TVV9LpBcAVOUSxHOVNx17QSzbpxqIxN18oGyTMKVq5UTHj/QADr16O9TrsSHCe+mjgTgQQCpDh3iakK4HhDFjvD+oZk3pAqZ9h/6QTF+pY06C18gCAUoaDOFWzlFXkFJTjM43Vt4UC2HQOad91PDkeBXRjQU37+/QnWlyCRmqa7R/NWO8Dnj4sxQilDIjpSev0bSnz9JGSOrQsiuAnwyJozXtuZQL82RkUhxuinLFAO/BMiVz5DIDiVQ2Bxa6YKu8OgqYDMRlSev35GJfgsdpfXl9JZ/hp2VpdlH5L8Itm3bk8QmZ+UnCi96Z9ypMUHJ2K83QZjNWiwsmzHvQqQkMHArU0JsQqoVfNblzSSbSqtIJicVwRS8Icr2jJQj09myI8OW0Dzg9YK8W1xvU8lUTlc7phOTuAGPk7+JUlPvmva4+5DztjM+XN0CYQLxBKd4twO4+hSDTVUE8B+3L/Sdpu91rxCEU/TXzDFq7AOOVibdt+5S8qZvHNE50DfG5KsUiIVkY0ApTRtlExFOqxgn9uWT0sUe2Ta6QZJY2O1NLN8mkvVRDk0FOdOFFkaSJdycaM3lcJa4TapK2iK6momFQ0c/ShZ43CTlKGNGdbx6iPT+FvaT8Xu4X1Q0sktlcnKSNLSoFsMVzonE9JQqjjhMDRyez03dWOkhU4seRSPDjGRg2xNXygKfrzKsVAp1PCCTTAwAbVqrnsTnkXPe/ZKMLwT1G1crSfgrBFO0XojEUahVP2oDSdfjhv/Px2TX+IrHVk/W52ke+nlygMuhEIZc3yL57cqAbT9y8S8TKGJcBFghghTHNB6CcEU7TLDToLUjdLMBWPrmgbElLy5dK0aacJirFc5oo040nRA+w4imp4rGRi5OBAh/m8pyLPrIuj5E+S0eSDR5gaUV5QJW+PcDKQ3A6SzTJiNK6hFPG64DpipXbRaqB+SNyjLbsyhJZOfdun/eWn5OZV0jOXbK4LnyvYc+l74sBlHZVrEBGgXT9vZD0RQm9tXiBbC71DSXU2j793UnET/nwTuWd/lk8nPOOPP/7WWFpzfg0TydtLw1u3Welem29Sl7gld7zRCjzhJO1AGA8uLYb20dxVueuDk8pEZ+HgOmqBmFiwzP6oL8NyJsy6y/1ag3LHS3376Yp8yQgcmRCvE+8of35zLH5zZh3TGbf9bPvKruw1L7k6UpO+X3xd0pD4KL2U648UWU3EPhg0Uwtm+Ob5EvdgEET879KjPNwmSx6BZy1lAz2SKlwqnpoa09gO877iAItfmRhKYkBnekJ9p1RPDYu7Nd35OEKwTS2Bgn/Od0tYM7f0gU5x8PPTci1DZk2tQ49cKo+T7la2KDJAJZ5STjCH/0dH8dqta0ga8G+9Xd/b6XVI0KheTeozlL35EAAy9uwDGwAIF9v6c+5lOPBxfhbXRexVtPKa5sA9l5E5STbhYnu4kLv7s7omC8m3K90NWhdrO4wojuMtJrddqRufEpWC6vwAB0DFZvmiVGyaUofQYVoRaU76p/31GiznV7OdG0EewAa9jm8SLUK0w5AIWCV9kDa00T2wj8ciZQ/FSBYH6Ydga3M6uM+jABYiGgpu06OD5Anx0+E4vGIjdCm/dBdy6WJR8BL0x4xSg6Y/0xAWNpEBVh1ey1UVilVKyG/LNba84Kbrbq97nsBYJXO/V3KAGOQqwCrqdnoARZg90dbM09Nw9DyakBqqb0zna0WaA1APNv1LbEB/zL3CDBkiQopQWR9UQOtWTcEAl9xmoeipT0i9+DBeihQPbSWFwYQ0NLSRQvXdnywqSo6eLNafwv3YOdD+wseWBi1oA3J+vvUPuN/MnTcqlTpk6nJ510PTJkkcfw4KITvKWnGXJUNJ54cJmv7QtGLQEt/WCqgVQZaIHbHiTKjT6laAMn44rlqcg7+r5U8kf2KnqHWZ+QxXUOJQMWrDZuB/rabWiFe9psyygJoVn1ERxehdgogOiEcT5XmlvaH+30YmxtLMiY3A3nKmrqN8XhGPJ7xka/9ruX+/iK1NVzo7MPf8D0mnncrDNmIdL0x9+8Nfy79JkrnLalYBul7G8uqA9CJfMPE1etTIdFRX+Hdu46rYq+U4RGmRDf4xlY2wn8qXWcDkHhKpAYirxbV/OqvCWsBtAKOLEgKV7rFDlp7YqrSPJivYH3oR8QFp6tO+V6lCyRMmAoOL/UIpWgY6/gyZXINt8C0A174KdYOkjAWhyZIdsAfi8vvJJqUNGy2p+1k/3lbh8K6EwOXXAOQ4cBZc+eiAou+NqF4qMKYtWBvVZImu3qFjfJ6m0HY1lE8PerQnSwzcPtUtNM4RCH1ygRosAgrimVxSj+PV6QJdr4fEM+owp2hQEsWiUdRyeeuhBCVxanvCeXuCUk9SMhMVvZWIkf7DNb3VLC5qGdWhU2nYpOlB3xD1PusOE/pdBU1jHd8ofZUxpFCeCIgKuTyNsmhLYHUnQq6c0basj6XSyyg8Cx5PuTVGgnN+pyobCmme7TTPBBvK6SA/pYEdqmfXaLJyUCy9Ne0j5wlKf3W9H+TpBIbnT2EUIEw5VMFmOinS0qQ52uW0OH+Fx04D5DDxCHQVNRrXXMMPeByXpTM3wknC7BxUbPq+NV5aUIRLhds0QpU42zpOiefwz/sSNZmYkHUxN69yNdb7kP1ErskjJCyJkXZfS/toedb9bTkOogHzSm5Ux9wg1j1HV1nPC2x44nG+mmisKH3Usl8MfQaOqSQOp/PaTRvl84Pfe3hbOYP2WfZNrpdYlMy4VRAr0+6t8WP/Ph34ovE1nDh8+zD3/i9+PA3fA+6O9YbeUaeq3R/h3S9qbJGaAPuzxZgtZ5pfmAFYPXs+dJBo3HZhtR4sTSzpFOph+JXEIByroiHYoOHrlanjHBKlRwE4Aa3VCqA5X+nAAtuAGxCNksAK/dxEWCFUmgVnG1/3YnUliVMGVLB8cWukpJAMT7VtLN9CufF829oQOduk9pvBxkQqyaZAGUzhrUlVeT6iifrUnhQJ+WpVNeo2mQhy6v6fKbxIzut2yIWm4SEWQit0e+Stm9u5Hf19sI5i1PR/6vmsN7U83SW2ozN0nitfJHl6pzkZ3LOTv6i3mFzQNmuUewfOQwsXKzpmj4/PwS3Y7m9k3CpFjydaRNxuh9nyuyaQSpNb8sIMUhSYHdngA+w62AhTVTft16nDQPsVitNTLNsr5a9Wb4Oavu5AuKmX2ZZgZqswc/y0YF+/zuZs9t7pk2C8F9H3t5P6Jc0rnz7AwEsndnU0y8e0mi8LufxkrG4vzlTpILPRbNXxePK7xUsycKFowOSTSigSuQunktE54UzAAOSIdD4vxmAcbLwIgDstsB2gyDaW90Fj+XBFvTVIYW35eoWViZ9Lv0sc8pJdLvq+6ZsuQ3SRncvfuRrvwsf/l3fc+HkvzjsjYtifZHYEsACjOCtHqwGYKk1D1F6sFV9o/6xhRXD0YiOoeMHFM1D0qjsYkoUx2fPVbne1d+rKF9SjwbgABNn4CwBrDJ0DMDcakq8bFNGiPUxqrRe1x9GyI7V5yZD0AzQuZ784ylhfDAQoPKDcQHuPkBeFz8Ip23A5llWT03pUKl598d6YItnC/P4yTOUggILU7aeAbE2VOj5Tl7dvco0vDSwumzLPMRF4KWyDcBsjbR5xgDpVB8gZPqN6hW56xTHOUk+TgUbLkKde0fqnxXGxoxfBBBovdRfuQHZbZjwIsDSBjcAa4k3Ffz3BrTCVDRktQi0CoWg+zv2aE3SLrmGdhh/r4z7gN1j63M9h+DAbWANtx6q+6Yep4nu2/5AyvDdXUDamWdTMgdLR96t3HgKJYOytf6QWcfKeaBg12y66tAfocT2NhO6DKRk7rMDM2vjeS/wour/mCsPuFfFrzzf/l/fRn+du0Dcq0YPS7T3pMgx7dxpfnkdQW1IRIHLenb0D81cTGCC93wxIUXiqza6809Xg84Z6gXKQN72CrBUuT4EHU9nNvTK562AlifDy7jPC20ACKczFZSeEso4Gl/rAgANLYdLT8QPktGus1wDGe/ZqxZOI4U2paKI9NeW9BDRd5AwbOT+Sfe3y8f+IrEv2nDht/5uElLTwszHkVzo9+iG0ELNgvLbLAtAb0Sf7ZLubyGZY/3jO/pQHqJWW0VuUiGJB1f0FLBwXh8RTolE5vzAxVkyYXQu52KDClWxbz53BM2y6Wer2cIDgj6Uwm1hPgEka0627yKJ+EUDWDqZaxp0rt5bW+sBd3xInr+79/RU220Czg9s0Jiugfu/kJGGQBlVzjT77y7pvqnvSGog7aIqaAOcwq+hEH6VBV2k/z35Xow8b8TNkUlMuFkkIDsHGCK+KAKP2nfO8zILxcagoZbMCu0ArIbhKZNIahOWK1ISJdeZVUU8A8WAkXFoTHAUMMDkifkebHiPYLcklVB44neeECuGjKqcj/LbGNhpuFD6zmWqxWOquVq5IO173bdUDuhOGXcv9zg9om3FczU+lPswoL+zNog6e3ei0GFLdC8R2DwpOL4U1Osp0gw7znK19tZdERNlskooUsKF44OANLCkgzvc9tWA4bagP1gofLiRcDqHsWWB4rJyI5fcyZuoXk1v/TEhd3HmlY9nUltPewewOhPAbSUsogMUVaZnb/efF9e1fpFyUWXm6bpUPkcXLE3FC8rUK0wid/e4f7b4GbTC0MWAHGBgJLvzAfT76T6NRaKXJaW3xMTT1XElD78viSi03n8Zb4tfFAOm3H480/gshaNlXhGQta/BSrg70jG9UKgf/2PQhblSS2QuknnNC5EC5jFrgK5tXyxcK+1SPlkzR3pOHaCh2B/9m+9K1fiL7tUvynDht34z1V9SgCXlCBhgSe2nIGUN2tCPaIm4mzBfDUj3t6RR4sYMFdZrUnTth67YKdxkyeV1VGfFrTJVm2rKFUjS1VwuFcAK7UpJHnL57XmklYl7+JXwnpzybyrmDUuculxQAax2AqgAludI6IReEFLG+HCDMGXcvadHzxyUgcN2w23BdM1cmsHU2EX/qgVYLWBpa8LJRCchGu+5AGgCXcpE7A9ZJ5uWyG/cIyG1hurVT2KAm4QW5B+obSYU2Go/Sean8G9aj9lsEpPPF8j2FBbMBjDbbXnfKkja7CINLSAhL10bagKgRbWXCOBL5uUqqLF1H+v7Xe21EtA1sRaWqq3D3k9XBWk774+0Cxjv2T0i9uzLaN/Hl+g3dx+g16dfalwzwACsWMgE0pfAqCfdL1qpt9M6leo9ps/lvu+PyVTgfRuSK2G1qxuYrgfdBlhIQLiY2HBh3b0AsEzzy7y39XnUxzKJCDlBDut5r7pUOxANLdiiQDiRJBFTZx+CvXJV4XvYvtukJXnWSg/V3aODyDlFykb00jQiw6DH5GdHhEnVq9+AsN2m9ixd6OO8cQ9QdMBGaCX+t20ylbwuZKvPLMZ5KFJkKuDmFQFgch662K5/K9IiMv9+sdgXlSfrW7/p+4AI9I+PdqNMWWUV4oFn23Gah+wAIynKg9l3SArMSEMrPjvSjThOBDhG5+aOwVB/CCiSMeKI76IFIyURSh8pm6+PpmvSXjOnxxVOo+nfiMRD15HHzWeuTInel0Lfy0A3TrTqmRKtVNzA5ktlCAky7bhq+0DE6tzFuedKyrDIrprspvMj6sPTiwP6Q8a0j+gPGXfvIaL33fsjwkSaVaUDdo8Lxn3A5iZT3ULelyrRR2ix4em6Q4nA6WHHgoE0OfUH0hvqmUjeHwtrR7HHyJG+ffiMeHN2Lp6YLaEqkZTQgskug87rCSGbwGo8Z5SeeGl503HINoJCW7KadkByytUEWGaTIx9CJ7Rmu855XYoDVRHzMGckEClAIncwT2ngkJZMOhw6K7H26qRNoHBYYa9Asr4NmQCEllsJBE5oH5TN1Z2zemimq46U9kFenPN9uk8OL0b0x4LDy/z6HiLZj/fZU/qieKcDkAP6A3ldupMsOoDpumDzNFAYkR3RuSeiehwDzg8y4hiQ7mX0TyNyD2we04S/fd15Gs/e+2P9n1lj6/wgIO1YAHcoKD04zB0QT6SZJSR4AbjSz+ppnKwWZjwm0ro6TJw1nJCueiNuT4X4RAs1BP19k4eooUIRCS5RQD9Iz0q8WGIhOK9saLxaAnycV9K/RrA+IOrfhMAeZVssxvOkwqTCX52pwTf/ex0sH9Ztw99UKorG0byhpJu0p7F62tGYLIu1eC56/4XCHlZp37j8fIoWlRLEvedJxu9SjPfk5xkflttvFWSFZKLX4TSi9B1pXXWRFtSOuF5i0PCizhVHFrb2lUKc9M4sk13oKI4jptGZ7aC/zTsXoWkoK+IpTNcDkIEf/RvfjneJrZ6sb/0m9l49PlafVwBrnKrq6WptqiubB1iA8bl0H/LKAEtvWn/jCurfkLaVKrtLoWX1qjWV6eUhdPtSr9k40erCF6AGLM1YzkUAVkr1uU/2MIl6/awWWbNC8gCLMsEckCgm1+D/xCQ1Xki8HmAdXo7qZaFwCXkshrvMWYSlBljADCScHrJGGWNa1c06ySTmwgAjEb7jwkJvSUVcV/6N9hJAK1/hXHnPV8vBUtK6kNSFu9EcruOQ0Cwlfekp/iyWRcJnq0+IXiqPVQu6Gu+GaEJZfUR6FYL7tAumVC4YMNtfve96H1qKSUKCqunEIHon39ux/GvdUOj59gcDo+LpGh8w6OfX6UpAUL2bPPD3D7jx3NbTC47Uv+DRCmlepkeI8HKPRw4rHl+0EK2AUD2Njie3Vl+N7yPll8p7x91boB9xSaJQhblbDp1lujY3W3sveIDV2ExV3mvsxbDoPSu9eK0IAJRNz6Au1sduZW/8/w7o6X3K+1QZBSfCGblcT+ckdghYQu8fuf9KCJDqBEAN6qoxcjOg0qTy8go+xMdSPLPzcPuMZ2uX1dCtQ3elF2J/HWGQc6Q/BlV+PmiOVZlkGXrQJ9fNgbfKetdPgCYYdLd0j8q8/G62LwqQ1YYHBbEXXhGoB0u+65sHRV5L0Rh/ekSxiJALwuGsoqHeo6T1qNwxAaBsN/wnGXkyK1HtQ6l/qJOphC3buDtAwChnq43VPri51L+VFY6ciwtfkg5WNIE5D7rcq/RbBfCmYnwNMEjM1l/V5659s/p77Onx3qM4zkN6ANSLpdyNhYl52sfmNwXD7Vx7SFLkjcBee7GWQm1yzFn9w8ar5NO5geXJDyB3esuZUcHGsQFemi0l+67bZ1yaZuDzDohGFmBpApZjlL4ZqMEezSYU1E7OngcHzPtEP+/ZCxLDbDJOKuMxVMfQ982+4khApL/DLHM0nOPib04vUD+NL1GnHD9IN9zIQIrKLrWTEJD3GeeHdR+nNjtRHkF+He4y+rtmX4E5iA/rz2dhRgU7FxfO9DvWvas+O9X3VssdlH5uxVDTNs6Fb9tMwbaZjedUPw+oAZW32LzqvszLVu8rEPi5lGAC2Dgjh5PjtvdyH6vi7Lr/QpzL7px1LLgkFqvtyDymt6E/HnPlz7dvxokSDhUT46tsZTkn0SiUsJxs05GoaWlCh6WPlEC1dZ4mWfxPyYRHAWufAFwxCU9GdyxpP88t8ThxXUn+TQPMZV6T+/PdHj58V4cLv/Wbv4+8KuIVaqUYwJO+gImhr0FVyvDAKl/tUIYOed+Tavqzo5LPiQOVa3DFdam8Zkm+2rjQYES8ozBj9+QWZTsg3B1RNgO5ZKU9Qw9flgcAcB5rANPG3IHZQFJ50wB6KCSUKdksQ28hxlIspBhjVdC6rUUoZSV8anOVkeSzC3UAjsoJKTEYt8ZpHJ3vG+G0RNLJAoD9q8R964+JSamUHRWmQvsptNr0ng2TJ4Duj9oKC4uM1O7uTKKC9N7CV3mglWvFj5FxknWytLulcK7jxMRzVm5CHLNp6HACAw3ORZMc0q63tPHsBSgdH7BjDawAO75MZqGeQHx5FG0zao9SyzsBhP8W9Hud5B2A0H4KcnwJkVq/eG0tX66IdJTsuGlDIcVxT+WVxquI4Y6SHjY3GeMVi952vn2ULZi7oLUYp2sopyntigKl7mgnNz1MCKeI+PIJ6aZH2GaUUwQ2Gd2rA/K+oH8aq35J1wZ6I++rv40aYuyOwOYpHWu4KxqOilNB7qi/jg+JayRFpMd7HLLeUNfvPxUwPC24/nSqQL5M8t2pWO3RY9KadUFCUjnrgihve7oHfJFnJx6qumUu8Ubvd6DyNHdH8qh2JybTj1nLWVVF5vkZlCLqYrVnrWiGomjLqTCxSMvI5uwRV82pVOqMPT+Xa9jLgSZXDFpKN4XivHPqZS3IPJZM+85CrbKfaIuL7pyJBF+4XdkWkkLQt7HP0SR80sAS/63U3n4pAO2zu/N20MxKLdvjvWdevZ3H93Jl2lmSMR/OYx3BEW+YF0iV9lbZiMHmDg8anY6Z8oQ92JYyQ3ydpPxP3nb40b/2jg0fXlz1vGs9WR/+xu+tCMAKsGRFIeVsPMACDIRoVooBLADIHKevAFZyrlIWiFMRuRZgAeqilhTX7gkhh3DHRPyGSKg38JTIq3V2K1T/UL0RwJLzk321+waMM7AA2kzlvQlTqN5KrR2zCLCc5W1/cVWbdvTXksL7YyaOiuy6IUMLUGtX3sNdUeVtbTeHYWbeKxUcrAGITDikvN4tr8YDnXfrQepOCf3NOKsr14oUYsZbyegO08yLlLuof2oOYAHOg+Z4EX67qt7hcxwjS9eovS6W7l6/zjxsyUBr9ftA5ZTyYGEy8QgKT05ex6vaG6XXhZOvIivgk6p7fZz+QJmFs+NvGUDc4+uzYY/1S/SsTQ/4nmv7KQB5U9DfzofS8wMC5Jp9WARQ0tvdk7oRww2DJ6mb+fSNn7207QicNJ5NndAb3SYxEen16uwAVG9u2oWZTti0p7CaaG/JM6cepoW+AehZzNvlG0zvQbnfRXtrqj/X9rkQ3+dsbXhVPMtNeF4XEyo30vyOn+/qGXcEep+ktOgF8tvz/mbq+yGgcPmdIots/9sQCKgUS0aqEgP8sZ1IqCriA5roVTaDK+sT52E/po8QvaT1aMb6VebORElZUThm7XUUD1i25K14SlrO7t1k71qQJRbGNLuBw5RrnlUbHhSvFH+fr3bI9zbI9zbonxzRv3pr8WyXaRFuD3ZDs7s3P6CwYrrmlQjfwB3LO8QnN5SyK2m7cjOXQsf3asZny1QMzrW7SIT3dglgibUcAdcXOgA0QoAl0GDnU6TplffRpC/7lfjSIEkleGiSnS7U5Os52tuG+rRGmlMVB8ASB2UWcgmJVuWyMvcWz4W9AfXnRAa2lXHX8KjkfX+of9jfTegOU83vAIN+JhEviULSd02I8FJIxnue3KVXJfpCk+oSp+ySj7ol0puuEarPW0DX7ndJuHUGcDoGWC5rFHD8qn092WmyAR9DwjgSUlYeUSIe3qyo9UTbiqwCAAyP6OaKHW880onG1+k57p/E6hjivSqRjj3et7Cit/MDEm89PZrf07kL2DwtGJ5Ku+X8ARTg9kMNqGxCcJqdKCBHSsg0z7+qkU95udwT5mC41TNLzTVJW+YabhbO60I4Le0j0j7Ov1caBL9tIg8t5UDGDgp/xVk4ygrThxrYAFUmNzWWF1StYGcTomwzlPUeLgTGiDu2wFdrObi+/W125YwDZeCItqP5ZlEI2FNJJPLg38tm8r9SV9hrJeFJF/6TYtYAapkIzxvz7XaeQv95JQcUgl0vzYbPFGJcGgffBfauChd++Bu+pwpfaQX0UmhFFwJ5rvzNEvhhzAZikLNm3OXdxlTURZGdQ4lKIPeaI9sN0kOSlpYsi+7ZCWXboXv9ljJAbg+2fYwo00QCfKVQBkgbvvNhvXYl0V6/iuC48DDmUoMp/wD0vbl7fWaKFjWluoya3SJZPnIuQDXIV+UtAOWeSSHa0kekXaeTxfk+/TPtAnJHXqfkyt1snxUrG3ImPaN4puLSIvwoIbvc17o2uQ+6eu8PWb/LfUA8Z5osHCjxk1G12lfvkPOSJgvbhLOU1+Aw5mhkdSnBoUKKshoFmjAq6eyUoQOy3Ud5a6niPnRYAqpMMc9d8cWMK/6U3BqZz6nw8QsP+v7WKTah62QjIZNQAywhF8/MbScZldp/gj9L4TAhT+6FAVhv4Ga4y5AMuzxQWHfaRpSO7psSiFuUB9pHYimG5Aoyh2QATUKMAJCvMvqX6Nkcn26x+TT1e38bMN4v6A8kHhqmgOkeJV7kHd+Ph4j+lrxkwy17YU983h2FDnMP7D+Tq+zK3AUcXpKJHDi+18Bsx+T8F/6RPa8letHYrN7hzZMzK4u7MjRuspVnt3QRpQ9akSFvCCylLbUpbbhkEAM9uXaa0Zjt2ejGoiWJ/P2Yeyu/M+2i6qLJvdgf2BMkZXaKja0i6ULXKatMjJd9kN9EtxARHaw2i03GHMmWlGLZylk8J4tIAFpqSMDjJJm9nZ1TmLid7tmhjGUHDqW6hpO9qUJqLlwo88gsbCjXbuirckEVqGyLZkfzXOux5NhdrPi0mjzgpID8Qt6bLoojAawSaxHY4OZFDSOK1Ab/rnTBEhecPqLqPBYSx1aJigD81b/1x/AOsYuxgHeVJ6uSLgDMBS3ZGD7u7NRzq5s0BKDrkK+2yBIHBxBOU7Uq0JtQHqCeSiAIwJIHoXtGy+XudQ4JeoAFUP2plOqHAVAl31lYD7jswRJryYpi3vsF1ABrab9OqgKwAUvMA6yQCmZZbwteDP1q0+kEVH0unEwhZbvBvf49r6j39UrT19jzFnWAr3ekmX2JvXYzb1GYk8fltxwyaAnFQuiMGvqQcGrzvq2fxnbx8ylT6aGFUHBVkNu3XyabC56mGdlYgVCpt9O2odrfjMB+cahhYBPm4ZfcMyBqyu2oYKlE9O+k3/hz4cWJR0fWTjzxpy21P20aT2YmxLekTzW9ukf6lSvE2/rGHJ6xB1P5V+xVO/L9t2cPtWiviZeMD32+33gt2GIq2D3OswzGkIHT+xL6I/DsN9QNnbZUg/N8r26jApElWQO4+04WGCLYmQ3wAfNnUs5hSesr7QKD2sZbw+FffZ7atWCrldUkTmibtRi14zMB5kEduvr3S8lBkEWGyUtUFuM8a5LNF4FXrppmUEoj6UXDpxvneXKvVUhNQnP+XDlRqAU4emy3EPNtt9/n+ZjrHQrAcpY6rB+hXsKuijiYqr2EAicKPfrQqJyXRD4WqALxMNox5ZoN5j0DYNmT7wjXzhvbuwZkfcu3fD+8YF08TIhn+tPQoKwe3IMtK5RwHu0G27FAXyGCXjhNit4BGPARtV0hhHNoED09tP1rBKziDbNhT2cCNiJWJ6uwvkcpBaUU4nQxcT5sNvZewnluBVRZ65Z2Wkz65+1SmQW/vxg1Q8UGM7dyAealIpb4YZBBt6O/TT2KC+fHlykBDFjpaxPX1/BgR3+aiTfVr+2krJ9fEu2csipUV59rMeM55wogToEW4h2blOaGa6X7dGWHQio2SDYiibqKbsAPFavOVluNJ7t8AVxdLGMj34dQHasNI+m5qhL78n4qk7VMV4dqtMzRECpR07ZWYcuNa4sgS61JAWPJyTekfbExYcbHo+0EQAHA/pc67D4dcfWJiM0T+3z3KntvDsDwbH6K/bMOWTxiA2m6UVut/6Z9UBX6lme2ecbbc01DyWq8+fIR8QzcfkA8K/S9gLYzy5OIppM+p42YsR8b8sYKHvuJLPehevaEO+bD85XHtBUd7eivvWe6sb4+tr0Bz1CKy5h1npyM5XI0cEBNJmk5VyczMwsPgkBS3kT+Wx6LZvegJN8o0JovZsgr2rSlr9tYmiofaMDM0tgeSvMcLkklwIE571XyYT7dsB6jNdKw5UzFC9GSCmiBQJ1UIilhzhcEQMfPzfFEEoiLzBPpvUeW0jzunL/lW75/8VzfSfaODxfKRZAslThShl84OcTu4tCavsqmbuaUyJUpN4JIMsTIVcqb0CBbudpWqN3/LpzOTiuLgZXeqEwmTJk1VGTQy6pdFYahAmKVaFzrbZJsEid8OgNWpdReM+0EWe2wd6+LqrNCpEjOAAkEsqIjaZt68fzBV2FVdnGnK+p7Xzw67TsdrE8PmffiBrTc2yAvRY0BAlhSH04ng6Nrg3pagnlERvZWNeDKMqsAOG+WD69VA0hhL5Z4v1idPYxyTa1fpGakuNfbch6XwhwAD5oRdB3kY1U57612WyqqKO/1uKrQnW9+F+beMPnOgSztP0ClELSmm/SRm9ByHzQLswVxWbLPBgr9eW+VhO8Ci7PmLqAbKbzWnWi//amAhEOzXVsXnhqvg2YV5p5U23PPGliRAJWQ4EVoNO1Y3Z/XQALWDu8JuPdLBXfvD7j+RNb7QQpHH18iD814T86NPUFbEibtTsDmccHAMg2nh/S76YpK5pQIbB+XmZbX+QG1+8xyEvgg11G96/HgJynlcPO4aB1GeS72n8nYPOVs2zsTI0YuiCOJ28Yx0z2TMrIkiWxZoFclJzicP/D1SHR9fIat5+BJ2JOEd8FtylVW8ZKHS0GzW6xUJPQMW6wIwEpFk44IlMgzywDulJD2PeKp+Z2G1GlxLc+DV77vD4mEhM/WN3Zf8zkXDq2q15TpCIUSZ7yeWJgK4jmRh7sUfU7FwnFC2fWIB8osVyoLC5ZqZrlkBTo+LJ0HbFFdSkUq19BkmwQlSu0hGODzbRqThvRU0shJB1VFpF0YEwDQReT9oAvE2BaSbrxp8j7v+irjU0O5TPWROpvy+dtcuPTCsvXd4skKQBgzupsTASzPSRBeggdYSrhzk0hnPKTA4qLgrAsFWKodwjcZp8Nq1tCzA//+TJmCLcAahfPV7M8DLL/90orFh/xa17jGzReutwCsS9bZw6zeq81Aq5ShQ+7nZPUKYLUOLQZYZejmxFTZpo8zwCMueOHgtCR3qaOXOLyiAOsgq6vmIDI+aWjzgveqIVPPdHXkZzIZOKV3ALPsQN2vW/VV5upV+lcxXZV6gOX3OxlIWzwfD7D8fl1YZbkwtQNYS/cRcHHJJddqqUwQYNwnKXdjB+UXuZaN58OkN5bvFcmCE9kGBelSM3eqz2P7Or3uXlk+jxf/ETXkhX+8IEwM82rNPn+FjtPfLn/fH4p6oMSj5S0mYLhZbtPT30II8bzwu7QNOD+gsW28V8cdZYJS7bh9s8gUANkkm+i9U+rt2vdTIwIrQK00z820rT3gyvFriPNW/1RoABLGCtr+pZCfgKOJF3K5Oc/Sx4vP/rTvCHBu4vJUyQuAtiZk7gkwtvxPaV/aGo+12p1wLPcDLV6Fg+RqAZZtX5PX/WsGjTPqPFg8LbOG63WRYM5jVN5zJKfNDtcTaD5PzfjfgqqF0C0AIrsnVxqOtyPZGqaTCKh8B9s71pP1Tb/3T6A7JYSpGAeGRTw15ZTNgyst0OmTI/hBVsX2EChkqJwuk0woO0Lsvqq5FwItxxOCTJwaUmPelairi8lNLNpUIdKr6pMwwTxGlJyt0rpfESzEvmerGAGbSwrDnuwu7ZbMyHtbdWV7/Zx4nOYAy/dn11HGE6dby3mOD5o6aQMNauM1/fh8n16HW/IQne9HxMkm745L4OSeJuBQgOE26QMeCp2b53l4jaZ45jIkMkb4GnDs+SPgxx6ihqtCIqnGqzJx0aT9ULn1K/5bcfwnN/jw9SuR+5h1suiEA69efd9aRqfWCJPzYI2hyqu1QGavJBQK9Np6vktFYnakZu2vYBMx9Tv/n8mDRPpD5r2aVOhStgnojoU9WNDrGydXziWgUt6XCa07Z0w7KhWjemoPqJ8kmy/3BLKkjaKs3h2o7Zun5knqjwVXn044P4jYvZYwXUX0d7kKO3bHgvODDt054/BCh/Eefbd9XHB8MWD7uODw3oCBw37bJwwME3t9OvJolRCQ9twOkIcwjoWI5xNweA99fn4hoewzuqsJm+2IB1dHfOoXX8D9n5JniJ6B4aagP5K4bnfKiKJBFUnHqkQr9SSJBABU/0meMRVQHUxLLaQCBOKZ+WchplJdW7hrWCL1Z+EEk7QJ1XVKW6rWkDYBw63VAvUke/FId6ekY4c8l5L8Ec919YOQiwIsAFo4XYto7zotXRXGbF51AYUd8TWL9FuwscFoC0X7Rn433ExI2w7dKVXeMc1WZK+cT4LxVrhodx6oJJIsxvK2p1JtXcdepmZBJWOGJMhI98lxZQ4UUn9TJq5Ill+xMY86hOc89rqHA5MLfSFplyigCvM7AYjijSo1ZcJnp4tHrQsq5aCleHjskTCujKfk3c6Y9j3+xl/+w3gb2rvLk/XNH/kBAFCApcWMm6yNMvT8R94YRcwyx20HlO2AeJy0fA2AmpNViupdiWm24d3RPFbOnVrGkbxWomnVeJBKyvyXUBxHy8rglMtcKm9L3Kz295d+JwDLt0v7q69KJ4jFKVMa+EXCPXsMW/L1JtJfv0w8Ha8jxuvI4opzzZjuTJNIq9ujhxXNmkv8IS7bE5e8PgEWUljwuD1XWVv7+QIxSfp56bj+Pm1TvwEFWBfNgZ7F0F8ui093C7Dmba4B1tLv1fPkfu89iBb6sQ28Yr9ysRyI8fISypm7cJtdkvg4P2Aw7B43/78AG3/e+9es4bvXaOP+zj7z/wsJev96wu61+TXff9p2vNR3Ary6g2U9ess9hS9be3BFH77v172Om18/P66XVViSVNBnLmA2yctxfVmk1tJmzpurLGDx2ZRqC7mfa24B9NxPV/SXF74X71JZOCcAlqyycP+nLXmn0q6bFcUuQzTOZcBsekxbqnd6qXB3yAX9MaE/zj1C0p4lbTmqC8l/zE+tvt/3SFcbJNZTzLvaK6nkffFIuXFnNgcCzvOVa15yS0h3nLeQ89zrDthYBlRk+zc0KeHjfy/tZ1HSkJLOLdSGonOvJPPEVJRmIvP/O8XecSDr6//An0IeIvpbJofriqG+MRRhbw1ZAy48w7WeTESUQ3TsxdFafZ5I6m56EQ61bMAJ5XiqgRJA2YMgYIWUjJO1ALwAONKnvS6GDcXa9OC2XIOkxk5N6MNnvIjgnW/PtqtJ7osTOXOMImYPnqSLt9lu+j3LCCwNrnRM9lZdAIrdWDDcpkXtJ+N5lFkYU44taeVLljeUdt5OlEqcP6fFMF1o+ny+Y97ugrtes5Iu9Nns3mDT68Tn3TVaXb5k0ZKZJtByhxhBefn3z9PE8p+3v9cQ7YXfqdgoz0WiFyUmnk/hPLX1JkVBXkJwbWmmq1foB9e/Qht2zaS5fXWsXjeP62fo/i+l6lVMSOzWkPqtjLoTc7qEYyWWm2zIV167X70XLlh3XL6gVtpo+YKNnJV4fKFNIyTAZVmGC/eDA+GtpQ1x1RbrRvL353smWTE79iZgvNdhup63a7zX85gSZmE7aldAf7cc3gXAxeFjxVmsfp4JFIpXXdu0jea5XSDEl2DlirrjUuYvhTyLkvSb/TP5Xr9Xz5qR+MvgeFlt100sqi3Rlrb2bsMBVZHt80jSDcwhnmUdtv/PkgeaUj5NKFITL5rsz9Z0DBDRXBm7JbFIuX08xk1UJePr/8CfWtzf29HeUeHCr/tX/jSGG7qI29dOhIRPTBY8MYlwquPK9IYufr7nJBnGVE92GVrKxJuEFlUg7ymzZAWUjY2nSkI5U83HAjAPF4aA0LkBJYa6FlTH6bAxUAhSPE8SgvN6JC70VFlKRp6X1YSsLjr2PHWRPHUtIbExza5jjScAjmNhKxU/aKStEdu1JIyU4QBweLFH4suyuZEQC7v4pXwIhwtl8O5G9k6di02MjuhfuOCsX6WGyZTdp32H7pgwXXfojpl0thz3Kw/BPCCByfXnzLwMccNzX2gtsmKgU66Fvx4NGd5rYiGi7m85F5+84MN1TOYvQzQQ6UPA4mLfdCpxoZNDgIEiH1qV9jjSchVilMO3Y2UDsEpH3iMJGSYuQ3Tm8Nq0Dy7MWkgUdKT9aGmjCZrwkDZBX+NEv49j0TJJ5/t0rSZWVU8b+q1obYng6OYJhbh2jzNyT6V5BLwNNxnDsxGlj+hvzki7Ht1xQtrPPQlhyhjvD4hjxni/r/quP2Yjj29MIsLz/ERY9fzQimbLvZa2MPHPfcH4Mk88e1moBXzJ+1/HL33qBWx/ZofrX6Ydb27IK9ONpHSvtTEdCZ04eABiYCFRVnAP9FwROKL+Kh0BUgnddmcqBTQc6Dr0h4y0jehOFLbtT1nLHo1XEd25KFcLoOfJn3serCh7SNQX+1foWl69knG6H3D9adMmFP28zU3SEj2tpEOJ9Ewl5Z7VeljINq4gm1fbwoUBk4D4Yt7UtKHwpu9XklqwsUbFXsdMYUk3PspYF84ZZROJXL8jlf687dAdJuRth3hMKJuIeEr0/jDVSUaAJdZ4TcJS6tCgN/Egga47GnFrlGLhwC5qZRI7YDAqjPe8N3ND2W6MjA8XEfC0CM2ubuY/cWYojysYRw2WrZl2HWIqpFvGm47XEf/Zn/uDeJvYxbDDOwZkfd2/8qcBANvXeFX5hBG43IRN7FcvtAz+klorInRMbg+nCWXbWyxZLrq/GSMQnzKpnW9KJbEDBpxKQTkvfH7BQhOuQwx1CC8welfl394AFh/vudZKRUS3H8BqVLEeWNZK7hfc8wuyBSqSB3v4POlUQFbaRssqcu0+vMgk0AHYcpmRpdBCTJT11HH3ShhHQJZMZAroLkgVWKID6u9b54NgN1F05+PEZoUlmi4z71RDWp0NJoABrcG8hhcFZIUz5ga4WRilWSCIZ0ykLjRs5EAWYB4sC0O4icvZTD/pgnmuVhqC8pfGq6Cfi/W3RbWlLnkt9XxUnsJ9xgA97YKCddoZv/Bl2TwpCuIBm+T7Ww4R3k4KsqpzifW9LfeVhKA0PMfH8yCLtpcd0YsHWQAwchKA3b927POjjCJerfuS6WXfP/qxLeJEIKsXHpPTgfMaT1qiaG+dJ16bcW8gC3AJByKN0Ug5zLy4zS2r4eBN/SrXX8BlW7xbQqXioZNrJO3Z8AJbzjGOGZq9DFRentOjQY89cFZyRReQRVKh9lYgC0bo18zmZ7nyoC3dq20GMmBerllB6q5+1tpnUtu3VK0EMKClCTfLER1dtMuz7PeXs4Eoub890GKB7HA8V3ON1lH0yTt+KFJur6Qkl2phLolQ4r1aAlr+9wK0ZF6Ssk7i2X6bAK2LIOsdES786v/hfwDAAJYvXZJ3vZLm5KK0SFqKEItpHUPOOJTftVkO6CMBrJtT9XsFWKJh1Yp8tiVqLumaCCdr8csClAzNONR9NQDrjfSuZJJv4+lOdA5wD4TXqonmdWhLW0jMvAVY2kzhHnThIkTPQ8DpBfoDgOMLbTwJrDDNTVJhUhl8baCkNsggzmBPBnkGGcLlkYmOshSNO6GASsu00HW9LEZKK8jnloMQYvsFd7l4vGzF3XRW83nlOYQbmNomPo/P5fZD51EuXiPjmCx/rxpnXZiFYqZdwPk+E9LvhxlIs5qQ/NrUimsFKjWbUEjaUnbnSq4fqleRZti+vhyW3DyeEMeC4elIpZae1M95mCiVPIxU9iMuXOf+kCihggnn/V2zTQHLHdDbNlt2FkoVsLYXcE4fDL9Ek1/X0w82P8fvTwRk2xCfFVVn3acLocPcU+g9bWvw69tHEg2X7wHy9Bb1BgtI8vpmaeOeV3mem7qS5wf0enyZzkFKEYkXVMRXZ4uGiBpssSnJ/zpiuo4X+ZWVXEPTB+d75A06P+iQtlGPrb915aU8r63lnqqKfZE+qmtKtos1S0KRe5+fDdH10gLYLmzXxflzL3ORRC/ahZMAJintJtpa2vDnjyMAOzD8T+QcRAoiler+k/F5ul/X9FVNMc0wlb7lMVIXvHQwEScWfPB2tbe9J+tr/vU/jTgVDHcZm8cuy0/mlk2H4elJszFEkj/zSlMqvMdTInK7KK0LJ0v0jUpBOI4oO0qr9cAqPL0hQHY60cpAXiUjUIBQLgSaGu2oUkoNcgR0DTX4CyGQd0keMOHasFhp6Fk7RY4tgMmHpkQnC1BRU9qXiORRfH+mgyUaTUHKDFk4DMCsJpo8CHlBc0VW91TixGW+SDmMVDBdRdy91GG6prDJ5knB5hldZ6pfSBNHd+ZJnsswhEKDtwdCCqp63z6afGJyno9G8kJWysJh0kl/E9EfJky7TrMJqS8KfOmPkN29U9VmdNdaMzt5Hy5LEx0DMKfPZoMnXQMh0Zqnox6ARCerTbcm/RlQAelgHhYBnqTxA5rUM33uQ35eH0hK8nj1ePEKEMCivhOwpGHesaj3Yrxn4TFVRR9BySviyWo5VYWunV7DQMfIrixQ3hBAobqSxruSskvDDYEDDRM+Zc8VX/MSgtaVpJRy8TxwI/oITJk83V4TjPmZeUNZqBKmklC1aE+N+2hhw0xtLDFgvCaQOO1qr6oHMueHWX/XnQLStiB88IicaN/Xf4/Y8/tPFyZjU03OtlB4d8oY73fojvTcxZHCfuqV4zlOCllTuLygO8mx+bmbCqSoumSlqhV79QuK8V4NlEiw0+41AWLy7J4f2nM4PKvFXEPmQu+poL+lMNxwMyFtIvpjQu6jZhASyTwg7ej5yAN5tEqksF/adZrtJx6qPET1Zo1X0UoD8bWUgt79bV0c2j8LAFh7jPq5BMpABAh8SKa2jiVT1rFNy+a40FtVokxMtPy40oaW8AFqj5bIFwHOceBWOkx5CZKgBQA7Lho99MpPjsI/lrGFi0lTFrmAPgeuVC8wGzd66LSNsqDPQ9Q+607JOISy6D2OSPsBccqYrhwf2tFC0oaSJnIf8GN//gvq0XpnerK+5l+nEOHgMnwAm8S1zhRLNAjAEqmAaUcDY3c3GWem2hFpdIS7E8JxRL6/q9JhAQJY5XwmgAUQwAJciLAOHy0BrPaYAPTmF/ClIGzJDd3sc+a98rokSysPD7DgvVcGNKv9XHJRA1yaYvm2SfsOeRO1/lm1D/E+pYJpTwALsIlZyMKtYvnMXd5eQp3cuH09uNiw7GexqRoKWf6OidCn+mCmTVW76i+puFe6Nt6k+9rtmn2ElgS6YJd0stoyOfrxuZ4QLpYtarxKs1I47LlSccel7DEBWPfD8hB0+bS4jXIsfpVxtr23RAjzUH8u5yrntn284Im6GxFKQXd3XsyqsmucKLzRXCvlP8m1aq7H0JZxEm+bhL2bbMJLSQBpy9ftE7vZdxJ6TJtwIUuPOvL0SDxB9TYCcofb2pOr/LBtcy804eXWLt6TvI9LWaMA8ODnM4Zb4P4vsMeu0RyTe2riUOfxJTfWw+YGAUHi9fBetZiMy9m2tb/L2D6esH2WsHm2fDGmay5hJRUnGnqFLoikqPbekqcA128uy65qS8byOC4WAwESFg9d1CGMkcb9Nku8JcaLyRwhkY9L24lNBqji7XH+LLv9hJRM5d03kR0g6AJldDZVKnQh0+qMNUXr5Tl/u5Lh37Yg6+v/Jeqwzk0KUgohjFkBlmSijPfpglQAC0CQOLoQ4q825J5sB1S+GcMp0d/NHYKUw2ErpzPKOKGMEyqJBEHWugquAVZoH5hLAMtnj10Sgrxk7fYKvGqApe+16rr7nRApQRN7GF2x2Vl2CRec5RRrz/UQy0PUUht5mNc3e/Zl9DrcFJwekddKijsDJkKpIRCfp+DLsDiANbMQLJ16IetPVpkCqLrDhHDOqhwtoeXZeyHAX5pQfH/1UQeTpbDhDKxN+WIpEf0Np6BTCaAa/KHYfS9p0ZVHLtev/tgeTC1lYmnpo8h/7GES01Ase2imKyKmi3REHNkTxmsVeU+NeO4pK5i6JBgpJgB6o5pV5t0J2RXyPZIekihcSzkloPHSADrxyfOglANnnfduyL3rvb9NyHB4VtSLFDIB3jgaWX94xnQHLkZdIlDeZx72Z7+5SZfk4yXRpOLX08OFlUaASpt4XpCUA9ISRdw+ExuVsFUDtOSFSeXCB5NaoV0didV6lZKcMiwIuO5er4HWcDAVfcDA33i/CSOyNtjwbEJ/SKSGD8yyEuNUMNzQNv0hKc/X2+ZZRsfJGed7kcKHrqkeaPnKELkPmHZRMzkFaGkiiQvvVqV/mhlZPdcxVH8z06QmN3fImP+rBVrn5v4q4n1L9Hech9elXE5bSqfa5jBqKLG75Wcv12O9jQn1Yru4JCrSNJP7i4HWv/T2A1pvy3DhN/x3/2T1Xgb+HadSS/FRIcCpSrgg21OhB6Ywb4ZLMvibc/jUU/qnFGC7gYq7nfhBe/0JvfKNptmCDbcphEBgStyzHrx58rwTcJObeQa+uq4GS9FIi0Fi6rIvwAjsMVhoKkZ6iNrsQAlDbQcOFzZeryaUNvOuyO/5dySDEDUc6L1b3ouVN5apJxyaZ18i6sykni2TYRsu0klJpBN8DTsOX9DKmMIB/vpaRiM4tEHnpERWHnglVFQBHEAHu7zttcRDPE76uedhaShVRPYk9Kob+A5pwo9woYBWf6bxMJaBqhLkQTKYMLOQ6fuQMiUgaAhQJkeeFJrEAD9parjQ92M7T7uQlGSo6Slu7Ji5p23zxgRBrcYkvxfvjnSp3IIy5ge6fsrdcm2RY/THQuHlk03IgCO4S6KEgmXzQMfRrbSV6+i8tyoOTM9YaTSO9Pp1QcOG3ruRnBCnnA8AHF9kbgrXlJdsyDwQX+nuQ7wwfMnRJA4d4r0RL714g1c+8Qjg0OGjn6Q2bp4aYPJ9KO+VTN7WAR3c8xIYLBcGx6XmT2mfnjLC5ACphgBz1S8yTkvZLCuWTfdAnAr6AzDc1hMmQAunaRc1wzQkCp8L0V/L2ciQeJCQnjzXvN2WMvrEy5S29Q3dnZKKgoZcKmV8af/xhY7FcJmuIFjmVrxlciwLOQJ2nw/PJgq/HifS6moKxgPQMGAZOg5zEqjz91jd13zvNuOXlImTcVl0IEV6qHQRYUpUMs6HC7c+e4SiHYHL/bTyRLYRv3eK9bRds0DX5B43V0g2Ic/R8ZyQdr0uYtrI0nQtGb2h6js5T3nG/tZf/EP4PNvFJeLbzpP1tf8qhQhlwlWvxq3FzfNgK4bTg7pzt585Y/PkjHi2Yr1tiYXh1VtNvQdgyJ0BVnh2W30+A6L+JvEAa8mkXE0DsC6HE5vQnQCs5netFS/H0KbYSnhQsgcvTeYajlw+l8KrJSG1L5kPCwI+HEXv5Xod31OHcsS8Mji9LnlTxA0fFz1kFcAC9PaXSVxkQHQVdTLXd2vd3Ugu8eOF1Z+0/w2KttrK9UL8simzs2SqJdO0RaU1moxH8b7pdqmgO6RZ+nvdXtmneJ+alahyy+QH9CJZn+2krqCn1Y4Cg6eEi8NTeywJsZnYKb2K52rJGwLMAVZ1jM9ukWltvnDfUwq984guaDkJMCBpBMumFZPsug2Llu4/eeEZ44+/8st/6WI7RwZuabv8/SwMrJ4obovzNALuWWpMQFBLCKfvai+E1B4VIKjX7aYdM5oQ3jFXsgndgjaeB+T+2GJtxmwUqR1utoAueTbigtAoIN6/ecjVm4Qo5fzkHhPJD4m6aAmgpp4uInGVRBZn6Z4rGrqtC4ELKFEyuV8cA6app5SHqQZNp9qbF84jLThynlNixPEgr/JbEetuNRu9h6s6Bo9XhwlhyuiOkyUESIk7PnanXErpBz6fxvMvOOLtYG8rT9bX/ct/SldJ8vBrTD2VavV9eKm3VdZUcP2Js14gALqaF4vnRJpao6SNClI2fajwlFQLS8pATiYeKiDKgyWgnlg9UPGEdMBWAF63pBTWwcqmlSWerBBoJPX6WALm/PGZvA7YwzPzSAHmLo6xdktn1DBbJ7Uyc18LOChDVNCaO1ZxD27SZbmBzEWIfYr03Xs6HN4TMD4ouPoVub5FJ0cJRchgO14HHYA3t5n3CS2rk4dgJUm4iK1l4wBC3jYibbIwxjMaEOI5aYFwNc+ZkPISLnVaV1fSXynZcXUw8/pnC33sSxxVZHf3/YLumZTfARwg68yL5gn0Qp4vA+mtadu4JEra0vVLUvhW8L2cam/XZAaupD0BHDYMFgKCeSl8QWhfYFhLHYk3K833LfvR7QO9JtZzogLhBCSGu6KJEoCF5PpjtpqIAqZzATJ44s6VF8vKi2SoTlkXCSx3QUV2fZFiNQeQxWMYUiGKw1QwPugQJhdS3dJzInUMS0f8KAET472A88OC8UvO+OD7XwcAfOYpoadp7PGbP/RJAMA/+KX3A69s0d8GbF8LQCBpDClPpH09QjlJcUL13Cq4dtdBJrLRiaV2Z9NWkyLe/YF0y4YD6WNJ8orujxNX5Bhn5lP1RyvGruHsYKHWkOmepkU11T+URJBuLOrZrtqe5LrXWXppiI5sn1lFPKvnkULZdA9UJGxAowvnh4Mt6IJzAKj3TORkCiWcgLxgcXRafHwPC9GdiPqx8ryphI4vrwUAGfU95/YVpqzZzpgyeV2dR0wSvMLRdB3DyYUDZdHPgCnEaJQSAFrZQjIUU0YZRyr5NiWELlpylohbh2AlwDqLxIinK+RsST9+3pJzYA2yvOsRUiES/Jgq/bo8zKscJK2nGfHj/5f/OT5P9vb3ZAlpTTg8/SGjP1Ctuda1fXiJL1IBHv3ULa4/QROmB1gAEO9G+hP+xJIabggaY5ZyNwCca3SZk3SxlMrzSg4IWGs9R/pbeYBrzpauFFzRYP27ZDHW5YDabdvmX6IAuVI5s3I5PMjEiVeZba0/DVnQ+8N76FUAlth4TdmEhbPUxuugmU7aPOU68PvBJir6vLk+DWAQS5uI7o6F/s5Gal40L/rnTD1ePsX4kl0qj9OEnWc1zVqgLj9baqsHYn4hIB6uVppEXmQhc3YTnOPoxAvOu7qdfCi5zQQ0afimfu/DjCE5b9bizpdf1csy1e/bBBndTUcTqBdaNQ5IvdJXa9T1Q3MvtJImsk/5644WwpHU80EzG7l/G8qL9ANlm5lHa/ilOoQDAO9/6Ql++clDAlgA+tvaIyXirLPnQuZrAcOBwq/Puw7DHXGhtg0RXPYhoHGU10aZX0M7mf4fDkUX0zNrQbwDUH5fl0r8CC9KpUeChXC13RLSbWVnnICyGGUCsgfuSX3BhNMmnKoS51UiRNJD9cuaMVEAwnTdY3zQI+0ar1Z1wPZk5ZXHXVn8NRJG6kUf3GK+5W+1uxbPVSuGLHOWPDcCzhoRbiHOy4JkKdLjx7iKl6Yhe35OjhPC3UlrFMurWDzXGmZehPrtQIZ/24CsEm3wUbE5Ta2l1UzaR1WwbrN2Np++UdBE+5BcbnrR8gFS6+rSxMjaVxXgupQhOKs5eAmpLJh4z7qObnoVjWvE4/wxZf+fy3GACmAthkecB6vyYgF67poxIxmdfT2R667cgCYZaDLJVNt1PLh3LsTkfgfArfADxus4CwtWXg6guqbtCl1CRkJ015CbTppygkBV4b5qmH+Q7Viqz9a8+pR/3TfcNVhKz269I5c4cnJdspBNcTlbMV4g3E8yOPMzcypKwAaWMwbVcyXPVQNmlR/ZrmdSsz2HCd8IyJEnhP5Xbl6jZ9adyyJAMJmPohOvKdwveHzhwFZsJiolIBOXpgyded5mCzC6fzRJwpd5Aqo1b38s6q3Vc2ZNqrQL2H86IP3GAz752gMAwLd82T+utr13j2KMEl4f73MTZK4OUF6kAeIagImyf64VZWZ6dAAlo8jCt02MyEOgRU9wYqzNM6qe5JPwmJpr6iIXdq/UY5CYcLSMq8mg9LYNpwvAc+3xFrmmaiDuFgAV+m3HOfFa6UKyoUMAmIE6K8dlQMsT2FNThih3kaMEcTFUqEkvxVWR0EVo3e5WJ63s54BdOb0xIoTgMt0vzDMSaly673NRza2lhQjAY5aWs2u2kXGNaxqiId9LaLG7O9PfKamHur+hbWUx053L82vPfp7sCx4u/D0fpWKPaUcV7ksAv3KWTLABUVzK5wcd7v/jp4hPmDvFA+H0XhqI4nGiixcpbBPvaKlL8WdG3FKj8JaW2uV4pBtEVNLPZ9u3aFOJceiurTeoYb/25vN9LCFC0cPquppDpdyroi5Y2mWov5fMkcbjoWFD1sNaBJPyYLbgq538heQ+dEp0l/ph2Xmx6LjNyllwBXuazvciHn95RB4Kdp8Jqms03Bb1Rkkq7pnBVX8HbB8bWV0m2zTw5Bx4Bb4QypJQR5yIpNodE7pTtlj/SdKnirqlSwXS/M4a0BUls5LDpjyAdYcRedOZtlWqAVwJwcKA/nIsebukDM/zik9z20nsVFapDvw1PAzlcQhJlAnZeQiIZwYiXEql9BSeaTlWF9W9nbxCnKDhwhIZmPlCBjzhd2eo0OWSlRh0MqeSMcvb5T4Q8b23MKEq9ivAIfASSpmBfiEPA1iU5SiNx7KwZzddWSF5wEAr6RgxoCt0HWQSFs/F+YGoWdP7owsZ0j/EIZz2AYf3FaQvO+Df/q1/Df/g7gP4tkf/JQDg//rK7wQA/Ng//o0AgP4TW3SnMPP4DTfUtjhyP2Tpd9fXMpyIblmzuPIgOnfkdc5MFch9DdDiSIkHJTBJPghYFrDBfbGl+05K9ETXf7Sh6bOlLS2ypi2BZSWTM1eXFs+Y8Q2r7M4+6L41E7DYc6EgSBbAkpnLoUfVBtxEnB90APeliqwmA/EeGMZzdmHGuYexaIids+Xk+h0NnIdcSAdsyuqBU69s4/lRzS1n6lzIDP5LQbhzWpAS5ZHXlIym4tpNJXL4O9aELNOESi9SIjGiubVrgF3v5knxYPFcHcaESnNLQpoyZw091RBu6Bl5N1DpvE2nulpxzDi+vMHAYdy//oN/BG+hXURzbwtPVjdmWuFkS/2VCUBu2u1rBHq2n7ghgPXqU/pxm0bK4mzpwXZOMm4BlmQONtpXVTHldpKTi30JYF0iNocAdB2tFCSEd2lbGQguAawLoaTKpiZE1LS/WjGUYtv7JjclHPSGbjWTWhLt0lwo46dIc/GpaBo2E3VF/V15QQtdpCTrC6d/SRtr0TslQIQf9IvWKCzPkgcArtnYVWEpb+Fz8HjWvLiFhqV2YE3152xeIPGSCQfG12YDMAvTa/r586LUfG00Q+zC8swy1C6v3+Q7I4w3x5qa7Z6jfdaG7lqzsjnzbNlL1so4tKn1SqJ+TkUA8bCKXIF+Lppf3Nz3v0jj3X/4oR+f7ePll58BAMaHSfW0vLX6Ym1CSGtpMz8XMSUcy+uFZ23ck9q/JLIs3TMSsRDvkN6jTQkY8VZV2cWtBWm7LBxsAVGZlkmSSXp+njImnR/WuouaQOPC63776Wp+kuM1cYZEaki8Vm2/vWGR9mgZ3aol2CyarBxN/X52jA0R5cvVluoOwuZEtXZuarPr/XsPsIBZFEbmWfVsNXNTaOeijPncNloYMhxHC9uLpAoT5OWZ7O9GxNOE3WfO6J5TOPzzYV9QkPXNH/6BSltGTGLiIRO48gALwAxglaGnVNSlla6cYc4om+H5ACuGGmBdsMLbXgRYLV/qDYTlKqtqS5XLAOtzMQk1LgCsmTUuXitVwynFfaj6+ZJYJWADmBBdpyv63e61gt1rBZsnBf1tuQiwvM28HQFVSJBW2HOA1S1M4jo5+uuiMgrkzp7xnC6YlbkIJjY42EpNZQE80f2SVavuetInjyrs742s9cQBxnFglek4FgthPkdAcnH37NGQNP+YDPTEhewv8yy5zxTMQbWIujN5LgVIL+1rMcQojoLEvLJi5ZDk3qnKI2m4db5/D7QKZw3Kb0oTPqS+uHx/xIbDJRP05ulkIU53rbpGnNTbn/vF3wEA+G9f3+Hnz+/B1zz8WfzU6++hXdzywi1YSZ7ngWEFWIH6II7F9RN/5YeiSwuXdrtN0CoOAI0fwtFqMxmXzAOtWZmsIZh2Hp/bkjbeEtDKm6icqZYorW1fqNm6BLTOj3ouMxRm3FABUaJ0720JaC21P7OorHg5F/XqFoBWJRTtJR/c7xeTSzzQ8nNXO1YJlUYcDc9bLMYAjCP94QLQmtLzF5ySeCTbOKAFoAJalV7gYpb4hG/+8A9cPtZbaF+wcOG3ftP3AXBkw524QOn74RnXKXzdBEHDUwoPFpFaYMCUPvAiAGC6Z27JUAqGVzicKC5QD1Bee8Lf0b7UM/UGk6EIjgaH9KXQ8xupu3tT8DT0xsPy3/ui0N58WYR28m9Dhm1svfWMLN3gqqfFoTBOBZ64/qNcp1lRVj+nSzbOffry5kuYR3dTh3IAeujP9wOOLxdsntLvhqf2vaS5q/cq1q9LA5DyO8aiZVRov3zfzKQNFtSf25BqqzqsxNW+em8qxIYEWuK8fVG7vDXUIM1wmjfW1iYMol6JBZAbo9b19GBeuSCSdt94u+yZtN94HaUKUMu8Kbf6VE+CptxvP5GQ3iWZD18Pzn++JEZqHLDac9aqaGtIZ+Fa6DZNgoDx9Oa/KdthkaRclaFaOCfV83G/lWdquorV/SyE8ld/G+3jf/v7/ncAgJ84fCkA4H/9E99k7bkTMWV+1p7Rb4UQP/BQqN4+5bnJDmanYnUWWw9Yqd+bJ2fuyZY6hlKcW5ITNDPQgT3AnqOZzhfm3p5LXC3AQpJSyqvaN9x16ey+9u+n7fweFwV4vbcFYEl7ZC0jz4rISrihQ85XwKIlbzReHXEU6b0oO1hYwDT3vAB7D/7DVDQxrF10AXDhOR4jDxfq9QJ1xRHRE/GerMYLZnOdCGC7BYqU3RF9LhcqBGAFrIWbpXJEtH2+bxUQ9Hc+OxxwYV767V/9W38Mb4FdXDp8QTxZH/n67wbgbvR+PhB7C3dHhLsjyjjaxZYH7oUHvI+a6BcPE9K9ZZGYcHtAVXy5zeYTaws9w4ErzbK4cEOJ+UxC/1dt07yPLHD6vNDj844DN9ifR8qeTFllK2YlE9oHV0InUgV95/gjhftYSLMzoEcv4jpv9WRk+/F+wHg/qDAhANx+KWeH8mXzvKg0PH81nQc+tjxfMo4wkND0fU4NrqwBwaWtx9hk5/iyGHFM1eDdgi/9vCl+qp8rz0dAkyOpN09nNfiU8vynl0mxmgDSatzIfjINwMTZqT0+fZMRJdaGEZUTl4iHQ2nlvK0DvABJcQA22faH5Yc+ThYiMtJ8DX7mAOoyb2sm5jjL2nTtEK5Ioz00EyJus06bzEVf5FcnQv5Nf9cQejMw3ORFDSgA+Lrf+Q/xf/jUN+IvP/6t+OTpIX34jCat4eebca4vGF/IQACme7S/88N6k5GfO0kumagMoupq+cWML3Dtv7MMUgZQrIXWNZmDu8d8zkeuHbhwjiKGO+2FsxZxfhD1/aIFAvwCaiQ0KVmOs/JLjijemudV+d+qh4qPcb4XMV5F5lzy+cv5lnpf0k/TVd2Qs/Y5j3/Fydc0feOBZR5o3F0KcdI24jGUi4fqVT11Mn9E2BjSJnwIpUX4aW2YUA+a6C9EA1xA9RvNPDyfieu8QE3RNsSI0nXmwW8AE3wyWpE6shd8QDJe8LgpPFzBH58v+7x7sj7y9d8N0e4pMSDtO72RNq+RrzyMmTwB42RiaIBxg6YJ4foK+WqHzN6rvO0oI4Ov8/YV8oCFuxMwkPJtmDICe7CqsGDKFi70xD8xX27Ag6sYyYsl4UOg5lPlbPtpwn1aDJq5Wp7oLp6xmXYIQABIyPgx2g3rvVWbwVTf5XtZPXBxaQqv5trr1YqW9hF50yFvOqRdRxlP21iH7gqM6F2oLmGJxsU4cV218wMiOve3NOB3Z6A7kObR8WXa3/iI2nr1i3T+PTsxN42QZZyA8Ype04ZIz2kDDHc2SMpKUTxZ3SnxfZX4Otr+QuPpK12oAI0WEwdNOGHMqv6dtz0BCxmMGjATTxNloklx2DY8lQoX6IaFn2VQkJWnB+W5kA5NyyFrPYvaWQx2XYFVIWMDNPB63SAASqxVDwtPdGkTVBHc+qP2BCjxvFldq/7dENAdqIivFPMVgu/MQ7LviDS8ocK/Fh52oDbQOQvXqj2uNyX/+v6C82A5cFR5AZprStpXHaWn64TWAD8fshAtNCbDB9Ysk74TdXFZEEioSRThX/9d5FX4+n/qn2DfjXjQH/AX/n//LYQcsPsV4QjSoY6/gT0Rxw6lK9i82iEP5Nmarkul3B5PAZtnBKw2T4oVD5eyP3eNF0XAVsGC59KATrfAn1Jgzi/dyagHaU/PxbiX8xfvW8HpQcDucUEaAmvl1YvxluAtCRjqIRLdtCMXYi50XM04nWyxovdyR+ejemabMOM0bm7pHLtzVp253M3rMp7vkbbfeI+enfEe9UF3hl6LLUt1dKeC/sgJABnaLq9qTwklRTUCtU8F4PkFCI/NlZ5WMmK9eLzEYx5PTngUzpsVgob9VEOS9ePsQshOjT4R5J5vgZlUPNltCVS5gtMADPBNmThY40TzqK/CsKfVQL5HqwPlsMrY3WR060K5J9pF2Xb4kR/7DryJ9jbyZLFYZZtKvX2VAZYM9Ow9kc5U2wwEsO4RwAqnZGm3beiAgUzeDlwzqSmgBRj6fiPOk4AmVl8PXWdgqOFkFA/GLu1TfiM3XC+vDcCSos9eyV3TX3n0mxpgeMes2ePC+Yo7+FSvpBVg8ao97QcCV/seadchbY0jIGYlV3gFKd6rhSzhDXFzdUUtxXwFYEmoMGQe2NgLnPbzfZ15EJbCuMcXZTCcbyumRZabRUWUfmhK3LTlHABbISYNnfI9+hySdBk64ku0ZY7ERLFYbtnnkKTbxcZzuX5vZAICpZDu4TIXUcjZttpf3k45Pc85BVHbF/0gEXBc3PbZVL3OSOtNKOW5vDKZj5ZkM1pTj9UFj8GuDhE/l2enPxK+yHN4Iwsq8d5+7inRIv7ij381AGD7qcuu3TDyMymerAf0OjXP0/k+eYHlWVqyS+R2DSc6E1V3uQdm0YnGQyR9eHw0P8jhJQab7PkRbucS/1Oufauir4BdEqkku0+8XwtkdWmThrUvJEvkITBgyuiOJGshYEyupYZJ+XX/aV503M332T5f6g3W+r183D4gsBizyG9ouFVe2+zC5ObE1jRkGm2+Acyb5e7v0EUCUn0/4+9S4zhi0HixWi8XAJqLMgEpTMlqJWrZOPEk9/M58IL0Sjg2fK2mikmYyIHTUkbeSvu8gqyPfdV32MDFrsrtq8cZwNJWeTmCvjMF2qW4dENynYUDGGCVUggELbg3i79p2FOlNQGBz4p0ftEzKDokXZzxrUJ0730oUL1PC8dVAmEDsNpVA5MVlWgIVKGjMCVqW8oVwKLvuemOMKxioA2JVVZ93kIq1QCwfa1g/2n6604FeQvsXwkXAdaJ5hQc3murSvGQidjidDXvmphoVdidigrV5U2n7uJwopT9SwBLrAydKhLnJq7f1j6jH8jqqejqUgf1Dan5V4BsFrKye2fmxWqyWesTrsOaleXMRZDtvrgEMMKZioJ3xwmhFCqk3HiXqsMu4DIfSurOBTFRGCxMZVZyxodoIteOi+eE7picFtYCh2qJ46b8Qxc+KO4P9uqBFqmRR/NiybYLHLbnyaHIedBrXibDtwkI5wkIIK6MNH8bTA+MPR39L81pD/KsqA7cgSbl/T/ZID6r+VmScSjh9mlPv0t706JCAaYd/SnHaumZlrWKv85jQe8kGKw+Yv0bgMJuiUnd01XEeB01FEcLubAoNCrJMZPIjrRCyLDFwCLQCkYoF0kI8dBOu8ilgebHVU9YE8ar6mfKM94UN+7OlDW/e5ww3BVcf5LatX/FwBvVX7VxVazSk4PjmHk6lPK05ANpjxt7/fdizxEhtZ03QKvlBgPL8xKgQMvkH6K9Bn7WZA5aKuMDWNSqLW4NmCREYRX7VhzaASoApsuVSvXsfeyr3lRP1kX7vIUL5YTSfRow1FXpeTe8QhSCXrxlT8xS1fDmJpheoNlWNbVu7OKFUhAOZ4Tbg5LmhfAOAK1kAtqsu9yAL8BkGNhmxHl/bl541LU5bDbVPtES1pcG9cZ7Vdr4dsvvAvQmF2+ZPjDuHMpuQwVFhw5pa7WwpN5WOwC1gpV+tStubKlTePFhd98Jb+HZl/EK8PVY7TdvC4YnQSd2+Ty4W2P3Kq9mn/I+nkz8yiV07tw1byUuuC/MSzEfQCTklvug4WfaMd9znCq8RDzV020I0eqNaVKSAdh93+qXSSFWD/T8ZY+wotVsGh7civeN70mRbfCu+IacLQLAquTt9iuTjZbBasvaiLCweHDaAdCTbyXZoPU26Uq7nsz8NlVZJyx4UGB93nq8NA1crpt6A/i5WVixa1apHH+sz3PR5JzlPBdI8NN1j/PDHtM24PZD7MH5bTf2/avkirr+eaEw0It4SvxzenqRwRUPM7kX7yVt09/ZtpJRKMBOSl2JlIRex4mePfVaLnizfKant6LPuj1bCuiE+6ScML6fHLiRzMtB21IwPE1awLnnunaaccccJK9DpcdtyOlWoqe5n2AASEtMpbodUlfX81CliHTrfZXnThaLqhHIj/rmmXXaEncNcGBuiZvVLIy7RpalLUptSSX83kc4mhJ0VrNwSeqoeaYuATDf1JRpu66rClNL9ErGASXjCwnezVv5ilbkhZ+hKBzUlkYDWNJYM/b+4D98U7IOL6LWz5snK4yTTgpLujFpV3txqhpi/HuAPFLhcCJCd6MGK6ZkX05fFbX3Mo6G4Bl4KCnvs9Ew8iFF7wlbSAP3Fji8SL9tANQlgOX/99wsaSPXjLpoKaMS0WwnfM126uhvM18xpJ14bWwgnLbkIm8Vv2XQ8pyc3ZP8nFuPVrzdmfgJ3iQzSixvxdNkg7C1kU9HLvmZ6qh1p0ICt6dsYT2tOegA8ZLUwYKpl29Xe7DUTZ2Khq3F6zUvrmyeDqmTF1Ih13Ub6rqkc9YveND0XgrVE92Clcw1DPNg0gSXyslYNhxxP3JvdQHb89KJKhWuv3e5H0MiMcSqLwDNxgwOiMQpq4gofXfB2xSMfmCfQfdDbTMQVHGzltpYuF/ksWuSFioeY7aJCzAgMctSzpnArwAsqTcJA3cK3ECcQgmpj0/mnizhHrXejO3j2uNRoi1E4iT3gfQnfS7H6Y5gAj55Yodb66eWa6QT/UL2qJjIVXTHhP4wYeBFiACJTrlfmV8Ldq8XdCdXXFnI5Rxe2z6TMHNWfTcJPUsfyKJKqjtsnkzYPJk0VL1kuQ8VCLPs2Pp8Zewr0cKXmnG9YKUP6tHybd29Sm3bve7aXvB8on+rX9fewur94vqOPvx8KVzIc4SWBvKk85ZCI5VJxEkwNNpacAv5C5nvss9Sij2rKdkfMJ+DJaIkES2XPKaZ1ypWyk4Q5nItqs5fqNzxVtnnBWR921f8UZXzb8MgaT9PhX4ewHojqwCW3ycXf1atDy6dAzwHYIlOR1X2pumypVjzJXsjgFVtGznevgCw2rbmROeVmRzY3litd6vRy/ImYbAlgNVabrJ6WtLzWbRiCtCdyMO0uS2498lpVrts+zq9v/oVASjcDQs4erzPK/S+3ua5k/vYXOP2WvM9Fm9OQIYpwsM9uH6CdOf5RiCbNm5AwNImSkR9vpBsyBnoI4cEam9P2+ZWHmLRWoAi7VkSVG2b5ABWa+L96E4EqmLDOVKdLPFcH0RQcO65Do2St32xcF7qjRDPzbKXSQpEk0r9hcXVBaC1xP9S/TUBim3NyMX919dPtJTEPNAan25RhozdJ/h+dMW16Tj0IkBr98rla94d6LvNY3ovdRKXrOUkqUex4WSGTATzMBXl2olaulgLtEQWYf/6HAC1QEuu/fb1+f2x+zR11MDJU1t+v//UodpuuEnYvjZiuM3YPkmIk5OVmAn5yj+o2uHtEtBaKkklnjbhGO5foft991q942lPoczcz2shPg9oXeKOWaMuAK0Fa4HWTKzUAa2w2SBsBgT2Rom00iLQElHupfAjcBloLdkbAC09bDLe1yw60EV821f80Tc+1q/B3vJw4cf+uX+fdtCFKgMqsf5SyEUn9uEZh3VuqMRNOI/UGaczoe1xNB7TFbnN06N7tP8hUkYDE9rKEK2Eyqdfp8/OZ+3ksiTEWS7chL78jK5iBUDkebhRtp0JifL7viceltxoHmTF+aQYuBYaJs6aUGV6dw4TZxOmTK8uIzEI18uDOsnq4AdC9LDSrkfeRKRdRNoQT0GEJ3XSEhrYIK5u4hYMt5l4D31QgCUrwe0zOofhhlb03TFj2ncIpeDwIvXD3QfYhc6e4/5A/JE4EXG39BYykEnCCyd2B1p9b24zNo+ZNC3aWGOm+L1kqSzd9+46S+kGLSnE9+jE4NPziXIf6H3g4xTU+3cyDXFMWpVARU+zAYIZB8vfkx2lN2s2lHrmQJ9dGDxJSJYzSTUlnEBa61GSYq5U2JXFG4eopXYAu+7kQaJrTCtn2l9/MJ6McKq0GDfz1UJij5IrZyQk1UroU0RwJfQzRM0iNgAJBZwK3DQswu9PE0pPRcEl1DsLDblr5vsscH9UWb66UAGf30THHxNKjHSfLQiXVh5LLqeU+6gq3ceX6OY/PYjIPXD7oYDjrz8DiY579bP0vO5fKZiuAoZnBXnDXqhi9yMAHF+2ENz4oCCMQOnJU5x7YPPUgINmCYbAXkQKHYbiQoOjuxflWoK5UIVARIlB+5j6XzyTdtqlJ69J7inzTsrdqATBlgRMJZtOTD1e6s0akYcO/dMj8ran47bPgLTjPCFdbxCmjHQ1IKSC6bpHd0w4P5LyWBJGzRjvdejvMqariO6cMe0i4liqjEOA2tcfqWQRieDS8yHjgW9vHLmAOHuO/Ot43VPZoD1d9/5IJPrhNtdeKSnPNEQqOdXIH3m6QadJFtmAYrHyPKWzObLNji0hIJ7pmQnniUreSORIwugSvguB5tUYaNwS5wQw9+j2vc13k/Neidak8K02XDrHR2MaCSKvsVX2Awks350R7k5zDxaXMyu9A4+lEFiUsOFPfi9+DfaFDRfO0mwdwAIIXA3Pzog3RwJYgF3Qkwv1AQgxIsSIst/S30B1xABUAAsA4uMbxMc3KFMiQLLE7dJGvjHKDyG4eG6ee4iWrPUSXELwgHqvZl6H1vPkbzyxliTvARaAmeaW3PznUSUGlIPDqzKL5/NhQ1gEWIDVEBOOxuYmY7wOSLtAAAtEgAZgKfsLJqBMuCDKwRJeRUd/UvQ1FBvAhUfSnQrSvkM3ZuR9b14QldPwMTXXlwtuZNNY4YGdayB6fZZWCNOnexepv9bUNGvFTbUtwDLAas0rwLe/l+PGQCFCwEJcDQih+nqFy3bU4TAlFytgoXPszgY25Hp1mgFl3o04si5SyhS2bwGd8ziFkUOm7ULls1SiLw1viyZ7AnK62BKg5/gouoBpQsdWd7J+ra6JB1juu+AmmBLCPBQMoC0eHs4Zp0c0+QuXUThZtH0BujLzJNLxeVcy1PD9uPvMfGMJxXtuY0jQcJH/TovCK8fJ2iz6Zb3qnTkQDerjyAuOkErl7bXjyLZ2T5be9KfaZIt4KvyX9HmMjQaSLgSlXm2bRQ2gY42yngtJbx5P6A4Zw7Nk59O+HuU86VmRupzUhrq/Oiet0B0Ly6SUqn3tqxS1Fu+van6Jp2xDi97MfwAWhZgre870lBuO5uKCgM0K3w8ou8G85LuNjU2aLS+d4l45I39RWLvvL8+J/lkTiaG+0wov3gJ7wcVZQIvEWIUWZ3Pm87jPb6K9pSDro1/98Zl7Pd2r8+y72/PsdxoWbF17zwEoOnAL4HoOAbU07sU3SsGuKpM3nK6l7WaCpLYBvfQ933j0J7wov41u68sQhFBlD6pXrZGDmL0uWawfhqWMM83kkaZxP7WZMJVxVx5foN9KTTbTqxKPCa3Och+w5e+uPikgiZvPQCskCn3kvmDikiGHD+SqLcLZGO4yc7Iy0rZDPEx6T+g5y4ooGT8npDwPBcO8RQJWdEI4zz2hOonLalCvy7xvLXwpB2oA1pK90aCQbbtQHLACZqFAmZBJRyfU+xScLljBlSEJCVVpJd1Gcil4UurOGYhU4LnEZaCh93Yr+LsQumtDfbOC5Avn9jxPlT+WcuOmbKD6bPeIb5NsE1I272PDI/Wk/nieCFBfCOvKfTU+GNAdM873TYduYNkTMJdq/3M0dl59ir6XsOCSCeiVMHw8cUh/oWyPACNVHZdhd+E2axeAVg+veXY6Fs4MfK0CZt4SX9oHYO/qVDBeR72vRFh0y+HE7es0OHS3I8IpUTKL7PcgCS6n+vX2RNnEh8kSFLRQvITwGHgxZ0pAz5LpglIS4UR1Z7FEE71qMfbnhO/VQ8dhUuFnnR5JSFL6OiBvA3uvuT+Ve8jXksO04WxeLDluKwIui2sRUKYarBF57wGVJARJ+FASaHjuascQb+3c9pws/TYhaKlGrG3cPFNyXrsFEXLRp5xRaXhOu9rgo1/98cvH+jXYWxYu/Nhv/07ykJwnILKo5bZX8cP+KXusbiX+0yHcHQl4jJN14DTNL17fo+y3SI+uaADNmUi8Q8T5Bergq596hRp+dzAhs5QIYF1CtEsWI4GmNuQnlhJ9N04Qoc8ZEHOTXeh7k4eQsN0SJ6vwxN9oYklGRwjhslyEnpablGOsVgRFsjr4AUjXNICPDzZU0HRPhUhzh5kj1GeSkavcsmgO7+mRtgaU9q/ICpMnqEz7s1CUKZyPnGEoKvAl0CR9fkCD9N37M/Ij4edRu69/lkPNtwXdkTxo/ZHkAuI5o7sbjVx9w43Kefaw6UAhXhyRsYiRw2WR+TscEvITp/eAZBbFE+9V4MGQDyeZs2FMxt1pdc+Ea6ClP/j+2AwkYqkAWS6IO5G+HsyVnySLkEa+QF3yjjyug+/GAfDA3o6eVtBWM40Pyxw7yqoSrybxnUxexcCHXYeir2UBiOjKWq7DECn7Ncyzx4QIHbjQfJjIixUKWAw2zMFtH+k69FGvaxgTyqansQvQ6+wzNANLnoRTIi9dU0zde+BKF1C2A6XW51qQFLCSVbkPOL7Yo3TA6WFE2gK3X5KRrxP6x3SSL/w3sk/2OAleWciqDIWeqekq4PAeCg+iGP9Kk1Y2QH+kxRSFunn/4/z6xonDYnycOJIw5nCbTEeP97t5NmLa9+hvRqRdh/5uwnRvQHewjMDWSgxEVdhSSHPaBtz7FboO28/QXCEAuISgIfdwHKtxXENKO7eoD4GABIv/hgINncl1Agh0xFNC3nUIU7EaghsDfwJ4jg87bJ9mjFcBu8dJtbM8iNJQn3i6TrkGZG57OdZ0JX1AY3A3FkzbgN2TrKFKLbLutObiSOHIkAtqwWX2JornWkKzPLZEXUzwvTHSPBamjDx0VNlCHCZSgkdej0TrCePEXmEHlPSZ5nsjZdNklDFVttWSbk782Zevk6iD21a36yNlxwfab/fshHA8UZs6Ox6dY6LxPjJ9IgT6LT/7P/R3vwu/CrsIIt4ST9bHfvt30lF5kJKsGRkUBWBp66ZEAKuUeUiv5TUxwMrXOx085WYSgCVZJRClWOAywLpkvlDmJYDlv5tlD7bhu2jcqMaL9KsxBVifDel6/mP+7dxjoHF8ifHL87IARFvC7SRigUsJcCprIPtDdZwlk5W1TAq7z1zuLy2Y2r5u5o1ZBFjAYgKC3LOz4qNL/aFlVFBvs3SOHmBVGmY1wFK7VLQVMFCi2W/SufNNZ0Dns30eYKvy5xUeNk+f44NgeZXfFqduhQMX29AAwbxAMG5L2MyI6H5byWrksJJ4Q8Ld5SSbyOEmIeqLAOJie3WxyPf/gmyDmBYjZg04Ee4N53mHywR7qUyM2HBXsHs1Y/8Kf7A0hHEwQUVk1bM031ZAV1u/b7yeP2fn+7SD6R6/XokkyGUPe1tiTUryLJlO8poo9Zxs6wbAK/BfSLLoWf5HBHrFK9QmbgDAvV+he+DqUyP/hj25C/pusQFbWu5moWC1eKS0UgL3y+HF53iBWuJ+6+X1iVfibZcFlSxY5PlyiTORgZYt0JooyI4lZYbegIssMNvwYcM/LhzJQTC6wiWnRxEngSwMYWNdy/1L97couy2FFpuMbH3fhBFlH4Jf3ix7XuDnV226AkwZGHoqmfBgSyKHvILTAUomFwkpuA4EUIe8hPR+OAHXVhgy3dtguu6RdgG7V0QHiwfP3Q7leCSCm3idUpofx7e/61BKqbU+LmVnyepAf+x+05DkSynM68qWiipip82N5eueKZkwJeKjKefDAa02M4w9XSp02nhdSIRRVjUMgpvyHp5ESwMu8SVCYo/FuehKtuwC7l6m3937pAx+PFj4CTYG5GAPB/GrCnIXMNwSsXT3esH5mngPiT1pmycFh5cD9j+zwfmfPSAfOmAKOL1ccPUJUkDuT8QTGa8iNjcJ03WH4WlButqguzmj7DcIp5F0WM5u5du8+lR9Eas0odzaNa2fZSNH629aXST5LddPDJPjAbnrMjMPirtOuWXFFxZ3HiwiaodqX0ouRzESfMHipLskvtlqVGmIhA/hM5va2oKzc6oyY50HiD0T5YIAcFslQjxY0qboCEst/wtThuqHAbb/EGi1G4Mt8M4jHbeRiAkj3xebAfE46cqXvmuzV3n/jjsSCnW53F8nXhSeH3IoOpsA6PkBN5Mv8YOfoVcpF1UiyTj0J6jSeDdCvR60Eb2kTcD29Yzzg4DNU3pe+0NBHmyhJF5k4TuK1lPa0HMpiQ2XLG1IZHTaUZkr8UZLSE3aPdxmpC0Rw9NAwqu5I8kVz7skbyQlVkz7iN1rJL9TZWzK+NVHuo0ncCQhWqKCG9+QCRCXXU+/nSjkW8Dh4tHGJQFfEe6eCQGJr1PIQUPYkh3YnTKmq05L+Ig3nXYkHuWmD+VSsYQEzY/sqTrQtdo9zjg9jIiJxsPzvUD9WmgclugQMB9rFGjJKUxlFgaWxIM0RHSnrAk6gHi0IrrDiLQfyHsIGROTzV9Syg2Aln3rmVzugFbZbei5GnrFB5iozJsk3Ehfl03vnid3bswhpmeYIiHi8ZquB3THyRY3m4H2L5GK6sSLJoq1Xus3094aTpaTEZCwSxUmAcztt0Tibk/Ua2iIiaudxU3Ffdu/dov+tdt623bA9t4xp+zu9axmWYTibm3/5DtviuQj/XmF3aYNbWw+pIwZyXYha/Ei70tP+Tkr3KYIqJAfp32Pad8vKhDrsSXsxQOurGQFYHmblQlxpOhL+7WaaPLFvA35MYUA+oOsYnjT5y1kL90DC1YuhNoWrUlsCJfuCRivyBOj6YBv7Ll5rkKzkNDbUOHCOS7xbKrjPMfKc66f2Ex0VEMHC82WQbNdYCz0xxKxHVj2mup+Gu/jolL8OFWvF4uoV/ttwiXPSTdX+Rn5zSXgCfMOqSSJOPzz5edFpFUU7C48A/Ksbp6yl1ELgS+0V3JDGBR1KtI53/aSCWl7ycamNI5Xe5+1JdfHlhqPS/efDyvTj3mbheuonkfxgjzHcyrXWOYv8VDNSjyx9XcJ/V1Cd8zzBB/N7HWe5oB6LpGkgLG+VtsnGdsnGd3JqBitoOmsXwoMxLWgi607JXSnpHPUYgFqvr+7w4juMHKmdqYQXashJ4sKfx3YS+VpD7RDfu85WyGgRE+J+P9T9289lyVNehgWmbnW3vs9VFV3f4eZIamRaRMmbcqGTQG0AfmSIIe/xjBgg7YkW0OJpiFAgO1fwyHhC18YvjEoG4IHhiAR1JAz5HfqQ1W9p70OmbqIeCIjY+Va9VZ3zwydQPXud+91yJUrD5FPPPGEo0bg0ca0TX0m41sDuMQ2OCLM1wuatfYz0P3XlB/dyPq9/8H/rtklErEWFnb2GrmEKABRbG38uEB2gDYBlpwEpUICW4Gf5zcDxanQ6buFpt96w8ci56Fzq4UUKYwD/4OP1i9G1gUIA2lvEbLkc38cog976ITwzsDz0VO82CR2AtYPDVTCE9+lIAIzWLQO90DYKyLJRk43s96OCotjYlUUC7u7hYgC6Q6XryNVkAkbubriVFEwj/4oMdxMCqEUvXYJdWHAhFKTmhLd/otEw/tIiK57/Ev8I3Kd6YKgu7esqYJ0YPp2TnWyCAsjjJvJF5O+Il9EykFwv1W5C0zKwh2Z1/ounLu4Ma7ln/aPxRkKti8AuSqFpQCcQVJTxhTto2rIoHs4Mmw1auQSPXVp+cpzQ3pulf9/Kh4F82Tc9tgtMta/aKAwLWwAFzYYsAmB4Xt9KxuW3xI068tC6RrozT+PmhEBiy4I4WnmdzO8lJpiRhfW9jMZPbmQ+Xg1wKDwDuMK0fkrj/G4FnUfYuzXFFvy/ZkDLqybEWrzOAef823lfa5nSXUjbjOvvn75mpGJ4burjnkswpsMAsvKhnKu4yS8iNcE3zkXk42srHxB0vP5oPruNTJXAx5aw9nKiKSr/HuuMg58srSvCejg9bG2Xb0ODpb7r0VSGRVaz4GG51zHq+9/djnygThYnrA5S/V58piarBEbxBbTjxwTllzXFr/GwKiCLIOhzFQ9rnbjX8Q9CYFUImNI6/Pg+oxM5tuRI1rXyndUkW19v2JQrtJHStnqEpbyo2pn/ajE99/7a//bBjXKb2/YqnSuEEQUhmkhmpcaZptzA68TUSV8zzO7vs4nKnc3NP/0luY7cR/KwLj8ghGs8HTlgTbNVAD5w+ABMuVz/BFt3Ht6jkUy/HU8j+dAnFSNohFpUXZE26juqDdJoG2Yfm/StzuAddV7WWkHQLM0chqdfB5ovR3VTTi/ETL8KMT0QBKKTzKRV86ATwo9vBS6+c26TdZNdTGxHIT1JBFoIIsH/s4v7uuZiALR9YtAaSJ6/lmh4THQclcU0ULI+vk7DnU/vV9lgltYn8q45zDxUimViClk9hIjk2N7O12/mO6hsI1LzB0CVANh53a3vYOK6MR1Y9JP6ASFHXI7GVkELuwYgdY1qDwnRcSqwdUEKsT6LgflzQnROAiHBRsIrWz9X1V3R7saflqJ4u5EHW7qip3HpBpuJQbtJ0B1EPUVcqHhcZH8lAvRWrjNjbFqk2yHZW0CG8i6QeQYbldjoGfZ/ECXbidqiRcUaVdo0UmENTSxHn+rjodZ3GzXL/j88YH/fvvPZZduOGjIdnD5RvhF0o16SFLlVuILas6xSJWO07Ht/x5tbhZwcw4HJbChtp5ZQT6PQdExfQYZ73AZDtdqKOIYlX25Zhq/lWCpIvpS69pE1ikaqe5wcd0PiakCc+U+YhzB0MqnoRUbtq8TywEAgvNAcV5puR0ZBSJSYMBHHa+XgdLLwmR6OQc6YkDHNPG8aPDlMxvieQw1Z2HB9Wqjq1EE2/Gam89GYHdtr6Mbf+mb831rjBARjaKcnz6KHIa6A9v+TGTGsuM36Xgzm9qNsO8VKO/Kelyl6LjXCOE5c3AKtLsWRtIoV+MZ5yCQJE6ZBtT96dpoYqnGF+qExNjIYyqaX5+Rcmdnd/VjI1kpEg2J8v0N5Vtx4yHipOdi8DyXAxdOQFgmFgkkme3tmvcMx56kgdeXOiK5+/I5KtpeZuGgqIF14LLoCZ8GkPXVHegMLEQYDoloHCifx82OEAbQehKjJxKxIjbpQnkk4QAFZ5QuAuJ+04Ve0art+xvEdQIS/P2/5L8vv9leH3yQ+R67JSySne4O48W72HrGjg/Rx+6uQ57Vojti99kr3oAzn9WNhZ2kuZBwGaNwTJRP4TWxDALn27ybB81X79Ndt+oleddc5/JaHyxinrhvj3WuSp/WyRYsfEq6dy7BplpGzoOIWo7YXsGxq1tIesUgKvhMTwtH3UFpHDpXxgU6fhRO4qXQ3Z9Uo6PKavDn+FB/U9HQHZ0pW0CuV+mNx/3nxfVU1+oV8wAQaEi4nN9v20jlPjQ9zn4dBgk2UAR2D7khYwz7cXTg9veq4UfjFFlFxm9fKD7NnNh8zmLcyb2W3BybHiYK15WGh0mSoBspHie7EAX9gnip/W38sN/XIBOxSGDBEQUgujkMEhY9l3qTI5XIiIJ26gLvlUSr53vJQ9ibe/FeHOqUO0Eh4Aur8dVJA+eLUpQQxLKTho8vaAz1dWVD60fiZ/2pEN9RpndIgCzQNhCsZ5O8eScJbuVNmVlUDK3lLW/hYGAhV5XKQRBtG9QbNxaB2jOwQJLv7VR1kTIvAyjWjoFVSuG1Jmei08iD0rmtgp+wS6nJoL1R6os1vHw0x0EkIzhZjYG1U7Bjrekk+O+7X9R6+8m9JtzFxF6v7xdJqDyniaFw1Vky10nP7Fq8fMNE+eGRDYD5PtTwdM22vko9eUdZxsTk19HsXB2fg8mwQUmfRLRvYOFvUUUmKrSRVnAGVhkTB36IXAm70l3Uov8kqrvBV0SlqkijN7BM0e/MO1Adn8BtqH0C3B9IEJTq0h0/LFSCMbBsyg9720BKGVA3iRoh1H6WQvkyckABdvqyeKhI6sIICQXOZVdCTduCCEBFLD0dgVqkT38jIqUpWKqCd9lvGtMgKn4uk3Piy9Ls/onEsPgyUpx4LA2PlfTuy3oKKsJLZBAlMlFoEAleidZYx2KhuuiuNWaIzzGGlrr1hJzuOZisZB66hpaiDqgX7CFxdw0vmd/Vtb7DkyBVyOEXp5r/EnIOt/+aBfP8eC2ngceyoJ8N+doV7Qe6SfdE51CDL4CSwJBXJNuin/sGW0kciIMAl9dwfMLKrv4055r7FBGGz+CFsaL++GGlfIqUqGyiqfEOlptE4+PCAQvPbV7Q6jqrc1kZIo0fZ1puBxaSXTgX6+BRLJRlJRICOrJi6Eb93JoV+f5c29Tcv/5/YUMLwQxE2mZWwiGPEogkWSBAsFegAPy553r9MqZ2f+fU4l/jRfih5UdzF/7eX//3KYsmyfIOqBN/pOeFX9wTp7UJD091slI/eSLoRu1ZkMi4TUT08peYezU8YFchA/EDuwyVv0VUSfPe0PJkeuvqs4aM3+UQ9euI61tV+BD5E4T6k3H3nEfV7AjQBjNGFlTuu6HJzqBTN6EVbHU7Ohh0CLld76po2yLh1ldJMTHdYyDKJazHTG41veXJ5ObrrPyOSlaVyR6Io4lqUVj8JHA4wCN1T9V76aQ/BiqpTurggM2mnohOGkVh/vY3XPnTtwJ7X2s7YkB695k+Y4+cf23fwx5xm29mBnqUCVsWb2uYEVF95waxUuNdPpXfYNyFcGk11yfa9k3rfgMnzRkCVrdIXUu6KMsxgkrbKLMROerUwAJHCXVsJ3SidgesvI+c1VVQJN0MEakER4mByhBpPceqj5Vk0S+oi5CTnxainNmQlbxlJUrb9owkndCdm9UHp9hzfbj5UbCK6v9IgIlsEh//En9O90HHgCp937MxdPcn7J6HPlLIlY8FhOn0IKK6wp9ax6DH1obmDz13YVfe6aGo+CW4P9NbY5nhEZR3JI/rOFaNuxH7O+VpCqoDIniwx4bm3ioOCemUXDTXX3qSOR2XMW5D6zbiiqGide4vl5E3+BLVXU5jRbDILOiR6kLu5wXn4sLxRFRznDo3eJPdYeOCri5I/tvMG5b7SRWZJcOdmu8Hdq8qeiVVmpgyEXKh4WHm9Xda9dl90Q2wuE0X4TfhexhbnNd1ZpfdWlh3LFLT/hqtbuVz1EsB9NdtVk07e1ehT1pvg0Z8tLDVnAyrzAHT3JynkYaW90pUVQdwDBHRONAf/OE/3LRXp+wiEz+au1B1NaCubQys3eKNHxuuLdEISA9Szjwgys1I5WakOInY5ONM6XHmlz3NHCKaM2tS2agNKRqZlwtt+FPgW73GVeiLN7BeUY4imXYNLEQsEjGJP4SqII/QWUSK2DYcB7ODAcojnAAxepCna74xqS3wWPK5igdyEpLuzdcygXbCu1Uz6VOJS/15vQgpRNss1cBKc6HLt7kaggv/W26Y3zG94YlgfitGpYOhy5h4Aky8gIN7xA9MzSejWlSzu5s0LJhc9NNvXHqjTAm2DvXQRmgNpiAifg1E7+7fLPA2nQQeBbtFXDcFrZuSsH303sCGdB5CTUoLlP8JoevGPekWBp38etIXneeu6FrhhSdUkVSlHuBUNEXgupQQ2MAiUokYPVajPt3iCzmM1J97enXcuN/tdz5iCu5oyYW5vmF9v+tPTppCBSUnNjZmTsdKd3/Cdb68b8fY+FyUvwQDBm2BaD0/HsG9AsHdFshGVDRErnVujTk29mvOQYt4w30J0nsZOO8oFUa9Qy6qaaYpZkxancoVC7TeRCpD3TTNb5hLs96M2m81LQ3eo+0ayPG6V4B8eImOHpLh3r0u6sqHAiJbjymJgxyqyPCOAS6BMPmUWiQU9yrIQpCJCqlmlU0rBE3I9LzyethJWQadMjV6fL06Rd2zQKcuHdE0FDwe2tVdVzdKp6jBappTMksOV/mXTwMRiOtYwxCYoNGHIncBGQcNbjOGKJkxfXJG21FBv8KafBRZ/sryoxhZv/fv/AdEVBcX5IayJaiEAyrf4ZZIUZVeTFDC7zoyYNQi3knVQUQaRVj2Gg5yC+bYqpoeiWLqn9fjWWlkoSOuzwd+Yb/7Oiia6Ry8KwQM9EJU1fedlOxexqRpFIjqBAs3YPMo8njzHX9e3+13Vt1tvMLAwoRQc5dJB++F8OuiLY8Cde8Dg0wXmkI0vxmJE5MLmuDSOzX3GvxifjBhl7bOamgdTGCb6MLOO/NZAMqBq3AT7mzb7xVItSf462LbozDC9fPsOJG9+3hAzQkdtnVoSfy6aTPX8AKPzXuBbWYWa6L+BqbRw7J1P+L3eGmAI76Gj5Q6d8akFCDG2MRcv+wgqJ2upGPFRez2NjsYK3ApQuATfClbILHw9DO4zvn7I9kOGFjKkzvo+pgPhkcOShk/LtUdhvygD/vzX6M1RzvjzC+UUrocIhSNJIXRerDWrG7Md8Ruqzq6rHvT0mYbyFnP662Xeq/c3iN3xo4vGJtdzT1c1+u6SemJsyrl4h6BG7we58tQLQjlSm4NrXhdKZ+T2SwhgGQ7l2nOSdAdDt2y8IZRc70eT1MRquTmyN68tZhNI1X75vuWH+wu/L1/5z9g63JMVdX4XCemMEl0T86s6r6sbHAIv8r6RvP9bY0wypy2gkpR4pqmSri9EC0rzX/hHZUQaPzNE0ea2CjF68SinTBY4Lbz6BXCOXGMd7/BXaNRSRVStIgSHyrNdJC6JygZ3bjyLK/LRD2WnCmEQGXNFFJkTtc41mvbRTozv0tTBlDtJBo5MQ48WUqao5LqzuLlK9EWOZkIssRGzHLL/nbseKG3kyYmtMJNETI1IeQ1wXR1q9UFHKsi2ofEJSRfOx0k655IM3NFhhdONYEFFsZfFETr/JHT+ECFeXxaNI2ESixMnJQ2XhkJAZep2R2VwsKFSM+E4t2xQdJ8hPYZG5JmkLQ8QbLcu3Oa6DdEvtmoNow124aZeJKzXCJTLyKe9LPo2litJrhlqugsux5LEEkIJZzX98IJsg1Rd1qVp8UXaREvrRf+ROohcu4D4/JUN4qZiMvAyXHXU32GdK05BNOjKLG/zPz7deK+p6iVcQPa8SkpNnScEFVDyUYPIvLIRxQ3UZTyu2t7IkYDSoq0vBkpj4Gev+IUVMtNUKMJRtbla/779tfMY4peVmWQfl6KRqDlU2hmamxilrtEw1Om5ZYTFSOidx3DxiDKQ6Dnn0Um3z8WlWRB4XkgEhWuQ8hsZKWXGmGMaw5XvheCYcYHGFMGbRABTiClKnYrXEA8Q5xW7iu5VL7ddeK5D+4gpI4aUrPZ1vGDjem8SFqkgd89kC/z3hhJcQvyWjYBXGHJzRjWyMRoDRlMiOLeF7e41u88bjMByHUQ8eo3DxotvRYlis9vR6ZlwMX3uNByNzC6mwKFpbS5go2hUU5DXYdKqXOKHLOCSxiJcoo0PEyUzwOlp0lFm/c2dPk0UDlVZBho0/AwcRshHU8pShuCyzBc2XsFJBPuVCB5MFALkPkQNFXSehlo+PBS34OlYoBfqZtimdvxDGZzVc6MoP7B//f/2H0+vJm9H344knUQjaUpK3xutk4Cx3x/S0TVElb/die9Rfj4RERE46+Zf7W+u8g5VSG2+PpYV+Ce9lUPTtx14xw03cZddLD78Ba1zdUEw0wmBzXQxGCiFE10XGo+e3WufneRaLjd7rDVCJLHnMRwmTroFaKCYBip330tGwPLa76ElUO12cVEzXWOYN1KonULuX0GaQKgcnBTLJdt2yASZ7l1kHoIdYekuc36UTZUTN4919ZNMcYY38tFNtoCiPvcIpW5F1WT3BgEtG6KkmndzjDOsoiv1eDS9Bmd91AXPfm87u849/Sluhy2oV3QwpKbZLZEdeHdpA8JoTGwiIjoKotJDxW2m6FO/ZoClNGnXjpCsozRZQ0sosp9fJZNDaLw8hhofhsortXAuvtVJYP7YnMHEtU+3ntnyIIBmQ3VoJu31/URitN9oOEl0/CS24AGWwfIF05E5w+Z0lTo/IF/xGcP0dZcgcgNOLaftui49M93EDHa/B0CH+uIz37cNhvejvtu7xk26GwPgAFa5vqkggPNsWaDTILOiHvfbwSRpm78UF184EieJKE2vAXrzdbtV1K7Waw8w864wFIOVAt6l0eRjGoHQFIjVqkLH90rbROf55oVBimvFoeemxLcOor5DvzH9uAdm6WXVg088NeBUd3yg6ML881YjSlr8ROp/H2+GSk+XCl/8YbCdaJ8f7OBbsPE0Vbh+cqRX9CueWRCO6XUDgAZJIieyndnih9fqNxeKDxfKYwjp9OxxfKmYmjdj0HEOzuk4baiLXql182Z0/EsC9EwkKa1ARIFQvoBsb8xtOyugqgS2q3Qm62vPbbU9udzU7XciXcS+WaguGSa7wZOBD0I12KtO1KQyq/veNItSRaFUkVHlZSJ12mbq1CzSPqow1DawQlEzB4bMk9kSBlCxHXJQ6A0ZTp94ISo17eJzt8VRbM0Asvk6ApT0RQSJUZ9/1kXTv5AQlRNfaP5zta680VZ1iq2F4mKtfrwfkppJ0skqJ0zlXOqCaeJUS+F7J3bKYvBlS9MdvV5u/gCpduH4YpZz5LsNXLdmBDOSXBBdG3kHAq3i13ok7oKDZKFxMopNosRohF7RdP/gGBsJ/eB65NPSRGydF35XQ2B4pQpFKqh80PkXXowUaFACEshTU3lDSyNHl4VaVCdpVzagILNA8j1RFOnNpAoVsOIkIVo+upEYSn0/NOB0lzo6WdRomINZ+q7QiXW1FTDcxZenBg/1KJZaaLNRqPEQOdvZ40sK0Ok8cNE681A528mWkRfMI9Bk7svd0z0fvky0fhQ6PpFoMtTURQqXTMNxAvcfD/Q+LDQ9MWghtvzT0canzLNt5HGZxEUhksfTX6JFKfCgS+FOWXrmVEQpByqUdv8sOsNo2/D41IXXYTYx9jKc1jEkahFT1c22hWdwvsXFXBFqb38gze0lmzS9MDKlEOx2YlUAzosemI3wKh3CETrShFJSpRrVlgGwUTX6vvFXCI8USIxtEqhUC5EmfmMGm13XRsS+nrDke1xWo2gam43hpE3dHFeNTKbiI3duHIE5HKbKE2ZSk6MLvr5XSk8HBGYx0QUGcEqMVA+JUrPta11rpiXDYUiTAvRmCi+rIS8iCqZYeeNSIrAM9l/UU+CN+SaQBjM1VAzsEh0Soymfc/yg5Csv/03/77+v91dNosGdnLQyziL5WssfxAQw3PrFgwehidSifx8M7Lxdl1YcJCoDi67u1HXSWyJ8N5fDaSrw2fZ5XARbUj7NuWNfnqJiOa+OzCrNZ6svpVZsA/J0hptCNKh4V/dIBGtfN7WboDovVmI7fOtXBJrkoCQ0z2HeOfELgp2LdYJgv/HPGYINUJpLSaCzRyTtt/po4Gsj1gJIGXSdmfRjzmLhMNyw5P79V2qBhea2UStwAVFJFC97xY9lMmWITFS6w9zk3RYsxA5DfQf3bFS8kl4c+dRw6MV9To7V+FeQb9yfashqcsnh0Z3rlncJzEiUYagk250LpHDFETmWqH4vuLuLZO+vR6M4eiU0kuKFJ8llN9zTXTjYsaM2XDYEqbZuJnkvJ6kCj7VYHPPrJM5iyqGUmj6iue955/ye1TOE6o7EI0f++/VokAwsNCn59tI032i5RwpDxyBe/4WyYrb0H38PTwuLNT4uFbyOQSdRUrh/B3/Pb2JND4supm15fRdnWeheYVPjmwjokKi92QMdUUbWvQN6Haa6ngCUgfDsDZK3wgiotYtrA1X3Ydq0ItxpcgSjCB7zbXov2Jc9RsUZIce0pSenhrOmxd2hT5cjeq8uya69BB0QxOht1Xac7Am8mZurfJJdjyd2vWox0MDB2w9Jz0eKBHmYBWXztzX8I8NodJcRwOJsrguex4Y35aZ/yGtT5xW3eA1CCKMXQ1Ykb9TYDTMUIM2UklKE5D0OxrcUg/52/+z/3jTPq8pP8jIqlEDThcDfuVeR1OSrTxsTyAM53kNixh1AGFX09sll7d3bNWft25JPiBv/99Dpr2CyUAjh8ZqAJmX1FzHf99Dsnr39NyQnt6V595Ec04MujO3Be9mAQH8NlKaWZsGC18vjxjKKAiWj1KKS6mdHKfjkLXKFsRFQoudQeZz0yHvlnU9gsD72jLf8v2mN3BDAKqqE1JVfI4U18xpaZp6GCTOp+TBBHFERjX9oKbEwftyxrIlz4sLsiTJ0eVGqo3W242CO+jL6hIcAj93NO9EuXzU/B0kEXGc8naCdgrSqFtz/pEhlqthQkSKIpZQEWevpq2uretCZRQkrZef1BfskvFbb1H2rkQ7KftFwI/RsRrEYV5pvh8pOtJ+byOB9r79NVyx0l5LViMH7lpNbQNpk5HlH87fLNVoAe8QY2+uCOTwOFOcs0anjQdkc6S7GUSw8vztxCljnmZ1044fxOiG2vgsaXuu7GaMU9b3P0BYU66n2SPeJM02AQPs+u5gbFnDKcU2qtAbQTY4BPP1mqmchq2wpR2P/j0tnb7ii537QWHx/ci5rEIuDC7krHqPkKzARsa6UWuuwLZ9Gs4VCnIPvq+K+SqL4CgCashBhuGcqAyRlrtBVeFBEcgHGz2l/XTQ9k2wgsyj+fZC5XJulNk3xHrlrmYK17Ub+NDbEGg7oV4dWo2VbSAiWn/yhj/fXSifUteN/ZryvYnvf+t/8Q+IQqB4XareD16QgdbY4g6atb5Gfjif7LxUwjYmvRdGtsCvCobLlb/kBtDGk91JfLxSiZHitx9q5a9bXtdGv8pHaNlB2os+SmmzODb/D6PQ6pIgHYcPZ8fkvKxbuFrrK53Muikb5Mos3NAcyrlxQxHx4FwvA+Uh0HKX2FWYAuWxTtzPP3fuIiIaH/ApE+W1KNE9XYuEG2NSL3pugCGTJA9VDEShDj4ropcH+Q2vQkO8pblMyLhyvLA7DjwApzeRKHAeuDhzuDt2w6cPFb6G6CnnWmPXVES4NG0XdK6HmdRt+1OdVIKf5HVQc98vY9qgPqq5I4ZOGbaTKa5jieDB7F5DIb6+8JiUz+T7qCA5eZT0FedEOUUJdOBjoZllEZSasFYmbEglGFHHTTJra3g5F70aZWudTIOgBZpWR0isNbFu69YlqhN+WHJNoTPNijS17mpM+GbuAbKFid2Kj6K9vGp7j/eo95DzjUr28vZMOQW6fjnQego03wdaLkGlGsYnudVKdP+vVqLCwqAliAGSK/I7vasGwfOXguzJ49z/saAVmV0yhDB3IoMgCAp4GoiWTPkW8iZJxzrG3/yG7zU8rWqMeQNZkQqL+Eo7X7860em7meY3A53ezzTfDzQ8CgkbvBq8WzHkpneshL/c8Dhex6CpdW7+dU2bpvfHRhzv1Bv5VppjcBtdee9liBqc5QMvlARui6UPUH3njUFm3HC0rETrquLTSrrXSMmWl6SaeLcs4rm+Oeu4aXSgYERr5H6L7uTLsEG2MN7y/Uk3TWHNjEIhrY30EfCZSgo0vRsovbDLdfw4V6kmNImRatL5TDXFZsq3J84/+eGFaUSYN9CfsGENgd9pDEzFuDltDL9GasNzYB2flI1XADrmnkCi4XY8j2J0gwsrXN23bHPEKdNyk2h4Wuj/9v/4D6lTdi3O749kOXJcD2rEQ8UHkO9y82nLJju2IFylJ3mAifq55kBEQyK8tLy73686+E1H5HVfbNJoa2DtFbXE3c76SKvDE++ODGBLxHXX1ISaHZK05t8CiVi5S9tbQI8KrgNwLMbnqgQdjdbNpqBaOgCkDp0mULkA2AK4fo/0q0lh7QX4AxySy3cw+DrPhcg0RQcOQrt33kEZ0+5usilOeDS+dCokxSe7LR2XFoolmm9Clo/6TQbSAONE2ukoZN0HL0x5Y/z1xkMNsW6v3Quxriha6+bry3ls76UpdNz5XT6Yz4awt7Eh6rsVPPJ1MBdoNgUhd0NstCePcfcLQWyRbgfPZJrAy1gQkWpTwQgdP8q8eN3v10E8AYjUiwfH1mCVem+fhaEX+HD5JfNpz79hBOX8jawDBwnElZwviJ0GuBDR/IUs+qcOP8ZGgxLVPnfkvsbCfpRBQakGtR5b5fS1/d4WTexewQQi4shIV7wYLozJ9OGF0kMHKNic79CxgzEdBSWrqaeEX9kh4SM4aHo3CNo4ahAR+tz89kASR7ik6VHe/8Pz7rHhBbkGuc/EhxeK+P8rvFcdVz+e1aHx3bnQc12F3N4IPaPu8o6ndxK40gkW+1T53kZWHmMNpTW7UYpi9IAM/9yBL4nqxNSD7bxrTIiO5emla2DpeZjzLIyMDieGVRhcI2GH0DlHS0cstd7UvMxSuK4bAVEYpOa6duGxoaO968qnKtX6SCd7WnexS8wPgeL0bcvrqdpHhaZ3gdJ138DKZn7TRKRAf5ayiSLyi6RFX0pkor268XAM1kmn8Bun0jewdoq6NENgZCAFdT1GuJ2XdkIqgmo1JGkpG8OCtgZWscgHXnd2E9m01okUIqcdgm3vGnHJrYHlE7NqBJMxNnxfQl2l/4CnlSbeqaaXLKT0rYHV5YIpisdtVGLY9kOPcoVQJ0QfsLFZLNp+ps8+c33jc7uT93MKxAvtc9RNkEP6BA0EAX63eAMrhDr5Qw3bjTflK0nfHZ4rinX/J2JUSA5B3Yh0tI7SNdN0H1lRXW55+0u+qKYYw2mZ+1LImdsHHCNT1NCaVgq5jmEorRMZbSMyhqtKs8h1lkxRknLXRRuIZyVhowS0cSldIw8BFmWowRiNoZVrImj+csewkqAH5kW2BrZyHV0mBOUVmRJK2Whj9QwtFhBdNZWPGlQO5Q7P1xqQ4Yr2PUOnsYZWXNgNC0+RRtX7sVNIpHpOsnbEuupv5hi597xqcvX6/rb90EeDzm+FqD/GjQYWjDqt39S2TXh6UcOKOlSirqG1llZQ1b32qvBuvAi+wNC2On0ic6Sodqho6+cKaxPR93MXNoR3QJVoEL+jsCRTTH7Kv5AOJtAghaDXKc/S4NbVN0rmdEB6sEBBpjeK3qr4vKycxicEomWhUhh+P9K74j+M+83+3XMRIrdgKU1UYTN4vIFmJPw37dPbIQMGVT4JQ96IzlKdMp/OhYigaL7eDDoglhu4n/h4EHGJKicLJPI6ibJBZpPJejdSMLkGQyltz0HTGXRBw7d9CHphoy0shiSP5hHDLKyFr4l7hPo8cH3auqr8gKIezkAxC5ollGpuNPO36lKZ84nMQu93kWjeHqfOblKIanqZkaNWm35g+51Hk72xYu7l6x/WlfkoMWxSeoCDo2inmVjAp4n4VL6IJaA6d2EwbZuLav8QufYybQQ9N24PoD/bTYUuAhjvOddNi38/1hBVQ7i0mxXc00a9eleNR1LMvVRiA7pHtwPlIdJ8n2g9BVoukZYbouUuaBDJmz+qffTma5DVa9sR1YXs+kVt56sEp5w+FhqfMl1+feW+jY1DQ87fRwahSeQFepXQTEyWRz0qqVkMikJ1sadq+LOaudF9MvXQArDTKIoj7Va8rrTcjzQ8LzTfDjQ+LRSmTOlpqv3GROmp69CuL0SVg2fd+4KuYHHVFD2WB2xpHP7vcaDwMm25PR0qQXiZ2t/0QVeWM1ozlTe37b2kLo1228Doucq69BArP/ZNLlKU6MVPY51zSKIn4bJHn7Bpt3zB/ZVjN9VnUOBD3kX6+iN/MS+83l05IrjkXFPOdea4ciMeKqBNbs4kcoYSrhN47QvXlfJlqKmZcD4C806pqsXDhJFxMX3B90wGgf2//8Hf2zRDt3HaKr6+lCEqWoU0I8pdmJd+WgMfubGT7Lic2DcaTifuhMNANpUMEVGZZiYIPvA2ENawT6XhSYYbgxKTUOaw0ILJMrSWbHeRUyJjNbC690AxqQMaUi2MUCMp4DlgqoFlDSzaQRVQhNuiYeQ3VfKCxRz5MN21PuE8/kA+wrgUSnPpu90mZ7R09ItqfewP1NR/w7XqNGElTVN7Lz9nL8zBssYVUU2yqnUVYUP9f3uvq3k/1EGZjEuqBGsY9hEjfkh85v6xxsAiMm1njbK19HedWYRS0b8sgd4WNTLAJeF7wFAJkgcQZOX0vDYGVpwz5cTyCT6fmKJrdjwL/64ppq00zH3PrSHPUvVx2khGaGKFl6VFEN3zNsEHe4necZx/d54LOaTtfeRevOFZGwOLiGi+53cKfaoBqjSyf5xvZVPzXevCDcIpy0OtF9S811Og4YUNLCKiy6/lYt5l5VASjzCWECi8LByar4uj/GgM4+XGEH8t34jILKTVuGqqYFGeUhQpsdeo/CbuX0C2BkEpkfhbA1N8EIotNho7xc2Ys27sMC8VnfKaW2uuQplkjCX7bMta/01zdQsCqREEpkwTlWXRf7oGwD328Ynv09lIaMG1nW7UZk7B3B+pzglGFxI8PG6r/q3QT4YH0Vj7jj81ldZLO+enKwfD5FOqayiRBDk5A8s9j76XySF+qMtZUMvTyHMFni1SRRyzzIWYLzbXkChJ6HohP6JfQyFoeh547J0TDc8rDc+rRr+OH3a8czvlexlZvfQE6mu2Dbc36XVgeKBRNaQVSFQvLUb7MsKyUhQ9rSh+365oIwpS3Xi3Xi8NQc9F6POf9YrlcO1dZ6/YHRcMLOy8eilYPDcIC0MHhoZ/HRPLchPVXQdDCtyQXoHbUF2FmgB6e44aJz1b8DUAKuwPF1nVLbgHzlkKnd9LFBMSB3dcEt6dUcOn+wspUd0lIr8WpCD4AseGr72OfvaM5aPvYGAdpe5xyEVXAFSKJdoDHQRHS13BPUMIl9QJ9cDIxKHGRaGGEZpu3T8fhi924RqSfsBxq/dk92wwC+arijeweimNlGiLjQ8jynmIyj1KB1GxJ3HHg0t4xKPBOEW2gzRVlDcfpCrxxGxFBrscNHQunBu0nwPZAuLZkzfBe1K6yB6yS9X1owaXuKjsO0KARbeg/k6Q+fBYoD/XmfvDuh4K1+q6JusL+EQQxO7eSo/lY8rzc702UNFeHwdXyZG3uwUbj+e2DeXi++eh4N1hCkHf6OhBjd+1nLrTeyBWVaD2cMMPGxAIcIePplX3hlas6GI3t6SUDYqJ63XaUBNQX6A5CaSwooZKUenxx48M4U75/mKkuLfpmEC0NFLQyhX0NEKG1JLYdjpHgaElnyFFyg+PFO9uib59T/TmXnRGeGccnyZ2hdycKDxdqdycWaB0GKpAKeoN4bNlIYpJ0+cEw0FodrjWr54qOhfsd7p4YuIb6m/rakLH94005V9hAomRCN5WJMs2kSBNXVFPU28bfgqVdXTA+YbDwJHTLC6F6FrdRutINBoDJ+riIZwYFyKupNghVBjeRLyxgJwsKEMgCF5SoY3Kd83dxXVWUU0vtWABFEFa4pR1gYtXds/GK0euNCHF4GwAWUmBaKXtO99z2zVtb9AmlEbkTzgkcI9l4vdqXLvd61rXDxGfuxJtDLfePJRC3QGSQQ80DUnUuuQxbpC7NIlmFSZLNHnhCYelFsjVwxnYdgPTqaPlukDE2JaSEoXrTCUlJtDGSPF5ZtdnRwamCop2brasGwR9cz76KcaRRAZvXBJr0Ug9fZfEk3MeYhV7hG2JGddU6+abvhtbdaRMn7ABKoiQrQiYXBSbLuMqLGOqKBuijk2aGNx7PSczVuteqAR+30h/U3mS1UDi40J1cVvPAH4jYsfELPSQl5nKeVDjOd+OFKe1QdaG9xJl7jaRXIFYESBEi9pjvLsdLsFlJTqNvFaNA4WnF+7LL5DgxxweKXx8ZP2khycKlzP/PY5ET2IUjSOvHynVQC0gVPwiCHSVJvuHro0g6Q0UPj5RubuhMM1Sn0ldZWFZiZbE7sXbVN22QKKJVJxzw0PCPGqGIcaZoufW2MiZaC0aPRyf+bdEJKm12Fu13A68Dpik3b35EsZ3OY3secrZ8KCrQUVEdV208it23JVijPfqng3rSqWXXSVzO5RAmtJLNwM61+XaV52Ri8hJH1H52vLZZ/2tf+8f9KNWfKqAI3Y/iuWyyCICSBaGVU8IFN8V6eTlI+sLhA+P22NvwNcCn4vJeSpO+triI5HOnWgKkOqtgekH/RGi5fWOeqgV8tadjPG1hyT0boVD5JxVdseY6JvqiNsimTUMcHF0BPLQ0Sap4fWlOaZJlQLSO8al5UXhmjrTd57HPVeFr+u9fQRN8973DPs94ViqO6rqLjFG22sSQztjZ9dd1isCk7+2fFK01NQD/DhkvQ+5Tsr96NGtEcBfHFXIjfkYtwhW550A9VD0A/lMD3bFakRGs+CrUOgRCtiG1OtzXnpRbWZhGsRAVVRz/xYoN1+bjQ3RYduhnRB9SFQ5h73x5+tYc146Q9Ee6sRq45Rr9G1u69iVOQGi4MeKMXZ1HOKYa0WrFKl0iFi3eP7TQUqxpk85UnmN+Nsa6wUZR+BihxFmo96xVvUiBoHMaNSjPJcPwDLXUSQMc+vztbohRbA7dtLNkWv7o6hn7QtGJLQkzkShHNxeuh8pqNsAKZeD6FQ1+mFgWU5jT18PBeiwSDcBgep6C9TlWz0SSNt2hErp8zgRYx+t2NxqCPS3/r1/sHstXz4byUpPU1XIxQNgt7BmIirVOIBGFJTKhXDLGlWu8jYP3M7EGUJQ48t30nKdKJxGCt9+oPLVu5YEbtEnIn7J00w9AdJwGqvBqIZRqOetKyNjy0rlcqruUQwiK0xod/UeBUGb2Z0YUTXC0MFOkvx5TIL8xHoN7FbWjoFF3FHyZaA8JuF1yCHyPNM9X+vynut++m6hbBJ5lhOjGHkIzAXJ2MUIgoVJYKkdvKTIaVscHI1IsDBnKqdUFdxnAzcXIk00nYskbs6qZwWBUiX7D7EiDqYeVaSSEYtgd3HFvQuLEjUcvFLfje2rcr4iLivXM4+SlNagMKq7s5SqEddZfIrRNmt2gQ6N9JwhJKMNWVAUZ3w1Wj/mXdSIKLR9/a3Eep5yoVZW9mejq3A6DLcT9Ol0ulys3D47EamSdkAgyJr5VKQ4MUhEuHLqFI3aepk0uixgPKtoMSPGiF7TdrDptJSA78ZOqufXemJ8B02mi9QlZUxVhwgEeNn1oo0RTHL9SjY1v6ptBdd7ERdjiUEDOzKSYQdO2h4X5mgNT1nbOHlJBNtfkGi8FCoUGvemdSWHmYnBjERx30K6JCKi8WGh5SZRmluBWKRTYnQWG43VZKdIiqQRkQZ0hBfWMtP5E9Fx5xOlhyvlu3NFXcCzkSjJMppxYo23qwl+MK7eJtLWtpGdByyqguNgPC2L0XMaeJNvBa2tFJAaoraPr3VTHwXRGoa6ES+FyrJwsBR+s65t5VXxWqo8r/PI6xDS0I21P4ZpoTKYvIKSiobWGjVZxy5SW9XABnWJFRjbC2eroKT9Il4XyudBE8TTyum7ysBK9E3KG1zuNFaDMUYquTXOkCUFgEVxYAauTTH2ud+EdYjX1iBpdeJ10fVCn9+KxBLV1ELSx5CQnOsfiObaLq/ZvKJ8NpLVpMPxREG8zLmqDvvIjiYZJYiH2EkIihU6KFEI7qFiEPdbrp0cC9c37/lvKI0j+vDuZps42t4DFjYMuFIqKgVIdS8hs9UEOuLlKMrU1rnudHK9B3hlsfNicQ9vaZt7Q91dU58AKFsLXd9xhzvJTlgVm82ErQrNzxiUjC6VSFsDy7mgOGy8cLZ4fHeAHNb0Hvw35B3KECuaYpTH23uKblcIumCBD9PstntIyY4BE+z3u5UWV8uSW0kGMoaERa2EuL7hUiknqbMbdAZJ42pTw8jxK+Sa1uXW41HqoRpeX/WvgiwI4GJVV6EgoOckxkDaJJTuTkAdMcWqsec2KnaxJtou4KaENVd3oZVhIdpuloxxoKWHZKoRVg2Achl5MTxB96oN/c9nbGYiC3OW+qzz/f40u1zg9pZJPlZ0V6P7nMsxLrJDX0tFlh0JvWmH0o4bItpw9TBX+HRHVm0ewSM4Jlu3rkcGES0unLuwrvXaSOLd44QhiOnxWl2KdlE0z9MgNVhzDuZ3LZ3chkwTMBtjQ01pzlmWakBh3SkH91QkLXN/mtmIKstS10QXPEUgxudchbTztv+rseI1uOaVDTAT6e2DFZoquoCFMrBhmg0/C2Na9bWwAbsulJ5mGh4m3XjVHJMdFAjRgYJOhSFRSJw32BtYdr4uN6e62RhiV07H11XtgYkN1jCv277UawsEoXl9P/N3egUXFOWzjKy//Tf/fiWa5sLGgN0R+AnM6EwUZ9FyTdvdPVx65CZdNH6xsgedov5w4y4rKXDHlF1tuL2p9zalCpQa6LmXV8ndv9klwcj0htQRUc6iJ5lfsA4Wgco9sV0hXUMaro2w7djXLyVWPBBR5Ek/TUyc1aTLCybO6uoIK/+DwaNVNq6jmocPC0FFjaDg7d19msoGiYh7tlfh3y1SteFfmQi3EkgTHDfHUHtP/sNMPNFMuEAYiQ6hdqCyXdegJwOb/hEyR1dt+1DHoPMImiGy+8lLo7fK9hhdBIH2md0rSk21BMSZNClx5RSV5nwi2fVid74zLKvhJcYbTtf6LfuGj11YEJWrmmOy07eG6Z4r0LZjb4Ht/U3Ec0YuRGdRxz6bRcep0OcxcgqSU+R/ph8MVkZEvE+TJDK/fAdDkq/RM1DVfaMbh8xaZmupY4ioQW2JqC6svr/Mq3DIcu07XrnddGMb1RmmXDcwgprwQzqeaQjV0HLBJI3bVRd/ZxCvmbUQS9kgsnZzRUTqJmuEY83/b4jKTmW8GXeaMkuM6N7GzCJXNvLdRPBVA0zG25r5WilthLY3AAKRcoPrF4VdlPjnntE+ZxmZvwhjv6mH0Yzz48xy3vJFjDRs9NGFoYln3Li6sXyeVeQW85fOP97IC4Ho5lL/31Jr0IeMW9EHaYR5bSNHiQ7pP2Fe+RmA3ptAlWK41c05ZnMPdM9qb1kpq6Pyee7CZndfmp2e/r4y+sMdnt1HgdoXqHAxip04AdUHZuJqB4yBQhxajlYROM8Q5cp6ZULjr7+h8ltf1WNNXcPlTOX9h/rbkhmuvchLH8fqrsCt3OTcTV6NAtQr8u4o2GtlY5B6K1wHiUOyiCifBnbVyKQeJ7hX9pEsq8LLxOWiO+c8cMLm218JBy4EkWxYNQJRkS+MCz+5kVk0Ox28JUMaI0mulRbSSSnDBZiqUealIdhAMfcV4i7SQ+TBIFlesNMhVRuuhnfPFeOGpO3CrG6+JYv4ZItkNffCZKjCd4GIQp24PgE9I4dfWFd1YbLcQlsfbSM9r6g7Z2uYlSb3GCLGYDiFzEhKIx4JQ4uK/s3Jamtbw30HkigHLIhLBCT5GIkiuyBoSLxIGmJ+t+1wvx5aYV312OyoRIy4ZDxibO/TQy2xsZPw8XzPc8NyzxO/bTsfyZyuq6ZqQr63ly+4PVbZ493/K36uPAYiRPdOpRkzKrNi0GXwo3jjU8St51DUXvYN/IZnBV9tHCjkVUVkQy5VH83ab5ivY8fgQfvGQBQHddsVvNtxoHBdqMC9mkKdD+elHovrwkMyJHX3cD9uxy/3vVLpHyjGKxDgZjN1ZpcxKfm9+a1pNEZXdHOv9BPjPdEGao1d5f0GIlpXCiny2gU39DQTnUYqLy+8wQfny9IBRHBbv7OC2nCJWqrLmqlERtXLZaT4slC+DMY9KMdN7SaeiJimsWQKAVHsifJlYLffmCqKnrPJFlHbXEXHh0TkBamXuvktQyQCP/o6s5fpOpGmoMPziB0ALcwwr1UHUwzv8DK38zYZO8O/c9nkEhEVAnqMjR+vxU0+1sizXGMkyn1exTc35bOQrC7h/QCeLcZVGJbc+qDP7cTUGC2edIzd8BFZ1ZZpphAjxV9/x+ddoInRgRb3rpnzlhh55PZSDlWHHIt7Wd7VkOrOZw81w3kQTNPcTZgo91/y8o7Rq/ku0SqGlUYLii7Vza87RE+b80n89CVQY3R8Sp/LHtMNE7dKvEREuVCcWdQwOl5VF3LGPXBpqavd2cOd0xsIm7Q+r3AJllQjdrCZ0IXrgCDaTOxEmpOPiDZoWSMD4VAIG+a+qaJvI4OCWXL+bhUtskdtH9BjPBIWJa+gcUnsJqpu7oU6rxVl9rvUzvjajL3PcOc2fJvw6TrWdyWuwLszUSlqYPWOJarjC4bV/JY/n3+2v5dtkm8nanTiahRnpz1A5p3bccI7dmd0oX/CeJnmSu7XOW7fnayLD+buUN/1UWoppZNA1Rtcuh4CjGcczbidl2ajqfc6Ch6ynoU1UzcFWm/+VledGDu9dG7+2LySygHBvXRA5FbAABt+EdwuLy81wtBGvbu6bs7HmtFZc5qNaQxtVOGRvJGeL/NGR6Zjo8vVQxCde7M7j+NdIyfxMPA/0ICo9qGuZ8Gj0jbf6OaBTH+NRDaASNH6A5vJrlX4fK2Uw6uNrAYa052jeXBLQhMSHhEdT2Z+oozRcC+kk+111o7PtFfiNyyAVu5EHX4c2Ai7udk3sOwA6yFX5Aw2T1ZPke8jeQ7LaTzU2tFr2l2VkBjhymm4MtR2fj8JQ6V3elvfD4yPmrJGPgO7haIQ0+09usVCzcUkGLUD2QvMwl1sB7rUv5cxXd2RjfuMGrfzUdqRSuiugxALw0Y3xfdP2yedwdgrjcYPXOnLKggr0BS32BNViBoLR4djoBOTS3/R8Lt6BpavozW0QKIlRpLQv5A2Rd3GBtk61OvBbTcuCKoRiYJA1pQ/nQVdjcIa3RZEHX6TlNiJGKroZHPQts03v3WQK0WTMRY7c4TKh5h+oSr5gkqtN63bLU1ELz8JlAei219mmm/rjngdO+3bMbTimlukEt1i7PQdoBVPbS64ZkFEm4uhlZ4YGeANT2EuVe6MRV9Va2iBG+Vdvvjb8nglIa+uFf7z4F7q9hmr++0wYtSPCwhAL+vGINBTcmaNq2Vp/xFVrcZesYZWySLh4+6PMWAROH0OY7gREc0LhZH748bQwqbnNPKmQNYOor5xrs9mDS3hRlMUxBLrAOYNy8NGHSdHzbH38u1pDa0sc5/vVz1wwhlanPzd6a85HqYa8KUcR3q70hha9vnF88YH4fnqs77GZfhZ7sIAzsq6UnANqNEPaiAsFS4OgV88jokSkSIGDxHvGoOkK6CXa4WAQyQQC5GyRtPW2IIOLTuXMs/V/YfJBI1zc6Hy+ETh9oZCCJQfnxjOnQV+TIloWRiWhY6WgZ3LyPAu8mfx/WXw98KIcyaKPNAUNSiFXYm5tOiV6Wz5ZqSwsJJuFRKE+2frHiKqBtbjb58proWVoa+s1A0E6/aXM4VCNDzOysFANFEoRKHwwrqeKum8WBK0z/cXqlYWLZkCcSgwG14GDTGLNSJSysj5oEpit5Mag1bRPcg/86gBCJspJbHLM5/iRsQw5KJIoNZV3qlG3xDVSClrDItxgklCSZNq8EUj4bC25yXeODQissG1i98tqntN+CzR7f5D1R9jqQUzsdj+tWY1GnydQeJOzzMtb86aCYCINHdjTmw4cz5D8CSLcn9KCJyOQtyXNUqpimTaCUkjT1Pi8HDMJ3gsjdQ16JbX0QuB5wrv9rPu4L1NQqPuHk10oSlZuFelULk9U4mR8nlg11QumhhXbx2qkVMGoiwuopALXd8moiLGVSIKK9H4UGi6D3T769y4HJdL5NyGhTQKNk3iJp45IMGikelppnwzUHqcJW1IByXSxcksVrZ/gFcbOT0X5pYs2SHyEIkGNrhB/dIxf4ocvZsL5ypcsiJHVrcsYMef89Z4grYVUfvbYtziz5J2xXo+TNRauM7ijpwdsiEbcVBQ5N2q98C58G3+WM4osm5kibSstp9GtnYtCd66EqGNiHl9cQgVXIt+I2OjYE8j01lsRH1KjBDeXFhT6zTWsaJtmtjdZw1TCcyAG9C6+TRSVsjtWdTR49PEcxAiaKGHeZ3rRhbjD2mAQqhtGALRldf2gGPdZiZMs0akElFdE4dUMynYIY80QCr2jTlTroHpzvIGQ52fSowa/V1C4HYZK4cNLtGG4tJzkR+BSHiVnzwCB4LQpmrXqUL91tCwv8uDNcWT7HoWLODD08gvw8k1aGfDgEFDOAJbeXkhSpHi+0eG42/ObbJYDFQPM8I/vphOpST21H5a158pDfphU+boQzgXC1EVHh1TjVo6tZO6RoCgk0onKSHQeneiUIge/yIbl5jEF9E/Sp0kn0RsdKTr2hhUfHy7E8iJd7lljA2CotGLPsLJLrBAsuSfzVFIVCfviFyFPfTEAls7fTsPEvp+TsJRaNu5MbCaT7Mz9vwt9Fkl4Mfu4Coh6KJF0UwkfnExBhJC5rlynvfXGrX2fCKStCsOKUDRvux+lwkQYfDLGx5r68lNBRhDgf9/PcemHnXnB9SwRf18QARR7Seqv+PbsEEuC22I7epCzdvzPmVg9UqKm3+aWeFWop90h1x4cTJ8E3CieKOEL/njChQZtuLKxtNyF+jm61yRZGkvTR6Ny7v2RZRfnDMjTkSUHg/cb0S1n1g17LV6HLRfqssy03o3MDcZUAABAABJREFUsis41QUHZb0daHkzamobnKeuefBoDKqo/7+HTtkNJoxlBFTZdri2myYlVW9ywubWy+ERTvyGMbzmDQKmUeY9rbzmwNh+IsrQRBuGEPqaWER1bPhPXDMlbYvNNZzLMVgUbF15I3SdN8gfNtXqIbk5Ne/AI+PxeRaDqpUo2Xh4YGDZY1A8iok2F++XGv/ewLJ1sntMP9dpHt+q+dWcL1GFuoEms+lE8ZkObARjNhvavVRGB+XVRpaSO+FfvwrqYyfBo/BZHz2STSQYEj5fWumGYF8oEnkmZ+w0lXQTbSlUHh4ZOQNcDnmIt/f7dcW9QMYDkkVkDLrYfsLYIqIN/8W2y477UXVlDDTb9YfjN13AI5Ux0np/ohIDffzdi07gUJcGAjU+rHT5RnKBSaqE2BH703BwpzMWcqH1FJvcdd7AssWiGRuXj0v70otOqzo5pPff/OaMMfCy2NBqXdabNje/NQPKu75e6yohM3itIYbX6DklyPhu7/EaMmXPzXV0vhfVlLqud6eOwSKXQUDCOVTXF3hZB8KXVvqimN14xO6P+v26azgRdcf5ZgNnEbzXFBvRK8gY/mk54DsqmmNER2uidP5EpoHrF7LRuRCtMvUgObuGxXfuhZx9SmoX/ab4NFdx3SOhTtS1l27EBhpRNbbyadDE3ygwlv1mj4holRx4+u4MB2p3k22v3Yu+zrl6P4hqf+7QLXR+OhKY9a5lGO+QSTC0gG5dz4YvhE/whjbUg87ahLkH51vkBUVljZzRRqQ8wo3MQ6cgjQ8RKTBQ5RRkg+PkfIhoIxWEjXz6eK1GBRBxlYmowqcByKPdqJpzmtJ5Hz4zg87zxjC3kdNEVOfScdhw9GrgiLlXz51oP+35SmsozXd2017tmO0j+vJqd2E0yTGrq9DrZNWBoNyhUCddCDd2cxqKxV4uJwovE4XLmeg6qS+6PD+3Fn8uVNZcjS6UHWJsSZENROFJERGVd2/4GM+dITGwiGoo72g6oi6aBxMJHtFp9mjbxcgCcjaCUdAFVXO3O0K5B6D8MGXKt2OF9zPR8895FkfC2dNjIQqM7pw+ruzyWAqd3ouhjEgfiZDTnWlKZOUWSqp8qzRlyqdIw4erPrtGvzm5AEY5DSxOpG4ucLiKfGd3zeoyxH8KT/b6N9XJv7osqVHNzmOkJFB5EFI9UJnm/diNdAgUyLi6iI9vjAK8aztYHepgz9Vz7LybcyXRB2NoQTgSi+drKAW9yaKHXuFwTV4sfUUiUBvkVU5DwEQoJtJS2hE6aVkXP7kVIhoBy6fQRigu7YK4Cd23/+/QXkt6V0mIHorjXTA+0Xsp6nIsfvddim7ENMeZuz8LHbZjnne5ROuFv3/5UgyoqdByGyhdidYz0fCExYKEJ0jsbUKi9o+gTwQaHlr9L+XIxEjpcWL3+GMdh3yeaZcYiajj8rKLUmK3CYtMLryZLkQkdSPiLA95jDRI3ZBsngLR8obbCv6I+FCpHuXmXCP4ILZLRE1KIghUo9gNAdANcLzgRh+qMcBjtlOUB2muaV3mcOOhr8AzAz5T4DDQMs8U7u6oXK9KP7F6VuF8Ym6vjSjMhcJhHsVKgeF6ldawgssRkYgiUFpELb34dXe27lnpI2/ulOoSn2ehY6xU0qBGxPIlP+Pw3QuV09CMpUZjb8pNcE/lSNW1DHXVFD0iiKqGUm8ThXekRpo5RvjZuJ5mUphXjbSvXKkqeqsGFlx5lpbhaBphyaLDKBukRlMR7Sljfo+X+gqY6tVIllbMT+BHO+/O7qkSXPfhtprxXowNpCawmiRHAnBeDf6pTbz5qdLTLdkt6lYJWwQL5SiaRRcS+KhbQuJeycINwW4SkUxQlrYFu+vTNxONHzBxU/PZc79ZF569DnI5EdGWiGiLe7eb3Yg9tOt+k0+ATEcEdMyfqiT/OnVeJa6jP/pIuU+ULp+KqI/qoq/EuDWg0DavEblTQ7Fzj95u3o1VoBLzm05UUk+KQ2U2YHTtVw0EekVpTPh2lzfk6/g5Y693vkeae2KFGyHhVI+DgXW7HyW8ef5Oewwv2+9OH+XzAcaS3L6TQDp9MB4DV7DhbWRwXKlJcMWIHutmUcfFkSEgRRXfP3TSuPSORyS3pjM7SIWiLlPDi9IH+PQOY6PR9ZmJe5WqgvN7UXoQzRzrb0ozEaNLDarenIEx7w0js9nv1btYtXkiKs8IXDiYHwyC5gV6j1J4LV+I8egpBrY+R23rbQF1R3+if+kGvN3o9Obe9Y770yr0hsadh3ofeX7Gdl7qIf+7bneq8+JrAkF8eX2vXFZVZNfS27mXwoR1J39AVB9QidPqalrbf58qeGDd8YrxdRrNwGnhWYVSUUfwMEoh+uINq87G2LooiRpoPcxLfTYTpWWFVvX/8TLRgcaBaBw4CgTu0XM7EVUEKzSuOssrUkVpItWzwcIGBGh4KTS8FJeHynQgH9Zv+DTQ6ak7AjkEaVRMHsDgXIUBujRr0cEcnAvX+/ybiMEYNulI1NByhlJcCyeqXavwJvJn9bSdqsEWRA8oV76Nm1Q0GAADWVyIUDgnooY3V/lzeH+pOb/EWI3oHirmNh5h4dQXYV37kXhE7abFB6EILyMsJkDFIbww0vPIKVw0uAAlinGN79RtZDgesnNkdLJtY/+samA9uznEuGs2ULybyJrJt4seu/nIuwVTrItFJ6UW5g4QfvOY+H3LnBGWUiMmtT3lMrlwKpxc01WhpBf+R0R083V/Z5yumf89TpQexYgSV098nmvfQM46lUWYeF7G3Gl5sVCld4ZW8//6bDXdyiBcLyi8w8WUHq+UHq80fpxofP9CYS0UpywEeDIbtu37J6JmXqkPjrnHLMgbvgw/WzPn+POtcR1Dv3+YtiFrYNv2wDEdN2JZ84Hkj4zhFDfelc059t2fW/kCew81sCRfooINNsqRiCydRt2Z+J6oirWqaDGQ1A4wgJR2lqvW407af1TnUJ+7spwGPmZIde3D2ov7kOmjWBv12EBZgrnmL4VrfDvWjAsHFISmrkTk0+xVikhdy8O0NP+atczTJI6kROxhrzpKSjHsf3qFj1hDN2XwB0Sh8InNMbboi9q4I83LVouy8wiA908ieoaO8LTdXqqB8+ZOrmfu4aM1ekV30FQ/PXLSscw1RFz5aNXA0oIxfqDPpSkuxMDqkduHF4GH7waeMFMg1QmR+/U4Fx4yVXFQa/FjHHZRFRhW7rwjZV6VX6jt8Jo8UZrSYTISAEubZ+2wwDBIMGD3uXHZ7tBie7waWuftrrhyH4h3XWYSr0jaQR17vCufbuYAQdt8PXT6pboupTpzUYFXJJDOniRvi4HXgSZuyLMHO+UjqZPNLjJ05gN3zOEO3Or2jZy3Tw2sm30mxUarq9S2ub7lz+WyPe/0vt1oINvC0bi2UVI1KbYYrNM+koXCQpK5NRx8Si9T0ke+x+lXj0REdPkFfzZjQDcn2129amFdHcLd64N+k2ejtQeHUn3qGcmtT0frkhd99n3PFiXQm/nAo0xH64MFAvA3/kFcFIaWLaqXNbf3eukginvEejJ9RQCSXtLnDTDg3XZEh7IaamhperxZDWKv+N4tmHPvbtp7UkVkMT+vdlzucJ+72oxWaT5TNZ4ybcCC7iNq+ijTv16Twok+08gKiCa8TtsHtMl0bQfHC5jm6ltHBIj5XXfzmDjEolbrvUcYJCJ1G8KVEaP+6z7D4zPfa17aiaNT514IbzUAzW/2Vpb/stexFN6UyeHkdh44t7jj8eGhSykwpkLhY0siOn+o9Rwf5soF0hs5hAmLk+MZBaddhTo35EKirVCgJ/rj73llnpXr2JomJLD4Z0+nKTgUQY0/v/jF0CW7+3arKsGh+czOuKqpYaohWFKoCA5C+Y3qcDkNG6O7jKmeeyDm2CV29wws873vGxW5aTlMGpmmRpHc0qs1q/HSVg0BF0QkMhLt73HNnOD7Za7qzK6u4EbtIljogzu8iIZwbYt/vzG0CygWjBR5h30ZiSJRvj+5qGCqGxHdMW/7Yj6ZJOQYbg6BPX3k39VglbUDhhaCCzSAAm5szIeaoqbT10PguVkU0pv6XdvIre7iAD4lNkXPiF6UhfllUUOZrynIlri2k4T8RxiBWGxhVPtIXjdXKMcKfDhFlaQRx6FydJCQ2lZfuD8hG0QntGPZR6Kry9gFuVQj341ZIDyOpuJBhs3f+sxYp9hNGIahoaWE01hlg3wmFVwLhpYHIYBQQQkeY93xHmFwgceH9zc8CCqK95dLlVMiqn3/cmrnIlcKsrUAXXeeKWivlSHWMeuM6HIauR87Qd3s5kfdTLv1q4kAt9e1qZkiKaqq6J7qbvG1DnMc2uwUryjhEIkydfy9v/r3pDKtj/iQv2QhYCA2XqTU+kQxoQAe9cKkw7BVxrX3cK6A4CdtY/FDrp+IKL/h/4/v2aUYnlsyqfWZN7AyUZt6x8Pje8lTiepg9wlnU6Qek1NdMDZdCRGtkgLn+SdbTpbmRSOi03cyIb4AOpbd9OiMInMPJfxCfT3XzjW8F1QQ7888o6KD3uDCn8G43Qwqso7tpFtlAOTDuDxjB8LdIB3ODWcNmaioirTDDTgrdsculzELr4qnekK/Jobe7u4bVM4ZFJgIIWTaLCAaJNHpED5Kp1d2jPl8Hmi943c0CZcvmpQlfsLyBtQRd8EeD+7e8EH6ihcw7NXVEmBfwdPaJqk3KIWfIzpjFX0UIe350jF2O9VF2yA44OVLPm96g0neLKDSnm/+hOuzXIKOUxhlb/6IeaPJcJ/CjuBjb+OgRsNtRUUaOgZRRaBU0HgbBdcURXddmwD9NgmENXGwjKt8e1ajy0cIlg4SjO9wHd3k2Y2uosYm6gzP9IzExW5c9FCZzoYabRHmDtoKNMlHSA9JjajNpt5umLFmCZq1iZA3z1heqreleII5ikbaOzkhokqXuV4p3EsEvbtfxtpn3fmaf1DWXryrc434V4MEtKFeO+4gxxAD9+epJBGkUzDnYF6+1HedhRaD9SheF/Oe5XoaaOY8TKaOOn+Z9E2buvXckCYXs637P/4v/hOi7qq9rcIniyJZL1c1YGCk6aftiHtIkB3Q+uByrDewSqYuoRGTmCIplqPC4blq+WdnrJkJELyFbEiU5c0tW/FKaJTG9URJk7W9ERn1Pt+e0ByRRkTk8wEUS0Qe0YpTVoMHoptwEwKRALmWiGhQDR7WjwL3qWdgVeI2tRwUW/3npU50PhDCvCskRPa7jabAZtHUQVj8iJDQWptBVe9x/a1hQIXYADKDxSbW5uuY95FYENUbDiUGPQ4DHyhbvU40xm+7M+4ZVjpxRYN+IZ/f0A5g6oXemx0pQor3UE2/CUBfs2W5JIpwL8P20wSq0teWUtXXEX06tu/KPy8R7zRLCpSeJn62A9cWlN039Qc52G9oPFEWEgyG1N1cx41R1QgaE1EKLH8yRFpvBjOOqf00bYTP9RSJMmtiwViC4rty2GTKuPk603Jx6EgIlIdAN18vNWUP+rhDiK2br+veUl5bazzyNVlWAW15SHj3KIqogTd8KmxwBNHS+pwG3bDqMwoPtZkXOrxMIiJass4rPsciEVWer0+IPq+btGTFca66RqQxxMI0s1G7R+LGvYa0iRwMQAotmd278EwSaQU2ND2OORauQz2+M0fLefkqa+XVcbbsI14nKk8v3I7TzFG1aEcELfm0S6UY9EuMV2sIYh10mpiK9HeyNVgk2xvtuvm7DKpTqHO90/fqeodiJBoYWa+abXUd4wth0Ep0u03nZblnaO/efEQyz0Vpj1daT682srpulx2Carf0JtmjXEO+WJ0SH1mIv3s7vNntBrHzeLluDKz5t95uz7+RaAZY9NbVgGPMC9SCSc9HwBxNcE6g0/6/KmF0NIrAB4F0w/CCjhkaA2u3OAs/TJ133YuqUKK1fx/be3mOSZzXmpPRG1i9JtoDT6AyTtRFHPR0cKbkHutNhzPVMTrRtiuI4p2UKvV8ifg0/Lr6TC062C2Op9i4ph3k3y1+PHYnaHFbPdbraP472MsqWdC5hfQRbY8xbtriMC2Tv549Nu4vLBok4j9vtnyWDbmdSNFVoC+58/71WG9oER3sU2u5Igm0ZFbIMmXYSEMYWoe8Ef1if361hpbqXN0zp2W9bSUoesVrEjKNo9PvfB0dOuxFqokYxbKf3Wd6RWkMLdTFkbi70engWnlRUUtlwZzVW5c8OgrkyHg/YGh1aSne0OrxhlGMoaXGl0eqOqVIvTeG1sMjkfx/fv9h93w1tB6lc8JD1QE0YGg198e66Hht3XsZQ0s3AQg4cAhWcw8EFGENNd6X6MVRD4pqMvZ05byh5f+fyBiTnbbZC0wy5bPS6rBicG5gTviBwziqbkjj3oOPNqVGh8SjU2Uc+GWekaEbGchhkRY2Qta1ug29oFve8RfnwpatXcROI8WPz4wkXEZa70YKc6bli1savnuqk5BNibJjFAa3U97o8phon7BWfQ90MOZ1JLb+DZnWuqQK1fqj005f1klsetOiPHkIdP5ureH3ol0UlmwMt+oWQpqbeF0oj0kjinAe7huKIFQ+fNztpDfuYOz2hPSZB0ZwWJm9GFI1p8bp5VGsOkFEYWVjIMxZ07nEJWs6nxKEh4Nutta+kQcWVIXhFSfhu8zyXWjRJovcRAgYlm3C7DhnWm85FdJyO27zMkauhwYSgFdg9Wlc+ptGAM+W0iYoVdLvgaFVzrxLXO9GkxRaPrBmRfN9MROU7ig5vdKKSNTM7RAXHp/qWlYkaMc16LkrQIWxKx4ZeStjqryMy4m5fDcnoiVTuTkpH6eMiRHBGFVDJxhDnog0uCRfRgprpvmtGANj66IImbRP2TbaKKCrq9C4vE9EcWZNrJDrufNdpPGJ3/18E6kkRgmH5xYtLon1tkpKFPLC7h/r1lgDf84LldOoBpEaNpeKCsTJJFj2ZHXvioWBJamGVENMvQCkdai6QsxrTQ9XQvBGeJ7YVXidWXsJekXGVQdeaBl57IdSuGkHvl++4bRG8ZlT5cA95TMncP+jbZ83/1/Ay7S/TbNyvIioRtTZMWPmKipGcf008lqDNDDQXvTrjpyvhpMCA4m9LER8/2Eguj7VteVzuD7m+gXvLyU2wLBGi8ZWpU4I+jjIM3hUB7/hWOFNhpdpY5iXmzNfQzTHgkWEcuZ7IuAiRdHPW6uBhdQ43o1nivJiQ/UshDnTehk4DVw2Gn4uQwZrNy7cZzUV3NpmqkHfhE7aTuBE8XWM8XjDa8rr3YXKbzCneIsdaE8vjNRnF9ck02YS7KXY0ZqGes+e5oivGwq0tpQkK/WYat4l8FPwkpYvbuv5nkB5UCpaw1FtltipC3KH4IzF3vM4bHoZlWLodMTnr8RYAAXjEmh8qHkA7bP1rHHsCvTTaDVZA8vWo1zGdmdIZhI8gOZhREQIwTkDi+/R2eVbkDDLABLj2cs92DQhWtxOqYmQg/GFiEKDHuZTpBLrtXVB7Oy8suOUAeUBxMx1P5hEsQDK4lbSQXJm20YeAeoiQWY3T9Qa84UaCYajWQGaaWnKbIzKQleMgdVL+t2tf3CyCtbAIqpRZ1YuQ/WfgFYMxlXbuhSa7AkSSg53wnKgg2VT3pQUWsNT/hdcNltmocDkc71OvDLCPIoI6SwEd7TjcmPHaG6f7cag5x4JN7pX+c2F3Z5vTw3H8XCXbzdB1sD6VHHoVlgyh7tfZ+VFxWvrjmrnCDf/WYKz4+JZra9yGrm/3JyooQB0onjrzbCJjBUN9jy3DhKhHCqbvcG7H/E31jy7KPtr2zGseQ8dhcXkTtQIXfw9bp8RvK6aGo7J9OoWJqqGYUdby/L9wrzw3zl3n0Ndhy/TNqgEfbQnweHThEnWB0sm99HM7cXreetN4vk0cL5UbFCPsqIoyrSsbHdYRNTXsSeK7A1eqwD/SgOL6HOMrF7OPqs7YkniVgdDv3ed0/7uXWiw8Ml0IrvjGgZqhEn9QOmlN2iuL8iF7JBOv/hIRETXn/LsGG3YKXRXjorP3m5VarEbsgtfjO3k4NwTjDYVRgh7Ip9ENAuH4+nndbJfZXK/+XrVBQG7dEVbpHPiGZHPKdi/iZRvoVWE4aJuS+FBoH1EObo2QukOWCUaC3KXTyYfnCJHobYfUeO2QuQkEbE45moRpWPXnN/xIBxYDdgJ6J0YXWNUVAO7KGuc7eXtg9FYIl9Lc8GZOimKhXxai2s78GicZs/G6LIIIVHbz+y4wh5DNGeWW3BV+B+0c3xR3pXfqMdAcS6ykyRBkeQ3VMWG83vDz6AEe7t3y9XIl6Gm0rARmXZsuUhNfS8nBIWkjejucpuMS9cZ4oa32NO1IiJ6+B2hGmyZBkSFaL0Qnd9njSZEwAbchuf3fJ0EniPes+GNlSEamYL2GfMt5xqc351515/bhafyQt0zOs5fsF4AT7DvueQcITi8TNUF9YFlH8JHCSQCUTqzQWYjjO336noEIKKcL+bbZUnYXU6Dc08616dWUu6DBXFZDDIn7jGfcsrOYeifg3DZzqct5wsFf3taSox8L0UOMUjcpr/kjVHW6G2NLQ9KDSnIFA0DG1rjsM2CAvAC6eFsCpt50TG40biyybPl+3CdagADxtd5aOVEPJ/N8vEkirW7rvlcrfL3/HbkROwp6Ny6yDzm9RfD87zdpK9swIdl3W4kvNsZhqaTkmnyxJr7vkbX89XRhX/3r/xvthXzNzS5ytR6ttcHqgTY0SNXVjxRRdEM4Q7XwgvV8NyOMWUnxWXhY6RjB8vvIqL803dERPT436n5DG//hKN9EO1CObcwMr5zRSfDU4vq2IUcfKAuquQUyOGPxoJudUI+/G51F873fIO7X4AUKo/4yH8jXQdRRax0MluNUUliCLkIv2YBBh/jpYXZu3kXOzsUH8mFBR8DKBqtr5rjkDSPm/6mk7VzhZhid/YlBqJSjagk50HEFNErXBepm0Mexoe6K1wQiWYGtRdfxXkqnWCFUrHTtzukHeLtJg0Nnoeov5mQCTIbFxkKlN673DfUA/M92sgmh4ZmjUPHkFDcZgSICA/v8DrqQdWdTmTGDhmjAkEf2ICY+9Y67yMmQCmXO9m8LUXdfWpA2u6Fn5b22ZBI++nntT2ffgfjhigPRGkilWa4iPgokKxJxmkyckf3/0rEPx9rBHAZIsWXZbMxsIagarJJnYK2P1Lz1Nx12lazRal3jKhe+2KMm2gz8NxUG6uj4bSJxg5mYQaaDeoBdI4uJkLSuc814MYod0NywvYxfTac7yP1sAb0kKyc1XjRcsQfVr6YPEdKVJaFQoxbMjrmhyZqEs/i1gM5ppTSpM7ZLa6Ng839dyMaVGjbHvLmIqa7BgQQ1NsLqcsXaxZ0KHvJuV3QhkaK3p+ZQhNCjXY0cw02hdevuK9hbUBquGgSh6tL8KXaB2pge4PvSEjUeK+K2fjYulku1h/84T8k2mxDzaPv36kt3h/uK0NEWwOLjGHU85tPc6OGfQRvN3IORu+Edxvy4N2ElFth0+K+i989EBHR5dcITa2nK2TtXBKNgeWsY0RywU2YT9XdsbzZkkEVLTCdnaPb4obv5Q0NIqLpHf92+yvs/DhqKc7FELXFWIBIoDVIDtpfUSH8ZHahRXJVaZtgIehpPmGxhDr9OfFO/1wjs2oU5fb0TfTfIBGSKSgJW3eAujutx687iIR9RiyoQJ3WU1TuFxZXXMdraBHRBiWJayEKpNyB3jG7RdzNBXwPr+tjjtskL3cGli1KWNdIydD8I9oaWE2xHtjrKjxCJs9r9N4hhG9geiMGyr+5HbBNcQSQ5UCYtnikS5FR3hzBwCIySF6nwG1N4gbFs5UYqrH91OGPiN21yHo2PLE7MC6VDI8yveW/bRQwjHxswtR9nev4V1kRJ4GSnhaKS6bhw4suevFjJ7ePlCZxtKDmG+mMnkgqDKmhzof59sw8I6+r5KLQ+OGwIF/bz3mpciaPvMFVA0vcPU1+VPSVXmJ67xK6TvX/U7sx6BXdhDduPtNO9tpoR2MEKQkd3/XI0aiH8n1TXdf85qm3mfeq8MtCZZqo2Kh61K23CcM7kqjc5vls5ggiJdlTzjXTAN4RjBwbLLC7UVw5inNe1CDWPtqbT2WuffnZyfA+ecONnKtHRQ0s9PFQ9ew29kjHiN5Il9i6uaTaR+WziO9K1MaGxSZhBIrlBQM7+iGWfBfmpU33ANLdJJ3AS0LsGGK7iaKJ5Bz7d+Tk0ifmFZXTyIP97kTDA9ft5accSXL59TPly1CTKYv7aBN5BaQhRgorQ//BuLKIiEnRa6H1tlV3jzMLNwYsVEnImtkkJy7VGHj+qWgcvavXvnwrE5SQkuPCaT5O71u+VUmxTYSJ4neamhCY36kVKw0l86BYsiZ89qHjumMwpOJ8kcSe4GLdsMtwuTXvDpspRVCqcVLvRfodpUBpyizD8FJDypF0usnD6t4bjKk0L5o2hzJRzJmW08BtOAR2h611oWsWf9tWxnCFWyi+tO7ZEkPdDXnDMQQlXKOvoU0tHL8R7yTaGlhOfw3Gtrr3SmlgdTwjSiWKYoI073/hRO9F/l9djtZwVxi/EwXmFzgoPltpBdMmSFjMgS/Sf5Y691SR2Hqu8hxz0fNR7/UcZTxVBMq2a8gYh0TpZWVu1Sr9KdaUVxm0U9N9w8ptOUgWr/FREOgTG1qz6GidvylUIivEnz7YhnfzG/YLaDMT2l5OkcJSupFWmr5IQ/CdcRCCkWuw722VdjYGDpHh+8GoN5srPH8IPJdiLkTQhjcSLFfGFiyCIVAUVKSMg77nMM18ffRd349s26leklBPrHEUzFgB/QTPhnoNqWvccJ1lHbJtmpIaV80zan1cXWMgiq1HRYtfT1f7k0FrYWitmVEwdTO6IJi9CDglc+N9LIrCQQZJ3apwBQ+JZZbOJwoPz1RuLxSus7xnN8bhYbJ9Db+FIBH+J+1PuqmQzzCvFXleiwIHJRKdvrOopXczmnsBHR14rVFbA65QyxHHmrWXa1jWZjxTOY+7dB5bfhiS1eNjEfVl/jtWoRLq1OJ+dXXkAo571TPAbFSIOTYYVyXuD4VjW6avJHmmyS5uP5t6W9+zQ6DU/XSwg27O9XwiWSSff2uLhJ2/5XtBugEh+cNTrpySo2Sdm0XvAG6xx+I4fKrA4/b8KqGA3XqtT8AmCP234/aLVhCVyJCsq7FwRIKMaiTIY3SeUYnHJmBAUQ181ZPZ0AvgeaRuU95uOo7IxVjsHfE75LzViLJlbI0TGCs9mQogcm0eQPeJPw8Smze/YcOKSX4fJNjubg23pbrEOrtaGGIOrbLClCjZIVlE1c2uOlavKGrom/6YnXaaLejHl9/w5/iA59leG+795n5LNU6I6sYodkLP8YyNuwSuwT0RS1t6OS0PEKxayfbdAJlev6pUi0+mMiKqczakODpBT16NnaiiW4fJ5vdce4YUvuEK++OIajtkZ3DaOvUQMb1HbD+PSq/9rfajr6KXKcHYG6p760gCoiaONgYWGdTKFis0Le7P8ii7iO8+8HWQG7hXem3k3k1Ps3F5I31Dfjp/zfdOL1llcg6DO3BfbPy9bAlRP6rT9a3dzC30iXVVymdZNUVkEg5dh7pLOADJer5eI7MfRGKBlqXvAiTaGFiNWBySdHrYdS81D1VD6/ybZ3HTmckVfd2EnhLtGFo518VOJkIYWFVOgd1PWVKyrKfY1b/yRgMW/7gSPf2c3WwwsE4fxUAIWyPAGlphzroLtEmSN+0hef9KCBujx6bm0Tra1Bg4LsUqpdB5HqK66HtDqyTetVgZAUW5jIGl97KGlqRRyQgVH9rFH595DJz+pTPA03VVhE1lMaB/JMena2aExAh1NgaWlOh3O5EklNkiSfL/PkLQLubW0ELE2Y6BpQZbDNUN5XMOCgJln3GT3BkIVYOayUeT1sedP3IEUDmPm5QwG+Vt2RXaolGHMWzcf3oMvpfw8DzGjauypKDIMVLX+LRMiI60v8HAapBo9FXpj6fHQvObQMNTrduJ1xw1sLTPrqQoFsp8H+juVyvlU6ThpY3wq/WRxdAEpnQNrBfntrGGiUex9O99I1oLIutiqP1PE9y38+D65d3mcl0dNG/omEhJGBs9A8sHSOm8MMS6EXEcrs29bbHq8EJu3yB4KJ/KUwc5I29gWb6wJG5vSO7+GffeTYx1jfM0naPArFwoXJg/pXws7xbunNONgsyCxqtB5gyuea4IWAitJIJ7FvupHKrC9JZ8ikprmCXZOjZH44dO7kWR/mD0P3OKJTfXaD8UXbliaRao47I2dggRbcV9Q2jUAl5TXk18/zt/4z+q0Nhc4WmNTnhNp8QgsQS7lHgyPbF2j+5QQKIzZEqN/FjXCo/mwhCmH0Q2TNTVRX3uGNxD4nqMg2b8vooGVUmBhmfmngwP7QvW5JsNKbgaNGWMlG8GyinyBF94oYZBgWdNz/V8JUbbBWgI9PLViUoievx50g4DkcOb3xgyNNZYMUCUqL2WGlno3QsChaL9kVuP27Gzi8JXpVS18rWwsRLbPHEWFVLOzgmoREUFNHdeJo1a47Y1u4pCrZtLDYSiz+jrqAtzCrSOPIBDFsMIpGZEMVnkQxbmPARabiLnhSxEw/Oq91R+1rk+b3qBm1M+hQQeChFkGfTZHEKhHACZNIhII6zU7WZ1rzSqkfVmELGJXd78ZtxEhRIZY6uHXKHbQbR0wo53u9PbpF/CveZcn98T3zG5WQI1NiP3ovXUSUC9niJzDMdAw8uqWmfLbVIDpUdcR19pEORA4v7F/duGiFOuzy/XBhI7fcFte30TNZoX/KrxoRAFouGZd9955M3Dcmc01+Sxv/hndcyOH2o/SNdMcV4pXNeazNe4fvKdQbIXb4At+smSGmvtL97AIqouKb8G9ASTrWt5HIhSpHypybRLipqyC+nJtO5ExsCKlf8DaYUhVZcTGXSFqIrN2qAcqvNAmOa6wYWb0gZZiIaT1h9rF/qfj4jGdVKkxiWI9vLuU1usLEDOrdsNt8A7MuCABxJ8+h7Wp3T3hbvUoFVqfMFbY8YY3VzaZ0TmFYxlW08YiNms6Tvuz1LKJpBMUTUrPeFFS0F8f8dySXmIuhnE+F/PUSKXiYanlcaPE0cID1E3QY33CfJADy+1zhJ9XM4j86hcX9djqc5jinwZ7TmOnjYbRbyiSPRP/l+/T7SZTc099n7oFUVuxoE2OwWE80NUsPe73jXoi9BGF5hSEQnAxx5G9mGuari5jukGAbhhYWS9lU1WcblufJioxECn99PGWl3ux6p7VIqS36yVCyOFiDQfHnbQitJAH1Csc0Q5KTLgggXU0ID9FZlbtDr00yM86Tkr74iIF4ow51pfA1Fruyv52RjCzU3aHWYNKcfA7BvtMEiwQ+EBVPktFUmpzxjnNi0PCktjkNY3O6SsMQIhREt18Oo9jFRDU1waHSTe9sMozewOVMV0fU/V2AAqaksBt8gqkntoP4oILHbpbjyVkTcWOA9GwOrI7hY9tZ/Fdf9KCEV9pG+eRJum00bKXXIoFt+H66+6VudTfQYz+efTUBdO6f85te8FRiHGi2YIkO8X06e47dyzW5kQIrI6aDyWuU+U2CKQMLAocF9cblMT+UokxPa5IlfDszyXTFtoZ0VRwZdGdobHdvFS7t7Z9QeZb2riaGjaTRSEUNyE4aNggS5lE6CjBYvtkQusoQm0fQEbCfS9FTqDTtNr45pxqJGmV8JcBCX72xPlm7ExsJqyZjYact5GsVpOIBArotYgItrKFXgKDIqXIOqlcaKK9jT5cpG2pxQmqtvnyIW9RId0AmNgEW1cncUZXVoHuGRR1w7a2Vyv5L6BJXXc6HihAO1aFjb4nD5XQaJvI97qOU3rObJ359x6OLBJwoZ4jwajqJgzSpUEH4L+C/NaEfTmXWS2P5a8CR4Cws6AAr2qfJaRRUSGkyQGxpEYnC0W6TIvKvR8wCCr+fDf7DolUW2cnv/ZGlZE27Bce22dCIJaxyDXaah3p2z0a4aqFxV6KIAUJIhVHSvdeW/vcf2K6/3wF+sz4vybr8U4VDdVZ4LEfLJkKueqsttEdr6mOKI3EdXB0rutWwS9VIMtimRhXculKq1bEv5eUYIwLtiiLUTUjczUPHRY1Jxha+s0PAExMAvxM9BBRxTvFV0kiI2nUggRduq2PXodsZ1YGpFT3LbDH0D/3eqGHdzLFDVugDAdcvakGnh/pRjh0P25Qgn6MKxUQqNWsv4Gg7021gzk0XHOeqiYFa+tYrsVhSSqOli9MkNAFN6up6JCwDCiYkexAgbX+TugZOAAbuvopRdKShW5kt/iw/NuHas2lLhAlpU0yuqIe+XdRD3DS7m0cqx1qQKNeMshlhCr7FFMlJNr1wYT9cbn7XdSRDpaBM/XsWtY6jgyngzzfXsTeTYLEvi17yhlGsADZEpBFGfOu4mniWgfNLDjW9/Vuj3Hp55TEvzBvXpBKr3gCF98/uAQ2MCzhPfOvFQu7XxQZYosWs+f568lVZDNl2o22kRm7u1FY+JdwcgSMCS8TP1NhSuaE9HyTl+5dr46ulBRgkU4R0tmrZN5rZOnVw4uxUGopUVGBJbd7L7gW7cvRtGdnQezUSI26vF80jQ6nF6nhSv5mgIDI4luCpSeZlruT3T6ONN8P1R3AwAesajjtKh7pyT7AuESa3fhK6LtMqMKEdFZxJ0lkImWymVjYK2C+sbZRBTO5nkpVJeVMQasEaTRWZFIxQsz6WR5JDOgLkXT2UoMggrgWWvb6qQrEV2eeKzSBmrAEZWVDYi4ykItiEmgoi5BRSZw/hBrehybiiYTUawDUQ2taBcGdkVxougibVGPtcTnqO5c0nqn55XWc1TXWn24bUM27wFq9Xh33tBW7oVxkZjoubBW/l8wicYRkZNPnRfp5pOaUkZuZVIaWSI/no9RoW2qH2tcel4TEdU0NxeOsM1OpiAsufKpoMN1ihJ9mrRu+SSRqTAcscAX7ndpyrSeE6c4OktEUSdYoUT5204DhdseBpaig2LUXd/Vg5cbPv70oVAZiNILUbLXDUTXL/m+8xu+8fmbQONHQbxeHFqNP3tGuhjhRVJ5lJRqSrBnp01llatfrjUFGRZ4n27FL7AhcETiKOl8kG4EHgoinctDLButt/VupHxKlF4Wyrec9ihLFFZFoqy2UY261bkAopku8XDEeVYP6zoJ6uvcoVhv7Hed7CLFRxEqKo5xVevRpAYCfwzaiTrfuPYk2hoo4k7U42OsizeWTjooaiTn9jpwjRJ1eVobbp79LQS+pzXAvaGmt98xzuF+TsHIYMTaXijGGLX6d+spqndhEi7W7S+3Iqf5FCk9eapFoDC7+hPxoNw+AD/zi0G3UNSoxlom/UAi/RuO4ad4elI+H8nyEWVH1pz9TTuDn+W3LwwKwYpyocOnWF+8fHZ3AY5QqZ+fUm535w8PEDzbb8xs9TKwQ9LweaBc2/sqguXdQGZXCwOrVy7ftMgJeGHgDPVKw5VynekYQQHatq2zRnL10sw4t4+mzencK3bQvopg8d89RFDPv7YQOEsVxKa+sbOAabQd3pGcH49ge1Mw6KprSS7zqb6mocWtq/NoPG3kCcz7hKvGakHVSuIC7fPn3jvr9VV11wmC1AkUQNnkYwyBvH5aT78LBmKN6OHvG3kPlIOm1WTp0g4bsr95HitTAgMZ/dBGv/oy3znDtAPGP/9Wb8zz5/k90CksrAfuOTPWwMtTHamXA4FXoCT4nIwbRSUUtlGLBUYPRDRxXs/j0CkQQtU+igTAHUTKRwGyNqBzMR4MwxoZt4+W9IpGmcVPr2E+iwRRB5UDSPCKNgpCPg+nU+VO9YK7VHvQzedHqIs91vOkXlM8gPGaqEgyRtdnJIYnokqRcArv1zc9TqDcwrjRlb8M23do+1NTPH2oo692qNPp6E2v1jukz9HJKkVRgXYCMH5ucLGGXLN6+/QC2FmZUFMlLIZVrxFepkqSRDSDvkzolDABXu+xLOp+OYwuUbTJGWE2HYUgNsP7K60/vaF4ZTmE5S41ZOz4vDAxDi8cFrBzfxSzU1F+TAqU1qITSR6C7qLntwNRIfrmrwnR9qd8z7s/rs81PNfJOqzFJLgtVQUd/b5JPo3zYoU9Td6qsPIOrVDdYdpoM3Y11iAG1aVSBKY2tRW95HsSgQMTVmoQIdVpUqOAO3Ogioqoxldsox5LIOUIQW+KIwv7E4UaE0XaTxCcoO0TKM2V0xYW4YvoLesYAHIW5jZSMQsSkwujeCCDs75XNDv3DnJLVA1f2y+biERjLJRSiaMHRpAmVEW7B0FUI/pfoTwIohXcO5G2ArJIVN+LlaYI5jnDWhFTfVYi486rSFw9n3fDNSUUjxVoecWF66J9DuPnHChOheZ75k7Nd5HStdB6aVHk4YWRsDjxcwC9w7PM9wOlKdP8BlGZgkjd1z4D92BcuS+rllrkthoe+bvn3y5Ehej0Hvdu30eJPCcowtpbROealkg3noLg2CAkImpFl1fmDLLrJlJZVl3Qy5opDKnydogqKgy9pGnmY+aZ52+45TCWS9WuitOsLkKLTrN2GUdPFycpEq4TlXGoBH3vmsOG57owJ2tMFB6eWxkUrEF+/FgVdYPAFc+paq5D20j0ddXk60Ui38OybvlN14nUTbZTNEXczYVoXpj83kipRCJa6zrXc9916mjfh65lpVSVdx/N6+Z7CqFNL2Tvp1H8xMAGaD7BJL/ulFIK18sbi4psJUVniQxdQ8r0NtDN17kBKCDpsJ4jpSd5HruWLbkir4KGFpv30wZ6HRWp43p7qjaNOb96ggwieXS5Tx6Bkt2nlGYR04V0e1mN8LNq6y6P0sb/r+GUJjR2e+H6/74z2ezrhvBGRH3NDH/pwIlIT+8nXbiaaDciJbeXc6pEdxclYUUe7eJOVCfwPEaKK8sNzJJ89tu/um8DX7+sxhsr4bKBFpaOgWWex4Y983fyozVClYhcJ0u9hk9a7FAuW6Ix+mBc8Rdtm+CYTUFTddAh71ap8gzcFqHQxsDqokvYIcHwPadKfHdK8F39H02fI20OF1kxz4S9gSHmcw7GsBkzr9khBVk8Q6lit2pgdZCo4OZ9K/TqCfHKFdTIT2qMd9T/NaUXicPX7MwPMB4R1accN4Noos+ogQgkgg0sosrTQuj3fLe9F/IGqiTHIEbqEJQDttzsT43axvjItNkggEty8wv+YnpX6O5fte0II7KnrF+8/hdI3aVUxORggtcFUNObVeRfRSw3vJ9Q51M1uATZ6qR10VyF8hk/PBNlovi8NIY2EfUVvSV6qyEfwy2pXFtpI6QKur/ZPizGdQ999kEzMOhs6pcOaqjFqdaXIVU6h82JSJ32JKoUms0GKmw9K8hcYrlMfo080L4KBrUKpxNfQxFB5yq0Ucqqmeb4V3Ztxf9jvvdE8XXtSCUdbPbmVeR2iELONHy80vyO23qRuInnn5gNq8xvL19B7xJzgqHXTG7DgfsvKxvpJmob6Gd3TpdnTEipV4qZy90c+Ape1me7C4OP1jATfRmHSiYUIyb4DOKWqG5IaM1vjSUdNgOlGQxHYnIygGAYoH7FRbto/b3rBqjUEJUE7/O2lRBovQzbBdy4rdZzNW5UWgD9cYJ7ivlHyyXxooSNBebKW/7i5Sf8992/5veQXlYikZcIK4d/e1FDFTfsQaQkE2HH2K2uQPmUiIqSXLTZ5tn5wybeZdkEXozsor8xlvaiE89RFHsN6Rt1b/4WpMUhXXr9PQPBzhlDdFGZMDprO8Y5kydOxCVLiplMFGpfUT6j5SrKuCkpdI1IvmDr7ixmwwAds0rcbo1/jWqDJ8WifqJBtp5r5KMa+07FPAg/jvOLmboFQRV1zMrX2d4ntpuy3B5zRGpeL5HSNVMeQ6NrZp9Nj5UIyOUcFa2yxy8ItAjOgIxE64URsvXCKDUMr8rD4jo+/nai9RQaF+v4UCjOhU4fs6bHgV7d5Ru8Fz72/HWgp58HGp6zoK71OfmZsNkSdAILhiWHh9CmL9lRUm8Qf/6C/+WVF0ufnFivV2iTwNgUVTRX12O7YBERxYdnRvgFcVZ5jnM7bquQsZlHOsRx8GbUnSxpeBCa310bSumqyeNTZYcQEIDnwzwHo68naqpof94iJCpeajb5R4KguKRVbidiV603rrwMEQwLL0o6DETDwAbfaazneSMPfUU3QjuBAkpml7bxQreIXI2xoniuX2l7NvJGqRriA+vcXX7B0h+aLUEidnMKtFySGlgnp5WFtGWQN9H3CLT89sybN8Np9UhmccEL+WZU3miAzElp51Ai6qZ18uXVOll/+9/9/Y0wHv/hFgAp4A0c+qntOQLJbn6zL13zNMnE4weB7dDG0Nr4+WNrTPVcShtfvFxuenfiRTTWxdEuYEg6DN7Kcte6HKy7BxPtIHnQ0pSVQ/L+L3NdP/wV6Yg3/Mw/+3/WFebuF9wep+8QZSMDZ0yamkXflbW4sRDDhel30jZa6G5sjxV9qLgY96MzZppEy5fWUFAdtA6/6kjgDWR+m3zYXq+5joF1cd1qHLeLGtHW0NOoL8xfL7W/g3PSFDWG+E/lo6hopFmEMLHYZ3WGZXXxHiAVCDIQ9BTRdTbiTnluZYtGoV+CYLqavVCUJkZ+PhgOVNiooGCQO0TQWlVoEyTjfyOqC6Z9Dg0CKEXbD+46oFGWnO/LalEpIkpzofXE7s9eFCWMJc/Twzu3iCByEVrX9t0vV1pPgc7ftbwQnLeY99DoaEndiIiGR26X4WU1gTSmrzzKuL46XhQWs958h8Uzi2snO2PDHms5N3vq4uibFiXp7f5xTdFjgjCpZh2w8x4iocWAik9TXXTVYNn2fSyi6ZsH98PW2Nt1BxLV8er03Zr0bjDqlC/UGqbBGmi9KMG8Nsd3ta/0ZgZ4WNfDcd+NkE+t4RDOoi1mjVYrKorbqlG0Y1jZDZMl22P9cCid1k3QP3VXEqnemQYcCC9T16whal7f93+5asHdfMu/z8LNBChx/0diiRkjJz610aYlBqLTSPk8VrHs5xZ9bfo7+oW8+1X6W2+N0TVjyfRP/unvE9E+U/TVSJZcSO7gDKCcGeGKfMUwLzXisKcO769jrXGvBuyjNohY1X1I9Rjvw+7dwxtYoznfu2waMc22iZD9m6guhhti8Jl97Zybj5rdeG+BQJll4Xv4i4nSVNTA4hP5vOefc13P72WCfphrVBY2HRCwNIu7GlvO8lbXolF/75ICpVhXqPrREVXpDG27UAVArmahItoaOPyjOybz/eK0bgyxPloFQ870mcyuWF1UPfJiXD81zx/V59srxkUdJHo2QqAVj9ORoPAI1KuKut2iukPx/pQb1ZsQ4OaTz/XCEXrLpSY89hpuKGkq6kJUPbCDOlsyM2t5Bd25viYFRd34MOoDnhhRRdlWF0CxXFjMtjGM4D7sRFhCoyqPfG4e+N9yCdVYAy2oM0O+/Zc8id/8WoyEOWtwzCDCwshHiPY9feRE2mniMcDJ29Ho23t4JEuj7Sznx4fHH22Yu+R6t/CuMMzkH9TJiYjmfZJ9sQjt0zNTGESQFAKlWo2hzpXLmzPl00CL6GplkOQ7bjuNon2pOVjVQ+ElFHpG4M64sMirT++mkb+iXB6m+TBCT4tDdIpoeDXn9dasjuAwH1rUyFGVdY9aEilypsbTAcDRvDO4iS3K2RxrjElNGi39QYXFTZ0hWwEhcZMvkJX5Y0WxMCd0mnOQcY8NyzoGmu4inb5baHrXGpu6viGgKLZrDxFtxJ/bm9U+xHlBBxYFxpiw9zLzX2MX7ZTPchc2mkp4SV5+wR5vDS2/CHcSR+/+1pNd2NzMdNpS2kHgjKmm7BhaRGbH7U4bTPgoXiZ4VNcv9rWAGkOrMPLBYelBJ9zH3+pE4dzx/YZv+B4wtCxvRA0qPDYMjGyMLulkwfOHbB2NoZXHRGFi8ncjSHkUOeeNoJ5RifFtDC0bim8/N4m4OyWsZmFwpZtjzh3mEz43xxpDK72I9gvcuQ7B6tZNiZkdJHPHWNm4b5sLdurYMbRYumCLYB0VID6QCZlNZJ/XGNPk0EYF2cP0vdKgWMb9zOcDgeycj+Gt7rwWueo+D/ZnKeg/GFh4xl5ZbtprpivR+EA0PhK9+RMeS5p43YwhGKEnUXA/v+dj736xH/GrvLBTIpahSH0Da6/4jWWsgUAbFMtrCxK1HNmdoov2PBHllco8K7erWaxdiR+Z5Q/UEy74+X678a6iukPzN1HHwOrxaf2GfS8Aiui4PV/h2akpW0JFsWCs7LjMmu+O9K1QjiIevYHVM4ysoYXxOc9ssB28s717keHkeQNL3Zy2DwEl9QmZbXEeh3hdaX4z0O1v1o2B1V0HsMahqbzAOZFyGyP4VSlUFAuo3JHOGarqN8WlvMpVSPQ50YWmsGaRKUIwD/NKJSXWwplXopXZ/Zr6IEaeOKCnYc8nagcFokUsEgUtKzzkONT0AETcaX0GcmRUR8SBEkKzTPASOTIm3hVhgWhylg2NeySsmcbvrhQK0ctPL5VfcSMIwU2kPPIOvDGErN4SyNTBLPqw9xaiD3+FKF0D5VPh9WXi65y+K3R+z66Qu19cRTx1ZgRxcYPH9oEli0q3vCvh9HC9nPu3FCoxUnxZaL1n92gZAgVJxpzHygXKKbLcQaz3g9EUl8Luz0yqV1TlGMQwEC4aIrxKkO9Sy6mKE0fu2cXecpyUSK6JoAVVmpkD08tPSCQGQam7ZyzaYSE2IJZCeYiUnhfKJ87Hp8hdp4C7FOeanLuJQFxyY5RVJXDwyEy/95MgHsFFTRZpv/WSKF6rwVoRLDlu4MjL5SZKvj5z6Zk4TUwhosBGyOVb5m0Nz5nV0FdJRVRM3zXEU74H82RqOqNYx6Phb0GbTblIUmdOK8NttV4YsQMqpS7fU6AkKXY02jAQ0VooLoWWc6hRf/J+iYxhhWrIVDLLc1sphuFFrp+l/QLR+cNKJRGNQKmmldv+um5TDMk9Lt+wzt5JDK7lLkoUIiN1rHJeUdAwr5QvIwsiR9EQDIHnw17OV6I674WgatsF/QgUizULoZpkDjV9y3K0/NyMAo1DayAYr0NZGEUJw8CeDKiMA7myGnqlap+FM6e6Gh8S5SSZNoZI4Zn1wMK8ULiyXtd6dyKKgdKHF57L18xeFJuDkKgaKDG2xg76IdrTIYAbsVzh4Wyuj/Yw2lTa5sNANE/8/9DAsudatxuRRuF515tu4CwPqBSOSDTrW5PHUPiom01wJ4J0w8vDeeZ8NeZsn0JdciHuTEQhJSoz5xkuk2isvbxQvLslenrmv2Mgzbma80ZpHbIu6Xml6YuB4lwoLkQvX2Bcsejv8MJjPE4r5ZuhSvcM8q4R8SeRm+E6a1uGZ5GGMimFCmwD1WSrc6+mQNN1srNJeUX5LCTrn/zT3ze5+YzBoiiQswSxsz2NtQOrsFsHXfILl30YRJ74Yt2R3tUoVqpGlDR5qORQdG6kq+hMMJYwrmRyTKK/4d3a8JTp+ctITz9NlXDrIpQ+lVTyWSIGP/wV/juf+CbxQTSQ3nIdr+8C3fyG3YTp8XX6NUTEBsgqFniRBNE7Oiwhi1FzBfplDB6TmFn1pNBExtAiYp6Zj0rz7sieaGrEwlNKFQV1QqJeZ6dFQx2iZu9hov4Qfr8pSlqXhf0GAp9JjUFfZyKDnmDRNQipf25rYLX1KvsD2RlY9tmSJhkuKm9gDSy+pywo5hKq9XUlDUxIL6xsDvcX3KwNyhSCJuS2iZx9fZtPnLpklZKwBhbXTf4WbtxwLQ1ZnUjkGOT9YXOCjQt2wbr7DRyxpEKhvdIZmnHmST1NhcbHTDmFxsAiqm0fZo7sjVMmKvwuoOPTzR7w3D4r+lQ+Jc04oe4rIB1WxBEuJDtnSq42XQx9WpOei8rzb3q6hZbYjX8hyic2pbJIyT3DdSIaEqUPL1RSpHRdN/pkRIZqId/BDaTpmGwIvjcerHCoj5o78lr4Pikk+mAW20bnzRe7jpi2DClWt6p3D26iC2vC5y4vuicY6tY3n6uwGnAin2DmkQb1Ogp8kE8Q3Isx0pu6fEIHMAwDFYjayvMSUZUBuc6N0RvnVTX+dA41S/v41LYR8rSCf9zU32eIybne16cUGlJrYNlncIFKzby8lle5Cok+08giopbz4fRMwrryor2W6lq0yrlEtbOFsI3e2JmQuabmevgnUQ3kDTh7D2ia+HQRPYQWE6e/PdxDRFVQ0UQeEjHv6u5XK5Whhp4iVBw7caJ2cbN/X99EigvRx79cJ+J4hQXNf7/5Z7XXgeCcjeK3Rz/UFw0XoOFdIdqieUaiZjKofK1qBMSV8wl6wrAPceUFvrSpS3QQbAeoF1Ul2eGnKW8EKlWrxZMxexOieUbNe6VuKa5niYzOlVQNrrqoo2+SCn4qbwg/BXMcnse0Az9fbgwSos6gtkaYfx/YgSOnIbXGYntvMZbsHHqw+VJEMxOlqRLfh5eiLkOkRqrZ7INyMDfuvR2Ur3nGQMqxq+HQ8uHyky3nsOEyVskO+xz8ubrsCtO9RAUWM/7QzTpY/vhY9PmJiNK1UMhE52+NUjm6shFfDfPK/V2iT7EpsDxOXwYkEM+MxsYl0yoE4OI3ogg7t+iGUxhvZASw+G4UxwPt8W8Oi6L8He4TxqRR+g7PVypDpPTxhZG7R3GxLv1+S0SN6zjfi8GlKLPMebeOj2N1tjBXKD+rs4OySJfe2KAa8jcR9eUyUmz4SQoyGKM2+PtuAgpya7zaTwhbx6jXCcH1heZaOM8Y4Z8SU25I+q0hZhGsvVLwvtGXYtXN0roepNEqyK4i//IpVRqOnA8tujRz8Mr9H1/p8puJ0tNM6UkI7K/htCKvZScyt8lpaD9N2XiIiD7Lcvpsd2EJgYIOhFQ3gHhBPSLbkLgDw5qE1n3OVXDU+kOtsWAHQjLnqVtLxDJvL+yW3OiCMNyrux1Ahzkr8qZ6UGPN7r0GQ+oWVxh2pJzSpCjxG5PH9MVIN19nev5JpI9/iX9LIj6IRfv0uEVOpvugKT3CGqikoovB8MDnje8Hmu+I3vwLwwFZMpVTJBLNkTDzTrYaKrnqg5oJQVN0WC4U2p2qEcG8I7i6RFoiGuQjF7dLt5Y/LxJpzhqNCNFMbn85CYvlWihSdckSGSNxNrt+b2ARVYiY0NZxk/qHiGiRFD0xF1qcrpSmN7KLtircEwEV0vQfUhdOhJyFiFsXCRglRERD5pQiYco1LREEXPUZW9SjGHFGD1ujvZpPZ9Q1KWVKIaJQtbCQSse04fDCLmgsgOx+JRoRASeZBEoIFEshWjiQQNMWqTFapI+1hqBGEaWoEZrr3YnSy6rGEQyW9ZZT76R1pfUSaHwuNN9EE/lHlGZ2GwK14mtzapBQiBZwt041IonbC+8W4632j2RA4fGJx+Dwwu8MHCwQuRv0VQylck5tyqEQODBlrBIwy5txe7649iDImz7wpLGnaN64bmKgkjOLhXqOjkVZghOP9FINR1IDSsPI4u4pbbASmYWVSFxObOiE54ny/Q2lh4nWu5Hb45QooZ/DhtGEwIWuX53ZbYhrDiyMTClQTomGl4WTZU/s9injoImhixHjLHBVx3aZ4/FrNvh+gyaCo0TSrx0hnt1LQ3XFWg0xSB2UZTMv1fYx7z6EavjbIC+DTm0MNl8aY3dlY6vwwNxEEBrDuso31Hm7cKXqeV39wkhEa0Wz0AcQXWj7hLRNAFp0cxYU2zwTZD5uBpHAqXMZNnyXb+pmpqTIidTF06H0CL95z6XaHBbV0t9FrHReRO6CWHQ1CFXFoKOVXvMKo86Vz0ay/sk//f2+Ne38lnXSP4AVbXJmq/hrf+sUn9CzGLfkXmnCyMEhW9pO5jOCtzfF4ie7qsu24yNZ8PhY6OY3mfJINL8BDM6fIN72ysPvYnLmj/HD9tjrWyEJSkeM13WTTsDqKe09R/CDvydjodo2nXfh/dMd9FFz2HmD4Cg9Tg/NKZ3ffF1d3sSNK5HqDno17w6LrqZfwTw3btvOu5KrfljauL97O6yKgLU72F6/2x0/Vj/ngBsAFEVdVgcb21FcV5BsiCsfH5caWbh2+ru+R3ftI5I9XGElBYovc+t2hfH+st1B+/pbg8sXjDHVorvWf5i0j2Y+GJaIahw/ioF17cwPhnzrKQdwtWPX3S0eET7amauEzbIxpLpCmCjYbOi8cPDwGDeKSAVDXv7M9GRE3XncG6oWpcSCOb8Vde93+xEKSoj3qvf+/+m4T+qc2OG8aeqiI56TqsP33CPu+V+T7+41AV694oIYegKyehmbZsleN+eWp7VTFGGTPhGO0veY9Si8TLzhVGkhVKhzGuYDvIIZEbsdV6p3784Lc+WMwXwcQOJ+U5Cmf/hrXYVE35P4TkR1QTfIkFcKb3YJIVS/fTQ7Bxg4a9a0BSUJOjAOTQ4628E0HYN1NcaoO5kwzfyb76+op/jfw7RowmsaYs10D60jc6pN3Mv+4Mik7TmrUnTIvAuebwOd3hea3gV6+Vmg8SMbXKcPhSZJz4EcaE9/QdwTT6Tb6rigcwVKE1Eeic7fSqebCy23kYbHRdtKJ2s/SfdcBZKYuynynsrAxm4jNirIlDy83iNMmREekLoBO6NjCgII9EvV6fHz6gQ15f1Gg1ypwv7CkLQfYIrEZdFXEi4S3hMCC6xoaZwzrcaoBAkcz8CE52pgDHbNR1qZFDdtu94MfO1b3u1rzkYYxDkrAlaDHJzB1FkoNq5YoqqYrK5UjBEcwEZ/GUKVC3DrRDJerOFF5BImS5xHu9B+wfjGu8btYWjIgmrVmDlApp160vNMNUAgKaoVJ1nAzqJ9NQZ1I6DALW/rmQd+78OzSRCN306k0ipEREncgogGJGLDar0kGj+ukjTa81fMw3baR92IQryN8vz6PKYAqcQionNqZ5PUuIGsoZXSlttj0SpoMKkad2j7byMKasSacc2d+aIqp9sNspmTiSg+XSnfnit/NAWK00rrzUjD40L5nGh8WDTfJJDF+d2Jxo8zrbeC/gExtIKtextKpUiYMWPRDOXttG2oBpt3LcUDNMm71UpmEjjI758iShsaRSmFh6mgYGEYNM1RU18iJc03KFUGaTHXuR7PR1QjA6O4PC0CCjJ+TzcLfUn6TUASbzL91Luuwc8bR3a7nk/Nhj3Mq3Lv8pm9Q88/G1VHrsSKVCeXP7grAYRnwebVun7XtTWkhK4U1szgzJBqH5agOA5iCvW5DuQmjspnI1lEZiduv+tZ375zKbzYQU0AJ7rM60fh4MW6GHF/nHd7EKPtxOv2NKSIzG49BY0g8qTmpZNMFvWGYTS/4e8hTNgryy0Qn5qO4/wtNde5vO/Bz+0gOUQRcayqwZfKN0OKlp18f3wejEDZhU7t7r29l1QDhlKu+RVVbuAAndKFevn0sRZJUmK653L1AFiHxFUUsPM44GkZKQsotsN1jPD0XoJhcJc+FQBh69PUdclkc1QeIll4vx2Zjs2tpO3iwtwjjuzBe2rf12FdDfH2U8fGF97cxCVXgdfD50Efar+3fEc9FpfDq8xMXk9T0ZQdPf0slOFREOkHuAg70WU7JcxrlUiZoOl0NIdhsZfnu74ikMWTcG3pagUajwHR65Aoz9fq3a+HiPk5B0mtodRuSnrgBX8Q42v8MGt0bnGGWreKLiPFoddk00dzNRSPuMD47nOSUUu7KLrzCtX37mXUDbf10KgLUd2KW3fg4Tj0qI6JdtwUl8haxWhfkVLGHlfT3+z3ceTjRVaQPBBdvhaZDPXUbM/zorHdiFAU/50hs5Pzunw/C6kt3+sSfcHD3A7+vQfB4Dka6EC+hOjb/H+MEp4Z23/2mjC0oDLrCPpaTFg0xFRB3o8T/2MeUB30ik64vHb6mDstevqOiJW3qw7Pcsf/5i9Xmr9cGTlIRJdfC4LySM2nVhth76dPvD4gJ/h/fCqiUmUcdLLXCYdqu1PfiLKinz5BNRFp79KExPgaC7a6A6W/rGXXlagEZ7fr2kSWlLIRGbQlTZmDBszPeW8OxDwPHRe9l3wvYdNQKK/Xq4ZayEWkCFqDzydI9pO2pg/C19hV+QJe4sr8vFC2icBhCAOxGTWyTdrE5AmMc1GdrTiXxqgpKTApvde2XjldESuHNIDrEgLFh6l1lbp5f70MlF4yLbcYc+750bUT//OT70kI7Gnm/jPfBopTey6MyJtvspCz4ZJoJ1t7bQ0bt/XN/C+shceDET7EAgCNsE2QhOb5Q6V4IWoS2CtHxrZXoY2Sd3DjWCu9M++GyP96CNmegaObOrh85JqG9N4UY2jFaeE8hG6zhr+Hx4UDN+QeiOrd1qFFTXqFE7qbtchvPkvh/ojnUQV343az1++4E0spfTcqDC3HU+oJjdZnOuZfVSOnddVtDeLthqisa6OvVcTz88kCxAj39qiVREk2JHkT3KPiqEPaGlduPGODCgMrCpfy6bdGzvSh3oio+V+x7pRRvBhJZE82blrXB5Tqse1f1pYBf6ykRDYA7nPKq9Pq+C/+zt/4j+pC5xGG3jXtJLsD7faRF/cbPg3BUQtE0VzDBQymGLbRI/aakPyXBW694wFikSpNGeIWGsg1NAlpMReZ6KtVxtz1J/zdw3+fZ/30nuv89r+uxybZ/GExPH/gC56/4c4KMjIRaYoKFR61xu5epIlNI4GoSVn0NVdYT8AQxpJLyIlIx/IJ429jSPnJz0L8Lv+iLw1fzEo7wKhx+SmRVsemn9GceJgXoGyOKDvTzp5wXtG/UO+BVEJSH4TrExmOFGQXkObB5PHyz7aXZqcRzoWxZicuaJm5NDUQ+EtWigPkcIP+EFUjZHioE6QayaXU6FaHYmn0nyAzyEFnS767yL3k2U9IDVT75fxGBHh/Ir+dUD9zDxOFhKKIKbw/4pq/vpNnf6nHXr7j+yu53cgy8P+IW/GxkrEb4xDvzIkjog6YR4iMoQVJDbnHALL7s8ko4QWf57nybLxxoYu4WaTVnYh6ufFlF+OhM5/iPnv5DBvysswXalQ4Y+K8FRBF+hK8dytUWzXmzO0QiYkxiL5l8xlK2fCrvHGAYt2CukYt20g5tA/4Ts444k/HZUJ7m3tUSYS2fiFJYJZp03A5b55rFy3G9ew7wf3VVegiJW2S6CMe1iuQT4+sKVcL7/2mepZUTHbNrKm5Fo2ovX7Fn1hHx4f6vsaP8r51bpJxin4AuaGr4UF4cj/aMsWa4qfTN3VOwtg2bfWP//O/322C3pdEPwQMsxEZdmcAn6gPS/WLJKxdHxrr70EkbqbcNcKaVB2aDmHV3/R3r+rq0uw0Whk5U74MOslFjSrkY63+lYpXZqquFpnsNY+aW8Dm+0DxSvT0P3qmeF4pPCXKY7soXL4tet24MM8rD7wQaJiz6fxQSu6mgOkR14kqRAzYfUzMXxrTFgnCI8BNODs+HFGLovjiSe9Wc8ehVN6gauQ/dLKUryxq5YnpcOsOgds+MJLF9W/fUY24E4MpVhX+9chotJvXtVA+QejTvJuhbSfULeRiFl13j94u0yO3thpqiMmniZgNhcUfVRpkbZ/dpxYiIo100whLacue2zCaTAL6PhS5bt34+v2QKF5nES0GkpCb+kA35/ouibBte98SOCoSxhXGKcYbPvPIvMblHNS4AkJ3+xtulBo9yPVp3Kx7yL39nBbVnQsz/8P4AvKlcxH6OQzt61rFGVWnCREZQFeMkQqdKlsOEB1Kkf8pUoZ5O7afxY3Nnp4Wfrf3hOEZY5uix3wCxbA6ReFlZvQPRPirMXiIqsG/lJabSfzu84UjwgqMkaMsIr4/6j3cfGmj6vwc2JM08AarctRMeyOXoA+OSUn/+RJ0fbJR925DCRmO3nuyc76IhVJg0dMmDyFRTfrsi5X5MG3hk0R7va6QIp+XTHSjv4elqxBpmiSiOudgQ0RUN7pVuFs8CDlX1H+E0T7qMfyF2Co5b8eJD5CADFXvmD0X/SfKD/c4Yuz1UCg30A5938bC7H5/ULrG1FHBS/D5FXsCcM7QKpGNifku0fULPm96s71nzY+GxRsT/n61vvzDIPeSaj3tv9DG0NJF0rsCOm3n3VJwF/bSz+wZWoDh7U+93Q4MIUyQkGboRdMBAXHIVTey0RlaTT3wPMqb2h6jriDMH14Tyz6CM7Ssjs9rOFYaDIAApAODTQ0uh2B10/bYXag30GC0dOqlhhXmWXA5O9GUen1naPEfYtjAwOpF3nmX7tEEBTRUUDcogi+3HYOy897PH8Ulem03Kz2h2dNHPgYG1vk7x73qFbORiNg5GwNrt4CO4CInfaJzPsgZ49iRewNrr3hy9hEXyBtaR+/GLjr+/tbA2pzXInFBctkdcXJgaFX9MYNOGgNrU/yzvmLd8NSDnqHqhV1tHsFdA8sWIDq3nCwZyZvj+bw5VFFAL6YJl+6niuc8H7SBpsKZjVG5dyyESaeJld2N8v9GELV3vjO0wvOWn4cCAWJNm3UKXQNrUyz1xB5zkMcy6NiUcXxkl3wP40ov8X3dhUREf+d/+n+oCEUpwvcxHddGF6KkWF2G+B11gLFjF/FS6oKrvALemZWUWEMlBc3grno82sh8D2hIeZmDIJZwmFeGrUuhfDMSGZQBLqYysBZSHoOiHUR1EVlPrHf1+DuRxo+MPI1PvJBht43Iwvd/rVCJhcrtSjRF+sk/5U5690up/8B1XM+BciKNlEpT1o6o/I+1MLdBfMiKCFijFhGFiHiR6ArolVi5hiYCRNEl0wUk+qIeZNIRxaBcJRtxyH3CGVLZ6JwNkZDSYTeMvRjtK+fGhJ8+i+DnRiATYq2Rj8ljVMNCXbzY7K6VixRn3kUrNI39Ap5f6gvjZblrJ5uwliaiMhiuT1yKvkO0i0aLyrWbkksrvplMu/tISnlWEPIbXlMwYwnGEjy/hZHFsHIbo47xupqgBeNyz3wO9L9QL/v8YV55gjUTYLm43WYIHEUWAk3vRr0XXJwv7yLlE9czLETnj0CBihpSOqalPogwhKCqdfFevl05VcfHlVgYVcaP73tB0LtSGK2CSxATtNfgA9fFzHv5jbhFZY4J00L5ZqxGAwIPrnL968QukJw1pQmRLIyI9FoWatLceHeh7Ttw+RW3ObKoi52nvaZSLjU60V4XyAVUvW1UotclwuZ3zZreTLmy4q7JEmlGa6F8UzccGMtqmFpUJUVKj1dtX/zeKHv3kAh8wuCTaL5i1zBTQqoK7b4OXTesdfvh/ZVS7wdvi6SCaY7BeWjPYaCN67fkVucK10ipGhYmsrAsC9/Lun/RhuvKqXGWmcIw8t9RUv04V7F1C4YQqmGoQEWp64zRUgvjuFnn1V13GYlipOkrNkQf/4JEHA48Tk/vF0XJsdFTFFgkYWgtVZbIoGbaDyxNaGBOdxlSrXfPS9ZJn/aP/9//8eY43Grvhx+GZJVCUH3mq+3AtbZze1SrZ5V6f75MAmHNeg81DlS9u7q8iGSxQCh6T7EV147teRtI3ZTqKgMSwoKFeQwarfT4O8LNEn2sGdFMIyenDZnou/+h1OcLGXCnDoIG/TvZmauatUFCdJL25GKrx+SIft5tE9aVKIWGV7fHf2qKO0QFOk09mvBpKMUvuSG26qdRekcpgZ8N0Y7dtC2uzjUSkV0+Yc4V2QG4Zd4ju5IQ0UQbJXsYYnmMKtCpqUBgfB9Fj7nfymAkKzxZXPljbOiWEPTf3k6zya3lj+m8xhqlV8dfKIz4VINajgV6a9A7yHVYZMd+NnXbQ7B6Gzu3+JUUaHqbqAQ2sLg+fAgMrHqf1sAiItXPmjtI2OVbiR4U9AsK8925yO2eyxDVYNzo7/hPIeLGp0rw90nam+dQThcWSUNUVpc56A0mcg0pbnoGFo6x56LE8CrUgxzfhkLcN7DstS0PZs2buV/bTxA7S4hH6SYLl6L8UXEbsqHUR9qav+1ahCAqoqo11pn7XwlG8C2AXoXACF8Iu+fDaNlwwJqbb/uKFxKtiNK2v3vl9rKuBFdgVXef629Equiu9w5xy7s6dRJ1+3XGp/zpFPA103Wl9RLp8s1axbvFja9caMj7SMq3MsStbNFRcSoGDQXFF4+Ofc/yg4ysf/z/+U/0/3UxGRJ30l6KG/+55ydHsYlnrXFQSpsiBscg7cLJDXh7Xx1I8j0WcJAvL5V8q88kgw5h+UC2iOpCBDv29L7Q6T1/d/1S0A2II1pvS5RBdcr05T8dKaO/egDmFCgunI+tJKLhqXZA7Xh+McsVaVIj0raxTuIwSLYGlhpaG15CRcma+wZrPDijNgvSAbRtWuqu0+7cDvqyykr4VCPOXQ1DoCG+O/RSjbbEkXUlVqQR3KxexGGjHabfha77AueDUK7GUqFtDjecbz8DKccNhimftDVcuiK6Rfhh+k7ka0Ww5NxVkKtsfsMh6P6aO9K4vlyb6m3N+N41ik8VqfJBJtMXEmxyy0bt9Cbqs8OFoAEKsgHJo6BzaesOrW5o/jy/z0SlyjTY0jN8amJ4YxyNnAS5Bv6s7addAKdZ+zwRbYwtvXcWBL3Hj7FuLB8lKIj0oVDonivIvrueAUbE193jdPYEKC1dY0g7hutOfXKm+DKpjhZR7Xt6qovK7W4IMfZNW+j/W8MPqdkIX2En23N9uzrvRGtuovCOrmHP6yBZG6FQFNHh8hF+fE4790Jja2M8ERmyOzYZPWqGPE/P8MT52hZi8Nt/2dSjfeAmzY0NDkGQy+U76QOzJI2XzWd8XlQzzW5Udb7xkhchMGJl+7GfRx0gpPOYafsDFOuwfH8x0k6pMgAy0eEHX+GGzGdh7VzFRFEzmxTVJmPDwj6vDflddzcR4aCcM85OoBBxLC4XHVFNNonj53f8whBh2NMDY00mfuDhpdDzTyOFlej0oS6kUHx/+u1C6SnSepvpd3/7G/oXv/iKpncsXHr3qzZ8HCjLegpVGFIF04oYFOIaE3cpXwB1FKtfw53Me8Akg7/FpVrOo7qc4ryKIKhx/aagcgJB3EUUzTX1RbS71YZbBdRBI+qqgURElJvJ37bzVqW/KgaXyk+zEwLqZYyCsBYKIVNYGI0anjMtN1GfOwvapGT4bCZreY7llvtOnAqV0ZLk+VNJ1ycjG0A82Y+PBs5eq9FKhdQQo0CmjRnBjZNJn4RnkzopwkRsYEChHdwmuNSYlN4iX0gx47WxrABgFDFYpLKAUa1oaQhbRNW+JxQZ38g/t54TkYzD+S2PtesXSdsy5MpvxOZFxQoT1TyUqT5THoK+O9bM4uNPD5VKAFd1utZ8g/oeqJ28N+iTunyyUhu8gaXRSePQCB/jeuU01Pd4GrjNlkz57kLp24+8IMy0WZjZJSTIyDC07p9eWhEUuBmPECu9jpw3nuq5GrGbdP5uVL69ZqF973ZDrfXB/L2wsPTTC0edGWQ7LZnWu5MaWpBzwIJfhkjrEGn4eKVyTkygB1KB2wSz8bOoRZO7T96VNQTQXvjsGa/+uz0EEWmPIm14N3vRhkREBKRoQ7cxdYdwrUeQ8Azm+Zr79iJMS67ImgRXKHplni2YdYbFU4O4knd4WTInl2XhPiNpbHymlvnNSCGTatkRybieSfpPqKrvUye6t0jC6CWzoTUvVE5j5QBa3phLtq3nqxyUb7Dvj2b9MHdhc6WO8XFy/s5eYk4UTZUj577m2N6EmLG4OQPK1CEsmfJlNLsbgwD5x5KFprrr5NCOeYqJfXxAB0altsf+zX/3v+Lr/5oveP+vzc5NngvcK6Q7QTir6hrlogZKTSezvVnVaMLu9ADCNfwgrs8+GdgvqupW6kzkqodj0bacD12A/Xu6fvEKrZeNS9L+phwpc4/Q7oKXS3sP/M0ipJxYWpEZgIQHYpfKwTkSckX9HPIRn7ekYctxIxLDpVQDi6gaI3hO697bBgDgh059VOQURgWM6M7BHsbHAjhuJ2NEEoIfh/a7vgsaLIJ66bvCMJN7Q0yVqBpi3v1LRHSSUHBwfI7SNWl4+OS4Ha8hVhPxbt0aIK4vNpu2gZXhy92N/H0gZrnXZ3rf94QqifrIhWpf1UixMAxiaGDeqFwfrqdzvdgN15E7En1JUteAEB0fO8RodTE6o7P37ny4vm7AzLHO01Ksi1dRDec+7HG1QvubIkq9d+avq0hSZ17ySbhTqq5hMX43yaM7MhyKrMGF2dGF0mOHFgHqoVdaRocWHQVZGG5fmURl3kkpYT75+G8JivVN1vVU5U5A8+jIweymkjsyjr5HkN33KT/YyFKXIcjUIZCGmYfAQl7yfcFvRGwFpzrpliGqbgpF+S5GXoS98CjcFUAl5rWFDVXzaajGVgrNgmw5KURE8UkGuoRf2zQaVmm2hEDriRctGFolCvqR6+57fCjsziiMdsSFaL0wr+Tn/5Nf0r/8+AUtOdJv//Vf0dt/nmk5S4Jhx0EYnjPFudD4sFLIhYan1aBtbQeyRk5XuNIcYw2tjaGzZEaoBEUJS3bvl3j3ECOVMbLCesdYqigNbm7qix2YnyT9zt1KNOi58pyj6T9j2pD2cX7zKYECaWYXXFwYjYH0hpfbwGK/XCItl0jzXaKSAi3nysNTFwYMXszfIpQXF6ugLhPFtTWwGiV3PCYMmWtraKGPNudgku9wWKzBV5IYIweBdEStizBOrGJeUUQ5yC1mvfYnZ9ir+zoIanhOlM+tGx7G1CLSOuNTlWk4PcBFJ5cvBvlVtE5uadLlnN+vND4sRsXdRbH5ydjkiFSNL58jDzI0PUI1gnXguoAkgJJuTTthY2PcvhXRN0hC5MTQysfx7h6bu25Z+Ps9V5CVb/hE5Frjwoqy2MfAi/re4obv7NiFa9PKI/gIxLmifWFaKD1OSm5GWh7vAlYOYzJoqp8HejIwaNu9yETr8sqF2xICpevaGlhAkW0OXvv/6sXZWcjRh2xfQnVgIGH9KpnbPgY2osbh0MgJEmjAWlzyaQVnQ6AwjBUNI2NgOcM8DMPWwNJnyHVM+OfUAIPa9kGCIELOdP3JRYEMbAhPHzNTJRauY3q8Mr8RYr/YqGNNcqiU3sMLwFouIhFB/b8JlnPFUqM+t/woSJZWwKIUrlRDxS2QHf6UXTyJDBp1IM+w4aX0fMhuIghZjIhCRLkuXvZZENY9PBcl3qrEgiSSPT1sn1cFEqd2Qph+th/u7VXljzhK3tBqkhX769pOI1wZ5Cj0x1uNEA3LPxDB3NwLrsBPiIjydeU+bpHpneO1nIpzE/XqUL+oiB8doG0omkhaOEDzzQEqBRenk0CIy/blqYEFKYsDhM0TrjcJuU3xhlZcs0Y5wvDr1WdzHawDMAinTr38Vy5lRq9kaEAdJn1HPds6gHdFRHT+gIVB6muHvF+Y5DeQ25vfVCsNXKoDJAttq6HuB/3Zz38O5ehfvzWgy5g2EWj9e3lk2Blc3Zt9xnSvbiyH5nSvG/qfvWK9Br4t0T865weHsOvm+ABp37rz9p8/+LofISDyfooznBoeVkePy/OmijfMbfGintbA+lQB4njwvqsb0M3/B4mePc8shFANM//OsumXyKNoDCyi/pwB9Or0EZupV7jp3GW6af90kye/+ajDphKoO3/8EAOrU70fUPDu/URzdAfnyivWGo+yuxT4GSKhXSuZqHJVQtB0ODAmynlUsb8iRkaY1wpVQnUbhotMvtjtWsVvX+C6O38ASW+/U4BT8q/+6CdERPQ3fvoviYjo+SfbRmJkrGx2bUAvlESe6z/m5hRuVzGieDeJyrbt1nXVhcBBBRuj1e0GcCmgSocT66cnBj+JekOrkSowkXf9i9VzSqw5J/X51e3ESZzjUoiFSsvW3YcxeQPUimgdSSIR5T6W70TVWDnUntoR3lXOgY9Gsy4YN8Y04OMGLrehkZWo9yBJlcPP2UR/OtebGqXCgysxVLmWgwwNHIFZjy1u4dQk4DvEZrTZ9CZo2ytChXNdsAlr1zGCpfkK3cKFzZJqtTn3tU1tAw4ikltvCMg2YMeLJOM3iIpaIrvwmkpy6Jc5N0xLDSsXFKyrQRVie74uau7zFS4QXSi9Yrm/tnGbhRi5XY4CnErZIn1E/fkg8fVKDNXINMfHl5lRyzkTFfO+kPIKxlZ260jHgGmCqIj6IqO+oG3wPl1UYHM/cNK84Y/3iPfacweLW7AswlsqhSUuTiNLIVwubXuGdnz1XcBuTTYRg7vFCdV2ifz+WOWgOcMf/WZZOBp1XvQd5JuR8s1ILz9J9PKTROcPme5+tdJ8HyldV8qnWNH054kzIggXUhXeIduUQstXAx8Ya9RrNgoo2X3+gPKDdLJ8+Tv/4/89/49/d6ioz49HtOVMlXZysIu9Jz0XB5E2BHjJ3K6pTT5em3N7E2MD1yPFxz2LxoEzArV3K4gIQwu/TW+EV6I+5Xrs4+/wd+/+578iIqJv//OfERHRV38oO3djpGEXnjzy0UvW69pPoy9UaM+8Qv8ecG6PsyTnA41QFfUD5CK697TRHupNspacDqPBoWzWKNyowqvoJ1xOnQGF01E9eZZV3pvlXimKJaTrBPK6Q3uIjLFljDei6q6KTfoavvnwBAXstTmn0Zhyed02OzaDAkPTrSaohjtWrtW4bfD82zaKghyNT1DhXpt68olyGek/PndjN8+lQ4jXO0mf8ba6HoC+Xd9y3dH2t78RxPgDJs163ZrCSC6PzbIkmrVBBniWKnSZm/o3RudLm6Jjg67aPuxRLtX/cUrfZOao3hDQTZ/MVRAjNYjWRghzzzCy9/Vcql4Akj6L3BNzawfZUOMAekeDaz+7pvSQAnuMdb3ip9Fd33k2uhkP0L90s2bu66OdybxPCG2+IIfZ9th6Hed6hbHUQ/BUUNRtFvG3NSSNVAcRaULocMsMcM0GQKQcwfL01NbNv2OiLRoporabSD8iFUktVvGeqKJ0HbmGRseLqrFemqACGWvWxSjjotwyH+D622+IiHMUEhGdv6vvDql0xl8/8Bd4B65vNPVa2ne7URaw3/mML87Y+sf/xatRrF0L7sdDsnoFz+TvYi1xj4BZn7n7+0iPiIgaWQcPIzeJeHes1uIiDsqYRIsjKEcLeehUwflaDYnxYSUK1X2IxRcL88tX4lr66w/07cdb+uV/8xVNX6305o841Q4R0XKRRf1qrl/4GkUQgkOLnLiTIZ1K7Uz7x2/cqAeGt1Vmh/bV7vH23dpj7Dtwi43KLHQGj69Dc14MLo/h7ulEkVo5BnQ9dEmk2hH5jJKIFuEiA7VSJX/0nVivVSKf59PpVJ21THmUSFYJxPDH+E++KRrg0+iE5iJ0z9j7rrp4Sfp6ppwihblGLG4CDhIjwvkybJHlPfKpcDLLeazSCPCgiLE03bUGFidubq8Dg1RzTjoDq/0NbqXa9kDntLpu01K5b5JotnTGnLpx2w0FDQNRLtXAIqou1d6CgGdCG+2lOCGzCPfev69fcQtdFuR+zVsDDQUGltXdyu09NwbWWHlZm77ieUjWC+GNq56RKKlgPJ1AN9l45JwN19T1UxRPNcGcBP6a/80WiHhaLtmBW23PwOofW9tBgwxwj7nloNnrhsulzqMhbNEpT36XvIillI1umncRwg0YUhVJVYV3R6SvOStH4+J0ba19ZiQaRyrjoIZ0xmZLRIexdg4vKw0vK6XHuXLxvNFk1xD7z643ey5iuwbBOHzFvPp9yo9uZIWc68N+6k7e0Dq8sHNL7YVa2u/cwPU77vZHqRI6Skd7aM/Q6pU9QyvtZxTYGFr5IAXLZtJHxwrV2NiE1Ef5V8oWtfLQdil1NxhYKqOGt++/MEWxekbCJ4ry9TpuzI2B7Sb25lif7gZzUwd9U2HRsT2np321Z2h103zg+s7QKkcjzhlaKMEbqPaTRNMtsGxDFGkPvo6/PlUUa3Dj6RVFA0ouB7yNvSHRuY+iw7ctfwzJnG0ZHyG/IHU52HApr8slej7qi4puuajJbvGL8BHX7LLDR4u0NbBwzpDYwIDbyfB51NhRo7cXxfY9fBzztPvToYHlb+2NKCWXd9rIkvqJarThtZN2B3Vw7zD3KA+qgwfer0uf1ikb42FPjoCIfHRgsUjZnoEVI7v7Tiduz2FojU+iaqScT4z8nE/bHLuvMdxe4506MLA2h9qchPacnqHpz7cGlivewEIUfS8/Ku2sPbvZQYi2ruzeOPXi3PkTwMH3KD+qu5CI6Pf++r9PlUeVOMWFnxDxsEjPEuOW2e/h5NU8uJynOj3ODYRdNsVIeWBEB3pPVShQLp+zXtun5UBdVtH0YY6XqHALD4RT+tS6qZRCDLTcRFpPgea7QA+/ywl309/4jq5Xce088XVv/6sKxZ6/ZYL96WOh08OqEhJeqTssbFSFRVKx2N02jHjsyFd7LDg2ck4n712wUS5i8ZcQzORldhDQHDMaTQRDG+2L9+kRyg2hXibFMxbdql2F92oTQxO1Bk4QFIkiG1TQQoryztXIMgt1iZIiaaAmVdIqc8Jyqb+ll0J55PuElejkpDosNyhkVpEfniXCEClpLKKSJR2StFdYVx07+t5s+zi3yXpOBglqI/TyGCguzMuCsj3I4OomRNsVkpx8zNcaXlaiXHlhTR1cYINt+3qQRwJKMw+sqpEVaX47EJWakurp55GoEA2St/PmW8N1FEQ3SwSvqvF7cn9h0V4i3hET0k7lmvi5mUSREmfJNUsEJBtcii99dns+2kLSiZTLicfMjXGxbIj52GBiPsKLXGvbdgjwm9Qu3r3VMw5D1JQ4Zc1GUynVc8wxrOgeNXUKNyQWVgQjOc+AGcvN5hPjPrt6enqIN1RioHI+EQ1pgwCqcPTIfYVi4LD+GDduQz1nTJpzUiMZ0b7X1sAspdS29ZGc0bUHUTVYfLsasdDmM2eWMiBiNDGmrVttHLkNxqFJNxfmhUhcmwU5Lc398X7LPFMYRz2m+L4UAv+/3A/nNlwyM18HRDDmwm7SXCicTf+2c/s8c//PmftPCHwujHNxE653J5rfnmi5Z8mZOBeKU6Y01/Vj/OUHvjzcukMyxnkUFBPu6o6rt+fCtvW1RpbyCPm6f/CH/5A+o+zu+n50JOsP/vAfmsmo5ZvwH6FFUhDKr4OtMwg3ejudxd4YWPa66pawnB1nAGx2ksawK9CusalqqC4qyqUJgTvKVF0sIE8//C5QEj7nfF4or4nSeaXzH4+03tT7Yxc+SVqefI66QJcQ2HhwGem9ThIFMnnw/LHVYtfvYVD5CDY/EYpBEOZ16+bVtsODUBO40JTOzqKMiVi6g10Vqsruuy7GRKw5EvUa0fQH83dObGxDSZ2o9p1qtJL+bQ0sIuM+vLTI1XQfGgOLz2/bYblBHYI8V6hRhk4SYeOuTjWtzoaXgmcOLJTLml0tKqeSEmPtf/kUiHMXUhXRpcrFqjkoqS0HqO2m/Ii7wD+PUrlwn4EIAT2+yIbsxnFY7IK1Z2BJKcjvGt2i3a1srO0tApKb4hIYF7gM56UuuioH0Ro9KnpK1Dew+KDmOXvCw5u/revSc6awYbtWWR3d7IkxrO5+jPELOKNJx4v91xSXO4/Op0o4V4PaGM5ELak7peM+rgaZQZ92Ea4a5dcYWNRBClEXcUWHcdwYePoJ4wmfp5HdgFZ2w6FLTaSgSTfUPH9P6f40tigh1kjfP+aF+840q8L7cs/XBW9VvTeRKD1NlN9cWgPLFuX8rnwMxIF7c5Xf4KN0NlHfw8A6LH+6nCyi7q6WiNgYQsTgpyBQObbRQdmD6FcxFux1HSlajbQY+R+uC3ca1U8baZheFoprprjmVr8JfcnwP+KU6fSw0ulhpbs/LnT3x3zs4/sbqT7XbX7Tts/0Lqg6/CQdsJfOhUhQE2fsKeZoov42LiGQUTUdSDU21TDacSNt+BE+F16v7OW0tAWGr/+pU49NBNzRdf25OOWovuhiyDF7sMbBiPL13kT2UX2PqybjduitrScWhleItdbs9O1nX96if+zRTLAx0I/aubMLJqKuC3h6h2ASPvbp5y3SaEs1dKUNT60haUuDYtl6H6RgCa+Qc9DiXbYHbig9xbVhP3TcSZj4XIidY5VX5Y0lU+DOqmlUXvGMPj3Ma9zKPaNrUxljENq/ewgcuGxW65CoRgvby6pWXWyOASp+WM+jucA/S08p3F8bKJGPSnXK8sp7GlLlMTmXbGPcIduCR0W93tcwHHPGiBoXYKOPlVKVd3DHUkxsDA4DhWGgcjnppkJLr71SYkMMASG3CHpBRgGp9vPKkfxYw4lqhK8vMKhsTkzfh3oGvvK43Bj4nE3kZ5YfNa1OtxSRqs/UGjH+MLiCwBmypD4y3xWkk5G/aes/RRg20ueQNTRiYGqKSrgbtAWfCLEmYjfOwlBZOQ0UpkzlVF1RYRU3iDO0iIjSc6b1JtLN17mRaXj4xT0REYUlEA2F4hypDIKmFOJr4ZEKSZqXasCVGCQ9CtcZgmtMeE8NOZ0iP4O2GSZ3cD4myFfAAE2aBoSW6r4KqWhH1Cec+X0VYhQqZCKQm0FG1UVFdV7q5Fpi1LBmdtGK63FItV2JZHeM/5fTG96VuIILUSFpk1wECTIdA4YnjG7Ng8af8019R8glmUeiOBWNNiQs9jf1shpFqNICgeJaEaT1ZtvpQy5EY6R4Xdkth8Wh1P5eziOnOrrhz3wRaYYTUC1TX/n/bIyPUKoxEmx/Sq2Brml0VN5A3jN00lLtYxEuZy8RAOPEabJRKRyEkQutN5I+475OO9M9S2g8/Zxdw8sN0fBc67YIOje8ZJrepCbNFD5RfxhXfLyTbIAR1XNb7dkcfufspQWIDKm9lV2wm8kwLdWVZdWu4baCESTpkZqChblnuDiEyqNRxSAqGjW2rorYhBDqsTA2UX+Q3wdxIw5D5Uwp0mqQDzNXN8/gUYJNXlN5PtkUh0HSEJ1GHvenoXoRYiBKct9ClM8sDBwnRrbCwmh1vmEXdEmiBzgmSs8zrW8vlD5ea7oq23YxssRAjFyXlJgQHxNRXmTuSEbBHsjUSuhAZWWDB24ybfOUiKZJSO3ShrrhH2r7ErV9Tg2CjifgciZaVr6mbWOn+q5I5PVKSIulBtYw0B5/ryac9gaX1Bv9XebmMM18/R5HCgioGGSgCxARB9vEOnfGl1XXjXwaKH584bRL86LeGV2XcA0r1SD9mxHHoC58As/RFghso85r6XMHf2D5U0GydqE244bb/LQW2qi29s6VSbGLAjgiaViEb2U66UZ+35PD7YSB1sFOWHOPVfccFMTVmHDVT0KSv/k60/kbovN/c6bzrzAQ2mMh9TA8Soc7IPX5dCuadmXaWv6bhUV3751dAr7zYek9gVCF9/EAWBm3x+4R1w+LcZt1r9HUZee6PWK84/1hke4KiGLd9u7AzsgB8lVdsvw33I62KNn7kiiPiVbJheiJwxseVod0vucm7KX2qYT3tq5H+m5eOuUQ7XF9FlGi692W+Drdc71fvuTPiSO5u4EEOFbdr/IcqSOYCgOrSja0ejq9+vo+1hNJ1uI3dQcT80Yt/kBoVAnf3qDqGVgbTSJXJ4uirOsheoVjD7WQdupyiGB7JM6lUukW1Bubv8eX3UPxfqsUy/47w7jRRMQwJjvvzrvajo6t64YYgljwe9pbuTVS9R36hMZNxVsuWDlvpRQ2dbEGVq8AXTpMm2M2DSMjYz0Di8gY1WsmWlc2UgFaOAMLUkDrzUCr5AMenjOl60rRIc9Nuivrhu4YWFqU/2bmUbdZCr4fOvT9x3QVEv0pugv/4A//YUU+rDYVCOUW4bCEM++qcv5+NXiMhlDpHS8IlZLejZHQGFqrIG0WhrX/7wytODMxNcxZSbQamdQxtELhVDhYaE/v+XtraOWB/93+otDwVGh4ZgRlvom03PI/rfvACaFL4nQ2ILRrqhX5F18QnUSKJJYYyWciDyBTil87LOv+JG8/TRsGpOHJxLvRUhgBlHezZ2BZBNImGrYkaX+uRQo5AKHuSv3iXFE0EaYN9fwjQ2s9Ea1n/oc25/riwnLZmf+la6mSG1D4V3cIf8y3gf+9SRpNc/1SkJ13wk+4q9puLEnB//IpUT5x2iCKJEEVzD2Z71pdLHWf4fFSoDyGJmmyD5CAOxQ7yJpom2r/78HsayGSFBcNmuyFa5FU+36k5X6k6W2i6S3fFLImy13btssN/5veBOUn+qhORPmePix0+rBo2DeRMbCcDlmlE1BFsBxFAKm48nnkfgPRUTILinc5DYnK+aTu+TDNdROztkaGpo6ZF/7/ad4aIMp9ad12TUh9KYxElEylFP63rq2BRbRNPox0JPZY3Uy1bsiyrPxvmqhMQhBH/V1SbKVoNFSNHQMry4Is12/S1KA8s4EVP75IIBOjs8nm78SUi2eVvhaXTBTk/XvUymszJr42WRkC4SUpsicusjAwATykSDXpdmwNlo5bLyAlHObOlNqNfYptNJwloGM8yv+XITE/KcWt4VeKti23u5Oo8DkRz2eu//nMv53PGzHcJocmkDN5lsbAMs9f1tzKmYTA42mMtN4MvMkspKLJ6XGmODOqH6elBgThsSQdlbcRGqFRa2DZlEZE3P9yrutbKdUbZNazH9vAIvpT5mT9wf/v/1QnJy8C6qMIbfGD7VVcm/acHzMEs7mu425gMY3TSnHOkqtOjC9EtQmZ7+bX/Pf5O3aJpOdI4/tIIRPd/Ym4PJ6p+ZxvIg2PmdYTGwk5BbX4NVGm55W4T1tK7AxK6uwIjsrh7pU/9sLTG6I6eHZO26YaAaU5lqi2N9432rhYqYRiIimtrliHX4Jj1lOgNBXVZ9LHQQQ15nVFgPabQKFvE+3myyx8u+sXrQsNoqK9gmcEcgU0rKdonFMg1uySc9E8+Nuck64ShenV0HFfi/Y6NBrjuicFkU+8W17uBlo7PBq4WZEAWlXnO02gaCDWSUmefnq/RQxUQNXzoHpgjhpYPIFrhKumCwKSCF5Q3PJIIcbpjRm/caNqkGxQZIsY78xdGyPkaByqvIAjYR+hVZ/Q32vKa9A2a9zYeWcnY0Dj0nSReelbFt9EX0zPM4U10/Aw1UwATqojiiJ4ukqez1yqfuKBHhmfdKDT59Crw3ZTPpNr/6P38Cm+kETYlZszX9ciYb5tleN14vqexmpgQePqnnc44XKp38MQdOl9NMBDZTfW9l+vaGL4dt7qFudGPiyYe16TPsltPDbCuaWwvfKnUP5UjSwti9stoWD3gVx6dvLa64Se19XbbTtESoUzfdi5aD8F+GYz1cXDT8zCFVPOUwyHUHlU45KPUd2sfTkaDvm/FhoEFYG7MDu3j809WBc9ud+1dR+qcYsx7nahumOCW4Foi1w1Ny+ys6pIoi3BtT1Rbcvi348tDrHybevlDDSVUOgQ+6Vd4pQZ2dkzuEOVAogL867GZ+yIxS0FF1wiQcLkESLRKsi9qsJf0XdxDHOzLHEe6XnWDuqv+QbPrevwSIfLFqSfyYoC2meVD1CnDA+rJF6gqqsM/C5jWFBF2LgPtPf2ruP1zBGPyx3rAa03qQq4yqEguq8yt4eV1IhCJKdy4T5RFLnyBlbPtYm6D9WwQrot7Ydi+GsULtxXlg+CMeBEEtWAskZWr48SOQTAcazsOdKney6gYpEkoq2B1Ry8Y8CBx2LO92KlIQRGRUIgTSfk3YcddXVNrePcZKp+boQ0y5ppk9NPEJtwXfmfyTGL+6k0yrWlOfR0lHRutKgkkA8loLefjTaUUzivOmIuAg/HjWN9ds9N3RjODvW0pO4j7TYcg2t/AmQId6wmDyX3qg+2HW816pGNr3Kqz1Ocjldxa3w5j0TXiblzLy2nsSSeM9M1U3hZapYFvwZ7xM7YCZvIer22eFCmubqe9+yQA527H6P86DpZvfJ7f/XvKSRaRgOTKsSLzilfo/Me5d9SJKkd1DqpmnPyaVC+V4mB3XwpbJEeMyA3riytmyMdY+HREw1KAikHQR4+/NsS3i2P+/G/y5/3f1RPv/kaBgk6oRhpH+H+wOJReDeHCQcaJxAwJKo7iFMlR4L8HualHYzogIgAwYShi2frZiSibdoLoE0dKQiVvtDdR2zaMeQ6CUO/qiSO/KzuQFgK/PzqxuslEZVzMjS3xnZys9GAcLEtN5HWc6D5JtB6EzaGUFhJtLjYMIgTi8uev8uKyuB9wTgA+T6PpPpqXu4BBjgSjiPPnhprtk85NKs4w6rm+wsEqQatP+xtNbDMri6LwRWI0syZ7eN1rZOuG1+KCODd2JRWQsyf34B/0boyH36nHrte+BnGByG9PxLlM+mMM36sL2p4KRQyb0TCWhjFCvX9W10vDfu3um+2oK/5/KmKVNaJOCK36UvrLtNdvU0D0zPCQthO8BY5Xlfj6uiMM+/+A+Jj3EBlXppjN+rwnYTF9QFF2VsR39g8XyMTgND+nksGdbSLWE+nyD1XcZtfS8bWdC9v7+rvJngAUhnr3YnfWS6SpUMCgU6GbG69EMtKYVkrlQQbbW/8+ATZTo2d22kHmfH8IBNI1BhbCDKybYPjTiNv7gfe3JfzuAke0H658JzezQzgka0dOYQGNUP/HhK3FfhgWJ+fhC83L+x+NtcIKVK5v60Gtbyn5c2Z5reD5OblYJXxw0TxfU0TpPInWDPAVfSGp20vjI3bS3su6lgKaaJqolqvgeU4/uC//E/pB5bd3eCfCZL1B//lf7pBNZQXIaKYveLdRoc7evXR7jwS5rts7u/ve5S2x7nBtI4e/j0wWs8fsRjw3/Eqi/vt9r5xLRp5QUS0qjI5On69n6KARBqFYUtNR7H/eFrsLryp0CsQBXWxbNvEpjxidLE1cIvXPkPdO+3p+U6vKT5581abCAZiFRlFvkLvzkLkoXKZDtpGXYfQDTx4B+DewYBanRo93M7LTaQS+ftGBNaUGmFKzedRwf2WSyXl+6IGtZFB6T7L/cjRgneJSmQ+2Gb8yt8X2Vjc/Jo/IURqC4xYfI4PcIlvGzQ4NKv+4BBhbPgskda3IyIsnRHTHQ8qMNm6ug5d8Rudqj7aX/lVmXzy3mLRDuoYWL3ir/s59Ap/rEXQMhs6m6TSKEd12is4B+143boD0nvhbyHxuOaebNET2ydguHxy7vYppZrf+shXl8w+OgMH1+25jiFMjNRCjvukfDj0OWdgNcUhiNQhkPtS7jl8Ot9L/sS7m/Z3tIVEHVMp2/7mXO3L/YkNrDHoPDh+cO9y4yo9mDA9QLBnA9g28Wjtj2NgHZY/G3chET+ouqo6EyPgZD8RdgytEojhfCGlFufv9o3cJElWKHIn0kXTqnQ6oDG0Gp0sXMIOVnMMIFGiY0Pr/L5QHswCqVIDUn1jaMUpH/J3wsq7Na+FpalrbIQIiJe+7BlaIXwyeWuxMhi7dVybdtwYWJ0UCpXg+mkUi1JQyQGivqFVQjX8k8/3R1tDy5eF5yCabyOfH4jKIEay71py/bjw9UCsn+6jkVgAEtY3tLpphIyh1Rhx2BSv9W9L8C+RNjB71fKCyzDWvJChbceeoZXHdGj8TveRTh+LGljn71oEcBQDa3guNDwXKoMxrOQ38LBs8EJYGH1TA8trepnNULEZJjoFC+8nDSyZs5pgkc2Y6XCR4Grzc5DdeHT4XE1R7au+gbVbB1t6iJIVMzV/Bz8/eHHN16Qh2lmEm2t7SQH0uY+CdCzGKFVUUNDVF7e+GPQV/3aLNQybOjqDRJAPEgK8fmc/TSnnsV3XVNzUuQ3xvj/BRQqCwBE5A8vWkYyB/QkDC3kEy+XM/+5vNgYWCYKVb8+Ub8+tgeUL2vB8ovBybQwsIqLxvSjQJ6JBUmXFx+uW50jUomuWpN7zwPi1H2vfJ9eg1yAPP6z8mbgLUf7uf+9/XcMw4Zayqt8q0uhg1h3uE6IDGgVlR8zV0lOJ1+vIhAUeBibqHv8B0UaJBw5Uuau4Y3U7cIoZXlAgvPb429UwQmTVy0/5Pu/+a/7+/GFL6EOoepzYZRKnTOl50fD0+MCpFnTgCSStbj8rmIjn8vwsLCZmF1YsvOoJ5LQ1sopEAGmqGBshgp09JvWO65XbzlwfCsBZ6u2jDRsUotTjtH5xc6x3PwIhsvyfly8k+u2n3vDjT/CI4kQaETo+ZYorGzI9iQdIKiziPpvFA3L6UOur3L0ZBnagfAqa8Bmk8JzCbp7AjeAo/sQmQUOkewZqe8xGO0uEePk71qILa6H1Muj3SPEzvQWnq31+m5sQuTxhgCKSEJGQ5/fiQp2JqBRu42uW1EZsdKu7EHzE2Rkvnc2X73PkDPBgZR/EnaRupT2jARsMjDmVvLCuwZY/pcKUblFUraXrxAv6LJ/LUg0ho5NVlmXDwbLIgqJb3rWFMWG/twtyKcQilKFez8sIqIzElqqxKR41kudv1iFN/cJuSeULeXRI9KzKDcKAzTU8FQW3d1piwaJicCd5rplPk2PTKNli+5ejW2wWc/uuUAcbcWivrxvXWDN5LKvO1z25iD1Uya4D1s2NNHTK9aU6j5QUKc4rJ7WX50kfrxQ+PNZrSeQp3lV5x1qQyE/4/NstEkZEdPMLju6K3z7wc4HecmuSq8sGSl2tObdBI+o2PrfPZyJ47bWkcfTzH/2z/2xTr+9Z/nzdhSj/6J/9Z+2CLiHMNaS59blaAVGE736yKIeo/71qWsV6jEfCWFgzb6zm3u53o7S+U4bnhYbnhfMzgRMjC0w+89/zfaDxqSh3xXOb7P2zJyfb6CdbP+x8DKqlk4RNk5HzPnz9OZOmLZ3eFWD86UTeCSDQwW3ui2v5gIRe1bBzDKFKbRSqqFlho0HT2xgDlqhyh/KJDaCSqqGgbr+exNhtRZ04f2E1lsIqeQxLTYSK96+q8diAx0DrOdJ6iVVc9LSPZG0evxhjQephSeWbYr83bR9Kxz1tT+u4eBfRvllukay6Hg9DKglNYnw0KFYhmu4CUWYCP/pET2OsNw+ojMriuDVE276ZzLyiF+A5Rsn/PQSqq7xuUJN1FaHMwuPO92uVcpDFcZp1l66q7IbbUrD49pI3+zQ4YpTZAsNl4z4EamBSp5RStA3MBbb31WsABctbBGYPofNzRSktn2kPTWofqj4DyXhAOx2hiFTnHv4tbNG311AiegaWq9Pme6IquWO/t2rlvtj8fFTn9WZ+Byl/T+YD9/aBESiQROgUVc5PmNM6KJ0gXnAVBqCzYgxDE2v6Unh1Mo8iIwqRoFi2uOwJPfSxSTfUk7GYHIfSptsxHMEf0cA6LH+mRhYREa2sVREcBL8xtNAWrsM0E2zHvcgnGUMrdr63BYaWGCtV68pdVweG+fTXM38iQbD/HgW7+etXQAxkly/8LG9orWOg9cSL73wnyIuI73lDq+t+QLk68q6G17YhuiTE+JBL3cHvFE174TWobAkHvxHtGlpd4doeAmPu370+Fhr3zvYMrdQR50wiq5HEfQWjSBMu9+qUOEGzj3LyhhZQNLzbXtGIO3Ud7h7a1K/9rq279s0jT4qTW9lrZ3wPQ6tXINh6+mgMrJ2S5vZ+aDO9X/IL/v611Gh6zYyHvtITLyWqC5PTv+oVT9ptDKzNbY8NDBhdqlf1ilQgek2PNqEgWOaoQDPLJ67uPLeiKnsGlhdGPnKPYT7BNV+wK+25qToGRK/49uiG++f2GP89ijfme/fZ+zxM64VNgDOsbHCEbT/Dh1I1foxV9LertF2Hz6abJQkW8AZWdIZOsBpW/vldPkTdpHWmhPh4ZaAFKJZPT2W5eHY97vF00Rd7BhZRW9/yCmP+Ryx/pu5ClL/7b/+v+EENkhKWtSbsJNL/LzejvnSfCqFya1ifqo1qkc9UDbEuD8PnVAM8iWvKd0TELrG1tHnlSqmcFVvsrUr9++l32M/0/NNIeQi03BFNb4sgDoFO39YFCK4SonYhBzpy/hYq72sbadgTFTWQt7a3JWLCJQLEa2hJwSp+R2TcIgwt66eBlwPcuKYdbZqjJoclyUKqEgHE/x+IjwXQKIgUUe0LiB5sXLbF9BXhRm2QGHWdSULvFJTwXQYW75zvIi3nQNevOCpweGRS/HzLRsr0BV8TxlcoRJevM8WlUJpFe0pch3Eq+hwwoF++SFQSUR6q8QH+0TqynMQ68m+hVANJI+DsqMSaYeUy8D4CH1tC/R3IlucVInrS/h2WLC5q2QDlwu84F8onTli+3NUIVpvix16LiAxSxG1YQkWrprf8GZei7QHUa7gWSlOmsNQoyDiz7pG6P8HJyXmbKzETWakXP2aDTLxqhGqYf1FuxyYaDTwRIh4vVmxymrfIDdzkiuZPpClArCseCyM2Qj1UjWjj+isir9BXG+eIr0avCXU19wiJZRRCilwvDdGv9wrgJaVk3J5rRYdSalx+4TTuG3NiJBRBAnFOgyphIy6Rho1b7mwWdePm7AVkNJHome8XPLpPRCr+KXOguumcqLW2I6JD0Z6hzmmafs0SrnNpOUg+stS8J8uF3DyPRM6VeWuwc980dU1JEa+qYC/tNc1U7m4ozAvlt7cUrjPly4niy0T5/sIJuS8DG1ulEK2F4stEFCOFh6d6P5L3cWIR3/X+THHONL070fgw0/Un/P5O382UHsW9+PBc66Q8MUHopkVFRDUpdxa6gtN/a1JS9YK37DVipH/0R//nbpv+gPJvhrsQRR9QSdmOyOdKXPLGmvali5AcRQseXcu4QVhOoA7aTeJe7CA2Ycj+ovxvfMwaqg9OTHUT8d/TGxbGhBvJlzyyivdyl1RbCXnhavSX2zoYougm2mlpOyw5PkG9Rm41hci0lQf+3OStRYmYoTGA+flbN041ogW9OiIrl6JtbO+vbjOLfhkDS+tiryXH4j2dv+G/oUo+yrxy+o4DFeY39T54p5oXUSMDdyZKeH0G1s66vq3K7KsX6bQE909sexCcoYYvgASnoaVGrbmP/xvvWHMmOkFCNWBDoPWG83Dq87p6+pRDe8+RBz53PZPqxsFFq88CRC8F5ibCzd8rxsCyz4BS7MK4sEGw2WRFd641sIi2u/tS2GAyGkeNgUXUuv1yadW5u8+xP2WDDxOGYZPod0Nc39lc12TSZsHy9fIuO0tGt5843Edd9uphDSxbPqEN5aMH+ZztfVTG4wjlJ6rGnZsDrbsO/7yB6ucnH8C0uYd111kDq7mIqU+HWN8tn0JpsJG2GlLwJEl7RpWFwFrV8u0yEkNDxPc8qsGL+QJegvEB75//wcDalCI6lNOimxw/phpZpxDquzgq7hp/CgbWYflzQbJQ/u6/9b+snSiEuoNIQEhSk6tJifEwdHwntirUNhfiEZKF+RLaHwYd498jhWkxKFYlH26v1b+PJVqXU6Sn3zrTdB8oj4xq2Mg1KIyDDA1UCzn0FkPOHl6yEoHTlaNnhu+q3kjVT9mJpLQGznnknbqgXDVCzwUjnJwxtyH/mmOxYOmkjIo7w2xv8bJIQAgiHtveTuFoXfDb94KBTqW0O1Ibuo1dmPDcZskjuIjr7uNfTHIt5hGdHrK6955/Gmm5ZY0nIqL7P+ZrXb41nBGqxgWMMMgwTG8YsVvFoJ5viUbhk6IPKJcJxoZrg5ownFT6g9uzvh/0K5yr11rcGCJSlKNEQcMKEUWiJCrrOFYNNhhhLndiXIokqi7VmMMrhcdNzgHhfZbP03s8s9R35tRFTHRnNCtOmbMsaIYDZzTv8AUVxYJIZmGDO5R6rM8NqnMNDAZ8Wo5PCBu3YHNfr2/lZUTWlYIkb951f3n0A6XHB7Lo0RF3EmUvGbD9DYiWTfVCRF64tNZbUAnLMdLgJJ5nCgjnXvbBGV4Ba4F9BnBRXYBPXSPkEkq0b+kpDW3CBk6hrrQ1yFEOpTmEpL3ZGHry/Gb+NH+nmj5HtQ5jpPAkQU7Pzn0KoxebaX/tnntzqOR3ItOOCiqI4e44juFl4nyEWCuMPqOu2Rjj94xgwetw+uVDvda8sHr9aaD19kTxZWG5HzyjSZ5u/+4Gn6C9l5VtiHlp6kVE9I/+5f+V/pTKv1lIFsruAxstkPBypSC++I3+jVlYOTqicy3TOUKpEgCbYz3xtUP0U9eW3wVrB5CJGArzB4R5aDHFpdDl66JaQQhpz2OgsFaO1saSNyVDmHJwOwobpWkHCSavDsysE0ePQyETkbr97Hm9yftATNYbWM1vPc6PtuX2OyKqYfdOLbh3LZ9SgeVDpMpD5Ii6WHPj4Z30ys1v+Jjhubq2NKABQqTJRBZePj3k5ruKcGmdVxKD5ZOnb4oaP8LrUxddoV2OXHtze61YP2MQiQc2ml4Ttdi4DsHhugSKczWw4mQTQW8v1UsK3SDJK2vHQQh2k1aJqHXP+WLzo8IoSLES24laVOGAC6jcmHmuyBZRo2xuowIPN70NHSJT43JyiyDX6zOm956g5mt5KybKsflHxMaXRW5eWxo5C1lo5/mTyNbefXQOhqvTFpszcK90OLqHCEoPtesZPUSmfUyfFJCBiPrJytUjYJCwYahuX5tv0Ect+rInHZJBTmeXXnh85n9+896tVyCbHxTRvOC+6n3kGdfbbQoMgBmbdu5twq3reyeR95+igXVY/lyNrKZgJ7NRmBbDyhha4WXZGFr1OlTTY/SiWYh2Da0KCVdDaz2zla2uEqAwzgjTjuDTwRhDK6yZwpRVSNG72GBo3f4SEDV/3zO0Qim0XCJN95+AkD3hEsUaWjn3YXdvaHmjacfQOtQe8W2+M/grAnRAcl2Fk2MkBfic1tBSFOJI16UwEuLd0jC0RhUoLfL9dgEKmej5p4HmuxppaAu4R1dJjqxyBZ3UMctdDY5YO65GoEhAjfbI6BudqF4B2LHW/mU/UVYxEA+J7Ro5y+3WM4hsyZ2oRRRVxvfjFueeXj997SGd+yccGBh7RoyPHsQuvEM21ksdpcCxZY9oTLRdJHdv9jqjSSPFuvVwLsHi5obPubdXREfpaRiaY7qSBarMvoM6uXlQN6KXTn6rzclbA6u552vO/xwDq1NUYsFea0OIlznzItw1bzjj2e3nTr8D0mcNLCLaaMYFoEXR1qt9hq6BZUp1PQaN6t9tW29Q+fmt8YxF9Yr9eZZ9Ncs/o/KP/sX/hYiEDG8NLdN4PnKgarsEFuSMolXVsWCbkG4DlwblzkTuBLlQOQfCiqO8D6RlgZHVhLQnJUOWGCiTgzSxWKFacuz4yB31+m6gnGrU1OWbmeb7QRaqgeJaaLpvF9oEW0jQlxKIpvtESYwBJQ3OK+ufkBiqFjYtNWRcXQLLQpQ7u/QQOCKUYBBF9tMDPRSouACqhUvVG2QhEGCYklpXgydpE5EStQOZRb9QTae0LMyTWwuRCLiWwO7JANfgvLKPH9oyxZFQ5d5wZelksGTKa3WBgYyOpXI98XfDM7+Dm18x9+nlp4FGQcLXsUWjgEDNt4HiUt1kWjJRHtlQU1famSis0giFpDHYMEnXwgjQQpVEnqT9ExsV1oABvytDeV1eR1jZcGwM0yiJtZPkdhxCE3iRrpwTkjXRaptGR/YPS2Ge1EpUhrrQZSwGmR8qLkTTO0Zu10vbbogwjHOhnAINT5k/n4XwrkK2kd0MWEBAzjfQmeajPCUh+LdEZgQI+AW5JrkvLULRkLPR/10k3vXKE8C8VOTd6215Uvger8zWy96rFOZf9egAe5ssOycirU6vqLq8vVaunw2ClttzLAl+GKgsCyMsIIqvq7hGS3s9u9nutIFKBViEBsbHdWIhzNmR0U0blMvIGm+Xk7y3Ha6YvJewrKpN1RCse2R+75qWAJEySnqf8yhIkHEX2jqGsEFLLScyzHmLDHpqxzjU92moIhYlLWjH1KJ4OjfOC88906zvSgMdrIFVihpY5TK27XxOVMZE8SoaWy5at4yJOb5n1mHLY6RUCpXTUN2WoBEhkwmMrJ7b3PcFaUfYGH9e5d8cJIvIQMxuYpBGazW12t1MKEyaq3n0qgtNr2GutUv8HIL8i7Vzi6G1XuDvt4ZWBwETiFMJyp1dHgytuFKTz2584O9vf82fcCuup9AaWPrc/G+9iUw6DluEzPrZy7JsXRI2pUfOLq8ajLehHkOkxs6G/GmiBUsMm7po8Zo8pihZ3VQzzOtm8dHkvUgOvNRFtvJ0Wu21TeJp7WP1uzxEinPeSDOcHqpmVpvbkj8vvxEjArkQL7AS2+eBC8xG1oGXh36AZM9QlPepl4B+5YHUJUmlcPqaT7lgUR+AEgYRgsgn/y4GjnH/lQg+WYugqR6Yl4jQ67o+V/jZQyk0vZONxGVTbSohKGo4PME1K8aFGW+9nW/zHQIRVKW+Hbt6zlFiaaItx4loF8HqktuJWq5Tb6HuoTF789Wn0CnMd7a+btcfwE/zZS8nHxa6jeGGRT8bgyu09fQK8dbAsnWznEkow3tD0POocI8d5NDO6c3349CPELeP5vPmHWmngU/s5XGGujYVSbaM45siLj6sZ95lli8nMWpO9XuXwqY+XNkYWJsCF2opql9JRBXU+FTKpw3vjP/1KDdh/W/be/eg25atLuzX3XOutb5v730e914g+EiIpaiJGoOKmoAg6OVijGiZMlgmonlUpYyVshQUReMLCQ9RYmmVpSYGk5hoYakYvJc38lBQMD5QUZBEhSD3ec5+fN9aa87ZnT9Gj9Gjx+y5vn0vd9+zzzk9qr5vPear51xzdv96jN/4jViP06a2rIRGmehv70s9adg6p9az+RracwOyhPEvSDX/tS4mI+njBH+aJXVbz2oBlJt0oy4euSWXwsdypZBxMuEYLnIrdd0MsOJsuU2OC5OFd0E4HyzGyF4qJu6Oj+jmvnpvBlqZ/K6zzVwqoayWpcHX+iLMGzMduLiOV/o59fVnnlllzHsKDnHwK8E6EbIzmYgr0/0/g1ILTLkPtkDLgikJGbZBlfzGlTDdRrPy+Q059MXyBzzocwbf7kl7Bz7zqLRXiaUJOFSoRUPpjfmsbL5ysl11TszxzceyOloM5Owr33fDzSLnp72GLf6XZMKqYwIlfLlqGz9Prl5vuqbQx/lB4dGtjiUE/va+pU4d//YbHiAGjlHdf7okD1DuzVUtUjY70GyBnpg9DXHZBilbpsCEU0Khl0KEF+sTAmvAZtZ3Mnm6MAjbUJadDGt5gkv7iokyEZ8qFJufD5UxWbWBP69KqOV7OKZCyrb3Bd+TUgrswjW0HkdzPtUYxSEqbTZjuxXW4lfn1iDJWMUrzpZyeLAqlQaUe9uEVyUcPAzbGYtajFub8XzJBJ7729sszcAkeAaIjRAgX/+4D1WmPI8jIsPBXiybNGBMJva+TDQ/0pmELXvNw4Xa3vkv/mjR0DKueh0KdPNSygUeAXgHjzzY7wYJF0kIagyAhI1oAHYoHVgRIM1fgVyXHlT3LgJSy41LoqTggGPZRg+OaSBPWYSXMiTJZuMsKYcJvQx2afBZoXzB+IjadoU8ML0U4CIBrTCVh2i4iaCwocP4ZMZyPSIcZ8SrEYHds9NMWYPUcHp1ZXbDruOUtX9cUO2UhygPGgOVVhABVANgIwLgMtjxDilnF8WhzJa1fgxdMz4e/W4+C+L540SfT5wJlAGAUc50uYSPcHhQgJZbEmUz5mxT51wNBmMigJxA+xiobcuupPCn4ARoDfo3z+bnhN2T4n1KA0QDyiWIDtayyyGxPZ1zHOm4aQSQiicnGpqISIodGRhR6IwJ9sOJsvgom4+OxWHJeU/HYO+ZtNHRfsI50jkvtE+/JOgsQM7OZEyyHDyGY6xCiHF0CDOdj59S0eUychGz1GNcD2rzVfn9vKIHBuF4McBd8rWYKTR5zgV0pzyhYO/mUg9ebFJOJ7fPzQlp5+tC09pLqwdpC7C0dIEGL3PNW6nM0iFMmG+bC7U9oXLOCadLtm+peWsQEGOReLATEQ4lpVh0vIIrfbEGJRpgWX4R7YyOe54KMEKZ3LEuF5wvfC/v4Mai5SR74/bzb8rtAkro14ZIZVJQ7oekBnHHXKLduK50oc+Bz5XbaEJ83Ib8hfLsq99Bhy/zeUjGsy0abSWDuCnsfZT2E+8oYZB9S1htiRXAcnz8VdmkTCUx6v1VpQAOLY4lyzF5R5+XSFm3rLM4RqLhaJV7r67TWCYQ55cIIHJCEJfuSd6TA6QFsOwzIs9PvjbzAizxuQBYwHPkyWJbXRgLtrI5o80i+h7nWXg5YmamkoKvXcfyUPLO6aWo1eaZfx4kpgccPvRY9pTFtJrJi0fMV6/WO8B8LB6wRPAxA6Th8YThdsH+FQ6JYWXhFBGOC/xxWQEAOohJz91wv4ta8JaLVQnpbXkNBGztaxV4K9NQwkzmd83H9sYjVbejdKIupbUyt/WM6GwxFM+HPWYzROTIo2Kz/baMfx8J//G9lMeXeV3CS45zlwlQMmTxWUKHDHroe8v7crE+ziVCvdYc08YyDrKPvepEUe5jq2XVIvdP9/m1ffKDAKs6TBhEdJSW+1sOa2x4SFISHtZqEYMuHrzsvcTfL6qTB9aZVSnRJEU0oS54a2Iiz8yGt2wVWjPPmhDqL3mEbL09Y1sAq9VWattGn7BVV1C3wXowePAWb5T1rpl9MWC03iy9jU3tN9dG6qVaL4kFSnd4ki6GqXR7gRVHWLykuzr7e6VpqGsIMifJNkMfg8ER1HWwfbusbzxq7InbKL0jAGs3KmFa5rZkLyNrbXEdQV/38Un6pUATXAP+zw/K2Mgi1vx7NcVfqwvBE2FfteF5AVjAc+bJYnvnv/wKfOa/+VvogyUGqu9EATvfZP7mDKmJdxjgkMNzmZwXg+poFwY3gQZdA7R4kJivvOj9ACXUsvLCJACg+mHlu+LdSTtPzOmYaPYEYHxEN8SZy+TsPfwU1qEv7zDcUjgnjk7AnoRsQvbLOcAfF/jjjHgYpHYUAHh+kDQXIJWbWS5t8MQH4MK1rU5HeDcR0dUeLbroCTF4AVCpMbPl4r7UBrWM23GcgaA8FNpSQoKngT1zMty0AAwaZor7CxBU27tpIY9hIm+lFDnORGnOgEnOley17NlxC+SJkQ7EQUJoFB7MHqd9Bjt5O9GpivS37F0huRdHHsIZUgR6uWIPK3ml3IwqrMhgajiiiLE2zC90zYmMXsDW7lHEsvPZm+VLmKW61vTCKutp8Cvi+rJziJnXEaacgFBx1nggA6YszcBeu/mqePeSJ5AaR+DqPeShZUFY5jAOT3KHfjuRZzIntriFjlspQCc0C1ezlazUDNZO6p4DyLPhVOKNAVpJe6y0iKYkfXjyBjU0oJJWpVa8rErWQWsPaW+KXk9/7101gZJ98Gf2ULHxc8nb8vWQ38sM5HLh8nIGB8MApAh3ONA1kZBfQC3h4Mqgbc4XKcKNI33WHjedORez16XFnWJulvbU6HPkfeXEHHiqa9oaVzaBlP7OJgfpV6OPVYSZASSXn7UIhFHuMQDi9eIMwnSJfoL8zGsyOB+b27osBVy1uIScyKGkQLTGloQUtzhk81J042JaaZQlRSWIh4Ax0j0f8+bL1YDzA49lTzV77/0r0nj0D2/Nibp1vyQXN5VnNF+L15robu2582SxyYWyRDcd/9YmM07uEHPHqcQoAQgxPBp+0NMU3gXIEzFfkTL3KZcBmaUwcI3gxZW989Ur3zDhNnOu8kDCKfJCDNwghw83EcNNrIpNW0+a8NRA10Ru/NHMPDd4I24YciYQIwjFZzko8JbV+Fu8mjh6SSRY1ZGE6nx4oElU0kg8SkZxe82JQLW8WWtuSaXcUMOSIUJzu2UAFgBYXpfRYd7nkjH8U7O0Q/a++Lksm+47LIf81/DosA25bxmeoFmAOqri9H6iUkzhjFLDkHedCEj5JZUyOjEJgZ3vmYoLZ4UgN0yAfyyh86huIeGDOfLuJp89Zgk433dIoSa4+5kAFr8HMsBqWAWwAFRR44bHRtTuvaOyPyjPPxJyNmrOiDxOOVyvAJY2I+jbLF3T+k6DL51dqPYl7Y9RJFX0Oa3qD176jVIqXqpLulQV+FDeZn5va5nyMv5slNkrXaZhgC7DA6AKFbbMXVreap82I/nAHCBaVu6LlnByPAyXgRVQuFdcjFiDPO210ftwjo5tamauErG0DlurjdmYI9niZMm52/PQv4k+ppwX97PZA2VFTAdTE9eEoG2FFiH7574+jl7GxLKOw3I1SN1d7g9l/LDRhNb14BCvpgLk3/l5A1jAcwyygMYFs1mH+oZWVgGtmFWh47pIbxx89ghQBke4mVYhI/ZicYfNIRYWTjzfzwPNjl2itaerkFnMg9ECWg5N7R+uHxdOSwZWpo1533EXsicph8WOJstmNA+NBVpbRF2euV/taz6JbWfm8yTtzePTXWV7NrYF1CwY9Wce9LgjsF4qBlqnCW5Z5Nytpw7I3qwL45RkKFquirk8swFMkmHHtyWPpeYnnQx5PZhC9ACwewiMj2m9VoiYv7srjMnL+ZXlKDhMbcsArba3ofRs07UHUg2wWsYe4HMjJMgDioi3mijR/pXsxXrUqEUGrEPWZqKxXNMOBWC1vAI+hx+9lyzV6hhSP9DM4tm06OaHYCt9rLsEOy8ALKcHHf09h1JMJtp6RbPcAioGTrb0TbYVGLy0zoY5yyXT3jag7TVqLS8HrD/zKfHqpl92thhxy7yvswftb6I9U0CZbI8G7Nj1FCCr7tXG9VyVCTKWxoH6+y2AxXYHwCpguw4/u5MSJL30e2dpBrji2WJjvb3dI6r3ugJYtgIIm71+efnzFCLU9lyGC7VVocOUCKw4ByAW1/g00+xF6au4aaFsv+xyd8kBAxWzZV0mIuZBSpKwpgnmiHCmjDBvcMpwSzUFlx0AGSw9EXOv6YaRKTaXg4gZGMUkfKA4BgF0onE1UObbsifynz8V75tLQFoSwk0ZcZkgTmCASIZxF+BZk2TOYGNekK52dP0ycTHln97xdQUg5EZNHvWU8VKVoVHLNVjhjqFoLNXk9qqeoMvuBGUV0HIO8AlY1GcmPXpQ2FWvO82glUGu/HkpOQnckegit2qGG3chhxCL5hODAz5vBtdxoDAfaVQlzHsq5EzrQgoXz1dOQoN0bKwI7W4uYCmcMqAPDiFvTzUTywUeHhPQ46xUBiduUcDWkXeLCfDJ5RBcKMfyArwKwKo0pzy1W4uAJudkVjof6t+2nJDD+GSpJCEqS8CSleZlEwNEw4nkKu79CDVy98pEiQePMmjOXizJXhooQYFTv5erEW6JmB/s4JaE6cEgWl9+TuUejQm+xTPSZVfsQA4UMM8cHjQGOksMt7IhQenKAeswngkVSqgv+Aqk8Pe8Tx2CowxFA1ZCoIfPOwCZ0G61rUIoYCrFNcBiIrw5X2kXh051cWIbovLkCXTO1VmDWU+rCrfJM288F9o0wPKq7FkLYPFzwstU2a9mmRyt2aVDbnytocKU2jvlM8He5THIg4YFtW7i30ifl310YlI1Rcv5JK07NQSAaQ7jAOSyNmleykSk5T1VAH/F2RoCEk/CnSv3ImtjaS+WFv1U1U8oMSVKhCaOJDFEEY7ioPBzpozwBJyzEXXZoNZvwMvm5bn0YLE9154sttUF1A+0NjuzXc1S8o2iSIKtwUIItXPKNdLq/XAK/7Kjv/MLTtS5geImXfb0F4PDfF3jWT8tOZMwYjguGI5GqM3VxS9FpJPDoEobivZX859k1sSDRk6tlWvH++UHyab/Gndsc7bmKJNFeG968UKeQ7/EledN70On27ZmLCmEwrNjs2Rcu53UjzN8swbhPY2Fp5fsucYkNQZbJoBrXwMHtuQpVBhOa4DFXhvmarFHibPp+B7bvz9hfJiwz9UAxg25CAEpZ95fPkfGypanLZmeyBOP9v7YWiGKlMfs3ZOIcI4Yn5h7OO9juqbrtBzas2lOBmAhVwZYbMPjDLCE8G6I1JyYkktzrHTreEJsnVDBw58WmhBMS0PLK9V9ypYXySvgsdL1idthrpZtkN23sg6lELTh3lQeI+fL4Ll6jvOyrTay5lWKd5+DVYGXyZuvwKbIxVgvyxaxfcuLKMAkt33LC8jesS1vjveX9ZR4gtkCebq/VF64FcHeUBs2pUKMtQBWZcwN2430tzcdDbfJhjl1+3lynbPHW7IOWqMSJkyI4JGuDxXAAlAU3oEc4chvjWtn5Y1vea40T89Mfp5ngAW8TkAWcHfosFJZj0lVFa85Wjz4b1ZGzz8oc41kcea37B7T3/i4DAoAzb6new7zlSt110z2lsyulIdAm1sALV5ZAFFpWwqqPl++iZ2pFcfyCpL9wdlztuaUADK1viY46pkMtyel0nHwtRG9ohKateYWw7fSy6ZInU6LV4A8qFrXse0w7tADovPUnixz7VNCK8NPOgDuzxkMnRlo52vIYxh7icxpskeU+Uj8maUJGKRJWO+Wj1P2EU5pFbJkG44Jfi4hSznunLlYaR0uB/L6LoecG4Mo6w7F4ApYdsWrNz6JQCJvrJNrY0FQrkWYyj65bUApiD3nazPlRJDdq6YztyFkBsUShsn7eZDDhNesu5PbO67v2zj41T3pDP9KzID6lPI10+RubTERwOA/a8tSPGIrr4tf/8GALX3PSyafzY7kQb6+ZmUf9rO5wbYGdyvXYKkcS7wYRgJQ89q2wMZdoTvTPpm0cR/ifbPGnowDd/GwgHWWYC7aXMKpZpI4hPo3Yy+QpbcY+ZstPtaKHgNINQsA4sXlRCfh9No+cgsgsuni0C2i/LwU7TG+tvoe5O8zv9AvUbzFugKIztZmuZb9+45lP/ra39Hmd/7gl+N5t+c+XKjtnf/yK2odLT1o5PIHcFTiBs5R3Nh7CifuB2ABUsg6HC7QD+83Qh+MxpG9XWcOl9D+i0fBAY6UucMJOL3oi1hlBLADkHJIz9Ns259I+4OzsMLjM4UqFVGwIuwvoNBnvkGpVAmFHmNuAuCReDDJKrpu5nI4C12bGOFu6GZOAD0MI0mGV6nLwcOdJgojQc0Al9JZ6BmaQyTQoDvcrEsW90FAnngYkLJAJM9oeTv1G7D7PUA8WbKUO02t+FxxGPJ+s4ZL2rP2QV7OeC2X3on7Ibvyy08KED+O9Kw8heS4D5oTKfBnoEWq/Y6uakrwWaNp2dPvdX4xn+aRPFjLgWZ1V+/J90kGWuzdWgGtU/HIxAGcpISgxg4uQ+QV0OF7Oo6OMh8DhGMYTmkFyMQ8ASrRjsr6WTE4zPd8zrBlcOlkwEq5KOyiimBrDy+AzCkEgERlhJYEDNnbNwLjw4TrdxdkKXINUqsUSMj3Q0oy0Cz390BKxL+KSYUoyjWg3zC3h8v1zDVwAmgQdVs1F1fAS/0IjSxCyczjEJ0qr0O7S9V7xzN2HYKyHjUosKVn9SqMT/ysBrdJt1/3ea0BPiUBXRx6ZGDpXM5W1WFT54GUs7y2+F/CYVPt0KE2Nl0LlkN281KAQIuPmxLKbMhX+0msladr2prrkcahhIn1cfJ1TSYkVh2fv+fsQI6aBNqWQ+6O2yJ8LGpPciiTiAYto74/jbdsDLmsnJP3/jRRHx08aRsez/V+5zlnhaZK+4queaQIR+LJWayFrZXXLu1HdY+WNs4vXwERmO4P9IyrMK2LuRTcGRgfL8VrriY78jtEpSHGy3J7nlcOlrXXjSeL7Z3/4o/WD4nV97A3pRD1cmedO0X2vhQ5gvrhL1IPZbmLCSETh/cPMyk3g63hBnBzGYiFw6PE8ujAuXkmm8RqNdlZt1ZXp/3Qq58WGhCNu5uBFgmxDusblV2+00zvTSeX9qSLwoDVLncpCbBx8/r4bqLacr5BJqbzRnUeK7vgTk+7Ubx6zRDBEFQntl7OVQC2i5DS77/yRnF23lIy9arN2JNycJWgJhtn0Y0P24eVUF9jW9o+gzdb9zAbC6ZycWa24jnKxznVbWe3vrj5TXiX79HpQXtOJpUHzG8lmmHMnbXHnerX3aN6v0KUbQ2oKIMMa7LZkLxIM8zmGeflRj9tU4xSDrgFSjfcizozT9ud2lTx8uentfQhbsftbWT8OVeEQlcZgdxXbGUKMgeslYUJlMlzS4Wcs/u2zF0ui5O8J8/RJc/YRjgwjQNNQoeGd4jbnTnBK29USkR5YDBqq15ozha3Qb+a9y2ABaCQ64XykHe4pTTPau9W+0qNo25e1rpb/NtpHhZQQsFqQivq+yjPHk96Vpp1THu5qbOAkmn/6w1gAa9DkAU0sgiWSH/ZnVkJ06Uk8WTh5GhO1qVYfDAekmwyaGUJhXBLf5tmn7sshJrGXJw630AhD25xINJ93AUpTK33E3eeshBbwEctX+7V8XnJiOHr0hBUlJnbpc5oo66bOy30Z64phxHDcUY4zlUYtjq896tQpP6+tYwOnNu7Bdhi/mtREpYSwmyF01xEE1ABJNcwnNImZyucEgGLxubhVEBTK3tQF81uhTHj4CrP2noHaB7XLRp0NJYnNSFo3ANEsqf3lOSRD6cGD74PJ1VvUQMsyw8DinwFAEw5GzA8KWizyrZSx2KABajroO6D6tow7lYgtBoUuUPfAjVaxqQFuDSwbz0/GcSllNpq8Fum+Fat4zrtLWplDl74PZ/G3JBlGbbA06Vnj20LWLJ0xRaANdSBpzL2KlnR6dZxW4f0NR+2aTzm2ENnr1VTsmZU7eG/anmpV8jteGrjPv2CUDSANjcre4yapXQkNOgugu9quXpOeIxs1dQN51iSg8z1krAv9+2pALbXE8ACAHdngVGyD/Iu/8iZZB4CdSeiiZCM7lV18xRCcdXyjFiX3Bi8yClwB++niPkQ4JeE6V4o3CuubzjSgMlp8qKdxNmDnlSrOQwjaJ5nAfl4p5fGfLy8H1bZdgTwluylCqeiCg+Q8GIanCznh2X3gRPCk3PpVJivpkUW1YNX66LUMxW+fkAGi2MgLSorwJdDRxh8eWgViEn7UIRANSE9ou4krGu/ChFDQoDCd9iqU6ZnixFSmJQ/xwOTbvNXXBR8H+j33cJvo6sU2FnWgb1WKWRFcx7/lXdn9ygVb46VUkjFK5r82kMqXhiOjGaPKmuuIREgKjNH9trk42UhxpXXijl/CblINl2080s5e290mA8OV+9nwdza8xtHAn9cQoelG1h4dbxNOWGANji94EEZkQnL3uH63RHXP1pms/42l9XwHu48S8YWQN5SzgxN3lWDaQqOSiPxdYw1V2x4MiE5h3A7wZ3zReHnIWZeoQVCNtGCs1ble3Pv8XrKQ1YBLKuDBRCf9NLgDqhQWBEe1fuXz1ZImMM6Lc+byiRcST0Moe4jonrWtIillbPwoQ6hVhmH1LdIVpseuJkGANTHtfwfMxmU/p1Blurb066UnUGMK8FnW1JGzp29VHze/F5HUFRoUtTOFf8z7UP1XAMqcjFFWi6eJpR2eSWMa6gOkn2aAYrVFnTm3mtmTvL58Xno8+KQaSsZJF/3KjqS38frHeIhZ/heF02W5eBL35rLb1G71Bj16i1d3/NUrimHK2N83vlXm4j4denJaprUYVLnqlyfXCMKgKo5ln9orfgOyOXy5yidNVBAGIcAC/cqg6E8YM4H4rDwjS7hGG4Oi5byc5f3zzwQBnUs9sj8kuWQZRrywMkz/vl+uZndnErIMe/3/PIey70d4r088tsSGJm7VLlk83WrOBGrzKkkWVnWyySk0jmuNcKQvV7TUomm0sUyK9qHPDhaR8KmeTXupCxhk8GF1LRL1asc9lxzf/g3YyBr3d4CLsx+guE5idhe/prvGQZFwosyp8naZ+Gcmh4nvke3MvaWXfF0aRPgNrS3E10bFH0pawywrJXJRnvf+0fmnLPxNTy8L+bt8/PAnl0m9l7V960AYx64rMYdT2ZMc1nUNNwYfRZp0HpG3ly+ZarMibakB/GWtyGm9TPGZpW7N2wVwrNhIsOxcnlwvHM78fKZQVkGaQOwhMdpMg5FEmLjPG2o0AA+KokWVr9BBbD0K5+OqW25si1nA3PqGuHKNA7kXRyHCmDpvintwyqrOYgMSaLJnlBUuG9pA6yqD4txHe5e6r4OuqoAsKKMNM9Z1+HUSQz6c+v+9x4xZ/fqSEYaHJaDlzELQBNgxV2owTQDvEu/2evEXveeLLbP/Em/rdwENr7MswvO+uBix5xdtx8r5W89M44DgYv5isjP0z2PcE6Yron4PN3z8FMu0Lsk0STaPY6Io8P4OGI5OIwP6wdNexBSKGVIWLTz9qNHLKMT0UgOt7hEXjSAvB9evGXMNaOCvzHk9ktNxIhwihgen4lDlQvrYpqFGJmGQEkCQ6iLlkoHXQ8+VQiHCZ9Qsyg5wVzwM647A+FKoAAlFzMw89ShaJXk6hj2IYz5+5ZQKXeSeuY7qpkak6hdlpVgQvU+KI8mStiRb62FZB4ofOckdMjll5Z9fp+/Hx8Xj5Jf6PxYwwmgWd5wS1mEwzFhPtA9MF3RfXd+4OEiMN0DkCAZrC5S5zU+ThLiTMFV2lsxEGibDx67x4uAjxQAf4qIe98UNz0/8MVTFco9KeKzJqSuPbxxdNmDm9Q+iBCfAqqyQvtXE/avEMeQ7m0eGMu9r8N7fJ+J7p13kiCSgpMyQEABzcNNrnHKA50GZjk5hL5X3iZbeBiovB5pUiQ6XUQ5c5CqWqAxQtcobGUXVkWetaeE29AICToO2WUPUc3p8W1PlT2OHURDKM+MPYe8fuJnKzW252Or68FaX5XGl/fAgV2/drZR+mXZN/cB81KDK+3dYm87e7Kcqz3f7MnivmI2IIy9+EssXpr9CLcsiIcR/mZCvKbXSrMqOLg5Ih4GuNOCtA9S5swfsyd2jkiHgdbblXHITUsu7ZVlRSytokpaWEcIRMNKeFKxXjdu0GP4Hl8WpBjhvCeNrQMlk6yAL3uy+N4YB3recv8ZdyTuvVyRB2/Zl/6NQ4d+ohJxA5fLekTe63g1wt+c4Y75+TxPz7sHi+2N78l65w9+OdJuLLpPACp9FBXbLeq13EHURYaFozNT4WXEhOE2rkI2y45S2CWDicOKCwmtlXBfeTh0Wqs+XsoAQvhWoNDPdO3p717+u/aVHlHcOcSdw3wVMF8FLFlF1y/lpqYbOnsn7mctISPzkA75e/4c/LaL+UMwHQJcgbA5ArPiEkgnkT9ucLjqQUJ9r1zN1XoNcn67re1SPAJAYg2SRbhUE+JTCRlW57KgKpkjBbUHB5dKiHml0J5DzsyDYtkDf6ZOi5XX2eslxaKlfli+BPnePd8PUg4KAKKuhyngpRRvra9DkYOwACvuciaj8pSJB9d0Q1oe4+r96hlhwMl8RJ4MWe+FCbFIIoYBQxZg8ffN+8r7GmCp9e80C7AAVBl+BmDpV7aVHpb1zG6ptVtJBSsdodqRlqh0s1T7nENV/aGluK3B5dNypRhEsPfMnmPIWZdPA7CUrb5vkc7VxIztImdJJDPMfZ3lEWIuKRavi1xCOY8CjFg6iD314rFXYwtAXh/d13BClmORVP2n25jlcNwci4aVhDVjAecKjFmushhnfyuAJeu1TF9vBli7Iv0jSV2eqBRuKeMQkAFW5hQvh4DlEBCvRgFYAERO6HUCsC7aGwZkAUB8gVQNpdyBqXa+yjhrpDVzRoQ/L3U2UiQPwXAksCWZXrvS0euyIEzulXCRCTNVV965FfDgmm+8T13zbrr2WEYIQX51HUYPpBLqku3uDySQesXXxXROowFe4qo3108OpF5jXJ/DhbCKVhOvvrcdoHah6685m4a9XMYbtiLabpRo0PulDmsNvMJpWV1LABhvZoTTguGm3WnbcjmcHMEhRdaFWqmeb4QQGYBx0eTSjiRgrFkb0WFFouX7UYBW4jbmcGkGkUVGIrv22SO78dOSphba2ZeewB57uth2jxKWHXB4P2cAc2dchymEx2JeZf/5t+dwYxr8KjQJkBdLBjHb/kl5eKudp/qVv7ZhM2tS4ot5Siaszl6ZFvDgiaEBVly8t7kNrcCNy8e0wK32SK8AnA0dskL6Vngpta+lPpZtq3ixbJ9sTcporb3jVdsbAEubW3JSTgtgsWfGcNjSGIAhSJiagVW8Ys6q8rxD9SUS1mskFgGF4mAmKAK2WvelpjnovpCzxJec9DWb+8yOcTbaw03L3tikJ9bKI1itq0K21Tk4Vyou3BtkciNh+znRn2kLT/C4niGfq9ABXuf2hgkXWvsln/SFGF49Iu4G+JsT0n4g1fPdSK5hpZ/Cwm7VrCS7PQEilLPN9wKma0+EZlay3oFKmASanYczDYjDMQIJGJ4sxNGaYu74S8eclGvfRdL54QHx+JaA8wP2ktB+k0MpeZLI05GCw+7VmfS7Hk2I+4BwMyPuA/xpQTyQJth8NRCZeXAYjgsCK2lPS+kgdEiuRSLn0J8K1bhlKarsWmCPd8kdtBUANWR5trpuFyoPF4VyuQNBmamlJFwF2UaTZjmsAdQdekqV50uSIK7Gqog48+iWnUc4EyE83MwUnvIO8yEg7hyWPbVHeHUHh9OL7GEBdg8zgJiTZN8Nt2UQGY66jEb5nQWIhewxdaAQ4pRwfkA6U/NVAXbDkbIewzmXCMr7HJ8Uj2w4JQFZ4Rixe6VwlJYrKqU03cv3zM5TKFpLkURIqDs5J0rOyTnEgUKfySGHCwoXY75ycl/vHiYBlVfvmanyQQR8Dp0glwoq1RqyRyx7izjky89q3HnhNnFZD4BU40W2RXuu8/3uUiI5k3kpAxdrCc0zARD2DvDrspRwWVxQEbwVKKhEN+/il1hAFQKkpM4SyRvE3K2YvfIprgGW1chS+l2VxlaVmWiAjg4T8jOsea5zzfmpjs8fG5loVWiUpQQa28q+A/3GSfN0LLhi7hRAbVThQuFN6tArIL973A00BlyNcLcTvZ4mIXAvV2PJuvWAO9OE0h/n+l7SfYzRINMK8NXE0nBFKwqE9wT2x6F+Dfl75+pogwaKfE3PHBZfStk4Pk5KwOlc/5bOl2xS5jlnqoVw4fI1jNfZVZ+1wAAg7gcZL+PoSK/POBGY45wynWD36ozp3oDDu28xP9jhm7/+89f3wfNvb/xwYcvmFw+IV4PcDOkqSxoMoUrt5Qeg8mK4knkVFDnbxSR8Fs6YAoBImp6rkKJkVChNKW1U13CRmobDk1m8aW4B9q/om5NeySPgZN8l0ywP4OyqFpd13ncuRm29DBW41N97X9KKTfX4pAcnqFnblhyC4dJcrCTfaofqHAV08aUUN7UCAAB1EqxSrO2CbAcTZC0h302kaD7c5GvKQHlhcETfW42q4ZgQzkm8UGyRBTiHAjjkfB3qaY11RORjlhBibsMtg/vsfWKx1DlhvIkrDxgADDcRh/ecSxHmbFy4fMyciZK8wQNWbhqDbev8yCF07VnjTEyrA7aMDlfvLYRbfhZKeIOPxRegDo1VAEt9H47kjeayPGxujvVAjeIFEx4iDzr8ajIC+bMAllYGHTKg2Arx3WEszbAq8CxCp6F+9QGb6vIbHiWxu9TBrQdvyRyvBv9yy6uVmMP1tGa9L9Z7ZZXXG21f9UM5lMa/NydVJPbuX9VhQfH6e5e5rNk7o0VyBYA2+jwFsFbWAljqe/Gm6tcYmxmDaSAe1KosjuZPadvwzHIiREX4z/sXAdLDiHQYi8SR+l38eRHPP2fzbqnq6wSu4XbB/GDXXO/1bm9YkPUN3/67cfwoAlfzS3vxtKTgEK93RHbfj6vt4m6gPysGmk0XOR6fMMlYDQAgj0IMEK0PcYcezCyVQ4gcj8+CqRyaEn5O9pLpv3Islwdxqh/HGlQiO3Gc4Y+zFJYOXCNxSVju79aidkDRebHnvqU5w+GbXJmdU+It8Grus8GZqMxuw14rfnBl375+tftsASveh8nC4d+Ds4Dsqz8uCE+m4hnJNjwpv5sV3mRv0korJntxpvsGKLKX37kmGZ1LU+jj7B4zX4tDfRmE5RAfA8Tdw0w2fVIGCn+amxyl5HK69YorRH+iKi/cL/aCrttM6wHnB2uglXxuj6ZBybO21UmH6tiSreuAcEPnMzyxB0rNe1ju3VyUVjhTl3T0ePlWWR1cADXA+p4VUFVz0ehLw7FiGwYCV0MdwrI8qFW72YNrr60Gn3aZlmsAGgDU7svLsZIps+O8J8K7fV63OGn680Z9vU3bAn4yyc6eGY5c7JnonsNXZlN/nIVHurJAfC5b8iaNISuwl0lqs33Sr1Hoz+kQYDb5zoJOpnk4cwzNXdV2VHwGqV041PUPvaNxMnObhbPLnN6l7jPdcYY/0Z+b2s+OWxKWnDnvZuD4Ml2r6X54vXqxLtobNlyo7ZN+1ZdhvvIy2OxeOcNPERMjZ74XY0J4MiHuh6LhlCu6k9t4ABLVROP6ai4VLaDkyr5SAPyZdIEoDZ+If/4USXR0yaVlpqKbxVXiARq8GNmfXxhw+xbK8IojZIAab4j0vH+VslF2D6kUzvDoTGHJ41yyVHi/YxE4TU6lEy+pAJglKa9QDn+p9GTx+LE+FlBlZtFFprBsOoyyfgqhAk18zKbIaGh09LF8L253vb3W3JozR+w8lX1oj4IewDizKKWs0UOvyTnKDrqdEK9GyhY6DLXeFwsM5sHs/OKYgTCBqumew7wnbl0cHYUDZ/rt5oND3Cng5YDDB5RKMtMrREOrrJdcKQdFRFJH9QNZWXnnlWczFqHbQNct3M6IY6CwnKNanRSKLoBqyQrqMZRkjGVfeIDDkcKH5/sUtiQvFelduUih0uRzu/kZm6mgup/oGbn/IwwAo3jTvApfVyKnSy5xFBPpmEU6T/IgF+0dnbUUTktdriPys6cGtlzxoNT2nAlILAs4M88NQwUAVrpQLXFR9gKknE03Z77XspSEHGOOBzugeBM43CchwgyOlByDZCryZHKe2zwoLiXG6zKoYtoCh6usDMVSBvU0TbSfJYPLVvker8KYnH0IlHAUAClIDJR+hhNuDACUUFXwpcyW1dPTQMUmvyhAIhnNSd3r96jc2XIYau+XklJwUxSpFwFGTKEIAS5GyUDkMCWVucmHjqmAEnW/FJpDfk2N2roAoOkVOXzqYqKkJSavK15ZRYZfiCCfvCu8w+MJGAakaYLb5bGQw4J8TXnc2I3F2xcc8dty+NjNlCXulgXx3h5ujpjv72j8NEB0OQScXxpkEnZ64HF4ZcG3/+XPW5/v68venOFCNv4Bzy/QzXN+aYfphV25LLovuTciDU7ESCVTIhAnhbdhb4FwpGK9Lx4gpytHBPah6Fsto8dyKA8fz6QQUWWaDI+o0989nHF4JWL/aoSfai+BS3ReNmS4UjFXXhqeaXhbsDnH2y0hc5XVY0o5yDoaxJwnegCPxpNgJzetmb7f+N7YijtmyfGKP3D3zsoMUr9KlhCD0UYY0Qp62qLSQ/Y2MQjg0NpoCfOpiJneZRKmzb/3+NhIhJyjgHpt4TiXMDIPHrwvfg7MxMsvMYvg1m1jbiJQtLH4Htdh9OoUmbdls8IZQM1x07MpoI9LRrEHy9yv46NJJkzuVN9/yQ6+fHzNwwLW+k6NbaQ49B3q7as6gxpI6fVa369ChPzZhBItF+rCfb9qjyVHW++dAlhiVvfKGi+3YMG7zfOXkJYlZesQVn0itecN9PumC+HZrd/fn2jSoQFWuJ1KX3maa4DFxwfkeLpAMzLVojrvTK/QntnCF2uH72hZrCawQjwPgUCVAVhyDCOcSiFPpYOV+XBut5NsvpVsDyvnm2QplxLceVbjDPFy3RyxXI9EdzH9cdyFaqw85czlNwDAumhvCpAFAN/5538bAODmo+hGvPkYumnOL3Lds4Dp3iACnwANVHFHRZt1+FCK8E714OkMwBJdoKFkAi5KZgEAFk4F3gf6yzN3ETjN3JjdI9rp+IQIzS5iVapgsuKRPPNUulZJxdDdaSEPzVynEcuDn0N5yblSAoIzP/YD4n5QgKsOeVQzyVyCwi1L/qu9ZfK95lrxrE0PHr4c38WYw1W+1uAC1oM0t8nyajhMqNcfQh4IzKMxL2UgRpmJ2swiCcci867OBEB0puH+1VSFIKSmYHaklNT0ugl+IokInTEXjgXk6ZqK3iixt4CLlmJYWUqSCSsJAHkXwjfk/UQKkcpzwJeAj83eLJAXC4CUHLLhU77/Sygwf5ZanPleNuE5eSY5Zf52XauoGuD4enD6O7AmpW+E6JLhZW0CjaqBDs4qsAOKdxV45/R6QfXdDQNc8OtQ4AqgNQjlvuhTXTzOBmen0gQbh3aY1N5rLFBq28OhJ+YTCWhR5HTNBRpLpQ6XSv/BfVqVEKPPg/vBEOQe4P7OnWfyuOT7RlMDdDUKNy0rsAMQoEqHgf725Knn9sfB0/3rXYkUtK6pBrs6hKqNr4EFopK1aibCwdVcVr2cj5GV/Jk2IwCLs/Jz2DDepzRoqSRii3tnT15VJkjGQjP5Z+9uXvW7/+xvXZ/rG8zeFOFCaz/3N/4RjDekb7XsHPavRhxf8kIY3j2KEn5JoZQACceI5eARTpRdxmGT6Z5HHArJV2rKnQE4Ij/HoWgecf04F8nTIOGg4MTLEG4phCGZGjnEd3rLgBichFx42/0rpAA83sxwcyJ+F4OpOVIMfY5Io8owUQOsU6UmqpmhiLRSnUWXcltiFrs8G32X80ygJ4ucQocT9eyIjTMA+VWJhnJleThHXioPiBioEJV98Y7xQ57yLIpDhhzKzG54Dv/yzE4qzuv2ObfiasH7osOm2zAGxDEg5hI8yyFg2TsFIhNOL5DX5/CBwpkLp4hl50iLKh9CvF4z/bbhlsRlwylmsny+B/O96E90j3LGo5/yeS1JQFHy+R5OGVixqv2W/lg+5zgS4EyDQxw85quANFBWI0DAKvl8X/MttWevLX2e7hXPlovEx3IJOLwv37evxlxiiH4fP6UilxETVUNYSvYggJUoKRxNiNwShdeok1gkvLSoSQRnXU2zqgChtrE8GPZoi7eHt4m1V8d6eDhkZkvwIHuUdJYgW4ukbDxXEh7TWY9lx2U7gIjeHI7S2YWcQaZDkXo7vT2Dq5TKuXMoEDD8MfWe95E5Y+6wl3A8oACVJrPPSx1GRAZSLa6YcyJcLF8p6kPzehjPl4DszD9ypwlpN5RyS1qJn0WXs9gzZ6E71lzka6GzOXXEoArBUrtJhDT/vkxxGAd6zZmV1I4y8XTzUiYaDIq4dBjfC3MsYUn+7U8ThRnPE4EoFuZOiTxZPGmeI+L9HdySMN8bi6zKaYZnodCclU+/T5BM64pkr0Kly4Ey509vGfA3/+Ln4g1mb+5woTVGzzzzPr1Il+H0El0nFmBkct7jj81127i8jRZuzObnUiqlKiuSynJtQhTeexFkA4DpQclqkYdXtQUgj8XhA5F4PipUUrSjajf6SktKp+Fn07ytypYk3Cs3xeJ58E4AVwq+8LyE6GmquzOnwh6D+R9A4YHkWlWVnoqShKhCjvq9kqHQ51v0bBjkxurzykW/JcIaoxCk7Xlw6I09njaExaR0Nu60xpuI/cM12NFeJsloFG9NJri/qvh0QPFoNTJYgbX356KZrDk+L2fu49GcVzglkitp5Rl4kpiw3it5NlakZwa9JUQBlJm/LVslAOsSeASA8wR3nsrgumroek5ZyTBoE5Cw0ZVeyiy0WYJsNlzHtQat+KbVtdoKjzNfCypUyCa8so15tPXutQCWNv0820Ws6t5SENffW4A1NPhrEQVoPg3A0m3S3nUFsABIeLkCWMoTlkyfGnfUr6VMeBevFVCERo1+lhjjcAWw0uCLXqG+LxhcLbEmwvM12g3U3/FnTXZX4qqiIcnkdj6G8rKmMSDe32E5DJjv6ZJtsSKz26SpVf+iAJZe/gYEWBftTenJsvYpn/klOL1MN9nxZeWCBmQQ5ywu9jSwV8pPCdO1l+/P931+dZjvAcOTIujI2033HPYPS2hHyMrBIZzSatBcDiF7KqhNcwZ7x5folQepw6tZGDPvb/cqE3nJg8UzjCK7UDqkSvF+Wi5ymeJuKEJxvh6MdeFTbTobULxLdvuWOz2HC5IuNA2AS+g0Z7gR1OFkUqbOInRaWNGUX0qjKiJrOE9WXTplWRDOQGKBwkl4QxlEhwxGzbgyPiaeUxqclEkCiCwu2YFcUklAxFK1jc3PUcJp2rjNtjgtex21wCrpmpkwRij8PF0f8/zAk7d3KANKqaXoRRsLIE4isPbyXr2Xzmn/CmdkFg6hP5VsPTmHoRD92VaSJbe1ontZMQ+gPAPnrCpbk01rQFnSN1ADC83V0t5YNg2+4rIWN9XK7Hp/trYfF1nmU9GZiFy4Wa+vJw6aK6bv61ZIv2XsfZsMX80CyhY/i0HLbkf750Gds9QsYNShVOVVttItVaF3ttwXVJOjTMreBLkaiOnvtOkJompL2hN3a7mus9P9RKCKklIMqIuoOaxyUuvnWb6fFQgUL2zNv0o7klIQD5SmU/BxUby4AOqoAts4UALPbpBnPanJqT8uhZNm+lvhLUsJIz5m8eZ9w7d9wfoc31jWPVl32dV7qCPhbCcGVfM9Wn7z4xxufpzDw3+LLtmjH083FKefCmGZx5xUtj++zeH4Nlp++7bsNXuBsrLO9z2WnReBNgBSKoc9XMzzYe+XX8hbwAV3Sy25rOCdHw4mClNGYKlbVbtzXZkB61lRS3ldPAezSENoEr2fS3Ybp/hLqr/yphHHy6RhbwiTilcre9qEaJm1bgQoZs+P49DBbEIoegBshTPM+1WNL9OxCCj1joBWY/LupyxIC0gFACAnTXBHNKdSJmnVydOLVfX354X+rMfG8KsEoLj8x2Mqp6yPvub18fphLdWheVXSjlwfMQUnNRTZmOAq583Ol/xcsTyJAEhTbmQLtG8W6rbXgoGVTTHnQcuWDuFByf4GpupDZUzgDgZcWAAFEIiw0gxbxZI1wKpOqX5OxYznp2nW+8WmJzaNZyHNOcPSAiwGVitV8zu8iNjwqOp2MPBIJXuZAZZM1pRXu8oUZd7UXQBLNKrav7uz/YXqMxhgyXOY/wRgSSiZ+qUVwNKJB43JgNAjWk0PfhVitfI7FbE+5nJlHM7khB5dOipGed5FvkKkWEyfwlzJMSAexlJm6IqjPYU7GfehOfl7s1n3ZCn7xb/0izE9oJvi5qOY5Aec3uKw5BIo/HCPj+l1/2oeLPLgITyt+8ivxaMFAOFIr8MtZWvtHhEwCHmy6BaqkxhH8mpVNeAWStX354S4dxUwQ0rYPVwQd14EMdlTwbIOcT9UcXTReYo1gNGEeZ69VLOz/HCzkB/X7JKHXXWYlRwED3zZu7Ryo/OD79ya+M7hRnu/ckcjg+pSeBNQMzoerHXnwt6sfCxdpV46WWc4BuwJCB5xPyLtg5C000DK76QOjeLd2fPABJHyoGMk2Q6gbD1qcz7lI7c5e0+fEJht8mCi4i1JPURfMvZC8Tr5XNiZCtF6CrOpfZF6e5YtOQzw5wXTC2V2mwbAn4i8LxpV+VZgzx2T47lQNnOz/JRw70cX2W7/Cgvk8qCdpF108pDjuphKJi4y8HJuzcPKA7W9n0WiQQk6yme1nkguiKdLeWpaAIGlHuJCwIhfZf/Zc8ByDLw+UO+P+TFAvvfL8ZwFSVvhd8mO3Qhvam0u79bePGVJJXpgOq8Blh6A9XkocON2O+EMFX5VY5JneWhcmFlXbVDPOvPyKoA1zWAlftuOet9L20Od0spTRLpXpT8RygUnKJ1n4m/l5CEbAaHzLm3fnOCtfkfl8W9lr7JUx2EsYtq2rM+s+lXH950r56g4XWkMmB+Qd56BktS/PdZZyBVRH8je+EHGnULDAL7pm37nuu1vTNv0ZHWQ1bBPffsXVxmATz46wM/kkWJCL8/+D+9LOL3ssHtYdIIAuvFioPBI3KGANL6SDvAnwE+k1L1/hW7QnQoVxcGt6tpJjblTxLL3JXuM+yGt4RR09XPa0XwVMqE6A7L8ADGZEY48MwLAbIrutFRaWVqjSmah2itlOg8J+/G4pTsE7lTsjJrJvTywsOWOkbMLuS2s37IKI4pXZCObjDuHccjkceX5Ey8ChdWSIonG6yz74UuRb+ngPIFhDvWyQCifs59Txc8TAvzNgmXvMT6eS0mboSRGaA8eE06BkiCRRo/kqcyPi+oaMPjIJWds9k/cebiJwo9x9MJ3mq958AeYQE9tzsdVM/X54OS+FLB1xecFXL97Fs8XC6P6Mw9SXjS7+PoBqmPXP3/2nAp/hr/PwL7SHwIKn26JBEJsuFgXMW+BLA0eNHm6xUGy4AlQ3pbUBmu04/LeHo/vQaUzVZXlyl7fykunywCpMNxdYXoBWBNzEGuA1STwA8QPS6noLhmAxaFC1h+svG+6nTorjonyuv3S0FTI68GXkkjsYWSwpsGKvSb8mc8/5BCtc00NP6YpVPeZuX5AAWIy+eTjoOF5VdvL/myhct0+AGlveK/RSPKo7cVjp/TH0lWmPNzbI+7oeU/BKV0vGlfCccFyPciknTN+U6C+zUWa/DNf088Jf+Ov//b1+b2xrYcLPxj7lq/7fClmCQD33k031+G9iThWT4Ddq/SnTYdPgDpE5E/0l0JCCjxAleXL3lFGmneVOz0cF4TjguGW/jhUuLVcBs08ELJ0xHR/wHSfHsrhyYzlKsCfo4Qkl+sdlusdiVueZnrodgHxQPyrtBtEZA8ssjeGEhJkUKMfZOWWZyvgA1UYUcitLVIsizcyANN/2cMmasqc9aPFDC3Q06R8qXemOsgMwnRaOa1TgBOA7BXUnJEMaM9xpRJtrSU26E+xSRiXkjZzaodaFpqBuyVWIURJ0PBYa58BOcznRaakZVHqjOnGI2vJOQFXa6V6VOWB/Jm8viJ7ItUMeGCJ9StfHgZIAgTyYRj8cxjQ6MKt9IdEdkFdYMubuWRbxPZWiLta3AgTPc326nhN1XjNa9ri9DSlABQg2iC7rwCWLFgDrMo4g3DXKI+iAJJr/QYa9PBnBsgaYJkJWAWwWMTU+zXAsvIIFmB5X8K/GmBpp1sOxa0AVivM7JzqI30bYNm+DGgCNn62q2vJ18MpmR02LiVmJSfYk3i1R7raU33Wq8IrKwLUdI9YesB0PWC6HrAcPP3lvoEnTFyN5E0IsC5aB1kb9q1fU98oh1cz0Mop+JLpdQL2H0g4vJ8+X7+HHyB6uX53hD8DV++mL67+db4hfXmI5itgzsWCmTg/3Q8C2vT+SraXq+rkOaWPRDP4JEALgBCOU3A4vzhi2XssV0H2zwNy3A/ZI5MPl2Pqy9WItBvIQzIGIXxXKbwKaJVBDvXDHrP3hJueQ1PyNwbir1jVYZ71OjVAWI/VUjpyESKtPAON2303tsNv2jYGwnQH34ABE/OOKlMDnK13yNtx4oIt33NxcAXaBFtkUDXqMk/19Yijx7IPJcP1wN6xGmhZnawV0FoduD4vBlAWaBVOmKvWs0CrAKpoPhtPgtwrBmDZ39nycdgjyl4YA7BWYp7WbIiv7Lgsb4X6OMR4l+6W2c7ZkF+D1Azg7lI0W+cT7mjXVlhOk91bHiHtqTHhOrfE2sNkwAigvOh6MpS5nok9fjEWgMXr8qsNndrroMN8ctBSiF48pcCK88mJQcnovTWTdJC9sluADWhLXahrIFmMNjPaZ7kalnk4ZO0r1sbKmeHJPHul//dYrgcZHyTDngEWiw/ndr3RhUU/FOvhwqewT/6sL6uUrIVnkoFROBUi76B4VFGADb0ePrBgPng8+ZhMls+ker66+w+kiix8+AC9WfYO+w/MdKOnEvrTYnzDzVJpeiEVvozmzrAUxLLzErpiz4s/U4hSgBq7lcccxnJ5QEyFN+Myz0QyEnnAS0l4BYnlF7ifVe9ZX4U+pBLOEjL7UgAVZ/+x6SwZ72ql55xdWBUyFk8ULRM1cJPGLRlQPCjxMXNnTGCzLJNisvuSii1CnqMXzhV5ooAwRSxjCT1qLoMI/jkCDeE4V+AhDpn8G5PxCEDChnFH13S+Guh+vaKQIWu1zQeH8SZivqJ7YD54jE/U5yvS4ZoeUFbrfPAU1lTh59IeR/d3yt7TfBypZuCJNxMDlRSCA3avLgKghiezAgk5FONd5emTLKdZ3Wug6+O0CrdNXweKgGxUmVoxUbhQh5/0e9YNco5KjjgnPC3aqdkmpeLd4fCWAVqynPlaKUJ0tS4UdJZ9sBeHNbf2uZSKzsrTofqW54fbzNdAfwbqLEJdvofX16T2mGiCwueldbBUCHP1uizFw8SmeVdKcNPNSykZw56pcVhJeAhflD06LE4aAvw5lxablvV10deHrwdr9ClaQ8X70tvpbQDxoMuE0bviyeV7VqQh8mXRv5f+HflY04y035VQ96jAG7dvmte/cy4/xPd8GmvQJ30FZ0ePBjSpZBa3KO5loM/Jq0lQAr7jL725ZBkatunS7iDrKY2BFrtQGWgBZWY/3CaRcgB06CJ/TknkF4ACkhisxQAsVw5D1tvSwA0oKf2ipG0yQFbEQz4O83UM0OLOinWYrEcFQCa0m5m8kmdwOVSl9WGqWnGShad2oA/DYGtXAFTlkZCw0FyAljaj2l4IqxszRh2OAEq2jVV/5/3lmZ+Upjio0hl5/3E/iGhs8baowWso7nyvgBEDKj9FCQkuyjvGv+Pw+Fzao7xFWnaD28ztAIrsAtfZtO5/3UnS8erltkRO0XxLzeWWP0gZja7oWeUxnGuIukTJGcwz03zFlomIqvLsaT5Wkz9jQRY/G1PhIFZmvTKZQM79pEgoWP7NSttqA2R9MKaFQ1s2DGXicZccQ4N3pb2p6axCg7N5FoBadFUfH6C6jgAwMv9qA2BZr4+AWntjmmdZjheq5QAK+R2oMmLFw7Msbf6TrKjAkgJ+Wki4eU35HBTAkqLJKNzIEi43yRmmP1oVQ+fv7T1t+jV3MoLJqpRO2o2FqG+Sj2jfRfqB+x3t3Y47J5qPFf2B+4uEDrCKbT6oPVz4lPZtf/Xz8B1f9blYdqQSj3yDaYtjLgZsa6rx5Y+UMcZ15jh1//o99KDsH0YEDdS4b2Iwdt88CMpbABCpndpRlwISrtBEmW3jwwXjw0VELZnUTET6RIO+BlJG8yqNvhKIJI9WKiV7dPo/N1VzZbwCI/y9kmiogIR4kWh2zJy35OrOpgA0KtEj6dPa9Y/aywEA6WpH4YWrPZHZbUgld6Yx62KJCGGeAS6Z07CSFhDPRr077lylU2W1fx5vTjVwKuFe19SyKitmELcxoCz7UjuTsxjZ+DODfZ5AsCzJYsAUcwIl/MeH5NvWyDaseGYKhEnbnbvQTeXVkunsgbp0CNtW2LIlwaBfFTm79dosuAzjpQLWYORSWNG7dXkcXpaPwX+tY6+qEthjyv1vzs0cR8CjkMM3QoT8eU/PgzvkjJ6x1oySNrEH2YaxWgArC4S2ytdU6/DuNWBQIIKlHiptqNZvqq+ZSrBg7b3NklPsidMeLL1fV48PWl8qhVIaSIrdqz6KvWAAKr4UAKkfKPdjS0Wej5P1s+x1ovZnbzF3nTKO8PYEsKJ5jphnyWPgd3zV53aA9RTWPVkfov38/+zLsewomzAOTtLiqcRJATWM9olfBfhTUsCj7I9DitO1F3IwD27LnrIMq5qIqZCI3UKDO+tGpVzby08l9JIctYezw8JpwbIP4hVYDkFAGZfmAQqA08bhL84Io/c523CkDESuwK51Y9xJldrRhFPugIMvGl3OEUgaPNytIeCqGZi4y4EacOUZfpJMnCADDaddU5uohIZ/ciJy/82J3PPnCekwwp1mpKsdZQ1ej/DHCcv1ToREJbvPOSppMziEJxOp9edOkDVkYvA1eDWAjEKBkN9DgBcruZ9YhyfrkfFAobk4eZCIY0DceQHQpxe9gJ1ldJjuOYxPkmS9speJZUPCOZVQIIr4bnJZl83lUKHhhyVPz0IMjopDK6DF9+94Q+0PxwiWkqDrUE8urMl6GkjaMA5QSY9AZZK6JdYZW0x+ZtL0EArRel4KADidq/0DoExEmzXIvwEAhLAKL0r2oskuXHm7TMgRQJ3GHwKBoqCybY2XR557BlGWt8Wv7KHlcFSKcMOAtES44KlNKRb5iZjgrq+Q5plCg0vEFnATY3DLHjJFAhdOJP8OMVFpG5ZY0LX6mIfEIUFtNgTY8GBX0g8GgEniTP7sJpPlDFQ6XZUHTWgbeZJ7GJTHvOzDTZH6s/Nc95PTQn3PtJDMzhIRDyP8acb8YIfh8SSah+HJBH+TPdtM+DfhViCDNZ1tbb19njIJ40DnvXC4MHOtNHXALwnLmCdpCfiu//23odvKuifrw23f9b/RjcbegZg9DW5JVVhGCIQ5ZBSVR0E0sFIioLRQKCVkrhSDKNbgEvJ63kw8DNy/Ku+QW6htHLLhtsaBPAbLISCcFvGcDDezeLCI11N7wbZMiJ3ZPV5le2VOViHBm0GOX7lTnqlgq7joPbJavQkbMMDInW06jNs8EA9IPa8YieSp3Przi6QtML2VCHLzRz2g8+Kw4L4OA04vESphr6Et+SIJCI0CxcRj23bXiCzCrv1YSpHkjfCKDbd6Q7hPnkRwlz0Qd0W7Spsotd93WHa4M8So073pNR9bsqTKseu25OQKt/ZO2XPbugeTAlXIHq1WyLBKYWezRGhb0mXrGrO1tItiKjIhl8J8vO7TLtN1EqG8Tncc42IZJdf2inLoT7xrSQE/AO7eNb1eHS63wZbr0bpdLYCl2rMCWBo4pdT2VDbAtg0r6ldZLlw3V297AWAB2ARYGHzRslO8SZcgMjfMp5LM6t2A+f4OcZ9fc98zPyCqggZY1XkFcw/rMkS5jcyN5XPg65qCo/6kcS0pUz1mfnDuk/JY0wHWB2/dk/Vhsp/3OX+E3rhSENpPCX6hLCoBQuyNnxOWg4M/5ULLrGitQjHJ000+XwUhIg+3EceXBzkWr8ueLTcrD4mEpnIj+Vlk8HZbSjX4iQahuAuk1psfXPG8cJ/rWecmVctZENLfTjTLO50pDKe1flIqhXnnpYTmLGeDB5EW0Z3Xcw7x/pW0zS2pENnzPtMYqvCjpFOjgELtibGD+XIYMNxMiPsgIdMle6UEXCRI2QkA8EcDroyGlT8vKzX1cDMBKWG53lHHxyA6g6ohAzZ3NqKixqNDxbKLKOlyPcixTy/Sd8eXCeRL3U2OVORKM3wPcSYh36+6jFSYkujjLGPRctOFzoESbkyBJgpWZHV8tFCB6SezENpJNiMfO3tnPYupnkijzSrbcxHx5CC/kz+eM+hZCsDSQMsKYrIZ7SzR1NLLs6hjVTQZMORpv/LoMIGe110Vndb7AFCJmLKJTMJIy+wzpEBCCp4y+GxojNucEwBSjATc5NrkZ0Odt5THAcoxJUwaC2BhL5w2K4zKHK6WB3Ac1mKlKYkwaTqMkLJZLbOeOgXEWajYnWdwkoBWS0dEEVy25Hw+T20G1EgYb1rImzUtSPtRyprZdZd9yBpTXiXK5PbyBDxSHztwX50nsdNLe+w+cMLprQfsf/QG84t7jB+4pT7PkOtJSsLLezkdzhrOoXouKs9af1POdH+z1Rr8EK17sp61/Z2v/K0AkLO1HPycPUcKXLkFFd8pHE0n45zwTpIvIIkfsPERy0jMOHxgLh4uR9svI6lxCxCKa+AAQMr4sEZSCpm/5VwuDxHhF/qTdfI+40iDq5RTYe5XnmXGq1HVKVzgTmf5Ex0bgCrBa9FE3eHqWas2/i4PCP7xLX0f88DOqeK+1DrUfAk3Ke0YnmnG0hkLONHk8WsmulOqM5fu8XNSUgTFG1e8iWtPRxXuSgBSAacAEG44ZKPOFzk0oWr7sWne3Za5mDDdo+zA6dohZDAloWoekzay8Fn7JobC0SgcLX7N7eHEih23D5ivgSXrwXFpHpuhSCvzdasHMsvdawIsaNCbJPuytb/2SSpvCn8GanADbPOaZPkFL2UjpNbiWm0a61uxhhEDF1uvT706y4Oy67VU4RkAcYjfKfK9c+R9Eo0pV4BHBVTV+9Yx7LOtQ5762ee/pwVYvC/FfWLvZgtgAZDn2S1pDbC4r2j1Rep83RxF8X0TYIn2lMsiwRwBoHNZ9h7L3ov+HC2k8YLHgbjzmF7aY3qJHqjTW7NX/cXMF2WAxddgHyqZmRJ1yH26K9xWC7D4We4A68duHWR9GE0DLT8l+JkyBOer4jmQrBXOlOIHfLaDS14/h0uYkO7mhHBDHdfh/WeEU8Lu8UKz+IgSO0cZeCR0EymcxQMRP9hRNE884kjeFm8I2DzA+imKMjBxdvKfLanDM22ogc4ADwZaLLZX5Cfyqy2qO5oZcFIdYyQuRFV9HmrmVgEtIqPqEjVy/fN6rZpbJUsug+TsYeIyFCuAxWNyYxzllO6V/k02SVrQkhhogwYqnxNyOHpYLRe9ruzB3HHNyyd1SM8l8sBGTqjcrUEDf7eMfOzstcqFoG/f6vOrq5Zb8rufU54ErA5RPLGciWWuwXoD005brom9WC2zYS3rCbHei0shOgvS+DzsNvaYrdBhilX4cXUoC/gEGBpglVIBCkBzf45J64d9tU/JGuTv+fnj51KX3bHm6+dQTPPIdPuNXIpwDtmT5xx0VnIz/MfLOAQ2+PLnfZFxYNNCtSllVXhz7zAZX2dE8p9eT6uri2ZVCbUyAHPZ0+yXKGCK+1bO7h6eUB81Pp5zDVDydskkZ8fVHBypsR8CZSCr67ncLwXseYIIFA9ZKSeU95/pLMuhA6wPt/Vw4TO0//BX/2EivPsSomO9KUBxZny58Tm85Wciq4cpFpIldzLcb5nP0/1BJCKYuBxOsczUuE+RenNqJpPvg3AkEDW+ekYaPPy0YLmqBUqXQyjeCAYec5LzGR5ldwmXeVBFSataYXl7XSfQWvKudO68PHfybiH+WOJBgL0amfhMhagV2MozUrekKqMH3iPmcxXdmAw8/Um1ObhKoZx0ZoJ4+ABg/z4qTlnVMRMuhAJ6iqAM7+CP8ypz0XqpwrFIEEhiweDBCRduSUg7D8QsLusdFQwHMLFsRyCS+3xFulXnBw7hSB4nP5HXSQjyO6e8qaULkPDgRPU3/QScXqI6nNN9qq0p93g+1oMfnjFnQUOWcBgfTUiDx/Bkout/ninEFckD6W8nIQZX94QKQctMnblgNxMB7yz5IeEyJrJbkKE9WMJDyp4wq0au789loeLJAKqyO/OMqm6hkmFIysNWbadFSlmPyq7LnEMmvQPkdbLq7TocyuR5fhWwwj9qUDpXqs28DyULkQYKbeE8kZfkfKZ2bAl6Amv+JbeXidrcLjsx0m3ha6d0npi8Xq4Nqu3rNpTfW5IhuF1yvctfk3BvASMryPP1TKkkT4wDed32Q8kM5uLL93bw5wXLvVHEScdXT5he2GP8wBHzi3uEm6kIPednetl7SX6ZuRBzzmIfn0TM1x6H95xxeuuIw3vOOL84YvfKGfP1IGXTdD1Tei3X3c1RSnp96//V1do/RNucfXWQ9RGwT/6sL0M4kdBn60qyp8lmaunQkJ/Ndx55YKo5U1MmSUqsv0GCFvczE/DZayLHLW0bnmSdoCHXqVpoAGSgJrUR8/7Zy8NAq6orZzvdFWG7HgBlwB2H0iFy56eAFgDE60zENZ7CqEjuEmaIEe5UCmVLJ214LXxdNIGYgSofd7mickUMojXIAiBArwJYsjMGu7XXagtkuZSormDmdsV9EI+jBoIAJFtozrIfDLIA5VVi0Cz3AapX9lpx5QAXCTQlBxHM5VAhk+glhMrlc7Kz4+r95byHLGESjkstWWHuCwl9WBLyBshyU4RnXh5z/1rlSICVQjc1yNfLLnmxsseI+UxV5qDexPKuBAzp4xtwwFIQthKBDwW0ZcAlbbYgy05YrIcOqGogVudrQJaIg+YC28xFE0+XWlcnsVT71DUMY+PaK4BkuZqS+MITJj1B4vVcmQRqE46eBVhsul6lrlXaOqeGgGv1WYM8zoQ09QvZo1RVceD+P1MxhK5gztPNCdODUXTvpC9S9xxXUZD+2PAkJdmK958oS/pb/1oHVz9G2wRZPVz4EbBv+6tUasDPaw0qYA2upC7c3ksJFE7Fl9BeLqRrOVPDccFwJO+Lz0RpJGTuVXERAwWwyYwrx+jnK485D8qnt+ZMlytS/07BSWFjJu8vh8L/iqMHPDA/2BPhMqujS7mccSiduu7kQ8hZLwoMZG+RiEjy7JHDi2qg9DdHAolZHytlxXd/nussm8ydSPtQXPj5DyAQ5M4z3LQQIR1Fu8rWFVsOg4Bm0aB6YSfXUhvzNnQZjcpyun3chRXIbun1cGctGYcGEErnzvy8VIcthxOD4oTxJiKck4QPh0x1a4U5BYhJ+Jvbwyvk/d/Q3+GViMMrEf6cShmdSDzDzaxCM4gJ52UpmaouRvpT34mx57TltQLKYKmzyywP8AIHZ8taGYUsy9CuP+jXAMtqbMmAH7b3Y0GhDhFuEMGxG5HyX9OY/G4AFh3HhFKrIs+pBjKKJykAy4bc9OnrOoWRMovl+ZV9YhtgsfZYat+/so7hWYlX3AIsPqeYVttQgzcO0rr2+XV4lSZi/tERWBJ5cBXAEt7ntMBPi9TRnR6MFc0EKBOh8z2P8z0vdQXpWiqvFVQYVd/3QAdYz9i6J+sjbJ/6ji9RoIa+m+9RhxZOFFosbuYSnhKvCosrP1rIjXyM9Hqm1+F2kbpS3ghdWvkACWGieLFYmqAInLrVttw+DiHxQLt7yKrGHD6h9vvzUkKHQCmboy2lqgwEFuIvcJYU7c+ENJwjRW/n6rChOh8p9mwGE9fik/DM+TBmpftAxNWrUcIOrHnFWYZuSTi/NEhSwvhK7kBVluFq5m2PpzN+dLYT1r+Z5oqRnhWFd/0UsezoPuDfkIGyS9lb5SiMnDzxBuPo5B7ge4ZChAnzlUfyJOXAZZAYJDF5noEVe7F2D2n51fvKIMuCt8UDmPfB2Zhavd2EBcULaj2c49o7yeu629w4q+APbA+I0lgzsLasxdnijEOgrey+8oTEdojQHofL7wTS73K2YLnNhNziaenvuIbdUHuvXMuzx5aflZUHS/aR1qE3nSFs22KvoQ0T6nV3o0iuSHku/Uy4un8iKkDtwbI8WOiEG/3a4optWevaGo+o6FRpzx3fl+zpMpxR8aJnsBV3pJe3HAJcAqYHAY6dcle195g8zVkf0VFUQTKrFZme1k34G+/8HZfPsdsHY92T9bzYt7zrd+Cbv/7z6UPufDlLcNmrDsNlgCJkZergeDCfHhT1dw7lpeAwXxVRUS7qqQc48QQk8r7Iw5fXkVThmLJeCnk69LaW7MzhxfML5NlJY9aKySV34i4gHsZVIegq9dk5wOcBNHjybA2ZJMuz4ODLQMiubq6v5j3c8SRKyrYyvTtPJRwaqeQEAzqbheWOXMMtD0DnRoZUtvNLagAAYBXdq/1mUdWVUnNr8Pdl0KjMfGQSLCcjLMpjKckTjFFPCUiQmpXhmOS34yLWReCWww7ksQynwukrIcH8mWUeMujmigYtK5ppxhvSMpswYT1c/Huen4KIPRfw3tpX03w9aK4/+5KNJ6rx5ndX5XVc8PQ3DPIeKCFFAV4hAD7Q95mD1VSFBy5fPzaZPGQvKwOf1rYWoE3murVsMOduw2zarMcwZyomlVkoXurdWIcdowIsXNFB7yuLLot53ZdmD9oWwLLX4OmcD3cDrEmFKacZIqrq3DopR/UzDBa1VAwAAVj8HI251NpwQ8lWvB2gQoRMO8j7+Nav+e0dYH0ErXuyXkP71Hd8CQBUnB/2PujizQCk5p1Uc0cpr7MSHZSZTfnZhKhueR68/LzucPkh5eNw+ZUqrp9t95i2Hx9RLxCsXhTUAMvgZanDcKsZJ7DmUFiNnsWEJgAqlQMI10G8VtoDwgM0ez5WBFu1LndWmSvFKdRMKpeakgB276FYWylizBlyLHde9mv5GuyxK2r29XUBVJjQCJZKvUC9rq0taABVq+IAA/MpA2jLtQKKJ4v3e35A61y9l/Z7/e4Cdvi+WnlRT+zJUgOLAZ9Sl02yNY13RK0rHCwOa10CBdbjswVg9Dq2n6z0rPI5MpAzz9idwqRArfYuhzYD+NOYJX8bgFV5g+X5a3Mkq2ePz01ApbmGLcAWjGfqAqhjL5bwovg5PIzrdUVIlj83JjQcpp3r1xVXrOWRsp9b94D1fl36jey6lvun2p/2dL7lOa9pAYt+7vntltNV30v5nuzE9mdmmzdAB1nPiX3q278YQD0YSbqtc+L65XDgcLNU4cRF6hYqj4oH3EzERi7/AxRQU0j0dZ2ulr6WCGoG4opRZlkJMQGQckLjY6X9lFWK2X2/mYYPNZNbpaVz+FGRY+1MsVKRjoiHXSknIYBKpTnrQeI8ESdjHMSrxZ0dhyoYYM33abCaXiiDFSv0M+ndPznVJ9bSMvKehBdz+QvmVMX9sL72rD815hIXewohcBYqUEBSTWylmW8cHcKxpIzL/hmnHuj3nO7T6/mBl9/y+BJ7Q0ubxsdl/wBwvk9v7r2bzvPqPYW/syLm8/d8P2gvoXhZDXDiDEHeDw/eWRTUcb07oCqjQxtseCqAy2DL3oM2fKj3y6FCGcCXOtQHFWKz+3WOtueQYwhtrhOvawGLZBM2wk4pESDN4XRLOr9YzcGozFfZh7ZdG4R5efY0YZyzGy3pXl0PBlwS4ufDmSzd6js+7S1wBawBFluTL8f3SH7VZYn4HCzAaiUb8O+r71m9rhZsZg+/TG5rL7nUh83f8Wf9zEv/jzKx7pyrj4h1kPV6sU/5ZV8q763bt9S6o9dwXneYUoNq75tAC8Cq8KefYhNo6Vdpk3croFUyyTijRRHS2WNxNFXomeSvOEirMJoeVHJnXWa49OpvObS3XAZaANyTY9lvA2jRDtfeEi7UmrwTkHV+kQi5/kSAlIHl8EpmjevQlfW+8bXMHjetbcXvue4cJxO4lCqQBaDK8BSQleuL0U7W4YU0OBEepA1qkAWUAtHTfQX482XZvcq/DR+PXq/eV87t8L4CssJN4cQk70RnjcsOyf2QEyp0TbgKZAG1t5G9MC2to0sAS+1HgM2QKwtoSYPWwLsVYlJeM1GBF+CmQBbv3w7SMplQIEsDQB6s9brRDPpaYkIN4NKuS946mOfcXj8O3cUoUg58b8q56+2tp0a3UwMsFI+VSCdsASx1XuLJYsHhTHSvMwVrrzmgJmQtDpY16x3jagH6t7Og0vL/FMASbzqfA0/iGgCLeZmWykHr1+2SiS5TQ9Tv8O1/+fO2z6/bh9s6yHo92id/1pfJe1v7jU00i0RCofxUVuwOKFkpwq+SrLQL+7TgQLu3pWOvt6G2KIVz/aoJzhtyDtJpVwMFz+IyyMjkc39exAvib07VdlGpt4sHj8HW1owcEJDFnqzlXq4jtg84vo06SO7Qrn5UgYosCug5bGXPQx+DS/xkELcwmGOP05xkkBHwrGQd4r6AF31+snulrC73RW4PSzuwdlVUURlRbi95BEXYlgtJs1Mw/167R+W89u+nlVjNXkKNjd/fFuql82Eyez4Yk7Obop0GdLAnMoe3dKhOk9JXHCcdRtsy6wHhiYJ+PqLxVABw+3whNVFct12bfQ62JBqAdRhVZ+zZcJ6r75XWsawYcEuvqgIyUzs8ugJXensLoixQQQFeK2kVfR7BrZelum+T++0u0G33w7Yholy11wBKmRCYgt7U5noCx889vG/TANRkic4jP7sHk2muPFnf8Ze6gOhrZB1kvZ7tkz/ry8hTkVBmkMZcpJBRuI2luDNrWC2pAC2XPR/e1dkn2mvmUGosGqClK9kD6zAQHGWO0f5rL1YVBklK5d58z8KR7jQVjSyU2R9iJPCzJAJRzgCt00SCgDn9m7WyqgKvp6kSDxTjASZzQdwcsbxwkHM4vY3qJTLhHQDGxxHDk5nK4kQCDm5a1iAOIHFNDpEZkBX3JPrKoV8r9RGDo/CiI++TS0n0r1i3KpwiPe4pAysGR6firUyOwssp1PpZAOQ+Y4/YciAO1pxlyMYnwLIDxhsKP++eMHewhC0FZE0LZcXxOKtkMoB8L01zGZwtyMqCotaDxFmn+jvLI9oEWQxIdUgLqD1IJmNQzLlKF6spMqpBlg0VDqGUltKeLLX/0ti0rp3H7Wdv2DyvweEGuNoCWZtlh1L2GmsvWrRAQk8Y1H61d1EfP2dHphzClPPU7bMAK6IUb9bhQttsT+uWkl4xe/HVJE57oC7xrVqSGED9PGuQvgWwLLgCCsC6plqQcU/Xgr3TlbyOPLuL0AmwJMz3SJdvvhdErLSDq9fcNkHWZR9yt+fCWGeLf0bWPmLjYtJIwHJVhEKXPIBW4cFEM5/kySsiXpCkQkkZsKUA0V2JIf9xzSsTwtT75++5c5FyNyblXLILtXI0d3pLDk1MsxR+dqeJAIontXOEDOQSyMWeMwsBEEiLOfykhUHlorlSK81mLQ4B7jiRxtdAavDxMFReMTbO9hQuCPNzxm3PSNoNiIcdlcE5ZLCY12e3f8vEC8m4Qp1P5JJzvD0vSgVsrzKVGhN0AddcRPxIWYPDEbjOxPb9Qw4LN8C+3aeub2cGLRkQI8l3VJ4Y2eG256XpmeB6cy1bJYjk65LSuo0N7wULjiYF5FYq7mwtz9gHQ7pmT2rFhTLA4JL3TXv41PlpUHWprmOV+AHltbrLLP+K/zijTstQbAEsgEBUpjuskw5ax60nUWsdLVe3R99rOix6F8DSfYUcO99zy1L4dSHUultZIzBe7+hvF4QawACrilY4muD6U5ayydmUcRfk2WSPXQdYz7d1T9br1H7RL/9S+HPE9EIOmeUHT7LM2PvDEQquj5VrKY43EdO1L2Ee7pN3TtTp/TmtOADMxwimYLFOnXapgC8pQzNHEhU8LeS+b/AiKs+WnR2mZPSROOwwqOWheEuMt4hAXvksA/1xAoKn/SguDJ+3v50wfdQ9IfAzGXW5HkSbys9J6hiGx4b0nr1z3KH680KFpqeIeBjgzzMt4wn4PSbaZ06dKzXNSkq2y8XHC9hlkIVEXi0qc1REHJmX52aaAfsp4fSCL8rtAuAJtHORcgAYjgnL6DDk+yKxmCOK5IPPMiS7hxPdH1zs2rNHMlDpoMy9EmOgkz2T2txCnjDRYGKgoDWw2DvBXh7N35rrRAqtyu6Ch1Zhd0OoVdvjUjLp2C6ptevSOhsZvKJ1JevFGihpb48R5aXtlaeN19cgwHKFdLuV1ImUGGIzHlerV+XOU9mOfwt7fvw7WWMiu1fgxPLePBV0tkkx4rEySu96vUqmRQNj/RNdGuO4WLz9jr3qQANUkSe1BTxtSBAAImd2Akgjy9c4oQCUdhKfVZfuApT30ZFUyzd90+/cPp9ur5X1cOEb0TgjESgcGzYaCPN7A7RSYwLMHohlV0JAJQtxuw1egajVMt6ew5bMxYlJ+DpNTgXvy+hYVbN6BlmVC98AQgO0gAJUqvZyZ5aJ6Mv1KGrvkumTCe+RtY10R587wfHhWc7DcYiUVZd364teikPnz6OXQYMFavk39CJKW86R61S6WL5nJfYhgx4GaNqsTINugxxP5B7UrJmdjIo3wmBbgywA8EfOKtX8q7UHyqbjS4ahBuJywszxa2RrarAh2kQGZFVK5BwCU8CJAY+VK2BrcXO0Yntrn2YdZ8N5wKoCgpUzwDS3ZSa2Ql7aM2Oz5FoEdVs+Z17Ke8u70tYCVbw/Ac9jdW7SLr19w4Mp4GlonLeslEpoWQj49SoXARawlohha3HXtBfQaLKtwJUvenW6DFS8LhU0tHFtQjcXzyi3XQPub/i2L7h8Pt1eK+sg641sn/r2L5ZBuJTfcQK0GFQxGFhyv+dSkV9gG26TAK1ldBiOhbflz0lUwnlQ546AB1nLI/JzEtd38sQBcVF1JFX4oh4kqAxN9mrFmAsHq86JZ/2W+8QcDueyIGrNj4qHgQZ/HgNzhxkfHKQdS+4Mw81EhVsfn3F62xWG44Jl9Nnbk8DFmTmLMpyWArLYycGK1d6Jt01rYcU91SJkkCWEVr7GGlPwz+Vpf1zEmX+X+eBEoDAFJ/IS5QfJ4eLgmiArnOj3H07EuRrs9o54XF61KZwjhpuIGBx2r54B5+BvuHbgevBzCgxQ+SNqF5zKMNThGl2Yl38vG17Tv3ELZKVEnCyrrF6dG4ezs2REFgJNOvy4LLSeVm1n00CG9yHnEMB1B1NK1X6FH7ZXHo8cKhfQyAWIB+Ups5wtoA6VtgoYA3Xoy3K2gheQxWH6ynulz1Xzm/TvpPlT+0LuBlC8YeqYdqJVPc8aZOljgQC6q0K968uxCbJSKt7PFvDUvC02XQ/TcLtEIiP4CmABQMz8zjQWoWjNhfULZSgzwBJwpQByB1fPvXWQ9WaxT/+UL5L3i5otsXDmYkQsl7F4LSzgAooHhT0a+js29pD5pRDi2YOiPSklA7JoJ5UU/Bp0iQfEueKRsjXRgPZs2oT8eCbppkU6bc7kq49Jr5K1eJpxfpmAV9zXwIdBJVC8N3SwGmy60yTtkezBXR3+0NlBXoXM5LcynoqW+GJr+2bNw9zJnx/w/eCKvtmTNaCS01IDzuml+h669yN0/kMOqSbvVp5Np8C3FqG14ehS9kOjMgYvtYez2j+n2AOF/M5yCtqzZLNXARlYmaCe5lkAlGNPjPFiVRmFLeDGAE+8VEObHK+OK+vZfVgbVSqozVrd4lltCbpqoNOSY2BreXb4OWNep+JhJgaMfAs37sXKFHACUHuleVt7r6jtBKhrs7dzSzaj4nGZHXASDrDm+WkAZgpaA6iSWQDyZFvwJH2E+s30c/YN3/G70e11Yx1kvRnt03/RHwJA/CE3JxHQ5MFb9G4W8kzxYHu+78WDoTtQgHkD5XYIRyoS7U8J87WXzEXxcCleF4Os4SZnHZpadTI4eyKrEwk/qlIssT0bB2gGHELxnPAAMBL3hV7zgQYPNy2YXsoAKl8PLgQdHp4xvXwQ1fr5OvOwDtRR6pDd+JBqSO4eTmWgGD3CTa6Z6IiHxSR/5nQhOMRARWE1yEqB+G7JK5FBHoznXKCbxwfhURX9KS6LFHce4bQgDn4lYpg8FfVeRrfiVFFmqQFzvoSfzw+8eEbDmTIN7//wOfOwZjkGUPhn/B4gsCWhQM0f0t6QnBkGmMFZCY2KrpJOAJESMBFgUjp7noACbiynKAMb9jJpc0POhONMPiUmmealeKxsCKySpmBy20D7Ye+J4ii5/Q6JX7lGoHP0neKPiddrGGpPlOaTVZlyJhymk0x06FJ7mHSYkc/JJiA4V3GF9P4pIxj1MiU0W2mhATXA8mqblNrgSS+373mbhumsaNcCTfpeVLzQpi5WI/tTPNZDucZxzN72wYESitoAi6/lN3x7B1avU+sg681qDLSAwgvirMNZp+8r7k8KRHpngvw58714YAtKiysceXZWdhVZAf5EAMzNgNXRiqPH7tUJaXBCGhey/ui3RUyBIvTJtc14EMiyDYDiM6gsv5ZS9HIYSACQvUYxCT+C+VfzdZCCxsuBeTNlV+PDDM5yW0W9ffAYHp2RghdAuagMRf49mGAeRy/XuCru7YmwzqT0UgmgtEFqDSoAbAnCUYpA+6r9AIFhW46p0kPLxzxnwdL9qwumfF+wwrs/LRI+taYLQQsfrxWS0YNmSrUURqPWZNEIU6FlDbB4X2wt0rblXnFTcpZYtQ+dYWhBm95vC2RJo02oMUVgZM+PfpDWbV2BLAmLr5MJmhwyfa6WiN7KdmxwyJL9TnGqkhLWrQCWR/FStgBWi3vVIvHb+0XbXd4yNMAVt8Ee65LWV4Mfl8acPZkBVhy8/G6t8jYCrvg3RAdYr3PrIKsbmQZd4l3ZkweKB81wjKQCrrxQhXsVMd8PAq7Yi6VLvPAsLQXysHCKcjgumO4PGG4XKiYNlHTklDDcLJivgtQ/nO8NGG5n6TyHhyQi6pZUeCraxa8FKY24oZtmpKud8Ezi9Q7+0RHxwUFCWwzIzm85YPf+I865RuFwu2B6MMJPUQirXMzbLwnLzuPwvux9iAn+TFpl3LmKh2fwBWAAKoXbV54mekP7cksScVjev4BRHuvYibLEMotXgxpQvHVchqMCUCGDLJdBNi9yTjS5/Fw8ePPe4d6PnDFfB+xezYBX9SPkncvewScT4tWA4ZVbCaFIBuhpRtoPRWJjJN0fnSVaPJcO7ngmrpIWidTZdkYjC/NcQAW/b2UIckZgC8wYE/I8by+8r8zH0dmG87zBZfL1PngdVrLXQMiZ4tA6VOgVuNKZlq0wI0tkWO/VhpzCKvswlVBgSy+qkixpZjjmRQ2QUxWKt+eiPVOtcCGbzUxlj9kWqLK2JRBrEwfYNLGdz53BlcP6uvJu1X46z+oNZR1kdauNwRZ3cC6VgbEKXykdLTYBJXn94XbGdD1U64XjkoFXLAN6KttLwVOtC8WHTeUzk76HxzSYh9NCelkMtIDCL9EhDxtWtGbUqd28ID4goVGrceUf3mL+qAe0+qEAxtPLu3wdyrqim8VljlgDx1FNx2XvJQtRl9PhhAXtBRLv1FQDGL42HOrl6ytFxIOn90vxFGklab7m1QxblWrSZXCA4vH0U0LcOVz96Em4XVWiA4e0FLBw7JE8Kd6aKZODZamysmSdIZDXckMBvjKWeHCucLG4DZpkLpmGs14hH7sBsjS5ucpqzNmIJ64wwEJlkYDHEtueJPGMaQTc8IRxCFPXPPQG5DQ8Qu0MSLUth7gYYGlv4tN4r/TxdS3RLV24aoJwAWDp51TzpSzA0l4nE4oEUCVVVK9bZoVTW9cDKL+LX4NKfh/Hjb7GAKwOrt6Q1kFWt8umCfOSFae5EzzpHonrw+CB+UacHQcA/nYmGYTjLOGxcJwpiy7zhADllREiaA6pXQ0ITyZML+wwPKHB8PyWHcbHs5SUGI4L1cVzQHhSytoAqAjyOtU6BV94Oy29IKCEPiTcOMDdHCk0CZTsxiwsCJSwnz/NWO6NGN97I8KlcTcgPDrh9icSSBtuF9IgW5Job2mwpZMVknclWYDDbYGFFVE9lcshiG4XQAkHArSwBtPJle+kZI4qucShS06YEEV377B//0mulZsoE83PUa5DeHxC2g3wD29L+PZI2zjrPdEeR8vx8eX3SsHDHc+194bX1YCZs+iM8C00DywfO1lyOpvSsxKx0cyjYiJ8mmcBYumotNE4FMhtmjKXy8o5eLcmmvM2OXToNOeKTYv2Kv5hanivKm8cg7UWQGVl91aFgkveK04oUVyn0k5UfCq3rD1LDE4uZglu4Ba9XpWJqnXVqvaY71rXwfLO9LY6Y5DfM+9Khzqzhpxct5Twjd/aQdWbwDrI6vZ0JmCr1bllzwiT04EyQIfjLINslVl2IRPOTYsADNHliUmJL3KIcsZyvUO4OWPOZHW25J2AFR2Kc6zTpAdAO/CqY6T9uCpEXA3K2msWI9L1oT2rHRhoKnDHZNtpxvljX8DwZMJ8nwZrz1yv60EAFQOt6X7A7hU6LoOs5RCaSuvCFVOXexTyvVulskstxJ1H0caiN3F0RTftwJyn4u3avVJArdSj1J7OnA3qHxWQJQWdOQtQh/lMlhqtWK7ZSppBn0tLP0qHfoyHJ6VE3iwmrgPlHm15lJRVWYDMzYqxcARtCFLvsyXiyZ+DLyG+scg4uJZEQ+MeTg3A4LTXq0rAM64AAB5fSURBVBUSTKkSzGxxnZq1C7m9Syyq9BUgsQ1xtfYZ75ufGd62obPX3B9Qc7tYimHV+Abf7y5g1fpeAV0Bhc5RQWenQWjt/QWAb/wbv6u9725vROsgq9sHZ5/+KV90N9ACKkI3E7+1tURKW52yVj2X+nJLpIw67yoABQDzSwf4TJhf7mVNqyeTgDbhbx2n4r1KGzNZBbSozUvxwGh1cRueZLCl93G1k30z0MM4iHeNQRZAwAqoZ8LnFxulex5rJesMPOeE6QGtO11rMnoO4WatrPHJvKo3qUn+8l4/4RyxO5R2aQmP3QcIZLmYEJ6cEfdD8Say5+lqB//otjoP1kmjjRloxLtBFluLoL0FskTOoWxvM/SSDi83AJbL/Kc0TfReJxJoz9HJqPwDNa9Ky0Y0VOAFZGkPFtAGABqc6vbwuVVgqKU6rACXlXFQ71PLi8bgCmiLAeufQmXErtqqPT8XQn6t0Hk1YWgJidow4cb12qQRsClZBvH4Ssi1AKxWoeoOrt6U1kFWtx+bfdqn/Q/yXocQbbYMlCeq1cFqwVHptLi/i2W26GJEvBqJv6U8ZC0dLd7/cm8vx+HyNFo3aniF+TMe/okaGLXIIEAq1cFTMefFdOhaiZwLXS+xUshmcrYAtZvjWksnRsQH9+h4TAg/z7j9cfcBAA8/jra9968jPvBTadv9+xOozE7hae2eRJweBNz70Qm3b8vb/H9nnN4yYnw4i76XP0XxNjHnLg3tfkHAmJKq4N/58N6zeMuGV45UKun2VLh7p4mAxHlal4wBLvJ9+Do6DrEBeT+Kp2Vti59kFOOrEjqaS5SMMCiDKetFmpdtraxJhau1XIOsqAC98VhVIUGWiNBSEbpgtZ4YbElg8H74O2kX/2ihvn+BSq9Oh+9XxwIKMGNvpPEYrcjm6rrL88CSKkAl7dA08UQ29qk8lSIQqkD7SiyUr0Mro9VyrpwTHhhLM7AcA1A/O9/4zR1Udesgq9uH0aqQIjsmtHI7h5D0dxfKqwgnA2WAT2OQzlqIpbtQ9s3g7jyrjq8MnpK5pyQTvGoPZ/wBKIBLl8rggSqDLQBw2psWjUcm6TCn4QwBtYCmHuSzJ0xqMAKYXiYC/unlkkl281EMTghkAcDhlXJN2XPFIUegTmCQ5qTiIdAg6lJdOE1k52zC5AhkAYC/odfkXVEJb/GdGiGYplnVcnl/gUgO1EBLhQfLfvM9E9aelBSjeK6a3rHTefVVtW9Twofe82DfAAg+lHZsSEi0s+DUxKV1DS95rxRwTK1z1Puz2YZ6e13Xj6+fMyr90l4VEuVdq+e0KVLa8DJX+1Wvzno3dUmfxu9cfW5kUvLEL+1VKZx98fgxWOveqm7GOsjq9uG3T/+UL1oNBC4muVukhI7MNrOHIWI7CyjP2IVUy7PelASIsHfLJVTHd9NSdeBJA6SYMF+PSlQ1CUDkYsaaRwVNkOf97Qe42xwq0/UU1czZTRn0KdHKqoPn/Wqux9W+kGizV2u+v5OwIocT3/czr/HW770BALzy8dd48Z8fcXorrb9/34TlKkjmIodvp8z9ClOUckBaZysNDkhlpu8iecuYkxUHkuFgYLZ//wkpeAyv3OZ9OAFZFZBsiT3yYKbDZjqTSxUDl2v0NCCr1Ye1QJY0xalswGUNclohvUmV8skAR7xfw4B0PNb7BLAiuYcgYMztdjlkN67P14ZSNaDX5YN0gWmteWVlB2K6CLBEqb0lX9AAItVvVgFb5tip4+pzAypRYOFUsQeKzZLWrZdSgyv+bgtc6Xbqdjc8q8y1on24wsHitnvXwVW3Lesgq9uzt1/ySV9YPihgwV4sLUgJIUw3ZqpAk8yaNFGX+9FG8Wf9fSXYqQ+la4uNJRwpmyt+WeWF49CiBhTMQzrs5Lyr5eJpKwOdXs7fp/tX5TtFppeyQlWITXFn5LvyXpcuYuN6jPr7pMajoommrps65vgqAbjh1cK1cgywgAKyWh4RoAz02tuiB9etYr12Xxuk74qP1DK9nMvl3EF2r0zfkxowcls4yUKR3KUsD1B7gmSjjfv/ae2SnINevvWb2HCa3WdDrqEZwtP7179pa3ttW2WAWvtqXZ8t6YdWu1oePa3Szt+p91//N3/P5fZ160bWQVa3j6z9kk/6wjJDVrwt4VRpr5blnwBl9qlnw4o7IZXtPWqgJbN40Ix5KPskvg8Td+vvASbfK69bNq/B100heAtQUhmM6d5VaSvbVhbXWQl55vNJV6pI8BiAWZWh4WvEyzVQVOFGucYxFQkHFf7gEKoufxQrgFo8XQxMWUoDAMKrBVj5J7era1CZ1XYC2oWNU7pMZHauCsmlhuejFQbU17YZ+gLWHhjbXtsWa+zVPJ0LaV4f64qTIyLx/VCH0pseOt1ebov1YrVq7VVJAUqt3mYY2lPTUg2Ne62pRN8CMxZg8WfNSZSMwmUNbLdkFjQHrXVed4VR2ZOqiOzwvvQXgdqVguvAqtuHYh1kdXvt7e0//w8AqL1LlewCg5m7PBpA2+ugBgUBHVtJRK0JdOXVUfu6KgBGCmArT5d/XPg6DDrii/eKB0pZlY0lOlWueMsaGVpbHJZWlmblAWvx4FA8Wos+LwWyRDerqlFZ9hUeF0DlbrL+1a0CWS3QsAWyWoPqhvfirr6qJbFQec22ODoMeCre0BoIukqMdMPryueuPFhSLFltV4GsFocP6h7UXuGtNljSu7XGtWtyljQIagErva8t75U+FuuKqd+/8l63ClvflQW45anSbWDvsL4eDW/V1/3t37vef7duH7x1kNXt+bG3f+LvLx/0AJJJ05Xswxbg0gOBHiCybbn/mynjW4OckPB9yczb1WKhbAy63O1UCPvau3SriNO6pM1eDcYcalyWenCQ7dZfAajL0rAavx7UFOiRTKldENX95F1R3tfRFXXph1uuG5jgb7Iu2VHpZWmQxX2KUmvfDJHptrV0jPR5bnko2FoD8tN4FDV/jsPMrfAYTBi4tS9lSYcHrYf2kjW8VRW42rpOW4CkFRJshdH0+7sAll6X1dLtcg00tadUkmUaZX3s8ey52PZWnjvtecu/o+4H1ASkg6tuH2brIKvb82lv/8Tfv+po3XlGpebc4oAA68FNk3cboQBAdfYtsMWdfis059yKBybSEllUdXhEQCONQbxYblpKzb4l0ffac6II/frYyfsC1rwXoFQBKS0xESMR/zk54DghXu/rjC818HDGVNx5RF0gO6GcZwKckukIp0UKd7vTUmoQLgswL7WavvZmzapsjvVYpFQLe14wtwUMfANE27CRc+TdaAEiHYZzbk2cTqlkWFovnYiORqT9Di5nIaZRh56zNIUuCtzaB5PjNZiwMgVsFtg0lPMlXM/r6OvDYcEGt+ypQ4P8vSXqA8AQ6mfGufKseWT9uwwg9fW32mVbx+VjDyp0qK8Be4l3RXKiA6tuz9A6yOr2+rHK06W5Ua36d3eFFjTwMoODaHJpcDItdR22DbJtahWr1Q4xXfJEH5fJ5cd5O5Qp+8iA61JhXFm5DLgigqqOG6+LhhiX/EmDhy4AHiV8iYoEz3ytcI7SE4TbGZ6B5Gkp56uzSbe8kLYMCn/XkgC4y7THb8tbpkHNVjiNN2t5sFwRUU1cxBlAOuyL9Mjgaw/sqQi2tsKBm2rqLdPk/g2yeSu8WVkrs9N6qO7yYtmMUH6vlfNbnEEVgrQ6WnLN7gDYtP/1A9M9Vd2eE+sgq9vr0z7jE9qdpfCd5uXpuCl6Rn8HCbgavLYAV4tsDwWu9JgxbKyrOFMIG99rTpJuix5r9Tp6P1rXS2cZPiAitq6ZqAEfl9xJwZUwaXAEslBrjIVHip+1JeGgw21bXKS7AJm2Frkb+LCALKDhaWrsX4Q1UyoyIQpkVeHTFsja4odtcIz0dWsWa7bbXvIA3bVOC4RttbeVSQgDfnTommUv5liFx6sQ6YaHzpZhAupn4mv/rpqcdev2kbUOsrq9/u1OwAXUWk3V7Ny3Z+K8HrDNBWlwWdLgC9AxIEpzoHQ5EB1uZCAVd4N46JL3NdhiHlcwg4oes60oKjLQ4gHsONUcsAwy4vVYQira26eOz2CLjlOOGW4VyOJsyyWVtiyxCRCqsjraYqw9WnaZtacFWdoz05Iy0PuyhHM90HONvq0SMg0PptNeVw0c1LGa6up5ueiwmWu2CbC0TlYrO1CbBVfy22tAk6rnRUJ7KSmRWtWuRkLH6piSVRiLR3cuGmxVCFFnSm6EAuFcB1bdnhfrIKvbG9fe/vN+n7zXavKVvpQFX8iclaFwappeDl3YV5uefetBgLkoyJ6dSgQyD65cI5E9VqJiXwMKGXBO5zLgjDojUGUStsCWc1UGo4RbhdAfivr7YayJ0cA20V5nHeaahW5SHsVWBpzmNW31OXdlmrUAl84o3CCrrwCW9XxasrsmbA/tfVZK5fZ8NKDQ90CLm+ZdXZOxFaLckpbQ52trQlrTx7FtbYUaFbCq7gPvSzFnCzTtenwIfh5aHmegogToKhJpXyYUX/c9v2/dxm7dnh/rIKvbm8MqwKU5MtrTAlSgqzmYVR4S8/y0SNB2cNMilBp0qAEtXuf6dVpqYTLhT71fXfZHEau3PBY6NKnDKsylSoOvQMRyraQGlFXlkWLxZHjVVi3e2gK0/N5tSQGINzHizmy2p8mS432xsQ5Z8MVLFHzVnnRVeGtpwxtTlYT6IENyKQQ0S888jWSJBohbEhjaLK9Ke4XYNnhhq3PXk4lWGRxgE2CJae/VtNSesdC+T7/u7/y+9rG6dXv+rIOsbm9O+4x//78vH7ZkG7ZAgR44LxGLW+ruShtplfavBsCogI32jmjgVfO4NmogboWGgGoAjIcC/rRGmeZnLffUOkofy9Y19KqNVUkiDQa1aU/QFjjQwDWmtlL4XURx2V6FszToNe0QxX11bbb4TW4x4Oop2pU2vq/uwS3vnf28BbA+GMkFYH1dbbjZrr8FrqxthVE3tcDK+6/9e3/w6Y7RrdvzZx1kdeum7R0/4wvKB5X5BOQBQfgjRpV6LlmDKz5PQy4BKdWASxUaFg8aD5w82KtMtTT4QmAPviYRTzWxXdLVlwQoL5WbY+2dyAOmiKyyQ2yr2LaSjQBQKeAjJVrGhOajUrFvear09eL1lFUZibZkjB6cN0rguJiKhEGWThDTOlnVRq7i+VS8ILa5EWrjzc25rqoO8HvU4exyMjokmupwI9AW3uV1W6HElm5VKzPPFcX/6v1dmbPa6yhfujoEakG0aue7/tEXtc+nW7fXr3WQ1a3bJXvHz/iCtTdID4w63GJJ2jYLir9j8LTE2pMCUA1EK3XgXBEn1anxvJ9pLvwhAxjcsgAxiVSDFNbm5nhXe4+WJOsBFCp00p4ySCcV4mEVfSnbk8o1EA0woJbXsADJAFB7zdxTELe3AFYF5vi9CftK4XEt+KoSEi7yh5ZU1tU6bqv2tdvd3Ke9BtY7ZYGUPccGkb9JUm+BKb2Mv1Paa81rcamQszaVzdtBVbc3gXWQ1a3bj8XE8zUvqv5cg0ujCcg8cPH6ZnBjcyq8VhWO3o2Xw0D62ZWCxzUBWtdpA5SAqiFBa09V8r6qdehsqEh7ddhbdp4LcLOejg2tKDkPnSiAQkB3i/HItMJuKa0AZ3UMVZqm5c0T29Ii08ddUg1WLMAywLRpsXF9rNeJPzfOt9r3xvWQZTr8vBWCtHUb56WaHGz9NgBkvQ6iunXrIKtbtw+rveOnfX75sKGrlEKoQ3oq89BaBbSM9teKT7QVbrNgQ3OSQqj4MuLlamWFMYgKbkWCrgCX1oWq+EUFjKwGc9tmzXea5m3AsQWyoLx61gOWksnGtMR4s6Ngjr21HhvjNxXaLcvMPZGLoQMNfpL+rVuEe72urLh9Parrb81mftr1NKiyshbZ3vVPv2S7jd26vTmtg6xu3Z6lVaDLuaY2FQAguNprdMmrpQbEtB/XoaRWSj7QLh+jB/INMcda76smp18EWzGuMjllPevtmZe6bVpPa0vjzH4231eeLBu6tRpjbBpMAmu5Ct1s3/i8YSmEzfDayiPI22gNtbusBay2PFY2tHeBUF/da0Oolr3rn33pUzauW7c3rXWQ1a3b82Dv+Om/s3wwGYsrwGUBypYcAHARVDWX61XHUHu9NJdrrNvoLAHcAiEDsIoWWO2dW5HSTZtXoqXOtRW/TSkXAM1CwdVhNsKGmsNE22JTuR9o/F5bZHZzHGrjHRmSF/rl6jfQ1wVYAW9b2qh7pLp1eybWQVa3bs+rveOn/o7yoSUVsVUuBtskazYbNrLaWZVqty44jTX/pxbFdHX5n4gaOBhdMlGv122zoSsVGrQArPKqWSJ46xpokVlz/ew1W12j1Xn77XUVkVzOQ7fNLrvwW25+x7uzQM2Aq81akQDe+QNftrmsW7duP2brIKtbt9ebiddLl70BNtPxK2t5SjaUtQEgHYb1cm1m/5U3KCa4qeZnVcBkWVbhxcrjIhmKG+FPe+wWB86CF16HgYcOKS6xBrMmNKnLEjXbYIDaCmTZPvUSsLKeqJY1yvZU128Icp7v+r4vvryvbt26PQvrIKtbtze6vePf/V30plW8+pIi90YfYEOFzXWZzK1DmVpvjG1JdTamLjuzcQzREeNsw+zNako4PI1AaQuc2mQBXuWuzL3WZ/V+JX+gZSBgrk1rP/m7nrnXrdvrwjrI6tbtzW7v+Jm/e+3x8vjQPWMw0g/BkcfK8raCCS0CBCIswLLhtUt2CQRdWkcXCpd2hzs9dxetdVzznS5+LN/FiHd97x96+uN069btebUOsrp16/Z09hmf8HtX3zXlD8x3KyB16ftWaLClOwasSvBserJafVlDQys1C4E3D72Wb/C4O8kAvURMt25vMusgq1u3bt26devW7RnYJsjaKOb19Dvo1q1bt27dunXrtranlcDr1q1bt27dunXr9kFYB1ndunXr1q1bt27PwDrI6tatW7du3bp1ewbWQVa3bt26devWrdszsA6yunXr1q1bt27dnoF1kNWtW7du3bp16/YMrIOsbt26devWrVu3Z2AdZHXr1q1bt27duj0D6yCrW7du3bp169btGVgHWd26devWrVu3bs/AOsjq1q1bt27dunV7BtZBVrdu3bp169at2zOwDrK6devWrVu3bt2egXWQ1a1bt27dunXr9gysg6xu3bp169atW7dnYB1kdevWrVu3bt26PQPrIKtbt27dunXr1u0ZWAdZ3bp169atW7duz8CG17oB3d4c9jb3b6QzzuUL5+DkvfyrluPicvOdM2+cWdlsfnkfZGlru6fYf2rsb+s4cI7Wv7hOY/9PeYy08f3F7/BBnoP5/s5j3nXsD/a4zWXpQ24/7C/SuhWqW6de3zXaom9RZ5bZbfT+9G3K3+vtaXn9fbW9OqdLy+t9m/25ell9fLPMnIc9ZlmcNvdvz6W81/tW+3CA6lFW6/MyvYYD8D3/4PS1KaV3oFu3Z2QdZHX7iNgZZ/x8/0vhPPfont47D3hHoMv70uPze+/g1Dqr5fwny7NzVq+vlwNIzpEPVy2X74D1d/y+jAhI8j2vn/cLAB6yPi+nV0jb+HO1HI3vHPKxkNtululX2O9c9Xm9fL1t9b36rhxb7e8p9r3aP7a3L9+nah27jSxf7TOpddRns9zZdWmNvKx+zT834BKcS/nWUOvwodRyL+8LeOLvPOp16HbIy2R5fq+W8zLfWibfx+ozLY8I8h0tD/k9b0/LeVl+5eWg995F2U5vH9R2wUVZn7alY9M6Ma9DxwKAkL/jbQJS3ob3ncq+5T39UdvzOgCCAwKcPMLBOXi4/J3Lnz18/lGDo0/hY7//bejW7RlaDxd269atW7du3bo9A+sgq1u3bt26devW7RlYB1ndunXr1q1bt27PwDrI6tatW7du3bp1ewbWQVa3bt26devWrdszsA6yunXr1q1bt27dnoF1kNWtW7du3bp16/YMrIOsbt26devWrVu3Z2AdZHXr1q1bt27duj0D6yCrW7du3bp169btGZhLaVU1rVu3D7s5574XwPG1bke3bt26KTuklH7Ga92Ibm9c67ULu32k7JhS+rmvdSO6devWjc05992vdRu6vbGthwu7devWrVu3bt2egXWQ1a1bt27dunXr9gysg6xuHyn7U691A7p169bNWO+Xuj1T68T3bt26devWrVu3Z2Ddk9WtW7du3bp16/YMrIOsbt26devWrVu3Z2AdZL1JzZH9MefcDzjn/oFz7hM21vs5zrl/mNf7Y845l79/i3Pu651z359fX87ff1be399zzn23c+6T1L6+1Dn3j5xz/4T35Zx7kNflv/c6574ir/8bnHPvUcv+K7Wvz8nH/n7n3Oeo79/lnPv7+Th/0jkXntEl7Nat20fInHPvcM7909wPfX5j+d459xfy8u9yzn1c/v6tzrlvds49ds79cbX+tXPua5xz35f7ii82+/s1zrl/nJf9ebPsBefcD5n9fUtuH/dVH/1hvwjdXp+WUup/b8I/AL8MwDsBOAC/AMB3baz3t/Nyl9f/zPz9lwL4/Pz+8wF8SX5/H4Xr97MAfF9+/x8A+A4AIf/9LQCf2jje9wD4Rfn9bwDwxxvrvAXAD+bXl/P7l/OyF/KrA/CXAHz2a32t+1//638f+l/uL/45gJ8EYAfg7wP4d8w6vwnAn8zvPxvAX8jv7wH4JAD/je5LAFwD+MX5/Q7At6m+7acA+L9Vn/LR5lj/I4A/b/b3LQB+7mt9rfrf8/fXPVlvXvssAH8ukX0ngJeccx+rV8ifX0gpfWdKKQH4cwB+pdr+K/P7r+TvU0qP87oAdXD8PgE4gDq0PYARwI+a4308gI8GdXiX7DMAfH1K6f0ppQ8A+HoA78jHf5jXGfKxemZHt26vb/tEAD+QUvrBlNIZwP8J6n+06f7oqwB8unPOpZSepJS+HabaRErpJqX0zfn9GcDfBfAT8uL/GsCfyH0LUkrv5u2ccz8HwMcA+LoP5wl2e+NaB1lvXvvxAP6V+vxD+Tu7zg9trPMxKaUfye//NajjAQA4536Vc+77AHwNgP8CAFJKfwvANwP4kfz3tSmlf2KOxzNQDYx+dQ4/fpVz7ic+Tdudc18L4N0AHoE63G7dur1+7Wn7qn8FACmlGcCrAN76NDt3zr0E4D8G8I35q48H8PHOue9wzn2nc+4deT0P4MsBfO7Grv5sDhX+HqZVdOvWQVa3H7NlUJTU57+cUvppIO/WHwQA59xPBvDTQbPFHw/g05xzn2x29dkA/g/1+a8B+LiU0s8Ceau+Ek9hKaXPAPCxII/Zp30Ip9StW7c3gTnnBlCf88dSSj+Yvx5AIcNPBfBrAfzpDMR+E4C/nlL6ocaufl1K6WcC+OT8958/46Z3e51YB1lvInPO/bdMzAR5k36iWvwTAPyw2eSHUVzodp0f5fBifn232RYppW8F8JOcc28D8KsAfGcOJz4G8bt+oWrbvwdgSCl9j9r+fSmlU/74ZwD8HNWui21PKR0B/FWswwrdunV7fdmdz7teJwOnFwG87yn2/acAfH9K6SvUdz8E4KtTSlNK6f8B8M9AoOsXAvjNzrn/F8AfBvDrmTCfUvrh/PoIxNf6xA/i/Lq9ga2DrDeRpZT+RErpZ6eUfjaAvwLqJJxz7hcAeFWF/3j9HwHw0Dn3C7L7+9eDgAsAfDUAzur7HP7eOfeTVQbiJ4C8Se8D8C8BfIpzbnDOjQA+BYAOF/5a1F4sBm9sv0Kt/7UA3u6cezlnNb4dwNc65+4r4DcA+I8AfN8He526dev2XNnfAfBTnHP/tnNuB/J4f7VZR/dH/wmAbzK0g5U5574QBMZ+i1n0V0BeLOQJ4scD+MGU0q9LKf2bKaWPA4UM/1xK6fNzn/a2vP4I4JcD+N4P4Ty7vQFteK0b0O01s78OyjD8AQA3AH4jL3DO/b0MxABykf8vAK5A3qd35u+/GMBfdM79lwD+BYBfk7//1SDwNgG4BfCfppSSc+6rQKG7fwgKLb4rpfTXVHt+TW6Ptv/OOfcrAMwA3g/KNkRK6f3OuT8I6nwB4A/k7z4GwFc75/agCcQ3A/iTH/yl6dat2/NiKaXZOfebQZOrAOB/Tin9I+fcHwDw3SmlrwbwPwH4X51zPwDqKz6bt8+epxcA7JxzvxI0KXsI4AtAk7C/m+eFfzyl9GdQJnH/GMAC4PNSSpe8YnvQJG/M7fsGAH/6w3X+3V7f1svqdOvWrVu3bt26PQPr4cJu3bp169atW7dnYB1kdevWrVu3bt26PQPrIKtbt27dunXr1u0ZWAdZ3bp169atW7duz8A6yOrWrVu3bt26dXsG1kFWt27dunXr1q3bM7AOsrp169atW7du3Z6B/f+AKWvWVTdmTAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -477,7 +496,31 @@ "outputs": [ { "data": { - "image/png": "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\n", + "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" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -489,7 +532,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -501,7 +544,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -513,7 +556,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -534,17 +577,49 @@ "nmean = np.mean(ncount)\n", "delta = ncount/nmean-1\n", "dzrsd = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", + "vtheta = np.bincount(ipix, minlength=npix, weights=cat['VTHETA'])\n", + "vphi = np.bincount(ipix, minlength=npix, weights=cat['VPHI'])\n", "dzrsd[goodpix] = dzrsd[goodpix] / ncount[goodpix]\n", "e1 = np.bincount(ipix, minlength=npix, weights=cat['E1'])\n", "e1[goodpix] = e1[goodpix] / ncount[goodpix]\n", - "e2 = np.bincount(ipix, minlength=npix, weights=cat['E2'])\n", + "e2 = np.bincount(ipix, minlength=npix, weights=cat['KAPPA'])\n", "e2[goodpix] = e2[goodpix] / ncount[goodpix]\n", "hp.mollview(delta, title=r'$\\delta$')\n", "hp.mollview(dzrsd, title=r'$\\Delta z_{\\rm RSD}$')\n", + "hp.mollview(vtheta, title=r'$vtheta$')\n", + "hp.mollview(vphi, title=r'$vphi$')\n", "hp.mollview(e1, title='$e_1$')\n", "hp.mollview(e2, title='$e_2$')" ] }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d0e01bd5-578c-4bbd-bf5d-cd8b1fbf2c95", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FITS_rec([(0, 135.14798 , -72.023506, 0.14752357, 0.00420645, 9.1869111e-08, 6.9041323e-07, 6.3695380e-04, 2.0482158e-04, -5.5567569e-05, 0.00997258, 0.04110185),\n", + " (0, 189.13899 , -74.79645 , 0.14293315, -0.00085942, 3.5034478e-07, 8.1963776e-07, -8.5430373e-05, 3.1329642e-04, -1.7480239e-04, 0.04010854, 0.02486622),\n", + " (0, 255.18294 , -77.3037 , 0.13650647, 0.00199598, 6.7545272e-07, 1.1957115e-06, 5.8054029e-05, -3.0786011e-04, -8.2123920e-04, 0.03487576, -0.02573383),\n", + " ...,\n", + " (0, 21.777729, 79.76989 , 0.13463575, -0.0017074 , 1.8299168e-06, -1.1566977e-06, -4.7826930e-04, -4.0466024e-05, 2.6472006e-04, -0.01369716, -0.00172807),\n", + " (0, 98.69248 , 77.87262 , 0.13808511, -0.00046557, -1.2522990e-07, -1.8932460e-06, -5.6265696e-04, -6.4774256e-05, 7.6205668e-04, 0.00199528, -0.00651289),\n", + " (0, 146.01144 , 79.69646 , 0.14366393, -0.00198077, -3.0381312e-07, 1.2278358e-06, -2.0604710e-04, 1.8634219e-04, 8.2336168e-04, 0.01980355, 0.00248315)],\n", + " dtype=(numpy.record, [('TYPE', '>i4'), ('RA', '>f4'), ('DEC', '>f4'), ('Z_COSMO', '>f4'), ('DZ_RSD', '>f4'), ('VTHETA', '>f4'), ('VPHI', '>f4'), ('E1', '>f4'), ('E2', '>f4'), ('KAPPA', '>f4'), ('DRA', '>f4'), ('DDEC', '>f4')]))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cat" + ] + }, { "cell_type": "markdown", "id": "6322ae20", @@ -556,10 +631,46 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "66d7a6c3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: non-ASCII characters are present in the FITS file header and have been replaced by \"?\" characters [astropy.io.fits.util]\n" + ] + }, + { + "ename": "OSError", + "evalue": "Header missing END card.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/hdulist.py\u001b[0m in \u001b[0;36m_try_while_unread_hdus\u001b[0;34m(self, func, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1108\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1109\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1110\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: list index out of range", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mUnicodeDecodeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/base.py\u001b[0m in \u001b[0;36m_readfrom_internal\u001b[0;34m(cls, data, header, checksum, ignore_missing_end, **kwargs)\u001b[0m\n\u001b[1;32m 405\u001b[0m \u001b[0;31m# that are needed to build the HDU object.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 406\u001b[0;31m \u001b[0mheader_str\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheader\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_BasicHeader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfromfile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 407\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/header.py\u001b[0m in \u001b[0;36mfromfile\u001b[0;34m(cls, fileobj)\u001b[0m\n\u001b[1;32m 2084\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2085\u001b[0;31m \u001b[0mheader_str\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcards\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparse_header\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2086\u001b[0m \u001b[0m_check_padding\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mheader_str\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBLOCK_SIZE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mastropy/io/fits/_utils.pyx\u001b[0m in \u001b[0;36mastropy.io.fits._utils.parse_header\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'ascii' codec can't decode byte 0xe2 in position 7: ordinal not in range(128)", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md_skw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'output/colore_srcs_s1_0.fits'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mv_skw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'output/colore_srcs_s1_0.fits'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mbkg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'output/colore_srcs_s1_0.fits'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbkg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'R'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/hdulist.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[0;31m# instead\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 310\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 311\u001b[0;31m return self._try_while_unread_hdus(super().__getitem__,\n\u001b[0m\u001b[1;32m 312\u001b[0m self._positive_index_of(key))\n\u001b[1;32m 313\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mIndexError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/hdulist.py\u001b[0m in \u001b[0;36m_try_while_unread_hdus\u001b[0;34m(self, func, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1109\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1110\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1111\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_read_next_hdu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1112\u001b[0m \u001b[0;32mcontinue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1113\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/hdulist.py\u001b[0m in \u001b[0;36m_read_next_hdu\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1150\u001b[0m \u001b[0mfileobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseek\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moffset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSEEK_SET\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1152\u001b[0;31m \u001b[0mhdu\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_BaseHDU\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadfrom\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1153\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mEOFError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1154\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_read_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/base.py\u001b[0m in \u001b[0;36mreadfrom\u001b[0;34m(cls, fileobj, checksum, ignore_missing_end, **kwargs)\u001b[0m\n\u001b[1;32m 323\u001b[0m \u001b[0mfileobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_File\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 324\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 325\u001b[0;31m hdu = cls._readfrom_internal(fileobj, checksum=checksum,\n\u001b[0m\u001b[1;32m 326\u001b[0m \u001b[0mignore_missing_end\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mignore_missing_end\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 327\u001b[0m **kwargs)\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/hdu/base.py\u001b[0m in \u001b[0;36m_readfrom_internal\u001b[0;34m(cls, data, header, checksum, ignore_missing_end, **kwargs)\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[0;31m# in the wild.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 412\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseek\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mheader_offset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 413\u001b[0;31m header = Header.fromfile(data,\n\u001b[0m\u001b[1;32m 414\u001b[0m endcard=not ignore_missing_end)\n\u001b[1;32m 415\u001b[0m \u001b[0mhdu_fileobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/header.py\u001b[0m in \u001b[0;36mfromfile\u001b[0;34m(cls, fileobj, sep, endcard, padding)\u001b[0m\n\u001b[1;32m 520\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 521\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 522\u001b[0;31m return cls._from_blocks(block_iter, is_binary, sep, endcard,\n\u001b[0m\u001b[1;32m 523\u001b[0m padding)[1]\n\u001b[1;32m 524\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/astropy/io/fits/header.py\u001b[0m in \u001b[0;36m_from_blocks\u001b[0;34m(cls, block_iter, is_binary, sep, endcard, padding)\u001b[0m\n\u001b[1;32m 607\u001b[0m \u001b[0;31m# TODO: Pass this error to validation framework as an ERROR,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 608\u001b[0m \u001b[0;31m# rather than raising an exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 609\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mOSError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Header missing END card.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 610\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 611\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mheader_str\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfromstring\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mheader_str\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mOSError\u001b[0m: Header missing END card." + ] + } + ], "source": [ "d_skw = fits.open('output/colore_srcs_s1_0.fits')[2].data\n", "v_skw = fits.open('output/colore_srcs_s1_0.fits')[3].data\n", @@ -569,32 +680,28 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "3e0b0bd4", "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "ename": "NameError", + "evalue": "name 'r' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\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 1\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md_skw\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md_skw\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m31\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'k--'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlw\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'r' is not defined" + ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAAEOCAYAAABSLcpPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABLZUlEQVR4nO3dd3wU1RbA8d9JA0IJhE5C771FilIEaQoCKioIgoKABZ9dsTz7U+wNRZCqooCgggUQBBSQFnrovQQIJZCEkn7fHzNoiOnZ7GzI+X4++8nu7Myds0PYk3vnFjHGoJRSSrmDl9MBKKWUKjg06SillHIbTTpKKaXcRpOOUkopt9Gko5RSym18nA7Ak5UpU8ZUq1bN6TCUUipfWb9+/WljTNm03tOkk4Fq1aoRGhrqdBhKKZWviMih9N7T5jWllFJuo0lHKaWU22jSUUop5TaadJRSSrmNJh2llFJuo0lHKaWU22jSUUop5TY6Tkf9mzFwaifsWwpl6kD1DuDj53RUSqmrgCYddaUNX8HKD+HM3n+2FQqABr2h8wtQvIJjoSml8j9tXlP/WP4ezBsFRUpBz/fh0a0wYCbU6wlbZsGnrWDjdKsmpJRSOSC6cmj6QkJCTIGYBscYWPI6LH8XGt8OfceBt++V+5zeA/MehsOrIKAylK0HZetClTZQ9TrwD3QmdqWUxxGR9caYkLTe0+Y1BavGWgmnxWDo9SF4ef97nzK14Z5fYdPX1r2eM3vg4HLrWARqd4M7v9Z7P0qpDGnSKegOroBFL0H9m6HXR+CVQYurl5eVmFoMtl4nxkP4etg9H1Z+BH+MgRtedE/cSql8SZNOQRZ9DL67BwJrQJ/PMk44afHxg6ptrceFM7DiA6jdHaq0zpNwlVL5n3YkKKiSk2D2UIi/aDWLFS6Ru/J6vAkBwfDDSIg775oYlVJXHU06BdWa8VangF7vQ7l6uS+vcAm4ZTycPQjL3sx9eUqpq5ImnYLo7EFY8pp187/Jna4rt+q10LQ/rJsE50+5rlyl1FVDk05BYwz89CiIlzUWR8S15bd/ApLiYNUnri1XKXVV0KRT0GyeAfuXQpeXoWRl15dfpjY0vBXWToSLka4vXymVr2nSKUgunYNF/4XgayBkWN6dp8OTkHABVn+Wd+dQSuVLmnQKkmVj4MJpuOnd7HePzo5y9aF+b6uzwvmTeXcepVS+o0mnoIjYBmsnQMi9UKlZ3p+v03OQlADT+0FcTN6fTymVL+jg0ILAGPj1aatbc+f/uuec5erDHdPg2wEwc5A1cejp3VY37ehjcCkSfP2h4zM6b5tSBYgmnYJg8ww4tMLqrebOL/g63aHPWPjxAXirKiTGWtu9fMG/NFw8Azt/gdunQXBL98WllHKMxyYdEekBfAR4AxONMWNSvV8I+BJoCZwB7jTGHLTfexYYBiQB/zHGLExxnDcQCoQbY3q54aM4K+YELHgGKreBlve6//zN7oLEOAgPhWrtoVo7KBFkddUO3wCzhsBkOzk17e/++JRSbuWRScdODJ8CXYGjwDoRmWeM2Z5it2HAWWNMLRHpD7wF3CkiDYD+QEOgErBYROoYY5Ls4x4BdgC5nPclHzAGfnnC+tLv82nedh7ISMi91iO1oBYw8g+YNRjmjrJWKQ1q4f74lFJu46kdCVoBe40x+40x8cAMoE+qffoA0+zns4EbRETs7TOMMXHGmAPAXrs8RCQY6AlMdMNncN6272Hnz9ZN/TK1nI4mbf6BcMeXUKw8zL4XYqOcjkgplYc8NekEAUdSvD5qb0tzH2NMIhAFlM7k2A+Bp4Hk9E4sIiNEJFREQk+dysdTuez8xao9VGoBbR5yOpqM+QdCv0lw7gj89IiuTKrUVcxTk47LiUgv4KQxZn1G+xljJhhjQowxIWXLlnVTdC62ehzMGGj1ILtrJnh7ZCvqlaq0gc4vwLYfYOPXTkejlMojnpp0woGUc7QE29vS3EdEfIAArA4F6R17HdBbRA5iNdd1FpGr69vt1C6ri/KC0VCvJwz5GYqVczqqrLvuUauzwYJnrVqPUuqq46lJZx1QW0Sqi4gfVseAean2mQcMsZ/3A5YYY4y9vb+IFBKR6kBtYK0x5lljTLAxpppd3hJjzCB3fJg8F38Bfn4MPmtjrQTa5WXrPomfv9ORZY+Xl9WLDQPzRkFyuq2gSql8yiPbXYwxiSIyCliI1WV6sjFmm4i8CoQaY+YBk4CvRGQvEImVSLD3mwVsBxKBh1L0XLv6RB+Db/vD8S3QeiR0eBqKlnY6qpwrVQ26vQ4/Pwqhk6DVcKcjUkq5kBi9aZuukJAQExoa6nQY6Tu2Cb65E+LPw22ToG4PpyNyDWPg69vg0Eq4d752o1YqnxGR9caYkLTe89TmNZWZ86fgmzvA2xeGLbp6Eg5YA0dvGQ9Fy8KMuyD6uNMRKaVcRJNOfpScDD/eb41puWsmlG/gdESuV6wsDPgWYqOtxJNwyemIlFIuoEknP1r9KexdDN3/B+UbOh1N3qnQGG6dAMc2wNSe1kzZSql8TZNOfnMiDBa/DPV65e1CbJ6ifi/oNwXOHoTxHazPriuSFijh5y6xbNdJ4hKv3v5ABYlH9l5TGVj5IfgUgd6fWPc+CoJGt0KN6+G3F2DFB9bicM0HwbUPQ8kqTken8siEP/cxY+0R9p++AEDV0v680LMBXeqXQwrK7/5VSGs6+UnUUWvEfovBBW8NGv9A6PsZ3L8SGvSF0CkwuYc1RklddZbsjOCNX3dSplghXuhZn7F3NcfX24vhX4Zyz5R1HIm86HSIKoc06eQnayeASbbG4xRUFRrBLeNgyE8QHQ4rP3I6IuViMbEJPP9DGHXKF+Pr+1pzX/sa9GpSifmPtOfFXg0IPRhJ9w//ZOrKAyQn65CP/Eab1/KLuPMQOhXq94ZSVZ2OxnlV20Kj26yk0/xuKFk582NUvjBm/k4iomMZN+g6/Hz++bvY19uLoe2q061heZ7/IYyXf9rOnA3hvHRzA0KqFZyavzGGDYfPsnzPadYeiGTvyfNUDChMldJFaVGlJLc0D6Kkv5/TYaZLazr5xabpEBcFbUc5HYnn6PKK9XPxy46GoVxn7YFIpq85zNDrqtOscsk09wku5c/Ue6/ho/7NOBUTR7/PV/GfbzdyMibWvcG6mTGGxdsjuHXcX9w2bhUf/76H6NgE2tcuS4kivmw4dJZXftpO6zd+5/GZm9h+LNrpkNOkMxJkwGNmJDAGPmkB/mXgvkVOR+NZlvwP/nzbGiBbuZXT0ahcGjhxNftOXmDJkx3x98u8IeZifCKfL9vH53/up4ivNy/2asCtLYKuuo4G245F8cKPYWw8fI7gUkW4v2NNejerRInCvv/a79u1h/lx4zHOxyXSrUF5HulSm4aVAtwab0YzEmjSyYDHJJ1Tu+HTa6DXBxAy1OloPEv8BXi/AdTpbo3pUfnWnogYun7wJ091r8tDnbK36ODek+cZPWcLoYfO0qV+ed6/s+m/vpDzo6hLCXy4eDfT/jpIYFE/nu5Rj1uaB+HrnXEjVdTFBCavPMDklQeIiU3k1uZBPNWjLhUDirgl7oySjt7TyQ/2L7N+1ujkaBgeya8oNOgDW2dbCcivqNMRqRya+tdB/Hy8GNAq+93ga5UrxqyRbZm88gBj5u+k76cr+WJwCDXLFsuDSLMuMSmZNQciORx5kcgL8VyKT6JSySJULe1PlUB/KgYUxieNBBKfmMzXqw/x8ZI9RF1KYGDrKjzVrR4B/llLpAH+vjzWtQ5D21Vn3LJ9TF55gF/DjvNYlzqM6FDD0ZqgJp38YP9Sa/blwOpOR+KZmtwBG6bBrvnQuJ/T0agciLqYwPcbwunTtBKBRXN2E9zLS7ivfQ0aBQXw0PQN9B27kqlDW9GyaikXR5u5PRExzN5wlB82hHMyJu6fGAVSdrjz8RKCShWhSqA/lQP9KeLrzc4T0YSFRxN1KYF2tcrw3E31aVCpRI7iCCjiy+gb6zGwdRVe/2U7b87fSeihs7x3h3M1QW1ey4BHNK8lJcJb1aDxbXCzdg9OU3IyfNgIyjeCgbOcjkblwMTl+3n9lx38/HA7GgXl/v5D+LlL3PXFai7FJ/Hzf9pRrnhhF0T5jyORF1l7IJIift4ULeSDMYbYhCSOR8Xy46ZjbD5yDm8voVPdcvRrGUST4JIEFvXD19uLE9GxHD5zkcORFzgceZHDkZc4fMZ6fiE+iXoVitOgYgl6NKpAxzplXVYrMcYwZeVB3vh1B8GlivDl0NZUKZ03a25p81p+dmwDxMdo01pGvLys7tOrP4MLZ/L3ekIFUFKyYdqqg7SqFuiShAMQVLII4+9uyS2f/sWo6RuZPrx1pvdBsuLwmYuMXbqH7zeEk5jOGKF6FYrzQs/69GkWRNnihdKMLahkEdrW/PfvqTEmz5q+RISh7arTODiA4V+GMnDSar4beS0VAlybkDOjScfT7VsKCFTv4HQknq3JHfDXx7D9B7jmPqejUdkwP+w4RyIv8eyN9V1abr0KJRhzW2MembGJN37dwUs3525y3L/2nuaeKetAYFCbqgxoVQWD4UJcIiD4+3lTvLAPQSWL5DhxuONeyzXVApl2bysGTlzDoElrmDmiDaWL/Ts55hVNOp5u/zKo1KzgTXuTXeUbQdn6sOU7TTr5SHKyYeySvdQsW5TuDSu4vPw+zYLYePgcU1YepG+zIJqmM/YnM7tOxDDy6/VUK+PPV8NaU76Ee2sHrta0ckkmDQlh8OS13DNlHTNHtslSF3VX0MGhniwuBo6utSa7VBkTgSa3w5HVcHqP09GoLFq0I4KdJ2IY1bkW3l5581f+k93rUrqoH2/8uoOc3MOOiI7l3ilrKeLrzZR7W+X7hHNZ6xql+WxgC7Ydi+LxmZvdNqWQJh1PdugvSE7U+zlZ1fxu8C4Eq8c5HYnKAmMMnyzZQ9XS/tzcpFKenadYIR8e6VKbNQciWbrrZLaOvRSfxH3TQom6lMDke64hqKR7xrm4yw31y/PcTfVZsO0E7y3a5ZZzatLxZPuXgU9hqNza6Ujyh2LlrNrOpm90zZ18YOmuk4SFR/PQ9bXSHKviSgNaVaF6maKMmb+TpCz+RW+M4ek5Wwg7FsXHA5q7rJODpxnWrjoDWlXm06X7mLspPM/Pp0nHkx1YbiUc36ujOu8WbR6CxEuwforTkagMxCUm8faCXQSVLMItLYLy/Hy+3l483b0uuyPO813okSwd89myffy0+RhPda/LDfXL53GEzhERXundiFbVAhk9Zyu7I2Ly9HyadDzVxUiI2ArV2zsdSf5SvoHVHLlmAiTGOx2NSsdb83ex80QMr/Zp6JKuzFnRo1EFrqlWijfn78x0ctB5m4/x7m+76N20Eg90rOmW+Jzk5+PF2LuaU7SQD/d/vZ7zcYl5di6PTToi0kNEdonIXhEZncb7hURkpv3+GhGpluK9Z+3tu0Sku72tsogsFZHtIrJNRB5x48fJvkMrrZ/VNOlkW9tRcP6EteCd8jhLd51k8soDDGlb1a01CBFhzG1NuJSQxPM/hKXbqWBW6BEenbGRa6oG8tZtTa66yUPTU65EYT4e0IyDpy/w7Pdbc9TpIis8MumIiDfwKXAj0AAYICINUu02DDhrjKkFfAC8ZR/bAOgPNAR6AJ/Z5SUCTxhjGgBtgIfSKNNzHFgOvv5QqYXTkeQ/tW6wuk8vfgmijzkdjUrhVEwcT323mbrli/PsTa4dl5MVNcsW48ludVi0PYJ5m6/83TDGMGnFAZ6evYXrapVh2tBWFPHzdnuMTrq2Zhke71qHnzYfY9H2iDw5h0cmHaAVsNcYs98YEw/MAPqk2qcPMM1+Phu4Qaw/SfoAM4wxccaYA8BeoJUx5rgxZgOAMSYG2AHkfWNyTh1cYd3P8fHcxZg8lgjcNtHqcv5tf13S2kMkJiXz8LcbiIlN5OMBzSns68wX+rB2NWhepSQvzdvGrHVHOHcxnl0nYhjwxWpe+3k7XRuUZ+KQkAKXcC4b2bEmNcsWZcyCnSQkJbu8fE9NOkFAyrt9R/l3gvh7H2NMIhAFlM7KsXZTXHNgTeoTi8gIEQkVkdBTp07l7lPk1IXTcHIbVGvnzPmvBhUaQb/JcGIrfD/Cmp9NOeqd33axen8kb9zSmLoVijsWh7eX8O7tTSnl78fTc7YQ8vpibvp4OTtPxPC/Wxrx+aCWFPIpmAkHrE4Xz95Yn/2nLjBj7WGXl1/gZiQQkWLAHOBRY8y/ltYzxkwAJoA14aebw7Ncvp+jU9/kTp3u0P0NWDAavr4F+n4OJSo6HVWBtCDsBOP/2M/A1lW4rWWw0+FQs2wxljzRkbDwaH7ZehyAkR1qUCqHM1xfbW6oX442NQL5YPEe+jQPcumM1J5a0wkHUi56H2xvS3MfEfEBAoAzGR0rIr5YCWe6Meb7PIncFQ4sB9+iUKm505Hkf63vt2bnPrIWxrWF7fOcjqjAOREVy1PfbaZp5ZK8eLPn3EYVERoHBzD6xnqMvrGeJpwURITnb2pA5IV4Pl+2z6Vle2rSWQfUFpHqIuKH1TEg9bfFPGCI/bwfsMRY3S3mAf3t3m3VgdrAWvt+zyRghzHmfbd8ipw6uAKqtAHv/L/yoeNEoOU9MHK5tSbRrLth7kMQd97pyAqMl+aFkZCczCf9mxfoZqv8pnFwADc3rcSXqw4RE5vgsnI9MunY92hGAQuxbvjPMsZsE5FXRaS3vdskoLSI7AUeB0bbx24DZgHbgQXAQ8aYJOA64G6gs4hssh83ufWDZcX5U3Bqh97PcbUytWDYImj/BGycDp+3g31LQNeTylMLwk6wcFsEj3Wpk2drt6i8M7x9dc7HJfJd6FGXlamLuGXAkUXcts6GOcPgvt8hOM01kFRuHfoLfhgJ5w5DUAh0eBJqd7fW5VEuExObQJf3/6B00ULMG3Vdnk91o/JGv3F/cTImjqVPXp/lSVkzWsRNfws8zf5lUChA7+fkparXwqhQ6PUBXDhpdase2xJWfQaxUU5Hd9V4c/5OTsXE8eatjTXh5GND21XncORFluzM3mSp6dHfBE9ijJV0qrcHL237zlM+hSBkKDy8AW6bBEXLwsJn4ZMQ2P+H09HlqT0RMew/lbf3tJbsjOCbNYe5r32NHK9hozxDtwblCSpZhMkrDrikPE06niRyP0QdgZq6lIHbePtC434w7De4bwkUKQlf9oGlb0ByktPRuVRCUjJvLdhJ1w/+pPN7f9B77Aqmrjzg8gGAp8/H8fTsLdSrUJwnutVxadnK/Xy8vRjctiqr9p9h+7F/jTLJNk06nmTfEuunrp/jjOCWMGIZNB0Af7xlje+5ShyPukT/CasZt2wfd4ZU5oWe9UlKNrz803ZGfBnKpXjXJFhjDKPnbCX6UiIf9m+mvdWuEv2vqUJRP2++WL4/12UVuMGhHm3/MgioAoE1nI6k4PIrCreMg8IBsGacNeFqg96ZH+fBYmITGDJ5LeFnL/HxgOb0bmotmHZf+xpMX3OIF34MY9CkNUwaEkJJ/4zHqhhj2B1xnoNnLnD83CUSkgz1K5agXsXirNx7ms//2M+O49G80LM+9SqUcMfHU24Q4O/LXa2rMHnlQR7vWofKgTnviahJx1MkJ1mDQhv0tsaWKGd1fdVa+nruKKjYxBrjkw8lJRsenbGJfacuMO3eVrSrXeaK9we2rkopfz8enbGJPp+u5NU+jehYp+y/yrkYn8jcTcf4atUhth9Pv4mlVrlivNOvCf08YNYB5VrD2tVg6l8Hmbh8P6/0aZTjcjTpeIpjGyEuSu/neAofP+g3BcZ3gNlDYehv4J3//ru8vWAnv+88yWt9Gv4r4Vx2U+OKlClWiGfmbGHI5LV0b1ieG+qVx7+QNxfiElm84yTL95wiNiGZehWK81rfRjQLLknFkoXxFmHbsWi2H4+iZtlidKpbDq8sdqtV+UuFgMLc0jyIGeuO8PANtSlTrFCOysl//4uuVvuXWj+rd3Q2DvWPwOrQ8334/j7YMhOaD3Q6oiy7EJfIS/O2MXv9UQa1qcLdbatluH+r6oEseLQ9E5cfYOySvSzc9s+09hUDCnNnSGV6Na1ESNVS/1pfpl3tMukmNHV1GdGhJt+tP8q0vw7yRLe6OSpDB4dmwK2DQ6f0hLhouH+5e86nssYYmNARLp2FUevdstTE2Qvx7I6IoWnlktme/t8Yw4bDZ3nquy0cOHOBUZ1q8cgNtbM1TuZSfBJnLsRxIS4Jby9rcsyCspCZytz9X63nr32nWf5MZwKKpD1VV0aDQ7Wm4wlio637B21HOR2JSk0EOv8XpveDDdOg1fA8Pd36Q2d5cPp6IqLj8Pfzpl2tMozsWIOWVQMzPO5CXCIz1x1hVugRdp6IoUKJwnxzXxva1iyd7RiK+HkT7KdT1qi0PXxDLRZsO8GEP/fxVPd62T5eu0x7gv3LIDnRmopfeZ5aXaByG/jzXYi/mGen+Wr1IfpPWEUhH28+vLMZt7UIZuORcwyYsOZfq1ymtGLPabp/+Cev/rwdPx8vXu/biEWPd8hRwlEqMw0rBdC7aSUmrTjAyejYbB+vSccT7PnNmvomuJXTkai0iMAN/4XzJ2DdxDw5xU+bj/HfH8NoV6sMP41qR9/mQbzWtxGLH+tIsyol+c+3G/n8j30kJf/THH486hJPfbeZQZPW4OftxcwRbZg3qh2D2lSluAvXP1EqtSe61SExyfDR73uyfaw2rznNGNizCGp1zpe9owqMau2gxvXw18dWE5tvEZcVfTI6lv/ODaNp5ZJ8MTjkivsvAf6+fDm0FU98t5kx83cyZeUB+jYPIi4hmW/WHsYYw/0da/Jol9qOLf+sCp6qpYtyV+sqTLenOqpepmiWj9WajtNObLX+gq7dzelIVGY6PAUXTsGGr1xWpDGGZ7/fyqX4JN67vWmaN/wL+3rzSf/mjBvYgsZBAUxafoCvVh/i1uZBLHniekbfWE8TjnK7UZ1r4eftxYeLd2frOP3T2ml7frN+1uribBwqc1Wvs+7trPzIWhjOBT3Zvlt/lN93nuS/vRpQq1yxdPfz8hJubFyRGxtXJPJCPInJyZQrXjjX51cqp8oVL8zgtlX5Yvl+Hu9ah6qls1bb0ZqO0/YsspYxKFbO6UhUZkSsReCij8LWWbkubndEDC/P20br6oHce221LB8XWNRPE47yCMPaVcfH24vP/8j6nGyadJx0MRKOrs3XTWvn4xJ5ed42+k9YxbzNx0h08YzFHqd2V6jQBJa/n6tZqKNjE7j/q/X4+/nw8YDmOopf5UvlShTm9pbBzFl/lIgs9mTTpOOkfUvAJOfbpLNiz2m6f/An01Yd5EjkJf7z7UY6v/cHf+077XRoeedybSdyH2z9LkdFGGN4ctZmDkVe5NO7mlO+hNZaVP41skNNEpOTmZjFGag16Thp9wLwL50vVwmds/4ogyatoZCPF9+NbMvypzsx/u6WeHsJ//l2I2fOxzkdYt6p3xsqNoPFL0Nc9hZD234smiFT1vHb9gieu6k+rWvoWBqVv1Up7U/vppWYvuYw5y7GZ7q/Jh2nJCVYnQjq9Mh3q4Qu3XWSp+ds4bpapfn1kfaEVAvEy0vo3rAC4wa1IPpSIi/8GMZVO8WSlxfc+DbEHIeVH2a468X4RP7cfYov/tzP/V+tp+cny9l85Bwv9KzP0OuquSVcpfLaA9fX4mJ8ElP/Opjpvtp7zSmHV0NslJV08pFNR87x4NcbqFehOJ8Pavmvrrr1KpTgsa51eGvBTuZtPkafZkEORZrHqrSGxrfDyo+h+d1Qquq/djl85iL3TFnL/tMXAChbvBAjO9TkgY41CfDXwZvq6lG3QnG61C/PlJUHGd4+4/XAPLamIyI9RGSXiOwVkX8t4SgihURkpv3+GhGpluK9Z+3tu0Ske1bLdKvdC8DbD2p2djSMrEpONkxdeYD+E1ZRprgfU+69Jt1R7yM61KB5lZK8OHcbp6/mZrYur1i11IXPWYN8U9h6NIpbx63kzIV4xt/dkg3/7cq657sw+sZ6mnDUVenBTjWJupTAt2sPZ7ifRyYdEfEGPgVuBBoAA0SkQardhgFnjTG1gA+At+xjGwD9gYZAD+AzEfHOYpnuYQzs+hWqd4BC6Y/N8AQX4xP5Y/cpBk5cw8s/badNjdLMvv/aDLvsensJb9/WhOjYBCatOODGaN0sIMgaMLrzZ2umAtuO49Hcac+hNueBtnRvWIHAonk/O7VSTmpRpRRta5Rmwp8Zdyjw1Oa1VsBeY8x+ABGZAfQBtqfYpw/wsv18NjBWrPnX+wAzjDFxwAER2WuXRxbKdI/TeyByP7R50O2nzoojkRdZuO0Ei3dEsP7QWRKSDMUK+fDWbY25I6Rylqa5r12+ODc1qshXqw5xf8ea6U6Bnu9d96g1q8SiF6FkVUyDPrz603YK+Xjx/YPXas80VaA81KkWgyatyXAfT006QcCRFK+PAq3T28cYkygiUUBpe/vqVMdevrGQWZnusXu+9dOD7ucYY1i2+xSfLtlL6KGzANQtX5yh11Xn2lpluKZaKfz9svfr8mCnmvyy9ThfrTrIqM618yJs53l5Qd9xEB0OP4xkXWQRVu1P5JXeDTXhqALnulqlaRIcwKGMdjLGeNwD6AdMTPH6bmBsqn3CgOAUr/cBZYCxwKAU2yfZ5WVapr19BBAKhFapUsUYY8xLL71kgL8foaGhJjQ09IptL730kjHGmIoVK/69rUWLFsYYY4YPH37FvuHvXm/m3V//im3jx483xgrg70evXr2MMcb06tXriu3GGDN+/Pgrts2bN8+Eh4dfsW348OHGGGNatGjx97aKFSum+ZnaPTnRVBjyYc4/U3i4mTdv3r8+0z2T1zj2mXL975TOZ0rz3+n8KdOrYYmr6zNdjf9O+pny/DPVadjEAKEmne93j1w5VETaAi8bY7rbr58FMMa8mWKfhfY+q0TEBzgBlAVGp9z38n72YRmWmVqerBx6MRLeqQntn4TOz7u27GyKTUjivd92MXHFASoFFOGRG2rTt3kQfj6uu9UXejCSfp+v4sVeDRjarrrLyvVE3/+2lM4rB+JbohxFH1gC/hkvvKbU1SqjlUM9siMBsA6oLSLVRcQPq2PAvFT7zAOG2M/7AUvsvwLmAf3t3m3VgdrA2iyWmff2/AYmGeo627R28PQFen2ygi+WH+CuVlVY+FgH7rimsksTDkBItUBaVQ9kwp/7iU+8eqfIibqYwKurE/i47Cv4XwyHmXdDYuYD5ZQqaDwy6RhjEoFRwEJgBzDLGLNNRF4Vkd72bpOA0nZHgcf5p4azDZiF1UFgAfCQMSYpvTLd+bkA2DUfipWHis7NQvDXvtP0+XQlZ87H8dWwVvzvlsYUK5R3t/dGdarFiehYfth4NM/O4bSxS/cQdSmB2269A+k9Fg6tsGajVkpdwSOb1zyFy5vXEuPh7RrQ6Fbo/XHm+2fR9mPRPD5rE+HnLhGfmEyxQj4MbluNe66tdsWYkNiEJCatOMAHi3ZTrUxRJg0JyfJ05LlhjKH32JXExCaw+PGOaa4Zk58dOnOBLu//wS3Ng3i7X1Nr43f3wM5f4IG/oMxV2olCqXRk1Lzmqb3Xrk6HVkB8DNS90WVFrtx7mpFfradYIR9uaxFMIR8v9p48zweLd/PF8v10qV+O2uWL4+/nzRd/7udYVCzdG5bnndubUsJNSxqLCA91qsn9X2/g17AT9G5ayS3ndZcx83fi6+3FE93q/rOxx1vWhK4/PQJDfrZ6uSmlNOm41a4F4FMYqnd0SXHztx7nPzM2Ur1MUabe24pKJf9ZQnnH8WjG/7GPtQci+XHTMQAaBwXw7h1NubZmGZecPzu6NahArXLF+GzpXm5uUjFLY33yg3UHI5kfdoLHu9a5sot08fLQ9TX46T+w8Utr0TelVNaTjoh0AaKNMWvzMJ6rlzHW+JwancDPP9fFnTkfxzNzttCwUgDThrb61+DL+hVL8GF/675RTGwCEdGx1ChTzLF1W7y8hAevr8njszazcFsEPRpVcCQOV0pKNrw8bxsVShROe76pFoOt5Q8WvmDNPhGY8ZxUShUE2anzvw/UTb1RRBqLiC57mZmT2+HcYZf1Wntv0W4uxCfxTr8mmY72L17Yl1rliju+UNjNTStRp3wxXpoXRtTFBEdjcYUZ6w6z7Vg0z/esTxG/NGYKF4G+n1lNa7OHaW82pche0qkNrExjeyvgK9eEcxXb5bpZCLYdi+LbtYe5u01Vapcvnuvy3MXX24v3bm/GmfPxvPyT+zsOutLZC/G8s3AXbWoE0qtJxfR3LFkFen8CxzbAktfcF6BSHio7Secc1uDL1FYA17gkmqvZzl+gUgsonrtmJWMMr/y0nZJFfHmsSx0XBec+jYMDeKhTLX7YGM6CsOPp7peYlOzR43reW7SLmNhEXu7dMPP7Uw36QMt7rUlBN053T4BKeajsdCRYADwD3Jpqu7f9UOmJPGD9pdv11VwXtWh7BGsPRPK/Wxrl2ynyR3WuxeIdETw9ewu7TpxnQKvKeHkJv249zm/bIjhw+gInomPx9/Pm8a51uLtNVY/qZr3jeDTfrDnM4LbVqFehRNYO6vEmnN4Ncx+E/UvhpnehSMk8jVMpT5TlcToiUglYA2wEXjLGbBSRYsDnQFVjTPu8C9MZLhuns+IDa2njR7akudhXdtz62UpOxsSx7MnrPeqLOLsOnr7Af+eGsXzPaXy8BIN1Y752uWI0rFSCyoH+bDpyjuV7TlOvQnHevb0pjYICnA4bYwx3T1pL2LEo/niyU/YSf1Ki9buw7E0oEQS3joeq1+ZdsEo5xCXjdIwxx0SkDTABWC8iCfbxZ4GbXRLp1WrbDxAUkuuEE3owkg2Hz/HyzQ3ydcIBqFamKF8Na82B0xeYue4I3l5WR4OUNQdjDAu3RfDyvG0MnryWOQ9cS/UyeT+YNSPLdp1ixd7TvNirQfZrmt4+0PEpqNkJ5twHU3tC+yeg4zPgnT9rrUplV45mJBCRKkAzIAFYY4yJdHFcHsElNZ0z++CTFtDtf3DtqFwVNeLLUNYejOSv0Z2zvcxAfnbg9AVu/WwlJYr4MueBaylTrJAjcSQmJdPjo+UkJiXz22MdczdPXVwMLBgNG7+Gqu1gwLdQOItNdUp5uFxN+Cki74tIexH5e19jzGFjzDxjzPyrNeG4zLYfrJ8N++aqmP2nzrNoRwR3t6laoBIOQPUyRZl0zzVERMcybOo6LsUnORLHjHVH2HvyPKNvrJ/7iVELFYc+n8ItE+DIaviyjzUDuVJXuaz8zykCzAAiRGSqiPQVkSKZHaRs236Eyq0hIDhXxXyx/AC+3l4MblvNJWHlNy2qlOLj/s3ZEh7F8z9sxd1zBsbEJvDBot20qhZI94blXVdw0zvhzq8hYpvV3Hb+pOvKVsoDZZp0jDEPGGOCgJ5AOPA6cFpE5onIUBFJqxu1AmtZ6oit0DB1h7/sOXbuEnM2HOW2FkGULe5M05In6NawAo/eUIfvN4bz9ZrDbj33uGX7OHMhnhd61Xf9FD51b4SB38HZgzDtZjh/yrXlK+VBstxGYIxZa4x53hjTCGgK/AHcAxwVkRUi8qSIBGVYSEGz+VsQL2ucRi58tHgPGGv98YLu4c616FS3LK/+tI0Nh8+65Zzh5y4xacUB+jarRJPgknlzkhod4a5ZcPaQ1dR24UzenEcph+W0YXo/cNYY0wEIBiYD7YABrgos30tKtAYC1u4OJTIYsZ6JvSfP8936IwxsU4XgUrmfsy2/8/ISPryzORUDivDQ9A2cu5j3U8u8s2AnAE/1qJe3J6re3upQELnPqvGcO5K351PKATlKOsaYZGCk/fyUMWayMaavMeZdl0aXn+35Dc6fsCZ9zIX3F+2iiK+31nJSCPD35dO7WnD6fBzPfp+393c2HTnHj5uOMaxddYJKuuFWZs1OVuKJOgJfdILDa/L+nEq5UW664ISKSO76AF/NNkyDYhWgdrccF7Hl6Dl+3XqCYe1rONZN2FM1Dg7gyW51mR92ghnr8qZGEJ+YzOg5WyhXvBAPXF8zT86Rppqd4b7F4FcMpvWC0CnWLOVKXQVyk3SCgcdF5KCIfCMiz4pIL1cFlq9FH7NqOs0HWgMCcyA2IYnRc7YSWNSP4e2ruzjAq8Pw9jVoV6sMr/y0jb0nz7u8/M//2MfOEzH875bGFHfTgnd/K1sXhi+BqtfBz49aK5FeOpe1Y2OjYNO38O0AGFMVfnwQoq7epcJV/pLlpCMiTVK+Nsb0McbUABoBHwGngC6uDS+f2jgdTDI0H5TjIl6et43tx6N59/Ym7v/Cyye8vIT372hKYV9vnnNxN+pdJ2L4ZMkebm5aia4NXNhFOjv8A2HQ99DlZdj5M3zeDrbMguR0xikZYyWbj5rBj/fD8c1Q43prTZ+PW8Dvr6V/rFJukp2azjp7nM4VA06MMeeNMWuMMRONMY+6Nrx8KCkBNnxprQ6aw0W75qw/yox1R3jw+pp0rufQF14+Ua5EYZ7pUY+1ByL5YWO4S8q8GJ/IU7M3U7ywLy/f3MAlZeaYlxe0ewyG/gaFA+D74fBZW+t3LNqepTvhEuxZZPV6+/F+KF0Lhi6ER8Pgjmnw8HqrB+Xyd2H2vZAY5+xnUgVadtp+mgFvArtFZCzwhjHmXF4Ela+FToGow9DzvRwdvv1YNM//uJXW1QN5vGv+W7rACXeGVGbmuiO88esObqhfPtNF7TJy+nwcw6auIyw8is8GtqS0p9xLC24JI5fDjrmw9E2Y97C1PbAmRIdDYiwUCrB+71oOtZLVZSWrwG1fQMWm8NvzVjNd/+nWrAhKuVm2514TkWuBt4AGWEnoE2PMVfmnU7bnXouNho+bQfmGMHietXJkNpyMiaXv2JUkG5j38HWUK144ewEXYGHhUfQeu4JBbaryap9GOSpj14kYRnwVSkR0LJ8MaOFcs1pmkpMhIsxaIuHQKihVDWp3te7/+GbyO7PpW5j7EFRsAgNnQ9EymZ/PGNi9AMLXW7/jCRetXnb1eoGPhyRl5VEymnstRxN+2oX2Af4HFAf+a4z5MuchXlFuIDATqAYcBO4wxvxrFKCIDAFesF++boyZZm9vCUzFmr7nV+ARY4wRkXewZsOOB/YB92ZWU8t20vn9VVj+HoxYBpWaZ/04rI4D/SesZteJGL67v61HTOOf37w0N4wvVx9i5oi2tKoemKVjEpOSWbgtgulrDvHXvjOU8vdl0j3X0KJKqTyO1kG7FsB3QyCgMtz9A5SsnP6+B1fCohchPBQQe1JSgdhz4F/aWpyu4zPg4+em4FV+kFdJpxTQBHgDaGOMcclCbiLyNhBpjBkjIqOBUsaYZ1LtEwiEAiGAAdYDLY0xZ0VkLfAfrLV/fgU+NsbMF5FuwBJjTKKIvAWQutzUspV0osKt2aTr3wy3TczOR8YYw6MzNzF30zE+H9SCHo1yPpi0IDsfl8hNHy0nKdkw/9H2lMigA0ZsQhLfhR5h/J/7OXr2EkElizCgVWXuvKZKwZhq6NAq+PZO8C0KN75l/d6mrJlHbIPFr8CehVC8EnR6DpoOsHpjJidbtaz1U2DHT1CtPdzxpdXxIbeMscYondhqxeDtB2VqQ7kGEKi9OPMLlyQdEXkQq0nt8qMskAwcALYaY25zUbC7gOuNMcdFpCKwzBhTN9U+A+x9RtqvxwPL7MdSY0y9tPZLcfwtQD9jzMCMYslW0vl+hDWj9KjQbK+bM3bJHt79bTdPda+rg0Bzaf2hs9wxfhW9m1bigzubpbnPH7tPMXrOFo5HxdK8Skke6FiTG+qXx9vLxXOqeboTYVbHgtO7raXUG/eDC6et1zt/sWo17R6H1iPBN52BsZtnWveXSlSy5o8rUzvn8UTuh58fg/3L0n6/1Qjo9ro26eUDLlnEDXgR2ApsAr6yn28zxlzKdYRXKm+MsbvlcAJIq2E9CEg5IvCovS3Ifp56e2pDsZrw/kVERgAjAKpUqZK1iPctgS0zocNT2U4487ce593fdnNL8yAedOcAxKtUy6qlGNWpFh/9vodmlUsyqE3Vv5NJ1MUE3lq4k2/WHKZWuWJ8M7w1bWuUdv0EnvlFhUbwwCrYMgOWjYGFz4GXDxSvCNc+bPWay6z20vROqwYy4y5rlux750PpbP4eJyfDqrGw9A3r/De8BNU7QLn6kJwIp/da/7/Wjoej6+D2qdZ9LJUv5bh5LVcnFVkMVEjjreeBacaYkin2PWuMuaKBXUSeBAobY163X/8XuIRV0xljjOlib28PPGOM6ZXi2OexmuVuNZl8+CzVdOIvwri21n+W+1dmfiM3hbDwKPp9/hcNKpbgm+FtKOzrkhbKAi8xKZmBE9ew5kAk1csUpf81ldl89ByLd5wkISmZEe1r8FjXOnq9U0pKsHq1+Ze+sudbVp3cCVNvAp/CVuLJ6h9fSYlWTWnzN1C3J9z0DgSkM2/wjp/gx4esXnej1oKfs6vIqvS5qqbjMpeTQlpEJEJEKqZoXktrgZFw4PoUr4OxEk64/Tzl9r8Hb4jIPUAv4IbMEk6W/fm2NSX9kJ+zlXAiomO5b1oopYsWYvzdIfoF6EI+3l58M7wNC8JO8Pkf+3hz/k5KF/XjrlZVuCOkMg0q6Qqd/+LtC8VysUpJuXoweK5V25l2s9UzrmwmXf4TYq3mvV2/QqfnrZaCjGqd9W+GomVhcnerw84NL+Y8XuUYR2o6GbF7mZ1J0ZEg0BjzdKp9ArE6D7SwN23A6kgQmUZHgk+MMb+KSA/gfaCjMSZLC5ZkWtM5EQbjO0CzAdYqkFl0KT6JOyesYu/J88x54FrqV9QvwbxijOHgmYsElyqCr3cuV/tUmQtfD9Nvtwas3vQONBuYdiKJOQGzhlirpt70LrQanvVzXL5/+tCaHA/AVnkrV8tVO2AM0FVE9mBNqzMGQERCRGQigL1E9mvAOvvxaoplsx8EJgJ7sbpGz7e3j8Xq3r1IRDaJyOe5ijI5CX56BIqUgq6vZf2wZMOTszezNTyKj/o314STx0SE6mWKasJxl6CWVjNzUEtrPNCsu+Hkjiv3ObjS+mPtxBboNyV7CQeg66tWr7YFz7kubuU2HlfT8SQZ1nTWTID5T8GtE6HJ7VkqLynZ8NTszXy/IZznbqrHiA7acUBdpZKTYMUHsPx9SLhg3a8pUgpO7YRjG63OB3d8BeVzOM3Qyo+s8UOD5kAtnfLR0+S3mo7niwqH31+BmjdY3UyzIDEpmcdnbeL7DeE83rWOJhx1dfPyhg5PwmNh0OFpOLQS9i4CP3+4dpQ1g3ZOEw5A6wegRDD8NdZ1MSu3cKQjQb5mDPzyhPWXXK/3szTVTVxiEo/O2MT8sBM83aMuD16vY3FUAeEfCJ2ftwaXurJruo+ftUDisjcg8oAOHM1HtKaTXesmwu75Vs+ZLIwViIlN4N4p65gfdoIXetbXhKMKprwYC9XibhAva8FElW9o0smO45utAXS1u0ObBzLdPfJCPAO+WM3aA5G8f0dT7muvPW2UcpkSlaBOD9j4NSTGOx2NyiJNOlkVFwPf3WsNnus7LtO/3OITk7n/6/XsjjjPF4NDuLVFcIb7K6VyoOU9cOGU1fqg8gVNOllhjNX98+wBazLPoqUz2d3w4tww1h6I5J1+TehUr5ybAlWqgKnVxepQEDrF6UhUFmnSyYo/34Htc6HLK1CtXaa7T1l5kBnrjjCqUy36NEtnSg+lVO55eVsdCvYvtToUKI+nSSczO36Cpf+DJv2tSRAzsfNENG/8uoNuDcrryp9KuUOzuwCBzTOcjkRlgSadjCTGwfcjrdHVN3+U6X2c5GTDc99vpUQRX966rQleBW2qfKWcULIy1OgIm76xZqxWHk2TTkZ8/KyBbHdOz9JknjPWHWHD4XM8d1N9ShXVlRSVcptmgyDqMBxa4XQkKhOadDIk1qC2Epmv5HkqJo4x83fQpkYgt7XQ+zhKuVX9XlCoBGyc7nQkKhOadFxkzPydxCYk879bGhfcRcGUcopvEWh0q9XhJzba6WhUBjTpuMC2Y1F8v/Eo915XjZplizkdjlIFU7NBkHgJtv/odCQqA5p0cskYwxu/7iCgiC8PdtIpbpRyTHAIlKljjdnR2fM9liadXFq2+xQr957hP51rE1DE1+lwlCq4RKD1SDi2wZrVWnkkTTq5kJRsGPPrTqqW9mdQmyyuCa+UyjvNBlpLWq/40OlIVDo06eTCN2sOsSsihmd61MPPRy+lUo7zLWLVdvYuspaTVx5Hvylz6Mz5ON5ZuItra5bmxkYVnA5HKXVZyDDwLQp/fex0JCoNmnRy6O0Fu7gYn8QrvRtqF2mlPIl/oDX79NbZcO6w09GoVDTp5MCmI+eYGXqEe6+rRu3yxZ0ORymVWtsHrQXelr/ndCQqFU062RSXmMRz32+lXPFCPNJFJ/RUyiMFBEPIvbDhKzizz+loVAqadLLpjV92sP14NK/3bUSxQj5Oh6OUSk/7J8HbD5aNcToSlYLHJR0RCRSRRSKyx/5ZKp39htj77BGRISm2txSRrSKyV0Q+llQ3XETkCRExIlImu7H9uvU401YdYli76nRrqJ0HlPJoxctbPdm2fgcR252ORtk8LukAo4HfjTG1gd/t11cQkUDgJaA10Ap4KUVyGgcMB2rbjx4pjqsMdAOyfXfxwOkLPDN7C00rl+SZHvWye7hSygnXPQKFiltrYimP4IlJpw8wzX4+Deibxj7dgUXGmEhjzFlgEdBDRCoCJYwxq40xBvgy1fEfAE8D2ZojY9eJGO4cvwpvb2HsgOY6Jkep/MI/ENqOgp0/w/EtTkej8MykU94Yc9x+fgIon8Y+QcCRFK+P2tuC7OeptyMifYBwY8zmjE4uIiNEJFREQk+dOsWGw2e5Y/wqAGaOaEvlQP+cfCallFNaj7SWPdCebB7BkTvhIrIYSOumyPMpXxhjjIjkeuY+EfEHnsNqWsuQMWYCMAGgcbMWZtDENZQtXoivh7XWhKNUflSkJFxzH6z4AE7thrLa69RJjtR0jDFdjDGN0njMBSLsZjLsnyfTKCIcqJzidbC9Ldx+nnp7TaA6sFlEDtrbN4hIhr0BCvl4MaJDDb4bqTUcpfK1tg+BT2FY8b7TkRR4nti8Ng+43BttCDA3jX0WAt1EpJTdgaAbsNBulosWkTZ2r7XBwFxjzFZjTDljTDVjTDWsZrcWxpgTmQXzaJc6lCuR+VLVSikPVrSMNW5nyyw4e9DpaAo0T0w6Y4CuIrIH6GK/RkRCRGQigDEmEngNWGc/XrW3ATwITAT2AvuA+e4NXynlka59GLy84a+xTkdSoInRxY7SFRISYkJDQ50OQynlKnPugz2/wRO7wVdbMPKKiKw3xoSk9Z4n1nSUUipvNBsIsVGw61enIymwNOkopQqO6h2gRDBsmu50JAWWJh2lVMHh5Q1N+8O+JRB9zOloCiRNOkqpgqXZXWCSYfMMpyMpkDTpKKUKltI1oUpb2PQNaEcqt9Oko5QqeJrdBWf2QPh6pyMpcDTpKKUKnvo3g5cP7JjndCQFjiYdpVTBU6QUVGsHO37WJjY306SjlCqY6vWCyH1wapfTkRQomnSUUgVTvZ7Wz50/OxtHAaNJRylVMJWoBEEtNem4WlJChm9r0lFKFVz1esKxjRB1NPN9VeYi98PkHhnuoklHKVVw1bvZ+rlT52LLkX1LYM0E2D4X1n4Bn7e3uqJnwJGVQ5VSyiOUrQNl6lhNbK1HOB1N/rJmAsx/6sptVdvBrePh2cppH4MmHaVUQVevJ6z8GC5Ggn+g09HkDys/gkUvWj0Ab3oXLp6G+AsQfI01v10GtHlNKVWw1bsZTBLsXuh0JPnDpm+shNPoNrh9KpSoCBUaQ5U2mSYc0KSjlCroKjWH4hW1F1tWJCfD8vesa3brF+Dtm+0iNOkopQo2Ly+riW3v7xB/0eloPNvexXBmL7QdlaVaTVo06SilVL2ekHgJ9i91OhLPtvozq1bYoE+Oi9Cko5RS1dpD4QBrLjaVtpM7rKTcaniOmtUu06SjlFLevlCnB+yeD0mJTkfjmVaPA5/C0PLeXBWjSUcppcBqYrt0Fg7/5XQknufSWdgy01rqO5fdyj0u6YhIoIgsEpE99s9S6ew3xN5nj4gMSbG9pYhsFZG9IvKxiEiK9x4WkZ0isk1E3nbH51FK5RO1uoCvP2z4yulIPM/OXyExFpoPznVRHpd0gNHA78aY2sDv9usriEgg8BLQGmgFvJQiOY0DhgO17UcP+5hOQB+gqTGmIfBuHn8OpVR+4lcUQoZC2Gw4s8/paDzL9rkQUAWCWuS6KE9MOn2AafbzaUDfNPbpDiwyxkQaY84Ci4AeIlIRKGGMWW2MMcCXKY5/ABhjjIkDMMaczLuPoJTKl679D3j7wfL3nY7Ec8RGWXOsNegN/zQc5ZgnJp3yxpjj9vMTQPk09gkCjqR4fdTeFmQ/T70doA7QXkTWiMgfInJNWicXkREiEioioadOncrN51BK5TfFy1s3yjd/C2cPOh2NZ9i1AJIToEFflxTnSNIRkcUiEpbG44rO33ZtxVVryfoAgUAb4ClgVsr7PSnOOcEYE2KMCSlbtqyLTq2Uyjeu+4818FFrO5btc6FEkLX2kAs4MuGnMaZLeu+JSISIVDTGHLeby9JqBgsHrk/xOhhYZm8PTrU93H5+FPjeTmRrRSQZKANodUYp9Y8SlaDFYFg/FfyKwbUPW/OLFUSx0dYsBCFDrZkbXMATZ5meBwwBxtg/56axz0LgjRSdB7oBzxpjIkUkWkTaAGuAwcAn9j4/Ap2ApSJSB/ADTufZp1BK5V+dX7BmTV7zOaz7wpo9WbysGlCzQdC4n0vub3i8Pb9BUlyuZiBIzRPv6YwBuorIHqCL/RoRCRGRiQDGmEjgNWCd/XjV3gbwIDAR2AvsA+bb2ycDNUQkDJgBDLFrPUopdaUipeCWz+Hh9VatB8AkWyuMfn8fTO0JJ8KcjdEdts6GYhWgcmuXFSn6vZu+kJAQExoa6nQYSilPkZwEG7+Cxa9AwkUYPA+quO4L2aOc3AGftYEOT1k1v2wQkfXGmJC03vPEmo5SSnkmL29oeQ88tNa69zNjwNU7pmf5++BbFNo86NJiNekopVR2FSsLA2eDMTD9dmvV0avJmX3WINlrhrp8NVVNOkoplROla8KAb637PDPugoRYpyNynZUfgpcvtH3Y5UVr0lFKqZyq0gZuGQeHV8HcB62VNfO7M/tg07dWB4riaY3Nzx1P7DKtlFL5R6Pb4NxhWPwylKoGN7zodEQ5d+gvmDUYfIvAdY/kySk06SilVG5d96g1bc7y98DLB65/1nPH8SQnWUky2V43KOEixETA8c3wxxgoWRXu+RZKVs6T02vSUUqp3BKBm96zFoD74y3rS/3mj8HHz+nILBHbrfVwDv0FEWFWoklL7e5w6wQoUjLPQtGko5RSruDtA33GQqmqsPR/cPaQdb+nVDXnYjq4EhaMhhNbrBpY8DXQYgiUb2g1oYE1q3bxCtYjoHKe19A06SillKuIQMenoVR1+Pkx+KwtdHkZrhnusrnLsmzv71avuuIVocdb1tQ9Rcu4N4Y0aO81pZRytSa3w0Oroeq1MP9pa9ocdw4i3b0Qvu0PpWvDfYuhzf0ekXBAk45SSuWNgGBrAGmfz+DkNhh3Laz40FoULS9FbIOZg6BcAxgyz2OSzWU691oGdO41pZRLRB+HXx6HXb+CT2GoeyPU6WElhjJ1wLewa86TnAyTu0HkfnhoHRQt7Zpysymjudf0no5SSuW1EhWh/zcQvt7qRRY2B7b9YL0n3lDrBmg+COrcmLseb6GT4Og6uGW8YwknM1rTyYDWdJRSeSIpEc7shVM7IHyDtYRAzDFrGYEb37LWr8luL7Lo4/BpK6jUHAbPdXSckM4yrZRSnsTbB8rVg4a3QLfX4LEw6/5P8fLw3RDrnkxUeOblXGaM1XyXFA+9PvDcgalo0lFKKed5eUPtrnDfEujyirVE9CctYcnrEBeT+fGrPrXuF93wojURqQfTpKOUUp7C2wfaPQoPrYF6N8Gf78DHzeH3V9Pvcn1oFSx6Eerf7PK1b/KC3tPJgN7TUUo56mioNa3O3sXWctlVr7M6HDToY82ddmgV/Pyo1SNu5B9QOMDpiIGM7+lo0smAJh2llEeIPgabv4WNX1vdoX39ITHWSkSFAuCen6FiE6ej/Jt2mVZKqfysRCVo/wS0e9xauyfse2tFz2rtrPnULs+jlg9o0lFKqfxCxJpap+q1TkeSYx7XkUBEAkVkkYjssX+WSme/IfY+e0RkSIrtLUVkq4jsFZGPRay+gyLSTERWi8gmEQkVkVbu+kxKKaUsHpd0gNHA78aY2sDv9usriEgg8BLQGmgFvJQiOY0DhgO17UcPe/vbwCvGmGbAi/ZrpZRSbuSJSacPMM1+Pg3om8Y+3YFFxphIY8xZYBHQQ0QqAiWMMauN1UPiyxTHG6CE/TwAOJY34SullEqPJ97TKW+MOW4/PwGUT2OfIOBIitdH7W1B9vPU2wEeBRaKyLtYyTbNRlERGQGMAKhSpUrOPoFSSqk0OVLTEZHFIhKWxqNPyv3s2oqr+nQ/ADxmjKkMPAZMSmsnY8wEY0yIMSakbNmyLjq1UkopcKimY4zpkt57IhIhIhWNMcft5rKTaewWDlyf4nUwsMzeHpxq++UJjIYAj9jPvwMm5ih4pZRSOeaJ93TmYSUI7J9z09hnIdBNRErZHQi6AQvtZrloEWlj91obnOL4Y0BH+3lnYE9efQCllFJp88R7OmOAWSIyDDgE3AEgIiHA/caY+4wxkSLyGrDOPuZVY0yk/fxBYCpQBJhvP8Dq0faRiPgAsdj3bZRSSrmPToOTARGJAXY5HUc6ygCnnQ4iHZ4am6fGBRpbTnlqbJ4aF7gntqrGmDRvintiTceT7Epv/iCniUioxpY9nhoXaGw55amxeWpc4HxsnnhPRyml1FVKk45SSim30aSTsQlOB5ABjS37PDUu0NhyylNj89S4wOHYtCOBUkopt9GajlJKKbfRpKOUUsptNOmkQ0R6iMgue12efy2v4EA8B+11gjaJSKi9LUtrD7k4jskiclJEwlJsSzMOsXxsX8MtItLCgdheFpFw+7ptEpGbUrz3rB3bLhHpnsexVRaRpSKyXUS2icgj9nZHr10GcTl+3USksIisFZHNdmyv2Nuri8gaO4aZIuJnby9kv95rv1/NgdimisiBFNetmb3d3f8XvEVko4j8bL92/Jr9zRijj1QPwBvYB9QA/IDNQAOHYzoIlEm17W1gtP18NPCWG+LoALQAwjKLA7gJa0YIAdoAaxyI7WXgyTT2bWD/uxYCqtv/3t55GFtFoIX9vDiw247B0WuXQVyOXzf7sxezn/sCa+xrMQvob2//HHjAfv4g8Ln9vD8wMw//PdOLbSrQL4393f1/4XHgG+Bn+7Xj1+zyQ2s6aWsF7DXG7DfGxAMzsNb58TRZWXvIpYwxfwKRqTanF0cf4EtjWQ2UFGsSV3fGlp4+wAxjTJwx5gCwF+vfPa9iO26M2WA/jwF2YC274ei1yyCu9Ljtutmf/bz90td+GKy5E2fb21Nfs8vXcjZwg4i1crAbY0uP2/4viEgw0BN7UmP7Gjh+zS7TpJO29NbrcZIBfhOR9WKt+QNZW3vIHdKLw1Ou4yi7SWNyiiZIx2KzmzCaY/117DHXLlVc4AHXzW4m2oQ12/wirJrVOWNMYhrn/zs2+/0ooLS7YjPGXL5u/7Ov2wciUih1bGnE7WofAk8Dyfbr0njINQNNOvlJO2NMC+BG4CER6ZDyTWPVjx3v/+4pcaQwDqgJNAOOA+85GYyIFAPmAI8aY6JTvufktUsjLo+4bsaYJGMtMR+MVaOq50QcaUkdm4g0Ap7FivEaIBB4xp0xiUgv4KQxZr07z5sdmnTSFg5UTvE65bo8jjDGhNs/TwI/YP0HjLhcRZf01x5yh/TicPw6GmMi7C+HZOAL/mkKcntsIuKL9cU+3Rjzvb3Z8WuXVlyedN3seM4BS4G2WE1Tl+eNTHn+v2Oz3w8Azrgxth52c6UxxsQBU3D/dbsO6C0iB7FuC3QGPsKDrpkmnbStA2rbPT78sG6wzXMqGBEpKiLFLz/HWj8ojKytPeQO6cUxDxhs99xpA0SlaEpyi1Tt5rdgXbfLsfW3e+9UB2oDa/MwDsFarXaHMeb9FG85eu3Si8sTrpuIlBWRkvbzIkBXrHtOS4F+9m6pr9nla9kPWGLXHt0V284Uf0AI1n2TlNctz/89jTHPGmOCjTHVsL63lhhjBuIB1yxlkPpIu/fHTVg9efYBzzscSw2sHkObgW2X48Fqe/0da0G6xUCgG2L5Fqu5JQGrbXhYenFg9dT51L6GW4EQB2L7yj73Fqz/YBVT7P+8Hdsu4MY8jq0dVtPZFmCT/bjJ6WuXQVyOXzegCbDRjiEMeDHF/4e1WJ0YvgMK2dsL26/32u/XcCC2JfZ1CwO+5p8ebm79v2Cf83r+6b3m+DW7/NBpcJRSSrmNNq8ppZRyG006Siml3EaTjlJKKbfRpKOUUsptNOkopZRyG006Siml3EaTjlJKKbfRpKOUG4nIMhEx9qON0/GkJiJjRGRxBu9PTRF/v/T2Uyo9mnSUcr8pWOvYrIcrvsgnpd5RRN6y3/s5LwIRkc9F5MMUm5phzUqQnkewYlcqRzTpKOV+F40xJ4wxCSm2HQHusOfWA/6egHEwcDgvgrDnB+sN/JhiczOs6ZbSZIyJMsacyIt4VMGgSUepHLKX+T0jIo+m2FZfRC6KSP9sFrcFa/61O1Js6wnEAstSnXeZXUP5SETO2o93RMQrxT4iIk+ItQx2nIgcFZE3U53zGqwVQFfYx1TAWs8nXkR+FZELIrJPRDpl87MolS5NOkrl3KNYSwK/BNZ681iTjs42xszIQXmTgKEpXg/FaopLa4LEgVj/f9sCI4ERdjyXvQH8F3gTaAjczpWLiIE1C/Iv5p/FvZrZPx8CPgCaYk1c+T5KuYgmHaVyyFhT07+HtVZJVWAMUALrSzsnvgFCRKS2XevoAUxNZ9/jwH+MMTuNMbOAd4DH4e8F2R4DRhtjJhtj9hpjVhljPktVRh/+3bQWBdxhjFlkjNmLtYRx2Rx+HqX+xSfzXZRS6THGHBSRc1jLA48AOhhjYnJY1lkR+QGrhnMOWGaMOSxpL1m/2lw5Rfwq4DURKYG1cmUhrCUT0iQitbCmu1+YYnMz4KdU92xqYU17r5RLaE1HqdzbDDwIvG6MWZXLsiZjdR4Yaj/PK32B340xF1Jsa4aVvFJqTsa92ZTKFk06SuWeYC2u97oLyvodiAfKcGXTV2qt5coqUBvgmDEmGmt1zTjghgyOv6JpTUT8sVYB3ZhqP006yqW0eU2pXBCRh4AOwC5jTFJuyzPGGBFpAogxJi6DXSsBH4rIZ0Bj4CnspGeMiRGRj4A3RSQO+BNrhdKWxphxIlIWK0mlHNzZxP65JcVnKw0Eo0lHuZAmHaVySEQaYN3A/xR4QET8jTEXc1tuFu8JTQe8gTVYvdsmYfU4u+xZ4CxWD7ZgIAL40n7vZmCdMSYixf7NgD2pmtuaYy39vT37n0KptOly1UrlgN09eg3WF/J9QAxwnTFmdSbHLQPCjDGjcnHuXJUhInOBlcaYt3MRgwFuN8bMzmkZqmDSezpK5cwYIAB4wK7d7AEeEZEqWTh2hIicF5Fr8jTC9K3EGk+Ubfag1PMujkcVIFrTUSqbRKQb8AtwvTFmpb3tbuBdYLsxJt0R/CISBBSxXx7J5L5NemUsI5e1pZwSkXJYY5EAjqdqjlMqU5p0lFJKuY02rymllHIbTTpKKaXcRpOOUkopt9Gko5RSym006SillHIbTTpKKaXcRpOOUkopt/k/qyke6TjGHOsAAAAASUVORK5CYII=\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -627,15 +734,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "89d171c3", - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -647,7 +752,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -659,7 +764,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -671,7 +776,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -683,7 +788,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -712,13 +817,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "bd879861", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -730,7 +835,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -759,7 +864,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "e5174ac1", "metadata": {}, "outputs": [ @@ -773,7 +878,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -785,7 +890,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -847,13 +952,21 @@ "plt.xlabel(r'$x\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", "plt.ylabel(r'$y\\,\\,[{\\rm Mpc}/h]$', fontsize=15);" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6709bf8e-92dd-4af9-9964-e79413199de7", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Bacon (BNL Astro Conda) latest", "language": "python", - "name": "python3" + "name": "bacon" }, "language_info": { "codemirror_mode": { @@ -865,7 +978,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/examples/simple/out_node0.dbg b/examples/simple/out_node0.dbg new file mode 100644 index 0000000..e69de29 diff --git a/examples/simple/out_params.cfg b/examples/simple/out_params.cfg new file mode 100644 index 0000000..0e0d42f --- /dev/null +++ b/examples/simple/out_params.cfg @@ -0,0 +1,64 @@ +global = { + prefix_out = "examples/simple/out" + output_format = "FITS" + output_density = true + pk_filename = "examples/simple/Pk_CAMB_test.dat" + z_min = 0.001 + z_max = 0.45 + seed = 1003 + write_pred = false + pred_dz = 0.1 + just_write_pred = true +} +field_par = { + r_smooth = 5.0 + smooth_potential = true + n_grid = 256 + dens_type = 1 + lpt_buffer_fraction = 0.6 + lpt_interp_type = 1 + output_lpt = 0 +} +cosmo_par = { + omega_M = 0.3 + omega_L = 0.7 + omega_B = 0.05 + h = 0.7 + w = -1.0 + ns = 0.96 + sigma_8 = 0.803869 +} +srcs1 = { + nz_filename = "examples/simple/Nz_test.txt" + bias_filename = "examples/simple/Bz_test.txt" + include_lensing = true + store_skewers = true + gaussian_skewers = false +} +srcs2 = { + nz_filename = "examples/simple/Nz2_test.txt" + bias_filename = "examples/simple/Bz2_test.txt" + include_lensing = false + store_skewers = true +} +imap1 = { + tbak_filename = "examples/simple/Tz_test.txt" + bias_filename = "examples/simple/Bz_test.txt" + freq_list = "examples/simple/nuTable.txt" + freq_rest = 1420.405 + nside = 64 +} +kappa = { + z_out = [ 0.4 ] + nside = 64 +} +isw = { + z_out = [ 0.4 ] + nside = 64 +} +lensing = { + nside = 256 + n_lensing = 11 + spacing_type = "r" + write = false +} diff --git a/output/.ipynb_checkpoints/params-checkpoint.cfg b/output/.ipynb_checkpoints/params-checkpoint.cfg new file mode 100644 index 0000000..2810578 --- /dev/null +++ b/output/.ipynb_checkpoints/params-checkpoint.cfg @@ -0,0 +1,69 @@ +global = +{ + prefix_out = "output/colore"; + output_format = "FITS"; + output_density = True; + pk_filename = "output/pk.txt"; + z_min = 0.0001; + z_max = 0.15; + seed = 1000; + write_pred = False; + just_write_pred = False; +}; +field_par = +{ + r_smooth = 1.0; + smooth_potential = True; + n_grid = 256; + dens_type = 1; + lpt_buffer_fraction = 0.6; + lpt_interp_type = 1; + output_lpt = 0; +}; +cosmo_par = +{ + omega_M = 0.3; + omega_B = 0.3; + omega_L = 0.7; + h = 0.7; + w = -1.0; + ns = 0.96; + sigma_8 = 0.8; +}; +custom1 = +{ + kz_filename = "output/wz.txt"; + bias_filename = "output/bias.txt"; + nside = 64; +}; +srcs1 = +{ + nz_filename = "output/dndz.txt"; + bias_filename = "output/bias.txt"; + include_lensing = True; + store_skewers = True; +}; +imap1 = +{ + tbak_filename = "output/tz.txt"; + bias_filename = "output/bias.txt"; + freq_list = "output/nuTable.txt"; + freq_rest = 1420.0; + nside = 64; +}; +kappa = +{ + z_out = + [ + 0.1 + ]; + nside = 64; +}; +isw = +{ + z_out = + [ + 0.1 + ]; + nside = 64; +}; diff --git a/output/bias.txt b/output/bias.txt new file mode 100644 index 0000000..918a31f --- /dev/null +++ b/output/bias.txt @@ -0,0 +1,1024 @@ +0.000000000000000000e+00 1.000000000000000000e+00 +1.955034213098729226e-04 1.000195503421309917e+00 +3.910068426197458452e-04 1.000391006842619834e+00 +5.865102639296187678e-04 1.000586510263929529e+00 +7.820136852394916904e-04 1.000782013685239447e+00 +9.775171065493646130e-04 1.000977517106549364e+00 +1.173020527859237536e-03 1.001173020527859281e+00 +1.368523949169110458e-03 1.001368523949169198e+00 +1.564027370478983381e-03 1.001564027370478893e+00 +1.759530791788856303e-03 1.001759530791788810e+00 +1.955034213098729226e-03 1.001955034213098727e+00 +2.150537634408602149e-03 1.002150537634408645e+00 +2.346041055718475071e-03 1.002346041055718562e+00 +2.541544477028347994e-03 1.002541544477028257e+00 +2.737047898338220916e-03 1.002737047898338174e+00 +2.932551319648093839e-03 1.002932551319648091e+00 +3.128054740957966762e-03 1.003128054740958008e+00 +3.323558162267839684e-03 1.003323558162267926e+00 +3.519061583577712607e-03 1.003519061583577621e+00 +3.714565004887585530e-03 1.003714565004887538e+00 +3.910068426197458452e-03 1.003910068426197455e+00 +4.105571847507331375e-03 1.004105571847507372e+00 +4.301075268817204297e-03 1.004301075268817289e+00 +4.496578690127077220e-03 1.004496578690126984e+00 +4.692082111436950143e-03 1.004692082111436902e+00 +4.887585532746823065e-03 1.004887585532746819e+00 +5.083088954056695988e-03 1.005083088954056736e+00 +5.278592375366568910e-03 1.005278592375366653e+00 +5.474095796676441833e-03 1.005474095796676348e+00 +5.669599217986314756e-03 1.005669599217986265e+00 +5.865102639296187678e-03 1.005865102639296182e+00 +6.060606060606060601e-03 1.006060606060606100e+00 +6.256109481915933523e-03 1.006256109481916017e+00 +6.451612903225806446e-03 1.006451612903225712e+00 +6.647116324535679369e-03 1.006647116324535629e+00 +6.842619745845552291e-03 1.006842619745845546e+00 +7.038123167155425214e-03 1.007038123167155463e+00 +7.233626588465298136e-03 1.007233626588465381e+00 +7.429130009775171059e-03 1.007429130009775076e+00 +7.624633431085043982e-03 1.007624633431084993e+00 +7.820136852394916904e-03 1.007820136852394910e+00 +8.015640273704788960e-03 1.008015640273704827e+00 +8.211143695014662749e-03 1.008211143695014744e+00 +8.406647116324536539e-03 1.008406647116324439e+00 +8.602150537634408595e-03 1.008602150537634357e+00 +8.797653958944280650e-03 1.008797653958944274e+00 +8.993157380254154440e-03 1.008993157380254191e+00 +9.188660801564028230e-03 1.009188660801564108e+00 +9.384164222873900285e-03 1.009384164222873803e+00 +9.579667644183772340e-03 1.009579667644183720e+00 +9.775171065493646130e-03 1.009775171065493637e+00 +9.970674486803519920e-03 1.009970674486803555e+00 +1.016617790811339198e-02 1.010166177908113472e+00 +1.036168132942326403e-02 1.010361681329423167e+00 +1.055718475073313782e-02 1.010557184750733084e+00 +1.075268817204301161e-02 1.010752688172043001e+00 +1.094819159335288367e-02 1.010948191593352918e+00 +1.114369501466275572e-02 1.011143695014662836e+00 +1.133919843597262951e-02 1.011339198435972531e+00 +1.153470185728250330e-02 1.011534701857282448e+00 +1.173020527859237536e-02 1.011730205278592365e+00 +1.192570869990224741e-02 1.011925708699902282e+00 +1.212121212121212120e-02 1.012121212121212199e+00 +1.231671554252199499e-02 1.012316715542521894e+00 +1.251221896383186705e-02 1.012512218963831812e+00 +1.270772238514173910e-02 1.012707722385141729e+00 +1.290322580645161289e-02 1.012903225806451646e+00 +1.309872922776148668e-02 1.013098729227761563e+00 +1.329423264907135874e-02 1.013294232649071258e+00 +1.348973607038123079e-02 1.013489736070381175e+00 +1.368523949169110458e-02 1.013685239491691092e+00 +1.388074291300097837e-02 1.013880742913001010e+00 +1.407624633431085043e-02 1.014076246334310927e+00 +1.427174975562072248e-02 1.014271749755620622e+00 +1.446725317693059627e-02 1.014467253176930539e+00 +1.466275659824047006e-02 1.014662756598240456e+00 +1.485826001955034212e-02 1.014858260019550373e+00 +1.505376344086021417e-02 1.015053763440860291e+00 +1.524926686217008796e-02 1.015249266862169986e+00 +1.544477028347996175e-02 1.015444770283479903e+00 +1.564027370478983381e-02 1.015640273704789820e+00 +1.583577712609970586e-02 1.015835777126099737e+00 +1.603128054740957792e-02 1.016031280547409654e+00 +1.622678396871945344e-02 1.016226783968719349e+00 +1.642228739002932550e-02 1.016422287390029267e+00 +1.661779081133919755e-02 1.016617790811339184e+00 +1.681329423264907308e-02 1.016813294232649101e+00 +1.700879765395894513e-02 1.017008797653959018e+00 +1.720430107526881719e-02 1.017204301075268713e+00 +1.739980449657868924e-02 1.017399804496578630e+00 +1.759530791788856130e-02 1.017595307917888547e+00 +1.779081133919843682e-02 1.017790811339198465e+00 +1.798631476050830888e-02 1.017986314760508382e+00 +1.818181818181818094e-02 1.018181818181818077e+00 +1.837732160312805646e-02 1.018377321603127994e+00 +1.857282502443792851e-02 1.018572825024437911e+00 +1.876832844574780057e-02 1.018768328445747828e+00 +1.896383186705767263e-02 1.018963831867057745e+00 +1.915933528836754468e-02 1.019159335288367441e+00 +1.935483870967742021e-02 1.019354838709677358e+00 +1.955034213098729226e-02 1.019550342130987275e+00 +1.974584555229716432e-02 1.019745845552297192e+00 +1.994134897360703984e-02 1.019941348973607109e+00 +2.013685239491691190e-02 1.020136852394916804e+00 +2.033235581622678395e-02 1.020332355816226722e+00 +2.052785923753665601e-02 1.020527859237536639e+00 +2.072336265884652806e-02 1.020723362658846556e+00 +2.091886608015640359e-02 1.020918866080156473e+00 +2.111436950146627564e-02 1.021114369501466168e+00 +2.130987292277614770e-02 1.021309872922776085e+00 +2.150537634408602322e-02 1.021505376344086002e+00 +2.170087976539589528e-02 1.021700879765395920e+00 +2.189638318670576733e-02 1.021896383186705837e+00 +2.209188660801563939e-02 1.022091886608015532e+00 +2.228739002932551144e-02 1.022287390029325449e+00 +2.248289345063538697e-02 1.022482893450635366e+00 +2.267839687194525902e-02 1.022678396871945283e+00 +2.287390029325513108e-02 1.022873900293255200e+00 +2.306940371456500660e-02 1.023069403714564896e+00 +2.326490713587487866e-02 1.023264907135874813e+00 +2.346041055718475071e-02 1.023460410557184730e+00 +2.365591397849462277e-02 1.023655913978494647e+00 +2.385141739980449482e-02 1.023851417399804564e+00 +2.404692082111437035e-02 1.024046920821114259e+00 +2.424242424242424240e-02 1.024242424242424176e+00 +2.443792766373411446e-02 1.024437927663734094e+00 +2.463343108504398998e-02 1.024633431085044011e+00 +2.482893450635386204e-02 1.024828934506353928e+00 +2.502443792766373409e-02 1.025024437927663623e+00 +2.521994134897360615e-02 1.025219941348973540e+00 +2.541544477028347820e-02 1.025415444770283457e+00 +2.561094819159335373e-02 1.025610948191593375e+00 +2.580645161290322578e-02 1.025806451612903292e+00 +2.600195503421309784e-02 1.026001955034212987e+00 +2.619745845552297336e-02 1.026197458455522904e+00 +2.639296187683284542e-02 1.026392961876832821e+00 +2.658846529814271747e-02 1.026588465298142738e+00 +2.678396871945258953e-02 1.026783968719452655e+00 +2.697947214076246158e-02 1.026979472140762351e+00 +2.717497556207233711e-02 1.027174975562072268e+00 +2.737047898338220916e-02 1.027370478983382185e+00 +2.756598240469208122e-02 1.027565982404692102e+00 +2.776148582600195674e-02 1.027761485826002019e+00 +2.795698924731182880e-02 1.027956989247311936e+00 +2.815249266862170086e-02 1.028152492668621631e+00 +2.834799608993157291e-02 1.028347996089931549e+00 +2.854349951124144497e-02 1.028543499511241466e+00 +2.873900293255132049e-02 1.028739002932551383e+00 +2.893450635386119255e-02 1.028934506353861300e+00 +2.913000977517106460e-02 1.029130009775170995e+00 +2.932551319648094013e-02 1.029325513196480912e+00 +2.952101661779081218e-02 1.029521016617790830e+00 +2.971652003910068424e-02 1.029716520039100747e+00 +2.991202346041055629e-02 1.029912023460410664e+00 +3.010752688172042835e-02 1.030107526881720359e+00 +3.030303030303030387e-02 1.030303030303030276e+00 +3.049853372434017593e-02 1.030498533724340193e+00 +3.069403714565004798e-02 1.030694037145650110e+00 +3.088954056695992351e-02 1.030889540566960028e+00 +3.108504398826979556e-02 1.031085043988269723e+00 +3.128054740957966762e-02 1.031280547409579640e+00 +3.147605083088954314e-02 1.031476050830889557e+00 +3.167155425219941173e-02 1.031671554252199474e+00 +3.186705767350928725e-02 1.031867057673509391e+00 +3.206256109481915584e-02 1.032062561094819086e+00 +3.225806451612903136e-02 1.032258064516129004e+00 +3.245356793743890689e-02 1.032453567937438921e+00 +3.264907135874877547e-02 1.032649071358748838e+00 +3.284457478005865100e-02 1.032844574780058755e+00 +3.304007820136852652e-02 1.033040078201368450e+00 +3.323558162267839511e-02 1.033235581622678367e+00 +3.343108504398827063e-02 1.033431085043988285e+00 +3.362658846529814616e-02 1.033626588465298202e+00 +3.382209188660801474e-02 1.033822091886608119e+00 +3.401759530791789027e-02 1.034017595307917814e+00 +3.421309872922775885e-02 1.034213098729227731e+00 +3.440860215053763438e-02 1.034408602150537648e+00 +3.460410557184750990e-02 1.034604105571847565e+00 +3.479960899315737849e-02 1.034799608993157483e+00 +3.499511241446725401e-02 1.034995112414467178e+00 +3.519061583577712260e-02 1.035190615835777095e+00 +3.538611925708699812e-02 1.035386119257087012e+00 +3.558162267839687365e-02 1.035581622678396929e+00 +3.577712609970674223e-02 1.035777126099706846e+00 +3.597262952101661776e-02 1.035972629521016541e+00 +3.616813294232649328e-02 1.036168132942326459e+00 +3.636363636363636187e-02 1.036363636363636376e+00 +3.655913978494623739e-02 1.036559139784946293e+00 +3.675464320625611292e-02 1.036754643206256210e+00 +3.695014662756598151e-02 1.036950146627565905e+00 +3.714565004887585703e-02 1.037145650048875822e+00 +3.734115347018572562e-02 1.037341153470185739e+00 +3.753665689149560114e-02 1.037536656891495657e+00 +3.773216031280547667e-02 1.037732160312805574e+00 +3.792766373411534525e-02 1.037927663734115269e+00 +3.812316715542522078e-02 1.038123167155425186e+00 +3.831867057673508936e-02 1.038318670576735103e+00 +3.851417399804496489e-02 1.038514173998045020e+00 +3.870967741935484041e-02 1.038709677419354938e+00 +3.890518084066470900e-02 1.038905180840664633e+00 +3.910068426197458452e-02 1.039100684261974550e+00 +3.929618768328446005e-02 1.039296187683284467e+00 +3.949169110459432863e-02 1.039491691104594384e+00 +3.968719452590420416e-02 1.039687194525904301e+00 +3.988269794721407968e-02 1.039882697947213996e+00 +4.007820136852394827e-02 1.040078201368523914e+00 +4.027370478983382379e-02 1.040273704789833831e+00 +4.046920821114369238e-02 1.040469208211143748e+00 +4.066471163245356790e-02 1.040664711632453665e+00 +4.086021505376344343e-02 1.040860215053763360e+00 +4.105571847507331201e-02 1.041055718475073277e+00 +4.125122189638318754e-02 1.041251221896383194e+00 +4.144672531769305612e-02 1.041446725317693112e+00 +4.164222873900293165e-02 1.041642228739003029e+00 +4.183773216031280717e-02 1.041837732160312724e+00 +4.203323558162267576e-02 1.042033235581622641e+00 +4.222873900293255128e-02 1.042228739002932558e+00 +4.242424242424242681e-02 1.042424242424242475e+00 +4.261974584555229539e-02 1.042619745845552393e+00 +4.281524926686217092e-02 1.042815249266862088e+00 +4.301075268817204644e-02 1.043010752688172005e+00 +4.320625610948191503e-02 1.043206256109481922e+00 +4.340175953079179055e-02 1.043401759530791839e+00 +4.359726295210165914e-02 1.043597262952101756e+00 +4.379276637341153466e-02 1.043792766373411451e+00 +4.398826979472141019e-02 1.043988269794721369e+00 +4.418377321603127877e-02 1.044183773216031286e+00 +4.437927663734115430e-02 1.044379276637341203e+00 +4.457478005865102288e-02 1.044574780058651120e+00 +4.477028347996089841e-02 1.044770283479960815e+00 +4.496578690127077393e-02 1.044965786901270732e+00 +4.516129032258064252e-02 1.045161290322580649e+00 +4.535679374389051804e-02 1.045356793743890567e+00 +4.555229716520039357e-02 1.045552297165200484e+00 +4.574780058651026216e-02 1.045747800586510179e+00 +4.594330400782013768e-02 1.045943304007820096e+00 +4.613880742913001320e-02 1.046138807429130013e+00 +4.633431085043988179e-02 1.046334310850439930e+00 +4.652981427174975732e-02 1.046529814271749848e+00 +4.672531769305962590e-02 1.046725317693059543e+00 +4.692082111436950143e-02 1.046920821114369460e+00 +4.711632453567937695e-02 1.047116324535679377e+00 +4.731182795698924554e-02 1.047311827956989294e+00 +4.750733137829912106e-02 1.047507331378299211e+00 +4.770283479960898965e-02 1.047702834799608906e+00 +4.789833822091886517e-02 1.047898338220918824e+00 +4.809384164222874070e-02 1.048093841642228741e+00 +4.828934506353860928e-02 1.048289345063538658e+00 +4.848484848484848481e-02 1.048484848484848575e+00 +4.868035190615836033e-02 1.048680351906158270e+00 +4.887585532746822892e-02 1.048875855327468187e+00 +4.907135874877810444e-02 1.049071358748778104e+00 +4.926686217008797997e-02 1.049266862170088022e+00 +4.946236559139784855e-02 1.049462365591397939e+00 +4.965786901270772408e-02 1.049657869012707634e+00 +4.985337243401759266e-02 1.049853372434017551e+00 +5.004887585532746819e-02 1.050048875855327468e+00 +5.024437927663734371e-02 1.050244379276637385e+00 +5.043988269794721230e-02 1.050439882697947303e+00 +5.063538611925708782e-02 1.050635386119256998e+00 +5.083088954056695641e-02 1.050830889540566915e+00 +5.102639296187683193e-02 1.051026392961876832e+00 +5.122189638318670746e-02 1.051221896383186749e+00 +5.141739980449657604e-02 1.051417399804496666e+00 +5.161290322580645157e-02 1.051612903225806361e+00 +5.180840664711632709e-02 1.051808406647116279e+00 +5.200391006842619568e-02 1.052003910068426196e+00 +5.219941348973607120e-02 1.052199413489736113e+00 +5.239491691104594673e-02 1.052394916911046030e+00 +5.259042033235581531e-02 1.052590420332355725e+00 +5.278592375366569084e-02 1.052785923753665642e+00 +5.298142717497555942e-02 1.052981427174975559e+00 +5.317693059628543495e-02 1.053176930596285477e+00 +5.337243401759531047e-02 1.053372434017595394e+00 +5.356793743890517906e-02 1.053567937438905089e+00 +5.376344086021505458e-02 1.053763440860215006e+00 +5.395894428152492317e-02 1.053958944281524923e+00 +5.415444770283479869e-02 1.054154447702834840e+00 +5.434995112414467422e-02 1.054349951124144757e+00 +5.454545454545454281e-02 1.054545454545454453e+00 +5.474095796676441833e-02 1.054740957966764370e+00 +5.493646138807429385e-02 1.054936461388074287e+00 +5.513196480938416244e-02 1.055131964809384204e+00 +5.532746823069403797e-02 1.055327468230694121e+00 +5.552297165200391349e-02 1.055522971652003816e+00 +5.571847507331378208e-02 1.055718475073313734e+00 +5.591397849462365760e-02 1.055913978494623651e+00 +5.610948191593352619e-02 1.056109481915933568e+00 +5.630498533724340171e-02 1.056304985337243485e+00 +5.650048875855327724e-02 1.056500488758553180e+00 +5.669599217986314582e-02 1.056695992179863097e+00 +5.689149560117302135e-02 1.056891495601173014e+00 +5.708699902248288993e-02 1.057086999022482932e+00 +5.728250244379276546e-02 1.057282502443792849e+00 +5.747800586510264098e-02 1.057478005865102544e+00 +5.767350928641250957e-02 1.057673509286412461e+00 +5.786901270772238509e-02 1.057869012707722378e+00 +5.806451612903226062e-02 1.058064516129032295e+00 +5.826001955034212920e-02 1.058260019550342212e+00 +5.845552297165200473e-02 1.058455522971651908e+00 +5.865102639296188025e-02 1.058651026392961825e+00 +5.884652981427174884e-02 1.058846529814271742e+00 +5.904203323558162436e-02 1.059042033235581659e+00 +5.923753665689149295e-02 1.059237536656891576e+00 +5.943304007820136847e-02 1.059433040078201271e+00 +5.962854349951124400e-02 1.059628543499511188e+00 +5.982404692082111258e-02 1.059824046920821106e+00 +6.001955034213098811e-02 1.060019550342131023e+00 +6.021505376344085669e-02 1.060215053763440940e+00 +6.041055718475073222e-02 1.060410557184750635e+00 +6.060606060606060774e-02 1.060606060606060552e+00 +6.080156402737047633e-02 1.060801564027370469e+00 +6.099706744868035185e-02 1.060997067448680387e+00 +6.119257086999022738e-02 1.061192570869990304e+00 +6.138807429130009596e-02 1.061388074291299999e+00 +6.158357771260997149e-02 1.061583577712609916e+00 +6.177908113391984701e-02 1.061779081133919833e+00 +6.197458455522971560e-02 1.061974584555229750e+00 +6.217008797653959112e-02 1.062170087976539667e+00 +6.236559139784945971e-02 1.062365591397849363e+00 +6.256109481915933523e-02 1.062561094819159280e+00 +6.275659824046921076e-02 1.062756598240469197e+00 +6.295210166177908628e-02 1.062952101661779114e+00 +6.314760508308894793e-02 1.063147605083089031e+00 +6.334310850439882346e-02 1.063343108504398726e+00 +6.353861192570869898e-02 1.063538611925708643e+00 +6.373411534701857450e-02 1.063734115347018561e+00 +6.392961876832845003e-02 1.063929618768328478e+00 +6.412512218963831168e-02 1.064125122189638395e+00 +6.432062561094818720e-02 1.064320625610948090e+00 +6.451612903225806273e-02 1.064516129032258007e+00 +6.471163245356793825e-02 1.064711632453567924e+00 +6.490713587487781377e-02 1.064907135874877842e+00 +6.510263929618768930e-02 1.065102639296187759e+00 +6.529814271749755095e-02 1.065298142717497454e+00 +6.549364613880742647e-02 1.065493646138807371e+00 +6.568914956011730200e-02 1.065689149560117288e+00 +6.588465298142717752e-02 1.065884652981427205e+00 +6.608015640273705305e-02 1.066080156402737122e+00 +6.627565982404691469e-02 1.066275659824046818e+00 +6.647116324535679022e-02 1.066471163245356735e+00 +6.666666666666666574e-02 1.066666666666666652e+00 +6.686217008797654127e-02 1.066862170087976569e+00 +6.705767350928641679e-02 1.067057673509286486e+00 +6.725317693059629232e-02 1.067253176930596403e+00 +6.744868035190615396e-02 1.067448680351906098e+00 +6.764418377321602949e-02 1.067644183773216016e+00 +6.783968719452590501e-02 1.067839687194525933e+00 +6.803519061583578054e-02 1.068035190615835850e+00 +6.823069403714565606e-02 1.068230694037145767e+00 +6.842619745845551771e-02 1.068426197458455462e+00 +6.862170087976539323e-02 1.068621700879765379e+00 +6.881720430107526876e-02 1.068817204301075297e+00 +6.901270772238514428e-02 1.069012707722385214e+00 +6.920821114369501981e-02 1.069208211143695131e+00 +6.940371456500488145e-02 1.069403714565004826e+00 +6.959921798631475698e-02 1.069599217986314743e+00 +6.979472140762463250e-02 1.069794721407624660e+00 +6.999022482893450803e-02 1.069990224828934577e+00 +7.018572825024438355e-02 1.070185728250244495e+00 +7.038123167155424520e-02 1.070381231671554190e+00 +7.057673509286412072e-02 1.070576735092864107e+00 +7.077223851417399625e-02 1.070772238514174024e+00 +7.096774193548387177e-02 1.070967741935483941e+00 +7.116324535679374730e-02 1.071163245356793858e+00 +7.135874877810362282e-02 1.071358748778103553e+00 +7.155425219941348447e-02 1.071554252199413471e+00 +7.174975562072335999e-02 1.071749755620723388e+00 +7.194525904203323552e-02 1.071945259042033305e+00 +7.214076246334311104e-02 1.072140762463343222e+00 +7.233626588465298657e-02 1.072336265884652917e+00 +7.253176930596284822e-02 1.072531769305962834e+00 +7.272727272727272374e-02 1.072727272727272751e+00 +7.292277614858259926e-02 1.072922776148582669e+00 +7.311827956989247479e-02 1.073118279569892586e+00 +7.331378299120235031e-02 1.073313782991202281e+00 +7.350928641251222584e-02 1.073509286412512198e+00 +7.370478983382208749e-02 1.073704789833822115e+00 +7.390029325513196301e-02 1.073900293255132032e+00 +7.409579667644183854e-02 1.074095796676441950e+00 +7.429130009775171406e-02 1.074291300097751645e+00 +7.448680351906158958e-02 1.074486803519061562e+00 +7.468230694037145123e-02 1.074682306940371479e+00 +7.487781036168132676e-02 1.074877810361681396e+00 +7.507331378299120228e-02 1.075073313782991313e+00 +7.526881720430107781e-02 1.075268817204301008e+00 +7.546432062561095333e-02 1.075464320625610926e+00 +7.565982404692081498e-02 1.075659824046920843e+00 +7.585532746823069050e-02 1.075855327468230760e+00 +7.605083088954056603e-02 1.076050830889540677e+00 +7.624633431085044155e-02 1.076246334310850372e+00 +7.644183773216031708e-02 1.076441837732160289e+00 +7.663734115347017872e-02 1.076637341153470206e+00 +7.683284457478005425e-02 1.076832844574780124e+00 +7.702834799608992977e-02 1.077028347996090041e+00 +7.722385141739980530e-02 1.077223851417399736e+00 +7.741935483870968082e-02 1.077419354838709653e+00 +7.761485826001955635e-02 1.077614858260019570e+00 +7.781036168132941799e-02 1.077810361681329487e+00 +7.800586510263929352e-02 1.078005865102639405e+00 +7.820136852394916904e-02 1.078201368523949100e+00 +7.839687194525904457e-02 1.078396871945259017e+00 +7.859237536656892009e-02 1.078592375366568934e+00 +7.878787878787878174e-02 1.078787878787878851e+00 +7.898338220918865726e-02 1.078983382209188768e+00 +7.917888563049853279e-02 1.079178885630498463e+00 +7.937438905180840831e-02 1.079374389051808381e+00 +7.956989247311828384e-02 1.079569892473118298e+00 +7.976539589442815936e-02 1.079765395894428215e+00 +7.996089931573802101e-02 1.079960899315738132e+00 +8.015640273704789653e-02 1.080156402737047827e+00 +8.035190615835777206e-02 1.080351906158357744e+00 +8.054740957966764758e-02 1.080547409579667661e+00 +8.074291300097752311e-02 1.080742913000977579e+00 +8.093841642228738475e-02 1.080938416422287496e+00 +8.113391984359726028e-02 1.081133919843597191e+00 +8.132942326490713580e-02 1.081329423264907108e+00 +8.152492668621701133e-02 1.081524926686217025e+00 +8.172043010752688685e-02 1.081720430107526942e+00 +8.191593352883674850e-02 1.081915933528836860e+00 +8.211143695014662403e-02 1.082111436950146555e+00 +8.230694037145649955e-02 1.082306940371456472e+00 +8.250244379276637507e-02 1.082502443792766389e+00 +8.269794721407625060e-02 1.082697947214076306e+00 +8.289345063538611225e-02 1.082893450635386223e+00 +8.308895405669598777e-02 1.083088954056695918e+00 +8.328445747800586330e-02 1.083284457478005836e+00 +8.347996089931573882e-02 1.083479960899315753e+00 +8.367546432062561435e-02 1.083675464320625670e+00 +8.387096774193548987e-02 1.083870967741935587e+00 +8.406647116324535152e-02 1.084066471163245282e+00 +8.426197458455522704e-02 1.084261974584555199e+00 +8.445747800586510257e-02 1.084457478005865116e+00 +8.465298142717497809e-02 1.084652981427175034e+00 +8.484848484848485362e-02 1.084848484848484951e+00 +8.504398826979471526e-02 1.085043988269794646e+00 +8.523949169110459079e-02 1.085239491691104563e+00 +8.543499511241446631e-02 1.085434995112414480e+00 +8.563049853372434184e-02 1.085630498533724397e+00 +8.582600195503421736e-02 1.085826001955034315e+00 +8.602150537634409289e-02 1.086021505376344010e+00 +8.621700879765395453e-02 1.086217008797653927e+00 +8.641251221896383006e-02 1.086412512218963844e+00 +8.660801564027370558e-02 1.086608015640273761e+00 +8.680351906158358111e-02 1.086803519061583678e+00 +8.699902248289345663e-02 1.086999022482893373e+00 +8.719452590420331828e-02 1.087194525904203291e+00 +8.739002932551319380e-02 1.087390029325513208e+00 +8.758553274682306933e-02 1.087585532746823125e+00 +8.778103616813294485e-02 1.087781036168133042e+00 +8.797653958944282038e-02 1.087976539589442737e+00 +8.817204301075268202e-02 1.088172043010752654e+00 +8.836754643206255755e-02 1.088367546432062571e+00 +8.856304985337243307e-02 1.088563049853372489e+00 +8.875855327468230860e-02 1.088758553274682406e+00 +8.895405669599218412e-02 1.088954056695992101e+00 +8.914956011730204577e-02 1.089149560117302018e+00 +8.934506353861192129e-02 1.089345063538611935e+00 +8.954056695992179682e-02 1.089540566959921852e+00 +8.973607038123167234e-02 1.089736070381231769e+00 +8.993157380254154787e-02 1.089931573802541465e+00 +9.012707722385142339e-02 1.090127077223851382e+00 +9.032258064516128504e-02 1.090322580645161299e+00 +9.051808406647116056e-02 1.090518084066471216e+00 +9.071358748778103609e-02 1.090713587487781133e+00 +9.090909090909091161e-02 1.090909090909090828e+00 +9.110459433040078714e-02 1.091104594330400746e+00 +9.130009775171064879e-02 1.091300097751710663e+00 +9.149560117302052431e-02 1.091495601173020580e+00 +9.169110459433039984e-02 1.091691104594330497e+00 +9.188660801564027536e-02 1.091886608015640192e+00 +9.208211143695015088e-02 1.092082111436950109e+00 +9.227761485826002641e-02 1.092277614858260026e+00 +9.247311827956988806e-02 1.092473118279569944e+00 +9.266862170087976358e-02 1.092668621700879861e+00 +9.286412512218963911e-02 1.092864125122189556e+00 +9.305962854349951463e-02 1.093059628543499473e+00 +9.325513196480939015e-02 1.093255131964809390e+00 +9.345063538611925180e-02 1.093450635386119307e+00 +9.364613880742912733e-02 1.093646138807429224e+00 +9.384164222873900285e-02 1.093841642228738920e+00 +9.403714565004887838e-02 1.094037145650048837e+00 +9.423264907135875390e-02 1.094232649071358754e+00 +9.442815249266861555e-02 1.094428152492668671e+00 +9.462365591397849107e-02 1.094623655913978588e+00 +9.481915933528836660e-02 1.094819159335288283e+00 +9.501466275659824212e-02 1.095014662756598200e+00 +9.521016617790811765e-02 1.095210166177908118e+00 +9.540566959921797929e-02 1.095405669599218035e+00 +9.560117302052785482e-02 1.095601173020527952e+00 +9.579667644183773034e-02 1.095796676441837647e+00 +9.599217986314760587e-02 1.095992179863147564e+00 +9.618768328445748139e-02 1.096187683284457481e+00 +9.638318670576735692e-02 1.096383186705767399e+00 +9.657869012707721856e-02 1.096578690127077316e+00 +9.677419354838709409e-02 1.096774193548387011e+00 +9.696969696969696961e-02 1.096969696969696928e+00 +9.716520039100684514e-02 1.097165200391006845e+00 +9.736070381231672066e-02 1.097360703812316762e+00 +9.755620723362658231e-02 1.097556207233626679e+00 +9.775171065493645783e-02 1.097751710654936375e+00 +9.794721407624633336e-02 1.097947214076246292e+00 +9.814271749755620888e-02 1.098142717497556209e+00 +9.833822091886608441e-02 1.098338220918866126e+00 +9.853372434017595993e-02 1.098533724340176043e+00 +9.872922776148582158e-02 1.098729227761485738e+00 +9.892473118279569710e-02 1.098924731182795655e+00 +9.912023460410557263e-02 1.099120234604105573e+00 +9.931573802541544815e-02 1.099315738025415490e+00 +9.951124144672532368e-02 1.099511241446725407e+00 +9.970674486803518533e-02 1.099706744868035102e+00 +9.990224828934506085e-02 1.099902248289345019e+00 +1.000977517106549364e-01 1.100097751710654936e+00 +1.002932551319648119e-01 1.100293255131964854e+00 +1.004887585532746874e-01 1.100488758553274771e+00 +1.006842619745845491e-01 1.100684261974584466e+00 +1.008797653958944246e-01 1.100879765395894383e+00 +1.010752688172043001e-01 1.101075268817204300e+00 +1.012707722385141756e-01 1.101270772238514217e+00 +1.014662756598240512e-01 1.101466275659824134e+00 +1.016617790811339128e-01 1.101661779081133830e+00 +1.018572825024437883e-01 1.101857282502443747e+00 +1.020527859237536639e-01 1.102052785923753664e+00 +1.022482893450635394e-01 1.102248289345063581e+00 +1.024437927663734149e-01 1.102443792766373498e+00 +1.026392961876832904e-01 1.102639296187683193e+00 +1.028347996089931521e-01 1.102834799608993110e+00 +1.030303030303030276e-01 1.103030303030303028e+00 +1.032258064516129031e-01 1.103225806451612945e+00 +1.034213098729227787e-01 1.103421309872922862e+00 +1.036168132942326542e-01 1.103616813294232557e+00 +1.038123167155425158e-01 1.103812316715542474e+00 +1.040078201368523914e-01 1.104007820136852391e+00 +1.042033235581622669e-01 1.104203323558162309e+00 +1.043988269794721424e-01 1.104398826979472226e+00 +1.045943304007820179e-01 1.104594330400781921e+00 +1.047898338220918935e-01 1.104789833822091838e+00 +1.049853372434017551e-01 1.104985337243401755e+00 +1.051808406647116306e-01 1.105180840664711672e+00 +1.053763440860215062e-01 1.105376344086021589e+00 +1.055718475073313817e-01 1.105571847507331285e+00 +1.057673509286412572e-01 1.105767350928641202e+00 +1.059628543499511188e-01 1.105962854349951119e+00 +1.061583577712609944e-01 1.106158357771261036e+00 +1.063538611925708699e-01 1.106353861192570953e+00 +1.065493646138807454e-01 1.106549364613880648e+00 +1.067448680351906209e-01 1.106744868035190565e+00 +1.069403714565004826e-01 1.106940371456500483e+00 +1.071358748778103581e-01 1.107135874877810400e+00 +1.073313782991202336e-01 1.107331378299120317e+00 +1.075268817204301092e-01 1.107526881720430012e+00 +1.077223851417399847e-01 1.107722385141739929e+00 +1.079178885630498463e-01 1.107917888563049846e+00 +1.081133919843597219e-01 1.108113391984359763e+00 +1.083088954056695974e-01 1.108308895405669681e+00 +1.085043988269794729e-01 1.108504398826979376e+00 +1.086999022482893484e-01 1.108699902248289293e+00 +1.088954056695992240e-01 1.108895405669599210e+00 +1.090909090909090856e-01 1.109090909090909127e+00 +1.092864125122189611e-01 1.109286412512219044e+00 +1.094819159335288367e-01 1.109481915933528740e+00 +1.096774193548387122e-01 1.109677419354838657e+00 +1.098729227761485877e-01 1.109872922776148574e+00 +1.100684261974584494e-01 1.110068426197458491e+00 +1.102639296187683249e-01 1.110263929618768408e+00 +1.104594330400782004e-01 1.110459433040078103e+00 +1.106549364613880759e-01 1.110654936461388020e+00 +1.108504398826979515e-01 1.110850439882697938e+00 +1.110459433040078270e-01 1.111045943304007855e+00 +1.112414467253176886e-01 1.111241446725317772e+00 +1.114369501466275642e-01 1.111436950146627467e+00 +1.116324535679374397e-01 1.111632453567937384e+00 +1.118279569892473152e-01 1.111827956989247301e+00 +1.120234604105571907e-01 1.112023460410557218e+00 +1.122189638318670524e-01 1.112218963831867136e+00 +1.124144672531769279e-01 1.112414467253176831e+00 +1.126099706744868034e-01 1.112609970674486748e+00 +1.128054740957966789e-01 1.112805474095796665e+00 +1.130009775171065545e-01 1.113000977517106582e+00 +1.131964809384164161e-01 1.113196480938416499e+00 +1.133919843597262916e-01 1.113391984359726194e+00 +1.135874877810361672e-01 1.113587487781036112e+00 +1.137829912023460427e-01 1.113782991202346029e+00 +1.139784946236559182e-01 1.113978494623655946e+00 +1.141739980449657799e-01 1.114173998044965863e+00 +1.143695014662756554e-01 1.114369501466275558e+00 +1.145650048875855309e-01 1.114565004887585475e+00 +1.147605083088954064e-01 1.114760508308895393e+00 +1.149560117302052820e-01 1.114956011730205310e+00 +1.151515151515151575e-01 1.115151515151515227e+00 +1.153470185728250191e-01 1.115347018572824922e+00 +1.155425219941348947e-01 1.115542521994134839e+00 +1.157380254154447702e-01 1.115738025415444756e+00 +1.159335288367546457e-01 1.115933528836754673e+00 +1.161290322580645212e-01 1.116129032258064591e+00 +1.163245356793743829e-01 1.116324535679374286e+00 +1.165200391006842584e-01 1.116520039100684203e+00 +1.167155425219941339e-01 1.116715542521994120e+00 +1.169110459433040095e-01 1.116911045943304037e+00 +1.171065493646138850e-01 1.117106549364613954e+00 +1.173020527859237605e-01 1.117302052785923649e+00 +1.174975562072336221e-01 1.117497556207233567e+00 +1.176930596285434977e-01 1.117693059628543484e+00 +1.178885630498533732e-01 1.117888563049853401e+00 +1.180840664711632487e-01 1.118084066471163318e+00 +1.182795698924731242e-01 1.118279569892473013e+00 +1.184750733137829859e-01 1.118475073313782930e+00 +1.186705767350928614e-01 1.118670576735092848e+00 +1.188660801564027369e-01 1.118866080156402765e+00 +1.190615835777126125e-01 1.119061583577712682e+00 +1.192570869990224880e-01 1.119257086999022377e+00 +1.194525904203323496e-01 1.119452590420332294e+00 +1.196480938416422252e-01 1.119648093841642211e+00 +1.198435972629521007e-01 1.119843597262952128e+00 +1.200391006842619762e-01 1.120039100684262046e+00 +1.202346041055718517e-01 1.120234604105571741e+00 +1.204301075268817134e-01 1.120430107526881658e+00 +1.206256109481915889e-01 1.120625610948191575e+00 +1.208211143695014644e-01 1.120821114369501492e+00 +1.210166177908113400e-01 1.121016617790811409e+00 +1.212121212121212155e-01 1.121212121212121104e+00 +1.214076246334310910e-01 1.121407624633431022e+00 +1.216031280547409527e-01 1.121603128054740939e+00 +1.217986314760508282e-01 1.121798631476050856e+00 +1.219941348973607037e-01 1.121994134897360773e+00 +1.221896383186705792e-01 1.122189638318670468e+00 +1.223851417399804548e-01 1.122385141739980385e+00 +1.225806451612903164e-01 1.122580645161290303e+00 +1.227761485826001919e-01 1.122776148582600220e+00 +1.229716520039100675e-01 1.122971652003910137e+00 +1.231671554252199430e-01 1.123167155425219832e+00 +1.233626588465298185e-01 1.123362658846529749e+00 +1.235581622678396940e-01 1.123558162267839666e+00 +1.237536656891495557e-01 1.123753665689149583e+00 +1.239491691104594312e-01 1.123949169110459501e+00 +1.241446725317693067e-01 1.124144672531769196e+00 +1.243401759530791822e-01 1.124340175953079113e+00 +1.245356793743890578e-01 1.124535679374389030e+00 +1.247311827956989194e-01 1.124731182795698947e+00 +1.249266862170087949e-01 1.124926686217008864e+00 +1.251221896383186705e-01 1.125122189638318559e+00 +1.253176930596285321e-01 1.125317693059628477e+00 +1.255131964809384215e-01 1.125513196480938394e+00 +1.257086999022482832e-01 1.125708699902248311e+00 +1.259042033235581726e-01 1.125904203323558228e+00 +1.260997067448680342e-01 1.126099706744867923e+00 +1.262952101661778959e-01 1.126295210166177840e+00 +1.264907135874877853e-01 1.126490713587487758e+00 +1.266862170087976469e-01 1.126686217008797675e+00 +1.268817204301075363e-01 1.126881720430107592e+00 +1.270772238514173980e-01 1.127077223851417287e+00 +1.272727272727272596e-01 1.127272727272727204e+00 +1.274682306940371490e-01 1.127468230694037121e+00 +1.276637341153470107e-01 1.127663734115347038e+00 +1.278592375366569001e-01 1.127859237536656956e+00 +1.280547409579667617e-01 1.128054740957966651e+00 +1.282502443792766234e-01 1.128250244379276568e+00 +1.284457478005865128e-01 1.128445747800586485e+00 +1.286412512218963744e-01 1.128641251221896402e+00 +1.288367546432062638e-01 1.128836754643206319e+00 +1.290322580645161255e-01 1.129032258064516014e+00 +1.292277614858260149e-01 1.129227761485825932e+00 +1.294232649071358765e-01 1.129423264907135849e+00 +1.296187683284457381e-01 1.129618768328445766e+00 +1.298142717497556275e-01 1.129814271749755683e+00 +1.300097751710654892e-01 1.130009775171065378e+00 +1.302052785923753786e-01 1.130205278592375295e+00 +1.304007820136852402e-01 1.130400782013685212e+00 +1.305962854349951019e-01 1.130596285434995130e+00 +1.307917888563049913e-01 1.130791788856305047e+00 +1.309872922776148529e-01 1.130987292277614742e+00 +1.311827956989247423e-01 1.131182795698924659e+00 +1.313782991202346040e-01 1.131378299120234576e+00 +1.315738025415444656e-01 1.131573802541544493e+00 +1.317693059628543550e-01 1.131769305962854411e+00 +1.319648093841642167e-01 1.131964809384164106e+00 +1.321603128054741061e-01 1.132160312805474023e+00 +1.323558162267839677e-01 1.132355816226783940e+00 +1.325513196480938294e-01 1.132551319648093857e+00 +1.327468230694037188e-01 1.132746823069403774e+00 +1.329423264907135804e-01 1.132942326490713469e+00 +1.331378299120234698e-01 1.133137829912023387e+00 +1.333333333333333315e-01 1.133333333333333304e+00 +1.335288367546431931e-01 1.133528836754643221e+00 +1.337243401759530825e-01 1.133724340175953138e+00 +1.339198435972629442e-01 1.133919843597262833e+00 +1.341153470185728336e-01 1.134115347018572750e+00 +1.343108504398826952e-01 1.134310850439882667e+00 +1.345063538611925846e-01 1.134506353861192585e+00 +1.347018572825024463e-01 1.134701857282502502e+00 +1.348973607038123079e-01 1.134897360703812197e+00 +1.350928641251221973e-01 1.135092864125122114e+00 +1.352883675464320590e-01 1.135288367546432031e+00 +1.354838709677419484e-01 1.135483870967741948e+00 +1.356793743890518100e-01 1.135679374389051866e+00 +1.358748778103616717e-01 1.135874877810361561e+00 +1.360703812316715611e-01 1.136070381231671478e+00 +1.362658846529814227e-01 1.136265884652981395e+00 +1.364613880742913121e-01 1.136461388074291312e+00 +1.366568914956011738e-01 1.136656891495601229e+00 +1.368523949169110354e-01 1.136852394916910924e+00 +1.370478983382209248e-01 1.137047898338220842e+00 +1.372434017595307865e-01 1.137243401759530759e+00 +1.374389051808406759e-01 1.137438905180840676e+00 +1.376344086021505375e-01 1.137634408602150593e+00 +1.378299120234603992e-01 1.137829912023460288e+00 +1.380254154447702886e-01 1.138025415444770205e+00 +1.382209188660801502e-01 1.138220918866080122e+00 +1.384164222873900396e-01 1.138416422287390040e+00 +1.386119257086999013e-01 1.138611925708699957e+00 +1.388074291300097629e-01 1.138807429130009652e+00 +1.390029325513196523e-01 1.139002932551319569e+00 +1.391984359726295140e-01 1.139198435972629486e+00 +1.393939393939394034e-01 1.139393939393939403e+00 +1.395894428152492650e-01 1.139589442815249321e+00 +1.397849462365591267e-01 1.139784946236559016e+00 +1.399804496578690161e-01 1.139980449657868933e+00 +1.401759530791788777e-01 1.140175953079178850e+00 +1.403714565004887671e-01 1.140371456500488767e+00 +1.405669599217986288e-01 1.140566959921798684e+00 +1.407624633431084904e-01 1.140762463343108379e+00 +1.409579667644183798e-01 1.140957966764418297e+00 +1.411534701857282414e-01 1.141153470185728214e+00 +1.413489736070381309e-01 1.141348973607038131e+00 +1.415444770283479925e-01 1.141544477028348048e+00 +1.417399804496578819e-01 1.141739980449657965e+00 +1.419354838709677435e-01 1.141935483870967660e+00 +1.421309872922776052e-01 1.142130987292277577e+00 +1.423264907135874946e-01 1.142326490713587495e+00 +1.425219941348973562e-01 1.142521994134897412e+00 +1.427174975562072456e-01 1.142717497556207329e+00 +1.429130009775171073e-01 1.142913000977517024e+00 +1.431085043988269689e-01 1.143108504398826941e+00 +1.433040078201368583e-01 1.143304007820136858e+00 +1.434995112414467200e-01 1.143499511241446776e+00 +1.436950146627566094e-01 1.143695014662756693e+00 +1.438905180840664710e-01 1.143890518084066388e+00 +1.440860215053763327e-01 1.144086021505376305e+00 +1.442815249266862221e-01 1.144281524926686222e+00 +1.444770283479960837e-01 1.144477028347996139e+00 +1.446725317693059731e-01 1.144672531769306056e+00 +1.448680351906158348e-01 1.144868035190615752e+00 +1.450635386119256964e-01 1.145063538611925669e+00 +1.452590420332355858e-01 1.145259042033235586e+00 +1.454545454545454475e-01 1.145454545454545503e+00 +1.456500488758553369e-01 1.145650048875855420e+00 +1.458455522971651985e-01 1.145845552297165115e+00 +1.460410557184750602e-01 1.146041055718475032e+00 +1.462365591397849496e-01 1.146236559139784950e+00 +1.464320625610948112e-01 1.146432062561094867e+00 +1.466275659824047006e-01 1.146627565982404784e+00 +1.468230694037145623e-01 1.146823069403714479e+00 +1.470185728250244517e-01 1.147018572825024396e+00 +1.472140762463343133e-01 1.147214076246334313e+00 +1.474095796676441750e-01 1.147409579667644230e+00 +1.476050830889540644e-01 1.147605083088954148e+00 +1.478005865102639260e-01 1.147800586510263843e+00 +1.479960899315738154e-01 1.147996089931573760e+00 +1.481915933528836771e-01 1.148191593352883677e+00 +1.483870967741935387e-01 1.148387096774193594e+00 +1.485826001955034281e-01 1.148582600195503511e+00 +1.487781036168132898e-01 1.148778103616813207e+00 +1.489736070381231792e-01 1.148973607038123124e+00 +1.491691104594330408e-01 1.149169110459433041e+00 +1.493646138807429025e-01 1.149364613880742958e+00 +1.495601173020527919e-01 1.149560117302052875e+00 +1.497556207233626535e-01 1.149755620723362570e+00 +1.499511241446725429e-01 1.149951124144672487e+00 +1.501466275659824046e-01 1.150146627565982405e+00 +1.503421309872922662e-01 1.150342130987292322e+00 +1.505376344086021556e-01 1.150537634408602239e+00 +1.507331378299120173e-01 1.150733137829911934e+00 +1.509286412512219067e-01 1.150928641251221851e+00 +1.511241446725317683e-01 1.151124144672531768e+00 +1.513196480938416300e-01 1.151319648093841685e+00 +1.515151515151515194e-01 1.151515151515151603e+00 +1.517106549364613810e-01 1.151710654936461298e+00 +1.519061583577712704e-01 1.151906158357771215e+00 +1.521016617790811321e-01 1.152101661779081132e+00 +1.522971652003909937e-01 1.152297165200391049e+00 +1.524926686217008831e-01 1.152492668621700966e+00 +1.526881720430107447e-01 1.152688172043010661e+00 +1.528836754643206342e-01 1.152883675464320579e+00 +1.530791788856304958e-01 1.153079178885630496e+00 +1.532746823069403574e-01 1.153274682306940413e+00 +1.534701857282502468e-01 1.153470185728250330e+00 +1.536656891495601085e-01 1.153665689149560025e+00 +1.538611925708699979e-01 1.153861192570869942e+00 +1.540566959921798595e-01 1.154056695992179860e+00 +1.542521994134897489e-01 1.154252199413489777e+00 +1.544477028347996106e-01 1.154447702834799694e+00 +1.546432062561094722e-01 1.154643206256109389e+00 +1.548387096774193616e-01 1.154838709677419306e+00 +1.550342130987292233e-01 1.155034213098729223e+00 +1.552297165200391127e-01 1.155229716520039140e+00 +1.554252199413489743e-01 1.155425219941349058e+00 +1.556207233626588360e-01 1.155620723362658753e+00 +1.558162267839687254e-01 1.155816226783968670e+00 +1.560117302052785870e-01 1.156011730205278587e+00 +1.562072336265884764e-01 1.156207233626588504e+00 +1.564027370478983381e-01 1.156402737047898421e+00 +1.565982404692081997e-01 1.156598240469208116e+00 +1.567937438905180891e-01 1.156793743890518034e+00 +1.569892473118279508e-01 1.156989247311827951e+00 +1.571847507331378402e-01 1.157184750733137868e+00 +1.573802541544477018e-01 1.157380254154447785e+00 +1.575757575757575635e-01 1.157575757575757480e+00 +1.577712609970674529e-01 1.157771260997067397e+00 +1.579667644183773145e-01 1.157966764418377315e+00 +1.581622678396872039e-01 1.158162267839687232e+00 +1.583577712609970656e-01 1.158357771260997149e+00 +1.585532746823069272e-01 1.158553274682306844e+00 +1.587487781036168166e-01 1.158748778103616761e+00 +1.589442815249266783e-01 1.158944281524926678e+00 +1.591397849462365677e-01 1.159139784946236595e+00 +1.593352883675464293e-01 1.159335288367546513e+00 +1.595307917888563187e-01 1.159530791788856430e+00 +1.597262952101661804e-01 1.159726295210166125e+00 +1.599217986314760420e-01 1.159921798631476042e+00 +1.601173020527859314e-01 1.160117302052785959e+00 +1.603128054740957931e-01 1.160312805474095876e+00 +1.605083088954056825e-01 1.160508308895405793e+00 +1.607038123167155441e-01 1.160703812316715489e+00 +1.608993157380254058e-01 1.160899315738025406e+00 +1.610948191593352952e-01 1.161094819159335323e+00 +1.612903225806451568e-01 1.161290322580645240e+00 +1.614858260019550462e-01 1.161485826001955157e+00 +1.616813294232649079e-01 1.161681329423264852e+00 +1.618768328445747695e-01 1.161876832844574770e+00 +1.620723362658846589e-01 1.162072336265884687e+00 +1.622678396871945206e-01 1.162267839687194604e+00 +1.624633431085044100e-01 1.162463343108504521e+00 +1.626588465298142716e-01 1.162658846529814216e+00 +1.628543499511241333e-01 1.162854349951124133e+00 +1.630498533724340227e-01 1.163049853372434050e+00 +1.632453567937438843e-01 1.163245356793743968e+00 +1.634408602150537737e-01 1.163440860215053885e+00 +1.636363636363636354e-01 1.163636363636363580e+00 +1.638318670576734970e-01 1.163831867057673497e+00 +1.640273704789833864e-01 1.164027370478983414e+00 +1.642228739002932481e-01 1.164222873900293331e+00 +1.644183773216031375e-01 1.164418377321603248e+00 +1.646138807429129991e-01 1.164613880742912944e+00 +1.648093841642228607e-01 1.164809384164222861e+00 +1.650048875855327501e-01 1.165004887585532778e+00 +1.652003910068426118e-01 1.165200391006842695e+00 +1.653958944281525012e-01 1.165395894428152612e+00 +1.655913978494623628e-01 1.165591397849462307e+00 +1.657869012707722245e-01 1.165786901270772224e+00 +1.659824046920821139e-01 1.165982404692082142e+00 +1.661779081133919755e-01 1.166177908113392059e+00 +1.663734115347018649e-01 1.166373411534701976e+00 +1.665689149560117266e-01 1.166568914956011671e+00 +1.667644183773216160e-01 1.166764418377321588e+00 +1.669599217986314776e-01 1.166959921798631505e+00 +1.671554252199413393e-01 1.167155425219941423e+00 +1.673509286412512287e-01 1.167350928641251340e+00 +1.675464320625610903e-01 1.167546432062561035e+00 +1.677419354838709797e-01 1.167741935483870952e+00 +1.679374389051808414e-01 1.167937438905180869e+00 +1.681329423264907030e-01 1.168132942326490786e+00 +1.683284457478005924e-01 1.168328445747800703e+00 +1.685239491691104541e-01 1.168523949169110399e+00 +1.687194525904203435e-01 1.168719452590420316e+00 +1.689149560117302051e-01 1.168914956011730233e+00 +1.691104594330400668e-01 1.169110459433040150e+00 +1.693059628543499562e-01 1.169305962854350067e+00 +1.695014662756598178e-01 1.169501466275659762e+00 +1.696969696969697072e-01 1.169696969696969679e+00 +1.698924731182795689e-01 1.169892473118279597e+00 +1.700879765395894305e-01 1.170087976539589514e+00 +1.702834799608993199e-01 1.170283479960899431e+00 +1.704789833822091816e-01 1.170478983382209126e+00 +1.706744868035190710e-01 1.170674486803519043e+00 +1.708699902248289326e-01 1.170869990224828960e+00 +1.710654936461387943e-01 1.171065493646138878e+00 +1.712609970674486837e-01 1.171260997067448795e+00 +1.714565004887585453e-01 1.171456500488758490e+00 +1.716520039100684347e-01 1.171652003910068407e+00 +1.718475073313782964e-01 1.171847507331378324e+00 +1.720430107526881858e-01 1.172043010752688241e+00 +1.722385141739980474e-01 1.172238514173998158e+00 +1.724340175953079091e-01 1.172434017595307854e+00 +1.726295210166177985e-01 1.172629521016617771e+00 +1.728250244379276601e-01 1.172825024437927688e+00 +1.730205278592375495e-01 1.173020527859237605e+00 +1.732160312805474112e-01 1.173216031280547522e+00 +1.734115347018572728e-01 1.173411534701857217e+00 +1.736070381231671622e-01 1.173607038123167134e+00 +1.738025415444770239e-01 1.173802541544477052e+00 +1.739980449657869133e-01 1.173998044965786969e+00 +1.741935483870967749e-01 1.174193548387096886e+00 +1.743890518084066366e-01 1.174389051808406581e+00 +1.745845552297165260e-01 1.174584555229716498e+00 +1.747800586510263876e-01 1.174780058651026415e+00 +1.749755620723362770e-01 1.174975562072336333e+00 +1.751710654936461387e-01 1.175171065493646250e+00 +1.753665689149560003e-01 1.175366568914955945e+00 +1.755620723362658897e-01 1.175562072336265862e+00 +1.757575757575757514e-01 1.175757575757575779e+00 +1.759530791788856408e-01 1.175953079178885696e+00 +1.761485826001955024e-01 1.176148582600195613e+00 +1.763440860215053640e-01 1.176344086021505309e+00 +1.765395894428152535e-01 1.176539589442815226e+00 +1.767350928641251151e-01 1.176735092864125143e+00 +1.769305962854350045e-01 1.176930596285435060e+00 +1.771260997067448661e-01 1.177126099706744977e+00 +1.773216031280547278e-01 1.177321603128054672e+00 +1.775171065493646172e-01 1.177517106549364589e+00 +1.777126099706744788e-01 1.177712609970674507e+00 +1.779081133919843682e-01 1.177908113391984424e+00 +1.781036168132942299e-01 1.178103616813294341e+00 +1.782991202346040915e-01 1.178299120234604036e+00 +1.784946236559139809e-01 1.178494623655913953e+00 +1.786901270772238426e-01 1.178690127077223870e+00 +1.788856304985337320e-01 1.178885630498533788e+00 +1.790811339198435936e-01 1.179081133919843705e+00 +1.792766373411534830e-01 1.179276637341153400e+00 +1.794721407624633447e-01 1.179472140762463317e+00 +1.796676441837732063e-01 1.179667644183773234e+00 +1.798631476050830957e-01 1.179863147605083151e+00 +1.800586510263929574e-01 1.180058651026393068e+00 +1.802541544477028468e-01 1.180254154447702764e+00 +1.804496578690127084e-01 1.180449657869012681e+00 +1.806451612903225701e-01 1.180645161290322598e+00 +1.808406647116324595e-01 1.180840664711632515e+00 +1.810361681329423211e-01 1.181036168132942432e+00 +1.812316715542522105e-01 1.181231671554252127e+00 +1.814271749755620722e-01 1.181427174975562044e+00 +1.816226783968719338e-01 1.181622678396871962e+00 +1.818181818181818232e-01 1.181818181818181879e+00 +1.820136852394916849e-01 1.182013685239491796e+00 +1.822091886608015743e-01 1.182209188660801491e+00 +1.824046920821114359e-01 1.182404692082111408e+00 +1.826001955034212976e-01 1.182600195503421325e+00 +1.827956989247311870e-01 1.182795698924731242e+00 +1.829912023460410486e-01 1.182991202346041160e+00 +1.831867057673509380e-01 1.183186705767350855e+00 +1.833822091886607997e-01 1.183382209188660772e+00 +1.835777126099706613e-01 1.183577712609970689e+00 +1.837732160312805507e-01 1.183773216031280606e+00 +1.839687194525904124e-01 1.183968719452590523e+00 +1.841642228739003018e-01 1.184164222873900219e+00 +1.843597262952101634e-01 1.184359726295210136e+00 +1.845552297165200528e-01 1.184555229716520053e+00 +1.847507331378299145e-01 1.184750733137829970e+00 +1.849462365591397761e-01 1.184946236559139887e+00 +1.851417399804496655e-01 1.185141739980449582e+00 +1.853372434017595272e-01 1.185337243401759499e+00 +1.855327468230694166e-01 1.185532746823069417e+00 +1.857282502443792782e-01 1.185728250244379334e+00 +1.859237536656891399e-01 1.185923753665689251e+00 +1.861192570869990293e-01 1.186119257086998946e+00 +1.863147605083088909e-01 1.186314760508308863e+00 +1.865102639296187803e-01 1.186510263929618780e+00 +1.867057673509286420e-01 1.186705767350928697e+00 +1.869012707722385036e-01 1.186901270772238615e+00 +1.870967741935483930e-01 1.187096774193548310e+00 +1.872922776148582547e-01 1.187292277614858227e+00 +1.874877810361681441e-01 1.187487781036168144e+00 +1.876832844574780057e-01 1.187683284457478061e+00 +1.878787878787878673e-01 1.187878787878787978e+00 +1.880742913000977568e-01 1.188074291300097673e+00 +1.882697947214076184e-01 1.188269794721407591e+00 +1.884652981427175078e-01 1.188465298142717508e+00 +1.886608015640273694e-01 1.188660801564027425e+00 +1.888563049853372311e-01 1.188856304985337342e+00 +1.890518084066471205e-01 1.189051808406647037e+00 +1.892473118279569821e-01 1.189247311827956954e+00 +1.894428152492668715e-01 1.189442815249266872e+00 +1.896383186705767332e-01 1.189638318670576789e+00 +1.898338220918865948e-01 1.189833822091886706e+00 +1.900293255131964842e-01 1.190029325513196401e+00 +1.902248289345063459e-01 1.190224828934506318e+00 +1.904203323558162353e-01 1.190420332355816235e+00 +1.906158357771260969e-01 1.190615835777126152e+00 +1.908113391984359586e-01 1.190811339198436070e+00 +1.910068426197458480e-01 1.191006842619745765e+00 +1.912023460410557096e-01 1.191202346041055682e+00 +1.913978494623655990e-01 1.191397849462365599e+00 +1.915933528836754607e-01 1.191593352883675516e+00 +1.917888563049853501e-01 1.191788856304985433e+00 +1.919843597262952117e-01 1.191984359726295128e+00 +1.921798631476050734e-01 1.192179863147605046e+00 +1.923753665689149628e-01 1.192375366568914963e+00 +1.925708699902248244e-01 1.192570869990224880e+00 +1.927663734115347138e-01 1.192766373411534797e+00 +1.929618768328445755e-01 1.192961876832844492e+00 +1.931573802541544371e-01 1.193157380254154409e+00 +1.933528836754643265e-01 1.193352883675464327e+00 +1.935483870967741882e-01 1.193548387096774244e+00 +1.937438905180840776e-01 1.193743890518084161e+00 +1.939393939393939392e-01 1.193939393939393856e+00 +1.941348973607038009e-01 1.194134897360703773e+00 +1.943304007820136903e-01 1.194330400782013690e+00 +1.945259042033235519e-01 1.194525904203323607e+00 +1.947214076246334413e-01 1.194721407624633525e+00 +1.949169110459433030e-01 1.194916911045943220e+00 +1.951124144672531646e-01 1.195112414467253137e+00 +1.953079178885630540e-01 1.195307917888563054e+00 +1.955034213098729157e-01 1.195503421309872971e+00 +1.956989247311828051e-01 1.195698924731182888e+00 +1.958944281524926667e-01 1.195894428152492583e+00 +1.960899315738025284e-01 1.196089931573802501e+00 +1.962854349951124178e-01 1.196285434995112418e+00 +1.964809384164222794e-01 1.196480938416422335e+00 +1.966764418377321688e-01 1.196676441837732252e+00 +1.968719452590420305e-01 1.196871945259041947e+00 +1.970674486803519199e-01 1.197067448680351864e+00 +1.972629521016617815e-01 1.197262952101661782e+00 +1.974584555229716432e-01 1.197458455522971699e+00 +1.976539589442815326e-01 1.197653958944281616e+00 +1.978494623655913942e-01 1.197849462365591311e+00 +1.980449657869012836e-01 1.198044965786901228e+00 +1.982404692082111453e-01 1.198240469208211145e+00 +1.984359726295210069e-01 1.198435972629521062e+00 +1.986314760508308963e-01 1.198631476050830980e+00 +1.988269794721407580e-01 1.198826979472140675e+00 +1.990224828934506474e-01 1.199022482893450592e+00 +1.992179863147605090e-01 1.199217986314760509e+00 +1.994134897360703707e-01 1.199413489736070426e+00 +1.996089931573802601e-01 1.199608993157380343e+00 +1.998044965786901217e-01 1.199804496578690038e+00 +2.000000000000000111e-01 1.199999999999999956e+00 diff --git a/output/colore_node0.dbg b/output/colore_node0.dbg new file mode 100644 index 0000000..d58c206 --- /dev/null +++ b/output/colore_node0.dbg @@ -0,0 +1 @@ +MPI task 0 has 97421 particles diff --git a/output/colore_params.cfg b/output/colore_params.cfg new file mode 100644 index 0000000..c7dcbe5 --- /dev/null +++ b/output/colore_params.cfg @@ -0,0 +1,55 @@ +global = { + prefix_out = "output/colore" + output_format = "FITS" + output_density = true + pk_filename = "output/pk.txt" + z_min = 0.0001 + z_max = 0.15 + seed = 1000 + write_pred = false + just_write_pred = false +} +field_par = { + r_smooth = 1.0 + smooth_potential = true + n_grid = 256 + dens_type = 1 + lpt_buffer_fraction = 0.6 + lpt_interp_type = 1 + output_lpt = 0 +} +cosmo_par = { + omega_M = 0.3 + omega_B = 0.3 + omega_L = 0.7 + h = 0.7 + w = -1.0 + ns = 0.96 + sigma_8 = 0.8 +} +custom1 = { + kz_filename = "output/wz.txt" + bias_filename = "output/bias.txt" + nside = 64 +} +srcs1 = { + nz_filename = "output/dndz.txt" + bias_filename = "output/bias.txt" + include_lensing = true + store_skewers = true +} +imap1 = { + tbak_filename = "output/tz.txt" + bias_filename = "output/bias.txt" + freq_list = "output/nuTable.txt" + freq_rest = 1420.0 + nside = 64 +} +kappa = { + z_out = [ 0.1 ] + nside = 64 +} +isw = { + z_out = [ 0.1 ] + nside = 64 +} diff --git a/output/dndz.txt b/output/dndz.txt new file mode 100644 index 0000000..8f1b9cd --- /dev/null +++ b/output/dndz.txt @@ -0,0 +1,1024 @@ +0.000000000000000000e+00 0.000000000000000000e+00 +1.955034213098729226e-04 5.144614850061313485e-03 +3.910068426197458452e-04 2.055867461599717935e-02 +5.865102639296187678e-04 4.619943569916008103e-02 +7.820136852394916904e-04 8.201127089156068362e-02 +9.775171065493646130e-04 1.279283939788823932e-01 +1.173020527859237536e-03 1.838764005650315447e-01 +1.368523949169110458e-03 2.497733215606447454e-01 +1.564027370478983381e-03 3.255304139944505404e-01 +1.759530791788856303e-03 4.110527900479271080e-01 +1.955034213098729226e-03 5.062399377224686692e-01 +2.150537634408602149e-03 6.109861645187324442e-01 +2.346041055718475071e-03 7.251809839682573644e-01 +2.541544477028347994e-03 8.487094582682835897e-01 +2.737047898338220916e-03 9.814525062558020485e-01 +2.932551319648093839e-03 1.123287183382744026e+00 +3.128054740957966762e-03 1.274086938634620303e+00 +3.323558162267839684e-03 1.433721852146530251e+00 +3.519061583577712607e-03 1.602058856425442324e+00 +3.714565004887585530e-03 1.778961943472002316e+00 +3.910068426197458452e-03 1.964292359637076046e+00 +4.105571847507331375e-03 2.157908789701169727e+00 +4.301075268817204297e-03 2.359667531397612539e+00 +4.496578690127077220e-03 2.569422661391640883e+00 +4.692082111436950143e-03 2.787026193562406551e+00 +4.887585532746823065e-03 3.012328230302780518e+00 +5.083088954056695988e-03 3.245177107445030185e+00 +5.278592375366568910e-03 3.485419533333289355e+00 +5.474095796676441833e-03 3.732900722491982126e+00 +5.669599217986314756e-03 3.987464524279927591e+00 +5.865102639296187678e-03 4.248953546870121833e+00 +6.060606060606060601e-03 4.517209276853444422e+00 +6.256109481915933523e-03 4.792072194729219525e+00 +6.451612903225806446e-03 5.073381886515504036e+00 +6.647116324535679369e-03 5.360977151686284969e+00 +6.842619745845552291e-03 5.654696107620751810e+00 +7.038123167155425214e-03 5.954376290730726495e+00 +7.233626588465298136e-03 6.259854754415894895e+00 +7.429130009775171059e-03 6.570968163982113808e+00 +7.624633431085043982e-03 6.887552888645597449e+00 +7.820136852394916904e-03 7.209445090734797112e+00 +8.015640273704788960e-03 7.536480812192184686e+00 +8.211143695014662749e-03 7.868496058469691690e+00 +8.406647116324536539e-03 8.205326879904005111e+00 +8.602150537634408595e-03 8.546809450651410955e+00 +8.797653958944280650e-03 8.892780145255825275e+00 +8.993157380254154440e-03 9.243075612918605799e+00 +9.188660801564028230e-03 9.597532849533820354e+00 +9.384164222873900285e-03 9.955989267548797983e+00 +9.579667644183772340e-03 1.031828276370569952e+01 +9.775171065493646130e-03 1.068425178471676773e+01 +9.970674486803519920e-03 1.105373539092272495e+01 +1.016617790811339198e-02 1.142657331798121234e+01 +1.036168132942326403e-02 1.180260603662959085e+01 +1.055718475073313782e-02 1.218167481056429580e+01 +1.075268817204301161e-02 1.256362175247692470e+01 +1.094819159335288367e-02 1.294828987828541500e+01 +1.114369501466275572e-02 1.333552315959705048e+01 +1.133919843597262951e-02 1.372516657443849830e+01 +1.153470185728250330e-02 1.411706615628677319e+01 +1.173020527859237536e-02 1.451106904143378351e+01 +1.192570869990224741e-02 1.490702351471596465e+01 +1.212121212121212120e-02 1.530477905363949453e+01 +1.231671554252199499e-02 1.570418637093061598e+01 +1.251221896383186705e-02 1.610509745553979499e+01 +1.270772238514173910e-02 1.650736561212764641e+01 +1.290322580645161289e-02 1.691084549905964352e+01 +1.309872922776148668e-02 1.731539316493635994e+01 +1.329423264907135874e-02 1.772086608368491767e+01 +1.348973607038123079e-02 1.812712318823713886e+01 +1.368523949169110458e-02 1.853402490281910531e+01 +1.388074291300097837e-02 1.894143317387645453e+01 +1.407624633431085043e-02 1.934921149965935427e+01 +1.427174975562072248e-02 1.975722495849057125e+01 +1.446725317693059627e-02 2.016534023573964518e+01 +1.466275659824047006e-02 2.057342564952594088e+01 +1.485826001955034212e-02 2.098135117517296422e+01 +1.505376344086021417e-02 2.138898846843592594e+01 +1.524926686217008796e-02 2.179621088752426417e+01 +1.544477028347996175e-02 2.220289351394074018e+01 +1.564027370478983381e-02 2.260891317215816798e+01 +1.583577712609970586e-02 2.301414844815477778e+01 +1.603128054740957792e-02 2.341847970682891855e+01 +1.622678396871945344e-02 2.382178910831359886e+01 +1.642228739002932550e-02 2.422396062321106669e+01 +1.661779081133919755e-02 2.462488004676758990e+01 +1.681329423264907308e-02 2.502443501200816200e+01 +1.700879765395894513e-02 2.542251500185090762e+01 +1.720430107526881719e-02 2.581901136022058907e+01 +1.739980449657868924e-02 2.621381730218054784e+01 +1.759530791788856130e-02 2.660682792310217692e+01 +1.779081133919843682e-02 2.699794020689086693e+01 +1.798631476050830888e-02 2.738705303328724838e+01 +1.818181818181818094e-02 2.777406718426227172e+01 +1.837732160312805646e-02 2.815888534952466671e+01 +1.857282502443792851e-02 2.854141213115898523e+01 +1.876832844574780057e-02 2.892155404741243885e+01 +1.896383186705767263e-02 2.929921953564849701e+01 +1.915933528836754468e-02 2.967431895448504520e+01 +1.935483870967742021e-02 3.004676458513481307e+01 +1.955034213098729226e-02 3.041647063196561618e+01 +1.974584555229716432e-02 3.078335322229773396e+01 +1.994134897360703984e-02 3.114733040545573317e+01 +2.013685239491691190e-02 3.150832215109170420e+01 +2.033235581622678395e-02 3.186625034679698487e+01 +2.052785923753665601e-02 3.222103879501899826e+01 +2.072336265884652806e-02 3.257261320929996629e+01 +2.091886608015640359e-02 3.292090120985386648e+01 +2.111436950146627564e-02 3.326583231849808442e+01 +2.130987292277614770e-02 3.360733795295581672e+01 +2.150537634408602322e-02 3.394535142054536436e+01 +2.170087976539589528e-02 3.427980791127210125e+01 +2.189638318670576733e-02 3.461064449033892743e+01 +2.209188660801563939e-02 3.493780009009068266e+01 +2.228739002932551144e-02 3.526121550140803862e+01 +2.248289345063538697e-02 3.558083336456613921e+01 +2.267839687194525902e-02 3.589659815957284650e+01 +2.287390029325513108e-02 3.620845619600203236e+01 +2.306940371456500660e-02 3.651635560233617639e+01 +2.326490713587487866e-02 3.682024631483330523e+01 +2.346041055718475071e-02 3.712008006593250542e+01 +2.365591397849462277e-02 3.741581037221255457e+01 +2.385141739980449482e-02 3.770739252191757629e+01 +2.404692082111437035e-02 3.799478356206386565e+01 +2.424242424242424240e-02 3.827794228514178343e+01 +2.443792766373411446e-02 3.855682921542626218e+01 +2.463343108504398998e-02 3.883140659490945268e+01 +2.482893450635386204e-02 3.910163836886890465e+01 +2.502443792766373409e-02 3.936749017108454751e+01 +2.521994134897360615e-02 3.962892930871727515e+01 +2.541544477028347820e-02 3.988592474686212341e+01 +2.561094819159335373e-02 4.013844709278873069e+01 +2.580645161290322578e-02 4.038646857988166516e+01 +2.600195503421309784e-02 4.062996305129266261e+01 +2.619745845552297336e-02 4.086890594331743642e+01 +2.639296187683284542e-02 4.110327426850863475e+01 +2.658846529814271747e-02 4.133304659853704521e+01 +2.678396871945258953e-02 4.155820304681266464e+01 +2.697947214076246158e-02 4.177872525087713029e+01 +2.717497556207233711e-02 4.199459635457884588e+01 +2.737047898338220916e-02 4.220580099004195063e+01 +2.756598240469208122e-02 4.241232525944030840e+01 +2.776148582600195674e-02 4.261415671658703985e+01 +2.795698924731182880e-02 4.281128434835051166e+01 +2.815249266862170086e-02 4.300369855590719936e+01 +2.834799608993157291e-02 4.319139113584174794e+01 +2.854349951124144497e-02 4.337435526110427730e+01 +2.873900293255132049e-02 4.355258546183518575e+01 +2.893450635386119255e-02 4.372607760606692295e+01 +2.913000977517106460e-02 4.389482888031268715e+01 +2.932551319648094013e-02 4.405883777005128366e+01 +2.952101661779081218e-02 4.421810404011767304e+01 +2.971652003910068424e-02 4.437262871500808359e+01 +2.991202346041055629e-02 4.452241405910898919e+01 +3.010752688172042835e-02 4.466746355685844350e+01 +3.030303030303030387e-02 4.480778189284860247e+01 +3.049853372434017593e-02 4.494337493187794053e+01 +3.069403714565004798e-02 4.507424969896120359e+01 +3.088954056695992351e-02 4.520041435930561846e+01 +3.108504398826979556e-02 4.532187819826108210e+01 +3.128054740957966762e-02 4.543865160125209712e+01 +3.147605083088954314e-02 4.555074603369951802e+01 +3.167155425219941173e-02 4.565817402093892952e+01 +3.186705767350928725e-02 4.576094912814371440e+01 +3.206256109481915584e-02 4.585908594025946883e+01 +3.225806451612903136e-02 4.595260004195691295e+01 +3.245356793743890689e-02 4.604150799761031720e+01 +3.264907135874877547e-02 4.612582733130793855e+01 +3.284457478005865100e-02 4.620557650690107465e+01 +3.304007820136852652e-02 4.628077490809814520e+01 +3.323558162267839511e-02 4.635144281861001758e+01 +3.343108504398827063e-02 4.641760140235270882e+01 +3.362658846529814616e-02 4.647927268371326903e+01 +3.382209188660801474e-02 4.653647952788470121e+01 +3.401759530791789027e-02 4.658924562127551638e+01 +3.421309872922775885e-02 4.663759545199958723e+01 +3.440860215053763438e-02 4.668155429045129523e+01 +3.460410557184750990e-02 4.672114816997127207e+01 +3.479960899315737849e-02 4.675640386760817790e+01 +3.499511241446725401e-02 4.678734888498071598e+01 +3.519061583577712260e-02 4.681401142924514858e+01 +3.538611925708699812e-02 4.683642039417281921e+01 +3.558162267839687365e-02 4.685460534134208643e+01 +3.577712609970674223e-02 4.686859648144905321e+01 +3.597262952101661776e-02 4.687842465574129136e+01 +3.616813294232649328e-02 4.688412131757858958e+01 +3.636363636363636187e-02 4.688571851412482516e+01 +3.655913978494623739e-02 4.688324886817449766e+01 +3.675464320625611292e-02 4.687674556011786819e+01 +3.695014662756598151e-02 4.686624231004795860e+01 +3.714565004887585703e-02 4.685177336001324733e+01 +3.734115347018572562e-02 4.683337345641888305e+01 +3.753665689149560114e-02 4.681107783257982646e+01 +3.773216031280547667e-02 4.678492219142910358e+01 +3.792766373411534525e-02 4.675494268838377110e+01 +3.812316715542522078e-02 4.672117591437162787e+01 +3.831867057673508936e-02 4.668365887902122324e+01 +3.851417399804496489e-02 4.664242899401804010e+01 +3.870967741935484041e-02 4.659752405662870700e+01 +3.890518084066470900e-02 4.654898223339626639e+01 +3.910068426197458452e-02 4.649684204400818999e+01 +3.929618768328446005e-02 4.644114234533973473e+01 +3.949169110459432863e-02 4.638192231567413160e+01 +3.968719452590420416e-02 4.631922143910198031e+01 +3.988269794721407968e-02 4.625307949010134934e+01 +4.007820136852394827e-02 4.618353651830047113e+01 +4.027370478983382379e-02 4.611063283342453190e+01 +4.046920821114369238e-02 4.603440899042805512e+01 +4.066471163245356790e-02 4.595490577481422179e+01 +4.086021505376344343e-02 4.587216418814271890e+01 +4.105571847507331201e-02 4.578622543372684106e+01 +4.125122189638318754e-02 4.569713090252140830e+01 +4.144672531769305612e-02 4.560492215920228176e+01 +4.164222873900293165e-02 4.550964092843846487e+01 +4.183773216031280717e-02 4.541132908135769242e+01 +4.203323558162267576e-02 4.531002862220601202e+01 +4.222873900293255128e-02 4.520578167520254453e+01 +4.242424242424242681e-02 4.509863047158939509e+01 +4.261974584555229539e-02 4.498861733687773778e+01 +4.281524926686217092e-02 4.487578467829007423e+01 +4.301075268817204644e-02 4.476017497239941889e+01 +4.320625610948191503e-02 4.464183075296534753e+01 +4.340175953079179055e-02 4.452079459896732061e+01 +4.359726295210165914e-02 4.439710912283516109e+01 +4.379276637341153466e-02 4.427081695887712698e+01 +4.398826979472141019e-02 4.414196075190517377e+01 +4.418377321603127877e-02 4.401058314605740662e+01 +4.437927663734115430e-02 4.387672677381776509e+01 +4.457478005865102288e-02 4.374043424523246415e+01 +4.477028347996089841e-02 4.360174813732303534e+01 +4.496578690127077393e-02 4.346071098369549901e+01 +4.516129032258064252e-02 4.331736526434551848e+01 +4.535679374389051804e-02 4.317175339565871894e+01 +4.555229716520039357e-02 4.302391772060579456e+01 +4.574780058651026216e-02 4.287390049913189216e+01 +4.594330400782013768e-02 4.272174389873948286e+01 +4.613880742913001320e-02 4.256748998526412464e+01 +4.633431085043988179e-02 4.241118071384233446e+01 +4.652981427174975732e-02 4.225285792007058205e+01 +4.672531769305962590e-02 4.209256331135498641e+01 +4.692082111436950143e-02 4.193033845845040730e+01 +4.711632453567937695e-02 4.176622478718800124e+01 +4.731182795698924554e-02 4.160026357039054545e+01 +4.750733137829912106e-02 4.143249591997432191e+01 +4.770283479960898965e-02 4.126296277923626121e+01 +4.789833822091886517e-02 4.109170491532550784e+01 +4.809384164222874070e-02 4.091876291189838355e+01 +4.828934506353860928e-02 4.074417716195498684e+01 +4.848484848484848481e-02 4.056798786085668240e+01 +4.868035190615836033e-02 4.039023499952295282e+01 +4.887585532746822892e-02 4.021095835780656103e+01 +4.907135874877810444e-02 4.003019749804524707e+01 +4.926686217008797997e-02 3.984799175878913502e+01 +4.946236559139784855e-02 3.966438024870169698e+01 +4.965786901270772408e-02 3.947940184063381963e+01 +4.985337243401759266e-02 3.929309516586844353e+01 +5.004887585532746819e-02 3.910549860853510040e+01 +5.024437927663734371e-02 3.891665030019235871e+01 +5.043988269794721230e-02 3.872658811457687023e+01 +5.063538611925708782e-02 3.853534966251729088e+01 +5.083088954056695641e-02 3.834297228701142046e+01 +5.102639296187683193e-02 3.814949305846536731e+01 +5.122189638318670746e-02 3.795494877009237911e+01 +5.141739980449657604e-02 3.775937593347043020e+01 +5.161290322580645157e-02 3.756281077425617809e+01 +5.180840664711632709e-02 3.736528922805434405e+01 +5.200391006842619568e-02 3.716684693644003090e+01 +5.219941348973607120e-02 3.696751924313281989e+01 +5.239491691104594673e-02 3.676734119032056469e+01 +5.259042033235581531e-02 3.656634751513141879e+01 +5.278592375366569084e-02 3.636457264625189367e+01 +5.298142717497555942e-02 3.616205070068969007e+01 +5.317693059628543495e-02 3.595881548067885802e+01 +5.337243401759531047e-02 3.575490047072634070e+01 +5.356793743890517906e-02 3.555033883479703860e+01 +5.376344086021505458e-02 3.534516341363657688e+01 +5.395894428152492317e-02 3.513940672222905448e+01 +5.415444770283479869e-02 3.493310094738872351e+01 +5.434995112414467422e-02 3.472627794548312608e+01 +5.454545454545454281e-02 3.451896924028614677e+01 +5.474095796676441833e-02 3.431120602095906946e+01 +5.493646138807429385e-02 3.410301914015777669e+01 +5.513196480938416244e-02 3.389443911226415906e+01 +5.532746823069403797e-02 3.368549611173985880e+01 +5.552297165200391349e-02 3.347621997160070606e+01 +5.571847507331378208e-02 3.326664018200965245e+01 +5.591397849462365760e-02 3.305678588898648229e+01 +5.610948191593352619e-02 3.284668589323246835e+01 +5.630498533724340171e-02 3.263636864906798252e+01 +5.650048875855327724e-02 3.242586226348145573e+01 +5.669599217986314582e-02 3.221519449528729950e+01 +5.689149560117302135e-02 3.200439275439148190e+01 +5.708699902248288993e-02 3.179348410116273627e+01 +5.728250244379276546e-02 3.158249524590714330e+01 +5.747800586510264098e-02 3.137145254844488562e+01 +5.767350928641250957e-02 3.116038201778686911e+01 +5.786901270772238509e-02 3.094930931190948087e+01 +5.806451612903226062e-02 3.073825973762573582e+01 +5.826001955034212920e-02 3.052725825055081188e+01 +5.845552297165200473e-02 3.031632945516043520e+01 +5.865102639296188025e-02 3.010549760493989524e+01 +5.884652981427174884e-02 2.989478660262235366e+01 +5.904203323558162436e-02 2.968422000051411658e+01 +5.923753665689149295e-02 2.947382100090564094e+01 +5.943304007820136847e-02 2.926361245656607935e+01 +5.962854349951124400e-02 2.905361687131978954e+01 +5.982404692082111258e-02 2.884385640070291856e+01 +6.001955034213098811e-02 2.863435285269845210e+01 +6.021505376344085669e-02 2.842512768854805216e+01 +6.041055718475073222e-02 2.821620202363849117e+01 +6.060606060606060774e-02 2.800759662846176568e+01 +6.080156402737047633e-02 2.779933192964630351e+01 +6.099706744868035185e-02 2.759142801105830500e+01 +6.119257086999022738e-02 2.738390461497112938e+01 +6.138807429130009596e-02 2.717678114330115946e+01 +6.158357771260997149e-02 2.697007665890846440e+01 +6.177908113391984701e-02 2.676380988696081786e+01 +6.197458455522971560e-02 2.655799921635919603e+01 +6.217008797653959112e-02 2.635266270122319199e+01 +6.236559139784945971e-02 2.614781806243481554e+01 +6.256109481915933523e-02 2.594348268923932466e+01 +6.275659824046921076e-02 2.573967364090086107e+01 +6.295210166177908628e-02 2.553640764841219735e+01 +6.314760508308894793e-02 2.533370111625619714e+01 +6.334310850439882346e-02 2.513157012421829961e+01 +6.353861192570869898e-02 2.493003042924788204e+01 +6.373411534701857450e-02 2.472909746736724657e+01 +6.392961876832845003e-02 2.452878635562689169e+01 +6.412512218963831168e-02 2.432911189410534547e+01 +6.432062561094818720e-02 2.413008856795235602e+01 +6.451612903225806273e-02 2.393173054947374467e+01 +6.471163245356793825e-02 2.373405170025700528e+01 +6.490713587487781377e-02 2.353706557333559957e+01 +6.510263929618768930e-02 2.334078541539104279e+01 +6.529814271749755095e-02 2.314522416899133717e+01 +6.549364613880742647e-02 2.295039447486427164e+01 +6.568914956011730200e-02 2.275630867420443337e+01 +6.588465298142717752e-02 2.256297881101251690e+01 +6.608015640273705305e-02 2.237041663446557038e+01 +6.627565982404691469e-02 2.217863360131724804e+01 +6.647116324535679022e-02 2.198764087832631020e+01 +6.666666666666666574e-02 2.179744934471255391e+01 +6.686217008797654127e-02 2.160806959463874577e+01 +6.705767350928641679e-02 2.141951193971743095e+01 +6.725317693059629232e-02 2.123178641154130375e+01 +6.744868035190615396e-02 2.104490276423626227e+01 +6.764418377321602949e-02 2.085887047703548447e+01 +6.783968719452590501e-02 2.067369875687415259e+01 +6.803519061583578054e-02 2.048939654100291818e+01 +6.823069403714565606e-02 2.030597249961945039e+01 +6.842619745845551771e-02 2.012343503851695914e+01 +6.862170087976539323e-02 1.994179230174846396e+01 +6.881720430107526876e-02 1.976105217430603744e+01 +6.901270772238514428e-02 1.958122228481353844e+01 +6.920821114369501981e-02 1.940231000823240493e+01 +6.940371456500488145e-02 1.922432246857902527e+01 +6.959921798631475698e-02 1.904726654165287059e+01 +6.979472140762463250e-02 1.887114885777466355e+01 +6.999022482893450803e-02 1.869597580453311991e+01 +7.018572825024438355e-02 1.852175352953993581e+01 +7.038123167155424520e-02 1.834848794319164256e+01 +7.057673509286412072e-02 1.817618472143754715e+01 +7.077223851417399625e-02 1.800484930855330035e+01 +7.096774193548387177e-02 1.783448691991842239e+01 +7.116324535679374730e-02 1.766510254479771902e+01 +7.135874877810362282e-02 1.749670094912529805e+01 +7.155425219941348447e-02 1.732928667829060743e+01 +7.174975562072335999e-02 1.716286405992553199e+01 +7.194525904203323552e-02 1.699743720669189173e+01 +7.214076246334311104e-02 1.683301001906861671e+01 +7.233626588465298657e-02 1.666958618813763593e+01 +7.253176930596284822e-02 1.650716919836805019e+01 +7.272727272727272374e-02 1.634576233039756588e+01 +7.292277614858259926e-02 1.618536866381079875e+01 +7.311827956989247479e-02 1.602599107991353122e+01 +7.331378299120235031e-02 1.586763226450235997e+01 +7.350928641251222584e-02 1.571029471062900029e+01 +7.370478983382208749e-02 1.555398072135886700e+01 +7.390029325513196301e-02 1.539869241252286614e+01 +7.409579667644183854e-02 1.524443171546223574e+01 +7.429130009775171406e-02 1.509120037976558137e+01 +7.448680351906158958e-02 1.493899997599756801e+01 +7.468230694037145123e-02 1.478783189841885992e+01 +7.487781036168132676e-02 1.463769736769643792e+01 +7.507331378299120228e-02 1.448859743360422137e+01 +7.526881720430107781e-02 1.434053297771304436e+01 +7.546432062561095333e-02 1.419350471606967012e+01 +7.565982404692081498e-02 1.404751320186442953e+01 +7.585532746823069050e-02 1.390255882808678578e+01 +7.605083088954056603e-02 1.375864183016867770e+01 +7.624633431085044155e-02 1.361576228861479088e+01 +7.644183773216031708e-02 1.347392013161966950e+01 +7.663734115347017872e-02 1.333311513767116274e+01 +7.683284457478005425e-02 1.319334693813950743e+01 +7.702834799608992977e-02 1.305461501985217154e+01 +7.722385141739980530e-02 1.291691872765357196e+01 +7.741935483870968082e-02 1.278025726694963993e+01 +7.761485826001955635e-02 1.264462970623662841e+01 +7.781036168132941799e-02 1.251003497961402111e+01 +7.800586510263929352e-02 1.237647188928100839e+01 +7.820136852394916904e-02 1.224393910801644125e+01 +7.839687194525904457e-02 1.211243518164171817e+01 +7.859237536656892009e-02 1.198195853146639500e+01 +7.878787878787878174e-02 1.185250745671627293e+01 +7.898338220918865726e-02 1.172408013694362339e+01 +7.917888563049853279e-02 1.159667463441938651e+01 +7.937438905180840831e-02 1.147028889650679950e+01 +7.956989247311828384e-02 1.134492075801668243e+01 +7.976539589442815936e-02 1.122056794354366538e+01 +7.996089931573802101e-02 1.109722806978344600e+01 +8.015640273704789653e-02 1.097489864783071667e+01 +8.035190615835777206e-02 1.085357708545762989e+01 +8.054740957966764758e-02 1.073326068937257993e+01 +8.074291300097752311e-02 1.061394666745905724e+01 +8.093841642228738475e-02 1.049563213099452419e+01 +8.113391984359726028e-02 1.037831409684903505e+01 +8.132942326490713580e-02 1.026198948966349711e+01 +8.152492668621701133e-02 1.014665514400743263e+01 +8.172043010752688685e-02 1.003230780651602849e+01 +8.191593352883674850e-02 9.918944138006500211e+00 +8.211143695014662403e-02 9.806560715573395370e+00 +8.230694037145649955e-02 9.695154034663024945e+00 +8.250244379276637507e-02 9.584720511126739950e+00 +8.269794721407625060e-02 9.475256483252874062e+00 +8.289345063538611225e-02 9.366758213777565345e+00 +8.308895405669598777e-02 9.259221891873977484e+00 +8.328445747800586330e-02 9.152643635120277565e+00 +8.347996089931573882e-02 9.047019491445924544e+00 +8.367546432062561435e-02 8.942345441056462008e+00 +8.387096774193548987e-02 8.838617398336589659e+00 +8.406647116324535152e-02 8.735831213731733769e+00 +8.426197458455522704e-02 8.633982675607681401e+00 +8.445747800586510257e-02 8.533067512088695850e+00 +8.465298142717497809e-02 8.433081392873674531e+00 +8.484848484848485362e-02 8.334019931030674400e+00 +8.504398826979471526e-02 8.235878684769618374e+00 +8.523949169110459079e-02 8.138653159193102837e+00 +8.543499511241446631e-02 8.042338808025636609e+00 +8.563049853372434184e-02 7.946931035320893066e+00 +8.582600195503421736e-02 7.852425197147340441e+00 +8.602150537634409289e-02 7.758816603252043365e+00 +8.621700879765395453e-02 7.666100518702847921e+00 +8.641251221896383006e-02 7.574272165508776133e+00 +8.660801564027370558e-02 7.483326724218894554e+00 +8.680351906158358111e-02 7.393259335499468676e+00 +8.699902248289345663e-02 7.304065101689674933e+00 +8.719452590420331828e-02 7.215739088335749507e+00 +8.739002932551319380e-02 7.128276325703683192e+00 +8.758553274682306933e-02 7.041671810270611509e+00 +8.778103616813294485e-02 6.955920506194835262e+00 +8.797653958944282038e-02 6.871017346764594080e+00 +8.817204301075268202e-02 6.786957235825734180e+00 +8.836754643206255755e-02 6.703735049188224160e+00 +8.856304985337243307e-02 6.621345636011754188e+00 +8.875855327468230860e-02 6.539783820170319117e+00 +8.895405669599218412e-02 6.459044401596092833e+00 +8.914956011730204577e-02 6.379122157602489906e+00 +8.934506353861192129e-02 6.300011844186658827e+00 +8.954056695992179682e-02 6.221708197311436095e+00 +8.973607038123167234e-02 6.144205934166875771e+00 +8.993157380254154787e-02 6.067499754411500135e+00 +9.012707722385142339e-02 5.991584341393344282e+00 +9.032258064516128504e-02 5.916454363350923451e+00 +9.051808406647116056e-02 5.842104474594229657e+00 +9.071358748778103609e-02 5.768529316665930828e+00 +9.090909090909091161e-02 5.695723519482839947e+00 +9.110459433040078714e-02 5.623681702457791864e+00 +9.130009775171064879e-02 5.552398475602076111e+00 +9.149560117302052431e-02 5.481868440608546500e+00 +9.169110459433039984e-02 5.412086191915566502e+00 +9.188660801564027536e-02 5.343046317751885432e+00 +9.208211143695015088e-02 5.274743401162584888e+00 +9.227761485826002641e-02 5.207172021016321928e+00 +9.247311827956988806e-02 5.140326752993882309e+00 +9.266862170087976358e-02 5.074202170558264946e+00 +9.286412512218963911e-02 5.008792845906514302e+00 +9.305962854349951463e-02 4.944093350903248307e+00 +9.325513196480939015e-02 4.880098257996256628e+00 +9.345063538611925180e-02 4.816802141114155056e+00 +9.364613880742912733e-02 4.754199576546335848e+00 +9.384164222873900285e-02 4.692285143805386305e+00 +9.403714565004887838e-02 4.631053426472028889e+00 +9.423264907135875390e-02 4.570499013022836898e+00 +9.442815249266861555e-02 4.510616497640891787e+00 +9.462365591397849107e-02 4.451400481009407883e+00 +9.481915933528836660e-02 4.392845571088706436e+00 +9.501466275659824212e-02 4.334946383876482123e+00 +9.521016617790811765e-02 4.277697544151645381e+00 +9.540566959921797929e-02 4.221093686201923489e+00 +9.560117302052785482e-02 4.165129454535255960e+00 +9.579667644183773034e-02 4.109799504575341267e+00 +9.599217986314760587e-02 4.055098503341310057e+00 +9.618768328445748139e-02 4.001021130111824142e+00 +9.638318670576735692e-02 3.947562077073693221e+00 +9.657869012707721856e-02 3.894716049955239789e+00 +9.677419354838709409e-02 3.842477768644502412e+00 +9.696969696969696961e-02 3.790841967792540679e+00 +9.716520039100684514e-02 3.739803397401917362e+00 +9.736070381231672066e-02 3.689356823400596230e+00 +9.755620723362658231e-02 3.639497028201398088e+00 +9.775171065493645783e-02 3.590218811247141595e+00 +9.794721407624633336e-02 3.541516989541766414e+00 +9.814271749755620888e-02 3.493386398167431128e+00 +9.833822091886608441e-02 3.445821890787916786e+00 +9.853372434017595993e-02 3.398818340138383576e+00 +9.872922776148582158e-02 3.352370638501760425e+00 +9.892473118279569710e-02 3.306473698171813247e+00 +9.912023460410557263e-02 3.261122451903188502e+00 +9.931573802541544815e-02 3.216311853348494232e+00 +9.951124144672532368e-02 3.172036877482646844e+00 +9.970674486803518533e-02 3.128292521014643057e+00 +9.990224828934506085e-02 3.085073802786900021e+00 +1.000977517106549364e-01 3.042375764162369212e+00 +1.002932551319648119e-01 3.000193469399554225e+00 +1.004887585532746874e-01 2.958522006015620764e+00 +1.006842619745845491e-01 2.917356485137755140e+00 +1.008797653958944246e-01 2.876692041842934700e+00 +1.010752688172043001e-01 2.836523835486298495e+00 +1.012707722385141756e-01 2.796847050018246073e+00 +1.014662756598240512e-01 2.757656894290426930e+00 +1.016617790811339128e-01 2.718948602350852006e+00 +1.018572825024437883e-01 2.680717433728188048e+00 +1.020527859237536639e-01 2.642958673705464001e+00 +1.022482893450635394e-01 2.605667633583337750e+00 +1.024437927663734149e-01 2.568839650933058660e+00 +1.026392961876832904e-01 2.532470089839316874e+00 +1.028347996089931521e-01 2.496554341133116139e+00 +1.030303030303030276e-01 2.461087822614806964e+00 +1.032258064516129031e-01 2.426065979267526540e+00 +1.034213098729227787e-01 2.391484283461059679e+00 +1.036168132942326542e-01 2.357338235146391181e+00 +1.038123167155425158e-01 2.323623362041062013e+00 +1.040078201368523914e-01 2.290335219805450961e+00 +1.042033235581622669e-01 2.257469392210205594e+00 +1.043988269794721424e-01 2.225021491294880249e+00 +1.045943304007820179e-01 2.192987157518020869e+00 +1.047898338220918935e-01 2.161362059898777499e+00 +1.049853372434017551e-01 2.130141896150217651e+00 +1.051808406647116306e-01 2.099322392804478632e+00 +1.053763440860215062e-01 2.068899305329934268e+00 +1.055718475073313817e-01 2.038868418240456393e+00 +1.057673509286412572e-01 2.009225545196978047e+00 +1.059628543499511188e-01 1.979966529101444550e+00 +1.061583577712609944e-01 1.951087242183343173e+00 +1.063538611925708699e-01 1.922583586078911999e+00 +1.065493646138807454e-01 1.894451491903178741e+00 +1.067448680351906209e-01 1.866686920314959197e+00 +1.069403714565004826e-01 1.839285861574970760e+00 +1.071358748778103581e-01 1.812244335597150924e+00 +1.073313782991202336e-01 1.785558391993384397e+00 +1.075268817204301092e-01 1.759224110111676564e+00 +1.077223851417399847e-01 1.733237599067992907e+00 +1.079178885630498463e-01 1.707594997771835654e+00 +1.081133919843597219e-01 1.682292474945689786e+00 +1.083088954056695974e-01 1.657326229138509799e+00 +1.085043988269794729e-01 1.632692488733305192e+00 +1.086999022482893484e-01 1.608387511948998316e+00 +1.088954056695992240e-01 1.584407586836649839e+00 +1.090909090909090856e-01 1.560749031270200149e+00 +1.092864125122189611e-01 1.537408192931800643e+00 +1.094819159335288367e-01 1.514381449291906767e+00 +1.096774193548387122e-01 1.491665207584200070e+00 +1.098729227761485877e-01 1.469255904775496724e+00 +1.100684261974584494e-01 1.447150007530724425e+00 +1.102639296187683249e-01 1.425344012173096031e+00 +1.104594330400782004e-01 1.403834444639593393e+00 +1.106549364613880759e-01 1.382617860431862633e+00 +1.108504398826979515e-01 1.361690844562635672e+00 +1.110459433040078270e-01 1.341050011497783245e+00 +1.112414467253176886e-01 1.320692005094101340e+00 +1.114369501466275642e-01 1.300613498532947165e+00 +1.116324535679374397e-01 1.280811194249825702e+00 +1.118279569892473152e-01 1.261281823860002316e+00 +1.120234604105571907e-01 1.242022148080300870e+00 +1.122189638318670524e-01 1.223028956647116194e+00 +1.124144672531769279e-01 1.204299068230791692e+00 +1.126099706744868034e-01 1.185829330346443111e+00 +1.128054740957966789e-01 1.167616619261316435e+00 +1.130009775171065545e-01 1.149657839898776457e+00 +1.131964809384164161e-01 1.131949925739036633e+00 +1.133919843597262916e-01 1.114489838716685943e+00 +1.135874877810361672e-01 1.097274569115156861e+00 +1.137829912023460427e-01 1.080301135458164419e+00 +1.139784946236559182e-01 1.063566584398246473e+00 +1.141739980449657799e-01 1.047067990602473131e+00 +1.143695014662756554e-01 1.030802456635415698e+00 +1.145650048875855309e-01 1.014767112839467966e+00 +1.147605083088954064e-01 9.989591172125769081e-01 +1.149560117302052820e-01 9.833756552835004605e-01 +1.151515151515151575e-01 9.680139399846400261e-01 +1.153470185728250191e-01 9.528712115225488333e-01 +1.155425219941348947e-01 9.379447372461793275e-01 +1.157380254154447702e-01 9.232318115129642955e-01 +1.159335288367546457e-01 9.087297555527880100e-01 +1.161290322580645212e-01 8.944359173299312182e-01 +1.163245356793743829e-01 8.803476714030625816e-01 +1.165200391006842584e-01 8.664624187833557256e-01 +1.167155425219941339e-01 8.527775867907835261e-01 +1.169110459433040095e-01 8.392906289086816685e-01 +1.171065493646138850e-01 8.259990246366327726e-01 +1.173020527859237605e-01 8.129002793417500206e-01 +1.174975562072336221e-01 7.999919241084197941e-01 +1.176930596285434977e-01 7.872715155865674941e-01 +1.178885630498533732e-01 7.747366358385239238e-01 +1.180840664711632487e-01 7.623848921845344240e-01 +1.182795698924731242e-01 7.502139170469912521e-01 +1.184750733137829859e-01 7.382213677934317264e-01 +1.186705767350928614e-01 7.264049265783824039e-01 +1.188660801564027369e-01 7.147623001840945900e-01 +1.190615835777126125e-01 7.032912198602288001e-01 +1.192570869990224880e-01 6.919894411625446828e-01 +1.194525904203323496e-01 6.808547437906670163e-01 +1.196480938416422252e-01 6.698849314249529785e-01 +1.198435972629521007e-01 6.590778315625441808e-01 +1.200391006842619762e-01 6.484312953526343293e-01 +1.202346041055718517e-01 6.379431974310169062e-01 +1.204301075268817134e-01 6.276114357539529509e-01 +1.206256109481915889e-01 6.174339314314126748e-01 +1.208211143695014644e-01 6.074086285597568580e-01 +1.210166177908113400e-01 5.975334940538580275e-01 +1.212121212121212155e-01 5.878065174787705516e-01 +1.214076246334310910e-01 5.782257108809377710e-01 +1.216031280547409527e-01 5.687891086190187684e-01 +1.217986314760508282e-01 5.594947671943676371e-01 +1.219941348973607037e-01 5.503407650812007779e-01 +1.221896383186705792e-01 5.413252025564911918e-01 +1.223851417399804548e-01 5.324462015296653750e-01 +1.225806451612903164e-01 5.237019053720798345e-01 +1.227761485826001919e-01 5.150904787463852497e-01 +1.229716520039100675e-01 5.066101074357630685e-01 +1.231671554252199430e-01 4.982589981731085360e-01 +1.233626588465298185e-01 4.900353784701653725e-01 +1.235581622678396940e-01 4.819374964466802691e-01 +1.237536656891495557e-01 4.739636206595826962e-01 +1.239491691104594312e-01 4.661120399322432606e-01 +1.241446725317693067e-01 4.583810631838420302e-01 +1.243401759530791822e-01 4.507690192588642009e-01 +1.245356793743890578e-01 4.432742567567756753e-01 +1.247311827956989194e-01 4.358951438619010355e-01 +1.249266862170087949e-01 4.286300681735232820e-01 +1.251221896383186705e-01 4.214774365362500275e-01 +1.253176930596285321e-01 4.144356748706805593e-01 +1.255131964809384215e-01 4.075032280043647259e-01 +1.257086999022482832e-01 4.006785595031389091e-01 +1.259042033235581726e-01 3.939601515028027801e-01 +1.260997067448680342e-01 3.873465045412234908e-01 +1.262952101661778959e-01 3.808361373908371039e-01 +1.264907135874877853e-01 3.744275868916140393e-01 +1.266862170087976469e-01 3.681194077844927581e-01 +1.268817204301075363e-01 3.619101725452992246e-01 +1.270772238514173980e-01 3.557984712191998855e-01 +1.272727272727272596e-01 3.497829112556767317e-01 +1.274682306940371490e-01 3.438621173440732370e-01 +1.276637341153470107e-01 3.380347312497232193e-01 +1.278592375366569001e-01 3.322994116506685636e-01 +1.280547409579667617e-01 3.266548339750139363e-01 +1.282502443792766234e-01 3.210996902389063878e-01 +1.284457478005865128e-01 3.156326888851810342e-01 +1.286412512218963744e-01 3.102525546226847508e-01 +1.288367546432062638e-01 3.049580282662794350e-01 +1.290322580645161255e-01 2.997478665775723528e-01 +1.292277614858260149e-01 2.946208421063565841e-01 +1.294232649071358765e-01 2.895757430328013693e-01 +1.296187683284457381e-01 2.846113730103944639e-01 +1.298142717497556275e-01 2.797265510096532681e-01 +1.300097751710654892e-01 2.749201111626280447e-01 +1.302052785923753786e-01 2.701909026081895648e-01 +1.304007820136852402e-01 2.655377893381418719e-01 +1.305962854349951019e-01 2.609596500441453415e-01 +1.307917888563049913e-01 2.564553779654831223e-01 +1.309872922776148529e-01 2.520238807376723456e-01 +1.311827956989247423e-01 2.476640802419270426e-01 +1.313782991202346040e-01 2.433749124554996923e-01 +1.315738025415444656e-01 2.391553273028910465e-01 +1.317693059628543550e-01 2.350042885079526300e-01 +1.319648093841642167e-01 2.309207734468894380e-01 +1.321603128054741061e-01 2.269037730021601640e-01 +1.323558162267839677e-01 2.229522914173018011e-01 +1.325513196480938294e-01 2.190653461526697043e-01 +1.327468230694037188e-01 2.152419677421109345e-01 +1.329423264907135804e-01 2.114811996505761571e-01 +1.331378299120234698e-01 2.077820981326721494e-01 +1.333333333333333315e-01 2.041437320921716814e-01 +1.335288367546431931e-01 2.005651829424716093e-01 +1.337243401759530825e-01 1.970455444680226098e-01 +1.339198435972629442e-01 1.935839226867233920e-01 +1.341153470185728336e-01 1.901794357132849944e-01 +1.343108504398826952e-01 1.868312136235813770e-01 +1.345063538611925846e-01 1.835383983199737057e-01 +1.347018572825024463e-01 1.803001433976281764e-01 +1.348973607038123079e-01 1.771156140118192723e-01 +1.350928641251221973e-01 1.739839867462306122e-01 +1.352883675464320590e-01 1.709044494822521132e-01 +1.354838709677419484e-01 1.678762012692736061e-01 +1.356793743890518100e-01 1.648984521959869776e-01 +1.358748778103616717e-01 1.619704232626874019e-01 +1.360703812316715611e-01 1.590913462545835155e-01 +1.362658846529814227e-01 1.562604636161186722e-01 +1.364613880742913121e-01 1.534770283262973933e-01 +1.366568914956011738e-01 1.507403037750268959e-01 +1.368523949169110354e-01 1.480495636404683124e-01 +1.370478983382209248e-01 1.454040917674020994e-01 +1.372434017595307865e-01 1.428031820466075796e-01 +1.374389051808406759e-01 1.402461382952517044e-01 +1.376344086021505375e-01 1.377322741382996651e-01 +1.378299120234603992e-01 1.352609128909274538e-01 +1.380254154447702886e-01 1.328313874419580209e-01 +1.382209188660801502e-01 1.304430401383052662e-01 +1.384164222873900396e-01 1.280952226704256403e-01 +1.386119257086999013e-01 1.257872959587881811e-01 +1.388074291300097629e-01 1.235186300413452232e-01 +1.390029325513196523e-01 1.212886039620165168e-01 +1.391984359726295140e-01 1.190966056601777817e-01 +1.393939393939394034e-01 1.169420318611510967e-01 +1.395894428152492650e-01 1.148242879677000977e-01 +1.397849462365591267e-01 1.127427879525234877e-01 +1.399804496578690161e-01 1.106969542517469290e-01 +1.401759530791788777e-01 1.086862176594099727e-01 +1.403714565004887671e-01 1.067100172229434596e-01 +1.405669599217986288e-01 1.047678001396404740e-01 +1.407624633431084904e-01 1.028590216541073049e-01 +1.409579667644183798e-01 1.009831449567056699e-01 +1.411534701857282414e-01 9.913964108296956235e-02 +1.413489736070381309e-01 9.732798881399952473e-02 +1.415444770283479925e-01 9.554767457783294726e-02 +1.417399804496578819e-01 9.379819235177931647e-02 +1.419354838709677435e-01 9.207904356572682580e-02 +1.421309872922776052e-01 9.038973700640536013e-02 +1.423264907135874946e-01 8.872978872261062799e-02 +1.425219941348973562e-01 8.709872193138151752e-02 +1.427174975562072456e-01 8.549606692512545791e-02 +1.429130009775171073e-01 8.392136097969073172e-02 +1.431085043988269689e-01 8.237414826337739748e-02 +1.433040078201368583e-01 8.085397974688557365e-02 +1.434995112414467200e-01 7.936041311419621269e-02 +1.436950146627566094e-01 7.789301267437388765e-02 +1.438905180840664710e-01 7.645134927429869665e-02 +1.440860215053763327e-01 7.503500021230768979e-02 +1.442815249266862221e-01 7.364354915275329871e-02 +1.444770283479960837e-01 7.227658604146648680e-02 +1.446725317693059731e-01 7.093370702212153933e-02 +1.448680351906158348e-01 6.961451435349877426e-02 +1.450635386119256964e-01 6.831861632763613912e-02 +1.452590420332355858e-01 6.704562718886886152e-02 +1.454545454545454475e-01 6.579516705374868768e-02 +1.456500488758553369e-01 6.456686183183717176e-02 +1.458455522971651985e-01 6.336034314737028217e-02 +1.460410557184750602e-01 6.217524826178477682e-02 +1.462365591397849496e-01 6.101121999710452937e-02 +1.464320625610948112e-01 5.986790666017870882e-02 +1.466275659824047006e-01 5.874496196776503310e-02 +1.468230694037145623e-01 5.764204497245818681e-02 +1.470185728250244517e-01 5.655881998944872063e-02 +1.472140762463343133e-01 5.549495652411465252e-02 +1.474095796676441750e-01 5.445012920043430099e-02 +1.476050830889540644e-01 5.342401769021817848e-02 +1.478005865102639260e-01 5.241630664315179849e-02 +1.479960899315738154e-01 5.142668561764346391e-02 +1.481915933528836771e-01 5.045484901247284520e-02 +1.483870967741935387e-01 4.950049599923167509e-02 +1.485826001955034281e-01 4.856333045555266681e-02 +1.487781036168132898e-01 4.764306089912031389e-02 +1.489736070381231792e-01 4.673940042245491172e-02 +1.491691104594330408e-01 4.585206662846797593e-02 +1.493646138807429025e-01 4.498078156677927375e-02 +1.495601173020527919e-01 4.412527167079027118e-02 +1.497556207233626535e-01 4.328526769551025583e-02 +1.499511241446725429e-01 4.246050465612425523e-02 +1.501466275659824046e-01 4.165072176730149484e-02 +1.503421309872922662e-01 4.085566238323422306e-02 +1.505376344086021556e-01 4.007507393840321203e-02 +1.507331378299120173e-01 3.930870788906364044e-02 +1.509286412512219067e-01 3.855631965544249057e-02 +1.511241446725317683e-01 3.781766856464556514e-02 +1.513196480938416300e-01 3.709251779426335494e-02 +1.515151515151515194e-01 3.638063431667360598e-02 +1.517106549364613810e-01 3.568178884403177403e-02 +1.519061583577712704e-01 3.499575577394325315e-02 +1.521016617790811321e-01 3.432231313581370069e-02 +1.522971652003909937e-01 3.366124253786770271e-02 +1.524926686217008831e-01 3.301232911483210214e-02 +1.526881720430107447e-01 3.237536147627801536e-02 +1.528836754643206342e-01 3.175013165561281492e-02 +1.530791788856304958e-01 3.113643505971901496e-02 +1.532746823069403574e-01 3.053407041923193385e-02 +1.534701857282502468e-01 2.994283973945079461e-02 +1.536656891495601085e-01 2.936254825187733022e-02 +1.538611925708699979e-01 2.879300436637504193e-02 +1.540566959921798595e-01 2.823401962394421830e-02 +1.542521994134897489e-01 2.768540865010537047e-02 +1.544477028347996106e-01 2.714698910888630259e-02 +1.546432062561094722e-01 2.661858165740593057e-02 +1.548387096774193616e-01 2.610000990104919746e-02 +1.550342130987292233e-01 2.559110034922782925e-02 +1.552297165200391127e-01 2.509168237171895827e-02 +1.554252199413489743e-01 2.460158815557902945e-02 +1.556207233626588360e-01 2.412065266262285526e-02 +1.558162267839687254e-01 2.364871358746660837e-02 +1.560117302052785870e-01 2.318561131612539850e-02 +1.562072336265884764e-01 2.273118888516046515e-02 +1.564027370478983381e-01 2.228529194137207625e-02 +1.565982404692081997e-01 2.184776870202951443e-02 +1.567937438905180891e-01 2.141846991563458799e-02 +1.569892473118279508e-01 2.099724882321257410e-02 +1.571847507331378402e-01 2.058396112012361376e-02 +1.573802541544477018e-01 2.017846491839129022e-02 +1.575757575757575635e-01 1.978062070954027946e-02 +1.577712609970674529e-01 1.939029132793965507e-02 +1.579667644183773145e-01 1.900734191464503731e-02 +1.581622678396872039e-01 1.863163988173431942e-02 +1.583577712609970656e-01 1.826305487713219752e-02 +1.585532746823069272e-01 1.790145874991674879e-02 +1.587487781036168166e-01 1.754672551610444303e-02 +1.589442815249266783e-01 1.719873132490664855e-02 +1.591397849462365677e-01 1.685735442545298335e-02 +1.593352883675464293e-01 1.652247513397651218e-02 +1.595307917888563187e-01 1.619397580145483240e-02 +1.597262952101661804e-01 1.587174078170267705e-02 +1.599217986314760420e-01 1.555565639990995862e-02 +1.601173020527859314e-01 1.524561092162090778e-02 +1.603128054740957931e-01 1.494149452214881511e-02 +1.605083088954056825e-01 1.464319925642112476e-02 +1.607038123167155441e-01 1.435061902925066635e-02 +1.608993157380254058e-01 1.406364956602670566e-02 +1.610948191593352952e-01 1.378218838382224733e-02 +1.612903225806451568e-01 1.350613476291196921e-02 +1.614858260019550462e-01 1.323538971869554597e-02 +1.616813294232649079e-01 1.296985597402280400e-02 +1.618768328445747695e-01 1.270943793191414359e-02 +1.620723362658846589e-01 1.245404164867321660e-02 +1.622678396871945206e-01 1.220357480738592897e-02 +1.624633431085044100e-01 1.195794669180142052e-02 +1.626588465298142716e-01 1.171706816059092660e-02 +1.628543499511241333e-01 1.148085162197879337e-02 +1.630498533724340227e-01 1.124921100874213403e-02 +1.632453567937438843e-01 1.102206175357436577e-02 +1.634408602150537737e-01 1.079932076480732278e-02 +1.636363636363636354e-01 1.058090640248883149e-02 +1.638318670576734970e-01 1.036673845481013434e-02 +1.640273704789833864e-01 1.015673811487957830e-02 +1.642228739002932481e-01 9.950827957838026538e-03 +1.644183773216031375e-01 9.748931918311113526e-03 +1.646138807429129991e-01 9.550975268195390985e-03 +1.648093841642228607e-01 9.356884594772711325e-03 +1.650048875855327501e-01 9.166587779149550780e-03 +1.652003910068426118e-01 8.980013975017112418e-03 +1.653958944281525012e-01 8.797093587727457600e-03 +1.655913978494623628e-01 8.617758253682532982e-03 +1.657869012707722245e-01 8.441940820031234097e-03 +1.659824046920821139e-01 8.269575324671006589e-03 +1.661779081133919755e-01 8.100596976550092365e-03 +1.663734115347018649e-01 7.934942136265929480e-03 +1.665689149560117266e-01 7.772548296956710741e-03 +1.667644183773216160e-01 7.613354065481395608e-03 +1.669599217986314776e-01 7.457299143885143949e-03 +1.671554252199413393e-01 7.304324311145792351e-03 +1.673509286412512287e-01 7.154371405198061383e-03 +1.675464320625610903e-01 7.007383305231817093e-03 +1.677419354838709797e-01 6.863303914260277146e-03 +1.679374389051808414e-01 6.722078141955307139e-03 +1.681329423264907030e-01 6.583651887745492828e-03 +1.683284457478005924e-01 6.447972024173996737e-03 +1.685239491691104541e-01 6.314986380512526733e-03 +1.687194525904203435e-01 6.184643726627766722e-03 +1.689149560117302051e-01 6.056893757097274456e-03 +1.691104594330400668e-01 5.931687075571018784e-03 +1.693059628543499562e-01 5.808975179375569162e-03 +1.695014662756598178e-01 5.688710444357396832e-03 +1.696969696969697072e-01 5.570846109962083667e-03 +1.698924731182795689e-01 5.455336264546284918e-03 +1.700879765395894305e-01 5.342135830919106550e-03 +1.702834799608993199e-01 5.231200552109765110e-03 +1.704789833822091816e-01 5.122486977358613192e-03 +1.706744868035190710e-01 5.015952448327954359e-03 +1.708699902248289326e-01 4.911555085530186840e-03 +1.710654936461387943e-01 4.809253774969685091e-03 +1.712609970674486837e-01 4.709008154995847524e-03 +1.714565004887585453e-01 4.610778603364166194e-03 +1.716520039100684347e-01 4.514526224502287896e-03 +1.718475073313782964e-01 4.420212836978511424e-03 +1.720430107526881858e-01 4.327800961169429340e-03 +1.722385141739980474e-01 4.237253807124323826e-03 +1.724340175953079091e-01 4.148535262623115165e-03 +1.726295210166177985e-01 4.061609881425430786e-03 +1.728250244379276601e-01 3.976442871707927366e-03 +1.730205278592375495e-01 3.893000084687112550e-03 +1.732160312805474112e-01 3.811248003425108440e-03 +1.734115347018572728e-01 3.731153731815726581e-03 +1.736070381231671622e-01 3.652684983748146104e-03 +1.738025415444770239e-01 3.575810072445771617e-03 +1.739980449657869133e-01 3.500497899977572051e-03 +1.741935483870967749e-01 3.426717946939563785e-03 +1.743890518084066366e-01 3.354440262303816887e-03 +1.745845552297165260e-01 3.283635453432621771e-03 +1.747800586510263876e-01 3.214274676255414551e-03 +1.749755620723362770e-01 3.146329625605951818e-03 +1.751710654936461387e-01 3.079772525717568588e-03 +1.753665689149560003e-01 3.014576120873958560e-03 +1.755620723362658897e-01 2.950713666213457004e-03 +1.757575757575757514e-01 2.888158918684297517e-03 +1.759530791788856408e-01 2.826886128148732320e-03 +1.761485826001955024e-01 2.766870028633814337e-03 +1.763440860215053640e-01 2.708085829726579810e-03 +1.765395894428152535e-01 2.650509208111554143e-03 +1.767350928641251151e-01 2.594116299248401709e-03 +1.769305962854350045e-01 2.538883689187585498e-03 +1.771260997067448661e-01 2.484788406522110606e-03 +1.773216031280547278e-01 2.431807914473069557e-03 +1.775171065493646172e-01 2.379920103107175354e-03 +1.777126099706744788e-01 2.329103281684224026e-03 +1.779081133919843682e-01 2.279336171132396310e-03 +1.781036168132942299e-01 2.230597896649684150e-03 +1.782991202346040915e-01 2.182867980429290932e-03 +1.784946236559139809e-01 2.136126334507266415e-03 +1.786901270772238426e-01 2.090353253730478124e-03 +1.788856304985337320e-01 2.045529408842990202e-03 +1.790811339198435936e-01 2.001635839689137539e-03 +1.792766373411534830e-01 1.958653948531468517e-03 +1.794721407624633447e-01 1.916565493481768101e-03 +1.796676441837732063e-01 1.875352582043366247e-03 +1.798631476050830957e-01 1.834997664763146326e-03 +1.800586510263929574e-01 1.795483528991424077e-03 +1.802541544477028468e-01 1.756793292748048876e-03 +1.804496578690127084e-01 1.718910398693143313e-03 +1.806451612903225701e-01 1.681818608200728350e-03 +1.808406647116324595e-01 1.645501995533730057e-03 +1.810361681329423211e-01 1.609944942118763300e-03 +1.812316715542522105e-01 1.575132130919016868e-03 +1.814271749755620722e-01 1.541048540903900387e-03 +1.816226783968719338e-01 1.507679441613686859e-03 +1.818181818181818232e-01 1.475010387817881881e-03 +1.820136852394916849e-01 1.443027214265683042e-03 +1.822091886608015743e-01 1.411716030527069513e-03 +1.824046920821114359e-01 1.381063215923258956e-03 +1.826001955034212976e-01 1.351055414544837571e-03 +1.827956989247311870e-01 1.321679530356402324e-03 +1.829912023460410486e-01 1.292922722386218070e-03 +1.831867057673509380e-01 1.264772399999534091e-03 +1.833822091886607997e-01 1.237216218254269876e-03 +1.835777126099706613e-01 1.210242073337685796e-03 +1.837732160312805507e-01 1.183838098082783639e-03 +1.839687194525904124e-01 1.157992657563146344e-03 +1.841642228739003018e-01 1.132694344764899634e-03 +1.843597262952101634e-01 1.107931976334637202e-03 +1.845552297165200528e-01 1.083694588401984318e-03 +1.847507331378299145e-01 1.059971432475675544e-03 +1.849462365591397761e-01 1.036751971411873936e-03 +1.851417399804496655e-01 1.014025875453598716e-03 +1.853372434017595272e-01 9.917830183401312675e-04 +1.855327468230694166e-01 9.700134734851567197e-04 +1.857282502443792782e-01 9.487075102226249146e-04 +1.859237536656891399e-01 9.278555901191413774e-04 +1.861192570869990293e-01 9.074483633518498453e-04 +1.863147605083088909e-01 8.874766651506939621e-04 +1.865102639296187803e-01 8.679315123039972471e-04 +1.867057673509286420e-01 8.488040997263550901e-04 +1.869012707722385036e-01 8.300857970877438367e-04 +1.870967741935483930e-01 8.117681455028926503e-04 +1.872922776148582547e-01 7.938428542798971546e-04 +1.874877810361681441e-01 7.763017977270558192e-04 +1.876832844574780057e-01 7.591370120170336418e-04 +1.878787878787878673e-01 7.423406921073179331e-04 +1.880742913000977568e-01 7.259051887160668584e-04 +1.882697947214076184e-01 7.098230053524574607e-04 +1.884652981427175078e-01 6.940867954005146669e-04 +1.886608015640273694e-01 6.786893592556551792e-04 +1.888563049853372311e-01 6.636236415129450998e-04 +1.890518084066471205e-01 6.488827282062806885e-04 +1.892473118279569821e-01 6.344598440975921481e-04 +1.894428152492668715e-01 6.203483500152284476e-04 +1.896383186705767332e-01 6.065417402407168599e-04 +1.898338220918865948e-01 5.930336399430356006e-04 +1.900293255131964842e-01 5.798178026596308675e-04 +1.902248289345063459e-01 5.668881078233792238e-04 +1.904203323558162353e-01 5.542385583346667779e-04 +1.906158357771260969e-01 5.418632781778979926e-04 +1.908113391984359586e-01 5.297565100815863860e-04 +1.910068426197458480e-01 5.179126132213483042e-04 +1.912023460410557096e-01 5.063260609650500422e-04 +1.913978494623655990e-01 4.949914386593399357e-04 +1.915933528836754607e-01 4.839034414569274288e-04 +1.917888563049853501e-01 4.730568721838397639e-04 +1.919843597262952117e-01 4.624466392460265928e-04 +1.921798631476050734e-01 4.520677545745811028e-04 +1.923753665689149628e-01 4.419153316089413424e-04 +1.925708699902248244e-01 4.319845833174149356e-04 +1.927663734115347138e-01 4.222708202543521056e-04 +1.929618768328445755e-01 4.127694486533773667e-04 +1.931573802541544371e-01 4.034759685559907087e-04 +1.933528836754643265e-01 3.943859719749899409e-04 +1.935483870967741882e-01 3.854951410920550532e-04 +1.937438905180840776e-01 3.767992464889166615e-04 +1.939393939393939392e-01 3.682941454115319039e-04 +1.941348973607038009e-01 3.599757800666717475e-04 +1.943304007820136903e-01 3.518401759503532651e-04 +1.945259042033235519e-01 3.438834402075767850e-04 +1.947214076246334413e-01 3.361017600227882477e-04 +1.949169110459433030e-01 3.284914010405503063e-04 +1.951124144672531646e-01 3.210487058158699902e-04 +1.953079178885630540e-01 3.137700922936780164e-04 +1.955034213098729157e-01 3.066520523169303874e-04 +1.956989247311828051e-01 2.996911501628208045e-04 +1.958944281524926667e-01 2.928840211066288516e-04 +1.960899315738025284e-01 2.862273700126825578e-04 +1.962854349951124178e-01 2.797179699519773710e-04 +1.964809384164222794e-01 2.733526608459677185e-04 +1.966764418377321688e-01 2.671283481360512855e-04 +1.968719452590420305e-01 2.610420014783179144e-04 +1.970674486803519199e-01 2.550906534630776202e-04 +1.972629521016617815e-01 2.492713983587504113e-04 +1.974584555229716432e-01 2.435813908796608440e-04 +1.976539589442815326e-01 2.380178449773213023e-04 +1.978494623655913942e-01 2.325780326547776397e-04 +1.980449657869012836e-01 2.272592828036012569e-04 +1.982404692082111453e-01 2.220589800631173256e-04 +1.984359726295210069e-01 2.169745637014720971e-04 +1.986314760508308963e-01 2.120035265181391426e-04 +1.988269794721407580e-01 2.071434137674879291e-04 +1.990224828934506474e-01 2.023918221030098885e-04 +1.992179863147605090e-01 1.977463985418592641e-04 +1.994134897360703707e-01 1.932048394493057373e-04 +1.996089931573802601e-01 1.887648895427628383e-04 +1.998044965786901217e-01 1.844243409150234060e-04 +2.000000000000000111e-01 1.801810320763509764e-04 diff --git a/output/log.txt b/output/log.txt new file mode 100644 index 0000000..c0d9daf --- /dev/null +++ b/output/log.txt @@ -0,0 +1,113 @@ +MPI task 0, OMP thread count starts at 0 + MPIThreadsOK = 1 + +|-------------------------------------------------| +| CoLoRe | +|-------------------------------------------------| + +The cosmological model is: + O_M=0.300 O_L=0.700 O_K=0.000 + O_B=0.300 w=-1.000 h=0.700 + Flat universe, standard cosmological constant + + Time of equality: a_eq=0.75416 + Particle horizon: chi_H(0)=9.908E+03 Mpc/h + Present growth factor: D_0=0.779 + +Reading P_k from file: output/pk.txt + Original sigma8=0.799990 + Sigma_Gauss should be 0.875326 +Node 0 will allocate 0.597 GB [0.190 GB (Gaussian), 0.302 GB (1LPT), 0.102 GB (srcs), 0.002 GB (imap), 0.375 MB (kappa), 0.375 MB (isw), 0.375 MB (custom)] + +Run parameters: + 0.000 < z < 0.150 + 0.300 < r/(Mpc/h) < 434.105 + L_box = 874.993 Mpc/h, N_grid = 256 + Scales resolved: 7.181E-03 < k < 9.156E-01 h/Mpc + Fourier-space resolution: dk = 7.181E-03 h/Mpc + Real-space resolution: dx = 3.418E+00 Mpc/h + Density field pre-smoothed on scales: x_s = 1.000E+00 Mpc/h + 1 galaxy populations + Some populations will include LoS skewers + 1 intensity mapping species + 1 custom maps + 1 lensing source planes + 1 ISW source planes + Will include lensing in source catalog + +Seed : 1000 +*** Creating Gaussian density field +Creating Fourier-space density and Newtonian potential +> Relative time ellapsed 2257.6 ms +Transforming density and Newtonian potential +> Relative time ellapsed 480.6 ms +Normalizing density and Newtonian potential +> Relative time ellapsed 19.6 ms + =-2.325E-10, =8.941E-01 + +*** Writing density field (native format) +> Relative time ellapsed 241.5 ms + +*** Creating physical matter density + 1LPT + - Transforming density field + - Computing displacement field + - Transform displacement field + - Computing particle positions + 1st-order displacement : [1.738749E-10,4.895681E-10,4.054534E-13] 2.882436E+01 + - Undoing padding + - Interpolating positions into density field + - Normalizing density field + Total density : -3.546011E-04 +> Relative time ellapsed 2258.7 ms + +*** Writing density field (native format) +> Relative time ellapsed 189.3 ms + +*** Computing normalization of density field +z=0.000E+00, =1.004E+00, =1.004E+00, =1.004E+00, 00000000000 +z=3.771E-02, =1.004E+00, =1.004E+00, =1.004E+00, 00000349448 +z=8.083E-02, =1.026E+00, =1.026E+00, =1.026E+00, 00002350328 +z=1.291E-01, =1.121E+00, =1.121E+00, =1.121E+00, 00006084072 +z=1.512E-01, =1.121E+00, =1.121E+00, =1.121E+00, 00006469528 +> Relative time ellapsed 1501.3 ms + +*** Getting point sources + 0-th galaxy population + Poisson-sampling + There will be 97421 objects in total + Assigning coordinates +> Relative time ellapsed 892.7 ms + +*** Filling up intensity maps + 0-th intensity mapping species +> Relative time ellapsed 6312.8 ms + +*** Re-distributing sources across nodes +> Relative time ellapsed 3.0 ms + +*** Getting LOS information +> Relative time ellapsed 1958.9 ms + +*** Writing kappa source maps +> Relative time ellapsed 13.1 ms + +*** Writing isw source maps +> Relative time ellapsed 5.1 ms + +*** Writing source catalogs + 0-th population (FITS) +> Relative time ellapsed 421.3 ms + +*** Writing intensity maps + 0-th species +> Relative time ellapsed 20.4 ms + +*** Writing custom maps + 0-th species +> Relative time ellapsed 5.2 ms + + +|-------------------------------------------------| + +> Total time ellapsed 16702.8 ms diff --git a/output/nuTable.txt b/output/nuTable.txt new file mode 100644 index 0000000..f6c8da2 --- /dev/null +++ b/output/nuTable.txt @@ -0,0 +1,5 @@ +1.245614035087719230e+03 1.269568151147098433e+03 +1.269568151147098433e+03 1.293522267206477636e+03 +1.293522267206477636e+03 1.317476383265856839e+03 +1.317476383265856839e+03 1.341430499325236042e+03 +1.341430499325236042e+03 1.365384615384615245e+03 diff --git a/output/params.cfg b/output/params.cfg new file mode 100644 index 0000000..2810578 --- /dev/null +++ b/output/params.cfg @@ -0,0 +1,69 @@ +global = +{ + prefix_out = "output/colore"; + output_format = "FITS"; + output_density = True; + pk_filename = "output/pk.txt"; + z_min = 0.0001; + z_max = 0.15; + seed = 1000; + write_pred = False; + just_write_pred = False; +}; +field_par = +{ + r_smooth = 1.0; + smooth_potential = True; + n_grid = 256; + dens_type = 1; + lpt_buffer_fraction = 0.6; + lpt_interp_type = 1; + output_lpt = 0; +}; +cosmo_par = +{ + omega_M = 0.3; + omega_B = 0.3; + omega_L = 0.7; + h = 0.7; + w = -1.0; + ns = 0.96; + sigma_8 = 0.8; +}; +custom1 = +{ + kz_filename = "output/wz.txt"; + bias_filename = "output/bias.txt"; + nside = 64; +}; +srcs1 = +{ + nz_filename = "output/dndz.txt"; + bias_filename = "output/bias.txt"; + include_lensing = True; + store_skewers = True; +}; +imap1 = +{ + tbak_filename = "output/tz.txt"; + bias_filename = "output/bias.txt"; + freq_list = "output/nuTable.txt"; + freq_rest = 1420.0; + nside = 64; +}; +kappa = +{ + z_out = + [ + 0.1 + ]; + nside = 64; +}; +isw = +{ + z_out = + [ + 0.1 + ]; + nside = 64; +}; diff --git a/output/pk.txt b/output/pk.txt new file mode 100644 index 0000000..0aaddb3 --- /dev/null +++ b/output/pk.txt @@ -0,0 +1,1024 @@ +1.000000000000000048e-04 1.224779862908184805e+04 +1.013596500938556902e-04 1.240755803744013610e+04 +1.027377866714885868e-04 1.256939960277221508e+04 +1.041346610843927429e-04 1.273335039240265360e+04 +1.055505281015629859e-04 1.289943782274179284e+04 +1.069856459559610632e-04 1.306768966367887333e+04 +1.084402763916133980e-04 1.323813404302439994e+04 +1.099146847113493375e-04 1.341079945100362420e+04 +1.114091398251883914e-04 1.358571474480309553e+04 +1.129239142993853772e-04 1.376290915316801329e+04 +1.144592844061424861e-04 1.394241228105265327e+04 +1.160155301739971450e-04 1.412425411432398687e+04 +1.175929354388950676e-04 1.430846502451810375e+04 +1.191917878959576692e-04 1.449507577365039651e+04 +1.208123791519533313e-04 1.468411751908048245e+04 +1.224550047784821541e-04 1.487562181843064718e+04 +1.241199643658837614e-04 1.506962063455959469e+04 +1.258075615778781635e-04 1.526614634059159835e+04 +1.275181042069493248e-04 1.546523172500068904e+04 +1.292519042304821162e-04 1.566690999675083367e+04 +1.310092778676621127e-04 1.587121479049271693e+04 +1.327905456371494570e-04 1.607818017181601863e+04 +1.345960324155364384e-04 1.628784064256015336e+04 +1.364260674966003071e-04 1.650023114618050386e+04 +1.382809846513614611e-04 1.671538707317191802e+04 +1.401611221889582535e-04 1.693334426655455900e+04 +1.420668230183496164e-04 1.715413902740530102e+04 +1.439984347108563953e-04 1.737780812046515712e+04 +1.459563095635532681e-04 1.760438877979251629e+04 +1.479408046635224147e-04 1.783391871447159792e+04 +1.499522819529808639e-04 1.806643611439843153e+04 +1.519911082952933080e-04 1.830197965609974199e+04 +1.540576555418825830e-04 1.854058850863715634e+04 +1.561523006000496586e-04 1.878230233954913638e+04 +1.582754255017160402e-04 1.902716132086702419e+04 +1.604274174731006183e-04 1.927520613517789388e+04 +1.626086690053438655e-04 1.952647798176331344e+04 +1.648195779260925296e-04 1.978101858277706924e+04 +1.670605474720571800e-04 2.003887018950303536e+04 +1.693319863625568399e-04 2.030007558865543615e+04 +1.716343088740630352e-04 2.056467810875038776e+04 +1.739679349157577902e-04 2.083272162652968109e+04 +1.763332901061186869e-04 2.110425057344727247e+04 +1.787308058505453559e-04 2.137930994221575020e+04 +1.811609194200413287e-04 2.165794529340504960e+04 +1.836240740309657540e-04 2.194020276211255987e+04 +1.861207189258693980e-04 2.222612906467496941e+04 +1.886513094554298617e-04 2.251577150545539916e+04 +1.912163071615006007e-04 2.280917798367602518e+04 +1.938161798612895201e-04 2.310639700031169923e+04 +1.964514017326810501e-04 2.340747766504525498e+04 +1.991224534007202704e-04 2.371246970327148665e+04 +2.018298220252709267e-04 2.402142346316345356e+04 +2.045740013898662867e-04 2.433438992279306331e+04 +2.073554919917679326e-04 2.465142069730167350e+04 +2.101748011332489163e-04 2.497256804613379427e+04 +2.130324430141181363e-04 2.529788488031558518e+04 +2.159289388255026599e-04 2.562742476979190178e+04 +2.188648168449052031e-04 2.596124195081172365e+04 +2.218406125325540334e-04 2.629939133336703162e+04 +2.248568686290629412e-04 2.664192850868049572e+04 +2.279141352544189524e-04 2.698890975674151559e+04 +2.310129700083160510e-04 2.734039205389092967e+04 +2.341539380718529089e-04 2.769643308045281447e+04 +2.373376123106136517e-04 2.805709122840964119e+04 +2.405645733791497655e-04 2.842242560912394765e+04 +2.438354098268829054e-04 2.879249606110051536e+04 +2.471507182054474968e-04 2.916736315779096549e+04 +2.505111031774928903e-04 2.954708821543536033e+04 +2.539171776269646117e-04 2.993173330095122219e+04 +2.573695627708853079e-04 3.032136123983084690e+04 +2.608688882726556630e-04 3.071603562412288011e+04 +2.644157923568950979e-04 3.111582082038282169e+04 +2.680109219258448600e-04 3.152078197771101259e+04 +2.716549326773531263e-04 3.193098503578265081e+04 +2.753484892244643456e-04 3.234649673291155341e+04 +2.790922652166349938e-04 3.276738461414732228e+04 +2.828869434625969352e-04 3.319371703937663551e+04 +2.867332160548916498e-04 3.362556319145486486e+04 +2.906317844960973860e-04 3.406299308434910927e+04 +2.945833598267730410e-04 3.450607757128594676e+04 +2.985886627551409913e-04 3.495488835291838768e+04 +3.026484237885337047e-04 3.540949798549422849e+04 +3.067633833666272790e-04 3.586997988902701036e+04 +3.109342919964865211e-04 3.633640835545555456e+04 +3.151619103894462296e-04 3.680885855682041438e+04 +3.194470095998537280e-04 3.728740655341131060e+04 +3.237903711656973135e-04 3.777212930190723273e+04 +3.281927872511474008e-04 3.826310466350521165e+04 +3.326550607910352432e-04 3.876041141202073049e+04 +3.371780056372962291e-04 3.926412924196207314e+04 +3.417624467074044771e-04 3.977433877658176789e+04 +3.464092201348251869e-04 4.029112157587833644e+04 +3.511191734215130954e-04 4.081456014456936828e+04 +3.558931655924840363e-04 4.134473794001537317e+04 +3.607320673524882257e-04 4.188173938008557889e+04 +3.656367612448138964e-04 4.242564985097148019e+04 +3.706081418122499039e-04 4.297655571493765456e+04 +3.756471157602369573e-04 4.353454431799412851e+04 +3.807546021222371819e-04 4.409970399750753131e+04 +3.859315324273520460e-04 4.467212408971162949e+04 +3.911788508702192268e-04 4.525189493713662523e+04 +3.964975144832197482e-04 4.583910789594556263e+04 +4.018884933110263447e-04 4.643385534315295081e+04 +4.073527705875249275e-04 4.703623068374218565e+04 +4.128913429151419485e-04 4.764632835765709024e+04 +4.185052204466096484e-04 4.826424384666143305e+04 +4.241954270692029592e-04 4.889007368107005459e+04 +4.299630005914809147e-04 4.952391544632251316e+04 +4.358089929325676955e-04 5.016586778940600198e+04 +4.417344703140068654e-04 5.081603042511524836e+04 +4.477405134542241988e-04 5.147450414212967735e+04 +4.538282177656344967e-04 5.214139080891384947e+04 +4.599986935544285514e-04 5.281679337941291305e+04 +4.662530662230762540e-04 5.350081589854813501e+04 +4.725924764755833583e-04 5.419356350749062403e+04 +4.790180805255385486e-04 5.489514244870311813e+04 +4.855310503069897314e-04 5.560566007075414382e+04 +4.921325736881877180e-04 5.632522483284393093e+04 +4.988238546882336165e-04 5.705394630910926935e+04 +5.056061136966766636e-04 5.779193519260412722e+04 +5.124805876960936667e-04 5.853930329904505925e+04 +5.194485304876958085e-04 5.929616357015363610e+04 +5.265112129200036914e-04 6.006263007679218572e+04 +5.336699231206312212e-04 6.083881802167004935e+04 +5.409259667312205089e-04 6.162484374175332778e+04 +5.482806671455713737e-04 6.242082471028356667e+04 +5.557353657510087077e-04 6.322687953840671253e+04 +5.632914221730315031e-04 6.404312797643471276e+04 +5.709502145232882124e-04 6.486969091464855592e+04 +5.787131396509233262e-04 6.570669038370894850e+04 +5.865816133973423326e-04 6.655424955457694887e+04 +5.945570708544394012e-04 6.741249273798069044e+04 +6.026409666263374482e-04 6.828154538341448642e+04 +6.108347750946852527e-04 6.916153407757880632e+04 +6.191399906875633390e-04 7.005258654234521964e+04 +6.275581281520449225e-04 7.095483163213651278e+04 +6.360907228304631990e-04 7.186839933075229055e+04 +6.447393309404348544e-04 7.279342074760132527e+04 +6.535055298586910739e-04 7.373002811332093552e+04 +6.623909184087667943e-04 7.467835477476169763e+04 +6.713971171526031661e-04 7.563853518931083090e+04 +6.805257686861128840e-04 7.661070491853977728e+04 +6.897785379387658469e-04 7.759500062114429602e+04 +6.991571124772466474e-04 7.859156004515163659e+04 +7.086632028132422217e-04 7.960052201937595964e+04 +7.182985427154132182e-04 8.062202644409627828e+04 +7.280648895256073075e-04 8.165621428092131100e+04 +7.379640244793725466e-04 8.270322754182726203e+04 +7.479977530308276092e-04 8.376320927733121789e+04 +7.581679051819495982e-04 8.483630356378170836e+04 +7.684763358163397215e-04 8.592265548972660326e+04 +7.789249250375253775e-04 8.702241114134491363e+04 +7.895155785118633789e-04 8.813571758689738635e+04 +8.002502278161052448e-04 8.926272286017220176e+04 +8.111308307896872294e-04 9.040357594291101850e+04 +8.221593718918116574e-04 9.155842674615027499e+04 +8.333378625633820150e-04 9.272742609047902806e+04 +8.446683415938599938e-04 9.391072568516821775e+04 +8.561528754931101897e-04 9.510847810613339243e+04 +8.677935588683004372e-04 9.632083677271136548e+04 +8.795925148059268416e-04 9.754795592320860305e+04 +8.915518952590332233e-04 9.878999058918694209e+04 +9.036738814396949072e-04 1.000470965684571711e+05 +9.159606842168390621e-04 1.013194303967410669e+05 +9.284145445194744509e-04 1.026071493179954414e+05 +9.410377337454033401e-04 1.039104112532644067e+05 +9.538325541754901632e-04 1.052293747681860259e+05 +9.668013393935633720e-04 1.065641990390014253e+05 +9.799464547120260473e-04 1.079150438169996632e+05 +9.932702976032535460e-04 1.092820693914907606e+05 +1.006775298136856683e-03 1.106654365511605283e+05 +1.020463919422890352e-03 1.120653065438212216e+05 +1.034338658061087273e-03 1.134818410344864824e+05 +1.048402044596200358e-03 1.149152020617703529e+05 +1.062656643979537595e-03 1.163655519925372355e+05 +1.077105056036769051e-03 1.178330534748174105e+05 +1.091749915942097273e-03 1.193178693888216512e+05 +1.106593894698873481e-03 1.208201627962576895e+05 +1.121639699626748041e-03 1.223400968875825201e+05 +1.136890074855445836e-03 1.238778349274854700e+05 +1.152347801825253726e-03 1.254335401982986805e+05 +1.168015699794314839e-03 1.270073759414537926e+05 +1.183896626352817305e-03 1.285995052968970267e+05 +1.199993477944177834e-03 1.302100912403866387e+05 +1.216309190393307944e-03 1.318392965187121881e+05 +1.232846739442065853e-03 1.334872835827462841e+05 +1.249609141291986841e-03 1.351542145182583190e+05 +1.266599453154392462e-03 1.368402509745703719e+05 +1.283820773807981853e-03 1.385455540908582625e+05 +1.301276244164000949e-03 1.402702844202141860e+05 +1.318969047839098482e-03 1.420146018513051677e+05 +1.336902411735970244e-03 1.437786655276990205e+05 +1.355079606631897195e-03 1.455626337647220062e+05 +1.373503947775287165e-03 1.473666639639187488e+05 +1.392178795490325513e-03 1.491909125249631761e+05 +1.411107555789848592e-03 1.510355347550969163e+05 +1.430293680996549965e-03 1.529006847759798111e+05 +1.449740670372631464e-03 1.547865154279589187e+05 +1.469452070758017065e-03 1.566931781717316480e+05 +1.489431477217242764e-03 1.586208229873323580e+05 +1.509682533695143238e-03 1.605695982704501366e+05 +1.530208933681452164e-03 1.625396507260382641e+05 +1.551014420884440229e-03 1.645311252591764787e+05 +1.572102789913710748e-03 1.665441648631675635e+05 +1.593477886972280389e-03 1.685789105048497731e+05 +1.615143610558068604e-03 1.706355010070797871e+05 +1.637103912174925433e-03 1.727140729283884575e+05 +1.659362797053326932e-03 1.748147604397643881e+05 +1.681924324880868958e-03 1.769376951985624910e+05 +1.704792610542693338e-03 1.790830062195027422e+05 +1.727971824871981721e-03 1.812508197427584964e+05 +1.751466195410653504e-03 1.834412590991046745e+05 +1.775280007180405099e-03 1.856544445721031516e+05 +1.799417603464234733e-03 1.878904932573568949e+05 +1.823883386598591999e-03 1.901495189187651849e+05 +1.848681818776298086e-03 1.924316318417611183e+05 +1.873817422860383055e-03 1.947369386836803751e+05 +1.899294783208988488e-03 1.970655423210275767e+05 +1.925118546511485557e-03 1.994175416936693364e+05 +1.951293422635962246e-03 2.017930316462890187e+05 +1.977824185488231967e-03 2.041921027665746806e+05 +2.004715673882523364e-03 2.066148412204791966e+05 +2.031972792424006566e-03 2.090613285846359213e+05 +2.059600512403321568e-03 2.115316416755454848e+05 +2.087603872703265497e-03 2.140258523759802629e+05 +2.115987980717810510e-03 2.165440274583169958e+05 +2.144758013283615174e-03 2.190862284049313748e+05 +2.173919217624203232e-03 2.216525112257032888e+05 +2.203476912306977578e-03 2.242429262725386943e+05 +2.233436488213247709e-03 2.268575180509978090e+05 +2.263803409521446697e-03 2.294963250290767173e+05 +2.294583214703712921e-03 2.321593794431560673e+05 +2.325781517536029078e-03 2.348467071009935171e+05 +2.357404008122085913e-03 2.375583271820976515e+05 +2.389456453931077928e-03 2.402942520351887797e+05 +2.421944700849592864e-03 2.430544869730031351e+05 +2.454874674247826960e-03 2.458390300643798546e+05 +2.488252380060276912e-03 2.486478719236894685e+05 +2.522083905881133178e-03 2.514809954976489826e+05 +2.556375422074565022e-03 2.543383758495285874e+05 +2.591133182900105456e-03 2.572199799409266561e+05 +2.626363527653332534e-03 2.601257664109124453e+05 +2.662072881822062989e-03 2.630556853528971551e+05 +2.698267758258263323e-03 2.660096780889785150e+05 +2.734954758365899536e-03 2.689876769420895143e+05 +2.772140573304931934e-03 2.719896050057595130e+05 +2.809831985211683984e-03 2.750153759117460577e+05 +2.848035868435802066e-03 2.780648935954740155e+05 +2.886759190794032943e-03 2.811380520593757392e+05 +2.926009014841051813e-03 2.842347351342394250e+05 +2.965792499157563888e-03 2.873548162385271862e+05 +3.006116899655924494e-03 2.904981581358611002e+05 +3.046989570903508009e-03 2.936646126906314748e+05 +3.088417967464070647e-03 2.968540206218527164e+05 +3.130409645257351686e-03 3.000662112553223269e+05 +3.172972262937160792e-03 3.033010022741733119e+05 +3.216113583288200770e-03 3.065581994678459596e+05 +3.259841474641884691e-03 3.098375964795897016e+05 +3.304163912311399321e-03 3.131389745525811450e+05 +3.349088980046287245e-03 3.164621022746578674e+05 +3.394624871506797016e-03 3.198067353218600620e+05 +3.440779891758287586e-03 3.231726162006924278e+05 +3.487562458785946774e-03 3.265594739894411759e+05 +3.534981105030105680e-03 3.299670240781519096e+05 +3.583044478942428324e-03 3.333949679080676287e+05 +3.631761346563260138e-03 3.368429927098261542e+05 +3.681140593120421980e-03 3.403107712409287342e+05 +3.731191224649743707e-03 3.437979615225980524e+05 +3.781922369637629160e-03 3.473042065757507225e+05 +3.833343280685956589e-03 3.508291341565115144e+05 +3.885463336199613746e-03 3.543723564911987633e+05 +3.938292042096979903e-03 3.579334700106426608e+05 +3.991839033543662270e-03 3.615120550843487727e+05 +4.046114076709806870e-03 3.651076757541097468e+05 +4.101127070551300463e-03 3.687198794674646924e+05 +4.156888048615191809e-03 3.723481968108281144e+05 +4.213407180869664474e-03 3.759921412424011505e+05 +4.270694775558885568e-03 3.796512088251667446e+05 +4.328761281083061754e-03 3.833248779594795778e+05 +4.387617287904096303e-03 3.870126091158596682e+05 +4.447273530477112609e-03 3.907138445676366100e+05 +4.507740889208263976e-03 3.944280081237053964e+05 +4.569030392439154924e-03 3.981545048612411483e+05 +4.631153218458248719e-03 4.018927208585427725e+05 +4.694120697539616756e-03 4.056420229279369814e+05 +4.757944314009414019e-03 4.094017583488192176e+05 +4.822635708340444055e-03 4.131712546007673373e+05 +4.888206679275213309e-03 4.169498190967376577e+05 +4.954669185977838251e-03 4.207367389164063497e+05 +5.022035350215225090e-03 4.245312805395475007e+05 +5.090317458567891577e-03 4.283326895794885349e+05 +5.159527964670862846e-03 4.321401905165942735e+05 +5.229679491485020315e-03 4.359529864316802705e+05 +5.300784833599348628e-03 4.397702587394707953e+05 +5.372856959564470056e-03 4.435911669218152529e+05 +5.445909014257920011e-03 4.474148482608210179e+05 +5.519954321281573054e-03 4.512404175716364989e+05 +5.595006385391668689e-03 4.550669669349871692e+05 +5.671078894961878447e-03 4.588935654291625251e+05 +5.748185724479858323e-03 4.627192588615448913e+05 +5.826340937077747160e-03 4.665430694994242513e+05 +5.905558787097077607e-03 4.703639958000255865e+05 +5.985853722688545472e-03 4.741810121396519244e+05 +6.067240388447144896e-03 4.779930685416554916e+05 +6.149733628083116008e-03 4.817990904032795806e+05 +6.233348487129222910e-03 4.855979782209832338e+05 +6.318100215684827742e-03 4.893886073142408859e+05 +6.404004271197282980e-03 4.931698275475210394e+05 +6.491076321281138983e-03 4.969404630502167856e+05 +6.579332246575681983e-03 5.006993119344175211e+05 +6.668788143641326410e-03 5.044451460100710392e+05 +6.759460327895381974e-03 5.081767104978364077e+05 +6.851365336587749745e-03 5.118927237385203480e+05 +6.944519931817061571e-03 5.155918768995961873e+05 +7.038941103587838775e-03 5.192728336781079997e+05 +7.134646072909217422e-03 5.229342300000367104e+05 +7.231652294935798746e-03 5.265746737152041169e+05 +7.329977462151210203e-03 5.301927442882000469e+05 +7.429639507594949614e-03 5.337869924845150672e+05 +7.530656608133103926e-03 5.373559400517337490e+05 +7.633047187773535011e-03 5.408980793954364490e+05 +7.736829921026147465e-03 5.444118732496983139e+05 +7.842023736308833398e-03 5.478957543413594831e+05 +7.948647819399742159e-03 5.513481250487029320e+05 +8.056721616936468253e-03 5.547673570530703291e+05 +8.166264839962836600e-03 5.581517909841105575e+05 +8.277297467523895766e-03 5.614997360580253880e+05 +8.389839750309798297e-03 5.648094697082919301e+05 +8.503912214349228227e-03 5.680792372092846781e+05 +8.619535664753033219e-03 5.713072512918906286e+05 +8.736731189508770840e-03 5.744916917516009416e+05 +8.855520163326847244e-03 5.776307050484074280e+05 +8.975924251538930018e-03 5.807224038988560205e+05 +9.097965414049393254e-03 5.837648668600304518e+05 +9.221665909340474865e-03 5.867561379055692814e+05 +9.347048298531879934e-03 5.896942259937988129e+05 +9.474135449495605515e-03 5.925771046282885363e+05 +9.602950541026687714e-03 5.954027114110452821e+05 +9.733517067070672490e-03 5.981689475888218731e+05 +9.865858841008557853e-03 6.008736775930384174e+05 +1.000000000000000021e-02 6.035147285739743384e+05 +1.013596500938556896e-02 6.060898899301640922e+05 +1.027377866714885950e-02 6.085969128338743467e+05 +1.041346610843927462e-02 6.110335097539111739e+05 +1.055505281015629848e-02 6.133973539771705400e+05 +1.069856459559610611e-02 6.156860791305330349e+05 +1.084402763916134105e-02 6.178972787050585030e+05 +1.099146847113493392e-02 6.200285055845775642e+05 +1.114091398251883941e-02 6.220772715812310344e+05 +1.129239142993853674e-02 6.240410469808214111e+05 +1.144592844061424926e-02 6.259172601010766812e+05 +1.160155301739971417e-02 6.277032968665964436e+05 +1.175929354388950687e-02 6.293965004044672241e+05 +1.191917878959576627e-02 6.309941706650699489e+05 +1.208123791519533259e-02 6.324935640733462060e+05 +1.224550047784821530e-02 6.338918932159283431e+05 +1.241199643658837636e-02 6.351863265707372921e+05 +1.258075615778781603e-02 6.363739882853173185e+05 +1.275181042069493259e-02 6.374519580125913490e+05 +1.292519042304821064e-02 6.384172708124299534e+05 +1.310092778676621127e-02 6.392669171273611719e+05 +1.327905456371494472e-02 6.399978428440443240e+05 +1.345960324155364221e-02 6.406069494503099704e+05 +1.364260674966003006e-02 6.410910943009186303e+05 +1.382809846513614535e-02 6.414470910050024977e+05 +1.401611221889582579e-02 6.416717099500432378e+05 +1.420668230183496153e-02 6.417616789777234662e+05 +1.439984347108563996e-02 6.417136842291048961e+05 +1.459563095635532659e-02 6.415243711772634415e+05 +1.479408046635224266e-02 6.411903458678253228e+05 +1.499522819529808607e-02 6.407081763881050283e+05 +1.519911082952933069e-02 6.400743945890482282e+05 +1.540576555418825787e-02 6.392854980833225418e+05 +1.561523006000496532e-02 6.383379525475917617e+05 +1.582754255017160272e-02 6.372281943559709471e+05 +1.604274174731006031e-02 6.359526335756467888e+05 +1.626086690053438893e-02 6.345076573562329868e+05 +1.648195779260925101e-02 6.328896337471633451e+05 +1.670605474720571887e-02 6.310949159786948003e+05 +1.693319863625568356e-02 6.291198472445027437e+05 +1.716343088740630504e-02 6.269607660256222589e+05 +1.739679349157578075e-02 6.246140119972397806e+05 +1.763332901061186869e-02 6.220759325619403971e+05 +1.787308058505453559e-02 6.193428900543372147e+05 +1.811609194200415260e-02 6.164112696639223723e+05 +1.836240740309659503e-02 6.132774881242287811e+05 +1.861207189258696007e-02 6.099380032178378897e+05 +1.886513094554300579e-02 6.063893241471276851e+05 +1.912163071615008078e-02 6.026280228221388534e+05 +1.938161798612895309e-02 5.986507461164664710e+05 +1.964514017326810663e-02 5.944542291422495618e+05 +1.991224534007202812e-02 5.900353095947782276e+05 +2.018298220252709094e-02 5.853909432155326940e+05 +2.045740013898662835e-02 5.805182204210566124e+05 +2.073554919917679207e-02 5.754143841419680975e+05 +2.101748011332489272e-02 5.700768489131643437e+05 +2.130324430141181460e-02 5.645032212515721330e+05 +2.159289388255026740e-02 5.586913213523678714e+05 +2.188648168449051912e-02 5.526392061279427726e+05 +2.218406125325540421e-02 5.463451936056665145e+05 +2.248568686290629282e-02 5.398078886914264876e+05 +2.279141352544189481e-02 5.330262102948337561e+05 +2.310129700083160542e-02 5.259994197996061994e+05 +2.341539380718529045e-02 5.187271508484433871e+05 +2.373376123106136701e-02 5.112094403956773458e+05 +2.405645733791497709e-02 5.034467609612993547e+05 +2.438354098268829054e-02 4.954400540029281401e+05 +2.471507182054475185e-02 4.871907643060603295e+05 +2.505111031774929012e-02 4.787008752541118884e+05 +2.539171776269645922e-02 4.699729448240338243e+05 +2.573695627708853448e-02 4.610101421245448291e+05 +2.608688882726556413e-02 4.518162842624068726e+05 +2.644157923568950935e-02 4.423958732915431610e+05 +2.680109219258448860e-02 4.327541329660681658e+05 +2.716549326773531198e-02 4.228970449836933985e+05 +2.753484892244643586e-02 4.128313843697974226e+05 +2.790922652166349938e-02 4.025647536163307377e+05 +2.828869434625969417e-02 3.921056151524679735e+05 +2.867332160548916389e-02 3.814633216869545868e+05 +2.906317844960974034e-02 3.706481439266487141e+05 +2.945833598267730280e-02 3.596712951403359184e+05 +2.985886627551409891e-02 3.485449520051561994e+05 +3.026484237885337242e-02 3.372822711430219351e+05 +3.067633833666272639e-02 3.258974007289019064e+05 +3.109342919964865060e-02 3.144054865324140992e+05 +3.151619103894462426e-02 3.028226717386565288e+05 +3.194470095998537540e-02 2.911660898867912474e+05 +3.237903711656973244e-02 2.794538502649035654e+05 +3.281927872511473943e-02 2.677050151083160308e+05 +3.326550607910352259e-02 2.559395679688335513e+05 +3.371780056372962464e-02 2.441783726523352088e+05 +3.417624467074045075e-02 2.324431221653765824e+05 +3.464092201348251826e-02 2.207562771678664139e+05 +3.511191734215130672e-02 2.091409934983092535e+05 +3.558931655924840037e-02 1.976210384234242374e+05 +3.607320673524882365e-02 1.862206953629433701e+05 +3.656367612448138682e-02 1.749646569554217858e+05 +3.706081418122499083e-02 1.638779064606264874e+05 +3.756471157602369465e-02 1.529855876385545416e+05 +3.807546021222371624e-02 1.423128634038110904e+05 +3.859315324273520503e-02 1.318847637257752649e+05 +3.911788508702192246e-02 1.217260234284107864e+05 +3.964975144832197373e-02 1.118609107370428683e+05 +4.018884933110263014e-02 1.023130476210360212e+05 +4.073527705875248928e-02 9.310522318783770606e+04 +4.128913429151419290e-02 8.425920159508328652e+04 +4.185052204466096354e-02 7.579552615273195261e+04 +4.241954270692029766e-02 6.773332150500672287e+04 +4.299630005914809039e-02 6.009009594632148219e+04 +4.358089929325677236e-02 5.288154620430276555e+04 +4.417344703140068524e-02 4.612136695766294724e+04 +4.477405134542242204e-02 3.982106807431951893e+04 +4.538282177656344923e-02 3.398980150119416066e+04 +4.599986935544285449e-02 2.863420161405150066e+04 +4.662530662230762735e-02 2.375824310287558546e+04 +4.725924764755833063e-02 1.936310255996489650e+04 +4.790180805255385421e-02 1.544711571127993739e+04 +4.855310503069897032e-02 1.200546080406196779e+04 +4.921325736881872193e-02 9.030948198067135309e+03 +4.988238546882330787e-02 6.511237367239962623e+03 +5.056061136966762126e-02 4.437284799880485480e+03 +5.124805876960931289e-02 2.779466929742228785e+03 +5.194485304876952231e-02 1.549648787903498715e+03 +5.265112129200031493e-02 6.588805848264186125e+02 +5.336699231206307181e-02 1.913185826683975677e+02 +5.409259667312199538e-02 8.811501260479357001e+00 +5.482806671455707492e-02 7.060553237164307916e+01 +5.557353657510081396e-02 6.253663137282856042e+02 +5.632914221730309090e-02 1.103866104447035468e+03 +5.709502145232881604e-02 2.022037286014455276e+03 +5.787131396509233305e-02 2.982598158466034874e+03 +5.865816133973422719e-02 4.129182127281172143e+03 +5.945570708544394706e-02 5.346811887435072094e+03 +6.026409666263374959e-02 6.630752272942214404e+03 +6.108347750946852700e-02 7.934517460898560785e+03 +6.191399906875633824e-02 9.228353365465149182e+03 +6.275581281520449528e-02 1.047885349300619055e+04 +6.360907228304631122e-02 1.165654659282267676e+04 +6.447393309404349238e-02 1.273396632294382289e+04 +6.535055298586910089e-02 1.368680707410752620e+04 +6.623909184087668767e-02 1.449405549540017819e+04 +6.713971171526031401e-02 1.513838448205032910e+04 +6.805257686861129751e-02 1.560640215427119801e+04 +6.897785379387658122e-02 1.588886770596430506e+04 +6.991571124772466561e-02 1.598083115443914176e+04 +7.086632028132422434e-02 1.588170049360269331e+04 +7.182985427154131575e-02 1.559522768686992822e+04 +7.280648895256074116e-02 1.512941000418444128e+04 +7.379640244793725379e-02 1.449630365699564936e+04 +7.479977530308275224e-02 1.371174904408326074e+04 +7.581679051819496806e-02 1.279500793355827227e+04 +7.684763358163397562e-02 1.176831806069273807e+04 +7.789249250375253342e-02 1.065636372518336611e+04 +7.895155785118633529e-02 9.485691567645682881e+03 +8.002502278161052751e-02 8.284019688097250764e+03 +8.111308307896872294e-02 7.079630038976727519e+03 +8.221593718918115967e-02 5.900377150715165953e+03 +8.333378625633819370e-02 4.773578142626958652e+03 +8.446683415938599504e-02 3.723784026424298190e+03 +8.561528754931102547e-02 2.775117566768379675e+03 +8.677935588683004242e-02 1.945435286258007181e+03 +8.795925148059269283e-02 1.250962234823917925e+03 +8.915518952590333057e-02 7.120290228813471458e+02 +9.036738814396948205e-02 3.014636964675549962e+02 +9.159606842168389884e-02 9.989285843016575939e+01 +9.284145445194744162e-02 2.997458172920902664e-01 +9.410377337454033098e-02 4.064468581551756898e+01 +9.538325541754902326e-02 3.080604622612893877e+02 +9.668013393935633026e-02 5.517760172678869139e+02 +9.799464547120259605e-02 1.003549721931005024e+03 +9.932702976032535547e-02 1.463788831591476310e+03 +1.006775298136856761e-01 1.999359150161223852e+03 +1.020463919422890386e-01 2.539662149577874516e+03 +1.034338658061087213e-01 3.074684935399231563e+03 +1.048402044596200428e-01 3.570804635254207369e+03 +1.062656643979537630e-01 4.005642136005389602e+03 +1.077105056036769121e-01 4.356674374464088942e+03 +1.091749915942097360e-01 4.606589157308966605e+03 +1.106593894698873481e-01 4.742675686578339082e+03 +1.121639699626748032e-01 4.757948361956161534e+03 +1.136890074855445715e-01 4.651416741718811863e+03 +1.152347801825253787e-01 4.428280332619166074e+03 +1.168015699794314882e-01 4.099723067974448895e+03 +1.183896626352817366e-01 3.682554684544679276e+03 +1.199993477944177739e-01 3.198047977825599901e+03 +1.216309190393307926e-01 2.672052992416417965e+03 +1.232846739442065853e-01 2.130008637976957289e+03 +1.249609141291986719e-01 1.606093869793093518e+03 +1.266599453154392541e-01 1.112162726076596527e+03 +1.283820773807981819e-01 7.115553513541295843e+02 +1.301276244164000784e-01 3.425206031132286171e+02 +1.318969047839098352e-01 1.722595576551439649e+02 +1.336902411735970131e-01 8.177118641148849676e+00 +1.355079606631897360e-01 1.851909064214946055e+00 +1.373503947775287226e-01 1.649645458027208917e+02 +1.392178795490325305e-01 2.740990643241340763e+02 +1.411107555789848644e-01 5.852228921023136081e+02 +1.430293680996549965e-01 8.763621463492336261e+02 +1.449740670372631490e-01 1.215990387015404849e+03 +1.469452070758017204e-01 1.532995979328508156e+03 +1.489431477217242894e-01 1.813358841026995606e+03 +1.509682533695143325e-01 2.026786961196407219e+03 +1.530208933681452277e-01 2.155083998690041881e+03 +1.551014420884440081e-01 2.185731235233530697e+03 +1.572102789913710774e-01 2.115439703533792454e+03 +1.593477886972280433e-01 1.950373835536194065e+03 +1.615143610558068543e-01 1.704957717446964580e+03 +1.637103912174925346e-01 1.403003750904443450e+03 +1.659362797053327010e-01 1.071068938932386800e+03 +1.681924324880868793e-01 7.413877998269809950e+02 +1.704792610542693321e-01 4.522273219090825478e+02 +1.727971824871981921e-01 1.978362889774882660e+02 +1.751466195410653626e-01 8.441953854260424350e+01 +1.775280007180405073e-01 1.677360118180868179e-02 +1.799417603464236737e-01 1.779375606987995795e+01 +1.823883386598593725e-01 1.969603749051336763e+02 +1.848681818776299890e-01 3.172839565514433389e+02 +1.873817422860384885e-01 5.744237433509807715e+02 +1.899294783208990423e-01 7.813627737197494980e+02 +1.925118546511487561e-01 9.845411880493159060e+02 +1.951293422635964336e-01 1.120450537649552643e+03 +1.977824185488233910e-01 1.181902705558203706e+03 +2.004715673882525306e-01 1.155418319301107204e+03 +2.031972792424008578e-01 1.044681753432810410e+03 +2.059600512403323702e-01 8.699336916016887926e+02 +2.087603872703267804e-01 6.438093092421635220e+02 +2.115987980717812800e-01 4.370425396533246385e+02 +2.144758013283617482e-01 1.960780580263223101e+02 +2.173919217624205591e-01 1.201055303522246192e+02 +2.203476912306980007e-01 1.050858043308702916e+00 +2.233436488213250137e-01 2.762205833687894518e+00 +2.263803409521448762e-01 1.619819575776823228e+02 +2.294583214703715401e-01 2.114509159932988496e+02 +2.325781517536031351e-01 4.144856883567687191e+02 +2.357404008122088168e-01 5.422482459128616483e+02 +2.389456453931078084e-01 6.521690194920564636e+02 +2.421944700849592569e-01 6.852899205181897742e+02 +2.454874674247826960e-01 6.506860996469182510e+02 +2.488252380060277102e-01 5.367278805400061401e+02 +2.522083905881132848e-01 4.147639563384595363e+02 +2.556375422074564918e-01 2.016775684294797486e+02 +2.591133182900105525e-01 1.811786645902025157e+02 +2.626363527653332586e-01 2.320501245866576578e+00 +2.662072881822062920e-01 3.917985375278010968e-02 +2.698267758258263149e-01 1.144501745620541158e+02 +2.734954758365899519e-01 1.206245770369595363e+02 +2.772140573304932021e-01 2.755646393331716695e+02 +2.809831985211684313e-01 3.524408060660239244e+02 +2.848035868435802032e-01 4.089291051416215623e+02 +2.886759190794033203e-01 3.955892913482853714e+02 +2.926009014841051692e-01 3.316023689105430776e+02 +2.965792499157564044e-01 2.201442689503160466e+02 +3.006116899655924546e-01 1.234900732040729423e+02 +3.046989570903508304e-01 2.748622474104781332e+01 +3.088417967464070490e-01 5.206402021276937964e-01 +3.130409645257352103e-01 2.374089227252479262e+01 +3.172972262937160948e-01 8.651568911433747644e+01 +3.216113583288200961e-01 1.658860011258385612e+02 +3.259841474641884673e-01 2.283334793629867647e+02 +3.304163912311399720e-01 2.488526731336039859e+02 +3.349088980046286967e-01 2.206555123179113878e+02 +3.394624871506797259e-01 1.556892349852158191e+02 +3.440779891758287690e-01 7.699907256545014889e+01 +3.487562458785946617e-01 2.058982840682226012e+01 +3.534981105030105542e-01 1.170738735497929284e+00 +3.583044478942428168e-01 1.684769074277168954e+01 +3.631761346563260329e-01 8.203174171577289542e+01 +3.681140593120422189e-01 1.215889790572051226e+02 +3.731191224649743621e-01 1.519256715246400518e+02 +3.781922369637629178e-01 1.406827758067751120e+02 +3.833343280685956311e-01 9.135506757096952413e+01 +3.885463336199613815e-01 5.277092353603351427e+01 +3.938292042096980250e-01 3.086810615046766682e+00 +3.991839033543662651e-01 3.509066483923192870e+00 +4.046114076709806939e-01 2.714796750210837573e+01 +4.101127070551300324e-01 6.512301106815830565e+01 +4.156888048615192122e-01 8.880698055434615412e+01 +4.213407180869664370e-01 9.067276988495410706e+01 +4.270694775558880885e-01 5.348970850144142020e+01 +4.328761281083057244e-01 3.886078325483795481e+01 +4.387617287904091445e-01 4.707219867125075896e-01 +4.447273530477107717e-01 5.674170925692310075e-01 +4.507740889208259327e-01 4.180086243349151687e+01 +4.569030392439150101e-01 4.221462653916083951e+01 +4.631153218458244347e-01 5.870057662395318943e+01 +4.694120697539612141e-01 4.058866764477216549e+01 +4.757944314009409092e-01 2.219086329330190921e+01 +4.822635708340439198e-01 1.510907278102133322e+00 +4.888206679275207689e-01 6.784753935019567361e-01 +4.954669185977833012e-01 2.314236579884914136e+01 +5.022035350215219296e-01 2.923251459290250409e+01 +5.090317458567886755e-01 3.139570179193196253e+01 +5.159527964670856948e-01 2.504888640934031230e+01 +5.229679491485015319e-01 2.687336732365690928e+00 +5.300784833599342383e-01 1.532399055862623261e-01 +5.372856959564464852e-01 8.628334314155939211e+00 +5.445909014257914738e-01 1.633781016354672033e+01 +5.519954321281567156e-01 1.963907554683072831e+01 +5.595006385391663173e-01 1.468680989335088505e+01 +5.671078894961878447e-01 2.202256601426014537e+00 +5.748185724479858427e-01 2.946468698455452506e-02 +5.826340937077747473e-01 6.458636766170734234e+00 +5.905558787097077156e-01 1.077117150506191301e+01 +5.985853722688545542e-01 1.135520947974146466e+01 +6.067240388447144861e-01 5.042003535138937842e+00 +6.149733628083116077e-01 3.096573978740629340e-01 +6.233348487129223292e-01 1.417588629558139690e+00 +6.318100215684827603e-01 5.716134107988207091e+00 +6.404004271197283327e-01 6.964807724970946801e+00 +6.491076321281139538e-01 4.235158947591982859e+00 +6.579332246575682053e-01 2.422662446562536542e-01 +6.668788143641326549e-01 7.345131414204307818e-01 +6.759460327895382425e-01 3.487675878764318504e+00 +6.851365336587750265e-01 3.531434293266512814e+00 +6.944519931817061398e-01 3.546493534286688121e+00 +7.038941103587839088e-01 1.777743056037015554e-03 +7.134646072909217596e-01 1.994499794997998954e-01 +7.231652294935798642e-01 3.400740326044505490e+00 +7.329977462151210377e-01 2.066519660602547770e+00 +7.429639507594949510e-01 2.534271562081419904e-01 +7.530656608133103891e-01 2.015328717448798546e-01 +7.633047187773535081e-01 9.630733245960834132e-01 +7.736829921026147083e-01 1.541817528939240622e+00 +7.842023736308834092e-01 3.543403678372473165e-01 +7.948647819399742298e-01 1.118497807791907633e-01 +8.056721616936468600e-01 3.735754592215401182e-01 +8.166264839962836808e-01 1.005050077919468210e+00 +8.277297467523895280e-01 1.951771907437504228e-01 +8.389839750309798783e-01 7.209383619166685742e-02 +8.503912214349227394e-01 2.342821493942424671e-01 +8.619535664753031901e-01 6.626899717889157548e-01 +8.736731189508771811e-01 3.680282993683339776e-02 +8.855520163326846550e-01 1.470140093505144067e-02 +8.975924251538929255e-01 2.998813576884919452e-01 +9.097965414049393740e-01 1.890985772818660482e-01 +9.221665909340474032e-01 3.314365733604412306e-02 +9.347048298531880350e-01 2.432347585538421203e-02 +9.474135449495605377e-01 2.700339531056112352e-01 +9.602950541026686881e-01 1.324213287248065217e-02 +9.733517067070671658e-01 7.728048975025146724e-04 +9.865858841008557922e-01 1.401515650534790880e-01 +1.000000000000000000e+00 3.340601048975868487e-02 +1.013596500938556799e+00 5.297846757962043976e-03 +1.027377866714885846e+00 3.534203338589970295e-02 +1.041346610843927323e+00 3.174322701678986697e-02 +1.055505281015630015e+00 4.700120435510321722e-03 +1.069856459559610729e+00 1.490349126688096312e-02 +1.084402763916133994e+00 2.006499407740732280e-02 +1.099146847113493530e+00 2.303837528025400733e-03 +1.114091398251883858e+00 8.853904479023377502e-03 +1.129239142993853751e+00 1.062777095935947026e-02 +1.144592844061424808e+00 3.987287177790688154e-04 +1.160155301739971501e+00 6.079962839456350306e-03 +1.175929354388950632e+00 5.327785199940493661e-03 +1.191917878959576793e+00 6.330719239021215532e-05 +1.208123791519533308e+00 3.602482466719248485e-03 +1.224550047784821460e+00 1.543591995166977227e-03 +1.241199643658837726e+00 6.773151972371982020e-04 +1.258075615778781575e+00 2.633211999905715837e-03 +1.275181042069493342e+00 2.658729818217967679e-05 +1.292519042304821175e+00 6.422065900758943801e-04 +1.310092778676621217e+00 6.502106703959643517e-04 +1.327905456371494486e+00 1.996516734693626512e-04 +1.345960324155364374e+00 8.208802865581414339e-04 +1.364260674966003117e+00 7.484301435498680358e-06 +1.382809846513614493e+00 1.450028136237560203e-04 +1.401611221889582648e+00 5.465693630346290285e-05 +1.420668230183496084e+00 8.540173044520036933e-05 +1.439984347108564045e+00 9.418140904263989997e-05 +1.459563095635532770e+00 4.850007818599418459e-05 +1.479408046635224183e+00 6.757825037464340406e-05 +1.499522819529808704e+00 2.268678886171001047e-05 +1.519911082952933201e+00 3.434169475197924919e-05 +1.540576555418825766e+00 1.084598035327964898e-05 +1.561523006000496538e+00 1.430675758027564214e-05 +1.582754255017160494e+00 6.289200010008156608e-06 +1.604274174731006086e+00 5.780860617974523019e-06 +1.626086690053438755e+00 4.608100950418957989e-06 +1.648195779260925198e+00 2.734095068466157919e-06 +1.670605474720571859e+00 3.642287760616521308e-06 +1.693319863625568411e+00 1.574377541875781742e-06 +1.716343088740630352e+00 2.532289292097178818e-06 +1.739679349157577937e+00 9.571935502739495368e-07 +1.763332901061186897e+00 1.316757783286377708e-06 +1.787308058505453712e+00 4.759204603603891367e-07 +1.811609194200413331e+00 3.147434387768833217e-07 +1.836240740309657449e+00 2.108994688996692604e-07 +1.861207189258694106e+00 1.217553665194496599e-08 +1.886513094554298720e+00 6.453173886890843432e-07 +1.912163071615006205e+00 8.950624895471883381e-08 +1.938161798612893394e+00 1.565745844016893715e-07 +1.964514017326808526e+00 8.336424873878821559e-08 +1.991224534007200786e+00 2.260679964007974537e-09 +2.018298220252706887e+00 1.815794003994911081e-07 +2.045740013898660781e+00 4.072580352167158156e-08 +2.073554919917677264e+00 4.371375223409862714e-09 +2.101748011332487120e+00 8.407578666261956362e-08 +2.130324430141179448e+00 2.338518875030186839e-08 +2.159289388255024367e+00 3.515648167322349634e-09 +2.188648168449049969e+00 4.402729783451704266e-08 +2.218406125325538270e+00 1.935067595783129354e-08 +2.248568686290627117e+00 8.416955280400663564e-11 +2.279141352544187260e+00 1.669692190340594312e-08 +2.310129700083157989e+00 2.283132001830495492e-08 +2.341539380718526964e+00 3.754865527975911398e-09 +2.373376123106134106e+00 2.368963832542095964e-09 +2.405645733791495378e+00 1.149207790481270683e-08 +2.438354098268826764e+00 1.290392753699561087e-08 +2.471507182054472729e+00 3.316263094937368073e-09 +2.505111031774926555e+00 4.823249934035306283e-10 +2.539171776269643299e+00 3.450367034924288235e-09 +2.573695627708850520e+00 8.981241670845377854e-09 +2.608688882726553970e+00 5.267107283376777808e-09 +2.644157923568948299e+00 4.296152086660124999e-09 +2.680109219258445918e+00 3.955445133513649913e-12 +2.716549326773528339e+00 1.330387039919479025e-10 +2.753484892244640658e+00 3.800696278889625719e-09 +2.790922652166347273e+00 3.203164308079419276e-09 +2.828869434625966406e+00 3.816057207873186227e-09 +2.867332160548913489e+00 2.852963019661365338e-09 +2.906317844960971009e+00 1.837400942013982270e-09 +2.945833598267727282e+00 9.700238827187776949e-10 +2.985886627551407102e+00 3.915689227677623255e-10 +3.026484237885334050e+00 1.369235381280480411e-10 +3.067633833666269627e+00 1.204661455824614768e-11 +3.109342919964861895e+00 2.149064511705589465e-12 +3.151619103894459428e+00 5.603900280420728356e-12 +3.194470095998533932e+00 1.285781148696825551e-11 +3.237903711656976657e+00 5.845686267876554598e-12 +3.281927872511477329e+00 1.385814989441409841e-12 +3.326550607910355950e+00 3.836826895369891405e-12 +3.371780056372966072e+00 5.068915078909505423e-11 +3.417624467074048322e+00 1.189511543641740138e-10 +3.464092201348255351e+00 2.479900016684872353e-10 +3.511191734215134641e+00 3.795961807302498353e-10 +3.558931655924843618e+00 4.795712522008579643e-10 +3.607320673524885724e+00 4.595815984152259875e-10 +3.656367612448142346e+00 3.533653149018047241e-10 +3.706081418122502580e+00 1.050741273844717035e-10 +3.756471157602373268e+00 1.563000457514201542e-11 +3.807546021222375732e+00 4.573761513529940752e-11 +3.859315324273524528e+00 1.980181373687901353e-10 +3.911788508702196410e+00 2.754149782700406589e-10 +3.964975144832201703e+00 5.026637529047589679e-11 +4.018884933110267177e+00 3.143305929643995758e-13 +4.073527705875252813e+00 1.294183698307227415e-10 +4.128913429151423564e+00 1.325301148287573817e-10 +4.185052204466100711e+00 3.221520152857290444e-11 +4.241954270692033901e+00 2.483132245049740278e-11 +4.299630005914813147e+00 1.056503921166582367e-10 +4.358089929325681844e+00 2.305868818090390017e-11 +4.417344703140073214e+00 2.895841589492563404e-11 +4.477405134542246756e+00 8.584818287264443991e-11 +4.538282177656349781e+00 9.926241782569738837e-14 +4.599986935544290390e+00 3.741119597472573113e-11 +4.662530662230767398e+00 7.285036743424729161e-12 +4.725924764755838225e+00 3.215760964217458397e-11 +4.790180805255389807e+00 9.223723711481904166e-12 +4.855310503069902417e+00 3.021250618059397195e-11 +4.921325736881876800e+00 3.635677545039932134e-12 +4.988238546882335811e+00 2.950851381487464452e-11 +5.056061136966767400e+00 4.081453558389049457e-13 +5.124805876960936146e+00 5.053391721099129650e-12 +5.194485304876957699e+00 2.095027338612179844e-11 +5.265112129200037572e+00 2.340462533294654313e-12 +5.336699231206313065e+00 8.123001225265392420e-12 +5.409259667312205089e+00 1.584650562630458055e-11 +5.482806671455713321e+00 5.534671903270756929e-13 +5.557353657510086364e+00 1.883825701495966238e-12 +5.632914221730315418e+00 1.248714522192430442e-11 +5.709502145232881354e+00 8.207802240743040657e-12 +5.787131396509233028e+00 3.948022900942526700e-13 +5.865816133973423163e+00 2.432899988168715805e-13 +5.945570708544394734e+00 2.687208354103757800e-12 +6.026409666263374376e+00 4.277744810384879239e-12 +6.108347750946852450e+00 5.101565371459687372e-12 +6.191399906875633796e+00 4.716112247469813512e-12 +6.275581281520448584e+00 4.089703748164791542e-12 +6.360907228304631289e+00 3.524794426310668992e-12 +6.447393309404349182e+00 3.158462606175369107e-12 +6.535055298586910588e+00 2.902336848125582609e-12 +6.623909184087668045e+00 2.691522087255429410e-12 +6.713971171526031512e+00 2.063435902254759041e-12 +6.805257686861128974e+00 1.619307612125451093e-12 +6.897785379387658011e+00 2.255441771974944101e-13 +6.991571124772466561e+00 2.832555534953842601e-14 +7.086632028132422434e+00 6.069240365164520716e-13 +7.182985427154132019e+00 1.359421378030937655e-12 +7.280648895256073061e+00 5.869847908410992465e-13 +7.379640244793725934e+00 6.099414978724654704e-14 +7.479977530308275391e+00 7.254723587427396585e-13 +7.581679051819496529e+00 3.934626156462388790e-13 +7.684763358163396951e+00 6.048911761349038520e-15 +7.789249250375253730e+00 7.094636526136330241e-13 +7.895155785118634029e+00 1.337272943502836473e-13 +8.002502278161051308e+00 3.728911202771460865e-13 +8.111308307896871739e+00 1.124986207411199483e-13 +8.221593718918116522e+00 3.563144531779366504e-13 +8.333378625633820036e+00 1.235077835348040245e-15 +8.446683415938599282e+00 2.534209449113114808e-13 +8.561528754931101659e+00 2.031364880039107376e-13 +8.677935588683004298e+00 3.286018891645796464e-15 +8.795925148059268395e+00 1.085907174023136451e-13 +8.915518952590332447e+00 2.271021171913103088e-13 +9.036738814396949593e+00 1.180882514004609323e-13 +9.159606842168390273e+00 4.190763391671987044e-14 +9.284145445194743829e+00 1.308323808310097664e-15 +9.410377337454033153e+00 1.758610005898305291e-15 +9.538325541754900883e+00 4.961918248527163059e-15 +9.668013393935632749e+00 7.080695840606389510e-15 +9.799464547120258828e+00 6.470854204379273954e-17 +9.932702976032535602e+00 1.178750891509657030e-15 +1.006775298136856733e+01 2.853786184421248321e-14 +1.020463919422890520e+01 4.575538911780519563e-14 +1.034338658061087202e+01 6.903778690960844511e-14 +1.048402044596200433e+01 7.699806884797746069e-15 +1.062656643979537563e+01 5.847065156113201713e-15 +1.077105056036769071e+01 1.160759585288051498e-13 +1.091749915942097360e+01 7.504386924517633606e-17 +1.106593894698873548e+01 6.606155011947836766e-16 +1.121639699626748055e+01 3.947337304085672795e-15 +1.136890074855445754e+01 1.651220143945378967e-15 +1.152347801825253804e+01 1.619492099709994447e-14 +1.168015699794314877e+01 3.063292067011784781e-15 +1.183896626352817449e+01 1.337851617405803086e-14 +1.199993477944177833e+01 1.642238560629258943e-14 +1.216309190393307915e+01 1.767907756163584604e-15 +1.232846739442065953e+01 3.175409477615417111e-16 +1.249609141291986703e+01 1.632799992558896383e-15 +1.266599453154392485e+01 3.322602697518877737e-15 +1.283820773807981830e+01 3.162589929028957580e-15 +1.301276244164000850e+01 2.054635315886267329e-15 +1.318969047839098430e+01 3.043544556714143982e-16 +1.336902411735970198e+01 1.422743656516061290e-16 +1.355079606631897349e+01 4.521282414279517890e-15 +1.373503947775287237e+01 4.254996609867038023e-15 +1.392178795490325349e+01 1.290040393259933655e-15 +1.411107555789848611e+01 1.322414477141368359e-15 +1.430293680996549988e+01 2.443562789731121594e-15 +1.449740670372631612e+01 2.616184429665232512e-16 +1.469452070758017115e+01 2.897176875791105259e-15 +1.489431477217242872e+01 9.725479317581386130e-16 +1.509682533695143292e+01 5.866355720223232368e-17 +1.530208933681452166e+01 1.526461648405563664e-15 +1.551014420884440170e+01 1.737500383507846387e-15 +1.572102789913710730e+01 1.404836680064527809e-15 +1.593477886972280366e+01 1.087546046875415447e-15 +1.615143610558068588e+01 1.019822004274210010e-15 +1.637103912174925568e+01 1.070773260439787044e-15 +1.659362797053326943e+01 9.195763145764453139e-16 +1.681924324880868937e+01 2.439420336844844160e-16 +1.704792610542693154e+01 1.154085771855522734e-16 +1.727971824871981710e+01 8.534527431167114316e-16 +1.751466195410653626e+01 8.942295565580289337e-18 +1.775280007180405306e+01 3.163010566441876702e-16 +1.799417603464234716e+01 6.935723780267376249e-17 +1.823883386598592082e+01 1.071042030092003590e-16 +1.848681818776298158e+01 3.717737325311852422e-16 +1.873817422860383175e+01 3.151831640239248478e-16 +1.899294783208988591e+01 2.100891933674560791e-16 +1.925118546511485462e+01 1.713620905622244520e-16 +1.951293422635962216e+01 1.899057063341581194e-16 +1.977824185488232089e+01 2.286860740372075824e-16 +2.004715673882523319e+01 9.518830675626367271e-17 +2.031972792424006613e+01 3.117985536571925331e-17 +2.059600512403321559e+01 1.074239069680495480e-16 +2.087603872703265750e+01 3.485155760321503407e-17 +2.115987980717810402e+01 2.622030876046057351e-17 +2.144758013283615483e+01 1.080536774909035380e-16 +2.173919217624203526e+01 6.427233257485440113e-17 +2.203476912306977553e+01 1.817061938857929196e-17 +2.233436488213247983e+01 6.465847656251512812e-18 +2.263803409521446497e+01 9.818640420843661984e-18 +2.294583214703713026e+01 2.640701562600458821e-17 +2.325781517536028886e+01 8.105127745606125849e-17 +2.357404008122085770e+01 4.029781869578445686e-18 +2.389456453931075686e+01 1.328831413473196537e-18 +2.421944700849590149e+01 3.127354153740169182e-17 +2.454874674247824373e+01 3.007874769241399462e-18 +2.488252380060274405e+01 1.736254962140798552e-17 +2.522083905881130406e+01 2.554405968085555773e-17 +2.556375422074562564e+01 2.281055686729740443e-17 +2.591133182900102838e+01 2.255325201417957789e-17 +2.626363527653330010e+01 8.462218080240629410e-18 +2.662072881822060211e+01 1.729511425212622060e-18 +2.698267758258260329e+01 8.987627728455088339e-18 +2.734954758365896765e+01 8.265149492930303042e-18 +2.772140573304929134e+01 5.295090228000256500e-18 +2.809831985211681271e+01 1.431657436429345196e-19 +2.848035868435799145e+01 1.837687691572782153e-18 +2.886759190794030161e+01 2.043723500710037062e-18 +2.926009014841048739e+01 5.887702382586123718e-19 +2.965792499157560869e+01 8.288795180695487756e-19 +3.006116899655921770e+01 5.471305569703699445e-18 +3.046989570903505040e+01 4.241424087282446402e-19 +3.088417967464067715e+01 4.369641816903386079e-18 +3.130409645257348572e+01 1.913009389456287463e-18 +3.172972262937157595e+01 3.081819242539703596e-19 +3.216113583288204580e+01 2.366088867849475779e-19 +3.259841474641887515e+01 9.881891841035755976e-19 +3.304163912311403095e+01 3.109461510540446853e-18 +3.349088980046290942e+01 1.199477551081526349e-19 +3.394624871506800190e+01 1.238890121916011092e-18 +3.440779891758290887e+01 1.069304960718572259e-18 +3.487562458785950525e+01 1.061541453003693068e-19 +3.534981105030109205e+01 7.667129781620593189e-20 +3.583044478942431965e+01 3.621784610538438811e-19 +3.631761346563263970e+01 1.574168918153163879e-18 +3.681140593120425564e+01 4.724573267981037557e-20 +3.731191224649747795e+01 1.792613948353079080e-19 +3.781922369637632642e+01 9.685501055201512217e-19 +3.833343280685960508e+01 5.958490508218047199e-19 +3.885463336199617856e+01 8.175220386612768138e-19 +3.938292042096983891e+01 1.033972088754904094e-19 +3.991839033543666915e+01 3.722096060891405738e-19 +4.046114076709811513e+01 6.312284257749575829e-21 +4.101127070551304143e+01 4.814001748085130133e-21 +4.156888048615196141e+01 4.209980816303435524e-19 +4.213407180869668878e+01 6.351580293424730202e-21 +4.270694775558884970e+01 1.371984729888255331e-20 +4.328761281083061618e+01 1.296432985044299651e-19 +4.387617287904095775e+01 4.756901553203897173e-20 +4.447273530477112757e+01 2.129604815008492819e-19 +4.507740889208263724e+01 2.250197696407538897e-19 +4.569030392439155008e+01 1.987119874942307447e-20 +4.631153218458248944e+01 5.473256581289069249e-21 +4.694120697539617026e+01 1.597346346457907741e-19 +4.757944314009413489e+01 1.639843495143668872e-20 +4.822635708340444438e+01 1.196279462791353910e-20 +4.888206679275212707e+01 5.786638067436779745e-20 +4.954669185977838453e+01 4.596975609733410766e-20 +5.022035350215224980e+01 5.894110564072886579e-21 +5.090317458567891862e+01 1.229595049317869903e-20 +5.159527964670862588e+01 6.775800192820293314e-21 +5.229679491485020293e+01 1.899329935305182002e-21 +5.300784833599347934e+01 5.099876104998231470e-20 +5.372856959564470003e+01 3.753825207010319558e-21 +5.445909014257919978e+01 2.626112198348697115e-22 +5.519954321281573328e+01 8.211019892774104681e-21 +5.595006385391668857e+01 2.425998217248500767e-20 +5.671078894961878802e+01 2.425197932305155932e-21 +5.748185724479857583e+01 3.519112317589604245e-22 +5.826340937077747384e+01 4.667666837191140005e-22 +5.905558787097077555e+01 1.550442717714803547e-20 +5.985853722688545986e+01 3.450930183911477384e-24 +6.067240388447144284e+01 2.064188517824290684e-21 +6.149733628083116344e+01 8.589177854217251283e-23 +6.233348487129223514e+01 7.514739709195326962e-21 +6.318100215684827958e+01 2.371759150611493844e-23 +6.404004271197283060e+01 1.456134580372753306e-22 +6.491076321281138917e+01 1.155950603269347914e-21 +6.579332246575683030e+01 4.332416526947445536e-21 +6.668788143641326371e+01 5.082131985939406833e-21 +6.759460327895382648e+01 5.361376521610464176e-21 +6.851365336587750221e+01 1.663304948843390140e-21 +6.944519931817060865e+01 2.809082977344747530e-21 +7.038941103587838199e+01 3.532998663796993886e-21 +7.134646072909217196e+01 2.502741673975676260e-21 +7.231652294935798864e+01 1.665126285831445679e-21 +7.329977462151209977e+01 2.182167056516942238e-22 +7.429639507594950487e+01 5.865443238575437542e-22 +7.530656608133104157e+01 9.313871344614685191e-22 +7.633047187773534858e+01 1.083101482067754828e-21 +7.736829921026146906e+01 7.416996439834608107e-22 +7.842023736308833293e+01 7.199469467658182589e-22 +7.948647819399742787e+01 4.104305182771962657e-22 +8.056721616936468422e+01 5.132487338497676593e-22 +8.166264839962836675e+01 2.780995020589183040e-22 +8.277297467523895591e+01 1.873597564840570368e-22 +8.389839750309798205e+01 7.171362689185365145e-23 +8.503912214349227838e+01 3.444688721692195656e-23 +8.619535664753031767e+01 1.287262503516967741e-21 +8.736731189508770967e+01 3.802401254768906923e-23 +8.855520163326846728e+01 7.427732606249141769e-24 +8.975924251538928900e+01 1.802541257920375526e-22 +9.097965414049393473e+01 5.143396857364147989e-23 +9.221665909340474343e+01 4.018195941272872435e-22 +9.347048298531879595e+01 2.030107426648087623e-22 +9.474135449495605599e+01 2.043080678325657402e-22 +9.602950541026687858e+01 2.345807650112681734e-22 +9.733517067070671658e+01 1.336002895847468352e-22 +9.865858841008557079e+01 7.196067801949256388e-24 +1.000000000000000000e+02 1.002895944086879748e-23 diff --git a/output/tz.txt b/output/tz.txt new file mode 100644 index 0000000..d8fb07b --- /dev/null +++ b/output/tz.txt @@ -0,0 +1,1024 @@ +0.000000000000000000e+00 5.000000000000000278e-02 +1.955034213098729226e-04 5.000000000000000278e-02 +3.910068426197458452e-04 5.000000000000000278e-02 +5.865102639296187678e-04 5.000000000000000278e-02 +7.820136852394916904e-04 5.000000000000000278e-02 +9.775171065493646130e-04 5.000000000000000278e-02 +1.173020527859237536e-03 5.000000000000000278e-02 +1.368523949169110458e-03 5.000000000000000278e-02 +1.564027370478983381e-03 5.000000000000000278e-02 +1.759530791788856303e-03 5.000000000000000278e-02 +1.955034213098729226e-03 5.000000000000000278e-02 +2.150537634408602149e-03 5.000000000000000278e-02 +2.346041055718475071e-03 5.000000000000000278e-02 +2.541544477028347994e-03 5.000000000000000278e-02 +2.737047898338220916e-03 5.000000000000000278e-02 +2.932551319648093839e-03 5.000000000000000278e-02 +3.128054740957966762e-03 5.000000000000000278e-02 +3.323558162267839684e-03 5.000000000000000278e-02 +3.519061583577712607e-03 5.000000000000000278e-02 +3.714565004887585530e-03 5.000000000000000278e-02 +3.910068426197458452e-03 5.000000000000000278e-02 +4.105571847507331375e-03 5.000000000000000278e-02 +4.301075268817204297e-03 5.000000000000000278e-02 +4.496578690127077220e-03 5.000000000000000278e-02 +4.692082111436950143e-03 5.000000000000000278e-02 +4.887585532746823065e-03 5.000000000000000278e-02 +5.083088954056695988e-03 5.000000000000000278e-02 +5.278592375366568910e-03 5.000000000000000278e-02 +5.474095796676441833e-03 5.000000000000000278e-02 +5.669599217986314756e-03 5.000000000000000278e-02 +5.865102639296187678e-03 5.000000000000000278e-02 +6.060606060606060601e-03 5.000000000000000278e-02 +6.256109481915933523e-03 5.000000000000000278e-02 +6.451612903225806446e-03 5.000000000000000278e-02 +6.647116324535679369e-03 5.000000000000000278e-02 +6.842619745845552291e-03 5.000000000000000278e-02 +7.038123167155425214e-03 5.000000000000000278e-02 +7.233626588465298136e-03 5.000000000000000278e-02 +7.429130009775171059e-03 5.000000000000000278e-02 +7.624633431085043982e-03 5.000000000000000278e-02 +7.820136852394916904e-03 5.000000000000000278e-02 +8.015640273704788960e-03 5.000000000000000278e-02 +8.211143695014662749e-03 5.000000000000000278e-02 +8.406647116324536539e-03 5.000000000000000278e-02 +8.602150537634408595e-03 5.000000000000000278e-02 +8.797653958944280650e-03 5.000000000000000278e-02 +8.993157380254154440e-03 5.000000000000000278e-02 +9.188660801564028230e-03 5.000000000000000278e-02 +9.384164222873900285e-03 5.000000000000000278e-02 +9.579667644183772340e-03 5.000000000000000278e-02 +9.775171065493646130e-03 5.000000000000000278e-02 +9.970674486803519920e-03 5.000000000000000278e-02 +1.016617790811339198e-02 5.000000000000000278e-02 +1.036168132942326403e-02 5.000000000000000278e-02 +1.055718475073313782e-02 5.000000000000000278e-02 +1.075268817204301161e-02 5.000000000000000278e-02 +1.094819159335288367e-02 5.000000000000000278e-02 +1.114369501466275572e-02 5.000000000000000278e-02 +1.133919843597262951e-02 5.000000000000000278e-02 +1.153470185728250330e-02 5.000000000000000278e-02 +1.173020527859237536e-02 5.000000000000000278e-02 +1.192570869990224741e-02 5.000000000000000278e-02 +1.212121212121212120e-02 5.000000000000000278e-02 +1.231671554252199499e-02 5.000000000000000278e-02 +1.251221896383186705e-02 5.000000000000000278e-02 +1.270772238514173910e-02 5.000000000000000278e-02 +1.290322580645161289e-02 5.000000000000000278e-02 +1.309872922776148668e-02 5.000000000000000278e-02 +1.329423264907135874e-02 5.000000000000000278e-02 +1.348973607038123079e-02 5.000000000000000278e-02 +1.368523949169110458e-02 5.000000000000000278e-02 +1.388074291300097837e-02 5.000000000000000278e-02 +1.407624633431085043e-02 5.000000000000000278e-02 +1.427174975562072248e-02 5.000000000000000278e-02 +1.446725317693059627e-02 5.000000000000000278e-02 +1.466275659824047006e-02 5.000000000000000278e-02 +1.485826001955034212e-02 5.000000000000000278e-02 +1.505376344086021417e-02 5.000000000000000278e-02 +1.524926686217008796e-02 5.000000000000000278e-02 +1.544477028347996175e-02 5.000000000000000278e-02 +1.564027370478983381e-02 5.000000000000000278e-02 +1.583577712609970586e-02 5.000000000000000278e-02 +1.603128054740957792e-02 5.000000000000000278e-02 +1.622678396871945344e-02 5.000000000000000278e-02 +1.642228739002932550e-02 5.000000000000000278e-02 +1.661779081133919755e-02 5.000000000000000278e-02 +1.681329423264907308e-02 5.000000000000000278e-02 +1.700879765395894513e-02 5.000000000000000278e-02 +1.720430107526881719e-02 5.000000000000000278e-02 +1.739980449657868924e-02 5.000000000000000278e-02 +1.759530791788856130e-02 5.000000000000000278e-02 +1.779081133919843682e-02 5.000000000000000278e-02 +1.798631476050830888e-02 5.000000000000000278e-02 +1.818181818181818094e-02 5.000000000000000278e-02 +1.837732160312805646e-02 5.000000000000000278e-02 +1.857282502443792851e-02 5.000000000000000278e-02 +1.876832844574780057e-02 5.000000000000000278e-02 +1.896383186705767263e-02 5.000000000000000278e-02 +1.915933528836754468e-02 5.000000000000000278e-02 +1.935483870967742021e-02 5.000000000000000278e-02 +1.955034213098729226e-02 5.000000000000000278e-02 +1.974584555229716432e-02 5.000000000000000278e-02 +1.994134897360703984e-02 5.000000000000000278e-02 +2.013685239491691190e-02 5.000000000000000278e-02 +2.033235581622678395e-02 5.000000000000000278e-02 +2.052785923753665601e-02 5.000000000000000278e-02 +2.072336265884652806e-02 5.000000000000000278e-02 +2.091886608015640359e-02 5.000000000000000278e-02 +2.111436950146627564e-02 5.000000000000000278e-02 +2.130987292277614770e-02 5.000000000000000278e-02 +2.150537634408602322e-02 5.000000000000000278e-02 +2.170087976539589528e-02 5.000000000000000278e-02 +2.189638318670576733e-02 5.000000000000000278e-02 +2.209188660801563939e-02 5.000000000000000278e-02 +2.228739002932551144e-02 5.000000000000000278e-02 +2.248289345063538697e-02 5.000000000000000278e-02 +2.267839687194525902e-02 5.000000000000000278e-02 +2.287390029325513108e-02 5.000000000000000278e-02 +2.306940371456500660e-02 5.000000000000000278e-02 +2.326490713587487866e-02 5.000000000000000278e-02 +2.346041055718475071e-02 5.000000000000000278e-02 +2.365591397849462277e-02 5.000000000000000278e-02 +2.385141739980449482e-02 5.000000000000000278e-02 +2.404692082111437035e-02 5.000000000000000278e-02 +2.424242424242424240e-02 5.000000000000000278e-02 +2.443792766373411446e-02 5.000000000000000278e-02 +2.463343108504398998e-02 5.000000000000000278e-02 +2.482893450635386204e-02 5.000000000000000278e-02 +2.502443792766373409e-02 5.000000000000000278e-02 +2.521994134897360615e-02 5.000000000000000278e-02 +2.541544477028347820e-02 5.000000000000000278e-02 +2.561094819159335373e-02 5.000000000000000278e-02 +2.580645161290322578e-02 5.000000000000000278e-02 +2.600195503421309784e-02 5.000000000000000278e-02 +2.619745845552297336e-02 5.000000000000000278e-02 +2.639296187683284542e-02 5.000000000000000278e-02 +2.658846529814271747e-02 5.000000000000000278e-02 +2.678396871945258953e-02 5.000000000000000278e-02 +2.697947214076246158e-02 5.000000000000000278e-02 +2.717497556207233711e-02 5.000000000000000278e-02 +2.737047898338220916e-02 5.000000000000000278e-02 +2.756598240469208122e-02 5.000000000000000278e-02 +2.776148582600195674e-02 5.000000000000000278e-02 +2.795698924731182880e-02 5.000000000000000278e-02 +2.815249266862170086e-02 5.000000000000000278e-02 +2.834799608993157291e-02 5.000000000000000278e-02 +2.854349951124144497e-02 5.000000000000000278e-02 +2.873900293255132049e-02 5.000000000000000278e-02 +2.893450635386119255e-02 5.000000000000000278e-02 +2.913000977517106460e-02 5.000000000000000278e-02 +2.932551319648094013e-02 5.000000000000000278e-02 +2.952101661779081218e-02 5.000000000000000278e-02 +2.971652003910068424e-02 5.000000000000000278e-02 +2.991202346041055629e-02 5.000000000000000278e-02 +3.010752688172042835e-02 5.000000000000000278e-02 +3.030303030303030387e-02 5.000000000000000278e-02 +3.049853372434017593e-02 5.000000000000000278e-02 +3.069403714565004798e-02 5.000000000000000278e-02 +3.088954056695992351e-02 5.000000000000000278e-02 +3.108504398826979556e-02 5.000000000000000278e-02 +3.128054740957966762e-02 5.000000000000000278e-02 +3.147605083088954314e-02 5.000000000000000278e-02 +3.167155425219941173e-02 5.000000000000000278e-02 +3.186705767350928725e-02 5.000000000000000278e-02 +3.206256109481915584e-02 5.000000000000000278e-02 +3.225806451612903136e-02 5.000000000000000278e-02 +3.245356793743890689e-02 5.000000000000000278e-02 +3.264907135874877547e-02 5.000000000000000278e-02 +3.284457478005865100e-02 5.000000000000000278e-02 +3.304007820136852652e-02 5.000000000000000278e-02 +3.323558162267839511e-02 5.000000000000000278e-02 +3.343108504398827063e-02 5.000000000000000278e-02 +3.362658846529814616e-02 5.000000000000000278e-02 +3.382209188660801474e-02 5.000000000000000278e-02 +3.401759530791789027e-02 5.000000000000000278e-02 +3.421309872922775885e-02 5.000000000000000278e-02 +3.440860215053763438e-02 5.000000000000000278e-02 +3.460410557184750990e-02 5.000000000000000278e-02 +3.479960899315737849e-02 5.000000000000000278e-02 +3.499511241446725401e-02 5.000000000000000278e-02 +3.519061583577712260e-02 5.000000000000000278e-02 +3.538611925708699812e-02 5.000000000000000278e-02 +3.558162267839687365e-02 5.000000000000000278e-02 +3.577712609970674223e-02 5.000000000000000278e-02 +3.597262952101661776e-02 5.000000000000000278e-02 +3.616813294232649328e-02 5.000000000000000278e-02 +3.636363636363636187e-02 5.000000000000000278e-02 +3.655913978494623739e-02 5.000000000000000278e-02 +3.675464320625611292e-02 5.000000000000000278e-02 +3.695014662756598151e-02 5.000000000000000278e-02 +3.714565004887585703e-02 5.000000000000000278e-02 +3.734115347018572562e-02 5.000000000000000278e-02 +3.753665689149560114e-02 5.000000000000000278e-02 +3.773216031280547667e-02 5.000000000000000278e-02 +3.792766373411534525e-02 5.000000000000000278e-02 +3.812316715542522078e-02 5.000000000000000278e-02 +3.831867057673508936e-02 5.000000000000000278e-02 +3.851417399804496489e-02 5.000000000000000278e-02 +3.870967741935484041e-02 5.000000000000000278e-02 +3.890518084066470900e-02 5.000000000000000278e-02 +3.910068426197458452e-02 5.000000000000000278e-02 +3.929618768328446005e-02 5.000000000000000278e-02 +3.949169110459432863e-02 5.000000000000000278e-02 +3.968719452590420416e-02 5.000000000000000278e-02 +3.988269794721407968e-02 5.000000000000000278e-02 +4.007820136852394827e-02 5.000000000000000278e-02 +4.027370478983382379e-02 5.000000000000000278e-02 +4.046920821114369238e-02 5.000000000000000278e-02 +4.066471163245356790e-02 5.000000000000000278e-02 +4.086021505376344343e-02 5.000000000000000278e-02 +4.105571847507331201e-02 5.000000000000000278e-02 +4.125122189638318754e-02 5.000000000000000278e-02 +4.144672531769305612e-02 5.000000000000000278e-02 +4.164222873900293165e-02 5.000000000000000278e-02 +4.183773216031280717e-02 5.000000000000000278e-02 +4.203323558162267576e-02 5.000000000000000278e-02 +4.222873900293255128e-02 5.000000000000000278e-02 +4.242424242424242681e-02 5.000000000000000278e-02 +4.261974584555229539e-02 5.000000000000000278e-02 +4.281524926686217092e-02 5.000000000000000278e-02 +4.301075268817204644e-02 5.000000000000000278e-02 +4.320625610948191503e-02 5.000000000000000278e-02 +4.340175953079179055e-02 5.000000000000000278e-02 +4.359726295210165914e-02 5.000000000000000278e-02 +4.379276637341153466e-02 5.000000000000000278e-02 +4.398826979472141019e-02 5.000000000000000278e-02 +4.418377321603127877e-02 5.000000000000000278e-02 +4.437927663734115430e-02 5.000000000000000278e-02 +4.457478005865102288e-02 5.000000000000000278e-02 +4.477028347996089841e-02 5.000000000000000278e-02 +4.496578690127077393e-02 5.000000000000000278e-02 +4.516129032258064252e-02 5.000000000000000278e-02 +4.535679374389051804e-02 5.000000000000000278e-02 +4.555229716520039357e-02 5.000000000000000278e-02 +4.574780058651026216e-02 5.000000000000000278e-02 +4.594330400782013768e-02 5.000000000000000278e-02 +4.613880742913001320e-02 5.000000000000000278e-02 +4.633431085043988179e-02 5.000000000000000278e-02 +4.652981427174975732e-02 5.000000000000000278e-02 +4.672531769305962590e-02 5.000000000000000278e-02 +4.692082111436950143e-02 5.000000000000000278e-02 +4.711632453567937695e-02 5.000000000000000278e-02 +4.731182795698924554e-02 5.000000000000000278e-02 +4.750733137829912106e-02 5.000000000000000278e-02 +4.770283479960898965e-02 5.000000000000000278e-02 +4.789833822091886517e-02 5.000000000000000278e-02 +4.809384164222874070e-02 5.000000000000000278e-02 +4.828934506353860928e-02 5.000000000000000278e-02 +4.848484848484848481e-02 5.000000000000000278e-02 +4.868035190615836033e-02 5.000000000000000278e-02 +4.887585532746822892e-02 5.000000000000000278e-02 +4.907135874877810444e-02 5.000000000000000278e-02 +4.926686217008797997e-02 5.000000000000000278e-02 +4.946236559139784855e-02 5.000000000000000278e-02 +4.965786901270772408e-02 5.000000000000000278e-02 +4.985337243401759266e-02 5.000000000000000278e-02 +5.004887585532746819e-02 5.000000000000000278e-02 +5.024437927663734371e-02 5.000000000000000278e-02 +5.043988269794721230e-02 5.000000000000000278e-02 +5.063538611925708782e-02 5.000000000000000278e-02 +5.083088954056695641e-02 5.000000000000000278e-02 +5.102639296187683193e-02 5.000000000000000278e-02 +5.122189638318670746e-02 5.000000000000000278e-02 +5.141739980449657604e-02 5.000000000000000278e-02 +5.161290322580645157e-02 5.000000000000000278e-02 +5.180840664711632709e-02 5.000000000000000278e-02 +5.200391006842619568e-02 5.000000000000000278e-02 +5.219941348973607120e-02 5.000000000000000278e-02 +5.239491691104594673e-02 5.000000000000000278e-02 +5.259042033235581531e-02 5.000000000000000278e-02 +5.278592375366569084e-02 5.000000000000000278e-02 +5.298142717497555942e-02 5.000000000000000278e-02 +5.317693059628543495e-02 5.000000000000000278e-02 +5.337243401759531047e-02 5.000000000000000278e-02 +5.356793743890517906e-02 5.000000000000000278e-02 +5.376344086021505458e-02 5.000000000000000278e-02 +5.395894428152492317e-02 5.000000000000000278e-02 +5.415444770283479869e-02 5.000000000000000278e-02 +5.434995112414467422e-02 5.000000000000000278e-02 +5.454545454545454281e-02 5.000000000000000278e-02 +5.474095796676441833e-02 5.000000000000000278e-02 +5.493646138807429385e-02 5.000000000000000278e-02 +5.513196480938416244e-02 5.000000000000000278e-02 +5.532746823069403797e-02 5.000000000000000278e-02 +5.552297165200391349e-02 5.000000000000000278e-02 +5.571847507331378208e-02 5.000000000000000278e-02 +5.591397849462365760e-02 5.000000000000000278e-02 +5.610948191593352619e-02 5.000000000000000278e-02 +5.630498533724340171e-02 5.000000000000000278e-02 +5.650048875855327724e-02 5.000000000000000278e-02 +5.669599217986314582e-02 5.000000000000000278e-02 +5.689149560117302135e-02 5.000000000000000278e-02 +5.708699902248288993e-02 5.000000000000000278e-02 +5.728250244379276546e-02 5.000000000000000278e-02 +5.747800586510264098e-02 5.000000000000000278e-02 +5.767350928641250957e-02 5.000000000000000278e-02 +5.786901270772238509e-02 5.000000000000000278e-02 +5.806451612903226062e-02 5.000000000000000278e-02 +5.826001955034212920e-02 5.000000000000000278e-02 +5.845552297165200473e-02 5.000000000000000278e-02 +5.865102639296188025e-02 5.000000000000000278e-02 +5.884652981427174884e-02 5.000000000000000278e-02 +5.904203323558162436e-02 5.000000000000000278e-02 +5.923753665689149295e-02 5.000000000000000278e-02 +5.943304007820136847e-02 5.000000000000000278e-02 +5.962854349951124400e-02 5.000000000000000278e-02 +5.982404692082111258e-02 5.000000000000000278e-02 +6.001955034213098811e-02 5.000000000000000278e-02 +6.021505376344085669e-02 5.000000000000000278e-02 +6.041055718475073222e-02 5.000000000000000278e-02 +6.060606060606060774e-02 5.000000000000000278e-02 +6.080156402737047633e-02 5.000000000000000278e-02 +6.099706744868035185e-02 5.000000000000000278e-02 +6.119257086999022738e-02 5.000000000000000278e-02 +6.138807429130009596e-02 5.000000000000000278e-02 +6.158357771260997149e-02 5.000000000000000278e-02 +6.177908113391984701e-02 5.000000000000000278e-02 +6.197458455522971560e-02 5.000000000000000278e-02 +6.217008797653959112e-02 5.000000000000000278e-02 +6.236559139784945971e-02 5.000000000000000278e-02 +6.256109481915933523e-02 5.000000000000000278e-02 +6.275659824046921076e-02 5.000000000000000278e-02 +6.295210166177908628e-02 5.000000000000000278e-02 +6.314760508308894793e-02 5.000000000000000278e-02 +6.334310850439882346e-02 5.000000000000000278e-02 +6.353861192570869898e-02 5.000000000000000278e-02 +6.373411534701857450e-02 5.000000000000000278e-02 +6.392961876832845003e-02 5.000000000000000278e-02 +6.412512218963831168e-02 5.000000000000000278e-02 +6.432062561094818720e-02 5.000000000000000278e-02 +6.451612903225806273e-02 5.000000000000000278e-02 +6.471163245356793825e-02 5.000000000000000278e-02 +6.490713587487781377e-02 5.000000000000000278e-02 +6.510263929618768930e-02 5.000000000000000278e-02 +6.529814271749755095e-02 5.000000000000000278e-02 +6.549364613880742647e-02 5.000000000000000278e-02 +6.568914956011730200e-02 5.000000000000000278e-02 +6.588465298142717752e-02 5.000000000000000278e-02 +6.608015640273705305e-02 5.000000000000000278e-02 +6.627565982404691469e-02 5.000000000000000278e-02 +6.647116324535679022e-02 5.000000000000000278e-02 +6.666666666666666574e-02 5.000000000000000278e-02 +6.686217008797654127e-02 5.000000000000000278e-02 +6.705767350928641679e-02 5.000000000000000278e-02 +6.725317693059629232e-02 5.000000000000000278e-02 +6.744868035190615396e-02 5.000000000000000278e-02 +6.764418377321602949e-02 5.000000000000000278e-02 +6.783968719452590501e-02 5.000000000000000278e-02 +6.803519061583578054e-02 5.000000000000000278e-02 +6.823069403714565606e-02 5.000000000000000278e-02 +6.842619745845551771e-02 5.000000000000000278e-02 +6.862170087976539323e-02 5.000000000000000278e-02 +6.881720430107526876e-02 5.000000000000000278e-02 +6.901270772238514428e-02 5.000000000000000278e-02 +6.920821114369501981e-02 5.000000000000000278e-02 +6.940371456500488145e-02 5.000000000000000278e-02 +6.959921798631475698e-02 5.000000000000000278e-02 +6.979472140762463250e-02 5.000000000000000278e-02 +6.999022482893450803e-02 5.000000000000000278e-02 +7.018572825024438355e-02 5.000000000000000278e-02 +7.038123167155424520e-02 5.000000000000000278e-02 +7.057673509286412072e-02 5.000000000000000278e-02 +7.077223851417399625e-02 5.000000000000000278e-02 +7.096774193548387177e-02 5.000000000000000278e-02 +7.116324535679374730e-02 5.000000000000000278e-02 +7.135874877810362282e-02 5.000000000000000278e-02 +7.155425219941348447e-02 5.000000000000000278e-02 +7.174975562072335999e-02 5.000000000000000278e-02 +7.194525904203323552e-02 5.000000000000000278e-02 +7.214076246334311104e-02 5.000000000000000278e-02 +7.233626588465298657e-02 5.000000000000000278e-02 +7.253176930596284822e-02 5.000000000000000278e-02 +7.272727272727272374e-02 5.000000000000000278e-02 +7.292277614858259926e-02 5.000000000000000278e-02 +7.311827956989247479e-02 5.000000000000000278e-02 +7.331378299120235031e-02 5.000000000000000278e-02 +7.350928641251222584e-02 5.000000000000000278e-02 +7.370478983382208749e-02 5.000000000000000278e-02 +7.390029325513196301e-02 5.000000000000000278e-02 +7.409579667644183854e-02 5.000000000000000278e-02 +7.429130009775171406e-02 5.000000000000000278e-02 +7.448680351906158958e-02 5.000000000000000278e-02 +7.468230694037145123e-02 5.000000000000000278e-02 +7.487781036168132676e-02 5.000000000000000278e-02 +7.507331378299120228e-02 5.000000000000000278e-02 +7.526881720430107781e-02 5.000000000000000278e-02 +7.546432062561095333e-02 5.000000000000000278e-02 +7.565982404692081498e-02 5.000000000000000278e-02 +7.585532746823069050e-02 5.000000000000000278e-02 +7.605083088954056603e-02 5.000000000000000278e-02 +7.624633431085044155e-02 5.000000000000000278e-02 +7.644183773216031708e-02 5.000000000000000278e-02 +7.663734115347017872e-02 5.000000000000000278e-02 +7.683284457478005425e-02 5.000000000000000278e-02 +7.702834799608992977e-02 5.000000000000000278e-02 +7.722385141739980530e-02 5.000000000000000278e-02 +7.741935483870968082e-02 5.000000000000000278e-02 +7.761485826001955635e-02 5.000000000000000278e-02 +7.781036168132941799e-02 5.000000000000000278e-02 +7.800586510263929352e-02 5.000000000000000278e-02 +7.820136852394916904e-02 5.000000000000000278e-02 +7.839687194525904457e-02 5.000000000000000278e-02 +7.859237536656892009e-02 5.000000000000000278e-02 +7.878787878787878174e-02 5.000000000000000278e-02 +7.898338220918865726e-02 5.000000000000000278e-02 +7.917888563049853279e-02 5.000000000000000278e-02 +7.937438905180840831e-02 5.000000000000000278e-02 +7.956989247311828384e-02 5.000000000000000278e-02 +7.976539589442815936e-02 5.000000000000000278e-02 +7.996089931573802101e-02 5.000000000000000278e-02 +8.015640273704789653e-02 5.000000000000000278e-02 +8.035190615835777206e-02 5.000000000000000278e-02 +8.054740957966764758e-02 5.000000000000000278e-02 +8.074291300097752311e-02 5.000000000000000278e-02 +8.093841642228738475e-02 5.000000000000000278e-02 +8.113391984359726028e-02 5.000000000000000278e-02 +8.132942326490713580e-02 5.000000000000000278e-02 +8.152492668621701133e-02 5.000000000000000278e-02 +8.172043010752688685e-02 5.000000000000000278e-02 +8.191593352883674850e-02 5.000000000000000278e-02 +8.211143695014662403e-02 5.000000000000000278e-02 +8.230694037145649955e-02 5.000000000000000278e-02 +8.250244379276637507e-02 5.000000000000000278e-02 +8.269794721407625060e-02 5.000000000000000278e-02 +8.289345063538611225e-02 5.000000000000000278e-02 +8.308895405669598777e-02 5.000000000000000278e-02 +8.328445747800586330e-02 5.000000000000000278e-02 +8.347996089931573882e-02 5.000000000000000278e-02 +8.367546432062561435e-02 5.000000000000000278e-02 +8.387096774193548987e-02 5.000000000000000278e-02 +8.406647116324535152e-02 5.000000000000000278e-02 +8.426197458455522704e-02 5.000000000000000278e-02 +8.445747800586510257e-02 5.000000000000000278e-02 +8.465298142717497809e-02 5.000000000000000278e-02 +8.484848484848485362e-02 5.000000000000000278e-02 +8.504398826979471526e-02 5.000000000000000278e-02 +8.523949169110459079e-02 5.000000000000000278e-02 +8.543499511241446631e-02 5.000000000000000278e-02 +8.563049853372434184e-02 5.000000000000000278e-02 +8.582600195503421736e-02 5.000000000000000278e-02 +8.602150537634409289e-02 5.000000000000000278e-02 +8.621700879765395453e-02 5.000000000000000278e-02 +8.641251221896383006e-02 5.000000000000000278e-02 +8.660801564027370558e-02 5.000000000000000278e-02 +8.680351906158358111e-02 5.000000000000000278e-02 +8.699902248289345663e-02 5.000000000000000278e-02 +8.719452590420331828e-02 5.000000000000000278e-02 +8.739002932551319380e-02 5.000000000000000278e-02 +8.758553274682306933e-02 5.000000000000000278e-02 +8.778103616813294485e-02 5.000000000000000278e-02 +8.797653958944282038e-02 5.000000000000000278e-02 +8.817204301075268202e-02 5.000000000000000278e-02 +8.836754643206255755e-02 5.000000000000000278e-02 +8.856304985337243307e-02 5.000000000000000278e-02 +8.875855327468230860e-02 5.000000000000000278e-02 +8.895405669599218412e-02 5.000000000000000278e-02 +8.914956011730204577e-02 5.000000000000000278e-02 +8.934506353861192129e-02 5.000000000000000278e-02 +8.954056695992179682e-02 5.000000000000000278e-02 +8.973607038123167234e-02 5.000000000000000278e-02 +8.993157380254154787e-02 5.000000000000000278e-02 +9.012707722385142339e-02 5.000000000000000278e-02 +9.032258064516128504e-02 5.000000000000000278e-02 +9.051808406647116056e-02 5.000000000000000278e-02 +9.071358748778103609e-02 5.000000000000000278e-02 +9.090909090909091161e-02 5.000000000000000278e-02 +9.110459433040078714e-02 5.000000000000000278e-02 +9.130009775171064879e-02 5.000000000000000278e-02 +9.149560117302052431e-02 5.000000000000000278e-02 +9.169110459433039984e-02 5.000000000000000278e-02 +9.188660801564027536e-02 5.000000000000000278e-02 +9.208211143695015088e-02 5.000000000000000278e-02 +9.227761485826002641e-02 5.000000000000000278e-02 +9.247311827956988806e-02 5.000000000000000278e-02 +9.266862170087976358e-02 5.000000000000000278e-02 +9.286412512218963911e-02 5.000000000000000278e-02 +9.305962854349951463e-02 5.000000000000000278e-02 +9.325513196480939015e-02 5.000000000000000278e-02 +9.345063538611925180e-02 5.000000000000000278e-02 +9.364613880742912733e-02 5.000000000000000278e-02 +9.384164222873900285e-02 5.000000000000000278e-02 +9.403714565004887838e-02 5.000000000000000278e-02 +9.423264907135875390e-02 5.000000000000000278e-02 +9.442815249266861555e-02 5.000000000000000278e-02 +9.462365591397849107e-02 5.000000000000000278e-02 +9.481915933528836660e-02 5.000000000000000278e-02 +9.501466275659824212e-02 5.000000000000000278e-02 +9.521016617790811765e-02 5.000000000000000278e-02 +9.540566959921797929e-02 5.000000000000000278e-02 +9.560117302052785482e-02 5.000000000000000278e-02 +9.579667644183773034e-02 5.000000000000000278e-02 +9.599217986314760587e-02 5.000000000000000278e-02 +9.618768328445748139e-02 5.000000000000000278e-02 +9.638318670576735692e-02 5.000000000000000278e-02 +9.657869012707721856e-02 5.000000000000000278e-02 +9.677419354838709409e-02 5.000000000000000278e-02 +9.696969696969696961e-02 5.000000000000000278e-02 +9.716520039100684514e-02 5.000000000000000278e-02 +9.736070381231672066e-02 5.000000000000000278e-02 +9.755620723362658231e-02 5.000000000000000278e-02 +9.775171065493645783e-02 5.000000000000000278e-02 +9.794721407624633336e-02 5.000000000000000278e-02 +9.814271749755620888e-02 5.000000000000000278e-02 +9.833822091886608441e-02 5.000000000000000278e-02 +9.853372434017595993e-02 5.000000000000000278e-02 +9.872922776148582158e-02 5.000000000000000278e-02 +9.892473118279569710e-02 5.000000000000000278e-02 +9.912023460410557263e-02 5.000000000000000278e-02 +9.931573802541544815e-02 5.000000000000000278e-02 +9.951124144672532368e-02 5.000000000000000278e-02 +9.970674486803518533e-02 5.000000000000000278e-02 +9.990224828934506085e-02 5.000000000000000278e-02 +1.000977517106549364e-01 5.000000000000000278e-02 +1.002932551319648119e-01 5.000000000000000278e-02 +1.004887585532746874e-01 5.000000000000000278e-02 +1.006842619745845491e-01 5.000000000000000278e-02 +1.008797653958944246e-01 5.000000000000000278e-02 +1.010752688172043001e-01 5.000000000000000278e-02 +1.012707722385141756e-01 5.000000000000000278e-02 +1.014662756598240512e-01 5.000000000000000278e-02 +1.016617790811339128e-01 5.000000000000000278e-02 +1.018572825024437883e-01 5.000000000000000278e-02 +1.020527859237536639e-01 5.000000000000000278e-02 +1.022482893450635394e-01 5.000000000000000278e-02 +1.024437927663734149e-01 5.000000000000000278e-02 +1.026392961876832904e-01 5.000000000000000278e-02 +1.028347996089931521e-01 5.000000000000000278e-02 +1.030303030303030276e-01 5.000000000000000278e-02 +1.032258064516129031e-01 5.000000000000000278e-02 +1.034213098729227787e-01 5.000000000000000278e-02 +1.036168132942326542e-01 5.000000000000000278e-02 +1.038123167155425158e-01 5.000000000000000278e-02 +1.040078201368523914e-01 5.000000000000000278e-02 +1.042033235581622669e-01 5.000000000000000278e-02 +1.043988269794721424e-01 5.000000000000000278e-02 +1.045943304007820179e-01 5.000000000000000278e-02 +1.047898338220918935e-01 5.000000000000000278e-02 +1.049853372434017551e-01 5.000000000000000278e-02 +1.051808406647116306e-01 5.000000000000000278e-02 +1.053763440860215062e-01 5.000000000000000278e-02 +1.055718475073313817e-01 5.000000000000000278e-02 +1.057673509286412572e-01 5.000000000000000278e-02 +1.059628543499511188e-01 5.000000000000000278e-02 +1.061583577712609944e-01 5.000000000000000278e-02 +1.063538611925708699e-01 5.000000000000000278e-02 +1.065493646138807454e-01 5.000000000000000278e-02 +1.067448680351906209e-01 5.000000000000000278e-02 +1.069403714565004826e-01 5.000000000000000278e-02 +1.071358748778103581e-01 5.000000000000000278e-02 +1.073313782991202336e-01 5.000000000000000278e-02 +1.075268817204301092e-01 5.000000000000000278e-02 +1.077223851417399847e-01 5.000000000000000278e-02 +1.079178885630498463e-01 5.000000000000000278e-02 +1.081133919843597219e-01 5.000000000000000278e-02 +1.083088954056695974e-01 5.000000000000000278e-02 +1.085043988269794729e-01 5.000000000000000278e-02 +1.086999022482893484e-01 5.000000000000000278e-02 +1.088954056695992240e-01 5.000000000000000278e-02 +1.090909090909090856e-01 5.000000000000000278e-02 +1.092864125122189611e-01 5.000000000000000278e-02 +1.094819159335288367e-01 5.000000000000000278e-02 +1.096774193548387122e-01 5.000000000000000278e-02 +1.098729227761485877e-01 5.000000000000000278e-02 +1.100684261974584494e-01 5.000000000000000278e-02 +1.102639296187683249e-01 5.000000000000000278e-02 +1.104594330400782004e-01 5.000000000000000278e-02 +1.106549364613880759e-01 5.000000000000000278e-02 +1.108504398826979515e-01 5.000000000000000278e-02 +1.110459433040078270e-01 5.000000000000000278e-02 +1.112414467253176886e-01 5.000000000000000278e-02 +1.114369501466275642e-01 5.000000000000000278e-02 +1.116324535679374397e-01 5.000000000000000278e-02 +1.118279569892473152e-01 5.000000000000000278e-02 +1.120234604105571907e-01 5.000000000000000278e-02 +1.122189638318670524e-01 5.000000000000000278e-02 +1.124144672531769279e-01 5.000000000000000278e-02 +1.126099706744868034e-01 5.000000000000000278e-02 +1.128054740957966789e-01 5.000000000000000278e-02 +1.130009775171065545e-01 5.000000000000000278e-02 +1.131964809384164161e-01 5.000000000000000278e-02 +1.133919843597262916e-01 5.000000000000000278e-02 +1.135874877810361672e-01 5.000000000000000278e-02 +1.137829912023460427e-01 5.000000000000000278e-02 +1.139784946236559182e-01 5.000000000000000278e-02 +1.141739980449657799e-01 5.000000000000000278e-02 +1.143695014662756554e-01 5.000000000000000278e-02 +1.145650048875855309e-01 5.000000000000000278e-02 +1.147605083088954064e-01 5.000000000000000278e-02 +1.149560117302052820e-01 5.000000000000000278e-02 +1.151515151515151575e-01 5.000000000000000278e-02 +1.153470185728250191e-01 5.000000000000000278e-02 +1.155425219941348947e-01 5.000000000000000278e-02 +1.157380254154447702e-01 5.000000000000000278e-02 +1.159335288367546457e-01 5.000000000000000278e-02 +1.161290322580645212e-01 5.000000000000000278e-02 +1.163245356793743829e-01 5.000000000000000278e-02 +1.165200391006842584e-01 5.000000000000000278e-02 +1.167155425219941339e-01 5.000000000000000278e-02 +1.169110459433040095e-01 5.000000000000000278e-02 +1.171065493646138850e-01 5.000000000000000278e-02 +1.173020527859237605e-01 5.000000000000000278e-02 +1.174975562072336221e-01 5.000000000000000278e-02 +1.176930596285434977e-01 5.000000000000000278e-02 +1.178885630498533732e-01 5.000000000000000278e-02 +1.180840664711632487e-01 5.000000000000000278e-02 +1.182795698924731242e-01 5.000000000000000278e-02 +1.184750733137829859e-01 5.000000000000000278e-02 +1.186705767350928614e-01 5.000000000000000278e-02 +1.188660801564027369e-01 5.000000000000000278e-02 +1.190615835777126125e-01 5.000000000000000278e-02 +1.192570869990224880e-01 5.000000000000000278e-02 +1.194525904203323496e-01 5.000000000000000278e-02 +1.196480938416422252e-01 5.000000000000000278e-02 +1.198435972629521007e-01 5.000000000000000278e-02 +1.200391006842619762e-01 5.000000000000000278e-02 +1.202346041055718517e-01 5.000000000000000278e-02 +1.204301075268817134e-01 5.000000000000000278e-02 +1.206256109481915889e-01 5.000000000000000278e-02 +1.208211143695014644e-01 5.000000000000000278e-02 +1.210166177908113400e-01 5.000000000000000278e-02 +1.212121212121212155e-01 5.000000000000000278e-02 +1.214076246334310910e-01 5.000000000000000278e-02 +1.216031280547409527e-01 5.000000000000000278e-02 +1.217986314760508282e-01 5.000000000000000278e-02 +1.219941348973607037e-01 5.000000000000000278e-02 +1.221896383186705792e-01 5.000000000000000278e-02 +1.223851417399804548e-01 5.000000000000000278e-02 +1.225806451612903164e-01 5.000000000000000278e-02 +1.227761485826001919e-01 5.000000000000000278e-02 +1.229716520039100675e-01 5.000000000000000278e-02 +1.231671554252199430e-01 5.000000000000000278e-02 +1.233626588465298185e-01 5.000000000000000278e-02 +1.235581622678396940e-01 5.000000000000000278e-02 +1.237536656891495557e-01 5.000000000000000278e-02 +1.239491691104594312e-01 5.000000000000000278e-02 +1.241446725317693067e-01 5.000000000000000278e-02 +1.243401759530791822e-01 5.000000000000000278e-02 +1.245356793743890578e-01 5.000000000000000278e-02 +1.247311827956989194e-01 5.000000000000000278e-02 +1.249266862170087949e-01 5.000000000000000278e-02 +1.251221896383186705e-01 5.000000000000000278e-02 +1.253176930596285321e-01 5.000000000000000278e-02 +1.255131964809384215e-01 5.000000000000000278e-02 +1.257086999022482832e-01 5.000000000000000278e-02 +1.259042033235581726e-01 5.000000000000000278e-02 +1.260997067448680342e-01 5.000000000000000278e-02 +1.262952101661778959e-01 5.000000000000000278e-02 +1.264907135874877853e-01 5.000000000000000278e-02 +1.266862170087976469e-01 5.000000000000000278e-02 +1.268817204301075363e-01 5.000000000000000278e-02 +1.270772238514173980e-01 5.000000000000000278e-02 +1.272727272727272596e-01 5.000000000000000278e-02 +1.274682306940371490e-01 5.000000000000000278e-02 +1.276637341153470107e-01 5.000000000000000278e-02 +1.278592375366569001e-01 5.000000000000000278e-02 +1.280547409579667617e-01 5.000000000000000278e-02 +1.282502443792766234e-01 5.000000000000000278e-02 +1.284457478005865128e-01 5.000000000000000278e-02 +1.286412512218963744e-01 5.000000000000000278e-02 +1.288367546432062638e-01 5.000000000000000278e-02 +1.290322580645161255e-01 5.000000000000000278e-02 +1.292277614858260149e-01 5.000000000000000278e-02 +1.294232649071358765e-01 5.000000000000000278e-02 +1.296187683284457381e-01 5.000000000000000278e-02 +1.298142717497556275e-01 5.000000000000000278e-02 +1.300097751710654892e-01 5.000000000000000278e-02 +1.302052785923753786e-01 5.000000000000000278e-02 +1.304007820136852402e-01 5.000000000000000278e-02 +1.305962854349951019e-01 5.000000000000000278e-02 +1.307917888563049913e-01 5.000000000000000278e-02 +1.309872922776148529e-01 5.000000000000000278e-02 +1.311827956989247423e-01 5.000000000000000278e-02 +1.313782991202346040e-01 5.000000000000000278e-02 +1.315738025415444656e-01 5.000000000000000278e-02 +1.317693059628543550e-01 5.000000000000000278e-02 +1.319648093841642167e-01 5.000000000000000278e-02 +1.321603128054741061e-01 5.000000000000000278e-02 +1.323558162267839677e-01 5.000000000000000278e-02 +1.325513196480938294e-01 5.000000000000000278e-02 +1.327468230694037188e-01 5.000000000000000278e-02 +1.329423264907135804e-01 5.000000000000000278e-02 +1.331378299120234698e-01 5.000000000000000278e-02 +1.333333333333333315e-01 5.000000000000000278e-02 +1.335288367546431931e-01 5.000000000000000278e-02 +1.337243401759530825e-01 5.000000000000000278e-02 +1.339198435972629442e-01 5.000000000000000278e-02 +1.341153470185728336e-01 5.000000000000000278e-02 +1.343108504398826952e-01 5.000000000000000278e-02 +1.345063538611925846e-01 5.000000000000000278e-02 +1.347018572825024463e-01 5.000000000000000278e-02 +1.348973607038123079e-01 5.000000000000000278e-02 +1.350928641251221973e-01 5.000000000000000278e-02 +1.352883675464320590e-01 5.000000000000000278e-02 +1.354838709677419484e-01 5.000000000000000278e-02 +1.356793743890518100e-01 5.000000000000000278e-02 +1.358748778103616717e-01 5.000000000000000278e-02 +1.360703812316715611e-01 5.000000000000000278e-02 +1.362658846529814227e-01 5.000000000000000278e-02 +1.364613880742913121e-01 5.000000000000000278e-02 +1.366568914956011738e-01 5.000000000000000278e-02 +1.368523949169110354e-01 5.000000000000000278e-02 +1.370478983382209248e-01 5.000000000000000278e-02 +1.372434017595307865e-01 5.000000000000000278e-02 +1.374389051808406759e-01 5.000000000000000278e-02 +1.376344086021505375e-01 5.000000000000000278e-02 +1.378299120234603992e-01 5.000000000000000278e-02 +1.380254154447702886e-01 5.000000000000000278e-02 +1.382209188660801502e-01 5.000000000000000278e-02 +1.384164222873900396e-01 5.000000000000000278e-02 +1.386119257086999013e-01 5.000000000000000278e-02 +1.388074291300097629e-01 5.000000000000000278e-02 +1.390029325513196523e-01 5.000000000000000278e-02 +1.391984359726295140e-01 5.000000000000000278e-02 +1.393939393939394034e-01 5.000000000000000278e-02 +1.395894428152492650e-01 5.000000000000000278e-02 +1.397849462365591267e-01 5.000000000000000278e-02 +1.399804496578690161e-01 5.000000000000000278e-02 +1.401759530791788777e-01 5.000000000000000278e-02 +1.403714565004887671e-01 5.000000000000000278e-02 +1.405669599217986288e-01 5.000000000000000278e-02 +1.407624633431084904e-01 5.000000000000000278e-02 +1.409579667644183798e-01 5.000000000000000278e-02 +1.411534701857282414e-01 5.000000000000000278e-02 +1.413489736070381309e-01 5.000000000000000278e-02 +1.415444770283479925e-01 5.000000000000000278e-02 +1.417399804496578819e-01 5.000000000000000278e-02 +1.419354838709677435e-01 5.000000000000000278e-02 +1.421309872922776052e-01 5.000000000000000278e-02 +1.423264907135874946e-01 5.000000000000000278e-02 +1.425219941348973562e-01 5.000000000000000278e-02 +1.427174975562072456e-01 5.000000000000000278e-02 +1.429130009775171073e-01 5.000000000000000278e-02 +1.431085043988269689e-01 5.000000000000000278e-02 +1.433040078201368583e-01 5.000000000000000278e-02 +1.434995112414467200e-01 5.000000000000000278e-02 +1.436950146627566094e-01 5.000000000000000278e-02 +1.438905180840664710e-01 5.000000000000000278e-02 +1.440860215053763327e-01 5.000000000000000278e-02 +1.442815249266862221e-01 5.000000000000000278e-02 +1.444770283479960837e-01 5.000000000000000278e-02 +1.446725317693059731e-01 5.000000000000000278e-02 +1.448680351906158348e-01 5.000000000000000278e-02 +1.450635386119256964e-01 5.000000000000000278e-02 +1.452590420332355858e-01 5.000000000000000278e-02 +1.454545454545454475e-01 5.000000000000000278e-02 +1.456500488758553369e-01 5.000000000000000278e-02 +1.458455522971651985e-01 5.000000000000000278e-02 +1.460410557184750602e-01 5.000000000000000278e-02 +1.462365591397849496e-01 5.000000000000000278e-02 +1.464320625610948112e-01 5.000000000000000278e-02 +1.466275659824047006e-01 5.000000000000000278e-02 +1.468230694037145623e-01 5.000000000000000278e-02 +1.470185728250244517e-01 5.000000000000000278e-02 +1.472140762463343133e-01 5.000000000000000278e-02 +1.474095796676441750e-01 5.000000000000000278e-02 +1.476050830889540644e-01 5.000000000000000278e-02 +1.478005865102639260e-01 5.000000000000000278e-02 +1.479960899315738154e-01 5.000000000000000278e-02 +1.481915933528836771e-01 5.000000000000000278e-02 +1.483870967741935387e-01 5.000000000000000278e-02 +1.485826001955034281e-01 5.000000000000000278e-02 +1.487781036168132898e-01 5.000000000000000278e-02 +1.489736070381231792e-01 5.000000000000000278e-02 +1.491691104594330408e-01 5.000000000000000278e-02 +1.493646138807429025e-01 5.000000000000000278e-02 +1.495601173020527919e-01 5.000000000000000278e-02 +1.497556207233626535e-01 5.000000000000000278e-02 +1.499511241446725429e-01 5.000000000000000278e-02 +1.501466275659824046e-01 5.000000000000000278e-02 +1.503421309872922662e-01 5.000000000000000278e-02 +1.505376344086021556e-01 5.000000000000000278e-02 +1.507331378299120173e-01 5.000000000000000278e-02 +1.509286412512219067e-01 5.000000000000000278e-02 +1.511241446725317683e-01 5.000000000000000278e-02 +1.513196480938416300e-01 5.000000000000000278e-02 +1.515151515151515194e-01 5.000000000000000278e-02 +1.517106549364613810e-01 5.000000000000000278e-02 +1.519061583577712704e-01 5.000000000000000278e-02 +1.521016617790811321e-01 5.000000000000000278e-02 +1.522971652003909937e-01 5.000000000000000278e-02 +1.524926686217008831e-01 5.000000000000000278e-02 +1.526881720430107447e-01 5.000000000000000278e-02 +1.528836754643206342e-01 5.000000000000000278e-02 +1.530791788856304958e-01 5.000000000000000278e-02 +1.532746823069403574e-01 5.000000000000000278e-02 +1.534701857282502468e-01 5.000000000000000278e-02 +1.536656891495601085e-01 5.000000000000000278e-02 +1.538611925708699979e-01 5.000000000000000278e-02 +1.540566959921798595e-01 5.000000000000000278e-02 +1.542521994134897489e-01 5.000000000000000278e-02 +1.544477028347996106e-01 5.000000000000000278e-02 +1.546432062561094722e-01 5.000000000000000278e-02 +1.548387096774193616e-01 5.000000000000000278e-02 +1.550342130987292233e-01 5.000000000000000278e-02 +1.552297165200391127e-01 5.000000000000000278e-02 +1.554252199413489743e-01 5.000000000000000278e-02 +1.556207233626588360e-01 5.000000000000000278e-02 +1.558162267839687254e-01 5.000000000000000278e-02 +1.560117302052785870e-01 5.000000000000000278e-02 +1.562072336265884764e-01 5.000000000000000278e-02 +1.564027370478983381e-01 5.000000000000000278e-02 +1.565982404692081997e-01 5.000000000000000278e-02 +1.567937438905180891e-01 5.000000000000000278e-02 +1.569892473118279508e-01 5.000000000000000278e-02 +1.571847507331378402e-01 5.000000000000000278e-02 +1.573802541544477018e-01 5.000000000000000278e-02 +1.575757575757575635e-01 5.000000000000000278e-02 +1.577712609970674529e-01 5.000000000000000278e-02 +1.579667644183773145e-01 5.000000000000000278e-02 +1.581622678396872039e-01 5.000000000000000278e-02 +1.583577712609970656e-01 5.000000000000000278e-02 +1.585532746823069272e-01 5.000000000000000278e-02 +1.587487781036168166e-01 5.000000000000000278e-02 +1.589442815249266783e-01 5.000000000000000278e-02 +1.591397849462365677e-01 5.000000000000000278e-02 +1.593352883675464293e-01 5.000000000000000278e-02 +1.595307917888563187e-01 5.000000000000000278e-02 +1.597262952101661804e-01 5.000000000000000278e-02 +1.599217986314760420e-01 5.000000000000000278e-02 +1.601173020527859314e-01 5.000000000000000278e-02 +1.603128054740957931e-01 5.000000000000000278e-02 +1.605083088954056825e-01 5.000000000000000278e-02 +1.607038123167155441e-01 5.000000000000000278e-02 +1.608993157380254058e-01 5.000000000000000278e-02 +1.610948191593352952e-01 5.000000000000000278e-02 +1.612903225806451568e-01 5.000000000000000278e-02 +1.614858260019550462e-01 5.000000000000000278e-02 +1.616813294232649079e-01 5.000000000000000278e-02 +1.618768328445747695e-01 5.000000000000000278e-02 +1.620723362658846589e-01 5.000000000000000278e-02 +1.622678396871945206e-01 5.000000000000000278e-02 +1.624633431085044100e-01 5.000000000000000278e-02 +1.626588465298142716e-01 5.000000000000000278e-02 +1.628543499511241333e-01 5.000000000000000278e-02 +1.630498533724340227e-01 5.000000000000000278e-02 +1.632453567937438843e-01 5.000000000000000278e-02 +1.634408602150537737e-01 5.000000000000000278e-02 +1.636363636363636354e-01 5.000000000000000278e-02 +1.638318670576734970e-01 5.000000000000000278e-02 +1.640273704789833864e-01 5.000000000000000278e-02 +1.642228739002932481e-01 5.000000000000000278e-02 +1.644183773216031375e-01 5.000000000000000278e-02 +1.646138807429129991e-01 5.000000000000000278e-02 +1.648093841642228607e-01 5.000000000000000278e-02 +1.650048875855327501e-01 5.000000000000000278e-02 +1.652003910068426118e-01 5.000000000000000278e-02 +1.653958944281525012e-01 5.000000000000000278e-02 +1.655913978494623628e-01 5.000000000000000278e-02 +1.657869012707722245e-01 5.000000000000000278e-02 +1.659824046920821139e-01 5.000000000000000278e-02 +1.661779081133919755e-01 5.000000000000000278e-02 +1.663734115347018649e-01 5.000000000000000278e-02 +1.665689149560117266e-01 5.000000000000000278e-02 +1.667644183773216160e-01 5.000000000000000278e-02 +1.669599217986314776e-01 5.000000000000000278e-02 +1.671554252199413393e-01 5.000000000000000278e-02 +1.673509286412512287e-01 5.000000000000000278e-02 +1.675464320625610903e-01 5.000000000000000278e-02 +1.677419354838709797e-01 5.000000000000000278e-02 +1.679374389051808414e-01 5.000000000000000278e-02 +1.681329423264907030e-01 5.000000000000000278e-02 +1.683284457478005924e-01 5.000000000000000278e-02 +1.685239491691104541e-01 5.000000000000000278e-02 +1.687194525904203435e-01 5.000000000000000278e-02 +1.689149560117302051e-01 5.000000000000000278e-02 +1.691104594330400668e-01 5.000000000000000278e-02 +1.693059628543499562e-01 5.000000000000000278e-02 +1.695014662756598178e-01 5.000000000000000278e-02 +1.696969696969697072e-01 5.000000000000000278e-02 +1.698924731182795689e-01 5.000000000000000278e-02 +1.700879765395894305e-01 5.000000000000000278e-02 +1.702834799608993199e-01 5.000000000000000278e-02 +1.704789833822091816e-01 5.000000000000000278e-02 +1.706744868035190710e-01 5.000000000000000278e-02 +1.708699902248289326e-01 5.000000000000000278e-02 +1.710654936461387943e-01 5.000000000000000278e-02 +1.712609970674486837e-01 5.000000000000000278e-02 +1.714565004887585453e-01 5.000000000000000278e-02 +1.716520039100684347e-01 5.000000000000000278e-02 +1.718475073313782964e-01 5.000000000000000278e-02 +1.720430107526881858e-01 5.000000000000000278e-02 +1.722385141739980474e-01 5.000000000000000278e-02 +1.724340175953079091e-01 5.000000000000000278e-02 +1.726295210166177985e-01 5.000000000000000278e-02 +1.728250244379276601e-01 5.000000000000000278e-02 +1.730205278592375495e-01 5.000000000000000278e-02 +1.732160312805474112e-01 5.000000000000000278e-02 +1.734115347018572728e-01 5.000000000000000278e-02 +1.736070381231671622e-01 5.000000000000000278e-02 +1.738025415444770239e-01 5.000000000000000278e-02 +1.739980449657869133e-01 5.000000000000000278e-02 +1.741935483870967749e-01 5.000000000000000278e-02 +1.743890518084066366e-01 5.000000000000000278e-02 +1.745845552297165260e-01 5.000000000000000278e-02 +1.747800586510263876e-01 5.000000000000000278e-02 +1.749755620723362770e-01 5.000000000000000278e-02 +1.751710654936461387e-01 5.000000000000000278e-02 +1.753665689149560003e-01 5.000000000000000278e-02 +1.755620723362658897e-01 5.000000000000000278e-02 +1.757575757575757514e-01 5.000000000000000278e-02 +1.759530791788856408e-01 5.000000000000000278e-02 +1.761485826001955024e-01 5.000000000000000278e-02 +1.763440860215053640e-01 5.000000000000000278e-02 +1.765395894428152535e-01 5.000000000000000278e-02 +1.767350928641251151e-01 5.000000000000000278e-02 +1.769305962854350045e-01 5.000000000000000278e-02 +1.771260997067448661e-01 5.000000000000000278e-02 +1.773216031280547278e-01 5.000000000000000278e-02 +1.775171065493646172e-01 5.000000000000000278e-02 +1.777126099706744788e-01 5.000000000000000278e-02 +1.779081133919843682e-01 5.000000000000000278e-02 +1.781036168132942299e-01 5.000000000000000278e-02 +1.782991202346040915e-01 5.000000000000000278e-02 +1.784946236559139809e-01 5.000000000000000278e-02 +1.786901270772238426e-01 5.000000000000000278e-02 +1.788856304985337320e-01 5.000000000000000278e-02 +1.790811339198435936e-01 5.000000000000000278e-02 +1.792766373411534830e-01 5.000000000000000278e-02 +1.794721407624633447e-01 5.000000000000000278e-02 +1.796676441837732063e-01 5.000000000000000278e-02 +1.798631476050830957e-01 5.000000000000000278e-02 +1.800586510263929574e-01 5.000000000000000278e-02 +1.802541544477028468e-01 5.000000000000000278e-02 +1.804496578690127084e-01 5.000000000000000278e-02 +1.806451612903225701e-01 5.000000000000000278e-02 +1.808406647116324595e-01 5.000000000000000278e-02 +1.810361681329423211e-01 5.000000000000000278e-02 +1.812316715542522105e-01 5.000000000000000278e-02 +1.814271749755620722e-01 5.000000000000000278e-02 +1.816226783968719338e-01 5.000000000000000278e-02 +1.818181818181818232e-01 5.000000000000000278e-02 +1.820136852394916849e-01 5.000000000000000278e-02 +1.822091886608015743e-01 5.000000000000000278e-02 +1.824046920821114359e-01 5.000000000000000278e-02 +1.826001955034212976e-01 5.000000000000000278e-02 +1.827956989247311870e-01 5.000000000000000278e-02 +1.829912023460410486e-01 5.000000000000000278e-02 +1.831867057673509380e-01 5.000000000000000278e-02 +1.833822091886607997e-01 5.000000000000000278e-02 +1.835777126099706613e-01 5.000000000000000278e-02 +1.837732160312805507e-01 5.000000000000000278e-02 +1.839687194525904124e-01 5.000000000000000278e-02 +1.841642228739003018e-01 5.000000000000000278e-02 +1.843597262952101634e-01 5.000000000000000278e-02 +1.845552297165200528e-01 5.000000000000000278e-02 +1.847507331378299145e-01 5.000000000000000278e-02 +1.849462365591397761e-01 5.000000000000000278e-02 +1.851417399804496655e-01 5.000000000000000278e-02 +1.853372434017595272e-01 5.000000000000000278e-02 +1.855327468230694166e-01 5.000000000000000278e-02 +1.857282502443792782e-01 5.000000000000000278e-02 +1.859237536656891399e-01 5.000000000000000278e-02 +1.861192570869990293e-01 5.000000000000000278e-02 +1.863147605083088909e-01 5.000000000000000278e-02 +1.865102639296187803e-01 5.000000000000000278e-02 +1.867057673509286420e-01 5.000000000000000278e-02 +1.869012707722385036e-01 5.000000000000000278e-02 +1.870967741935483930e-01 5.000000000000000278e-02 +1.872922776148582547e-01 5.000000000000000278e-02 +1.874877810361681441e-01 5.000000000000000278e-02 +1.876832844574780057e-01 5.000000000000000278e-02 +1.878787878787878673e-01 5.000000000000000278e-02 +1.880742913000977568e-01 5.000000000000000278e-02 +1.882697947214076184e-01 5.000000000000000278e-02 +1.884652981427175078e-01 5.000000000000000278e-02 +1.886608015640273694e-01 5.000000000000000278e-02 +1.888563049853372311e-01 5.000000000000000278e-02 +1.890518084066471205e-01 5.000000000000000278e-02 +1.892473118279569821e-01 5.000000000000000278e-02 +1.894428152492668715e-01 5.000000000000000278e-02 +1.896383186705767332e-01 5.000000000000000278e-02 +1.898338220918865948e-01 5.000000000000000278e-02 +1.900293255131964842e-01 5.000000000000000278e-02 +1.902248289345063459e-01 5.000000000000000278e-02 +1.904203323558162353e-01 5.000000000000000278e-02 +1.906158357771260969e-01 5.000000000000000278e-02 +1.908113391984359586e-01 5.000000000000000278e-02 +1.910068426197458480e-01 5.000000000000000278e-02 +1.912023460410557096e-01 5.000000000000000278e-02 +1.913978494623655990e-01 5.000000000000000278e-02 +1.915933528836754607e-01 5.000000000000000278e-02 +1.917888563049853501e-01 5.000000000000000278e-02 +1.919843597262952117e-01 5.000000000000000278e-02 +1.921798631476050734e-01 5.000000000000000278e-02 +1.923753665689149628e-01 5.000000000000000278e-02 +1.925708699902248244e-01 5.000000000000000278e-02 +1.927663734115347138e-01 5.000000000000000278e-02 +1.929618768328445755e-01 5.000000000000000278e-02 +1.931573802541544371e-01 5.000000000000000278e-02 +1.933528836754643265e-01 5.000000000000000278e-02 +1.935483870967741882e-01 5.000000000000000278e-02 +1.937438905180840776e-01 5.000000000000000278e-02 +1.939393939393939392e-01 5.000000000000000278e-02 +1.941348973607038009e-01 5.000000000000000278e-02 +1.943304007820136903e-01 5.000000000000000278e-02 +1.945259042033235519e-01 5.000000000000000278e-02 +1.947214076246334413e-01 5.000000000000000278e-02 +1.949169110459433030e-01 5.000000000000000278e-02 +1.951124144672531646e-01 5.000000000000000278e-02 +1.953079178885630540e-01 5.000000000000000278e-02 +1.955034213098729157e-01 5.000000000000000278e-02 +1.956989247311828051e-01 5.000000000000000278e-02 +1.958944281524926667e-01 5.000000000000000278e-02 +1.960899315738025284e-01 5.000000000000000278e-02 +1.962854349951124178e-01 5.000000000000000278e-02 +1.964809384164222794e-01 5.000000000000000278e-02 +1.966764418377321688e-01 5.000000000000000278e-02 +1.968719452590420305e-01 5.000000000000000278e-02 +1.970674486803519199e-01 5.000000000000000278e-02 +1.972629521016617815e-01 5.000000000000000278e-02 +1.974584555229716432e-01 5.000000000000000278e-02 +1.976539589442815326e-01 5.000000000000000278e-02 +1.978494623655913942e-01 5.000000000000000278e-02 +1.980449657869012836e-01 5.000000000000000278e-02 +1.982404692082111453e-01 5.000000000000000278e-02 +1.984359726295210069e-01 5.000000000000000278e-02 +1.986314760508308963e-01 5.000000000000000278e-02 +1.988269794721407580e-01 5.000000000000000278e-02 +1.990224828934506474e-01 5.000000000000000278e-02 +1.992179863147605090e-01 5.000000000000000278e-02 +1.994134897360703707e-01 5.000000000000000278e-02 +1.996089931573802601e-01 5.000000000000000278e-02 +1.998044965786901217e-01 5.000000000000000278e-02 +2.000000000000000111e-01 5.000000000000000278e-02 diff --git a/output/wz.txt b/output/wz.txt new file mode 100644 index 0000000..e297b8e --- /dev/null +++ b/output/wz.txt @@ -0,0 +1,1024 @@ +0.000000000000000000e+00 1.000000000000000056e-01 +1.955034213098729226e-04 9.980449657869013003e-02 +3.910068426197458452e-04 9.960899315738025450e-02 +5.865102639296187678e-04 9.941348973607039285e-02 +7.820136852394916904e-04 9.921798631476051733e-02 +9.775171065493646130e-04 9.902248289345064181e-02 +1.173020527859237536e-03 9.882697947214076628e-02 +1.368523949169110458e-03 9.863147605083089076e-02 +1.564027370478983381e-03 9.843597262952102911e-02 +1.759530791788856303e-03 9.824046920821115358e-02 +1.955034213098729226e-03 9.804496578690127806e-02 +2.150537634408602149e-03 9.784946236559140254e-02 +2.346041055718475071e-03 9.765395894428152701e-02 +2.541544477028347994e-03 9.745845552297165149e-02 +2.737047898338220916e-03 9.726295210166178984e-02 +2.932551319648093839e-03 9.706744868035191431e-02 +3.128054740957966762e-03 9.687194525904203879e-02 +3.323558162267839684e-03 9.667644183773216326e-02 +3.519061583577712607e-03 9.648093841642228774e-02 +3.714565004887585530e-03 9.628543499511242609e-02 +3.910068426197458452e-03 9.608993157380255057e-02 +4.105571847507331375e-03 9.589442815249267504e-02 +4.301075268817204297e-03 9.569892473118279952e-02 +4.496578690127077220e-03 9.550342130987292399e-02 +4.692082111436950143e-03 9.530791788856304847e-02 +4.887585532746823065e-03 9.511241446725318682e-02 +5.083088954056695988e-03 9.491691104594331130e-02 +5.278592375366568910e-03 9.472140762463343577e-02 +5.474095796676441833e-03 9.452590420332356025e-02 +5.669599217986314756e-03 9.433040078201368472e-02 +5.865102639296187678e-03 9.413489736070382308e-02 +6.060606060606060601e-03 9.393939393939394755e-02 +6.256109481915933523e-03 9.374389051808407203e-02 +6.451612903225806446e-03 9.354838709677419650e-02 +6.647116324535679369e-03 9.335288367546432098e-02 +6.842619745845552291e-03 9.315738025415445933e-02 +7.038123167155425214e-03 9.296187683284458381e-02 +7.233626588465298136e-03 9.276637341153470828e-02 +7.429130009775171059e-03 9.257086999022483276e-02 +7.624633431085043982e-03 9.237536656891495723e-02 +7.820136852394916904e-03 9.217986314760509559e-02 +8.015640273704788960e-03 9.198435972629522006e-02 +8.211143695014662749e-03 9.178885630498534454e-02 +8.406647116324536539e-03 9.159335288367546901e-02 +8.602150537634408595e-03 9.139784946236559349e-02 +8.797653958944280650e-03 9.120234604105573184e-02 +8.993157380254154440e-03 9.100684261974585632e-02 +9.188660801564028230e-03 9.081133919843598079e-02 +9.384164222873900285e-03 9.061583577712610527e-02 +9.579667644183772340e-03 9.042033235581622974e-02 +9.775171065493646130e-03 9.022482893450635422e-02 +9.970674486803519920e-03 9.002932551319647869e-02 +1.016617790811339198e-02 8.983382209188661705e-02 +1.036168132942326403e-02 8.963831867057674152e-02 +1.055718475073313782e-02 8.944281524926686600e-02 +1.075268817204301161e-02 8.924731182795699047e-02 +1.094819159335288367e-02 8.905180840664711495e-02 +1.114369501466275572e-02 8.885630498533725330e-02 +1.133919843597262951e-02 8.866080156402737777e-02 +1.153470185728250330e-02 8.846529814271750225e-02 +1.173020527859237536e-02 8.826979472140762673e-02 +1.192570869990224741e-02 8.807429130009775120e-02 +1.212121212121212120e-02 8.787878787878788955e-02 +1.231671554252199499e-02 8.768328445747801403e-02 +1.251221896383186705e-02 8.748778103616813850e-02 +1.270772238514173910e-02 8.729227761485826298e-02 +1.290322580645161289e-02 8.709677419354838745e-02 +1.309872922776148668e-02 8.690127077223852581e-02 +1.329423264907135874e-02 8.670576735092865028e-02 +1.348973607038123079e-02 8.651026392961877476e-02 +1.368523949169110458e-02 8.631476050830889923e-02 +1.388074291300097837e-02 8.611925708699902371e-02 +1.407624633431085043e-02 8.592375366568916206e-02 +1.427174975562072248e-02 8.572825024437928654e-02 +1.446725317693059627e-02 8.553274682306941101e-02 +1.466275659824047006e-02 8.533724340175953549e-02 +1.485826001955034212e-02 8.514173998044965996e-02 +1.505376344086021417e-02 8.494623655913979832e-02 +1.524926686217008796e-02 8.475073313782992279e-02 +1.544477028347996175e-02 8.455522971652004727e-02 +1.564027370478983381e-02 8.435972629521017174e-02 +1.583577712609970586e-02 8.416422287390029622e-02 +1.603128054740957792e-02 8.396871945259043457e-02 +1.622678396871945344e-02 8.377321603128054517e-02 +1.642228739002932550e-02 8.357771260997068352e-02 +1.661779081133919755e-02 8.338220918866080800e-02 +1.681329423264907308e-02 8.318670576735093247e-02 +1.700879765395894513e-02 8.299120234604105695e-02 +1.720430107526881719e-02 8.279569892473118142e-02 +1.739980449657868924e-02 8.260019550342131978e-02 +1.759530791788856130e-02 8.240469208211144425e-02 +1.779081133919843682e-02 8.220918866080156873e-02 +1.798631476050830888e-02 8.201368523949169320e-02 +1.818181818181818094e-02 8.181818181818181768e-02 +1.837732160312805646e-02 8.162267839687195603e-02 +1.857282502443792851e-02 8.142717497556208051e-02 +1.876832844574780057e-02 8.123167155425220498e-02 +1.896383186705767263e-02 8.103616813294232946e-02 +1.915933528836754468e-02 8.084066471163245393e-02 +1.935483870967742021e-02 8.064516129032259228e-02 +1.955034213098729226e-02 8.044965786901271676e-02 +1.974584555229716432e-02 8.025415444770284124e-02 +1.994134897360703984e-02 8.005865102639296571e-02 +2.013685239491691190e-02 7.986314760508309019e-02 +2.033235581622678395e-02 7.966764418377322854e-02 +2.052785923753665601e-02 7.947214076246335301e-02 +2.072336265884652806e-02 7.927663734115347749e-02 +2.091886608015640359e-02 7.908113391984360196e-02 +2.111436950146627564e-02 7.888563049853372644e-02 +2.130987292277614770e-02 7.869012707722386479e-02 +2.150537634408602322e-02 7.849462365591397539e-02 +2.170087976539589528e-02 7.829912023460411374e-02 +2.189638318670576733e-02 7.810361681329423822e-02 +2.209188660801563939e-02 7.790811339198436269e-02 +2.228739002932551144e-02 7.771260997067450105e-02 +2.248289345063538697e-02 7.751710654936461165e-02 +2.267839687194525902e-02 7.732160312805475000e-02 +2.287390029325513108e-02 7.712609970674487447e-02 +2.306940371456500660e-02 7.693059628543499895e-02 +2.326490713587487866e-02 7.673509286412512342e-02 +2.346041055718475071e-02 7.653958944281524790e-02 +2.365591397849462277e-02 7.634408602150538625e-02 +2.385141739980449482e-02 7.614858260019551073e-02 +2.404692082111437035e-02 7.595307917888563520e-02 +2.424242424242424240e-02 7.575757575757575968e-02 +2.443792766373411446e-02 7.556207233626588415e-02 +2.463343108504398998e-02 7.536656891495602251e-02 +2.482893450635386204e-02 7.517106549364614698e-02 +2.502443792766373409e-02 7.497556207233627146e-02 +2.521994134897360615e-02 7.478005865102639593e-02 +2.541544477028347820e-02 7.458455522971652041e-02 +2.561094819159335373e-02 7.438905180840665876e-02 +2.580645161290322578e-02 7.419354838709678324e-02 +2.600195503421309784e-02 7.399804496578690771e-02 +2.619745845552297336e-02 7.380254154447703219e-02 +2.639296187683284542e-02 7.360703812316715666e-02 +2.658846529814271747e-02 7.341153470185729502e-02 +2.678396871945258953e-02 7.321603128054741949e-02 +2.697947214076246158e-02 7.302052785923754397e-02 +2.717497556207233711e-02 7.282502443792766844e-02 +2.737047898338220916e-02 7.262952101661779292e-02 +2.756598240469208122e-02 7.243401759530793127e-02 +2.776148582600195674e-02 7.223851417399804187e-02 +2.795698924731182880e-02 7.204301075268818022e-02 +2.815249266862170086e-02 7.184750733137830470e-02 +2.834799608993157291e-02 7.165200391006842917e-02 +2.854349951124144497e-02 7.145650048875856752e-02 +2.873900293255132049e-02 7.126099706744867812e-02 +2.893450635386119255e-02 7.106549364613881647e-02 +2.913000977517106460e-02 7.086999022482894095e-02 +2.932551319648094013e-02 7.067448680351906543e-02 +2.952101661779081218e-02 7.047898338220918990e-02 +2.971652003910068424e-02 7.028347996089931438e-02 +2.991202346041055629e-02 7.008797653958945273e-02 +3.010752688172042835e-02 6.989247311827957720e-02 +3.030303030303030387e-02 6.969696969696970168e-02 +3.049853372434017593e-02 6.950146627565982616e-02 +3.069403714565004798e-02 6.930596285434995063e-02 +3.088954056695992351e-02 6.911045943304008898e-02 +3.108504398826979556e-02 6.891495601173021346e-02 +3.128054740957966762e-02 6.871945259042033793e-02 +3.147605083088954314e-02 6.852394916911046241e-02 +3.167155425219941173e-02 6.832844574780058688e-02 +3.186705767350928725e-02 6.813294232649072524e-02 +3.206256109481915584e-02 6.793743890518084971e-02 +3.225806451612903136e-02 6.774193548387097419e-02 +3.245356793743890689e-02 6.754643206256109866e-02 +3.264907135874877547e-02 6.735092864125122314e-02 +3.284457478005865100e-02 6.715542521994136149e-02 +3.304007820136852652e-02 6.695992179863147209e-02 +3.323558162267839511e-02 6.676441837732161044e-02 +3.343108504398827063e-02 6.656891495601173492e-02 +3.362658846529814616e-02 6.637341153470185939e-02 +3.382209188660801474e-02 6.617790811339199775e-02 +3.401759530791789027e-02 6.598240469208210834e-02 +3.421309872922775885e-02 6.578690127077224670e-02 +3.440860215053763438e-02 6.559139784946237117e-02 +3.460410557184750990e-02 6.539589442815249565e-02 +3.479960899315737849e-02 6.520039100684263400e-02 +3.499511241446725401e-02 6.500488758553274460e-02 +3.519061583577712260e-02 6.480938416422288295e-02 +3.538611925708699812e-02 6.461388074291300743e-02 +3.558162267839687365e-02 6.441837732160313190e-02 +3.577712609970674223e-02 6.422287390029327026e-02 +3.597262952101661776e-02 6.402737047898338085e-02 +3.616813294232649328e-02 6.383186705767351921e-02 +3.636363636363636187e-02 6.363636363636364368e-02 +3.655913978494623739e-02 6.344086021505376816e-02 +3.675464320625611292e-02 6.324535679374389263e-02 +3.695014662756598151e-02 6.304985337243401711e-02 +3.714565004887585703e-02 6.285434995112415546e-02 +3.734115347018572562e-02 6.265884652981427994e-02 +3.753665689149560114e-02 6.246334310850440441e-02 +3.773216031280547667e-02 6.226783968719452889e-02 +3.792766373411534525e-02 6.207233626588466030e-02 +3.812316715542522078e-02 6.187683284457478478e-02 +3.831867057673508936e-02 6.168132942326491619e-02 +3.851417399804496489e-02 6.148582600195504066e-02 +3.870967741935484041e-02 6.129032258064516514e-02 +3.890518084066470900e-02 6.109481915933529655e-02 +3.910068426197458452e-02 6.089931573802542103e-02 +3.929618768328446005e-02 6.070381231671554551e-02 +3.949169110459432863e-02 6.050830889540567692e-02 +3.968719452590420416e-02 6.031280547409580139e-02 +3.988269794721407968e-02 6.011730205278592587e-02 +4.007820136852394827e-02 5.992179863147605728e-02 +4.027370478983382379e-02 5.972629521016618176e-02 +4.046920821114369238e-02 5.953079178885631317e-02 +4.066471163245356790e-02 5.933528836754643765e-02 +4.086021505376344343e-02 5.913978494623656212e-02 +4.105571847507331201e-02 5.894428152492669354e-02 +4.125122189638318754e-02 5.874877810361681801e-02 +4.144672531769305612e-02 5.855327468230694943e-02 +4.164222873900293165e-02 5.835777126099707390e-02 +4.183773216031280717e-02 5.816226783968719838e-02 +4.203323558162267576e-02 5.796676441837732979e-02 +4.222873900293255128e-02 5.777126099706745427e-02 +4.242424242424242681e-02 5.757575757575757874e-02 +4.261974584555229539e-02 5.738025415444771016e-02 +4.281524926686217092e-02 5.718475073313783463e-02 +4.301075268817204644e-02 5.698924731182795911e-02 +4.320625610948191503e-02 5.679374389051809052e-02 +4.340175953079179055e-02 5.659824046920821500e-02 +4.359726295210165914e-02 5.640273704789834641e-02 +4.379276637341153466e-02 5.620723362658847089e-02 +4.398826979472141019e-02 5.601173020527859536e-02 +4.418377321603127877e-02 5.581622678396872678e-02 +4.437927663734115430e-02 5.562072336265885125e-02 +4.457478005865102288e-02 5.542521994134898267e-02 +4.477028347996089841e-02 5.522971652003910714e-02 +4.496578690127077393e-02 5.503421309872923162e-02 +4.516129032258064252e-02 5.483870967741936303e-02 +4.535679374389051804e-02 5.464320625610948751e-02 +4.555229716520039357e-02 5.444770283479961198e-02 +4.574780058651026216e-02 5.425219941348974340e-02 +4.594330400782013768e-02 5.405669599217986787e-02 +4.613880742913001320e-02 5.386119257086999235e-02 +4.633431085043988179e-02 5.366568914956012376e-02 +4.652981427174975732e-02 5.347018572825024824e-02 +4.672531769305962590e-02 5.327468230694037965e-02 +4.692082111436950143e-02 5.307917888563050413e-02 +4.711632453567937695e-02 5.288367546432062860e-02 +4.731182795698924554e-02 5.268817204301076002e-02 +4.750733137829912106e-02 5.249266862170088449e-02 +4.770283479960898965e-02 5.229716520039101590e-02 +4.789833822091886517e-02 5.210166177908114038e-02 +4.809384164222874070e-02 5.190615835777126486e-02 +4.828934506353860928e-02 5.171065493646139627e-02 +4.848484848484848481e-02 5.151515151515152074e-02 +4.868035190615836033e-02 5.131964809384164522e-02 +4.887585532746822892e-02 5.112414467253177663e-02 +4.907135874877810444e-02 5.092864125122190111e-02 +4.926686217008797997e-02 5.073313782991202558e-02 +4.946236559139784855e-02 5.053763440860215700e-02 +4.965786901270772408e-02 5.034213098729228147e-02 +4.985337243401759266e-02 5.014662756598241289e-02 +5.004887585532746819e-02 4.995112414467253736e-02 +5.024437927663734371e-02 4.975562072336266184e-02 +5.043988269794721230e-02 4.956011730205279325e-02 +5.063538611925708782e-02 4.936461388074291773e-02 +5.083088954056695641e-02 4.916911045943304914e-02 +5.102639296187683193e-02 4.897360703812317362e-02 +5.122189638318670746e-02 4.877810361681329809e-02 +5.141739980449657604e-02 4.858260019550342951e-02 +5.161290322580645157e-02 4.838709677419355398e-02 +5.180840664711632709e-02 4.819159335288367846e-02 +5.200391006842619568e-02 4.799608993157380987e-02 +5.219941348973607120e-02 4.780058651026393435e-02 +5.239491691104594673e-02 4.760508308895405882e-02 +5.259042033235581531e-02 4.740957966764419024e-02 +5.278592375366569084e-02 4.721407624633431471e-02 +5.298142717497555942e-02 4.701857282502444613e-02 +5.317693059628543495e-02 4.682306940371457060e-02 +5.337243401759531047e-02 4.662756598240469508e-02 +5.356793743890517906e-02 4.643206256109482649e-02 +5.376344086021505458e-02 4.623655913978495097e-02 +5.395894428152492317e-02 4.604105571847508238e-02 +5.415444770283479869e-02 4.584555229716520686e-02 +5.434995112414467422e-02 4.565004887585533133e-02 +5.454545454545454281e-02 4.545454545454546275e-02 +5.474095796676441833e-02 4.525904203323558722e-02 +5.493646138807429385e-02 4.506353861192571170e-02 +5.513196480938416244e-02 4.486803519061584311e-02 +5.532746823069403797e-02 4.467253176930596759e-02 +5.552297165200391349e-02 4.447702834799609206e-02 +5.571847507331378208e-02 4.428152492668622348e-02 +5.591397849462365760e-02 4.408602150537634795e-02 +5.610948191593352619e-02 4.389051808406647937e-02 +5.630498533724340171e-02 4.369501466275660384e-02 +5.650048875855327724e-02 4.349951124144672832e-02 +5.669599217986314582e-02 4.330400782013685973e-02 +5.689149560117302135e-02 4.310850439882698421e-02 +5.708699902248288993e-02 4.291300097751711562e-02 +5.728250244379276546e-02 4.271749755620724009e-02 +5.747800586510264098e-02 4.252199413489736457e-02 +5.767350928641250957e-02 4.232649071358749598e-02 +5.786901270772238509e-02 4.213098729227762046e-02 +5.806451612903226062e-02 4.193548387096774493e-02 +5.826001955034212920e-02 4.173998044965787635e-02 +5.845552297165200473e-02 4.154447702834800082e-02 +5.865102639296188025e-02 4.134897360703812530e-02 +5.884652981427174884e-02 4.115347018572825671e-02 +5.904203323558162436e-02 4.095796676441838119e-02 +5.923753665689149295e-02 4.076246334310851260e-02 +5.943304007820136847e-02 4.056695992179863708e-02 +5.962854349951124400e-02 4.037145650048876155e-02 +5.982404692082111258e-02 4.017595307917889297e-02 +6.001955034213098811e-02 3.998044965786901744e-02 +6.021505376344085669e-02 3.978494623655914886e-02 +6.041055718475073222e-02 3.958944281524927333e-02 +6.060606060606060774e-02 3.939393939393939781e-02 +6.080156402737047633e-02 3.919843597262952922e-02 +6.099706744868035185e-02 3.900293255131965370e-02 +6.119257086999022738e-02 3.880742913000977817e-02 +6.138807429130009596e-02 3.861192570869990959e-02 +6.158357771260997149e-02 3.841642228739003406e-02 +6.177908113391984701e-02 3.822091886608015854e-02 +6.197458455522971560e-02 3.802541544477028995e-02 +6.217008797653959112e-02 3.782991202346041443e-02 +6.236559139784945971e-02 3.763440860215054584e-02 +6.256109481915933523e-02 3.743890518084067032e-02 +6.275659824046921076e-02 3.724340175953079479e-02 +6.295210166177908628e-02 3.704789833822091927e-02 +6.314760508308894793e-02 3.685239491691105762e-02 +6.334310850439882346e-02 3.665689149560118210e-02 +6.353861192570869898e-02 3.646138807429130657e-02 +6.373411534701857450e-02 3.626588465298143105e-02 +6.392961876832845003e-02 3.607038123167155552e-02 +6.412512218963831168e-02 3.587487781036169388e-02 +6.432062561094818720e-02 3.567937438905181835e-02 +6.451612903225806273e-02 3.548387096774194283e-02 +6.471163245356793825e-02 3.528836754643206730e-02 +6.490713587487781377e-02 3.509286412512219178e-02 +6.510263929618768930e-02 3.489736070381231625e-02 +6.529814271749755095e-02 3.470185728250245460e-02 +6.549364613880742647e-02 3.450635386119257908e-02 +6.568914956011730200e-02 3.431085043988270356e-02 +6.588465298142717752e-02 3.411534701857282803e-02 +6.608015640273705305e-02 3.391984359726295251e-02 +6.627565982404691469e-02 3.372434017595309086e-02 +6.647116324535679022e-02 3.352883675464321533e-02 +6.666666666666666574e-02 3.333333333333333981e-02 +6.686217008797654127e-02 3.313782991202346428e-02 +6.705767350928641679e-02 3.294232649071358876e-02 +6.725317693059629232e-02 3.274682306940371324e-02 +6.744868035190615396e-02 3.255131964809385159e-02 +6.764418377321602949e-02 3.235581622678397606e-02 +6.783968719452590501e-02 3.216031280547410054e-02 +6.803519061583578054e-02 3.196480938416422501e-02 +6.823069403714565606e-02 3.176930596285434949e-02 +6.842619745845551771e-02 3.157380254154448784e-02 +6.862170087976539323e-02 3.137829912023461232e-02 +6.881720430107526876e-02 3.118279569892473679e-02 +6.901270772238514428e-02 3.098729227761486127e-02 +6.920821114369501981e-02 3.079178885630498574e-02 +6.940371456500488145e-02 3.059628543499512410e-02 +6.959921798631475698e-02 3.040078201368524857e-02 +6.979472140762463250e-02 3.020527859237537305e-02 +6.999022482893450803e-02 3.000977517106549752e-02 +7.018572825024438355e-02 2.981427174975562200e-02 +7.038123167155424520e-02 2.961876832844576035e-02 +7.057673509286412072e-02 2.942326490713588483e-02 +7.077223851417399625e-02 2.922776148582600930e-02 +7.096774193548387177e-02 2.903225806451613378e-02 +7.116324535679374730e-02 2.883675464320625825e-02 +7.135874877810362282e-02 2.864125122189638273e-02 +7.155425219941348447e-02 2.844574780058652108e-02 +7.174975562072335999e-02 2.825024437927664556e-02 +7.194525904203323552e-02 2.805474095796677003e-02 +7.214076246334311104e-02 2.785923753665689451e-02 +7.233626588465298657e-02 2.766373411534701898e-02 +7.253176930596284822e-02 2.746823069403715734e-02 +7.272727272727272374e-02 2.727272727272728181e-02 +7.292277614858259926e-02 2.707722385141740629e-02 +7.311827956989247479e-02 2.688172043010753076e-02 +7.331378299120235031e-02 2.668621700879765524e-02 +7.350928641251222584e-02 2.649071358748777971e-02 +7.370478983382208749e-02 2.629521016617791807e-02 +7.390029325513196301e-02 2.609970674486804254e-02 +7.409579667644183854e-02 2.590420332355816702e-02 +7.429130009775171406e-02 2.570869990224829149e-02 +7.448680351906158958e-02 2.551319648093841597e-02 +7.468230694037145123e-02 2.531769305962855432e-02 +7.487781036168132676e-02 2.512218963831867879e-02 +7.507331378299120228e-02 2.492668621700880327e-02 +7.526881720430107781e-02 2.473118279569892775e-02 +7.546432062561095333e-02 2.453567937438905222e-02 +7.565982404692081498e-02 2.434017595307919057e-02 +7.585532746823069050e-02 2.414467253176931505e-02 +7.605083088954056603e-02 2.394916911045943952e-02 +7.624633431085044155e-02 2.375366568914956400e-02 +7.644183773216031708e-02 2.355816226783968848e-02 +7.663734115347017872e-02 2.336265884652982683e-02 +7.683284457478005425e-02 2.316715542521995130e-02 +7.702834799608992977e-02 2.297165200391007578e-02 +7.722385141739980530e-02 2.277614858260020025e-02 +7.741935483870968082e-02 2.258064516129032473e-02 +7.761485826001955635e-02 2.238514173998044920e-02 +7.781036168132941799e-02 2.218963831867058756e-02 +7.800586510263929352e-02 2.199413489736071203e-02 +7.820136852394916904e-02 2.179863147605083651e-02 +7.839687194525904457e-02 2.160312805474096098e-02 +7.859237536656892009e-02 2.140762463343108546e-02 +7.878787878787878174e-02 2.121212121212122381e-02 +7.898338220918865726e-02 2.101661779081134829e-02 +7.917888563049853279e-02 2.082111436950147276e-02 +7.937438905180840831e-02 2.062561094819159724e-02 +7.956989247311828384e-02 2.043010752688172171e-02 +7.976539589442815936e-02 2.023460410557184619e-02 +7.996089931573802101e-02 2.003910068426198454e-02 +8.015640273704789653e-02 1.984359726295210902e-02 +8.035190615835777206e-02 1.964809384164223349e-02 +8.054740957966764758e-02 1.945259042033235797e-02 +8.074291300097752311e-02 1.925708699902248244e-02 +8.093841642228738475e-02 1.906158357771262080e-02 +8.113391984359726028e-02 1.886608015640274527e-02 +8.132942326490713580e-02 1.867057673509286975e-02 +8.152492668621701133e-02 1.847507331378299422e-02 +8.172043010752688685e-02 1.827956989247311870e-02 +8.191593352883674850e-02 1.808406647116325705e-02 +8.211143695014662403e-02 1.788856304985338153e-02 +8.230694037145649955e-02 1.769305962854350600e-02 +8.250244379276637507e-02 1.749755620723363048e-02 +8.269794721407625060e-02 1.730205278592375495e-02 +8.289345063538611225e-02 1.710654936461389330e-02 +8.308895405669598777e-02 1.691104594330401778e-02 +8.328445747800586330e-02 1.671554252199414226e-02 +8.347996089931573882e-02 1.652003910068426673e-02 +8.367546432062561435e-02 1.632453567937439121e-02 +8.387096774193548987e-02 1.612903225806451568e-02 +8.406647116324535152e-02 1.593352883675465403e-02 +8.426197458455522704e-02 1.573802541544477851e-02 +8.445747800586510257e-02 1.554252199413490299e-02 +8.465298142717497809e-02 1.534701857282502746e-02 +8.484848484848485362e-02 1.515151515151515194e-02 +8.504398826979471526e-02 1.495601173020529029e-02 +8.523949169110459079e-02 1.476050830889541476e-02 +8.543499511241446631e-02 1.456500488758553924e-02 +8.563049853372434184e-02 1.436950146627566371e-02 +8.582600195503421736e-02 1.417399804496578819e-02 +8.602150537634409289e-02 1.397849462365591267e-02 +8.621700879765395453e-02 1.378299120234605102e-02 +8.641251221896383006e-02 1.358748778103617549e-02 +8.660801564027370558e-02 1.339198435972629997e-02 +8.680351906158358111e-02 1.319648093841642444e-02 +8.699902248289345663e-02 1.300097751710654892e-02 +8.719452590420331828e-02 1.280547409579668727e-02 +8.739002932551319380e-02 1.260997067448681175e-02 +8.758553274682306933e-02 1.241446725317693622e-02 +8.778103616813294485e-02 1.221896383186706070e-02 +8.797653958944282038e-02 1.202346041055718517e-02 +8.817204301075268202e-02 1.182795698924732353e-02 +8.836754643206255755e-02 1.163245356793744800e-02 +8.856304985337243307e-02 1.143695014662757248e-02 +8.875855327468230860e-02 1.124144672531769695e-02 +8.895405669599218412e-02 1.104594330400782143e-02 +8.914956011730204577e-02 1.085043988269795978e-02 +8.934506353861192129e-02 1.065493646138808426e-02 +8.954056695992179682e-02 1.045943304007820873e-02 +8.973607038123167234e-02 1.026392961876833321e-02 +8.993157380254154787e-02 1.006842619745845768e-02 +9.012707722385142339e-02 9.872922776148582158e-03 +9.032258064516128504e-02 9.677419354838720511e-03 +9.051808406647116056e-02 9.481915933528844986e-03 +9.071358748778103609e-02 9.286412512218969462e-03 +9.090909090909091161e-02 9.090909090909093937e-03 +9.110459433040078714e-02 8.895405669599218412e-03 +9.130009775171064879e-02 8.699902248289356765e-03 +9.149560117302052431e-02 8.504398826979481241e-03 +9.169110459433039984e-02 8.308895405669605716e-03 +9.188660801564027536e-02 8.113391984359730191e-03 +9.208211143695015088e-02 7.917888563049854667e-03 +9.227761485826002641e-02 7.722385141739979142e-03 +9.247311827956988806e-02 7.526881720430117495e-03 +9.266862170087976358e-02 7.331378299120241970e-03 +9.286412512218963911e-02 7.135874877810366446e-03 +9.305962854349951463e-02 6.940371456500490921e-03 +9.325513196480939015e-02 6.744868035190615396e-03 +9.345063538611925180e-02 6.549364613880753749e-03 +9.364613880742912733e-02 6.353861192570878225e-03 +9.384164222873900285e-02 6.158357771261002700e-03 +9.403714565004887838e-02 5.962854349951127175e-03 +9.423264907135875390e-02 5.767350928641251651e-03 +9.442815249266861555e-02 5.571847507331390004e-03 +9.462365591397849107e-02 5.376344086021514479e-03 +9.481915933528836660e-02 5.180840664711638954e-03 +9.501466275659824212e-02 4.985337243401763430e-03 +9.521016617790811765e-02 4.789833822091887905e-03 +9.540566959921797929e-02 4.594330400782026258e-03 +9.560117302052785482e-02 4.398826979472150733e-03 +9.579667644183773034e-02 4.203323558162275209e-03 +9.599217986314760587e-02 4.007820136852399684e-03 +9.618768328445748139e-02 3.812316715542524159e-03 +9.638318670576735692e-02 3.616813294232648635e-03 +9.657869012707721856e-02 3.421309872922786988e-03 +9.677419354838709409e-02 3.225806451612911463e-03 +9.696969696969696961e-02 3.030303030303035938e-03 +9.716520039100684514e-02 2.834799608993160414e-03 +9.736070381231672066e-02 2.639296187683284889e-03 +9.755620723362658231e-02 2.443792766373423242e-03 +9.775171065493645783e-02 2.248289345063547717e-03 +9.794721407624633336e-02 2.052785923753672193e-03 +9.814271749755620888e-02 1.857282502443796668e-03 +9.833822091886608441e-02 1.661779081133921143e-03 +9.853372434017595993e-02 1.466275659824045619e-03 +9.872922776148582158e-02 1.270772238514183972e-03 +9.892473118279569710e-02 1.075268817204308447e-03 +9.912023460410557263e-02 8.797653958944329222e-04 +9.931573802541544815e-02 6.842619745845573975e-04 +9.951124144672532368e-02 4.887585532746818728e-04 +9.970674486803518533e-02 2.932551319648202259e-04 +9.990224828934506085e-02 9.775171065494470124e-05 +1.000977517106549364e-01 0.000000000000000000e+00 +1.002932551319648119e-01 0.000000000000000000e+00 +1.004887585532746874e-01 0.000000000000000000e+00 +1.006842619745845491e-01 0.000000000000000000e+00 +1.008797653958944246e-01 0.000000000000000000e+00 +1.010752688172043001e-01 0.000000000000000000e+00 +1.012707722385141756e-01 0.000000000000000000e+00 +1.014662756598240512e-01 0.000000000000000000e+00 +1.016617790811339128e-01 0.000000000000000000e+00 +1.018572825024437883e-01 0.000000000000000000e+00 +1.020527859237536639e-01 0.000000000000000000e+00 +1.022482893450635394e-01 0.000000000000000000e+00 +1.024437927663734149e-01 0.000000000000000000e+00 +1.026392961876832904e-01 0.000000000000000000e+00 +1.028347996089931521e-01 0.000000000000000000e+00 +1.030303030303030276e-01 0.000000000000000000e+00 +1.032258064516129031e-01 0.000000000000000000e+00 +1.034213098729227787e-01 0.000000000000000000e+00 +1.036168132942326542e-01 0.000000000000000000e+00 +1.038123167155425158e-01 0.000000000000000000e+00 +1.040078201368523914e-01 0.000000000000000000e+00 +1.042033235581622669e-01 0.000000000000000000e+00 +1.043988269794721424e-01 0.000000000000000000e+00 +1.045943304007820179e-01 0.000000000000000000e+00 +1.047898338220918935e-01 0.000000000000000000e+00 +1.049853372434017551e-01 0.000000000000000000e+00 +1.051808406647116306e-01 0.000000000000000000e+00 +1.053763440860215062e-01 0.000000000000000000e+00 +1.055718475073313817e-01 0.000000000000000000e+00 +1.057673509286412572e-01 0.000000000000000000e+00 +1.059628543499511188e-01 0.000000000000000000e+00 +1.061583577712609944e-01 0.000000000000000000e+00 +1.063538611925708699e-01 0.000000000000000000e+00 +1.065493646138807454e-01 0.000000000000000000e+00 +1.067448680351906209e-01 0.000000000000000000e+00 +1.069403714565004826e-01 0.000000000000000000e+00 +1.071358748778103581e-01 0.000000000000000000e+00 +1.073313782991202336e-01 0.000000000000000000e+00 +1.075268817204301092e-01 0.000000000000000000e+00 +1.077223851417399847e-01 0.000000000000000000e+00 +1.079178885630498463e-01 0.000000000000000000e+00 +1.081133919843597219e-01 0.000000000000000000e+00 +1.083088954056695974e-01 0.000000000000000000e+00 +1.085043988269794729e-01 0.000000000000000000e+00 +1.086999022482893484e-01 0.000000000000000000e+00 +1.088954056695992240e-01 0.000000000000000000e+00 +1.090909090909090856e-01 0.000000000000000000e+00 +1.092864125122189611e-01 0.000000000000000000e+00 +1.094819159335288367e-01 0.000000000000000000e+00 +1.096774193548387122e-01 0.000000000000000000e+00 +1.098729227761485877e-01 0.000000000000000000e+00 +1.100684261974584494e-01 0.000000000000000000e+00 +1.102639296187683249e-01 0.000000000000000000e+00 +1.104594330400782004e-01 0.000000000000000000e+00 +1.106549364613880759e-01 0.000000000000000000e+00 +1.108504398826979515e-01 0.000000000000000000e+00 +1.110459433040078270e-01 0.000000000000000000e+00 +1.112414467253176886e-01 0.000000000000000000e+00 +1.114369501466275642e-01 0.000000000000000000e+00 +1.116324535679374397e-01 0.000000000000000000e+00 +1.118279569892473152e-01 0.000000000000000000e+00 +1.120234604105571907e-01 0.000000000000000000e+00 +1.122189638318670524e-01 0.000000000000000000e+00 +1.124144672531769279e-01 0.000000000000000000e+00 +1.126099706744868034e-01 0.000000000000000000e+00 +1.128054740957966789e-01 0.000000000000000000e+00 +1.130009775171065545e-01 0.000000000000000000e+00 +1.131964809384164161e-01 0.000000000000000000e+00 +1.133919843597262916e-01 0.000000000000000000e+00 +1.135874877810361672e-01 0.000000000000000000e+00 +1.137829912023460427e-01 0.000000000000000000e+00 +1.139784946236559182e-01 0.000000000000000000e+00 +1.141739980449657799e-01 0.000000000000000000e+00 +1.143695014662756554e-01 0.000000000000000000e+00 +1.145650048875855309e-01 0.000000000000000000e+00 +1.147605083088954064e-01 0.000000000000000000e+00 +1.149560117302052820e-01 0.000000000000000000e+00 +1.151515151515151575e-01 0.000000000000000000e+00 +1.153470185728250191e-01 0.000000000000000000e+00 +1.155425219941348947e-01 0.000000000000000000e+00 +1.157380254154447702e-01 0.000000000000000000e+00 +1.159335288367546457e-01 0.000000000000000000e+00 +1.161290322580645212e-01 0.000000000000000000e+00 +1.163245356793743829e-01 0.000000000000000000e+00 +1.165200391006842584e-01 0.000000000000000000e+00 +1.167155425219941339e-01 0.000000000000000000e+00 +1.169110459433040095e-01 0.000000000000000000e+00 +1.171065493646138850e-01 0.000000000000000000e+00 +1.173020527859237605e-01 0.000000000000000000e+00 +1.174975562072336221e-01 0.000000000000000000e+00 +1.176930596285434977e-01 0.000000000000000000e+00 +1.178885630498533732e-01 0.000000000000000000e+00 +1.180840664711632487e-01 0.000000000000000000e+00 +1.182795698924731242e-01 0.000000000000000000e+00 +1.184750733137829859e-01 0.000000000000000000e+00 +1.186705767350928614e-01 0.000000000000000000e+00 +1.188660801564027369e-01 0.000000000000000000e+00 +1.190615835777126125e-01 0.000000000000000000e+00 +1.192570869990224880e-01 0.000000000000000000e+00 +1.194525904203323496e-01 0.000000000000000000e+00 +1.196480938416422252e-01 0.000000000000000000e+00 +1.198435972629521007e-01 0.000000000000000000e+00 +1.200391006842619762e-01 0.000000000000000000e+00 +1.202346041055718517e-01 0.000000000000000000e+00 +1.204301075268817134e-01 0.000000000000000000e+00 +1.206256109481915889e-01 0.000000000000000000e+00 +1.208211143695014644e-01 0.000000000000000000e+00 +1.210166177908113400e-01 0.000000000000000000e+00 +1.212121212121212155e-01 0.000000000000000000e+00 +1.214076246334310910e-01 0.000000000000000000e+00 +1.216031280547409527e-01 0.000000000000000000e+00 +1.217986314760508282e-01 0.000000000000000000e+00 +1.219941348973607037e-01 0.000000000000000000e+00 +1.221896383186705792e-01 0.000000000000000000e+00 +1.223851417399804548e-01 0.000000000000000000e+00 +1.225806451612903164e-01 0.000000000000000000e+00 +1.227761485826001919e-01 0.000000000000000000e+00 +1.229716520039100675e-01 0.000000000000000000e+00 +1.231671554252199430e-01 0.000000000000000000e+00 +1.233626588465298185e-01 0.000000000000000000e+00 +1.235581622678396940e-01 0.000000000000000000e+00 +1.237536656891495557e-01 0.000000000000000000e+00 +1.239491691104594312e-01 0.000000000000000000e+00 +1.241446725317693067e-01 0.000000000000000000e+00 +1.243401759530791822e-01 0.000000000000000000e+00 +1.245356793743890578e-01 0.000000000000000000e+00 +1.247311827956989194e-01 0.000000000000000000e+00 +1.249266862170087949e-01 0.000000000000000000e+00 +1.251221896383186705e-01 0.000000000000000000e+00 +1.253176930596285321e-01 0.000000000000000000e+00 +1.255131964809384215e-01 0.000000000000000000e+00 +1.257086999022482832e-01 0.000000000000000000e+00 +1.259042033235581726e-01 0.000000000000000000e+00 +1.260997067448680342e-01 0.000000000000000000e+00 +1.262952101661778959e-01 0.000000000000000000e+00 +1.264907135874877853e-01 0.000000000000000000e+00 +1.266862170087976469e-01 0.000000000000000000e+00 +1.268817204301075363e-01 0.000000000000000000e+00 +1.270772238514173980e-01 0.000000000000000000e+00 +1.272727272727272596e-01 0.000000000000000000e+00 +1.274682306940371490e-01 0.000000000000000000e+00 +1.276637341153470107e-01 0.000000000000000000e+00 +1.278592375366569001e-01 0.000000000000000000e+00 +1.280547409579667617e-01 0.000000000000000000e+00 +1.282502443792766234e-01 0.000000000000000000e+00 +1.284457478005865128e-01 0.000000000000000000e+00 +1.286412512218963744e-01 0.000000000000000000e+00 +1.288367546432062638e-01 0.000000000000000000e+00 +1.290322580645161255e-01 0.000000000000000000e+00 +1.292277614858260149e-01 0.000000000000000000e+00 +1.294232649071358765e-01 0.000000000000000000e+00 +1.296187683284457381e-01 0.000000000000000000e+00 +1.298142717497556275e-01 0.000000000000000000e+00 +1.300097751710654892e-01 0.000000000000000000e+00 +1.302052785923753786e-01 0.000000000000000000e+00 +1.304007820136852402e-01 0.000000000000000000e+00 +1.305962854349951019e-01 0.000000000000000000e+00 +1.307917888563049913e-01 0.000000000000000000e+00 +1.309872922776148529e-01 0.000000000000000000e+00 +1.311827956989247423e-01 0.000000000000000000e+00 +1.313782991202346040e-01 0.000000000000000000e+00 +1.315738025415444656e-01 0.000000000000000000e+00 +1.317693059628543550e-01 0.000000000000000000e+00 +1.319648093841642167e-01 0.000000000000000000e+00 +1.321603128054741061e-01 0.000000000000000000e+00 +1.323558162267839677e-01 0.000000000000000000e+00 +1.325513196480938294e-01 0.000000000000000000e+00 +1.327468230694037188e-01 0.000000000000000000e+00 +1.329423264907135804e-01 0.000000000000000000e+00 +1.331378299120234698e-01 0.000000000000000000e+00 +1.333333333333333315e-01 0.000000000000000000e+00 +1.335288367546431931e-01 0.000000000000000000e+00 +1.337243401759530825e-01 0.000000000000000000e+00 +1.339198435972629442e-01 0.000000000000000000e+00 +1.341153470185728336e-01 0.000000000000000000e+00 +1.343108504398826952e-01 0.000000000000000000e+00 +1.345063538611925846e-01 0.000000000000000000e+00 +1.347018572825024463e-01 0.000000000000000000e+00 +1.348973607038123079e-01 0.000000000000000000e+00 +1.350928641251221973e-01 0.000000000000000000e+00 +1.352883675464320590e-01 0.000000000000000000e+00 +1.354838709677419484e-01 0.000000000000000000e+00 +1.356793743890518100e-01 0.000000000000000000e+00 +1.358748778103616717e-01 0.000000000000000000e+00 +1.360703812316715611e-01 0.000000000000000000e+00 +1.362658846529814227e-01 0.000000000000000000e+00 +1.364613880742913121e-01 0.000000000000000000e+00 +1.366568914956011738e-01 0.000000000000000000e+00 +1.368523949169110354e-01 0.000000000000000000e+00 +1.370478983382209248e-01 0.000000000000000000e+00 +1.372434017595307865e-01 0.000000000000000000e+00 +1.374389051808406759e-01 0.000000000000000000e+00 +1.376344086021505375e-01 0.000000000000000000e+00 +1.378299120234603992e-01 0.000000000000000000e+00 +1.380254154447702886e-01 0.000000000000000000e+00 +1.382209188660801502e-01 0.000000000000000000e+00 +1.384164222873900396e-01 0.000000000000000000e+00 +1.386119257086999013e-01 0.000000000000000000e+00 +1.388074291300097629e-01 0.000000000000000000e+00 +1.390029325513196523e-01 0.000000000000000000e+00 +1.391984359726295140e-01 0.000000000000000000e+00 +1.393939393939394034e-01 0.000000000000000000e+00 +1.395894428152492650e-01 0.000000000000000000e+00 +1.397849462365591267e-01 0.000000000000000000e+00 +1.399804496578690161e-01 0.000000000000000000e+00 +1.401759530791788777e-01 0.000000000000000000e+00 +1.403714565004887671e-01 0.000000000000000000e+00 +1.405669599217986288e-01 0.000000000000000000e+00 +1.407624633431084904e-01 0.000000000000000000e+00 +1.409579667644183798e-01 0.000000000000000000e+00 +1.411534701857282414e-01 0.000000000000000000e+00 +1.413489736070381309e-01 0.000000000000000000e+00 +1.415444770283479925e-01 0.000000000000000000e+00 +1.417399804496578819e-01 0.000000000000000000e+00 +1.419354838709677435e-01 0.000000000000000000e+00 +1.421309872922776052e-01 0.000000000000000000e+00 +1.423264907135874946e-01 0.000000000000000000e+00 +1.425219941348973562e-01 0.000000000000000000e+00 +1.427174975562072456e-01 0.000000000000000000e+00 +1.429130009775171073e-01 0.000000000000000000e+00 +1.431085043988269689e-01 0.000000000000000000e+00 +1.433040078201368583e-01 0.000000000000000000e+00 +1.434995112414467200e-01 0.000000000000000000e+00 +1.436950146627566094e-01 0.000000000000000000e+00 +1.438905180840664710e-01 0.000000000000000000e+00 +1.440860215053763327e-01 0.000000000000000000e+00 +1.442815249266862221e-01 0.000000000000000000e+00 +1.444770283479960837e-01 0.000000000000000000e+00 +1.446725317693059731e-01 0.000000000000000000e+00 +1.448680351906158348e-01 0.000000000000000000e+00 +1.450635386119256964e-01 0.000000000000000000e+00 +1.452590420332355858e-01 0.000000000000000000e+00 +1.454545454545454475e-01 0.000000000000000000e+00 +1.456500488758553369e-01 0.000000000000000000e+00 +1.458455522971651985e-01 0.000000000000000000e+00 +1.460410557184750602e-01 0.000000000000000000e+00 +1.462365591397849496e-01 0.000000000000000000e+00 +1.464320625610948112e-01 0.000000000000000000e+00 +1.466275659824047006e-01 0.000000000000000000e+00 +1.468230694037145623e-01 0.000000000000000000e+00 +1.470185728250244517e-01 0.000000000000000000e+00 +1.472140762463343133e-01 0.000000000000000000e+00 +1.474095796676441750e-01 0.000000000000000000e+00 +1.476050830889540644e-01 0.000000000000000000e+00 +1.478005865102639260e-01 0.000000000000000000e+00 +1.479960899315738154e-01 0.000000000000000000e+00 +1.481915933528836771e-01 0.000000000000000000e+00 +1.483870967741935387e-01 0.000000000000000000e+00 +1.485826001955034281e-01 0.000000000000000000e+00 +1.487781036168132898e-01 0.000000000000000000e+00 +1.489736070381231792e-01 0.000000000000000000e+00 +1.491691104594330408e-01 0.000000000000000000e+00 +1.493646138807429025e-01 0.000000000000000000e+00 +1.495601173020527919e-01 0.000000000000000000e+00 +1.497556207233626535e-01 0.000000000000000000e+00 +1.499511241446725429e-01 0.000000000000000000e+00 +1.501466275659824046e-01 0.000000000000000000e+00 +1.503421309872922662e-01 0.000000000000000000e+00 +1.505376344086021556e-01 0.000000000000000000e+00 +1.507331378299120173e-01 0.000000000000000000e+00 +1.509286412512219067e-01 0.000000000000000000e+00 +1.511241446725317683e-01 0.000000000000000000e+00 +1.513196480938416300e-01 0.000000000000000000e+00 +1.515151515151515194e-01 0.000000000000000000e+00 +1.517106549364613810e-01 0.000000000000000000e+00 +1.519061583577712704e-01 0.000000000000000000e+00 +1.521016617790811321e-01 0.000000000000000000e+00 +1.522971652003909937e-01 0.000000000000000000e+00 +1.524926686217008831e-01 0.000000000000000000e+00 +1.526881720430107447e-01 0.000000000000000000e+00 +1.528836754643206342e-01 0.000000000000000000e+00 +1.530791788856304958e-01 0.000000000000000000e+00 +1.532746823069403574e-01 0.000000000000000000e+00 +1.534701857282502468e-01 0.000000000000000000e+00 +1.536656891495601085e-01 0.000000000000000000e+00 +1.538611925708699979e-01 0.000000000000000000e+00 +1.540566959921798595e-01 0.000000000000000000e+00 +1.542521994134897489e-01 0.000000000000000000e+00 +1.544477028347996106e-01 0.000000000000000000e+00 +1.546432062561094722e-01 0.000000000000000000e+00 +1.548387096774193616e-01 0.000000000000000000e+00 +1.550342130987292233e-01 0.000000000000000000e+00 +1.552297165200391127e-01 0.000000000000000000e+00 +1.554252199413489743e-01 0.000000000000000000e+00 +1.556207233626588360e-01 0.000000000000000000e+00 +1.558162267839687254e-01 0.000000000000000000e+00 +1.560117302052785870e-01 0.000000000000000000e+00 +1.562072336265884764e-01 0.000000000000000000e+00 +1.564027370478983381e-01 0.000000000000000000e+00 +1.565982404692081997e-01 0.000000000000000000e+00 +1.567937438905180891e-01 0.000000000000000000e+00 +1.569892473118279508e-01 0.000000000000000000e+00 +1.571847507331378402e-01 0.000000000000000000e+00 +1.573802541544477018e-01 0.000000000000000000e+00 +1.575757575757575635e-01 0.000000000000000000e+00 +1.577712609970674529e-01 0.000000000000000000e+00 +1.579667644183773145e-01 0.000000000000000000e+00 +1.581622678396872039e-01 0.000000000000000000e+00 +1.583577712609970656e-01 0.000000000000000000e+00 +1.585532746823069272e-01 0.000000000000000000e+00 +1.587487781036168166e-01 0.000000000000000000e+00 +1.589442815249266783e-01 0.000000000000000000e+00 +1.591397849462365677e-01 0.000000000000000000e+00 +1.593352883675464293e-01 0.000000000000000000e+00 +1.595307917888563187e-01 0.000000000000000000e+00 +1.597262952101661804e-01 0.000000000000000000e+00 +1.599217986314760420e-01 0.000000000000000000e+00 +1.601173020527859314e-01 0.000000000000000000e+00 +1.603128054740957931e-01 0.000000000000000000e+00 +1.605083088954056825e-01 0.000000000000000000e+00 +1.607038123167155441e-01 0.000000000000000000e+00 +1.608993157380254058e-01 0.000000000000000000e+00 +1.610948191593352952e-01 0.000000000000000000e+00 +1.612903225806451568e-01 0.000000000000000000e+00 +1.614858260019550462e-01 0.000000000000000000e+00 +1.616813294232649079e-01 0.000000000000000000e+00 +1.618768328445747695e-01 0.000000000000000000e+00 +1.620723362658846589e-01 0.000000000000000000e+00 +1.622678396871945206e-01 0.000000000000000000e+00 +1.624633431085044100e-01 0.000000000000000000e+00 +1.626588465298142716e-01 0.000000000000000000e+00 +1.628543499511241333e-01 0.000000000000000000e+00 +1.630498533724340227e-01 0.000000000000000000e+00 +1.632453567937438843e-01 0.000000000000000000e+00 +1.634408602150537737e-01 0.000000000000000000e+00 +1.636363636363636354e-01 0.000000000000000000e+00 +1.638318670576734970e-01 0.000000000000000000e+00 +1.640273704789833864e-01 0.000000000000000000e+00 +1.642228739002932481e-01 0.000000000000000000e+00 +1.644183773216031375e-01 0.000000000000000000e+00 +1.646138807429129991e-01 0.000000000000000000e+00 +1.648093841642228607e-01 0.000000000000000000e+00 +1.650048875855327501e-01 0.000000000000000000e+00 +1.652003910068426118e-01 0.000000000000000000e+00 +1.653958944281525012e-01 0.000000000000000000e+00 +1.655913978494623628e-01 0.000000000000000000e+00 +1.657869012707722245e-01 0.000000000000000000e+00 +1.659824046920821139e-01 0.000000000000000000e+00 +1.661779081133919755e-01 0.000000000000000000e+00 +1.663734115347018649e-01 0.000000000000000000e+00 +1.665689149560117266e-01 0.000000000000000000e+00 +1.667644183773216160e-01 0.000000000000000000e+00 +1.669599217986314776e-01 0.000000000000000000e+00 +1.671554252199413393e-01 0.000000000000000000e+00 +1.673509286412512287e-01 0.000000000000000000e+00 +1.675464320625610903e-01 0.000000000000000000e+00 +1.677419354838709797e-01 0.000000000000000000e+00 +1.679374389051808414e-01 0.000000000000000000e+00 +1.681329423264907030e-01 0.000000000000000000e+00 +1.683284457478005924e-01 0.000000000000000000e+00 +1.685239491691104541e-01 0.000000000000000000e+00 +1.687194525904203435e-01 0.000000000000000000e+00 +1.689149560117302051e-01 0.000000000000000000e+00 +1.691104594330400668e-01 0.000000000000000000e+00 +1.693059628543499562e-01 0.000000000000000000e+00 +1.695014662756598178e-01 0.000000000000000000e+00 +1.696969696969697072e-01 0.000000000000000000e+00 +1.698924731182795689e-01 0.000000000000000000e+00 +1.700879765395894305e-01 0.000000000000000000e+00 +1.702834799608993199e-01 0.000000000000000000e+00 +1.704789833822091816e-01 0.000000000000000000e+00 +1.706744868035190710e-01 0.000000000000000000e+00 +1.708699902248289326e-01 0.000000000000000000e+00 +1.710654936461387943e-01 0.000000000000000000e+00 +1.712609970674486837e-01 0.000000000000000000e+00 +1.714565004887585453e-01 0.000000000000000000e+00 +1.716520039100684347e-01 0.000000000000000000e+00 +1.718475073313782964e-01 0.000000000000000000e+00 +1.720430107526881858e-01 0.000000000000000000e+00 +1.722385141739980474e-01 0.000000000000000000e+00 +1.724340175953079091e-01 0.000000000000000000e+00 +1.726295210166177985e-01 0.000000000000000000e+00 +1.728250244379276601e-01 0.000000000000000000e+00 +1.730205278592375495e-01 0.000000000000000000e+00 +1.732160312805474112e-01 0.000000000000000000e+00 +1.734115347018572728e-01 0.000000000000000000e+00 +1.736070381231671622e-01 0.000000000000000000e+00 +1.738025415444770239e-01 0.000000000000000000e+00 +1.739980449657869133e-01 0.000000000000000000e+00 +1.741935483870967749e-01 0.000000000000000000e+00 +1.743890518084066366e-01 0.000000000000000000e+00 +1.745845552297165260e-01 0.000000000000000000e+00 +1.747800586510263876e-01 0.000000000000000000e+00 +1.749755620723362770e-01 0.000000000000000000e+00 +1.751710654936461387e-01 0.000000000000000000e+00 +1.753665689149560003e-01 0.000000000000000000e+00 +1.755620723362658897e-01 0.000000000000000000e+00 +1.757575757575757514e-01 0.000000000000000000e+00 +1.759530791788856408e-01 0.000000000000000000e+00 +1.761485826001955024e-01 0.000000000000000000e+00 +1.763440860215053640e-01 0.000000000000000000e+00 +1.765395894428152535e-01 0.000000000000000000e+00 +1.767350928641251151e-01 0.000000000000000000e+00 +1.769305962854350045e-01 0.000000000000000000e+00 +1.771260997067448661e-01 0.000000000000000000e+00 +1.773216031280547278e-01 0.000000000000000000e+00 +1.775171065493646172e-01 0.000000000000000000e+00 +1.777126099706744788e-01 0.000000000000000000e+00 +1.779081133919843682e-01 0.000000000000000000e+00 +1.781036168132942299e-01 0.000000000000000000e+00 +1.782991202346040915e-01 0.000000000000000000e+00 +1.784946236559139809e-01 0.000000000000000000e+00 +1.786901270772238426e-01 0.000000000000000000e+00 +1.788856304985337320e-01 0.000000000000000000e+00 +1.790811339198435936e-01 0.000000000000000000e+00 +1.792766373411534830e-01 0.000000000000000000e+00 +1.794721407624633447e-01 0.000000000000000000e+00 +1.796676441837732063e-01 0.000000000000000000e+00 +1.798631476050830957e-01 0.000000000000000000e+00 +1.800586510263929574e-01 0.000000000000000000e+00 +1.802541544477028468e-01 0.000000000000000000e+00 +1.804496578690127084e-01 0.000000000000000000e+00 +1.806451612903225701e-01 0.000000000000000000e+00 +1.808406647116324595e-01 0.000000000000000000e+00 +1.810361681329423211e-01 0.000000000000000000e+00 +1.812316715542522105e-01 0.000000000000000000e+00 +1.814271749755620722e-01 0.000000000000000000e+00 +1.816226783968719338e-01 0.000000000000000000e+00 +1.818181818181818232e-01 0.000000000000000000e+00 +1.820136852394916849e-01 0.000000000000000000e+00 +1.822091886608015743e-01 0.000000000000000000e+00 +1.824046920821114359e-01 0.000000000000000000e+00 +1.826001955034212976e-01 0.000000000000000000e+00 +1.827956989247311870e-01 0.000000000000000000e+00 +1.829912023460410486e-01 0.000000000000000000e+00 +1.831867057673509380e-01 0.000000000000000000e+00 +1.833822091886607997e-01 0.000000000000000000e+00 +1.835777126099706613e-01 0.000000000000000000e+00 +1.837732160312805507e-01 0.000000000000000000e+00 +1.839687194525904124e-01 0.000000000000000000e+00 +1.841642228739003018e-01 0.000000000000000000e+00 +1.843597262952101634e-01 0.000000000000000000e+00 +1.845552297165200528e-01 0.000000000000000000e+00 +1.847507331378299145e-01 0.000000000000000000e+00 +1.849462365591397761e-01 0.000000000000000000e+00 +1.851417399804496655e-01 0.000000000000000000e+00 +1.853372434017595272e-01 0.000000000000000000e+00 +1.855327468230694166e-01 0.000000000000000000e+00 +1.857282502443792782e-01 0.000000000000000000e+00 +1.859237536656891399e-01 0.000000000000000000e+00 +1.861192570869990293e-01 0.000000000000000000e+00 +1.863147605083088909e-01 0.000000000000000000e+00 +1.865102639296187803e-01 0.000000000000000000e+00 +1.867057673509286420e-01 0.000000000000000000e+00 +1.869012707722385036e-01 0.000000000000000000e+00 +1.870967741935483930e-01 0.000000000000000000e+00 +1.872922776148582547e-01 0.000000000000000000e+00 +1.874877810361681441e-01 0.000000000000000000e+00 +1.876832844574780057e-01 0.000000000000000000e+00 +1.878787878787878673e-01 0.000000000000000000e+00 +1.880742913000977568e-01 0.000000000000000000e+00 +1.882697947214076184e-01 0.000000000000000000e+00 +1.884652981427175078e-01 0.000000000000000000e+00 +1.886608015640273694e-01 0.000000000000000000e+00 +1.888563049853372311e-01 0.000000000000000000e+00 +1.890518084066471205e-01 0.000000000000000000e+00 +1.892473118279569821e-01 0.000000000000000000e+00 +1.894428152492668715e-01 0.000000000000000000e+00 +1.896383186705767332e-01 0.000000000000000000e+00 +1.898338220918865948e-01 0.000000000000000000e+00 +1.900293255131964842e-01 0.000000000000000000e+00 +1.902248289345063459e-01 0.000000000000000000e+00 +1.904203323558162353e-01 0.000000000000000000e+00 +1.906158357771260969e-01 0.000000000000000000e+00 +1.908113391984359586e-01 0.000000000000000000e+00 +1.910068426197458480e-01 0.000000000000000000e+00 +1.912023460410557096e-01 0.000000000000000000e+00 +1.913978494623655990e-01 0.000000000000000000e+00 +1.915933528836754607e-01 0.000000000000000000e+00 +1.917888563049853501e-01 0.000000000000000000e+00 +1.919843597262952117e-01 0.000000000000000000e+00 +1.921798631476050734e-01 0.000000000000000000e+00 +1.923753665689149628e-01 0.000000000000000000e+00 +1.925708699902248244e-01 0.000000000000000000e+00 +1.927663734115347138e-01 0.000000000000000000e+00 +1.929618768328445755e-01 0.000000000000000000e+00 +1.931573802541544371e-01 0.000000000000000000e+00 +1.933528836754643265e-01 0.000000000000000000e+00 +1.935483870967741882e-01 0.000000000000000000e+00 +1.937438905180840776e-01 0.000000000000000000e+00 +1.939393939393939392e-01 0.000000000000000000e+00 +1.941348973607038009e-01 0.000000000000000000e+00 +1.943304007820136903e-01 0.000000000000000000e+00 +1.945259042033235519e-01 0.000000000000000000e+00 +1.947214076246334413e-01 0.000000000000000000e+00 +1.949169110459433030e-01 0.000000000000000000e+00 +1.951124144672531646e-01 0.000000000000000000e+00 +1.953079178885630540e-01 0.000000000000000000e+00 +1.955034213098729157e-01 0.000000000000000000e+00 +1.956989247311828051e-01 0.000000000000000000e+00 +1.958944281524926667e-01 0.000000000000000000e+00 +1.960899315738025284e-01 0.000000000000000000e+00 +1.962854349951124178e-01 0.000000000000000000e+00 +1.964809384164222794e-01 0.000000000000000000e+00 +1.966764418377321688e-01 0.000000000000000000e+00 +1.968719452590420305e-01 0.000000000000000000e+00 +1.970674486803519199e-01 0.000000000000000000e+00 +1.972629521016617815e-01 0.000000000000000000e+00 +1.974584555229716432e-01 0.000000000000000000e+00 +1.976539589442815326e-01 0.000000000000000000e+00 +1.978494623655913942e-01 0.000000000000000000e+00 +1.980449657869012836e-01 0.000000000000000000e+00 +1.982404692082111453e-01 0.000000000000000000e+00 +1.984359726295210069e-01 0.000000000000000000e+00 +1.986314760508308963e-01 0.000000000000000000e+00 +1.988269794721407580e-01 0.000000000000000000e+00 +1.990224828934506474e-01 0.000000000000000000e+00 +1.992179863147605090e-01 0.000000000000000000e+00 +1.994134897360703707e-01 0.000000000000000000e+00 +1.996089931573802601e-01 0.000000000000000000e+00 +1.998044965786901217e-01 0.000000000000000000e+00 +2.000000000000000111e-01 0.000000000000000000e+00 diff --git a/src/.ipynb_checkpoints/common-checkpoint.c b/src/.ipynb_checkpoints/common-checkpoint.c new file mode 100644 index 0000000..cf7429f --- /dev/null +++ b/src/.ipynb_checkpoints/common-checkpoint.c @@ -0,0 +1,750 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +#ifdef _HAVE_OMP +static double relbeg,relend,absbeg,absend; +#else //_HAVE_OMP +static time_t relbeg,relend,absbeg,absend; +#endif //_HAVE_OMP +int NodeThis=0; +int NodeLeft=0; +int NodeRight=0; +int NNodes=1; +int IThread0=0; +int MPIThreadsOK=0; + +void *my_malloc(size_t size) +{ + void *ptrout=malloc(size); + if(ptrout==NULL) { + fprintf(stderr,"out of memory\n"); + exit(1); + } + + return ptrout; +} + +void *my_calloc(size_t nmemb,size_t size) +{ + void *ptrout=calloc(nmemb,size); + if(ptrout==NULL) { + fprintf(stderr,"out of memory\n"); + exit(1); + } + + return ptrout; +} + +void error_open_file(char *fname) +{ + fprintf(stderr,"CoLoRe: Couldn't open file %s \n",fname); + exit(1); +} + +void error_read_line(char *fname,int nlin) +{ + fprintf(stderr,"CoLoRe: Error reading file %s, line %d \n",fname,nlin); + exit(1); +} + +int linecount(FILE *f) +{ + ////// + // Counts #lines from file + int i0=0; + char ch[1000]; + while((fgets(ch,sizeof(ch),f))!=NULL) { + i0++; + } + return i0; +} + +typedef struct { + int i; + flouble d; +} IsortStruct; + +static int compareIsort(const void *a,const void *b) +{ + IsortStruct *ia=(IsortStruct *)a; + IsortStruct *ib=(IsortStruct *)b; + if(ia->dd) return -1; + else return 1; +} + +int *ind_sort(int n,flouble *arr) +{ + int i; + IsortStruct *st=my_malloc(n*sizeof(IsortStruct)); + for(i=0;i initialize relative clock + // timer(1) -> read relative clock + // timer(2) -> read relative clock and initialize it afterwards + // timer(4) -> initialize absolute clock + // timer(5) -> read absolute clock +#ifdef _HAVE_OMP + if(i==0) + relbeg=omp_get_wtime(); + else if(i==1) { + relend=omp_get_wtime(); + printf("> Relative time ellapsed %.1lf ms\n",1000*(relend-relbeg)); + } + else if(i==2) { + relend=omp_get_wtime(); + printf("> Relative time ellapsed %.1lf ms\n",1000*(relend-relbeg)); + relbeg=omp_get_wtime(); + } + else if(i==4) + absbeg=omp_get_wtime(); + else if(i==5) { + absend=omp_get_wtime(); + printf("> Total time ellapsed %.1lf ms\n",1000*(absend-absbeg)); + } +#else //_NO_OMP + int diff; + + if(i==0) + relbeg=time(NULL); + else if(i==1) { + relend=time(NULL); + diff=(int)(difftime(relend,relbeg)); + printf("> Relative time ellapsed %02d:%02d:%02d \n", + diff/3600,(diff/60)%60,diff%60); + } + else if(i==2) { + relend=time(NULL); + diff=(int)(difftime(relend,relbeg)); + printf("> Relative time ellapsed %02d:%02d:%02d \n", + diff/3600,(diff/60)%60,diff%60); + relbeg=time(NULL); + } + else if(i==4) + absbeg=time(NULL); + else if(i==5) { + absend=time(NULL); + diff=(int)(difftime(absend,absbeg)); + printf("> Total time ellapsed %02d:%02d:%02d \n", + diff/3600,(diff/60)%60,diff%60); + } +#endif //_NO_OMP +} + +gsl_rng *init_rng(unsigned int seed) +{ + // gsl_rng *rng=gsl_rng_alloc(gsl_rng_ranlux); + gsl_rng *rng=gsl_rng_alloc(gsl_rng_mt19937); + gsl_rng_set(rng,seed); + + return rng; +} + +double rng_01(gsl_rng *rng) +{ + double result=gsl_rng_uniform(rng); + return result; +} + +int rng_poisson(double lambda,gsl_rng *rng) +{ + unsigned int pois=gsl_ran_poisson(rng,lambda); + return (int)pois; +} + +void rng_delta_gauss(double *module,double *phase, + gsl_rng *rng,double sigma2) +{ + ////// + // Returns module and phase of two random + // gaussian numbers. I.e.: + double u; + *phase=2*M_PI*rng_01(rng); + u=rng_01(rng); + *module=sqrt(-sigma2*log(1-u)); +} + +void rng_gauss(gsl_rng *rng,double *r1,double *r2) +{ + double phase=2*M_PI*rng_01(rng); + double u=sqrt(-2*log(1-rng_01(rng))); + *r1=u*cos(phase); + *r2=u*sin(phase); +} + +void end_rng(gsl_rng *rng) +{ + gsl_rng_free(rng); +} + +void mpi_init(int* p_argc,char*** p_argv) +{ +#ifdef _HAVE_MPI + int ii,nthreads_this; + int *nthreads_all; +#ifdef _HAVE_OMP + int provided; + MPI_Init_thread(p_argc,p_argv,MPI_THREAD_FUNNELED,&provided); + MPIThreadsOK=provided>=MPI_THREAD_FUNNELED; +#else //_HAVE_OMP + MPI_Init(p_argc,p_argv); + MPIThreadsOK=0; +#endif //_HAVE_OMP + + MPI_Comm_size(MPI_COMM_WORLD,&NNodes); + MPI_Comm_rank(MPI_COMM_WORLD,&NodeThis); + if(NodeThis==0) + NodeLeft=NNodes-1; + else + NodeLeft=NodeThis-1; + if(NodeThis==NNodes-1) + NodeRight=0; + else + NodeRight=NodeThis+1; + + nthreads_all=my_malloc(NNodes*sizeof(int)); +#ifdef _HAVE_OMP + nthreads_this=omp_get_max_threads(); +#else //_HAVE_OMP + nthreads_this=1; +#endif //_HAVE_OMP + MPI_Allgather(&nthreads_this,1,MPI_INT,nthreads_all,1,MPI_INT,MPI_COMM_WORLD); +#ifdef _DEBUG + if(NodeThis==0) { + for(ii=0;iiNSIDE_MAX_HPX) + n_extra/=2; + if(n_extra<=0) n_extra=1; //This should never happen + + int i_extra=(int)(n_extra*n_extra*rng_01(rng)); + pix2ang_nest(nside*n_extra, + (ipix0+ipix_nest)*n_extra*n_extra+i_extra,th,phi); + (*phi)+=(rng_01(rng)-0.5)*0.57/(nside*n_extra); + (*th)+=(rng_01(rng)-0.5)*0.57/(nside*n_extra); +} +*/ + +void get_radial_params(double rmax,int ngrid,int *nr,double *dr) +{ + *nr=NSAMP_RAD*ngrid/2; + *dr=rmax/(*nr); +} + +CatalogCartesian *catalog_cartesian_alloc(int nsrcs) +{ + CatalogCartesian *cat=my_malloc(sizeof(CatalogCartesian)); + + if(nsrcs>0) { + cat->nsrc=nsrcs; + cat->pos=my_malloc(NPOS_CC*nsrcs*sizeof(float)); + cat->ipix=my_malloc(nsrcs*sizeof(int)); + } + else { + cat->nsrc=0; + cat->pos=NULL; + cat->ipix=NULL; + } + + return cat; +} + +void catalog_cartesian_free(CatalogCartesian *cat) +{ + if(cat->nsrc>0) { + free(cat->pos); + free(cat->ipix); + } + free(cat); +} + +Catalog *catalog_alloc(int nsrcs,int has_lensing,int has_skw, + int skw_gauss,double rmax,int ng) +{ + Catalog *cat=my_malloc(sizeof(Catalog)); + + if(nsrcs>0) { + cat->nsrc=nsrcs; + cat->srcs=my_malloc(nsrcs*sizeof(Src)); + cat->has_lensing=has_lensing; + cat->has_skw=has_skw; + cat->skw_gauss=skw_gauss; + get_radial_params(rmax,ng,&(cat->nr),&(cat->dr)); + cat->rmax=rmax; + cat->idr=1./cat->dr; + if(has_skw) { + if(skw_gauss) { + cat->g_skw=my_calloc(cat->nsrc*cat->nr,sizeof(float)); + } + else { + cat->d_skw=my_calloc(cat->nsrc*cat->nr,sizeof(float)); + } + cat->v_skw=my_calloc(cat->nsrc*cat->nr,sizeof(float)); + } + } + else { + cat->nsrc=0; + cat->srcs=NULL; + cat->has_skw=0; + } + + return cat; +} + +void catalog_free(Catalog *cat) +{ + if(cat->nsrc>0) { + free(cat->srcs); + if(cat->has_skw) { + if(cat->skw_gauss) { + free(cat->g_skw); + } + else { + free(cat->d_skw); + } + free(cat->v_skw); + } + } + free(cat); +} + +void hp_shell_adaptive_free(HealpixShellsAdaptive *shell) +{ + int ib,ir; + free(shell->r); + free(shell->nside); + free(shell->num_pix_per_beam); + for(ib=0;ibnbeams;ib++) { + for(ir=0;irnr;ir++) + free(shell->data[ib][ir]); + free(shell->data[ib]); + free(shell->pos[ib]); + } + free(shell->data); + free(shell->pos); + free(shell); +} + +static int *get_adaptive_nside(int nside_max, int nside_base, + int nr, flouble *r_arr, flouble dx, flouble dx_fraction) +{ + int ir; + int *nsides=my_malloc(nr*sizeof(int)); + for(ir=0; irNSIDE_MAX_HPX) + report_error(1,"Can't go beyond nside=%d\n",NSIDE_MAX_HPX); + if(nside_maxnbeams=0; + for(ib=NodeThis;ibnbeams++; + + shell->nq=nq; + shell->nr=nr; + shell->nside=get_adaptive_nside(nside_max, nside_base, nr, + r_arr, dx, dx_fraction); + shell->num_pix_per_beam=my_malloc(nr*sizeof(long)); + shell->r=my_malloc(nr*sizeof(flouble)); + for(ir=0; irr[ir]=r_arr[ir]; + nside_ratio=shell->nside[ir]/nside_base; + shell->num_pix_per_beam[ir]=nside_ratio*nside_ratio; + } + + long npix_hi=shell->num_pix_per_beam[nr-1]; + shell->data=my_malloc(shell->nbeams*sizeof(flouble **)); + shell->pos=my_malloc(shell->nbeams*sizeof(double **)); + for(ib=0;ibnbeams;ib++) { + shell->data[ib]=my_malloc(nr*sizeof(flouble *)); + shell->pos[ib]=my_malloc(npix_hi*3*sizeof(double)); + for(ir=0; irdata[ib][ir]=my_malloc(shell->nq*shell->num_pix_per_beam[ir]*sizeof(flouble)); + } + + for(ib=0;ibnbeams;ib++) { + long ip, ip0=(ib*NNodes+NodeThis)*npix_hi; + double *u=shell->pos[ib]; + for(ip=0;ipnside[nr-1],id_nest,u); + u+=3; + } + } + return shell; +} + +HealpixShells *hp_shell_alloc(int nq, int nside,int nside_base,int nr) +{ + if(nside>NSIDE_MAX_HPX) + report_error(1,"Can't go beyond nside=%d\n",NSIDE_MAX_HPX); + if(nsidenq=nq; + shell->nside=nside; + shell->num_pix=nside_ratio*nside_ratio*nbeams_here; + shell->listpix=my_malloc(shell->num_pix*sizeof(long)); + shell->pos=my_malloc(3*shell->num_pix*sizeof(double)); + + double *u=shell->pos; + long ipix=0; + for(ib=NodeThis;iblistpix[ipix]=id_nest; + pix2vec_nest(shell->nside,id_nest,u); + u+=3; + ipix++; + } + } + + //Figure out radial shells + shell->nr=nr; + shell->r0=my_malloc(shell->nr*sizeof(flouble)); + shell->rf=my_malloc(shell->nr*sizeof(flouble)); + + //Zero all data and clear + shell->data=my_calloc(shell->nq*shell->nr*shell->num_pix,sizeof(flouble)); + shell->nadd=my_calloc(shell->nr*shell->num_pix,sizeof(int)); + + return shell; +} + +void hp_shell_free(HealpixShells *shell) +{ + if(shell->listpix!=NULL) + free(shell->listpix); + if(shell->pos!=NULL) + free(shell->pos); + if(shell->r0!=NULL) + free(shell->r0); + if(shell->rf!=NULL) + free(shell->rf); + if(shell->data!=NULL) + free(shell->data); + if(shell->nadd!=NULL) + free(shell->nadd); + free(shell); +} + +unsigned long long get_max_memory(ParamCoLoRe *par,int just_test) +{ + unsigned long long total_GB=0; + unsigned long long total_GB_gau=0; + unsigned long long total_GB_lpt=0; + int fac_gau=2; + if(par->need_beaming) fac_gau=3; + + total_GB_gau=(fac_gau*(par->nz_here+1)*((long)(par->n_grid*(par->n_grid/2+1))))*sizeof(dftw_complex); + + if(par->dens_type==DENS_TYPE_1LPT) { + total_GB_lpt=(unsigned long long)(3*(1+par->lpt_buffer_fraction)*par->nz_here* + ((long)((par->n_grid/2+1)*par->n_grid))*sizeof(dftw_complex)); + } + else if(par->dens_type==DENS_TYPE_2LPT) { + total_GB_lpt=0; + total_GB_lpt=(unsigned long long)(8*(1+par->lpt_buffer_fraction)*par->nz_here* + ((long)((par->n_grid/2+1)*par->n_grid))*sizeof(dftw_complex)); + } + + unsigned long long total_GB_srcs=0; + if(par->do_srcs) { + int ipop; + for(ipop=0;ipopn_srcs;ipop++) { + int nz,ii; + long nsrc=0; + double nztot=0; + FILE *fi=fopen(par->fnameNzSrcs[ipop],"r"); + + double *zarr,*nzarr; + if(fi==NULL) error_open_file(par->fnameNzSrcs[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + nzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameNzSrcs[ipop],ii+1); + nzarr[ii]*=RTOD*RTOD; + } + for(ii=0;ii=par->z_min) && (zarr[ii]<=par->z_max)) + nztot+=nzarr[ii]*(zarr[ii+1]-zarr[ii]); + } + if((zarr[ii]>=par->z_min) && (zarr[ii]<=par->z_max)) + nztot+=nzarr[ii]*(zarr[ii+1]-zarr[ii]); + nztot*=4*M_PI/NNodes; + nsrc+=(long)(nztot); + if(just_test) + print_info(" Expect %ld type-%d sources\n",(long)(nztot*NNodes),ipop); + free(zarr); + free(nzarr); + fclose(fi); + + long size_source=sizeof(Src)+NPOS_CC*sizeof(float)+sizeof(int); + if(par->skw_srcs[ipop]) { + int nr=NSAMP_RAD*par->n_grid/2; + size_source+=2*nr*sizeof(float); + } + total_GB_srcs+=size_source*nsrc; + } + } + + unsigned long long total_GB_imap=0; + if(par->do_imap) { + int ipop; + for(ipop=0;ipopn_imap;ipop++) { + int nr; + unsigned long long size_map=he_nside2npix(par->nside_imap[ipop]); + FILE *fnu=fopen(par->fnameNuImap[ipop],"r"); + if(fnu==NULL) error_open_file(par->fnameNuImap[ipop]); + nr=linecount(fnu); + fclose(fnu); + total_GB_imap+=size_map*nr*(sizeof(flouble)+sizeof(int)); + } + } + + unsigned long long total_GB_cstm=0; + if(par->do_cstm) { + int ipop; + for(ipop=0;ipopn_cstm;ipop++) { + unsigned long long size_map=he_nside2npix(par->nside_cstm[ipop]); + total_GB_cstm+=size_map*(sizeof(flouble)+sizeof(int)); + } + } + + unsigned long long total_GB_kappa=0; + if(par->do_kappa) { + int ib; + int nr=par->n_kappa; + int nbases=he_nside2npix(par->nside_base); + int nside_ratio=par->nside_kappa/par->nside_base; + int npix_perbeam=nside_ratio*nside_ratio; + unsigned long long size_map=0; + for(ib=NodeThis;ibdo_lensing) { + int ib,ir; + int nr=par->n_lensing; + int nbases=he_nside2npix(par->nside_base); + flouble *rs=compute_lensing_spacing(par); + int *nsides=get_adaptive_nside(par->nside_lensing, + par->nside_base, nr, rs, + par->l_box/par->n_grid, 1.); + int nbeams_here=0; + for(ib=NodeThis;ibnside_base; + npix_total+=nside_ratio*nside_ratio; + } + npix_total*=nbeams_here; + int nside_ratio_hi=nsides[nr-1]/par->nside_base; + unsigned long long npix_hi=nside_ratio_hi*nside_ratio_hi*nbeams_here; + total_GB_lensing+=npix_total*5*sizeof(flouble)+npix_hi*3*sizeof(double); + free(rs); + free(nsides); + } + + unsigned long long total_GB_isw=0; + if(par->do_isw) { + int ib; + int nr=par->n_isw; + int nbases=he_nside2npix(par->nside_base); + int nside_ratio=par->nside_isw/par->nside_base; + int npix_perbeam=nside_ratio*nside_ratio; + unsigned long long size_map=0; + for(ib=NodeThis;ibdens_type==DENS_TYPE_1LPT) || (par->dens_type==DENS_TYPE_2LPT)) + printf(", %.3lf GB (%dLPT)",(double)(total_GB_lpt/pow(1024.,3)),par->dens_type); + if(par->do_srcs) + printf(", %.3lf GB (srcs)",(double)(total_GB_srcs/pow(1024.,3))); + if(par->do_imap) + printf(", %.3lf GB (imap)",(double)(total_GB_imap/pow(1024.,3))); + if(par->do_kappa) + printf(", %.3lf MB (kappa)",(double)(total_GB_kappa/pow(1024.,2))); + if(par->do_lensing) + printf(", %.3lf MB (lensing)",(double)(total_GB_lensing/pow(1024.,2))); + if(par->do_isw) + printf(", %.3lf MB (isw)",(double)(total_GB_isw/pow(1024.,2))); + if(par->do_cstm) + printf(", %.3lf MB (custom)",(double)(total_GB_cstm/pow(1024.,2))); + printf("]\n"); + } +#ifdef _HAVE_MPI + MPI_Barrier(MPI_COMM_WORLD); +#endif //_HAVE_MPI + } +#endif //_DEBUG + + if(just_test==0) { + void *ptest=my_malloc(total_GB); + free(ptest); + } + + return total_GB; +} diff --git a/src/.ipynb_checkpoints/common-checkpoint.h b/src/.ipynb_checkpoints/common-checkpoint.h new file mode 100644 index 0000000..309c87e --- /dev/null +++ b/src/.ipynb_checkpoints/common-checkpoint.h @@ -0,0 +1,618 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#ifndef _COMMON_ +#define _COMMON_ + +#include +#include +#include +#include +#include +#include +#include +#ifdef _HAVE_OMP +#include +#endif //_HAVE_OMP +#include +#include +#include +#include +#include +#include "fftw3.h" +#ifdef _HAVE_MPI +#include +#include +#endif //_HAVE_MPI +#include +#ifdef _HAVE_FITS +#include +#endif //_HAVE_FITS +#ifdef _HAVE_HDF5 +#include +#include +#endif //_HAVE_HDF5 +#include +#ifdef _WITH_SHT +#include +#include +#include +#ifdef _WITH_NEEDLET +#include +#endif //_WITH_NEEDLET +#endif //_WITH_SHT +#include "cosmo_mad.h" + +///////// +// Interpolation parameters + +#define INTERP_NGP 0 +#define INTERP_CIC 1 +#define INTERP_TSC 2 +#define RETURN_DENS 1 +#define RETURN_VEL 2 +#define RETURN_TID 4 +#define RETURN_PDOT 8 +#define RETURN_GAUSS 16 + +// Radial spacing +#define SPACING_R 0 +#define SPACING_LOGZ 1 + +//Interpolation type +#ifndef INTERP_TYPE_SKW +#define INTERP_TYPE_SKW INTERP_CIC +#endif //INTERP_TYPE_SKW +#ifndef INTERP_TYPE_LENSING +#define INTERP_TYPE_LENSING INTERP_NGP +#endif //INTERP_TYPE_LENSING + +//dr_par = dx/NSAMP_RAD +#ifndef NSAMP_RAD +#define NSAMP_RAD 1 +#endif //NSAMP_RAD + +//Maximum allowed healpix resolution +#define NSIDE_MAX_HPX 8192 + +//Background tags +#define BG_Z 1000 +#define BG_D1 1001 +#define BG_D2 1002 +#define BG_V1 1003 +#define BG_PD 1004 +#define BG_IH 1005 +#define BG_NZ_SRCS 1006 +#define BG_BZ_SRCS 1007 +#define BG_NORM_SRCS 1008 +#define BG_TZ_IMAP 1009 +#define BG_BZ_IMAP 1010 +#define BG_NORM_IMAP 1011 +#define BG_KZ_CSTM 1012 +#define BG_BZ_CSTM 1013 +#define BG_NORM_CSTM 1014 + +//Density field parameters +#define DZ_SIGMA 0.05 +#define DENS_TYPE_LGNR 0 +#define DENS_TYPE_1LPT 1 +#define DENS_TYPE_2LPT 2 +#define DENS_TYPE_CLIP 3 + +// End of interpolation parameters +///////// + +#define DYNAMIC_SIZE 1 +#define RTOD 57.2957795 +#define DTOR 0.01745329251 +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) +#define MAX(a, b) (((a) > (b)) ? (a) : (b)) +#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) + +#define TWOPIPIINVLOGTEN 0.1166503235296796 //ln(10)/(2*pi^2) +#define TWOPIPIINV 0.05066059182116889 //1/(2*pi^2) +#define NA 5001 +#define NPOP_MAX 10 +#define NPLANES_MAX 100 + +#ifdef _HAVE_MPI +#ifdef _SPREC +#define FLOUBLE_MPI MPI_FLOAT +#else //_SPREC +#define FLOUBLE_MPI MPI_DOUBLE +#endif //_SPREC +#endif //_HAVE_MPI + +#ifdef _SPREC +typedef float flouble; +typedef float complex fcomplex; +typedef fftwf_complex dftw_complex; +#else //_SPREC +typedef double flouble; +typedef double complex fcomplex; +typedef fftw_complex dftw_complex; +#endif //_SPREC + +//Defined in common.c +extern int NodeThis; +extern int NodeLeft; +extern int NodeRight; +extern int NNodes; +extern int IThread0; +extern int MPIThreadsOK; + +#ifdef TVEL +#define NPOS_CC 6 +#else +#define NPOS_CC 4 +#endif + +typedef struct { + int nsrc; + float *pos; + int *ipix; +} CatalogCartesian; + +typedef struct { + float ra; //Right ascension + float dec; //Declination + float z0; //Cosmological redshift + float dz_rsd; //RSD contribution +#ifdef TVEL + float vtheta; + float vphi; +#endif + float e1; + float e2; + float kappa; + float dra; + float ddec; +} Src; + +typedef struct { + int nsrc; + Src *srcs; + int nr; + double rmax; + double dr; + double idr; + int has_lensing; + int has_skw; + int skw_gauss; + float *d_skw; + float *g_skw; + float *v_skw; +} Catalog; + +typedef struct { + int nq; + int nr; //Number of spherical shells + flouble *r; //r in this shell + int *nside; //Resolution parameter + long *num_pix_per_beam; + int nbeams; //Number of different bases + double **pos; //3D positions of the pixels in the furthest shell + flouble ***data; +} HealpixShellsAdaptive; + +typedef struct { + int nq; //Number of quantities to map + int nside; //Resolution parameter + long num_pix; + long *listpix; + double *pos; + int nr; //Number of spherical shells + flouble *r0; //r_min in this shell + flouble *rf; //r_max in this shell + flouble *data; + int *nadd; +} HealpixShells; + +typedef struct { + +#ifdef _DEBUG + FILE *f_dbg; //File into which all debug info is written +#endif //_DEBUG + + //Cosmological parameters + // Background + double OmegaM; //Cosmological parameters + double OmegaL; //Cosmological parameters + double OmegaB; //Cosmological parameters + double hhub; //Cosmological parameters + double weos; //Cosmological parameters + double n_scal; //Cosmological parameters + double sig8; //Cosmological parameters + double fgrowth_0; //Growth rate at z=0 + double hubble_0; //Expansion rate at z=0 (inverse length units) + double prefac_lensing; //3*O_M*H_0^2/2 + double z_max; //Maximum redshift + double z_min; //Minimum redshift + double r_max; //Maximum radial comoving distance + double r_min; //Minimum radial comoving distance + double a_arr_a2r[NA]; //Array of redshifts used to compute r(z) + double r_arr_a2r[NA]; //Array of comoving distances used to compute r(z) + double z_arr_r2z[NA]; //Array of redshifts used to compute z(r) + double r_arr_r2z[NA]; //Array of comoving distances used to compute z(r), D_d(r), D_v(r), 1/H(z) + double growth_d_arr[NA]; //Array of density growth factors used to compute D_d(r) + double growth_d2_arr[NA]; //Array of density growth factors used to compute D_d(r) + double growth_v_arr[NA]; //Array of velocity growth factors used to compute D_v(r) + double growth_pd_arr[NA]; //Array of potential derivative factors used to compute \dot{\phi} + double ihub_arr[NA]; //Array of 1/H(z) + double glob_idr; //1/dr, where dr is the radial comoving distance interval used in the arrays above + // Power spectra + char fnamePk[256]; //File containing power spectrum + int numk; //Number of k-values + double logkmax; //Maximum log10(k) + double logkmin; //Minimum log10(k) + double idlogk; //1/D(log10(k)) + double *logkarr; //Array of log10(k) values (units of h/Mpc) + double *pkarr; //Array of power spectrum values (units of (Mpc/h)^3) + + //Density parameters + // Density methods + int output_density; //Do you want to output the density grid? + double r2_smooth; //Square of the smoothing scale + int do_smoothing; //Are we smoothing the density field? + int smooth_potential; //Do we smooth the newtonian potential as well? + int dens_type; //Method to produce the density field + int lpt_interp_type; + double lpt_buffer_fraction; //Fraction of memory saved for buffer particles + int output_lpt; + unsigned int seed_rng; //RNG seed + // Box parameters + int n_grid; //Number of cells per side for the Cartesian grid + flouble l_box; //Box size for the cartesian grid + int nz_here; //Number of cells in the z-direction stored in this node + int iz0_here; //index of the first cell in the z-direction stored in this node + int nz_max; + int *nz_all; + int *iz0_all; + double z0_norm; + double zf_norm; + // Density grids + dftw_complex *grid_dens_f; //Fourier-space grid for the density field + flouble *grid_dens; //Real-space grid for the density field + dftw_complex *grid_npot_f; //Fourier-space grid for the Newtonian potential + flouble *grid_npot; //Real-space grid for the Newtonian potential + flouble *slice_left; //Dummy array to store grid cells coming from the left node + flouble *slice_right; //Dummy array to store grid cells coming from the right node + double sigma2_gauss; //Variance of the cartesian density field + + //IO parameters + char prefixOut[256]; //Output prefix + int output_format; //0-> ASCII, 1-> FITS, 2-> HDF5 + double pos_obs[3]; //Observer position + + //Tracers + // Custom + int do_cstm; //Do we include custom maps? + int n_cstm; //Number of custom maps + char fnameBzCstm[NPOP_MAX][256]; //Files containing b(z) for each source type + char fnameKzCstm[NPOP_MAX][256]; //Files containing K(z) + double *cstm_kz_arr[NPOP_MAX]; + double *cstm_bz_arr[NPOP_MAX]; + double *cstm_norm_arr[NPOP_MAX]; + double norm_cstm_0[NPOP_MAX]; //Bottom edge of spline for density normalization + double norm_cstm_f[NPOP_MAX]; //Top edge of spline for density normalization + int nside_cstm[NPOP_MAX]; //Output angular resolution for each IM species + HealpixShells **cstm; //Maps for each custom map tracer + // Sources + int do_srcs; //Do we include sources? + int do_skewers; //Do we include skewer information? + int do_srcs_lensing; //Do we need to compute the lensing potential? + int n_srcs; //Number of source types + char fnameBzSrcs[NPOP_MAX][256]; //Files containing b(z) for each source type + char fnameNzSrcs[NPOP_MAX][256]; //Files containing dN/dzdOmega (in deg^-2) + double *srcs_nz_arr[NPOP_MAX]; + double *srcs_bz_arr[NPOP_MAX]; + double *srcs_norm_arr[NPOP_MAX]; + double norm_srcs_0[NPOP_MAX]; //Bottom edge of spline for density normalization + double norm_srcs_f[NPOP_MAX]; //Top edge of spline for density normalization + int lensing_srcs[NPOP_MAX]; //Do we do lensing for this source type? + int skw_srcs[NPOP_MAX]; //Do we want to store skewers for each source of this type? + int skw_gauss[NPOP_MAX]; //Do we want the skewers to be gaussian? (as opposed to physical density) + long *nsources_c_this; //Number of sources initially found in this node + CatalogCartesian **cats_c; //Galaxy positions initially stored in this node + long *nsources_this; //Number of sources finally found in this node + Catalog **cats; //Final galaxy properties + // Intensity mapping + int do_imap; //Do we include intensity mapping + int n_imap; //Number of IM species + char fnameBzImap[NPOP_MAX][256]; //Files containing b(z) for each IM species + char fnameTzImap[NPOP_MAX][256]; //Files containing T(z) for each IM species + char fnameNuImap[NPOP_MAX][256]; //Files containing frequency table for each IM species + double *imap_tz_arr[NPOP_MAX]; + double *imap_bz_arr[NPOP_MAX]; + double *imap_norm_arr[NPOP_MAX]; + double norm_imap_0[NPOP_MAX]; //Bottom edge of spline for density normalization + double norm_imap_f[NPOP_MAX]; //Top edge of spline for density normalization + int nside_imap[NPOP_MAX]; //Output angular resolution for each IM species + double nu0_imap[NPOP_MAX]; //Rest-frame frequency for each IM species + HealpixShells **imap; //intensity maps for each IM species + // Kappa + int do_kappa; //Do you want to output kappa maps? + int n_kappa; //How many maps? + double z_kappa_out[NPLANES_MAX]; //Array of source plane redshifts + int nside_kappa; + HealpixShells *kmap; //Kappa maps at each redshift +#ifdef _ADD_EXTRA_KAPPA + int *need_extra_kappa; + flouble **fl_mean_extra_kappa; + flouble **cl_extra_kappa; +#endif //_ADD_EXTRA_KAPPA + // Lensing + int do_lensing; //Do you want to create lensing maps? + int write_lensing; //Do you want to output lensing maps? + int lensing_spacing_type; //log(1+z)? r? + int n_lensing; //How many maps? + int nside_lensing; + HealpixShellsAdaptive *smap; //Lensing maps at each redshift + // ISW + int do_isw; //Do you want to output isw maps? + int n_isw; //How many maps? + double z_isw_out[NPLANES_MAX]; //Array of source plane redshifts + int nside_isw; + HealpixShells *pd_map; //Isw maps at each redshift +#ifdef _ADD_EXTRA_KAPPA + int *need_extra_isw; + flouble **fl_mean_extra_isw; + flouble **cl_extra_isw; +#endif //_ADD_EXTRA_KAPPA + + //Lognormal predictions + int do_pred; + int just_do_pred; + double pred_dz; + + //Beam distribution + int nside_base; //Minimum n_side used in the pixelization + int npix_base; //Corresponding number of pixels + int need_beaming; //Do we need spherical voxels at all? +} ParamCoLoRe; + +void mpi_init(int* p_argc,char*** p_argv); +void *my_malloc(size_t size); +void *my_calloc(size_t nmemb,size_t size); +size_t my_fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream); +void error_open_file(char *fname); +void error_read_line(char *fname,int nlin); +void print_info(char *fmt,...); +void report_error(int level,char *fmt,...); +int linecount(FILE *f); +int *ind_sort(int n,flouble *arr); +void timer(int i); +gsl_rng *init_rng(unsigned int seed); +double rng_01(gsl_rng *rng); +int rng_poisson(double lambda,gsl_rng *rng); +void rng_delta_gauss(double *module,double *phase, + gsl_rng *rng,double sigma2); +void rng_gauss(gsl_rng *rng,double *r1,double *r2); +void end_rng(gsl_rng *rng); +unsigned long long get_max_memory(ParamCoLoRe *par,int just_test); +void get_radial_params(double rmax,int ngrid,int *nr,double *dr); +//void get_random_angles(gsl_rng *rng,int ipix_nest,int ipix0,int nside,double *th,double *phi); +HealpixShells *hp_shell_alloc(int nq,int nside,int nside_base,int nr); +HealpixShellsAdaptive *hp_shell_adaptive_alloc(int nq, int nside_max, int nside_base,int nr, + flouble *r_arr, flouble dx, flouble dx_fraction); +void hp_shell_free(HealpixShells *shell); +void hp_shell_adaptive_free(HealpixShellsAdaptive *shell); +CatalogCartesian *catalog_cartesian_alloc(int nsrcs); +void catalog_cartesian_free(CatalogCartesian *cat); +Catalog *catalog_alloc(int nsrcs,int has_lensing,int has_skw,int skw_gauss,double rmax,int ng); +void catalog_free(Catalog *cat); + +static inline double bias_model(double d,double b) +{ + if(d<=-1) + return 0; +#ifdef _BIAS_MODEL_2 + if(d < 0) + return exp(b*d/(1+d)); + else + return 1+b*d; +#elif defined _BIAS_MODEL_3 + if(1+b*d>0) + return 1+b*d; + else + return 0; +#else //_BIAS_MODEL + return pow(1+d,b); +#endif //_BIAS_MODEL +} + + +////// +// Functions defined in cosmo.c +double pk_linear0(ParamCoLoRe *par,double lgk); +void cosmo_set(ParamCoLoRe *par); +double r_of_z(ParamCoLoRe *par,double z); +double get_bg(ParamCoLoRe *par,double r,int tag,int ipop); +void compute_tracer_cosmo(ParamCoLoRe *par); +flouble *compute_lensing_spacing(ParamCoLoRe *par); + +////// +// Functions defined in io.c +ParamCoLoRe *read_run_params(char *fname,int test_memory); +void write_density_grid(ParamCoLoRe *par,char *prefix_dens); +void write_lpt(ParamCoLoRe *par,unsigned long long npart,flouble *x,flouble *y,flouble *z); +void write_srcs(ParamCoLoRe *par); +void write_imap(ParamCoLoRe *par); +void write_cstm(ParamCoLoRe *par); +void write_kappa(ParamCoLoRe *par); +void write_lensing(ParamCoLoRe *par); +void write_isw(ParamCoLoRe *par); +void param_colore_free(ParamCoLoRe *par); + + +///// +// Functions defined in predictions.c +void write_predictions(ParamCoLoRe *par); + + +////// +// Functions defined in fourier.c +void init_fftw(ParamCoLoRe *par); +void allocate_fftw(ParamCoLoRe *par); +void create_cartesian_fields(ParamCoLoRe *par); +void end_fftw(ParamCoLoRe *par); +void fftw_wrap_c2r(int ng,dftw_complex *pin,flouble *pout); +void fftw_wrap_r2c(int ng,flouble *pin,dftw_complex *pout); + + +////// +// Functions defined in beaming.c +int interpolate_from_grid(ParamCoLoRe *par,double *x, + flouble *d,flouble v[3],flouble t[6],flouble *pd,flouble *g, + int flag_return,int interp_type); +void get_beam_properties(ParamCoLoRe *par); + + +////// +// Functions defined in density.c +void compute_physical_density_field(ParamCoLoRe *par); +void compute_density_normalization(ParamCoLoRe *par); + + +////// +// Functions defined in srcs.c +void srcs_set_cartesian(ParamCoLoRe *par); +void srcs_distribute(ParamCoLoRe *par); +void srcs_get_local_properties(ParamCoLoRe *par); +void srcs_beams_preproc(ParamCoLoRe *par); +void srcs_get_beam_properties(ParamCoLoRe *par); +void srcs_beams_postproc(ParamCoLoRe *par); + + +////// +// Functions defined in imap.c +void imap_set_cartesian(ParamCoLoRe *par); +void imap_distribute(ParamCoLoRe *par); +void imap_get_local_properties(ParamCoLoRe *par); +void imap_beams_preproc(ParamCoLoRe *par); +void imap_get_beam_properties(ParamCoLoRe *par); +void imap_beams_postproc(ParamCoLoRe *par); + + +////// +// Functions defined in cstm.c +void cstm_set_cartesian(ParamCoLoRe *par); +void cstm_distribute(ParamCoLoRe *par); +void cstm_get_local_properties(ParamCoLoRe *par); +void cstm_beams_preproc(ParamCoLoRe *par); +void cstm_get_beam_properties(ParamCoLoRe *par); +void cstm_beams_postproc(ParamCoLoRe *par); + + +////// +// Functions defined in kappa.c +void kappa_set_cartesian(ParamCoLoRe *par); +void kappa_distribute(ParamCoLoRe *par); +void kappa_get_local_properties(ParamCoLoRe *par); +void kappa_beams_preproc(ParamCoLoRe *par); +void kappa_get_beam_properties(ParamCoLoRe *par); +void kappa_beams_postproc(ParamCoLoRe *par); + + +////// +// Functions defined in lensing.c +void lensing_set_cartesian(ParamCoLoRe *par); +void lensing_distribute(ParamCoLoRe *par); +void lensing_get_local_properties(ParamCoLoRe *par); +void lensing_beams_preproc(ParamCoLoRe *par); +void lensing_get_beam_properties(ParamCoLoRe *par); +void lensing_beams_postproc(ParamCoLoRe *par); + + +////// +// Functions defined in isw.c +void isw_set_cartesian(ParamCoLoRe *par); +void isw_distribute(ParamCoLoRe *par); +void isw_get_local_properties(ParamCoLoRe *par); +void isw_beams_preproc(ParamCoLoRe *par); +void isw_get_beam_properties(ParamCoLoRe *par); +void isw_beams_postproc(ParamCoLoRe *par); + + +////// +// Defined in healpix_extra.c +long he_nside2npix(long nside); +double he_pixel_area(int nside); +long he_ang2pix(long nside,double cth,double phi); +void he_write_healpix_map(flouble **tmap,int nfields,long nside,char *fname,int isnest); +flouble *he_read_healpix_map(char *fname,long *nside,int nfield); +int he_ring_num(long nside,double z); +long *he_query_strip(long nside,double theta1,double theta2,long *npix_strip); +void he_ring2nest_inplace(flouble *map_in,long nside); +void he_nest2ring_inplace(flouble *map_in,long nside); +void he_udgrade(flouble *map_in,long nside_in,flouble *map_out,long nside_out,int nest); +#ifdef _WITH_SHT +#ifdef _SPREC +#define SHT_TYPE 0 +#else //_SPREC +#define SHT_TYPE SHARP_DP +#endif //_SPREC +#define HE_MAX_SHT 32 +#define HE_FWHM2SIGMA 0.00012352884853326381 //Transforms FWHM in arcmin to sigma_G in rad: +long he_nalms(int lmax); +long he_indexlm(int l,int m,int lmax); +void he_alm2map(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms); +void he_map2alm(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms); +void he_alm2cl(fcomplex **alms_1,fcomplex **alms_2, + int nmaps_1,int nmaps_2,int pol_1,int pol_2,flouble **cls,int lmax); +void he_anafast(flouble **maps_1,flouble **maps_2, + int nmaps_1,int nmaps_2,int pol_1,int pol_2, + flouble **cls,int nside,int lmax); +flouble *he_generate_beam_window(int lmax,flouble fwhm_amin); +void he_alter_alm(int lmax,flouble fwhm_amin,fcomplex *alm_in, + fcomplex *alm_out,flouble *window); +flouble *he_synfast(flouble *cl,int nside,int lmax,unsigned int seed); +//HE_NT +#ifdef _WITH_NEEDLET +#define HE_NBAND_NX 512 +#define HE_NORM_FT 2.2522836206907617 +#define HE_NL_INTPREC 1E-6 +#define HE_NT_NSIDE_MIN 32 +typedef struct { + double b; + double inv_b; + gsl_spline *b_spline; + gsl_interp_accel *b_intacc; + int nside0; + int nj; + int *nside_arr; + int *lmax_arr; + flouble **b_arr; +} HE_nt_param; +void he_nt_end(HE_nt_param *par); +HE_nt_param *he_nt_init(flouble b_nt,int nside0); +flouble ***he_alloc_needlet(HE_nt_param *par,int pol); +void he_free_needlet(HE_nt_param *par,int pol,flouble ***nt); +void he_nt_get_window(HE_nt_param *par,int j,flouble *b); +fcomplex **he_map2needlet(HE_nt_param *par,flouble **map,flouble ***nt, + int return_alm,int pol,int qu_in,int qu_out); +fcomplex **he_needlet2map(HE_nt_param *par,flouble **map,flouble ***nt, + int return_alm,int pol,int qu_in,int qu_out); +#endif //_WITH_NEEDLET +#endif //_WITH_SHT + + +#endif //_COMMON_ diff --git a/src/.ipynb_checkpoints/cosmo-checkpoint.c b/src/.ipynb_checkpoints/cosmo-checkpoint.c new file mode 100644 index 0000000..eee344d --- /dev/null +++ b/src/.ipynb_checkpoints/cosmo-checkpoint.c @@ -0,0 +1,868 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" +#include +#include + +#define CL_TYPE_KAPPA 0 +#define CL_TYPE_SHEAR 1 +#define CL_TYPE_ISW 2 + +static double f_of_r_linear(ParamCoLoRe *par,double r,double *f,double f0,double ff) +{ + if(r<=0) return f0; + else if(r>=par->r_arr_r2z[NA-1]) return ff; + else { + int ir=(int)(r*par->glob_idr); + return f[ir]+(f[ir+1]-f[ir])*(r-par->r_arr_r2z[ir])*par->glob_idr; + } +} + +double get_bg(ParamCoLoRe *par,double r,int tag,int ipop) +{ + if(tag==BG_Z) + return f_of_r_linear(par,r,par->z_arr_r2z,0,par->z_arr_r2z[NA-1]); + else if(tag==BG_D1) + return f_of_r_linear(par,r,par->growth_d_arr,1,par->growth_d_arr[NA-1]); + else if(tag==BG_D2) { + return f_of_r_linear(par,r,par->growth_d2_arr,par->growth_d2_arr[0], + par->growth_d2_arr[NA-1]); + } + else if(tag==BG_V1) + return f_of_r_linear(par,r,par->growth_v_arr,par->growth_v_arr[0],par->growth_v_arr[NA-1]); + else if(tag==BG_PD) { + return f_of_r_linear(par,r,par->growth_pd_arr,par->growth_pd_arr[0], + par->growth_pd_arr[NA-1]); + } + else if(tag==BG_IH) + return f_of_r_linear(par,r,par->ihub_arr,par->ihub_arr[0],par->ihub_arr[NA-1]); + else if(tag==BG_NZ_SRCS) + return f_of_r_linear(par,r,par->srcs_nz_arr[ipop],0,0); + else if(tag==BG_BZ_SRCS) + return f_of_r_linear(par,r,par->srcs_bz_arr[ipop],par->srcs_bz_arr[ipop][0],1); + else if(tag==BG_NORM_SRCS) { + return f_of_r_linear(par,r,par->srcs_norm_arr[ipop],par->norm_srcs_0[ipop], + par->norm_srcs_f[ipop]); + } + else if(tag==BG_TZ_IMAP) + return f_of_r_linear(par,r,par->imap_tz_arr[ipop],0,0); + else if(tag==BG_BZ_IMAP) + return f_of_r_linear(par,r,par->imap_bz_arr[ipop],par->imap_bz_arr[ipop][0],1); + else if(tag==BG_NORM_IMAP) { + return f_of_r_linear(par,r,par->imap_norm_arr[ipop],par->norm_imap_0[ipop], + par->norm_imap_f[ipop]); + } + else if(tag==BG_KZ_CSTM) + return f_of_r_linear(par,r,par->cstm_kz_arr[ipop],0,0); + else if(tag==BG_BZ_CSTM) + return f_of_r_linear(par,r,par->cstm_bz_arr[ipop],par->cstm_bz_arr[ipop][0],1); + else if(tag==BG_NORM_CSTM) { + return f_of_r_linear(par,r,par->cstm_norm_arr[ipop],par->norm_cstm_0[ipop], + par->norm_cstm_f[ipop]); + } + else { + report_error(1,"Unknown background quantity tag %d\n",tag); + return -1; + } +} + +static double a_of_r_provisional(ParamCoLoRe *par,double r) +{ + if(r<=0) return 1.; + else if(r>=par->r_arr_a2r[0]) return 1E-6; + else { + int ia=0; + while(r<=par->r_arr_a2r[ia]) + ia++; + return par->a_arr_a2r[ia-1]+(par->a_arr_a2r[ia]-par->a_arr_a2r[ia-1])* + (r-par->r_arr_a2r[ia-1])/(par->r_arr_a2r[ia]-par->r_arr_a2r[ia-1]); + } +} + +double r_of_z(ParamCoLoRe *par,double z) +{ + double a=1./(1+z); + if(a>=1) return 0; + else if(a<=0) return par->r_arr_a2r[0]; + else { + int ia=(int)(a*(NA-1)); + double r=par->r_arr_a2r[ia]+(par->r_arr_a2r[ia+1]-par->r_arr_a2r[ia])* + (a-par->a_arr_a2r[ia])*(NA-1.); + return r; + } +} + +typedef struct { + ParamCoLoRe *par; + int l; + double chi_0_a; + double chi_f_a; + double chi_0_b; + double chi_f_b; + double chi_s; + int cl_type; +} ClParams; + +static double window_kappa_limber(ParamCoLoRe *par,int l,double k,double chi_0,double chi_f,double chi_s) +{ + double chi_l=(l+0.5)/k; + + if((chi_l<=0) || (chi_lchi_f)) + return 0; + else { + double gf=get_bg(par,chi_l,BG_D1,0); + double aa=1/(1+get_bg(par,chi_l,BG_Z,0)); + + return par->prefac_lensing*l*(l+1.)*gf*(chi_s-chi_l)/(k*k*chi_s*chi_l*aa); + } +} + +static double window_shear_limber(ParamCoLoRe *par,int l,double k,double chi_0,double chi_f,double chi_s) +{ + double chi_l=(l+0.5)/k; + + if((chi_l<=0) || (chi_lchi_f)) + return 0; + else { + double gf=get_bg(par,chi_l,BG_D1,0); + double aa=1/(1+get_bg(par,chi_l,BG_Z,0)); + + return par->prefac_lensing*sqrt((l-1)*l*(l+1.)*(l+2.))*gf*(chi_s-chi_l)/(k*k*chi_s*chi_l*aa); + } +} + +static double window_isw_limber(ParamCoLoRe *par,int l,double k,double chi_0,double chi_f,double chi_s) +{ + double chi_l=(l+0.5)/k; + + if((chi_l<=0) || (chi_lchi_f)) + return 0; + else + return -2*par->prefac_lensing*get_bg(par,chi_l,BG_PD,0)/(k*k); +} + +static double cl_integrand(double lk,void *params) +{ + ClParams *p=(ClParams *)params; + double k=pow(10.,lk); + double pk=pk_linear0(p->par,lk); + double wa=0,wb=0; + if(p->cl_type==CL_TYPE_KAPPA) { + wa=window_kappa_limber(p->par,p->l,k,p->chi_0_a,p->chi_f_a,p->chi_s); + wb=window_kappa_limber(p->par,p->l,k,p->chi_0_b,p->chi_f_b,p->chi_s); + } + else if(p->cl_type==CL_TYPE_SHEAR) { + wa=window_shear_limber(p->par,p->l,k,p->chi_0_a,p->chi_f_a,p->chi_s); + wb=window_shear_limber(p->par,p->l,k,p->chi_0_b,p->chi_f_b,p->chi_s); + } + else if(p->cl_type==CL_TYPE_ISW) { + wa=window_isw_limber(p->par,p->l,k,p->chi_0_a,p->chi_f_a,p->chi_s); + wb=window_isw_limber(p->par,p->l,k,p->chi_0_b,p->chi_f_b,p->chi_s); + } + if((p->par->do_smoothing) && (p->par->smooth_potential)) + pk*=exp(-k*k*p->par->r2_smooth); + + return k*wa*wb*pk; +} + +static double compute_cl(ParamCoLoRe *par,int l, + double chi_0_a,double chi_f_a, + double chi_0_b,double chi_f_b, + double chi_s,int cl_type) +{ + ClParams p; + gsl_function F; + double lkmin,lkmax,eresult,result=0,chi_min=1E16,chi_max=-1; + gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000); + p.par=par; + p.l=l; + p.chi_0_a=chi_0_a; + p.chi_f_a=chi_f_a; + p.chi_0_b=chi_0_b; + p.chi_f_b=chi_f_b; + p.chi_s=chi_s; + p.cl_type=cl_type; + F.function=&cl_integrand; + F.params=&p; + + if(chi_0_achi_max) chi_max=chi_0_a; + if(chi_0_b>chi_max) chi_max=chi_0_b; + if(chi_f_a>chi_max) chi_max=chi_f_a; + if(chi_f_b>chi_max) chi_max=chi_f_b; + if(chi_min<=0) lkmax=2.; + else lkmax=log10((l+0.5)/chi_min); + if(chi_max<=0) lkmin=-5.; + else lkmin=log10((l+0.5)/chi_max); + + gsl_integration_qag(&F,lkmin,lkmax,0,1E-4,1000,GSL_INTEG_GAUSS41,w,&result,&eresult); + gsl_integration_workspace_free(w); + + return M_LN10*result/(l+0.5); +} + +static void int_error_handle(int status,double result, + double error) +{ + ////// + // Error handler for gsl + if(isnan(result)) { + fprintf(stderr,"CoLoRe: NAN found \n"); + exit(1); + } + else{ + if(status==GSL_EROUND) + fprintf(stderr,"CoLoRe: Roundoff error: %lE %lE \n",result,error); + else if(status==GSL_EMAXITER) + fprintf(stderr,"CoLoRe: Ran out of iterations: %lE %lE \n",result,error); + else if(status==GSL_ESING) + fprintf(stderr,"CoLoRe: Singularity found: %lE %lE \n",result,error); + else if(status==GSL_EDIVERGE) { + fprintf(stderr,"CoLoRe: Integral seems to diverge: %lE %lE \n", + result,error); + } + else if(status==GSL_ETOL) { + fprintf(stderr,"CoLoRe: Can't reach tolerance: %lE %lE : %lE %%\n", + result,error,100*error/result); + } + else if(status==GSL_EUNDRFLW) + fprintf(stderr,"CoLoRe: Underflow: %lE %lE \n",result,error); + else if(status==GSL_EDOM) { + fprintf(stderr,"CoLoRe: Outside interpolation range!! %lE %lE\n", + result,error); + exit(1); + } + else if(status) { + fprintf(stderr,"CoLoRe: Unknown error code %d %lf %lf \n", + status,result,error); + exit(1); + } + } +} + +static double wind(double x,int setwf) +{ + ////// + // Window function: + // setwf=0 -> top hat + // setwf=1 -> gaussian + // setwf=2 -> sharp-k + if(setwf==1) { //Gaussian + return exp(-0.5*x*x); + } + else if(setwf==0) { //TopHat + if(x<0.1) { + return 1.-0.1*x*x+0.003571429*x*x*x*x-6.61376E-5*x*x*x*x*x*x + +7.51563E-7*x*x*x*x*x*x*x*x; + } + else + return 3*(sin(x)-x*cos(x))/(x*x*x); + } + else if(setwf==2) { //Sharp-k + if(x<1) return 1; + else return 0; + } + else + return -1; +} + +double pk_linear0(ParamCoLoRe *par,double lgk) +{ + ////// + // Linear power spectrum at redshift 0. + // Extrapolated to ~k^ns for small k and + // to k^{-3} for large k + double pk; + int ik=(int)((lgk-par->logkmin)*par->idlogk); + + if(ik<0) + pk=par->pkarr[0]*pow(10,par->n_scal*(lgk-par->logkmin)); + else if(iknumk) + pk=par->pkarr[ik]+(lgk-par->logkarr[ik])*(par->pkarr[ik+1]-par->pkarr[ik])*par->idlogk; + else + pk=par->pkarr[par->numk-1]*pow(10,-3*(lgk-par->logkmax)); + + return pk; +} + +static double j_bessel_0(double x) +{ + ////// + // Bessel's j0 function + if(x>0.1) + return sin(x)/x; + else + return 1.-0.166667*x*x+0.00833333*x*x*x*x- + 0.000198413*x*x*x*x*x*x+2.75573E-6*x*x*x*x*x*x*x*x; +} + +typedef struct { //Param struct for integrals + double r; + double R1; + double R2; + int wf1; + int wf2; + ParamCoLoRe *par; +} xiparam; + +static double integxiL_O(double kk,void *params) +{ + ////// + // integrand for xi_L (for oscillatory integration) + double dum; + double x1,x2,xr; + xiparam *par; + double lgk=log10(kk); + par=(xiparam *)params; + + x1=kk*(par->R1); + x2=kk*(par->R2); + xr=kk*(par->r); + + dum=TWOPIPIINV*pk_linear0(par->par,lgk)*kk*kk* + wind(x1,par->wf1)*wind(x2,par->wf2)/xr; + + return dum; +} + +static double integxiL_NO(double logk,void *params) +{ + ////// + // integrand for xi_L (including oscillatory term in j0) + double dum; + double x1,x2,xr; + xiparam *par; + par=(xiparam *)params; + + double kk=pow(10,logk); + x1=kk*(par->R1); + x2=kk*(par->R2); + xr=kk*(par->r); + + dum=TWOPIPIINVLOGTEN*pk_linear0(par->par,logk)*kk*kk*kk* + wind(x1,par->wf1)*wind(x2,par->wf2)*j_bessel_0(xr); + + return dum; +} + +static double xi2p_L(ParamCoLoRe *par,double r,double R1,double R2, + char *wf1,char *wf2,double errfac) +{ + ////// + // Correlation function between the linear density contrast smoothed + // with window function (wf1,R1) and with window function (wf2,R2) + // at two points separated by a distance r: + // + gsl_function integrand; + double relerrt=1E-4; + double integral,errintegral; + xiparam xpar; + double lim=MIN(R1,R2); + lim/=r; + + xpar.r=r; + xpar.R1=R1; + xpar.R2=R2; + xpar.par=par; + if(!strcmp(wf1,"Gauss")) + xpar.wf1=1; + else if(!strcmp(wf1,"TopHat")) + xpar.wf1=0; + else { + fprintf(stderr,"CoLoRe: Unknown window function %s \n",wf1); + exit(1); + } + if(!strcmp(wf2,"Gauss")) + xpar.wf2=1; + else if(!strcmp(wf2,"TopHat")) + xpar.wf2=0; + else { + fprintf(stderr,"CoLoRe: Unknown window function %s \n",wf2); + exit(1); + } + + gsl_integration_workspace *w + =gsl_integration_workspace_alloc(1000); + integrand.params=&xpar; + if(lim>=1) { + integrand.function=&integxiL_NO; + int stat=gsl_integration_qagil(&integrand,par->logkmax,0,relerrt,1000,w, + &integral,&errintegral); + int_error_handle(stat,integral,errintegral); + } + else { + lim*=errfac; + gsl_integration_workspace *cw + =gsl_integration_workspace_alloc(1000); + gsl_integration_qawo_table *wf + =gsl_integration_qawo_table_alloc(r,0.1,GSL_INTEG_SINE,100); + + integrand.function=&integxiL_O; + int stat=gsl_integration_qawf(&integrand,0,relerrt*lim,1000, + w,cw,wf,&integral,&errintegral); + int_error_handle(stat,integral,errintegral); + + gsl_integration_qawo_table_free(wf); + gsl_integration_workspace_free(cw); + } + gsl_integration_workspace_free(w); + + return integral; +} + +static double sigL2(ParamCoLoRe *par,double R1,double R2,char *wf1,char *wf2) +{ + ////// + // Covariance between the linear density contrast smoothed with + // window function (wf1,R1) and with window function (wf2,R2) at + // the same point: + return xi2p_L(par,0,R1,R2,wf1,wf2,1); +} + +static void pk_linear_set(ParamCoLoRe *par) +{ + ////// + // Reads linear power spectrum. CAMB format expected. + int ii; + double kk,ppk; + FILE *fpk; + + print_info("Reading P_k from file: %s\n",par->fnamePk); + fpk=fopen(par->fnamePk,"r"); + if(fpk==NULL) error_open_file(par->fnamePk); + par->numk=linecount(fpk); + par->logkarr=(double *)my_malloc(par->numk*sizeof(double)); + par->pkarr=(double *)my_malloc(par->numk*sizeof(double)); + rewind(fpk); + for(ii=0;iinumk;ii++) { + int stat=fscanf(fpk,"%lf %lf",&kk,&ppk); + if(stat!=2) error_read_line(par->fnamePk,ii+1); + par->pkarr[ii]=ppk; + par->logkarr[ii]=log10(kk); //log(k) in h Mpc^-1 + } + fclose(fpk); + + par->logkmin=par->logkarr[0]; + par->logkmax=par->logkarr[par->numk-1]; + par->idlogk=(par->numk-1)/(par->logkmax-par->logkmin); + + //Re-interpolate just in case the file is not equi-spaced in log10(k) + gsl_interp_accel *intacc=gsl_interp_accel_alloc(); + gsl_spline *spline=gsl_spline_alloc(gsl_interp_cspline,par->numk); + gsl_spline_init(spline,par->logkarr,par->pkarr,par->numk); + for(ii=0;iinumk-1;ii++) { + double lk=par->logkmin+ii/(par->idlogk); + par->pkarr[ii]=gsl_spline_eval(spline,lk,intacc); + par->logkarr[ii]=lk; + } + gsl_spline_free(spline); + gsl_interp_accel_free(intacc); + + // normalize + double norm_pk=par->sig8*par->sig8/sigL2(par,8,8,"TopHat","TopHat"); + print_info(" Original sigma8=%lf\n", + sqrt(sigL2(par,8,8,"TopHat","TopHat"))); + for(ii=0;iinumk;ii++) + par->pkarr[ii]*=norm_pk; + + double r_effective=sqrt(par->r2_smooth+pow(0.45*par->l_box/par->n_grid,2)); + par->sigma2_gauss=sigL2(par,r_effective,r_effective,"Gauss","Gauss"); +#ifdef _DEBUG + print_info(" Sigma_Gauss should be %lf\n",sqrt(par->sigma2_gauss)); +#endif //_DEBUG +} + +static void compute_hp_shell_distances_imap(HealpixShells *shell,flouble nu_rest, + char *fname_nutable,Csm_params *pars) +{ + int ii; + FILE *fi; + + //Figure out radial shells + fi=fopen(fname_nutable,"r"); + if(fi==NULL) error_open_file(fname_nutable); + for(ii=0;iinr;ii++) { + double nu0,nuf; + int stat=fscanf(fi,"%lf %lf",&nu0,&nuf); + if(stat!=2) error_read_line(fname_nutable,ii+1); + shell->r0[ii]=csm_radial_comoving_distance(pars,nuf/nu_rest); + shell->rf[ii]=csm_radial_comoving_distance(pars,nu0/nu_rest); + } + fclose(fi); +} + +void cosmo_set(ParamCoLoRe *par) +{ + ////// + // This initializes the cosmological model + // at redshift z_s + + int ii,ipop,nz; + double *zarr,*fzarr; + FILE *fi; + gsl_spline *spline_srcs_bz[NPOP_MAX]; + gsl_spline *spline_srcs_nz[NPOP_MAX]; + gsl_spline *spline_imap_bz[NPOP_MAX]; + gsl_spline *spline_imap_tz[NPOP_MAX]; + gsl_spline *spline_cstm_bz[NPOP_MAX]; + gsl_spline *spline_cstm_kz[NPOP_MAX]; + + Csm_params *pars=csm_params_new(); + csm_unset_gsl_eh(); + csm_background_set(pars,par->OmegaM,par->OmegaL,par->OmegaB,par->weos,0,par->hhub,2.275); + + par->fgrowth_0=csm_f_growth(pars,1); + par->hubble_0=csm_hubble(pars,1); + + par->r_min=csm_radial_comoving_distance(pars,1/(1+par->z_min)); + par->r_max=csm_radial_comoving_distance(pars,1/(1+par->z_max)); + + par->prefac_lensing=1.5*par->hubble_0*par->hubble_0*par->OmegaM; + + par->l_box=2*par->r_max*(1+2./par->n_grid); + par->pos_obs[0]=0.5*par->l_box; + par->pos_obs[1]=0.5*par->l_box; + par->pos_obs[2]=0.5*par->l_box; + + for(ipop=0;ipopn_srcs;ipop++) { + fi=fopen(par->fnameBzSrcs[ipop],"r"); + if(fi==NULL) error_open_file(par->fnameBzSrcs[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + fzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameBzSrcs[ipop],ii+1); + } + if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) + report_error(1,"Bias z-range is too small\n"); + spline_srcs_bz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); + gsl_spline_init(spline_srcs_bz[ipop],zarr,fzarr,nz); + free(zarr); free(fzarr); + fclose(fi); + + fi=fopen(par->fnameNzSrcs[ipop],"r"); + if(fi==NULL) error_open_file(par->fnameNzSrcs[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + fzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameNzSrcs[ipop],ii+1); + a=1./(1+zarr[ii]); + hz=csm_hubble(pars,a); + rz=csm_radial_comoving_distance(pars,a); + fzarr[ii]*=RTOD*RTOD*hz/(rz*rz); + } + //Correct for z[0]=0 + if(zarr[0]==0) + fzarr[0]=fzarr[1]; + if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) + report_error(1,"N(z) z-range is too small\n"); + spline_srcs_nz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); + gsl_spline_init(spline_srcs_nz[ipop],zarr,fzarr,nz); + free(zarr); free(fzarr); + fclose(fi); + + par->srcs_nz_arr[ipop]=my_malloc(NA*sizeof(double)); + par->srcs_bz_arr[ipop]=my_malloc(NA*sizeof(double)); + } + + for(ipop=0;ipopn_imap;ipop++) { + fi=fopen(par->fnameBzImap[ipop],"r"); + if(fi==NULL) error_open_file(par->fnameBzImap[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + fzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameBzImap[ipop],ii+1); + } + if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) + report_error(1,"Bias z-range is too small\n"); + spline_imap_bz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); + gsl_spline_init(spline_imap_bz[ipop],zarr,fzarr,nz); + free(zarr); free(fzarr); + fclose(fi); + + fi=fopen(par->fnameTzImap[ipop],"r"); + if(fi==NULL) error_open_file(par->fnameTzImap[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + fzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameTzImap[ipop],ii+1); + } + if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) + report_error(1,"T(z) z-range is too small\n"); + spline_imap_tz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); + gsl_spline_init(spline_imap_tz[ipop],zarr,fzarr,nz); + free(zarr); free(fzarr); + fclose(fi); + + par->imap_tz_arr[ipop]=my_malloc(NA*sizeof(double)); + par->imap_bz_arr[ipop]=my_malloc(NA*sizeof(double)); + } + + for(ipop=0;ipopn_cstm;ipop++) { + fi=fopen(par->fnameBzCstm[ipop],"r"); + if(fi==NULL) error_open_file(par->fnameBzCstm[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + fzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameBzCstm[ipop],ii+1); + } + if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) + report_error(1,"Bias z-range is too small\n"); + spline_cstm_bz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); + gsl_spline_init(spline_cstm_bz[ipop],zarr,fzarr,nz); + free(zarr); free(fzarr); + fclose(fi); + + fi=fopen(par->fnameKzCstm[ipop],"r"); + if(fi==NULL) error_open_file(par->fnameKzCstm[ipop]); + nz=linecount(fi); rewind(fi); + zarr=my_malloc(nz*sizeof(double)); + fzarr=my_malloc(nz*sizeof(double)); + for(ii=0;iifnameKzCstm[ipop],ii+1); + } + if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) + report_error(1,"K(z) z-range is too small\n"); + spline_cstm_kz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); + gsl_spline_init(spline_cstm_kz[ipop],zarr,fzarr,nz); + free(zarr); free(fzarr); + fclose(fi); + + par->cstm_kz_arr[ipop]=my_malloc(NA*sizeof(double)); + par->cstm_bz_arr[ipop]=my_malloc(NA*sizeof(double)); + } + + //Set z-dependent functions + for(ii=0;iia_arr_a2r[ii]=a; + par->r_arr_a2r[ii]=ra; + } + + double growth0=csm_growth_factor(pars,1); + par->glob_idr=(NA-1)/par->r_arr_a2r[0]; + for(ii=0;iiglob_idr; + double a=a_of_r_provisional(par,r); + double z=1./a-1; + double gz=csm_growth_factor(pars,a)/growth0; + double om=csm_omega_m(pars,a); + double fz=csm_f_growth(pars,a); + double hhz=csm_hubble(pars,a); + par->z_arr_r2z[ii]=z; + par->r_arr_r2z[ii]=r; + par->growth_d_arr[ii]=gz; + par->growth_d2_arr[ii]=-0.42857142857*gz*gz*pow(om,-0.00699300699); + par->growth_v_arr[ii]=(gz*hhz*fz)/(par->fgrowth_0*par->hubble_0); //This is for the comoving velocity + par->growth_pd_arr[ii]=gz*hhz*(fz-1); + par->ihub_arr[ii]=1./hhz; + for(ipop=0;ipopn_srcs;ipop++) { + if((zz_min) || (z>par->z_max)) { + par->srcs_nz_arr[ipop][ii]=0; + par->srcs_bz_arr[ipop][ii]=1.; + } + par->srcs_nz_arr[ipop][ii]=gsl_spline_eval(spline_srcs_nz[ipop],z,NULL); + par->srcs_bz_arr[ipop][ii]=gsl_spline_eval(spline_srcs_bz[ipop],z,NULL); + } + for(ipop=0;ipopn_imap;ipop++) { + if((zz_min) || (z>par->z_max)) { + par->imap_tz_arr[ipop][ii]=0; + par->imap_bz_arr[ipop][ii]=1.; + } + par->imap_tz_arr[ipop][ii]=gsl_spline_eval(spline_imap_tz[ipop],z,NULL); + par->imap_bz_arr[ipop][ii]=gsl_spline_eval(spline_imap_bz[ipop],z,NULL); + } + for(ipop=0;ipopn_cstm;ipop++) { + if((zz_min) || (z>par->z_max)) { + par->cstm_kz_arr[ipop][ii]=0; + par->cstm_bz_arr[ipop][ii]=1.; + } + par->cstm_kz_arr[ipop][ii]=gsl_spline_eval(spline_cstm_kz[ipop],z,NULL); + par->cstm_bz_arr[ipop][ii]=gsl_spline_eval(spline_cstm_bz[ipop],z,NULL); + } + } + + for(ipop=0;ipopn_cstm;ipop++) { + gsl_spline_free(spline_cstm_kz[ipop]); + gsl_spline_free(spline_cstm_bz[ipop]); + } + for(ipop=0;ipopn_imap;ipop++) { + gsl_spline_free(spline_imap_tz[ipop]); + gsl_spline_free(spline_imap_bz[ipop]); + } + for(ipop=0;ipopn_srcs;ipop++) { + gsl_spline_free(spline_srcs_nz[ipop]); + gsl_spline_free(spline_srcs_bz[ipop]); + } + + pk_linear_set(par); + + if(par->do_kappa) { + for(ii=0;iin_kappa;ii++) { + double z=par->z_kappa_out[ii]; + if(z>par->z_max) { +#ifdef _ADD_EXTRA_KAPPA + int l,nl=3*par->nside_kappa; + double chi_here=r_of_z(par,z); +#ifdef _DEBUG + if(NodeThis==0) + fprintf(par->f_dbg,"Power spectra for extra kappa, shell %d (z=%.3lf)\n",ii+1,z); +#endif //_DEBUG + par->need_extra_kappa[ii]=1; + par->fl_mean_extra_kappa[ii]=my_malloc(nl*sizeof(flouble)); + par->cl_extra_kappa[ii]=my_malloc(nl*sizeof(flouble)); + for(l=0;lr_max,0. ,par->r_max,chi_here,CL_TYPE_KAPPA); + flouble cl_k_12=compute_cl(par,l,0. ,par->r_max,par->r_max,chi_here ,chi_here,CL_TYPE_KAPPA); + flouble cl_k_22=compute_cl(par,l,par->r_max,chi_here ,par->r_max,chi_here ,chi_here,CL_TYPE_KAPPA); + par->fl_mean_extra_kappa[ii][l]=cl_k_12/cl_k_11; + par->cl_extra_kappa[ii][l]=cl_k_22-cl_k_12*cl_k_12/cl_k_11; + if(l==0) { + par->fl_mean_extra_kappa[ii][l]=0; + par->cl_extra_kappa[ii][l]=0; + } +#ifdef _DEBUG + if(NodeThis==0) + fprintf(par->f_dbg,"%d %lE %lE \n",l,par->fl_mean_extra_kappa[ii][l],par->cl_extra_kappa[ii][l]); +#endif //_DEBUG + } +#ifdef _DEBUG + if(NodeThis==0) + fprintf(par->f_dbg,"\n"); +#endif //_DEBUG +#else //_ADD_EXTRA_KAPPA + report_error(1,"Source plane %d outside redshift range\n",ii+1); +#endif //_ADD_EXTRA_KAPPA + } + } + } + + if(par->do_isw) { + for(ii=0;iin_isw;ii++) { + double z=par->z_isw_out[ii]; + if(z>par->z_max) { +#ifdef _ADD_EXTRA_KAPPA + int l,nl=3*par->nside_isw; + double chi_here=r_of_z(par,z); +#ifdef _DEBUG + if(NodeThis==0) + fprintf(par->f_dbg,"Power spectra for extra isw, shell %d (z=%.3lf)\n",ii+1,z); +#endif //_DEBUG + par->need_extra_isw[ii]=1; + par->fl_mean_extra_isw[ii]=my_malloc(nl*sizeof(flouble)); + par->cl_extra_isw[ii]=my_malloc(nl*sizeof(flouble)); + for(l=0;lr_max,0. ,par->r_max,chi_here,CL_TYPE_ISW); + flouble cl_i_12=compute_cl(par,l,0. ,par->r_max,par->r_max,chi_here ,chi_here,CL_TYPE_ISW); + flouble cl_i_22=compute_cl(par,l,par->r_max,chi_here ,par->r_max,chi_here ,chi_here,CL_TYPE_ISW); + par->fl_mean_extra_isw[ii][l]=cl_i_12/cl_i_11; + par->cl_extra_isw[ii][l]=cl_i_22-cl_i_12*cl_i_12/cl_i_11; + if(l==0) { + par->fl_mean_extra_isw[ii][l]=0; + par->cl_extra_isw[ii][l]=0; + } +#ifdef _DEBUG + if(NodeThis==0) + fprintf(par->f_dbg,"%d %lE %lE \n",l,par->fl_mean_extra_isw[ii][l],par->cl_extra_isw[ii][l]); +#endif //_DEBUG + } +#ifdef _DEBUG + if(NodeThis==0) + fprintf(par->f_dbg,"\n"); +#endif //_DEBUG +#else //_ADD_EXTRA_KAPPA + report_error(1,"Source plane %d outside redshift range\n",ii+1); +#endif //_ADD_EXTRA_KAPPA + } + } + } + + csm_params_free(pars); + //FREEE SLPINES! +} + +void compute_tracer_cosmo(ParamCoLoRe *par) +{ + Csm_params *pars=csm_params_new(); + csm_unset_gsl_eh(); + csm_set_verbosity(0); + csm_background_set(pars,par->OmegaM,par->OmegaL,par->OmegaB,par->weos,0,par->hhub,2.275); + + if(par->do_imap) { + int ipop; + for(ipop=0;ipopn_imap;ipop++) { + compute_hp_shell_distances_imap(par->imap[ipop],par->nu0_imap[ipop],par->fnameNuImap[ipop],pars); + } + } + if(par->do_kappa) { + int ii; + for(ii=0;iin_kappa;ii++) { + double z=par->z_kappa_out[ii]; + par->kmap->r0[ii]=csm_radial_comoving_distance(pars,1./(1+z)); + par->kmap->rf[ii]=csm_radial_comoving_distance(pars,1./(1+z)); + } + } + if(par->do_isw) { + int ii; + for(ii=0;iin_isw;ii++) { + double z=par->z_isw_out[ii]; + par->pd_map->r0[ii]=csm_radial_comoving_distance(pars,1./(1+z)); + par->pd_map->rf[ii]=csm_radial_comoving_distance(pars,1./(1+z)); + } + } + + csm_params_free(pars); +} + +flouble *compute_lensing_spacing(ParamCoLoRe *par) +{ + flouble *rarr; + int ir,nr=par->n_lensing; + rarr=my_malloc(nr*sizeof(flouble)); + if(par->lensing_spacing_type==SPACING_R) { + flouble dr=par->r_max/nr; + for(ir=0;irlensing_spacing_type==SPACING_LOGZ) { + flouble dlogz=log(1+par->z_max)/nr; + for(ir=0;ir. // +// // +/////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include "common.h" +#include "cosmo_mad.h" + +//Number of points for the a(t) relation +#define CSM_NINTERP_A 1000 + +/**** Verbosity ****/ +static int csm_flag_verbose=1; + +/**** Error handler ****/ +static gsl_error_handler_t *csm_gsl_error_handler_old; + + +/****************************/ +/* General routines */ +/****************************/ +static void int_error_handle(int status,double result, + double error) +{ + ////// + // Error handler for gsl + if(isnan(result)) { + fprintf(stderr,"CoLoRe: NAN found \n"); + } + else{ + if(status==GSL_EROUND) { + fprintf(stderr,"CoLoRe: Roundoff error: %lE %lE \n", + result,error); + } + else if(status==GSL_EMAXITER) { + fprintf(stderr,"CoLoRe: Ran out of iterations: %lE %lE \n", + result,error); + } + else if(status==GSL_ESING) { + fprintf(stderr,"CoLoRe: Singularity found: %lE %lE \n", + result,error); + } + else if(status==GSL_EDIVERGE) { + fprintf(stderr,"CoLoRe: Integral seems to diverge: %lE %lE \n", + result,error); + } + else if(status==GSL_ETOL) { + fprintf(stderr,"CoLoRe: Can't reach tolerance: %lE %lE\n", + result,error); + } + else if(status==GSL_EUNDRFLW) + fprintf(stderr,"CoLoRe: Underflow: %lE %lE \n",result,error); + else if(status==GSL_EDOM) { + fprintf(stderr,"CoLoRe: Outside interpolation range!! %lE %lE\n", + result,error); + exit(1); + } + else if(status) { + fprintf(stderr,"CoLoRe: Unknown error code %d %lf %lf \n", + status,result,error); + exit(1); + } + } +} + +void csm_unset_gsl_eh(void) +{ + ////// + // Disables GSL default error handler + csm_gsl_error_handler_old=gsl_set_error_handler_off(); +} + +void csm_set_verbosity(int verb) +{ + ////// + // Sets verbosity level + csm_flag_verbose=verb; +} + +static void csm_bg_params_free(Csm_bg_params *par) +{ + ////// + // bg_params destructor + free(par); +} + +static Csm_bg_params *csm_bg_params_new(void) +{ + ////// + // bg_params creator + // Default Planck parameters + Csm_bg_params *bg=(Csm_bg_params *)malloc(sizeof(Csm_bg_params)); + if(bg==NULL) { + fprintf(stderr,"CoLoRe: Out of memory!\n"); + exit(1); + } + bg->OM=0.315; + bg->OL=0.685; + bg->OB=0.049; + bg->h=0.673; + bg->w0=-1; + bg->wa=0; + bg->TCMB=2.725; + bg->OK=0; + bg->ksign=0; + bg->normalDE=1; + bg->constantw=1; + + return bg; +} + +void csm_params_free(Csm_params *par) +{ + ////// + // csm_params destructor + if(par->bg_params_set) + csm_bg_params_free(par->bg); + par->bg_params_set=0; + free(par); +} + +Csm_params *csm_params_new(void) +{ + ////// + // csm_params destructor + Csm_params *par=(Csm_params *)malloc(sizeof(Csm_params)); + if(par==NULL) { + fprintf(stderr,"CoLoRe: Out of memory!\n"); + exit(1); + } + par->bg_params_set=0; + par->bg=NULL; + + return par; +} + +/****************************/ +/* Background cosmology */ +/****************************/ + +static double aeqmin(Csm_bg_params *par) +{ + ////// + // Returns MIN(aeq_k,aeq_L), where aeq_i is the scale + // factor at equality of M with k or L. + double aeqK=1; + double aeqL=1; + + if(par->ksign!=0) + aeqK=par->OM/fabs(par->OK); + + if (par->OL!=0) { + if(par->normalDE) + aeqL=pow(par->OM/par->OL,0.333); + else + aeqL=pow(par->OM/par->OL,-1/(3*par->w0)); + } + + return CSM_MIN(aeqK,aeqL); +} + +static double sinn(double x,int sign) +{ + ////// + // { sin(x) , if k==1 + // sinn(x)={ x , if k==0 + // { sinh(x) , if k==-1 + double dum; + + if(sign==-1) + dum=sinh(x); + else if(sign==1) + dum=sin(x); + else + dum=x; + + return dum; +} + +static double naHm1(double a,void *params) +{ + ////// + // H0/(a*H[a]) + double dum; + Csm_bg_params *par=(Csm_bg_params *)params; + + if(par->normalDE) + dum=sqrt(a/(par->OM+par->OL*a*a*a+par->OK*a)); + else if(par->constantw) { + dum=sqrt(a/(par->OM+par->OL*pow(a,-3*par->w0)+par->OK*a)); + } + else { + dum=sqrt(a/(par->OM+par->OL*pow(a,-3*(par->w0+par->wa))* + exp(3*(a-1)*par->wa)+par->OK*a)); + } + + return dum; +} + +static double na2Hm1(double a,void *params) +{ + ////// + // H0/(a^2*H[a]) + double dum; + Csm_bg_params *par=(Csm_bg_params *)params; + + if(par->normalDE) + dum=1/sqrt(a*(par->OM+par->OL*a*a*a+par->OK*a)); + else if(par->constantw) { + dum=1/sqrt(a*(par->OM+par->OL*pow(a,-3*par->w0)+par->OK*a)); + } + else { + dum=1/sqrt(a*(par->OM+par->OL*pow(a,-3*(par->w0+par->wa))* + exp(3*(a-1)*par->wa)+par->OK*a)); + } + + return dum; +} + +static double naHm3(double a,void *params) +{ + ////// + // (H0/(a*H[a]))^3 + double dum; + Csm_bg_params *par=(Csm_bg_params *)params; + + if(par->normalDE) { + dum=sqrt(a/(par->OM+par->OL*a*a*a+par->OK*a)); + } + else if(par->constantw) { + dum=sqrt(a/(par->OM+par->OL*pow(a,-3*par->w0)+par->OK*a)); + } + else { + dum=sqrt(a/(par->OM+par->OL*pow(a,-3*(par->w0+par->wa))* + exp(3*(a-1)*par->wa)+par->OK*a)); + } + + return dum*dum*dum; +} + +static void parthor(Csm_bg_params *par, + double aa,double *ph,double *delph) +{ + ////// + // Particle horizon. The returned value is in Mpc/h. + double alim; + + alim=0.01*par->a_equality; + if(aa<=alim) { + *ph=2*sqrt(aa/par->OM)*CSM_HMPC; + *delph=0; + } + else { + double relerrt=1E-6; + double integral,errintegral,int0; + size_t sdum; + gsl_function integrand; + int stat; + + int0=2*sqrt(alim/par->OM); + integrand.function=&na2Hm1; + integrand.params=par; + + stat=gsl_integration_qng(&integrand,alim,aa,0,relerrt, + &integral,&errintegral,&sdum); + int_error_handle(stat,integral,errintegral); + *ph=(int0+integral)*CSM_HMPC; + // *delph=errintegral*CSM_HMPC; + } +} + +static void gfac(Csm_bg_params *par, + double aa,double *gf,double *delgf) +{ + ////// + // Growth factor, normalized to gfac(a<a_equality; + int0=0.4*sqrt(alim*alim*alim*alim*alim/(par->OM*par->OM*par->OM)); + if(aa<=alim) { + *gf=aa; + *delgf=0; + } + else { + double relerrt=1E-4; + double integral,errintegral; + size_t sdum; + gsl_function integrand; + int stat; + + integrand.function=&naHm3; + integrand.params=par; + + stat=gsl_integration_qng(&integrand,alim,aa,0,relerrt, + &integral,&errintegral,&sdum); + int_error_handle(stat,integral,errintegral); + *gf=(int0+integral)*2.5*par->OM/(aa*naHm1(aa,par)); + } +} + +double csm_omega_m(Csm_params *par,double aa) +{ + if(par->bg->normalDE) + return par->bg->OM/(par->bg->OM+par->bg->OL*aa*aa*aa+par->bg->OK*aa); + else if(par->bg->constantw) { + return par->bg->OM/(par->bg->OM+par->bg->OL*pow(aa,-3*par->bg->w0)+par->bg->OK*aa); + } + else { + return par->bg->OM/(par->bg->OM+par->bg->OL*pow(aa,-3*(par->bg->w0+par->bg->wa))* + exp(3*par->bg->wa*(aa-1))+par->bg->OK*aa); + } +} + +double csm_hubble(Csm_params *par,double aa) +{ + ////// + // Hubble rate at aa in h/Mpc + if(par->bg->normalDE) { + return sqrt((par->bg->OM+par->bg->OL*aa*aa*aa+par->bg->OK*aa)/ + (aa*aa*aa))/CSM_HMPC; + } + else if(par->bg->constantw) { + return sqrt((par->bg->OM+par->bg->OL*pow(aa,-3*par->bg->w0)+ + par->bg->OK*aa)/(aa*aa*aa))/CSM_HMPC; + } + else { + return sqrt((par->bg->OM+par->bg->OL*pow(aa,-3*(par->bg->w0+par->bg->wa))* + exp(3*par->bg->wa*(aa-1))+par->bg->OK*aa)/(aa*aa*aa))/CSM_HMPC; + } +} + +double csm_particle_horizon(Csm_params *par,double aa) +{ + ////// + // Particle horizon + double ph, eph; + + parthor(par->bg,aa,&ph,&eph); + return ph; +} + +double csm_radial_comoving_distance(Csm_params *par,double aa) +{ + ////// + // chi(a) + double rcd; + + rcd=csm_particle_horizon(par,aa); + return par->bg->phorizon-rcd; +} + +double csm_curvature_comoving_distance(Csm_params *par,double aa) +{ + ////// + // r(a) + if(par->bg->ksign==0) + return csm_radial_comoving_distance(par,aa); + else { + double dum; + double ksq=sqrt(fabs(par->bg->OK)); + dum=csm_radial_comoving_distance(par,aa)/CSM_HMPC; + dum=sinn(ksq*dum,par->bg->ksign)/ksq; + return dum*CSM_HMPC; + } +} + +double csm_growth_factor(Csm_params *par,double aa) +{ + ////// + // D(a) + double gf,egf; + + gfac(par->bg,aa,&gf,&egf); + + return gf; +} + +double csm_f_growth(Csm_params *par,double aa) +{ + ////// + // f(a)= d ln(D)/d ln(a) + // Using the integral definition for D(a) + double apow,coeff,Da; + + Da=csm_growth_factor(par,aa); + if(par->bg->normalDE) { + coeff=0; + apow=aa*aa*aa; + } + else if(par->bg->constantw) { + coeff=(1+par->bg->w0); + apow=pow(aa,-3*par->bg->w0); + } + else { + coeff=(1+par->bg->w0+par->bg->wa*(1-aa)); + apow=pow(aa,-3*(par->bg->w0+par->bg->wa))*exp(3*par->bg->wa*(aa-1)); + } + + return 0.5*(5*par->bg->OM*aa/Da- + (3*par->bg->OM+3*coeff*par->bg->OL*apow+2*par->bg->OK*aa))/ + (par->bg->OM+par->bg->OL*apow+par->bg->OK*aa); +} + +void csm_background_set(Csm_params *par, + double OmegaM,double OmegaL,double OmegaB, + double ww,double wwa,double hh,double T_CMB) +{ + ////// + // This initializes the cosmological parameters. + if(par->bg_params_set) + csm_bg_params_free(par->bg); + par->bg_params_set=0; + + par->bg=csm_bg_params_new(); + par->bg_params_set=1; + par->bg->h=hh; + par->bg->w0=ww; + par->bg->wa=wwa; + par->bg->OM=OmegaM; + par->bg->OL=OmegaL; + par->bg->OK=1-par->bg->OM-par->bg->OL; + par->bg->OB=OmegaB; + par->bg->TCMB=T_CMB; + + //Check parameters + if(fabs(par->bg->wa)<1E-6) { + if(fabs(par->bg->w0+1)<1E-6) { + par->bg->constantw=1; + par->bg->normalDE=1; + } + else { + par->bg->constantw=1; + par->bg->normalDE=0; + } + } + else { + par->bg->constantw=0; + par->bg->normalDE=0; + } + + if(fabs(par->bg->OK)<1E-6) + par->bg->ksign=0; + else if(par->bg->OK>0) + par->bg->ksign=-1; + else + par->bg->ksign=1; + + if(par->bg->OM<=0) { + fprintf(stderr,"CoLoRe: Wrong matter parameter %.3lf \n", + par->bg->OM); + exit(1); + } + if(par->bg->OMbg->OB) { + fprintf(stderr,"CoLoRe: Wrong M/B parameter %.3lf > %.3lf \n", + par->bg->OB,par->bg->OM); + exit(1); + } + if(par->bg->w0>-0.333333) { + fprintf(stderr,"CoLoRe: DE is too exotic (w=%.3lf \n",par->bg->w0); + exit(1); + } + if(par->bg->TCMB<0) { + fprintf(stderr,"CoLoRe: Wrong CMB temperature %.3lf \n", + par->bg->TCMB); + exit(1); + } + + if(csm_flag_verbose) { + print_info("The cosmological model is:\n"); + print_info(" O_M=%.3f O_L=%.3f O_K=%.3f\n", + par->bg->OM,par->bg->OL,par->bg->OK); + print_info(" O_B=%.3f w=%.3f h=%.3f\n", + par->bg->OB,par->bg->w0,par->bg->h); + if(par->bg->ksign==0) + print_info(" Flat universe, "); + else if(par->bg->ksign==1) + print_info(" Closed universe, "); + else if(par->bg->ksign==-1) + print_info(" Open universe, "); + if(par->bg->normalDE) + print_info("standard cosmological constant\n"); + else { + print_info("non-standard dark energy"); + if(par->bg->constantw) + print_info("\n"); + else + print_info(": w(a) = %.3lf + %.3lf*(1-a) \n",par->bg->w0,par->bg->wa); + } + } + par->bg->a_equality=aeqmin(par->bg); + par->bg->phorizon=csm_particle_horizon(par,1); + par->bg->growth0=csm_growth_factor(par,1); + if(csm_flag_verbose) { + print_info("\n Time of equality: a_eq=%.5lf\n",par->bg->a_equality); + print_info(" Particle horizon: "); + print_info("chi_H(0)=%.3lE Mpc/h\n",par->bg->phorizon); + print_info(" Present growth factor: "); + print_info("D_0=%.3lf\n\n",par->bg->growth0); + } +} diff --git a/src/.ipynb_checkpoints/cstm-checkpoint.c b/src/.ipynb_checkpoints/cstm-checkpoint.c new file mode 100644 index 0000000..a8997c1 --- /dev/null +++ b/src/.ipynb_checkpoints/cstm-checkpoint.c @@ -0,0 +1,158 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +void cstm_set_cartesian(ParamCoLoRe *par) +{ + return; +} + +void cstm_get_local_properties(ParamCoLoRe *par) +{ + return; +} + +void cstm_distribute(ParamCoLoRe *par) +{ + return; +} + +static void cstm_beams_preproc_single(ParamCoLoRe *par, int ipop) +{ + //Zero all data and clear +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,ipop) +#endif //_HAVE_OMP + { + long ipp; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ipp=0;ippcstm[ipop]->num_pix;ipp++) { + par->cstm[ipop]->data[ipp]=0; + par->cstm[ipop]->nadd[ipp]=1; + } //end omp for + } //end omp parallel + + return; +} + +void cstm_beams_preproc(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_cstm;ipop++) + cstm_beams_preproc_single(par,ipop); +} + +static void cstm_get_beam_properties_single(ParamCoLoRe *par,int ipop) +{ + HealpixShells *cmap=par->cstm[ipop]; + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,cmap,ipop) +#endif //_HAVE_OMP + { + double idx=par->n_grid/par->l_box; + + //Setup radial decomposition + int ir,nr; + double dr; + get_radial_params(par->r_max,par->n_grid,&nr,&dr); + + //Precompute kernel, bias and normalization + double k_max=-1E100; + double *kz=my_malloc(nr*sizeof(double)); + double *bz=my_malloc(nr*sizeof(double)); + double *normz=my_malloc(nr*sizeof(double)); + for(ir=0;irk_max) + k_max=fabs(kz[ir]); + } + //Find integration edges + int ir_min=0, ir_max=nr-1; + + for(ir=0;ir1E-4*k_max) { + ir_min=ir; + break; + } + } + for(ir=nr-1;ir>=0;ir--) { + if(fabs(kz[ir])>1E-4*k_max) { + ir_max=ir; + break; + } + } + if(ir_max < ir_min) + report_error(1, "Custom kernel has no suppport"); + + + long ip; +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ip=0;ipnum_pix;ip++) { + int ax,irr,added; + flouble d; + double xn[3]; + double *u=&(cmap->pos[3*ip]); + double cval=0; + + for(irr=ir_min;irr<=ir_max;irr++) { + double rm=(irr+0.5)*dr; + for(ax=0;ax<3;ax++) + xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; + added=interpolate_from_grid(par,xn,&d,NULL,NULL,NULL,NULL,RETURN_DENS,INTERP_CIC); + if(added) + cval+=kz[irr]*(bias_model(d,bz[irr])*normz[irr]-1); + } + cmap->data[ip]+=cval*dr; + } //end omp for + + free(kz); + free(bz); + free(normz); + } //end omp parallel + + return; +} + +void cstm_get_beam_properties(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_cstm;ipop++) + cstm_get_beam_properties_single(par,ipop); +} + +void cstm_beams_postproc(ParamCoLoRe *par) +{ + //Set rf to end of cell + return; +} diff --git a/src/.ipynb_checkpoints/density-checkpoint.c b/src/.ipynb_checkpoints/density-checkpoint.c new file mode 100644 index 0000000..f41bbc3 --- /dev/null +++ b/src/.ipynb_checkpoints/density-checkpoint.c @@ -0,0 +1,1393 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +static dftw_complex *dftw_alloc_complex(ptrdiff_t dsize) +{ + dftw_complex *p; +#ifdef _SPREC + p=fftwf_alloc_complex(dsize); +#else //_SPREC + p=fftw_alloc_complex(dsize); +#endif //_SPREC + if(p==NULL) + report_error(1,"Ran out of memory\n"); + return p; +} + +static void pos_2_ngp(ParamCoLoRe *par,unsigned long long np, + flouble *x,flouble *y,flouble *z,flouble *delta) +{ + unsigned long long ii; + flouble i_agrid=par->n_grid/par->l_box; + long ngx=2*(par->n_grid/2+1); + + for(ii=0;ii=par->n_grid) i0[ax]-=par->n_grid; + if(i0[ax]<0) i0[ax]+=par->n_grid; + } + i0[2]-=par->iz0_here; + + if((i0[2]>=0) && (i0[2]nz_here)) { + index=i0[0]+ngx*(i0[1]+par->n_grid*i0[2]); + delta[index]+=1.; + } + } +} + +static void pos_2_cic(ParamCoLoRe *par,unsigned long long np, + flouble *x,flouble *y,flouble *z,flouble *delta) +{ + unsigned long long ii; + flouble i_agrid=par->n_grid/par->l_box; + long ngx=2*(par->n_grid/2+1); + + for(ii=0;iin_grid; + if(i1[ax]<0) i1[ax]+=par->n_grid; + if(i0[ax]>=par->n_grid) i0[ax]-=par->n_grid; + if(i1[ax]>=par->n_grid) i1[ax]-=par->n_grid; + } + i0[2]-=par->iz0_here; + i1[2]-=par->iz0_here; + + if((i0[2]>=0) && (i0[2]nz_here)) { + delta[i0[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=a0[0]*a0[1]*a0[2]; + delta[i1[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=a1[0]*a0[1]*a0[2]; + delta[i0[0]+ngx*(i1[1]+par->n_grid*i0[2])]+=a0[0]*a1[1]*a0[2]; + delta[i1[0]+ngx*(i1[1]+par->n_grid*i0[2])]+=a1[0]*a1[1]*a0[2]; + } + if((i1[2]>=0) && (i1[2]nz_here)) { + delta[i0[0]+ngx*(i0[1]+par->n_grid*i1[2])]+=a0[0]*a0[1]*a1[2]; + delta[i1[0]+ngx*(i0[1]+par->n_grid*i1[2])]+=a1[0]*a0[1]*a1[2]; + delta[i0[0]+ngx*(i1[1]+par->n_grid*i1[2])]+=a0[0]*a1[1]*a1[2]; + delta[i1[0]+ngx*(i1[1]+par->n_grid*i1[2])]+=a1[0]*a1[1]*a1[2]; + } + } +} + +static void pos_2_tsc(ParamCoLoRe *par,unsigned long long np, + flouble *x,flouble *y,flouble *z,flouble *delta) +{ + unsigned long long ii; + flouble i_agrid=par->n_grid/par->l_box; + long ngx=2*(par->n_grid/2+1); + + for(ii=0;iin_grid; + if(i0[ax]<0) i0[ax]+=par->n_grid; + if(ip[ax]<0) ip[ax]+=par->n_grid; + if(im[ax]>=par->n_grid) im[ax]-=par->n_grid; + if(i0[ax]>=par->n_grid) i0[ax]-=par->n_grid; + if(ip[ax]>=par->n_grid) ip[ax]-=par->n_grid; + } + i0[2]-=par->iz0_here; + im[2]-=par->iz0_here; + ip[2]-=par->iz0_here; + + if((im[2]>=0) && (im[2]nz_here)) { + delta[im[0]+ngx*(im[1]+par->n_grid*im[2])]+=am[0]*am[1]*am[2]; + delta[i0[0]+ngx*(im[1]+par->n_grid*im[2])]+=a0[0]*am[1]*am[2]; + delta[ip[0]+ngx*(im[1]+par->n_grid*im[2])]+=ap[0]*am[1]*am[2]; + delta[im[0]+ngx*(i0[1]+par->n_grid*im[2])]+=am[0]*a0[1]*am[2]; + delta[i0[0]+ngx*(i0[1]+par->n_grid*im[2])]+=a0[0]*a0[1]*am[2]; + delta[ip[0]+ngx*(i0[1]+par->n_grid*im[2])]+=ap[0]*a0[1]*am[2]; + delta[im[0]+ngx*(ip[1]+par->n_grid*im[2])]+=am[0]*ap[1]*am[2]; + delta[i0[0]+ngx*(ip[1]+par->n_grid*im[2])]+=a0[0]*ap[1]*am[2]; + delta[ip[0]+ngx*(ip[1]+par->n_grid*im[2])]+=ap[0]*ap[1]*am[2]; + } + if((i0[2]>=0) && (i0[2]nz_here)) { + delta[im[0]+ngx*(im[1]+par->n_grid*i0[2])]+=am[0]*am[1]*a0[2]; + delta[i0[0]+ngx*(im[1]+par->n_grid*i0[2])]+=a0[0]*am[1]*a0[2]; + delta[ip[0]+ngx*(im[1]+par->n_grid*i0[2])]+=ap[0]*am[1]*a0[2]; + delta[im[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=am[0]*a0[1]*a0[2]; + delta[i0[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=a0[0]*a0[1]*a0[2]; + delta[ip[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=ap[0]*a0[1]*a0[2]; + delta[im[0]+ngx*(ip[1]+par->n_grid*i0[2])]+=am[0]*ap[1]*a0[2]; + delta[i0[0]+ngx*(ip[1]+par->n_grid*i0[2])]+=a0[0]*ap[1]*a0[2]; + delta[ip[0]+ngx*(ip[1]+par->n_grid*i0[2])]+=ap[0]*ap[1]*a0[2]; + } + if((ip[2]>=0) && (ip[2]nz_here)) { + delta[im[0]+ngx*(im[1]+par->n_grid*ip[2])]+=am[0]*am[1]*ap[2]; + delta[i0[0]+ngx*(im[1]+par->n_grid*ip[2])]+=a0[0]*am[1]*ap[2]; + delta[ip[0]+ngx*(im[1]+par->n_grid*ip[2])]+=ap[0]*am[1]*ap[2]; + delta[im[0]+ngx*(i0[1]+par->n_grid*ip[2])]+=am[0]*a0[1]*ap[2]; + delta[i0[0]+ngx*(i0[1]+par->n_grid*ip[2])]+=a0[0]*a0[1]*ap[2]; + delta[ip[0]+ngx*(i0[1]+par->n_grid*ip[2])]+=ap[0]*a0[1]*ap[2]; + delta[im[0]+ngx*(ip[1]+par->n_grid*ip[2])]+=am[0]*ap[1]*ap[2]; + delta[i0[0]+ngx*(ip[1]+par->n_grid*ip[2])]+=a0[0]*ap[1]*ap[2]; + delta[ip[0]+ngx*(ip[1]+par->n_grid*ip[2])]+=ap[0]*ap[1]*ap[2]; + } + } +} + +static void pos_2_dens(ParamCoLoRe *par,unsigned long long np_here, + flouble *x,flouble *y,flouble *z,flouble *dens) +{ + if(par->lpt_interp_type==INTERP_NGP) + pos_2_ngp(par,np_here,x,y,z,dens); + else if(par->lpt_interp_type==INTERP_CIC) + pos_2_cic(par,np_here,x,y,z,dens); + else if(par->lpt_interp_type==INTERP_TSC) + pos_2_tsc(par,np_here,x,y,z,dens); + else + report_error(1,"Wrong interpolation type\n"); +} + +#ifdef _HAVE_MPI +static void share_particles(ParamCoLoRe *par,unsigned long long np_allocated,unsigned long long np_real, + flouble *x,flouble *y,flouble *z,unsigned long long *np_here) +{ + int inode; + unsigned long long ip; + flouble dx=par->l_box/par->n_grid; + flouble *z_left=my_malloc(NNodes*sizeof(flouble)); + flouble *z_right=my_malloc(NNodes*sizeof(flouble)); + flouble *z_true_left=my_malloc(NNodes*sizeof(flouble)); + flouble *z_true_right=my_malloc(NNodes*sizeof(flouble)); + flouble *z_bleft_left=my_malloc(NNodes*sizeof(flouble)); + flouble *z_bleft_right=my_malloc(NNodes*sizeof(flouble)); + flouble *z_bright_left=my_malloc(NNodes*sizeof(flouble)); + flouble *z_bright_right=my_malloc(NNodes*sizeof(flouble)); + unsigned long long nbuffer=(unsigned long long)(par->lpt_buffer_fraction*par->nz_here* + ((long)(par->n_grid*par->n_grid))); + flouble *x_b=my_malloc(nbuffer*sizeof(flouble)); + flouble *y_b=my_malloc(nbuffer*sizeof(flouble)); + flouble *z_b=my_malloc(nbuffer*sizeof(flouble)); + + for(inode=0;inodeiz0_all[inode]*dx; + z_right[inode]=(par->iz0_all[inode]+par->nz_all[inode])*dx; + z_true_left[inode]=(par->iz0_all[inode]+(par->lpt_interp_type+1)*0.5)*dx; + z_true_right[inode]=(par->iz0_all[inode]+par->nz_all[inode]-(par->lpt_interp_type+1)*0.5)*dx; + z_bleft_left[inode]=(par->iz0_all[inode]-(par->lpt_interp_type+1)*0.5)*dx; + z_bleft_right[inode]=z_left[inode]; + z_bright_left[inode]=z_right[inode]; + z_bright_right[inode]=(par->iz0_all[inode]+par->nz_all[inode]+(par->lpt_interp_type+1)*0.5)*dx; + if(inode==0) { + z_bleft_left[inode]=(par->n_grid-(par->lpt_interp_type+1)*0.5)*dx; + z_bleft_right[inode]=par->n_grid*dx; + } + else if(inode==NNodes-1) { + z_bright_left[inode]=0; + z_bright_right[inode]=(par->lpt_interp_type+1)*0.5*dx; + } +#ifdef _DEBUG + print_info("MPI task %d: [%lf,%lf] [%lf,%lf] [%lf %lf] [%lf %lf]\n",inode, + z_left[inode],z_right[inode], + z_true_left[inode],z_true_right[inode], + z_bleft_left[inode],z_bleft_right[inode], + z_bright_left[inode],z_bright_right[inode]); +#ifdef _HAVE_MPI + MPI_Barrier(MPI_COMM_WORLD); +#endif +#endif //_DEBUG + } + + //Figure out which particles need to be moved and which stay + unsigned long long n_inrange=0,n_inbuffer=0; + for(ip=0;ip=z_left[NodeThis]) && (z[ip]=z_bleft_left[NodeThis]) && (z[ip]=z_bright_left[NodeThis]) && (z[ip]=z_true_right[NodeThis])) + send=1; + + if(send) { + if(n_inbuffer>=nbuffer) + report_error(1,"Out of memory, enlarge buffer %llu (%llu,%llu) %llu\n", + np_allocated,n_inbuffer,nbuffer,n_inrange); + x_b[n_inbuffer]=x[ip]; + y_b[n_inbuffer]=y[ip]; + z_b[n_inbuffer]=z[ip]; + n_inbuffer++; + } + + if(include) { + if(n_inrange>=np_allocated) + report_error(1,"Out of memory, enlarge buffer %llu %llu %llu\n",np_allocated,n_inbuffer,n_inrange); + x[n_inrange]=x[ip]; + y[n_inrange]=y[ip]; + z[n_inrange]=z[ip]; + n_inrange++; + } + } + +#ifdef _DEBUG + printf("MPI task %d: %llu %llu %llu %llu\n",NodeThis,np_allocated,n_inrange,nbuffer,n_inbuffer); +#ifdef _HAVE_MPI + MPI_Barrier(MPI_COMM_WORLD); +#endif +#endif //_DEBUG + + for(inode=1;inode=z_left[node_to]) && (z_b[i]=z_bleft_left[node_to]) && (z_b[i]=z_bright_left[node_to]) && (z_b[i]=0 && + (((z_b[j]>=z_left[node_to]) && (z_b[j]=z_bleft_left[node_to]) && (z_b[j]=z_bright_left[node_to]) && (z_b[j]np_allocated) + report_error(1,"Not enough memory, enlarge buffer\n"); + +#ifdef _HAVE_MPI + MPI_Sendrecv(x_send,nsend*sizeof(flouble),FLOUBLE_MPI,node_to,tag, + x+n_inrange,nrecv*sizeof(flouble),FLOUBLE_MPI,node_from,tag,MPI_COMM_WORLD,&status); + MPI_Sendrecv(y_send,nsend*sizeof(flouble),FLOUBLE_MPI,node_to,tag, + y+n_inrange,nrecv*sizeof(flouble),FLOUBLE_MPI,node_from,tag,MPI_COMM_WORLD,&status); + MPI_Sendrecv(z_send,nsend*sizeof(flouble),FLOUBLE_MPI,node_to,tag, + z+n_inrange,nrecv*sizeof(flouble),FLOUBLE_MPI,node_from,tag,MPI_COMM_WORLD,&status); +#endif //_HAVE_MPI + + n_inrange+=nrecv; + } + + *np_here=n_inrange; + + free(z_left); + free(z_right); + free(z_bleft_left); + free(z_bleft_right); + free(z_bright_left); + free(z_bright_right); + free(x_b); + free(y_b); + free(z_b); + + return; +} +#endif //_HAVE_MPI + +static void lpt_1(ParamCoLoRe *par) +{ + int axis; + + dftw_complex *(cdisp[3]); + flouble *(disp[3]); + ptrdiff_t dsize=par->nz_here*((long)(par->n_grid*(par->n_grid/2+1))); + ptrdiff_t dsize_buff=(ptrdiff_t)(dsize*(1+par->lpt_buffer_fraction)); + + print_info(" 1LPT\n"); + + print_info(" - Transforming density field\n"); + for(axis=0;axis<3;axis++) { + cdisp[axis]=dftw_alloc_complex(dsize_buff); + disp[axis]=(flouble *)cdisp[axis]; + } + fftw_wrap_r2c(par->n_grid,par->grid_dens,par->grid_dens_f); + + print_info(" - Computing displacement field\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,cdisp) +#endif //_HAVE_OMP + { + int ii; + double dk=2*M_PI/par->l_box; + double kv[3]; + double fftnorm=(double)(par->n_grid*((long)(par->n_grid*par->n_grid))); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iinz_here;ii++) { + int jj,ii_true; + ii_true=par->iz0_here+ii; + if(2*ii_true<=par->n_grid) + kv[2]=ii_true*dk; + else + kv[2]=-(par->n_grid-ii_true)*dk; + for(jj=0;jjn_grid;jj++) { + int kk; + if(2*jj<=par->n_grid) + kv[1]=jj*dk; + else + kv[1]=-(par->n_grid-jj)*dk; + for(kk=0;kk<=par->n_grid/2;kk++) { + int ax; + double k_mod2; + long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k + if(2*kk<=par->n_grid) + kv[0]=kk*dk; + else + kv[0]=-(par->n_grid-kk)*dk; //This should never happen + + k_mod2=fftnorm*(kv[0]*kv[0]+kv[1]*kv[1]+kv[2]*kv[2]); + + for(ax=0;ax<3;ax++) { + if(k_mod2<=0) + cdisp[ax][index]=0; + else + cdisp[ax][index]=I*kv[ax]*par->grid_dens_f[index]/k_mod2; + } + } + } + } //end omp for + } //end omp parallel + + print_info(" - Transform displacement field\n"); + for(axis=0;axis<3;axis++) + fftw_wrap_c2r(par->n_grid,cdisp[axis],disp[axis]); + + print_info(" - Computing particle positions\n"); +#ifdef _DEBUG + double d_sigma2_1=0; + double d_mean_1[3]={0,0,0}; +#endif //_DEBUG +#ifdef _HAVE_OMP +#ifdef _DEBUG +#pragma omp parallel default(none) shared(par,disp,d_mean_1,d_sigma2_1) +#else //_DEBUG +#pragma omp parallel default(none) shared(par,disp) +#endif //_DEBUG +#endif //_HAVE_OMP + { + long iz; + int ngx=2*(par->n_grid/2+1); + flouble dx=par->l_box/par->n_grid; + flouble xv[3]; + +#ifdef _DEBUG + double d_sigma2_1_thr=0; + double d_mean_1_thr[3]={0,0,0}; +#endif //_DEBUG + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + xv[2]=(iz+par->iz0_here+0.0)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + xv[1]=(iy+0.0)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + int ax; + double r,dg; + long index=ix+indexy+indexz; + xv[0]=(ix+0.0)*dx-par->pos_obs[0]; + r=sqrt(xv[0]*xv[0]+xv[1]*xv[1]+xv[2]*xv[2]); + dg=get_bg(par,r,BG_D1,0); + for(ax=0;ax<3;ax++) { +#ifdef _DEBUG + d_mean_1_thr[ax]+=disp[ax][index]; + d_sigma2_1_thr+=disp[ax][index]*disp[ax][index]; +#endif //_DEBUG + flouble p=xv[ax]+dg*disp[ax][index]+par->pos_obs[ax]; + if(p<0) p+=par->l_box; + if(p>=par->l_box) p-=par->l_box; + disp[ax][index]=p; + } + par->grid_dens[index]=0; + } + } + } //end omp for +#ifdef _DEBUG +#ifdef _HAVE_OMP +#pragma omp critical +#endif //_HAVE_OMP + { + d_mean_1[0]+=d_mean_1_thr[0]; + d_mean_1[1]+=d_mean_1_thr[1]; + d_mean_1[2]+=d_mean_1_thr[2]; + d_sigma2_1+=d_sigma2_1_thr; + } +#endif //_DEBUG + } //end omp parallel + +#ifdef _DEBUG +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(d_mean_1,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(&d_sigma2_1,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + if(NodeThis==0) { + d_mean_1[0]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_1[1]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_1[2]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_sigma2_1/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + + print_info(" 1st-order displacement : [%lE,%lE,%lE] %lE\n", + d_mean_1[0],d_mean_1[1],d_mean_1[2],sqrt(d_sigma2_1)); + } +#endif //_DEBUG + + print_info(" - Undoing padding\n"); + { + long iz; + int ngx=2*(par->n_grid/2+1); + + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + long indexz_unpadded=iz*((long)(par->n_grid*par->n_grid)); + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + long indexy_unpadded=iy*par->n_grid; + for(ix=0;ixn_grid;ix++) { + int ax; + long index=ix+indexy+indexz; + long index_unpadded=ix+indexy_unpadded+indexz_unpadded; + for(ax=0;ax<3;ax++) + disp[ax][index_unpadded]=disp[ax][index]; + } + } + } + } + + unsigned long long np_here; + if(par->output_lpt) { + np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); + print_info(" - Writing LPT positions\n"); + write_lpt(par,np_here,disp[0],disp[1],disp[2]); + } + +#ifdef _HAVE_MPI + print_info(" - Sharing particle positions\n"); + share_particles(par,(unsigned long long)(2*dsize_buff), + (unsigned long long)(par->nz_here*((long)(par->n_grid*par->n_grid))), + disp[0],disp[1],disp[2],&np_here); +#else //_HAVE_MPI + np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); +#endif //_HAVE_MPI + + print_info(" - Interpolating positions into density field\n"); + pos_2_dens(par,np_here,disp[0],disp[1],disp[2],par->grid_dens); + +#ifdef _SPREC + for(axis=0;axis<3;axis++) + fftwf_free(cdisp[axis]); +#else //_SPREC + for(axis=0;axis<3;axis++) + fftw_free(cdisp[axis]); +#endif //_SPREC + + print_info(" - Normalizing density field\n"); +#ifdef _DEBUG + double numtot=0; +#endif //_DEBUG +#ifdef _HAVE_OMP +#ifdef _DEBUG +#pragma omp parallel default(none) shared(par,numtot) +#else //_DEBUG +#pragma omp parallel default(none) shared(par) +#endif //_DEBUG +#endif //_HAVE_OMP + { + long iz; + int ngx=2*(par->n_grid/2+1); + flouble inv_dens=1.; +#ifdef _DEBUG + double numtot_thr=0; +#endif //_DEBUG + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + for(ix=0;ixn_grid;ix++) { + long index=ix+indexy+indexz; +#ifdef _DEBUG + numtot_thr+=par->grid_dens[index]; +#endif //_DEBUG + par->grid_dens[index]=par->grid_dens[index]*inv_dens-1.; + } + } + } //end omp for +#ifdef _DEBUG +#ifdef _HAVE_OMP +#pragma omp critical +#endif //_HAVE_OMP + { + numtot+=numtot_thr; + } +#endif //_DEBUG + } //end omp parallel + +#ifdef _DEBUG +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(&numtot,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + print_info(" Total density : %lE\n",numtot-(double)(par->n_grid*((long)(par->n_grid*par->n_grid)))); +#endif //_DEBUG +} + +static void lpt_2(ParamCoLoRe *par) +{ + int axis; + + dftw_complex *(cdisp[3]),*(cdigrad[6]); + flouble *(disp[3]),*(digrad[6]); + ptrdiff_t dsize=par->nz_here*((long)(par->n_grid*(par->n_grid/2+1))); + ptrdiff_t dsize_buff=(ptrdiff_t)(dsize*(1+par->lpt_buffer_fraction)); + + print_info(" 2LPT\n"); + + print_info(" - Transforming density field\n"); + for(axis=0;axis<2;axis++) { + cdisp[axis]=dftw_alloc_complex(dsize_buff); + disp[axis]=(flouble *)cdisp[axis]; + } + for(axis=0;axis<6;axis++) { + cdigrad[axis]=dftw_alloc_complex(dsize_buff); + digrad[axis]=(flouble *)cdigrad[axis]; + } + cdisp[2]=par->grid_dens_f; + disp[2]=par->grid_dens; + fftw_wrap_r2c(par->n_grid,par->grid_dens,par->grid_dens_f); + + print_info(" - Computing displacement field\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,cdisp,cdigrad) +#endif //_HAVE_OMP + { + int ii; + double dk=2*M_PI/par->l_box; + double kv[3]; + double fftnorm=(double)(par->n_grid*((long)(par->n_grid*par->n_grid))); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iinz_here;ii++) { + int jj,ii_true; + ii_true=par->iz0_here+ii; + if(2*ii_true<=par->n_grid) + kv[2]=ii_true*dk; + else + kv[2]=-(par->n_grid-ii_true)*dk; + for(jj=0;jjn_grid;jj++) { + int kk; + if(2*jj<=par->n_grid) + kv[1]=jj*dk; + else + kv[1]=-(par->n_grid-jj)*dk; + for(kk=0;kk<=par->n_grid/2;kk++) { + int ax; + double k_mod2; + long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k + if(2*kk<=par->n_grid) + kv[0]=kk*dk; + else + kv[0]=-(par->n_grid-kk)*dk; //This should never happen + + k_mod2=fftnorm*(kv[0]*kv[0]+kv[1]*kv[1]+kv[2]*kv[2]); + + for(ax=0;ax<3;ax++) { + if(k_mod2<=0) + cdisp[ax][index]=0; + else + cdisp[ax][index]=I*kv[ax]*par->grid_dens_f[index]/k_mod2; + } + + cdigrad[0][index]=I*kv[0]*cdisp[0][index]; //SIGN + cdigrad[1][index]=I*kv[1]*cdisp[0][index]; + cdigrad[2][index]=I*kv[2]*cdisp[0][index]; + cdigrad[3][index]=I*kv[1]*cdisp[1][index]; + cdigrad[4][index]=I*kv[2]*cdisp[1][index]; + cdigrad[5][index]=I*kv[2]*cdisp[2][index]; + } + } + } //end omp for + } //end omp parallel + + print_info(" - Transform digradient\n"); + for(axis=0;axis<6;axis++) + fftw_wrap_c2r(par->n_grid,cdigrad[axis],digrad[axis]); + + print_info(" - Computing second-order potential\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,digrad) +#endif //_HAVE_OMP + { + int iz; + int ngx=2*(par->n_grid/2+1); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + for(ix=0;ixn_grid;ix++) { + long index=ix+indexy+indexz; //SIGN + digrad[5][index]= + digrad[0][index]*digrad[3][index]+//xx*yy + digrad[0][index]*digrad[5][index]+//xx*zz + digrad[3][index]*digrad[5][index]-//+yy*zz + digrad[1][index]*digrad[1][index]-//-xy*xy + digrad[2][index]*digrad[2][index]-//-xz*xz + digrad[4][index]*digrad[4][index];//-yz*yz + } + } + } //end omp for + } //end omp parallel + + print_info(" - Transforming second-order potential\n"); + fftw_wrap_r2c(par->n_grid,digrad[5],cdigrad[5]); + + print_info(" - Computing 2nd-order displacement field\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,cdigrad) +#endif //_HAVE_OMP + { + int ii; + double dk=2*M_PI/par->l_box; + double kv[3]; + double fftnorm=(double)(par->n_grid*((long)(par->n_grid*par->n_grid))); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iinz_here;ii++) { + int jj,ii_true; + ii_true=par->iz0_here+ii; + if(2*ii_true<=par->n_grid) + kv[2]=ii_true*dk; + else + kv[2]=-(par->n_grid-ii_true)*dk; + for(jj=0;jjn_grid;jj++) { + int kk; + if(2*jj<=par->n_grid) + kv[1]=jj*dk; + else + kv[1]=-(par->n_grid-jj)*dk; + for(kk=0;kk<=par->n_grid/2;kk++) { + int ax; + double k_mod2; + long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k + if(2*kk<=par->n_grid) + kv[0]=kk*dk; + else + kv[0]=-(par->n_grid-kk)*dk; //This should never happen + + k_mod2=fftnorm*(kv[0]*kv[0]+kv[1]*kv[1]+kv[2]*kv[2]); + + for(ax=0;ax<3;ax++) { + if(k_mod2<=0) + cdigrad[ax][index]=0; + else + cdigrad[ax][index]=-I*kv[ax]*cdigrad[5][index]/k_mod2; //SIGN, 1/k^2, normalization + } + } + } + } //end omp for + } //end omp parallel + + print_info(" - Transform 1st- and 2nd-order displacement fields\n"); + for(axis=0;axis<3;axis++) { + fftw_wrap_c2r(par->n_grid,cdisp[axis],disp[axis]); + fftw_wrap_c2r(par->n_grid,cdigrad[axis],digrad[axis]); + } + + print_info(" - Computing particle positions\n"); +#ifdef _DEBUG + double d_sigma2_1=0; + double d_mean_1[3]={0,0,0}; + double d_sigma2_2=0; + double d_mean_2[3]={0,0,0}; +#endif //_DEBUG +#ifdef _HAVE_OMP +#ifdef _DEBUG +#pragma omp parallel default(none) shared(par,disp,digrad,d_mean_1,d_mean_2,d_sigma2_1,d_sigma2_2) +#else //_DEBUG +#pragma omp parallel default(none) shared(par,disp,digrad) +#endif //_DEBUG +#endif //_HAVE_OMP + { + long iz; + int ngx=2*(par->n_grid/2+1); + flouble dx=par->l_box/par->n_grid; + flouble xv[3]; + +#ifdef _DEBUG + double d_sigma2_1_thr=0; + double d_mean_1_thr[3]={0,0,0}; + double d_sigma2_2_thr=0; + double d_mean_2_thr[3]={0,0,0}; +#endif //_DEBUG + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + xv[2]=(iz+par->iz0_here+0.0)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + xv[1]=(iy+0.0)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + int ax; + double r,dg,d2g; + long index=ix+indexy+indexz; + long index_nopad=ix+par->n_grid*((long)(iy+par->n_grid*iz)); + xv[0]=(ix+0.0)*dx-par->pos_obs[0]; + r=sqrt(xv[0]*xv[0]+xv[1]*xv[1]+xv[2]*xv[2]); + dg=get_bg(par,r,BG_D1,0); + d2g=get_bg(par,r,BG_D2,0); + for(ax=0;ax<3;ax++) { +#ifdef _DEBUG + d_mean_1_thr[ax]+=disp[ax][index]; + d_mean_2_thr[ax]+=digrad[ax][index]; + d_sigma2_1_thr+=disp[ax][index]*disp[ax][index]; + d_sigma2_2_thr+=digrad[ax][index]*digrad[ax][index]; +#endif //_DEBUG + flouble p=xv[ax]+dg*disp[ax][index]+d2g*digrad[ax][index]+par->pos_obs[ax]; + if(p<0) p+=par->l_box; + if(p>=par->l_box) p-=par->l_box; + digrad[3+ax][index_nopad]=p; + } + par->grid_dens[index]=0; + } + } + } //end omp for +#ifdef _DEBUG +#ifdef _HAVE_OMP +#pragma omp critical +#endif //_HAVE_OMP + { + d_mean_1[0]+=d_mean_1_thr[0]; + d_mean_1[1]+=d_mean_1_thr[1]; + d_mean_1[2]+=d_mean_1_thr[2]; + d_mean_2[0]+=d_mean_2_thr[0]; + d_mean_2[1]+=d_mean_2_thr[1]; + d_mean_2[2]+=d_mean_2_thr[2]; + d_sigma2_1+=d_sigma2_1_thr; + d_sigma2_2+=d_sigma2_2_thr; + } +#endif //_DEBUG + } //end omp parallel + +#ifdef _DEBUG +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(d_mean_1,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,d_mean_2,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(d_mean_2,d_mean_2,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(&d_sigma2_1,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,&d_sigma2_2,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(&d_sigma2_2,&d_sigma2_2,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + if(NodeThis==0) { + d_mean_1[0]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_1[1]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_1[2]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_2[0]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_2[1]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_mean_2[2]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_sigma2_1/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + d_sigma2_2/=(par->n_grid*((long)(par->n_grid*par->n_grid))); + + print_info(" 1st-order displacement : [%lE,%lE,%lE] %lE\n", + d_mean_1[0],d_mean_1[1],d_mean_1[2],sqrt(d_sigma2_1)); + print_info(" 2nd-order displacement : [%lE,%lE,%lE] %lE\n", + d_mean_2[0],d_mean_2[1],d_mean_2[2],sqrt(d_sigma2_2)); + } +#endif //_DEBUG + +#ifdef _SPREC + for(axis=0;axis<2;axis++) + fftwf_free(cdisp[axis]); + for(axis=0;axis<3;axis++) + fftwf_free(cdigrad[axis]); +#else //_SPREC + for(axis=0;axis<2;axis++) + fftw_free(cdisp[axis]); + for(axis=0;axis<3;axis++) + fftw_free(cdigrad[axis]); +#endif //_SPREC + + unsigned long long np_here; + if(par->output_lpt) { + np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); + print_info(" - Writing LPT positions\n"); + write_lpt(par,np_here,digrad[3],digrad[4],digrad[5]); + } + +#ifdef _HAVE_MPI + print_info(" - Sharing particle positions\n"); + share_particles(par,(unsigned long long)(2*dsize_buff), + (unsigned long long)(par->nz_here*((long)(par->n_grid*par->n_grid))), + digrad[3],digrad[4],digrad[5],&np_here); +#else //_HAVE_MPI + np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); +#endif //_HAVE_MPI + + print_info(" - Interpolating positions into density field\n"); + pos_2_dens(par,np_here,digrad[3],digrad[4],digrad[5],par->grid_dens); + +#ifdef _SPREC + for(axis=0;axis<3;axis++) + fftwf_free(cdigrad[3+axis]); +#else //_SPREC + for(axis=0;axis<3;axis++) + fftw_free(cdigrad[3+axis]); +#endif //_SPREC + + print_info(" - Normalizing density field\n"); +#ifdef _DEBUG + double numtot=0; +#endif //_DEBUG +#ifdef _HAVE_OMP +#ifdef _DEBUG +#pragma omp parallel default(none) shared(par,numtot) +#else //_DEBUG +#pragma omp parallel default(none) shared(par) +#endif //_DEBUG +#endif //_HAVE_OMP + { + long iz; + int ngx=2*(par->n_grid/2+1); + flouble inv_dens=1.; +#ifdef _DEBUG + double numtot_thr=0; +#endif //_DEBUG + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + for(ix=0;ixn_grid;ix++) { + long index=ix+indexy+indexz; +#ifdef _DEBUG + numtot_thr+=par->grid_dens[index]; +#endif //_DEBUG + par->grid_dens[index]=par->grid_dens[index]*inv_dens-1.; + } + } + } //end omp for +#ifdef _DEBUG +#ifdef _HAVE_OMP +#pragma omp critical +#endif //_HAVE_OMP + { + numtot+=numtot_thr; + } +#endif //_DEBUG + } //end omp parallel + +#ifdef _DEBUG +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(&numtot,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + print_info(" Total density : %lE\n",numtot-(double)(par->n_grid*((long)(par->n_grid*par->n_grid)))); +#endif //_DEBUG +} + +//Lognormalizes density grid and puts in lightcone +static void densclip(ParamCoLoRe *par) +{ + print_info("Lognormalizin'\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) shared(par) +#endif //_HAVE_OMP + { + long iz; + int ngx=2*(par->n_grid/2+1); + flouble dx=par->l_box/par->n_grid; + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + flouble z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + flouble y0=(iy+0.5)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + long index=ix+indexy+indexz; + flouble x0=(ix+0.5)*dx-par->pos_obs[0]; + double r=sqrt(x0*x0+y0*y0+z0*z0); + double dg=get_bg(par,r,BG_D1,0); + double delta=par->grid_dens[index]; + par->grid_dens[index]=fmax(1+dg*delta,0)-1; + } + } + }//end omp for + }//end omp parallel +} + +//Lognormalizes density grid and puts in lightcone +static void lognormalize(ParamCoLoRe *par) +{ + print_info("Lognormalizin'\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) shared(par) +#endif //_HAVE_OMP + { + long iz; + int ngx=2*(par->n_grid/2+1); + flouble dx=par->l_box/par->n_grid; + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + flouble z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + flouble y0=(iy+0.5)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + long index=ix+indexy+indexz; + flouble x0=(ix+0.5)*dx-par->pos_obs[0]; + double r=sqrt(x0*x0+y0*y0+z0*z0); + double dg=get_bg(par,r,BG_D1,0); + double delta=par->grid_dens[index]; + par->grid_dens[index]=exp(dg*(delta-0.5*dg*par->sigma2_gauss))-1; + } + } + }//end omp for + }//end omp parallel +} + +void compute_physical_density_field(ParamCoLoRe *par) +{ + print_info("*** Creating physical matter density\n"); + if(NodeThis==0) timer(0); + + if(par->dens_type==DENS_TYPE_LGNR) + lognormalize(par); + else if(par->dens_type==DENS_TYPE_1LPT) + lpt_1(par); + else if(par->dens_type==DENS_TYPE_2LPT) + lpt_2(par); + else if(par->dens_type==DENS_TYPE_CLIP) + densclip(par); + else + report_error(1,"Density type %d not supported\n",par->dens_type); + + if(NodeThis==0) timer(2); + print_info("\n"); + + if(par->output_density) + write_density_grid(par,"lightcone"); +} + +static void collect_density_normalization_from_grid(ParamCoLoRe *par,int nz,double idz,double *zarr, + unsigned long long *narr, + double **norm_srcs_arr,double **norm_imap_arr, + double **norm_cstm_arr) +{ +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,idz,nz,zarr,narr,norm_srcs_arr,norm_imap_arr,norm_cstm_arr) +#endif //_HAVE_OMP + { + int iz,ipop; + flouble dx=par->l_box/par->n_grid; + double *zarr_thr=my_calloc(nz,sizeof(double)); + unsigned long long *narr_thr=my_calloc(nz,sizeof(unsigned long long)); + double **norm_srcs_arr_thr=my_malloc(par->n_srcs*sizeof(double *)); + double **norm_imap_arr_thr=my_malloc(par->n_imap*sizeof(double *)); + double **norm_cstm_arr_thr=my_malloc(par->n_cstm*sizeof(double *)); + for(ipop=0;ipopn_srcs;ipop++) + norm_srcs_arr_thr[ipop]=my_calloc(nz,sizeof(double)); + for(ipop=0;ipopn_imap;ipop++) + norm_imap_arr_thr[ipop]=my_calloc(nz,sizeof(double)); + for(ipop=0;ipopn_cstm;ipop++) + norm_cstm_arr_thr[ipop]=my_calloc(nz,sizeof(double)); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long iz0=iz*((long)(2*(par->n_grid/2+1)*par->n_grid)); + flouble z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long iy0=iy*2*(par->n_grid/2+1); + flouble y0=(iy+0.5)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + long index=ix+iy0+iz0; + flouble x0=(ix+0.5)*dx-par->pos_obs[0]; + double r=sqrt(x0*x0+y0*y0+z0*z0); + double redshift=get_bg(par,r,BG_Z,0); + int ind_z=(int)(redshift*idz)+1; + if((ind_z>=0) && (ind_zgrid_dens[index]; + narr_thr[ind_z]++; + zarr_thr[ind_z]+=redshift; + for(ipop=0;ipopn_srcs;ipop++) + norm_srcs_arr_thr[ipop][ind_z]+=bias_model(d,get_bg(par,r,BG_BZ_SRCS,ipop)); + for(ipop=0;ipopn_imap;ipop++) + norm_imap_arr_thr[ipop][ind_z]+=bias_model(d,get_bg(par,r,BG_BZ_IMAP,ipop)); + for(ipop=0;ipopn_cstm;ipop++) + norm_cstm_arr_thr[ipop][ind_z]+=bias_model(d,get_bg(par,r,BG_BZ_CSTM,ipop)); + } + } + } + } //end omp for +#ifdef _HAVE_OMP +#pragma omp critical +#endif //_HAVE_OMP + { + for(iz=0;izn_srcs;ipop++) + norm_srcs_arr[ipop][iz]+=norm_srcs_arr_thr[ipop][iz]; + for(ipop=0;ipopn_imap;ipop++) + norm_imap_arr[ipop][iz]+=norm_imap_arr_thr[ipop][iz]; + for(ipop=0;ipopn_cstm;ipop++) + norm_cstm_arr[ipop][iz]+=norm_cstm_arr_thr[ipop][iz]; + } + } //end omp critical + + free(narr_thr); + free(zarr_thr); + for(ipop=0;ipopn_srcs;ipop++) + free(norm_srcs_arr_thr[ipop]); + free(norm_srcs_arr_thr); + for(ipop=0;ipopn_imap;ipop++) + free(norm_imap_arr_thr[ipop]); + free(norm_imap_arr_thr); + for(ipop=0;ipopn_cstm;ipop++) + free(norm_cstm_arr_thr[ipop]); + free(norm_cstm_arr_thr); + } //end omp parallel +} + +static void collect_density_normalization(ParamCoLoRe *par,int nz,double idz,double *zarr, + unsigned long long *narr, + double **norm_srcs_arr,double **norm_imap_arr, + double **norm_cstm_arr) +{ + // if(par->need_onions) + // collect_density_normalization_from_pixels(par,nz,idz,zarr,narr,norm_srcs_arr,norm_imap_arr); + // else + // collect_density_normalization_from_grid(par,nz,idz,zarr,narr,norm_srcs_arr,norm_imap_arr); + collect_density_normalization_from_grid(par,nz,idz,zarr,narr,norm_srcs_arr, + norm_imap_arr,norm_cstm_arr); +} + +//Computes sigma2(z) for physical density field +void compute_density_normalization(ParamCoLoRe *par) +{ + int nz,iz,ii,ipop; + double idz; + double *zarr,**norm_imap_arr,**norm_srcs_arr,**norm_cstm_arr; + unsigned long long *narr; + double zmax=get_bg(par,par->l_box*0.5,BG_Z,0); + gsl_spline *spline_norm_srcs[NPOP_MAX]; + gsl_interp_accel *intacc_srcs=gsl_interp_accel_alloc(); + gsl_spline *spline_norm_imap[NPOP_MAX]; + gsl_interp_accel *intacc_imap=gsl_interp_accel_alloc(); + gsl_spline *spline_norm_cstm[NPOP_MAX]; + gsl_interp_accel *intacc_cstm=gsl_interp_accel_alloc(); + + print_info("*** Computing normalization of density field\n"); + if(NodeThis==0) timer(0); + + nz=(int)(zmax/DZ_SIGMA)+2; + idz=(nz-2)/zmax; + + zarr=my_calloc(nz,sizeof(double)); + narr=my_calloc(nz,sizeof(unsigned long long)); + norm_srcs_arr=my_malloc(par->n_srcs*sizeof(double *)); + norm_imap_arr=my_malloc(par->n_imap*sizeof(double *)); + norm_cstm_arr=my_malloc(par->n_cstm*sizeof(double *)); + for(ipop=0;ipopn_srcs;ipop++) + norm_srcs_arr[ipop]=my_calloc(nz,sizeof(double)); + for(ipop=0;ipopn_imap;ipop++) + norm_imap_arr[ipop]=my_calloc(nz,sizeof(double)); + for(ipop=0;ipopn_cstm;ipop++) + norm_cstm_arr[ipop]=my_calloc(nz,sizeof(double)); + + collect_density_normalization(par,nz,idz,zarr,narr,norm_srcs_arr,norm_imap_arr,norm_cstm_arr); + +#ifdef _HAVE_MPI + MPI_Allreduce(MPI_IN_PLACE,narr,nz,MPI_UNSIGNED_LONG_LONG,MPI_SUM,MPI_COMM_WORLD); + for(ipop=0;ipopn_srcs;ipop++) + MPI_Allreduce(MPI_IN_PLACE,norm_srcs_arr[ipop],nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); + for(ipop=0;ipopn_imap;ipop++) + MPI_Allreduce(MPI_IN_PLACE,norm_imap_arr[ipop],nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); + for(ipop=0;ipopn_cstm;ipop++) + MPI_Allreduce(MPI_IN_PLACE,norm_cstm_arr[ipop],nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); + MPI_Allreduce(MPI_IN_PLACE,zarr,nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); +#endif //_HAVE_MPI + + for(iz=0;iz0) { + zarr[iz]/=narr[iz]; + for(ipop=0;ipopn_srcs;ipop++) + norm_srcs_arr[ipop][iz]=narr[iz]/norm_srcs_arr[ipop][iz]; + for(ipop=0;ipopn_imap;ipop++) + norm_imap_arr[ipop][iz]=narr[iz]/norm_imap_arr[ipop][iz]; + for(ipop=0;ipopn_cstm;ipop++) + norm_cstm_arr[ipop][iz]=narr[iz]/norm_cstm_arr[ipop][iz]; + } + } + + zarr[0]=0; + zarr[nz-1]=get_bg(par,0.5*par->l_box,BG_Z,0); + for(ipop=0;ipopn_srcs;ipop++) { + norm_srcs_arr[ipop][0]=norm_srcs_arr[ipop][1]; + norm_srcs_arr[ipop][nz-1]=norm_srcs_arr[ipop][nz-2]; + } + for(ipop=0;ipopn_imap;ipop++) { + norm_imap_arr[ipop][0]=norm_imap_arr[ipop][1]; + norm_imap_arr[ipop][nz-1]=norm_imap_arr[ipop][nz-2]; + } + for(ipop=0;ipopn_cstm;ipop++) { + norm_cstm_arr[ipop][0]=norm_cstm_arr[ipop][1]; + norm_cstm_arr[ipop][nz-1]=norm_cstm_arr[ipop][nz-2]; + } + + par->z0_norm=zarr[0]; + par->zf_norm=zarr[nz-1]; + for(ipop=0;ipopn_srcs;ipop++) { + par->norm_srcs_0[ipop]=norm_srcs_arr[ipop][0]; + par->norm_srcs_f[ipop]=norm_srcs_arr[ipop][nz-1]; + spline_norm_srcs[ipop]=gsl_spline_alloc(gsl_interp_linear,nz); + gsl_spline_init(spline_norm_srcs[ipop],zarr,norm_srcs_arr[ipop],nz); + par->srcs_norm_arr[ipop]=my_malloc(NA*sizeof(double)); + } + for(ipop=0;ipopn_imap;ipop++) { + par->norm_imap_0[ipop]=norm_imap_arr[ipop][0]; + par->norm_imap_f[ipop]=norm_imap_arr[ipop][nz-1]; + spline_norm_imap[ipop]=gsl_spline_alloc(gsl_interp_linear,nz); + gsl_spline_init(spline_norm_imap[ipop],zarr,norm_imap_arr[ipop],nz); + par->imap_norm_arr[ipop]=my_malloc(NA*sizeof(double)); + } + for(ipop=0;ipopn_cstm;ipop++) { + par->norm_cstm_0[ipop]=norm_cstm_arr[ipop][0]; + par->norm_cstm_f[ipop]=norm_cstm_arr[ipop][nz-1]; + spline_norm_cstm[ipop]=gsl_spline_alloc(gsl_interp_linear,nz); + gsl_spline_init(spline_norm_cstm[ipop],zarr,norm_cstm_arr[ipop],nz); + par->cstm_norm_arr[ipop]=my_malloc(NA*sizeof(double)); + } + + for(ii=0;iir_arr_r2z[ii],BG_Z,0); + for(ipop=0;ipopn_srcs;ipop++) { + double nm; + if(zz0_norm) + nm=par->norm_srcs_0[ipop]; + else if(z>=par->zf_norm) + nm=par->norm_srcs_f[ipop]; + else + nm=gsl_spline_eval(spline_norm_srcs[ipop],z,intacc_srcs); + par->srcs_norm_arr[ipop][ii]=nm; + } + for(ipop=0;ipopn_imap;ipop++) { + double nm; + if(zz0_norm) + nm=par->norm_imap_0[ipop]; + else if(z>=par->zf_norm) + nm=par->norm_imap_f[ipop]; + else + nm=gsl_spline_eval(spline_norm_imap[ipop],z,intacc_imap); + par->imap_norm_arr[ipop][ii]=nm; + } + for(ipop=0;ipopn_cstm;ipop++) { + double nm; + if(zz0_norm) + nm=par->norm_cstm_0[ipop]; + else if(z>=par->zf_norm) + nm=par->norm_cstm_f[ipop]; + else + nm=gsl_spline_eval(spline_norm_cstm[ipop],z,intacc_cstm); + par->cstm_norm_arr[ipop][ii]=nm; + } + } + +#ifdef _DEBUG + for(iz=0;izn_srcs;ipop++) + print_info("=%.3lE, ",ipop,get_bg(par,rz,BG_NORM_SRCS,ipop)); + for(ipop=0;ipopn_imap;ipop++) + print_info("=%.3lE, ",ipop,get_bg(par,rz,BG_NORM_IMAP,ipop)); + for(ipop=0;ipopn_cstm;ipop++) + print_info("=%.3lE, ",ipop,get_bg(par,rz,BG_NORM_CSTM,ipop)); + print_info("%011llu\n",narr[iz]); + } +#endif //_DEBUG + if(NodeThis==0) timer(2); + print_info("\n"); + + free(zarr); + free(narr); + for(ipop=0;ipopn_srcs;ipop++) { + free(norm_srcs_arr[ipop]); + gsl_spline_free(spline_norm_srcs[ipop]); + } + free(norm_srcs_arr); + gsl_interp_accel_free(intacc_srcs); + for(ipop=0;ipopn_imap;ipop++) { + free(norm_imap_arr[ipop]); + gsl_spline_free(spline_norm_imap[ipop]); + } + free(norm_imap_arr); + gsl_interp_accel_free(intacc_imap); + for(ipop=0;ipopn_cstm;ipop++) { + free(norm_cstm_arr[ipop]); + gsl_spline_free(spline_norm_cstm[ipop]); + } + free(norm_cstm_arr); + gsl_interp_accel_free(intacc_cstm); +} diff --git a/src/.ipynb_checkpoints/fftlog-checkpoint.c b/src/.ipynb_checkpoints/fftlog-checkpoint.c new file mode 100644 index 0000000..5f93749 --- /dev/null +++ b/src/.ipynb_checkpoints/fftlog-checkpoint.c @@ -0,0 +1,157 @@ +#include +#ifndef M_PI + #define M_PI 3.14159265358979323846 +#endif +#include +#include +#include "fftlog.h" + +/* Computes the Gamma function using the Lanczos approximation */ +static double complex gamma_fftlog(double complex z) { + /* Lanczos coefficients for g = 7 */ + static double p[] = { + 0.99999999999980993227684700473478, + 676.520368121885098567009190444019, + -1259.13921672240287047156078755283, + 771.3234287776530788486528258894, + -176.61502916214059906584551354, + 12.507343278686904814458936853, + -0.13857109526572011689554707, + 9.984369578019570859563e-6, + 1.50563273514931155834e-7 + }; + + if(creal(z) < 0.5) + return M_PI / (sin(M_PI*z)*gamma_fftlog(1. - z)); + z -= 1; + double complex x = p[0]; + for(int n = 1; n < 9; n++) + x += p[n] / (z + (double)(n)); + double complex t = z + 7.5; + return sqrt(2*M_PI) * cpow(t, z+0.5) * cexp(-t) * x; +} + +static double complex polar (double r, double phi) { + return (r*cos(phi) +I*(r*sin(phi))); +} + +static double complex lngamma_fftlog(double complex z) { + return clog(gamma_fftlog(z)); +} + + +static void lngamma_4(double x, double y, double* lnr, double* arg) { + double complex w = lngamma_fftlog(x+y*I); + if(lnr) *lnr = creal(w); + if(arg) *arg = cimag(w); +} + +static double goodkr(int N, double mu, double q, double L, double kr) { + double xp = (mu+1+q)/2; + double xm = (mu+1-q)/2; + double y = M_PI*N/(2*L); + double lnr, argm, argp; + lngamma_4(xp, y, &lnr, &argp); + lngamma_4(xm, y, &lnr, &argm); + double arg = log(2/kr) * N/L + (argp + argm)/M_PI; + double iarg = round(arg); + if(arg != iarg) + kr *= exp((arg - iarg)*L/N); + return kr; +} + +void compute_u_coefficients(int N, double mu, double q, double L, double kcrc, double complex u[]) { + double y = M_PI/L; + double k0r0 = kcrc * exp(-L); + double t = -2*y*log(k0r0/2); + + if(q == 0) { + double x = (mu+1)/2; + double lnr, phi; + for(int m = 0; m <= N/2; m++) { + lngamma_4(x, m*y, &lnr, &phi); + u[m] = polar(1.0,m*t + 2*phi); + } + } + else { + double xp = (mu+1+q)/2; + double xm = (mu+1-q)/2; + double lnrp, phip, lnrm, phim; + for(int m = 0; m <= N/2; m++) { + lngamma_4(xp, m*y, &lnrp, &phip); + lngamma_4(xm, m*y, &lnrm, &phim); + u[m] = polar(exp(q*log(2) + lnrp - lnrm), m*t + phip - phim); + } + } + + for(int m = N/2+1; m < N; m++) + u[m] = conj(u[N-m]); + if((N % 2) == 0) + u[N/2] = (creal(u[N/2]) + I*0.0); +} + +void fht(int N, const double r[], const double complex a[], double k[], double complex b[], double mu, + double q, double kcrc, int noring, double complex* u) +{ + double L = log(r[N-1]/r[0]) * N/(N-1.); + double complex* ulocal = NULL; + if(u == NULL) { + if(noring) + kcrc = goodkr(N, mu, q, L, kcrc); + ulocal = malloc (sizeof(complex double)*N); + compute_u_coefficients(N, mu, q, L, kcrc, ulocal); + u = ulocal; + } + + /* Compute the convolution b = a*u using FFTs */ + fftw_plan forward_plan = fftw_plan_dft_1d(N, (fftw_complex*) a, (fftw_complex*) b, -1, FFTW_ESTIMATE); + fftw_plan reverse_plan = fftw_plan_dft_1d(N, (fftw_complex*) b, (fftw_complex*) b, +1, FFTW_ESTIMATE); + fftw_execute(forward_plan); + for(int m = 0; m < N; m++) + b[m] *= u[m] / (double)(N); // divide by N since FFTW doesn't normalize the inverse FFT + fftw_execute(reverse_plan); + fftw_destroy_plan(forward_plan); + fftw_destroy_plan(reverse_plan); + + /* Reverse b array */ + double complex tmp; + for(int n = 0; n < N/2; n++) { + tmp = b[n]; + b[n] = b[N-n-1]; + b[N-n-1] = tmp; + } + + /* Compute k's corresponding to input r's */ + double k0r0 = kcrc * exp(-L); + k[0] = k0r0/r[0]; + for(int n = 1; n < N; n++) + k[n] = k[0] * exp(n*L/N); + + free(ulocal); +} + +void fftlog_ComputeXiLM(int l, int m, int N, const double k[], const double pk[], double r[], double xi[]) { + double complex* a = malloc(sizeof(complex double)*N); + double complex* b = malloc(sizeof(complex double)*N); + + for(int i = 0; i < N; i++) + a[i] = pow(k[i], m - 0.5) * pk[i]; + fht(N, k, a, r, b, l + 0.5, 0, 1, 1, NULL); + for(int i = 0; i < N; i++) + xi[i] = creal(pow(2*M_PI*r[i], -1.5) * b[i]); + + free(a); + free(b); +} + +void pk2xi(int N, const double k[], const double pk[], double r[], double xi[]) { + fftlog_ComputeXiLM(0, 2, N, k, pk, r, xi); +} + +void xi2pk(int N, const double r[], const double xi[], double k[], double pk[]) { + static const double TwoPiCubed = 8*M_PI*M_PI*M_PI; + fftlog_ComputeXiLM(0, 2, N, r, xi, k, pk); + for(int j = 0; j < N; j++) + pk[j] *= TwoPiCubed; +} + diff --git a/src/.ipynb_checkpoints/fourier-checkpoint.c b/src/.ipynb_checkpoints/fourier-checkpoint.c new file mode 100644 index 0000000..aea1cef --- /dev/null +++ b/src/.ipynb_checkpoints/fourier-checkpoint.c @@ -0,0 +1,423 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +static void compute_sigma_dens(ParamCoLoRe *par) +{ + double mean_gauss=0; + // double s2_save=par->sigma2_gauss; + par->sigma2_gauss=0; + + //Compute Gaussian variance +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,mean_gauss) +#endif //_HAVE_OMP + { + int iz; + double sigma2_thr=0; + double mean_thr=0; + long ng_tot=par->n_grid*((long)(par->n_grid*par->n_grid)); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long iz0=iz*((long)(2*(par->n_grid/2+1)*par->n_grid)); + for(iy=0;iyn_grid;iy++) { + int ix; + long iy0=iy*2*(par->n_grid/2+1); + for(ix=0;ixn_grid;ix++) { + long index=ix+iy0+iz0; + sigma2_thr+=par->grid_dens[index]*par->grid_dens[index]; + mean_thr+=par->grid_dens[index]; + } + } + } //end omp for +#ifdef _HAVE_OMP +#pragma omp critical +#endif //_HAVE_OMP + { + mean_gauss+=mean_thr/ng_tot; + par->sigma2_gauss+=sigma2_thr/ng_tot; + } //end omp critical + } //end omp parallel + +#ifdef _HAVE_MPI + double sigma2_gathered=0,mean_gathered=0; + + MPI_Allreduce(&(par->sigma2_gauss),&sigma2_gathered,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); + MPI_Allreduce(&mean_gauss,&mean_gathered,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); + mean_gauss=mean_gathered; + par->sigma2_gauss=sigma2_gathered; +#endif //_HAVE_MPI + + par->sigma2_gauss-=mean_gauss*mean_gauss; + print_info(" =%.3lE, =%.3lE\n",mean_gauss,sqrt(par->sigma2_gauss)); + // if(par->need_onions) + // par->sigma2_gauss=s2_save; +} + +void fftw_wrap_c2r(int ng,dftw_complex *pin,flouble *pout) +{ +#ifdef _SPREC + fftwf_plan plan_ft; +#ifdef _HAVE_MPI + plan_ft=fftwf_mpi_plan_dft_c2r_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); +#else //_HAVE_MPI + plan_ft=fftwf_plan_dft_c2r_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); +#endif //_HAVE_MPI + fftwf_execute(plan_ft); + fftwf_destroy_plan(plan_ft); +#else //_SPREC + fftw_plan plan_ft; +#ifdef _HAVE_MPI + plan_ft=fftw_mpi_plan_dft_c2r_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); +#else //_HAVE_MPI + plan_ft=fftw_plan_dft_c2r_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); +#endif //_HAVE_MPI + fftw_execute(plan_ft); + fftw_destroy_plan(plan_ft); +#endif //_SPREC +} + +void fftw_wrap_r2c(int ng,flouble *pin,dftw_complex *pout) +{ +#ifdef _SPREC + fftwf_plan plan_ft; +#ifdef _HAVE_MPI + plan_ft=fftwf_mpi_plan_dft_r2c_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); +#else //_HAVE_MPI + plan_ft=fftwf_plan_dft_r2c_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); +#endif //_HAVE_MPI + fftwf_execute(plan_ft); + fftwf_destroy_plan(plan_ft); +#else //_SPREC + fftw_plan plan_ft; +#ifdef _HAVE_MPI + plan_ft=fftw_mpi_plan_dft_r2c_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); +#else //_HAVE_MPI + plan_ft=fftw_plan_dft_r2c_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); +#endif //_HAVE_MPI + fftw_execute(plan_ft); + fftw_destroy_plan(plan_ft); +#endif //_SPREC +} + +void init_fftw(ParamCoLoRe *par) +{ + //Set FFTW domain decomposition + par->nz_all =my_calloc(NNodes,sizeof(int)); + par->iz0_all=my_calloc(NNodes,sizeof(int)); + +#ifdef _HAVE_MPI + ptrdiff_t nz,iz0; + + //Initialize OpenMP fftw (if possible) +#ifdef _HAVE_OMP + if(MPIThreadsOK) { + int stat; +#ifdef _SPREC + stat=fftwf_init_threads(); +#else //_SPREC + stat=fftw_init_threads(); +#endif //_SPREC + if(!stat) { + fprintf(stderr,"Couldn't initialize FFTW threads \n"); + exit(1); + } + } +#endif //_HAVE_OMP + + //Initialize MPI fftw +#ifdef _SPREC + fftwf_mpi_init(); +#else //_SPREC + fftw_mpi_init(); +#endif //_SPREC + + //Plan OpenMP fftw (if possible) +#ifdef _HAVE_OMP + if(MPIThreadsOK) { +#ifdef _SPREC + fftwf_plan_with_nthreads(omp_get_max_threads()); +#else //_SPREC + fftw_plan_with_nthreads(omp_get_max_threads()); +#endif //_SPREC + } +#endif //_HAVE_OMP + + //Get MPI FFT bounds +#ifdef _SPREC + fftwf_mpi_local_size_3d(par->n_grid,par->n_grid,par->n_grid/2+1,MPI_COMM_WORLD,&nz,&iz0); +#else //_SPREC + fftw_mpi_local_size_3d(par->n_grid,par->n_grid,par->n_grid/2+1,MPI_COMM_WORLD,&nz,&iz0); +#endif //_SPREC + par->nz_here=nz; + par->iz0_here=iz0; + + MPI_Allreduce(&(par->nz_here),&(par->nz_max),1,MPI_INT,MPI_MAX,MPI_COMM_WORLD); + MPI_Allgather(&(par->nz_here),1,MPI_INT,par->nz_all,1,MPI_INT,MPI_COMM_WORLD); + MPI_Allgather(&(par->iz0_here),1,MPI_INT,par->iz0_all,1,MPI_INT,MPI_COMM_WORLD); + +#else //_HAVE_MPI + +#ifdef _HAVE_OMP + int stat; +#ifdef _SPREC + stat=fftwf_init_threads(); +#else //_SPREC + stat=fftw_init_threads(); +#endif //_SPREC + if(!stat) { + fprintf(stderr,"Couldn't initialize FFTW threads \n"); + exit(1); + } +#ifdef _SPREC + fftwf_plan_with_nthreads(omp_get_max_threads()); +#else //_SPREC + fftw_plan_with_nthreads(omp_get_max_threads()); +#endif //_SPREC +#endif //_HAVE_OMP + + par->nz_here=par->n_grid; + par->iz0_here=0; + par->nz_max=par->nz_here; + par->nz_all[0]=par->nz_here; + par->iz0_all[0]=par->iz0_here; +#endif //_HAVE_MPI +} + +void allocate_fftw(ParamCoLoRe *par) +{ + //Allocate all memory for grids + ptrdiff_t dsize=par->nz_max*((long)(par->n_grid*(par->n_grid/2+1))); + +#ifdef _SPREC + par->grid_dens_f=fftwf_alloc_complex(dsize); +#else //_SPREC + par->grid_dens_f=fftw_alloc_complex(dsize); +#endif //_SPREC + if(par->grid_dens_f==NULL) + report_error(1,"Ran out of memory\n"); + par->grid_dens=(flouble *)(par->grid_dens_f); + +#ifdef _SPREC + par->grid_npot_f=fftwf_alloc_complex(dsize+2*par->n_grid*(par->n_grid/2+1)); +#else //_SPREC + par->grid_npot_f= fftw_alloc_complex(dsize+2*par->n_grid*(par->n_grid/2+1)); +#endif //_SPREC + if(par->grid_npot_f==NULL) + report_error(1,"Ran out of memory\n"); + par->grid_npot=(flouble *)(par->grid_npot_f); + +#ifdef _HAVE_MPI + par->slice_left =&(par->grid_npot[2*dsize]); + par->slice_right=&(par->grid_npot[2*(dsize+par->n_grid*(par->n_grid/2+1))]); +#endif //_HAVE_MPI +} + +void end_fftw(ParamCoLoRe *par) +{ +#ifdef _SPREC + if(par->grid_dens_f!=NULL) + fftwf_free(par->grid_dens_f); + if(par->grid_npot_f!=NULL) + fftwf_free(par->grid_npot_f); +#else //_SPREC + if(par->grid_dens_f!=NULL) + fftw_free(par->grid_dens_f); + if(par->grid_npot_f!=NULL) + fftw_free(par->grid_npot_f); +#endif //_SPREC + +#ifdef _HAVE_MPI + +#ifdef _HAVE_OMP + if(MPIThreadsOK) { +#ifdef _SPREC + fftwf_cleanup_threads(); +#else //_SPREC + fftw_cleanup_threads(); +#endif //_SPREC + } +#endif //_HAVE_OMP + +#ifdef _SPREC + fftwf_mpi_cleanup(); +#else //_SPREC + fftw_mpi_cleanup(); +#endif //_SPREC + +#else //_HAVE_MPI + +#ifdef _HAVE_OMP +#ifdef _SPREC + fftwf_cleanup_threads(); +#else //_SPREC + fftw_cleanup_threads(); +#endif //_SPREC +#endif //_HAVE_OMP + +#endif //_HAVE_MPI +} + +static void create_grids_fourier(ParamCoLoRe *par) +{ + ////// + // Generates a random realization of the delta_k + // from the linear P_k. + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,IThread0) +#endif //_HAVE_OMP + { + int ii; + double dk=2*M_PI/par->l_box; + double idk3=1./(dk*dk*dk); +#ifdef _HAVE_OMP + int ithr=omp_get_thread_num(); +#else //_HAVE_OMP + int ithr=0; +#endif //_HAVE_OMP + unsigned int seed_thr=par->seed_rng+IThread0+ithr; + gsl_rng *rng_thr=init_rng(seed_thr); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iinz_here;ii++) { + int jj,ii_true; + double kz; + ii_true=par->iz0_here+ii; + if(2*ii_true<=par->n_grid) + kz=ii_true*dk; + else + kz=-(par->n_grid-ii_true)*dk; + for(jj=0;jjn_grid;jj++) { + int kk; + double ky; + if(2*jj<=par->n_grid) + ky=jj*dk; + else + ky=-(par->n_grid-jj)*dk; + for(kk=0;kk<=par->n_grid/2;kk++) { + double kx; + double k_mod2; + long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k + double delta_mod,delta_phase; + if(2*kk<=par->n_grid) + kx=kk*dk; + else + kx=-(par->n_grid-kk)*dk; //This should never happen + + k_mod2=kx*kx+ky*ky+kz*kz; + + if(k_mod2<=0) { + par->grid_dens_f[index]=0; + par->grid_npot_f[index]=0; + } + else { + double lgk=0.5*log10(k_mod2); + double sigma2=pk_linear0(par,lgk)*idk3; + rng_delta_gauss(&delta_mod,&delta_phase,rng_thr,sigma2); + par->grid_dens_f[index]=delta_mod*cexp(I*delta_phase); + par->grid_npot_f[index]=-par->prefac_lensing*par->grid_dens_f[index]/k_mod2; + if(par->do_smoothing) { + double sm=exp(-0.5*par->r2_smooth*k_mod2); + par->grid_dens_f[index]*=sm; + if(par->smooth_potential) + par->grid_npot_f[index]*=sm; + } + } + } + } + } + end_rng(rng_thr); + } +} + +void create_cartesian_fields(ParamCoLoRe *par) +{ + ////// + // Creates a realization of the gaussian density + // contrast field from the linear P_k + + long n_grid_tot=2*(par->n_grid/2+1)*((long)(par->n_grid*par->nz_here)); + print_info("*** Creating Gaussian density field \n"); + + print_info("Creating Fourier-space density and Newtonian potential \n"); + if(NodeThis==0) timer(0); + create_grids_fourier(par); + if(NodeThis==0) timer(2); + + print_info("Transforming density and Newtonian potential\n"); + if(NodeThis==0) timer(0); + fftw_wrap_c2r(par->n_grid,par->grid_dens_f,par->grid_dens); + fftw_wrap_c2r(par->n_grid,par->grid_npot_f,par->grid_npot); + if(NodeThis==0) timer(2); + + print_info("Normalizing density and Newtonian potential \n"); + if(NodeThis==0) timer(0); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(n_grid_tot,par) +#endif //_HAVE_OMP + { + long ii; + double norm=pow(sqrt(2*M_PI)/par->l_box,3); + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iigrid_dens[ii]*=norm; + par->grid_npot[ii]*=norm; + } + }//end omp parallel + if(NodeThis==0) timer(2); + + long slice_size=2*(par->n_grid/2+1)*par->n_grid; +#ifdef _HAVE_MPI + MPI_Status stat; + + //Pass rightmost slice to right node and receive left slice from left node + MPI_Sendrecv(&(par->grid_npot[(par->nz_here-1)*slice_size]),slice_size,FLOUBLE_MPI,NodeRight,1, + par->slice_left,slice_size,FLOUBLE_MPI,NodeLeft,1,MPI_COMM_WORLD,&stat); + //Pass leftmost slice to left node and receive right slice from right node + MPI_Sendrecv(par->grid_npot,slice_size,FLOUBLE_MPI,NodeLeft,2, + par->slice_right,slice_size,FLOUBLE_MPI,NodeRight,2,MPI_COMM_WORLD,&stat); +#else //_HAVE_MPI + par->slice_left=&(par->grid_npot[(par->n_grid-1)*slice_size]); + par->slice_right=par->grid_npot; +#endif //_HAVE_MPI + + compute_sigma_dens(par); + + print_info("\n"); + + //Output density field if necessary + if(par->output_density) + write_density_grid(par,"gaussian"); +} diff --git a/src/.ipynb_checkpoints/healpix_extra-checkpoint.c b/src/.ipynb_checkpoints/healpix_extra-checkpoint.c new file mode 100644 index 0000000..f17fd97 --- /dev/null +++ b/src/.ipynb_checkpoints/healpix_extra-checkpoint.c @@ -0,0 +1,885 @@ +#include "common.h" + +//HE_IO +void he_write_healpix_map(flouble **tmap,int nfields,long nside,char *fname,int isnest) +{ + fitsfile *fptr; + int ii,status=0; + char **ttype,**tform,**tunit; + float *map_dum=my_malloc(nside2npix(nside)*sizeof(float)); + + ttype=my_malloc(nfields*sizeof(char *)); + tform=my_malloc(nfields*sizeof(char *)); + tunit=my_malloc(nfields*sizeof(char *)); + for(ii=0;ii=0) + return (v1=0) ? v : v+v2; } + +long he_nside2npix(long nside) +{ + return 12*nside*nside; +} + +double he_pixel_area(int nside) +{ + return M_PI/(3*nside*nside); +} + +static const double twopi=6.283185307179586476925286766559005768394; +static const double twothird=2.0/3.0; +static const double inv_halfpi=0.6366197723675813430755350534900574; +long he_ang2pix(long nside,double cth,double phi) +{ + double ctha=fabs(cth); + double tt=fmodulo(phi,twopi)*inv_halfpi; /* in [0,4) */ + + if (ctha<=twothird) {/* Equatorial region */ + double temp1=nside*(0.5+tt); + double temp2=nside*cth*0.75; + int jp=(int)(temp1-temp2); /* index of ascending edge line */ + int jm=(int)(temp1+temp2); /* index of descending edge line */ + int ir=nside+1+jp-jm; /* ring number counted from cth=2/3 */ /* in {1,2n+1} */ + int kshift=1-(ir&1); /* kshift=1 if ir even, 0 otherwise */ + int ip=(jp+jm-nside+kshift+1)/2; /* in {0,4n-1} */ + ip=imodulo(ip,4*nside); + + return nside*(nside-1)*2 + (ir-1)*4*nside + ip; + } + else { /* North & South polar caps */ + double tp=tt-(int)(tt); + double tmp=nside*sqrt(3*(1-ctha)); + int jp=(int)(tp*tmp); /* increasing edge line index */ + int jm=(int)((1.0-tp)*tmp); /* decreasing edge line index */ + int ir=jp+jm+1; /* ring number counted from the closest pole */ + int ip=(int)(tt*ir); /* in {0,4*ir-1} */ + ip = imodulo(ip,4*ir); + + if (cth>0) + return 2*ir*(ir-1)+ip; + else + return 12*nside*nside-2*ir*(ir+1)+ip; + } +} + +int he_ring_num(long nside,double z) +{ + //Returns ring index for normalized height z + int iring; + + iring=(int)(nside*(2-1.5*z)+0.5); + if(z>0.66666666) { + iring=(int)(nside*sqrt(3*(1-z))+0.5); + if(iring==0) iring=1; + } + + if(z<-0.66666666) { + iring=(int)(nside*sqrt(3*(1+z))+0.5); + if(iring==0) iring=1; + iring=4*nside-iring; + } + + return iring; +} + +static void get_ring_limits(long nside,int iz,long *ip_lo,long *ip_hi) +{ + long ir; + long ipix1,ipix2; + long npix=12*nside*nside; + long ncap=2*nside*(nside-1); + + if((iz>=nside)&&(iz<=3*nside)) { //eqt + ir=iz-nside+1; + ipix1=ncap+4*nside*(ir-1); + ipix2=ipix1+4*nside-1; + } + else { + if(izM_PI)|| + (theta2<0)||(theta2>M_PI)) { + report_error(1,"wrong strip boundaries\n"); + } + + irmin=he_ring_num(nside,z_hi); + irmax=he_ring_num(nside,z_lo); + + //Count number of pixels in strip + int iz; + long npix_in_strip=0; + for(iz=irmin;iz<=irmax;iz++) { + long ipix1,ipix2; + get_ring_limits(nside,iz,&ipix1,&ipix2); + npix_in_strip+=ipix2-ipix1+1; + } + *npix_strip=npix_in_strip; + pixlist=my_malloc(npix_in_strip*sizeof(long)); + + //Count number of pixels in strip + long i_list=0; + for(iz=irmin;iz<=irmax;iz++) { + long ipix1,ipix2,ip; + get_ring_limits(nside,iz,&ipix1,&ipix2); + for(ip=ipix1;ip<=ipix2;ip++) { + pixlist[i_list]=ip; + i_list++; + } + } + + return pixlist; +} + +void he_ring2nest_inplace(flouble *map_in,long nside) +{ + long npix=12*nside*nside; + flouble *map_out=my_malloc(npix*sizeof(flouble)); + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(map_in,nside,npix,map_out) +#endif //_HAVE_OMP + { + long ip; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ip=0;ipnside_out) { + long ii; + long np_ratio=npix_in/npix_out; + double i_np_ratio=1./((double)np_ratio); + + for(ii=0;ii0) + return l+m*lmax-(m*(m-1))/2; + else + return l; +} + +static void sht_wrapper(int spin,int lmax,int nside,int ntrans,flouble **maps,fcomplex **alms,int alm2map) +{ + double time=0; + sharp_alm_info *alm_info; + sharp_geom_info *geom_info; + + sharp_make_triangular_alm_info(lmax,lmax,1,&alm_info); + sharp_make_weighted_healpix_geom_info(nside,1,NULL,&geom_info); + sharp_execute(alm2map,spin,alms,maps,geom_info,alm_info,ntrans,SHT_TYPE,&time,NULL); + sharp_destroy_geom_info(geom_info); + sharp_destroy_alm_info(alm_info); + // printf(" Took %lf s according to libsharp\n",time); +} + +void he_alm2map(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms) +{ + int nbatches,nodd,itrans; + nbatches=ntrans/HE_MAX_SHT; + nodd=ntrans%HE_MAX_SHT; + + for(itrans=0;itrans0) + sht_wrapper(0,lmax,nside,nodd,&(maps[nbatches*HE_MAX_SHT]),&(alms[nbatches*HE_MAX_SHT]),SHARP_ALM2MAP); +} + +void he_map2alm(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms) +{ + int nbatches,nodd,itrans; + nbatches=ntrans/HE_MAX_SHT; + nodd=ntrans%HE_MAX_SHT; + + for(itrans=0;itrans0) + sht_wrapper(0,lmax,nside,nodd,&(maps[nbatches*HE_MAX_SHT]),&(alms[nbatches*HE_MAX_SHT]),SHARP_MAP2ALM); +} + +void he_alm2cl(fcomplex **alms_1,fcomplex **alms_2, + int nmaps_1,int nmaps_2, + int pol_1,int pol_2, + flouble **cls,int lmax) +{ + int i1,index_cl; + + index_cl=0; + for(i1=0;i13*nside-1) + lmax_here=3*nside-1; + alms=my_malloc(he_nalms(lmax_here)*sizeof(fcomplex)); + + int ll; + for(ll=0;ll<=lmax_here;ll++) { + int mm; + flouble sigma=sqrt(0.5*cl[ll]); + double r1,r2; + rng_gauss(rng,&r1,&r2); + alms[he_indexlm(ll,0,lmax_here)]=(fcomplex)(M_SQRT2*sigma*r1); + + for(mm=1;mm<=ll;mm++) { + rng_gauss(rng,&r1,&r2); + alms[he_indexlm(ll,mm,lmax_here)]=(fcomplex)(sigma*(r1+I*r2)); + } + } + he_alm2map(nside,lmax_here,1,&map,&alms); + free(alms); + end_rng(rng); + + return map; +} + + +#ifdef _WITH_NEEDLET +//HE_NT +static double func_fx(double x,void *pars) +{ + return exp(-1./(1.-x*x)); +} + +static double func_psix(double x,gsl_integration_workspace *w,const gsl_function *f) +{ + double result,eresult; + gsl_integration_qag(f,-1,x,0,HE_NL_INTPREC,1000,GSL_INTEG_GAUSS61, + w,&result,&eresult); + + return result*HE_NORM_FT; +} + +static double func_phix(double x,double invB, + gsl_integration_workspace *w,const gsl_function *f) +{ + if(x<0) + report_error(1,"Something went wrong"); + else if(x<=invB) + return 1.; + else if(x<=1) + return func_psix(1-2.*(x-invB)/(1-invB),w,f); + else + return 0.; + + return -1.; +} + +void he_nt_end(HE_nt_param *par) +{ + int j; + + gsl_spline_free(par->b_spline); + gsl_interp_accel_free(par->b_intacc); + free(par->nside_arr); + free(par->lmax_arr); + for(j=0;jnj;j++) + free(par->b_arr[j]); + free(par->b_arr); + free(par); +} + +HE_nt_param *he_nt_init(flouble b_nt,int nside0) +{ + HE_nt_param *par=my_malloc(sizeof(HE_nt_param)); + par->b=b_nt; + par->inv_b=1./b_nt; + par->b_spline=gsl_spline_alloc(gsl_interp_cspline,HE_NBAND_NX); + par->b_intacc=gsl_interp_accel_alloc(); + par->nside0=nside0; + + int ii; + gsl_function F; + gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000); + double *xarr=my_malloc(HE_NBAND_NX*sizeof(double)); + double *barr=my_malloc(HE_NBAND_NX*sizeof(double)); + F.function=&func_fx; + F.params=NULL; + for(ii=0;iib_spline,xarr,barr,HE_NBAND_NX); + gsl_integration_workspace_free(w); + free(xarr); + free(barr); + + double lmax=3*nside0-1; + double djmax=log(lmax)/log(b_nt); + int jmax=(int)(djmax)+1; + par->nj=jmax+1; + par->nside_arr=my_malloc(par->nj*sizeof(int)); + par->lmax_arr=my_malloc(par->nj*sizeof(int)); + for(ii=0;iinj;ii++) { + double dlmx=pow(par->b,ii+1); + // double dlmn=pow(par->b,ii-1); + int lmx=(int)(dlmx)+1; + int ns=pow(2,(int)(log((double)lmx)/log(2.))+1); + par->nside_arr[ii]=MAX((MIN(ns,par->nside0)),HE_NT_NSIDE_MIN); + par->lmax_arr[ii]=3*par->nside_arr[ii]-1; + } + + par->b_arr=my_malloc(par->nj*sizeof(flouble *)); + for(ii=0;iinj;ii++) { + par->b_arr[ii]=my_calloc(3*nside0,sizeof(flouble)); + he_nt_get_window(par,ii,par->b_arr[ii]); + } + + int lmx0=(int)(par->b); + for(ii=0;ii<=lmx0;ii++) { + flouble b1=par->b_arr[0][ii]; + flouble b2=par->b_arr[1][ii]; + flouble h_here=b1*b1+b2*b2; + if(h_here<1) + par->b_arr[0][ii]=sqrt(1-b2*b2); + } + + return par; +} + +flouble ***he_alloc_needlet(HE_nt_param *par,int pol) +{ + int ii,nmaps; + flouble ***nt=my_malloc(par->nj*sizeof(flouble **)); + if(pol) + nmaps=3; + else + nmaps=1; + + for(ii=0;iinj;ii++) { + int imap; + long ns=par->nside_arr[ii]; + + nt[ii]=my_malloc(nmaps*sizeof(flouble *)); + for(imap=0;imapnj;ii++) { + int imap; + for(imap=0;imaplmax_arr[j]; + flouble bfac=1./pow(par->b,j); + + for(l=0;l<=lmx;l++) { + double x=(double)l*bfac; + if((xinv_b)||(x>par->b)) + b[l]=0; + else + b[l]=gsl_spline_eval(par->b_spline,x,par->b_intacc); + } +} + +fcomplex **he_needlet2map(HE_nt_param *par,flouble **map,flouble ***nt, + int return_alm,int pol,int qu_in,int qu_out) +{ + int j,nmaps; + fcomplex **alm,**alm_dum; + int l_max=3*par->nside0-1; + long n_alms=he_nalms(l_max); + + //Figure out spin + if(pol) + nmaps=3; + else + nmaps=1; + + //Allocate alms + alm=my_malloc(nmaps*sizeof(fcomplex *)); + alm_dum=my_malloc(nmaps*sizeof(fcomplex *)); + for(j=0;jnj;j++) { + int mm; + int lmx=par->lmax_arr[j]; + int imap; + + //Compute alm's for j-th needlet + sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],1,nt[j],alm_dum,SHARP_MAP2ALM); + if(pol) { + if(qu_in) + sht_wrapper(2,par->lmax_arr[j],par->nside_arr[j],1,&(nt[j][1]),&(alm_dum[1]),SHARP_MAP2ALM); + else + sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],2,&(nt[j][1]),&(alm_dum[1]),SHARP_MAP2ALM); + } + //Loop over spin components + for(imap=0;imapb_arr[j][ll]*alm_dum[imap][index]; + } + } + } + } + + //Transform total alm back to map + sht_wrapper(0,l_max,par->nside0,1,map,alm,SHARP_ALM2MAP); + if(pol) { + if(qu_out) + sht_wrapper(2,l_max,par->nside0,1,&(map[1]),&(alm[1]),SHARP_ALM2MAP); + else + sht_wrapper(0,l_max,par->nside0,2,&(map[1]),&(alm[1]),SHARP_ALM2MAP); + } + + if(!return_alm) { + for(j=0;jnside0-1; + long n_alms=he_nalms(l_max); + + //Figure out spin + if(pol) + nmaps=3; + else + nmaps=1; + + //Allocate alms + alm=my_malloc(nmaps*sizeof(fcomplex *)); + alm_dum=my_malloc(nmaps*sizeof(fcomplex *)); + for(j=0;jnside0,1,map,alm,SHARP_MAP2ALM); + if(qu_in) + sht_wrapper(2,l_max,par->nside0,1,&(map[1]),&(alm[1]),SHARP_MAP2ALM); + else + sht_wrapper(0,l_max,par->nside0,2,&(map[1]),&(alm[1]),SHARP_MAP2ALM); + + //Iterate over scales + for(j=0;jnj;j++) { + int mm,imap; + int lmx=par->lmax_arr[j]; + + //Loop over spin components + for(imap=0;imapb_arr[j][ll]*alm[imap][index0]; + } + } + } + + //SHT^-1 + sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],1,nt[j],alm_dum,SHARP_ALM2MAP); + if(qu_out) + sht_wrapper(2,par->lmax_arr[j],par->nside_arr[j],1,&(nt[j][1]),&(alm_dum[1]),SHARP_ALM2MAP); + else + sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],2,&(nt[j][1]),&(alm_dum[1]),SHARP_ALM2MAP); + } + + if(!return_alm) { + for(j=0;j. // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +static inline void cart2sph(double x,double y,double z,double *r,double *cth,double *phi) +{ + *r=sqrt(x*x+y*y+z*z); + + if((*r)==0) { + *cth=1; + *phi=0; + } + else { + double xn=x/(*r); + double yn=y/(*r); + + *cth=z/(*r); + *phi=atan2(yn,xn); + if((*phi)<0) + (*phi)+=2*M_PI; + } +} + +static double get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, + double x0,double y0,double z0,double rr) +{ + double v[3],u[3]; + double idx=par->n_grid/par->l_box; + long ngx=2*(par->n_grid/2+1); + long iz_hi=iz+1,iz_lo=iz-1,iz_0=iz; + long iy_hi=iy+1,iy_lo=iy-1,iy_0=iy; + long ix_hi=ix+1,ix_lo=ix-1,ix_0=ix; + if(iy==0) iy_lo=par->n_grid-1; + if(iy==par->n_grid-1) iy_hi=0; + if(ix==0) ix_lo=par->n_grid-1; + if(ix==par->n_grid-1) ix_hi=0; + iz_0*=ngx*par->n_grid; + iz_lo*=ngx*par->n_grid; + iz_hi*=ngx*par->n_grid; + iy_0*=ngx; + iy_lo*=ngx; + iy_hi*=ngx; + + u[0]=x0/rr; u[1]=y0/rr; u[2]=z0/rr; + v[0]=par->grid_npot[ix_hi+iy_0+iz_0]-par->grid_npot[ix_lo+iy_0+iz_0]; + v[1]=par->grid_npot[ix_0+iy_hi+iz_0]-par->grid_npot[ix_0+iy_lo+iz_0]; + if(iz==0) + v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->slice_left[ix_0+iy_0]; + else if(iz==par->nz_here-1) + v[2]=par->slice_right[ix_0+iy_0]-par->grid_npot[ix_0+iy_0+iz_lo]; + else + v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->grid_npot[ix_0+iy_0+iz_lo]; + + return 0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); +} + +static int get_r_index_imap(HealpixShells *sh,double r,int ir_start) +{ + int gotit=0; + int ir0; + if(ir_start<0) + ir0=0; + else if(ir_start>=sh->nr) + ir0=sh->nr-1; + else + ir0=ir_start; + + while(!gotit) { + if((ir0==-1) || (ir0==sh->nr)) + gotit=1; + else { + if(rr0[ir0]) + ir0--; + else { + if(r>=sh->rf[ir0]) + ir0++; + else + gotit=1; + } + } + } + + return ir0; +} + +static void imap_preproc(HealpixShells *imap) +{ + int ir; + flouble *r0_i=my_malloc(imap->nr*sizeof(flouble)); + flouble *rf_i=my_malloc(imap->nr*sizeof(flouble)); + + memcpy(r0_i,imap->r0,imap->nr*sizeof(flouble)); + memcpy(rf_i,imap->rf,imap->nr*sizeof(flouble)); + + int *i_sorted=ind_sort(imap->nr,imap->r0); + for(ir=0;irnr;ir++) { + imap->r0[ir]=r0_i[i_sorted[ir]]; + imap->rf[ir]=rf_i[i_sorted[ir]]; + } + free(r0_i); + free(rf_i); + free(i_sorted); + + //All nodes must store the entire sky + imap->num_pix=he_nside2npix(imap->nside); + free(imap->listpix); + imap->listpix=my_malloc(sizeof(long)); //No need to initialize this really + free(imap->pos); + imap->pos=my_malloc(sizeof(double)); //No need to initialize thi either + free(imap->data); + imap->data=my_calloc(imap->nr*imap->num_pix,sizeof(flouble)); + free(imap->nadd); + imap->nadd=my_calloc(imap->nr*imap->num_pix,sizeof(flouble)); +} + +static void imap_set_cartesian_single(ParamCoLoRe *par,int ipop) +{ + if(NodeThis==0) timer(0); + HealpixShells *imap=par->imap[ipop]; + imap_preproc(imap); + + print_info(" %d-th intensity mapping species\n",ipop); + if(NodeThis==0) timer(0); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,imap,ipop) +#endif //_HAVE_OMP + { + long iz; + double dx=par->l_box/par->n_grid; + int ngx=2*(par->n_grid/2+1); + double factor_vel=-par->fgrowth_0/(1.5*par->hubble_0*par->OmegaM); + + double pixel_size=sqrt(4*M_PI/he_nside2npix(imap->nside)); + double rmin_here=imap->r0[0]-20.; + double rmax_here=imap->rf[imap->nr-1]+20.; + int nsub_lo,nsub_hi; + int *nsub_array=my_malloc(imap->nr*sizeof(int)); + for(iz=0;iznr;iz++) { + double r0=imap->r0[iz]; + double rf=imap->rf[iz]; + double vol=(rf*rf*rf-r0*r0*r0)*pixel_size*pixel_size/3; + double sct=r0*pixel_size; //Scale associated to pixel size + double scr=rf-r0; //Scale associated to the width of the shell + double scv=pow(vol,0.333333); //Scale associated to the overall volume + double sc0=fmin(scv,fmin(sct,scr)); //We now pick the minimum of the previous 3 + + nsub_array[iz]=(int)(dx/sc0+0.5)+1; + //#ifdef _HAVE_OMP + // if(omp_get_thread_num()==0) + //#endif //_HAVE_OMP + // print_info("%ld %lf %lf %d %lf %lf\n",iz,r0,rf,nsub_array[iz],rmin_here,rmax_here); + } + nsub_lo=nsub_array[0]; + nsub_hi=nsub_array[imap->nr-1]; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + int irad=0; + long indexz=iz*((long)(ngx*par->n_grid)); + double z0=(iz+par->iz0_here)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + double y0=iy*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + double x0=ix*dx-par->pos_obs[0]; + long index=ix+indexy+indexz; + double r0=sqrt(x0*x0+y0*y0+z0*z0); + double tmean=get_bg(par,r0,BG_TZ_IMAP,ipop); + if((r0<=rmax_here) && (r0>=rmin_here)) { + if(tmean>0) { + int nsub_here,izz; + double dx_sub; + double bias=get_bg(par,r0,BG_BZ_IMAP,ipop); + double dnorm=get_bg(par,r0,BG_NORM_IMAP,ipop); + double rvel=factor_vel*get_rvel(par,ix,iy,iz,x0,y0,z0,r0); + double dr_rsd=rvel*get_bg(par,r0,BG_V1,0)*get_bg(par,r0,BG_IH,0); + double temp=tmean*bias_model(par->grid_dens[index],bias)*dnorm; + irad=get_r_index_imap(imap,r0,irad); + if(irad<0) + nsub_here=nsub_lo; + else if(irad>=imap->nr) + nsub_here=nsub_hi; + else + nsub_here=nsub_array[irad]; + dx_sub=dx/nsub_here; + for(izz=0;izz=0) && (iradnr)) { + long irad_t=irad*imap->num_pix; + long pix_id=he_ang2pix(imap->nside,cth,phi); +#ifdef _HAVE_OMP +#pragma omp atomic +#endif //_HAVE_OMP + imap->data[irad_t+pix_id]+=temp; +#ifdef _HAVE_OMP +#pragma omp atomic +#endif //_HAVE_OMP + imap->nadd[irad_t+pix_id]++; + } + } + } + } + } + } + } + } + } //end omp for + + free(nsub_array); + } //end omp parallel + if(NodeThis==0) timer(2); +} + +void imap_set_cartesian(ParamCoLoRe *par) +{ + int ipop; + + //First, compute lensing Hessian + print_info("*** Filling up intensity maps\n"); + for(ipop=0;ipopn_imap;ipop++) + imap_set_cartesian_single(par,ipop); + print_info("\n"); +} + +static void imap_distribute_single(ParamCoLoRe *par,int ipop) +{ + return; +} + +void imap_distribute(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_imap;ipop++) + imap_distribute_single(par,ipop); +} + +static void imap_get_local_properties_single(ParamCoLoRe *par,int ipop) +{ + return; +} + +void imap_get_local_properties(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_imap;ipop++) + imap_get_local_properties_single(par,ipop); +} + +static void imap_beams_preproc_single(ParamCoLoRe *par,int ipop) +{ + return; +} + +void imap_beams_preproc(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_imap;ipop++) + imap_beams_preproc_single(par,ipop); +} + +static void imap_get_beam_properties_single(ParamCoLoRe *par,int ipop) +{ + return; +} + +void imap_get_beam_properties(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_imap;ipop++) + imap_get_beam_properties_single(par,ipop); +} + +static void imap_beams_postproc_single(ParamCoLoRe *par,int ipop) +{ + return; +} + +void imap_beams_postproc(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_imap;ipop++) + imap_beams_postproc_single(par,ipop); +} diff --git a/src/.ipynb_checkpoints/io-checkpoint.c b/src/.ipynb_checkpoints/io-checkpoint.c new file mode 100644 index 0000000..344ce3e --- /dev/null +++ b/src/.ipynb_checkpoints/io-checkpoint.c @@ -0,0 +1,1374 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +static ParamCoLoRe *param_colore_new(void) +{ + int ii; + ParamCoLoRe *par=my_malloc(sizeof(ParamCoLoRe)); + +#ifdef _DEBUG + par->f_dbg=NULL; +#endif //_DEBUG + + //Cosmological parameters + // Background + par->OmegaM=0.3; + par->OmegaL=0.7; + par->OmegaB=0.05; + par->hhub=0.7; + par->weos=-1.; + par->n_scal=0.96; + par->sig8=0.83; + par->fgrowth_0=-1; + par->hubble_0=-1; + par->prefac_lensing=-1; + par->z_max=1.5; + par->z_min=0.5; + par->r_max=-1; + par->r_min=-1; + par->glob_idr=-1; + // Powerspectra + sprintf(par->fnamePk,"default"); + par->numk=0; + par->logkmax=1; + par->logkmin=-3; + par->idlogk=100; + par->logkarr=NULL; + par->pkarr=NULL; + + //Density parameters + // Density methods + par->output_density=0; + par->r2_smooth=2.0; + par->do_smoothing=1; + par->smooth_potential=0; + par->dens_type=DENS_TYPE_LGNR; + par->lpt_interp_type=INTERP_CIC; + par->lpt_buffer_fraction=0.2; + par->output_lpt=0; + par->seed_rng=1234; + par->z0_norm=0; + par->zf_norm=0; + // Box parameters + par->n_grid=512; + par->l_box=-1; + par->nz_here=512; + par->iz0_here=0; + par->nz_max=512; + par->nz_all=NULL; + par->iz0_all=NULL; + // Density grids + par->grid_dens_f=NULL; + par->grid_dens=NULL; + par->grid_npot_f=NULL; + par->grid_npot=NULL; + par->sigma2_gauss=0; + + //IO parameters + sprintf(par->prefixOut,"default"); + par->output_format=0; + par->do_pred=0; + par->just_do_pred=0; + par->do_pred=1; + + //Tracers + par->do_srcs=0; + par->do_skewers=0; + par->do_srcs_lensing=0; + par->do_cstm=0; + par->do_isw=0; + par->do_imap=0; + par->do_kappa=0; + par->do_lensing=0; + par->lensing_spacing_type=SPACING_R; + par->do_isw=0; + par->n_srcs=-1; + par->n_cstm=-1; + par->n_imap=-1; + par->n_kappa=-1; + par->n_lensing=-1; + par->n_isw=-1; + par->nside_kappa=-1; + par->nside_lensing=-1; + par->nside_isw=-1; + par->write_lensing=0; + for(ii=0;iifnameBzCstm[ii],"default"); + sprintf(par->fnameKzCstm[ii],"default"); + par->cstm_bz_arr[ii]=NULL; + par->cstm_kz_arr[ii]=NULL; + par->cstm_norm_arr[ii]=NULL; + sprintf(par->fnameBzSrcs[ii],"default"); + sprintf(par->fnameNzSrcs[ii],"default"); + par->srcs_bz_arr[ii]=NULL; + par->srcs_nz_arr[ii]=NULL; + par->srcs_norm_arr[ii]=NULL; + par->lensing_srcs[ii]=0; + par->skw_srcs[ii]=0; + par->skw_gauss[ii]=0; + sprintf(par->fnameBzImap[ii],"default"); + sprintf(par->fnameTzImap[ii],"default"); + sprintf(par->fnameNuImap[ii],"default"); + par->imap_bz_arr[ii]=NULL; + par->imap_tz_arr[ii]=NULL; + par->imap_norm_arr[ii]=NULL; + par->nside_imap[ii]=-1; + par->nu0_imap[ii]=-1; + par->nside_cstm[ii]=-1; + } + for(ii=0;iiz_kappa_out[ii]=-1; + par->z_isw_out[ii]=-1; + } + par->cats_c=NULL; + par->nsources_c_this=NULL; + par->cats=NULL; + par->nsources_this=NULL; + par->imap=NULL; + par->kmap=NULL; + par->smap=NULL; + par->pd_map=NULL; + + //Beam distribution + par->nside_base=-1; + par->npix_base=-1; + par->need_beaming=0; + + return par; +} + +static void conf_read_string(config_t *conf,char *secname,char *varname,char *out) +{ + int stat; + char fullpath[256]; + const char *str; + sprintf(fullpath,"%s.%s",secname,varname); + stat=config_lookup_string(conf,fullpath,&str); + if(stat==CONFIG_FALSE) + report_error(1,"Couldn't read variable %s\n",fullpath); + sprintf(out,"%s",str); +} + +static void conf_read_double(config_t *conf,char *secname,char *varname,double *out) +{ + int stat; + char fullpath[256]; + sprintf(fullpath,"%s.%s",secname,varname); + stat=config_lookup_float(conf,fullpath,out); + if(stat==CONFIG_FALSE) + report_error(1,"Couldn't read variable %s\n",fullpath); +} + +static void conf_read_double_array(config_t *conf,char *secname,char *varname, + double *out,int *nel,int nmax) +{ + int n_elem,index; + config_setting_t *arr; + char fullpath[256]; + sprintf(fullpath,"%s.%s",secname,varname); + arr=config_lookup(conf,fullpath); + if(arr==NULL) + report_error(1,"Couldn't read variable %s\n",fullpath); + n_elem=config_setting_length(arr); + if(n_elem==0) + report_error(1,"Couldn't read variable %s\n",fullpath); + if(n_elem>nmax) + report_error(1,"Too many elements in %s (%d > %d)\n",fullpath,n_elem,nmax); + + *nel=n_elem; + for(index=0;indexnside_base=choose_nside_base(); + if(par->nside_base>NSIDE_MAX_HPX) + report_error(1,"Can't go beyond nside=%d\n",NSIDE_MAX_HPX); + par->npix_base=he_nside2npix(par->nside_base); + + config_init(conf); + + config_set_options(conf,CONFIG_OPTION_AUTOCONVERT); + stat=config_read_file(conf,fname); + if(stat==CONFIG_FALSE) + error_open_file(fname); + + conf_read_string(conf,"global","prefix_out",par->prefixOut); + conf_read_string(conf,"global","pk_filename",par->fnamePk); + conf_read_double(conf,"global","z_min",&(par->z_min)); + conf_read_double(conf,"global","z_max",&(par->z_max)); + conf_read_bool(conf,"global","output_density",&(par->output_density)); + conf_read_int(conf,"global","seed",&i_dum); + conf_read_bool(conf,"global","write_pred",&(par->do_pred)); + if (par->do_pred) { + conf_read_bool(conf,"global","just_write_pred",&(par->just_do_pred)); + conf_read_double(conf,"global","pred_dz",&(par->pred_dz)); + } + conf_read_double(conf,"field_par","r_smooth",&(par->r2_smooth)); + conf_read_bool(conf,"field_par","smooth_potential",&(par->smooth_potential)); + conf_read_int(conf,"field_par","n_grid",&(par->n_grid)); + conf_read_int(conf,"field_par","dens_type",&(par->dens_type)); + conf_read_double(conf,"field_par","lpt_buffer_fraction",&(par->lpt_buffer_fraction)); + conf_read_int(conf,"field_par","lpt_interp_type",&(par->lpt_interp_type)); + conf_read_int(conf,"field_par","output_lpt",&(par->output_lpt)); + + par->seed_rng=i_dum; + conf_read_string(conf,"global","output_format",c_dum); + if(!strcmp(c_dum,"HDF5")) { +#ifdef _HAVE_HDF5 + par->output_format=2; +#else //_HAVE_HDF5 + report_error(1,"HDF5 format not supported\n"); +#endif //_HAVE_HDF5 + } + else if(!strcmp(c_dum,"FITS")) { +#ifdef _HAVE_FITS + par->output_format=1; +#else //_HAVE_FITS + report_error(1,"FITS format not supported\n"); +#endif //_HAVE_FITS + } + else if(!strcmp(c_dum,"ASCII")) + par->output_format=0; + else + report_error(1,"Unrecognized format %s\n",c_dum); + + conf_read_double(conf,"cosmo_par","omega_M",&(par->OmegaM)); + conf_read_double(conf,"cosmo_par","omega_L",&(par->OmegaL)); + conf_read_double(conf,"cosmo_par","omega_B",&(par->OmegaB)); + conf_read_double(conf,"cosmo_par","h",&(par->hhub)); + conf_read_double(conf,"cosmo_par","w",&(par->weos)); + conf_read_double(conf,"cosmo_par","ns",&(par->n_scal)); + conf_read_double(conf,"cosmo_par","sigma_8",&(par->sig8)); + + //Get number of galaxy populations + par->n_srcs=0; + found=1; + while(found) { + sprintf(c_dum,"srcs%d",par->n_srcs+1); + cset=config_lookup(conf,c_dum); + if(cset==NULL) + found=0; + else + par->n_srcs++; + } + if(par->n_srcs>NPOP_MAX) + report_error(1,"You're asking for too many populations %d! Enlarge NPOP_MAX\n",par->n_srcs); + for(ii=0;iin_srcs;ii++) { + sprintf(c_dum,"srcs%d",ii+1); + conf_read_string(conf,c_dum,"nz_filename",par->fnameNzSrcs[ii]); + conf_read_string(conf,c_dum,"bias_filename",par->fnameBzSrcs[ii]); + conf_read_bool(conf,c_dum,"include_lensing",&(par->lensing_srcs[ii])); + if(par->lensing_srcs[ii]) + par->do_srcs_lensing=1; + conf_read_bool(conf,c_dum,"store_skewers",&(par->skw_srcs[ii])); + if(par->skw_srcs[ii]) { + par->do_skewers=1; + sprintf(c_dum2,"%s.gaussian_skewers",c_dum); + config_lookup_bool(conf,c_dum2,&(par->skw_gauss[ii])); + } + } + if(par->n_srcs>0) + par->do_srcs=1; + + //Get number of custom maps + par->n_cstm=0; + found=1; + while(found) { + sprintf(c_dum, "custom%d", par->n_cstm+1); + cset=config_lookup(conf,c_dum); + if(cset==NULL) + found=0; + else + par->n_cstm++; + } + if(par->n_cstm>NPOP_MAX) + report_error(1,"You're asking for too many populations %d! Enlarge NPOP_MAX\n",par->n_cstm); + for(ii=0;iin_cstm;ii++) { + sprintf(c_dum,"custom%d",ii+1); + conf_read_string(conf,c_dum,"kz_filename",par->fnameKzCstm[ii]); + conf_read_string(conf,c_dum,"bias_filename",par->fnameBzCstm[ii]); + conf_read_int(conf,c_dum,"nside",&(par->nside_cstm[ii])); + } + if(par->n_cstm>0) + par->do_cstm=1; + + //Get number of intensity mapping species + par->n_imap=0; + found=1; + while(found) { + sprintf(c_dum,"imap%d",par->n_imap+1); + cset=config_lookup(conf,c_dum); + if(cset==NULL) + found=0; + else + par->n_imap++; + } + if(par->n_imap>NPOP_MAX) + report_error(1,"You're asking for too many populations %d! Enlarge NPOP_MAX\n",par->n_imap); + for(ii=0;iin_imap;ii++) { + sprintf(c_dum,"imap%d",ii+1); + conf_read_string(conf,c_dum,"tbak_filename",par->fnameTzImap[ii]); + conf_read_string(conf,c_dum,"bias_filename",par->fnameBzImap[ii]); + conf_read_string(conf,c_dum,"freq_list",par->fnameNuImap[ii]); + conf_read_double(conf,c_dum,"freq_rest",&(par->nu0_imap[ii])); + conf_read_int(conf,c_dum,"nside",&(par->nside_imap[ii])); + } + if(par->n_imap>0) + par->do_imap=1; + + //Kappa maps + cset=config_lookup(conf,"kappa"); + if(cset!=NULL) { + par->do_kappa=1; + conf_read_double_array(conf,"kappa","z_out",par->z_kappa_out,&(par->n_kappa),NPLANES_MAX); + conf_read_int(conf,"kappa","nside",&(par->nside_kappa)); + } + +#ifdef _USE_FAST_LENSING + //Lensing maps + cset=config_lookup(conf,"lensing"); + if(cset!=NULL) { + par->do_lensing=1; + par->do_srcs_lensing=1; + conf_read_int(conf,"lensing","n_lensing",&(par->n_lensing)); + char spacing_string[256]="default"; + conf_read_string(conf,"lensing","spacing_type",spacing_string); + if(!strcmp(spacing_string,"r")) + par->lensing_spacing_type=SPACING_R; + else if(!strcmp(spacing_string,"log(1+z)")) + par->lensing_spacing_type=SPACING_LOGZ; + else + report_error(1,"Unknown spacing type %s\n",spacing_string); + conf_read_int(conf,"lensing","nside",&(par->nside_lensing)); + conf_read_bool(conf,"lensing","write",&(par->write_lensing)); + } + // Check lensing exists if requested with catalog + if(par->do_srcs_lensing && !(par->do_lensing)) + report_error(1,"Include a \"lensing\" section if you want lensing with your galaxies\n"); +#endif //_USE_FAST_LENSING + + cset=config_lookup(conf,"isw"); + if(cset!=NULL) { + par->do_isw=1; + conf_read_double_array(conf,"isw","z_out",par->z_isw_out,&(par->n_isw),NPLANES_MAX); + conf_read_int(conf,"isw","nside",&(par->nside_isw)); + } + +#ifdef _DEBUG + sprintf(c_dum,"%s_node%d.dbg",par->prefixOut,NodeThis); + par->f_dbg=fopen(c_dum,"w"); + if(par->f_dbg==NULL) error_open_file(c_dum); + if(NodeThis==0) { + sprintf(c_dum,"%s_params.cfg",par->prefixOut); + config_write_file(conf,c_dum); + } +#endif //_DEBUG + +#ifdef _ADD_EXTRA_KAPPA + if(par->do_kappa) { + par->need_extra_kappa=my_calloc(par->n_kappa,sizeof(int)); + par->fl_mean_extra_kappa=my_malloc(par->n_kappa*sizeof(flouble *)); + par->cl_extra_kappa=my_malloc(par->n_kappa*sizeof(flouble *)); + } + if(par->do_isw) { + par->need_extra_isw=my_calloc(par->n_isw,sizeof(int)); + par->fl_mean_extra_isw=my_malloc(par->n_isw*sizeof(flouble *)); + par->cl_extra_isw=my_malloc(par->n_isw*sizeof(flouble *)); + } +#endif //_ADD_EXTRA_KAPPA + + config_destroy(conf); + + if(par->r2_smooth>0) { + par->r2_smooth=pow(par->r2_smooth,2); + par->do_smoothing=1; + } + else + par->do_smoothing=0; + + par->need_beaming=(par->do_srcs_lensing+par->do_kappa+par->do_lensing+ + par->do_isw+par->do_skewers+par->do_cstm); + init_fftw(par); + + cosmo_set(par); + + get_max_memory(par,test_memory+par->just_do_pred); + + print_info("\n"); + + double dk=2*M_PI/par->l_box; + print_info("Run parameters: \n"); + print_info(" %.3lf < z < %.3lf\n",par->z_min,par->z_max); + print_info(" %.3lf < r/(Mpc/h) < %.3lf\n",par->r_min,par->r_max); + print_info(" L_box = %.3lf Mpc/h, N_grid = %d \n",(double)(par->l_box),par->n_grid); + print_info(" Scales resolved: %.3lE < k < %.3lE h/Mpc\n",dk,0.5*(par->n_grid-1)*dk); + print_info(" Fourier-space resolution: dk = %.3lE h/Mpc\n",dk); + print_info(" Real-space resolution: dx = %.3lE Mpc/h\n",par->l_box/par->n_grid); + if(par->do_smoothing) + print_info(" Density field pre-smoothed on scales: x_s = %.3lE Mpc/h\n",sqrt(par->r2_smooth)); + else + print_info(" No extra smoothing\n"); + if(par->do_srcs) + print_info(" %d galaxy populations\n",par->n_srcs); + if(par->do_skewers) + print_info(" Some populations will include LoS skewers\n"); + if(par->do_imap) + print_info(" %d intensity mapping species\n",par->n_imap); + if(par->do_cstm) + print_info(" %d custom maps\n",par->n_cstm); + if(par->do_kappa) + print_info(" %d lensing source planes\n",par->n_kappa); + if(par->do_lensing) + print_info(" %d lensing source planes\n",par->n_lensing); + if(par->do_isw) + print_info(" %d ISW source planes\n",par->n_isw); + if(par->do_srcs_lensing) + print_info(" Will include lensing in source catalog\n"); + if(!par->need_beaming) + print_info(" Will NOT need to all-to-all communicate fields\n"); + print_info("\n"); + + if(test_memory) { +#ifdef _DEBUG + fclose(par->f_dbg); +#endif //_DEBUG + free(par); + return NULL; + } + + if(par->just_do_pred) + return par; + + allocate_fftw(par); + + if(par->do_srcs) { + par->cats_c=my_malloc(par->n_srcs*sizeof(CatalogCartesian *)); + par->cats=my_malloc(par->n_srcs*sizeof(CatalogCartesian *)); + par->nsources_c_this=my_calloc(par->n_srcs,sizeof(long)); + par->nsources_this=my_calloc(par->n_srcs,sizeof(long)); + for(ii=0;iin_srcs;ii++) { + par->cats_c[ii]=NULL; + par->cats[ii]=NULL; + } + } + + if(par->do_imap) { + par->imap=my_malloc(par->n_imap*sizeof(HealpixShells *)); + for(ii=0;iin_imap;ii++) { + FILE *fnu=fopen(par->fnameNuImap[ii],"r"); + if(fnu==NULL) error_open_file(par->fnameNuImap[ii]); + par->imap[ii]=hp_shell_alloc(1,par->nside_imap[ii],par->nside_base,linecount(fnu)); + fclose(fnu); + } + } + + if(par->do_cstm) { + par->cstm=my_malloc(par->n_cstm*sizeof(HealpixShells *)); + for(ii=0;iin_cstm;ii++) + par->cstm[ii]=hp_shell_alloc(1,par->nside_cstm[ii],par->nside_base,1); + } + + if(par->do_kappa) + par->kmap=hp_shell_alloc(1,par->nside_kappa,par->nside_base,par->n_kappa); + +#ifdef _USE_FAST_LENSING + if(par->do_lensing) { + flouble *r_arr=compute_lensing_spacing(par); + par->smap = hp_shell_adaptive_alloc(5, par->nside_lensing, par->nside_base, + par->n_lensing, r_arr, par->l_box/par->n_grid, + 1.); + free(r_arr); + } +#endif //_USE_FAST_LENSING + + if(par->do_isw) + par->pd_map=hp_shell_alloc(1,par->nside_isw,par->nside_base,par->n_isw); + + compute_tracer_cosmo(par); + + free(conf); + + return par; +} + +void write_density_grid(ParamCoLoRe *par,char *prefix_dens) +{ + FILE *fo; + char fname[256]; + int iz; + int ngx=2*(par->n_grid/2+1); + int size_flouble=sizeof(flouble); + double lb=par->l_box; + + if(NodeThis==0) timer(0); + print_info("*** Writing density field (native format)\n"); + sprintf(fname,"%s_dens_%s_%d.dat",par->prefixOut,prefix_dens,NodeThis); + fo=fopen(fname,"wb"); + if(fo==NULL) error_open_file(fname); + my_fwrite(&NNodes,sizeof(int),1,fo); + my_fwrite(&size_flouble,sizeof(int),1,fo); + my_fwrite(&lb,sizeof(double),1,fo); + my_fwrite(&(par->n_grid),sizeof(int),1,fo); + my_fwrite(&(par->nz_here),sizeof(int),1,fo); + my_fwrite(&(par->iz0_here),sizeof(int),1,fo); + for(iz=0;iznz_here;iz++) { + int iy; + for(iy=0;iyn_grid;iy++) { + long index0=ngx*((long)(iy+iz*par->n_grid)); + my_fwrite(&(par->grid_dens[index0]),sizeof(flouble),par->n_grid,fo); + } + } + fclose(fo); + if(NodeThis==0) timer(2); + print_info("\n"); +} + +typedef struct { + int np[6]; + double mass[6]; + double time; + double redshift; + int flag_sfr; + int flag_feedback; + unsigned int np_total[6]; + int flag_cooling; + int num_files; + double boxsize; + double omega0; + double omega_lambda; + double hubble_param; + int flag_stellarage; + int flag_metals; + unsigned int np_total_highword[6]; + int flag_entropy_instead_u; + int flag_gadgetformat; + char fill[56]; +} GadgetHeader; + +void write_lpt(ParamCoLoRe *par,unsigned long long npart,flouble *x,flouble *y,flouble *z) +{ + GadgetHeader header; + FILE *fo; + char fname[256]; + unsigned long long ipart,np_total; + unsigned long long np_total_expected=par->n_grid*((long)(par->n_grid*par->n_grid)); + + sprintf(fname,"%s_lpt_out.%d",par->prefixOut,NodeThis); + fo=fopen(fname,"w"); + if(fo==NULL) error_open_file(fname); + +#ifdef _HAVE_MPI + unsigned long long np_send=npart; + MPI_Reduce(&np_send,&np_total,1,MPI_UNSIGNED_LONG_LONG,MPI_SUM,0,MPI_COMM_WORLD); + MPI_Bcast(&np_total,1,MPI_UNSIGNED_LONG_LONG,0,MPI_COMM_WORLD); +#else //_HAVE_MPI + np_total=npart; +#endif //_HAVE_MPI + + if(np_total!=np_total_expected) + report_error(1,"Only %llu particles found, but there should be %ull\n",np_total,np_total_expected); + + double m=27.7455*par->OmegaM*pow(par->l_box,3.)/np_total; + memset(&header,0,sizeof(GadgetHeader)); + + header.np[1]=npart; + header.mass[1]=m; + header.time=1.; + header.redshift=0.; + header.np_total[1]=(unsigned int)np_total; + header.np_total_highword[1]=(unsigned int)(np_total >> 32); + header.num_files=NNodes; + header.boxsize=par->l_box; + header.omega0=par->OmegaM; + header.omega_lambda=par->OmegaL; + header.hubble_param=par->hhub; + header.flag_gadgetformat=1; + + int blklen=sizeof(GadgetHeader); + my_fwrite(&blklen,sizeof(blklen),1,fo); + my_fwrite(&header,sizeof(GadgetHeader),1,fo); + my_fwrite(&blklen,sizeof(blklen),1,fo); + + float x0[3]; + // position + blklen=npart*sizeof(float)*3; + my_fwrite(&blklen,sizeof(blklen),1,fo); + for(ipart=0;ipartiz0_here*((long)(par->n_grid*par->n_grid))); + for(ipart=0;ipartn_imap;ipop++) { + int ir; + HealpixShells *imap=par->imap[ipop]; + long npx=he_nside2npix(imap->nside); + flouble *map_write=my_malloc(npx*sizeof(flouble)); + int *map_nadd=my_malloc(npx*sizeof(int)); + print_info(" %d-th species\n",ipop); + for(ir=0;irnr;ir++) { + long ip; + long ir_t=ir*imap->num_pix; + + //Write local pixels to dummy map + for(ip=0;ipprefixOut,ipop+1,ir); + for(ip=0;ipdata[ir_t+ip]; + map_nadd[ip]+=imap->nadd[ir_t+ip]; + } + + //Collect all dummy maps +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + + for(ip=0;ip0) + map_write[ip]/=map_nadd[ip]; + } + + //Write dummy map + if(NodeThis==0) + he_write_healpix_map(&map_write,1,imap->nside,fname,0); + } + free(map_write); + free(map_nadd); + } + if(NodeThis==0) timer(2); + print_info("\n"); +} + +void write_cstm(ParamCoLoRe *par) +{ + int ipop; + char fname[256]; + + if(NodeThis==0) timer(0); + print_info("*** Writing custom maps\n"); + for(ipop=0;ipopn_cstm;ipop++) { + long ip; + HealpixShells *cmap=par->cstm[ipop]; + long npx=he_nside2npix(cmap->nside); + flouble *map_write=my_malloc(npx*sizeof(flouble)); + int *map_nadd=my_malloc(npx*sizeof(int)); + print_info(" %d-th species\n",ipop); + + //Write local pixels to dummy map + for(ip=0;ipprefixOut,ipop+1); + for(ip=0;ipdata[ip]; + map_nadd[ip]+=cmap->nadd[ip]; + } + + //Collect all dummy maps +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + + for(ip=0;ip0) + map_write[ip]/=map_nadd[ip]; + } + + //Write dummy map + if(NodeThis==0) + he_write_healpix_map(&map_write,1,cmap->nside,fname,1); + + free(map_write); + free(map_nadd); + } + if(NodeThis==0) timer(2); + print_info("\n"); +} + +void write_kappa(ParamCoLoRe *par) +{ + int ir; + char fname[256]; + long npx=he_nside2npix(par->nside_kappa); + flouble *map_write=my_malloc(npx*sizeof(flouble)); + int *map_nadd=my_malloc(npx*sizeof(int)); + if(NodeThis==0) timer(0); + print_info("*** Writing kappa source maps\n"); + for(ir=0;irkmap->nr;ir++) { + long ip; + long ir_t=ir*par->kmap->num_pix; + + //Write local pixels to dummy map + for(ip=0;ipprefixOut,ir); + for(ip=0;ipkmap->num_pix;ip++) { + int id_pix=par->kmap->listpix[ip]; + map_write[id_pix]+=par->kmap->data[ir_t+ip]; + map_nadd[ id_pix]+=par->kmap->nadd[ir_t+ip]; + } + + //Collect all dummy maps +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + + for(ip=0;ip0) + map_write[ip]/=map_nadd[ip]; + } + +#ifdef _ADD_EXTRA_KAPPA + if(par->need_extra_kappa[ir]) { + if(NodeThis==0) { + int lmax=3*par->kmap->nside; + flouble *map_extra; + flouble *map_mean=my_calloc(npx,sizeof(flouble)); + fcomplex *alm=my_malloc(he_nalms(lmax)*sizeof(fcomplex)); + print_info("Adding perturbations to kappa shell #%d\n",ir+1); + he_map2alm(par->kmap->nside,lmax,1,&map_write,&alm); + he_alter_alm(lmax,0,alm,alm,par->fl_mean_extra_kappa[ir]); + he_alm2map(par->kmap->nside,lmax,1,&map_mean,&alm); + free(alm); + map_extra=he_synfast(par->cl_extra_kappa[ir],par->kmap->nside,lmax,par->seed_rng); + for(ip=0;ipnside_kappa,fname,1); + } + free(map_write); + free(map_nadd); + if(NodeThis==0) timer(2); + print_info("\n"); +} + +void write_lensing(ParamCoLoRe *par) +{ + int ir; + char fname[256]; + long npx=he_nside2npix(par->smap->nside[par->smap->nr-1]); + flouble **map_write=my_malloc(2*sizeof(flouble *)); + map_write[0]=my_malloc(npx*sizeof(flouble)); + map_write[1]=my_malloc(npx*sizeof(flouble)); + if(NodeThis==0) timer(0); + print_info("*** Writing lensing source maps\n"); + for(ir=0;irsmap->nr;ir++) { + long ip, ib; + + //Write local pixels to dummy map + for(ip=0;ipprefixOut,ir); + for(ib=0;ibsmap->nbeams;ib++) { + long ipix_0=(NodeThis+NNodes*ib)*par->smap->num_pix_per_beam[ir]; + for(ip=0;ipsmap->num_pix_per_beam[ir];ip++) { + long id_pix=ipix_0+ip; + map_write[0][id_pix]+=par->smap->data[ib][ir][5*ip+0]; + map_write[1][id_pix]+=par->smap->data[ib][ir][5*ip+1]; + } + } + + //Collect all dummy maps +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_write[0],npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_write[0],NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_write[1],npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_write[1],NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + + //Write dummy map + if(NodeThis==0) + he_write_healpix_map(map_write,2,par->smap->nside[ir],fname,1); + } + free(map_write[0]); + free(map_write[1]); + free(map_write); + + if(NodeThis==0) { + sprintf(fname,"%s_lensing_r.txt", par->prefixOut); + FILE *f=fopen(fname, "w"); + if(f==NULL) + report_error(1,"Couldn't open file %s\n", fname); + for(ir=0;irsmap->nr;ir++) { + fprintf(f,"%d %lE %lE\n",ir, + par->smap->r[ir], + get_bg(par, par->smap->r[ir], BG_Z, 0)); + } + fclose(f); + } + + if(NodeThis==0) timer(2); + print_info("\n"); +} + +void write_isw(ParamCoLoRe *par) +{ + int ir; + char fname[256]; + long npx=he_nside2npix(par->nside_isw); + flouble *map_write=my_malloc(npx*sizeof(flouble)); + int *map_nadd=my_malloc(npx*sizeof(int)); + if(NodeThis==0) timer(0); + print_info("*** Writing isw source maps\n"); + for(ir=0;irpd_map->nr;ir++) { + long ip; + long ir_t=ir*par->pd_map->num_pix; + + //Write local pixels to dummy map + for(ip=0;ipprefixOut,ir); + for(ip=0;ippd_map->num_pix;ip++) { + int id_pix=par->pd_map->listpix[ip]; + map_write[id_pix]+=par->pd_map->data[ir_t+ip]; + map_nadd[ id_pix]+=par->pd_map->nadd[ir_t+ip]; + } + + //Collect all dummy maps +#ifdef _HAVE_MPI + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); + if(NodeThis==0) + MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); + else + MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); +#endif //_HAVE_MPI + + for(ip=0;ip0) + map_write[ip]/=map_nadd[ip]; + } + +#ifdef _ADD_EXTRA_KAPPA + if(par->need_extra_isw[ir]) { + if(NodeThis==0) { + int lmax=3*par->pd_map->nside; + flouble *map_extra; + flouble *map_mean=my_calloc(npx,sizeof(flouble)); + fcomplex *alm=my_malloc(he_nalms(lmax)*sizeof(fcomplex)); + print_info("Adding perturbations to isw shell #%d\n",ir+1); + he_map2alm(par->pd_map->nside,lmax,1,&map_write,&alm); + he_alter_alm(lmax,0,alm,alm,par->fl_mean_extra_isw[ir]); + he_alm2map(par->pd_map->nside,lmax,1,&map_mean,&alm); + free(alm); + map_extra=he_synfast(par->cl_extra_isw[ir],par->pd_map->nside,lmax,par->seed_rng); + for(ip=0;ipnside_isw,fname,1); + } + free(map_write); + free(map_nadd); + if(NodeThis==0) timer(2); + print_info("\n"); +} + +static void write_catalog(ParamCoLoRe *par,int ipop) +{ + char fname[256]; + + if(NodeThis==0) timer(0); + if(par->output_format==2) { //HDF5 +#ifdef _HAVE_HDF5 + hid_t file_id,gal_types[6]; + hsize_t chunk_size=128; + size_t dst_offset[11]={HOFFSET(Src,ra),HOFFSET(Src,dec),HOFFSET(Src,z0),HOFFSET(Src,dz_rsd),HOFFSET(Src,vtheta),HOFFSET(Src,vphi),HOFFSET(Src,e1), + HOFFSET(Src,e2),HOFFSET(Src,kappa),HOFFSET(Src,dra),HOFFSET(Src,ddec)}; + const char *names[11]={"RA" ,"DEC","Z_COSMO","DZ_RSD","VTHETA","VPHI","E1","E2","K" ,"DRA","DDEC"}; + char *tunit[11]= {"DEG","DEG","NA" ,"NA" ,"NA","NA","NA","NA","NA","DEG","DEG"}; + gal_types[0]=H5T_NATIVE_FLOAT; + gal_types[1]=H5T_NATIVE_FLOAT; + gal_types[2]=H5T_NATIVE_FLOAT; + gal_types[3]=H5T_NATIVE_FLOAT; + gal_types[4]=H5T_NATIVE_FLOAT; + gal_types[5]=H5T_NATIVE_FLOAT; + gal_types[6]=H5T_NATIVE_FLOAT; + gal_types[7]=H5T_NATIVE_FLOAT; + gal_types[8]=H5T_NATIVE_FLOAT; + gal_types[9]=H5T_NATIVE_FLOAT; + gal_types[10]=H5T_NATIVE_FLOAT; + + print_info(" %d-th population (HDF5)\n",ipop); + sprintf(fname,"%s_srcs_s%d_%d.h5",par->prefixOut,ipop+1,NodeThis); + + //Create file + file_id=H5Fcreate(fname,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT); + //Write table for each galaxy type + char table_title[256],table_name[256]; + sprintf(table_title,"sources%d_data",ipop+1); + sprintf(table_name,"/sources%d",ipop+1); + H5TBmake_table(table_title,file_id,table_name,6,par->nsources_this[ipop],sizeof(Src), + names,dst_offset,gal_types,chunk_size,NULL,0,par->cats[ipop]->srcs); + H5LTset_attribute_string(file_id,table_name,"FIELD_0_UNITS",tunit[0]); + H5LTset_attribute_string(file_id,table_name,"FIELD_1_UNITS",tunit[1]); + H5LTset_attribute_string(file_id,table_name,"FIELD_2_UNITS",tunit[2]); + H5LTset_attribute_string(file_id,table_name,"FIELD_3_UNITS",tunit[3]); + H5LTset_attribute_string(file_id,table_name,"FIELD_4_UNITS",tunit[4]); + H5LTset_attribute_string(file_id,table_name,"FIELD_5_UNITS",tunit[5]); + H5LTset_attribute_string(file_id,table_name,"FIELD_6_UNITS",tunit[6]); + H5LTset_attribute_string(file_id,table_name,"FIELD_7_UNITS",tunit[7]); + H5LTset_attribute_string(file_id,table_name,"FIELD_8_UNITS",tunit[8]); + + //End file + H5Fclose(file_id); +#else //_HAVE_HDF5 + printf("HDF5 not supported\n"); +#endif //_HAVE_HDF5 + } + else if(par->output_format==1) { //FITS +#ifdef _HAVE_FITS + long ii,nrw=0; + int status=0; + fitsfile *fptr; + int *type_arr; + float *ra_arr,*dec_arr,*z0_arr,*rsd_arr,*vtheta_arr,*vphi_arr,*e1_arr,*e2_arr,*k_arr,*dra_arr,*ddec_arr; + int nfields=5; +#ifdef TVEL + char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD", "VTHETA", "VPHI", "E1","E2","KAPPA","DRA","DDEC"}; + char *tform[]={"1J" ,"1E" ,"1E" ,"1E" ,"1E" , "1E", "1E", "1E","1E","1E" ,"1E!","1E"}; + char *tunit[]={"NA" ,"DEG","DEG","NA" ,"NA" , "NA", "NA", "NA","NA","NA" ,"DEG","DEG"}; + //char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","KAPPA","DRA","DDEC"}; + nfields+=2; +#else + char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","KAPPA","DRA","DDEC"}; + char *tform[]={"1J" ,"1E" ,"1E" ,"1E" ,"1E" ,"1E","1E","1E" ,"1E!","1E"}; + char *tunit[]={"NA" ,"DEG","DEG","NA" ,"NA" ,"NA","NA","NA" ,"DEG","DEG"}; +#endif + if(par->cats[ipop]->has_lensing) + nfields+=5; + + print_info(" %d-th population (FITS)\n",ipop); + sprintf(fname,"!%s_srcs_s%d_%d.fits",par->prefixOut,ipop+1,NodeThis); + + fits_create_file(&fptr,fname,&status); + fits_create_tbl(fptr,BINARY_TBL,0,nfields,ttype,tform,tunit,NULL,&status); + fits_update_key(fptr,TSTRING,"CONTENTS","Source catalog",NULL,&status); + + fits_get_rowsize(fptr,&nrw,&status); + type_arr=my_malloc(nrw*sizeof(int)); + ra_arr=my_malloc(nrw*sizeof(float)); + dec_arr=my_malloc(nrw*sizeof(float)); + z0_arr=my_malloc(nrw*sizeof(float)); + rsd_arr=my_malloc(nrw*sizeof(float)); +#ifdef TVEL + vtheta_arr=my_malloc(nrw*sizeof(float)); + vphi_arr=my_malloc(nrw*sizeof(float)); +#endif + e1_arr=my_malloc(nrw*sizeof(float)); + e2_arr=my_malloc(nrw*sizeof(float)); + k_arr=my_malloc(nrw*sizeof(float)); + dra_arr=my_malloc(nrw*sizeof(float)); + ddec_arr=my_malloc(nrw*sizeof(float)); + + long row_here=0; + while(row_herensources_this[ipop]) { + long nrw_here; + if(row_here+nrw>par->nsources_this[ipop]) + nrw_here=par->nsources_this[ipop]-row_here; + else + nrw_here=nrw; + + for(ii=0;iicats[ipop]->srcs[row_here+ii].ra; + dec_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dec; + z0_arr[ii]=par->cats[ipop]->srcs[row_here+ii].z0; + rsd_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dz_rsd; +#ifdef TVEL + vtheta_arr[ii]=par->cats[ipop]->srcs[row_here+ii].vtheta; + vphi_arr[ii]=par->cats[ipop]->srcs[row_here+ii].vphi; +#endif + if(par->cats[ipop]->has_lensing) { + e1_arr[ii]=par->cats[ipop]->srcs[row_here+ii].e1; + e2_arr[ii]=par->cats[ipop]->srcs[row_here+ii].e2; + k_arr[ii]=par->cats[ipop]->srcs[row_here+ii].kappa; + dra_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dra; + ddec_arr[ii]=par->cats[ipop]->srcs[row_here+ii].ddec; + } + } + fits_write_col(fptr,TINT ,1,row_here+1,1,nrw_here,type_arr,&status); + fits_write_col(fptr,TFLOAT,2,row_here+1,1,nrw_here,ra_arr,&status); + fits_write_col(fptr,TFLOAT,3,row_here+1,1,nrw_here,dec_arr,&status); + fits_write_col(fptr,TFLOAT,4,row_here+1,1,nrw_here,z0_arr,&status); + fits_write_col(fptr,TFLOAT,5,row_here+1,1,nrw_here,rsd_arr,&status); +#ifdef TVEL + fits_write_col(fptr,TFLOAT,6,row_here+1,1,nrw_here,vtheta_arr,&status); + fits_write_col(fptr,TFLOAT,7,row_here+1,1,nrw_here,vphi_arr,&status); + int offset = 2; + //int offset = 0; +#else + int offset = 0; +#endif + if(par->cats[ipop]->has_lensing) { + fits_write_col(fptr,TFLOAT,6+offset,row_here+1,1,nrw_here,e1_arr,&status); + fits_write_col(fptr,TFLOAT,7+offset,row_here+1,1,nrw_here,e2_arr,&status); + fits_write_col(fptr,TFLOAT,8+offset,row_here+1,1,nrw_here,k_arr,&status); + fits_write_col(fptr,TFLOAT,9+offset,row_here+1,1,nrw_here,dra_arr,&status); + fits_write_col(fptr,TFLOAT,10+offset,row_here+1,1,nrw_here,ddec_arr,&status); + } + + row_here+=nrw_here; + } + + if(par->cats[ipop]->has_skw) { + int ir; + long nelements,naxis=2; + long naxes[2]; + + if(par->cats[ipop]->skw_gauss) { + //Write gaussian skewers + naxes[0]=par->cats[ipop]->nr; + naxes[1]=par->cats[ipop]->nsrc; + nelements=naxes[0]*naxes[1]; + fits_create_img(fptr,FLOAT_IMG,naxis,naxes,&status); + fits_update_key(fptr, TSTRING, "CONTENTS", "gaussian skewers",NULL, &status); + fits_write_img(fptr,TFLOAT,1,nelements,par->cats[ipop]->g_skw,&status); + } + else { + //Write density skewers + naxes[0]=par->cats[ipop]->nr; + naxes[1]=par->cats[ipop]->nsrc; + nelements=naxes[0]*naxes[1]; + fits_create_img(fptr,FLOAT_IMG,naxis,naxes,&status); + fits_update_key(fptr, TSTRING, "CONTENTS", "density skewers",NULL, &status); + fits_write_img(fptr,TFLOAT,1,nelements,par->cats[ipop]->d_skw,&status); + } + + //Write velocity skewers + fits_create_img(fptr,FLOAT_IMG,naxis,naxes,&status); + fits_update_key(fptr, TSTRING, "CONTENTS", "velocity skewers",NULL, &status); + fits_write_img(fptr,TFLOAT,1,nelements,par->cats[ipop]->v_skw,&status); + + //Write slicing information + float sg=sqrt(par->sigma2_gauss); + float *ra=my_malloc(par->cats[ipop]->nr*sizeof(float)); + float *za=my_malloc(par->cats[ipop]->nr*sizeof(float)); + float *gda=my_malloc(par->cats[ipop]->nr*sizeof(float)); + float *gva=my_malloc(par->cats[ipop]->nr*sizeof(float)); + char *tt[]={"R","Z","D","V"}; + char *tf[]={"1E","1E","1E","1E"}; + char *tu[]={"MPC_H","NA","NA","NA"}; + for(ir=0;ircats[ipop]->nr;ir++) { + double r=par->cats[ipop]->dr*(ir+0.5); + ra[ir]=r; + za[ir]=get_bg(par,r,BG_Z,0); + gda[ir]=get_bg(par,r,BG_D1,0); + gva[ir]=get_bg(par,r,BG_V1,0); + } + fits_create_tbl(fptr,BINARY_TBL,0,4,tt,tf,tu,NULL,&status); + fits_update_key(fptr,TSTRING,"CONTENTS","Background cosmology",NULL,&status); + fits_update_key(fptr,TFLOAT,"SIGMA_G",&sg,NULL, &status); + fits_write_col(fptr,TFLOAT,1,1,1,par->cats[ipop]->nr,ra,&status); + fits_write_col(fptr,TFLOAT,2,1,1,par->cats[ipop]->nr,za,&status); + fits_write_col(fptr,TFLOAT,3,1,1,par->cats[ipop]->nr,gda,&status); + fits_write_col(fptr,TFLOAT,4,1,1,par->cats[ipop]->nr,gva,&status); + free(ra); free(za); free(gda); free(gva); + } + + fits_close_file(fptr,&status); + free(ra_arr); + free(dec_arr); + free(z0_arr); + free(rsd_arr); + free(type_arr); + free(e1_arr); + free(e2_arr); + free(k_arr); + free(dra_arr); + free(ddec_arr); +#else //_HAVE_FITS + printf("FITS not supported\n"); +#endif //_HAVE_FITS + } + else { + print_info(" %d-th population (ASCII)\n",ipop); + sprintf(fname,"%s_srcs_s%d_%d.txt",par->prefixOut,ipop+1,NodeThis); + + long jj; + FILE *fil=fopen(fname,"w"); + if(fil==NULL) error_open_file(fname); + fprintf(fil,"#[1]type [2]RA, [3]dec, [4]z0, [5]dz_RSD "); + if(par->cats[ipop]->has_lensing) + fprintf(fil,"#[6]e1, [7]e2 [8]kappa [9]d_ra [10]d_dec\n"); + else + fprintf(fil,"\n"); + for(jj=0;jjnsources_this[ipop];jj++) { + fprintf(fil,"%d %E %E %E %E ", + ipop,par->cats[ipop]->srcs[jj].ra,par->cats[ipop]->srcs[jj].dec, + par->cats[ipop]->srcs[jj].z0,par->cats[ipop]->srcs[jj].dz_rsd); + if(par->cats[ipop]->has_lensing) { + fprintf(fil,"%E %E %E %E %E \n",par->cats[ipop]->srcs[jj].e1,par->cats[ipop]->srcs[jj].e2, + par->cats[ipop]->srcs[jj].kappa,par->cats[ipop]->srcs[jj].dra,par->cats[ipop]->srcs[jj].ddec); + } + else + fprintf(fil,"\n"); + } + fclose(fil); + } + if(NodeThis==0) timer(2); +} + +void write_srcs(ParamCoLoRe *par) +{ + print_info("*** Writing source catalogs\n"); + int ipop; + for(ipop=0;ipopn_srcs;ipop++) + write_catalog(par,ipop); + print_info("\n"); +} + +void param_colore_free(ParamCoLoRe *par) +{ + int ii; + free(par->nz_all); + free(par->iz0_all); + free(par->logkarr); + free(par->pkarr); + end_fftw(par); + + if(par->do_srcs) { + for(ii=0;iin_srcs;ii++) { + free(par->srcs_bz_arr[ii]); + free(par->srcs_nz_arr[ii]); + free(par->srcs_norm_arr[ii]); + if(par->cats_c!=NULL) { + if(par->cats_c[ii]!=NULL) + catalog_cartesian_free(par->cats_c[ii]); + } + if(par->cats!=NULL) { + + if(par->cats[ii]!=NULL) + catalog_free(par->cats[ii]); + } + } + if(par->cats_c!=NULL) + free(par->cats_c); + if(par->cats!=NULL) + free(par->cats); + free(par->nsources_c_this); + free(par->nsources_this); + } + + + if(par->do_imap) { + for(ii=0;iin_imap;ii++) { + free(par->imap_bz_arr[ii]); + free(par->imap_tz_arr[ii]); + free(par->imap_norm_arr[ii]); + if(par->imap!=NULL) + hp_shell_free(par->imap[ii]); + } + if(par->imap!=NULL) + free(par->imap); + } + + if(par->do_cstm) { + for(ii=0;iin_cstm;ii++) { + free(par->cstm_bz_arr[ii]); + free(par->cstm_kz_arr[ii]); + free(par->cstm_norm_arr[ii]); + if(par->cstm!=NULL) + hp_shell_free(par->cstm[ii]); + } + if(par->cstm!=NULL) + free(par->cstm); + } + + if(par->do_kappa) { + if(par->kmap!=NULL) + hp_shell_free(par->kmap); +#ifdef _ADD_EXTRA_KAPPA + for(ii=0;iin_kappa;ii++) { + if(par->need_extra_kappa[ii]) { + free(par->fl_mean_extra_kappa[ii]); + free(par->cl_extra_kappa[ii]); + } + } + free(par->need_extra_kappa); + free(par->fl_mean_extra_kappa); + free(par->cl_extra_kappa); +#endif //_ADD_EXTRA_KAPPA + } + +#ifdef _USE_FAST_LENSING + if(par->do_lensing) { + if(par->smap!=NULL) + hp_shell_adaptive_free(par->smap); + } +#endif //_USE_FAST_LENSING + + if(par->do_isw) { + if(par->pd_map!=NULL) + hp_shell_free(par->pd_map); +#ifdef _ADD_EXTRA_KAPPA + for(ii=0;iin_isw;ii++) { + if(par->need_extra_isw[ii]) { + free(par->fl_mean_extra_isw[ii]); + free(par->cl_extra_isw[ii]); + } + } + free(par->need_extra_isw); + free(par->fl_mean_extra_isw); + free(par->cl_extra_isw); +#endif //_ADD_EXTRA_KAPPA + } + + +#ifdef _DEBUG + fclose(par->f_dbg); +#endif //_DEBUG + free(par); +} diff --git a/src/.ipynb_checkpoints/isw-checkpoint.c b/src/.ipynb_checkpoints/isw-checkpoint.c new file mode 100644 index 0000000..ad1d81e --- /dev/null +++ b/src/.ipynb_checkpoints/isw-checkpoint.c @@ -0,0 +1,153 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +void isw_set_cartesian(ParamCoLoRe *par) +{ + return; +} + +void isw_get_local_properties(ParamCoLoRe *par) +{ + return; +} + +void isw_distribute(ParamCoLoRe *par) +{ + return; +} + +void isw_beams_preproc(ParamCoLoRe *par) +{ + //Sort radii in ascending order + int ir; + flouble *r0_i=my_malloc(par->pd_map->nr*sizeof(flouble)); + flouble *rf_i=my_malloc(par->pd_map->nr*sizeof(flouble)); + + memcpy(r0_i,par->pd_map->r0,par->pd_map->nr*sizeof(flouble)); + memcpy(rf_i,par->pd_map->rf,par->pd_map->nr*sizeof(flouble)); + + int *i_sorted=ind_sort(par->pd_map->nr,par->pd_map->r0); + for(ir=0;irpd_map->nr;ir++) { + par->pd_map->r0[ir]=r0_i[i_sorted[ir]]; + par->pd_map->rf[ir]=rf_i[i_sorted[ir]]; + } + free(r0_i); + free(rf_i); + free(i_sorted); + + //Zero all data and clear +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par) +#endif //_HAVE_OMP + { + long ipp; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ipp=0;ipppd_map->num_pix*par->pd_map->nr;ipp++) { + par->pd_map->data[ipp]=0; + par->pd_map->nadd[ipp]=1; + } //end omp for + } //end omp parallel + + return; +} + +void isw_get_beam_properties(ParamCoLoRe *par) +{ + HealpixShells *pd_map=par->pd_map; + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,pd_map) +#endif //_HAVE_OMP + { + double idx=par->n_grid/par->l_box; + + //Setup radial decomposition + int i_r,nr; + double idr,dr; + get_radial_params(par->r_max,par->n_grid,&nr,&dr); + idr=1./dr; + + //Compute index of each source plane + int *i_r_max_arr=my_malloc(pd_map->nr*sizeof(int)); + int *i_r_min_arr=my_malloc(pd_map->nr*sizeof(int)); + for(i_r=0;i_rnr;i_r++) { + int i_r_here=(int)(pd_map->rf[i_r]*idr+0.5); + i_r_max_arr[i_r]=MIN(i_r_here,nr-1); + } + i_r_min_arr[0]=0; + for(i_r=1;i_rnr;i_r++) + i_r_min_arr[i_r]=i_r_max_arr[i_r-1]+1; + + //Fill up integral kernels + double *fac_r=my_malloc(nr*sizeof(double)); + for(i_r=0;i_rnum_pix;ip++) { + int ax,added; + flouble pd; + double xn[3]; + double isw=0; + double *u=&(pd_map->pos[3*ip]); + + for(i_r=0;i_rnr;i_r++) { + int irr; + int irmin=i_r_min_arr[i_r]; + int irmax=i_r_max_arr[i_r]; + for(irr=irmin;irr<=irmax;irr++) { + double rm=(irr+0.5)*dr; + for(ax=0;ax<3;ax++) + xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; + added=interpolate_from_grid(par,xn,NULL,NULL,NULL,&pd,NULL,RETURN_PDOT,INTERP_TYPE_LENSING); + if(added) + isw+=pd*fac_r[irr]; + } + pd_map->data[i_r*pd_map->num_pix+ip]+=isw; + } + } //end omp for + + free(fac_r); + free(i_r_max_arr); + free(i_r_min_arr); + } //end omp parallel + + return; +} + +void isw_beams_postproc(ParamCoLoRe *par) +{ + //Set rf to end of cell + return; +} diff --git a/src/.ipynb_checkpoints/kappa-checkpoint.c b/src/.ipynb_checkpoints/kappa-checkpoint.c new file mode 100644 index 0000000..bb961fd --- /dev/null +++ b/src/.ipynb_checkpoints/kappa-checkpoint.c @@ -0,0 +1,181 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +void kappa_set_cartesian(ParamCoLoRe *par) +{ + return; +} + +void kappa_get_local_properties(ParamCoLoRe *par) +{ + return; +} + +void kappa_distribute(ParamCoLoRe *par) +{ + return; +} + +void kappa_beams_preproc(ParamCoLoRe *par) +{ + //Sort radii in ascending order + int ir; + flouble *r0_i=my_malloc(par->kmap->nr*sizeof(flouble)); + flouble *rf_i=my_malloc(par->kmap->nr*sizeof(flouble)); + + memcpy(r0_i,par->kmap->r0,par->kmap->nr*sizeof(flouble)); + memcpy(rf_i,par->kmap->rf,par->kmap->nr*sizeof(flouble)); + + int *i_sorted=ind_sort(par->kmap->nr,par->kmap->r0); + for(ir=0;irkmap->nr;ir++) { + par->kmap->r0[ir]=r0_i[i_sorted[ir]]; + par->kmap->rf[ir]=rf_i[i_sorted[ir]]; + } + free(r0_i); + free(rf_i); + free(i_sorted); + + //Zero all data and clear +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par) +#endif //_HAVE_OMP + { + long ipp; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ipp=0;ippkmap->num_pix*par->kmap->nr;ipp++) { + par->kmap->data[ipp]=0; + par->kmap->nadd[ipp]=1; + } //end omp for + } //end omp parallel + + return; +} + +void kappa_get_beam_properties(ParamCoLoRe *par) +{ + HealpixShells *kmap=par->kmap; + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,kmap) +#endif //_HAVE_OMP + { + double idx=par->n_grid/par->l_box; + + //Setup radial decomposition + int i_r,nr; + double idr,dr; + get_radial_params(par->r_max,par->n_grid,&nr,&dr); + idr=1./dr; + + //Compute index of each source plane + int *i_r_max_arr=my_malloc(kmap->nr*sizeof(int)); + int *i_r_min_arr=my_malloc(kmap->nr*sizeof(int)); + double *inv_r_max=my_malloc(kmap->nr*sizeof(double)); + for(i_r=0;i_rnr;i_r++) { + int i_r_here=(int)(kmap->rf[i_r]*idr+0.5); + inv_r_max[i_r]=1./(i_r_here*dr); + i_r_max_arr[i_r]=MIN(i_r_here,nr-1); + } + i_r_min_arr[0]=0; + for(i_r=1;i_rnr;i_r++) + i_r_min_arr[i_r]=i_r_max_arr[i_r-1]+1; + + //Fill up integral kernels + double *fac_r_1=my_malloc(nr*sizeof(double)); + double *fac_r_2=my_malloc(nr*sizeof(double)); + for(i_r=0;i_rnum_pix;ip++) { + int ax,added; + flouble t[6]; + double rot[6],xn[3]; + double kappa_1=0,kappa_2=0; + double *u=&(kmap->pos[3*ip]); + double prefac=idx*idx; + double cth_h=1,sth_h=0,cph_h=1,sph_h=0; + + cth_h=u[2]; + if(cth_h>=1) cth_h=1; + if(cth_h<=-1) cth_h=-1; + sth_h=sqrt((1-cth_h)*(1+cth_h)); + if(sth_h!=0) { + cph_h=u[0]/sth_h; + sph_h=u[1]/sth_h; + } + + rot[0]=(cth_h*cth_h*cph_h*cph_h+sph_h*sph_h)*prefac; + rot[1]=(2*cph_h*sph_h*(cth_h*cth_h-1))*prefac; + rot[2]=(-2*cth_h*sth_h*cph_h)*prefac; + rot[3]=(cth_h*cth_h*sph_h*sph_h+cph_h*cph_h)*prefac; + rot[4]=(-2*cth_h*sth_h*sph_h)*prefac; + rot[5]=(sth_h*sth_h)*prefac; + for(i_r=0;i_rnr;i_r++) { + int irr; + int irmin=i_r_min_arr[i_r]; + int irmax=i_r_max_arr[i_r]; + for(irr=irmin;irr<=irmax;irr++) { + double rm=(irr+0.5)*dr; + for(ax=0;ax<3;ax++) + xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; + added=interpolate_from_grid(par,xn,NULL,NULL,t,NULL,NULL,RETURN_TID,INTERP_TYPE_LENSING); + if(added) { + double dotp=0; + for(ax=0;ax<6;ax++) + dotp+=rot[ax]*t[ax]; + kappa_1+=dotp*fac_r_1[irr]; + kappa_2+=dotp*fac_r_2[irr]; + } + } + kmap->data[i_r*kmap->num_pix+ip]+=(kappa_1-inv_r_max[i_r]*kappa_2); + } + } //end omp for + + free(fac_r_1); + free(fac_r_2); + free(i_r_max_arr); + free(i_r_min_arr); + free(inv_r_max); + } //end omp parallel + + return; +} + +void kappa_beams_postproc(ParamCoLoRe *par) +{ + //Set rf to end of cell + return; +} diff --git a/src/.ipynb_checkpoints/lensing-checkpoint.c b/src/.ipynb_checkpoints/lensing-checkpoint.c new file mode 100644 index 0000000..ea2f7a0 --- /dev/null +++ b/src/.ipynb_checkpoints/lensing-checkpoint.c @@ -0,0 +1,256 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +void lensing_set_cartesian(ParamCoLoRe *par) +{ + return; +} + +void lensing_get_local_properties(ParamCoLoRe *par) +{ + return; +} + +void lensing_distribute(ParamCoLoRe *par) +{ + return; +} + +void lensing_beams_preproc(ParamCoLoRe *par) +{ + //Sort radii in ascending order + int ir; + flouble *r_i=my_malloc(par->smap->nr*sizeof(flouble)); + + memcpy(r_i,par->smap->r,par->smap->nr*sizeof(flouble)); + + int *i_sorted=ind_sort(par->smap->nr,par->smap->r); + for(ir=0;irsmap->nr;ir++) { + par->smap->r[ir]=r_i[i_sorted[ir]]; + } + free(r_i); + free(i_sorted); + + //Zero all data and clear +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par) +#endif //_HAVE_OMP + { + long ir, ib, ipp; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ir=0;irsmap->nr;ir++) { + for(ib=0;ibsmap->nbeams;ib++) { + for(ipp=0;ipp<5*par->smap->num_pix_per_beam[ir];ipp++) + par->smap->data[ib][ir][ipp]=0; + } + } //end omp for + } //end omp parallel + + return; +} + +void lensing_get_beam_properties(ParamCoLoRe *par) +{ + HealpixShellsAdaptive *smap=par->smap; + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,smap) +#endif //_HAVE_OMP + { + double idx=par->n_grid/par->l_box; + long npix_hi=smap->num_pix_per_beam[smap->nr-1]; + + //Setup radial decomposition + int i_r,nr; + double idr,dr; + get_radial_params(par->r_max,par->n_grid,&nr,&dr); + idr=1./dr; + + //Compute index of each source plane + int *i_r_max_arr=my_malloc(smap->nr*sizeof(int)); + int *i_r_min_arr=my_malloc(smap->nr*sizeof(int)); + long *npix_ratio=my_malloc(smap->nr*sizeof(long)); + double *inv_npix_ratio=my_malloc(smap->nr*sizeof(double)); + double *inv_r_max=my_malloc(smap->nr*sizeof(double)); + for(i_r=0;i_rnr;i_r++) { + int i_r_here=(int)(smap->r[i_r]*idr+0.5); + inv_r_max[i_r]=1./(i_r_here*dr); + i_r_max_arr[i_r]=MIN(i_r_here,nr-1); + npix_ratio[i_r]=npix_hi/smap->num_pix_per_beam[i_r]; + inv_npix_ratio[i_r]=1./((double)(npix_ratio[i_r])); + } + + i_r_min_arr[0]=0; + for(i_r=1;i_rnr;i_r++) + i_r_min_arr[i_r]=i_r_max_arr[i_r-1]+1; + + //Fill up integral kernels + double *fac_r_0=my_malloc(nr*sizeof(double)); + double *fac_r_1=my_malloc(nr*sizeof(double)); + double *fac_r_2=my_malloc(nr*sizeof(double)); + for(i_r=0;i_rnbeams;ib++) { + //We loop over all pixels in the last plane (since this has the + //highest resolution). + long ip; +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ip=0;ippos[ib][3*ip]); + double prefac=idx*idx; //1/Dx^2 + double prefac_m=0.5*idx; //1/(2 * Dx) + double cth_h=1,sth_h=0,cph_h=1,sph_h=0; + + cth_h=u[2]; + if(cth_h>=1) cth_h=1; + if(cth_h<=-1) cth_h=-1; + sth_h=sqrt((1-cth_h)*(1+cth_h)); + if(sth_h!=0) { + cph_h=u[0]/sth_h; + sph_h=u[1]/sth_h; + } + + u_x[0]=cth_h*cph_h*prefac_m; + u_x[1]=cth_h*sph_h*prefac_m; + u_x[2]=-sth_h*prefac_m; + + u_y[0]=-sph_h*prefac_m; + u_y[1]=cph_h*prefac_m; + u_y[2]=0; + + r_k[0] =(cth_h*cth_h*cph_h*cph_h+sph_h*sph_h)*prefac; + r_k[1] =(2*cph_h*sph_h*(cth_h*cth_h-1))*prefac; + r_k[2] =(-2*cth_h*sth_h*cph_h)*prefac; + r_k[3] =(cth_h*cth_h*sph_h*sph_h+cph_h*cph_h)*prefac; + r_k[4] =(-2*cth_h*sth_h*sph_h)*prefac; + r_k[5] =(sth_h*sth_h)*prefac; + + r_e1[0]=(cth_h*cth_h*cph_h*cph_h-sph_h*sph_h)*prefac; + r_e1[1]=(2*cph_h*sph_h*(cth_h*cth_h+1))*prefac; + r_e1[2]=(-2*cth_h*sth_h*cph_h)*prefac; + r_e1[3]=(cth_h*cth_h*sph_h*sph_h-cph_h*cph_h)*prefac; + r_e1[4]=(-2*cth_h*sth_h*sph_h)*prefac; + r_e1[5]=(sth_h*sth_h)*prefac; + + r_e2[0]=(-2*cth_h*cph_h*sph_h)*prefac; + r_e2[1]=(2*cth_h*(cph_h*cph_h-sph_h*sph_h))*prefac; + r_e2[2]=(2*sth_h*sph_h)*prefac; + r_e2[3]=(2*cth_h*sph_h*cph_h)*prefac; + r_e2[4]=(-2*sth_h*cph_h)*prefac; + r_e2[5]=0; + for(i_r=0;i_rnr;i_r++) { + int irr; + int irmin=i_r_min_arr[i_r]; + int irmax=i_r_max_arr[i_r]; + long ipix_this=ip/npix_ratio[i_r]; + for(irr=irmin;irr<=irmax;irr++) { + double rm=(irr+0.5)*dr; + for(ax=0;ax<3;ax++) + xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; + added=interpolate_from_grid(par,xn,NULL,v,t,NULL,NULL,RETURN_VEL | RETURN_TID, + INTERP_TYPE_LENSING); + if(added) { + double dotk=0,dote1=0,dote2=0,dotvx=0,dotvy=0; + for(ax=0;ax<6;ax++) { + dote1+=r_e1[ax]*t[ax]; + dote2+=r_e2[ax]*t[ax]; + dotk +=r_k[ax]*t[ax]; + } + for(ax=0;ax<3;ax++) { + dotvx+=u_x[ax]*v[ax]; + dotvy+=u_y[ax]*v[ax]; + } + dx_0+=dotvx*fac_r_0[irr]; + dx_1+=dotvx*fac_r_1[irr]; + dy_0+=dotvy*fac_r_0[irr]; + dy_1+=dotvy*fac_r_1[irr]; + kappa_1+=dotk*fac_r_1[irr]; + kappa_2+=dotk*fac_r_2[irr]; + shear1_1+=dote1*fac_r_1[irr]; + shear1_2+=dote1*fac_r_2[irr]; + shear2_1+=dote2*fac_r_1[irr]; + shear2_2+=dote2*fac_r_2[irr]; + } + } + if(ipix_this>=smap->num_pix_per_beam[i_r]) { + printf("SHIT\n"); + exit(1); + } + smap->data[ib][i_r][5*ipix_this+0]+=(shear1_1-inv_r_max[i_r]*shear1_2)*inv_npix_ratio[i_r]; + smap->data[ib][i_r][5*ipix_this+1]+=(shear2_1-inv_r_max[i_r]*shear2_2)*inv_npix_ratio[i_r]; + smap->data[ib][i_r][5*ipix_this+2]+=(kappa_1-inv_r_max[i_r]*kappa_2)*inv_npix_ratio[i_r]; + smap->data[ib][i_r][5*ipix_this+3]+=2*(dx_0-inv_r_max[i_r]*dx_1)*inv_npix_ratio[i_r]; + smap->data[ib][i_r][5*ipix_this+4]+=2*(dy_0-inv_r_max[i_r]*dy_1)*inv_npix_ratio[i_r]; + } + } //end omp for + } + +#ifdef _HAVE_OMP +#pragma omp single +#endif //_HAVE_OMP + { + for(i_r=0;i_rnr;i_r++) + smap->r[i_r]=1./inv_r_max[i_r]; + } + + free(fac_r_0); + free(fac_r_1); + free(fac_r_2); + free(i_r_max_arr); + free(i_r_min_arr); + free(inv_r_max); + free(npix_ratio); + free(inv_npix_ratio); + } //end omp parallel + + return; +} + +void lensing_beams_postproc(ParamCoLoRe *par) +{ + //Set rf to end of cell + return; +} diff --git a/src/.ipynb_checkpoints/main-checkpoint.c b/src/.ipynb_checkpoints/main-checkpoint.c new file mode 100644 index 0000000..12072c2 --- /dev/null +++ b/src/.ipynb_checkpoints/main-checkpoint.c @@ -0,0 +1,154 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +int main(int argc,char **argv) +{ + int test_memory=0; + char fnameIn[256]; + ParamCoLoRe *par; + if(argc<2) { + fprintf(stderr,"Usage: ./CoLoRe file_name\n"); + exit(0); + } + if(!strcmp(argv[1],"--test-memory")) { + test_memory=1; + sprintf(fnameIn,"%s",argv[2]); + } + else + sprintf(fnameIn,"%s",argv[1]); + + mpi_init(&argc,&argv); + + setbuf(stdout,NULL); + print_info("\n"); + print_info("|-------------------------------------------------|\n"); + print_info("| CoLoRe |\n"); + print_info("|-------------------------------------------------|\n\n"); + + if(NodeThis==0) timer(4); + + par=read_run_params(fnameIn,test_memory); + if(par==NULL) { + if(NodeThis==0) timer(5); +#ifdef _HAVE_MPI + MPI_Finalize(); +#endif //_HAVE_MPI + return 0; + } + + print_info("Seed : %u\n",par->seed_rng); + + if(par->do_pred) + write_predictions(par); + if(!(par->just_do_pred)) { + + //Create Gaussian density and radial velocity fields + create_cartesian_fields(par); + + //Lognormalize density field + compute_physical_density_field(par); + + //Compute normalization of density field for biasing + compute_density_normalization(par); + + //Get information from slabs + if(par->do_kappa) + kappa_set_cartesian(par); +#ifdef _USE_FAST_LENSING + if(par->do_lensing) + lensing_set_cartesian(par); +#endif //_USE_FAST_LENSING + if(par->do_isw) + isw_set_cartesian(par); + if(par->do_srcs) + srcs_set_cartesian(par); + if(par->do_imap) + imap_set_cartesian(par); + if(par->do_cstm) + cstm_set_cartesian(par); + + //Distribute information across + if(par->do_kappa) + kappa_distribute(par); +#ifdef _USE_FAST_LENSING + if(par->do_lensing) + lensing_distribute(par); +#endif //_USE_FAST_LENSING + if(par->do_isw) + isw_distribute(par); + if(par->do_srcs) + srcs_distribute(par); + if(par->do_imap) + imap_distribute(par); + if(par->do_cstm) + cstm_distribute(par); + + //Postprocess after + if(par->do_kappa) + kappa_get_local_properties(par); +#ifdef _USE_FAST_LENSING + if(par->do_lensing) + lensing_get_local_properties(par); +#endif //_USE_FAST_LENSING + if(par->do_isw) + isw_get_local_properties(par); + if(par->do_srcs) + srcs_get_local_properties(par); + if(par->do_imap) + imap_get_local_properties(par); + if(par->do_cstm) + cstm_get_local_properties(par); + + //All-to-all communication of density field + //and computation of all required quantities + if(par->need_beaming) + get_beam_properties(par); + + //Write output + if(par->do_kappa) + write_kappa(par); +#ifdef _USE_FAST_LENSING + if(par->do_lensing && par->write_lensing) + write_lensing(par); +#endif ///_USE_FAST_LENSING + if(par->do_isw) + write_isw(par); + if(par->do_srcs) + write_srcs(par); + if(par->do_imap) + write_imap(par); + if(par->do_cstm) + write_cstm(par); + } + + print_info("\n"); + print_info("|-------------------------------------------------|\n\n"); + + param_colore_free(par); + + if(NodeThis==0) timer(5); +#ifdef _HAVE_MPI + MPI_Finalize(); +#endif //_HAVE_MPI + return 0; +} diff --git a/src/.ipynb_checkpoints/predictions-checkpoint.c b/src/.ipynb_checkpoints/predictions-checkpoint.c new file mode 100644 index 0000000..70b59d0 --- /dev/null +++ b/src/.ipynb_checkpoints/predictions-checkpoint.c @@ -0,0 +1,173 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso, Anze Slosar // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// + +#include "common.h" +#include "fftlog.h" + +void write_predictions(ParamCoLoRe *par) +{ + if ((!par->do_srcs) && (!par->do_imap) && (!par->do_cstm)) return; + if (NodeThis!=0) return; + print_info("*** Writing predictions\n"); + // first generate k array, sufficiently finely spaced + // note that we need to sufficiently pad on both ends + const int Nk=10000; + const double kmin=1e-4; + const double kmax=100; + const double kminout=kmin; + const double kmaxout=kmax; + const double rminout=0.5; + const double rmaxout=300.; + double *ka=my_malloc(Nk*sizeof(double)); + double *pk=my_malloc(Nk*sizeof(double)); + double *pklin=my_malloc(Nk*sizeof(double)); + double *ra=my_malloc(Nk*sizeof(double)); + double *xi=my_malloc(Nk*sizeof(double)); + double *xilin=my_malloc(Nk*sizeof(double)); + for (int i=0; ir2_smooth+0.9*pow(par->l_box/par->n_grid,2)/12.; + double rsm2_gm=par->r2_smooth+2.0*pow(par->l_box/par->n_grid,2)/6.; + double rsm2_mm=par->r2_smooth+1.88*pow(par->l_box/par->n_grid,2)/6.; + sprintf(gbiasfn,"%s_gbias.txt",par->prefixOut); + fg=fopen(gbiasfn,"w"); + fprintf (fg,"#1-z 2-r(z) 3-g(z) "); + for (int ipop=0; ipopn_srcs; ipop++) + fprintf(fg,"%d-bg_%d(z) ",ipop+4,ipop+1); + for (int ipop=0; ipopn_imap; ipop++) + fprintf(fg,"%d-bi_%d(z) ",ipop+4+par->n_srcs,ipop+1); + for (int ipop=0; ipopn_cstm; ipop++) + fprintf(fg,"%d-bc_%d(z) ",ipop+4+par->n_srcs+par->n_imap,ipop+1); + fprintf(fg,"\n"); + + // outter loop is over redshifts + for (double z=0; z<=par->z_max; z+=par->pred_dz) { + double r=r_of_z(par,z); + double g=get_bg(par,r,BG_D1,0); + fprintf (fg,"%g %g %g ",z,r,g); + for (int i=0; ido_srcs) { + for (int ipop=0; ipopn_srcs; ipop++) { + double bias=get_bg(par,r,BG_BZ_SRCS,ipop); + fprintf(fg,"%g ",bias); +#ifdef _DEBUG + print_info (" Population %i, bias %g. \n",ipop,bias); +#endif //_DEBUG + for (int i=0; iprefixOut,ipop,z); + sprintf(fnamexi,"%s_xi_srcs_pop%i_z%.3lf.txt",par->prefixOut,ipop,z); + fpk=fopen(fnamepk,"w"); + fprintf (fpk, "# k[h/Mpc] P_tt P_tl P_ll\n"); + fxi=fopen(fnamexi,"w"); + fprintf (fxi, "# r[Mpc/h] xi_tt xi_ll*b^2 xi_ll\n"); + for (int i=0; i=kminout) && (ka[i]<=kmaxout)) + fprintf (fpk,"%g %g %g %g\n",ka[i],pk[i], pklin[i]*bias*exp(-rsm2_gm*ka[i]*ka[i]), pklin[i]*exp(-rsm2_mm*ka[i]*ka[i])); + if ((ra[i]>=rminout) && (ra[i]<=rmaxout)) + fprintf (fxi,"%g %g %g %g\n",ra[i], xi[i], + xilin[i]*bias, xilin[i]); + } + fclose(fpk); + fclose(fxi); + } + } + if(par->do_imap) { + for (int ipop=0; ipopn_imap; ipop++) { + double bias=get_bg(par,r,BG_BZ_IMAP,ipop); + fprintf(fg,"%g ",bias); +#ifdef _DEBUG + print_info (" Population %i, bias %g. \n",ipop,bias); +#endif //_DEBUG + for (int i=0; iprefixOut,ipop,z); + sprintf(fnamexi,"%s_xi_imap_pop%i_z%.3lf.txt",par->prefixOut,ipop,z); + fpk=fopen(fnamepk,"w"); + fprintf (fpk, "# k[h/Mpc] P_tt P_tl P_ll\n"); + fxi=fopen(fnamexi,"w"); + fprintf (fxi, "# k[Mpc/h] xi_tt xi_ll*b^2 xi_ll\n"); + for (int i=0; i=kminout) && (ka[i]<=kmaxout)) + fprintf (fpk,"%g %g %g %g\n",ka[i],pk[i], + pklin[i]*bias*exp(-rsm2_gm*ka[i]*ka[i]), + pklin[i]*exp(-rsm2_mm*ka[i]*ka[i])); + if ((ra[i]>=rminout) && (ra[i]<=rmaxout)) + fprintf (fxi,"%g %g %g %g\n",ra[i],xi[i], xilin[i]*bias, xilin[i]); + } + fclose(fpk); + fclose(fxi); + } + } + if(par->do_cstm) { + for (int ipop=0; ipopn_cstm; ipop++) { + double bias=get_bg(par,r,BG_BZ_CSTM,ipop); + fprintf(fg,"%g ",bias); +#ifdef _DEBUG + print_info (" Population %i, bias %g. \n",ipop,bias); +#endif //_DEBUG + for (int i=0; iprefixOut,ipop,z); + sprintf(fnamexi,"%s_xi_custom_pop%i_z%.3lf.txt",par->prefixOut,ipop,z); + fpk=fopen(fnamepk,"w"); + fprintf (fpk, "# k[h/Mpc] P_tt P_tl P_ll\n"); + fxi=fopen(fnamexi,"w"); + fprintf (fxi, "# k[Mpc/h] xi_tt xi_ll*b^2 xi_ll\n"); + for (int i=0; i=kminout) && (ka[i]<=kmaxout)) + fprintf (fpk,"%g %g %g %g\n",ka[i],pk[i], + pklin[i]*bias*exp(-rsm2_gm*ka[i]*ka[i]), + pklin[i]*exp(-rsm2_mm*ka[i]*ka[i])); + if ((ra[i]>=rminout) && (ra[i]<=rmaxout)) + fprintf (fxi,"%g %g %g %g\n",ra[i],xi[i], xilin[i]*bias, xilin[i]); + } + fclose(fpk); + fclose(fxi); + } + } + fprintf(fg,"\n"); + } + fclose(fg); + free(ka); + free(pk); + free(pklin); + free(ra); + free(xi); + free(xilin); +} diff --git a/src/.ipynb_checkpoints/srcs-checkpoint.c b/src/.ipynb_checkpoints/srcs-checkpoint.c new file mode 100644 index 0000000..4bb5797 --- /dev/null +++ b/src/.ipynb_checkpoints/srcs-checkpoint.c @@ -0,0 +1,763 @@ +/////////////////////////////////////////////////////////////////////// +// // +// Copyright 2012 David Alonso // +// // +// // +// This file is part of CoLoRe. // +// // +// CoLoRe is free software: you can redistribute it and/or modify it // +// under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License, or // +// (at your option) any later version. // +// // +// CoLoRe is distributed in the hope that it will be useful, but // +// WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with CoLoRe. If not, see . // +// // +/////////////////////////////////////////////////////////////////////// +#include "common.h" + +#ifdef _USE_FAST_LENSING +static int get_r_index_lensing(HealpixShellsAdaptive *sh,double r,int ir_start) +{ + int gotit=0; + int ir0; + if(ir_start<0) + ir0=0; + else if(ir_start>=sh->nr) + ir0=sh->nr-1; + else + ir0=ir_start; + + while(!gotit) { + if(ir0==0) { + if(rr[1]) + gotit=1; + else + ir0++; + } + else if(ir0==sh->nr-1) { + if(r>=sh->r[sh->nr-2]) { + ir0=sh->nr-2; + gotit=1; + } + else + ir0--; + } + else { + if(rr[ir0]) + ir0--; + else { + if(r>=sh->r[ir0+1]) + ir0++; + else + gotit=1; + } + } + } + + return ir0; +} +#endif //_USE_FAST_LENSING + + +static inline void cart2sph(double x,double y,double z,double *r,double *cth,double *phi) +{ + *r=sqrt(x*x+y*y+z*z); + + if((*r)==0) { + *cth=1; + *phi=0; + } + else { + double xn=x/(*r); + double yn=y/(*r); + + *cth=z/(*r); + *phi=atan2(yn,xn); + if((*phi)<0) + (*phi)+=2*M_PI; + } +} + +static void get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, + double x0,double y0,double z0,double rr, + double* rvel, double* vtheta, double* vphi) +{ + double v[3],u[3]; + double idx=par->n_grid/par->l_box; + long ngx=2*(par->n_grid/2+1); + long iz_hi=iz+1,iz_lo=iz-1,iz_0=iz; + long iy_hi=iy+1,iy_lo=iy-1,iy_0=iy; + long ix_hi=ix+1,ix_lo=ix-1,ix_0=ix; + if(iy==0) iy_lo=par->n_grid-1; + if(iy==par->n_grid-1) iy_hi=0; + if(ix==0) ix_lo=par->n_grid-1; + if(ix==par->n_grid-1) ix_hi=0; + iz_0*=ngx*par->n_grid; + iz_lo*=ngx*par->n_grid; + iz_hi*=ngx*par->n_grid; + iy_0*=ngx; + iy_lo*=ngx; + iy_hi*=ngx; + + u[0]=x0/rr; u[1]=y0/rr; u[2]=z0/rr; + v[0]=par->grid_npot[ix_hi+iy_0+iz_0]-par->grid_npot[ix_lo+iy_0+iz_0]; + v[1]=par->grid_npot[ix_0+iy_hi+iz_0]-par->grid_npot[ix_0+iy_lo+iz_0]; + if(iz==0) + v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->slice_left[ix_0+iy_0]; + else if(iz==par->nz_here-1) + v[2]=par->slice_right[ix_0+iy_0]-par->grid_npot[ix_0+iy_0+iz_lo]; + else + v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->grid_npot[ix_0+iy_0+iz_lo]; + + *rvel = 0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); +#ifdef TVEL + *vtheta = 0.5*idx*(v[0]*(u[0]*u[2]/sqrt(1-u[2]*u[2]))+v[1]*(u[1]*u[2]/sqrt(1-u[2]*u[2]))+v[2]*(-sqrt(1-u[2]*u[2]))); + *vphi = 0.5*idx*(v[0]*(-u[1]/sqrt(1-u[2]*u[2]))+v[1]*(u[0]/sqrt(1-u[2]*u[2]))); +#endif + +} + +static void srcs_set_cartesian_single(ParamCoLoRe *par,int ipop) +{ + int ii,nthr; + int ngx=2*(par->n_grid/2+1); + long *np_tot_thr; + int *nsources=my_calloc(ngx*((long)(par->n_grid*par->nz_here)),sizeof(int)); +#ifdef _HAVE_OMP + nthr=omp_get_max_threads(); +#else //_HAVE_OMP + nthr=1; +#endif //_HAVE_OMP + np_tot_thr=my_calloc(nthr,sizeof(long)); + + print_info(" %d-th galaxy population\n",ipop); + if(NodeThis==0) timer(0); + print_info(" Poisson-sampling\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,np_tot_thr,IThread0,ipop,nthr,nsources) +#endif //_HAVE_OMP + { + long iz; +#ifdef _HAVE_OMP + int ithr=omp_get_thread_num(); +#else //_HAVE_OMP + int ithr=0; +#endif //_HAVE_OMP + double dx=par->l_box/par->n_grid; + double cell_vol=dx*dx*dx; + int ngx=2*(par->n_grid/2+1); + unsigned int seed_thr=par->seed_rng+ithr+nthr*(ipop+par->n_srcs*IThread0); + gsl_rng *rng_thr=init_rng(seed_thr); + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + double z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + double y0=(iy+0.5)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + int npp=0; + long index=ix+indexy+indexz; + double x0=(ix+0.5)*dx-par->pos_obs[0]; + double r=sqrt(x0*x0+y0*y0+z0*z0); + if(rl_box/2+20.) { + double ndens=get_bg(par,r,BG_NZ_SRCS,ipop); + if(ndens>0) { + double bias=get_bg(par,r,BG_BZ_SRCS,ipop); + double dnorm=get_bg(par,r,BG_NORM_SRCS,ipop); + double lambda=ndens*cell_vol*bias_model(par->grid_dens[index],bias)*dnorm; + //double lambda=ndens*cell_vol*dnorm; + npp=rng_poisson(lambda,rng_thr); + } + } + + nsources[index]=npp; + np_tot_thr[ithr]+=npp; + } + } + }//end omp for + + end_rng(rng_thr); + }//end omp parallel + + par->nsources_c_this[ipop]=0; + for(ii=0;iinsources_c_this[ipop]+=np_tot_thr[ii]; + + long nsources_total=0; +#ifdef _HAVE_MPI + MPI_Allreduce(&(par->nsources_c_this[ipop]),&nsources_total,1,MPI_LONG,MPI_SUM,MPI_COMM_WORLD); +#else //_HAVE_MPI + nsources_total=par->nsources_c_this[ipop]; +#endif //_HAVE_MPI + + print_info(" There will be %ld objects in total \n",(long)nsources_total); +#ifdef _DEBUG + fprintf(par->f_dbg,"MPI task %d has %ld particles\n",NodeThis,(long)(par->nsources_c_this[ipop])); +#endif //_DEBUG + + for(ii=nthr-1;ii>0;ii--) { + int jj; + long nh=0; + for(jj=0;jjcats_c[ipop]=catalog_cartesian_alloc(par->nsources_c_this[ipop]); + + print_info(" Assigning coordinates\n"); +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,IThread0,np_tot_thr,ipop,nthr,nsources) +#endif //_HAVE_OMP + { + long iz; +#ifdef _HAVE_OMP + int ithr=omp_get_thread_num(); +#else //_HAVE_OMP + int ithr=0; +#endif //_HAVE_OMP + double dx=par->l_box/par->n_grid; + int ngx=2*(par->n_grid/2+1); + unsigned int seed_thr=par->seed_rng+ithr+nthr*(ipop+par->n_srcs*IThread0); + gsl_rng *rng_thr=init_rng(seed_thr); + double factor_vel=-par->fgrowth_0/(1.5*par->hubble_0*par->OmegaM); + +#ifdef _HAVE_OMP +#pragma omp for schedule(static) +#endif //_HAVE_OMP + for(iz=0;iznz_here;iz++) { + int iy; + long indexz=iz*((long)(ngx*par->n_grid)); + double z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; + for(iy=0;iyn_grid;iy++) { + int ix; + long indexy=iy*ngx; + double y0=(iy+0.5)*dx-par->pos_obs[1]; + for(ix=0;ixn_grid;ix++) { + double x0=(ix+0.5)*dx-par->pos_obs[0]; + long index=ix+indexy+indexz; + int npp=nsources[index]; + if(npp>0) { + int ip; + double rr=sqrt(x0*x0+y0*y0+z0*z0); + double rvel, vtheta, vphi; + get_rvel(par,ix,iy,iz,x0,y0,z0,rr, &rvel, &vtheta, &vphi); + rvel *=factor_vel; + double dz_rsd=rvel*get_bg(par,rr,BG_V1,0); + for(ip=0;ipcats_c[ipop]->pos[NPOS_CC*pid+0]=x0+dx*(rng_01(rng_thr)-0.5); + par->cats_c[ipop]->pos[NPOS_CC*pid+1]=y0+dx*(rng_01(rng_thr)-0.5); + par->cats_c[ipop]->pos[NPOS_CC*pid+2]=z0+dx*(rng_01(rng_thr)-0.5); + par->cats_c[ipop]->pos[NPOS_CC*pid+3]=dz_rsd; + #ifdef TVEL + par->cats_c[ipop]->pos[NPOS_CC*pid+4]=vtheta; + par->cats_c[ipop]->pos[NPOS_CC*pid+5]=vphi; + #endif + + + for(ax=0;ax<3;ax++) + pos[ax]=par->cats_c[ipop]->pos[NPOS_CC*pid+ax]; + + vec2pix_ring(par->nside_base,pos,&pix_id_ring); + ring2nest(par->nside_base,pix_id_ring,&pix_id_nest); + par->cats_c[ipop]->ipix[pid]=pix_id_nest; + np_tot_thr[ithr]++; + } + } + } + } + }//end omp for + end_rng(rng_thr); + }//end omp parallel + if(NodeThis==0) timer(2); + + free(np_tot_thr); + free(nsources); +} + +void srcs_set_cartesian(ParamCoLoRe *par) +{ + int ipop; + + //First, compute lensing Hessian + print_info("*** Getting point sources\n"); + for(ipop=0;ipopn_srcs;ipop++) + srcs_set_cartesian_single(par,ipop); + print_info("\n"); +} + +static void srcs_distribute_single(ParamCoLoRe *par,int ipop) +{ + int ii; + long *ns_to_nodes=my_calloc(NNodes,sizeof(long)); + long *i0_in_nodes=my_calloc(NNodes,sizeof(long)); + long *ns_transfer_matrix=my_calloc(NNodes*NNodes,sizeof(long)); + CatalogCartesian *cat=par->cats_c[ipop]; + + //Count how many objects need to be sent to each node + for(ii=0;iinsources_c_this[ipop];ii++) { + int i_node=cat->ipix[ii]%NNodes; + ns_to_nodes[i_node]++; + } + + //Gather all transfers into a 2D array +#ifdef _HAVE_MPI + MPI_Allgather(ns_to_nodes,NNodes,MPI_LONG, + ns_transfer_matrix,NNodes,MPI_LONG,MPI_COMM_WORLD); +#else //_HAVE_MPI + ns_transfer_matrix[0]=ns_to_nodes[0]; +#endif //_HAVE_MPI + + //Calculate position of each particle going to each node + for(ii=0;iinsources_c_this[ipop]*sizeof(float)); + for(ii=0;iinsources_c_this[ipop];ii++) { + int ax; + int i_node=cat->ipix[ii]%NNodes; + long id_here=ns_to_nodes[i_node]; + for(ax=0;axpos[NPOS_CC*ii+ax]; + ns_to_nodes[i_node]++; + } + + //Count particles this node will receive + par->nsources_this[ipop]=0; + for(ii=0;iinsources_this[ipop]+=ns_transfer_matrix[ii*NNodes+NodeThis]; + + //Loop through all nodes and receive particles + //Free up old catalog and create new one + catalog_cartesian_free(par->cats_c[ipop]); + par->cats_c[ipop]=catalog_cartesian_alloc(par->nsources_this[ipop]); + par->nsources_c_this[ipop]=par->nsources_this[ipop]; + long i_sofar=0; + for(ii=0;ii%d from->%d.",NodeThis,ii,node_to,node_from); + // print_info(" Should get %07ld objects, and will send %07ld.\n",npart_recv,npart_send); +#ifdef _HAVE_MPI + MPI_Sendrecv(&(pos_ordered[NPOS_CC*i0_in_nodes[node_to]]),NPOS_CC*npart_send,MPI_FLOAT,node_to ,ii, + &(par->cats_c[ipop]->pos[NPOS_CC*i_sofar]) ,NPOS_CC*npart_recv,MPI_FLOAT,node_from,ii, + MPI_COMM_WORLD,MPI_STATUS_IGNORE); +#else //_HAVE_MPI + memcpy(&(par->cats_c[ipop]->pos[NPOS_CC*i_sofar]),&(pos_ordered[NPOS_CC*i0_in_nodes[node_to]]), + NPOS_CC*npart_send*sizeof(float)); +#endif //_HAVE_MPI + i_sofar+=npart_recv; + // print_info(" %07ld sources gathered so far\n",i_sofar); + } + + free(pos_ordered); + free(i0_in_nodes); + free(ns_to_nodes); + free(ns_transfer_matrix); +} + +void srcs_distribute(ParamCoLoRe *par) +{ + if(NodeThis==0) timer(0); + int ipop; + print_info("*** Re-distributing sources across nodes\n"); + for(ipop=0;ipopn_srcs;ipop++) + srcs_distribute_single(par,ipop); + if(NodeThis==0) timer(2); + print_info("\n"); +} + +static void srcs_get_local_properties_single(ParamCoLoRe *par,int ipop) +{ + par->cats[ipop]=catalog_alloc(par->cats_c[ipop]->nsrc, + par->lensing_srcs[ipop], + par->skw_srcs[ipop], + par->skw_gauss[ipop], + par->r_max,par->n_grid); + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,ipop) +#endif //_HAVE_OMP + { + int ii; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iicats[ipop]->nsrc;ii++) { + double r,cth,phi; + float *pos=&(par->cats_c[ipop]->pos[NPOS_CC*ii]); + cart2sph(pos[0],pos[1],pos[2],&r,&cth,&phi); + par->cats[ipop]->srcs[ii].ra=RTOD*phi; + par->cats[ipop]->srcs[ii].dec=90-RTOD*acos(cth); + par->cats[ipop]->srcs[ii].z0=get_bg(par,r,BG_Z,0); + par->cats[ipop]->srcs[ii].dz_rsd=pos[3]; + #ifdef TVEL + par->cats[ipop]->srcs[ii].vtheta=pos[4]; + par->cats[ipop]->srcs[ii].vphi=pos[5]; + #endif + + par->cats[ipop]->srcs[ii].e1=-1; + par->cats[ipop]->srcs[ii].e2=-1; + }//end omp for + }//end omp parallel +} + +void srcs_get_local_properties(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_srcs;ipop++) + srcs_get_local_properties_single(par,ipop); +} + +static void srcs_beams_preproc_single(ParamCoLoRe *par,int ipop) +{ +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,ipop) +#endif //_HAVE_OMP + { + int ii; + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iicats[ipop]->nsrc;ii++) { + par->cats[ipop]->srcs[ii].dz_rsd=0; + par->cats[ipop]->srcs[ii].e1=0; + par->cats[ipop]->srcs[ii].e2=0; + }//end omp for + }//end omp parallel +} + +void srcs_beams_preproc(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_srcs;ipop++) + srcs_beams_preproc_single(par,ipop); +} + +static void srcs_get_beam_properties_single(ParamCoLoRe *par,int ipop) +{ + Catalog *cat=par->cats[ipop]; + CatalogCartesian *catc=par->cats_c[ipop]; + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,cat,catc) +#endif //_HAVE_OMP + { + long ip; + double idx=par->n_grid/par->l_box; + + //Kernels for the LOS integrals +#ifndef _USE_FAST_LENSING + double *fac_r_0=NULL,*fac_r_1=NULL,*fac_r_2=NULL; + if(cat->has_lensing) { + fac_r_0=my_malloc(cat->nr*sizeof(double)); + fac_r_1=my_malloc(cat->nr*sizeof(double)); + fac_r_2=my_malloc(cat->nr*sizeof(double)); + + for(ip=0;ipnr;ip++) { + double rm=(ip+0.5)*cat->dr; + double pg=get_bg(par,rm,BG_D1,0)*(1+get_bg(par,rm,BG_Z,0)); + fac_r_0[ip]=pg*cat->dr; + fac_r_1[ip]=rm*pg*cat->dr; + fac_r_2[ip]=rm*rm*pg*cat->dr; + } + } +#endif //_USE_FAST_LENSING + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ip=0;ipnsrc;ip++) { + int ax,added; + double xn[3],u[3]; + flouble v[3],vr,dens,gauss; + float *pos=&(catc->pos[NPOS_CC*ip]); + double r=sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]); + double ir=1./(MAX(r,0.001)); + + for(ax=0;ax<3;ax++) {//TODO these could be precomputed in the cartesian catalog + xn[ax]=(pos[ax]+par->pos_obs[ax])*idx; + u[ax]=pos[ax]*ir; + } + + //Compute RSD + added=interpolate_from_grid(par,xn,NULL,v,NULL,NULL,NULL,RETURN_VEL,INTERP_TYPE_SKW); + if(added) { + vr=0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); + cat->srcs[ip].dz_rsd+=vr; + } + + //Fill up skewers + if(cat->has_skw) { + int i_r,i_r_max=MIN((int)(r*cat->idr+0.5),cat->nr-1); + long offp=ip*cat->nr; + for(i_r=0;i_r<=i_r_max;i_r++) { + double rm=(i_r+0.5)*cat->dr; + for(ax=0;ax<3;ax++) + xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; + if(cat->skw_gauss) { + added=interpolate_from_grid(par,xn,&dens,v,NULL,NULL,&gauss,RETURN_GAUSS | RETURN_VEL,INTERP_TYPE_SKW); + } + else { + added=interpolate_from_grid(par,xn,&dens,v,NULL,NULL,&gauss,RETURN_DENS | RETURN_VEL,INTERP_TYPE_SKW); + } + if(added) { + vr=0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); + if(cat->skw_gauss) + cat->g_skw[offp+i_r]+=gauss; + else + cat->d_skw[offp+i_r]+=dens; + cat->v_skw[offp+i_r]+=vr; + } + } + } + +#ifndef _USE_FAST_LENSING + //Compute lensing + if(cat->has_lensing) { + //Compute linear transformations needed for lensing + double u_x[3], u_y[3]; + double r_k[6], r_e1[6],r_e2[6]; + double cth_h=1,sth_h=0,cph_h=1,sph_h=0; + double prefac=idx*idx*ir; // 1 / (Dx^2 * r) + double prefac_m=0.5*idx*ir; // 1 / (2 * Dx * r) + + cth_h=u[2]; + if(cth_h>=1) cth_h=1; + if(cth_h<=-1) cth_h=-1; + sth_h=sqrt((1-cth_h)*(1+cth_h)); + if(sth_h!=0) { + cph_h=u[0]/sth_h; + sph_h=u[1]/sth_h; + } + + u_x[0]=cth_h*cph_h*prefac_m; + u_x[1]=cth_h*sph_h*prefac_m; + u_x[2]=-sth_h*prefac_m; + + u_y[0]=-sph_h*prefac_m; + u_y[1]=cph_h*prefac_m; + u_y[2]=0; + + r_k[0] =(cth_h*cth_h*cph_h*cph_h+sph_h*sph_h)*prefac; + r_k[1] =(2*cph_h*sph_h*(cth_h*cth_h-1))*prefac; + r_k[2] =(-2*cth_h*sth_h*cph_h)*prefac; + r_k[3] =(cth_h*cth_h*sph_h*sph_h+cph_h*cph_h)*prefac; + r_k[4] =(-2*cth_h*sth_h*sph_h)*prefac; + r_k[5] =(sth_h*sth_h)*prefac; + + r_e1[0]=(cth_h*cth_h*cph_h*cph_h-sph_h*sph_h)*prefac; + r_e1[1]=(2*cph_h*sph_h*(cth_h*cth_h+1))*prefac; + r_e1[2]=(-2*cth_h*sth_h*cph_h)*prefac; + r_e1[3]=(cth_h*cth_h*sph_h*sph_h-cph_h*cph_h)*prefac; + r_e1[4]=(-2*cth_h*sth_h*sph_h)*prefac; + r_e1[5]=(sth_h*sth_h)*prefac; + + r_e2[0]=(-2*cth_h*cph_h*sph_h)*prefac; + r_e2[1]=(2*cth_h*(cph_h*cph_h-sph_h*sph_h))*prefac; + r_e2[2]=(2*sth_h*sph_h)*prefac; + r_e2[3]=(2*cth_h*sph_h*cph_h)*prefac; + r_e2[4]=(-2*sth_h*cph_h)*prefac; + r_e2[5]=0; + + //Integrate along the LOS + flouble tp[6],vp[3]; + double dtx=0,dty=0,kp=0,e1=0,e2=0; + int i_r,i_r_max=MIN((int)(r*cat->idr+0.5),cat->nr-1); + for(i_r=0;i_r<=i_r_max;i_r++) { + double rm=(i_r+0.5)*cat->dr; + for(ax=0;ax<3;ax++) + xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; + added=interpolate_from_grid(par,xn,NULL,vp,tp,NULL,NULL,RETURN_VEL | RETURN_TID, + INTERP_TYPE_LENSING); + if(added) { + double fr=fac_r_1[i_r]*r-fac_r_2[i_r]; + double frm=2*(fac_r_0[i_r]*r-fac_r_1[i_r]); + double dotvx=0,dotvy=0,dotk=0,dote1=0,dote2=0; + for(ax=0;ax<6;ax++) { + dote1+=r_e1[ax]*tp[ax]; + dote2+=r_e2[ax]*tp[ax]; + dotk+=r_k[ax]*tp[ax]; + } + for(ax=0;ax<3;ax++) { + dotvx+=u_x[ax]*vp[ax]; + dotvy+=u_y[ax]*vp[ax]; + } + e1+=dote1*fr; + e2+=dote2*fr; + kp+=dotk*fr; + dtx+=dotvx*frm; + dty+=dotvy*frm; + } + } + cat->srcs[ip].e1+=e1; + cat->srcs[ip].e2+=e2; + cat->srcs[ip].kappa+=kp; + cat->srcs[ip].dra+=dty; + cat->srcs[ip].ddec+=dtx; + } +#endif //_USE_FAST_LENSING + }//end omp for +#ifndef _USE_FAST_LENSING + if(cat->has_lensing) { + free(fac_r_0); + free(fac_r_1); + free(fac_r_2); + } +#endif //_USE_FAST_LENSING + }//end omp parallel +} + +void srcs_get_beam_properties(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_srcs;ipop++) + srcs_get_beam_properties_single(par,ipop); +} + +static void srcs_beams_postproc_single(ParamCoLoRe *par,int ipop) +{ + Catalog *cat=par->cats[ipop]; + //CatalogCartesian *catc=par->cats_c[ipop]; + +#ifdef _HAVE_OMP +#pragma omp parallel default(none) \ + shared(par,cat,NNodes,NodeThis) +#endif //_HAVE_OMP + { + int ii; + double factor_vel=-par->fgrowth_0/(1.5*par->hubble_0*par->OmegaM); +#ifdef _USE_FAST_LENSING + int ir_s=0; + HealpixShellsAdaptive *smap=NULL; + if(cat->has_lensing) + smap = par->smap; +#endif //_USE_FAST_LENSING + +#ifdef _HAVE_OMP +#pragma omp for +#endif //_HAVE_OMP + for(ii=0;iinsrc;ii++) { + double z=cat->srcs[ii].z0; + double r=r_of_z(par,z); + double vg=get_bg(par,r,BG_V1,0); + + //RSDs + cat->srcs[ii].dz_rsd*=vg*factor_vel; + + //Lensing + if(cat->has_lensing) { +#ifdef _USE_FAST_LENSING + int ax; + long ipix_up,ipix_lo,ibase,ibase_here; + double u[3]; + double g1_lo,g1_up,g2_lo,g2_up; + double kp_lo,kp_up; + double dx_lo,dx_up,dy_lo,dy_up; + //Find lower shell index + ir_s=get_r_index_lensing(smap, r, ir_s); + if(ir_s>=smap->nr-1) + report_error(1, "SHIT\n"); + + //Find intervals + double h = (r - smap->r[ir_s]) / (smap->r[ir_s+1] - smap->r[ir_s]); + + //Find pixel index + //Find base this galaxy belongs to + for(ax=0;ax<3;ax++) + u[ax]=catc->pos[NPOS_CC*ii+ax]; + vec2pix_nest(par->nside_base,u,&ibase); + if(ibase%NNodes!=NodeThis) + report_error(1,"Bad base!!\n"); + //Find base index within this node + ibase_here=(ibase-NodeThis)/NNodes; + + //Find pixel in lower edge + vec2pix_nest(smap->nside[ir_s],u,&ipix_lo); + //Offset to pixel indices in this node + ipix_lo-=ibase*smap->num_pix_per_beam[ir_s]; + if((ipix_lo<0) || (ipix_lo>=smap->num_pix_per_beam[ir_s])) + report_error(1,"Bad pixel!!\n"); + //Find lensing at edges + g1_lo=smap->data[ibase_here][ir_s][5*ipix_lo+0]; + g2_lo=smap->data[ibase_here][ir_s][5*ipix_lo+1]; + kp_lo=smap->data[ibase_here][ir_s][5*ipix_lo+2]; + dx_lo=smap->data[ibase_here][ir_s][5*ipix_lo+3]; + dy_lo=smap->data[ibase_here][ir_s][5*ipix_lo+4]; + + //Same in upper edge + vec2pix_nest(smap->nside[ir_s+1],u,&ipix_up); + ipix_up-=ibase*smap->num_pix_per_beam[ir_s+1]; + if((ipix_up<0) || (ipix_up>=smap->num_pix_per_beam[ir_s+1])) + report_error(1,"Bad pixel!!\n"); + g1_up=smap->data[ibase_here][ir_s+1][2*ipix_up+0]; + g2_up=smap->data[ibase_here][ir_s+1][2*ipix_up+1]; + kp_up=smap->data[ibase_here][ir_s+1][2*ipix_up+2]; + dx_up=smap->data[ibase_here][ir_s+1][2*ipix_up+3]; + dy_up=smap->data[ibase_here][ir_s+1][2*ipix_up+4]; + + //Interpolate + cat->srcs[ii].e1=g1_lo*(1-h)+g1_up*h; + cat->srcs[ii].e2=g2_lo*(1-h)+g2_up*h; + cat->srcs[ii].kappa=kp_lo*(1-h)+kp_up*h; + cat->srcs[ii].dra=dy_lo*(1-h)+dy_up*h; + cat->srcs[ii].ddec=dx_lo*(1-h)+dx_up*h; +#endif //_USE_FAST_LENSING + cat->srcs[ii].dra*=RTOD; + cat->srcs[ii].ddec*=RTOD; + } + + //Skewers + if(cat->has_skw) { + int i_r,i_r_max=MAX((int)(r*cat->idr+0.5),cat->nr-1); + long offp=ii*cat->nr; + for(i_r=0;i_r<=i_r_max;i_r++) { + vg=get_bg(par,(i_r+0.5)*cat->dr,BG_V1,0); + cat->v_skw[offp+i_r]*=vg*factor_vel; + } + } + }//end omp for + }//end omp parallel +} + +void srcs_beams_postproc(ParamCoLoRe *par) +{ + int ipop; + for(ipop=0;ipopn_srcs;ipop++) + srcs_beams_postproc_single(par,ipop); +} diff --git a/src/common.h b/src/common.h index 7a0fdda..309c87e 100644 --- a/src/common.h +++ b/src/common.h @@ -159,7 +159,12 @@ extern int NNodes; extern int IThread0; extern int MPIThreadsOK; +#ifdef TVEL +#define NPOS_CC 6 +#else #define NPOS_CC 4 +#endif + typedef struct { int nsrc; float *pos; @@ -171,6 +176,10 @@ typedef struct { float dec; //Declination float z0; //Cosmological redshift float dz_rsd; //RSD contribution +#ifdef TVEL + float vtheta; + float vphi; +#endif float e1; float e2; float kappa; diff --git a/src/io.c b/src/io.c index ab2f065..344ce3e 100644 --- a/src/io.c +++ b/src/io.c @@ -1025,10 +1025,10 @@ static void write_catalog(ParamCoLoRe *par,int ipop) #ifdef _HAVE_HDF5 hid_t file_id,gal_types[6]; hsize_t chunk_size=128; - size_t dst_offset[9]={HOFFSET(Src,ra),HOFFSET(Src,dec),HOFFSET(Src,z0),HOFFSET(Src,dz_rsd),HOFFSET(Src,e1), + size_t dst_offset[11]={HOFFSET(Src,ra),HOFFSET(Src,dec),HOFFSET(Src,z0),HOFFSET(Src,dz_rsd),HOFFSET(Src,vtheta),HOFFSET(Src,vphi),HOFFSET(Src,e1), HOFFSET(Src,e2),HOFFSET(Src,kappa),HOFFSET(Src,dra),HOFFSET(Src,ddec)}; - const char *names[9]={"RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","K" ,"DRA","DDEC"}; - char *tunit[9]= {"DEG","DEG","NA" ,"NA" ,"NA","NA","NA","DEG","DEG"}; + const char *names[11]={"RA" ,"DEC","Z_COSMO","DZ_RSD","VTHETA","VPHI","E1","E2","K" ,"DRA","DDEC"}; + char *tunit[11]= {"DEG","DEG","NA" ,"NA" ,"NA","NA","NA","NA","NA","DEG","DEG"}; gal_types[0]=H5T_NATIVE_FLOAT; gal_types[1]=H5T_NATIVE_FLOAT; gal_types[2]=H5T_NATIVE_FLOAT; @@ -1038,6 +1038,8 @@ static void write_catalog(ParamCoLoRe *par,int ipop) gal_types[6]=H5T_NATIVE_FLOAT; gal_types[7]=H5T_NATIVE_FLOAT; gal_types[8]=H5T_NATIVE_FLOAT; + gal_types[9]=H5T_NATIVE_FLOAT; + gal_types[10]=H5T_NATIVE_FLOAT; print_info(" %d-th population (HDF5)\n",ipop); sprintf(fname,"%s_srcs_s%d_%d.h5",par->prefixOut,ipop+1,NodeThis); @@ -1072,13 +1074,21 @@ static void write_catalog(ParamCoLoRe *par,int ipop) int status=0; fitsfile *fptr; int *type_arr; - float *ra_arr,*dec_arr,*z0_arr,*rsd_arr,*e1_arr,*e2_arr,*k_arr,*dra_arr,*ddec_arr; + float *ra_arr,*dec_arr,*z0_arr,*rsd_arr,*vtheta_arr,*vphi_arr,*e1_arr,*e2_arr,*k_arr,*dra_arr,*ddec_arr; int nfields=5; +#ifdef TVEL + char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD", "VTHETA", "VPHI", "E1","E2","KAPPA","DRA","DDEC"}; + char *tform[]={"1J" ,"1E" ,"1E" ,"1E" ,"1E" , "1E", "1E", "1E","1E","1E" ,"1E!","1E"}; + char *tunit[]={"NA" ,"DEG","DEG","NA" ,"NA" , "NA", "NA", "NA","NA","NA" ,"DEG","DEG"}; + //char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","KAPPA","DRA","DDEC"}; + nfields+=2; +#else char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","KAPPA","DRA","DDEC"}; char *tform[]={"1J" ,"1E" ,"1E" ,"1E" ,"1E" ,"1E","1E","1E" ,"1E!","1E"}; char *tunit[]={"NA" ,"DEG","DEG","NA" ,"NA" ,"NA","NA","NA" ,"DEG","DEG"}; +#endif if(par->cats[ipop]->has_lensing) - nfields=10; + nfields+=5; print_info(" %d-th population (FITS)\n",ipop); sprintf(fname,"!%s_srcs_s%d_%d.fits",par->prefixOut,ipop+1,NodeThis); @@ -1093,6 +1103,10 @@ static void write_catalog(ParamCoLoRe *par,int ipop) dec_arr=my_malloc(nrw*sizeof(float)); z0_arr=my_malloc(nrw*sizeof(float)); rsd_arr=my_malloc(nrw*sizeof(float)); +#ifdef TVEL + vtheta_arr=my_malloc(nrw*sizeof(float)); + vphi_arr=my_malloc(nrw*sizeof(float)); +#endif e1_arr=my_malloc(nrw*sizeof(float)); e2_arr=my_malloc(nrw*sizeof(float)); k_arr=my_malloc(nrw*sizeof(float)); @@ -1113,6 +1127,10 @@ static void write_catalog(ParamCoLoRe *par,int ipop) dec_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dec; z0_arr[ii]=par->cats[ipop]->srcs[row_here+ii].z0; rsd_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dz_rsd; +#ifdef TVEL + vtheta_arr[ii]=par->cats[ipop]->srcs[row_here+ii].vtheta; + vphi_arr[ii]=par->cats[ipop]->srcs[row_here+ii].vphi; +#endif if(par->cats[ipop]->has_lensing) { e1_arr[ii]=par->cats[ipop]->srcs[row_here+ii].e1; e2_arr[ii]=par->cats[ipop]->srcs[row_here+ii].e2; @@ -1126,12 +1144,20 @@ static void write_catalog(ParamCoLoRe *par,int ipop) fits_write_col(fptr,TFLOAT,3,row_here+1,1,nrw_here,dec_arr,&status); fits_write_col(fptr,TFLOAT,4,row_here+1,1,nrw_here,z0_arr,&status); fits_write_col(fptr,TFLOAT,5,row_here+1,1,nrw_here,rsd_arr,&status); +#ifdef TVEL + fits_write_col(fptr,TFLOAT,6,row_here+1,1,nrw_here,vtheta_arr,&status); + fits_write_col(fptr,TFLOAT,7,row_here+1,1,nrw_here,vphi_arr,&status); + int offset = 2; + //int offset = 0; +#else + int offset = 0; +#endif if(par->cats[ipop]->has_lensing) { - fits_write_col(fptr,TFLOAT,6,row_here+1,1,nrw_here,e1_arr,&status); - fits_write_col(fptr,TFLOAT,7,row_here+1,1,nrw_here,e2_arr,&status); - fits_write_col(fptr,TFLOAT,8,row_here+1,1,nrw_here,k_arr,&status); - fits_write_col(fptr,TFLOAT,9,row_here+1,1,nrw_here,dra_arr,&status); - fits_write_col(fptr,TFLOAT,10,row_here+1,1,nrw_here,ddec_arr,&status); + fits_write_col(fptr,TFLOAT,6+offset,row_here+1,1,nrw_here,e1_arr,&status); + fits_write_col(fptr,TFLOAT,7+offset,row_here+1,1,nrw_here,e2_arr,&status); + fits_write_col(fptr,TFLOAT,8+offset,row_here+1,1,nrw_here,k_arr,&status); + fits_write_col(fptr,TFLOAT,9+offset,row_here+1,1,nrw_here,dra_arr,&status); + fits_write_col(fptr,TFLOAT,10+offset,row_here+1,1,nrw_here,ddec_arr,&status); } row_here+=nrw_here; diff --git a/src/srcs.c b/src/srcs.c index 9792ba9..eecd196 100644 --- a/src/srcs.c +++ b/src/srcs.c @@ -84,8 +84,9 @@ static inline void cart2sph(double x,double y,double z,double *r,double *cth,dou } } -static double get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, - double x0,double y0,double z0,double rr) +static void get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, + double x0,double y0,double z0,double rr, + double* rvel, double* vtheta, double* vphi) { double v[3],u[3]; double idx=par->n_grid/par->l_box; @@ -114,7 +115,12 @@ static double get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, else v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->grid_npot[ix_0+iy_0+iz_lo]; - return 0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); + *rvel = 0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); +#ifdef TVEL + *vtheta = 0.5*idx*(v[0]*(u[0]*u[2]/sqrt(1-u[2]*u[2])) + v[1]*(u[1]*u[2]/sqrt(1-u[2]*u[2])) + v[2]*(-sqrt(1-u[2]*u[2]))); + *vphi = 0.5*idx*(v[0]*(-u[1]/sqrt(1-u[2]*u[2])) + v[1]*(u[0]/sqrt(1-u[2]*u[2]))); +#endif + } static void srcs_set_cartesian_single(ParamCoLoRe *par,int ipop) @@ -250,7 +256,9 @@ static void srcs_set_cartesian_single(ParamCoLoRe *par,int ipop) if(npp>0) { int ip; double rr=sqrt(x0*x0+y0*y0+z0*z0); - double rvel=factor_vel*get_rvel(par,ix,iy,iz,x0,y0,z0,rr); + double rvel, vtheta, vphi; + get_rvel(par,ix,iy,iz,x0,y0,z0,rr, &rvel, &vtheta, &vphi); + rvel *=factor_vel; double dz_rsd=rvel*get_bg(par,rr,BG_V1,0); for(ip=0;ipcats_c[ipop]->pos[NPOS_CC*pid+1]=y0+dx*(rng_01(rng_thr)-0.5); par->cats_c[ipop]->pos[NPOS_CC*pid+2]=z0+dx*(rng_01(rng_thr)-0.5); par->cats_c[ipop]->pos[NPOS_CC*pid+3]=dz_rsd; + #ifdef TVEL + par->cats_c[ipop]->pos[NPOS_CC*pid+4]=vtheta; + par->cats_c[ipop]->pos[NPOS_CC*pid+5]=vphi; + #endif + + for(ax=0;ax<3;ax++) pos[ax]=par->cats_c[ipop]->pos[NPOS_CC*pid+ax]; @@ -409,6 +423,11 @@ static void srcs_get_local_properties_single(ParamCoLoRe *par,int ipop) par->cats[ipop]->srcs[ii].dec=90-RTOD*acos(cth); par->cats[ipop]->srcs[ii].z0=get_bg(par,r,BG_Z,0); par->cats[ipop]->srcs[ii].dz_rsd=pos[3]; + #ifdef TVEL + par->cats[ipop]->srcs[ii].vtheta=pos[4]; + par->cats[ipop]->srcs[ii].vphi=pos[5]; + #endif + par->cats[ipop]->srcs[ii].e1=-1; par->cats[ipop]->srcs[ii].e2=-1; }//end omp for @@ -634,11 +653,11 @@ void srcs_get_beam_properties(ParamCoLoRe *par) static void srcs_beams_postproc_single(ParamCoLoRe *par,int ipop) { Catalog *cat=par->cats[ipop]; - CatalogCartesian *catc=par->cats_c[ipop]; + //CatalogCartesian *catc=par->cats_c[ipop]; #ifdef _HAVE_OMP #pragma omp parallel default(none) \ - shared(par,cat,catc,NNodes,NodeThis) + shared(par,cat,NNodes,NodeThis) #endif //_HAVE_OMP { int ii; From a526e9505a4fe3ab87c78889a2bed28201c21c40 Mon Sep 17 00:00:00 2001 From: Walter3ffb <89849649+Walter3ffb@users.noreply.github.com> Date: Mon, 11 Jul 2022 14:11:52 -0400 Subject: [PATCH 2/6] Delete .ipynb_checkpoints directory --- .ipynb_checkpoints/Makefile-checkpoint | 155 ---- .../example_CoLoRe-checkpoint.ipynb | 813 ------------------ .../param_example-checkpoint.cfg | 149 ---- 3 files changed, 1117 deletions(-) delete mode 100644 .ipynb_checkpoints/Makefile-checkpoint delete mode 100644 .ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/param_example-checkpoint.cfg diff --git a/.ipynb_checkpoints/Makefile-checkpoint b/.ipynb_checkpoints/Makefile-checkpoint deleted file mode 100644 index 01fbfb7..0000000 --- a/.ipynb_checkpoints/Makefile-checkpoint +++ /dev/null @@ -1,155 +0,0 @@ -########## User-definable stuff ########## -# -###Compiler and compilation options -COMP_SER = gcc -COMP_MPI = mpicc -OPTIONS = -Wall -Wno-format-overflow -O3 -std=c99 -# -### Behavioural flags -#Use double precision integer (enable in general) -DEFINEFLAGS += -D_LONGIDS -#Use normalized bias model -DEFINEFLAGS += -D_BIAS_MODEL_2 -#Use linear bias model -#DEFINEFLAGS += -D_BIAS_MODEL_3 -#Use new lensing method -#DEFINEFLAGS += -D_USE_FAST_LENSING -#get transvers velocities -DEFINEFLAGS += -DTVEL -#Generate debug help. Only useful for development -DEFINEFLAGS += -D_DEBUG -#Use double precision floating point? Set to "yes" or "no" -USE_SINGLE_PRECISION = yes -#Add random perturbations to kappa from redshifts outside the box -#ADD_EXTRA_KAPPA = yes -#Compile with HDF5 capability? Set to "yes" or "no" -USE_HDF5 = no -#Use OMP parallelization? Set to "yes" or "no" -USE_OMP = yes -#Use MPI parallelization? Set to "yes" or "no" -USE_MPI = no -# -###Path to libraries and headers -###If two or more of the dependencies reside in the same paths, only -###one instance is necessary. -#GSL -#GSL_INC = -I/add/path -#GSL_LIB = -L/add/path -GSL_INC = -I/astro/u/anze/local/include -GSL_LIB = -L/astro/u/anze/local/lib -#FFTW -FFTW_INC = -FFTW_LIB = -#cfitsio -FITS_INC = -FITS_LIB = -#cfitsio -HDF5_INC = -HDF5_LIB = -#libconfig -CONF_INC = -CONF_LIB = -#healpix -HPIX_INC = -HPIX_LIB = -#libsharp -SHT_INC = -SHT_LIB = -# -########## End of user-definable ########## - -USE_FITS = yes -DEFINEFLAGS += -DHAVE_INLINE -DGSL_RANGE_CHECK_OFF - -ifeq ($(strip $(USE_OMP)),yes) -OPTIONS += -fopenmp -DEFINEFLAGS += -D_HAVE_OMP -endif #OMP - -ifeq ($(strip $(USE_MPI)),yes) -DEFINEFLAGS += -D_HAVE_MPI -COMP_PAR = $(COMP_MPI) -else #MPI -COMP_PAR = $(COMP_SER) -endif #MPI - -ifeq ($(strip $(USE_SINGLE_PRECISION)),yes) -DEFINEFLAGS += -D_SPREC - -ifeq ($(strip $(USE_OMP)),yes) -LIB_FFTW += -lfftw3f_omp -endif #OMP -ifeq ($(strip $(USE_MPI)),yes) -LIB_FFTW += -lfftw3f_mpi -endif #MPI -LIB_FFTW += -lfftw3f - -else #SINGLE_PRECISION - -ifeq ($(strip $(USE_OMP)),yes) -LIB_FFTW += -lfftw3_omp -endif #OMP -ifeq ($(strip $(USE_MPI)),yes) -LIB_FFTW += -lfftw3_mpi -endif #MPI - -endif #SINGLE_PRECISION - -# for fftlog -LIB_FFTW += -lfftw3 - -OPTIONS += $(DEFINEFLAGS) - -INC_ALL = -I./src $(GSL_INC) $(FFTW_INC) $(FITS_INC) $(HDF5_INC) $(CONF_INC) $(SHT_INC) $(HPIX_INC) -LIB_ALL = $(GSL_LIB) $(FFTW_LIB) $(FITS_LIB) $(HDF5_LIB) $(CONF_LIB) $(SHT_LIB) $(HPIX_LIB) -lconfig -lgsl -lgslcblas $(LIB_FFTW) -lcfitsio -lchealpix -ifeq ($(strip $(ADD_EXTRA_KAPPA)),yes) -#DEFINEFLAGS += -D_ADD_EXTRA_KAPPA -D_WITH_SHT -#LIB_ALL += -lsharp -lfftpack -lc_utils -endif #EXTRA_KAPPA -ifeq ($(strip $(USE_HDF5)),yes) -DEFINEFLAGS += -D_HAVE_HDF5 -LIB_ALL += -lhdf5 -lhdf5_hl -lz -endif #HDF5 -ifeq ($(strip $(USE_FITS)),yes) -DEFINEFLAGS += -D_HAVE_FITS -#LIB_ALL += -lcfitsio -endif #FITS -LIB_ALL += -lm - -COMMONO = src/common.o -COSMOMADO = src/cosmo_mad.o -COSMOO = src/cosmo.o -FOURIERO = src/fourier.o -DENSO = src/density.o -SRCSO = src/srcs.o -IMAPO = src/imap.o -CSTMO = src/cstm.o -KAPPAO = src/kappa.o -LENSINGO = src/lensing.o -ISWO = src/isw.o -IOO = src/io.o -HPIXO = src/healpix_extra.o -BEAMO = src/beaming.o -PREDICTO = src/predictions.o -FFTLOGO = src/fftlog.o -MAIN = src/main.c -OFILES = $(COMMONO) $(COSMOMADO) $(COSMOO) $(FOURIERO) $(DENSO) $(BEAMO) $(IOO) $(HPIXO) $(SRCSO) $(IMAPO) $(CSTMO) $(KAPPAO) $(LENSINGO) $(ISWO) $(FFTLOGO) $(PREDICTO) -#OFILES = $(COMMONO) $(COSMOMADO) $(COSMOO) $(FOURIERO) $(DENSO) $(LCO) $(IOO) $(HPIXO) $(PIXO) $(PREDICTO) $(FFTLOGO) - -EXEC = CoLoRe - -default : $(EXEC) - -%.o : %.c - $(COMP_CC) $(OPTIONS) $(INC_ALL) -c $< -o $@ - -$(OFILES) : COMP_CC := $(COMP_PAR) - -$(EXEC) : $(OFILES) - $(COMP_PAR) $(OPTIONS) $(INC_ALL) $(OFILES) $(MAIN) -o $(EXEC) $(LIB_ALL) - -clean : - rm -f src/*.o - -cleaner : - rm -f *~ src/*.o src/*~ $(EXEC) diff --git a/.ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb b/.ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb deleted file mode 100644 index b2d9d3b..0000000 --- a/.ipynb_checkpoints/example_CoLoRe-checkpoint.ipynb +++ /dev/null @@ -1,813 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "31b70d10", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import numpy as np\n", - "import pyccl as ccl\n", - "import healpy as hp\n", - "import matplotlib.pyplot as plt\n", - "import libconf\n", - "from scipy.integrate import simps\n", - "from astropy.io import fits" - ] - }, - { - "cell_type": "markdown", - "id": "1e7130ab", - "metadata": {}, - "source": [ - "This notebook shows how to generate a CoLoRe simulation and analyse its outputs." - ] - }, - { - "cell_type": "markdown", - "id": "04bfc9d6", - "metadata": {}, - "source": [ - "# 1 Generating inputs\n", - "Let's simulate a set of low-redshift tracers:\n", - "- A galaxy sample with median redshift $z\\sim0.045$ including RSDs, lensing observables and density/velocity skewers.\n", - "- A set of 21cm intensity maps.\n", - "- A lensing convergence for a source plane at $z=0.1$.\n", - "- An ISW map for a source plane at $z=0.1$.\n", - "- A custom projected tracer with a kernel $W(z)=(0.1-z)$.\n", - "\n", - "We start by defining the properties of the CoLoRe simulation box and the linear power spectrum to be used." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e8c2d567", - "metadata": {}, - "outputs": [], - "source": [ - "z_max = 0.15\n", - "n_grid = 256\n", - "csm = {'omega_M': 0.3,\n", - " 'omega_B': 0.3,\n", - " 'omega_L': 0.7,\n", - " 'h': 0.7,\n", - " 'w': -1.0,\n", - " 'ns': 0.96,\n", - " 'sigma_8': 0.8}\n", - "dirname_out = 'output'\n", - "os.system(f'mkdir -p {dirname_out}');\n", - "\n", - "cosmo = ccl.Cosmology(Omega_c=csm['omega_M']-csm['omega_B'],\n", - " Omega_b=csm['omega_B'],\n", - " h=csm['h'],\n", - " sigma8=csm['sigma_8'],\n", - " n_s=csm['ns'],\n", - " transfer_function='eisenstein_hu')\n", - "k_h = np.geomspace(1E-4, 100, 1024)\n", - "pk_h = ccl.linear_matter_power(cosmo, k_h*cosmo['h'], 1.)*cosmo['h']**3\n", - "np.savetxt(f'{dirname_out}/pk.txt', np.transpose([k_h, pk_h]))" - ] - }, - { - "cell_type": "markdown", - "id": "df2bd0c4", - "metadata": {}, - "source": [ - "Let's generate the inputs needed for the galaxy sample" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d430cafe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.04513716654216523\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Redshift distribution\n", - "ngals = 1E5\n", - "ndens = ngals / (4*np.pi*(180/np.pi)**2)\n", - "zs = np.linspace(0, 0.2, 1024)\n", - "nz = zs**2*np.exp(-(zs/0.03)**1.5)\n", - "nz *= ndens / simps(nz, x=zs)\n", - "\n", - "# Linear bias\n", - "bz = (1+zs)\n", - "\n", - "np.savetxt(f'{dirname_out}/dndz.txt', np.transpose([zs, nz]))\n", - "np.savetxt(f'{dirname_out}/bias.txt', np.transpose([zs, bz]))\n", - "plt.plot(zs, nz)\n", - "plt.ylim([0, np.amax(nz)*1.1])\n", - "plt.xlim([0, z_max])\n", - "plt.xlabel(r'$z$', fontsize=14)\n", - "plt.ylabel(r'$dN/dzd\\Omega\\,\\,[{\\rm deg}^{-2}]$', fontsize=14)\n", - "print(np.average(zs, weights=nz))" - ] - }, - { - "cell_type": "markdown", - "id": "063c53d0", - "metadata": {}, - "source": [ - "Now let's generate the input needed for the custom tracer." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "49e3c406", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$W(z)$')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "wz = (0.1-zs)\n", - "wz[zs > 0.1] = 0\n", - "np.savetxt(f'{dirname_out}/wz.txt', np.transpose([zs, wz]))\n", - "\n", - "plt.plot(zs, wz)\n", - "plt.xlim([0, z_max])\n", - "plt.ylim([0, np.amax(wz)*1.1])\n", - "plt.xlabel(r'$z$', fontsize=14)\n", - "plt.ylabel(r'$W(z)$', fontsize=14)" - ] - }, - { - "cell_type": "markdown", - "id": "9fb3ddd0", - "metadata": {}, - "source": [ - "Almost there. Now generate inputs needed for the intensity mapping observations." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ddb406d4", - "metadata": {}, - "outputs": [], - "source": [ - "# Constant background temperature T_HI = 0.05 mK\n", - "tz = 0.05 * np.ones_like(zs)\n", - "\n", - "nu_ref = 1420.\n", - "nu0 = nu_ref / (1+0.14)\n", - "nu1 = nu_ref / (1+0.04)\n", - "n_nu = 5\n", - "nu_arr = np.linspace(nu0, nu1, n_nu+1)\n", - "\n", - "np.savetxt(f'{dirname_out}/tz.txt', np.transpose([zs, tz]))\n", - "np.savetxt(f'{dirname_out}/nuTable.txt', np.transpose([nu_arr[:-1], nu_arr[1:]]))" - ] - }, - { - "cell_type": "markdown", - "id": "8a8cf15c", - "metadata": {}, - "source": [ - "Finally, pick a source plane for the ISW and convergence maps" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5a9fba94", - "metadata": {}, - "outputs": [], - "source": [ - "z_source = 0.1" - ] - }, - { - "cell_type": "markdown", - "id": "7c76c433", - "metadata": {}, - "source": [ - "Before we can run CoLoRe, we need to create the config file. We will use 1st-order LPT as a structure formation model." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "09d51cc4", - "metadata": {}, - "outputs": [], - "source": [ - "config = {}\n", - "config['global'] = {'prefix_out': dirname_out + '/colore',\n", - " 'output_format': 'FITS',\n", - " 'output_density': True,\n", - " 'pk_filename': f'{dirname_out}/pk.txt',\n", - " 'z_min': 0.0001,\n", - " 'z_max': z_max,\n", - " 'seed': 1000,\n", - " 'write_pred': False,\n", - " 'just_write_pred': False}\n", - "config['field_par'] = {'r_smooth': 1.,\n", - " 'smooth_potential': True,\n", - " 'n_grid': n_grid,\n", - " 'dens_type': 1,\n", - " 'lpt_buffer_fraction': 0.6,\n", - " 'lpt_interp_type': 1,\n", - " 'output_lpt': 0}\n", - "config['cosmo_par'] = csm\n", - "# Note: if you need more than one sample of galaxies/intensity maps/custom tracers etc.\n", - "# just add `srcs2` `imap2` etc.\n", - "config['custom1'] = {'kz_filename': f'{dirname_out}/wz.txt',\n", - " 'bias_filename': f'{dirname_out}/bias.txt',\n", - " 'nside': 64}\n", - "config['srcs1'] = {'nz_filename': f'{dirname_out}/dndz.txt',\n", - " 'bias_filename': f'{dirname_out}/bias.txt',\n", - " 'include_lensing': True,\n", - " 'store_skewers': True}\n", - "config['imap1'] = {'tbak_filename': f'{dirname_out}/tz.txt',\n", - " 'bias_filename': f'{dirname_out}/bias.txt',\n", - " 'freq_list': f'{dirname_out}/nuTable.txt',\n", - " 'freq_rest': 1420.0,\n", - " 'nside': 64}\n", - "config['kappa'] = {'z_out': [z_source],\n", - " 'nside': 64}\n", - "config['isw'] = {'z_out': [z_source],\n", - " 'nside': 64}\n", - "with open(f'{dirname_out}/params.cfg', 'w') as configfile:\n", - " libconf.dump(config, configfile)" - ] - }, - { - "cell_type": "markdown", - "id": "c4c19d02", - "metadata": {}, - "source": [ - "# 2 Run CoLoRe\n", - "Now just run the code" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "80697c00", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "os.system(f'LD_LIBRARY_PATH=/astro/u/wcook/ ./CoLoRe2 {dirname_out}/params.cfg > {dirname_out}/log.txt')\n", - "f = open(f'{dirname_out}/log.txt', 'r')\n", - "print(f.read())\n", - "f.close()" - ] - }, - { - "cell_type": "markdown", - "id": "69c3b9cc", - "metadata": {}, - "source": [ - "/astro/u/anze/local/lib/# 3 Inspect output\n", - "Let's now look at the output\n", - "\n", - "## 3.1 Custom tracer\n", - "CoLoRe produces healpix maps for each custom projected tracer:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "532583ee", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:368: UserWarning: If you are not specifying the input dtype and using the default np.float64 dtype of read_map(), please consider that it will change in a future version to None as to keep the same dtype of the input file: please explicitly set the dtype if it is important to you.\n", - " warnings.warn(\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:391: UserWarning: NSIDE = 64\n", - " warnings.warn(\"NSIDE = {0:d}\".format(nside))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:400: UserWarning: ORDERING = RING in fits file\n", - " warnings.warn(\"ORDERING = {0:s} in fits file\".format(ordering))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:426: UserWarning: No INDXSCHM keyword in header file : assume IMPLICIT\n", - " warnings.warn(\"No INDXSCHM keyword in header file : \" \"assume {}\".format(schm))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:428: UserWarning: INDXSCHM = IMPLICIT\n", - " warnings.warn(\"INDXSCHM = {0:s}\".format(schm))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:920: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", - " newcm.set_over(newcm(1.0))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:921: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", - " newcm.set_under(bgcolor)\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:922: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", - " newcm.set_bad(badcolor)\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:202: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n", - " aximg = self.imshow(\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "m = hp.read_map(f\"{dirname_out}/colore_custom_s1.fits\")\n", - "hp.mollview(m, title='Custom tracer')" - ] - }, - { - "cell_type": "markdown", - "id": "012cd628", - "metadata": {}, - "source": [ - "## 3.2 Source catalogs\n", - "Galaxy samples are stored as FITS tables. Below we read this catalog, plot its redshift distribution, and maps of the galaxy overdensity, mean redshift distortions, and mean galaxy ellipticities." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bd3d1ffe", - "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" - }, - { - "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" - } - ], - "source": [ - "cat = fits.open(f\"{dirname_out}/colore_srcs_s1_0.fits\")[1].data\n", - "nside = 32\n", - "npix = hp.nside2npix(nside)\n", - "ipix = hp.ang2pix(nside, cat['RA'], cat['DEC'], lonlat=True)\n", - "ncount = np.bincount(ipix, minlength=npix)\n", - "goodpix = ncount > 0\n", - "nmean = np.mean(ncount)\n", - "delta = ncount/nmean-1\n", - "dzrsd = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", - "vtheta = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", - "vphi = np.bincount(ipix, minlength=npix, weights=cat['DZ_RSD'])\n", - "dzrsd[goodpix] = dzrsd[goodpix] / ncount[goodpix]\n", - "e1 = np.bincount(ipix, minlength=npix, weights=cat['E1'])\n", - "e1[goodpix] = e1[goodpix] / ncount[goodpix]\n", - "e2 = np.bincount(ipix, minlength=npix, weights=cat['E2'])\n", - "e2[goodpix] = e2[goodpix] / ncount[goodpix]\n", - "hp.mollview(delta, title=r'$\\delta$')\n", - "hp.mollview(dzrsd, title=r'$\\Delta z_{\\rm RSD}$')\n", - "hp.mollview(vtheta, title=r'$vtheta$')\n", - "hp.mollview(vphi, title=r'$vphi$')\n", - "hp.mollview(e1, title='$e_1$')\n", - "hp.mollview(e2, title='$e_2$')" - ] - }, - { - "cell_type": "markdown", - "id": "6322ae20", - "metadata": {}, - "source": [ - "## 3.3 Density/velocity skewers\n", - "The source catalogs are also endowed with \"skewers\" containing the density and radial velocity along galaxy lines of sight." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "66d7a6c3", - "metadata": {}, - "outputs": [], - "source": [ - "d_skw = fits.open('output/colore_srcs_s1_0.fits')[2].data\n", - "v_skw = fits.open('output/colore_srcs_s1_0.fits')[3].data\n", - "bkg = fits.open('output/colore_srcs_s1_0.fits')[4].data\n", - "r = bkg['R']" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "3e0b0bd4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEOCAYAAACJlmBtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABTeklEQVR4nO2dd3hb5fmw71eS5W0nXokznb1DdkLCCGFvUkZTChQo0FJaCoW29Ef5oAXaQlugLbuFAmWXMsIqq2GFkODsPZ0d78S2PGRZer8/XsmWbclTsSTrua/L15GOjo6ecyyd5zxbaa0RBEEQBEu4BRAEQRAiA1EIgiAIAiAKQRAEQfAiCkEQBEEARCEIgiAIXmzhFqA7ZGVl6by8vHCLIQiCEFWsXLmyVGud3XJ9VCuEvLw88vPzwy2GIAhCVKGU2hNovbiMBEEQBEAUgiAIguBFFIIgCIIAiEIQBEEQvIhCEARBEABRCIIgCIIXUQiCIAgCIApBEIRoRmtY8yLU14Rbkl6BKARBEKKXsp3w5vWw5d1wS9IrEIUgCEL04qw0y7ojYRWjtyAKQRCE6MVVa5b1jvDK0UsQhSAIQvTiUwhOUQihQBSCIAjRi8sbTBYLISSIQhAEIXrxKQSxEEKCKARBEKKXRguhKrxy9BJEIQiCEL1IDCGkiEIQBCF6kRhCSBGFIAhC9CIWQkgRhSAIQvRSLxZCKBGFIAhC9CIuo5AiCkEQhOhFXEYhRRSCIAjRi89CcDvB7QqvLL0AUQiCIEQvPgsBwCm1CN1FFIIgCNGLy28OgsQRuo0oBEEQohd/hSBxhG4jCkEQhOjFVQvxaeaxWAjdRhSCIAjRi6sWUnLMY4khdJuIUwhKKatSarVS6p1wyyIIQoRTXw3JXoUgFkK3iTiFAPwU2BxuIQRBiAJctZCSbR5LDKHbRJRCUEoNAs4G/hFuWQRBiHA8HmioFQshhESUQgAeAn4BeIJtoJS6TimVr5TKLykp6THBBEGIMBrqzFJiCCEjYhSCUuocoFhrvbKt7bTWT2qtZ2itZ2RnZ/eQdIIgRBy+orSEPmCJEwshBESMQgDmAecppXYDLwMLlFLPh1ckQRAiFle1WdqTID5FYgghIGIUgtb6V1rrQVrrPGAR8D+t9WVhFksQhEjFZyHEJYI9VSyEEBAxCkEQBKFT+KqU45LAniwxhBBgC7cAgdBafwp8GmYxBEGIZPwthPgUsRBCgFgIgiBEJ80sBIkhhAJRCIIgRCf1fgpBLISQIApBEITopGVQWSyEbiMKQRCE6MTV0kKQoHJ3EYUgCEJ00sxC8MYQtA6vTFGOKARBEKITX2Gaz0LQ7qZ2FkKXEIUgCEJ04qoFZQVrnIkhgMQRuokoBEEQohNXrSlIU8pYCCBxhG4iCkEQhOjEVWPiB2BiCCAWQjcRhSAIQnTiqm1SCI0WgiiE7iAKQRCE6KS+2gSUQWIIIUIUgiAI0UlAC0FiCN1BFIIgCNGJq9bPQpAYQigQhSAIQnTiqmlSCBJDCAmiEARBiE78XUYSQwgJohAEQYhO/C0Eqw1sCWIhdBNRCIIgRCf+dQhg4giiELqFKARBEKITVy3Yk5qex8uQnO4iCkEQhOhD6+YuIzBxBLEQuoUoBEEQog//1tc+4lPAKXUI3UEUgiAI0UejQvC3ECSG0F1EIQiCEH00TktraSGIQugOohAEQYg+xEI4KohCEAQh+vCfp+wjPlUshG4iCkEQhOgjkMsoId00t3O7wiNTL0AUgiAI0UcgCyE5yyxrynpenl5CxCgEpVSCUmqFUmqtUmqjUuo34ZZJEIQIJVDaaZJXIVSX9rw8vQRbuAXwwwks0Fo7lFJxwJdKqfe11l+HWzBBECIMn0KwJzetS842y+qSnpenlxAxCkFrrQFfRCjO+6fDJ5EgCBFLoBiCuIy6TcS4jACUUlal1BqgGPhIa708wDbXKaXylVL5JSVyJyAIMUl9IIUgFkJ3iSiFoLV2a62nAIOAWUqpiQG2eVJrPUNrPSM7O7vHZRQEIQIIFFRO6APKKjGEbhBRCsGH1voI8ClwRnglEQQhInHVgrKA1d60zmKBpEyxELpBxCgEpVS2UqqP93EicAqwJaxCCYIQmfjmKSvVfH1ylsQQukHEBJWBXOBZpZQVo6he1Vq/E2aZBEGIRFq2vvaRnCUWQjeIGIWgtV4HTA23HIIgRAEtp6X5SMqCQ2t7Xp5eQsS4jARBEDpMUAshW4LKAXhj9X7ufXdTu9uJQhAEIfpw1Qa2EJKzwFkBDfU9L1ME8+HGIt5ee6jd7UQhCIIQffiCyi1pLE4TK8GfyjoX9W5Pu9uJQhAEIfqod4A9gEKQfkYBqah1Ud8gCkEQhN6Is8rMP2iJVCsHpKJWLARBEHorTkcQhSD9jAJRUWMsBNMyLjiiEARBiD6CWQhJmWYpFkIjHo+mytkAgMstCkEQhN6E2wUNtRCf1vq1hD5gsUkMwY8qZwM+w6A9t5EoBEEQogtnlVnaU1q/Jv2MWlFZ2zRS1NVOYFkUgiAI0UW9d2xKIJcRmMCyxBAaqfBTCGIhCILQu/BZCMEUglgIzfC3ENpLPRWFIAhHiZIqJy+v2BtuMXof7SkEaV/RDH8LwSkKQRDCw1trDnDb6+spczjDLUrvwtmeyyhLFIIflXV+MQRxGQlCeKiqM6l+NfXuMEvSy3BWmmVbCqG+Clx1PSdTBFMhLiNBCD/VTlEIR4V2YwjSz8gfCSoLQgRQXd/QbCmEiI5kGYG4jbxU1jZ9/8RCEIQw4XAay6BWLITQ0lYdAjS1rxCFAIiFIAgRQY24jI4OziqISwaLNfDrPgtBXEaAUQg2i5k9LRaCIIQJR6NCEJdRSHFWBncXgfQzakFlnYuslHhAFIIghA1f7EAshBDjdEB8EHcRQEI6WOLEZeSlotZFdqooBEEIK9XeGIIohBATrNOpD6UgKQNqy3tOpgimstZFVoodkDoEQQgbjS4jp7iMQkp7CgHAliB1CIDWmsrahiaXkSgEQQgPjUFll1gIIaXeEbj1tT9xidAgCqHO5aHe7RGXkSCEE49HU+11FYmFEGKclcFTTn3Y4qFBWob4Uk59FoL0MhKEMOBvFUgMIcR0yGWUaIboxDiNCsFrIUgMQRDCQLWfVSAuoxCidQcVglgI0NTYrm9SHDaLEpeRIIQDh79CEJdR6Ghwgqehg0FlsRAqaoxCSE+MI85qiR6FoJQarJRaopTarJTaqJT6abhlEoSu0sxCEJdR6GivsZ2PuASxEGhyGaUlxGG3WdrNMrL1hFAdpAG4RWu9SimVCqxUSn2ktd4UbsEEobP4ahDibRZqxWUUOtprfe3DliBZRjS5jNITjUKImhiC1vqQ1nqV93EVsBkYGF6pBKFr+CyEnLT4ZtaC0E3a63TqQxQC4GchJMZht1qiM8tIKZUHTAWWB3jtOqVUvlIqv6REepUIkYmvbUV2Srx0Ow0lHXUZiUIAjEJIjbdhtSjjMoo2haCUSgH+A9ykta5s+brW+kmt9Qyt9Yzs7OyeF1AQOoAvqJydGi9ZRqGkvdbXPmzxUqmMmYWQlhgHgD2agsoASqk4jDJ4QWv9erjlEYSuUu2vEJyiEEJGo4XQgUplt9OkqcYwFbWuJoUQTTEEpZQCngI2a60fCLc8gtAdfEHlzOR46t0eGtr5IQodpMMuI1OIFeuZRpW1LtITTe5QR7KM2lQISqn/p5Q61fu4r1LqXqXUP5VStyqlBoVKaC/zgMuBBUqpNd6/s0L8GYLQI1Q7G0iyW0lNMD/GULmN3B5NcWUMu0IaFUJ7LqNEs4zxauXKOhdpCcZCiLN2vzDth0Ch9/G/gfOAkcDtwC6l1E3dEdYfrfWXWmultZ6stZ7i/XsvVPsXhJ6kur6B5HgbiXYz1StUbqM3Vx9g7h/+x6aDrcJrsYGzCpQF4pLa3k4sBMC4jNIbXUbWbiuEDKBUKTUCWKa1nqS1Ph7IBm4A7lFKXdBtqQWhl+FwukmJt5HkUwghmpp2qKKWBo/mrrc3omPRP17vMO4ipdrezpZgljGeadRMIVgt1Lvb/s60pxDKMUrhZOBx30qtdYPW+u/ArcAvuiOwIPRGfC6jJLvXZRSi1NOqOqNYVhSU8866QyHZZ1ThrGo/oAymUhliOtPI5fZQU+9uDCrH2yzUN7T9PWxPIXwMPAjcAvQL8PonwITOiyoIvZtqp3EZNVkIoVEIlXUNZCTbmTAgjd+/tzn25jV3pPU1iIWACSgDjRZCnFV1e0DOLUAlsBWYq5Ra5E0N9XE+INVhgtCC6vqGo+IycjgbSE+M485zJ3Cwoo6/f14Qkv1GDR3pdAqiEGiqUk73SzttL4bQZi8jrXUJcBGAUsoCPAA8qZTaDiQDo4BfdVNuQeh1VDvdJGfZGl1GoapWrqpzkZpgY9awDI4ZlM6K3WWYn2GM4HRAQnr724lCoNLrXkzzSzt1dTOG0IjW2qO1vgmTHvoW8AFwmdb6/q6JKwi9F4ezgZR4a6OFUB0iheCoM5YHQGZKfONdYMzQaQshdrOMKv06nQLYre1nGXW626nWej2wvvPiCULsYILKTWmntSFyGVXVNZCXZVIu0xPj2FZUFZL9Rg3OqvZrEMAvqBy7dQi+9ikpCX6FadHUukIQegMej6am3k1yvI3kEGcZGcvD3PGlJ8bFnoVQ7+hYlpFYCDi8LiOfRWn3BpXbSlcWhSAIIcZXlZwSbyUxLrQuo0pvDAGMQqiqa8DtiZF6BI+nCy4jsRBS45uCykCbcQRRCIIQYnyN7ZLjbVgsioQ4S0hcRh6PxuFsIM2rEPokmR96ZaxYCa5qQEsMoYM4Gr+H5qbEpxDaSj0VhSAIIabRd+s11ZPttpBYCDUuN1o3+YR96YRHYkUhdLT1Nfi1rojdLCOHs4HEOCs2q7nM273LtuIIohAEIcQ0Wgje+EGi3RqStNMq7zjE1ISmGAIQO3EEZwenpUGThRDDlcpVdQ2NNw8AcTZRCILQ4/gshCSvqZ5st4WkMK1lkNDnMjpSU9/tfUcFHZ2FAGC1gcUW8xaC77sCTRZCWzMRRCEIQojxdTb1/RgT7daQZBn5Co1SW7iMYsdC8HZ47UjaKZgW2LGsEOpczRWC10Joa66yKARBCDG+ecrJ3h9jUogUQpPLyKcQ7EAMKYT6TriMwMQRYlkhtLAQ4sVlJAg9T8ugcpLdFhKF0JhG2DKGUBMjCqGj09J82BJiOsuoVQzBKllGgtDj+Kedgs9C6H4MoaqFy8hus5Bkt8aOheAoMsukzI5tH5cQ05XK1fUNpAZwGUkMQRB6EIc3hpDkLUoLlcuoZVAZjJUQM2mn5QWQlCUWQgdxtLAQJO1UEMJAjXc4jsVipnol2W0hSztVqimdFWKsfcXh3ZAxrOPb2xJitlJZa906y0hiCILQ8/jmKftIsluprm/o9sjLKmcDKXZbo6IBr0KIlRjC4QLom9fx7WPYQnA2eHC5dbPvoS+GIFlGgtCD+OYp+0i0W9G67R9iR6iqa2iMH/jokxQjFkJDPVTsh76dsRBiN8uoKQGhdZaRxBAEoQcx4zOtjc+TQzRGs6rO1cwnDL4YQgwUplXsA+3pnMsoLjFmK5UDxZvEZSQIYcDhnYXgw/fYl33Unf36Uk59xEwModw7KlQshA7RMvUZpLmdIISF6hbBvMYhOa7uWgiBXEZ26lwe6rq574jnsFchdCqoHLuVyr4U5YB1CGIhCELP4RuO48PnPuquy8h/fKaPtMQYaYFdXmAu8Cn9Ov6eGLYQqlvMQgCpQxB6A188AB/+OtxSdArfPGUfiXHeqWnddBlV1rV2GfWJlRbYvgwjpdrdtJEYzjJqOT4TmuoQoibLSCn1tFKqWCm1IdyyCBHCymdg01vhlqJTVDsbmtUKJIUoqOxwulq5jGKmwV1naxAgpiuVq1oMx4HoLEx7Bjgj3EIIEULlITiyB6oKoZs5/D2Fb55yUiCXUTf8/C63hzqXp1krAvBvgd2LFYLWRiF0JqAMxkLQbnB3v21ItOHLMvJ3GVksCptFRU9QWWv9OVAebjmECGHf12bprofaw+GVpYNUNfpu/YPK3XcZBQoSQoxYCI4icNV03kJonJoWe1aCw+nC6h3f6o/dZsEVRRZCuyilrlNK5Sul8ktKSsItjnA02bu86XHVofDJ0QkKSqsBGJyR1LjO19OoOy6jxju+VjEE0wK7Vw/J6UrKKZggNMRkHMGXgKBaxFzsNkv0WAgdQWv9pNZ6htZ6RnZ2drjFEY4me5eB3dvILEoUwrYi06J5TP+mBmy+yWndSTutbDELwUdqgg2lenmWkS/ltDNtKyCm5ypXOVtnpIGJI7QVQ2j9DkGIBJwOKFwPEy+E9a+aOEIUsK2winibhSF+FoLdasFqUd0qTHMEcEWB8QunJQTuePrN7nJ2l1aTHG8jJzWe6UP7trpjjArKC0BZoM+Qzr0vzmshxGC1siNAzQqYWgRRCEL0cWClCQiOP98ohMoosRCKHYzITsHq14BOKUVSXPdaYFcFcRlB4GplrTVX//ObxpgGwPs/PZ5xuR2YRxxpHC6AtEFgs3fufTFsIVTXB7YQ4qPJZaSUeglYBoxRSu1XSn0/3DIJYWLfckBB3nGQmBE1LqPtRVXN3EU+kuKt3WqB7XCaC37LoDJ4+xm1yDI6VFFHlbOBW08bzV+/M9W7LkqDq+UFkJHX+ffZEswyRmMIyYFcRra2LYSIUgha6+9orXO11nFa60Fa66fCLZMQJvYug5zxkNgHUnOjwmVUUeviUEUdo/q1HgKfZLc1zlruCi2npfkTqOPpzhIzf3hGXgZTBvUBoMwRJPBc8Dn8fQHUVXZZvqNKV1JOwU8hRKki7AZVzoaANw+9LqgsxAAeN+z7BobMNs9T+0eFhbCj2BtQ7tfaQkiOtzbGAbpCWwohLYDLaGexUQgjslPISDGulvLqIAph8zvGRReJBYB1FVBT2vmUU/BTCLHnMnLUNbSKN0H7MQRRCELkUbwJ6qtg8BzzPEoshK2F5iI8OoBC6Jtk53CwC3IHqKprwG61EG+ztnqtTwCFsKPEQVqCjawUO8l2K3abJbhCOLjaLNe+1GX5jhrFW8wye2zn3xvnVQixGFRuI8tIehkJ0UXRJrMcYHzfpPY3xUkerw/e44lI98a2oioS46wM7JPY6rXMZDtl3VIIrdtW+PAFlf0nsu0srmZETgpKKZRSwT/f7YLCdSa9d8/Sppz/SKGkGwohRi0Et7daPqjLSCwEIarwuYfScs0ytb/JOKouNc9X/wv+PBaO7A2PfEHYXlzF6H4pzUZc+shMiQ9+h94BHEF8wmBiCG6PbuaS2lniYGR2UywjI9ke+PNLtpgL5gm3AArWvtxlGY8KJVsgLgn6DO38exuzjGIrqBxoFoIPu80SPc3tBAEw1kBcMsR7XS+pXsXgUxS7vwRXtemEGkFsLXQwKoC7CMwFuabe3eVMo0CzEHz42lf4Mo0q61wUVzkZkdNcIQS0EHzuorHnwrATjNvI071RnyGleDNkjQZLFy5VjZXKsRVUDjQ+04cElYXoo6rQWAU+GhWCN47gu4itfj5irITy6npKHc6AAWWALG9gt6y6a3erVXWugHd8AOne9hW+OIJ/QNlHZrKd8kCffXA1xKdBxnCYcqlpJrh3WZdkPCqUbOmauwhi1kKobux0KjEEoTfQSiF4H1cdMrGDsu0w/UrTG/+LP4dFxJb4WlYESjkFyEg2F6euuo2qAsxC8JHeYkjOzhLTT2lEdnKzzy8PlHZ6cDXkHmPuwMedC/YUWPdKl2QMObVHzP88p4sKobFSObYshKoA85R9tNe6QhSCEHk4WiiElBxAGUVRuM6sG3sOTLsiYqyE7V6FECjDCIzLBtqoBWiHtlxGPutjT3kNADuKHcRZVbP2GZkpdqrr3c1HbTY4oXBDU/DengyDZ5mWIZFAyVazzB7XtfdbvZXNMWYhtOsyEoXQRTYthv0rwy1FbKG1ufCn+CkEaxwkZ5u7RZ+7KHcKHPcz0+Pmq4fDIqo/24ocpMbbyE1PCPh6k8uoawrB4QycVw4wMieF4VnJ/Dt/H2ACynmZydisTT9vn0JqZqEUbwKPq0khgOkXVLGvSzKGnJLNZtlVC0Ep79S02MoycjRaCK0tSlEIXUVrWPwT+OwP4ZYktnBWmd73qS1m56b2N4ri4BrT1yYlG9IHwpBjTVFVmNldVs2w7OSgzeOaLsidv1vV2mQQBXMZKaW4dPYQVu09wuZDlewscTSLHzT/fD+F4FOuA6c1rUsfDNUlUF/TaTlDTrE3wyi9k03t/IlFhdBGm5M4qwWXO/iwKVEIwag8CHVHoHR7uCWJLRxFZukLJPtIzW2yEAZMaVqfOQLKd/aYeMEorKijf1pg6wCMP9dutXTJZVRT78bt0UHTTgEunDYIu83Cc8t2s6eshhE5yc1ez0wOYKEcXA2JfZundPoeR4KVULIZssd0LcPIRwwqhDZjCJJl1EWKNprlkT09Vumoteb8R5by0orw+8TDhi+1NCWAhVBeYC7+/gohY4SZplYT3kF7hZV19A/iLgJzF5+Z0rXiNN9dve8uPxB9k+2cPSmXV/P34/ZoRuYEsxD8LJSDq2HAVDYXVnHLq2tpcHuaWkxHQFyGkq1dzzDyEZcQc5XKbdUhxNvavuSLQghGkTewpj1QvqtHPrKwso61+440+oJjkqo2LIR6E7ht5vPOHGGWPfQ/CkRNfQNVdQ1tKgRoozisHUoc5iKenRLf5nbfnT0Et8e4A1q6jDK9WU6NFkrtYZPjnzuFf+fv5z+r9pugdKNC2NNpOUOKL8OouwohBi0ER10DiXHWZi3YfditohC6RtFGUN6+MaXbeuQjtxWZ/PHV+450q6o1qvFZCIFiCD5y/RRChlchlIXPbVRYYS44bbmMwFQrlzk6H0PwXcQzU9qeBzB9aF9Ge9Neh7dQCGmJNmwW1fS9+uYp8DTAhIWs3GOsq33lNcYys9rDbyH4WlbkdDHDyIctPuayjKrrg1e1x1nbHpAkCiEYRRtNL37osTjCtkJzB6w1fLE9RudFO4pMhWl8i0EuPoshfTAkZzat7zvUZBqFMY5QWNlBhdDFfkalXiWS1Y6FoJTitjPHcuXcvFbuAqUUfX0WiqsOlj8OI06mNnMCGw+avlD7D9caf336IDgSZiu12Jth1G0LITHmKpWrgnQ6BbAHaI7ojyiEQLjqjBIYPMtcgHrIQthaVEVWip3MZDtLthT3yGdGHL6itJbZOj4LwT9+AOYOMH1QWC2EIq9C6HeUXEalVUYhtGchACwY24+7zpsQ8LVGhbT2RZNJdNxNrN1/hAavm2n/Ye+Fs8+QyLAQ4pLN7687xKCF0FbfK7vEELpA6VbTTK3fBMgc2WMKYXtRFWP7p3HC6Gw+317a6A+OKVpWKftIHwQoGDi99WsZ4c00KqwwF5z2XUZd62dUVl1PaoItYOvrzpCRbOeIoxa++hsMmAZ5x7Nyz2EjW7Kd/Ye9qaaRoBB2fWaUf3cyjMBUK8dYpbKjLnDraxCF0DV8GUb9JprGWmU7jB/nKOLxaLYVORjVL4X5Y7Ipr65n3f4jR/UzIxJHYesMI4DkLLjiTZh1XevXMkdA2a6j/j8KRlFlHanxtoC9Y/xpSv3s3B1ricPZbkC5I2Qk25lY8ZkJwM/7KSjFyj2HGZmTwrjctOYWQnVx+C6kxZtNyun4C7q/r1i1EIIpBIkhdIHCDSY7IWM4ZI2CesdRn9i1/3AttS43Y/qlcsKobCwKlmyNwThCVVHrDCMfw+eb9gotyRgBzgqoKTuqogWjsKKuXXcRNGX6dNZtVOZwdshd1CZuF+dXvcJtzofMTc64c/F4NCv3HGb6kL4M6pvopxC8tQjhiiNsfBNQMP687u8rBrOMKmtd4jIKKUUbTHaDxWp+PHDU3Ua+5mij+6fSN9nO1CF9+XRrjMURnA6TWtoyw6g9MsObaVRY2XZRmg/fKMvOFqeVOurbDSi3SeUh+PsCTj30OJ+4p+K67C2wWNlV6qCi1sX0PKMQSh1O0+vI57evCIPbSGvY+AYMnRfYddhZYkwh1Dd4KKysY1CAIU0AdmsvDiq73B7eWnMgtDvV2iiEfhPN80aFcHQzjbb6umV6C4rmj85m3f6KLqUpRi3BqpTbw5d6GqY4QlFlHf06oBACVgt3gFKHs0khbHwDHprc5NZsD63hnZuhdDufTfkzP3LdxGFLBgD5u038YMbQvgzqaxrh7T9cE97itOLNJoY34YLQ7C/GFML+wzV4NAzNDGBJ08sthPLqem56ZQ3FlSH8hzuKjevBpxBS+5vxgj1gIQzsk9jYr2bqkL5Ak6KICYJVKbdH36GmZiQMFoLboymuctI/vf07+MwUn8uo40re5fZwpMZlXEbuBvj4N6Zo7PmLoGJ/+zvY9CZsex8W3E71iLOBJoW0cs9hMpLtDMtKZnCGuaPcd7jWfOctceFRCBvfMGnE40LgLoKYq1TeU2YSA/KykgK+3qvrEPok2U0PurUHQ7fTog1m2c+buqeUiSMcdYXgaNZL3/cP9f2DYwLfAJzOugqsceauNgwWQpnDidujO+Qy8g2774zLyBdvyEqJNxfLwwVw0u0mrvX8RaaiNxg15fDez01n2NnXt2pwt3LPYaYN6YtSys9CqDWu0vRBPa8QmrmLOnlTEAxbAridYUs46Gl2l5lZGDFpIcTbLEwZkBxaheDrBd/PL5c7a/RRdRk1uD3sLHY0m7aVm56I3Wphd2n1UfvciKPRZdQF33HmiLC0rzjkq1JOD+yz9afNYfdBaCxKS7aZYUDZ4+D4W+Hbz5vst/d/EfzNH91hlML5D4PV1sxlVVBaza7SambmGUs0OyUeu9US3tTToo1m+NGEhaHbZ4xNTdtTVkNKfNP/uiW9u5eRo5iXqq5k4/5ydpU4QrPPvcuMTzopo2ld1iioPGBaM3eRgtJqfv/+Zmbe+zF3v7Op2Wt7ymuod3uaDVexWhRDMpMaNX5MUHUIrPGQ0Kfz780IT+ppR6uUfWSm2DsVFyr1WhMjD39hUjGP/5nJzR9+Iky9DDa/E9glUl0Ga14yabr9J3k/2+uycjh59qvdxFkVC6cNBMBiUQxslmk0uOcVwua3AWUmt4WKGJurvLusmqGZSUHbsPfqoDJWO4muw0y2FPDWmhBYCR437FnW1LLCR9Yosyzb0andaa35cnsp33t6BSf96VP+8UUBCvh3/r5mQyp8LStaTtvKy0yKMZdRUeAq5Y6QMdxkKFX3bKpuU5Vyx7KAMpLjO5V2aqqUNYM3Pg5982DCt5peHHs2uKph9xet37j1XVNcOeU7jav6JMZhUbC7rIZX8/dx7jEDyEltUmStUk8dRT3rf9/yjplvkZITun3GoIWQF8RdBBBni6IYglLqDKXUVqXUDqXUbe2+Id743Bdl7eStNQfQ3b07LNpg8tlbKgRfPxVff5UOUFPfwMJHv+Kyp5az8WAlPzt1NMtuW8C9CydRWdfAsl1NOfNbi6pQilYti/Myk9ldVo0nViqWqw51PdWwMfW0c0q7uxRW1GGzKLKSO6YQsjrpMiqrdjJEFRNftBpm/xCsfvnleceb9g5b32v9xk2LzUW9/+TGVRaLom+SnVfz91FT7+bqecOavWVQ3yT2l/u5jKBjgetQUL7L/P7GnRPa/frmKsdAplGD28O+8hqGZgYOKEMUdTtVSlmBR4AzgfHAd5RS49t8k8UG/Sdzkm0Tu8tqWLe/ontC7P7SLIfOa74+Y4QJTnU01Q94a81B1uw7wv87ZzxLbzuJG08eRU5aAsePyiLZbuX99SajxuPRvLvuEBMGpJFob27ODc1Kps7lobgqNu5ucBR1PsPIR+4xJtNo+0ehlakdCivryEmNxxKg1XAgMpLtnQoqlzrqmWvzzhYePr/5i3EJMHIBbH0fPH5DT2qPwK5PTWFXC2srI9m0z5g1LIOJA9ObvTaobyJl1fXU1Dc0KYTSrR2WNSgl22Dv8uYytmTzO2Y5NsQKwWchxECm0cEjdTR4dJsWQntB5bZr7XuWWcAOrfUuAKXUy8D5wKY23zV8PtlfP0a6tZ7nv97DMYP7dF2C3UuNWZ4+sPl6qw1nxhjshevpyM9ea82/lu1hbP9UrpqX18yflxBn5eRx/fhgYyH3XDCR/20pZnuxg78smtJqP3leTV9QWt1ur/2ox+MxU+qGn9S196fkwMhTYO3LsODXJlOmByiq7FiVso+MFDu1LtPPyP8GQGsd0O9b6nBykn072PtC1pjWOxxztvG9H1rTNApz23/NrORx57f+fG+wsaV1AEYhABw4XMuo/pNMPcj7v4RBM7vuxmlwwnPnea2/XBMwnn8bJDRXRmx5x1gzfYcG3k9XsXn/N9v+2zSjuZfiOFTJWZYdTK0qh40pAbdJcHs4y7KGx4LtRGsdEX/ARcA//J5fDjwcYLvrgHwgf8iQIfrOn1yugca/P7/4vs7Pz2+27s4779Raa52bm9u4btq0aVprra+99tpm2x546nt68eLFzdb93+8e0C/dfl6zdeecc47WWutzzjmn2Xqttb799w80W7d48WJ94MCBZutSjjldf7m9RKcPHt24Ljc3V2ut9Z133tls23ufead7x3TgQKtjeuKJJ7Q2J7RDx/TEE0+0e0zXXnut1lrradOmtXtM+fn5rY/pRLvWq57v+jHdeb3Wd6ZF1jEF+D/Z+43Q+8qrWx3TPa9+2eqYZl9xm97/23EhPabc2WfrBren1THl7y7X6fO+0/yYrs/U+b+e2fXv3vsP6sWLEpv/n64/sfV3b7RN60/vC/3/aX++vvNEe/NjujZZ51+b3Pq7d2eazk1RTceUa9H6zjR97bS45sf0s5TWx3ROQuvv3mib1nem6XNG25of051p+olzEpof06JEfeBnKc2PaVqc1nem6Wm5lqZjSlFa35nW7WMC8gNdh5WOkPxcpdTFwOla62u8zy8HZmmtfxLsPTNmzND5y76APwzFPfNavl1wNpsOVfLWDfMY1SJA2y6FG+DxeXDB480CcQB//WQ7h5f8lTttzzHf8xg3LTyRC6YODLIj+Nkra/hwUxFf/9/JAZtM1da7mXb3R4zISWbDgUruvmAil88Z2mo7t0cz7o7/ctVxefzqzG4OCol0Vvwd3rsVblwDGa3vXjtEgxP+PMZYGRf/M6TiBWPinR9w0fRBQVtOt+TjTUVc81w+b90wr9Gavenl1by55iCD+ibyxS9OamYpXPrgYl6suBxO/a1pSBeIp88EZyVcv9Rkwt0/AmZcBWfe12rT2no39W4P6YlxrV4rrqpj1r2fcPf5E7j82DyzcvPb8MplMOxEk/2TMw4Gz2keywiGxw0Pz4T4VLjuU+O++vgu+PJBuPI9yPO6Zr95Ct79Gfzo6+4PxAnE4T3g6v3JGY9/tpN31h3k7R8fFzTLCGBXqYMRE2at1FrPaPlaJLmM9gP+zc8HAe2nDsUlwpDZWAs+4+FL7+Ccv33BD59fyeIfH9du98lm7FlqlnnzWr30ze5y+vcZCw44uW8Jv/jPOhaMyyEtofWPqry6nnfWH2LRzMFBOw4m2q2cNDab99YXkpUSz8XTBwXczmpRDM5IZE9p7/8ys3cZpA4wLruuYouHSRfDymfNiMjEviETLxAOZwMOZ/ujM/3xNan7cFMhEwak8d6GQt5cc5CJA9PYcKCS9QcqmDyoT+P2Q6rXeh/MDb7TMWeamoMlv4fK/aYQK0ilb6LdSiKB3WnZKfHE2yxNmUZglMCZ98Mnd0PBZ2bd+AvgkmfbP9jNi02x4CXPNcUyTvgFbPiPUQA/+ALc9bDuVROn6+4wnGCE2g0VAGeDm6v++Q3zRmbxo/kj2rwgHy3yaxw0ZKah+rUdeh3ehvcvYoLKwDfAKKXUMKWUHVgELO7QO4fPh6L19LdW8dfvTGVXaTUPfdzJyuLdX0D6EN7bF8fZf/0CZ4PpWd/g9rBqz2HS86YA8P1RNdQ3ePjv+sKAu/GllF4W4I7fnzMnmn49Vx+XR0JccH+3L9OoV6M17PkKhh7btZRTf6Zcai6IG1433TrXvGgCzUehlXNHR2f6M3FgOieNyeaRJTs59+Gl/PqN9Uwd0odnrpqFzaJ4z+975fFoxjg34LLEm6B5MMafD3FJ8NkfYPXzkDkKhszp9PEoZWoR9h1ucQMy+wfwq31w8yZjpWx6E7YEyGzyR2v44gEzT8Q/UGxPgrP+ZAbgvHIZPDQJ9n0NM7/f/f99GHln7SG+2lnGHz/Yyq/f3BBwlkllnav7mZBtsLus7QyjjhAxCkFr3QD8GPgA2Ay8qrXuWFqPL/ui4DPmjshi0cwhPL10N5u8owE78OHmgpQ3j8+2lrDxYCVfbCsFYEthFdX1biaNzIO0QeTW7SAvM4k3Vrduqqe15tX8fczM69uqpqAlZ07sz/0XTg4Y3PNnaGYye8pqjuoXKewcLjBBx6Ft3AV3lNwpkDMB/nsbPDQR3rweXrgI7hsG/77SdFQNEYcqjJLpSGM7H3FWC09fOZPHL5tGRU09bo/mwUumkJUSz7EjMnlv/aHG/3VlnYvpaiul6ZPA1kb7675D4ba9cHsR/LoEbljR5aD68KyUxtnezVDKJFssuANyxpuWGG2dy/WvQeE6mHdTa1lGn24sj+0fmIFH13wCx97QJXkjAa01z3y1m1E5KfzwxBG8sHwvP3phJS53U1bVmn1HmH73R5zzty9ZvPYgDe42Mq66gNuj2dtODUJHiBiFAKC1fk9rPVprPUJrfW+H35g7xVS3elMOf3nGGPokxnH7m+s7lsNfvss0tBtyLNuKTZHYe9600G92mwHkM/MyoP9EVNEGLpg6kK8Lyjh4pPld58aDlewsqWbh1MAuIH9sVguXzBzcpnUAMCwriVqXu3ennu5ZZpYt0327glKw4HYYcTKc/ju4/iu47D9wzCLTJ2fDa93/DC9vrD5AYpyVcbmdi1cppThjYi7/u3U+S34+n7ws8yM+e1Iue8trGmccl5WXMUHtpjJnZvs7tcaZNFSbvVtTxsbnprKrxGHaYAf7nHMeMq6pJfdCXYXx0Vf7zaJY/Ty8cZ3JTpp8SeD9fOvvcMM3cNlrMKiVKzuqWLX3MOsPVPC9uXncduZY7jhnPB9sLOJvn5h2Nw1uD//3+nrSE02G2Y0vrWbho1+FtL6osLKOercnaA+jjhJRCqHLWKzGbN68GOoq6ZNk5/azx7F67xFe/qYDQz68De10/8ns8N4dfbSpCGeDm/zdhxnYJ5EBfRJNB9TS7SycmBmwqd7itQeJsyrOnBiCPu5efP/ggt7c02jPV5CYETitsiuMPRsufdncdfabYNJRz3nQ7H/NSyH5iH3lNby15iCXzh5Cn6SuDa9JiLM2qxQ+bUJ/rBbFu96bEWfBcqxK0zCo8+6frjIuNw2Phu2BrAQfQ2bD9Kvg60fhD0PgL5PhjyPgH6fAmzfAWzcYq/3yN5vqAFoSlwjZo4/GIfQ4z3y1h9QEGwu9iSbfP24YF04bxMNLdrCioJxnvtrNpkOV/Pb8CXx884n8/PQxrD9QwebCDnowMFZIRa0r6Ot7vNeHvN7iMuo2064wmQQbXwdg4dSBzB6WwUMfb2vf3VK0EZSFooQ8qpwNnDIuhypnA19sK2XF7vLGBmD0nwjazVDPPqYO6cObfm4jj0ezeM1BThydTd8gjaW6wjDv3eOe3hxH2LPUtCzo7vzctlDKZI/t+7pzbbKDVOo+8flOrEpx7fHDQyPf/pVkuMuY6+c2su1fhlsr4obODs1ndICxuWkAbD7UzsXqtHuMBXbavXD+IzD/VyaraM0LMPEi+M4rjZ0EejOFFXW8v/4Q354xuFkSy2/On8DgjCRuenk1D360jZPGZHPmxP5YLIoLpxkPwlc7Oj7h7601B5l5z8dBx+ru9ra4GZolFoJh4HTj21z1HGDM8oVTB1Jc5WRnSTsX06KNkDmS7eUNAHxvbh7piXE89tlOSqqczMjzNrrzzUgo2sDCqQPZUljV+MNZsbucwso6zp8SPB21K+SmJxBnVRT01kyjykMmhhCK+EF7TP626bW/tgNWQn21udt9cALkP93speLKOl7N38+F0weFpmCwvhqeOQueOo0LR8exp6yGj7/4gqE7XyBfjyEzI6P9fYSIoRlJJMZZ2797jU8xFtjcH5sme/N/CdctgdsL4aKn2o559CKeW7Ybt9Zc4UvT9ZISb+Mvi6ZSXOXErTW/PX9iY+ZR//QEhmcn89XO0g5/zltrDlDv9nDbf9YHjD+s23+EZLu1UwkOgeg9CkEpYyUcWGlqCoDZwzMBWF7QjiYu2gD9JjSayeNz0zhtfD9W7jkMeOMHYBqo2RKhaCNnT8olzqr49ZsbKHM4eWvNQZLsVk4ZF6I+7l5sVguD+yb1Xgth71dm2RMKIW2AcWWsfbntNgpFG+HJ+eZuN22QSbmsNd8Fj0fz6Kc7aXB7+OGJIbIOCr4wvXYq9nHepls4Z4iLMZ98n1q3lVtd19O3iy6prmCxKMb0T23fQghGXC+vqPdjT1k1//iygHMmD2BIAFfNlMF9ePS703jsu9MZnNH89bkjMllRUN4s8BwsbuNwNrB0Rxlj+6ey6VAl/1y6u9nrDW4PH24q4uRx/bB2sIVKMHqPQgBzB2i1w+p/AcaflpMaz/Jd5cHf46yCw7uNQiiuIiPZTmZKPGdPNmmh6YlxjWMtsVih33goXE9mSjwPXDKFDQcqOO/hpby77iCnT+jfqh9RKBjVL4W1+46ENNOott5NVV1wn2SPsWeZadDm14TtqHLMpVCxD/Z8Gfj1wg2m0KuuAq54C77zEtQepuSdu7np5dXMvPdjnvlqNxdMGdjtAF4jOz4y5+DiZ7AUruFv5T+knzrClXU/ozZ5UIf7JIWKcblpbD5U1bsz27qJ1pq7Fm8kzqK4/azgxXSnTejPSWNbJ/7PG5FFdb270QX05fZSJt/1Ic8sLWi17adbi6l3e/jNeRM4eWwOD3y0jX3lTR6D5QXllFfXc9ak7scue5dCSMowOc/rXgFXHUopZg/PZHlBWfAvt6+Dab+JbC9yNHYcnTcyiz5JcczM69v8B5l7DBxcDfU1nHvMAF79wbG43B4q6xo4b8qAo3JYp43vz8GKOlbvO9LutqUd6LV/4Egtpz/0Oac/+Hlox492hX3LTZZJRypfQ8HYs81I1FX/av1aeQE8/y3jDrnmYxh+Irr/JLYOXEifDc+wZ+sajh+VxQOXHMPvvjUpNPJoDds/hGEnmDnCZ9yH0m4azn+c+v7TGBZkFOLRZHxuKhW1rsZZD0JrPthYxJKtJdx86uguuQ3nDM9EKVi6w1yb/vThVurdHu56exPPLdvd6rMyk+3MyMvgtxdMRCm4a3FTRv676w+RZLcyf0z324b3LoUAMP1KY95/8lsAZg/LoKjSGXyugC/DKGcc24sdjdZAnNXC89+fzW/On9h8+wkLzfjCLe8CcMzgPrz9k+O4/6LJnDgq+6gc0qkT+mG3Wnh33aE2t1tRUM7Mez/mnXXBC7z3H65h0ZPLOFxTz5FaF9c8l2+6W4aD+mrjnhk8q+c+054E078H619tjDcBUHEA/nWBqZy9/A3oMwSX28ONL6/h0p2n4rLE8+qwd3lo0VS+NW1Qu+nCjdRXm06ei280FbktKd1uBtGMOsU8n30d3LaP5KkX8uYN83j26h48N146HFiOUSpqXPz27Y2M7Z/KlXPzurSPvsl2xuem8dXOUr7YXsqafUf4zXkTOHV8P/7fWxv5l1cpOBvcLNlSzCled9DAPon89ORRfLKlmCVbi2lwe/hgQyELxuZ0/DvZBr1PIQw/0fSN//oRyH+aOcON/39FQRC3UdFGsKdSYu1HRa2rWUHZxIHpDOzTYjTi0OMgfYjxL3vpl5bAJTMGHzXTPi0hjhNGZ/Pe+kNt5i7//YtdaA1/eH9LY6W1D2eDm/9uKGTRk19TUePihWtm89dFU1l/oIKbX1kTnpkLB1aBdsOgHr7onXKXqVN4+ybY9oGJKTx2LFSXwndfg2yT/vre+kO8vfYgV5wyk8TjfkTcro8bYwkdYu0rcP9weOW7sOpZ06up5dS9Hd523SNPbVrn9cPbbRaS7D3fXWZsf/Mb2Hyo6xMCeytr9x3hnIe/oLjKyb0LJ2JrZ75AW8wdkcmqPUf484dbGZCewKJZg3nk0mmcMi6HO97ayPNf72HZzjIczgZOn9gUm7xq3jCGZyVz99ubWLqzjLLqes6alBuKw+uFCgFMKtzIU+HdWxmx41nuSXyJ6Usubeq57sXj0ejCjd74gQnajsppJ1XOYjHpi7s+NXeVPcQ5k3M5VFHH6n2BL0h7yqr5eHMRc4ZnsP9wLc9/bcYfOhvc3P3OJmbe8zE/fH4lDW7NC9fMYfKgPpwyvh+/PtsU0dz3wZYeO5ZG9i03y54uTLLGmV48/SfCS4vgjR+YDLUffN5Mlhe+3kteZhI/WTASNWIBoJuK6Npj/0pY/GMYMBWuWAxXf2jiEiufab7d9o/MzO4e6LfTUVIT4hickSgWQgteXL6Xix7/Co8HXv3hsUwf2r3sr7kjs6h3e1i7v4Lr548g3mbFbrPwyHensWBsDr9+cwP3vLuZZLuVuSOyGt9nt1m445zx7Cqt5pZX15IYZ+WkELiLoLcqBKsNLnoaskajPrydb/Nfsmt2woe/BndD43zjWfd+RO3+tXj6TWB7kbkbGtmvA7nTxywCNKx7+egehx8nj8thkO0Iw1+YBy9cYu5sPU1WwDNf7cZmUfxl0VSOH5XF3/63nX3lNVz+1Aqe+rKA+WNyePbqWXz5y5OYNCi98X1Xz8vj8jlDeeKzXby0IvAM3UMVtWw8WME3u8tZtfcwhzsx8atN9n9jLoZJPZdW2Uh8Klz6b5N1dNq9cOW7TVPXgK2FVazYXc6ls4cYy2/gdNNbf3eQYLQ/jmLTpye1Pyx60VitQ2abCWfLHoUG7/mrrzY1GKNOOzrH2A3G9k/r1Qphw4GKTrlK95bVcMdbG5gzPJN3bzyOaUO63zhxVl4GNouiX1o8F89o6usZb7Py2GXTOGlMNjuKHcwP4A46aWwOC8bmUOpwsmBsTsiSWSKp22loSUiDq96D8gJeKkhh6fsv8cThB/nnPx7iNwXjsFoUpw5wklRaw5dV/djucpCeGEd2SgdGIWYMN90n17wIx/2sR5pypSbEcX/fN0muKkYfWoN68RLTHfLqD6hSyfw7fz9nT8qlX1oCvzxjLOc+/CWnPPAZWsNfFk0JWh+hlOLOc8ezt7yGO97cwOC+SRw3ytyNHK6u5973NvPaytbFWX2S4rhw2iB+duroznWV9aE17FsBY87q/HtDRWo/Ey8IwIvL92C3WrhouveHGpdgWjEEy07y4XGbnkm1h+Gaj5oru+NugucvNPGLqZeZdFN3vamkjjDG5abxyeYi6lzukPimI4mDR2o5/5GlXD5naIfblj+yZAdWi+JPFx/T5cr0liTH2/jlGWMZkZPc6hwbpTCdh/+3g3OPCZyscsc541m77wgXz2i/VU5H6b0KAcyPMSmDmdZK7vRMZ7tnIHMPPssN81/lirnDyDn4P3gZHt4YT1GfMkblpHS8be2US41LYP83PRMUPbiauVUf8njDuazKvIE5SZ/zveI/sO3ZG3llwC9xOBu4+jjTKG/iwHS+PWMw728o5MnLpzfWYwTDZrXw8KVTueixZVz5zxWMH5DGhAHpfLixkIpaFz84YTjThvYl2W7D2eCmoLSatfsreOrLAj7YWMjvFk7ihNGdDKiX7YTachjcgT49PUxNfQOvrzrAWZP6N04YA0yvpc/vN66flhO/fKx6ztz1X/A49G+RiTTiZOg3Cb58yGS3rXzW7KcnajA6ybj+qXi0sZS6NYUwzFTUuPj3yn1cOntIYzzmzTUHcHs0r63cz89PH9PuDc2+8hr+s2o/l80Z2qlGhh3h2hOC17IkxFm59fTg7VyGZSWz8o5Tg77eFXqny6gFY/qlMmd4NisGXsEYtZefD9tDv7QEVLFJ3dptG0pBaXXnhupMuMDkji/9y9ER2h+t4b+/Qidl83n/77G9zMnLzjm8aLuAcYVvsfPrxcwY2rdZH/3fLZzE8v87uV1l4CM1IY5/fX8W150wnGS7jcVrDjAkM4nFPz6OX501jtMn9Oe4UVmcPK4f1xw/nL99Zyr//uGx2G0Wrnh6RUArok32rzDLwT3XlqElhypquWvxRjYcaD6L++21B6lyNrRuYZ43D7QH9n4deIe1R+B/dxvFccyi1q8rZdpHl22Hrx8zXT+vej94v58wMmVIH2wWxZOf74rqeoQ73jJ+eF8xl9aa11cdoF9aPA5nQ8CuxS15ZMkOLBbF9fNHtLtttNO7LQQvFovipevmgHs6/PUFWHIPHMg3gzr6DOXmedP55X/WM7oj8QMf8alwwi0mvXX7x01pg0eDTW/B3mWocx7ixRl+dwSu2bgfW8ffnc9RefG1zd5isSgSWrYdLi+Aj+80vWfivcqvwQlv/BDm/ZScAVP4xRlmSIkOMuPXn5l5Gbx34/Fc82w+v/zPOjKT7QGLcAKybwXEp4euoZ2XBreH+z/YyufbSpg+tC/zRma1SsnzeDQvfbOX37+3BYezgQ82FvLOT44jMyWe8up6Hvt0J2P6pTJ9aAs/8aCZpvBx9xfmYt6Sz+6HmnI44w/B3YgTLzSvDZ4NfQYH3iYCyE1P5JbTxnDff7dw/DdZLJo1JNwidZr/bihk8dqDpMbbeOrLAq6al8eOYgc7ih38buEkXli+h+e/3sN3Zw9p9l3XWvPp1hKq6xtQKF5buZ/vzh4ScusgEokJC6ERaxwcfzMUrjfDOyxxMOdHXDJjMI9+dxoXBZlcFpRjf2wmPb3/c3NhPVp88WfIHmdac/gTl4D1gkdJqD5EzsoH29/PprfMX8HnTesOrDQNAf1z8qHDrrOEOCuPXz6dcbmp/OiFVaza28G0zP3fwKDpnWpo52qnh3xFjYurnvmGJz/fRaLdypurD/CjF1ax6MmvG6uya+obuOa5fG5/YwPHDE7n8cumU1Zdz02vrKGixsUVTy/nUEUdd18wsfU5iEuEgTNg99LWH16yDVY8Yf5HuW1UXVssMOmiiFYGPn5wwnDmjczkN29vYkdx8+6nbo9ma2HkVjMfrq7n129uYHxuGn//3gzKq+t5cfleXl91ALvNwtmTc7ni2KFsKazim93Nv7N//nAbVz3zDT9+cTU3vLgKq0Vx/fyRYTqSniUmLIRmTL/KzIdNG9iY762ga3m8tng4634TKPzqb3DCraGVFYyvuXAdnHFf4KEnQ2bDxG+ZHvQL7mi7l8zB1Wa5d5mp2PU9hqbxiF0gJd7GP6+cxUWPf8VPXlzNklvnY7e1caGvPWLqP/wnaQXh/fWHeHvdQdYfqODA4VqunDuMO84Z1+pivavEwTXP5rPvcA33XziZS2YOxuX28N76Q9zy6lqueHoFf100lRtfXs1abxHQFccORSnFb8+bwG2vr+fkBz7lSI2Lv18xg1nDgmQ+5c0zNxN1lSZxwcfHd5qpZQvu6MAZiw4sFsUDl0zhjIc+57rn8rnzvAmcMCqLgtJqfvHaOvL3HOYHJwzntjPHdvgGYuWectbsq2DLoUr2ltdQWdeAw+liaEYy88dks2BsDsOzO9cltby6vnmsB7j7nU0cqannuatnMX5AGnNHZPLE57twezSnju9HemIc5x0zkHvf3cy/vt7T+P9+YfkeHl6yg2/PGMz3jx9GVV0DfZLiQtPEMAqILQsBjLmeOSJ0TbhGnmKmP33+JzNoJ9SsexWU1Vz0gzHlu1B3BLa93/a+GhWCnw/c97hsR7fqKrJT47nrvAkcOFLL66vaiCcUb4Z/ngnoNrNrKmpc3PjSaq5/YRVr91UweWAfzpyYy9NLC7hz8cZmd6ZfbC/hgkeWcqTWxYvXzuGSmebuO85q4fwpA3n40mms31/B/D99ysaDlTz63el8b25e40Xs2zMHc/H0QZRX1/PQoiltu72GzjPFdL4aCoBD62DrezD3J5BydKrVw0W/tAQe+e40nA0evvf0Cs57eCln/fULthVVccq4HJ74fBe/f39Lu5aCx6O5+51NXPjYMu5+ZxNLtpbg0ZqBfRKYMrgvhZV13PPuZk5+4DOWbCnusHwFpdXMuvdj3lrT9N09eKSWN9Yc4PvHDWP8AKO0f7xgJCVVTsqr67lwmsm4S7RbuXjGYN5dd5CFjy7lV6+v4443N3DSmGzuXTiR0V634YhOKqhoJvYshKPBGX+Agrnwn2vg6g+MayoUeDxmFOGIBZDSxkVq+HwzoH7Ni6a1RiBqyuHIHohPa+zFhC0B9i43bpAD+cZKmHJpl8WdPzqbYwb34eElO7hw+iDiWlZxrn3ZVAfHp5gpZgEyjGrqTaDv4f/toKTKyS2njub6+SOwWS1orRn4fiJPfr6LUoeT4VkplNfU88o3+xiVk8Lfr5jRqqskwBkT+/PwpdN48KNt3HXeBI4d0TzQrpTivgsn87PTRpObntjq/c0YPMu4Gte/BqO88ZzP/2jO66zrOnO6ooa5I7JYcut8Xs3fxz+XFnDi6Gx+e/5EclLjuXPxRp78fBdKwa/ODNzkrc7l5uZX1vD+hkKunJvHDSeNJDu1dSB9/+Eavv9MPv/3xno+vPkEUhPa/x19tKmQBo/m6aW7G1OrX1+1H63hu7ObkgKOHZ7JzLy+FJTWcLxfi5mfnjIKu83CNwXl/GfVAaYN6cvDl07rVgVyNCMKIRSkD4Jz/2Lyzz/9A5wcIrfBvq+hYm/7+7NYTVbL0oegqtAURLXEZx1MuwKWPWxiB0kZ4KyAGVebjq+7Pg2uEGoPw8e/MdPNskZBzjhTDT54VmMAVSnFTSeP4qpnvuH1Vfv59ky/QOShdWaS1uA5pmgw1ZTirygo5+UVe1FK4fZ4+N+WYirrGpg4MI0nLp/eLHNKKcWvzhyL3Wrh0U93AKZq84yJ/bnvwsmktJE+eMbE/pzRxiQ7i0W1rwwA7MnGEvjyAZMuOmimmdR3ws8hsU+7b49W7DYLl80Z2irz6jfnTcDt0Tzx2S5G56RyoV8czuPRfLCxkAc/3sb2Ygd3nDOe7x8XfIb4oL5J3HfRZL716FLu++8W7rlgEkdq6nlxxV6S4qxMGdKXcbmpxNuaXKdLtpQApqXEhgMVjM9N49X8/cwZntGsJbVSiscum46jrqHZjUpaQhy/9CZSuNwebBbV8dTzXogohFAxYaHJNvrizzDiJMg7rvv7XPeKSW31+fvbYsql5iK17hWT2tgSn0KYda1RCHu/hiRvFs3Quabb5q7PTIpryx/EpsWmD091qbFGSrbC1vfNnXHWaFNkNe48yBjG/DHZTB6UzsNLdvCtaV4roaHeDLtPyoRv/6uxWKu+wcOt/15LmcNJnyQ7Hq05fnQ2V83NY/rQvgF/mEopbj19DDefOrrbvd+7zIJfw6E15pzkHgP2FJjzo/DIEmaUUvzmvAnsLHHwf2+sZ3S/VCYMSOO/Gwv56yfb2VJYxfCsZP5xxQxO7sCskCmD+3D1vGH848sC4m1WXlu5v9noyJzUeN698XiyU+OpqnPxjbea/PVV+3lh+R7OnzKQveU13HTKqFb7zkqJJ6uNwtNWFm0MIgohlJx5nxn48u+rTPvk7vSnaXCaofBjzzZ3pe2RNco0iVvzIsy9sfVF/dAaU2HdN8/07dm7zFyYU/qbdcNPNNlGpdsam7sBpnjq7RvNvIJLX4UBU8x6pwM2vWmykz76f+YvexxqyqXcvOBbXPXcWt5YfYBLZgyGL/5kusoueqlZ5e7L3+xlb3kN/7xqZqd7sYRNGYCxyC58Cv5+ksmWmndTeNpvRAg2q4VHLp3GuX/7kuv+lU9aQhxbi6oYnp3MQ9+ewrnHDOjU/+uW08bw4aYinvqygONHZXH72eNIS4hjeUEZP3t1Lf9atpufnTaGL7eX0uDRXDBlIA1uD2+uPkiZo56UeBtnTgxNs7dYQ1RiKIlPMb1r3E544SLjt+8qm982FbGTL+n4e6ZcCiVbYNeS1q8dXGMarQEMmWPqAPZ8ZR4rZTKvwFgJPvZ+De/eYmIY1/6vSRmAOdapl8H3P4QbV8Ppv4fEvvDRHcz/9GIWZh/iw/99gmfp34zVNPnbMLapTUW1s4G/frKd2cMymN/ZKudIICkDvvOyGbgz98ZwSxN2MlPieeLyGRyuqcetNX9ZNIWPbj6RC6YO7LTyTrRbef77s3nlujk8d/UsxvZPY0CfRBZOHcQp4/rxr6/3UOdys2RrMakJNqYN6cNlc4ZS63Lz4aYizj0m96gMqooFRCGEmpxxRikc3g0vX2qKwQKNayzZCu//0sQd/rUQPri9abuGelhyr6k9GLGg45896WLIHAX/ubb5cHhHiZkS1qgQjoX6Kqg8YB4DZAyDPkOb0k8r9sMrl5t8+YuebjtQnjEcjv0RXP0+LHoRVXuEB6tu4R81P8Xy0a/NOTnjD83e8o8vCih11HcqZTHiyBkHCx+D5I5Vg/d2Jg1KZ/n/ncIHN53A+VM6rwj8GZKZxOzhma2+G9ccN4zDNS5eW7mfJVtLOGF0NjarhcmD+jDZ27TRv1Gc0DnEZXQ0yDsOFj4Or10Nf51iJnT1n2SyagbOgO0fGNeONd4EpG0JsPNhSM6C4242LZLLd5lunIFqD4Lhs1D+vsB027zqfVNMdWiNed1fIfgY6vd4+Imw5iV4YALUlJpsmu+9be78O8rYsyHveNz5/+T3n5WyP30aj/+weeZTmcPJk5/v5IwJ/Zkagq6RQuSQnhiiDLsgzBqWwaSB6fzxg61U1LpY4Odq/OUZY/loUxFTo7j3UrgRhXC0mHihucPft9z4zw+uMa2PPS7T/mD29XD8LebuUmt47SozzL3/JPjsD6ZVsi+tsTNkj4ZvPQkvfwfe/BFc8GhTQNk3t7jPYDM8vq4Ccvy6Pc68xhSN2VNMxszECyFnbOdlSEjDetxPGWzZzT8Wb+Sb3eXMzGvysT+8ZAe1LnebjbsEIRBKKa45fhg/fXkNACeOaXI3zhuZxbyRWUHeKXQEUQhHk37jzZ8PV61Jv0wfBOl+7aiVMmmrB1fDCxebBmqn/rbrbbXHnmWmgn18l6kIjks0riT/ytoZV5liNv9ZxrnHmCygEHHxjEE89PE2Hv90JzOvNAphX3kNz3+9h0tmDG6cXy0IneGsSbnc9/4WctIS2swaEjqPxBB6krhE02rCXxn4SEg3vnplhYkXwcBp3fus4242vf6dlcZl5HMX+TjhVjjtnu59Rjsk2W1cNW8Yn2wp5pElpm7ggY+2YVGKm04ZfVQ/W+i9xFktvHDtHP72nantbyx0ioiwEJRSFwN3AeOAWVrr/PBKFCYGToefrITUEKXMjVgA139lCtbGnx+afXaS6+ePYGeJgz9+sJWdJQ7eXHOA604YHjO9YYSjw7CsDqRiC50mIhQCsAH4FvBEuAUJO6GerZuUYdxPYSLOauGBS6aQZLfy0op9pCXY+NGJsdE5UhCijYhQCFrrzdDxlstCdGG1KH63cBIjc1IZmpFEetLRzUQRBKFrRIRC6AxKqeuA6wCGDIm+oR2xilKqzT42giCEnx5TCEqpj4FA3cVu11q/1dH9aK2fBJ4EmDFjRmRO5xAEQYhCekwhaK2P4oxJQRAEobtI2qkgCIIARIhCUEotVErtB44F3lVKfRBumQRBEGKNiAgqa63fAN4ItxyCIAixTERYCIIgCEL4EYUgCIIgAKIQBEEQBC9K6+hN5VdKVQFbwy1HELKA0nALEYBIlQtEtq4SqbJFqlwgsg3VWrcaVRgRQeVusFVrPSPcQgRCKZUfibJFqlwgsnWVSJUtUuUCkS0Y4jISBEEQAFEIgiAIgpdoVwhPhluANohU2SJVLhDZukqkyhapcoHIFpCoDioLgiAIoSPaLQRBEAQhRIhCEARBEIAoVQhKqTOUUluVUjuUUrdFgDy7lVLrlVJrlFL53nUZSqmPlFLbvcu+PSTL00qpYqXUBr91QWVRSv3Kex63KqVOD4NsdymlDnjP3Rql1Fk9LZtSarBSaolSarNSaqNS6qfe9WE/b23IFtbzppRKUEqtUEqt9cr1G+/6SDhnwWQL+3fN7/OsSqnVSql3vM/Dft4A0FpH1R9gBXYCwwE7sBYYH2aZdgNZLdbdD9zmfXwbcF8PyXICMA3Y0J4swHjv+YsHhnnPq7WHZbsLuDXAtj0mG5ALTPM+TgW2eT8/7OetDdnCet4ABaR4H8cBy4E5EXLOgskW9u+a32f+DHgReMf7POznTWsdlRbCLGCH1nqX1roeeBk4P8wyBeJ84Fnv42eBC3riQ7XWnwPlHZTlfOBlrbVTa10A7MCc356ULRg9JpvW+pDWepX3cRWwGRhIBJy3NmQLRo/Ipg0O79M4758mMs5ZMNmC0aO/A6XUIOBs4B8tZAj7bzQaFcJAYJ/f8/20/QPpCTTwoVJqpXfmM0A/rfUhMD9qICds0gWXJVLO5Y+VUuu8LiWfqRwW2ZRSecBUzF1lRJ23FrJBmM+b1+2xBigGPtJaR8w5CyIbRMZ37SHgF4DHb11EnLdoVAgqwLpw587O01pPA84EblBKnRBmeTpKJJzLx4ARwBTgEPBn7/oel00plQL8B7hJa13Z1qYB1vW0bGE/b1prt9Z6CjAImKWUmtjG5j16zoLIFvZzppQ6ByjWWq/s6FsCrDtq5y0aFcJ+YLDf80HAwTDJAoDW+qB3WYwZ9DMLKFJK5QJ4l8XhkzCoLGE/l1rrIu+P1wP8nSZzuEdlU0rFYS64L2itX/eujojzFki2SDlvXlmOAJ8CZxAh5yyQbBFyzuYB5ymldmPc3QuUUs8TIectGhXCN8AopdQwpZQdWAQsDpcwSqlkpVSq7zFwGrDBK9P3vJt9D3grPBJCG7IsBhYppeKVUsOAUcCKnhTM9yPwshBz7npUNqWUAp4CNmutH/B7KeznLZhs4T5vSqlspVQf7+NE4BRgC5FxzgLKFu5zBqC1/pXWepDWOg9z7fqf1voyIuC8+QSMuj/gLEy2xU7g9jDLMhyTBbAW2OiTB8gEPgG2e5cZPSTPSxhz2IW5u/h+W7IAt3vP41bgzDDI9i9gPbAO8+XP7WnZgOMwZvg6YI3376xIOG9tyBbW8wZMBlZ7P38D8P/a+9734DkLJlvYv2st5JxPU5ZR2M+b1lpaVwiCIAiGaHQZCYIgCEcBUQiCIAgCIApBEARB8CIKQRAEQQBEIQiCIAheRCEIgiAIgCgEQRAEwYsoBEHwQyn1qVJKe//mhFueliil7lNKfdTG68/4yX9RT8omRD+iEAShNf/EzCFYCc0usv9ouaFS6n7va+8cDUGUUo8rpR70WzUFUxUfjJ9iZBeETiMKQRBaU6O1LtRau/zW7QO+7e1XBYBSygZcDuw9GkJ4+xidS/M+WMfQhkLQWldorQuPhjxC70cUgtBrUUq9qpQqU0rd5LdunFKqRim1qJO7W4fpM3OJ37qzgTpMN03/z/3Ue2f/F6XUYe/fH5VSFr9tlFLqFu/IRKdSar9S6vctPnMmkAB86X1Pf6AfUK+Uek8pVa2U2qmUOqmTxyIIARGFIPRmfooZU3gngLc77kvAa1rrl7uwv6eAq/2eX41xLwVqCPZdzO/rWOAHwHXATX6v/w64A/g9MAG4mOaDUMBMzXpXa93gfT7Vu7wBeBBjLWwAHkAQQoAoBKHXos3kqT8DfZRSQ4H7gDTgx13c5YvADKXUKO/d+hnAM0G2PQTcqLXeorV+FfgjZo6ub9jNzZgZuk9rrXdorZdprR9tsY/zgTf9nk8BKoBLtNYfaa13AK8B2V08HkFohi3cAgjC0URrvVspdQQzsvA64ETd9jS0tvZ1WCn1BsYyOAJ8qrXea1z9rfhaN28lvAy4WymVBozFDE3/JNhnKaVGYlqrf+C3egrwdosYwUjMnF1B6DZiIQixwDrgR8A9Wuuvurmvp4ErMErh6S7uI6AGacEFwCda62q/dVMwisWfqZgZCYLQbUQhCLHCRuCeEOznE6AeyKK5O6cls1Vz02EOcNBrnWwCnMDJbby/mbtIKZWEsQZWt9hOFIIQMsRlJPRqlFI3ACcAW7XW7u7uT2utlVKTAaW1drax6QDgIaXUo8Ak4Od4FZLWukop9Rfg90opJ/A5ZmLWdK31Y0qpbIwC8S8sO8a7XOd3bJmYGbtruntcggCiEIRejFJqPCaY+whwvVIqSWtd0939aq2rOrDZC4AVWI7JQnoKkxnk41fAYUym0SCgCHjO+9q5wDda6yK/7Y8BtrdwIU3FjCPd1IXDEIRWyAhNoVeilIrHXIw3AdcAVcA8rfXX7bzvU2CD1rqrmUjd3odS6i1gqdb6/m7IoIGLtdavdXUfQuwhMQSht/IHIB243msVbAduVEoN6cB7r1NKOZRSM4+qhMFZiqmX6DTegjhHiOURYgSxEIReh1LqNOBdYL7Weql33eXAn4BNWuuglb1KqYFAovfpvnbiBMH28SndtDK6ilIqB1NrAXCohYtJENpEFIIgCIIAiMtIEARB8CIKQRAEQQBEIQiCIAheRCEIgiAIgCgEQRAEwYsoBEEQBAEQhSAIgiB4+f+MezWuR++H2QAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAAEOCAYAAABSLcpPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABI+0lEQVR4nO3dd3hUZfbA8e9JIQktoSQQUum9hyaooCCgKNhRQewFXLurrrrurvqzrq66LlbsDRtdaYoC0kuoAUIoSUhCAiSEQPr7++MOGkJ6JnMnyfk8zzzJ3Lnl3IHMmfe9576vGGNQSimlXMHD7gCUUkrVH5p0lFJKuYwmHaWUUi6jSUcppZTLaNJRSinlMl52B+DuWrZsaSIjI+0OQymlapUNGzakGWMCiy/XpFOOyMhI1q9fb3cYSilVq4jIgZKWa/eaUkopl9Gko5RSymU06SillHIZTTpKKaVcRpOOUkopl9Gko5RSymU06SillHIZvU9HKaXqmOy8AqLj04k/dorUzByuiQqlRWMfu8MCNOkopVSdc+vH61gZe+SP53tSMnn12j72BVSEdq8ppVQdsi0xg5WxR7jz/HYse3g4d5zXjh82J7ItMcPu0ABNOkopVad8uuoAft6eTB3egciWjbjngg4E+Hnz/I87cYeZojXpKKVUHZF+MpdZmxO5vF8I/n7eADT19eYvF3RkZewRft2danOEbpx0RGSMiOwSkVgReayE10VE3nC8vkVE+lVkWxH5i+O17SLykivORSmlXGHm+nhy8gu5cUjEGcsnDY4gvHlDXvgxxvbWjlsmHRHxBN4CxgLdgOtEpFux1cYCHR2PO4Dp5W0rIiOA8UAvY0x34JWaPxullKp5BYWGz1YfZGDb5nRp3fSM1xp4eXDPiA7EJGey8eAxmyK0uGXSAQYCscaYOGNMLvAVVrIoajzwibGsBgJEJLicbe8GXjDG5AAYYw674mSUUqqmLd+TysGjJ5kyJLLE18f2bI2PlwezNh1ybWDFuGvSCQHiizxPcCyryDplbdsJOFdE1ojIryIywKlRK6WUTX7alkwTHy9GdWtV4utNfL0Z2a0V87cmkVdQ6OLo/uSuSUdKWFa8I7K0dcra1gtoBgwGHgFmishZ64vIHSKyXkTWp6baf+FNKaXKUlhoWBpzmPM6BdLAq/SP9Ql9QjialcvyPfZ9rrlr0kkAwoo8DwWKtwlLW6esbROA7x1dcmuBQqBl8YMbY941xkQZY6ICA8+abVUppdzK1sQMUjNzGNktqMz1zu8USEBDb1u72Nw16awDOopIWxFpAEwE5hRbZw5wo6OKbTCQYYxJKmfbWcAFACLSCWgApNX42SilVA1aujMFD4HhncpOOg28PLi4ZzCLd6SQlZPvoujO5JZJxxiTD9wDLAR2AjONMdtF5C4Rucux2gIgDogF3gOmlrWtY5sZQDsR2YZVYDDF2F0/qJRS1bRk52GiIprTrFGDcted0CeEU3kFLNqR7ILIzua2Y68ZYxZgJZaiy94u8rsBplV0W8fyXGCScyNVSin7JKafYkfScR4f26VC60dFNCMkwI9Zmw5xed/QGo7ubG7Z0lFKKVUxP+9MAeDCriVXrRXn4SFc1qcNK2LTSDuRU5OhlXx8lx9RKaWU0yzZeZjIFg1pH9iowttM6BNCQaFhXrTrCwo06SilVC11PDuPVXuPcGHXVpRw90epOrduQpfWTZi1WZOOUkqpClq0PYXcgkIu6RVc6W0n9A1hc3w6+9OyaiCy0mnSUUqpWmpu9CFCAvzoGxZQ6W0v690GEZjt4taOJh2llKqFjmblsiI2jUt7t6lU19ppbQL8GBjZnNmbE1068rQmHaWUqoV+3JZEQaHh0t6V71o7bULfEOLSsliz76gTIyubJh2llKqF5mw+RLvARnQLblr+yqW4rHcbQgL8eOKHrWTnFTgxutJp0lFKqVomOSObtfuPOq7LVL5r7bRGPl68cGVP9qZm8Z8le5wYYek06SilVC0zb8shjIFxvdpUe1/ndgxk4oAw3v1tL5vj06sfXDk06SilVC2SX1DIJ6sO0DssgA5BjZ2yz79d0pVWTX2Z+tkGftqWVKOFBZp0lFKqFpm9+RAHj57knhEdnLbPpr7evD2pP419vbjrs41c++5q9qRkOm3/RWnSUUqpWqKg0PDfX2LpGtyUkV3LnsagsnqHBbDg3nN57vIexB4+wYS3VrJwu/NHotako5RStcS8LYfYl5bFfRd2qFYBQWm8PD24YVAEC+49lw5Bjbnz0w28vmSPU7vbNOkopVQtUFBoePPnWDq3asJF3VrX6LFa+/vy9Z1DuKJfCK8t2c0PmxKdtm9NOkopVQu8tzyO2MMnuOeCDnh4OL+VU5yvtyevXNWb/hHN+Ne8HaRmOmcaBE06Sinl5lbGpvHSTzFc3LM146owuGdVeXgIL17Zi5O5BTw9Z5tz9umUvSillKoRiemn+MuXm2gX2JiXrupdI9dyytIhqDH3XdiRBVuT+WlbUrX3p0lHKaXc1ImcfO78dD25+YW8M7k/jX28bInjjvPa0S24Kc/M20leQWG19qVJRyml3FBOfgF3fLKenUmZvHFdH9oHOudG0Krw9vTgkdGdSUw/xaxqFhVo0lFKKTdTUGi4/6vN/L73CC9d2YsLurSyOySGdw6ke5um/G/ZXgoKq15CrUlHKaXczDPzdvDjtmSevKQrV/YPtTscAESEe0Z0YF9aFgu2Vv3ajiYdpZRyI5+u2s9Hv+/n1mFtue3cdnaHc4bR3VvTIagxb/0SS2EVWzuadJRSyk0s35PKP+bu4MIuQfzt4q52h3MWDw9h2oj2xCRnsnhnStX24eSYlFJKVUH80ZNM/XwjHYMa8/p1ffF0wQ2gVXFprza0a9mI1xbvrlJrR5OOUkrZrLDQ8Mi30RgD790YZVtpdEV4eXpw/6hOxCRnMnfLoUpvr0lHKaVs9vGq/ayOO8pT47oS1ryh3eGUa1zPYLq0bsJri3dX+r4dTTpKKWWjvakneOHHGC7oEsQ1UWF2h1MhHh7CI6M7s//ISb7dkFC5bWsoJqWUUhXwjznb8fX25IUrerp8iJvquKBLEH3DA3h9yR4yTuZVeDtNOkopZZP9aVks35PGbcPaEtTU1+5wKkVE+Pu4bqSdyOHBmZsrXFSgSUcppWzy1bp4PD2Eq2tJt1pxfcOb8dS4biyNOcx/f4mt0DaadJRSyga5+YV8uyGeEZ2DaO1fu1o5Rd04JILL+1qTvf22O7Xc9d026YjIGBHZJSKxIvJYCa+LiLzheH2LiPSrxLYPi4gRkZY1fR5KKVWSpTtTSDuRy/WDamcr5zQR4f8u70mLRj58U4GiArdMOiLiCbwFjAW6AdeJSLdiq40FOjoedwDTK7KtiIQBo4CDNXwaSilVqi/WHiTY35fzOwXZHUq1+TXwpGXjBmTnFZS7rlsmHWAgEGuMiTPG5AJfAeOLrTMe+MRYVgMBIhJcgW1fA/4KVH2YVKWUqob4oydZEZvGNVFhbjvyQGX5eHuSk1/+PTvumnRCgPgizxMcyyqyTqnbishlQKIxJrqsg4vIHSKyXkTWp6aW30eplFKVsXB7MsbAVW4ygrQz+Hp5kFOLWzolpf7iLZPS1ilxuYg0BJ4A/l7ewY0x7xpjoowxUYGBgeUGq5RSlbHx4DFCAvxqxegDFVXbWzoJQNGra6FA8UF+SluntOXtgbZAtIjsdyzfKCKtnRq5UkqVwRjDhgPH6B/RzO5QnMrHy6NWJ511QEcRaSsiDYCJwJxi68wBbnRUsQ0GMowxSaVta4zZaowJMsZEGmMisZJTP2NMssvOSilV7yWmnyLleE4dTTrld6+55VCmxph8EbkHWAh4AjOMMdtF5C7H628DC4CLgVjgJHBzWdvacBpKKXWWDQeOAdTBpONJTl75LR23TDoAxpgFWIml6LK3i/xugGkV3baEdSKrH6VSSlXOxgPHaNjAky6tm9gdilP5eNfu7jWllKqTNhw8Rp+wALw869bHb0W71+rWWSullBvLyslnZ1JmnetaA0f3mrZ0lFLKfUTHp1NQaOhXJ5OOB7n5hVhXPkqnSUcppVzkdBFBv7A6mHS8rXRSXmtHk45SSrnIhoPH6BjUGP+G3naH4nQ+Xp6AJh2llHILxhg21sGbQk/z8Trd0im7mECTjlJKuUDCsVMcz86nZ6i/3aHUiD+STjn36mjSUUopF9iVnAlQ5+7POc3HW7vXlFLKbexKsZJOp1Z1NOk4WjrlzamjSUcppVwgJjmTkAA/mvjWvSICKHpNR1s6Sillu5ik43W2aw2KVq9pS0cppWyVk19AXFoWnety0tH7dJRSyj3sPZxFQaGhS3BTu0OpMVq9ppRSbmJXynGg7laugXavKaWU24hJzsTbU2jbspHdodQYX+1eU0op97ArOZP2gY3xrmPTGRSlw+AopZSb2JWcWae71qBIIYHep6OUUvbJOJlHUkY2nVvX3SIC0Pt0lBs5np1HamaO3WEoZYuY5LpfRADQwLNiScfLFcGo+uVUbgFzow8xc308u1IyyczOB+CR0Z2ZOrw9IlKp/a2OO8JP25LpExZAVGQzQps1rImwlaoRp4e/qcv36ACISIWmrNako5yioNCwdt9R5m45xNzoQ2Rm59MhqDGX9w0hJMCPLYkZvLxwF0kZp/jnZT3w9KhY4olLPcHtn6z/I3EB3HtBBx68qHNNnYpSThWTnElTXy+C/X3tDqXG+Xh5lHufjiYdVWWZ2Xms2nuEX3YdZsnOw6Rm5uDn7clF3Vtx/cBwBrZt/kerprDQEN68IdOX7eVkTgGvXtunQvu/49MNeHt68NsjIziRk88bS/cw/de9XN4vtE6Xn6q6wyoiaFrpFn5t5OPtqd1ryrl+iTnM+yviiD18gpTj1nWaJj5enNupJRf3DOaCLkE0bHD2fysPD+HRMV3w8hDe/DmWawaEMbhdi1KPU1hoeHBmNPvSsvj01oGEt7C61P41oTvLX07l/xbs5L0bo2rmJJVyEmMMu5MzmdA3xO5QXEK715TTZOcV8MKPMXz0+34iWjRkWIdA2gU2om9YAFGRzWngVbGalGkjOvDdhgT+b8FOZk0dikcp3WzfbUxg8Y4UnhrXjXPat/xjeVATX6aO6MDLC3fx+960M15Tyt0kpp8iMye/zl/POc1KOtrSUdV0Mjefq99exfZDx7l5aCSPjumCr2PCpsry9fbkoYs689A30czdcojxfc7+BphxKo8Xf4qhf0Qzbj4n8qzXbx3Wli/WHOSZeTuZ95dhFb4+pJSrxSTV7YnbivPx8tSx11T1vflzLNsPHeftSf14+tLuVU44p13eN4RuwU15eeGuEpvi/1mymyNZufzzsu4ltoR8vT3565jO7Ew6zi8xh6sVi1I16Y+J2+pL0vEuv3tNk44qU+zhTN77LY6r+ocypkewU/bp4SE8cUlXEo6d4vkFMRhj/ngtJvk4n6w6wPUDw+kRUvpc8hf3DKZl4wZ8syHeKTEpVRNOT9zWtI5O3FZcRbrXNOmoUhljeGrWdho28OSxsV2cuu+hHVpyy9C2fPT7fl5dvBuAbYkZ3PvlJpr4evFwOSXR3p4eTOgTwtKdhzlyQm88Ve5pV3LdnritOB+v8qvXNOmoUs2JPsSquCM8MqYLLRv7OH3/T43rysQBYbz5cyyTP1jDZf9dwdGsPP5zbR+aNWpQ7vZXR4WRX2iYvfmQ02NTqrpy8wuJS63bE7cVZ92no9Vr9da2xAzmRh+ia3BTBrRtTkiAX4W3jT96kqdmbaN3qD/XDwyvkfhEhOcu78nJ3ALmbjnEpEERPDy6M/5+FeuK6Ny6Cb1C/flmQwK3DGtbIzEqVVV7U0+QX2jqV9Lx9iRXq9fqp59jUpj2+SZOFfnWMaxDS169pjdBTcu+Mzo7r4Cpn2/EAG9e169Gq8M8PYT/XNuHJ8d1JahJ5e/Yvqp/KH+fvZ3thzLo3qb0a0BKudqu5NOVa3V7oM+iavU1HREZIyK7RCRWRB4r4XURkTccr28RkX7lbSsiL4tIjGP9H0QkwEWn41Iz18Vz+ycbaBfYiNWPX8j8e4fx1zGd2XDgGGNfX85vu1PL3P6ZeTvYmpjBq9f0+eOmzJrk4SFVSjgAl/VuQwNPD75Zn+DkqJSqnp3Jx/H2FNoF1p+RM3y8PMiujd1rIuIJvAWMAhKAdSIyxxizo8hqY4GOjscgYDowqJxtFwOPG2PyReRF4HHgUVedlyvMiT7EX7/bwrkdWzJ9Un8a+3jR2t+X7m38GdW1Ffd8sYkbZ6ylb3gAY7q3JiqyGXkFhpO5+Ww4cIxfYlLZkXScO89vx6hurew+nXIFNGzA6B6t+W5jAg9d1Ikm9aRKSLm/+jBxW3EVKSRwy6QDDARijTFxACLyFTAeKJp0xgOfGKvedrWIBIhIMBBZ2rbGmEVFtl8NXFXjZ+JCGw4c4+FvohkY2Zz3p0T9MZPfaR1bNWHWtKF8+Ps+ftyazPM/xpzxuqeH0D+iGU9e0pWbSrgp013dfm5b5kYf4vM1B7nr/PZ2h1OmzOw8YpIz2ZeaxdCOLSt1nU3VLruSMxnYtrndYbhURe7TqXDSEZGRwHFjzNrqBlYBIUDRGzASsFoz5a0TUsFtAW4Bvi7p4CJyB3AHQHh4zVxEd7b4oye545P1BPv78vbk/mclnNP8GngydXgHpg7vQPzRk8SmnsDHywNfb0/aBzau8EV8d9IrNIBhHVrywYp93HROZLVvXq2q3PxCdiVnknDsJInppzAGGvtaf2LR8ems23+UvalZf6zf2MeLp8Z15ZqosHoxGGR98ufEbfWniADA18uTvAJDQaEpdZ3KtHReBV4Bzkg6ItITSDHGOPPW8JL+AoufRWnrlLutiDwB5AOfl3RwY8y7wLsAUVFRpb97biIp4xSTP1hDXkEhM24aQPMKlBsDhDVvSFjzujE3zdTh7bn+/TV8tzGBGwZFlLhObn4h+49k0T6wsVOLI46cyOHLtQf5ZNUBDpcyWZ2/nzdREc2Y0CeE7iFNCWzsy3MLdvDod1tZvOMw0yf1q1fdMHVdfZm4rbjTU1aXVcFWmaTTEVhRwvKBwDXA6ErsqzwJQFiR56FA8ZsxSlunQVnbisgUYBxwoSl6K3wtdSj9FNe9t5ojJ3L5+JaBtA9sbHdIthjSvgW9Q/1559c4ro0Kw6vIB/iKPWl8uyGepTsPk5mTz8iurXjzur74NaheiyjjVB5v/7qXD1fuIzuvkPM6BfLUuFDaBTYiNKAhHh5wIiefvHxDaDO/s4b0+eK2wbzzWxwv/hTDzPXxpSZLVftsTcwAKHNUjbrozymrS+9iq0zSSQcCgbhiy1cAL1cutHKtAzqKSFsgEZgIXF9snTnAPY5rNoOADGNMkoiklratiIzBKhw43xhz0skxu9yh9FNMfHc1x7Jy+fTWgfQNb2Z3SLYREe4e3oG7PtvAgzOjmXJOJEFNfHhm3g4W7UihWUNvxvZsTVATX95aFst1763mgylRtKjCTa9pJ3L4el087y2PI+NUHuN7t2HaiA50bHX2t9qyChs8PIS7zm/Hkp0pvLF0D1f0Da12IlTuYXN8Om38fatclVlbne7WL6uYoDJJZxbWB/YVxZZ7Oh5O46guuwdY6Nj3DGPMdhG5y/H628AC4GIgFjgJ3FzWto5d/xfwARY7+tBXG2PucmbsrpKamcOk99dwLCuXz24bRO+wALtDst1F3Vpx0zmRfL0unjnRhxCx+pj/OqYztw5r+8cfRI8Qf+77ahPXvLOK2fcMo7FP+X8GhYWG3/ce4cu1B1m0I5m8AsN5nQJ5dEznat0fJGLNM3TNO6v4eNV+ty+EUBWzJSGDXqEBdofhcn+0dMoYaboySecJIFpE5gJ/N8ZsEpHGwN+ALdWIs0TGmAVYiaXosreL/G6AaRXd1rG8g5PDtEX6yVwmf7CGpIxsPrttoCYcBw8P4R+Xdeehizoxf0sSe1NPcNPQtmdViI3p0ZoPbxrADR+s4Zm5O3jxql6l7jM7r4BPVx3gszUHOHDkJAENvZkyJJKJA8PoEOSc/vqBbZszonMg//sllusGhOPfsPYVc6g/HcvK5eDRk0wcGFb+ynXM6Ws6TuleM8YcFZHBWBfYN4hInmP7Y8Cl1YpUVVheQSE3f7SOuNQsZtw0gP4R9asksyKa+HozsZyhe87p0JK7z2/P/5btZUSXIMb0aH3WOr/vTePJH7YRl5bFwLbNeXBUJ0Z3b10j1XGPjO7CxW8s553f9vLXMc4dXFW51hbH9Zw+9bKl49zuNYwxicAlIhIG9AXygDXGmKNVD1NVxvRle9l0MJ03r+vLsI46a2Z13D+yE8v3pPHY91voHeZPsL/VIjpyIofnFuzk+42JhDdvyCe3DOS8ToE1Gku3Nk0Z26M1n685yL0XdrSt7FtV35b4dAB6hNavIgJwUiGBiPwb63rOSmNMIYAxJp4z74VRLhCTfJw3f97Dpb3bcGnvNnaHU+s18PLgPxP7MO6NFQx/eRlje7Sma3BTpv+6l6ycfO4Z0YF7LujgsgQweUgEP25LZm70Ia6Oqn9dM3VFdEI67QIb1Zs5dIqqyDWditwY0BD4EkgRkY9EZIKI6G3ULpZfUMgj32yhqa83/7ysu93h1BntAxsza9pQrokKY2nMYZ7/MYaOQY1ZcO+5PDy6s0tbHEPataB9YCM+W3PQZcdUzmWMITohg971sGsNrFGmoezutXKTjjHmbmNMKHAJVgnys0CaiMwRkVtEpGb7HRQAM1buY2tiBs9M6FHhmz9VxXRu3YRnJvRg3RMjmX/vML6+Y0iJ5c81TUSYNDiC6Ph0tiZkuPz4qvqSj2eTmplD73rYtQYV616r8C3Qxpi1xpgnjDE9gN7Ar8BNQIKIrBCRh0UkpFoRqxJlZufx1i97Gd45kIt7OmfKaHU2X29PurfxP+smTle6ol8oft6efLb6gG0xqKqLjre+LPSqpxWlfyad6nWvlSQOOGGMOQ/rjv8ZwDDguiruT5Xho5X7yTiVx4OjOtkdiqph/n7ejO/ThtnRiWScyrM7HFVJWxLS8fIQugXXnzl0ivqje62a13TO4igouMnxe6oxZoYxZoIx5pWq7E+V7nh2Hu8tj2Nk16B6ebNZfTRpcATZeYV8v1HnCKptohPS6dy6Sb2tPnRq91oJfhWR+6uxvaqAGSv2cTw7n/tHaiunvugR4k/vsAA+W32AOjA8YL2RV1DI5oPp9A0PsDsU29Rk9xpAN+BeEYkXka9F5AkR0ZtEnSjjVB4frNjHRd1a1buBA+u7yYMj2Juaxaq4I3aHoipo08F0snILGNah/t4/V5GbQyucdETkjLFCjDGXGWPaAV2B14AU4MKqBKpK9uXag2Rm53PvhR3tDkW52Lhewfj7efP5ai2fri1WxKbhITCkff1NOt6eggjklDFldWVaOutE5EMRCS260Bhzwhiz2hjzvjHm/irGqorJKyjko5X7Oad9C23l1EO+3p5c3T+UhduTOXw82+5wVAWs2JNKr9CAWjkRorOICD5eHk7rXusNNAN2i8iLIhJQzfhUGRZsTSL5eDa3ndvW7lCUTW4YHEF+oeGrdTr4h7s7np1HdEIG5+rQVPh4eTon6RhjYowxE4CRwBBgr4g8JCJ6p6KTGWP4YMU+2gU2YninILvDUTZp27IR53ZsyZdrD5JfUPofsbLfqr1HKCg09fp6zmlWS8eJ1WvGmN8d9+fcgjWHzR4RubHqIari1u0/xpaEDG4d1tbWGxWV/W4YFEFSRjY/xzhzNnjlbCv2pNGwgWe9nkjxNF9vT+ffp+PwG9Z8NgnAh9XYjyrm3d/iaNbQmyv6hpa/sqrTRnYNonVTXz7VEQrc2orYNAa3a0EDr+p8pNYNPl4eZDujpSMiU0XkvyLys4gkA2nAEiAImF3tSBVg3dG8ZGcKU86J1KmLFV6eHlw3MJzle9LYn5ZldziqBAnHTrIvLUu71hx8vD2c1tJ5GugCRGPNFjoY8DfGdDTGFJ/CWlXRK4t206yhN7cO0wICZZk4MAxPD+GLtVo+7Y5W7EkD0CICh/IKCSozc2grp0SkSrU67gi/7U7liYu70qQezsWhStaqqS8XdWvFzPXxPDiqU70dYsVd/RxzmDb+vnQIamx3KG7B6YUEqmYYY3hl4S5aNfVh8pAIu8NRbmby4AjST+Yxf0uS3aGoIrLzCli+J42R3VohokU/gFPv01E1aNbmRNYfOKZTFasSDWnfgnaBjfhsjRYUuJOVsWmcyitgZFftCDrNx6vmqtdUFeUXFJJX5L6LT1ft56GZ0fQLD+AanaZYlUBEuGFQBJsOprMtUSd4cxdLdqbQ2MeLQe2a2x2K2/DxLrt7rcLXdFT1ZOcVMHN9PL/tTmN13BHyCgrpH9GMlo19mBN9iJFdg3jzun54e+r3AFWyq/qF8vLCGD5fc4Dnr+hV/gaqRhUWGpbsPMz5nQP/GOhSld+9pknHBQoLDQ/NjGb+1iTCmzfksj5t8PHyYE3cUdbsO8oNg8L552Xd8dKEo8rg39Cby3q3YdamQzx+cVeaarGJrbYkZpCamcMo7Vo7g9Oq11TVvb50D/O3JvHY2C7cdX77M17LLyjUZKMqbNLgCGauT+CHjYlMOSfS7nDqtSU7UvD0EIZ3DrQ7FLfi4+XhtFGmVRXMiT7E60v3cHX/UO48r91Zr2vCUZXRKzSA3qH+fKoTvNluyc4UBkQ2I6ChDj9ZlHVNRwsJbHHgSBaPfruFAZHNePbyHlpSqZxi0uAIYg+f4MdtyXaHUm8dOJJFTHKmVq2VwMfLk/zC0r8QadKpIYWFhke/24KXh/Dmdf30QqNymgl9Q+gZ4s+Ts7aRmpljdzj10vyt1v1SY3q0tjkS9+NTzvhzmnRqyBdrD7I67ihPjutKa39fu8NRdYi3pwevXtObEzn5/O2HrdrNZoN50Un0DQ8gtFlDu0NxO5p0bJCYfornF+xkWIeWet+Nq6Vsh7RYKKzb8890bNWERy7qzOIdKXy3MdHucOqVuNQT7Eg6zrhebewOxS35lHNzu1av1YBn5u7AAM9f0VOv47hKYSH88hwsf8V67tMUwgbC8L9BaH97Y6shtwxry+KdKTz+/RbyCgq5bmC43SHVC6eHIrq4p3atlURbOi628eAxftqezF3ntyesuTa9XSLvFHx3i5Vw+k6C8W9Br2sgeSu8fwF8f6fVAirIt9Y3Bo4nwZG91u+1lKeH8N6NUQxp35LHv9/K07O3nTHShaoZ87cmMSCyGcH+fnaH4pbKu37tti0dERkDvA54Au8bY14o9ro4Xr8YOAncZIzZWNa2ItIc+BqIBPYD1xhjjjkrZmMMLyyIoWVjH52awJV+uBN2zIFRz8A5fwERK/mM/AcsfxVW/Re2fAVevtC8HRxPhGzHUDJNQ6DdCGu7oC62nkZV+Pt58+FNA3jhx528t3wf+46cZPoN/Wjk47Z/2rVa7OFMYpIz+cel3ewOxW3VypaOiHgCbwFjgW7AdSJS/F95LNDR8bgDmF6BbR8DlhpjOgJLHc+d5ueYw6zdf5T7RnbUP3pXOfA77JgNwx+HofdaCec0nyYw8mm4dzNc/i4MuA38w6D7FTD2ZbjkVQiNsrb/7ArIOmLbaVSHp4fwxCXdeOGKnqyMTWPiu6u1qq2GzNuShAhc3DPY7lDclo932WnFXT8ZBwKxxpg4ABH5ChgP7CiyznjgE2OV7qwWkQARCcZqxZS27XhguGP7j4FlwKPOCLig0PDiTzFEtmjIxAFaPOASxsCip6BJsNVSKY1/CPS+1noUN+BWOLQJPrgIvr8dbvgWPNzyu1i5Jg4MJ7CJD9O+2MiV03/nh6nn0KKxj91h1RnGGGZtSmRQ2+YENS1SkbpjDsx/CIx2bQIMLjSs98mj1HEajDFu9wCuwuoWO/18MvDfYuvMA4YVeb4UiCprWyC92D6OlXL8O4D1wPrw8HDz9NNPG+CPx/r168369evPWHbdXQ+aiEfnmeaBrf5Y1q9fP2OMMbfffvsZ6yYmJpo5c+acseydd94xjgT6x2PcuHHGGGPGjRt3xnJjjHnnnXfOWDZnzhyTmJh4xrLbb7/dGGNMv379/lgWHBxsjDEVOqenn37aGGNMcHCwe59Ty4Dqn9Pa983t/bzd55yq+e/k07qDuWnGGnPbbbe5zzk18zNm+2zz9FNP1sr/e+OvnWwiHp1n2nXpeea/06yp5ukLmpx5Tq9db9a/dv2Z53TdYGPmPmCCmzf685zaBxkz9wFz++geZ57TR7ebOU9dduY5TbvQmLkPnHlOA9oaM/cBM25A2zPPae4D5p1pF555Tk9dZhI/OvO9u310D2PmPmD6tQ/685yaNzJm7gPm6esGV+mc+rQLNKvfuNEA60v6fBXjhhdSReRqYLQx5jbH88nAQGPMX4qsMx943hizwvF8KfBXoF1p24pIujEmoMg+jhljmpUVS1RUlFm/fn2Z8RpjmPDWSjJO5bH0oeF4emjFWo3Lz4W3BoK3H9y1AjyqefOtMVZLZ9t31v5adXdOnDb5+Pf9PD1nO09e0pXbzj17+CWXyD0Jv70Eq9+Gwjzwaw5Zh6FhCxjzIvS62p64quj+rzaxNOYwa/82Er8GRf6/vT8KPBvAzfPtC84NicgGY0xU8eXu2o+QABTtowoFDlVwnbK2TXF0weH4edgZwa7bf4zohAxuPbedJhxX2fIVHNsHI/9Z/YQD1rWgsS9ZHx5r36v+/mx245AIRndvxYs/xRAdn+76AFJ3wXsXwIrXoOs4mLYWHoqxui9bdITvb4N177s+rirKOJnHgm3JTOgTcmbCMQbSdkNgJ/uCq2XcNemsAzqKSFsRaQBMBOYUW2cOcKNYBgMZxpikcradA0xx/D4FmO2MYN9bHkezht5c1S/UGbtT5TEGVv0PWvWEjqOct9+GzaHHlbBlJmQfd95+bSAivHRlb4Ka+PLod1soLGMsLKfb+i28OwKyUmHyD3Dl+9CivfXloOMouHE2dBprXQf57WUoyHNdbFU0a3MiufmFXFv8em1WKmSnQ0tNOhXlloUExph8EbkHWIhV9jzDGLNdRO5yvP42sACrXDoWq2T65rK2dez6BWCmiNwKHASq3b6PSz3Bkp0p/GVEhzO/AamaE7cMUnfChOlnVqs5Q9StsPlz2PI1DLzduft2Mf+G3jw8uhMPfB3Noh0prhknbPXb8NOjEH4OXDUDmpZQ5eXtC9d+apW6//wsrHkHek+EwC5wdB9kxFvdpn7NrGU9r7G1uMMYw5drD9IjpCk9QvzPfDFtt/VTk06FuWXSATDGLMBKLEWXvV3kdwNMq+i2juVHgAudGecHK/bh7enB5CGRztytKsvq6dAo0GqVOFtIPwjuDetnWCXWtXxEiUt7teGNpbG8sXQPo7u3qtkRMpb/G5b+C7qMsxKOVxmVc57ecMX7VkLZ9Kn1b1qYD+IJTdtAfg6cOmot2/wFXP62tdwGWxMziEnO5NkJPc5+MXWX9VOTToW5bdKpDVKOZ/PNhgSu6BtCYBMtTXWJtD2wZ6F1X05ZH2pVJWK1dubeCwdXQ8QQ5x/Dhbw8PZg2ogMPfxPNkp2HGdWthobiX/OulXB6XmO1QD0r8NHi4QGdx1iPrDTIOW7dR+XpmBHVGNj4Cfz0GEw/x+qm6zCyZuIvw3cbEmjg5cGlvUtIeml7wLuRdZOxqhB3vaZTK0xftpeCQsPU4R3sDqX+WPO2dbE/6taaO0bPq8DHv1Zd6C7LhD5tiGjRkNeX7q6ZEamPJ8HSf1oJ4fJ3KpZwimvU0hotwrPIFNwi0H8K3LkcmobCl9dbXasulFdQyLwtSYzq2gp/vxKmB0/bBS071Np7u+yg71QVHT6ezZdrD3JF3xDCW+gYay6RmwWbv4SeV0PjGpwiuEEj6HM97JgFGQk1dxwXOd3a2ZZ4nGW7U51/gMV/h4JcuPjlmvnwbdkBpsyBFh3gy+usFqiLrNiTxpGsXMb3KaVrL20PtOzssnjqAk06VfT2r3HkFxruuUBbOS6z60fIy4I+N9T8sQbfbXXvrJ5e88cq7sRhmHOvNTyPk6ZouNzRBfzZqgNO2d8f9q+ErTNh6H1WS6WmNGwON86yRp/4/Go4tLnmjlXErM2JBDT0ZnjnoLNfzDlhFT3o9ZxK0aRTBYczs/l8zQEm9AkhokUju8OpP7Z+Y/Wdh7vgOkuzCKtQYcNHcOpYzR/vtONJ8NElsPFjmHkjvHse7P252rv19vRg4oAwft51mIRjJ50QKNao3T/+1boOM+xB5+yzLI2DrBaPbwB8ejkc3lmjh8vKyWfR9hQu6RlMg5IGsTwSa/3Ue3QqRZNOJRlj+OfcHdrKcbWTRyF2iZUIXNV/PvReyD1hVbK5QkYCfHQxHD8EU+ZZ10dyTsBnVznlA3biwHAE+GptfPVjBetLQMo2GPUvaOCiLmb/UKvF4+kNn0yAo3E1dqhFO5I5lVfAhL6lFAlouXSVaNKppE9WHWD+liQeuqgTbVtqK8dltv9glc/2dOHQKa17QvsLrftI8rLPfM0YiF8LP9wFL7WHRU+evU5lFOTDFxOtKq7JP0Dbc617V25bao2WveARqjv3T0iAHxd0CeKrdfHVn3enIN8a4qZ1T+h+efX2VVkt2ls3mBbkwkfj4HBMjRzmh02HCG3mR//wUkbKStttlXjXZLdiHaRJpxI2x6fz7PwdXNgliLvOa293OPXL1m+tC7ate7r2uEPvgxMpMO/+P7vZkrfCjNHwwSjYOReCe8Hvb8I750HixqodZ+NHkLIVLnvTmvH0tEYt4MKnYP9yK/FW0w2DIkg7kcOi7SnV29HWmVYr4/zH7LmXKair1dVWmG/9Wxxc49TdH83KZWVsGpf1boNHaUNbpe6CZpE1U7pfh2nSqaD4oyeZ+tkGWjX15d/X9C79P6JyvvR4OPi71cpx9Qdc2/Ng6P3WCAX/HQizpsI751uzjl78ijWe2OQfYNL3kJNpffNOr2T31al0+Pk5iBgG3caf/Xr/m61ku+hJq7utGs7rFEhIgB+fra5GQUFBPvz6ErTuBV0uqVY81dK6J9y6yBpA9JPLrJtInVQSvnhHMgWFpux5c9L2QKBWrlWWJp3y5Bxn/7ofuWL672TlFvD2pP4ENGxgd1T1y7bvrJ89a2AEgvKIwKh/wu2/WPPybP4c+t0I96yzhsnxaWKt1+FCuHUhmEJY9ETljvHrS1YraszzJSdVD08rwR1PhGXPV27fhYXW0DK7F8KGj/DMSeeGweGsijvCjkNVHF9uy9fWYKvDH7d/xIZmkVbiadMPZt0Nn10Jx6pfoffTtmTCmvvRvU3TklcoyLcKCVp2rPax6htNOuUoOJ5M5PyJvF7wHLOvDjh77CVV83YtsL5V29l33qaPdX3lwZ1w6X+sEt7iAsLhvIesUufYpRXbb9oeWPsO9JtsddOVJnwwRN1iTb29Z3HF9p20xbqT/40+8MU1MPc++PBiJnVtQKMGnrz7296K7aeo7Az45TlrqKDOYyu/fU1o1BJumm/NBhu/Bt4aBD8+WvkWp8Px7DxWxh5hTPfWpQ8bFLfMmq6hVQlD46gyadIpRzxteNvnZgZ77yXym9Ewe5pVXaRcI+sIJKxzjw84D8/yx/86514rOf74V2v8sPIsfAK8/OCCp8pfd/T/QVB3a6DMsv4PFhZY15jeu8BqQV3yb7hlEVw/E9IP0vTLcUzt5cHcLUnEH61k+fTiv0NmkjXVt92tnKI8PGDQHTB1tVXYsO59K9n++GjF/h2K+CXmMLkFhaUPkFqQb7Vmm7UtuTtUlUmTTjnCWjRi4n0v4XHfZhg81Rr2/o1+MPd+6w9w0VNWZdEPd8P3d0Lihorv/Mhe+PASWP5qrRje3RaxS6wuq06j7Y6kYrx8rG/cR2Jh1Vtlrxu7xBpH7vxHrHtQyuPtB1d/BHmn4LvbrHt6TjPGajUtfQb+47j+02k03P27NXBp+CDr+ZQ5kJPJXfv+QkvS+WDFvoqfW9wy676lIdMg9Ky5udxDQBhcPh3u3Qx9J1vDJs0YDekHK7yLn7YlE9jEh75hpVStbfgQUmPgome1iKAK3HLmUHdy1syhxw7Az8/AznnWh6EIePlaffs5mdaghef8xerv9vYrfceHNln3X+SegPxsa26Yy96wRjlWf/rmZti/Ah7aVbvGt/rqBuumzmlrrQ/C4gryYPpQq+x32prKfXhFf2W1dgBCB1qtr/g1VgtEPKwy7/5TrNGeS2qNJG2B90eyy7cXlx9/kJWPjaRZo3KuU+Zmwf+GgIcX3L2y7P/b7mTnXKv4w8PTmkCunGR5KreAfs8s5sr+ITw7oYRKyVPHrC+drbrDlLnu1dpzM6XNHKqjTFdWswhrtNuSZGdYLZ+Vr8PuRTD5+5K7Y/b+Al9PsqbvvWWhNTfM/IdhxhjrAnWziJo9h9qiIA/2LoUul9auhANWUcB/B8LCv1lzxxS3foY1WOTELyr/bbn3ROvC+c7Z1odq4kaIHAZhg6DzxVbBQ1mCe8GY5+k8/0FuLJzNByva8/DoMqqwck7AV9dbrYWbF9SehAPQ9VII6gafXQFfXAu3LS7z2uBve1I5lVfAmO6lVK0te8GatG3MC5pwqqiW/SW7OV9/q7Uy6Tvr7vIZY6zKoaK2fW+NHRUQYVXdtOxg/WHcvhQwsOJVW0J3S/FrrEReW7rWigoIh/Mehp1zzi4qSNlhXYxve76VJKoisBOc9wjc+Rs8sNX6IjTw9vITzmlRt0C38TziPZMNyxcQe7iUUuyTR+HTCVZrc8L/IOKcqsVrpxbt4YbvwBTA59dY51SKudGH8PfzZlC7EgpFDq6xbhSOugVaawFBVWnSqQkdRsKU2VZX24djYdNn1t3rq/4H394CoQOsb4xFZ1X0D7VKcTd9Xqn+5zpt90/g4Q3tR9gdSdWc8xdo3t665ne6jDd5K3w8DrwbwrjX7Pu2LAKXvgEB4Xzg9Twzv3z/7Cmt4361vjglRcM1n1gjb9dWLTtYrcr0A1arrYTpyA8fz+anbclc2S8Ub89iH415p2D2VGucuZH/cE3MdZQmnZoS0h9uWgCIVfH2wShY+Lj1zXby9+AXcPY2wx6wfi7X1g5g3VsSOezPe2FqGy8fGPeq9UH3em+rhfvxpdY1wJvmW9/A7eQXgOctP5HTtB1/PfpPNs58zur63TITPr3CuuEy76R1LaTrOHtjdYaIc+CKd61qyA/HnlUB+OXaePILDZOHlNC9/fOzVnHI+P/W3v+PbkILCcpxViFBZRXkWS2XI7HWH3CXS8ue5Greg9ZsifduKvkCdH1xNA7e6Gv1nQ++2+5oqicjwar62vCxlXCmzIHmbe2O6g8mJ5PNr11B3+y1fy70awbnPmxVvnn72hdcTYhdCjOngG9Tq5w8chh5Xo0Y9uLPdG7dlE9uKTIMkTHWdNpz7oUBt1rrqwoprZBAk045qp10Kis93vqw7TfZ6n6pr1a/DT89aiXfujKgYkG+dV3BDctsD6Rm8K833iEyuDlPXn0eEhBWuwoGKitpi1VYkHkIxJN0/64sPdKMPr370b5jd2jSyvqC8POz1rh34efADd+AT2O7I681tHqttggIsxLOxk/h3Iesaz310e6frCHj60rCAUcL1z3/5CIC/Rl+ybU8NWsbkXt9mDy4DiccsCr47t1oFavsX0H86sUM89pBq23LYVuR9Xz8Ydx/oN+U2ldB6abc8y+gvhv2oJV0lr9qXROob3Iy4cBKGHSn3ZHUK5MGhbN4Rwr/N38nwzq0rPtTd3j7QbvhbPfty6WL+vK3i7twx5A2VndoZjKcTLNaOE1a2R1pnaKp2x0FhEHfG6y+5IwEu6Nxvbhl1k2THWthqXQtJiK8dGUvvD2Fh7+JPruarY56eeEu/P28uTYq3EpELTta8xl1v1wTTg3QpOOuzn3IGvFgRT28rrP7J6tbI3yw3ZHUO639fXlyXDc2HDjGtxvr/hee3/emsWxXKtNGtMe/obfd4dQLmnTcVUA49LnBqmSrT62dwkJrFOUOF1pTEiuXu6pfKP3CA3jxxxgyTtbdMQGNMbz4Ywxt/H25cUik3eHUG5p03Nl5DwMCS/9ldySuk7TZmqmz0xi7I6m3PDyEf43vwbGTuby6eJfd4dSYBVuTiU7I4IFRnfD19rQ7nHpDk447CwiHc+6xJs2KX2d3NK6xeyEg1qgOyjY9QvyZNDiCT1cfYFtiht3hOF1OfgEvL4yhc6smXNGvnlaI2kSTjrsb9iA0bm3ds1JYaHc0NW/XAmuYoEYt7I6k3ntoVGeaN/LhwZmbyc4rsDscp5qxYj/7j5zkb5d0xVOnnncpTTruzqexNdZT4garxVOXpe6G5C1W1ZCynX9Db/59TW92p5zgufk77Q7HaVKOZ/Pmz3sY1a0V53cKtDucekeTTm3Q61prLLclT1vzedRVW7+x5oPpcYXdkSiH8zsFcvu5bfl09QEWbU+2OxyneOHHGPILDU9d0s3uUOolTTq1gYeHNT1wVpo1I2RdZAxsnQltz4MmpUwTrGzxyOgu9AhpysPfRPPBin2czM23O6QqW7//KD9sSuSOc9sR3qKh3eHUS26XdESkuYgsFpE9jp8lzhkrImNEZJeIxIrIY+VtLyKjRGSDiGx1/LzAVefkFG36wNB7rWkS9v5sdzTOl7Aeju2HntfYHYkqpoGXB9Nv6E/X4KY8M28HQ1/4mUe+iealn2L4ZNV+TuTUjiSUmZ3HgzOjCQnwY+oIm0f4rsfcLukAjwFLjTEdgaWO52cQEU/gLWAs0A24TkS6lbN9GnCpMaYnMAUoYTpHN3f+Y9CiI8y5z5rNsS7Z+g14+tSNIfTroLDmDfn6ziF8d/cQoiKb89ueVN79LY6/z97OLR+tc/tCA2MMT87aRmL6KV6f2IeGDXQEMLu4Y9IZD3zs+P1jYEIJ6wwEYo0xccaYXOArx3albm+M2WSMOT2BxnbAV0Tcb7jfsnj7WvN5ZMTDT2fl4tqrIB+2fw+dx1izryq31T+iOe/dGMWav41kz3NjeX1iH9btP8o9X2wkv8B9qyu/3ZDA7M2HuP/CjkRFljArqHIZd0w6rYwxSQCOn0ElrBMCxBd5nuBYVtHtrwQ2GWNySgpARO4QkfUisj41NbWKp1FDwgdbQ+Rs+hTWf2h3NM4R9wtkpWrXWi0jIozvE8K/xvdgyc7D/O2HrXaHVKK9qSf4++ztDG7XnKkjOtgdTr1nS9IRkSUisq2Ex/jyt7Z2UcKyCo1OKCLdgReBUocwNsa8a4yJMsZEBQa6YUnliL9B+wutaZDj15a/vrtb+To0CoKOo+yORFXB5MER3HleO2auTyD2cKbd4ZwhO6+Ae77YhK+3B/+5tq/ek+MGbEk6xpiRxpgeJTxmAykiEgzg+Hm4hF0kAEWn1QwFTnedlbq9iIQCPwA3GmP2Ov/MXMTDE658H/xDYOaNkJlid0RVt3+FNUnWsAfccnIzVTG3ndsOTw/hmw3uNU7gCz/GsDPpOK9c3ZvW/nVsBtRayh271+ZgXejH8XN2CeusAzqKSFsRaQBMdGxX6vYiEgDMBx43xqysmdBdqGFzuPZzyM6Ab6ZAfq7dEVXNL89D41YQdbPdkahqCGziw4jOgXy/MdFtru0s3pHCR7/v5+ahkVzYVacocBfumHReAEaJyB5glOM5ItJGRBYAGGPygXuAhcBOYKYxZntZ2zvW7wA8JSKbHY+SrvfUHq17wGVvwsFVsOgJu6OpvH3L4cAKq5VTl6dGrieu6h9GamYOv+2x/zpoVk4+T/ywlW7BTXlsbBe7w1FFuF3doDHmCHBhCcsPARcXeb4AWFCJ7Z8FnnVqsO6g51VwaBOs+i+06Qt9rrc7oooxBpY9b40r1/8mu6NRTnBBlyCaN2rAN+sTuKCLvS2Ld37dy+HMHKZP6o+Pl44g7U7csaWjKmvkPyHyXKuwIP2g3dFUzOr/WVNSn/+ItnLqiAZeHkzoE8KSnSkcy7Kvu/dQ+ineXR7Hpb3b0D+ixHvLlY006dQFnl4w4X9W62HeA9ZPdxb3Kyx6CrpeClG32h2NcqKro0LJKzDM3pxoWwyvLNxFoYFHx3S2LQZVOk06dUVAOIx8GmKXuPdo1OkH4ZubrHnoJ0wH0RLWuqRrcFO6BjdldvSh8leuAVsTMvh+UyK3DWtLaDMdW80dadKpSwbcBmGDrNEKTpRUaW6zzBT47CooLICJX4BPE7sjUjVgXK9gNh1MJ+HYSZcfe/qvsTT19eLu4Tq2mrvSpFOXeHha1Wy5WbD4abujOVNmCnw8DjIS4LovoYV+KNRV43oFA/DjVtdOhRB/9CQ/bUvmukHhNPH1dumxVcVp0qlrAjvDkGkQ/YX7THF9eKcj4STCDd9A5FC7I1I1KKJFI3qG+DNva5JLj/vx7/sREaYMiXTpcVXlaNKpi859GJoEw49/df0U15nJsGM27PsNEjbArGkw/Rw4kaIJpx65pFcw0fHpxB91TRdbZnYeX62L55KewbQJ0GpId6ZJpy7yaQyj/gWHNlotHlfZPgveGmQNzfPxpfD+BdbEbIOnwr2bNeHUI5f0tLrYFriotTNzfQIncvK5dVhblxxPVZ3b3RyqnKTn1bDufVjyD+h8sTVsTk0pyIN591sTzIX0h4ueg8I8OHnUeh4QVu4uVN0S1rwhvUP9mb81iTvPr9nrdwWFho9+30dURDN6hwXU6LFU9WlLp64SgUv+DafSa/7enc2fWwln6P1wy0KIGGJNO919giacemxcrzZsSchgX1pWjR7n192HiT96ipuHaiunNtCkU5e17gkjHocds2DrtzVzjII8WP5vaNMPRv4DPLVqSFnG92lDA08P3v0trkaP8/nqgwQ28eGi7jqoZ22gSaeuG3q/de/Ogoes6jFni/7KuuFz+GN6o6c6Q1BTX64dEMa3G+JJTD9VI8dIOHaSn3cd5tqoMLw99eOsNtB/pbrOw9O6878gH766HrLSnLfvgnxY/goE94aOFzlvv6rOuMtxk+bby2pm+qqv18UjwHWDwmtk/8r5NOnUBy3aw9UfQmoMzBgD6fHlb1MRW7+BY/vh/Ee1laNKFBLgx1X9w/h6XTzJGdlO3XdeQSFfrYtnROcgQrRMutbQpFNfdBoNk3+whsf54CLYs7h6xQWFhda1nFY9reo4pUoxdXh7CozhjZ/3YJxY0LJ4RwqpmTncMFhbObWJlkzXJxHnwM3z4etJ8PlVEDHUmhYhbEDl97VrARzZA1fN0FaOKlNY84ZcPzCcT1cfIONkHs9d3gN/P2/i0rJYHXeEmKRMdqVkEuDnzWV92nBhl1b4NSh7DpzCQsP/lsUS2syP8zvV7rkY6xtNOvVN654wbR1s/Bh+fRE+GAldxsEFT0FQJWZYXPk6BERA1/E1F6uqM/5xWXfaBPjx70W7WH/gKA28PIg/ahUXNPbxolOrxkQnpLNoRwqNfbx4YFQnbj4nEg+Pkr/QfLshgW2Jx3l9Yh88S1lHuSdxZnO3LoqKijLr16+3O4yakXPCmkxt5RuQlwUD77DKnsubVO3gapgxGsa+DIPucEmoqm7YmpDBM/N20NTPi/M7B3Fex5aEN2+IiFBQaFgTd4R3l8exbFcq53ZsyStX96ZVU98z9pGZnceIV5YR2aIR39w1BNGWtlsSkQ3GmKizlmvSKVudTjqnZR2BZf9njWDQsjNc8S606VP6+l9eZyWeB7ZBg0YuC1PVD8YYPl9zkGfn78DP25Pnr+jFmB6t/3j9+QU7eee3OObcM5ReoQH2BarKVFrS0UICBY1aWKMXTPoeco7D+yNhcyljtqXusq7nDLxdE46qESLCpMERzPvLuYQ08+Ouzzbw2HdbmL05kSdnbWXGyn1c3T9UE04tpS2dctSLlk5RJ49aM3vu+xWGP35mOfTxQ/DROMhKhXs3QaOWtoaq6r7c/EJeXbybd37bizHQqIEnQ9q34IUre9GysY/d4akyaPdaFdW7pAOQn2sN4Ln5c+umz/43Q6tu8OnlcCIVJn0H4YPsjlLVI3tSMsnJL6RL6yZ46cgDtUJpSUer19TZvBrA+LegZSf4/Q3Ys8ha3qAJTP4ewgbaG5+qdzq20qnN6wpNOqpkIjDsfmsW0r2/WNdx+k6G0P52R6aUqsU06aiyeXpDp4ush1JKVZN2jiqllHIZTTpKKaVcRpOOUkopl9Gko5RSymU06SillHIZTTpKKaVcRpOOUkopl9Gko5RSymV07LVyiEgmsMvuOErQEkizO4hSaGxV466xuWtcoLFVhaviijDGBBZfqCMSlG9XSYPW2U1E1rtjXKCxVZW7xuaucYHGVhV2x6Xda0oppVxGk45SSimX0aRTvnftDqAU7hoXaGxV5a6xuWtcoLFVha1xaSGBUkopl9GWjlJKKZfRpKOUUsplNOmUQkTGiMguEYkVkcfcIJ79IrJVRDaLyHrHsuYislhE9jh+NnNRLDNE5LCIbCuyrNRYRORxx/u4S0RGuziuf4hIouN92ywiF7s6LsexwkTkFxHZKSLbReQ+x3Jb37cy4rL9fRMRXxFZKyLRjtj+6VjuDv/XSovN9vfNcSxPEdkkIvMcz21/z/5gjNFHsQfgCewF2gENgGigm80x7QdaFlv2EvCY4/fHgBddFMt5QD9gW3mxAN0c758P0Nbxvnq6MK5/AA+XsK7L4nIcLxjo5/i9CbDbEYOt71sZcdn+vgECNHb87g2sAQbb/Z6VE5vt75vjeA8CXwDzHM9tf89OP7SlU7KBQKwxJs4Ykwt8BYy3OaaSjAc+dvz+MTDBFQc1xvwGHK1gLOOBr4wxOcaYfUAs1vvrqrhK47K4HLElGWM2On7PBHYCIdj8vpURV2lc+e9pjDEnHE+9HQ+De/xfKy220rgsNhEJBS4B3i92fFvfs9M06ZQsBIgv8jyBsv8QXcEAi0Rkg4jc4VjWyhiTBNaHBxBkW3Slx+IO7+U9IrLF0f12ulvBtrhEJBLoi/Xt2G3et2JxgRu8b45uos3AYWCxMcZt3rNSYgP737f/AH8FCossc4v3DDTplEZKWGZ3bflQY0w/YCwwTUTOszmeirL7vZwOtAf6AEnAvx3LbYlLRBoD3wH3G2OOl7VqCctqLL4S4nKL980YU2CM6QOEAgNFpEcZq7tDbLa+byIyDjhsjNlQ0U1KWFajfweadEqWAIQVeR4KHLIpFgCMMYccPw8DP2A1gVNEJBjA8fOwfRGWGout76UxJsXx4VAIvMefXQcuj0tEvLE+2D83xnzvWGz7+1ZSXO70vjniSQeWAWNwg/estNjc4H0bClwmIvuxLgtcICKf4UbvmSadkq0DOopIWxFpAEwE5tgVjIg0EpEmp38HLgK2OWKa4lhtCjDbngihjFjmABNFxEdE2gIdgbWuCur0H5rD5Vjvm8vjEhEBPgB2GmNeLfKSre9baXG5w/smIoEiEuD43Q8YCcTgBv/XSovN7vfNGPO4MSbUGBOJ9bn1szFmEm7wnhUNUh8lV39cjFXJsxd4wuZY2mFVmEQD20/HA7QAlgJ7HD+buyieL7G6DvKwvindWlYswBOO93EXMNbFcX0KbAW2YP2BBbs6LsexhmF1W2wBNjseF9v9vpURl+3vG9AL2OSIYRvw9/L+37tBbLa/b0WON5w/q9dsf89OP3QYHKWUUi6j3WtKKaVcRpOOUkopl9Gko5RSymU06SillHIZTTpKKaVcRpOOUkopl9Gko5RSymU06SjlQiKyTESM4zHY7niKE5EXRWRxGa9/VCT+q1wZm6obNOko5XofYs1jswHO+CB/v/iKIvKS47V5NRGIiLwtIq8VWdQHa+SL0tyHFbtSVaJJRynXO2mMSTbG5BVZFg9c6xhbDwAR8QImAwdrIgjHuGuXcuaYfb0pI+kYYzKMMck1EY+qHzTpKFVFIjJTRI6IyP1FlnUVkZMiMrGSu9uCNS7WNUWWXQJkY41gXPS4yxwtlNdF5Jjj8bKIeBRZR0TkIcf0xDkikiAizxc75gDAF1jh2KY10ArIFZEFIpIlIntFZEQlz0WpUmnSUarq7sOaEvhpAMeI5F8C3xpjvqrC/j4Abiny/BasrriSBki8AevvdwhwJ3AHcH+R1/8PeAp4HugOXM2Zk3WBNXvkfGNMvuN5X8fPacBrWK2ebcCrKOUkmnSUqiJjzcD4byBARCKAF4GmwD1V3OUXQJSIdHS0OsYAH5WybhJwrzEmxhgzE3gZeBD+mJDtAeAxY8wMY0ysMWaVMeZ/xfYxHphV5HkfIAO4xhiz2BgTC3wLBFbxfJQ6i5fdAShVmxlj9otIOtb0wHcA55uyZwQta1/HROQHrBZOOrDMGHPQuvRyltXmzCHiVwHPiEhToAvggzWEfYlEpAPWlBkLiyzuA8wtds2mAxBb+bNRqmTa0lGq+rYAU4FnjTG/V3NfM4AbsRLPjCruo8QsVcwEYKkxJqvIsj5Yyauovlhz7CjlFJp0lHKO7cCzTtjPUiAXaMmZXV/FDZIzm0CDgUOOVtYOIAe4sIztz+haE5GGWK2aTcXW06SjnEq715SqBhGZBpwH7DLGFFR3f8YYIyK9ADHG5JSxahvgPyLyP6An8AiOpGeMyRSR14HnRSQH+A1r5sj+xpjpIhKIlaSK3tzZ2/FzS5FzawGEoklHOZEmHaWqSES6YV3Afwu4W0QaGmNOVne/xpjMCqz2OeAJrMGqbvsAq+LstMeBY1gVbKFACvCJ47VLgXXGmJQi6/cG9hTrbuuLNfX3jiqchlIl0umqlaoCEfHB+sDfAdwGZAJDjTGry9luGbDNGFPVCrdq70NEZgMrjTEvVSMGA1xtjPm2qvtQ9ZNe01Gqal4A/IG7Ha2bPcC9IhJegW3vEJETIjKgRiMs3Uqs+4kqzXFT6gknx6PqEW3pKFVJInIRMB8YboxZ6Vg2GXgF2GGMKfUOfhEJAfwcT+PLuW5T2j6WUc3WUlWJSBDWvUgAScW645QqlyYdpZRSLqPda0oppVxGk45SSimX0aSjlFLKZTTpKKWUchlNOkoppVxGk45SSimX0aSjlFLKZf4f9HX7t3s0lY4AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "plt.plot(r, d_skw[0])\n", - "plt.plot(r, d_skw[31])\n", - "plt.plot(r, 0*r, 'k--', lw=1)\n", - "plt.xlim([0, r[-1]])\n", - "plt.xlabel(r'$\\chi\\,\\,[{\\rm Mpc}/h]$', fontsize=14)\n", - "plt.ylabel(r'$\\delta$', fontsize=14)\n", - "\n", - "plt.figure()\n", - "plt.plot(r, v_skw[0])\n", - "plt.plot(r, v_skw[31])\n", - "plt.plot(r, 0*r, 'k--', lw=1)\n", - "plt.xlim([0, r[-1]])\n", - "plt.xlabel(r'$\\chi\\,\\,[{\\rm Mpc}/h]$', fontsize=14)\n", - "plt.ylabel(r'$v_r/c$', fontsize=14);" - ] - }, - { - "cell_type": "markdown", - "id": "4c9710fe", - "metadata": {}, - "source": [ - "## 3.4 Intensity maps\n", - "Intensity maps are stored as HEALPix maps." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "89d171c3", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:368: UserWarning: If you are not specifying the input dtype and using the default np.float64 dtype of read_map(), please consider that it will change in a future version to None as to keep the same dtype of the input file: please explicitly set the dtype if it is important to you.\n", - " warnings.warn(\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:391: UserWarning: NSIDE = 64\n", - " warnings.warn(\"NSIDE = {0:d}\".format(nside))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:400: UserWarning: ORDERING = RING in fits file\n", - " warnings.warn(\"ORDERING = {0:s} in fits file\".format(ordering))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:426: UserWarning: No INDXSCHM keyword in header file : assume IMPLICIT\n", - " warnings.warn(\"No INDXSCHM keyword in header file : \" \"assume {}\".format(schm))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/fitsfunc.py:428: UserWarning: INDXSCHM = IMPLICIT\n", - " warnings.warn(\"INDXSCHM = {0:s}\".format(schm))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:920: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", - " newcm.set_over(newcm(1.0))\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:921: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", - " newcm.set_under(bgcolor)\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:922: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. In future versions, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = copy.copy(mpl.cm.get_cmap(\"viridis\"))\n", - " newcm.set_bad(badcolor)\n", - "/cvmfs/astro.sdcc.bnl.gov/SL73/packages/bacon/latest/lib/python3.8/site-packages/healpy/projaxes.py:202: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n", - " aximg = self.imshow(\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAF1CAYAAADbfv+XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9ebR1y3YXhv2qajV779N/3/1u+57eQ08NWCCJVooQj0bSk8DgeJDEJsEBPDwy0pE4jomxTWMhITCyA/EIwxn5g8SAEzdhYBIICNFEorMAI4QMVvek19726063m9VV5Y9Zc9as2ut89z7pPb1779tzjDPOOXuvplattap+Nedv/qYJIeBgBzvYwQ52sIMd7GCfX7Nf7AYc7GAHO9jBDnawg70f7QCyDnawgx3sYAc72MG+AHYAWQc72MEOdrCDHexgXwA7gKyDHexgBzvYwQ52sC+AHUDWwQ52sIMd7GAHO9gXwA4g62AHO9jBDnawgx3sC2AHkHWwgx3sYAc72MEO9gWwA8g62MEOdrCDHexgB/sC2AFkHexgB9szY8wfNcb8777Y7fhSNmPMPzDGfM0Xux0HO9jBfvZ2AFkHO9j7yIwxP2CMeWqMadVnv9MYcxt/dsaYSf1/qbeN2z8A8DsA/F+/wG393caY/8YY0xlj/pPiu9YY86eMMZ8yxtwYY/6xMeY3qu8/bIz5y/Fa3zDG/EljTPVOjj3Tjh+I/cJ98hNvs/0njTG9Mea54vMfMcYEY8yH1XbfWmzzu4wxf+dtuobtPwTwXe9w24Md7GDvQjuArIMd7H1icXL/WgA/BuBf4M9DCH86hHAcQjgG8EcA/CX+P4RwHkLoikP9LgB/OYSw/QI3+TUAfxjA/23muwrAZwD8WgBnAP4AgP+SAQyA/xjAWwBeAvD1cbv/1Ts89pz9btUnX/0Otv8EgP8x/2OM+SUAlu/wXO/U/j8Afr0x5qXP83EPdrCD/TzZAWQd7GDvH/sdAP4rAP8JgN95xzZfD+CfvM1xfiOAH9QfGGM+wZ4kY8y5MeaRMeb459LYEMKfDyH8BQCPZ75bhxC+M4TwyRCCDyH8JRCw+eVxk18A4L8MIexCCG8A+D4AX/NOjv15sj8L6m+23wngz3wuBzDG/MvKe3YbvW4/wN+HEHYA/hGAj30+Gnywgx3s598OIOtgB3v/2O8A8J8B+HMgD8gLM9t8PYAfeZvj/BIAZcjsNQCvAEAI4RLkLftGvYEx5i/F8OPcz1/6XC+mOPYLAL4KwD+LH/1HAH6bMWZljHkFBAy/7+dwij8agePfNcb8unew/Q8BODXG/CJjjAPwLwP4Tz+XE4YQ/gvlYXwZwM+A7p+2HwPwdZ/LcQ92sIO9e6x6+00OdrCDvdvNGPPNAI4A/P9CCJMx5m8C+J8A+BNqm1MAH8bbg6xzADfFZwKyoi0AGL1BCOE3/yya/rZmjKkB/D8A/OkQwo/Hj38QwP8MwDUAB+BPA/gLP8tT/F4A/x2AHsBvA/AXjTFfH0L46bfZj71ZPwjgxwG8OrPNXzDGjOr/BsAP6w2MMRbA/xPAD4QQSh7cDSgkerCDHew9aAdP1sEO9v6w3wngvwghTPH//wz7IcOvA03an3ibYz0FcFJ89ioiyDLG/AoAXw7gb/9cGvxOLAKQPwsCQL9bffZXAfx5ELB8DsAFgD/2szlHCOHvhxBuQghdCOFPA/i7AH7TO9j1z4KA7O/C3aHCfzHy3s5DCOfIeWNs3wPq7//tzHcnAC7fQVsOdrCDvQvtALIOdrD3uBljlgD+JeShpv83gK8wxuhQ09cD+NEQQnibQ/4oKDSn7TUAHzDGnIDAxf86coZ0O/5KwTHSP3/lZ3FdBsCfAvACgP9BCGGIX90D8EEAfzICo8cA/u94Z8DonVhA4aWb3SiET4EA628CAb7P2Ywxvw1EoP8fquvT9ovw9hy6gx3sYO9SO4Csgx3svW//IoAnAP6JMWZhjFkAmAD8ZeTk7K/H24cKEff7tcVnr4G8V/8VgP80hPCflzuFEH6jytArf35jub0xpoptdQBcbLumMPxfQCDjt+hMxxDCIxC4+V/GY5yDvHb/5HM4Nm93boz5dv7eGPPbAXwU5Cl7J/avAfgNIYT1O9xen/uXAvg/g7xdD2e+b0FE/7/2uR77YAc72LvDDiDrYAd779vvBHGttsXP/wjAb1fg4uvwzkDWnwHwm6KHjO1VAF8N4AdDCN/z+Wk2fn9s578N4F+Jf/9+ADDGfAjA/xwEDN9QHrHfHvf9rQC+A8BDAB8HMAL4N97JsePx/4ox5t8FUIOkHh4CeATgfwMCPc/UymILIfx0COG/+ZyvnOy/Dwpz/p07PH7/Aoin9drP8vgHO9jBvshm3j5ycLCDHexLzYwxfwTAWyGE/9MXuy1fqmaM+fsA/rUQwj/9YrflYAc72M/ODiDrYAc72MEOdrCDHewLYIdw4cEOdrCDHexgBzvYF8AOIOtgBzvYwQ52sIMd7AtgB5B1sIMd7GAHO9jBDvYFsAPIOtjBDnawgx3sYAf7Atg7LatzYMcf7GAHO9jBDnawg+3bneLFh9qFBzvYwTL79d/672f/TwuL/tRln/XH+2PK8okHALidzz6/+nCd/X/vxztsXsg/A4D2atr7DAF7/vap3XfA17cTfL3fpuZJv39IZ2CKZaPtxuz/aUFDo+3zNvUXLdpH2+yz4Wyxt93f+Fu/b++8BzvYwb707J1KOBw8WQc72HvcvvXXfA98nQMUX5m9z4wPgMkBy3Ccb1OtCUiFKm3XnVpsXrC4+aocsJje4PSncpC2eTng6LP5OcYVcPYzOViZ2n3gFCxgZwrQ2DEfpnxtcPTZrPIPxqNqbzsAqK+6/FjbAX5RZf3g2/k1qbvJz2G6EWHZ7G03HRWfhYC//nd+/952BzvYwd5zdqcn6wCyDnaw94l97Jd/JwDAr/a9ROMygRwGGewR8g39Ngw+GE8ph9S0oA+HFY0l/Sn9bq9on/WLCYQdv0o7vvGr07Bx8c8sbj6cjtdc0f5GYarhOJ62pf18Rb/PfpK2vfly7O1z8WO0TXdG529u6P9xQd+316kNdQSGtlcXZgzskP6vn+ziNgooxjHSr5rs/yn+b3zY27a6yoEXRmp0WNRy3vQdnX86beUjd0ug76/+yHfjYAc72LveDiDrYAd7r9l3/BLycgRjsgk41PvhsnGZe1l8beC2CY3snqthpvQaB5uHzNrLMYEsADAFeFBmBp+BhPGoQn2dwnLjqoLbpXNvX2zF8wUAV19eY/k4/X/5FXQ9R6/S+bbPG7SX6dw2HrpZx8/UmDVG8KfbOi5T26aG/h6P1bU+DjAKZy2fTKjWqb12CrBd+t/ddvCLBFxtNyI0qb+DS+czo5dQI7fLbZLbbTxps7YGA/gmAeDmyRah8CLatQJs8TuzTiHLsFrI/3/lM/8RDnawg/282wFkHexg71b79q/9A/J36YUKlUWwahIvuUQFF8hXCYCtP7DIAACQc6nOfqZHUHjNTiHzeFXb/NhWAadQWbhd8vb42uZg4riBU0Clu5dAIgB0FxVcly5md26xekjb377isHqY87p8ZVBt4mfaCbQwcH3eKf2xhY1N608Mrj+SvmufGoRiODz7RDpX+2SAU56tElCaYcKk7lG1HjKQ5NYJbPpFBaP6YDqqUd2ksGSo8xCqbytMbfqsBLn1k032v1E8MrPe7oV4tf2VT/2JO7872MEO9nO2A8g62MHeDfbtv+zfk7/Hkxx4uG1ONMo8IiGFkAAgNBWMCmlx6AoAbj+0xPZ+waHaplf46M2cM4WAzMvF4UTjw743K8c+qK5zL0tQIA/GCMjrzxo4Fabrzmv4guK0eJLaNa5yAIIAhLi90c032B+d1HB3+1J+nJtfkH/fPDXoL+gAD344oH2S7oEGWwAysMtt0mYHL6DXrvN7BZ8fy2wTGCv5W6GpMuDmFfBCQAZu7aaHGXVct7hBxXm1F/D7fvJ7cbCDHezzYgeQdbCDfSFNZ+TVV7sMjLirtfztV4tsP3/cwCpwZYbcW5S+MNkEuXv5BN1ZmnyffE16x5dvGQxHadfnfnTIhoD6WgEJNWFDAa3puMH2+TT5r15PYCo4C6vaaYYp88pocBisycjxwRqMq3RdHM4DgEZlF/rGZN+5Pgj4c9vUuVNrUW8U2Gwdqtt0fcNpuobN86ldVx8x6C/S+Zav3OJkmYBR9afup7+3PuNxVZsxB1wmDxdqsGxuU1jPDKqvXQkiVQjR2dwr1dTqO5M9W+P5Igsf63ZpMr8ZJvhlOo676RLHDMgAu9kN8MdpAfD9//A7cbCDHeyZdgBZBzvY59M++puTF2Dxpgrj+BxUhVZPkPnEmk+6VibaMowEmybRq68+RXee3uf1K0D3Ah3n6GdqHL2WXtXlo3T8+mbIJm4OW4XKwm5UiKutgeh9uv3QERaPCTBIWDIe3oSQcYd0WDJUFtOCrkE8YfH3cFrBK9ClwUV969FEALh+mSZ5N9D3dlCeNvW3GQNs4b1hPlWwJgMgu/sJVPTHVkKnV78wep+eoz557vwWT/7JA9n2g39deZ2M8vSNLFlB/TwtawFYZvQwnfJMDiPMyH1YDKdmHrABQKi0F0uT6Jo8FKyekeFiIfcpOJON3toz6XZjFsZdPNzJMe12yLIp9TP51//2QZ7iYAcr7ACyDnawn4v9uo+Rp8o3FsvXCETJhHRFIMv4QF4IAKhcyihrYxbaLnoWnMs9FzpcFEI2Yeqw0aNfeoyrr6C/p9MR7RsJwL34Q3mokblb1XqUtgGAjbwpE0IWstKAb7p3DB8nVd+6jAROB4njiQ8YTms5DwMr9sAxJ8s7A9clIMQAitvFQGrxkNrDkhL9eYXmkto1HjnUt0WYE9FzFa8xVGavrQwEQ2MzUHj9odSG4cigu0d/9/8c3ct/7pU3AAA//vd+AU4+Qd+d/3QvHq3g8nPZYRIvZKhdFsLL+rlTul3cnhjSC9FjlYFvvR0IdPH3oXJAXQAh9exoyQjOIOU+4cxS5t3t7sf7uPXw0YO4fGMnXknm2zHwMj5gOKF9fvAv/1s42MG+xO0Asg52sGfZx37VH8IUwyni5YkgynQTzBQn1GFMGV48GRqTuC9xkgvOZhMeIvjKPVv5e+kXtQCMaeHw2q+mCa3a0HbP/3AvXrPxuMlI735ZwW5HImoDsLs+4+eEpobpB2lvNtnHz8KCJmV/vJB2MGi0wyS8rfGIrsFXKUMxGEjGHk/o1e0gQIsn6+G4EjmIajNlRH4zBVQ3fRIGNSYLt/mzFexthxCBRRlq9cta2hss6X/pPgqVFbkGX1vp/+GYwGF36kRG4vorqGEvfM1bOK6prz7+ox/AB/8aHa+5iucNQY4poV7vs5Ce4TFWgyfNlTLznj0zTnQPtTfLKyL+5NNxGEwOA8zRij7rB4QlgUm+99O9U2nP7kWKKU8LAx/7ojuzqDfRUxfvtxuChCE5+cDXBtWG762VGaI7p7YevUZ9Nq4c/tZfOoCwg73v7QCyDnYwbd/6q/8wAAIP7HmxzE9Sk6Tp+v2Jj03CewWDW3uijhYyqflFlXGuWBaAQQlnlgULPPw6+q59GvDCD13R58bMyjcAJCsgvBoGgtpTotqkwZa2sGzhj2hSDs6IN8tt81Bjf5Y8JG43YVo4AWUMmmzvUd/0cv7d86t0fhWy0sKgbjPCxdCl2fYCIEzhEQRUn/NlxfZpoOXrIjPzDkmK4bhCiDhmOLLozmif7Qv0+943voFfeP4WfuC//sWyz0f+XOKomckLIDH9mJ4L5+R+CyDnZ0mBrMwDGgLM5OX/7HlT15kdCwB2nfC8Qj8kb2NcHJhF5AI69fz0A/wL5MILtcPmlSX9bQ125yyNQZuyxlh3ZkXZvwzhch/CA90F/cMJF67zAq7/7p/7PTjYwd5ndgBZB/vStI99w3fJ39pzZG/vCOEo05P6Hn/qDuufJ1eIDhdl2WHIM/k4xAYA4zIdd/W60kFSQMFdJzKz1VpJRZuM5intlJp5pQChAof+NIGgzMN2hyyAr112Xfo66psZOXYfsmFIX5OWNbA3qmSN9zmQYJCkQ2QLFRJrc/mL/n5KMpi0NIXWxOonTCs63vZ+Ou7unuLB/SoFqGyAX6sw7Q+m7c5+8iZtpxMYlKYWh5YBBXb1tQH7nC1t+j5rT6kCY2GjOIL6uVUEeoz7oVdp18kJbfLShXy2eWWVbbN5oEC7am69Tv80N+kZbFSyhebGaTmNv/f/OoCvg71n7QCyDvalYVoiYVLZVCYEuCg3EKxN/ChdNuV0mQ6kozmTyqQbvZCAzTBhuE8hl+BMVlNPTzw6M02ri49HMYR25MQLcPTZbQZeNI+ofpQmT7veJm/IHR6abCK1M8CwbXJwpvk8Z6kvMm2uEDK+FoOlzDultbv0vgXIErmDbkwen12fh9I0WOS2ao6SAg5+lUtijOf0v1egcVq6FAbb+aytzDGiv9M9uH2ZznvzS3cwNnol1zWWrybwdPHj6Thn/+xpap8ijIfaSQanTo6ABlvPAD8ACCRP0/x3eiyva4TbeA5rEPh51x5NDaCzbEm1zfGR9Pv4/Jl4fbcvLLJakTuVjMHhRiAJwx69kWpLLh734rUdjl2WRVqpupd/58//H+av82AHe/fZAWQd7P1rGljxpOYrCxc9JEZP2v2Q0ue9R4gTc6gUh2r0yRNh86xAH5XVg7MCkhBC4mn5kEJHWjncGtgdTab9/aV8311UAgKO3ujyjL048TVvrSUsZq/Wqp1qslWcsNDHkJsteGEFbwxNnbLXQkj94iym4xywaDCWSUtwlEuXpwlBgCILmAZnBIiF2sJux/h9ysZjsGF2M+RwIPNgSVsyr5YCSfcSSGTNLavI9xyibS77BBTjKNef1inL8ZWFhDQ/++1p/5OfSOcalZPn4icm2Ak4+XECWqFKcgxBA5z4fNnNLgNZYYh9YIz8nWcfxjCes+Cx21iLwPdWHcu0DcImegadQxjHFILl0GIIMHxvNVi3Jnk9Jw+EuN/5mQDf9S9+STYfThz6oxiyrSEit81tkGxSX1OSAQCcfnpK21xPGI6oPVNr0J/QNquHk4Qk/9ZfPPC6DvautgPIOth73771m/9wRormlbsZpsShCiFxYppK0uhDU2Wf88Rlr7f7/B7kHggt9MkTdrWbBBDZfhKulBm8AAgTQgZsNh+kUKKvkwaU8cDRq+RhM5MXL5EZvYBEe1uEf4T4PCXApEJrIQQCWACC98ljYUwKGfkgoCVYxd+yVsCK1lXyqj8ypfcIuEJj4eNkPZw6NFcpq5HL9ZhhSlmO18kTZ3Z9On85HjEInHwicevQmCaFV06ATFjW4i2ZVpUAKTt4Gc3cTiUxTF5Ahi6QPR6lckRPflEKP95+WTrt2U+lvx9+I3vnLF7+wSQ/sfr0NfXXqhHuXzAmebS6XjxUIYTkrTI2ebeaOn3uXOaJysZx3mYc5ZqC8pCFacq9WAyurU2Ay9h0nKZOHkVnk6erUzpc91Nocf0Ln5e/mZvVXk2YIrCt1xPWL6ZsRhbOba8Dhuj5atYBnvG/NQJk3Q5YvUXX4ltz8HYd7N1iB5B1sPemfes3/2H5W4d2mOQdmkoyzPyiSnwn9Vz7tkqT+3ZIHiAVItkL60TTAEuDMFOogbPp0jJst19+ktqiNKKOP53Ak/ZgOc1RKgGWHGj+/OGOz432aEUPhc501OKY/oTAhG8rERKdWie1ELXY5nSUjtFdpL/bp2kbBp0A4C4VJ2lTFFGebbgauxhQFZIGe98DQuAHgP5CSUYoPpxT7dLhTs2nG4/3ATYAPPlFdK3Hn/UYFwkwc+Hs669Mx/jAX09/Lx5FQK1rI76lwos6XFh6lmYsA0u6X/RzoMBQ0F4zHQbPPIZRSkLz9+7iId41f7zwnPy5e1k9/ywdsZlSssQUsLsXpSKGgCGK1Va7IIsROwYMS84cTadZKAHbA+A62BfRDiDrYO8d+5Zf+0fSP+r5rBRZXUJWYX5y1Ho+kuY/Tmmy0DpVtRNPWGiT1tC0qARQTEc1XFQW11lr+aStJrAYAlx/6DjzWnFpmeUbuzSJ2nmAZbbxb83B0Rwl9bmeVDPPlRxYgZE6hTyz7zkrb9VI/4XKiEdIF5x221SzL9QW3XkEWAawsZZg+yRdi74uxESDPQ8Wt2eOh6WuIQNWd0z+TDYPTZV5tJgfl0k76P5n8BOC9IGvrYQXfWVEpmD9ksXxZ+l448JIJl5/mnS3uvsetqPjv/y3kyevfZQAZgY8r2/j6dVzrQGy/lvf/7lxXD832pOVEe697M8hxEzBXodo6wg4g0/P0zQlz5af8vvJIO3+udyP7rmlaKYNp5XIQOh7oPlw+nMGVzojlQuEAwc+18G+qHYAWQd7d9qv/7Z/f++zaj2k0E0AwOCpsvnfSpogOEMgi0GPTd4Cv6pT4V6WU2CpAqPAhqFwEvNlplUtk+JwXMvk4BuLaj2kENR2hPE+AT9rcfshim/4yqB9mia45qrPwJVvnRDa/bJOHjrnhEtmRi/ABG0Do71b/Hnk3Ij3gfuGJ706hUjDokkgc4phRtaeamtM0XszrlwU+NRyA7EbK5N0s6KHh/+v1yPcRpHZhymdL4TkSQxhX3jTuRQ2U9pemuCeyVOEkIt4atBlDDxn9jmD4bSVoTAYkp8ACHAxYHTrAaF1AgpD7UjB/ojP4WXb6qZD94Duc33do79oxCO5fslJjcWrryStsyretvYy4OwTzBdMvD0zTHBPbhPw2XUEsPQYrb1LSg4icJ/6ghTPz1rkVAXub2uBYSYLFMjFcjmc2mjBXAWyrJNFguaGGWsTp4w+SH8eLRGaWjymdJ9i/2+GlLBiaKHDiv6+sjA+YFTVBES/azuJl9gEoD+lfmJOl+s9fuD7fu/89R7sYD93O4Csg717TAMrHT5rrqKHY/ocHjctzljWf4vGhZX9shZQ5hV522oPmNKhGmNqv2+sACwdYhLgBuU5cQY3H6aJNwNXT5Mnh8nzdIwY6qydcHXMMBGI5L9nLANao+LO9DMTp659F3lNMCaFH1WtPM6WBMjTwMZAy4TkpcuyKdU9WzyMXhrvc+0xObAK083U8yvlKMQUP2vWMs9dvM8qJDpcJE6VDjnV13Qf3boXUGZVLb+Mm6bAAPeDLj+jy9RsHkQw1gVcfTmdcPlWgI2HPv9p5c1SXlr36Dpd55QAqZgGWtqbpUHN23i2gu73uWzFsrZitD2wxdvaCHyq+f3mAJdZLUQmRWf2ao/0tFLPLgvkKu/WpJTsdVUBvjc6xKu/PwCug32e7QCyDvbFt1/3HX8MQJ5Sr/VzeNWtJ7g7xRf5I5315vSk77PfQD4Zag4Ok7olWxD5JJwVB44lXNxagSbF27r+cgJYi8cjqugpqVSh3vFE8YNGVmcfE6jKikVHr5Zudzc/Ocp16j7SHJ2F5pYpsjxfw3ECIN39vIg1kEtPaB0tBlrtY8Uj6zSIil4aXVpGZ0Xexa+ShunQ4cz3+npnrj0oWYfxLP2tQXYVgW4W0tSAPQIvrwpf2908P25iPpua/Ncv6ZqJTMBPu5//zB1g683L2PA7ZB3mOFgaMM2N7eq55yzUbNu7+ltnRjLIC/PbZkCMt1UgKwuFLqJH+SiBrKx2p9q2zHilbZXsiJI+cZv9PtPvNwOuv/k3/5297Q52sJ+FHUDWwX5+7Zt/638A2wVMCys8pKm1UovOTp4y8foUSjJTSKVsomckVClc0l8sUMXBczyu4bZTtup120HCNWX4DqCJlT8LlcG45LRx/h6oNwxWUl236laRuNdJX2s8pQn18S9JOfwXPxW9Zs6guaS/tV7XXGae2/QwLGWgPQwxFGb6IQFIl8Izwbmk4TXnzaqrWa8P10qcljVsBEHDqQIjLHkwzgOYSfNgtnT85okS7NQgmbM+9eRfhgi53TNtFaCpMyBLMOZnAII0UHHsVC0/7SHhZ6i61NegQEEEatl91GCYAaQ1IvcxXijPTGyfr608c15pQ5nYNfXtKMKsZpjkWO7hZWz0dGdiAx005AT5u/S02PQ1jsrjyIApE4JV8h8qE1WuQctAaHDGyvWRTB8GJaEyquzOtk3n0cr+SwWsjAHGKcmu1C7V9ozXzuWUAFoYMNg1U4Dtpyw0DCRv9bR0qDYTptYeygAd7GdjB5B1sC+8ffNv/Q/k75BlPdGvxWO1Sl8rfaQZYzDUn6tBNlMJj96H7XyIhPf3Sm3bK1XyXoXCmJjOpUMAoFYetupal1Chc6y//Ew+e/LVdKwX/tFOvHQcgqI25IWTS6ufkpZRpnY+57XTYb8ZzSgz59WZ8cgAKWtyUqFLFov0tRWAFbQzI/JbdIh3jtyuPV1Z6JcJ77qmYjmJAm9f4++OkFS239y2ChQwQNb3JLvPEfRq7S3eB1DA7IkSFVXgl70xIVPFn7ln6vnnttRPVChYXb59fEnbzQGtuzIR54CW7n8GV3P8rKKQ+TNNk+UzkJW012at4H4BCZABmAdc2jt9lhY4Iidyx3vGz6VOoOF3s7s/n4F6AFwHe4d2AFkH+/zbr/hX/zhczCTjSXlcWvmsuZpgpyCAyIQAd9PlcgnGROmFKHD4ZStUa58eWQM0T3rAICOvc0YgA4vgyNPBfA3ygCn+0KoCfJDyL243SakVDgdWuymBP9Yyqp2cYzpq8PhryEPRn3EGH/Dcjw5y7YuHXTbImzESpePmvjIIjorrcpgKo4fdRLBS1Oujf3jytkmQMwqgMnAyw0TE+ZHJ+Q62GyVEavsJflEhOJuFsqbWybG4vW7wGOIKf+R0+ujhC5XJvHxuM8L2IxXR5slfHU8mxCll1ml9ryyMyduqPuAQopm8AMvs835In+/6fVV47ZlR7QsrAkzTySJlosa+055F9k6FZS0gqT+rUW2n9Nw83ZKnzqhnD5BrHM9aYArybAHAcG9BtRq3g3j+/LKG6SZ5P2yXi5EGY2CmCebyRo7PIEkyEJ2T8KKM7T6k0B7zvJxLnxlLf+tQ4jjmSQgzcg9ZRqLu8znTXi+dxMDG584SF6hdEp6sotZdrTXvanAihD/mups2jg8M4AAEqEzhBvABobECYnUWMQBMtUV3LyY7SPLAofTPwe60A8g62OfPfsW/+scBELBilWzt3Vg+pEG+uUwrRvYSBGOEf8Thl/6i2ZvM6+shlT+JRYMz8DLl4ApAFgZgsKVr6mmzarXKg6ieBDlLMdRWJr03viGumk3y8Jz/1CTHEAHOmbqFmiTOaetA4msJyAJmCzhLuFB5ZrTOlYRB79BTYu+Gr12mfQUAwUDuY6WI/dvnmtjefT6W202Jn8YhLi2+yjZHcvdJriHzZA3cf3dwtjj0pL02b1eCR49vfFxjUqmYF85pszqVCOJn1Yxejs+ctf6skWequUrPS/3oVo4jxmHKVS3HFhDvvXgTqytdp1I943xtGryoUkqS/DDHo9Ikd77ucZ7PN6vBxSKm2hPKlQSqKtfz4vbOSEDM2tsBrhmFe1iTpEk0sKvYYxjBel0Jd04KsNdWJDtEx270mE5UtYdoDLa0B30ThVODNeLtPoCtgxV2AFkH+7nZr/xdf1z+lrIxIZHYl49UJl0EVxXr/1gr4UMfuTDBWfQXNDAOR6wE7SVMZ6YAuyukEYA0AM+EGTSxXbIE1aPPJV78wiUxUWdgu8jtkpV/AlddbOPTr6oEXLVPaLvlYy/ginlM3H7fOgED49IJOGkuYxjKGdSRAyQZhOOUvDhzXCpn06TCk7m15AkcvXhabD+Rrtd6kExG202p5mDNoVQrBXrrW8UVi54urVfEI4CZkvRBtR5hJg+7GVKo0nuYbiAAeBfAAgBnyQOlw3nDSNvpzMemzv8ujQFp5ZKcBXs89LG5faPScnIWoW0wna9SeM+SFIjb9Aksew+/aIDKoj+LYdaFE7DcvJVChkZnbEYbz5dybKczSEFh26z80zAitE1eCgogr6Wo008JZEmJJQV62PMzjsljyP00jsmDNVfz8g7AJfOE8mwx2JISPfG7d+Tdiu0S4FRXs7pxsr+xSSriLrDlHHk4WY5kUWWJJgC9G5yYwRIv00krY4yIFnejfNZFMdvdfQXEd6nv/uv//N+cv8aDfSnZAWQd7HOzj/7m78VwHMMWQwoJTo3B6o1OVvPMPTL9KJOS5uR4xWnhrLWgvF46VMd6QdobwwWZeWAUrpXyyIgnajMKL4NlGcyQyt9o6QStQs6kbM4SDMYIALz5QBXbBzQ3sa2R7G18SCAlhkRDnQAlZ+S5q52AS7sZ9uUZtOdmJmMw41+pcBjLE3CII2TyE5FrcuqwfDjADV5CI9xvwRpJgXcqg5KJ7VofazxOE1p1G0HWdoLdDVQuh8NrGhzwRBqBhz9ZCkk8HNGzYPoxebC2KrtvjkvE3orJp37oZjLk2ib1KQMtzS/Sv+O9mu6TKrlvKgGMLGIbmgrwHuNJK8/4tEr3hMPhAFA9utlrNica+FUqyF09pQWI2fXwxwuYTbe/gFAkc34GQu1SHcvr5AETcHeHF1BM1UMM27j/HJ9Lk+jfxquV9lVZq+W8ckfo0bb7GYN7bQGSRyt4AZFybi6x5VzqL/aQNrW819sXUjICZ8NqTh3fJ0BlAYeQFzxHXCDeawAPDMdJpBYguY6/++cOXq4vQTuArIO9M/vob/5eAMBw7ARMsGmApcEVwNyjuIJUmVs6rZplEbRaO8scGJ7k9aPKYKUb4RvyDEkNPX5unUnp2lr1XGcnRuMMuvqpIjhHoOOPk5Dk7nnabv2CQxU35XppQAJXUmRYkeS5Tp+72i8Z41e1gKw9/as5L1YICWDxtSlRUS0dMZ5EAVEVHmVlcgFZgADZkbknTcr+ZA9XcBBAJllwJim56zCZu4neOBXuFFNCmjyBmW1Pns1lk56ddZzstfduTlJA111k00WUeZJnYDVOicNm0zMnv7ltx1E4dlElnSwt0RCfoVGVEBqOYxmY3qdyQ5FQbW+3KSuSPY+rVu6X3fB21HcCspCHQrPi3dH8cQQKNoXb67cI2Jk+lYySQtONEp7VwFSDLCDnY3G2rw7VKi8Vfz8HtEqvFnQImQnt04QyrJzJPmjTQKv0dFVVquFYZjyqkLDc31UjCz1O8lh94jq1QbVpPIveR5XdzNUAWMCYgRaQwu27C4eqo38OYOtLyg4g62DPtt/wLX9U0std5zGuHJrrAf0pDYztkzgx7AYqJDukQXQ6amC3o+gQsQdnap2sAqeFI0/YwgmXB1aBKyA9pgFpIGXS+ZJKooj3avAy6Im2FOMpa8WbxmGgcVXDhIAqyipQyAWAM8KNsaPH5uUl7BiwvZ8mjtVbo3is5NqWyrOzjpNsR2Ecd9PBKA9LaJtE0DeGBnPtZWAvRPSsMCcpRJFQM07Ju2cpZBhql/F/xpMGZvAYTiJ4WliMC4Pmltq7fGMbj2kQnCVPJL/VJk4czJVrDWxPfLupZa9cnGh2qd9tP8F05MnCMCbPm7PU5pkMSFgLs4tZiEdLql+o1eel0wqQZVOoNANZ45i2rWvavqnTfrrEkDHJQ2at9LuQ79sGoXaYlnWm+G5iosXUOpX1WomiewY6b/sMZAEElkIER8wXslq2g1XtK5eDrDbKWlQue0b8yYqeW5WtWL91Q+fka+p6eoeYGL+ImZGVS+R3DiWuyZsTWFvOGAJJ1qZ+VIWpy3sTQtjzaMkx5GJCSkJgIMRgK3q5eC6ybZuAntbBm3wG/GCNAC0ggj0+HrdRwusV0DYSuh1OavSntJDksc1d7SSBQd6Fo5aSH0xauLGX3MuzQM9PvRkxLiu43SSk+Wrj8YN/+ZCh+CVgB5B1sNy+5aPfAyBNrMGZVGZEFTnOsveiSU039lKpp4PTo6cFFWX2jRNgwoDLVzaXG+DjMmdIZb9JOI49ZyGBKl55yjXUbk8tXP+vU/TlnNEbsHthKUBmjIVo61sGE2nyH07o2purUQCf1tGq3qKVsQAOnsB5wuLQBpDAgipro4smz4lzanFNTAFhUQlJnyfw7YsL+Ip4I8y10m2UUJfCNP05k3uJd2XHMAuw7OTJcxj73rInaxhzQCTtZXFOJQR5SSRxbOO1xpJAAFL6PvcJc7SA5JWaI7tPE7BcEKdpUXhFQoDpinBmVjA7PncnS+yZh3iyZOJdVBiPa0wLI0WLmaOzeNQnoMVgWd3H6f4xnX6TQDh7tPIyUfF3vN9miFyyrhcgNt07lmOIsO2bT9Jls6fKKZC2jGHaut4L6YVdbAcDtTmdLGA/lKvAGHukggaz/PeMvtbed3RiOUbibMVMP2cFDMq1S1KI8qgxqJypAhAqJ/26e4n6sD8jHt/Ra13KYmZOnoVk8c7JcGiPu3zEfMzjJtEg4hj6N/7W79s/xsHe63YAWQcj+9g3fFfKKouTRnXbw7fVPLhiDhSTygPVC2P+T3U7YDyqSY6A6wI2qraYs+T9AtQEkki8oi1kDXbPNWiuR2wf0IC6eDTAdV4GL26fuPUnn6mh+0VNZV/0eO1sIjErDk4whgCKMdi+SJMrgyuAABbX6TMjke/HZQKHIqra0+RXvXkVdyQCr+kH+KhibUqvDLetdjDdiOlsKQM7g6ywaHJ+DRTAKkj/wVK7pmUtr/r6lQVcH9Bcz4Ms0/sMYA8nFYYji/pWZxIS4OIJo2YP5BRIemD0wrFiz12oSY4jK98TAnxbJ3AVPVkIgSZM9tJNU+5xAVIfOBs9lDaFUxmUzBDjg7Mk78B1DW83NAkzQVx7XqLHkLcNbUX3ZlBAAfTMwBn42mE4Y/4ehWX7E4PVQy8h8eOfuYXddNQGBbL86ZIWA8ZI1QABWYUFZ4GmRlAiugJqxwmYJkwPzuj/WDXArHeSdcggiz1AIQSYVQSS40h9XYCc0PfUN/2wV4BapBu0cOmMmUWbeFx8DOU52wNbPn834wnT3xoYM7drRv1fe71QVQQknUvPkq53WVcIy0YydLt7LYZjJ/fv9Kcit24GaPmGCPBGFjdxvBsDvRNTGrNC7SgpZckJPzHLtJvw/X//D87238Hek3YAWV+q9rFf9YfoD2P2eEBZ1p5SXWf+ExduFeKnKs4sqt7MD1IrPM7agUVKY18kkAaQR6q718BXBn0kjx69yQKjKgMoTqh2O6TwmCoCDcuaOJ4mVi4srYoT67R4tinys3bPt7BdwHBC11zfevG8MUdpWhjhI7E+lFFq6FUUEy1T7iUbLIQEKlWfs+p4dZU8GVr3CoBkm4GlKoqi2KnToxfuRPG04uDfPu0QjIEdfSqIHYENZ08OxxbDkj5bXCViP5uNPJP6ZoAdPWwEWdxGbj+cI9BSlPnJwmebGcI1X0bbEOBpaYI0uy6l588cS18/A1Oz6wnsRk+ZLlqcwkj7yQQS3nQO09kSZvIY43MiIHX0Ami5/FOvaiI+/Wra/uInCEAtPnMlfLS0sCBite0m2JGyMff6Upn2XupkCQlJ+wB/diz9IuHH2w2kMPR2BsjF58gerQiIVS71Veyf0rsFJOAk3kfnVOFplQFY17nnaU7wlD2XMwkTswT6OSsJ/loiIoJKYy2waOl4/P6wBMo4IbQNwrLGeBxlZZRY8eJRCifS8VNCT5KwIfA/HZFch9uMUk3BKsFkHid5LDNTkHH1+//Rd779tR7s3Wp3gqz92edg7xsTgDUFybILxmBa1qrSffQ0LOooVJmv+kqAZYaJAJYim8oqe0eilKgs/dwBsPqLBt29BrcvO/THFlUXhCzqugJgeUiGIXFqeJJkz4bJAFawSZC0BFjMY5pOWyCQ5pHtAsYj2rd9OsIOnoBmTZ8ZH2D7ANt7AlghAqxInK6ebuktKjhgWvH+LgVqIGWZ6T4XtXFLEgOoUpYZZgAjg1qjydpMU9qMUcTSJ14ZC60qUjEDLDMzp/G1uM4nPkp8fvh3WNRKoylO7O1MaCUCABbPNE0tWkmGhSWdTcWiI8DSZW6yjEJppOLghECgQMkEGGMIQMyVjIlmdvG4DCKcFdkP2WaYgNHDbQcJ+S1e288oZG/s7oNn8hlntzIoG09q9BctQlunBcSMTIVZ7wMk8RzuOoS+h728SQkEDJSUWrpZRY23mefHX1P7w3YLdJGLxvdptaJ7Ukfuk3NCbhcgNk0E5pSgaQgBoe/z0J5Scg8hykIMQ1o4FPdLPFd3mRa/FQ4XLbgkzNgPQD/Qve+HLFwvIeSKeHdmO6B+uEF12aG5HkVgWZJ3bPzxSRhZ3ikWsl0PqK97TKsKw1kL31bwy1rAlekm+hk9jWtqofSxX/6dd1/rwd6zdvBkvc/s7V5UId4quQUReSwz3gDRk8q+Kzgqkta+rOW4c8Yp1LevRA/LVZCQ3OrNGDrZso5QPK9OG5/x3IjCuwojuds4UfCKVZU4CeLxUeVSohAqhwCl3tkYJHzAA66UU9H8rrlUeQ0Gy3eMwVSh6E37qXAde1ZKkOaTHENpw3OpzIjuu7Jfp+PowTqtcPsSPxO0bXvNk1c6LgutAkDFYVsG3uzV5N0WVcocZMB8q8AkT45zZVtYqiCGG81ml/pnVKEnNiXrwPwvARultlNJ0GYrMw/rSs7PWWYiCcJ8QN0Gdf+6l0gKYvM8PV8nn6bnZDiphVfI9fLY69O+qXS29PvDwLLoo8wrGEOvwmXTITP9LAkoY89UHsKH91KsGXUEtovkQcsyERlEx+xCCR/qPimAmNbOkv1UqFjuS6mfBexpdN0VppR9y3vM564qAfQSztagk/W1ojc5tE7K7Tiu0fmI7pUuvRPKjGfkoUUgLlYZ/DJHixef6lhW1f38vv/2D89f58HejXYIF76f7du+6buTN0PxojjcISG0PgcuEtYDhGMVnIUdPakkx7IsOnxG8gUmyySj33Gw9ElXZlrWMJPH+gNLeEdp064PqLY+kcpVG5xMYHE1XNMkHCwBQb9wQkKn9k0IzqRVpMoIIx5QBVgTifaQ/YJLRWSBlDGos+1EcDXyscxIpPXgDOqnW/KSNVVWkBog4GmGCaGtBZhmRa+9p895AnQ2J8BXCXjwQJ0p3XMYtItZdUymVxmHHOKaWpcyAXfp+TCjx3DWYlpYvPVLa/QXHvDUxvOfBI5enxAc8dJER6tTIUQDDEeViHEGS8Kkw1mD9tEW01EtoM5FNXPOKKSG5aFETBNQ1wh9TxN71wt4CrtOvF6iXO6ToKgUFo7HkH1cLDljbNo+hKSxpCdXkThIAq/Un5G3Y60AXffwiop2bzsh2IuXbfIIiwbGB/QfvED1mK69e/FIMmuDSc8ba48tX6Pt3JPblACx64nfxl67rs/7CAlgUZ/E53WheHs6o09LKViLcBMV6vvcKxjGkfp0mmCWkb8VPMzREXmM+R50HSUsdKTvFfoh49aJMdjSpY04w1CFD8XjZQ1tO+O5ZV5ZumYVTmRvmAbwAIzOcGWtrSqBXOJtRWHcQgaE31uW3mBR0mpLJbFMNygJh1jc3hMINioBY7yghY8ZJhmHjK656mJ5rBAo6iCc00SL+Ks/8t042LvaDiDr/Wjf9k3qxSv4LZpPknhKzG9i8m8awLSIpwYgmfEpVJhpPIpinYpYzcBr81L0Biziiv2KBt/6dhLxPqcEL0UNm0EWj9lRn8j2qW2STaWEAiV7sXHZbxM0v4qVvdNliZdqSr/LwtUMdJq34uSksuU01waAgCwghRo461K8V9pKkAW1OpaTMDCeKY0SQRagJoQHcWCP11Gr+8N6T6//95Knoj+j47/yg0loFEAGavk5Yo0oIKm/SxJFfLYykMVtZ7HRmUy1PW2mtkkggvtniIBAeUWyYsIAAREh1hdgbs4sgwDt0ci9HT4Kp7qnKiyoskclzMjnid4SHz1r2rvIMikC7AHx5rafpszAjNjPxp4odS0SrmNulPD+VHh+LpsyGgMtH0OEfC8YZAEJtAngAnKgpc6f8bK05AOQjU/S13zvZsCWUfy4Z5q/4x7PgTSts1bl3kQBrryNTqIQOYcUfuWxhYt5pzGLqQpj0kpTpaP4GJIMxM1n+kYEWkBauOlrO4Ctd60dQNb7zRhgyQTPiTPskbKGuEMy8Udvz2agfSJp3CsPFkAD/LSoBPCI8YKxJUkGJkynzDn6Vd+O2D7fyCqQAVa98bBDgOtohV0CG7cbhZw9rSqZpKVga+vgdhPGowhaNrmHxkViPAMzHgRF1+isgutCBq4AAljeGRHk1J41bp9vnbRTatQ5B1R2j9AuBamXTGD3cLukhi+erLjqDs7FVa8aZAHyDlhLZYU4DDIpLxav4jn8wV4vZzCetJgWDuPSor6JYGfwVFqnsvCtw/qlGtcftvBfS8Dh9C9TKvvy0YT6diQPYZdAHAnBWvFiCeCKJZGaG4/dPYfjVzuMywrNkxROdZcbcLkdDAN5QHSZF4Cug0u1KK9GLjzax2yxVDaGQVYYx3xfIPdgxeuQPrYufW/sXmZa8g5WQjy3V+u0f+R8hb6HaZokzFlHXpkqYszWfeg+Pb+e3pOptai2kwDx9vVr0hvbdnk5ISXsGYZBsiTNYpHVEBRiP2cQ8vkZdLKCfAjU/13yhPmuU2CfOV0RYHHG7NEKQfGdWPAUwxh5WRFoiKZXItGHEPYXgs5mPC0GWwK0GpKZMIUI7d6cdQfQoudhyr1ZgPJYOvJ4MsBfpBBiqJKelxQgj+dhra0SaJGmXczanULy3jLQqylr1TcOsCbJeKgwO5VPirv1KXkHSGPLAWi9K+0Ast7r9q2/muLzGUdJASwpqTIFwBjJbJHJXXEceFBnr45R8xIRv71MonyO7YuL+H3A7sJh+WTEEAGPZ2pBVAd3veIY8Bx6HcmeIQGrEtAMUfh0d78YFNVxlg97jAuH5rJHqCzcbpTr2b5Ag2RzM+HmlSgDceml3QAQeAHbBUxRsoH5Fu3TTq7ZTB6+rRCcQfPmTR7egwI11krmH4doubgsl9rR+jk8EdjdSCKumwFhWcP0I6V7c1IBlDdL3bu7NMJgLaZlDd867J6LwCPutnqrJ9A9eHT3CRy/+muj57KnjT7wA6mN3G6tsD0tKPtyXEUR03js7ozayMR5ADj9DO3fvkGA1Gw6AVhhGAjgsJdJ92sM5zDgkcmW/x+GBGKAfMJnsMEhIb/PL8w1k1wOKiS8FCd0NTH7syP6bq3kE3ZdBFlD7rnhU82UiwmndJztlxEZvtpMsMNEMiMxc83eRCAXJRq07ETK0ktZhWIMBFg5fbmAP17A3mwp7HizTuWGuM82iSfHoDfzAhqbkhK0R0lrbQGpfcNwJ+DKREWLe7VXJNpaxTVLpXMysKTL/ujP+Bwl4DImbV/KQBj1OW/P4F3r3IE8XWYY89qUHA5UmdAMZmX85bBvm0osSVsVqJLKFo2LxHhLC0j2kGlZjTg+fP8//E4c7Ituh+zC97J96zfPAyy/cPALlwMs4E6ANS0qTK3DcFITP8QZAVh2IOkCzqjztYOvHXbPt9g932I4MhiODHYXDs2tvxNgVdvomeoC7Ai0Twa0TyhF3Y6BCj93VKdQC53yKo2LEjMoaq8mAVj1zYQxtjtUFr6xosK9faGFnQLsFHDzSo3Fpcfiks5ZAiwzAtPSYqpNBrBC5EeZyWNa1dQmAwICKptSG18DZ1BuXo7lOGaiHKnGoMN00sIvK4z3l8QRW6bv7jIO6QqRX23L2aJTGz13URbDTsAuAqvtizTxX34kEt37/evh8J9OdJgWDuPKSZgwlJObsqM3ab8mAlbTjRIiFc8HAyye1NiLWjmYymV9rSdgmfi0JMPbmVcelLLoNl+HselYuhxMadwWDgP1Cozy9vxMj2O5N/Dkik47pOceiIkaLu9T2V97qmZEN++0KJPhT1cIywbTi/cxXZzA3zuBv4giphdne7tJf3N2pwC8O0CrMdSeqEtlVksY50R93dQVEDzC5PdEREVeQmWOhpG8tMaRdzF5xdR9nANYdUOfsfeNwWFV7XvSrMvDkCFQP0/T3v2XUDA/c/1AIGvyMNsOZkvipW7dIzjScfPLWrKh5R1tGzpn1wM9ZaZKwki8FvG+czJPRZ7jaVlLxnZwjrzogHjAvu0bv2v/3hzsXWMHT9a72BhcAcg0iwAVjpIJJAIsxVFikuXUJiIpT5QiMMl199SgxS85l4boT2hwr9dxclBzG2cKrt6MqzilH8UZacwH0rpRbAwcGACIwvsmZsG1iqBealXFa55aK14pKc7M4Ui9uuU+4BDXdQQE14XnBklgsHntmj7Q/CfOgIveLCkmC2D3gAANc80YxFle5SrvHSvm82el+OWkwpTSByqMy94sLgvEnsD1S7EU0nWa1PieXX9Z9Po9T8c9+zh9fv7xFDpyMXtQq+V3zzGhOp473sNxwcT41M7lmzTBcwFjEViV8InOplTPa8mvYu8BZxoyuMlI9MXkX3qyZrS4AOwBFVOq6yv5A39+HM8f79NVDBmLTtUMANHq4wwOI8jsvuaD9Dm/g09T5p6Ngq0lH028eRq8sfdJA4M4AdujWK/vhXv0VRFyBpDqTT6+pG3KbEFlexl71iYNKvaeMcC8Tty1vWPqQs/6+MrzV3LMTNOkz/baoZ6lulD6L5+BLCu18DSyd1DfN96mFDMF9jJS2dspnCtdVJr5o5uck8hh6NBUqQyYPkeBI4XHV/JFFYf2r/3QH8TBvih2CBe+V+xbf833yN/sfhYwwUJ2VS5fAOx7IJifROrEBDp4e35Z2dPFIaftCw2MJ2DAhYHdjrdhPgvQnzq0T0dsH1RYvTUKEGofRRkGlYYswKEIgfGqTdLZgbSiU5mK41EKT02NQXOTi4EylypYg2lhYYcAMwbYycuAxWHR7f147tpg+Ygy6NonA3QNRS4506i0esuSACbKXVS0mgy1Q2gdfGVlP1Gb1yE+nigL4FeWG6LGKeAUUlki7n9f21T7MRrXIRxOHKbGYFxYTHF+cJycdhaB8wWB72oN1LcBzW1AtSMtsPZJLqOhC30LeNyxp5LazIKnmshdbVL7qiuqTcjZeOZmI/wrAEmmoKXrDccroOvRf/AC9ZMtugcrNLGgt3tEgDesN8kTofWzrCEvBXO5mHMl2YxMHCSvh6kqakfbpBqBvK1WaY8TqOiFMTcreouCFtkseE2om6T/BZDHZLXE8MIZ1h+gsBuri5v1jt75zZY8L+NIx5umFL5kECCg3yZZhkK93RwfpXY9dwFtIobJiRjRywYgicXydXF4TXG6wHpUUX8rC/kxOL5lDptHGMbopQqR4xXf2xLQRR2uMIyJs8VcxBJg1fH+GZv6iK9dl2fi6yrPpbl/hYlOmL6uqiLgV4YbFecKoBCjXzVRFZ509wSAcoJR5GMF52CmicaTQhWey4zpJByREuFxlftRxtXUR3/97/7+ves62BfMDiDr3W7stcomXDZDMgRcET7URFg3U5BJPRVd5hXRPsASMnuhMQXsA6zFQ5ZDoEFhiFmEJcACICRnU5LltfHCz3EWXMzAUqsw7bUCQPwfQGroTXVq79HrqZYhgGcCLPbibJ6na5gFWIa8g9yexevkUbA3Sh8IkKxBr+rjSRiw0LPiDErNeeNrrLaUYVltJ8AHGjxj2j17piSTUnv+Isgal45I0xHkDFEOoDvlPqPtXQ9snjdwHQEsAKhjdZujN6hhGmQZH2C6CaFlEEzXxgkHQMo4ZIArZZri5TeXSRagusw1q/ayK1UGXYhliPrnCRww2G6e7gBr4d66JJkEBhXOEXnbqH4vJ2LtMeFJlnWgeAKd8VQE4c5EL1rRfnObngvxOulJfJroXZwDWQCGX/AiAGD9gQWaG4/FG+sMZAHIiOXUbiKgZyA1XvuzgJYxBuH+uUhjmOtYEFrXeGROF3vpuGi0DteVVoC5vexGY8iT1Q/zQEsfXzrTzwMtfdpqf2Gm+YNZ27QA6lyxayAB9Rnpib3Qdgm0gESc53a1zTzQQgJQ0vxNPwu0AJ0lHYHZbtoDWWbbk+gvryPa9J4y8Pprf+8P4GBfcDuArHejsddqFlgVK5/heH8i53R5EaYMuZdBAxgRDI2TJpOjuVZd+3Czv+0xTTD9WeQ3xPPozDGpd8hZjFPe7mwlGV96Dq/J4MH6XYVnDQD6cxq4dpFgvXycSwzoayw9PFz0ePMghjTfSv3cPs3T7vuYLbl8NYoNKpVt0QRjeYVFzp/S3CjRDePBPjaPPT56Iuf2OlnV2uz6M25GNAZpkhUax3Xun0lFQcYV7T/GZLPhlK519Tp9fvxa6o/FIybps8ZZDIWuuN3puNU6f16nGDLkjM/6kXqWhLfE9zhOTKyDpcjM0xl5dvh5Y8+aexQ9PVyTbyZkJsbHs+xlUA3n/UrZBplA1X08juE2VurmtPqiViOAJK/A0gaD+g4oSvjEc8dMtiff9AoA4OynCNy4h8qjFD1BobjGZ3GzxAtVno9De2ofVnqXeoanMSwqZXmSN7cs9xNK7hIfA0geIuZFFckJWRv5fSjCvnsCpFBhyULoNBNgfRsrZS/yL+NxWJpCVOSL50S3i/cptpG2ApLwIM+SZAu67H9AhXOZMhDHyql4DgGgfhzvDycXFEXpvQJsB8D1BbcD8f3dZgKwOPNs9PSjSkSwu5gnPF1c1HVTXkImruRY0FPi9oF++osWfRTT6y7o5WOF8/Zx9EQN057qO+v6MMeIgYHdDaT14gz9qLIYOnMGiJyDpsK0ajCtGtKhioMFAzbmpbCSen25Q39eob6e9gDWFGUhWCiT26UBVwmwmDzvek8Ai/vZGPQXDYUQX11L6SEJAeg07kj0Nd1IBP4d90Uc5MpV5ujJSzaFBKgiiJHftymN2wyUTSS8Jw4rsqDokEK3JgT0JxZD5KJNsXweh3lHzvaLv/qLu9dJ1TYPS4fYr9Nyf3gQXTOeG9scKIsemPf00w/0M/k0CbCO1Ak1OixrWsFHkvrizQ0WbxKgqt64pOOtlXdHvSN7psnLgBCf6WDxd+TqhJjtGHr64RIsAFI2WJnscJcuE9RkXHKDSsK3sosffQoAuP1wDO3xRN4VGYR8Xd4n708BFBJHzKefIQdMAnSipwrThHBzi7DZIrzxMDu3hBv3agOaLOsPAHzU3MoI5FEmIoQgEhumqogcLxmKudI7mzFRlNS55K3j+8rXJErzPoEdUwAiySBMnLYwjlIiCCZltSYQHsfUSL7PkifYXAHiRduMtg19n2Q9RB+OfqW6hRN5sFonHihdTxFAVgIrWAMp7YMEouS94nZvdjCbHezNTgqKc/3EQ+men387eLJ+nu1bPvo9EuISgKXJzc4IuAqNlRdHlLd7BZ5MmtxKcTsgrZyYEM1eCdZOaq7Sirss8SJiltzWPh24utpm25Z8K108OsS6e9OiEgX56ulWSkoIINkNCG2VhDxHj/75I9Q3Pa6+ggZ7F7OypsagfTphWlhUW49xadFcjUIuBxKQ5PDZ0Rt0fSKaqiYO5hutPrWWNkmaNnN1xhx8imioMZT1U3qfdMq61DXMJ5LqskNpUmibm8ePRjwug0e+tt2FhZ0C+hODahezPWUf+rV+OcAEYPmGQXcRsHxo4HYB1Q5YPo7JCdeppJAdPabawrc2Du6UEVdqm/EzyeCvidcj+j+AkN7TMxLLjZwus8+BlATBnD73OBKo2VNUqJMD2C+ozJNeGRIEZjP2aB/2jChPVgxd+vMYCmMAzTIOyttj6ppK9rAieSmeyhO8UmsnpXGHcH6C3UvH4rE9++E3aZ9pArqejtcP1PZpyvrLFDwtAVlzhZjZa8LAqahRqL00TJoX1f119EzytvyM6/I+sU/tckHFpkUMtAghQnmTuJ0cdiu9knzsiULqmaYVhwNZ28q55L0EpNi1sTaFCXVIcU4sVT8XBTFf9i01t+a2KYVOuT8BTJHfp4WLAQ284kLHGCLKO0sL1KMmZlKbvQWaexoBc9cjLFsay0VqhoV1473kBAjv8Vf/8SEr8fNoh3DhF9u+5aPkuRJVc62HZC1CTem/obJppcIq2uuBJm9D5WBsT4Ot3QzJF8njiHBoKgRDL61vLKrNBDMFVNc7Kv3STbRvFL30iyp5Pc7iBOVpYqUSEhNsP+7XK4zubHFjjz5JM9QOZjtImzi0aO6YGNl9rtWP1x88gus8unOHsTWie8VWx9BVd16hvRwRrMG4ssJVc31AfRsnAK4ZVhN42MaQ6ckneFUfEuhjAvpxS+nZxghvwkQScCjBZQh0zcOUakKWZX0a2s/2E0JNBYinZZU4P0qfTMoG9RP8soJ3FtPCCv9q8xzdi/GY7r+vgWoLrF8JaJ8Y+F92g+GTFALiEOHiSRCOXrX1SseM/hhXDm47YTitCFgNJODqduq+xuuurzv09xZwMXTrdqMUIrcMRjgjMIYwQksCkzLYixp8j7CoYbY9hRSHkUCVD2nC04CAnxkmKEeAY5TeFqqKJmEGvByq3G7z8BRvrwCBqSri1rQ1TDeQ1lQ/JGHKqGcV1ptEwG5bmqgjb0ckC9h7JPIEDmhqyV7b/qKXAFA279Fnt6gut8lzF8sKeQ7daRX4SEA3zgqwCeMoHh8J04WQdK6kzE3SotLSCnwse3pMwqgRIAggMpbAY5RRCFP0mIWQzsuhsmHY51Nx8W8BSYv8+NEDxlpbc9IRCcBZEhuNxzPO7YWLBTiz3pglkvxeOJJLLqlkg70qBGya+K4Fc+fClpNPpZycBZYLAj4RPGH0ifAeebRJhJQzkqlvqNB0jeG4ggmA24xUqPy2S+F4XtT4eF5VqivUFRWKj5UIeCw/gK3Pix1A1hfTvu2bvhu+snDrYbawrG+r7DcDJ53uL54RFrPcjlmwl8nS05I9LAR82Pug08TFc8bq5IUEgDb2drmbLgNY4qpmHlUpz8Arf329PJgXg1aQrJx8lTgHsLrT6O3g7MI4NrMcA8szsCAq84SAHGRtn6uFY3b8qQSy8nZxJtD+ClsDjlC7jJwOJNIqgyzOPjRK4qIELaVMh2QVcbaRAlndicHUGgJYADxHme7F+/1hCt/UP3QCAFg8TseWvouyC5ZpIAOHqel81YbDEAlk2d5jah3qa5qgWZ9Lkio4XX2Xh9t0GSLmBbrrDqis8JzK8jsCsjgVn8H5HDcGSCALEOAknhte2XOmqOZNmWJyZC6R8kDo9oW6Ap5ckgdLgyzVNpFt4FBOJKbLhK2z1u5TRsLV1z0HADj7p09oW25rBJL+dp17s5RkQ9kfWYkbYA9kzW5bmOWQ3tEq8c2APc7S3LFmeUwAST+oep3C5dIFpPn42yj9wR6mgtxuYlh/D2gBSS+LpTi4z8ri0vr5KT2AZb/wsRlg6QxDIAdZUgkj926ZyPXTpXakkP2yFqBFx4vv4WWic/hlje456jOmINQPb+VYArLG4l3htqmwbGhq4pdOAX/1R78bB/s52YGT9cWwj/2qP4Rv+6bvht2NcGtd248kAKajhn5WtUw8bAwIfGUzgGX7KdUejDZEwvC0dLS62RBnKPGoYmjD2lTs1hE4KAEWSwVUuwnNVQ93vaPCyzrDbUkvJjg1OQQqPFwCLC3WOHnhQOnBKNRV4nXxsUYPM3q4zqNejxhbg2oX0J2SNIEdA3b3LdwA7C7MHsBiIDY1hjS02lhMurICnO4EWLEtoU3eEjZTDNBlcejSQu3IO1lbCakxh0k8OLxaLeQ65szXBt2ZE0C1ozlZ6g6OxzGM91wMr/3Y8d4xmpjosHgaSeq3uZ4XAywGXLb3cDsPtx2lhBEDLAH8MezNntdyVNElf4IzsNtRnmHRamIvCE9s3ou3ZM/uEEPNvEcFf4cBvvBsNBentKkAdfxcM4CIv/3tmvhGu07ARQkM2JOyJz8ws7g9epX2XX/knDaJIUsm4bPXh/mPe8ecMxHwjP0iGYssEMvX6PdDZHyIq+u0DRIwMjOeG1NX+eelJ0pqKZLnMWy2BECnaU8LS3hbVUXgyRolzxEI5Gnulu5Tvp6Qxig6r03eLs4SVNmQmRWhwYzPxVUCBLyYnHtXhkvHEQge4XZD1QLGSTyrXH7HbnqpiGGmAB+P3cfal+wxbx9tYQJFK4bTGsODY8owBPYI+KlQOP/4DGia3QDT9fj2r/0D+I5f/PtwsM+/HTxZn2f72DdE12sIFBLkemIh5PIFIVCYaIrgxNM+dvRpsmK9qDEIwAqW6siNJw2FsALVlKuve/KWdROmRUVhwSbp0WTV4rngqeZsMZXldkR1uaOwT6ydB0TAEPfzMbvO3XbJ7a8J88LdsPTSDyOt3DlMZFN7YPf5CONZi+qqk78B4MlXL9BeB2yej1INHhiODE4+M+H2FYfmKmA8Mjh6fcK4NFg8mTAuLRaPB+FJsbdl89ICzdWI5rKj66ws4MlzZXzY07IR4BMHde53EQ50hkAazy2Wwr6+pZCt5mJpj5/tPYU1+T4PXgRKEUh+wnWkcm98QHdBx7v+MB1v+1IEPTeK8P9yj+azBJxPPhnv6SYAhrx7ZiJen2FZD1Wgm3lBLIXhOi+yDOz9qm57uufewzcx/FBFsr6JgMsjhVb5eYuhVEAlCmw6Bayjh4bL1XRdmiiYj+RDmuAAcA1EHc7JCijHSdSw2ra1eQkYgCZGHfKJYXk+vmkaeoeamp5rYwgUODevJzWXbae9GtrjFXW9TNvA3yOP4/rLT2n/CTj66ct4/EQtwGMiyod+yDxCxAXLw3ZlUeaMN1Z8TwfxtC97Aa1B8AF20VKY8/gImLz0Z1iv5R6lcjwK1MX6nNIvmk/GXKqyrdbQ+Zs68bAmL88Ah1z1NTA3TbheISQNNPZK1nUSmLU21naN5x6n9G7vck9Qxi8DUkhUE985/GkseV2tAmEA8cL65Nk1LfVnOGG+X/QCMiBraWyfTlqYEDCuauJKDl7G+mmZBEx9ZURUun7jKh0zxMWts3SNlYNUJ3AWurJCiCFFkgeh9+v7fuyP4mDv2A6erJ8P46LN8D4DWMHaPX0oUWwPVGZGMgoZYJk08bJ3J1iD6ajGeJKKM7v1gPq6j56rCaYbJEOvBFiI5Wg4U2U4rTGc1pKCv3htQ67pKXFm2DTAMpOHW6fJdo8nAtAqkF9kJl/yMT2ipwjYWz0CewBr/VKL9jpgd2GoyPSOAJZvSHF+94AAVnvpJatuZAV4BbDM6DGuKjRXI9qHGwGSAORN4PCXndP8mlGsp51C9r24+9nTs9vnlUgigTHkeVRinkACdvx5d0HPCwMsbT46QfsHI6qHzd73/PobzjqXcGHuRVs87GH7IByrsph2fo0sjMvPa3mBNvt+r1wQg6thTJMdc4RU4WIA+yTl4vO7For8eeh6mjy5qLY27YmYOwZPjrxwmJEW2Gsnb8+eGeYl3VFrL3T7hP7uzGL7wVMM94/y0GI0IfRLdlvsi7l2hQRKZvtKlReiX3Hije3zfF84Q5GzD4+OUJp41/i9EmJ5njktoKzM0mOwFftPPJNVRaC3qoC6puxDYyIvLF57oRSfPS/WUgIFg1FAJFlQOSnoXdacNM6KByuEkMb0EhyKp8wloMhWVTBNQz8M/qxNvDv2dvKxuh6mH+BuOrinG1SbAc1lJ9nTw2kjOolMCWE6ApdMkmvjMbgq+lkEetUih/s9Xtt3fM2/i4P93O0Asj5PlgGsYcoAFkDejFBbTAsnApJuZvKV1YWFhFQk1LRivSqqL8ghSJmQO1ppc7hNr1RS1pqR8OS0II6P6zwWr23Ia8WAwdLPdLqgn2WNaUkAy+6IAM+Zg6ICHULyWkXj7UIMUQIEsMxAnotQWdjdSKCmSM13tz3WL7VYvjVg+dYAtwPcDuguCGC5HbB7ELB63WD9SsDunpWfYIH26Qi3GwVgDacN3G6C20156BQEAoQbpwCBVlvm+wvvaSDkIrbDmHhT0csnQEsZg61qQ5IGtp8Sl4nvPRIIkkxIAM0V7XvyGY/tV3fYfnWHcDwhHM88QwAufoKOsXo0oV57NDexdqTPAaGU+ylAHl2DxXjsMB5T3UIuyTQe5wsF9nNz2JBBqF9U8LUTj6nY3ETPGYRDIaXQz4S1dEr9HMdGyTjM6iExl6ksEMwTUAGkZo8xZyUIBPaBVqaMbgA/wRwtYa8pg49lVfaa3NRUnPj4KFdy196osl/nwn9zcgTKTBXHGAUI9d9huyVgsyOBWFZ8tyf7oWlAeXzqOr07MdyZAS1jk1dIQn0eWckiBlrG0PHqOtUmjFy1EMIskAwdeUhJGJVABXmtnfxkpXJKbTPnkixDGZos+5TD3Ayi+17qO6JtYoWBXGcsLJpcHDbKn4S6gnvKz0aHcWllAdmf5lUmphXVpvUXx/AXxwhtI3p0ch1AGrOHMeOdGR3uPACtz5sdwoU/B/sNv4Hcqex5gUUCWN6LXhQLiQIErEzg7QzMFLIadVzcWTxbLHzJi7OtCsWp7Uq19bAgXSdf2Xie9AIxiKiudwjWUtagMaLVwudkjSwOFbGCuYsTcnWpMhWBnOQOULhyCuRB4zAhkPGOkjCfSd4PZ+TzKWopXX84ClWeUhtuPkT7T8fUltOfdJhaAiEAcPRqBECSrRf7bz3khbZrR6tCT255O3hUV9t9cAXQAF1XKbzAek/R+yWJCxw6Y95R7JfpqCXhUXbRF+rPflHD9hTudZtejjecpoHy6sPRo/Vrdpg6B1PFdl5TGy5+lPrw/KfzUKcU4D5m3bMI1LfMek/tGFaUaRqsQajovuualPwcLB4PSYXa+zvFVEXvixcNWgZhiOGfXYe5gsG0oQGmCWbRkmdDlVnhMJlx7m4wxB4QaxIBWWXeAUhE4T09JCuTrrE2EcCVt41DWFJ2ZpqyrDrhMMXsP+HIMAiK3pPwEpHsrr6aQoZcZPz04+RBspuBgH1UZc/aoICheFlU6E9Me9PmOG9lWaDChC/FSQGRtJ+B3ctrhM02C9/pfUPfq+w8mzIO364NrD9WJkIU1xaGUcYSnW0qIUog8amYPB+TFyR0F7l1QvLnY5aq8fE+7/HTRCjVpczXqlIevoKXCiC0DS10x3wOyKIDALqX6fngGqX1hr5fPI7vfFE2zV0SSDP9gFAR9SA4mzizQDpnU8esaJvd0xD77kCQv9MO4cLPt7GYKGft2Z7S182Yh88E0GzJg+K2Q5IJYA/UFOA2vSh/lwCLBx0hz/PhJdMwfs6T25LKeAQDwBopbeKebuBrh+bTj1Bd72B2g2gShdbRcTnr/A6A5VsL05PI5rMAFk02gTSkFMDSACMDWNJhXvpxOlnArfs9gHX8+oRqY1Bt6P+jT+UAa2Cl85XLvGPVbR/5b2rwZjAV+1g0wMrFx1gM7FJ2JUoTxEGTvTlSTkZZ9WS9l8Gozd1GhfPNfvgIALozXonGD3gMvqXBt32Lvj/9dGzDTX4ct5uweNSjWtMqXmc6sjHZls/B913acELn6GOSwXjC9dZiKOM8LyTN4qQukuXtTRzw11uSaei6vOCzNCQCt2FUobAi8UDEI99mGBMuT8i4NvzdrM2JTGJmMpXtbRaO3Ev7BwTskUaW3VNsZ29WvY5JCLHvdy8ss+0kVHiHZpNoSL0dMf4ZSQWybwHSRMyUQciTS/o/lh9iXTH7/HNZG3VbSFYjhRHlHt9V7Bug7f2UOE/q2On7ABib1UakxnnyQu26pJnFfCU9Hjgnnh/DzxRnKfIxuZ3cfk4gyEjviYcrCwIG3ywQO6VnJQkfI6dplM9QHHuahwS6qy3tP0Zx5t19rqJgMZzUEkGYziNxXmgbFHlg72h5LjN58s5bmzhtEZB9+9f/ARzsc7ODJ+tzNAZXPCEaVQwZxsAfEanRtxWtFkYi1rKmlRkmSvkfFUhhT48jzlUwBtVtD187VNc7IhhHorXxXkJsADLyNRPdecJz6z6lgQPKNR1XznWViO1Mhj9ZSFjI9R7j0qG5GtSqKoEAIbszeZhDhZNHWDZKhJOul0nmppsI7PRD4ms5kwqpjhMN2qPH8GCF+skW619wgtVn1vjUP38GAOien3D0SQdfA44diQNw8ZPUtvompr23Lk34V+zdSmHRULsk1bDLw6/SZ5pAOozwJyvYfiSAJWR48jSE1pFujZbcMEZETYMxKWyqBlfi3BEYZQ/WtKxgR49hVaGPoqq7ewaLp9S+my+zuP0wPQeLN2ifF//BIHUX5X63tYQv7W5Af7FAtZ2y0j/BEqF/OHGwY0B/4iTzkHS1gO39Crt7Bu1lQHdhcP+/63H7co2Tz/TY3a/RXo5EmN+OqC43pDF1u0VYtLCbHZGN19tEbOdnR3OrWNV8RiVd6t1xyj6gQn02n6QjOdpoD4mUPIm1/+oGWRFpTYBn4vIwJo5NVQHBkwet65OW0jAkkMUeFKljFydpJXQKDmmp0iwM3vyL9wEAmw8cY3eP9uFMUDsELD/xlHa53SSSttZ1Kj0tfMrJJ4AYZQ/uskyHKtYPDOMYwQP1C2f0mbaBqWv4B+fQySwMGAMrwfs8BMdtYX5X6FQSDYMn7VXkUKJuZ13Tc2JN7omM91E8jGwRHJmmIZ0yyS6M5P1FwcfadaTZxZmuXZeyC/mes3kvXDEAKbFBm3X7IN25JOfgXMoSBGB20XOu+IBmUh7jVQu/arB+ZQlfJ9Fg0gak2qjBGjRXfdLeGj0lnLB3OHq1EALMrs+BH4dR47lYaoXLiv3VHzl4tZTd6ck6gKx3aN/2jd9FauU3caIuC90C8MeLrLSLcFV2KmykVydqogeA6bRBdZX0qNhDJaRhXiUX2lQyafN+1wSs9kQ/RbMorl7K8A7XFjxNg43t04rLrQtwBWSTJA+C/lhpwHBG2XaQ683qvmmOCqfB68/UtdntgDe/mSYh9mqxFIONt+P0M3G1V3BbMoAF7GmFzYYHgT3OjxSG5kSAKB5otoXQajmYmvweATnIEjHZZRpkmfM0NRb17YjuXi18DIBAFgBSeQdw/nGP05+4SucsVsqh4I2l2oj0mzkefA4GWRzue/qVvOqlX+0lfS7hilj/sH39mjbb7CKQj+1geYMhTRrwYY/oPls0GMCeaCiQE60LkKWvXUyJcer/5zLtss9LvSHWv5LSLjloeSbIApJHhbdn7mQEWQBw/VWn4qXgYuwMsgDAXN/ScVgRHtgHFaVpnaQ7gJYGWXLMmMlJn8d3JoqO2sgR8/fP4/fx122836wYX+rAzQEt/X3piStK+ZjFgsjxZchXWeiHWeBpljGEyxwp7IMsgICWeFrZe4c8PCumQKD04V0K8XwNHCqOQMufRLkO9oDxOMWiuxzOjH03PUdZqTcfXmXbV7uAajNJVYbFwzgnqHHObPskFsz3dKvugbVJRHil+iaewx83gA/4az/0B+ev8UvLDuHCn4sxwGIT71UkPPqjFv54Id8HR9pWth9TGFEDE5Z0iDXbpuMG03F8mCsLu+5g110iivI+iC8Je1eqRNzmNgnA2vVCMAWQCvIySIiKynJc5oRFQNi8tSaNpCsaWDj8JWVFNrsMYMlEGv+320HUz60OkfIEylmH7G0pXOOmp7qIZtNlAOvorQlHb01wXQ6wfE0Aa3fmsDtzEu4ECGBRFueQ3QcTszbNbtgvmwMCJaF2WT/OaWKZTinvF4sWJtiLOrzNAS0lGKT7mA5K21frQRTrAeDodRoEmQh/LBy02I8x68+wV477vctDzVKGKZqPAGwbvSfdGf0/tZED90E67vrL6AC7BwFXXwns7pvYHmpj+yZ5LlgUUc7Lg3nxPO/xqOR7jzleEJdY2QNFHIphz2y5eCwnWgZsmlCfnSc/Tog6RzKRCwhjAFhktBVeDOZyCaerKPHDwNM+vAQA7F6Ik2a8TvZq9S+d5ucFyCvDYZ058r26jnLRYKJXaja8ydc1c0wGWGaxoGuqKljmigGwN1u6x/1A4dE5uQhOCuAQHQOOyCsLGkABuRitc+TJi+r6ZtEmcnlp/P7OCbGGkGo16rC1uq/C5VouFMAswmwxlGgUF4s+L66bt+fnj8fPkfhgDK7CHfdRDhOfTxcX/e3lhPZygvE0LjI4D5VBqIwkLpHnPh2bSf9mGGlsVqCT+oSAmNn2yZOlM4Wtwbd943c9s61f6nbwZD3Dvu2bvhvwQVytGL2E60w3YrpYEXdoWZMKeiSwZ6VzWD/JAyy4ObGnx5A7t7qiEIrpFSkWoCyepspBnbP0kBtD7ZkmKn8x+aSnE4mLoaXBjcopKBChNVMql0J1bP2A0Daw6y3Vwtp2MfSZeElh2QI3ayLA9gPCooFZbxEuTmF2PaaLIypOOlf3D0ilHvTqT8RLPQ1u/YBwtITZ7HDz9S9i8bDHW79sheY6YHffwI7kxTEeaJ8GDMcGZz8zoDt3OHq9J1f5ExrsM3DKfcnt4P5AIrHLSrMbYKakiTVFL1+wBiZEMvK0X1hblwgy2yHtx6HcbQzB2hwka84ag9Rp1cgzxWE/X1usX2rQRiFWt6NBt/3MZeq7RZPU02MpDd/WFB50pOPFoWEuLL295+AbYFwZnHyaNMgA4OoX0vndxsJ1RsDa/X9G/Xj2Y1cEWNdpcgWQvCHGJA/WmLKaSg9MmAhcBeFAsRdXfaYkB3T4hYGReEhCrgtVhg5NDP+JKa/VXR4qgCZYTa5OwC0lb2RkbiFJN0SkblsKU3IfcPsYKC0WCOcnuPmqcwDA9n70LG4CXBewfJPuqSh9X16nflWE+qDfJ1ZGv6s/NGF/biHhHAFc5THU3jpTpWxNvs9mtSTvD4dXfdGXxkgyCYO2ME4pLBcTBZgwLrpgRc1G08SwPYeBJ5+eNSaux3CplAGaJvJmqTqDpmnimFvT+YaRxr1dT+Mue7L6gfqYy9YMo4SwQ9+Ll0xMSvqwh9CJZzOMkwpfx3I7bUN1XKdAY3M3pnHKx0LrWfJOBdQVxtMFti/GkjmWxkXOKA4xyaq5imC+n4jisKPxjRNQZFHEfTyMWVkezkz0q5aqNfQjQsN6gA5//W9/yQqaHjxZn6uxJIMGWEAK90wXtNKcljXGlRMRyQxgATShtbWEpTTAAohobaaQAykg8gymvc9lFaEAFgC1yrMIy5bOyVkz2saJXiAfMt6UWD/A7HrYyOXiSVrE7SJZGbF2m7ix11saYHY9wvWNVH+na8hd3ZKxFc2EED1XNhLfx7TPZgd0PRYPe7irHZrr6HEbAbcjUVK3I4C1eEIleAACQTYORqH0EmnzXngQvpl37d+1P2cszml9AZC6juP95d53mlfHYRU2XjFaJo2Xml3xWTj51D65Hkjewsz1z+2srFwnAyy225cd1i8bPPlV1PcMsG4+HLlZHYeP8sMuHzJ4Ulo7z7KyPE7kYIn36K7QnVyHzT5PoCGCKwZbDCj43Sl5SiUJnk1n583tp8ELnSh+MeNd0xZL+YT1OtVmnDvuHcY6Z2WhcZyTd0tqBtZN/j2HSI2Z5bqJFXUG5bzinbvjPbojqzNE8EdyDzPvCF/vNBEx3ftMId9wokAUQwVniHK7xEtf557EpoZhflRLHi5+NoyLxHhWeh9H8qT5YvEVkxgkK1v3G3P0mG+p+sg0zT5VAIh1NKOCfVOLR1PCyFx3MXI/DcuhSE1YzgJOi5bMhhHV9Q7LN6IHmR2tFS2I2CPan+USM35RYzxdCKgKbS3HA0CfKykgSbaKlRrEcx6byZzlgyU7gKwZ+9iv/E7Y7SCcKEH3lkDSdNxiWlZJJyia7SYCY2Mx+AJSQkc/sFlNvMnTTynuySHJkwX8ySJpThXGOitCoowhKuP9fogrEtOz80RtIrPraeXCWkWspcKEdFbi7jqg6+CvruGvrglgnZ0iXN8A985hNjv66QfS9xknIlGW4QrW1mJleGNSOMgYoOsxfPmLcFc7PP7lF2huPZpbD7cLGFcGbkerPTsG9KcG/anB6s0BdvJJYiIWbBbjAUulS+vvtcaVDDoAJi5ftEgDi1flkKR8TFsLwMruEQujbodZDph2yWefx+fP9ON++AFAfTWgebhG83CdgCygQhNmf1AGUG9G9KcO/anD7cvz4Yk9gAWg2hos34o/EWBxeHJWA4uboydxLVKJfSAjFnLgpb1Y2WZ3AK1y8tTyBoaftbi91lgqw2dhmhCGkTxY+rsSaJWmwptzICr0fVKM1+VOLm+wfHOH5Zs71Ov9Pg21lYXebJ/XTQpplab1m2ZMFNTnPH9IHqzsnt0VpmQA1g/pXuh6geNI/TJNxK/ynrzj0TtjnKMi2YuWPElVRdmFNnqNrAVu1vSeDiNCW8dFrZVQogAqFU40TYOw2ZCXbb0hoFURCd7Eupuigj6OyUvIBH5OkgiRaK9BJC8Y4+dcyin0A3kpOWGBw5j8fnZ98iA5S/93/d6cwHQUuV/jlL337eWA9nKgcli7tB8LIE+tIz2ttspoMMJJi/2wt1jiSEBsj10XXMooci2akQcDcAgXZvaxX/mdaeXAVc2HCX7RiPo4155jsnB9zYKhk2wPID28ItRJ/4r3olceKFZOBxIYiYKJ/pS8IL62sJ3idw1jTqqM5+FSJkACDnwNthvg21qK9/LkHZwlknLxUpm2oYFvGJJrH/v8DhNXj5nqMe/P5Ui4jSBASGUzilUiZ7gI7yVI6Ynrr32A9umIy69o4DqIGjkrvNspoNoCp5/aobuocfQz13LtoXZxNeeFE2Wie5x0YQzVk2zVROEDrc68x6gA03BcodpMGFcO7dMe49JlumHTUQO3GTCtaoxRhVlK14QAtx2Sl0/dcwBJpblN/Dzej/tvWjWyupZyRMNEbv+BFP8zIMvPxdFSjtO9eAI7eQzHFfpjh+19i8uvS/ferkaYt1q0jyx2DzzOfjJNIN09g5NPeezuWdS3ASefoWdp8doNnW69zdPTZ0JPWrLBb/ZJ0XryNnMekPRlHi5UAIlDhfrzbFelWSTHUCVqRNOqaA+XeslIznWV6yiVHp/I1fFdl8JuvG/RViFkr5YIxyuM94/QnzXCibv4ydh3BmjeuJFFAINzURHn5BIOl0VAlZXUUR5Co0NvSn09K1PE4VUub6T7ZbkgEG0MCZayjWMKl8XsxMzTyNxQIHncuAwSFwfn8UR5fcJuR9mF4wQTQ+HhaBmpC22iUbA3VwnLmsVCjVVxPN91MCdHCfTzueL7I8CL+zWkd1rGRpWdqssqhWFIdSfF42ZTVIG5UHw8xDEyHjcrHO898WvLdxxx7oiL7PF8if6cJYBoQRgM0FyrGrrq3fINlesBkMqJ3Rbvpu4TvX9TEy+5cdnnthu/lEjxh3Dhs+w7fsnvJ4DV5SJwoa0zgMXGDxETkhlg+TI7T1ys9MtG70UGsIAcYKlQGgOsaVXtAyxuS+RnTacLAgrRy5KI1TYDWO4yEpOvY7hvu8sBFvMm4upNuA0MsHj1qwGW6jNY8nIxmTUDWEPkCWUZP56yDTlkyGKNenDvB1Jv345wHVB19F21o9/LJx7VFmivJ3QXtfQ386JEkLPwAIoacumFKEpl8P6s1N+fRVHAizwss3uJVK+751foz/fL29h+InmHOZNMw+KV5DbE8IGI0RbGXrS9rLrCzT+d0mDPoULm+5TWPrJ4/h8PGcACgHs/PmH5eEJ9O+NdsTYHWPw5T/D8LBXk5DtJ129nRbgwq+MHKBCVwmX6/2ceWsshaIuFjfeyCesqF5ssjzcH2FRb5Tf3VayLyAKurnA6tZ98TN/H97mkBQgguSu77Q4LfZ+8gHvkfRVCAogIDkgGpTyrRWkaWTTdBZg1eRxICTXB57IHSrbDLBYUFqycZCOPFyv6zHt695uaqBPLpMtlqor+N4Z4ijyOLVQEoHLJM6RBD5BI+iVoirUWhZemwoumrtNzwVyspiY+bFMDdSVgWSIR+tzW5JmROjtbXb8AQxDAaS5TBAZIIT29jTYWPRZx5fPjuGG8xlIklW0irxYnRwWlrfdt3/hd+PZf+iUDtGbtc3sD38c2B7CAVD+PJ1jm4eiML+BZACsIuAKQCOhdn69QlI0PiGMRGva6JK8agKQtxfywOHGGRSVZfQDkxX4WwIK1Mc1ZE+OJpxB2uzRY8ARZ1ymTC2pCEy9CnEx4IOBsHJ7g+gFhtUgrTN5Pl1JRZvoBu488D7cdcfuhZQawdhcWyyce6xfoOtsr2ufoE9cIzonHDqCwZODFhlbZ0CJ87PUC9u4N339f5xPFtHSYlg52oO1Hpe7vG4sqKqpnAxoT050lr5RkLoa8XmABsOTjsg6gOm5YLWTVnWWWTl7xCOnz3YVDe+3x5Bfn13T693MO2fnPDKIUr+3ozUTm3at1WYB2BlihSIL4XAFW8CEv81KAlD0Vcw20vCr2O+PdmvXqs0YSnXw+Q80mj9qs9ywSot/22gI9oaHvYZ+7R7UcVeq864HdfXq+2k+pS7y8hT9eEdBaNOn+8ztdV3Jc+nzm2plgzv9HoriQxbPPlQbUcpEfbw6Yxj5gM1V1d7kjT1mHJk5NZpEU1UPXp8Ubh3qbmjTDjunZHuMzHgx5lk30pIdlK8DJ3KzFQ84JIdSRKZEhVC6N4cxXEpBuETY7AVqyeGgQQ4U50DJV1NXicLkCWqbrU+a3Alpm2+VldmK75kwfAwXHlgWHxxWds7pFqjgCNS4F4hVPqwpuPcAva4qAnB8TkGfiPScJhSC8r+AgOoDV5Rb980cEtIaf5eLpfWZfsuFCUa7VvJUQiDcFqBIhhsresBuYVbINxbj5e7b6msqmmGGSlYNoKHFWDnO8eJCOL8j44ATwqdhnFRXe7W6E6Qb4VZPF0IE4MRsjHg4JAbY1zKZLGXvs/SrVs+dKVFizr1XEmUXeZxOI1BGbCZOkdOY4AZWrP08vpujo6P3aBugHEjmMdv3VZ/CVgRsC+uMIIId0PwDg+LORLB75bqztFVzBS4rZmXQQxG3i4BeJxez+FoBdWZI0MIAZFRDjhd7CormZsH6hFgFJAKjXI9x6IHFYTUaPWZR07PgMVQogM2fMWpnU/FEE/Uc1PYtMRI2Dpd30MN1Aq191veFoAb+o0J81uPpyGszXL8fvamBqAk4/Ttd98XHqs+om6SJtX2ilbIfoaxlKD3fdBHebQIR7fIOw3gJ+ErAl4KZtiQAeOVXi4VEAYI6fZaxJAEsT35X8QAm09gRLuS/Gkb4rxS8ByT7LQufBS6hrr12c+SbenHybECfdEmTpLL/s89guc3wERN2pm194AQDoTi3GBfDCD9FqwnzmDfp9cgx0PQEH72cKbkfh1EJVnTM5y2vjIsxakmDvnW/bnITO92DyROxm3pHu+xByXh5ACzkea8rwLXufOFuv0Cgrjx+WLY3hF0cYoyRO/ZTaYbshWwjIYlcySgtpFS2ZM4wIRwqMgUCKud3Anx+nxS8/M5fXNNYVYWiMMSxYvvPMnWNpH17oaZ6jeNVzbhZntIZlnLf4mY7UiOmIjn0Tq2YsHlNbWTeLjce64aRGtZuAKWQLTTN6VA+vCRhyVIOTFJi+EEGiVMHg62AHRuyO7/+H34n3oR3Chdo+9iu/k/4oNIsYYPEDJ8CKS66sWbiNOFLaLdpcdhnAYiv1odIqMz6YixbTvSNM92hlxQDLTAFeZaDxgwsg1aS67XJPTMz4wDjlAEsTvTEDsMoQhgZYHBopalmJtk7JQ5nyc2UDIxNIhxQuDOtNVgxYVrl9Upk3w4Trrz6jww1BNJ0WTyf0J2YPYEm5onjfRJahNH76y+S1gNnQxri0AjCqzbT3HQDcfIDrPpqsLaVrXuufaRKr/r4E43dmsfG/fFtX+YTAYefxaL8fqo3B1AScfHJ+KGAv7OqzEQhz3zIPbV14dJuKPCpluj5iqGzo97l/d4Tx2GNV/pZ7U9bl05m5+jjlcZkXNQtybAZqs7YDQsAPxWKlFNJUF0dgZU5rqghjyudNHmpfPIxVDGK5ne75VbZduIp8uOvb2XClWS2TJ6nMIBSR1fy3hC0Lj5OQ6a1JpWeUhd0O/ull/iF7dPjcemELwCxT1h39H0EV9/F2SyE1PncBSqQI92YHGIPq4TWq2x7NW2sMFwsY70m6JJpf1SQcfbwQcMJt5LFi5OhAZcmTxR7T2GbfVAjHK5IvqB2Geyv4E/rhbE9Mnjxl/H7zorMATEH3hzEJpOjEhfhdcDYLC8qxtn3kazEvKr837RWda/N8zKQWIBfD0eu0CBgXDuNRhWBNltw1PjjF8PwJJg4jsofvjlJTUnJNA1Z86WUgfkl5sr7tm76bXKBNBbclcrLtJ4wnDcwYhCherRUIqJ08ROPSiUckGAAGWDzcEXFaew48hQjNECUYIsdA65uEpsZ4/xgmBPRnjXi9bO/JUzIkL4ftRoTaoXq6wXTcwj25pTIHXfJOyQpnnNJLzbIL3ucK01oDaC50wJoveoD1RahEPzdM7udtQsg4EACSmx9q4A6UcSWTTHTtM2k0XJwiOIfrX3SG5sajO3OoYrbMsLLozgwWUXV8/ZLF8WcnLB8NqG4HShToJ2kb62RJOaPRJ+/WFIVhlV5YcLG4NigEqJXWWXjTdRMp/BsK40yNwbgwWFzGrJ7YRcvXWKCzo/uU1VWL+jOliOWonheVMCB8iaaS6wBSQoUZJvhVDbsZMF4s4TY9+osFTAC68wqb5y3aq4DrD6XrOfmMl4HeTgHLR1GQ9mkH04/wbQUTKCsJjvrLbQf4RQ13tUNYVDJo290Iexu1sh5f7ofJAnmqrObtOIfQdUIOByAlUDBNeyFCKQytTIjqJgEkUzyDWTOiDhNCUKrxyRuDYUjniG3IjMvxGEvnCR6mKTL62FvXq3Il6h2RBQVrVHGmGSKAip6s4SX6HSqDqbEyViz/289mHkDKkKskBCbCv6wIr5XhY1v2QJSEuqa8/7i4dgiUmed9BrLYG635aqzLpdXVQwj5fmPkXpVJM4tWuFMiEmotXVs/IKxa2Juo43d5k/oWoP41Bqgc/FE8d6y2wWCLvdUm0KLarXup3sAZ3Gb0VKx9PSDExCMA0PVHQ+1ESHhq6bzutodf1SLkbKJ2l+ljAtE4pWetqalUzqJBsFaylUmDT9Wy1XyouLA1k0/zTlwYsNiophTwODYtHHb3axEqPf/JDZVImwJpgsXQ7HjSRq89PY928BhOHKrbCeOxQ/uYxle3HVOt13FKgBVI/NeYcARjyMMeQalvK4xHFX7g+34v3id28GRxWilrBE0rfqAikXHyqNaDhOiACLCswbjMFcSZl7V4GMtGFKteXv2LxlUEQSGSFPUKpT9jNy8EuNHOCWABQPWUBjEBWJsOe0VVdRFjll0A9kp4iD1j5Z+JRJYAi9unpQFmAJZsumjjoFclAb+QUtrDOCbvVTQGWLsPnKC5iV6TncewshhWFlNjUG0JXDHAkm44zrVgGIiUvwW8KE9XcBFAF5Nqtc3ToV1cpdno0ZmimOfiUocyyC0fape8jEA2mdLBir59FsH0tsv0vEJlZaUIZ2SQ5t/9BU243XkONM5/2uP8p70U1ZamxfBrdTOkKgI8ucRFSEm+J9LrRoDes2QcpM85fHUXCZ0ne/Ym30GW3wsVzoT0xNo2kbQLbwr9nYerjKGw+R7AYivOGXrlpZtT+p4T+SwVwvnQfao76rZD5jUPBlh84onwkORzVi7f5LprunTVnteM9ai4HiF/Xt4XKRit9p/zZPV9urf82bbIeCxNyiUlgJV2DgiLln7YQ9tE8eeTuBg7P0E4P9n3po8TTNcnonigqg+2GygJJQpymmHKohjBGlmMie7hMP9cmWFKY7czIJkfOtZ0tsB0tiDPlLNp3GfhVn7G+XnzHmbwci4dvRBZBV7MKh4nbZzzds0wkf7iTEH6ahdQ7QKGswbTqkmlxWJ4kkvHcVY0l4obIy+zu5+ep/FsifFsSWBRyc+YgoqRuLf5mPLrvuOPzfbr+8m+JEDWr/2NdCPFLWtNVLyOq+8uDQhmmOQhDtbINgBNwLyKXDzayWfTohLtJCnEOUwUGtTx6/hiTOcrjPeP0d3Ps3Bc51HdkieG2hU9Jk/XNHD2AymQqwmbFMl94l8Ubv49bR5W2xYehBq84z5eVJLv0C7ic+vMJWuzydUYQxNI6UreAw5FeJE3U4O87T1s74VoydbH0i/19fwkaFjHZsb2yvjE0JykLwvfKno3Y5bX4uF+WKgU9aw21NB6zSHinHMS1Co2My6yrY09qszJimK240kEUzwAnufPEnMxRD4i2r0f73DySZr0mqgWz3Xx2EvIMiVswVrSIuvy56F661pKqZgbWgSwSCEDBFNmtxVCn2zsnTJNcycZXsJo/P9dpHkfJRHmFhd3CGfqfbNzaK9YCeDsPEDkcLuUjdFClfF/neKfTmb2nlfWLnLx+Wsfx3GHvQZzZWQASqwo+57DcexdZj2s8vPymHOhzhJg3VHWZ0/8tB8QhiGRxbONlSyC/ji20y/ydo3nC2y+7BSbLztNH1qLcHqcvJlM0+AyT/ycXq2zY/nGZlELAFLUPjUkLWYAiP4gRxHYY7R9oUGwBpsX0zvpVw36V84w3TvGdO8Y/nSV7SvSMnzMXi1Y2Pul2mGGkfpFZ2Izsb+bEg8KaUEYKovF4wFtrOs6LYwALfZi8dxSP021Ds3oRQiXrT8jnUhOzvIrch6wB8u3lXjTpDZuQ8Km/H/zhO4Jz8/vV3tfhwt/7W/8Y6jWI02YmiBpjTzcWhQy1E5A0nhcwwwe08LB7SbKuthOtH3cf1pQ3Jr3qSL51/QjKZ8zgHEOwwOKY29eXsgkbKaA9mmHaVGhfrJBaGsiDS9bklWoHA0OdUUvkDFZOElIxZXLvVUykanPWMNlmpIOkJ7w7iK1A+C6X0aBVOmz6DEjQOUSUGhbCqG07R5nyzPRXWUpwrk0CZ2fyiDU319Jxt3mhVpA7vY5i+AIYJkANDcei8cjeXUCqaTre2P6MYUCTSxZo0M4HoCle+KXNTAFTMdUzmZaVTADuebt6OGrFLKZFsnLGSpSnwciKONirZe7FLpR3ptQVzDDCL9qKRMyhncFHMawgkyWbYP++ViMt7aShDGcUHajHal8husm+c4OE6ZlbH9tUV13lDwRgOGsQX0zYDyq0J3F7KNdgIsZkfV1L6vq0DqZRKqbTgZjs+vJ61KTTlo4XtEzO0ZF8xiSDnPgij2fQB4CHIZU2ibuayPYCMNInqa6lozXUsIBSN4oXbNOhCmBfSJ65GkJX0vpKiWSPsuRFAkeDJp9SIBKhYAzMMjvoQI2UiC5Tx4X07ak/H1yTNnGDBpGn8JI/ZBXXog6VqZtcw4TjyPGILD2EddiBEghnv/WizIOEZbGYwGDQmNS2I/FReNYYpxL9wwA6jrqVOXvfdhuJXxq6jp6eqjEDEJQGXgJCPm2kqy5YA3ap1383MFx0tDNLvNkyZgYw4lh0SA0JMo5HdWon+4wLWtUV1v4VQO76Ql8RVFjuefKQ+SbCrAxzOYMts/VsFNAf2TRxCLr1dZjOHZYPuxJx+9Tt9i+dITVZ2/lOKGyaUGmsgQzoKfAFmsqmmGkez1N8CcrySY3wwQ4Ks3mG4fhJC3qqvWI8ShGdRYGi1iqqXqyTgu7toE/buBrJwuvaenga4NhZVBtueKGR72JHqrtmIAjl4CLfc9yJDoJoX/hCL4y2D6osHw44gf/yns2fHhnuPB9C7K+5aOJXJfpgxQkPPm45hR9O/u9cCWYTF1bmcQrlVll+jG9CJGgONwjwLB5mdzd7EFoLunB5kFTyqvwPdEaU6WWDAovFRONebs7ymdkYcAZT5UWRqRGpUwf4VUpbwANoIUmD7v9S09NPF8GsjRxX4EsDg2w9hRAIGv7gEVf6FdzRX11+sncA8XgSnsW97gUAAGrgqAp4ThelfEzUaiHc6iZQRZ7rhDy56e6jKvowksV6rTas7dx5SiSGXFbTveO/cEga3eP+tYKmGKyfyKjWzU4+8pKmE+uT7IE6d8+6n5pkAXEwVIN+hxOsJe3IiyaeT+sJTVtdR1Bgxa9PT/rmtSvF0S8kGDBTxThJM2dKkN0Usw3Pld7WYjPCC2WWXjqGp5lGcjCjFeIFyjKa6TDaAy0TNPARAI1S7q4J3FC5vdKZbPRTvE5ZYmXyEfiZ8hsuwSyAEhmIf/NFku7zNodZP0k9RKfGcWjAuI4Ee+bZBkDCTADSSZGczSRPL4CtGJ4f1okkAWQNwogwU0NsuRcm93e8xaOoxbhCbVJL8q0saSBHIv/tqlMldZT3LzQCPeJgRYAqU5B56LfXE9QMsQ5RMnjZZRysN2w59GSa2FC/ir3aLNnjMu5cVmd+obOwUCLx7b2zXXsqy7JQgAYL5YCtIZTlrSg78RzvylCq6WnObbXsVYg4/oXjrB+Kc0V/+DP/Jt4D9qXJifLBPrhSZI9S6UGkl9yxoWVOHYGzPSgXxnZjuP69EWsP1hoqzDA2j2gh5xdte2bkWN1tYW93eUAa7ujn+LcsnLvOpp8GOwMBddBFNTz33cVveVyInuA21ribMQfanDKQgrDmEI4kiEUJzTFnwCQRPZiHTFTDOKmrmDahsixd5QDYd6ThA3jb+ZBcUiF5Rts9D6VnLnppKV6iXNaSc5QwefiOzt4ei4K8D3FgZ0Hzr02ryoCa6UQal1Fz9lEg2dpsawIkAAWP0vdRd4/pSufB04vC4e4sp/BFLYb4XbjvlAhZxGyxzf+zxOBvYmgkCermLIvz9iM1xPRszFbsmYc90E/S56w14dBfBFi3vOwajmCUpmc9y+zCwu9tzLbTnhad2U8ynGKxduz9LGco3euyq+L28yCpJz5JdnOMeQlvJyjlbRxtpTOOBGp+mgJ3DvLvjJNTT931C3cyz7UZYhUvUkxLh80J8rK/V5mnvJYwOCZr4E5ZlyhgvsnPoP1kw0Wr95i8WryBgGAu+6FvD6d5WFZFidlDSpdNouOnfPaWHIl0x9EWqQRhYTGEr3YBoDjV3scv9pj9VrOkeMC326XSxtI5i5fN1MY4gKMvW+i91UCLkucMD2rT6vIu5ILxKxxYo9sW1fEZ+N3zAe4zsN1HvX1iPp6hB3Jez6uIvhaVZiipzFwMW9gb/yVvlOahEevD6g37zlfzjuy95Un66O/5XtRrZMHwzeOJkVjYDwV+/S1g+1G9PcWqLYjptoSbyUEAUyhdrItkCaaUMd6gFMgBXYe9HpeecTwDU+G0dvQXg6YWof2tVsKSZZeC0XUFO+OHqTYC9D1aRDXK1Bj0zbsqdur4ab4Dsw5Uzo40gbluQLiBBczlwJnRO1IiC9stjCnx7RqPTmiItGKjCvlYpylvlJCrAB5tGglm6spo3KyCt+9dAwfV1BXH64RHDAtANsB9W3A8qmnoqiBAIBkCNUu5ysA8vK77ZBWolxlfkqFos0UpL/88ULtn7IPpza5301QHrTBY2qpHqAA6rc2CMbA7nr4RUNk2dYlkupIKeb2dovQNrCbHfxqQb9Plpl22+5B9DZ1PpfvELmRtMJ0nRdivrvtBcz5ZZ3uCQBMgYjyPqC/14g8he09leuZAqZlDRgCZfa2I6/cNNG9NCZ5LmLYgo6bvKWZZIIKH1M5GkVi10kB05RrsHF42RKYkFI2wyDPs+wn4EhpZc2NdXoBNY53b++LhQqQZT1mtRWLcj+8WKEb4VLIkPuLJ6PdLgFH55Ki+nMXqRD7zVo8P6RkHoHWrqeFWeyvcLRMvCxjKPTmXMx628KvWrhHV0RNWG+lVl1g8VWd8ae9cVrsdRwTLy34xD+dudecaQiAsg0tqbaHcZSiyhw+Z5FO+ED3tlLXsGzpXW1qyjpkkN9SJQl/soC93gpQ43cHILAqEzx7fpYVlcFaUpafi54vc7vNS9+ME8LJSjIbzRSkHJeZJhI/5vcrhhmHB0dEFYjAbbx/jPr1p5genME3DtWbV9SWqME1ni/grvtUEYTvuQ4LxtJBAChbUUnoBEdyE37RABYYzhYwPmBqLerrAdOyQncRNRh3RJGob8cogkz9MUWvfHUzoLraJo7VKo1BwZqYfZ3eHd9acCFqKkdGoMzEeo82ZmrSfBwThpimAeLb+YXD5vmUaV+vJ/ytv/hv4T1iXxqeLA2wgBSySSE+eoD6ewtKz+Vq9nowjXwrr1YtQHy4+IV2ZlatPTgjAItdqm0sbdDGNP5ZgMVKukDuudLckLfLzCnbMrfK5OPzCvjtABZXjedSEhzi4M9PYyjv5IhKWBTZTnLKO7KzTFMLwBIryLoMsGSlFecdLuvCVefFw6I8i9qYx7FXlkZpznBGTt4AD7DcQ2GuowGjvD5e2cm5eUBfJF5Jfo15OIR1rjh7im1aOtS30x6Znb1svjECsOTYtc0AllxryUmM19A8KbhK3B98XA2A9P9ywhBB//yzFyInsNzHlAsLQMlacDp4bHPp2bpjP+Edlm0sM2OVzW6vziHvDPO0ysLVd1gq9VNsFz3SIt6p29F1MKvlfrZg9GhnwrZAAmUMYLWeFJIniL0703Pk1ZKwIm9fepq4OPJcuNRHz1R5v2Pigaiel+T5MmtUFrLRe8sLrrq4hnjNRgEQIHl/JDw4M176poJZ7/Y+n1Y1ZXCWIVKWUOEwdfQgCh9R5F5ygjfTP+qHFHrjJIXqMc0B7uEV6k8/Sjp40arLHVWmmKnoYCIn16y3mSCpLJ59BDRSqo1+sSd/OI0L/qcxTLiI3qfjIlz4Fl3jeFLDr5pU9J4B8uTJAx+CeLLELEV6gqG5UBJo4jPvdiNl3vMuxXtro2ePx7Dh6I7M4/eYvW9A1kd/y/dm/wdriDwYU/KDAfrzGuNRJQjc7Sa43SShP364WbQxVAS4mJMi4UZNDu9H2U8DLF8ZyUSrH8WXc0ceAOHmaI5OUWldroMzcYLf92IBMW28TzIIzGvg0OKuIy/D2/FJ4mAmE9hiAfgphQPb5EYGUvgvLHIOADiLci5ccMfEJuFDnjQFlESuQwRYoXjnVo8iqO5GAkHsbWBAVKTpC7DglSID27GcVKbZa2BAEgxEHgJI7vBgUiivOzO4/tB+CIaKOKvzMXCvSSOHa0+O55GD9Rw9U0mOgidM2t2OIetXKQrOArobpRqNNBHAmCz06ZhnlZWA8nsZXXwszdcQ4wnTT/tgAiApE33/Nb9QTxw8oTKviUE+i28KRyr30s7pYenPsu+1l1MrgSsyfi7voLyGc7pbGmgHvw8kgUxDKi2e5rOC5X7d3Obik2wMtFjcmNungII/WsAf72cx+sZJ9qnXSubjtM+V08eO15bCtcVChikHd401DLTK762hsB1zIiM/anrxgojpy2KM4WYx+CklT/h318NdbeFYy4n3W+9EyqFcIAXnCDSVfc7PJIcuI7eNS3eFmjyF/H7xdvY6jv0MiDkLnItoX93CvvkE9s0ntJ0SlOYxKCyavMRO1MiSMYrffw6nxhq3bkdUAF6USZKAM/miMfaB2/QYT1oBWuxomI5auHUSvpZkmHgMOwbYzosH3PXpXWb5o/KcvrLwjYserKjDZg2OP039Ut9OqG+nvXn9vWjv+XAhp3+6zmNqLardRNlfHN8ePYaTOnKpTBKS3KWBwkweoXaYFi5pXI0pnkwkd8h5+LgAZWi53STkZ85wCdagutolXkG50otZeWEcYaxN2YE+SJ0u6MKgRemLsuwNizlyDTJd5FUmtpixZZyL2yQPlolhHrNYUGmMRUsrWFndhlR6ggc9T0KaxtOKT1ZmTMitKxpUlotMwV1zwwyHAmL7AMg5h5fOsXmplSLG4yqCrxq4+ImRXsTLXSYgCnC4N6iBMQ7GPLGGEEMiKqTBGZwcllKV7llAj0VofVuJCKmvLXxFgn39qYOdgPXzFoun0dP2aCAC+ejJk+CpHcHFDMfRS6kkLStCQoiORAn75EnjEj8AMBxb1Lc+c/fzKtD4gPp2TIKIQfWRTWKLe9IZbS2ZtXb0on0ladiVhXuyThPbkEBB6Hp6dochTcBBASJFUtdlWADsST2YmJ0KY2PYZkzHZKDfDymEqAqV69AUh88ka1AuVAEpBlm8QCl1zErQFbNxy4zJTDRVc8+UR476h95BEV4tayOylye+B/YegQ0zjDJJZ8etqbQPup7+ZhB6ekSkbGdg1xRaC9YCzmA8acmr6yOhWi/+Olq4wbo8oaZISsi4n7o4dyHPwNIcdK0+ebWaOqm78z21BmHVYrygz901JwWRwO0eoGJjCRluH2/H7wWT7tkryO/DssV0/xjupqP3seeqHuyVSmP43iIxCoHyeDidLCgk6QxMR/3JYT4533YX9deG1KfWSb1Yum/HQr0wuy5lF/MYxRnIpXlPYdNhJN4Zi5AeNTA+oLtoUW/GPY7UuHBoH+8QnIXtx6R3F/twvHdE2fQRmNs+HzOmhcv4qno8nhZOxhqOStTXacwQLmhRc5Tn4uGokvP9wPf/2/vX/O6x93e4cDyiFFM7UimaKbpC+7MKw0mNaWkzgCUPSYgAq6IXVFbx/KtmD1b8nzVBYphxOMuzy1g7y11tSTy0AFjiji50dDTAApBCg3PZf8M4C7DkeMZmAEu2iYAO2F+Jm4bSqiUMqAmoI6Xgz+kLaYC1p+800oQQvMdc4WdpRxlG4PTsyIVigCWHXQLVBtg8x3y52GdM8m7ylXgGsAA1MSiABaSJriBVi15XPI/UjmSOdfzdn9J26+cLF7gMPHkGI7vhNcDSxuWVSB9sf0AdjouMx8Lq23G/lA+QAMUdiyvfOFlSlYOxtC2WgCqNkx3ejkS9V+aGJxH2SIlgaGwrvyd7YUZ+zvNrkgw/nlhLfS0+311CqGx3eGRM6b0tjmuqas/Lk9oc7//cu31XSA7KYzV37q5Pz+s2D4cxv4drXjKQ4gxRngFM4c2VPmPOlbnjuWEQXYDnveOUlATenbNQeXvhudJxxeMWPXKzXj0gXX/0MO1JdNxuIs9rP1rgHt8CXU8cyaIf/PECaBtKPpkJc8Na8lKNU+JzyZhUEb+0WEAk4dyQAVkRk72+pQVovJa9yIfyWgHqPZUycfE55PJrMXGCHQDCH42Ohir+NpOHbyopKcRjcfVkHY+Te8Wl/3YxUYgXuVUam9xuQnU7xDmWtmeuMi9agwF5M/k64n5mDKjXI6rt22f1vpvtPevJ+uhv/l5MC4thaVBvo7uTFWorg2FlZSJkxfDmcqAU2n7KQiW66LJviBDsaysTKHsR3M5jiqErXxnJclu+QS5O+/QWXAoEQFr1sJcnrvZnyetz90F5sWTQKDktehVdCiZGAu7eAMj8kral1RO7xwvuCwGsOHgNQ6o6f7SMZRga0QMz3ZBAXdencxYipdQdIWkWzQya/uwIftVg/coSu3OLzYscpgXapwG2B+wEnH6ygxm9iO35ijxBZvTwjUN9Q4NqtjJjMqsebDUZWZU3EX5ITeEVLi1jJyKdM7juLhx8ZTC1gNtRZt7i8SiDV3VF5WlCZcWLBADTskZ3v0a18fDOoNpNGI4qcbe7bgJiputwXGFaWgxLK6nh1S5gXBqs3pqIcOqJn2VlcKVC0XZXeBac28ueDMbIIDkeN0RMDQHumvknE8YIrsxEHDB7vUVY1BQS0f3J939Mk4OACp2IwB4n/dyxJpuzKOUFxOslXjBFsNahKO8TEGJZg0Urel5htyOvrqizx/evLHJeTsjxuTB1lbWFvD45uVuMw498nUzSL6Qt2GsnnjAmzzsHs2hhTk+EGC792PVybLk2WUxMBFaNgb9/Sp4ZC9hb1jfrEBZRj2+12C8kL+0nD1m2cBMpE8UZ1RxT7kdOUuDyQdynqqwQe7DMisLiYdEQv7N2mGKpKwBoXrskkv7tJu8HTq7ZRLJ71xHPs1wgjGOkQKi2cT9GE06ptUk6panAhdzNpqPr0d5E9np6n5IMtMXjTMct3NVWgBMvjM1ikaIWXZeeVx2Ody71my6ZFhN2OGlAtuXrimKloUqeWV7c2U30uG06jA9OlYMhPtfdBLhUh1dnBAZrKKlM6U+yh31qLarNBN9Y0pVUSWNsg2Q/G1Tb3PvlK4Nqk+ZnSQKwMbzYWPzNv/Hv4F1od3qy5uWC3+XGcVoGWN0J3cDoaMJUx1gxlwhZc5ZbnKyZW1Ok1ZeeKv49LRLIAiCcruXrrB6cr8aEW8ScgTJFXyYGdm3PrJD0b8Yh7A3hF6b0LhXgrZRJSBmDRTYfm3CUcoXyst2l3pMYZxeVgJE9Z+xJmyMWq/Nl5SQA1DFD2/V3YH3mcrTzq1y578Huf6mLAc95EZyR1XRp7E3SWTbaqism6e7313RUC3/Lu/39be/Fe1YqygPA7r7Bgmgc2DzvcPRGfg4zhllP1BzAyjcIKSPxel/d3jcW1W0EtafLFF5pGyEfy/2vqnTPlc6VtJEnDyBNJFDPrdJxkkzC0nQW4Jy3xCUSPnvYzGKRFMc1kJo7fnmu2BazXOwlo+xdT/k8KZKyrg0oFjzCNOPpOz2h3zEMtEd4Z+8oh2kLGQf7+BrTg3Py0Fduz1tjNru7dbEAoG1SpvBdivlzJZLYszKOs/0RuGA8AFi35yF020QxuMtm2zP0ewA9a5vmAs554LwHprsTGcKiTc9qyef0M+eLNp0tYeOCXiR7tJe/nfeQpgNM+TPOAtVIY7L0lrWSOW1Gv1cwWlv18Boh6mslSYu7vUfae85zpnbDjCu3J2kjPK7aol6PFAYcAobjPCLhdh7jyqGKU2qIRFwzTLA9ne+jv+V730tZh++9cOFv+JY/CgRgdxG9CBFg8fzJWkp8k9nbNHKmAjuXquLh4EhevOmsf7R+MYpFDoHCjnFCXb0aAdZaie7pF4uzXpgY2feFF6t4iUVstOCyhJCUs6FCjKJHZDOl6VQHLD++XS6y/0W/KgRJ396zWFiaiPfFYDeQqj2mKfdi8eVUFXmx7ij7QXUM3Z0T2/bFBXbnVnhY2oIDXLevWcXGoprwRVkMOfczyPlxv9BWmeoykIMdXcuSrV5HUL8NaJ7uAxQp6H3HxCH6V3eEmli80JcJmWvmD8bdS02uJnnkAGAvUzJODCKK2xeTcHw2uH6mHDceh4vw7pHhy9qYpfeMQdddYTt+lu/IoE3larjf5p8HWUwU7dvLrr3DsvCO3p/D68uCXM7P1R1h00Run29v0PwmAOEm14G6iwguxvSBzXb2a8nMu7rZ/1JP5HNJKk0Dw97ncrH1dsk1URfsLqAWdh15xquZ+z2MJKa62SWV+/Lc/XDnu4OBMjhDCYr43OMYQ4pFFm43iPc5rNr90F8TCfvWEtC5YwHJwISTo9j8vRPSB4xllvb0COs6B7DlmDXFzE7Rs8s9UrLQ53uuZFx0JrUQ7iUZBORFjxw2LkPE4yl7ydn6M2q3OCKcwbRM6vzC1+IFHHObuV+O2KGROziEaxrHrup2QLWZCAe8R+w95cn6lo9+D7Yv0QCzfc7C18DiMYVTqi7AV4k/ZXpgXMawytYSR0WHCUOaJHYPGkqBj/tPjUN3FuPRuwC3CwiOPBaLt2IWFoMrJkuzRe0Ps+v3w4Ns2apJDeCsTwO1co/ud8na0cWbxWOlAFZ8KG1L4RE4B1tXFH6Iv9HUpPcSf1P4YkgeDl6xe59WmpkoaiRyMpmd3dYchrQ2EVnrKvFJNOBiEn3kLQCJN7J9kSavxZVHP1kMx5wdGA8T5471KwssHg9U+qjzGE5imYjGoOJxeG4eU4KxwRigslk9SH9xDNMNRBiNBPTgyI0NC/jY9qk1QADqjcfUGDQ3Hr4yAsCpeKxJROQFhT+GswWm1sKMgAmBBhaTCKHNZUd6X92I8bRFc9WjuxcVm08NxpVBdz+gfQo0t/uTivGBPE59CqdlCvecFDJMKUOIhQ+3A8azJT2LzqSir7HP6scbIiV7kKJ8IXnhT45oveIDZbXys5RVJ0ip/SEEGNAiRLwJMTxumkbCU6ZpUlJH/A3lDTLG0HoperbC5MkjNo5AVSF4T+sr9jZZB/hRSrrcqaMVjdtpOLTM1raRtNwSr6QvPGT8DsdwZA6wHIw1BKo4sYU9d9MEY+O1IgKtB/fg2xp+WaECyHOoNMooqSUS6/kerDeANXCXFWVJHy0AZ1NfDIP0FZe0CeOUYh/8zjZRW60byLOFHgEt0HUp5MmhOFXySDxYJY+IvfLx+GG3S0Bj04lnxYwe5jpKIVxd033rh+Q40fqA2y09Mz6APTF7nio/IYwJePN1yrPD/b1MAN90Q0Z7CHUlHEsYI0DLjJBs9OQdp3Ce3Q7wyxrVTYfh3gpu1WSCnbAWFqA+3iKO0Uh0ihBSX3KIMoI7TFPUp4v6Yex15Ocv0iNMsZD2yxqWn/lhhNl0MMMEf9QiNBVRHJiXO04CtEqQb3zUBoxAa2pjiPdqgj+u0FxTQW5E7cpgDew0wfYevrGYWov+qEJ36mCnAB8jUcPS4vjVHtPCornsSeNymASofewbvgvf//f/IN7t9p7xZHGZnGFlMawIYAGQ7AT2WNmBfhhgLZ5wmv8k2xsFsNhbwR6q/sSiP7FSqZytfTKgfTLArTu4dZdrW7GFALPrk/eq1GqZI05qm6ac2F4IjM6GILQpgCXbA/seAX7ZOLzHcg+FtpYUgZUByif+StZuNaEogJWZs/mPtnGCXzUx5k78Jh2Cq2+D6GIxwCqLRQ+nFQnvRU9mfbWvhxN01hi3kbPmlg3C0QL+grS/uAzFcBo1bmJ6MgOs3f24suqoXcz7Y4DFZFM5dyzAOpwRgOSVHKdFa4AFJG9SpUJ29c0onr3lW/F5PTaodh6+NhiXdp8IX8hYlGamQKvTOwBGWFKoKPMwsDM2iqqCV/nNvCcuTD7zVpX6bcI35PBS3+efc1vLAsaFCnl63pmzFfuYNagk4yxeB9f6u4PILosGY/IsWOVtNs7ShD2XJMDvS+TslBamKfLK/J1eLVNVRGZ/cI8OuWSJj2XmmRMP95D/ljGEPQrrXfZ/6UWUsaCkDvDEzeEk8Q4y902NEQABrbpOfV1QHeTvMtGEywptKNvPLwtvIGc78hg2+b2yRPoH3u/TE7QO2KxCflxEllml3G4Gk6IrmI9nhj1LwlOLnuKo0cdJB+x1muLi0p8R51FAjKo9mbc/jsEFx1YWrpWjBIE9bbLoPdoN9FPSGOLx7LqDXXeYThYyblG/0Jxnbrcwt1vY+MNWbT2qrYd3gHfIZBvGE7om209w20HpGlKblo9jgoYz2F1Y7C7oWm5foeesP48agoWG2Me+4bvwbrf3BMj61l/9hwEAVx+hlc7VV9DnHDZyHZPm6PP+lMMT+XGYs8OZW8NJjd39RiYm9oL1Z7R/e+nRXvq97IbMtRoCDbB6khIwwj8Bs5MYf69d9PxV6VK/C1yxdldRK01WcJLunuvwMPEyld7JQzthnGigvcv9rvkUc9cWByHDBM13YuW5AlL2CYDmhr7nki8VJzowdy6GeFlpPdUXi4crMhD9MlaN5wE+gggGVsMJeZ7cMD8BMghvn4zC+8uvh2QbQlvt9RGv1owPWDzp5Rw88LGn1G562N2I5Wu0ily9EQfsePtWj2OadXSzd+e1HDezcqLQYVSbeEvyvfDvplyjR9lwTqK+CKQIP50UK9y2Ic+As28fSoICVfIsKjAEPJs3lB1ofjEjzzybNUDbEhgrZRsA+t+lycqUIXfE98mYO3mOJnqeZaF0R+iz5BCJkjy/Y0+u6FKiXlr1iEKIRLo3+/2rvevDmDLVSn6o91Rg/i6uFRC9gW5fhoab3jTJqxKPCSRAZZomaWgB6X6Umb4c0toVCxQGHVpdHkilx3j8vCP8L2D2LmsburczFILpdEHvBi+qy4W1DscprUMRSeVrimE39zRm6kWgVUUNLwE8LOPAgImBFv+WhYVa2AIQeYlyrI2fU2JM2AP7oSLulhknarMGhyBZCn+2ysp8lcewV2ssXr/F4rMUfl4+omthLjNXRykXaS4mJPH8yjUeXbyt7EhZv1hh/WKF3XNxXI7CqlOczxkfvFvtXZ9d+Ou+44+hP3HYPG+xfhnoX6KH9rm/FyeTiSbdcWEAA7g4ji4fcpgr3UTjA/pYCmUbPRGLq4kIeCuL21ccYIDjV70UcbaDR/N4C4wedrOjTLpY5oC1lEwX9XrGYlU2pNWWrHSNSQMqcyeUnEA22Gl+FocCOaSoQoN7pUBiGMAs2rSy7el/PRib8sXVqee82uPt6yZNAEqHS/gZug1K80bOpRXtNfG0bYDKYTxbYjitMS0sjKeQH2WJGoxLg8VTdp+AQnRbyvBjDgAA+Nagvokv7MN1yiLiXblUTltTKKxIgBiPeYCjzEE7eNQ3Qzb5hspgd68hQG6o2LcZA1xHdSzt7Y70dhSICbUTD4CvLYaTWkKA7aMd/LJC/fp1vAj2BLC0A3mKuudogfHwl9GEU90C5z/dY1pa1NeTcA4l2WM7wvQx0zCueu3tjsp/bHY0cfFq2MeBlZ/DhgCTmQKBvZgdy+nz3QfOJc7SPNqQx6F2stpsH9MoWb32BOGWwUCa3EsCfPZcO5eeZ+foGeU0dx161aFDY+gdUs+VYf5P30vo3BwfpYUBVxqwJnGXvN+Te+CwZeh7AVlmsUiyEhy6jIBMajhGACAga0oLljByIWSLLFmlSFyxLAzcNMByAf+BBxhPWvGEuNceSxtFM0xla2acs6ZOkinWSjYifx+4YDzTFmJ2J2V5xmMyjzN+ZnT28e2aNKCi/p4Ixxb1UrkfpOxXfOa0990ck0fHXxynbLjrLWVCdn30NDH3aF8AVfe1UR47U1cxW5MA1fT8GUw3wcf33j26kaSCcHYs/CkOr7OUAUIQ8GMvb5L0Ao+FbUNzQVOnsl282BxGCb2KRI6LJPVIrQjLNlExOAwYxwO73tK2fL3O5WMuL4hCyMchBoO6niBnUfZDAt98nIoyGXVZMbvuRK4C3tOc0jakj3e0lPHDnx1h99IxXOexe67G6tUd7DDteaHsbgQqi2lRRaX4GFWKi+XNgwrLRyPWL1WodgGbF+hzjmocvzpi86DC6ac6jEuHv/X//aKS4e/MlHhXe7J+3XeQ0Ogmag8xwDIbzkig7TilnQEWe7a6c4dqS5OgGRPAYls9GjOAdfyax/GrOUpvHm9htj2J0kGBBY7p88N5F8AqQWyp/aMEDe9cTWqApY9RGk807PJXAIvPMWulgnNZVqNoy2y5HjZOG76rzEgZNokDE69OOAzI4UIO+w5HcWXPTsrC6xDi9lNj4TYjPLu5Z5pqhklI3nPGpPb6ppA+YO9C7H4G4iwhAeb7lW0ritC2b9GkvoyFbQVgZY1IK/PxZD+cdf7TsXTH9fy9MkoLDkjZTJY9GpsihFY8p9w/zJMrrwGBAOPuJQqvclHqzKYJZrncCxemkxTht7sI8FwAXQGs7Heplh6NPSks+llqSPG5zWJBiRrNvsfOnhzLb1NVQnYX0ynzwJ4GXSjfLWlcEcK/I1woFtsu+lbFNdCx7uCVlf1ajjNlEejSSk8T34ci1CYg9Bn6Y8aY/axn/f1qCXgPf48yKncPaHHhTyNfa67SwFzb+V0t68PyOMvjdJGRHJYt/P1ToB8y4d/iIqiw+6On9H/Znxy+LGUx+F0r6BriOWIgtO1yEn3ZX3WVSig5O3/PRTIkHrPwGoqnW0SF8zbxPCdZkNGSVzGC5K4nnts6T7JYvE5j2+LRALsbiU+1y/vJLyoSDh89zdGxbbxIW0VHydHr9Hv1Jl0Dc3RvX6F37fpD1KaP/vPvTnX4dy3I+lX/0/8jAOD25eh5et7AbBzMxuH+j1jcfiByUmJoj0NJGmABacK8+TK6EZcfqXD5kQqrR/kNXz6iG1jfTKhvJlTrEdV6P2QXmjojA1IjmMfAfIgCYGkvFjALsOhrNemwAu4cWJn7vJzYeSAsswbvyMCi76Y0YJQhzGISMJWjldszsvSMD6mM0F0hxdj25WdvYIdAYTeeM3ju7fNwLkCeLvZiMcCy3QwJPAQY78WLtWcFMLL9hPZJh+WrtGq1W1aAjiCudWhuJuFBcWUAG8vX8Mo7a0OfOB58vMw4xKBWm3OhmesP0QTz4Ic7mClg8eotmrfWaB5RW+tb2r++oWxPuxsTMZ1FE4F0L54Flu8wrsM2Hjm6fh/Q30vAw0dOnFv3CPfO6NTHR4nXhBjCFgFFsw+2tGkPReEVyZTF1d/8zHsVHpRMvWGk83SdnNtUUYsq/gCAOVKFznV2Ik94c5O9mmznAJt8V83wgIxNP2Wbpwl48UGqy8c2B2b0Z88AbiYmuwTdhxoslKWLJjXWKRK1KKlHnSvhaBVcq71SRDEMa6qKvF93AQUkoDW9cL4f0oUaN/l/5q4GH5815vrlY6G92WFa1qSvV1lMz53sHXtaOOxeaLF7oYVf0U82lglnbcz6UxTd2YoM1awGo9Z7K/uBQU8gEBKW7dtnl3I/lF6sEmiVn5dAK/Kt3OObdBz2zFVubw4Kmx3CZgd7tYa9WqN58wbNm3kGq92RXqBUkIheqySzkwMtFvg++SS15eQzdE3DscFwbLB+mfa7/Ep6pxg3vJvsXRku/KX/iz8OIMV0v+pf+gkAwD/88V8AAFh8uoEdgIufinyUmM3ACLe5DoAB2ssJmwcV7BgwHBsBYkAiKt++5FBvAtpLEliUiepJXPFHhM7p6aKmu2NRvz4vgaMnLqkDFj+LiuylHMNeDTcOAzKBN4QUEkERBgCS4KG/oyg0kL0QWep76RXTbn0gqWPzdkwWLtPT9aRTkF2lT3iCYpf1sgXqpDAsYbvoFbl9mbMF4+5xgVivQywb45UHy2DxOA2iElJ5uk6iqYsmrSp54GUhWm5zodDORZ2n4wa+tqroabrc5nKA3Qy0jzFSroa9P5LZx5mncfCzvPoTKQNuUwQyz5EXZf0BmmS6E4OTzw4EsD75JNPo4SK/vqngVzWqpxv4tk6FoXlAlUzPgiRerJbDssm8V1oLLiwbbL6MJiTX0XvD0icAJGTbvnoFc31L3D6dhabBA2aeZ12o3NNEGXbd/ETMZaj4vdHvhD4mP/NS5DxOVHGSh/fAopWQaKYFx+EZYyh8U5QAKYsRh8lngMWzqrkSF6YNI5CZAZeGQ6UA7L0L+Xx64RwIAe6Np4AxifRdUA9SWaGyuoMmy08JQPJ73/c52K0IEGsgI+dYtASyQiDQwPeVEw2KxafwRXXGcgzpm+VCpDCGL3tOzrV+ZUHPkwEWb24AY+DevEyeqBjq3QPgzxCSBQBzQs+vP4ue2POFCHIOx7XwPgFg+xzdh8XjEfXTHdUrnHyaG1hiowS9UshcjZXMHdOyDJpHxdwqFUYMyzbpYPExNWBSIroZAOP7AuwvqHQI0/u9SIz0GYeWj1bpOS90IMu+l/c5vmPSJvYsH6U2Tq2j5DNPQMuMHqG2qG4jMf4yZjSqGps3X3EiIqY3H4iJIDHiwTyuf/bH/g38PNt7J1z4Nb/3TwBIHioGWNd97OTewg6k/A0ALpKPWfWduTK7exabB5Hgfpxff3PtJUsRIII7kDwBQkbk+DwDrEUBLG7WSaJhj3jKcS1Pg03JTVA8LNre5vsp06rYs674ECK508+vXsvP+JxlqKJsW2mSCXU35g465RhIL3fJ3bqDRMkAS8KCM08oh4fHlcXUGMkoZHObJEcAYN89X+odRdCzRwoGpACsr+dfFQ5Zc9aXrNCYgxWJyqmm4Nt4j54hGngc3eaLT1/mX/D1xIGyepNI0u4y11faS0KYaYsU0R4mqstYXnfch4n4nB3UPqZ+WjyKYUzO7uSwxkwWF9fQvNPiytqXYb6iBFKZWbd/Iktg7Fnn4smrJDazujeD0evYp+V2nE2nJA/2msHfKVX37HsGgoWuWJll6R5ReHkve1nbswR2ASnlJZ4szf/S+91V0ojbvOuoz+ZCgFLgO062JeDlZIGyrFKhbTecOHRnDv0FPUscSnymle9RkXHKzxYvdKrLIix2B91huFgQSNAF7ffOnXtmQ1nLsQCfJUhHCNTvE/GeZnXBdKkdHRZkGgBfZ5n1WYwVYLL7XeW2IlcvrDeJu6jL+yCBSP4tz4oKfwKg8bcf9qkaLCkzUWk7M3jZhj2m9uEl/X+7xcnHb7D8DHnIzn+Ktqvi/M/Jb4wj3g32rvJkffhP/oc4+gy9gLdfQZ371V/5GgDg468/j+bHaKWzeBRw8iqFlerbEd29Gq7zuP6yCu1VwO6exdQCQyyxtnozYPnIk4ClJv5F2/NeDVMi+nJ5FWfkYbC3G+J36JW5Fl4UgmvhqSr1tIqMGJ0BI+rRyks1W7iWB8uSF6CItMEHmLrK3epMMFYDwl31xzKzJpGGAQkZ6lh9VmuLy1NULmaYOEociNv7phKo3z2IpTU4kjR4XH0kAlwLbB8YnHwqYFpQeHdcGlRbKi2zfDTB7SYBWO42ajR1/ew9z7J0OOzJIExzIYwhbaJFhfGkJnV2QwCvjtkw9XUvmatZXcxCLNUMFLY0m47AjD5fCDJo+7MjhMqiP28xLZl/SNew+viTNJDKtURgpxIbzHpLK0lPRWMp09FHb5ryxGgeT+wTBojjxUre/Orxbeova+FPiDw8HtWoL3cYjxvUT7cYz5dSJNfuSECSB2mEqJ3FK3nd19gP5+iSUGKlWG8syhymCVlZGj7mNEl4ThI9pgmoa3rOhczeJrLyrqN6dZdXpA4f9aP87ZpCW10He3Euk46EFlVfpqSXiXSdQqCJnYu0VxVdL48X+jffw6ahNrct/Ace0GfsBb1akzAnIPtQyaAulZfRx+XtnKNEglI8mD17k5dkhfRlIr0j9rOUAXIWWC0lIQi7Ll/s8dioM/yUNIYQ308TcApnx5iOW4TaYftCi/p6xPZBjZNPbTGuKtTXPWWsjR7m8WUKq262+1nayrvCIDYEAtymbSIwjqKZkbA+XaxghgnDeQR1lYHrSNOJKST165dp7GVPFo97XNyc+85PBL7ZezWOKZkjJhsJT62u0zO05YSMeP+aOktWQFXRM1VVpHPIwqXsFGibvFxSKUlhTD4O6N/bXZ4NyovrmBTBJZvkHvOz7z21h3Xv9KKagR2T62M9SL+sk8TI5BFqB3e1pblkvZVxw0QBa629GE5W6F46BZDoFFyGbfvShE/+7t+Dnyd793uyvvyPRw7WR0bcfmREe7FDe7HDx19/Hh9//fls25NX6WbVtyPs4EVzqL2ih2KK48XqzSAAC8BeWrsdPNwuZoX1E4ErrtXE4IBXKwpg0f/zhOE7JQ+ABLbmQJcynV0FKPClyulo8uadFtXgadcZ3oKyObCdfTbDA5NsmrqiAba8HgWwst8lp8ATuXtcEQnSDl5Ku7BtH8SwYHSMsHuYf3MFgNS4uMq6635EkVe6trvS6qMLekHPQMVEeJ7nHR3/znI+lRVdNhbQE/mPEmQogAUgFXeNmbHBGSxe3zxTxsDsiDDLYYxUh6zP/r9zYJ0mAqLDSAPd7QzJWjyuMdMnegDqp+wRiMCDi+S6fIUskzlnRT3D3g5gyXb8jN/hfeBsPsnAg3ofopcsrON7zcKel+QNlGzBIfc++KeXcw3Ott3zDPOKX3PTgJyfBghfSd77UnoiXXiiFvDky2CIuVHl889AQH1ulgvozM3Z82SSLfG54nvLITsOtZbPqMqCJsX46tkLOUCevaNPEIBZPowaU5vY/1xY/f55saPSh3Iu4wLK9fI4yu8FT/7xfxcrG9SXO9RXnfCDZAEl1xX5qFUlYdW90jiaKgKocGbhKZw87tJTE+sHhK5X7WY5ngg4+LnjbMfSQ6ZBUdQr3KvSwLZcUN8pgWC6Zu67+dJOAqC1R3SaqE1lYgqryW8H2N0gNVbFkykRF2qHhJ0Lj3X7+jXa169x/NqA49cGnH7K4/RTtC/jii+mvWtAlm/SS1+d0sPRb+hG1T+xRP0TS5z/lMf5T1HnNdfFqncMqLZB3Iac5snAi2O4riNQVk7iYkxoV7ogohnEbl5euagCuPRF8iqFcaRVxrAfgqKN1OCn9VV4QFCASmyaaKJQA6Sc6xkmg7kegJAG/2dmC0obi8G6qPxeWnCWRPG4AHV5uKaCbypMpw2m06b4riBDjsDRqwFNkYTHgnUcsgvOYDyJHKqYkccpzaEEFnsNiv0/Timzp+wXa9Cdu5i1mr7jcjvjgnW4GFiAsmdY++qWNXFYDZuyRkNb74ERXkVzH9Q3ZUaYzgLw4oqXosGFZQMTe/bK0C6n5TO/I943z1lWcWD2Jwvpr4nFIvn4PMBv8kFYSs/o/i+endmsM04C0d+zKroCV8/KaKOM2In6mtPMS/mUaDJR8aTCfcVgbNeJYLC/jXyR60juVZ7gsNneHc5T1220ZAV/Fnlitm3p/C88kMLOLJIr5ovJjT1zmn4QPX0STuUJkifp7Q5aBkA81XMLFNVf5bhhth2BQ12Gayq8Fxz6LEoiCbeKPdzLWibdhiVBirJOflHRc3dGXjBRjC/fcQZDxfgn5qy898y15f7mZIMmZgCzNtMUF0MpQ3A+LHun6cSiMps7JsnMbsubjCS7sac9xqKxHGLfdfRT0lP0sdom8a8WTZKB4FB/QSeRcbGM1GixavZulTaOiUAPiEeKS46VGYhlWD5cXafjjCPMzQbmhp6L5See0u+36J6cfMJluOKLZV/0cOEv/Pcodrp7MGH1qkP3dRuYTy0xvtTj9IdbdOfAC/+IVzFxFepJIoC9FPzg7+7Ri9yxmOhVQL0mYm61pVW6iysh5v40T5NIHOu/0Eni78rRxGEtzM06DRLsNgcSuOL4eBH/LgVCsxdmbuWiS+eUL9fMqp1DJvELvXEKC2p15VLJndtcTnrs7pX94vatCkvFyVO8Uy4/tm+ZqDlRJfp1T0TwKaB7YYVqO+Lmg7QvJzCcvBoHfxPJ7/G07LVqLwP6M4NggPUHAp77kQA7AYvHA1zM3uPixqbg1OwJXYYALhJtOpocRMMm2ni2BKxBf1qjO3dobn0U9qPvOZO1vYycqN0Etx5SNYKe+RJRc0o9JxzKC8cxgyqCFt/mhZzdbawreKuui7kYJaG8IBpLDb0SaOoEBdU/IWbR+TkRUkdhAW6nW8fw7FMCGiGKVoa6gukH+j1OeZ27cYRfb6QEDNteJqzmtmgvlZ78+d2bqMRO+X4kL3AMJaoyPGymaeh+88QQE1SkH/lZ1tww5U2zUdfJHB0l3a7NVnS6TNPsL7ZKYFVwoXQBafPcPYS6okSIEJK38KaoJblsqc8ZPD+9kmNyPwugk5p78RzsYQwhaVHpsUd72VhHi/u1qTOuX7i+BZcY0jpVe6bDmMZIIWzWZgq1g+km8qo+vaHr6wb41SIrawOAlMiHMYWdYsRBhxLt8RGFnVjbqW0gyQxAyqhc5TIdUqZG6cSZEFBddrC7nu4DL3al1FlcCLB6vMiU8DvHc4Tf46gleYS4EOh6Ca0aZ3Ndw7I/OTzs1TsNpPukC1g7m2Q4CjI7l0oTcv+oAHpVUfurKumoaeN2lWLVRUUG+buu0ljI4U5e9MZnXEKnQJ40wO/70Yqe3aMlUDnsXj6Bby2eflWNzUu0zU//nv89voD27g4XXvw4AayzT3iYT9Fkc/rD9NIzwGofx8llJIDF6t4lQXF7L35ugHpNN4rFSBlgiZDiVZy4OHOqJAl6T5yeYYQpyYclafyusJQU9ozH1oPtXAYMlCuWB1xepZTlSnyYzUwCkvdKJpNypaVBx1ypnLlrYCuzpPjaOBxYaiohFUblMhndC/Q/A6ztfTrW9VfGU0Ry+/Fr+166gRKCsP5AoDJKzKeNAMt2xT5SQmdmoOewYiS9l1l23N4haqzxuXTZH23t044A1tx9Ye8kr+o5I/Bstb9pCPK8uut9jwjvK9fGz85d9/EZYQgJiRerXVskAkxRtHEqS53odjNxnj1ad5DR7b1z+n5GRV2OJWAwhZtmrSwfNWflarw0BnhlAfZnHav8mL0xnF03JzXxDo8ppPCo0zU8oN9luSYAaULieqSlPatf9toRCHywcGlpxf0UEFV6tH3MiJ6eMT5y2LQAmJKIUv5m2YM5D6GIcUYPNnu3Il9OvFwsOXEaB5G5BAXOmhOtPZ993n72EgAwnufe8j0NNYDCuJr7xFYsimXfufsHpAzzye8lfuwXYudnvQir60VMCNACxHtFuRlYRsApC7Y2X0yHaX9xvqcbxiYAr9ieFwBdLEnX9ftJSFY9iwz0AXmGONzPoHDx2g1Wn7zGxU8OePDDX1xv1hcVZH3tv/4ncPHj+4Pecz9CnXL/n3ZoH3cZwAKwD7BiSIEBljbma1U3PYGruwAWkCkYz7pVtetS1xsrXPbiLi0B1owF8aSolQ/wtgBr9lhMcC9K7MC55M0A9r060F+Z7LeYXsmGcCfA0sapuuNZHNjY83hUo9qOuPxIje7M3gmwsmvj08Vn4PaDqe2PvtaguZ4wnDZ3A6zsWornhLlI3EZDvCQBWGd3ax6xzESwwO5ecb9DrAtoVKHlZxhLPdjRJ4DFCwMPmCmQTtU7KS+jJ1ae5LlMkhoYg737WWDjzEkgB1h29Aitg910tAotFyna+PlQz4k5I8KqWRIBVvSz7LMFK2czcBmUOCIUh3FMhZdn7B2FyJHeA1Ixr2cBFhdont3/LmCok1z0M3pXxhqQMm5rR0WTVeJL5kFmz0js31mTQtZTugYmcjOIUZyvZ5rykIfbdUbeB7APtJ41limgZSbShhIerE7S4LF45j7OAS1T19QvTa3qLt79XqdjzQCtukLz1hpuO2I6i5784wjm+JhzmaxzQKuqEoCQMlJRh6rwimU2A7RyDhUvrj39DPP1QOlDBbR0+Rz+XAEtShiI4/kdgBBAJPfbGfCtnlddSLvM1kVc+LKkBZADLd0HkRMnnuerInEDwIMfDvjaf/1P3N3eL6B90cKF3/CvECFt9UYSWwMSkBIZBaVXIurSUZPHRV4MlxR5+lXpJiweBVz8RAwFciq/Ag72Kd0IyTwrJQXUYGeeUhw49H0CP3eliwN3P1jATPaLzwbuUHiJJOwxp6VTvrQz3A7auYjH6wwV3rZ8Ye6aHBiEcVo2cyhOkjeGVZS5jAJ7N5gHt31hKds++toKx58NuP6wQR3fjdNPp3axqvrNB6h9/Qmd//oX0z09/8ep3Q/+cawLplOEZwQBjRAs44qV+3imUPD2QyfZNvy89Cd0bX1Uoj//aa5FRr81MGHgx6E+boc/4rAI3WsuCi0D+lRMKEiDPhPjJdNwmxO05fL5Xuv7qQdzYM/dz++CX6X+4FW78UFCl9pKuQyjU8SLcwjng4nS13TfPHOb7vI23ZWlC2TCo/nFJL4Z/eaJS4E9DjGVJXWKbNvsHJo4rscKfi841MOgoQiV5MAqAsTKibSCbk//YcosZO03++aT/ess3l8mNPPKnvtWJuFyAagmME5oEfBYAksGcfxssTeSOavrGckBlSFHO+eLNPYwiSeOnw1dx5An/SYHPjJW62eMten4Hm663Kta1FksJQ84fA9AnmHZP+7rVymsCSTOpZyTr3mTQl13SmFwH3K7FAeQ2sfuev0e38UvnaGl6O0ZJK3SNcr8x4CuBD2q3ZnMiZkBSewoKKoh8DthdHIAn1dXnpjh+Uq4sNRc1FZo4fGzNp0TbnjrG2jR8SP/8RckbPjuChf+yt/1xwEAJ5+KmUlXnKE0U/YCyKp5s7lt/uIPka/DBYWP3pjQn80jbXu9TUrk2A8RiWbM9Rrmep0rI5dg584swzw8wQR1XSi1XE1nRUyD3x/cCpsLF85qAZlIfJ3jhAFZNs6sCT+NQghmsUiThdJVAiAk9vEohtcKzxLrLvWnFv2pxf+fuj+NtbXb0sOgZ77danZ3mq+7XdW91bjK5bLjOLGVKDbECdjXigMIFAlEEkUGCStBikARSCj8JFKEiISEEAiMYojBCCIFJOSyDcoPtyFBAduxXVWuW7f/7ne+0+2z917N201+jPmMOeZ851pnf3VvFWFKR/vsvdbbzXc2YzzjGc+4/L4h0nJOhsWAqFV/XWP1btaSO6V2+aPMeNVi0OlPIBgq3kfuSt7CWCN5frhIvzdu5BmONw6+EQ4ZS3BQB0vlG7jHa7Hq8lysdgMwSh3MhVKzZoRxTHkpK+T9efVnk5GzKK1Ew7KuTmoC8T6GoE/k9Z3LQyk5mAZWKJ/jZrNQcuxw/nCuhTlma6Ml1+5a+UexUCCV3UB0dOZ+OIlYLZrhcCUtI4onaBqR4Xx++PQ+bJYmf9dMOo6LbK5RFBMfPROFfIaxslbf9/DOwX36MmpchY1HywqZUknuYS/vPyAs1UUaklbEXOVW+vj8MKg91yBLGj9lBBPFOYUeku9lz8v1KysO7Y5DRDJONDeJLIkaYhm6ldQP3a5itQ5gibbm1+HYMrUAATFGfF3B11UMifN9UDCTWeE8NnfelDdYSYLC9WWkEJBqkSNiFmE61YJUhvbtKSOMRHqbcDVk44GNiDefgYkKppC1p2YY72+V9pkazK1IUJwMxau+lkkYO/ddRlROzf0wHqgX+PzvyHyh/fE71X7Hkaw/+C/9W7j4YY9mP8nGUsVFmhujbypUu15/n1g/LWx+40WD5jBhXNcYtzWGrcPxSYX+Gth8Lrd685tBpOyuVzJgdRxR3S69LN+1xpCopWDm/hgHlCWQjsw8I0E1KFKf8Fjt9+Q/9Jiq0wt+7n2zmcHkKifhwRy9CtpCSlrXtPKwYZuJykKujuTDkrdkEYDKifdqz9E28F2Ledti3jTwlZMEg4Oci+VmXJgU00WHadNg93GLZu/RX1U6uqiyzOyQeZVOHqJHu48q9DfA4eMJmx/UeParE9r7Cc3doIjoTI5BGDPVXkix9a6XzW9nMm7YR0SWOqmpdfyA4y50wQTASzjzeF1hboHLH0yoRq91DsmZmS5ihpbvKjRv9kKUt4/kHHxVoepH2UD7QVWeAbPwGS6Xm2Yh/vZDVG0GlDOYJGbYd0n+C+H3oFzuV+1SRyxb8PtnGynp4Ry61wFh3mX8mNwAyThOiV6Oc/DbtWikNRX6p9LP6x8EtCXA/f7+Xo7jhldAq9TAKRB99e+mD+1nigTnavBtI9/hBhcMkJnSGFk4LJmX+UZoE06ozRVI5yxFM338RM4f1jui+FOohFAHBGvuGlTffyHX3x8iydk8Q0SG1qIpRA7S7Z04eZbPNM9x/ahc7BduoAfj9GYF6pVDRASKyNkwisYSEZhcmHMcQ6UJF7k1lYvZkEDcpO3f2If9INfMnQa+qzxjlhmyl2txDkLhZc0gtqR0jtWmEQdmLVl388U6olTaH+FY56Q6QluLWjnXG6LpdEx2B2CcUmed7yogSr4J4cx5BowUS1KmjQlXlvydj8fQ/DRrNQRneWEc78z4peEZkn6KtSkrB1/Xuo5L3y/Dye44RM006vLZZDAgXZuqSvtRa+5aBNkm5ASBVjk2M6w4PoNeXI6ioWvh2wbDR1c4fLhCf1XhP/y3f6KI1n96kKyLH/ZYvXjQzVe94IyAN10xhT1dvOvjhOYgRZ/Hbcj2eCLH0MBa3Ybw1CiDwI2ziNcdCgRUhc/LaBabSiUw266KhZIXRlKGYp1rizDgKaM3M7AAY9DlnsspuNjeG8+18L4NAuGcegqurhaldDgJFTUK786GeLWNTPkPmlN7Gjjh1sMx7U6+RyON9Qlte/Lr8h4vvi3X3Qcph2l7hs+SZT0qpM9JmykeL4ig5rmoMN8+hNB2qR4hr9tVkoF3AoWjorwt03Sq0eiiSvW5755suWYQx/AZL7l7FXSDAtLMbMlF4wZ+LpRO7/+1OC5uX5iTvDeiPESWc223PkNFvgDB+5SmFoDzVABgyZc8N8/zzCq9geX1F+nr+eff/VROGSRkznHB+B2VnbkKGZCFAtZ+ms7zpLJGA4vnTM5XZetpFrpZUBgew/miQUU9KEro2OvSIMxJ8VQMZ6FjXbOWIUZtYbMn+ZqZs4tqAEHyxO17AQWaShwHINYwzXhNZ/uZBhnnda7CrmvXHA0rvjuO/VPRiMzASppFXk10JU9acVPIEnZO1sdCBrKWErPitaeaQdJSSaPQZ/Zv1Ds7UbVBQ/6LjMtw/jAO2hd3uPjuvZbV+51ov6NG1j/9R/8NrF6wHMeIyhTOBeLGxg2RBhZh4fqYZQmaxk07MbBMUwNLjQdjJRdIub6u4N/dyb/cGz/XTmVxMfxn4M0imf0MPH7yvECE+QshSEkHrxYEStc0GkYUMbzMECk1vhuGewL6Q30q26rDkAi8zpsWzcOA6jhh/fkR3bsRlz/sTxpY7W1Y5A6zamF1t2EMBMdy82LZh9OmiUVIJy/htdopN88Nk6gnnzCwuLh2bwfMrSBzVc/QpXyXRattU4PFhLbJMfRrQW0SjSQaK5lYqJtmQVJtEXK2UrKC5TMA6aJLZWhgKVhZ8vqrSrxF52JhawDN2+WGruiZ3eyPxoO30hBW/DV8v/7RKwDA6of38JXD/mvX4rFeXxgEtTAWSwu3RVy9FwSrhGIBSMLwoeQOZp9mX9nFmhySgkGQG1pFAy0Lcyp3KYT76s/egmLHzcs7NVKbF8IFLZGCYxg4GB7HI3zfy7vIuEOqy/b0Rn6n+niieTXJ8X0f15BHkLd922C+3koNUO2DLDRsDS2m/M8+Gk+PaVlxYytvsJC7OWFouX0g9xNNtTykukDS5jGIBocrcAw5j2alKERDy7e1rEP9EMOHNgFg9qmxweueWJvOOhKZoaWGx6kkEiswe+qUHEuFMUh5nnnd6T/fNTEiQCpDnl1r995T+6UmfBU+t89jwtguc6DjuaR/3cNe0cGL797jn/6j/0b52j/h9jsWLvzm7/3X5T9ZKMRySii0R2OLYYzIZ4mdyxDD8SaEGMPkJ1GaKr2ACVmxzlZ2XSIxGgLhZvk2EN7tQMy5Vln/lQqpxmOJ3qQImJZ7yNEkK1KXbRR6DPtIlenLYQz7Hb1uRvR1TRMWwZj1sSDK0hNk4eQb6jvFBbllSCkYulx0GLqDTWb4JJTSCZ95hvVfDcnfh8sG3e2gwp8vf5/cx8UP47kuPu2TY4g8UQstqZk1ZmOKYcaAoB4+jhwWFoU+BgNruHJYvZ1jzctQaoOaUdM29FHow8YQxXUs8h0cUyTXbjyaLaP6ORnJtGCA+MNB3t/Qp+WPtCBynZwjL94qD5Ia21S8d8HJ0WwvGFSB45ChnryAuGaupeR/hswA4+2zb1g6I6AU860gClRwt+dZtDMZtKoNVQi1A7GviNjM4RlP6WTZc+VzSg5MN8ycmJuk/teV6kwpYmTCpFo/LktiKSqoc7x8+Fy+E9a1+XMxbpO1ItuYdeyQq8X3u92IgRJQLL8JocUuzv/6xdvkGB1PRKLsxpkLzSqvi1w+o6Om0jbRsfT9EJ+dQqwce5kTbcNfNLB0Hu4yJMyOjZy7mYeiOJeupU/mTYu5k1I9zZt91PQCou4Tr8N1lsR36yRzzuSSIHoyGlUFI8o6XMAS7eVYz5IXLE91Ib+SJR7w3dtGJX4m8agocUgeAxCTrJyTvqWcRH4dvu88k90mneQRCraSSDb7L4Rnx4+ECP+X//r/cPndL97+UxIuPKedkyEw+pKO6YYyd7X8qx3m2qF9mFUPS9P8Scw1Uv0AgLqOZQQ4MTQDLrw4fl66R2Ng+WlepoGrVxs+I5xrFXtP8LAWpHfzzHlmlC2Xc7IFletToUxnPYl5LhLmlSehsf9KeAWGN1TRgCDH8S09P/GU/RlUbN628I2Db1KjiMfQuKFhhQpoA4r59NfluVinqh4MGho8Jd9UqA9TlB3ggk44nhyH0EoaQ8MFUVX5fcwkrVj30g2zkOsrh/ogRHgqv+vCw6zGfhChP3rWVqeM/Kvcyy8YYdr4DEYM0Tbl2Kw7rceJVgxqohzMJNSUdc4P5+COU5yHQCTDkqOUbITnQ5huvU6ELqng7DVcugyb0tiomJKfGzLWM9YbyUIsWRr4OYV4P4zCV2H4hkbXqdCWmY95CSxtJhHAk09DZy5o/CSZobOPBlXpHrMkFk2mCciWGoSuAl6+EX7WqpUCvZR2yB0oBCS8aSLyngsps7URrQHKoXoNHW1W8vw0gvKQta3bR4kROhI0NNgXlotFR12NnUz+htcnOfuMVtx8FdDTnKSer4Elvip/fVi+r/HpJhmfimZxLOncDaj1e5AlWwFhUWjc6sWpLMQJFFeLqoekrqDC7tetrgGLihB8Tt3Hl+gW923lV2+Zych3b6JG1kCyxHkS5Utiq6HO47J0U/Y719WSscXySe8Oynf87Wy/I0bWN3/vvx4NLCXEBrg6bDjJTZ0xsE61koGVfL5OydqoqtMGFhthdeA0zyrTfjmrv/MYA8t+l4RAIDGw5IcJSanK7wlI+VSWYjHswvMXDKz8FsNnE2v7WQMLiHyIQy96N28fUO16uGHCvE0NGg0RvqPxJO/i4ctLb0mRKnIgrYF1okWldGNg2aZGJzDcrAG/NLCGS6KlIbSzY+jyzMLIvZ0yDnlxZ9u4aZwysFRvaBaO4DCkBpZtDBEyvFsQiGVjyHd6GlBFhu1LvKEda/0tDaz0WWzoLRB68/OFe59fv5HfX76Wey5sVvS4q5B9V5G0m2vnAEWE7+R39bNQcucEd2phaJXCNnm4nRvrmWiB1p1jpuDDLv3cpv9T7NToUgE4bWgV+lFv1aTv23MUWya/4J+KkTZ8LD+toeVrB3+xEaMFSKUQgKWhdY6TNeZrb1g/S1pPoXHdUqHf59fZsxiHphFOEfX85uvgQZ3IBizSRU4YWirHYptVUwdOSodgHKV8Uz8ImsPwaumezHhMCjLb9h5Dq9QWhlYezrSGlvfwVRXnCvUQiehbQ6tpknMtMrzfZ2jZe3ifoWX/TkOX5zN6mBpl+21qv+3hwm/+rv+eXCjP5qhcNHbCC+0/jETKei/fV7VfL8RqlsPhRkDl7WY34eHLLdavJ6xf7IEgZGe/yzpUABKir0LGZgP2D3vAz9EzzzIf8kHvp+mkppX9O7MCF7wQW7UeiH1F8nk4jy2h4xPYtI5GnM06tKV1gEWIUpEtm+JNb7+pY2aImURazPhig3nbotoNcPMsekcskaB10BrtW5Yt8qsOflVjvFrBjbORP5BDDs/DO64dfAXcf7nC6tZj94nDh/+xLAz3XwmZhl8KE3sAPv6PelOYWP6+ehEWvUOvZXP0nWVq1TQ2hmdrTJ0Udx43Fca1wyEI3XZ3cvzl92VcdK/3mNeNEF9XLbwDhusO9TBrIkD3MqgR7/tYYqauhJvUtlJ6JRgROt6OIbt1muFuruSYppY0/dwLBhJewqKsznYjGT/THLOHnINv6qjVxSLXsxcHpaokWYF2w76P4S4aWvu9cE1CIghmybTF7JehMCIfu718Tk4Ns3VhDJmO2W2hBMo4Sur34Ri5h6He3rw/SDmdcUidEn3J3IxkfmhYr2liFlMuq8DNqmlEu+phF2sdnjAq+dwu8H3svVi6AUtcubo2a8kcw7m8/3EUNIvcqfxcAQ1zzgnqFvieSWiRc905uKsruK6Fv9iIMvz+IJv5PjX6E7mMutL7SBKBPpLw4/Bc1uvqOGpmcb0f4cYZjiR+jh+j+eb6QdaUcYp9ZbLlfD9ImJJJRuSw5rXyKjEsNJu6a+M8Csa4hrS8R3W3l3XJe0Gtm0rWCY6/wJGcLlZoXt1jfH6J9kdvBYnrh5CBvSRqJ5pwdSU8tScXiu61Yf4r0BCU1n1TS/mfzVqOrZxECuhk2T0hT2ZiNmjXxiw8Iw+UfDf0rzdOmqsFdc81z1TAdRglm7mUXKG1TYlABu5ZW4uA7DBh3rSytm9ZfisaZdaJKiXcuNnLPY+ZA5k5FWhDaahaIixoQraq7QP+v21SXplzkV8cKBO/8p/8WByt/9+GCzU8mGeUmEK0eRZhvlhq5pqXf1U/o+pnNLtJEYX169CJYUIztGjJ16XmQyqxZz0vQAd4zjHJS30AJ5Co/BqPUW5Xo6pM+j1/7Fz+zoJ3kvG/QuHUUqaSL/GWnCwEc/AUlWMUBCUX8gPDGI1XbhSrpbdFJIuIJI2k+y/LHxgWPDyrcXhW4+7rwN3XxbhyzGkgijl61McZ7d2AedNoBt8C9p5mDZv5roUbJgzPgqdNZzfosa1fz7j84YTubsblD6R6AOUMyPUiv6oNZXCqcUb7+gBfVVHxnf1SUqomipFzT0ob+xkvNNGWYjkRagdlm0T1cMB00cr8yisX5KvDPIeaiS4iLxnSq0ZIP8gmfn8vIYndPqIyuRRDSH7x+0NE8w7GCHtEc01MQ09+Oneag+WCQvY8L8mzDJOFOVBRwLFtpCC1RZLbDJUx97C4/xPolhiQtWycDOUkFAKfbrb2WAo15oh1ScCYJHAiSpu1kocXemS6uZlnvbyA2x3Qf3wJ3zhFaMk/JDfTrxv4lWy8GjXIkalcDHeahH9ELqqlWHhDv7AVMuhIq1QNMwMDmleKfqghG+fCtGkx3mxULmh8Lkba8MkT+Q6NTBL3S6gJkakhVmuo9qPIuVgDCxHBoY5ZKfkqadRvs41r/iMkf/KmY8voOAIolyxK7iP0ewBI1HlieFAlc0LS0k4kHcarVXkP5ru07zSvIsKsQirht23kfObJa+eQ0bxvuSbuf3tDhr+tRtaf+Nl/LRJ785IKp6A9AEPQQ2LhZ9Xx6d5/u+07Zra8v7M1Y0Szyr5ASnxpsTtTSzB8If6fWYahcO2CI5IXes6uI19xyc9FbcMzEg6LDadYfuaEsXcm9BR5EeE69Fq4sKqRWqF5GFAfJy1xxLDb9lMmIMjz7L484/h0Rv9kxqt/iKG6YHT9QkBVOOe8THQ3zpIVeBwxbwMywoXNZkjOXg388cka1THtsykUraYw6upNMKRuT3t49N4q1lJ8WIYINSuMxsp9SMsvqWXzGCXnhmurx5u9d3q0LLhqnllJpVTqv96gPoxo7o5ROJabD18ZE0Ko9XM4LsPIPK8xEPwwCj9xty9yybQPhtSomN+8XXx3vg/9okkboY8zkU35sBwuL86H4GSIdx8TPpTwHY5Vja6QuZnMNSVvLzdIRy2oDInQcj2hD1xdy3s1PKgcbdZ+ep/EhFwg/Z33Xypfcq6Ic95YvYHzhMkdefapSqSEn8N0cpNbZCXa7Fiu/Vyrcz6XM6VkVEMpzPPAhRyvVhiv15IFGZAtRi8om9G8CQ7TuHR+Fo3PofUSM/FN0yzaA8Q1qEi/oCFXZc/DsWM4aJoN3g+yhqkBm92DqXXoakH+oqOdUWDoaBx7mQ/3u2X5oqzsnCJY4xwFmLPGPmX9WjUsS61O1+izJcRO9WVpnnPO5JVdOE53B/yJn/3XTl/rx2i/beHCP/G1fzUNNfGn96mYZVjsx6dbzG2F/kmD+uBR9TPq/YhqyLw5QInM86pGdZwwdzXq/Shp+kduKuTYeLg51JBjCJHZDPQ89tkC5H2sqj4J/0XDhSdERZNQIPhRZvxQwuExLc8G8UvjaBE6DOdfLPY04uZZxVPjTQZDzWawVQIlO6JcwxA0SlLvyzcVqlfvxAMN3/HeS2iHHqU5r4q+Oof5egM3TMHDJfyf3tPdNy7QHDy+/0croALcBEwXIaPvbXjGr4dSOn//EtUR+OT/GVTIjxOqfhI5BJagsVyxEP7061YkHtoa00W7CEOPF7UQ8L3H+vUIN3k59zBFEV31pipMmxbzqkZNHbjdAEdxWyAVabQCi5ULaEYVwzzKW4ljhuKC0k0mfMuQDsUd+b7yBSiEKUScTxbI6uEI3zVwNAZzyQHvzf0fxAhg+IxyBINBPaZJSmdMk3ic4fdFqv2cJY/wWFOHLBbQXcH3ParNWojpbSNjsx/U4GLoay6Vgwnz1IYLk77lPGgbFXHM9XqUC2RI7o5hmzwb1/S71aFyQSrANU1quAGoFFWq4I89nHOYj0ckhZYtJcCEe6rLVLPKH44yL0MozXUd0DYhtJgaxDgel+sSxyf/zvBv12H65KlUbvDioNav7jFfbrSguHL62hrVfohjq2tFaLauTkoyWLTOj2N49nTT1HDyOMb3xPdKYc8bQaLGJ+H3uhIx6n5Sx9/tjxI+fStZq9yXpg9vUH9+i+FLT1E/HDE+3cD1M+qHYwyZW604oqFVJYYJQ/Gh8LuuP30Q07Th3+0KbndUykz16l18NyeSXBYZ7SrE2oiT2zSCBlqDdDKkejOu82xSDVvXlaBvVRVlYDLhV2ZT+trp3u474eVVB5F/oShz/1R+trcDpnWN9af3mC461PdHzKsWbp41QagmrWcY4bcrVO92mJ9c6hjCMEZut8qN1NHwOxzhqirSMLLsUw1FWkSV4rDjhL/wvf/pst/f335nw4V/4mv/qvwnL7Z8wqCbL1aY2wpu8qgP8p0FmZgeUTCiprUYWM3dUb9LA8umrxYNLCBayCUxxgyNyflYqokTDBtr7Jxt7zOwTqSFl7+a3kuOap29TE7mTy7K84R7zTdG+9WwKdOL0o3gXCgrEwc8KWwJ4Prv3QIAvvTXyLM6+VUcPpbzvPzlUArnmhouBdRNS0WkYqol4jwzHNevAypFGYOCiCaNf2tgASfgaGNgqb4RsIDx88SLeV9Axfg3hoIKG71+NwvRVG+Dbt3L2+U9hqZSCjmCVmiKthxTo1JDWucakazC+ecQSuXzk9Rd0gAiuqUGlc26es+1/ankA9OUsJyHCR/R8jUk+YzzJjPqSo6wzvMM5SC3RvltgbOUI6dJW62WfwOKyBbPwzqkdDAWiuiITo3O8XxjLLUsOeFcuFj5fgzlFmqP6mkzlFYNq89eLr/77R8BAJpvifhr+0OZG8W1hNIvAc0i4b7Yd1k9Ra4/8/Vm8V1dQ99XIseen1IPPPZEMgy5WM7wffU6Q/aO5lnG3zjGdZ4ZwEHKRfl2zsE7+X3aZokuPH0odXf40iWOH6wxXa7QP1/DV1UsgRZCtsr9vd5ivFnBX6wx3qwDByyLvGQIrZ9ndf59jt7m62OGAqr98hNqp6n7P0bzxmJ2TUBC6Nl2ad04dqgbhYy7ernHvGrgvE/TxhENrObdAdP6Ql9ufXeE3wivRJEveo45hGl5TyrjkHUDPYKgw4K6TsIggDFyFqnbZxZyi2SdIr7bv8GiYZX+Xa+Ve7X5tYAlKqGLs0Ep6KWoKrOBYedQksHqqDAr9O5Bnr9yAO9v9vCzWfDNZuCG4MmFEg264E2TIFXHWVFG37VA7TB1DnXv8dX/h8fLX24AVDh8OKO9daiPwPTuEruvjUDl0ewA3wCf//4Vnv7qiMNHG3S3A8brNer9gHnTiuREFz1tII6R9q0sUuNlh+bosf9kjfYuGFVESIMhNt6EkicPvZI8Yx3HWRIBuKnQwwqIlXBLZBEQ4na1MCwcNYDq4Ek6FzdKGi78bttg3u1Qbbcybusu5U6E96w/WQKFPLHXtzLmQzkb5SHa8I5y+GpgNlIROUdxiuPRB0kJP4zxOfJmSrUAy3kFT8JdpeRoGkDz/YOgP5QTuRbS7vywQ3Wxhd/vo6FFlFk1d8w8NZwg8hNd2ywRA6Kyg6BnUiKmS5AqD4byzflLSTIWGbCtawEiOPaecjSncuE80r+wyGGJW1VV+lwJGsJ7MyWEFMkjQueclBrL0LLmZTBUvBdaQF3Db9fi0mcaUsrLrKtobCmxPWz6HLMhVEux5IRk3rVIyvrUYV3iVjbPEWmvKkGugpFHQWrftSE824vxAMDv9kkyBA0WF4pxNwDcNGP8QMZYBSQIvJumQFPwovc2zZLRXAdR5DkcRCkJK6GDStC+fhRkLc8Krcwcm6IT5ZXQbsJ93GMUmSEibLiGRAtDYk26J1UAZR2qWhExncvG0HLbNdz9ThKZjE4a69OONyu4wexrM3B4XmOuG4wb4Pq7I+6+cYH1q0G+O4oMTn0YMV+sdK09Pl2h3Y3onwm1Yd52qPohlBkzQs7eSeJQ5WJ4XBNGpqhXNs2yth2OAgzMU/KsP+n228PJMhyEGGdPOTl+vYJfrzCtauVeqSJ3LunwcBBeSxXvuHkgwhI8CULUFRW6p5hGS0t7wQsSMqEWizZI1+K+z7UstEdirHK0zhV75jEmA3B5+hOcD6sef8LIIwnaFqY+hXQoYdqQEBeNG29Q+z7rYXGzVj5K2EhL3BUuWMqrkPOWlNXXnwfuEzUcq/DOzsyPHKWykh6Le6HxHkr6sC5hqc2bVHiUi4oaMLZlXAtFZUqoSWYM+Azqt22BijBTqMSzy3XgtObhGfXtPFvxXFp1rgj+iKSQRdLGmcLoGpb0aR/aRh2oKgidak3C0ljNuGU+35RKjSE6hh++SDOhsLxpOJL3S6OuhHrpeYIA7j3V95f9kZeyKX1HWwgbxUy0DPkvNWukAkXel7Z8/Oq7KZz/zDhY3EJ+f0T2CqWKnDXygJhoUHonTNZ4Jw4IDctTckJaaYIq8jBrGx+HGdfHUf4dRr1PoltqROZO+2oVkbsTkii631guYI6G2vJHpu8S/UcmIFhUzb6TY6+EfvJOE6MKgG8r+Wf0ECmz9O6npB8OzykXUYXSRPWif4eQqUm5oPnJBeYnF6m+1onM/2J/0Pjns9tnfWSyzWPbT9zI+uZHfzresHkhYhlXWvuI9dfqPOzinKSBTh5oKrh5jmTFsHERgaiCh+JXNap+xLwWXo39jhK957jBe8bQeW9UvW7SSYdhDNIIURKhSBAHFsgTcMIosv8/pXmVHWMzAkubVlG7J5yfm+fJ0CNTyVerBRFSF52wMc9XGyE5vnuISsH5gOaGvA5pyeQg2M+4AGoZGfFW3f4YPwvvevNpqJsXRD9vfnPGzW/OuPjU4+KHHvURuPo1uZf7n5LzHZ/K9VgCZ+4qjBeSPZhnNla21A4AjLMI1FUO3btsbLJA+TaSM2eSPmkI8zxMrjDiic45RUiBwsYQmqscWJ9MUJJ5uaDaFiQ7fJB9UDI1+9IaUP0A74Qf5+4e4uZGzl9G6sWZ+niLTTALXf//bcvQ3nPlSVxOVqbBmJH5daG3fZOFMatQq9G1Ldz1lXBKFM3JNj5bDcILz3LeH+A2G32ni/AZr2c2aX2m7J0l420KYsWkTfAjjnGGk1nLkIK3QMzKsyVs+Hdu8F2bOnbk/OS183iu1WqZVcg1pmuFAznNqHYH+f8hdZiVX8hkE9bjm6aFBpcaqAxlX66lXNjso6OWO6uTcSqnWfYRVXjnpp6TzgUxdIchhhy7bI3lvbCGrr2/vNmqAtbItkKluQFn6R6zj9mctmXZ99isZZ1pG92PmfBjK3sAgJs91m8mVAOwfiOfHZ7JONl/FDhbIZpQP/So9gOqXY9NKBzfvpP3pglxDEOHUkmamTqYd8h+Ykh8GBJDykrIWMfqmx/9afyk2k+U+P7NJ/+NSMKtKyx0nqg8bTKbUFWYVqKvUZkq5pqO/9ZkW3kvZMKAarpxFus3TFxmdTUPopnj+lE3PTW6iKSZiUE+gZbcCbFm9fiMsKKGDXMtrFIM/pQX/0UK2p75bm5cSY3COh5nCLnJcRbJqmv1mjRMxGf0XrzpuhJIeN3C7Y5CGM0zMXmf0xyFDq3mD6Aif6q6z9BB28jCx3fTRpI9kaLxeoXmrse7n7vE+uWA+692cBOw/8ipCvvhZ2UStt/vMDyZ8fFfdxjXDtff6QEPtLcHHQf1Oypiu6ixMk7wbQO/bjCvGuVx2JBz/yyIHLZyr8xmrVmyh+PWio4qzydsRkQdyFsqpdorwpK9P/vdLCSsMgN5/wMRqWFmD8dmKB1lz6Obs1l0/TiGskshXGfed/JsmTyDD9pRp4xEhjz4XX2u98yNnHAOANW1IFhu1cmmeftOzj8M4kD4WNlAydOBGO7HMfJPgIjowqAKQ8yGjCWq5nRjzrmSbRMz4044OtZ4qz75SI4PY2R6/Tact7CWkD/J988SRWEcWMTKZUZPXuw9UX1XbcA+OR8+eCq3EkJDCQ/LZplSi6oRnu28blC/eYhZeLzv+10MGQIhc1X0z5RnaPenupYMufU6DeXSwbHrymzuo21E96muFqWarE6Yyhg4pwkbAOAuLsLPMPevt6IFdbGSfWbyqinnyP0yITxeG86JMdBUso7mcg6bTgxCL9SKRPG/hPIy6SQTp3UmSUGfLeda5Q5DntBlr3mimLYzXD4FKsijChndWsfRRBIYTtx9LPc5bOW8qzuPzYse7dsDqtuwRgaleF87YIYYtkFyoxpnVHtjRHMtMzpjHCuOmlqZcG9iRDJpgEbsMOJX3v4ZPLL9zhDfhWAZFuA8O6ig/6H6QlyYzskukGB5KwaQEo8LMPPAYsUcL0aPa3EPtIbzQpyFRe2UgVVqpwysc15+Tl7/QoiANwJzOVky54SE0KFr4uan70fDjpJd6Ldr+FWHebtKDNOTz5CJKvq8OKhtefHRvNCxad1n4nXe/N23AIDtZ3Jsd7v87vXvfwUA6P9rwqe4/RkZD+NVgRjLa3HBohH2sAz3aXke0huCPlvzdrf4rp5e4ejwTnKNqEJbvHcLc5OjZ8PDs4+IR11HFXEiD4bsLBtbFTfboJy+2HSTGyKvgWHDMxkIubDnuTGc1fJbENVL7ZQenG28z8DR4mZTLB2Vyxfkoo+FFjOwwv2eQRlj1ly4b6LRJvTCcLFynryHu9jCH3tUF1uhH7CPlLxMJKONTlaOwuQVLJIbi8hPeIjT32UL9zldBgO1cH7W/iRHh9zF/stPlregBr/hLALF0kz63HQkFBEqjAOuI3sm14T+PRRC+Pl1Eq7Uie8Ep6t6OIoIsXOC8A9TRKnJzwxhRuFBzRJFmTz8psN8GZzbDL2Hc2IQbjcxgaFO50qx5XV1H0N1yY2rEh0hT1iwxefzpjqJgcvaUzNs2feX35P3swoCz4qQnpHRYFi1Pp6en9oyp7OYRMFn4TNSEqMfigknv5X228PJ0rNzITBZFd5HUTFEq9ZlD+SOg6TaWnFOnpapwmEiHz9Y4/jBWvlYAIzicGpg+aoKhMjxpIFFj8V1bYTI32Ng2YXzfTwUUX3OIOYTBpZFpnIRxHjxbKLUxmB6hEFYMrBOfndvNg0/ax0p10a15YWBtV4B6xXmmwvMNxdIqs7n1+ICSTLzfoghvfC+Vi/Ey9m8pK6Wx7T2aH/Q4fkHAi0//ek3cg/h0W5/NhS0XjeoDmNC1NTMvS0RnJg04XpBOE4ZWFrMvB/hDoPw+/oBvqkXBpZulG0gktb1EhHNwk5nOVjnxAY5Xs9k9WkqOw2tqkpDTAWyOo0G9QyDUa/PBCwMraQ+JLmBNLDUyM8MrXPjnL+a87q6hn94iEZTxj9M+FNtG+7BEIiBJQ9pGMRQ4XXbbmlE0lh1boFi5bSJpLB19kw0tIhgldrC0DLvPzdC9O+rLhVQJiIJRAPLGlpdC3d1Id81/B8EBfWSoeVXnaicXwYEjVEDVlIIqfnDs60UT7Z8SD43kd8qPRbOGJgZQmt5XI5C0hk1QVtB9iDnny4MGO49Qw8MPebLLWYahueM0szQQoE3yJYYWjm3LaszuzC0OPaMU6Lj3xhavu+hskXAIrO+ZGj5fpDSXTnPqWRoNXVSj1jfP7vDGFr1rkd7e0B7K32SG1q7jwMCdrERwWvD+9LqAcHA0uoeod6iW69k/TLCrXr/RJ69XxpP7ozB/hNoP7Fw4R+/+VNLr9C5uBizBf0eDtbxeYBg6wr1ccLcVqhprb4K2U45URERnjx+HPRQLuSz1SvZBCwSoVAlDS5y/ohAGEEyPebuPv6/7+XlvE8EkGEOzfCY4sRhH9jfqzo5xoVNN9fX0g2nrmPoocDdKt5POC75Kidt4IAAcbNQ42ed1vOyar0uZKGhqSUT8PoC7mGvsDx6U76G1+7aCClPxsjyPpal4Pvh9/gdlt+oY73J3U9LaIjkyXEL9NdyzX/un/2rAID/86/9fgDAR/97GWPbHxhEh+nlNNh5nxwrxptSiYcVHQP52b68j8+jJ049YYYA3O4gIYpxjB47Q2z5e2ajkCVgSPMmk2iaxEBKdKkKWWtWxymElOanMm+qu0ws1j5P7hFz42oKmyRRFB5DT94W/2Uzgrh51i5LyRQFdk0YUcv32L8Z2QK33WgfiSDqTjWwkvsy95pomMEYNTTQ7DzKpE2UgJ8R0pO2WNx5nTaKqz6TkJyK1O4P8gxnnDzqZbEckNusAVdJZnfOqdNMtdrwyVJeFkM0CfIT7r3/2nP5jKKkgX9DLiyAhVYhHV8fHOr282hIMpNOqx3oeAjvKegiAcbIMmPJ9z2SOqt5GIgO3zyrdhKqWhBl8hh5Lqv1xvsLocPq+kq++/EH8oHlOebK9UTO6JBa5FdLeAXHhnsP+6GAEuv6SIRa10sX1tpMbw5mPeceYw2pTP+Nz6nlsYACZ8ygzEHLTasEVIFbx/V7RfmcJdKpwEa49uHLsgdNm/jc9VGuvQ5cLMqEcP0tiZ5STkgzM8khtHOWazJLGNkMzJxDaQz4v3j7v1lcr9B+B8KFc7ah58ZFoZE4OIcFj6gWINbqfLmRyVzyiJ2Ddw7DdY3huhbEwgPHZytUwyyiaPwXRBcBQRyq44j6zUM0rjgAKWqYZVo9yhDN0aRSy/vk3DGB8G4NLAAxCzEnufM89h9bvulyAGmqdDAixlE21K5NjCAAGG826b3zGArSFRICFNnoslBUCca2kgNWKC4LIbphwnSxwurlEb4Crr4/Kidr2nhMG48//3//J/C71p/if/D7/gKGY4Mf/FfkffY3wfuu43vwXSOLQlNJKRAt30QjkdCV8Eu8EzX59sVd5IJwUc2KoGvCRqkodF5w9VRYLQ/5cpFDRKAWyFGuMq4XkXI4ft1pLcL55iI9lgs5f/I+A4wOYJFtuBAZRWrE2N9dwfsuPW/R8LQGlvkuEVUMQ0RtcseCmYaZI7hQvQa079QYZtjJZe+iqoG2E8mDvMhvVtBdCcf8ByzRlcsLceisgQWUwxx6GZfcmxqETGQgMqnoV2GcqZ5h6mySQ8W5PT2/Qr3rMVw36J92kr3N+RF+znREmkrnStVPqO+PqqqumV2vb+X8toKAKWweDfRGaqs6B3+5TSpOLLISnUif+IwrmD4vs87fH3Li2j+/kw0/19VyueM9iqHiQq1RuU6GGPHcbS2cpXFSRHDRnItroiZhmb7R+XRmKy8JzaKA3CXfyQCTcy3Xw2QUgtIZ4e/VQZTkcezVEF293GP1co/2ftR/1TCje3PEvO1CpqYDgsBpdRgl0mBI9W6YBIEdp5g9DaSO3fsaMz51n82MzR+j/USMrD9+86fkP4+B2xS6lh/DxfJFH5/LwlBpSZ7ToRM9bZgvXUi3Hy+XHax6KSH27cZJXkw/yM9Q+RxAokrPa5/liuQtJ6w/gvOQa3D9WCnMthkjlZ6IW680XZufye0aDz9M4CmEAWhoafZLqXFxU1j5TOgxKwuzqFllG+Febo7UULlZfncOr/71JGhN+60NXvzDDeph1qKt5yaPKrgbA+vkMwRvlR6UGlQlj1QTDALiYsKHyy+fWBgL/amGi5XMeIwAZ2hELhSVIim4lFmYZ3ydEYBUI4gCmcoDOy19oMbCKSTLNvOZbqpEQkj6LsmF0DjMN+LCfFsIsGo9v/fzxuIFz4yfnIc2jtGhOJNBVswotvdpv0tx1lVKPD8ruEqENxha85PLk98lirX7EoWAT3PBum99Lv959VaiAw+7aOzwfkqbf+68c87kDhwQDXWO40xfrti+wGaqc5wbM3+3RrOigyYU5ZzMn/0B1cMe1V0Q2L08M4fy0j3n1lN3eo1YtIxPaIuVL85LTmNmsDtWcindlzW0Ji+GFu9vMo5b1po7eVdcp5n4VGrkCOvPvB5k8hC0O7KQa1G7L51Tat/8FtuPHS784zd/ClrVm009zVpQEgogzj4QqRuM17LQHp+zlpRkbNX9jOZhQvcihAp3B4O8GDi3rjF+cIXDx7Lh1/sJNTU6Zoguh3NB5R2odwPq+2P0oggP7vYS0mQqJzf8Ywx/+L4P+iHpCzm7EdhwYKlZPgVT9Qs8rURo1IYizbX87FF1rWZQlTZozaCqa7iuCxlY1XLzDt4iqgrjM+FmzF2F6jChuQ0eNsNnlC/ox1ggehxTqN+5NKWbGaf5ZK5CligLj2ZeEcK5vHPw60YKul402H3UoL+Wc49h73742ozqgyP+27//38eb8QL/x3/vP4v1S+DDv7VH/UASJ9EIYLhZoz5IBlB9z2SMOT6rEyVjVE6yEqdQKJnPZMfS5YUgER8+WzgFSWjEz0kZHV3sjLfr6iqF9Ota5logSDuTRea6TpA5CsXmjSKobSdhpKfXycJIVAFVJYYFBQtLhk3bAE0TxSOpWJ9n7vDcXSdOQF1LySVjSChaQyOf4zQ0i2j5aYqIUSlsZrKg3Hol99g0aZgAkLkeBDkXYc7MwaFTwsxNtA00Y5rzknpnR9MHdq1Qzseka0LCo2ma+FzcVPeHWF7Iys2YcJgkO4QyWaHItavruPkz25BcJRN2FEHGJqLYYWNyFHlkSCmgRvx5/GADVA7jpkJ99PCVZNg+fGWtx7A6Qn0QTmh9J9IsipBZdOl4FLHLUEYIQJjrYTOkAzDN4tzNUfR3ERK0mYK7/cmkBr/fp2tMa7i3PLdFUJkhaw26j0LYsKmFPtHUmK8uRI5mmqPuIuLm745DNKKbRgynqpJkgTCXWAkDQRZBeWFEybmGBFkXnUsl/m1ePi2nrNh+rKR0k2saCcFSADc3Siop0eTHSfaQaVJqifY9EVA7xvshSn5QQiPsC37dihhrKLPmm0oRUcxANUxSFukwaCYn12caYe4YxEaHkBk4z/CrTkShGUKkHdEP8JdbEVINa0EepraNVRPeEzb8bQwX5kri9qr05indECYMDazkNCElvnk4EdqyjVY4x0wYXNOq1oxCohFTXlTae0VoNEU2K2eRfJ1e0AkDK/1yGmI7i0S9R+FdvuLTn7nmTvJZhpzZU2chFPVoC8/AxZYk8Dn0X/N6SchVXhMXTy4EdRUXJJv0IDcTrl3FkBbfcV68M30IOU0IMY8BAaWBZdvqtZzvL/zol+W7Pyfv+fUvLMfdeB287ytyGCDqzU3kf2nWSy7M6L3oSE2TjiUlmp9DdbmBPyLrLUczXKEgMrPotJW8e44dhojfvIufhUVnkWFbGr95Ft45J40GR2bIlJpqweUGmkn2eKyBBSCiIecQCm6sOR/DtCj6SU2e089blcrTeC/GVUE7MPla36shrIYn+60Q9nB5KZmzGZnZGsFWEt/k2sg+Pw4h/DWJgQVg3BBBkGNYwspXDr52GK5qMbAALQ7sChmD0ejJwqKlMaV6Xo/fspJQcEhMivPTGFjmZxIRyDN6S5zc8Lfx4yfyHUoWlOgTDHMS0Qmct+quQCfIBTZXnRgnVaUh/EWihl3P8+ur8VgYJ5lun65LpTFFp4fr+heJ7oyTPLNNZtO+yLISj5Pu5eM2G/8l+jGNMgV4UpQraRzjRLwe8QyPQgdPtDNB2Ue2Ko2dA4hZZqa8g68roKkxXYlcPgUd+6uwie89msOM4arB6tVRSqC826fcoIBgAcIPAKKBxTZ3FerdiHr2GC7l+qwlpwRKcmjWq0jSrmvVaAGMcRW8BIsqJUruQIowzal3pZ/xGQovq5Rhlv+tRHjNleAtYZj9zmewivL+2C/Tu4O2kBtGTE+lb4frFnU/o3thDKw80/PtvZ5T7mFOx4MpxK1Na0XNKcoVyh14chqmSfRi2kY8OedQ9ZJxugp9ub2q0L2bcPuNFtvPgHc/I+f62U8kLPHn/s4fAgC8+/kJT/9OhVe/7wrP//Y9jh9vlKBLA59pxtPFClU/Shhk8uifSF+tX+zFoJwEheJzqoEVPD/nHPDqjXiFl1t5D5WDv9rCvXkn2i0sABu8LrTCg3PGq15IHHBjvbyAcjWAxGs+VVSW9+fqUDbmYgv37kEcH6Oh5Ted1jFUMjLPodpd5PBNgQsVddVy4jrJpfP+IMWdWWDaOc10S2rrDWPR0XCB2K1oLPstIIGqEcd+2B/kfledamGJsRM29vcgWImzMnvArsPTLCFkrgEsVdNLkfS5HzSJBS6eUxNbAkqg+mF1HZ5jThCVZMOnEWCMRtfJs+kYYgvevD8cZTO0qI01rOpa+sE5oUuME/zlRp/Rt5XM1X7A/meeAQDuv9yiOXhMK4fufsbbnwtJIHdA3Xt0dx6rNxmnddMC95B1YBiFgJ6rwgexaj8GDbJZUEvftYJIeC/1Bivh3uUhRX9/DzQN5rt7sKC2JDoY4vZs+L25IUf5Ey2F5eNPoqiNaJ659SqsAxP85Rbz82s5xc0a9f1Rk138qlP9PSCghE+u4O52ca/sB0n0Cfcz3VCHr0b7eieaWkMwTqpKsk/ts7sKgIleVIVIBtvsxUDhnkTyN8J4cw7eRz08AHB+DsWhI2/Zc52yUQqzt2moOezxbpY9QA2s0NdummWtP4Y1fvJw/YB6mKSW4dON8rSnVY3qMEjpohkxmc0Me981qjOGeQZWjei0hVC3ipmTK3sYhLpw7AV1cw6uDv2hSTDVwvH7ou3HQrKSWKW+5FoWC/UQwmAKL6m+k5tvdhP6qxrVIAYWEL0ncrJKhTP9qoVftdh/vMH+4w2q44wqZCOo0q5ZpFl+p74/RvgViIsOvX5FiXyof1QtCKcL/Sqj2p5wr6yBlZyggPadkGXIleMTEnzWNNSSW+TWM7fQbWZgWV4N+VbHj+SnGlhZajwAVO9Cxfn9IfWieK3BhCY48PsBiYSDvWfCyQWPUf+WeUDdO3nGm9+UiX39LY/hF3b4jc8+wHdfP0XbjZhfyfNW4RSvfq9MumlV4/ikxbit0RwmTJediucxRR1Gu615cbu4L3/sYWvLLSQJgrAtZi+LzGYdeUPsy5y/0bbyr44GqHqXV4EbYyd+KUWc3nsWvtKfwYByu4OWleLic7JNzMoxCSg0MJWrZELopxZ7q7hM/hGfL/PAXeWic0DCvRp7Ee1zTZPOrwwZi30dakCWvNdzkhg6lk0fqCBrePfMECT3LNy7a9oF90rFTC0XxhoBtp1DAJ1QAWhg0ggFDNqgEiKF9YF9RkOAAqOc702N4ePrWMbMtP4y9hfLX/VX4f03DtVB5nr15l5CQzTGMwPLGQRblOXHKBbLKEi+bp8pXK/v3K4ji4xbF/+uiOsJjhr5uN4boV72V9BtPFDaIvBXn5k6jwzJEkG5Mmh0uI/q4YjxssO0bjR7WZNwmOXJfuL8GccQgjbjviRHUNVG9d1YJdk+pf0WxIeT81ltvfZElIJhy2mS5Jo5hvX0GUy4W+vgAmlVijA+NFEitLlrMHdNrAgDxHqEwFLZfxf4suMsGYltkxhYAGIYlig519tMnwz4rXOzfiwjy9VVWNwymDErpeCbWuPSUxCE7G8Csa0Q2aj35E1ZXoMTlCC8rO33JNvj/quBmBks3rlximCxFAtrGPJYZyY5N5uocsywwI+fVVBqpRqFRZQqXxTOiDAWU/+ZgZiJK5ZqYvnDMRT5ZOrtaYCTcDgHsG7w/RA3TlNKRn4nZyeSH/V83JRX2UCwk0cF7k5nWfH910PwCPcNDu9WONx38Fdy3N1PhwlE3uV1jbl18BWw/6DDXFeYNiEcuZZ3tP9Axtf2u+9EzuJwXGinnc1SMkkHvq6Aw1EXKZdlBtnfXV3p5qnaL0BMLOB3d4dYhkRTvM9ko2VZXBgGYBfkN4KnR89cjXE+n0GqdfEJJHZnNy22TOvrvRIo9rtEiwMKmH4nI9sGJEh4KRmZvchPy7iPNEpKzk6ebURum+FxLDIV2ey9O3M8TH/ZaxkV+uR81kHi/XQm5F9lPDZWEsgQ0ViPNYTpLSJyRjSYkjq33wgE948qHG8cqtHj8vtyj8en8jyblyGTbC8cx2o/SObXvSG4cy0LxHTKX3jvhdcGaFjv3JzX8f6wA1wVeFg0wDOjTA/yaoyyZNWp8klJFh8PZ3LImf3h+GEoUL3plGPEmoT6LqhkbhJ62pc7DJcN+hv5bv88UDeCjI6/MxGFXNMw19dLbnouf8dVkcRusjrt7wj7uxWujlpkhXWPY5YGNWsKW+cp16UMfVrtDpqMxooZ1NPiHq6ipt6L4VRVJhM83HsppJ/RVfR9bNZxDVvnP2OCkmua88llZ9pvmfj+zWf/zWhccTHOLVw+UIAUp6dbeOdw+GiFqUsRCXiP9iFFpNafSihKyYBmAR++IvD1Z39IPIanvzrg+LTG+tWIuauwet2j2vHlBYvWZoVMUwyHTLOZlCS+G/2UjJelpEAbJjxDcLfE9tJCXiwnYom39jvpgfF+1NuaVTPHhhw03T8MFkvwdNsNfNtg/IAoSbwEC6LSo1TPYZyEIzCOsnjb8KmduHUdQgCGj0CZCJjJV4fQBNOVERdY1Y4pxNd9EDrc/dQ12ocRu487zDXw2T814o/80q/hr/z9nweOcvz6U/nu1Xc8hq3D9uWMw1OnG8PqzYhpLdcYLuK11q/kPtbffiV/IHrDjWkYT2+mawnH+VUrRv40RU+eiBB5EqwCb1XhQwYoBXK94Vup98dyJNOshG7H0iKZBIgSQ5sQkqEw55PruBCxvz9/E+9jJlqTol06Nx52SyPDjmerWm70qiKns4rlb4AYcqQchWkWedWQLbXXcl0fe7+WmG8MED+McePXzctw4jjPGK7NN3LrsPDd0djzQY2/HzR8paHO/Hmc6Dh51o4LfZUaWWYOcG3gODDP5FYrCdFw3hmUAoAYn5u1hOTX66QentYq5ebeVNh/Sf7/7qflHV5/Jzg+Ya2++2rcRJ/8hoyJ5q6XGoL7QdYKy73SLFDpL1W9bxtxLLoW7uYafr1StEgzRktJBRn/T0PEpp8s+pug/0QQk5A4CWdDlE4Ioe2YJRvmZECm+k8iN5JZci6UinPjLOhJU6s6PFFzDQFPHvNlh8MHa8AJP9k3DqsXO9WBwuev4rNbWRfEd6vPbTXzTmVsWlmWupKfXHPM3HJdm/ZP7iQkKHIAPMh5qqQfKM3j7DqRI5QMbVeVCtxSCLphUhKV8WGMJSJQ1Msy2pq6fyiiGPlurh8lvEnKhdIHsuQK0l7GEb/y+n+97Ev8dhDfMwFAlNKyp3SzrN/IZFm9XXpNqzepx1L3YWEzHRrPK5+RKzNcAC/+gHT261+Svx2fPaKkBCeoFW7LW65nRD7FmfBdcu780udkKM541MvTk6wY79kKOspnhXtQYzK8mzD5WA7DNi0XoyTHcM39MQrt8dol9ISGGccIvbZNgSA8mMUfiJtUQdBOOXXGy6UILTObnv6H8k7/xT/wN5eXupTnePhY+ufNL8jzPXxpCatyXK5+dJfcF5omGq4lonlouvAd3+8BK8pIaQ0udtvlu3GlUEiujF0iYvNeuckx+cPWMMyvRUN9XbiPzOtLWm6MnCJg22fgeTWEVJgvJeQw71culqUyRieQxyKinImKFsnAZ/SGWE+wurk6fbx+2Z3//URLapHCoBJndIJU1oHh5zPPoCT40ePmN8LcC8bV6rX078WLQtguqxcLgwycvC/2D8e+1ZhTPt1y/0g4tOa75YuEEF2ePFDqL67JOWJrTxfmtmYu28/2qWHAsCdr+yXPECIITYjkMOlo2rQYPwjj5+JicVx8rABq5IKspe+qI5wmQxXnONcfmxWuzvaY/izfmPzk+n9mvYQNywNwxwlNKBqtPKxzZb2U/hP2j9J3x2jUAlg+k2058n9OW+xE+60bWV172sCynJsTSNn2RY/VmxGr1wNWrzOiZNjMhwCXehYSZlVzpAYW2+7j9HGq4xC1tnQjCtYsJy+NIduJgeRYMrDsz+R48rMKPK0kKxAxFGLT00+V01EELBh1yXcfyyth2jzRo+DxaliXcO1x1AyhUwaWegFNvQwPmmfXLDg9Pp0gvq4iipWPFRpY5hiW7sgNrOlihekicPja9Nn/zp/9PQCAf/Ef/2u4/tUG3TtgHRxBltshokpD6/A0EHkf5oWBpQafNShyHpBFREtlOgBofUnn5DuVM4r7oQ/abBE2WbGJgcUwN98756JKDnTy/5yzBMQFjSHf2zv5zjTDHXq4q4ulgVVAE/lZdbHR8FVUFs/Gql0Psve+SJ/PEJyF0zDP8MOY8qVss4YW/59vBhp6NHOWGYHnsoNzAyikvtvsWS1XxA16u+SYuq6D1TVbcNtObZRtJ05hvikRuStwkPwkyKKGq1VB3WRmOifZpiZ8DADrzyI/5uZbMgfXn4eSKMbQWr3z2H/YxuxCljfje6ehtV4L16mTUkXVZo0qlwLQUjtVHHfG0PLDmIi3aqgxH082tJYbWMozSrPSiuOtbWLIfJO+S2totZ/v4A6jZg1q9qCG2eioVfBtpWWHbNOyXWacJYYWpTraJoawbd/ZeeaqQNWQ9VkNLDXKyeGLIUNXV1oOTW7I7DU5L87+JPrVtbJWk9PKeUGOXZcirHZv509ndM1KhhbJ8opiMdudAECOmAWifdJPdbY/6dfdEgl11RfLpuS5fivhwm9+6V+JJ7DcACDGaW38lhtr6ODpCUu1SAaLm2b0zzfoXu01TZgTt35pPGx2enjxL//IlwEAb38+XPoi3ubP/rsxlls9iD6WO/ba2airqG5dyLzJ9XsWWUjFXsrCfdbgyeUdzmlohZagVKeyn/wsRWIL13S6IKwjSpcf/8ETAClRkyWJSIJlxpEbQogwaMEAEcJX+Yb1WsJQ11eyWG9WugBFQVFzj0O2CNuwFsO6LPOxX6ISopQsumvVOGu676tfljFy+4vxnW6/J9cfbuRaVdhDRkZSdw6f/Adyr92t/Gy0dM6kRpQ7Sm1C1awZC6gS+Qb0jvNN1LTIf6gVUvfjFN5t+CwrvK19BGM0cwEpeVsGjmdmpD8cYkixrnWMOML8llunxNnMS6ZnTkVs8x0tAUUdJ4YCbBag4XIlRpYNdeb9ZP/GMWXHUY5q0aigpx+0p7ylCWSJAaW2RD4oKWGyFsklMrpXNCT8/b04JBnBXQtDA1q7MBbjzhIBShGDoE0Xs3qDLlkbKzckNSd5Lb5njlVbkgRx3gNIyk4NT9ZoX+8wXazQvN1p+ZTdT8lz1Ec5X3vbq+o3DQ3VSMpU7a3xHY3ScH/DAH/s43sz4dRFhndtSo9lSGpRYoPPx8xbhnPbJtVlBKLjQie8aWJojBlsgVCdlGgLfFOGyWxJnfFJWkmDJWMOH2+kvMzsUR9nVMOEatejuttH9NmGsvRi2frOZrlWGfJpw+ia7dq1mJ5conpI3xuA6FznlQKyiIV1DNX4Ipl/mCTBYQx7iQVmrCFEm+GZ9C/r2DLUamEi1jSsOI5pizS17CHWOVXpiPBcHF/m+XIAxhrdf+GH/zNk7ScbLnRNE4sx1pX8cy4lwuXGm6bEBit1IP8qXRBXL6WDjs9WqO4Pgh4MIzAI98cPA/ydZKs8/xufYW6A698M9xVOtXkhj0Wy3MLw04uJGJwL6JXAoUIKJdlNJ2aeHZR7su9TZyca1TTR4MnRrwwJ81nMfaHy/B5P20/TclGmNV454Ol1nKDhWgsD62INeJ8mIbAZYUMZE2FxpG4TkbNVC7/u1Lhi4oEuRJxohKNL2YWl0jSAcrKad/J5sxvgZo8P/pb8fvFd+fyjvxF4Wa88rr4FNPcOVR8mWjZU2zu5fmJgmZ8q0MjF8hSEzExbA7NHRXNy5cL7OZEJphP/QIHQsGmSOLvugKsL2TzrWpAsLnI0QJhUYLx0uVYWWpmDJMP+INezHCe5eTHSbNkSvkuWreE1QxZejhDYwr9JhlepzT71KLNz2JBiIt+QN1NuJ9ZKTMc9E0XUYVlkBtOACaK/TZPOv8ph3u0iitL38T1w/l5eps+RN5NIoc89TVAxUSAR3LTHWAMreT7t7yreFxDLj3Bzv98tkGTdWIdRNqOwQbavBeUm2l0xGem7wUDMo577GKnwG0ni0HBlltVFGQVrYAEw2n4p57Go6B94XdrCO57z0HFIEFpk3tpEDyYQAeXw6zQL6vdwED6QcgIzbuahl3VtnlHdPShZu3m71+efV3VSAzJvDDEqApmH41WbsIn7su7PJsISxFA1WaTUgoM1X5DCkEYd1LFzLuoi0lAK+zUAQbO8F95oXjnD8nGB5RrBRKzLtVRr8R7zupHErApAJaHUaROEqtcNqrsHuYc8gzXfPzJqjTarh2dDosGR8bbM3yPbby1cWBLmyie1zb7JCmbW90tEYvUj2dCGJ2Hz4OAsba52sAAYLhw2L4JHvZH7ePl7T5d+ISfIZwT9UueV4tuL0N7ZrKQTBtL7WhZqPBciPOV9lzw3Df+ERW56ssVEPpbWLjtTfoItQ2yKwqYWYvY+Mah1AS9lqPAQygy8DSjJuUyjYEhU+wHtmz3GTY0nvy7j7ubvyWT+8P+95ExUx9Cv4Tb6a7nn5vO7xXcTAwGItbKcWy7ApTmiBlRYXK5l0/UFzpWS6q3hcOzh20aN1fHLz5bXYKPnGNCIIg+OTcemC1lXsxpPOv5LwpUq5hnmNw2tM4hBQiw+UR+tNMZzLswCTSpdg/cZsta8kSw4lym0mLvB8Cqi/gzrmQLRXIhVa+dctqdmZL9HPgMRjfL7g1yvriO6wmeeC/MpD8tmiSXJNbI6dO4g5HVUla4LKtJbeE+rV2JwMVzophOGL+IapMhVyGCrLraRxP+IDe1RfZgLOjNk7+eI+JfKW3GukiP2CE5Ovme5h3100MKYcLf3y1sMobX9l2TOvvtaFlKz52xPfMbQ4InjTrUiT3LxJZ/+5Fh/T9PscPLTDst1eNHoZDZ1/L7qcBX4f022lih3trCW8H4YyVJn30Sy6IyV5u4XFCb9rXOy2GwslZa01TKyYYImCJC1tWpouCmiJDSwdh9HCxZAtMbNtVxIZ/3wr4no5LgFposZaGc8/FyP7s7j7e+6EMhyLVa279qoVcKXSDSCixVhYBt/tzFZ470miuyWj5QbRHPmIVEB+lRB53gBOcc0JRwu/t01sfzEQpHeEvYaKQmh/IPgCU0hRDh3wbB4u5PQHsvbdCLGCe8ltJqpNuumo1mOEsv34R+ABaqCPmRy2HT7dadlc0BBRm7glNiw9cHMPzdMUSU4pPdyExi3FZqQ9by6k+88/0/26O49bn5jxs1vyPUvvy3va/VWvlsRtbMQdt6I2Fg9sxMIhZ/nuHlxboSNhRlc+t2A1uqzAonQq7bwt/lqK/+eX6v0gp7LGE8AjGdbRzQzC5fZ0IMqS/M9872Y7DDNhAxK8jarT/61yT8AZZJ8aGfTpOlwEL63iQddG58L0BBh0TDSewz3xfI7xftJnSTVpVqt4pqRiQIDZnG2yvgnNr2T4yboFc2HI+awOSdEfhVVTnl42tcJN5ZOcLhHY2i5YUyRxRKfNuen0ngKqEV16BXR6t4Fjif5WDaUG0JImq0cQqXVk5slCZ8G7OEQ/h1j+SYaLXktTb6frlUk1Y4plW5ga1MDzW3W8q9toyGz2NfCmnvsRdj5EP7NXvqycosIAb8PQEPC7u2d/Jtixh1Fuo83co3bnwmZnsGImJ5fxXAjnbsp7CX9sJzH+bjj/sbPYOaIkfvx27WGeueLte7fCOFEF7ikpeb7XhBTg2gpYkqe3zSLo20jYERtiUTNsxqsGoYl74rrfigeDRjuWxY1AyD7UV2JYTUL5xTjJCg3s+11Lw3rXr6nNvVSa+4R7QsbWX/ip/87C5IYgKUw2SMs/ukiQsDztsPcVrj/SlDXflkODwEGjQmT+pO/egsAuPzW8pp335BJ7LeG09I2GipMWrtjMwABAABJREFU7rmkQcUFPSuBUi6Fkmb6+XGAH1L5B/5+ruUetG05pF0i4atHVuJvhA2OBqwaWIWyOUoStOvrqRTXEleNY4L3U/KcWeeKE9YOYiUrh59nCtoqmTS8y+5W+nnzasb19+S6XPyvvhPH1uqN/Nx+JtdvDmGCncuA4eLEMFxTF4jGZ6YWDbTtGcQnO17T140HzJB7sTGkFvhwKgZYanNqzCE3EE41csLIX9xRc+40EqqGVidaW86kmWvKeGmc5F40+WOlRc+KutpzjGPslzOoR17GSjMMC4ixVeNniDTffB7De31M6SG9r+Mxrkcadg4bbyGkpefOy68UUGQ1+CyixfvnuA1OTFWIMpCg3IRMOxURTYjYwXiioWVI5O75U/lPcATPzXm+HzVAhyUSkWtgyf+N0wwssnltc1nYT3WuSghO6V4VEUmz8XxBl6y9D8bpGEKJgdv2+pc2Wp6I6/X85Gp5rco4U8B5xCXfpysXn5Xk9Dy8Z47T+rScs+eyC0tcKJUdOaM1SCeiTw2sktXCWofe0hOaWsAVPteZqEmUcAnvNUfEbJsmsYMe2b54PuI8xw1NibbC9HfjJFa/0ahQxKKW0jp+vYJvax0selqKllVAc/Axrs+HnSYZPP0gonOB98Mae1/663v86B/bYPOdDvsvjXj1+xw++o+yDuLkdk7QNJLw+BIN4VhRFXt4JtQmhN50AVWPt2lTdMo+h0HEFiV1NAtrBiD6V9V6Jd7FMC51s/ws1zR6RH6aJHWc+lTOJeVr5qtN0ufkM8kf/TLTYpb+UI93GGPx2raTe6XKv/cyLvJzcEEmgZxGDLkWwyiT4NhH3a3wPPChZMl6Db87mGrwQhSfL7PQcFgINi973H9lheoY+7jqJ8xdjYsf9bj/cofV7YyK/MgDeYJmUwnaUzEMPqfPVlUAQtgwlCZR4vYcwlOjcCD8PGtoREviaDrxDD8MOraUy+V9HEdDL4vi23eAq1BPc6w7yH71JtuGCMudlOKgB13ystXQGseAgphizN4nYXM/jpHjZMMgdS3II0ufAPDcS7Q2XJ2S7YO6ty2EnBfGTlTRWXqFhWy7TrS+gkcKFyo1GM6Iqso7p+VbRC+ujppiMBuFpZYag8vVNebdThCsfohzOFyP2nRANCaRoYmuYLz7vk8RBvPMnt49x0IlRHp/PKK6CcjlRki9br0ShJMI5DwL0ljXsYQT15Vh0HCdb2ph7Ya5LU5D4J5klRlyoWJH7soUNrO6RnUM60RTicahKS2jThTRgiyM7YYR/mIja42VcxhHnfeauNEPqLoWcz8kzqddl72fkrVRmy0Vw9+BiGYMg6x5WgNTSj+5qpIC66yB6Cp4ahO2bTFUd0q2hfOoefEOvq4wfPkG7f2I45MW3d2Mtz8b+/r1777A9uWE1asjppsQXp1vJKGL5xsGQTP9nBpadS39R12vdSfIGeebN4kpVdwT/XYl0aYx8M4OqSOgXGbzPOgHzXa0hpdyTLs2NbjzPjn2sjfMXo6pzf1sujgPAMzrFr5ykd9NJ9Gsgfn1fNfGWru6jjByYN6TTRQaR7iVFMVWjt0XECv/wkhWyWLV0gcME5W8S76Y4HVUvWxA00WHMZQwefhEBtW4LvB7KBzK0EA4X/35Wy2BMgXgZhNEJ1/8oxXWr0f0H17IZmZkA0qdtKinVYsxpNC7/W6Ji8SNY5HZsUSb8tCinHQW9Ct4zrmnZjkDC96KkQ6olIScxe29lwVs8hhvNoBz0cDKUu6TZkvajPLeYjHXMMCZIaVk5mAkOGcI7uGYEhKaeVFUsfb9sPBmI9clhAnv92oIKl8kyDlcfBoRHCZC8OflD3vUA+BmoLubUA0e2x+E7DDdXDLPHkgNLoSJzLGT6ZDFtG2p2YZjHz34LOU4QSHUsDLe+TTLIsQxROeApXssT45QPYVTD6eRYTYlWw+jGoWLBZFGvg8lXIyA32My9JLacEG6IF9TFkWiC+nUmtXa9xEV4JzKM/JK5HnzWd5isWkzV10lgr8MEebhfRLizXOqYvQZvSo9zzhK1hjFYWH60aWGmu97uM1ajDMaHuT12ZJZRBSz94MpGNDDuOSlFsjIHK85EuA3q/jONboQruk9MM6Seci1IDOwit2haFkDHHtZe/PyZuFaLF9Uda2EBcO/5LuFiIMS4M+FprNEiVguak4MLPs8JXQqIepXLkqphOQGIPZd+0OJyKzeDnAz8PTXRzz9Nbk+FfVZcg7Aktytgs9VDHeqzlc0sOw1ASySbjB7qRe579UJVAMrT56pxXl3VRXBlTPoFAENz+xN74Ui4X1E0tXhi+uZv9jIvTgH3zUqJVTSJothbx9/r+vAK0yLkSfyQ+G55N+yMktCFTqH3GXtCxlZ3/zSv5KEcHwvXqGSmB9DCAsTY7po4ZtgFYa+uPg0EJV/UzqifhM87yFY4ZYLwmYMui//VcZkw4/O49t/skVz12O6XKUaGax9xBjxkBoNJxsHGT1T+8zcONjyOlI27Ti/jk29zYy0ojDjCR5XdSZE6C82QEgbdrNHc2tqQ2UhGm88GjiXlCJKmm56AbJnCC3UiXR3u+WkUYOkYMDwPoYx8ivYx8yk4qJvlODdYQAmr6TIepc+T/c2GltuH0MZ65cDuncT3CTaNONlpiBMA+gYVKvrKoZQSqTKPFvKbJQ+FLZdJHPkAqFZwgiAFJ5nCDqrG6hSGVy8DkejFRQ38+S+gNTA5r/jURbO/DnyjRuIHnBJkT9LHEnK79DbzXhUbLrIKYesSgwFvw88HZLOiUjlwpS8tzqiufrZGWK11aVzgd8TnYtwPDeNvk/J1F0bnQF7TobGcv6HkctYlM7JHbOug98f5FzWCF91acjKFP+1zyr1AQeRl2AofpWN2yQ7L4SqLldwwwTvHMbrtRC6lYwcrmv1j6qQeVinxgisIcT3sUmv746SnalyBbblIbvAEbIbo10HY5mc8BkzF3NnmFxZ3r/tB5vVmYcVKydOlHMm1G5QTiDuXZp9WEeEtRB23fwwpW84D7z9uQbt3ah6gEo3YLahir2adbHJjGbbNCSWhg79ynCYc+Oba7Wdq6U5xL2Q45N8NIIc5GPR2BxHE8bOMmaBRSjWNxVQORw/XGMIZYi0QgGzv62Q9Twn49VmVOs7P0HxcEQ9xzGuf/2QSFmda19IJ+ubH/63jFclD+m6blFGJyFIc1CFATA9lTDfdB28+dFrrUHyctrdiPbTd4D3MgCrSvkeej56lDcxNr3/hsTzP/0npJOHK4/mweHr/9d7OC+bayxhEDd2HeQMcWQZVaXFciGcyarvwxjDD+f61kw2IHinTSuhPg01cDGZklCEfJYOFhpi1dMn8TtmMfNdCzS1GJutQPquH2Mmod0gM36dLqDHJW9EN/iAZPkmbIZtA/fuQZ8NQOR72EnJe7RVzx8eUsIoN2hbYyqb/JrIEMosjNdMmohGcPsycIYC4jU8XcN5j2lVw40zqsmjeRuQ1rudHqd6WBeZwjvvgXovpo90c7DaZVniARcBZ66liJPlRVUuNbI0FBL7SBWbGQLimC7xo0pSIE2TOjC6OId3ZRe5nL/ANmUop2nKITLhuxgeDO/uDAIWr23GxRBCmxynJhQXEbOMY8FmNyAeF/qKtfRsGRF1qogI9HGN03p2NhM4bPzV1aWggtR641gyxoOeK9MXK/WHXRvc1aWESq+2QiTOs6Us/9MW+oVBPeiAdW0sY5UnrVCzDhAEHFG+Qee4CfvNNyaZowohw6oS5Gzdwk1eBaeZoejsWGYZtHf3SV9FUefC2tA0iWHkXOTGLUo4Ia5XOj+SaEMISeUcNvs+8s9yw9i0JJGlYMQm2lVmDJM3e/iSJATc/ZR89uw/kb6vdyKPUN0ZQ5T32A/w15dw97uoh5ZTOB7McVxTTA1ZT6ONyRGcUwVEUvmY2bzTNfvCjAl73LGPxHOjN7coRo04xji+Dh/RYZESRO3rnepvLRw+76NDwbmX1dhNWi4RQooD6T7hO7/y+f+SR5xEmL5wuDCGnhjOOENGtjcfdH7q1+9Q9aNueP0TCrXFiUMIkBClLkIl/SQWzQwvvu5nfPXfP+L4lQHztXz/e39MDDG/KiAPRGDo/VpPX3kUuUaLIVFmRbHPZkdZRMvW3LLeayl9nRywrDJ4gqJlIQVNgd2udYGfLzhpwsJUkmrgBCJHaprFgJmm8+UM2OipcDMpGag5msJ3cDjGBdXqDWVNYWX2tffKF3NHOXdNbZ4SMBkWeNbCqkIJJ18IlSpK670sWNuVeFHTfFp/zbacc+dc9Ioznoo+Vz8sjmMrEW7VAOCCNE4yHm39zXMGTJamnigcs+Xj2ihHx++8f3wk8ysLiy00tWzL/5aJbBbvw4YIbVYqUAwjsS0QJCvLQIeB91qQdomLcGasFFpCeJ/nSJ5HeS3QaxF1CBuPbiCH48IBW17ULwpon9KhAyJi0n98iXldoxpn0S7aHXTsqiNmG51EWyUCiEKS9hrkxzJR49jHslzBKcnX2tK14jvPDCzEd1aUajhHwM6bnRdcy2cxoPKi3Elb6B6a72TIqCK/Zl+8+JH8bfdlSu4s+V/6ON/4WH5+/SOMH1zCr9tYrLpZ7mOLW30a5GXW6TgDDGJEKSQK6O6NTtjieQoLMUEMe/9EgylXkq/1ptVHOWd/RUMofGDfL+c7HSEaWMcjhJ4zxr3mHCiiHLcCv+897dFG1jc//peXf2SH7g/Q1MsQXnrMYCWCxdbej1h/HjgxVAbmomwIiErkM8R7AFrv0LbVL78FAHz3jwei/CYSwc8aWGzqseSbjCFF5os6Ci8sDxmWWsnzUsQmNeJ0Y6UQHIDq2dPwXWavRcic1j9DswuDgim6wFk9qlxM0rWt8FSGMS74mvhgwqXTJAtQrjuWiyua589DTX5/WHjkpQVGs5/IJxhm1LsR87YzVeHlpxr09BmerVG/vZe0amNgnWzc3Jgl14iYIjJSKIA0/Me+zrKOkpaHe3gs+VCG12ENrLxZjo8PCRTyh3m5eNDQshm3irpyvp3Jl6myDYhCoSbtvrQ2JKE9/uQxiyxgg+rBzF+SuxE96GI9Ovs+6Rw5J4kVeVLAmcLsuoAH7qb8P0U0Zmq9DaPMizBO3KqLhk7RqFwaWqJIPkcjMOis6Tu3RtkpOkKChqfcPvL43CFUxhgnnUv9x5fLe2QzhpZfryRkr3SDLIU/zElf14pikUyvoanChlo0tMIavAjRl0jJHDPcgFlqqTHJS1M2FysHCm37w1HK+ORrU6FZQ8uPAfnIQ7bsn9K7D4ZFdSvGy+b7d1rHcP1GzqOGluXbhvJjw1eeyWN8cPqdJYZWkEugxFJuYLGurb+5xPSJ7DG5oZXMkzzz3Rpa5OZlXLei0ZIZWq4fgK5FtR8w3ATDP+ga7j4h14wUgyqOOa53Z8jq1tDyPjhVDHfmIUbTinZR1h4dLvzmx/+yTNTc6OFDMZPN3LALHqQ/SvaMW3XK1eFLOnwsP9u7Ab6u0H72Tjplf9CHU6KhLbVBfZPLWN/QX27gncPwdI25q/DqTwvcPP9NGRhf/Yu3+kBJuQDeo58jpGshaXp7dSUblKkUnmdZWd7IQmej6zQjyh+OMbzYtcsK6rAImjHehlGOMxsKABHwAxZEWN8KD2VeN7qINW93USeHi4ZRY/csg8LsOu9jDB1I0pJp4Gk4RD0G6lrNS4TDZkaGyvYUr9VNznqEXCA749nWtdyfRYPGSSf99DwsFKbvqpCFcny2wur1EdX9AfOFIFPDZYtq9GjugmDuq7twj14WvaaBX3eYn17qxqEieXQwED3xmMkXkQlRYq5jlhQ3eKKxsIa+cHsiZ6fXUNsC4WB4pBODV0q3CGyeaFyZ79v+lL+F9x9CF7pR6OYQPl+tInpkPktg/2DM2aYOiZ0ngIypEyhV8v1wDMPxpULAuoHWdRyXJnyRlKqpqhhizUOA0xS981B6R41ZI4LqH8J3bPkVksrnGe7yIhLlbRYtzJoG462H+9T5zXMzWxUGMW9DhYW2jdl74Xt67jOGO+paVetd2yZzWZ20EB73bY0plKtiqnz75oDq3S7M2wno2iiS++G1fHddw40e/ZMW68/28E2Faj8uMhQBiDZdQG0YqndEiwM5ms3ReAE0JOo2m/g35dg4QeJN5qqeg0ZwCHO5wPvTsjJmk9b1PFtz5biAYpHIHfo1GaMWbeUaYMOGwWG1SKt8NxihN4GKUde4/9lLzI1Dez9j86MdMHlU9/uIGq6jUzFdytgbLxq40aO96yWKMc5wk4TmFMHMrnX8aKvrZb2PYeTqOAr3dZrECKSTGeYCszA10znMRdd1cW+yPLvcnuiHaGSzn7jHXsm9DR/L+OpvWtUTu/iRjI/29UE0tPro0CuVg1Izx17meN/LmmJkiBJCP6DPAGRrWBc1Kn/ls/85gJ9EuJCeEC80jrLI9kNxMtNCTxYQQBeZ6t0O87pBd9ujvQsd9Nk7OcbWPuILs021q0QugpObRkT7Rjrz+f/iEr/04Wf45X/276PZAT/6IzcqggoYtMymftqfQAjlmWKhWciQlm8J6ZJ77PQffwdgMo+i7pYjudeKKub121rz7KFVT24kK+nqQhTBrYFlnsedMKh9kHfQwcgFyWYVhvP4w1GSHixiwmfNDSy2MKFTWYbMI9RwqRiuObfBbcSwWhS1ZaPRuD/CTTOaF+/gJq8LBeUMjs+k36v7UNvyQcYANWrGqxWqu0Oa+svxxvB114ihlb+bcRKDY7+XhSJHbAzHTw2s3SHy8jKSujWwbF95yqLYGni5UUEdqSyUqShYSE3OmxoiWnMxkpatkruj06Sk4vxnxjkBlgYW26kUd1O+B4jGzCnH0Nu0f0D7YJEZzPdw7OU5R+EcuYvt4p0l/Mo61sUDIIV6XRS+BMz8JkeRG+yxl0zPIOjq7Dpqr5fN7xhCDTpGlCgAIko3xk0CwIJcry0LV+kcJBeVUQg6WhnZeO5qwMf1VfuKSNY0Y/rgCs57zOuAgD2h+LPcy7zJsv8sslY7VDuRnNC/c+3KkyKaGm7VxVJFtlUmwUERE9MXHPt+RrVZR/SxkKwiP82x06TitbGU0RJw0PP1w/I96PNmEZCc/hH6oLp9iKhfSBYbLmkMpOhd9W4ne+uqgRsmjBdyb+0dNfAikggE57hyCyeRbW4rDNexJBqLWcdalrXwSCnNYp8rNF2TmCUfkpn8bq/Z4363X+qM2dDjeqWIVH3I5swM7D5q0b4OwIlmDIYx0NQqYaKCsAUaCmDX4Ax5n2c5RsfG402nL8zJStIseSNZodpiqNAsbACAfkDz/Veo745obqVzqECuBE6TebPgomTicABUcbgKA2VaO/zwf/xz+Cef/ir+9J/+v+Di0wnvftf1+x/SwoKUZMjSw/PsQqnhZLKhYBbcRAgv41MZLpYuvCV5iLwxU+b6SgbAdi2LxyaGxHSQBQ5Edd+jvisLRTozwLW2IBdtvjPnpGalVb5VOYKC12wza4Zs3LCdCSEthCOtjlCeaq6k4QH+YSde19vgXTGPoVAXTCUfiPLdHlXhOL+GvzkTMuE41OSAAoLHd71ewfVDgg6q4fCIyZvIEeQhjvdlxyI1gBbZctaD43m9WXiAqMxdapmQZ1J/7wwHJIraptdCZYjy2X0Uw45KAQjo8zlR2XnG/O4O/mIDXzlBPZ9ch+POlGjhOzoavl6+YfL6RPePx8S4sz8f0+x64Qto2OL7Jp0fQNHBSd5x+ExLJHE+h7VAa+zZlm+mmxXqdwfMq1rXDvJmhutlfzKcz59ACE3VVeT7rDNny74XGnfB0HKr5TUWch4BHYmh5jOcYmCxqUqixZz8LeeBqSMIxIw95XzN8ZjcubBjn9mIxx6YPeqXEoW5+P4ZkW46uV2L+naP6jhi9VlQlycPl/PSqqHnVVDC8xyfthgu5W/DlXynDqrqdQhl+ocd4Jzs0TlIUeIUDsbBMe8meU8FsMNTpobrvElo8pyOSoRPnX7XD2IMGgTNCuCebNmcTiIIOofev94+3sjqB5OunGbTANBSKf5wUATK9wzBBWOJ2jYMj6jGikN9fxQDgBub4WCp16BZHmm2iJu9TGrn1MDafOs1AGD/TDrmw+YO/93/0f8B61cj+udbWUSaWuLQNBpyCQYgesNNk9avomdpQgmKMJimRhhLd5hQhhpsRnsoSVe3BaP599VKMyurZ0+kGz4MPwNB1bc15k0rJMdWYNv67hiRrCxUqJDx/gDsD0nNQV1srVdR1+JZMGtFeQ7L0juRQ5V6ebqIeK8/WYCT5URCByan43f0vkwpCX84KE/J3T3Ab7qFZ3Z80uD4JGTzhHOzgG1zGzILTUKAbxv5t+5E48pBhHLN8RbpS39KqCkx0p2TPkoybI7x+4VmZSwSQ56hDfYL+/54jCKUiohmxn2eIcqF/RiQyhAmzlEPfdfbDbDdwG3kH9ou8rms3s40B45DZhCx/6zHmBF5k3IoXspK+XNGOVsmN1HST9Iacps18PYd/MVaiqEDQJhXi2bDORl/M6EL1HVEFochIedzDSRXi5uvvmMr4WJDWPmz0ZgN6ywTXPy6i4ZJlxlapfqpTLIY+mUmKt9DoFasvvsaq+++hrvfw93vxTC18yN8vwoyKhSJnLqAvly1GK5aVMOkpauoWafjwTkN4VM0mdqIjmLH1ErkcfZeWVKI72qKxbYT54L9zlJEGtYN66udO4YaY8uv6DsCInJMA2vVmSLcJ3h+dDq4Fs5lIjZRF4ZRNy8GbF4Mkh3eC9fP9YPMn8MR7t093DBq1uH6e2Kg1S8lUlTtDnCHHn7VwBOZyrTQmrsBm08PqI8z5tZh/em91Bx2DtXdThySzFAClk6bvg/KqDDy07VAbUL2jOyQe9c0IYxt9oJwb1MIN1ejx+bVhHbvVR2fFo079tCMQs1qZ3StkFEPgPI13nuJPjHUmUdNrOTOI2o3fmEki22hRVP8jtngMo9bU9U/e7k8MCfvljSkcjJu8n25p8tffQMA+Lf+vf8CAODf/PU/fvJei9dje0SJIMBsgI9Rg21TREybPfaMlayK98HAGlmHcFvw5vpokBCVchYWBcpkd76/vNyK3fxyArdtGX8uMbCyVsxCXHh6pzdW9VL0HmtUr8KiEuBlXdBNI6+KmmE0RP2Z+nrphX359xIKqarSMTFERXbzGoCFpuOLKEVJl4pcsOQ4E/KCMQgKmcGlkjbxs+BcncugZVOjfI7P+ggCat5KYqHFe1Oybbi3c6h6RnR267WOlf5rIXmkpDfHxuc5x2ctfUbnVN91JjNhmyJQBaI6v3JuXeJGoJmjmcAqUJ7zeTYsjZEz2Ye2ETV3oTRM9yZwHA+F9xD6iNU/+psO/U0Qlg6Z0DiDRCYF6M35klYqVp7XnMy4aEnL6iiWbySlFdi2oJnwEMMRLM7jXDMv/GTZomKz5yF5Phha1VvhJ1NyI7lHOtsMTwbHdLhu9T0q9aTUaFCVwp7nWm6gnEusCf2v1T0cUNOYz4GR0vpkSlIBkYtnnb9za42uvbnj8oj26G/6vjdk09TjpLXph/DPqnRbdEjj7AHZChtM9eINqhdvYlkSIAkX6HkAaJFbwGhYhJIO9vhwjywg/d//j/7LAIBv/8kW3/6TbfScbAHLQASV62acKIo08vq2DIZmBaYkXTmtQTX8nPRHvumdfMlBj8y1LXB1If8AzEFzjIr5JJS6UUohJJ635ZJkBpaGeVlMmroowNJ44oYdPNiksU+taCw3FCvEiohIJUVEbRFlU9bAXlf5cQE18w+7WEQ6GBjz25jgoDo8wXPu7id09xPmVYs5aMLQUyeCRWFEv11J+noolu23K7hhRrXLhPGsSjX70fRnMmZtBioNLC6oJGbSe7PZdUSi6HkXofgojKn8gVOIDyUQwnfnhz3mILsxv3sHDH0sxgvEMUttHaUKCMfIivotwnv2eKO0zBDDwljJ58G557CivNk8zHkXlhup3zVG6fBMFvCHX3gu37/Yyj9FmQx6STQ6cK9cXaPS//Ndi1PIQsIAVIOLoT7tDyYLmOdJspczjTn1+MM96ny0he3zMHsp3MF1zTqwRE1phHAtD9EMN4zyWVUJWpOtA0SG6dRc/brMx+62l5qik1eSO9cuciUB4PBBkJyhw8h1LEQekqZhdjNmQtkkXcM36/QfInISEzrMuKAeUs7PW3Xp94DUmbBtmk1oMNsLrJOpoqWB52rXzgy1JSrfvjmgfXPAeL2WLM3tWgnrWK+UYL7gWTFUF9bM6vZBMxhz57u53WP1QsZo9zp8dhjk3zgJQmTmA4uUa1Yvozv9AFR1up4RaUecf9PrN+HeQhiSa2BBRmbuKk1oagKXtg4l0WYS/y0SeaIl+7VFGecYidN9iucEEqP6XJ1Wti+GZHFBBeKkP6OTtSiuyU42oceiN5Zv3gUSuFae5+/WK8u8r5/5d8VL7eoCh4MpqCqVYMIeWgz6zMsqFBU9yz3J7tHnXrE9NudTmIWEk2oMqazTNtzrsYDWsLBmyGDxVTAuZx8RpJKBl/+NIRDjXS7CibYpxywzrktaTzkKWNcRsclDA6WWLXLzq9fAPKP+0Ssd5f3TAsrH0GlWQDnx3LiQkDRqPtO+4BjRuorn0U/lDh2PYmwM0fg41XIttsQoPzMPc3RKw9sl+YtwfTUGwjixnyUihvnxBkn0cwjxjaMURj/z/heaPzaE/oimGlU5YlDoT83uDOHQ+c1b+JtLdC8eVFZm/tpHpy8WrqVG1XYTRRd1zVuuGbFIPOd+9szJl8MGaeUJGN4OgsPMtio2w/9L7sdysgpNUU+r3J7foyKqS10zau/RwOIG3/3g7fJiwdBinVpfO1UzH6/OcOl4rVybi/X3gJSDlh9HaRsVyjzTj2z2feYo4YkkE/sd1zSRn8gEBi3PdSb0zcZQrCkQT/kZrkcaXgVUgFTVz/PSObblxtyhVwd09YoO6BmEnes0HcD1Shyapon7dEkKhRy2LGs9CVtnPMz6zV08nNU9DmEcNSkHOWmNcU4o/WFoGMB71poFVWmKGZXvaV/MyLLWYellGaRrWb3cRZ0eetoA5rswaDgYSQrNERSTcQggvpBCBhycWxCxf+5/IgPyS7/0Ak//rsNn/9SX0rBHXmOqNDn5csivyoyghaGQoQDacg5KjnqFa+n3aNwwpfpiDXivBpaeNhhavoqCc8nksH1TOS1qm9xTnS1S3Lxz2F7Dahn/g/3YZQZSSfumMMAThEYFJ7MJHrhtfhDdFJ2sazPJL7Yyzp5eq2fd3oaEiJXcC8mb9Ni1tAfviffCBAyiSSb7yHkfSaQ0gujNnfCk/DwLMqYo37xcaBfyH9z0IgJR4gAuNLUyztDJhSQzhBP+yjQtj+sH+N1BPL3dXuQirObZNInhw2LrzhnFbnOtKWp9LYyNLJHkfe2UoK/vB6Dtlo5ZSDN32y3w4jWOn1yi2cV+n7/x5XBsG58pr43XtsJLY71QbtglHTrAOEzZPMufXYVhw5hbr+DWq1jRgYTqWrx6dzjKvM4NWO8FgakrkzFa6E8/K0qjjmfu+OVzOCuZEmt5hrU8f52vQsgqnJdVP/on8nPc1pjWFapgfJEs7zeruN409RJB17Wr1u+5sFaq8Rtq+bnMCVIuVs4ZzVCohQI4jS6+p5zGQkcmD1uHEjxSyNyEqqi1ZtHSvA1C4K5D6I+ZhURv5m2H8eObSGRn8kBWZkYz/+lg52tG24Qsz2DUD3FvcJQwGqflOLK1GRntseelnEZYvwEUE0zcem0EuImQyfucPryRWwmyEiyDRp1DZrOqjhfHLJ+1H3TeozIyG1nEqih9A+ia5Q/H0+8pf57H6mT98e2/EG4i5Qokx2clXs5yLyiuaW5Uy43kC4XlAvGzAspEIyRP/z1+4wM5/F9/od8d/s1P9P+bX/0sXCczfvKJByyzsWxHj6mHGrPAzHfykih5WMw0mxnFsMQcvNfxqTwrU3RXn4XQUxPPQ3kCANpvminIQWd5QnqPaWJB0ogwUHhUIeiC9okO3CxlfH+IG2GpbzLSu26egYdmP0syrLJ3wok5P5Pj+g9iaYf2nfRD/bmEMiw6N1/LcTTOVJQUZqEi8pWPA00RNpPTIAeq1K0ZZimSWAwDFv7G4xYcKov2Zka/GrLv8d5Ksg/23q2h4U05JG2m1JT8zAxGK+9A5MSWDcrao4qx5mn4dZ1uvjCoDrAIX7ubawBA/3VZK1qLvLwK/7f8DerS5VwNzb42iQ0GtQw3mWp2wfSpQcZzzR7dNAMvJanYUOD+6LjlveQObKmMEgAwi5ZjkmOd74qogB171Eti6am6UoSFVRiUnmDew8PPSr83DzEJSn6XYyjrkzTrjGa0BjUQVZHfzD2TJa3zlY6BSj4UIgF5JEOJz9HJ4XHF8Ztv1ES+srEvv9j/Z+tZGHPcAygWevjYIFj87uRV2Jv7gLs/XYUjzxafmdRkAyuHbD2048dna3fOU8vr7uaNfVCla3fC/w0IJPnH1XHEeBUM9I3cP8OGq8+CQW+4hP7NW/mZrVnneKhJdnK2Z/O9/aXjnwPwkyqrk2mNAGZRK8Gz5zSlcs/aLNzCuQlx21MLrE8HtxpdNvMwnHv1LeFlvf2zXwMA/IMffqinaYJGV5KFRS5NRuRbCDTKA6Q/qR9knyn3WoEk44VpxYtG+JZiieG809UKbpwxbWKqtBpXY2EAc5MMpY38/iD9btGyOjWetS8sr8s0a3gkjZv/OBpeHhGMQniKRtohrRvnp0nj+JpkcS8Th1ym+dVrPQ8R0fn+AfPdPfxuL583tYgmAmhD9iC1Zqo397JhjNOC2Fs9HJeIJJvltHGc5WiWXWyzMSIZuLMYiNS74nzIx3sBUS0aWKp5tMx6SxSMk3NXJzWCEuLtFAQ2OeczRIjXSX56r6Eplz1Djmjpd20LqLlm3J5rFsHKnRV7bAktnIWL6R928Ns12hdhjBEVZeo4EOcz0Y+18PWmT55iehYME+XshDXPFgrOnoN9mqBjGiYM6EPY7OYPn8BfbjBfbaMyepJ1mIUeed22gV91ggBdBK25VYY+21R6htLMc/jtWp49LytGp2gXDZV8HuUGFgBUIbucRkL3jvpHE5qHEXU/a0WGpA5iuN/5igaAuZ+uBVZdXA/VGc94NLYljlAQPNVycYGHRFkDW9Q+M8T0uHlaGFTeGkr852eUZH3kl6p4v65pxEiua1Shj0lfIEJ/vC7Mk8ljDo6hv9yIHlww0pR+wHHAMPpmFaUeKP0wzrH81yajRJgsTKJQrhUBUmcjRGw5t8nup5yPmhTik5+2tiKbr5xIhXiJUtSHEeMNtSLDPVr6Qx5x4r1Zfqc38xZYgEtA2aAutS9AkS9Y6PnALWVgFOr9acs8zbM8FvXqKuSw9ULbxbbwt+57Qqz77l/5KQDAd/6FaWlglTJZcgu9xCfJeCQAlhkrX7DmkfJucj2PZtmPmrnTpBN0vogwuytl7+nFMsTtHAJpvXlVXWbodllAWhsNLSP/oRsyDSwtMlqoV8jw8q14tjSw/G6fGFinWtSJ8cnvpVa9M+iYyiIww/K0wZgQ9xHeYWZgani80FQaJTe0jOdXJFoq1ynl/MzFjM2CwZyJhc7kZZX4TCEsZvkXeQJHkXN16l6nwqJVMqpyKRAlaRfWlVIhcg0LFBDUrLWfyhhTQ2vVRQ+bKfqFtWp6HpDWnF9mPXeOjZIOV75GEFUIGcS2nTW0QmOB4VJzeTgfxsDKQ/72utv0nIrS2THLtaswx2gE0VBYvQ3ZvbtCxrE1tGhgPSGivy3ej/wtGAtGMBOAoNUnUNpi41id058A4jpQ2hfzEjrnNNdCKxpap34HohxPeB4aWv1VpWschUOLLaCVuVGd8G0zQwtANFq5r/H722yfSm4/o+IAMUx7Lht7SvcMInH1Qy/K84DWnS01n+2HpTkbpVfc8m8Z4las//qI/fyLIVnM+uI/mEFaKEpKq9GWq3CWmwGzwFf0GMbT4QFq93hvLP5wH2GDVlJ9kmko9/T8/yUbc/cbG1Q/WOM3/4tbvPiDF5ivt5FbZMsp8DmyjEd7f4zNar066ZTy/eeZimbQ5aEcP81SuuNoVWbls/GiwXjRoBpmVTRfNO+Fj1VVWpXc7w5pAVLLscsr1YeMNos+sgwBpilOshNQq2YBVnWEx43qvWakUheGKInJjMrV8rmxJ/0fiNkkIVeXF4IQXlwshQipzTMargmfp67g7h5EMX4YZULnoYiHHdITBs/UjjW2OmTUWC0o826lXEu1XKTnzIMyYa1YXmqO5VYyYcQcNdJsVmp28bl5LQ2TZIkYDP0bdWsNb9DLDCV8HNWec6FZ3perUHUtKkX56uQaieFH9DT0jZ479ClgFmiLEM9es5sVXZymuF4AMRRnDa3KaSaYO/QaGqvud6ge9sBmLeMzeOeAQZlCRt/uK1vsvpISjfXxrcGdoRyua2WM2gxsGqyq3G/CJbWDX9WojgOqY9BGynl5WWRhvlqLwCfHms0Icy5SPFYdtLacaePzC4zPLzB8coPhE+HDzNQTy5AAPwyCcnBs2/XajnUS+ANftHkbwlmzR9VPsnF6MSTHS9HfmtfNUp7GZuw6J/y0zAF3D3swM1Gd8Mww9MMgY9pkWGqoe0w3YVZLkIiHzHHXtjJ+Au8LQCTVMwt0vRYEuK71J1YdrNZdYmjZDGX+bJrkGbVGaz+hf9qhu5/ha+DwvMZ4YZAyk6E8X2+VrzR/cBPOXUCWgu4knJO1P0nICn2Rcb2o1YbtBv7mSu73+lLnjqsq+ceoU1izI5+X89FkdnKMjVIb1+2O4mBMXjMM690o/46z/HvoUT8EJJLvjw7TZq0Isvc+zoFs3bPrHxCdfNVyZHTgEe3xRpblOpxqvEEudkBMVc6KMPtpiuq5GU+l2Gzh1mkS1GToo6AlUNZq4u2HxfMb/6dXGC5n+Mbj4odhscmKmNo04UV2Eo26fjBci/Bs1GpyLhoXJAFyMyzxa3Jo2IVSHfMU4eowSI4fLD2GOpMUwOTh+lH4Dby3EPbQRaP0HidjYOX3SCFZ6psRJenaVK6j8DxyzrCQBF5Btd2iWq1QrVaLorpFNV6Tul49e4Lqw+eorq9QP3+KKhTK1WyvixRtAaBjgyUZ+ufmGnnYhPyK4wDcPRTFUX0J9WTf0lBcrWKGjToTZ6acRRKdSRQZxsgjyIoja0UCRONFDdUSRJ8bWtOEeX9IhD55XFkmImqmza9ei/zDfg8/mlDLGe+uMhIUC15eCYHi8/CeVMD3dD/60jh2LjpiQBHR069aWZfDMRKFTehSQyamaUUBTfYIZTxcteDBOLuxsOWOKh2P3VG5SvW7LBw3zXBHqR7gdge42/uzKEu8FsdMBVV6z1AKhlxsY6FoIklJlhYLViu/rICk0IlgCj4FgPejhr+YYUjUa7xaYV63mLs6GpoHygos9wy3NwWFAemX+72sb1yzc10927jG2+omQVohlwCxyTZ6ff6fIVf7GY0w9rUZKypUbWudAuXs9mxfWn+2x7CtUA1AcyBaSF275fHTB4K6zk8u1fj2bQMmR6X9EdZ1Gs4wBhYRMIsEUdKG5d2IllGk10hxKDJeoMskhbYvNsA8q4FPlPPsPCZnsaokKaeu4/3nSHrJSc3DmradKyCftccbWTm68750xzwbg81sCJ51nUoDnYMv5wxVLiIw3GBywvSZdvjKFX7qL42YLmfc/pJ8/+4XnwIwZD+TUuqaOm4e+QKf8dJSXRvC+cEzt/3A+3bZ8VktLFU4Rlz4mXmjp3owky0sUi54jpYYqxOVi0NrwplNzMrJ49UR6uXfzQbAmlOVgz8ckjGhHCBV1w3GCY3tvo8hwzz0kWXkJDDtOMLfP8C/u4c/9sK/4sLJuDs3NBr0oT/njTxz8zCg+/whFlPNwgpRRDXUszPaNbb8kKok5xpYpjKCn+bA2cjmCzWtyJmynxPN4XVMWan852KS24w8Ow6z73mDyrrKyb+SA2BKW9nz+8Mx0ewqGmShOcvn4d8CMqZoDpAiLEgNSaaEA4hcxdzQ0rFd0G8DZLE9HLLPzDn43ixpmnO+qlJeGtWnn8ia0d0Wwl3jGLNI+fyKFmSZxyqHkBmYwwi/blMZFnOvGIKTSfSuqSPBGxDNvMMYnYIC99I5KZeVj1EVCQ3ZfywODQBV0JZDVUkS03aT1iEEIm/T8MR8U0c5ARpBPhQcPsTfgXTjnltZ571zYmjaTZlr5Jj2kf4eEDV/OMYEi3xdAyS0nyepKCdHxmC+pizoA1rOyKxpo1njcqTXFrhvamCe9d5KSv/sUxUOJandA9ffCjqBwSAfnopBohUsvDjftkC37xpMH1yLIdS1wt+jkUTnQvsKohCfO0U5Iq8cp5QfKM8xn9awyrKMdb4HFNKvVzIPKvP8Yc8bgohte9cvJRz6IaCNUwxln6EmucrFNSTPeq/StekxvKzHZxde/UvxlzyUYRfyTPvi3PnVK6U1a26aZSeSgZYvRFkNrryIKAB5maGQLi3ql/+4aOB8/k/Ic/zcnwuZLD+6i/fxLhBgGep0Tuot1VUkF5cmQ+aFLBZVG/7Iyy0AC4ViekXD154DgCoiAyLuB8hCSl0ahZBDAWT3Nj4TG7kFivgoJBtgWpOYoMdYA5YGB7P3AheKfeW6ziAuZjLR0CplpAGxX20snOhM0xijK/VGFrXEED2S6kmAxJ89AZoa0/VatcSqEOPXml+29lkm5Kf3/OQq3nu28Mkv4RkZ2sv00JJyNoV6nGpgBI9ZuWjcVBN+TxpiPTv/7HVzVe+83IqfU+MDmadO5PlE7bzkuTIESsPU9p5yoc0SSmj5ZpWE3iJilT6zPVeu56dIRG2cJxqLF3Ed0nmbhcNjWnwcK1NAfOa2Qvf5g5Dlw+apwrgcK7y+NQRd1v8I/d3USzkFm/YfeE2qX0bUm9ln2xWm4Fi0P3q7fJ6M1+MDOjU8l+P3H5u1KNzi+tWAJhQb1tqgPF0YI5UlvxvpheSaoQ/8KhqQdIKGazPWwvfpTBKdqbiu2ULWtk8577IszsW6VuAE2rUu31OYiJBkOGq2ZjTy/LoTQ4DfyyMidqzmnNgTSQwA0vqtRBPD+jN+eA0AePgp+fvVPzD7GTMLwzuaLzstT0N0X/mqYc1zJolKDa3aRH9oQObJXxpOjHOEY8JnBprbS3Jb4ohaxYGQZOOvw5hmrdkmDZkC0OfpPgvPPU6KdOo+zqQh8oDtewn8WddGtFKpDWe0zP7S/t8B8JPKLgTOQ2dGOGxhiGWem2rUtE0MQZwjkVm9k7qKdYP6wWxkyxhpFEeMaMMHf/Nz3H/NYfNdmUDf+aace/gwkAGtOnohk0rudWm5e2tIkTfGsGHOB0nOFZET/b1ywpPQARx+1Ms+Yo0wTd8dJlm87nYFLZMwuC1RMZ8klgeSfaaG8c21eD7jFLVMTnlr5tksEiPVAaJm2qOKG99co3r2BPUnH6H5ypdQP3uC+vkzAEAdwhV1SMevP/wgPgdRKxJvH8xGwDF6K5OTBjYXm/n1mxhqenN7+uYywrC7vIB7eiOImCpMn0F8TEheUb7wfeUz5SRaPxu+QEZ8t6hbZlhV3BA3a0NCfUT/m/lgw7o2pHpuQVogunYeFQzRxXF5COxcsk2yobdA255H4PNGxfuAZNr6fKUyIxRHVOT03Z2gZ7YeXV6T02b2sY4bjSSLlmQhUGe4lRrymwV546br3en1VEM51xfwV1vMz69jIfmwua7eLNE5KmxXoVCw1hF0LiJoRJTfhc3ObmQu3WSZ+Qsg1hC9D/IqQQuJBpabZgkV7g4x0lFK7rBFmAHVHLTvQQvbF0JxquLPdxOe0V9f6n1rUsQhOuFsGko7lbENpIlc4Rjfhoz25sRYLzQVBp5nNJ+9ha8rbH8g/T9tw5pxv3SGqtDHvnYYL1qMFy2G6w5zV2O6Ck4D+YV2XyWpnmWPNLFraTRqslXYs/xmBaw6+MtNTE5gpmhhXdR1qZUx7RtB+L2VKdqfFmGO0ZlKuFhNozp2XLuqzKFzpupLUpMYSB3VIbNvzrQvhGQlhYyBAL9OEa0oIBBnlV5r4Sy5tlGBMn0woxytN6vcrSgslpyzNVlAxpN3TPGtRciOOki/9q/IRNv8qrzML/+VHZq7wBHg5O8HUxIgpngmBp2F3jno6lqeafZwTS3GyKpTNCx5RusVWU8bkZw4bVrsv7RG1Xu093Ic7xUz4Fc13HEKfIVRS8XoIpB4Q3VyDdlIzMZmwlUaXrHPyw1/LSRXf+xjGRYen5M5A4LnQyFUIHrgSfYcxxONi2Bc+2EUYcG6lvfZNDFMaLk27EcaNU+l//x2Bd/W8HWFKpSHULQq17xinwCyMR+Oco1KCpq6zUY2KULGutB5IWeOk3pslAAgMlsUHrWN/IhxhGuaIgE+bxJyPb8gW66By/lhTNzIz+2qmOZNkirRMlOYez4jKZHz7RBkSzzJrdagD+errq8X54H3InjK0JiRiijJn+TaXkS/VJ+vMTwvGo62skAmLaIq8SuRCpi7RsMurI05rxvUu17m3u29hNCJ7uZZhaY2ov7Ne0FAZi8btHMylqwhYNeaB5bmieRsea5KpCVuLjCHjba+DeuBRa2JfBEVCEaWbyq4ccZwvUKl9exidm51fwjJFBKezCtslDJgiRJ6Fm+uKjEUSTu4uVSj0JuwZCl1HjNESHia0j1AM08dfN/HEFH2GftKuVarzHEB5B6PPfz1Jdyxx/TsGtXuqM4aNaP0u4iGr2/qaGhMc5L0EjtkyWHS9YhFjZnEUcr2bhoNL2piTkDZppsg+dNUUtQZ0BqGHEt+1cGvGww3KxlvldMsdUULraI+r9G1QGPErmnkDHFdV3Fny9OiUaW1LWd45ySB42Ev9AO+68b0RwAaqGaviSWkxsyzZlEOT+Qa62+/0ePdcZB1Wudziv4mXMmCniEQ1hImD+kX4rr1k9XJytpChVrv1dtfit8B4qLsjVd2slnPLS/aqeHKQspwmyIYvMZw1eEb/1v5U/ePvQYAvPnFAuGam4wSFsMgSUKEp7uRysP48Gn6e+m7XOxX3aJG18NXQ3y9kE3IRYkKygr39oPhhp1BCTPpgJKEwqJEjjlOYVYS10vx7nm56akhlKXnu0JRVzVeg5c8vRDts/nt7aIUTKmxRpeGVdft8kskcRa4fXYjlIuV3gN1fEJG0dFs6oVQxKJxjNHA5WY1TcX5E2/OhPnMz0WmIVBEhFR3Kw8jlvgG2ZzzfW84VHXy82w7049FjuYjPEY9dYGvthjT59Ya3pPJBlRjSxNHCohyzg3KQ4RAyrfMW1b6hEZLSZNuYWDZph78mTmf1xu826N+JchT8wNZD1fffb04TGkINKg1vd44Oo+Qu0nqIQInChdnPEVA1zHdbEtrTea8Jqrrue5RwcDSMFdA+1nCLFkz6GCVZE7I++K6eq7Itf2MKFnO9Swdn6/remyj3LZqf3qtYfiO2oFNQAuZlQcYtNaGqPm+mKSwSdesYqP8xrZT40x5YRwPpYLsjH5oNm8AHtoK86aAoGVN54jOlcK63ma2BLCsApBlHibtJy3hkJTXmLOFPDe0hjEuZHbxz4m4nAg70xHORdL3OC7j2cBSVdz+fQ7plVkaLC3r6k3UKsoNrc//4BPJzFvHyadExLwkQ8HQsmJnHDj+qXjmjCuD2kJEbGyNJ9M0xZa/852vKkWxdOAFQ6u+DaiKNdLshLR/n6YI7WdV3/0gSIVr2yVKcjQZV/uI4gDG0CJEz+SG9zXyi4yh5rouRQy5aFGM9N07/cgaWv54xHz7TgQmv/+pbgi6aPPetyv49Qrzk6vFQua9j0ZPxutQ5CwUt/ZdG8mim9TQBaL3pIZWILonKHK26bpsgsuBmSflqjjxc2fGGFqOiRYlYnseaiyUgHKbdXofnHt2o85KS7mmhWtk7IhMwRw3yILA3yLEOI4xe5gh5gK/jH/Xf3mJECLRwKKPMYyCiFJqgyRyIHK4rKGZIZfVMKF+OMJNkzo6NOZZ10zfY9umnC8gpvx7H8/NzNbciNkf4fpQnLdkYOWbbk80YoSbZsyXnRiBRsJB78Nwb2ho1Z+9ldv+wVu0L+5R3+51bdGxneuBzfOyntsk/D6/O+gccSXDEEB1ew/nvSDxU2FDo/QDeTbMWiN6R9kOmLnKBJM84QFIs8gDIT8aOHVyr86MuVz/S6teGB0ulwEHvm3iNcJ6UTS+GC3KMzQZluU/IPa7ZqEun9HXNdy+FwRrnmUMZXOEHDs1Dr1PEc/3NDW0nDNisJP0izGw9J6InIY5461WF7MrVaYijBmK2hacsqqfFMXqPt9jvljDUfCW0Q6+j8DtdbXhHZskvdzAitGmsAbZ9faxmpePDRf+sc0/vwwzkHxa8rJz79rceNyQBc51nVRyL3l3iYIujZuui9dmKC8TNE3Is1xUMsv49h8Szs7d1yp8+Z/5Dj5/uMDm3xbE6fpvfR7OV0s8uGvji+M9qUFiiZLh+htRV/Y3l/BNBd81kgkyjGYCFvpNB6UMvN3XrzFcVNi+6DGua6x/tIsx7jBYNXUcQPdSDADCw0p0NQu5Gri5x2dDL5opGQa7ncAMs1A7K1Qtd1YTTb9ryLxc+LLNct7vxaAq9aPNlpsmianzvrWUSZhIlsRKfZpg6E4f3qB6OMK3ogDv60pqQNq+KokNOgd4nxiTbrtRfgGQevFaX5Kck5dv4mfMxMwLNquGywb+/j5kE2bZZzxHCYE5Qfz3sy+jWZnopTPJIUkYjinlQOQUDr0erwsQNzLdbP3ynoxz5Sj7kUlFcOxQiqN4zwjI2zyXYfy8cbPMSfHeR35hXiIHiOOeCBbHbgjJsLQHANQhZDJtWtS7HtXLWzE2mgZ+f0D15EadSL2WXXctl7FpIoIW6BQqAwMkHKRYYHpO7hFtC79dY77eqBxC80IcEme5JAyj0Nggp0oNQxMy4XwcRp0TqpsYEmYigmiNP6LTptA1n185hMGQDOu/N2g/w0xT4ABFtHCW9XSa43pqye4Ma88emCcjvZChQzZsx/HITLb7nXCI3t3BrVbyTpkkYccT+a12zoZwLwBx2Pl/GkSFsK1Kx2Tl3XzbRMOI788eMwwyX5ksQ6FWwxtU+oupocmakH67kvBnU8sY4D5pjndazFueY3wSeLgeqO+PIpthw51AYgQSDWQiRkMpklIihmZqNjFMGcKbc1ej3g3F0DKTwra//jL8YYh7RS4TFXjgpRJDCwRrKjiBpv3l8c8D+AmFC5WbNAzLwom8uTx13GSHxVIyhuvBwZ+LWtIjYLilTb+vEzonpY1jaqWyNcZDCAbHzd+JcPgP/28/DQDY/0tv0N5P2P/Ms0XIjlk7FJ9b6BMF3pGWwQmquoxDkyzo8wmuWUEhpv78Cn7TYvd1QcDaB3nWhsruk/Ahco+q3pEbcRROxzwjUce3pVWYzWEMLPtTBycnfqbro/HzHME4oW6sZGwiZ/u9aiwBWBhnFBlNyiCwNY2QyjOR0iS1/3iU9zROWlRUUb8gxkfemnJeMrHCRaYg740aO8deQjnZ/Snv4HCM2UimubaJQquXF/I8mTaYFeG0QqALo6lgYMmf/dmfyXWAVPoBcRNRkd3ckJlMYee2hS3Rk9wPS1VMkz5PoqvGd2yOURpB9ndtXMwLWXnJ7+Z+EmfSigq3TSKWnD7jrCKKmGdxuLJFuRpn+LbWzaN6GRIjaMBlopS53EesJBGuvShIS4dklg2Qx2nZkZjdJc+TOqrVMKP90S3c7IV7WCqvNErB28i1DfOCXMNxUpHe5J64YVPzKJcyyXWeshR9HWs0rmhsheuqYVFVqPcD5nWNadMkyBsQ1tMgk+DzCEcw+Jhgo4gWn4UUA44pot50nPIao8o/HNKfyrn06bPqTXrMFyv4TQu/qgX9sWE4iiD3kStaDMFRcgeIBgjfG/l/dyEzn7wl6kDmRcppsFLiwVbwGCfVGwMP6xrhta5q1PthUQAcVSVIVlXFZI1MTLfqR9S7PpLX834inzcvxB7eA+keNLYpaHt8KnvA6lV4n3n0i9GIVSdjoq7TvSVPwMl1tGyz5Xce0b4YJ2uOcHxeSuNsc9XyZksaSKHpgphX4raZOAzdWaI5j88NMC5MBY7J1bckdPjwVTnm9WfX+PY/J58dviab8/jJk9PPlglAYrUyBVjDMxZsXDW0GG8OocTh45vFd0l0b99ENImehabh0sDaZ0gSECdX4CT43U5VjnNULr3JmOCQtEIJjVJblFvhZlYw0F2T8vucVTPnAnimdEOEhWOB5vn1G6CuUL94Gy5SeBEMS3BjpxyF1RpiKJeGv5EzUFg/86ZL5Y/0/tsu1secQ2JGTtA904oheqIHBV7iIhQ8hs3sHE+PHndjUuSPaR8X7y03tOw//vmcSGVmiFnUjxvdwtEq3kiG2pa+0jSCLIeQnR+n+N7PCSOHMT9eyZidVrVm/dKoLvISnz9Jjo/PWHBY+W6M4jVbYmCdaD6Qgas394LQ7A+Rk8TjC168CiuHsJ8vlariulbILMudZ0WwzkVMMmMLgFHeP82zVD0kWwcw5+AWsrnnkPWo2Y/HTB3cXoMGp+F70sliiSzPCEdeEQLA9EQc7eOXrzV7b163qO6PcT25Wx4XqTaZQVsalyXUm2OL1Aj2UakANg1L9oOJttAA05BgoakxR6OcYw2ISRHHwhjPEDttFtzIyvdQFwyASvCoM8rHL/E8DfXDtW1A1LPQ8GPKHxn0vRglKLTTilx5y0tfGHj4VGjDho9c02LuB1Rdm2RO2SyfpNlMg8C3cEDMLLIeWyYUBiCGvjJiYNRtIXFxxAd/u8cHfxv49n/9Eq6d4YcK3/tjDX7qL45493ue4eL7e+x+/hkAYPutcJ7XZvFrg4ZT5eT3pol1x4IRRG+CMX937OEvN3DHAfPlFm6eMXx0CdfP2Juq6pvPAv+D9fRYj6oyVe6DoaAQLAemUUP2w5CiT1XgoLRNSgwFltwVhIXFiPOp4VVX8McjXNNollmpaWh4vQKGIca+jcdRKRE+bFjH41L0TUnaqQEt91Kb0HHMHnHrlWw2lxtUb+/jdwF4APPFGvX+GOBys3mbDFdFmlhhwHo+tvxO18oYNRmW2p/DICFBooO1OB+eAoQ+nz8MtYWf0xxDgCVPKvsbF4GUyuXgp3ju3BjwecYf5+pRCO7+IMid6g+x1BEPmCYNB7q2USOJ/5eM1CmWpikZ9+EefD/IuYgkhvWE2afOhjctuqFhojQs7S1Kx3Fjkiz0fez3cG0bkZU81IS4fhw+WqO9HVT2wIaOmZGZZAfynhf1KQtGCLPSrIFl62MyZAeDBl3GtYPcU3e/E5RnGJIyIY5ZpUB6jX6QvjgcJCN6CGKOHOelMKLRBdQwbGscyXGKm5+ds2F9d5vNsk8Cp4cbvbsKoUOGnIZJhVr9ZiWocri+Px6BCUjEqukcVJUYRJWMZ7fdaNguZiwHNK1rlyLHbfhb6D+3rsWw6Np4jVUMJ2u2H7ciU6HD3UlYWRE1K4w8SSRCw5Z3D3I/HGNWV4scZDuOhhHoqEUWUJsxjj2393ot9+5eCmyHa6EfYpLG4SjFvElaDyFo1g8EEEO2x9jH8oGTa1aVZuHqOHJOzt02sh8y8xTQuptuP8h9ea97qDPyO+44AutWiorXDo7XyNBS+X8FjAUQpsCNjTU5w3NZtNwg5e4ROT5fOLuQXijLY+Q6E7YlKNUJeK2UibTwsC20PmXW7zndqVyl9ZEZStVarvG9/5w826vfW+CIsFmVd4YPtZq5LM7VYWnFz2ExZFHZ/dcCOb6Lr4QGVrER6iVsGhb5IpmS3sw8L6ubs/9KqAbRDOXglbwovocSSkTORQgVniqAfKItUI1zBaCpbaOledZwVyFcyzH76t3iuPFpWAAp7KcaOY+YPYAZh6GvSB4tIYomfBINKBpCy4y4RcvJl7apM1GaDzFkD2DhwSWnKZHjF0jY6ffH8JiWOGqbuGZo2aPCfMqveyZkUkTP84LR50r8cPOngZjIsYQxuzs99+jc3H1FzjNcFeacQTv1FvneiBKcU5/O+SmIYyTPdC41DQFlPNJEs6uAilgk2N5rEek+03yOJpQysInoMcmo9DwnaqMC0NT9mbXzCqWOivedU0y4TgWdPNuITiVjPt+cVR9yuceR0kHNL0Vd+kH1+IrUm8xo4dpHFK7Y7D2SE8pxQMO4sK6pEcmEinAtRaaA8v7AduodnTsG0NC7qtiXpHT0JkljYSJCDEWOV/L+Gc3xJaQ8j3iV1A7Ooa15YfsvkO38eCTLz4a4LhesNmv4vke1WkUSaraoWd0rFVRcrVJOx+yDsOUIuMg/ARB5NtbTV56X6E+VJqf1rHgeTQVddXCTV4ifSNCTvyGT9PYPH4BPjsAP1vjsD1W4+XXg/ssN+iuH5uEKvnZYTbOQ9d89AF2Xqp0DmJ5exWweRNjW+QnzuoUbZoxPt6iGGccvizEwrmv0N3LfF9/bwzugfh0g6ayyvJvnKD5K63/bwe0H+KoKnkslk9SQTKX/KlkQcm6YblA+bkSBj+JWnUDnRIoskXm1AvysmlZWSmGmsm742/ywEzRFyerxvrR2ntlw51CAWBf9zsC+m42gnPTM6uC1DmMiXut53HGItba2S1VpVgdwF5vUI6ur4G0NUd/ITsimBvo5EuFtZlTg8qAfpJ8zlIjPgqaREI31mPIMF0AJ7VKuKVsovAccoqHAj6ta/lY1qkPmxzHqVSEYRyTcm+Lv+i6GobxR8hLX4iz4w0EqOIxjWYqDoX9WebiLm4agBgUDik4Ca8fNcYF1da1jyzUN/DQLQgMsnC06ht77VMGe60LO16Fxz+/VMQP4+FyOOTypsX494fh0hc0P7uC3a1X6JoKVZHPlSQ9ZFpwiU8x6rGtB8J1L1kDXtoKABsNVeYYWXbjfwSMzEJixzU3ieFwmY/Bdk4gffuo8o7GHTonzCUpmuF1uLeMKTRPXGTt3jKGl/EbDiVHC8qYDKsBXLmaJH+N6yHVK+WET7yXMO9XkSw0jhjO1/2lwWH2zLBkkafPSmNei35CxU933mK5XWH2+w7TtohDyehWvRwRuHKNTazO9+a4AzW52uSFfV/IeOulLZu1pFKWuJEvSJlewWV4fECkvt/dA5VAHLa356SXqeyYQ7eM7PcGp1n4xVTXcPEd+n4YMbVi0BsYZbphiVqdzcV1tG2Dq4VfCEWvfHnD4eCtabk0FHPmdkAHId6bXSrls2gXmnRPVdmZvt1QWP2d76pn2eCSLC77h11CRWm+WXnnBsl1YfnUdPWrd7MOEy8sKAHGB5yannJGC5z5nGyCvN826yS4qupt281eD9MJXDsAM3P4s0F+R15VlKl4bBOWJoFGTERAFkNRSmtfU/EihV+eBw7MGcy0GFmDkGApNjbZ+RrUf4V2YTLWLA5iGgvUoMmJosf/ycKHlxtnFEmZSlmQ2rJAs6+M9Mo4NRJQ0apkY7gWTC3JPlZOK9aqAmLEZEhGSR6MURmeucZCwg27ufNerJWLBDXThRVMoEFgu8Aj9RTFEIC6g5xADGtilcKFyN05nH/osbJKIRiq6kpH4jdFV5DpkTflr5JyRDlC5s8jLKc5OknFaCNsB4uwtwspneBbRuYthS5Ur4fXOcOOIoGzeSF8fntXY/ECMRR0PpXmVE8f5jAXUbEGI9176rzUyASVtIT4jQ0o5T2cwBlaJ5lGQx0jup/Q85GiNYxzXOVpUer+quRSOD9luiSMS5pUWfTb3ykoXmqlXQjD4ro1DmRhBtubqOX4wf7ff4bmzbOdSXzWvBB1qP30jfzgcEwPLHudnqeLgh0HQRlY2Ac7PQZulW0koDjkXS2tlGv5b/hwFmYJc/kiTrrwXLlceEgeKKLJqh5nMQc3gps4gFfNtVQXNJkxRy2nb4fCxOBisFKD7H599miIiSI5dycZgq9K1xK4hzq7Bj2yPNrJywUEAgg4dj0lYKM8MmrPNNxpkVdSKKtRwk4PTUIy2LsLlJTE+NRxsVss8S2x6itYxXyqVbrcv5XpDMKhW6x7dz7/DdDHj/hvynbuvBqQq8AMwz6FMQHnBm9tavK+WG3bIcGPx1ZB2uvuoga+B1e2E/mmH/umJkA4J1UbGYV41knXhnAz+jIyunJYTGzj1ehYGF89jvB4tmmoRqMzQysMfrm3SzFP+A5TwTpSBBkRJCNN17UJMUIsUEyHZbODWK+X+qDYZ75WGmy2rA5MVduwXKbxK2uRELyEUkIVovtpo+Qdd9HOC8DxLXxNRyBf3UsaLuR9FspLOycKFeRhYfxcSuhpcGY+uRGovwejqbPF4zlX2b1PLM9K4KoQxVW8sPKdFQL0XVLxEkte1yJb4OUNaXYRHszHDz/wQeSjFDXd/wPhRTEy5/1KN/trh+lt7lRhQGYA8HZ+cTUplsGWGjobwiFhxLq1XMh/rKgpohn7IUSwXwl66kbiAXBOBptGdZaVZxMaWdErudRwXIcWFaO7xGJELZg9zcxvOGAtVJYkDLqIPuilv0vfbPAxS5SI7j78Q6RzKKqijZSMawQgBIEko7PsTBqUd/46yFdZxpbwJkT5THcBRL6rUOI7zsNr+IAYs+9MYOwvB38yIdJu1GN/OiSHD/ZdrSaYu74+98BA57goJas65aLQTFaYoLdXpp6xPzj3vcZA1lYWlg34j5wp10Kre9JuJ3OTXae9GVKPH8SNTVcB+L1R88cfje+/RVrWxxrcjB1S/eCbUn5/z0WV1tv9CVK+2SIaKGdIyPM0bUWa+0XPR3ysnC3Gu+ZKTJIElBGl1ZXgtTq5ETFA+n4JmB0npxw9kUjx8HI+//Tn5+dV/5IcAgG//+scAgA//gxrd/YyLH+wjkc8W0qT6OpEyDUWlHgEQUaz984CU1EATyIiX3049BiJg1pOjR61ESpY6eDhKGHOaDIHPIAK00Enm1iSDMMCMCrKqTeeaWodDJA1n5XF8ScuHLfcAzmkqYbmYKOeqVAswk8TA4SjCr5tVPD7wDLgxAYgp4Vn69qKQNqBZOsVMJNaDY0ICiZpWsTsr72BLNWH2GjYA4uY1m/5UMntuBHDS2+QP65HmBZ85F/kOSzUE9csu/r2qJOSYZVq6q6t4XUUfsmxERTfimGBxcdc2wDxLeDhP3yaSWvKQM+093dQDfYHGNoCEC6YOBdEH6sCRd2jXr6y00PjRDd793AWONw6Xn8q5L/+O6OrpuCglRuRcKBondR0zJ22IVRHksGmvM0PS9pOGdwKiRjkDVwm6aYz5Yi02q3GGpRe/MDTy6+cI2JA5Q4V1WNfo9Sok8pjsca5bRjNrNOViAFNWjEkH9h6pIG+rWLwng9ei8TFhK8xFGlB89ro2jl6h0gVRxjxEus+QFMSx6OdZy1UtykJZ2RE9kEkPlAsJfUW0p6kXyKpdizQbMp/vecF4QDOj/eVWtSOjbFI2nnKtRSCVULL3YUR0vYk6LY7LqhdwPzx8FMfH6lVQr38Z5kCQ9YD3mkmbZ6EXQ36MYOScPYuiqrFb4S/u/ncAfgI6WeFE4ajsfFUlBNc6qDu7qJlTTNfOm6Z79nFS5Jt6HvumBQ0svfrk3GlGi1+1qA59lPWHWMJANHCOz+Lzffs7HwIA/sk/8PcAAG9/t/z98OEau6+F8FOY9FOoHj88WWPuKvgmIFjOgVoj58j3zUE+6+4m9M/DoC4UogUiEuaGSVEybYNZWMDHT70m9eIpeNi1sT/PyDIo1+nqShbgKSBnNnxlODTynzn+ywdugUyv923CW/4R8gHmYeUnN6e2lnps7x50PJAYvP9a4BIRIfReFnZvhFnPpfPTIwyhjnndSJbLMMUxl+sHoeAEcL4YmQpF6TKypk5+o3OmPINHEJSpAG839BhCK2UtRvQ5uR/7FTpbLPja1PJ/W5y1wNHSlleQsOfOyj0tirMGj9/qRBUV8/msXbq5ox9ko/NzmsgCFENQnJNN2KMu/+6rOHdyIUa7btUhq20ckzDVXKi9qQYWxW236yWySaeAhOE3MbFjIfOQoVfJ81hHqHJJyPVREj25YG4/xOdXxfVMMHiatA9UHiEvk2YvEagXNKTq+x7eOUFF8s2+VOqG8y2gTqq2z5C2/a5dK6fJcD6jYXVOkkL7mCFBG3LP5o41PpWLpaFuo02YE7e57pgQn3/YxQxC4DSCZu+/acRZZkjfOmkWoQQky497SyZsbdedRXSJjuG6k/VgnMqh3bzNqfNLYV7fRuOxuw3Rk8DXqml4V1VEtFQe5nSoNZkXtgLFe8Z/YhedaF8ou1DUvdPJehamN4YWQ0au62SgZjXdEuIcF9Up7ZxiKEPjumawMu055xyc6eTc0Fq/dhg/kBf49avXAKKh9eIPxms9fF0MrcNX5OfDTy15P9oyQ6saZozbCu1+RnMMg+RYWARDWDMPT6Xk64BivQ3ZROQIGS6MIgL0eAoZUImhVVeSEl4FI0y1yU5nlC5vvtDnuaE1jvBzCFEYVEd+vp8HBCAaMNnktYhV3oZnQb37CTeyAlHbGFqKYrH8SiklPW8cw7YO2anwYKYJIw+QIcSlSV8wtLQvHyGal5RCsvdTugZbmMN+mhMZhOQ5Ss3y0vb7RGj1nIHIzygToqK2BW0iXVssMtK1wNBHkvuZGqK6lpjyJa5pgMMRw1eeAQCmVvrqcGPQ81PZUY/VknNS2LhoYOW3SAOLGWCvAtfH8vwW78yETxTVen9Wa/JeuAFp2OlMJESd52Bo9enP5BorY1BAntmvOmCclgbWYTlOWItPDaymluev69gPDOuVQtekOuQi2aWmkiqhju4UDZ7EwMobDZT8vRQywhf1ee1xmYFVUi3XQtBNLWtPSMLy23VqYJ1qLj6jvRYAww9Lna+krFV2/wsUVg5IzqPIky2KrY5EIUM/RHJWb9KyQDYSs0Avuxbws6wNgf/3qGjeQni8KjoDpfaFjKwqW0wTSDNkTpFLIQdEj0AY+9FC59/0e3WdTlhdfAys6lxEFdomxHRd3ExKartZiMLtj8A4oXm7k3CfEyhy93EHXzu8+5kK0woYt8D6+x3qNzIBfu3th/i1tx/iD/1n/h6Gjwa8+fkGn/2j8pLf/pIQ3pnK3V836K8bjOsaTE2qhglu9lK0c/Jwwww3zKj3M6o+9COdvK7CXDtMmzZu7BxAlcPcxvP6hn0gCvB+u5L04H6QxYQLSl700hgl85Mr+KbGfLHBfLXBdLPBvO0kOWD28OuVLHrrLix+rfQ/DefNBlitFqKxrmnEeJp9vG5di9ZTWMSqdUA5KocqhOXyBS4Jn1lUZb2SSRMGvL/cwK9azNu11AbbxMrvrs8W5rBJNA8yPqbL8N2LgBiETDU/hQm/6uAmkxUTVJE1ZN3WgnAE/bK5a1Lv1Tl5l6yXp2VszCbHDLLZh5IsQauntEmf42TZbFGiyn6OiQcBrUh4BhnnI+HOUVfKPI/r2ohc90N8Z3yefpBsRer9VFWCbBJ18uOomxPHizyOg1WJB4xBwjqVxxgCUD5XqEbhpyn5N+8PkBp6kWTuuzC/Nuu4IechSSc0Bj/N8E+v0bwWJ6YaPXwNXH9XyMXu2EfOlH0fbMc+8P0qea+smqE1EsUYcOuVEPLXqzjWp0nCZ9MEd7+LBhbH3msaWJMIDR+OEoYdAhHdGlSBk+SZlWsN8YyblGT5hVqm8F42qGmSsWZ0DsnJTZIl2EydyqSF+3Nv7yQjrq0xX65lPq1bzBdrYBb6haf+GQTBrw5ScWFRS5GN76IJ61RTw23X0rfrVfhbE8LKa1NCytBZ2vZEwfs5GsVh/VVNrnEU0vp+LwK3D7vEEEuaItp1mlnpZ313/KmVTIwGX3JvqzSsrPxTs/66oH/lxzHdO1nbNESiknMbjvR8tZF1KstGVWBjFu6hAjKjkM7d7iC1FZ0TdC831Ni8jzI45Hk5p3UhbWSn3vUKWHRvA8rNz+tKnpUaYrbZ5wuJEIuSgQhrkBFS5tpIPcfcHjrVvpCR9Stv/0xqyYHWaxbrZzOTdmEtWmiywMWR4zNSqPeLqunJhpxrDqm2RkAexkljwtRWYaXyzUt56VffoVUt/wDgr/yVX9ZL/LW/L2StPvBfX/zDcr7D8wa7j1r0l7FLm5COXgVeFQdP1U9aHqB5kIvUhxmr1wPa+1gcld/JFePdNEs9xLpahh/PoSpNE/kd15fwXYuZ3jL7lV3X1nDjDL8OxUwtumE5WxkKooYWjaiujYhCNkhtMWg9n/LEZHzoZmC+rzA2J2pda2kNvc+MxE9xOwA66brP7jBe1Oifdqh3kurNLKaFhpCGNCr4/SHUR5vTzwDlDpC8adEDF+r1KSKbLzRcXAIp3pbaqVarOOFPhceNceWaNlElXmQN2vnIeRv6W07lIsnXfodeNMUP60o4a96XEZcj0YvwzMqvqmRxDhsgEJNkdCxxXJBPZI2u0tpS0hvSrnGCnGl5m4z/UaomQMOLRumbd1qzcFrJPd5+I8wn8+y+bYJBEPrOchRPaL35aZJw6uyjvAX7gUaVzRo+9mLE3poQ4cMuCW/5zFGNGZjBoS2No9zQAuJz0LAYxogKET3NQlNJ0W7uEZo8ZflZ4f9hTWGNPb9qMV2uMG8aTJdhnSD3KtSK1LkeBKqdRciswcVnyUqDqdhmQDfOrZ2JMWPOLZIiPjqz3LO0rqfJapumGBKsXOSVFvS1FoXOp1n6mA6PuSfdA8nrO/RafkejHxwL+0MMz57Yr+m0CpARrkX9OxZAL+oxRqc+55KxKfLK+azGXpQ8IbCQVGgpVdAYJtR3B2N4h/FhKRxs4yjryinjDliE45M5QOe0jX3+K2//zPIchfaFjKzFhbO2QKeyz8J/0oNsdlW2gC6+B6iHLOGKUHdMdTDStGc/zTGcSPJrINxVWXaZHCA/2rBuHT6eMK9nTJcTfvibH8jxD9nm3clBr37Z4c3vBqrJY9y48FkYLJbInT3aHIjy1egxdxWGqwa+CccHOFQNKTvviOZSUX4QL7O6fViQTUmsVILl1YUMahtO0YzL+Hw+54AA6p3osdZbhIGwTXZSnplaCnnFDTUmPrimQbVZx4LBSkQPStokmm8E0ZpvtqJMLBeVQ1ZmccwQ1v1PP4GbxMDtn0tW4HwdspI0VBQ63SALXCiV97LqdPHRTYoeFTe4UHfO7w7L8c1r2IVcN4QYSlvwlRaZhAXO1Dm+IhslKoZRoXpP8m3GE9HThjCJaKQRXTR8yazltS7hqqB+H8P6XMAWoqcm5PkYjpDlqQCIhkfbqphjLNJeOJ96tWYueA9/fYnmczl+9U7u6fo7IVRxHKKxr9yRR/BOQquoHVgqjs30813M0NOSWJx3mRwAAIOSZfwZZjqWQsnnQiBcV/hcxjCJvMHMSA+NSB2AYriQjXN6vGwxr2qM2wbTSq7LuayJJdawC33uLH/H/rStEA53q1VEcmAN0oyDVdeCbnVdBBzodJbEmud4nA/6bq5ptJSTfBbm+DE6Zq6ugpNjkF2koILOlywk5jcrrR24kBK5EQ5qYjSW9vSMOqBCpcEpZwkeRUWHYQGKFKkehgKUoPnOLZOJuF+tpa+mTYs56HOxAkqiScjHYTUXa9Cx/3KQppTJzWjCnK5rScLfY7iKfIxHf5NtmtJaW3ZyUbjSiUfs6hjv1DI3QHrzASJluQydgBqKjJ3oVh1UL6YfpOTCZi0LTJ69oQt/HctChI1f06uJMIX7qUPY7uJHHg+uQntf4+5nJ1THCvNqxou/9TGwmXHxqx3GrRhM9dHh8z/gAXhUvcPb31Xhya/JQBouamwegvcRBtxsSeq1QzXOmNYV5tahGjyGiwrtwxyLQUOMNDd5oEqt+2kTCLi3E3xVoWbJGFu2gAYWvaYx3I/34h2Ms+qcOO/hDmNiy0l6rdy/r2rps8pJKELvywFTiMc78YJcFUqqUCQwb8UJaJ45eB662dtw4+Eg4ardQYpwk2/QVIK+bVq4Xa+LsdY/s+jU5Rab773D69//FECNyx/0GC870VqxCzNhdJYgWndw+wNcyLJTI2i7FvG8VlCCRPF9Dovd3QO05ItRv9eFfBxjeRqDeCWGa96c2SwD7E/BUQ0DBOFS9Xy1fFEcS55iqZw3HLM5gZvP0/dBqE9K30Q9uir1zHW8NnBAKHMURGvf3ck5jHaThDAjnJ8QavNsyTCfYyabeW/WkOUas9+jurmO44cI0xQNe+0Lailxzeg6KcF0vUF1HDGu16h7j4cvteg+q+G3tW48tvn9Ac65WC+P1zKp9CpfEioUKFrI+xtHHbvzIQqvsn8XGbyqhVTHxJSS42opGqpabj7nhl6aq8djKJezHJvR0a6WKVdhLsd+OBFeBTBcNqj3E5wXh7XejUFQcxb5hmGMZcp20Wl2U5/xWDOKRLg3lWKw/MpSFnZulFn5ByClyJzhTKqjwRA65wyNjPUqGhZD3AcdIGuK0m1SRN8PIzwGVJcXYqiZbGoAwsvaGr2xJ9fwgL6bRKctlPLRxsSAq4u4NoXyY4uC01W219h7KPDGFsBLKDDtjWPsN7Lnj9druHFGc7sXEfD9Ee5uj+nJpWb5EyjQagdAyskaR33WojaaGQtFioY1xB6nyiCHPfqbof3F+z+7gNVKbaHnUWqG/+DabEHNNpikqacaJioXg5LXohuQ8RrmGb5r1etp7uRa43p5fHsrz7p6IS/+yd+V3y9+sOzk4UM53/55hbuv1mj2s/K0VB9rdbo/jk/kGt3bIdzXcmCyfM4UFqfmfsC8yeQuzsDe/jos5GEQkTCayAyEpoJzdpGlR5Av2mdSYbXloadSM9fShfhcCJSNgoYNoWY5pjaFWLUZL67dyXPsPwxCeN3p96MQeZZIAMRFXrlfJTKrFq/NMldKcyQTH/wiZRxK7Zyei89RHbPondTsKhyvY+hMsoIj+jgMEoIwC5pSEEqFnzNETikKpQwqFTU2nrWrxFBiqKSAtunhWtQ4Nb5KrbsL36FDYcM5oaTN/Pb25PGLrNJzGVCUp+h7zUjU8OOZskyqXZjPu3Pz0IZTLW8I5v2UECnleqbjP+lDboYZ0i4nT0M/rIBRatPTEFYtGUhZFlwRVcylB4pOTEZlYb/YzNysf2zTPs/R2VK47VSChE0IYgJMYV9UDue5rEL9csHIACK/7NRhdm0AvnC5pffej/1T2DOHUPqMVqE1qNlIz1CtuIe9hNPHSaNZxULsvJZKUaUJIaeK0P/F+z979nFs++JIFlummeWJkNhmU76di6U8AsqlJVpQR0gvoBIA4udZ+rGSYptI8nXbrRhPAFQbxlrSLPMRCoG6YZSJl+lvHJ/I75PVKdw7/Tluge6dR30Etj/0aA7A8UkV+FsV7r/uMW6Bi+85vP6FFs9+dUB/06K7HXD4eIP2fsTuSyl35Xgt/dQ9eGxeUAXZwx0HVIASqueuRtVP8E2F+jgn2YaxInn4Ww73Wr4M1XtfvROvIJQBcQ97+KYWy5uD/ki+jlkAyBHJU6bzMA2vH9BNuS0XS3TUtfxui4kGj4PNT3McK2ahVl2h12FS3FyhfrPD9HQrEgp8hoBAJUbkOCa6K1PnUPcew2WD1etJF7uiIGqYzJ7PZDOt+gFoVqh2gobpYpeRKT2g5Up089EyUIbvwRT6ugbmUREp+bBCKdyThBQDUqHFucnx0owho9M0BETNimWa8EYqj2D6hSWB7h/gLi/gbu9lrHFdIIehMgZ22y74U9TJItKnCLgiXPG7wu8xfZpvgEZ7TZ4r2/x0fcnnSqV/V6Qyz/wM90XjSp6xDkaWILpANLBoBC2MQbtWWgHUuo7eduZoOueSDGsVGWb2Xh62PdeyUIgfiLZYNNCMhTYNXysiy8exVAB+N1/PuQZYg8cHpGmctLj1FBzR9n7E9KzFGBD7ueG9yfm72x7TzQb1mwfpQ/J7YB2iGr6FhM4CCgZmBwPL0jUmnK2Ne9DGlAiCMQ4N6q7HhoQLO/b8IaB//QBs6uW4A+Ln+fyePQCz1kAM13l/0LnjLraakZr3PZ1HfyFOdvP5nVxrPy3eZeRVmXV59pi3a4l27I/A4WikdsJz54AG73UYNbrF0nsuf/aAnFMJ3m86+FWL8ULe47it0d7NMUrD0n5ErRhVgTGwD8eASE8h2cRwFYnSz7NG2WLEIDWw1O44JY7+nvaFkSy52nISR/jaLNDZRr9IFTfNZ7H0U8Q5wCwmhOebOtas0sXgDCLBhV8JpXKN6+8u0Zz2noPUw9dy3amTvxEF2b5YbnY00u6+Ktfqb+S+hsvTdm1/Ea7VVgKLmjaHAT9cLVNhm5chTMi+UsX7R9jQw7jUgTrDmcgH+VlEwHi1SlDOOT7nkE5/3ptIrhVEGOs3OzFyEGFjTa0vtDmk4itvLvfU7DUY4ycXgokYZjHLhU2TRuNNNXsyA6v0Xc6ZVjIwXV2rSv5ZvhV5BEwyMCT6RcvT+QuhH1ckuoa+IrmXwqIFT1ObIjdbMQA3mxhyPedB5+uAqSO2/HL6GTlIfpoiYnQO7s/XEkUcC/1NBgTlP5hpuOow392H659B9miccIF/KBPj5Zb9yd/PGVh5VME9Yu5Z42DJrzqRqIRoQD0Kfea9k75xv4fvGjR3R9X+K0nasO0/DmHnYJydleVQXppBvXJ06dw6w5Duarn+nmx0FA7HGA4/p7NlM6dtKwl7h3Fc8Zl1rMbScWeJ/ENmXObSObZx3HCdyHi477tW0fk+dV9ExQdeyyknj3zIYt8R0MlER0tIm8siERqud255j6X15QuMbeC3amR5H7MDmHraSuaaoxbWIo6dba58mHwz4nlNGrDvBwlJ8J/lhdlYr5KmUyKw/sxLMGxWcOOM6aJDdZzw8EmH7p1H9y529PGZpGo7OikEJ2g1h+fYvJZzr1+UX8Duwwb7ZzXuvlJj96Hcz7h2GNcO7c6j3Xlcf7cHHNC9DN4veQUatpNrkdd1LrQFljSx9ZuA8O5muBPIl6JTwwh36IXQO/uzxhSqSjObbLOCblYuYLGZkv9jMqMWje9wSDl7eWFdzDPcvo8G1lTwPpoG1es7vPvFJwCiscw2MgzBhYv3xHFF41wzi6r0Wnz+rhU+ROWWWTb5RpVP5ixDTLPBcnK7i1IMrmmhHDLeX/7shZYW6Rb0SlP1q3RzzWsD5miaIoy7g0heZDphaszOM9x2o4hm8kw813vCHonhVQrVcGMzGUGLrFGOmzAv8gVUN8WALlW7HvO6xfplD0s4ckPIbA0I+fz67bLf2Vd5xqeNBoTvUa7kfeKyuVK73k8pxd9+btGkwPfRTFSOmzD+F9nhOdqThdQWBhaRAK4B9l4zR6F6fQc3TOg+EwO1vR+Tn1VA3KZ1mAdDwTCqQ1Zd2yTvc1HTDmH9yAjo8TyV/OvSqE3p2fwgiQ8aqs4MON/38OOI+f5BSN+7bP1VZO0RIdxcWoHrKg2U3UETWAhA9E9X6J+KMVE/9JhvLuQe3ueIk6dIHTPuyTTuWDLLVVHg1UqZBPkbAMvIQE5vYR80KZe2Gj1Wrw6Yb7biMAe5GzgnRaJXQQD6QQpW+/uH5XpqEhDkXrI1krdEYW1rdIZ/min7BUOkjy6rk//hj23++ZPIVLL4ZQtNMukpDKgeX2GAcaE0tZnkP2GSWc8iU3hVns71hZCkKUAGJLAriwOP13Lu3SdyztufkRdx+DBO5O4tN1T5/eq78hlJ829/Pi72dXDo24fYfcOl9NX6ZQg73Mvx3Z2csHsVESxFRcI9D89l86eRtfrhvX63CuEJnXAUoAMWG10Cp/JafE8kLZ5QKAYQDQbNekrDGyc9ZJUKSDkz53h7+UYbS0gEqQjL/eBYsJtlZhhxk52/+pEe9ub3XgMA2l3IGPvbr+Tc7+4Xz0MNGg0/csyNU9Sn4aIS+jfhrzExQ5XBs03CGGo6mRkOUhg7Hpv3XcITU/HYtLZake9oQx1Y9nPZw62W3j/H2CojvxZQIM2We8hCajabMCdmnwsTllpuaLGmnc3iU62y1CDX0ipBv81vVsoTuf3Faz386tvCj2o+E+6Vf/tOfpJDZbX+2A85Zyk3tFDujzxjV+d7yWM/hVjl4UVg2U82NK9GUmZg22hBnlmWj+uC3pnLEBEdM9MkGdAAhk9u9Lgq8G2GJwF5GMMa+moXfk+TM5LnYl9y/p3h56QhTiLKKapZNDqzIu8xkcJU3giIsu5btsi39yJ6zHtjcoxFlinvwUPC3NH98SaOS47j6QP52/G5XGvzD17K528MV5DPYNcPrp3hHtXpDw66hquB5X6c9ZeNjmi5MudkzZ79wiian0hYc7yK3Lf2M5lXStlgdYm8HFrp3XLttO/CcMIBJLVTF+PYOBJ/af/vLM+Pn0BZnVJbZD/1vfzN+2jMcCNd8LWcLPr9sCgfstg4AifH1fUylFXYKFSEct3FjY+cJN5HVmOMcgXVMOHye3v42uH6O9LBmxeEruXY8TJOsNufT7tw+yOP7Y/k8/uvyzV2H8txh2fkdgHDhcPm1YT66LF52aMO3Ke5y0jskwdmYLpao+pnHJ+2GC4DR+EyGphK7CwQZ30thNwoBXHiZygxgn5YlKhQiJjGysNuqceTe7zAaXJt4DQVUc853fRYMcAFAcHkPoKYpVwre3ZONn53v9fNoA4FoW9/UVKa24fwrj/rMXx0JQaSUfwGEMNI+yV6CoTJ39RSFNZqI3EB0YxCQ4YtFGRNflpdKiwdESVqanp+6DMTJnRZ+Fg30rzfjSaUFLFuItKcc8dsqzJDqq7jO+FPJddHB8h1LXA8mtqEGTIC/uq0FFDy7ET38jT3vMJBkFWwJYuQZRbGZ4nhHDXgC+Hzix+EOmmH4GS9vIOvK3EY6yqRllmglobPqsaVzeqEea8n5o+G3n367HlfyDNOEdkwPKt8Tdb3vlot5mTy3VMhFeciipGPkyp9riQ0M47wx14zMLWFcVrvetSBAsAkn3o3ouon1MdJhYRZKk3J2ZwLVkA4T1rRfs/CeCURS0OB0f7g+2HI3GRC6xw4ZeyW9jM2Vcc/U9Ir8IwdNfSABWLj2wbV7Q790xXc7NG9PmB6JgaMllY74wiVmhpbtjQbjIHV1Mqv8nT0CKhYA8ve7zjFPUcTEuI4a96FxCKu5as2iB1XsXj4KWcrZH8W+zJP5tBjIpqVOHpfQLqB7bdsZKmXpSTaQrbDIgswq9dmGwdvbmiVYqIFQ8vnG+q52HlmaNEDqu+XLyE3tKaNhwcw3Hgcfkks+Vf/UAlGlh93vyD39eaX5A/HZ6eRw9zQOlW3EEBqaHF94EAmtFsYdCoOqZsMN+kC7H7K0JrjBsRCx8XNIDMY8rIQpeYz46KYSpsZWgAiikVjgyiCTU/OG/f0cEzzULivzNBKtFxyDZpzTefJmUmacaLOlrmxLQvbKMJsCiJrO0WKPneNkqH1vnAnsDC0FLkqlRwpbUAwaNV7Wm5gKc+iUDpK+WkndHmS7/KZDVeE3rU1sE42DUuQh3e6JNVJg+p9XJZcZ5DHnQm35s5QkXPHz+yGqB59tj6XQmk5NYTtzPzXTMyAIhO9AFIDK2+aVZxzKkt9modSNfR9pp9L62TJwMrvK+NZaXmoUjmorO7l2Qz7QtMi7Y94HpcjV0ZGZtHCGuqOg9BIQqKUvdY5rpoaWufeCb9L9D/QPZq3h7KBlT8Pi9HnKFaJZ7fYj85wQa22HB4xFwvttxwuBID/fPNfjerdJmPM973RyopZFLrghcwqkeH3cTCZ2L0fxphxxGbSyV3XJpwTihpyAVWhynUrafW8h0Mfs0xgDIeuFah2u4KbPOZth2krA/DdT8u57r/q4CtguPQYPxhQraTjq08ZUgE+/I89+kuH/UcOh9+zx/zQ4Ms//Qqf/qqEp0ikb+4dbn5zRn306N6NsZ5hH4yLaYYbZ7n3GXDzjOHZFtO2weGZ3FezF5X45nYPX9eo7vfwF2tTZsIgMKFoqzsOYpTOc9TMMn3rqgq2tpnG5AnNjpMgNuMoEyKUM/KZse1CVqFmB9r3a733OWSaVlXQ1XJJ1p1FcCpTxDo3IBwL6I6iuZbLI7j1KgiBTkBVw61XmD6SUMTb3y2L0/qVHLN6c0R136O6vRc0rIlhZkVEWYneoAnJeMrKiOgCYUnhNgOWmTfASaPU1TXm41EzYVwo/SOfiV5SdXkh/XdzHZELmM1hDKVWyIHLN9uQ0Sh8szkgjaGY9AJFk3erC5vNxgOkwoAiM0Qnp6hzB0SEQ7mWY6KvB7O4uSpkAJkwldXVWnC7Kif3yPDtyiz2tYyVxIv3XjcEdzjGTc85QcedU72h/Vdk/NX7GavP7uHe3kWu6DTFcky22TFRVYuwneO6yMzGkCUZMywzdMkaRuc2DssBC9lUyXnCGq3raZ7pat6Vn+ZlRizH8TTHTDVNikg3bUX4lMtk5rx5P267kfM8vVZEi3QOH0SeXT+jGmflplYHZmbL2umdk/dYVSmaBSw5j+Zvev/JOMvGpD0uM3I10z43KuZZkoCCxpyEy1YyflVUNgpo+sMxcCQD4tm20Zm42AJdK7pzTdgnuxZamgeIIbILqT/bf3yF7sV9DLfR0GM27igZzL7vRVJpGFFRu40oMMvy1BXccYiolhEg9UFtnuuxO/bCVTwa58rMSzSSGar9G2SG3P6I+ckVqt1BogFcS7YrjTypNuT+IFnOD7uUxmCyjHXO2Sxp88584IJ7k52co+d/efzzONF+e8KFrm3SOlWnsght+JDtDFJ1UgMnLED2Gvq7GaR+1SbE+QWZ1XIkMs0XWtDMULPt8vvyDJpxeKzx9S+9wk/9gR+ACp594FxtXgSj6UKe4Uu/8AJ+M6H/cMQc1ibqcvXXyxCMEoWJanFQGS9u9VruebyRCaBZNqtWan+tmuidc1HjpLBhEbMZyolOe5qLzEVDxE4MLMBwr2RTscT3BS8j41CUBDjPZp/ReFFRzFqfS4175Y2EkOGLW9z9zCXqo8f2xYhq8li9Ce//Nkxek47uL7eyAW5ZE9Gkqp9q7IO2SRcWe1yeGRaSSah6n6hL5yExQ0avnojR6D54llw7aVmNLtYUtYkJOn/zeoRMcqmjmGRiYNmf5l4TAwsoZ/yQU2Kz0/JQ6AmP3k9z0cACTnjYapRlISL7HjOUi56y2x3RP9ug3kvdUQBiYAHLsFBl6kPmtfuKvJHwvFlYQ8Olp5ot1m2Vqtkyb1xDdQWBy3NN37lFKOd0Q7cUBN8PaQYknyufx7y/49H0U/jOGdV8rZZxGFAdR1T7QaMSOaKldIo2oLCrTpyAErKoyRmFtecx4SJF2kNtSuvskOfH+6PhEUq/ufV6ke2r37VjhvOF8znnQBWep/s88Hb7AQiCyjZka++Pey8zZLHbLyIaJURJ+5nrC3m7mYGVNGukzh4IdSwBRB3HPLFjnuHmGfP1NvLsaDSW0CuOq0yGJqWblHmyj0XTT7Ufy8iyBLCUUFZFTgg3AxJObcYWF+tMc6soqDeZxWkYxMoPXkos9xDOYzgzVv3V7U2B4UyKQFXgx0n0otoaza0cuw5aTP213N+0CgbCrsZv/t0vAQAuf/cbAMCrPzjh1R8M5woI13/pq/8fAMDTTyL03T8J4cObKii9B29tkxpFbpiA2sGvatT7AdO2wfq13PvDV8JmzzI82xDCc07reqkeVGGx0pBfoqqdGaYZ3ympRdfFsCQ10ABjJCvR3WmhXjl1gYsC45mXwpzZuXFMQ04UucQ8S5Yr779QZ5HPNn7lGS6/J57j8aZG9+aoWivzzeXyHgr8CWYP5oW8nUFB9O8h8SIaFJmRlo978ltshhNDXWZzKG6Q1A1i472z3zIFd7sRLDIh6cWGuZaURcm4YJbbcJJcPIzLENcZWRjNest4Pvp3k9CSiwmq82SNSxvuME2KWYeQ/dNAIM5DiHWF1afvMHeVls1Sle7MCHRdG4uoZ/euPEY7975A5pKOoa4L3LkhIMIuGgmZgGX+rpIMQzNXAcQSMX2Ktp1sp8QyQ8ZwiQ+zcKJDFATTFAndr0MyQRgfrAOrRlTBIaQgcEK3MHXxfNuAZdmAwjxUAy0DAuy8OBE2eowxlszXlYnuhIw5dxmQHNI/stAcVgGVr2tg1cFfbpchOcP7dG/exT3yXZQI0bWe4U5ThSIfhyx4DZj9Ve8n8J5rMx+CDhWRf2ckJsLFhWqSO2LAEnghSBMyJadth2kbal1+9np5HMeiQbhd16b7jnUcAYP4m5A4UgPrDIp1tj1CSOl8K2pecRLTI84NrMnA9HzRNJCGAagN1MrrUE05HK/hkgC9Jvpa06SbnGcar/ei8m43CG76XIiN90rjbPpgg/owodk7NHvg8LxGNTpsfyNOlB++/CoA4PIfkRc+TDUO/wzwS89f6Xeeb3bABnj7nSeYtjPqXYXjjcPq1sM3gBvtwhE3Ht81cP2IuWtQ9bF4NPkghw/kPuZgTLkhLixapFjLCJEsnnIJAMRiq8EYckHbKnm/LKUDhJIqfQwRhT4m1G4z4DABKjwKxAnP85pra4iY3JqMK5JwbIY+hg3HCeiCwW0F5oJI5mLhbGo0n91i/PgGzV7qTY4XLZqHQVFMXSDsZlA5eR+c5HcHQSwYepomuNlo1XgvXhj7J4gNuq6NJORpikZ/CbEI33HbDfyx12y3mCbtQ3jQwz0VNEu9O4YfZi/Cg6Gf7XvItcEUXeyiER7RwEJ4RR2W0OecT10rC2nbYaFyz9p5hj+imwrHqRFldJWTBbCqU+MAMGWEhHSs43b2uon5KYjHcmwFUeIcxeJmVd3v1Cj2FxtJD59noK4wfCSb4PrT4OXzeasKXkuL8LlmWc/6Ac45TOG9uMpFDsYpPmNBB80+u27WmVizGlNBwNJRQsRVCRnb27C89/o+HXVqgrjnIsOXY9bKMVAs09ZEPJG8USyIPPtEcFbLZ91cw93ey5rD8zAbLBSPbj+P+my6prQN3BEx07cfZC8oRTcCmi8bbOhPZzds85wq5xKJ8xo2N5EWsIxbdi2NIJh1TcZmysdy6zX8cJ+GhCsJWVZGWHrermV9amr4y21qRA1DzOADYvYd1wRzX0SDE6RtmoRmcThEgvh+D7fdwh0HzE9XABoJza67pRwTjbamBh44ns27b+MaKQ/DPgiaduu1ZLDbvgroWfM2PMuhoMm3MmuVXXvAxxYqk58ikZ0l4VQ0GWYw1nU6Nr9g+7GQLCBO7JI3vfB+zkHeHJA5fFsKxfA7ucKsLQNCQ4IejIGNPcVLc2i60Lo36UtkOZ2qsC6Of0XCNJdrMdC+/eYpAOB/9bf/8OK7m6CnVTEN+U4GZH2YFH1i8WcSbbUa/ezR3Y6oDx5NCFkot6WkUs5QWrJwoLiI5/pTajCXBCY5QDN0JBEvzHWdSqV2zqVTs+XHUY+mMMm8CtKFz2hYF0JHDDkwu9DtB1kHTNYKJzb7dnwmhp07TloQeAGTF8u9ZCEMzaIpwNt5Cjz7r1Suh0gT0bdjLwuySbFW5ISIQrbJJP2bccOS28pUnmOIeDmWtGjxLiP5npMFsQZ3CIUqopWjseQqEQWwUhtcEzLEE0DcKDOicfG+1PgKYyGE7+tDYQHgIYoytaHKxBjDlxSyTQyh2PzsH0W2XfTFF1GhLhUSz1ocL0ZHKm952JUZoHPmnJnzlS+WGmXFBIAsAWUKqH11LHyXKf1cu4wTrWGnLGM4Gev5uvhFMsry7DnbcopExhsqteQdzUI3YFiMxZ+HDyOHCRBDyOdyEizwXKivGTUrMy5vqWn2YkpnOStKbdfCpoHWLMYSTbOGmq7fWdahOzeWaLjNmeFmmj8RGi2Ou/clHT2i/VjEd7Y/tvnngdmjspofOefKOUGyDEkdjNmXCKIFL0A/gxmozCJqWyWvswAnBdNYcFJ1VEbhazmSU0l0nH1cMKYZ/nKDeduhf77B8SYM6IsKcwOMG4dpA6xeS4mdJigTv/05Of7qD7/AZz94iqsP7zH8x08x/eIDql/fYm6B1St5ptVbOebyB/KSW/KtmLrqnJrBLDVRGfG9ej+if7JCcy9hxPZdD+8cGmY7hQwdJUauOqmm7mdBROjFMo2eg58DXTlHEoZwbQtN01Yid6aRRW/OeK9LAcuck0FDsYrE5yk1Hh15SiSJ2s+ztGwdX+OYKp3TyDr2YuB88AQAsPsZ+dm9lmeo745SPBuCLlaHXsfdvJE+mUMoor47iofN0kTDGInNPlvQmbLtnBhArpLFxcXxXtQQCv2v4zTzpp1zwHYjKKMJlc/v7qQvD0cl3Gpf5s3KDcw+CjnqZmQ2dRsKsu+3wJ1StCQkq+j3SiEYJhjMXvqH48joqmlCjQskbGN0asmukISjRHI7joEoaWENk6qC367h12HzfhcMQxobTQ03e8xXG4zXa/jaYfUPPkv70CKERFSPx5hsAGvkmmcyIQkluRO54+2Z8KD8getVrbI5p7ITLepEQrPrWiR6UKYfEmK+jSBw7Q2p++zHyMsLxHe7UWrZmpEPmCJgJk3eVUK+53sGEHWlAkLrVy18XWP4QMpnNQ8DqpAVrjxKhr43a0HfNysxtEr7iqWhOCfrAvs2d0ZpsHPN8V6elaWgLGeYxnke/rWJGjyvdVDUAK7EILI0i7oGaLgDmL78PD31qztgf5D3EcpdJUilfQaikXMIUYckJdsSTTcmJlQO7uoSfrPCfBGjCtW7/bKPjcOE2cesYia/2GY0qrz3cKsQBm/bOAdN0hEAuNe38lzH43Kd5LiyRmVuxJ/QdONY1D6q61PaWEl3nfrgx0aygMjN0gWkWG4h4/8QXXgMivGIphOdG2nJs2YtJhOfF0OGi4iLGRkBvWDoaHU7YVqRkyU/G+p/Dksb9P/L3p/F6pZk6WHYF7GnfzjTHTJvZlZmVnVVd1Wzm91mt6mWBUOSacvsagMGH0xJLwJoiC9+MSzSkkXSJtkywZkiZfPBECDKFjwABiwZsmFXVcsaKUMUyW432WQ1q7pryqyszLzjmf5hTxF+WLFWrIi9///eYteUVTeAg3POP+wde4r44lvf+tbuC5RN6P9LYrOW/zWxH+tvHhbRCQ1eHwAjM62+pBuXBfFzKF/OeRsHeM5Qywtjzq7oJNYdtj2Xgs9tIv49Iho8IBifK0My0dpkE3uy2TlPp7pKbD2OpqwH0DeuQyhWDSaTz/IAsMg8teaYLGZ2uJ4d21/M2Z+In5TKeNK/9WcZmKn32HPI5WHDI21iGTHXLy5IzGzBMdE/fycXls55bUkiRTq55nUfk9/qGc8dzqMG60j/bDoezD5vfG4ZvIb/628+e+4x5LXQjjaeXK2ZCG3zkDmACGjz53du06o0E/2fiaZ16w+My8e2LwWSs/FiruUA39gILI+UXeOWa03tjO2OLNq2mYboWLkwlqvwBH5kfJC+8PbypAvVEp3pjDbv4Lbb9LrK/d0cHot4fJF9HCm7JWx/fs/PXbssIUOKrOswqMznw+Q9Aj1qP/kzqvulM23phcPHkC8Aj9nJZKzVQdNc3cJnXgBgHW3fEZClW8wgYabhBeg20e+oE6qtH1T2U15HS2pQnZ/ClwXc2QruzillgqmahtK/MjAMVZl6HgEqTMKrG7og9bPDoIIBlw9n8vwrhy9a8zSAszDf8Xfai+k5cnWBcVUKg9Wd0u9hVWBYFTC9gystzOhRtCPM6OGNQXG1k+OWc9WFRAE+3lz8zJNCTym8JKjkWmzp5DURR/MDM+NHJJSwsuZ4XhPj0cwwM3GgbruQjeNCum52HZk9KQqio3lSYZDJGoXrDXYfv4AZgXIzwjWF1IwUgBXCEm5ZTVgs9m9hga2Y4knSQEpzp31MdSoHGWUxSXTxJwcbrNFi0XYAWBOxsV7JaaG72tYEzLFebLefAKypmW0w/JsTI+flnXhcqLIQrgL2ZrkIVi1hosoyhOQri4aYt+Uislb5AJ6zWFmWpTCmoSSTZ/GuOl53Qitpvkf8ItSt1IwQ3/N59YNgS6Ov5wQYzZiwAure4IVqYDd8yEgDpsDEqLFT/55NMNAFqvXvvM5e39NzNYRi4nP3rIkTnQ/aW5nYbHaP8VeKgoCkc/D9ELNFi3it/M0G8B52s4NfVqiugzlpkFBwFtqERZ5reZj4WONrMqTHICBIrk1klY3JJvsZYElfDsyf95CSWW6kn6BtM0GkT3VSGwJ2TS1jGBdQttc7+LOT+WPKvN5ieOwIwBDAkuk25z66y4yG88/yuWlqmLKAsUoCkM3n/LfbbKPVB1sr1BXpqnct/bDNhyolpptcoxxgHWnCHuclo34H7TsSLuT2iyd/iDbKF1V0KioUASQ6mhxR56vpZGKW0GNKs/Ik078Z6dNiw6JvBnvhq1xzUGuMJEVWx47DYBkG7d0nLgAA2wdhoFPnnouYsk5rYMaL5w91z5nsvma9IxenluxCAC4Uoh5CnS4Wuy8+VLR1aJ5PW9AoFO+TCF8YDE3hH8iAMVlYJdkHT4o58s8HISBN1wUiKGA9ij7PmRfU0abDO9kkImFjFk9zDT092TIQDIPs+OACANDdI9akeTg1COwvQmgk3EfiZ9YefmCLx9fUB6HH1ePDGoFjOoDQJmVR8gLTOjwfBlB3Ffatw7f5dvMQAhSLwM9oXiz6yPURb7rMfJj6EUXwyTFxWaS51eyQsmSxpt/hSd1kLNKsliLX4WTp/YmTP3+GE2jY+oT/V+GNyTEwmA1MikvS16c6K5OPawdqGybH4ObB+SwLlOsh83p5+jXejfJfS74Ldbx5ySXW6elqB/m1zMT5xwpac78tlzU6PwUADPdj5m/5LJTUuQk6pdwiAYggIw9NA1MbD24z2iVevMgYcyi8po8vB7Bzk3beh1wTqeuHhmfNPSD9L0c9yodXtImNYqwndUWPuMfni+fs+UkSLoJVzHiHrod4VWXPCpo6PlNzAIcBK98v/JzMsHU8PnE1F1kwz2V852WJMh9OAM9nssJ1+pX2/zz//sw3Dr3xHWey0t1miD6kqCarlCobfLmFFaJO/Z/qvJSAcHQoNp2AK2YXOPQTiyzTCt4XNorEJ4NvSoO6syWap2kdOhZKc+1BV1GxZ1dCikeX+/DZUIC4CPdFufco914AVr1x2N8LK5IghC9DJpjtPeqbEfX1CNv5CLCACZPA4VB7u4c/XdFDZVM2abbx6vsFkH50JXepYLsspzSw1mCp1Zr2ZDooLGRdi7LoOKTPQ1HE1TXT6zmQYIDlSXfnVwvKDATQr8Px84QdUsDdokSxHwAD+FAvclwyoxe6FK51d2+J7t4SdtuRtme7n4b2dIadzsDULWcR5uh7KQX1/FCdaH/mxKxaOA5IRp5nXRl7/KimmTfvPWm9slptYt/CCyWVXi5lR6TMDie8pAszs2hkxc6LKK7bxnUHRa9zsqbr29RTvyBhXJltbCj5palT7ySoyYEHaZ40lg0kg5RbFsblIvZ+T5oY3/cJu5H0Za69SHhdklKmTMRRlngcIyMQzFKp78ymxlC8H11gyIhlEQH8IbCtJ6tsMTUnxs9Znokth37GA+PKXk0s3i7Cc2u3fXw9aBU5e2/C0uhoCeuAg83ABGDxvRnmK992pGHlEjY4PlbmetIXEs4bS2P1jIlsJBUis2efXKO9v0R/VqO43AoZIL5wOinMe8luTXaZj6d67OFkmPx88lwR9mf3XWR0eRGYjzWSmBakObqAdL5vNYeQlthPAWvmqYg66LG5v+qaHpz3Zsrm/OO4ub9I+86CLK53Zk1EoznQUk0unMTDXyBenelt5szk+OGDsA8Z0NJ9OAS0Zlbuh4DWnCbrENCyR3BMDrTqqxcAPTxRjh7ekg1B94BWGHEVGoEWufCTJivJyNIhw9B82xIT0Q+0yuiPrITy9jwQhQMrdWB2cM63GwfyF9B/sI/LTNmU/as0cRcB1HLxUwzT6/88oDXb/nEe3EwEL2FRIHUthwJadQV/fRMsFDgDMKW+tamnMBUv8Mzlbv7Hwgzirh5WnpIMM3dN81UoTxQc/tTb5YLOdy/o96uBtb44O9xxEe6WyfZ1c2dhXyokRr+PTKJs0MjnYy6DkT/LoF+ny0/80GYWd/r5UeGvCcDShqIvoI+TlomAj13Tg+Ww5u7tDGgdMznNdU/H7kUBWhIWfP5zNdE1HrvX+bMcYjriV5awvMpwVEKdQGRpBLBZEWRPtq3Dh/zbp6BGA6yDLS86f2RhfRRg5c2mIE8DrEnjZ01Z2NCHj9ybGYkyex/kLPmMFca03y+gF83vIyYCqnK+pNs/RnsxFd4Lti9s/4/47MUfTgd3VVTx4CWX7Bc3zUDzcWKQU1ZX4PIo3jl5nSdIUxRw7MptLYmThxGmH6JppNbLlKT/8mVBr7NQj0NDV0RF96+fobly8Hy/bx28AYrWwV7QqexXtP1+aQAD1Dce1dbBdg67+yXK1ounVRkm5/Y09MkDxd6j2gyAB4p9LLcjZnxh8rfbjtg674nBMgbjssSwLlBuRnQPTtE8uw7ZZXvJygIQMviO66Mmep6iUA8/rURMWRJoszaW6Zlr7JHFmUW2lIyTpFrARKNi4qoz7wsUiPQOqGrpi/6udrYHkPimDfcJjLqKzm1xeUv3R9cDiwb2toNflLDtiP6shisNzOixeLyHUX1tX6Pwxf5OCeAci29ek7/MbkdZqsNA4MMYGsy5dEXwKhJND7M8gXWQlVxR0Pc4W66qogWJMXQ/PnlGQOt2E0Mz8GCfI2PNNFQRytQIFa/CyPkKcG7SYY2keCOJbi/X3Ni0vJJivuj1Qs4BZ/HJhMHXvqmnA2yWCi+hIj1RMKPJGkyeXDTg5tTwTZYc4MlM0Qyj6LHw5Fk4KL43wza9g9/tiYHrU38pzywSnw+VOWg466+w0wmOn9FQmDiGTV1yLaU0DTCfCBI8nPQYoD87l+Eo3lqx03Q/6fBKWLChquNYr/dbV/BdH70LOXOQx3tgwoJOSg9pvVv4PYZEFLcsYVvyvzIhA/hFzFw9MztlAbQq040B1m5HOrCui5YDORjNAUw4Jnn2ul4tYLMwsIS01etjBpB4PAwaOB3edOe04JBELkm+qWH2wUfvQIHpJLMxjDE8Bviuo3OcZUjKORtH8iXc7iljc9/JwlUWsE0t/TJ7xYTzPEsbjh3qB4lEwBYxFCv3hdLlWeqb0Ro/5XWVXAuE52JmLEvOB4NhvVipiEX7/OXfOPi9b6d9x8OFn7/8G7MxVUHywVDQ5+GCuQmWf/LG32UNQLAnMEN8eCesFa+sRhdq741JbTJAAS+dbRQG5/51WjFrgAUQMAKA+nLAWFvYIQAsEMACIPUIl4/p5rAjAa9q6+AqYsJ4O9WGszPol21HFLcdypuWHOgHF0v+sI4tAK/qOui61gXqh7fwd89jBls+aeb0vxrgcy8l+a6xMItFpHKhJrRMGErlWmxkzYA0pVd9VhqHkfV1n6yeM0uIohDxtNEDtP4/pBabMYY0GGDVl3Ss29dDiGskaw+72cEHn7L+LLAygWHc349aqPGELDQIYAGLbwZNFGvhGFi0HfVjHKcZYdkkwgyj9z7UI7NxkJWKCTH8YTY7Mi9su1QUnnkzsZCWV2nGmINMw2SlO6MlmaRCaxDwUW4MzELK+ARg6cZAhTVaDKxm3MxF3AwkpXImpaUAugd0OZb83OpzfARgAcBsckXmxTX5ziTk4ybXVfrNDDffIyHpRB9T1PypMSAAPwHZOWOmtGOmKuFvbuBXC5RPNzI+CpgIPmZJVimzRqK5DeFF0frxQnugkODool7YZ/e0vlZZqZx4PrKFawh3ksVGFuLKWRIOofOiCohJIRlbY682uP70GbpTi/K2R//gLPY3MxKmGqRhmwfCjzKW81jAESl1PLJAYid+LjOl59DMh9DkWejDGOcZRZ7QQXHCiKrQ4DxdoxyAy4nI5gG2M+EkE0znPQCJLlL70nHz/fAdA1jAd0uTxRl/+WuIF0tP1NIy9ipvWp8lIE0G+LAabTuYtoPd7iXjhFkg0WDwQ8cPNgOuufh8eJDKJzuUT3ZSs8xbI6GaYk/Htgp6qeVTh+VTh7E2GOt0sir2DIzod3NJ2x8b+unOSqll6Mr08ojjcWnhSwvTjwImWUfE9dT2b4YwCmuljpRN0QP581aC8n7mnTNLYx8St86JP/OQ1FwBV+7DJLvtBbKFdungaWdCx9L4QedzOxM6jJ2hX0UXANgbIVQ7E/J6wSQT+r7JBkRuc5Yn/EwF/6JjKeXxO9kAezSUkp2rYyCKJ732QELLXMtB5lyqfRiwzU0Y5NnZ+mYz+ajPsjql1tpMuJg96WR1zKHl9XL6Wd5+NvZoEXzeTK7LOpRxpl/LhOlHn8l88n4RgJv7BSWbC+cj7+cL3Etx+0dCjweE1bOL6VyLGUCHO11MPmrGbGzL9IbHmrBTc2HffCEhIGn+fOi6rNI3ua4HxsOuj/e8hI75+Qy/6xqmrjHeO8V4j8aY/Z3w3LNcgVmgkIWXzGe555cW/heWSIiqhDlZx9B87m/Ic0kAyMliOFvg2ptdemwzmf55ZqxkEvP21fEjX4jMgNy4MD+AI7S+i7/CC1G1IJ0Y/f4O23cFZPmuI0TZh1T7sILXQkq5YHMP12QVnf6fZ8cZbYDGbYygC0DMFumHKZiaYXOojwFdN5WEh8rANLlQL7AMTu3lTYvitkN9PYoLOxuUtiGUaIN2q7oh5+FyO6LcjbB9NCbd32EmLtWRmT6AwMLEmlzCwAWQJH5WoX+jA+7doc/kLBI3ZZwoA5JiF5OU/HEkO4jR0UTGD5m1MMtFArQmg402KRzHyGzqUAqHNNqW9q2Alvc+1b64NAQDF2hhZn+sjb+5H/uW6lI2Ncx+wOatJTZvLVG0DkXrqA5hWZBwvbAwmz1cXaDcDtjfKbC/U6DoHIrOYTxpMJ40YFH84ilde1dZDOdL9G/cJdZPMX+8OuQBUxd+5uuQFGpmJ/dJeJSOkxcUAKbO94HRsssF/axWsCwcZ2DFwnH+n4tN88pQD0osEs3uH7ETCMJvIIIQzqrTdQ25vE0septmCfFkyYDfD6OAJgFubFERzHaljqle3OUhRdawrRoq8K0mCPb48Sd0ftxFCCOfr+DOVzDblmwd1DFKiJLvSb73grjXLBoR/FsW6meGorq4t7SMuYoZmz4yEiKpSIFFUspK/+jvq+vJnlzHCuAaY+L9y8Jv3Qfe9jDE8V7tT84DfycUsxZhNR+zHiv4c+EaSUh1tRB2xHYj4AF/soym0hyyy1zFZV85M++DAWe4b6TUiqPi1rMAy6qC89zP0CbZtfz+iySo6GvHc1eWTcyJGbs31ij3HkUHXP34Er626D92Qbu+IOmC2bNtQQ8x6HQ+TVBaZc//Imb8mtWS7vE85JkDF++JzRpHmWMFYAmoVGF9TqphgMV9YKNRteAyZRHG8CyqkT2DkqDA4V2oZ6zMFjl8LCEBS34z03coevY7aN8VkPWFm/8D/ZFTznxyJszGkQObySxLVvl9F1d8OVIeqYahabtIv+d+Pdw00DIGqEoR+EmMeg5oWRNcwem15hHpt+aAVndRotyOEhrMS0Iw0OJWbA6b57mGAVEKELUjvDQOUTBCP8J05L46Jh/Q5xqvtjhUdWRQ0UVI6UCObJdXo4dYHd3YYiITu09WT4AwnAx6d3fpM+58yj7x+Wyu6FoxYJ7L7KuvgndPqFvHk/UcqyUhgLoKk0gmdJUOZAzITKLHJAWaB7C5EjySMJIlDrwAA+Kfs4oHFDjIwmVuhiUQ0HQbwNImdVmf3S5XGAhhiznWS1a/vLIPk6L4mKlmudxIOB88Sbmzw0yW3I8vIDCO1iJpuGyWZcwBbJ7AcKTNgV/aUfbMzFznPLvqaOavzcaSI9s9VLXjhQTFLzDR8Zgr4/TMszHpCzcBnzOMdv5sH2MfcynEoec4+U4WMpspnp0/y9KV3eE5ob+3Trebs95iDRKqL5TFLMACoMToSvc6A7D0b9MPMG1grvqw4NEAC5Bn0p2uSUNXlTRWs0wEiL+ZVeZSeEVBYUprp55cc1EaJgAO3EsRxKbATPDLd6h9R32y8vbZiz9MX/Y+CmSNjRNM19Nqos9Wnyx6dC6WyihCyZUMKCQeXJyWXZUwuzaGB+Vow03GoGvfxvIIZaoF8lqIygPwogQcga1x3cCMDr4qUNy2wia5Rcw86+4tYAeP9m4FbwHjANt5FEGjxS7tw5q+050VaC8shoXB2TsDVt/aSZabzSrLU1886Yduw7GWFuOyCuFEAzN4VA9p1S96kmEAl4DgwTS5PojMA7/mu56YqnEkyn4YYsyfBzbtK+Q9TYJFEYWNwoS4eH0BCX/5UJKDy6XIJVMDsvSrKiOA4HIKAH2fBwkGWfzQdT38QPXwsFqif/0Cu1dpAtxf0Pfv/QadK7NXGZbLCsO6wrCi4xuWNtSNHKNHTchm9dbAtgOGswbV0x0wBrZp18asG2ZlOipr5NuWzte+nRRUlz6ocBGXNiJ2lVaGvu9pUOYSGfxZ5ecj5XLCeQIAKZ+jzxOfZ9aTjIENUTqHaQiMnlV6ToOYnydsBjhqItFuzn4cYwZi09A9zcWz9feMkXtXjiHXmqgQi18Tw+E47FcYWnXvs2Lw3kfx7irafPimknC8eXpFQFYP4Hn2GB9XUVBSSFXFumzsus9JDtzUOZtbbJCeyMp3+dxqsa7sO38tiOMTMJelrCei3yDGTxZVSsitAYyMFYHZ4d/Jc8vfE0sNLZh3E7f0hM2ayTZmhtWcnQLei0eT3YYw8lbJAXQiSc6SAWkigkpwQmFTmUvuOp6Fs/U10fMVdSw7Bq21qqvA/GVeeaG/pq4DYxaeC2ayTlfwpcXVT11Qd8MCfvGYnpHyakesa0sZj8LShXMORDBFujlLrH7Xk5C9DdeEFzLan07f+4HVlDlTnyOOTujXrKXtcwKJAz2PgMhcZN98Lr2nCh3jiPEuLXzKDy/Tc9r1lPhWlqHGpovXM5OfwLn4PFmTjl2A3Ou/Ay3WwVXBd0eTFdrnL/9GHIzy2DC3OXZCPILSLIdjsVKZgPnGXR4uPyDlVZj2zW8UbuKpZaSMA5+xYhMe7hDO86WF2e5hb/aw13STNg9ptd0840mYvjvWNOH50sJ4YsYYeA0L2s/122xVYWHGWDTa9KMAOQ6tuBM22QzngMOH5cx1l9BQutKa1T7ljMiLpBEzq7UOqyrRwYVrqWPr4YGaaE6O2H1M7oHs/vG8euKwsLUxFMX7DoPI8mGL248VGNYGq8cjdq+vEoAFgApGAyi3gcUMDOW4mGEBw2BdXnN9sHDvz9yLAqhCyM4Ggz8TDBfnmoQNgshXStvMMYhFIeE5AIfZkD4M9vr9PJNKMaESuskGqYmfkmWA3pFT+BFZAJf+mVQi0G3IJqRjGiSuM6kBFiAASzfJNq3KGJKHeq7Zb09XNKirkH2Wbi+WDwr3Ko9jy8VU/5QXEg4eYslzqABW8jvXTR1rmVB+tth0bn7qs77pz+a6FxHQp9dB/NByPz1gct7UxmcBlt4+h4qLZzcw/UiZhdtMrM5tDrjO6XSAqRD9BbRcedH7F9FACuicswiRaMoB5iUYrp5/8RLlzsE4j+pmwNhYqUIgYKVSi1AmN4qCFmSc2BHmQcdh8pMI6kR6kZ8vsVBSoVgGNocSL8L4J9svjty3fL1D3xhgzW5XFmJ97Asw60sWBfaH9/2dFLvr9l0FWdwO0sNaL5HpoSZFhQ/d9FyGAJhkC4pJGbf8hgmDK0LpAln9IAIYqJChGT0BmLB9y6vibvrA2GAnUT2lB2PxhD47Lg5f5OXjHs2VR3NFfXj603SDiQYr9K24aVHctHB1CcdV0Pl03dBEVT2jgYcBmDnNbladORJ0F9HcNWgC8sK6VTUpBqz1Tsn/CKumsoznMC+hohtPArL6ScF5dCIfI1MSfGcmk4JOG+aipeqY/b0LAMD7/9QKwwJYPXQYlhbGeew+TiBnCC7w41mcXMvtCOMgKcri+s9WHyHrk8MYZtdFZpTZkhMuWj4TymMGKzNzPAhQsvvbawqdhaGT4uspW5m0LBw4AbQuvRa0HdaPFGlfOXuMyxtx0W7VJJOooGxj3w/w29R1f84H71hLCkbvWwph8HPKoFSE6y7+HRjYxLQY8dmWbFHe/jBMw7F8DngRF8qH+O1uqvfM70kFHqOG7UhyxkzzGfCcA2G50FcyHvViJQMPie6IwRMziMekAXzNxzF5TnNvvkToPzexc5sTLvO40x+YaI9klyUsT56slX9Pl4erqzhvYOb51OFWfa74GBCf9QnoyzVQ2u6Boyvheiwe0rHXT4L84XYfj+t5VhZswMtsN88xs+BPjQve0zPJFhU5c5ezWFVJz5gxMFmVjMQBQF13WZTKgseJRhlA1GAC8Vqy9IAryLBWVCXLyX7z+/sYOP4OtO9quJDbZy/+cETT7KeTpPKmYs9Jyn8OuICoxcgdgxmVq+wgo8V2vFrKhZeIgzD1ywFlQWHDuoLPQSDfEIWhECJnP2kzz8xRevc2sRXjkrZVXdPFt128Cdr7NEBffbxEc+WxekjbW34rZFXxSiX0ZzhboNhRSrFpB1rZscifw5zLCnY/0IpvGGnC4JThLDtpkg02p0fIBxX+Dk+I/DuEBSU01lF1eN91U8NN5Z2Tt7xYqISY2LpBHMVjv/hhm9xLYQL88Pe9HncQLu35VzqMS4t+ZbF62GHzGm13/V4I95QW5aZHe2+B/sSivhzgC4P6WStldiQTUTQCKlwRwmBuFSwhmDXje4bP4y4bQHRCAbNYzO6GzwoIUJooCS9lA2FeMkf8zjg8rN9/wXIrc4BAwtFZ7brcf8coPYapSmL3eLvMbqkwN+ssWEYgjfVPZUnPblXCtD15XW2zxIC8XAyvilkzojRZUqKKdWC5eaR6dkxd0XPAx77d0bjGY4wK0ct+wzPC25qcS59+V15O9Cff3np5UsoHRxbDvABlfYtmvLJxQx9Tsj8NzHmC5HHiiJ1Mnr1mmhrmZD0thRQMdk1NFQiMNnDNxjQJG/VdDHWyFCVnY7KMdKkkofVOB8bDqV7LS/acD7YRLIOZLKiKgsJyZSGhPRgDd76O7Gpg2Xm8N6OLSWZ5H2XxGvpyl+Yi9pNkOYp5ehW/ojWB1hw2AC8sLVIUSeG7Hma9jIvMVcwIdcuKfB4tRWnMPuqqAUzC9wzO+BlOit2r0G3SePxQ5cUoISK7x3/nYUJu359wIbfPX/4NpdHI0m85I0e3FxFbZ00e4i5dtUrT/hwMtnJzNP6tPYiCvQOveM0hUPoCVdubx6EsxI4Zh/DGDH26/sChPTd48tO03f4OnTcvD2zQau0HeGNoci8s7M0mrs750EP4Uuo+LTmMcvjyT4Szc6vqrPK6C8JleQh44FhQ/N7U1SRjLm/5RGJnPNf4tTjRhwf5WOotDzzhsyfvp/fHK3+HBpfFwz1Ov77F1ScWErq9fTsUBr4NwvZgXrp7NUzI9ZGVUOY2zm78sy3PiONzwavOMFD5po4rUL6mmbheStuw980RxiFmAQbQlU8OSR9ThvEg2+L8RMOVT2A+n4z49TkhsISbc5ByhKlgu4fbaU3K2E/StSF4qOXjhjw7BxZ1SRcl2SJcryNO8HEHWbj7CHvlxzHx9YnF0+fHnmPhq5z1OtoOiYsZYEmYdIwAQiboA6HCXCh+LMs8B0lHLDMkmYK96Cbu6kYtBtkXKgt95vYxkhU9PVciGOcxSYfpJp8NYxlXOGmyRSK34I1nVlTw3C9iCagcYHESj9m1CcCabcoqgb78AuHm3EOLmyzmemKWul4VZFZliaDYstLCLSt0dxdCWpjcNZ4XcYFMmAvx5y1GP+aTMozO6M5qnH6HANbR9j0BWQCiqSIUM5H0JKYKA3g+0BL/pxgunANaRrshqzRemfwOAa0ZMJUALR2K4bOYl4loe/oJVcOB40DL1QWq6xFDEzQl4b5+HtCaa6brYbb7uIJnxH8a0vhrNSGU5bxnziGg5X0EWHnavgZax6h/QFYReW23fHLQ2U6TbBheIWmg1Xa0TWUDAURAooFWe8+gvUP/108zx29gArTy49nfo/4Mpw28tXB1SYkHtVo1ZffFcNqgP1+gfXACt6opqzGzEzgEtObKXiRAS4dkZ7LE8rqEuSmtAKMZwfOhUG5y7xzRZgDhWgb9ETAdC8REcL+ne8rYo75Lss+ioBAeD+z7TN+li1Y31bxnFr+/amAGdxhgaddsPlZOBOFi2QywFGMmADFjCGdB5QsuMA8BLHk/F77PbVclpYguTIe65louLJ6b3PUxjgfE7kDK+OTZ5Hn4j7cR7DsATE1wD9lfHMtY9D7xCfSKkdH79SFpytT1YYClmqkqmeABzDIpAOLcd2Sx7ssC9nIzD7Dyz+rqKcBhgFVa+mFtpm55LVK241AAa7JfrX/d7ROABUBChO0bJ7FqxjAm2r0cYMk8PndODgAsnldmFxoZK/ndbt+TcCG3X/rY/1SV3ggPtvb3OZR2bDMABCQULNwYqNUyPrghY8lXgWrNi3bqkAUXVr4OK16+oDNlAHxVUlZhWUiMnEOGACQlHMaEzLqw7zDYclYMAIxrFpQHAXDoxxhA1u0b8SZgIPD6f7mhjMJtD7+sYviQ938VvYN0tl0ivuYJgT8b6oLl+hrqWww1+X1Lzst60ssdqRFuXu+Dr8500peBK0xELuhwZm96XvWFMAyvlmS7LAY/WYLL9Jh9J9oePfCxD9L2M/cBAM8+Te+99l/R8ZfvP5PP9m/eAwC8/9+m77z6d4M/T9AGPPz5IFjvyXzWG2D9fofuosTiUZcADS6FNJzQ/javUd/ZFmLxKD4DNiRUyCrQkC+aDEg2DlbeGHo93F9m31F4mw06M7PWXMeQXMdc/My/dfYnAC2gfp7wWu69/Nmb+2ye5s+TUpbtBmOCzs6I59ZEtzkpX5KJjulN+p2L18MihBcyxjnKVC5sKERsCUDpMjLMsmkxMCD3atKyMLkwLn0GFKSfWdgtK3+jX5tYMByxa8ivXfLsKbAjYVkTPQ6TsBum7JuZGacFYOZmxtIxn3xHZ8NOdH9ncQz1i1qYyuR+zl3oBVRkoP5Wmdl6H8Ls2fzDY5C6n2hBU8bat0BaQFzAYeiTzr4GUlCqj321jPfIKov66OMrbKyzekx3lodMFSPF97pbNzDdAHu9TRIJWJrgTleUxek9gR3tF8ct15xxyO8s6IqVfQqTBc1vfRjOyYAk1HiiWHlrRdPleYzT4cJMihBZ5Omzl9tTmPUKn3vvr08+94/Zvr/hQm6fe++vx8mehYPKHG2ideAm4skjWC83ITyUaRI0WWImqZrXbAFnHenBYG4llLFZB7MaA1K3tzsRxRe8Igl+WcZ52HZEdU2vc0irO6P9lirq4VapQR2XgMlDgGygqNk0uZnPT+hhkfBbJmKcSUeelAvJQ0x6321LmhROCW7bkP1naBC0hjRDeUiQB1Nl5ijZeHlIZkZA7hd1ZOjCytyfrgFjcPOzr2JsLC4/WcGEQxlWrCFLhd83by9w8q6Dt8CHvxDL7gCx4Ldum9epb/tXarT3GrT3GgynVXhtgWFZ4OHPLbB5na7RPvhz7R4QYGvv0j52b59j99YZ+vsrEeALezn3DHBSAOu1TtdpeRGuHcchh4yR0s+bH4O2QmV/5p+Rz84wVvKascKMTAbgmdWlXKccfMyxPM8LcwRzTN/38ViAuCDgCa8f0me6LOIzoh4jn+u3dNP3qgpF+P0+njOeNLMQFtW2DAkCMxqpYzqrObCkS/Ukba4kkvOYCN65HUm4EICVZTxqRlrATg6w2NiY762c6Q7j7Zw27FDo0wyjZIkLyM29r8YxTsZsA+L8FGAfKQqeFzGGCkmxDxsXG/dKVO6XTZxLpDqGAv11Rf3PQoZSn5ATm2bY3INzjTGp7pmvQx6aDpVD5po/D35xp1kB9dkPu5TBzgFPAFj9xQL9xQLlZYvyMtOdcsujGHM+eFpypNnWA2OkOMlz8gAAc3rynQRYR9v3FGRx88smChfzGPZcRfLky+HBHEdiQmwEQsKKaaAVVvpU+Hl6owrQ4rcOgbTQeDtmiA+ulDVQQMs3VXwQZwYNrmAuhqNhG75iUXwEWhdfGWBGoD8BHv38GrefoAeQmZEJ0OpTijvpf2C+JJskCCAlU0YDq7xkx9wkA6S0PDAbOnAh9VrK2/DqX8DTAaA1N+AGmwNZ8XDfjwySYnfBz2Mog3MIaNnt9Nxd/jj19ebjYVANmGZ/5/CkP9YW3Z0GLiuvxECrX9Pv7RsEpnZvnR0+BvZMC4yrzQsa55+fCz3MsVjq9bk2x2Ida897P+njkRCOgJI2Zffku5km72iIjYWwHL44okeUcMWhcLzKtgUgyTZzTY5ht0v/z+u6fRvthbIOJ5l8R473OWGTWNsus3KZ+2zGHiYAC/FeeqEIiswRGfu0mdHYiW5sBmDp/eWsW66HAlQyR6ZByxMPCksAq7Qk0mZzTcT7TOYmfp0lC6fryW4569mFaMdBgFWVkpgF7+cZWn4mWPfF8+xMiE8yaKsS7nQxAVisQzZcIkc/F4fqWWbJSv3FtBSSJDsxG50DLOWfKb6Vh+6bA/e3ya4DjIU5PTlaNus73b6n4UJun/3JPwa/qGB2HV24YJpGRpWpqJLL8VBvlTaIM0F0GEHbB7BlAYftdKsrbD/9CgBg+0qJs3f2KK47ihcXBvZmR9RkriGQjEJLICtQmGwB4QsT6M3o0SSaqEm8uyAwVpckArTAuKwwLgrYALjKm2gB8Ox30fHs7hucfpNu7OUjGriGVYHqqkex62FvW5jrW6K+NWUqtZkq8kFpKrETMLsOZruP6fPjGA0sw3n3XRdBlnpQPXuksClh2FduVMnnUcxlc9q+bSkLkUX5LhQzZhsIPmfsw5UPPDqku9nCWEsTWWEJwDU1dj9+H+05fX9/l47l1b91ie7+CuVNh+IyhBi3e6CuMJ6v0b66xOOfqTEugOVDj+0bBue/7fD0pwyaZ7TP6paO25UG5c5j8cwBhmw7+nWJ+rKjrFEPPPmpUhjJs3dHuAJYPezQXtBgUOzDtX3nCv29NaqHN6QR2uwpHVoLRfl+3+1j2FStbrV/kN/v6bruyTHZs1YxF0Bra4+iSFf3WajQ8/Onih7z+/z9ZNvZ9jnjZwL4ZswCTV0BVU3ZWBy+ajtawGQCer1NYT6NofAIh+77gZ7vEGKW8YO9gwIrMS4r8sQzNC6gHyhsHowS/cmKxoLdPjBYqfCaj5MuQ+h3yG5LyuDoxeWxTEHtMm+L9Nwam4YBtaQib+ray3NeVSno5Yxw/psbZ+Qpk1U2VJUs1bzbM6Fp2ncqTTDGEGiYAUVyTbVWiK9vH8OQfr+HZA/q72ktHY8p/Bm2JBjHqEtkOYjK0JXFYABEZhipSgBnVA6OFtsugBKWi2gN4MDzV5pN6VY1yQAKQ3ORLPwRBeABrElWOdSiYNfG88bjLmeRF5bK3qjw+vjgQj5rugFuWQUfxgpidN2NoiuWedq5OOarDGVpVSXZvePdNbw12L/SiHnq8mvPpJ8JU8XzldhKlDDOw60W9LmqhLm8oWuUhwP1/an1fPoZMRbmZAVflfj8P/oL+A63H4xwITc+QInTMoV3aHXJVCSHDQH1UB1gntoIUCat67H86lMsv/oUAHD9Nuu36OZzpyFEEwpt+sLGIrPyoIYBXcwes9956iqHRxVFnocm+KFxhYFtx4NZazdvWty8abF9tcb21UDFnodMN2bm8mN3flIDixtfBxNq20XvnoxNDBXl03TtNDNHtqlT1PXrSjCbF6TWAAtQ9P0wUD3BYxmcPr0/2KhOBsXwUDZXI27fKDAsDF79W5cAApjVmwrXrLgivcb936D3d6/SOb36cbpg7R2P/gTYvmakluXiGe2XfdGqUIKpCa7M976YZa+F27m57LH61g7N0xbLd67ou8Gt32xmgPpuT95kxzKtls1kshIRa15WJ5gVJt/PFwYZmDIZg+TZfsC7w7qg3CvrgJ+Pvn+k5h+PE/zsKQD1PDEr609krMlLfPH+2o6ef+8xLrNVME++7GLPDFZWfHzueCUMekDHxLUEXxhg6f/z9/W+D7GKMwBL9zPZpqqnB2ASrp1kfB5r+ba45bq5XKoxuylHQE8BLADKKT3qgIwJ5/bQ+c3sRhLTZKhxi1nVJ5dRgyW+fDxO8jaz8CA3/t9aWuxWhdi6iOm1AlhAnIuGswWGsxlWKGwvSR6YO6e8/zJ8jgFeuNfdIjxrmQg9asuycWMuOSIc33iX2Lr9K/S81Jct6st2/jkBCDAHNlDKXOn5E5jeO8e82mzaL2acvwsA62j7vjBZ3H7px/+1+A97KHEZj5kU7YmPVqb1gApB+tGJx4jvKNtsrlzL5ufeBhC9q06+ch0+EIXHlusxAcQk5LqnzA9Lbubcj+h2S/1pu+iXcrKK5TwADOcENFxN+2AA0F/QZ559Oqy0C6DaeBgXQl8eWD4esPqtx7FfHKLLPFJMoEqFMg3Az1xvaEXn4uB8MHtIBp8jA72xshrU35GWZRLxvhLbhqokcLgIdDwzWQxQWZiduW1Lf3lV9NorcCc1Ln9ijfbC4PX/4tnEpLJ744J2+QGBHKbLbz9FLOJYGVx/wuJ/8M//V/gPv/wzuDjd4fFX7qK8tahu6BjOv0r7P/1GYMXGFGwybW47h7GxaD7YkKv/7Y7uHyWe1aVfgHifSVUDntyZUQJk5WrWK/i+j8BawlWqfAWAiW0Dr9yz50UzH/KdmfIuuiXZdPz5ooD2gproAHnyz9OwWWMyjnRsw0jPt/bXyTMWw73iVLIJQKDVsH8Z67KGgZ6HcE+2b15Qt0KigwBeTlPnMMz1LZ2zwBTKOdKLkYwtnAjW1bNlimLeXiG3u8jHbRUOkW2H86Vfp4OaB0lQ9wCANNysx7QxFGOfy0jOhMg5UNf3gJTRCl5psj9+/vkezUAsL5w8G8L2Q7QwYR1QVs9zcm9kZZFMmCdkP8w4AlEszgu3kFTF+0zGUT5HvKA2JlQMCeMWP8sSVuXzGvqnDTr5vbAN15RwdSFzQ/00ZBey+TF7A+Z1/cK5FN+4hnzcxjsruEAssM8fezZyPwxLEhRz5IcxgGVH17CqggY2gKvwvF1/hn4vnoaF5sMwJmrz7mGEryspdWeGkbSloe/9XTrH5XUwXP3waehDRrIAUzzApaFU5YXP/fZfxnep/WAxWdw+99t/ebbQ7uTESeZTYJPywYs/MzfY65Rc5YTL6afr3/iWfHT5YSsarUOCQACBNh1lQhS0r00l1SBkZvolD/ftFvZ2L269zGb5jM0qdrStk/emA9sY9D67+yXGuydSikDXqUrc2rnfM6m/eYrvrGeSm4LVY6nhB8FVsBCYgOe5xgOIAiH+hiY+v9/TJLndxZUm31czujQuxO3Dqs3fbDDeoVVXsekJXDW1GPSt3znss3T/U/TQ96cezTPa7upDNgcM131wsjKtnh5mnjRTJcepqhiYYUx0Z7mQVbdEt5LVM5QCsc4dP+ezGw4TjQYIgYU5lm0o7x3x1QIQBm0FsOZCT8PMNngSWy4o6yvoPjXASphhHkNmvNW6N0in2J8WaO9WsO2A8XxJIbLMjRpAmiF96LjU8zEBp2q8O6pnywHWDNuTXIcX0W5BgbwMuB0sf5O3nHkGIlhW/TH5JDjX+FwMQXIxDLP3g0yyczpMXogpzZ4prNi6yCLZZcBrrjuZ3YSpSupbUUjonTqkAJb+f6aJHhYAuIoIEDWAhUm8E/2Mj2J5E+YP/q4KdQOIhp6BFRJN2EyiEIM2VxfzYnjW0TlHEQK+l2eed1589HcWuHnb4ubtANjH7N6qCvrJWTbV+rsrbF+rsX0tNWCOFSkC61YWMenhUCvL7ybAOtq+ryCLm7dGMg3lZNl8dRWBlk4nnjywzouTbqwAng02B4BWf0I3YgK0LOCaKrmBAfWQZ0Br4iytgJYAPU6pzx5EBlpcc5AnhTmgdfKtEf3aYDyQYMIPkwAtkwJVDbTMrj0wmWUD2Jwjs97mMeHxEU8vva/JpG+nD48+x+KnpPYxAVp3LwAAN5+YESg/JpBUfHiJYtdjPEmvcw60yn/yGQDgf/t7/6+TTS0uPfZ3KHQ4LqYDNw801TWBsDpk2Eg48FCbyyziFWbOVEwypsJ9eaQ8TW6XIJqXPHwvur4jk1JuBfEihoeHtpV75k1Cjakg+dgxxsLtB+7DzOl9+9oRvyJmFLVXEyDXYFrG4/lZgjNvhN8vEEQw8ZzPbu/bcYNnV3dgPnGCWwasJqHlEBY8Chrz9zTAUu9T8d/Ifs5lnEpizQzAAhBDh1ntwFmAZbJ7WAMsYFplhJ/FucW0svcBMoCFCKwEYB1Y3JueFtzlTTsPsIBYfF4BrKTxPX6+wnhnhf39RQKwdJPnRQEs+j8D5JzFvagTgJX0fQZgAZhUUYH3tJ3SCoMVNxIBll82CcACEAX+mqlkjd/3yA/rUPu+hgt1+6Uf+6OQwr4hvdcHOlIurJ5sxDdI+eVwU7FoU5axhhaLG9X3vffRVO50je1PkIdS/SxMgI5YKbvtopA9FB/2yvwwoeabdNKSiW8YolA8eHsBanIoC/j1Em5ZYTgNMfqw/WJHg0J7j1BVuRuxu19hf5fet2HcWX9IfSj2IxbvXVNmJYOSPEuGyyHUFf3mh5MHrJ7766KQMvNrYrFrMtl7NxU/KzGzFsdOy/ioUEWomC5hzsC+ACEc4F26mlQhTBPSpk1RSDbJ5c9TssPi6YByM6D87W+JR4tZLDC+dkd0ONWTjZwDocFPF/jgT9B1+Iu/+z8AAPzJP/svo7sweOXX99g+qHH2Wzfo7izQPNrCNRzec+RnFc6hrCbDsdurQKNzeQ0WYrM/TAgv+7aFWSxE2Ov3e6VLyiaocM7pvKjHl4W41shEw4kIevKieoJdfL8o5g1r8/I9mXcUM8zyfhZGEkExC4FDvT/ZfqL/C/df7pjdKB2ilORYwJcW40kjTDLXlgQAs20lkcCXBUzXw5+s4JYVdq+v0J1auMJg+WRAfdUrAXBgKRUL7NtOwie5TYMJ9hlJ6RwWvefnCpgPEUqnD4cKJTTrfDzPhwTvyVcNtElzIkQPofok0QBQ9hq6bMs8eE2SJHj7LO7XAvhQ8sQUNkg92O8orUYAYBK+43NiTk9Ie8qZe11PYyqDoCykLl8NxyMWJ2F8jz5v4d5dLmJGHPfDGmJjckZLsY30PumdROs0xN++tCR4r0uYbojGnUHOwIy7aYdk/3kz+5ZCb6NLQm7cH7eqAe+xf20Fbwz2dwssn9B9Wl3RvmIkxVIikHPAzYYSifpgDuxGGpNDqJD3xbKXy58iJvj6Exb9OZ2Hu//A4+JLYUwNx+4rC7vtaWxkgLisMdxZYhfKy3WnFs2Vw8lXruj+uN3Brxf0/AKR2efxktk2F0pulSU+986/NXu+vsPtBzNcOGkqCw1QqxFxH7aYOGGHdggsChujwdURGn31W4+x+q3Hidg9pgdzzCdMnjlC5n20Hf3wvuZCMpqhUX3iVRFrsWSVYuinedqi3MX+L556LJ56ef/mzQI3b2bnhsWDBWnUJpoxXSR3GFMfklzQn63uJiJLFU4ybAMxRysHT6TE8T00WUFLuJEyTKclMjKtl7VpkWRAskxNZncwrNNVKYd8il2P4rYj9jJbnRc3e+y+eIHdFy/w2VWcZF/5dfouhwnrUJzbtgNsO8RVKq9amfXsR5r4qzIOFrpYrvo9Cd2wvqft6Pq1LWVKzU121qQ6wrmJFjRpmJAByv8n7xfF5HrJZ3OrgElqd5rpZqqSJjUdHjwS/gQwZbJ40m/bWYaKJzJvDdWJ1NvnCXWRMpe714NBYwjR7IKjP6/0/bKWFXfsSNiPrpNmjFpV88KhTj7/3MbhQB0WPAS8+N9jGYWTzaeT8KTSQm7CCcz7Wx3bR/7sHwo1ZbYJifv6ofGa+5FFNTyb8XIfmpoA+ZxIG/G+T0pBKYAFQMytkT0bMfFHhYO5jp8sHMPrDLB6OocCtPr0+Fg+YrqeftohLa48jjBtJz8ADuqxOPzHwvr9a1M2nwyPLf3oeY/HK9HO8sIpY47DvsZVjXFVY/vAYvsgAizd+tNa9kX9TY99uBM0yZWBqwyaq/RZ8etwHdhjTJ9nGWcVy3aERf5ete9/D0L73Nf+Kv3BJ+3AAwEgnrhstSZAS5sAalB1aHttSz+7vWQKlVeZm65kukWNTPKbTfYOaVw0bZlrJsQaIYgPb8Ikvc8ePhYljh5m9Dh597BP0vZBhf7VE/Svn9FhZOVnJhkvuX8KlyqRndvpJKgnWDY3VK8n24K6PjOZiFLKIwiuJ4L6Q6UcsqwgaXk2EH+89ejXBZZf+nDeIwcQyp6BD9smPP4nieX8//xLFNv/X/zv/jDauyYa62XNbNv4wwxIWIHZyzAR8KSShaOFZWK9zzAQU3KbhagQz6sAMZnIwnUoU0A5MQ3M0/6DxvGYH1MuIJaW641ysbxkChZSU+zwcz6z2ALi4H+oYG3WfGUxnDcYV5VIAdw6MyIO90J1G8572NXJt1SRXEBCH3M6S1OVKRDMQWF+Po+4uadfPAJofHp+JyDmeeHa8Mwd9cpiEXg2YQk4zhm5Q55FOpP1EAjs09B/PnFOaujljbMh9aIkH+uyczWpVcibYhuebLEh7zfBCmdZx0z5fPyX+SH8O6b3UXSAdzRGHNPBjSPpMjO9prlibWpWSor7Gfy2hiCF2LxaYvtKgbGOkZK8GU/3uNGARb/fpMfL45cP4cfdg3BfWvoZK4P+NJdicHamhztZwgVLIRfuszpUxCi3xARz/yeaMcYMYY7SGi3BFd/H9v0NVmbtc1/7q/ilt/8VsMeUFubm3koeAwBLwkgHCWt5a2EcAOsQlxBWsllgyV9LVp0aOCjfIdMPKAGhWFFXkgEJIMnckgusmwsPuqqgDkRmikKYCJ5U5Hruh4EIKe+p56cL+c6wqigmfxutKXxlsf6ghekdNm8uYZxHe2bFj+T2YzRxnOAMth1RhH4lFKsxQYDuYNDTea5r6JprcjxsBsepwpiyeQJ2GHjJ+aDznwCtPJyVU+HO09Oerfx93ycAW1a/7KnmvJxL8gtr4X7sDSwe92jvlLADyN/odgtT1/C7Hfwbr8DueoynIRz7ZEMPbMg+2/z4HSyfjPgT//z/Bb/Wvobf9+//S8CbDutvkm6vvGxRPL2mDJ5dDGH6RU0hqUUN++QaftnAPqEMVgZvEQCHUCF7sO3JewlSB68I14ldqxWDF3zMxN8sc102VUUaJmMBUB059pyizKYIXBKPNAn3ZvcBMAkhyvbyxuxmyLiSiVJ/t2kSCUDeOJxp6pqel1yvxWCbU79D2Hc4qVC0cT+uLuDurlBse4ynCxQ3e7iTJey2xXBBg/z+grZVhufI1RZ2P8KtahQ3LfzJEuZ6G9mszfYAg2gnAEnkC3LOMh2VLtfD72sG1xhw1pr8BlIWyjsAMTSrNWHJ9ckdwHUGXnhWk+SKzDcwMVTVAMsa2j83FUqmcGZ8XfanF0/OgROHdH9NXcdsxLBo1aJ9CZ8nY3TM+OZnPZ6jAwDLZvdxYSVMLRofXZOSGdMmGnC69QJ228KtGvFfNAMdlxnDs8u2REC0FNGgUi3GhaHSY/c4xoz8fRuyW10MvRUGvi7hKgtXFxgXBTavlvAsVV4YXH+ixOKJQ9FZ8vm77ScsOsL9AChwFeYBv1rQM2cJYG1frbF74FHeGvTnHiffoO+df20fzZS7Udg7lk5wiTkNsKrbAcYVMKMngFWYoJOOpewMPwf63IXw9/coTPjc9gPDZHGTE5OHDjPNlclW5/K+vkl50JgR8OqwyMR6gb93s01f5zDWHKuSgyz+nz+rtCLADDjJXK2Z/rU93ZBlcCAfTqYrOV9YrN/dob4e0Vw7cTPnxmCLfUskoyMDUgJW5kqZAClTd4Dl0AU6aWPPEbw/z3l8bj9ZPycCXWZTeHK6d4f+lxqRYd/BN0WK+s5k8SA4+xe7+ePdvBkGjk1WrJXZln2X/Mazq9ntxL4feSTHuPJL2sSj7UDIrkyZrcm5Rzynvh/m+8ILi8z6YeJhlTEpc2VRTNOkReHzvmTh4TyMKZ9jS5K81ltoY1OgPynR3Zk+O8Mdugf61ygL8ebNwGiFskn7ewGshfJIDN4mWdGGzG/zgrXJR5R+01TlQeZqGoI9wI7MJIUc3Gf+en4OD46V8wkV8X2DXF813VkYXw4J3WcE0MnH+HzlyTu68bk6xHg/J/Em14QebCxb4cXmTHMhpOXYmqdI5xWfjaGT0jEmMMlNEJPP7UcsWDLdcpY57kJYblyw2Dx0SXvl1tHnb5Jhygs2Y1KABb04pF/s2Vje0rYiwOrD6x3K224SHs3HXduNwigL41eo6+N9TCbg/jLgD+fqBwVgAT9gTBa3z737vyFGi1FqmdHwUnG7oocqrNINEFf9AKH+qgzCXQsE8TCAlIkZBnFtzzUx9noHFBa+oJTTgid0LqIJF1d7XPMwf2hGB1QBaFVlBFrKmBNATDEOjf1PfFPA9MREjYtSBvixCccwEPPFWSfeAN1ZgaLz6E4DffvaAuXWwYwndJOzVxDvi0HgENigzFcmAV58XcYxFpvmz/HrRQEDwA9OTfak6fEWcRWn09dZs1DpQU+FhI2fvsb7qqvkPPoAxP1uD8PX8W5DQPTJXiZLizXGdU3OwnWRTmi7PVAU2P3U64DzKHYj/q2v/XPU1zt0rj/573kZCHxTwwwqhMshZD6vfJxS/okK4Zo+ZOe4WEmAzoMyiAzCTqOfBcUumeUyZQKdp4GJ7zEEJqAs4Xc7mKaOxbZZ9J77mTFQVMkLflRAW963cF0PywLgnMVUehe7VEAosLjchLVRE16SJWbL6IHXBLHtItNIlfScwhgMpzX6dYHuhLaxuBzRn5YodiPcWY1yS/fLeEbfvf7EgtjgCwu3BZobh3LnZKISDc0u6OhutvBtR31md+2Q3GKA+JwURWRqqoreC9fK9wNMFa+TDqn57PmYbQrA5GamUjyb+zCOKdjNNVhZRl7CFjZNvG8zxpGKxo+JGz83P5KZrFjW5HpADfaUAF/Ox8TDKxwjv6y25ceRwFUYewDEMBdbxWjrjZC0MTkHnKghjGt4HhasO830kiFbblzFcNbYWLm/ils1J2mt/qKBvY1WK74sYLwnYOU9hTnZtiUzuQZACVZuT+NERgSQhUk8tiJIT4ounfKrW/JaFDAj4XCXapKtBYWIEG1MnKNQaV1i/8oS7Tl9/vQd2gaL6pfv3KRAUllo+EWZZB/aTo1/HP0wgB+NJKGZbohaLl74M7s4jD9QAAv4AWSyuMmJ0tl7XEx6UKtsZrIklTPcAFkoSlZqTUOhiXz1rEWq/LDnotJ+JHp0tYhFJ4GY3sqNgVjmOSWNmbNMTJnUyhpH2Ntt8hBKs/RjOwfb0Xd4IpAuXNNNWN84FK3HWFEfujvBnmKtQlQAPbBFkRZg1sW789WUhBr9VL/FLQAdU5aY1WHM+KFNdC38HpAyM3rCOKIdsq/eF4FouaGsQt0mzIT3KB/dxCLC2YTyja+/gnd+6wGwKfHm/71AdxbAJa9a+ZofAFhzTQCCpIgX8ytvXTtOef/IeUg0dCaZUEwVS5WYE2I07VqJYPVC4UibJqMUcF0W6gn7N1WZZpfWFU2EGbiS8zDj/q61dibLKkxW3arfvFLm5JH61qHacajCwRcGRe/gQxjFG4PbNxoYB7QXtJ3mJp7//V0CZuOyEr2ksNyHWq7ZRAQUAl6MSesBBkfyiX8WO5UfcyznphNNDjFhh746uql+j7/bky2O9lgDFOvGE+OBJJbJ9WZvQ62nOdSUZORQeR4AyTjg+4HO5XanWJ6MGQ2JFzL2HBJJ63lnGBJjTtlWyApkvdC4LNDea2atXACIOalUFeFFbqbNnEg7uHJI3poaaGoCV1wfMRxPEaIgtk2vAZcDa27odTtEgJU0vja87/AjOjT+2EA/6/c7rN/vUF33UoNXjmcY45wBTDVq/Dmet036v+kGer77IS3wXvzgMVjcfmBBFgB87ht/jf4o40BN/89n9c0CrZKYJWPtTHmDUlzhzYI0UZPPACRKZEZA2UMAOGwImQOtvB0CWkeypMzgUOwHuEz4Ny7of9cUKG96ARJcB695Rv8zJTycZlXjuY8c6ssF4aLrKdOJM2+BUbJNM5OpFK+ZCXR4OOD4mm4HBNUHBb1Z+MrmBaeTz8bMntnG98AyDT99/Q/QMRS3PPmFzTFQy695vgDglh/rXNhuGeuyJdme0sdMk3So6XqfQFxFXlBChL04p49NQq7zep3kfWvjeZ8Z+H3IrH1uOFDsPw5Mmpn2ThgEBqeS2Zr2sQtVEnjymAv52m5Ef1KivnHY3Z8+y/06nl92fU9allgxeTayzEIR68sYZdPvHQohzi00svY85/1JZjC3LJEgvw556I2vw+QZe969GPZxzDdMmzgnfTm08OJxk++lA0kQyb02jtN7Ktv2wTGOtzWMYo2TOJgD4p7O9xtX8WD9kQ/Ay51wnczwfhB++6qkMWjOuR1hnGlq0n9W1WyxY7eqYUZ3EGAxy7R+P7yfAyxlQZHsmw3Bg5i+v7vC/pUlnn16/rzbwZE9Sl0lRtKyPWNo/FS7EbF99jyXz0KUICujJCHCr/6bs334frcfyHChbp/7xl/DL33qXyUBsfNEEyvPIWpGqHkJ/63O4Ld7mLIgky9rKYzHVOyyIZ1MXcGEjEITSregpBvZBBM8Ehk6Ca/5ugIWtdwXJhQizhtnLFE4Q3mdABSCDCsOWa2MY3TVBeSmZEDglhVcVcB2jsS4g4MZPIq9wbiwcJVBfUWfLzdDiK6VMI6AVrkZ0N2pYSpLQIsOldzlb0ATIsJv7rvUZlRWFMMAgxngy8W9Q5KA0RmihWJnrKVQIkYS/3sH74M1QAi7UBhF3Z4h3AFbxP0EwzkJBRRFDFdUJe2jLGCGEcOr5zGbBfRw83kdQqkbMziUN0HLcL5C8eQGWC4w1hbv/hIdZ/2Q+vTgP+WLH05TAFpiLggE7zG6Hw3XCnOcDdknYRSMDu5sSaC9MNGgtKmpbEjT0LkpfRKShfO0qNCFhV0GWnL7Ei6BsVzQZHGyht9u4yTLguNw73v2ecq8rRh42bqKlhz8/M008ZXTui7RAhWJiPm57Au/X5V0j3Jorh9oAgr3pe09YKiY+lhZNA9jONctp8OfpIz7qBVZvxeBFE+sSYHabGIiS4Coc8yrJkh4kbfJi8QQdrMh9M0iefldFPCDO2g6Kh5UzkdtpAYL2k6GPcfyBJZhiPIMYybg2o8uPqO8PR2m1oWJw/5911EoGaBr3/dKs0kicPZim1jDZOBKFmhhTBYPxLBtCZGqcSkBWDqyMQYZSa5hNBbAGJOSWOPJ7w+DLORNP0hpGAZXJkgLqusOrinJt6qp4CoL60tiREsLVxUwZ0t4a+BPlhTeG0r4qoDZDnKcnj3kgp8hO7ibkOjF/ooAgSuOatjOS5huvEfvL58MqC/ZaiboL622I4khUFl4jV0EV00NlBbjukYbNI6Xnypx8r6D7T1KZowHT/NTH8rmOEfPZF3R8xqSA4yn57PYdLFAdVPCNQXG2sIOHuVGma8GOQXNxZ7OwzD+wAIs4AecyeL2ua/8FQAqpJNnPHEzasIHYERknn2e6ecF0as5YyFCcPFryqjMjk3ialpNN/V88eIwUfllPZ00RhdLC4QQ5LGm2SwAEiZkd3hmrbrzPObODz79zw8WP4jDeWC1Qiaj1+GLohC2QIo3c2OanVufUejsY1KVkVnMj0mFnObaxJaBXZtzwW8WNpSJgb2QMiaJPVq8MWjvL4XhY6pfNBb3TnH1cw8wNvMTvisNFh/O2zcAiIVYi2Jyr0roK4ReeDXLAk8J5wKQTEN9bDnzkQMsOdhwn2TshZSCCvX/8uubTILAbPjShIwt+TtnrBjUhQl0wlbmQvZ89ayBFKA0QzY9Bqk4EL4fABA767OVcv0kdda3uwG+sqhveuzuF1LcW45v9Fg+6uBLQ+a0cwspDQzVMck2WDicMy7c5kAEFOMl7FLKeOlSNUYzL6zRYgsQDs0eCqmH6+PbdpYlMyq7dZb1AYPKYnIOJmxQzjLxODuXHab/132hP/JO0sSbv54fzyHbCBF3T8OxpiiUfc8wXUAorZi2POB7jxfmIkDnQszieh6ed/6/Sp9rcW3nsKv4uylpAQK4UgCLW/fgBN2DE+kbAyxuvjCobnqRnvCcJKdsVZN3VhMd3cd1GiY8ed+hvh4TgAUg1j90jnwHs/mUM+2LTZd83gWtsWwnWBaJqJ/JDg4RBnzwg9o+EiALAD7/5b8EANGbRIMBAIl3Fq90ABW6iTFv39QxXJcVfJU6T7kmK2hsxKdExZUBCCXqrZmvxwjQ9njiBcTRV1pT04BVpxodeQALC6NM7MbwQFVBe2JDVqEYbYZmeXAM/WL3eA479uc0oQ931xjurgVYyW9m3JZL+snDV3wNWLswNxiXZXpsc23Oi0tv/8hrpiwlW036ot/3IOf1UPCXw78MPr01qJ5uZQAYQkrx9hUG3C75PP+2HHZkgoDFr88Jv8mkG8C13QQzwRB6sJfBD0ulyftO+ehwmMr5WKpJFfZOWljBz2rDOPV7GKLWKW/MauWeTGzJUVXJ9ZiArcCGHTQMPjA558aak7DVWciW5UmB7RvukAFte5/ObfOUjRqD9oStM5oCth2xv5sed31L13TxlPZXPdqSNQx/j5NA+o7C53Udw3+68QLikI7qmP+VWoCQX1O2wCyK47UixcMqu2ZZss0kLJw9u3zOvWLbk+3ygjM3DvVkoyIZwIEZT4xvlTHyxJJjpm/J+5wkYw6E9rSeND//QR9o6mq+5EpZptqn54VFWaIQKgrYTQu77WFDqE70ROF3cUufY9acX+fxmBnW4SIY4wa9p+hHFyXsNhgmI445nHnen9Xoz2o8/rnTtNuBESo2XfjJFojhmhKTVMKtaqlGwfv1i1LmvsRHi7/vPWw3JlEDALBhQeRLC7+oYmSHrRxYy7aqyRyViRDOKjyQHfr5L/3F2dd/kNoPfLhQt89/+S/hs7/rj9PgzhcqCObsdi8hPj3Bma6HXy+p+vj5CcxmB3dBgzBCGQPXEE3pq5JKyXBVcIBWSPxa18eMC1kZUi0lXxQU5tl1RN8qMbDpBnlfSiYABNr2PTFdIzFe9mpDIS4Q4DPgG60IrJWF7UY4AOXoMKxK2MKguulQXXvsXyH6eViXKPcjZR7uBmBZKhp5RLEb4GsLV1p4Q0BrWHGWTInm/Rv0d1eonm7hmorQODMKm52EFZOJWwZuE4GWqkfpnRr4VQainCcpFmrFE4m2FybdMFCLP49OAbc2fj8QFv6t14h+XuVi0sD6vULsjRmJss4tPB7+XrpPHv+LWzQA2qtF9GEDcPrbpNEpwkAxripZqdqbfWQBZYCwKrxi6X7zns6r9wS0RkdAyxj4mwC0tiHEVZVUWofPgWaC8sxCOhD6VVgJA/l9C5RjwniZupawlFRVmClBxedaa2rEt6gqo+1DSEpIMgc5bKNq46XeRIbCN2VJ9wVnw2ln7ZDdaDSzODqgKiStnoujt/cIYC0e7uBLi+rhLXxVRKsN7+ERy1Txqnn1QZiIegpvVM9Yd9NLP82iiQW4xYDXwqwCGxhC13LutPcVh9g0a6fDo1pfpkXzRUFSCedoLMmKG0tmbqjZyqVgBOSUpYTloACWmMQWYcxS+/d9n1Y9UGFR33Vg6wbXtkrzV4TvBgadF4r8zPJCi+9dPjZLIf6J47pmjjTAymsTJr5WM8CWn7MQLs9Bne96mCVl3JqyAHsdeBsylzcdMeluTLP5jCGtVViU200rcwYAGFfTojiUzinaEbYbYJ8EAFZamP2A8bSB8R5uWaI/rQC/Qn9Wwe4byn7dkHapADCc1ihHj/7uAtV1h/39BcrdiNs3aywfj3jvnylx9jXg6c86VLc1jANOv0bmx8wasV9XsaeMy3FZwYwerqHs9WI/ULb12RKuLmH7Udg3Mzq09xcwjsrelDuXnn9jYPc9jQWDg1s3kXUG6HwYg3FRwDpiz8ZlJbWDi5Cc4gqDxcNtJDw4kSgww5//zT+Pj0L7yDBZ3D7/m3+eUHRY8XumX1dZuCs0/l9Eh5lIkAV8+WrYZxlMJtRFMjlLw4PUOMJbGzMusn6YcUzE1uJaKytU+u3O12l/qxKuLgXRc3iQGZRyO8CMXt5fPKIJWWjokoCd3eU0N2Q75W4U/xRu7eunuH1rgf7uCu2DlbjxSuNsxDIMkHkIzwaX6AP6HJpI7cFQIbED88yKaWoa6AI7ljf74BWYsqTMsWq6fd8URK3P+WIBgLUotj2KbKFXPaF742P/eYdyMyPiFPNAH40Jk+2G9/PwtGwg3Gu7+RCku6WB0m3TzLbIrCiQqxvfs1J4N/OpCROgMEW5BUmu28ma1BDMxO8RJGfibn4/s4KYrFZlwj8Qptql7N94mp5XDo2Xjwms5swxC+NZ8M4Ai5tUXOD7JA+5cfg6DyMqbRswEyI8ICqWt5kVYkuSSQgyXI9DyR1Sw/N4VuuhELBc/zxcH7Yp91t+XQwB6IM+ewymDonKjQ1VAKbSC8kIZ13PXL+PSA/Chw4WCzYNST/yJBViuwqgqmFWi0l1Ad9UtIgzBq4uJ9c0L51jM5G82ZMdAYfO+uDH1p8Fk86zGmbwsnjjmrb9XbrX9/cXGJcWt2/S6+/9M3R8T382Zd4nx8vZfDzmsA1NGDu4jJQL86MGWLzdYWVR7lM2luUpos3LkrQkCrNmxj8I6BXAAhDH5nA+nR7HP0IAC/gIgiwAcoK9tcQSLSv6YXariKtLhJUdbEyvlQsXaFGOQ0vlcaWL8etFWs9JN0bYoeYft+FiSe7R/P4EmJHo0tel3GQA0N0L9PD5Cu58Jem93PpVAICGfmybPbDhAW6etWieteKeK++H2Pa4LDEuy0lJhWozoNoMaC9KtBfTwWg8aTCeNPP6MyCGUCcu8H1waS8AOx1Ec0PKHFwJtX8gK0nbaRxr+QAH0MOcDzi6FS1QlgdGKg4hz2yXOhau/6GwxyGNCX/9SGjVh3AMgHm9jTUHz5e0udCitn2YmZAOmVsmn5mbyLQ/UQYiAKT6Owk5qfOu/9ai85mQGduUAKAit3lXForp1kTsSaoFAaKGhj4c9tX1h0OAQGRq85c1eJ07j/qazjXltp9+jZMHDvQpS1T4dpskQRwK9wa7hEnjhV4/zIMf746GVL330XJnphE756f38cih83FeR1UUFOKuqqgd1W3RAKsl/cy1RXPYSsFEsbrP39fXfHSTecHuepTbkcrIAPL7UNMmnvs7Fvs7FuXWoNzS6+f/iM550Xuxl9A2E9ItlXk4CQHy6yrxiyMBAGAGDzP4pN9WL2Z0uTmed0NJK9eUGE5qCnMayMKfs+UBAleuKlA+upbvf5QAFvARCxfq9vl/+OcAAJ/93f9LyrAoTMJa+FUNu+3gQygQQMzscw5m9LBmJDpzFeLDgAAtOwzALbFC4tlRlTBtT+GfYYxixLD6saFCuKwCQp00e70LWREOZogPhrcBNAWgVbQjxpMGbdCIyEr8co/h3hKuNuhRog43ebHpYPcDZcoBUXMSWJZEXFnaGHMPYcNiHOm7jtgsppI53ffm40vcvrUIq6FVNLS7svCLJhYnBeDh4kTYtkDTUJh1GICwOjHM4JQUBkVZwoTPUsc8CeibkLm5aOJ3+Px3PYVT94ApEbV2XQezWMDv93AnCwxvXNCxbHuqdL8kgbntBoyVxf5BCBVqcWWgsQHg9tNnqG89uhMTuuzQWuDN/6yDN8DivRDKs6AQ86pGsR8wLkqM6wrl5RhCi04yYABEI9q2J/NSZhM4vKDF3MqckUvJ5MBKssw4HMMsB2eHTpzJlVDeBZ+ZQi0EcqPJXNvIWZ48KYZaZZJF2dSUWSr+SC77nknARFIiJ/xPYQYOG4XtNw1tn5kFbmw4XJeiSbG9R8EDPYfd+gHuNDj8jyN2H1vDjMDlpyosn1Afq+vppGa8JwYsbGPSNKD0YeLk0k7at0mxRjpEJ+cGSMKsfqQi0xOwFjL3TB18zzg8yxmJxsRzHlijQ35ySYiRX+NQp5Y7GAOPCITlnguZjPq4JBvPO8BZeDfEe5DLPpUhfDpXmSD02Y99vC/Ee44WcFLaRr+HYEytAV1iBUELOcmA5Ww5BkJ8DhaNmEYDIUJRBwPZohDgJZGTpoBbVICje0WSZxSQ8dbA+FTgboRBIr1k8YwWA6UA2SWKrTIIzu1J7i5Q3vYYViUuf7zCnS+HsTh8jKxHIkM2hAV6w+HCEHY2o6dQZqbbNaOHU6/z7+GsQXunQre2WD4ehHmyPMcyI1YYKncXzqvd9QSuRo9xUcK2A2w7oA9GwGb08KXBsCpgBo9hRd9rnnkUT24/cuyVbh9JJitvtu3JHV1WETHjAiHmS9RluME51bYnN1277QmwbDOauyGvEfGRyYre8kBkssG3uqQ6TbIKPvCgcNFgcZdnEMibDymyYjHgAFcbeWCkX7zdIdSECg8ECythghifRaZ5geYiTAphYCgvCVyu36f+DUuD9nwm7MZ+Lotm6hfWtmSjMDdRADRYVhXM+Vn6OodgVCJCss+6gjtdRY8kDlVxllsQ5XM4VSwVdkF4Ge6Nok2zM+sPSV/FjCRnytTBsM/92jl9LwBN1ujYp/Q9LvhctPOrTzEbZHr8Ndqe51BaLkrXurM5lu45nkSe7UcOfc+a+QLZTTM19M3bIRaHv3coHJrrjrhl4UQRR4dryZmPkwxXMZnklX94HsNxS5H3LCy2+xgJgp/81HH2c5yxeABwkNGR1g/zrJEyqD3mNXf09RkfKPKe4utqJ+/JvjFlIiXEe8A7ixsDQwGImW/XJDSZh3r5GucC95mQY/I5DbC4L89LGACmYw7buxxhWc3oppnIddBbFcVkLBrPGrhFRQs5nRhSxWvhrZkwR+KrVwVtHR8Pn9t+RLHtpiE9BjKDoxqD4VoywOIEjzpIRozMK5zNR5sT5p3F5iF0N64qjMqBPYYGA1A7o+e7W4dFujLCNoOLAEsnajmP4rYlS4gde3bR/vuzGuOygC8M2otYyWRYWbTnFuv3duhPqvlIwEeofWSZLG6f/wd/FgDw+/+JX5YyNCiMrJhZMOerQsTtpu2IXeGbFxAfkuLpLcXmt/voT8IeW2UU2MIWsm0ApA8pC5irDXxVoigtsRqrGuOyQnm9J3DHD9IwwpcF7PUWftlEcbb3aJ62GJcUsmOgZXsP23u4ysBVFt15Dds72NsgzHVhVctlWUYH0/ZygdmAFMag2A4YVyWGNa0a/LJAddPDoYAF4E2F8nIHt6ywBrC/X6E7sRjWBcrNCL+s6UH1wadkdAS0igJ+v4/lWooiik1ngRadw4kn1+iInSgsJRGEj/u6Qn+f2IiKdSerBvaa3ncnK+zfPKVjqSyJOoeRGC8Gy1UB2wGW2cB2pIEwJEFwKQuAgNY3/8Ue9WhR39KdYpxPgJbveymTYkGZbUU7xuWLcjLWQGtYlSiv9sQkXm/o3hkovOG7jkwGNxsCnWPwRlJeQlRqR62Wfcj44ResjUWgQ2kTaToTkCftkp4VSWQIIl9wpm2iIwp/h7R38YTyPm6bmScAXLA7EXLXFfy+hT09ofuFJ+FFQ75gi8h66kbCfyrxYk7WMJsd1aDkCaV38KVBcd3yiQnHQ75CHJJ/+pmg5ayB9tzg9JsDXG3l2kqo3XlaRHFpE96ed/PibH2faw+oXMSuroUkDzDTwv5UwZtsEgpnto/ZQQ1gvKdzqD2xdAafTkbQoKGKLu45wGJhOzNYxpoItsoqAi0GQizM945Cfd4HqxIfvJ6GULB8EJ+85F7ugo9W00RwxaHFwKJ6+CBQzxau6xU9Q5wsEgC/FL0X3aJa+Fobk5oE8ARxvTFUzWHXYTxfEvtydwnbjuhPKzQPdxjPapSXe/R3lihvO3QXDeqrDu3dhsaiYEngmgJ2b9Fd1Ci2HcaTBuWui+e7KglImSBh8D6VIjCIK0O/DC36ZGE3ODQf3GI8XWD5sEUXdF31dY/urMLigy26+yvUT+jcjOsa29caLJ70uPnkEqfvtti+VuP06wPaOw0Wj3Zo7y1QtA63H6vRrw1u3wZW3zLwJbB6ROerebyDa0rYfU+/eypFZQdKHvFVIcfhFmwDUWFcFuhXFlhZwAD92mLzmsXYAK/+aov+pEL9bP+RZbC4fbQhomq/8nd+WbRZACLAyn6Mc1HUzq/1AwEFZqa4qC8/kI4mfdFd6Sw0vTJkH49+gL3e0SSvPu+DMZ2sEIa4ErdbYtLM4EQcWLQeY20w1kY0EeV2FPYFANzJAu5kEfVnufi47ekni/8Xoa4Wb4sFlxxidE1FGoHAhnFa+7BOGZmJ0HOxIGF6LlpnH525VShbN/AqUq0sAcSQ4DKdbNhLyp2tMN47hQ+DGR+LlLTg85z57zDQmmgQygLFbpw4hFchQmhcdhw84Wx2Anph7aQQKn3IoH0llrPRLKTf7ATkiAid/cey0FLCSMwxTpx6n+sBNSDQK0SZiIuYbr9aTa5vvs8809BYS6xmsp/4vCTO/7yfpk5L/GQaHDkn7BXGv0MiAJc0EnHukF3PsE8GWACweOJlZX/6zdjXcVFgWBcYlxblbTfZxsHzAcgiQcxigfQcz1mUZJUK+LoJm8cZqLw9vi+y+0GYJP263pcG1sZMGK5J/7Q2T2kD2TAVCABLNVtXZDqaPU8S8ucqGWJGyyyYS4BqUlyef4BpuDNjf4XpZI+xO+fztjFNLVZAk+vBWqtM3zYG1/b+bvjNY0wId2mABQDtXdYdFcnv7iKAjCAlAYcm8/srGHmafpyMm5wBGDXBjn5CK272KG72qK971Ne9FIcWsfxra+xfW2P7GvXh5i36TQBrizZoGjlDVwMsAPD8CHtPdWAbukddwyJ5zsw0UovQLeoEYLUXVSxKDWDzWgRYdJ5KdBclfuXv/DI+6u2HBmQBwKOfo/RtBgAiZGeQwys+7xOvLC1qF7rY2nSwYPHeEG76IgUEDHJ4WwzQiixMJcU11SpTVsqIVKrtgk4qUL3jMvaRgdb+/gL7V+ZKrhRwp4tYAig0MzqMy0JCafUlp6XTrzGEIUcu9xAyHJeP2MDUhM+xX0sVz58xU4DHhpuHwkf6PKi+69e5D/x6e4f+33yCQj59mDiZqROAus08lfha12kfpUSR91QEPE8G+OoCZ/+PEyyezIhBNztiH3LTxHDNc0sIbs0j0l/IvniCyYXs+WTFodc5+vyQ0WLfh59DLuwpqJNqA3lJnzzMcyBzzjtH25oBI8zI2FA7Mb5BbJtoHLkQMU+uDDQZMPKx8GTapc9OsVWf53CPaq4xcHWs3abbuDBwlUF1lRd5zyb0zDpBWIYDmYP8+lxYba6Wo6nrGF6cy7pkx3b9ncy0NRZZz+6XA55tB5Ma+h6mrmFnwsumsJPEFYAAtFkuI6jOt83/C2ALYzZnztrs2ZDzygul7Nillm04ljvnyft+tZByNJNmDY1huVB9dATged8czloGwBSMn3f3aZsMsG4/Rv/nyUNj0C/6IljsPMuyhBkwzz3fhtj23IcxaqFG+tmzhCWGHsfaRi+uAID6EPJ79pkojgcgAGvzWombNyvs7tMxMMCiDgJ3vtRhWBUCrIAob2nvNjCDkwSU9lUao/evrzBcNNi+Sp/bPKA+XH+Cfu8eUB8uvkJ939394YAn5gUzTv7x0lK+j+2T/+Zfxdv/UY/dvRJnX9uiP6mI1qyLGEMHRPjN4aSkIKc+N/x38OsBEAfxwGh5GwBTUdCDUJWAtXCLMgoew+qESwSYLk5IvioJuIT/h7OFAKD+pISrDMxIIGtYFoABxtqIfmjx/hbjWY1i06M/b1Bd0iqjuG7JRM579OcL+NLAdg7VJU1m47rG7lUuKhprHdrOycTlliXM4LF/pUbzuINx5L9lQljCbEM6fSgxYbZ7Sjq43ZKY9HYTB/MqAidmFU0/yOBhhlHqKrpFJdks40mN608sUN869GuD+sahvhoAQ+yFL0wYhKLjcnFL/RrOlwIiq6sW/VmcMJr3ruT8cxvuLXHzJn2mvnVoz6jvd/7BNZlZjo7CzsNIISEXwkdc7JUHShWiMPtOWYksosfb42cRWGhPJecT/QmJmscYhhodhQPVvZm4oqtQVbRTMBEoGYNEfKy9zZqaQqEVhXcknMVlTLj8CpD6QumQlExOBX2G61Qul5GB2e2i/Yd38Ls9xEtLSnCk4SSMIYxZljCrJVVeqEiAbPc9+WFd70JIzcr150nA1QbbV2if6/dHySYcGwMYEsDbbkT1bEehS9a3BeNX71wqMB+CuJu1WH2fAJnEL0yf+0PO5uLd1MVUeCCGy5il4pCgaNr0Pg9orPLxnhkzNj3lz/J+eX88xrG4XodAVYIGXZuwuDImjpVVHcOezqW2I+G4XNsSYKvKOM46L9daFhLBq4pE9OF88r0C0P0QWG6z72OFDtaQgkJuwjRzaDAUHDa7lrwV+wHudAl7vcXw4Bz2tsPu7VOU2xG7V2s0T3t05yVFGkBj8eIyJAftYxINe1IBQH9aotqMGFYWq3c3GM4aVI+2GE8blFc7SpYZQ7Z6qF/olzXMvqdw5bbHcLFAeb0ns9Btl1qTcOi+KOAXpbBRvjBwNXlPDUuDm7ctij2wedNh8ciiaAHjgfoyzIuWGKvu1KBoCQDZzqB5BhgHnHxrRHVD49rNWzXGsBY7fXeMEQIPPPmpGne+3OPxz1Q4+zq9vr9jcPsJoH5msPl0h+phhdd+/gO898UHOPvkJf7e//DP4CPYDlLcH3lN1rH2zn+f6ewVlo96tPeXVE9qVcnDb2+7cGPTwMITreF6aDw48QNTqoGxKinEGCh9MwaNUkiD9fw5IOjBiqgNK60AEt3Mvo9uuIGV8WEFZHtPRqMrnpTo17AkQ7j96ytUmwFjcCvvLxYodgPGs0ZoW9puOtAWmw6Lp/Te7pW40nO1JdQFoNhQvH3xiLLrvDUY1xWKDSgEu2pgtm3UHa0WpOM4WZFL/smaJlB9LlXzqqq7Pm/0HgMH+tWdkPN9d2pRX8XzYEY6P9obJmeuAKA/b2QVWl9OGZ7hIgIgbs31iPXXrtVJUyvnzsWVNGv3uI0z3moA1Sa0FuZmM7PKD0ArGHTKsWQsiWYs2BXcjy4aQGp2ZRxnizhTOGa6hiKdlCGgpcJLpgzhIg2wdGPtlQZY+rjqikCKZlldqtmTyZvNMXOhfZXumxcwNlvF83UYzlIm1VuD5RMnFRLSN8MuuBgtP+NBi8ZM3wTE8OIsd6U/5F0GHLZkYCB9ILSYlwebfn96v6W1XrPXAUwW2xrYqX3lZX8m944GWHnjc5f7aGVsVgRT4XfOkumSVHnxddDYba42Sb+lsaRDa6+AuBBi7zWOLFwT22RvO/T3V2JT0IRqAM2zQSwHmOnnxmDD510ImXMsJB8DCy8M1qDAHyAgym57wALl9T78r84jP+sM0BfpOXM1s3D0uwhD8eIRR3fSPvqSQCN7BdrOUNUMByyeOQxLgz2HPvnx8sDNm4UkZvE4/Phn6Hpd/kQ47hPa2ebT1P/Xfv4D3OwbnH3yEj+M7YeDj5tpX/2f/1H8C//c/xcAcP0Hb7B7hU3eajz5mRO0dxq0dxqphC4sBusScto/CwsIZR9c4hMfIGuEsdBNajMtKrhFFY1LpR4Vh9/CpMF1CncDqtsB9bNOakxxK1oPO3i05wXa8wL9uky+yyUWmNYtVRitv1jEbLstOxQD7Z0S+7vBVmIXP1/ctvSTZ9AJAC2Sc+nOiY0a71BobxI2DIzM7ODv6Ccvz7B62GP1sEe5CyxQeJ/7KbR4ZgbaXdTY3a+wux+viwCszBCWj+/kW5y1E7YtFiCeWIsctIQMVtP1U6H/bk+g4Oo2fT0v/cHfMxFAzZ0jU9fzGp9vp4ljfsw4nLRxnPVuMlVFk12VhV/keMJkfMgTLZucfdcTM7VcROZHbCMY0JaybwAwpyQPEFDF+9x1YMuFvM5auR3RPO1RbtPzyfUpq9sQBuUMMS67tdvPm2w6Oj+HsgmlduFcExH9gd8zeqnJfrReCwrUPSdbUNqcRYTe59xnmYmegP7AVOd+XcGENAmrs54o6O/E6yu3Hqky4MVMbJ6FOYyUdMOMsG67PbDbS3Fv6UKbAmLRyOaG1hmQK7Y96ssW9WU0DV58SGBs9c0Nir2TTD8eVwFisbhx6LBflxhOKwxB48W2OO5sGX0SrUnGGtMO8UezWDKH8QfDdVFGo/WNQ30TIgPhVJ99w+Hs6yPOvj6i2nq4Glg9CnPP4NHeIRDWPAW2r9G2rj5FO7n6DG3j6tMBOL1FAM2XQHcR9+EqYFh7DGuP/mJE/wr1+603n+BT548BAL/09hc/qizW0fZDGy7U7Y/9vf8R7lQb/Afv/h4AwLO//QAn73jsXqWbkPU264cjTr58ifFsIb4l7PQuK0HJoFFhGVlF2EhTb/ZAVcKdLGBv9+QR4j3Gk+Dg2xQkrGVKHMQoibO7KtRpRg9vCEC4upAV0rCuMC4KlJsB7d0KReuxv1Og2oVVuieaeGwMqg19p7qJIvhxEdNmi/0A2ztxEB4ryqRbPB3IkqIfyVeFLTEAotY7FV7l5j0weriTmsraBPBouxHFoysKJ+5ayuLsevhFk2TYuKaC3bLvkxU2alzX2L7Oqz7KwDn56i3V+jIGth2we32F6mbAsCxQ3VJCw/Ung1h1ZdBcRTr87GtxlcphT18VoBJHFeymRffgBOV1i3FVo/rwOhxzn+j4EvuFfpCi0NRHYor8bg9jbQgB0aRj1is6bnZcb7v5LExAyqTo+0UE1kURQ1SqyG7ix6QnwKIQYGXKgnRZ1ihHeE+ARqXXiyGknnC6Hn4YKWTZ9zDLpTBffhgoLOhUSJ3PT3iefNeL3sp3vZSl8bt9FMXXddz2voU5WdGkySWWmpr6zhnA0uEQwrlYiYbQDI4Y5NFjWJfCFHcXJWzvUW5GGB8sWEZPmb/WwNxuI7hp48SqS7LIeWdQGrIu8/HVqPCelJDhbEBumkXihUjINNSALc9STMKUvJ/8fmKWUbNo/NkciOkFZd9HcDVmoFaL7bV3lpJSMDD2WktWFOk9x5Uj+o6u9XolYUEMQwgJjvFe1H3WfS8KKnsU9GLQrFtZxBBkfix8XapSacJG+ex40kSbndEDFlK2y267+PtkAbPrMZ42sP0oCTj7Vxphu8qti2yaRzCBrrD65gb9xQL1hxsag26J8RamVGW9UrksCiuK5lebW5/XKMJc4UqL/qRAfT1gf7dCfTNid7/E+v0O7UWF+mrA7pUKRchiB4DNqwW2b3Ao1KN/Kzyro0H1qIKrPLwFTt6x2N/3qC8p3G5boLsTjiusKZkRu/zdA85eu0H/q3fo9P70Lf7gZ34df+G/8e/jI94Ohgt/JEAWAPzFL34WAARo7Tt66Lu/dRcAAa31wzggLT/Y4/HPrvHgP38Eo4r0ApgCLdZUcTx8zSV+4g3f3lugebyTUB5AaeLCLLmUmdFgS79vnJf9DWpbPHEAJN4FIP4oTE8z0Cp37BPmZACQTEjQw9kFDdLyMfWvfpTS75NyNWHwNkMafnLLKhrShWOToqMSUsq0KcaIHkFn+fT31tg9CMxjGARPf+uGvhomUjZy5ZCoqw2607BqXMXnoGiBO1+iY7Ihi4w9tSRBIvzvVD1C1tAlFQBCCjjtJJzHrCyTpJTzpMKmiosmLQLNn3uBNtFrDcN0ohRtmAJZxkZWSOpKKn0Ra7U0yGJ3bL1/Nlnl/uchxKqCP11RCEaPM20XM8NY1D7DbgGIWrKyhD9ZUuYvn1MWtTPw4+zgsIhwqwXG84WIfaWslTEYm3j9uosS5c7Btg51qFVYPAv3e7geUscvY6W88tEDQCCL9VvZZ3XNRq3pEvYmF7OzBov3AyBmdWbPnwLX+XezTkzDjrytAyDL6xqS4RhnARa/B0zLimmQpVsO7AH4G3qm7cU5/c8O/xweZ5BVV8mzA4BAf13BBzAsiRv5WJODrNwHyxqYtoc7iWy/3D/iI3VgQRT0UNzGRYmiHdHeW2AICUzsMcUzK4MvZlJZU2q3XZq0Uli4dUOv8/3EBqiZNII1qJzcY5yXZwGgcKYZ6DXOMufnYvMqHfPVT4RtvRYBFgAUlyXW34zbciXNod2pgQuXnkOQDLCGJZ+P8P9PEwL77X/hT+an8KPYDoKsH9pwYd7+9Z/6PADgg6/fo/9/8gsAgP/WH/j7AIDP/KF/hA9+ocAHvxAHr/t/f4MP/9lX0L9xF/0bd+PGcoNM/j/LYGMQtH91gebJHu39Jfp1KSE9/Rm3LOGWpay6uWYUZ6BJJXdO6QWkTA63ckMPY3UzorqJA0B9Ncg2jPPy0I2LUsAVl9oBaACor0cUvUd7p0R7R5X/ES0DsVXygAdvMvFwUf0nkz+DsSkwNoWUDUoE/0qUSidmpEF1dIrRc1h+2MGMdCx28HCLEm5RSsV7ALh9gz5/83a4DkGHwA8912lkgGlvVZZP18PsW9gsrGd3qdYqOiSr1S+QZC/5wlKooR/SmmfOp6wLG6+yxujQwmcm7KQzu7i4MoCpliYP4XglGk42aOT9iRaK+5xrfpYL+BNlEMuggZ+HZROzavPv5uHGvPHEG2pn8j5iTdL0vuTrkpfBKvYD7OAkjM5+WAywgPj82JAsgbajyTcLQQngyU19ddhwpt7i3HU1+WSvP8sAy2eAzYUCzIcAtfRzBgTMMVtzIfu5kGX2fV3oWVpRUAhQ3TsH9VtiSxFYqpn7m7WB4snWBNZPsaNSe3OIzvcAKEmBS3oBgREK2bZtR2B/u6c+s7ffvk0AllFO5tpeRwDW6KSsmml7YvtDf9iWhwFW9OZzBK74dPAjV5hE0qA1VzxmMsBiX0VeAEZDUV5olxiW9AMg0YWx5IQBFjfOhrwO4+b2lwjsvvnf/BYAoGzovK6+Ep/Z+sqjvvICsLidvEfHev41Ok/lxoff9H7zlH7/kACso+1HhsnS7eP/9l8GCo8//8/+3/DH/4s/iP/uz/wmHAz+7vtvAQDa3zzHz/7Tv4Uv/T8/jdvPdKjfpxv54/+vLZ78zAoP/uZjmLZH//oFAMCXBtX71+gfnKF6fIvtj9Hrw9Ji8aTH7cdqLC5HbF8psf5gwOZBidWjATdvlVg9cgKC2julaEXqyy4567runhkcsS2ljRYEAFxTxNIwFmKoODZWHnCrQBln7XEZIKavXWEEkHTnZQBmBtWtQ/N4J4yVCDWtmtRsNNJjIzraqBcBP0YfHdlHMtzzpYVpR/imiNT7zR7udEElGZaVhHtcQ8Wf2zsVYIBFsJh4+lO0RDp5b8Sj31Ni+cijOzNoLkO41UPCoPf+4R6+MGjeeUoTyRBX576pQtkbtqoIoSvnoq5Ds1k6i8gF8T0nNXgvHmy+72O4KTBFZrEgkJV7QbEhIzcOxYRzySavHEZDYUUoTmamZVIP0NR1BE7MCDC7wCE/XRNQm+72nTBNEr5bLOgaL0P5pJPgQdV2dOxcdoRZQQ5d3mzp3OXsMO+DjxUg08qTNd07J8sIIvoh1h8M9UvR9bQQYfbxZIXxfAHbDhPHbVdaDCcV+hOLsTY4eY/6UoZsW7PvKUTI12oY0hAtEJMNgkHpBNBoDRFfA2Mm1i8SBtaC+hASzjNHYQ1lAQZGLcnym8lmzC0cuFSPHIMGP3nIUIEsU9fx+DjLNLBbJlsgYHShcLtaVGjNmCzS2COQzq1ZLeG9h7u8QnHnYlLyRzJpwz3hN7to3LtaxXDibh8SNsK9w1mw2odrsZA6kmSKG59pc3YK7PbwF6cigvcVZQ2j7cgwdNeS5OFmQ4k9NxtgtYzZ0f0gY4Y7W6I/qyWTm8XurjBwjYUZQ6SBT0uQdrjSYPG4Q3dRCSu/eLSjrPGrNomIyH6dBxwkMaq9KLF4EjIrC4PurMDyUY/9vQrLhx3aexWq6xHPPl1j+dTjyU9bdD9G/VysOrx+cQ3nDd59dAfVl+j5tj1QX1N24f7CYqWiP7v7BZZPRnQnljK8dx6bVylzcfMxg+YpsHvNY/mhwd/7638EP2TtZbgwbx//d/4S/RFOzX/nZ/4R/t7DN9CPdIN+5v5DAMCvfvkTWF3sMPzmGQDg5B36/PlXOzz8vQ3e+JvbxBwUDnj6uxY4/eYg1PAQwneSfcIPFFsQBSKl2jm0pxbrD4fwegivteNscWM4EJhSNDGHGY3z8JUVoMXsjQZZNridA3EFZHtaZbFRnGti5sxYkXCSfZ64D76i7EzxCOPFPB+urqGISLvH+l3TVfN4UqPQZpDSaZoI2BeLBxROJ2agtXuFRezA/p7H2VeRmN/d/40d6nceI6nTxpNSWNn7NbMnAWQFAAEfhO+555knd3AfrDu4Sd3CzTbV9HBrmui7pAb8hO3Ky5AUBU0inJ7eZyyTd98WyKKTmd1jYlUypjoWZseYVWjqCLJCY5fnCci6pmzKBNABSdiQnc+BGErzK/J9M97HwrgOVHeNa4wq01m3WkjIJgdZ3UWD7qyAC4ejQZbZdTSJ7lTYdgZkJW3G50qDLA2iEpA14wafZAby+WcWm5nBOc8utT15XYGsXM+VfE/3CyBgVZUE9Mtsn2yvEfSB8R4a4jbnSgNpVk73n7V73mN8dkm7OKOxNqkkoLYBY0m31Q+TMKYAzNzTK9S4TP4Hpvc0M86qrJfpB6qXqrWXbUeLDX28pVpQrhbyP/s1msGhv7uEYylIuC95nhgbWsjyPMHWImbwcI1BdTPK4pRbd1qh2gwCxHg8HJcWQ2MnRsuc8cfzwO1r9Pnt67TP7sf28LclPvnpD/CNhzF6U31phdNveJgRqIPshLNzi86RkD/cXu2ZDX2jF/b3w1xS0+e//L/6o/ghbC9B1rH2qb/yV3H2u54AAHxABldXNGk0S3ZgplPQdwGMfJkMFcsd0N7xWDwOgsZAh9rBY/uaweoDL+mzAMWld685VNdx9WLD897edTj9uhVqdf0w1jIst2OsRRiaLsYJUEadryzsjt3cY1hwXMT98e1Q3QzRvVxdYdcE0bbz4vBe7ANDUFl0pxbVrWLcoMJnfJwha7MIfZHyQB2VXKivQ1qy0qDtHiyweNyJ2R8AFL2DKy3KTZ+EZ4wHnv70CU7f6WRg6U/oeJ/+lEF1a7B71cE4Q5MxgJN3DE6/NcC2Hst3b2BvwsXSTv78PISVuDtfk/syhxN2WbmWzDxVGIoshMyZTP76JuxziGyWrskXitf6200sT5SnofM22dQz6G/YAT0pRQJMWIE8S88PYwL+Eram64CqmrJqwdlbJsI7Z3IuWZOom4RdLun4RXumgRz3TZXqkXDhekkCX9UP8Wi74VUKZ+nWcE0l1h+ilQzPAydPsP5l8SikxLNW8OklgdcM5CSFn3VojpMmgoeUblIKSTqdHq+caxbR8+SvwbQWZetwXVKc2k/fz8AbM2N5+I5K37jpfZJlvMa+5loufhbCfcXFqhmwGBMrEGQFqBkMuatr+n+1FMaUzkdYPHQ9XNvCLhdwuxi+tcuFOmdqfAjHNKeNY/+5g88V9zsv96WOwTRNCiwBSGHzppYFGkD3nb3eYrx/Jq+JVKEf0V00sgAUz7aFge3i3GGYSORLw4/LdsSwKiT8PZzQNSE2yaAPa5/+LOh4V8D+zQ4nX66xvxfPl39rh/qLK+zeGFBsaSer9+n3+lsOY2OweBYW/UEYz33lxfP2VTqmXQBV2trhN//sDx1zlbeXmqznte3fvQ8A+OxbvwkAeP2VKwBA9zWyHxh+84zYrG/QXdu+Qg/Y9nV6APf36YbbPaDtbT4WbrzXDMYmprLy7/7Mofv0Dt2nd9h+qsP2U3Flv33NYPuawe5eid29Ui5ffx7KyDQlXFOmhUZBk4npHWXbATLJUL09F7cT3H77E12eAfK+0WGvkR5o1rPYnlKA93cL7O8Wkn7MVhHs8tudl+jOS2zfWGD7xkK8ZDavU83F7qxCd1ZJuLM/qbD8cI/9/Rr7exX29+jYdvdr2MGRds0aDKc0+O5fXeDuP7zFzds1yu2IzWsF2jOD9szg7hc9+hOP5UMdSlVi/EY9D3lWJP+Za5hybyZmkPYtTRg5MxPOu4Cr3NJDWTdI6EyzXydrCblMWBKppZetfSzpv2RSZCYs93ZSjFVemkQ+r/fZ9/DeT1kca+T1ufR40/ZJuQ86btaMHR96Zr2eoNnP1EtI7EOCZovfz608+pMwkYYFCqfam7aH2U7T/GPWm5meb+nU/PiamHtq3ZNmhYoigjAJ1WWsl/TFzbqrzwGsSReZveSMRX6dReTGptsV4GASBkiACZ+LA5UEAAWQkDGAiqFlWwwTjGUlJD2MdG+GUDsDLLkvxjEBWBObkQCwknBr+JEwLzfRfJl4LY2hfev7MGQqMsAyhkK2Ups1ACwW45unVzBPrwRgMYi3m6DZCgBLzDvHFGDxOM0ArF9bdCf0AwBdYIyK/YhxWWBcThnEcWEwLgz29zz9vEnn+/Z3Bfb2k7coP3mL+os0r937VdrGq3+Hvr/+FvVt+TgI8oPWt9iTposZNO7r/l7o6xl5cRXZ4/Sj2F6CLABf+Vf/KL70p//ILNCyYwRa0jKgNS7oRsuBlud7XuLt9Lt+FrLt3gt2D9tA8d4ZcPMJJ8wWh9t290piawwBLQ0AxmUFb0wCtAAkQMuVJtg/mFmg1Z2p0iMKaI1LK55cvFphunr5hB627Sshg4UB3ejR3Wkk1MkDhDfAuLCoNw6b12thnfoAtMrNgP6kQr+yKPcOu/s2AVq7VyoM6wo3b9YJ0AKAm7drVBsP4yhM2IZVW3+STorsrcXNXYQyTMsstMDvnxNTxFmGwpSEUJLfbJLP+01gZ5xPQwv8flORbcNME6A18cNKgdbUNDL8zyAvY4a8DjlCgZcjAm3ux0H/J52mr/saQIrZZCNrDrQkdHZg+AnHcMjwUwCWMCgpwOIQ5SGAVbS0XQ2wksYs1gFQZZhdyl9XeqcpILXzv3WIGpgALJO/z/viMNkBgHWwRI7qz6TwNML9VswDYcmOzDNp5XqEey4vtRRK5RzKnPWbNNvYDyNtaxjg25YKVAMJwPLjSADL+8n+TF3BB/d98plTi6cAsATY5iHUijNWs0zZzMNMzm+WYKIBFgBiw/phFmDZ2w62dyg3fQKwABqf7UjjpyuNjNcAVaDozigyMawiuOKMwPaUIhH7u7St6oa2vfoW9zmI0D9JyT3212h+W71Pr+cAi321NMDSrV8HM2wFsLj9g7/yR34UWKyj7WW4cKb97P/sr2HzFh3y6deA248Dd3/DY/OGRRnGCaZtm0uPm7cNFo89Nm8CxY5utOUjj2FlUF95dOcm0rw8L2w8dg8Mqhtg+7rHuAqZJzumag1cCSwfhhV3uNFZJG8HBzhMalLxw2oGh2LXS9YJh+B8SeE+VxlsX7Eo9+E43wl13wKo4u1KKG5l0Z5ZXHy1hTcGNgx4+7tcbJu0Z82zEdsHpZSX8MZgWJAL+7A0GJZAtYkAsto6FB0xbd15iaJz6ING4epTFs0zoL0AmisAHlg+of0ODYnzXQnUtz640NM2P/ynPBYfFvAVsP94i/JD6uPFl4CL3w4p+vtBPL4YFJg2ZBAakzrQG4Pi8ZUIbemE+zghst1BxfX+FGjzXioC+GUDjC4Kam83ccUdHNk55VzCOiOZLKIsSTzPg3xNZqDee9ofm2aqTLgkjJLXsTSBodDu6lATJFtC8OfDpM59kiLOrLPT4EGVVpnUg2PjXgaBmt0JYc8kFMNho9WC/Ml0n7meKB+vZByGa2gN+coFkLd7EMOY9dUgYmQb3ME9Z5laQ+FTMWvllYmazLVfmS4jxKyhZot0xmeY4BNQxOFH9sOaEa5zSSNTVzGsp8X3ejvclGidCjvHyVFK3jgfkyV06SXxYQphbbGSCJpELZTXgI21T6zb4nuIGSd1rKau01Bk38OsV7TgYMDVdfDOwy4p0cLtdrAcXg+lpfzQwy6XdJxZCFUqFGiWWB87m5vaIrEzMdZSQkhTT5nKvp9o2OT6A2Q30naSFKB1Xz4krKAoMN6hBVd3Tp8rNwO6i1qFCMOzzpu3ZIx8+yYXRA9hOfbs7cLiOLzO42F/YrB65PDsMxZnX/V4/AthofxNOobTdxwWT8kjrrztY1HrypIxsw8MMstTysiwVdcd2vsLLL+1wfWnCV31S4O/+7//odRdHWsvNVnfbvun/8BfBkBlAgCgvk5veAZLY20EZAEQfZTErXugOzdieMrs1hiev2FlsH3do7pJr1G1IQCxfBRWIUEML2nAvRPhu25moDBfcdvBLUpxQheh+LokCrkyArQA4OT9sLq/HBJbCHZ+b88smmuXAC0gPsj7+xWKzidACwCKzqPc+QRo6bI35Z40YRpo7e7Fc7G/ZyZAS87RrU+AVreO33vycy4BWm/8v0t0JzYBWUBIk26pFqMYiSJO2G5F5614TCtTXpXL6lhquzHblQEtBbL0ds12Tyt4BbKAwJKETCsBWXqlHoCWBllJf7yLIc0EFMywEmqi8F1Hk/+LgKy81VTfUDIP87ATZ33l4a8w+el6eHoffhjoPDqf2Gf4ukonNmtJr2UtASwgScLwhYE3BvtXI/hdvUfXsXgSNHL9kIS3KATkQs28EVJ/UTrhUpCVWR7MCtAB0lhpkDUz/vqQaCAhPgaaCmTp8yX71WBCsW0aZJnCThm6HGTpYwQEZB0MR1qbblec+gthBSfZpOG45B5TAEvfd74fEoAF72F5IfJtAqwJu6cBlsrk1ADL931cQMwlCYRFGYCYIdx2ackf1tsFgOUXlJHrTkJZnSD76C5qVLdkLL141MnYzVGE3etLNE97tIHh358HMMRJuQFkcSSEx/HbNwqsHrkJ+Gquw4J1YbB4OqK6SROAJKHrAMgqtqmutr+g6/Kf/Cd/HD+C7aUm69ttf/M//NcAAPe+SJMyZ1Sw+I+LKC+ejjh9x0sZgsVTFogHIfyefES4yjkLFotAiFQbj9X7Bifv0vvMXPXrIIgPzzWbgzq2QQgAywTmybbs5+JIC+Q9rDIY5Uy9cjOg2HtUt46AYNjc9lX6o70oaVLiLEVenLUe7ZnF7oHB5ScbPPndoVr768GfpTYYa4N+bdDeKTAE0sCVVJAUgWkq9+QSzExWd0I6iLGxGBcW3dpg+cRL0dXVB1TWob4B2vNoaGecR39CxbHtQNurN15u9ZOvF9g/GHH/741YfIP6eu/Xr6cXWk9Uc7X9ANg8/DXZxoGQG0/aMxOMX9TTDCh+jw0wJevxQNhmptwNAGGZJpNm3nJvpkNO3pMOZscb+umCqN/3Mxg/zlgAAFLMSURBVOE3IJ5r7fiNAKoWTRQc86SodUG65d5NDIx5Ba4qDNhNm4jlAaDcBAHvdaClc12R9I+ZrOw85P055CmVN55ss9CTNHEvPxCmZGH5gVCgXO+ctRT3/Gp225JJechck9nbF1uQxxYE6jlwmuw3MEN+36rQo0+Y2ATI8veHAEJ0v71PQ6iZ0XHy2aKg8lDBGgKAVDGg7MVoucL3tA5ZJsCf/y6L+ZqKAQSb0SUAywYgVex6VLcDytuOANatMiMFYPc9mqe9ZGYXwduNIxzV1icAqw/egHakEjlNmLcYYK0/4Ax2YrGqbVxc0fHEe0wDLC49xvNNbp79IwqwjraXTNYLtP/e7/tzKDb0MIzLCsO6RH3ZCs3rKovmGT0Mw7KQOol5xkhzNQYgEbL+eA7kcaCkB2J3l14ow9zeXI/YnxeodhQWq29YhBhCfPsBrrSw+yF6XS1KAVni+eR91KssSnShwGd/YnH7ZoF+DTSXFMpsrh36tcX6gx43H6vQ3NBKyBeUmtveMXA1mcrt73uc/xZpzoouHJch+4R+BZy9O2B3r8TJex26sxLVzYD9/QrVrcPuHnmrbF8tUO580CFQONCOVLF99cihXxlUG4/dK/HcLR97DEtg+YQGVlcZAbH92mD1aMSznyjx5hee4ObTF1h/nTQIkpXGNe8400lrNxa1GKqaUOLH7Npp/bquR6Kj0eVBgOCwzitCT8JY50mfNYyUCh40KZLe7lwstLtQmXpOaZF4nxyaUOVyZFXuPLEvwdQVmAIzch7PJrAsU1KXHJFwIeumOPzHbEhZktWApLWHzxsVUtKu42UZxepdT/2sypjxyaVDwjUhY9vUa4reazCex3NVbDq6vmFy7V89wRhC6vVlC3u9i5miwvxl4JCPN2Sd5kyXuL1zyC6EwdjrapKRCcQQG/8dkgrEsV+bePI1RQp4dWaczgRl7zQ65y56nXFTYNJ7T9eLAbVmlbi/ytldQoRxA6nVhu6P0jyJllA5u2tjXD8M8M5HU1aXeo6JbUUAO3axEI0W91uyL3X5sxB2nWW3hoFqZHY9hfT42Whb0XOxz5xZLuj5WiwAN0bNFoemq1JKZ4nXXqhhiq6n553NVkEMq9l38GdrmH2H8c6afAHXnBnlYVkjODr4pqRqHqHIeX9G2yk3A/rzCu1ZgX5tZNHu+LHbe6w/6DAswv3DrCuH932s/AHExboLny/Ue660Aq7gSIpiByfjpy8MfuXv/DJ+xNvLcOHvtDHQYmrX9nEg4BsXxiT2A+Lno0JrnGUHxNXGPoAqO3iU28iaSWgyPCBcVJRZoEVg0+pnPFmE7/HAx33kVRy7sDPQCuL4zcfoAX72Ger7+r14ue2YPrgA0F7E+2n3wAjQYg8x3fjhXz4ZRDCp3YfHRTxfXP5G364aqDLQonORCvWrbQCXLH8Y+XXa5/qrIdyXXROzC9lNmVA9OouHVOsnxILNgqx8MgNS9sO7ONhr53eebPYtHIt/9UTOQKupafJ1Y8pE5BYNIYQobyvPLAAHgdZEUzIHsoBJ2GUicA6To+VC4LnrvGSyKXF+U4vdhZQm0qFNnrwQr8lc86sG42kEWeUlJyEEPdbHL2AGJ0V9iw8v6X0GWMM4y0iarBiyMBrifp/dNyzOnyuSrBtbMvD9pD2geN8zIGtSSsn75HOzmY7ez2YBMljJzUwnLQdc0r9UPB6d8NMsyjyBgc+N48VNXkGDz2EGsPj+kYxEBlgzLQk9z81xikUV09m5bVkbAZZmhuuUdRWtIbe8zBE33ofoB6v0dW5Z1iw7vI+Bre3P6Xu3r9M56oNUYvWQvle2Hs2zXsASV/Pg7wMEspg8kDmqSPvBc5tOtmKpBdWzfQmwQnsZLvydtv/4P/0T+JW//adRPb5F9fgWdj8k4TgAsNse5W5E/YQoKI5x10/p/+bxHsXeiUP5+gN6nx8Mbw2GFbC9HwYhHjd5UR+yourg79OzJ0qwTWAXYF9a+inSyVFT6QCEel6/R/2786URzVOqrM7V1TevE6MEUOx++8AGB3Xa9vqbHu1dYPHY4PZtCByvQ0ZL0cX9sVeX8epYgs9WfdmhvnFBoxW/x/UWi86j2hLTZUcaROhcBKYi1CWstg7V1mH5uMfycY/mMQ2gm0+eh3OZDrhuvYBfVKFGWZnWL+NzBkhZF550Wach4labTXI8YfMkzk7uouni90OYlxkrDcKgJmvvZicB3/UUhijsVL/FLcsWm2pTsky3fGLIwzRjCt7zTLhoHZFpWCQjy6av5/3IG9+31iaao+RHNfFsG0a4dSMsAQOsvHamn4BMm/4+1K9D4cE8nHjg+0kSRdaYjfTDfAYddVdP6tk2xONqqhFL9i3fd7O/JUTJWsI60xwqBirZfshMpf67CYA9BLDy5ufMe8P9MJfNqa1GEoCljysUvE4AVg4Mh0GYRrgxCve54DmQAiwB6wP9dN3kuvshfG4YpKwPdTQmn5h9R/U5VV8YYMVFdHo6ePF78i36/Ok7ezTPepTXfGzh3IT9lLshAVgSkgzh8+Ixhf05lMmt2A+UMLTrYXY9vvBr/8ZLgPUC7SWT9Y/ZPvvTf0KMF802lFnoerj1Imp4nMPw6hnKyx1VcN/3cIsqlrPh1cWylHpVu/sWZyHTj9kab0njxam03gJF66OIvrGwnUfRuZDx0cNXFuVNh+GkRvV0i+F8ifJ6j92bJ1i+e4P+7grlVYvhnAbL/qSUzMJnP15jfz89XnbrLVrKiASA5SOXiCcBYPN6IWaqRU/9dCUBIzN6YpYcgSzxhxHRNon2h5MKw9LClUxrRxBKx2viCssC9RUNLmUw5NvfrbB40qO7KCXtuH60EdYK3sOdRiuF8aRGebXDeLpA+fgWfllTpqElsGp2nYStJMSkhMsTxoibZEiFCYUZhzEDVvzx0QFupM9zGApKm8T12lS40O9bGsyLIm5f7DiiqWfitB3K72gDytQ3iCfocR545X5PGuRwZmHIEpR+83EYIyBrAmhDS4xtQ0FuAHAXlGourvqA2Dn4porO2qFUEwD0dwkcj7UlzcvDa2ItedLsCaRKOIwZQ81EcgmbIbIVct71+QjaobycTTwwI/tJQJM22S0isNPJEHz+dHaeCM6BWAOSXf37DjB2Cs4UQJ415ATkdWFuQmIDmmaeuQ3n0rVtKurXYW0gSWiYZG6CGCwTahTG1wJr1TQTRotOqQ5T+pjteqiANjcVthWjVi5pFMKMeQFvs1jAhHJRVLMw0zGJ351JLSCYydVlo5yjUKL3MeQYQo2+DAuHsgj62ELCdeO6Qn9SwvYe21dLrD7o0d4pcfIuASQGTL4qYvJH7xLPRDl3+4HsaUKY03S9hOL9qoHpBrg1/eZSY3DAF/7+n8HLNmkvmazvdPv8P/xzABDT/7seph9gN/s4EQMoH1KYqbhtKZa972HDSqXYhAfCQJiXO7/VCcvDbA6HDTmcJmHEjOHicGJ/VqE7KzGc1uhPSvR3CVAMZwtU1wN2b51iWBcYzhvcvEUDyP5ugbG2GGuL5ROHO19KByXbMcDxcBXgKuofl1Dg1dT6/Rg+ufqUwdgY7O9auIIAU78KmqrGim+RDrca58k7Zkemp97E7/AAUbRxoKhvRsAC1XYQ/cHiaWAQLweUNx3Kmw5m34slQ5L2H+jz7j55Yg33gos6M1Xs8cQTfw4MDvkRzWWN9cNsllX8QBjUD21TwmlKDwUkk0Wy7xz05d5AeQHomXZQ/M6Nmb28MPVB0bxmUgOIOGTyCaQC4zIDZ9x9BsNZwXTZpTWobgcUN/upf1km9hfdGzf2fso9u3IAxRqgQwALgGi3DoAbDbDmmjidM8t0yGdMsSqH2jGABSAFWEC07OB98r2nABYATDIQDTO+TfoaG4ByG0cCWLovfUdjQlXPs32SPekSgCUtZ+ey9/wYFhme/x4nIU4NsABIMeijAAuIjBU3zeYyG8bnmotMs6aMQ8MciVAAC4iZ66sQCckBlhkc7K6H6V34CWH8NoT5uoEAVtdHJl356ZnR0SLFxcUKe8m9BFjffnvJZH2H2md/8o8BoFU2uTv7mBbd97EWFq/qufbd6OCXNdpXCAgxgCraEa6ysN1ItQFDxXQzevGu4lbuR6KCDcAGdUDMcPTWwPZeio8Oq1Tbtb+wKDrg9k2Dk/c8nvwMcPp1epOz+XoiEeAaj/5sxMlXaaI7+0Zgiq7p983bFVaPRty+XqC58nj2mTgRLB4D6w/Ij6V5OmBsLIrWScZLwcyWlJYo4MqY6chg0lUW3gCuMRgWFovHffJ9ADCdI5F0VaC4beGthb3dqXBe2Mc9MiQdVpVoDQCgvCJjTa5Zxis8maT3adaRgLCZEh7COmW6mGQAd462pevk5Wn+Rchc4omAt6e1UpyWbkyiz4pGj0Nkw3Ravha2K62XTMS6xlvX0yTR9QDXuKurOPHyOdCi42GI9ha6ZA4DKPbX0sWSd3sa6E/XgHNwZ6uEgTB9sICoCozrGq62okFhRtSMlCzSPNwQCOMFEGdwaoYPmF7HcaR+D0N8zXnqOwMLvj7sn8THoRlBIB4XA5w8821GbyX749e1rYNmTHgSV0Dcd31kaLTPldpHwuhkAEtC4czu5Z5qOrSmQZB+BpyPhroTLaBP9FnMYnHWoO6L74iZs3WVsHz5ficgVwEsSTDQ9T31uWUWjdkwDpWuwtisC8JbxRLmz6liLFEU0QICUNfLRqE8P7OA6A55YTwuCsAaFLt0H+X1Hr4qYG/bKLI3oTA9a9n4mS0MsVFVEZJBsulcs+bO01hnjBRh/8L/73+Nl+257aXw/XvRPvuTfwwI2SMJ0JrLMuIHoa7gl7U4tvNqxRVsBJeKj72m10uDsbYoOrJt0EBLf7Y7Z8aIXhcXdgY3nZ8FWgAwnoWVzCKE5OoR+MYK/Rn9v3yPtt1c0ucvfrvDzduVCNCvPh1vHbekwe2N/9hMgBYQ04HzAtPDukxeN6OfBVq8HQATjxnbDhFoqfOPfhCgxZ8tbluakLMSKwK0eJLJnKoFUOmJNguZTIBRU9MqX4BFdI0HaCIzRREnQJ2ZlQuKswE7t3CYrLZzg0ikICvdON8sx/Va6IfoG8ZZbkC6zZA6n4AsvS0+dhY4B5d8dxIqJOikkyAc7u+EklOiQ1SACBnIGseEUeRJ0DNDoa+hPnbeJocSQygruQ7sV8UgS2cfQgGZjOmbc2zXICv3zEr6UxQxi5NDXkDKyrBDuvpeXs6H/NcCwKpDFl0GOnPB/xzYIU+u8CxrzzPNPCHey9GbzU7OBRWqPgCwsv1Kv3VTZqc5wJo0dZ11VmK0wGD9pU2A+aSA9RzAynWP3PgchH30r5zErgeAVT/ZYVzVKK/3KRPcpkw2LSrLCCwFbBXCSNHnM51a6HMCsJYUynwJsF64vQwXfi/a5//RXwBAqxF3cUIPazCWFGGmTNA0mZpdC7PrYJhF4TGNBwNjiOb1HrYbQx3CYKS5H0VH5W1gfPSYw4kswSXeOGK37OCxec1i+4B+WPvF1gu3HzMCrlb3CUgs1sGioiuAj29R3WmBhcP+9RH710dc/SQNMJc/HgpBD0B3ZnD+ZYOiDeDlrAufKeANsL9Xomgdym2PctvHrBUehMOxlJsBRUehQ2+IRncVATVvDcq9gy8txsbGO5rdksO2XFPCOEdaA9bksF0AIEkMDPRmaxFyllteSDZvebmRubAcD3BdH9LY83BUmAh5gOfJ6lBNP6XDmrQ8fKhdthEnW1NXKQsxty2jwBjUObDp4kG+y/vMhdHM2nF9OkABstAvBj+a7dKNqx0ELRaHy9lLjgFX0TsKI7bdJBvQZMzmxN09K7Yt1hy5D5LelmaxgEm46rl6IWSs1kxYcMJyMVDJP+sCuMhZRt1CfywzNgwwsioAeS3MuWZyIbyyePBKv3gIYEnI3Jq4LWOJZbJWQEpeLgdQAIsXDOo8JwBrLlw+oxGTbVmyRpEEDH0P6f6o10xZpgDLmMhw8XnJABYzR0U7YlwUWLx7hfrJDsXTW5TXexW6G+gnaDdN10cdY57E0YfKFvmCTC/2vCdGuiwoESjIKl4CrO9Me8lkfRfbL/7cnyKQdLWJLMiuhc8mcMnUcQ7uzhlMP6B/9ZQM6cpI58vAzTohZqbqErAGrrYJ02VGj2FZCEAZ1tSHYWkxVlTbyvK4yePTAPgC6E/o79tP9bC7Aou3brB/5xTNW7cYfusU41vE8rguHNe2QHkb9FkbnrjIK8tboNgDu9c9lh8YbH5hi9Wv0oC+eOKxfj9oqK6ipoCOq6Cai6UlZ/fKAgbozkoUe4f2Tolq46Lx6zYOJPXTPdyyRHEdttmP8E2B4tmGhKZBuOyDWNwva5h+hGOLjstN6ItiE8NgSYWzHYUM2T8pn4y1RkRPIFko0BS0WkXT0Ep5UJ46+zQ7CCFzCYiTVpLGz/s0FqgrGviZPWCGDEh8gCSDKpRukfCfhEamLE7CpuksL+ejpkkzHBmrFC9SlVpbcJkcnowKC3Q9xtfu0a55NT6Mss3d2+exLwFUlbsRw6LAuLBYPO1QbHrYyw0xzHnIij2wvJfwHxcRjqGncE7LMim9oj8PQLzCklBVnt02B74YTAZNVz4myzVmtop1cGbqki8gi8FAOBa/b4VhMlzeJ5TcARRL411ajikclzQdEtWeX/o4tI0FM0/6+eAyVKp559Nw3SEAxVUC+iEND4b7R6wuAgs6O7/lz+pciJABXlWnySPh+6Ys5PywrosTTbz38yFC9s8axigfKcPYMzi4VY3i0RV8o3zjEEKIfE5ZrmBMfA64IsIwiv+e1+F9IGYWc8H6ZSOLE7vt4EKY8ld+9Zen5+tle5H2Mlz4/Wy/+PN/mgaAXZeI4icDPg8QJyE8slJiUSXype86jCc1iiB2ZJdrcYQHsTy8urdKr8Sf2d2jh6w7pfuDgZZOER6D3nP7hsPJ1y1uP+6wet+ivePDdsN3XGDDQrFsBlq6CrtlbMkYLIzdXHKI3fQXj+mDN28vcPqNHW7fXmL9zT3ae7WwchwCHUKdQ04SYKDFthks9qTOhT5v92QKyIMYD0gy8IVzFmraJSExnnD4td2eBlkpJDvP3MwBDZngmBk7PU0+m4MsU1gC6AF8oCqnOihu7PrOE18GspKWTbST0GSobyf1GdmUETOTWK5T4eOdY1B4Qst1Rdzn1QJm32K8e0YvM8hSEzuDLF9QuaYiOFG3F9S/9bt0De3VlhY4QUOnJ0FhEbNCxHkRYF4MeZ7ctBEth7qGrI+HQNZcNueMNitpIWwogMv7xO+J+srjA4eCU/ZSt+S85wazed+rKvVwO9AmTNWx8BwgmqhjCRYCsATUqAWKthHhMN3MZ6XlAEuzXTnAYrF+zkgH37tpMoRa4PI1zasW8KJHhzX5+d/s4De7+NwFvznJEmSAdYDNpuPJkkPy8KRK3HGLkO07+pfg6nfeXoYLv5/tC7/2bwAAaa9WC/hVatbID6uk+l/dwFzdoHhGPwAkjMjNLUoUtx3GVY1xVcNVVopEczOObB1s0DDJai2AjdUjGkzP3qXf6w8d1h86LB/RDwCcf4Ue7Hu/bnD7CYeTb1hsX3donhk0zwyKHf3AUR+LvQmsmcew9hgX5AQ/NgTIbA/Z9um7QYs1eNjBY3e3wO5ugcufWOLyJ5Y4fWePm48vcfLODps3F2iedOjOS6pvGD67vzDYX1BJH0oKsKiuO3R3F7DtANeUwo6YtoMJLKIZHenhWHuiBiMzOJjBwa+5hk862Qpb6D3ALORcTT/VJJNJ/s/S8xcLmsSUW7oJg6wIkHXjQbrKAEo+WbGPVFnO9pH9jJCk3kfh+6SxDoknXAYVE4bIzocbdb+0GF/tNwdkblXBrQLTFT7D/lf7u6XU18wbm/KyL1ZMUgjhUucIYDmf/iTnIJ2kPU903QzgmNX5BI0ch1VzfSZbbmgrguTrKTg/uijm/Xd9AswBBVR0aHhuE5zQkV0Tv2/jODXjTQVMAZb0aYa1kmOfe19rsjgLTyw2DNX3PASw+LPqXplt4f7kbZmyJDaXn7+miRmC/BP6mgCsrO/GBHatqWXRhgPhbjOMQFXCXN2mACvzfjPDGAHWoUUNH+/oBIRNNKVhId7fX6G/v5J77iXA+u62l0zW97j94u/5kwKYTBjQTNBnies06144MwhxUGSA5i7WBJx8ZF5gAW9MtB0ITaq5c0ZdoIm1uy+LzMfgWG9Z61WyXisOEPs79Hd3Ru9xBiIL6YcTL//bDvAVUN6QKL9ogXIDZcdA36k3nqrJG6DogG5t0J0ZNFcelz8ZDi8wYXe/6LF5YHH+9QHXb5eobqmO4cVX4sS3eBg0b306OEmJHM0oSSHXTKTK52+ziytDlYUDgAa2foimhsyOHXuuco2OqmEoGqe8rqGIa9V3x5HCImUZ/XjUaj7x4RpH0UFpbywJP2blR2iFO07CMGmXot4GQJqBKPs9wGTMbE+OfRW8rc7JTmM8o8mqfEbXdPv2mXxn+wpt5/zrdP55ocHZWNWX34s7yNLuBQSyTYO218gSTqLoORWVy3bCcyvFrmfq5tH3Q4hNi+KVVicBdZlfE52jGUApQmdVIQBIzzHXEcxF2vk2oAAWfz+URZpcQx1K5s+Axi0xGxU3eAWcyjCWsQeW6A3H5H3etjYVTWwydJtjA3XyyeTzJrEdEXDjsvOTZ8rmWkPVf+ii8EC8z44wT3LPsRaNt7VcxIL1uf6OFwsMzFn4zpnsRUGZ69bCh2jIcBoK3e8jS/krf/tPH+zXy/Ztt5dM1g9K+8Kv/xnxGnHnISx47wIAophWl0vJHMPNTQh/BM0QZROGya53MD56BfFvBlPeGLiqINfegcTAlvVP2eTkaotxSdYR+wvSdbFPF9dcrK9DiC5Eooyj0F95a3DxJfr/zpc8TB/CiJ6+O6yB/pQA1NgAdiRQpTMj643HybdGtOcGi0f04wvAF8DTnzJo7wJXnyip3M6JQbn1uPxURdswgKsKuKoQ93sZkMKg460SoXLLs244+245X8gZiLS8+ADx/3M+SIc8lGZCObJv9kbilWwmuDZ1TQMzT0RaXDtkYZ+wQjdlKfqeifA7T0cPZp1e6cFkwjyUYfY8b61Dx5y3Mj1P7GXGbX+X9lMH81u2/phtqnbei/ZtEmriNlOiRgAGW7QcOgfayFWLoPV7wV6D+uDm/bByloYB1hxDxQCLj0eKHU+PTwAds7Z9FgafaflnGGDJOKYzD8sKpPuaB1jyPe8iePNULDoBWMz26CoA3HT2X24tEX50sofoGTkT+HkAixszYEVBAItrGAIRYA3ZOWetWNdNAJaAMWPiPeZ98NDKABafKs3O9j2wWsp4xWOdaK+CdOJX/us/9RJgfQ/bSybr+9h+/z/xywAA08YBxl7dAlArHJ4cONSnM9rCir9744LeE73BdF9SOLrKNEUBgPWruELm+or8HS5o7eWzesOhezyHsW/knl+PnWH9FmuxuJ8sXBd2S+cFhD7cvE1fau/yhErfWX2gth++dxIqzNdPQ7kIzspRqf/CaHEIJGdhEh1WGFxZfMqhGw7FKFqewfDsRIyM4eIVaKYBSZyx1f8ApmaofQrCdZN7hSdMvpeYbVM6rQnrcuh/YHqOcrZHT/QCyJ7PaJkl3c/+jMAUl8MZw73pwvm+fTOGT9kEd/V+YLIC49q8H8LsHz6O+xIQqMThQDyHqtRMLiiXY8snYACT5ADeXg6edJsA/JkQbcZuTJhDfU3yMOABT6s564HcWmGizYJipDgMeeD/ZF95xmB+H+pjy8Lnasfxz7wc05G5S65lfm24v7wY0s9Wrpvk/cxJATKh/NFSVEN2P3DLM0OhWO38GOcAcV7s/Yw0ney1NZ7p4vK0nf/ob/2p6bG8bN+J9lL4/oPefv8vkG7LKENMGyZvXxYkmC8s/O0GZrGA3+8plMDX75Qmpv5jF/QdYwgkjT6Y0Snhe5Nqi/b3K1Q3I3b3S1Rbh919K4CFARGL4scFsUblFgdvK+26vXxMx1NuAmDgt8JDnxTaDsyFyxgMLgmxfRAn15u36LX9K7Sdu79BfVw+oaKl1e1IpYgu++m+jAEGR9XuRwe/qGB2Ha38uD4YA6pcBCwHqSYVHnBDUoMAnuexNc4TaBrHFGApHUzeTFMTu7FakCUBT1KcserUMfL2dKkdqNUvC711ar4OZ0FNfpqZywFY7ss1N3Hl/ko8wWu92QWFAf06CH5Dce6xoSzT3YMFjPPY3wn7c3R/2c5Fr7WwWi+/9ZS2wV5mACY1E4eULUxCWrmgPDueJISXMU2StXns+mvw+jzBO++HswzrmljIuopygkz4LsekGDxThHBmBtr4/eQYBi4FxdmUM33LwdOcZYmb+mUBIBf3mf3o0KtkDx5jRjMgK2HKvLqBapNrO2fpkL/HTYVwJ6yhsFdDzLblBIk8W1cL7wODZppm1k9MGMG2i+fDBn3aYkH3WdBvutNlPDVhHH1ZX/B70l6CrI9K+8WfVzQuT/g8cPBExRS0XsnwgxnE2v3HLg4Crf6MC0mHDMCdmwVaQKzu7jmj+cZPgBYXabYdg5k4AfHkV95y0dPwmZlMMWF/wiqzv7dG9fAG/aunqJ5s0L12ivKGtrN/QMfZntOA+fj3mONAC0jB1gzQ0ueRmS4AIpaHtdHtPHzWZ3XcuLhrwhIdyrSbWSnLwO9cNMdkbQkiyALU5B40WVKDrY/1/mR7mfu6aFaG4aD/UeLVlIONXKCt39clVLSGaS7TbbmIr927A4wj3PmKEg8UyAKA/Su03fbcSmWE9bdCiaqWHP6ldNXTGwKe2qld95HDUKHANoA0HKUY4yTLUp+XY8LqWesAlwLUY47vOhEBmPZLgSyZeIMB7ARgqb7n2ZCzXc+BD1LGyqtt5foqABDPtCMAK1YzYJBYxf9zgMWfVdYVsj3WDloLt28joyZGq9PrICwWP8d5lqv+vl4U5AArzyDlc3UIYNEJDOdIsWYZwMoZKm35k4NpyfINi2ydtfiyBM73tL0EWR/F9os/+yfjP7wQCmwM+51Ejcf0gffn5B7cvbJGsU1j+a4JQCbUD3R1vEeGEC4clvQahwDH5fQ+Wn9A/Vl+GKwklECew2osomejT66xRTtJwxhSgZ61R5pByXRJrD3Y/tg56mf0vfZuEHqG0kFs+QDEAtKs3WGxf5FVmwfUeeawYn6+1f51qECygMLA6EP5ltnJLWNWNMACQCArcxVPWJN8cpDJZxrSmhin8uQRmB6uPae351UGnWiNMrPJSQhLHY+A0SMTvBTcBeB4ouCQdlazjW0ZuGIBADTP6PpyOZ3yCYXbcXWDo22GvQoHRP1SE+40zJOBq0OAKvt+UsxY/T8biuWWJ2FoRjIDeyZ4nAGY2HQc1JcBs+L0mQ+FDcVrKN/LEwr0+TgEuHLrhqwigP6seLgBkUmcye504V6eTQ6AYlqh7uesSHsSTs0tK7Ki4bRTvgYHrCKA+Jwyy9iniz7U1ex2mMmehFAZJJ6E50UlyXz+N/88XrbvS3sJsj7K7Rd/9k/CtJ0YZgIgqphZE2uiaeaM+aM/W1P5mIsVbDeSyaenLEMOobG+aH+/xuJhi9u3iSnKgRZMCBkGsfHpu9SH+hlNWuOqRrEf0J/VKHYDXFMIqJECpZ5AC5c5EfF415N/FbuxG0NAhCcaHli5fIy1lBlYkeh7uBPFYu3dBjDko8VgqtzTQN5cUjV547wI4O0QCqmGicJyWZ7CwN7sov4qA4G+LBJGwrBoWRUilszDYUhLzeThK2ST+4GMxYTBmgNo3keDRH6fC89qcbxzwrhJ8WFAGASxFKnKyIzVddwul9DRTbFuXFtP3LY5rMr+P5sdcP9CNG05yDKOak+OwSCWa3L2J4WAZ9YJVtfU10Mgy5RlUmNPQro6w49OcjyfecHi3FWbXx8GYZ6SUjVz2YVIQRYZySr7jZDJmWxLfS+GksY0JCmZbFEwn/Z9HkDNAqxDmYQMADLglOyfOho/5x1y4CrGo9POTEOEDLAUY6zNchlMut2etlkUE6Ne2XxdxyzC3AOtjCa8vu2i6F43zTwPw/x5AKbPRR0ZONk2f8Ya2o5Yo2Q6q6JIQrxSNqssSb9lLXxdvQRX3//2EmR91NtnP/Ov0x86u0xnsEjR3CHqPIyRCV1nyEmGXZjMeKKy2w7j6QJ228dSJUF03F7Q73LrcPuxEtXWY2joeznQ0qtvzlp0dSFaLdsOlAk5jjDbVgn2Z8Iw/F6lQERWWNUL6GDKzWG4Tyxeey/UBAvMFgOtYu9QbtPBkQEnW2CY/UDhVq8KC/MgyCBLC43HMYIsQICWb2e0VVWVAB4/DBIa4UzFHGTRKcqAFmu5eHvKZTwRzh/IbPQbylKdgCxk7JlMdpnW5Vi2ntXAzANVRYLku+dRv7bkDKgahtlMzooNmpKBBbwWGBbqPho8lVJCBFnVB5fpOdP2CPxa39GxBad7+RwQAcFMll5i7MnXLXNpn80qfB7ICh5N/Nrz2qRwuO5/DrK4CPIci/gCYnXV6fj3MZCVZ9e9CMBS1g+0fZuEx5Pt8rE4HwtUh+dkEtJGykLa5YJCfU1N42JdpWBJh+kOJWjwItb5gwkUUiEgLDIATDSJSQKLvmYa9DOQLorJ8w4AJiQ+fe4rf2Vy3C/b97y9BFk/bO2XfuyPBi2RKloKxAHdhIrsXM6HmRUORTU1YEzMquO5ZqA6gGb0cHUJG8JlPoQXhztLmMGjC7quNoiQm+DWXt30VGORwZ0MnIYsJJoCthvl9eJWZQC2Xczc4wm6j6EIrTcQfRrvp6nou/mEFgbp4d4a3hps3qQJu18FYNkDq4c97EDWF8U+W0kqwAUQu0IbHGOJDE4B1/3Vz1U/xAG57UhbogZ0z0WFdSticdmYKWVE/CqTMzNsuSeWLlQMNaFbS5MLT4IhJOFuiAGScjtQIE18t5o4yeTaEraEqCr4ULKFjr2n9Pa2gz87gdnu4e6dSfiVy3lws5t9FG83BByHiwXEjNeCCqGDwFh3Qdd98cEWph9hr4PQnfVzwEToz4Xb5XPGpCEmPZFak4KrcB2SiXAOWB0IIbJeh4FrYrkR/uaEloS1gmLMQlmkSWgxgL48PCsgi8HMnHeV1l/NsV7eRy1VllwhLBeDFSWInxPMG2VzkjB5eSLFoiF2iYHKTL9c2yrRvAJ2fK4Rw4TJdjjhRGm+EhbJ2tQuIjkXR7R4/HnlGzYphRXGi8ncy+A916DxM75cAmWJz33jrx3f/8v2/WgvQdYPY/ult/+V+E8eeur6ib/TBGhpw0ue2KyNQCLzemGgNZ7GCb0/DcJLRZAwq1BIyM0mv6E8quxOZVOy1QKzHDnQKopoHJofk/78kA3G3k+q3F/+RMzCYfuJkyCiri73URck+2GmcEx+8/YBpEDrkI5HTzqc3SaamiqGsXSYDwooaC2KXu1nE8JET6KPha+71vcEkDWZcJhdys1RZWPhmnJIJCsn4pdNLF/EZYuWEVi5OhxDSJawmxA6XC/EQmQ459qe0933Z7Sf5bsUHuQQNIAIsvicakaQQZYO1R7Q8hwKE1KH7fT1IxouYQcP7CvpE1+LrpsVcudsm2ijtM9XJnCfY68m2YE6fMrfUwahLIyfiOcZfHif6pey/ea2BxP/K/Veso0sAYH6kunB8uzVmVC8AB3ddV0wGRmjOBfafE7zXZ8scPJtTaopaDuXvG7jOsogPvfeX/+2+/KyfU/awZvkyJP+sv2gt8+9828BCGBLDADD5LFakt5p2cigKSCHJ8R9G9khLZ5loKVT+gGYljLdCqiQThg0WPA+NlbeG5eVsFq+Kui3LmQMJIaTnv0ihrDS7Qf4wlJB52EkpoQ/W5KuwmtHZPWeyYwB2V2/egSgsLj4LUidu13IVBRX+4sFqssgjK4KYk5KS0au4ZgtCGj50hLgErG5GrxFm2Lj6lazX0VN7F1VJaDINBmgMdE80fOksdtHtoUb73scYayNNfmANLORMySZRdG6leUSfrcjFmHfJll20liTIsyAiyGzuqLtKzDs6yoBVuOKtllse7iamE27balWp7aPCNmxwlxZBrMK9OqIlbIO8dbQvSI+Q2FhkbMhh5gozWZxy13aeULOQUrWRB90YGLVgMCP4T6v61TXBQJbpqwiQMgzPIsi8fqKX4wsFofrDgKstONhw0Y0YgnAUtvV2qscYMnnkYYEtT0IZ+z5ridAz88Dn2OdScnd0wArA1dzLQm1h+dRQnQzoE5a7pvFmkQNYkNhbUk+0CE+/ZmZ2o6moGdVAFaeOIKX4Oqj3F4yWT9k7bOv/k9mX5+k8osDehpmAhBrbgGii0mYmzxziUs3nC1i2DFkFBp1f/FkyRowM/qkJJD+XrHhrD5l1Kd9ozisqMOlvC8pkhsGca3PkY3Fv9lbhrU/bHEBDzRP2KssDIpBY6Z9x4oblZknYDcLH+r2Io7v6nM5OMaTyxiOy1lH3fSzna/wFyozUoNB/T2l05ozkJTGk4IqPcT3FTOCbqXYK76nnEexCc7fbJkRjmO8oNW76R36u7QtyVJV98RwStttPriVfXHI0F9dhx2yJqubP9dZWGY2lCOdD+dbX0MNZvPJXoO0XBf1vLATfy0DRLrUDjNiPmcgn7P95wHDF2pZWSLYYqK3OqqTUrqqQ9YLFKLOJAA66zU7/tl9K6A2Gbu0DmuOecpNihmsbqP/Gm/DLtVYyudG3Q+zzv36s0DCmn3+0b89//mX7QexvQwX/ii2z178YfojCDxFt8ODzzCIPsifnaQTEA9eklHD4GIg9mbXxc/1A1BX8KVFd39FmXpDHEi14SgQQ0TeGmIyQqiovVuhuewxVhblZoDtR5huiLUYRzf1ClNZfmYYo8aMGS5mtLxP9F3JbxZGs8fYnSX2rzYo9mw94VBddzSJ82e5DNGmJ4brpiXh9uiIgVNFYY3yudH79tZQhiPr5toOvqnpd1VOdG3ufAW76+EaAgUcWjObHQHjro+TQrgmZFhaiKUEHW4wtNQTotbkVKkGxtxugUUjRriiJ6uqUNSaPIP4/LmzZehfKxmffI19QbU1x0WJ6slGvLDMZk/nZFnD7Hv0r5/RZV6W8n32SAMAF153pZXRib3Yysc31J+b24mmJ2F6GCjx5KpqheqWZKnldQgzHU3imp5bV8gGU5CVi8E1qMrr+U0AVw4yxjHxsZqttRcA+izrxf3zLtn/JOMwWDiwV1WSITnHDmomVYEr2pQCWBkoNU0TQb9YmwxyHF6JzXVWofRD+50dYsGAlLGXkj0mag0VsPX7PX2Wr8WSi7cqEM1/MzMVxPqT0GN2fT7/9N/By/aRbC9B1o9qY6Dlx3FavmWO2bGWdDS7VqwfRLtVTlfvAoDUttrXSPdUBF8qu++RMy2mHzGuQ/mHkMnYn9LAXLRetltfEsOhvbWSTD9l56BbokfLtGjU70y8G7IxfVkIk3fzmQsAwPLDFkMonF3uppld4v/F7Btba7A4ubCx9I4e6A8UpE76qgTObllRYkL4PIOs5HhmMs58U8Fs9wTgrm/hT1bR9ytnEDAFWcn2WVCuxP7yPc4UPIt6NwbU2qBW9HiXmxQUAhheOUOxabF/4xTlbsDYFBKSrp8GvdYysiNcasd4j2JDSRf28hbYt9E3SZ9zLXjndsRRPPe2SkDWzGtzIC0HWd75qdnoEa+qRA+VgSw6ltRu4BjI0l5RSemZjGXLy+YkIG1GwzUJceuWCe9nAZZmc7QXl8oqFlsS/Xm2fDjUqiiHkHOeZ0AGgEXJBBlrjHgP8P3kuy4mgzDAGscUQOnj0dc0t+UYBmG4XgKsj3R7CbJeNmq/ePo/lr9loM4HSGto5da20U4gTKBms4O/ex7NNk+WwODgF6VMhsK8NAWKbR+tIqxBse3Cyj+EA8R6YsRwQQPW/lXa1+Jhi/6sxvLdEPZhFqsqCbSoDDIAqnSFiQBDZ3Eprx3TkieXzu4SDyyrsi4BjHdPMK6q5Fg4fFo8vYVfL2K4q64I1HH6NZAaq/aDuMubXRc1TNwHDm0xE1cWAoj8oqbvh/BsPJYgtGfbDoD0b9akdQSBmBWphLmyIg/ZmcKsOR/PkXOR8QlMnWk7BcDDtvoBqEq4JbNtLdyihr3dxb5oQOicHI9pB2x//A7qp128Bx7TNRnWJZpv3QKlRXcvMGalQdE5lLch0eJJ8Mba7uC9h7/dpELmoohO/BmLlehysqyzo6HYuZqDk88qEKYBx0w4LwdfufYpMe/MtnFMZ2WKAjBWASOXZv9lLNVc/ye1B3MGCxnrhxi+FO+vzDGe92eyjFUTPMP0eZXjU8/mpNyTBsEZoNF9Fe8p7kO28Iw+asS6+WGAXUUBui5/k2bYEsM1sVphgMkZrkWBL1z9u3jZfmjaS5D1sqWNwVayImawpVdkuX8OAMMhuhAeMv0gRpIuiJrttsd42sB2gwJdIcRTWVTXgaG6UYWNw+cYbNndIKxFeRVCY7uWDEv33UR7JawW/w2k2Yj56j//bga2fAjLoSqTjEoAKB9di5ZLl+CZ+AU1SjsV9E+ic+PkgcJEZ3mdOcUsjZ5o1Gu+qVLjQ56EBgJ4syBLNw0MFKAw/ZCGK8M5dKcL2NuWfl/vkuP1VZno76Rpy4u8he8O909Q3NLx7946DcfgMS4sTn77Su6HItwD+4+dyCaap+E+ut0TGO0HYWjYbV98kXCAyTpQHgUIDPBcgWBt4YAZkHUgVPc8DdQEZKnXE+A300/53LHX5go6H3Lkn2GvZrdrbBRyczj9QIH0g9vVWYCaPeRFh95nCDmajAmey1LUzJ00HcpVRqEAyCyUw7gMEBXDldua6G0kC74ZVosB1hdu/71pn162j3p7CbJetuMtZ7hItzMzQduChK6ZEBTeSaqx37fA6Rpm18LdIW2N3e4x3lnD7nr0d4NOZ3AYVpWURJmI3RVAcnUZAFtgavY9gQk9mHNGks6IO2Ca6ZcNgYm6Eq2WbypiuMoiFbBbG0N77PFzsxVxt3z/2SUB1XGMYQRrgGGk0CtAYKMq6bVFen7N4Iih0xM2m5Qye9DU4MLSXg3khg1aGcwUlnzUGCgKA6LOgxbianPFfojasMAycWjXtgOGU3qtvO3g6iKWbOLQcci49KWNAJSB2qIWq47hYoniao+bz5wDALrToHNrPS7+4SX2r59g9eVH1G1O0PAe/St0LstnO5h+jKFYp9glvneYcdV6GkB0NgBiSaGgmZmYi+ZsCe9jDlDMhAYnr38bwndTVhBDUSBmBqqyNsm+ZnRTuh+zTuu6n/o4Dn0/zxQEZtmrg8enQ5IzAG2uakXScnF9BqS0ti5xSrdFsl2p86n1Yv2QbN/v26l2zxh6/kJiiN6HZAsqwPUSVP1ItJcg62V7sabBVpKVA8TBTwtbMwNCAAfLxDCrwxmBZtdieEATLGceFrs+tYwAaH9NHUNdgIAr0/URlOSi5ENN+wDx9hj86DZqMGnifqsS/uY2JhLoCSY4qCdFn7WD+51zAXcAUoNVPu6bkLmUOFCrR5CLwjbqu1IDcmZiGwYyBAWSMKhsN6sT6atCwrlcPxDGiPUC66yAqEfLa2MCwP61NRbvk//WGLILh9MK9aMdbn78BOtvEbjZvhZCg097XH+c/r73a89o+7f7CGY4Y7GI45m9ovPt922cbDVLmTNNfQff9QnrkWTqzWUPau0ON+1FdUjgDgVOcvuD9EOT7wGYiN31Z+ec5Sdhxud9R4UbZ01DD5W+4T9nwFFe+Hn2u6qwtLYyONaSpAT2w2On/BkLBlPYuD+d6CPlp2YYQa1r40xmXZdUanp2Yssy0eypbbwEVz9S7SXIetm+vXYQbGmgBShLCKUPOXRPsV5Ia8ACyBgenIsVghiBOpcCLUDVD4uZfsJksOeN2lfCQsz1K3fcBghs5SEk/Tke7APY0p8zi0V8LU//BgRkATEMp01hdSaiud0e7ndVTUXrXHJIf8faBGTp/miPMa9sOzSwmmtScmlRotz0cJUVkMV1Botdj/1rxDix9UKxGzAE89r2nPq8/laLxz9DrN/dL9H1v/54g1f+s/di/0NjgOibEvYZnWOdISdGqKyLA1KQFerDcQmh2XI4ziVi6aSpWoEJoJkJ4WnQErVMynpAA6gMkOgw3Bxoke3N2EPMhQZpU4cBU1In8Rg4SvqoAFbOEg9TwK3HBzsjkk9AVsY2yX54U3n4VgGtiTcVe7odajqUqy1i5hIjtHdXAFhz4eeX4OpHsr0EWS/b76z94vm/HP/hgd+5NLuGmxaCAilImFltcw0ujGMEA6ODP1nC7LtYQFqFZUSc3Q8xlKR0P7lfFb2o9ENaPxHEqgI4AuUPY9JjCIOqYSZpt5sO4tqvyE5X/YmBJx8rA5xwzMmxWEsWDUC0ZGCxPJDWstTHycwcC7OrMnHOB4hRFHd9xaixs7/ZTyfL3CbDF4ZAsXh6GTERbe8EMbHz8KVBv7Kw4bB2d+nzp+/2Uhfz4tceAnVFx8vXoq4igGV9ziZ6FEG7nBeK5WwaAlUV175zdM6sSVmKvDSO9xONG4CJcSi9diSUNXefFxaOi27PaKIO6bH4veexTpOQ4EzWYNJHfRy5/YAK47FxaJKl6X1qFxEPZtpvIJhzqns1TxhQWYIJoFJsY+6Sn4At1mrpMYJD7Xo7wXICQFq+Ro1p0i9mzGYWG7qPv7L7P03ef9l+5NpLkPWyfefaL578ofgPh7jmBKZzQnNgGl7hYqqAABgsmsgYMeOjgUJoviwmzJBuiZA8EaMqPRMDFl12hY1MGWzp49ErWJ7kNdjSYYesXAeQTw5hAmawCkzrUUIBTAZZwJRpyY5rzi7CaEsOfi0kEyTHqI5DC+81UI06q2j6qEN5ANDeaeQadGfBzmFMQRa35VefpsfK++Fdc5mcOZAFZO7sGdBXn010NrpenpjZviDI0k3remb6w4BlDmRpAHRQ9H7s/eeE9WaB1nPa/7+9M421LK3K8Lv2Ge6tW1W3quliaGkENGjSoIIig1EhRKzWHzKIAlFoFKOgxsTIjyYmxCHGKcZE/xhUwiBhMCp2CE03IRL+CAoyg9JN20I12k31UF3TvWda/tjfsNa3v33uKajTNdz3SW7uOXve+9y793vWWt+7rP9WLSW2TFw5MZU8yLoCy23T7tv+3VbaEHXEVTimtE78mzD3Ji2jWTZiabotlI7sfdx27h1L55N9B0UWufgcP3STH4GDSih/L6EFpG/OaZmFtiPCgBxNUvWeSjFKEx+WsVVNFFyxsD0e13zhRYf11opi49xOPq5w43XfaJsmt79Jhegb2Rm90nQWQKfxbLxOaaTSxtgYfIbzPno4R5ligf1sjkV43Zw930aiQqpUxyPIZJoiUp2i/nC9dHPDTUt9Kq0rvjFQ1eGgFUkmsiTTWa4HaxosxkOgQRotudgcJouLWCQ/32hw/tHtZzHYVUwOtdfh6B1tlG52cIgD//1gOs92Q9lOAiIpfapTU4cXTR7jtS5bzWyMs3iyja9tCqgQAlqLvNp2P0F4lFEtm9qKjZzb7eaRaWW0KXpmxe32zYvnWi7ft25cP00rnNTtCLtU7xT/zoN9QrtcPue0XfP3bP29qiMFzRcTdz1RRKxMuraszyoFVmqODrT/u5OpE1E6bb2nXCrY3iuCwLJ+V6lxd+nLBS+4KK5IDxRZZP0c33pVfmOdlss6CaCbsgB8FGbmU1uAiXL1YQVepRDVYbYVPcBsf73kaA9k81OYuo2pcVCvuYSXI/dQRCFqFgJ7RbtMo9honxEd09s32nlt2xLFNKA7zpk59kr9WTIthYkEVtouWdScR2yJAwCnr2/XG0zzcW7flaNSg/vPhGPqRpCAfO31zNnOPgFUBzv4qEjhGwX0fwmoWTPUIoe1/Rs38E4EBeiNXC2tiyrW6+67e+wA6q1iDEvv/3aUX19RfWX/fVGr8pjCAbS/3BeR+rZqo50XpvVTirya/52aYK7Or6V+Ady++87qdEIKKLLII8vxrVeFOglfl5S+3Y/HSI1W4wjFxTzXO81m7c18OvFRrlg8PxwmMZC+sZomvK030tw/eK1JoORv98leYb7A/FGhWPv8NDchPpdv5NF7CQsFwtD/Wv+zeL5APZIVjyccjK8PietHs0STipQj2ynqpNdsp3qt+aNaqwxZLNJIvsHZ3dQWqXFiKV5PuKbKeQHNv+PnZaNFJrKQhKm5j0QjUgA4/7hWZO1u5+ty+KtZtI5OtiJrcWiMwcnWTNQJu5CWlc0N6MOm2L02IMGewjT3k6sVJ4vtM1cbIVvxEPORl4qIjoaw8A//WjqvVhjfHosRNWU9UawVRF3Yd1r5OLGz4i28iHCl400GpI2PeMX5thVQEcFrtxu/aPmBKElkVtKttkatObCZRF8S27boXhd59J8dhWhFbGV+eW11vqCwIt8MFFnk0uNGLFZIheDW/qBSn9G+6daZVB8KfXYSFfRQjhQtjPlocypHW2p1QWp7E1pTz1r6ydR/JEHVV+xc8ymzUQRnE9GKncXRw/lQDudRXLZ/ZGr2ba0nTEQsicvzlfMCulYXAOZHck3ZdDtHus5f2y574Bv5vDfveTivaMWGrTuLxxVFLfJn2ttzzx1QeOibkWyucNqOcEv+WvPuNLOtvnS3S1VFI9QeEVVL6+35N9qTYqtFrFwqr0g1dqiJsMb83fZFl6JY2TURXnO+TW0k67IRfnb/6K+Hqj6r+iLVZXq03G6Yf9vpty4/LkJWgyKLXD7U7CEAI6isuLAPIBsFimmGGPHCajdnqaSUUEnNAUj1TYvtAxj8X1svVPXSAdJDTK2NRB9OsIzq0+PxbmXxgp6IWYrumebNXjDm14gBhSJNGCNesfE1AFfwboVmqtMxZqqz7SxKz13XPmQ3Ts0x22qXPXj3mbz6g6fr5xGLy20KyLxObuLWtqFmFGqoCtVyv9alv+Z51RMFioLJio0q1ooB9ciWGzhi7SQqaUu3LRtVNL0IbeqxOhqxJ01aeod1qEXlprPOyL8OtYhSz7OnOgqxR1z2RgQrvRptFI3iilxkKLLI5cnxw6/JN0fr8mwfjkVRPIC2tY/xLcJwCN2dpJY/znBUNRt4TiZ1oQW0+zRF3hgOsmP44YPAg20ERjbG0J2dnNqcTDqF/OkhZZzBO75TIb0URxbqbOb8uVJUYzzK18DUgnWEQumeffhgSr3Njx1BE9oFLbbGTmTpeOjc2tUOfJsvcmTr7I7rP2hF1vTaLUhoAj09MsJ0q8HBE6ENzmM3cOgLJ9t9HdxEc3+IZNmCbCCZv+qp0+m8o+eYHShgDUCrKanIIttkpFRb/JxGw/w6uOPnC9IVWC4dZvsWmtore4ydvoK2qNpaRti2PWU/xam30LANknWhWawNBjmtWjSTdkX0tj8g0E0NRvE8nfm0pE092jqtVTD+dk7A2VReWShvi+QbL1CdU/9k6u0qTKo1XVPjeUZhRdYIRRa5crjx2l/Ob3qc5FMdjf0WXklTOCFmtqFFuialATfHuXfhaJjNQeeLPLJwMq2nXyzGs8m5QdcKkPsK3uNx1wQnsFxw9R0PzHWazaExvaiKRajlkp0ZdCP6kPljjmlFHUhKO863xinqJQvF7GB7vOOTOfrVPJQjWamP4OY413pNZymKmEQWgMU5k6qtpZ56isGtx9PekZNufZUbIdqIj+xUrB1sc2I7irAZj3wdYCmk7DaA3I6lqBeqoebzr6YZ+66NGUFX6/vXm9ozEeOqeWho99M5zh6z087oyfL4AP+3Z65Nnl3////gA39TPwdC1gNFFrkyufHRv5Lf1NI2w6EfOh9vuhtjLzbiw82mGuzNvHeUmfH/sQXwtibLpq/iduy2S4PEtLB5QLgHy5JIW2Qvf6hi+zVTVluvpEdy0+VYGK8bg1y/ZbZlC9sXo3zdbN3X4FSupbLXzdUy2bZAttjdjB6speKWGnbW2Gu0G5Zcf9fcuSK0CmuAZMvRV/9X8Y1yNV1OwNU/1966qxXo6zfoPpfK9W2sWW1f1K9v1GSP8Wr1uIxYbSN0xiW/kpK0f8MfvP/NnfmEPEJQZJErnz0FF3IBeMKKHttqx6UgvOkpANdmxlofRBf0tpFzSBXt7OY0znTmHyDx4WRG6gHmIWTSgu4bv03tWOE0HObld3ZMamXRL7DSTguhFSMT41E2fD14IB+nbWljroEaYRVNTBcbQwxDW6TF5hCDB4JQGjTZAiM02wbQRtGCdUbbPsmIrFMhnTgYtK764Vj6xFU6pU5vvhzNzFGhuRNF7npHj7JZjqphNvOjByPWwLISWevUB5rRdalOyIx2deLf9kNE/luR0dALrFEl6lkI9FqdYq0VTtyP8+AyPQJ7hdWKuPRmMVjFClO7n9Jxvp02oLAilyMUWeTqxaUXI8buAYNBjiyUrvDWfLTmHq3q/bnijX++SCJBdiZ5umo29myaFIlxD5A4iq3WB9KO+Ivu4NHKAWiFQHwomaJ4F/GJD3rTmxCDQX6Y2WHrNjpmzFl1NPQ1TnvU4ci5nWz8ujPJTcB73Ns7DX13c12bmhShK4KP03pHYxqBbVs/ld0IGvGDHUoxa1oswQgeZ8hpr7dNxYaUoIvkhP27XolG9LlRqMYEt+rubq9hzWXeYmqT4t+eFWxAqFEMx9eJkJWtduDFUtk70Ylc2xexFskaDf0oRtv02dQwxuNk+o9c5lBkkf2BE1ylQWP8BjyfZ2PP2TwLr926NUCnl1p8QE6n7Yg+tOlDOXSwvm9rrumcsyuNdOdzLwBsj0XXrqSpR7rcyLOKgCqW8WlSE7naNMLEClPTk9G1OLJpOBv1KArT1aaF4nE6y4YdHymxrY5q4srev8pIlrm+SUio+mhnT2oQLoUXps/nWYjYLgXoT8NZgedqmez1std9p2ekoh0UskRU5WOe5yJ4O8KwJ73Xl3Ys035qI2Y9rXR6G1MbUWUjiH2pVRaqkysIiiyyP7nx6GvzmyLtFrHpB1doa0VXT7EtUKSLYgG4tV4oo2dWOJzPtUu1voHAkhocG4Va8n8chWC5XUeP2HIp1EIwOZFl929FpR2pacWEbZVSiqz0ZlEXOz0CpUPNkwzoF1n2c7S1WPbzms68uOhxF+9zKnfeU7V+e0An8ubWsdgIUa0uEEsET1n3VxSkl8uXNhDVfolL9uem28/e2iqwZQ25cqHIIsRy/Mgvti8Wi+63ePsQGI26kSzA9b+LlhBqxcXMRDxCrY8MB26Z9PCNQibM03Pn8wN0OsvRg6ZxD9PGikPr9j0auvXKBrnZMsBERwAXHZNB0+8fVo7+UvWtcAAfzbLF4UCuxSq2K7vT7GZvBVIx2k0n047zue1BZz8jJ6ArzaLTMdQiZsbp3Y0MBDpGnWXEqj3vHHUqBWI5gq8j3FeogSqFS3ZaH3Sifr1NpGttcwD3twPk87U2EJ0oV01IVYr3bz//d9XzIeQKhiKLkGUcP/ya7BJe1vBYTyUTlXBu9PH/KD6sbR3VfJHXSzVgk1xoHbc3Hvn+d/GBHIXVQl2LGCe4trfbNj+mrqzsi5fqgaIfWDxOoBUd8YHbDHKNTIwAxYbcKKJQsV6pka7QsgXWRtA5kWWjfGFwQLTQACop1dnM+yuVruT2c5ovvLAqttOtUetG4Kq9BWFEx2jozUPLacbWwH5eSWRZTyfANWrGfO4LxuPxRCFcCJsS1xjapvlKcW1SnzqbdqNc5tx76+GMZxcAJ/jYpobsAyiyCPlW+PEDPw8gPJCNwSFQFCNb0VI+4FIdSlk7VPhd2chS0fpEQmNozOY+lRbEiGwH36vwkEsiJUVngvArnNCdQeuBzey0vrnh03ODQRZZ83n2uTJ9+1D6OpVRGlPvtTh0ABLuQbND7fThmWCseX7iUonpnOyw/mJ0mvNHgxEzVoCiUlBfjsastLKRwSBHHxfqI5zDoY989Yi7xenTnVq6KPIWcaDDskEGPTYJ7Qayp1nHIsFFJQddL6xKrZUbrFFGvIyL/Ydm7+4/XkL2BxRZhFxMjm+9Kr8Z+GhMfBCX7UY67UdsJMsKrWKUoRMAlehMqjEaFpEdWwt05ly1YFqkHGknKV2qg6YbnTIu+rZGy7bgwcyMzivFi3EWB4D5kTxYYH5onNYbPXAuny983RZscbhpnp3EVkgR6myWmniX6Dy7tVtfpnhuvXVfpidlPqeB2391f6b2rlPHZcWSFVGzaSpe76T/RkM3wrEj6nr6Ifr6wcI81BigLibT+khGgJEpQrpQZBGyTmKkC0AbcepxrXZmi6ikJm39jS3OL72KphP/gLTLbm50aqisCNLT2ezT+SiZ4nCdTIDtbFDqxJYdkQm0ws6+7+t7B3hrDQCL7dxXcWaaTI8eOOeEppzfze/tsQwaZwyLybSNxMXzMMamnRGWKxbQa5HSA4rUoTP1LOrPVhjYEPeRtj0e9/thLbRTpN7XbBplzZZtrG3ThvA1Zs145MTY7ZN3gRCyFIosQi4HeiNgQMfR2g7ndy2DAGA09rYBNtJT9uIr1y+bJveJokHjR/sBkK1Nv8xuUT9lU6GLubeRsBGVg2b0ZWBy3XY+xHtP+5knH0p9Ke3gAT17thvl6YvcAF0TTtuXz/YUrFAWp5fL9kWWbBPzNN9+dmVhf5kGNOs241HXsLOIpLptFSMT7X45mo+QiwZFFiGXK8cP3ZTfFA/ycqRYp7XIqD8S5hoWm2lpUVVXi6Wzubc3KHr6OQ8nXThrCN2dZJPVsLyzvRgVwm7rgCug373+SLrLbHztwW6a8b6T6Vz1rIlOmVY2eWeV4m7LMsfySoRnWY1UJ5Jk55XpuMJbqzwOGY7cZ92UYrjcfnHv7ohAAwUVIWuFIouQK40kvso6oEp7EieIUKnRGY28b9SBTZd2c6kkoCNOXCRMtW3p4xawgsy3hXEjLQHg6HYumAcwefw17WrjdhsbX3vIR2TuPdn+jnYIRuyl+1dpFVC4tJd1VH4k4SIbdwJt42UTkZPRsJveK9zO07Ljccezylkb7NVrcI+WNbVm19Ze4rYzb1u+fULIOqDIIuRqx6UiA9bpPE0r+js6p3oAGtJyzmzU9kgE8sjGSkNsPX2mXcXWeC0WwNGcDkz1UCZaExtPD+4JoioIu8W93wjn0s5fVFrt5I0U1gvarX8rBWW1WXMtKhSFpG03syJpH1oU2QPee63YF4vMCbkioMgiZL9TE2EYjTpRGtk60K0hKlNXsT7KObdPgeEAWtpDPHymW7900KcLAbRWDvc94Jc7XdRmAc5w1E3fq7Yp7mdYnEslelSLgNWc0Os7aKojOWvijkXlhFwVUGQRQlajKsYqo+86wis64JdtYYoidzm/60f2xeUqvRz1zNlO7VG1zso22rbr15osDwbdAvdim2UjZbdcTZQV69M7ipB9BUUWIYQQQsga6BVZPT0nVt8AIYQQQgjpsnrlJiGEEEIIWRmKLEIIIYSQNUCRRQghhBCyBiiyCCGEEELWAEUWIYQQQsgaoMgihBBCCFkDFFmEEEIIIWuAIosQQgghZA1QZBFCCCGErAGKLEIIIYSQNUCRRQghhBCyBiiyCCGEEELWAEUWIYQQQsgaoMgihBBCCFkDFFmEEEIIIWuAIosQQgghZA1QZBFCCCGErAGKLEIIIYSQNTC81AdA9gfH5HE6waR9IwKJM7ovALGva/OL9+VyxazqtKXbALS6ne5yte1rdZm+dQGItOssXabY/orLuuUv5Jiw5DxW2M6ex7jXvi9kv73z9AI/h2JdM726GYm/tDur2JZ767anleXzNss/Uzc9zVczv1gurVuu192v33Y+ZulsXzvbcfPMdbGn1bd9u4++7bvzrW1DgHhXKZdtX9t5+f7zyc/u3qaqN4KQNUGRRR4RJpjg2c0LIY0A0qTfaOIdWSBN097102+BSAi2NtJOs/Mlr5vnN37ZYr6KtPHbYn45Pb238yW8jsshiIEwL66TljXz29/teaTXlfnuPcK0pjLPrd/93c4TP60zH8vnozvdzl9l29Xpy7YbHrbV9cv57hg0LwOzbDk/fnRu+fZ1EhPxteRlRYx4kLy8hPd2fpPea/jT07TtBn6a/Z3nt+/dTxAbtent60Web6YN0vs8fxDeN6Jhvp0Xpy/QIPwO68b18u9FWgeAXwftvttl4vqLtL9BXD+c1yBuN81Tv+30Ph5/mBY+7oEAAwgaAAMRNJDwXsJ8QYOmnS7tKwAYXHfHMRCyRpguJIQQQghZAxRZhBBCCCFrgCKLEEIIIWQNUGQRQgghhKwBiixCCCGEkDVAkUUIIYQQsgYosgghhBBC1gBFFiGEEELIGqDIIoQQQghZAxRZhBBCCCFrQFS7fbcIudiIyOcB7Fzq4yCEEMOmqj7tUh8EuXph70LySLGjqs+81AdBCCEREfnEpT4GcnXDdCEhhBBCyBqgyCKEEEIIWQMUWeSR4s2X+gAIIaSA9yWyVlj4TgghhBCyBhjJIoQQQghZAxRZhBBCCCFrgCJrHyIiN4rIf4nInSJyc2W+iMhfhPmfFZHv32tdEXmUiHxIRO4Iv68J039ORD5tfhYi8vQw75Ui8rmwjw+KyLHiOF4mIioizzTTvl1EbheRL4nIF0XkSeaY/0BEvhzm/cbFvm6EkEvDCves54vIKXOfedNe64rIe8zyd4vIp8P0Z5npnxGRl5h1fiDcs+4M90gJ058oIh8O97KPiMj1a70g5MpBVfmzj34ADAB8BcB3ABgD+AyAG4plfhLArQAEwHMAfHyvdQH8CYCbw+ubAfxxZd/fA+Cu8HoI4D4Ax8z6v2OWPQzgowA+BuCZZvpHALwwvD4EYCu8/gUAbwfQhPePudTXmj/84c+3/rPiPev5AN7/zawblvszAG8Kr7cADMPr68J9Kr7/NwDPDffGWwH8RJj+9wBuCq9fAOAdl/q68efy+GEka//xLAB3qupdqjoB8G4ALyqWeRGAt2vLxwAcFZHr9lj3RQDeFl6/DcCLK/t+JYB3hdcSfg6Gb4PbAL5ulv19tMIrucSLyA1ob3YfAgBVPaOq58Ls1wP4PVVdhHn3rXpBCCGXNavcs77pdcP952cR7k2qek5VZ2H2JgANy10HYFtV/1VVFe2XuheH5W4A8OHw+l8u4PjIVQ5F1v7j8QC+Zt6fCNNWWWbZuo9V1f8FgPD7MZV9vxz5RjZFK4w+h1Zc3QDgbwFARJ4B4Amq+v5i/e8C8JCI/KOIfEpE/lREBmHedwJ4uYh8QkRuFZGnLLkGhJArh1XuWQDw3JDeu1VEnnoB6/4IgHtV9Y44QUSeLSJfQHt/el0QXY8P69e29RkAPx1evwTAYRG5dtUTJFcvFFn7D6lMK308+pZZZd36TkWeDeCcqn4+vB+hFVnPAPBtAD4L4I0i0gD4cwC/VdnMEO0N8Q0AfhBtCuA1Yd4GcuuevwbwllWOixBy2bPKfec/ADxRVb8PwF8CeN8FrGsj7O0Cqh9X1aeivc+8UUQ299jWGwA8T0Q+BeB5AO4BMKssT/YZFFn7jxMAnmDeXw+fplu2zLJ17w3h9BhWL9N1r4C/kT0dAFT1KyH0/l4AP4S2FutpAD4iInejrQm7JRS/nwDwqRD6n6G9kcai/BMA/iG8/icA39t3AQghVxR73rNU9WFVPRNefwDAKAykWbquiAwBvBTAe2o7VtUvATiL9p50Iqzf2Zaqfl1VX6qqzwDw22HaqQs+U3LVQZG1//h3AE8RkSeLyBit+LmlWOYWAK8OI/aeA+BUSAEuW/cWADeF1zcB+Oe4sRCd+hm09RCRewDcICKPDu9fCOBLqnpKVY+p6pNU9UloC99/SlU/EfZ/jVnnBQC+GF6/L7wH2m+SX77QC0MIuSzZ854lIo8zI/2ehfbZdv8K6/4YgP9U1RNmW08O4gsi8kQA3w3g7nAPPC0izwn7ejXCfU5EjoX7HAC8EYykk8DwUh8AeWRR1ZmI/DqA29COvHmLqn5BRF4X5v8VgA+gHWF4J4BzaEfu9a4bNv1HAN4rIq8F8FW0oiryowBOqOpd5ji+LiK/C+CjIjIF8D/Iqb++Y5+LyBsAfDjc5D6JNjUY9/9OEflNAGcA/NKFXx1CyOXGiveslwF4vYjMAJwH8IoQIV92zwK6EXYA+GEAN4f70gLAr6rqyTDv9QDeCuAA2tGFt4bpzwfwhyKiaEdF/9rFOn9yZcO2OoQQQggha4DpQkIIIYSQNUCRRQghhBCyBiiyCCGEEELWAEUWIYQQQsgaoMgihBBCCFkDFFmEEEIIIWuAIosQQgghZA38PyZb9EYEDje5AAAAAElFTkSuQmCC\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" - }, - { - "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" - } - ], - "source": [ - "for i in range(5):\n", - " nu = 0.5*(nu_arr[i] + nu_arr[i+1])\n", - " m = hp.read_map(f'{dirname_out}/colore_imap_s1_nu00{i}.fits')\n", - " hp.mollview(m, title='$\\\\Delta T\\\\,\\\\,(\\\\nu = %.1lf\\\\,\\\\,{\\\\rm MHz})$' % nu)" - ] - }, - { - "cell_type": "markdown", - "id": "00068d28", - "metadata": {}, - "source": [ - "## 3.5 Convergence and ISW maps\n", - "Again, stored as HEALPix maps" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "bd879861", - "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" - } - ], - "source": [ - "m_k = hp.read_map('output/colore_kappa_z000.fits')\n", - "m_i = hp.read_map('output/colore_isw_z000.fits')\n", - "hp.mollview(m_k, title=r'$\\kappa$')\n", - "hp.mollview(m_i, title=r'$\\Delta T_{\\rm ISW}/T$')" - ] - }, - { - "cell_type": "markdown", - "id": "68f03984", - "metadata": {}, - "source": [ - "## 3.6 Cartesian density grids\n", - "CoLoRe can also optionally output the matter overdensity boxes used to generate the simulation." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "e5174ac1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ngrid = 256\n", - "Lbox = 874.993 Mpc/h\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" - } - ], - "source": [ - "def read_grid(prefix):\n", - " f = open(prefix+\"_0.dat\", \"rb\")\n", - " nfiles, size_float = np.fromfile(f, dtype=np.int32, count=2)\n", - " lbox = np.fromfile(f, dtype=np.float64, count=1)[0]\n", - " ngrid = np.fromfile(f, dtype=np.int32, count=1)[0]\n", - " f.close()\n", - "\n", - " if size_float == 4:\n", - " f_type = np.float32\n", - " else:\n", - " f_type = np.float64\n", - "\n", - " grid_out = np.zeros([ngrid, ngrid, ngrid])\n", - " for ifil in np.arange(nfiles):\n", - " f = open(prefix+\"_%d.dat\" % ifil, \"rb\")\n", - " nf, sz = np.fromfile(f, dtype=np.int32, count=2)\n", - " _ = np.fromfile(f, dtype=np.float64, count=1)\n", - " ng, nz_here, iz0_here = np.fromfile(f, dtype=np.int32, count=3)\n", - " for iz in np.arange(nz_here):\n", - " d = np.fromfile(f, dtype=f_type, count=ng*ng).reshape([ng, ng])\n", - " grid_out[iz0_here+iz, :, :] = d\n", - " f.close()\n", - "\n", - " return ngrid, lbox, np.array(grid_out)\n", - "\n", - "ng, lb, dens = read_grid('output/colore_dens_lightcone')\n", - "_, _, densG = read_grid('output/colore_dens_gaussian')\n", - "print(\"Ngrid = %d\" % ng)\n", - "print(\"Lbox = %.3lf Mpc/h\" % lb)\n", - "\n", - "\n", - "plt.figure(figsize=(7, 7))\n", - "plt.title(r'$\\log_{10}(1+\\delta)$', fontsize=15)\n", - "plt.imshow(np.log10(1.001+dens[ng//2, :, :]),\n", - " origin='lower',\n", - " interpolation='nearest',\n", - " vmin=-1, extent=[0, lb, 0, lb])\n", - "plt.colorbar()\n", - "plt.xlabel(r'$x\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", - "plt.ylabel(r'$y\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", - "\n", - "plt.figure(figsize=(7, 7))\n", - "plt.title(r'$\\delta_G$', fontsize=15)\n", - "plt.imshow(densG[ng//2, :, :], origin='lower',\n", - " interpolation='nearest',\n", - " extent=[0, lb, 0, lb])\n", - "plt.colorbar()\n", - "plt.xlabel(r'$x\\,\\,[{\\rm Mpc}/h]$', fontsize=15)\n", - "plt.ylabel(r'$y\\,\\,[{\\rm Mpc}/h]$', fontsize=15);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6709bf8e-92dd-4af9-9964-e79413199de7", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Bacon (BNL Astro Conda) latest", - "language": "python", - "name": "bacon" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/param_example-checkpoint.cfg b/.ipynb_checkpoints/param_example-checkpoint.cfg deleted file mode 100644 index 9935fc5..0000000 --- a/.ipynb_checkpoints/param_example-checkpoint.cfg +++ /dev/null @@ -1,149 +0,0 @@ -global: -{ - #Output prefix. Output will be in prefix_. - prefix_out= "examples/simple/out"; - #Output format. Select HDF5, FITS or ASCII - output_format= "FITS"; - #Output Gaussian overdensity field at z=0? - output_density= true - #Path to power spectrum at z=0. Power spectrum file must - #be in CAMB format: k (h/Mpc), P(k) (Mpc/h)^3. - pk_filename= "examples/simple/Pk_CAMB_test.dat" - #This redshift range also defines the size of the box - z_min= 0.001 - z_max= 0.450 - #RNG seed note that output will depend on number of nodes, etc not only - #on the RNG seed - seed= 1003 - #Set to true if you want to generate the theory prediction for the 3D power spectrum - #of the different tracers. - write_pred=false - #Intervals of redshift at which the prediction will be produced. - pred_dz=0.1 - #If write_pred is true, set this to true if you just want to generate the prediction - #and then exit. This is also useful if you want to inspect the memory requirements - #before a run. - just_write_pred= true -} - -field_par: -{ - #Extra Gaussian smoothing scale [Mpc/h] (set to a - #negative value if you don't want any smoothing) - r_smooth= 5. - #Do you want to smooth the Newtonian potential as well? - smooth_potential= true - #Will use a Cartesian grid with n_grid^3 cells - n_grid= 256 - #Density field type - # 0-lognormal - # 1-1LPT - # 2-2LPT - dens_type= 1 - #If dens_type==1 or 2, buffer size (fraction per particle) - lpt_buffer_fraction= 0.6 - #If dens_type==1 or 2, scheme to interpolate particle - #positions into a grid - # 0-NGP - # 1-CIC - # 2-TSC - lpt_interp_type= 1 - #Set to 1 if you want to output the LPT particle positions - output_lpt= 0 -} - -cosmo_par: -{ - #Non-relativistic matter - omega_M= 0.3 - #Dark energy - omega_L= 0.7 - #Baryons - omega_B= 0.05 - #Hubble parameter (in units of 100 km/s/Mpc) - h= 0.7 - #Dark energy equation of state - w= -1.0 - #Primordial scalar spectral index, used only to extrapolate - #P(k) at low k end (-3 used at high k end) - ns= 0.96 - #Power spectrum normalization. The input power spectrum will be - #renormalized to this sigma8 - sigma_8= 0.803869 -} - -#For each galaxy population, create a section called srcsX, starting with X=1 -srcs1: -{ - #Path to N(z) file. Should contain two columns - # 1-> z, 2-> dN(z)/dz*dOmega - # with dN/dzdOmega in units of deg^-2 - nz_filename= "examples/simple/Nz_test.txt" - #Path to bias file. Should contain two columns - # 1-> z, 2-> b(z) - bias_filename= "examples/simple/Bz_test.txt" - #Do you want to include shear ellipticities? - include_lensing= true - #Do you want to store line-of-sight skewers for each object? - store_skewers= true - #You can also store the Gaussian density field (instead of the non-Gaussian one) - #This is false by default. - gaussian_skewers= false -} - -srcs2: -{ - nz_filename= "examples/simple/Nz2_test.txt" - bias_filename= "examples/simple/Bz2_test.txt" - include_lensing= false - store_skewers= true -} - -#For each intensity mapping species, create a section called imapX, -#starting with X=1 -imap1: -{ - #Tabulated background temperature as a function of redshift - tbak_filename= "examples/simple/Tz_test.txt" - #Tabulated linear bias as a function of redshift - bias_filename= "examples/simple/Bz_test.txt" - #Frequency bands in which to output maps. Should contain 2 columns: - # 1-> nu_ini, 2-> nu_end - freq_list= "examples/simple/nuTable.txt" - #Rest-frame frequency of this species (in the same units as the - #frequencies in freq_list). - freq_rest= 1420.405 - #HEALPix resolution parameter. - nside= 64 -} - -#Include a section entitled kappa if you want to generate maps -#of the lensing convergence at specific redshifts. -kappa: -{ - #Redshifts at which maps should be generated - z_out= [0.4] - nside= 64 -} - -#Include a section entitled isw if you want to generate maps -#of the ISW effect (time derivative of the gravitational potential). -isw: -{ - z_out= [0.4] - nside= 64 -} - -#This section is needed if using the fast lensing method -lensing: -{ - # Maximum Nside used for the lensing shells. - nside= 256 - # Select number of slices. - n_lensing= 11 - # Select spacing type ("r" or "log(1+z)"). - spacing_type= "r" - # Set to true if you want to output the different - # lensing shells. - write=false -} From 9bef94baeab7a4206e5b52a7c59c47b7138d6a8c Mon Sep 17 00:00:00 2001 From: Walter3ffb <89849649+Walter3ffb@users.noreply.github.com> Date: Mon, 11 Jul 2022 14:12:06 -0400 Subject: [PATCH 3/6] Delete examples/simple directory --- examples/simple/out_node0.dbg | 0 examples/simple/out_params.cfg | 64 ---------------------------------- 2 files changed, 64 deletions(-) delete mode 100644 examples/simple/out_node0.dbg delete mode 100644 examples/simple/out_params.cfg diff --git a/examples/simple/out_node0.dbg b/examples/simple/out_node0.dbg deleted file mode 100644 index e69de29..0000000 diff --git a/examples/simple/out_params.cfg b/examples/simple/out_params.cfg deleted file mode 100644 index 0e0d42f..0000000 --- a/examples/simple/out_params.cfg +++ /dev/null @@ -1,64 +0,0 @@ -global = { - prefix_out = "examples/simple/out" - output_format = "FITS" - output_density = true - pk_filename = "examples/simple/Pk_CAMB_test.dat" - z_min = 0.001 - z_max = 0.45 - seed = 1003 - write_pred = false - pred_dz = 0.1 - just_write_pred = true -} -field_par = { - r_smooth = 5.0 - smooth_potential = true - n_grid = 256 - dens_type = 1 - lpt_buffer_fraction = 0.6 - lpt_interp_type = 1 - output_lpt = 0 -} -cosmo_par = { - omega_M = 0.3 - omega_L = 0.7 - omega_B = 0.05 - h = 0.7 - w = -1.0 - ns = 0.96 - sigma_8 = 0.803869 -} -srcs1 = { - nz_filename = "examples/simple/Nz_test.txt" - bias_filename = "examples/simple/Bz_test.txt" - include_lensing = true - store_skewers = true - gaussian_skewers = false -} -srcs2 = { - nz_filename = "examples/simple/Nz2_test.txt" - bias_filename = "examples/simple/Bz2_test.txt" - include_lensing = false - store_skewers = true -} -imap1 = { - tbak_filename = "examples/simple/Tz_test.txt" - bias_filename = "examples/simple/Bz_test.txt" - freq_list = "examples/simple/nuTable.txt" - freq_rest = 1420.405 - nside = 64 -} -kappa = { - z_out = [ 0.4 ] - nside = 64 -} -isw = { - z_out = [ 0.4 ] - nside = 64 -} -lensing = { - nside = 256 - n_lensing = 11 - spacing_type = "r" - write = false -} From 03d147577f00ba0deb1020b055031ebf47ca6162 Mon Sep 17 00:00:00 2001 From: Walter3ffb <89849649+Walter3ffb@users.noreply.github.com> Date: Mon, 11 Jul 2022 14:12:36 -0400 Subject: [PATCH 4/6] Delete output/.ipynb_checkpoints directory --- .../.ipynb_checkpoints/params-checkpoint.cfg | 69 ------------------- 1 file changed, 69 deletions(-) delete mode 100644 output/.ipynb_checkpoints/params-checkpoint.cfg diff --git a/output/.ipynb_checkpoints/params-checkpoint.cfg b/output/.ipynb_checkpoints/params-checkpoint.cfg deleted file mode 100644 index 2810578..0000000 --- a/output/.ipynb_checkpoints/params-checkpoint.cfg +++ /dev/null @@ -1,69 +0,0 @@ -global = -{ - prefix_out = "output/colore"; - output_format = "FITS"; - output_density = True; - pk_filename = "output/pk.txt"; - z_min = 0.0001; - z_max = 0.15; - seed = 1000; - write_pred = False; - just_write_pred = False; -}; -field_par = -{ - r_smooth = 1.0; - smooth_potential = True; - n_grid = 256; - dens_type = 1; - lpt_buffer_fraction = 0.6; - lpt_interp_type = 1; - output_lpt = 0; -}; -cosmo_par = -{ - omega_M = 0.3; - omega_B = 0.3; - omega_L = 0.7; - h = 0.7; - w = -1.0; - ns = 0.96; - sigma_8 = 0.8; -}; -custom1 = -{ - kz_filename = "output/wz.txt"; - bias_filename = "output/bias.txt"; - nside = 64; -}; -srcs1 = -{ - nz_filename = "output/dndz.txt"; - bias_filename = "output/bias.txt"; - include_lensing = True; - store_skewers = True; -}; -imap1 = -{ - tbak_filename = "output/tz.txt"; - bias_filename = "output/bias.txt"; - freq_list = "output/nuTable.txt"; - freq_rest = 1420.0; - nside = 64; -}; -kappa = -{ - z_out = - [ - 0.1 - ]; - nside = 64; -}; -isw = -{ - z_out = - [ - 0.1 - ]; - nside = 64; -}; From 0a04af0fb36397bcc529b362c810f2666dc5a59f Mon Sep 17 00:00:00 2001 From: Walter3ffb <89849649+Walter3ffb@users.noreply.github.com> Date: Mon, 11 Jul 2022 14:13:30 -0400 Subject: [PATCH 5/6] Delete output directory --- output/bias.txt | 1024 -------------------------------------- output/colore_node0.dbg | 1 - output/colore_params.cfg | 55 -- output/dndz.txt | 1024 -------------------------------------- output/log.txt | 113 ----- output/nuTable.txt | 5 - output/params.cfg | 69 --- output/pk.txt | 1024 -------------------------------------- output/tz.txt | 1024 -------------------------------------- output/wz.txt | 1024 -------------------------------------- 10 files changed, 5363 deletions(-) delete mode 100644 output/bias.txt delete mode 100644 output/colore_node0.dbg delete mode 100644 output/colore_params.cfg delete mode 100644 output/dndz.txt delete mode 100644 output/log.txt delete mode 100644 output/nuTable.txt delete mode 100644 output/params.cfg delete mode 100644 output/pk.txt delete mode 100644 output/tz.txt delete mode 100644 output/wz.txt diff --git a/output/bias.txt b/output/bias.txt deleted file mode 100644 index 918a31f..0000000 --- a/output/bias.txt +++ /dev/null @@ -1,1024 +0,0 @@ -0.000000000000000000e+00 1.000000000000000000e+00 -1.955034213098729226e-04 1.000195503421309917e+00 -3.910068426197458452e-04 1.000391006842619834e+00 -5.865102639296187678e-04 1.000586510263929529e+00 -7.820136852394916904e-04 1.000782013685239447e+00 -9.775171065493646130e-04 1.000977517106549364e+00 -1.173020527859237536e-03 1.001173020527859281e+00 -1.368523949169110458e-03 1.001368523949169198e+00 -1.564027370478983381e-03 1.001564027370478893e+00 -1.759530791788856303e-03 1.001759530791788810e+00 -1.955034213098729226e-03 1.001955034213098727e+00 -2.150537634408602149e-03 1.002150537634408645e+00 -2.346041055718475071e-03 1.002346041055718562e+00 -2.541544477028347994e-03 1.002541544477028257e+00 -2.737047898338220916e-03 1.002737047898338174e+00 -2.932551319648093839e-03 1.002932551319648091e+00 -3.128054740957966762e-03 1.003128054740958008e+00 -3.323558162267839684e-03 1.003323558162267926e+00 -3.519061583577712607e-03 1.003519061583577621e+00 -3.714565004887585530e-03 1.003714565004887538e+00 -3.910068426197458452e-03 1.003910068426197455e+00 -4.105571847507331375e-03 1.004105571847507372e+00 -4.301075268817204297e-03 1.004301075268817289e+00 -4.496578690127077220e-03 1.004496578690126984e+00 -4.692082111436950143e-03 1.004692082111436902e+00 -4.887585532746823065e-03 1.004887585532746819e+00 -5.083088954056695988e-03 1.005083088954056736e+00 -5.278592375366568910e-03 1.005278592375366653e+00 -5.474095796676441833e-03 1.005474095796676348e+00 -5.669599217986314756e-03 1.005669599217986265e+00 -5.865102639296187678e-03 1.005865102639296182e+00 -6.060606060606060601e-03 1.006060606060606100e+00 -6.256109481915933523e-03 1.006256109481916017e+00 -6.451612903225806446e-03 1.006451612903225712e+00 -6.647116324535679369e-03 1.006647116324535629e+00 -6.842619745845552291e-03 1.006842619745845546e+00 -7.038123167155425214e-03 1.007038123167155463e+00 -7.233626588465298136e-03 1.007233626588465381e+00 -7.429130009775171059e-03 1.007429130009775076e+00 -7.624633431085043982e-03 1.007624633431084993e+00 -7.820136852394916904e-03 1.007820136852394910e+00 -8.015640273704788960e-03 1.008015640273704827e+00 -8.211143695014662749e-03 1.008211143695014744e+00 -8.406647116324536539e-03 1.008406647116324439e+00 -8.602150537634408595e-03 1.008602150537634357e+00 -8.797653958944280650e-03 1.008797653958944274e+00 -8.993157380254154440e-03 1.008993157380254191e+00 -9.188660801564028230e-03 1.009188660801564108e+00 -9.384164222873900285e-03 1.009384164222873803e+00 -9.579667644183772340e-03 1.009579667644183720e+00 -9.775171065493646130e-03 1.009775171065493637e+00 -9.970674486803519920e-03 1.009970674486803555e+00 -1.016617790811339198e-02 1.010166177908113472e+00 -1.036168132942326403e-02 1.010361681329423167e+00 -1.055718475073313782e-02 1.010557184750733084e+00 -1.075268817204301161e-02 1.010752688172043001e+00 -1.094819159335288367e-02 1.010948191593352918e+00 -1.114369501466275572e-02 1.011143695014662836e+00 -1.133919843597262951e-02 1.011339198435972531e+00 -1.153470185728250330e-02 1.011534701857282448e+00 -1.173020527859237536e-02 1.011730205278592365e+00 -1.192570869990224741e-02 1.011925708699902282e+00 -1.212121212121212120e-02 1.012121212121212199e+00 -1.231671554252199499e-02 1.012316715542521894e+00 -1.251221896383186705e-02 1.012512218963831812e+00 -1.270772238514173910e-02 1.012707722385141729e+00 -1.290322580645161289e-02 1.012903225806451646e+00 -1.309872922776148668e-02 1.013098729227761563e+00 -1.329423264907135874e-02 1.013294232649071258e+00 -1.348973607038123079e-02 1.013489736070381175e+00 -1.368523949169110458e-02 1.013685239491691092e+00 -1.388074291300097837e-02 1.013880742913001010e+00 -1.407624633431085043e-02 1.014076246334310927e+00 -1.427174975562072248e-02 1.014271749755620622e+00 -1.446725317693059627e-02 1.014467253176930539e+00 -1.466275659824047006e-02 1.014662756598240456e+00 -1.485826001955034212e-02 1.014858260019550373e+00 -1.505376344086021417e-02 1.015053763440860291e+00 -1.524926686217008796e-02 1.015249266862169986e+00 -1.544477028347996175e-02 1.015444770283479903e+00 -1.564027370478983381e-02 1.015640273704789820e+00 -1.583577712609970586e-02 1.015835777126099737e+00 -1.603128054740957792e-02 1.016031280547409654e+00 -1.622678396871945344e-02 1.016226783968719349e+00 -1.642228739002932550e-02 1.016422287390029267e+00 -1.661779081133919755e-02 1.016617790811339184e+00 -1.681329423264907308e-02 1.016813294232649101e+00 -1.700879765395894513e-02 1.017008797653959018e+00 -1.720430107526881719e-02 1.017204301075268713e+00 -1.739980449657868924e-02 1.017399804496578630e+00 -1.759530791788856130e-02 1.017595307917888547e+00 -1.779081133919843682e-02 1.017790811339198465e+00 -1.798631476050830888e-02 1.017986314760508382e+00 -1.818181818181818094e-02 1.018181818181818077e+00 -1.837732160312805646e-02 1.018377321603127994e+00 -1.857282502443792851e-02 1.018572825024437911e+00 -1.876832844574780057e-02 1.018768328445747828e+00 -1.896383186705767263e-02 1.018963831867057745e+00 -1.915933528836754468e-02 1.019159335288367441e+00 -1.935483870967742021e-02 1.019354838709677358e+00 -1.955034213098729226e-02 1.019550342130987275e+00 -1.974584555229716432e-02 1.019745845552297192e+00 -1.994134897360703984e-02 1.019941348973607109e+00 -2.013685239491691190e-02 1.020136852394916804e+00 -2.033235581622678395e-02 1.020332355816226722e+00 -2.052785923753665601e-02 1.020527859237536639e+00 -2.072336265884652806e-02 1.020723362658846556e+00 -2.091886608015640359e-02 1.020918866080156473e+00 -2.111436950146627564e-02 1.021114369501466168e+00 -2.130987292277614770e-02 1.021309872922776085e+00 -2.150537634408602322e-02 1.021505376344086002e+00 -2.170087976539589528e-02 1.021700879765395920e+00 -2.189638318670576733e-02 1.021896383186705837e+00 -2.209188660801563939e-02 1.022091886608015532e+00 -2.228739002932551144e-02 1.022287390029325449e+00 -2.248289345063538697e-02 1.022482893450635366e+00 -2.267839687194525902e-02 1.022678396871945283e+00 -2.287390029325513108e-02 1.022873900293255200e+00 -2.306940371456500660e-02 1.023069403714564896e+00 -2.326490713587487866e-02 1.023264907135874813e+00 -2.346041055718475071e-02 1.023460410557184730e+00 -2.365591397849462277e-02 1.023655913978494647e+00 -2.385141739980449482e-02 1.023851417399804564e+00 -2.404692082111437035e-02 1.024046920821114259e+00 -2.424242424242424240e-02 1.024242424242424176e+00 -2.443792766373411446e-02 1.024437927663734094e+00 -2.463343108504398998e-02 1.024633431085044011e+00 -2.482893450635386204e-02 1.024828934506353928e+00 -2.502443792766373409e-02 1.025024437927663623e+00 -2.521994134897360615e-02 1.025219941348973540e+00 -2.541544477028347820e-02 1.025415444770283457e+00 -2.561094819159335373e-02 1.025610948191593375e+00 -2.580645161290322578e-02 1.025806451612903292e+00 -2.600195503421309784e-02 1.026001955034212987e+00 -2.619745845552297336e-02 1.026197458455522904e+00 -2.639296187683284542e-02 1.026392961876832821e+00 -2.658846529814271747e-02 1.026588465298142738e+00 -2.678396871945258953e-02 1.026783968719452655e+00 -2.697947214076246158e-02 1.026979472140762351e+00 -2.717497556207233711e-02 1.027174975562072268e+00 -2.737047898338220916e-02 1.027370478983382185e+00 -2.756598240469208122e-02 1.027565982404692102e+00 -2.776148582600195674e-02 1.027761485826002019e+00 -2.795698924731182880e-02 1.027956989247311936e+00 -2.815249266862170086e-02 1.028152492668621631e+00 -2.834799608993157291e-02 1.028347996089931549e+00 -2.854349951124144497e-02 1.028543499511241466e+00 -2.873900293255132049e-02 1.028739002932551383e+00 -2.893450635386119255e-02 1.028934506353861300e+00 -2.913000977517106460e-02 1.029130009775170995e+00 -2.932551319648094013e-02 1.029325513196480912e+00 -2.952101661779081218e-02 1.029521016617790830e+00 -2.971652003910068424e-02 1.029716520039100747e+00 -2.991202346041055629e-02 1.029912023460410664e+00 -3.010752688172042835e-02 1.030107526881720359e+00 -3.030303030303030387e-02 1.030303030303030276e+00 -3.049853372434017593e-02 1.030498533724340193e+00 -3.069403714565004798e-02 1.030694037145650110e+00 -3.088954056695992351e-02 1.030889540566960028e+00 -3.108504398826979556e-02 1.031085043988269723e+00 -3.128054740957966762e-02 1.031280547409579640e+00 -3.147605083088954314e-02 1.031476050830889557e+00 -3.167155425219941173e-02 1.031671554252199474e+00 -3.186705767350928725e-02 1.031867057673509391e+00 -3.206256109481915584e-02 1.032062561094819086e+00 -3.225806451612903136e-02 1.032258064516129004e+00 -3.245356793743890689e-02 1.032453567937438921e+00 -3.264907135874877547e-02 1.032649071358748838e+00 -3.284457478005865100e-02 1.032844574780058755e+00 -3.304007820136852652e-02 1.033040078201368450e+00 -3.323558162267839511e-02 1.033235581622678367e+00 -3.343108504398827063e-02 1.033431085043988285e+00 -3.362658846529814616e-02 1.033626588465298202e+00 -3.382209188660801474e-02 1.033822091886608119e+00 -3.401759530791789027e-02 1.034017595307917814e+00 -3.421309872922775885e-02 1.034213098729227731e+00 -3.440860215053763438e-02 1.034408602150537648e+00 -3.460410557184750990e-02 1.034604105571847565e+00 -3.479960899315737849e-02 1.034799608993157483e+00 -3.499511241446725401e-02 1.034995112414467178e+00 -3.519061583577712260e-02 1.035190615835777095e+00 -3.538611925708699812e-02 1.035386119257087012e+00 -3.558162267839687365e-02 1.035581622678396929e+00 -3.577712609970674223e-02 1.035777126099706846e+00 -3.597262952101661776e-02 1.035972629521016541e+00 -3.616813294232649328e-02 1.036168132942326459e+00 -3.636363636363636187e-02 1.036363636363636376e+00 -3.655913978494623739e-02 1.036559139784946293e+00 -3.675464320625611292e-02 1.036754643206256210e+00 -3.695014662756598151e-02 1.036950146627565905e+00 -3.714565004887585703e-02 1.037145650048875822e+00 -3.734115347018572562e-02 1.037341153470185739e+00 -3.753665689149560114e-02 1.037536656891495657e+00 -3.773216031280547667e-02 1.037732160312805574e+00 -3.792766373411534525e-02 1.037927663734115269e+00 -3.812316715542522078e-02 1.038123167155425186e+00 -3.831867057673508936e-02 1.038318670576735103e+00 -3.851417399804496489e-02 1.038514173998045020e+00 -3.870967741935484041e-02 1.038709677419354938e+00 -3.890518084066470900e-02 1.038905180840664633e+00 -3.910068426197458452e-02 1.039100684261974550e+00 -3.929618768328446005e-02 1.039296187683284467e+00 -3.949169110459432863e-02 1.039491691104594384e+00 -3.968719452590420416e-02 1.039687194525904301e+00 -3.988269794721407968e-02 1.039882697947213996e+00 -4.007820136852394827e-02 1.040078201368523914e+00 -4.027370478983382379e-02 1.040273704789833831e+00 -4.046920821114369238e-02 1.040469208211143748e+00 -4.066471163245356790e-02 1.040664711632453665e+00 -4.086021505376344343e-02 1.040860215053763360e+00 -4.105571847507331201e-02 1.041055718475073277e+00 -4.125122189638318754e-02 1.041251221896383194e+00 -4.144672531769305612e-02 1.041446725317693112e+00 -4.164222873900293165e-02 1.041642228739003029e+00 -4.183773216031280717e-02 1.041837732160312724e+00 -4.203323558162267576e-02 1.042033235581622641e+00 -4.222873900293255128e-02 1.042228739002932558e+00 -4.242424242424242681e-02 1.042424242424242475e+00 -4.261974584555229539e-02 1.042619745845552393e+00 -4.281524926686217092e-02 1.042815249266862088e+00 -4.301075268817204644e-02 1.043010752688172005e+00 -4.320625610948191503e-02 1.043206256109481922e+00 -4.340175953079179055e-02 1.043401759530791839e+00 -4.359726295210165914e-02 1.043597262952101756e+00 -4.379276637341153466e-02 1.043792766373411451e+00 -4.398826979472141019e-02 1.043988269794721369e+00 -4.418377321603127877e-02 1.044183773216031286e+00 -4.437927663734115430e-02 1.044379276637341203e+00 -4.457478005865102288e-02 1.044574780058651120e+00 -4.477028347996089841e-02 1.044770283479960815e+00 -4.496578690127077393e-02 1.044965786901270732e+00 -4.516129032258064252e-02 1.045161290322580649e+00 -4.535679374389051804e-02 1.045356793743890567e+00 -4.555229716520039357e-02 1.045552297165200484e+00 -4.574780058651026216e-02 1.045747800586510179e+00 -4.594330400782013768e-02 1.045943304007820096e+00 -4.613880742913001320e-02 1.046138807429130013e+00 -4.633431085043988179e-02 1.046334310850439930e+00 -4.652981427174975732e-02 1.046529814271749848e+00 -4.672531769305962590e-02 1.046725317693059543e+00 -4.692082111436950143e-02 1.046920821114369460e+00 -4.711632453567937695e-02 1.047116324535679377e+00 -4.731182795698924554e-02 1.047311827956989294e+00 -4.750733137829912106e-02 1.047507331378299211e+00 -4.770283479960898965e-02 1.047702834799608906e+00 -4.789833822091886517e-02 1.047898338220918824e+00 -4.809384164222874070e-02 1.048093841642228741e+00 -4.828934506353860928e-02 1.048289345063538658e+00 -4.848484848484848481e-02 1.048484848484848575e+00 -4.868035190615836033e-02 1.048680351906158270e+00 -4.887585532746822892e-02 1.048875855327468187e+00 -4.907135874877810444e-02 1.049071358748778104e+00 -4.926686217008797997e-02 1.049266862170088022e+00 -4.946236559139784855e-02 1.049462365591397939e+00 -4.965786901270772408e-02 1.049657869012707634e+00 -4.985337243401759266e-02 1.049853372434017551e+00 -5.004887585532746819e-02 1.050048875855327468e+00 -5.024437927663734371e-02 1.050244379276637385e+00 -5.043988269794721230e-02 1.050439882697947303e+00 -5.063538611925708782e-02 1.050635386119256998e+00 -5.083088954056695641e-02 1.050830889540566915e+00 -5.102639296187683193e-02 1.051026392961876832e+00 -5.122189638318670746e-02 1.051221896383186749e+00 -5.141739980449657604e-02 1.051417399804496666e+00 -5.161290322580645157e-02 1.051612903225806361e+00 -5.180840664711632709e-02 1.051808406647116279e+00 -5.200391006842619568e-02 1.052003910068426196e+00 -5.219941348973607120e-02 1.052199413489736113e+00 -5.239491691104594673e-02 1.052394916911046030e+00 -5.259042033235581531e-02 1.052590420332355725e+00 -5.278592375366569084e-02 1.052785923753665642e+00 -5.298142717497555942e-02 1.052981427174975559e+00 -5.317693059628543495e-02 1.053176930596285477e+00 -5.337243401759531047e-02 1.053372434017595394e+00 -5.356793743890517906e-02 1.053567937438905089e+00 -5.376344086021505458e-02 1.053763440860215006e+00 -5.395894428152492317e-02 1.053958944281524923e+00 -5.415444770283479869e-02 1.054154447702834840e+00 -5.434995112414467422e-02 1.054349951124144757e+00 -5.454545454545454281e-02 1.054545454545454453e+00 -5.474095796676441833e-02 1.054740957966764370e+00 -5.493646138807429385e-02 1.054936461388074287e+00 -5.513196480938416244e-02 1.055131964809384204e+00 -5.532746823069403797e-02 1.055327468230694121e+00 -5.552297165200391349e-02 1.055522971652003816e+00 -5.571847507331378208e-02 1.055718475073313734e+00 -5.591397849462365760e-02 1.055913978494623651e+00 -5.610948191593352619e-02 1.056109481915933568e+00 -5.630498533724340171e-02 1.056304985337243485e+00 -5.650048875855327724e-02 1.056500488758553180e+00 -5.669599217986314582e-02 1.056695992179863097e+00 -5.689149560117302135e-02 1.056891495601173014e+00 -5.708699902248288993e-02 1.057086999022482932e+00 -5.728250244379276546e-02 1.057282502443792849e+00 -5.747800586510264098e-02 1.057478005865102544e+00 -5.767350928641250957e-02 1.057673509286412461e+00 -5.786901270772238509e-02 1.057869012707722378e+00 -5.806451612903226062e-02 1.058064516129032295e+00 -5.826001955034212920e-02 1.058260019550342212e+00 -5.845552297165200473e-02 1.058455522971651908e+00 -5.865102639296188025e-02 1.058651026392961825e+00 -5.884652981427174884e-02 1.058846529814271742e+00 -5.904203323558162436e-02 1.059042033235581659e+00 -5.923753665689149295e-02 1.059237536656891576e+00 -5.943304007820136847e-02 1.059433040078201271e+00 -5.962854349951124400e-02 1.059628543499511188e+00 -5.982404692082111258e-02 1.059824046920821106e+00 -6.001955034213098811e-02 1.060019550342131023e+00 -6.021505376344085669e-02 1.060215053763440940e+00 -6.041055718475073222e-02 1.060410557184750635e+00 -6.060606060606060774e-02 1.060606060606060552e+00 -6.080156402737047633e-02 1.060801564027370469e+00 -6.099706744868035185e-02 1.060997067448680387e+00 -6.119257086999022738e-02 1.061192570869990304e+00 -6.138807429130009596e-02 1.061388074291299999e+00 -6.158357771260997149e-02 1.061583577712609916e+00 -6.177908113391984701e-02 1.061779081133919833e+00 -6.197458455522971560e-02 1.061974584555229750e+00 -6.217008797653959112e-02 1.062170087976539667e+00 -6.236559139784945971e-02 1.062365591397849363e+00 -6.256109481915933523e-02 1.062561094819159280e+00 -6.275659824046921076e-02 1.062756598240469197e+00 -6.295210166177908628e-02 1.062952101661779114e+00 -6.314760508308894793e-02 1.063147605083089031e+00 -6.334310850439882346e-02 1.063343108504398726e+00 -6.353861192570869898e-02 1.063538611925708643e+00 -6.373411534701857450e-02 1.063734115347018561e+00 -6.392961876832845003e-02 1.063929618768328478e+00 -6.412512218963831168e-02 1.064125122189638395e+00 -6.432062561094818720e-02 1.064320625610948090e+00 -6.451612903225806273e-02 1.064516129032258007e+00 -6.471163245356793825e-02 1.064711632453567924e+00 -6.490713587487781377e-02 1.064907135874877842e+00 -6.510263929618768930e-02 1.065102639296187759e+00 -6.529814271749755095e-02 1.065298142717497454e+00 -6.549364613880742647e-02 1.065493646138807371e+00 -6.568914956011730200e-02 1.065689149560117288e+00 -6.588465298142717752e-02 1.065884652981427205e+00 -6.608015640273705305e-02 1.066080156402737122e+00 -6.627565982404691469e-02 1.066275659824046818e+00 -6.647116324535679022e-02 1.066471163245356735e+00 -6.666666666666666574e-02 1.066666666666666652e+00 -6.686217008797654127e-02 1.066862170087976569e+00 -6.705767350928641679e-02 1.067057673509286486e+00 -6.725317693059629232e-02 1.067253176930596403e+00 -6.744868035190615396e-02 1.067448680351906098e+00 -6.764418377321602949e-02 1.067644183773216016e+00 -6.783968719452590501e-02 1.067839687194525933e+00 -6.803519061583578054e-02 1.068035190615835850e+00 -6.823069403714565606e-02 1.068230694037145767e+00 -6.842619745845551771e-02 1.068426197458455462e+00 -6.862170087976539323e-02 1.068621700879765379e+00 -6.881720430107526876e-02 1.068817204301075297e+00 -6.901270772238514428e-02 1.069012707722385214e+00 -6.920821114369501981e-02 1.069208211143695131e+00 -6.940371456500488145e-02 1.069403714565004826e+00 -6.959921798631475698e-02 1.069599217986314743e+00 -6.979472140762463250e-02 1.069794721407624660e+00 -6.999022482893450803e-02 1.069990224828934577e+00 -7.018572825024438355e-02 1.070185728250244495e+00 -7.038123167155424520e-02 1.070381231671554190e+00 -7.057673509286412072e-02 1.070576735092864107e+00 -7.077223851417399625e-02 1.070772238514174024e+00 -7.096774193548387177e-02 1.070967741935483941e+00 -7.116324535679374730e-02 1.071163245356793858e+00 -7.135874877810362282e-02 1.071358748778103553e+00 -7.155425219941348447e-02 1.071554252199413471e+00 -7.174975562072335999e-02 1.071749755620723388e+00 -7.194525904203323552e-02 1.071945259042033305e+00 -7.214076246334311104e-02 1.072140762463343222e+00 -7.233626588465298657e-02 1.072336265884652917e+00 -7.253176930596284822e-02 1.072531769305962834e+00 -7.272727272727272374e-02 1.072727272727272751e+00 -7.292277614858259926e-02 1.072922776148582669e+00 -7.311827956989247479e-02 1.073118279569892586e+00 -7.331378299120235031e-02 1.073313782991202281e+00 -7.350928641251222584e-02 1.073509286412512198e+00 -7.370478983382208749e-02 1.073704789833822115e+00 -7.390029325513196301e-02 1.073900293255132032e+00 -7.409579667644183854e-02 1.074095796676441950e+00 -7.429130009775171406e-02 1.074291300097751645e+00 -7.448680351906158958e-02 1.074486803519061562e+00 -7.468230694037145123e-02 1.074682306940371479e+00 -7.487781036168132676e-02 1.074877810361681396e+00 -7.507331378299120228e-02 1.075073313782991313e+00 -7.526881720430107781e-02 1.075268817204301008e+00 -7.546432062561095333e-02 1.075464320625610926e+00 -7.565982404692081498e-02 1.075659824046920843e+00 -7.585532746823069050e-02 1.075855327468230760e+00 -7.605083088954056603e-02 1.076050830889540677e+00 -7.624633431085044155e-02 1.076246334310850372e+00 -7.644183773216031708e-02 1.076441837732160289e+00 -7.663734115347017872e-02 1.076637341153470206e+00 -7.683284457478005425e-02 1.076832844574780124e+00 -7.702834799608992977e-02 1.077028347996090041e+00 -7.722385141739980530e-02 1.077223851417399736e+00 -7.741935483870968082e-02 1.077419354838709653e+00 -7.761485826001955635e-02 1.077614858260019570e+00 -7.781036168132941799e-02 1.077810361681329487e+00 -7.800586510263929352e-02 1.078005865102639405e+00 -7.820136852394916904e-02 1.078201368523949100e+00 -7.839687194525904457e-02 1.078396871945259017e+00 -7.859237536656892009e-02 1.078592375366568934e+00 -7.878787878787878174e-02 1.078787878787878851e+00 -7.898338220918865726e-02 1.078983382209188768e+00 -7.917888563049853279e-02 1.079178885630498463e+00 -7.937438905180840831e-02 1.079374389051808381e+00 -7.956989247311828384e-02 1.079569892473118298e+00 -7.976539589442815936e-02 1.079765395894428215e+00 -7.996089931573802101e-02 1.079960899315738132e+00 -8.015640273704789653e-02 1.080156402737047827e+00 -8.035190615835777206e-02 1.080351906158357744e+00 -8.054740957966764758e-02 1.080547409579667661e+00 -8.074291300097752311e-02 1.080742913000977579e+00 -8.093841642228738475e-02 1.080938416422287496e+00 -8.113391984359726028e-02 1.081133919843597191e+00 -8.132942326490713580e-02 1.081329423264907108e+00 -8.152492668621701133e-02 1.081524926686217025e+00 -8.172043010752688685e-02 1.081720430107526942e+00 -8.191593352883674850e-02 1.081915933528836860e+00 -8.211143695014662403e-02 1.082111436950146555e+00 -8.230694037145649955e-02 1.082306940371456472e+00 -8.250244379276637507e-02 1.082502443792766389e+00 -8.269794721407625060e-02 1.082697947214076306e+00 -8.289345063538611225e-02 1.082893450635386223e+00 -8.308895405669598777e-02 1.083088954056695918e+00 -8.328445747800586330e-02 1.083284457478005836e+00 -8.347996089931573882e-02 1.083479960899315753e+00 -8.367546432062561435e-02 1.083675464320625670e+00 -8.387096774193548987e-02 1.083870967741935587e+00 -8.406647116324535152e-02 1.084066471163245282e+00 -8.426197458455522704e-02 1.084261974584555199e+00 -8.445747800586510257e-02 1.084457478005865116e+00 -8.465298142717497809e-02 1.084652981427175034e+00 -8.484848484848485362e-02 1.084848484848484951e+00 -8.504398826979471526e-02 1.085043988269794646e+00 -8.523949169110459079e-02 1.085239491691104563e+00 -8.543499511241446631e-02 1.085434995112414480e+00 -8.563049853372434184e-02 1.085630498533724397e+00 -8.582600195503421736e-02 1.085826001955034315e+00 -8.602150537634409289e-02 1.086021505376344010e+00 -8.621700879765395453e-02 1.086217008797653927e+00 -8.641251221896383006e-02 1.086412512218963844e+00 -8.660801564027370558e-02 1.086608015640273761e+00 -8.680351906158358111e-02 1.086803519061583678e+00 -8.699902248289345663e-02 1.086999022482893373e+00 -8.719452590420331828e-02 1.087194525904203291e+00 -8.739002932551319380e-02 1.087390029325513208e+00 -8.758553274682306933e-02 1.087585532746823125e+00 -8.778103616813294485e-02 1.087781036168133042e+00 -8.797653958944282038e-02 1.087976539589442737e+00 -8.817204301075268202e-02 1.088172043010752654e+00 -8.836754643206255755e-02 1.088367546432062571e+00 -8.856304985337243307e-02 1.088563049853372489e+00 -8.875855327468230860e-02 1.088758553274682406e+00 -8.895405669599218412e-02 1.088954056695992101e+00 -8.914956011730204577e-02 1.089149560117302018e+00 -8.934506353861192129e-02 1.089345063538611935e+00 -8.954056695992179682e-02 1.089540566959921852e+00 -8.973607038123167234e-02 1.089736070381231769e+00 -8.993157380254154787e-02 1.089931573802541465e+00 -9.012707722385142339e-02 1.090127077223851382e+00 -9.032258064516128504e-02 1.090322580645161299e+00 -9.051808406647116056e-02 1.090518084066471216e+00 -9.071358748778103609e-02 1.090713587487781133e+00 -9.090909090909091161e-02 1.090909090909090828e+00 -9.110459433040078714e-02 1.091104594330400746e+00 -9.130009775171064879e-02 1.091300097751710663e+00 -9.149560117302052431e-02 1.091495601173020580e+00 -9.169110459433039984e-02 1.091691104594330497e+00 -9.188660801564027536e-02 1.091886608015640192e+00 -9.208211143695015088e-02 1.092082111436950109e+00 -9.227761485826002641e-02 1.092277614858260026e+00 -9.247311827956988806e-02 1.092473118279569944e+00 -9.266862170087976358e-02 1.092668621700879861e+00 -9.286412512218963911e-02 1.092864125122189556e+00 -9.305962854349951463e-02 1.093059628543499473e+00 -9.325513196480939015e-02 1.093255131964809390e+00 -9.345063538611925180e-02 1.093450635386119307e+00 -9.364613880742912733e-02 1.093646138807429224e+00 -9.384164222873900285e-02 1.093841642228738920e+00 -9.403714565004887838e-02 1.094037145650048837e+00 -9.423264907135875390e-02 1.094232649071358754e+00 -9.442815249266861555e-02 1.094428152492668671e+00 -9.462365591397849107e-02 1.094623655913978588e+00 -9.481915933528836660e-02 1.094819159335288283e+00 -9.501466275659824212e-02 1.095014662756598200e+00 -9.521016617790811765e-02 1.095210166177908118e+00 -9.540566959921797929e-02 1.095405669599218035e+00 -9.560117302052785482e-02 1.095601173020527952e+00 -9.579667644183773034e-02 1.095796676441837647e+00 -9.599217986314760587e-02 1.095992179863147564e+00 -9.618768328445748139e-02 1.096187683284457481e+00 -9.638318670576735692e-02 1.096383186705767399e+00 -9.657869012707721856e-02 1.096578690127077316e+00 -9.677419354838709409e-02 1.096774193548387011e+00 -9.696969696969696961e-02 1.096969696969696928e+00 -9.716520039100684514e-02 1.097165200391006845e+00 -9.736070381231672066e-02 1.097360703812316762e+00 -9.755620723362658231e-02 1.097556207233626679e+00 -9.775171065493645783e-02 1.097751710654936375e+00 -9.794721407624633336e-02 1.097947214076246292e+00 -9.814271749755620888e-02 1.098142717497556209e+00 -9.833822091886608441e-02 1.098338220918866126e+00 -9.853372434017595993e-02 1.098533724340176043e+00 -9.872922776148582158e-02 1.098729227761485738e+00 -9.892473118279569710e-02 1.098924731182795655e+00 -9.912023460410557263e-02 1.099120234604105573e+00 -9.931573802541544815e-02 1.099315738025415490e+00 -9.951124144672532368e-02 1.099511241446725407e+00 -9.970674486803518533e-02 1.099706744868035102e+00 -9.990224828934506085e-02 1.099902248289345019e+00 -1.000977517106549364e-01 1.100097751710654936e+00 -1.002932551319648119e-01 1.100293255131964854e+00 -1.004887585532746874e-01 1.100488758553274771e+00 -1.006842619745845491e-01 1.100684261974584466e+00 -1.008797653958944246e-01 1.100879765395894383e+00 -1.010752688172043001e-01 1.101075268817204300e+00 -1.012707722385141756e-01 1.101270772238514217e+00 -1.014662756598240512e-01 1.101466275659824134e+00 -1.016617790811339128e-01 1.101661779081133830e+00 -1.018572825024437883e-01 1.101857282502443747e+00 -1.020527859237536639e-01 1.102052785923753664e+00 -1.022482893450635394e-01 1.102248289345063581e+00 -1.024437927663734149e-01 1.102443792766373498e+00 -1.026392961876832904e-01 1.102639296187683193e+00 -1.028347996089931521e-01 1.102834799608993110e+00 -1.030303030303030276e-01 1.103030303030303028e+00 -1.032258064516129031e-01 1.103225806451612945e+00 -1.034213098729227787e-01 1.103421309872922862e+00 -1.036168132942326542e-01 1.103616813294232557e+00 -1.038123167155425158e-01 1.103812316715542474e+00 -1.040078201368523914e-01 1.104007820136852391e+00 -1.042033235581622669e-01 1.104203323558162309e+00 -1.043988269794721424e-01 1.104398826979472226e+00 -1.045943304007820179e-01 1.104594330400781921e+00 -1.047898338220918935e-01 1.104789833822091838e+00 -1.049853372434017551e-01 1.104985337243401755e+00 -1.051808406647116306e-01 1.105180840664711672e+00 -1.053763440860215062e-01 1.105376344086021589e+00 -1.055718475073313817e-01 1.105571847507331285e+00 -1.057673509286412572e-01 1.105767350928641202e+00 -1.059628543499511188e-01 1.105962854349951119e+00 -1.061583577712609944e-01 1.106158357771261036e+00 -1.063538611925708699e-01 1.106353861192570953e+00 -1.065493646138807454e-01 1.106549364613880648e+00 -1.067448680351906209e-01 1.106744868035190565e+00 -1.069403714565004826e-01 1.106940371456500483e+00 -1.071358748778103581e-01 1.107135874877810400e+00 -1.073313782991202336e-01 1.107331378299120317e+00 -1.075268817204301092e-01 1.107526881720430012e+00 -1.077223851417399847e-01 1.107722385141739929e+00 -1.079178885630498463e-01 1.107917888563049846e+00 -1.081133919843597219e-01 1.108113391984359763e+00 -1.083088954056695974e-01 1.108308895405669681e+00 -1.085043988269794729e-01 1.108504398826979376e+00 -1.086999022482893484e-01 1.108699902248289293e+00 -1.088954056695992240e-01 1.108895405669599210e+00 -1.090909090909090856e-01 1.109090909090909127e+00 -1.092864125122189611e-01 1.109286412512219044e+00 -1.094819159335288367e-01 1.109481915933528740e+00 -1.096774193548387122e-01 1.109677419354838657e+00 -1.098729227761485877e-01 1.109872922776148574e+00 -1.100684261974584494e-01 1.110068426197458491e+00 -1.102639296187683249e-01 1.110263929618768408e+00 -1.104594330400782004e-01 1.110459433040078103e+00 -1.106549364613880759e-01 1.110654936461388020e+00 -1.108504398826979515e-01 1.110850439882697938e+00 -1.110459433040078270e-01 1.111045943304007855e+00 -1.112414467253176886e-01 1.111241446725317772e+00 -1.114369501466275642e-01 1.111436950146627467e+00 -1.116324535679374397e-01 1.111632453567937384e+00 -1.118279569892473152e-01 1.111827956989247301e+00 -1.120234604105571907e-01 1.112023460410557218e+00 -1.122189638318670524e-01 1.112218963831867136e+00 -1.124144672531769279e-01 1.112414467253176831e+00 -1.126099706744868034e-01 1.112609970674486748e+00 -1.128054740957966789e-01 1.112805474095796665e+00 -1.130009775171065545e-01 1.113000977517106582e+00 -1.131964809384164161e-01 1.113196480938416499e+00 -1.133919843597262916e-01 1.113391984359726194e+00 -1.135874877810361672e-01 1.113587487781036112e+00 -1.137829912023460427e-01 1.113782991202346029e+00 -1.139784946236559182e-01 1.113978494623655946e+00 -1.141739980449657799e-01 1.114173998044965863e+00 -1.143695014662756554e-01 1.114369501466275558e+00 -1.145650048875855309e-01 1.114565004887585475e+00 -1.147605083088954064e-01 1.114760508308895393e+00 -1.149560117302052820e-01 1.114956011730205310e+00 -1.151515151515151575e-01 1.115151515151515227e+00 -1.153470185728250191e-01 1.115347018572824922e+00 -1.155425219941348947e-01 1.115542521994134839e+00 -1.157380254154447702e-01 1.115738025415444756e+00 -1.159335288367546457e-01 1.115933528836754673e+00 -1.161290322580645212e-01 1.116129032258064591e+00 -1.163245356793743829e-01 1.116324535679374286e+00 -1.165200391006842584e-01 1.116520039100684203e+00 -1.167155425219941339e-01 1.116715542521994120e+00 -1.169110459433040095e-01 1.116911045943304037e+00 -1.171065493646138850e-01 1.117106549364613954e+00 -1.173020527859237605e-01 1.117302052785923649e+00 -1.174975562072336221e-01 1.117497556207233567e+00 -1.176930596285434977e-01 1.117693059628543484e+00 -1.178885630498533732e-01 1.117888563049853401e+00 -1.180840664711632487e-01 1.118084066471163318e+00 -1.182795698924731242e-01 1.118279569892473013e+00 -1.184750733137829859e-01 1.118475073313782930e+00 -1.186705767350928614e-01 1.118670576735092848e+00 -1.188660801564027369e-01 1.118866080156402765e+00 -1.190615835777126125e-01 1.119061583577712682e+00 -1.192570869990224880e-01 1.119257086999022377e+00 -1.194525904203323496e-01 1.119452590420332294e+00 -1.196480938416422252e-01 1.119648093841642211e+00 -1.198435972629521007e-01 1.119843597262952128e+00 -1.200391006842619762e-01 1.120039100684262046e+00 -1.202346041055718517e-01 1.120234604105571741e+00 -1.204301075268817134e-01 1.120430107526881658e+00 -1.206256109481915889e-01 1.120625610948191575e+00 -1.208211143695014644e-01 1.120821114369501492e+00 -1.210166177908113400e-01 1.121016617790811409e+00 -1.212121212121212155e-01 1.121212121212121104e+00 -1.214076246334310910e-01 1.121407624633431022e+00 -1.216031280547409527e-01 1.121603128054740939e+00 -1.217986314760508282e-01 1.121798631476050856e+00 -1.219941348973607037e-01 1.121994134897360773e+00 -1.221896383186705792e-01 1.122189638318670468e+00 -1.223851417399804548e-01 1.122385141739980385e+00 -1.225806451612903164e-01 1.122580645161290303e+00 -1.227761485826001919e-01 1.122776148582600220e+00 -1.229716520039100675e-01 1.122971652003910137e+00 -1.231671554252199430e-01 1.123167155425219832e+00 -1.233626588465298185e-01 1.123362658846529749e+00 -1.235581622678396940e-01 1.123558162267839666e+00 -1.237536656891495557e-01 1.123753665689149583e+00 -1.239491691104594312e-01 1.123949169110459501e+00 -1.241446725317693067e-01 1.124144672531769196e+00 -1.243401759530791822e-01 1.124340175953079113e+00 -1.245356793743890578e-01 1.124535679374389030e+00 -1.247311827956989194e-01 1.124731182795698947e+00 -1.249266862170087949e-01 1.124926686217008864e+00 -1.251221896383186705e-01 1.125122189638318559e+00 -1.253176930596285321e-01 1.125317693059628477e+00 -1.255131964809384215e-01 1.125513196480938394e+00 -1.257086999022482832e-01 1.125708699902248311e+00 -1.259042033235581726e-01 1.125904203323558228e+00 -1.260997067448680342e-01 1.126099706744867923e+00 -1.262952101661778959e-01 1.126295210166177840e+00 -1.264907135874877853e-01 1.126490713587487758e+00 -1.266862170087976469e-01 1.126686217008797675e+00 -1.268817204301075363e-01 1.126881720430107592e+00 -1.270772238514173980e-01 1.127077223851417287e+00 -1.272727272727272596e-01 1.127272727272727204e+00 -1.274682306940371490e-01 1.127468230694037121e+00 -1.276637341153470107e-01 1.127663734115347038e+00 -1.278592375366569001e-01 1.127859237536656956e+00 -1.280547409579667617e-01 1.128054740957966651e+00 -1.282502443792766234e-01 1.128250244379276568e+00 -1.284457478005865128e-01 1.128445747800586485e+00 -1.286412512218963744e-01 1.128641251221896402e+00 -1.288367546432062638e-01 1.128836754643206319e+00 -1.290322580645161255e-01 1.129032258064516014e+00 -1.292277614858260149e-01 1.129227761485825932e+00 -1.294232649071358765e-01 1.129423264907135849e+00 -1.296187683284457381e-01 1.129618768328445766e+00 -1.298142717497556275e-01 1.129814271749755683e+00 -1.300097751710654892e-01 1.130009775171065378e+00 -1.302052785923753786e-01 1.130205278592375295e+00 -1.304007820136852402e-01 1.130400782013685212e+00 -1.305962854349951019e-01 1.130596285434995130e+00 -1.307917888563049913e-01 1.130791788856305047e+00 -1.309872922776148529e-01 1.130987292277614742e+00 -1.311827956989247423e-01 1.131182795698924659e+00 -1.313782991202346040e-01 1.131378299120234576e+00 -1.315738025415444656e-01 1.131573802541544493e+00 -1.317693059628543550e-01 1.131769305962854411e+00 -1.319648093841642167e-01 1.131964809384164106e+00 -1.321603128054741061e-01 1.132160312805474023e+00 -1.323558162267839677e-01 1.132355816226783940e+00 -1.325513196480938294e-01 1.132551319648093857e+00 -1.327468230694037188e-01 1.132746823069403774e+00 -1.329423264907135804e-01 1.132942326490713469e+00 -1.331378299120234698e-01 1.133137829912023387e+00 -1.333333333333333315e-01 1.133333333333333304e+00 -1.335288367546431931e-01 1.133528836754643221e+00 -1.337243401759530825e-01 1.133724340175953138e+00 -1.339198435972629442e-01 1.133919843597262833e+00 -1.341153470185728336e-01 1.134115347018572750e+00 -1.343108504398826952e-01 1.134310850439882667e+00 -1.345063538611925846e-01 1.134506353861192585e+00 -1.347018572825024463e-01 1.134701857282502502e+00 -1.348973607038123079e-01 1.134897360703812197e+00 -1.350928641251221973e-01 1.135092864125122114e+00 -1.352883675464320590e-01 1.135288367546432031e+00 -1.354838709677419484e-01 1.135483870967741948e+00 -1.356793743890518100e-01 1.135679374389051866e+00 -1.358748778103616717e-01 1.135874877810361561e+00 -1.360703812316715611e-01 1.136070381231671478e+00 -1.362658846529814227e-01 1.136265884652981395e+00 -1.364613880742913121e-01 1.136461388074291312e+00 -1.366568914956011738e-01 1.136656891495601229e+00 -1.368523949169110354e-01 1.136852394916910924e+00 -1.370478983382209248e-01 1.137047898338220842e+00 -1.372434017595307865e-01 1.137243401759530759e+00 -1.374389051808406759e-01 1.137438905180840676e+00 -1.376344086021505375e-01 1.137634408602150593e+00 -1.378299120234603992e-01 1.137829912023460288e+00 -1.380254154447702886e-01 1.138025415444770205e+00 -1.382209188660801502e-01 1.138220918866080122e+00 -1.384164222873900396e-01 1.138416422287390040e+00 -1.386119257086999013e-01 1.138611925708699957e+00 -1.388074291300097629e-01 1.138807429130009652e+00 -1.390029325513196523e-01 1.139002932551319569e+00 -1.391984359726295140e-01 1.139198435972629486e+00 -1.393939393939394034e-01 1.139393939393939403e+00 -1.395894428152492650e-01 1.139589442815249321e+00 -1.397849462365591267e-01 1.139784946236559016e+00 -1.399804496578690161e-01 1.139980449657868933e+00 -1.401759530791788777e-01 1.140175953079178850e+00 -1.403714565004887671e-01 1.140371456500488767e+00 -1.405669599217986288e-01 1.140566959921798684e+00 -1.407624633431084904e-01 1.140762463343108379e+00 -1.409579667644183798e-01 1.140957966764418297e+00 -1.411534701857282414e-01 1.141153470185728214e+00 -1.413489736070381309e-01 1.141348973607038131e+00 -1.415444770283479925e-01 1.141544477028348048e+00 -1.417399804496578819e-01 1.141739980449657965e+00 -1.419354838709677435e-01 1.141935483870967660e+00 -1.421309872922776052e-01 1.142130987292277577e+00 -1.423264907135874946e-01 1.142326490713587495e+00 -1.425219941348973562e-01 1.142521994134897412e+00 -1.427174975562072456e-01 1.142717497556207329e+00 -1.429130009775171073e-01 1.142913000977517024e+00 -1.431085043988269689e-01 1.143108504398826941e+00 -1.433040078201368583e-01 1.143304007820136858e+00 -1.434995112414467200e-01 1.143499511241446776e+00 -1.436950146627566094e-01 1.143695014662756693e+00 -1.438905180840664710e-01 1.143890518084066388e+00 -1.440860215053763327e-01 1.144086021505376305e+00 -1.442815249266862221e-01 1.144281524926686222e+00 -1.444770283479960837e-01 1.144477028347996139e+00 -1.446725317693059731e-01 1.144672531769306056e+00 -1.448680351906158348e-01 1.144868035190615752e+00 -1.450635386119256964e-01 1.145063538611925669e+00 -1.452590420332355858e-01 1.145259042033235586e+00 -1.454545454545454475e-01 1.145454545454545503e+00 -1.456500488758553369e-01 1.145650048875855420e+00 -1.458455522971651985e-01 1.145845552297165115e+00 -1.460410557184750602e-01 1.146041055718475032e+00 -1.462365591397849496e-01 1.146236559139784950e+00 -1.464320625610948112e-01 1.146432062561094867e+00 -1.466275659824047006e-01 1.146627565982404784e+00 -1.468230694037145623e-01 1.146823069403714479e+00 -1.470185728250244517e-01 1.147018572825024396e+00 -1.472140762463343133e-01 1.147214076246334313e+00 -1.474095796676441750e-01 1.147409579667644230e+00 -1.476050830889540644e-01 1.147605083088954148e+00 -1.478005865102639260e-01 1.147800586510263843e+00 -1.479960899315738154e-01 1.147996089931573760e+00 -1.481915933528836771e-01 1.148191593352883677e+00 -1.483870967741935387e-01 1.148387096774193594e+00 -1.485826001955034281e-01 1.148582600195503511e+00 -1.487781036168132898e-01 1.148778103616813207e+00 -1.489736070381231792e-01 1.148973607038123124e+00 -1.491691104594330408e-01 1.149169110459433041e+00 -1.493646138807429025e-01 1.149364613880742958e+00 -1.495601173020527919e-01 1.149560117302052875e+00 -1.497556207233626535e-01 1.149755620723362570e+00 -1.499511241446725429e-01 1.149951124144672487e+00 -1.501466275659824046e-01 1.150146627565982405e+00 -1.503421309872922662e-01 1.150342130987292322e+00 -1.505376344086021556e-01 1.150537634408602239e+00 -1.507331378299120173e-01 1.150733137829911934e+00 -1.509286412512219067e-01 1.150928641251221851e+00 -1.511241446725317683e-01 1.151124144672531768e+00 -1.513196480938416300e-01 1.151319648093841685e+00 -1.515151515151515194e-01 1.151515151515151603e+00 -1.517106549364613810e-01 1.151710654936461298e+00 -1.519061583577712704e-01 1.151906158357771215e+00 -1.521016617790811321e-01 1.152101661779081132e+00 -1.522971652003909937e-01 1.152297165200391049e+00 -1.524926686217008831e-01 1.152492668621700966e+00 -1.526881720430107447e-01 1.152688172043010661e+00 -1.528836754643206342e-01 1.152883675464320579e+00 -1.530791788856304958e-01 1.153079178885630496e+00 -1.532746823069403574e-01 1.153274682306940413e+00 -1.534701857282502468e-01 1.153470185728250330e+00 -1.536656891495601085e-01 1.153665689149560025e+00 -1.538611925708699979e-01 1.153861192570869942e+00 -1.540566959921798595e-01 1.154056695992179860e+00 -1.542521994134897489e-01 1.154252199413489777e+00 -1.544477028347996106e-01 1.154447702834799694e+00 -1.546432062561094722e-01 1.154643206256109389e+00 -1.548387096774193616e-01 1.154838709677419306e+00 -1.550342130987292233e-01 1.155034213098729223e+00 -1.552297165200391127e-01 1.155229716520039140e+00 -1.554252199413489743e-01 1.155425219941349058e+00 -1.556207233626588360e-01 1.155620723362658753e+00 -1.558162267839687254e-01 1.155816226783968670e+00 -1.560117302052785870e-01 1.156011730205278587e+00 -1.562072336265884764e-01 1.156207233626588504e+00 -1.564027370478983381e-01 1.156402737047898421e+00 -1.565982404692081997e-01 1.156598240469208116e+00 -1.567937438905180891e-01 1.156793743890518034e+00 -1.569892473118279508e-01 1.156989247311827951e+00 -1.571847507331378402e-01 1.157184750733137868e+00 -1.573802541544477018e-01 1.157380254154447785e+00 -1.575757575757575635e-01 1.157575757575757480e+00 -1.577712609970674529e-01 1.157771260997067397e+00 -1.579667644183773145e-01 1.157966764418377315e+00 -1.581622678396872039e-01 1.158162267839687232e+00 -1.583577712609970656e-01 1.158357771260997149e+00 -1.585532746823069272e-01 1.158553274682306844e+00 -1.587487781036168166e-01 1.158748778103616761e+00 -1.589442815249266783e-01 1.158944281524926678e+00 -1.591397849462365677e-01 1.159139784946236595e+00 -1.593352883675464293e-01 1.159335288367546513e+00 -1.595307917888563187e-01 1.159530791788856430e+00 -1.597262952101661804e-01 1.159726295210166125e+00 -1.599217986314760420e-01 1.159921798631476042e+00 -1.601173020527859314e-01 1.160117302052785959e+00 -1.603128054740957931e-01 1.160312805474095876e+00 -1.605083088954056825e-01 1.160508308895405793e+00 -1.607038123167155441e-01 1.160703812316715489e+00 -1.608993157380254058e-01 1.160899315738025406e+00 -1.610948191593352952e-01 1.161094819159335323e+00 -1.612903225806451568e-01 1.161290322580645240e+00 -1.614858260019550462e-01 1.161485826001955157e+00 -1.616813294232649079e-01 1.161681329423264852e+00 -1.618768328445747695e-01 1.161876832844574770e+00 -1.620723362658846589e-01 1.162072336265884687e+00 -1.622678396871945206e-01 1.162267839687194604e+00 -1.624633431085044100e-01 1.162463343108504521e+00 -1.626588465298142716e-01 1.162658846529814216e+00 -1.628543499511241333e-01 1.162854349951124133e+00 -1.630498533724340227e-01 1.163049853372434050e+00 -1.632453567937438843e-01 1.163245356793743968e+00 -1.634408602150537737e-01 1.163440860215053885e+00 -1.636363636363636354e-01 1.163636363636363580e+00 -1.638318670576734970e-01 1.163831867057673497e+00 -1.640273704789833864e-01 1.164027370478983414e+00 -1.642228739002932481e-01 1.164222873900293331e+00 -1.644183773216031375e-01 1.164418377321603248e+00 -1.646138807429129991e-01 1.164613880742912944e+00 -1.648093841642228607e-01 1.164809384164222861e+00 -1.650048875855327501e-01 1.165004887585532778e+00 -1.652003910068426118e-01 1.165200391006842695e+00 -1.653958944281525012e-01 1.165395894428152612e+00 -1.655913978494623628e-01 1.165591397849462307e+00 -1.657869012707722245e-01 1.165786901270772224e+00 -1.659824046920821139e-01 1.165982404692082142e+00 -1.661779081133919755e-01 1.166177908113392059e+00 -1.663734115347018649e-01 1.166373411534701976e+00 -1.665689149560117266e-01 1.166568914956011671e+00 -1.667644183773216160e-01 1.166764418377321588e+00 -1.669599217986314776e-01 1.166959921798631505e+00 -1.671554252199413393e-01 1.167155425219941423e+00 -1.673509286412512287e-01 1.167350928641251340e+00 -1.675464320625610903e-01 1.167546432062561035e+00 -1.677419354838709797e-01 1.167741935483870952e+00 -1.679374389051808414e-01 1.167937438905180869e+00 -1.681329423264907030e-01 1.168132942326490786e+00 -1.683284457478005924e-01 1.168328445747800703e+00 -1.685239491691104541e-01 1.168523949169110399e+00 -1.687194525904203435e-01 1.168719452590420316e+00 -1.689149560117302051e-01 1.168914956011730233e+00 -1.691104594330400668e-01 1.169110459433040150e+00 -1.693059628543499562e-01 1.169305962854350067e+00 -1.695014662756598178e-01 1.169501466275659762e+00 -1.696969696969697072e-01 1.169696969696969679e+00 -1.698924731182795689e-01 1.169892473118279597e+00 -1.700879765395894305e-01 1.170087976539589514e+00 -1.702834799608993199e-01 1.170283479960899431e+00 -1.704789833822091816e-01 1.170478983382209126e+00 -1.706744868035190710e-01 1.170674486803519043e+00 -1.708699902248289326e-01 1.170869990224828960e+00 -1.710654936461387943e-01 1.171065493646138878e+00 -1.712609970674486837e-01 1.171260997067448795e+00 -1.714565004887585453e-01 1.171456500488758490e+00 -1.716520039100684347e-01 1.171652003910068407e+00 -1.718475073313782964e-01 1.171847507331378324e+00 -1.720430107526881858e-01 1.172043010752688241e+00 -1.722385141739980474e-01 1.172238514173998158e+00 -1.724340175953079091e-01 1.172434017595307854e+00 -1.726295210166177985e-01 1.172629521016617771e+00 -1.728250244379276601e-01 1.172825024437927688e+00 -1.730205278592375495e-01 1.173020527859237605e+00 -1.732160312805474112e-01 1.173216031280547522e+00 -1.734115347018572728e-01 1.173411534701857217e+00 -1.736070381231671622e-01 1.173607038123167134e+00 -1.738025415444770239e-01 1.173802541544477052e+00 -1.739980449657869133e-01 1.173998044965786969e+00 -1.741935483870967749e-01 1.174193548387096886e+00 -1.743890518084066366e-01 1.174389051808406581e+00 -1.745845552297165260e-01 1.174584555229716498e+00 -1.747800586510263876e-01 1.174780058651026415e+00 -1.749755620723362770e-01 1.174975562072336333e+00 -1.751710654936461387e-01 1.175171065493646250e+00 -1.753665689149560003e-01 1.175366568914955945e+00 -1.755620723362658897e-01 1.175562072336265862e+00 -1.757575757575757514e-01 1.175757575757575779e+00 -1.759530791788856408e-01 1.175953079178885696e+00 -1.761485826001955024e-01 1.176148582600195613e+00 -1.763440860215053640e-01 1.176344086021505309e+00 -1.765395894428152535e-01 1.176539589442815226e+00 -1.767350928641251151e-01 1.176735092864125143e+00 -1.769305962854350045e-01 1.176930596285435060e+00 -1.771260997067448661e-01 1.177126099706744977e+00 -1.773216031280547278e-01 1.177321603128054672e+00 -1.775171065493646172e-01 1.177517106549364589e+00 -1.777126099706744788e-01 1.177712609970674507e+00 -1.779081133919843682e-01 1.177908113391984424e+00 -1.781036168132942299e-01 1.178103616813294341e+00 -1.782991202346040915e-01 1.178299120234604036e+00 -1.784946236559139809e-01 1.178494623655913953e+00 -1.786901270772238426e-01 1.178690127077223870e+00 -1.788856304985337320e-01 1.178885630498533788e+00 -1.790811339198435936e-01 1.179081133919843705e+00 -1.792766373411534830e-01 1.179276637341153400e+00 -1.794721407624633447e-01 1.179472140762463317e+00 -1.796676441837732063e-01 1.179667644183773234e+00 -1.798631476050830957e-01 1.179863147605083151e+00 -1.800586510263929574e-01 1.180058651026393068e+00 -1.802541544477028468e-01 1.180254154447702764e+00 -1.804496578690127084e-01 1.180449657869012681e+00 -1.806451612903225701e-01 1.180645161290322598e+00 -1.808406647116324595e-01 1.180840664711632515e+00 -1.810361681329423211e-01 1.181036168132942432e+00 -1.812316715542522105e-01 1.181231671554252127e+00 -1.814271749755620722e-01 1.181427174975562044e+00 -1.816226783968719338e-01 1.181622678396871962e+00 -1.818181818181818232e-01 1.181818181818181879e+00 -1.820136852394916849e-01 1.182013685239491796e+00 -1.822091886608015743e-01 1.182209188660801491e+00 -1.824046920821114359e-01 1.182404692082111408e+00 -1.826001955034212976e-01 1.182600195503421325e+00 -1.827956989247311870e-01 1.182795698924731242e+00 -1.829912023460410486e-01 1.182991202346041160e+00 -1.831867057673509380e-01 1.183186705767350855e+00 -1.833822091886607997e-01 1.183382209188660772e+00 -1.835777126099706613e-01 1.183577712609970689e+00 -1.837732160312805507e-01 1.183773216031280606e+00 -1.839687194525904124e-01 1.183968719452590523e+00 -1.841642228739003018e-01 1.184164222873900219e+00 -1.843597262952101634e-01 1.184359726295210136e+00 -1.845552297165200528e-01 1.184555229716520053e+00 -1.847507331378299145e-01 1.184750733137829970e+00 -1.849462365591397761e-01 1.184946236559139887e+00 -1.851417399804496655e-01 1.185141739980449582e+00 -1.853372434017595272e-01 1.185337243401759499e+00 -1.855327468230694166e-01 1.185532746823069417e+00 -1.857282502443792782e-01 1.185728250244379334e+00 -1.859237536656891399e-01 1.185923753665689251e+00 -1.861192570869990293e-01 1.186119257086998946e+00 -1.863147605083088909e-01 1.186314760508308863e+00 -1.865102639296187803e-01 1.186510263929618780e+00 -1.867057673509286420e-01 1.186705767350928697e+00 -1.869012707722385036e-01 1.186901270772238615e+00 -1.870967741935483930e-01 1.187096774193548310e+00 -1.872922776148582547e-01 1.187292277614858227e+00 -1.874877810361681441e-01 1.187487781036168144e+00 -1.876832844574780057e-01 1.187683284457478061e+00 -1.878787878787878673e-01 1.187878787878787978e+00 -1.880742913000977568e-01 1.188074291300097673e+00 -1.882697947214076184e-01 1.188269794721407591e+00 -1.884652981427175078e-01 1.188465298142717508e+00 -1.886608015640273694e-01 1.188660801564027425e+00 -1.888563049853372311e-01 1.188856304985337342e+00 -1.890518084066471205e-01 1.189051808406647037e+00 -1.892473118279569821e-01 1.189247311827956954e+00 -1.894428152492668715e-01 1.189442815249266872e+00 -1.896383186705767332e-01 1.189638318670576789e+00 -1.898338220918865948e-01 1.189833822091886706e+00 -1.900293255131964842e-01 1.190029325513196401e+00 -1.902248289345063459e-01 1.190224828934506318e+00 -1.904203323558162353e-01 1.190420332355816235e+00 -1.906158357771260969e-01 1.190615835777126152e+00 -1.908113391984359586e-01 1.190811339198436070e+00 -1.910068426197458480e-01 1.191006842619745765e+00 -1.912023460410557096e-01 1.191202346041055682e+00 -1.913978494623655990e-01 1.191397849462365599e+00 -1.915933528836754607e-01 1.191593352883675516e+00 -1.917888563049853501e-01 1.191788856304985433e+00 -1.919843597262952117e-01 1.191984359726295128e+00 -1.921798631476050734e-01 1.192179863147605046e+00 -1.923753665689149628e-01 1.192375366568914963e+00 -1.925708699902248244e-01 1.192570869990224880e+00 -1.927663734115347138e-01 1.192766373411534797e+00 -1.929618768328445755e-01 1.192961876832844492e+00 -1.931573802541544371e-01 1.193157380254154409e+00 -1.933528836754643265e-01 1.193352883675464327e+00 -1.935483870967741882e-01 1.193548387096774244e+00 -1.937438905180840776e-01 1.193743890518084161e+00 -1.939393939393939392e-01 1.193939393939393856e+00 -1.941348973607038009e-01 1.194134897360703773e+00 -1.943304007820136903e-01 1.194330400782013690e+00 -1.945259042033235519e-01 1.194525904203323607e+00 -1.947214076246334413e-01 1.194721407624633525e+00 -1.949169110459433030e-01 1.194916911045943220e+00 -1.951124144672531646e-01 1.195112414467253137e+00 -1.953079178885630540e-01 1.195307917888563054e+00 -1.955034213098729157e-01 1.195503421309872971e+00 -1.956989247311828051e-01 1.195698924731182888e+00 -1.958944281524926667e-01 1.195894428152492583e+00 -1.960899315738025284e-01 1.196089931573802501e+00 -1.962854349951124178e-01 1.196285434995112418e+00 -1.964809384164222794e-01 1.196480938416422335e+00 -1.966764418377321688e-01 1.196676441837732252e+00 -1.968719452590420305e-01 1.196871945259041947e+00 -1.970674486803519199e-01 1.197067448680351864e+00 -1.972629521016617815e-01 1.197262952101661782e+00 -1.974584555229716432e-01 1.197458455522971699e+00 -1.976539589442815326e-01 1.197653958944281616e+00 -1.978494623655913942e-01 1.197849462365591311e+00 -1.980449657869012836e-01 1.198044965786901228e+00 -1.982404692082111453e-01 1.198240469208211145e+00 -1.984359726295210069e-01 1.198435972629521062e+00 -1.986314760508308963e-01 1.198631476050830980e+00 -1.988269794721407580e-01 1.198826979472140675e+00 -1.990224828934506474e-01 1.199022482893450592e+00 -1.992179863147605090e-01 1.199217986314760509e+00 -1.994134897360703707e-01 1.199413489736070426e+00 -1.996089931573802601e-01 1.199608993157380343e+00 -1.998044965786901217e-01 1.199804496578690038e+00 -2.000000000000000111e-01 1.199999999999999956e+00 diff --git a/output/colore_node0.dbg b/output/colore_node0.dbg deleted file mode 100644 index d58c206..0000000 --- a/output/colore_node0.dbg +++ /dev/null @@ -1 +0,0 @@ -MPI task 0 has 97421 particles diff --git a/output/colore_params.cfg b/output/colore_params.cfg deleted file mode 100644 index c7dcbe5..0000000 --- a/output/colore_params.cfg +++ /dev/null @@ -1,55 +0,0 @@ -global = { - prefix_out = "output/colore" - output_format = "FITS" - output_density = true - pk_filename = "output/pk.txt" - z_min = 0.0001 - z_max = 0.15 - seed = 1000 - write_pred = false - just_write_pred = false -} -field_par = { - r_smooth = 1.0 - smooth_potential = true - n_grid = 256 - dens_type = 1 - lpt_buffer_fraction = 0.6 - lpt_interp_type = 1 - output_lpt = 0 -} -cosmo_par = { - omega_M = 0.3 - omega_B = 0.3 - omega_L = 0.7 - h = 0.7 - w = -1.0 - ns = 0.96 - sigma_8 = 0.8 -} -custom1 = { - kz_filename = "output/wz.txt" - bias_filename = "output/bias.txt" - nside = 64 -} -srcs1 = { - nz_filename = "output/dndz.txt" - bias_filename = "output/bias.txt" - include_lensing = true - store_skewers = true -} -imap1 = { - tbak_filename = "output/tz.txt" - bias_filename = "output/bias.txt" - freq_list = "output/nuTable.txt" - freq_rest = 1420.0 - nside = 64 -} -kappa = { - z_out = [ 0.1 ] - nside = 64 -} -isw = { - z_out = [ 0.1 ] - nside = 64 -} diff --git a/output/dndz.txt b/output/dndz.txt deleted file mode 100644 index 8f1b9cd..0000000 --- a/output/dndz.txt +++ /dev/null @@ -1,1024 +0,0 @@ -0.000000000000000000e+00 0.000000000000000000e+00 -1.955034213098729226e-04 5.144614850061313485e-03 -3.910068426197458452e-04 2.055867461599717935e-02 -5.865102639296187678e-04 4.619943569916008103e-02 -7.820136852394916904e-04 8.201127089156068362e-02 -9.775171065493646130e-04 1.279283939788823932e-01 -1.173020527859237536e-03 1.838764005650315447e-01 -1.368523949169110458e-03 2.497733215606447454e-01 -1.564027370478983381e-03 3.255304139944505404e-01 -1.759530791788856303e-03 4.110527900479271080e-01 -1.955034213098729226e-03 5.062399377224686692e-01 -2.150537634408602149e-03 6.109861645187324442e-01 -2.346041055718475071e-03 7.251809839682573644e-01 -2.541544477028347994e-03 8.487094582682835897e-01 -2.737047898338220916e-03 9.814525062558020485e-01 -2.932551319648093839e-03 1.123287183382744026e+00 -3.128054740957966762e-03 1.274086938634620303e+00 -3.323558162267839684e-03 1.433721852146530251e+00 -3.519061583577712607e-03 1.602058856425442324e+00 -3.714565004887585530e-03 1.778961943472002316e+00 -3.910068426197458452e-03 1.964292359637076046e+00 -4.105571847507331375e-03 2.157908789701169727e+00 -4.301075268817204297e-03 2.359667531397612539e+00 -4.496578690127077220e-03 2.569422661391640883e+00 -4.692082111436950143e-03 2.787026193562406551e+00 -4.887585532746823065e-03 3.012328230302780518e+00 -5.083088954056695988e-03 3.245177107445030185e+00 -5.278592375366568910e-03 3.485419533333289355e+00 -5.474095796676441833e-03 3.732900722491982126e+00 -5.669599217986314756e-03 3.987464524279927591e+00 -5.865102639296187678e-03 4.248953546870121833e+00 -6.060606060606060601e-03 4.517209276853444422e+00 -6.256109481915933523e-03 4.792072194729219525e+00 -6.451612903225806446e-03 5.073381886515504036e+00 -6.647116324535679369e-03 5.360977151686284969e+00 -6.842619745845552291e-03 5.654696107620751810e+00 -7.038123167155425214e-03 5.954376290730726495e+00 -7.233626588465298136e-03 6.259854754415894895e+00 -7.429130009775171059e-03 6.570968163982113808e+00 -7.624633431085043982e-03 6.887552888645597449e+00 -7.820136852394916904e-03 7.209445090734797112e+00 -8.015640273704788960e-03 7.536480812192184686e+00 -8.211143695014662749e-03 7.868496058469691690e+00 -8.406647116324536539e-03 8.205326879904005111e+00 -8.602150537634408595e-03 8.546809450651410955e+00 -8.797653958944280650e-03 8.892780145255825275e+00 -8.993157380254154440e-03 9.243075612918605799e+00 -9.188660801564028230e-03 9.597532849533820354e+00 -9.384164222873900285e-03 9.955989267548797983e+00 -9.579667644183772340e-03 1.031828276370569952e+01 -9.775171065493646130e-03 1.068425178471676773e+01 -9.970674486803519920e-03 1.105373539092272495e+01 -1.016617790811339198e-02 1.142657331798121234e+01 -1.036168132942326403e-02 1.180260603662959085e+01 -1.055718475073313782e-02 1.218167481056429580e+01 -1.075268817204301161e-02 1.256362175247692470e+01 -1.094819159335288367e-02 1.294828987828541500e+01 -1.114369501466275572e-02 1.333552315959705048e+01 -1.133919843597262951e-02 1.372516657443849830e+01 -1.153470185728250330e-02 1.411706615628677319e+01 -1.173020527859237536e-02 1.451106904143378351e+01 -1.192570869990224741e-02 1.490702351471596465e+01 -1.212121212121212120e-02 1.530477905363949453e+01 -1.231671554252199499e-02 1.570418637093061598e+01 -1.251221896383186705e-02 1.610509745553979499e+01 -1.270772238514173910e-02 1.650736561212764641e+01 -1.290322580645161289e-02 1.691084549905964352e+01 -1.309872922776148668e-02 1.731539316493635994e+01 -1.329423264907135874e-02 1.772086608368491767e+01 -1.348973607038123079e-02 1.812712318823713886e+01 -1.368523949169110458e-02 1.853402490281910531e+01 -1.388074291300097837e-02 1.894143317387645453e+01 -1.407624633431085043e-02 1.934921149965935427e+01 -1.427174975562072248e-02 1.975722495849057125e+01 -1.446725317693059627e-02 2.016534023573964518e+01 -1.466275659824047006e-02 2.057342564952594088e+01 -1.485826001955034212e-02 2.098135117517296422e+01 -1.505376344086021417e-02 2.138898846843592594e+01 -1.524926686217008796e-02 2.179621088752426417e+01 -1.544477028347996175e-02 2.220289351394074018e+01 -1.564027370478983381e-02 2.260891317215816798e+01 -1.583577712609970586e-02 2.301414844815477778e+01 -1.603128054740957792e-02 2.341847970682891855e+01 -1.622678396871945344e-02 2.382178910831359886e+01 -1.642228739002932550e-02 2.422396062321106669e+01 -1.661779081133919755e-02 2.462488004676758990e+01 -1.681329423264907308e-02 2.502443501200816200e+01 -1.700879765395894513e-02 2.542251500185090762e+01 -1.720430107526881719e-02 2.581901136022058907e+01 -1.739980449657868924e-02 2.621381730218054784e+01 -1.759530791788856130e-02 2.660682792310217692e+01 -1.779081133919843682e-02 2.699794020689086693e+01 -1.798631476050830888e-02 2.738705303328724838e+01 -1.818181818181818094e-02 2.777406718426227172e+01 -1.837732160312805646e-02 2.815888534952466671e+01 -1.857282502443792851e-02 2.854141213115898523e+01 -1.876832844574780057e-02 2.892155404741243885e+01 -1.896383186705767263e-02 2.929921953564849701e+01 -1.915933528836754468e-02 2.967431895448504520e+01 -1.935483870967742021e-02 3.004676458513481307e+01 -1.955034213098729226e-02 3.041647063196561618e+01 -1.974584555229716432e-02 3.078335322229773396e+01 -1.994134897360703984e-02 3.114733040545573317e+01 -2.013685239491691190e-02 3.150832215109170420e+01 -2.033235581622678395e-02 3.186625034679698487e+01 -2.052785923753665601e-02 3.222103879501899826e+01 -2.072336265884652806e-02 3.257261320929996629e+01 -2.091886608015640359e-02 3.292090120985386648e+01 -2.111436950146627564e-02 3.326583231849808442e+01 -2.130987292277614770e-02 3.360733795295581672e+01 -2.150537634408602322e-02 3.394535142054536436e+01 -2.170087976539589528e-02 3.427980791127210125e+01 -2.189638318670576733e-02 3.461064449033892743e+01 -2.209188660801563939e-02 3.493780009009068266e+01 -2.228739002932551144e-02 3.526121550140803862e+01 -2.248289345063538697e-02 3.558083336456613921e+01 -2.267839687194525902e-02 3.589659815957284650e+01 -2.287390029325513108e-02 3.620845619600203236e+01 -2.306940371456500660e-02 3.651635560233617639e+01 -2.326490713587487866e-02 3.682024631483330523e+01 -2.346041055718475071e-02 3.712008006593250542e+01 -2.365591397849462277e-02 3.741581037221255457e+01 -2.385141739980449482e-02 3.770739252191757629e+01 -2.404692082111437035e-02 3.799478356206386565e+01 -2.424242424242424240e-02 3.827794228514178343e+01 -2.443792766373411446e-02 3.855682921542626218e+01 -2.463343108504398998e-02 3.883140659490945268e+01 -2.482893450635386204e-02 3.910163836886890465e+01 -2.502443792766373409e-02 3.936749017108454751e+01 -2.521994134897360615e-02 3.962892930871727515e+01 -2.541544477028347820e-02 3.988592474686212341e+01 -2.561094819159335373e-02 4.013844709278873069e+01 -2.580645161290322578e-02 4.038646857988166516e+01 -2.600195503421309784e-02 4.062996305129266261e+01 -2.619745845552297336e-02 4.086890594331743642e+01 -2.639296187683284542e-02 4.110327426850863475e+01 -2.658846529814271747e-02 4.133304659853704521e+01 -2.678396871945258953e-02 4.155820304681266464e+01 -2.697947214076246158e-02 4.177872525087713029e+01 -2.717497556207233711e-02 4.199459635457884588e+01 -2.737047898338220916e-02 4.220580099004195063e+01 -2.756598240469208122e-02 4.241232525944030840e+01 -2.776148582600195674e-02 4.261415671658703985e+01 -2.795698924731182880e-02 4.281128434835051166e+01 -2.815249266862170086e-02 4.300369855590719936e+01 -2.834799608993157291e-02 4.319139113584174794e+01 -2.854349951124144497e-02 4.337435526110427730e+01 -2.873900293255132049e-02 4.355258546183518575e+01 -2.893450635386119255e-02 4.372607760606692295e+01 -2.913000977517106460e-02 4.389482888031268715e+01 -2.932551319648094013e-02 4.405883777005128366e+01 -2.952101661779081218e-02 4.421810404011767304e+01 -2.971652003910068424e-02 4.437262871500808359e+01 -2.991202346041055629e-02 4.452241405910898919e+01 -3.010752688172042835e-02 4.466746355685844350e+01 -3.030303030303030387e-02 4.480778189284860247e+01 -3.049853372434017593e-02 4.494337493187794053e+01 -3.069403714565004798e-02 4.507424969896120359e+01 -3.088954056695992351e-02 4.520041435930561846e+01 -3.108504398826979556e-02 4.532187819826108210e+01 -3.128054740957966762e-02 4.543865160125209712e+01 -3.147605083088954314e-02 4.555074603369951802e+01 -3.167155425219941173e-02 4.565817402093892952e+01 -3.186705767350928725e-02 4.576094912814371440e+01 -3.206256109481915584e-02 4.585908594025946883e+01 -3.225806451612903136e-02 4.595260004195691295e+01 -3.245356793743890689e-02 4.604150799761031720e+01 -3.264907135874877547e-02 4.612582733130793855e+01 -3.284457478005865100e-02 4.620557650690107465e+01 -3.304007820136852652e-02 4.628077490809814520e+01 -3.323558162267839511e-02 4.635144281861001758e+01 -3.343108504398827063e-02 4.641760140235270882e+01 -3.362658846529814616e-02 4.647927268371326903e+01 -3.382209188660801474e-02 4.653647952788470121e+01 -3.401759530791789027e-02 4.658924562127551638e+01 -3.421309872922775885e-02 4.663759545199958723e+01 -3.440860215053763438e-02 4.668155429045129523e+01 -3.460410557184750990e-02 4.672114816997127207e+01 -3.479960899315737849e-02 4.675640386760817790e+01 -3.499511241446725401e-02 4.678734888498071598e+01 -3.519061583577712260e-02 4.681401142924514858e+01 -3.538611925708699812e-02 4.683642039417281921e+01 -3.558162267839687365e-02 4.685460534134208643e+01 -3.577712609970674223e-02 4.686859648144905321e+01 -3.597262952101661776e-02 4.687842465574129136e+01 -3.616813294232649328e-02 4.688412131757858958e+01 -3.636363636363636187e-02 4.688571851412482516e+01 -3.655913978494623739e-02 4.688324886817449766e+01 -3.675464320625611292e-02 4.687674556011786819e+01 -3.695014662756598151e-02 4.686624231004795860e+01 -3.714565004887585703e-02 4.685177336001324733e+01 -3.734115347018572562e-02 4.683337345641888305e+01 -3.753665689149560114e-02 4.681107783257982646e+01 -3.773216031280547667e-02 4.678492219142910358e+01 -3.792766373411534525e-02 4.675494268838377110e+01 -3.812316715542522078e-02 4.672117591437162787e+01 -3.831867057673508936e-02 4.668365887902122324e+01 -3.851417399804496489e-02 4.664242899401804010e+01 -3.870967741935484041e-02 4.659752405662870700e+01 -3.890518084066470900e-02 4.654898223339626639e+01 -3.910068426197458452e-02 4.649684204400818999e+01 -3.929618768328446005e-02 4.644114234533973473e+01 -3.949169110459432863e-02 4.638192231567413160e+01 -3.968719452590420416e-02 4.631922143910198031e+01 -3.988269794721407968e-02 4.625307949010134934e+01 -4.007820136852394827e-02 4.618353651830047113e+01 -4.027370478983382379e-02 4.611063283342453190e+01 -4.046920821114369238e-02 4.603440899042805512e+01 -4.066471163245356790e-02 4.595490577481422179e+01 -4.086021505376344343e-02 4.587216418814271890e+01 -4.105571847507331201e-02 4.578622543372684106e+01 -4.125122189638318754e-02 4.569713090252140830e+01 -4.144672531769305612e-02 4.560492215920228176e+01 -4.164222873900293165e-02 4.550964092843846487e+01 -4.183773216031280717e-02 4.541132908135769242e+01 -4.203323558162267576e-02 4.531002862220601202e+01 -4.222873900293255128e-02 4.520578167520254453e+01 -4.242424242424242681e-02 4.509863047158939509e+01 -4.261974584555229539e-02 4.498861733687773778e+01 -4.281524926686217092e-02 4.487578467829007423e+01 -4.301075268817204644e-02 4.476017497239941889e+01 -4.320625610948191503e-02 4.464183075296534753e+01 -4.340175953079179055e-02 4.452079459896732061e+01 -4.359726295210165914e-02 4.439710912283516109e+01 -4.379276637341153466e-02 4.427081695887712698e+01 -4.398826979472141019e-02 4.414196075190517377e+01 -4.418377321603127877e-02 4.401058314605740662e+01 -4.437927663734115430e-02 4.387672677381776509e+01 -4.457478005865102288e-02 4.374043424523246415e+01 -4.477028347996089841e-02 4.360174813732303534e+01 -4.496578690127077393e-02 4.346071098369549901e+01 -4.516129032258064252e-02 4.331736526434551848e+01 -4.535679374389051804e-02 4.317175339565871894e+01 -4.555229716520039357e-02 4.302391772060579456e+01 -4.574780058651026216e-02 4.287390049913189216e+01 -4.594330400782013768e-02 4.272174389873948286e+01 -4.613880742913001320e-02 4.256748998526412464e+01 -4.633431085043988179e-02 4.241118071384233446e+01 -4.652981427174975732e-02 4.225285792007058205e+01 -4.672531769305962590e-02 4.209256331135498641e+01 -4.692082111436950143e-02 4.193033845845040730e+01 -4.711632453567937695e-02 4.176622478718800124e+01 -4.731182795698924554e-02 4.160026357039054545e+01 -4.750733137829912106e-02 4.143249591997432191e+01 -4.770283479960898965e-02 4.126296277923626121e+01 -4.789833822091886517e-02 4.109170491532550784e+01 -4.809384164222874070e-02 4.091876291189838355e+01 -4.828934506353860928e-02 4.074417716195498684e+01 -4.848484848484848481e-02 4.056798786085668240e+01 -4.868035190615836033e-02 4.039023499952295282e+01 -4.887585532746822892e-02 4.021095835780656103e+01 -4.907135874877810444e-02 4.003019749804524707e+01 -4.926686217008797997e-02 3.984799175878913502e+01 -4.946236559139784855e-02 3.966438024870169698e+01 -4.965786901270772408e-02 3.947940184063381963e+01 -4.985337243401759266e-02 3.929309516586844353e+01 -5.004887585532746819e-02 3.910549860853510040e+01 -5.024437927663734371e-02 3.891665030019235871e+01 -5.043988269794721230e-02 3.872658811457687023e+01 -5.063538611925708782e-02 3.853534966251729088e+01 -5.083088954056695641e-02 3.834297228701142046e+01 -5.102639296187683193e-02 3.814949305846536731e+01 -5.122189638318670746e-02 3.795494877009237911e+01 -5.141739980449657604e-02 3.775937593347043020e+01 -5.161290322580645157e-02 3.756281077425617809e+01 -5.180840664711632709e-02 3.736528922805434405e+01 -5.200391006842619568e-02 3.716684693644003090e+01 -5.219941348973607120e-02 3.696751924313281989e+01 -5.239491691104594673e-02 3.676734119032056469e+01 -5.259042033235581531e-02 3.656634751513141879e+01 -5.278592375366569084e-02 3.636457264625189367e+01 -5.298142717497555942e-02 3.616205070068969007e+01 -5.317693059628543495e-02 3.595881548067885802e+01 -5.337243401759531047e-02 3.575490047072634070e+01 -5.356793743890517906e-02 3.555033883479703860e+01 -5.376344086021505458e-02 3.534516341363657688e+01 -5.395894428152492317e-02 3.513940672222905448e+01 -5.415444770283479869e-02 3.493310094738872351e+01 -5.434995112414467422e-02 3.472627794548312608e+01 -5.454545454545454281e-02 3.451896924028614677e+01 -5.474095796676441833e-02 3.431120602095906946e+01 -5.493646138807429385e-02 3.410301914015777669e+01 -5.513196480938416244e-02 3.389443911226415906e+01 -5.532746823069403797e-02 3.368549611173985880e+01 -5.552297165200391349e-02 3.347621997160070606e+01 -5.571847507331378208e-02 3.326664018200965245e+01 -5.591397849462365760e-02 3.305678588898648229e+01 -5.610948191593352619e-02 3.284668589323246835e+01 -5.630498533724340171e-02 3.263636864906798252e+01 -5.650048875855327724e-02 3.242586226348145573e+01 -5.669599217986314582e-02 3.221519449528729950e+01 -5.689149560117302135e-02 3.200439275439148190e+01 -5.708699902248288993e-02 3.179348410116273627e+01 -5.728250244379276546e-02 3.158249524590714330e+01 -5.747800586510264098e-02 3.137145254844488562e+01 -5.767350928641250957e-02 3.116038201778686911e+01 -5.786901270772238509e-02 3.094930931190948087e+01 -5.806451612903226062e-02 3.073825973762573582e+01 -5.826001955034212920e-02 3.052725825055081188e+01 -5.845552297165200473e-02 3.031632945516043520e+01 -5.865102639296188025e-02 3.010549760493989524e+01 -5.884652981427174884e-02 2.989478660262235366e+01 -5.904203323558162436e-02 2.968422000051411658e+01 -5.923753665689149295e-02 2.947382100090564094e+01 -5.943304007820136847e-02 2.926361245656607935e+01 -5.962854349951124400e-02 2.905361687131978954e+01 -5.982404692082111258e-02 2.884385640070291856e+01 -6.001955034213098811e-02 2.863435285269845210e+01 -6.021505376344085669e-02 2.842512768854805216e+01 -6.041055718475073222e-02 2.821620202363849117e+01 -6.060606060606060774e-02 2.800759662846176568e+01 -6.080156402737047633e-02 2.779933192964630351e+01 -6.099706744868035185e-02 2.759142801105830500e+01 -6.119257086999022738e-02 2.738390461497112938e+01 -6.138807429130009596e-02 2.717678114330115946e+01 -6.158357771260997149e-02 2.697007665890846440e+01 -6.177908113391984701e-02 2.676380988696081786e+01 -6.197458455522971560e-02 2.655799921635919603e+01 -6.217008797653959112e-02 2.635266270122319199e+01 -6.236559139784945971e-02 2.614781806243481554e+01 -6.256109481915933523e-02 2.594348268923932466e+01 -6.275659824046921076e-02 2.573967364090086107e+01 -6.295210166177908628e-02 2.553640764841219735e+01 -6.314760508308894793e-02 2.533370111625619714e+01 -6.334310850439882346e-02 2.513157012421829961e+01 -6.353861192570869898e-02 2.493003042924788204e+01 -6.373411534701857450e-02 2.472909746736724657e+01 -6.392961876832845003e-02 2.452878635562689169e+01 -6.412512218963831168e-02 2.432911189410534547e+01 -6.432062561094818720e-02 2.413008856795235602e+01 -6.451612903225806273e-02 2.393173054947374467e+01 -6.471163245356793825e-02 2.373405170025700528e+01 -6.490713587487781377e-02 2.353706557333559957e+01 -6.510263929618768930e-02 2.334078541539104279e+01 -6.529814271749755095e-02 2.314522416899133717e+01 -6.549364613880742647e-02 2.295039447486427164e+01 -6.568914956011730200e-02 2.275630867420443337e+01 -6.588465298142717752e-02 2.256297881101251690e+01 -6.608015640273705305e-02 2.237041663446557038e+01 -6.627565982404691469e-02 2.217863360131724804e+01 -6.647116324535679022e-02 2.198764087832631020e+01 -6.666666666666666574e-02 2.179744934471255391e+01 -6.686217008797654127e-02 2.160806959463874577e+01 -6.705767350928641679e-02 2.141951193971743095e+01 -6.725317693059629232e-02 2.123178641154130375e+01 -6.744868035190615396e-02 2.104490276423626227e+01 -6.764418377321602949e-02 2.085887047703548447e+01 -6.783968719452590501e-02 2.067369875687415259e+01 -6.803519061583578054e-02 2.048939654100291818e+01 -6.823069403714565606e-02 2.030597249961945039e+01 -6.842619745845551771e-02 2.012343503851695914e+01 -6.862170087976539323e-02 1.994179230174846396e+01 -6.881720430107526876e-02 1.976105217430603744e+01 -6.901270772238514428e-02 1.958122228481353844e+01 -6.920821114369501981e-02 1.940231000823240493e+01 -6.940371456500488145e-02 1.922432246857902527e+01 -6.959921798631475698e-02 1.904726654165287059e+01 -6.979472140762463250e-02 1.887114885777466355e+01 -6.999022482893450803e-02 1.869597580453311991e+01 -7.018572825024438355e-02 1.852175352953993581e+01 -7.038123167155424520e-02 1.834848794319164256e+01 -7.057673509286412072e-02 1.817618472143754715e+01 -7.077223851417399625e-02 1.800484930855330035e+01 -7.096774193548387177e-02 1.783448691991842239e+01 -7.116324535679374730e-02 1.766510254479771902e+01 -7.135874877810362282e-02 1.749670094912529805e+01 -7.155425219941348447e-02 1.732928667829060743e+01 -7.174975562072335999e-02 1.716286405992553199e+01 -7.194525904203323552e-02 1.699743720669189173e+01 -7.214076246334311104e-02 1.683301001906861671e+01 -7.233626588465298657e-02 1.666958618813763593e+01 -7.253176930596284822e-02 1.650716919836805019e+01 -7.272727272727272374e-02 1.634576233039756588e+01 -7.292277614858259926e-02 1.618536866381079875e+01 -7.311827956989247479e-02 1.602599107991353122e+01 -7.331378299120235031e-02 1.586763226450235997e+01 -7.350928641251222584e-02 1.571029471062900029e+01 -7.370478983382208749e-02 1.555398072135886700e+01 -7.390029325513196301e-02 1.539869241252286614e+01 -7.409579667644183854e-02 1.524443171546223574e+01 -7.429130009775171406e-02 1.509120037976558137e+01 -7.448680351906158958e-02 1.493899997599756801e+01 -7.468230694037145123e-02 1.478783189841885992e+01 -7.487781036168132676e-02 1.463769736769643792e+01 -7.507331378299120228e-02 1.448859743360422137e+01 -7.526881720430107781e-02 1.434053297771304436e+01 -7.546432062561095333e-02 1.419350471606967012e+01 -7.565982404692081498e-02 1.404751320186442953e+01 -7.585532746823069050e-02 1.390255882808678578e+01 -7.605083088954056603e-02 1.375864183016867770e+01 -7.624633431085044155e-02 1.361576228861479088e+01 -7.644183773216031708e-02 1.347392013161966950e+01 -7.663734115347017872e-02 1.333311513767116274e+01 -7.683284457478005425e-02 1.319334693813950743e+01 -7.702834799608992977e-02 1.305461501985217154e+01 -7.722385141739980530e-02 1.291691872765357196e+01 -7.741935483870968082e-02 1.278025726694963993e+01 -7.761485826001955635e-02 1.264462970623662841e+01 -7.781036168132941799e-02 1.251003497961402111e+01 -7.800586510263929352e-02 1.237647188928100839e+01 -7.820136852394916904e-02 1.224393910801644125e+01 -7.839687194525904457e-02 1.211243518164171817e+01 -7.859237536656892009e-02 1.198195853146639500e+01 -7.878787878787878174e-02 1.185250745671627293e+01 -7.898338220918865726e-02 1.172408013694362339e+01 -7.917888563049853279e-02 1.159667463441938651e+01 -7.937438905180840831e-02 1.147028889650679950e+01 -7.956989247311828384e-02 1.134492075801668243e+01 -7.976539589442815936e-02 1.122056794354366538e+01 -7.996089931573802101e-02 1.109722806978344600e+01 -8.015640273704789653e-02 1.097489864783071667e+01 -8.035190615835777206e-02 1.085357708545762989e+01 -8.054740957966764758e-02 1.073326068937257993e+01 -8.074291300097752311e-02 1.061394666745905724e+01 -8.093841642228738475e-02 1.049563213099452419e+01 -8.113391984359726028e-02 1.037831409684903505e+01 -8.132942326490713580e-02 1.026198948966349711e+01 -8.152492668621701133e-02 1.014665514400743263e+01 -8.172043010752688685e-02 1.003230780651602849e+01 -8.191593352883674850e-02 9.918944138006500211e+00 -8.211143695014662403e-02 9.806560715573395370e+00 -8.230694037145649955e-02 9.695154034663024945e+00 -8.250244379276637507e-02 9.584720511126739950e+00 -8.269794721407625060e-02 9.475256483252874062e+00 -8.289345063538611225e-02 9.366758213777565345e+00 -8.308895405669598777e-02 9.259221891873977484e+00 -8.328445747800586330e-02 9.152643635120277565e+00 -8.347996089931573882e-02 9.047019491445924544e+00 -8.367546432062561435e-02 8.942345441056462008e+00 -8.387096774193548987e-02 8.838617398336589659e+00 -8.406647116324535152e-02 8.735831213731733769e+00 -8.426197458455522704e-02 8.633982675607681401e+00 -8.445747800586510257e-02 8.533067512088695850e+00 -8.465298142717497809e-02 8.433081392873674531e+00 -8.484848484848485362e-02 8.334019931030674400e+00 -8.504398826979471526e-02 8.235878684769618374e+00 -8.523949169110459079e-02 8.138653159193102837e+00 -8.543499511241446631e-02 8.042338808025636609e+00 -8.563049853372434184e-02 7.946931035320893066e+00 -8.582600195503421736e-02 7.852425197147340441e+00 -8.602150537634409289e-02 7.758816603252043365e+00 -8.621700879765395453e-02 7.666100518702847921e+00 -8.641251221896383006e-02 7.574272165508776133e+00 -8.660801564027370558e-02 7.483326724218894554e+00 -8.680351906158358111e-02 7.393259335499468676e+00 -8.699902248289345663e-02 7.304065101689674933e+00 -8.719452590420331828e-02 7.215739088335749507e+00 -8.739002932551319380e-02 7.128276325703683192e+00 -8.758553274682306933e-02 7.041671810270611509e+00 -8.778103616813294485e-02 6.955920506194835262e+00 -8.797653958944282038e-02 6.871017346764594080e+00 -8.817204301075268202e-02 6.786957235825734180e+00 -8.836754643206255755e-02 6.703735049188224160e+00 -8.856304985337243307e-02 6.621345636011754188e+00 -8.875855327468230860e-02 6.539783820170319117e+00 -8.895405669599218412e-02 6.459044401596092833e+00 -8.914956011730204577e-02 6.379122157602489906e+00 -8.934506353861192129e-02 6.300011844186658827e+00 -8.954056695992179682e-02 6.221708197311436095e+00 -8.973607038123167234e-02 6.144205934166875771e+00 -8.993157380254154787e-02 6.067499754411500135e+00 -9.012707722385142339e-02 5.991584341393344282e+00 -9.032258064516128504e-02 5.916454363350923451e+00 -9.051808406647116056e-02 5.842104474594229657e+00 -9.071358748778103609e-02 5.768529316665930828e+00 -9.090909090909091161e-02 5.695723519482839947e+00 -9.110459433040078714e-02 5.623681702457791864e+00 -9.130009775171064879e-02 5.552398475602076111e+00 -9.149560117302052431e-02 5.481868440608546500e+00 -9.169110459433039984e-02 5.412086191915566502e+00 -9.188660801564027536e-02 5.343046317751885432e+00 -9.208211143695015088e-02 5.274743401162584888e+00 -9.227761485826002641e-02 5.207172021016321928e+00 -9.247311827956988806e-02 5.140326752993882309e+00 -9.266862170087976358e-02 5.074202170558264946e+00 -9.286412512218963911e-02 5.008792845906514302e+00 -9.305962854349951463e-02 4.944093350903248307e+00 -9.325513196480939015e-02 4.880098257996256628e+00 -9.345063538611925180e-02 4.816802141114155056e+00 -9.364613880742912733e-02 4.754199576546335848e+00 -9.384164222873900285e-02 4.692285143805386305e+00 -9.403714565004887838e-02 4.631053426472028889e+00 -9.423264907135875390e-02 4.570499013022836898e+00 -9.442815249266861555e-02 4.510616497640891787e+00 -9.462365591397849107e-02 4.451400481009407883e+00 -9.481915933528836660e-02 4.392845571088706436e+00 -9.501466275659824212e-02 4.334946383876482123e+00 -9.521016617790811765e-02 4.277697544151645381e+00 -9.540566959921797929e-02 4.221093686201923489e+00 -9.560117302052785482e-02 4.165129454535255960e+00 -9.579667644183773034e-02 4.109799504575341267e+00 -9.599217986314760587e-02 4.055098503341310057e+00 -9.618768328445748139e-02 4.001021130111824142e+00 -9.638318670576735692e-02 3.947562077073693221e+00 -9.657869012707721856e-02 3.894716049955239789e+00 -9.677419354838709409e-02 3.842477768644502412e+00 -9.696969696969696961e-02 3.790841967792540679e+00 -9.716520039100684514e-02 3.739803397401917362e+00 -9.736070381231672066e-02 3.689356823400596230e+00 -9.755620723362658231e-02 3.639497028201398088e+00 -9.775171065493645783e-02 3.590218811247141595e+00 -9.794721407624633336e-02 3.541516989541766414e+00 -9.814271749755620888e-02 3.493386398167431128e+00 -9.833822091886608441e-02 3.445821890787916786e+00 -9.853372434017595993e-02 3.398818340138383576e+00 -9.872922776148582158e-02 3.352370638501760425e+00 -9.892473118279569710e-02 3.306473698171813247e+00 -9.912023460410557263e-02 3.261122451903188502e+00 -9.931573802541544815e-02 3.216311853348494232e+00 -9.951124144672532368e-02 3.172036877482646844e+00 -9.970674486803518533e-02 3.128292521014643057e+00 -9.990224828934506085e-02 3.085073802786900021e+00 -1.000977517106549364e-01 3.042375764162369212e+00 -1.002932551319648119e-01 3.000193469399554225e+00 -1.004887585532746874e-01 2.958522006015620764e+00 -1.006842619745845491e-01 2.917356485137755140e+00 -1.008797653958944246e-01 2.876692041842934700e+00 -1.010752688172043001e-01 2.836523835486298495e+00 -1.012707722385141756e-01 2.796847050018246073e+00 -1.014662756598240512e-01 2.757656894290426930e+00 -1.016617790811339128e-01 2.718948602350852006e+00 -1.018572825024437883e-01 2.680717433728188048e+00 -1.020527859237536639e-01 2.642958673705464001e+00 -1.022482893450635394e-01 2.605667633583337750e+00 -1.024437927663734149e-01 2.568839650933058660e+00 -1.026392961876832904e-01 2.532470089839316874e+00 -1.028347996089931521e-01 2.496554341133116139e+00 -1.030303030303030276e-01 2.461087822614806964e+00 -1.032258064516129031e-01 2.426065979267526540e+00 -1.034213098729227787e-01 2.391484283461059679e+00 -1.036168132942326542e-01 2.357338235146391181e+00 -1.038123167155425158e-01 2.323623362041062013e+00 -1.040078201368523914e-01 2.290335219805450961e+00 -1.042033235581622669e-01 2.257469392210205594e+00 -1.043988269794721424e-01 2.225021491294880249e+00 -1.045943304007820179e-01 2.192987157518020869e+00 -1.047898338220918935e-01 2.161362059898777499e+00 -1.049853372434017551e-01 2.130141896150217651e+00 -1.051808406647116306e-01 2.099322392804478632e+00 -1.053763440860215062e-01 2.068899305329934268e+00 -1.055718475073313817e-01 2.038868418240456393e+00 -1.057673509286412572e-01 2.009225545196978047e+00 -1.059628543499511188e-01 1.979966529101444550e+00 -1.061583577712609944e-01 1.951087242183343173e+00 -1.063538611925708699e-01 1.922583586078911999e+00 -1.065493646138807454e-01 1.894451491903178741e+00 -1.067448680351906209e-01 1.866686920314959197e+00 -1.069403714565004826e-01 1.839285861574970760e+00 -1.071358748778103581e-01 1.812244335597150924e+00 -1.073313782991202336e-01 1.785558391993384397e+00 -1.075268817204301092e-01 1.759224110111676564e+00 -1.077223851417399847e-01 1.733237599067992907e+00 -1.079178885630498463e-01 1.707594997771835654e+00 -1.081133919843597219e-01 1.682292474945689786e+00 -1.083088954056695974e-01 1.657326229138509799e+00 -1.085043988269794729e-01 1.632692488733305192e+00 -1.086999022482893484e-01 1.608387511948998316e+00 -1.088954056695992240e-01 1.584407586836649839e+00 -1.090909090909090856e-01 1.560749031270200149e+00 -1.092864125122189611e-01 1.537408192931800643e+00 -1.094819159335288367e-01 1.514381449291906767e+00 -1.096774193548387122e-01 1.491665207584200070e+00 -1.098729227761485877e-01 1.469255904775496724e+00 -1.100684261974584494e-01 1.447150007530724425e+00 -1.102639296187683249e-01 1.425344012173096031e+00 -1.104594330400782004e-01 1.403834444639593393e+00 -1.106549364613880759e-01 1.382617860431862633e+00 -1.108504398826979515e-01 1.361690844562635672e+00 -1.110459433040078270e-01 1.341050011497783245e+00 -1.112414467253176886e-01 1.320692005094101340e+00 -1.114369501466275642e-01 1.300613498532947165e+00 -1.116324535679374397e-01 1.280811194249825702e+00 -1.118279569892473152e-01 1.261281823860002316e+00 -1.120234604105571907e-01 1.242022148080300870e+00 -1.122189638318670524e-01 1.223028956647116194e+00 -1.124144672531769279e-01 1.204299068230791692e+00 -1.126099706744868034e-01 1.185829330346443111e+00 -1.128054740957966789e-01 1.167616619261316435e+00 -1.130009775171065545e-01 1.149657839898776457e+00 -1.131964809384164161e-01 1.131949925739036633e+00 -1.133919843597262916e-01 1.114489838716685943e+00 -1.135874877810361672e-01 1.097274569115156861e+00 -1.137829912023460427e-01 1.080301135458164419e+00 -1.139784946236559182e-01 1.063566584398246473e+00 -1.141739980449657799e-01 1.047067990602473131e+00 -1.143695014662756554e-01 1.030802456635415698e+00 -1.145650048875855309e-01 1.014767112839467966e+00 -1.147605083088954064e-01 9.989591172125769081e-01 -1.149560117302052820e-01 9.833756552835004605e-01 -1.151515151515151575e-01 9.680139399846400261e-01 -1.153470185728250191e-01 9.528712115225488333e-01 -1.155425219941348947e-01 9.379447372461793275e-01 -1.157380254154447702e-01 9.232318115129642955e-01 -1.159335288367546457e-01 9.087297555527880100e-01 -1.161290322580645212e-01 8.944359173299312182e-01 -1.163245356793743829e-01 8.803476714030625816e-01 -1.165200391006842584e-01 8.664624187833557256e-01 -1.167155425219941339e-01 8.527775867907835261e-01 -1.169110459433040095e-01 8.392906289086816685e-01 -1.171065493646138850e-01 8.259990246366327726e-01 -1.173020527859237605e-01 8.129002793417500206e-01 -1.174975562072336221e-01 7.999919241084197941e-01 -1.176930596285434977e-01 7.872715155865674941e-01 -1.178885630498533732e-01 7.747366358385239238e-01 -1.180840664711632487e-01 7.623848921845344240e-01 -1.182795698924731242e-01 7.502139170469912521e-01 -1.184750733137829859e-01 7.382213677934317264e-01 -1.186705767350928614e-01 7.264049265783824039e-01 -1.188660801564027369e-01 7.147623001840945900e-01 -1.190615835777126125e-01 7.032912198602288001e-01 -1.192570869990224880e-01 6.919894411625446828e-01 -1.194525904203323496e-01 6.808547437906670163e-01 -1.196480938416422252e-01 6.698849314249529785e-01 -1.198435972629521007e-01 6.590778315625441808e-01 -1.200391006842619762e-01 6.484312953526343293e-01 -1.202346041055718517e-01 6.379431974310169062e-01 -1.204301075268817134e-01 6.276114357539529509e-01 -1.206256109481915889e-01 6.174339314314126748e-01 -1.208211143695014644e-01 6.074086285597568580e-01 -1.210166177908113400e-01 5.975334940538580275e-01 -1.212121212121212155e-01 5.878065174787705516e-01 -1.214076246334310910e-01 5.782257108809377710e-01 -1.216031280547409527e-01 5.687891086190187684e-01 -1.217986314760508282e-01 5.594947671943676371e-01 -1.219941348973607037e-01 5.503407650812007779e-01 -1.221896383186705792e-01 5.413252025564911918e-01 -1.223851417399804548e-01 5.324462015296653750e-01 -1.225806451612903164e-01 5.237019053720798345e-01 -1.227761485826001919e-01 5.150904787463852497e-01 -1.229716520039100675e-01 5.066101074357630685e-01 -1.231671554252199430e-01 4.982589981731085360e-01 -1.233626588465298185e-01 4.900353784701653725e-01 -1.235581622678396940e-01 4.819374964466802691e-01 -1.237536656891495557e-01 4.739636206595826962e-01 -1.239491691104594312e-01 4.661120399322432606e-01 -1.241446725317693067e-01 4.583810631838420302e-01 -1.243401759530791822e-01 4.507690192588642009e-01 -1.245356793743890578e-01 4.432742567567756753e-01 -1.247311827956989194e-01 4.358951438619010355e-01 -1.249266862170087949e-01 4.286300681735232820e-01 -1.251221896383186705e-01 4.214774365362500275e-01 -1.253176930596285321e-01 4.144356748706805593e-01 -1.255131964809384215e-01 4.075032280043647259e-01 -1.257086999022482832e-01 4.006785595031389091e-01 -1.259042033235581726e-01 3.939601515028027801e-01 -1.260997067448680342e-01 3.873465045412234908e-01 -1.262952101661778959e-01 3.808361373908371039e-01 -1.264907135874877853e-01 3.744275868916140393e-01 -1.266862170087976469e-01 3.681194077844927581e-01 -1.268817204301075363e-01 3.619101725452992246e-01 -1.270772238514173980e-01 3.557984712191998855e-01 -1.272727272727272596e-01 3.497829112556767317e-01 -1.274682306940371490e-01 3.438621173440732370e-01 -1.276637341153470107e-01 3.380347312497232193e-01 -1.278592375366569001e-01 3.322994116506685636e-01 -1.280547409579667617e-01 3.266548339750139363e-01 -1.282502443792766234e-01 3.210996902389063878e-01 -1.284457478005865128e-01 3.156326888851810342e-01 -1.286412512218963744e-01 3.102525546226847508e-01 -1.288367546432062638e-01 3.049580282662794350e-01 -1.290322580645161255e-01 2.997478665775723528e-01 -1.292277614858260149e-01 2.946208421063565841e-01 -1.294232649071358765e-01 2.895757430328013693e-01 -1.296187683284457381e-01 2.846113730103944639e-01 -1.298142717497556275e-01 2.797265510096532681e-01 -1.300097751710654892e-01 2.749201111626280447e-01 -1.302052785923753786e-01 2.701909026081895648e-01 -1.304007820136852402e-01 2.655377893381418719e-01 -1.305962854349951019e-01 2.609596500441453415e-01 -1.307917888563049913e-01 2.564553779654831223e-01 -1.309872922776148529e-01 2.520238807376723456e-01 -1.311827956989247423e-01 2.476640802419270426e-01 -1.313782991202346040e-01 2.433749124554996923e-01 -1.315738025415444656e-01 2.391553273028910465e-01 -1.317693059628543550e-01 2.350042885079526300e-01 -1.319648093841642167e-01 2.309207734468894380e-01 -1.321603128054741061e-01 2.269037730021601640e-01 -1.323558162267839677e-01 2.229522914173018011e-01 -1.325513196480938294e-01 2.190653461526697043e-01 -1.327468230694037188e-01 2.152419677421109345e-01 -1.329423264907135804e-01 2.114811996505761571e-01 -1.331378299120234698e-01 2.077820981326721494e-01 -1.333333333333333315e-01 2.041437320921716814e-01 -1.335288367546431931e-01 2.005651829424716093e-01 -1.337243401759530825e-01 1.970455444680226098e-01 -1.339198435972629442e-01 1.935839226867233920e-01 -1.341153470185728336e-01 1.901794357132849944e-01 -1.343108504398826952e-01 1.868312136235813770e-01 -1.345063538611925846e-01 1.835383983199737057e-01 -1.347018572825024463e-01 1.803001433976281764e-01 -1.348973607038123079e-01 1.771156140118192723e-01 -1.350928641251221973e-01 1.739839867462306122e-01 -1.352883675464320590e-01 1.709044494822521132e-01 -1.354838709677419484e-01 1.678762012692736061e-01 -1.356793743890518100e-01 1.648984521959869776e-01 -1.358748778103616717e-01 1.619704232626874019e-01 -1.360703812316715611e-01 1.590913462545835155e-01 -1.362658846529814227e-01 1.562604636161186722e-01 -1.364613880742913121e-01 1.534770283262973933e-01 -1.366568914956011738e-01 1.507403037750268959e-01 -1.368523949169110354e-01 1.480495636404683124e-01 -1.370478983382209248e-01 1.454040917674020994e-01 -1.372434017595307865e-01 1.428031820466075796e-01 -1.374389051808406759e-01 1.402461382952517044e-01 -1.376344086021505375e-01 1.377322741382996651e-01 -1.378299120234603992e-01 1.352609128909274538e-01 -1.380254154447702886e-01 1.328313874419580209e-01 -1.382209188660801502e-01 1.304430401383052662e-01 -1.384164222873900396e-01 1.280952226704256403e-01 -1.386119257086999013e-01 1.257872959587881811e-01 -1.388074291300097629e-01 1.235186300413452232e-01 -1.390029325513196523e-01 1.212886039620165168e-01 -1.391984359726295140e-01 1.190966056601777817e-01 -1.393939393939394034e-01 1.169420318611510967e-01 -1.395894428152492650e-01 1.148242879677000977e-01 -1.397849462365591267e-01 1.127427879525234877e-01 -1.399804496578690161e-01 1.106969542517469290e-01 -1.401759530791788777e-01 1.086862176594099727e-01 -1.403714565004887671e-01 1.067100172229434596e-01 -1.405669599217986288e-01 1.047678001396404740e-01 -1.407624633431084904e-01 1.028590216541073049e-01 -1.409579667644183798e-01 1.009831449567056699e-01 -1.411534701857282414e-01 9.913964108296956235e-02 -1.413489736070381309e-01 9.732798881399952473e-02 -1.415444770283479925e-01 9.554767457783294726e-02 -1.417399804496578819e-01 9.379819235177931647e-02 -1.419354838709677435e-01 9.207904356572682580e-02 -1.421309872922776052e-01 9.038973700640536013e-02 -1.423264907135874946e-01 8.872978872261062799e-02 -1.425219941348973562e-01 8.709872193138151752e-02 -1.427174975562072456e-01 8.549606692512545791e-02 -1.429130009775171073e-01 8.392136097969073172e-02 -1.431085043988269689e-01 8.237414826337739748e-02 -1.433040078201368583e-01 8.085397974688557365e-02 -1.434995112414467200e-01 7.936041311419621269e-02 -1.436950146627566094e-01 7.789301267437388765e-02 -1.438905180840664710e-01 7.645134927429869665e-02 -1.440860215053763327e-01 7.503500021230768979e-02 -1.442815249266862221e-01 7.364354915275329871e-02 -1.444770283479960837e-01 7.227658604146648680e-02 -1.446725317693059731e-01 7.093370702212153933e-02 -1.448680351906158348e-01 6.961451435349877426e-02 -1.450635386119256964e-01 6.831861632763613912e-02 -1.452590420332355858e-01 6.704562718886886152e-02 -1.454545454545454475e-01 6.579516705374868768e-02 -1.456500488758553369e-01 6.456686183183717176e-02 -1.458455522971651985e-01 6.336034314737028217e-02 -1.460410557184750602e-01 6.217524826178477682e-02 -1.462365591397849496e-01 6.101121999710452937e-02 -1.464320625610948112e-01 5.986790666017870882e-02 -1.466275659824047006e-01 5.874496196776503310e-02 -1.468230694037145623e-01 5.764204497245818681e-02 -1.470185728250244517e-01 5.655881998944872063e-02 -1.472140762463343133e-01 5.549495652411465252e-02 -1.474095796676441750e-01 5.445012920043430099e-02 -1.476050830889540644e-01 5.342401769021817848e-02 -1.478005865102639260e-01 5.241630664315179849e-02 -1.479960899315738154e-01 5.142668561764346391e-02 -1.481915933528836771e-01 5.045484901247284520e-02 -1.483870967741935387e-01 4.950049599923167509e-02 -1.485826001955034281e-01 4.856333045555266681e-02 -1.487781036168132898e-01 4.764306089912031389e-02 -1.489736070381231792e-01 4.673940042245491172e-02 -1.491691104594330408e-01 4.585206662846797593e-02 -1.493646138807429025e-01 4.498078156677927375e-02 -1.495601173020527919e-01 4.412527167079027118e-02 -1.497556207233626535e-01 4.328526769551025583e-02 -1.499511241446725429e-01 4.246050465612425523e-02 -1.501466275659824046e-01 4.165072176730149484e-02 -1.503421309872922662e-01 4.085566238323422306e-02 -1.505376344086021556e-01 4.007507393840321203e-02 -1.507331378299120173e-01 3.930870788906364044e-02 -1.509286412512219067e-01 3.855631965544249057e-02 -1.511241446725317683e-01 3.781766856464556514e-02 -1.513196480938416300e-01 3.709251779426335494e-02 -1.515151515151515194e-01 3.638063431667360598e-02 -1.517106549364613810e-01 3.568178884403177403e-02 -1.519061583577712704e-01 3.499575577394325315e-02 -1.521016617790811321e-01 3.432231313581370069e-02 -1.522971652003909937e-01 3.366124253786770271e-02 -1.524926686217008831e-01 3.301232911483210214e-02 -1.526881720430107447e-01 3.237536147627801536e-02 -1.528836754643206342e-01 3.175013165561281492e-02 -1.530791788856304958e-01 3.113643505971901496e-02 -1.532746823069403574e-01 3.053407041923193385e-02 -1.534701857282502468e-01 2.994283973945079461e-02 -1.536656891495601085e-01 2.936254825187733022e-02 -1.538611925708699979e-01 2.879300436637504193e-02 -1.540566959921798595e-01 2.823401962394421830e-02 -1.542521994134897489e-01 2.768540865010537047e-02 -1.544477028347996106e-01 2.714698910888630259e-02 -1.546432062561094722e-01 2.661858165740593057e-02 -1.548387096774193616e-01 2.610000990104919746e-02 -1.550342130987292233e-01 2.559110034922782925e-02 -1.552297165200391127e-01 2.509168237171895827e-02 -1.554252199413489743e-01 2.460158815557902945e-02 -1.556207233626588360e-01 2.412065266262285526e-02 -1.558162267839687254e-01 2.364871358746660837e-02 -1.560117302052785870e-01 2.318561131612539850e-02 -1.562072336265884764e-01 2.273118888516046515e-02 -1.564027370478983381e-01 2.228529194137207625e-02 -1.565982404692081997e-01 2.184776870202951443e-02 -1.567937438905180891e-01 2.141846991563458799e-02 -1.569892473118279508e-01 2.099724882321257410e-02 -1.571847507331378402e-01 2.058396112012361376e-02 -1.573802541544477018e-01 2.017846491839129022e-02 -1.575757575757575635e-01 1.978062070954027946e-02 -1.577712609970674529e-01 1.939029132793965507e-02 -1.579667644183773145e-01 1.900734191464503731e-02 -1.581622678396872039e-01 1.863163988173431942e-02 -1.583577712609970656e-01 1.826305487713219752e-02 -1.585532746823069272e-01 1.790145874991674879e-02 -1.587487781036168166e-01 1.754672551610444303e-02 -1.589442815249266783e-01 1.719873132490664855e-02 -1.591397849462365677e-01 1.685735442545298335e-02 -1.593352883675464293e-01 1.652247513397651218e-02 -1.595307917888563187e-01 1.619397580145483240e-02 -1.597262952101661804e-01 1.587174078170267705e-02 -1.599217986314760420e-01 1.555565639990995862e-02 -1.601173020527859314e-01 1.524561092162090778e-02 -1.603128054740957931e-01 1.494149452214881511e-02 -1.605083088954056825e-01 1.464319925642112476e-02 -1.607038123167155441e-01 1.435061902925066635e-02 -1.608993157380254058e-01 1.406364956602670566e-02 -1.610948191593352952e-01 1.378218838382224733e-02 -1.612903225806451568e-01 1.350613476291196921e-02 -1.614858260019550462e-01 1.323538971869554597e-02 -1.616813294232649079e-01 1.296985597402280400e-02 -1.618768328445747695e-01 1.270943793191414359e-02 -1.620723362658846589e-01 1.245404164867321660e-02 -1.622678396871945206e-01 1.220357480738592897e-02 -1.624633431085044100e-01 1.195794669180142052e-02 -1.626588465298142716e-01 1.171706816059092660e-02 -1.628543499511241333e-01 1.148085162197879337e-02 -1.630498533724340227e-01 1.124921100874213403e-02 -1.632453567937438843e-01 1.102206175357436577e-02 -1.634408602150537737e-01 1.079932076480732278e-02 -1.636363636363636354e-01 1.058090640248883149e-02 -1.638318670576734970e-01 1.036673845481013434e-02 -1.640273704789833864e-01 1.015673811487957830e-02 -1.642228739002932481e-01 9.950827957838026538e-03 -1.644183773216031375e-01 9.748931918311113526e-03 -1.646138807429129991e-01 9.550975268195390985e-03 -1.648093841642228607e-01 9.356884594772711325e-03 -1.650048875855327501e-01 9.166587779149550780e-03 -1.652003910068426118e-01 8.980013975017112418e-03 -1.653958944281525012e-01 8.797093587727457600e-03 -1.655913978494623628e-01 8.617758253682532982e-03 -1.657869012707722245e-01 8.441940820031234097e-03 -1.659824046920821139e-01 8.269575324671006589e-03 -1.661779081133919755e-01 8.100596976550092365e-03 -1.663734115347018649e-01 7.934942136265929480e-03 -1.665689149560117266e-01 7.772548296956710741e-03 -1.667644183773216160e-01 7.613354065481395608e-03 -1.669599217986314776e-01 7.457299143885143949e-03 -1.671554252199413393e-01 7.304324311145792351e-03 -1.673509286412512287e-01 7.154371405198061383e-03 -1.675464320625610903e-01 7.007383305231817093e-03 -1.677419354838709797e-01 6.863303914260277146e-03 -1.679374389051808414e-01 6.722078141955307139e-03 -1.681329423264907030e-01 6.583651887745492828e-03 -1.683284457478005924e-01 6.447972024173996737e-03 -1.685239491691104541e-01 6.314986380512526733e-03 -1.687194525904203435e-01 6.184643726627766722e-03 -1.689149560117302051e-01 6.056893757097274456e-03 -1.691104594330400668e-01 5.931687075571018784e-03 -1.693059628543499562e-01 5.808975179375569162e-03 -1.695014662756598178e-01 5.688710444357396832e-03 -1.696969696969697072e-01 5.570846109962083667e-03 -1.698924731182795689e-01 5.455336264546284918e-03 -1.700879765395894305e-01 5.342135830919106550e-03 -1.702834799608993199e-01 5.231200552109765110e-03 -1.704789833822091816e-01 5.122486977358613192e-03 -1.706744868035190710e-01 5.015952448327954359e-03 -1.708699902248289326e-01 4.911555085530186840e-03 -1.710654936461387943e-01 4.809253774969685091e-03 -1.712609970674486837e-01 4.709008154995847524e-03 -1.714565004887585453e-01 4.610778603364166194e-03 -1.716520039100684347e-01 4.514526224502287896e-03 -1.718475073313782964e-01 4.420212836978511424e-03 -1.720430107526881858e-01 4.327800961169429340e-03 -1.722385141739980474e-01 4.237253807124323826e-03 -1.724340175953079091e-01 4.148535262623115165e-03 -1.726295210166177985e-01 4.061609881425430786e-03 -1.728250244379276601e-01 3.976442871707927366e-03 -1.730205278592375495e-01 3.893000084687112550e-03 -1.732160312805474112e-01 3.811248003425108440e-03 -1.734115347018572728e-01 3.731153731815726581e-03 -1.736070381231671622e-01 3.652684983748146104e-03 -1.738025415444770239e-01 3.575810072445771617e-03 -1.739980449657869133e-01 3.500497899977572051e-03 -1.741935483870967749e-01 3.426717946939563785e-03 -1.743890518084066366e-01 3.354440262303816887e-03 -1.745845552297165260e-01 3.283635453432621771e-03 -1.747800586510263876e-01 3.214274676255414551e-03 -1.749755620723362770e-01 3.146329625605951818e-03 -1.751710654936461387e-01 3.079772525717568588e-03 -1.753665689149560003e-01 3.014576120873958560e-03 -1.755620723362658897e-01 2.950713666213457004e-03 -1.757575757575757514e-01 2.888158918684297517e-03 -1.759530791788856408e-01 2.826886128148732320e-03 -1.761485826001955024e-01 2.766870028633814337e-03 -1.763440860215053640e-01 2.708085829726579810e-03 -1.765395894428152535e-01 2.650509208111554143e-03 -1.767350928641251151e-01 2.594116299248401709e-03 -1.769305962854350045e-01 2.538883689187585498e-03 -1.771260997067448661e-01 2.484788406522110606e-03 -1.773216031280547278e-01 2.431807914473069557e-03 -1.775171065493646172e-01 2.379920103107175354e-03 -1.777126099706744788e-01 2.329103281684224026e-03 -1.779081133919843682e-01 2.279336171132396310e-03 -1.781036168132942299e-01 2.230597896649684150e-03 -1.782991202346040915e-01 2.182867980429290932e-03 -1.784946236559139809e-01 2.136126334507266415e-03 -1.786901270772238426e-01 2.090353253730478124e-03 -1.788856304985337320e-01 2.045529408842990202e-03 -1.790811339198435936e-01 2.001635839689137539e-03 -1.792766373411534830e-01 1.958653948531468517e-03 -1.794721407624633447e-01 1.916565493481768101e-03 -1.796676441837732063e-01 1.875352582043366247e-03 -1.798631476050830957e-01 1.834997664763146326e-03 -1.800586510263929574e-01 1.795483528991424077e-03 -1.802541544477028468e-01 1.756793292748048876e-03 -1.804496578690127084e-01 1.718910398693143313e-03 -1.806451612903225701e-01 1.681818608200728350e-03 -1.808406647116324595e-01 1.645501995533730057e-03 -1.810361681329423211e-01 1.609944942118763300e-03 -1.812316715542522105e-01 1.575132130919016868e-03 -1.814271749755620722e-01 1.541048540903900387e-03 -1.816226783968719338e-01 1.507679441613686859e-03 -1.818181818181818232e-01 1.475010387817881881e-03 -1.820136852394916849e-01 1.443027214265683042e-03 -1.822091886608015743e-01 1.411716030527069513e-03 -1.824046920821114359e-01 1.381063215923258956e-03 -1.826001955034212976e-01 1.351055414544837571e-03 -1.827956989247311870e-01 1.321679530356402324e-03 -1.829912023460410486e-01 1.292922722386218070e-03 -1.831867057673509380e-01 1.264772399999534091e-03 -1.833822091886607997e-01 1.237216218254269876e-03 -1.835777126099706613e-01 1.210242073337685796e-03 -1.837732160312805507e-01 1.183838098082783639e-03 -1.839687194525904124e-01 1.157992657563146344e-03 -1.841642228739003018e-01 1.132694344764899634e-03 -1.843597262952101634e-01 1.107931976334637202e-03 -1.845552297165200528e-01 1.083694588401984318e-03 -1.847507331378299145e-01 1.059971432475675544e-03 -1.849462365591397761e-01 1.036751971411873936e-03 -1.851417399804496655e-01 1.014025875453598716e-03 -1.853372434017595272e-01 9.917830183401312675e-04 -1.855327468230694166e-01 9.700134734851567197e-04 -1.857282502443792782e-01 9.487075102226249146e-04 -1.859237536656891399e-01 9.278555901191413774e-04 -1.861192570869990293e-01 9.074483633518498453e-04 -1.863147605083088909e-01 8.874766651506939621e-04 -1.865102639296187803e-01 8.679315123039972471e-04 -1.867057673509286420e-01 8.488040997263550901e-04 -1.869012707722385036e-01 8.300857970877438367e-04 -1.870967741935483930e-01 8.117681455028926503e-04 -1.872922776148582547e-01 7.938428542798971546e-04 -1.874877810361681441e-01 7.763017977270558192e-04 -1.876832844574780057e-01 7.591370120170336418e-04 -1.878787878787878673e-01 7.423406921073179331e-04 -1.880742913000977568e-01 7.259051887160668584e-04 -1.882697947214076184e-01 7.098230053524574607e-04 -1.884652981427175078e-01 6.940867954005146669e-04 -1.886608015640273694e-01 6.786893592556551792e-04 -1.888563049853372311e-01 6.636236415129450998e-04 -1.890518084066471205e-01 6.488827282062806885e-04 -1.892473118279569821e-01 6.344598440975921481e-04 -1.894428152492668715e-01 6.203483500152284476e-04 -1.896383186705767332e-01 6.065417402407168599e-04 -1.898338220918865948e-01 5.930336399430356006e-04 -1.900293255131964842e-01 5.798178026596308675e-04 -1.902248289345063459e-01 5.668881078233792238e-04 -1.904203323558162353e-01 5.542385583346667779e-04 -1.906158357771260969e-01 5.418632781778979926e-04 -1.908113391984359586e-01 5.297565100815863860e-04 -1.910068426197458480e-01 5.179126132213483042e-04 -1.912023460410557096e-01 5.063260609650500422e-04 -1.913978494623655990e-01 4.949914386593399357e-04 -1.915933528836754607e-01 4.839034414569274288e-04 -1.917888563049853501e-01 4.730568721838397639e-04 -1.919843597262952117e-01 4.624466392460265928e-04 -1.921798631476050734e-01 4.520677545745811028e-04 -1.923753665689149628e-01 4.419153316089413424e-04 -1.925708699902248244e-01 4.319845833174149356e-04 -1.927663734115347138e-01 4.222708202543521056e-04 -1.929618768328445755e-01 4.127694486533773667e-04 -1.931573802541544371e-01 4.034759685559907087e-04 -1.933528836754643265e-01 3.943859719749899409e-04 -1.935483870967741882e-01 3.854951410920550532e-04 -1.937438905180840776e-01 3.767992464889166615e-04 -1.939393939393939392e-01 3.682941454115319039e-04 -1.941348973607038009e-01 3.599757800666717475e-04 -1.943304007820136903e-01 3.518401759503532651e-04 -1.945259042033235519e-01 3.438834402075767850e-04 -1.947214076246334413e-01 3.361017600227882477e-04 -1.949169110459433030e-01 3.284914010405503063e-04 -1.951124144672531646e-01 3.210487058158699902e-04 -1.953079178885630540e-01 3.137700922936780164e-04 -1.955034213098729157e-01 3.066520523169303874e-04 -1.956989247311828051e-01 2.996911501628208045e-04 -1.958944281524926667e-01 2.928840211066288516e-04 -1.960899315738025284e-01 2.862273700126825578e-04 -1.962854349951124178e-01 2.797179699519773710e-04 -1.964809384164222794e-01 2.733526608459677185e-04 -1.966764418377321688e-01 2.671283481360512855e-04 -1.968719452590420305e-01 2.610420014783179144e-04 -1.970674486803519199e-01 2.550906534630776202e-04 -1.972629521016617815e-01 2.492713983587504113e-04 -1.974584555229716432e-01 2.435813908796608440e-04 -1.976539589442815326e-01 2.380178449773213023e-04 -1.978494623655913942e-01 2.325780326547776397e-04 -1.980449657869012836e-01 2.272592828036012569e-04 -1.982404692082111453e-01 2.220589800631173256e-04 -1.984359726295210069e-01 2.169745637014720971e-04 -1.986314760508308963e-01 2.120035265181391426e-04 -1.988269794721407580e-01 2.071434137674879291e-04 -1.990224828934506474e-01 2.023918221030098885e-04 -1.992179863147605090e-01 1.977463985418592641e-04 -1.994134897360703707e-01 1.932048394493057373e-04 -1.996089931573802601e-01 1.887648895427628383e-04 -1.998044965786901217e-01 1.844243409150234060e-04 -2.000000000000000111e-01 1.801810320763509764e-04 diff --git a/output/log.txt b/output/log.txt deleted file mode 100644 index c0d9daf..0000000 --- a/output/log.txt +++ /dev/null @@ -1,113 +0,0 @@ -MPI task 0, OMP thread count starts at 0 - MPIThreadsOK = 1 - -|-------------------------------------------------| -| CoLoRe | -|-------------------------------------------------| - -The cosmological model is: - O_M=0.300 O_L=0.700 O_K=0.000 - O_B=0.300 w=-1.000 h=0.700 - Flat universe, standard cosmological constant - - Time of equality: a_eq=0.75416 - Particle horizon: chi_H(0)=9.908E+03 Mpc/h - Present growth factor: D_0=0.779 - -Reading P_k from file: output/pk.txt - Original sigma8=0.799990 - Sigma_Gauss should be 0.875326 -Node 0 will allocate 0.597 GB [0.190 GB (Gaussian), 0.302 GB (1LPT), 0.102 GB (srcs), 0.002 GB (imap), 0.375 MB (kappa), 0.375 MB (isw), 0.375 MB (custom)] - -Run parameters: - 0.000 < z < 0.150 - 0.300 < r/(Mpc/h) < 434.105 - L_box = 874.993 Mpc/h, N_grid = 256 - Scales resolved: 7.181E-03 < k < 9.156E-01 h/Mpc - Fourier-space resolution: dk = 7.181E-03 h/Mpc - Real-space resolution: dx = 3.418E+00 Mpc/h - Density field pre-smoothed on scales: x_s = 1.000E+00 Mpc/h - 1 galaxy populations - Some populations will include LoS skewers - 1 intensity mapping species - 1 custom maps - 1 lensing source planes - 1 ISW source planes - Will include lensing in source catalog - -Seed : 1000 -*** Creating Gaussian density field -Creating Fourier-space density and Newtonian potential -> Relative time ellapsed 2257.6 ms -Transforming density and Newtonian potential -> Relative time ellapsed 480.6 ms -Normalizing density and Newtonian potential -> Relative time ellapsed 19.6 ms - =-2.325E-10, =8.941E-01 - -*** Writing density field (native format) -> Relative time ellapsed 241.5 ms - -*** Creating physical matter density - 1LPT - - Transforming density field - - Computing displacement field - - Transform displacement field - - Computing particle positions - 1st-order displacement : [1.738749E-10,4.895681E-10,4.054534E-13] 2.882436E+01 - - Undoing padding - - Interpolating positions into density field - - Normalizing density field - Total density : -3.546011E-04 -> Relative time ellapsed 2258.7 ms - -*** Writing density field (native format) -> Relative time ellapsed 189.3 ms - -*** Computing normalization of density field -z=0.000E+00, =1.004E+00, =1.004E+00, =1.004E+00, 00000000000 -z=3.771E-02, =1.004E+00, =1.004E+00, =1.004E+00, 00000349448 -z=8.083E-02, =1.026E+00, =1.026E+00, =1.026E+00, 00002350328 -z=1.291E-01, =1.121E+00, =1.121E+00, =1.121E+00, 00006084072 -z=1.512E-01, =1.121E+00, =1.121E+00, =1.121E+00, 00006469528 -> Relative time ellapsed 1501.3 ms - -*** Getting point sources - 0-th galaxy population - Poisson-sampling - There will be 97421 objects in total - Assigning coordinates -> Relative time ellapsed 892.7 ms - -*** Filling up intensity maps - 0-th intensity mapping species -> Relative time ellapsed 6312.8 ms - -*** Re-distributing sources across nodes -> Relative time ellapsed 3.0 ms - -*** Getting LOS information -> Relative time ellapsed 1958.9 ms - -*** Writing kappa source maps -> Relative time ellapsed 13.1 ms - -*** Writing isw source maps -> Relative time ellapsed 5.1 ms - -*** Writing source catalogs - 0-th population (FITS) -> Relative time ellapsed 421.3 ms - -*** Writing intensity maps - 0-th species -> Relative time ellapsed 20.4 ms - -*** Writing custom maps - 0-th species -> Relative time ellapsed 5.2 ms - - -|-------------------------------------------------| - -> Total time ellapsed 16702.8 ms diff --git a/output/nuTable.txt b/output/nuTable.txt deleted file mode 100644 index f6c8da2..0000000 --- a/output/nuTable.txt +++ /dev/null @@ -1,5 +0,0 @@ -1.245614035087719230e+03 1.269568151147098433e+03 -1.269568151147098433e+03 1.293522267206477636e+03 -1.293522267206477636e+03 1.317476383265856839e+03 -1.317476383265856839e+03 1.341430499325236042e+03 -1.341430499325236042e+03 1.365384615384615245e+03 diff --git a/output/params.cfg b/output/params.cfg deleted file mode 100644 index 2810578..0000000 --- a/output/params.cfg +++ /dev/null @@ -1,69 +0,0 @@ -global = -{ - prefix_out = "output/colore"; - output_format = "FITS"; - output_density = True; - pk_filename = "output/pk.txt"; - z_min = 0.0001; - z_max = 0.15; - seed = 1000; - write_pred = False; - just_write_pred = False; -}; -field_par = -{ - r_smooth = 1.0; - smooth_potential = True; - n_grid = 256; - dens_type = 1; - lpt_buffer_fraction = 0.6; - lpt_interp_type = 1; - output_lpt = 0; -}; -cosmo_par = -{ - omega_M = 0.3; - omega_B = 0.3; - omega_L = 0.7; - h = 0.7; - w = -1.0; - ns = 0.96; - sigma_8 = 0.8; -}; -custom1 = -{ - kz_filename = "output/wz.txt"; - bias_filename = "output/bias.txt"; - nside = 64; -}; -srcs1 = -{ - nz_filename = "output/dndz.txt"; - bias_filename = "output/bias.txt"; - include_lensing = True; - store_skewers = True; -}; -imap1 = -{ - tbak_filename = "output/tz.txt"; - bias_filename = "output/bias.txt"; - freq_list = "output/nuTable.txt"; - freq_rest = 1420.0; - nside = 64; -}; -kappa = -{ - z_out = - [ - 0.1 - ]; - nside = 64; -}; -isw = -{ - z_out = - [ - 0.1 - ]; - nside = 64; -}; diff --git a/output/pk.txt b/output/pk.txt deleted file mode 100644 index 0aaddb3..0000000 --- a/output/pk.txt +++ /dev/null @@ -1,1024 +0,0 @@ -1.000000000000000048e-04 1.224779862908184805e+04 -1.013596500938556902e-04 1.240755803744013610e+04 -1.027377866714885868e-04 1.256939960277221508e+04 -1.041346610843927429e-04 1.273335039240265360e+04 -1.055505281015629859e-04 1.289943782274179284e+04 -1.069856459559610632e-04 1.306768966367887333e+04 -1.084402763916133980e-04 1.323813404302439994e+04 -1.099146847113493375e-04 1.341079945100362420e+04 -1.114091398251883914e-04 1.358571474480309553e+04 -1.129239142993853772e-04 1.376290915316801329e+04 -1.144592844061424861e-04 1.394241228105265327e+04 -1.160155301739971450e-04 1.412425411432398687e+04 -1.175929354388950676e-04 1.430846502451810375e+04 -1.191917878959576692e-04 1.449507577365039651e+04 -1.208123791519533313e-04 1.468411751908048245e+04 -1.224550047784821541e-04 1.487562181843064718e+04 -1.241199643658837614e-04 1.506962063455959469e+04 -1.258075615778781635e-04 1.526614634059159835e+04 -1.275181042069493248e-04 1.546523172500068904e+04 -1.292519042304821162e-04 1.566690999675083367e+04 -1.310092778676621127e-04 1.587121479049271693e+04 -1.327905456371494570e-04 1.607818017181601863e+04 -1.345960324155364384e-04 1.628784064256015336e+04 -1.364260674966003071e-04 1.650023114618050386e+04 -1.382809846513614611e-04 1.671538707317191802e+04 -1.401611221889582535e-04 1.693334426655455900e+04 -1.420668230183496164e-04 1.715413902740530102e+04 -1.439984347108563953e-04 1.737780812046515712e+04 -1.459563095635532681e-04 1.760438877979251629e+04 -1.479408046635224147e-04 1.783391871447159792e+04 -1.499522819529808639e-04 1.806643611439843153e+04 -1.519911082952933080e-04 1.830197965609974199e+04 -1.540576555418825830e-04 1.854058850863715634e+04 -1.561523006000496586e-04 1.878230233954913638e+04 -1.582754255017160402e-04 1.902716132086702419e+04 -1.604274174731006183e-04 1.927520613517789388e+04 -1.626086690053438655e-04 1.952647798176331344e+04 -1.648195779260925296e-04 1.978101858277706924e+04 -1.670605474720571800e-04 2.003887018950303536e+04 -1.693319863625568399e-04 2.030007558865543615e+04 -1.716343088740630352e-04 2.056467810875038776e+04 -1.739679349157577902e-04 2.083272162652968109e+04 -1.763332901061186869e-04 2.110425057344727247e+04 -1.787308058505453559e-04 2.137930994221575020e+04 -1.811609194200413287e-04 2.165794529340504960e+04 -1.836240740309657540e-04 2.194020276211255987e+04 -1.861207189258693980e-04 2.222612906467496941e+04 -1.886513094554298617e-04 2.251577150545539916e+04 -1.912163071615006007e-04 2.280917798367602518e+04 -1.938161798612895201e-04 2.310639700031169923e+04 -1.964514017326810501e-04 2.340747766504525498e+04 -1.991224534007202704e-04 2.371246970327148665e+04 -2.018298220252709267e-04 2.402142346316345356e+04 -2.045740013898662867e-04 2.433438992279306331e+04 -2.073554919917679326e-04 2.465142069730167350e+04 -2.101748011332489163e-04 2.497256804613379427e+04 -2.130324430141181363e-04 2.529788488031558518e+04 -2.159289388255026599e-04 2.562742476979190178e+04 -2.188648168449052031e-04 2.596124195081172365e+04 -2.218406125325540334e-04 2.629939133336703162e+04 -2.248568686290629412e-04 2.664192850868049572e+04 -2.279141352544189524e-04 2.698890975674151559e+04 -2.310129700083160510e-04 2.734039205389092967e+04 -2.341539380718529089e-04 2.769643308045281447e+04 -2.373376123106136517e-04 2.805709122840964119e+04 -2.405645733791497655e-04 2.842242560912394765e+04 -2.438354098268829054e-04 2.879249606110051536e+04 -2.471507182054474968e-04 2.916736315779096549e+04 -2.505111031774928903e-04 2.954708821543536033e+04 -2.539171776269646117e-04 2.993173330095122219e+04 -2.573695627708853079e-04 3.032136123983084690e+04 -2.608688882726556630e-04 3.071603562412288011e+04 -2.644157923568950979e-04 3.111582082038282169e+04 -2.680109219258448600e-04 3.152078197771101259e+04 -2.716549326773531263e-04 3.193098503578265081e+04 -2.753484892244643456e-04 3.234649673291155341e+04 -2.790922652166349938e-04 3.276738461414732228e+04 -2.828869434625969352e-04 3.319371703937663551e+04 -2.867332160548916498e-04 3.362556319145486486e+04 -2.906317844960973860e-04 3.406299308434910927e+04 -2.945833598267730410e-04 3.450607757128594676e+04 -2.985886627551409913e-04 3.495488835291838768e+04 -3.026484237885337047e-04 3.540949798549422849e+04 -3.067633833666272790e-04 3.586997988902701036e+04 -3.109342919964865211e-04 3.633640835545555456e+04 -3.151619103894462296e-04 3.680885855682041438e+04 -3.194470095998537280e-04 3.728740655341131060e+04 -3.237903711656973135e-04 3.777212930190723273e+04 -3.281927872511474008e-04 3.826310466350521165e+04 -3.326550607910352432e-04 3.876041141202073049e+04 -3.371780056372962291e-04 3.926412924196207314e+04 -3.417624467074044771e-04 3.977433877658176789e+04 -3.464092201348251869e-04 4.029112157587833644e+04 -3.511191734215130954e-04 4.081456014456936828e+04 -3.558931655924840363e-04 4.134473794001537317e+04 -3.607320673524882257e-04 4.188173938008557889e+04 -3.656367612448138964e-04 4.242564985097148019e+04 -3.706081418122499039e-04 4.297655571493765456e+04 -3.756471157602369573e-04 4.353454431799412851e+04 -3.807546021222371819e-04 4.409970399750753131e+04 -3.859315324273520460e-04 4.467212408971162949e+04 -3.911788508702192268e-04 4.525189493713662523e+04 -3.964975144832197482e-04 4.583910789594556263e+04 -4.018884933110263447e-04 4.643385534315295081e+04 -4.073527705875249275e-04 4.703623068374218565e+04 -4.128913429151419485e-04 4.764632835765709024e+04 -4.185052204466096484e-04 4.826424384666143305e+04 -4.241954270692029592e-04 4.889007368107005459e+04 -4.299630005914809147e-04 4.952391544632251316e+04 -4.358089929325676955e-04 5.016586778940600198e+04 -4.417344703140068654e-04 5.081603042511524836e+04 -4.477405134542241988e-04 5.147450414212967735e+04 -4.538282177656344967e-04 5.214139080891384947e+04 -4.599986935544285514e-04 5.281679337941291305e+04 -4.662530662230762540e-04 5.350081589854813501e+04 -4.725924764755833583e-04 5.419356350749062403e+04 -4.790180805255385486e-04 5.489514244870311813e+04 -4.855310503069897314e-04 5.560566007075414382e+04 -4.921325736881877180e-04 5.632522483284393093e+04 -4.988238546882336165e-04 5.705394630910926935e+04 -5.056061136966766636e-04 5.779193519260412722e+04 -5.124805876960936667e-04 5.853930329904505925e+04 -5.194485304876958085e-04 5.929616357015363610e+04 -5.265112129200036914e-04 6.006263007679218572e+04 -5.336699231206312212e-04 6.083881802167004935e+04 -5.409259667312205089e-04 6.162484374175332778e+04 -5.482806671455713737e-04 6.242082471028356667e+04 -5.557353657510087077e-04 6.322687953840671253e+04 -5.632914221730315031e-04 6.404312797643471276e+04 -5.709502145232882124e-04 6.486969091464855592e+04 -5.787131396509233262e-04 6.570669038370894850e+04 -5.865816133973423326e-04 6.655424955457694887e+04 -5.945570708544394012e-04 6.741249273798069044e+04 -6.026409666263374482e-04 6.828154538341448642e+04 -6.108347750946852527e-04 6.916153407757880632e+04 -6.191399906875633390e-04 7.005258654234521964e+04 -6.275581281520449225e-04 7.095483163213651278e+04 -6.360907228304631990e-04 7.186839933075229055e+04 -6.447393309404348544e-04 7.279342074760132527e+04 -6.535055298586910739e-04 7.373002811332093552e+04 -6.623909184087667943e-04 7.467835477476169763e+04 -6.713971171526031661e-04 7.563853518931083090e+04 -6.805257686861128840e-04 7.661070491853977728e+04 -6.897785379387658469e-04 7.759500062114429602e+04 -6.991571124772466474e-04 7.859156004515163659e+04 -7.086632028132422217e-04 7.960052201937595964e+04 -7.182985427154132182e-04 8.062202644409627828e+04 -7.280648895256073075e-04 8.165621428092131100e+04 -7.379640244793725466e-04 8.270322754182726203e+04 -7.479977530308276092e-04 8.376320927733121789e+04 -7.581679051819495982e-04 8.483630356378170836e+04 -7.684763358163397215e-04 8.592265548972660326e+04 -7.789249250375253775e-04 8.702241114134491363e+04 -7.895155785118633789e-04 8.813571758689738635e+04 -8.002502278161052448e-04 8.926272286017220176e+04 -8.111308307896872294e-04 9.040357594291101850e+04 -8.221593718918116574e-04 9.155842674615027499e+04 -8.333378625633820150e-04 9.272742609047902806e+04 -8.446683415938599938e-04 9.391072568516821775e+04 -8.561528754931101897e-04 9.510847810613339243e+04 -8.677935588683004372e-04 9.632083677271136548e+04 -8.795925148059268416e-04 9.754795592320860305e+04 -8.915518952590332233e-04 9.878999058918694209e+04 -9.036738814396949072e-04 1.000470965684571711e+05 -9.159606842168390621e-04 1.013194303967410669e+05 -9.284145445194744509e-04 1.026071493179954414e+05 -9.410377337454033401e-04 1.039104112532644067e+05 -9.538325541754901632e-04 1.052293747681860259e+05 -9.668013393935633720e-04 1.065641990390014253e+05 -9.799464547120260473e-04 1.079150438169996632e+05 -9.932702976032535460e-04 1.092820693914907606e+05 -1.006775298136856683e-03 1.106654365511605283e+05 -1.020463919422890352e-03 1.120653065438212216e+05 -1.034338658061087273e-03 1.134818410344864824e+05 -1.048402044596200358e-03 1.149152020617703529e+05 -1.062656643979537595e-03 1.163655519925372355e+05 -1.077105056036769051e-03 1.178330534748174105e+05 -1.091749915942097273e-03 1.193178693888216512e+05 -1.106593894698873481e-03 1.208201627962576895e+05 -1.121639699626748041e-03 1.223400968875825201e+05 -1.136890074855445836e-03 1.238778349274854700e+05 -1.152347801825253726e-03 1.254335401982986805e+05 -1.168015699794314839e-03 1.270073759414537926e+05 -1.183896626352817305e-03 1.285995052968970267e+05 -1.199993477944177834e-03 1.302100912403866387e+05 -1.216309190393307944e-03 1.318392965187121881e+05 -1.232846739442065853e-03 1.334872835827462841e+05 -1.249609141291986841e-03 1.351542145182583190e+05 -1.266599453154392462e-03 1.368402509745703719e+05 -1.283820773807981853e-03 1.385455540908582625e+05 -1.301276244164000949e-03 1.402702844202141860e+05 -1.318969047839098482e-03 1.420146018513051677e+05 -1.336902411735970244e-03 1.437786655276990205e+05 -1.355079606631897195e-03 1.455626337647220062e+05 -1.373503947775287165e-03 1.473666639639187488e+05 -1.392178795490325513e-03 1.491909125249631761e+05 -1.411107555789848592e-03 1.510355347550969163e+05 -1.430293680996549965e-03 1.529006847759798111e+05 -1.449740670372631464e-03 1.547865154279589187e+05 -1.469452070758017065e-03 1.566931781717316480e+05 -1.489431477217242764e-03 1.586208229873323580e+05 -1.509682533695143238e-03 1.605695982704501366e+05 -1.530208933681452164e-03 1.625396507260382641e+05 -1.551014420884440229e-03 1.645311252591764787e+05 -1.572102789913710748e-03 1.665441648631675635e+05 -1.593477886972280389e-03 1.685789105048497731e+05 -1.615143610558068604e-03 1.706355010070797871e+05 -1.637103912174925433e-03 1.727140729283884575e+05 -1.659362797053326932e-03 1.748147604397643881e+05 -1.681924324880868958e-03 1.769376951985624910e+05 -1.704792610542693338e-03 1.790830062195027422e+05 -1.727971824871981721e-03 1.812508197427584964e+05 -1.751466195410653504e-03 1.834412590991046745e+05 -1.775280007180405099e-03 1.856544445721031516e+05 -1.799417603464234733e-03 1.878904932573568949e+05 -1.823883386598591999e-03 1.901495189187651849e+05 -1.848681818776298086e-03 1.924316318417611183e+05 -1.873817422860383055e-03 1.947369386836803751e+05 -1.899294783208988488e-03 1.970655423210275767e+05 -1.925118546511485557e-03 1.994175416936693364e+05 -1.951293422635962246e-03 2.017930316462890187e+05 -1.977824185488231967e-03 2.041921027665746806e+05 -2.004715673882523364e-03 2.066148412204791966e+05 -2.031972792424006566e-03 2.090613285846359213e+05 -2.059600512403321568e-03 2.115316416755454848e+05 -2.087603872703265497e-03 2.140258523759802629e+05 -2.115987980717810510e-03 2.165440274583169958e+05 -2.144758013283615174e-03 2.190862284049313748e+05 -2.173919217624203232e-03 2.216525112257032888e+05 -2.203476912306977578e-03 2.242429262725386943e+05 -2.233436488213247709e-03 2.268575180509978090e+05 -2.263803409521446697e-03 2.294963250290767173e+05 -2.294583214703712921e-03 2.321593794431560673e+05 -2.325781517536029078e-03 2.348467071009935171e+05 -2.357404008122085913e-03 2.375583271820976515e+05 -2.389456453931077928e-03 2.402942520351887797e+05 -2.421944700849592864e-03 2.430544869730031351e+05 -2.454874674247826960e-03 2.458390300643798546e+05 -2.488252380060276912e-03 2.486478719236894685e+05 -2.522083905881133178e-03 2.514809954976489826e+05 -2.556375422074565022e-03 2.543383758495285874e+05 -2.591133182900105456e-03 2.572199799409266561e+05 -2.626363527653332534e-03 2.601257664109124453e+05 -2.662072881822062989e-03 2.630556853528971551e+05 -2.698267758258263323e-03 2.660096780889785150e+05 -2.734954758365899536e-03 2.689876769420895143e+05 -2.772140573304931934e-03 2.719896050057595130e+05 -2.809831985211683984e-03 2.750153759117460577e+05 -2.848035868435802066e-03 2.780648935954740155e+05 -2.886759190794032943e-03 2.811380520593757392e+05 -2.926009014841051813e-03 2.842347351342394250e+05 -2.965792499157563888e-03 2.873548162385271862e+05 -3.006116899655924494e-03 2.904981581358611002e+05 -3.046989570903508009e-03 2.936646126906314748e+05 -3.088417967464070647e-03 2.968540206218527164e+05 -3.130409645257351686e-03 3.000662112553223269e+05 -3.172972262937160792e-03 3.033010022741733119e+05 -3.216113583288200770e-03 3.065581994678459596e+05 -3.259841474641884691e-03 3.098375964795897016e+05 -3.304163912311399321e-03 3.131389745525811450e+05 -3.349088980046287245e-03 3.164621022746578674e+05 -3.394624871506797016e-03 3.198067353218600620e+05 -3.440779891758287586e-03 3.231726162006924278e+05 -3.487562458785946774e-03 3.265594739894411759e+05 -3.534981105030105680e-03 3.299670240781519096e+05 -3.583044478942428324e-03 3.333949679080676287e+05 -3.631761346563260138e-03 3.368429927098261542e+05 -3.681140593120421980e-03 3.403107712409287342e+05 -3.731191224649743707e-03 3.437979615225980524e+05 -3.781922369637629160e-03 3.473042065757507225e+05 -3.833343280685956589e-03 3.508291341565115144e+05 -3.885463336199613746e-03 3.543723564911987633e+05 -3.938292042096979903e-03 3.579334700106426608e+05 -3.991839033543662270e-03 3.615120550843487727e+05 -4.046114076709806870e-03 3.651076757541097468e+05 -4.101127070551300463e-03 3.687198794674646924e+05 -4.156888048615191809e-03 3.723481968108281144e+05 -4.213407180869664474e-03 3.759921412424011505e+05 -4.270694775558885568e-03 3.796512088251667446e+05 -4.328761281083061754e-03 3.833248779594795778e+05 -4.387617287904096303e-03 3.870126091158596682e+05 -4.447273530477112609e-03 3.907138445676366100e+05 -4.507740889208263976e-03 3.944280081237053964e+05 -4.569030392439154924e-03 3.981545048612411483e+05 -4.631153218458248719e-03 4.018927208585427725e+05 -4.694120697539616756e-03 4.056420229279369814e+05 -4.757944314009414019e-03 4.094017583488192176e+05 -4.822635708340444055e-03 4.131712546007673373e+05 -4.888206679275213309e-03 4.169498190967376577e+05 -4.954669185977838251e-03 4.207367389164063497e+05 -5.022035350215225090e-03 4.245312805395475007e+05 -5.090317458567891577e-03 4.283326895794885349e+05 -5.159527964670862846e-03 4.321401905165942735e+05 -5.229679491485020315e-03 4.359529864316802705e+05 -5.300784833599348628e-03 4.397702587394707953e+05 -5.372856959564470056e-03 4.435911669218152529e+05 -5.445909014257920011e-03 4.474148482608210179e+05 -5.519954321281573054e-03 4.512404175716364989e+05 -5.595006385391668689e-03 4.550669669349871692e+05 -5.671078894961878447e-03 4.588935654291625251e+05 -5.748185724479858323e-03 4.627192588615448913e+05 -5.826340937077747160e-03 4.665430694994242513e+05 -5.905558787097077607e-03 4.703639958000255865e+05 -5.985853722688545472e-03 4.741810121396519244e+05 -6.067240388447144896e-03 4.779930685416554916e+05 -6.149733628083116008e-03 4.817990904032795806e+05 -6.233348487129222910e-03 4.855979782209832338e+05 -6.318100215684827742e-03 4.893886073142408859e+05 -6.404004271197282980e-03 4.931698275475210394e+05 -6.491076321281138983e-03 4.969404630502167856e+05 -6.579332246575681983e-03 5.006993119344175211e+05 -6.668788143641326410e-03 5.044451460100710392e+05 -6.759460327895381974e-03 5.081767104978364077e+05 -6.851365336587749745e-03 5.118927237385203480e+05 -6.944519931817061571e-03 5.155918768995961873e+05 -7.038941103587838775e-03 5.192728336781079997e+05 -7.134646072909217422e-03 5.229342300000367104e+05 -7.231652294935798746e-03 5.265746737152041169e+05 -7.329977462151210203e-03 5.301927442882000469e+05 -7.429639507594949614e-03 5.337869924845150672e+05 -7.530656608133103926e-03 5.373559400517337490e+05 -7.633047187773535011e-03 5.408980793954364490e+05 -7.736829921026147465e-03 5.444118732496983139e+05 -7.842023736308833398e-03 5.478957543413594831e+05 -7.948647819399742159e-03 5.513481250487029320e+05 -8.056721616936468253e-03 5.547673570530703291e+05 -8.166264839962836600e-03 5.581517909841105575e+05 -8.277297467523895766e-03 5.614997360580253880e+05 -8.389839750309798297e-03 5.648094697082919301e+05 -8.503912214349228227e-03 5.680792372092846781e+05 -8.619535664753033219e-03 5.713072512918906286e+05 -8.736731189508770840e-03 5.744916917516009416e+05 -8.855520163326847244e-03 5.776307050484074280e+05 -8.975924251538930018e-03 5.807224038988560205e+05 -9.097965414049393254e-03 5.837648668600304518e+05 -9.221665909340474865e-03 5.867561379055692814e+05 -9.347048298531879934e-03 5.896942259937988129e+05 -9.474135449495605515e-03 5.925771046282885363e+05 -9.602950541026687714e-03 5.954027114110452821e+05 -9.733517067070672490e-03 5.981689475888218731e+05 -9.865858841008557853e-03 6.008736775930384174e+05 -1.000000000000000021e-02 6.035147285739743384e+05 -1.013596500938556896e-02 6.060898899301640922e+05 -1.027377866714885950e-02 6.085969128338743467e+05 -1.041346610843927462e-02 6.110335097539111739e+05 -1.055505281015629848e-02 6.133973539771705400e+05 -1.069856459559610611e-02 6.156860791305330349e+05 -1.084402763916134105e-02 6.178972787050585030e+05 -1.099146847113493392e-02 6.200285055845775642e+05 -1.114091398251883941e-02 6.220772715812310344e+05 -1.129239142993853674e-02 6.240410469808214111e+05 -1.144592844061424926e-02 6.259172601010766812e+05 -1.160155301739971417e-02 6.277032968665964436e+05 -1.175929354388950687e-02 6.293965004044672241e+05 -1.191917878959576627e-02 6.309941706650699489e+05 -1.208123791519533259e-02 6.324935640733462060e+05 -1.224550047784821530e-02 6.338918932159283431e+05 -1.241199643658837636e-02 6.351863265707372921e+05 -1.258075615778781603e-02 6.363739882853173185e+05 -1.275181042069493259e-02 6.374519580125913490e+05 -1.292519042304821064e-02 6.384172708124299534e+05 -1.310092778676621127e-02 6.392669171273611719e+05 -1.327905456371494472e-02 6.399978428440443240e+05 -1.345960324155364221e-02 6.406069494503099704e+05 -1.364260674966003006e-02 6.410910943009186303e+05 -1.382809846513614535e-02 6.414470910050024977e+05 -1.401611221889582579e-02 6.416717099500432378e+05 -1.420668230183496153e-02 6.417616789777234662e+05 -1.439984347108563996e-02 6.417136842291048961e+05 -1.459563095635532659e-02 6.415243711772634415e+05 -1.479408046635224266e-02 6.411903458678253228e+05 -1.499522819529808607e-02 6.407081763881050283e+05 -1.519911082952933069e-02 6.400743945890482282e+05 -1.540576555418825787e-02 6.392854980833225418e+05 -1.561523006000496532e-02 6.383379525475917617e+05 -1.582754255017160272e-02 6.372281943559709471e+05 -1.604274174731006031e-02 6.359526335756467888e+05 -1.626086690053438893e-02 6.345076573562329868e+05 -1.648195779260925101e-02 6.328896337471633451e+05 -1.670605474720571887e-02 6.310949159786948003e+05 -1.693319863625568356e-02 6.291198472445027437e+05 -1.716343088740630504e-02 6.269607660256222589e+05 -1.739679349157578075e-02 6.246140119972397806e+05 -1.763332901061186869e-02 6.220759325619403971e+05 -1.787308058505453559e-02 6.193428900543372147e+05 -1.811609194200415260e-02 6.164112696639223723e+05 -1.836240740309659503e-02 6.132774881242287811e+05 -1.861207189258696007e-02 6.099380032178378897e+05 -1.886513094554300579e-02 6.063893241471276851e+05 -1.912163071615008078e-02 6.026280228221388534e+05 -1.938161798612895309e-02 5.986507461164664710e+05 -1.964514017326810663e-02 5.944542291422495618e+05 -1.991224534007202812e-02 5.900353095947782276e+05 -2.018298220252709094e-02 5.853909432155326940e+05 -2.045740013898662835e-02 5.805182204210566124e+05 -2.073554919917679207e-02 5.754143841419680975e+05 -2.101748011332489272e-02 5.700768489131643437e+05 -2.130324430141181460e-02 5.645032212515721330e+05 -2.159289388255026740e-02 5.586913213523678714e+05 -2.188648168449051912e-02 5.526392061279427726e+05 -2.218406125325540421e-02 5.463451936056665145e+05 -2.248568686290629282e-02 5.398078886914264876e+05 -2.279141352544189481e-02 5.330262102948337561e+05 -2.310129700083160542e-02 5.259994197996061994e+05 -2.341539380718529045e-02 5.187271508484433871e+05 -2.373376123106136701e-02 5.112094403956773458e+05 -2.405645733791497709e-02 5.034467609612993547e+05 -2.438354098268829054e-02 4.954400540029281401e+05 -2.471507182054475185e-02 4.871907643060603295e+05 -2.505111031774929012e-02 4.787008752541118884e+05 -2.539171776269645922e-02 4.699729448240338243e+05 -2.573695627708853448e-02 4.610101421245448291e+05 -2.608688882726556413e-02 4.518162842624068726e+05 -2.644157923568950935e-02 4.423958732915431610e+05 -2.680109219258448860e-02 4.327541329660681658e+05 -2.716549326773531198e-02 4.228970449836933985e+05 -2.753484892244643586e-02 4.128313843697974226e+05 -2.790922652166349938e-02 4.025647536163307377e+05 -2.828869434625969417e-02 3.921056151524679735e+05 -2.867332160548916389e-02 3.814633216869545868e+05 -2.906317844960974034e-02 3.706481439266487141e+05 -2.945833598267730280e-02 3.596712951403359184e+05 -2.985886627551409891e-02 3.485449520051561994e+05 -3.026484237885337242e-02 3.372822711430219351e+05 -3.067633833666272639e-02 3.258974007289019064e+05 -3.109342919964865060e-02 3.144054865324140992e+05 -3.151619103894462426e-02 3.028226717386565288e+05 -3.194470095998537540e-02 2.911660898867912474e+05 -3.237903711656973244e-02 2.794538502649035654e+05 -3.281927872511473943e-02 2.677050151083160308e+05 -3.326550607910352259e-02 2.559395679688335513e+05 -3.371780056372962464e-02 2.441783726523352088e+05 -3.417624467074045075e-02 2.324431221653765824e+05 -3.464092201348251826e-02 2.207562771678664139e+05 -3.511191734215130672e-02 2.091409934983092535e+05 -3.558931655924840037e-02 1.976210384234242374e+05 -3.607320673524882365e-02 1.862206953629433701e+05 -3.656367612448138682e-02 1.749646569554217858e+05 -3.706081418122499083e-02 1.638779064606264874e+05 -3.756471157602369465e-02 1.529855876385545416e+05 -3.807546021222371624e-02 1.423128634038110904e+05 -3.859315324273520503e-02 1.318847637257752649e+05 -3.911788508702192246e-02 1.217260234284107864e+05 -3.964975144832197373e-02 1.118609107370428683e+05 -4.018884933110263014e-02 1.023130476210360212e+05 -4.073527705875248928e-02 9.310522318783770606e+04 -4.128913429151419290e-02 8.425920159508328652e+04 -4.185052204466096354e-02 7.579552615273195261e+04 -4.241954270692029766e-02 6.773332150500672287e+04 -4.299630005914809039e-02 6.009009594632148219e+04 -4.358089929325677236e-02 5.288154620430276555e+04 -4.417344703140068524e-02 4.612136695766294724e+04 -4.477405134542242204e-02 3.982106807431951893e+04 -4.538282177656344923e-02 3.398980150119416066e+04 -4.599986935544285449e-02 2.863420161405150066e+04 -4.662530662230762735e-02 2.375824310287558546e+04 -4.725924764755833063e-02 1.936310255996489650e+04 -4.790180805255385421e-02 1.544711571127993739e+04 -4.855310503069897032e-02 1.200546080406196779e+04 -4.921325736881872193e-02 9.030948198067135309e+03 -4.988238546882330787e-02 6.511237367239962623e+03 -5.056061136966762126e-02 4.437284799880485480e+03 -5.124805876960931289e-02 2.779466929742228785e+03 -5.194485304876952231e-02 1.549648787903498715e+03 -5.265112129200031493e-02 6.588805848264186125e+02 -5.336699231206307181e-02 1.913185826683975677e+02 -5.409259667312199538e-02 8.811501260479357001e+00 -5.482806671455707492e-02 7.060553237164307916e+01 -5.557353657510081396e-02 6.253663137282856042e+02 -5.632914221730309090e-02 1.103866104447035468e+03 -5.709502145232881604e-02 2.022037286014455276e+03 -5.787131396509233305e-02 2.982598158466034874e+03 -5.865816133973422719e-02 4.129182127281172143e+03 -5.945570708544394706e-02 5.346811887435072094e+03 -6.026409666263374959e-02 6.630752272942214404e+03 -6.108347750946852700e-02 7.934517460898560785e+03 -6.191399906875633824e-02 9.228353365465149182e+03 -6.275581281520449528e-02 1.047885349300619055e+04 -6.360907228304631122e-02 1.165654659282267676e+04 -6.447393309404349238e-02 1.273396632294382289e+04 -6.535055298586910089e-02 1.368680707410752620e+04 -6.623909184087668767e-02 1.449405549540017819e+04 -6.713971171526031401e-02 1.513838448205032910e+04 -6.805257686861129751e-02 1.560640215427119801e+04 -6.897785379387658122e-02 1.588886770596430506e+04 -6.991571124772466561e-02 1.598083115443914176e+04 -7.086632028132422434e-02 1.588170049360269331e+04 -7.182985427154131575e-02 1.559522768686992822e+04 -7.280648895256074116e-02 1.512941000418444128e+04 -7.379640244793725379e-02 1.449630365699564936e+04 -7.479977530308275224e-02 1.371174904408326074e+04 -7.581679051819496806e-02 1.279500793355827227e+04 -7.684763358163397562e-02 1.176831806069273807e+04 -7.789249250375253342e-02 1.065636372518336611e+04 -7.895155785118633529e-02 9.485691567645682881e+03 -8.002502278161052751e-02 8.284019688097250764e+03 -8.111308307896872294e-02 7.079630038976727519e+03 -8.221593718918115967e-02 5.900377150715165953e+03 -8.333378625633819370e-02 4.773578142626958652e+03 -8.446683415938599504e-02 3.723784026424298190e+03 -8.561528754931102547e-02 2.775117566768379675e+03 -8.677935588683004242e-02 1.945435286258007181e+03 -8.795925148059269283e-02 1.250962234823917925e+03 -8.915518952590333057e-02 7.120290228813471458e+02 -9.036738814396948205e-02 3.014636964675549962e+02 -9.159606842168389884e-02 9.989285843016575939e+01 -9.284145445194744162e-02 2.997458172920902664e-01 -9.410377337454033098e-02 4.064468581551756898e+01 -9.538325541754902326e-02 3.080604622612893877e+02 -9.668013393935633026e-02 5.517760172678869139e+02 -9.799464547120259605e-02 1.003549721931005024e+03 -9.932702976032535547e-02 1.463788831591476310e+03 -1.006775298136856761e-01 1.999359150161223852e+03 -1.020463919422890386e-01 2.539662149577874516e+03 -1.034338658061087213e-01 3.074684935399231563e+03 -1.048402044596200428e-01 3.570804635254207369e+03 -1.062656643979537630e-01 4.005642136005389602e+03 -1.077105056036769121e-01 4.356674374464088942e+03 -1.091749915942097360e-01 4.606589157308966605e+03 -1.106593894698873481e-01 4.742675686578339082e+03 -1.121639699626748032e-01 4.757948361956161534e+03 -1.136890074855445715e-01 4.651416741718811863e+03 -1.152347801825253787e-01 4.428280332619166074e+03 -1.168015699794314882e-01 4.099723067974448895e+03 -1.183896626352817366e-01 3.682554684544679276e+03 -1.199993477944177739e-01 3.198047977825599901e+03 -1.216309190393307926e-01 2.672052992416417965e+03 -1.232846739442065853e-01 2.130008637976957289e+03 -1.249609141291986719e-01 1.606093869793093518e+03 -1.266599453154392541e-01 1.112162726076596527e+03 -1.283820773807981819e-01 7.115553513541295843e+02 -1.301276244164000784e-01 3.425206031132286171e+02 -1.318969047839098352e-01 1.722595576551439649e+02 -1.336902411735970131e-01 8.177118641148849676e+00 -1.355079606631897360e-01 1.851909064214946055e+00 -1.373503947775287226e-01 1.649645458027208917e+02 -1.392178795490325305e-01 2.740990643241340763e+02 -1.411107555789848644e-01 5.852228921023136081e+02 -1.430293680996549965e-01 8.763621463492336261e+02 -1.449740670372631490e-01 1.215990387015404849e+03 -1.469452070758017204e-01 1.532995979328508156e+03 -1.489431477217242894e-01 1.813358841026995606e+03 -1.509682533695143325e-01 2.026786961196407219e+03 -1.530208933681452277e-01 2.155083998690041881e+03 -1.551014420884440081e-01 2.185731235233530697e+03 -1.572102789913710774e-01 2.115439703533792454e+03 -1.593477886972280433e-01 1.950373835536194065e+03 -1.615143610558068543e-01 1.704957717446964580e+03 -1.637103912174925346e-01 1.403003750904443450e+03 -1.659362797053327010e-01 1.071068938932386800e+03 -1.681924324880868793e-01 7.413877998269809950e+02 -1.704792610542693321e-01 4.522273219090825478e+02 -1.727971824871981921e-01 1.978362889774882660e+02 -1.751466195410653626e-01 8.441953854260424350e+01 -1.775280007180405073e-01 1.677360118180868179e-02 -1.799417603464236737e-01 1.779375606987995795e+01 -1.823883386598593725e-01 1.969603749051336763e+02 -1.848681818776299890e-01 3.172839565514433389e+02 -1.873817422860384885e-01 5.744237433509807715e+02 -1.899294783208990423e-01 7.813627737197494980e+02 -1.925118546511487561e-01 9.845411880493159060e+02 -1.951293422635964336e-01 1.120450537649552643e+03 -1.977824185488233910e-01 1.181902705558203706e+03 -2.004715673882525306e-01 1.155418319301107204e+03 -2.031972792424008578e-01 1.044681753432810410e+03 -2.059600512403323702e-01 8.699336916016887926e+02 -2.087603872703267804e-01 6.438093092421635220e+02 -2.115987980717812800e-01 4.370425396533246385e+02 -2.144758013283617482e-01 1.960780580263223101e+02 -2.173919217624205591e-01 1.201055303522246192e+02 -2.203476912306980007e-01 1.050858043308702916e+00 -2.233436488213250137e-01 2.762205833687894518e+00 -2.263803409521448762e-01 1.619819575776823228e+02 -2.294583214703715401e-01 2.114509159932988496e+02 -2.325781517536031351e-01 4.144856883567687191e+02 -2.357404008122088168e-01 5.422482459128616483e+02 -2.389456453931078084e-01 6.521690194920564636e+02 -2.421944700849592569e-01 6.852899205181897742e+02 -2.454874674247826960e-01 6.506860996469182510e+02 -2.488252380060277102e-01 5.367278805400061401e+02 -2.522083905881132848e-01 4.147639563384595363e+02 -2.556375422074564918e-01 2.016775684294797486e+02 -2.591133182900105525e-01 1.811786645902025157e+02 -2.626363527653332586e-01 2.320501245866576578e+00 -2.662072881822062920e-01 3.917985375278010968e-02 -2.698267758258263149e-01 1.144501745620541158e+02 -2.734954758365899519e-01 1.206245770369595363e+02 -2.772140573304932021e-01 2.755646393331716695e+02 -2.809831985211684313e-01 3.524408060660239244e+02 -2.848035868435802032e-01 4.089291051416215623e+02 -2.886759190794033203e-01 3.955892913482853714e+02 -2.926009014841051692e-01 3.316023689105430776e+02 -2.965792499157564044e-01 2.201442689503160466e+02 -3.006116899655924546e-01 1.234900732040729423e+02 -3.046989570903508304e-01 2.748622474104781332e+01 -3.088417967464070490e-01 5.206402021276937964e-01 -3.130409645257352103e-01 2.374089227252479262e+01 -3.172972262937160948e-01 8.651568911433747644e+01 -3.216113583288200961e-01 1.658860011258385612e+02 -3.259841474641884673e-01 2.283334793629867647e+02 -3.304163912311399720e-01 2.488526731336039859e+02 -3.349088980046286967e-01 2.206555123179113878e+02 -3.394624871506797259e-01 1.556892349852158191e+02 -3.440779891758287690e-01 7.699907256545014889e+01 -3.487562458785946617e-01 2.058982840682226012e+01 -3.534981105030105542e-01 1.170738735497929284e+00 -3.583044478942428168e-01 1.684769074277168954e+01 -3.631761346563260329e-01 8.203174171577289542e+01 -3.681140593120422189e-01 1.215889790572051226e+02 -3.731191224649743621e-01 1.519256715246400518e+02 -3.781922369637629178e-01 1.406827758067751120e+02 -3.833343280685956311e-01 9.135506757096952413e+01 -3.885463336199613815e-01 5.277092353603351427e+01 -3.938292042096980250e-01 3.086810615046766682e+00 -3.991839033543662651e-01 3.509066483923192870e+00 -4.046114076709806939e-01 2.714796750210837573e+01 -4.101127070551300324e-01 6.512301106815830565e+01 -4.156888048615192122e-01 8.880698055434615412e+01 -4.213407180869664370e-01 9.067276988495410706e+01 -4.270694775558880885e-01 5.348970850144142020e+01 -4.328761281083057244e-01 3.886078325483795481e+01 -4.387617287904091445e-01 4.707219867125075896e-01 -4.447273530477107717e-01 5.674170925692310075e-01 -4.507740889208259327e-01 4.180086243349151687e+01 -4.569030392439150101e-01 4.221462653916083951e+01 -4.631153218458244347e-01 5.870057662395318943e+01 -4.694120697539612141e-01 4.058866764477216549e+01 -4.757944314009409092e-01 2.219086329330190921e+01 -4.822635708340439198e-01 1.510907278102133322e+00 -4.888206679275207689e-01 6.784753935019567361e-01 -4.954669185977833012e-01 2.314236579884914136e+01 -5.022035350215219296e-01 2.923251459290250409e+01 -5.090317458567886755e-01 3.139570179193196253e+01 -5.159527964670856948e-01 2.504888640934031230e+01 -5.229679491485015319e-01 2.687336732365690928e+00 -5.300784833599342383e-01 1.532399055862623261e-01 -5.372856959564464852e-01 8.628334314155939211e+00 -5.445909014257914738e-01 1.633781016354672033e+01 -5.519954321281567156e-01 1.963907554683072831e+01 -5.595006385391663173e-01 1.468680989335088505e+01 -5.671078894961878447e-01 2.202256601426014537e+00 -5.748185724479858427e-01 2.946468698455452506e-02 -5.826340937077747473e-01 6.458636766170734234e+00 -5.905558787097077156e-01 1.077117150506191301e+01 -5.985853722688545542e-01 1.135520947974146466e+01 -6.067240388447144861e-01 5.042003535138937842e+00 -6.149733628083116077e-01 3.096573978740629340e-01 -6.233348487129223292e-01 1.417588629558139690e+00 -6.318100215684827603e-01 5.716134107988207091e+00 -6.404004271197283327e-01 6.964807724970946801e+00 -6.491076321281139538e-01 4.235158947591982859e+00 -6.579332246575682053e-01 2.422662446562536542e-01 -6.668788143641326549e-01 7.345131414204307818e-01 -6.759460327895382425e-01 3.487675878764318504e+00 -6.851365336587750265e-01 3.531434293266512814e+00 -6.944519931817061398e-01 3.546493534286688121e+00 -7.038941103587839088e-01 1.777743056037015554e-03 -7.134646072909217596e-01 1.994499794997998954e-01 -7.231652294935798642e-01 3.400740326044505490e+00 -7.329977462151210377e-01 2.066519660602547770e+00 -7.429639507594949510e-01 2.534271562081419904e-01 -7.530656608133103891e-01 2.015328717448798546e-01 -7.633047187773535081e-01 9.630733245960834132e-01 -7.736829921026147083e-01 1.541817528939240622e+00 -7.842023736308834092e-01 3.543403678372473165e-01 -7.948647819399742298e-01 1.118497807791907633e-01 -8.056721616936468600e-01 3.735754592215401182e-01 -8.166264839962836808e-01 1.005050077919468210e+00 -8.277297467523895280e-01 1.951771907437504228e-01 -8.389839750309798783e-01 7.209383619166685742e-02 -8.503912214349227394e-01 2.342821493942424671e-01 -8.619535664753031901e-01 6.626899717889157548e-01 -8.736731189508771811e-01 3.680282993683339776e-02 -8.855520163326846550e-01 1.470140093505144067e-02 -8.975924251538929255e-01 2.998813576884919452e-01 -9.097965414049393740e-01 1.890985772818660482e-01 -9.221665909340474032e-01 3.314365733604412306e-02 -9.347048298531880350e-01 2.432347585538421203e-02 -9.474135449495605377e-01 2.700339531056112352e-01 -9.602950541026686881e-01 1.324213287248065217e-02 -9.733517067070671658e-01 7.728048975025146724e-04 -9.865858841008557922e-01 1.401515650534790880e-01 -1.000000000000000000e+00 3.340601048975868487e-02 -1.013596500938556799e+00 5.297846757962043976e-03 -1.027377866714885846e+00 3.534203338589970295e-02 -1.041346610843927323e+00 3.174322701678986697e-02 -1.055505281015630015e+00 4.700120435510321722e-03 -1.069856459559610729e+00 1.490349126688096312e-02 -1.084402763916133994e+00 2.006499407740732280e-02 -1.099146847113493530e+00 2.303837528025400733e-03 -1.114091398251883858e+00 8.853904479023377502e-03 -1.129239142993853751e+00 1.062777095935947026e-02 -1.144592844061424808e+00 3.987287177790688154e-04 -1.160155301739971501e+00 6.079962839456350306e-03 -1.175929354388950632e+00 5.327785199940493661e-03 -1.191917878959576793e+00 6.330719239021215532e-05 -1.208123791519533308e+00 3.602482466719248485e-03 -1.224550047784821460e+00 1.543591995166977227e-03 -1.241199643658837726e+00 6.773151972371982020e-04 -1.258075615778781575e+00 2.633211999905715837e-03 -1.275181042069493342e+00 2.658729818217967679e-05 -1.292519042304821175e+00 6.422065900758943801e-04 -1.310092778676621217e+00 6.502106703959643517e-04 -1.327905456371494486e+00 1.996516734693626512e-04 -1.345960324155364374e+00 8.208802865581414339e-04 -1.364260674966003117e+00 7.484301435498680358e-06 -1.382809846513614493e+00 1.450028136237560203e-04 -1.401611221889582648e+00 5.465693630346290285e-05 -1.420668230183496084e+00 8.540173044520036933e-05 -1.439984347108564045e+00 9.418140904263989997e-05 -1.459563095635532770e+00 4.850007818599418459e-05 -1.479408046635224183e+00 6.757825037464340406e-05 -1.499522819529808704e+00 2.268678886171001047e-05 -1.519911082952933201e+00 3.434169475197924919e-05 -1.540576555418825766e+00 1.084598035327964898e-05 -1.561523006000496538e+00 1.430675758027564214e-05 -1.582754255017160494e+00 6.289200010008156608e-06 -1.604274174731006086e+00 5.780860617974523019e-06 -1.626086690053438755e+00 4.608100950418957989e-06 -1.648195779260925198e+00 2.734095068466157919e-06 -1.670605474720571859e+00 3.642287760616521308e-06 -1.693319863625568411e+00 1.574377541875781742e-06 -1.716343088740630352e+00 2.532289292097178818e-06 -1.739679349157577937e+00 9.571935502739495368e-07 -1.763332901061186897e+00 1.316757783286377708e-06 -1.787308058505453712e+00 4.759204603603891367e-07 -1.811609194200413331e+00 3.147434387768833217e-07 -1.836240740309657449e+00 2.108994688996692604e-07 -1.861207189258694106e+00 1.217553665194496599e-08 -1.886513094554298720e+00 6.453173886890843432e-07 -1.912163071615006205e+00 8.950624895471883381e-08 -1.938161798612893394e+00 1.565745844016893715e-07 -1.964514017326808526e+00 8.336424873878821559e-08 -1.991224534007200786e+00 2.260679964007974537e-09 -2.018298220252706887e+00 1.815794003994911081e-07 -2.045740013898660781e+00 4.072580352167158156e-08 -2.073554919917677264e+00 4.371375223409862714e-09 -2.101748011332487120e+00 8.407578666261956362e-08 -2.130324430141179448e+00 2.338518875030186839e-08 -2.159289388255024367e+00 3.515648167322349634e-09 -2.188648168449049969e+00 4.402729783451704266e-08 -2.218406125325538270e+00 1.935067595783129354e-08 -2.248568686290627117e+00 8.416955280400663564e-11 -2.279141352544187260e+00 1.669692190340594312e-08 -2.310129700083157989e+00 2.283132001830495492e-08 -2.341539380718526964e+00 3.754865527975911398e-09 -2.373376123106134106e+00 2.368963832542095964e-09 -2.405645733791495378e+00 1.149207790481270683e-08 -2.438354098268826764e+00 1.290392753699561087e-08 -2.471507182054472729e+00 3.316263094937368073e-09 -2.505111031774926555e+00 4.823249934035306283e-10 -2.539171776269643299e+00 3.450367034924288235e-09 -2.573695627708850520e+00 8.981241670845377854e-09 -2.608688882726553970e+00 5.267107283376777808e-09 -2.644157923568948299e+00 4.296152086660124999e-09 -2.680109219258445918e+00 3.955445133513649913e-12 -2.716549326773528339e+00 1.330387039919479025e-10 -2.753484892244640658e+00 3.800696278889625719e-09 -2.790922652166347273e+00 3.203164308079419276e-09 -2.828869434625966406e+00 3.816057207873186227e-09 -2.867332160548913489e+00 2.852963019661365338e-09 -2.906317844960971009e+00 1.837400942013982270e-09 -2.945833598267727282e+00 9.700238827187776949e-10 -2.985886627551407102e+00 3.915689227677623255e-10 -3.026484237885334050e+00 1.369235381280480411e-10 -3.067633833666269627e+00 1.204661455824614768e-11 -3.109342919964861895e+00 2.149064511705589465e-12 -3.151619103894459428e+00 5.603900280420728356e-12 -3.194470095998533932e+00 1.285781148696825551e-11 -3.237903711656976657e+00 5.845686267876554598e-12 -3.281927872511477329e+00 1.385814989441409841e-12 -3.326550607910355950e+00 3.836826895369891405e-12 -3.371780056372966072e+00 5.068915078909505423e-11 -3.417624467074048322e+00 1.189511543641740138e-10 -3.464092201348255351e+00 2.479900016684872353e-10 -3.511191734215134641e+00 3.795961807302498353e-10 -3.558931655924843618e+00 4.795712522008579643e-10 -3.607320673524885724e+00 4.595815984152259875e-10 -3.656367612448142346e+00 3.533653149018047241e-10 -3.706081418122502580e+00 1.050741273844717035e-10 -3.756471157602373268e+00 1.563000457514201542e-11 -3.807546021222375732e+00 4.573761513529940752e-11 -3.859315324273524528e+00 1.980181373687901353e-10 -3.911788508702196410e+00 2.754149782700406589e-10 -3.964975144832201703e+00 5.026637529047589679e-11 -4.018884933110267177e+00 3.143305929643995758e-13 -4.073527705875252813e+00 1.294183698307227415e-10 -4.128913429151423564e+00 1.325301148287573817e-10 -4.185052204466100711e+00 3.221520152857290444e-11 -4.241954270692033901e+00 2.483132245049740278e-11 -4.299630005914813147e+00 1.056503921166582367e-10 -4.358089929325681844e+00 2.305868818090390017e-11 -4.417344703140073214e+00 2.895841589492563404e-11 -4.477405134542246756e+00 8.584818287264443991e-11 -4.538282177656349781e+00 9.926241782569738837e-14 -4.599986935544290390e+00 3.741119597472573113e-11 -4.662530662230767398e+00 7.285036743424729161e-12 -4.725924764755838225e+00 3.215760964217458397e-11 -4.790180805255389807e+00 9.223723711481904166e-12 -4.855310503069902417e+00 3.021250618059397195e-11 -4.921325736881876800e+00 3.635677545039932134e-12 -4.988238546882335811e+00 2.950851381487464452e-11 -5.056061136966767400e+00 4.081453558389049457e-13 -5.124805876960936146e+00 5.053391721099129650e-12 -5.194485304876957699e+00 2.095027338612179844e-11 -5.265112129200037572e+00 2.340462533294654313e-12 -5.336699231206313065e+00 8.123001225265392420e-12 -5.409259667312205089e+00 1.584650562630458055e-11 -5.482806671455713321e+00 5.534671903270756929e-13 -5.557353657510086364e+00 1.883825701495966238e-12 -5.632914221730315418e+00 1.248714522192430442e-11 -5.709502145232881354e+00 8.207802240743040657e-12 -5.787131396509233028e+00 3.948022900942526700e-13 -5.865816133973423163e+00 2.432899988168715805e-13 -5.945570708544394734e+00 2.687208354103757800e-12 -6.026409666263374376e+00 4.277744810384879239e-12 -6.108347750946852450e+00 5.101565371459687372e-12 -6.191399906875633796e+00 4.716112247469813512e-12 -6.275581281520448584e+00 4.089703748164791542e-12 -6.360907228304631289e+00 3.524794426310668992e-12 -6.447393309404349182e+00 3.158462606175369107e-12 -6.535055298586910588e+00 2.902336848125582609e-12 -6.623909184087668045e+00 2.691522087255429410e-12 -6.713971171526031512e+00 2.063435902254759041e-12 -6.805257686861128974e+00 1.619307612125451093e-12 -6.897785379387658011e+00 2.255441771974944101e-13 -6.991571124772466561e+00 2.832555534953842601e-14 -7.086632028132422434e+00 6.069240365164520716e-13 -7.182985427154132019e+00 1.359421378030937655e-12 -7.280648895256073061e+00 5.869847908410992465e-13 -7.379640244793725934e+00 6.099414978724654704e-14 -7.479977530308275391e+00 7.254723587427396585e-13 -7.581679051819496529e+00 3.934626156462388790e-13 -7.684763358163396951e+00 6.048911761349038520e-15 -7.789249250375253730e+00 7.094636526136330241e-13 -7.895155785118634029e+00 1.337272943502836473e-13 -8.002502278161051308e+00 3.728911202771460865e-13 -8.111308307896871739e+00 1.124986207411199483e-13 -8.221593718918116522e+00 3.563144531779366504e-13 -8.333378625633820036e+00 1.235077835348040245e-15 -8.446683415938599282e+00 2.534209449113114808e-13 -8.561528754931101659e+00 2.031364880039107376e-13 -8.677935588683004298e+00 3.286018891645796464e-15 -8.795925148059268395e+00 1.085907174023136451e-13 -8.915518952590332447e+00 2.271021171913103088e-13 -9.036738814396949593e+00 1.180882514004609323e-13 -9.159606842168390273e+00 4.190763391671987044e-14 -9.284145445194743829e+00 1.308323808310097664e-15 -9.410377337454033153e+00 1.758610005898305291e-15 -9.538325541754900883e+00 4.961918248527163059e-15 -9.668013393935632749e+00 7.080695840606389510e-15 -9.799464547120258828e+00 6.470854204379273954e-17 -9.932702976032535602e+00 1.178750891509657030e-15 -1.006775298136856733e+01 2.853786184421248321e-14 -1.020463919422890520e+01 4.575538911780519563e-14 -1.034338658061087202e+01 6.903778690960844511e-14 -1.048402044596200433e+01 7.699806884797746069e-15 -1.062656643979537563e+01 5.847065156113201713e-15 -1.077105056036769071e+01 1.160759585288051498e-13 -1.091749915942097360e+01 7.504386924517633606e-17 -1.106593894698873548e+01 6.606155011947836766e-16 -1.121639699626748055e+01 3.947337304085672795e-15 -1.136890074855445754e+01 1.651220143945378967e-15 -1.152347801825253804e+01 1.619492099709994447e-14 -1.168015699794314877e+01 3.063292067011784781e-15 -1.183896626352817449e+01 1.337851617405803086e-14 -1.199993477944177833e+01 1.642238560629258943e-14 -1.216309190393307915e+01 1.767907756163584604e-15 -1.232846739442065953e+01 3.175409477615417111e-16 -1.249609141291986703e+01 1.632799992558896383e-15 -1.266599453154392485e+01 3.322602697518877737e-15 -1.283820773807981830e+01 3.162589929028957580e-15 -1.301276244164000850e+01 2.054635315886267329e-15 -1.318969047839098430e+01 3.043544556714143982e-16 -1.336902411735970198e+01 1.422743656516061290e-16 -1.355079606631897349e+01 4.521282414279517890e-15 -1.373503947775287237e+01 4.254996609867038023e-15 -1.392178795490325349e+01 1.290040393259933655e-15 -1.411107555789848611e+01 1.322414477141368359e-15 -1.430293680996549988e+01 2.443562789731121594e-15 -1.449740670372631612e+01 2.616184429665232512e-16 -1.469452070758017115e+01 2.897176875791105259e-15 -1.489431477217242872e+01 9.725479317581386130e-16 -1.509682533695143292e+01 5.866355720223232368e-17 -1.530208933681452166e+01 1.526461648405563664e-15 -1.551014420884440170e+01 1.737500383507846387e-15 -1.572102789913710730e+01 1.404836680064527809e-15 -1.593477886972280366e+01 1.087546046875415447e-15 -1.615143610558068588e+01 1.019822004274210010e-15 -1.637103912174925568e+01 1.070773260439787044e-15 -1.659362797053326943e+01 9.195763145764453139e-16 -1.681924324880868937e+01 2.439420336844844160e-16 -1.704792610542693154e+01 1.154085771855522734e-16 -1.727971824871981710e+01 8.534527431167114316e-16 -1.751466195410653626e+01 8.942295565580289337e-18 -1.775280007180405306e+01 3.163010566441876702e-16 -1.799417603464234716e+01 6.935723780267376249e-17 -1.823883386598592082e+01 1.071042030092003590e-16 -1.848681818776298158e+01 3.717737325311852422e-16 -1.873817422860383175e+01 3.151831640239248478e-16 -1.899294783208988591e+01 2.100891933674560791e-16 -1.925118546511485462e+01 1.713620905622244520e-16 -1.951293422635962216e+01 1.899057063341581194e-16 -1.977824185488232089e+01 2.286860740372075824e-16 -2.004715673882523319e+01 9.518830675626367271e-17 -2.031972792424006613e+01 3.117985536571925331e-17 -2.059600512403321559e+01 1.074239069680495480e-16 -2.087603872703265750e+01 3.485155760321503407e-17 -2.115987980717810402e+01 2.622030876046057351e-17 -2.144758013283615483e+01 1.080536774909035380e-16 -2.173919217624203526e+01 6.427233257485440113e-17 -2.203476912306977553e+01 1.817061938857929196e-17 -2.233436488213247983e+01 6.465847656251512812e-18 -2.263803409521446497e+01 9.818640420843661984e-18 -2.294583214703713026e+01 2.640701562600458821e-17 -2.325781517536028886e+01 8.105127745606125849e-17 -2.357404008122085770e+01 4.029781869578445686e-18 -2.389456453931075686e+01 1.328831413473196537e-18 -2.421944700849590149e+01 3.127354153740169182e-17 -2.454874674247824373e+01 3.007874769241399462e-18 -2.488252380060274405e+01 1.736254962140798552e-17 -2.522083905881130406e+01 2.554405968085555773e-17 -2.556375422074562564e+01 2.281055686729740443e-17 -2.591133182900102838e+01 2.255325201417957789e-17 -2.626363527653330010e+01 8.462218080240629410e-18 -2.662072881822060211e+01 1.729511425212622060e-18 -2.698267758258260329e+01 8.987627728455088339e-18 -2.734954758365896765e+01 8.265149492930303042e-18 -2.772140573304929134e+01 5.295090228000256500e-18 -2.809831985211681271e+01 1.431657436429345196e-19 -2.848035868435799145e+01 1.837687691572782153e-18 -2.886759190794030161e+01 2.043723500710037062e-18 -2.926009014841048739e+01 5.887702382586123718e-19 -2.965792499157560869e+01 8.288795180695487756e-19 -3.006116899655921770e+01 5.471305569703699445e-18 -3.046989570903505040e+01 4.241424087282446402e-19 -3.088417967464067715e+01 4.369641816903386079e-18 -3.130409645257348572e+01 1.913009389456287463e-18 -3.172972262937157595e+01 3.081819242539703596e-19 -3.216113583288204580e+01 2.366088867849475779e-19 -3.259841474641887515e+01 9.881891841035755976e-19 -3.304163912311403095e+01 3.109461510540446853e-18 -3.349088980046290942e+01 1.199477551081526349e-19 -3.394624871506800190e+01 1.238890121916011092e-18 -3.440779891758290887e+01 1.069304960718572259e-18 -3.487562458785950525e+01 1.061541453003693068e-19 -3.534981105030109205e+01 7.667129781620593189e-20 -3.583044478942431965e+01 3.621784610538438811e-19 -3.631761346563263970e+01 1.574168918153163879e-18 -3.681140593120425564e+01 4.724573267981037557e-20 -3.731191224649747795e+01 1.792613948353079080e-19 -3.781922369637632642e+01 9.685501055201512217e-19 -3.833343280685960508e+01 5.958490508218047199e-19 -3.885463336199617856e+01 8.175220386612768138e-19 -3.938292042096983891e+01 1.033972088754904094e-19 -3.991839033543666915e+01 3.722096060891405738e-19 -4.046114076709811513e+01 6.312284257749575829e-21 -4.101127070551304143e+01 4.814001748085130133e-21 -4.156888048615196141e+01 4.209980816303435524e-19 -4.213407180869668878e+01 6.351580293424730202e-21 -4.270694775558884970e+01 1.371984729888255331e-20 -4.328761281083061618e+01 1.296432985044299651e-19 -4.387617287904095775e+01 4.756901553203897173e-20 -4.447273530477112757e+01 2.129604815008492819e-19 -4.507740889208263724e+01 2.250197696407538897e-19 -4.569030392439155008e+01 1.987119874942307447e-20 -4.631153218458248944e+01 5.473256581289069249e-21 -4.694120697539617026e+01 1.597346346457907741e-19 -4.757944314009413489e+01 1.639843495143668872e-20 -4.822635708340444438e+01 1.196279462791353910e-20 -4.888206679275212707e+01 5.786638067436779745e-20 -4.954669185977838453e+01 4.596975609733410766e-20 -5.022035350215224980e+01 5.894110564072886579e-21 -5.090317458567891862e+01 1.229595049317869903e-20 -5.159527964670862588e+01 6.775800192820293314e-21 -5.229679491485020293e+01 1.899329935305182002e-21 -5.300784833599347934e+01 5.099876104998231470e-20 -5.372856959564470003e+01 3.753825207010319558e-21 -5.445909014257919978e+01 2.626112198348697115e-22 -5.519954321281573328e+01 8.211019892774104681e-21 -5.595006385391668857e+01 2.425998217248500767e-20 -5.671078894961878802e+01 2.425197932305155932e-21 -5.748185724479857583e+01 3.519112317589604245e-22 -5.826340937077747384e+01 4.667666837191140005e-22 -5.905558787097077555e+01 1.550442717714803547e-20 -5.985853722688545986e+01 3.450930183911477384e-24 -6.067240388447144284e+01 2.064188517824290684e-21 -6.149733628083116344e+01 8.589177854217251283e-23 -6.233348487129223514e+01 7.514739709195326962e-21 -6.318100215684827958e+01 2.371759150611493844e-23 -6.404004271197283060e+01 1.456134580372753306e-22 -6.491076321281138917e+01 1.155950603269347914e-21 -6.579332246575683030e+01 4.332416526947445536e-21 -6.668788143641326371e+01 5.082131985939406833e-21 -6.759460327895382648e+01 5.361376521610464176e-21 -6.851365336587750221e+01 1.663304948843390140e-21 -6.944519931817060865e+01 2.809082977344747530e-21 -7.038941103587838199e+01 3.532998663796993886e-21 -7.134646072909217196e+01 2.502741673975676260e-21 -7.231652294935798864e+01 1.665126285831445679e-21 -7.329977462151209977e+01 2.182167056516942238e-22 -7.429639507594950487e+01 5.865443238575437542e-22 -7.530656608133104157e+01 9.313871344614685191e-22 -7.633047187773534858e+01 1.083101482067754828e-21 -7.736829921026146906e+01 7.416996439834608107e-22 -7.842023736308833293e+01 7.199469467658182589e-22 -7.948647819399742787e+01 4.104305182771962657e-22 -8.056721616936468422e+01 5.132487338497676593e-22 -8.166264839962836675e+01 2.780995020589183040e-22 -8.277297467523895591e+01 1.873597564840570368e-22 -8.389839750309798205e+01 7.171362689185365145e-23 -8.503912214349227838e+01 3.444688721692195656e-23 -8.619535664753031767e+01 1.287262503516967741e-21 -8.736731189508770967e+01 3.802401254768906923e-23 -8.855520163326846728e+01 7.427732606249141769e-24 -8.975924251538928900e+01 1.802541257920375526e-22 -9.097965414049393473e+01 5.143396857364147989e-23 -9.221665909340474343e+01 4.018195941272872435e-22 -9.347048298531879595e+01 2.030107426648087623e-22 -9.474135449495605599e+01 2.043080678325657402e-22 -9.602950541026687858e+01 2.345807650112681734e-22 -9.733517067070671658e+01 1.336002895847468352e-22 -9.865858841008557079e+01 7.196067801949256388e-24 -1.000000000000000000e+02 1.002895944086879748e-23 diff --git a/output/tz.txt b/output/tz.txt deleted file mode 100644 index d8fb07b..0000000 --- a/output/tz.txt +++ /dev/null @@ -1,1024 +0,0 @@ -0.000000000000000000e+00 5.000000000000000278e-02 -1.955034213098729226e-04 5.000000000000000278e-02 -3.910068426197458452e-04 5.000000000000000278e-02 -5.865102639296187678e-04 5.000000000000000278e-02 -7.820136852394916904e-04 5.000000000000000278e-02 -9.775171065493646130e-04 5.000000000000000278e-02 -1.173020527859237536e-03 5.000000000000000278e-02 -1.368523949169110458e-03 5.000000000000000278e-02 -1.564027370478983381e-03 5.000000000000000278e-02 -1.759530791788856303e-03 5.000000000000000278e-02 -1.955034213098729226e-03 5.000000000000000278e-02 -2.150537634408602149e-03 5.000000000000000278e-02 -2.346041055718475071e-03 5.000000000000000278e-02 -2.541544477028347994e-03 5.000000000000000278e-02 -2.737047898338220916e-03 5.000000000000000278e-02 -2.932551319648093839e-03 5.000000000000000278e-02 -3.128054740957966762e-03 5.000000000000000278e-02 -3.323558162267839684e-03 5.000000000000000278e-02 -3.519061583577712607e-03 5.000000000000000278e-02 -3.714565004887585530e-03 5.000000000000000278e-02 -3.910068426197458452e-03 5.000000000000000278e-02 -4.105571847507331375e-03 5.000000000000000278e-02 -4.301075268817204297e-03 5.000000000000000278e-02 -4.496578690127077220e-03 5.000000000000000278e-02 -4.692082111436950143e-03 5.000000000000000278e-02 -4.887585532746823065e-03 5.000000000000000278e-02 -5.083088954056695988e-03 5.000000000000000278e-02 -5.278592375366568910e-03 5.000000000000000278e-02 -5.474095796676441833e-03 5.000000000000000278e-02 -5.669599217986314756e-03 5.000000000000000278e-02 -5.865102639296187678e-03 5.000000000000000278e-02 -6.060606060606060601e-03 5.000000000000000278e-02 -6.256109481915933523e-03 5.000000000000000278e-02 -6.451612903225806446e-03 5.000000000000000278e-02 -6.647116324535679369e-03 5.000000000000000278e-02 -6.842619745845552291e-03 5.000000000000000278e-02 -7.038123167155425214e-03 5.000000000000000278e-02 -7.233626588465298136e-03 5.000000000000000278e-02 -7.429130009775171059e-03 5.000000000000000278e-02 -7.624633431085043982e-03 5.000000000000000278e-02 -7.820136852394916904e-03 5.000000000000000278e-02 -8.015640273704788960e-03 5.000000000000000278e-02 -8.211143695014662749e-03 5.000000000000000278e-02 -8.406647116324536539e-03 5.000000000000000278e-02 -8.602150537634408595e-03 5.000000000000000278e-02 -8.797653958944280650e-03 5.000000000000000278e-02 -8.993157380254154440e-03 5.000000000000000278e-02 -9.188660801564028230e-03 5.000000000000000278e-02 -9.384164222873900285e-03 5.000000000000000278e-02 -9.579667644183772340e-03 5.000000000000000278e-02 -9.775171065493646130e-03 5.000000000000000278e-02 -9.970674486803519920e-03 5.000000000000000278e-02 -1.016617790811339198e-02 5.000000000000000278e-02 -1.036168132942326403e-02 5.000000000000000278e-02 -1.055718475073313782e-02 5.000000000000000278e-02 -1.075268817204301161e-02 5.000000000000000278e-02 -1.094819159335288367e-02 5.000000000000000278e-02 -1.114369501466275572e-02 5.000000000000000278e-02 -1.133919843597262951e-02 5.000000000000000278e-02 -1.153470185728250330e-02 5.000000000000000278e-02 -1.173020527859237536e-02 5.000000000000000278e-02 -1.192570869990224741e-02 5.000000000000000278e-02 -1.212121212121212120e-02 5.000000000000000278e-02 -1.231671554252199499e-02 5.000000000000000278e-02 -1.251221896383186705e-02 5.000000000000000278e-02 -1.270772238514173910e-02 5.000000000000000278e-02 -1.290322580645161289e-02 5.000000000000000278e-02 -1.309872922776148668e-02 5.000000000000000278e-02 -1.329423264907135874e-02 5.000000000000000278e-02 -1.348973607038123079e-02 5.000000000000000278e-02 -1.368523949169110458e-02 5.000000000000000278e-02 -1.388074291300097837e-02 5.000000000000000278e-02 -1.407624633431085043e-02 5.000000000000000278e-02 -1.427174975562072248e-02 5.000000000000000278e-02 -1.446725317693059627e-02 5.000000000000000278e-02 -1.466275659824047006e-02 5.000000000000000278e-02 -1.485826001955034212e-02 5.000000000000000278e-02 -1.505376344086021417e-02 5.000000000000000278e-02 -1.524926686217008796e-02 5.000000000000000278e-02 -1.544477028347996175e-02 5.000000000000000278e-02 -1.564027370478983381e-02 5.000000000000000278e-02 -1.583577712609970586e-02 5.000000000000000278e-02 -1.603128054740957792e-02 5.000000000000000278e-02 -1.622678396871945344e-02 5.000000000000000278e-02 -1.642228739002932550e-02 5.000000000000000278e-02 -1.661779081133919755e-02 5.000000000000000278e-02 -1.681329423264907308e-02 5.000000000000000278e-02 -1.700879765395894513e-02 5.000000000000000278e-02 -1.720430107526881719e-02 5.000000000000000278e-02 -1.739980449657868924e-02 5.000000000000000278e-02 -1.759530791788856130e-02 5.000000000000000278e-02 -1.779081133919843682e-02 5.000000000000000278e-02 -1.798631476050830888e-02 5.000000000000000278e-02 -1.818181818181818094e-02 5.000000000000000278e-02 -1.837732160312805646e-02 5.000000000000000278e-02 -1.857282502443792851e-02 5.000000000000000278e-02 -1.876832844574780057e-02 5.000000000000000278e-02 -1.896383186705767263e-02 5.000000000000000278e-02 -1.915933528836754468e-02 5.000000000000000278e-02 -1.935483870967742021e-02 5.000000000000000278e-02 -1.955034213098729226e-02 5.000000000000000278e-02 -1.974584555229716432e-02 5.000000000000000278e-02 -1.994134897360703984e-02 5.000000000000000278e-02 -2.013685239491691190e-02 5.000000000000000278e-02 -2.033235581622678395e-02 5.000000000000000278e-02 -2.052785923753665601e-02 5.000000000000000278e-02 -2.072336265884652806e-02 5.000000000000000278e-02 -2.091886608015640359e-02 5.000000000000000278e-02 -2.111436950146627564e-02 5.000000000000000278e-02 -2.130987292277614770e-02 5.000000000000000278e-02 -2.150537634408602322e-02 5.000000000000000278e-02 -2.170087976539589528e-02 5.000000000000000278e-02 -2.189638318670576733e-02 5.000000000000000278e-02 -2.209188660801563939e-02 5.000000000000000278e-02 -2.228739002932551144e-02 5.000000000000000278e-02 -2.248289345063538697e-02 5.000000000000000278e-02 -2.267839687194525902e-02 5.000000000000000278e-02 -2.287390029325513108e-02 5.000000000000000278e-02 -2.306940371456500660e-02 5.000000000000000278e-02 -2.326490713587487866e-02 5.000000000000000278e-02 -2.346041055718475071e-02 5.000000000000000278e-02 -2.365591397849462277e-02 5.000000000000000278e-02 -2.385141739980449482e-02 5.000000000000000278e-02 -2.404692082111437035e-02 5.000000000000000278e-02 -2.424242424242424240e-02 5.000000000000000278e-02 -2.443792766373411446e-02 5.000000000000000278e-02 -2.463343108504398998e-02 5.000000000000000278e-02 -2.482893450635386204e-02 5.000000000000000278e-02 -2.502443792766373409e-02 5.000000000000000278e-02 -2.521994134897360615e-02 5.000000000000000278e-02 -2.541544477028347820e-02 5.000000000000000278e-02 -2.561094819159335373e-02 5.000000000000000278e-02 -2.580645161290322578e-02 5.000000000000000278e-02 -2.600195503421309784e-02 5.000000000000000278e-02 -2.619745845552297336e-02 5.000000000000000278e-02 -2.639296187683284542e-02 5.000000000000000278e-02 -2.658846529814271747e-02 5.000000000000000278e-02 -2.678396871945258953e-02 5.000000000000000278e-02 -2.697947214076246158e-02 5.000000000000000278e-02 -2.717497556207233711e-02 5.000000000000000278e-02 -2.737047898338220916e-02 5.000000000000000278e-02 -2.756598240469208122e-02 5.000000000000000278e-02 -2.776148582600195674e-02 5.000000000000000278e-02 -2.795698924731182880e-02 5.000000000000000278e-02 -2.815249266862170086e-02 5.000000000000000278e-02 -2.834799608993157291e-02 5.000000000000000278e-02 -2.854349951124144497e-02 5.000000000000000278e-02 -2.873900293255132049e-02 5.000000000000000278e-02 -2.893450635386119255e-02 5.000000000000000278e-02 -2.913000977517106460e-02 5.000000000000000278e-02 -2.932551319648094013e-02 5.000000000000000278e-02 -2.952101661779081218e-02 5.000000000000000278e-02 -2.971652003910068424e-02 5.000000000000000278e-02 -2.991202346041055629e-02 5.000000000000000278e-02 -3.010752688172042835e-02 5.000000000000000278e-02 -3.030303030303030387e-02 5.000000000000000278e-02 -3.049853372434017593e-02 5.000000000000000278e-02 -3.069403714565004798e-02 5.000000000000000278e-02 -3.088954056695992351e-02 5.000000000000000278e-02 -3.108504398826979556e-02 5.000000000000000278e-02 -3.128054740957966762e-02 5.000000000000000278e-02 -3.147605083088954314e-02 5.000000000000000278e-02 -3.167155425219941173e-02 5.000000000000000278e-02 -3.186705767350928725e-02 5.000000000000000278e-02 -3.206256109481915584e-02 5.000000000000000278e-02 -3.225806451612903136e-02 5.000000000000000278e-02 -3.245356793743890689e-02 5.000000000000000278e-02 -3.264907135874877547e-02 5.000000000000000278e-02 -3.284457478005865100e-02 5.000000000000000278e-02 -3.304007820136852652e-02 5.000000000000000278e-02 -3.323558162267839511e-02 5.000000000000000278e-02 -3.343108504398827063e-02 5.000000000000000278e-02 -3.362658846529814616e-02 5.000000000000000278e-02 -3.382209188660801474e-02 5.000000000000000278e-02 -3.401759530791789027e-02 5.000000000000000278e-02 -3.421309872922775885e-02 5.000000000000000278e-02 -3.440860215053763438e-02 5.000000000000000278e-02 -3.460410557184750990e-02 5.000000000000000278e-02 -3.479960899315737849e-02 5.000000000000000278e-02 -3.499511241446725401e-02 5.000000000000000278e-02 -3.519061583577712260e-02 5.000000000000000278e-02 -3.538611925708699812e-02 5.000000000000000278e-02 -3.558162267839687365e-02 5.000000000000000278e-02 -3.577712609970674223e-02 5.000000000000000278e-02 -3.597262952101661776e-02 5.000000000000000278e-02 -3.616813294232649328e-02 5.000000000000000278e-02 -3.636363636363636187e-02 5.000000000000000278e-02 -3.655913978494623739e-02 5.000000000000000278e-02 -3.675464320625611292e-02 5.000000000000000278e-02 -3.695014662756598151e-02 5.000000000000000278e-02 -3.714565004887585703e-02 5.000000000000000278e-02 -3.734115347018572562e-02 5.000000000000000278e-02 -3.753665689149560114e-02 5.000000000000000278e-02 -3.773216031280547667e-02 5.000000000000000278e-02 -3.792766373411534525e-02 5.000000000000000278e-02 -3.812316715542522078e-02 5.000000000000000278e-02 -3.831867057673508936e-02 5.000000000000000278e-02 -3.851417399804496489e-02 5.000000000000000278e-02 -3.870967741935484041e-02 5.000000000000000278e-02 -3.890518084066470900e-02 5.000000000000000278e-02 -3.910068426197458452e-02 5.000000000000000278e-02 -3.929618768328446005e-02 5.000000000000000278e-02 -3.949169110459432863e-02 5.000000000000000278e-02 -3.968719452590420416e-02 5.000000000000000278e-02 -3.988269794721407968e-02 5.000000000000000278e-02 -4.007820136852394827e-02 5.000000000000000278e-02 -4.027370478983382379e-02 5.000000000000000278e-02 -4.046920821114369238e-02 5.000000000000000278e-02 -4.066471163245356790e-02 5.000000000000000278e-02 -4.086021505376344343e-02 5.000000000000000278e-02 -4.105571847507331201e-02 5.000000000000000278e-02 -4.125122189638318754e-02 5.000000000000000278e-02 -4.144672531769305612e-02 5.000000000000000278e-02 -4.164222873900293165e-02 5.000000000000000278e-02 -4.183773216031280717e-02 5.000000000000000278e-02 -4.203323558162267576e-02 5.000000000000000278e-02 -4.222873900293255128e-02 5.000000000000000278e-02 -4.242424242424242681e-02 5.000000000000000278e-02 -4.261974584555229539e-02 5.000000000000000278e-02 -4.281524926686217092e-02 5.000000000000000278e-02 -4.301075268817204644e-02 5.000000000000000278e-02 -4.320625610948191503e-02 5.000000000000000278e-02 -4.340175953079179055e-02 5.000000000000000278e-02 -4.359726295210165914e-02 5.000000000000000278e-02 -4.379276637341153466e-02 5.000000000000000278e-02 -4.398826979472141019e-02 5.000000000000000278e-02 -4.418377321603127877e-02 5.000000000000000278e-02 -4.437927663734115430e-02 5.000000000000000278e-02 -4.457478005865102288e-02 5.000000000000000278e-02 -4.477028347996089841e-02 5.000000000000000278e-02 -4.496578690127077393e-02 5.000000000000000278e-02 -4.516129032258064252e-02 5.000000000000000278e-02 -4.535679374389051804e-02 5.000000000000000278e-02 -4.555229716520039357e-02 5.000000000000000278e-02 -4.574780058651026216e-02 5.000000000000000278e-02 -4.594330400782013768e-02 5.000000000000000278e-02 -4.613880742913001320e-02 5.000000000000000278e-02 -4.633431085043988179e-02 5.000000000000000278e-02 -4.652981427174975732e-02 5.000000000000000278e-02 -4.672531769305962590e-02 5.000000000000000278e-02 -4.692082111436950143e-02 5.000000000000000278e-02 -4.711632453567937695e-02 5.000000000000000278e-02 -4.731182795698924554e-02 5.000000000000000278e-02 -4.750733137829912106e-02 5.000000000000000278e-02 -4.770283479960898965e-02 5.000000000000000278e-02 -4.789833822091886517e-02 5.000000000000000278e-02 -4.809384164222874070e-02 5.000000000000000278e-02 -4.828934506353860928e-02 5.000000000000000278e-02 -4.848484848484848481e-02 5.000000000000000278e-02 -4.868035190615836033e-02 5.000000000000000278e-02 -4.887585532746822892e-02 5.000000000000000278e-02 -4.907135874877810444e-02 5.000000000000000278e-02 -4.926686217008797997e-02 5.000000000000000278e-02 -4.946236559139784855e-02 5.000000000000000278e-02 -4.965786901270772408e-02 5.000000000000000278e-02 -4.985337243401759266e-02 5.000000000000000278e-02 -5.004887585532746819e-02 5.000000000000000278e-02 -5.024437927663734371e-02 5.000000000000000278e-02 -5.043988269794721230e-02 5.000000000000000278e-02 -5.063538611925708782e-02 5.000000000000000278e-02 -5.083088954056695641e-02 5.000000000000000278e-02 -5.102639296187683193e-02 5.000000000000000278e-02 -5.122189638318670746e-02 5.000000000000000278e-02 -5.141739980449657604e-02 5.000000000000000278e-02 -5.161290322580645157e-02 5.000000000000000278e-02 -5.180840664711632709e-02 5.000000000000000278e-02 -5.200391006842619568e-02 5.000000000000000278e-02 -5.219941348973607120e-02 5.000000000000000278e-02 -5.239491691104594673e-02 5.000000000000000278e-02 -5.259042033235581531e-02 5.000000000000000278e-02 -5.278592375366569084e-02 5.000000000000000278e-02 -5.298142717497555942e-02 5.000000000000000278e-02 -5.317693059628543495e-02 5.000000000000000278e-02 -5.337243401759531047e-02 5.000000000000000278e-02 -5.356793743890517906e-02 5.000000000000000278e-02 -5.376344086021505458e-02 5.000000000000000278e-02 -5.395894428152492317e-02 5.000000000000000278e-02 -5.415444770283479869e-02 5.000000000000000278e-02 -5.434995112414467422e-02 5.000000000000000278e-02 -5.454545454545454281e-02 5.000000000000000278e-02 -5.474095796676441833e-02 5.000000000000000278e-02 -5.493646138807429385e-02 5.000000000000000278e-02 -5.513196480938416244e-02 5.000000000000000278e-02 -5.532746823069403797e-02 5.000000000000000278e-02 -5.552297165200391349e-02 5.000000000000000278e-02 -5.571847507331378208e-02 5.000000000000000278e-02 -5.591397849462365760e-02 5.000000000000000278e-02 -5.610948191593352619e-02 5.000000000000000278e-02 -5.630498533724340171e-02 5.000000000000000278e-02 -5.650048875855327724e-02 5.000000000000000278e-02 -5.669599217986314582e-02 5.000000000000000278e-02 -5.689149560117302135e-02 5.000000000000000278e-02 -5.708699902248288993e-02 5.000000000000000278e-02 -5.728250244379276546e-02 5.000000000000000278e-02 -5.747800586510264098e-02 5.000000000000000278e-02 -5.767350928641250957e-02 5.000000000000000278e-02 -5.786901270772238509e-02 5.000000000000000278e-02 -5.806451612903226062e-02 5.000000000000000278e-02 -5.826001955034212920e-02 5.000000000000000278e-02 -5.845552297165200473e-02 5.000000000000000278e-02 -5.865102639296188025e-02 5.000000000000000278e-02 -5.884652981427174884e-02 5.000000000000000278e-02 -5.904203323558162436e-02 5.000000000000000278e-02 -5.923753665689149295e-02 5.000000000000000278e-02 -5.943304007820136847e-02 5.000000000000000278e-02 -5.962854349951124400e-02 5.000000000000000278e-02 -5.982404692082111258e-02 5.000000000000000278e-02 -6.001955034213098811e-02 5.000000000000000278e-02 -6.021505376344085669e-02 5.000000000000000278e-02 -6.041055718475073222e-02 5.000000000000000278e-02 -6.060606060606060774e-02 5.000000000000000278e-02 -6.080156402737047633e-02 5.000000000000000278e-02 -6.099706744868035185e-02 5.000000000000000278e-02 -6.119257086999022738e-02 5.000000000000000278e-02 -6.138807429130009596e-02 5.000000000000000278e-02 -6.158357771260997149e-02 5.000000000000000278e-02 -6.177908113391984701e-02 5.000000000000000278e-02 -6.197458455522971560e-02 5.000000000000000278e-02 -6.217008797653959112e-02 5.000000000000000278e-02 -6.236559139784945971e-02 5.000000000000000278e-02 -6.256109481915933523e-02 5.000000000000000278e-02 -6.275659824046921076e-02 5.000000000000000278e-02 -6.295210166177908628e-02 5.000000000000000278e-02 -6.314760508308894793e-02 5.000000000000000278e-02 -6.334310850439882346e-02 5.000000000000000278e-02 -6.353861192570869898e-02 5.000000000000000278e-02 -6.373411534701857450e-02 5.000000000000000278e-02 -6.392961876832845003e-02 5.000000000000000278e-02 -6.412512218963831168e-02 5.000000000000000278e-02 -6.432062561094818720e-02 5.000000000000000278e-02 -6.451612903225806273e-02 5.000000000000000278e-02 -6.471163245356793825e-02 5.000000000000000278e-02 -6.490713587487781377e-02 5.000000000000000278e-02 -6.510263929618768930e-02 5.000000000000000278e-02 -6.529814271749755095e-02 5.000000000000000278e-02 -6.549364613880742647e-02 5.000000000000000278e-02 -6.568914956011730200e-02 5.000000000000000278e-02 -6.588465298142717752e-02 5.000000000000000278e-02 -6.608015640273705305e-02 5.000000000000000278e-02 -6.627565982404691469e-02 5.000000000000000278e-02 -6.647116324535679022e-02 5.000000000000000278e-02 -6.666666666666666574e-02 5.000000000000000278e-02 -6.686217008797654127e-02 5.000000000000000278e-02 -6.705767350928641679e-02 5.000000000000000278e-02 -6.725317693059629232e-02 5.000000000000000278e-02 -6.744868035190615396e-02 5.000000000000000278e-02 -6.764418377321602949e-02 5.000000000000000278e-02 -6.783968719452590501e-02 5.000000000000000278e-02 -6.803519061583578054e-02 5.000000000000000278e-02 -6.823069403714565606e-02 5.000000000000000278e-02 -6.842619745845551771e-02 5.000000000000000278e-02 -6.862170087976539323e-02 5.000000000000000278e-02 -6.881720430107526876e-02 5.000000000000000278e-02 -6.901270772238514428e-02 5.000000000000000278e-02 -6.920821114369501981e-02 5.000000000000000278e-02 -6.940371456500488145e-02 5.000000000000000278e-02 -6.959921798631475698e-02 5.000000000000000278e-02 -6.979472140762463250e-02 5.000000000000000278e-02 -6.999022482893450803e-02 5.000000000000000278e-02 -7.018572825024438355e-02 5.000000000000000278e-02 -7.038123167155424520e-02 5.000000000000000278e-02 -7.057673509286412072e-02 5.000000000000000278e-02 -7.077223851417399625e-02 5.000000000000000278e-02 -7.096774193548387177e-02 5.000000000000000278e-02 -7.116324535679374730e-02 5.000000000000000278e-02 -7.135874877810362282e-02 5.000000000000000278e-02 -7.155425219941348447e-02 5.000000000000000278e-02 -7.174975562072335999e-02 5.000000000000000278e-02 -7.194525904203323552e-02 5.000000000000000278e-02 -7.214076246334311104e-02 5.000000000000000278e-02 -7.233626588465298657e-02 5.000000000000000278e-02 -7.253176930596284822e-02 5.000000000000000278e-02 -7.272727272727272374e-02 5.000000000000000278e-02 -7.292277614858259926e-02 5.000000000000000278e-02 -7.311827956989247479e-02 5.000000000000000278e-02 -7.331378299120235031e-02 5.000000000000000278e-02 -7.350928641251222584e-02 5.000000000000000278e-02 -7.370478983382208749e-02 5.000000000000000278e-02 -7.390029325513196301e-02 5.000000000000000278e-02 -7.409579667644183854e-02 5.000000000000000278e-02 -7.429130009775171406e-02 5.000000000000000278e-02 -7.448680351906158958e-02 5.000000000000000278e-02 -7.468230694037145123e-02 5.000000000000000278e-02 -7.487781036168132676e-02 5.000000000000000278e-02 -7.507331378299120228e-02 5.000000000000000278e-02 -7.526881720430107781e-02 5.000000000000000278e-02 -7.546432062561095333e-02 5.000000000000000278e-02 -7.565982404692081498e-02 5.000000000000000278e-02 -7.585532746823069050e-02 5.000000000000000278e-02 -7.605083088954056603e-02 5.000000000000000278e-02 -7.624633431085044155e-02 5.000000000000000278e-02 -7.644183773216031708e-02 5.000000000000000278e-02 -7.663734115347017872e-02 5.000000000000000278e-02 -7.683284457478005425e-02 5.000000000000000278e-02 -7.702834799608992977e-02 5.000000000000000278e-02 -7.722385141739980530e-02 5.000000000000000278e-02 -7.741935483870968082e-02 5.000000000000000278e-02 -7.761485826001955635e-02 5.000000000000000278e-02 -7.781036168132941799e-02 5.000000000000000278e-02 -7.800586510263929352e-02 5.000000000000000278e-02 -7.820136852394916904e-02 5.000000000000000278e-02 -7.839687194525904457e-02 5.000000000000000278e-02 -7.859237536656892009e-02 5.000000000000000278e-02 -7.878787878787878174e-02 5.000000000000000278e-02 -7.898338220918865726e-02 5.000000000000000278e-02 -7.917888563049853279e-02 5.000000000000000278e-02 -7.937438905180840831e-02 5.000000000000000278e-02 -7.956989247311828384e-02 5.000000000000000278e-02 -7.976539589442815936e-02 5.000000000000000278e-02 -7.996089931573802101e-02 5.000000000000000278e-02 -8.015640273704789653e-02 5.000000000000000278e-02 -8.035190615835777206e-02 5.000000000000000278e-02 -8.054740957966764758e-02 5.000000000000000278e-02 -8.074291300097752311e-02 5.000000000000000278e-02 -8.093841642228738475e-02 5.000000000000000278e-02 -8.113391984359726028e-02 5.000000000000000278e-02 -8.132942326490713580e-02 5.000000000000000278e-02 -8.152492668621701133e-02 5.000000000000000278e-02 -8.172043010752688685e-02 5.000000000000000278e-02 -8.191593352883674850e-02 5.000000000000000278e-02 -8.211143695014662403e-02 5.000000000000000278e-02 -8.230694037145649955e-02 5.000000000000000278e-02 -8.250244379276637507e-02 5.000000000000000278e-02 -8.269794721407625060e-02 5.000000000000000278e-02 -8.289345063538611225e-02 5.000000000000000278e-02 -8.308895405669598777e-02 5.000000000000000278e-02 -8.328445747800586330e-02 5.000000000000000278e-02 -8.347996089931573882e-02 5.000000000000000278e-02 -8.367546432062561435e-02 5.000000000000000278e-02 -8.387096774193548987e-02 5.000000000000000278e-02 -8.406647116324535152e-02 5.000000000000000278e-02 -8.426197458455522704e-02 5.000000000000000278e-02 -8.445747800586510257e-02 5.000000000000000278e-02 -8.465298142717497809e-02 5.000000000000000278e-02 -8.484848484848485362e-02 5.000000000000000278e-02 -8.504398826979471526e-02 5.000000000000000278e-02 -8.523949169110459079e-02 5.000000000000000278e-02 -8.543499511241446631e-02 5.000000000000000278e-02 -8.563049853372434184e-02 5.000000000000000278e-02 -8.582600195503421736e-02 5.000000000000000278e-02 -8.602150537634409289e-02 5.000000000000000278e-02 -8.621700879765395453e-02 5.000000000000000278e-02 -8.641251221896383006e-02 5.000000000000000278e-02 -8.660801564027370558e-02 5.000000000000000278e-02 -8.680351906158358111e-02 5.000000000000000278e-02 -8.699902248289345663e-02 5.000000000000000278e-02 -8.719452590420331828e-02 5.000000000000000278e-02 -8.739002932551319380e-02 5.000000000000000278e-02 -8.758553274682306933e-02 5.000000000000000278e-02 -8.778103616813294485e-02 5.000000000000000278e-02 -8.797653958944282038e-02 5.000000000000000278e-02 -8.817204301075268202e-02 5.000000000000000278e-02 -8.836754643206255755e-02 5.000000000000000278e-02 -8.856304985337243307e-02 5.000000000000000278e-02 -8.875855327468230860e-02 5.000000000000000278e-02 -8.895405669599218412e-02 5.000000000000000278e-02 -8.914956011730204577e-02 5.000000000000000278e-02 -8.934506353861192129e-02 5.000000000000000278e-02 -8.954056695992179682e-02 5.000000000000000278e-02 -8.973607038123167234e-02 5.000000000000000278e-02 -8.993157380254154787e-02 5.000000000000000278e-02 -9.012707722385142339e-02 5.000000000000000278e-02 -9.032258064516128504e-02 5.000000000000000278e-02 -9.051808406647116056e-02 5.000000000000000278e-02 -9.071358748778103609e-02 5.000000000000000278e-02 -9.090909090909091161e-02 5.000000000000000278e-02 -9.110459433040078714e-02 5.000000000000000278e-02 -9.130009775171064879e-02 5.000000000000000278e-02 -9.149560117302052431e-02 5.000000000000000278e-02 -9.169110459433039984e-02 5.000000000000000278e-02 -9.188660801564027536e-02 5.000000000000000278e-02 -9.208211143695015088e-02 5.000000000000000278e-02 -9.227761485826002641e-02 5.000000000000000278e-02 -9.247311827956988806e-02 5.000000000000000278e-02 -9.266862170087976358e-02 5.000000000000000278e-02 -9.286412512218963911e-02 5.000000000000000278e-02 -9.305962854349951463e-02 5.000000000000000278e-02 -9.325513196480939015e-02 5.000000000000000278e-02 -9.345063538611925180e-02 5.000000000000000278e-02 -9.364613880742912733e-02 5.000000000000000278e-02 -9.384164222873900285e-02 5.000000000000000278e-02 -9.403714565004887838e-02 5.000000000000000278e-02 -9.423264907135875390e-02 5.000000000000000278e-02 -9.442815249266861555e-02 5.000000000000000278e-02 -9.462365591397849107e-02 5.000000000000000278e-02 -9.481915933528836660e-02 5.000000000000000278e-02 -9.501466275659824212e-02 5.000000000000000278e-02 -9.521016617790811765e-02 5.000000000000000278e-02 -9.540566959921797929e-02 5.000000000000000278e-02 -9.560117302052785482e-02 5.000000000000000278e-02 -9.579667644183773034e-02 5.000000000000000278e-02 -9.599217986314760587e-02 5.000000000000000278e-02 -9.618768328445748139e-02 5.000000000000000278e-02 -9.638318670576735692e-02 5.000000000000000278e-02 -9.657869012707721856e-02 5.000000000000000278e-02 -9.677419354838709409e-02 5.000000000000000278e-02 -9.696969696969696961e-02 5.000000000000000278e-02 -9.716520039100684514e-02 5.000000000000000278e-02 -9.736070381231672066e-02 5.000000000000000278e-02 -9.755620723362658231e-02 5.000000000000000278e-02 -9.775171065493645783e-02 5.000000000000000278e-02 -9.794721407624633336e-02 5.000000000000000278e-02 -9.814271749755620888e-02 5.000000000000000278e-02 -9.833822091886608441e-02 5.000000000000000278e-02 -9.853372434017595993e-02 5.000000000000000278e-02 -9.872922776148582158e-02 5.000000000000000278e-02 -9.892473118279569710e-02 5.000000000000000278e-02 -9.912023460410557263e-02 5.000000000000000278e-02 -9.931573802541544815e-02 5.000000000000000278e-02 -9.951124144672532368e-02 5.000000000000000278e-02 -9.970674486803518533e-02 5.000000000000000278e-02 -9.990224828934506085e-02 5.000000000000000278e-02 -1.000977517106549364e-01 5.000000000000000278e-02 -1.002932551319648119e-01 5.000000000000000278e-02 -1.004887585532746874e-01 5.000000000000000278e-02 -1.006842619745845491e-01 5.000000000000000278e-02 -1.008797653958944246e-01 5.000000000000000278e-02 -1.010752688172043001e-01 5.000000000000000278e-02 -1.012707722385141756e-01 5.000000000000000278e-02 -1.014662756598240512e-01 5.000000000000000278e-02 -1.016617790811339128e-01 5.000000000000000278e-02 -1.018572825024437883e-01 5.000000000000000278e-02 -1.020527859237536639e-01 5.000000000000000278e-02 -1.022482893450635394e-01 5.000000000000000278e-02 -1.024437927663734149e-01 5.000000000000000278e-02 -1.026392961876832904e-01 5.000000000000000278e-02 -1.028347996089931521e-01 5.000000000000000278e-02 -1.030303030303030276e-01 5.000000000000000278e-02 -1.032258064516129031e-01 5.000000000000000278e-02 -1.034213098729227787e-01 5.000000000000000278e-02 -1.036168132942326542e-01 5.000000000000000278e-02 -1.038123167155425158e-01 5.000000000000000278e-02 -1.040078201368523914e-01 5.000000000000000278e-02 -1.042033235581622669e-01 5.000000000000000278e-02 -1.043988269794721424e-01 5.000000000000000278e-02 -1.045943304007820179e-01 5.000000000000000278e-02 -1.047898338220918935e-01 5.000000000000000278e-02 -1.049853372434017551e-01 5.000000000000000278e-02 -1.051808406647116306e-01 5.000000000000000278e-02 -1.053763440860215062e-01 5.000000000000000278e-02 -1.055718475073313817e-01 5.000000000000000278e-02 -1.057673509286412572e-01 5.000000000000000278e-02 -1.059628543499511188e-01 5.000000000000000278e-02 -1.061583577712609944e-01 5.000000000000000278e-02 -1.063538611925708699e-01 5.000000000000000278e-02 -1.065493646138807454e-01 5.000000000000000278e-02 -1.067448680351906209e-01 5.000000000000000278e-02 -1.069403714565004826e-01 5.000000000000000278e-02 -1.071358748778103581e-01 5.000000000000000278e-02 -1.073313782991202336e-01 5.000000000000000278e-02 -1.075268817204301092e-01 5.000000000000000278e-02 -1.077223851417399847e-01 5.000000000000000278e-02 -1.079178885630498463e-01 5.000000000000000278e-02 -1.081133919843597219e-01 5.000000000000000278e-02 -1.083088954056695974e-01 5.000000000000000278e-02 -1.085043988269794729e-01 5.000000000000000278e-02 -1.086999022482893484e-01 5.000000000000000278e-02 -1.088954056695992240e-01 5.000000000000000278e-02 -1.090909090909090856e-01 5.000000000000000278e-02 -1.092864125122189611e-01 5.000000000000000278e-02 -1.094819159335288367e-01 5.000000000000000278e-02 -1.096774193548387122e-01 5.000000000000000278e-02 -1.098729227761485877e-01 5.000000000000000278e-02 -1.100684261974584494e-01 5.000000000000000278e-02 -1.102639296187683249e-01 5.000000000000000278e-02 -1.104594330400782004e-01 5.000000000000000278e-02 -1.106549364613880759e-01 5.000000000000000278e-02 -1.108504398826979515e-01 5.000000000000000278e-02 -1.110459433040078270e-01 5.000000000000000278e-02 -1.112414467253176886e-01 5.000000000000000278e-02 -1.114369501466275642e-01 5.000000000000000278e-02 -1.116324535679374397e-01 5.000000000000000278e-02 -1.118279569892473152e-01 5.000000000000000278e-02 -1.120234604105571907e-01 5.000000000000000278e-02 -1.122189638318670524e-01 5.000000000000000278e-02 -1.124144672531769279e-01 5.000000000000000278e-02 -1.126099706744868034e-01 5.000000000000000278e-02 -1.128054740957966789e-01 5.000000000000000278e-02 -1.130009775171065545e-01 5.000000000000000278e-02 -1.131964809384164161e-01 5.000000000000000278e-02 -1.133919843597262916e-01 5.000000000000000278e-02 -1.135874877810361672e-01 5.000000000000000278e-02 -1.137829912023460427e-01 5.000000000000000278e-02 -1.139784946236559182e-01 5.000000000000000278e-02 -1.141739980449657799e-01 5.000000000000000278e-02 -1.143695014662756554e-01 5.000000000000000278e-02 -1.145650048875855309e-01 5.000000000000000278e-02 -1.147605083088954064e-01 5.000000000000000278e-02 -1.149560117302052820e-01 5.000000000000000278e-02 -1.151515151515151575e-01 5.000000000000000278e-02 -1.153470185728250191e-01 5.000000000000000278e-02 -1.155425219941348947e-01 5.000000000000000278e-02 -1.157380254154447702e-01 5.000000000000000278e-02 -1.159335288367546457e-01 5.000000000000000278e-02 -1.161290322580645212e-01 5.000000000000000278e-02 -1.163245356793743829e-01 5.000000000000000278e-02 -1.165200391006842584e-01 5.000000000000000278e-02 -1.167155425219941339e-01 5.000000000000000278e-02 -1.169110459433040095e-01 5.000000000000000278e-02 -1.171065493646138850e-01 5.000000000000000278e-02 -1.173020527859237605e-01 5.000000000000000278e-02 -1.174975562072336221e-01 5.000000000000000278e-02 -1.176930596285434977e-01 5.000000000000000278e-02 -1.178885630498533732e-01 5.000000000000000278e-02 -1.180840664711632487e-01 5.000000000000000278e-02 -1.182795698924731242e-01 5.000000000000000278e-02 -1.184750733137829859e-01 5.000000000000000278e-02 -1.186705767350928614e-01 5.000000000000000278e-02 -1.188660801564027369e-01 5.000000000000000278e-02 -1.190615835777126125e-01 5.000000000000000278e-02 -1.192570869990224880e-01 5.000000000000000278e-02 -1.194525904203323496e-01 5.000000000000000278e-02 -1.196480938416422252e-01 5.000000000000000278e-02 -1.198435972629521007e-01 5.000000000000000278e-02 -1.200391006842619762e-01 5.000000000000000278e-02 -1.202346041055718517e-01 5.000000000000000278e-02 -1.204301075268817134e-01 5.000000000000000278e-02 -1.206256109481915889e-01 5.000000000000000278e-02 -1.208211143695014644e-01 5.000000000000000278e-02 -1.210166177908113400e-01 5.000000000000000278e-02 -1.212121212121212155e-01 5.000000000000000278e-02 -1.214076246334310910e-01 5.000000000000000278e-02 -1.216031280547409527e-01 5.000000000000000278e-02 -1.217986314760508282e-01 5.000000000000000278e-02 -1.219941348973607037e-01 5.000000000000000278e-02 -1.221896383186705792e-01 5.000000000000000278e-02 -1.223851417399804548e-01 5.000000000000000278e-02 -1.225806451612903164e-01 5.000000000000000278e-02 -1.227761485826001919e-01 5.000000000000000278e-02 -1.229716520039100675e-01 5.000000000000000278e-02 -1.231671554252199430e-01 5.000000000000000278e-02 -1.233626588465298185e-01 5.000000000000000278e-02 -1.235581622678396940e-01 5.000000000000000278e-02 -1.237536656891495557e-01 5.000000000000000278e-02 -1.239491691104594312e-01 5.000000000000000278e-02 -1.241446725317693067e-01 5.000000000000000278e-02 -1.243401759530791822e-01 5.000000000000000278e-02 -1.245356793743890578e-01 5.000000000000000278e-02 -1.247311827956989194e-01 5.000000000000000278e-02 -1.249266862170087949e-01 5.000000000000000278e-02 -1.251221896383186705e-01 5.000000000000000278e-02 -1.253176930596285321e-01 5.000000000000000278e-02 -1.255131964809384215e-01 5.000000000000000278e-02 -1.257086999022482832e-01 5.000000000000000278e-02 -1.259042033235581726e-01 5.000000000000000278e-02 -1.260997067448680342e-01 5.000000000000000278e-02 -1.262952101661778959e-01 5.000000000000000278e-02 -1.264907135874877853e-01 5.000000000000000278e-02 -1.266862170087976469e-01 5.000000000000000278e-02 -1.268817204301075363e-01 5.000000000000000278e-02 -1.270772238514173980e-01 5.000000000000000278e-02 -1.272727272727272596e-01 5.000000000000000278e-02 -1.274682306940371490e-01 5.000000000000000278e-02 -1.276637341153470107e-01 5.000000000000000278e-02 -1.278592375366569001e-01 5.000000000000000278e-02 -1.280547409579667617e-01 5.000000000000000278e-02 -1.282502443792766234e-01 5.000000000000000278e-02 -1.284457478005865128e-01 5.000000000000000278e-02 -1.286412512218963744e-01 5.000000000000000278e-02 -1.288367546432062638e-01 5.000000000000000278e-02 -1.290322580645161255e-01 5.000000000000000278e-02 -1.292277614858260149e-01 5.000000000000000278e-02 -1.294232649071358765e-01 5.000000000000000278e-02 -1.296187683284457381e-01 5.000000000000000278e-02 -1.298142717497556275e-01 5.000000000000000278e-02 -1.300097751710654892e-01 5.000000000000000278e-02 -1.302052785923753786e-01 5.000000000000000278e-02 -1.304007820136852402e-01 5.000000000000000278e-02 -1.305962854349951019e-01 5.000000000000000278e-02 -1.307917888563049913e-01 5.000000000000000278e-02 -1.309872922776148529e-01 5.000000000000000278e-02 -1.311827956989247423e-01 5.000000000000000278e-02 -1.313782991202346040e-01 5.000000000000000278e-02 -1.315738025415444656e-01 5.000000000000000278e-02 -1.317693059628543550e-01 5.000000000000000278e-02 -1.319648093841642167e-01 5.000000000000000278e-02 -1.321603128054741061e-01 5.000000000000000278e-02 -1.323558162267839677e-01 5.000000000000000278e-02 -1.325513196480938294e-01 5.000000000000000278e-02 -1.327468230694037188e-01 5.000000000000000278e-02 -1.329423264907135804e-01 5.000000000000000278e-02 -1.331378299120234698e-01 5.000000000000000278e-02 -1.333333333333333315e-01 5.000000000000000278e-02 -1.335288367546431931e-01 5.000000000000000278e-02 -1.337243401759530825e-01 5.000000000000000278e-02 -1.339198435972629442e-01 5.000000000000000278e-02 -1.341153470185728336e-01 5.000000000000000278e-02 -1.343108504398826952e-01 5.000000000000000278e-02 -1.345063538611925846e-01 5.000000000000000278e-02 -1.347018572825024463e-01 5.000000000000000278e-02 -1.348973607038123079e-01 5.000000000000000278e-02 -1.350928641251221973e-01 5.000000000000000278e-02 -1.352883675464320590e-01 5.000000000000000278e-02 -1.354838709677419484e-01 5.000000000000000278e-02 -1.356793743890518100e-01 5.000000000000000278e-02 -1.358748778103616717e-01 5.000000000000000278e-02 -1.360703812316715611e-01 5.000000000000000278e-02 -1.362658846529814227e-01 5.000000000000000278e-02 -1.364613880742913121e-01 5.000000000000000278e-02 -1.366568914956011738e-01 5.000000000000000278e-02 -1.368523949169110354e-01 5.000000000000000278e-02 -1.370478983382209248e-01 5.000000000000000278e-02 -1.372434017595307865e-01 5.000000000000000278e-02 -1.374389051808406759e-01 5.000000000000000278e-02 -1.376344086021505375e-01 5.000000000000000278e-02 -1.378299120234603992e-01 5.000000000000000278e-02 -1.380254154447702886e-01 5.000000000000000278e-02 -1.382209188660801502e-01 5.000000000000000278e-02 -1.384164222873900396e-01 5.000000000000000278e-02 -1.386119257086999013e-01 5.000000000000000278e-02 -1.388074291300097629e-01 5.000000000000000278e-02 -1.390029325513196523e-01 5.000000000000000278e-02 -1.391984359726295140e-01 5.000000000000000278e-02 -1.393939393939394034e-01 5.000000000000000278e-02 -1.395894428152492650e-01 5.000000000000000278e-02 -1.397849462365591267e-01 5.000000000000000278e-02 -1.399804496578690161e-01 5.000000000000000278e-02 -1.401759530791788777e-01 5.000000000000000278e-02 -1.403714565004887671e-01 5.000000000000000278e-02 -1.405669599217986288e-01 5.000000000000000278e-02 -1.407624633431084904e-01 5.000000000000000278e-02 -1.409579667644183798e-01 5.000000000000000278e-02 -1.411534701857282414e-01 5.000000000000000278e-02 -1.413489736070381309e-01 5.000000000000000278e-02 -1.415444770283479925e-01 5.000000000000000278e-02 -1.417399804496578819e-01 5.000000000000000278e-02 -1.419354838709677435e-01 5.000000000000000278e-02 -1.421309872922776052e-01 5.000000000000000278e-02 -1.423264907135874946e-01 5.000000000000000278e-02 -1.425219941348973562e-01 5.000000000000000278e-02 -1.427174975562072456e-01 5.000000000000000278e-02 -1.429130009775171073e-01 5.000000000000000278e-02 -1.431085043988269689e-01 5.000000000000000278e-02 -1.433040078201368583e-01 5.000000000000000278e-02 -1.434995112414467200e-01 5.000000000000000278e-02 -1.436950146627566094e-01 5.000000000000000278e-02 -1.438905180840664710e-01 5.000000000000000278e-02 -1.440860215053763327e-01 5.000000000000000278e-02 -1.442815249266862221e-01 5.000000000000000278e-02 -1.444770283479960837e-01 5.000000000000000278e-02 -1.446725317693059731e-01 5.000000000000000278e-02 -1.448680351906158348e-01 5.000000000000000278e-02 -1.450635386119256964e-01 5.000000000000000278e-02 -1.452590420332355858e-01 5.000000000000000278e-02 -1.454545454545454475e-01 5.000000000000000278e-02 -1.456500488758553369e-01 5.000000000000000278e-02 -1.458455522971651985e-01 5.000000000000000278e-02 -1.460410557184750602e-01 5.000000000000000278e-02 -1.462365591397849496e-01 5.000000000000000278e-02 -1.464320625610948112e-01 5.000000000000000278e-02 -1.466275659824047006e-01 5.000000000000000278e-02 -1.468230694037145623e-01 5.000000000000000278e-02 -1.470185728250244517e-01 5.000000000000000278e-02 -1.472140762463343133e-01 5.000000000000000278e-02 -1.474095796676441750e-01 5.000000000000000278e-02 -1.476050830889540644e-01 5.000000000000000278e-02 -1.478005865102639260e-01 5.000000000000000278e-02 -1.479960899315738154e-01 5.000000000000000278e-02 -1.481915933528836771e-01 5.000000000000000278e-02 -1.483870967741935387e-01 5.000000000000000278e-02 -1.485826001955034281e-01 5.000000000000000278e-02 -1.487781036168132898e-01 5.000000000000000278e-02 -1.489736070381231792e-01 5.000000000000000278e-02 -1.491691104594330408e-01 5.000000000000000278e-02 -1.493646138807429025e-01 5.000000000000000278e-02 -1.495601173020527919e-01 5.000000000000000278e-02 -1.497556207233626535e-01 5.000000000000000278e-02 -1.499511241446725429e-01 5.000000000000000278e-02 -1.501466275659824046e-01 5.000000000000000278e-02 -1.503421309872922662e-01 5.000000000000000278e-02 -1.505376344086021556e-01 5.000000000000000278e-02 -1.507331378299120173e-01 5.000000000000000278e-02 -1.509286412512219067e-01 5.000000000000000278e-02 -1.511241446725317683e-01 5.000000000000000278e-02 -1.513196480938416300e-01 5.000000000000000278e-02 -1.515151515151515194e-01 5.000000000000000278e-02 -1.517106549364613810e-01 5.000000000000000278e-02 -1.519061583577712704e-01 5.000000000000000278e-02 -1.521016617790811321e-01 5.000000000000000278e-02 -1.522971652003909937e-01 5.000000000000000278e-02 -1.524926686217008831e-01 5.000000000000000278e-02 -1.526881720430107447e-01 5.000000000000000278e-02 -1.528836754643206342e-01 5.000000000000000278e-02 -1.530791788856304958e-01 5.000000000000000278e-02 -1.532746823069403574e-01 5.000000000000000278e-02 -1.534701857282502468e-01 5.000000000000000278e-02 -1.536656891495601085e-01 5.000000000000000278e-02 -1.538611925708699979e-01 5.000000000000000278e-02 -1.540566959921798595e-01 5.000000000000000278e-02 -1.542521994134897489e-01 5.000000000000000278e-02 -1.544477028347996106e-01 5.000000000000000278e-02 -1.546432062561094722e-01 5.000000000000000278e-02 -1.548387096774193616e-01 5.000000000000000278e-02 -1.550342130987292233e-01 5.000000000000000278e-02 -1.552297165200391127e-01 5.000000000000000278e-02 -1.554252199413489743e-01 5.000000000000000278e-02 -1.556207233626588360e-01 5.000000000000000278e-02 -1.558162267839687254e-01 5.000000000000000278e-02 -1.560117302052785870e-01 5.000000000000000278e-02 -1.562072336265884764e-01 5.000000000000000278e-02 -1.564027370478983381e-01 5.000000000000000278e-02 -1.565982404692081997e-01 5.000000000000000278e-02 -1.567937438905180891e-01 5.000000000000000278e-02 -1.569892473118279508e-01 5.000000000000000278e-02 -1.571847507331378402e-01 5.000000000000000278e-02 -1.573802541544477018e-01 5.000000000000000278e-02 -1.575757575757575635e-01 5.000000000000000278e-02 -1.577712609970674529e-01 5.000000000000000278e-02 -1.579667644183773145e-01 5.000000000000000278e-02 -1.581622678396872039e-01 5.000000000000000278e-02 -1.583577712609970656e-01 5.000000000000000278e-02 -1.585532746823069272e-01 5.000000000000000278e-02 -1.587487781036168166e-01 5.000000000000000278e-02 -1.589442815249266783e-01 5.000000000000000278e-02 -1.591397849462365677e-01 5.000000000000000278e-02 -1.593352883675464293e-01 5.000000000000000278e-02 -1.595307917888563187e-01 5.000000000000000278e-02 -1.597262952101661804e-01 5.000000000000000278e-02 -1.599217986314760420e-01 5.000000000000000278e-02 -1.601173020527859314e-01 5.000000000000000278e-02 -1.603128054740957931e-01 5.000000000000000278e-02 -1.605083088954056825e-01 5.000000000000000278e-02 -1.607038123167155441e-01 5.000000000000000278e-02 -1.608993157380254058e-01 5.000000000000000278e-02 -1.610948191593352952e-01 5.000000000000000278e-02 -1.612903225806451568e-01 5.000000000000000278e-02 -1.614858260019550462e-01 5.000000000000000278e-02 -1.616813294232649079e-01 5.000000000000000278e-02 -1.618768328445747695e-01 5.000000000000000278e-02 -1.620723362658846589e-01 5.000000000000000278e-02 -1.622678396871945206e-01 5.000000000000000278e-02 -1.624633431085044100e-01 5.000000000000000278e-02 -1.626588465298142716e-01 5.000000000000000278e-02 -1.628543499511241333e-01 5.000000000000000278e-02 -1.630498533724340227e-01 5.000000000000000278e-02 -1.632453567937438843e-01 5.000000000000000278e-02 -1.634408602150537737e-01 5.000000000000000278e-02 -1.636363636363636354e-01 5.000000000000000278e-02 -1.638318670576734970e-01 5.000000000000000278e-02 -1.640273704789833864e-01 5.000000000000000278e-02 -1.642228739002932481e-01 5.000000000000000278e-02 -1.644183773216031375e-01 5.000000000000000278e-02 -1.646138807429129991e-01 5.000000000000000278e-02 -1.648093841642228607e-01 5.000000000000000278e-02 -1.650048875855327501e-01 5.000000000000000278e-02 -1.652003910068426118e-01 5.000000000000000278e-02 -1.653958944281525012e-01 5.000000000000000278e-02 -1.655913978494623628e-01 5.000000000000000278e-02 -1.657869012707722245e-01 5.000000000000000278e-02 -1.659824046920821139e-01 5.000000000000000278e-02 -1.661779081133919755e-01 5.000000000000000278e-02 -1.663734115347018649e-01 5.000000000000000278e-02 -1.665689149560117266e-01 5.000000000000000278e-02 -1.667644183773216160e-01 5.000000000000000278e-02 -1.669599217986314776e-01 5.000000000000000278e-02 -1.671554252199413393e-01 5.000000000000000278e-02 -1.673509286412512287e-01 5.000000000000000278e-02 -1.675464320625610903e-01 5.000000000000000278e-02 -1.677419354838709797e-01 5.000000000000000278e-02 -1.679374389051808414e-01 5.000000000000000278e-02 -1.681329423264907030e-01 5.000000000000000278e-02 -1.683284457478005924e-01 5.000000000000000278e-02 -1.685239491691104541e-01 5.000000000000000278e-02 -1.687194525904203435e-01 5.000000000000000278e-02 -1.689149560117302051e-01 5.000000000000000278e-02 -1.691104594330400668e-01 5.000000000000000278e-02 -1.693059628543499562e-01 5.000000000000000278e-02 -1.695014662756598178e-01 5.000000000000000278e-02 -1.696969696969697072e-01 5.000000000000000278e-02 -1.698924731182795689e-01 5.000000000000000278e-02 -1.700879765395894305e-01 5.000000000000000278e-02 -1.702834799608993199e-01 5.000000000000000278e-02 -1.704789833822091816e-01 5.000000000000000278e-02 -1.706744868035190710e-01 5.000000000000000278e-02 -1.708699902248289326e-01 5.000000000000000278e-02 -1.710654936461387943e-01 5.000000000000000278e-02 -1.712609970674486837e-01 5.000000000000000278e-02 -1.714565004887585453e-01 5.000000000000000278e-02 -1.716520039100684347e-01 5.000000000000000278e-02 -1.718475073313782964e-01 5.000000000000000278e-02 -1.720430107526881858e-01 5.000000000000000278e-02 -1.722385141739980474e-01 5.000000000000000278e-02 -1.724340175953079091e-01 5.000000000000000278e-02 -1.726295210166177985e-01 5.000000000000000278e-02 -1.728250244379276601e-01 5.000000000000000278e-02 -1.730205278592375495e-01 5.000000000000000278e-02 -1.732160312805474112e-01 5.000000000000000278e-02 -1.734115347018572728e-01 5.000000000000000278e-02 -1.736070381231671622e-01 5.000000000000000278e-02 -1.738025415444770239e-01 5.000000000000000278e-02 -1.739980449657869133e-01 5.000000000000000278e-02 -1.741935483870967749e-01 5.000000000000000278e-02 -1.743890518084066366e-01 5.000000000000000278e-02 -1.745845552297165260e-01 5.000000000000000278e-02 -1.747800586510263876e-01 5.000000000000000278e-02 -1.749755620723362770e-01 5.000000000000000278e-02 -1.751710654936461387e-01 5.000000000000000278e-02 -1.753665689149560003e-01 5.000000000000000278e-02 -1.755620723362658897e-01 5.000000000000000278e-02 -1.757575757575757514e-01 5.000000000000000278e-02 -1.759530791788856408e-01 5.000000000000000278e-02 -1.761485826001955024e-01 5.000000000000000278e-02 -1.763440860215053640e-01 5.000000000000000278e-02 -1.765395894428152535e-01 5.000000000000000278e-02 -1.767350928641251151e-01 5.000000000000000278e-02 -1.769305962854350045e-01 5.000000000000000278e-02 -1.771260997067448661e-01 5.000000000000000278e-02 -1.773216031280547278e-01 5.000000000000000278e-02 -1.775171065493646172e-01 5.000000000000000278e-02 -1.777126099706744788e-01 5.000000000000000278e-02 -1.779081133919843682e-01 5.000000000000000278e-02 -1.781036168132942299e-01 5.000000000000000278e-02 -1.782991202346040915e-01 5.000000000000000278e-02 -1.784946236559139809e-01 5.000000000000000278e-02 -1.786901270772238426e-01 5.000000000000000278e-02 -1.788856304985337320e-01 5.000000000000000278e-02 -1.790811339198435936e-01 5.000000000000000278e-02 -1.792766373411534830e-01 5.000000000000000278e-02 -1.794721407624633447e-01 5.000000000000000278e-02 -1.796676441837732063e-01 5.000000000000000278e-02 -1.798631476050830957e-01 5.000000000000000278e-02 -1.800586510263929574e-01 5.000000000000000278e-02 -1.802541544477028468e-01 5.000000000000000278e-02 -1.804496578690127084e-01 5.000000000000000278e-02 -1.806451612903225701e-01 5.000000000000000278e-02 -1.808406647116324595e-01 5.000000000000000278e-02 -1.810361681329423211e-01 5.000000000000000278e-02 -1.812316715542522105e-01 5.000000000000000278e-02 -1.814271749755620722e-01 5.000000000000000278e-02 -1.816226783968719338e-01 5.000000000000000278e-02 -1.818181818181818232e-01 5.000000000000000278e-02 -1.820136852394916849e-01 5.000000000000000278e-02 -1.822091886608015743e-01 5.000000000000000278e-02 -1.824046920821114359e-01 5.000000000000000278e-02 -1.826001955034212976e-01 5.000000000000000278e-02 -1.827956989247311870e-01 5.000000000000000278e-02 -1.829912023460410486e-01 5.000000000000000278e-02 -1.831867057673509380e-01 5.000000000000000278e-02 -1.833822091886607997e-01 5.000000000000000278e-02 -1.835777126099706613e-01 5.000000000000000278e-02 -1.837732160312805507e-01 5.000000000000000278e-02 -1.839687194525904124e-01 5.000000000000000278e-02 -1.841642228739003018e-01 5.000000000000000278e-02 -1.843597262952101634e-01 5.000000000000000278e-02 -1.845552297165200528e-01 5.000000000000000278e-02 -1.847507331378299145e-01 5.000000000000000278e-02 -1.849462365591397761e-01 5.000000000000000278e-02 -1.851417399804496655e-01 5.000000000000000278e-02 -1.853372434017595272e-01 5.000000000000000278e-02 -1.855327468230694166e-01 5.000000000000000278e-02 -1.857282502443792782e-01 5.000000000000000278e-02 -1.859237536656891399e-01 5.000000000000000278e-02 -1.861192570869990293e-01 5.000000000000000278e-02 -1.863147605083088909e-01 5.000000000000000278e-02 -1.865102639296187803e-01 5.000000000000000278e-02 -1.867057673509286420e-01 5.000000000000000278e-02 -1.869012707722385036e-01 5.000000000000000278e-02 -1.870967741935483930e-01 5.000000000000000278e-02 -1.872922776148582547e-01 5.000000000000000278e-02 -1.874877810361681441e-01 5.000000000000000278e-02 -1.876832844574780057e-01 5.000000000000000278e-02 -1.878787878787878673e-01 5.000000000000000278e-02 -1.880742913000977568e-01 5.000000000000000278e-02 -1.882697947214076184e-01 5.000000000000000278e-02 -1.884652981427175078e-01 5.000000000000000278e-02 -1.886608015640273694e-01 5.000000000000000278e-02 -1.888563049853372311e-01 5.000000000000000278e-02 -1.890518084066471205e-01 5.000000000000000278e-02 -1.892473118279569821e-01 5.000000000000000278e-02 -1.894428152492668715e-01 5.000000000000000278e-02 -1.896383186705767332e-01 5.000000000000000278e-02 -1.898338220918865948e-01 5.000000000000000278e-02 -1.900293255131964842e-01 5.000000000000000278e-02 -1.902248289345063459e-01 5.000000000000000278e-02 -1.904203323558162353e-01 5.000000000000000278e-02 -1.906158357771260969e-01 5.000000000000000278e-02 -1.908113391984359586e-01 5.000000000000000278e-02 -1.910068426197458480e-01 5.000000000000000278e-02 -1.912023460410557096e-01 5.000000000000000278e-02 -1.913978494623655990e-01 5.000000000000000278e-02 -1.915933528836754607e-01 5.000000000000000278e-02 -1.917888563049853501e-01 5.000000000000000278e-02 -1.919843597262952117e-01 5.000000000000000278e-02 -1.921798631476050734e-01 5.000000000000000278e-02 -1.923753665689149628e-01 5.000000000000000278e-02 -1.925708699902248244e-01 5.000000000000000278e-02 -1.927663734115347138e-01 5.000000000000000278e-02 -1.929618768328445755e-01 5.000000000000000278e-02 -1.931573802541544371e-01 5.000000000000000278e-02 -1.933528836754643265e-01 5.000000000000000278e-02 -1.935483870967741882e-01 5.000000000000000278e-02 -1.937438905180840776e-01 5.000000000000000278e-02 -1.939393939393939392e-01 5.000000000000000278e-02 -1.941348973607038009e-01 5.000000000000000278e-02 -1.943304007820136903e-01 5.000000000000000278e-02 -1.945259042033235519e-01 5.000000000000000278e-02 -1.947214076246334413e-01 5.000000000000000278e-02 -1.949169110459433030e-01 5.000000000000000278e-02 -1.951124144672531646e-01 5.000000000000000278e-02 -1.953079178885630540e-01 5.000000000000000278e-02 -1.955034213098729157e-01 5.000000000000000278e-02 -1.956989247311828051e-01 5.000000000000000278e-02 -1.958944281524926667e-01 5.000000000000000278e-02 -1.960899315738025284e-01 5.000000000000000278e-02 -1.962854349951124178e-01 5.000000000000000278e-02 -1.964809384164222794e-01 5.000000000000000278e-02 -1.966764418377321688e-01 5.000000000000000278e-02 -1.968719452590420305e-01 5.000000000000000278e-02 -1.970674486803519199e-01 5.000000000000000278e-02 -1.972629521016617815e-01 5.000000000000000278e-02 -1.974584555229716432e-01 5.000000000000000278e-02 -1.976539589442815326e-01 5.000000000000000278e-02 -1.978494623655913942e-01 5.000000000000000278e-02 -1.980449657869012836e-01 5.000000000000000278e-02 -1.982404692082111453e-01 5.000000000000000278e-02 -1.984359726295210069e-01 5.000000000000000278e-02 -1.986314760508308963e-01 5.000000000000000278e-02 -1.988269794721407580e-01 5.000000000000000278e-02 -1.990224828934506474e-01 5.000000000000000278e-02 -1.992179863147605090e-01 5.000000000000000278e-02 -1.994134897360703707e-01 5.000000000000000278e-02 -1.996089931573802601e-01 5.000000000000000278e-02 -1.998044965786901217e-01 5.000000000000000278e-02 -2.000000000000000111e-01 5.000000000000000278e-02 diff --git a/output/wz.txt b/output/wz.txt deleted file mode 100644 index e297b8e..0000000 --- a/output/wz.txt +++ /dev/null @@ -1,1024 +0,0 @@ -0.000000000000000000e+00 1.000000000000000056e-01 -1.955034213098729226e-04 9.980449657869013003e-02 -3.910068426197458452e-04 9.960899315738025450e-02 -5.865102639296187678e-04 9.941348973607039285e-02 -7.820136852394916904e-04 9.921798631476051733e-02 -9.775171065493646130e-04 9.902248289345064181e-02 -1.173020527859237536e-03 9.882697947214076628e-02 -1.368523949169110458e-03 9.863147605083089076e-02 -1.564027370478983381e-03 9.843597262952102911e-02 -1.759530791788856303e-03 9.824046920821115358e-02 -1.955034213098729226e-03 9.804496578690127806e-02 -2.150537634408602149e-03 9.784946236559140254e-02 -2.346041055718475071e-03 9.765395894428152701e-02 -2.541544477028347994e-03 9.745845552297165149e-02 -2.737047898338220916e-03 9.726295210166178984e-02 -2.932551319648093839e-03 9.706744868035191431e-02 -3.128054740957966762e-03 9.687194525904203879e-02 -3.323558162267839684e-03 9.667644183773216326e-02 -3.519061583577712607e-03 9.648093841642228774e-02 -3.714565004887585530e-03 9.628543499511242609e-02 -3.910068426197458452e-03 9.608993157380255057e-02 -4.105571847507331375e-03 9.589442815249267504e-02 -4.301075268817204297e-03 9.569892473118279952e-02 -4.496578690127077220e-03 9.550342130987292399e-02 -4.692082111436950143e-03 9.530791788856304847e-02 -4.887585532746823065e-03 9.511241446725318682e-02 -5.083088954056695988e-03 9.491691104594331130e-02 -5.278592375366568910e-03 9.472140762463343577e-02 -5.474095796676441833e-03 9.452590420332356025e-02 -5.669599217986314756e-03 9.433040078201368472e-02 -5.865102639296187678e-03 9.413489736070382308e-02 -6.060606060606060601e-03 9.393939393939394755e-02 -6.256109481915933523e-03 9.374389051808407203e-02 -6.451612903225806446e-03 9.354838709677419650e-02 -6.647116324535679369e-03 9.335288367546432098e-02 -6.842619745845552291e-03 9.315738025415445933e-02 -7.038123167155425214e-03 9.296187683284458381e-02 -7.233626588465298136e-03 9.276637341153470828e-02 -7.429130009775171059e-03 9.257086999022483276e-02 -7.624633431085043982e-03 9.237536656891495723e-02 -7.820136852394916904e-03 9.217986314760509559e-02 -8.015640273704788960e-03 9.198435972629522006e-02 -8.211143695014662749e-03 9.178885630498534454e-02 -8.406647116324536539e-03 9.159335288367546901e-02 -8.602150537634408595e-03 9.139784946236559349e-02 -8.797653958944280650e-03 9.120234604105573184e-02 -8.993157380254154440e-03 9.100684261974585632e-02 -9.188660801564028230e-03 9.081133919843598079e-02 -9.384164222873900285e-03 9.061583577712610527e-02 -9.579667644183772340e-03 9.042033235581622974e-02 -9.775171065493646130e-03 9.022482893450635422e-02 -9.970674486803519920e-03 9.002932551319647869e-02 -1.016617790811339198e-02 8.983382209188661705e-02 -1.036168132942326403e-02 8.963831867057674152e-02 -1.055718475073313782e-02 8.944281524926686600e-02 -1.075268817204301161e-02 8.924731182795699047e-02 -1.094819159335288367e-02 8.905180840664711495e-02 -1.114369501466275572e-02 8.885630498533725330e-02 -1.133919843597262951e-02 8.866080156402737777e-02 -1.153470185728250330e-02 8.846529814271750225e-02 -1.173020527859237536e-02 8.826979472140762673e-02 -1.192570869990224741e-02 8.807429130009775120e-02 -1.212121212121212120e-02 8.787878787878788955e-02 -1.231671554252199499e-02 8.768328445747801403e-02 -1.251221896383186705e-02 8.748778103616813850e-02 -1.270772238514173910e-02 8.729227761485826298e-02 -1.290322580645161289e-02 8.709677419354838745e-02 -1.309872922776148668e-02 8.690127077223852581e-02 -1.329423264907135874e-02 8.670576735092865028e-02 -1.348973607038123079e-02 8.651026392961877476e-02 -1.368523949169110458e-02 8.631476050830889923e-02 -1.388074291300097837e-02 8.611925708699902371e-02 -1.407624633431085043e-02 8.592375366568916206e-02 -1.427174975562072248e-02 8.572825024437928654e-02 -1.446725317693059627e-02 8.553274682306941101e-02 -1.466275659824047006e-02 8.533724340175953549e-02 -1.485826001955034212e-02 8.514173998044965996e-02 -1.505376344086021417e-02 8.494623655913979832e-02 -1.524926686217008796e-02 8.475073313782992279e-02 -1.544477028347996175e-02 8.455522971652004727e-02 -1.564027370478983381e-02 8.435972629521017174e-02 -1.583577712609970586e-02 8.416422287390029622e-02 -1.603128054740957792e-02 8.396871945259043457e-02 -1.622678396871945344e-02 8.377321603128054517e-02 -1.642228739002932550e-02 8.357771260997068352e-02 -1.661779081133919755e-02 8.338220918866080800e-02 -1.681329423264907308e-02 8.318670576735093247e-02 -1.700879765395894513e-02 8.299120234604105695e-02 -1.720430107526881719e-02 8.279569892473118142e-02 -1.739980449657868924e-02 8.260019550342131978e-02 -1.759530791788856130e-02 8.240469208211144425e-02 -1.779081133919843682e-02 8.220918866080156873e-02 -1.798631476050830888e-02 8.201368523949169320e-02 -1.818181818181818094e-02 8.181818181818181768e-02 -1.837732160312805646e-02 8.162267839687195603e-02 -1.857282502443792851e-02 8.142717497556208051e-02 -1.876832844574780057e-02 8.123167155425220498e-02 -1.896383186705767263e-02 8.103616813294232946e-02 -1.915933528836754468e-02 8.084066471163245393e-02 -1.935483870967742021e-02 8.064516129032259228e-02 -1.955034213098729226e-02 8.044965786901271676e-02 -1.974584555229716432e-02 8.025415444770284124e-02 -1.994134897360703984e-02 8.005865102639296571e-02 -2.013685239491691190e-02 7.986314760508309019e-02 -2.033235581622678395e-02 7.966764418377322854e-02 -2.052785923753665601e-02 7.947214076246335301e-02 -2.072336265884652806e-02 7.927663734115347749e-02 -2.091886608015640359e-02 7.908113391984360196e-02 -2.111436950146627564e-02 7.888563049853372644e-02 -2.130987292277614770e-02 7.869012707722386479e-02 -2.150537634408602322e-02 7.849462365591397539e-02 -2.170087976539589528e-02 7.829912023460411374e-02 -2.189638318670576733e-02 7.810361681329423822e-02 -2.209188660801563939e-02 7.790811339198436269e-02 -2.228739002932551144e-02 7.771260997067450105e-02 -2.248289345063538697e-02 7.751710654936461165e-02 -2.267839687194525902e-02 7.732160312805475000e-02 -2.287390029325513108e-02 7.712609970674487447e-02 -2.306940371456500660e-02 7.693059628543499895e-02 -2.326490713587487866e-02 7.673509286412512342e-02 -2.346041055718475071e-02 7.653958944281524790e-02 -2.365591397849462277e-02 7.634408602150538625e-02 -2.385141739980449482e-02 7.614858260019551073e-02 -2.404692082111437035e-02 7.595307917888563520e-02 -2.424242424242424240e-02 7.575757575757575968e-02 -2.443792766373411446e-02 7.556207233626588415e-02 -2.463343108504398998e-02 7.536656891495602251e-02 -2.482893450635386204e-02 7.517106549364614698e-02 -2.502443792766373409e-02 7.497556207233627146e-02 -2.521994134897360615e-02 7.478005865102639593e-02 -2.541544477028347820e-02 7.458455522971652041e-02 -2.561094819159335373e-02 7.438905180840665876e-02 -2.580645161290322578e-02 7.419354838709678324e-02 -2.600195503421309784e-02 7.399804496578690771e-02 -2.619745845552297336e-02 7.380254154447703219e-02 -2.639296187683284542e-02 7.360703812316715666e-02 -2.658846529814271747e-02 7.341153470185729502e-02 -2.678396871945258953e-02 7.321603128054741949e-02 -2.697947214076246158e-02 7.302052785923754397e-02 -2.717497556207233711e-02 7.282502443792766844e-02 -2.737047898338220916e-02 7.262952101661779292e-02 -2.756598240469208122e-02 7.243401759530793127e-02 -2.776148582600195674e-02 7.223851417399804187e-02 -2.795698924731182880e-02 7.204301075268818022e-02 -2.815249266862170086e-02 7.184750733137830470e-02 -2.834799608993157291e-02 7.165200391006842917e-02 -2.854349951124144497e-02 7.145650048875856752e-02 -2.873900293255132049e-02 7.126099706744867812e-02 -2.893450635386119255e-02 7.106549364613881647e-02 -2.913000977517106460e-02 7.086999022482894095e-02 -2.932551319648094013e-02 7.067448680351906543e-02 -2.952101661779081218e-02 7.047898338220918990e-02 -2.971652003910068424e-02 7.028347996089931438e-02 -2.991202346041055629e-02 7.008797653958945273e-02 -3.010752688172042835e-02 6.989247311827957720e-02 -3.030303030303030387e-02 6.969696969696970168e-02 -3.049853372434017593e-02 6.950146627565982616e-02 -3.069403714565004798e-02 6.930596285434995063e-02 -3.088954056695992351e-02 6.911045943304008898e-02 -3.108504398826979556e-02 6.891495601173021346e-02 -3.128054740957966762e-02 6.871945259042033793e-02 -3.147605083088954314e-02 6.852394916911046241e-02 -3.167155425219941173e-02 6.832844574780058688e-02 -3.186705767350928725e-02 6.813294232649072524e-02 -3.206256109481915584e-02 6.793743890518084971e-02 -3.225806451612903136e-02 6.774193548387097419e-02 -3.245356793743890689e-02 6.754643206256109866e-02 -3.264907135874877547e-02 6.735092864125122314e-02 -3.284457478005865100e-02 6.715542521994136149e-02 -3.304007820136852652e-02 6.695992179863147209e-02 -3.323558162267839511e-02 6.676441837732161044e-02 -3.343108504398827063e-02 6.656891495601173492e-02 -3.362658846529814616e-02 6.637341153470185939e-02 -3.382209188660801474e-02 6.617790811339199775e-02 -3.401759530791789027e-02 6.598240469208210834e-02 -3.421309872922775885e-02 6.578690127077224670e-02 -3.440860215053763438e-02 6.559139784946237117e-02 -3.460410557184750990e-02 6.539589442815249565e-02 -3.479960899315737849e-02 6.520039100684263400e-02 -3.499511241446725401e-02 6.500488758553274460e-02 -3.519061583577712260e-02 6.480938416422288295e-02 -3.538611925708699812e-02 6.461388074291300743e-02 -3.558162267839687365e-02 6.441837732160313190e-02 -3.577712609970674223e-02 6.422287390029327026e-02 -3.597262952101661776e-02 6.402737047898338085e-02 -3.616813294232649328e-02 6.383186705767351921e-02 -3.636363636363636187e-02 6.363636363636364368e-02 -3.655913978494623739e-02 6.344086021505376816e-02 -3.675464320625611292e-02 6.324535679374389263e-02 -3.695014662756598151e-02 6.304985337243401711e-02 -3.714565004887585703e-02 6.285434995112415546e-02 -3.734115347018572562e-02 6.265884652981427994e-02 -3.753665689149560114e-02 6.246334310850440441e-02 -3.773216031280547667e-02 6.226783968719452889e-02 -3.792766373411534525e-02 6.207233626588466030e-02 -3.812316715542522078e-02 6.187683284457478478e-02 -3.831867057673508936e-02 6.168132942326491619e-02 -3.851417399804496489e-02 6.148582600195504066e-02 -3.870967741935484041e-02 6.129032258064516514e-02 -3.890518084066470900e-02 6.109481915933529655e-02 -3.910068426197458452e-02 6.089931573802542103e-02 -3.929618768328446005e-02 6.070381231671554551e-02 -3.949169110459432863e-02 6.050830889540567692e-02 -3.968719452590420416e-02 6.031280547409580139e-02 -3.988269794721407968e-02 6.011730205278592587e-02 -4.007820136852394827e-02 5.992179863147605728e-02 -4.027370478983382379e-02 5.972629521016618176e-02 -4.046920821114369238e-02 5.953079178885631317e-02 -4.066471163245356790e-02 5.933528836754643765e-02 -4.086021505376344343e-02 5.913978494623656212e-02 -4.105571847507331201e-02 5.894428152492669354e-02 -4.125122189638318754e-02 5.874877810361681801e-02 -4.144672531769305612e-02 5.855327468230694943e-02 -4.164222873900293165e-02 5.835777126099707390e-02 -4.183773216031280717e-02 5.816226783968719838e-02 -4.203323558162267576e-02 5.796676441837732979e-02 -4.222873900293255128e-02 5.777126099706745427e-02 -4.242424242424242681e-02 5.757575757575757874e-02 -4.261974584555229539e-02 5.738025415444771016e-02 -4.281524926686217092e-02 5.718475073313783463e-02 -4.301075268817204644e-02 5.698924731182795911e-02 -4.320625610948191503e-02 5.679374389051809052e-02 -4.340175953079179055e-02 5.659824046920821500e-02 -4.359726295210165914e-02 5.640273704789834641e-02 -4.379276637341153466e-02 5.620723362658847089e-02 -4.398826979472141019e-02 5.601173020527859536e-02 -4.418377321603127877e-02 5.581622678396872678e-02 -4.437927663734115430e-02 5.562072336265885125e-02 -4.457478005865102288e-02 5.542521994134898267e-02 -4.477028347996089841e-02 5.522971652003910714e-02 -4.496578690127077393e-02 5.503421309872923162e-02 -4.516129032258064252e-02 5.483870967741936303e-02 -4.535679374389051804e-02 5.464320625610948751e-02 -4.555229716520039357e-02 5.444770283479961198e-02 -4.574780058651026216e-02 5.425219941348974340e-02 -4.594330400782013768e-02 5.405669599217986787e-02 -4.613880742913001320e-02 5.386119257086999235e-02 -4.633431085043988179e-02 5.366568914956012376e-02 -4.652981427174975732e-02 5.347018572825024824e-02 -4.672531769305962590e-02 5.327468230694037965e-02 -4.692082111436950143e-02 5.307917888563050413e-02 -4.711632453567937695e-02 5.288367546432062860e-02 -4.731182795698924554e-02 5.268817204301076002e-02 -4.750733137829912106e-02 5.249266862170088449e-02 -4.770283479960898965e-02 5.229716520039101590e-02 -4.789833822091886517e-02 5.210166177908114038e-02 -4.809384164222874070e-02 5.190615835777126486e-02 -4.828934506353860928e-02 5.171065493646139627e-02 -4.848484848484848481e-02 5.151515151515152074e-02 -4.868035190615836033e-02 5.131964809384164522e-02 -4.887585532746822892e-02 5.112414467253177663e-02 -4.907135874877810444e-02 5.092864125122190111e-02 -4.926686217008797997e-02 5.073313782991202558e-02 -4.946236559139784855e-02 5.053763440860215700e-02 -4.965786901270772408e-02 5.034213098729228147e-02 -4.985337243401759266e-02 5.014662756598241289e-02 -5.004887585532746819e-02 4.995112414467253736e-02 -5.024437927663734371e-02 4.975562072336266184e-02 -5.043988269794721230e-02 4.956011730205279325e-02 -5.063538611925708782e-02 4.936461388074291773e-02 -5.083088954056695641e-02 4.916911045943304914e-02 -5.102639296187683193e-02 4.897360703812317362e-02 -5.122189638318670746e-02 4.877810361681329809e-02 -5.141739980449657604e-02 4.858260019550342951e-02 -5.161290322580645157e-02 4.838709677419355398e-02 -5.180840664711632709e-02 4.819159335288367846e-02 -5.200391006842619568e-02 4.799608993157380987e-02 -5.219941348973607120e-02 4.780058651026393435e-02 -5.239491691104594673e-02 4.760508308895405882e-02 -5.259042033235581531e-02 4.740957966764419024e-02 -5.278592375366569084e-02 4.721407624633431471e-02 -5.298142717497555942e-02 4.701857282502444613e-02 -5.317693059628543495e-02 4.682306940371457060e-02 -5.337243401759531047e-02 4.662756598240469508e-02 -5.356793743890517906e-02 4.643206256109482649e-02 -5.376344086021505458e-02 4.623655913978495097e-02 -5.395894428152492317e-02 4.604105571847508238e-02 -5.415444770283479869e-02 4.584555229716520686e-02 -5.434995112414467422e-02 4.565004887585533133e-02 -5.454545454545454281e-02 4.545454545454546275e-02 -5.474095796676441833e-02 4.525904203323558722e-02 -5.493646138807429385e-02 4.506353861192571170e-02 -5.513196480938416244e-02 4.486803519061584311e-02 -5.532746823069403797e-02 4.467253176930596759e-02 -5.552297165200391349e-02 4.447702834799609206e-02 -5.571847507331378208e-02 4.428152492668622348e-02 -5.591397849462365760e-02 4.408602150537634795e-02 -5.610948191593352619e-02 4.389051808406647937e-02 -5.630498533724340171e-02 4.369501466275660384e-02 -5.650048875855327724e-02 4.349951124144672832e-02 -5.669599217986314582e-02 4.330400782013685973e-02 -5.689149560117302135e-02 4.310850439882698421e-02 -5.708699902248288993e-02 4.291300097751711562e-02 -5.728250244379276546e-02 4.271749755620724009e-02 -5.747800586510264098e-02 4.252199413489736457e-02 -5.767350928641250957e-02 4.232649071358749598e-02 -5.786901270772238509e-02 4.213098729227762046e-02 -5.806451612903226062e-02 4.193548387096774493e-02 -5.826001955034212920e-02 4.173998044965787635e-02 -5.845552297165200473e-02 4.154447702834800082e-02 -5.865102639296188025e-02 4.134897360703812530e-02 -5.884652981427174884e-02 4.115347018572825671e-02 -5.904203323558162436e-02 4.095796676441838119e-02 -5.923753665689149295e-02 4.076246334310851260e-02 -5.943304007820136847e-02 4.056695992179863708e-02 -5.962854349951124400e-02 4.037145650048876155e-02 -5.982404692082111258e-02 4.017595307917889297e-02 -6.001955034213098811e-02 3.998044965786901744e-02 -6.021505376344085669e-02 3.978494623655914886e-02 -6.041055718475073222e-02 3.958944281524927333e-02 -6.060606060606060774e-02 3.939393939393939781e-02 -6.080156402737047633e-02 3.919843597262952922e-02 -6.099706744868035185e-02 3.900293255131965370e-02 -6.119257086999022738e-02 3.880742913000977817e-02 -6.138807429130009596e-02 3.861192570869990959e-02 -6.158357771260997149e-02 3.841642228739003406e-02 -6.177908113391984701e-02 3.822091886608015854e-02 -6.197458455522971560e-02 3.802541544477028995e-02 -6.217008797653959112e-02 3.782991202346041443e-02 -6.236559139784945971e-02 3.763440860215054584e-02 -6.256109481915933523e-02 3.743890518084067032e-02 -6.275659824046921076e-02 3.724340175953079479e-02 -6.295210166177908628e-02 3.704789833822091927e-02 -6.314760508308894793e-02 3.685239491691105762e-02 -6.334310850439882346e-02 3.665689149560118210e-02 -6.353861192570869898e-02 3.646138807429130657e-02 -6.373411534701857450e-02 3.626588465298143105e-02 -6.392961876832845003e-02 3.607038123167155552e-02 -6.412512218963831168e-02 3.587487781036169388e-02 -6.432062561094818720e-02 3.567937438905181835e-02 -6.451612903225806273e-02 3.548387096774194283e-02 -6.471163245356793825e-02 3.528836754643206730e-02 -6.490713587487781377e-02 3.509286412512219178e-02 -6.510263929618768930e-02 3.489736070381231625e-02 -6.529814271749755095e-02 3.470185728250245460e-02 -6.549364613880742647e-02 3.450635386119257908e-02 -6.568914956011730200e-02 3.431085043988270356e-02 -6.588465298142717752e-02 3.411534701857282803e-02 -6.608015640273705305e-02 3.391984359726295251e-02 -6.627565982404691469e-02 3.372434017595309086e-02 -6.647116324535679022e-02 3.352883675464321533e-02 -6.666666666666666574e-02 3.333333333333333981e-02 -6.686217008797654127e-02 3.313782991202346428e-02 -6.705767350928641679e-02 3.294232649071358876e-02 -6.725317693059629232e-02 3.274682306940371324e-02 -6.744868035190615396e-02 3.255131964809385159e-02 -6.764418377321602949e-02 3.235581622678397606e-02 -6.783968719452590501e-02 3.216031280547410054e-02 -6.803519061583578054e-02 3.196480938416422501e-02 -6.823069403714565606e-02 3.176930596285434949e-02 -6.842619745845551771e-02 3.157380254154448784e-02 -6.862170087976539323e-02 3.137829912023461232e-02 -6.881720430107526876e-02 3.118279569892473679e-02 -6.901270772238514428e-02 3.098729227761486127e-02 -6.920821114369501981e-02 3.079178885630498574e-02 -6.940371456500488145e-02 3.059628543499512410e-02 -6.959921798631475698e-02 3.040078201368524857e-02 -6.979472140762463250e-02 3.020527859237537305e-02 -6.999022482893450803e-02 3.000977517106549752e-02 -7.018572825024438355e-02 2.981427174975562200e-02 -7.038123167155424520e-02 2.961876832844576035e-02 -7.057673509286412072e-02 2.942326490713588483e-02 -7.077223851417399625e-02 2.922776148582600930e-02 -7.096774193548387177e-02 2.903225806451613378e-02 -7.116324535679374730e-02 2.883675464320625825e-02 -7.135874877810362282e-02 2.864125122189638273e-02 -7.155425219941348447e-02 2.844574780058652108e-02 -7.174975562072335999e-02 2.825024437927664556e-02 -7.194525904203323552e-02 2.805474095796677003e-02 -7.214076246334311104e-02 2.785923753665689451e-02 -7.233626588465298657e-02 2.766373411534701898e-02 -7.253176930596284822e-02 2.746823069403715734e-02 -7.272727272727272374e-02 2.727272727272728181e-02 -7.292277614858259926e-02 2.707722385141740629e-02 -7.311827956989247479e-02 2.688172043010753076e-02 -7.331378299120235031e-02 2.668621700879765524e-02 -7.350928641251222584e-02 2.649071358748777971e-02 -7.370478983382208749e-02 2.629521016617791807e-02 -7.390029325513196301e-02 2.609970674486804254e-02 -7.409579667644183854e-02 2.590420332355816702e-02 -7.429130009775171406e-02 2.570869990224829149e-02 -7.448680351906158958e-02 2.551319648093841597e-02 -7.468230694037145123e-02 2.531769305962855432e-02 -7.487781036168132676e-02 2.512218963831867879e-02 -7.507331378299120228e-02 2.492668621700880327e-02 -7.526881720430107781e-02 2.473118279569892775e-02 -7.546432062561095333e-02 2.453567937438905222e-02 -7.565982404692081498e-02 2.434017595307919057e-02 -7.585532746823069050e-02 2.414467253176931505e-02 -7.605083088954056603e-02 2.394916911045943952e-02 -7.624633431085044155e-02 2.375366568914956400e-02 -7.644183773216031708e-02 2.355816226783968848e-02 -7.663734115347017872e-02 2.336265884652982683e-02 -7.683284457478005425e-02 2.316715542521995130e-02 -7.702834799608992977e-02 2.297165200391007578e-02 -7.722385141739980530e-02 2.277614858260020025e-02 -7.741935483870968082e-02 2.258064516129032473e-02 -7.761485826001955635e-02 2.238514173998044920e-02 -7.781036168132941799e-02 2.218963831867058756e-02 -7.800586510263929352e-02 2.199413489736071203e-02 -7.820136852394916904e-02 2.179863147605083651e-02 -7.839687194525904457e-02 2.160312805474096098e-02 -7.859237536656892009e-02 2.140762463343108546e-02 -7.878787878787878174e-02 2.121212121212122381e-02 -7.898338220918865726e-02 2.101661779081134829e-02 -7.917888563049853279e-02 2.082111436950147276e-02 -7.937438905180840831e-02 2.062561094819159724e-02 -7.956989247311828384e-02 2.043010752688172171e-02 -7.976539589442815936e-02 2.023460410557184619e-02 -7.996089931573802101e-02 2.003910068426198454e-02 -8.015640273704789653e-02 1.984359726295210902e-02 -8.035190615835777206e-02 1.964809384164223349e-02 -8.054740957966764758e-02 1.945259042033235797e-02 -8.074291300097752311e-02 1.925708699902248244e-02 -8.093841642228738475e-02 1.906158357771262080e-02 -8.113391984359726028e-02 1.886608015640274527e-02 -8.132942326490713580e-02 1.867057673509286975e-02 -8.152492668621701133e-02 1.847507331378299422e-02 -8.172043010752688685e-02 1.827956989247311870e-02 -8.191593352883674850e-02 1.808406647116325705e-02 -8.211143695014662403e-02 1.788856304985338153e-02 -8.230694037145649955e-02 1.769305962854350600e-02 -8.250244379276637507e-02 1.749755620723363048e-02 -8.269794721407625060e-02 1.730205278592375495e-02 -8.289345063538611225e-02 1.710654936461389330e-02 -8.308895405669598777e-02 1.691104594330401778e-02 -8.328445747800586330e-02 1.671554252199414226e-02 -8.347996089931573882e-02 1.652003910068426673e-02 -8.367546432062561435e-02 1.632453567937439121e-02 -8.387096774193548987e-02 1.612903225806451568e-02 -8.406647116324535152e-02 1.593352883675465403e-02 -8.426197458455522704e-02 1.573802541544477851e-02 -8.445747800586510257e-02 1.554252199413490299e-02 -8.465298142717497809e-02 1.534701857282502746e-02 -8.484848484848485362e-02 1.515151515151515194e-02 -8.504398826979471526e-02 1.495601173020529029e-02 -8.523949169110459079e-02 1.476050830889541476e-02 -8.543499511241446631e-02 1.456500488758553924e-02 -8.563049853372434184e-02 1.436950146627566371e-02 -8.582600195503421736e-02 1.417399804496578819e-02 -8.602150537634409289e-02 1.397849462365591267e-02 -8.621700879765395453e-02 1.378299120234605102e-02 -8.641251221896383006e-02 1.358748778103617549e-02 -8.660801564027370558e-02 1.339198435972629997e-02 -8.680351906158358111e-02 1.319648093841642444e-02 -8.699902248289345663e-02 1.300097751710654892e-02 -8.719452590420331828e-02 1.280547409579668727e-02 -8.739002932551319380e-02 1.260997067448681175e-02 -8.758553274682306933e-02 1.241446725317693622e-02 -8.778103616813294485e-02 1.221896383186706070e-02 -8.797653958944282038e-02 1.202346041055718517e-02 -8.817204301075268202e-02 1.182795698924732353e-02 -8.836754643206255755e-02 1.163245356793744800e-02 -8.856304985337243307e-02 1.143695014662757248e-02 -8.875855327468230860e-02 1.124144672531769695e-02 -8.895405669599218412e-02 1.104594330400782143e-02 -8.914956011730204577e-02 1.085043988269795978e-02 -8.934506353861192129e-02 1.065493646138808426e-02 -8.954056695992179682e-02 1.045943304007820873e-02 -8.973607038123167234e-02 1.026392961876833321e-02 -8.993157380254154787e-02 1.006842619745845768e-02 -9.012707722385142339e-02 9.872922776148582158e-03 -9.032258064516128504e-02 9.677419354838720511e-03 -9.051808406647116056e-02 9.481915933528844986e-03 -9.071358748778103609e-02 9.286412512218969462e-03 -9.090909090909091161e-02 9.090909090909093937e-03 -9.110459433040078714e-02 8.895405669599218412e-03 -9.130009775171064879e-02 8.699902248289356765e-03 -9.149560117302052431e-02 8.504398826979481241e-03 -9.169110459433039984e-02 8.308895405669605716e-03 -9.188660801564027536e-02 8.113391984359730191e-03 -9.208211143695015088e-02 7.917888563049854667e-03 -9.227761485826002641e-02 7.722385141739979142e-03 -9.247311827956988806e-02 7.526881720430117495e-03 -9.266862170087976358e-02 7.331378299120241970e-03 -9.286412512218963911e-02 7.135874877810366446e-03 -9.305962854349951463e-02 6.940371456500490921e-03 -9.325513196480939015e-02 6.744868035190615396e-03 -9.345063538611925180e-02 6.549364613880753749e-03 -9.364613880742912733e-02 6.353861192570878225e-03 -9.384164222873900285e-02 6.158357771261002700e-03 -9.403714565004887838e-02 5.962854349951127175e-03 -9.423264907135875390e-02 5.767350928641251651e-03 -9.442815249266861555e-02 5.571847507331390004e-03 -9.462365591397849107e-02 5.376344086021514479e-03 -9.481915933528836660e-02 5.180840664711638954e-03 -9.501466275659824212e-02 4.985337243401763430e-03 -9.521016617790811765e-02 4.789833822091887905e-03 -9.540566959921797929e-02 4.594330400782026258e-03 -9.560117302052785482e-02 4.398826979472150733e-03 -9.579667644183773034e-02 4.203323558162275209e-03 -9.599217986314760587e-02 4.007820136852399684e-03 -9.618768328445748139e-02 3.812316715542524159e-03 -9.638318670576735692e-02 3.616813294232648635e-03 -9.657869012707721856e-02 3.421309872922786988e-03 -9.677419354838709409e-02 3.225806451612911463e-03 -9.696969696969696961e-02 3.030303030303035938e-03 -9.716520039100684514e-02 2.834799608993160414e-03 -9.736070381231672066e-02 2.639296187683284889e-03 -9.755620723362658231e-02 2.443792766373423242e-03 -9.775171065493645783e-02 2.248289345063547717e-03 -9.794721407624633336e-02 2.052785923753672193e-03 -9.814271749755620888e-02 1.857282502443796668e-03 -9.833822091886608441e-02 1.661779081133921143e-03 -9.853372434017595993e-02 1.466275659824045619e-03 -9.872922776148582158e-02 1.270772238514183972e-03 -9.892473118279569710e-02 1.075268817204308447e-03 -9.912023460410557263e-02 8.797653958944329222e-04 -9.931573802541544815e-02 6.842619745845573975e-04 -9.951124144672532368e-02 4.887585532746818728e-04 -9.970674486803518533e-02 2.932551319648202259e-04 -9.990224828934506085e-02 9.775171065494470124e-05 -1.000977517106549364e-01 0.000000000000000000e+00 -1.002932551319648119e-01 0.000000000000000000e+00 -1.004887585532746874e-01 0.000000000000000000e+00 -1.006842619745845491e-01 0.000000000000000000e+00 -1.008797653958944246e-01 0.000000000000000000e+00 -1.010752688172043001e-01 0.000000000000000000e+00 -1.012707722385141756e-01 0.000000000000000000e+00 -1.014662756598240512e-01 0.000000000000000000e+00 -1.016617790811339128e-01 0.000000000000000000e+00 -1.018572825024437883e-01 0.000000000000000000e+00 -1.020527859237536639e-01 0.000000000000000000e+00 -1.022482893450635394e-01 0.000000000000000000e+00 -1.024437927663734149e-01 0.000000000000000000e+00 -1.026392961876832904e-01 0.000000000000000000e+00 -1.028347996089931521e-01 0.000000000000000000e+00 -1.030303030303030276e-01 0.000000000000000000e+00 -1.032258064516129031e-01 0.000000000000000000e+00 -1.034213098729227787e-01 0.000000000000000000e+00 -1.036168132942326542e-01 0.000000000000000000e+00 -1.038123167155425158e-01 0.000000000000000000e+00 -1.040078201368523914e-01 0.000000000000000000e+00 -1.042033235581622669e-01 0.000000000000000000e+00 -1.043988269794721424e-01 0.000000000000000000e+00 -1.045943304007820179e-01 0.000000000000000000e+00 -1.047898338220918935e-01 0.000000000000000000e+00 -1.049853372434017551e-01 0.000000000000000000e+00 -1.051808406647116306e-01 0.000000000000000000e+00 -1.053763440860215062e-01 0.000000000000000000e+00 -1.055718475073313817e-01 0.000000000000000000e+00 -1.057673509286412572e-01 0.000000000000000000e+00 -1.059628543499511188e-01 0.000000000000000000e+00 -1.061583577712609944e-01 0.000000000000000000e+00 -1.063538611925708699e-01 0.000000000000000000e+00 -1.065493646138807454e-01 0.000000000000000000e+00 -1.067448680351906209e-01 0.000000000000000000e+00 -1.069403714565004826e-01 0.000000000000000000e+00 -1.071358748778103581e-01 0.000000000000000000e+00 -1.073313782991202336e-01 0.000000000000000000e+00 -1.075268817204301092e-01 0.000000000000000000e+00 -1.077223851417399847e-01 0.000000000000000000e+00 -1.079178885630498463e-01 0.000000000000000000e+00 -1.081133919843597219e-01 0.000000000000000000e+00 -1.083088954056695974e-01 0.000000000000000000e+00 -1.085043988269794729e-01 0.000000000000000000e+00 -1.086999022482893484e-01 0.000000000000000000e+00 -1.088954056695992240e-01 0.000000000000000000e+00 -1.090909090909090856e-01 0.000000000000000000e+00 -1.092864125122189611e-01 0.000000000000000000e+00 -1.094819159335288367e-01 0.000000000000000000e+00 -1.096774193548387122e-01 0.000000000000000000e+00 -1.098729227761485877e-01 0.000000000000000000e+00 -1.100684261974584494e-01 0.000000000000000000e+00 -1.102639296187683249e-01 0.000000000000000000e+00 -1.104594330400782004e-01 0.000000000000000000e+00 -1.106549364613880759e-01 0.000000000000000000e+00 -1.108504398826979515e-01 0.000000000000000000e+00 -1.110459433040078270e-01 0.000000000000000000e+00 -1.112414467253176886e-01 0.000000000000000000e+00 -1.114369501466275642e-01 0.000000000000000000e+00 -1.116324535679374397e-01 0.000000000000000000e+00 -1.118279569892473152e-01 0.000000000000000000e+00 -1.120234604105571907e-01 0.000000000000000000e+00 -1.122189638318670524e-01 0.000000000000000000e+00 -1.124144672531769279e-01 0.000000000000000000e+00 -1.126099706744868034e-01 0.000000000000000000e+00 -1.128054740957966789e-01 0.000000000000000000e+00 -1.130009775171065545e-01 0.000000000000000000e+00 -1.131964809384164161e-01 0.000000000000000000e+00 -1.133919843597262916e-01 0.000000000000000000e+00 -1.135874877810361672e-01 0.000000000000000000e+00 -1.137829912023460427e-01 0.000000000000000000e+00 -1.139784946236559182e-01 0.000000000000000000e+00 -1.141739980449657799e-01 0.000000000000000000e+00 -1.143695014662756554e-01 0.000000000000000000e+00 -1.145650048875855309e-01 0.000000000000000000e+00 -1.147605083088954064e-01 0.000000000000000000e+00 -1.149560117302052820e-01 0.000000000000000000e+00 -1.151515151515151575e-01 0.000000000000000000e+00 -1.153470185728250191e-01 0.000000000000000000e+00 -1.155425219941348947e-01 0.000000000000000000e+00 -1.157380254154447702e-01 0.000000000000000000e+00 -1.159335288367546457e-01 0.000000000000000000e+00 -1.161290322580645212e-01 0.000000000000000000e+00 -1.163245356793743829e-01 0.000000000000000000e+00 -1.165200391006842584e-01 0.000000000000000000e+00 -1.167155425219941339e-01 0.000000000000000000e+00 -1.169110459433040095e-01 0.000000000000000000e+00 -1.171065493646138850e-01 0.000000000000000000e+00 -1.173020527859237605e-01 0.000000000000000000e+00 -1.174975562072336221e-01 0.000000000000000000e+00 -1.176930596285434977e-01 0.000000000000000000e+00 -1.178885630498533732e-01 0.000000000000000000e+00 -1.180840664711632487e-01 0.000000000000000000e+00 -1.182795698924731242e-01 0.000000000000000000e+00 -1.184750733137829859e-01 0.000000000000000000e+00 -1.186705767350928614e-01 0.000000000000000000e+00 -1.188660801564027369e-01 0.000000000000000000e+00 -1.190615835777126125e-01 0.000000000000000000e+00 -1.192570869990224880e-01 0.000000000000000000e+00 -1.194525904203323496e-01 0.000000000000000000e+00 -1.196480938416422252e-01 0.000000000000000000e+00 -1.198435972629521007e-01 0.000000000000000000e+00 -1.200391006842619762e-01 0.000000000000000000e+00 -1.202346041055718517e-01 0.000000000000000000e+00 -1.204301075268817134e-01 0.000000000000000000e+00 -1.206256109481915889e-01 0.000000000000000000e+00 -1.208211143695014644e-01 0.000000000000000000e+00 -1.210166177908113400e-01 0.000000000000000000e+00 -1.212121212121212155e-01 0.000000000000000000e+00 -1.214076246334310910e-01 0.000000000000000000e+00 -1.216031280547409527e-01 0.000000000000000000e+00 -1.217986314760508282e-01 0.000000000000000000e+00 -1.219941348973607037e-01 0.000000000000000000e+00 -1.221896383186705792e-01 0.000000000000000000e+00 -1.223851417399804548e-01 0.000000000000000000e+00 -1.225806451612903164e-01 0.000000000000000000e+00 -1.227761485826001919e-01 0.000000000000000000e+00 -1.229716520039100675e-01 0.000000000000000000e+00 -1.231671554252199430e-01 0.000000000000000000e+00 -1.233626588465298185e-01 0.000000000000000000e+00 -1.235581622678396940e-01 0.000000000000000000e+00 -1.237536656891495557e-01 0.000000000000000000e+00 -1.239491691104594312e-01 0.000000000000000000e+00 -1.241446725317693067e-01 0.000000000000000000e+00 -1.243401759530791822e-01 0.000000000000000000e+00 -1.245356793743890578e-01 0.000000000000000000e+00 -1.247311827956989194e-01 0.000000000000000000e+00 -1.249266862170087949e-01 0.000000000000000000e+00 -1.251221896383186705e-01 0.000000000000000000e+00 -1.253176930596285321e-01 0.000000000000000000e+00 -1.255131964809384215e-01 0.000000000000000000e+00 -1.257086999022482832e-01 0.000000000000000000e+00 -1.259042033235581726e-01 0.000000000000000000e+00 -1.260997067448680342e-01 0.000000000000000000e+00 -1.262952101661778959e-01 0.000000000000000000e+00 -1.264907135874877853e-01 0.000000000000000000e+00 -1.266862170087976469e-01 0.000000000000000000e+00 -1.268817204301075363e-01 0.000000000000000000e+00 -1.270772238514173980e-01 0.000000000000000000e+00 -1.272727272727272596e-01 0.000000000000000000e+00 -1.274682306940371490e-01 0.000000000000000000e+00 -1.276637341153470107e-01 0.000000000000000000e+00 -1.278592375366569001e-01 0.000000000000000000e+00 -1.280547409579667617e-01 0.000000000000000000e+00 -1.282502443792766234e-01 0.000000000000000000e+00 -1.284457478005865128e-01 0.000000000000000000e+00 -1.286412512218963744e-01 0.000000000000000000e+00 -1.288367546432062638e-01 0.000000000000000000e+00 -1.290322580645161255e-01 0.000000000000000000e+00 -1.292277614858260149e-01 0.000000000000000000e+00 -1.294232649071358765e-01 0.000000000000000000e+00 -1.296187683284457381e-01 0.000000000000000000e+00 -1.298142717497556275e-01 0.000000000000000000e+00 -1.300097751710654892e-01 0.000000000000000000e+00 -1.302052785923753786e-01 0.000000000000000000e+00 -1.304007820136852402e-01 0.000000000000000000e+00 -1.305962854349951019e-01 0.000000000000000000e+00 -1.307917888563049913e-01 0.000000000000000000e+00 -1.309872922776148529e-01 0.000000000000000000e+00 -1.311827956989247423e-01 0.000000000000000000e+00 -1.313782991202346040e-01 0.000000000000000000e+00 -1.315738025415444656e-01 0.000000000000000000e+00 -1.317693059628543550e-01 0.000000000000000000e+00 -1.319648093841642167e-01 0.000000000000000000e+00 -1.321603128054741061e-01 0.000000000000000000e+00 -1.323558162267839677e-01 0.000000000000000000e+00 -1.325513196480938294e-01 0.000000000000000000e+00 -1.327468230694037188e-01 0.000000000000000000e+00 -1.329423264907135804e-01 0.000000000000000000e+00 -1.331378299120234698e-01 0.000000000000000000e+00 -1.333333333333333315e-01 0.000000000000000000e+00 -1.335288367546431931e-01 0.000000000000000000e+00 -1.337243401759530825e-01 0.000000000000000000e+00 -1.339198435972629442e-01 0.000000000000000000e+00 -1.341153470185728336e-01 0.000000000000000000e+00 -1.343108504398826952e-01 0.000000000000000000e+00 -1.345063538611925846e-01 0.000000000000000000e+00 -1.347018572825024463e-01 0.000000000000000000e+00 -1.348973607038123079e-01 0.000000000000000000e+00 -1.350928641251221973e-01 0.000000000000000000e+00 -1.352883675464320590e-01 0.000000000000000000e+00 -1.354838709677419484e-01 0.000000000000000000e+00 -1.356793743890518100e-01 0.000000000000000000e+00 -1.358748778103616717e-01 0.000000000000000000e+00 -1.360703812316715611e-01 0.000000000000000000e+00 -1.362658846529814227e-01 0.000000000000000000e+00 -1.364613880742913121e-01 0.000000000000000000e+00 -1.366568914956011738e-01 0.000000000000000000e+00 -1.368523949169110354e-01 0.000000000000000000e+00 -1.370478983382209248e-01 0.000000000000000000e+00 -1.372434017595307865e-01 0.000000000000000000e+00 -1.374389051808406759e-01 0.000000000000000000e+00 -1.376344086021505375e-01 0.000000000000000000e+00 -1.378299120234603992e-01 0.000000000000000000e+00 -1.380254154447702886e-01 0.000000000000000000e+00 -1.382209188660801502e-01 0.000000000000000000e+00 -1.384164222873900396e-01 0.000000000000000000e+00 -1.386119257086999013e-01 0.000000000000000000e+00 -1.388074291300097629e-01 0.000000000000000000e+00 -1.390029325513196523e-01 0.000000000000000000e+00 -1.391984359726295140e-01 0.000000000000000000e+00 -1.393939393939394034e-01 0.000000000000000000e+00 -1.395894428152492650e-01 0.000000000000000000e+00 -1.397849462365591267e-01 0.000000000000000000e+00 -1.399804496578690161e-01 0.000000000000000000e+00 -1.401759530791788777e-01 0.000000000000000000e+00 -1.403714565004887671e-01 0.000000000000000000e+00 -1.405669599217986288e-01 0.000000000000000000e+00 -1.407624633431084904e-01 0.000000000000000000e+00 -1.409579667644183798e-01 0.000000000000000000e+00 -1.411534701857282414e-01 0.000000000000000000e+00 -1.413489736070381309e-01 0.000000000000000000e+00 -1.415444770283479925e-01 0.000000000000000000e+00 -1.417399804496578819e-01 0.000000000000000000e+00 -1.419354838709677435e-01 0.000000000000000000e+00 -1.421309872922776052e-01 0.000000000000000000e+00 -1.423264907135874946e-01 0.000000000000000000e+00 -1.425219941348973562e-01 0.000000000000000000e+00 -1.427174975562072456e-01 0.000000000000000000e+00 -1.429130009775171073e-01 0.000000000000000000e+00 -1.431085043988269689e-01 0.000000000000000000e+00 -1.433040078201368583e-01 0.000000000000000000e+00 -1.434995112414467200e-01 0.000000000000000000e+00 -1.436950146627566094e-01 0.000000000000000000e+00 -1.438905180840664710e-01 0.000000000000000000e+00 -1.440860215053763327e-01 0.000000000000000000e+00 -1.442815249266862221e-01 0.000000000000000000e+00 -1.444770283479960837e-01 0.000000000000000000e+00 -1.446725317693059731e-01 0.000000000000000000e+00 -1.448680351906158348e-01 0.000000000000000000e+00 -1.450635386119256964e-01 0.000000000000000000e+00 -1.452590420332355858e-01 0.000000000000000000e+00 -1.454545454545454475e-01 0.000000000000000000e+00 -1.456500488758553369e-01 0.000000000000000000e+00 -1.458455522971651985e-01 0.000000000000000000e+00 -1.460410557184750602e-01 0.000000000000000000e+00 -1.462365591397849496e-01 0.000000000000000000e+00 -1.464320625610948112e-01 0.000000000000000000e+00 -1.466275659824047006e-01 0.000000000000000000e+00 -1.468230694037145623e-01 0.000000000000000000e+00 -1.470185728250244517e-01 0.000000000000000000e+00 -1.472140762463343133e-01 0.000000000000000000e+00 -1.474095796676441750e-01 0.000000000000000000e+00 -1.476050830889540644e-01 0.000000000000000000e+00 -1.478005865102639260e-01 0.000000000000000000e+00 -1.479960899315738154e-01 0.000000000000000000e+00 -1.481915933528836771e-01 0.000000000000000000e+00 -1.483870967741935387e-01 0.000000000000000000e+00 -1.485826001955034281e-01 0.000000000000000000e+00 -1.487781036168132898e-01 0.000000000000000000e+00 -1.489736070381231792e-01 0.000000000000000000e+00 -1.491691104594330408e-01 0.000000000000000000e+00 -1.493646138807429025e-01 0.000000000000000000e+00 -1.495601173020527919e-01 0.000000000000000000e+00 -1.497556207233626535e-01 0.000000000000000000e+00 -1.499511241446725429e-01 0.000000000000000000e+00 -1.501466275659824046e-01 0.000000000000000000e+00 -1.503421309872922662e-01 0.000000000000000000e+00 -1.505376344086021556e-01 0.000000000000000000e+00 -1.507331378299120173e-01 0.000000000000000000e+00 -1.509286412512219067e-01 0.000000000000000000e+00 -1.511241446725317683e-01 0.000000000000000000e+00 -1.513196480938416300e-01 0.000000000000000000e+00 -1.515151515151515194e-01 0.000000000000000000e+00 -1.517106549364613810e-01 0.000000000000000000e+00 -1.519061583577712704e-01 0.000000000000000000e+00 -1.521016617790811321e-01 0.000000000000000000e+00 -1.522971652003909937e-01 0.000000000000000000e+00 -1.524926686217008831e-01 0.000000000000000000e+00 -1.526881720430107447e-01 0.000000000000000000e+00 -1.528836754643206342e-01 0.000000000000000000e+00 -1.530791788856304958e-01 0.000000000000000000e+00 -1.532746823069403574e-01 0.000000000000000000e+00 -1.534701857282502468e-01 0.000000000000000000e+00 -1.536656891495601085e-01 0.000000000000000000e+00 -1.538611925708699979e-01 0.000000000000000000e+00 -1.540566959921798595e-01 0.000000000000000000e+00 -1.542521994134897489e-01 0.000000000000000000e+00 -1.544477028347996106e-01 0.000000000000000000e+00 -1.546432062561094722e-01 0.000000000000000000e+00 -1.548387096774193616e-01 0.000000000000000000e+00 -1.550342130987292233e-01 0.000000000000000000e+00 -1.552297165200391127e-01 0.000000000000000000e+00 -1.554252199413489743e-01 0.000000000000000000e+00 -1.556207233626588360e-01 0.000000000000000000e+00 -1.558162267839687254e-01 0.000000000000000000e+00 -1.560117302052785870e-01 0.000000000000000000e+00 -1.562072336265884764e-01 0.000000000000000000e+00 -1.564027370478983381e-01 0.000000000000000000e+00 -1.565982404692081997e-01 0.000000000000000000e+00 -1.567937438905180891e-01 0.000000000000000000e+00 -1.569892473118279508e-01 0.000000000000000000e+00 -1.571847507331378402e-01 0.000000000000000000e+00 -1.573802541544477018e-01 0.000000000000000000e+00 -1.575757575757575635e-01 0.000000000000000000e+00 -1.577712609970674529e-01 0.000000000000000000e+00 -1.579667644183773145e-01 0.000000000000000000e+00 -1.581622678396872039e-01 0.000000000000000000e+00 -1.583577712609970656e-01 0.000000000000000000e+00 -1.585532746823069272e-01 0.000000000000000000e+00 -1.587487781036168166e-01 0.000000000000000000e+00 -1.589442815249266783e-01 0.000000000000000000e+00 -1.591397849462365677e-01 0.000000000000000000e+00 -1.593352883675464293e-01 0.000000000000000000e+00 -1.595307917888563187e-01 0.000000000000000000e+00 -1.597262952101661804e-01 0.000000000000000000e+00 -1.599217986314760420e-01 0.000000000000000000e+00 -1.601173020527859314e-01 0.000000000000000000e+00 -1.603128054740957931e-01 0.000000000000000000e+00 -1.605083088954056825e-01 0.000000000000000000e+00 -1.607038123167155441e-01 0.000000000000000000e+00 -1.608993157380254058e-01 0.000000000000000000e+00 -1.610948191593352952e-01 0.000000000000000000e+00 -1.612903225806451568e-01 0.000000000000000000e+00 -1.614858260019550462e-01 0.000000000000000000e+00 -1.616813294232649079e-01 0.000000000000000000e+00 -1.618768328445747695e-01 0.000000000000000000e+00 -1.620723362658846589e-01 0.000000000000000000e+00 -1.622678396871945206e-01 0.000000000000000000e+00 -1.624633431085044100e-01 0.000000000000000000e+00 -1.626588465298142716e-01 0.000000000000000000e+00 -1.628543499511241333e-01 0.000000000000000000e+00 -1.630498533724340227e-01 0.000000000000000000e+00 -1.632453567937438843e-01 0.000000000000000000e+00 -1.634408602150537737e-01 0.000000000000000000e+00 -1.636363636363636354e-01 0.000000000000000000e+00 -1.638318670576734970e-01 0.000000000000000000e+00 -1.640273704789833864e-01 0.000000000000000000e+00 -1.642228739002932481e-01 0.000000000000000000e+00 -1.644183773216031375e-01 0.000000000000000000e+00 -1.646138807429129991e-01 0.000000000000000000e+00 -1.648093841642228607e-01 0.000000000000000000e+00 -1.650048875855327501e-01 0.000000000000000000e+00 -1.652003910068426118e-01 0.000000000000000000e+00 -1.653958944281525012e-01 0.000000000000000000e+00 -1.655913978494623628e-01 0.000000000000000000e+00 -1.657869012707722245e-01 0.000000000000000000e+00 -1.659824046920821139e-01 0.000000000000000000e+00 -1.661779081133919755e-01 0.000000000000000000e+00 -1.663734115347018649e-01 0.000000000000000000e+00 -1.665689149560117266e-01 0.000000000000000000e+00 -1.667644183773216160e-01 0.000000000000000000e+00 -1.669599217986314776e-01 0.000000000000000000e+00 -1.671554252199413393e-01 0.000000000000000000e+00 -1.673509286412512287e-01 0.000000000000000000e+00 -1.675464320625610903e-01 0.000000000000000000e+00 -1.677419354838709797e-01 0.000000000000000000e+00 -1.679374389051808414e-01 0.000000000000000000e+00 -1.681329423264907030e-01 0.000000000000000000e+00 -1.683284457478005924e-01 0.000000000000000000e+00 -1.685239491691104541e-01 0.000000000000000000e+00 -1.687194525904203435e-01 0.000000000000000000e+00 -1.689149560117302051e-01 0.000000000000000000e+00 -1.691104594330400668e-01 0.000000000000000000e+00 -1.693059628543499562e-01 0.000000000000000000e+00 -1.695014662756598178e-01 0.000000000000000000e+00 -1.696969696969697072e-01 0.000000000000000000e+00 -1.698924731182795689e-01 0.000000000000000000e+00 -1.700879765395894305e-01 0.000000000000000000e+00 -1.702834799608993199e-01 0.000000000000000000e+00 -1.704789833822091816e-01 0.000000000000000000e+00 -1.706744868035190710e-01 0.000000000000000000e+00 -1.708699902248289326e-01 0.000000000000000000e+00 -1.710654936461387943e-01 0.000000000000000000e+00 -1.712609970674486837e-01 0.000000000000000000e+00 -1.714565004887585453e-01 0.000000000000000000e+00 -1.716520039100684347e-01 0.000000000000000000e+00 -1.718475073313782964e-01 0.000000000000000000e+00 -1.720430107526881858e-01 0.000000000000000000e+00 -1.722385141739980474e-01 0.000000000000000000e+00 -1.724340175953079091e-01 0.000000000000000000e+00 -1.726295210166177985e-01 0.000000000000000000e+00 -1.728250244379276601e-01 0.000000000000000000e+00 -1.730205278592375495e-01 0.000000000000000000e+00 -1.732160312805474112e-01 0.000000000000000000e+00 -1.734115347018572728e-01 0.000000000000000000e+00 -1.736070381231671622e-01 0.000000000000000000e+00 -1.738025415444770239e-01 0.000000000000000000e+00 -1.739980449657869133e-01 0.000000000000000000e+00 -1.741935483870967749e-01 0.000000000000000000e+00 -1.743890518084066366e-01 0.000000000000000000e+00 -1.745845552297165260e-01 0.000000000000000000e+00 -1.747800586510263876e-01 0.000000000000000000e+00 -1.749755620723362770e-01 0.000000000000000000e+00 -1.751710654936461387e-01 0.000000000000000000e+00 -1.753665689149560003e-01 0.000000000000000000e+00 -1.755620723362658897e-01 0.000000000000000000e+00 -1.757575757575757514e-01 0.000000000000000000e+00 -1.759530791788856408e-01 0.000000000000000000e+00 -1.761485826001955024e-01 0.000000000000000000e+00 -1.763440860215053640e-01 0.000000000000000000e+00 -1.765395894428152535e-01 0.000000000000000000e+00 -1.767350928641251151e-01 0.000000000000000000e+00 -1.769305962854350045e-01 0.000000000000000000e+00 -1.771260997067448661e-01 0.000000000000000000e+00 -1.773216031280547278e-01 0.000000000000000000e+00 -1.775171065493646172e-01 0.000000000000000000e+00 -1.777126099706744788e-01 0.000000000000000000e+00 -1.779081133919843682e-01 0.000000000000000000e+00 -1.781036168132942299e-01 0.000000000000000000e+00 -1.782991202346040915e-01 0.000000000000000000e+00 -1.784946236559139809e-01 0.000000000000000000e+00 -1.786901270772238426e-01 0.000000000000000000e+00 -1.788856304985337320e-01 0.000000000000000000e+00 -1.790811339198435936e-01 0.000000000000000000e+00 -1.792766373411534830e-01 0.000000000000000000e+00 -1.794721407624633447e-01 0.000000000000000000e+00 -1.796676441837732063e-01 0.000000000000000000e+00 -1.798631476050830957e-01 0.000000000000000000e+00 -1.800586510263929574e-01 0.000000000000000000e+00 -1.802541544477028468e-01 0.000000000000000000e+00 -1.804496578690127084e-01 0.000000000000000000e+00 -1.806451612903225701e-01 0.000000000000000000e+00 -1.808406647116324595e-01 0.000000000000000000e+00 -1.810361681329423211e-01 0.000000000000000000e+00 -1.812316715542522105e-01 0.000000000000000000e+00 -1.814271749755620722e-01 0.000000000000000000e+00 -1.816226783968719338e-01 0.000000000000000000e+00 -1.818181818181818232e-01 0.000000000000000000e+00 -1.820136852394916849e-01 0.000000000000000000e+00 -1.822091886608015743e-01 0.000000000000000000e+00 -1.824046920821114359e-01 0.000000000000000000e+00 -1.826001955034212976e-01 0.000000000000000000e+00 -1.827956989247311870e-01 0.000000000000000000e+00 -1.829912023460410486e-01 0.000000000000000000e+00 -1.831867057673509380e-01 0.000000000000000000e+00 -1.833822091886607997e-01 0.000000000000000000e+00 -1.835777126099706613e-01 0.000000000000000000e+00 -1.837732160312805507e-01 0.000000000000000000e+00 -1.839687194525904124e-01 0.000000000000000000e+00 -1.841642228739003018e-01 0.000000000000000000e+00 -1.843597262952101634e-01 0.000000000000000000e+00 -1.845552297165200528e-01 0.000000000000000000e+00 -1.847507331378299145e-01 0.000000000000000000e+00 -1.849462365591397761e-01 0.000000000000000000e+00 -1.851417399804496655e-01 0.000000000000000000e+00 -1.853372434017595272e-01 0.000000000000000000e+00 -1.855327468230694166e-01 0.000000000000000000e+00 -1.857282502443792782e-01 0.000000000000000000e+00 -1.859237536656891399e-01 0.000000000000000000e+00 -1.861192570869990293e-01 0.000000000000000000e+00 -1.863147605083088909e-01 0.000000000000000000e+00 -1.865102639296187803e-01 0.000000000000000000e+00 -1.867057673509286420e-01 0.000000000000000000e+00 -1.869012707722385036e-01 0.000000000000000000e+00 -1.870967741935483930e-01 0.000000000000000000e+00 -1.872922776148582547e-01 0.000000000000000000e+00 -1.874877810361681441e-01 0.000000000000000000e+00 -1.876832844574780057e-01 0.000000000000000000e+00 -1.878787878787878673e-01 0.000000000000000000e+00 -1.880742913000977568e-01 0.000000000000000000e+00 -1.882697947214076184e-01 0.000000000000000000e+00 -1.884652981427175078e-01 0.000000000000000000e+00 -1.886608015640273694e-01 0.000000000000000000e+00 -1.888563049853372311e-01 0.000000000000000000e+00 -1.890518084066471205e-01 0.000000000000000000e+00 -1.892473118279569821e-01 0.000000000000000000e+00 -1.894428152492668715e-01 0.000000000000000000e+00 -1.896383186705767332e-01 0.000000000000000000e+00 -1.898338220918865948e-01 0.000000000000000000e+00 -1.900293255131964842e-01 0.000000000000000000e+00 -1.902248289345063459e-01 0.000000000000000000e+00 -1.904203323558162353e-01 0.000000000000000000e+00 -1.906158357771260969e-01 0.000000000000000000e+00 -1.908113391984359586e-01 0.000000000000000000e+00 -1.910068426197458480e-01 0.000000000000000000e+00 -1.912023460410557096e-01 0.000000000000000000e+00 -1.913978494623655990e-01 0.000000000000000000e+00 -1.915933528836754607e-01 0.000000000000000000e+00 -1.917888563049853501e-01 0.000000000000000000e+00 -1.919843597262952117e-01 0.000000000000000000e+00 -1.921798631476050734e-01 0.000000000000000000e+00 -1.923753665689149628e-01 0.000000000000000000e+00 -1.925708699902248244e-01 0.000000000000000000e+00 -1.927663734115347138e-01 0.000000000000000000e+00 -1.929618768328445755e-01 0.000000000000000000e+00 -1.931573802541544371e-01 0.000000000000000000e+00 -1.933528836754643265e-01 0.000000000000000000e+00 -1.935483870967741882e-01 0.000000000000000000e+00 -1.937438905180840776e-01 0.000000000000000000e+00 -1.939393939393939392e-01 0.000000000000000000e+00 -1.941348973607038009e-01 0.000000000000000000e+00 -1.943304007820136903e-01 0.000000000000000000e+00 -1.945259042033235519e-01 0.000000000000000000e+00 -1.947214076246334413e-01 0.000000000000000000e+00 -1.949169110459433030e-01 0.000000000000000000e+00 -1.951124144672531646e-01 0.000000000000000000e+00 -1.953079178885630540e-01 0.000000000000000000e+00 -1.955034213098729157e-01 0.000000000000000000e+00 -1.956989247311828051e-01 0.000000000000000000e+00 -1.958944281524926667e-01 0.000000000000000000e+00 -1.960899315738025284e-01 0.000000000000000000e+00 -1.962854349951124178e-01 0.000000000000000000e+00 -1.964809384164222794e-01 0.000000000000000000e+00 -1.966764418377321688e-01 0.000000000000000000e+00 -1.968719452590420305e-01 0.000000000000000000e+00 -1.970674486803519199e-01 0.000000000000000000e+00 -1.972629521016617815e-01 0.000000000000000000e+00 -1.974584555229716432e-01 0.000000000000000000e+00 -1.976539589442815326e-01 0.000000000000000000e+00 -1.978494623655913942e-01 0.000000000000000000e+00 -1.980449657869012836e-01 0.000000000000000000e+00 -1.982404692082111453e-01 0.000000000000000000e+00 -1.984359726295210069e-01 0.000000000000000000e+00 -1.986314760508308963e-01 0.000000000000000000e+00 -1.988269794721407580e-01 0.000000000000000000e+00 -1.990224828934506474e-01 0.000000000000000000e+00 -1.992179863147605090e-01 0.000000000000000000e+00 -1.994134897360703707e-01 0.000000000000000000e+00 -1.996089931573802601e-01 0.000000000000000000e+00 -1.998044965786901217e-01 0.000000000000000000e+00 -2.000000000000000111e-01 0.000000000000000000e+00 From 559e7bb7e067764063703eb693a24666d0ae89b1 Mon Sep 17 00:00:00 2001 From: Walter3ffb <89849649+Walter3ffb@users.noreply.github.com> Date: Mon, 11 Jul 2022 14:13:47 -0400 Subject: [PATCH 6/6] Delete src/.ipynb_checkpoints directory --- src/.ipynb_checkpoints/common-checkpoint.c | 750 --------- src/.ipynb_checkpoints/common-checkpoint.h | 618 -------- src/.ipynb_checkpoints/cosmo-checkpoint.c | 868 ---------- src/.ipynb_checkpoints/cosmo_mad-checkpoint.c | 520 ------ src/.ipynb_checkpoints/cstm-checkpoint.c | 158 -- src/.ipynb_checkpoints/density-checkpoint.c | 1393 ----------------- src/.ipynb_checkpoints/fftlog-checkpoint.c | 157 -- src/.ipynb_checkpoints/fourier-checkpoint.c | 423 ----- .../healpix_extra-checkpoint.c | 885 ----------- src/.ipynb_checkpoints/imap-checkpoint.c | 316 ---- src/.ipynb_checkpoints/io-checkpoint.c | 1374 ---------------- src/.ipynb_checkpoints/isw-checkpoint.c | 153 -- src/.ipynb_checkpoints/kappa-checkpoint.c | 181 --- src/.ipynb_checkpoints/lensing-checkpoint.c | 256 --- src/.ipynb_checkpoints/main-checkpoint.c | 154 -- .../predictions-checkpoint.c | 173 -- src/.ipynb_checkpoints/srcs-checkpoint.c | 763 --------- 17 files changed, 9142 deletions(-) delete mode 100644 src/.ipynb_checkpoints/common-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/common-checkpoint.h delete mode 100644 src/.ipynb_checkpoints/cosmo-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/cosmo_mad-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/cstm-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/density-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/fftlog-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/fourier-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/healpix_extra-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/imap-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/io-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/isw-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/kappa-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/lensing-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/main-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/predictions-checkpoint.c delete mode 100644 src/.ipynb_checkpoints/srcs-checkpoint.c diff --git a/src/.ipynb_checkpoints/common-checkpoint.c b/src/.ipynb_checkpoints/common-checkpoint.c deleted file mode 100644 index cf7429f..0000000 --- a/src/.ipynb_checkpoints/common-checkpoint.c +++ /dev/null @@ -1,750 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -#ifdef _HAVE_OMP -static double relbeg,relend,absbeg,absend; -#else //_HAVE_OMP -static time_t relbeg,relend,absbeg,absend; -#endif //_HAVE_OMP -int NodeThis=0; -int NodeLeft=0; -int NodeRight=0; -int NNodes=1; -int IThread0=0; -int MPIThreadsOK=0; - -void *my_malloc(size_t size) -{ - void *ptrout=malloc(size); - if(ptrout==NULL) { - fprintf(stderr,"out of memory\n"); - exit(1); - } - - return ptrout; -} - -void *my_calloc(size_t nmemb,size_t size) -{ - void *ptrout=calloc(nmemb,size); - if(ptrout==NULL) { - fprintf(stderr,"out of memory\n"); - exit(1); - } - - return ptrout; -} - -void error_open_file(char *fname) -{ - fprintf(stderr,"CoLoRe: Couldn't open file %s \n",fname); - exit(1); -} - -void error_read_line(char *fname,int nlin) -{ - fprintf(stderr,"CoLoRe: Error reading file %s, line %d \n",fname,nlin); - exit(1); -} - -int linecount(FILE *f) -{ - ////// - // Counts #lines from file - int i0=0; - char ch[1000]; - while((fgets(ch,sizeof(ch),f))!=NULL) { - i0++; - } - return i0; -} - -typedef struct { - int i; - flouble d; -} IsortStruct; - -static int compareIsort(const void *a,const void *b) -{ - IsortStruct *ia=(IsortStruct *)a; - IsortStruct *ib=(IsortStruct *)b; - if(ia->dd) return -1; - else return 1; -} - -int *ind_sort(int n,flouble *arr) -{ - int i; - IsortStruct *st=my_malloc(n*sizeof(IsortStruct)); - for(i=0;i initialize relative clock - // timer(1) -> read relative clock - // timer(2) -> read relative clock and initialize it afterwards - // timer(4) -> initialize absolute clock - // timer(5) -> read absolute clock -#ifdef _HAVE_OMP - if(i==0) - relbeg=omp_get_wtime(); - else if(i==1) { - relend=omp_get_wtime(); - printf("> Relative time ellapsed %.1lf ms\n",1000*(relend-relbeg)); - } - else if(i==2) { - relend=omp_get_wtime(); - printf("> Relative time ellapsed %.1lf ms\n",1000*(relend-relbeg)); - relbeg=omp_get_wtime(); - } - else if(i==4) - absbeg=omp_get_wtime(); - else if(i==5) { - absend=omp_get_wtime(); - printf("> Total time ellapsed %.1lf ms\n",1000*(absend-absbeg)); - } -#else //_NO_OMP - int diff; - - if(i==0) - relbeg=time(NULL); - else if(i==1) { - relend=time(NULL); - diff=(int)(difftime(relend,relbeg)); - printf("> Relative time ellapsed %02d:%02d:%02d \n", - diff/3600,(diff/60)%60,diff%60); - } - else if(i==2) { - relend=time(NULL); - diff=(int)(difftime(relend,relbeg)); - printf("> Relative time ellapsed %02d:%02d:%02d \n", - diff/3600,(diff/60)%60,diff%60); - relbeg=time(NULL); - } - else if(i==4) - absbeg=time(NULL); - else if(i==5) { - absend=time(NULL); - diff=(int)(difftime(absend,absbeg)); - printf("> Total time ellapsed %02d:%02d:%02d \n", - diff/3600,(diff/60)%60,diff%60); - } -#endif //_NO_OMP -} - -gsl_rng *init_rng(unsigned int seed) -{ - // gsl_rng *rng=gsl_rng_alloc(gsl_rng_ranlux); - gsl_rng *rng=gsl_rng_alloc(gsl_rng_mt19937); - gsl_rng_set(rng,seed); - - return rng; -} - -double rng_01(gsl_rng *rng) -{ - double result=gsl_rng_uniform(rng); - return result; -} - -int rng_poisson(double lambda,gsl_rng *rng) -{ - unsigned int pois=gsl_ran_poisson(rng,lambda); - return (int)pois; -} - -void rng_delta_gauss(double *module,double *phase, - gsl_rng *rng,double sigma2) -{ - ////// - // Returns module and phase of two random - // gaussian numbers. I.e.: - double u; - *phase=2*M_PI*rng_01(rng); - u=rng_01(rng); - *module=sqrt(-sigma2*log(1-u)); -} - -void rng_gauss(gsl_rng *rng,double *r1,double *r2) -{ - double phase=2*M_PI*rng_01(rng); - double u=sqrt(-2*log(1-rng_01(rng))); - *r1=u*cos(phase); - *r2=u*sin(phase); -} - -void end_rng(gsl_rng *rng) -{ - gsl_rng_free(rng); -} - -void mpi_init(int* p_argc,char*** p_argv) -{ -#ifdef _HAVE_MPI - int ii,nthreads_this; - int *nthreads_all; -#ifdef _HAVE_OMP - int provided; - MPI_Init_thread(p_argc,p_argv,MPI_THREAD_FUNNELED,&provided); - MPIThreadsOK=provided>=MPI_THREAD_FUNNELED; -#else //_HAVE_OMP - MPI_Init(p_argc,p_argv); - MPIThreadsOK=0; -#endif //_HAVE_OMP - - MPI_Comm_size(MPI_COMM_WORLD,&NNodes); - MPI_Comm_rank(MPI_COMM_WORLD,&NodeThis); - if(NodeThis==0) - NodeLeft=NNodes-1; - else - NodeLeft=NodeThis-1; - if(NodeThis==NNodes-1) - NodeRight=0; - else - NodeRight=NodeThis+1; - - nthreads_all=my_malloc(NNodes*sizeof(int)); -#ifdef _HAVE_OMP - nthreads_this=omp_get_max_threads(); -#else //_HAVE_OMP - nthreads_this=1; -#endif //_HAVE_OMP - MPI_Allgather(&nthreads_this,1,MPI_INT,nthreads_all,1,MPI_INT,MPI_COMM_WORLD); -#ifdef _DEBUG - if(NodeThis==0) { - for(ii=0;iiNSIDE_MAX_HPX) - n_extra/=2; - if(n_extra<=0) n_extra=1; //This should never happen - - int i_extra=(int)(n_extra*n_extra*rng_01(rng)); - pix2ang_nest(nside*n_extra, - (ipix0+ipix_nest)*n_extra*n_extra+i_extra,th,phi); - (*phi)+=(rng_01(rng)-0.5)*0.57/(nside*n_extra); - (*th)+=(rng_01(rng)-0.5)*0.57/(nside*n_extra); -} -*/ - -void get_radial_params(double rmax,int ngrid,int *nr,double *dr) -{ - *nr=NSAMP_RAD*ngrid/2; - *dr=rmax/(*nr); -} - -CatalogCartesian *catalog_cartesian_alloc(int nsrcs) -{ - CatalogCartesian *cat=my_malloc(sizeof(CatalogCartesian)); - - if(nsrcs>0) { - cat->nsrc=nsrcs; - cat->pos=my_malloc(NPOS_CC*nsrcs*sizeof(float)); - cat->ipix=my_malloc(nsrcs*sizeof(int)); - } - else { - cat->nsrc=0; - cat->pos=NULL; - cat->ipix=NULL; - } - - return cat; -} - -void catalog_cartesian_free(CatalogCartesian *cat) -{ - if(cat->nsrc>0) { - free(cat->pos); - free(cat->ipix); - } - free(cat); -} - -Catalog *catalog_alloc(int nsrcs,int has_lensing,int has_skw, - int skw_gauss,double rmax,int ng) -{ - Catalog *cat=my_malloc(sizeof(Catalog)); - - if(nsrcs>0) { - cat->nsrc=nsrcs; - cat->srcs=my_malloc(nsrcs*sizeof(Src)); - cat->has_lensing=has_lensing; - cat->has_skw=has_skw; - cat->skw_gauss=skw_gauss; - get_radial_params(rmax,ng,&(cat->nr),&(cat->dr)); - cat->rmax=rmax; - cat->idr=1./cat->dr; - if(has_skw) { - if(skw_gauss) { - cat->g_skw=my_calloc(cat->nsrc*cat->nr,sizeof(float)); - } - else { - cat->d_skw=my_calloc(cat->nsrc*cat->nr,sizeof(float)); - } - cat->v_skw=my_calloc(cat->nsrc*cat->nr,sizeof(float)); - } - } - else { - cat->nsrc=0; - cat->srcs=NULL; - cat->has_skw=0; - } - - return cat; -} - -void catalog_free(Catalog *cat) -{ - if(cat->nsrc>0) { - free(cat->srcs); - if(cat->has_skw) { - if(cat->skw_gauss) { - free(cat->g_skw); - } - else { - free(cat->d_skw); - } - free(cat->v_skw); - } - } - free(cat); -} - -void hp_shell_adaptive_free(HealpixShellsAdaptive *shell) -{ - int ib,ir; - free(shell->r); - free(shell->nside); - free(shell->num_pix_per_beam); - for(ib=0;ibnbeams;ib++) { - for(ir=0;irnr;ir++) - free(shell->data[ib][ir]); - free(shell->data[ib]); - free(shell->pos[ib]); - } - free(shell->data); - free(shell->pos); - free(shell); -} - -static int *get_adaptive_nside(int nside_max, int nside_base, - int nr, flouble *r_arr, flouble dx, flouble dx_fraction) -{ - int ir; - int *nsides=my_malloc(nr*sizeof(int)); - for(ir=0; irNSIDE_MAX_HPX) - report_error(1,"Can't go beyond nside=%d\n",NSIDE_MAX_HPX); - if(nside_maxnbeams=0; - for(ib=NodeThis;ibnbeams++; - - shell->nq=nq; - shell->nr=nr; - shell->nside=get_adaptive_nside(nside_max, nside_base, nr, - r_arr, dx, dx_fraction); - shell->num_pix_per_beam=my_malloc(nr*sizeof(long)); - shell->r=my_malloc(nr*sizeof(flouble)); - for(ir=0; irr[ir]=r_arr[ir]; - nside_ratio=shell->nside[ir]/nside_base; - shell->num_pix_per_beam[ir]=nside_ratio*nside_ratio; - } - - long npix_hi=shell->num_pix_per_beam[nr-1]; - shell->data=my_malloc(shell->nbeams*sizeof(flouble **)); - shell->pos=my_malloc(shell->nbeams*sizeof(double **)); - for(ib=0;ibnbeams;ib++) { - shell->data[ib]=my_malloc(nr*sizeof(flouble *)); - shell->pos[ib]=my_malloc(npix_hi*3*sizeof(double)); - for(ir=0; irdata[ib][ir]=my_malloc(shell->nq*shell->num_pix_per_beam[ir]*sizeof(flouble)); - } - - for(ib=0;ibnbeams;ib++) { - long ip, ip0=(ib*NNodes+NodeThis)*npix_hi; - double *u=shell->pos[ib]; - for(ip=0;ipnside[nr-1],id_nest,u); - u+=3; - } - } - return shell; -} - -HealpixShells *hp_shell_alloc(int nq, int nside,int nside_base,int nr) -{ - if(nside>NSIDE_MAX_HPX) - report_error(1,"Can't go beyond nside=%d\n",NSIDE_MAX_HPX); - if(nsidenq=nq; - shell->nside=nside; - shell->num_pix=nside_ratio*nside_ratio*nbeams_here; - shell->listpix=my_malloc(shell->num_pix*sizeof(long)); - shell->pos=my_malloc(3*shell->num_pix*sizeof(double)); - - double *u=shell->pos; - long ipix=0; - for(ib=NodeThis;iblistpix[ipix]=id_nest; - pix2vec_nest(shell->nside,id_nest,u); - u+=3; - ipix++; - } - } - - //Figure out radial shells - shell->nr=nr; - shell->r0=my_malloc(shell->nr*sizeof(flouble)); - shell->rf=my_malloc(shell->nr*sizeof(flouble)); - - //Zero all data and clear - shell->data=my_calloc(shell->nq*shell->nr*shell->num_pix,sizeof(flouble)); - shell->nadd=my_calloc(shell->nr*shell->num_pix,sizeof(int)); - - return shell; -} - -void hp_shell_free(HealpixShells *shell) -{ - if(shell->listpix!=NULL) - free(shell->listpix); - if(shell->pos!=NULL) - free(shell->pos); - if(shell->r0!=NULL) - free(shell->r0); - if(shell->rf!=NULL) - free(shell->rf); - if(shell->data!=NULL) - free(shell->data); - if(shell->nadd!=NULL) - free(shell->nadd); - free(shell); -} - -unsigned long long get_max_memory(ParamCoLoRe *par,int just_test) -{ - unsigned long long total_GB=0; - unsigned long long total_GB_gau=0; - unsigned long long total_GB_lpt=0; - int fac_gau=2; - if(par->need_beaming) fac_gau=3; - - total_GB_gau=(fac_gau*(par->nz_here+1)*((long)(par->n_grid*(par->n_grid/2+1))))*sizeof(dftw_complex); - - if(par->dens_type==DENS_TYPE_1LPT) { - total_GB_lpt=(unsigned long long)(3*(1+par->lpt_buffer_fraction)*par->nz_here* - ((long)((par->n_grid/2+1)*par->n_grid))*sizeof(dftw_complex)); - } - else if(par->dens_type==DENS_TYPE_2LPT) { - total_GB_lpt=0; - total_GB_lpt=(unsigned long long)(8*(1+par->lpt_buffer_fraction)*par->nz_here* - ((long)((par->n_grid/2+1)*par->n_grid))*sizeof(dftw_complex)); - } - - unsigned long long total_GB_srcs=0; - if(par->do_srcs) { - int ipop; - for(ipop=0;ipopn_srcs;ipop++) { - int nz,ii; - long nsrc=0; - double nztot=0; - FILE *fi=fopen(par->fnameNzSrcs[ipop],"r"); - - double *zarr,*nzarr; - if(fi==NULL) error_open_file(par->fnameNzSrcs[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - nzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameNzSrcs[ipop],ii+1); - nzarr[ii]*=RTOD*RTOD; - } - for(ii=0;ii=par->z_min) && (zarr[ii]<=par->z_max)) - nztot+=nzarr[ii]*(zarr[ii+1]-zarr[ii]); - } - if((zarr[ii]>=par->z_min) && (zarr[ii]<=par->z_max)) - nztot+=nzarr[ii]*(zarr[ii+1]-zarr[ii]); - nztot*=4*M_PI/NNodes; - nsrc+=(long)(nztot); - if(just_test) - print_info(" Expect %ld type-%d sources\n",(long)(nztot*NNodes),ipop); - free(zarr); - free(nzarr); - fclose(fi); - - long size_source=sizeof(Src)+NPOS_CC*sizeof(float)+sizeof(int); - if(par->skw_srcs[ipop]) { - int nr=NSAMP_RAD*par->n_grid/2; - size_source+=2*nr*sizeof(float); - } - total_GB_srcs+=size_source*nsrc; - } - } - - unsigned long long total_GB_imap=0; - if(par->do_imap) { - int ipop; - for(ipop=0;ipopn_imap;ipop++) { - int nr; - unsigned long long size_map=he_nside2npix(par->nside_imap[ipop]); - FILE *fnu=fopen(par->fnameNuImap[ipop],"r"); - if(fnu==NULL) error_open_file(par->fnameNuImap[ipop]); - nr=linecount(fnu); - fclose(fnu); - total_GB_imap+=size_map*nr*(sizeof(flouble)+sizeof(int)); - } - } - - unsigned long long total_GB_cstm=0; - if(par->do_cstm) { - int ipop; - for(ipop=0;ipopn_cstm;ipop++) { - unsigned long long size_map=he_nside2npix(par->nside_cstm[ipop]); - total_GB_cstm+=size_map*(sizeof(flouble)+sizeof(int)); - } - } - - unsigned long long total_GB_kappa=0; - if(par->do_kappa) { - int ib; - int nr=par->n_kappa; - int nbases=he_nside2npix(par->nside_base); - int nside_ratio=par->nside_kappa/par->nside_base; - int npix_perbeam=nside_ratio*nside_ratio; - unsigned long long size_map=0; - for(ib=NodeThis;ibdo_lensing) { - int ib,ir; - int nr=par->n_lensing; - int nbases=he_nside2npix(par->nside_base); - flouble *rs=compute_lensing_spacing(par); - int *nsides=get_adaptive_nside(par->nside_lensing, - par->nside_base, nr, rs, - par->l_box/par->n_grid, 1.); - int nbeams_here=0; - for(ib=NodeThis;ibnside_base; - npix_total+=nside_ratio*nside_ratio; - } - npix_total*=nbeams_here; - int nside_ratio_hi=nsides[nr-1]/par->nside_base; - unsigned long long npix_hi=nside_ratio_hi*nside_ratio_hi*nbeams_here; - total_GB_lensing+=npix_total*5*sizeof(flouble)+npix_hi*3*sizeof(double); - free(rs); - free(nsides); - } - - unsigned long long total_GB_isw=0; - if(par->do_isw) { - int ib; - int nr=par->n_isw; - int nbases=he_nside2npix(par->nside_base); - int nside_ratio=par->nside_isw/par->nside_base; - int npix_perbeam=nside_ratio*nside_ratio; - unsigned long long size_map=0; - for(ib=NodeThis;ibdens_type==DENS_TYPE_1LPT) || (par->dens_type==DENS_TYPE_2LPT)) - printf(", %.3lf GB (%dLPT)",(double)(total_GB_lpt/pow(1024.,3)),par->dens_type); - if(par->do_srcs) - printf(", %.3lf GB (srcs)",(double)(total_GB_srcs/pow(1024.,3))); - if(par->do_imap) - printf(", %.3lf GB (imap)",(double)(total_GB_imap/pow(1024.,3))); - if(par->do_kappa) - printf(", %.3lf MB (kappa)",(double)(total_GB_kappa/pow(1024.,2))); - if(par->do_lensing) - printf(", %.3lf MB (lensing)",(double)(total_GB_lensing/pow(1024.,2))); - if(par->do_isw) - printf(", %.3lf MB (isw)",(double)(total_GB_isw/pow(1024.,2))); - if(par->do_cstm) - printf(", %.3lf MB (custom)",(double)(total_GB_cstm/pow(1024.,2))); - printf("]\n"); - } -#ifdef _HAVE_MPI - MPI_Barrier(MPI_COMM_WORLD); -#endif //_HAVE_MPI - } -#endif //_DEBUG - - if(just_test==0) { - void *ptest=my_malloc(total_GB); - free(ptest); - } - - return total_GB; -} diff --git a/src/.ipynb_checkpoints/common-checkpoint.h b/src/.ipynb_checkpoints/common-checkpoint.h deleted file mode 100644 index 309c87e..0000000 --- a/src/.ipynb_checkpoints/common-checkpoint.h +++ /dev/null @@ -1,618 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#ifndef _COMMON_ -#define _COMMON_ - -#include -#include -#include -#include -#include -#include -#include -#ifdef _HAVE_OMP -#include -#endif //_HAVE_OMP -#include -#include -#include -#include -#include -#include "fftw3.h" -#ifdef _HAVE_MPI -#include -#include -#endif //_HAVE_MPI -#include -#ifdef _HAVE_FITS -#include -#endif //_HAVE_FITS -#ifdef _HAVE_HDF5 -#include -#include -#endif //_HAVE_HDF5 -#include -#ifdef _WITH_SHT -#include -#include -#include -#ifdef _WITH_NEEDLET -#include -#endif //_WITH_NEEDLET -#endif //_WITH_SHT -#include "cosmo_mad.h" - -///////// -// Interpolation parameters - -#define INTERP_NGP 0 -#define INTERP_CIC 1 -#define INTERP_TSC 2 -#define RETURN_DENS 1 -#define RETURN_VEL 2 -#define RETURN_TID 4 -#define RETURN_PDOT 8 -#define RETURN_GAUSS 16 - -// Radial spacing -#define SPACING_R 0 -#define SPACING_LOGZ 1 - -//Interpolation type -#ifndef INTERP_TYPE_SKW -#define INTERP_TYPE_SKW INTERP_CIC -#endif //INTERP_TYPE_SKW -#ifndef INTERP_TYPE_LENSING -#define INTERP_TYPE_LENSING INTERP_NGP -#endif //INTERP_TYPE_LENSING - -//dr_par = dx/NSAMP_RAD -#ifndef NSAMP_RAD -#define NSAMP_RAD 1 -#endif //NSAMP_RAD - -//Maximum allowed healpix resolution -#define NSIDE_MAX_HPX 8192 - -//Background tags -#define BG_Z 1000 -#define BG_D1 1001 -#define BG_D2 1002 -#define BG_V1 1003 -#define BG_PD 1004 -#define BG_IH 1005 -#define BG_NZ_SRCS 1006 -#define BG_BZ_SRCS 1007 -#define BG_NORM_SRCS 1008 -#define BG_TZ_IMAP 1009 -#define BG_BZ_IMAP 1010 -#define BG_NORM_IMAP 1011 -#define BG_KZ_CSTM 1012 -#define BG_BZ_CSTM 1013 -#define BG_NORM_CSTM 1014 - -//Density field parameters -#define DZ_SIGMA 0.05 -#define DENS_TYPE_LGNR 0 -#define DENS_TYPE_1LPT 1 -#define DENS_TYPE_2LPT 2 -#define DENS_TYPE_CLIP 3 - -// End of interpolation parameters -///////// - -#define DYNAMIC_SIZE 1 -#define RTOD 57.2957795 -#define DTOR 0.01745329251 -#define MIN(a, b) (((a) < (b)) ? (a) : (b)) -#define MAX(a, b) (((a) > (b)) ? (a) : (b)) -#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) - -#define TWOPIPIINVLOGTEN 0.1166503235296796 //ln(10)/(2*pi^2) -#define TWOPIPIINV 0.05066059182116889 //1/(2*pi^2) -#define NA 5001 -#define NPOP_MAX 10 -#define NPLANES_MAX 100 - -#ifdef _HAVE_MPI -#ifdef _SPREC -#define FLOUBLE_MPI MPI_FLOAT -#else //_SPREC -#define FLOUBLE_MPI MPI_DOUBLE -#endif //_SPREC -#endif //_HAVE_MPI - -#ifdef _SPREC -typedef float flouble; -typedef float complex fcomplex; -typedef fftwf_complex dftw_complex; -#else //_SPREC -typedef double flouble; -typedef double complex fcomplex; -typedef fftw_complex dftw_complex; -#endif //_SPREC - -//Defined in common.c -extern int NodeThis; -extern int NodeLeft; -extern int NodeRight; -extern int NNodes; -extern int IThread0; -extern int MPIThreadsOK; - -#ifdef TVEL -#define NPOS_CC 6 -#else -#define NPOS_CC 4 -#endif - -typedef struct { - int nsrc; - float *pos; - int *ipix; -} CatalogCartesian; - -typedef struct { - float ra; //Right ascension - float dec; //Declination - float z0; //Cosmological redshift - float dz_rsd; //RSD contribution -#ifdef TVEL - float vtheta; - float vphi; -#endif - float e1; - float e2; - float kappa; - float dra; - float ddec; -} Src; - -typedef struct { - int nsrc; - Src *srcs; - int nr; - double rmax; - double dr; - double idr; - int has_lensing; - int has_skw; - int skw_gauss; - float *d_skw; - float *g_skw; - float *v_skw; -} Catalog; - -typedef struct { - int nq; - int nr; //Number of spherical shells - flouble *r; //r in this shell - int *nside; //Resolution parameter - long *num_pix_per_beam; - int nbeams; //Number of different bases - double **pos; //3D positions of the pixels in the furthest shell - flouble ***data; -} HealpixShellsAdaptive; - -typedef struct { - int nq; //Number of quantities to map - int nside; //Resolution parameter - long num_pix; - long *listpix; - double *pos; - int nr; //Number of spherical shells - flouble *r0; //r_min in this shell - flouble *rf; //r_max in this shell - flouble *data; - int *nadd; -} HealpixShells; - -typedef struct { - -#ifdef _DEBUG - FILE *f_dbg; //File into which all debug info is written -#endif //_DEBUG - - //Cosmological parameters - // Background - double OmegaM; //Cosmological parameters - double OmegaL; //Cosmological parameters - double OmegaB; //Cosmological parameters - double hhub; //Cosmological parameters - double weos; //Cosmological parameters - double n_scal; //Cosmological parameters - double sig8; //Cosmological parameters - double fgrowth_0; //Growth rate at z=0 - double hubble_0; //Expansion rate at z=0 (inverse length units) - double prefac_lensing; //3*O_M*H_0^2/2 - double z_max; //Maximum redshift - double z_min; //Minimum redshift - double r_max; //Maximum radial comoving distance - double r_min; //Minimum radial comoving distance - double a_arr_a2r[NA]; //Array of redshifts used to compute r(z) - double r_arr_a2r[NA]; //Array of comoving distances used to compute r(z) - double z_arr_r2z[NA]; //Array of redshifts used to compute z(r) - double r_arr_r2z[NA]; //Array of comoving distances used to compute z(r), D_d(r), D_v(r), 1/H(z) - double growth_d_arr[NA]; //Array of density growth factors used to compute D_d(r) - double growth_d2_arr[NA]; //Array of density growth factors used to compute D_d(r) - double growth_v_arr[NA]; //Array of velocity growth factors used to compute D_v(r) - double growth_pd_arr[NA]; //Array of potential derivative factors used to compute \dot{\phi} - double ihub_arr[NA]; //Array of 1/H(z) - double glob_idr; //1/dr, where dr is the radial comoving distance interval used in the arrays above - // Power spectra - char fnamePk[256]; //File containing power spectrum - int numk; //Number of k-values - double logkmax; //Maximum log10(k) - double logkmin; //Minimum log10(k) - double idlogk; //1/D(log10(k)) - double *logkarr; //Array of log10(k) values (units of h/Mpc) - double *pkarr; //Array of power spectrum values (units of (Mpc/h)^3) - - //Density parameters - // Density methods - int output_density; //Do you want to output the density grid? - double r2_smooth; //Square of the smoothing scale - int do_smoothing; //Are we smoothing the density field? - int smooth_potential; //Do we smooth the newtonian potential as well? - int dens_type; //Method to produce the density field - int lpt_interp_type; - double lpt_buffer_fraction; //Fraction of memory saved for buffer particles - int output_lpt; - unsigned int seed_rng; //RNG seed - // Box parameters - int n_grid; //Number of cells per side for the Cartesian grid - flouble l_box; //Box size for the cartesian grid - int nz_here; //Number of cells in the z-direction stored in this node - int iz0_here; //index of the first cell in the z-direction stored in this node - int nz_max; - int *nz_all; - int *iz0_all; - double z0_norm; - double zf_norm; - // Density grids - dftw_complex *grid_dens_f; //Fourier-space grid for the density field - flouble *grid_dens; //Real-space grid for the density field - dftw_complex *grid_npot_f; //Fourier-space grid for the Newtonian potential - flouble *grid_npot; //Real-space grid for the Newtonian potential - flouble *slice_left; //Dummy array to store grid cells coming from the left node - flouble *slice_right; //Dummy array to store grid cells coming from the right node - double sigma2_gauss; //Variance of the cartesian density field - - //IO parameters - char prefixOut[256]; //Output prefix - int output_format; //0-> ASCII, 1-> FITS, 2-> HDF5 - double pos_obs[3]; //Observer position - - //Tracers - // Custom - int do_cstm; //Do we include custom maps? - int n_cstm; //Number of custom maps - char fnameBzCstm[NPOP_MAX][256]; //Files containing b(z) for each source type - char fnameKzCstm[NPOP_MAX][256]; //Files containing K(z) - double *cstm_kz_arr[NPOP_MAX]; - double *cstm_bz_arr[NPOP_MAX]; - double *cstm_norm_arr[NPOP_MAX]; - double norm_cstm_0[NPOP_MAX]; //Bottom edge of spline for density normalization - double norm_cstm_f[NPOP_MAX]; //Top edge of spline for density normalization - int nside_cstm[NPOP_MAX]; //Output angular resolution for each IM species - HealpixShells **cstm; //Maps for each custom map tracer - // Sources - int do_srcs; //Do we include sources? - int do_skewers; //Do we include skewer information? - int do_srcs_lensing; //Do we need to compute the lensing potential? - int n_srcs; //Number of source types - char fnameBzSrcs[NPOP_MAX][256]; //Files containing b(z) for each source type - char fnameNzSrcs[NPOP_MAX][256]; //Files containing dN/dzdOmega (in deg^-2) - double *srcs_nz_arr[NPOP_MAX]; - double *srcs_bz_arr[NPOP_MAX]; - double *srcs_norm_arr[NPOP_MAX]; - double norm_srcs_0[NPOP_MAX]; //Bottom edge of spline for density normalization - double norm_srcs_f[NPOP_MAX]; //Top edge of spline for density normalization - int lensing_srcs[NPOP_MAX]; //Do we do lensing for this source type? - int skw_srcs[NPOP_MAX]; //Do we want to store skewers for each source of this type? - int skw_gauss[NPOP_MAX]; //Do we want the skewers to be gaussian? (as opposed to physical density) - long *nsources_c_this; //Number of sources initially found in this node - CatalogCartesian **cats_c; //Galaxy positions initially stored in this node - long *nsources_this; //Number of sources finally found in this node - Catalog **cats; //Final galaxy properties - // Intensity mapping - int do_imap; //Do we include intensity mapping - int n_imap; //Number of IM species - char fnameBzImap[NPOP_MAX][256]; //Files containing b(z) for each IM species - char fnameTzImap[NPOP_MAX][256]; //Files containing T(z) for each IM species - char fnameNuImap[NPOP_MAX][256]; //Files containing frequency table for each IM species - double *imap_tz_arr[NPOP_MAX]; - double *imap_bz_arr[NPOP_MAX]; - double *imap_norm_arr[NPOP_MAX]; - double norm_imap_0[NPOP_MAX]; //Bottom edge of spline for density normalization - double norm_imap_f[NPOP_MAX]; //Top edge of spline for density normalization - int nside_imap[NPOP_MAX]; //Output angular resolution for each IM species - double nu0_imap[NPOP_MAX]; //Rest-frame frequency for each IM species - HealpixShells **imap; //intensity maps for each IM species - // Kappa - int do_kappa; //Do you want to output kappa maps? - int n_kappa; //How many maps? - double z_kappa_out[NPLANES_MAX]; //Array of source plane redshifts - int nside_kappa; - HealpixShells *kmap; //Kappa maps at each redshift -#ifdef _ADD_EXTRA_KAPPA - int *need_extra_kappa; - flouble **fl_mean_extra_kappa; - flouble **cl_extra_kappa; -#endif //_ADD_EXTRA_KAPPA - // Lensing - int do_lensing; //Do you want to create lensing maps? - int write_lensing; //Do you want to output lensing maps? - int lensing_spacing_type; //log(1+z)? r? - int n_lensing; //How many maps? - int nside_lensing; - HealpixShellsAdaptive *smap; //Lensing maps at each redshift - // ISW - int do_isw; //Do you want to output isw maps? - int n_isw; //How many maps? - double z_isw_out[NPLANES_MAX]; //Array of source plane redshifts - int nside_isw; - HealpixShells *pd_map; //Isw maps at each redshift -#ifdef _ADD_EXTRA_KAPPA - int *need_extra_isw; - flouble **fl_mean_extra_isw; - flouble **cl_extra_isw; -#endif //_ADD_EXTRA_KAPPA - - //Lognormal predictions - int do_pred; - int just_do_pred; - double pred_dz; - - //Beam distribution - int nside_base; //Minimum n_side used in the pixelization - int npix_base; //Corresponding number of pixels - int need_beaming; //Do we need spherical voxels at all? -} ParamCoLoRe; - -void mpi_init(int* p_argc,char*** p_argv); -void *my_malloc(size_t size); -void *my_calloc(size_t nmemb,size_t size); -size_t my_fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream); -void error_open_file(char *fname); -void error_read_line(char *fname,int nlin); -void print_info(char *fmt,...); -void report_error(int level,char *fmt,...); -int linecount(FILE *f); -int *ind_sort(int n,flouble *arr); -void timer(int i); -gsl_rng *init_rng(unsigned int seed); -double rng_01(gsl_rng *rng); -int rng_poisson(double lambda,gsl_rng *rng); -void rng_delta_gauss(double *module,double *phase, - gsl_rng *rng,double sigma2); -void rng_gauss(gsl_rng *rng,double *r1,double *r2); -void end_rng(gsl_rng *rng); -unsigned long long get_max_memory(ParamCoLoRe *par,int just_test); -void get_radial_params(double rmax,int ngrid,int *nr,double *dr); -//void get_random_angles(gsl_rng *rng,int ipix_nest,int ipix0,int nside,double *th,double *phi); -HealpixShells *hp_shell_alloc(int nq,int nside,int nside_base,int nr); -HealpixShellsAdaptive *hp_shell_adaptive_alloc(int nq, int nside_max, int nside_base,int nr, - flouble *r_arr, flouble dx, flouble dx_fraction); -void hp_shell_free(HealpixShells *shell); -void hp_shell_adaptive_free(HealpixShellsAdaptive *shell); -CatalogCartesian *catalog_cartesian_alloc(int nsrcs); -void catalog_cartesian_free(CatalogCartesian *cat); -Catalog *catalog_alloc(int nsrcs,int has_lensing,int has_skw,int skw_gauss,double rmax,int ng); -void catalog_free(Catalog *cat); - -static inline double bias_model(double d,double b) -{ - if(d<=-1) - return 0; -#ifdef _BIAS_MODEL_2 - if(d < 0) - return exp(b*d/(1+d)); - else - return 1+b*d; -#elif defined _BIAS_MODEL_3 - if(1+b*d>0) - return 1+b*d; - else - return 0; -#else //_BIAS_MODEL - return pow(1+d,b); -#endif //_BIAS_MODEL -} - - -////// -// Functions defined in cosmo.c -double pk_linear0(ParamCoLoRe *par,double lgk); -void cosmo_set(ParamCoLoRe *par); -double r_of_z(ParamCoLoRe *par,double z); -double get_bg(ParamCoLoRe *par,double r,int tag,int ipop); -void compute_tracer_cosmo(ParamCoLoRe *par); -flouble *compute_lensing_spacing(ParamCoLoRe *par); - -////// -// Functions defined in io.c -ParamCoLoRe *read_run_params(char *fname,int test_memory); -void write_density_grid(ParamCoLoRe *par,char *prefix_dens); -void write_lpt(ParamCoLoRe *par,unsigned long long npart,flouble *x,flouble *y,flouble *z); -void write_srcs(ParamCoLoRe *par); -void write_imap(ParamCoLoRe *par); -void write_cstm(ParamCoLoRe *par); -void write_kappa(ParamCoLoRe *par); -void write_lensing(ParamCoLoRe *par); -void write_isw(ParamCoLoRe *par); -void param_colore_free(ParamCoLoRe *par); - - -///// -// Functions defined in predictions.c -void write_predictions(ParamCoLoRe *par); - - -////// -// Functions defined in fourier.c -void init_fftw(ParamCoLoRe *par); -void allocate_fftw(ParamCoLoRe *par); -void create_cartesian_fields(ParamCoLoRe *par); -void end_fftw(ParamCoLoRe *par); -void fftw_wrap_c2r(int ng,dftw_complex *pin,flouble *pout); -void fftw_wrap_r2c(int ng,flouble *pin,dftw_complex *pout); - - -////// -// Functions defined in beaming.c -int interpolate_from_grid(ParamCoLoRe *par,double *x, - flouble *d,flouble v[3],flouble t[6],flouble *pd,flouble *g, - int flag_return,int interp_type); -void get_beam_properties(ParamCoLoRe *par); - - -////// -// Functions defined in density.c -void compute_physical_density_field(ParamCoLoRe *par); -void compute_density_normalization(ParamCoLoRe *par); - - -////// -// Functions defined in srcs.c -void srcs_set_cartesian(ParamCoLoRe *par); -void srcs_distribute(ParamCoLoRe *par); -void srcs_get_local_properties(ParamCoLoRe *par); -void srcs_beams_preproc(ParamCoLoRe *par); -void srcs_get_beam_properties(ParamCoLoRe *par); -void srcs_beams_postproc(ParamCoLoRe *par); - - -////// -// Functions defined in imap.c -void imap_set_cartesian(ParamCoLoRe *par); -void imap_distribute(ParamCoLoRe *par); -void imap_get_local_properties(ParamCoLoRe *par); -void imap_beams_preproc(ParamCoLoRe *par); -void imap_get_beam_properties(ParamCoLoRe *par); -void imap_beams_postproc(ParamCoLoRe *par); - - -////// -// Functions defined in cstm.c -void cstm_set_cartesian(ParamCoLoRe *par); -void cstm_distribute(ParamCoLoRe *par); -void cstm_get_local_properties(ParamCoLoRe *par); -void cstm_beams_preproc(ParamCoLoRe *par); -void cstm_get_beam_properties(ParamCoLoRe *par); -void cstm_beams_postproc(ParamCoLoRe *par); - - -////// -// Functions defined in kappa.c -void kappa_set_cartesian(ParamCoLoRe *par); -void kappa_distribute(ParamCoLoRe *par); -void kappa_get_local_properties(ParamCoLoRe *par); -void kappa_beams_preproc(ParamCoLoRe *par); -void kappa_get_beam_properties(ParamCoLoRe *par); -void kappa_beams_postproc(ParamCoLoRe *par); - - -////// -// Functions defined in lensing.c -void lensing_set_cartesian(ParamCoLoRe *par); -void lensing_distribute(ParamCoLoRe *par); -void lensing_get_local_properties(ParamCoLoRe *par); -void lensing_beams_preproc(ParamCoLoRe *par); -void lensing_get_beam_properties(ParamCoLoRe *par); -void lensing_beams_postproc(ParamCoLoRe *par); - - -////// -// Functions defined in isw.c -void isw_set_cartesian(ParamCoLoRe *par); -void isw_distribute(ParamCoLoRe *par); -void isw_get_local_properties(ParamCoLoRe *par); -void isw_beams_preproc(ParamCoLoRe *par); -void isw_get_beam_properties(ParamCoLoRe *par); -void isw_beams_postproc(ParamCoLoRe *par); - - -////// -// Defined in healpix_extra.c -long he_nside2npix(long nside); -double he_pixel_area(int nside); -long he_ang2pix(long nside,double cth,double phi); -void he_write_healpix_map(flouble **tmap,int nfields,long nside,char *fname,int isnest); -flouble *he_read_healpix_map(char *fname,long *nside,int nfield); -int he_ring_num(long nside,double z); -long *he_query_strip(long nside,double theta1,double theta2,long *npix_strip); -void he_ring2nest_inplace(flouble *map_in,long nside); -void he_nest2ring_inplace(flouble *map_in,long nside); -void he_udgrade(flouble *map_in,long nside_in,flouble *map_out,long nside_out,int nest); -#ifdef _WITH_SHT -#ifdef _SPREC -#define SHT_TYPE 0 -#else //_SPREC -#define SHT_TYPE SHARP_DP -#endif //_SPREC -#define HE_MAX_SHT 32 -#define HE_FWHM2SIGMA 0.00012352884853326381 //Transforms FWHM in arcmin to sigma_G in rad: -long he_nalms(int lmax); -long he_indexlm(int l,int m,int lmax); -void he_alm2map(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms); -void he_map2alm(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms); -void he_alm2cl(fcomplex **alms_1,fcomplex **alms_2, - int nmaps_1,int nmaps_2,int pol_1,int pol_2,flouble **cls,int lmax); -void he_anafast(flouble **maps_1,flouble **maps_2, - int nmaps_1,int nmaps_2,int pol_1,int pol_2, - flouble **cls,int nside,int lmax); -flouble *he_generate_beam_window(int lmax,flouble fwhm_amin); -void he_alter_alm(int lmax,flouble fwhm_amin,fcomplex *alm_in, - fcomplex *alm_out,flouble *window); -flouble *he_synfast(flouble *cl,int nside,int lmax,unsigned int seed); -//HE_NT -#ifdef _WITH_NEEDLET -#define HE_NBAND_NX 512 -#define HE_NORM_FT 2.2522836206907617 -#define HE_NL_INTPREC 1E-6 -#define HE_NT_NSIDE_MIN 32 -typedef struct { - double b; - double inv_b; - gsl_spline *b_spline; - gsl_interp_accel *b_intacc; - int nside0; - int nj; - int *nside_arr; - int *lmax_arr; - flouble **b_arr; -} HE_nt_param; -void he_nt_end(HE_nt_param *par); -HE_nt_param *he_nt_init(flouble b_nt,int nside0); -flouble ***he_alloc_needlet(HE_nt_param *par,int pol); -void he_free_needlet(HE_nt_param *par,int pol,flouble ***nt); -void he_nt_get_window(HE_nt_param *par,int j,flouble *b); -fcomplex **he_map2needlet(HE_nt_param *par,flouble **map,flouble ***nt, - int return_alm,int pol,int qu_in,int qu_out); -fcomplex **he_needlet2map(HE_nt_param *par,flouble **map,flouble ***nt, - int return_alm,int pol,int qu_in,int qu_out); -#endif //_WITH_NEEDLET -#endif //_WITH_SHT - - -#endif //_COMMON_ diff --git a/src/.ipynb_checkpoints/cosmo-checkpoint.c b/src/.ipynb_checkpoints/cosmo-checkpoint.c deleted file mode 100644 index eee344d..0000000 --- a/src/.ipynb_checkpoints/cosmo-checkpoint.c +++ /dev/null @@ -1,868 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" -#include -#include - -#define CL_TYPE_KAPPA 0 -#define CL_TYPE_SHEAR 1 -#define CL_TYPE_ISW 2 - -static double f_of_r_linear(ParamCoLoRe *par,double r,double *f,double f0,double ff) -{ - if(r<=0) return f0; - else if(r>=par->r_arr_r2z[NA-1]) return ff; - else { - int ir=(int)(r*par->glob_idr); - return f[ir]+(f[ir+1]-f[ir])*(r-par->r_arr_r2z[ir])*par->glob_idr; - } -} - -double get_bg(ParamCoLoRe *par,double r,int tag,int ipop) -{ - if(tag==BG_Z) - return f_of_r_linear(par,r,par->z_arr_r2z,0,par->z_arr_r2z[NA-1]); - else if(tag==BG_D1) - return f_of_r_linear(par,r,par->growth_d_arr,1,par->growth_d_arr[NA-1]); - else if(tag==BG_D2) { - return f_of_r_linear(par,r,par->growth_d2_arr,par->growth_d2_arr[0], - par->growth_d2_arr[NA-1]); - } - else if(tag==BG_V1) - return f_of_r_linear(par,r,par->growth_v_arr,par->growth_v_arr[0],par->growth_v_arr[NA-1]); - else if(tag==BG_PD) { - return f_of_r_linear(par,r,par->growth_pd_arr,par->growth_pd_arr[0], - par->growth_pd_arr[NA-1]); - } - else if(tag==BG_IH) - return f_of_r_linear(par,r,par->ihub_arr,par->ihub_arr[0],par->ihub_arr[NA-1]); - else if(tag==BG_NZ_SRCS) - return f_of_r_linear(par,r,par->srcs_nz_arr[ipop],0,0); - else if(tag==BG_BZ_SRCS) - return f_of_r_linear(par,r,par->srcs_bz_arr[ipop],par->srcs_bz_arr[ipop][0],1); - else if(tag==BG_NORM_SRCS) { - return f_of_r_linear(par,r,par->srcs_norm_arr[ipop],par->norm_srcs_0[ipop], - par->norm_srcs_f[ipop]); - } - else if(tag==BG_TZ_IMAP) - return f_of_r_linear(par,r,par->imap_tz_arr[ipop],0,0); - else if(tag==BG_BZ_IMAP) - return f_of_r_linear(par,r,par->imap_bz_arr[ipop],par->imap_bz_arr[ipop][0],1); - else if(tag==BG_NORM_IMAP) { - return f_of_r_linear(par,r,par->imap_norm_arr[ipop],par->norm_imap_0[ipop], - par->norm_imap_f[ipop]); - } - else if(tag==BG_KZ_CSTM) - return f_of_r_linear(par,r,par->cstm_kz_arr[ipop],0,0); - else if(tag==BG_BZ_CSTM) - return f_of_r_linear(par,r,par->cstm_bz_arr[ipop],par->cstm_bz_arr[ipop][0],1); - else if(tag==BG_NORM_CSTM) { - return f_of_r_linear(par,r,par->cstm_norm_arr[ipop],par->norm_cstm_0[ipop], - par->norm_cstm_f[ipop]); - } - else { - report_error(1,"Unknown background quantity tag %d\n",tag); - return -1; - } -} - -static double a_of_r_provisional(ParamCoLoRe *par,double r) -{ - if(r<=0) return 1.; - else if(r>=par->r_arr_a2r[0]) return 1E-6; - else { - int ia=0; - while(r<=par->r_arr_a2r[ia]) - ia++; - return par->a_arr_a2r[ia-1]+(par->a_arr_a2r[ia]-par->a_arr_a2r[ia-1])* - (r-par->r_arr_a2r[ia-1])/(par->r_arr_a2r[ia]-par->r_arr_a2r[ia-1]); - } -} - -double r_of_z(ParamCoLoRe *par,double z) -{ - double a=1./(1+z); - if(a>=1) return 0; - else if(a<=0) return par->r_arr_a2r[0]; - else { - int ia=(int)(a*(NA-1)); - double r=par->r_arr_a2r[ia]+(par->r_arr_a2r[ia+1]-par->r_arr_a2r[ia])* - (a-par->a_arr_a2r[ia])*(NA-1.); - return r; - } -} - -typedef struct { - ParamCoLoRe *par; - int l; - double chi_0_a; - double chi_f_a; - double chi_0_b; - double chi_f_b; - double chi_s; - int cl_type; -} ClParams; - -static double window_kappa_limber(ParamCoLoRe *par,int l,double k,double chi_0,double chi_f,double chi_s) -{ - double chi_l=(l+0.5)/k; - - if((chi_l<=0) || (chi_lchi_f)) - return 0; - else { - double gf=get_bg(par,chi_l,BG_D1,0); - double aa=1/(1+get_bg(par,chi_l,BG_Z,0)); - - return par->prefac_lensing*l*(l+1.)*gf*(chi_s-chi_l)/(k*k*chi_s*chi_l*aa); - } -} - -static double window_shear_limber(ParamCoLoRe *par,int l,double k,double chi_0,double chi_f,double chi_s) -{ - double chi_l=(l+0.5)/k; - - if((chi_l<=0) || (chi_lchi_f)) - return 0; - else { - double gf=get_bg(par,chi_l,BG_D1,0); - double aa=1/(1+get_bg(par,chi_l,BG_Z,0)); - - return par->prefac_lensing*sqrt((l-1)*l*(l+1.)*(l+2.))*gf*(chi_s-chi_l)/(k*k*chi_s*chi_l*aa); - } -} - -static double window_isw_limber(ParamCoLoRe *par,int l,double k,double chi_0,double chi_f,double chi_s) -{ - double chi_l=(l+0.5)/k; - - if((chi_l<=0) || (chi_lchi_f)) - return 0; - else - return -2*par->prefac_lensing*get_bg(par,chi_l,BG_PD,0)/(k*k); -} - -static double cl_integrand(double lk,void *params) -{ - ClParams *p=(ClParams *)params; - double k=pow(10.,lk); - double pk=pk_linear0(p->par,lk); - double wa=0,wb=0; - if(p->cl_type==CL_TYPE_KAPPA) { - wa=window_kappa_limber(p->par,p->l,k,p->chi_0_a,p->chi_f_a,p->chi_s); - wb=window_kappa_limber(p->par,p->l,k,p->chi_0_b,p->chi_f_b,p->chi_s); - } - else if(p->cl_type==CL_TYPE_SHEAR) { - wa=window_shear_limber(p->par,p->l,k,p->chi_0_a,p->chi_f_a,p->chi_s); - wb=window_shear_limber(p->par,p->l,k,p->chi_0_b,p->chi_f_b,p->chi_s); - } - else if(p->cl_type==CL_TYPE_ISW) { - wa=window_isw_limber(p->par,p->l,k,p->chi_0_a,p->chi_f_a,p->chi_s); - wb=window_isw_limber(p->par,p->l,k,p->chi_0_b,p->chi_f_b,p->chi_s); - } - if((p->par->do_smoothing) && (p->par->smooth_potential)) - pk*=exp(-k*k*p->par->r2_smooth); - - return k*wa*wb*pk; -} - -static double compute_cl(ParamCoLoRe *par,int l, - double chi_0_a,double chi_f_a, - double chi_0_b,double chi_f_b, - double chi_s,int cl_type) -{ - ClParams p; - gsl_function F; - double lkmin,lkmax,eresult,result=0,chi_min=1E16,chi_max=-1; - gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000); - p.par=par; - p.l=l; - p.chi_0_a=chi_0_a; - p.chi_f_a=chi_f_a; - p.chi_0_b=chi_0_b; - p.chi_f_b=chi_f_b; - p.chi_s=chi_s; - p.cl_type=cl_type; - F.function=&cl_integrand; - F.params=&p; - - if(chi_0_achi_max) chi_max=chi_0_a; - if(chi_0_b>chi_max) chi_max=chi_0_b; - if(chi_f_a>chi_max) chi_max=chi_f_a; - if(chi_f_b>chi_max) chi_max=chi_f_b; - if(chi_min<=0) lkmax=2.; - else lkmax=log10((l+0.5)/chi_min); - if(chi_max<=0) lkmin=-5.; - else lkmin=log10((l+0.5)/chi_max); - - gsl_integration_qag(&F,lkmin,lkmax,0,1E-4,1000,GSL_INTEG_GAUSS41,w,&result,&eresult); - gsl_integration_workspace_free(w); - - return M_LN10*result/(l+0.5); -} - -static void int_error_handle(int status,double result, - double error) -{ - ////// - // Error handler for gsl - if(isnan(result)) { - fprintf(stderr,"CoLoRe: NAN found \n"); - exit(1); - } - else{ - if(status==GSL_EROUND) - fprintf(stderr,"CoLoRe: Roundoff error: %lE %lE \n",result,error); - else if(status==GSL_EMAXITER) - fprintf(stderr,"CoLoRe: Ran out of iterations: %lE %lE \n",result,error); - else if(status==GSL_ESING) - fprintf(stderr,"CoLoRe: Singularity found: %lE %lE \n",result,error); - else if(status==GSL_EDIVERGE) { - fprintf(stderr,"CoLoRe: Integral seems to diverge: %lE %lE \n", - result,error); - } - else if(status==GSL_ETOL) { - fprintf(stderr,"CoLoRe: Can't reach tolerance: %lE %lE : %lE %%\n", - result,error,100*error/result); - } - else if(status==GSL_EUNDRFLW) - fprintf(stderr,"CoLoRe: Underflow: %lE %lE \n",result,error); - else if(status==GSL_EDOM) { - fprintf(stderr,"CoLoRe: Outside interpolation range!! %lE %lE\n", - result,error); - exit(1); - } - else if(status) { - fprintf(stderr,"CoLoRe: Unknown error code %d %lf %lf \n", - status,result,error); - exit(1); - } - } -} - -static double wind(double x,int setwf) -{ - ////// - // Window function: - // setwf=0 -> top hat - // setwf=1 -> gaussian - // setwf=2 -> sharp-k - if(setwf==1) { //Gaussian - return exp(-0.5*x*x); - } - else if(setwf==0) { //TopHat - if(x<0.1) { - return 1.-0.1*x*x+0.003571429*x*x*x*x-6.61376E-5*x*x*x*x*x*x - +7.51563E-7*x*x*x*x*x*x*x*x; - } - else - return 3*(sin(x)-x*cos(x))/(x*x*x); - } - else if(setwf==2) { //Sharp-k - if(x<1) return 1; - else return 0; - } - else - return -1; -} - -double pk_linear0(ParamCoLoRe *par,double lgk) -{ - ////// - // Linear power spectrum at redshift 0. - // Extrapolated to ~k^ns for small k and - // to k^{-3} for large k - double pk; - int ik=(int)((lgk-par->logkmin)*par->idlogk); - - if(ik<0) - pk=par->pkarr[0]*pow(10,par->n_scal*(lgk-par->logkmin)); - else if(iknumk) - pk=par->pkarr[ik]+(lgk-par->logkarr[ik])*(par->pkarr[ik+1]-par->pkarr[ik])*par->idlogk; - else - pk=par->pkarr[par->numk-1]*pow(10,-3*(lgk-par->logkmax)); - - return pk; -} - -static double j_bessel_0(double x) -{ - ////// - // Bessel's j0 function - if(x>0.1) - return sin(x)/x; - else - return 1.-0.166667*x*x+0.00833333*x*x*x*x- - 0.000198413*x*x*x*x*x*x+2.75573E-6*x*x*x*x*x*x*x*x; -} - -typedef struct { //Param struct for integrals - double r; - double R1; - double R2; - int wf1; - int wf2; - ParamCoLoRe *par; -} xiparam; - -static double integxiL_O(double kk,void *params) -{ - ////// - // integrand for xi_L (for oscillatory integration) - double dum; - double x1,x2,xr; - xiparam *par; - double lgk=log10(kk); - par=(xiparam *)params; - - x1=kk*(par->R1); - x2=kk*(par->R2); - xr=kk*(par->r); - - dum=TWOPIPIINV*pk_linear0(par->par,lgk)*kk*kk* - wind(x1,par->wf1)*wind(x2,par->wf2)/xr; - - return dum; -} - -static double integxiL_NO(double logk,void *params) -{ - ////// - // integrand for xi_L (including oscillatory term in j0) - double dum; - double x1,x2,xr; - xiparam *par; - par=(xiparam *)params; - - double kk=pow(10,logk); - x1=kk*(par->R1); - x2=kk*(par->R2); - xr=kk*(par->r); - - dum=TWOPIPIINVLOGTEN*pk_linear0(par->par,logk)*kk*kk*kk* - wind(x1,par->wf1)*wind(x2,par->wf2)*j_bessel_0(xr); - - return dum; -} - -static double xi2p_L(ParamCoLoRe *par,double r,double R1,double R2, - char *wf1,char *wf2,double errfac) -{ - ////// - // Correlation function between the linear density contrast smoothed - // with window function (wf1,R1) and with window function (wf2,R2) - // at two points separated by a distance r: - // - gsl_function integrand; - double relerrt=1E-4; - double integral,errintegral; - xiparam xpar; - double lim=MIN(R1,R2); - lim/=r; - - xpar.r=r; - xpar.R1=R1; - xpar.R2=R2; - xpar.par=par; - if(!strcmp(wf1,"Gauss")) - xpar.wf1=1; - else if(!strcmp(wf1,"TopHat")) - xpar.wf1=0; - else { - fprintf(stderr,"CoLoRe: Unknown window function %s \n",wf1); - exit(1); - } - if(!strcmp(wf2,"Gauss")) - xpar.wf2=1; - else if(!strcmp(wf2,"TopHat")) - xpar.wf2=0; - else { - fprintf(stderr,"CoLoRe: Unknown window function %s \n",wf2); - exit(1); - } - - gsl_integration_workspace *w - =gsl_integration_workspace_alloc(1000); - integrand.params=&xpar; - if(lim>=1) { - integrand.function=&integxiL_NO; - int stat=gsl_integration_qagil(&integrand,par->logkmax,0,relerrt,1000,w, - &integral,&errintegral); - int_error_handle(stat,integral,errintegral); - } - else { - lim*=errfac; - gsl_integration_workspace *cw - =gsl_integration_workspace_alloc(1000); - gsl_integration_qawo_table *wf - =gsl_integration_qawo_table_alloc(r,0.1,GSL_INTEG_SINE,100); - - integrand.function=&integxiL_O; - int stat=gsl_integration_qawf(&integrand,0,relerrt*lim,1000, - w,cw,wf,&integral,&errintegral); - int_error_handle(stat,integral,errintegral); - - gsl_integration_qawo_table_free(wf); - gsl_integration_workspace_free(cw); - } - gsl_integration_workspace_free(w); - - return integral; -} - -static double sigL2(ParamCoLoRe *par,double R1,double R2,char *wf1,char *wf2) -{ - ////// - // Covariance between the linear density contrast smoothed with - // window function (wf1,R1) and with window function (wf2,R2) at - // the same point: - return xi2p_L(par,0,R1,R2,wf1,wf2,1); -} - -static void pk_linear_set(ParamCoLoRe *par) -{ - ////// - // Reads linear power spectrum. CAMB format expected. - int ii; - double kk,ppk; - FILE *fpk; - - print_info("Reading P_k from file: %s\n",par->fnamePk); - fpk=fopen(par->fnamePk,"r"); - if(fpk==NULL) error_open_file(par->fnamePk); - par->numk=linecount(fpk); - par->logkarr=(double *)my_malloc(par->numk*sizeof(double)); - par->pkarr=(double *)my_malloc(par->numk*sizeof(double)); - rewind(fpk); - for(ii=0;iinumk;ii++) { - int stat=fscanf(fpk,"%lf %lf",&kk,&ppk); - if(stat!=2) error_read_line(par->fnamePk,ii+1); - par->pkarr[ii]=ppk; - par->logkarr[ii]=log10(kk); //log(k) in h Mpc^-1 - } - fclose(fpk); - - par->logkmin=par->logkarr[0]; - par->logkmax=par->logkarr[par->numk-1]; - par->idlogk=(par->numk-1)/(par->logkmax-par->logkmin); - - //Re-interpolate just in case the file is not equi-spaced in log10(k) - gsl_interp_accel *intacc=gsl_interp_accel_alloc(); - gsl_spline *spline=gsl_spline_alloc(gsl_interp_cspline,par->numk); - gsl_spline_init(spline,par->logkarr,par->pkarr,par->numk); - for(ii=0;iinumk-1;ii++) { - double lk=par->logkmin+ii/(par->idlogk); - par->pkarr[ii]=gsl_spline_eval(spline,lk,intacc); - par->logkarr[ii]=lk; - } - gsl_spline_free(spline); - gsl_interp_accel_free(intacc); - - // normalize - double norm_pk=par->sig8*par->sig8/sigL2(par,8,8,"TopHat","TopHat"); - print_info(" Original sigma8=%lf\n", - sqrt(sigL2(par,8,8,"TopHat","TopHat"))); - for(ii=0;iinumk;ii++) - par->pkarr[ii]*=norm_pk; - - double r_effective=sqrt(par->r2_smooth+pow(0.45*par->l_box/par->n_grid,2)); - par->sigma2_gauss=sigL2(par,r_effective,r_effective,"Gauss","Gauss"); -#ifdef _DEBUG - print_info(" Sigma_Gauss should be %lf\n",sqrt(par->sigma2_gauss)); -#endif //_DEBUG -} - -static void compute_hp_shell_distances_imap(HealpixShells *shell,flouble nu_rest, - char *fname_nutable,Csm_params *pars) -{ - int ii; - FILE *fi; - - //Figure out radial shells - fi=fopen(fname_nutable,"r"); - if(fi==NULL) error_open_file(fname_nutable); - for(ii=0;iinr;ii++) { - double nu0,nuf; - int stat=fscanf(fi,"%lf %lf",&nu0,&nuf); - if(stat!=2) error_read_line(fname_nutable,ii+1); - shell->r0[ii]=csm_radial_comoving_distance(pars,nuf/nu_rest); - shell->rf[ii]=csm_radial_comoving_distance(pars,nu0/nu_rest); - } - fclose(fi); -} - -void cosmo_set(ParamCoLoRe *par) -{ - ////// - // This initializes the cosmological model - // at redshift z_s - - int ii,ipop,nz; - double *zarr,*fzarr; - FILE *fi; - gsl_spline *spline_srcs_bz[NPOP_MAX]; - gsl_spline *spline_srcs_nz[NPOP_MAX]; - gsl_spline *spline_imap_bz[NPOP_MAX]; - gsl_spline *spline_imap_tz[NPOP_MAX]; - gsl_spline *spline_cstm_bz[NPOP_MAX]; - gsl_spline *spline_cstm_kz[NPOP_MAX]; - - Csm_params *pars=csm_params_new(); - csm_unset_gsl_eh(); - csm_background_set(pars,par->OmegaM,par->OmegaL,par->OmegaB,par->weos,0,par->hhub,2.275); - - par->fgrowth_0=csm_f_growth(pars,1); - par->hubble_0=csm_hubble(pars,1); - - par->r_min=csm_radial_comoving_distance(pars,1/(1+par->z_min)); - par->r_max=csm_radial_comoving_distance(pars,1/(1+par->z_max)); - - par->prefac_lensing=1.5*par->hubble_0*par->hubble_0*par->OmegaM; - - par->l_box=2*par->r_max*(1+2./par->n_grid); - par->pos_obs[0]=0.5*par->l_box; - par->pos_obs[1]=0.5*par->l_box; - par->pos_obs[2]=0.5*par->l_box; - - for(ipop=0;ipopn_srcs;ipop++) { - fi=fopen(par->fnameBzSrcs[ipop],"r"); - if(fi==NULL) error_open_file(par->fnameBzSrcs[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - fzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameBzSrcs[ipop],ii+1); - } - if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) - report_error(1,"Bias z-range is too small\n"); - spline_srcs_bz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); - gsl_spline_init(spline_srcs_bz[ipop],zarr,fzarr,nz); - free(zarr); free(fzarr); - fclose(fi); - - fi=fopen(par->fnameNzSrcs[ipop],"r"); - if(fi==NULL) error_open_file(par->fnameNzSrcs[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - fzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameNzSrcs[ipop],ii+1); - a=1./(1+zarr[ii]); - hz=csm_hubble(pars,a); - rz=csm_radial_comoving_distance(pars,a); - fzarr[ii]*=RTOD*RTOD*hz/(rz*rz); - } - //Correct for z[0]=0 - if(zarr[0]==0) - fzarr[0]=fzarr[1]; - if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) - report_error(1,"N(z) z-range is too small\n"); - spline_srcs_nz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); - gsl_spline_init(spline_srcs_nz[ipop],zarr,fzarr,nz); - free(zarr); free(fzarr); - fclose(fi); - - par->srcs_nz_arr[ipop]=my_malloc(NA*sizeof(double)); - par->srcs_bz_arr[ipop]=my_malloc(NA*sizeof(double)); - } - - for(ipop=0;ipopn_imap;ipop++) { - fi=fopen(par->fnameBzImap[ipop],"r"); - if(fi==NULL) error_open_file(par->fnameBzImap[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - fzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameBzImap[ipop],ii+1); - } - if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) - report_error(1,"Bias z-range is too small\n"); - spline_imap_bz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); - gsl_spline_init(spline_imap_bz[ipop],zarr,fzarr,nz); - free(zarr); free(fzarr); - fclose(fi); - - fi=fopen(par->fnameTzImap[ipop],"r"); - if(fi==NULL) error_open_file(par->fnameTzImap[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - fzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameTzImap[ipop],ii+1); - } - if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) - report_error(1,"T(z) z-range is too small\n"); - spline_imap_tz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); - gsl_spline_init(spline_imap_tz[ipop],zarr,fzarr,nz); - free(zarr); free(fzarr); - fclose(fi); - - par->imap_tz_arr[ipop]=my_malloc(NA*sizeof(double)); - par->imap_bz_arr[ipop]=my_malloc(NA*sizeof(double)); - } - - for(ipop=0;ipopn_cstm;ipop++) { - fi=fopen(par->fnameBzCstm[ipop],"r"); - if(fi==NULL) error_open_file(par->fnameBzCstm[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - fzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameBzCstm[ipop],ii+1); - } - if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) - report_error(1,"Bias z-range is too small\n"); - spline_cstm_bz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); - gsl_spline_init(spline_cstm_bz[ipop],zarr,fzarr,nz); - free(zarr); free(fzarr); - fclose(fi); - - fi=fopen(par->fnameKzCstm[ipop],"r"); - if(fi==NULL) error_open_file(par->fnameKzCstm[ipop]); - nz=linecount(fi); rewind(fi); - zarr=my_malloc(nz*sizeof(double)); - fzarr=my_malloc(nz*sizeof(double)); - for(ii=0;iifnameKzCstm[ipop],ii+1); - } - if((zarr[0]>par->z_min) || (zarr[nz-1]z_max)) - report_error(1,"K(z) z-range is too small\n"); - spline_cstm_kz[ipop]=gsl_spline_alloc(gsl_interp_cspline,nz); - gsl_spline_init(spline_cstm_kz[ipop],zarr,fzarr,nz); - free(zarr); free(fzarr); - fclose(fi); - - par->cstm_kz_arr[ipop]=my_malloc(NA*sizeof(double)); - par->cstm_bz_arr[ipop]=my_malloc(NA*sizeof(double)); - } - - //Set z-dependent functions - for(ii=0;iia_arr_a2r[ii]=a; - par->r_arr_a2r[ii]=ra; - } - - double growth0=csm_growth_factor(pars,1); - par->glob_idr=(NA-1)/par->r_arr_a2r[0]; - for(ii=0;iiglob_idr; - double a=a_of_r_provisional(par,r); - double z=1./a-1; - double gz=csm_growth_factor(pars,a)/growth0; - double om=csm_omega_m(pars,a); - double fz=csm_f_growth(pars,a); - double hhz=csm_hubble(pars,a); - par->z_arr_r2z[ii]=z; - par->r_arr_r2z[ii]=r; - par->growth_d_arr[ii]=gz; - par->growth_d2_arr[ii]=-0.42857142857*gz*gz*pow(om,-0.00699300699); - par->growth_v_arr[ii]=(gz*hhz*fz)/(par->fgrowth_0*par->hubble_0); //This is for the comoving velocity - par->growth_pd_arr[ii]=gz*hhz*(fz-1); - par->ihub_arr[ii]=1./hhz; - for(ipop=0;ipopn_srcs;ipop++) { - if((zz_min) || (z>par->z_max)) { - par->srcs_nz_arr[ipop][ii]=0; - par->srcs_bz_arr[ipop][ii]=1.; - } - par->srcs_nz_arr[ipop][ii]=gsl_spline_eval(spline_srcs_nz[ipop],z,NULL); - par->srcs_bz_arr[ipop][ii]=gsl_spline_eval(spline_srcs_bz[ipop],z,NULL); - } - for(ipop=0;ipopn_imap;ipop++) { - if((zz_min) || (z>par->z_max)) { - par->imap_tz_arr[ipop][ii]=0; - par->imap_bz_arr[ipop][ii]=1.; - } - par->imap_tz_arr[ipop][ii]=gsl_spline_eval(spline_imap_tz[ipop],z,NULL); - par->imap_bz_arr[ipop][ii]=gsl_spline_eval(spline_imap_bz[ipop],z,NULL); - } - for(ipop=0;ipopn_cstm;ipop++) { - if((zz_min) || (z>par->z_max)) { - par->cstm_kz_arr[ipop][ii]=0; - par->cstm_bz_arr[ipop][ii]=1.; - } - par->cstm_kz_arr[ipop][ii]=gsl_spline_eval(spline_cstm_kz[ipop],z,NULL); - par->cstm_bz_arr[ipop][ii]=gsl_spline_eval(spline_cstm_bz[ipop],z,NULL); - } - } - - for(ipop=0;ipopn_cstm;ipop++) { - gsl_spline_free(spline_cstm_kz[ipop]); - gsl_spline_free(spline_cstm_bz[ipop]); - } - for(ipop=0;ipopn_imap;ipop++) { - gsl_spline_free(spline_imap_tz[ipop]); - gsl_spline_free(spline_imap_bz[ipop]); - } - for(ipop=0;ipopn_srcs;ipop++) { - gsl_spline_free(spline_srcs_nz[ipop]); - gsl_spline_free(spline_srcs_bz[ipop]); - } - - pk_linear_set(par); - - if(par->do_kappa) { - for(ii=0;iin_kappa;ii++) { - double z=par->z_kappa_out[ii]; - if(z>par->z_max) { -#ifdef _ADD_EXTRA_KAPPA - int l,nl=3*par->nside_kappa; - double chi_here=r_of_z(par,z); -#ifdef _DEBUG - if(NodeThis==0) - fprintf(par->f_dbg,"Power spectra for extra kappa, shell %d (z=%.3lf)\n",ii+1,z); -#endif //_DEBUG - par->need_extra_kappa[ii]=1; - par->fl_mean_extra_kappa[ii]=my_malloc(nl*sizeof(flouble)); - par->cl_extra_kappa[ii]=my_malloc(nl*sizeof(flouble)); - for(l=0;lr_max,0. ,par->r_max,chi_here,CL_TYPE_KAPPA); - flouble cl_k_12=compute_cl(par,l,0. ,par->r_max,par->r_max,chi_here ,chi_here,CL_TYPE_KAPPA); - flouble cl_k_22=compute_cl(par,l,par->r_max,chi_here ,par->r_max,chi_here ,chi_here,CL_TYPE_KAPPA); - par->fl_mean_extra_kappa[ii][l]=cl_k_12/cl_k_11; - par->cl_extra_kappa[ii][l]=cl_k_22-cl_k_12*cl_k_12/cl_k_11; - if(l==0) { - par->fl_mean_extra_kappa[ii][l]=0; - par->cl_extra_kappa[ii][l]=0; - } -#ifdef _DEBUG - if(NodeThis==0) - fprintf(par->f_dbg,"%d %lE %lE \n",l,par->fl_mean_extra_kappa[ii][l],par->cl_extra_kappa[ii][l]); -#endif //_DEBUG - } -#ifdef _DEBUG - if(NodeThis==0) - fprintf(par->f_dbg,"\n"); -#endif //_DEBUG -#else //_ADD_EXTRA_KAPPA - report_error(1,"Source plane %d outside redshift range\n",ii+1); -#endif //_ADD_EXTRA_KAPPA - } - } - } - - if(par->do_isw) { - for(ii=0;iin_isw;ii++) { - double z=par->z_isw_out[ii]; - if(z>par->z_max) { -#ifdef _ADD_EXTRA_KAPPA - int l,nl=3*par->nside_isw; - double chi_here=r_of_z(par,z); -#ifdef _DEBUG - if(NodeThis==0) - fprintf(par->f_dbg,"Power spectra for extra isw, shell %d (z=%.3lf)\n",ii+1,z); -#endif //_DEBUG - par->need_extra_isw[ii]=1; - par->fl_mean_extra_isw[ii]=my_malloc(nl*sizeof(flouble)); - par->cl_extra_isw[ii]=my_malloc(nl*sizeof(flouble)); - for(l=0;lr_max,0. ,par->r_max,chi_here,CL_TYPE_ISW); - flouble cl_i_12=compute_cl(par,l,0. ,par->r_max,par->r_max,chi_here ,chi_here,CL_TYPE_ISW); - flouble cl_i_22=compute_cl(par,l,par->r_max,chi_here ,par->r_max,chi_here ,chi_here,CL_TYPE_ISW); - par->fl_mean_extra_isw[ii][l]=cl_i_12/cl_i_11; - par->cl_extra_isw[ii][l]=cl_i_22-cl_i_12*cl_i_12/cl_i_11; - if(l==0) { - par->fl_mean_extra_isw[ii][l]=0; - par->cl_extra_isw[ii][l]=0; - } -#ifdef _DEBUG - if(NodeThis==0) - fprintf(par->f_dbg,"%d %lE %lE \n",l,par->fl_mean_extra_isw[ii][l],par->cl_extra_isw[ii][l]); -#endif //_DEBUG - } -#ifdef _DEBUG - if(NodeThis==0) - fprintf(par->f_dbg,"\n"); -#endif //_DEBUG -#else //_ADD_EXTRA_KAPPA - report_error(1,"Source plane %d outside redshift range\n",ii+1); -#endif //_ADD_EXTRA_KAPPA - } - } - } - - csm_params_free(pars); - //FREEE SLPINES! -} - -void compute_tracer_cosmo(ParamCoLoRe *par) -{ - Csm_params *pars=csm_params_new(); - csm_unset_gsl_eh(); - csm_set_verbosity(0); - csm_background_set(pars,par->OmegaM,par->OmegaL,par->OmegaB,par->weos,0,par->hhub,2.275); - - if(par->do_imap) { - int ipop; - for(ipop=0;ipopn_imap;ipop++) { - compute_hp_shell_distances_imap(par->imap[ipop],par->nu0_imap[ipop],par->fnameNuImap[ipop],pars); - } - } - if(par->do_kappa) { - int ii; - for(ii=0;iin_kappa;ii++) { - double z=par->z_kappa_out[ii]; - par->kmap->r0[ii]=csm_radial_comoving_distance(pars,1./(1+z)); - par->kmap->rf[ii]=csm_radial_comoving_distance(pars,1./(1+z)); - } - } - if(par->do_isw) { - int ii; - for(ii=0;iin_isw;ii++) { - double z=par->z_isw_out[ii]; - par->pd_map->r0[ii]=csm_radial_comoving_distance(pars,1./(1+z)); - par->pd_map->rf[ii]=csm_radial_comoving_distance(pars,1./(1+z)); - } - } - - csm_params_free(pars); -} - -flouble *compute_lensing_spacing(ParamCoLoRe *par) -{ - flouble *rarr; - int ir,nr=par->n_lensing; - rarr=my_malloc(nr*sizeof(flouble)); - if(par->lensing_spacing_type==SPACING_R) { - flouble dr=par->r_max/nr; - for(ir=0;irlensing_spacing_type==SPACING_LOGZ) { - flouble dlogz=log(1+par->z_max)/nr; - for(ir=0;ir. // -// // -/////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include "common.h" -#include "cosmo_mad.h" - -//Number of points for the a(t) relation -#define CSM_NINTERP_A 1000 - -/**** Verbosity ****/ -static int csm_flag_verbose=1; - -/**** Error handler ****/ -static gsl_error_handler_t *csm_gsl_error_handler_old; - - -/****************************/ -/* General routines */ -/****************************/ -static void int_error_handle(int status,double result, - double error) -{ - ////// - // Error handler for gsl - if(isnan(result)) { - fprintf(stderr,"CoLoRe: NAN found \n"); - } - else{ - if(status==GSL_EROUND) { - fprintf(stderr,"CoLoRe: Roundoff error: %lE %lE \n", - result,error); - } - else if(status==GSL_EMAXITER) { - fprintf(stderr,"CoLoRe: Ran out of iterations: %lE %lE \n", - result,error); - } - else if(status==GSL_ESING) { - fprintf(stderr,"CoLoRe: Singularity found: %lE %lE \n", - result,error); - } - else if(status==GSL_EDIVERGE) { - fprintf(stderr,"CoLoRe: Integral seems to diverge: %lE %lE \n", - result,error); - } - else if(status==GSL_ETOL) { - fprintf(stderr,"CoLoRe: Can't reach tolerance: %lE %lE\n", - result,error); - } - else if(status==GSL_EUNDRFLW) - fprintf(stderr,"CoLoRe: Underflow: %lE %lE \n",result,error); - else if(status==GSL_EDOM) { - fprintf(stderr,"CoLoRe: Outside interpolation range!! %lE %lE\n", - result,error); - exit(1); - } - else if(status) { - fprintf(stderr,"CoLoRe: Unknown error code %d %lf %lf \n", - status,result,error); - exit(1); - } - } -} - -void csm_unset_gsl_eh(void) -{ - ////// - // Disables GSL default error handler - csm_gsl_error_handler_old=gsl_set_error_handler_off(); -} - -void csm_set_verbosity(int verb) -{ - ////// - // Sets verbosity level - csm_flag_verbose=verb; -} - -static void csm_bg_params_free(Csm_bg_params *par) -{ - ////// - // bg_params destructor - free(par); -} - -static Csm_bg_params *csm_bg_params_new(void) -{ - ////// - // bg_params creator - // Default Planck parameters - Csm_bg_params *bg=(Csm_bg_params *)malloc(sizeof(Csm_bg_params)); - if(bg==NULL) { - fprintf(stderr,"CoLoRe: Out of memory!\n"); - exit(1); - } - bg->OM=0.315; - bg->OL=0.685; - bg->OB=0.049; - bg->h=0.673; - bg->w0=-1; - bg->wa=0; - bg->TCMB=2.725; - bg->OK=0; - bg->ksign=0; - bg->normalDE=1; - bg->constantw=1; - - return bg; -} - -void csm_params_free(Csm_params *par) -{ - ////// - // csm_params destructor - if(par->bg_params_set) - csm_bg_params_free(par->bg); - par->bg_params_set=0; - free(par); -} - -Csm_params *csm_params_new(void) -{ - ////// - // csm_params destructor - Csm_params *par=(Csm_params *)malloc(sizeof(Csm_params)); - if(par==NULL) { - fprintf(stderr,"CoLoRe: Out of memory!\n"); - exit(1); - } - par->bg_params_set=0; - par->bg=NULL; - - return par; -} - -/****************************/ -/* Background cosmology */ -/****************************/ - -static double aeqmin(Csm_bg_params *par) -{ - ////// - // Returns MIN(aeq_k,aeq_L), where aeq_i is the scale - // factor at equality of M with k or L. - double aeqK=1; - double aeqL=1; - - if(par->ksign!=0) - aeqK=par->OM/fabs(par->OK); - - if (par->OL!=0) { - if(par->normalDE) - aeqL=pow(par->OM/par->OL,0.333); - else - aeqL=pow(par->OM/par->OL,-1/(3*par->w0)); - } - - return CSM_MIN(aeqK,aeqL); -} - -static double sinn(double x,int sign) -{ - ////// - // { sin(x) , if k==1 - // sinn(x)={ x , if k==0 - // { sinh(x) , if k==-1 - double dum; - - if(sign==-1) - dum=sinh(x); - else if(sign==1) - dum=sin(x); - else - dum=x; - - return dum; -} - -static double naHm1(double a,void *params) -{ - ////// - // H0/(a*H[a]) - double dum; - Csm_bg_params *par=(Csm_bg_params *)params; - - if(par->normalDE) - dum=sqrt(a/(par->OM+par->OL*a*a*a+par->OK*a)); - else if(par->constantw) { - dum=sqrt(a/(par->OM+par->OL*pow(a,-3*par->w0)+par->OK*a)); - } - else { - dum=sqrt(a/(par->OM+par->OL*pow(a,-3*(par->w0+par->wa))* - exp(3*(a-1)*par->wa)+par->OK*a)); - } - - return dum; -} - -static double na2Hm1(double a,void *params) -{ - ////// - // H0/(a^2*H[a]) - double dum; - Csm_bg_params *par=(Csm_bg_params *)params; - - if(par->normalDE) - dum=1/sqrt(a*(par->OM+par->OL*a*a*a+par->OK*a)); - else if(par->constantw) { - dum=1/sqrt(a*(par->OM+par->OL*pow(a,-3*par->w0)+par->OK*a)); - } - else { - dum=1/sqrt(a*(par->OM+par->OL*pow(a,-3*(par->w0+par->wa))* - exp(3*(a-1)*par->wa)+par->OK*a)); - } - - return dum; -} - -static double naHm3(double a,void *params) -{ - ////// - // (H0/(a*H[a]))^3 - double dum; - Csm_bg_params *par=(Csm_bg_params *)params; - - if(par->normalDE) { - dum=sqrt(a/(par->OM+par->OL*a*a*a+par->OK*a)); - } - else if(par->constantw) { - dum=sqrt(a/(par->OM+par->OL*pow(a,-3*par->w0)+par->OK*a)); - } - else { - dum=sqrt(a/(par->OM+par->OL*pow(a,-3*(par->w0+par->wa))* - exp(3*(a-1)*par->wa)+par->OK*a)); - } - - return dum*dum*dum; -} - -static void parthor(Csm_bg_params *par, - double aa,double *ph,double *delph) -{ - ////// - // Particle horizon. The returned value is in Mpc/h. - double alim; - - alim=0.01*par->a_equality; - if(aa<=alim) { - *ph=2*sqrt(aa/par->OM)*CSM_HMPC; - *delph=0; - } - else { - double relerrt=1E-6; - double integral,errintegral,int0; - size_t sdum; - gsl_function integrand; - int stat; - - int0=2*sqrt(alim/par->OM); - integrand.function=&na2Hm1; - integrand.params=par; - - stat=gsl_integration_qng(&integrand,alim,aa,0,relerrt, - &integral,&errintegral,&sdum); - int_error_handle(stat,integral,errintegral); - *ph=(int0+integral)*CSM_HMPC; - // *delph=errintegral*CSM_HMPC; - } -} - -static void gfac(Csm_bg_params *par, - double aa,double *gf,double *delgf) -{ - ////// - // Growth factor, normalized to gfac(a<a_equality; - int0=0.4*sqrt(alim*alim*alim*alim*alim/(par->OM*par->OM*par->OM)); - if(aa<=alim) { - *gf=aa; - *delgf=0; - } - else { - double relerrt=1E-4; - double integral,errintegral; - size_t sdum; - gsl_function integrand; - int stat; - - integrand.function=&naHm3; - integrand.params=par; - - stat=gsl_integration_qng(&integrand,alim,aa,0,relerrt, - &integral,&errintegral,&sdum); - int_error_handle(stat,integral,errintegral); - *gf=(int0+integral)*2.5*par->OM/(aa*naHm1(aa,par)); - } -} - -double csm_omega_m(Csm_params *par,double aa) -{ - if(par->bg->normalDE) - return par->bg->OM/(par->bg->OM+par->bg->OL*aa*aa*aa+par->bg->OK*aa); - else if(par->bg->constantw) { - return par->bg->OM/(par->bg->OM+par->bg->OL*pow(aa,-3*par->bg->w0)+par->bg->OK*aa); - } - else { - return par->bg->OM/(par->bg->OM+par->bg->OL*pow(aa,-3*(par->bg->w0+par->bg->wa))* - exp(3*par->bg->wa*(aa-1))+par->bg->OK*aa); - } -} - -double csm_hubble(Csm_params *par,double aa) -{ - ////// - // Hubble rate at aa in h/Mpc - if(par->bg->normalDE) { - return sqrt((par->bg->OM+par->bg->OL*aa*aa*aa+par->bg->OK*aa)/ - (aa*aa*aa))/CSM_HMPC; - } - else if(par->bg->constantw) { - return sqrt((par->bg->OM+par->bg->OL*pow(aa,-3*par->bg->w0)+ - par->bg->OK*aa)/(aa*aa*aa))/CSM_HMPC; - } - else { - return sqrt((par->bg->OM+par->bg->OL*pow(aa,-3*(par->bg->w0+par->bg->wa))* - exp(3*par->bg->wa*(aa-1))+par->bg->OK*aa)/(aa*aa*aa))/CSM_HMPC; - } -} - -double csm_particle_horizon(Csm_params *par,double aa) -{ - ////// - // Particle horizon - double ph, eph; - - parthor(par->bg,aa,&ph,&eph); - return ph; -} - -double csm_radial_comoving_distance(Csm_params *par,double aa) -{ - ////// - // chi(a) - double rcd; - - rcd=csm_particle_horizon(par,aa); - return par->bg->phorizon-rcd; -} - -double csm_curvature_comoving_distance(Csm_params *par,double aa) -{ - ////// - // r(a) - if(par->bg->ksign==0) - return csm_radial_comoving_distance(par,aa); - else { - double dum; - double ksq=sqrt(fabs(par->bg->OK)); - dum=csm_radial_comoving_distance(par,aa)/CSM_HMPC; - dum=sinn(ksq*dum,par->bg->ksign)/ksq; - return dum*CSM_HMPC; - } -} - -double csm_growth_factor(Csm_params *par,double aa) -{ - ////// - // D(a) - double gf,egf; - - gfac(par->bg,aa,&gf,&egf); - - return gf; -} - -double csm_f_growth(Csm_params *par,double aa) -{ - ////// - // f(a)= d ln(D)/d ln(a) - // Using the integral definition for D(a) - double apow,coeff,Da; - - Da=csm_growth_factor(par,aa); - if(par->bg->normalDE) { - coeff=0; - apow=aa*aa*aa; - } - else if(par->bg->constantw) { - coeff=(1+par->bg->w0); - apow=pow(aa,-3*par->bg->w0); - } - else { - coeff=(1+par->bg->w0+par->bg->wa*(1-aa)); - apow=pow(aa,-3*(par->bg->w0+par->bg->wa))*exp(3*par->bg->wa*(aa-1)); - } - - return 0.5*(5*par->bg->OM*aa/Da- - (3*par->bg->OM+3*coeff*par->bg->OL*apow+2*par->bg->OK*aa))/ - (par->bg->OM+par->bg->OL*apow+par->bg->OK*aa); -} - -void csm_background_set(Csm_params *par, - double OmegaM,double OmegaL,double OmegaB, - double ww,double wwa,double hh,double T_CMB) -{ - ////// - // This initializes the cosmological parameters. - if(par->bg_params_set) - csm_bg_params_free(par->bg); - par->bg_params_set=0; - - par->bg=csm_bg_params_new(); - par->bg_params_set=1; - par->bg->h=hh; - par->bg->w0=ww; - par->bg->wa=wwa; - par->bg->OM=OmegaM; - par->bg->OL=OmegaL; - par->bg->OK=1-par->bg->OM-par->bg->OL; - par->bg->OB=OmegaB; - par->bg->TCMB=T_CMB; - - //Check parameters - if(fabs(par->bg->wa)<1E-6) { - if(fabs(par->bg->w0+1)<1E-6) { - par->bg->constantw=1; - par->bg->normalDE=1; - } - else { - par->bg->constantw=1; - par->bg->normalDE=0; - } - } - else { - par->bg->constantw=0; - par->bg->normalDE=0; - } - - if(fabs(par->bg->OK)<1E-6) - par->bg->ksign=0; - else if(par->bg->OK>0) - par->bg->ksign=-1; - else - par->bg->ksign=1; - - if(par->bg->OM<=0) { - fprintf(stderr,"CoLoRe: Wrong matter parameter %.3lf \n", - par->bg->OM); - exit(1); - } - if(par->bg->OMbg->OB) { - fprintf(stderr,"CoLoRe: Wrong M/B parameter %.3lf > %.3lf \n", - par->bg->OB,par->bg->OM); - exit(1); - } - if(par->bg->w0>-0.333333) { - fprintf(stderr,"CoLoRe: DE is too exotic (w=%.3lf \n",par->bg->w0); - exit(1); - } - if(par->bg->TCMB<0) { - fprintf(stderr,"CoLoRe: Wrong CMB temperature %.3lf \n", - par->bg->TCMB); - exit(1); - } - - if(csm_flag_verbose) { - print_info("The cosmological model is:\n"); - print_info(" O_M=%.3f O_L=%.3f O_K=%.3f\n", - par->bg->OM,par->bg->OL,par->bg->OK); - print_info(" O_B=%.3f w=%.3f h=%.3f\n", - par->bg->OB,par->bg->w0,par->bg->h); - if(par->bg->ksign==0) - print_info(" Flat universe, "); - else if(par->bg->ksign==1) - print_info(" Closed universe, "); - else if(par->bg->ksign==-1) - print_info(" Open universe, "); - if(par->bg->normalDE) - print_info("standard cosmological constant\n"); - else { - print_info("non-standard dark energy"); - if(par->bg->constantw) - print_info("\n"); - else - print_info(": w(a) = %.3lf + %.3lf*(1-a) \n",par->bg->w0,par->bg->wa); - } - } - par->bg->a_equality=aeqmin(par->bg); - par->bg->phorizon=csm_particle_horizon(par,1); - par->bg->growth0=csm_growth_factor(par,1); - if(csm_flag_verbose) { - print_info("\n Time of equality: a_eq=%.5lf\n",par->bg->a_equality); - print_info(" Particle horizon: "); - print_info("chi_H(0)=%.3lE Mpc/h\n",par->bg->phorizon); - print_info(" Present growth factor: "); - print_info("D_0=%.3lf\n\n",par->bg->growth0); - } -} diff --git a/src/.ipynb_checkpoints/cstm-checkpoint.c b/src/.ipynb_checkpoints/cstm-checkpoint.c deleted file mode 100644 index a8997c1..0000000 --- a/src/.ipynb_checkpoints/cstm-checkpoint.c +++ /dev/null @@ -1,158 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -void cstm_set_cartesian(ParamCoLoRe *par) -{ - return; -} - -void cstm_get_local_properties(ParamCoLoRe *par) -{ - return; -} - -void cstm_distribute(ParamCoLoRe *par) -{ - return; -} - -static void cstm_beams_preproc_single(ParamCoLoRe *par, int ipop) -{ - //Zero all data and clear -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,ipop) -#endif //_HAVE_OMP - { - long ipp; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ipp=0;ippcstm[ipop]->num_pix;ipp++) { - par->cstm[ipop]->data[ipp]=0; - par->cstm[ipop]->nadd[ipp]=1; - } //end omp for - } //end omp parallel - - return; -} - -void cstm_beams_preproc(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_cstm;ipop++) - cstm_beams_preproc_single(par,ipop); -} - -static void cstm_get_beam_properties_single(ParamCoLoRe *par,int ipop) -{ - HealpixShells *cmap=par->cstm[ipop]; - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,cmap,ipop) -#endif //_HAVE_OMP - { - double idx=par->n_grid/par->l_box; - - //Setup radial decomposition - int ir,nr; - double dr; - get_radial_params(par->r_max,par->n_grid,&nr,&dr); - - //Precompute kernel, bias and normalization - double k_max=-1E100; - double *kz=my_malloc(nr*sizeof(double)); - double *bz=my_malloc(nr*sizeof(double)); - double *normz=my_malloc(nr*sizeof(double)); - for(ir=0;irk_max) - k_max=fabs(kz[ir]); - } - //Find integration edges - int ir_min=0, ir_max=nr-1; - - for(ir=0;ir1E-4*k_max) { - ir_min=ir; - break; - } - } - for(ir=nr-1;ir>=0;ir--) { - if(fabs(kz[ir])>1E-4*k_max) { - ir_max=ir; - break; - } - } - if(ir_max < ir_min) - report_error(1, "Custom kernel has no suppport"); - - - long ip; -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ip=0;ipnum_pix;ip++) { - int ax,irr,added; - flouble d; - double xn[3]; - double *u=&(cmap->pos[3*ip]); - double cval=0; - - for(irr=ir_min;irr<=ir_max;irr++) { - double rm=(irr+0.5)*dr; - for(ax=0;ax<3;ax++) - xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; - added=interpolate_from_grid(par,xn,&d,NULL,NULL,NULL,NULL,RETURN_DENS,INTERP_CIC); - if(added) - cval+=kz[irr]*(bias_model(d,bz[irr])*normz[irr]-1); - } - cmap->data[ip]+=cval*dr; - } //end omp for - - free(kz); - free(bz); - free(normz); - } //end omp parallel - - return; -} - -void cstm_get_beam_properties(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_cstm;ipop++) - cstm_get_beam_properties_single(par,ipop); -} - -void cstm_beams_postproc(ParamCoLoRe *par) -{ - //Set rf to end of cell - return; -} diff --git a/src/.ipynb_checkpoints/density-checkpoint.c b/src/.ipynb_checkpoints/density-checkpoint.c deleted file mode 100644 index f41bbc3..0000000 --- a/src/.ipynb_checkpoints/density-checkpoint.c +++ /dev/null @@ -1,1393 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -static dftw_complex *dftw_alloc_complex(ptrdiff_t dsize) -{ - dftw_complex *p; -#ifdef _SPREC - p=fftwf_alloc_complex(dsize); -#else //_SPREC - p=fftw_alloc_complex(dsize); -#endif //_SPREC - if(p==NULL) - report_error(1,"Ran out of memory\n"); - return p; -} - -static void pos_2_ngp(ParamCoLoRe *par,unsigned long long np, - flouble *x,flouble *y,flouble *z,flouble *delta) -{ - unsigned long long ii; - flouble i_agrid=par->n_grid/par->l_box; - long ngx=2*(par->n_grid/2+1); - - for(ii=0;ii=par->n_grid) i0[ax]-=par->n_grid; - if(i0[ax]<0) i0[ax]+=par->n_grid; - } - i0[2]-=par->iz0_here; - - if((i0[2]>=0) && (i0[2]nz_here)) { - index=i0[0]+ngx*(i0[1]+par->n_grid*i0[2]); - delta[index]+=1.; - } - } -} - -static void pos_2_cic(ParamCoLoRe *par,unsigned long long np, - flouble *x,flouble *y,flouble *z,flouble *delta) -{ - unsigned long long ii; - flouble i_agrid=par->n_grid/par->l_box; - long ngx=2*(par->n_grid/2+1); - - for(ii=0;iin_grid; - if(i1[ax]<0) i1[ax]+=par->n_grid; - if(i0[ax]>=par->n_grid) i0[ax]-=par->n_grid; - if(i1[ax]>=par->n_grid) i1[ax]-=par->n_grid; - } - i0[2]-=par->iz0_here; - i1[2]-=par->iz0_here; - - if((i0[2]>=0) && (i0[2]nz_here)) { - delta[i0[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=a0[0]*a0[1]*a0[2]; - delta[i1[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=a1[0]*a0[1]*a0[2]; - delta[i0[0]+ngx*(i1[1]+par->n_grid*i0[2])]+=a0[0]*a1[1]*a0[2]; - delta[i1[0]+ngx*(i1[1]+par->n_grid*i0[2])]+=a1[0]*a1[1]*a0[2]; - } - if((i1[2]>=0) && (i1[2]nz_here)) { - delta[i0[0]+ngx*(i0[1]+par->n_grid*i1[2])]+=a0[0]*a0[1]*a1[2]; - delta[i1[0]+ngx*(i0[1]+par->n_grid*i1[2])]+=a1[0]*a0[1]*a1[2]; - delta[i0[0]+ngx*(i1[1]+par->n_grid*i1[2])]+=a0[0]*a1[1]*a1[2]; - delta[i1[0]+ngx*(i1[1]+par->n_grid*i1[2])]+=a1[0]*a1[1]*a1[2]; - } - } -} - -static void pos_2_tsc(ParamCoLoRe *par,unsigned long long np, - flouble *x,flouble *y,flouble *z,flouble *delta) -{ - unsigned long long ii; - flouble i_agrid=par->n_grid/par->l_box; - long ngx=2*(par->n_grid/2+1); - - for(ii=0;iin_grid; - if(i0[ax]<0) i0[ax]+=par->n_grid; - if(ip[ax]<0) ip[ax]+=par->n_grid; - if(im[ax]>=par->n_grid) im[ax]-=par->n_grid; - if(i0[ax]>=par->n_grid) i0[ax]-=par->n_grid; - if(ip[ax]>=par->n_grid) ip[ax]-=par->n_grid; - } - i0[2]-=par->iz0_here; - im[2]-=par->iz0_here; - ip[2]-=par->iz0_here; - - if((im[2]>=0) && (im[2]nz_here)) { - delta[im[0]+ngx*(im[1]+par->n_grid*im[2])]+=am[0]*am[1]*am[2]; - delta[i0[0]+ngx*(im[1]+par->n_grid*im[2])]+=a0[0]*am[1]*am[2]; - delta[ip[0]+ngx*(im[1]+par->n_grid*im[2])]+=ap[0]*am[1]*am[2]; - delta[im[0]+ngx*(i0[1]+par->n_grid*im[2])]+=am[0]*a0[1]*am[2]; - delta[i0[0]+ngx*(i0[1]+par->n_grid*im[2])]+=a0[0]*a0[1]*am[2]; - delta[ip[0]+ngx*(i0[1]+par->n_grid*im[2])]+=ap[0]*a0[1]*am[2]; - delta[im[0]+ngx*(ip[1]+par->n_grid*im[2])]+=am[0]*ap[1]*am[2]; - delta[i0[0]+ngx*(ip[1]+par->n_grid*im[2])]+=a0[0]*ap[1]*am[2]; - delta[ip[0]+ngx*(ip[1]+par->n_grid*im[2])]+=ap[0]*ap[1]*am[2]; - } - if((i0[2]>=0) && (i0[2]nz_here)) { - delta[im[0]+ngx*(im[1]+par->n_grid*i0[2])]+=am[0]*am[1]*a0[2]; - delta[i0[0]+ngx*(im[1]+par->n_grid*i0[2])]+=a0[0]*am[1]*a0[2]; - delta[ip[0]+ngx*(im[1]+par->n_grid*i0[2])]+=ap[0]*am[1]*a0[2]; - delta[im[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=am[0]*a0[1]*a0[2]; - delta[i0[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=a0[0]*a0[1]*a0[2]; - delta[ip[0]+ngx*(i0[1]+par->n_grid*i0[2])]+=ap[0]*a0[1]*a0[2]; - delta[im[0]+ngx*(ip[1]+par->n_grid*i0[2])]+=am[0]*ap[1]*a0[2]; - delta[i0[0]+ngx*(ip[1]+par->n_grid*i0[2])]+=a0[0]*ap[1]*a0[2]; - delta[ip[0]+ngx*(ip[1]+par->n_grid*i0[2])]+=ap[0]*ap[1]*a0[2]; - } - if((ip[2]>=0) && (ip[2]nz_here)) { - delta[im[0]+ngx*(im[1]+par->n_grid*ip[2])]+=am[0]*am[1]*ap[2]; - delta[i0[0]+ngx*(im[1]+par->n_grid*ip[2])]+=a0[0]*am[1]*ap[2]; - delta[ip[0]+ngx*(im[1]+par->n_grid*ip[2])]+=ap[0]*am[1]*ap[2]; - delta[im[0]+ngx*(i0[1]+par->n_grid*ip[2])]+=am[0]*a0[1]*ap[2]; - delta[i0[0]+ngx*(i0[1]+par->n_grid*ip[2])]+=a0[0]*a0[1]*ap[2]; - delta[ip[0]+ngx*(i0[1]+par->n_grid*ip[2])]+=ap[0]*a0[1]*ap[2]; - delta[im[0]+ngx*(ip[1]+par->n_grid*ip[2])]+=am[0]*ap[1]*ap[2]; - delta[i0[0]+ngx*(ip[1]+par->n_grid*ip[2])]+=a0[0]*ap[1]*ap[2]; - delta[ip[0]+ngx*(ip[1]+par->n_grid*ip[2])]+=ap[0]*ap[1]*ap[2]; - } - } -} - -static void pos_2_dens(ParamCoLoRe *par,unsigned long long np_here, - flouble *x,flouble *y,flouble *z,flouble *dens) -{ - if(par->lpt_interp_type==INTERP_NGP) - pos_2_ngp(par,np_here,x,y,z,dens); - else if(par->lpt_interp_type==INTERP_CIC) - pos_2_cic(par,np_here,x,y,z,dens); - else if(par->lpt_interp_type==INTERP_TSC) - pos_2_tsc(par,np_here,x,y,z,dens); - else - report_error(1,"Wrong interpolation type\n"); -} - -#ifdef _HAVE_MPI -static void share_particles(ParamCoLoRe *par,unsigned long long np_allocated,unsigned long long np_real, - flouble *x,flouble *y,flouble *z,unsigned long long *np_here) -{ - int inode; - unsigned long long ip; - flouble dx=par->l_box/par->n_grid; - flouble *z_left=my_malloc(NNodes*sizeof(flouble)); - flouble *z_right=my_malloc(NNodes*sizeof(flouble)); - flouble *z_true_left=my_malloc(NNodes*sizeof(flouble)); - flouble *z_true_right=my_malloc(NNodes*sizeof(flouble)); - flouble *z_bleft_left=my_malloc(NNodes*sizeof(flouble)); - flouble *z_bleft_right=my_malloc(NNodes*sizeof(flouble)); - flouble *z_bright_left=my_malloc(NNodes*sizeof(flouble)); - flouble *z_bright_right=my_malloc(NNodes*sizeof(flouble)); - unsigned long long nbuffer=(unsigned long long)(par->lpt_buffer_fraction*par->nz_here* - ((long)(par->n_grid*par->n_grid))); - flouble *x_b=my_malloc(nbuffer*sizeof(flouble)); - flouble *y_b=my_malloc(nbuffer*sizeof(flouble)); - flouble *z_b=my_malloc(nbuffer*sizeof(flouble)); - - for(inode=0;inodeiz0_all[inode]*dx; - z_right[inode]=(par->iz0_all[inode]+par->nz_all[inode])*dx; - z_true_left[inode]=(par->iz0_all[inode]+(par->lpt_interp_type+1)*0.5)*dx; - z_true_right[inode]=(par->iz0_all[inode]+par->nz_all[inode]-(par->lpt_interp_type+1)*0.5)*dx; - z_bleft_left[inode]=(par->iz0_all[inode]-(par->lpt_interp_type+1)*0.5)*dx; - z_bleft_right[inode]=z_left[inode]; - z_bright_left[inode]=z_right[inode]; - z_bright_right[inode]=(par->iz0_all[inode]+par->nz_all[inode]+(par->lpt_interp_type+1)*0.5)*dx; - if(inode==0) { - z_bleft_left[inode]=(par->n_grid-(par->lpt_interp_type+1)*0.5)*dx; - z_bleft_right[inode]=par->n_grid*dx; - } - else if(inode==NNodes-1) { - z_bright_left[inode]=0; - z_bright_right[inode]=(par->lpt_interp_type+1)*0.5*dx; - } -#ifdef _DEBUG - print_info("MPI task %d: [%lf,%lf] [%lf,%lf] [%lf %lf] [%lf %lf]\n",inode, - z_left[inode],z_right[inode], - z_true_left[inode],z_true_right[inode], - z_bleft_left[inode],z_bleft_right[inode], - z_bright_left[inode],z_bright_right[inode]); -#ifdef _HAVE_MPI - MPI_Barrier(MPI_COMM_WORLD); -#endif -#endif //_DEBUG - } - - //Figure out which particles need to be moved and which stay - unsigned long long n_inrange=0,n_inbuffer=0; - for(ip=0;ip=z_left[NodeThis]) && (z[ip]=z_bleft_left[NodeThis]) && (z[ip]=z_bright_left[NodeThis]) && (z[ip]=z_true_right[NodeThis])) - send=1; - - if(send) { - if(n_inbuffer>=nbuffer) - report_error(1,"Out of memory, enlarge buffer %llu (%llu,%llu) %llu\n", - np_allocated,n_inbuffer,nbuffer,n_inrange); - x_b[n_inbuffer]=x[ip]; - y_b[n_inbuffer]=y[ip]; - z_b[n_inbuffer]=z[ip]; - n_inbuffer++; - } - - if(include) { - if(n_inrange>=np_allocated) - report_error(1,"Out of memory, enlarge buffer %llu %llu %llu\n",np_allocated,n_inbuffer,n_inrange); - x[n_inrange]=x[ip]; - y[n_inrange]=y[ip]; - z[n_inrange]=z[ip]; - n_inrange++; - } - } - -#ifdef _DEBUG - printf("MPI task %d: %llu %llu %llu %llu\n",NodeThis,np_allocated,n_inrange,nbuffer,n_inbuffer); -#ifdef _HAVE_MPI - MPI_Barrier(MPI_COMM_WORLD); -#endif -#endif //_DEBUG - - for(inode=1;inode=z_left[node_to]) && (z_b[i]=z_bleft_left[node_to]) && (z_b[i]=z_bright_left[node_to]) && (z_b[i]=0 && - (((z_b[j]>=z_left[node_to]) && (z_b[j]=z_bleft_left[node_to]) && (z_b[j]=z_bright_left[node_to]) && (z_b[j]np_allocated) - report_error(1,"Not enough memory, enlarge buffer\n"); - -#ifdef _HAVE_MPI - MPI_Sendrecv(x_send,nsend*sizeof(flouble),FLOUBLE_MPI,node_to,tag, - x+n_inrange,nrecv*sizeof(flouble),FLOUBLE_MPI,node_from,tag,MPI_COMM_WORLD,&status); - MPI_Sendrecv(y_send,nsend*sizeof(flouble),FLOUBLE_MPI,node_to,tag, - y+n_inrange,nrecv*sizeof(flouble),FLOUBLE_MPI,node_from,tag,MPI_COMM_WORLD,&status); - MPI_Sendrecv(z_send,nsend*sizeof(flouble),FLOUBLE_MPI,node_to,tag, - z+n_inrange,nrecv*sizeof(flouble),FLOUBLE_MPI,node_from,tag,MPI_COMM_WORLD,&status); -#endif //_HAVE_MPI - - n_inrange+=nrecv; - } - - *np_here=n_inrange; - - free(z_left); - free(z_right); - free(z_bleft_left); - free(z_bleft_right); - free(z_bright_left); - free(z_bright_right); - free(x_b); - free(y_b); - free(z_b); - - return; -} -#endif //_HAVE_MPI - -static void lpt_1(ParamCoLoRe *par) -{ - int axis; - - dftw_complex *(cdisp[3]); - flouble *(disp[3]); - ptrdiff_t dsize=par->nz_here*((long)(par->n_grid*(par->n_grid/2+1))); - ptrdiff_t dsize_buff=(ptrdiff_t)(dsize*(1+par->lpt_buffer_fraction)); - - print_info(" 1LPT\n"); - - print_info(" - Transforming density field\n"); - for(axis=0;axis<3;axis++) { - cdisp[axis]=dftw_alloc_complex(dsize_buff); - disp[axis]=(flouble *)cdisp[axis]; - } - fftw_wrap_r2c(par->n_grid,par->grid_dens,par->grid_dens_f); - - print_info(" - Computing displacement field\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,cdisp) -#endif //_HAVE_OMP - { - int ii; - double dk=2*M_PI/par->l_box; - double kv[3]; - double fftnorm=(double)(par->n_grid*((long)(par->n_grid*par->n_grid))); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iinz_here;ii++) { - int jj,ii_true; - ii_true=par->iz0_here+ii; - if(2*ii_true<=par->n_grid) - kv[2]=ii_true*dk; - else - kv[2]=-(par->n_grid-ii_true)*dk; - for(jj=0;jjn_grid;jj++) { - int kk; - if(2*jj<=par->n_grid) - kv[1]=jj*dk; - else - kv[1]=-(par->n_grid-jj)*dk; - for(kk=0;kk<=par->n_grid/2;kk++) { - int ax; - double k_mod2; - long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k - if(2*kk<=par->n_grid) - kv[0]=kk*dk; - else - kv[0]=-(par->n_grid-kk)*dk; //This should never happen - - k_mod2=fftnorm*(kv[0]*kv[0]+kv[1]*kv[1]+kv[2]*kv[2]); - - for(ax=0;ax<3;ax++) { - if(k_mod2<=0) - cdisp[ax][index]=0; - else - cdisp[ax][index]=I*kv[ax]*par->grid_dens_f[index]/k_mod2; - } - } - } - } //end omp for - } //end omp parallel - - print_info(" - Transform displacement field\n"); - for(axis=0;axis<3;axis++) - fftw_wrap_c2r(par->n_grid,cdisp[axis],disp[axis]); - - print_info(" - Computing particle positions\n"); -#ifdef _DEBUG - double d_sigma2_1=0; - double d_mean_1[3]={0,0,0}; -#endif //_DEBUG -#ifdef _HAVE_OMP -#ifdef _DEBUG -#pragma omp parallel default(none) shared(par,disp,d_mean_1,d_sigma2_1) -#else //_DEBUG -#pragma omp parallel default(none) shared(par,disp) -#endif //_DEBUG -#endif //_HAVE_OMP - { - long iz; - int ngx=2*(par->n_grid/2+1); - flouble dx=par->l_box/par->n_grid; - flouble xv[3]; - -#ifdef _DEBUG - double d_sigma2_1_thr=0; - double d_mean_1_thr[3]={0,0,0}; -#endif //_DEBUG - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - xv[2]=(iz+par->iz0_here+0.0)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - xv[1]=(iy+0.0)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - int ax; - double r,dg; - long index=ix+indexy+indexz; - xv[0]=(ix+0.0)*dx-par->pos_obs[0]; - r=sqrt(xv[0]*xv[0]+xv[1]*xv[1]+xv[2]*xv[2]); - dg=get_bg(par,r,BG_D1,0); - for(ax=0;ax<3;ax++) { -#ifdef _DEBUG - d_mean_1_thr[ax]+=disp[ax][index]; - d_sigma2_1_thr+=disp[ax][index]*disp[ax][index]; -#endif //_DEBUG - flouble p=xv[ax]+dg*disp[ax][index]+par->pos_obs[ax]; - if(p<0) p+=par->l_box; - if(p>=par->l_box) p-=par->l_box; - disp[ax][index]=p; - } - par->grid_dens[index]=0; - } - } - } //end omp for -#ifdef _DEBUG -#ifdef _HAVE_OMP -#pragma omp critical -#endif //_HAVE_OMP - { - d_mean_1[0]+=d_mean_1_thr[0]; - d_mean_1[1]+=d_mean_1_thr[1]; - d_mean_1[2]+=d_mean_1_thr[2]; - d_sigma2_1+=d_sigma2_1_thr; - } -#endif //_DEBUG - } //end omp parallel - -#ifdef _DEBUG -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(d_mean_1,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(&d_sigma2_1,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - if(NodeThis==0) { - d_mean_1[0]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_1[1]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_1[2]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_sigma2_1/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - - print_info(" 1st-order displacement : [%lE,%lE,%lE] %lE\n", - d_mean_1[0],d_mean_1[1],d_mean_1[2],sqrt(d_sigma2_1)); - } -#endif //_DEBUG - - print_info(" - Undoing padding\n"); - { - long iz; - int ngx=2*(par->n_grid/2+1); - - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - long indexz_unpadded=iz*((long)(par->n_grid*par->n_grid)); - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - long indexy_unpadded=iy*par->n_grid; - for(ix=0;ixn_grid;ix++) { - int ax; - long index=ix+indexy+indexz; - long index_unpadded=ix+indexy_unpadded+indexz_unpadded; - for(ax=0;ax<3;ax++) - disp[ax][index_unpadded]=disp[ax][index]; - } - } - } - } - - unsigned long long np_here; - if(par->output_lpt) { - np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); - print_info(" - Writing LPT positions\n"); - write_lpt(par,np_here,disp[0],disp[1],disp[2]); - } - -#ifdef _HAVE_MPI - print_info(" - Sharing particle positions\n"); - share_particles(par,(unsigned long long)(2*dsize_buff), - (unsigned long long)(par->nz_here*((long)(par->n_grid*par->n_grid))), - disp[0],disp[1],disp[2],&np_here); -#else //_HAVE_MPI - np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); -#endif //_HAVE_MPI - - print_info(" - Interpolating positions into density field\n"); - pos_2_dens(par,np_here,disp[0],disp[1],disp[2],par->grid_dens); - -#ifdef _SPREC - for(axis=0;axis<3;axis++) - fftwf_free(cdisp[axis]); -#else //_SPREC - for(axis=0;axis<3;axis++) - fftw_free(cdisp[axis]); -#endif //_SPREC - - print_info(" - Normalizing density field\n"); -#ifdef _DEBUG - double numtot=0; -#endif //_DEBUG -#ifdef _HAVE_OMP -#ifdef _DEBUG -#pragma omp parallel default(none) shared(par,numtot) -#else //_DEBUG -#pragma omp parallel default(none) shared(par) -#endif //_DEBUG -#endif //_HAVE_OMP - { - long iz; - int ngx=2*(par->n_grid/2+1); - flouble inv_dens=1.; -#ifdef _DEBUG - double numtot_thr=0; -#endif //_DEBUG - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - for(ix=0;ixn_grid;ix++) { - long index=ix+indexy+indexz; -#ifdef _DEBUG - numtot_thr+=par->grid_dens[index]; -#endif //_DEBUG - par->grid_dens[index]=par->grid_dens[index]*inv_dens-1.; - } - } - } //end omp for -#ifdef _DEBUG -#ifdef _HAVE_OMP -#pragma omp critical -#endif //_HAVE_OMP - { - numtot+=numtot_thr; - } -#endif //_DEBUG - } //end omp parallel - -#ifdef _DEBUG -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(&numtot,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - print_info(" Total density : %lE\n",numtot-(double)(par->n_grid*((long)(par->n_grid*par->n_grid)))); -#endif //_DEBUG -} - -static void lpt_2(ParamCoLoRe *par) -{ - int axis; - - dftw_complex *(cdisp[3]),*(cdigrad[6]); - flouble *(disp[3]),*(digrad[6]); - ptrdiff_t dsize=par->nz_here*((long)(par->n_grid*(par->n_grid/2+1))); - ptrdiff_t dsize_buff=(ptrdiff_t)(dsize*(1+par->lpt_buffer_fraction)); - - print_info(" 2LPT\n"); - - print_info(" - Transforming density field\n"); - for(axis=0;axis<2;axis++) { - cdisp[axis]=dftw_alloc_complex(dsize_buff); - disp[axis]=(flouble *)cdisp[axis]; - } - for(axis=0;axis<6;axis++) { - cdigrad[axis]=dftw_alloc_complex(dsize_buff); - digrad[axis]=(flouble *)cdigrad[axis]; - } - cdisp[2]=par->grid_dens_f; - disp[2]=par->grid_dens; - fftw_wrap_r2c(par->n_grid,par->grid_dens,par->grid_dens_f); - - print_info(" - Computing displacement field\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,cdisp,cdigrad) -#endif //_HAVE_OMP - { - int ii; - double dk=2*M_PI/par->l_box; - double kv[3]; - double fftnorm=(double)(par->n_grid*((long)(par->n_grid*par->n_grid))); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iinz_here;ii++) { - int jj,ii_true; - ii_true=par->iz0_here+ii; - if(2*ii_true<=par->n_grid) - kv[2]=ii_true*dk; - else - kv[2]=-(par->n_grid-ii_true)*dk; - for(jj=0;jjn_grid;jj++) { - int kk; - if(2*jj<=par->n_grid) - kv[1]=jj*dk; - else - kv[1]=-(par->n_grid-jj)*dk; - for(kk=0;kk<=par->n_grid/2;kk++) { - int ax; - double k_mod2; - long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k - if(2*kk<=par->n_grid) - kv[0]=kk*dk; - else - kv[0]=-(par->n_grid-kk)*dk; //This should never happen - - k_mod2=fftnorm*(kv[0]*kv[0]+kv[1]*kv[1]+kv[2]*kv[2]); - - for(ax=0;ax<3;ax++) { - if(k_mod2<=0) - cdisp[ax][index]=0; - else - cdisp[ax][index]=I*kv[ax]*par->grid_dens_f[index]/k_mod2; - } - - cdigrad[0][index]=I*kv[0]*cdisp[0][index]; //SIGN - cdigrad[1][index]=I*kv[1]*cdisp[0][index]; - cdigrad[2][index]=I*kv[2]*cdisp[0][index]; - cdigrad[3][index]=I*kv[1]*cdisp[1][index]; - cdigrad[4][index]=I*kv[2]*cdisp[1][index]; - cdigrad[5][index]=I*kv[2]*cdisp[2][index]; - } - } - } //end omp for - } //end omp parallel - - print_info(" - Transform digradient\n"); - for(axis=0;axis<6;axis++) - fftw_wrap_c2r(par->n_grid,cdigrad[axis],digrad[axis]); - - print_info(" - Computing second-order potential\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,digrad) -#endif //_HAVE_OMP - { - int iz; - int ngx=2*(par->n_grid/2+1); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - for(ix=0;ixn_grid;ix++) { - long index=ix+indexy+indexz; //SIGN - digrad[5][index]= - digrad[0][index]*digrad[3][index]+//xx*yy - digrad[0][index]*digrad[5][index]+//xx*zz - digrad[3][index]*digrad[5][index]-//+yy*zz - digrad[1][index]*digrad[1][index]-//-xy*xy - digrad[2][index]*digrad[2][index]-//-xz*xz - digrad[4][index]*digrad[4][index];//-yz*yz - } - } - } //end omp for - } //end omp parallel - - print_info(" - Transforming second-order potential\n"); - fftw_wrap_r2c(par->n_grid,digrad[5],cdigrad[5]); - - print_info(" - Computing 2nd-order displacement field\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,cdigrad) -#endif //_HAVE_OMP - { - int ii; - double dk=2*M_PI/par->l_box; - double kv[3]; - double fftnorm=(double)(par->n_grid*((long)(par->n_grid*par->n_grid))); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iinz_here;ii++) { - int jj,ii_true; - ii_true=par->iz0_here+ii; - if(2*ii_true<=par->n_grid) - kv[2]=ii_true*dk; - else - kv[2]=-(par->n_grid-ii_true)*dk; - for(jj=0;jjn_grid;jj++) { - int kk; - if(2*jj<=par->n_grid) - kv[1]=jj*dk; - else - kv[1]=-(par->n_grid-jj)*dk; - for(kk=0;kk<=par->n_grid/2;kk++) { - int ax; - double k_mod2; - long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k - if(2*kk<=par->n_grid) - kv[0]=kk*dk; - else - kv[0]=-(par->n_grid-kk)*dk; //This should never happen - - k_mod2=fftnorm*(kv[0]*kv[0]+kv[1]*kv[1]+kv[2]*kv[2]); - - for(ax=0;ax<3;ax++) { - if(k_mod2<=0) - cdigrad[ax][index]=0; - else - cdigrad[ax][index]=-I*kv[ax]*cdigrad[5][index]/k_mod2; //SIGN, 1/k^2, normalization - } - } - } - } //end omp for - } //end omp parallel - - print_info(" - Transform 1st- and 2nd-order displacement fields\n"); - for(axis=0;axis<3;axis++) { - fftw_wrap_c2r(par->n_grid,cdisp[axis],disp[axis]); - fftw_wrap_c2r(par->n_grid,cdigrad[axis],digrad[axis]); - } - - print_info(" - Computing particle positions\n"); -#ifdef _DEBUG - double d_sigma2_1=0; - double d_mean_1[3]={0,0,0}; - double d_sigma2_2=0; - double d_mean_2[3]={0,0,0}; -#endif //_DEBUG -#ifdef _HAVE_OMP -#ifdef _DEBUG -#pragma omp parallel default(none) shared(par,disp,digrad,d_mean_1,d_mean_2,d_sigma2_1,d_sigma2_2) -#else //_DEBUG -#pragma omp parallel default(none) shared(par,disp,digrad) -#endif //_DEBUG -#endif //_HAVE_OMP - { - long iz; - int ngx=2*(par->n_grid/2+1); - flouble dx=par->l_box/par->n_grid; - flouble xv[3]; - -#ifdef _DEBUG - double d_sigma2_1_thr=0; - double d_mean_1_thr[3]={0,0,0}; - double d_sigma2_2_thr=0; - double d_mean_2_thr[3]={0,0,0}; -#endif //_DEBUG - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - xv[2]=(iz+par->iz0_here+0.0)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - xv[1]=(iy+0.0)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - int ax; - double r,dg,d2g; - long index=ix+indexy+indexz; - long index_nopad=ix+par->n_grid*((long)(iy+par->n_grid*iz)); - xv[0]=(ix+0.0)*dx-par->pos_obs[0]; - r=sqrt(xv[0]*xv[0]+xv[1]*xv[1]+xv[2]*xv[2]); - dg=get_bg(par,r,BG_D1,0); - d2g=get_bg(par,r,BG_D2,0); - for(ax=0;ax<3;ax++) { -#ifdef _DEBUG - d_mean_1_thr[ax]+=disp[ax][index]; - d_mean_2_thr[ax]+=digrad[ax][index]; - d_sigma2_1_thr+=disp[ax][index]*disp[ax][index]; - d_sigma2_2_thr+=digrad[ax][index]*digrad[ax][index]; -#endif //_DEBUG - flouble p=xv[ax]+dg*disp[ax][index]+d2g*digrad[ax][index]+par->pos_obs[ax]; - if(p<0) p+=par->l_box; - if(p>=par->l_box) p-=par->l_box; - digrad[3+ax][index_nopad]=p; - } - par->grid_dens[index]=0; - } - } - } //end omp for -#ifdef _DEBUG -#ifdef _HAVE_OMP -#pragma omp critical -#endif //_HAVE_OMP - { - d_mean_1[0]+=d_mean_1_thr[0]; - d_mean_1[1]+=d_mean_1_thr[1]; - d_mean_1[2]+=d_mean_1_thr[2]; - d_mean_2[0]+=d_mean_2_thr[0]; - d_mean_2[1]+=d_mean_2_thr[1]; - d_mean_2[2]+=d_mean_2_thr[2]; - d_sigma2_1+=d_sigma2_1_thr; - d_sigma2_2+=d_sigma2_2_thr; - } -#endif //_DEBUG - } //end omp parallel - -#ifdef _DEBUG -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(d_mean_1,d_mean_1,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,d_mean_2,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(d_mean_2,d_mean_2,3,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(&d_sigma2_1,&d_sigma2_1,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,&d_sigma2_2,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(&d_sigma2_2,&d_sigma2_2,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - if(NodeThis==0) { - d_mean_1[0]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_1[1]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_1[2]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_2[0]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_2[1]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_mean_2[2]/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_sigma2_1/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - d_sigma2_2/=(par->n_grid*((long)(par->n_grid*par->n_grid))); - - print_info(" 1st-order displacement : [%lE,%lE,%lE] %lE\n", - d_mean_1[0],d_mean_1[1],d_mean_1[2],sqrt(d_sigma2_1)); - print_info(" 2nd-order displacement : [%lE,%lE,%lE] %lE\n", - d_mean_2[0],d_mean_2[1],d_mean_2[2],sqrt(d_sigma2_2)); - } -#endif //_DEBUG - -#ifdef _SPREC - for(axis=0;axis<2;axis++) - fftwf_free(cdisp[axis]); - for(axis=0;axis<3;axis++) - fftwf_free(cdigrad[axis]); -#else //_SPREC - for(axis=0;axis<2;axis++) - fftw_free(cdisp[axis]); - for(axis=0;axis<3;axis++) - fftw_free(cdigrad[axis]); -#endif //_SPREC - - unsigned long long np_here; - if(par->output_lpt) { - np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); - print_info(" - Writing LPT positions\n"); - write_lpt(par,np_here,digrad[3],digrad[4],digrad[5]); - } - -#ifdef _HAVE_MPI - print_info(" - Sharing particle positions\n"); - share_particles(par,(unsigned long long)(2*dsize_buff), - (unsigned long long)(par->nz_here*((long)(par->n_grid*par->n_grid))), - digrad[3],digrad[4],digrad[5],&np_here); -#else //_HAVE_MPI - np_here=par->nz_here*((long)(par->n_grid*par->n_grid)); -#endif //_HAVE_MPI - - print_info(" - Interpolating positions into density field\n"); - pos_2_dens(par,np_here,digrad[3],digrad[4],digrad[5],par->grid_dens); - -#ifdef _SPREC - for(axis=0;axis<3;axis++) - fftwf_free(cdigrad[3+axis]); -#else //_SPREC - for(axis=0;axis<3;axis++) - fftw_free(cdigrad[3+axis]); -#endif //_SPREC - - print_info(" - Normalizing density field\n"); -#ifdef _DEBUG - double numtot=0; -#endif //_DEBUG -#ifdef _HAVE_OMP -#ifdef _DEBUG -#pragma omp parallel default(none) shared(par,numtot) -#else //_DEBUG -#pragma omp parallel default(none) shared(par) -#endif //_DEBUG -#endif //_HAVE_OMP - { - long iz; - int ngx=2*(par->n_grid/2+1); - flouble inv_dens=1.; -#ifdef _DEBUG - double numtot_thr=0; -#endif //_DEBUG - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - for(ix=0;ixn_grid;ix++) { - long index=ix+indexy+indexz; -#ifdef _DEBUG - numtot_thr+=par->grid_dens[index]; -#endif //_DEBUG - par->grid_dens[index]=par->grid_dens[index]*inv_dens-1.; - } - } - } //end omp for -#ifdef _DEBUG -#ifdef _HAVE_OMP -#pragma omp critical -#endif //_HAVE_OMP - { - numtot+=numtot_thr; - } -#endif //_DEBUG - } //end omp parallel - -#ifdef _DEBUG -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(&numtot,&numtot,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - print_info(" Total density : %lE\n",numtot-(double)(par->n_grid*((long)(par->n_grid*par->n_grid)))); -#endif //_DEBUG -} - -//Lognormalizes density grid and puts in lightcone -static void densclip(ParamCoLoRe *par) -{ - print_info("Lognormalizin'\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) shared(par) -#endif //_HAVE_OMP - { - long iz; - int ngx=2*(par->n_grid/2+1); - flouble dx=par->l_box/par->n_grid; - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - flouble z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - flouble y0=(iy+0.5)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - long index=ix+indexy+indexz; - flouble x0=(ix+0.5)*dx-par->pos_obs[0]; - double r=sqrt(x0*x0+y0*y0+z0*z0); - double dg=get_bg(par,r,BG_D1,0); - double delta=par->grid_dens[index]; - par->grid_dens[index]=fmax(1+dg*delta,0)-1; - } - } - }//end omp for - }//end omp parallel -} - -//Lognormalizes density grid and puts in lightcone -static void lognormalize(ParamCoLoRe *par) -{ - print_info("Lognormalizin'\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) shared(par) -#endif //_HAVE_OMP - { - long iz; - int ngx=2*(par->n_grid/2+1); - flouble dx=par->l_box/par->n_grid; - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - flouble z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - flouble y0=(iy+0.5)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - long index=ix+indexy+indexz; - flouble x0=(ix+0.5)*dx-par->pos_obs[0]; - double r=sqrt(x0*x0+y0*y0+z0*z0); - double dg=get_bg(par,r,BG_D1,0); - double delta=par->grid_dens[index]; - par->grid_dens[index]=exp(dg*(delta-0.5*dg*par->sigma2_gauss))-1; - } - } - }//end omp for - }//end omp parallel -} - -void compute_physical_density_field(ParamCoLoRe *par) -{ - print_info("*** Creating physical matter density\n"); - if(NodeThis==0) timer(0); - - if(par->dens_type==DENS_TYPE_LGNR) - lognormalize(par); - else if(par->dens_type==DENS_TYPE_1LPT) - lpt_1(par); - else if(par->dens_type==DENS_TYPE_2LPT) - lpt_2(par); - else if(par->dens_type==DENS_TYPE_CLIP) - densclip(par); - else - report_error(1,"Density type %d not supported\n",par->dens_type); - - if(NodeThis==0) timer(2); - print_info("\n"); - - if(par->output_density) - write_density_grid(par,"lightcone"); -} - -static void collect_density_normalization_from_grid(ParamCoLoRe *par,int nz,double idz,double *zarr, - unsigned long long *narr, - double **norm_srcs_arr,double **norm_imap_arr, - double **norm_cstm_arr) -{ -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,idz,nz,zarr,narr,norm_srcs_arr,norm_imap_arr,norm_cstm_arr) -#endif //_HAVE_OMP - { - int iz,ipop; - flouble dx=par->l_box/par->n_grid; - double *zarr_thr=my_calloc(nz,sizeof(double)); - unsigned long long *narr_thr=my_calloc(nz,sizeof(unsigned long long)); - double **norm_srcs_arr_thr=my_malloc(par->n_srcs*sizeof(double *)); - double **norm_imap_arr_thr=my_malloc(par->n_imap*sizeof(double *)); - double **norm_cstm_arr_thr=my_malloc(par->n_cstm*sizeof(double *)); - for(ipop=0;ipopn_srcs;ipop++) - norm_srcs_arr_thr[ipop]=my_calloc(nz,sizeof(double)); - for(ipop=0;ipopn_imap;ipop++) - norm_imap_arr_thr[ipop]=my_calloc(nz,sizeof(double)); - for(ipop=0;ipopn_cstm;ipop++) - norm_cstm_arr_thr[ipop]=my_calloc(nz,sizeof(double)); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long iz0=iz*((long)(2*(par->n_grid/2+1)*par->n_grid)); - flouble z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long iy0=iy*2*(par->n_grid/2+1); - flouble y0=(iy+0.5)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - long index=ix+iy0+iz0; - flouble x0=(ix+0.5)*dx-par->pos_obs[0]; - double r=sqrt(x0*x0+y0*y0+z0*z0); - double redshift=get_bg(par,r,BG_Z,0); - int ind_z=(int)(redshift*idz)+1; - if((ind_z>=0) && (ind_zgrid_dens[index]; - narr_thr[ind_z]++; - zarr_thr[ind_z]+=redshift; - for(ipop=0;ipopn_srcs;ipop++) - norm_srcs_arr_thr[ipop][ind_z]+=bias_model(d,get_bg(par,r,BG_BZ_SRCS,ipop)); - for(ipop=0;ipopn_imap;ipop++) - norm_imap_arr_thr[ipop][ind_z]+=bias_model(d,get_bg(par,r,BG_BZ_IMAP,ipop)); - for(ipop=0;ipopn_cstm;ipop++) - norm_cstm_arr_thr[ipop][ind_z]+=bias_model(d,get_bg(par,r,BG_BZ_CSTM,ipop)); - } - } - } - } //end omp for -#ifdef _HAVE_OMP -#pragma omp critical -#endif //_HAVE_OMP - { - for(iz=0;izn_srcs;ipop++) - norm_srcs_arr[ipop][iz]+=norm_srcs_arr_thr[ipop][iz]; - for(ipop=0;ipopn_imap;ipop++) - norm_imap_arr[ipop][iz]+=norm_imap_arr_thr[ipop][iz]; - for(ipop=0;ipopn_cstm;ipop++) - norm_cstm_arr[ipop][iz]+=norm_cstm_arr_thr[ipop][iz]; - } - } //end omp critical - - free(narr_thr); - free(zarr_thr); - for(ipop=0;ipopn_srcs;ipop++) - free(norm_srcs_arr_thr[ipop]); - free(norm_srcs_arr_thr); - for(ipop=0;ipopn_imap;ipop++) - free(norm_imap_arr_thr[ipop]); - free(norm_imap_arr_thr); - for(ipop=0;ipopn_cstm;ipop++) - free(norm_cstm_arr_thr[ipop]); - free(norm_cstm_arr_thr); - } //end omp parallel -} - -static void collect_density_normalization(ParamCoLoRe *par,int nz,double idz,double *zarr, - unsigned long long *narr, - double **norm_srcs_arr,double **norm_imap_arr, - double **norm_cstm_arr) -{ - // if(par->need_onions) - // collect_density_normalization_from_pixels(par,nz,idz,zarr,narr,norm_srcs_arr,norm_imap_arr); - // else - // collect_density_normalization_from_grid(par,nz,idz,zarr,narr,norm_srcs_arr,norm_imap_arr); - collect_density_normalization_from_grid(par,nz,idz,zarr,narr,norm_srcs_arr, - norm_imap_arr,norm_cstm_arr); -} - -//Computes sigma2(z) for physical density field -void compute_density_normalization(ParamCoLoRe *par) -{ - int nz,iz,ii,ipop; - double idz; - double *zarr,**norm_imap_arr,**norm_srcs_arr,**norm_cstm_arr; - unsigned long long *narr; - double zmax=get_bg(par,par->l_box*0.5,BG_Z,0); - gsl_spline *spline_norm_srcs[NPOP_MAX]; - gsl_interp_accel *intacc_srcs=gsl_interp_accel_alloc(); - gsl_spline *spline_norm_imap[NPOP_MAX]; - gsl_interp_accel *intacc_imap=gsl_interp_accel_alloc(); - gsl_spline *spline_norm_cstm[NPOP_MAX]; - gsl_interp_accel *intacc_cstm=gsl_interp_accel_alloc(); - - print_info("*** Computing normalization of density field\n"); - if(NodeThis==0) timer(0); - - nz=(int)(zmax/DZ_SIGMA)+2; - idz=(nz-2)/zmax; - - zarr=my_calloc(nz,sizeof(double)); - narr=my_calloc(nz,sizeof(unsigned long long)); - norm_srcs_arr=my_malloc(par->n_srcs*sizeof(double *)); - norm_imap_arr=my_malloc(par->n_imap*sizeof(double *)); - norm_cstm_arr=my_malloc(par->n_cstm*sizeof(double *)); - for(ipop=0;ipopn_srcs;ipop++) - norm_srcs_arr[ipop]=my_calloc(nz,sizeof(double)); - for(ipop=0;ipopn_imap;ipop++) - norm_imap_arr[ipop]=my_calloc(nz,sizeof(double)); - for(ipop=0;ipopn_cstm;ipop++) - norm_cstm_arr[ipop]=my_calloc(nz,sizeof(double)); - - collect_density_normalization(par,nz,idz,zarr,narr,norm_srcs_arr,norm_imap_arr,norm_cstm_arr); - -#ifdef _HAVE_MPI - MPI_Allreduce(MPI_IN_PLACE,narr,nz,MPI_UNSIGNED_LONG_LONG,MPI_SUM,MPI_COMM_WORLD); - for(ipop=0;ipopn_srcs;ipop++) - MPI_Allreduce(MPI_IN_PLACE,norm_srcs_arr[ipop],nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); - for(ipop=0;ipopn_imap;ipop++) - MPI_Allreduce(MPI_IN_PLACE,norm_imap_arr[ipop],nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); - for(ipop=0;ipopn_cstm;ipop++) - MPI_Allreduce(MPI_IN_PLACE,norm_cstm_arr[ipop],nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); - MPI_Allreduce(MPI_IN_PLACE,zarr,nz,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); -#endif //_HAVE_MPI - - for(iz=0;iz0) { - zarr[iz]/=narr[iz]; - for(ipop=0;ipopn_srcs;ipop++) - norm_srcs_arr[ipop][iz]=narr[iz]/norm_srcs_arr[ipop][iz]; - for(ipop=0;ipopn_imap;ipop++) - norm_imap_arr[ipop][iz]=narr[iz]/norm_imap_arr[ipop][iz]; - for(ipop=0;ipopn_cstm;ipop++) - norm_cstm_arr[ipop][iz]=narr[iz]/norm_cstm_arr[ipop][iz]; - } - } - - zarr[0]=0; - zarr[nz-1]=get_bg(par,0.5*par->l_box,BG_Z,0); - for(ipop=0;ipopn_srcs;ipop++) { - norm_srcs_arr[ipop][0]=norm_srcs_arr[ipop][1]; - norm_srcs_arr[ipop][nz-1]=norm_srcs_arr[ipop][nz-2]; - } - for(ipop=0;ipopn_imap;ipop++) { - norm_imap_arr[ipop][0]=norm_imap_arr[ipop][1]; - norm_imap_arr[ipop][nz-1]=norm_imap_arr[ipop][nz-2]; - } - for(ipop=0;ipopn_cstm;ipop++) { - norm_cstm_arr[ipop][0]=norm_cstm_arr[ipop][1]; - norm_cstm_arr[ipop][nz-1]=norm_cstm_arr[ipop][nz-2]; - } - - par->z0_norm=zarr[0]; - par->zf_norm=zarr[nz-1]; - for(ipop=0;ipopn_srcs;ipop++) { - par->norm_srcs_0[ipop]=norm_srcs_arr[ipop][0]; - par->norm_srcs_f[ipop]=norm_srcs_arr[ipop][nz-1]; - spline_norm_srcs[ipop]=gsl_spline_alloc(gsl_interp_linear,nz); - gsl_spline_init(spline_norm_srcs[ipop],zarr,norm_srcs_arr[ipop],nz); - par->srcs_norm_arr[ipop]=my_malloc(NA*sizeof(double)); - } - for(ipop=0;ipopn_imap;ipop++) { - par->norm_imap_0[ipop]=norm_imap_arr[ipop][0]; - par->norm_imap_f[ipop]=norm_imap_arr[ipop][nz-1]; - spline_norm_imap[ipop]=gsl_spline_alloc(gsl_interp_linear,nz); - gsl_spline_init(spline_norm_imap[ipop],zarr,norm_imap_arr[ipop],nz); - par->imap_norm_arr[ipop]=my_malloc(NA*sizeof(double)); - } - for(ipop=0;ipopn_cstm;ipop++) { - par->norm_cstm_0[ipop]=norm_cstm_arr[ipop][0]; - par->norm_cstm_f[ipop]=norm_cstm_arr[ipop][nz-1]; - spline_norm_cstm[ipop]=gsl_spline_alloc(gsl_interp_linear,nz); - gsl_spline_init(spline_norm_cstm[ipop],zarr,norm_cstm_arr[ipop],nz); - par->cstm_norm_arr[ipop]=my_malloc(NA*sizeof(double)); - } - - for(ii=0;iir_arr_r2z[ii],BG_Z,0); - for(ipop=0;ipopn_srcs;ipop++) { - double nm; - if(zz0_norm) - nm=par->norm_srcs_0[ipop]; - else if(z>=par->zf_norm) - nm=par->norm_srcs_f[ipop]; - else - nm=gsl_spline_eval(spline_norm_srcs[ipop],z,intacc_srcs); - par->srcs_norm_arr[ipop][ii]=nm; - } - for(ipop=0;ipopn_imap;ipop++) { - double nm; - if(zz0_norm) - nm=par->norm_imap_0[ipop]; - else if(z>=par->zf_norm) - nm=par->norm_imap_f[ipop]; - else - nm=gsl_spline_eval(spline_norm_imap[ipop],z,intacc_imap); - par->imap_norm_arr[ipop][ii]=nm; - } - for(ipop=0;ipopn_cstm;ipop++) { - double nm; - if(zz0_norm) - nm=par->norm_cstm_0[ipop]; - else if(z>=par->zf_norm) - nm=par->norm_cstm_f[ipop]; - else - nm=gsl_spline_eval(spline_norm_cstm[ipop],z,intacc_cstm); - par->cstm_norm_arr[ipop][ii]=nm; - } - } - -#ifdef _DEBUG - for(iz=0;izn_srcs;ipop++) - print_info("=%.3lE, ",ipop,get_bg(par,rz,BG_NORM_SRCS,ipop)); - for(ipop=0;ipopn_imap;ipop++) - print_info("=%.3lE, ",ipop,get_bg(par,rz,BG_NORM_IMAP,ipop)); - for(ipop=0;ipopn_cstm;ipop++) - print_info("=%.3lE, ",ipop,get_bg(par,rz,BG_NORM_CSTM,ipop)); - print_info("%011llu\n",narr[iz]); - } -#endif //_DEBUG - if(NodeThis==0) timer(2); - print_info("\n"); - - free(zarr); - free(narr); - for(ipop=0;ipopn_srcs;ipop++) { - free(norm_srcs_arr[ipop]); - gsl_spline_free(spline_norm_srcs[ipop]); - } - free(norm_srcs_arr); - gsl_interp_accel_free(intacc_srcs); - for(ipop=0;ipopn_imap;ipop++) { - free(norm_imap_arr[ipop]); - gsl_spline_free(spline_norm_imap[ipop]); - } - free(norm_imap_arr); - gsl_interp_accel_free(intacc_imap); - for(ipop=0;ipopn_cstm;ipop++) { - free(norm_cstm_arr[ipop]); - gsl_spline_free(spline_norm_cstm[ipop]); - } - free(norm_cstm_arr); - gsl_interp_accel_free(intacc_cstm); -} diff --git a/src/.ipynb_checkpoints/fftlog-checkpoint.c b/src/.ipynb_checkpoints/fftlog-checkpoint.c deleted file mode 100644 index 5f93749..0000000 --- a/src/.ipynb_checkpoints/fftlog-checkpoint.c +++ /dev/null @@ -1,157 +0,0 @@ -#include -#ifndef M_PI - #define M_PI 3.14159265358979323846 -#endif -#include -#include -#include "fftlog.h" - -/* Computes the Gamma function using the Lanczos approximation */ -static double complex gamma_fftlog(double complex z) { - /* Lanczos coefficients for g = 7 */ - static double p[] = { - 0.99999999999980993227684700473478, - 676.520368121885098567009190444019, - -1259.13921672240287047156078755283, - 771.3234287776530788486528258894, - -176.61502916214059906584551354, - 12.507343278686904814458936853, - -0.13857109526572011689554707, - 9.984369578019570859563e-6, - 1.50563273514931155834e-7 - }; - - if(creal(z) < 0.5) - return M_PI / (sin(M_PI*z)*gamma_fftlog(1. - z)); - z -= 1; - double complex x = p[0]; - for(int n = 1; n < 9; n++) - x += p[n] / (z + (double)(n)); - double complex t = z + 7.5; - return sqrt(2*M_PI) * cpow(t, z+0.5) * cexp(-t) * x; -} - -static double complex polar (double r, double phi) { - return (r*cos(phi) +I*(r*sin(phi))); -} - -static double complex lngamma_fftlog(double complex z) { - return clog(gamma_fftlog(z)); -} - - -static void lngamma_4(double x, double y, double* lnr, double* arg) { - double complex w = lngamma_fftlog(x+y*I); - if(lnr) *lnr = creal(w); - if(arg) *arg = cimag(w); -} - -static double goodkr(int N, double mu, double q, double L, double kr) { - double xp = (mu+1+q)/2; - double xm = (mu+1-q)/2; - double y = M_PI*N/(2*L); - double lnr, argm, argp; - lngamma_4(xp, y, &lnr, &argp); - lngamma_4(xm, y, &lnr, &argm); - double arg = log(2/kr) * N/L + (argp + argm)/M_PI; - double iarg = round(arg); - if(arg != iarg) - kr *= exp((arg - iarg)*L/N); - return kr; -} - -void compute_u_coefficients(int N, double mu, double q, double L, double kcrc, double complex u[]) { - double y = M_PI/L; - double k0r0 = kcrc * exp(-L); - double t = -2*y*log(k0r0/2); - - if(q == 0) { - double x = (mu+1)/2; - double lnr, phi; - for(int m = 0; m <= N/2; m++) { - lngamma_4(x, m*y, &lnr, &phi); - u[m] = polar(1.0,m*t + 2*phi); - } - } - else { - double xp = (mu+1+q)/2; - double xm = (mu+1-q)/2; - double lnrp, phip, lnrm, phim; - for(int m = 0; m <= N/2; m++) { - lngamma_4(xp, m*y, &lnrp, &phip); - lngamma_4(xm, m*y, &lnrm, &phim); - u[m] = polar(exp(q*log(2) + lnrp - lnrm), m*t + phip - phim); - } - } - - for(int m = N/2+1; m < N; m++) - u[m] = conj(u[N-m]); - if((N % 2) == 0) - u[N/2] = (creal(u[N/2]) + I*0.0); -} - -void fht(int N, const double r[], const double complex a[], double k[], double complex b[], double mu, - double q, double kcrc, int noring, double complex* u) -{ - double L = log(r[N-1]/r[0]) * N/(N-1.); - double complex* ulocal = NULL; - if(u == NULL) { - if(noring) - kcrc = goodkr(N, mu, q, L, kcrc); - ulocal = malloc (sizeof(complex double)*N); - compute_u_coefficients(N, mu, q, L, kcrc, ulocal); - u = ulocal; - } - - /* Compute the convolution b = a*u using FFTs */ - fftw_plan forward_plan = fftw_plan_dft_1d(N, (fftw_complex*) a, (fftw_complex*) b, -1, FFTW_ESTIMATE); - fftw_plan reverse_plan = fftw_plan_dft_1d(N, (fftw_complex*) b, (fftw_complex*) b, +1, FFTW_ESTIMATE); - fftw_execute(forward_plan); - for(int m = 0; m < N; m++) - b[m] *= u[m] / (double)(N); // divide by N since FFTW doesn't normalize the inverse FFT - fftw_execute(reverse_plan); - fftw_destroy_plan(forward_plan); - fftw_destroy_plan(reverse_plan); - - /* Reverse b array */ - double complex tmp; - for(int n = 0; n < N/2; n++) { - tmp = b[n]; - b[n] = b[N-n-1]; - b[N-n-1] = tmp; - } - - /* Compute k's corresponding to input r's */ - double k0r0 = kcrc * exp(-L); - k[0] = k0r0/r[0]; - for(int n = 1; n < N; n++) - k[n] = k[0] * exp(n*L/N); - - free(ulocal); -} - -void fftlog_ComputeXiLM(int l, int m, int N, const double k[], const double pk[], double r[], double xi[]) { - double complex* a = malloc(sizeof(complex double)*N); - double complex* b = malloc(sizeof(complex double)*N); - - for(int i = 0; i < N; i++) - a[i] = pow(k[i], m - 0.5) * pk[i]; - fht(N, k, a, r, b, l + 0.5, 0, 1, 1, NULL); - for(int i = 0; i < N; i++) - xi[i] = creal(pow(2*M_PI*r[i], -1.5) * b[i]); - - free(a); - free(b); -} - -void pk2xi(int N, const double k[], const double pk[], double r[], double xi[]) { - fftlog_ComputeXiLM(0, 2, N, k, pk, r, xi); -} - -void xi2pk(int N, const double r[], const double xi[], double k[], double pk[]) { - static const double TwoPiCubed = 8*M_PI*M_PI*M_PI; - fftlog_ComputeXiLM(0, 2, N, r, xi, k, pk); - for(int j = 0; j < N; j++) - pk[j] *= TwoPiCubed; -} - diff --git a/src/.ipynb_checkpoints/fourier-checkpoint.c b/src/.ipynb_checkpoints/fourier-checkpoint.c deleted file mode 100644 index aea1cef..0000000 --- a/src/.ipynb_checkpoints/fourier-checkpoint.c +++ /dev/null @@ -1,423 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -static void compute_sigma_dens(ParamCoLoRe *par) -{ - double mean_gauss=0; - // double s2_save=par->sigma2_gauss; - par->sigma2_gauss=0; - - //Compute Gaussian variance -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,mean_gauss) -#endif //_HAVE_OMP - { - int iz; - double sigma2_thr=0; - double mean_thr=0; - long ng_tot=par->n_grid*((long)(par->n_grid*par->n_grid)); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long iz0=iz*((long)(2*(par->n_grid/2+1)*par->n_grid)); - for(iy=0;iyn_grid;iy++) { - int ix; - long iy0=iy*2*(par->n_grid/2+1); - for(ix=0;ixn_grid;ix++) { - long index=ix+iy0+iz0; - sigma2_thr+=par->grid_dens[index]*par->grid_dens[index]; - mean_thr+=par->grid_dens[index]; - } - } - } //end omp for -#ifdef _HAVE_OMP -#pragma omp critical -#endif //_HAVE_OMP - { - mean_gauss+=mean_thr/ng_tot; - par->sigma2_gauss+=sigma2_thr/ng_tot; - } //end omp critical - } //end omp parallel - -#ifdef _HAVE_MPI - double sigma2_gathered=0,mean_gathered=0; - - MPI_Allreduce(&(par->sigma2_gauss),&sigma2_gathered,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); - MPI_Allreduce(&mean_gauss,&mean_gathered,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); - mean_gauss=mean_gathered; - par->sigma2_gauss=sigma2_gathered; -#endif //_HAVE_MPI - - par->sigma2_gauss-=mean_gauss*mean_gauss; - print_info(" =%.3lE, =%.3lE\n",mean_gauss,sqrt(par->sigma2_gauss)); - // if(par->need_onions) - // par->sigma2_gauss=s2_save; -} - -void fftw_wrap_c2r(int ng,dftw_complex *pin,flouble *pout) -{ -#ifdef _SPREC - fftwf_plan plan_ft; -#ifdef _HAVE_MPI - plan_ft=fftwf_mpi_plan_dft_c2r_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); -#else //_HAVE_MPI - plan_ft=fftwf_plan_dft_c2r_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); -#endif //_HAVE_MPI - fftwf_execute(plan_ft); - fftwf_destroy_plan(plan_ft); -#else //_SPREC - fftw_plan plan_ft; -#ifdef _HAVE_MPI - plan_ft=fftw_mpi_plan_dft_c2r_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); -#else //_HAVE_MPI - plan_ft=fftw_plan_dft_c2r_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); -#endif //_HAVE_MPI - fftw_execute(plan_ft); - fftw_destroy_plan(plan_ft); -#endif //_SPREC -} - -void fftw_wrap_r2c(int ng,flouble *pin,dftw_complex *pout) -{ -#ifdef _SPREC - fftwf_plan plan_ft; -#ifdef _HAVE_MPI - plan_ft=fftwf_mpi_plan_dft_r2c_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); -#else //_HAVE_MPI - plan_ft=fftwf_plan_dft_r2c_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); -#endif //_HAVE_MPI - fftwf_execute(plan_ft); - fftwf_destroy_plan(plan_ft); -#else //_SPREC - fftw_plan plan_ft; -#ifdef _HAVE_MPI - plan_ft=fftw_mpi_plan_dft_r2c_3d(ng,ng,ng,pin,pout,MPI_COMM_WORLD,FFTW_ESTIMATE); -#else //_HAVE_MPI - plan_ft=fftw_plan_dft_r2c_3d(ng,ng,ng,pin,pout,FFTW_ESTIMATE); -#endif //_HAVE_MPI - fftw_execute(plan_ft); - fftw_destroy_plan(plan_ft); -#endif //_SPREC -} - -void init_fftw(ParamCoLoRe *par) -{ - //Set FFTW domain decomposition - par->nz_all =my_calloc(NNodes,sizeof(int)); - par->iz0_all=my_calloc(NNodes,sizeof(int)); - -#ifdef _HAVE_MPI - ptrdiff_t nz,iz0; - - //Initialize OpenMP fftw (if possible) -#ifdef _HAVE_OMP - if(MPIThreadsOK) { - int stat; -#ifdef _SPREC - stat=fftwf_init_threads(); -#else //_SPREC - stat=fftw_init_threads(); -#endif //_SPREC - if(!stat) { - fprintf(stderr,"Couldn't initialize FFTW threads \n"); - exit(1); - } - } -#endif //_HAVE_OMP - - //Initialize MPI fftw -#ifdef _SPREC - fftwf_mpi_init(); -#else //_SPREC - fftw_mpi_init(); -#endif //_SPREC - - //Plan OpenMP fftw (if possible) -#ifdef _HAVE_OMP - if(MPIThreadsOK) { -#ifdef _SPREC - fftwf_plan_with_nthreads(omp_get_max_threads()); -#else //_SPREC - fftw_plan_with_nthreads(omp_get_max_threads()); -#endif //_SPREC - } -#endif //_HAVE_OMP - - //Get MPI FFT bounds -#ifdef _SPREC - fftwf_mpi_local_size_3d(par->n_grid,par->n_grid,par->n_grid/2+1,MPI_COMM_WORLD,&nz,&iz0); -#else //_SPREC - fftw_mpi_local_size_3d(par->n_grid,par->n_grid,par->n_grid/2+1,MPI_COMM_WORLD,&nz,&iz0); -#endif //_SPREC - par->nz_here=nz; - par->iz0_here=iz0; - - MPI_Allreduce(&(par->nz_here),&(par->nz_max),1,MPI_INT,MPI_MAX,MPI_COMM_WORLD); - MPI_Allgather(&(par->nz_here),1,MPI_INT,par->nz_all,1,MPI_INT,MPI_COMM_WORLD); - MPI_Allgather(&(par->iz0_here),1,MPI_INT,par->iz0_all,1,MPI_INT,MPI_COMM_WORLD); - -#else //_HAVE_MPI - -#ifdef _HAVE_OMP - int stat; -#ifdef _SPREC - stat=fftwf_init_threads(); -#else //_SPREC - stat=fftw_init_threads(); -#endif //_SPREC - if(!stat) { - fprintf(stderr,"Couldn't initialize FFTW threads \n"); - exit(1); - } -#ifdef _SPREC - fftwf_plan_with_nthreads(omp_get_max_threads()); -#else //_SPREC - fftw_plan_with_nthreads(omp_get_max_threads()); -#endif //_SPREC -#endif //_HAVE_OMP - - par->nz_here=par->n_grid; - par->iz0_here=0; - par->nz_max=par->nz_here; - par->nz_all[0]=par->nz_here; - par->iz0_all[0]=par->iz0_here; -#endif //_HAVE_MPI -} - -void allocate_fftw(ParamCoLoRe *par) -{ - //Allocate all memory for grids - ptrdiff_t dsize=par->nz_max*((long)(par->n_grid*(par->n_grid/2+1))); - -#ifdef _SPREC - par->grid_dens_f=fftwf_alloc_complex(dsize); -#else //_SPREC - par->grid_dens_f=fftw_alloc_complex(dsize); -#endif //_SPREC - if(par->grid_dens_f==NULL) - report_error(1,"Ran out of memory\n"); - par->grid_dens=(flouble *)(par->grid_dens_f); - -#ifdef _SPREC - par->grid_npot_f=fftwf_alloc_complex(dsize+2*par->n_grid*(par->n_grid/2+1)); -#else //_SPREC - par->grid_npot_f= fftw_alloc_complex(dsize+2*par->n_grid*(par->n_grid/2+1)); -#endif //_SPREC - if(par->grid_npot_f==NULL) - report_error(1,"Ran out of memory\n"); - par->grid_npot=(flouble *)(par->grid_npot_f); - -#ifdef _HAVE_MPI - par->slice_left =&(par->grid_npot[2*dsize]); - par->slice_right=&(par->grid_npot[2*(dsize+par->n_grid*(par->n_grid/2+1))]); -#endif //_HAVE_MPI -} - -void end_fftw(ParamCoLoRe *par) -{ -#ifdef _SPREC - if(par->grid_dens_f!=NULL) - fftwf_free(par->grid_dens_f); - if(par->grid_npot_f!=NULL) - fftwf_free(par->grid_npot_f); -#else //_SPREC - if(par->grid_dens_f!=NULL) - fftw_free(par->grid_dens_f); - if(par->grid_npot_f!=NULL) - fftw_free(par->grid_npot_f); -#endif //_SPREC - -#ifdef _HAVE_MPI - -#ifdef _HAVE_OMP - if(MPIThreadsOK) { -#ifdef _SPREC - fftwf_cleanup_threads(); -#else //_SPREC - fftw_cleanup_threads(); -#endif //_SPREC - } -#endif //_HAVE_OMP - -#ifdef _SPREC - fftwf_mpi_cleanup(); -#else //_SPREC - fftw_mpi_cleanup(); -#endif //_SPREC - -#else //_HAVE_MPI - -#ifdef _HAVE_OMP -#ifdef _SPREC - fftwf_cleanup_threads(); -#else //_SPREC - fftw_cleanup_threads(); -#endif //_SPREC -#endif //_HAVE_OMP - -#endif //_HAVE_MPI -} - -static void create_grids_fourier(ParamCoLoRe *par) -{ - ////// - // Generates a random realization of the delta_k - // from the linear P_k. - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,IThread0) -#endif //_HAVE_OMP - { - int ii; - double dk=2*M_PI/par->l_box; - double idk3=1./(dk*dk*dk); -#ifdef _HAVE_OMP - int ithr=omp_get_thread_num(); -#else //_HAVE_OMP - int ithr=0; -#endif //_HAVE_OMP - unsigned int seed_thr=par->seed_rng+IThread0+ithr; - gsl_rng *rng_thr=init_rng(seed_thr); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iinz_here;ii++) { - int jj,ii_true; - double kz; - ii_true=par->iz0_here+ii; - if(2*ii_true<=par->n_grid) - kz=ii_true*dk; - else - kz=-(par->n_grid-ii_true)*dk; - for(jj=0;jjn_grid;jj++) { - int kk; - double ky; - if(2*jj<=par->n_grid) - ky=jj*dk; - else - ky=-(par->n_grid-jj)*dk; - for(kk=0;kk<=par->n_grid/2;kk++) { - double kx; - double k_mod2; - long index=kk+(par->n_grid/2+1)*((long)(jj+par->n_grid*ii)); //Grid index for +k - double delta_mod,delta_phase; - if(2*kk<=par->n_grid) - kx=kk*dk; - else - kx=-(par->n_grid-kk)*dk; //This should never happen - - k_mod2=kx*kx+ky*ky+kz*kz; - - if(k_mod2<=0) { - par->grid_dens_f[index]=0; - par->grid_npot_f[index]=0; - } - else { - double lgk=0.5*log10(k_mod2); - double sigma2=pk_linear0(par,lgk)*idk3; - rng_delta_gauss(&delta_mod,&delta_phase,rng_thr,sigma2); - par->grid_dens_f[index]=delta_mod*cexp(I*delta_phase); - par->grid_npot_f[index]=-par->prefac_lensing*par->grid_dens_f[index]/k_mod2; - if(par->do_smoothing) { - double sm=exp(-0.5*par->r2_smooth*k_mod2); - par->grid_dens_f[index]*=sm; - if(par->smooth_potential) - par->grid_npot_f[index]*=sm; - } - } - } - } - } - end_rng(rng_thr); - } -} - -void create_cartesian_fields(ParamCoLoRe *par) -{ - ////// - // Creates a realization of the gaussian density - // contrast field from the linear P_k - - long n_grid_tot=2*(par->n_grid/2+1)*((long)(par->n_grid*par->nz_here)); - print_info("*** Creating Gaussian density field \n"); - - print_info("Creating Fourier-space density and Newtonian potential \n"); - if(NodeThis==0) timer(0); - create_grids_fourier(par); - if(NodeThis==0) timer(2); - - print_info("Transforming density and Newtonian potential\n"); - if(NodeThis==0) timer(0); - fftw_wrap_c2r(par->n_grid,par->grid_dens_f,par->grid_dens); - fftw_wrap_c2r(par->n_grid,par->grid_npot_f,par->grid_npot); - if(NodeThis==0) timer(2); - - print_info("Normalizing density and Newtonian potential \n"); - if(NodeThis==0) timer(0); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(n_grid_tot,par) -#endif //_HAVE_OMP - { - long ii; - double norm=pow(sqrt(2*M_PI)/par->l_box,3); - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iigrid_dens[ii]*=norm; - par->grid_npot[ii]*=norm; - } - }//end omp parallel - if(NodeThis==0) timer(2); - - long slice_size=2*(par->n_grid/2+1)*par->n_grid; -#ifdef _HAVE_MPI - MPI_Status stat; - - //Pass rightmost slice to right node and receive left slice from left node - MPI_Sendrecv(&(par->grid_npot[(par->nz_here-1)*slice_size]),slice_size,FLOUBLE_MPI,NodeRight,1, - par->slice_left,slice_size,FLOUBLE_MPI,NodeLeft,1,MPI_COMM_WORLD,&stat); - //Pass leftmost slice to left node and receive right slice from right node - MPI_Sendrecv(par->grid_npot,slice_size,FLOUBLE_MPI,NodeLeft,2, - par->slice_right,slice_size,FLOUBLE_MPI,NodeRight,2,MPI_COMM_WORLD,&stat); -#else //_HAVE_MPI - par->slice_left=&(par->grid_npot[(par->n_grid-1)*slice_size]); - par->slice_right=par->grid_npot; -#endif //_HAVE_MPI - - compute_sigma_dens(par); - - print_info("\n"); - - //Output density field if necessary - if(par->output_density) - write_density_grid(par,"gaussian"); -} diff --git a/src/.ipynb_checkpoints/healpix_extra-checkpoint.c b/src/.ipynb_checkpoints/healpix_extra-checkpoint.c deleted file mode 100644 index f17fd97..0000000 --- a/src/.ipynb_checkpoints/healpix_extra-checkpoint.c +++ /dev/null @@ -1,885 +0,0 @@ -#include "common.h" - -//HE_IO -void he_write_healpix_map(flouble **tmap,int nfields,long nside,char *fname,int isnest) -{ - fitsfile *fptr; - int ii,status=0; - char **ttype,**tform,**tunit; - float *map_dum=my_malloc(nside2npix(nside)*sizeof(float)); - - ttype=my_malloc(nfields*sizeof(char *)); - tform=my_malloc(nfields*sizeof(char *)); - tunit=my_malloc(nfields*sizeof(char *)); - for(ii=0;ii=0) - return (v1=0) ? v : v+v2; } - -long he_nside2npix(long nside) -{ - return 12*nside*nside; -} - -double he_pixel_area(int nside) -{ - return M_PI/(3*nside*nside); -} - -static const double twopi=6.283185307179586476925286766559005768394; -static const double twothird=2.0/3.0; -static const double inv_halfpi=0.6366197723675813430755350534900574; -long he_ang2pix(long nside,double cth,double phi) -{ - double ctha=fabs(cth); - double tt=fmodulo(phi,twopi)*inv_halfpi; /* in [0,4) */ - - if (ctha<=twothird) {/* Equatorial region */ - double temp1=nside*(0.5+tt); - double temp2=nside*cth*0.75; - int jp=(int)(temp1-temp2); /* index of ascending edge line */ - int jm=(int)(temp1+temp2); /* index of descending edge line */ - int ir=nside+1+jp-jm; /* ring number counted from cth=2/3 */ /* in {1,2n+1} */ - int kshift=1-(ir&1); /* kshift=1 if ir even, 0 otherwise */ - int ip=(jp+jm-nside+kshift+1)/2; /* in {0,4n-1} */ - ip=imodulo(ip,4*nside); - - return nside*(nside-1)*2 + (ir-1)*4*nside + ip; - } - else { /* North & South polar caps */ - double tp=tt-(int)(tt); - double tmp=nside*sqrt(3*(1-ctha)); - int jp=(int)(tp*tmp); /* increasing edge line index */ - int jm=(int)((1.0-tp)*tmp); /* decreasing edge line index */ - int ir=jp+jm+1; /* ring number counted from the closest pole */ - int ip=(int)(tt*ir); /* in {0,4*ir-1} */ - ip = imodulo(ip,4*ir); - - if (cth>0) - return 2*ir*(ir-1)+ip; - else - return 12*nside*nside-2*ir*(ir+1)+ip; - } -} - -int he_ring_num(long nside,double z) -{ - //Returns ring index for normalized height z - int iring; - - iring=(int)(nside*(2-1.5*z)+0.5); - if(z>0.66666666) { - iring=(int)(nside*sqrt(3*(1-z))+0.5); - if(iring==0) iring=1; - } - - if(z<-0.66666666) { - iring=(int)(nside*sqrt(3*(1+z))+0.5); - if(iring==0) iring=1; - iring=4*nside-iring; - } - - return iring; -} - -static void get_ring_limits(long nside,int iz,long *ip_lo,long *ip_hi) -{ - long ir; - long ipix1,ipix2; - long npix=12*nside*nside; - long ncap=2*nside*(nside-1); - - if((iz>=nside)&&(iz<=3*nside)) { //eqt - ir=iz-nside+1; - ipix1=ncap+4*nside*(ir-1); - ipix2=ipix1+4*nside-1; - } - else { - if(izM_PI)|| - (theta2<0)||(theta2>M_PI)) { - report_error(1,"wrong strip boundaries\n"); - } - - irmin=he_ring_num(nside,z_hi); - irmax=he_ring_num(nside,z_lo); - - //Count number of pixels in strip - int iz; - long npix_in_strip=0; - for(iz=irmin;iz<=irmax;iz++) { - long ipix1,ipix2; - get_ring_limits(nside,iz,&ipix1,&ipix2); - npix_in_strip+=ipix2-ipix1+1; - } - *npix_strip=npix_in_strip; - pixlist=my_malloc(npix_in_strip*sizeof(long)); - - //Count number of pixels in strip - long i_list=0; - for(iz=irmin;iz<=irmax;iz++) { - long ipix1,ipix2,ip; - get_ring_limits(nside,iz,&ipix1,&ipix2); - for(ip=ipix1;ip<=ipix2;ip++) { - pixlist[i_list]=ip; - i_list++; - } - } - - return pixlist; -} - -void he_ring2nest_inplace(flouble *map_in,long nside) -{ - long npix=12*nside*nside; - flouble *map_out=my_malloc(npix*sizeof(flouble)); - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(map_in,nside,npix,map_out) -#endif //_HAVE_OMP - { - long ip; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ip=0;ipnside_out) { - long ii; - long np_ratio=npix_in/npix_out; - double i_np_ratio=1./((double)np_ratio); - - for(ii=0;ii0) - return l+m*lmax-(m*(m-1))/2; - else - return l; -} - -static void sht_wrapper(int spin,int lmax,int nside,int ntrans,flouble **maps,fcomplex **alms,int alm2map) -{ - double time=0; - sharp_alm_info *alm_info; - sharp_geom_info *geom_info; - - sharp_make_triangular_alm_info(lmax,lmax,1,&alm_info); - sharp_make_weighted_healpix_geom_info(nside,1,NULL,&geom_info); - sharp_execute(alm2map,spin,alms,maps,geom_info,alm_info,ntrans,SHT_TYPE,&time,NULL); - sharp_destroy_geom_info(geom_info); - sharp_destroy_alm_info(alm_info); - // printf(" Took %lf s according to libsharp\n",time); -} - -void he_alm2map(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms) -{ - int nbatches,nodd,itrans; - nbatches=ntrans/HE_MAX_SHT; - nodd=ntrans%HE_MAX_SHT; - - for(itrans=0;itrans0) - sht_wrapper(0,lmax,nside,nodd,&(maps[nbatches*HE_MAX_SHT]),&(alms[nbatches*HE_MAX_SHT]),SHARP_ALM2MAP); -} - -void he_map2alm(int nside,int lmax,int ntrans,flouble **maps,fcomplex **alms) -{ - int nbatches,nodd,itrans; - nbatches=ntrans/HE_MAX_SHT; - nodd=ntrans%HE_MAX_SHT; - - for(itrans=0;itrans0) - sht_wrapper(0,lmax,nside,nodd,&(maps[nbatches*HE_MAX_SHT]),&(alms[nbatches*HE_MAX_SHT]),SHARP_MAP2ALM); -} - -void he_alm2cl(fcomplex **alms_1,fcomplex **alms_2, - int nmaps_1,int nmaps_2, - int pol_1,int pol_2, - flouble **cls,int lmax) -{ - int i1,index_cl; - - index_cl=0; - for(i1=0;i13*nside-1) - lmax_here=3*nside-1; - alms=my_malloc(he_nalms(lmax_here)*sizeof(fcomplex)); - - int ll; - for(ll=0;ll<=lmax_here;ll++) { - int mm; - flouble sigma=sqrt(0.5*cl[ll]); - double r1,r2; - rng_gauss(rng,&r1,&r2); - alms[he_indexlm(ll,0,lmax_here)]=(fcomplex)(M_SQRT2*sigma*r1); - - for(mm=1;mm<=ll;mm++) { - rng_gauss(rng,&r1,&r2); - alms[he_indexlm(ll,mm,lmax_here)]=(fcomplex)(sigma*(r1+I*r2)); - } - } - he_alm2map(nside,lmax_here,1,&map,&alms); - free(alms); - end_rng(rng); - - return map; -} - - -#ifdef _WITH_NEEDLET -//HE_NT -static double func_fx(double x,void *pars) -{ - return exp(-1./(1.-x*x)); -} - -static double func_psix(double x,gsl_integration_workspace *w,const gsl_function *f) -{ - double result,eresult; - gsl_integration_qag(f,-1,x,0,HE_NL_INTPREC,1000,GSL_INTEG_GAUSS61, - w,&result,&eresult); - - return result*HE_NORM_FT; -} - -static double func_phix(double x,double invB, - gsl_integration_workspace *w,const gsl_function *f) -{ - if(x<0) - report_error(1,"Something went wrong"); - else if(x<=invB) - return 1.; - else if(x<=1) - return func_psix(1-2.*(x-invB)/(1-invB),w,f); - else - return 0.; - - return -1.; -} - -void he_nt_end(HE_nt_param *par) -{ - int j; - - gsl_spline_free(par->b_spline); - gsl_interp_accel_free(par->b_intacc); - free(par->nside_arr); - free(par->lmax_arr); - for(j=0;jnj;j++) - free(par->b_arr[j]); - free(par->b_arr); - free(par); -} - -HE_nt_param *he_nt_init(flouble b_nt,int nside0) -{ - HE_nt_param *par=my_malloc(sizeof(HE_nt_param)); - par->b=b_nt; - par->inv_b=1./b_nt; - par->b_spline=gsl_spline_alloc(gsl_interp_cspline,HE_NBAND_NX); - par->b_intacc=gsl_interp_accel_alloc(); - par->nside0=nside0; - - int ii; - gsl_function F; - gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000); - double *xarr=my_malloc(HE_NBAND_NX*sizeof(double)); - double *barr=my_malloc(HE_NBAND_NX*sizeof(double)); - F.function=&func_fx; - F.params=NULL; - for(ii=0;iib_spline,xarr,barr,HE_NBAND_NX); - gsl_integration_workspace_free(w); - free(xarr); - free(barr); - - double lmax=3*nside0-1; - double djmax=log(lmax)/log(b_nt); - int jmax=(int)(djmax)+1; - par->nj=jmax+1; - par->nside_arr=my_malloc(par->nj*sizeof(int)); - par->lmax_arr=my_malloc(par->nj*sizeof(int)); - for(ii=0;iinj;ii++) { - double dlmx=pow(par->b,ii+1); - // double dlmn=pow(par->b,ii-1); - int lmx=(int)(dlmx)+1; - int ns=pow(2,(int)(log((double)lmx)/log(2.))+1); - par->nside_arr[ii]=MAX((MIN(ns,par->nside0)),HE_NT_NSIDE_MIN); - par->lmax_arr[ii]=3*par->nside_arr[ii]-1; - } - - par->b_arr=my_malloc(par->nj*sizeof(flouble *)); - for(ii=0;iinj;ii++) { - par->b_arr[ii]=my_calloc(3*nside0,sizeof(flouble)); - he_nt_get_window(par,ii,par->b_arr[ii]); - } - - int lmx0=(int)(par->b); - for(ii=0;ii<=lmx0;ii++) { - flouble b1=par->b_arr[0][ii]; - flouble b2=par->b_arr[1][ii]; - flouble h_here=b1*b1+b2*b2; - if(h_here<1) - par->b_arr[0][ii]=sqrt(1-b2*b2); - } - - return par; -} - -flouble ***he_alloc_needlet(HE_nt_param *par,int pol) -{ - int ii,nmaps; - flouble ***nt=my_malloc(par->nj*sizeof(flouble **)); - if(pol) - nmaps=3; - else - nmaps=1; - - for(ii=0;iinj;ii++) { - int imap; - long ns=par->nside_arr[ii]; - - nt[ii]=my_malloc(nmaps*sizeof(flouble *)); - for(imap=0;imapnj;ii++) { - int imap; - for(imap=0;imaplmax_arr[j]; - flouble bfac=1./pow(par->b,j); - - for(l=0;l<=lmx;l++) { - double x=(double)l*bfac; - if((xinv_b)||(x>par->b)) - b[l]=0; - else - b[l]=gsl_spline_eval(par->b_spline,x,par->b_intacc); - } -} - -fcomplex **he_needlet2map(HE_nt_param *par,flouble **map,flouble ***nt, - int return_alm,int pol,int qu_in,int qu_out) -{ - int j,nmaps; - fcomplex **alm,**alm_dum; - int l_max=3*par->nside0-1; - long n_alms=he_nalms(l_max); - - //Figure out spin - if(pol) - nmaps=3; - else - nmaps=1; - - //Allocate alms - alm=my_malloc(nmaps*sizeof(fcomplex *)); - alm_dum=my_malloc(nmaps*sizeof(fcomplex *)); - for(j=0;jnj;j++) { - int mm; - int lmx=par->lmax_arr[j]; - int imap; - - //Compute alm's for j-th needlet - sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],1,nt[j],alm_dum,SHARP_MAP2ALM); - if(pol) { - if(qu_in) - sht_wrapper(2,par->lmax_arr[j],par->nside_arr[j],1,&(nt[j][1]),&(alm_dum[1]),SHARP_MAP2ALM); - else - sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],2,&(nt[j][1]),&(alm_dum[1]),SHARP_MAP2ALM); - } - //Loop over spin components - for(imap=0;imapb_arr[j][ll]*alm_dum[imap][index]; - } - } - } - } - - //Transform total alm back to map - sht_wrapper(0,l_max,par->nside0,1,map,alm,SHARP_ALM2MAP); - if(pol) { - if(qu_out) - sht_wrapper(2,l_max,par->nside0,1,&(map[1]),&(alm[1]),SHARP_ALM2MAP); - else - sht_wrapper(0,l_max,par->nside0,2,&(map[1]),&(alm[1]),SHARP_ALM2MAP); - } - - if(!return_alm) { - for(j=0;jnside0-1; - long n_alms=he_nalms(l_max); - - //Figure out spin - if(pol) - nmaps=3; - else - nmaps=1; - - //Allocate alms - alm=my_malloc(nmaps*sizeof(fcomplex *)); - alm_dum=my_malloc(nmaps*sizeof(fcomplex *)); - for(j=0;jnside0,1,map,alm,SHARP_MAP2ALM); - if(qu_in) - sht_wrapper(2,l_max,par->nside0,1,&(map[1]),&(alm[1]),SHARP_MAP2ALM); - else - sht_wrapper(0,l_max,par->nside0,2,&(map[1]),&(alm[1]),SHARP_MAP2ALM); - - //Iterate over scales - for(j=0;jnj;j++) { - int mm,imap; - int lmx=par->lmax_arr[j]; - - //Loop over spin components - for(imap=0;imapb_arr[j][ll]*alm[imap][index0]; - } - } - } - - //SHT^-1 - sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],1,nt[j],alm_dum,SHARP_ALM2MAP); - if(qu_out) - sht_wrapper(2,par->lmax_arr[j],par->nside_arr[j],1,&(nt[j][1]),&(alm_dum[1]),SHARP_ALM2MAP); - else - sht_wrapper(0,par->lmax_arr[j],par->nside_arr[j],2,&(nt[j][1]),&(alm_dum[1]),SHARP_ALM2MAP); - } - - if(!return_alm) { - for(j=0;j. // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -static inline void cart2sph(double x,double y,double z,double *r,double *cth,double *phi) -{ - *r=sqrt(x*x+y*y+z*z); - - if((*r)==0) { - *cth=1; - *phi=0; - } - else { - double xn=x/(*r); - double yn=y/(*r); - - *cth=z/(*r); - *phi=atan2(yn,xn); - if((*phi)<0) - (*phi)+=2*M_PI; - } -} - -static double get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, - double x0,double y0,double z0,double rr) -{ - double v[3],u[3]; - double idx=par->n_grid/par->l_box; - long ngx=2*(par->n_grid/2+1); - long iz_hi=iz+1,iz_lo=iz-1,iz_0=iz; - long iy_hi=iy+1,iy_lo=iy-1,iy_0=iy; - long ix_hi=ix+1,ix_lo=ix-1,ix_0=ix; - if(iy==0) iy_lo=par->n_grid-1; - if(iy==par->n_grid-1) iy_hi=0; - if(ix==0) ix_lo=par->n_grid-1; - if(ix==par->n_grid-1) ix_hi=0; - iz_0*=ngx*par->n_grid; - iz_lo*=ngx*par->n_grid; - iz_hi*=ngx*par->n_grid; - iy_0*=ngx; - iy_lo*=ngx; - iy_hi*=ngx; - - u[0]=x0/rr; u[1]=y0/rr; u[2]=z0/rr; - v[0]=par->grid_npot[ix_hi+iy_0+iz_0]-par->grid_npot[ix_lo+iy_0+iz_0]; - v[1]=par->grid_npot[ix_0+iy_hi+iz_0]-par->grid_npot[ix_0+iy_lo+iz_0]; - if(iz==0) - v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->slice_left[ix_0+iy_0]; - else if(iz==par->nz_here-1) - v[2]=par->slice_right[ix_0+iy_0]-par->grid_npot[ix_0+iy_0+iz_lo]; - else - v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->grid_npot[ix_0+iy_0+iz_lo]; - - return 0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); -} - -static int get_r_index_imap(HealpixShells *sh,double r,int ir_start) -{ - int gotit=0; - int ir0; - if(ir_start<0) - ir0=0; - else if(ir_start>=sh->nr) - ir0=sh->nr-1; - else - ir0=ir_start; - - while(!gotit) { - if((ir0==-1) || (ir0==sh->nr)) - gotit=1; - else { - if(rr0[ir0]) - ir0--; - else { - if(r>=sh->rf[ir0]) - ir0++; - else - gotit=1; - } - } - } - - return ir0; -} - -static void imap_preproc(HealpixShells *imap) -{ - int ir; - flouble *r0_i=my_malloc(imap->nr*sizeof(flouble)); - flouble *rf_i=my_malloc(imap->nr*sizeof(flouble)); - - memcpy(r0_i,imap->r0,imap->nr*sizeof(flouble)); - memcpy(rf_i,imap->rf,imap->nr*sizeof(flouble)); - - int *i_sorted=ind_sort(imap->nr,imap->r0); - for(ir=0;irnr;ir++) { - imap->r0[ir]=r0_i[i_sorted[ir]]; - imap->rf[ir]=rf_i[i_sorted[ir]]; - } - free(r0_i); - free(rf_i); - free(i_sorted); - - //All nodes must store the entire sky - imap->num_pix=he_nside2npix(imap->nside); - free(imap->listpix); - imap->listpix=my_malloc(sizeof(long)); //No need to initialize this really - free(imap->pos); - imap->pos=my_malloc(sizeof(double)); //No need to initialize thi either - free(imap->data); - imap->data=my_calloc(imap->nr*imap->num_pix,sizeof(flouble)); - free(imap->nadd); - imap->nadd=my_calloc(imap->nr*imap->num_pix,sizeof(flouble)); -} - -static void imap_set_cartesian_single(ParamCoLoRe *par,int ipop) -{ - if(NodeThis==0) timer(0); - HealpixShells *imap=par->imap[ipop]; - imap_preproc(imap); - - print_info(" %d-th intensity mapping species\n",ipop); - if(NodeThis==0) timer(0); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,imap,ipop) -#endif //_HAVE_OMP - { - long iz; - double dx=par->l_box/par->n_grid; - int ngx=2*(par->n_grid/2+1); - double factor_vel=-par->fgrowth_0/(1.5*par->hubble_0*par->OmegaM); - - double pixel_size=sqrt(4*M_PI/he_nside2npix(imap->nside)); - double rmin_here=imap->r0[0]-20.; - double rmax_here=imap->rf[imap->nr-1]+20.; - int nsub_lo,nsub_hi; - int *nsub_array=my_malloc(imap->nr*sizeof(int)); - for(iz=0;iznr;iz++) { - double r0=imap->r0[iz]; - double rf=imap->rf[iz]; - double vol=(rf*rf*rf-r0*r0*r0)*pixel_size*pixel_size/3; - double sct=r0*pixel_size; //Scale associated to pixel size - double scr=rf-r0; //Scale associated to the width of the shell - double scv=pow(vol,0.333333); //Scale associated to the overall volume - double sc0=fmin(scv,fmin(sct,scr)); //We now pick the minimum of the previous 3 - - nsub_array[iz]=(int)(dx/sc0+0.5)+1; - //#ifdef _HAVE_OMP - // if(omp_get_thread_num()==0) - //#endif //_HAVE_OMP - // print_info("%ld %lf %lf %d %lf %lf\n",iz,r0,rf,nsub_array[iz],rmin_here,rmax_here); - } - nsub_lo=nsub_array[0]; - nsub_hi=nsub_array[imap->nr-1]; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - int irad=0; - long indexz=iz*((long)(ngx*par->n_grid)); - double z0=(iz+par->iz0_here)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - double y0=iy*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - double x0=ix*dx-par->pos_obs[0]; - long index=ix+indexy+indexz; - double r0=sqrt(x0*x0+y0*y0+z0*z0); - double tmean=get_bg(par,r0,BG_TZ_IMAP,ipop); - if((r0<=rmax_here) && (r0>=rmin_here)) { - if(tmean>0) { - int nsub_here,izz; - double dx_sub; - double bias=get_bg(par,r0,BG_BZ_IMAP,ipop); - double dnorm=get_bg(par,r0,BG_NORM_IMAP,ipop); - double rvel=factor_vel*get_rvel(par,ix,iy,iz,x0,y0,z0,r0); - double dr_rsd=rvel*get_bg(par,r0,BG_V1,0)*get_bg(par,r0,BG_IH,0); - double temp=tmean*bias_model(par->grid_dens[index],bias)*dnorm; - irad=get_r_index_imap(imap,r0,irad); - if(irad<0) - nsub_here=nsub_lo; - else if(irad>=imap->nr) - nsub_here=nsub_hi; - else - nsub_here=nsub_array[irad]; - dx_sub=dx/nsub_here; - for(izz=0;izz=0) && (iradnr)) { - long irad_t=irad*imap->num_pix; - long pix_id=he_ang2pix(imap->nside,cth,phi); -#ifdef _HAVE_OMP -#pragma omp atomic -#endif //_HAVE_OMP - imap->data[irad_t+pix_id]+=temp; -#ifdef _HAVE_OMP -#pragma omp atomic -#endif //_HAVE_OMP - imap->nadd[irad_t+pix_id]++; - } - } - } - } - } - } - } - } - } //end omp for - - free(nsub_array); - } //end omp parallel - if(NodeThis==0) timer(2); -} - -void imap_set_cartesian(ParamCoLoRe *par) -{ - int ipop; - - //First, compute lensing Hessian - print_info("*** Filling up intensity maps\n"); - for(ipop=0;ipopn_imap;ipop++) - imap_set_cartesian_single(par,ipop); - print_info("\n"); -} - -static void imap_distribute_single(ParamCoLoRe *par,int ipop) -{ - return; -} - -void imap_distribute(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_imap;ipop++) - imap_distribute_single(par,ipop); -} - -static void imap_get_local_properties_single(ParamCoLoRe *par,int ipop) -{ - return; -} - -void imap_get_local_properties(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_imap;ipop++) - imap_get_local_properties_single(par,ipop); -} - -static void imap_beams_preproc_single(ParamCoLoRe *par,int ipop) -{ - return; -} - -void imap_beams_preproc(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_imap;ipop++) - imap_beams_preproc_single(par,ipop); -} - -static void imap_get_beam_properties_single(ParamCoLoRe *par,int ipop) -{ - return; -} - -void imap_get_beam_properties(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_imap;ipop++) - imap_get_beam_properties_single(par,ipop); -} - -static void imap_beams_postproc_single(ParamCoLoRe *par,int ipop) -{ - return; -} - -void imap_beams_postproc(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_imap;ipop++) - imap_beams_postproc_single(par,ipop); -} diff --git a/src/.ipynb_checkpoints/io-checkpoint.c b/src/.ipynb_checkpoints/io-checkpoint.c deleted file mode 100644 index 344ce3e..0000000 --- a/src/.ipynb_checkpoints/io-checkpoint.c +++ /dev/null @@ -1,1374 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -static ParamCoLoRe *param_colore_new(void) -{ - int ii; - ParamCoLoRe *par=my_malloc(sizeof(ParamCoLoRe)); - -#ifdef _DEBUG - par->f_dbg=NULL; -#endif //_DEBUG - - //Cosmological parameters - // Background - par->OmegaM=0.3; - par->OmegaL=0.7; - par->OmegaB=0.05; - par->hhub=0.7; - par->weos=-1.; - par->n_scal=0.96; - par->sig8=0.83; - par->fgrowth_0=-1; - par->hubble_0=-1; - par->prefac_lensing=-1; - par->z_max=1.5; - par->z_min=0.5; - par->r_max=-1; - par->r_min=-1; - par->glob_idr=-1; - // Powerspectra - sprintf(par->fnamePk,"default"); - par->numk=0; - par->logkmax=1; - par->logkmin=-3; - par->idlogk=100; - par->logkarr=NULL; - par->pkarr=NULL; - - //Density parameters - // Density methods - par->output_density=0; - par->r2_smooth=2.0; - par->do_smoothing=1; - par->smooth_potential=0; - par->dens_type=DENS_TYPE_LGNR; - par->lpt_interp_type=INTERP_CIC; - par->lpt_buffer_fraction=0.2; - par->output_lpt=0; - par->seed_rng=1234; - par->z0_norm=0; - par->zf_norm=0; - // Box parameters - par->n_grid=512; - par->l_box=-1; - par->nz_here=512; - par->iz0_here=0; - par->nz_max=512; - par->nz_all=NULL; - par->iz0_all=NULL; - // Density grids - par->grid_dens_f=NULL; - par->grid_dens=NULL; - par->grid_npot_f=NULL; - par->grid_npot=NULL; - par->sigma2_gauss=0; - - //IO parameters - sprintf(par->prefixOut,"default"); - par->output_format=0; - par->do_pred=0; - par->just_do_pred=0; - par->do_pred=1; - - //Tracers - par->do_srcs=0; - par->do_skewers=0; - par->do_srcs_lensing=0; - par->do_cstm=0; - par->do_isw=0; - par->do_imap=0; - par->do_kappa=0; - par->do_lensing=0; - par->lensing_spacing_type=SPACING_R; - par->do_isw=0; - par->n_srcs=-1; - par->n_cstm=-1; - par->n_imap=-1; - par->n_kappa=-1; - par->n_lensing=-1; - par->n_isw=-1; - par->nside_kappa=-1; - par->nside_lensing=-1; - par->nside_isw=-1; - par->write_lensing=0; - for(ii=0;iifnameBzCstm[ii],"default"); - sprintf(par->fnameKzCstm[ii],"default"); - par->cstm_bz_arr[ii]=NULL; - par->cstm_kz_arr[ii]=NULL; - par->cstm_norm_arr[ii]=NULL; - sprintf(par->fnameBzSrcs[ii],"default"); - sprintf(par->fnameNzSrcs[ii],"default"); - par->srcs_bz_arr[ii]=NULL; - par->srcs_nz_arr[ii]=NULL; - par->srcs_norm_arr[ii]=NULL; - par->lensing_srcs[ii]=0; - par->skw_srcs[ii]=0; - par->skw_gauss[ii]=0; - sprintf(par->fnameBzImap[ii],"default"); - sprintf(par->fnameTzImap[ii],"default"); - sprintf(par->fnameNuImap[ii],"default"); - par->imap_bz_arr[ii]=NULL; - par->imap_tz_arr[ii]=NULL; - par->imap_norm_arr[ii]=NULL; - par->nside_imap[ii]=-1; - par->nu0_imap[ii]=-1; - par->nside_cstm[ii]=-1; - } - for(ii=0;iiz_kappa_out[ii]=-1; - par->z_isw_out[ii]=-1; - } - par->cats_c=NULL; - par->nsources_c_this=NULL; - par->cats=NULL; - par->nsources_this=NULL; - par->imap=NULL; - par->kmap=NULL; - par->smap=NULL; - par->pd_map=NULL; - - //Beam distribution - par->nside_base=-1; - par->npix_base=-1; - par->need_beaming=0; - - return par; -} - -static void conf_read_string(config_t *conf,char *secname,char *varname,char *out) -{ - int stat; - char fullpath[256]; - const char *str; - sprintf(fullpath,"%s.%s",secname,varname); - stat=config_lookup_string(conf,fullpath,&str); - if(stat==CONFIG_FALSE) - report_error(1,"Couldn't read variable %s\n",fullpath); - sprintf(out,"%s",str); -} - -static void conf_read_double(config_t *conf,char *secname,char *varname,double *out) -{ - int stat; - char fullpath[256]; - sprintf(fullpath,"%s.%s",secname,varname); - stat=config_lookup_float(conf,fullpath,out); - if(stat==CONFIG_FALSE) - report_error(1,"Couldn't read variable %s\n",fullpath); -} - -static void conf_read_double_array(config_t *conf,char *secname,char *varname, - double *out,int *nel,int nmax) -{ - int n_elem,index; - config_setting_t *arr; - char fullpath[256]; - sprintf(fullpath,"%s.%s",secname,varname); - arr=config_lookup(conf,fullpath); - if(arr==NULL) - report_error(1,"Couldn't read variable %s\n",fullpath); - n_elem=config_setting_length(arr); - if(n_elem==0) - report_error(1,"Couldn't read variable %s\n",fullpath); - if(n_elem>nmax) - report_error(1,"Too many elements in %s (%d > %d)\n",fullpath,n_elem,nmax); - - *nel=n_elem; - for(index=0;indexnside_base=choose_nside_base(); - if(par->nside_base>NSIDE_MAX_HPX) - report_error(1,"Can't go beyond nside=%d\n",NSIDE_MAX_HPX); - par->npix_base=he_nside2npix(par->nside_base); - - config_init(conf); - - config_set_options(conf,CONFIG_OPTION_AUTOCONVERT); - stat=config_read_file(conf,fname); - if(stat==CONFIG_FALSE) - error_open_file(fname); - - conf_read_string(conf,"global","prefix_out",par->prefixOut); - conf_read_string(conf,"global","pk_filename",par->fnamePk); - conf_read_double(conf,"global","z_min",&(par->z_min)); - conf_read_double(conf,"global","z_max",&(par->z_max)); - conf_read_bool(conf,"global","output_density",&(par->output_density)); - conf_read_int(conf,"global","seed",&i_dum); - conf_read_bool(conf,"global","write_pred",&(par->do_pred)); - if (par->do_pred) { - conf_read_bool(conf,"global","just_write_pred",&(par->just_do_pred)); - conf_read_double(conf,"global","pred_dz",&(par->pred_dz)); - } - conf_read_double(conf,"field_par","r_smooth",&(par->r2_smooth)); - conf_read_bool(conf,"field_par","smooth_potential",&(par->smooth_potential)); - conf_read_int(conf,"field_par","n_grid",&(par->n_grid)); - conf_read_int(conf,"field_par","dens_type",&(par->dens_type)); - conf_read_double(conf,"field_par","lpt_buffer_fraction",&(par->lpt_buffer_fraction)); - conf_read_int(conf,"field_par","lpt_interp_type",&(par->lpt_interp_type)); - conf_read_int(conf,"field_par","output_lpt",&(par->output_lpt)); - - par->seed_rng=i_dum; - conf_read_string(conf,"global","output_format",c_dum); - if(!strcmp(c_dum,"HDF5")) { -#ifdef _HAVE_HDF5 - par->output_format=2; -#else //_HAVE_HDF5 - report_error(1,"HDF5 format not supported\n"); -#endif //_HAVE_HDF5 - } - else if(!strcmp(c_dum,"FITS")) { -#ifdef _HAVE_FITS - par->output_format=1; -#else //_HAVE_FITS - report_error(1,"FITS format not supported\n"); -#endif //_HAVE_FITS - } - else if(!strcmp(c_dum,"ASCII")) - par->output_format=0; - else - report_error(1,"Unrecognized format %s\n",c_dum); - - conf_read_double(conf,"cosmo_par","omega_M",&(par->OmegaM)); - conf_read_double(conf,"cosmo_par","omega_L",&(par->OmegaL)); - conf_read_double(conf,"cosmo_par","omega_B",&(par->OmegaB)); - conf_read_double(conf,"cosmo_par","h",&(par->hhub)); - conf_read_double(conf,"cosmo_par","w",&(par->weos)); - conf_read_double(conf,"cosmo_par","ns",&(par->n_scal)); - conf_read_double(conf,"cosmo_par","sigma_8",&(par->sig8)); - - //Get number of galaxy populations - par->n_srcs=0; - found=1; - while(found) { - sprintf(c_dum,"srcs%d",par->n_srcs+1); - cset=config_lookup(conf,c_dum); - if(cset==NULL) - found=0; - else - par->n_srcs++; - } - if(par->n_srcs>NPOP_MAX) - report_error(1,"You're asking for too many populations %d! Enlarge NPOP_MAX\n",par->n_srcs); - for(ii=0;iin_srcs;ii++) { - sprintf(c_dum,"srcs%d",ii+1); - conf_read_string(conf,c_dum,"nz_filename",par->fnameNzSrcs[ii]); - conf_read_string(conf,c_dum,"bias_filename",par->fnameBzSrcs[ii]); - conf_read_bool(conf,c_dum,"include_lensing",&(par->lensing_srcs[ii])); - if(par->lensing_srcs[ii]) - par->do_srcs_lensing=1; - conf_read_bool(conf,c_dum,"store_skewers",&(par->skw_srcs[ii])); - if(par->skw_srcs[ii]) { - par->do_skewers=1; - sprintf(c_dum2,"%s.gaussian_skewers",c_dum); - config_lookup_bool(conf,c_dum2,&(par->skw_gauss[ii])); - } - } - if(par->n_srcs>0) - par->do_srcs=1; - - //Get number of custom maps - par->n_cstm=0; - found=1; - while(found) { - sprintf(c_dum, "custom%d", par->n_cstm+1); - cset=config_lookup(conf,c_dum); - if(cset==NULL) - found=0; - else - par->n_cstm++; - } - if(par->n_cstm>NPOP_MAX) - report_error(1,"You're asking for too many populations %d! Enlarge NPOP_MAX\n",par->n_cstm); - for(ii=0;iin_cstm;ii++) { - sprintf(c_dum,"custom%d",ii+1); - conf_read_string(conf,c_dum,"kz_filename",par->fnameKzCstm[ii]); - conf_read_string(conf,c_dum,"bias_filename",par->fnameBzCstm[ii]); - conf_read_int(conf,c_dum,"nside",&(par->nside_cstm[ii])); - } - if(par->n_cstm>0) - par->do_cstm=1; - - //Get number of intensity mapping species - par->n_imap=0; - found=1; - while(found) { - sprintf(c_dum,"imap%d",par->n_imap+1); - cset=config_lookup(conf,c_dum); - if(cset==NULL) - found=0; - else - par->n_imap++; - } - if(par->n_imap>NPOP_MAX) - report_error(1,"You're asking for too many populations %d! Enlarge NPOP_MAX\n",par->n_imap); - for(ii=0;iin_imap;ii++) { - sprintf(c_dum,"imap%d",ii+1); - conf_read_string(conf,c_dum,"tbak_filename",par->fnameTzImap[ii]); - conf_read_string(conf,c_dum,"bias_filename",par->fnameBzImap[ii]); - conf_read_string(conf,c_dum,"freq_list",par->fnameNuImap[ii]); - conf_read_double(conf,c_dum,"freq_rest",&(par->nu0_imap[ii])); - conf_read_int(conf,c_dum,"nside",&(par->nside_imap[ii])); - } - if(par->n_imap>0) - par->do_imap=1; - - //Kappa maps - cset=config_lookup(conf,"kappa"); - if(cset!=NULL) { - par->do_kappa=1; - conf_read_double_array(conf,"kappa","z_out",par->z_kappa_out,&(par->n_kappa),NPLANES_MAX); - conf_read_int(conf,"kappa","nside",&(par->nside_kappa)); - } - -#ifdef _USE_FAST_LENSING - //Lensing maps - cset=config_lookup(conf,"lensing"); - if(cset!=NULL) { - par->do_lensing=1; - par->do_srcs_lensing=1; - conf_read_int(conf,"lensing","n_lensing",&(par->n_lensing)); - char spacing_string[256]="default"; - conf_read_string(conf,"lensing","spacing_type",spacing_string); - if(!strcmp(spacing_string,"r")) - par->lensing_spacing_type=SPACING_R; - else if(!strcmp(spacing_string,"log(1+z)")) - par->lensing_spacing_type=SPACING_LOGZ; - else - report_error(1,"Unknown spacing type %s\n",spacing_string); - conf_read_int(conf,"lensing","nside",&(par->nside_lensing)); - conf_read_bool(conf,"lensing","write",&(par->write_lensing)); - } - // Check lensing exists if requested with catalog - if(par->do_srcs_lensing && !(par->do_lensing)) - report_error(1,"Include a \"lensing\" section if you want lensing with your galaxies\n"); -#endif //_USE_FAST_LENSING - - cset=config_lookup(conf,"isw"); - if(cset!=NULL) { - par->do_isw=1; - conf_read_double_array(conf,"isw","z_out",par->z_isw_out,&(par->n_isw),NPLANES_MAX); - conf_read_int(conf,"isw","nside",&(par->nside_isw)); - } - -#ifdef _DEBUG - sprintf(c_dum,"%s_node%d.dbg",par->prefixOut,NodeThis); - par->f_dbg=fopen(c_dum,"w"); - if(par->f_dbg==NULL) error_open_file(c_dum); - if(NodeThis==0) { - sprintf(c_dum,"%s_params.cfg",par->prefixOut); - config_write_file(conf,c_dum); - } -#endif //_DEBUG - -#ifdef _ADD_EXTRA_KAPPA - if(par->do_kappa) { - par->need_extra_kappa=my_calloc(par->n_kappa,sizeof(int)); - par->fl_mean_extra_kappa=my_malloc(par->n_kappa*sizeof(flouble *)); - par->cl_extra_kappa=my_malloc(par->n_kappa*sizeof(flouble *)); - } - if(par->do_isw) { - par->need_extra_isw=my_calloc(par->n_isw,sizeof(int)); - par->fl_mean_extra_isw=my_malloc(par->n_isw*sizeof(flouble *)); - par->cl_extra_isw=my_malloc(par->n_isw*sizeof(flouble *)); - } -#endif //_ADD_EXTRA_KAPPA - - config_destroy(conf); - - if(par->r2_smooth>0) { - par->r2_smooth=pow(par->r2_smooth,2); - par->do_smoothing=1; - } - else - par->do_smoothing=0; - - par->need_beaming=(par->do_srcs_lensing+par->do_kappa+par->do_lensing+ - par->do_isw+par->do_skewers+par->do_cstm); - init_fftw(par); - - cosmo_set(par); - - get_max_memory(par,test_memory+par->just_do_pred); - - print_info("\n"); - - double dk=2*M_PI/par->l_box; - print_info("Run parameters: \n"); - print_info(" %.3lf < z < %.3lf\n",par->z_min,par->z_max); - print_info(" %.3lf < r/(Mpc/h) < %.3lf\n",par->r_min,par->r_max); - print_info(" L_box = %.3lf Mpc/h, N_grid = %d \n",(double)(par->l_box),par->n_grid); - print_info(" Scales resolved: %.3lE < k < %.3lE h/Mpc\n",dk,0.5*(par->n_grid-1)*dk); - print_info(" Fourier-space resolution: dk = %.3lE h/Mpc\n",dk); - print_info(" Real-space resolution: dx = %.3lE Mpc/h\n",par->l_box/par->n_grid); - if(par->do_smoothing) - print_info(" Density field pre-smoothed on scales: x_s = %.3lE Mpc/h\n",sqrt(par->r2_smooth)); - else - print_info(" No extra smoothing\n"); - if(par->do_srcs) - print_info(" %d galaxy populations\n",par->n_srcs); - if(par->do_skewers) - print_info(" Some populations will include LoS skewers\n"); - if(par->do_imap) - print_info(" %d intensity mapping species\n",par->n_imap); - if(par->do_cstm) - print_info(" %d custom maps\n",par->n_cstm); - if(par->do_kappa) - print_info(" %d lensing source planes\n",par->n_kappa); - if(par->do_lensing) - print_info(" %d lensing source planes\n",par->n_lensing); - if(par->do_isw) - print_info(" %d ISW source planes\n",par->n_isw); - if(par->do_srcs_lensing) - print_info(" Will include lensing in source catalog\n"); - if(!par->need_beaming) - print_info(" Will NOT need to all-to-all communicate fields\n"); - print_info("\n"); - - if(test_memory) { -#ifdef _DEBUG - fclose(par->f_dbg); -#endif //_DEBUG - free(par); - return NULL; - } - - if(par->just_do_pred) - return par; - - allocate_fftw(par); - - if(par->do_srcs) { - par->cats_c=my_malloc(par->n_srcs*sizeof(CatalogCartesian *)); - par->cats=my_malloc(par->n_srcs*sizeof(CatalogCartesian *)); - par->nsources_c_this=my_calloc(par->n_srcs,sizeof(long)); - par->nsources_this=my_calloc(par->n_srcs,sizeof(long)); - for(ii=0;iin_srcs;ii++) { - par->cats_c[ii]=NULL; - par->cats[ii]=NULL; - } - } - - if(par->do_imap) { - par->imap=my_malloc(par->n_imap*sizeof(HealpixShells *)); - for(ii=0;iin_imap;ii++) { - FILE *fnu=fopen(par->fnameNuImap[ii],"r"); - if(fnu==NULL) error_open_file(par->fnameNuImap[ii]); - par->imap[ii]=hp_shell_alloc(1,par->nside_imap[ii],par->nside_base,linecount(fnu)); - fclose(fnu); - } - } - - if(par->do_cstm) { - par->cstm=my_malloc(par->n_cstm*sizeof(HealpixShells *)); - for(ii=0;iin_cstm;ii++) - par->cstm[ii]=hp_shell_alloc(1,par->nside_cstm[ii],par->nside_base,1); - } - - if(par->do_kappa) - par->kmap=hp_shell_alloc(1,par->nside_kappa,par->nside_base,par->n_kappa); - -#ifdef _USE_FAST_LENSING - if(par->do_lensing) { - flouble *r_arr=compute_lensing_spacing(par); - par->smap = hp_shell_adaptive_alloc(5, par->nside_lensing, par->nside_base, - par->n_lensing, r_arr, par->l_box/par->n_grid, - 1.); - free(r_arr); - } -#endif //_USE_FAST_LENSING - - if(par->do_isw) - par->pd_map=hp_shell_alloc(1,par->nside_isw,par->nside_base,par->n_isw); - - compute_tracer_cosmo(par); - - free(conf); - - return par; -} - -void write_density_grid(ParamCoLoRe *par,char *prefix_dens) -{ - FILE *fo; - char fname[256]; - int iz; - int ngx=2*(par->n_grid/2+1); - int size_flouble=sizeof(flouble); - double lb=par->l_box; - - if(NodeThis==0) timer(0); - print_info("*** Writing density field (native format)\n"); - sprintf(fname,"%s_dens_%s_%d.dat",par->prefixOut,prefix_dens,NodeThis); - fo=fopen(fname,"wb"); - if(fo==NULL) error_open_file(fname); - my_fwrite(&NNodes,sizeof(int),1,fo); - my_fwrite(&size_flouble,sizeof(int),1,fo); - my_fwrite(&lb,sizeof(double),1,fo); - my_fwrite(&(par->n_grid),sizeof(int),1,fo); - my_fwrite(&(par->nz_here),sizeof(int),1,fo); - my_fwrite(&(par->iz0_here),sizeof(int),1,fo); - for(iz=0;iznz_here;iz++) { - int iy; - for(iy=0;iyn_grid;iy++) { - long index0=ngx*((long)(iy+iz*par->n_grid)); - my_fwrite(&(par->grid_dens[index0]),sizeof(flouble),par->n_grid,fo); - } - } - fclose(fo); - if(NodeThis==0) timer(2); - print_info("\n"); -} - -typedef struct { - int np[6]; - double mass[6]; - double time; - double redshift; - int flag_sfr; - int flag_feedback; - unsigned int np_total[6]; - int flag_cooling; - int num_files; - double boxsize; - double omega0; - double omega_lambda; - double hubble_param; - int flag_stellarage; - int flag_metals; - unsigned int np_total_highword[6]; - int flag_entropy_instead_u; - int flag_gadgetformat; - char fill[56]; -} GadgetHeader; - -void write_lpt(ParamCoLoRe *par,unsigned long long npart,flouble *x,flouble *y,flouble *z) -{ - GadgetHeader header; - FILE *fo; - char fname[256]; - unsigned long long ipart,np_total; - unsigned long long np_total_expected=par->n_grid*((long)(par->n_grid*par->n_grid)); - - sprintf(fname,"%s_lpt_out.%d",par->prefixOut,NodeThis); - fo=fopen(fname,"w"); - if(fo==NULL) error_open_file(fname); - -#ifdef _HAVE_MPI - unsigned long long np_send=npart; - MPI_Reduce(&np_send,&np_total,1,MPI_UNSIGNED_LONG_LONG,MPI_SUM,0,MPI_COMM_WORLD); - MPI_Bcast(&np_total,1,MPI_UNSIGNED_LONG_LONG,0,MPI_COMM_WORLD); -#else //_HAVE_MPI - np_total=npart; -#endif //_HAVE_MPI - - if(np_total!=np_total_expected) - report_error(1,"Only %llu particles found, but there should be %ull\n",np_total,np_total_expected); - - double m=27.7455*par->OmegaM*pow(par->l_box,3.)/np_total; - memset(&header,0,sizeof(GadgetHeader)); - - header.np[1]=npart; - header.mass[1]=m; - header.time=1.; - header.redshift=0.; - header.np_total[1]=(unsigned int)np_total; - header.np_total_highword[1]=(unsigned int)(np_total >> 32); - header.num_files=NNodes; - header.boxsize=par->l_box; - header.omega0=par->OmegaM; - header.omega_lambda=par->OmegaL; - header.hubble_param=par->hhub; - header.flag_gadgetformat=1; - - int blklen=sizeof(GadgetHeader); - my_fwrite(&blklen,sizeof(blklen),1,fo); - my_fwrite(&header,sizeof(GadgetHeader),1,fo); - my_fwrite(&blklen,sizeof(blklen),1,fo); - - float x0[3]; - // position - blklen=npart*sizeof(float)*3; - my_fwrite(&blklen,sizeof(blklen),1,fo); - for(ipart=0;ipartiz0_here*((long)(par->n_grid*par->n_grid))); - for(ipart=0;ipartn_imap;ipop++) { - int ir; - HealpixShells *imap=par->imap[ipop]; - long npx=he_nside2npix(imap->nside); - flouble *map_write=my_malloc(npx*sizeof(flouble)); - int *map_nadd=my_malloc(npx*sizeof(int)); - print_info(" %d-th species\n",ipop); - for(ir=0;irnr;ir++) { - long ip; - long ir_t=ir*imap->num_pix; - - //Write local pixels to dummy map - for(ip=0;ipprefixOut,ipop+1,ir); - for(ip=0;ipdata[ir_t+ip]; - map_nadd[ip]+=imap->nadd[ir_t+ip]; - } - - //Collect all dummy maps -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - - for(ip=0;ip0) - map_write[ip]/=map_nadd[ip]; - } - - //Write dummy map - if(NodeThis==0) - he_write_healpix_map(&map_write,1,imap->nside,fname,0); - } - free(map_write); - free(map_nadd); - } - if(NodeThis==0) timer(2); - print_info("\n"); -} - -void write_cstm(ParamCoLoRe *par) -{ - int ipop; - char fname[256]; - - if(NodeThis==0) timer(0); - print_info("*** Writing custom maps\n"); - for(ipop=0;ipopn_cstm;ipop++) { - long ip; - HealpixShells *cmap=par->cstm[ipop]; - long npx=he_nside2npix(cmap->nside); - flouble *map_write=my_malloc(npx*sizeof(flouble)); - int *map_nadd=my_malloc(npx*sizeof(int)); - print_info(" %d-th species\n",ipop); - - //Write local pixels to dummy map - for(ip=0;ipprefixOut,ipop+1); - for(ip=0;ipdata[ip]; - map_nadd[ip]+=cmap->nadd[ip]; - } - - //Collect all dummy maps -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - - for(ip=0;ip0) - map_write[ip]/=map_nadd[ip]; - } - - //Write dummy map - if(NodeThis==0) - he_write_healpix_map(&map_write,1,cmap->nside,fname,1); - - free(map_write); - free(map_nadd); - } - if(NodeThis==0) timer(2); - print_info("\n"); -} - -void write_kappa(ParamCoLoRe *par) -{ - int ir; - char fname[256]; - long npx=he_nside2npix(par->nside_kappa); - flouble *map_write=my_malloc(npx*sizeof(flouble)); - int *map_nadd=my_malloc(npx*sizeof(int)); - if(NodeThis==0) timer(0); - print_info("*** Writing kappa source maps\n"); - for(ir=0;irkmap->nr;ir++) { - long ip; - long ir_t=ir*par->kmap->num_pix; - - //Write local pixels to dummy map - for(ip=0;ipprefixOut,ir); - for(ip=0;ipkmap->num_pix;ip++) { - int id_pix=par->kmap->listpix[ip]; - map_write[id_pix]+=par->kmap->data[ir_t+ip]; - map_nadd[ id_pix]+=par->kmap->nadd[ir_t+ip]; - } - - //Collect all dummy maps -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - - for(ip=0;ip0) - map_write[ip]/=map_nadd[ip]; - } - -#ifdef _ADD_EXTRA_KAPPA - if(par->need_extra_kappa[ir]) { - if(NodeThis==0) { - int lmax=3*par->kmap->nside; - flouble *map_extra; - flouble *map_mean=my_calloc(npx,sizeof(flouble)); - fcomplex *alm=my_malloc(he_nalms(lmax)*sizeof(fcomplex)); - print_info("Adding perturbations to kappa shell #%d\n",ir+1); - he_map2alm(par->kmap->nside,lmax,1,&map_write,&alm); - he_alter_alm(lmax,0,alm,alm,par->fl_mean_extra_kappa[ir]); - he_alm2map(par->kmap->nside,lmax,1,&map_mean,&alm); - free(alm); - map_extra=he_synfast(par->cl_extra_kappa[ir],par->kmap->nside,lmax,par->seed_rng); - for(ip=0;ipnside_kappa,fname,1); - } - free(map_write); - free(map_nadd); - if(NodeThis==0) timer(2); - print_info("\n"); -} - -void write_lensing(ParamCoLoRe *par) -{ - int ir; - char fname[256]; - long npx=he_nside2npix(par->smap->nside[par->smap->nr-1]); - flouble **map_write=my_malloc(2*sizeof(flouble *)); - map_write[0]=my_malloc(npx*sizeof(flouble)); - map_write[1]=my_malloc(npx*sizeof(flouble)); - if(NodeThis==0) timer(0); - print_info("*** Writing lensing source maps\n"); - for(ir=0;irsmap->nr;ir++) { - long ip, ib; - - //Write local pixels to dummy map - for(ip=0;ipprefixOut,ir); - for(ib=0;ibsmap->nbeams;ib++) { - long ipix_0=(NodeThis+NNodes*ib)*par->smap->num_pix_per_beam[ir]; - for(ip=0;ipsmap->num_pix_per_beam[ir];ip++) { - long id_pix=ipix_0+ip; - map_write[0][id_pix]+=par->smap->data[ib][ir][5*ip+0]; - map_write[1][id_pix]+=par->smap->data[ib][ir][5*ip+1]; - } - } - - //Collect all dummy maps -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_write[0],npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_write[0],NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_write[1],npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_write[1],NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - - //Write dummy map - if(NodeThis==0) - he_write_healpix_map(map_write,2,par->smap->nside[ir],fname,1); - } - free(map_write[0]); - free(map_write[1]); - free(map_write); - - if(NodeThis==0) { - sprintf(fname,"%s_lensing_r.txt", par->prefixOut); - FILE *f=fopen(fname, "w"); - if(f==NULL) - report_error(1,"Couldn't open file %s\n", fname); - for(ir=0;irsmap->nr;ir++) { - fprintf(f,"%d %lE %lE\n",ir, - par->smap->r[ir], - get_bg(par, par->smap->r[ir], BG_Z, 0)); - } - fclose(f); - } - - if(NodeThis==0) timer(2); - print_info("\n"); -} - -void write_isw(ParamCoLoRe *par) -{ - int ir; - char fname[256]; - long npx=he_nside2npix(par->nside_isw); - flouble *map_write=my_malloc(npx*sizeof(flouble)); - int *map_nadd=my_malloc(npx*sizeof(int)); - if(NodeThis==0) timer(0); - print_info("*** Writing isw source maps\n"); - for(ir=0;irpd_map->nr;ir++) { - long ip; - long ir_t=ir*par->pd_map->num_pix; - - //Write local pixels to dummy map - for(ip=0;ipprefixOut,ir); - for(ip=0;ippd_map->num_pix;ip++) { - int id_pix=par->pd_map->listpix[ip]; - map_write[id_pix]+=par->pd_map->data[ir_t+ip]; - map_nadd[ id_pix]+=par->pd_map->nadd[ir_t+ip]; - } - - //Collect all dummy maps -#ifdef _HAVE_MPI - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_write,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_write ,NULL ,npx,FLOUBLE_MPI,MPI_SUM,0,MPI_COMM_WORLD); - if(NodeThis==0) - MPI_Reduce(MPI_IN_PLACE,map_nadd,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); - else - MPI_Reduce(map_nadd ,NULL ,npx,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD); -#endif //_HAVE_MPI - - for(ip=0;ip0) - map_write[ip]/=map_nadd[ip]; - } - -#ifdef _ADD_EXTRA_KAPPA - if(par->need_extra_isw[ir]) { - if(NodeThis==0) { - int lmax=3*par->pd_map->nside; - flouble *map_extra; - flouble *map_mean=my_calloc(npx,sizeof(flouble)); - fcomplex *alm=my_malloc(he_nalms(lmax)*sizeof(fcomplex)); - print_info("Adding perturbations to isw shell #%d\n",ir+1); - he_map2alm(par->pd_map->nside,lmax,1,&map_write,&alm); - he_alter_alm(lmax,0,alm,alm,par->fl_mean_extra_isw[ir]); - he_alm2map(par->pd_map->nside,lmax,1,&map_mean,&alm); - free(alm); - map_extra=he_synfast(par->cl_extra_isw[ir],par->pd_map->nside,lmax,par->seed_rng); - for(ip=0;ipnside_isw,fname,1); - } - free(map_write); - free(map_nadd); - if(NodeThis==0) timer(2); - print_info("\n"); -} - -static void write_catalog(ParamCoLoRe *par,int ipop) -{ - char fname[256]; - - if(NodeThis==0) timer(0); - if(par->output_format==2) { //HDF5 -#ifdef _HAVE_HDF5 - hid_t file_id,gal_types[6]; - hsize_t chunk_size=128; - size_t dst_offset[11]={HOFFSET(Src,ra),HOFFSET(Src,dec),HOFFSET(Src,z0),HOFFSET(Src,dz_rsd),HOFFSET(Src,vtheta),HOFFSET(Src,vphi),HOFFSET(Src,e1), - HOFFSET(Src,e2),HOFFSET(Src,kappa),HOFFSET(Src,dra),HOFFSET(Src,ddec)}; - const char *names[11]={"RA" ,"DEC","Z_COSMO","DZ_RSD","VTHETA","VPHI","E1","E2","K" ,"DRA","DDEC"}; - char *tunit[11]= {"DEG","DEG","NA" ,"NA" ,"NA","NA","NA","NA","NA","DEG","DEG"}; - gal_types[0]=H5T_NATIVE_FLOAT; - gal_types[1]=H5T_NATIVE_FLOAT; - gal_types[2]=H5T_NATIVE_FLOAT; - gal_types[3]=H5T_NATIVE_FLOAT; - gal_types[4]=H5T_NATIVE_FLOAT; - gal_types[5]=H5T_NATIVE_FLOAT; - gal_types[6]=H5T_NATIVE_FLOAT; - gal_types[7]=H5T_NATIVE_FLOAT; - gal_types[8]=H5T_NATIVE_FLOAT; - gal_types[9]=H5T_NATIVE_FLOAT; - gal_types[10]=H5T_NATIVE_FLOAT; - - print_info(" %d-th population (HDF5)\n",ipop); - sprintf(fname,"%s_srcs_s%d_%d.h5",par->prefixOut,ipop+1,NodeThis); - - //Create file - file_id=H5Fcreate(fname,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT); - //Write table for each galaxy type - char table_title[256],table_name[256]; - sprintf(table_title,"sources%d_data",ipop+1); - sprintf(table_name,"/sources%d",ipop+1); - H5TBmake_table(table_title,file_id,table_name,6,par->nsources_this[ipop],sizeof(Src), - names,dst_offset,gal_types,chunk_size,NULL,0,par->cats[ipop]->srcs); - H5LTset_attribute_string(file_id,table_name,"FIELD_0_UNITS",tunit[0]); - H5LTset_attribute_string(file_id,table_name,"FIELD_1_UNITS",tunit[1]); - H5LTset_attribute_string(file_id,table_name,"FIELD_2_UNITS",tunit[2]); - H5LTset_attribute_string(file_id,table_name,"FIELD_3_UNITS",tunit[3]); - H5LTset_attribute_string(file_id,table_name,"FIELD_4_UNITS",tunit[4]); - H5LTset_attribute_string(file_id,table_name,"FIELD_5_UNITS",tunit[5]); - H5LTset_attribute_string(file_id,table_name,"FIELD_6_UNITS",tunit[6]); - H5LTset_attribute_string(file_id,table_name,"FIELD_7_UNITS",tunit[7]); - H5LTset_attribute_string(file_id,table_name,"FIELD_8_UNITS",tunit[8]); - - //End file - H5Fclose(file_id); -#else //_HAVE_HDF5 - printf("HDF5 not supported\n"); -#endif //_HAVE_HDF5 - } - else if(par->output_format==1) { //FITS -#ifdef _HAVE_FITS - long ii,nrw=0; - int status=0; - fitsfile *fptr; - int *type_arr; - float *ra_arr,*dec_arr,*z0_arr,*rsd_arr,*vtheta_arr,*vphi_arr,*e1_arr,*e2_arr,*k_arr,*dra_arr,*ddec_arr; - int nfields=5; -#ifdef TVEL - char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD", "VTHETA", "VPHI", "E1","E2","KAPPA","DRA","DDEC"}; - char *tform[]={"1J" ,"1E" ,"1E" ,"1E" ,"1E" , "1E", "1E", "1E","1E","1E" ,"1E!","1E"}; - char *tunit[]={"NA" ,"DEG","DEG","NA" ,"NA" , "NA", "NA", "NA","NA","NA" ,"DEG","DEG"}; - //char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","KAPPA","DRA","DDEC"}; - nfields+=2; -#else - char *ttype[]={"TYPE","RA" ,"DEC","Z_COSMO","DZ_RSD","E1","E2","KAPPA","DRA","DDEC"}; - char *tform[]={"1J" ,"1E" ,"1E" ,"1E" ,"1E" ,"1E","1E","1E" ,"1E!","1E"}; - char *tunit[]={"NA" ,"DEG","DEG","NA" ,"NA" ,"NA","NA","NA" ,"DEG","DEG"}; -#endif - if(par->cats[ipop]->has_lensing) - nfields+=5; - - print_info(" %d-th population (FITS)\n",ipop); - sprintf(fname,"!%s_srcs_s%d_%d.fits",par->prefixOut,ipop+1,NodeThis); - - fits_create_file(&fptr,fname,&status); - fits_create_tbl(fptr,BINARY_TBL,0,nfields,ttype,tform,tunit,NULL,&status); - fits_update_key(fptr,TSTRING,"CONTENTS","Source catalog",NULL,&status); - - fits_get_rowsize(fptr,&nrw,&status); - type_arr=my_malloc(nrw*sizeof(int)); - ra_arr=my_malloc(nrw*sizeof(float)); - dec_arr=my_malloc(nrw*sizeof(float)); - z0_arr=my_malloc(nrw*sizeof(float)); - rsd_arr=my_malloc(nrw*sizeof(float)); -#ifdef TVEL - vtheta_arr=my_malloc(nrw*sizeof(float)); - vphi_arr=my_malloc(nrw*sizeof(float)); -#endif - e1_arr=my_malloc(nrw*sizeof(float)); - e2_arr=my_malloc(nrw*sizeof(float)); - k_arr=my_malloc(nrw*sizeof(float)); - dra_arr=my_malloc(nrw*sizeof(float)); - ddec_arr=my_malloc(nrw*sizeof(float)); - - long row_here=0; - while(row_herensources_this[ipop]) { - long nrw_here; - if(row_here+nrw>par->nsources_this[ipop]) - nrw_here=par->nsources_this[ipop]-row_here; - else - nrw_here=nrw; - - for(ii=0;iicats[ipop]->srcs[row_here+ii].ra; - dec_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dec; - z0_arr[ii]=par->cats[ipop]->srcs[row_here+ii].z0; - rsd_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dz_rsd; -#ifdef TVEL - vtheta_arr[ii]=par->cats[ipop]->srcs[row_here+ii].vtheta; - vphi_arr[ii]=par->cats[ipop]->srcs[row_here+ii].vphi; -#endif - if(par->cats[ipop]->has_lensing) { - e1_arr[ii]=par->cats[ipop]->srcs[row_here+ii].e1; - e2_arr[ii]=par->cats[ipop]->srcs[row_here+ii].e2; - k_arr[ii]=par->cats[ipop]->srcs[row_here+ii].kappa; - dra_arr[ii]=par->cats[ipop]->srcs[row_here+ii].dra; - ddec_arr[ii]=par->cats[ipop]->srcs[row_here+ii].ddec; - } - } - fits_write_col(fptr,TINT ,1,row_here+1,1,nrw_here,type_arr,&status); - fits_write_col(fptr,TFLOAT,2,row_here+1,1,nrw_here,ra_arr,&status); - fits_write_col(fptr,TFLOAT,3,row_here+1,1,nrw_here,dec_arr,&status); - fits_write_col(fptr,TFLOAT,4,row_here+1,1,nrw_here,z0_arr,&status); - fits_write_col(fptr,TFLOAT,5,row_here+1,1,nrw_here,rsd_arr,&status); -#ifdef TVEL - fits_write_col(fptr,TFLOAT,6,row_here+1,1,nrw_here,vtheta_arr,&status); - fits_write_col(fptr,TFLOAT,7,row_here+1,1,nrw_here,vphi_arr,&status); - int offset = 2; - //int offset = 0; -#else - int offset = 0; -#endif - if(par->cats[ipop]->has_lensing) { - fits_write_col(fptr,TFLOAT,6+offset,row_here+1,1,nrw_here,e1_arr,&status); - fits_write_col(fptr,TFLOAT,7+offset,row_here+1,1,nrw_here,e2_arr,&status); - fits_write_col(fptr,TFLOAT,8+offset,row_here+1,1,nrw_here,k_arr,&status); - fits_write_col(fptr,TFLOAT,9+offset,row_here+1,1,nrw_here,dra_arr,&status); - fits_write_col(fptr,TFLOAT,10+offset,row_here+1,1,nrw_here,ddec_arr,&status); - } - - row_here+=nrw_here; - } - - if(par->cats[ipop]->has_skw) { - int ir; - long nelements,naxis=2; - long naxes[2]; - - if(par->cats[ipop]->skw_gauss) { - //Write gaussian skewers - naxes[0]=par->cats[ipop]->nr; - naxes[1]=par->cats[ipop]->nsrc; - nelements=naxes[0]*naxes[1]; - fits_create_img(fptr,FLOAT_IMG,naxis,naxes,&status); - fits_update_key(fptr, TSTRING, "CONTENTS", "gaussian skewers",NULL, &status); - fits_write_img(fptr,TFLOAT,1,nelements,par->cats[ipop]->g_skw,&status); - } - else { - //Write density skewers - naxes[0]=par->cats[ipop]->nr; - naxes[1]=par->cats[ipop]->nsrc; - nelements=naxes[0]*naxes[1]; - fits_create_img(fptr,FLOAT_IMG,naxis,naxes,&status); - fits_update_key(fptr, TSTRING, "CONTENTS", "density skewers",NULL, &status); - fits_write_img(fptr,TFLOAT,1,nelements,par->cats[ipop]->d_skw,&status); - } - - //Write velocity skewers - fits_create_img(fptr,FLOAT_IMG,naxis,naxes,&status); - fits_update_key(fptr, TSTRING, "CONTENTS", "velocity skewers",NULL, &status); - fits_write_img(fptr,TFLOAT,1,nelements,par->cats[ipop]->v_skw,&status); - - //Write slicing information - float sg=sqrt(par->sigma2_gauss); - float *ra=my_malloc(par->cats[ipop]->nr*sizeof(float)); - float *za=my_malloc(par->cats[ipop]->nr*sizeof(float)); - float *gda=my_malloc(par->cats[ipop]->nr*sizeof(float)); - float *gva=my_malloc(par->cats[ipop]->nr*sizeof(float)); - char *tt[]={"R","Z","D","V"}; - char *tf[]={"1E","1E","1E","1E"}; - char *tu[]={"MPC_H","NA","NA","NA"}; - for(ir=0;ircats[ipop]->nr;ir++) { - double r=par->cats[ipop]->dr*(ir+0.5); - ra[ir]=r; - za[ir]=get_bg(par,r,BG_Z,0); - gda[ir]=get_bg(par,r,BG_D1,0); - gva[ir]=get_bg(par,r,BG_V1,0); - } - fits_create_tbl(fptr,BINARY_TBL,0,4,tt,tf,tu,NULL,&status); - fits_update_key(fptr,TSTRING,"CONTENTS","Background cosmology",NULL,&status); - fits_update_key(fptr,TFLOAT,"SIGMA_G",&sg,NULL, &status); - fits_write_col(fptr,TFLOAT,1,1,1,par->cats[ipop]->nr,ra,&status); - fits_write_col(fptr,TFLOAT,2,1,1,par->cats[ipop]->nr,za,&status); - fits_write_col(fptr,TFLOAT,3,1,1,par->cats[ipop]->nr,gda,&status); - fits_write_col(fptr,TFLOAT,4,1,1,par->cats[ipop]->nr,gva,&status); - free(ra); free(za); free(gda); free(gva); - } - - fits_close_file(fptr,&status); - free(ra_arr); - free(dec_arr); - free(z0_arr); - free(rsd_arr); - free(type_arr); - free(e1_arr); - free(e2_arr); - free(k_arr); - free(dra_arr); - free(ddec_arr); -#else //_HAVE_FITS - printf("FITS not supported\n"); -#endif //_HAVE_FITS - } - else { - print_info(" %d-th population (ASCII)\n",ipop); - sprintf(fname,"%s_srcs_s%d_%d.txt",par->prefixOut,ipop+1,NodeThis); - - long jj; - FILE *fil=fopen(fname,"w"); - if(fil==NULL) error_open_file(fname); - fprintf(fil,"#[1]type [2]RA, [3]dec, [4]z0, [5]dz_RSD "); - if(par->cats[ipop]->has_lensing) - fprintf(fil,"#[6]e1, [7]e2 [8]kappa [9]d_ra [10]d_dec\n"); - else - fprintf(fil,"\n"); - for(jj=0;jjnsources_this[ipop];jj++) { - fprintf(fil,"%d %E %E %E %E ", - ipop,par->cats[ipop]->srcs[jj].ra,par->cats[ipop]->srcs[jj].dec, - par->cats[ipop]->srcs[jj].z0,par->cats[ipop]->srcs[jj].dz_rsd); - if(par->cats[ipop]->has_lensing) { - fprintf(fil,"%E %E %E %E %E \n",par->cats[ipop]->srcs[jj].e1,par->cats[ipop]->srcs[jj].e2, - par->cats[ipop]->srcs[jj].kappa,par->cats[ipop]->srcs[jj].dra,par->cats[ipop]->srcs[jj].ddec); - } - else - fprintf(fil,"\n"); - } - fclose(fil); - } - if(NodeThis==0) timer(2); -} - -void write_srcs(ParamCoLoRe *par) -{ - print_info("*** Writing source catalogs\n"); - int ipop; - for(ipop=0;ipopn_srcs;ipop++) - write_catalog(par,ipop); - print_info("\n"); -} - -void param_colore_free(ParamCoLoRe *par) -{ - int ii; - free(par->nz_all); - free(par->iz0_all); - free(par->logkarr); - free(par->pkarr); - end_fftw(par); - - if(par->do_srcs) { - for(ii=0;iin_srcs;ii++) { - free(par->srcs_bz_arr[ii]); - free(par->srcs_nz_arr[ii]); - free(par->srcs_norm_arr[ii]); - if(par->cats_c!=NULL) { - if(par->cats_c[ii]!=NULL) - catalog_cartesian_free(par->cats_c[ii]); - } - if(par->cats!=NULL) { - - if(par->cats[ii]!=NULL) - catalog_free(par->cats[ii]); - } - } - if(par->cats_c!=NULL) - free(par->cats_c); - if(par->cats!=NULL) - free(par->cats); - free(par->nsources_c_this); - free(par->nsources_this); - } - - - if(par->do_imap) { - for(ii=0;iin_imap;ii++) { - free(par->imap_bz_arr[ii]); - free(par->imap_tz_arr[ii]); - free(par->imap_norm_arr[ii]); - if(par->imap!=NULL) - hp_shell_free(par->imap[ii]); - } - if(par->imap!=NULL) - free(par->imap); - } - - if(par->do_cstm) { - for(ii=0;iin_cstm;ii++) { - free(par->cstm_bz_arr[ii]); - free(par->cstm_kz_arr[ii]); - free(par->cstm_norm_arr[ii]); - if(par->cstm!=NULL) - hp_shell_free(par->cstm[ii]); - } - if(par->cstm!=NULL) - free(par->cstm); - } - - if(par->do_kappa) { - if(par->kmap!=NULL) - hp_shell_free(par->kmap); -#ifdef _ADD_EXTRA_KAPPA - for(ii=0;iin_kappa;ii++) { - if(par->need_extra_kappa[ii]) { - free(par->fl_mean_extra_kappa[ii]); - free(par->cl_extra_kappa[ii]); - } - } - free(par->need_extra_kappa); - free(par->fl_mean_extra_kappa); - free(par->cl_extra_kappa); -#endif //_ADD_EXTRA_KAPPA - } - -#ifdef _USE_FAST_LENSING - if(par->do_lensing) { - if(par->smap!=NULL) - hp_shell_adaptive_free(par->smap); - } -#endif //_USE_FAST_LENSING - - if(par->do_isw) { - if(par->pd_map!=NULL) - hp_shell_free(par->pd_map); -#ifdef _ADD_EXTRA_KAPPA - for(ii=0;iin_isw;ii++) { - if(par->need_extra_isw[ii]) { - free(par->fl_mean_extra_isw[ii]); - free(par->cl_extra_isw[ii]); - } - } - free(par->need_extra_isw); - free(par->fl_mean_extra_isw); - free(par->cl_extra_isw); -#endif //_ADD_EXTRA_KAPPA - } - - -#ifdef _DEBUG - fclose(par->f_dbg); -#endif //_DEBUG - free(par); -} diff --git a/src/.ipynb_checkpoints/isw-checkpoint.c b/src/.ipynb_checkpoints/isw-checkpoint.c deleted file mode 100644 index ad1d81e..0000000 --- a/src/.ipynb_checkpoints/isw-checkpoint.c +++ /dev/null @@ -1,153 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -void isw_set_cartesian(ParamCoLoRe *par) -{ - return; -} - -void isw_get_local_properties(ParamCoLoRe *par) -{ - return; -} - -void isw_distribute(ParamCoLoRe *par) -{ - return; -} - -void isw_beams_preproc(ParamCoLoRe *par) -{ - //Sort radii in ascending order - int ir; - flouble *r0_i=my_malloc(par->pd_map->nr*sizeof(flouble)); - flouble *rf_i=my_malloc(par->pd_map->nr*sizeof(flouble)); - - memcpy(r0_i,par->pd_map->r0,par->pd_map->nr*sizeof(flouble)); - memcpy(rf_i,par->pd_map->rf,par->pd_map->nr*sizeof(flouble)); - - int *i_sorted=ind_sort(par->pd_map->nr,par->pd_map->r0); - for(ir=0;irpd_map->nr;ir++) { - par->pd_map->r0[ir]=r0_i[i_sorted[ir]]; - par->pd_map->rf[ir]=rf_i[i_sorted[ir]]; - } - free(r0_i); - free(rf_i); - free(i_sorted); - - //Zero all data and clear -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par) -#endif //_HAVE_OMP - { - long ipp; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ipp=0;ipppd_map->num_pix*par->pd_map->nr;ipp++) { - par->pd_map->data[ipp]=0; - par->pd_map->nadd[ipp]=1; - } //end omp for - } //end omp parallel - - return; -} - -void isw_get_beam_properties(ParamCoLoRe *par) -{ - HealpixShells *pd_map=par->pd_map; - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,pd_map) -#endif //_HAVE_OMP - { - double idx=par->n_grid/par->l_box; - - //Setup radial decomposition - int i_r,nr; - double idr,dr; - get_radial_params(par->r_max,par->n_grid,&nr,&dr); - idr=1./dr; - - //Compute index of each source plane - int *i_r_max_arr=my_malloc(pd_map->nr*sizeof(int)); - int *i_r_min_arr=my_malloc(pd_map->nr*sizeof(int)); - for(i_r=0;i_rnr;i_r++) { - int i_r_here=(int)(pd_map->rf[i_r]*idr+0.5); - i_r_max_arr[i_r]=MIN(i_r_here,nr-1); - } - i_r_min_arr[0]=0; - for(i_r=1;i_rnr;i_r++) - i_r_min_arr[i_r]=i_r_max_arr[i_r-1]+1; - - //Fill up integral kernels - double *fac_r=my_malloc(nr*sizeof(double)); - for(i_r=0;i_rnum_pix;ip++) { - int ax,added; - flouble pd; - double xn[3]; - double isw=0; - double *u=&(pd_map->pos[3*ip]); - - for(i_r=0;i_rnr;i_r++) { - int irr; - int irmin=i_r_min_arr[i_r]; - int irmax=i_r_max_arr[i_r]; - for(irr=irmin;irr<=irmax;irr++) { - double rm=(irr+0.5)*dr; - for(ax=0;ax<3;ax++) - xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; - added=interpolate_from_grid(par,xn,NULL,NULL,NULL,&pd,NULL,RETURN_PDOT,INTERP_TYPE_LENSING); - if(added) - isw+=pd*fac_r[irr]; - } - pd_map->data[i_r*pd_map->num_pix+ip]+=isw; - } - } //end omp for - - free(fac_r); - free(i_r_max_arr); - free(i_r_min_arr); - } //end omp parallel - - return; -} - -void isw_beams_postproc(ParamCoLoRe *par) -{ - //Set rf to end of cell - return; -} diff --git a/src/.ipynb_checkpoints/kappa-checkpoint.c b/src/.ipynb_checkpoints/kappa-checkpoint.c deleted file mode 100644 index bb961fd..0000000 --- a/src/.ipynb_checkpoints/kappa-checkpoint.c +++ /dev/null @@ -1,181 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -void kappa_set_cartesian(ParamCoLoRe *par) -{ - return; -} - -void kappa_get_local_properties(ParamCoLoRe *par) -{ - return; -} - -void kappa_distribute(ParamCoLoRe *par) -{ - return; -} - -void kappa_beams_preproc(ParamCoLoRe *par) -{ - //Sort radii in ascending order - int ir; - flouble *r0_i=my_malloc(par->kmap->nr*sizeof(flouble)); - flouble *rf_i=my_malloc(par->kmap->nr*sizeof(flouble)); - - memcpy(r0_i,par->kmap->r0,par->kmap->nr*sizeof(flouble)); - memcpy(rf_i,par->kmap->rf,par->kmap->nr*sizeof(flouble)); - - int *i_sorted=ind_sort(par->kmap->nr,par->kmap->r0); - for(ir=0;irkmap->nr;ir++) { - par->kmap->r0[ir]=r0_i[i_sorted[ir]]; - par->kmap->rf[ir]=rf_i[i_sorted[ir]]; - } - free(r0_i); - free(rf_i); - free(i_sorted); - - //Zero all data and clear -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par) -#endif //_HAVE_OMP - { - long ipp; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ipp=0;ippkmap->num_pix*par->kmap->nr;ipp++) { - par->kmap->data[ipp]=0; - par->kmap->nadd[ipp]=1; - } //end omp for - } //end omp parallel - - return; -} - -void kappa_get_beam_properties(ParamCoLoRe *par) -{ - HealpixShells *kmap=par->kmap; - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,kmap) -#endif //_HAVE_OMP - { - double idx=par->n_grid/par->l_box; - - //Setup radial decomposition - int i_r,nr; - double idr,dr; - get_radial_params(par->r_max,par->n_grid,&nr,&dr); - idr=1./dr; - - //Compute index of each source plane - int *i_r_max_arr=my_malloc(kmap->nr*sizeof(int)); - int *i_r_min_arr=my_malloc(kmap->nr*sizeof(int)); - double *inv_r_max=my_malloc(kmap->nr*sizeof(double)); - for(i_r=0;i_rnr;i_r++) { - int i_r_here=(int)(kmap->rf[i_r]*idr+0.5); - inv_r_max[i_r]=1./(i_r_here*dr); - i_r_max_arr[i_r]=MIN(i_r_here,nr-1); - } - i_r_min_arr[0]=0; - for(i_r=1;i_rnr;i_r++) - i_r_min_arr[i_r]=i_r_max_arr[i_r-1]+1; - - //Fill up integral kernels - double *fac_r_1=my_malloc(nr*sizeof(double)); - double *fac_r_2=my_malloc(nr*sizeof(double)); - for(i_r=0;i_rnum_pix;ip++) { - int ax,added; - flouble t[6]; - double rot[6],xn[3]; - double kappa_1=0,kappa_2=0; - double *u=&(kmap->pos[3*ip]); - double prefac=idx*idx; - double cth_h=1,sth_h=0,cph_h=1,sph_h=0; - - cth_h=u[2]; - if(cth_h>=1) cth_h=1; - if(cth_h<=-1) cth_h=-1; - sth_h=sqrt((1-cth_h)*(1+cth_h)); - if(sth_h!=0) { - cph_h=u[0]/sth_h; - sph_h=u[1]/sth_h; - } - - rot[0]=(cth_h*cth_h*cph_h*cph_h+sph_h*sph_h)*prefac; - rot[1]=(2*cph_h*sph_h*(cth_h*cth_h-1))*prefac; - rot[2]=(-2*cth_h*sth_h*cph_h)*prefac; - rot[3]=(cth_h*cth_h*sph_h*sph_h+cph_h*cph_h)*prefac; - rot[4]=(-2*cth_h*sth_h*sph_h)*prefac; - rot[5]=(sth_h*sth_h)*prefac; - for(i_r=0;i_rnr;i_r++) { - int irr; - int irmin=i_r_min_arr[i_r]; - int irmax=i_r_max_arr[i_r]; - for(irr=irmin;irr<=irmax;irr++) { - double rm=(irr+0.5)*dr; - for(ax=0;ax<3;ax++) - xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; - added=interpolate_from_grid(par,xn,NULL,NULL,t,NULL,NULL,RETURN_TID,INTERP_TYPE_LENSING); - if(added) { - double dotp=0; - for(ax=0;ax<6;ax++) - dotp+=rot[ax]*t[ax]; - kappa_1+=dotp*fac_r_1[irr]; - kappa_2+=dotp*fac_r_2[irr]; - } - } - kmap->data[i_r*kmap->num_pix+ip]+=(kappa_1-inv_r_max[i_r]*kappa_2); - } - } //end omp for - - free(fac_r_1); - free(fac_r_2); - free(i_r_max_arr); - free(i_r_min_arr); - free(inv_r_max); - } //end omp parallel - - return; -} - -void kappa_beams_postproc(ParamCoLoRe *par) -{ - //Set rf to end of cell - return; -} diff --git a/src/.ipynb_checkpoints/lensing-checkpoint.c b/src/.ipynb_checkpoints/lensing-checkpoint.c deleted file mode 100644 index ea2f7a0..0000000 --- a/src/.ipynb_checkpoints/lensing-checkpoint.c +++ /dev/null @@ -1,256 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -void lensing_set_cartesian(ParamCoLoRe *par) -{ - return; -} - -void lensing_get_local_properties(ParamCoLoRe *par) -{ - return; -} - -void lensing_distribute(ParamCoLoRe *par) -{ - return; -} - -void lensing_beams_preproc(ParamCoLoRe *par) -{ - //Sort radii in ascending order - int ir; - flouble *r_i=my_malloc(par->smap->nr*sizeof(flouble)); - - memcpy(r_i,par->smap->r,par->smap->nr*sizeof(flouble)); - - int *i_sorted=ind_sort(par->smap->nr,par->smap->r); - for(ir=0;irsmap->nr;ir++) { - par->smap->r[ir]=r_i[i_sorted[ir]]; - } - free(r_i); - free(i_sorted); - - //Zero all data and clear -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par) -#endif //_HAVE_OMP - { - long ir, ib, ipp; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ir=0;irsmap->nr;ir++) { - for(ib=0;ibsmap->nbeams;ib++) { - for(ipp=0;ipp<5*par->smap->num_pix_per_beam[ir];ipp++) - par->smap->data[ib][ir][ipp]=0; - } - } //end omp for - } //end omp parallel - - return; -} - -void lensing_get_beam_properties(ParamCoLoRe *par) -{ - HealpixShellsAdaptive *smap=par->smap; - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,smap) -#endif //_HAVE_OMP - { - double idx=par->n_grid/par->l_box; - long npix_hi=smap->num_pix_per_beam[smap->nr-1]; - - //Setup radial decomposition - int i_r,nr; - double idr,dr; - get_radial_params(par->r_max,par->n_grid,&nr,&dr); - idr=1./dr; - - //Compute index of each source plane - int *i_r_max_arr=my_malloc(smap->nr*sizeof(int)); - int *i_r_min_arr=my_malloc(smap->nr*sizeof(int)); - long *npix_ratio=my_malloc(smap->nr*sizeof(long)); - double *inv_npix_ratio=my_malloc(smap->nr*sizeof(double)); - double *inv_r_max=my_malloc(smap->nr*sizeof(double)); - for(i_r=0;i_rnr;i_r++) { - int i_r_here=(int)(smap->r[i_r]*idr+0.5); - inv_r_max[i_r]=1./(i_r_here*dr); - i_r_max_arr[i_r]=MIN(i_r_here,nr-1); - npix_ratio[i_r]=npix_hi/smap->num_pix_per_beam[i_r]; - inv_npix_ratio[i_r]=1./((double)(npix_ratio[i_r])); - } - - i_r_min_arr[0]=0; - for(i_r=1;i_rnr;i_r++) - i_r_min_arr[i_r]=i_r_max_arr[i_r-1]+1; - - //Fill up integral kernels - double *fac_r_0=my_malloc(nr*sizeof(double)); - double *fac_r_1=my_malloc(nr*sizeof(double)); - double *fac_r_2=my_malloc(nr*sizeof(double)); - for(i_r=0;i_rnbeams;ib++) { - //We loop over all pixels in the last plane (since this has the - //highest resolution). - long ip; -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ip=0;ippos[ib][3*ip]); - double prefac=idx*idx; //1/Dx^2 - double prefac_m=0.5*idx; //1/(2 * Dx) - double cth_h=1,sth_h=0,cph_h=1,sph_h=0; - - cth_h=u[2]; - if(cth_h>=1) cth_h=1; - if(cth_h<=-1) cth_h=-1; - sth_h=sqrt((1-cth_h)*(1+cth_h)); - if(sth_h!=0) { - cph_h=u[0]/sth_h; - sph_h=u[1]/sth_h; - } - - u_x[0]=cth_h*cph_h*prefac_m; - u_x[1]=cth_h*sph_h*prefac_m; - u_x[2]=-sth_h*prefac_m; - - u_y[0]=-sph_h*prefac_m; - u_y[1]=cph_h*prefac_m; - u_y[2]=0; - - r_k[0] =(cth_h*cth_h*cph_h*cph_h+sph_h*sph_h)*prefac; - r_k[1] =(2*cph_h*sph_h*(cth_h*cth_h-1))*prefac; - r_k[2] =(-2*cth_h*sth_h*cph_h)*prefac; - r_k[3] =(cth_h*cth_h*sph_h*sph_h+cph_h*cph_h)*prefac; - r_k[4] =(-2*cth_h*sth_h*sph_h)*prefac; - r_k[5] =(sth_h*sth_h)*prefac; - - r_e1[0]=(cth_h*cth_h*cph_h*cph_h-sph_h*sph_h)*prefac; - r_e1[1]=(2*cph_h*sph_h*(cth_h*cth_h+1))*prefac; - r_e1[2]=(-2*cth_h*sth_h*cph_h)*prefac; - r_e1[3]=(cth_h*cth_h*sph_h*sph_h-cph_h*cph_h)*prefac; - r_e1[4]=(-2*cth_h*sth_h*sph_h)*prefac; - r_e1[5]=(sth_h*sth_h)*prefac; - - r_e2[0]=(-2*cth_h*cph_h*sph_h)*prefac; - r_e2[1]=(2*cth_h*(cph_h*cph_h-sph_h*sph_h))*prefac; - r_e2[2]=(2*sth_h*sph_h)*prefac; - r_e2[3]=(2*cth_h*sph_h*cph_h)*prefac; - r_e2[4]=(-2*sth_h*cph_h)*prefac; - r_e2[5]=0; - for(i_r=0;i_rnr;i_r++) { - int irr; - int irmin=i_r_min_arr[i_r]; - int irmax=i_r_max_arr[i_r]; - long ipix_this=ip/npix_ratio[i_r]; - for(irr=irmin;irr<=irmax;irr++) { - double rm=(irr+0.5)*dr; - for(ax=0;ax<3;ax++) - xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; - added=interpolate_from_grid(par,xn,NULL,v,t,NULL,NULL,RETURN_VEL | RETURN_TID, - INTERP_TYPE_LENSING); - if(added) { - double dotk=0,dote1=0,dote2=0,dotvx=0,dotvy=0; - for(ax=0;ax<6;ax++) { - dote1+=r_e1[ax]*t[ax]; - dote2+=r_e2[ax]*t[ax]; - dotk +=r_k[ax]*t[ax]; - } - for(ax=0;ax<3;ax++) { - dotvx+=u_x[ax]*v[ax]; - dotvy+=u_y[ax]*v[ax]; - } - dx_0+=dotvx*fac_r_0[irr]; - dx_1+=dotvx*fac_r_1[irr]; - dy_0+=dotvy*fac_r_0[irr]; - dy_1+=dotvy*fac_r_1[irr]; - kappa_1+=dotk*fac_r_1[irr]; - kappa_2+=dotk*fac_r_2[irr]; - shear1_1+=dote1*fac_r_1[irr]; - shear1_2+=dote1*fac_r_2[irr]; - shear2_1+=dote2*fac_r_1[irr]; - shear2_2+=dote2*fac_r_2[irr]; - } - } - if(ipix_this>=smap->num_pix_per_beam[i_r]) { - printf("SHIT\n"); - exit(1); - } - smap->data[ib][i_r][5*ipix_this+0]+=(shear1_1-inv_r_max[i_r]*shear1_2)*inv_npix_ratio[i_r]; - smap->data[ib][i_r][5*ipix_this+1]+=(shear2_1-inv_r_max[i_r]*shear2_2)*inv_npix_ratio[i_r]; - smap->data[ib][i_r][5*ipix_this+2]+=(kappa_1-inv_r_max[i_r]*kappa_2)*inv_npix_ratio[i_r]; - smap->data[ib][i_r][5*ipix_this+3]+=2*(dx_0-inv_r_max[i_r]*dx_1)*inv_npix_ratio[i_r]; - smap->data[ib][i_r][5*ipix_this+4]+=2*(dy_0-inv_r_max[i_r]*dy_1)*inv_npix_ratio[i_r]; - } - } //end omp for - } - -#ifdef _HAVE_OMP -#pragma omp single -#endif //_HAVE_OMP - { - for(i_r=0;i_rnr;i_r++) - smap->r[i_r]=1./inv_r_max[i_r]; - } - - free(fac_r_0); - free(fac_r_1); - free(fac_r_2); - free(i_r_max_arr); - free(i_r_min_arr); - free(inv_r_max); - free(npix_ratio); - free(inv_npix_ratio); - } //end omp parallel - - return; -} - -void lensing_beams_postproc(ParamCoLoRe *par) -{ - //Set rf to end of cell - return; -} diff --git a/src/.ipynb_checkpoints/main-checkpoint.c b/src/.ipynb_checkpoints/main-checkpoint.c deleted file mode 100644 index 12072c2..0000000 --- a/src/.ipynb_checkpoints/main-checkpoint.c +++ /dev/null @@ -1,154 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -int main(int argc,char **argv) -{ - int test_memory=0; - char fnameIn[256]; - ParamCoLoRe *par; - if(argc<2) { - fprintf(stderr,"Usage: ./CoLoRe file_name\n"); - exit(0); - } - if(!strcmp(argv[1],"--test-memory")) { - test_memory=1; - sprintf(fnameIn,"%s",argv[2]); - } - else - sprintf(fnameIn,"%s",argv[1]); - - mpi_init(&argc,&argv); - - setbuf(stdout,NULL); - print_info("\n"); - print_info("|-------------------------------------------------|\n"); - print_info("| CoLoRe |\n"); - print_info("|-------------------------------------------------|\n\n"); - - if(NodeThis==0) timer(4); - - par=read_run_params(fnameIn,test_memory); - if(par==NULL) { - if(NodeThis==0) timer(5); -#ifdef _HAVE_MPI - MPI_Finalize(); -#endif //_HAVE_MPI - return 0; - } - - print_info("Seed : %u\n",par->seed_rng); - - if(par->do_pred) - write_predictions(par); - if(!(par->just_do_pred)) { - - //Create Gaussian density and radial velocity fields - create_cartesian_fields(par); - - //Lognormalize density field - compute_physical_density_field(par); - - //Compute normalization of density field for biasing - compute_density_normalization(par); - - //Get information from slabs - if(par->do_kappa) - kappa_set_cartesian(par); -#ifdef _USE_FAST_LENSING - if(par->do_lensing) - lensing_set_cartesian(par); -#endif //_USE_FAST_LENSING - if(par->do_isw) - isw_set_cartesian(par); - if(par->do_srcs) - srcs_set_cartesian(par); - if(par->do_imap) - imap_set_cartesian(par); - if(par->do_cstm) - cstm_set_cartesian(par); - - //Distribute information across - if(par->do_kappa) - kappa_distribute(par); -#ifdef _USE_FAST_LENSING - if(par->do_lensing) - lensing_distribute(par); -#endif //_USE_FAST_LENSING - if(par->do_isw) - isw_distribute(par); - if(par->do_srcs) - srcs_distribute(par); - if(par->do_imap) - imap_distribute(par); - if(par->do_cstm) - cstm_distribute(par); - - //Postprocess after - if(par->do_kappa) - kappa_get_local_properties(par); -#ifdef _USE_FAST_LENSING - if(par->do_lensing) - lensing_get_local_properties(par); -#endif //_USE_FAST_LENSING - if(par->do_isw) - isw_get_local_properties(par); - if(par->do_srcs) - srcs_get_local_properties(par); - if(par->do_imap) - imap_get_local_properties(par); - if(par->do_cstm) - cstm_get_local_properties(par); - - //All-to-all communication of density field - //and computation of all required quantities - if(par->need_beaming) - get_beam_properties(par); - - //Write output - if(par->do_kappa) - write_kappa(par); -#ifdef _USE_FAST_LENSING - if(par->do_lensing && par->write_lensing) - write_lensing(par); -#endif ///_USE_FAST_LENSING - if(par->do_isw) - write_isw(par); - if(par->do_srcs) - write_srcs(par); - if(par->do_imap) - write_imap(par); - if(par->do_cstm) - write_cstm(par); - } - - print_info("\n"); - print_info("|-------------------------------------------------|\n\n"); - - param_colore_free(par); - - if(NodeThis==0) timer(5); -#ifdef _HAVE_MPI - MPI_Finalize(); -#endif //_HAVE_MPI - return 0; -} diff --git a/src/.ipynb_checkpoints/predictions-checkpoint.c b/src/.ipynb_checkpoints/predictions-checkpoint.c deleted file mode 100644 index 70b59d0..0000000 --- a/src/.ipynb_checkpoints/predictions-checkpoint.c +++ /dev/null @@ -1,173 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso, Anze Slosar // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// - -#include "common.h" -#include "fftlog.h" - -void write_predictions(ParamCoLoRe *par) -{ - if ((!par->do_srcs) && (!par->do_imap) && (!par->do_cstm)) return; - if (NodeThis!=0) return; - print_info("*** Writing predictions\n"); - // first generate k array, sufficiently finely spaced - // note that we need to sufficiently pad on both ends - const int Nk=10000; - const double kmin=1e-4; - const double kmax=100; - const double kminout=kmin; - const double kmaxout=kmax; - const double rminout=0.5; - const double rmaxout=300.; - double *ka=my_malloc(Nk*sizeof(double)); - double *pk=my_malloc(Nk*sizeof(double)); - double *pklin=my_malloc(Nk*sizeof(double)); - double *ra=my_malloc(Nk*sizeof(double)); - double *xi=my_malloc(Nk*sizeof(double)); - double *xilin=my_malloc(Nk*sizeof(double)); - for (int i=0; ir2_smooth+0.9*pow(par->l_box/par->n_grid,2)/12.; - double rsm2_gm=par->r2_smooth+2.0*pow(par->l_box/par->n_grid,2)/6.; - double rsm2_mm=par->r2_smooth+1.88*pow(par->l_box/par->n_grid,2)/6.; - sprintf(gbiasfn,"%s_gbias.txt",par->prefixOut); - fg=fopen(gbiasfn,"w"); - fprintf (fg,"#1-z 2-r(z) 3-g(z) "); - for (int ipop=0; ipopn_srcs; ipop++) - fprintf(fg,"%d-bg_%d(z) ",ipop+4,ipop+1); - for (int ipop=0; ipopn_imap; ipop++) - fprintf(fg,"%d-bi_%d(z) ",ipop+4+par->n_srcs,ipop+1); - for (int ipop=0; ipopn_cstm; ipop++) - fprintf(fg,"%d-bc_%d(z) ",ipop+4+par->n_srcs+par->n_imap,ipop+1); - fprintf(fg,"\n"); - - // outter loop is over redshifts - for (double z=0; z<=par->z_max; z+=par->pred_dz) { - double r=r_of_z(par,z); - double g=get_bg(par,r,BG_D1,0); - fprintf (fg,"%g %g %g ",z,r,g); - for (int i=0; ido_srcs) { - for (int ipop=0; ipopn_srcs; ipop++) { - double bias=get_bg(par,r,BG_BZ_SRCS,ipop); - fprintf(fg,"%g ",bias); -#ifdef _DEBUG - print_info (" Population %i, bias %g. \n",ipop,bias); -#endif //_DEBUG - for (int i=0; iprefixOut,ipop,z); - sprintf(fnamexi,"%s_xi_srcs_pop%i_z%.3lf.txt",par->prefixOut,ipop,z); - fpk=fopen(fnamepk,"w"); - fprintf (fpk, "# k[h/Mpc] P_tt P_tl P_ll\n"); - fxi=fopen(fnamexi,"w"); - fprintf (fxi, "# r[Mpc/h] xi_tt xi_ll*b^2 xi_ll\n"); - for (int i=0; i=kminout) && (ka[i]<=kmaxout)) - fprintf (fpk,"%g %g %g %g\n",ka[i],pk[i], pklin[i]*bias*exp(-rsm2_gm*ka[i]*ka[i]), pklin[i]*exp(-rsm2_mm*ka[i]*ka[i])); - if ((ra[i]>=rminout) && (ra[i]<=rmaxout)) - fprintf (fxi,"%g %g %g %g\n",ra[i], xi[i], - xilin[i]*bias, xilin[i]); - } - fclose(fpk); - fclose(fxi); - } - } - if(par->do_imap) { - for (int ipop=0; ipopn_imap; ipop++) { - double bias=get_bg(par,r,BG_BZ_IMAP,ipop); - fprintf(fg,"%g ",bias); -#ifdef _DEBUG - print_info (" Population %i, bias %g. \n",ipop,bias); -#endif //_DEBUG - for (int i=0; iprefixOut,ipop,z); - sprintf(fnamexi,"%s_xi_imap_pop%i_z%.3lf.txt",par->prefixOut,ipop,z); - fpk=fopen(fnamepk,"w"); - fprintf (fpk, "# k[h/Mpc] P_tt P_tl P_ll\n"); - fxi=fopen(fnamexi,"w"); - fprintf (fxi, "# k[Mpc/h] xi_tt xi_ll*b^2 xi_ll\n"); - for (int i=0; i=kminout) && (ka[i]<=kmaxout)) - fprintf (fpk,"%g %g %g %g\n",ka[i],pk[i], - pklin[i]*bias*exp(-rsm2_gm*ka[i]*ka[i]), - pklin[i]*exp(-rsm2_mm*ka[i]*ka[i])); - if ((ra[i]>=rminout) && (ra[i]<=rmaxout)) - fprintf (fxi,"%g %g %g %g\n",ra[i],xi[i], xilin[i]*bias, xilin[i]); - } - fclose(fpk); - fclose(fxi); - } - } - if(par->do_cstm) { - for (int ipop=0; ipopn_cstm; ipop++) { - double bias=get_bg(par,r,BG_BZ_CSTM,ipop); - fprintf(fg,"%g ",bias); -#ifdef _DEBUG - print_info (" Population %i, bias %g. \n",ipop,bias); -#endif //_DEBUG - for (int i=0; iprefixOut,ipop,z); - sprintf(fnamexi,"%s_xi_custom_pop%i_z%.3lf.txt",par->prefixOut,ipop,z); - fpk=fopen(fnamepk,"w"); - fprintf (fpk, "# k[h/Mpc] P_tt P_tl P_ll\n"); - fxi=fopen(fnamexi,"w"); - fprintf (fxi, "# k[Mpc/h] xi_tt xi_ll*b^2 xi_ll\n"); - for (int i=0; i=kminout) && (ka[i]<=kmaxout)) - fprintf (fpk,"%g %g %g %g\n",ka[i],pk[i], - pklin[i]*bias*exp(-rsm2_gm*ka[i]*ka[i]), - pklin[i]*exp(-rsm2_mm*ka[i]*ka[i])); - if ((ra[i]>=rminout) && (ra[i]<=rmaxout)) - fprintf (fxi,"%g %g %g %g\n",ra[i],xi[i], xilin[i]*bias, xilin[i]); - } - fclose(fpk); - fclose(fxi); - } - } - fprintf(fg,"\n"); - } - fclose(fg); - free(ka); - free(pk); - free(pklin); - free(ra); - free(xi); - free(xilin); -} diff --git a/src/.ipynb_checkpoints/srcs-checkpoint.c b/src/.ipynb_checkpoints/srcs-checkpoint.c deleted file mode 100644 index 4bb5797..0000000 --- a/src/.ipynb_checkpoints/srcs-checkpoint.c +++ /dev/null @@ -1,763 +0,0 @@ -/////////////////////////////////////////////////////////////////////// -// // -// Copyright 2012 David Alonso // -// // -// // -// This file is part of CoLoRe. // -// // -// CoLoRe is free software: you can redistribute it and/or modify it // -// under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 3 of the License, or // -// (at your option) any later version. // -// // -// CoLoRe is distributed in the hope that it will be useful, but // -// WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with CoLoRe. If not, see . // -// // -/////////////////////////////////////////////////////////////////////// -#include "common.h" - -#ifdef _USE_FAST_LENSING -static int get_r_index_lensing(HealpixShellsAdaptive *sh,double r,int ir_start) -{ - int gotit=0; - int ir0; - if(ir_start<0) - ir0=0; - else if(ir_start>=sh->nr) - ir0=sh->nr-1; - else - ir0=ir_start; - - while(!gotit) { - if(ir0==0) { - if(rr[1]) - gotit=1; - else - ir0++; - } - else if(ir0==sh->nr-1) { - if(r>=sh->r[sh->nr-2]) { - ir0=sh->nr-2; - gotit=1; - } - else - ir0--; - } - else { - if(rr[ir0]) - ir0--; - else { - if(r>=sh->r[ir0+1]) - ir0++; - else - gotit=1; - } - } - } - - return ir0; -} -#endif //_USE_FAST_LENSING - - -static inline void cart2sph(double x,double y,double z,double *r,double *cth,double *phi) -{ - *r=sqrt(x*x+y*y+z*z); - - if((*r)==0) { - *cth=1; - *phi=0; - } - else { - double xn=x/(*r); - double yn=y/(*r); - - *cth=z/(*r); - *phi=atan2(yn,xn); - if((*phi)<0) - (*phi)+=2*M_PI; - } -} - -static void get_rvel(ParamCoLoRe *par,int ix,int iy,int iz, - double x0,double y0,double z0,double rr, - double* rvel, double* vtheta, double* vphi) -{ - double v[3],u[3]; - double idx=par->n_grid/par->l_box; - long ngx=2*(par->n_grid/2+1); - long iz_hi=iz+1,iz_lo=iz-1,iz_0=iz; - long iy_hi=iy+1,iy_lo=iy-1,iy_0=iy; - long ix_hi=ix+1,ix_lo=ix-1,ix_0=ix; - if(iy==0) iy_lo=par->n_grid-1; - if(iy==par->n_grid-1) iy_hi=0; - if(ix==0) ix_lo=par->n_grid-1; - if(ix==par->n_grid-1) ix_hi=0; - iz_0*=ngx*par->n_grid; - iz_lo*=ngx*par->n_grid; - iz_hi*=ngx*par->n_grid; - iy_0*=ngx; - iy_lo*=ngx; - iy_hi*=ngx; - - u[0]=x0/rr; u[1]=y0/rr; u[2]=z0/rr; - v[0]=par->grid_npot[ix_hi+iy_0+iz_0]-par->grid_npot[ix_lo+iy_0+iz_0]; - v[1]=par->grid_npot[ix_0+iy_hi+iz_0]-par->grid_npot[ix_0+iy_lo+iz_0]; - if(iz==0) - v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->slice_left[ix_0+iy_0]; - else if(iz==par->nz_here-1) - v[2]=par->slice_right[ix_0+iy_0]-par->grid_npot[ix_0+iy_0+iz_lo]; - else - v[2]=par->grid_npot[ix_0+iy_0+iz_hi]-par->grid_npot[ix_0+iy_0+iz_lo]; - - *rvel = 0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); -#ifdef TVEL - *vtheta = 0.5*idx*(v[0]*(u[0]*u[2]/sqrt(1-u[2]*u[2]))+v[1]*(u[1]*u[2]/sqrt(1-u[2]*u[2]))+v[2]*(-sqrt(1-u[2]*u[2]))); - *vphi = 0.5*idx*(v[0]*(-u[1]/sqrt(1-u[2]*u[2]))+v[1]*(u[0]/sqrt(1-u[2]*u[2]))); -#endif - -} - -static void srcs_set_cartesian_single(ParamCoLoRe *par,int ipop) -{ - int ii,nthr; - int ngx=2*(par->n_grid/2+1); - long *np_tot_thr; - int *nsources=my_calloc(ngx*((long)(par->n_grid*par->nz_here)),sizeof(int)); -#ifdef _HAVE_OMP - nthr=omp_get_max_threads(); -#else //_HAVE_OMP - nthr=1; -#endif //_HAVE_OMP - np_tot_thr=my_calloc(nthr,sizeof(long)); - - print_info(" %d-th galaxy population\n",ipop); - if(NodeThis==0) timer(0); - print_info(" Poisson-sampling\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,np_tot_thr,IThread0,ipop,nthr,nsources) -#endif //_HAVE_OMP - { - long iz; -#ifdef _HAVE_OMP - int ithr=omp_get_thread_num(); -#else //_HAVE_OMP - int ithr=0; -#endif //_HAVE_OMP - double dx=par->l_box/par->n_grid; - double cell_vol=dx*dx*dx; - int ngx=2*(par->n_grid/2+1); - unsigned int seed_thr=par->seed_rng+ithr+nthr*(ipop+par->n_srcs*IThread0); - gsl_rng *rng_thr=init_rng(seed_thr); - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - double z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - double y0=(iy+0.5)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - int npp=0; - long index=ix+indexy+indexz; - double x0=(ix+0.5)*dx-par->pos_obs[0]; - double r=sqrt(x0*x0+y0*y0+z0*z0); - if(rl_box/2+20.) { - double ndens=get_bg(par,r,BG_NZ_SRCS,ipop); - if(ndens>0) { - double bias=get_bg(par,r,BG_BZ_SRCS,ipop); - double dnorm=get_bg(par,r,BG_NORM_SRCS,ipop); - double lambda=ndens*cell_vol*bias_model(par->grid_dens[index],bias)*dnorm; - //double lambda=ndens*cell_vol*dnorm; - npp=rng_poisson(lambda,rng_thr); - } - } - - nsources[index]=npp; - np_tot_thr[ithr]+=npp; - } - } - }//end omp for - - end_rng(rng_thr); - }//end omp parallel - - par->nsources_c_this[ipop]=0; - for(ii=0;iinsources_c_this[ipop]+=np_tot_thr[ii]; - - long nsources_total=0; -#ifdef _HAVE_MPI - MPI_Allreduce(&(par->nsources_c_this[ipop]),&nsources_total,1,MPI_LONG,MPI_SUM,MPI_COMM_WORLD); -#else //_HAVE_MPI - nsources_total=par->nsources_c_this[ipop]; -#endif //_HAVE_MPI - - print_info(" There will be %ld objects in total \n",(long)nsources_total); -#ifdef _DEBUG - fprintf(par->f_dbg,"MPI task %d has %ld particles\n",NodeThis,(long)(par->nsources_c_this[ipop])); -#endif //_DEBUG - - for(ii=nthr-1;ii>0;ii--) { - int jj; - long nh=0; - for(jj=0;jjcats_c[ipop]=catalog_cartesian_alloc(par->nsources_c_this[ipop]); - - print_info(" Assigning coordinates\n"); -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,IThread0,np_tot_thr,ipop,nthr,nsources) -#endif //_HAVE_OMP - { - long iz; -#ifdef _HAVE_OMP - int ithr=omp_get_thread_num(); -#else //_HAVE_OMP - int ithr=0; -#endif //_HAVE_OMP - double dx=par->l_box/par->n_grid; - int ngx=2*(par->n_grid/2+1); - unsigned int seed_thr=par->seed_rng+ithr+nthr*(ipop+par->n_srcs*IThread0); - gsl_rng *rng_thr=init_rng(seed_thr); - double factor_vel=-par->fgrowth_0/(1.5*par->hubble_0*par->OmegaM); - -#ifdef _HAVE_OMP -#pragma omp for schedule(static) -#endif //_HAVE_OMP - for(iz=0;iznz_here;iz++) { - int iy; - long indexz=iz*((long)(ngx*par->n_grid)); - double z0=(iz+par->iz0_here+0.5)*dx-par->pos_obs[2]; - for(iy=0;iyn_grid;iy++) { - int ix; - long indexy=iy*ngx; - double y0=(iy+0.5)*dx-par->pos_obs[1]; - for(ix=0;ixn_grid;ix++) { - double x0=(ix+0.5)*dx-par->pos_obs[0]; - long index=ix+indexy+indexz; - int npp=nsources[index]; - if(npp>0) { - int ip; - double rr=sqrt(x0*x0+y0*y0+z0*z0); - double rvel, vtheta, vphi; - get_rvel(par,ix,iy,iz,x0,y0,z0,rr, &rvel, &vtheta, &vphi); - rvel *=factor_vel; - double dz_rsd=rvel*get_bg(par,rr,BG_V1,0); - for(ip=0;ipcats_c[ipop]->pos[NPOS_CC*pid+0]=x0+dx*(rng_01(rng_thr)-0.5); - par->cats_c[ipop]->pos[NPOS_CC*pid+1]=y0+dx*(rng_01(rng_thr)-0.5); - par->cats_c[ipop]->pos[NPOS_CC*pid+2]=z0+dx*(rng_01(rng_thr)-0.5); - par->cats_c[ipop]->pos[NPOS_CC*pid+3]=dz_rsd; - #ifdef TVEL - par->cats_c[ipop]->pos[NPOS_CC*pid+4]=vtheta; - par->cats_c[ipop]->pos[NPOS_CC*pid+5]=vphi; - #endif - - - for(ax=0;ax<3;ax++) - pos[ax]=par->cats_c[ipop]->pos[NPOS_CC*pid+ax]; - - vec2pix_ring(par->nside_base,pos,&pix_id_ring); - ring2nest(par->nside_base,pix_id_ring,&pix_id_nest); - par->cats_c[ipop]->ipix[pid]=pix_id_nest; - np_tot_thr[ithr]++; - } - } - } - } - }//end omp for - end_rng(rng_thr); - }//end omp parallel - if(NodeThis==0) timer(2); - - free(np_tot_thr); - free(nsources); -} - -void srcs_set_cartesian(ParamCoLoRe *par) -{ - int ipop; - - //First, compute lensing Hessian - print_info("*** Getting point sources\n"); - for(ipop=0;ipopn_srcs;ipop++) - srcs_set_cartesian_single(par,ipop); - print_info("\n"); -} - -static void srcs_distribute_single(ParamCoLoRe *par,int ipop) -{ - int ii; - long *ns_to_nodes=my_calloc(NNodes,sizeof(long)); - long *i0_in_nodes=my_calloc(NNodes,sizeof(long)); - long *ns_transfer_matrix=my_calloc(NNodes*NNodes,sizeof(long)); - CatalogCartesian *cat=par->cats_c[ipop]; - - //Count how many objects need to be sent to each node - for(ii=0;iinsources_c_this[ipop];ii++) { - int i_node=cat->ipix[ii]%NNodes; - ns_to_nodes[i_node]++; - } - - //Gather all transfers into a 2D array -#ifdef _HAVE_MPI - MPI_Allgather(ns_to_nodes,NNodes,MPI_LONG, - ns_transfer_matrix,NNodes,MPI_LONG,MPI_COMM_WORLD); -#else //_HAVE_MPI - ns_transfer_matrix[0]=ns_to_nodes[0]; -#endif //_HAVE_MPI - - //Calculate position of each particle going to each node - for(ii=0;iinsources_c_this[ipop]*sizeof(float)); - for(ii=0;iinsources_c_this[ipop];ii++) { - int ax; - int i_node=cat->ipix[ii]%NNodes; - long id_here=ns_to_nodes[i_node]; - for(ax=0;axpos[NPOS_CC*ii+ax]; - ns_to_nodes[i_node]++; - } - - //Count particles this node will receive - par->nsources_this[ipop]=0; - for(ii=0;iinsources_this[ipop]+=ns_transfer_matrix[ii*NNodes+NodeThis]; - - //Loop through all nodes and receive particles - //Free up old catalog and create new one - catalog_cartesian_free(par->cats_c[ipop]); - par->cats_c[ipop]=catalog_cartesian_alloc(par->nsources_this[ipop]); - par->nsources_c_this[ipop]=par->nsources_this[ipop]; - long i_sofar=0; - for(ii=0;ii%d from->%d.",NodeThis,ii,node_to,node_from); - // print_info(" Should get %07ld objects, and will send %07ld.\n",npart_recv,npart_send); -#ifdef _HAVE_MPI - MPI_Sendrecv(&(pos_ordered[NPOS_CC*i0_in_nodes[node_to]]),NPOS_CC*npart_send,MPI_FLOAT,node_to ,ii, - &(par->cats_c[ipop]->pos[NPOS_CC*i_sofar]) ,NPOS_CC*npart_recv,MPI_FLOAT,node_from,ii, - MPI_COMM_WORLD,MPI_STATUS_IGNORE); -#else //_HAVE_MPI - memcpy(&(par->cats_c[ipop]->pos[NPOS_CC*i_sofar]),&(pos_ordered[NPOS_CC*i0_in_nodes[node_to]]), - NPOS_CC*npart_send*sizeof(float)); -#endif //_HAVE_MPI - i_sofar+=npart_recv; - // print_info(" %07ld sources gathered so far\n",i_sofar); - } - - free(pos_ordered); - free(i0_in_nodes); - free(ns_to_nodes); - free(ns_transfer_matrix); -} - -void srcs_distribute(ParamCoLoRe *par) -{ - if(NodeThis==0) timer(0); - int ipop; - print_info("*** Re-distributing sources across nodes\n"); - for(ipop=0;ipopn_srcs;ipop++) - srcs_distribute_single(par,ipop); - if(NodeThis==0) timer(2); - print_info("\n"); -} - -static void srcs_get_local_properties_single(ParamCoLoRe *par,int ipop) -{ - par->cats[ipop]=catalog_alloc(par->cats_c[ipop]->nsrc, - par->lensing_srcs[ipop], - par->skw_srcs[ipop], - par->skw_gauss[ipop], - par->r_max,par->n_grid); - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,ipop) -#endif //_HAVE_OMP - { - int ii; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iicats[ipop]->nsrc;ii++) { - double r,cth,phi; - float *pos=&(par->cats_c[ipop]->pos[NPOS_CC*ii]); - cart2sph(pos[0],pos[1],pos[2],&r,&cth,&phi); - par->cats[ipop]->srcs[ii].ra=RTOD*phi; - par->cats[ipop]->srcs[ii].dec=90-RTOD*acos(cth); - par->cats[ipop]->srcs[ii].z0=get_bg(par,r,BG_Z,0); - par->cats[ipop]->srcs[ii].dz_rsd=pos[3]; - #ifdef TVEL - par->cats[ipop]->srcs[ii].vtheta=pos[4]; - par->cats[ipop]->srcs[ii].vphi=pos[5]; - #endif - - par->cats[ipop]->srcs[ii].e1=-1; - par->cats[ipop]->srcs[ii].e2=-1; - }//end omp for - }//end omp parallel -} - -void srcs_get_local_properties(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_srcs;ipop++) - srcs_get_local_properties_single(par,ipop); -} - -static void srcs_beams_preproc_single(ParamCoLoRe *par,int ipop) -{ -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,ipop) -#endif //_HAVE_OMP - { - int ii; - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iicats[ipop]->nsrc;ii++) { - par->cats[ipop]->srcs[ii].dz_rsd=0; - par->cats[ipop]->srcs[ii].e1=0; - par->cats[ipop]->srcs[ii].e2=0; - }//end omp for - }//end omp parallel -} - -void srcs_beams_preproc(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_srcs;ipop++) - srcs_beams_preproc_single(par,ipop); -} - -static void srcs_get_beam_properties_single(ParamCoLoRe *par,int ipop) -{ - Catalog *cat=par->cats[ipop]; - CatalogCartesian *catc=par->cats_c[ipop]; - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,cat,catc) -#endif //_HAVE_OMP - { - long ip; - double idx=par->n_grid/par->l_box; - - //Kernels for the LOS integrals -#ifndef _USE_FAST_LENSING - double *fac_r_0=NULL,*fac_r_1=NULL,*fac_r_2=NULL; - if(cat->has_lensing) { - fac_r_0=my_malloc(cat->nr*sizeof(double)); - fac_r_1=my_malloc(cat->nr*sizeof(double)); - fac_r_2=my_malloc(cat->nr*sizeof(double)); - - for(ip=0;ipnr;ip++) { - double rm=(ip+0.5)*cat->dr; - double pg=get_bg(par,rm,BG_D1,0)*(1+get_bg(par,rm,BG_Z,0)); - fac_r_0[ip]=pg*cat->dr; - fac_r_1[ip]=rm*pg*cat->dr; - fac_r_2[ip]=rm*rm*pg*cat->dr; - } - } -#endif //_USE_FAST_LENSING - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ip=0;ipnsrc;ip++) { - int ax,added; - double xn[3],u[3]; - flouble v[3],vr,dens,gauss; - float *pos=&(catc->pos[NPOS_CC*ip]); - double r=sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]); - double ir=1./(MAX(r,0.001)); - - for(ax=0;ax<3;ax++) {//TODO these could be precomputed in the cartesian catalog - xn[ax]=(pos[ax]+par->pos_obs[ax])*idx; - u[ax]=pos[ax]*ir; - } - - //Compute RSD - added=interpolate_from_grid(par,xn,NULL,v,NULL,NULL,NULL,RETURN_VEL,INTERP_TYPE_SKW); - if(added) { - vr=0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); - cat->srcs[ip].dz_rsd+=vr; - } - - //Fill up skewers - if(cat->has_skw) { - int i_r,i_r_max=MIN((int)(r*cat->idr+0.5),cat->nr-1); - long offp=ip*cat->nr; - for(i_r=0;i_r<=i_r_max;i_r++) { - double rm=(i_r+0.5)*cat->dr; - for(ax=0;ax<3;ax++) - xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; - if(cat->skw_gauss) { - added=interpolate_from_grid(par,xn,&dens,v,NULL,NULL,&gauss,RETURN_GAUSS | RETURN_VEL,INTERP_TYPE_SKW); - } - else { - added=interpolate_from_grid(par,xn,&dens,v,NULL,NULL,&gauss,RETURN_DENS | RETURN_VEL,INTERP_TYPE_SKW); - } - if(added) { - vr=0.5*idx*(v[0]*u[0]+v[1]*u[1]+v[2]*u[2]); - if(cat->skw_gauss) - cat->g_skw[offp+i_r]+=gauss; - else - cat->d_skw[offp+i_r]+=dens; - cat->v_skw[offp+i_r]+=vr; - } - } - } - -#ifndef _USE_FAST_LENSING - //Compute lensing - if(cat->has_lensing) { - //Compute linear transformations needed for lensing - double u_x[3], u_y[3]; - double r_k[6], r_e1[6],r_e2[6]; - double cth_h=1,sth_h=0,cph_h=1,sph_h=0; - double prefac=idx*idx*ir; // 1 / (Dx^2 * r) - double prefac_m=0.5*idx*ir; // 1 / (2 * Dx * r) - - cth_h=u[2]; - if(cth_h>=1) cth_h=1; - if(cth_h<=-1) cth_h=-1; - sth_h=sqrt((1-cth_h)*(1+cth_h)); - if(sth_h!=0) { - cph_h=u[0]/sth_h; - sph_h=u[1]/sth_h; - } - - u_x[0]=cth_h*cph_h*prefac_m; - u_x[1]=cth_h*sph_h*prefac_m; - u_x[2]=-sth_h*prefac_m; - - u_y[0]=-sph_h*prefac_m; - u_y[1]=cph_h*prefac_m; - u_y[2]=0; - - r_k[0] =(cth_h*cth_h*cph_h*cph_h+sph_h*sph_h)*prefac; - r_k[1] =(2*cph_h*sph_h*(cth_h*cth_h-1))*prefac; - r_k[2] =(-2*cth_h*sth_h*cph_h)*prefac; - r_k[3] =(cth_h*cth_h*sph_h*sph_h+cph_h*cph_h)*prefac; - r_k[4] =(-2*cth_h*sth_h*sph_h)*prefac; - r_k[5] =(sth_h*sth_h)*prefac; - - r_e1[0]=(cth_h*cth_h*cph_h*cph_h-sph_h*sph_h)*prefac; - r_e1[1]=(2*cph_h*sph_h*(cth_h*cth_h+1))*prefac; - r_e1[2]=(-2*cth_h*sth_h*cph_h)*prefac; - r_e1[3]=(cth_h*cth_h*sph_h*sph_h-cph_h*cph_h)*prefac; - r_e1[4]=(-2*cth_h*sth_h*sph_h)*prefac; - r_e1[5]=(sth_h*sth_h)*prefac; - - r_e2[0]=(-2*cth_h*cph_h*sph_h)*prefac; - r_e2[1]=(2*cth_h*(cph_h*cph_h-sph_h*sph_h))*prefac; - r_e2[2]=(2*sth_h*sph_h)*prefac; - r_e2[3]=(2*cth_h*sph_h*cph_h)*prefac; - r_e2[4]=(-2*sth_h*cph_h)*prefac; - r_e2[5]=0; - - //Integrate along the LOS - flouble tp[6],vp[3]; - double dtx=0,dty=0,kp=0,e1=0,e2=0; - int i_r,i_r_max=MIN((int)(r*cat->idr+0.5),cat->nr-1); - for(i_r=0;i_r<=i_r_max;i_r++) { - double rm=(i_r+0.5)*cat->dr; - for(ax=0;ax<3;ax++) - xn[ax]=(rm*u[ax]+par->pos_obs[ax])*idx; - added=interpolate_from_grid(par,xn,NULL,vp,tp,NULL,NULL,RETURN_VEL | RETURN_TID, - INTERP_TYPE_LENSING); - if(added) { - double fr=fac_r_1[i_r]*r-fac_r_2[i_r]; - double frm=2*(fac_r_0[i_r]*r-fac_r_1[i_r]); - double dotvx=0,dotvy=0,dotk=0,dote1=0,dote2=0; - for(ax=0;ax<6;ax++) { - dote1+=r_e1[ax]*tp[ax]; - dote2+=r_e2[ax]*tp[ax]; - dotk+=r_k[ax]*tp[ax]; - } - for(ax=0;ax<3;ax++) { - dotvx+=u_x[ax]*vp[ax]; - dotvy+=u_y[ax]*vp[ax]; - } - e1+=dote1*fr; - e2+=dote2*fr; - kp+=dotk*fr; - dtx+=dotvx*frm; - dty+=dotvy*frm; - } - } - cat->srcs[ip].e1+=e1; - cat->srcs[ip].e2+=e2; - cat->srcs[ip].kappa+=kp; - cat->srcs[ip].dra+=dty; - cat->srcs[ip].ddec+=dtx; - } -#endif //_USE_FAST_LENSING - }//end omp for -#ifndef _USE_FAST_LENSING - if(cat->has_lensing) { - free(fac_r_0); - free(fac_r_1); - free(fac_r_2); - } -#endif //_USE_FAST_LENSING - }//end omp parallel -} - -void srcs_get_beam_properties(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_srcs;ipop++) - srcs_get_beam_properties_single(par,ipop); -} - -static void srcs_beams_postproc_single(ParamCoLoRe *par,int ipop) -{ - Catalog *cat=par->cats[ipop]; - //CatalogCartesian *catc=par->cats_c[ipop]; - -#ifdef _HAVE_OMP -#pragma omp parallel default(none) \ - shared(par,cat,NNodes,NodeThis) -#endif //_HAVE_OMP - { - int ii; - double factor_vel=-par->fgrowth_0/(1.5*par->hubble_0*par->OmegaM); -#ifdef _USE_FAST_LENSING - int ir_s=0; - HealpixShellsAdaptive *smap=NULL; - if(cat->has_lensing) - smap = par->smap; -#endif //_USE_FAST_LENSING - -#ifdef _HAVE_OMP -#pragma omp for -#endif //_HAVE_OMP - for(ii=0;iinsrc;ii++) { - double z=cat->srcs[ii].z0; - double r=r_of_z(par,z); - double vg=get_bg(par,r,BG_V1,0); - - //RSDs - cat->srcs[ii].dz_rsd*=vg*factor_vel; - - //Lensing - if(cat->has_lensing) { -#ifdef _USE_FAST_LENSING - int ax; - long ipix_up,ipix_lo,ibase,ibase_here; - double u[3]; - double g1_lo,g1_up,g2_lo,g2_up; - double kp_lo,kp_up; - double dx_lo,dx_up,dy_lo,dy_up; - //Find lower shell index - ir_s=get_r_index_lensing(smap, r, ir_s); - if(ir_s>=smap->nr-1) - report_error(1, "SHIT\n"); - - //Find intervals - double h = (r - smap->r[ir_s]) / (smap->r[ir_s+1] - smap->r[ir_s]); - - //Find pixel index - //Find base this galaxy belongs to - for(ax=0;ax<3;ax++) - u[ax]=catc->pos[NPOS_CC*ii+ax]; - vec2pix_nest(par->nside_base,u,&ibase); - if(ibase%NNodes!=NodeThis) - report_error(1,"Bad base!!\n"); - //Find base index within this node - ibase_here=(ibase-NodeThis)/NNodes; - - //Find pixel in lower edge - vec2pix_nest(smap->nside[ir_s],u,&ipix_lo); - //Offset to pixel indices in this node - ipix_lo-=ibase*smap->num_pix_per_beam[ir_s]; - if((ipix_lo<0) || (ipix_lo>=smap->num_pix_per_beam[ir_s])) - report_error(1,"Bad pixel!!\n"); - //Find lensing at edges - g1_lo=smap->data[ibase_here][ir_s][5*ipix_lo+0]; - g2_lo=smap->data[ibase_here][ir_s][5*ipix_lo+1]; - kp_lo=smap->data[ibase_here][ir_s][5*ipix_lo+2]; - dx_lo=smap->data[ibase_here][ir_s][5*ipix_lo+3]; - dy_lo=smap->data[ibase_here][ir_s][5*ipix_lo+4]; - - //Same in upper edge - vec2pix_nest(smap->nside[ir_s+1],u,&ipix_up); - ipix_up-=ibase*smap->num_pix_per_beam[ir_s+1]; - if((ipix_up<0) || (ipix_up>=smap->num_pix_per_beam[ir_s+1])) - report_error(1,"Bad pixel!!\n"); - g1_up=smap->data[ibase_here][ir_s+1][2*ipix_up+0]; - g2_up=smap->data[ibase_here][ir_s+1][2*ipix_up+1]; - kp_up=smap->data[ibase_here][ir_s+1][2*ipix_up+2]; - dx_up=smap->data[ibase_here][ir_s+1][2*ipix_up+3]; - dy_up=smap->data[ibase_here][ir_s+1][2*ipix_up+4]; - - //Interpolate - cat->srcs[ii].e1=g1_lo*(1-h)+g1_up*h; - cat->srcs[ii].e2=g2_lo*(1-h)+g2_up*h; - cat->srcs[ii].kappa=kp_lo*(1-h)+kp_up*h; - cat->srcs[ii].dra=dy_lo*(1-h)+dy_up*h; - cat->srcs[ii].ddec=dx_lo*(1-h)+dx_up*h; -#endif //_USE_FAST_LENSING - cat->srcs[ii].dra*=RTOD; - cat->srcs[ii].ddec*=RTOD; - } - - //Skewers - if(cat->has_skw) { - int i_r,i_r_max=MAX((int)(r*cat->idr+0.5),cat->nr-1); - long offp=ii*cat->nr; - for(i_r=0;i_r<=i_r_max;i_r++) { - vg=get_bg(par,(i_r+0.5)*cat->dr,BG_V1,0); - cat->v_skw[offp+i_r]*=vg*factor_vel; - } - } - }//end omp for - }//end omp parallel -} - -void srcs_beams_postproc(ParamCoLoRe *par) -{ - int ipop; - for(ipop=0;ipopn_srcs;ipop++) - srcs_beams_postproc_single(par,ipop); -}