{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# SWIFTSimIO primer\n", "Theory Lunch 07-02-22" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `SWIFTSimIO` package is available at: https://github.com/SWIFTSIM/swiftsimio\n", "\n", "SWIFTSimIO uses the unyt package (similar to `astropy.units`) for symbolic units. In most cases a derived class `cosmo_array` is used to store whether quantity is comoving, etc. alongside the units." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import unyt as u\n", "from os import path" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## SWIFTDataset\n", "\n", "The central piece of the SwiftSimIO interface is the `SWIFTDataset`, representing a snapshot file." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from swiftsimio.reader import SWIFTDataset" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "snapnum = 23\n", "base_dir = '/home/koman/106e3_104b2_norm_0p3_new_cooling_L006N188/'\n", "snapshot_filename = path.join(base_dir, 'colibre_{:04d}.hdf5'.format(snapnum))\n", "\n", "SD = SWIFTDataset(snapshot_filename) # Works fine for snapshots split into multiple files." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Metadata contains a wealth of information on simulation and code configuration, contents of snapshot, ..." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on SWIFTMetadata in module swiftsimio.reader object:\n", "\n", "class SWIFTMetadata(builtins.object)\n", " | SWIFTMetadata(filename, units: swiftsimio.reader.SWIFTUnits)\n", " | \n", " | Loads all metadata (apart from Units, those are handled by SWIFTUnits)\n", " | into dictionaries.\n", " | \n", " | This also does some extra parsing on some well-used metadata.\n", " | \n", " | Methods defined here:\n", " | \n", " | __init__(self, filename, units: swiftsimio.reader.SWIFTUnits)\n", " | Constructor for SWIFTMetadata object\n", " | \n", " | Parameters\n", " | ----------\n", " | \n", " | filename : str\n", " | name of file to read from\n", " | \n", " | units : SWIFTUnits\n", " | the units being used\n", " | \n", " | extract_cosmology(self)\n", " | Creates an astropy.cosmology object from the internal cosmology system.\n", " | \n", " | This will be saved as ``self.cosmology``.\n", " | \n", " | get_mapping_metadata(self)\n", " | Gets the mappings based on the named columns (must have already been read),\n", " | from the form:\n", " | \n", " | SubgridScheme/{X}To{Y}Mapping.\n", " | \n", " | Includes a hack of `Dust` -> `Grains` that will be deprecated.\n", " | \n", " | get_metadata(self)\n", " | Loads the metadata as specified in metadata.metadata_fields.\n", " | \n", " | get_named_column_metadata(self)\n", " | Loads the custom named column metadata (if it exists) from\n", " | SubgridScheme/NamedColumns.\n", " | \n", " | load_particle_types(self)\n", " | Loads the particle types and metadata into objects:\n", " | \n", " | metadata._properties\n", " | \n", " | This contains six arrays,\n", " | \n", " | metadata._properties.field_names\n", " | metadata._properties.field_paths\n", " | metadata._properties.field_units\n", " | metadata._properties.field_cosmologies\n", " | metadata._properties.field_descriptions\n", " | metadata._properties.field_compressions\n", " | \n", " | As well as some more information about the particle type.\n", " | \n", " | postprocess_header(self)\n", " | Some minor postprocessing on the header to local variables.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " | \n", " | __dict__\n", " | dictionary for instance variables (if defined)\n", " | \n", " | __weakref__\n", " | list of weak references to the object (if defined)\n", " | \n", " | code_info\n", " | Gets a nicely printed set of code information with:\n", " | \n", " | Name (Git Branch)\n", " | Git Revision\n", " | Git Date\n", " | \n", " | compiler_info\n", " | Gets information about the compiler and formats it as:\n", " | \n", " | Compiler Name (Compiler Version)\n", " | MPI library\n", " | \n", " | diffusion_info\n", " | Gets information about the diffusion scheme and formats it as:\n", " | \n", " | $\u0007lpha_{D, 0}$ = Diffusion alpha, eta_D$ = Diffusion beta\n", " | Diffusion alpha (min) < $\u0007lpha_D$ < Diffusion alpha (max)\n", " | \n", " | hydro_info\n", " | Gets information about the hydro scheme and formats it as:\n", " | \n", " | Scheme\n", " | Kernel function in DimensionD\n", " | $\\eta$ = Kernel eta (Kernel target N_ngb $N_{ngb}$)\n", " | $C_{\\rm CFL}$ = CFL parameter\n", " | \n", " | library_info\n", " | Gets information about the libraries used and formats it as:\n", " | \n", " | FFTW vFFTW library version\n", " | GSL vGSL library version\n", " | HDF5 vHDF5 library version\n", " | \n", " | present_particle_names\n", " | The particle _names_ that are present in the simulation.\n", " | \n", " | present_particle_types\n", " | The particle types that are present in the file.\n", " | \n", " | viscosity_info\n", " | Gets information about the viscosity scheme and formats it as:\n", " | \n", " | Viscosity Model\n", " | $\\alpha_{V, 0}$ = Alpha viscosity, $\\ell_V$ = Viscosity decay length [internal units], $\\beta_V$ = Beta viscosity\n", " | Alpha viscosity (min) < $\\alpha_V$ < Alpha viscosity (max)\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data and other attributes defined here:\n", " | \n", " | __annotations__ = {'filename': , 'header': ...\n", "\n", "None\n" ] } ], "source": [ "print(help(SD.metadata))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's inspect a couple of entries, and save the boxsize for later use. Notice that the boxsize has units specified with `unyt`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SPHENIX (Borrow+ 2020)\n", "Quartic spline (M5) in 3D\n", "$\\eta$ = 1.23 (64.90 $N_{ngb}$)\n", "$C_{\\rm CFL}$ = 0.20\n", "[6.25 6.25 6.25] Mpc\n" ] } ], "source": [ "print(SD.metadata.hydro_info)\n", "print(SD.metadata.boxsize)\n", "boxsize = SD.metadata.boxsize" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The usual particle types for a periodic cosmological hydro box are present:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['gas', 'dark_matter', 'stars', 'black_holes']" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "SD.metadata.present_particle_names" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can list the `properties` available for gas particles and their descriptions from the metadata:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "atomic_hydrogen_masses \n", " Atomic hydrogen masses containted in the particles. This quantity is obtained from the cooling tables and, if the particle is on the entropy floor, by extrapolating to the equilibrium curve assuming constant pressure. \n", "------------\n", "cold_dense_diffuse_metal_masses \n", " Diffuse metal mass where particles outside the cold, gas selection are zeroed \n", "------------\n", "cold_dense_gas_masses \n", " Gas masses where particles outside the cold, gas selection are zeroed \n", "------------\n", "coordinates \n", " Co-moving positions of the particles \n", "------------\n", "densities \n", " Co-moving mass densities of the particles \n", "------------\n", "densities_at_last_agnevent \n", " Physical density (not subgrid) of the gas at the last AGN feedback event that hit the particles. -1 if the particles have never been heated. \n", "------------\n", "densities_at_last_supernova_event \n", " Physical density (not subgrid) of the gas at the last SNII thermal feedback event that hit the particles. -1 if the particles have never been heated. \n", "------------\n", "diffuse_carbon_masses_from_model \n", " Mass in diffuse (i.e. non-dust dwelling) Carbon contained in the particles, according to dust model. \n", "------------\n", "diffuse_carbon_masses_from_table \n", " Mass in diffuse (i.e. non-dust dwelling) Carbon contained in the particles, according to cooling table depletion. \n", "------------\n", "diffuse_iron_masses_from_model \n", " Mass in diffuse (i.e. non-dust dwelling) Iron contained in the particles, according to dust model. \n", "------------\n", "diffuse_iron_masses_from_table \n", " Mass in diffuse (i.e. non-dust dwelling) Iron contained in the particles, according to cooling table depletion. \n", "------------\n", "diffuse_magnesium_masses_from_model \n", " Mass in diffuse (i.e. non-dust dwelling) Magnesium contained in the particles, according to dust model. \n", "------------\n", "diffuse_magnesium_masses_from_table \n", " Mass in diffuse (i.e. non-dust dwelling) Magnesium contained in the particles, according to cooling table depletion. \n", "------------\n", "diffuse_oxygen_masses_from_model \n", " Mass in diffuse (i.e. non-dust dwelling) Oxygen contained in the particles, according to dust model. \n", "------------\n", "diffuse_oxygen_masses_from_table \n", " Mass in diffuse (i.e. non-dust dwelling) Oxygen contained in the particles, according to cooling table depletion. \n", "------------\n", "diffuse_silicon_masses_from_model \n", " Mass in diffuse (i.e. non-dust dwelling) Silicon contained in the particles, according to dust model. \n", "------------\n", "diffuse_silicon_masses_from_table \n", " Mass in diffuse (i.e. non-dust dwelling) Silicon contained in the particles, according to cooling table depletion. \n", "------------\n", "diffusion_parameters \n", " Diffusion coefficient (alpha_diff) of the particles \n", "------------\n", "dust_mass_fractions \n", " Fractions of the particles' masses that are in a given species of dust grain \n", "------------\n", "dust_masses_from_table \n", " Mass in dust contained in the particles, according to cooling table depletion. \n", "------------\n", "element_mass_fractions \n", " Fractions of the particles' masses that are in the given element \n", "------------\n", "element_mass_fractions_in_gas \n", " Fractions of the particles' masses that are in the given element, not including the dust contribution. \n", "------------\n", "energies_received_from_agnfeedback \n", " Total amount of thermal energy from AGN feedback events received by the particles. \n", "------------\n", "entropies \n", " Co-moving entropies per unit mass of the particles \n", "------------\n", "fofgroup_ids \n", " Friends-Of-Friends ID of the group the particles belong to \n", "------------\n", "graphite_masses \n", " Graphite Masses (dust) contained in the particles \n", "------------\n", "hiiregions_end_time \n", " Time until particle is in HII region \n", "------------\n", "hiiregions_star_ids \n", " ID of star particle responsible for this HII region \n", "------------\n", "helium_masses \n", " Helium Masses contained in the particles \n", "------------\n", "hydrogen_masses \n", " Hydrogen Masses contained in the particles \n", "------------\n", "internal_energies \n", " Co-moving thermal energies per unit mass of the particles \n", "------------\n", "ionised_hydrogen_masses \n", " Ionised Hydrogen Masses contained in the particles \n", "------------\n", "iron_mass_fractions_from_snia \n", " Fractions of the particles' masses that are in iron produced by SNIa stars (incorporating both depleted and nebular phases) \n", "------------\n", "laplacian_internal_energies \n", " Laplacian (del squared) of the Internal Energy per unit mass of the particles \n", "------------\n", "last_agnfeedback_scale_factors \n", " Scale-factors at which the particles were last hit by AGN feedback. -1 if a particle has never been hit by feedback \n", "------------\n", "last_kinetic_early_feedback_scale_factors \n", " Scale-factors at which the particles were last hit by kinetic early feedback. -1 if a particle has never been hit by feedback \n", "------------\n", "last_sniikinetic_feedback_scale_factors \n", " Scale-factors at which the particles were last hit by SNII kinetic feedback. -1 if a particle has never been hit by feedback \n", "------------\n", "last_sniikinetic_feedbackvkick \n", " Physical kick velocity the particles were kicked with at last SNII kinetic feedback event. -1 if a particle has never been hit by feedback \n", "------------\n", "last_sniithermal_feedback_scale_factors \n", " Scale-factors at which the particles were last hit by SNII thermal feedback. -1 if a particle has never been hit by feedback \n", "------------\n", "last_snia_thermal_feedback_scale_factors \n", " Scale-factors at which the particles were last hit by SNIa thermal feedback. -1 if a particle has never been hit by feedback \n", "------------\n", "log_oxygen_over_hydrogen_masses_hi_floor \n", " Masses multplied by diffuse Oxygen/Hydrogen log abundance fraction, with floor value [O/H] = -3, zeroed for non cold, dense gas. \n", "------------\n", "log_oxygen_over_hydrogen_masses_lo_floor \n", " Masses multplied by diffuse Oxygen/Hydrogen log abundance fraction, with floor value [O/H] = -4, zeroed for non cold, dense gas. \n", "------------\n", "masses \n", " Masses of the particles \n", "------------\n", "masses_from_agb \n", " Masses of gas that have been produced by AGN stars \n", "------------\n", "masses_from_cejsn \n", " Mass of europium that have been produced by common-envelop jets SN events \n", "------------\n", "masses_from_collapsar \n", " Mass of europium that have been produced by collapsar events \n", "------------\n", "masses_from_nsm \n", " Mass of europium that have been produced by neutron star merger events \n", "------------\n", "masses_from_snii \n", " Masses of gas that have been produced by SNII stars \n", "------------\n", "masses_from_snia \n", " Masses of gas that have been produced by SNIa stars \n", "------------\n", "maximal_sniikinetic_feedbackvkick \n", " Maximal physical kick velocity the particles were kicked with in SNII kinetic feedback. -1 if a particle has never been hit by feedback \n", "------------\n", "maximal_temperature_scale_factors \n", " Scale-factors at which the maximal temperature was reached \n", "------------\n", "maximal_temperatures \n", " Maximal temperatures ever reached by the particles \n", "------------\n", "mean_iron_weighted_redshifts \n", " Mean redshift of SNIa events weighted by the iron mass imparted by each event. -1 if a particle has never been enriched by SNIa. \n", "------------\n", "mean_metal_weighted_redshifts \n", " Mean redshift of enrichment events weighted by the metal mass imparted by each event. -1 if a particle has never been enriched. \n", "------------\n", "metal_diffusion_coefficients \n", " Metal diffusion coefficients of the particles.Controls the metal diffusion rate, not to be confused with the energy diffusion coefficient. Stored in physical co-ordinates \n", "------------\n", "metal_diffusion_rates \n", " Metal diffusion rates for each element in physical co-ordinates \n", "------------\n", "metal_mass_fractions \n", " Fractions of the particles' masses that are in metals (incorporating both depleted and nebular phases) \n", "------------\n", "metal_mass_fractions_from_agb \n", " Fractions of the particles' masses that are in metals produced by AGB stars (incorporating both depleted and nebular phases) \n", "------------\n", "metal_mass_fractions_from_snii \n", " Fractions of the particles' masses that are in metals produced by SNII stars (incorporating both depleted and nebular phases) \n", "------------\n", "metal_mass_fractions_from_snia \n", " Fractions of the particles' masses that are in metals produced by SNIa stars (incorporating both depleted and nebular phases) \n", "------------\n", "molecular_hydrogen_masses \n", " Molecular hydrogen masses containted in the particles. This quantity is obtained from the cooling tables and, if the particle is on the entropy floor, by extrapolating to the equilibrium curve assuming constant pressure. \n", "------------\n", "oxygen_over_hydrogen_masses \n", " Masses multplied by diffuse Oxygen/Hydrogen (linear) abundance fraction, zeroed for non cold, dense gas. \n", "------------\n", "particle_ids \n", " Unique IDs of the particles \n", "------------\n", "pressures \n", " Co-moving pressures of the particles \n", "------------\n", "progenitor_particle_ids \n", " ID of the progenitor of this particle. If this particle is the result of one (or many) splitting events, this ID corresponds to the ID of the particle in the initial conditions that its lineage can be traced back to. If the particle was never split, this is the same as ParticleIDs. \n", "------------\n", "silicates_masses \n", " Silicate Masses (dust) contained in the particles \n", "------------\n", "smoothing_lengths \n", " Co-moving smoothing lengths (FWHM of the kernel) of the particles \n", "------------\n", "species_fractions \n", " Fractions of neutral, ionized and molecular hydrogen: [nHI/nH, nHII/nH, nH2/nH], assuming equilibrium tables. If the particles are within deltaT of the entropy floor the fractions are calculated using the subgrid quantities, i.e. assuming a pressure equilibrium on the entropy floor. If the particles are above deltaT of the entropy floor, the normal hydro quantities are used. \n", "------------\n", "split_counts \n", " Number of times this particle has been split. Note that both particles that take part in the splitting have counter incremented, so the number of splitting events in an entire simulation is half of the sum of all of these numbers. \n", "------------\n", "split_trees \n", " Binary tree describing splitting events. Particles that keep the original ID have a value of zero in a splitting event, whereasparticles given a new ID have a value of one. \n", "------------\n", "star_formation_rates \n", " If positive, star formation rates of the particles. If negative, stores the last time/scale-factor at which the gas particle was star-forming. If zero, the particle was never star-forming. \n", "------------\n", "stellar_wind_momenta_received \n", " Momentum received from stellar winds in physical coordinates \n", "------------\n", "subgrid_physical_densities \n", " The subgrid physical density if the particles are within deltaT of the entropy floor the subgrid density is calculated assuming a pressure equilibrium on the entropy floor, if the particles are above deltaT of the entropy floor the subgrid density is identical to the physical SPH density. \n", "------------\n", "subgrid_temperatures \n", " The subgrid temperatures if the particles are within deltaT of the entropy floor the subgrid temperature is calculated assuming a pressure equilibrium on the entropy floor, if the particles are above deltaT of the entropy floor the subgrid temperature is identical to the SPH temperature. \n", "------------\n", "temperatures \n", " Temperatures of the gas particles \n", "------------\n", "time_bins \n", " Time-bins of the particles \n", "------------\n", "total_oxygen_over_hydrogen_masses \n", " Masses multplied by total (i.e. dust-inclusive) Oxygen/Hydrogen (linear) abundance fraction, zeroed for non cold, dense gas. \n", "------------\n", "velocities \n", " Peculiar velocities of the stars. This is (a * dx/dt) where x is the co-moving positions of the particles \n", "------------\n", "velocity_dispersions \n", " Physical velocity dispersions (3D) squared, this is the velocity dispersion of the total velocity (peculiar velocity + Hubble flow, a H x + a (dx/dt) ). Values of the Velocity dispersion that have the value of FLT_MAX are particles that do not have neighbours and therefore the velocity dispersion of these particles cannot be calculated \n", "------------\n", "velocity_divergence_time_differentials \n", " Time differential (over the previous step) of the velocity divergence field around the particles. Again, provided without cosmology as this includes a Hubble flow term. To get back to a peculiar velocity divergence time differential, x_pec = a^4 (x - a^{-2} n_D dH / dt) \n", "------------\n", "velocity_divergences \n", " Local velocity divergence field around the particles. Provided without cosmology, as this includes the Hubble flow. To return to a peculiar velocity divergence, div . v_pec = a^2 (div . v - n_D H) \n", "------------\n", "viscosity_parameters \n", " Visosity coefficient (alpha_visc) of the particles, multiplied by the balsara switch \n", "------------\n" ] } ], "source": [ "for name, desc in zip(SD.metadata.gas_properties.field_names, SD.metadata.gas_properties.field_descriptions):\n", " print(name, '\\n', desc, '\\n------------')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `SWIFTDataset` uses a \"lazy-loading\" approach. So far no particle arrays have been loaded, but we also don't need to load them explicitly - they're simply read from disk at first use:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0.16098554 0.01664983 0.12197359]\n", " [0.01400104 0.05345625 0.17775067]\n", " [0.08225423 0.14768666 0.16685584]\n", " ...\n", " [6.07958223 6.09383357 6.21733188]\n", " [6.10960895 6.15101505 6.15021308]\n", " [6.10177972 6.23066568 6.22951251]] Mpc (Comoving)\n" ] } ], "source": [ "print(SD.gas.coordinates) # using SD.gas.coordinates again later will be faster, only read from disk once" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Particle arrays also come with units attached. If needed, we can get the units, and the bare array in a particular unit, like this:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mpc\n", "[[0.16098554 0.01664983 0.12197359]\n", " [0.01400104 0.05345625 0.17775067]\n", " [0.08225423 0.14768666 0.16685584]\n", " ...\n", " [6.07958223 6.09383357 6.21733188]\n", " [6.10960895 6.15101505 6.15021308]\n", " [6.10177972 6.23066568 6.22951251]]\n" ] } ], "source": [ "print(SD.gas.coordinates.units)\n", "print(SD.gas.coordinates.to_value(u.Mpc))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's take a quick look at what we've read in: plot a histogram of gas particle positions in `x` & `y`:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "nperr = np.seterr(all='ignore')" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAECCAYAAADesWqHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAADnRklEQVR4nOz9W7Nt25IeBn3ZWu9jzDnXWnvvs6tUclVJRjplEw4uCqvkklSYgMAu40deJDkCXo0FPAgQAbL5BUiKkCW/GMkieCOwXFyeIEAy8AKqQHYhh8O2jF0SYTss1+2cs/dea845Ru+tJQ+ZX2b2sS57l6XtdSJ0esRac85x6Zd2ycuXX2aKquJHx4+OHx1/bx3tY9/Aj44fHT86/rM/frTxf3T86Ph78PjRxv/R8aPj78HjRxv/R8ePjr8Hjx9t/B8dPzr+Hjx+tPF/dPzo+HvwWD7WhdvprHff+QlEMFFufgKA+t8fijiqf0Xzc/F3/Xlz8DPb5TXW08u339Tjl0UBFeD2g/K+cKjfu4p/Jv72C9Tn8vPuT6+x3L2AlGe5/Uw8Y71u/ax/TqbatZrk2Lx1//6aCKAKlbyvbXuD9fzi7ceKeZK3X/uGx2F+3nXo8Y/t8gan9cVxLDSHMMa3XmOf9uwAUMdKBJgTaC1fV+Rn8Y5n9AtpE2zXNzitDzlW9X7LnAoAbcf3VGwdxXXKNd9e6/6C3LzP+bm+wXJ+Ee+rlPf9uH75PexPb945Ox9t40MV/+A/9cdjcOYK6JKDXhe/TBtEGfk3ND8jE2ibQob/Pm4/rzng/j1+59/4v/05/MP/jT92mEiZdi4ooN0mSKZCpm+oJofz2/3aBdQXi3Y7f2z+qZir2L0DmIudow0N4fDX/+9/Dj/7j/6xsrltnEQBGRr/0ADZbWO3fdoCUrsHGQrsE2iArh0qgrbbRce5Q4ZCl4a2DchQjHPHPHW0bWJ/saBtE3Nt+OX/57+A3/uP/jH067T5OTVoL/feBXNxgdHE5k/En6fME3BYnBx7m0PN5/S5aUMxF/G5tDf++v/jz+H3/ldtjmT4eOwT/TKh3V6ba8P6/WfINiBzQpdmm18V2ruN2fMGPa2Q6wa5btClQ1/eQ7Zx/HxrwNKga7ex7IJ56tAm+Gt//V/Ez/2+/wFUJDauNkC7oF8nxqmZkmg2NhCJcVP+LrlOYnzUBYWUdSV+7mbPOE4SY/Vv/l/+LP7L/+T/CHMBZhfMBRhngS4IIfHv/2/+zO2ui+OjmvoyFLLjHdoMwCwLBIhNLcP+tZHvy7ANxkU1u7+u+k6NHIvOJSQ3nkzTHDap+fm2u1AZtnmh9pqdy66hctx8fD8FQQoEbSYU+sWev1/mWxqrjeML3Ezz1DCX5hJeMJcWGkubQAXQtZlGg93PuFvsc0Bseu0N49wBf3btguYLt2026MvzgAowzi3Gg4vdxqqMwUjNW+eN8yoD6Bt8fG0M5iLxbNpM8M4usfDnksKYwlOmom3TBMTafLwn+vOO+bDaZlUFWoMuNg4yBuR583U0oKfVxud8spNfrsDgHOZ8ahfo6gJBxK0FhWwTbZs2BhRywwRgo0Depq3Lw8LzHzvX4fH9ttuasHH2f8US5vrmXIyTxBjae8XyeZ+F58fH0/h+iCowJaTbO4+Dlsif/L5MoO3c7P7MPqgykKahL0YVtwrCVizn42SIbVJq+bC8uMBxnLh4bRQTT4olADluBn7fF327alowCltgU9GGppXRJe6FrofQTJ22AWQqMBQyJ+bDCe15B849rqc9NZWNVfUPyn0pNxtCi+siYQHZ11KrxYKspieK5SbA5PzS7B035m4xhWMtaL7GTUUhCsA2bHcLZttN259XYNrG0y4Q9fs8rcA+oHc2Hro0M/tFTCCsHdp9SzSbAwAYL06QMe1FAeapHza1qN2Twr8jtqBiviCxJmT6c/pcUGnR4tSee4KWAq0qmblmudFt3MWmYaZgqHvkXcdH2/jL3ct3vh7a/vami9lPzVrN9tjg/Ez9zsEkp5a2Qfzt3/0D7g9Lmvg3Qqia6m0/StU0UzVMPLoG9AvFrQtex+7j7Vn5yZ/6/RA1bRHPiNxoNPW1iy8A17o8FTckzJwXdbfgOjG5+YeaRTD0MMYULNRkP/XTvz8FU+xmjofLSt+osajL+SomchAK/nkToDcDwA3TisAA8Pf9/X8AomrWgALVN6fwksswTX1a0B6vh3PaWHQTBtuO9izQbhPcXj9Dl24WgEiY+3YvJhS0zNtP/fTvz7mrPrlvQoj9rt0sBEW512IhQIu7KAB6Yiy0IjHFXLYbzS0K/MTP/EETnP34OgXNBzEUfIsbX0R+FsB3AUBVf/GtC98bcFTN6luNyNfqAqKkrdrxsNH1+F4Ig7IQK9j127/7B4FdIQdk8OYefAO1XQG6Hq6F+Tu1Q0j52/OUa+aJkQsCwE//9O+Huj9+2PTwTR8mJ5Dgmmt6LZqw+2If6gsa2O87tAuWx2ELS3BYlGhFsIjgp3/q5w6LGjw3NxvnTHMf1sVWx56a/C1ZfjM38R09Csmf/M/9gaNl5tYQ3Q3x+9fW45wBqjomor3nhg2tXG/GPzunvT8n0DswFA0D87xABfjpn/y5FJo7AN94xGoAuJKgq1UEJOfc57ft9lO5USkYJcf6drxoKfzEP/AHD29zHgyb0qNV9I7j2/Tx/znf8J+LyHff+6miXcNnr5sURTP4eweAqGAB1e9OBB3hK1FbVJO0uW8Wmr7jbUHkk9G21JJhkvp11Debmebl3os1Yd8ruIM6fjAVy/PAXFua1U2KFeJ+59IC2IuFDwBNINtAe94h27CF6YtYBRh3C8Zdw34v0OXdkQiZinadEIKFMDyBYxSbspjyvNd8tvxX5y9Mz2LKAznW0wGvA9hXBMdcuaHyWlAbB1pV87zY+D1vGC9ObraLm+z+lbVD706YD+cw8ecnD0BvwLanuX9eUsCrYhI3gFlPdHHaNsKXl23a843EIWRqzFUIKJrgsX5cy4+i6YHjvqiCsa5LKecqe+IgdN9zfCsaX0T+GQB/TUS+q6p/4X2fq+GjA7AHxIO/tdFoHpWHpYYgoEc0nn78waQk2NaOKojnPWz68n7bpqPYqe0TD5C8zlToUiS22sLtz3QFUotT6GgDZJtYdpPU/WLIui2clCIC07zmG0606zC0WSgk5kGTyT4xz0tuzIkA7kzkS2iXdp1231PQLwPjrttrDrqNU8M8SWzotqeZSVO+AlHx/H4E4OrjGmg1Iy6a46ii6NwIBd2nAOE8qwBwC6u/uWL/5C42IcdCl2ZI/8VvWBXtups2V4Vcd+jaIa3ZWLgrD/8eROzzEwb0TTWZ4MKZrpbhNDM1/a5osM0/Wov7JGg7zi2fC4kF2HLSBDa5od0i027XFEjg02HBUMB1BHbwvuPb0vg/A+DHAHxPRP68iHz2zk9RK9/eYJVcQNnkenydp+EDtzwfXYTDBma4q8TVAQRAqGVxWojGPjPuGnRxxNZ/tm0W66OAcEvL56Hl/Ww3GBtl5H20bfqmawYgHTSlocp2TrGwkoedtDczP9cWMWhdWlgFgG38djWt1J8nlseJ/rSbSTtMG/F92/Twn4p2GbF4xtkXs29SmYYoc+wjDFVcABWG/Yqp21IAGOiWE0nLKQArR/cnrzM0xlEcWQ93BoCeFvTXV+yf3UfoTvYJuRjAo3drfE6XFpseU4HWME9LulceBq3rsV13B/hgQjdQfb8/Gl/XYaHG5z2svb5NLI/D5rkLxqmhX+w1wC1V7gPJaEasxerH08VURRsJar/tFnxY5cu3kY8vIn8SwK+o6l9w7f+Zqv6p+pnTJ59r+PkAPv89P4/Pf8/Px6YPc1xgA7+5WUwl62E9CXMZEW4j6FHjoUITnGaVI6VtM+naNv8uQcP63anAZHhLYnPwUNfCULcMzi0k9VwlNecNoUN29QU9IAqMux6LWqaDcBF6FJCUE8AdkBuUB9HsYp7OU64c00wWztNTi9h4VQH0j6cDYHOV0GSm/SW1rwJjTe3EeauoPICD+U/AM6yNobHIGafXBvRnhS5Au2rMW7vOuI+2TzO9AfTHK+b9iva02calNXHdg6zTfvAaene2Z3p1h/blE+aLO9Pol6u91yU0/XhxQrsOQBXjwUN/LedexnRhnXH+frEQ6DwvAZbOtcX4xBie65zYe+KWaiD8PoZzkYO12H09MZTHWD4A/Nqv/FX8+v/3lwAA+9MbXL/63jslwLcF7v01AJ/7758B+MFbF75/gZ/57/zx3OTA0bQex8/XsN1BW49E4k0I2EAEworjYqostX7JTQ+kZobHmGXa5uSm2F4sgR/ITi3mi3c3QbK/6B6jn9jvu5N4jNgykZK8XdNUB0zTLm82Q5vVQlQYppFFffP6GPTnq/mdMK0+Tx3t4v69x69JSmmPV0A9bu2MtemCo72x2PY8L/Yc07XZPrF9dk6BxedzLKMNxSigY7vR7jX2TmFHTd82t4x6YgTV1QucaxohheMqgX04x8HxHeMfDEPzn3fM84L2uKHNacKvucmuivmdV3FPct2x//hLLL/5BugN89UD2vMV0AY9LZDrjva8henf9gm5bMGPIGqP1sw62SfUN/tcWvj1gAlncgKgMB6Acy5kAv0ycP10tecegC4IN2eeMgy8PE2Mc8N+buEyaKPWV4xV8OP/0M/j8//Sz2OeBP/e//bP3G673F/vfefv4HBQ7zMR+QX/+51+ftuRE480bcLnU5P23JjBxHONzBimSX9jNqkA/arpHgzbeNMnqvq7c3Hp2V3S0sQazrpThCYXBfp1mpl/KeQMTTAOWog7XbA8jdTSIZg0tNY8m4avfrp9GWibm6i9TJGYb5+htwG57uhvrrbBJ4A50d5cIBczdeeLs1lCp45xv/p9aBBOArgaiv602Wunjn4xk1VdMLarmbdtt7Bac2trrql5oEmssjG2MZyLP7dbbBTQbQeWi6Jvetgob6H8kib/XFtqUApyrrulmSVzv2Ler/a3+/nzbH+3N88R7eiPmwF7HrXRsxOAeExA79dg8OnaC2jY8tqxpjQ3PeeV/Avf8OLWW7uMwCr2F4u5Ah65YWRFmwTZR5vhLFBgeZ4hQC28rCFwKRxRFN+7jm8tnFdM+7/y3s9QO2guFnuDr7lpP4BOoK4QaGrojgSHQOlDg1CyFnNSC9LuWsg+i4OJRcR9LibRbcFO7HcZExdqI59gDvggIu5gWpieuxZ3ogiJry4Y9ytv2WijANDczCYuERrY4s16Mm0trRmgNYrfuQ1gn5Ax0NaeCHwxu3lBUdP8YcVMAF3QH3fDFrphCYHmRygTEGeZhfXG6aHQnPn8JhxSqNbYfDDThIIZ6HSXNvWQI2yjKQ7PSkyg7RPti0dgXQ7ujswJbIrx2QP6F0+YL00g6mmxa7t5z2OeVzP7nzbo3YJ2tWiBhQ5bMCHpMmpvZnXBxrE/bai5AjLVxo9uoUisjT6HWQGXgXGfYCzXY9sRLmkIwOW4qw/5HWKK7EOx/G8znPe1Rw1XAGUxam7uQ1ivovZSFp4LCZru9rqH7VQzHMXzuEZvezLZwmVQUidnACnU4kDy3QEEkYYbql0d8HO/vT/bYuoXo5gSxKEPN08tTOvx8mTmZFg7an9vA0S8jZ1m/nl7fbWFOiyO356v9tkupt18Qc+XJ8wX59z05PL70fZ5wCvaZQdDhftdP2pUxykOlFMf+xCeKBbZ0HjuwGEodEIYa2z6wAiQIbzZJYBWWlWitvBJStKlQS4jBOT85B7TffID/x5Af3N1k7wZot9tDO1EJkiIoURE5RZD2YbNzZjBr7C5mZjcuE6uMovUzH+j/yr642bhv2b3p2JuwDz3iGS1yM1wS2I1Hr5pehzG1CxaBBj9TUJ6H23jK68e2h1hPgJpyh/+af6MeLlvEpqUcJNcywBUIDAESkcs2uDWE/WHLyzf2MGW6yVJpPyrh+zTQEAHWw7huEI8iUXPzbvZBrTreSiqt7Ay7ARmYrbrwHxpC7s9X42WKwJttpjb4yVMXHFhIWOCPHTTnDNQahvviXbZDfEGgKlYX+82thNojmTDUWYVB5S4uAK4K5YcyiLkOBVrLeYowlAS4c3MRTCrYXY6/wkIWqjUzF899+AgaJMwzedpQc1bwD6g5xXtcYM2x0CKv841YG6DQO/X4FCIRwAYUgPs+kb9tXFtTxYpmHerzZ8LVlFEYtV4WMHwm55aWqDuKgr5KL4+4aBnu+bYVWVUFaZFTiT32HuOj6fxuTC4eWb+OxBCKto764PjAOARuAswSNNPt3NpACbA8T1jdkmYvDFRxSytoUVqeQAZmiNlszm442a5KIzjThyA39k9JOWfMX+6QusUQJmUE2wshqlUMR9OvmFo6k/z8x3Nbq8vscgsxj0i3msXmEb8GY6AA4F1VB59JCEVViLN8hACyDmpYT2+Tu1U5/9wqKZgnZnld6BPNxysujShkynXnjcj4wgsy845DiqC+fJsm52RERFzCUregYYlpU6CEsMM3OLQXvx7Kg9FuQeNdQWfN13kMP9xkHfAKIdjMGGF0d11IUnfnnOSUZSSWMbx/2HU+MBxA/Egel+1RGj5vSygYh7WeHoAS7cps675Kx8gFvBOdJkTVnwzsubEPndLAQ4cwq/DDSq7hi96ZF1x0viM6SMecA0t94MUMGFJkKwzAWagQQRYFxxyzZuYecq/95HfpUAIK6gAW2VtVgKNAYyppePjLRfbgcjzjsV3648eXr/5nLiWl5vPh6sXvAzbkFaDoOV3KlMyrJkZTMt5XuM1mvloiI0oQ80imOZSGQVYYh7CHYNv/NjcMwR7jFEXww3GDOA05gEcOzmMhZR1cNgr1IFlrGnqH8Kp7zk+vo/PhUJJVzQrj8yGQ2gE+5smOoVBvn78zlEQoPIEYK4BfXPUjTm0DGxJ3W0SMfi8x/zZrjPBRJpv1CD8Ti8L1w8i+fHMijDJ2z7NfCWY5Yu4uZbGtufrvcX7el4jJTVPLkHiCWtnTgs3AZDrDB/3oJ2oVW42YW7QOqfi//zzkoKyjtctgSusmootlO+loDchrMvRBdClYd4t5tPPmZumWX59e94te69s8vgMWXHF7+a9tMuezLi6OcN1SS0MYkMkeRHUDWwot532wpHA8fzh+hUFVzV8TTaj4KV7+kO98dO3w2ERHbSEpslJv4+fq5onCSWZG9+v0zZ1gEjlWhzMoUmmaOIhlRswqiUJR7ZZaKt6WNzkaAd/2zdvuxgY1LaZ90+LADCm19MW7wXhhuPgITbAhYODQrJb6i1UTdPvDv61FmYq3zMg0seRHIBJnrnz/BX+U+P65t+mhjsQkNzsZ0QlpsxDrDHPN5p8LhnDjnmNL/uYDDXAiouY66JofPUwrS5eW6BJYipc2a3Z2LkgnKfFvndeHPtQD9F1s3481wENhrvw/lShhXQTbpMWslQoMDjBpuV4UJA6oDzPPZiTdmN1/JDKrByyT3evEt0nkWeWPfR1Zn4dno9ytB0egrG/b/2UqikqEmwmuIfbYqH4+zs3IH2kvB5BPPUNDgXW13uY8dM3x22pLAvXmVm3vVotlr3mZqigIdSR/1l9Nn9rYUjPkWaPxRvCb+G2ts3joqGPug1beCKBB/B1mot6Z2i+uOlLzT4fTubrN1gCCjjeLcZlnux1uWwRR6bmMyLRDFeHwGjk5atvUmeW3SZY2XPpIUxq1/fP0CoLIe48BZ/Tfs3wIa+rhdZK6jMAtMckJUEEctlMW5OAAwBLM3Bv7Vl5hwk9To02TGRg3uV40aTvby654WEbUlcjUS1fPGPcLVYY5O7oOmkXi+TQWqEAIHNSHUT19UaBG1aT74+2ZfWhufh8EBDlpr8RtrfHx9v41c8jsCc4THBw7vvRNIx0Ri4k167taoywfnH67Z4DCrgZfiGQYue/frLGQLehaGOG9g5zfXfiytKwPBspZ3k2Ld5dmwMmPGrcfnnc0kSFaZDge0+T9vNs5a7aZY+YfX+8hoXQtvTPyTsfL88RugvOuW9U7POYktkF7c3FKKpfWWmq9uVToPuxgP1c49WdkYI8Dm1JQ6OER1PIRpWYsMikvJbzRaIPhS61fVRR0uNnq9ZnyJUW2y320a4jEHjZBvbv3IfWn6eOebcaM/Fs5Jv5sDoDD4aNMP8e9reeFguFeukt2Zw5eWfsR11b8P2nE4bm2k1Qt4b90zvf4B39aTeNTrfCuSOyTbTnEesgiqNUH38ik2/Is+gS4zEXsQo83bT97Kk4K536fcdHK8Qh/l9s7IHY/LML+p4gV7+4md4AmbY6FO5zl4w6ozdqnC/SbcN0leDRt82yrAjEHUpLFXdDVDEeFhc4evDH+mVE6qr4ooZL5HFuLoUFWJBAj/uARGunb6754uSax9lnvXnewXRf2+K+c21Yvv+I/dN7q7dXtJYwkcTJK7JPzPsV8uYZsnbMV3cWYtom2mWzzzoeIDvcnF3MDPbr9pF1+SJKIYjxGCtNTqR1Ru3Tgbab+jHtLe8QBDhop7apJ7IgORSaoC0abO5dwI6HJcJf+8sT1i+ebRxPPUhXKshNpBZqAxCU6Qq45o1Y5R6zqNRchaHQ+8WIftuIqAAwzWK5bMByxvobjxivLCdg3C0HFiaZkRBERqTVDUCUEousVRKm/Fmlidf0c4uzFdeVm0rTgv7Q8XFLb5UJZ262hbbgPhbQnbF0ROzfFmWG0mvG7OHmEgApDo84A3A437k/jTRbYRu1uflMamjkVm8zzDjWsWPGleXSz2CTGePQLQgA8AQOwGmnXr6pP23uh3uCzmU37v11BNJsSSCLmb1vrhgvz+hPWxTJlG3Y+6fFgLx9AGt3n79hfvrgob1nBGcfMNeAWu3xAqwLZJnhHolO58L74A1zQSyZKLVThKyKDx6MTGrzln+3AczOopp60Pjj5HTgoehXjSzAcbbcCjBNt1llnLal3yxuvXBjAzATHwgw1SyrBrls2D+5szlxgRCRmjEhjwN659rf+QH9zQWzbOTkB9if2+cPWL66RCGU9rwDS5J4VGxNML16rmapNF8XrH0Y/IZd0Zn1KazYo9gfWhKbAl86Ct9bfOD2+GgbXwFMn59DPF4BdEB9bM23rhKCcXpNE94R/bkIemToafDKIz5L7dLcLL/OTDlV5CYmiKPm14+1mVV87hGPDWDLhVK7mPQm77o/7pb9hmLWF2vBIhITNbNLikVgSTntIBxlKsbLcwBCsiXS314/AUu3zexmJ2Ax/vbFo2WetWZCgVr+eYM8XTFf3QEPZz+nJbzQv5+nJdyTubQgzMzVNfcisYGjJl/FNVxz1Q0+TuJ+ux6eLejCYsKBxSSXZ/XrC6QB7erCvwl0AliA5fWG/cUauQcW+mzJvSfQSvbjeXVhPjDuV4uOeC4EJjA+OdscPZsgZsJP/+oCLX5/8BQUkWQ1Ty4cVLH84Bn7Z3eB7gOJCQgUOgxTYOEVAMHwJDeCIcL9vkUWKS0te983vVsAk7Uo8P7j4xJ4/N9cEQhujUPOKDaYP40o4aeocXlVrF+59ub3ZtJ1GfprpOYCUSbaCl+IVZMtYbY2fFN5yHA6c4+mGqnDZr41zN4yriy+MV1jjwdbLKahXON6GK1ddiyvrx41GJFxRhPfqLw2CLQEdGkZl14a5kunqYqgPW1oXzxCtoH+/TfQF3eQqwNbvUG+/6XVmlsX6IPhBZab7iblNiBvng0Ee3Y2X88qt1mzIM18s3pyrrj5A/iki+CCnNl6nFdWteX5OPc1Vz2qHVcL4WzCaH/pWsStRj01nyONTU/fW9eOcbfYnN4tWL54QqQ/8xz7jGc3bGjH/smdbfphVXmi6IYn5/D3tk8TkufFBIjTqu0DyevXxQTN7C0StyLvg2Pbc1z688T+0EDK7iGct5h7NM7APAH7HT64uz+eqS9OsQUiPslCGA0wSShm4jSCPf6QLSi49M0kyC1tV6CUyOJxZKGZ+W+VcSx9VkZ+jgUoZitVUroVVMAoxTaK/2UFWBXY4DiDVX4ddw3B+QcwSrLKXBq6V8npry+2qZs4sGZlpLT3qAYzz4s3imheO18T4AOsdiDBKg/hYTENqKcVsu3Q+xPwyUvLSmtI3n6hrAKwirScKi/8QQYiN5GRlewzDCdVDWiMPkuwAhDjEAy49rZJSquMvREqUDiXggu4idg84hAms7Pkgi9BRp4fkRjzeE0s5eEUvIcK9jGiEdLs7BaZb1hiHlEHcZKY0wzbcNIPrwMFZHeA9n618zcT8uOuh9VKRiRaluse56yARJdYfdznYkJ3nuD9Db7e1P+o4TxudoYk+I+hIQDhAmSqZ/m+a9tDtp4DOoboS5IgSkJIG+Yb9uvEPLVIh2TGlARNNzc9yTfTQSPENerzVK3oQmtk+apJqqciEjwOmWHF3NMuniaabDSZCnnekwFGX1ME8ngxLe156HGe+xPal4/G1uuep796RtrF6szJoOtg9yHXPUOIqy1aarJa0omJM5y3dx1vxfeBsBreImnRQpipFDiv+T0Ni5Dpr4H5MDuy8C/i8LkhBZrna2HtcA0V94OxeybYFIIV3Rd4JMWEtmn56bUBuOkrsxNAVgAiK7DgI3NtsbG5Djh2zGQ8kqpyz8wFmKtCFw2X633HR9v4gf7yhk/F5Oe/GhIqYTEe0TkmhIKbwwyBuSnExIfggQ+azRmGO96X5OJu3KiGE1Q/Lcy3BltsTK5wf3dG/fa64E0LMPmGLK7xsCaw6Ke1EFHSVQ+VclSTcEJ0uTsRhSzDPd0KbLv59/vIeLWqcfs9gYe8dGy7g6vj7ZBQSz8+AKbmwpuhJPXxeI/WeYuYUjZbDb3eZm/a/EgQtOAgX+AOlREn9oy0MCr5q23DAEA32Q9UZVJoib7PzLGv6H8Am13M5aoU6bLhgr9fE6L2mUJnZ4q4PXvbZgJ8TBhbW4S0KwM1AFUg3eYF2B8Uc9XDfdweH1Xjo27+VTEXTQKCvK31M7c6w28HJhkBJP/HTd58oGMD+/tWZGKCoZOIqdaECkeOSW091FqTOsNu1lFqi4VeZm+IctA3lGDzzVqEeVgOOrvx+MadZWOuPem/dfaWbv8AM0/p2+6p4c262EOIYelm8gdvX90ysM2gIoaKMwdBMtkoKuSGtcZiJzn275xyPf5+4DkEvbYscHl7cceQv4OeGqQXZtctGUPPc/j8+v2SpBPYS/jX6epZlKcXE9w/WyyIsN78d8uhmAewEzgKAT43carooERrJa6P+EwUJfW9EmuewvZmTN51fPxwnqa/Ell6fAg9PgCz5aKvnQiEyHDRinORyGduTrGVznN6VGCbGHcdfTMgBg7+zYUmN8AceADGcnNhIVdPlvE4fWZ5mampq5FpmguTqCA0c1Jrr762T2iEqQBtPX1vtybA5yzhOIhljWECgmklontLX73RjweC1vvmybS+34dpN7i1sYcACTM3Qnuw8GSUtK4WmwSbD0MCra954dWfr2mkB84Ey05pfl5v5jcXg7tW6m+64CfZJyy1wukXZwAyts6wKQE80p1NuE60OTFXG4tB4RBWpluLRBMnAGILilRS2/QMQeTcN/fnvZqP7NO+CyTG5FRcrnkdFLb8HJLR52QoHQCeC336PcKXy+qjHJSAbYf1j3sSdL/pmnt/ICQoDpo4GyT4Z32wDnXaPNwG9+OFnPupBtbxGtVvYpy4IXywWeKt864nqcLprQSUZJ/O0FP0Z2NukQyT2j4nGUDkjsuzxZiN/CJpkrvZHeY5J9aptoz/YulRHgpTIU8XN9slrAF9uDPabhPI8xXy5sloupvl3uvSgvNv4+wpwBRKtMbEG2U2d9H8X4SWuCjr4it4TWomulJ0E/RoBVD+1Q5GPJcA1SefpxbYCtcH058rlZqauVKfZ6lQTG0+14523THPHW0bBrrCLQ26FXT5PEKDLpkIpGpEqacjg5Pz3pkXQQtEud41ypxhaqY8F7LaoQKSFv7KANomkP0Ddj4+ssY/bHDkRk+E3YVpBxoEy9M8Mr2q79et+eQ4d0w437lneSPAzerFJ9aFSNsGhNK2p7ZnVd7pJZz7ZcaC53fn0oyWefHKObtluFnIUaCQpJu2FA4Bkm2aobIxjU66GeGEHV/ZBw+ACYbFim3M8+q11p2DLr6RAVt0APTOGkvIm+cy5nY+XRfo3SlN4H1gvrq3RXh/8vp0FwsR+iadHv8PNF+MgTdPwDjBKiF7rpHSE6LpPxGhqrC6iJfcAH2hyYsbR2uM4cBYI93qJsputevqJpldIARs9wnhBiMNdkzTvvA10VIPGvfC+PztaQebkoZA3EtIdeYaM0GtwG7VeDDWCLuaNUrgwpl6V4sO9MvAODtxiwlViiQekcg27JR9M1NpLKlIWIh2+m18iLL7UX18svRiwZTf2zVN+ggNsaMKGU6u1TuLV/pGX55sctplRM5zZM5d08xtV9uoJE/wM0zTJVOKSSHj3thztRoPSSLjbsH+6TkzxeCL8nmHdmO7sbgDO9VGMcaWWWV67qY1T2laxtEAeboaGOcCqV2sIYSeFsyHO/PnN4vJ62nJyrt3Z8i2Y768gz7c5YZXBa7WPjou88WbKNTZnjYPGXooTGtatJ+iAZcfm4fQ24GxB+IBN+bsYS1obOhjGS/T9JO4i+T5tCHCsdvLBf15JJe9eyKWmCUQYU+1cZznBfsnRlqiJieTLrGXiheYQB/OlVBW9qlu12nJCIza3MyHFay8CyBYoe2yoz9umHc9cKFDgQ13BVm+jKW3KqHtfX58LXj6vuOjavx2LVqe/v5AZM41ppErsFxKLrpItiYCkhHXJLjvbZtG4oCZeKaZt0RzWbH0iwvwycl93OnhFKHbmAkvvhbZ/zz60jeYFt8m5DnvRzyBZ/vOHcZ9Q7t440ot5qxr/3nqEJbRbkYwjlLOc1oXmDGAbnx7ed6dgNMz/ux94UEUeduh+4S8ecL8zivIm2foi3sTHKrAaU3hIgK5XM01AKCfvsyS1C/OTl32jTOO8XejlgL3/0lDvxZh4NpeiMUcVLq/N3AIA1L4WqvuvA799LoxxFWbdaQxDbw/9Kx9MG0eCMbO3oBOTT7MfH8e5vM/rIG0h/8+xcdfgd7Q31yD6KSnBexfEAU8Ti1Dg6UrT3vcrGy3lz3nmENMkfQnUwwEZImlhOmPjJ7IAMQxH5aQlwFIV2CWzNYPaHoeH93UbzsKgKSxkA6+HYEcmoZKEEzCjOxPWRyzU9NPpBBYGkZfI4bcrsZ1Hy9PNuhrpnqGViH4Njw5Z3oRTlWMtZllMRNQkm1gvDgBU7G/PAU4Y6BVA/aJ5Sk7rLTrjnG/YvnqYmmkANrTjv7FG8xX9yZ01jUptF3QfvDG2j81j92fT8B1g7x+BJbFtHlvUCzHsJ0q5NHYelFb7ukKuVwN+X/1AP30pT3LZbcSVa8vtthbw3xYTXstLQkmCre4Mvkm2pvFJCPM/cNGRlJ3I+KiLGBh/jm1IBN6WA69AoKBYPtkiadM05aluU9rThcrsNHfeK5DqYmobh9LRDnc7VJD/oXpug4M0hStsfr5cDLB44J7PKzR7YiJVA1G4BHPBI2YvsLSdF0x0PqwyFPzcZQM7amGFXRb0OTrNv/H2/gEeLgQwg9MU0WG1Vw3E56fKX4hEDF+pof2zfx8huDCxy8ZepbTbP51fzbwRraZSS9IwcIij/0yMHtz8BC26Ysm0madV4Jrfh2AZOaXFUt0AvW0RI15XtCuw7jcnprbrjvmw118B5fN6LZz2iZvzUA8EUvKebra35+9Asa0jbzt0Ic7yOMFulpzCHm+Yn7+KttCTwWGhfr05YPhDCwjtVjIUM9LgFQAnBcgUGlRYrsh/f3bduQxPz63DEHNbiCu8fXtQ9Tq8dxAFJckW88IOAlqwbEG67RjrpsxJWHuEJfaKoA0S8xihIX1DgjSSVY1Vo/QyISNy9XKZhvab0hzu2i6S95Ouz1tUZtPREyof/HsBT/hguBkY7UbZjTuFvP9aZ14SBeru1fT37tOjPtugk8aRk+86a1N/i4BfHN83Di+38EhN5tAj5o1wNRMk3K2ONiUgvnqdh6fhGmbjtl0cyUY1bKKDWmVnipLF4J554ABWYf8594i0052CwVGMo9IYAXsbAOFEYRKPJ5Iszoxp10H2nWgv9mwfGG58vNuyZbUM5s/Yl0AFwBRkfXLRxMKJN2oQu/P0JcPRg0VgZ5PJgheWJ663nkrKIb31sWQe7oA4IJSS+IhQQjp9y6P8xCqY+gVQFhU9kf64tX3v43f0yow/568Cn8tBDbP7+atZ631iwvpwv3vF6M+R208kbj2PBkzjhuO9OHoU+C1CazMuLtz5D2IgJV61M15mvRy3a2F1+MV7F7c31ws3MqQrJaqTJvXdXh99eewcZZdY/2Ib3piDiT7ZBhcczy5ZzyXoX3Nxv+4+fiKjNvzdWr+oOFq+PxR86wJxIP/AkRudvMUS22C9nS1UBeLZIwJmRmfj3jv2rC42cd86Hov8bv7if1igGD3QgoUJqQKB9FiTMxupqSqmdYUDIcsLafGznvDHuQycqF0gToJBPuA7AN6f4Y8X8BkD6wL5PE5FyZgFsDJNLVsnoZ63aD35zT9SeoZiQuA/PM5bYGvjgE4QMiMx5oook0gi3q6bE5uWONqm3JCHImmEHCzulgJAJIeDeTqrPBAq5+zN829s0QrRly4oW2cCA6axm9o5t8z4sL14CnbAomGnLJNK909FO3xGvwNcUIVqd6s1DvPq2X0sSTaUKf8eobiPqGnHi3QWBFJxoyIyXGTIMLS8RrxDn5Yj/847vVUt8fH1/gAasiHkxyoJiU8Q39cBJouAv+O0w32TZNguVWqbJjn3uCA5ashMGCFGpX+ny8m+91LdDGOOm7ZVBlCpKZv14H2tEfxxbRO3LRTjdLWZtYjwnaRVUez0otqyj4i/KRLImSyD/MvyfZTj+eLBGWXNfYtXm/pqOjNTH8Cfm+ezfpgsQ8PORJhB3JMjvkTCGJPpIoWzCQo0UjQKhWAz2eE2xCCI0pzBd6DcLFCUIhEP75bindUpylUcMMkkl8BIFKdY36m06pJZ+a/agUxpLebe0mBI4X1WGsgxuulRkD0QtRi9QBJJ7/hN9Txjs/WvfA1Pv5HD+fVhXHYvAHk2evBg58avlD8PhMcwdTIJovqtECaZX6OqCcHHPLv3xX7rGQhglvEAOxcvsHUBQFdgsswie/dV2raq9V+T61hGMBuGtzNdvrsQkYdkLFmtwDk+Xq418oNF8+9tzTe7vexp48vYmAfz+ulp3B1wokz/8IPLub8W4fmImSKbRSBLKvswDjj+FYra+pBUABJ3skNWyjbvLYLE8N2POqjAAlPbVMHEo+CCjNdMQpiqSQpIOeKLlg96Ba5axA5HZ7fT1ZgoP8OBIawIv2bZLHDeMrhOoe1ScV4OxUV9Hz7bvOZPvDe39EhIt8Xkb8sIv+zd72vKJqALLmQXJm9pe7ntdDahXs/bYFbq2hrIhH16bzggg04wucDEMy8cAMKV7oW+Thkd2nea/NiDeSCR/39MT3JhkKgmO3wny4Equ8MN/Owef73tsfCsffts6zbTvYZANukwzZ20DmXbpt7H2a+n09pzqul6MLdBD2bya8i9vo0gaFn+51ZgRwzWmFAWbxAUnN9ETNbzPARBAAYY1pAP/6d5BoE+AXxuH6YvQg/Itqaw4VC5TwIrTGLyvSrNZq0f2xMiVwTnux1UBC+idvrZ0SKbmH90XSvtf0Pa7z07ouEIa/9n/UKrLQZ230bHsVNbd+Nzrh1OXKs+bqUny3H+33Ht+nj/2FVfW/DzOBvb+9/PxbH8A139cUwy8JAlZ7cmKZJI52UJbEdyKv909tlx1SvisvzODvWFjDNaS+dNRyc83ZdKobghunXXMpf9jRZNxdIYwADQGtG+716rfalW8ksEcjT1eO6BJusF5tcNvv9+19CX72ArIa4y+VqWtuvg+tmPj4jA4/PFrPvHe35Cl16MAEJJgGuRYlMf/JgocJLj1pzZK4ZqQUhGDM//zivusQlAAi0J1uPWj1zMUw90SWz3S6BdkfWX+T186cJaIZrLfbvfAwSeIqVMhevqcBnp6UIhIAO12ufwOUKPT3Yc64d7c2zCUe6R2zMCXe9XLAboaqb0HnarDgqLD/EADsWcjGBynsQrytAAcpUaCvMYhjGwbe/2eykS39dw0w+7rd1fCYi3/3aT7mmr8hvgBTDKudOalX1FtMNh6qlcKk77xe0pz0lMgtckj+/jSiJ1J+29HWLCXaoNnOd4W8xAgA3YcWLXvRnTyRwJDfM/KEYL05oXz0nBdN7tVsJa/O325sne7Y3T7a5TqvF5AHIdStm/4A8X6DPz5DXj3a/3//SPrc5FvD4lBp921Or350MEKTLcN1MIDheEELm3htNENjzijVwKrNtDrWaiLeLzc37wzwCB3979vwccZZImQ7AUzOVWCQ0MyM70fOQyVqSBK4Q8AD684iqx6JG2CLjjQU7wrz3+voyRmIjAPThjHbZ7OfzNdiNej5BT2tEP+ARAdY2EK+qxNwHcjzEz92uu4VuXWARP5lO2ZXqvjazAPplBDU5Qp90lV0YR04+cYwPaPxvc+N/DuB7IvLn3/XmrZkXvsrNzTKMZw0WSJSZEXMWAirTS1GT4w73pR+3I+3VQZdgRzk7y0paabxn1zZTnht9nLuxAC8ufLzDKY/pXVhJ/uiPG+bLM8bDCSx2od3otdQUelohz1eMv+87dv3LFfrJS9uAD3dGrnl8isWG8xlYXJ3enf3Cbia+emGovwOC6ppfni5Wc88z9/TujPnyIVB7PS/AmGg/eOOLcGC+vEPUoCPBxPMfaiUYln1C/O7zORBErGg6gvTPaarW1s8y1RNtPPbuRK3IHrxm48gIw21J2QYAOPdC15aNQBToT8Po2I87mJ0Za8wLl2jv2UevvEdgVC5X8+M3K2DS3jyh/eC14SYnlt/OKM8hGchp1fwMCVtmTXiXH+eSRBckB5GbV3OOwjMefXgfZfebaH1R/Rqb4O/wEJE/CeCvqeov1tdPn3yuy/2L+Pvz/8LP4yf+wT9oPP1d0Td4coxJt7tff8a4X7IeOTWrwmiUzqfuXzxhfnKf4EqXqEdf68fLMHadFdkcvqGHJVc8rBbaoxnoVsE4F2CGmowx3oYQGDRnWagxfHIHfaJhBfvdqUK+ejTNPCb08Qny4sE2NMNt+4C+eYTuO9qnn1hc/uJU0HUJ4A6wDW8144edk1TcdYGeVrSv3phQaS0tgxrWgwkomdapZ5668SDWhnHXsL1oGGfBficY58RnWPYp5n4aF6NfkpHZN/VGKhoknqx45Ncm0g+Ey0e/vnLYM+nHim2OOzevfb6jIg9xHwf7mN/AdTEfVnTvOcCuOjKnuV+e8SiPl6hdoB4ejcOxEArSeVrQvnqEvrzPCshAMimHWpuvLpE7YkrDlRLvG0jKuK+37eWCuQo2r7S7vbAKxHM1ofv9/89fxQ/++l8FAIw3b3D98nvv1Pvfio8vIv8MgH9NVX/5fZ/p9y/wM//tPw72W+9XhWwEPODsOvts2xT7i9UmlH6l+CRMRd/Ml+4/eDQw5jGRbu0lbbUhsqrmqYVZNV6ePKTSjJbJkIsj7fursyfcDOwvV/Q5IlbcMBO8cw3JZJYAiZyqyc3F5Bn56jEptq8e7Bz7BbKumWhz3QCdkGWBvHwBvHoAvnqE/kd/2yy973xmAsA3O4AIUTFhZ/7tXwX+gd+F9v0vbSG/fDAsoKl9j2Sf02JhvE8f0L54xPzshVetdSHngFpUtekInzMKbd4i+N2+066KFki1HuY5THZadL5ZtWfYjgzKVkE0FwLL6z3q65O8NU8dy+tr5LzzdVtQ3oXI/frl177EfHkfwqA9PUH2gfni3twtVSth9sUbI0QxfHdyCrMn3qgI2ldvIN95BX1xB8xpQoCKyZt56ipZg0GRCTp0DWjiu6sDtcxDqy+R7MW52rjBMRUV4LOf/Xl89vt+HjKAv/W//jPv3aPflqn/l2xe5A8BwK22B5AmfQA1OMTxI07b4ZsIkb4aee702eOckmwtP5r74EbGMI3e3mRhS7K0aHqJM6qYeBEUy+FknyerR9f2aTTK1UtO+wTNU8/svJqie1q8WcWaaCyz5LYd8uUbQ/VP3jt920yDfPbKNrw/G37tNw3UO50gv+MnTWCsi+cMuJvxfIG+eTQBdt0gv/t3moY6rSZ8tj20E6+pd6uNz2mFXIa5BkB21GHEoJEQQ3OTZroPuB5/sstLYAKgH1o2OZXa1Jj30OgFAT/Ms7tsbVen4noOhRetBGD59HtmZFo1ZAtrLl8+B5inD2e0x4vVyXMm5PjspVlkSzc8RNVcp9Vp0oCHW72kmWNQ+vLB+Rd7WIxG4/WuPYUjEN14Vid4eXJXPKZ/f9x1LM8DnW3VS8Srhvx0AeYZWRvhP2sfX1V/oKq/rKq/qKp/4p0fEmCe7A7qoomEDdcw/Tn7hNEvN41dOsi8efYuJ0ZHlacrcN0sseLNUwBKtnm7FbH0ggnUHsuXxn6jny77tDxsR75pjjL0OM4d+4slAC0r21x6rpOk4hKcvqLhDhfTuG6i43yCvrgHzifIV28MkHv5AFyuAfTpi3ugd8jLF4Ygn1aLEnzvi4OZrksH7u8gd2cwTi9fPSabr0m4DgT/6HKox/FlzgT6vJ5cdHWl2a30s5GbupjlycBEaHOSrlq1kku6bYCDAox762HQS+EUWlLxXU+cioItzyPWCklUsxQLDXIMEOY3+wvo/cnSau8t7bZ/8cbcpcdnYzwCwbGQ56tp+3Vx0PWaffkKOMjCHAHsOTEsSm8pMlpCrS8S2j7Cxb6OBiMcNYLSC9bSgLlYvb1bt+v2+LgEnmDlpY9X2XlhUjolk40HwNx6b4YID1FFKqubvc0r2giplfuIttK0BAjkjIdTNqpgAwnvdtO2kZRJwJlaeliE9kZKYOtQY9VZlO5HEDXSHwTz5wHIF6/tteHsu2WxTLwxIc9X6Pe/MDP16RnSmkUCXr2wzbzttigvV9Mmp9Xe7x7aG9M0F5DhKDebtZsPK7P03XMrq85BPCZjxIJkT8bCAw79CmnRBahXQnrtuDLjNRHPxVBPu9Xgq0cI0T+PYonY3Eg+G60R4ise0ZHLMGakGg3XtPoF7c1zJClFMZP7s1coGkFpJujaHp9tfu9OJmB/8wc2Pz5nEIE871nSi9V1HUtgzn67MBSIJIZ5Upd4L4h2teIyUR6OQvZG6LIikvYPY3cfd+OPuvlv3lR4CiwQ2W58q4JQa8dkJRmaPZ55BuCYlAIEAh6SmQNMAMhTZqu7wJroADKuXIo5ZqxZUMNL0VbZGzAeaJ6VgefmJTWLnk+RQBOAW2+m5VUhy2IaZ9sC3NP7s/30f7cFHaOw5u6uDGvzjWmhPjIFCxmF9ejIKKNmqWm5tTgGgOh5ANyY5yEINNKV7TMKFulg8xITLI6h7CkMZBYi13RE/1JdPboJbHk2stIwC5U6eBYNRCgkolDpTFDVac18XbY9Nn+Y/nTN5oS+fABLn1eBfkD3WzOL010VUnVjjU4KNFM87M1IHIBWVjAg+VV3ibQD+ycjBcN7jo+68SNeP/P3iNFqWgPByWaRhVHMqWaLJ8CzOok7U2fF6afiIbPsRU/CBgFB8qhJngiudfhmZlpqB+ZJol32XK3JZZjDKFpI4KQh32wTZl7TLaja/+58RIy7V88VgZxcwHFzn88Q1zqs6GoPYRaA3lvVHfHS2rpYfN64Db6g/dxwNp8483Ce6MaUTd/ksPmjwo2H8GrS1S2V9LZ7KzV3LTpaG6QEE4+AHH93k72eh9/lGmH8P/IiqOWrj+0WgDHy5rESL4WyJzixRJkpAApIX2sM7zlAKkNTqLDOYc9okv2d/Rltg9ISLJ/h+iS/wZPEmItf15Y9f/l3TUX1vuPjbXz6gAczP9HeTM5Igof4gB82PsM1t5TJbiAOJlMZNWmnUwNs0TrZbgHUctg0TdVNQ2o7a1Pc7N9ZsqxzSGTJxQK4S9IiAcjGQN2sPIUFElRbIK0TX5zozcpkOVPPTHimcxr5RKixVDNO73z9OBefleSg0+r37pVj/J7naQnyEUkimeQEI/I4OHcogc0pDpO8zKmDU8EDCPPfv8M59+9YM0wUhl11uSRAQhvX1Hz1+jzo5lWqtMT4zXAPOAZBnjqsW80Nz4SnSL5xApAnQ+naTYgX94n9DjAsOSxwC+c7VL5+pY5bOrccOBEHje5CVzZg/VIgQz64+X9IfPyi9eO9Y0HGWjQztC+TSNjX3LukytMlw1u9SO/hcVp2Uw3mmkZ6LYDjQqvaeyI3uHPQ97P3KV8lTM0IsTDC4KmuZHexSw6Ag0sRqbcPd+n/Tl9YzSwDfX5O81QEuDsbKt/EhB0xhvuzabK7k73O5B/XTFh6ZPLR7BRV6xC7WlVZAk+Ww54ahtq+7Yhy54fMSZRNN1HKi3MsiybT1PR17k0oH88ZvxfUv7N4heDAmgwu/O7hVrpbi1tcly1DmdWkL64XANPmj9ahSC6F7dmamfrdXS3mR/jYGmiqYb2FqU+3ieXiPOeflZi5zgBYxOhkLmXWcUwz/63xmUDbBG1YsZgfzmKbSjM+X2LVHYJF7Wq+2jg3i9PSfBMfHGa7uamvJ/OrSGgBEKCXfdBX41C0x2egt9AC3ctModmisDZSANNEu+fJs3GmnQ8RoqLWYcsu5t43L6s979dYMNS4LOogl6s1tnSiTWzI02qLSY2Gq+eTofqXqy0UaiTiGxQS3awIuW6hnSz1tgcSzTi/ntcklvgGnOfFW0GVDe9U5VqDMNyxAS+Qaj+jktKWf7NYRxbWKJpbJDR/XGttUT8vzV+49ZdjjmFl0NplZGss1bRyKgkLtmbkSmzElQM3q6q5Tk8XUyaOnYTpzwzH52tYdADiHJH+XLIX2cyE9RGjmQlgoHFv0aYsvtMLbjL12PHJrc1DEk7gJ2mJyZ6vv+v46IU44mZnmvkWdklm1vJkMfu5tKieI9cdckkqpFx348XDBru9eTJz+Lym7y9ibKw5MV/eWUKM90ab4n7Y0NDGXusD7XHDeGGFMljwoV8Mgm1sVgHf/CwTBliLbe/GarXukRmDXHj7hN6fIK+fMD9/ZQvjcgU8yYameeTNu6YBTXIKk+vMenpwYeLltUEf00N31tOth9uDCTNN71a0NxeMV57gsyv2V/1Ara5ZivbMRr6aq789JFD9KIMtBvqxTHo0vlSBMioAOdQ/4LW0wXocuuXEyseMoOipY3lj5dOWry5e6VYC96D6VM+TMJ99DQoyFiP4YMISnz4xNmn0E3zzZOc5rZjnE9oPvoK+enArwNaKjGkJPZ++dGrxZlyKVy+Mar32Q4ed9njN/gewMKRRvyV8+dsc+3FqkFUxVtv0Aa4Wd4qMxwMd/j3HRzX1W0F/W/C6aerZE+8ez9Wlob+5IHLbRYIY0d5cgiBjBJSrmctObAFg4FW1BCZCwwK2IduXT2BlFRQiBTxJAh5njnbN03jiy7MnroD+qRYhMKwA48X7stPkhFkW7fUjyJ9vXz6aX81NXSITunR7ruZm+pev01XZR0YCFndllm4x/gkj8Tza2Gkv5ulpcWEBi1+rxqafJzMzZSj2+4ZxJ4fN3K960Cis6c65o1XExci22P1CyYEsmkFl7J2I+nWiP880c72xaW1o2q4jGlKwmjIByXbdDzRpZnOyxwDLjLXXj7aenq7GuGNtg6K19e5sY//Fa7MS3T3QKFvmJdYf7sxaeL5gfPbS8ihUjSD21bMRfSjXViutzjWmJ7NYRG3TE/diX8Dt5XIIfzL1uYZDgzdBcPVrNv7HK7bpYA+QEpygTpjX28D6ejPJujTs37nH+huPaTaxBPT9avXfRYDLFfOzF4asLivar37PyDC7mdDKFlHXzSbrcoV2C6ONzx6sHPLTboUmGyypY2kYL1bIdaJ7QQbtgvP3jcXHkAtNMZr4oRX3ifHpHdqzmZgsrNheP9uG3c381NOK9toSctoXr83MdBBO785WG58JOC8fTMi9fjQL57qFWyB7x3w4mwXvGX7qPj1kM6KQKsDOMN5AA8OZbZIgkrIz0bSFxi62wdH3RaYdXiMxpziKqLjpD1hlXeaXTzFhMn0htCFAU2wvO/pF0Z+HU6vTN25XB0FXI7T0JwfYVrMGp/gNOO1VdufcA8Cdu0vDYvLz5YPxHgCbBwDy+sn+fuXvjQnsu3Eqgg+wmyYXR/QBzIc7G+sx0X/9B9BPXpgg8eIqZvGZ0prn1XMCrCR3//KKwRLv15EJRgLHhRDJYvbPx5lkngL2HXoe/FD6+IBrEL+RoUFQyJ7gHfuLFfPeauct338yLU8+/TYi712XZkw3B0na62e0H7yGfvoKrDkHwCbui9dRq072gf2Vbaj+A2PJzYczWGOulr2OY1j8mOCLeCRAl+zRPs9WjLNddpsMgpSPVyy/8RrtC7tWgI/rgvnCTeyZsWIWwmg/+Aryq7+ZviQA/Nr3jKgzsusuxGrkt//416G//XM77ycPCJ5ANy1K2i6vCRdo/XnHOJupOe66p0Tno0cJtIpziG/sW00zXRhUdJ+atCLTknH9ZDxaUpS1hi7FV/iM28TyegOzJKNRqLMvsTSzAJZmrLxXd1bT8PniFtgV7fUj9MGFKyMsdycbe9Yo3HfT3qxR6ACpbLvNg3MgZNsNQ7k/Q1/cm7L49EWUQaOpT7O/PTpQKGIdlK5uzXQqC008wDd4pCWLWUfRodhp0beVrG6CGofj42p8N+tr5w/WXmf9embj6doxupn7DLORv96+9Dz0hzPkqycrK91bADZw0xaA/f7i3qiYn7wAVHH6W78G/fQlpvv2FsLK6rwWVjIeQL8My1I7dWdR+TO4KRbZeAIsX14sAehpR3+8QlvDeHGCjCWShSKBZ9vRPBynJzGufABrDXJaAb/fqKDz277j1oCX3Wb48nzK+PzlAix36eZMBxXvJdOPHemeJ68c3KwxCXPeD5EHQXDv2cut7RbLZzitplirpEtXK+ECaf5rB0QEDV4s43nCSqMrZFo+BOCfLSm88JoJAKIxSbtkyG758pp1G67W+hsnsw71/myMxadrsiiZrLQuUfhEP/80Ab3TCvzgC8jLlyagXtxHWA9zGjbEKAAegPvm4GmLegwWdnQQ2cepXUf2ECA7sYCp2szHnws8goQMhUbOBAc1La0PHR9P4zs4wV5nNButUSA8o2tG6AwestHzivHqDD338JeZCy1l0oOQwoIT5Eg7rVU9Ji7PV+gnL6w66ptn8w8919/KX7MMlp16+kKK0tgXW3izt6SjqtUMGA8n9NdmSrLMcuSBH2i8zbO51NJo3zzFZ4g4V42ud0bHNcExPDowg3+v63II7cmzhewMCzAuPoCY/Xlaojw405HJiIu24EDEldMdS1DpEDpyFD9AOh7q7gJj88UsZViwbRp8CF3Mjeqb5Ws0r6HYn0em3gJgK+oYHxdkZEtG3Qai8EVrY13s9+9/6Vo7w2zydAF+4/uG8j8+2Xs//nlUK5bni7lozqsIws+Lexvn10/JI/GGKjKsrJlsI8PCXk77QEUGHN8Q7HcN272HjT3BaS7APCHLmtH05zL5mo3/8TvplAwsAAEQsYxSNe8MgZ4WriDrrTW0sScxhzRXVqU5rR728UIbWKL0tC0SR1YfL6EVrZ2ycQSwLNH4AqqYdyvaZce4WzIWq3grFm3n9qSf5mmYvaHtZvsatbMUXRAB7s3f108eTHJX6qgv6KjX5ywxfbgzgMvR+2C/nQ3dxgsvqPF0xfz0waMWPbgQ06sRq7QgS/GZAERqbNuttdU7K7sUtD/QZZ6j+Pm08GqVXcbgJwRNvX8CQd+RQkCCMw0k4cbOSV9ZAZu/CTOZd3VMRdLXZ56Ex+3lyzdmMd1xM1uCV7hGFAz3d9BtNyGzLkmzJnbCkmeAKaEnCnWPcnjBGApp7TYHrO8fLctdOIIgqZv0zLYLk3+B1zREulskPdXxf8/xcQk8HpIJ6e8LKMI9QCZlTK9C29rNOdR58x6e8pCWXHzgr1toS71eMyFmzCCxBIoOuw4Kg0que5TtMk1m7/eooAuwQlAg2YVuGddmjJr97qgFRs6OxkbwxcKkEEYkxMtiiTi45I0aWSWmu7bjeABR4GE+nG0sSQRhWehqxY95yFtnZlxw6Vua88FQZFiplwV3mCDENer7TDSJ+fV/wf1XeA9CL2fugCOr/jIycqC94vhTWfKMr3tmZ1hSw8hS7D1AQg4JOABsfQDpx5Pgo3XeTJjo/dldNQ/xrUtyNbY9SFJMxmH+gY1N/R0Zy1dE/kOWLktTf54U404xT4q5OLj8Q23qg/6gHsEjaoh645Xs4UkQScN1RhwJMaoWBydZZd/Tb1u8Lzxz0sltL6wt5vOzaILVY6OG9ZALs6w8byC0JHDIp2bCRQi1JlYYopRWYpFLmt+H/GoPuYUQ2ka6OHfefpkzyMUsZbHTN5+wtE8v0CGXkRWGPV89/nZ8IlJufRFmPT2JRXfY0NS+RftHLF5uPtNwqA0XvP0anirgYVgL3DQ8+Hm/RruOJNZwfvgdrg+uIY73nVl/8b3es3PwPgy88wYmQQOn9alJJQ8qNHAMtTWz3LIgqq+11pKyy3Hns9fx87EgCH5Ivmk2huNOMc56iO9/3cb/IQD38m/rj2cLr7lpJNsMYG3erYjS2ACgEum2mBO4P0G+KLnngJlwnKxzydRTo1PSVFP6vX21DYtjgQ/rF2+hRWnIBgi7I/BowUGoCHOAXVKwivr+Il5nwBcNhQ4AnCTMWnL8pX4WMOvm+WrNL0TSgqCv55lewl4Emzfs8O4+gG+ypZlQcq66hYvc1+6p5Q1JltjkIQBuNnuY/lWoT0RSDjd/G4geFFoBXhi+wAqz8dPHuGaqAaZ1GVqL+L2WsaIQIFhJYtR1Tx/dvys1uet8sjRowDT6k1XajRZlTSJrTwCvoeglzzm2ZO4BpkR6ts3OMdPDuIqPhykOZiYKBgWo75l31aq8TYh61/FxTf2BmMiotkq/TrghJO5SF0nTngvU+9BFtpUTKOS1VaCxctKayRTMVLt3YsZIxhv9O7lcbfKovblRW/OuOFuUPY5jGiDGDC4Seeapv4VhAEC0TV4aZAzM+8U0sycDkUXIVM75sFqZZq/+Ig5aWQGQnhq/i5v6zbgNWtwRuivNN6CDcMEfd2uqjZnYS1gUZZPTFGfuPRBFNmNufVHOjlig4b7RrPd8h0NVXvqspAdPluBS3GbmAcicgi5WeIWkmCZmLfn4Br2ZgpRhPACMzWO4GU9ClPv58nCP+ZvfNwVDRcJ5nh5lOa3A03MQoWrKr/YeTEDWMGTjjnFnGNA897RkkZs/yWKIeazciH4RLF8J+hPLlOW/Dx0fd+N7nJdphszcCvOH3HyPk7cn85NYhKPGRtWtAf3JH7NSyC/ubQJ+43s2+HenZLdRSp9WA3YG2SXDzDnAhUbDvHOyS2sYr85x79M7pBCnCHQWvuDP3ReqRrlulFxxAAHi6GmJCsGk8jJvwHrnDa8ZAIxP79Ger9hfnmyTPm4eF7YqMLJPyNOG/sWTCzEvPuKLkdRhAOkqTITgmI477A+eCjw9pr4mn57amuZ7rQATvjo1l5vpNjCIcK3sQH9W9NIIKOrtD5t7a5iRQnPeOYuzt4iujPsVKrBybM879penCMEaULu7q7McBCSZjOEenU9pbvdmiP0lK+vIKXsYBNefyVHMDbg7Q97Y5tcHq7k3XnoEyoFXRheYix+1BRilEI9wFPyEa+rgBvvGlw3oV0G/CNrVk3OKsfq+46NufABgWabuCTkQM0tZE08XI5WYVG8x0PO8uAk7zAUgoLYNC6MQA/jxz+31x2cz7Xuzzb2Xkknf/8KAmE9eWjjsfLLii6VQYvvyKXKtrXnDsFp9DpBlIUfTVm2b0X67Pe0RAQhQTb36Cv3S6UUaInQpEVZkQlJ7vIJ9AdfffAOIWN33ivj7QtV1gT6cMR9WIzY9b9bIsSGz1Eh4ucsKr+1izLH+PL2+gIWRuKlvu95q8dMjzMSab62+bxvequwqDh2SnfzDOYyiJkAs/Maa8l53n5Tc/voaRTXHizX7HLCZZSkkYlmYS/YXqDgRYAUyzqeI9IBo/ZyQVy+h3gPB7lHAFmbMC9BHK9JpDVOMW9GeN7O8ugkphoKDw+H4gHo4uF2Gg5kuAGYKRCAJbwfN7mPYNgR1/ENlt4CPmaRDSTY0eN+UaDSFGBffX56iTRZ9VRR0tl12i1WzYCZgE9Sdmnt3AqvyyHWzQpQ/8WMWn/3qNfQnf8KECHr4/kbLLPXv70+m5Ul2ue9BzZ10N1QtFOhZbQytjYcV2RLKY+Xd3Ib9YTE+f7eqOe3xGnFecsLDAth2U9B3C8RLRNf8fl05uO4mXHdIa9CX9xj3K/pXF3MDWCW2GS7RtoFxl7n3sk3sn65WZIQA3ZKgXjDG6JO2nLu6YacczdJlV4yT1YWPTruqkacR6yJALWCeGpY3u7WZIqDGsZ5Wpro979BTQ39t/AyL2LQMoS3NSDMOourdapyPipWMAfzgDUQEuPc8j5cnI3p5azH9yR+D/Or3TLOT/n3n1ZGnQn/b58bWfH2JCjx6f495Z2Pa1Iu6Ojg477ptdKdws+qOjYVbnF7ope2KtgnGOd0ApkMrwc2BGMsQpu85PmocnxKN2WwqBzcxSDIhCDq1JaxmnmsrqWSOyx7pk2HWPV1MkpN66WWR0Rv07/ttZmJPlPLXa4Js9LVVo4bfeLFG7FXdnI/ojgDM2+9vNjPJAbSi0cxd8SrB4mi0k024yceLk3dUmekfvrqzSrAk13z5ZAv2fHJwr3uc37T++PQ++Af9q0tB0TS161KqBDszbi7mDrRNsd/JwTdnMY5ZNj0cYwsYgziAlBRmmMtQNzjfmR1WLd1JP7bhJajb28sFpy83sCgltukuSEN/2qwu/uMe541wGXLMyfmQOb1Gfo8EpQjZffaJ3RMxAbYnV4V+9dqiQp99YgLr+RrrC0AmXrHa8ssT+lcaa4cWXzA2VdGf9gj3jjurCJzlwwDVafwKZzaagM9CJpEb0W24q5n/Fq/k5vioG7+ik2whzbJX8HLW0zX6PHX0Z2snbJrfCRiwQZxeIhlNIrllvjhbZtR1s8kEEuChxO/mjMqbJ/fZWhRCNC0LQ2HvXWvv2T7bBFFaLwDA6j0KcZ8SZj4vkr61wNKA/Trjfk33wTV+e9w8dFemiB1Z3Hyd58UoquIsQI8dz4ezCypD8PXe04y9ZoEKEo8Yhp1Y1eKygwVeXMSLcZQCENM754SfL8gccCp8k89o6pu/wVBqf36ZQFM9YAAyjL49ToLlaQZ7c3kc2F8sZu5XJuFQjJcnj/xIELNir9OdKZx3TGC+ejAB6Wa8vrizud32ZE2eTxj/4X+M9rt+hwHFP/455MvXwfiM1GjnAKA1y94DMD5/aS7og1mJ/c0FTM6ysZEIH7IPg6pEn8ZJtiqKZm+2saPAxkwMJYBTBwMPe+s9x0cN54ma1o9eePtMreGavdYco6RkJ5RokOExdj0vJs3Plm3WvnpOQQBE5VN9OLvgELQv3mB85xXw8Cna963KLevwRaksZ/1RaGhzyq53yolmnEszwDtCYl4WarVkk35h2TDE5lIxPECHAZbzwYg53UNOjE+zM9C8X5133sLf5yILE9+BSdkUWIynPl6eAdZtb5n7PpdmbMTrxKAvXLQ5efk2MAXAA5zH7xp+AaYvRFoGgA+Zg1DNuf2RmouCGZQQlBSFAMAq7e7qm6FBWHjVhSpBU/Y7GOfuJrDH2XUA2/Smq2Yns76BPF+PgO5LM93lckX/nT9lkcmXD8D3voB++tJp0f75AGO9JHkTCxlTaTQ1I+tkjFC2/wKMWBWFT5wuHdWbnKTD+o22B9LtskhMbvgQABMR4mzviIDU46MW4rC4PWyD7zM54BNmvqh6WWv3s5sNwng4WRjHY9oCp2Oq2qZfPfmiN8jTxTqijGFm8WlNBt7SnW01gG1Yy6PrDt2RhQ+XBu2mWaeDM1CfuJMWSjFs4SximVbe6BOwApDtZjEDafbRx2PZ7jYG5tm75FKbPZjLYOmzPWi3lp9f4/qAThcap8Vagt2vQd7R8ln64+15YHr7KQDmvpSabbU+XlgDHdm0QUybo+d7aIgwVA3tNS/MwUXcBoAbs/SQe+5pwWlJSJQ9j1bVHtZkWI8REPZSMAJXD58+Smh3gWxr9hkAUBl687OHTJe+O5vP/vIhw8K92xqb08b6RLbfxHhxRn+8gtGhCFP31PrZHLSMI5mMcLeB7zlWEkK3DhkFQqD++rXI/kdD9XnfbU9gL3jblICO4rJxglFDHbwpRJVksnWPT0/PQTcaZqTkOqlHPA47750Q5KCPXDanyQLB/opqqOmvtn0aWls6tNh5NWPxu1oYbzeLxkKCMG0axJgWAzE9jZTRiygk4TH5wAecbCOejRavAYhqPAS25iy13fRwr2FqavHz4WPvhTXt5OUfEOE87cD2SVKrY14bjjzysiDt+xTgOBRiyQISfp+8Pkks/Fc4EmhWi86iEnkj87wgm3J6vL3Wu6vsyLtTNheJuLvhPxbOs0aZ2LYs6cbqPksPhifYk0DTMiU9+NA0lG6qaggqKywyc/yjhJiNSV1fgalQeAKhLLMqNb72+Ggbv8bAefD35uG80EjbPCw+ms/cANSc4Z9fjI0V7Z6BiI/HMSaEYcKWG0uJuhYADNPdidKuiyBO1gj0jeR5+aG1OMIs9USMQWF8gqLtCGDWxhIqQPYL9Hsk88w3ilKj+QLkuay5Q0thwxRj0lObLbRaux2AI/gJxN3m2RO8k11SszB0Rwq9x+pjIcpRS0nZ0PZCroGouhtYQ9b+CxpxuB8uQAVZLts3VRw+91Eemz70RITrmADGc9q1NJH/dU3mJxClsyP6RByB64DhRN6GczYOJCSGbV0pJHW53MO7joMg9peo6TXN/h9aVN+SWJAMPiBu1opgFCSUJBggurfKPo0AMhQiGqw1W+Q9fV3gqL15/cs16tBpF2BdXXA4KHbuOYlALKq5djSSYW6PoMFOqDgOwQUuZfFCQxsAvlGnxu4IzGOqKcxeKMHOCLQOLbmpOVYAPNRXhMSUCDnSNWDsPbvRwGsMeP32qZBpFXOmSGxWrrrlEenTF9+fBVYitPQuDUQGmpZNzHs4lO3KHAHZySg0yrZS85MY5UKtlbLpkVvBjccxbzh2U2LnYtY1EPEkGw3QNIuWpnUQwtjxFS2JV5EfcRBC4mNJ2rECA8HwpNC/raAb9xkDhUNk5MDP1/eMeTm+dY3vbbLf//6gAMhEjXmyvvME2diDXgqabi/gQEZRn7R5dzLzrJI4SNVlptf9KXvtOTJuJydBxIGblglB0dSwjj8LI9I056RuI+iVBPrCvD9wzJPVx/TSeXL/3RfYoVGGm7j0dUOT+YKZa3e3oYdlVBNASBQJZLkkyJAtF5/11w5UUD3+Hv7n7esoAgEAGX5AOY9v+iocamaZxamZq4CgapfFBdZZEHWLpYZ9+bxugjfWzifO4Yh+kHm8ZmEIAJbrvm62fljjsFFwtqRtL1axmVZeAqzDE72Oll27jrAUmExEii4jXDZWGmMXOAuOG/swN4zff0DbA9/yxheRXwDw3fd+wE1VPjA3RLuW+uKenigK47PDCCetdrXtEs0eo6BhS1cAE9CHc2z0IKoMNRT9/mRIuVsFh8q9z5slsHgzTV2aMfFu03h9QTImvr86h08KX7QknWBqlN0WRRThZJ2+djVWoIzp2reFRSDDc7gJ1Pn50cRdpD04AvO8GDjovqRsI8xmvhY/AyV2Us3Vznsw94eZ7/2qaBf7vW2u2f1flNge6cPXTjssrFqTetQ3CnP5uZnmydbD9FJgh6XDeV9NkI4Hbx5Cf5gpzY6WC4lWbpG159JjgDUPajMSVSvEMYyooy/vTUioJhBIk7yE33zhWzWgq0dbJkDfPwWsW4s+3izQEiXM1TgMk41YUTY/56UK25nq/5tw9b81U19Evgvgb773/anoF/Weab4Bdm4Sp7xGySXXptPNK5pJRMQvPmFD0Z4vYNLOlG7rbbUkCVZaNbqsAX7917/A/M4rq8NGemxMZNJmrZqrDde8tyIcZBMqfGG6W2C10zQ0axsukES8b5x66MuIP6y6GhVbVYFzVggmvbPNabF738xEgftlpFnfeyYv+djJdcd4sWJ6Ag6AzA5TM+eB1PBtV1w/6Y6mi8eRbfz75rfljLu5iCne6vVoLszI1R9A89dUjNBUueizy2HBsoy2TCvsub4esSkoULMOv7H2ZJ/YP7mL/vGAa1547XoRoPnmPS1e+EMg9P09CoN1sdvqzZJ5xLj9pONGSTcUUhCjJ2HJebbgGEau4jrmnJ4amCDVCDAPi/4QY+F3WAyFoGrQeEvOfjBfhdbUh1X+t+njf1dV/4q8B6S4Xt/gl/9f/0L8/ZO/4w/gp37H7zeSxlCM++4L2r4/fPBarlf7+2lHe/NsxRQbsH/+wjSeFz0gs4859RjqPn03Yst59fJaLkgejDzTrlfb6PQJiZR3sWShRz83zUz30QAb9H1tkOkkGDRgAfrzyNxtKTnoIsY3dxJNe7I8hdpMAiKuwS2Tz2rNeZ22k7P+mhyKNbKWmy1CB0B942S7L9eGgeonRZQx4b7ZipqreqwcsaHbUG8ygkDro1oyx8O1f5BLXMsHbTciNhJWIC2P/YF5A+mymI+vMT66WMr2dFeseatsXZqRYhaAYS51ywgNGC/P6N+3nIeosjuMKh01G04r8Ovfh/7Uj1stR+aF7EkiI8W6tmSTRW0tXXZLkqr7wH/vT5uta84DgVLHvI65CykcDzz8QPPtGX/j3/mr+M1/55cAAPvz63fuPV+jX+MM/Kc4ROQXVPWv+O//iqr+4dvPvPzO79Tf+1/7YxEC69d58APbsDBef9zDbBK1jjfj4VTMn/SR+xdPkOtmVWVZXvl5g96tYBEGayjhz7wPzE/uj2g9a9+X/HgURJ/al5bD8A450QwCiFAbUWRaB+EzO+B0rBrr5r5bOm1zv7aEqQxJTxN23C9Yv/dsC+w6ku3FKEf0wPNrEXxyE5IA0qyaA8C4a1l9p+f7s3uhR4b0uCBPcMyBpn5FrvP2+9X+jrZb05h66efnhq+dc9slU3PFzeao9KtAf7KGGv1x8w6zHW1Ykc4kwSDqB/Yny+SjQG9vvGoxuxPBNjPdAD1bbsT85N5Loq+Hen6AWW1km6IJ2tOG8eLkpdp7RlKAIBtFGvRlYHu5plZf2jF1eRHs94L9TjBOiLFgFSPS3unfN3fH/q3/85/F6+/9h+/UvN+Wj/89EfkFEflDAL4rIj/79kdo4yEXuWuBfrFFF5t+82SYtWE8WPnj6ay69rSjvb46m2/B9pOfRV057R3j8xdmxo+B9nyNOLsV6lxi0ttvfml3FWE585cDnHn9ZJu5+PKyT/THqzV2YJfZOHczrfKwoL/Z7O8aUaBP5sLMFpKbftuMtN92NY0RTDvHOSzLa3reQMb0ARx+1yboTzvYRZavGc6gGV5SgAUbuYhqaA5w/5yNfCtQ7WG7cUaYmhFbnnkO1uRn5lkbiJJe9O2p2bQjym7NsxcDcSHP1lrtOtGfdoz7JcA0XRtaYCOW3bk/NFxfNewP5k7Repz3RnCKcK4TulhM04DAHvkf7fUzWJlX2JOAHP1tGKZEPMFp0vN+SbKRx+/3B3uvX8y1nGfrBpR1KUopcbeA6pYh8S2AvhCkbln52H7o+FY2vqr+smv8zwF89u5PSVlsLv2aSbdx332T+4QGbzmRWWrteb9gfHI2gUCEvMFSIWE/Wc123p0OITq9W2zSVTF/7BNj+zWgpqvGZnlxF4QdAJE8xL5phh5nKe7+xkKC0b+dAM/Jc8ndHwMQtNtsE20bPqISaw9Tt7n7E73fpycPTY0KOm0z4LBddgeJilnvoBE1Zt3U7INHnr540geBt7Zb74O+WUZlv2rUg2tX4Px9RX82Cy46IzWEgKuLldWVqfUPJqz/3B8KqCd2H9ad2EufL4J5Zy6hkAi2WzeacWo3Fou7jG4BjPsV/ctL9E6MGvwimY7rx/zkPog7er96JeNu4O9jFhQgQDxXq8XQnna0zSjEYbm5hQJBce12qzXQiQEhrQPVEI5zjUsFxlMrHnP8gsvwAWv+W43jq+pfAPAXvvZzpC8SfVZD9juTW4ZGgQgi2kJSzVTIxQCUyHHeJ/bvPKB/8Qy9Y+sXR9i5D+9XtK+eLfWWQNfZquCgafrhi5vhXnVXHIwzsoegZgEyRTdYW/5sNd4vnnHG5wQ0ffdz91ZKbq6fltzwLmjIXwAA1g8cDyv6oy1Umroxpl3iHGyDHQCaL7SKIwBIeunN6rjt01YbaDYnowXIhPwskIKFMfpgofG8NwapTKf+IoUEr0VfmGW656lFzgNDaZ2l2XfBggmW7kYT9NdWl4HlsOz+kufBJCcry+Wafu3QB4v+zBeWBKbIwh7jxSkwFba+ponPCI5dCBG5sT4AA+NhBUHPFJb2groyNBeojFWFDOjnVy3/IQIQPmo+fq4OFZi2pt8Ge/hx1x3p1AA7DoUqiOyuLQCUuXaI+1+11zibZLC2OdBigtlGWXYvmQwDbxqZYA0maOj379M+v82obBtSFgA58RZ/b+l/c/IZ+1cLTcrVknNYhWWuDSJLUjZFLC3Tqw/RnSBH3QRkhqqg1n5KBdDpqav3Hto79YM/b5ORIBIECdSNfA1qP2YBmmpRDgJ7Ycn45yMMOLOqTNtd8O0aC7kKo7axUYmvg5OUOLWGlSisxiyOURAfupqWxVRPgHIF4RGLSf9cLQ2aWptRm+ifCMTmp1VmeSBsPbZaxuHm0R1/7umZlgf2JXEUFxTZeMU2NjtJHYRcA9Spz8yO5JxUfsRtVd0WFZ/fv/m/dQLPNz7eIaEYtglwqsHReoTkBAGwG9SUGu5Qg80ngMBMFKQkd5rncKFitdV88rjpZ2pRugWstnu4Hwp4xoiB4AGIZ+LxWuqkG9mn5dorgljTvEpLAHElTGfnT1coklCI2jMhxK0l9ZiwFex0DUNknMLATW4jzlRXIMFUe6Fofg79DaBH90AKjlDJPcfJzsXMzczqvuPkPj4NjNCCru3cBTRBkvcHmJbvHili482gTKuaEC8WGnzexYHQKMfNqste3CPYj70Z5yOKrsK6JtVwKbkWhXBEPEJL6DFKzc98xkmrDMfnx+2Yl2f+oWDufegIje3+CZlk9p4v4BKrZX+3GurgQXJE24p2bShgnZMknNkF+KZxIA9h3rrPvmRteoJ98FbLTBlGSdAIqetCqVV6sCSfHEDwDEQ1wm2gHw7/Lhl69Tu+gILe2+RAOyWvn+MlI0s7AcnF5/jGON+Y52xzfXsE0nxjMdSCnHE+D+u1HYEDAIgwn4SAQTFhxecnF3rNDKwAIBFv+1xJgx4a/QzbyOQe/p74xkx3jJu7uDwmdHpsarsPCtB+sLCCphusyorjyAHRty+4wGXSl0cnoh4C8vnmmpZVjDU1vu+R27nKKkbv9/E/rsavmpsvSS7C6TX2pJB5ZtXuvqmZ1x7CwZl05sf5BA1NZp8vEHVuPwtvAEiz3TUxKBzI/KLUBxehJI/epTmoTfwes/Ak6acSzK26QbW3I6BYQEN7Iame9PXDNwUQdQFEguVnWtxdI4+bZ7z8RvPe+I51Y7E4BEkkQFl8xaqkOW3/EIucBSQ578FJr8LtHWAU6/SJE6AOOQHiG4M95hyvmB4ZIWsRgAl9RnQEQZFGd23uFp+y+nHvqL0OTJjNTO9VpgXPsAL4fOPFmkg8cn0nb8OelaHsGHv/Oc5Wcmt2i4RU6nOtTHxbUTf2ThHq7zs+2sY/ADo3Zt9tk8bQWKfcoLO0ElYHuaKi7XUPTjzj11jMJMvS0rYQIvzWBXLZHel2JmAD5sNqJpkLh3lf+p5R2FTB5Vpk0l90C8HMaxNIbRuRSEK2XtB7gYjxUyAcuPqqh+uxrTXNU46ZuUjeReeu50LDUYuGVaGamqgsGKvC4wvO+7axh9tbnXPUw0lRUDOTkyKNlFqqcAEOYcaCSLPUNktKMQqRuQZuEjPGv6vH8F2oUKOLWLzcOfMsm0ZGaPA2wix3YXHdDVh+WFPjL+1QE1/cVRj3TiDy/n7sCRBVlWcRfG5RzpNFa8Kvn2YBzrOP8SqBpZivLzEmh/yJgYNQ5c8PFdz8qMU2x6l5k0SY5PVsMJZ36hfTWOHjwxZeA5BxYvq6E3NZglrbv3pGlJ0q/mEbVn+OpJf+eI24PwDz+YCgYerqOddzRohQTwv6k5VYrkUrubnJOTBMwcC96FlHFmFrRsE9Lan9erOYfmv22aGJpDspqF2dVUayyzbdd0//MVh/jIU7mMTFaAMhSR9tEguH9NC5cmOkj00CjxV8lDBRD/H9d/iX7KQbqbhqICHN/uqiWMiP8fq0KnhvGGoKswNgWS8BthcLlicn00AAdjG+uJm+tihnrV2yC7OP+bxfAZWw9tDUSDyOCbXHLcHDzfonRPYo3YmNVqELJC8YEunAsHU+iSEBkM2Zh27RjrMc5oOgJbkNB7CVCVRa3KaZAv4tjVqOj7bxDbhK1WIATWqk/my+moEx1OpM5CjSuls+ua4WO58n2/zzXOLubqoxpi1doladNeSAl686J+6g1mVFnq7QV3eY55NtWs/6s6orLTe9wkN7HePOKue2q/n5425xsga1x5q+Gedm2g7avnMPACV7K/306Pjq4T3tchQQ7uIAiFRU8cIiNQOSjDj+XVNj5ypRHMXou3aPVlsfXjrbBcEUT781FL5fEH549T1ZVHVCgyn4FjmomKuWmutj4n4yQMEKd6XEqgqvpiD688A42Vz25xkmNGsNsHSXTHVwthCeXpyNyNNdkFw26GnBeOHK4c01wFKZpt37855KYljlXm7etpmQXr+8mDVx48IoN/8EpGms7XEymvc4FWKTICoa3eZD3Obk2834+F/nB/n6H728ti5mqphv6mZYxIcdjIFZB8uT964rErFtA8uXz9GVlqYVSzLRzGP4pG1bFK0gCcZKeQnam4v5doBn5K1orJjSGtrz1RaJCOTLS8b2A2twqwWI7Lj+5QXifmV02ZmG1ltZLJsCW2Q2We1pz9CXC69519FeXz2evBr4vDbXsMMKdw6FEvTbBvZXJ6jkamnXgSY0f5GkHmeMzVOLIpfU8ETuZ7e5GmfBPCN7228AIFgvikDm99z09Dnblpx+aQg+BXEF9c8yWSuSjoBoohqYA8ya4eLfXjQ0z+DrTxPjbOOyPI/cIB4RUkGUM2PeRSTBuBIhbtIulmar3tGWGhzI6IphC17ZifUTBMYYPJ0iR+JYq2A6VgXM5q3APb/AehjYog+KdHM3y7McZQDdMyCBdLlYXrvtFPI/hBofsBvuz1mMA0AQW5QMpiaYjYUq3Qpw807XhrG0aDXMuLtsxoSCp7rKdfemHAhkPpJTziuWHzxCzyvmy7tDeq7srM1mhJ15Z+2P+uOG+coqsw7vjCpOHmmOL8zTYpaKUzfHw4r1+0+IpB8A4xPvF3Dd0S5uhrZ+4AWMntV30Y1NuHz/Eftn97ZhHy2ZSIaany/iBTS9Kq2DhrowaUVCA6Pw/udd8bO5UQNDMW1j2XG26fcHRb/6XG2mpfoVB4ssTM9hVkL3c0Y4TSR80QivAa71MnZfLROj/cpRsABQpfBKYZFkGgOFpZk1x6YbbNwyXpycADQgwwqZEh+RYWxLcdq47NMyK3mvu0L9MyGkPR0arqACZGx2H3Np4fPLBPplYty1aGAyfazn6uPuPyMzzzn5wbb0kGZlSM5qHbzj+KimfvDBqb0dEJpdIiRjH1YPa7QAdyLVtcHpmgagoIsTdBazBE5Oy3WTD/sESODYjbgxX96lMPCfelqswKW/pl7Gu12HCYF1Rd9GhtOWhnHOZCLeD83+/myVbiu637+0ZpfjhVUBtnp6GsCe+aJOA71bIdtE/+qC/TsPtvk/vbd+euR2twSeCGDtjjDLrtBVsL7eMO5JVAHUQ12xsVh+yxfZrCtEuRGB/YWi7RI+fYQHgytetL4n1wjLF8LPe8MYBBAx68YCLS3j9ZNYjVsrlXrMunbkDlBLqrTg9tu1EB2OALiAHF6CrCdm5My55QePmC/O2D49m5BuGXatSTe4Tmv8sk1TWrx/pgNLMg3bdZp7OjUsAdkVOLl1taSGt6gFsomJwOrsXzTo1TagZgWE++z4yfuOj2rqG0kiGVzGU5bQOv0yg9UEBfb7juV5gFVxKMElJIcYcPfyZCSKtUcFGpo+zZMlok4dEKWrZZ9ZptotBQBgzjWzAtuja9KTl0j2f7009iDIt3x1CSIIufOB6t57XfyWZiNRfsBJJLxHhfl5d5anP1+c0b+6QO8WA63YapbY3ZUYhpmz48EEwP5iPXIDHAzStUV57fB1gQNy3IYCm6BfgdMPWpTX6le14hvFX2e9vQxl2QJmamzwDvhsZGN6+G6sUiIOxeogA86vE7lenqnWdmA4+6+5mT9F0HSijQmFrzfG4XfFuGuR30DLSXuDngX75y8gY6I/Wree4QCrhRJdyIpFV5ZHb2fWO9plx/U7dyF0rKAGPKKB0Pi0ZsZdOxCYAoOJ36tllJqeUZIQlJzbD2x64AMbX0T+FwB+FuklVaSg/v3LqvrPffgybx/qfhcTdRiuiXsWi2e2XaN9EimN/TIjLHcsxzUxH9Yk2Uw4OOa8696jEwuAKD/NDR/xcI+PG/DnC2Ra/rR2q22vS4M87WASEUN14r3nIsXVc7JZCjsQb8cC7HdfaE0MSHLswCfCNPp1j1Bi97Tb8cnZF2H1990HPS3mD26MTJiVZHUHMtYPuHk/NVtTEeyjn62mgXUHRNQ6s9LE3G8WYZj3DF9lzj2jBSyyERVskD9l+qaXPB/j1hHaKjFzAyv9dccjMgoAyAaz4Bowlh7uIlFx5jSEX93sYpVbQv6Gihc98eSfqJfQbWyJ5LfNlMTyaOnCVvXIT1Z4C3NtpthYPlyAsVp6c7hVS7F04BaNC1nLckSa+ECGR2n6v+f4kMb/TVX9b37gfZ8v+Z9+3Wfe+T1FDi7DcvG3h2wWr25S6KkAIscaCkgXB5MynEKT1aS4gytDEBxvIveAA38+DHPa5+ALXpwT0FrEcBl6YlIMWVtt3+MzorBMLrdcIuwHyU2wzSQPkcFFIIgMQS+YiS6RHz7PS8T1D/XnysFcbytY6jXoGeIhj+FdX6XW3SekCeZQM80ddW5lc8qgSf5uk97uz/19VciOHHO6DPW6ACoh67BWZvIJCNQd1rSb+NrEIgfuorQhoCEUAsbXmQzFWA1UY/6+CoW8rxU/J6nDjZWOlhwHuNAnhyBcigbMYH4iGZW8Z09SMgvPxiZNfDn49TWHIvrlNdw00PSxB92C98wx4vbefajqn45xFfmXD+Nc/q6f+60cB363lr+BAEWA1EYoZkwyxjLltLKUglKqepgIOI3UUoCBqK+2ZDwejvYG/3/kiScTb6abgxHzffvZCEwy7RNA+JX8TjLIPOzm4brpAiHDhDeDV+ipQQcOH1ujHuFbpbulCB6GyviRxjCeBuDHrrZsbdV2NT9ys244fbMNXem/1K7gYq1ClsK60HWPz+S/8nlVj518kH4ufw+N6NeLclQkDfF18XvryRNRx5IMUGtOBmppETE0WVmdDpCCZjqFO/n4DVE6i+8d1rav5UPBVRd2g/68h02t6MZx3CzMeRy7SnuuhWw+dHxTH/9WdnyNB/HNDhbeCISXmqyLU4018pMz/iyB1MZ53DcNc1cR6bnw88CRT4W5BeFXeqJGbYAQqDMQrbqYdsuaegf/vuAF8GYdtolLnF9s9shaO3ALmoC1/mSfaASqFMEZsJtxQeMxehKFDvRQAXz0wow1wNSZh04cUviCFgspUQBZTN7NUdckUWcPplGbHqmztb5eTaAiJZVYDItqhsXB2y7gHsFPEOsBgcCbteObjFpy8ToAb5m3YhtLREMY8HVyFQBgnni/6mMDqOYzcKNbQZTUpuxWrM62JEefa7vyNOpmrXiKzZXH71fT9mxIEm4NxzYGgGNfTCcf93ABPnB8043/PRH5pwH8awB+DsD3vuH3Pny45O3MuKOvSZR5FPPfySwE6QQJHBG8s6KRhe3m6DwAWySS1wDcmmjNGHlcfJHrzg3t4ODSLO//vAS4U3OkSeCh6W7sPPO1I3OPVX+picnxdkox4ELvabPYf+T0uwtx3aGek9+uu0cs3O9k3sDabSMDkYjSHjeLRV+nsRhvWHKs0LufGjoFcVhMbtLznlWgrcTVywKkhRBgHK2GkeMJwEA++uNAjoeTNjiu0zkeBO6I2htC7l8hseUpLcHAATwChM5r57yH5VctQm5okQgPBn7i40VtW62YiETQuCvCxWi8vjmrupT8biD5J2C/Q2x8WpJaNbp/rwpahmdDaHpE40M+/ntN/Xqo6n/PL/dHAXzqf/8dHsXUcbpuu04nUnBDewiEYb6TaU9ymO0zGuEx5l+zc8yR9+3MK4JOan52e7ae5dGJBghTXw9CR6NmwKG0VdHM9rehvQzRWemsEWg9Ee3Jpp8XTwmeM5ph6mptoVgYNPsLsOwW7HPdNv24WxBFScj0o9ns2qiNGb0KmPV4yIJrguVxHNNEyZYcGv5lG155x4kizHrrW4bgMh3X56pUjeXGjEy5G01YMwCjHoB/r5b6bu7r9otifZNpxvT361GLWYSmdvbgPEn6871qYBuf/b4H4m7auDQ2KfPPgiA8dwidecw2HCcD9GRkZR2a+eMs2B+MIzHPirkotKXVUBOkYh3wXqsFxjX+Abv8G2l8EfldAH7G/0FEPlHVL7/Jdz90GB8cgFdGCRqnIqiOzWmaczUkuT8PEwBFIEQt/ZN9R3arPQ9uUEfbm2qWsV4alFzrbZTKOYslWXi8nod2a1TZHq+YL89ob662+c7d4rFnauIRWICu3hhjkeyO6oQk5t5Pr78marXh2+797qZ637yyEJeG/rgFa6/TUmn+7CUDjlV2hyPNQcxhz4Kav+CxXy7IiJ+7hRQbdFj9uyhfTWXpMXZDqOkq2XxRa2pD1IozDr4U7S25Yf01msrT25HFJqkYAey6MtyK8NAi+PrkvaAAw64wWBqsp8aOgp+HDSXhYhpqb/cz7oo65vnJ2ms2TpWUFDx/t2anlwajqzLugHkCLj9GGjAgQwxbubiBwLktodawcIq71PZ8hvcd30jjA/jLAP7fAP4wgH8VwL/yDb/3/kPgRR1t4GwA6FtaTLxt/oBq/Gv6iNUd2O+6ATQnqyc/z93or7Vg4dSiAU1j9y+eIGMe6ujVCrjjfrWSzXerlcC6XyLsZ3HxU5y7WhxRg98ZWvurE8a9cb55LVZ7Ha/O2XhTLFwoT1vQjoE0y+NZ1EhB/XHDPDuf/Gl3Mz4z7eZqz8AkluVxM3P+vmPcG4rdLzO0I81omRphJj4fTe9+nejPVlePdfcYbouNW7LbqhmcufISqH/4rm4l8DsAmXfirbXFrQhELT+7t1K5N9pwMx+haD5uGPVQoeaG57lrld95Fk/15WuuzQuw2K4zwoBzEUulPTcbW3bCcUszwLcuaTVQ05+ygu7swPIk0NOEfr5h/sQF23d27A+KcadhBUV0o3hIofEFcc0PHd/Ux/9XVfV/77//ooj849/we+8/fLO3shjEmXgqwHbXI5kES0rd7WGJh+qXATjHvD/uQBf0L6+RaRctlxQRy2b+9P7Zg5VYPncz9+/Em3PsxuybzHTzWu1uamuz7ED7jrHyAABiCD47t8o20B9TQMzVrIH2tIXP3jzjrr+5Yv/sHrpN4H41s59lvs+LGQqb8c7n/Yr1e4/YP7kzv/qNCQCQnecmKrP5pFsG3/RkpP48gC5WdBK54K0xqY3B8nrD7uWerbXTDP+S4KQMq3kfvnQzzU8hwc1Jim2/TuwvOvqT4xpqoGIbRkuO2D6I7tu8zVK7v/ru/Yrw9SPv360FVv09bI4uRuxxF2W/b2BZ6tD4RUgYrkD3CU76MSBvdgG8aAY5C9rFiEC7Wq6AANDMdMSaApA/9zs5btgGzFUhDzseXl1wWnZctgWP/R765YJ+Ecjz0ZVRPj/S7XgrYvKO45tu/O+KyL/ovwuAf4R/q+p//xue43hIDnR/ngfwwtI8s6oNB6s/jWRLsQmEYwMMvV1/7A7Lo/Hlo82Wo8SYicCaMLDvs1CiaSSns0K9um2HeMMKq4ZqTLm+Z9ZctPUeblZMzcKY7noAro2ohb0QJkSwf3KH9riZINmtW46s7lvTchlqlE4I5sPJCnNeh3X3BRK0bOIFQr1A57mjP09sL1fb9H4fTAohQMdaB1brcIl6dkEzagxR2WIf52bIMct216SbYi43p2Urefklc08bMMHmHWbyU1uP09u+ehsKnZIaD3QbMnwlu73XDxta8zlgxDBtYuPyomHxcu6jmPz5cctK7JudO7IX4TgBJKzWdi0ZgC50xMt3h1tRuPh2bwhhEz56V/yuz7+Hf+zH/10MCP5X//Z/BZe9Yb7OOWhXRJiRCVMWoXHMYSvnfcfxTTf+H/2Gn/vmB296EcAlJcNHkZlFgN1TFikMVBCNMrE07KuZoXNtWJ726AnPqrXRTVY1mkpE2ynX7jShQwD1HiY8TXee16S7D50jwyysUXvkxfca/VRHeDus17oDMG2b1pWH1N83V8z7NYo2SrEqZE93QXvzfgL9ACKxeQdgGn5/WEsXG6L/xU9XWIhPBH2bMUZtK/UOyX8/NYw7KXgAInEH4AI06U1f3Hzao9MZnXrA7+eGHicXFM3dQNf2xhlwzKD4tPTrtdmGD/o3r1+yDIMIMxX7vaBf05qIpdlS2WApVgEzEgWJRzkYHaHpaRasVfRNwM9IOV49p4TwAp0nOWcIxtOCX/n1H8ff/uoV9tGxXRfIsKiVjBt350ZoxD2142u3xzfa+Kr6t77J535LR0HKAUSYhEDMZNzXkf3abklCNBp40+bRl8x8fViteQeI5EoePHLTwxbTPC9pxmreo1mc4mWd7Lv0y2W6BgIiNi1jRi31Gl+fS4siGszrbtcRpbr707CuPCy66QKCHAH1jC7AowoziToKZBWhkc9AllmEH1dW9klyT42pa7PS0+PFGolPxAhiEalJK5J6mG1HXxewzde2qjTF8/WnVZIhMnd7cANMOKJd4u5AWCcSghVp4gPZlYeWYv1u2QiDMXuxmPkhGUjT/WHcfzouYJwTuqYaWEVe4/hQMbaSmp4ZiaSra2ko2rwJqVwanr844/n1KYsubQJhPgSjJlxedfNLAp4fOj648W8Ye/SYBICq6j/14VN//ZHAFTW8m4Cs9e4zZ+20JP01f8ADMDWKzVTAHOa/s0FhAC11I5WYOWvR1w3RqAW7+clMswxyjJe/orUyzt3j0I7y32ea5lxXsFvueFih3dB5doMxrj/JQGSaucugKbiiUqt/Dn4/wS/Yp2UkUhCMGeMpArxF3R2Kvu15bfezyfG/pfmGLzkTV5irLVxqWaNVaFh3lYFmrtZxPrm6DgxNpB+vAmsw6eeSPe/F1lHOfy0uUo+wHlRK6DDxg9DAkLfi5nRNwhXg672sxYYA4JTUWc1nidJpevAmwHyVdhX01w1zE2g3q0EmsHwlkYN/W7yEByMKbHb6oePrNP4PAPxuAH/J/334bL/Fg0U1+DvJE5HVJcgQCUk7NAk5mFzMdON57oHIwQaQCxnwTdhy0bK66Y12IdJdY9tzadb1FWkxxHeaZEwYrlHcBzeTPynE0WSzIaigsg0LD4oEcUm24c99DMAEpZihSc9Isxpynv3XjaVn9yThlhgGMG00bgo2xLPSZ256eN8+xE3ow+YAWNuS5ps0VhPiJL0I2YsxZxK05EheIWGHm5GmtSLYdDRnyflPXgDnAqkJy/zwnNNNfv5drYvW9LCpYp6IL0DtBFxbaQyWdSIhROI9OQoTovE1Aadf7HODytAF3PIkkfFY06A5H7fHW/UQb44PbnxV/aN2v/LfBfAXAfwKgD+vqv+/D5/2GxyaGudQiKNOGCX/koAJkz7ifQEimcIFh917KYkM4NAjjtlznPAaMuNG0Dx/+OZcmF6fXh15jiwtwBYEEI0uxtkTQBZxDZXPgQbIdUYOPbPAWAASLkegmddd6+gTv4hOOYtLvokIGUWyjgOQjdwEjlPJjmOps3luaFMzy1DycxWxtzGz962MtsZrgdXIUSMz9yLMdm4iqHMcEMg5ufikEguzmkvoL6bJXRVAUyC0vDbvpXL36UZGQgzn1+PnbB+WJru5VdFRqSitAxOR6xL5/bh+YRxGCTJfwzJ84wOQIXFP9Olj/dI6QrkeD1o6X6Oiv6mP/y8B+JdE5HcD+GdF5Dt/V0z9GISMmQKIQgbxHq2AQhHlYsx4N/KhgeD4x9HES2xrAD918AgeRptpmouu+TsBRtI4lxsqpkqUWQ7NItwA/gw6I1vO8hA6lssAs8IoLChYZmsYdz03n7tD8VxN8n1YXzgWemAhCQrK6n8yNEUz9MAZICLtyUKHZ+QpuJkc0FJIEFPsnNzp1YTihi2m+sw1UC2Ew8ZuRmUFBH2qtZD2DV4138E9oGNcuPmhZYkpKayGIAteLBItw2QASpxCk/tuoUU7vzrweEDlfQyzPFddr1K0vK+PAyjqwmOa8G7bURjl5KXwurUoKNhuXYB3Hd+UufcJgH8KRuD5ZQB/8ht85xf8139CVf/E2x9A0SYe09/LIiw11YBEhSml+XvEQEWitXMQMRYn/giCgYaWsVX6jUG5PHvV3+Zc7S0X8DyZNh4nC4XNLqYVvXiIUTB7mNwyrQVY32b4kNPbV/EemzMMreBGaY3dPBw3Z2SK1WiHbCbArp+spmWpSZu5MhQctFLCSnIrxwYY3tPNXotkHzHBcZv8ExZXaDKfF+ImA6UOXm64ME0nsN8J1scZr0czz3IcQnm8fNlcNLvtZtIKMwuc4bRcI3WdMa+9CptoUXW26wLwisE+ZqN8tktWzaElw3EgMajxWrnemLFIRH/epNtCEVl3SoFdGIzHiINAxXsHkJVYtHxYeSUz813H14F7/xgslPc9AP/KN8nP9+/9LICfVdU/JSJ/QkS+q6p/8+0PcsNrLkzYQLA6T3yUrDLXVNyUwVG/ERiMHY8Ta9YD7MZLn7MWSFiehrEAC+vJTGdrwUTqqJ6tWysFBRThN2clXPgmY7pnmsG3/rKQogt7vnHXgxVmAFG3e5xOdgJCg8fmW5sVlixEl8gpVwQ4F1V6VQEKFB/05pmR82wWRCtNTAAE5iLqWn4zdJzhsXDLbiwDcsYPKLTjINKO+fss49223PyWD4Dc/H69LPRBBeDzUyzCSFumX1+KW9B3DiCy5wajiyHTcIxwGyqA5xpDO8Llo0DYHlgXUnxNsg+BpF/PijrT7qM53hCFQ9TXtj/LYfO74EBF7mkBq1smGz54fJ3G/yswDf8zAH5OJKj/qqo/974vqeovA/hlEfkMwN9856YHYoMDftOO1FR2k+yKeS/oTxPzLL4o1SQ1J9tNKvVMsvGiYXmcQE+/V12zsVuseN0zaiTzxTXAsggrrg2zZbZgu5gPLFv6fgFECgJTMJ/UON3iG5b+dmOMXwTzrqFv1vdtf7EEAzFQ/l0ttk5eQ7ea8NfvnLB+tVtl3G1iv7NIQvQWhOc1uG+/vN4MUIRZGtOTdGjytzIe7TqyLp8zAiEIINZed5JMT755oPX+seaavnlCSvPedqzvTwFeQ4Fm/VhhTqDE37leaAm4cE3LA4C7iAeQEDhsnLkA+71TgB2ck12NFedaNim8CAGR6cYIqvLBDCdXgyni3VmJq1mJAA5C54B9uFCjed82k83VnTgUz/Tvj1XQoQeLiDUS51Jv7u1Dbmt+/9083Nz/WVX9U7fvnV98ruvdi7jh3/7dP4Cf/Pv/QIRobAKcIbYd7/EgfRl94kYEMkbd0sc6WBSuNbTVHAD4JnWzliw4ocSX0IJhct/klvMabS94QNHOy9MeFkBUTfGQ4LhfDKzz5CMAqEw8AJBtxobsT1bWqfrpjSXFGF3w7zAMGZ/lnDMl1YVKIOOKFJglSYjjSM017ruV0uIakyTOBNLPGv6+MdavRtBhaZYGYYauhC/qAOI4D7ExnUZbloV41uD1VXPf3IewmNT72cbFSljbZ/olM/vCqnFl0LzoCO9ruSiq5VlzEwLTKfdE0344eHgLuKkgymgFaKpp3h+Qebn5/kxAtaYI/+qv/FX8xt/4JQiA/ekNLq+/904J8N6NLyL/tKr+xXe++Vv4nIj8eQB/WVV/sb7+4sd/p/6ef/x/GCZa9enMP82NX319A1rcMnCwjwkd8X36vED4/Xw97muUCRzZzANAhvIUGS5r5vuydXcUCe0EJv38xWKpWVIE3eL6fi9G4rFcAyspJhFuO9ROI2W2CJxb0E6LoIp02qlZ/dfHxai8S9Kf/RrjrptwckozPx/jxk3o40OtLWqCjpvmIID9q83Zdf0yI1FleRpGn+1lk0uaxdReFZA7VBWafM2VQQnP0T04hOs6sN/b68wP6Vd92z1xbd+vOZ9ccyQJHUK/glgDASbSvHfBE2a9osxRrkW2/apkohr2CyCUz9u5hvM8dFHIp/h3/w//PN78xn/4zo3/IVP/HxGRP4LDtstnLb//TVioLydE5E8C+BVV/QswLsDn77oAUy37ZoBFHYwgRdQrqZuXTHgQGDAFD3MVF4EbnhMOnluprc1vX54G9vvunU00UWnx0JJwk3oSz54c8AirEW9wjUEtJ66x+/OIxZ1tpzR7vV0Hrp+evHfANHdizf7pJuBSUPA789QPAkL6ESzTRSCXie5NIyBiNQbvM3/fJszuh1WCa8OHoMjeRAWa4xH9MrC96n5v7oL5c9J645i1bWLcN7TLBNa0sACjM1udvCK4PEw7PQRa10Gw9pTa2rT3OBtoyzCx3mzQtqWQsOxQMChzYAJWRUB8phXBEkKmmOA1dTjq4dexEwU8TBhFNtxgJLZE6vIhBZmVeChYFIZPEBy8idnrIpjy4dTc9278v8NiG38eltjzCwA+cwHw1jHO7uMJ4PScIJvUDWbplN6+KGibKGagWmFFcdNtIUVScgFSSvt8MmS433HRzmAMHlpMLZJCoZswCGAocIYUWGGuKrWWoHWJcGEQkaTw5QGcvriWmvaJqMfkUesN2/zD68Hzvhj3J9V23PWwEkzDeR5D0cZ1M89eCE3iVX0cAGR833xYcg4kxqw/K6AeCdiB1d2nDCUisv/6c2lVJciqu1PRr/6dSRPdBesoYa/izxKpp0Df7yS0YVqPiHEUbpjiLvAz/GcfRggabvC2W/gv5jg2bobmGCWoIbYgGKkeX5+ptau1wNBhnXviHAergRwFSaFgg0Wh8YFdj2+prr6DeQT0/so7PyM0TTLBoQ2bHQ6k7E7gQMZGOQjMSIpKJj6w81TP5wv5BBA8EUdi5YojoFT8PFoUKH83fl788x41eFdBS2p9arm5NrNAqvBxrcYkm3HupmlJ8z05WDdtI8uYmfHHbqxrAzwxJLPezEqwTDbksxBMZA1DItF+WB1DT87ZLdegP+9Ab1lSuqUARLNmH/u6eHXjMhbqDS+FeQEx6wBSu5EyndRrn38xAs1oZeMwdFs2fUXhQzNS6Pp4BAgXJrwL3ZnmddzaO+zaaCyy5md4/7lmyoY/hAol5pr3HNYA115XRGQE9nMWt+PWEuHzhgIrhCD+VDfu3nqecny8FlqCt6WYUoMqVCW43LffA1LaASVU5mEi8gIARKgpTNZe0FvHEpRx7GI6ViIOgGgGEc0YVzlq+QVWmtvvi+BeCgkY8lsBOCA2OLpYVEIkXjswET1bUL3RBJoz94Tuhm/cntWJsNCslLA+gt+vuSnD5Hf8gOHR2pY8OBe++dlLLtphDxwJVnXKAmeYCVR6k8pcwBLClNejq8Mwopb552cIZLbhIbCWIUptcrydcA/svHQzYp4pIBQhwO3e8j2usxqWm10idGp2+819oigJvs5zFwwlNPjNM9aHqJhR9f2DrSicp7fnoR4ftXfeXBHorC1McqTp17npzdprN4vqMAjVj0L+XRM3AHi4JDUkEWfG4wEAYYnkRuA5gzJ7mAxKIAoSKdpCgkMQRJv6Xd+I7Wr0WwBm1l9nFOAMRH5PwQOPXXOzszZA+HsMXarz0neG0HwsxNUCAUlmrClMYOzGMmSF2Vomm6AmxzVeH5mLEIu4i8ETbvJjqicJSWzqA7CGcp3JyXWBrcA7LVhN10AbzJqRYv7WdcDNHVZeTdZBxs2LUgkyEP131/Dc8Ac0f6JETfDWmj0kNxVgOwp1FuGCcl+3z3v4vZj8kcvyNcc3Ze79w6r617/JZ7/pYVrW2EcqTjoIWwhATJ758JyUAwXTj2DyKSUxhUC6BLbQfAMLAb9E5AmSHKT/4X65aZzCuZeFhGpRUJjRX04BJq6BYoMUqc+sumjowOuXGDYjCdTW7NoCIEN2RPuL5jTTf2I4Wl/nQMUZiF0sdNWAKYI+CjtEyuZWBWvmkxgUIbxI9fWvkTvBtOoimytRyj7LHXEj0GF8gFHMeH6GcxJ4EL9b1kjy24/READH76Cc950KpWh6UnxdyzJCdODTl7URf3PJxPUUBJ1vzfm4XkX3CfgBmIxcAGmFLqnpbyMPt8c31fj/hIj8KQD/VwC/+HclSSceTMCCC2Ha0u+hT8YN6V8lC+wAoMRg2oIaa254AkwKN/MXDZAtYqfUGPQNh2ufUiSCG5pavW0+C14Jldq87RODrY/jnDBt4NV45iJgRxcZBsbJVCMGda5AW+Vhvez5ntBkBexzjMU7QMokIlENUDFArdAqHpbz4iFkKrIj8cHVaLk4OUbTi4tKt0QkRgKiBLqTf+ZqDDRRZA6FwNt7tfcuUC2LPczoukmZvbwkO++wFhgJjg2SFyKLD0Cy6MqmrWBbKJTu/AICjc5TsHBcfuddhTAOEap63mZhwyQ4Hb+jrbAKGfLk2Ny4ATFuLQyb9x7fNEnnTwP40yLyewH8KRH5FEbh/do4/3sPmpAltp5SzW5b3e4KRJaTwZzqQjoJMJCgn9bwixSJnNeLcsqHTeTarad1AKSGp7VgtdUyoUSc2z8XwfbQsDxr9P7jebnpSALqF0um4aTPRdA4a7VACc1ftbDXwpx3928P3GwXFtyEddNE6XEPM8rUtKJcMPRtWiNJdhcuy4dWF8N92pLiG116p0ZVG5CU45bMuHcy1nT3RHEgFkUIjmFPd5PYMhtqmi6YksgNGWaxHoVUFRDVwmK8u1odSuFeXARqXGYJTlco5AD0i4WYg4FacCFbF8i16pjK9Bh/1fIrw8/cAxySqWgQ8+w8ukEgka5yjWCEcH6/PAXwW0vS+Z/Dmmj+ZQB/AcDnIvIv/6fN0hMUUwXFjOGE+YBwIxNwA2zyQwgs1LJ+Xp/sfvEqrdTKMSC5yMZJCn5QFp+Uv5GLg6GbjBcnOEiGFgVUVgRiXF+wnwXtonGPBAitlHiuttkl+tUJNHjtujT0Z6/is/Zg+LWtWBYKK6qxD9tg3iLKiDPNGH+ndtAWfqcBvNF37U8z20FRQ6lirlYqvLY1py88Ty1NZNXQ9CZ4NGr5yVDs9z1JT76YxZr8muDRTPCpJjjHNUzbIgRi4ctx4WtHNKYgsQaabiKbUvDcEZ5zl9RCt86WuyrWR+ve0y8zhHa/pMsB1FBl3h+Byr7ZfVDb16axdFEz3KqQlTRge45xcoV28JdyvdZGm+86vqmp/xcB/C9V9Z8tr30hIn/pG37/3UcZkEDpKfGQJtVcXcMyL1uTkxyWABD+NSSpowFCAdCWEheSvqFpOg2zi2FG82PVq8HCwDtuavfNqI3axgcoVgetmQmgA+1iZvgsYbFx12LB0O+PMmOebWbMMZbjEqhaGed+GWZuu58fFXiWhulhyPX1DukAwTXDU9Injzz9zc6/3/WoX3hMkspsxaop52rhPqYEY+ghQsIkqeECYbxowf2369f5cUvPhSW/x6o14Y61pOLGRhNERIeaNcJ4wFGTkiZMS5JsvOpPu2UXnIAJ9AEsbxSnN3qIZtgAuSB3QcjEH3/L71neElT7ndX943VI8OqMNi0AIxCNuFGDFxlNQRPAbH3WDxzf1NT/I+95/X/3Tb7/zu9SOs1cRACySaLmpNDXCU1S4rOmHTXOFRPV3DIgE8xR8LGkKTi8bnut3rLfSdwTJ4tpvHHvtDzWjOeOs70fNFDHAKInG5C1/3YNfw2AuwweMSio+FgMvGvX4d19uMg1tL2ooj9Zie15sk3VLgN6agaMLg7sMUV4bVFiW0WywYZY9dn+nMk60dzR78c0nwOMvin7xWL+mOq9C1nwJP3VSm+O9tg4jinBvmzAkX0WcqNKaHntmR3IOTGikM2zUg4XK860d661NhDIO8lZ3JiRqOPVbNtuRTJOr6mtuEbdxy8uUb8o9odMM9cyhnRX7AXbwHOxzR8UZLqPQyNNuU8bo3FCJPPMlVyEEr6uVurfBY3/7RwE50Yx5Yq5EvRd17w1Fjrp51WhsRSLwBfBWz3EijkYjDCR8M+p+SkIgGKuN/EEnESk6+cAROZgf7ZswnahBlQPIyK0k9W5n9GvHYqwAGLTNAHWFgKoXYeb/Lvl9yuwvzqFIJhrs1r6DuoxtwBNTJtfbPPTfAeQVsU1LYe5Wh89bj4BF6IGaWp5tlRmmZpVj1EstpZ4iC6SAJa/TtYakGSa/T4jD8zcA5lrJZ9+nCQ2caXNDvrTdc5h8zxXxJphbUCBv14tALYH2xEps8vTxPKcnX1ybfgJfT7nIhYOZc6CUCjJW+6KNQGpgqGyCX0+e1oE5PRv9y2rFHOju9Kj8Poa4t5HJvBU074CE2VDk2BC/5q+N1Fr7RZ+AgAWYLDOqAg/PAAgIDYv8QP6nlHAgSY3cKCJWi12RDZaLTBxAAy9lRObK1ixRNP8eha0K4tmSpjaEVfuLOLhJvBEFMRg1ZyJbs/m2XzRx4/l9ZlXz3qDvLWpViLOzVjmEUQBUi+prU5uARB1BwC6TgLslpYMuMtCAdhSe9U8eBPqcoiGcL5rsZUaflQPVUUnW/dvCWxVPjsFaZi2RdPXpJgw24GkcCNdRgg3vG/6DaGFl2d7yAAZJZVBLGeFsQE99Xic5diq2t0VWhMcMzb5CBB08Tmb6U6GgvNxoyAgjZjAIXkcUqb9fcfHJ/BML6kkiHpqIbEp0A6EDmScugwIJ9eSMCQAoXGSwyiIL7hDs4VIDfWB7knqYOplltDCYbHbg5QYcdBQHenltRWx6Sm4KpofAq5lp9NMznEWo7g2YaiNJKRKpy1VbcjeI8UWu/ufS6n2I2XTd0Cl9C9oKeTCQuj1Wm6NOcYSYGUTBwWRmIhbVQdKq/vRh/H0646GDCnC14KHVpnXbkLA3pun/GxzBiVDqPaiz28lyvD5J9CupgDahkh3rTkY0bEH5TWCcpoaebZcS6omrGwtHzfyLIoIakI5xoEJXbWnoXM3sv6k/Wy7RwgEVhCmhF//boB738qhC6DOxw/0tsRtI7RSTKS6IMN3o0YXc0sjxn/74Ao3yXKTUMOEduL1/fOMHBzM+V2zRrqDUVDG5P26Yc34JqRZOySRei+3RC2hS0YAoiGo+8vxCE2yMAZz+zXfy8XvKc0M381E7aE3baNu+OoRLuPvRUPyvQBJ+Rq/WzY2kOCb3r5Xxuhdrhj91mDklbkM5txKYaCYJ0AXhWyCqH47TbGIz3uksZZNz4hQbHquOVqfLV3IAI/9+7E2GRdhGq6zIqe352ZiV12ztHIY1lO1fJMpjg0UYcJOQwE2w+fAGdtBQJMbxfmB46Nt/ABbFvimAUTSfK6LIzUBgCoIqonH17wp7eHBKUj8cxHbJsjkfmyDuwC+mQ7hHVoDKCHG9nYlFl3yc9wQUSqrMATZlpk7KkqN1Xvj9clMnPm8LLdl7o5vbqC4SyW85+dgRaG2eU1+yXENerIWOq6PXfAE6oYt5zzOa+Gkl88GW8994RRqxw0RhT+KhqdACT/fNf44KXR1//1uQrtCVsHcBew0i6GWClvCs2TfWc49onNuHDf3PiO0J2jIjUduRigYTUuSPQN5vUTyJa5R1810JqkJPQXZmxZC1LgeQW6jPtOdsDi/+rjKKHkk7zk+rsaXnEwAoUGlLAZu7kP5bbl5v/w9GQYrG7fMS05ooeDSHDN8gB/WuEfeT4ukkdwI1UJI/nox0aYCXipZdgRVOBJJCG7tSGsBPsEom80X2fSiIIcc7IK+K0k5zL8fbDvG8JRAZ4aVFCUktku5PrUHzfwixCRDVUfBLPGzhpPeCtf6+Ndxi/nrqfGDe8/NvlrF3XEC5glWIPOs0LsBnMy3UwC6CeS5AxuMBk7Bz/uUFOzCsuA32phFMvmMHKPRBKzYbi7gcSMTBzi0EpcyBhwH2N9sHZ7kGz2G4ppjWIpYMzwsfGoKy/JIct4ay4W95/hoGz8WAk3y2ORm8giAQ5z/dmKq9A5hkBz8W00U56/XBtLHDHMZceKQyAXFjeYQxQqJ2xGEj0uaMEEuCJJs4c8dHVco/G43jZbNz40FRNPPYMeVJKLQDByrmww4cWruoeinj12kLJf7Asr9DwSgCmo9QRCleN+ZwYeDgIm55Lg5z4L+KDc7prezBje8vT7ODvSdgHGnGHcT+jCwvrxiWSbGMGLS2DqmSoC+TYtrRyB5FmFb10iMBw43Hlafa2RxN6K6LywWWl1GwVGzh8Kgj17y/bPxSF4LMGHYN0ViKy4IPDRqPA9TSkqL9x0JQvX4uOE82APObgARx3p2A/xC65TBCFNYcjKS7OJ/A5HwQ3IPkAN58LVwXIj1voBcnEAyASvAd3AJ/P65KatA4TkPBKOR1+AR+e5xr0ULC4JEA0W0/YpYuwOKseHhGyt2HQrYhvBHaa4aOJebn+N58MMF4bJEck6tk0heRLvRerxnuiWaLha/S2BTVFBNeyvVVTb9WTFXhZ4Uy8OO+7sNn94/Y6rgOjpeP53xrALFAi1WTGh5B/MIzNV7rGusxvzD9WowN4KhOElBd4hS+FxHLX7NTS9Fe0c4mGDvAA49AbSUpStWVeMYroU2zvE/IOPvPj7exi+LgYtwAkdCDbg4UyjUTRASmuYQLQj4uabtUPHrqCDMveBKA0moQAqZ+nslDiXiCjBlOL7rfjtZfAZCpfYDEBjAofJKoWeKx461l8/SHw7rQLA8jqC8Wp57C3TfLqReNQcY9y2ut58yf4AJIPR/uV7GKlj2ElMuFgWFRb/O2EisX1cBylj8RUAaNuLnKuZ9sugUor7JvbrRXG0cqO1D6wqAZWI97Vj6wP2y4Z/87f82/s3XP41/49d+Ctt1wS6JzMsQM+s38+v7M9VxmQcgegMkx4HCCrH5m1dd1j0JXMEU5bO4gOd65lqP8eBm9nVdu/sSsc+FVdZHsWRlIDgDgGv9q83l5Lp/z/FxNX4xuQGUReDNAjg4zcOaddJDAKSpiJbAW7gG9NW0WA4uZQ9ug98LhUDEQgWGCMM3CorZLxJmH69PVD6JPU522WdwAFqNHPgvPGdoUWpcFwosKCoDVor7wbj64po/wocowspj3+1iJCEVwfLk9xHEGYTmUJhACwopx5jApCJM+lEESBaSSC2kgqCfzpNtHEYkTKuaVgvUvnDLqUW1uS/v3W5qrF6GTWTvE70pzsuO//qLv4Ff+sHvRm+aeoWb9YqovmtIOXKjlo2e18/1Q3cOcAXVBOgWQgwNXvAZruVYV2V+gQwL1pCxlp0YkSsKzggpI3CkdnULNCI8sNqTohBakz+MGt/omXBph0Mcs6Lpt8BI+IHI9/i52RHxWgzHvAYOBJ+qPe0iCKSZ3UvgsqJKaJpsNPvBpIpi1lV65mGjOn/bTDQctHeE1agpkaBgtQbS9fD+61er2R/dgwasSYYn9yxeU1/2GT3al8eB4cy4qDzkYUnGjWcH1ueC7BetpAswm/UJiOQnlHBXyw1PwWOodLamZo35WvOec0DNTqyGGp6HtkTxdVVgAtfrgtOy4zefHvA/+ff+CL66nPD4fLZqRipou/+rWXc0iX0cptr6C9eiWGDhcngEKustAFDJ8Nm0zchGFhHfl/zMYTx9LsnVINWY5dhj0yvHgFwRnyfnp4Ql4GFh8VBN2z+k7z+yxjd/k9opN1siZQrZEO2zDv4TP9dywjhBgGOG0yyFg48aUDbzzwHphXxTFmI1//rVFm3bbUHvrSCnCg9FSkhwLnBQYJT7iJjsXqq7wLSoCjWub0a20vLNHfXcWykdXoSUDM8Wc948K/z268R+38E033HXQrMGw7H55x5MmzOTMMC9YsHUVFcyHwFaVRLWV0RqJtmKpWY+kJpeqNVz01devlKoC8D6DXJtuH55xg+2jr4MtKZoTXF5WqGXDrk00/RX2HO7u8G1R0vFBIPGetzvjBOPEnEaJ2DcA3NRLI/OtqubWfw+aU2Qw1+jQxPZWHTYtZbnGdWebDzkYPmASg/wDMCZRKmOoDUf3EWGin8YNX5sruFmjk88gVcuIPYzi0o5QGr3IggAHBbTvLkOv8e2Q6oJirzVlFPsi7GpfSNHCq5PxnS/igKgcgogUog+vE8By4gDCOS6alwBgqpqcff0a7KyjucNXDUECE3QwAf8HsnV314s6M8D476DJvuMFlhuBbmpvjzOGAfG0TmWQC4sppIGX90/X+nR2mBAoxRrjS5vAQ+ng3jakNz55lbGqgehTqakDIFuHXpp2LpaDYV1AtcG2Rra1eL5vOeDj12iM2zTRV+5X+HWCaAnyZLhV6BdJPrcEeOIv4f93kbR/Ewou3E5AS8VH9YSAhuIzL4QtvZeIPsj3wuL0d2B5HzkOnvX8XE1/g4DU5ALtaL1UcAQ+ZnY6GXxhHkvOGp+H8ijxkf47IfwjVsCFVQJgNEnpSkiCYJ1zSd8M8+S6edSO8M/AFFawZGFhnL+2YsAKCY2U2KtJLe/TLcEvB+rZRcYRtQPTNdj3PXSKdfPMzTCXa0sqPp+uDDuL4f2Ho41kNwDZ5aJHBF72LNxgUebJ+fgB+PNx4G572+5cqs54xbpcWttAvos8VkwErS7JqdvXzYQ8QZAHaRFbErrfpQbsG2mRLqXU78t1EFacPcuO92tJD5r0MxJAS5EKDLvGJoT8Y2sXi6+RJaAowsY69QBWgUVqdF/5wehvY+t8TUHrlZR4QauoNvBTAYtgrJYuHkWIBh1Tq6oZB7kqZLIUYWDpAUAIIg3QDET6ZoQ3fcvBy7ABJhCLY7n0FzUby0g/nTQi4tQm2RhUk684wu3fIXQMCTwIDcOm39ygWv4npn5SIF2YC3SEpqcG2cBnlr4+jIV+11FwfwZ6TvTf/ZNHRu9UG9jacjxpwwDUdsmcW7TrmJNJjmuvcyn5u8VyBMt5jbH/CBk3TwXD9k57RYKoy7zez7XTOhpe1biob+d4HJ+FmrPbJWI3Gth+JSUbbcMOfccB+tV6KE84C0sIOar8Dned3xcVJ8xes2NHB1GQuPk7/YCwveOGDM1Q4fPrPv2miSNighzcVLa1tcibv4OYfNWVEGKezKse4lIoebyHhVpvdBPBVI7zRReESF4h4CoVWHgFkq7ZXrFOAlknxge8gtz3AVTzSEAEFl99prGz+jkW58byO+X8JzoMTRq4+nnnAiAMy2zYhWUhVt5FVwfxkfQOKkMRG+7sFDCFcjNEOE8v3+GUg8uoKaFVe+XYBldGtFUAjw/oyAUuEehbOfm+TiHzNFIwe1M0N0JQGSIcmAK2YouMIG+D23uDyn9j4fqA272pBSv5trhgx84tH6nAEEKQBeFMkZdJP4BqW4ACk2U0twAqkTW4x65qRWZeaWcX0GyZfwrjvhHiE3Ktfl4JWWzLvjDPbr1IgxzlvMTybcPCBQuDJzhF9RX53nzVgFfZOV6ge6vJqkOmXnI57cwU2qemvRzcGWEz25p1PX9W1M2Nn19DbnZWIOP82mbrghLyXHml0M7y/Fax0Yo+fkY0zDBTbgyFNi2gv2obdws+2YniIzLeRyMsGrL3IaFKDcbvqs974RFM5oL7BshANyMd1zsHa+V46Oa+gx13N7kIaZKUI+DRMkNHDSz+ch69BUBTDUfFsgNWH17ATdWvk4QLdJS62Yu98HnCIFF67pMLqmwUhbfW88q6c9VFPetZ/Vz1AUQaHArJ/f3mBuvpQ5cms+22G59ditnjsA0MG78ez1OlzWHlBwDPuc7rIM67nGrigyj+ngKynzw3yhfKxuf7k+rPnyxkg5YkEtbckXeWnh13RWLUybNeCfklEYklfIbltR0ATGByBQUHIR3bSPG5Cmm3tpcS7SNh3iVJufl23NK3n61Zuvxgc3/ccE9TanGUsiHzVEkcEwmN5p/NsAf+pA098VRdwV05pd4rTj/jfQF0pSicLrNqKKP2K9F07g0Zw523/TwnXdKeuBAXKkSnIsoqr2ojRfN5SMAh9iYh/PTzIwmIGo5/G7qVgFb69RpzyISXOCRelq1tbpg9vuqzLMAGd8h1G9xmsACKNgooMsYVSuHmphCK8z3IiTrhqzXCAHs66m6Ghwjfk5RQrFAgmdDPaNPU/N72XSSqQiw6tqyKceNEqHVJEMhS57LhL2m0HMhx/DuXOWoADT3CMvL37pct8e3svFF5DMA3/V/P6eqf+Kdn2M2UdEiVSOHeV40dazVKiAOAkDLZ11zu28s/Ezxq5kkJKWnut0IF0khs/iP2S09k5NS74EAYI3PM5fgcN9FQ4q6dmZddTfLE9zjJipEmWaEnLm2SNaIzV8WrjhfIc3loyBqg4CURgNRgaA/7hb6K4zAiEy4Scp8g2AbeuWgcGt8HCyr0LPW1qPQOqyHIowO5v+tRTDzHz8bG9XrO9RNFGW1inVpIUwuijy/dsEsAqtaEzzahaY5opmo7AoZE2xsMrsVK7XeCoAwmcqvEwVSFU600tIYhDeTz8zOvrUdfFqkPq9dDkL1Q27y18iF/9THHwHwj6jqLwKAiPwz7/pQ0AqruV+052R8/1SkddmcIeUAaNMDgAZQe/nGaRkLruHCjDmXDSE5qIBrlXmsBhOHX1NKLJ+DH0kefj7+tDJSHvLiZJXnCsCv5XsR0umZN78/dOf0i8fA/XweS2c9v3ahNpIQdLwv9qoneef0xRXLmz2q5wZN1FllYc4eioPYGI1TK89Z5ymthQPfAWU+KASrpi604Vgj3PjMoffvBHtuaPj9B5fMhbQMtQQdf2+5HKsNHbCCaeAhr7k+TiyPE/060Z+njc/QKJoyzz20cL8M7xAMMMU3CrUARqFuKUitqUoLkJSWVjSPEYkkqsADaMiGBfsB2/7m+La65da22N+F1eJ/6wg/aTpyWth72gHMwuxrRVAAIcUZJqoxf10V2AkEeagKSNOpaH5tCLqw+noOLnWTGOCD1p84dj7p9P3yuaI6DHIRkmb5NgjlbDVxn9w3ZxCDXGvWph4AFwxCe98e466hP42omht04lEEGWmi3JRryxLbrrVIEIr55dgUEz/uRxEhQwEOmykKXgJJUonFUKywMldhvRUknqY9C2KSV9EmDs8Ydfp87TQfL2uE4ZyCqCJUrjVxsKzarliec4NbfH+C7pQM+709WyFUZkj2NxvGizVCnzEuXouxX63jUvPSZ/15hgAFSMyy+bHirRYupfbfHyoJDWEp3Fo37zq+VR9fRL4L4Huq+lar7P35Df7G//Gfj8H+zu/5eXz2+37eGyoiAJ9AUKkJuMiLOastQT0z298myfC7UXCx5kHzKBqimuYM8QXCTytD3v69mrOV0ll92GpqqyCqwcRtlLAdG19GpIGakfnuNGtvrSa4ie3JNCTKMMQU1oz7pmgSQN7ybHXyjbY7MTykx8UOaqsyjrWBSM4LQtDF3IFWT45lDW9yLGuUge8FRx5F6JU5I/5yiDKUiIWQVcfwbimddgTzyJCzm2d8XhexwhduQdUOxbzH5i3FZSrm/RLP3x939C45li7E2cOA7dSbZz3yeTSsRUF/Ntq1qGLc+TXIivR/v/orv4Rf+/d/CQCwX97gfce3De79IVX9o++88N0L/EP/rf9xasZVMDiJBKu4OIsmrb5baHwqUm6uiQO6Lv5ejeGSZlk1TQC9giCtVP5+LtzUxOl7Zuivhg5l83tEfrdueloq1FxoNxROXlqO322ew3BI5iEJ5wZ5PiD+cR8SY0r/VLaJeerWeed5WHusQTJKCetNUovbMdTpi7QClij3bYSdQssFENTcKuRdcDBcevDlC5CnC6zufQm5TgKLFRvQJNjwXu0amRORuAE/kxuzXRLn0WZNUKKvgZv2sk/Iphh3i3UmbgK5Tl+HjBCx/LuN5Tg1EDeJ8J8gMhgjE28zPgbQgsIdLdcIHPp8/vaf+YP4bf/5PwgA+Lf+T3/2rXnn8a1tfBH5Q6r6p/z3n1XVX377Q/5TaV4hep8dFg8QAMbBZyv/wtpVJjBklRQCWjTvA6whMu0bsIJBEc8nC4q3Wn6Pbj4TxtTza8Z9uqtS0zBDyChv2K2ExbnYpfAGqkATu0aU/naQh9qzs4IvN9hZsi6A2OIJ6qrYoPOcuohl3bnmWb7cMO8XNF/A+fDx1fDroYJ5zrkMwe25AzXqEsUzSdEt9Or4Xg7LYbyjcMaBvVg09SyCgoK9Wm96y7tIViW7Jx2ut6MIVRt3muaHYwJtTsB9/P68Y9wt1vfg3NEuA4OgKa0rsTE3FyD7GdBNsBuQ4Amom/cqhtsorTfNrj2BTVDIynHd3h7fCrgnIr8A4E+KyL8uIv86gM/f+bmCzDJkQdAmONFFOMSirv96auSK9lrBQfK6i8Co4B7snFwMND/DL62jUzbqYZG3spDLIg+QkVps4qDRDtcGN7dr7PrZWy1E4UFsQ49/663QYszYx4Wo+8GtGZbFJ17td54Xa4JZffddg93HzD7Arsm8e/unh3mqVhLB1HEyjT/OLKGlVlXnNveez7/nvNZ5vj1atQxhG6ONjL/3reAmYpaMNfj0e5RcKwH6OnU6QnQll2OuLRqgAnA/vnlcvrvL4eXK92mlyZeWMXwX5JPVkL0KT1ixLQFgWgNRq1+RLbnqUdfpB45vC9z7KwB+5us+F0jsbht40p8t4Z6Y4CIAblNwAZf+hRklTvgIQPAdTn+AIG/dWJ7nELIL9DRPF/56B3RKmIBc9N2ztA7Pc3srkq8rjJd+8F1LPH8uWZaMvipR6dr3Pcpwsfb+YiE6XZa8VqloS9+Y5JLm3XTamC6QppFomgNNK1FmvNX/rg41IytzkayFvwJztY1egU7y8cMaCjOuzMnt0Pk4RTiRm+Qtrc8bcoBvSxcoBO2NoNfu4TjP12Dj0cgFYb3AtTn/3sA59fFol2Hv8ZxD0TT7FWIqpAnUQUnZZ0Rl6njGOlNgv28R8YG7EbfjAbcUPhq498GjaDQAiBAFEev6PNW/LX+HO1AeMBYNN07V+DTzqjmP8tl6froQmvemB58CYT0A8I0P6CjnKfdUhcyHBDI52CF3tNw/NYtncPFe33XCCvaxNtw89aTZ3tzjJCefwNam1qG3MVfc3o+kE5HAXgJrCWowwtTkPLGIBYulzBWYZzWLrcGwhKuj1EPCpYhnLEfldNA6zGaTmhhLEeqHUlax9jy9mexE5TqT2DjsgltrDtRy1xatMGHV3JRnI1Ndm/1O4SkIXCHGvXQeYrPRQ1guTHgH80rVndvxqPjXOxVaOT4+c2+kRKucayK4zLuP55S60PTdLLwiUEwbyHFzcO3efO6wf6R8Dr6Qi0A5xP15+UYJnWy7WwRfyuTEpaqFg/x8vdeaZ812VhMUlI7wU2gWocDns6ot1jAz/PZZAEBK2gmvwuv3TA1eNOn0giFZL8DHgEBfMfUjGaei+E2hi2KeJtbvXDBVMF6v0Nk9SlFCsJyjagXwkmExpnsUDMQbn/0gBEbR9vV3XwMEeqOkmJvZBNMy70BT83KsTj2+N5d2nMeFixehVChwwm309ZprKceWJdCOuItCILl2vW7hgYz2juNb8fF/K0etPPqW5q6bt2oXxu05jtUiKJs/v3Bz0TAN83eUa9hFizYHEn2n+VgXoOTnY3ETSCrnCWHB58O73i/mJy0EakwuBqEGTUT4UBG3PoNkXJ0kkjrGh8Vdh4jmKGAA4Ds0TITNBKgmWtRBrGh+Q8TUa0Wdly+ecXe3BePySKLK+YpxLvfeCtBnBVEyV705E66NnDOWDIuyWB4iDAuP66IMBeP549ziXm5zD+w7GUakyZ7ELyo3txjGLAJJM9/BN7XVRBR3iyTGOiML5X45rzFGhTr9gePjl9cu6CMHkJu1hsaOmh7enggHzQz/8+AfimvFG6GS8WDHGDhQLb9Pc5GnAY7vHXj2KK+pTeLsavKJLai4mMu5KhhXsYVAoJHXCPDOF99ojAQkNTaJLhpmqgJRd29/sVj8mXF7EW+v7chy0ewCtRbYflujS3b7EYSfbyaxv9ZTu0chTfftKRCjuswQfP9vfwKoQPZ0Hd5y6RqOGixM9aMmD1Nds2xZphgjw6QeWqvhvrC0pFwD9lkD54xkM5tVL04rwcfQ8xsEXvWIioyW3LASarM3b4riacacq5NfnIrNFVFsfiRXgmsigL5acLZYlh86PnqVXUsizcUUbxEdr9qUfxMh5sO2fFgFjmG/d2j7g1UgGSqJtNWqucvmB5tZtlzot+fke22HPddQW/gTKVTe4X8ZenzU+tVU50ImKs/P7550Y9EA5iWQ6Vfuk5x8RYakosQXMM9G7Y0OudRENOW1mPqrlf1iz0Nu5P1MCwG5wZai7Sm4fI4s487v5UbTVqEeJnC1yDS1vT2TRPUbAJkdp1QmiDmO86OERYuFEdVyaFEQKPPfs5qQ4OAmkFZLl6EAdla9SbIiskcJGIdvm2K/b9FZJ4psFFCXsXuyCWPNc3/4xo804beXWRwft5MOEJJ7rkgpV0zDLNrory/AXPQmfFbMRPg5IMnvrhLwxhSW2832Pi078z4pgKKUN8qi0TTL+8Xr6kkyteIeKOhmasMhjtQXUgzLUMm01MxgBRYBFNVoJlLri1kEoS3ZDKQn5VM9Ro3OMJ7RRsedraLk/3Nck6a737cYf8NiJOcKuekZnjNAT+PZ2y6sGg2ICS0eZsFotL8K16KwLmn1TGa1eahyebIqQwJ4swmN1mBkLrIsWL8em4fyPat25PjH5qXEtxkxdZvjHO+Kg6xfbthfrc7Lzxh84CIl14HpuHym/pzUaCZoQbxwa1jF9qKNSanw5OsqXN+ea/ldx0dtmllNw9rqOuK41S9ckfn24c9qLIiI508Y8NXdynIf6GDu81fX7NGjHGXQKFSKPKimaPXLK+hXs89mcSPY7x5ANAcN64Wuh3h56eIO8HOjIMH8/pHP4EJoCISLZ2j44DIBuEZuJ05CkpwIWI3zEs8lE9juJZBvc79u0pQppNciLAuYV8k6t367FcL0ueGaKLjKFNv8U5GNbCbPr1AP2bbhAmcC+107lDYHELRmFieFiPvViM2Sc6nZWsvnoF+mCbxCrWXYlrkKbSpmE2yfrPE8bD8OEneAMMsBknjchC9Ve8hkrWDwbFmcM9Yz8r4j7Zeh3uq+vuP4yE0zk4BQQ0JcINz082QbmyEhlEw7Q3kA9YIHAi9fBLWae2Eu+mA1RO00AFHLbpxwMPMPkhR+rZ4b8Z0gHT9Ljc3Rpd/lVgOfO6vmlqP+WTR+nFcBtphiJVcAkdzEDSoKry1v7zOvPKwWsfMEZkHhAMb0kanFYs0ieQ8UTHMtpqYvvNrbgP78XIrQDsGqKbC52SkMvSZ8BTeVrkDZpPME4Gpj2d31iFx1d7HaSLZjxN1pKvt4UvPbPZuArtWD9wdLWiKWwtLskaXYgNGtezEbnVjqNhVZN+Yk4/UFfKukoJprz1ZpQcUuaH4bwFiLYPc5MutP0IcGq/R9x8fb+EWzciGyqCT5+yytzA2viz+QUHL7hq+btJjqwdeXfL2a2EDRlnuaqXF/N5uQnwcQizV6AVB5MYbMDdXL+/X7apr2cG/++1tsrKopxaR/AIPFCpFhfqSZ0umDywTGchyDGrq6vdZ0rKBy5asPXOPQY3GNS+3Zjv8yXu/X64Cuav+6InvZp0VUhZt1/01TNyw8mvd8Rm4QX/TSzLWZHUBYdMysS/Nc1KvbcGO5hTiXFAj9opFhF8vB2XfMoGusorNb5MDcMkGCdy0EDsD4PTBPgtMXO8a5ZUwfEhseQFpja2JQdK9UzJ3kOGRnnQ+oe3zsjd9wNA9J8giGl2YYa7FGieiAcuP7eeynxsli05dNqYLsYsPv1Q3Vcdhwgaj3XPiVy39ATm8WJVwRHCi0yO9UTWa/2DmDfUhBIWXDlXmkND9UhymCSWZqaMa2D1GNm3BPcCe4wSP8V+aoCsIbITYowCPkiHCjZi91EMQ2/TxN4Dwh67QOvaOZdbL7RaYL9AArj8IErpmnali8+52gb7khA6yNYqCpbandARwaoR4q44Igrd0/AdEa/7fvG/JIs75dZ4bgWK2ZWEvBnCgAljfTKdASVkZYG0LTvQg+cgdwWPIZ4QjrTQ9r5vb4eD4+ckGHWVhKLQdnmw0VViN9hIZ4H3Chx83FFF9x6yDMW16/muplM08usNByOFYDvj3e8dpbwgbHTQaU+6wCoQit6OnOa5R7V85t2RiRuEILZCAr/5bP3oKcB8HGcXMhdxijdvP83ECF2x6bs+Wi187NaK/JMrGcdqzrwL537NeOiW4hrl3eHk4KQQoChTfq0BhHgq0I6jHAuHZkT1JbtqQGR8fZW0IOW3V7xmS/zEyDZQRIYBYJn3Px8OjQUBqcB1MMbgWoglVz7P7z2gRVee2Yy7qOWk5LG3qoo39Lm37X8XF9/PD53L9aEMUa5qouAGzD66LAMt/iU4e9yt8LY+5QT1HyNZXcMLemdmw6/k7Tsnu4rOA0tzgAj+BL15/lnm9jrFLuWyYibChc4Iq3KcwVtb2xbmp4EXL8/FuCq1oSdWwL9iLlWSvBBiiC4OY9Lf9irChwxOjAr14847/44/8J/oOvPsd/9OvfeXsgy/iEpeXWUYKqEpgP+9/1DYajCKxGvuMV3QdleC5D7Q/I+P9h3h2EixLYXjCm4lL8yY06WPSEWXMTAQS+dRCxRO4BWgqcm3qtLJ6CG0syJzF4FGXs33V8VFM/ARUCQHBzX1NLkKW3TPT7gfPdFZfLms0yhkB3F39TCu3x5nrUlHXTv0MTVzP7dnELcJisdz3TAY1/x/XfKxSoBRQW16OUn8fvA77AywI8nLdet0z8O4Xd+xYGX9eb7/h1aH3cLiwKqkNiFfkLOH5ep0BVcJ0LLqNjDrHnjue94esDYXWhH04LRmy0a9C8OR7xHQEG3JfvdnMxr3ytCkvYZp6iZlm4+dWuevjMYcz8erLhWJik4Dr1sxEJKqW46Sbwu+leydvCtJfzyY0QvsWJbo6Pu/E9Jn7w6xc9hoCagUCyKJZ1x0988hpfPN1hnw1Lm7juCx6/OpsgmOp5yjAhUDc3XYCbTfdO9N7vL6W/vqWlb5/l8PuNT183Ou/lrU2KfD9KLAPhl1aNHjkMfr23qMe3z6UeBuPmfYcw4a3fWgPxHSYfVQHpITSpCy3sTz9Zh7lYwzWza2ndG758fY9/4/LT2LYO3Rqs4nKmUtexusUV4DJC3L1pHhZru0LXJLHMWsK9Z/GKcXJOAjfo7RyGgHQroIvl7Usy5mrhEwCRQMMegM3nMRtgSG5KNYY96dayA8I+Dq2k20YZdaSV40eNutSwbozTD6PG17rxW270oHouGr4iAEDU0GYVfHr/jKVN3C8bvrqe8R88nuzhWYDwpniGfR/AvHlRi5LmW2UBh0+Km4V4MwF1g8Xf3JD8Wd4/LGxBgG81qyw2bwFz6n3HPTmoU4VDNoQsCw7vXgcVBDokC02PUb9DEIj/PhUBSEab6apxGF/31+b/v71vWZbsuK5bO8+pe283SAYE06InmkB/QJEhcU5+gCMgjz2xOPHEEzEc4bmDmthTauahTf4BNVUIEk1+gEKA7bAkSiYJgkI/blWdzO3BfuTKrLoNgGJ3dURXRgC3uuqcPHky92PtR+4UmPasgKKg6opaVuPgrZhw4Hfh+SXBmZpakHvww9/RC5RMdQ0qLFIgQBxRFlp/ON0o3pEFbQO21eZzBdKBmDSV26F7n3byj8s+qt8XGYEW5fB1qVbjII4wg9t2jZh90OBBX64A0qEsPZ7P6eTn2oWhPkYP8EoQf1VyELnkbAW/ePoYN+uGIsAv2mPcH3YetlO7VgQqPQQ02KSiVuVFZYgJM3wdoT5peop5A0gn0exVP3E6BkPP2j+mgerXA8gNJdG/VEB1LMWUffp9eayT77ZLrR8bcAavUNcKLDDyeYQeJJN2xnWLfIs1KgbRBqrZRpbVGC4Ivu1MYGC19bQ58KIpFZ35+XkhbIgBYs0aXOjEb/EORTzNN/bOI4u7VK8DkGcBOoOxtz8f30Jo2Om5UM/Jr9ITh24kax/UJbLuNMNv7QaZBgzA05ij9LYkzcTBqDGXtrZeY8ARV5QOz4gB1VSwzT1OqpxSfqZdXuMPyRz8n3btG2EfAPv7HfayZietFVt0JQoJmzKSdkShKlSYoXPwHG5jO51d3SdwO67nS+lzal+g24+kgQYB4QwOEIEqLX4+uxfLiIdH2Sj2HgfSKG30tkfLktE0jnI8fXZmM1LYsEPVWB/t3vYoSkpT3KoLJgXKQYYai2BZGnPDaCjXRKcJpvH7mPqhorRMzX7M7e0rMrznJvtgEqUGJa4oR+t7Odii1jtAjx6DZxRyR0LZqymXqpCjppMwS7X561jNvf6emWVZ0fPyubozC3Wg78ok7T7yFR5sl9X4tz03WUPyLrNKVGArJtmloaJPsCp9riU94xYmUcQ56nGRFrE3JjgFBdqN26A8UcmMksMAMIw3hQIzMjGxKHo4Ec4wbX6M9NNPKWYd2p5hnVRYameoOc/c4ww+ZugQCMEU0Qp9ZlidySiuZewd/B2JsGboKQo7tRY6aGQAmaQiauMom3vY73t/c9QDmATyFFp9qIUJ4PKohzhJeA5n/LWxXxbkgUZrpGCvJrjKsedRZG17n8ewq8PzvxwEshMrzU1hx0RRrqtK1J5YfZ6IKzNCQOZIbLMek6Ukk9506Wb0Q+2yjJ/pnUqLq0PYJ7mkuffeJ1Cb0Ez4NSpmc7nW19VQQubDH23xsMLsTNEuGVclm1lGyMuIIAjljLdPGkatTmNLjV76T7nxZxVzlAEZzy21C8XoL3ddNYCUPnWI1KLxfWb3lVFAzH6H1Nja7USGlHP1XFFADsgwLNuvbAKVZsJDCyCbO70CIfC4SWBlItFCfREkH4ROmFFU+WgMgdkazHZ7K7A5D01auvLhfnUHtKJQTw1uN+iaN+hE+r0saPXeNt7U1veCAH1vQQjguqPkoWk9w5koR+D4uO+TyJwXZ/r8d2yMuiHeOdMuCvXTa58MpaNdz57i1nciDQ6nhu7BF7jB14kFAIac9AVmkwoyzJKEovB8/CjQKAOTxrVRc+1B7wlr/wm6DoU85r+CdOQ13lTUup0aY4i92gPBEyo8YaraE1xyxx/LrmbzEXOxHNA3HC0sTagFc24+b5WYN+cKqSWX8HKX/p6z4w4IlBHv2ud4TA7qGjYdgsGA0XXMfcwtIy9eOmJcFjCicAUhqI8UVYGyhS8CNMY+l7oAhy/Z6br4pXWch5K636QGsnOUULxuIddITAckCbNwEPZdq5TtmvkvSJ/ZuSWLduEEngekUjCtp23axbA474KeRMPMJ5j+BvVJz/eG9Zm181pfcGOsrqpEgQa1rLf4unC/SHUU5md4mgFCCvSc1E4x9nwHnHiWcyo8vNNCe8Htv4DvpU9DIJbhGSHwgISAOf/9FRJxxLPZZmYnoGDUVsFc5UCdomu/SCsuJORMgNHah7BggRmQl84rGGxZ2vabjDqbUWXqm9BWXhPKIARGMP7S742+whQNJ2SH975dt1mh1PVZT/RpO2BTr6dfgcKbdER9dx4S+RkdjtttDeZ3pg8fSWr80PI7UA4MXtguCvUHYo/v+D+gi+ygijn2nfcRQ6aqh8ecxLWTO8d8j7ZpD3csThBdw+8SyR0ejx7GS86/wVkW42dNlugj7kUPtUXIhh1xrLmYeNWIPjX+XEQyBAyQJlMQUUJ4meadnhHj6l63znAP5T+Urceo+663jhJECcqKjMdi07gHrzyQ8XneXdcZXW3Nqgz2LOfDz3M+CFbS0MnsMQY2J4K2cu59LhYd5wLIBCKFZ3kWYuoiQANaFA8hJHWSvg2nDYfwiYhjnF4zgEuR6w49B+aMApnbZTV+7KwDiCCJkE/i7qwKtaMC9b9xjwJYAi6KM5UiD80I51+oIoUJBy8fbb6CmHBDHcOhnCBGmIY3pAkPP05/BYk8QusMjI9OfPEa6UNwyG7OPqG+Ne8TJeLFqEVOtIEiM+5MaIjFnvldQluS6VK2/vtysKSYOZEnzgmIvkSjMtCU1AIzCYa8gxAY0VccG0Zn4sHr5rcbGQVUQ9+dCWLqGMf03cz0uvRFTBMz5kowzE0u6ST4o28+Uk00TIUodIq+wxMgISW5VhzKDW1eb0CJb2OdipMdq2faZTV+ECBpl/x3aAWHaKxBUBRYFGU1bKdkDrCnHzkBXSsre8W0r1wQPHyBgE44vNlkSC4Zog/TX2bwcLDNvzPhBeO75j8JLcK+l2Lj09KnJZNYaBIVJDgmzT84unjqg8C9mEPOPTdfhu6I0+G+1LKNcyBcTisynTbrxbnpVVqPc5vfxx+kGHchtr6G6UNo9pC2k8Fhx572GUmmrczvzgjUJ4mRDZtlPM/D3LBCkK7xu+PY1rCI5xlMRU4ZRXBtivRvSNf07YaYPmlpSnx7oF1Q4yt0dVUQjKYCUavCl4yeFEOML0BZG3a3G25vNhRRfPLkkeV7AznzkdjTS/E4r1fpK8we+0WBY3j0pdfJm1swEGlaiWcTQ82MG88ZctlnUOMLHOWqEn6HNibiavG86Tnsk0gbNp7n9/DUsvlkhG5IaNTU05j9uUPIjcaT2kxoPKDvgikdBeTcDO8Rqpl8NJ54L+Kwuonvnbfr4+COfBdWKvSX/QInYa9gPjYxva80AeNdX9RYsCuykEvY/0FnnLMxm1LzOs7b1i2i0gXu4Ch/LTU+AKz+psdCITlA4BVIZ8aI2RGTmsvS8Pj2gLt1w5OndwDEDoHwvygWP5VwykU3VWyTSC0jUQgM1gdHzamuM5EETWRlW4xMgunfwSi8SPzXGT7tNUJE5miTLgD68KBEUKLJGz1cyvIwxjmPjxGKe+qzci8T5pl28rv3l8tVFRqlpObNReSN57lIP4N2zcfIIdOh/eSfgPbFH5y27jnij3XT6feQMyzYdPx3HP4xIr/T/rszmK4LwRGOyDSt+rD43zEfMV+9NgV6lmuEwmW8J+2SB9pLY3wReQ/At1X1Wy+8bm22QYObGpFrOvaAhOz+t1XB/fMbHPY7LKthXWN6OLMbw5fSIEVRXAioWilkbYK6Kdrmzy4wh18iBOmpwioD8+YYQxMH4xBTDYThr6H+nIccmroYfGu3XjmGOE08J9yyugCpkgwf4UlmuICE8X0hUyM07llGVtcsUQRjoyQoF0CssbOg5SRAEq4KICJDDbjZ9GGzJpg8CoMOvgqx34P5NfoiFCFH2BpuYg7ZpY87X1H6PazUB3STY42B+RCGc/zEr1Ewg1tlJZfMoe0VPaNUe05F+mNkeldem0Bt4ky/jHB+dram8H9Be2mMr6o/EJGzR2RnO5Y+2bybTuAS3GH/DLmaa2wAutjmHWNsmJYvZu0ua8WyNJSiWP2I3KqCWgsabT5XXyhFMZNiceLJ0lia0jjGOtivdcre4xaLxkIgPpJGiVBbu7UDJPVG/Rrt5oYCcihY9n4SbrNcg3Qy7eiZzCzEWENc2wVCQO7iufQqFPZbLadAvGZ82v7UsiIMHS0VTM79Q+A5633DSuSed+bVPmf+vME8AgbmEEdnusp4lmAwAXvK/XklhKWjhhY7Ohn1UIQhYTn6PIKVQYuSWP3BQlur8z7qWxW99uMkeE6a39N8yzpYw/NaR18PIR1ql4P6KpCjWN0mhS1C96zkZaIO+xN3YfD2K4BeZlixOOMDQHFNv5aG253N8mFbsIhitx6w1YInz26xHVZDA6KIraPiHv94dDxLqgDHru1tkKHZaFCs5YlwFaOEjiPC6s6yreqtot028zesClkUsrQkonZYUNcF+lxQDmaWKMXcAaQzqN0qjl8+AseC3a8Wy1z0PPPMGgwGqb2EFtA90W2NkJpAPYc8UQZIey702RklnHKDnU8JOZlQNF0jzerILQfN/QPWfzc94j1DkEV9es6eg/rx4Q2ZgrxsXXuKRyrKET30ySFFRz9lo2gFSxXQtYLRz0P+mUHoos8xC8lEitw9Ce3ZYTegRhpL/iYPXWTtoja+HIPq5h86Iw/OMhahVIJLa0GThkLwOHKj19KwWyt++60n+IPf+l+4K0f8t7/5fTx5fovtuNjmnbX1yAAzr8ChuTrzmhCyzR3yYOhuiClPfZ7A69BuxY+Pvm1Wj25RlJuOWIojln25Qd2svFOoiCD+iGhosT3p2+OGd77yT/j447ewbYKyN9vX4Kp0syFyFQYi7kzAGiW0f9jrcQhI1JAz52R43OlMO43+PTvN8xAYorbwYquVkg7Iyn4L9njzhpvQciGs1uekPKptjc1Qndr9RbsQ6OXZMEQCEn47MysonZvRG/o7QuAZf0QHjBCZNogOhsgPy5bw6gs5fTHxddBijLnyj6dN9NOMgX9GE5EfPmTjr++8o8tbb+WEfOkP/gBf/MY3EHZ8xlLJQZKZfnMYTQCsze1605KlNKxrw7I03KwbbtaKXWloKnh+XHF/2GHbDE/WWtCOBXpY7KRWrgQjGOKiUqWf7FqZeaSnjhIaYKdbNtJYAWnrLXB4u6F9acPyyG64udnwhUd7fPnxU9wtR/ztJ2/jl796C9t+AZ4vKPuC5V6SCHk/QB5pFbUKFxO0Nm4bQznappNhfBrxdKTQZRs04tFRgrscfV42usfnTRqyWCUn1gRz8nhzatiRF3XomKbCFIjvyYToR03x9X4Zac4QdOPx3iSEXNPG2mRZ9xAUHlKdlf/g3OS/Z3hwEAY431eOObP1eugu0UDRPKhENsEnf/4+PvmL9wEA9elTbB99dFYCXEzjL4/fwu/8+/+Qk6KA21ySL9R/sL8SJ6IE7Ak7HABg55YjYvsoaM3E9F532B936fBorWBdq0n+VlD3i0cWxKGXperODhbAtRjEt25a8U6VUR6dc5oxhAwtIgqDzP65bILm7xMa/t23f4F/+5U/xxfLc/ynD/417h+veKZ3qE2gm3TtKb1/qGtiqkYkR6DshfLpaYOJEzLg9q+gCzGf+5ICTfN9+MBJpRN++B3rjSTzqwjWfc8RiDkI8yC1eAr67jhsq9iBElSc0v7aEOtNP0BjqAgUy0djSls64bWmbyevF9h25NXmsgUN+JplCq+MQjJNPP6eWc+/S8cih0MfoBvLOdCMcGfGaSCKGnMCfOn3v4Ev/f43AAB/91//y2mH3l6mV/+bAL4mIu+p6g9OfgeQXuJ573B679EdJ9K/FxW3MR3akhs2DtFoALAtaKXZIjqxA7BjmbeCWovt+NsvNnnzIgGZbdW3/PaiErIJysH+zkSfHt7oc4KGCaUL8hQY2QA5FNSyQO/MR/G3n7yN7y9fx+2y4X5bzUkphmr0RlHT0+/SJ5xWOX7T6mXza0g4nDU9GL4y/Kd3yiIQDC9DYARaI8ERp81A/OASRlPo9/W4ffSp+cx1Px4SkbvUbiwCEPvXedzwJY9nhyMx6E786DAuX53+gxiX/zvPDuD5cZpsIcTzhejZJ9f3f5/AfWqMUNj0sDLz6JmprftsUpjPiONMe5le/T8D8FsvuiYldIN50jFOjhw7wdjvkk6l3omO3n+yE2sVCC9qaG21wovtWLLkU/gbUsAAPdLAjwsG3yxEFX8Tbg9Ml0McmYy/rzbkFn03ANXGdsSKn//TW/jk/ndQRHHYFis84to+DUuR7lGO1ATXaIVMjcE7HgTI8ByjpuQQU/gCbNyUZUeabsxvx8DE/bP7Geo0sTrdq44A/Ifmzr2EuH5tpLNmliJp+yFMx+8XKIUz4yjUxjA71oiFYE/FpfoDzaO/k0lz6r/y/whtzSZSjjmZX/v3C6C3LRGxUK3CudbD/GhuF/Tq0wTHvwFLkkFPVAHgefVE0MqLKn2Ty6oWiwcQ0rdPoPZMPoE5PwLeu5bsoa4Onbrb2wfgGr+4luXkHVHqB+M42bsLYEoPpeu9rmAUHzliRatGXem82wpkv1iMvYbAkZwbrgkwwPq5CXqS0BlnU0DL4aCPgJUJaWjeQNopfmvIslhj8pKcMCZD44z5Y7qOGd/nrO7sezZvBkjP/Qv6AZ+R4cdjjvkLr74gU7c52xCwKEx7pEAFlmduaqKbHNkfxjnJPh/Q+Mz083e6U3zhK0/wr770CT74v78NHMrIE0xnl9D4n6UNTB9hIMCPT86fAKAnXCAYjOrmUf59QjRgZNriyTl59IqkTZ9xeQX1OTETHbkUDM6FLoUJJsbILzALgGjxLDVBUu5NE+kKoBU09fJLNCG6L+mkCxMl0EZk+OV3s6afW/TLHnxHTNwael4TRwECdCSjDkU80CvPBEPPMWceygOa7wSlYKIFGvsQc5/eM9GATA67mfH9r7gG5cSeHLL63EdkQeBe//HkX37XuJ9PeWKUaGFHmiufykgIUhIWTQUaJyTr2F+syYvaZVN2Y1Fj8mPw/lu/pjvQUvMWhQbD1qBU6RrBJykrq7JEmJk6/6PfdRyPNuSpNlD0Y6npWmY0AAnnHrS5BkFmHvJVBJCCdmNlxbUqtJS+kiqQfUE5invX/T0pnXeuAiT8vDNjGGxPmdYi1iZex9csT+fh9wXGNGNF2uKWYqyYGSwJn7T0CUTWaYwhPGVkxMhkjM03AxKJ68P0m1BGCIVBa87CACS41CMaT8sQXjvJ5dBpLUgopdlImZfh004TxFG9qqBBUQ6CJ//4BTz5xWNI+KacD07m7Yz8iXbZ3XkgoqEFnyEaBnpx6VdgcHPrHeXZYzG5MbGQMdspnVV9wkJKzzAypbF7vhW+UAQHmdEGb270MTHH8JyQV7XnZywiuf00PLg8phK+D2b4qAoDdC1A95xsRJmZCGeuiXHOxBRMRPNzbqPLQPgC5CnBgx/kjGqSntyTgocRAAuCuH1m9jNzHn0P3zOzxG+s6eMn1vYhNFzwDttqnSbSJ6I4r32T7ugd0K9XRxDNa0U0BUpoP12AYhMeBUFOwpZnHsnt4hr/RCrpA98pMuyFKlm5NS91dVQ2zXPvUrMjAIEms5+TxgOje5/MtFLhJaZkuJ41/ondDnRozEKOBAUThwiw7D205zuvRDvVD8QyoY2BmGgMrFFSoxMDZE382M8N9Ey2GLMnvkRxjBRwQp8xPndYQlprRgXmkNT+b9LEogR9WRNyxy40M77NwugcHaE/I94rtSu/B/XVplBlIoPw8bCAqLBIj8/TCdo7h3ioHl9sTlI/CitKh0NMAECd9mWax+ibBTMebhcuxDFJf2+JagnhYqYNfitmnmYZWZlrznBcyE4fClh0Rs/nE1FHPyqAULouCxAAJ/Zo1JpjCDnEa+N6hdn0rilUYemxfgYcQM8jYTTPHUcNhkq61cJWWR0H6B7tgLgOK3NbMGBM4Rl4ubVB3czZkNGMcuwMmnBznhda00G4C2AOPM33jChClgYX4q1ZwDgDRBnsk0aMFifRApTaGzsYI6eAd975uGNDTfH1aTt/X0yKwa+VjdKAKRJi79KlRBQdWY7ahUpoevZHuTJoiz9/RfpSItEtBNcL/RzULqvxo/EgGb7FV/G7O/1O4KcTehJXDagcxERMHkzImnq2xalp6UyUW2M9Lp457xPj598zoRoOBw0ahFJkZSN0f0ajKxFqH+iZ+VJAvMBFcU0SmXax+ScKOqpI1/guhHJ3X4QLw4G8c0KN2nMupApvOpky3EJw5CEU/pnnPc+sb5qZfbkDMfolRmb4Hbn5iUBan+9Ym1It1i+bh4AXH4907czrmnMPZ1JPRV42O8cii2Novz6qCEkDEH2FwAeQ5xH4wJeDWpXdoDFQaBeaDurIktSV6DXXPWwbEkQFA4vM7aJVdlkrDC2YggmJFxz932bfSicgJ0gVxbxDagizuX1s+eQdusdxztGCIOI5Uh2K17GvHDdGzZc8HxpfiBjoHebvmant2dq1UD0VIAAyjbWf7da1co7BvwvhaajCYtKZkVa7n8QOKwFEBW3R8QBIRYawmpsKCXHdBxH5GfFM1kbJ1C54QlCdrHmszSRIU8AuXXjGmsVz0oTyPpbNilcse82TZxaG5DTfubMQwdhGfHxuYQ7PcwyWo9HPchjvHTRwHFRS7H3Xe2T9vZyTDbbbMsKoQVON56z3G7Ruc0G1HB5oF2P87lTrhE6m7MSkMvwe9wPoUIptsMUcYEoFEdm2H51Lkv3ZRMpIb2ka0H/UD2+sEF44F90lTr9pBuu4NPhgXgQDT7A2dqOd2JjhN2jokDKhhyMgQhPxwNhMk9qhWFw70mHbDsBmk6FitJ5yzY8nizBY1AXgPP0BhQRhhjaMz/yufLINo6Toovb5LBMzZZJNNSWhK/opQWRG9cl2YbiPte5SgW18ZrDia892fiHklok/kUmnwOrC1LT5FNcHMCRAxZiO6rUNOi1JA9QrKqejtznc93dk06lXBvaFe0G7uHOPM65YYwIx0VSaiKDhbPsP8HYzKZ4nkZ6TmP78Ya87MHp546PfWzYjPmZ64QmOSSeiUunRhrxmMlVK7HZrXWvyPARBMcqAIBkuyo0PYSOal+Xo0JkO5LBrDe2IH95RtKOfyARsO5uTthsJzaCndAbJjT99jBlqpEIeo++hf56FRpSdBq07KwkWGOGvkH0v3hmHWuaJtuFLCcGhyLPkT9AFWNCa5i8T8wKkiASYNxMVR2hpv5NgZJ/AKMA0urP+wjwSoKkloEXCWgijfL7PRfT7YrZ/DZx7AxwGOqyZGJrj5WdNBCaaYJQjeinnWdP7PbM0PtdyLEP1la6Nh4WMVFQN7eWLOZ96q9RH6+/OlWrOeuypMm0udMwl+jXxrs1Pdi1wx5ZvXOhCwgmqGbGJus158PJlkIEhAbFTcNf+ZTB4oIyAyifoKGFpjFUH/0pcGzUASg1TxcbdTaNx3gMyx8SOyOGUBaLM+HpsWbE3kQPRnTkZe818676PRWLyAcQW5OpHZUd/bHalKdZ6P0wPWb/A6UYqLD27AfAS4oLYodezRnPTWryu0OcH2muh8YOI8sTUmbGDKFizvajF9WxCyOll7B2fGRigf/uY0l6eNOy58YR5wGZLmw4QSSjauvTvzqQ+BxHiiTGWpkM9vFmTcf9L1nH3joNppgy60mCn67p9ChhiQlFUiIWNidGWB460zvlkIUDCIHwMHerHjf1dytaf1Z1z2ncOos+TvfN46ixXrh1MsaaotwVLlgpT4KB5tPZsTpry8Jp+6Hn5eSY3kEIgHJvLQX3L8khwg4/Hnz/Y4QH3V0pRLnGj9ChHgaWYk5Mv/T007tfXq58vp9BbTYgdO+E45Mb27ae1QbMEIUhn/nPaNK+ncXFfnXDRCQb9/uGdFN2bHfa3d55lokPDxZbcM5qQx8/z5bt1jXjje4L9g0ZyBNLngzucTA8QIRFa0SJYwmj269OZRmuTcf5AHDEX9F/a6scoFNmLaaRwAjpcdwEXlXh4jtPHAaAcdIDsmcjlWjO1qyqKuDYOX4fY/bZ3QoZ8i9jpmf2lyaEZgQC0a35/TDwzfTFuHgV6yLVtSvkQvZZgFDpRcX+TG/QFyGpw3O+sGO25ZzQdtctqfKW/rOEaUvvH7wn1MUllaoM5EN8FMft9WStfxsnK57DQIKYPWD4865zp0JwPwrmmHb4x/0QfvH01HW/0ezpuiJHn32Pfete+466xRAysnQmqRz1+PrPO9qBL7kUvFFfmowkCLfG2iHmOgqlzTnPe+7j42cFs0mAVaTeSTujvkF78TSkEFgIjnq/OSApdC5ZDQ9uJ/Y2Tc6v9Fud8pYPWt+2WaoTF9IhFgTyyHKnhs6yXC/Z06sY70g7DNHO8U0YDrMnF5zx4JGlJkbsJ+Zi2HONITkO7OONLFSzPZCSkIFBi5BlOn4PmTNizjwDAoPlBk5djIcJMR6DSgmMah57/fhi/2+8NSK3A9xa3A8NBZjFsL24Zgs4dPXGqTGrkIKxgrBl2k/aKUlflYBpPSXpKMKBrNItva89hCJ+CT7qyQyqIk96Z5yeYPp1/lSrykFAIB5kJP00hyHNfjqcHXCSqkX6NIRtPad3U+l/EzJxNIZ7II4ugHBvq7TJIs1Hh+NxQdl36A+LgkWBY+FwlDZLgCOFAqHOIUrEGn5WDeF/gyJQLFGZ6obX4lHbZmnsct44FbQAiNXVCAfNecWBiXGbQifnCnzAzOttnTKiDEGn9+mEctEjdFu3CyxinS3y7sF8TBBGExMwUdq6G9hvy8O001tBMZWukBTXPue9HW4fnvsP1ciSNzyfX5pcUDxdLeCkAoJqOwCRiZvgH0Bhn35WjHbdlMe/ObAJnUthx0GVTs2UVmdMfn4szdNj267OK7fHiyEKz4q80hWzNk1+s32VfIapYnle0m4L1+Ya2FKsBSAqlHBXtpnTBJB0NdPTXzQMWBrp4aq0fspmOXnX5H+iJipQOTfqEhee/VEVDzzoUVbTY/5AoauSTh9plGV/Ra8IT47NjCOgvnkxCiwPgBMbOnmRGE6xxQxuz4yl+C2gdXnY+xinSJgc7FuhMG2GZLb6Lgdv7FXLK2TN6OK+tZtMCJEQoItAP2lSUdEyFPUve7qZAESz3DW1XIFuDaElEEe/ZEYG9f7uR1G7mXQ94akTW4an3QxpYmr1z5juQvc8O1Dgyeo5ymM0uaX/rAuyeVJuHDQbHfawmnI2Ryr4CRbA+qybcqqLUCix+nrz7PFQEsjW02wXL8w3bWzvX5oqChibFUAGAdlPQbsqAMqQqlgO9N7egA7rW8kl6LcBZOIYWT8UTCCreMRCYAFjpbIIZVRFSO8sfZ9plnXs+unBYxeRF2iQAIjR7oUj9PIHoM/MTYjjxuoeAcSnJZaROMvIUvYqNdDjGnml+JQCphQRxyCNrCKT9lwIizIHVE31oZ1poGp6fMD/qXcGybwZfo/vw4qsCWzXn3L6i3i7YfXLE8QurE5Vm2Gm7W3LcFh+WTkBwIhTJU2qaIMtppfZJZu9oaTR/7B+5cUVijjUddaFJ610xjb7ZZ3WmlmPr2lGRMXq9KRBHOcv9hrZbUI61Z8hFVt2zDfXRDrtf7VHf2qFsDeuv9ji+fQfZGpbjBl0K2s7mNUyuECCiHgpUdF9LOPBCg5NvJY7zGnIJYO+avob9eOxX6p4CcAhzOUSuvgniCvTTkkUGWcDjeKhdXuMz84T0CgXJ8FnxQqg/hr/6vcEoHPsW14Zc0y0dczIRrBJxty6FM9EnzIj0ynZmhnYNzqEbq5HXGTS827unDfXWEuI5K6w78YAlMtOaYn3WT5tZ9hWoCt0Vj927ZnUCXZ9v2B4tqYGKQ/+2CpZ9gxagrn2QWpBECSBz2sW1bxHNUtoWUdDU+EM8uo1Ipt7YYSCjbU/rBZubgOHLfcv3TWccRyeaQfj16R54vIMcqwm6t3Y9iWdXbG6WYgLv2QHtZjH7/tEO5dgwbw9OjVl6TT7zVbjHfbUwRqDWslW02wLZgHpjZkP4LQah31x47iSRmxZg99RyCuqtdFosjrYARGQiabQB4huTmLY+TdNHu7iND3QtyptehhdkRpjgEqekcvyzO4+cESn2KuxRnpEDjSsRCG28CK2ccCqQAmm6OK+diZvNlnTcCaD2PwDAdmec3m6iyIUm4wDOEPsOg9vONCHgGsfj0cu++Ts3tBujilYEuydHHL+wc0YXRy52Cg2a5vdt1yvjhkZugDnFilrJMfUdapXj2/ZOsYuMk1difSwH3lJZS5TxCl9HLG1TZyKPu++7B75s7rxzuK9LwfJ8s/cUQf3CDeTQzIQ6VvJfCHS3QI4V7fGNM6CafwRAvV3SfAgIDjcNFn/WdrcY6guB6kVHy7Fhu+tCVQuw3rsQl6AZm6Dwvdg72XwtB3vPELaxvnbWg9HP8ZG40LdjxuvNiAKZhtuCFDwPtYt79QcmpRdIRiRmzx1sdH/C+XCgVGIy1UF7Rz9hJ6VzL+x3NisC5lO8N/KvAeQJOGGf9Zxtev4Up+c4LtuDmbjhkDe89+Ek0qULi3rXw5zlYFpifXKELqUTpJrmNydpMApM47X+3HT2OQJSCWE7RjLCSWkCWVB36h54N72U1pDWkctlS+1ZbfXGmDkdZkVSyOTeCQr/jaFDpciLX+Djb7uC9cnBoP79Ee1mtWc7c4eW110xhEb5DsvTozH8zgSlrAany9ZQdwX1bkGEi8vemDpMpuoOwDADgnkjXwFl3BK93LeMYNSbglJNuKQzdunrllmG95pMXSrQBjPLCZkZnQXCmXbRTTpAh4IDE08mwAAFgyHiPacXDMJmLZIOvtTOvX8BOnz3z+wz0MUXDT02DyD8XWljoY33tyUYhgiAxpi2bUE6i3ijSNjY7M02O9oYqexbHhvVbhdzcGV4BGbz+hZU8zC37iB0zaZZdcirFDuRpTmwNxt7NIksnz+y08qxj3sw2dhvQ2uY80nHXaWgifcOiF483HZTsHu2de3tyT8RstOdheOWe9P85VChy2jkSm1WXnwRyLH5NfYe7WaBPhpZwUKogu1uwXpfcw0is64cms8dITiY5g4mT7S0jgqrb7jxMxAV6dcom/a6CNL9KKF4UkiGUJwTqYJW4lCUB9pncPy/vDY6hUYhYBecuWl+mTNExjv25lDcYL9vyJ1jw+8D7KcbJgHT4XtARL+skA1fdXDsJMR3+zrj5mH3qi1uW6bchoDNSxcyQIfTkG7Pm7ZXyLEhS4755o5lP25OyBr5KRSA5XnLiMQSBE4e+J6Y0xk21jLfMS9GmmwsyPs8mv8lNlTN69t2xbR06UIKDZBjg1TT9nKs9s6+RoE0ytZ8jM2iGlX9b0XPcBSUZ0eUY0uzsN4uqLdLf2cOhaK/xzCPS5+/QZBppxU2bdmnYaad5tg5QsAmLm/0CsdsCgTp8/pZ9p9cHOoHfGI7BcCw6SAJ6QGbJe6Pwg6DhqJnAeOEAwTzSYBwkgT3bZ/9uyDE8OC7zchaQeN5itEhRZIbbYSBg/kT78w0t0Uoy6E+h8Sc4MXNEakNqgWiBm9lU0MQTYZUYvVEFgD94MmqPcmp2aRwdKHvQ/AdfWzCxLhn5CbjPKh4dCAFZneERbWcWIPm4x/8101RWkO9W82ur+YbAOydZX8EdlafjvPs9WZFeX6ElmLo4dbhfeZc+Px5wo/uSt826849Pvwz7jV/UKN8DDJhAMoUtHmIPQLx3eCkI0Ec6C+zcH3egtm785FoZaLzub0eXn3Q37MXjp8TVpIGH/riRgw9xPNBn2OhUtvrqPW1L17cY1LYYT49C+Awneb1+btreJboxkR0ImsIGI5qeH+lGvOW2pJRMm88YtgbvWC8izN2xMLh9inWksKSoWX8e7Yb00lVxnDei4SygrR8hKhCgHbaN1mx+Atrf+/QaCWiM36N3iyJYKSav2PZV7Sd+ztKGdcHMGbPyEt3IKhEPn5D2c8vATMN1jXNKzDCI4Z0X1yO35yk0teZBbz0kmODz4WEZY57ZvrSrwnhy3H/B5Yj2+Wg/hlondr/DKMPaY4TMeZfYv7B7iHINcCvKe58wvQE04A+3iTcFtl3oaXQk1MkUMIojcweppWRvk003i/8BsOcAGM+doOfmKt9Fd3TbCG2Znauz6dEdp92LSquoWTzo6QWI8Sy9aSbGHMuh47zYd+dkbg+lw+FlwYn7bSmPT7tyIhQAYBuUy+CdmNON10K2lpMy0c/i9j7HqvB+2amjxw90Sf8IftjCqIwEcq+JgqK9SiHdkK36SQmDRxj1IKeMuzzkYVBQ6PXeEf0+4kWzh76EXPvyGsoA3fOZD7TLsv4nKQzaeyEMaGJWdPPjN8wCgxicobvbMdzIYf0WD/E9BRWY+iV34UwQAiSrq0DuvPCB0NEuSUAWU46Gb7q1Cc/V8325VTdpiiHanavZ6vB7VvTVnb9sjf7VlfxFNbTdWHCs85jDhn1UMRE+3plRh0CxUiOGykwXUC9QC1lSvDSmaqlHe92u8Pq0PBla2iPb1yYNZT7DeXZAXKwnUayNci+QpdlgMLq5oAcbW7azlHQsRoqCiEb4wLR52rRBN4FyXNp4b2ALn0ONbA2M3PwRJCmJ/HYj/25nPhV3E817sLEICjPtZfG+CLynoh8U0T+6Nzv9fnT1Fx2A5DOjCj6SMzP3vyBYOK+hOvaJzmZfGTSYCRRxc/++v2EZKkdWzjntE8oM2ENSY1B6kY2X2428c89r91i5JzyGfCubMA//O/3U6P38Jml5pZDG+x+i70DLexTskuh5qk2+GtLXPYb6t2acf3yfPN8dvFc9pYmgorgp//nL/NzOWqaI0Mjc6REiulEcCfn7MHCek4kw1pqCdvVThIyE0bwDx++3wl/FdS7ZXjvLDCCzpiI0FwpacuXXz2FHI5+n5kGcKcftuY79Dy92XMEItc/5v2nf/uXfr9/VTXNDROmJQVz/A1zK2gA6JGeEJaZRh3ry/MyIEybo5/99V/knA0haOapF7SXwvgi8h6AODgzTs4d2vb8SY/7VmSdfGZ4oEuukxRE0swcD5+jBKw1GfZbGAb4f3/zfnZZai9CEZo3wiXLvQ2kLZF5ppnkwt7qshmjqufJ56YRSiTKyim+oG0V1BvBP374l1mqKTbWJBRcDbbGMdER5gvBoktBu13R1pKZaLoWiCrqo50zd0XZb2YGrCX7bXeLMROFwP7+7/8qUdDsfxDtqc3Cwg0g77amn4DXNO6NfIMwTaLvCHX1zTuKn/79X9nPAvdvWL/1bkW7XdzzX+0d91vmM+giaHerh/Aq9NEtsC4o+yPa7Q7lk3uz87dqvo6qZg74/Krb8sHM5b7i7376I1tDVd9V2Z2eYWLV26XH4wlBREJZcdPKMjolkR87AoMeIzoUTui22nc//+v385ouVPqacDWhc+1lafyvA/jQP38I4KsvvJrg++CsA0PIDmG4/DEnjgxe00r3pU1K9m30B6+asnV4Hd5kwO2npmh+zvty0KHEcdk0w2hh68W19ZExVzlEX9qRgnS4XHzzB0BwOWxt3n9fFevzakkfm8Hd9dkRy9NjChGD/z2UVZ4fsfv5E9THN87oxVBAZJ253aqOItoqqHfuG/BdboFyGAXF+y4ZQejCMNcUyC3HcX1brdRV2u3qAoDu6RAfaLcd4sZzE9ofzRY35lpQ37LCgOGdB4Dll08hT+/RHt9YP7sFOBxRnjwHFtPGerdD+dUzlMPm72ICZLmP7Cxj+na7nDiRQ3im5z78LvAMSvWQqNNGKok4uw+RlKPdNJD+ffV9E5m5eNThQJMsVU77Wzjd+6Emes4x889sIvI9AN9T1Z+4tv+Wqn5nuuYe46HXPwPw89/4YD69fflCzz3XrmM5365jOW0PjePLAP6lf26q+sVzN7+scN7HAN550QWqeveSnn1t13Ztn9JeFtT/EYC3/fO7AH74kp5zbdd2bb9GeymMr6o/APCuw/y3w8l3bdd2ba9Heyk2/gsfaB7/jwG8q6p/+koffn4s31bVb114HG/DkNG7AL4++0MuMJ6Iwpz4Zi7RROS7lx6HiPwSwP8E8ENV/ZMLj+WrMFoJJfu52ytN4PksYb5X2X7dSXsJ7d8A+FqM56Hch1fRnKi+6mv0VRF591Jj8fF8E07kF25/qKrfujTTe/uPTivv/Lrr86pz9b8O4L/75wjzvfFmwIR8LuoTUdWfAPiJo5APVfXDT7nlpTUn6os9f2pvi8i7l5wPIJXCj3wsvzZiftUpu29P//4Xr/j5r3VzQv/oNfGJfA3ABxcew8UZjdo7AD7yUPUl2+/C+OYjEfmeC+jP3V4143+MTwnzveHtPVX99qUHAaQ59rthnr3qJiLffE0EIABDZar6MYCPLzUn1D7wsfwYwK9lFr5qxr+G+R5oIvJe2I9uZ19qHN8lH8PHuJyg/sj3erwHixBdck7+6JLPn9qP6PPbsDX63O2VMv7rFubzcXzt0hLcx/FdEfmxiPwYl0VF3wPwIa3RRSIvqvoTp493cGoivur2P4DBOX0xp7A/++1wjP+66/PKw3nXdm3Xdvl2uf3413Zt13axdmX8a7u2N7BdGf/aru0NbFfGv7ZrewPblfGvLZsnhPzG0oVF5I9F5Lu/qf6u7TfXrox/bdwyDVREdN5L4YLh+5+1M89LeF3i39dG7cr41/ZQ+wmAOYvwddgsc22/gXZl/DekeUbeN/3z9z9jjvdHcZ2bAKntReRdEfmho4APYpdYoILPgwyu7dW3yx6hdW2vrKnqd5whvwWrh/jxZ7jt+7Atw38K4FsA/p3/jfahqn476hqIyAcAfnzpOgvX9untqvHfrPY9AJ9584tf94efYXvsn8Fs+d+DFau4tte8XRn/zWrfBvCfP6fn/icAvgMTGg+1b8IEwwew7bzX9pq3K+O/Ic33kX/HN3n83ufYbfY9AO88sC/+a97vt73vP/G+rzb+a96um3SuLZuI/PCz1h90+P+dT6sf8Hn6vLZX164a/9qu7Q1sV8a/Nm4fflb7X1U//Aza/o9hPoJre83aFepf27W9ge2q8a/t2t7AdmX8a7u2N7BdGf/aru0NbFfGv7ZrewPblfGv7drewHZl/Gu7tjew/X9c1efzvsOEpAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "hist, xbins, ybins = np.histogram2d(\n", " SD.gas.coordinates[:, 0],\n", " SD.gas.coordinates[:, 1],\n", " bins=(\n", " np.linspace(0, boxsize[0], 200),\n", " np.linspace(0, boxsize[1], 200)\n", " )\n", ")\n", "fig = plt.figure(1)\n", "sp = fig.add_subplot(1, 1, 1)\n", "sp.imshow(\n", " np.log10(hist.T),\n", " origin='lower',\n", " extent=(0, boxsize[0], 0, boxsize[1])\n", ")\n", "sp.set_xlabel('x [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "sp.set_ylabel('y [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Selecting (sub)halos\n", "\n", "The default halo finder in SWIFT is *not* SUBFIND, but Velociraptor. There is a package providing some tools at: https://github.com/SWIFTSIM/velociraptor-python. This package is pretty rough around the edges and may change in the future." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "from velociraptor import load as load_catalogue\n", "from velociraptor.particles import load_groups\n", "from velociraptor.swift.swift import to_swiftsimio_dataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pick a halo at random (#3 - this is the position in the array, not a FOF ID). Load both a list of groups and their properties, and information about which particles belong to which group:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "target_halo_index = 3\n", "velociraptor_filebase = path.join(base_dir, 'halo_{:04d}'.format(snapnum))\n", "halo_catalogue = load_catalogue('{:s}.properties'.format(velociraptor_filebase))\n", "groups = load_groups('{:s}.catalog_groups'.format(velociraptor_filebase), catalogue=halo_catalogue)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Get a \"mask\" specifying where in the particle array the particles belongning to our chosen group are. Separate masks are generated for the gravitationally bound and unbound particles. The particles are intelligently indexed so that the boundaries of a region enclosing them can be read without actually reading the coordinate arrays." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "particles, unbound_particles = groups.extract_halo(halo_id=target_halo_index)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can use `to_swiftsimio_dataset` so that only a small region will be loaded - this is *much* faster than reading the entire snapshot and selecting a region of interest afterwards! Notice that the resulting object is a `SWIFTDataset`." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SWIFT dataset at /home/koman/106e3_104b2_norm_0p3_new_cooling_L006N188/colibre_0023.hdf5.\n" ] } ], "source": [ "SD, bound_mask = to_swiftsimio_dataset(particles, snapshot_filename, generate_extra_mask=True)\n", "print(SD)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can (lazily) load the gas coordinates for this `SWIFTDataset` and re-make a similar visualisation to before. This time only a subset of the box is read in. The selection of gravitationally bound particles has not yet been applied." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(1)\n", "hist, xbins, ybins = np.histogram2d(\n", " SD.gas.coordinates[:, 0],\n", " SD.gas.coordinates[:, 1],\n", " bins=(\n", " np.linspace(0, boxsize[0], 200),\n", " np.linspace(0, boxsize[1], 200)\n", " )\n", ")\n", "sp1 = fig.add_subplot(2, 2, 1)\n", "sp1.imshow(\n", " np.log10(hist.T),\n", " origin='lower',\n", " extent=(0, boxsize[0], 0, boxsize[1])\n", ")\n", "sp1.set_xlabel('x [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "sp1.set_ylabel('y [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "hist, xbins, ybins = np.histogram2d(\n", " SD.gas.coordinates[:, 1],\n", " SD.gas.coordinates[:, 2],\n", " bins=(\n", " np.linspace(0, boxsize[1], 200),\n", " np.linspace(0, boxsize[2], 200)\n", " )\n", ")\n", "sp2 = fig.add_subplot(2, 2, 2)\n", "sp2.imshow(\n", " np.log10(hist.T),\n", " origin='lower',\n", " extent=(0, boxsize[1], 0, boxsize[2])\n", ")\n", "sp1.set_xlabel('y [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "sp1.set_ylabel('z [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The mask allows us to select only the gravitationally bound particles." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "cosmo_array([[5.7584856 , 3.11983931, 3.77567353],\n", " [5.75910851, 3.12410757, 3.78021704],\n", " [5.76010915, 3.12063059, 3.78501992],\n", " ...,\n", " [5.90772246, 3.36409004, 3.9115557 ],\n", " [5.89042843, 3.380795 , 3.91772705],\n", " [5.90390773, 3.3848351 , 3.90824232]], 'Mpc')" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "SD.gas.coordinates[bound_mask.gas]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plot only the bound particles. Now this actually looks like a galaxy." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP0AAAEFCAYAAAAog+E8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAByRUlEQVR4nO39eZBc15Xei/723mfIOWseUBgIgAM4SRQHUUMPtkQAVTduxI0bIcrS6+6QotWm9DQ8idTcEimKklottd2yw+57LYbd4RvXHW2L/d6LuPGuARLstt12D2pJ1ESKM0iMBaDmysrhTHu/P3ZmVmYNQIFEEQDrfBEIVJ5z8uTJYZ2991rf+j5hjCFFihRbB/JyX0CKFCneWKRBnyLFFkMa9ClSbDGkQZ8ixRZDGvQpUmwxpEGfIsUWw6YFvRDinua/71zguO90/D0nhDgihPjCZl1XihRbHZsS9EKI24HbjTFPArcLIfasc9w9QOe+e40x+40x392M60qRIgU4m3FSY8xTwFNCiB7gqDHm6MpjmjeCldt7hBB71jo+RYoUlwabEvQduBN4eZ19e4wxTwohOrf1AbNCiO8bYz7auWNgYMBcc801m3OVbxCmpqYYHBy83JfxhmMrvu/L/Z5/8pOfTBtj1ryATQ36ZlDfK4R4nzHmL1rbhRD3NKf+K49/tLl/fuVz8vl817H33Xcf99133yZe/aXHnXfeyY9//OPLfRlvOLbi+74c7/nRRx/l0UcfbT2srnfcpgR9Mzn3cjOI57EjeCdmm+v5HmBPMwdwJ/Dj5tJgFQYHB7fcDydFiotB50AohJhe77jNyt5/HzjaCuyOEfwI2DV/c6TvwwY+wA+ax7yvecxfrDxpihQpXj82K5F3lOUk3ZMd2/evOO5R4NGOTU81/70pA/5qW45cKmzF930lv2dxtbTW3nnnnSad3qdIsTEIIX5ijLlzrX0pIy9Fii2GNOhTpNhiSIM+RYothjToU6TYYkiDPkWKLYY06FOk2GJIgz5Fii2GNOhTpNhiSIM+RYothjToU6TYYkiDPkWKLYY06FOk2GJIgz5Fii2GNOhTpNhiSIM+RYothjToU6TYYkiDPkWKLYY06FOk2GJIgz5Fii2GNOhTpNhiSIM+RYothjToU6TYYrjSrKrf13zOlSsaniLFVY4rxqq6w9nmyY59KVKkuMTYlKBv2lZ99yKtqu/qeHwUuH0zri1Fiq2OzV7TX8iqujPoe1bs7+98MDU1xZ133tn+1+HOmSJFCqxrbSs+gIH1jruSrKrnWe1u20bqWpsixfmxUdfaK8mq+kcsj/Z7gCObcW0pUmx1XDFW1c2ZwJ6O56ycCaRIkeISIHWtTZHiTYjUtTZFihRtpEGfIsUWQxr0KVJsMaRBnyLFFkMa9ClSbDGkQZ8ixRZDGvQpUmwxpEG/Sdgv773cl5AixZpIg36TcEQ/drkvIUWKNZEGfYoUWwxp0KdIscWQBn2KFFsMadCnSLHFkAb9FYY0659is5EG/RWGS5H1T28cKc6HNOivYEzs/Az7nQ9c9PNey40jvVFsHWyqRl6K14dDx//FG/Zaqqf8hr1WisuLdKS/AjDe85HXfY4D/m9xMPc7r/nch2f/7eu+hhRXB9Kg3wTsV+/f2HHyXjutdi/BhMtodKPRtWl88KMcnv93533apbjhpLi6kAb9a8B+9X4O+L/VtW189BPtv48kP1g+thnYB7K/veo8R/RjHNGPkczMvvZraa7Fnwj/fNVafr3zdq7fL3RTSPHmQyqM+RoxPvxxDp/93y543AHvgzwR/jlgg83ZsZ34xMmuAG0Fobp+L/qVEzwR/NnmXHQH9jsfAJ2kPQJvUpxPGDNN5L1GbCTg98t7cbaPtR+vDPT2YyHAGA4/94eX/DrXw5H4P75hr5XiykI6vd9kxCdPrbuvNcIfSX7wmkfc8eGPv6bnrXc97TxDijctLptV9Vr7hRBzQogjQogvbNZ1vZFordnX27cexm/96rr1+ZUBuZEZx1rPW++aznfNKd4cuCxW1efZf68xZr8x5rubcV1XC5JnngedrLlPuN5rOqfM51/PJaV4E+GyWFWfZ3/Pel72bwZM7Lq/6/HKEXVix6fb253REQ54H1x1DjU28ppeW/b1vqbnpXjzYbMTeeezql5rfx/W3PL7xpiPdh7YsqpuodOh80rGxNinSKameSL8cw4d+966x43f+GX0uWWj0fjsVNdoPzH2KQ6d+lccOvrP29sOZH8bEwQ4u3dhHMXh57/TdbxeqqIrFVR/H4envv+63kerRGmiEGd0hEOn/tXrOt962K/e31XyTLFxPProo50W7utaVW96yU4I8X3gSKdV9YX2N9f5P+rcdqWV7M6Hg7nfQWwfRWhDcmoSEwQXtU7eL+/F2b2LQy//s+Vzln+Xxxf+tOu48b7fA9Zm0x3I/jYmil9zlr6z1NjiIBye/JP2uZ+o/4cNvQ/heiDFho5PcenwhpfsLmRVvdZ+IcR9wI+NMU9txjW9ERgf+hgik+Hx2v8JwMS1n7/ogAc7vZ/Y+7mubY8v/Cn75b3IjvPrah2kWPMcqq933dF4v/MBVKmAKBTW5ffLPbvaf7eCvYWNBvBa7/tg7ndAKR6v/PsNnSPFpcdlsapeZ/8Pmse8D9rW1VcN9jsfQGSzmMVKe5uZXs2Im9h1P+P7vrQm/bVzm5mZ62L5gW2KaQU8wBPBn7UDsDXqg73ZIJe/2pXsQdG8UXQG/MHc73DgjoeXj6l1U3rXwvi+L7Ff3tuVqxjv+ch5KwWP1/7PNOAvMzZlpG8m5lrJuSc7tu9fb78xZh54qvnvqgp4AIzG1GrdtFbXQebzlgPfXFMb3wUh1qS/JouLbUJPUqlwpOOYib2fQ5RL67585xT/0Et/1LVvJcNPZLOrlgQim0WEMeP993F45tF1ZwD75b3tHMFaZCKTrF112Aj2Ox9ISUNvAFJyzuvEfucDjA9/nCPJD1Yny4YHENuGMWNDTFz7ecu/99yuUfRg+XftyEzHdNhRyGy261SHXv5nECccLHyove1A9rdtH8AavP610KoGrMwNHCx8CDyXw7/8Jodn2omgVSP2weKHEb6/Jqd/fPQTTOy6H1HII3x/TdLQfvV+JnY/sO71rQz4/c4HOFj88PrvZ4PvO0U3Uu79JcbEjk+TDPUitObxnz4CWLKNefkYsrfHHuR76DPnMDfu5YmfPLzqHOM3/z6iERIfO4n03PaU/oD3QdRAP4dO/2v7WmOfQi9W1pwuT+z5bDvTP37rV8EYmJprk3kmdt1/3mrCSuxX70fddD1isUoyeaad5Ot6zbFPEU+eWV2K3PZJ4rPn7DVIhZBizeev+bqddOUUG0bKvX+DMDH2KeIzZ2HyLObOm9rbRbVO/LYb0D98ekPTV7FUx5TyCClI3nZDe7uJY/s6ux8gOXMOE4ao/uUc6fjgR0lmZjmiH+PQ0X9uWX1GA6wugxnDxLWfJ+kv8sQPHwLs2l/u2Yl+9URXsm6/vBek4vAvv2lff+dnmNj5GeKTp1A339DevlbAA/YzYXkmM7HzMxf8DFpIA/7SIw36S4j47BTO2Dbi02eQQcx73vtt/FdniLb1oqoh3Hr9Bc/RWtOLpdqq0bAzAA6WfxdZKmGqVcaHPsbhc/+Gw1PfZ7x/mbug9u1F1BqYperqaz15qn2+A3c/whM/fIgngj9jYtf9qKHB7pmAEDhjo13PbSH51Qvsf9c34O9/sfb7aWoLdF77G6kIlGI10qDfADYyxTzg/xbm7luIAHYOEGYcopLi7L1jqAaoRo7S8ZiJXfejews8/rNvAHDPu7/Jk3/zVQDe855v81cbHNkeX/hTu4bO+OiONbbIZTnw9q+jzs6TnDi57vPNO9+6/PePftn+O+54Tut9H0l+wMSu+9kv78W8862467QHOzu2r/6sjOnqNExx+ZEG/SWCSRLc07MgJdV9Q4RlxcytgmgswJn0KL4CjV6Fd+IknFh+nnt6OWD9V6Yu7jUXFkkWF1ED/cvbanXU1AKmYkuHanAQ+lbr3zlHJ9t/d/L5nd27iIfLqMUG+oVl9nR84iTOju3QvF5nx/ZV54zXuslIdVHvKcXmIw36DeCIfqw9hV73mPg/tqey2cmz8J5bKb3sEJ/yUaFBRlB+rkIrbdpKtB165Y8t6eaWfegTp1edd+Laz6NzGR7/hZ0ZHMz9znKtXinUQL+tDmz7JPGZs6jeXszcAqJcwikW7YjckbwzjQBTq7WTfwcLH0LuWh6Jk4ESarpCPFxG6OUkr7Nje1fib2UfQWs0j7d18bDWzWFMbPtkOyG5EYz3fCRV+blESIN+gzhfwLfQSpYd8D6I0ND/yyWMAPXcsfYPtlUG04Vc13PN80dBJ0zsfgCT8Tn87LftjjDi8Wbd/WDud5CjwzYbf/ocyfz88mve/Qgq0dBM9pmlKqJUwBnb1n6N+NQkGI0sFNrbHl/6Pzhw9yPtx62k3sHc76CNZmL3A8THTiCc7p9KMtJrlyrlArJSJTlzFjU6wpG/f+iCnxOwbsB3cho68XoCPq3/dyMN+k2AiWOyP3wJE4YIYzi89H+096nhIcBm9Pe/4xGcs/PLCbW7HkY/8/IyjXfbJ9HzC+3ntrYfLH4Ykc0gHLe9Tx4/i55faBNx9jsfwCkX0f0lxm/4on3twX5Exsfks4zf+OX2jUUuNdj/rm+gXp5sl/TMjXtxJm0DkLxlHwDjt3wF/fIx1NAgcmERs30EXjkBfb3tykIL47d8BSNle4ayYYi1acWvB2nAdyMN+s2Cksi+3q517sSu+zGVJbj+Gg4/9fX2tvZTTk1zqINma0oFHm+OiJ2afLK3B5PLIPt7mdj7Ocz8IsnCIjKbWT5XqYBxHeTcEnp+oU3Imdh1PzrvoyZnmRj7FKaYbzPrJsY+tfz8c3Mk2wdRZ+cRU7Po7YM8/qPmEqPwIXSthsjvwlSryL5e1PV7IQjtcqG/j8MXwQHohAnC1/S8FBtHGvSbgPUy/WuRYczC4vKDFaNcF821o7FG95faxB+w+QGnkAdjGN/3JUQ9QOTzmOb5hL+cqDONAO1IZD6LWKqB1sv7eksc8D6IvG43wnMRUYLJeCQnTyF2DC1f5o5tOItLJMbgjI5gsv6G9P32q/dbCm9zqbRf3ovM57vIRSvZgheLg8UPX5Dbv9UJPykj7zLi4NsegqMnz/tDP3DHw8gggiju6pdfCxO77seU8qA1otEcMY3B5LPEpQzOfA3OzZBctx0jBU/+j6+2XyMpech6DP/wS4TrYe7Yh3NmnqS32GYNTux+gEOv/DFg+/+N7yCCGOM77RJkJ8Z7PoIoFc9blz9Y/DByaABTWVo3b7IWe3B89BNQKiBqDQ6d+Jfrnr9zPb+RG8KbBSkj7w3E+I1fJnn+pTVHkolrP0989NX2uv7xZsvqxLWfx2Q8Dj/9re5z3fBFpOus2t7CgTseRs1V2nRb0wgglwFHYTIeolIDY9CeY2cK2oAQyEZMXPTb5xFJghECNV/DZDKIYpEEMFm/qzsjHu5Zfk4UI6LmOl5JDtz9CCKI4JVTJG/ZizNXg2wGvbDIwbc9hDgzs6pFF0AO9kMjaAd8p27AAe+D9rPqmI20cHjyTxgf/QSH1jhnJzrX81sl4C+ENOgvMdpZ9ybapbQbrm072egVDSvGUYh6sPyc3Q+gi3k4cXqVaw3A/nc8gnz2VeT2EeKRHsvVDyJEPotJEnQpi4gS0FmQAlkL7GwhSaCnhAgilKs4cNfDyKWAeKSIUwlgZg6xYxu6J49Rkrg3h3tmwTbJCIGcmWP/u76BbMRQyMDLJ2DvDuRSg3i4gFcLMbvHUJUGolonmZ1HXr8bMb1AsnOYg297CLlg2YFtBSAhMNVa+70Jx2kH/hPhn3cxDFd91isCfqtP2zeKNOg3EeO3fIXDzUTcfvV+23ACqJHh9jZn+xjJqUnUjddywP8tngj+jEOv/DEHb/8acnQYc/pMO1hagaJ9B+W5JM+9BIDYPkYy3IOshXD6LCrRJP1F8B2Mq2xvvTHEQwWEMailEDm3hMln0DkfERuSrEvj7r1kphrI+SrJcAn37CLxUAnn7AK6nCfe1Y9aDNEZBxEkxG+/AXeuQTRcxn9lGqTEFJrJRCFQYyNoR2JmZjGTZ5H79gJgcssJx5Y60MTOz6CnZ9BBgBpYVnoShY0JerbUgw8WPsTjHdWSFKuRrulfJzY6ukzsun8VY20jzzt424OY51/BhKFdn7/rrThzta72XD09ixzoIxrrQy0FoMFkHGSlgS5m0L6Dc24Rk/UwnkOSd5H1GBFpkoJHnHfIHp3FHD+FuXEvjZEcuRenWbplkPwrFZKch84o/FemWbplhMIvJ1m6dZTMdIMk6yAbCaoatNf1B2970F6YEATDeZxK1LV/Ytf9tmEoCtufQasioAb6ob8XZuYg0YhCvs08bB9b/DCyr3fVOv+A/1uokaE1E6ZbrVafruk3CRNjn9pQ4HbeGFrknLVorO3jO36g+ukXcYYHCfeO4J5dRP/oWfRbr4e8j5ECEWmia4fwZupWk6/gI8OEJ/7ha4DNMSCy1K7tJztZRc5XEaHfDsADdz9CklWgNcnbbkA+9RxeZh/xcBkZGTAGd3KOYPcA0bZe3GqMLucp/Pw08YmT+Lt2oMv59rQdsH9rQ7B3CO+vfoaJYzpX5YeOfY8Db/86Mu6oHNywG/XyCZLpGZieQfX3YeJ4VelvYudn1l2bPxH8GRPbPrnmPmfba1MRfjMiDfrXgXjyzEU/pxXsa/LUW8d0/EDlLdfBol3z6kIWtX0UphZIBkoYpTBKImONiBKcuQq6nMd4y1+r8R3kfJXcUgO0IR4sYZyO7JzWiNgQ7ugFA9yxjyRjn595/Kckb7+ZcCBPWHYoPWV7A5beMorbn0Nu76dWtuXAXEfQ29KjIfEl/o4x4lePk/yjt3W9RxFreOHV5fd58hxmz3ZUPcScnGQ9dK7/10KrjXcVNoH0c7UiVc55Hdho0qjzuPjkKeKTp7o6zzrdbPbLe4lPneYfjX+Hg4UP2YQcoIIEYWzQxqO9oEHVQpznjuMdn0XnPII9gyR5H+0uN7mEg3l0OYfOeMR9q9fHshGTeXUGpxKS+BLt2+dqT5K8+1aMK3H/5mkQEOweJB7txZ8JcGfrqFpIZnLJvq/RXu75tW8ysfdz1K8fYuHtY2T+29MQxQT/0514J+e7tPoeb5KTxkc/0VbAkXMVzMlJdNXeQGTP6kahTmWfFrocg8/DkVjZL7BVka7pLwE2uq4/cNfDqDNzAMSTZ+HOm1Zx1VuGFybro4s5jK/QjsR95pitr7vKlt6wAQuQlDy0khhH4E3VQYL2HGQjRmccZJQgGjFxb3Y5mViP0J5DVHJxaglIEJFGhglx0cP76cs07ryW7NEZCCNqt2wj89fPUP/HN+PNhriTc8z82jb6/8dpkt4i/OolauNvJTtZR0QalEBWA0StQdJXIurN4FZC1EylreE3sfsB9NkpdKOBc81Okv4i8tgZhO9jWlULIVbV78eHPw69pTfU8PNqw/nW9GnQX6E48Pavt0fsVr/9+PVf4PAL1vHrwN2PIMKYJO+hahGiFoAQiChui2+SaJLenGXmCQj6fVQ9QcYGGSaIWJPkXfxnTxFeO2oDNUgwSqKWAsIB2xQkEmOn40qAtlNzZ7FBMFIg88JZqm8ZRdU1/pkKhBHBzj5kZNfr2pP4P3mJ+MZr0L7CPz5L0l8kLrh4vzwGvWXM6bPIYoFkdABZqSGCCLOweN4mm/H++xC+19W4M973e23Bz04i0aXA1VYOPF/Qp9P7KwBriUU+8Q9f48m/+WpXskv3LnfHoTVGSls/n6sg4oSknEWXcuicR1LwQUnUbBVVCXDmauRfmsOpxoikOVOoRWDA9PcgDBgpSDIOcVZhpMQ7W8UoQZxXaE/hHZ0izimMJwkH7VLBFLKouiYqKfuaroOzZCsNSVah6jH4vl2KVCNMxkNWA2SoIYxASqsdqBRyqQ6uYysVHX0EE3s/x8TOzzA+uGx6dHjmUXCcrqVR0kFpPvTKHzN+/aXzQT2iH3vTuPmmQb/J6GxiATtidGrUA+cfkWLNPe/+Jgff9hBGCe55t103y3qE0Bq0QZfzJOU82neIejI88aOHOfL3DxEOF9DFjJ3uZ2zCrb0kyDgkJcvKa4wV0Z4EA6oRoxp2ui+XajiVCBEbEDYfIWND4itkpBGJIRgtISONqmuQgmC0hPYU7lzdBrYB+sqEAzmMwC5PEo17fNqSlWYXMEtLmFwGkTRvcGGE6Ah6wggAvVTtyguYUh41uCwgslIHsDUrmth1/0Xp8q3lSQBvHr2+TcveN40sAPYbY764kf1No4t5YE/LIONqQ0uyuVVW6nSZGR/6GACiWLzgecZv/n2SchapNcIYm5HXBpQgGunBPTHN4San/eDbHkIYW15TjWXd+cSTmHLGTrUlRH0ZZKgxjiDJSMDBnWsQl320J5GRxjm7QLizD+05iJ4CCCzRphahrtuDqceEPR6yEaFdn6ioyJ0KbMBqQ5K1uQVVdxDGoDOKpJwlyUicajODLoXNLQiB8D1MHCMaoV2WJLqdrBu//gu2h8BR7RtjpyT24ae/tcoJCLqVgFto8f87dfs7zycyPqYR8Hjl369aVrzZOPubZWvVsqL+rhDii0KIPZ3OtWvtB24HMMY8KYS4TwhxT9PK+qrC+X4cGxHiGL/+C+0RUOQ8jJQYKTjyt5bwcvC2B0nyfjshB7YublwHij6qEjB+61eJerN4sSbOucQ5hQo0cU4hMhIZaFTD3kyE1rizNYKRglXKiWLCoou3EKE9WxI0EoQx1Hf3kj2xSNjjEZUzGAkqsOt9mRiSkkf2VJVgKEd9NI9TS+zNpJHgLsXIpRDjK0SIZRCenLL/1/OYmXnbN9DBs2+N1OP7vtTeJnLd4iOdfn8t6KmZ7mNW1Po7dftlXy+mEbTbltfCmyngYfMcbp4CnjqfVfXK/UKIjwL/qXnIUexN4KoK+teS7Dl424NE/Tn+6i+/DIDJZ4h7MjjHTiHrPSQFH+0tl+BkpY5caqB7S4zv+5Jl2Q2WrULPUkg0kCPxFSI2aF+hHTu6xlmFjAxCG4QBb7rK0t4yYcnBXUrQSuDP1Ql3D+HPBnaq/9wx1PAAMsjTGMqSf24KZuZxB/PUhjzyJxvERZfKtUWyZywTkJdPYEb2oRoJbiWkMZTBWWzQGCviJglJxjIEZT3GjPSjZpfQ+SyMDmCUQM2tVu7FGPa/4xHUUtAlKtLCeN/vIcql9mxAltafSR3Rj3Gw8KH2+ny976vTwPPNhivJqrpnxb7+zgdXg1X1a1nzrWpJNQYZJMihAdv3HsRo3+HAXQ8jogShpG2IkQJT9HHma4QDOWSsccKAOKMwSuBE2ibkhMCtxhghljXvBBjPITMdopZCkpJH4ssulp741VGCu/fxX560o+yv/a9/RLi9l/DmQXLHq8h+myNwqjFONSbscdGOIHnnDWRfnsFkPeo7iuSfnWLppiGyp6pEAwWchTo646KzjqUMAzrnol45g1QSU6uv+oxEGOGcW8Dks8hdY6sDctsw1ANLwx3oIz5z9rxBbW7czZEfPbzm99HS878a1+8btapeN+iFEH+IHW0NdmXXWdvrfPyUMebLa52jOVW/VwjxvrUMKTv3s4a7bScGBwe5nCW7tUbxlmf8RnAxjjKyZnvhje+iHYlTCYjLPu7kIuH2XkSscZ9+BX3dTqKBAjLWGCmIejNoT+JUE2QjQfgKJ4iRQUJccDEIEl/aET9qfvVKEGe7fwZBfwZ59z60u8xiSzyBO1fHnYOlvSWcmkZVA2o7S2hPUO+TuDVDZczBHR2m7xeLONUEXcrhzwQIbct8vPAqatd2oqEi4vgkZDI4kwmHmtPre979zVWfhynk0FkXEcaYcg5x83Vdcl/Jr14AOsw0mo46nZqFrZvExK77eeI838PVGvDQPRAKIabXO+58I/2MMebAhV5ICPH5NbZdtFU18COWR/s9wBGuIKz1Q3g9Ad9qwDHvfGu7Dt9uVAF0KQc/fRb51htIsi7OQkB9Tx/ZY/M2AdbXC7FGLYXgSJKcnTLLILGZ+ayDUXZa70Y2yWYciVuJUbWIxlAWoQ3uuQqiL4OzFPOb/5NdQ4tYE/Y4lH5ymok9n6WxZxDPkyQ5D1UNKLy8SGPUlg9zxxdZurZMlBcknkD74MwYlvYUKL5cIerJEPS65F+Nics+yT+6FRlq/BNzMDaCVgJeWTbPkI24XZoThbxV9u0tQ7bcnomM3/z7XS3MR/RjXb52h07/aw7e/rX2YxPH7Y7Glej0HdgqWLdkZ4xpW58KIf5T577Ox53HdeCiraqbM4E9HduuqvX8xWIt7r3+5fPI2WWra3HTtfCLF63ijdZ48wE0hSvCbT3onIvOOLZZxld2vR5rS6HN2q/WSEFccFEdZJm46NmKgBREgwWMABlr/P/yCzKTS/hTNbJnAyq3jTL3jm2oekxmcglVC20SEYhz9vxL11qqbPnVGLdq2P7/PUnuXIhb1SxeV8RZCMieaaDml4iziuzLM7iVkHigSFzKIF49bYU0OhDdsovopl1WtCObgSBEneoYuM51J+oAGu95S9dj8/QLyw+EsM5DJ06u+tzF3/286/H5GqHeLNjomn5lt8J5uxdei1V1c/t3V267mjCx49NrSjetNa2Xt+xDLiy1zSMAuPtWgoyD8zdPI6/fbRNb24YxUqJzHkYIgl19+KcXLVnmXJVwKE/Y6yE01Lbn0EqgAoM3HyIMNAY8tBCYQGAEJDmJqtvlgFNLiPMOwkBtNIscfCtONSHJSLyFCKEhey4iyTqEfR75Z86S5D2i3iz5/+snyLFRZFSi8PRZZt49SmY+AWOI8g7//f+yE8D97/oGOqPQpRzefIjJ+ajpRRgooR0JQ/0c6sjSqyBEmCJyat5Scft7SYqZ7g+vdzUn33/8qa7HJo6XlXeMITlzdtVsreVT0AndW2ibdbY8+rq+452fueptuTYa9LNCiN8DfgzcBaz2Kt6CGB/9BMnZcyAVR+L/eEGtNmd0mPjUaZwd2zGTZ2B0hPjEaQ7e9iByqYE4NYl4x03w1us53GyNfe9vfAtnKUQ+8wpi+whhbw/1nWW8uQDRCMi82iDpKyAaMaIREA+VCMsexpE4szXySwFxT4bElSBANQxOIyGSAu0IVKgRkUYFCe5UlereHgCcswskmT60a4/JvTDD4ttG8ecjgh4X5603oIMEp5bQ2DNA7kyEaiRW8acDUcHFOBKZ98BAkvPAGEQY47x4GtFhyS2qdUw+a2W3pMSEEWJmDvKjGF9ZXT7XwZS7y3YA6GV+wvi+Ly2v73fdjzMy3NV9t9/5AOhkzSVbO5npfXDNm/jVHvCwwaA3xnxMCPFPgY9i1+If29zLujogpJ3irhRnmNj9AMZzEXHSriMfif8jB/zf6vqhjd/6VcyOW+BnL0J/HyYIcE/Nd51L+4pY+cgbr0EGMU49sdP4SBMPl0kyCiNAu1mEKZL4AqeaoGqR7bBzJSqwASESg1NLcBbqqCVFbUfe1tFDjdNIqO7pwa3EREXHJgy1wZ8NCXt9RBhRfGEenXFQ1Qi5UEMkGtXItCsMcd5B+3m8hYjxfV8i6cmhPIU7s0g0UEAkGmd6yX42jQb6up3I+Y4SnediMi5Iic77iL4ihDGyEUIlRsQJKAnJ6lVp53q9U3osGSijpuZBCMZv+KIl+3TcIGDtJO2btVwHGwx6IcQ1wN7mP4QQJWPM4nmftAWwMpE33vMRksVFZC63pmSTibo13VvTx/HhjxPt6McpZDHHTyP7eq35RCXAB4LhAvhW3NJZitCOROfcJldeIhJQocYIcGLsiOspooJCaMBIhAF/NiAqecTlLCLWFJ6fo7bb8u7jjMI44CxZgw4RauKiS1j2iLOS2o0juJUIGSbIRkS4vRcZWXafxkHWIpQUOHN1GmMFGCriTi1h+vLojC0JZiZrxP0FnNkqyYCtpZsOeW5dtKO+iKxQp5HSlolchcnbZUFLJPTgbQ/CS8cRvg8jA1BanmEkI73Wdnv3DuTMHLpqBUKZmoFiETXQ30WUOqIfsx4AUbQhAtXVjo1O748AXwS+DewHHgMObtZFXa1YqytsYs9nMQsVGOhF9fZad9exbZgwarPARMYnyTokmRKZIELnMhgh2jeF97z32wht0K5CSI2MNNpTiESTPVHBKEXUl0G7lkortCXmCA2qnuDNB82OPN/2zLsStxLZZp3YoF2BSCBzNiAuesggQfsKVYtpDPm4SwlxTuIuGqKih8i7REUHGRlkqEkKkmzFtsImRR+nGhOVXZyKa/MSs4v4WsOZKfTQNcQDBZ78718B4J5f+6ZV9T0zg9k+iPYUznwdGcYYJSBOMDmPqORD0kG60aBrNaTWyEZoGYlNtKy5xoc/Dtog+/uQjiI+fhKnWOxaUrQQT56x4qVbABsN+r80xvx/mn//hRDivZt1QVcLOts4z4dkoIRKNIeamvUHy7+LCZYln8dv/DKmv4R/coFosGBHuxXtzrI5PdeuQigBBtv3XnCRoYP2FElGohq2wSXJOna9Xk9QgUbEGtGIiIfyyNjgVCIQ0NheAiDOSNyqRkaJDTQDjX4Xfy4m8QR+qJFNZp/2ZLt+L0ONkZbjrzMuItGEPR7egp3RaN9B+8oGZGLQi0uISBOWl+24kozT7A2Qyz56tz2IUQqhtTXuyPltktDEtZ+3aj+5DGp4CJHLYpREVKqM3/pVxMx8u912LWrtSiGNTrVdUa2fl1W5Ecbl1dCCu9Gg3yOE+N+bfwvgztZjY8z/c1Ou7ApHK+BXCi6udLdtadW1IDIZzGhHiWp2gejmHXivnsKVwpbkpISCb9f8x0+jdo1hXNU2p3jPe7+NiQSJJ2nsypN4Aq+iUfUY7SvCooNqaNylCO0qwr4sKu+hXYnTSHAWG8TlDIknmzkCMAIag1myp5eIezLEWUGcdTHCJvwSX9oqQYJtx1Wg6jFx3kHGhrjgoYIEp9GcJTQ0Moih4FG/dgARazJny8SOzSEcfNtDyEodZ6Bop/OdXnhCtM03RBR16e+ZShXhuei8D7khe0MLYwhsJx5Kndfh9tCx73W1Mpt6Hd1obChQW+215zv2Sg942KCIhhBi93r7jDGvXNIrWgdXkohGS6p6JcZHP4GpLCH7+9Czc+dt1JjY+zmoNyyX/PprbF/5XMW60ZSzNkk2u2RvAE1xjJbizD8a/w6JJ/HmQ7t2Lymcmka7y4w7fzpAhnG7MUbopgSWL3AriRXRMCAS25RjpbIEMjKEBYV2Ic4KZAjlow1qIx5Ow07nhaH9+sJAVHSRoSbodfDnYtyFBjrjIkObWwjLLhjInKtRH83jVSLcMxWYnkWUikSjPbY9d8pKbRsprcx2olELdZhfhCRBZGzpTvcViXuzuNO19hLonl/7Js65xXaTTgvrdciN7/tSW3mny/57xfdzMXbaVxJS5Zw3CPudD6Bu2IOoB12tnfvf8QgyiLv851oYv8WubXXOs/XrOCHe1od8+mXE9lFqe/tsEm66jogSdNYl7PHx5m1STru23p74Cn+mgREQFz07OmclMjS4i1G7acdISLIKkRhUQ5M5OoXxPerX9BD0OOTOhtRGPBLP1vtVZFB1jVNPkJFu99KrWkgwmENGGm+6RtSXbSv0tAjacc6+TpyTOHWNNx8S5xxkYm8e2pMkniR7smLlvU5PYQYteVOcnCRZXMIZGyUZKlsdgLPToBR6xxCyGmBOnlk25tz2SZLpmXbW/T3v/Tb+qzMY19mQrNb4LV8hee7lN41M9muWwF7BxGt9nQIwxph/cuku8c2B1g9m5brxyN8/xP53rW3ZnDz7YvtvffMN6F+9iCoXSG7Zi/jp83gDBdTPXyJ5y7U2g9/smdeObbmN8oqgpOwUu9l2qh07Ygtj2v3w2rVJO3+qhs66BP2+DeKBkk3exQYn0NSGPTKzMfUBh8RrruMdRXaySmMkjww1lV0+KvTJTEdERYWqW+JQa70vYoMKdLu1NjfZIOjzkUGMGzd1+Mo+cU6Bhqg3i6pGJLuGEYm2cl3bhnGKRaLt/TiLDau1t2sEkRjCvgz/tSXxfctXrH1XLrvMr9/zWdxyHpPx0C8ds6Yj61iDtXCh/W8mXEg5Zx7oxWbvfw+4D/inzf9TrIMWA69LXunvf7HmsUeSH3Ak+YGViFYCect11k32R0+jhgZwT8wQvmMfQb9PnFUkGcdSa/MOSUbgVhMKpwMyszHuYowKNP58jD8f4U+H+DMBUcEhztsSXlLwEUGCdgQi0SztytuuviBBhrb1dn6PiwoNUR7CgqA2KKmP5tsJvMxMQpQV1EZcGj2KoN9SczOTS8RZSZyTqEaM9iTuYoiqhhgFUU8G+fTL6IyDVhIRGzLTDbzT87bP3kBc9KmPZtE5Dz2/gPi7nyPqAdFIDwBxwcOb7bD6MgZTq5H0Lpfs9LlpdNbFKIUaG2kHdOda/p53f/NNI391sTjvSG+M+ShAk5jzb7FtsN83xry6+Zf2JkCH1rqza8d5D3VnasiFKvHxk8S/dhtmzyAmSJA/eQ598yiqYTPr3nyDJOsCEqcaEgx4JK4kKjoUn5vFeA7hQM5q2ffaGrtbTVANTVhSVHZm8BddMlMBxpU4NY1xJfVBD3dJ4y5pVGRo9ChkBElG4C0agh6FCg3VYY8oL5AR6BCKJ2PCkiLOSsKeElFWUDwRUR/JEOUEzpJgYV+Z/KkGwYCHe+NuaqNZhDH4MxG1sSz5oMk9yCvcxRB3rk59WwHP3YOqBM0Mf0KS82yD0MJyfwKJRu8ctUujJszNe3HOzKMLua5KSHjNcrepqgbILcCzXwsXtaZvJvS+CPS+0dP7K21NP7HtkxdM8uxX71+l2zax+wHi4ydXbd+v3k/03tvJvniOeLQX8dPn4dbr2vV19YuX0LfuJSzbLHxmukHY4xPnJGFe4gQGt2LZeq2bjXYFcVaSeDaR588niMQ0pasSMqcrNLaXUEFCfdDDqWqSjKQ2JNsLOa3sssAoyM4YwoIg8cEoQZQHb9HgVQwigUafJDutyU5FNPod3Kom8SVCG+KMxAk0IoYoLykeqyHrUTtH4dRjm9yTtjbP2WnM7jHqYwXLIlwKkZWGFQTNehjfRdQjxOS5ZemrZqnP+Ar5i5cwN+9FnZlb2+aqo+tuzf3yXpztY8SnTq/6rq4GvG41XCFEqTnafx875f/S+Z/x5sfKgO9UZYXm1N4YDvi/1dayByuCufJHdODtX8cZ24ZMrMilEQJ57TXWiUYIuzbfvQM1XcGbC3CrMVHBJc5ZKavMfIK7lGAcQVRQyFDbGroCp6Ypvtqg9FLVlt3KDokvafS71HaVCXocGv028RcVbHYfA5l5g4jBOCASG+Rxxo7w3qIhLNmkoHYFsS8IS4LSsRgZG4I+B6HBXYysLJcGp6HxZyLirCA7FSGChKgvi1ps4NRj67+X9dB5n+oNA0Rv2YNxFflnz+Efn+WJf/gah5/9NiKMEPXQaupHMcl1y6O1XKyh5io4ZxeQpSLily+yFib2fBa1r0nEkat7x/Y7H7BdeafPgDGrxE070Wm0cbXgQom892D59rPAYxvpr9+q6Mz6Tmz7JGp4iOTcVLu0N7H3c2vquQGI549hdowig2TZBLL8u5i37EUcO43Yu524N4tRNlEX5xQY8OZjtCuIigqhBSrQaFdSH3LtNL1h2rz7uOBZzn6zJp87FyGMsWKYdVvCm73Zttk6dbuWF7oV8Ja3n/j2uUYJVAOCXjsdMFIgY6j321Jf/oydcSzuzuLWNd5iQqPPwQx65E8HhGWX2o1FcmcjSxDSBpkYgqEcTiXCnwtRlQbGVcSDJZL8MpknHu21Hn6xxjm3gJpOlqWusz6iHlhX3IyHdBx03xrSWcYgGiHJmXOA7QRsaRCu/C4vhJV22VcDLkTOeRJ4Csu5v0sI0Zm9v2uzL+5qxHjPRzBJAtfuhLPnlndobb3df/YC5sa9yEbI4Wf+AACxfQTCCGd6uRFEDA/YJNU1lpgT5x2MgPxz51DDZZvYyylUaNfhcU4S5W3zjb9gCTdRQaIdK5elXUGcsRx8t5qQ+NKKVUqD9iRBr4dbs9P3OGuDXWrblYeAqGADW8QgtCEza0gywpJ0AmMlugJD6Arq/YrcuRinoVGBsT0AiSHxBFHRJc5K/IXE3kAEGFcS5y0V2G3x/stZVC1ELdRxpiuMX/8FdE/e9h8s1DGuQpfziFjbmVHFioPGIz2o2Sq6nIOM17YFg2YjVC6D6S1aBZ+xEeJXj6Nmq7ZB6IWX4e23rnIdWgtXA/NuPaR1+teBibFPWSXVNfzVWhjv+Qj6uh080dRkG9/3JXQxg1ysY7KeVbLNZ21bacbHND3lZaVBY2ePnSZXrHlEXPRwFgOicoY4r9qusklGImP7PYYFhVuzmvRxVuI0NDKyf7dKe5m5pE3YSXw7vY3yksS1AZ9k7RTfqVkRTSOg0S9QoQ16GUNmTlPvl4QlOzOQMTh1G9hCG9wqqNCAoWmkYV/PqWnirEBFBtm8WajQCnyI2OAuWqeeJOfgzFluQsutx/gOslKHKCbe1of2lPX4q0fWlqseEg8WcU/M2BtmuWDr/8cnoa8HEcXEIz04x85hGgE4ziqq7sSOT2NqdZI5az/m7NhOfOJkV4CvzNWslbu53HhN5BwhxO8ZYy5ILt/oca8XV0LQHyx8aM3uuRYu5u4/sfsBTMZfVoEZ6LU3gaUGupCxXPkBK0klwwTtKpKs1ZKP8g7ateW6pMWyq9o1fKPXZt1lbDDSBqNofsdG2JEZ02TouTZAnZomLCrComiOxk2abdAa2SHoBe0anLrAqYNTNcR5QdBrEImd7ovEBriMQDv2+TI2uFV7M1Chwa0ZEleQ+ILcubjZ7GMsT2Apss1CjmxbbCUZh7/6KyvBuP8dj6CaKkK6nGvfSA/e/jWSnIszVSHpL+CcmMY0GpgdIyR5D2eu6XQbJ/aG++IJGBsmefbFC35fB8u/i65UkMUiulJB9ZQ31HNxufFayTl3CiHezzIhpxOdd4qj2HLemx7nC3gAmct1ce/Hhz/eHkkmrv18m0YLgFKIKEY3ud9qxJaTzGIFchmSnhzOVAWTz2BcRWPItwG0EKFCjYysFBbCJskwhrDokDSDKPGbSjkeCC1w6xoVWqpua8RPXIFfsew4GUsy84agKIkLAgPEWdo3iKhoSEoxesEBI4gKgjhr0L5BNWgmDYXVtPdt0CNAJwKtBMYBHdhqgArtDclIO7qHZXs9KkgwGksJ9iTknK5Uc5J3SfJlnMUAubBsWZ3kXGQQ28/TV+B7CNexikGOICll2mv2ib2fw+wYBa1Rg4Nd39Ga3/nCn67L5T+Y+x1EPteuHlwtWDfoU6GMi4cc7Cc+dqL92FSrTOz9HMnJyXZC78Ddj6DOzGFKeYhixI5tyFNnEEt1KOYwY0Pw/CvoO/ehHGV/0GGCtxBbgk3Zusy6UzWigVwz4ARGiWaW3CbrtNOcXmOVbBtlZbc1ZwGJK9AuRFkBxkGFzTZZT+DUbDlOO5BkDNoFPRzg+TGhtN1+RhlMViMaEhELJKAVqASr0BPaLH+jXzRLf80ZQPMmZCS20tBclsjIEOUc3CXbUpv4EqeWIAPDe//xH0BioMlCTHK2B3//Ox7BmZxDjPYiF+u2DVcI29U3v4icnYfrd3Z9R/rcNMlbr203LwHtXAvQ5uCP3/BFDjc7I9cK+PHhj6/i618t2Gzd+y2Bg7c9iHn+FZ6o/4f2tvFbvgJ7dqIBNbRMCmm1j4KVZEreeStOPgPzS4hqHX36LGrHNryTsySTZzHvuImkKW0lYmPVb5YiwuG8FZqcrJJkXcIeD61s0Ntpe/NFhEAmdvSViU3CaSVIMs3MvBTIWKPqCVHJzhS8BYOqw+JeO4In5Zg926YZzS3y/OwQiRZEiSIIHCLjEyuDP23794UBp2Lr+kbYWYKIwW3Y4BYxBL0CEUNuKkG7gsy0ldpKMso29tQNTn2ZxmukQEYaWYuQQUw4kCPJZhGxIbphGKcag+sQbivjH7PW2nphEbF3F3K+2m7COfiWB+HanYi/f7rr+1OLDdizE+MqJnZ82tqIr8BKufPzzQ6udKRBfwlgfvUSarDbW2AjXG6x71q849NW9bWUQy7WEDfuobK7RO54FVHK4cw34PlXcHfvIO7JEfT7NLyMNaxwoLKngLukSXxhO97ywmazW4m8usZpGKtCk0CjT5BkbKIOY9fp2lVkZ7FLA2PLeYvXuDh1QZw3jOyY5Z+M/Zhfz75EtE1yJi5yJi5zeOZWfvjKNYgzPsFQQv4VW2GI8wJ/zibxyi8n1PslKrSjuXZtX4CRgqVtttog+zy8isFbSnDqlgrs1K1sl3YF3mJsVXqUIC5lrJNvDM5cHaMUOusQl7PIICEa6UFVAqSjMGFEfe9yG7OsVAmvGcDbsY173v1N3KYoabKCLLWWZPlG5c6vBqRBfwnwRPjnXTzu9RJ6++W9mHe+FfF3P+eIfozHf/GN9na5YzvR9n5ULST/iqWUysUajb2DqMI+tCsJexz8uQgRaZypCiKMqN40gluLUYEkzitrMOEKGv3NAMxIjLIBGJaaZbeqsW2zSSuDD7VBRemVkKDXYfEa13bjZQyJb5ieK/Kf3DsJRl3eV3yGPm+OA7mIMfeveXpqhEaYgVKIChwyswYnMM3qgU0F5aY19T5J0CvJn7YltqAPqAvcql0+qMjYtbwjyE0G1hhDN51shZXxFrFB1a0+n8kuy2whBDKIkMfPsfgbe8ieFXi1Bkl/gczkEgff8iByvkJ86jStZ6lqYN1+8z5PXkIf+6sBG9XIu80Y87OLOfH5XGubHnZ7mv/u6nCtncMq7h7pkMO+6nA+7XT39Czxim3yLfuI8tbDXf/iOZyxbaAk8XAPmaPTNPYMoF1J7kSVqCeDzjo0hgaQzUAB264qtCHodYgzol2Ka8Fq5dm/tSuIc3Yq7lZEuxZfG3EJypKw3CzDheBFgjjMcnRxhP9trsz/r+9WtufnyaqIc0GBjBtTzRg4m6ExaHO+vc/HREWFUzc0eiSFMzH+AiSeIsrZpYWqg0xM0wQTagOS7KxGBZqg3yXscfHmQtRSQJL3rTefK4kKWZyi7epzlkJkEFuOwZIkfPduvEpiCUlaIxsxOuPinFtA9xWRfTegwUpt/eI5nB3b0b947tJ98VcJNupPv18I8YQQ4nNNkczzosOV9kng9qYrbSfeD9zZsroSQrS69u41xuy/GgO+c2Q/dOx77Jf3ruriOqIfI9rWh7xlX9f2JO8jfvg0+hfPoW66nnh7v6XfPvUsSV+BqNDslXetT50/00CGNuCzZwOyp5fQjiAs2E41YcBf1PgLtowXlARBuVmPL1harxXCsIm1qCSI8oIoZ48xrcRbCG4F3EWBCCTRqwVePDnEf3nhev7zM7fw45euYepcCeMYjDIkHkQFmLveJSjZPAQSgrKyhhN1W+Zz6pCdtVJbxgHtgluzpUOEbQ3GQDDgsbS3jHGkHeEjjVuzLj6qYRV4o94s/kxA4ksKz84iYkOSc9A9BcL+LI2hph6eEFYjsOBT31VE3rIPXS6smpEdvO3BLkOM9/7jP7hkv5ErBRuVwP4j4I+EEG8DviuEKGNpuWuW6jbgWtvJZum0sOpZaWt9NaFzLXhEP8b4zb+/Sk6rZaF0wPsgaodt+JAnJ3liBfXz4G0Pot9+M+qXR8nJa6yklHLIHJsn7suT+NIGpydp7C7SaJa9vCWNSJplucTgLRmCoi2ZCd1kz0mBCmxwx1lQDXACW+ZLMpA7Z+xsoTkixxk7I5CRIIl94qJGVW2OQEY2D+DUwFkCJM0ZiCBqSmtZt1zwKwa3bm8uQoNbtedWTcJPUFa4dY1TbbrxuJLMVICqWiks91yFaLBA2OOhGhr/TAUxt0iwbxsiMTR2lPHmrbhnXPZR9RhVs/OqJOdhPIl3fBb3jOiyxAarhqSGBjBnz6Fuur69Xf3tM+t/3+uYm1zpuJiGmz8EvoP1nHs/8Jcr7a7WwHlda5szgNkOC6s+rLHG1VX4xGZ3MabLNeXwM3+AMzSw5vEmjiFOSE5OIm7au2r/4z/7Bk/+j68idoximjP1JOuQ9NpknluJUaEh6G1KUS0k+IuaKK8scadmR9Iwb9fx3qLBaRj8BUuWsQHbJOAkoD2B9rD6d03feXcJwjIkWWMDPmOI8xrZsI03bkWQP23wZ2zQI2yAu1VD/myCCg3+omXd1QbtTcpd0jh1g4zs9YjE8vrBLju0I3CXYrz50LYD93jonAsS4oECIjFkTy0hjCEYLRLvGsJZiqztVqCJC57N9tdjwl4PGSXoM+dwpiuISNvP/NQkyUAJk89y4O1ftwHf30t0zRBPhH++LLP9todWyZZ34tCJf8nE2Kc4mPud1/ajuUzYaCLv3wL/xhjT2V23IIQ4L/fwQq61wPtaPfvN41ued/Mrn3M5rao3wrTTi5W1NfFc17Zp7tqB8T2SF15GvO1m1OAgYLXwZT3kwN2PIF88jujrJekvtkt7SSlDnHOt7LUr0crW6VWQEJYdWxMPbNA41QQjHcKCJHc2IncmoT7kE2fsyJp4or2OxoDTsFN8sIGPA0kWdF3gLtn0fpy1dXvt2JsERti6fGgD3wjwKganbqgNS7JntJXqajLwgKZdtqX8ytgm7YxqzgCMzT+IhrGzEAG1kWbgxpapF5Zc6HGt205dgxSoaoTOOhglMcJg8jbAw5xn5cGyDvmnz5AM9SDKJUQjxHnhJMmOEWQx13YQamFi9wNWyLMD4uTq0t2q731u/oqp179uq+pOGGNWm37Z7f/vtbZfyLW2ecz7Wmv3Zg7gTuDHzaXBKlxOq+rzBfz5fNDXev54/30QRJYmOtqPY8ZIihnU6Rno64UkQZ2c4sAdD1s+OQAuainEqRii3gyqHhP0+nZaXbWWVFHesd13TcR51Q4a2wlnSTkqMkRZmzU3AjA2oDF2NpD4ln/vLrVkt2xSL87RJO6ACkTTYKNZ+09aTTi6fXNpiasJY49xAo1WdjQ3AhBQmGwgI484Jy2xJ7QSX0Y0m34ikKGdKYjEavWJxDYISW3wTsxZd19AZxycswsc+VvbyXjgjocx+azV9Osrk+R9zFOTiF0jxD2rde9Nxkcu1JjY/QCHmtn8CzHtrjTO/UatqjeayLtYnNe1trn9O0KInwghfoK9Kfygue99AOvMDK4YjA9/HLABfbHdVqJSQ1cqGM9q3qHtdP/QS3/EoVf+GFOvo87MNEUjrNS0iBLEqamm1rxAewJ3Mba96KZJummScmQMcdb2zLdGeWFs0GPsfhW2ptc2qQctoQ2byQ/LdrrvNJr+d82mGlUXqLo9nwosBbcl3JGZSWzDjTHt5YV2aAesv2BFPGRiryPxbfedjEwzgWevQ4XaUnUF9hcq7Gs41RinFmOksFoDujmdF7a913jLLbjGV01VYUNSzCCrAc7oMOrsfDeJvPWdLNUwOb8d8BfCweKHL+o7v5KwKXX6DbjWPknTImsFnmr+u6IDHkCo898vW5zuQ8e+x8HbHkScnuLwuX/T7sjbL+9FTS+i5+ZRUqKHOyZDvm8ZZfksOuvgLDTQWReZz9re80aMu+QgA9u3nhSsxZUMbQA7DUtkMbI5Ekea2LeCHNoBt6bbopfQ7JxLDFFe4FVssIVlG/AyNMgYkubNxNJ7aavxOA1bR7fBq0EonIZBNex5WqQhALTBaWhEYq2uGwNuk3OvrZGHoV2VsCw8Q+LJJkdftNf+NKW7k8EyUdltvr5Gl5ZH8KDPJ3PWqvMYKRFLdeKxfuQzR3myw4RyfOhjiEwGPTcP/aWu7y+ZmkLcdSviV0dXLd3OJ29+pSMl56yDC03d1pPKOvi2hxBnZrpomqIeYmr1ruNkLoc+N40cHoS6FXocv/WrGCXQUzOo/j6SgSLaU5ZhVwup3TCEP11Hnp5ClLcTlVyyp6skGQedFziRbpbGmtlvxwaKdiXCwyrpxnbkba27nbpl5ZnmyiDO2hbZlqKM0DazH+XtjEFFNtHX6qQzSrQDWfuy3T6b+LK9phfaEBUkwliGoAoS28XXAKee2JlMYiWzVC2mPpLFSNv339IBcOoJshFbE4wwaec4/JkA7SpULUIuLjfhODWrqafOznO4GeQH7n4EObB8c23JZgcTd/HX//e/6Pp+kqkpZC6HnF6EoQH2q/cjHHdNv4MD3gevKsPLNOjXwUbXaiuTfI//9JFV9fnDz3/H8r47ce1OO61PEvTJScRwH2KpiukpID2XZGYWc902ZJAQDufxT8yjAks4ifaNEeeVHTGLPklL/LIWk2RUW9ces2xDJRLTvhkEPYqkmeF3GobFncs/A9t+a5ojt62n1wYlbs0QIcjMGKIcbdGLRq8gMyfJnwqoD9usoLcQEfR57eVG4lr2X2YqJCo6NPrddhmvlYuQUVM8I2/ZgCo0Tf+8BKdqk5ZxTlmbLmFIaPL8z86j81mCbQU8R3LPr38L2YiQvoPQBpNZZu7JmvW8+/X/5Y/IvzRHcuYsSEXmXI2VWLlkO+D/Fmrb8Jq/gasp4CEN+jcMLcrtxM7P2A09RWTFqt/Km29oG2Hsf8cjyOuvwanUOdTsBDuQ/W24ZgeqEdMYLaAC6xevS1m075A7Ok9jrERt1Cd3LkQ1EsIeD9Px7cq4qYDT1NUT2q7744xds6vI0nHjrCCRlhyjQkO9X7az9L0vBMxf5yHDZv0+b5tzwqJA7/LJT0Y0+hwSX7U59nFW4laskq/2rN+eUdZnLy4ovPnY6uDnHKrbM2SnIjLTIWHJRYY2aQfgLca24SjWqHqECCLinlxbguy9v/EtkryLe3qBcHsPqh4jf/ES4d372mXU1o384G0Pkjx/FKTC2bGN+KlfdX1Xa83y1hrhu55zFSnppEH/OrHyi1755a98HJ88Zf84CbxlH/LWG7q82pyz86ANldu3tbepkSGSknWQcarNnvHZeZLhkk3gFTK200wKtJK41QBvHuKCi3YExrPTcFnX5E82aAz7aGUNMOp9zdyENMgQyADarvEbvYLyqzFBSRFnYW6fj3btet6tGlSzhJ0/YyWpwrJD/lTDOu+0lhYKEODPhTQGPWRoyP3XZ4nuvI7Yl6iMIs5ZpmH+ZIOo5BIVrD+eaZpmimZewllskOR9wr4sbkXZxpsm/vKvrVPQwdu/hrMUoc7MwfAgspEg7rwF86Nfto9t6RC2cPC2B5nYdT/xiZPIt+y7YPPNSlxNAQ+bl73fuujQul8LK3n5+hfPdfXgx8dPglmeigOEOwcI+nycmSVklOCdmkcvVXFnaxhX2rJUGOOfWcKbrhKVfBpDvq1rh5rsmQa5kzWMFFR3ZAmb2nlOXZOZ000WXVMIo26annWQmTXUBhROYCiejJuZ+GV1HLdmyE0ldsaQlai6Jsk4NHoV+VMNm4xLQAWaqGjNMAHCu64nzilKR6tkTlcwUuBU7ZrdSEH2TA23EiFim9lXLdptztbivZmateWuBqs+X7s8EcQnTpKcnETVwg19L2t9N0AXJXc9CNe74DFXEtKR/hJiYvcDONtGlx/v/Ex7BNiv3o+z0+qttXTX5EIVbtmHLnhN2WX73EPNxNPEns+SDJZxogRn0ZD05DBKEuztJ+s6RH05ZN0SShpDOZKsJH+ihjddRZgc2rVeccH2LG41QQYatwKetsm92lCzBz62xJigp8kKqEKUg+xcQm1AUe8TBCWn2fba9MPzoXgiojHg2nxBTZNkJdnTS1RHyyS+wqlr3HMRqhpad5tQ4x+fJRopN8lFHtrP4FUiooKDdrOoQNMYzOItWoUgZykiyTRLmz/8JfL6vYTbSrgzNcKhgk2cRkmbRSeSBNEwJO98K1oJvFenSM5OIW++gYNve4ioL8tf/eWXV313rVE+yfvtba3cTOd0f61R/UJT/ysNadC/TnQ62CanJlEjw+0fxqGO0tBaicGJXffbUbYeYe64ieSnzyJuv6m9Px4qI8MEXni1LdW1/13fsF1kie6qseeO23bcuJRBCBd3zjrh6B4rfR1nJSa3nF0PyrLJf9eo0LLfVEPgNJotsQKirETG0Ptig9qQR3VE4c9bKWygnVhLfIm3GBE4HknOIzNnp/tuxQa8XKgiyj4GQTTWg5GC2qBnG2wAZ6aOiHzrbX+2Rlz0aQx47T4B/+QCohFgbrwOUa1bY8qMh7MQIKoNTCHLgTseRi1UoZCBWOOembcXKQRqZMguZ3wH52+fsSXUWLdvFJ3T/QPeB5e/s6toyn4xSNVwXwPO1y+/1vb17JJbeO9v/gHOUy8gxkYQcQL1Bsn2QeK8a4kuU9X2D3T8xi9DkoDnwtQcetew7UJ7eRIGegi2lfBPLgDQ2NVjxSZjTTCQacpq2cSdduyafpmaK9ojdm3IIc5C7wshS9s9q7oTYoU7msq4wkB2qtngo42tr2ckIjH4MyG1UR9vMWn3+DvV2EpdZ22SL3e82mYX6oyyTUA1m6/QjsCbt3ZWUcnSjoUxJL4CbVCRbqoIaauWq7E3z8U68VAJZ76OqDWIB0vorIM7VUXUrcqucZrahKUcwXAe/6+f3jCNdr96Pxhz3pvBejbmbzRSq+rzYC1v8teC/fJekOo1Wx2P3/IVOHkGxobtj9NzbIa6N4eqRYhqg3iwiFoKrJf9mRlwHEs1LWcRkSYpeMQ5Za2fMw710bwt3UkrpuEtxDhV24iiAk1YdpqsOYG3kKB92/ASN//PnYsJem1psC20mYE4Z4k/mRnL489NWUPM7JkGjSHfdsbVIsTkNI23NjXqtHXblbHGmZwjHu5B+04zo5+gFhpEgznirL0BZCerJDmPqOSg6tbpVmjTpW03seezVhB0p/UIcJZCa+edcVBzVaKRMs6LpyEIEKUienoG4XltzbvxW79K8szzyExmzd/A+PDHMZXKur+PS/Xb2Qy8blurNzNe75c2PvhRxgc/aum4Fxnw44PtXiN01kWUS+i8b73ctEbUA5yZKjrjYPIZ1FJgjS8KHqavjMl4iMAaQuBI3Nka/kyDaCBHUvBQjQS3FtuRUtsynXGsq2ySkU1KrsFd0ra/3rV01sxsgtNoqtRGpildrdsa+O6SwakatGMDviWoqTPKEn4WGoh6SLJ7BCMF7mKIP123dNy5GrqngAwToqJD4km0K61rrTb4swFOLSEqZxCxxl2IcGoRzmIDVYu6Pj+T9Un6Sqh6hHuuQpL37Iiu7T6hDUQhyVIVk/XRjQa4HZyE46dx9lyDyOeY2HX/Kotx+sroRoPx/vtW78P+dg4WPnRR3/mVgHRNfwmwXmPGwdu/xuNPfb1r2355bzuR15ktVqdn0IM9PNHyXb/xy5jKEswnSH/U6uEXsxhXoRrx8nT/hi+Co+xNYqmGjH2b+AKkNJAYVD3G8SSJb/+1FGhVQxPnrbEkxgZ3i+oqEyugKZPmjWEuxgx5gGh39cUZsdwL4GJvIgkQxSQ9OYI+nyQj8WYNIkqQyirVNkbyTSEQeyPRjkB7ju2bNwahrb6/qgYY321aaSlwJPe8+5vojKUPiqECqhqhpuxyxpmtdsuMY2dQTm8Pxtj+ADM2xHjPR2B4AFkuEY714kXL3XUTu+7HVCocnv23HH7221b++jxmJheSRb8SseVH+tcLvbBskbxf3tvVWy1Onu1i540PfQyZy2Hq9fb/LZhG0JVQMr4NXJHPIxoRZrFilXOk6NJ814Us0UAOnXEx+SzGd3BnazhLYVMX3xpaqFC3v21nKcFdilHNgDWOJdJYs0lDkpV4iwluVbc962WYNI0r7DH+QoJbN0RFZV1wGwanElgHm4GC7RmoJba5RQqivpxVryn6uJWIJO/i1GKcSmgpv1JYt56cR5xVbeVfaOrdlzxLN/YVf/WXX7YZeA3q1DSm1rDGIdPzq76fuCdLNNKDaDRLdxpEb5nDz3+HQ8f/RZsLAGDqdfudOMtj4Vry153Jvk5cLX736Uj/OtFJwZT5fFfCLpme6TpWL1Qs0ebMuXayZ/z6L5C89EqXhNbErvuJ9g7hyhHqwzncSoQsZZELNaRnG0wOvu0hRD1EZD1kkKAdaW8KnoOIGhBb51qnEtjW1EjjzWuSjE2UiZpGyCZP32BNITK2l9epJvhnqzRGCzbzn5M0Bv02dbfep/AqdnbQotNmJhv2xiMgLHu4lYi46FjqcC0k3Fa0rcKRxllokOQ9gv6MlfpSGcIeF3dJQLMiEZZbBhYJ2rUaeTJJbN9/E+65CqZeRxQKdiQf7GX/u+yNUy6FiEaA6LNLCRNFCMfFvPgKjAy1z9Eq303sur/9fcm37LOW4sdOrLKzcnZuX592uwEuwJWANOgvIcQ13eSOjdRz9bFTIBUowcTuB0jOnEMNDuBNVTGu4r8dspqi9/z6t6CQRbx0HHaNISt1jOsgTp2D2Xm8HdsgCDG9JYLREu5CAxnE1HYUbLLtVA01UyG8aQgjBUG/T/ZMvZ04a037vfkI4wgWry/Z7HuTRhvnFG5V488ExJmMla5uWljL2GbR47xVuPHm7TTdW4xoDHiIILZTeCVRkaZ2TQl3MUZoQziQs0nFHseabgTaruVrsc0/FDzQdrahggRZC+3Sx3UQjoKxEZiZJ9jegwwT3HMVRBCiewrgOqhqSFzKoBYWUWMjNjDDyCYBhVh2Em7JZ0mFef4VGB1e9f0dSX7A+L71XdqvpN768yEN+kuIw7/85rqiGut17Ymb9vJEk3cPtkuP2QpiqUa0c1n8xJ2cR+cyyMF+jDGY6VnIZtC7t+E4DsZzibf1IcMYb6ZmDRxdhTcfWRXZkt+0eDbojNWSF2FM5lydqOyTeBIkJBllTTSmrdR2WM5Q/MVZqjcN4VQTVC3EXfLaSwKRGLyFiOquAjIy+DMBUcnDf/KnhO+5DbeSUNvTS/75afTxU3DLtSReBkcJooIiMxuR+ArVsKKY3kydsC9LY8hvS2nJUOMsBMhXTyMyPuG1o2hP8l+O2AC859e/ZXMAjZjkxaPIbBZ6CiTPH0W4Du7oMPFt1/P433Y3Pd3za9/k4NseQv/8WXvjBZxtI9Ycc0XSsP0dP/eHVx3tdiXSoL/EWO/HcCT5QTsD3OWCuqJkGgzm8J55EXnDXpyFOgdve9C2jCbadpLNuTZIsjsRYYx88TiUS9b8MtbIeoT2bX1fRAm4ChlpwrKLMC5OI8GtRBglaYzkLcddCbzFqN3c4lZjZGips96iNZDIP30G3VMgyXtNeWtt6+9/9RPmPvROiidCtCeJSpaSKm6+znrdBwnuf/8lwa/fit7bz3/7z9ZL/jf+5+/iLcRWSqsSERVdK+E9lMM/W8WpuYQ9PqqR4CyFoASip2TX/Vllew2aEFGCN1ez3vTX7SF54WXk869g3nkrUVbxX59Ye3TWvuLJ//HImvtgfd79hQL+Qv54lxtp0L/BuBCX210MUdu3EQ7k7Og2v0Ry8jQmjvH7irZf/ldHMddbhVxGhzCRXfsa30UsLCGrVTslHh4gKlsCjD8b2FZbXxH1eO2suwxi25jjSfxjs0TD5a5rCcseld1ZuGaM4rE6ScbBW0wIS03SzY7t+BVt+fA/fxbzzrcSDPjUtxUwjiDo8/DffhPeTI2od1nkIslYrzqw6/dOAk7ck7FLgWbAx02de+0pjJL4Z5bQuWW+u1qoEw0VcRYsOUhdu5topIx3ag7ZX1z3s/aPTr2u72o9JFPnP+/lRhr0m4iDb3mw3VILdI0aren+4z/7Rtd0UQaWLab+5peY2/YRXDOA21OAZ19G//xZnJFhzK4x4ryLPHkOBnpgYQmMRupektE+kswQMrZB7SyFqLkqSW8e46q27fP49V9A9+SJi7aeL8OEaKSMcSWqGrG4t0DvP0yC6CXOS8o/nkSX81THMhT+4h+Q//h2AKLt/RReXiTqyxL8r3fjLcQUfnmGYPdAO0n2zn/yz8hNgjvfaL///Ikacd61iUaZQdUiwj7Lzwds9cGRGEfaDH8TcUGR5H2cqUU7C6rUMZNn8RbKxGfOokolwjuutcq3xiAayzOC/e/6Bs6pWeKTp3DGti13PK6DzpLq+ab0K/dd6VP/NOgvMboCuFJd9zh143XLf3forMuFKsmpM+0M8fj1X8BkfPSdNxLnHcRMHTVXxTsVQMaHWoNDzank+A1fRIQxwlOIWOOcmcNUa4hSAbUUEIx2jHqug6w0cIRAvnic6JbdxHmH7MszJANFys8vQhQjf/wsuTtvJB4q45xboPiSJHrP7WhX4i6GBP0+Pra7Lc4ISj+fIR4q484tB3jxpSXCwSzumQXe+5t/YJN/rsQ7vWATcInGNOXHjCP4yyd/H4DfnPhOm9RT35ZHBRpvpm6XRMq+x3BnH2zvQyQaNdCLdpUVzCznaOwdxJ1vcMD/LeR11yBefBVGhnC2jxHuGcQtFzj4lgfRv3pxTWJV503aGdu2ysOg/f0ND63adiUjDfpLgM5Ad0ZH2ttXiiweyP42amgQ4hg9O9febo4eX37O0X9uNfRb+wpZxNGTODtGcV6YtYmsawbtj3wp6Jrm4rnISt2SUFyFyfpQLhAM5nEqAf7pRd77G9/CuBKnkCEuuLizdczOUaKiS5KVRCNlW6Yr+1AYhGsGcc8sEG7vJdk9gP/qDMFwzspVeQpv3o7C/vFZ3EoBksQm8v72WQ7e/jXC/iymP0PmxAL4nl1GTFbg5BniW/fgNBNmcc5FxBp/qlvFJipnkIkmM1lDaI3OuqjZKqJSJd4xiKpGyEqDpGz5Ct7ZStul9sDbv06SdfEG+qARWn+B2QrJ5Bmc2TmrWnTb9aATLoTk3PS6xx2e/JMLPv9KQhr0lwBdllbncTd9ov4fOJD9beTeXahspr1d7On2UDe9JcZv+YqtuZ88i967A3niDCJv5Z7d6SXQBp3zEbFmYsenMT1FkryHVJbkImLdbDCxvfNxyUe5tjQIIKsB0rN2U9p3yEzVu9iAcX8eZ75OfUcJVc4hYo327Y3En2kgF+sEY2VkYoU68WyCkYGSZdk1AkTztWVs4NRZ4lv30OhzcGdd5PYRooKDN2d74lsS3SKMGb/1q0QDOYSv8M5VEVFM3JcHIM47HPnbPwQs49E4Es5OId1Ru/b3ln/SScaxBB+l0GenSIavBVHiieYIPj76CYwQPNkpUT76CRjo5fAvv9n9ncRR+3s+kP3tLlvyqw1p0G8ixoc+hhkbakthAaihQUwUY5RcVd4bH/oYZmTQdoGVc4gwRs8vwI4RhOuClOh8FqE1zMwissMYBPgehBEi42BcZZN6QkDWa5btAmSlgc75qMRYZRvfJc47Vk+uERF3JNlM1sMoSVLKkDlj+QJJzsGdD9B5HxFEmJOTZJZqJCO94EhMIjGuhDrWa66vh3p/BrcS4Z6YQe/chkisDDYS4t4mQy/v2pJcNSbJOoTDRdzZGrJuPetszT2PzihUPcbrWDbojGNFQ0ft9NqphBgpuefXvomqRShHWhlxJRG7xnAW6uhsh0z2SD8y7Da4MEtVpBCMD36UZGZ2eQa3e1f7mKs54CEN+k3F4XP/hgN3Pdy9MY4RDTCVCqpUIllcpvESRsjpubbS7sSez2IKeajUML0lRK1hAz7RiFKRwyt4/WCntDrjIiJLmBGxhia33DRbU2WokbUAyCKCpD36v/c3vmXFJIu+bYJRwp4jSiwZJ4iJSxnchRoo1eXjdvC2B/FOzBEPl3HmG9DXgwq0vRFojXEV2pE4S5Fl7knRLt+99zf/AKfSwJmvEQ0VSIoZ22pbjyyZJta4UzV7M8z5dh2ec0EK4ryD8QqIyCYuVfN/AHVmDt1XtDeOvI986SRyqMOvfn4JwojxG77I4ee/A1hp6/HRTyByOVQUL2sjrOD0X83YtKB/jVbV78M64uxZYXJ5xWO/ej+qXOLwbLenp1wKOFj4ULsxY+X0v7NLS5RL3Wv9XIbDR/85wDITbGoO4XvE21aZBtlzhDG64NvsdaIhSWyw9BTQvrJOOXN1xOIS7mIO0QjQvQXUUmiTaVKglurE5azNrAtBXPTJnFoCiW32ee4PV73u4z/7BgeLH+bJ1nr67kfwzlaI+vN2NqAt8cepJ5bYE3Svj0ViEEGEWgpJcl6TM+C2bzoiihGBpR0n5QyyEaFd16oCVwBH2q66js/BNBqI2C4LZC3EhCFiZvnzjY+dQPX2Yoa7P8vONfpafPqV2fqJvZ/DzM2v+u4Pln+Xxxf+dM3v6XJiU4K+w6r6u0KIL67hRPt+sN51Qoi7mlbVs81tTwoh7hNC3NNhbHlFYS3xS+E4q750gMPPfvu85xLFAuO3fMUmqKII2dfb3heXO+yXZuYgl7M/ZEehKg3Gb/2qndbHCclACXVuHqmUbSoxhqSctfz1s7PI6QWcxCCrdev/1luy/PRgmXnmTFeIB4qIyRlkZgQxOY0IAhrvuh75Nz9H3noD6sS59vHjo5+gdvsu/vr/tiO2HB5s70t8hVzQlh/vudR3Fm3Sz4CqWl7B/nc8Qtjr4xhLEKpfN4DTSHAWbAtxVPRI8napEZUcMmfrqOlFkmwvjeEciS+tDZZjmYbOYmBJPInBSAljQ/DiMWhSlMW2YfTxU0zsfoBoW1/XWv7gWx5EHD+9qsFmlZX1GmaVbSrvClyJAQ+bLKLRHNG/02lSucYxj2FtsPYD/8kY81RzlnB7p0/9laSc83pw4K6HMT95BnnbTZinXwAhbRPOuSlMEOBsH0PPziH7ettyW+/9zT/AmauDEpadJ6whhshl26PSgbsfQdZCm8SbW8SEIQwPoHMeItaIemin2TnfBoQjUSfOYeKY4K3X4E1VEY2IcJsl5zjVCPHLF2HfHvu8X72E3HsN5sRp5GA/upiHl17F3LwXfv58u8R44K6HUdOLmIxP3Je3Zhg/fxlzw642NVj7CmemDi+9SvSOm5BBgjs5R7StlyTj4FZC5HwV3ZNHLtYRjYBw50BbUAMB1VG7Nner1qhDJODPRXbGoA1P/nerjju+70tEwyWcHz17Xu2E/fJexB03A/DEjx7ejK/+DcXlFNG4GKvqnhW7+1c/4/LitbRO7pf3LmvdY39QR/RjaE+hRoZ5IvgzDh37nk0OSZtNj++4oUtfT/3Dr9DPPA+AUZJwrBexfQSRWRZxfOKHD3H4l98kKWUwvSUY6IM4QTRiklbyynPtjGKuYnvQMz709SBjTZL3SfryuPNWrMIoATfs5vGnvs7jP/sGanSE5IWXie7eB4lGVqpE77gJ89SvUGPLYqDmJ9bPPXn+JYQxeKfm0Dda9mDYm0EECbIeI45blqGzZFtrzVIVtRjgVuyNC9dBRAnRUBGUwntpktxLc6h6TG3YRWjQShAWJIkrUA2NU41wzy5CxzQ/Gi7hHZ9GjqxfSx+/1arxmKd+hXnqVxy8rZujv9/5wMV96Vc4NjWRd5FW1fOs4W7bwuW0qm7htTCt1uXi//1Dq7Y5O7ataaComj/YQ80qQKez6oG7H0G+eqbN9T7ytw/abr3Bss1cHzuFMzII0t7fk6xD0sGWO3jbgzhz9XYv/4E7HkY89Sxi37XIpdXOL2C1+50d2/FfmYKd29HlfJeyjC7mQQiigots5NsW0P5UDblYw+Qy1N91AyLWeHMNjLBJz9b7UdOLRKO9bfMLXcySjPbgzNVwz8yjtmVo9Mm2HbaqgPYFYa+P8hVJRtnGJUBmXXQ5b3X01sDErvs53EHCmdh1P4dW6OKvRci5EptuLqlV9cXiNVpV/4jl0X4PcKTz+MtpVf2GQa+z1BICk19e3+tyvv23OjNHcMuOrsPr1w3hLkWIxSXIZDBZS+AxrkI2rL58+9T1EHN62Yfd/Pw5K8W9VOt6HZQkPHgnKkjayj/mnW9FVQPkQrWtBOTs2I5uzh/9M1VkpUp4zQBx1kGGmvq+MqWjVetbtxSiZpegr9B+GfnKacxgH850hfJsFV3MEA7krHqOzBMVymhX4C4ZMqGm0WNbgo0QBGVFNtTW4ac/R+b5SfTkWeTYKKxjOPpa+fXO2LYLH/QG46qzqm7OBPZ0POeKTOJtBlrTybU6uiZ2P0By8jRJc3oPIM8tZ6APHfsef/WXX7YquU1kfnIUuRQSXTOMGe63EtSnziGeexVnarHr/CbrdQl/xP/otuYO0+W8c+joP+e//ecv2CYVKZBvsaIfcsE29zT+57e3uexJ3qf+v9xFUvLRPQWc+QbuQsh/efJL/P2ffxbxyxeR/+2nqFPTRCM9xKXlZUrt7j22xGgMh5/9Nk/8w9fwZupkjs/jHT1L/hen8OcTa6IRGvxFKwIiI0PxlSre2QpJziHz/CTJ2XM4o8MkZ86RDC43Ep0PF3KzaR/XUa682nBFWVV3JO6uyoBfj5vdiYNveRA5X+las+unX2z/PbHrfnS50G7U0WenUAP9hNdtY/z6L1h22Q6r89aVadaa8b7fI1lYxNm53WreVQJMxsGEnl2/+w5ioYqs1Ky23tQMYmyZNvybE9/BiXT7h7/KdBNAGzu937ndGkNogy4XyJ1cQo5tIx7rQ/74WfI37SXJeV3EpBZayeNkbABntooIo3YlIlPKEu7oRcQd5bd6aDX39vbhzzTIvjyDua4fp55Y4Y3QOuGGPT6uI3EqEbq3hCwXoNZoi5dM7Ph0V7BO7PwM6uYbLuhQ/GbDlpfAfqMxseeztn4ex8STZ1A3XGuTXr7fZnpN7Pksh5r1+RbGr/+CrbdPzyK2j9oRegU55+DbHrL2zLUQko7vVWLX0vksSdG3pbokQTRCkoHScta/HqCnZ9ulpgPZ3wbAvPV65NMvw/XX2CXCYh0chXn5GGLvLhqjhXbP+j3v/ibu8SmS6RnM227gyArhiv3v+gbyZy+Q3LEPZ76OefUkXLsT40hEk4GHMeB7RL1ZjCO7rKlbEtgH7noY7VldfBk1hT6DBOdXxzA7hhG1gKTPNhq1REQPeB/ExPGqtfg97/4m7smZ9lRfOM6GnWgvpHN/udb+58vep4y8NxitYG4HlO+ghodIzi7Xv1cKawCIOEFPz6JrNZylGrqYYWLv57pqxCtH1YPFDyMH+kgGSuhSDp2zNe+2g+6ez6KmFjALFRjsI+kvIitLHCx+GHbvaN+E3vubfwC1GvLlEzzRUXsev/WrGCXI/OzV9jZnuoIpF5BxTIKV+RalIuHOPksYEgKxcwz36Bl0fw/s3mFLiFIiktD+H8WYOME7OYtxHaLhki3lnV1emogoQQJOQ6KVRCa6XaY7eNuDICXqheOgDRO7H8D43rqB/OTffLX9fUC37uF+eS/O7l3r1uIvZGxxpSX7IA36TcV+ee8qscwWWgE1PvhRRC63zL9vPl6J1s1iYvcDoE27OQZgYtsnV9FiAXvzCJpMOyGQtbCrKy/c3oc7V0ckGuoBqlrnUDOLPj788fZx7mwNsX2sa0kCWF05pRDZLO/9jW+BEjhnphCe234PydwCqq8HZyEgybo8+Td2pJ7Y+RlEGFlefBCiyzmSYgYZJtaC25U4UxqRWHFPUW3AwhLjN36ZaKiI8t0mPbdqbxpd18Uq1mBndWFNP7p1+PRXYtC+XqRBv0lo1fSFUuc97vDU9xnv+73242R2DtW7nHSa2PFpTK3e1l5fq6SnqzWIIkvV1RrmFhCFPHJkCOOodnlwfN+XkNjprGzEUPBojBXxPAdZbXRluEVHtUAs1bpov+O3ftUq2RQzqPkaureAd2KGeLQXoWQ74FUlgGuvsec4NombX76ZmayPybiIs7MQBEjXIe7NIeaqCNfhidaU/O1ft/0DUiKKeQxYf/pGbPUKlIKMtyxxDYgOHfv26/mupUpfu/u838dWQBr0m4SLGiHEcrC1FFf3Ox/AGR1uj97jQx9DZDLt0Xb81q+2FVyFEBxuss0Ovu0hZJxgHGX97jqWCiKKEWGE8RzkUh3ZCNHbSshGSNxfIMk5tmHHd1DlvE0czi8iCnm03+EM40hrszWUx5mca4+qB297EAb60PmMrRaAbXipBZg4RsSxTQ4qgaxYNR/H8zDaWDpxlNjcwsJSxzVbjn7cX7AagHNLyErDLgEWl2wbbPMG0UaScM+7v4n4u5+DVDg7x6B5E2s11mxlpEF/GbFf3tuVwGtjoYLM5zBhtyJr5/TauAo5V1s18q9c14+PfsImAePE2mU5ChLT/vG3HF1kfgfUmn32L59ClIuW6utam+gWwabzNQ7c8XD3azdJLRO7H0AHIfT1oH/xHOr6vYhtwxxq9iFMXPt5TKPRniUYr8cSicAaUC40bJWj1kBMzyJKRRDldoLPuArjO4immccqSGlbZtf6bFufy74vrdk4tBWQOtxcRhzRj635ozw8+SeI7SPouTk72rLMWGvh8ae+TnzidNe28Zt/f81zHX7hu5av31ck2taLSJY73PTsHPg+8uVTyEaMPnocvXcMXcjBtTvR1+7g0Ct/zJG/f2jNZhOUZP+7vtFFUT70yh/Dnu12dM7ZTr5ocJmAc+ilP7K2Uc/9IaJhp+pIYdWAahE662KyLgQh+D6mmLN04J8+AlFs3Xd9F1PIYrJe12tPXPt5e1nnFlCD65LSLhjwV4tbzWtBOtJfoTj8zB+s2jax8zPo6Zl244jq6+k+oIPRN7HzM10zg5XZ53ve/U1klFgBinMzmN1jmJ8+g/B91PTicuKw07jxhuX1cMul19x4rW1bdZwunkJ7NnD3Ixz64WrKcfuSixnkYh1z4jSqmYOgkEWenQWlMKP9XclH47nnbYgxUqCPHkMNDhCfnWr3PcSnz+BsG+n6TFYKl3bizZjAayEN+suMVb3Z62itg53ej9/wRQ4WP4yudotu7pf3ovqXk22dSq8H3v71rmw/gLNQJ/nVC5hcDnHN9jVJNAC6tyke+czzyFtv6Npn7r6F5O9+3r7+e979zVXPf2KNgN//rm8gGzFyoYrM+ohEY6TEVOuIXKYtDnLwtgetpPVstc1alPOVNa/znnd/E1UN0C+9gmh50enEBvvYKM7Y6KrPdb2AX3W9VyDP/vUgDfrLjFU/JmNslvmm61fptIFNRE3s/Rym7xrk0eXpvbrxOpiaXX5cKtlRznUQ07Nt+afWax5++luMj36C5Ow55LHVUtAHvA/yRPjnPP6zb9gy4c03oH/xnF2vNzn54u9+3iUT/eTffNUyCnsLJHkf8cOnuxiKB+56GDVXRWV9RK1BcnIS2ddDsn2QeOc+nCXbUtv+KFyF8QRqsdqejo/f8EXGb/xyW6dg/JavICo1XNfBZH2ckeEuD8HW6+9X71/z8z/fTbaFzvf4ZkAa9FcY4pOnUDffYFtb14O2TjaidwWfvKe0/PfIIObcNMn8As7oCHqoFwWY+rLGnPC8dX/QYt+1XY/lwpJtVNMG/Yvn2tz7KO+veq5cqKJ/+XyXtDdgBTBOTWLipnzXu96KnKmipheRdcu+073La381V4Uw6pq1RCNlVEfDEFNz6EoFsWMbSd5DhXlYYRwK6zfIdL7eenitTTlXKtKgfwOxEW7+WtPI8Ru/jH71RDvpt1atflUOYGp2TSWfTk4AYOm0zjKXYGLnZ6zYRQdDMD6+/KNvjYrrvZdDx75nZwbGdr61ZgwA0bY+1NmpdtCLv3+axGjU0CACIJ9F1Ku2opDxONzUpTt4+/LSxH3OXsv4zb9vNQObmgLmzBRKCJKXXrHWV9OzOCPDy+/h9Bkmdnya+NRpEKLNte/se1gPb6apPaRB/4biQgG/Eq215IUkt9aEWbuBvPNGcOjY96zTzasdQd2R6DrgfRCEbAdIV0Z7hQZ8Z3AnpybbgdI5rW6x8VrUVj15Ft1oYIb70EohK7W2Zv346Cfaz5PTC9bNZmaRZNp2jKooxAwNgBBd/fBgJa06VXL2y3utQ22T89D5Pi72O3kzIC3ZXUa81rLQeM9HGB9cV4EMWA7uVglr3eNe+O66/HGTJKv2Tex+gPFbvrKK2Sb7+xi/xXLfO7nra3WvObt2WCnvnWMc0Y+16/tdGOhl/PovWIefYs6SdKREXb+XI8kPODz7bxGV6po3RB0E3Ruk6rqON9vIfbFIR/rLiAv++ISwWfmectcIvVK8sYW11FfXk24eH/0Eemb2vN1kqkOkc63rbVURjujHODz5J6tkptbCxNinIOMjGisC05FQqTI+/HFEMW+77bTGFPOIerCq6xAsZXktrLzRbMXR/HxIR/orGEeSH9iAWmNtvhYeX/jTtQk0a+Dw5J9Y3vr5sAaHvev1Kv++60aw1og9sfsB2xDUhCkVLLNuZh5RXw78J374kL2mKMRMz3LoxL/k0Kl/hQhCzNJqT8CJXfejBvoZ7/nImte2lq7deM9H3tSkm40iDfo3Gc6n+LoS53Nq2S/vXXdGsRG0guvQK3/ModP/uk3yOfzst63HnueCEExs+2Q3k3BooOt1TSOAOO7q+gPbQHPoxL9c/xrXyGkcnv93W35qD2nQX5GY2PmZbiZcE/vlvRzwf2vVen690e71YKWZw0bRyiGsDK6uWrg20N+DyXgcOv2v25WHA3c83NXpd/D2r1mijVIIz+1K7nXq+q15/ckPVt0oUlikyjkpXjfWY6ydj8k2se2T6IHeLlbcWk0wE9d+HsIIvbCIXlpaMzE4fuOXEUu1q1q37lIjVc65ynEpNdxWaeutgY2w1DqxZsCr969yAeo6TgiMryxvwPVgoAddzKw6j5mdWzen0SrNvaaS5hZGOr2/CnApRRu7DDPXg15HJP4isIoBJxUTOz69/NhzUecWEMUienERpucRz3T7okzsfuC8ScyLyV+kWEYa9Cm6sF/ee0mmySultZyx0fZ5J8Y+RTJYRs8vLLv7NNHZo9+pu79f3ptm3i8R0ul9im7IC5TxXiNW8dd//gI6CjsOiNGNBvz0mfYm0SHcoYaHoFzclGvbati0kV4IcU/z35r6REKI97XMLzq2zQkhjgghvrBZ13UlozWardcRdinOf6GS1WYRWZztY6u2qeFlfzlRyCMzmfb1Tez8DMkLLzPebx1bDk/+CZyZ2pRr22q4XFbVGGP+Qgixkkt671ZytlmJza4hv9E16s6bzKHj/4KJHZ8mOXvOauLpBNEhdbUycdhaHnTeAJPK2r30nbz/FBuAMWbT/mG96b5/nv1HVjx+H7BnrWPvuOMOk+LNhfEdn15z+373A6/tfNv/X6/jat5cAH5s1om7y2pVvQb6gFkhxPdX7mi51rb+dbhzprgMuBRJNb0Gd3586GPInnKX+cT48MdXtwSvga1ep3/00Ufb8cF5XGs3nZzTDOAjZg2raiHEEdP0t1ux/TvAjzqfk5Jzri5spNbfunFcaNmxUv47xYVxPnLOpoz0QojvCCFa5vHznMd3vuM59zVzASmuQFzsyH7o2PeY2HX/qqTkyhFblUqcD+M9H8EsVdOAv4S4LFbVzb/vAe4UQryvuekHze3vA5vo26RrS/EG4dCx760mFjnLuWPheoiBvrZi7Vo4PP/v1iXhpHX714j1FvtX2r80kXd5cY9433n3j2/75Gs+937v/7H6fNfc/5rPl+L8iby04SZFijch3vA1fYoUm4UWWSfFa0dKw01x2dAlUNkS0rxARr/l3pvitSMd6VOk2GJIR/oUF4WNWjxtiOe/xv5UzmrzkY70KS4KGw3KNHivXKRBnyLFFkMa9ClSbDGkQZ8ixRZDGvQpUmwxpEGfIsUWQxr0KVJsMaRBnyLFFkMa9ClSbDGkQZ8ixRZDGvQpUmwxpEGfIsUWQxr0KVJsMaRBnyLFFkMa9ClSbDGkQZ8ixRZDGvQpUmwxpEGfIsUWw5VmVf2+5nNSydMUKTYJm2Vr1bKqfhK4XQixZ+UxZoWDTYezzZPNx/dsxrVdTmxV082t+L6v5Pe8KUFvjHnKWG/6HuCoWeFNvw7uAlrHHQXedL52V/IPYTOxFd/3lfyeN1sN92KsqntWPO7vfNCyqm7hvvvu47770lVAihQtPProo503myvfqrq59j9ijHmyObXfb4z5YsexU8CxTb3YzccAMH25L+IyYCu+78v9nncZYwbX2rEpI30zgF821q12ng1YVQM/Ynm03wN0JfnWewMpUqS4OFwxVtXNmcCejuc8uUnXliLFlsZV41qbIkWKS4OUnLNJEELMCSGOCCG+sMa+24UQLwshftL8tyaX4WrD+d5zc/+bkoexgff9heb7XnP/G43Uy27zcO95lih9xpi90OY0zL9hV7W5WPc9N5dtR40xTzUD4HZjzFNv8PVtFs73vr8AzDcT1LdfCe87Hek3Dz1rkZJgmYDUxJ4N8hiuBqz7noEfA481b3J7LvcP/xLjfO+7H5jteHzZSWdp0G8e+oDZZslyTQgh7lurlHkVY933bIyZxyZ4HwPueIOva7Nxvu/6+8BdTaLa3jf0qtZBGvSbBGPMo80f+nyrQrEG9r+Bl7TpON97bk7vn2wua873mVx1ON/7NsYcbfJN+rBEtcs+q0uDfhMghLivOY093zE9b9DlvCHYwHvuXMt+m41xN654XOh9N9fx72su4e66EmZ2adBvDn4AXU1Ef9F83Ek46qN7rXe140Lv+dFmgNwDvL/F3XgT4Lzvu3Wja+7/9mW6xi6kdfoUKbYY0pE+RYothjToU6TYYkiDPkWKLYY06FOk2GJIgz7FBSGE+P6l5Ms3uehvin6DqxFp0KfYCPZ0tEeblfqFzZvCYxs9mTHmu7wJ5dCuFqRBn+Ji8RTw0RXb1uOdp7gCkQb9FocQ4jutkVsI8dgGmYKzreOa0/72KC+E2NNsM/1+s314T3P795vn3/CMIMXmIG2t3eIwxnyxGYz7ge83OeQXwmPA+4FHsf0D/5TuPoKjxpiPNlloHxVCvAz85E3EwruqkY70KcB2gt2zUYmy5nH3Nkfx8zWQPIldu9+Bba1NcQUgDfoUYNfo377IDP1TwBexN4z1cA/2pvAyVg49xRWANOi3OJo94F9sNorccaHuwA58H6sAtNZIf2fzvB9tnvu7zXOna/orAGnDTYoLotOfYAPH7sEG+soM/2s+Z4pLi3SkT5FiiyEN+hQbwdGNrvebSjEXGuW/gM0JpLgMSKf3KVJsMaQjfYoUWwxp0KdIscWQBn2KFFsMadCnSLHFkAZ9ihRbDGnQp0ixxfD/B/o5n2LxClruAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(1)\n", "hist, xbins, ybins = np.histogram2d(\n", " SD.gas.coordinates[bound_mask.gas, 0],\n", " SD.gas.coordinates[bound_mask.gas, 1],\n", " bins=200\n", ")\n", "sp1 = fig.add_subplot(1, 1, 1)\n", "sp1.imshow(\n", " np.log10(hist.T),\n", " origin='lower',\n", " extent=(xbins[0], xbins[-1], ybins[0], ybins[-1])\n", ")\n", "sp1.set_xlabel('x [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "sp1.set_ylabel('y [{:s}]'.format(str(SD.gas.coordinates.units)))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## SWIFTGalaxy\n", "\n", "The above demos of `velociraptor` + `SWIFTSimIO` have a lot of steps. It would be nice to simply specify a snapshot file and a halo ID and get directly a \"galaxy\" object that we can work with. This is the purpose of `SWIFTGalaxy`, currently a prototype package. https://github.com/kyleaoman/swiftgalaxy" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "from swiftgalaxy import SWIFTGalaxy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need to specify the halo catalogue file and the halo ID of interest in addition to the snapshot file. Some other options are also available." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "SG = SWIFTGalaxy(\n", " snapshot_filename,\n", " velociraptor_filebase,\n", " target_halo_index,\n", " extra_mask='bound_only', # default is None, but let's select bound particles\n", " auto_recentre=True, # the default\n", " centre_type='minpot' # the default\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The galaxy is automatically centred on the potential minimum (including wrapping the box as needed). Coordinate transformations are implemented so that all particles keep a consistent reference frame, even if loaded later. This also works for translations, velocity \"boosts\", and sequences of coordinate transformations. For example, to rotate the galaxy around the `z`-axis:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "SG.rotate(angle_axis=(180 * u.deg, 'z'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Some additional coordinate systems are provided for convenience, again evaluated lazily:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "unyt_array([[ 0.02364763, 0.02302472, 0.02202408, ..., -0.12558923,\n", " -0.1082952 , -0.12177451],\n", " [ 0.13688264, 0.13261438, 0.13609136, ..., -0.10736809,\n", " -0.12407305, -0.12811315],\n", " [-0.01746863, -0.01292512, -0.00812225, ..., 0.11841354,\n", " 0.12458489, 0.11510016]], 'Mpc')" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "SG.gas.spherical_coordinates.r\n", "SG.gas.spherical_coordinates.lon\n", "SG.gas.spherical_coordinates.lat\n", "SG.gas.cylindrical_coordinates.R # or .rho\n", "SG.gas.cylindrical_coordinates.phi # or .lon\n", "SG.gas.cylindrical_coordinates.z\n", "SG.gas.cartesian_coordinates.x\n", "SG.gas.cartesian_coordinates.y\n", "SG.gas.cartesian_coordinates.z\n", "SG.gas.cartesian_coordinates.xyz" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's plot the particle distribution again. Notice two differences: the image is rotated 180 degrees (due to the call to `rotate` above), and is centred at `(0, 0)` instead of being in box coordinates." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(1)\n", "hist, xbins, ybins = np.histogram2d(\n", " SG.gas.coordinates[:, 0],\n", " SG.gas.coordinates[:, 1],\n", " bins=200\n", ")\n", "sp1 = fig.add_subplot(1, 1, 1)\n", "sp1.imshow(\n", " np.log10(hist.T),\n", " origin='lower',\n", " extent=(xbins[0], xbins[-1], ybins[0], ybins[-1])\n", ")\n", "sp1.set_xlabel('x [{:s}]'.format(str(SG.gas.coordinates.units)))\n", "sp1.set_ylabel('y [{:s}]'.format(str(SG.gas.coordinates.units)))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These features simplify the analysis of simulated galaxies. For example, producing a circular velocity curve is reduced to a few lines of code (please excuse some hideous unit manipulation revealing my limited experience with `unyt` - I ran into some overflow issues that I don't quite understand and just hacked together a work-around until it went away... I'm sure there's a better way though!):" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "ptypes = ['gas', 'dark_matter', 'stars']\n", "r_all = np.concatenate([SG.__getattribute__(t).spherical_coordinates.r.to_value(u.kpc) for t in ptypes]) * u.kpc\n", "M_all = np.concatenate([SG.__getattribute__(t).masses.to_value(u.Msun) for t in ptypes]) * u.Msun\n", "rsort = np.argsort(r_all)\n", "r_all = r_all[rsort]\n", "M_all = M_all[rsort]\n", "vc_all = np.sqrt(u.physical_constants.G * np.cumsum(M_all.to_value(u.Msun)) * u.Msun / r_all).to(u.km / u.s)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, '$v_{circ}$ [km/s]')" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "sample_r = np.linspace(.1, 30, 200) * u.kpc\n", "fig = plt.figure(1)\n", "sp = fig.add_subplot(1, 1, 1)\n", "sp.plot(sample_r, np.interp(sample_r, r_all, vc_all), '-r')\n", "sp.set_xlabel(r'$r$ '+'[{:s}]'.format(str(sample_r.units)))\n", "sp.set_ylabel(r'$v_{circ}$ '+'[{:s}]'.format(str(vc_all.units)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 4 }