diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml index a1da8b2..b09bc27 100644 --- a/.github/workflows/push.yml +++ b/.github/workflows/push.yml @@ -8,7 +8,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.7", "3.8", "3.9", "3.10"] + python-version: ["3.8", "3.9", "3.10"] steps: - uses: actions/checkout@v4 @@ -16,10 +16,11 @@ jobs: uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} + cache: 'pip' - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install importlib-metadata==4.13.0 + python -m pip install --upgrade "jax[cpu]" python -m pip install .[dev] - name: Lint with flake8 run: | @@ -30,9 +31,9 @@ jobs: #mypy ./croissant/ - name: Test with pytest run: | - pytest --cov=croissant --cov-report=xml tests/ + pytest --cov=croissant --cov-report=xml croissant/tests croissant/core/tests croissant/jax/tests - name: Upload coverage to Codecov - uses: codecov/codecov-action@v3 + uses: codecov/codecov-action@v4 with: token: ${{ secrets.CODECOV_TOKEN }} fail_ci_if_error: true diff --git a/README.md b/README.md index de82065..01768ef 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,8 @@ Overall, this makes CROISSANT a very fast visibility simulator. CROISSANT can th ## Installation For the latest release, do `pip install croissant-sim` (see https://pypi.org/project/croissant-sim). Git clone this repository for the newest changes (this is under activate development, do so at your own risk!). +To access the JAX features, JAX must also be installed. See the [installation guide](https://github.com/google/jax#installation). + ## Demo Jupyter Notebook: https://nbviewer.org/github/christianhbye/croissant/blob/main/notebooks/example_sim.ipynb diff --git a/croissant/__init__.py b/croissant/__init__.py index c424027..b45cb53 100644 --- a/croissant/__init__.py +++ b/croissant/__init__.py @@ -1,9 +1,9 @@ __author__ = "Christian Hellum Bye" -__version__ = "3.0.0" +__version__ = "4.0.0" -from . import constants, dpss, sphtransform -from .healpix import Alm, HealpixMap -from .beam import Beam -from .rotations import Rotator -from .simulator import Simulator -from .sky import Sky +from . import constants +from . import core +from . import dpss +from . import jax +from . import utils +from .core import * # noqa F403 diff --git a/croissant/constants.py b/croissant/constants.py index 902ba2e..c472bf6 100644 --- a/croissant/constants.py +++ b/croissant/constants.py @@ -1,7 +1,4 @@ -import numpy as np - -# nside's for which healpix has computed pixel weights: -PIX_WEIGHTS_NSIDE = (32, 64, 128, 256, 512, 1024, 2048, 4096) +from math import pi, sqrt # sidereal days in seconds # https://nssdc.gsfc.nasa.gov/planetary/factsheet/earthfact.html @@ -9,4 +6,7 @@ # https://nssdc.gsfc.nasa.gov/planetary/factsheet/moonfact.html sidereal_day_moon = 655.720 * 3600 -Y00 = 1 / np.sqrt(4 * np.pi) # the 0,0 spherical harmonic function +sidereal_day = {"earth": sidereal_day_earth, "moon": sidereal_day_moon} + +Y00 = 1 / sqrt(4 * pi) # the 0,0 spherical harmonic function +PIX_WEIGHTS_NSIDE = (32, 64, 128, 512, 1024, 2048, 4096) diff --git a/croissant/core/__init__.py b/croissant/core/__init__.py new file mode 100644 index 0000000..b30f85b --- /dev/null +++ b/croissant/core/__init__.py @@ -0,0 +1,6 @@ +from . import simulator, sphtransform +from .healpix import Alm, HealpixMap +from .beam import Beam +from .rotations import Rotator +from .simulator import Simulator +from .sky import Sky diff --git a/croissant/beam.py b/croissant/core/beam.py similarity index 98% rename from croissant/beam.py rename to croissant/core/beam.py index a499e6d..39dc236 100644 --- a/croissant/beam.py +++ b/croissant/core/beam.py @@ -1,7 +1,7 @@ from healpy import npix2nside, pix2ang import numpy as np -from .constants import Y00 +from ..constants import Y00 from .healpix import Alm from .sphtransform import map2alm diff --git a/croissant/healpix.py b/croissant/core/healpix.py similarity index 95% rename from croissant/healpix.py rename to croissant/core/healpix.py index d10fe05..f554189 100644 --- a/croissant/healpix.py +++ b/croissant/core/healpix.py @@ -3,34 +3,12 @@ from scipy.interpolate import RectSphereBivariateSpline import warnings -from . import constants +from .. import constants +from ..utils import coord_rep from .rotations import Rotator from .sphtransform import alm2map, map2alm -def coord_rep(coord): - """ - Shorthand notation for coordinate systems. - - Parameters - ---------- - coord : str - The name of the coordinate system. - - Returns - ------- - rep : str - The one-letter shorthand notation for the coordinate system. - - """ - coord = coord.upper() - if coord[0] == "E" and coord[1] == "Q": - rep = "C" - else: - rep = coord[0] - return rep - - def healpix2lonlat(nside, pix=None): """ Compute the longtitudes and latitudes of the pixel centers of a healpix @@ -567,14 +545,7 @@ def rot_alm_z(self, phi=None, times=None, world="moon"): """ if times is not None: - if world.lower() == "moon": - sidereal_day = constants.sidereal_day_moon - elif world.lower() == "earth": - sidereal_day = constants.sidereal_day_earth - else: - raise ValueError( - f"World must be 'moon' or 'earth', not {world}." - ) + sidereal_day = constants.sidereal_day[world] phi = 2 * np.pi * times / sidereal_day return self.rot_alm_z(phi=phi, times=None) diff --git a/croissant/rotations.py b/croissant/core/rotations.py similarity index 82% rename from croissant/rotations.py rename to croissant/core/rotations.py index 4536396..b579441 100644 --- a/croissant/rotations.py +++ b/croissant/core/rotations.py @@ -1,69 +1,12 @@ from astropy.coordinates import AltAz, EarthLocation import healpy as hp -from lunarsky import LunarTopo, MoonLocation, SkyCoord +from lunarsky import LunarTopo, MoonLocation import numpy as np +from ..utils import get_rot_mat, rotmat_to_euler from .sphtransform import map2alm, alm2map -def get_rot_mat(from_frame, to_frame): - """ - Get the rotation matrix that transforms from one frame to another. - - Parameters - ---------- - from_frame : str or astropy frame - The coordinate frame to transform from. - to_frame : str or astropy frame - The coordinate frame to transform to. - - Returns - ------- - rmat : np.ndarray - The rotation matrix. - - """ - # cannot instantiate a SkyCoord with a gaalctic frame from cartesian - from_name = from_frame.name if hasattr(from_frame, "name") else from_frame - if from_name.lower() == "galactic": - from_frame = to_frame - to_frame = "galactic" - return_inv = True - else: - return_inv = False - x, y, z = np.eye(3) # unit vectors - sc = SkyCoord( - x=x, y=y, z=z, frame=from_frame, representation_type="cartesian" - ) - rmat = sc.transform_to(to_frame).cartesian.xyz.value - if return_inv: - rmat = rmat.T - return rmat - - -def rotmat_to_euler(mat): - """ - Convert a rotation matrix to Euler angles in the ZYX convention. This is - sometimes referred to as Tait-Bryan angles X1-Y2-Z3. - - Parameters - ---------- - mat : np.ndarray - The rotation matrix. - - Returns - -------- - eul : tup - The Euler angles. - - """ - beta = np.arcsin(mat[0, 2]) - alpha = np.arctan2(mat[1, 2] / np.cos(beta), mat[2, 2] / np.cos(beta)) - gamma = np.arctan2(mat[0, 1] / np.cos(beta), mat[0, 0] / np.cos(beta)) - eul = (gamma, beta, alpha) - return eul - - class Rotator(hp.Rotator): def __init__( self, @@ -90,7 +33,8 @@ def __init__( rot : sequence of floats Euler angles in degrees (or radians if deg=False) describing the rotation. The order of the angles depends on the value of - eulertype. + ``eulertype''. When ``eulertype'' is "ZYX", the angles are + (yaw, -pitch, roll). coord : sequence of strings Coordinate systems to rotate between. Supported values are "G" (galactic), "C" (equatorial), "E" (ecliptic), "M" (MCMF), diff --git a/croissant/simulator.py b/croissant/core/simulator.py similarity index 80% rename from croissant/simulator.py rename to croissant/core/simulator.py index 53ecfc2..88cdfa2 100644 --- a/croissant/simulator.py +++ b/croissant/core/simulator.py @@ -1,64 +1,10 @@ -from astropy import units from astropy.coordinates import EarthLocation from copy import deepcopy from lunarsky import MoonLocation, Time import matplotlib.pyplot as plt import numpy as np -import warnings -from . import dpss - - -def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): - """ - Generate an array of evenly sampled times to run the simulation at. - - Parameters - ---------- - t_start : str or astropy.time.Time - The start time of the simulation. - t_end : str or astropy.time.Time - The end time of the simulation. - N_times : int - The number of times to run the simulation at. - delta_t : float or astropy.units.Quantity - The time step between each time in the simulation. - - Returns - ------- - times : astropy.time.Time or astropy.units.Quantity - The evenly sampled times to run the simulation at. - - """ - - if t_start is not None: - t_start = Time(t_start, scale="utc") - - try: - dt = np.arange(N_times) * delta_t - except TypeError: - t_end = Time(t_end, scale="utc") - total_time = (t_end - t_start).sec - if N_times is None: - try: - delta_t = delta_t.to_value("s") - except AttributeError: - warnings.warn( - "delta_t is not an astropy.units.Quantity. Assuming " - "units of seconds.", - UserWarning, - ) - dt = np.arange(0, total_time + delta_t, delta_t) - else: - dt = np.linspace(0, total_time, N_times) - dt = dt * units.s - - if t_start is None: - times = dt - else: - times = t_start + dt - - return times +from .. import dpss class Simulator: @@ -73,7 +19,9 @@ def __init__( times=None, ): """ - Simulator class. Prepares and runs simulations. + BaseSimulator class. Prepares simulations. End users should use the + subclasses in core/simulator.py and crojax/simulator.py to + instantiate this class and run simulations. """ self.world = world.lower() # set up frequencies to run the simulation at diff --git a/croissant/sky.py b/croissant/core/sky.py similarity index 93% rename from croissant/sky.py rename to croissant/core/sky.py index db30ec9..633b834 100644 --- a/croissant/sky.py +++ b/croissant/core/sky.py @@ -1,5 +1,5 @@ import numpy as np -from pygdsm import GlobalSkyModel2016 as GSM16 +from pygdsm import GlobalSkyModel16 as GSM16 from .healpix import Alm from .sphtransform import map2alm diff --git a/croissant/core/sphtransform.py b/croissant/core/sphtransform.py new file mode 100644 index 0000000..613e4b5 --- /dev/null +++ b/croissant/core/sphtransform.py @@ -0,0 +1,77 @@ +import numpy as np +import healpy as hp +from ..constants import PIX_WEIGHTS_NSIDE + + +def alm2map(alm, nside, lmax=None): + """ + Compute the healpix map from the spherical harmonics coefficients. + + Parameters + ---------- + alm : array-like + The spherical harmonics coefficients in the healpy convention. Shape + ([nfreq], hp.Alm.getsize(lmax)). + nside : int + The nside of the output map(s). + lmax : int + The lmax of the spherical harmonics transform. Defaults to 3*nside-1. + + Returns + ------- + map : np.ndarray + The healpix map. Shape ([nfreq], hp.nside2npix(nside)). + + """ + alm = np.array(alm, copy=True) + if alm.ndim == 1: + return hp.alm2map(alm, nside, lmax=lmax) + else: + npix = hp.nside2npix(nside) + nfreqs = alm.shape[0] + hp_map = np.empty((nfreqs, npix)) + for i in range(nfreqs): + map_i = hp.alm2map(alm[i], nside, lmax=lmax) + hp_map[i] = map_i + return hp_map + + +def map2alm(data, lmax=None): + """ + Compute the spherical harmonics coefficents of a healpix map. + + Parameters + ---------- + data : array-like + The healpix map(s). Shape ([nfreq], hp.nside2npix(nside)). + lmax : int + The lmax of the spherical harmonics transform. Defaults to 3*nside-1. + + Returns + ------- + alm : np.ndarray + The spherical harmonics coefficients in the healpy convention. Shape + ([nfreq], hp.Alm.getsize(lmax)). + + """ + data = np.array(data, copy=True) + npix = data.shape[-1] + nside = hp.npix2nside(npix) + use_pix_weights = nside in PIX_WEIGHTS_NSIDE + use_ring_weights = not use_pix_weights + kwargs = { + "lmax": lmax, + "pol": False, + "use_weights": use_ring_weights, + "use_pixel_weights": use_pix_weights, + } + if data.ndim == 1: + alm = hp.map2alm(data, **kwargs) + else: + # compute the alms of the first map to determine the size of the array + alm0 = hp.map2alm(data[0], **kwargs) + alm = np.empty((len(data), alm0.size), dtype=alm0.dtype) + alm[0] = alm0 + for i in range(1, len(data)): + alm[i] = hp.map2alm(data[i], **kwargs) + return alm diff --git a/tests/__init__.py b/croissant/core/tests/__init__.py similarity index 100% rename from tests/__init__.py rename to croissant/core/tests/__init__.py diff --git a/tests/test_beam.py b/croissant/core/tests/test_beam.py similarity index 100% rename from tests/test_beam.py rename to croissant/core/tests/test_beam.py diff --git a/tests/test_healpix.py b/croissant/core/tests/test_healpix.py similarity index 98% rename from tests/test_healpix.py rename to croissant/core/tests/test_healpix.py index 776143a..a177231 100644 --- a/tests/test_healpix.py +++ b/croissant/core/tests/test_healpix.py @@ -4,13 +4,7 @@ import pytest from croissant import healpix as hp, sphtransform as spht from croissant.constants import sidereal_day_earth, sidereal_day_moon, Y00 - - -def test_coord_rep(): - coords = ["galactic", "equatorial", "ecliptic", "mcmf", "topocentric"] - short = ["G", "C", "E", "M", "T"] - for i in range(len(coords)): - assert hp.coord_rep(coords[i]) == short[i] +from croissant.utils import coord_rep def test_healpix2lonlat(): @@ -301,7 +295,7 @@ def test_from_healpix(): alm = hp.Alm.from_healpix(hp_map, lmax=lmax) assert alm.lmax == lmax assert np.allclose(alm.frequencies, freqs) - assert alm.coord == hp.coord_rep(coord) + assert alm.coord == coord_rep(coord) assert np.allclose(alm.alm, spht.map2alm(data, lmax=lmax)) diff --git a/tests/test_rotations.py b/croissant/core/tests/test_rotations.py similarity index 56% rename from tests/test_rotations.py rename to croissant/core/tests/test_rotations.py index f721bea..43976ab 100644 --- a/tests/test_rotations.py +++ b/croissant/core/tests/test_rotations.py @@ -1,6 +1,6 @@ -from astropy.coordinates import AltAz, EarthLocation +from astropy.coordinates import EarthLocation import healpy as hp -from lunarsky import LunarTopo, MCMF, MoonLocation, SkyCoord, Time +from lunarsky import MoonLocation, Time import numpy as np import pytest @@ -35,71 +35,6 @@ def test_rotator_init(): rotations.Rotator(coord=["T", "M"], loc=loc) -def test_get_rot_mat(): - # check that we agree with healpy for galactic -> equatorial - rot_mat = rotations.get_rot_mat("galactic", "fk5") - rot = hp.Rotator(coord=["G", "C"]) - assert np.allclose(rot_mat, rot.mat) - - # equatorial -> galactic - rot_mat = rotations.get_rot_mat("fk5", "galactic") - rot = hp.Rotator(coord=["C", "G"]) - assert np.allclose(rot_mat, rot.mat) - - # check that we agree with astropy for equatorial -> AltAz - time = Time("2022-06-16 17:00:00") - loc = EarthLocation(lon=0, lat=40) - to_frame = AltAz(obstime=time, location=loc) - rot_mat = rotations.get_rot_mat("fk5", to_frame) - x, y, z = np.eye(3) - xp, yp, zp = ( - SkyCoord(x=x, y=y, z=z, frame="fk5", representation_type="cartesian") - .transform_to(to_frame) - .cartesian.xyz.value - ) - assert np.allclose(rot_mat, np.array([xp, yp, zp])) - - # MCMF -> AltAz - loc = MoonLocation(lon=0, lat=40) - to_frame = LunarTopo(obstime=time, location=loc) - rot_mat = rotations.get_rot_mat("mcmf", to_frame) - xp, yp, zp = ( - SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") - .transform_to(to_frame) - .cartesian.xyz.value - ) - assert np.allclose(rot_mat, np.array([xp, yp, zp])) - - # galactic -> MCMF - # in this case we have to invert the matrix that does MCMF -> galactic - # since we cannot instantiate a galactic frame from cartesian coords - rot_mat = rotations.get_rot_mat("galactic", MCMF()) - xp, yp, zp = ( - SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") - .transform_to("galactic") - .cartesian.xyz.value - ) - assert np.allclose(rot_mat, np.array([xp, yp, zp]).T) - - -def test_rotmat_to_euler(): - # check that rotmat_to_euler is the inverse of euler_matrix_new - rot_mat = rotations.get_rot_mat("galactic", "fk5") - eul = rotations.rotmat_to_euler(rot_mat) - rmat = hp.rotator.get_rotation_matrix(eul)[0] - assert np.allclose(rot_mat, rmat) - - rot_mat = rotations.get_rot_mat("galactic", "mcmf") - eul = rotations.rotmat_to_euler(rot_mat) - rmat = hp.rotator.get_rotation_matrix(eul)[0] - assert np.allclose(rot_mat, rmat) - - rot_mat = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) - eul = rotations.rotmat_to_euler(rot_mat) - rmat = hp.rotator.get_rotation_matrix(eul)[0] - assert np.allclose(rot_mat, rmat) - - def test_rotate_alm(): lmax = 10 size = hp.Alm.getsize(lmax) diff --git a/tests/test_simulator.py b/croissant/core/tests/test_simulator.py similarity index 99% rename from tests/test_simulator.py rename to croissant/core/tests/test_simulator.py index 2741fbe..17e8a44 100644 --- a/tests/test_simulator.py +++ b/croissant/core/tests/test_simulator.py @@ -8,7 +8,7 @@ from croissant import Beam, dpss, Rotator, Simulator, Sky from croissant.constants import sidereal_day_earth -from croissant.simulator import time_array +from croissant.utils import time_array # define default params for simulator @@ -32,7 +32,6 @@ def test_time_array(): - # check that the times are set consistently regardless of # which parameters that specify it delta_t, step = np.linspace(0, sidereal_day_earth, N_times, retstep=True) @@ -57,7 +56,6 @@ def test_time_array(): def test_simulator_init(): - sim = Simulator(*args, **kwargs) # check that the simulation attributes are set properly assert sim.sim_coord == "M" # mcmf diff --git a/tests/test_sphtransform.py b/croissant/core/tests/test_sphtransform.py similarity index 97% rename from tests/test_sphtransform.py rename to croissant/core/tests/test_sphtransform.py index 744dcc2..73b5fb2 100644 --- a/tests/test_sphtransform.py +++ b/croissant/core/tests/test_sphtransform.py @@ -2,7 +2,7 @@ import numpy as np from croissant.constants import Y00 -from croissant.sphtransform import alm2map, map2alm +from croissant.core.sphtransform import alm2map, map2alm def test_alm2map(): diff --git a/croissant/jax/README.md b/croissant/jax/README.md new file mode 100644 index 0000000..e69de29 diff --git a/croissant/jax/__init__.py b/croissant/jax/__init__.py new file mode 100644 index 0000000..18e57f2 --- /dev/null +++ b/croissant/jax/__init__.py @@ -0,0 +1,6 @@ +# enable double precision +from jax import config + +config.update("jax_enable_x64", True) + +from . import alm, rotations, simulator diff --git a/croissant/jax/alm.py b/croissant/jax/alm.py new file mode 100644 index 0000000..6154b3e --- /dev/null +++ b/croissant/jax/alm.py @@ -0,0 +1,174 @@ +from functools import partial +import jax +import jax.numpy as jnp +from ..constants import Y00 + + +@partial(jax.jit, static_argnums=(1,)) +def total_power(alm, lmax): + """ + Compute the integral of a signal (such as an antenna beam) given + the spherical harmonic coefficients. This is needed to normalize the + visibilities. Only the monoopole component will integrate to + a non-zero value. + + Parameters + ---------- + alm : jnp.ndarray + The spherical harmonic coefficients. The last two dimensions must + correspond to the ell and emm indices respectively. + lmax : int + The maximum l value. + + Returns + ------- + power : float + The total power of the signal. + + """ + # get the index of the monopole component + lix, mix = getidx(lmax, 0, 0) + monopole = alm[..., lix, mix] + return jnp.real(monopole) / Y00 + + +@jax.jit +def getidx(lmax, ell, emm): + """ + Get the index of the alm array for a given l and m. + + Parameters + ---------- + lmax : int + The maximum l value. + ell : int or jnp.ndarray + The value of l. + emm : int or jnp.ndarray + The value of m. + + Returns + ------- + l_ix : int or jnp.ndarray + The l index (which is the same as the input ell). + m_ix : int or jnp.ndarray + The m index. + + """ + return ell, emm + lmax + + +@jax.jit +def getlm(lmax, ix): + """ + Get the l and m corresponding to the index of the alm array. + + Parameters + ---------- + lmax : int + The maximum l value. + + ix : jnp.ndarray + The indices of the alm array. The first row corresponds to the l + index, and the second row corresponds to the m index. Multiple + indices can be passed in as an array with shape (2, n). + + Returns + ------- + ell : jnp.ndarray + The value of l. Has shape (n,). + emm : jnp.ndarray + The value of m. Has shape (n,). + + """ + ell = ix[0] + emm = ix[1] - lmax + return ell, emm + + +def lmax_from_shape(shape): + """ + Get the lmax from the shape of the alm array. + + Parameters + ---------- + shape : tuple + The shape of the alm array. The last two dimensions must correspond + to the ell and emm indices respectively. + + Returns + ------- + lmax : int + The maximum l value. + + """ + return shape[-2] - 1 + + +def is_real(alm): + """ + Check if the an array of alms correspond to a real-valued + signal. Mathematically, this is true if the coefficients satisfy + alm(l, m) = (-1)^m * conj(alm(l, -m)). + + Parameters + ---------- + alm : jnp.ndarray + The spherical harmonics coefficients. The last two dimensions + must correspond to the ell and emm indices respectively. + + Returns + ------- + is_real : bool + True if the coefficients correspond to a real-valued signal. + + """ + lmax = lmax_from_shape(alm.shape) + emm = jnp.arange(1, lmax + 1) # positive ms + # reshape emm to broadcast with alm by adding 1 or 2 dimensions + emm = emm.reshape((1,) * (alm.ndim - 1) + emm.shape) + # get alms for negative m, in reverse order (i.e., increasing abs(m)) + neg_m = alm[..., :lmax][..., ::-1] + # get alms for positive m + pos_m = alm[..., lmax + 1 :] + return jnp.all(neg_m == (-1) ** emm * jnp.conj(pos_m)).item() + + +def reduce_lmax(alm, new_lmax): + """ + Reduce the maximum l value of the alm. + + Parameters + ---------- + alm : jnp.ndarray + The alm array. Last two dimensions must correspond to the ell and + emm indices. + new_lmax : int + The new maximum l value. Must be less than the lmax of alm. + + Returns + ------- + new_alm : jnp.ndarray + The alm array with the new maximum l value. + + + """ + lmax = lmax_from_shape(alm.shape) + d = lmax - new_lmax # number of ell values to remove + return alm[..., :-d, d:-d] + + +def shape_from_lmax(lmax): + """ + Get the shape of the alm array given the maximum l value. + + Parameters + ---------- + lmax : int + The maximum l value. + + Returns + ------- + shape : tup + + """ + return (lmax + 1, 2 * lmax + 1) diff --git a/croissant/jax/rotations.py b/croissant/jax/rotations.py new file mode 100644 index 0000000..8905908 --- /dev/null +++ b/croissant/jax/rotations.py @@ -0,0 +1,30 @@ +from s2fft import generate_rotate_dls +from ..utils import get_rot_mat, rotmat_to_euler + + +def generate_euler_dl(lmax, from_frame, to_frame): + """ + Generate the Euler angles and reduced Wigner d-function values for a + coordinate transformation. + + Parameters + ---------- + lmax : int + The maximum spherical harmonic degree. + from_frame : str or astropy frame + The coordinate system of the input alm. + to_frame : str or astropy frame + The coordinate system of the output alm. + + Returns + ------- + euler : jnp.ndarray + The Euler angles for the coordinate transformation. + dl_array : jnp.ndarray + The reduced Wigner d-function values for the coordinate transformation. + + """ + rmat = get_rot_mat(from_frame, to_frame) + euler = rotmat_to_euler(rmat, eulertype="ZYZ") + dl_array = generate_rotate_dls(lmax, euler[1]) + return euler, dl_array diff --git a/croissant/jax/simulator.py b/croissant/jax/simulator.py new file mode 100644 index 0000000..f19e393 --- /dev/null +++ b/croissant/jax/simulator.py @@ -0,0 +1,69 @@ +import jax +import jax.numpy as jnp + +from .. import constants + + +def rot_alm_z(lmax, N_times, delta_t, world="moon"): + """ + Compute the complex phases that rotate the sky for a range of times. The + first time is the reference time and the phases are computed relative to + this time. + + Parameters + ---------- + lmax : int + The maximum ell value. + N_times : int + The number of times to compute the convolution at. + delta_t : float + The time difference between the times. + world : str + ``earth'' or ``moon''. Default is ``moon''. + + Returns + ------- + phases : jnp.ndarray + The phases that rotate the sky, of the form exp(-i*m*phi(t)). + Shape (N_times, 2*lmax+1). + + """ + day = constants.sidereal_day[world] + dt = jnp.arange(N_times) * delta_t + phi = 2 * jnp.pi * dt / day # rotation angle + emms = jnp.arange(-lmax, lmax + 1) # m values + phases = jnp.exp(-1j * emms[None] * phi[:, None]) + return phases + + +@jax.jit +def convolve(beam_alm, sky_alm, phases): + """ + Compute the convolution for a range of times in jax. The convolution is + a dot product in l,m space. Axes are in the order: time, freq, ell, emm. + + Note that normalization is not included in this function. The usual + normalization factor can be computed with croissant.jax.alm.total_power + of the beam alm. + + Parameters + ---------- + beam_alm : jnp.ndarray + The beam alms. Shape (N_freqs, lmax+1, 2*lmax+1). + sky_alm : jnp.ndarray + The sky alms. Shape (N_freqs, lmax+1, 2*lmax+1). + phases : jnp.ndarray + The phases that rotate the sky, of the form exp(-i*m*phi(t)). + Shape (N_times, 2*lmax+1). See the function ``rot_alm_z''. + + Returns + ------- + res : jnp.ndarray + The convolution. Shape (N_times, N_freqs). + + """ + s = sky_alm[None, :, :, :] # add time axis + p = phases[:, None, None, :] # add freq and ell axes + b = beam_alm.conjugate()[None, :, :, :] # add time axis and conjugate + res = jnp.sum(s * p * b, axis=(2, 3)) # dot product in l,m space + return res diff --git a/croissant/jax/tests/__init__.py b/croissant/jax/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/croissant/jax/tests/test_alm.py b/croissant/jax/tests/test_alm.py new file mode 100644 index 0000000..f372e72 --- /dev/null +++ b/croissant/jax/tests/test_alm.py @@ -0,0 +1,114 @@ +import jax.numpy as jnp +import numpy as np +import pytest +import s2fft +from croissant.constants import Y00 +import croissant.jax as crojax + +pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) +rng = np.random.default_rng(seed=0) + + +def test_total_power(lmax): + # make a map that is 1 everywhere so total power is 4pi: + shape = crojax.alm.shape_from_lmax(lmax) + alm = jnp.zeros(shape, dtype=jnp.complex128) + a00_idx = crojax.alm.getidx(lmax, 0, 0) + alm = alm.at[a00_idx].set(1 / Y00) + power = crojax.alm.total_power(alm, lmax) + assert jnp.isclose(power, 4 * jnp.pi) + + # m(theta) = cos(theta)**2 + alm = jnp.zeros(shape, dtype=jnp.complex128) + alm = alm.at[a00_idx].set(1 / (3 * Y00)) + a20_idx = crojax.alm.getidx(lmax, 2, 0) + alm = alm.at[a20_idx].set(4 * jnp.sqrt(jnp.pi / 5) * 1 / 3) + power = crojax.alm.total_power(alm, lmax) + expected_power = 4 * jnp.pi / 3 + assert jnp.isclose(power, expected_power) + + +def test_getidx(lmax): + # using ints + ell = 3 + emm = 2 + ix = crojax.alm.getidx(lmax, ell, emm) + ell_, emm_ = crojax.alm.getlm(lmax, ix) + assert ell == ell_ + assert emm == emm_ + + # using arrays + ls = lmax // jnp.arange(1, 10) + ms = jnp.arange(-lmax, lmax + 1) + ixs = crojax.alm.getidx(lmax, ls, ms) + ls_, ms_ = crojax.alm.getlm(lmax, ixs) + assert jnp.allclose(ls, ls_) + assert jnp.allclose(ms, ms_) + + +def test_getlm(lmax): + alm = jnp.zeros(crojax.alm.shape_from_lmax(lmax), dtype=jnp.complex128) + nrows, ncols = alm.shape + # l correspond to rows, m correspond to columns + ls = jnp.arange(nrows) + ms = jnp.arange(ncols) - lmax + for i in range(nrows): + for j in range(ncols): + ix = (i, j) + ell, emm = crojax.alm.getlm(lmax, ix) + assert ell == ls[i] + assert emm == ms[j] + + +def test_lmax_from_shape(lmax): + shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + _lmax = crojax.alm.lmax_from_shape(shape) + assert _lmax == lmax + + +def test_is_real(lmax): + alm = jnp.zeros(crojax.alm.shape_from_lmax(lmax), dtype=jnp.complex128) + assert crojax.alm.is_real(alm) + val = 1.0 + 2.0j + ix_21 = crojax.alm.getidx(lmax, 2, 1) # get index for l=2, m=1 + alm = alm.at[ix_21].set(val) # set l=2, m=1 mode but not m=-1 mode + assert not crojax.alm.is_real(alm) + ix_2m1 = crojax.alm.getidx(lmax, 2, -1) # get index for l=2, m=-1 + # set m=-1 mode to complex conjugate + alm = alm.at[ix_2m1].set(-1 * val.conjugate()) + assert crojax.alm.is_real(alm) + + # generate a real signal and check that alm.is_real is True + alm = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=True + ) + assert crojax.alm.is_real(alm) + # complex + alm = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=False + ) + assert not crojax.alm.is_real(alm) + + +def test_reduce_lmax(lmax): + signal1 = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) + # reduce lmax to new_lmax + new_lmax = 5 + signal2 = crojax.alm.reduce_lmax(signal1, new_lmax) + assert crojax.alm.lmax_from_shape(signal2.shape) == new_lmax + # confirm that signal 2 has the expected shape + expected_shape = crojax.alm.shape_from_lmax(new_lmax) + assert signal2.shape == expected_shape + # check that the signals are the same for all ell, emm + for ell in range(new_lmax + 1): + for emm in range(-ell, ell + 1): + # indexing differes since lmax differs + ix1 = crojax.alm.getidx(lmax, ell, emm) + ix2 = crojax.alm.getidx(new_lmax, ell, emm) + assert signal1[ix1] == signal2[ix2] + + +def test_shape_from_lmax(lmax): + shape = crojax.alm.shape_from_lmax(lmax) + expected_shape = s2fft.sampling.s2_samples.flm_shape(lmax + 1) + assert shape == expected_shape diff --git a/croissant/jax/tests/test_rotations.py b/croissant/jax/tests/test_rotations.py new file mode 100644 index 0000000..0db22de --- /dev/null +++ b/croissant/jax/tests/test_rotations.py @@ -0,0 +1,9 @@ +import jax.numpy as jnp +import pytest +from croissant.jax import rotations + +pytestmark = pytest.mark.parametrize("lmax", [8, 16, 64, 128]) + + +def test_generate_euler_dl(lmax): + pass diff --git a/croissant/jax/tests/test_simulator.py b/croissant/jax/tests/test_simulator.py new file mode 100644 index 0000000..5fa6ce1 --- /dev/null +++ b/croissant/jax/tests/test_simulator.py @@ -0,0 +1,91 @@ +import jax.numpy as jnp +import numpy as np +import s2fft +import pytest +from croissant.constants import sidereal_day, Y00 +from croissant.jax import alm, simulator + +rng = np.random.default_rng(0) + + +@pytest.mark.parametrize("lmax", [8, 32]) +@pytest.mark.parametrize("world", ["earth", "moon"]) +@pytest.mark.parametrize("N_times", [1, 24]) +def test_rot_alm_z(lmax, world, N_times): + + # do one sidereal day (2pi rotation), split into N_times + delta_t = sidereal_day[world] / N_times + phases = simulator.rot_alm_z(lmax, N_times, delta_t, world=world) + # expected phases + dphi = jnp.linspace(0, 2 * jnp.pi, N_times, endpoint=False) + # the m-modes range from -lmax to lmax (inclusive) + for m_index in range(phases.shape[1]): + emm = m_index - lmax # m = -lmax, -lmax+1, ..., lmax + expected = jnp.exp(-1j * emm * dphi) + assert jnp.allclose(phases[:, m_index], expected) + + # check that these phases really rotate the alm + alm_arr = s2fft.utils.signal_generator.generate_flm(rng, lmax + 1) + for i in range(N_times): + phi = dphi[i].item() + phase = phases[i] + alm_rot = alm_arr * phase[None, :] + euler = (phi, 0, 0) # rotation about z-axis + expected = s2fft.utils.rotation.rotate_flms(alm_arr, lmax + 1, euler) + assert jnp.allclose(alm_rot, expected) + + +def test_convolve(): + lmax = 32 + freq = jnp.arange(50, 251) # 50 to 250 MHz + Ntimes = 100 + delta_t = 3600 # 1 hour cadence + world = "earth" + # check that we recover sky temperature for a monopole sky + T_sky = 1e4 * (freq / 150) ** (-2.5) + sky_monopole = T_sky / Y00 # monpole component + shape = (freq.size, *alm.shape_from_lmax(lmax)) + sky = jnp.zeros(shape, dtype=jnp.complex128) + l_indx, m_indx = alm.getidx(lmax, 0, 0) + sky = sky.at[:, l_indx, m_indx].set(sky_monopole) + # the beam is achromatic, but the details don't matter + beam = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=True + ) + # normalization factor + norm = alm.total_power(beam, lmax) + # add frequency axis + beam = jnp.repeat(beam[None, :], freq.size, axis=0) + # get the phases that rotate the sky + phases = simulator.rot_alm_z(lmax, Ntimes, delta_t, world=world) + ant_temp = simulator.convolve(beam, sky, phases) / norm + assert jnp.allclose(ant_temp, T_sky) + + # for a general sky, the telescope is sensitive to the multipole moments + # that are in the beam. We consider a beam with 5 non-zero multipoles + sky = s2fft.utils.signal_generator.generate_flm( + rng, lmax + 1, reality=True + ) + shape = alm.shape_from_lmax(lmax) + beam = jnp.zeros(shape, dtype=jnp.complex128) + beam = beam.at[l_indx, m_indx].set(1.0) # monopole component + # randomly, we choose 5 (l, m) pairs + ells = rng.integers(1, lmax, size=5, endpoint=True) # random l + emms = [rng.integers(0, ell, endpoint=True) for ell in ells] # random m + # give the (l, m) mode a weight of 1 + 1j + val = 1.0 + 1j + for ell, emm in zip(ells, emms): + l_indx, m_indx = alm.getidx(lmax, ell, emm) + beam = beam.at[l_indx, m_indx].set(val) + # we need to set -m to the conjugate of m since the beam is real + neg_m_indx = alm.getidx(lmax, ell, -emm)[1] + neg_val = (-1) ** emm * val.conjugate() + beam = beam.at[l_indx, neg_m_indx].set(neg_val) + # add frequency axis, but only one frequency + ant_temp = simulator.convolve(beam[None], sky[None], phases) + # the antenna temperature is the sum of the sky temperature * beam + # over the multipoles that are in the beam + for i in range(Ntimes): + phase = phases[i] + expected = jnp.sum(sky * beam.conj() * phase[None]) + assert jnp.isclose(ant_temp[i], expected) diff --git a/croissant/sphtransform.py b/croissant/sphtransform.py deleted file mode 100644 index 275b5d5..0000000 --- a/croissant/sphtransform.py +++ /dev/null @@ -1,47 +0,0 @@ -import healpy as hp -import numpy as np - -from .constants import PIX_WEIGHTS_NSIDE - - -def alm2map(alm, nside, lmax=None): - alm = np.array(alm, copy=True) - if alm.ndim == 1: - alm.shape = (1, -1) - nfreqs = alm.shape[0] - npix = hp.nside2npix(nside) - hp_map = np.empty((nfreqs, npix)) - for i in range(nfreqs): - map_i = hp.alm2map(alm[i], nside, lmax=lmax) - hp_map[i] = map_i - return np.squeeze(hp_map) - - -def map2alm(data, lmax=None): - """ - Compute the spherical harmonics coefficents of a healpix map. - """ - - data = np.array(data) - npix = data.shape[-1] - nside = hp.npix2nside(npix) - use_pix_weights = nside in PIX_WEIGHTS_NSIDE - use_ring_weights = not use_pix_weights - kwargs = { - "lmax": lmax, - "pol": False, - "use_weights": use_ring_weights, - "use_pixel_weights": use_pix_weights, - } - if data.ndim == 1: - alm = hp.map2alm(data, **kwargs) - elif data.ndim == 2: - # compute the alms of the first map to determine the size of the array - alm0 = hp.map2alm(data[0], **kwargs) - alm = np.empty((len(data), alm0.size), dtype=alm0.dtype) - alm[0] = alm0 - for i in range(1, len(data)): - alm[i] = hp.map2alm(data[i], **kwargs) - else: - raise ValueError("Input data must be a map or list of maps.") - return alm diff --git a/croissant/tests/__init__.py b/croissant/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/croissant/tests/test_coordinates.py b/croissant/tests/test_coordinates.py new file mode 100644 index 0000000..c65fd56 --- /dev/null +++ b/croissant/tests/test_coordinates.py @@ -0,0 +1,77 @@ +from astropy.coordinates import AltAz, EarthLocation +import healpy as hp +from lunarsky import LunarTopo, MCMF, MoonLocation, SkyCoord, Time +import numpy as np +from croissant import utils + + +def test_coord_rep(): + coords = ["galactic", "equatorial", "ecliptic", "mcmf", "topocentric"] + short = ["G", "C", "E", "M", "T"] + for i in range(len(coords)): + assert utils.coord_rep(coords[i]) == short[i] + + +def test_get_rot_mat(): + # check that we agree with healpy for galactic -> equatorial + rot_mat = utils.get_rot_mat("galactic", "fk5") + rot = hp.Rotator(coord=["G", "C"]) + assert np.allclose(rot_mat, rot.mat) + + # equatorial -> galactic + rot_mat = utils.get_rot_mat("fk5", "galactic") + rot = hp.Rotator(coord=["C", "G"]) + assert np.allclose(rot_mat, rot.mat) + + # check that we agree with astropy for equatorial -> AltAz + time = Time("2022-06-16 17:00:00") + loc = EarthLocation(lon=0, lat=40) + to_frame = AltAz(obstime=time, location=loc) + rot_mat = utils.get_rot_mat("fk5", to_frame) + x, y, z = np.eye(3) + xp, yp, zp = ( + SkyCoord(x=x, y=y, z=z, frame="fk5", representation_type="cartesian") + .transform_to(to_frame) + .cartesian.xyz.value + ) + assert np.allclose(rot_mat, np.array([xp, yp, zp])) + + # MCMF -> AltAz + loc = MoonLocation(lon=0, lat=40) + to_frame = LunarTopo(obstime=time, location=loc) + rot_mat = utils.get_rot_mat("mcmf", to_frame) + xp, yp, zp = ( + SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") + .transform_to(to_frame) + .cartesian.xyz.value + ) + assert np.allclose(rot_mat, np.array([xp, yp, zp])) + + # galactic -> MCMF + # in this case we have to invert the matrix that does MCMF -> galactic + # since we cannot instantiate a galactic frame from cartesian coords + rot_mat = utils.get_rot_mat("galactic", MCMF()) + xp, yp, zp = ( + SkyCoord(x=x, y=y, z=z, frame="mcmf", representation_type="cartesian") + .transform_to("galactic") + .cartesian.xyz.value + ) + assert np.allclose(rot_mat, np.array([xp, yp, zp]).T) + + +def test_rotmat_to_euler(): + # check that rotmat_to_euler is the inverse of euler_matrix_new + rot_mat = utils.get_rot_mat("galactic", "fk5") + eul = utils.rotmat_to_euler(rot_mat) + rmat = hp.rotator.get_rotation_matrix(eul)[0] + assert np.allclose(rot_mat, rmat) + + rot_mat = utils.get_rot_mat("galactic", "mcmf") + eul = utils.rotmat_to_euler(rot_mat) + rmat = hp.rotator.get_rotation_matrix(eul)[0] + assert np.allclose(rot_mat, rmat) + + rot_mat = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]) + eul = utils.rotmat_to_euler(rot_mat) + rmat = hp.rotator.get_rotation_matrix(eul)[0] + assert np.allclose(rot_mat, rmat) diff --git a/tests/test_dpss.py b/croissant/tests/test_dpss.py similarity index 99% rename from tests/test_dpss.py rename to croissant/tests/test_dpss.py index 661f540..e4759e6 100644 --- a/tests/test_dpss.py +++ b/croissant/tests/test_dpss.py @@ -4,7 +4,6 @@ def test_dpss_op(): - x = np.linspace(1, 50, 50) # target frequencies with pytest.raises(ValueError): # didn't specify any kwargs _ = dpss.dpss_op(x) diff --git a/croissant/utils.py b/croissant/utils.py new file mode 100644 index 0000000..548d014 --- /dev/null +++ b/croissant/utils.py @@ -0,0 +1,229 @@ +from astropy import units +from lunarsky import SkyCoord, Time +import numpy as np +import warnings + + +def coord_rep(coord): + """ + Shorthand notation for coordinate systems. + + Parameters + ---------- + coord : str + The name of the coordinate system. + + Returns + ------- + rep : str + The one-letter shorthand notation for the coordinate system. + + """ + coord = coord.upper() + if coord[0] == "E" and coord[1] == "Q": + rep = "C" + else: + rep = coord[0] + return rep + + +def get_rot_mat(from_frame, to_frame): + """ + Get the rotation matrix that transforms from one frame to another. + + Parameters + ---------- + from_frame : str or astropy frame + The coordinate frame to transform from. + to_frame : str or astropy frame + The coordinate frame to transform to. + + Returns + ------- + rmat : np.ndarray + The rotation matrix. + + """ + try: + from_name = from_frame.name + except AttributeError: + from_name = from_frame + # skycoord does not support galactic -> cartesian, do the inverse + if from_name.lower() == "galactic": + from_frame = to_frame + to_frame = "galactic" + return_inv = True + else: + return_inv = False + x, y, z = np.eye(3) # unit vectors + sc = SkyCoord( + x=x, y=y, z=z, frame=from_frame, representation_type="cartesian" + ) + rmat = sc.transform_to(to_frame).cartesian.xyz.value + if return_inv: + rmat = rmat.T + return rmat + + +def rotmat_to_euler(mat, eulertype="ZYX"): + """ + Convert a rotation matrix to Euler angles in the specified convention. + + Parameters + ---------- + mat : np.ndarray + The rotation matrix. + eulertype : str, either ``ZYX'' or ``ZYZ''. + The Euler angle convention to use. + + Returns + ------- + eul : tup + The Euler angles in the specified convention. + + Notes + ----- + ``ZYX'' is the default healpy convention, what you would make ``rot'' + when you call healpy.Rotator(rot, euletype="ZYX"). Wikipedia refers + to this as Tait-Bryan angles X1-Y2-Z3. + + ``ZYZ'' is the convention typically used for Wigner D matrices, which + s2fft uses. Wkipidia calls it Euler angles Z1-Y2-Z3. This would be + used in s2fft.utils.rotation.rotate_flms. + + + """ + if eulertype == "ZYX": + return rotmat_to_eulerZYX(mat) + elif eulertype == "ZYZ": + return rotmat_to_eulerZYZ(mat) + else: + raise ValueError("Invalid Euler angle convention.") + + +def rotmat_to_eulerZYX(mat): + """ + Convert a rotation matrix to Euler angles in the ZYX convention. This is + sometimes referred to as Tait-Bryan angles X1-Y2-Z3. + + Parameters + ---------- + mat : np.ndarray + The rotation matrix. + + Returns + -------- + eul : tup + The Euler angles in the order yaw, -pitch, roll. This is the input + healpy.rotator.Rotator expects when ``eulertype'' is ZYX. + + """ + beta = -np.arcsin(mat[0, 2]) # pitch + cb = np.cos(beta) + if np.abs(cb) > 1e-10: # can divide by cos(beta) + gamma = np.arctan2(mat[1, 2] / cb, mat[2, 2] / cb) # roll + alpha = np.arctan2(mat[0, 1] / cb, mat[0, 0] / cb) # yaw + # else: cos(beta) = 0, sensitive only to alpha+gamma or alpha-gamma; + # this is called gimbal lock. We take gamma = 0. + else: + gamma = 0 + alpha = np.arctan2(-mat[1, 0], mat[1, 1]) + + eul = (alpha, -beta, gamma) # healpy convention for ZYX + return eul + + +def rotmat_to_eulerZYZ(mat): + """ + Convert a rotation matrix to Euler angles in the ZYZ convention. This is + sometimes referred to as Euler angles Z1-Y2-Z3. + + Parameters + ---------- + mat : np.ndarray + The rotation matrix. + + Returns + -------- + eul : tup + The Euler angles in the order alpha, beta, gamma. This is the input + s2fft.utils.rotation.rotate_flms expects. + + """ + alpha = np.arctan2(mat[1, 2], mat[0, 2]) + cos_beta = mat[2, 2] + beta = np.arctan2(np.sqrt(1 - cos_beta**2), cos_beta) + gamma = np.arctan2(mat[2, 1], -mat[2, 0]) + eul = (alpha, beta, gamma) + return eul + + +def hp_npix2nside(npix): + """ + Calculate the nside of a HEALPix map from the number of pixels. + + Parameters + ---------- + npix : int + The number of pixels in the map. + + Returns + ------- + nside : int + The nside of the map. + + """ + nside = int(np.sqrt(npix / 12)) + return nside + + +def time_array(t_start=None, t_end=None, N_times=None, delta_t=None): + """ + Generate an array of evenly sampled times to run the simulation at. + + Parameters + ---------- + t_start : str or astropy.time.Time or lunarsky.Time + The start time of the simulation. + t_end : str or astropy.time.Time or lunarsky.Time + The end time of the simulation. + N_times : int + The number of times to run the simulation at. + delta_t : float or astropy.units.Quantity + The time step between each time in the simulation. + + Returns + ------- + times : astropy.time.Time or lunarsky.Time or astropy.units.Quantity + The evenly sampled times to run the simulation at. + + """ + + if t_start is not None: + t_start = Time(t_start, scale="utc") + + try: + dt = np.arange(N_times) * delta_t + except TypeError: + t_end = Time(t_end, scale="utc") + total_time = (t_end - t_start).sec + if N_times is None: + try: + delta_t = delta_t.to_value("s") + except AttributeError: + warnings.warn( + "delta_t is not an astropy.units.Quantity. Assuming " + "units of seconds.", + UserWarning, + ) + dt = np.arange(0, total_time + delta_t, delta_t) + else: + dt = np.linspace(0, total_time, N_times) + dt = dt * units.s + + if t_start is None: + times = dt + else: + times = t_start + dt + + return times diff --git a/notebooks/croissant_jax.ipynb b/notebooks/croissant_jax.ipynb new file mode 100644 index 0000000..0da8621 --- /dev/null +++ b/notebooks/croissant_jax.ipynb @@ -0,0 +1,249 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "9f3469f3-959d-4e39-8ef1-8432975e6f7f", + "metadata": {}, + "outputs": [], + "source": [ + "import croissant as cro\n", + "import croissant.jax as crojax\n", + "from functools import partial\n", + "from healpy import get_nside, projview\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import lunarsky\n", + "import matplotlib.pyplot as plt\n", + "import s2fft" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "223b215e-1342-4c0b-aa1a-cd175fe31cba", + "metadata": {}, + "outputs": [], + "source": [ + "# simulation parameters\n", + "world = \"moon\"\n", + "L = 180 # maximal harmonic band limit given sampling of beam\n", + "freq = jnp.arange(1, 51) # 1-50 MHz\n", + "time = lunarsky.Time(\"2025-12-01 09:00:00\") # time at the beginning of the simulation\n", + "loc = lunarsky.MoonLocation(lon=0, lat=-22.5) # location of telescope\n", + "topo = lunarsky.LunarTopo(obstime=time, location=loc) # coordinate frame of telescope\n", + "# 240 bins in a sidereal day on the moon\n", + "ntimes = 240\n", + "dt = cro.constants.sidereal_day[world] / ntimes\n", + "phases = crojax.simulator.rot_alm_z(L-1, ntimes, dt, world=world)\n", + "\n", + "# get the euler angles and wigner d functions for the coordinate transforms\n", + "eul_topo, dl_topo = crojax.rotations.generate_euler_dl(L-1, topo, \"mcmf\") # beam transform, from topocentric to mcmf\n", + "eul_gal, dl_gal = crojax.rotations.generate_euler_dl(L-1, \"galactic\", \"mcmf\") # sky transform, from galactic to mcmf\n", + "\n", + "topo2mcmf = partial(s2fft.utils.rotation.rotate_flms, L=L, rotation=eul_topo, dl_array=dl_topo)\n", + "gal2mcmf = partial(s2fft.utils.rotation.rotate_flms, L=L, rotation=eul_gal, dl_array=dl_gal)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f2e8e12b-fbd7-4c25-9a97-39d863b3820e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAHECAYAAAAnGhD9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADb7UlEQVR4nOy9ebwmRXkv/q3uc+YMIDMwLLMkw6YR3BgQZZxEDcRRGL0ELkQFMSAgXr3iTxmNOols6g0qxmAikcQFJC6oNwQTNbiMAvFmBIVwiV5FQBQEZkQUxhnlnPN21e+PWvqp6qpe3vc9y3t4vvN553RXV1dv9Tz9fb61tFBKKTAYDAaDwWCMELK5PgEGg8FgMBiMrmACw2AwGAwGY+TABIbBYDAYDMbIgQkMg8FgMBiMkQMTGAaDwWAwGCMHJjAMBoPBYDBGDkxgGAwGg8FgjByYwDAYDAaDwRg5MIFhMBgMBoMxcmACw2AwGAwGY+TABIbBYDAYjHmCG2+8EccddxxWrVoFIQSuvfbazmV85StfwXOe8xzsvvvu2GeffXDSSSfhJz/5ydDPda7BBIbBYDAYjHmCnTt3Ys2aNbjsssv62v+ee+7B8ccfjz/6oz/Cbbfdhq985Sv4xS9+gRNPPHHIZzr3EPwxRwaDwWAw5h+EEPjnf/5nnHDCCS5tcnISf/EXf4HPfOYzeOSRR/D0pz8d733ve3HUUUcBAP73//7fOOWUUzA5OYks0xrFv/7rv+L444/H5OQkxsfH5+BKZgaswDAYDAaDMSI455xzsGXLFlx99dW4/fbb8dKXvhTHHnss7rzzTgDAEUccgSzLcMUVV6AoCjz66KP4x3/8R6xfv35BkReAFRgGg8FgMOYlQgXm3nvvxUEHHYR7770Xq1atcvnWr1+PI488En/5l38JALjhhhvwspe9DA8//DCKosC6devw5S9/GXvsscccXMXMgRUYBoPBYDBGAP/1X/+Foijw5Cc/GU94whPc74YbbsDdd98NANi6dSvOPvtsnH766fjOd76DG264AYsWLcKf/MmfYKHpFWNzfQIMBoPBYDCasWPHDuR5jltuuQV5nnvbnvCEJwAALrvsMixduhTve9/73LZPfvKTWL16NW666SY85znPmdVznkkwgWEwGAwGYwRw+OGHoygK/PznP8fznve8aJ7f/OY3rvOuhSU7UsoZP8fZBDchMRgMBoMxT7Bjxw7cdtttuO222wDoYdG33XYb7r33Xjz5yU/GqaeeitNOOw3XXHMN7rnnHtx88824+OKL8aUvfQkA8JKXvATf+c538M53vhN33nknbr31VpxxxhnYf//9cfjhh8/hlQ0f3ImXwWAwGIx5guuvvx5HH310Jf3000/HlVdeienpabz73e/GVVddhfvvvx977703nvOc5+Ciiy7CM57xDADA1Vdfjfe973340Y9+hF133RXr1q3De9/7XhxyyCGzfTkzCiYwDAaDwWAwRg4LtgnpsssuwwEHHIDFixdj7dq1uPnmm+f6lBgMBoPBYAwJC5LAfPazn8XGjRtxwQUX4NZbb8WaNWtwzDHH4Oc///lcnxqDwWAwGIwhYEE2Ia1duxbPfvaz8aEPfQiA7nm9evVqvOENb8Db3/72xv2llHjggQew++67Qwgx06fLYDAYjBGFUgq//vWvsWrVqsron2Hisccew9TU1FDKWrRoERYvXjyUsuYSC24Y9dTUFG655RZs2rTJpWVZhvXr12PLli3RfSYnJzE5OenW77//fjz1qU+d8XNlMBgMxsLAfffdh9/93d+dkbIfe+wxHLj/E7D158VQyluxYgXuueeekScxC47A/OIXv0BRFFi+fLmXvnz5cvzwhz+M7nPxxRfjoosuqqQ/8X+ej3xitB8wg8FgMGYOxeRjuPvv3ondd999xo4xNTWFrT8v8NNbDsCS3QdTebb/WmL/I36CqakpJjALAZs2bcLGjRvd+vbt27F69WrkE4uZwDAYDAajEbPR3eAJuws8YffBjiOxcLpFLDgCs/feeyPPc2zbts1L37ZtG1asWBHdZ2JiAhMTE7NxegwGg8Fg9IVCSRQD9lot1MKZjXfBjUJatGgRjjjiCGzevNmlSSmxefNmrFu3bg7PjMFgMBiM/iGhhvJbKFhwCgwAbNy4Eaeffjqe9axn4cgjj8Sll16KnTt34owzzpjrU2MwGAwGgzEELEgC8/KXvxwPPfQQzj//fGzduhWHHXYYrrvuukrH3kYI85svWDjE+fGL+VSfGD7YvuYv5rPdzOK5SUgM2gA0eAnzBwuSwADAOeecg3POOWeuT2O46GIo7IznBvPZ0TLqUffs2J6GD7aVziiUQjHg1G2D7j+fsGAJzOMegzqHhVPH+wc7WIZFP3VhodsQ2wdjjsEEhhFHyjktZKfMDpkxTMTq06jaD9vGvMAwOuFyJ97HCZTQv5mCGMV61HQ/5vs1LQBHPJN1cpSw4Oxnrq5ngdenmbaX2bRHCYWCCYwDE5g5RNuKP1KOOrym+XDuI+igmaQ0o+4ejZTNWNDrmenzXwD1i22EwQRmBNCPoc4bBz7bMvo8dmrscGcPXe71vLEVimHZzYjUObaNduAmJB9MYBYoYg5h3jhqe27DPJ956ADZKY8Gwuc0b+wkRBuFZkTqHNtGf+BRSD6YwDyOkHIac+awhyGZzwNHuKCd8eNw6P68s5MYRqTOLWjbYMw5mMDUYVgT2c0nxxcBdTJzTma6HH8OneNIOObZPscFbiv2mc8rIjMPMRK2YTGMc53VTrwYwkR2CwdMYGYD/VbwOXCUIyOnzzLmhVOehXMY5nX2VXe6Hp9tZM7xeLGN+YBiCKOQBt1/PoEJTA2GPYy6s6ObB3OxzNuoc5Yc1pw55yEcd65fLLPS+XwezLWixDy0j1nAKNsGMLzzn837UCgM4WvUwzmX+QAmMHXo2oTUUDGGNjJiDojNvGhmolCYURIzK06pj2MM5bzmOlqtqT9DsRG2jxnFgraNfo4/1/b0OEY21yewoCA6/Bpg1Z/w1+n4M4QZc2BdHf8MvShm1EEPWAc6ld9n3ZtxzKCNdDruDGGula+ZwkxP7DnjthEeYz7bSAJySL8uuPHGG3Hcccdh1apVEELg2muvrc3/qle9CkKIyu9pT3uay3PhhRdWth9yyCEdz4wVmHoMszKHL9s25UZe0J2GR4d5h/jCH3rTUr/lDFGJmRHn3LLMTg54Bo4/54g9/6ZzH6Z9DJkMz3jT6ywPo54r2+h03H7OccQUTQmBYsADyo7779y5E2vWrMGZZ56JE088sTH/Bz/4QbznPe9x671eD2vWrMFLX/pSL9/TnvY0fP3rX3frY2Pd6QgTmBp0YfaNjqoPZ9y2fb91p0Kbb8hEZiFI5rMtP7dWU4Z0vL7PYcjo3OwDtH9ZJ/K1at6ZITIzdPtoKmsGmlYfj7bR+jw65BtVbNiwARs2bGidf+nSpVi6dKlbv/baa/GrX/0KZ5xxhpdvbGwMK1asGOjcmMA0oU8S0VhsW0WmTb4gTyOhGbKzHthJD3oOAzrtoTmghnJqj9Om+aMFBrqWmXDEDXUzBa8+tSU3w7CNsJz5YB+uoCGU0fWQs2AbrZr+Bii/07HaYA4Ji1T6N2gZs4mPfexjWL9+Pfbff38v/c4778SqVauwePFirFu3DhdffDH222+/TmUzgekH/VZgUnFaf8elDYFqcLi1cvaQVJlRVWJm2qH1TVoGIUMty+iMfpoku5xDC/toJP4dtzc29YhImX1gVu1jSCrMgraNFuXMRxRDaEKy+2/fvt1Ln5iYwMTExEBlh3jggQfwb//2b/j0pz/tpa9duxZXXnklDj74YDz44IO46KKL8LznPQ/f+973sPvuu7cunwlMHYbRB6aPSLKxHb/OKdeQmdkgMnOGGR6VFEXieH055plw9P3k64JhlNnGPoZlG3R7jTKTJElzaRv9dHCfS1Wyn/o8bNto2LevfMPedw6xevVqb/2CCy7AhRdeONRjfOITn8Aee+yBE044wUunTVKHHnoo1q5di/333x+f+9zncNZZZ7UunwlMDQbpde+cYNu+Lw1KS630nSItifSZctZ9RZlz+FLo20l3JS4d0zuX07StTdmzjE720UBshmkbtLxhE5lRUSlnohlyxm2jrqymbV2OMYT8g2CYCsx9992HJUuWuPRhqy9KKXz84x/Hn/7pn2LRokW1effYYw88+clPxl133dXpGExg6iBUN49DanJTpa514KltbUhIk8OOOOukIjNbJGYOMCvkpW1al/37KSe6/xw9JHOCfTehttg2X22jtszanfo71qxjGHU7kj5Mxaa2vGhZLW7+LNqSVAJyQMZk91+yZIlHYIaNG264AXfddVcrRWXHjh24++678ad/+qedjsEEpg4dFBih0L4iK1Hfxp8iNf067Ia02ohzVJznbKCtc22ZNiOkB2hVD+dsBFLTufVrGwi2zYZthPvPN/TRjNRXvZgBUj8o6UmW4fZp9+DmpK/ZPMOOHTs8ZeSee+7BbbfdhmXLlmG//fbDpk2bcP/99+Oqq67y9vvYxz6GtWvX4ulPf3qlzLe85S047rjjsP/+++OBBx7ABRdcgDzPccopp3Q6NyYwdRAYqN+KV5RKrfgFdIoeaxz20Jx1HyRmzlSYlg57WE66Uk6/znkQpw7U3uw5d8BdO663tA1/n8jxZsA2hq3GLGS0IiCzERAAg9tHH+cyUxhmE1JbfPe738XRRx/t1jdu3AgAOP3003HllVfiwQcfxL333uvt8+ijj+Kf/umf8MEPfjBa5s9+9jOccsopePjhh7HPPvvguc99Lr797W9jn3326XRuTGDq0ERgOjivumypyFRFDl6JQkOHXRd5ppx1k3Q+U9HmqDj+4DH045z7IS3x40TqSVMdrcNMO9+WNpIcBJRSbQKlphWZGdA2hqVUdiL4g9pIBxVmGC/zoRGXvslO/Ib11a+sbb5ZJTAZigEn0C865j/qqKOgVLoiXnnllZW0pUuX4je/+U1yn6uvvrrjWcTBBKYGsU68redvcYXU5GvqhCiqGSpONHS8baLH0OF2iTjnO/qQzWvRj4LRlbw05m9JWgZ0ssNsVuo8j0uYp6NttCIl/dpG274x8xXDtonUYWaC2LciOx1I/aBEJnKM2WyOVUPoA6PmS0/+IYAJTB0iCoz37Ns4sa7OTkWcdsSDVhx2eF7BeiPxsWldnHsNGp38KLwAuiovXZxzR9LSb7NTdN+W+w0CFatfgx562LaRaloaBvEZBuazjQydpHfN34d91KQP1NS6cPjAyIEJTB0ogUm1f9ehMYqs5m3Vdh+JPttGkf1EnP7JN2yfD5iliHMY5GVgx9wmQq3JO1C+FNqoLzNpG4FimazvQyTsfeWvw0yQoXnyop1VYt/FPhL5axEJcmcSc9EHZj6DCUwNFIgfSTzz2qqQcGgqlt5CsahGlopsFsG2cj/vRFNqTFvCMwzMdwIEDJGQtMhX55S7RqaxfVJptJz6zd0goovVPC1to1JGjcKo8/usJKnItFVj2hKeYWGm7GNYJKZP26jkbZ1PxdMj+/VtH3XptqyO6TOBQmUo1IB9YEbB/7YEE5g6hOw65nBrdvUXgh1aRZNke6OjLb2451hrosK+8jXkdVnm2khmMuLsR8kYlLx0eWnUpLV6LIPct7BFp674Jtvos4nHr9c1amUNOUlitkjMTGGmlZiasodKXroSlw5EpvXjFMFfxqyDCUwdQgITq6ipl35qu2iu7x5XqHM4oZpCnLWfTgqudfbo7tC7okWZHabTaT5WJE/QyjDYcZLEpLrc2TG3VXYi69Fb2PI6BkKKlMSSmmwjJAt1hwrqdlKtNLbRVOdryf2AtpGs37NFhIZkF0B7UtG5jg9iHy3Iy1DtYxYJjISAHHAUkhwJCbwdmMDUIDYKCYioEdGdI9tVYlNNRNlW0q5EnR3VmFnBkFWbyCCt+DGH6WC6OtBo5Dczzrm1U264H4MOUmi0j35to06ZaUvSEUnrh8QMGy3LbjEPYPvjzZISMxTy0lqxqclXc46t0mPHi6zPJLgPjA8mMHUQKuoxohW2OjzCFeGlhRFlsL2JD5GiKxnq1JiKI27jqFN5GhDNl9h3GPJ7I5GZaWftnUx1OeacOzn1tk65SZVJOuzhvpkrx4nYRtNcKqFtiJpn24bIuPrbUYkZNrrYRjJ/x/K72EU/KkxrtLQNL32AgKGLbVTK9PIOOfJiDA1MYOogUP/iq7T10G2C/imzhFFnGC3SLF0iwwayESUgs6XIzCB5iZUXJ5jw7v0wHXX7jrSRC+6TvCSdcxvSUnfjh/XyarCNil3QY8fqPM3SRFKCfe1yJyUmtn0mMETy0lROG7uw+QeyjRTRiGz3Dtpyn75tI7JebZrtwzZmU4EZSifehUO4mMDUQGX6p1ciGSKGX1mhUaWAbzEJ50mjz1Tk6Xaj5CUVcYbNSX04am9bF6erGrbH0Na+Evcm6bCHSWLqnGzU2dYoL3XOuSNpqesg3CnqDFEXxbfIX7GN0C7oQg2poL5XkPruInp6vHB7GyWGnv+QCX+TbUTz1MG7p+2P32QXM4K6ulenvESVmuryXNrGgHyiE3QfmMEe1qD7zycwgWmLFkpMRSmPKi5+5or8HUaN9PB1UWUdKal7Uw9RhWnjoJPo5xzCyD1yPnPirNugX/IyBOfcOipug6b9IrYRtQu3AZ5CkyIidLWt2lK7LcgzbAxMXprOKXatNecyo+S+DjFCgiAtprAgva1v22hLWuaDv2BEwQSmBkrUs+uK9O12LPen635kGUShtpCEc7WRZyXqjJGYGiWmjvCUF1azLbVLV+VlmC+JGucdjTrJPUo66pZEJypnV7apeN7QmddFlrWEJ+6Uq/J4w3pqv45IduKtsQtvP2Ib3vxGdMFuT9lFtfi0EpNSYboisX9d3U8ecybOpY1dkHwzaRvhibS2jTriEiNHbWyjJWlJ2cVsduKVQ/gWEo9Cerwg0Yk31r/FZtcLNC9ZJw6hGllGJO1YZGl3o2SlQYmZdQxKXtqef8pxRBxsrQg1zGizJsKk22vz9UNe2hKXYFvjdbd9q5OC+rELup9PxiN2AVTrPwK7GAQp2xoGhkVeGghKcp8OdjF0VEjJLJGXNsSlA2GpKpyz53C5D4wPJjB1yMzPgkaIIaKyrPCjywiRsU4ljD5df5mI86xEnaTMihLTRoVJOepYPY+kpfZpJC4zGWVGVAAv6mwTbZJn039fmcBJk2MmHTcS6W1IS8Ip1zYxhfulELs/dWWaPH6Ub2842S1GZEK7ALmPpozK6cTsApVH7Z3XoCqMy99GfeliGzVlJlGXv61d2Dx1dkGLGJAAdSUvXW2jdZ8zlyckJzUnb7fNah+YjOeBIWAC0wUdIv5Y9AibFDqKmDLThnDQw1bIip93ELR26kMkL3XHrHWYyWdRf7yZRDsp3eQN1ofqoBva/zvfo64RP7UJc3Jt7CKqVraxi7q6PwS7aMKcEfsYWtiFR0aaSMygNtXGqQyLvNQFD7FzqZCa5lNlzA2YwNRAZQoqazY0EVp3zOGa5dJBiDLCJM60Gi2ayBORqNM66+AlEWtOCqPNWqQuuU59UcF6bJ8m9aYlksF+TZRJb2xFiWkZbTafWHAeMcJA89Q56K7Ouc2x65Zh9x/O21MQ9bEsPFhuaRdUMetkF8EGd8gauxhWc1GMvNSqm0OyjRja2oU9ZozEDIwIcYjV4WhaeM6eDXW0C1T3qV1Gs020eUcMC4USKAZs8xt0//kEJjB1oC+ZFJRfwaOOO7IPdZj2ULEsSTUG5baYElO5jhmwsSb5vI68NDrnuu2J+5vsmNhVKZhhRJuTgnUvX52T7uqg2zjnQe+Fqpbr2UVMbXHLDepKJb2FXcQICyJleieM4dhMmzJmkLzQsmrtooHI903uY/u0rXM19bdTk2zCjuqWK3ZRd+2z6DuKIXTiLbgJ6XGCTDVXzvCFEHaQctGX8J2xzuzyxPq8VPsCkKiTOl2qxJj8tdEmEk67DikCourTaqXzSLn9nEt5gOpxKv1dGpSYiqMO09uSHdr3JRVhUvKSii5rnHPSMUfIiueQa6LNoSBSpmcXXp0gNyGwC7eLEnFFJmIXlUDA3kJCkhyXCuyj9Vva2XT1elLps2YbMTTZhc0T2EajQpmymRaoJeEmzSP1MTLi2QrJG+ZDdXuZbwh2MYsEhuFjFrsfDY6LL74Yz372s7H77rtj3333xQknnIA77rjDy3PUUUdBCOH9Xvva1/Z/UKHqf5X88AzOGaNQ2lgixobA2GIGGcvnHS/Mg8CppIyswfjakpzODliltzfd8uQ5RcpMyvYzFIS0cuT0GUXSPWkcGIi8uHpn08Jf9PxaPICuDydx7LZ2oUTNiyrI5+2L+D2uw7AV9pkgL61twpZVZxc1x2hzLm3R1TbC9SR5CfKW5F/F653owy76ckjDh1TZUH4LBSOlwNxwww14/etfj2c/+9no9Xr48z//c7zoRS/C//t//w+77baby3f22Wfjne98p1vfdddd+ztgrvTPImqBqubFKCqLiqguAPwIVEEbg6qqLDYaKktUlfb/2JwYXrQJu95HyESvKnBsdQ66YttdHWkYJdbsl2rrrygttqwwguw3okzkjaovdB2R7YBzvMkoNUZawogyRoDd+SaizpprST6oNjZhkioHoS+ntnYhUFVkTFlWjYn1i1EKVYUSwbo7TmC3Hd5Ps2obqWNHEFNcau2C5OnHNpJ5EsGXsw3y2KP1Pkpc4+Qmqrb0YxdN15J3fFADgJuQfIwUgbnuuuu89SuvvBL77rsvbrnlFjz/+c936bvuuitWrFgx+AErbDz14FM1nHoIkpU6X6EQ7x+gPUUod5eOtsxTKbvt+kwhdYymqLNu39i24LaLyO1uatun+yabiNqmhSeSQh1poE7WbutCXto46DrnXKegRNHVJsg+Yd31ciTswhiAAiEx9DRCu5hpm4jtmyIoqW1diEubc43c+lTzT2VbXb1OnU9T/vDZNq2Hh6D1Psyfsp0upL7JLppsosv9YgwVI0VgQjz66KMAgGXLlnnpn/rUp/DJT34SK1aswHHHHYfzzjuvVoWZnJzE5OSkW9++fbteyJT+xRB6g5RDsm9FLxLzI1AaffqRp4k6a9UY48zpIeuiTQv6ErDn0oVUpCLMBgdd57gbj+kKqckj/GOE0WWFqMS2IU52aqPPOqdsI8REhBlVXsLoMiZ3o4a0JJuWWkaZ/cjilTckELUL+rYM6w+xjbRd6PNTSpflSovYBSmx0h/GBQP2eAguuyO5aSTlKZtJ7d/m2ClyXTm5Zrvw0snf1ipMDZmp5Kd1nKyrcN3WfY/EI1hXfnkiIC2xut3GZsJlmodiFkchSQw+ikgO51TmBUaWwEgp8aY3vQl/8Ad/gKc//eku/RWveAX2339/rFq1Crfffjve9ra34Y477sA111yTLOviiy/GRRddVEkXAsmPKToHWiYkMqrI9iAC9ciGKp21IPlDNcY7bEBG6LZ+bSsVdNSQmYHJS9tzrVx/sI2kxaLLWrUlUkZbRJ10oviqAyfkhezfN3lJEZeUcw4ebLLe16FiE+FBLBoeYJ1dhORVEAJPzErEygIhMeEpBufd1Mm9iay0IvapsrraRoKwRPPY2xGxi0r+wd6TreCRdYuQ2Id5Y+SF7JskL02kvo7U2NXIPenLVvrEcCay4z4wc47Xv/71+N73vodvfetbXvprXvMat/yMZzwDK1euxAte8ALcfffdeOITnxgta9OmTdi4caNb3759O1avXg2RSYi8yleV8iM77Rx8UkJHUHgJNN1LKx2tMsqLN3KJqDHC5UMl4nQ+KRZtktMdJNKsIyqx6DJJXNo487rTiJ13mJaILqNKTBBddu4LY3aqU19C8kKdsJcvQVxqnTNNa3DWIsxH89BiWz6Qik0AM2YX+jmZm2mO4amUZbZyGzk3p1Ciagv99hHzbmMTeWkg+tH1yHFiiPYDczuT9JhdgNyjSN5a0t8G1jYSpIXaRsUuEtv8dFUtO2YvNQRfpPYNT5c8CJEtJE1jtDCSBOacc87BF7/4Rdx444343d/93dq8a9euBQDcddddSQIzMTGBiYmJ6oaYocFUXur0IuqKoxIuKm0KcSLRYkKNiaot4XkjEW0OGw0OtS156afFItnnBQjYWrBjhKwMHS3KjTrpWDl15KVCctLEpYm0VMhKh3sT2gRQbxcqqkzafPV2oZMqDaf+TRQ+iWn1oLsS+WGhgbx0sY1KM1FYbsQuGu2gBWmJltGwT5LMRA+AKrH30hPkxSM5afup2EYXu5hxJ1tiON9CYgVmTqCUwhve8Ab88z//M66//noceOCBjfvcdtttAICVK1d2Pl6WKWRB+2bFlyihIzbQ6LLMqeyICdsMlIo0Y5EniTpF8JamozGU9KNNQRxOJdoEXa4nQxW7jUWZ5KYkI8zwb6TscHsXVPx0ED0mo0tLYmi+MI2em+cc251YSn1pVF5C4hKLGGNRZYqw2JdV1EHTc/YfQlvf3Mou6IpVUAi5sH1anIRSYxeWxDjbULoA1y+G7OLZBjmNil10rX91xCNmC6FdRPJZDGwfolpGyi5iCktMcUmqk3UEp2UFGtg22hB6si7CbajaRmu7mNU+MAJyQMY06P7zCSNFYF7/+tfj05/+NL7whS9g9913x9atWwEAS5cuxS677IK7774bn/70p/HiF78Ye+21F26//Xace+65eP7zn49DDz208/GEUBX2XTrA0pKdHzCkAsTnChhDNN7A5lGxSDMWUTonG0Sc9LRExFHPhk3FCEmKvCCSN1JO3+dBX8htnWtNGfMF0Ym2PCdeddBtiEtMjfH8dccK1MouQN+Zvl3oNP3m9BXLGrtoeYrRvmMzhFpiH6INse/3nClRIWVH7SJBWprytz6VMO+wiX0deREgaTW2UUNamuyiq60MAlZgfIwUgfnwhz8MADjqqKO89CuuuAKvetWrsGjRInz961/HpZdeip07d2L16tU46aST8I53vKOv44lcIov0gQGIowZ8VUUorboI4ntMNGr7rLimHaU9RG3kSaJOT42xEacUEb+SiDb7sbOIQ21qFmrsAxApd1AfEO4eUsPYNndrqeMOdk7K69SJEwdbdbpIOmmVVdMaHXTonBOOmRIWus0tiupDoc67H6esiOqi1+lG4fKk7AJQpWKpqF3RX0u7MHldWeaaGlUYt+x3Dq7r1FtHOqLEvom4DMk2Yn3EonYRIy10neyYVGGaQG2jMW+f5KXONjx7CAhLQFRC2wg76Ya2oRLvCMbMY6QITGWa/gCrV6/GDTfcMLTjhU1IlLQIFynqCq4ceTEVXGnn59IBWPdu+wso4zmMG7cl26OhfPPVIHDKtflNccMOGKJNSy3Jy0BSeUA0gHjEGJPDvWNFnGq0GWkIqHRAjKFfBx1ElEniEnHMXqfEBodduSbbgdfkq9iFOQdFTju0CwhL7G2HXGVe9qFaGSzHVMrU6QqSq4sNtCH/NSSmSYnpZBup4wGVOkX3b2UXIYmJHXOY9pAg9t4hh0VeYqSeEJcUaWljF7P6McehTGTHCszjAnmukAfsOqq8kPTyr3LrpeIiygjUiySNx7DRonHckArIGiJOqfe3JKb054lRSaYYc9TWjtyLHO3OiuwfLNO/0SgUQd4QjcQtkkcEREb56WFEKkg+EdknCerImxx64KRdmueQUX53K3TQXZxzyjETpywSDjrlqNsoMSp42/VrF96LldiCp8hQuwnVGJhan1lbMqRJ2m2Ow5Q2oMj1DvgeCm2Erns2kLALLw3VbRXQbXUkS/jlqiC9otTY9MiyPUe63hUxJSbWdKQVyoC80O/TJWxDZMQZRWwjJCzUFtrahbdtFmfilUpAtpa90mUsFDCBqUEmFDLLsk0ardDUOVtFRv8VJPpUbtkN6LR6tHlrepEnVWQyQ2ISEWclMAXcC1PQNJTbqmndItJGxWQQ8tLFD4TOm6bFiEzorKkzjiynjumITh0oQaG7E3KRijqj3wXqSF5SxMV31D6RsemxZXsaiVtSsQnXLGPsQi9T4lLai7MLoUfcKSXcCCP9mCJ2ETMAb5GM3oNvMpa1x+r80PrKBPvXEpUUeelqG7HtEbuwx0n2dQGQusXR9a4g+zoSFJYXrf8I+oNFyEtWYxdmH2obIaEPSUtchanaRfSL7oxZAROYGozlBfK8cOvVSFOvW0argnQbZZbLAkqpMvq0aox9K9q5Xsy7R0n4CozNI4WLRmx0iSzSH0b47fhwx4pcbCo9BqV/oT+h5CVJXGqctGhoIkyfTtqjxnx4VJ2JZKZcp31bfyKNOGQXYXrONyAvdNmpMwkHnVUdM1CSlpCwUEdNTzcLHLg7/QYHnbILwLcNS+jjdoGSyJu6breFdlFRY6TQ94g8RJWpeoWSEh4VPLaULdB6T+t1kEbTw33dNqTXK8vozza62kV4WGor7pYEZKatbVQIvQi3qbRtWPJiWz4IYfFIfRYhLgnSUrEDz2aUd4pNdiHIO2KmIYfQhMQT2T1OkGcKudcHxt8uTYIghAXQPtMRCOuEUb5ArLPWTlh5REaTEONwM6VJTEWBsX/hotVoZBm8qO1yXYfEzgiITMwJVxy05+gjJ9L23KzTsdF9ukemF3XGSIy7FrutD1T2E8GlUPXFrgfkJq28BOSFRJt1DjrmnFOOmTrojFxLM4Hx1yVRW3JjA0A5hbkidqFtRHkkBkR3cffCkBUl9YPz1BhB2QgQPnu37MoCqRBBujvHPm0ksIcosSHn09k2gjwV0Esi+ys6qoAw81o1JmUPsXR6r5tQS2TcyfvkJWYzlLyY5S7kJUrwkbaLLLg+ZxezOYx6CF+T5q9RP04wlhUYC9g1bT+sKDBuvVxWps1SgUabvsP2iEwGL+rUhZg8LtIU5iCGxEBB0IZ8s+xIlCE1no8JHHYU1Mmq8m+FtCCSHiz75Sl/P4JOL43wHURC6Vj0SYlLSGKoQ64oMv0gcNJ+ZEmctV2nbft22UaUtk2fOuhAdcmyuGOGyWMdM3XW1iGX6zEi0+6BxOyCpms7KLdTu6BprllJCUiJCsEXAlAScZXS2keDQhnEAFGSH6IzmaH2Qtcjy/RvnW20Oo/AJtx+pLDQNlIczy4QflNrFyEnjJ203e6V4xEU3zaiqiRRXjzbIKQ+a0laqF0AOr2rXYhs9hQYhg8mMDUYz2TFgedClc5a6Bgwh3bUbjQGkcildcBKaGVGUPLiExkpqW8wfQCMCiMg9EtOWq9C3Ur5h4o0Ll1F/g4DAamppANpB03yR51y0zkSsuF28QiJMmnCu+4oiQFZJ2VXnHdLQuPlo046sR5v26d/S/IiTMdGS160027noK1zpo45dNL0FNuSFyBuF3qxJDDlcmAXVokxtiGNVJNlhOBr49GKo+kbVlEprRJD3qShQulYi2Uudt1WS2o7LVEh9ioooyt5abINCuICUvtUm0xVxS5C9aWWxJOqHFNnuhB/R2jcMyEX4JH8duTFEXRiB1nMRlC1C8ASGFVdJucc2sVs9oEpIFAMFFlh4P3nE5jA1GA8LzA21nPrNMqsqi7lX4Uw8hQuArXRZeFFnGXHXxt1Qmb65SaNk1aAkITEUDKDsuOjc8zhx14CRw2glsyENpl00oS8VJy3t813zqGDrzt2FKrqPIW/2aQZIuNRw4DEkJ0b1ZeUg46ctLsNIvI3FWFm/l9BVJjQQVPVpXTSadKSufXSKdvlMMqMkZdYWjiiocku3HLCLiQAkZdNTFIaGxEKUopSjTGqi7MPq8TYkXuk8ztVKD31hf5F+pGn4Op/ChF78Pbpwza8Y0fyxNWXataYXdi8qma5QlpUJC0F0fw3ahs2T4S8ePYB6O/X1RCXvMYuAGM35pB0EEfMLuxyTt4RMw1uQvLBBKYG41mBTJTDqHP7AjJkwE7JLJVwKkxGHLa0EaNxxlaZkYaghIqMlDrqlFIAmdQkxknfynAQUToL+9d4FueoYw6aRpY1xMWVZ7M2OekgX5K8hM45PEbNOcQP6O9XjTL9YvT9E9XoUQW3IyQyJI2erwruPcK8oUOn6XURJvnbhrxk1GETZ5wiLpa0xKJM95fc/Kb+L55NmGuK2UWOkszrex+3C6pWSlgVRkHKDJkh8q4zDURpH5bEWGUyplAqe39FRX2I/42wZCBeNwk5CYl9uL1cb0dcah8BtelIXs8uymxxIkPtIUaECNGrJSxt2KCzB1Vdp3YRSWsiL5TMu2WYep/JWrsAUCH6oV2ENqEET2Q3V2ACU4PxTGI81+w6/H6EDIgKYBw0/HTrtG0EWsgMQglkQrrIs5CZduhCR5z2r4SEUAIyg/NESgIi08pM2d7vGAwx/IijRn+RpkPCSVfSXF7l7wc0OuvoeuJc6IUIsk5393kGcdZIk5jQQUdVmbY3MiA3tRGm/bm2fOOca6JL+5dGlnmWJi2U6ADaKYfRZfiXgpKblE3QZdq0KiGSdhGqMoXUwUDh9pcl0QdAVUpA24MQKBXKkNyLgNw3kXiKGjIREvzUekhq6kh9owJTlxYh2zQtzEaJTEWlJH8rZRPekSTzMdBzEeQvtQ0Q2xCqVCUT5MX2d7ETj1rVJctkkrjkdFuEsIR2kbKJDArTszgKqcDgTUALqccOE5gaLMp7GM+13FZxzsIuZxXSIpVABgFpZOuezJDZ6DOTzimXfWW0cy5gFRj9FzDLME5b0EgT+r8goqyoMLHIE4Ei04A6FaaWvEQcdEyBCctue16pbM6fEi9MSYhQpbNORpORSDQVkCdBIsjKftEI0zhlS2Ks8oJqdOn+2p9x0Hkma4nLmIkWvX2DCNOqjl36wACUtGhiEdoF7StGyUwhs4oqA2SeUgnTHyaqUpp7pzLoZlZ7L92DF+X9pmTevNC85tU6YtOCqNC8TeSlFXGJnEvdY2l6YlXiQkl8RKWEf0u8tC7EJXWOUTugaQhITFV5CclLE6nPSb337AARgm/S9XLVLjKhIHJuQporLJwrmQEsygr3W5z3/OW8ML8eFmX0p9PH8wLjWYFcSCzKzHpeYCyTGM8kxjKJ3PzGconMpGXEGN2nDKyxUcMlHdjoyw9AxQG0eumGDjPiQFMOOSynQl5i+wXp7ifjeRr3q9leOT7IOSZeNN7Lpdt7PBplunTznKrqS+CkBWk2IuQly2T510SSY7lEnik9b1EmkQtl1MOy3i3KTH006YtyW7dJ3c3tj24v63zsV7GRvMDisem4XRDbyIXEmNB13p2nsQ19TYW5Jr3uSJp3D+y90Z2bBa0MdBZXc4+9qD71jLrCq1OorVM6j4rWNS+frG5rax9CNttFeEx/WXnXVRe8VK498tchSuDLTEn1hfg36//CZqPQX2ZCaV+aabsYN3WI+t7QLsaNj6Z2sTifdnah63TkPWCWZwv2Y46D/rrgxhtvxHHHHYdVq1ZBCIFrr722Nv/1118PIUTlZz++bHHZZZfhgAMOwOLFi7F27VrcfPPNXW8HKzB1WCR6WJT5D9tGlQWJNl3kCQGpJFFiskqkmeWqXDYSuTARp1VjbNRJDy0ldD7T5m8jdRdtxtr1U5JBGIUmHFTtSzz54icOmuYLygmjz8ox2yC4vDC6jKW7S48pMfZvJLL0bmV4n+On5p+AIE46GXX6TpoSGfvittK4jS71XEXSiyzdC18o5EJ6SksGhSySBli1RkeZOY0yGxgcbUqidqH/iqpdoLQD2qTUU6Z5VQn0ZAZk0qkxQhSQXpqElBnssFn9TLVCCaDsD0PtgN538lycLaQfZ5rQh9tteuTlH5KXig3EXv6p49WgjjvEtqlg2SkxNJ+q5ovaRkcoUtdd4SGxN77OERf7KCvkRdfE3BAXQWyhYhvw7aSrXfj9xGZPgZkL7Ny5E2vWrMGZZ56JE088sfV+d9xxB5YsWeLW9913X7f82c9+Fhs3bsTll1+OtWvX4tJLL8UxxxyDO+64w8vXBCYwNdgl72FRLqIOGrDkRXqkxhKa0Gn3VI5MKN2cBAFkSDprSmL0C8scD4Fk7oyfOGqUHYcBlM1Igiw3OEJR46SrThlx8qKC7XR/IO6sSXpbxJxzHZEJSUwUpCDnuBsIS+PJ1eWJOWkreVPnTMgLbTKyqkvmOWzfGY+JIkJktGOmTrmUzqtEpg5V4qL3lxC1diFVhp7ZJpRCQQICS/ABQ95N/bdNraabr/7fmEYtuSf3vELcY3ZR91ZuIOhh3lrykiD1/dqGCOspIRiebZhrjvPyBnKP7sSlMa9Iqy8xVbIy9xFK8pIi9WNCp4+59cHtYjabkBREpe9ZP2V0wYYNG7Bhw4bOx9l3332xxx57RLd94AMfwNlnn40zzjgDAHD55ZfjS1/6Ej7+8Y/j7W9/e+tjMIGpwaJsGhNEBaFTOFvnC4ROWkaddiZ1xJmJXDtrqVzUCfjOmpIYmD4xQghkmSpJTGbcihJxFSaILtsg+a6KONwqMal30Enn3EeEGZ5b6JxtmnXksfdUG0cdU12EimyjhYfwiKZq76TNvinyYp20jS6tRE4jyzEhXVRpt1nnPE7a862zTrX15+WwnyisXXh9YFDahU2ztjAtc4/MZDJzamXP2Ykm+5CZ6zcWknsQElMoQ3LakHshnL14/WAaIFJ1N6z31D5SttGGuAxiG8ElhaReJPLU2gbxJ956SO7riD4JpuqVSUSIPQIig7I50diAtYsUqQ+JS2gX1g662EWWTTc8jOGhnyagWBkAsH37di99YmICExMTA5VNcdhhh2FychJPf/rTceGFF+IP/uAPAABTU1O45ZZbsGnTJpc3yzKsX78eW7Zs6XQMJjA1mMh6mCDzR1cJjHDptMmIkplp0+kqyxR6KkOmFHoy18RECet/tfM1SoyGT2JSknn5EmzhqLvegMBp1qoxLclLbZSZcNKVTwWE2yO7x3wpdd6tHHXgmLtGnEnUOGmbFs5jEZKXsomoJC9NDno8KxLO2jh4+A66fwITsQuhnF1oIm6IDASyXDniEtqFLtAsZDZR24UCTPu60h17IaFk5mwh2cTaBck66f9tq0pGyUsTkak5jzrQS1VBmjIrQlXVmIptkDmlnH2gktFPGwYosQ/6Anp9oRLkhRJ5ujyWFYTgl4S+b7vIRrMJafXq1d76BRdcgAsvvHDgcleuXInLL78cz3rWszA5OYmPfvSjOOqoo3DTTTfhmc98Jn7xi1+gKAosX77c22/58uX44Q9/2OlYTGBqsEs+hcXmU+mU9ZZNRtpBl45aVMjMmBLoWUdtIs9MKGQyc81KQqqy/AYSU4k2zacFknI5hWjhXSgpAVlOkRDjpCsOGqg67tj+7tSCk45cg5cn8M5KCO/yQrKSWq6QGOrIFYlUw2MmQDsjRtMdeVHleqC+WCdN+76EyktuyEmeSeegLVkZywpv2Tpku2zJTQ7SV4Y46dxGmuZu2fUUCqK42PUqiSlto6dyFEpgTEj0VIZCCWSwNlIqlT2pz7snFAqjxoQkxq7biSAzoRzfUfYBJ/rCREl95Nkl1Y+AaHjkpIG8VIhLLSFqto3ouauS9DvbILeALofk32VPqS4mgZL6CsFvcDdtlEkh4PV7Ke2ktJUUeYmR+jFjL5TQUxuhpIXaRswuAG0bWT57CgwNnAcpAwDuu+8+r4/KsNSXgw8+GAcffLBb//3f/33cfffd+Ou//mv84z/+41COYcEEpgZagdHLdOhZYcjJuCjccozMTKscGTLkucK0UV0KGl1K6C+D2nHSNOLMdD8Ba6Q02rTKin6pEhWGeovwhUnTw2gxAkGIRsWpettU3KG2JC+x6dPrzgsInChgHKkyxZRKii2WOt4kiSE7VFSY4Lpo4UKh8jFDW3iFtIA4aXrugfriO2kz2kIoZKIcFk2HgFpnTVUX23w0HnPWCeecwXfSlLhkCRIjVYZxoUdhOCIjRGkjKJxtTCtDUoRWIaVQyJRET+aejVQVGFRswxqNLHKjwEgolZnmveDbSfa+WoIaPCdHZsIXfPjc65ZDWzFpnclLaBfh8UDy1pxieXnGLogCRVUXuxxVVuw1xMg9JS+KLLdFnYETO6BOiDYd2WeeidJO2pKXkshLokoaOwnIfcwugJLUZ0JCzaICUwzha9R2/yVLlngEZiZx5JFH4lvf+hYAYO+990ae59i2bZuXZ9u2bVixYkWncpnA1GCXbAq7GDXEEhg7iRBdl6ZdUkI7aeuwxyDRk7rCZVAYN7J5LhQyaTv1KkDCyegOMoMMJXNRRuUSgCiE53y9iIa4YOec7bq3td6XhE43VF+anHScxPikpXL8uvOh+YmTLfvBVImMQnlLSCDqbY85aveXLsecPBBhVbETD5aJk/bUF2GVl7g8Ph5RXkIHTYmLJTbj5C91zO6vkMjNNYTLdYjZhmcXhtBYMjOtcoyLQhMapb9YrVUYhcw2uQqlZ9yqITFK5cgzaxvCzNSr36wiQ1kvNAN0z9A1r3ZFDRmPqi+RbRVbQYK4JAhRHSp2QXZxHzpVmszEFBgvTfnVPiQvUZsg56Ei6WUGcn4eeSfbCbEXdr5C4TcdCaCiSobkxdqDXdb2ICuEfiyTHmkZF0XSLgB462JEm5BmE7fddhtWrlwJAFi0aBGOOOIIbN68GSeccAIAQEqJzZs345xzzulULhOYGiwW0xi3jk4UkEpgHIbBikI7WghIw+D1uoIURn1R2qCmlY4sezLHeFZ4Cox1yj1DaHIhzaRd2rEroduglXvJaRUGMB/AU+ZvJLp030dqA+JEk9vNXxFxtp3IS4NzriVU8V08XqHXSyITVWBiTtemG+dro0p7HeFyJ7ibRk44XDZ5/C/jViPMcBr0GHmhzUWUuFjH7Zy0cc5V8lKdtCvWF6a0hdI2JJReFsIjM1qR1MeeluWoPADIiBI5Dd2pfSyTno1IKbRqI8xHVDPpyI500bnpwEuaispnEHsm3YmMSNRVzy5UtX7XkZckcQlsock2Qh7tcWyT4KYPSBEVe76JfULy4ghLf7fTP9nATqgtlCOOStuwqiSdnK4LeYmRercc2EZJXnzb6InZmwdmmE1IbbFjxw7cddddbv2ee+7BbbfdhmXLlmG//fbDpk2bcP/99+Oqq64CAFx66aU48MAD8bSnPQ2PPfYYPvrRj+Ib3/gGvvrVr7oyNm7ciNNPPx3PetazcOSRR+LSSy/Fzp073aiktmACU4NdsynsmhWeZFcoPY+FXs5ck5H+q510AYFxVTg1JlMKmVIu6rSRZvk3NxHnGBFcdCWzvkiqTA/dM1J5lindF8YQHL9PhfAlBkSWEwgVlkDF9bZ52+vIS+CgQ+fcJcqsnGugwlClRV+y+WoxSReAfjEKwEwaSyLQMr8CfGfd5KBT5x59caKMMgEytwVRYBxxKac+pxHmorxw5MVOyFU66jhx0cs955DHRdmkZB2zduTlMFIg3ZE3ZhuFU2RK25hWOcZVgQIC03Ks7MiL3CmVmSrVSfsX9lmFqjlpZlXKkBohytEpQgcSuoLS74ep8qbHnk0MIRkxaZTUhz+v/st2dmFPbxC7qKgwhGz7qovy1JiAk/juw5EcEzDRtH7IvDvZcrHyRXb7lyiV9BtHtk+YJfZjTp0sasnLRNarEBdLWCihL5dL2yibkYI5YWZRgdGWOeBMvB33/+53v4ujjz7arW/cuBEAcPrpp+PKK6/Egw8+iHvvvddtn5qawpvf/Gbcf//92HXXXXHooYfi61//ulfGy1/+cjz00EM4//zzsXXrVhx22GG47rrrKh17m8AEpgbjKDAu9F8rj+fIABSmWUgiR9lEJC0zN6qMXi4Ncxo5ciUhhUAOHU3m0NGjjQikFC6SkMLv/6CMt6AvPVe6CP5S9BlpegicaqXvShfyUhNltlVfgCDaJIqJjR5t0bGJuSrXRcsLpfHw9oWRJ4EjPjGIIKP5S6NM+zdUYaJzVcAqMGa4tCEl5UijkrxYSXw86xnS4hOYkLRox+3L5TGEtlEY518o4dlGDolpjMHOgaT7fwlfiQz6rhdCYEzoT3JkqoyupVEkC9Mh3t4jKcqmOGUfUOxv+CzCx1RHHFSQFpCbVF2v5E+VMQTbiNkF/KSKspIkMSlbCNPIdSlyTdH+YSFiQRa5WBuTwfwtv1FkmlwRsxMZV14IKbHkJU5geh5xsbZRqi+lbcgF9XWhKo466iiomgd55ZVXeutvfetb8da3vrWx3HPOOadzk1EIJjA12C2bxK6ZjgKtky5HXJhpmWFlchpllsvTSpMW+5tG7hQZq8CYAk0HxsJ1ZJRCy+hKZk4ut81KttOibVZSIISmjsykk5OqCiLrYb5a8hI46HSU6RtJzGF781Y4jywqCkwZaaIMFa0nNEoVVV/cuZnzcKoNLdc65PAGdiBdcRIDdzNp511vRlEbadJ+LzbCzApMOAVGO+SxTHoOmhKXcdEjkrnEIuK4aZSZk2YlCxt9hlFcAdHKNqZVrs8hN2qkVJ4ak9mvNcaCRJOu6HBrosKU904/MOFG54FUjOrzS00xUEcYQhsJlyvrEu3swix7x0+8POj5NdmFS6cqpLORGhKjSF6gqsLE7CGEEi2ZjD3v8q83UZ39ARX1xW86Kow66ZOXRcYGKKkfd0plSeYpobFE3tpGqb6UBEbM6qcE6Hxh/ZexUMAEpgZjoodxy/aNc7YRagEJ0/iDorRuXcHVGCB0W/54UGYhTERKlJgxIVEIPStvJpSLNjOhUKC050yYlo+IouL6wXSFEpUoMoU69cVt74e8EOfWdB7hdmW9LADb38eSOKeGpIicIo6a5qdeXJH14BpUpCwgyB89cDrJNoFQhPNPhCpMLnzlJSQvloiE5IU66EWicKQF0I6Zrtu0EqXyAmj7aGUb7h6NAaIo+72YKQVsM5fu2yKRi8z1e8mEBAxph9L3gTrjMFKPViWPsZokj0RH9kkQkzBPnSpZyVdDXmbMLog6GdpIlMTQe6WCtJg9dOAoTYgJprGvppe+MaZOlqrkmPBH38XIS0lgek5toUSfEnpKZMYWeB+Y+QwmMDXYTUxjNztE1FiU7eti0wqVYVrkGFcZptUYCiGwSBWYUjlyjGnCoiQyVXZIzJXEYxj3JHM3iRd0BR3LzFTr5m/uhlXryNK96JxXbZbGY06XwosAYw5bRbbZj8fVRZgx4mKda0CCKueSuhQR5DMOW0eUEUWGRuLmTef1f5GlIgNzfp4KExIZcg/dSyAkMXUIokygjDbtZvpVaTebKG3fJ39tx90JGmUS5cX+Fgm73nOExjpm6qSt1E5JSzgayZtaQJT9wAqYZWQohMC40stTKkeuNHnPlJ7vJYfp42MUylJ9mQbkOKTp1F5Ocld2cpdCd3SXmf4Mh1JlMxJQTjmgzL3t4reF8v+6Z1ohI76N0PXKX5mwC4TLKkmqOtmFIxmK2IJwdRUCTn2KkhireMEn91aFcaSG3hdTriA2U7GPumugSpK9mcIfPm37hdFpBMoh06U6GdrEWCaxOJt2tjBhli1RscQltI1xFD55IZ3cc/tgZwlqCF+jVgvoa9RMYGqg5XiFAkIHiipDjgKFkLrzosrMmw/G8HrIkWEKtq9MD1BjmpQgc/PGuChT2KGjdk6OMoKgRk4jTdHkwZrQxjHTNOqUEUSZMfKRIi8gx02Ql8qlpS5V+HlpVKhvnSUBwnPo9jEl09wKWSbX2khm6s65A+gIC7sMoKwbILOBWvXFEQ5DQsyvDXmhDpoSl1gfGLtcQCC35N7YR64UCmHVF6WVGMISc2QA+fDdFMYMzRH6pzLdx8WQE3tdsMOqFTwVxiqUqXvYWZEM63OiXsaIfcUu6L4xohJNa2kX9BzdSVXzKrJNKDhVxtmFAsJq75GYSJtSWQ5ZJgd0NhLceo+8DCAA0F2zyI2x6otd9kYnwSgyxv9qVbJUWZrIS0jqrX3MpgLD8MEEpga7ih4Wi9yt62GhVokRKMxw6UJkWnUxJpKZSj4NPZrCRZYACtsOBD3hl/07nhWQRdmBl3bEtJ15M0umBO2w2MIbhN6EOMaU6lKrvgSjKnwFJkJeiIOORpzeObVgAB55ITPwGsdZrisrZfiRptQXr7JItCnh5hCB0l/+dnOKeC+scrlMtycBQqb8800hRUxjE9eV3zcq1RfX74W07U+QaJOSl0Xmr3XOriOvc9KGTBtSDfid0UNICN3fxVTswvRn0TZS2kYuJAqVpTsFkw69hcwMyc8gTROr69BL7gm9N/RHX3W1ZCYkCe6vqGyvkpZAfQntQtLlertw55A6HzTYRmATrgzaDGRVSGoXJEuFxJDO1S5WM7ZAVZgKubfnY0lO5Fqi6y3hkXpaD4jPHDfkd4wqLFmoSoY2UXjEpewbJgnhIeTILKtZVGAKY2uDlrFQwASmBrkxBABuoi0pTAVyTqFw1p+b9FyUzhwKjnRkkMiVghTStfnrqLL8q19OWfl3kJA+JAiUyNQRicQhRYyAeE63D/ISIy5tL1mU+8Vm4KWKjIDvrO2+yWhTkfU6VF587tTqyUtHUpMFy7F6QSPMkoiYURfm7yKiwITkpRydVKqBQNnvKyQezhEqVG1DFHrEUWAbEPqbRePomZFK0imUEkrPAWPOu2d68tq+MFa7GcgmauAedeKZtkKlXgf7tyUvKeLSdC7Cz++IGyXUNXbhkZhw9l5RnhtVYTziAvj7uDTCpFRkve31+ZeqyQx8Yk+/GB0SHKqm2I6/VsV0qiXoPDA+eQlJPX1HzAakGrwPi+xwj+c7mMDUYEIoLDbOuzCVVqJkwTby1HK5cENF7QthCqV6I437lcL2nyk/RyCVwJgoUAiB3JCWmDxqh1PXmkvKYYbbKaEheTxSIk1UKcsIEqqMLO1ymwgzTNfH8h1YxQ+kDC0UlDJTllNhyLwvTnnxnbWdB8YpMWG06e5BSXIqp+Yi2mp0XukXYEdihM/HZlH27MwlRp5/GGXS5iM6iZeNMMvOiTrC1O3/PRddlnK5HZ0knVPWBAbIzYXHW831jNAQek6iNrbhkUI6dNqgyASk1IqknjbdTC0A+jIqyX2bJlXdP8Z/PuUzgfdMqB04FQWI2IPZZmzDrXs2YdaVivQRQ9UuUOZ3x0TELsg2h8g7rY1dUDXG1Wfb70UqN3KgosBIAFmgwsiA5NjzVESJIeQGJJ/+/EP6WdKpBVLwO7UrR4S92XVJs+oi0TOTlZY2khGST+3CEnpqG4C2j+kWdZAxM2ACU4NxlI7bEQdrlSSAsHO+SOg+AFAZCkinxOjJ68j8AUoTG9pWG7PdMOqODX9r2/PfOeQgjb5kQ+edKqOSJyA/rclLzEG3uR6aR5T7qwylsmKiRz+yDCJO12/ANDHY+xM42xTsY3OPL7gfelmg6aKUQnTURRM8Zy3KzwIAcOoLUPaTcekuulTkb9VB56Ks/3nk+B6o5FRjGzns0GoJmCZWCdunDKDKT/SaY8S+xb2qRaS5iJ5Cyh5icHlj9XwQ8tJ0/Aih8ewCvqpClchYWZ6CmOr7Eti1swUVlEXcm/Avr921wZJQkXwQYb1w/adQKpN6ubSFLBIKUtugvzrbmM0usXIInXgH3X8+gQlMDcaFwGLbT8WkFdAdByUUCihMQ0eH07YaK2gSY5dRfuxOome+tKujZDtpHRTpcBZYs23vnQ7IizNobx1BNBlEmNbhxNrqzfkiVFdSEaa3TJyxK7tKXLxJvgLH3G8Tks2rhIDwxpxT9kKiS8PinOriok4FSOFHmOSEoiqM8KNS/SuVlqQq4z2X+MWqjjKxddKhRK5VljKqzIwkvgi2zV8GUSYwLjRhyU3dL0lM9ZwKqIptTCtdl20TU0aamuxiAYFFsB+BFG44dwahXyKKNn/5w6gr9yq4b/6PbhTevRfk59uIqNgCtZWU+lJVYVTV3mRLQj9HdhEqMbq9QZD9ofuJmWUoosLI8tg2TqPKi5DCTMYZ3G+gkqbMcxCtLzoOSu5ps9AiN+Io6BcW2MY4TOdeKEdaQtuY7if66BPSqJuDlrFQsHCo2Awgh3C/DKbyCoHcLduIljD1QO+1huOXG0YL9eu2zVMpEW8Djb3sqHOIIdVJEUEEGpajwn0IKSH5KtEl2Z+SF92vpiwj5dBqnR4SkWvwcqg9v8h9aER4XxDcQ7rNHS/tPPqdRyOc5r/6zRZffaFpAFECUTYZ5YLUeWsDwv/BbAtto3T0VsYvbYMOPw2nZE99rqAtkqTPkpJKWrkqSHr0+TfaEymL1KnoMsJlQnRi5CVlgy3twpEjVWMX7q+K2ESzfcaU2YofCeHIZI0/66O/h1VLKunCnxag8ukMKEeknfpifXtAXkLbYMwNWIGpwSIxhnFTN/WH6hSk0v1QcgCFa18mb2UFT5a1cnkm9FwwtLnIfdhO+QK9DJSVFGyU4kf2QZQphXGMwo8gqTOjjihQWWzH3TLipJEocbxu34TyQsuumwivcoERBLOUuaYg5znhRZ56JC8ZWZFSYmCeZ0JXr6gwAmXUKe1xg0hT2vNV8GYk9Z6ZctXGKgeS/O0HtPnIkgXrpBehbNsfh8QiISvKi143kzc6JSWId4TukGsJkCT2kAlgWgGLhMSUGQadKwVpXgy2iVWnSWcHjui07BipCLmnaU7QcPcYhNwSG5HUVqhSEtR1mhZTX7ztJTGgfV+q/cR8uwDKNKBM0+mVCw+ehR+QAOTdL+D1hbEdYKxd6MpXKi8qU/oekf0BRdrR4frE2IMqIdyMEtYeBKBVmMBGaN8x+/N9WGkrpY9TZReylnZh1ZdouvHJtEO7JS6LTL8ZS77152RKu7BkHmZ5bBb5C8/E64MJTAOs05bQ7fe0cbgAHBNPzQSQmbb+EHqYdT1iRqqUMEZcrpcb4TmwWgSkIRotJaIsP8Ij+3YlLzEH3WoYNd1R+G3yVsI2hVvS4pEYe2iBsn3eLgeOFcH1Obk8vD+CpMFPp30Ewv2cVE4cdYi+SUyEBIQKYZnX/i2dNGAVlozkK8+lUMpsk66TewYAQqBQOmqVSpMoacjLtD0HVbWJVF+wGKSqSumW9CWRsg+v7vvk2HvGJM0R+6CueHbl1R/lpbclL63tIkJoov1NDJmhdhHydf0YVNW2wvpM91OlLVX6xDiDi503yH0iHXktmYFKPlNaJLWRfppIqPri1oVy/r3MF6qPFVo/o+A+MD6YwNRgXOQYF5khL7lWXFxoARdtSqGjzwLKizQL46hzoYdP2zlhUg4cKI3PGqSEcKSFNiW5H/S5KBJJascodHQpQf6a07d5idriRZ1UfYm17ZN+L2V6sB4jLsQ5h45Z+N6o3QPKiKLhokVzj0yUV0aehnxm5fwvOiJU5BsNtlwFGrVbgc0bOmp5QESFqagy7pmYMjJ45dtIk/bbUOY2WOdtpxC3MzVTh13UuFAqk9PmIyqRl3I4vAhz3BBvTWqqx8gEnG1kZnoAKP3AFwmBKWVHa5S2oacSEKXiElEgY9DXnLm/frpuWrU8wZJC0H4wnuoS1HMECopK/KVNPJ6tVW0G3r7KI8JWuUkR+grhKS+28T65B2P2d/1e6XeREnZR6QNjSIwu0x6fKDMealQYAaJ8GnWS2itVJ8l9VYQUVfs2EZUy8JmA+TK6tZPgfHNIp0zqSyOkBcpTX3Q3AW0D48YuLHGxZH5cNNdfxsyACUwNbOdDPTWdlrx1yCLd6Aq93fYB0JFmk7KSQijteVEFMVyLuAoTRJAJNLZV07Rgn9DpepEoyv1pdOmlp8hL4KBTfVHc5dr8GY0UVRk5As55uZFGZNk6Vyh/dtLoz0WeERWGXJsXyYfRpLteE2kqso0UFDaLpBSYQTvjWSdt4TomirJdPyQv1ibKr61r23DbjfpSltnuvRsbEWIRu05K4sII3evA6+6vRrQPUqTu+s/ST6+oL5Gyyu2kjlPbSRw/Sl4GtAt9CFOm1SYDuwhVypgiqTkNmR+GXKuCv5xUYcL7FhCW0lbMWSt9xpTgU8gGGxkWaEd23x4icwHMIGwAM2gZCwVMYGqg52SxsGMRtaVbuVsKeA4b8JuH4n1csnKuDBdV6kpVuCg7I9GljThKIiNNROmUF6u4wDjpippil4kaQ0hGRX2JjK6o9HsJI0wTgUaVl5hDl4GjBlqTr3IFQKHKZfOoaOTpok4ooAiUGNonBoLMTaJIgZE1IXwVRsBv76dKTI7SUUsBlamq45b6PJUUUJmAlBmU0N8LUtAz044J6Skxtr4AaRWmQIZx0sBZduz1SUbutpeknZKXLHB6/no5SUiBwpShkKPq2lNNpxK6vrsvWNvvjbkmXOFduyK2IZW5X+5v+UKF8uu7rpvVfmF+uj6nUHmxdd3vBxOxGVdmuR5VXqhdwOQPSIvXbNuAlF04EcIqM04JQWkX5l6p3Ky7PjCWuQjS70WZsvQ9cApLQoUJ+7vE1Bb6bJx9SKHtVAp9vkapLJTQImlYB1RmfKqv0oWI2QptWq0ok0J4TUdASeztZzBmCwqDj0Lq66O/8xRMYBqQiwyF0sM7qeqSB+shUs1EdXK/NbpQefE69cJxgDIacX8ROAn6F15kGKovMRWmrn3fU1FcmQOQF3IrW31OACgjQcCPGKWCyISvrrhs9UqM9fbufIOmpErkSJYr/QVovmgafTblNdPLpxFnGH1Z8kKbGykKVQ7hHwTWQefCr7uFqkaeMbvot8Xd2krRYA9umdoDVWFo5thzQVDXI+veMso8VJX0+4iFM08rf7mBvMyUXTi1Er5dOEWGKjHBTLwI67fZ5uo+/OWo/whtydkBKdy77zotNm1ETH3xl7NKfRkUIbEHqnYxk+CvUftgAtMClsR0gftitYkmC4jAEWee+kLb96US6KnM6+dSyMxFmVaBUYCO2BX8Nv6AqFiBwfXdsHmSKoyKpMHrE0MjyooKQ2ftjRCX0DlXRiUhSA9QfuvFFgDjXMl3kQpz4ZmhLAoov0Ct4koMaef353aBfz1UoQnUFuuDtRKj2/utKqOU0OUL/X2lsBlJST0dvzDPt8h0pFnIzDRP0roiXYc+W2dsfZMqQyF85cXVxUi6Rd18LzEn3Y9dhN9h0bYREqPMV1xUVlUmIbRNKIFCattSCtouaPORVSaVMMqkUWQoebRqTGAb1X4wvvoSrR/WfqhdKaVHxMXIiyUulNAP2S70siV35svUETVGWGdhlRhvJl4zMgnw+8PYY7tDNKgwZlkIUTonoloqs02ZdOXmZ1Lm+Wbmy+Ka1BRKYMz4xJ7KMEbtA4KQYGsXpXJZCIFxc/5SZUAD2Q/tYjaVF0YcTGDmALGPacU6osXSvEjEizj1YmryOhfpAJUos1Z9oQhe5H7EWTrsGGLkJTZJV5so0/vWixclRr7fQtUYehwbYaJUYmD8qX/PlPey8yJHBMso75si90mF2yrHKN8lADzVIOzEC/hKjK/IZO4DoRSFaaochhrTD0KKE1MhLZEJpf9Slcy8a471f3F9h+x/NNL0iEGE2MPfVtkvrOveT3nr5UkQwkKX+yAvfdsFULENAW0XyATZlxAOwCkx1CY89UXY6xGuTjepMM1XEMA9Q3uckpHZjttumfjUUGHQHwgIttdwjwIlsZlv4FFIPpjAtECXKJN+LVS3yWbechlRZi5CmFZ5GWFCoCdz56R7RnWpRJmmrb+MKOEinOTcL8Evqr6Eoyhi7fsKFcWFqjIxB52S0wGyHt7mlNMmL2kBZUb1wCgw1kObdf0AdZoZMqqM49bn6rf7KzO7qIs23YmSdRdNKri+MNa/BhK7mxPG7m67i9BI0zp42+9AaAXG9oMpZIY8kybitOoLGZVE1ApbB60KUyjh5jKikEp4ZKeAGW0BPd9R6OIKJQeWykOyFVMmK33DPCWmVCalsn0d9H1y6iTpG6bcSDxBbANuuewbIyr9ZLz+Lcqv/xW1xbMp5dkSlA7s/cnk4sRlRuzClEdtQ0E4+7R2od/pQs+y6+qrrpxOoYSqzAVD74Vyp5AYkSTcyVV/0ioyxF6sOmNsSBm7EEIgy2D8oq9O9mSOsUxi2qkxtq5kToWBsH2uMv21czMRBiUu2m78+xyzi9kGNyH5mOvn0QkXXnghhBDe75BDDnHbH3vsMbz+9a/HXnvthSc84Qk46aSTsG3bthk5FzvvhZcWOGILSW4zjT4LElWG+3sRN4k2wyjT+TKiwtRCRZbpX4UgEiwjzDJPSVIqbfuu7MjJRPILpcqXh91Pqfj+SORxnS4jL4BIMZX+DhLB9aYP7coPyqBReViOH5lHnpMry1cVlEKlDtBl2pG3IpXbF7911HYquyCC0wSi4XoTiBF7+tHTGFLRX6i+SHJNKSXS/pXkfkX7vQBwo4/IfbaI9QuLqZKh+hJDqMK4vqHUtoL8rchLv3YRsY2KmuM+b6Ci1+2POixJV6g+uetxx/HTQsU27J9XtanyuQaHr/jCmL8M67qzl5gC6LZRv02323otyfY+DYcxNIycAvO0pz0NX//619362Fh5Ceeeey6+9KUv4fOf/zyWLl2Kc845ByeeeCL+z//5P30dq1DSOXcJ89E5pVwlLqDMelnZ7UgKvV04+b5A5r9cgjZ+rbpk6MnMjbKwbbw20nB9YrwRSCbChI726+Z+8RWUMMKMqy++mlBGj54KYyNMF6EGykuK6FDnbNBIHgK4ia8KAEJUFRmoSsSpFRfzUUep0tGmpzMH64EK45QUE2kqO5rJKCrlPYHpQ0CVGWG+7AvX3i+lQJbZ/k8CeabVuDyTRonIMaYkpmXuRidZqZxGmjHYehnK5IXSM+jqDuu2N6c+4QwiSlisEw/twj6SQhFVJVAmPXKl/BFIhUmbllqd7JG+Pj1l+75ksN2ttGJF+oWllElX12199vOF/Vtio4vSI/V8JTKpShY+USin9I/bRdQmQhISNh2avi7uQRDbcN13ldlPoGxqtVslIDIFFNX+MNZOnPIi4C1XRiQJsi0gKqnOvIL0f0Gmn6kw8ydZFUYK4WzD+kbbD6Ync4wL3Q9mWuUYVwUKlbnlKTWGcVGYfmECmVEs7czQVp2Uzi4EpFLI7TQBQrqOvF37gQ0C/haSj5EjMGNjY1ixYkUl/dFHH8XHPvYxfPrTn8Yf/dEfAQCuuOIKPOUpT8G3v/1tPOc5z+n7mDGmLSOREK0YcZZfNifRYaKVyeuIdK7X9f40uCqVF/KDH00Ksp6OchJpbt9E+77NI/197H7upCnaOumWoy282UaF2c826WT6WNZZKyqvK5SO2iaTl4mqvAz8a/bS3HXpv8qVXx7Lc9TJ8mw0qkCVmHAuGBlJs4i1/duOu9ZRezI5BDIlzBehy6HU1lF7ZUMlOy3SqLQJtIk1up104C2vyx9KTa+VTmymE0jZSsBTvCLPoNpnpfxbUSNS1dI9N7uvcumC1m+qZILkpWn92gXd5vp2mU2BbYisnOvFnSd8EmMnvnNNq3YqgICEaFKiF5S7ZvjL5G/ob6L3OJrXDqMOVGjAqXCxSUAt4v2udEde2z/MduS1NqL/KvdYwuZV6aKR2QM3IfkYqSYkALjzzjuxatUqHHTQQTj11FNx7733AgBuueUWTE9PY/369S7vIYccgv322w9btmypLXNychLbt2/3foBVXQwjJ+qL/uqudvo0yrQ/K11OqzGvnd9GmbT/i2vLj/R/sVEmnXXSSeYKZPZdUYkkQ+OPkpxQfQnSquXQfjBkZIXrD6P0MhmFoRUbVTpzaW6YUp6a48nf0WuIn4/9VcqxyhM9ts1DJXOSj15PtN8P6d9gy4qpVLFtHglUwXNTIM/OzMRr5zMhdcCqcWG/EKvIWMVCknqoSQxRAm0aqo6wQPn+LFBVHEt7UJ5tULuQRpGkyqQ7PkhTV6BMFk6NoXMjZZXrdPcD8FVJcs+8fi8A3Ogje8+9Z0EUlOAZ0mdayRt+B8k9c1PPSL8X1zfGq3t+3RSFqbOp+tzFLqRCk22U56aitkFHEtLrKe8NvbbEfQryRIMg6puscuzKKAmofr7CHZrO++PZgaT1yNiD2ab7GmoVJta8Ssm19dnatxObUGWd1zbhT2rKmF2MFIFZu3YtrrzySlx33XX48Ic/jHvuuQfPe97z8Otf/xpbt27FokWLsMcee3j7LF++HFu3bq0t9+KLL8bSpUvdb/Xq1W6bk8WpIzeVN3TSFmH/l7Azr96XjqrIHMHR68ZZmzJoe79yL7lUxAnfKQQvz7D/Ryz6KR2/qu6Lah79t+YGW2dNAvWyLOOdgnLL41d/tFzQcsJygWYSQ8sCSkUJpJzovUHlPlXuJV1Wwts32o/C3gp7O+zzRilo+S/0zJOUw34wdaCqRtgPJta/K6ayxNJo85F/PGIfQQdeS16KSARNo+polG3Ji7MHlH8jz8xXI0X8WZllS1rpugdXjvKPE/R7scdOkZek6tLRLjrZhoSX37MNl0a22TJRrb9Uqa27n638kcsbUdKCZc8vIqg3qpzMzhvBlugHQ302Jfelf1dke5XEzBZCQt/vb6FgpJqQNmzY4JYPPfRQrF27Fvvvvz8+97nPYZdddum73E2bNmHjxo1uffv27Vi9erWppLYilxFmTH2xRjOtchfhxqLMsP+LjZzp/BZUaSmkHWlByQtMxOJHL12aj3y1pUpUqgqM8iKrMPLyIkzpOz3npKmEHjhFwHeo+qZXX6QAEA6GcTNLKn3hQgEQRgqHvk9WNi9b+aElc8DMFaPvQ9m2rwAI15/Guw+y7PPi9QEwz8H1jwl+KrZdojoayb2U4alvlflgUI7GKRW+UsVwHXmFP+KCSuVZ0IxUmKYG92VpmL4wQIXdUQceU1/C/i9uzpoW/V+ccqT8/i82yrYj8/QjKUkM7SPmzYsUURQrdT6wi9i+cWWOkB2XjxACperJSx1xQXu70JPU+dvKWVfNMWCbX5SzCyj4/cUKBeRmTdoZeJWruNZGXHNncE9tvYZturKj66wNRJ5D1F5sC40r084HI0wfsXJW3lCh9n6e2p35dc00r2a2zpl+MIVQrt5mSvcNy+19tLfC2EY4E/tMgpuQfIyUAhNijz32wJOf/GTcddddWLFiBaampvDII494ebZt2xbtM0MxMTGBJUuWeD8AtQw7Vmk9Fk/6ueht5QiQcJp0IN7/JdbWm5x9ly57v3jzkbdPrBzEnTvN689xgaiqETppcyHBcYLo0TRDJWG3u2GotOzyGNGIMzjvMK8jZw0II9C2kWeZJvxzCPLqdVIHInXBgo62CPuOeORZEWId6YcSk8tttKm3K+8H+LYRqi+0+UinNztOX3GpjiBJjsyLKTAABL3PgQrm3Wsg+tx8laHmxG0+Qt5dMyXZL6q8AGhFXjrahbd/WL5dTtX12GzAnr3W+4bUcm0zkpeWXg9twCMuERUv/NyGJP6X1k8ZKIHhiCRLzC2obTDmBiNNYHbs2IG7774bK1euxBFHHIHx8XFs3rzZbb/jjjtw7733Yt26dX2V7/q+QEXVl3gbv5X2Sbuq8g0i1f8lJvX5X2A1thzMvutPXtey+Sj4+W3XfjRJJXLXD4RKzi0iTL8dnpRF20ho/5kWP7qfJ6MTZ11HYnxZX8XvS9jfIdHPiEro9F7qY5fPJlTHhBSR8qiiAE+FcX+j9YU0IUX6wVDQfjDeCCEQBSUgMbF/1Dao1B4qk3Uj81wTkpuroyr/e7YAVO3CKZPx++lsAfYZxvLBe4YiUSfKekHVmLIPFbUbWsdKVaa0C5fHSW6BbQxoF9Q2wvMqbbdK7u15Q/l2nVJmYa6P+plwub1fIsqZU9JIU2GouMVUF9IPxutLFaqTQRM/raelfy7JfaFIfQ8I/myAm5B8jFQT0lve8hYcd9xx2H///fHAAw/gggsuQJ7nOOWUU7B06VKcddZZ2LhxI5YtW4YlS5bgDW94A9atW9f3CCTrnAH45CXhpPU+JYPX+5Uyud7Hj5Rt/xeXN6hcyVEWYSVsUympM0H6L414KpEn2YbIfqkI01wM2ccseNFi7JyDxGA0EWAu3fsCLxlloYLRRl7ZcE1JyMsvWgsne0dGJNlzN05WBfdMmEsU5aU6B61IvvA8nOOGHk5N70V4q8K+UhR1DooSBzvqohDKa0bSIy3KEUnlvqoylXpoG4BP7KvHL0lKrP9LOLwzdLgpFaa8UfD6EIUvS5cWQaOi5vJURxL55aiyDH2SZXmJ4yZVl9jHTimobaTswpZj7cLN0KvKfUx9D5tZbXOs/uRF2QzkzjEgga5+m3NQJG85lQF5RgGhCZ+bUuSA9oIUvTjlKZH6UsO+hHqSOkruIYwKQ3a1o/T06CPdjARhP0cgkKEcqSfNSeaO7NRUiCFDARU76aeMhYKRIjA/+9nPcMopp+Dhhx/GPvvsg+c+97n49re/jX322QcA8Nd//dfIsgwnnXQSJicnccwxx+Dv/u7v+j6eMiwbgEdeUuqL9/2jRJQZjrIASJRJHLT2a6Ux2ugyZvyViAaJyAZVJx2LMr3JqUhE1qi+gJQZtu2H5CVFXELCUn0olSTXrm+JDCUx5qSsW071hwF11Ijd46rDpvdRRfchREYRpx7NJ8rjG+etUA4btfVBhS910pE39e2XVD+YQsjyWzCkvR+i7AtTXhwQ+s2Ybehjw/ytjsxrgte/B75NUCXGDZJx9wrwSH7yOZbPokmZbM5TtR26rZbYU+WF5tEXq2/3kOwCgCbpgOs/pgwbifWJKeeJET65V4A/YzW9D+VcSyqhboVkxbcZ4d9PJOzFHs6pMKT/i7sVflBZ+euIR9kPZhyF89M5FGJ9xCy5R2AbqunZDBHcB8bHSBGYq6++unb74sWLcdlll+Gyyy4b6nGtg/bSInU2JDGx7UDYTyHepi+Nk9ZpcNv0Qry9v+osRMUhePkiZUTzhGUn8lc6G9rtCfKSdNBtHQKNIEWpoKQizhiJcT7ezIFhOQRVYWLNDb7zDZSX8B6WPMojNHTirtI7031F5dnXqS+0rb8pSqNzXeTGQQNwUWboqHMIxOY+otGnPwzbV1S8fgY1HXjt+VOEM/TS++E1HYH8hWl+sLDPEAky4vIlFEeyb/Wnqn1f9Ml6ZfVFXsJ73mQbVDF0zw8V23DXBoXKJHj0Xpi/FXKfyO/OndpD3T4pJPwNVWH8mXhLIgOkSUuplJO6qcoPO9LPCmQI50xSxJYJiWHMGUaKwMw26HwvgK++6O3VNn7AGgGZS4BMk940gV0I7edIhFFLWvwXbV0EGbZTV/Ig7qTtMUP1pTbCdOWptIOOOeZU07L7xkt1HxdRkogzRWKQE3nbXrYjFOG9Jdvc9ZJnYtKUEpV7TfP4107cX/KFWt+Rl45EAvw6RL9MHU5oR6XysBmpUN53/pxkDiAqm4fqC51WIOz/0oRSQSpHVtlyYmTfQ+ylR4kL6gm634ykIragyL6q+sxIPfH7fyj60GrJS5S4tLWNLJEXqBD8OrvwFEohtM0mmlgrzUjBPXPNodZeIj6osq99btZAqL0o0Jasah1ApKmRKC4Abca36ovdr/pNJK1eCuTwJ3ukj2E2m5BYgfHBBKYBIXnRyzVt/CTSTMEbfRQxNtph0SLqz5SA942XjqiOULDpaUdfGXkUHjscLk33a0Ne2vSHo3komTFT9ieddYCSvJSOmqowtSBOWCFQXuz26H7Cy+j1C/DKFp40XSExMccdGYmUQurr1LS93xwIudAdGbV79y8sbFYNyyqXqxPYVc4/QXBi6d59qKgwCOpsWJ/98rztZH+vuTVSbgxUfdHrqiQplT5hHclLk2002QVQ9gcL7UJFSAz5erXmEpbBIEraYPq5GE5U8Svu/qjIbaSEBqQMt70kW0qZM3XuI5jk07slhrwQdRKo9oGpzsJb9oOx+1tyT1UYaxuzBSYwPpjA1ICSlzBNp1f7v9SWF+QJR4bEUCUyVancLtf2fyFOudJhjvytRJkg2739SjLiOWn/5InzJuSlgbjEmqJiUPazAUAZfdaRGNLun3LUyp23aN2M5Jw2vU9kuVaRiRCX0L2X77i4Ukc7K1oUKvO+Nh2DddqujESkWQQkBqh/l1YnBUt8wDEYgUSvJ0SoPtE0P6O/XCEmSKiOdnuE/NC02uYjU7cr5QJRVbKWvLht/uU12YYjJKFdAM42KiSGNKUKS1RgbSKiwpjNQsLZBiUcFXWS3lsE62G6u05rJ4KcE0r7qCHyQLeXtFVeYnD9YBLMdTbngGFUwQSmAU4aD9Nr5HD60bo2iH1tN4oYeTEIFY90GfCcCnW0oaLSpo2/tZO2+9U46KhzDtO80RZ6m09klJdXqOjtCo5RddQ2PRVp2uMrlMSmth9M5EXqrQdpVnovlYbqaYffDAIiJNn2LxGZa+un6ot10Lk5gVikSclMtS9YXJmMqSaxfmEpxGwnpj4pe4+8+xuuw3+RxtBIXCKjj4K6Uau+pNCSvLQl9TRfHcGnI/PKDu+qtC8Jj9yD8Hh7TdXviyG4Z8Qe6DZiK/DShfMbXpkh3P2qkn2g6kdjzatAOVTaVlVtF/XqJKDISCTTX2wWSQwrMD6YwHSADP52QZv2f8CPsr3oImwqCkmITfOcATxnEEajIrYtJDMhEvu0dtJAxUFHlZsUIoSmQmSCqFMomA/VAU0qjHXUJMiLnAPiTlaVL4OoVB6+SO1zgn3hkZFIiTdt3TxmMwmrwoRpFjGbGNzRVqcVqEOl2tQRx4B8WHh9XUiav0/qzVq1IwBpYt+CvPiTNLZ8+K7jbsIuaMfeSKfeykdOBannjgShcv+8Op8iMfQ007cx/twStyL20VO9HFdWBh2GbCYqnhOEiny/ZSwUjPREdjON6Gy7DT6kS5SZgvQizJaVre2LLUJk3N+QvIROijrbcBbcGidNLqbZQVNHXveL7COCsit5yYfrYvfFv/byGryPXarqS6rSXFB5IfqHikfy6ecc7+8yfCfU1NnW+x5Mzcs01jRaNzrPz1d/rXUd3gG4+yjC7SkiY9DUDybcJ9V8ZLfZfarkPGEX9i+ZREeEtuCV084mvHIidiEUSrsIyw/Po25emqDOe2nOTlrMiROUmSqLnqbFMG0iVAAHJT2MmQErMENGLiSmVdhXHU6iHwQqZswJZxJt5/ecjPLyl+nhwXzE+xTUX5vXdATEHbQrs+V9ou36dl2QodO0w0YgmXtpNsQEkcVpM1LNNSmgev/rXpTBfa5cqbevHXmmoptnE7GJ7eYDWiv35ME3Ko0tXs61zbXRz1uoqg0gsIsY4QjSGy84ZhNmPWUXYZNs2JTkTUVAm5HsedoJH2GbfyLNq0DcFgLfpEj6TCLVn8XL0+Z7InMAOjfSIGUsFDCBmUFkQgIRMtMVjY66idA07WcQjkqKRplIKDggDjkWZQLxqC7loJv8RziU2uu8S52176SjiLT32+tRlPxVSGDpdCvyeeo50P1B9knkmW/ot73f2oIm+MM7H28Su4rqIqr1E4iqKSHxDIlKlLiQOhFX5lS8HsfsAtD1sA2pbzu9QC25pyQFflOSTbPGQMmLLY/0HSnzh9efIPltEPMx7q8mWcNoCsnIQ81rSEsb0jMb4D4wPrgJqSNy0XzTUmpLitX3ZRx97BJVY0JSEiMp3nFVfHudYlOJPAckLzZPLF/sPIxk7snlkfPyiVvNsT0yF15bmBeRF5xI7zOgn4zVsUxI5JBmNtH0Aey2MA+l4LkQlb4ww0RWe+P7R6szjh06lZY4zRRJCju1p1TJ6rGCPHW2EW6P2Fen/mbkvGKf/tD7l4txdZb8jdkCzd/2/veJsG7Zep7N6kDo0cONN96I4447DqtWrYIQAtdee21t/muuuQYvfOELsc8++2DJkiVYt24dvvKVr3h5LrzwQgghvN8hhxzS+dyYwNQgdNT0Zg3SJJQbg8kjzrrRgTe0/QMBSQkJC4EInExSYQn3j/V/aUIYjcbIS+CAdZt59edBBmWQfducW/giaTvaQx8zvV7X1h/bt/Gx9xE1ZYgTlrpIsw7UHupIjK3XM0VGahEhEH59LlWH6DOKvFyTUwskEG0+Sp6vSquSCbuweWttItYPLCRDlf1qyH0A796R5di11g4ICJ5BkuiniGENLJmP+9m0DTTZx1x14AUAOufNIL8u2LlzJ9asWdN6hvsbb7wRL3zhC/HlL38Zt9xyC44++mgcd9xx+M///E8v39Oe9jQ8+OCD7vetb32r03kB3ITUiFwIPQID8ZkC9LwZCoWQyJXAtIlXMzKbRj4Ehp+c84IaP5pfhDGH4dJjeQnizikgIjbKDEcexfLbfYBO8114oyvsvtF5YOIfY4wiNs0mQK6n7AAQnplraiLnpxIxf0Vqj0Stw0AbkqKVmXpVZphI9Q/risaRWC1VAS+9KS1xzNoXfuIRNBIa+relXVRswu4bCVErdhHrIxbLr1DpBxPPj3TTUcuqlh6H162ctmjb5yUL/s425qIJacOGDdiwYUPr/Jdeeqm3/pd/+Zf4whe+gH/913/F4Ycf7tLHxsawYsWKTucSghWYARBj9hX53UWjNhoYglxZE/nHEIs2a/ux1JRZ248ghrpILuKkoxFlAiKMKOuOF2tGqi1PJcuK9XcojxPJF0SajR1Hg2dV5XyDh4BhPbRqCa3TnuIYIYI0bT46kq5Nc23VA9o3zAOZF6lx9JHy61e0424fdlHJ18YukmU1Hi4oK7Iv+eulqYgdKVSZEbWFYdT7hmCS+u+Q4KeaVmeySTXEXCgwg0JKiV//+tdYtmyZl37nnXdi1apVOOigg3Dqqafi3nvv7Vw2KzAtYFWYOYfnkBP9KKwTiEWVdeV5ZRDHKiPOuCu6trs35Q1HTsQciFVjgGQkaiPK1ulN6PLCTJGYsIw56nBnZfI2eolVJ3NRvp8zqNZzH7VBOHKicnvrFJPUizViI9Fh9iniPwykmlXDcwoRprV9iVK7aJs/1pEX8NRJlQX5vTLaH47mj47UM4dw09Qo0cmdMEps377dW5+YmMDExMTQj/P+978fO3bswMte9jKXtnbtWlx55ZU4+OCD8eCDD+Kiiy7C8573PHzve9/D7rvv3rrs+Rg4zWtkaG4DtZ3C+pHmm+Q9v6kiGHlRdzgv6lGVF2Y4AslLq6QHaW08SCrwSc02GkSoHlLpkWM0kq8B+rzQ+5CM9lORZrgcKT9+ujPYgdacQOgUQqWlTpnp6lC6NK+GtlH5EjXQjshEnmNMFWschdQCsU7s1TyR7XWdelOEJqXotLC9zkj1OQMaVahW9zEI1spvvololvj8QdXaGPsGVwxt6+Vsqi+ArvNywJ/1IatXr8bSpUvd7+KLLx76+X7605/GRRddhM997nPYd999XfqGDRvw0pe+FIceeiiOOeYYfPnLX8YjjzyCz33uc53KZwWmDzRNZke/Rl3dt8t06sL4pcjwUIJY8xD9JV+MJNIJEXUyA4Y6fc0qmgKJJGNt+l2iTK9NPwggvaHUdntwr+mVxIaTJo/p8gUt/kpE789CmkHTou0LxaLTPWggLxVSErOV1kFBy32aUEsMZtBmYOpk08dPa+yq01BqBe/+0XVFnlVahdGzOIVpFv5X2bvbTYEM44nvI80lWvDhVmUAwH333YclS5a49GGrL1dffTVe/epX4/Of/zzWr19fm3ePPfbAk5/8ZNx1112djsEKTEf0G7REowE7q2jN13bdeiTNM36XKX78sD9GdARSjNCE5dWNQFJlO3/XaLUvRz1M7bjy4mjR2TK4T5UhoyY9pboIRbiSgh9pQq9bhSF89jSiimEYM0L3g0F7eDXNxAtY5cXcE6rC0Hvo7reo1uvUyxRlvlB9MQeuPk9E8oHkn22kVJgO++l1shzr60Pzxe4VKaN2KHXsFxy/ak+lGhMGeArxmZury8FMuxF7afstu1HFkiVLvN8wCcxnPvMZnHHGGfjMZz6Dl7zkJY35d+zYgbvvvhsrV67sdBxWYFog1f8lxuzdhxytCqOE/wl3+FFn+aGxrJT4zDZLWlRgtPGQRP9pO4Ta5QUaHVCliaQt2rTdzyS6tvf3CW/UUXAvFfx1uIi0VF28dItQlbHJEdLiS8Tkq851HxyNfLBOov5r1DpPWE78eXb9mKOEcNupLdBPBzSOwAjIn7MJVOu6iNlGWM8VIQEtq23rWam79gsbNllvYxcN+SrKJU2Hn55SUpLl2n0T/igsTBMXP43WwZhd2I85SlF+M6mAwDgpY759jVpCQMzyTLw7duzwlJF77rkHt912G5YtW4b99tsPmzZtwv3334+rrroKgG42Ov300/HBD34Qa9euxdatWwEAu+yyC5YuXQoAeMtb3oLjjjsO+++/Px544AFccMEFyPMcp5xySqdzW9gUc4hIfY26gCi/+Bs0HUmVQUI745LYVF82UunpoW1UqbfBizIBxImJjTphnaPfgTcW6VQiGpqPHidA9SVAI7GEIdcZeMeJ6OrQKtqkI5FqzifZdh/7JlL4QiT5o5EmEtEnqmnK/fUjTTv7bOyFTusXAK9uFqYeUqJQ1l+T3/3Vt6ONiF6YW2ebVunXf6l96G3mmIbY23Ow+a0tlNcSIfZOgTH3hNyr8v7H7rOIK5EuLyEroT2APrvq7NQVtJmBt3GOoj5fjl361KTyp86F1tVKOajWcbIPKs8j4XfscwJ8fxY8S6pO0o85+n6U1qGM1PPwq+2ZSytUlug/I1w9p7YxmyRmLkYhffe738Xhhx/uhkBv3LgRhx9+OM4//3wAwIMPPuiNIPqHf/gH9Ho9vP71r8fKlSvd741vfKPL87Of/QynnHIKDj74YLzsZS/DXnvthW9/+9vYZ599Op0bKzA1KJSqfHHXVl69TtpZ7Yui5qN1Bdkug2gzRKUJiZITIE5IKo7Wz9vYgdcdyKS3HIE06MiM2mOE59biswBRWh6m17T10zyaGTYckzhtFdxbuxyNKmPL3n7l95DsCzv2oU9NlAWJLH1HXAhDUMhlaIXQpyeFiTTtX2+buTCrxCRVyZoPQkpYQu8Te89urFqJ6nXaZdo3TNntIcmPLEdVFzQ0w8ZeyCFMs2kdOpGRtu1wtsxalaTDXEjR/YHQPcVGInnzHpGRSLFvIlUUy+DZqCDdJ6damVRuG6kLlLgEpBgoyX2hMkAYAi8yp0Zacq+nEiic+pIrASlEdFDG/OslM3wcddRRUDX198orr/TWr7/++sYyr7766gHPSoMJTA0KlBXUZ97CRbPTKsO0yjWDh4BEhmk1hgICUyrHlBrDtBrDtMqdAdnlnsrQMwSmJ/VyT2YoZKYNUZqfElCStvULCClcpOKRGal/Lk0m+r+oarrvrClxgHOWQxmBNEgfl5DEDNpMZL1l4uN1Xr7KT7n+Fiq4tzZNSOdz9XKG8rlkpCwpoDJl8plJxVyfi9JJSyVQSIFCakdbkDpUKIFpmWNMFJhWOcZREBKj62Wu9LwWuZCYUrme60IpTAlgkZKQ5tpz+5YKby15JlHbMC8PqQSmnMKSYUrl7gVho12nwBgCNq1ybR8yx7TMnU1I6OvVv5K0eKRe6nuo7cKsm21CtlTBiE1UbCRWB6J1KRIQdOAuUTQ1xXaxgTBvivBXjhWzCWI3Eo7tUAJCbaIkHTa/KTbiw1QW7C8FIKFtRAogQ4XcFzKDVNKRlp7MMCZs3cowZlS/aZUb++gR28iRQ0KKDAV82yiEQgahT8o6V3IvZpPESBX0k+uzjIUCbkJqgJ2VOyQv1km7fMo6ZeFeGrEos0D5sikqEmfpnEspFKWTjjQPhY4XCLYnkJbHSabQUce+tDtMzFCn3M4qUt09qRwnOIb3TErSRzsylvc+9jxDla0qlaeHUvpSuSUGqWYkGTThuOYe97es95aDFuQXsw27Ly3T2kKq+Ug6m/FtIfYDymjb68DrPZOyqUiQ+5gi7anO142fEAjtjtQHV14D+rKlNn3LBrGlGjUp+k0kFeZJK8AV1OStKGYhgST2QdU4hbIpqWxSzfy65WyiVGUcsW5oYqW2AQzecb0LbGv6oL+FAlZgajCtfOcM6Ao8bUiIjTAfU+OYUjmmkTu1JVRfplWOSTlmosocU3IMPRJlFirzokxpFBglMygJKBOBuCjTvD2ENCqMXQ4UF+HyAUIqt15GpqZPh/02Sug0kCJHqrRc199DlSOQAivp7KibmpVmonOuUjq6y835umhSmZei2W51dXOfQvWFRpqwkaa9x6a1g0agNg1CQEill82zVuavzPRzF0KgyAQyqf8WUkeQU3IMmVDIhMSYypCpHJnUSksmFfJMIVMSOUoVBvA/ZCfdw9UhcAGFXChIpSINTnYfn9T7qqTAtBoztmBtw7eJaTnmbEOnZZg2qlJP5aVNGOWpJ7OqMikFUFCb0PcbYV0Plv20su6Hio3wfvH+L55qGfvOUNv6N4uo+6SAa+axmyUqX2x39d3U71CdLBViVZJNaUxXaBum+7qZjTPoui90M6+2A2XsA84+lElXIoOUClJmKKREITNMQ88uncsMU9C20VMZJo2dTMscj2HczbYLALmS5Dt10idm5jwzYw/UNnoLiBCMGpjA1EABmCbERRI2biPLKeSu6ahQVirXcn1MfZlWuVNfeiYq6Ek/6rTNR5U2fq+dX1ScbCxCiTYfISKLE9Q56W43UKXXUx1mh41ByY5U5cyF0Xscb0ZS7r4T503vtVsX5sUBUoYwZSgvn5ICKosoMUHH8J7MMS6ka47JMuXJ5YUSKIRAjkx/u8uek+gFUjncy6pAdWLGImIb0yRqteRlGrm2j4j6oklM7p17NVIOrllmgTJp71mwjhaRPMpn1qhiRmylTf+XoaIPYu+ICm0uatsUW8kHR16U3R6Qe78/DLx7qYJ0SvrDfWj/Fy8ftYlIM1IhFfJMVuqQbl6Vxi+bpiU5psm9kNp/QzcdTasx3UQLiQyZa0qy10/vxTBnnG7CMD4FsJDmk2ICU4PHVI6xYJSEdbqhg7bLj8lxTKsxPKbGTWQ5jsfkOH4jF2FSjmFSjuG3xTim5BimijFMmfb+6cKoMYXpB1NkkEUGVQiowkSYhYAwkaYoAFEIEkmSZUWiy1B9IduE9EfUVPrP0JcwbT5yTr7FfC9t+7+EbfpNoI7VLEcddXgumbkOiHLSLhNe6amxlHG0pskBcPdCAYiqMCYqFCZKLNfN6QkbdepfVpjbQtJQmPIL8xIwygsK6AhTmNC1EBAigxAKolAQQiErcmRQRoHR1xf7ErTMzE3JACkzSDGtCY3olQQDGXJIFCjcd2DsV62nI7eUEvrSNmw/gzGivORGqRzDpLGHx+S4s4lJsjwltUI5XWi7mJYZpqldSE1iZCGgikzbhnkOwtiIKJCwk9hPuf09ZZKoMzTN5o83fVg7MfXSplFlkqqXtv4GGGgEUmAXtXmAuL0Q4q7tQXnqpNK9YCEyn7x7SopjO6Y8CM8OYOzF2Yd3AwCrSGr70IqMrv/aprRtCChhAkihIATQKxSEyCFQ2oGbZVpIZGKstI8M5bPITCdyCT20OrPqYmb6xghjD9KzjelZ5a9MYCiYwNTARpR2uexLIFxHXaq8TKsx04lXR5FOJjedE3WTUV6qLqZzousTY+TyuPpiTkqhbDZq+KWiz3inxLQV1jYfuTKJk67sP4sWTkEcdT9fpvb28V4MwQ80IoUfPcKSPl+FodGlU2EsUVLQLwuqwNimElGqEFIoFFKhJxTyLEMuM/REhjEh0VMZMtuUpJTr0DutctOUJF20mUN3XIQy7sDK+naeGKVHcISkiA7VDsmL7e9iidGUSbP2UPbPscpk0KE96NQuTcd2RZuNvJemMPcMru+L16fIPgtC0MOOujG1MknQSbrXfGTrSr+oI/wzYEedmpGC/J6iUofQTiJ+iq5TO/KfMXTnXUu4iF2o3B+pp4hPtfYwZn2wkOgJbQOFyCCF8OxiGlp9mVK5JitGiYEaA0QPoUJp3xGzAe7E64MJTA1+K8eRqTIydZ26TKfEWHRJVRfbtm8jzN8W40Z9yfFYMY7pIsdkMYZpmWGqN4apnmnzL0yk2cugehnQ085Z9KwKQ6LKAshcGkgaWbcRZBB1lqqL8tMLqtiUxCSqvsScalOUGTYf9euk2zYPxfJZRx1TYajzVvAjTdMXwFNhaHRJo056OOGa9l0E6p+SYQ0CyHpC90cR/qSGEOWkiHWww6qLoPNikZNOvSLDuND1d1z0sEgUGBcFxkWORUIL7ItEYQiO6RcQPJuyo64+xpTKnV1U7MMpk2POPkpFchEmjeoyVWjbmCzGMNnT69M9o072chQ9Q2YKUdpGoZWq0C68nzQ2Qfu+SCArVJk/qlaqil04ciO1bUSJfUx9CTDUzwRQtFUnaT6rTiYUG6tO6noPq1UaFcUQSNe+Yv/CXxbETuxm4R8zVGMyYW0BeidR2pezDZFpu6oBHVZN0yzhXpxNa7+e2SHVGRaJHFJkmDZ2kQuJcaX/5ko525hUj4fB1PMTTGBqMIUc48FIDau86Ggy7LCb1/xI50TSeddGmHZ4qO2gWJnAicjb3jpZBiKqSyTaDNWDOjSqLxZtPh/Qj5Om/QuyGi/VthmJ5K0/z3K7194vROXe0ntv1SwVPD9h0ugQ0UrkaZ+l5UauLwxcp0UIuA69Wab7n4wZtc526O0JhZ7MkCFHLpRTYsaURK50p97w3uRBOJ3b4dRGRQGAQvgPvpxZukrqrUo5HXZml76d9FQe2ES1467t0O6USXsvFFD2fRGOkFv7sEplzCY8Qk7reGhHQXq5rspnDrK9rlnVEvswrQ1mUMVMqjCJuZJCFQaGx4d5vI7ugHfvFfkb81Muv4Q+B+cHhSZangpj0q0CIzPITKGQurm1J3RTay70sOqe8cWZmXKA9hXLla7jmf3rObuetj+lFUtrG1MD3v8uiFWhfspYKGACU4MdcgJS5uWwOtNcRKVyqrqUkWY5qmJKjmGyGEsqL9ORCLMotPKiegLo6TZZ0TNt+z1RRpQ9uPZ+F2EGUacoFDLTHyCLKjIt1BfaodekV9r4LQL1RYQW11Z9iXWMtGmZ72wbyYgwTTQwLz4SgSZVGKe0ACoTEIXSfQKk0utK6cjfKS4+6cmgQCdjMwfUJKsoV5HDOe9MiXIkEIQro+QWGZTSU/2H34GRCihy3UHRNcVkhXbWWY5epsnCZDaGiayHxWoa06KH8ayHcVHgMTWOcVFgkdDrOaT+K2T5dfWAwNTZRdlcNFaxC6pIuj4vpD/YZM+qkqZvWC9HzygvsqfVF/Sysk9YT2hb6Bn1pRdXJe1P24nytxEbqNgJ7fti+5gpXYZTaVS5rVF9kajajEkHIrYRe+PE7CNlF1FyX9pFowpj2ARVYQQ0CXZ9YfSZw9qDMvVaVxkF4crU5duuJ/pvwICU3zVF51dQuU3z5BcopaAgIWE7d0tz2QJKFV5zvIrYx2TWw0TWK+eHsfMoiQLTWV6xi0xodVKfp8SkjPUOmxlQmx+kjIUCJjA1sM7XteeTuTR0lJl55CX8WfIyKceSykuvMJGm7ZxI2/iNLirM0Gk6RFoTDJJmJHEnfTvHWq770Wf4I0TFIIxCY31Z+v1440CQKq7GDFuFoZ0WhXAdG13kSHd3Ly7h3edQRQs79FaiUxthKk22hFRasZFkHzPElA4f7UHfkiKTyGSGaaG/ZqQ7LRoVRuamQ67Uo4/oW4RAz0zag/4ibw9ArjvxKp/EFESB8ZuQAjWSDJWmHXZLRdJMJWD6vhRKoFfkmrDYPmEyK23CTiNgI3QTgbsmUXK/q6oLKs/HswG3XfnPzttH+Z3aYY9VYwSDqC8hZmDUU6MK45o4faLh1EKS5o1ICpQapzQqX4lxtmPquZLETiQAoSd6dIqzHV5tbCU15UDPdHifLnLTLziHEAo9kWu7sDYhFDIbePnsytmHtYvcqPK2/9j0QmIEIwYmMDV4VO6CqWLMn4DOVF47EsmRF1mqLpNmjpem6LJXaLm819MjjnSE6bfte6oLiSpdhNkro0hPgZHVCNO191fUl6B936XZ9TLCDNUXD3XqS5hu0+i+Fm0cNCUxETIS7YAbqjC2GaDFiCRhj1foSLBVm7+NLAkJrCgzyvCVvLx9eni0Mqeov4tlO/Uq+5MCSknTobfA2Fg5S+90LjEuM4xnus6NFwUW59OYygtMZjkmjAozlul+LxNGhbGKi122bfyZUP78GKDkRf+1HdfLodFBU5HMyEijsr+LHW00RUbiTRFFUttGbkYcBcpLAadMZtYWAuWlokoWiX4vnm3Uq5KisP3HVPnCjqmSsTmRBlVf6mwjVCg7qjDC1CuaHtqGHRWkIKoKpTm2ktAKjWPogvgL4dsAsQ2XF4ECY4uGtgutWtoyhRcEKJXpbkkmCLRNj3p+GDJYQmWYkjkWZQWmcu2rrU1Ye5jMxjCeFZiQ4xjPesihonYxJWevEYlHIflgAlODx+Q4hBxzTpo6aG+UUQ15sdGlHSrtRZeB8iILorwoO2GdHQJK2vPJRHZA6YRpxEkj0Xi/mEiECbItNutuk5P21JsEOYmhK3mheUMlJiQzrq08ke7OF/Fo0zQl2Qm8BGAcpnaeqcnt/PscjkCy+0C/DMzzUqI8LyFhlXD9bE1USjszqqJUYooCJrLUEWcmMhNx6qGeU6Jq6hLCvSmk0JHrOOhXee0sGFqxySExrcrvVDfZhW1GojbRRF6mi8x1ZKcTOYJOVqdQ9nEhdT82RLqiSnpNoSAEHZFfdT6kxj5hxC4q9VIG613Rj/LStonVOw7SHXrpfjGFUlc63wZsC6t1EZb8mXxOhbEKJVUqM3OrTd0XwhRmlEgITbpEUdqP6ysmMkAoCJGhEHpIda/Qf6eLPHpZDsHwaimF+15SrgyRMXYxNYvzAFFXPUgZCwVMYGrwq95u+G1v3EUL1iFbJaYnfQc9rTIzw27mnHShMjeXxVRvzM3z0uvlKApRjqgoTJ8XMt+LU15s235qxFGPrqsgsvSjyoxEky6C9NSXSIRZqPbkhUaYQeQJNESYMUcQOvqKszUkpjHaLMsTgB+F2qIj0aYyUrUw7KXSH8ZoNY6J0GjTERqFTAnXhi8UIPOS8GQKUJmvxEglzLo+hjKERo4JIFdQKgMKpV/yuYIc0+S3yCWKPMN0LjGWSYzlOabyAuOFxHg+hvGiwKKswKK8hzEhMWH+jmcFxpzyory/VnUJP/BI7UJPCpZ7dtEz5N4S+FCNdHMf2XleAkWyKMhoo8KQ+WAknlNYejXKi7UDorzE+4P5tuHswq47W7DkRpWqJFVjaJNqkyo5iG2kkFJiUnZBA4+IbdQqlAVK2xJWjaTLxo5yXVIG3Znd9FIBXD2HsQWdN4Nwty2lUNqmo0xCzwCgDMmXGVSuUOQKMheQYxJFoUfh5blEr8gwlkssGuthPMsxmUmMF2NYlBdYlPUwlkksynoYd/ah7WIsK5WXcdORLRcSU73x9s+GMVQwganBlBqDUGPuOy22Gcl9kNH0Zp+SY85RTxXacU8V2kkXMnOddXuRybgceSnK9n0hBRkOStr2qfKiSqfraLl1wopst85W2byqzO/yWOdb/jy1oC1iEeYg7cOxfesiyg7RZnKOlwC6CSmINm3HxWASL2HZSUKJcaOQBMlLlBjX/u+2m3V7X4UmTwrhZF4ACj00ugtkZtSWTI/EKDJdRib0Rx0zofTHHWGmZU914iWEXv/VZJ7+1bbRTF4825BmojprF3YSR0LOrT3UKi+UgAQ2E5KX6nMjNtF1Msc2qmRds6p7UH0Q+xRCEhNBbFtMoXSdem2nWqq0EIXSTUdAbEHYem9Jv7UL48eUqfueHRAb8ZUY8ytEmY/8VGFH0knXL0bfsqoKI5XAItXTy0JCQmCRsYtpJR2xnxa5IzM9JSvlzBS4CckHE5ga/HLqCVg0pRWYck4N4aJNO+JjqhhznREpaSkizrmiuthZdoPoMiOqS9j/pW2flzDCLPvAGMISKi80wrT9Xooa5QUonXRMeWkbYcbk9jrY7W70hKqNNgFU+r0AKPvDAN2iTTuhiyvLLGeuVMSUGB1dmsgyNy+FTOnJqaROc4qMiSaVtNv07Lyq0EqOKqCtNzffg8kFikJHnCLPUGQKWS7RyyXyXGJSjGEsLzBulJnxXEeU45n+OybsXxNhZgUyKIxlNtJUNQqM+QyAMh1wZU465+auw/oUsY1ejNDbfmBUdaH9XSJzIAlnL/DthdpB0OclC+0lnBOJKi/WFlLKS8o2YsoLSLq+gdVtYf1vaxs0ndoFUK9QBvXf7u/1h7H5U7ZRKIgcjlzoMux5mTKIEqPcaLtSoXRKTAYgN7aiTF4bHEjo/WVpG4qWaYlMblTKXEFl2jaQK8g8g5QSWSbRy3UzUp5JZxd5JjGeSeTZuLMLq8iEdmG/O5YLhd7ULCowlgQOWsYCAROYGkzKHEWhK2dIYuocdKGE7u8iRXvyQqNL+mG6cCr0SBRZiSRd1Og7Zi9/UUaSXoTp9iudbxJBhFnZpm8cgAYnHduvDahTriExDlQyTykxqCcx1ulWJvJC2c9FFABIE5H3k/p4Qho/IvSzsWle5FgXcRrVhTZiAYAykaZt9NGXJZDn1Ydpv6VUSIlelmFMlURGKq3ATKssSl7KW1q1CxmQmMKSe9LPRcqSvLjPZth+YOTTGaUdEPIS1vcCVRuIEPhShQztpGpP1i4q/cHoe76JvLh8MWJSs83laUle2qJJoQzylSSm3JRUYiQa+4pRJUaLecaeXMFmu63fVpWxAg9VVtzccfoclLAlmXUIG0qUlwW4zw747craFsZybQ/jyn5/SyuT1C56KjNkRiIXme5fVsyeAmO//zRoGQsFTGBq8MupXZGPLQagHTX94KJrVrLTnpMJ6Xpm+KcfWQpHXKhzFlJ4bfq+whKZyyL8m4ouo05cEWdfHVXRr/ICWOceOOOuEWaqyYgiMqNuWyWmtt2/rRJTKNe50HaoFaps43dKjBKExFjySJSYTECZCbpUhjKSlGV/Fy/iLKDVmxw6sizM/rmAGlN6ZEZuplTP9PBSmSuIPEOW688NZLlEnueYynU0OZYXyDP94btcKN3Gn0nXXGS/rZQRApORZiQ7kZ2EcB8ktfNshJ/ICElLqLhAiiqhT6kuHqGh9kLXiQ20GW2kGkbiDaK8zIRd1CGmUOqHF7ULoFr/7f6tlRhpNgMlyQD5m1Bi9Kg6M6dRpvucqcyMvMuMrUhTz53ygtJ26lTKHBCZsYlc26XsZUaNkShyhcwolVmmkOdandF2oO1izK2n7WJ6NhUYhgcmMDWYLMaQFfoWKeV/9Td00L2idNpSikhbfoS8eB9nbCAvTdFlRJUBcbK+WqPcNtrnpaK8BA7aYTacdJNCE8xZ0TeJCZUYiVbNSbE+MVSJETYPjTJjEScN3mzYavudwN/sZ1RlJGreGk6Nsc8apt4qqSV+M9GXVWQUACkVikwgzxQKJZDLTEeaItMkxxAWISyBKZ+LnZbd2kbPfK+oJzXdKQipd8shqQ+IS2fy4sgGyn4v0k/zCImp75XRRobYO3XA1nlb/xX6Iy+0jgJpu6DoSupdtagh97H0ZP0nx4gpMao6vNrVW6vEOKUSbuoBPbJSE+yqj/LTHE92RMjYTo14kIFOBGl2VqXNKdBlo1QqvaynJMiQZUI3x0qFPBOQuXB2kQnliIwlL0Io9IoiPJUZQ53o3aWMhQImMDV45LFdkOcTAOyLQLg2WTsMupzmXDcRKfvROQndTESHfzrnHLThKxCy0qC60Ciysi0SXSobSaLSrh/OsjvQaKOUg7bb6d9+iEuIkMjQ9VTECUIlaMTpIkuyjZAYFOZNlwl/IjogrsQolMdU7SJOZT5SpxUX05fFqjA24iRqDDIzqik3c8IYNQamzV9lCrBqjTAjlTJAmMhTZApZpiNP+xPGMeeZNMtAnsUJDCUvdr0wU/0XhsDYSejcZwAkUSKdXdhfM6FHaAfOhmg+VSEx1h6qI49svSfLqb5gLn/CLmwdDO2CpAMJ4tKG1LexC5qno120VymVIzKhbdiMtmhhlEY7Ikn3+RLOx7g6rUxfFmcLZNnmk6YuS5MuSbr9WwDCqpSZsTlrW3Y5B+kfI0yfGwWZKYhcQmS6rotMIs+JjVjSkknoS9LrQigUk7PXJMOdeH0wganBVJEj7+XugVsSY4mMUqWTVk5tgT+TblHjoEOJuxJpxv5WVZfW5EUhTV7ULJEXin7JS7hPkxoTiURTQ6wrsjngledFnAqalNqZc1EOsXZt/yTiFNJGgGUkaA4crJcT3rlJeJX/1waaNuoUygaz5npNZ2H7orBNWspo75rg6BeHzCSEgCEyEoXMkGW6i25m5pWxBKZ6+4WzC3t8+80iSlw8Ul8Q21Co2kRRkjeqRoYjkFK2ESMvpTppbxRK8uLqO9J9wVw9Duo3rXcN5CVxA8vlQchLrNwudtGkUipT68PpB7xj6P88lVLAqZFGl9Hkm9x/TYoEqdhEsYz22anaSzULsVG7npt9jdrjgg1LklQGkWkbFyqHkgpZLkpynykIo8RYIi+Egix69efCmDEwganBbx5bhEyUCow2OkNeAPdBOY+wuKHOdiI6sxx2xnVOtyayDNWVaHNS/WgK2mQUneOlTXTZlbg0RZdNxKWtw45FmeG6izqr+/rt/8pz2H7EqUwn2lI2d47RvgcktIO0/CSDayWykrjKhNcvxqbpaJNEnSaqpPPQINN1QWWAyEnU2QOJOuEiS2Rm3faTMZGmPQ4yhSLT1ywye43m2qyDFrq/j3DOOv6YKrZhFSZjD4rYgSPztu+Xq+8iICjBKDxbr01dh4T7xpdVV+z+maeo+CSmosCEiiS1jbaK5KCEvi1xmQ27AOIqpd1m7KNiGwqIqpSGTEMYe7AEMbf7AFACQgQqpbUNFVEprb3YfmEFSpXFjNCz+8CpL8qzBWX6xsDYDGyZAobcm2vLNKmB0HYiYOyB2Ebx2zqGOmQogYE74S4gBabbxBHzAAcccACEEJXf61//egDAUUcdVdn22te+tq9jFdP2Q3I5il4OWeR61EQvg5zWH1yU0znUdAbYX09A9DI9JLqnh0ZnPTMs2jpj++G5QugPz9khoNRhe7+W5CVIHxp5sVGtXZ8P5MXmbevww+OTfUVwLXabl04VKvOyo/2IoMIOn6i+EFWphllFIN3hunxZZ4Uq6wD90aHDZjLDzH7Y0OUp66CYFm4ddlr+noCazqCm9YcSpflb9DIUpt7b+t+b9n90W2E/RNrTn8OQpkxl7MB9AqAn/HOy66QTrrMVb4JGsl6U5CULPlZKO7HXf7y0gby0VSS7kPrQRmw96lqXmxDbt8kuaTqxC6dASX97RZ0ituH6DNm0gqah7HtEfBNtyqv1b2G/wOCjnLbuZ6Q+hf5W0HpmtsHVQ2Mbxp+raePjjW0UCduYLYQuuN/fQsHIKTDf+c53UJBOU9/73vfwwhe+EC996Utd2tlnn413vvOdbn3XXXft61i9x8aQiTF4MqQxQsdibTSpgHLaf7KsQBQWv4nIRYgxckJGS6Qk8VRzUYW4KHRv07fOCYS4ANV0m2YxhMhSyHYWpmhnXQBem3643k/UqUrlxU0YR9QY0ZM6ogsjTiFMB1/o0URWjVE6DHUjRk27vFValIlevWjRRZwkvQgVFvJXIB552vZ+18dAuKjT9uOxESiE/QtTsYKb5B4A+Rvahn1ZUcXF1VkRqdMkzSou3ouK2kKbZlRqA/DIYyNxqRuB1w9xoX+BgRSXJtuo2ITbMbAF73xIvqA5FQhtQ1WUyoptKKCixigYOyBDra0N2O1NakygUkJAz51k1RizzSmU5ufZSkbUSjtHTEbthvSNEapUZux9CW0DgHxs5F6jCwYjd+f32Wcfb/0973kPnvjEJ+IP//APXdquu+6KFStWDH6w6QwYI287F0EQZ22+UVRxzoDvpGm7fuTn56130KU0nogslSVICfIyTx10W+IS5o8SmXA9SmRs+0+5vVY+t+m0428B7dRy3a5k2/9FAUQnvRMmV6Z0pAdLEEyezDuLgBhYIqQn+fK2mfZ8kZHHpfQ1Ckp+cph+OzpNCOGcezk8XEBZ4hK2G9G+MFSKDm1D6u1+fRUleSiCNGsHCl5zkE/uW5J6hcBWalQXW89ryIttSnJ1yu3jp+nbE7EHqriEabH1AeyC5nV2Ycusa1oacMi1ZxtAeqi1rfuGlNDPcjimI1yJuo5lgGU4tP6rTJR9jd1P7yMoufe2o7QT11yryvyC2otw9oCstIeKbUzPYkOGvYZBy1ggGDkCQzE1NYVPfvKT2Lhxo2b+Bp/61KfwyU9+EitWrMBxxx2H8847r1aFmZycxOTkpFvfvn07ACCbzJBpC9QwLxAbZZbDj1GSBucgq47ZV1jC9G7Oubpf6Zxtc0Z5Xt1Ul9bOeaZIS1uN00aIodNOqTAhXOSpKkOvq239epuOMIWZ/E65qFMoaVSVzKkxyj4j6wwVSjXGKjPWkduoU5aRJgSNOkEUGrh+LPHI0m63ThnVfjGZchGy+2CeXRfm2l2kSR6NWfb69AZ24GyDEnm77qmUtE6jWu+DJoUwv7dNIbAToka6ep0gLnV9Xay9UBtIEfoupGWW7QJAqSLYPHXlhbZBFZmYbdh0JerVGKXKPl2hGiMMmTFBhraNsn5DJJTKTAT1XhE7Ces9PDuBKPcvlZjANhxxQdU2AOCx2SMwPArJx0gTmGuvvRaPPPIIXvWqV7m0V7ziFdh///2xatUq3H777Xjb296GO+64A9dcc02ynIsvvhgXXXRRJT2bEsjciw3ur7Dr1mmHpMU5a71LjLjEnG6UuCia328uou3GtLmorSxeG1kSB92KuDTJ32R9IOec2idw2sNSZVKKjOfEvSHX0pPOw49BlswG/nlkgB0pZJublBndZJUW19TkOslC75eb66KRJ1FV4uvCc9iOdFniZG+ZvW2WuASPwBEZaw902dZxahshoSe2UlUk00qkFxAQO6ooLoqkObJi6r8h/RXyUsjBSf2wiMuQ7IKW3Ujym5peo7ZBiIxNo82wCnpYf0KNKRUNVTZpmqkJyp7wgOsAL6gdVIlM2WyrjJ0Q25A+iRESjvAIo8J4tmGWhSUyKE0ZAsD0wiEEo4aRJjAf+9jHsGHDBqxatcqlveY1r3HLz3jGM7By5Uq84AUvwN13340nPvGJ0XI2bdqEjRs3uvXt27dj9erVyCbNyDsLG1kCUSddOutgW41jTjniWtISOPGK4tIQWTriQp0zkE6jf9s45n6dcj/OGqg6YJTk0RVdFyRRCb2wy6okM0C1LwxAosx01OmWg6jTnrISSs8WShQZSyTovBguUrQRIiEiZfu/VW5QdeiecgOnzEAYh+2W4V5EXn+YuttvSZZbRr1tJJXJgJi0IC0lEYr0/7LLktgGUSNhSYy1mTo1sg2hj5H5YRCWIdoFhKhXZmLHrrMNolZW+8Lo/Vya0oMqXL8xq8YYVYP2G6P9Y4SE6/Ni+465+kxJN1UkRVj3fbWSqjKebZByqW3YbR6hty+Dx/p7PH2jz+qwEDGyBOanP/0pvv71r9cqKwCwdu1aAMBdd92VJDATExOYmJiopGfTRoGhpAXESZNlqsTEyEtF4q6Ql4QcTh0ymbOiorhQSZw6aLu9q4Pu6pz7kcDrHHPdttR4XpoepPXVzERJkG1stx0XAV99aZLPbaRn3wFBNOuGmRqiYssT0jQtCdLZV5o8kjpmIqMLlO34InDY5tjeMiEvTiSyEWcw+2myCcn8bbINv5kVrr55BD8gNaFi04a4dCX1jbbRhbjMJGlpIjMxG6DbIupMa9ugy842VNn8ClSmH7D24tmK6TfmlMos6DdmiYJC2Y9MwTW1ajsRWq20SoywfpHYhSztwm+OslMJCKdIOrWUEpjANuwFlnZiCFpv9hQYbkLyMbIE5oorrsC+++6Ll7zkJbX5brvtNgDAypUrOx8jnyznPnKwDpIuE9Lir5dNQBUlpkJSgGQTkXW0FVJCjxOQlkGcM3XMLQhL3w6538iy3/0MQnUGUGWTky0/dNxh9An46gtQr8hIs5+Vp219yIgiYyNPQnqUgJv/hSorrj+AVWZCVcZzyIEyQyRyGl3Sdn2vjb8rgaHLoW0QwhJVKYldULXRsyNKWlz9RZq0RGzDV2Zq7CDafBQhKgny0jeRb6rjYbmp0UfuRBIkPczm6rk7kXhzbMw27Cy7oVrZpFRatmyVSqPIiMzMWh3ahcneWpXx7IYQGaGqaqTNE6guSdsAgKnG2zo8WJsatIwFgpEkMFJKXHHFFTj99NMxNlZewt13341Pf/rTePGLX4y99toLt99+O84991w8//nPx6GHHtr5ONkUCS6svaYctHOWZFugyCSVFs/Jd4woByQu+ppIGuATl4hjHjph6Tj6qII2Q0fr0lAlNVFZ3RIb57DhOey2ioxC2dFXt/8Th02al/TMv6KU0Ul7PYzTVkQ6h5XNBSUsIZmBR36iTUgpRw2yHt7COvJCbKNCXLy0RJ8vqi7WqZBDto2oXdh6EPuLObSNVL4utpFIb90cG9iFUyvbEplgErxGkm87/Arb4dfvDB+SfLdOmpiqiovy7MASGiBiGzB5ZpPAMDyMJIH5+te/jnvvvRdnnnmml75o0SJ8/etfx6WXXoqdO3di9erVOOmkk/COd7yjr+PkUwo5lOesvT4wdp2SluCv3x4fOGbqhIkTH9Qxl+fVwjnD5KPOOXDMnlMeJHqsc8aDqCoVRcWgjoSkjm9l9YKu62Unr5cdWMo8mWityNgRS9phC3NIVY0+jXN2f8mcMxVlxs0BA4+4VJ14kM/kaXLStaC2YNYrfcVcXQ/qfZCebB4KlRZiG34/lvJZdiIttg5UbCVtF0AftpFKT9nGIHYBdLMNe7xYEy3tDOypNKrRLlw/mQpxSRAZoFQrY6oMITOwfbTaKJahMhMoL15zUWAboS1461MDPqNOiEUV/ZSxMDCSBOZFL3oRVMSwV69ejRtuuGFox8mmSFcFeriQvJDlmBJDm37C5qNBlRZ97IhzBto1FSXUFhFGm+FybN2iX6LS1VlbJ5qKJJNRaYdjEOctSDOS57QBT0bvIqELEAdso88EmRGSkhpAmQ8+OoXGEJk4SSnldN9JC28d8Jfdeg3qbMMnNaTOJ0mMqe9WaelAWspj+aSlPJ8IcUnaSpq4tLKNVBrQH1mZNdsQ6WsJ+9d0tAvA3uMaImPPz5KZNnZhyIyI2YVH6oGw+ZWqlq3sAuW6TZtVBYa8cwYqY4GgE4H5l3/5l84HeOELX4hddtml837zAfmU+bxN5cWt/0Qlc8B3uCnHHDrwNn1a3LESjhlojipdWuDAqXOORJoVpzZTTlimQsYAWdbdqVtU2vkpTJl1k4AJUXXaNPpsEXkCyvVFEeaFIgRVb7pFoCo3aQWcsw77t1QIjY0w0cZRx++XZxsRu3DrClW7oESE9G/pp0+LSwdKW7LPy+a359uF0Mfswm6LLZvjJ9GvfbS1C4ushqXHVBaLJtsYhl2oBKGXKOulJTNSlHaR6XKpXdgAwI5uiiozQpnmJZOeRZqPBrELbkKaM3QiMCeccEKnwoUQuPPOO3HQQQd12m++IJs2TUgIokygdGxJEtPgmBW8OSlat9nbY4eEhZxT0mEDPnGJRZQx8jKsYdBdnHAqcmxT1iDkxiLSmVGXTSLMwGn7Uroo9680LylCXGCcpnbOwkjcHqHJzEgOExXadGEIkBICKFQpg2d2ttBwMq6QxJgrizlpoHL9MSWmjV24dVrXpb8+KJlvZRsptQWIEvqoXZBrdPtFrj+JQUhKmzptn9kg9tGJ4BBS08kuVH2zKyUz1i7MXEwpoi9kxC5MEyydnE5E7KC1XQT3RQkFNT2gr+kC8o4ZqIwFgs5NSFu3bsW+++7bKu/uu+/e+YTmE/IphTxi6NGoU5Jl4pT1OoJRDzWkhQx5tvu2Iix120JHnFJbqDN319fSQbchJ4OSirb7dyFKTZEq4DutxFwY+vmVztlFn4ZceM1LQNVp2+PECE3ouDPhn0Ndv5kYobGRqD0X68At3OWSPA1IqpSyXPfIiqnXA3XAtc8oJOw23f4NybxLH6JdpNIohkFQAMSazwHz4m5TRheVM34C9oD6b9hfbCbsgqqWNUQ/qVrKql04xUbATR9Q5jGn4/oQuNOr3o5ZJTAifhJdy1gg6ERgTj/99E7NQa985SuxZMmSzic1X5BPSeRKphkrISh6nZAOj4B0dMzEKdeRFV1+aruqptmoss45JyPNhNPrQEpSjnfoUKp0iE0gHwYFkI48gdKhW+dMHTd12mH0afOEnX7tsrTHDRw04MiLJTUCKNUbq8SYzsBJdUaU5ZaT1RlSE1yzr8AAncK1IOuM2QVQq67o8mvsItwnpbaEJMddZ3ChdYRgQFISRayJKhPty2hrH9Q2utpFjMyEdkGbl+wxau0Cw7WLoiQrZRMVHNnXy+Q6Y/YgADXdsXmPMTR0IjBXXHFFp8I//OEPd8o/35D1FLKYAw8cSFUuV/5yx0gy1sHQlWXz0r+xyDD425q4uHRilAnH2JmQDDpcugNqZxet3bHGuReF78hphBo67broM3TaQNnJ0aalSE2g0liFhsrqdY4bKEmNWzbExt2CAQO0arOSTW+wC5O3FZmP2UaMZNQMfa50xg3tItwHqJKVGhsYmJR0QZf9u5Adi652kSIzFbtAO7sgCo1ZqNoFUWma7MIrlxB9fQjfJjx7yKr3IOvNol9TtVWudRkLBSM5Cmm2kE8WyMMIPQT1ZzTStOuew+4wcRZNA9LydcTJRh0z/RtzztYxk3KiTq4fR6vmIEKxj010ZzIqJK1hx0UYx2frhhAJpw3S3APttG1+wFdn7C2iLwIXdZo0GTh3S0qsJO+OGUSi5jwcqaHn4EWYkRdU29uXesQxmwBKogLUKyzELnQ5LW0jYiMzahfhebTBXNgF0LdtNNmFIxmU0AzDLiI2oU+/ahdUjWmyi0abIPvV3pdewztimFCoiEB9lbFA0DeBod8OohBCYPHixXjSk56E448/HsuWLev75OYaoqcgEHGIIcgmETjVWoXFpjfNyxIeP0ZWUnnqItEm5xydRbRPpzsXtF+I4bwkZNWDUYVHAM1OO9X5156nKzfirKkTJy+AsBNwUqEBXDQKEAdt5XqQqNO7KJQvu7aIPGYR1KnWHW6byHyKiCCwi7q8dQpkF7sA+qtrcxUOD8M2ArtQQYdeR/JjdiH1HnWd4m1litoEEFVrHBEJ1Zga5ZIW5XWYtypMzAYokZpFBYbho28C85//+Z+49dZbURQFDj74YADAj370I+R5jkMOOQR/93d/hze/+c341re+hac+9alDO+HZRDbVQ1b0mjN6zq1cbBwBYbc1tcuHxwidXrhe124fkBYVOnKg6thmUwofKhrOJSIHx4uJ9AUgUayijhjkuVPHHSMh4TkI4c96mog8VSb08Ul0KSxJoscII0iTVjpoUny/TW5tkLIJ+7dtJ1uyX1+2MZd2EZY150icS1ubANrZBSnTswvXb6aDTYQKYcom7DanxkTsIvPzejaRlfw9qkoGaPWOGBbmoBPvjTfeiEsuuQS33HILHnzwQfzzP/9z44jk66+/Hhs3bsT3v/99rF69Gu94xzvwqle9ystz2WWX4ZJLLsHWrVuxZs0a/O3f/i2OPPLITufWN4Gx6soVV1zhOuo++uijePWrX43nPve5OPvss/GKV7wC5557Lr7yla/0e5g5hegpiKYopdZhmnJSUWQkve95WGrPo6NzbjpWF8yVTB5D+Jbu57oqL3pzfUVZvlVnnJug/SZoFApUR3C4fMJ/DjTii0nuVG6nTU+eDB/pDOnOcUCnWIcmm6B/6+wilr9SfuSZJvPOkV0sNJsA0nYBOKXGs4uYMgOUqqVdDqcv8M69wSbseqyTsCztJNlBOHKcGJySOgsQiqj6A5TRBTt37sSaNWtw5pln4sQTT2zMf8899+AlL3kJXvva1+JTn/oUNm/ejFe/+tVYuXIljjnmGADAZz/7WWzcuBGXX3451q5di0svvRTHHHMM7rjjjtajnPW19Dk05Hd+53fwta99raKufP/738eLXvQi3H///bj11lvxohe9CL/4xS/6OcScYfv27Vi6dClecMibMZZXv1IdRZMKEosg28rasfKB+OiHIF9U+laymrdCiBqc7LyKJmcQdREpdf4xmTuyvdIRMtrvJCKHJNSYSnRJ/npOPPY3PO+ZRMumzlZ2kSrDO169bdTaReqYYZ4Y2C7a2wXZJlL1G0gP566zCe945V/PJlooom3QKyax+Yd/hUcffXTGRt3ad9LqS9+JbJfFA5Ulf/sY7nvT+X2drxCiUYF529vehi996Uv43ve+59JOPvlkPPLII7juuusAAGvXrsWzn/1sfOhDH9LnJCVWr16NN7zhDXj729/e+nz6VmAeffRR/PznP68QmIceegjbt28HAOyxxx6YmhrhaQp7hS+TtkHCsdZOFlcXXbYc9dDY4bbJOYeOuQ9HPGvDpGcYnjOtnXK9GmXqbeavIlGmjUJjs5mGx6wbvhqLVkkfALpPGJUCEVJT9z5u6cArqKsHKZuI/R2CXehNNcpJSmEZkm0sBJuIjj6quwdZg13UqJZ6RbW3B6BBwYFnF7VKDTm1TnW/aaDHPIV9T1tMTExgYqJlwF6DLVu2YP369V7aMcccgze96U0AgKmpKdxyyy3YtGmT255lGdavX48tW7Z0OtZATUhnnnkm/uqv/grPfvazAQDf+c538Ja3vMWxs5tvvhlPfvKT+z3EnENMT0MUVveMVOgm51TX/p5oe9eLDZI4UB8JdiEzMnFcb995JHnPApJPNRw2baCdrXFiti3ebXS6dOlII04yesxYx5TMfxYijCLpOUYiTBFGzv2SlH6QJAiR5Zmwi/BYlfOI20Xl2CEWuH20omAR2/DsAiBNOZTU2Odt1i2xoGU3ddBqsgl6fsE20UZxaWpCkqPZB2b16tVe8gUXXIALL7xwsLKhJ7tdvny5l7Z8+XJs374dv/3tb/GrX/0KRVFE8/zwhz/sdKy+Cczf//3f49xzz8XJJ5+MXk8/wLGxMZx++un4wAc+AAA45JBD8NGPfrTfQ8w9Ctl/e3WqT0qdY66L+mJlxtA0cqjJMbd1xgsgsmwFT42J3Jss8+6hCLOkolEACDo5VqDIMG2LYAhsYwdic45lmZFjzTSJidWVlJoyV3YRydOXbTxe7AJotA0VNP0426A2QVQYs1fVHkIVPKyvTTYhhD/lAVDtRJwquw3kaA6jvu+++7wmpGGoL7ONvgnME57wBHzkIx/BX//1X+PHP/4xAOCggw7CE57wBJfnsMMOG/gE5xTTvfqp5mswsGwd5kuhQc6ONy21lN8XeGTZN7xo05e3VZjP6+An43J86P+a+qXoMaDR/N7oIvdiKCr5vOJmmMC0njdlFu0iel4t+pQ15n+8I2YboaoSzDIpwl6l1h669M8KbYLsr8g5lHnjNtGXLcymAjNELFmyZEb67KxYsQLbtm3z0rZt24YlS5Zgl112QZ7nyPM8mmfFihWdjjXQRHb//u//jr//+7/Hj3/8Y3z+85/HE57wBPzjP/4jDjzwQDz3uc8dpOh5AVVIqEFGDDRFiwO0s7duW2/rlDs644XQtt8G8fb/0FGSqdTr8qEalUbhSfDRDL7j9aJYouqECk60aQvVCcpmEm0UlNmwC2BGbOPxYhcWlToas40Gu0jaRNHhkyAxQhLahZujhthFYBP92IKaTSI7RAVmprBu3Tp8+ctf9tK+9rWvYd26dQCARYsW4YgjjsDmzZtddxMpJTZv3oxzzjmn07H6JjD/9E//hD/90z/FqaeeiltvvRWTk5MAdOfev/zLv6xcwEiiNwUMKziNON5OEnW/jjFRZqOjfbyMpmhA7eyjFkEnvlqn2+E5+v0AErI5YAhUoh8AxWyNOGqLNjYBpO1iULJQY2+tiAjbSLN9tLGNug7YqQ0pG+tqF21sIuyDU5kPaBYHqswBgdmxYwfuuusut37PPffgtttuw7Jly7Dffvth06ZNuP/++3HVVVcBAF772tfiQx/6EN761rfizDPPxDe+8Q187nOfw5e+9CVXxsaNG3H66afjWc96Fo488khceuml2LlzJ84444xO59Y3gXn3u9+Nyy+/HKeddhquvvpql/4Hf/AHePe7391vsfMLUg086L5Tx9gZlKvrOyEuMEfcVjXrZ/a2ulFJ9vCRe+0cZ7/PsU65Cb9FA+Ojwn0alZ2ZR+fOsI1Ee/Dod9bIfFc1d0ZnF5whJD40aeH1F+vHJlJqZ/RcIgooLQNoaRMNfVwWuOr23e9+F0cffbRbt7Pwn3766bjyyivx4IMP4t5773XbDzzwQHzpS1/Cueeeiw9+8IP43d/9XXz0ox91c8AAwMtf/nI89NBDOP/887F161YcdthhuO666yode5vQN4G544478PznP7+SvnTpUjzyyCP9FjuvoHo9qGE4kUEjPWC4JGMGJ9JSQzzPyoiZoR8j7phSx+1UVFBvBm6maVlPksNPLbLo50lnFy1eWHOqgAzJPgavp+Xz66tOdkTb8+18Lgnb6Msm+iQLTXbRqmk3AaVGcxRSWxx11FG19njllVdG9/nP//zP2nLPOeeczk1GIfomMCtWrMBdd92FAw44wEv/1re+hYMOOmigk5o3kDIyrKQ9Zp2c9Ol4h0k6hom5Oq+ux4069C7Pog1JbnNObb4ybJz3XKgws/p1ZnfQ+UJGRvv4FAPbR90zabKFPu9D49fpB7GLWZxZeS5m4p3P6JvAnH322XjjG9+Ij3/84xBC4IEHHsCWLVvwlre8Beedd94wz3HOoHoFlJgZdj1nDmk+TWO+QJCc67C1ejekYZi2b2KLCHk++zC2jYWFqH0kbWOGhiS3tI1+ap7qOtkpY2jom8C8/e1vh5QSL3jBC/Cb3/wGz3/+8zExMYG3vOUteMMb3jDMc5wzKKmg5oKusiNdGJjp55h4CcynaH2oYLtYOJjJZ1kTOMyEbczqyLMRGIU0m+ibwAgh8Bd/8Rf4sz/7M9x1113YsWMHnvrUp3rzwIw8lET9XOtdy1tANYcx92gb+c1hp91WYLtgDBOzbRdMrOcMA80DA+gx3eH3kBYM1DDoLoMxx2CCwGBUMSy7mEX7EhhCH5ihnMn8QCcCY4dPtYH9nACDwWAwGAzGsNGJwITDom699Vb0ej0cfPDBAIAf/ehHyPMcRxxxxPDOkMFgMBgMxpwMo57P6ERgvvnNb7rlD3zgA9h9993xiU98AnvuuScA4Fe/+hXOOOMMPO95zxvuWTIYDAaD8XgHd+L10PfsPX/1V3+Fiy++2JEXANhzzz3x7ne/G3/1V381lJNjMBgMBoPBiKHvTrzbt2/HQw89VEl/6KGH8Otf/3qgk2IwGAwGgxGAFRgPfSsw//2//3ecccYZuOaaa/Czn/0MP/vZz/BP//RPOOuss3DiiScO8xwZDAaDwXjcw87EO+hvoaBvBebyyy/HW97yFrziFa/A9PS0LmxsDGeddRYuueSSoZ0gg8FgMBgMRoi+Ccyuu+6Kv/u7v8Mll1yCu+++GwDwxCc+EbvtttvQTo7BYDAYDIYBNyF5GHgiu9122w2HHnroMM6FwWAwGAxGCkxgPHTqA3P77bdDyvbTJn//+99HrzeLnxpnMBgMBoPxuEAnAnP44Yfj4Ycfbp1/3bp1uPfeezufFIPBYDAYDB/ciddHpyYkpRTOO+887Lrrrq3yT01N9XVSDAaDwWAwAvBMvB46EZjnP//5uOOOO1rnX7duHXbZZZfOJ8VgMBgMBiMA94Hx0InAXH/99TN0GgwGg8FgMBjtMfAoJAaDwWAwGDOPYfRhedz2gWEwGAwGgzFH4CYkD31/SoDBYDAYDAZjrjCvCMyNN96I4447DqtWrYIQAtdee623XSmF888/HytXrsQuu+yC9evX48477/Ty/PKXv8Spp56KJUuWYI899sBZZ52FHTt2zOJVMBgMBoMxAxjGEOrHqwLz61//Gm9+85vxlKc8Bfvssw+e9KQn4cUvfjH+1//6X/jhD3848Mns3LkTa9aswWWXXRbd/r73vQ9/8zd/g8svvxw33XQTdtttNxxzzDF47LHHXJ5TTz0V3//+9/G1r30NX/ziF3HjjTfiNa95zcDnxmAwGAzGnEIN6bdA0KkPzGmnnYZbbrkFZ599NpYvX47f/va3eNvb3oYf//jHOP/88/Hf/tt/w4c//GGsWrWqr5PZsGEDNmzYEN2mlMKll16Kd7zjHTj++OMBAFdddRWWL1+Oa6+9FieffDJ+8IMf4LrrrsN3vvMdPOtZzwIA/O3f/i1e/OIX4/3vf3/f58VgMBgMBmN+oZMC89WvfhVf+MIXcN555+E1r3kN3vjGN2J8fBxf/vKX8eMf/xjLly/Hs5/9bNxzzz1DP9F77rkHW7duxfr1613a0qVLsXbtWmzZsgUAsGXLFuyxxx6OvADA+vXrkWUZbrrppmTZk5OT2L59u/djMBgMBmNegRUYD50IzPLly/Gb3/wmum3//ffHP/zDP+B1r3sd3vjGNw7l5Ci2bt3qziE8J7tt69at2Hfffb3tY2NjWLZsmcsTw8UXX4ylS5e63+rVq4d89gwGg8FgDAb+lICPTgTmnHPOwZlnnon/+3//bzLPK1/5SnzjG98Y+MRmE5s2bcKjjz7qfvfdd99cnxKDwWAwGIwadOoDs3HjRjzwwAN45jOfiRe+8IU44YQTIKWEEOW3Fa6++mrsvffeQz/RFStWAAC2bduGlStXuvRt27bhsMMOc3l+/vOfe/v1ej388pe/dPvHMDExgYmJiaGfM4PBYDAYjJlB52HU73//+/Ef//Ef2H333fHmN78Zv/3tb7FmzRocdNBB2GuvvfCud70Ll1xyydBP9MADD8SKFSuwefNml7Z9+3bcdNNNWLduHQD97aVHHnkEt9xyi8vzjW98A1JKrF27dujnxGAwGAzGrIH7wHjoaybetWvX4vOf/zympqZw66234kc/+hG2b9+OvffeG3/0R39U6YfSFjt27MBdd93l1u+55x7cdtttWLZsGfbbbz+86U1vwrvf/W783u/9Hg488ECcd955WLVqFU444QQAwFOe8hQce+yxOPvss3H55Zdjenoa55xzDk4++WQegcRgMBiMkQZ/SsDHQJ8SWLRoEZ7znOfgOc95zlBO5rvf/S6OPvpot75x40YAwOmnn44rr7wSb33rW7Fz50685jWvwSOPPILnPve5uO6667B48WK3z6c+9Smcc845eMELXoAsy3DSSSfhb/7mb4ZyfgwGg8FgMOYHhFJqAfGx4WD79u1YunQpjsLxGBPjc306DAaDwZin6KlpXI8v4NFHH8WSJUtm5Bj2nfSkt/8l8onFzTvUoJh8DHe9589n9HxnC/wxRwaDwWAwRgH8MUcP8+pbSAwGg8FgMBhtwAoMg8FgMBgjAO7E64MJDIPBYDAYowBuQvLATUgMBoPBYDBGDkxgGAwGg8EYAczVt5Auu+wyHHDAAVi8eDHWrl2Lm2++OZn3qKOOghCi8nvJS17i8rzqVa+qbD/22GM7nxc3ITEYDAaDMQqYgyakz372s9i4cSMuv/xyrF27FpdeeimOOeYY3HHHHdFJa6+55hpMTU259Ycffhhr1qzBS1/6Ui/fscceiyuuuMKt9/M5H1ZgGAwGg8FgRPGBD3wAZ599Ns444ww89alPxeWXX45dd90VH//4x6P5ly1bhhUrVrjf1772Ney6664VAjMxMeHl23PPPTufGxMYBoPBYDBGAbP8LaSpqSnccsstWL9+vUvLsgzr16/Hli1bWpXxsY99DCeffDJ22203L/3666/Hvvvui4MPPhive93r8PDDD7c/MQNuQmIwGAwGYwQwzGHU27dv99InJiYqzTi/+MUvUBQFli9f7qUvX74cP/zhDxuPdfPNN+N73/sePvaxj3npxx57LE488UQceOCBuPvuu/Hnf/7n2LBhA7Zs2YI8z1tfCxMYBoPBYDBGAUPsA7N69Wov+YILLsCFF144YOE+Pvaxj+EZz3gGjjzySC/95JNPdsvPeMYzcOihh+KJT3wirr/+erzgBS9oXT4TGAaDwWAwHme47777vG8hxTrR7r333sjzHNu2bfPSt23bhhUrVtSWv3PnTlx99dV45zvf2XguBx10EPbee2/cddddnQgM94FhMBgMBmMUMMQ+MEuWLPF+MQKzaNEiHHHEEdi8ebNLk1Ji8+bNWLduXe2pfv7zn8fk5CRe+cpXNl7Wz372Mzz88MNYuXJlY14KJjAMBoPBYIwA5mIemI0bN+IjH/kIPvGJT+AHP/gBXve612Hnzp0444wzAACnnXYaNm3aVNnvYx/7GE444QTstddeXvqOHTvwZ3/2Z/j2t7+Nn/zkJ9i8eTOOP/54POlJT8IxxxzT6dy4CYnBYDAYDEYUL3/5y/HQQw/h/PPPx9atW3HYYYfhuuuucx177733XmSZr4Xccccd+Na3voWvfvWrlfLyPMftt9+OT3ziE3jkkUewatUqvOhFL8K73vWuznPBMIFhMBgMBmMUMEffQjrnnHNwzjnnRLddf/31lbSDDz4YSsUPtMsuu+ArX/lK95OIgAkMg8FgMBgjAP4atQ/uA8NgMBgMBmPkwAoMg8FgMBijgDlqQpqvYALDYDAYDMYogAmMB25CYjAYDAaDMXJgBYbBYDAYjBGAML9By1goYALDYDAYDMYogJuQPDCBYTAYDAZjBMDDqH1wHxgGg8FgMBgjB1ZgGAwGg8EYBXATkgcmMAwGg8FgjAoWEAEZFNyExGAwGAwGY+TACgyDwWAwGCMA7sTrgwkMg8FgMBijAO4D44GbkBgMBoPBYIwcWIFhMBgMBmMEwE1IPpjAMBgMBoMxCuAmJA/chMRgMBgMBmPkwAoMg8FgMBgjAG5C8sEEhsFgMBiMUQA3IXlgAsNgMBgMxiiACYwH7gPDYDAYDAZj5MAKDIPBYDAYIwDuA+ODCQyDwWAwGKMAbkLyMK+akG688UYcd9xxWLVqFYQQuPbaa9226elpvO1tb8MznvEM7Lbbbli1ahVOO+00PPDAA14ZBxxwAIQQ3u8973nPLF8Jg8FgMBiMmcS8IjA7d+7EmjVrcNlll1W2/eY3v8Gtt96K8847D7feeiuuueYa3HHHHfjjP/7jSt53vvOdePDBB93vDW94w2ycPoPBYDAYMwah1FB+CwXzqglpw4YN2LBhQ3Tb0qVL8bWvfc1L+9CHPoQjjzwS9957L/bbbz+Xvvvuu2PFihUzeq4MBoPBYMwquAnJw7xSYLri0UcfhRACe+yxh5f+nve8B3vttRcOP/xwXHLJJej1erXlTE5OYvv27d6PwWAwGAzG/MW8UmC64LHHHsPb3vY2nHLKKViyZIlL///+v/8Pz3zmM7Fs2TL8x3/8BzZt2oQHH3wQH/jAB5JlXXzxxbjoootm47QZDAaDwegLPArJx0gSmOnpabzsZS+DUgof/vCHvW0bN250y4ceeigWLVqE//E//gcuvvhiTExMRMvbtGmTt9/27duxevXqmTl5BoPBYDD6ATcheRg5AmPJy09/+lN84xvf8NSXGNauXYter4ef/OQnOPjgg6N5JiYmkuSGwWAwGAzG/MNIERhLXu68805885vfxF577dW4z2233YYsy7DvvvvOwhkyGAwGgzEz4CYkH/OKwOzYsQN33XWXW7/nnntw2223YdmyZVi5ciX+5E/+BLfeeiu++MUvoigKbN26FQCwbNkyLFq0CFu2bMFNN92Eo48+Grvvvju2bNmCc889F6985Sux5557ztVlMRgMBoMxOLgJycO8IjDf/e53cfTRR7t12y/l9NNPx4UXXoh/+Zd/AQAcdthh3n7f/OY3cdRRR2FiYgJXX301LrzwQkxOTuLAAw/Eueee6/VvYTAYDAZjFMEKjI95RWCOOuooqJpJduq2AcAzn/lMfPvb3x72aTEYDAaDwZhnmFcEhsFgMBgMRgLchOSBCQyDwWAwGCOChdQENChGeiZeBoPBYDAYj08wgWEwGAwGYxSg1HB+HXHZZZfhgAMOwOLFi7F27VrcfPPNybxXXnklhBDeb/HixcFlKJx//vlYuXIldtllF6xfvx533nln5/NiAsNgMBgMxgjAjkIa9NcFn/3sZ7Fx40ZccMEFuPXWW7FmzRocc8wx+PnPf57cZ8mSJXjwwQfd76c//am3/X3vex/+5m/+Bpdffjluuukm7LbbbjjmmGPw2GOPdTo3JjAMBoPBYDCi+MAHPoCzzz4bZ5xxBp761Kfi8ssvx6677oqPf/zjyX2EEFixYoX7LV++3G1TSuHSSy/FO97xDhx//PE49NBDcdVVV+GBBx7Atdde2+ncmMAwGAwGgzEKUEP6tcTU1BRuueUWrF+/3qVlWYb169djy5Ytyf127NiB/fffH6tXr8bxxx+P73//+27bPffcg61bt3plLl26FGvXrq0tMwYmMAwGg8FgjACEHM4P0B8tpr/JycnK8X7xi1+gKApPQQGA5cuXu5nwQxx88MH4+Mc/ji984Qv45Cc/CSklfv/3fx8/+9nPAMDt16XMFJjAMBgMBoPxOMPq1auxdOlS97v44ouHUu66detw2mmn4bDDDsMf/uEf4pprrsE+++yDv//7vx9K+RQ8DwyDwWAwGKOAIU5kd99992HJkiUueWJiopJ17733Rp7n2LZtm5e+bds2rFixotXhxsfHcfjhh7vvHNr9tm3bhpUrV3plhp8JagIrMAwGg8FgjACGOQppyZIl3i9GYBYtWoQjjjgCmzdvdmlSSmzevBnr1q1rdc5FUeC//uu/HFk58MADsWLFCq/M7du346abbmpdpgUrMAwGg8FgjAL6nMelUkYHbNy4Eaeffjqe9axn4cgjj8Sll16KnTt34owzzgAAnHbaafid3/kd1wT1zne+E895znPwpCc9CY888gguueQS/PSnP8WrX/1qAHqE0pve9Ca8+93vxu/93u/hwAMPxHnnnYdVq1bhhBNO6HRuTGAYDAaDwWBE8fKXvxwPPfQQzj//fGzduhWHHXYYrrvuOtcJ995770WWlY05v/rVr3D22Wdj69at2HPPPXHEEUfgP/7jP/DUpz7V5XnrW9+KnTt34jWveQ0eeeQRPPe5z8V1111XmfCuCUI1feL5cYjt27dj6dKlOArHY0yMz/XpMBgMBmOeoqemcT2+gEcffdTrUzJM2HfS2uPehbHxbi/5EL3px3DTv543o+c7W2AFhsFgMBiMUQB/jdoDd+JlMBgMBoMxcmAFhsFgMBiMEUA/3zKKlbFQwASGwWAwGIxRwByMQprP4CYkBoPBYDAYIwdWYBgMBoPBGAFwE5IPJjAMBoPBYIwCeBSSB25CYjAYDAaDMXJgBYbBYDAYjBEANyH5YALDYDAYDMYoQCr9G7SMBQImMAwGg8FgjAK4D4wH7gPDYDAYDAZj5MAKDIPBYDAYIwCBIfSBGcqZzA8wgWEwGAwGYxTAM/F64CYkBoPBYDAYIwdWYBgMBoPBGAHwMGofTGAYDAaDwRgF8CgkD9yExGAwGAwGY+TACgyDwWAwGCMAoRTEgJ1wB91/PoEJDIPBYDAYowBpfoOWsUDATUgMBoPBYDBGDqzAMBgMBoMxAuAmJB9MYBgMBoPBGAXwKCQPTGAYDAaDwRgF8Ey8HrgPDIPBYDAYjJEDKzAMBoPBYIwAeCZeH/NKgbnxxhtx3HHHYdWqVRBC4Nprr/W2v+pVr4IQwvsde+yxXp5f/vKXOPXUU7FkyRLsscceOOuss7Bjx45ZvAoGg8FgMGYAtglp0N8CwbwiMDt37sSaNWtw2WWXJfMce+yxePDBB93vM5/5jLf91FNPxfe//3187Wtfwxe/+EXceOONeM1rXjPTp85gMBgMBmMWMa+akDZs2IANGzbU5pmYmMCKFSui237wgx/guuuuw3e+8x0861nPAgD87d/+LV784hfj/e9/P1atWjX0c2YwGAwGYzYgpP4NWsZCwbxSYNrg+uuvx7777ouDDz4Yr3vd6/Dwww+7bVu2bMEee+zhyAsArF+/HlmW4aabbkqWOTk5ie3bt3s/BoPBYDDmFbgJycNIEZhjjz0WV111FTZv3oz3vve9uOGGG7BhwwYURQEA2Lp1K/bdd19vn7GxMSxbtgxbt25NlnvxxRdj6dKl7rd69eoZvQ4Gg8FgMBiDYV41ITXh5JNPdsvPeMYzcOihh+KJT3wirr/+erzgBS/ou9xNmzZh48aNbn379u1MYhgMBoMxv8AT2XkYKQUmxEEHHYS9994bd911FwBgxYoV+PnPf+7l6fV6+OUvf5nsNwPofjVLlizxfgwGg8FgzCfYTwkM+lsoGGkC87Of/QwPP/wwVq5cCQBYt24dHnnkEdxyyy0uzze+8Q1IKbF27dq5Ok0Gg8FgMBhDxrxqQtqxY4dTUwDgnnvuwW233YZly5Zh2bJluOiii3DSSSdhxYoVuPvuu/HWt74VT3rSk3DMMccAAJ7ylKfg2GOPxdlnn43LL78c09PTOOecc3DyySfzCCQGg8FgjDb4UwIe5pUC893vfheHH344Dj/8cADAxo0bcfjhh+P8889Hnue4/fbb8cd//Md48pOfjLPOOgtHHHEE/v3f/x0TExOujE996lM45JBD8IIXvAAvfvGL8dznPhf/8A//MFeXxGAwGAzGcKAAyAF/C4e/zC8F5qijjoKqYYdf+cpXGstYtmwZPv3pTw/ztBgMBoPBmHMMow8L94FhMBgMBoPBmEPMKwWGwWAwGAxGAgpD6AMzlDOZF2AFhsFgMBiMUcAczcR72WWX4YADDsDixYuxdu1a3Hzzzcm8H/nIR/C85z0Pe+65J/bcc0+sX7++kr/Nh5nbgAkMg8FgMBiMKD772c9i48aNuOCCC3DrrbdizZo1OOaYYypzrllcf/31OOWUU/DNb34TW7ZswerVq/GiF70I999/v5ev6cPMbcAEhsFgMBiMUcCgI5DsrwM+8IEP4Oyzz8YZZ5yBpz71qbj88sux66674uMf/3g0/6c+9Sn8z//5P3HYYYfhkEMOwUc/+lFIKbF582Yvn/0ws/3tueee3U4MTGAYDAaDwRgJDHMm3vADxpOTk5XjTU1N4ZZbbsH69etdWpZlWL9+PbZs2dLqnH/zm99genoay5Yt89LrPszcFkxgGAwGg8F4nGH16tXeR4wvvvjiSp5f/OIXKIoCy5cv99KXL19e+4Fkire97W1YtWqVR4KaPszcFjwKicFgMBiMUcAQZ+K97777vO/+0Qlhh4X3vOc9uPrqq3H99ddj8eLFLn1YH2ZmBYbBYDAYjFHAEEchhR8wjhGYvffeG3meY9u2bV76tm3baj+QDADvf//78Z73vAdf/epXceihh9bmDT/M3BZMYBgMBoPBYFSwaNEiHHHEEV4HXNshd926dcn93ve+9+Fd73oXrrvuOjzrWc9qPE74Yea2YALDYDAYDMYoYA7mgdm4cSM+8pGP4BOf+AR+8IMf4HWvex127tyJM844AwBw2mmnYdOmTS7/e9/7Xpx33nn4+Mc/jgMOOABbt27F1q1bsWPHDgD6o81/9md/hm9/+9v4yU9+gs2bN+P444/3PszcFtwHhsFgMBiMUYAEIIZQRge8/OUvx0MPPYTzzz8fW7duxWGHHYbrrrvOdey99957kWWlFvLhD38YU1NT+JM/+ROvnAsuuAAXXnih+zDzJz7xCTzyyCNYtWoVXvSiF+Fd73pX5344QtV9PfFxiu3bt2Pp0qU4CsdjTIzP9ekwGAwGY56ip6ZxPb6ARx991OsUO0zYd9L6J2/EWD5YZ9teMYmv/+gDM3q+swVuQmIwGAwGgzFy4CYkBoPBYDBGAUMcRr0QwASGwWAwGIxRgFSAGJCAyIVDYLgJicFgMBgMxsiBFRgGg8FgMEYB3ITkgQkMg8FgMBgjgSEQGCwcAsNNSAwGg8FgMEYOrMAwGAwGgzEK4CYkD0xgGAwGg8EYBUiFgZuAeBQSg8FgMBgMxtyBFRgGg8FgMEYBSurfoGUsEDCBYTAYDAZjFMB9YDwwgWEwGAwGYxTAfWA8cB8YBoPBYDAYIwdWYBgMBoPBGAVwE5IHJjAMBoPBYIwCFIZAYIZyJvMC3ITEYDAYDAZj5MAKDIPBYDAYowBuQvLABIbBYDAYjFGAlAAGnMdFLpx5YLgJicFgMBgMxsiBFRgGg8FgMEYB3ITkgQkMg8FgMBijACYwHrgJicFgMBgMxsiBFRgGg8FgMEYB/CkBD0xgGAwGg8EYASgloQb8mvSg+88nMIFhMBgMBmMUoNTgCgr3gWEwGAwGg8GYO8wrAnPjjTfiuOOOw6pVqyCEwLXXXuttF0JEf5dcconLc8ABB1S2v+c975nlK2EwGAwGY8iwo5AG/S0QzKsmpJ07d2LNmjU488wzceKJJ1a2P/jgg976v/3bv+Gss87CSSed5KW/853vxP/f3r0HRXWefwD/LsouKuwiIi5YoKAWa0FQEskaGzXQIE2jxP4cY3GCKcVitY2IGDUXjOl0M7XapEkb20kUO9OGVCdoJl4mFoV4QRoUqpiWCMGSZFhIVe43YZ/fHw6nriwCymXP8v3M7Mie85x338f36D6c25ucnKy89/DwGJwOExERDRWrFdDc5zUsvAZmcMTFxSEuLq7H9Uaj0eb9oUOHsHDhQgQHB9ss9/Dw6BZLREREzsOhTiH1R3V1NQ4fPoykpKRu61599VVMmDABs2bNwo4dO9DR0XHXttra2lBfX2/zIiIicig8hWTDoY7A9Me+ffvg4eHR7VTTL37xC8yePRteXl44e/YstmzZgqqqKuzatavHtsxmM15++eXB7jIREdE9E6sVcp+nkHgbtQPYs2cPEhIS4ObmZrN8w4YNys8zZ86EVqvFT3/6U5jNZuh0OrttbdmyxWa7+vp6+Pv7D07HiYiI6L6psoA5deoUSktL8d577/UaGxUVhY6ODly9ehUhISF2Y3Q6XY/FDRERkUOQAXgSL08hDa933nkHkZGRCA8P7zW2uLgYLi4u8PHxGYKeERERDRKrABoWMF0cqoBpbGxEWVmZ8r6iogLFxcXw8vJCQEAAgFund/bv34+dO3d22z4/Px8FBQVYuHAhPDw8kJ+fj9TUVKxcuRLjx48fsjyIiIhocDlUAVNYWIiFCxcq77uuS0lMTERmZiYAICsrCyKCFStWdNtep9MhKysL27ZtQ1tbG4KCgpCammpzfQsREZEqiQC43+fAOM8RGI2IE2UzQOrr62EwGLAASzBa4zrc3SEiIgfVITeRi0Ooq6uDXq8flM/o+k5aOPr/7vs7qUNu4mTHgUHt71BR7XNgiIiIRhSxDsyrn37/+9/jm9/8Jtzc3BAVFYV//OMfd43fv38/pk+fDjc3N4SFheHIkSO2aYjgpZdegq+vL8aMGYOYmBhcuXKl3/1iAUNERER2vffee9iwYQMyMjJw4cIFhIeHIzY2FjU1NXbjz549ixUrViApKQlFRUWIj49HfHw8SkpKlJhf//rX+N3vfofdu3ejoKAA48aNQ2xsLFpbW/vVN55CsoOnkIiIqC+G8hTSAs2TA3IKKVey+9zfqKgoPPjgg3jzzTcBAFarFf7+/vj5z3+OzZs3d4tfvnw5mpqa8OGHHyrLHnroIURERGD37t0QEfj5+SEtLQ0bN24EANTV1WHSpEnIzMzEU0891edceASGiIhIDYb4FFJ7ezvOnz+PmJgYZZmLiwtiYmKQn59vd5v8/HybeACIjY1V4isqKmCxWGxiDAYDoqKiemyzJw51F5Kj6Doo1YGb9/3MICIicl4duAngf98bg/5Z9/kxXf29c84/ew90/e9//4vOzk5MmjTJZvmkSZPw73//2277FovFbrzFYlHWdy3rKaavWMDYce3aNQDAaRzpJZKIiAhoaGiAwWAYlLa1Wi2MRiNOWwbmO8nd3b3bdDkZGRnYtm3bgLQ/VFjA2OHl5QUAqKysHLQdcrh0zfP0xRdfqP4Wujs5c26Ac+fH3NSJud068tLQ0AA/P79B64ubmxsqKirQ3t4+IO2JCDQajc0ye9PpeHt7Y9SoUaiurrZZXl1dDaPRaLdto9F41/iuP6urq+Hr62sTExER0a88WMDY4eJy69Igg8HgdP8ou+j1euamUs6cH3NTp5Ge21D8ouvm5tZt8uLBptVqERkZiZycHMTHxwO4dRFvTk4O1q1bZ3cbk8mEnJwcrF+/Xll2/PhxmEwmAEBQUBCMRiNycnKUgqW+vh4FBQVYs2ZNv/rHAoaIiIjs2rBhAxITE/HAAw9gzpw5eO2119DU1IRnnnkGAPD0009j8uTJMJvNAIBnn30W8+fPx86dO/H4448jKysLhYWF+NOf/gQA0Gg0WL9+PX75y19i2rRpCAoKwosvvgg/Pz+lSOorFjBERERk1/Lly/H111/jpZdegsViQUREBI4dO6ZchFtZWamctQCAuXPn4q9//SteeOEFbN26FdOmTcPBgwcRGhqqxGzatAlNTU1YvXo1amtrMW/ePBw7dqzfR5hYwNih0+mQkZFh95yg2jE39XLm/JibOjG3kWHdunU9njLKzc3ttmzZsmVYtmxZj+1pNBps374d27dvv69+8UF2REREpDp8kB0RERGpDgsYIiIiUh0WMERERKQ6LGDs6O/U4Y5o27Zt0Gg0Nq/p06cr61tbW7F27VpMmDAB7u7u+OEPf9jt4UOO4uOPP8YTTzwBPz8/aDQaHDx40GZ9X6Zmv379OhISEqDX6+Hp6YmkpCQ0NjYOYRb29ZbbqlWruo3jokWLbGIcNTez2YwHH3wQHh4e8PHxQXx8PEpLS21i+rIfVlZW4vHHH8fYsWPh4+OD9PR0dHR0DGUq3fQltwULFnQbu5SUFJsYR8ztrbfewsyZM5Xnn5hMJhw9elRZr9YxA3rPTa1jNmIJ2cjKyhKtVit79uyRy5cvS3Jysnh6ekp1dfVwd61fMjIy5Dvf+Y5UVVUpr6+//lpZn5KSIv7+/pKTkyOFhYXy0EMPydy5c4exxz07cuSIPP/88/L+++8LAMnOzrZZ/+qrr4rBYJCDBw/KP//5T1m8eLEEBQVJS0uLErNo0SIJDw+Xc+fOyalTp2Tq1KmyYsWKIc6ku95yS0xMlEWLFtmM4/Xr121iHDW32NhY2bt3r5SUlEhxcbF8//vfl4CAAGlsbFRietsPOzo6JDQ0VGJiYqSoqEiOHDki3t7esmXLluFISdGX3ObPny/Jyck2Y1dXV6esd9TcPvjgAzl8+LB89tlnUlpaKlu3bhVXV1cpKSkREfWOmUjvual1zEYqFjB3mDNnjqxdu1Z539nZKX5+fmI2m4exV/2XkZEh4eHhdtfV1taKq6ur7N+/X1n2r3/9SwBIfn7+EPXw3tz5JW+1WsVoNMqOHTuUZbW1taLT6eTdd98VEZFPP/1UAMgnn3yixBw9elQ0Go189dVXQ9b33vRUwCxZsqTHbdSSm4hITU2NAJC8vDwR6dt+eOTIEXFxcRGLxaLEvPXWW6LX66WtrW1oE7iLO3MTufVl+Oyzz/a4jVpyExEZP368vP322041Zl26chNxrjEbCXgK6Tb3MnW4I7ty5Qr8/PwQHByMhIQEVFZWAgDOnz+Pmzdv2uQ5ffp0BAQEqC7PvkzNnp+fD09PTzzwwANKTExMDFxcXFBQUDDkfe6v3Nxc+Pj4ICQkBGvWrFEmGwXUlVtdXR2A/8011pf9MD8/H2FhYTYz18bGxqK+vh6XL18ewt7f3Z25dfnLX/4Cb29vhIaGYsuWLWhublbWqSG3zs5OZGVloampCSaTyanG7M7cuqh9zEYSPsjuNvcydbijioqKQmZmJkJCQlBVVYWXX34Z3/3ud1FSUgKLxQKtVgtPT0+bbe5lOvPh1pep2S0WC3x8fGzWjx49Gl5eXg6f76JFi7B06VIEBQWhvLwcW7duRVxcHPLz8zFq1CjV5Ga1WrF+/Xo8/PDDyhM5+7IfWiwWu2Pbtc4R2MsNAH70ox8hMDAQfn5+uHjxIp577jmUlpbi/fffB+DYuV26dAkmkwmtra1wd3dHdnY2ZsyYgeLiYtWPWU+5Aeoes5GIBYyTiouLU36eOXMmoqKiEBgYiL/97W8YM2bMMPaM+uOpp55Sfg4LC8PMmTMxZcoU5ObmIjo6ehh71j9r165FSUkJTp8+PdxdGXA95bZ69Wrl57CwMPj6+iI6Ohrl5eWYMmXKUHezX0JCQlBcXIy6ujocOHAAiYmJyMvLG+5uDYiecpsxY4aqx2wk4imk29zL1OFq4enpiW9961soKyuD0WhEe3s7amtrbWLUmOftU7Pf7s7p22tqamzWd3R04Pr166rLNzg4GN7e3igrKwOgjtzWrVuHDz/8ECdPnsQ3vvENZXlf9kOj0Wh3bLvWDbeecrMnKioKAGzGzlFz02q1mDp1KiIjI2E2mxEeHo7XX3/dKcasp9zsUdOYjUQsYG5z+9ThXbqmDr/9HKkaNTY2ory8HL6+voiMjISrq6tNnqWlpaisrFRdnrdPzd6la2r2rlxMJhNqa2tx/vx5JebEiROwWq3Kf1Bq8eWXX+LatWvw9fUF4Ni5iQjWrVuH7OxsnDhxAkFBQTbr+7IfmkwmXLp0yaZIO378OPR6vXLYfzj0lps9xcXFAGAzdo6Ymz1WqxVtbW2qHrOedOVmj5rHbEQY7quIHU1WVpbodDrJzMyUTz/9VFavXi2enp42V52rQVpamuTm5kpFRYWcOXNGYmJixNvbW2pqakTk1q2QAQEBcuLECSksLBSTySQmk2mYe21fQ0ODFBUVSVFRkQCQXbt2SVFRkfznP/8RkVu3UXt6esqhQ4fk4sWLsmTJEru3Uc+aNUsKCgrk9OnTMm3aNIe41fhuuTU0NMjGjRslPz9fKioq5O9//7vMnj1bpk2bJq2trUobjprbmjVrxGAwSG5urs1tqc3NzUpMb/th122rjz32mBQXF8uxY8dk4sSJw37bam+5lZWVyfbt26WwsFAqKirk0KFDEhwcLI888ojShqPmtnnzZsnLy5OKigq5ePGibN68WTQajXz00Uciot4xE7l7bmoes5GKBYwdb7zxhgQEBIhWq5U5c+bIuXPnhrtL/bZ8+XLx9fUVrVYrkydPluXLl0tZWZmyvqWlRX72s5/J+PHjZezYsfLkk09KVVXVMPa4ZydPnhQA3V6JiYkicutW6hdffFEmTZokOp1OoqOjpbS01KaNa9euyYoVK8Td3V30er0888wz0tDQMAzZ2Lpbbs3NzfLYY4/JxIkTxdXVVQIDAyU5OblbMe2oudnLC4Ds3btXienLfnj16lWJi4uTMWPGiLe3t6SlpcnNmzeHOBtbveVWWVkpjzzyiHh5eYlOp5OpU6dKenq6zTNFRBwztx//+McSGBgoWq1WJk6cKNHR0UrxIqLeMRO5e25qHrORirNRExERkerwGhgiIiJSHRYwREREpDosYIiIiEh1WMAQERGR6rCAISIiItVhAUNERESqwwKGiIiIVIcFDBEREakOCxgiIiJSHRYwREREpDosYIic2Le//W28/fbbd41ZsGABNBoNNBqNMvtuT3Hr168f2A4CWLVqlfL5Bw8eHPD2icg5sYAhclItLS24cuUKwsPDe41NTk5GVVUVQkNDh6Bntl5//XVUVVUN+ecSkbqNHu4OENHgKCkpgYj0qSgZO3YsjEbjEPSqO4PBAIPBMCyfTUTqxSMwRE6muLgYjz76KObNmwer1YqAgAC89tpr/WqjqakJTz/9NNzd3eHr64udO3d2i7FarTCbzQgKCsKYMWMQHh6OAwcO2MQ0NDQgISEB48aNg6+vL377298O2qkoIhpZWMAQOZHy8nLMnz8fjz76KBYvXoylS5ciLS0Nqampd72+5U7p6enIy8vDoUOH8NFHHyE3NxcXLlywiTGbzfjzn/+M3bt34/Lly0hNTcXKlSuRl5enxGzYsAFnzpzBBx98gOPHj+PUqVPd2iEiuhcsYIicSEpKCpYuXYoXXngBlZWVePjhh7Fp0ybo9XqcOnWqT200NjbinXfewW9+8xtER0cjLCwM+/btQ0dHhxLT1taGX/3qV9izZw9iY2MRHByMVatWYeXKlfjjH/8I4NbRl3379inthIaGYu/evejs7ByU3IloZOE1MEROwmKx4MSJEzh79iw6Oztx6dIlmM1muLi4YNSoUdBqtX1qp7y8HO3t7YiKilKWeXl5ISQkRHlfVlaG5uZmfO9737PZtr29HbNmzQIAfP7557h58ybmzJmjrDcYDDbtEBHdKxYwRE7i3LlzsFqtiIiIQGlpKVpaWhAREYGrV6/ixo0bmDt37oB9VmNjIwDg8OHDmDx5ss06nU43YJ9DRNQTnkIichLt7e0AgNbWVhQVFSEwMBBeXl7YvXs3QkNDERYW1qd2pkyZAldXVxQUFCjLbty4gc8++0x5P2PGDOh0OlRWVmLq1Kk2L39/fwBAcHAwXF1d8cknnyjb1dXV2bRDRHSveASGyEmYTCaMHj0a27dvR2NjI4KDg/Hmm2/ijTfewMcff9zndtzd3ZGUlIT09HRMmDABPj4+eP755+Hi8r/fdzw8PLBx40akpqbCarVi3rx5qKurw5kzZ6DX65GYmAgPDw8kJiYiPT0dXl5e8PHxQUZGBlxcXKDRaAbjr4CIRhAWMEROwt/fH3v27MFzzz2HqqoqjB49Gs3NzTh27BgiIyP71daOHTvQ2NiIJ554Ah4eHkhLS0NdXZ1NzCuvvIKJEyfCbDbj888/h6enJ2bPno2tW7cqMbt27UJKSgp+8IMfQK/XY9OmTfjiiy/g5uY2IDkT0cilEREZ7k4Q0cDy8vJCZmYmFi9e3GvsggULEBER0e9nxdyLpqYmTJ48GTt37kRSUpLNOo1Gg+zsbMTHxw96P4hI/XgNDJGT+fLLL3Hjxo1+TQvwhz/8Ae7u7rh06dKA9qWoqAjvvvsuysvLceHCBSQkJAAAlixZosSkpKTA3d19QD+XiJwfj8AQOZmjR49i2bJlaGho6NO1Jl999RVaWloAAAEBAX2+3bovioqK8JOf/ASlpaXQarWIjIzErl27bC4orqmpQX19PQDA19cX48aNG7DPJyLnxQKGiIiIVIenkIiIiEh1WMAQERGR6rCAISIiItVhAUNERESqwwKGiIiIVIcFDBEREakOCxgiIiJSHRYwREREpDosYIiIiEh1WMAQERGR6rCAISIiItX5f72WR6HJADy2AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "etheta, ephi = jnp.load(\"lusee_beam.npy\")[:, :, :, :-1]\n", + "beam = jnp.abs(etheta)**2 + jnp.abs(ephi)**2 # power beam\n", + "# add horizon\n", + "beam = jnp.concatenate((beam, jnp.zeros_like(beam)[:, :-1, :]), axis=1)\n", + "plt.figure()\n", + "plt.imshow(beam[30], aspect=\"auto\")\n", + "plt.xlabel(\"$\\\\phi$ [deg]\")\n", + "plt.ylabel(\"$\\\\theta$ [deg]\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1cdb03e4-1bc0-491b-90d2-87dd8832745c", + "metadata": {}, + "outputs": [], + "source": [ + "# define the map2alm transform for the beam\n", + "beam2alm = partial(s2fft.forward_jax, L=L, spin=0, nside=None, sampling=\"mwss\", reality=True)\n", + "# use vmap t vectorize frequency axis\n", + "beam_alm = jax.vmap(beam2alm)(beam)\n", + "\n", + "# normalization for visibilities\n", + "norm = crojax.alm.total_power(beam_alm, L-1)[:, None, None]\n", + "beam_alm /= norm" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d5cb7cb6-ced9-4033-8b8f-5abd1e242cab", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sky\n", + "sky_map = jnp.load(\"../ulsa.npy\")\n", + "ix = -6\n", + "projview(m=sky_map[ix], title=f\"ULSA sky at {freq[ix]} MHz\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "91f2b69f-103c-4471-86de-711448abb1d0", + "metadata": {}, + "outputs": [], + "source": [ + "# define the map2alm transform for the sky\n", + "sky2alm = partial(s2fft.forward_jax, L=L, spin=0, nside=get_nside(sky_map[0]), sampling=\"healpix\", reality=True)\n", + "sky_alm = jax.vmap(sky2alm)(sky_map)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "fdf352d3-b46a-4477-ad14-799e2f970ed5", + "metadata": {}, + "outputs": [], + "source": [ + "# coordinate transform\n", + "beam_alm = jax.vmap(topo2mcmf)(beam_alm)\n", + "sky_alm = jax.vmap(gal2mcmf)(sky_alm)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0c1a8329-b180-4a52-852f-72149c7adca3", + "metadata": {}, + "outputs": [], + "source": [ + "vis = crojax.simulator.convolve(beam_alm, sky_alm, phases).real" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "fdb085d4-2fad-4bc4-a95d-45e55fda095e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGdCAYAAADJ6dNTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABKcElEQVR4nO3deXRV5b3/8fc5GQmZZ0ISEmYCJEAIMUyKRAEVFSesWhFbrRatiu29evurtr0qtvZaq6RarYptHXAEZwVkngkECHMgkJA5QOY5Z//+OBCMoBJIss9JPq+1zmqy98453+xFzWc9+3m+j8UwDAMRERERB2E1uwARERGRb1M4EREREYeicCIiIiIOReFEREREHIrCiYiIiDgUhRMRERFxKAonIiIi4lAUTkRERMShuJpdQFvZbDby8/Px8fHBYrGYXY6IiIicA8MwqKysJCIiAqv1h8dGnC6c5OfnExUVZXYZIiIich5yc3OJjIz8wWucLpz4+PgA9l/O19fX5GpERETkXFRUVBAVFdXyd/yHOF04OfUox9fXV+FERETEyZzLlAxNiBURERGHonAiIiIiDkXhRERERByKwomIiIg4FIUTERERcSgKJyIiIuJQFE5ERETEoSiciIiIiENROBERERGHonAiIiIiDsWUcPLXv/6VoUOHEhcXx69+9SsMwzCjDBEREXFAnR5OSkpKmD9/Punp6ezcuZP09HQ2bNjQ2WWIiIiIgzJl47+mpibq6uoAaGxsJDQ01IwyWtmz8SvK0z/AJWI4Sdfeb3Y5IiIi3VabR05WrVrF9OnTiYiIwGKxsGjRojOuSUtLIyYmBk9PT5KTk9m0aVPLuZCQEH79618THR1NREQEqamp9OvX74J+ifZQfiidi4oX4rr/C7NLERER6dbaHE6qq6tJSEggLS3trOcXLlzI3Llzefzxx9m6dSsJCQlMmTKF4uJiAE6cOMGnn37K4cOHycvLY926daxaterCfot24N17CAABtUdMrkRERKR7a3M4mTZtGk888QQzZsw46/lnn32Wu+66i9mzZxMXF8dLL72El5cXr732GgBLly6lf//+BAYG0qNHD6688sofnHNSX19PRUVFq1dHCO87HIAIWwF19fUd8hkiIiLy49p1QmxDQwPp6emkpqae/gCrldTUVNavXw9AVFQU69ato66ujubmZlasWMGgQYO+9z3nzZuHn59fyysqKqo9S24RFBFLLe64W5rJPbSnQz5DREREfly7hpPS0lKam5sJCwtrdTwsLIzCwkIALrroIq644gpGjhxJfHw8/fr14+qrr/7e93z00UcpLy9veeXm5rZnyS0sVhcKXSMBOHY4s0M+Q0RERH6cKat1nnzySZ588slzutbDwwMPD48Orsiu0jsWyg5RV7i3Uz5PREREztSuIyfBwcG4uLhQVFTU6nhRURHh4eHt+VEdojmwPwAux7NMrkRERKT7atdw4u7uTmJiIsuWLWs5ZrPZWLZsGSkpKRf03mlpacTFxZGUlHShZX4vr16DAfCvPtxhnyEiIiI/rM2PdaqqqsjKOj2ykJ2dTUZGBoGBgURHRzN37lxmzZrF6NGjGTNmDM899xzV1dXMnj37ggqdM2cOc+bMoaKiAj8/vwt6r+8TEjsc1kJE81HqGpvxdHPpkM8RERGR79fmcLJlyxYmTZrU8v3cuXMBmDVrFgsWLGDmzJmUlJTw2GOPUVhYyIgRI/jyyy/PmCTriAKi7L1OgiyV7M3NZXDfGHMLEhER6YYshpPtundq5KS8vBxfX992f//SP/Yn2FbCqglvMnHyVe3+/iIiIt1RW/5+m7Ir8fnojDknACe8YgCoztvdoZ8jIiIiZ+c04WTOnDns3r2bzZs3d+jnNAWc3OfnmFbsiIiImMFpwkln8Qi3r9jxqco2uRIREZHuSeHkOwL7DAUgojGXusZmk6sRERHpfpwmnHTWnBO/qDgAoizFZBWe6NDPEhERkTM5TTjprDknFt/e1Fk8cbM0U5CtSbEiIiKdzWnCSaexWDjmGQ1A5VHtTiwiItLZFE7Oot7PvseOrWS/yZWIiIh0PwonZ+EaNhAAr0qt2BEREelsCidn4R9lX7ET1pBDbYNW7IiIiHQmpwknnbVaB8Cnt73XST9LPgeLKzv880REROQ0pwknnbVaB8AS1B8bFvwt1Rw5mtPhnyciIiKnOU046VTuXpS72XdRLsvZZXIxIiIi3YvCyfeo8e0LQFOxVuyIiIh0JoWT72EJsa/Y8Sg7aHIlIiIi3YvCyffwjRwCQEi9VuyIiIh0JqcJJ525WgfAu7d9j52+lnwOllR1ymeKiIiIE4WTzlytA0DQAACiLCVk5R/rnM8UERER5wknnc4nnDqrF64WGyU5e82uRkREpNtQOPk+FgtV3rEANBQqnIiIiHQWhZMfYJx8tOOqFTsiIiKdRuHkB/TsbV+xE1x3RCt2REREOonCyQ/w6mXfY6evpYCsYq3YERER6QwKJz8k2N6IrZ8ln/2FFSYXIyIi0j04TTjp7D4nAAT2xYYFX0sNefnaAFBERKQzOE046fQ+JwBunlT36A1Abf6ezvtcERGRbsxpwolZmgL7AWA9dsDkSkRERLoHhZMf4RlunxQbUHuEmoYmk6sRERHp+hROfkSPkyt2+lnytWJHRESkEyic/JiTK3b6Wgo4UKRwIiIi0tEUTn7MyXASZSnhYGGpycWIiIh0fQonP6ZnCA2uPlgtBpV5+82uRkREpMtTOPkxFgv1/vYVO0apwomIiEhHUzg5B+5h9kc7ftVasSMiItLRnCacmNIh9iSPk8uJ+1m1YkdERKSjOU04MaVD7ClBA4CTe+xoxY6IiEiHcppwYqpvLyfWBoAiIiIdSuHkXATGYrO44GOppTj/sNnViIiIdGkKJ+fC1YMG70gAmkq0x46IiEhHUjg5R9bQQQD4VWdTXa8VOyIiIh1F4eQcuYeenneiFTsiIiIdR+HkXJ2cFGtfsVNpcjEiIiJdl8LJuQo+uZzYms8BjZyIiIh0GIWTc3Vy5CSCYxwpKDG5GBERka5L4eRceQXR5O6H1WJQVbAfwzDMrkhERKRLUjg5VxYL1hD76Il/zRFNihUREekgCidtYA2xLyfuZ8ln9YFSk6sRERHpmpwmnJi58V+L4P4A9LXms/qA5p2IiIh0BKcJJ6Zu/HfKyUmx/S35bMw+TkOTzbxaREREuiinCScOIXw4AIOtOVgbKtmac8LkgkRERLoehZO28I+GgFhcsTHGulePdkRERDqAwklb9b0EgPHWTNZoUqyIiEi7Uzhpq74XAzDWuosdeeWU1TSYXJCIiEjXonDSVjETAQuDrbkEG2WszTpmdkUiIiJdisJJW/UMgl7xAKRYd7EmS/NORERE2pPCyfmItT/aGW/NZNX+UrWyFxERaUcKJ+fj1KRYl0zyymo4fKzG3HpERES6EIWT8xGdAi7uRFiOEWMpZI2WFIuIiLQbhZPz4e4FUcnAyUc7WlIsIiLSbhROztfJJcXjrJlsOHiMpma1shcREWkPCifnq+8kAMa67Ka6voHtR8vMrUdERKSLUDg5X71GgIcvflQz1HKYVfv1aEdERKQ9KJycLxdXiJkAnGxln6VwIiIi0h4UTi7EySXFY62ZZOSWUVHXaG49IiIiXYDCyYU4OSk22WUfrrZ61h9UK3sREZEL1enhZN++fYwYMaLl1aNHDxYtWtTZZbSP4IHg0wt3Gkm07tcuxSIiIu3AtbM/cNCgQWRkZABQVVVFTEwMl112WWeX0T4sFvujne1vM86ayXsHxphdkYiIiNMz9bHOxx9/zOTJk+nZs6eZZVyYln12dnH4WA25x9XKXkRE5EK0OZysWrWK6dOnExERgcViOesjmbS0NGJiYvD09CQ5OZlNmzad9b3effddZs6c2eaiHcrJeSfDrYfwpUqrdkRERC5Qm8NJdXU1CQkJpKWlnfX8woULmTt3Lo8//jhbt24lISGBKVOmUFxc3Oq6iooK1q1bxxVXXHF+lTsK3wgIHogVgxTrHlZrnx0REZEL0uZwMm3aNJ544glmzJhx1vPPPvssd911F7NnzyYuLo6XXnoJLy8vXnvttVbXLV68mMsvvxxPT88f/Lz6+noqKipavRzOySXF46yZrM06RrPNMLceERERJ9auc04aGhpIT08nNTX19AdYraSmprJ+/fpW157rI5158+bh5+fX8oqKimrPktvHyXAywTWT8tpGMvPKza1HRETEibVrOCktLaW5uZmwsLBWx8PCwigsLGz5vry8nE2bNjFlypQffc9HH32U8vLylldubm57ltw++owDi5VYCujFMT3aERERuQCmrNbx8/OjqKgId3f3H73Ww8MDX1/fVi+H08MfIkYBMM4lk9XqdyIiInLe2jWcBAcH4+LiQlFRUavjRUVFhIeHt+dHOZ5vzTvZmnOC6vomc+sRERFxUu0aTtzd3UlMTGTZsmUtx2w2G8uWLSMlJeWC3jstLY24uDiSkpIutMyOcXJJ8QSX3TQ229iYrVb2IiIi56PN4aSqqoqMjIyWLq/Z2dlkZGSQk5MDwNy5c3nllVd444032LNnD/feey/V1dXMnj37ggqdM2cOu3fvZvPmzRf0Ph0mcgy49iCYEwyw5OnRjoiIyHlqc/v6LVu2MGnSpJbv586dC8CsWbNYsGABM2fOpKSkhMcee4zCwkJGjBjBl19+ecYk2S7HzRP6pMDBbxhnzWT1gcFmVyQiIuKULIZhOFVTjoqKCvz8/CgvL3e8ybFrnoOlj7O0eRQ/b/w1y399CbHBTtyaX0REpJ205e+3qXvrtIXDzzmB05NiXffiQjMfbj1qbj0iIiJOyGnCicPPOQEIj4ceAfQwakiwHOTDrXnY1C1WRESkTZwmnDgFqxViJwJwqcdu8spq2XBIq3ZERETaQuGkvZ18tHNlz/0AvJ+uRzsiIiJtoXDS3k6Gkz61u/Cmhs8zC6isazS3JhERESfiNOHEKSbEAgTEQvAgrLZGZvllUNdo44udhT/+cyIiIgI4UThxigmxABYLjPgJALd6rgH0aEdERKQtnCacOJX4mWCxElGeQYyliE2Hj3PkWLXZVYmIiDgFhZOO4BsBfe1ddB8ISQfgg615ZlYkIiLiNBROOsqIWwCY0vgNFmx8kH5UPU9ERETOgdOEE6eZEHvK4CvBwxev2nwu8Thg73minYpFRER+lNOEE6eZEHuKWw8YOgOAOYH2mjUxVkRE5Mc5TThxSicf7YysXIEXdXyxs5Cq+iZzaxIREXFwCicdKSoZAvvi0lTDT/22U9vYzBc7C8yuSkRExKEpnHQkiwUS7KMnP+2xDtCjHRERkR+jcNLREmYCEFm2mUhLCRuzj5NzrMbkokRERByX04QTp1utc4p/dMtOxQ+GbAXgg60aPREREfk+ThNOnG61zredfLQztXk5YPDBVvU8ERER+T5OE06c2pDp4NYT7+ocJngc5OiJWjYdPm52VSIiIg5J4aQzeHjD0GsBuD9IPU9ERER+iMJJZ0mw71ScWLkCDxr4fGcB1ep5IiIicgaFk87SZxz4RePSWMltfjupaWjmi8xCs6sSERFxOAonncVqhRH20ZPbvU71PMk1syIRERGHpHDSmRJuBiC6bCPhluNsOKSeJyIiIt/lNOHEafucfFtgX4hOwWLYeChsGwD/XHPI5KJEREQci9OEE6fuc/JtJzcDnG6sBAze2ZxLcWWduTWJiIg4EKcJJ11G3LXg2gOv8ixu6lVCQ5ONV9dkm12ViIiIw1A46WyevjDkKgB+FbQJgP+sP0J5TaOZVYmIiDgMhRMznHy00/vo5wwP86S6oZk31h82tyYREREHoXBihtiLwbc3lroy/th/HwCvrc1WUzYREREUTsxhdYGknwMw4sjrxAZ6UlbTyNubckwuTERExHwKJ2ZJ+jl4+mEp3c8Tgw8D8PKqQ9Q3NZtbl4iIiMkUTszi6QtjfgFASv4Cevl6UFxZrw0BRUSk21M4MdNF94JbT6yFO/jD0AIAXlp5kKZmm8mFiYiImMdpwkmX6BD7XV6BMHo2AJNL/k2Qlxu5x2v5dEeByYWJiIiYx2nCSZfpEPtdY+8HFw9cjm7k/w0/AUDa8ixsNsPkwkRERMzhNOGky/IJh5G3ATC9/C18PFw5UFzFkj1FJhcmIiJiDoUTRzDuAbC44Hp4Bf8VXw3YR08MQ6MnIiLS/SicOIKAPhA/E4CZtQvxdLOy42g5a7JKTS5MRESk8ymcOIrxDwEW3LO+5IHh9n120pZnmVuTiIiICRROHEXIQIi7GoA7mj/EzcXChkPHST9y3OTCREREOpfCiSOZ8DAAPfYv5u6h9kNpyw+aWJCIiEjnUzhxJL0SYMDlYNi4x/VjrBb4Zm8xu/LLza5MRESk0yicOJoJvwbAZ+/73DrEFYCnv9irlTsiItJtKJw4muhkiJkAtkZ+4/MV7i5WVh8oZclu9T0REZHuQeHEEZ2ce+K76y1+dZEfAE98toe6Ru1YLCIiXZ/CiSPqewn0ToSmWu52/5IwXw9yjtfw6ppssysTERHpcAonjshiaZl74p7+Gr+b3Auw9z0pLK8zszIREZEO5zThpEvuSvxDBk6F0KHQUMmVlR8wKtqfmoZm/vTlXrMrExER6VAWw8mWgVRUVODn50d5eTm+vr5ml9Ox9n4G79wCLu7svX4p0/59FMOAD+4dS2KfALOrExEROWdt+fvtNCMn3dKgK6DfpdDcwODtT3NjYiQAf/hkFzabU2VKERGRc6Zw4sgsFpj6J7C6wr7P+Z+B+fh4uLLjaDnvpx81uzoREZEOoXDi6EIGQvI9APiv/H88OCkGgD9/tZfKukYTCxMREekYCifO4OL/hp6hcCyLWS5f0DekJ6VVDbzwjXYtFhGRrkfhxBl4+kLq7wFwXf0M/zs5GIDX12ZzqKTKxMJERETan8KJs0j4CfQeDQ1VjDv0ApcODqWx2eB/P91tdmUiIiLtSuHEWVitcMWfAQvseIcnEqtxc7GwfF8Jy/cWm12diIhIu1E4cSa9E2HkbQBErHuMn42NBuB/P91NQ5PNzMpERETajcKJs5n8OHj4QsF2HgzaSLC3B4dKq7XvjoiIdBkKJ87GOwQueRQAz1VP8tjJfXf+unQ/B4oqzaxMRESkXSicOKMxd0HIYKg5xvQTC5g0KISGJhsPvZtBY7Me74iIiHNTOHFGLm4w9WkALJtf5S8TXfH3ciMzr4L56n0iIiJOTuHEWfWbBEOmg9FM0OrHeOKaoQDMX57F9twyc2sTERG5AAonzuzyJ8HVEw6v5iqXjVydEEGzzeChdzOoa2w2uzoREZHzonDizAL6wLgH7V9//hv+NzWUUB8PDpVU86cv95pamoiIyPlSOHF24x+C0DioKcVv6a/58/XDAXh97WHWZZWaXJyIiEjbmRJOsrOzmTRpEnFxcQwfPpzq6mozyuga3DzhupfB6gb7PueSmq+4NdnenO3X722nQjsXi4iIkzElnNxxxx388Y9/ZPfu3axcuRIPDw8zyug6wofDpf/P/vWXj/LblB5EB3qRX17HHz/R3jsiIuJcOj2c7Nq1Czc3NyZMmABAYGAgrq6unV1G1zP2fogeCw1VeH02h2dvGIbFAu+nH+WrXYVmVyciInLO2hxOVq1axfTp04mIiMBisbBo0aIzrklLSyMmJgZPT0+Sk5PZtGlTy7kDBw7g7e3N9OnTGTVqFE899dQF/QJyktUFZrwE7j6Qu4HRef/mFxP7AfA/H+6ktKre5AJFRETOTZvDSXV1NQkJCaSlpZ31/MKFC5k7dy6PP/44W7duJSEhgSlTplBcbN85t6mpidWrV/P3v/+d9evXs2TJEpYsWfK9n1dfX09FRUWrl3yPgD4w7U/2r5c/xdzhtQwO9+FYdQOPfrgTwzDMrU9EROQctDmcTJs2jSeeeIIZM2ac9fyzzz7LXXfdxezZs4mLi+Oll17Cy8uL1157DYDevXszevRooqKi8PDw4IorriAjI+N7P2/evHn4+fm1vKKiotpacvcy4hYYfBXYGnFffA/PXjcINxcLS3YX8cHWPLOrExER+VHtOuekoaGB9PR0UlNTT3+A1Upqairr168HICkpieLiYk6cOIHNZmPVqlUMGTLke9/z0Ucfpby8vOWVm5vbniV3PRYLTP8b9AyFkr3E7f4bD6YOBOCxxZnaHFBERBxeu4aT0tJSmpubCQsLa3U8LCyMwkL7pExXV1eeeuopJk6cSHx8PAMGDOCqq6763vf08PDA19e31Ut+RM9guGa+/esNadwTlUtK3yBqGpq5+9/pWl4sIiIOzZSlxNOmTWPnzp1kZmby7LPPmlFC1zdwCiTOBsDl4zmkXdeXCD9PskurmbtwOzab5p+IiIhjatdwEhwcjIuLC0VFRa2OFxUVER4efkHvnZaWRlxcHElJSRf0Pt3K5U9AYF+oyCNw5W958bZE3F2tLN1TRNpy7V4sIiKOqV3Dibu7O4mJiSxbtqzlmM1mY9myZaSkpFzQe8+ZM4fdu3ezefPmCy2z+/Dwhhkvg8UKO98loXwZT1wzDIBnl+5n+b5ikwsUERE5U5vDSVVVFRkZGS0rbLKzs8nIyCAnJweAuXPn8sorr/DGG2+wZ88e7r33Xqqrq5k9e3a7Fi7nKCoJJvza/vUnD3JTbB23JEdjGPDA29s4ckxbB4iIiGOxGG1sfrFixQomTZp0xvFZs2axYMECAObPn88zzzxDYWEhI0aM4Pnnnyc5ObldCq6oqMDPz4/y8nJNjj1XzY2w4CrI3QDBA6mf/TU3v7GbbTllDA734cNfjsXLXV16RUSk47Tl73ebw4lZ0tLSSEtLo7m5mf379yuctFVlEbx8CVTmw6ArKZz2T66av47SqnquTojgbzePwGKxmF2liIh0UV0ynJyikZMLcDQdXp8KzQ1wyaNs6nM3t7yygSabwe+uiuNn42PNrlBERLqotvz9NmUpsZgkMhGu+qv96xXzGFO/gd9eaW+A99Tne1h/8JiJxYmIiNgpnHQ3I2+DpLvsX394N3cMbODaERE02wzue2srBeW15tYnIiLdnsJJdzR1HvQZBw2VWN65lXlXxDCkly/Hqhu459/p1DY0m12hiIh0Y04TTtSErR25uMGNb4Bvbzh2gB6f3sPLt43E38uN7UfLuf/tbTQ128yuUkREuilNiO3O8rbCa1OhuR4u/m82x97Drf/cSEOTjZ+MieapGcO0gkdERNqFJsTKuek9yr6DMcDKP5FUu47nbx6J1QJvb8rh+WVqcS8iIp1P4aS7G/ETSL7H/vVHv2BqaBl/ONni/q9L9/P2phwTixMRke5I4UTsGwTGTICGKnjnJ/x0uDf3TeoPwG8/2snS3UU/8gYiIiLtx2nCiSbEdiAXN7hxAfhFw/FD8OYNPHxJBDcmRmIz4L63t7I154TZVYqISDehCbFyWsl+eG0K1B6HfpfSOPNt7n5zB8v3leDv5cb794ylf6i32VWKiIgT0oRYOT8hA+HW98DNCw5+g9vHc0i7ZQQJUf6U1TQy67VNFFXUmV2liIh0cQon0lrkaJj5b7C6Qub7eH3zGK/dnkhscE/yymq54/XNVNQ1ml2liIh0YQoncqb+qXDti/avN75IUEYab8weQ7C3B3sKKrjn3+nUNaqLrIiIdAyFEzm7+JtgylP2r5f9kegj77NgdhI93V1Yd/AY9/5HAUVERDqG04QTrdYxQcocGPeg/etPHmBY5VpemTUaTzcry/eVKKCIiEiH0God+WGGAYvvg4z/gKsn/PQj1jUN5M4Fm6lrtDFpUAgv3paIp5uL2ZWKiIgD02odaT8Wi73F/cBp0FQHb93MWO8iXrsjSSMoIiLSIRRO5Me5uMINr0HURVBfDv++jrH+5QooIiLSIRRO5Ny4e8Et70BoHFQVwoIrGetXpoAiIiLtTuFEzl2PALh9MYQMhsoCWHAFY32PK6CIiEi7UjiRtvEOhTs+g9ChUFVkH0HxKVFAERGRdqNwIm3XMxhmfQLhw6G6GBZcxdiehQooIiLSLpwmnKjPiYPpGQS3fwy9EqCmFN6Yzliv/FYB5c4Fm6lUq3sREWkj9TmRC1N7Av59HeRvBU9/uH0x62ujuOtfW6iqbyKuly8L7kwi1MfT7EpFRMRE6nMinadHANy+CCKToK4M/nU1KZ6Heefuiwj2dmd3QQXXv7iOw6XVZlcqIiJOQuFELpynH9z2ob0PSl05/Otahtn288G9Y4kO9CL3eC3Xv7iOnUfLza5UREScgMKJtA9PX7jtA+gzDuor4N8z6FOZwQf3jmVohC/Hqhu4+eX1rD5QYnalIiLi4BROpP14eMOt70HMBGiohH9fS0jO57xz90WM6x9EdUMzdy7YzMfb882uVEREHJjCibQv9572gDJkOjQ3wHuz8cn4J6/dkcSV8b1obDb41dvbeG1NttmVioiIg1I4kfbn1gNufAOS7gIM+PIRPL55nBdmJjArpQ8Af/x0N3/6ci9OtlhMREQ6gcKJdAyrC1zxDKT+3v79uhewfnQXv7+iP7+ZMgiAF1ccZO6729WsTUREWlE4kY5jscD4h2DGP8DqCpkfYHnzBuakhPCn64fjYrXw0bY8bn55A8UVdWZXKyIiDsJpwok6xDqxhJvt81DcveHwanj9CmYOcuVfd47Br4cbGbllXD1/rZYai4gIoA6x0pkKtsObN9o3DPSNhNs+INsaxc/f2MzBkmo83az8340juDK+l9mViohIO1OHWHFMvRLgZ0sgaABUHIXXLie2ahsfzRnHxQNDqGu0MeetrTy7ZD82m1NlZhERaUcKJ9K5AvrAz76GqOST3WSvwXfnG7x2RxJ3TYgF4PllB5jz1lZqGppMLlZERMygcCKdzysQbl8Mw64HWxN89jAunz3Eb6f05883xOPmYuGLzEJueHE9eWW1ZlcrIiKdTOFEzOHWA65/9eRSYwukvw7/upqbBnvw9l2nNw28Zv4athw+bna1IiLSiRROxDynlhrf8i54+EHOenj5Eka7H2HRnHEM6eVLaVUDN7+8gVfXZKthm4hIN6FwIuYbeDnctezkRNk8eG0qkbmf8f49KVwZ34smm8H/frqbe/+zlYq6RrOrFRGRDqZwIo4heIA9oAy4HJrq4MOf03PVH5k/M54/XD0UNxcLX+4qZPoLa9iVr34oIiJdmcKJOA5PP/jJOzB+rv37tX/D8vZMZo304717xtLbvwdHjtUw4+/reHtTjh7ziIh0UQon4lisLpD6uH2yrGsPyFoKL09ihMthPvvVeCYPDqWhycajH+7k4Xe3a7mxiEgXpHAijmn4DfCzr8AvGk5kw6uX4Z/5Bq/8NJH/njoYF6uFD7flcc38tWQVV5pdrYiItCOFE3FcvRLgFyth0BXQ3ACf/xrrB3dw70XBvPXzZEJ9PDhQXMXV89eyaFue2dWKiEg7UTgRx+YVCDe/BVPmgdUNdi+GlyaQ7HGEz341gXH9g6hpaObBhRk8tDBDq3lERLoApwkn2pW4G7NYIOWX9sc8/tFQdgRevZyQXa/zr9ljeDB1AFYLfLQtj2nPrWbjoWNmVywiIhdAuxKLc6ktg8VzYO+n9u8HXwXXzCe9GB5amEHO8RosFrjn4n48lDoQd1enyd8iIl2adiWWrquHP8z8D0z7M7i420PKPyaS6HKIzx+YwE2jIzEMeHHFQa57cS1ZxVVmVywiIm2kcCLOx2KB5F/YdzcOiIGyHHjtcrw3PMufZwzlpdtG4e/lRmZeBVe9sJp/rz+snigiIk5E4UScV8RI+MUqGDrDvrvx8ifhtSlMDa/mqwcnMmFAMHWNNn63eBd3LthMSWW92RWLiMg5UDgR5+bpBze8Dte9Yt88MG8L/GMCYfv+wxt3JPH49DjcXa0s31fClOdW8emOfI2iiIg4OE2Ila6j/CgsuheyV9m/7zcZrkljf603D7yTwZ6CCgCmDA3jf68dRqiPp4nFioh0L5oQK92TXyT8dDFMfRpcPeHgMvj7RQws+ZpFc8byq8kDcLVa+GpXEZc9u4oP0o9qFEVExAFp5ES6ppJ98OHdUJBh/37YDXDlX9h9woX/+mA7mXn2UZRLBoXw1IzhRPj3MK9WEZFuQCMnIiGD4OdLYeJ/gcUFMt+Hv48lrnIdi345jv+aOgh3Fysr9pVw+V9X8dZG7XIsIuIoNHIiXd/RLfZRlOMH7d8Pux6m/omsGk9+8/4OtuWUAZDSN4g/XR9PdJCXebWKiHRRGjkR+bbI0XDPGhh7P1iskPkBpCXRv+Az3v9FCr+7Kg5PNyvrDx1jynOreHnVQRqbbWZXLSLSbWnkRLqXvK3w8f1QlGn/vt9kmP4cR5qD+O8PdrDh0HEABoX58OSMYYyOCTSxWBGRrqMtf78VTqT7aW6Edc/Dij9Bcz249YTJv8M2+i7ezyhg3ud7OFFj3934ptGRPDJtCIE93U0uWkTEuSmciJyL0gPw8a8gZ539+96j4Zr5nOjZjz99uZd3NucC4O/lxqPTBnNjYhRWq8XEgkVEnJfCici5stkg/XVY8jg0VILVzT43ZeKv2ZJfz/9blMnewkoAEvsE8MS1wxjSS//uRETaSuFEpK3K8+Czh2H/F/bv/aJg6jwaB1zBG+uP8OyS/dQ0NONitXDnuBgeSB2It4eruTWLiDgRhROR82EYsPcz+PIRKLc/0qH/ZTDtTxS4RvDHT3bzRWYhAKE+HvzX1MFcN7K3HvWIiJwDhw8nMTEx+Pr6YrVaCQgIYPny5ef8swon0uEaamD1/9knzTY3gIs7jHsQJsxl+aFKfv/xLo4cqwEgIdKPx6YPJbFPgLk1i4g4OKcIJ5mZmXh7e7f5ZxVOpNOUZsEXv4GD39i/94+GaX+mvt/lvL72MPO/yaKqvgmAa0dE8N/TBtPLT23wRUTORk3YRNpDcH+47UO46V/g2xvKcuDtm/F49xbuGW7hm19fzE2jI7FYYFFGPpf+ZSV/W3qA2oZmsysXEXFqbQ4nq1atYvr06URERGCxWFi0aNEZ16SlpRETE4OnpyfJycls2rSp1XmLxcLFF19MUlISb7755nkXL9LhLBaIuwbu2wzjH7Kv5tn/JaQlE7r+Cf58VQwfzxlPUkwAtY3N/HXpflKfXckn2/O1V4+IyHlqcziprq4mISGBtLS0s55fuHAhc+fO5fHHH2fr1q0kJCQwZcoUiouLW65Zs2YN6enpfPzxxzz11FPs2LHj/H8Dkc7g3hNSfw/3roN+l9rnoqx7AZ4fyfCC93j3riRe+MlIevv3IK+slvvf3sYNL60n/chxsysXEXE6FzTnxGKx8NFHH3Httde2HEtOTiYpKYn58+cDYLPZiIqK4v777+eRRx454z1+85vfMHToUO64446zfkZ9fT319fUt31dUVBAVFaU5J2Iew4CspfDVb6F0n/1YyGC4/EnqYibx8qpD/H1FFnWN9v15Lo8L47+mDqZ/aNvnWImIdBWmzTlpaGggPT2d1NTU0x9gtZKamsr69esB+8hLZaW9qVVVVRXffPMNQ4cO/d73nDdvHn5+fi2vqKio9ixZpO0sFhhwGdy7Fq74C/QIhJK98Ob1eC68iV8Nb2bFrydxc1IUVgt8vbuIKc+t4tEPd1JcUWd29SIiDq9dw0lpaSnNzc2EhYW1Oh4WFkZhob0/RFFREePHjychIYGLLrqI22+/naSkpO99z0cffZTy8vKWV25ubnuWLHL+XNxgzF3wq62Qcp99PkrWUnhxLOGr/4enp0bw1YMTSR0SRrPN4O1NOVz8zAr+7+t9VNY1ml29iIjD6vQWl3379mX79u3nfL2HhwceHh4dWJHIBeoRAFOehNF3wpLHYO+nsOVV2PEuA8b9in/e/Es2F/Rl3ud72JpTxgvfZPHWxhzuv7Q/tyT3wd1Vi+ZERL6tXf+rGBwcjIuLC0VFRa2OFxUVER4efkHvnZaWRlxc3A+OsoiYKqgf3PwmzPoEwuPte/UsfxKeH0FS0ft8cPdoXrotkb7BPTlW3cDvP9lN6rMr+SD9KM02rewRETmlXcOJu7s7iYmJLFu2rOWYzWZj2bJlpKSkXNB7z5kzh927d7N58+YLLVOkY8VOhLtXwvWvQkAsVJfAF7/BMj+JqbZVfPXgeJ6cMYwQHw9yjtfw8Hvbufyv9uXHNoUUEZG2h5OqqioyMjLIyMgAIDs7m4yMDHJycgCYO3cur7zyCm+88QZ79uzh3nvvpbq6mtmzZ7dr4SIOzWqF4TfY+6Nc+X/gHQZlR+DDu3B75WJuDdjHyl9fzCPTBuPv5cbBkmruf3sbVzy/mq92FapHioh0a21eSrxixQomTZp0xvFZs2axYMECAObPn88zzzxDYWEhI0aM4Pnnnyc5ObldClb7enFKDdWw4UVY+zeor7Af6zMOUn9PZchIXl97mFdWHaLyZDv8+Eg/HrpsIJcMDMFi0caCIuL8HH5vnfORlpZGWloazc3N7N+/X+FEnFPNcVjzLGx8GZpP9u/pnwqX/A/lgfG8svoQr63NpuZkC/zEPgE8fNlAUvoFKaSIiFPrkuHkFI2cSJdQfhRWPA0Zb4Fxci+eAZfDJY9yzG8oL608yL/WH6G+yd7ILSkmgPsuHcDEAcEKKSLilBRORJzF8UOw6i+w/Z3TIWXgVLjkUYq9B/P3FQd5a1MODSdDSkKkH/ddOoDUIaEKKSLiVBRORJzNsYOw6hnYsRAMexBh0JVwySMU9RzIy6sO8ebGIy0t8Yf08uX+S/szdWg4VqtCiog4PoUTEWdVegBW/hl2vgec/L/m4Ktg4m8o9R3Cq2uy+de6w1SfnJPSP9Sb+yb156r4Xri6qJmbiDiuLhlONCFWupWS/bDyT5D5AS0hpX8qTHiYspDRvLb2MK+vzaayzr66JybIi19c3I8ZI3vj6eZiXt0iIt+jS4aTUzRyIt1K8V5Y/X+Q+f7pxz3RY2Hiw1T0nsi/N+Twz9WHOFFj36snxMeD2eNiuDW5D3493EwsXESkNYUTka7m+CF7j5SMt6C5wX6s1wiY8DDVfafy9uajvLomm4Jy+67H3h6u3JIczZ3jYgn38zSvbhGRkxRORLqqinxYNx/SX4fGGvux4EEwYS6NQ2bw8c4S/rHqIPuLqgBwc7Fw7Yje/OLivvQP9TGxcBHp7hRORLq66lLY+JK9mVt9uf2YXxRcdC/GyJ+y/HAtL604xKbDx1t+JHVIGL+4uC+j+wRoGbKIdLouGU40IVbkLOrKYfOrsOHv9g0GATz8YPRsSL6H9BOe/GPlQZbsKeLU/9PjI/342fhYrhjeCzet8BGRTtIlw8kpGjkROYvGOtjxjv2Rz7ED9mNWN4i/CVLuI8sSzatrDvHh1ryWrrPhvp7cPrYPt4yJxt/L3cTiRaQ7UDgR6a5sNtj/Jax7HnLWnz7e/zIYez/HQpJ5a1Mu/9pwhJJK+94+nm5Wrh8VyZ3jY+kX4m1S4SLS1SmciAjkbraHlD2f0NIrJXw4JN9L/ZBr+XTXCV5dk83ugoqWH5k0KIQ7x8cyvr/28BGR9qVwIiKnHTton5Oy7U1oqrUf8wqG0XdijL6TDSXuvLomm2V7T89L6RfSk9tTYrhuVG98PNUvRUQunMKJiJyp5jhsfQM2vQIVefZjVjcYOgMuuodsj8EsWJvN++lHW9rj93R34frESG5P6aOlyCJyQbpkONFqHZF20twEez+BDS9C7sbTxyPHwEX3Uhk7lY92FPPGusMcLKluOT2ufxC3p8QweXCo9vERkTbrkuHkFI2ciLSjvK32fimZH4LN3gIfnwhIvANj1O2sK3bjjXWHWbqnCNvJ/1L09u/BLcnR3DQ6ihAfD/NqFxGnonAiIm1TWQhbXrO/TvVLsbrCkOmQ9HOO+o7kzU25vLMpp2UfH1erhSlDw7klOZqUvkFYrZpAKyLfT+FERM5PUz3s/hg2/xNyN5w+HjIEkn5GXdwNfLqvmjc3HmFbTlnL6djgnvxkTBQ3JEYR2FM9U0TkTAonInLhCnfau8/ueBcaT849cfeG+JmQ9DN2N0fx1qYjLNqWT1V9k/20i5Vpw8O5NbkPSTFqky8ipymciEj7qSuH7e/YR1NK958+HjkGEu+gesB0Pt5dxlsbc9iZV95yun+oNzcnRTFjZG+CvDU3RaS7UzgRkfZnGHB4tX0p8r7PwWYfLcHD194mP/EOdjRF8dbGHBZn5FPbaF+O7OZiIXVIGDclRTFxQAgumpsi0i0pnIhIx6osgow37X1TThw+fTxiFCTeQcWAq/lkTwXvbs5l+9HToym9/Dy5ITGSm0ZHERXo1fl1i4hpumQ4UZ8TEQdks8HhVZC+APZ8eno5srs3DL8BRt7OHmt/Fm45yqKMPMpOrvQBe9+Um0ZHMWVoOJ5uLubULyKdpkuGk1M0ciLioKpKYPtb9qBy/NDp4yGDYeRt1A25gSU5Bu9uyWVNVmlLq3wfT1euio/ghsTejIrWJFqRrkrhRETMc2puyrb/wO7F0FRnP251hQFTYOSt5AaN572MIj5IP0peWW3Lj8YG9+T6Ub2ZMSqS3v49TPoFRKQjKJyIiGOoK4fMD+ybDuZtOX28ZwjEz8SWcCsbqkN5P/0oX+wsbJlEa7FASt8gbkiMZOqwcLzcXU36BUSkvSiciIjjKd4LGf+B7Quhuvj08YiRkPATqgZewxcHG/lg61E2HDrecrqnuwtTh/Xi2pERjO0XrNU+Ik5K4UREHFdzIxxYYl/ts//L00uSra7Q/zJIuJnckIl8tPMYH2w9ypFjNS0/GurjwdUJEVw7sjdDI3w1P0XEiSiciIhzqC61P/bZ/jbkbzt93MMPhs3AiL+ZdNtAFm3P59MdBa1W+/QP9ebaERFcM6K3liWLOAGFExFxPiX77J1odyyEirzTxwNiYPhNNMRdz8rjASzKyGPp7iLqm2wtl4zuE8A1I3tzxbBwdaMVcVAKJyLivGw2+2qfHQvtq30aqk6f65UAw2+kcsA1fHHEwuKMPNYdPNayLNnFamFc/2Cmx/fi8qHh+PVwM+d3EJEzKJyISNfQUA17P4Od70HWMjCaT56wQMx4GH4jRZFT+HhfDR9vz2+1t4+7i5WLB4VwdUIEk4eEasWPiMm6ZDhRh1iRbq66FHYvgp3vQ87608etbjDgchh+PYeDJvLx7jI+3p5PVvHpEZcebi6kxoUxPb4XEweGqCOtiAm6ZDg5RSMnIkJZjn0i7c73oSjz9HE3Lxg4BWPoDPb7XsTizBN8siOf3OOnG715e7gyeUgoVw5XUBHpTAonItJ9FO22P/bZ9WHrTQjdvWHQFRhDZ7DDM5HFO4/x+c4CCivqWi45FVSuGN6LixVURDqUwomIdD+GYV+OvOtD2LUIynNPn/PwgyFXYRtyLRlu8Xy66zhfZBZQUH46qPR0d2HykDCuGN6LSwYpqIi0N4UTEeneDAOOboZdH9lflQWnz3n6waArsA2+mgz3kXy25wRf7Cwg/1tBpYebC5MGhzBlaDiXDg7Fx1OrfkQulMKJiMgpNhvkboDMD2HPx1BVdPqcuw8Mmopt8HS290jis91lfJFZ2GozQncXK+MHBDN1aDipcWEE9nQ34ZcQcX4KJyIiZ2OzQe5Ge/+UPR+3bvbm5gUDLscYcjW7e17E5wcq+SKzkEMl1S2XuFgtJMcGMnVYOJfFhdHLTzsni5wrhRMRkR9js0Feun158p6P7SuATnHxgL6XYAy+kuygi/nsYCNf7ipkV35Fq7eIj/Tj8rgwLh8azoBQb+31I/IDFE5ERNrCMKAgwz6Rds8ncPzg6XMWK0SnwOCryAufzOe5bny5q5CtOSf49n89+wR5tQSVUdEB2j1Z5DsUTkREzpdhQMle2PMp7P0ECra3Ph8eD0Omczwqla9Lgvh6TzFrskpp+NZeP0E93Zk8JJTUIWGMHxCs7rQiKJyIiLSfshx7C/09n0LOOjBOhxD8o2HQFdT2vZyVdQP4au9xlu0poqKuqeUSd1cr4/oFMXlIGJOHhGqeinRbCiciIh2huhT2fWEPK4eWQ9Pp5cd4+MGAy2gaMJV0t0S+yKpl6Z4ijp6obfUWQyN8mTwkjNQhoQyL8MOqxz/STSiciIh0tIYae0DZ9zns+xJqSk+fs7pCzHiMgVPJDpzAF3meLNtTxLbcslbzVEJ9PLh0cCiTBocyvn8wPT30+Ee6LoUTEZHOZGuGo1tOBpXPoXR/6/PBg2DgFMqiJrO0sg9L9x1n9YESqhuaWy5xd7EyJjaQSYNDuXRwKLHBPTv5lxDpWF0ynGhXYhFxGqVZsP8L2P8VHFkHxukQgqcf9L+Mxv6Xs8llFEuyG1i+r5gjx2pavUVscE8uGRTCpYNDGRMbiIer2umLc+uS4eQUjZyIiFOpLYODy+xB5cASqD1++pzFCpFjMAZcxtHg8XxVGsLy/SVsyj5OY/Pp/zR7ubswtl8QFw8K5ZKBIUQFenX+7yFygRROREQc0anHP/u/tIeV4l2tz3uHw4BUavtcylojniUHa1m+r5jiyvpWl/UN6cnFA0O4ZFAoybGB2qRQnILCiYiIMyjLsY+mZC2FQyug8VuPdqyuEJWM0f8yDvqn8HVpECv2l7L1yAmabKf/s+3hauWivkFcPDCEiQND6BfSU51qxSEpnIiIOJumevv8lANLIGvJmZNqvcOh36XU9LmY9UY8S480sWJfCQXf2k0ZoLd/DyYMCGbCgBDG9Q/C30sbFYpjUDgREXF2Jw7bg8qBJXB4detRFSwQMRKj36XkBo3l67IoVmSdYNPh46061VotEB/pz8QBwUwYGMKIKH/cXKyd/quIgMKJiEjX0lQPOevtj3+yvjlzroqHH/SdSEOfS9jmPpKv83uw+kAJ+4uqWl3m7eHKRX2DGN8/iPED9AhIOpfCiYhIV1aRDwe/gaxl9kZwtSdanw+Igb6TONFrPCsaBvPNkUbWHCjhRE1jq8t6+Xkyrn8w4/sHM65/MCE+Hp33O0i3o3AiItJd2Johf5s9rBxcDkc3ge303j5YrBAxCqPvJRzyHcOSymhWHypn8+ETrR4BAQwO92kJK0mxgXirY620I4UTEZHuqr4SDq+xB5VDy8+cWOvWE/qMpbHPBHa6j+CrY8GsyTrOrvyKVpe5Wi0kRPkztl8QKf2CGBUdoCXLckEUTkRExK786OmgcmgF1Bxrfd4rCGInUhUxjo2WeJYU9GDdwWPkHG/dsdbD1cromADG9gtmbL8ghvf2w1WTa6UNFE5ERORMNpt9Mu2hlfagcmQdNFa3vsY/GmIncizkItY2x7Esz8q6g8co+U4jOB8PV5JiA0npG8RFfYOIi/DFRTssyw9QOBERkR/X1AB56ZC90h5YvjtfBSBoAEbMBAqDxrCyYRDLc22sP3iMirrW1/l6ujIm1v4IKKVvEIPDfbAqrMi3KJyIiEjb1VfZlyxnr7K/CrYD3/kTEToUW8x4cv1Gs7JuACtym9iUfZyq+tZhxd/LjeTYQJJjg0juG8iQcF+FlW5O4URERC5c7Qn7o5/s1fZGcEWZ37nAAmHDsPUZyxGfUayoH8CKnGY2Hz5OTUNzqyvtIyunw0pcL1/NWelmFE5ERKT9VZfaVwJlr7L/b+m+M68JHUpzn3H2sFLXn5VHDbYcPk71d8KKt4cro2MCSI4NYkxsAMN7++PuqrDSlSmciIhIx6sqhiNr7UHl8Boo2XvmNSFDsEWnkOszktWNA1me58Kmw8ep/M6cFU83KyOi/BkTG8SYmEBG9fHHy119VroShRMREel8VSXfCSt7zrwmIBZbn7Hk+41iXeMglhV6svlIGcerG1pd5mK1MKy3H2NiAhgTG8ToPgEE9NQmhs7MKcJJTU0NQ4YM4cYbb+Qvf/nLOf+cwomIiJOoPgY56+zzVo6shcKdYLTuSotPBEafFEoDRrLZNpglpQFsOlJBXlntGW/XP9SbpJgARvcJJCkmkKjAHtobyIk4RTj57W9/S1ZWFlFRUQonIiLdQV055G6yB5Uj6yBvK9ha7/eDhx9EJ1Meksh26xCWlPVm3ZEqDpZUn/F2oT4eJMUEMvpkYBnSy0eTbB1YW/5+m/JA78CBA+zdu5fp06eTmfnd2d8iItIlefrBgMvsL4CGGsjbAkfW25cwH90M9eVw4Gv8DnzNRGCiiztEjKJ2SBL73OJYURPLqjwbO/PKKa6s57OdBXy2swAAL3cXRkT5M7pPAKP6BDAyOgC/Hm7m/b5y3to8crJq1SqeeeYZ0tPTKSgo4KOPPuLaa69tdU1aWhrPPPMMhYWFJCQk8MILLzBmzJiW89dccw3PPPMM69atIzMzUyMnIiICzU1QtBNyNthHVnLWQ3XJmdcFD6Sp9xiO9BzO+sYBLC3yJj2n7IxJthYLDAz1ITEmgMToAEbHBBAd6KVHQSbp0JGT6upqEhISuPPOO7nuuuvOOL9w4ULmzp3LSy+9RHJyMs899xxTpkxh3759hIaGsnjxYgYOHMjAgQNZt25dWz9eRES6KhdXiBhpf110LxgGHD9kDyk5GyB3o30jw9L9uJbupx/QD7jNKxhj0BhK/UewjYEsK49gQ24NR47VsK+okn1Flby1MQeAYG93RkQFkNgngFHR/sRH+tPDXRsaOpoLmnNisVjOGDlJTk4mKSmJ+fPnA2Cz2YiKiuL+++/nkUce4dFHH+U///kPLi4uVFVV0djYyMMPP8xjjz121s+or6+nvv70ng4VFRVERUVp5EREpDuqPmZvs38qrORthebW+/5gdYNe8dSEJbLfbQir6/qyotCdnUfLaWhuPSHX1WphSC9fRkX7M6pPAKOiA4gM0ETbjtBpE2K/G04aGhrw8vLi/fffbxVYZs2aRVlZGYsXL2718wsWLPjRxzq///3v+cMf/nDGcYUTERGhqd7eZj9ngz205G6CqqIzr/PtTXPv0eT7DGdr8wCWloWxKbeaoor6My4N9vZgZLS//RUVQHykHz091HPlQpk2Iba0tJTm5mbCwsJaHQ8LC2Pv3rM05zkHjz76KHPnzm35/tTIiYiICK4eEDXG/gL7o6CyHHtIyd1oDyyFmVCRh0tFHlEsJgq4xsUdIzye6riR7HMbzOraGJYXerIrv4LSqnqW7C5iyW57yLFaYGCYDyOjAxgZ7c+oaH/6Bntrr6AOZGoUvOOOO370Gg8PDzw8PDq+GBERcX4WCwT0sb/ib7Qfa6i2P/7J3QhHt9gDS80xLHlb8M7bQiKQCDzoHUbzsNEU+Axju9GfZeW92XC0jvzyOvYWVrK3sJK3N9nnrvh4upIQ6U9ClB8jogJIiPIj1MfTtF+7q2nXcBIcHIyLiwtFRa2H1IqKiggPD7+g905LSyMtLY3m5uYfv1hEROQU954QO8H+Avvoyonsk0Fls32UpSgTqopw2f8ZkXxGJHClxQohQ6gZMIJDHoPZ0BDLkpIAtudVUlnXxJqsUtZklbZ8TG//HoyIOh1YhvX2VQv+89QhE2LHjBnDCy+8ANgnxEZHR3PffffxyCOPXHDBWkosIiLtrqHGPnfl6CZ7aMlLh4q8M69z98bWawTH/IezxzqAVdXRrCp040BJNd/9a3rqcZB9hMWf+Eg/BoX74NZNG8V16JyTqqoqsrKyWr7Pzs4mIyODwMBAoqOjmTt3LrNmzWL06NGMGTOG5557jurqambPnt3230RERKQzuHtBnxT765SKAnuTuLx0e2DJ3wYNVViPrCHkyBpCgIkA3uE0Dh1Bvncc2239WF7Rm3X5zRRV1Lc8Dlq4JRcAD1crQyN8iT/5SCgh0p+YoJ6av/IdbR45WbFiBZMmTTrj+KxZs1iwYAEA8+fPb2nCNmLECJ5//nmSk5PbpWCNnIiIiClszVCyzx5Yjm6B/K1QtBuMs0w3COxHbegIjngMJL0plm9OhLEpv/6MRnFgn78yvLcfwyP9iO9tH2HpisuZnWJvnbb69pyT/fv3K5yIiIj5GmrsGxrmpdtf+VvtjeO+y2LFCBlMZVA8h9wGsqmhD0uPBbO9oJb6JtsZlwd4uTE80p/4U6El0o9wX0+nDixdMpycopETERFxaDXH7SElb6v9UVDeVqgqPPM6qxu2sGGU+Q/loGt/NtRF882xQDKLamlsPvNPc7C3O8N6+zG8t1/L//byc57AonAiIiLiSCoK7EEl/1uBpfb4mde5uGMLHcoJv6Hsd+nHxroolpQGsbekjmbbmX+ug3raA0t8pD2wDOvtR4SDBhaFExEREUd2qllc/lbIz7AHloIMqCs/81oXD2yhQznmO5gsl/5srIti2bEgdpfUnzWwBHi5May3H0Mj/BjW25dhEX5EB3qZPulW4URERMTZGAacOHw6qORvg/ztUH+WwGJ1wxYyhON+Qzjo0o9N9dEsOx5CZnEDTWcJLD4ersRF+J4MLb4MjfCjX0hPXDtxWXOXDCeaECsiIt3OqYZx+Rn2PiwF2+3BpfbEmddaXLAFD6DcbwjZrv1Ib4xm+YkwthQbNJxl0q2Hq5XB4T7ERZwKLL4M6eWLp1vH7NLcJcPJKRo5ERGRbs0woDz3dFjJz7AHluqSs1/u34fKgDiOuPdnR1MfVlaEs7bIleqGMwOL1QL9Q72ZMTKSey/p165lm7bxn4iIiHQwiwX8o+2vIdPtxwwDKguhcMfp0FK4A8pysJQdwbfsCMOB4cCtgOETQm1gHPk9+rPbFsPa6giWF3tTXN3M/qIqjlefuVtzZ9LIiYiISFdVc9zeh6VwBxScDC7HDoBx5qiJ4eZFY/AQinsOhH6TiUy5sV1L0ciJiIiIgFcg9L3Y/jqloQaK99gDy6ngUrQLS2MN7gXpRJIO/j2A9g0nbeE04US7EouIiLQDdy+ITLS/TrE12zvbFmy3B5Y+48yrDz3WERERkU7Qlr/f3XPfZhEREXFYCiciIiLiUBRORERExKEonIiIiIhDcZpwkpaWRlxcHElJSWaXIiIiIh1Iq3VERESkw2m1joiIiDgthRMRERFxKAonIiIi4lAUTkRERMShKJyIiIiIQ1E4EREREYfiNOFEfU5ERES6B6frc1JeXo6/vz+5ubnqcyIiIuIkKioqiIqKoqysDD8/vx+81rWTamo3lZWVAERFRZlciYiIiLRVZWXlj4YTpxs5sdls5Ofn4+Pjg8ViOaefOZXWNNrSOXS/O5fud+fS/e58uuedq6Put2EYVFZWEhERgdX6w7NKnG7kxGq1EhkZeV4/6+vrq3/YnUj3u3Ppfncu3e/Op3veuTrifv/YiMkpTjMhVkRERLoHhRMRERFxKN0inHh4ePD444/j4eFhdindgu5359L97ly6351P97xzOcL9droJsSIiItK1dYuRExEREXEeCiciIiLiUBRORERExKEonIiIiIhD6RbhJC0tjZiYGDw9PUlOTmbTpk1ml9QlrFq1iunTpxMREYHFYmHRokWtzhuGwWOPPUavXr3o0aMHqampHDhwwJxiu4B58+aRlJSEj48PoaGhXHvttezbt6/VNXV1dcyZM4egoCC8vb25/vrrKSoqMqli5/biiy8SHx/f0ogqJSWFL774ouW87nXHefrpp7FYLDz44IMtx3S/29fvf/97LBZLq9fgwYNbzpt9v7t8OFm4cCFz587l8ccfZ+vWrSQkJDBlyhSKi4vNLs3pVVdXk5CQQFpa2lnP//nPf+b555/npZdeYuPGjfTs2ZMpU6ZQV1fXyZV2DStXrmTOnDls2LCBJUuW0NjYyOWXX051dXXLNQ899BCffPIJ7733HitXriQ/P5/rrrvOxKqdV2RkJE8//TTp6els2bKFSy+9lGuuuYZdu3YButcdZfPmzfzjH/8gPj6+1XHd7/Y3dOhQCgoKWl5r1qxpOWf6/Ta6uDFjxhhz5sxp+b65udmIiIgw5s2bZ2JVXQ9gfPTRRy3f22w2Izw83HjmmWdajpWVlRkeHh7G22+/bUKFXU9xcbEBGCtXrjQMw35/3dzcjPfee6/lmj179hiAsX79erPK7FICAgKMf/7zn7rXHaSystIYMGCAsWTJEuPiiy82HnjgAcMw9G+7Izz++ONGQkLCWc85wv3u0iMnDQ0NpKenk5qa2nLMarWSmprK+vXrTays68vOzqawsLDVvffz8yM5OVn3vp2Ul5cDEBgYCEB6ejqNjY2t7vngwYOJjo7WPb9Azc3NvPPOO1RXV5OSkqJ73UHmzJnDlVde2eq+gv5td5QDBw4QERFB3759ufXWW8nJyQEc43473cZ/bVFaWkpzczNhYWGtjoeFhbF3716TquoeCgsLAc5670+dk/Nns9l48MEHGTduHMOGDQPs99zd3R1/f/9W1+qen7+dO3eSkpJCXV0d3t7efPTRR8TFxZGRkaF73c7eeecdtm7dyubNm884p3/b7S85OZkFCxYwaNAgCgoK+MMf/sCECRPIzMx0iPvdpcOJSFc1Z84cMjMzWz0jlvY3aNAgMjIyKC8v5/3332fWrFmsXLnS7LK6nNzcXB544AGWLFmCp6en2eV0C9OmTWv5Oj4+nuTkZPr06cO7775Ljx49TKzMrks/1gkODsbFxeWMGcZFRUWEh4ebVFX3cOr+6t63v/vuu49PP/2U5cuXExkZ2XI8PDychoYGysrKWl2ve37+3N3d6d+/P4mJicybN4+EhAT+9re/6V63s/T0dIqLixk1ahSurq64urqycuVKnn/+eVxdXQkLC9P97mD+/v4MHDiQrKwsh/j33aXDibu7O4mJiSxbtqzlmM1mY9myZaSkpJhYWdcXGxtLeHh4q3tfUVHBxo0bde/Pk2EY3HfffXz00Ud88803xMbGtjqfmJiIm5tbq3u+b98+cnJydM/bic1mo76+Xve6nU2ePJmdO3eSkZHR8ho9ejS33npry9e63x2rqqqKgwcP0qtXL8f4990p025N9M477xgeHh7GggULjN27dxt333234e/vbxQWFppdmtOrrKw0tm3bZmzbts0AjGeffdbYtm2bceTIEcMwDOPpp582/P39jcWLFxs7duwwrrnmGiM2Ntaora01uXLndO+99xp+fn7GihUrjIKCgpZXTU1NyzX33HOPER0dbXzzzTfGli1bjJSUFCMlJcXEqp3XI488YqxcudLIzs42duzYYTzyyCOGxWIxvv76a8MwdK872rdX6xiG7nd7e/jhh40VK1YY2dnZxtq1a43U1FQjODjYKC4uNgzD/Pvd5cOJYRjGCy+8YERHRxvu7u7GmDFjjA0bNphdUpewfPlyAzjjNWvWLMMw7MuJf/e73xlhYWGGh4eHMXnyZGPfvn3mFu3EznavAeP1119vuaa2ttb45S9/aQQEBBheXl7GjBkzjIKCAvOKdmJ33nmn0adPH8Pd3d0ICQkxJk+e3BJMDEP3uqN9N5zofrevmTNnGr169TLc3d2N3r17GzNnzjSysrJazpt9vy2GYRidM0YjIiIi8uO69JwTERERcT4KJyIiIuJQFE5ERETEoSiciIiIiENROBERERGHonAiIiIiDkXhRERERByKwomIiIg4FIUTERERcSgKJyIiIuJQFE5ERETEoSiciIiIiEP5/50NYriPA/1XAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(freq, jnp.mean(sky_map, axis=-1))\n", + "plt.plot(freq, jnp.mean(sky_map, axis=-1)[0] * (freq/freq.min())**(-2.5))\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "25e7ec10-c915-4fee-b528-3e5b784583ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.imshow(vis, aspect=\"auto\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "dcab37f2-8d91-497e-bbca-b180eac12097", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(freq, vis[150])\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/dpss.ipynb b/notebooks/dpss.ipynb new file mode 100644 index 0000000..94a50cd --- /dev/null +++ b/notebooks/dpss.ipynb @@ -0,0 +1,319 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7cf7036d-747f-49dd-a4f4-f5e9db5ff967", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "jax.config.update(\"jax_enable_x64\", True)\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import s2fft\n", + "from healpy import mollview\n", + "from croissant import crojax" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f91c0e4e-1e94-4583-b2de-df8587f642df", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "freqs = jnp.linspace(10, 50, 41)\n", + "lmax = 128\n", + "sky = crojax.Sky.gsm(freqs, lmax=lmax)\n", + "ix = -1\n", + "m = sky.alm2map(sampling=\"healpix\", nside=64, frequencies=freqs[ix])\n", + "mollview(m[0], title=f\"Sky at {freqs[ix]:.0f} MHz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "890007b4-ed71-43ee-9ddc-032755261cf1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfft\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfftfreq\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mArray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbool_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomplex\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mArray\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Return the Discrete Fourier Transform sample frequencies.\n", + "\n", + "LAX-backend implementation of :func:`numpy.fft.fftfreq`.\n", + "\n", + "*Original docstring below.*\n", + "\n", + "The returned float array `f` contains the frequency bin centers in cycles\n", + "per unit of the sample spacing (with zero at the start). For instance, if\n", + "the sample spacing is in seconds, then the frequency unit is cycles/second.\n", + "\n", + "Given a window length `n` and a sample spacing `d`::\n", + "\n", + " f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even\n", + " f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is odd\n", + "\n", + "Parameters\n", + "----------\n", + "n : int\n", + " Window length.\n", + "d : scalar, optional\n", + " Sample spacing (inverse of the sampling rate). Defaults to 1.\n", + "dtype : Optional\n", + " The dtype of the returned frequencies. If not specified, JAX's default\n", + " floating point dtype will be used.\n", + "\n", + "Returns\n", + "-------\n", + "f : ndarray\n", + " Array of length `n` containing the sample frequencies.\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/projects/croissant/.venv/lib/python3.10/site-packages/jax/_src/numpy/fft.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "jnp.fft.fftfreq?" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "a83793d6-1e1e-4732-a688-5f2b0269cd82", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(jnp.fft.fftshift(jnp.fft.fftfreq(freqs.size, 1e6*(freqs[1]-freqs[0])))*1e9, jnp.fft.fftshift(jnp.fft.fft(beam[:, 0, 0])))\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "ac9edb4b-d2b3-4d6e-831e-2ef447fa4b95", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(beam[:, 0, 0].real)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "4c3abeea-d3f9-4bd3-b69e-a3bd1a99e181", + "metadata": {}, + "outputs": [], + "source": [ + "from croissant import dpss" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "23eb1359-55d9-4b9d-a075-6393365f572a", + "metadata": {}, + "outputs": [], + "source": [ + "def res(nterms):\n", + " A = dpss.dpss_op(freqs, filter_half_width=100e-9, nterms=nterms)\n", + " M = jnp.linalg.inv(A.T @ A) @ A.T\n", + " cs = jnp.einsum(\"ij, jlm -> ilm\", M, sky.alm)\n", + " ss = jnp.einsum(\"ij, jlm -> ilm\", A, cs)\n", + " return jnp.abs(ss-sky.alm)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "eb924f69-0caa-428e-9cf1-6326537a4342", + "metadata": {}, + "outputs": [], + "source": [ + "rm = jnp.empty(41)\n", + "for i in range(41):\n", + " rm = rm.at[i].set(res(i+1).mean())\n", + "\n", + "plt.figure()\n", + "plt.plot(rm)\n", + "plt.yscale('log')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "848cdc15-d7f4-4cae-a029-038e2871d7cd", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "def map2alm(m, lmax):\n", + " forward = partial(\n", + " s2fft.forward_jax, spin=0, nside=None, sampling=\"mw\", reality=True, precomps=None, spmd=True, L_lower=0\n", + " )\n", + " L = lmax + 1\n", + " return jax.vmap(forward, in_axes=(0, None))(m, L)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f38e9465-234d-4805-bf10-8c4e389c3c44", + "metadata": {}, + "outputs": [], + "source": [ + "beam = jnp.load(\"lusee_beam.npy\")[:, 9:, :, :-1]\n", + "beam = jnp.sqrt(jnp.abs(beam[0])**2 + jnp.abs(beam[1])**2)\n", + "beam = jnp.append(beam, jnp.zeros_like(beam)[:, :-1], axis=1)\n", + "beam_alm = map2alm(beam, lmax)\n", + "beam = crojax.Beam(beam_alm, frequencies=freqs, coord=\"T\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "c38c68db-b1de-435a-9530-674328d7d43c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(beam[:, 0, 0])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8ac78db-eae7-4c4c-bf4f-69ba4816c87d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "c829613b-06cb-42f5-821d-e055a6a9d8c7", + "metadata": {}, + "outputs": [], + "source": [ + "def res(nterms):\n", + " A = dpss.dpss_op(freqs, filter_half_width=50e-9, nterms=nterms)\n", + " M = jnp.linalg.inv(A.T @ A) @ A.T\n", + " cs = jnp.einsum(\"ij, jlm -> ilm\", M, beam.alm)\n", + " ss = jnp.einsum(\"ij, jlm -> ilm\", A, cs)\n", + " return jnp.abs(ss-beam.alm) / jnp.abs(beam.alm)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "82500d59-6cfb-4c8d-a970-eec578da1fdc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rm = jnp.empty(41)\n", + "for i in range(41):\n", + " rm = rm.at[i].set(jnp.nanmean(res(i+1)))\n", + "\n", + "plt.figure()\n", + "plt.plot(rm)\n", + "#plt.yscale('log')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/example_sim.ipynb b/notebooks/example_sim.ipynb index 062505d..82fc103 100644 --- a/notebooks/example_sim.ipynb +++ b/notebooks/example_sim.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6a05778f", "metadata": {}, "outputs": [], @@ -18,12 +18,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "2348797a", - "metadata": { - "scrolled": false - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# simple beam in topocentric coordinates\n", "lmax = 32\n", @@ -42,10 +51,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "3be26219", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# we can impose a horizon like this, note that the sharp edge creates ripples since we don't have an inifinite lmax\n", "beam.horizon_cut()\n", @@ -62,10 +82,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "6d25d25a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0QAAAIECAYAAAA5Nu72AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9efBtzVUXDq/ufc53uPc+U2YSEkgYBQuR6QcIokgmQBlkCJFJC1CQQX+COPCC8lMQhBcxKIn1vhIxJGAqBFDAEAuqhIISygLEEuVlCCETISR58jzPvff7PWfvfv84p7vXWnutHvbe5zs8tz9Vt25/9+nd3Xten/6stdo45xw0NDQ0NDQ0NDQ0NDTcg7CXPYCGhoaGhoaGhoaGhobLQiNEDQ0NDQ0NDQ0NDQ33LBohamhoaGhoaGhoaGi4Z9EIUUNDQ0NDQ0NDQ0PDPYtGiBoaGhoaGhoaGhoa7lk0QtTQ0NDQ0NDQ0NDQcM+iEaKGhoaGhoaGhoaGhnsWjRA1NDQ0NDQ0NDQ0NNyzaISooaGhoaGhoaGhoeGeRSNEDQ0NDY8DGGPgq7/6qy97GA0NDQ0NDdcOjRA1NDQ0XGH8xm/8BnzO53wOvM/7vA+cnJzAM57xDHjuc58LL3nJSy57aCJ+6qd+Cv7RP/pHk/bdbDbwIR/yIWCMge/6ru8a/T4MA3znd34nPPvZz4aTkxP4sA/7MHjVq15V1PY/+kf/CIwxYK2FP/iDPxj9/p73vAdOT09HxPINb3iDOh7c7jve8Y7Co2xoaGhouGpohKihoaHhiuIXf/EX4aM+6qPg13/91+HLv/zL4fu+7/vgy77sy8BaC9/7vd972cMT8VM/9VPwj//xP56070te8hJ44xvfqP7+D//hP4Rv/MZvDITwWc96Frz4xS+GH/7hHy7u4/j4WCRRP/qjPzppzA0NDQ0N1x+ryx5AQ0NDQ4OMf/pP/yk88MAD8Cu/8ivw4IMPkt/e/va3X86gDoS3v/3t8K3f+q3wjd/4jfDN3/zNo9/f/OY3w3d/93fD3/ybfxO+7/u+DwAAvuzLvgw+6ZM+Cb7hG74BPvdzPxe6rsv286mf+qnwqle9Cv7u3/27ZPsrX/lK+LRP+zR4zWtes8wBNTQ0NDRcGzSFqKGhoeGK4nd+53fgQz/0Q0dkCADgKU95Snb/f/JP/glYa+ElL3kJfMmXfAk86UlPgs1mM6r3vOc9Dz7ogz4o2dbP//zPw+d+7ufCs571LDg+PoZnPvOZ8Lf/9t+GO3fuhDpf+qVfCv/qX/0rANjFNPl/Jfh7f+/vwQd90AfBF37hF4q///iP/zhsNhv4qq/6qrDNGANf+ZVfCW9605vgl37pl4r6efGLXwy/9mu/Bv/7f//vsO1tb3sb/OzP/iy8+MUvLmojhZe//OXk2PG/P/fn/tzs9hsaGhoalkdTiBoaGhquKN7nfd4HfumXfgn+5//8n/An/+SfrNr3m77pm+Dbvu3b4GUvexl8+Zd/OfyX//Jf4Ad/8Afhda97HXz6p396qOfJwLd8y7ck23v1q18Nt2/fhq/8yq+EJz7xifDLv/zL8JKXvATe9KY3watf/WoAAPjrf/2vw1ve8hZ4/etfD//+3//74rH+8i//Mvy7f/fv4Bd+4RdUAvWrv/qrcPPmTfgTf+JPkO0f8zEfE37/hE/4hGxff/bP/ll47/d+b3jlK18J3/qt3woAAD/yIz8Ct27dgk/7tE9T97t9+7YYJ3T79u1R+/zYf//3fx++6Zu+qYjENjQ0NDRcPBohamhoaLii+Pqv/3p44QtfCB/+4R8OH/MxHwOf+ImfCH/hL/wF+PN//s/Der1O7vc93/M98AM/8APwJV/yJQAA8Mmf/Mnw3u/93vCKV7yCEKJXvepVMAyDqsx4fMd3fAecnp6Gv7/iK74C3v/93x/+wT/4B/DGN74RnvWsZ8HHfdzHwQd+4AfC61//+mx7Hs45+Jqv+Rr4/M//fPi4j/s4eMMb3iDWe+tb3wpPfepTR4Tpvd7rvQAA4C1veUtRf8YYeNGLXgSvetWrAiH6oR/6Ifjsz/5sOD4+Vvf7lm/5lixpBAB4znOeA895znPC33fv3oVP+IRPgKc//enwL//lvywaY0NDQ0PDxaK5zDU0NDRcUTz3uc+FX/qlX4K/9Jf+Evz6r/86fOd3fic8//nPh2c84xnwEz/xE6P6zjn46q/+avje7/1eeMUrXhHIEACAtRb+yl/5K/ATP/ET8Mgjj4TtP/RDPwQf//EfD89+9rOTY8Fk6LHHHoN3vOMd8PEf//HgnINf/dVfnXyML3/5y+E3fuM34Du+4zuS9e7cuSMSlpOTk/B7KV784hfDb//2b8Ov/MqvhP9z7nJf8RVfAa9//etH/77oi74oud9XfdVXwW/8xm/Aa17zGnja055WPMaGhoaGhotDU4gaGhoarjA++qM/Gn70R38Uzs/P4dd//dfhta99LXzP93wPfM7nfA782q/9GnzIh3xIqPuDP/iD8Oijj8L3f//3wxd8wReM2vriL/5i+I7v+A547WtfC1/8xV8M/+f//B/47//9v8NLX/rS7Dje+MY3wjd/8zfDT/zET8C73vUu8tvDDz886dje8573wN//+38fvuEbvgGe+cxnJuuenp7C2dnZaPvdu3fD76X403/6T8MHf/AHwytf+Up48MEH4WlPexp88id/cnKfD/iAD4BP+ZRPGW3/hV/4BXWfl73sZfADP/AD8LKXvQw+9mM/tnh8DQ0NDQ0Xi6YQNTQ0NFwDHB0dwUd/9EfDt33bt8H3f//3w2azCbE7Hn/mz/wZeOpTnwrf933fB+985ztHbXzIh3wIfORHfiS84hWvAACAV7ziFXB0dASf93mfl+y773t47nOfCz/5kz8J3/iN3wg/9mM/Bq9//evh5S9/OQDs1geagu/6ru+C8/Nz+PzP/3x4wxveAG94wxvgTW96EwAAvOtd74I3vOENcH5+DgA717i3ve1t4Jwjbbz1rW8FAICnP/3pVX2/+MUvhh/5kR+BV77ylfD5n//5YO2yn8Nf/uVfhq/7uq+DL/uyL4Ov+IqvWLTthoaGhoZl0QhRQ0NDwzXDR33URwFAJAMe7//+7w8/8zM/A295y1vgBS94AXGN8/jiL/5i+Nmf/Vl461vfGlJNP/TQQ8n+fuM3fgN+67d+C777u78bvvEbvxE+4zM+Az7lUz5FJCGlWeUAdqrTu971LvjQD/1QePaznw3Pfvaz4RM/8RMBAODbvu3b4NnPfjb8r//1vwAA4MM//MPh9u3b8Ju/+Zukjf/23/5b+L0GL37xi+Gtb30r/NZv/dYi2eUw/uiP/gg+53M+Bz78wz88ZN1raGhoaLi6aISooaGh4Yri537u50aKCMBu8VMAEFNlf9iHfRj81E/9FPzmb/4m/MW/+BdHsTVf8AVfAMYY+Lqv+zr43d/93aLkB359HzwW55y4OOzNmzcBAODd7353tt2v/dqvhde+9rXk38te9jIA2KXwfu1rXxtimz7jMz4D1us1/Ot//a/JGF760pfCM57xDPj4j//4bH8Y7/d+7wf/4l/8C/j2b//2kKluCfR9Dy960Yvg/PwcXvOa18DR0dFibTc0NDQ0HAYthqihoaHhiuJrvuZr4Pbt2/BZn/VZ8MEf/MFwfn4Ov/iLvwg/8iM/Au/7vu8Lf/Wv/lVxv4/92I+FH//xH4dP/dRPhc/5nM+BH/uxHwtZ6Z785CfDC17wAnj1q18NDz74YDLVtMcHf/AHw/u93/vB13/918Ob3/xmuP/+++E1r3nNKJYIAOAjP/IjAWBHdp7//OdD13Xwohe9SGz3Iz7iI+AjPuIjyDafZe5DP/RD4TM/8zPD9vd+7/eGv/W3/hb883/+z2Gz2cBHf/RHw4/92I/Bz//8z8MP/dAPFS3KyvF1X/d11fvk8NKXvhR+9md/Fv7G3/gb8HM/93Pkt6c+9anw3Oc+d/E+GxoaGhrmoRGihoaGhiuK7/qu74JXv/rV8FM/9VPwb/7Nv4Hz83N41rOeBV/1VV8F3/RN3yQu2OrxyZ/8yfAf/sN/gL/8l/8yfNEXfRG88pWvDHEyX/zFXwz/6T/9J/i8z/u8ZKppj/V6Df/xP/5H+Nqv/Vr49m//djg5OYHP+qzPgq/+6q+GP/Wn/hSp+9mf/dnwNV/zNfDDP/zD8IpXvAKccyohqsU/+2f/DB566CF42cteBi9/+cvhAz7gA+AVr3jF4i5vc/BHf/RHALAjRjxZxSd90ic1QtTQ0NBwBWGc5I/R0NDQ0PC4xY//+I/DZ37mZ8J//a//NcTsNDQ0NDQ03KtohKihoaHhHsOnf/qnw2/+5m/Cb//2b1clQWhoaGhoaHg8ornMNTQ0NNwj+OEf/mH4H//jf8BP/uRPwvd+7/c2MtTQ0NDQ0ABNIWpoaGi4Z2CMgVu3bsHnf/7nw0tf+lJYrdqcWENDQ0NDQ/saNjQ0NNwjaPNfDQ0NDQ0NY7R1iBoaGhoaGhoaGhoa7lk0QtTQ0NDQ0NDQ0NDQcM+iEaKGhoaGhoaGhoaGhnsWjRA1NDQ0NDQ0NDQ0NNyzaISooaGhoaGhoaGhoeGeRSNEDQ0NDQ0NDQ0NDQ33LFra7YaGhobHMZ7/wF8L5dRCrD4ld1usVcZ/fvf/97KH0NDQ0NBwILSFWRsaGhquMDChWQLXjfCkPlHGGPX3yzpObTyve/jfXvBIGhoaGhpK0QhRQ0NDwwXh+fd9KYBVPJWHYVqjWnsJzCILNrPvsOwn5bI+UUsRqsnjHwZ43SMvX2QMDQ0NDQ1pNELU0NDQMAPPv+9L9R/965Ub1/i1i3/TtmNgAoRJlEKMJhv2OeKTwsKkCODyiFEOc4hT9TElSHMjTw0NDQ3T0QhRQ0NDg4Ln3/oSusEbv4d4bdYa1gXK0CRjfQ4R8jgAIdKgxT5dlU/bVMJUNf5CdbGRpoaGhgYZjRA1NDTcsxgRnouGMWNyVaIMZZutJVcHiLcZ3LhdT5RK3e6k/bU2C3CVPnc11+gQ5EhCI0wNDQ33KhohamhoeFzi0slODSTj2FrZuBWIURUBOgT5OQSMQADdMN7uhHMkESe/nTfpnHj+LvLTeGFud1PIEmv/dY/+u/o2GhoaGq44GiFqaGi4trhWpIej1AguVIZEo/qqkh+J7GC4AaDrprff9zJx4tv6vpg4AVyPBA+zxlhDmIR+GllqaGi4rmiEqKGh4UrjWpMejosgQaO2LpAUlZAQgDKXuY635eTkFCXb+qHc1U5TnHi1a0COOIrHPMPtTkNzx2toaLjKaISooaHhSmCUre26vpomZ3VbMEnCIUhQTtXRII2FHwdve+gBLFOIJNWo7/NKkqQWDb1MmqTxSvv3/agbyfXuoj+vF6IkDcP4Xm1xSw0NDdccjRA1NDRcKJJpqj34LP9Vfk3NWtPnipAgbPB7heQiCZCg3hikELk9WSHbnAPDzp8bBpGU4G1OIj4S6QHYEafRNnYvenKE27sCitKFZLcrwUSy1IhSQ0PDRaIRooaGhoOhiPzkoJGjyyBMSyzWuRQJKiVAnOxMJTo148gRIKDkBtd3ewParFbxd64EeRKCt3nDG5/fvs/eO04z2Dmp8eQIt9cL+3KXuytAjjAudN2kFLjSJF0/dm0aSWpoaDgUGiFqaGiYjec/8NfiHweIP1BxCHK0BOkBqEqTvet2IRK0NOEpGUMtAeL7SEawJzv+eqaM55Qx7fsJSo5ucHtwpcmVEJ9rSI4A5hEkD2ktqIMdl3CtX/fwvz1MXw0NDfcMGiFqaGioAiE/HBdJhjhqX2VLER+PSgK0G8I1JUHSuNkYkgTIw5Me/5u/f1ZYDfIEyZMfR//GRMSPk69jhOvwvjhh4mD3VTU5skr7CXLk74uiz7NGDvG2CixBkDRcpLnRSFJDQ0MNGiFqaGhQkSQ/GFedCB3QyLs0InRIEjRBBRoRIGkfKQFCZ3f1MInwhIgb95Kxz68//lta+BZgTEa0e4iTmBQ50ogPbxv/7s8h3mbNNCWp5hk8hHo5AxdlhjSS1NDQoKERooaGBgCoID8Yl0WESl9bhzLkpCxbGSPz2pGgpVWg8LewDycu1uavsUR2Su4LXkdKvy21kyNHE/YZE7N8yu8q1agGS6Z6XwD4OI0xo+Pm23J/a2gkqaGhAaARooaGexbVBOiqkx+MCzLaFkmQcFkucYeIBQLIEyCxn/Tfzhow2rpBodIEMjRFPXJu/CzkyFGOGIn9puOPDkaMJCxB9q8IcuetEaSGhnsTjRA1NNwDuDbqz1VJiFCLKQbjSJE5cByQ1CdAEQnC+xmv6GCUqECkPZYuuzJluBkc2WdElg5JjnA96RmZS44OoRod4lkW7vnLIEYlylHN/hIaSWpoePyjEaKGhscZishPKjbjorDkq+e6ECGRkFQSocx6N8n6EjRCxPbja/4sSoJ4lsDc3wkUk6O5atGIyFwD1ehQz3niObgMF7scprrXYTSS1NDw+EIjRA0N1xwjAlSwnseF41Cvmct21VEMwSwRypEgLVsaB/89V58OcryNkZxwHP5/f7yj7exvj5wSxNvhadRz943ye5YU1cQelcQYHZocXRdiBHCh5GhSVr4DoRGkhobrjUaIGhquGZ5/35deLbIj4SJeK0uToZwyIYEZf7MVoUrXsWpoiRK4SxwGV4JGSpFN/j4iQTxhQul1TN1T3G1qSULkUaI83QvEqOS5wDiwa91VNWEaQWpouF5ohKih4Yrj+fd96fSdpYVLl8ZFv0KWOJaSDGYpTCFCZAdOIg54faYkSjgECVoSGUJzaYQo9XuCHF1bYoRR+cxwzCVJVaYMzwpZ8jfArPu4EaSGhquNRogaGq4YFiFAHkuTB21dl0Nh7vjnjFVMhFDhDpRzk7toNSjT/yhGaLWif+dIEP7dubzxqF3bnPJiDDXgjQGD1gMaZaQ7BBmq2f+QqtF1JEYYuYmFGajOwjclljJ3jyfaf90jL6/rq6Gh4aBohKih4ZKRJUBaXEWOnPDfc3EapXEbh8Qcg+gikjSUuP+Uxgtdhiok9KkmS/BtYKKTIkFiv8o9lkMFiUmqQZg8+b7533MJUWqcqd8O6U530cRo7kTMRRIjrvYs6XKMSU9l+40gNTRcLhohami4YDz/1pfsCtggq8ii9bjDVSFBHqnxIMNtscQJh4BEiPb9jRIlAMgZ4/DvLNW2s+jv3JpCJeDPwDCof3s1yLvlBXUIE55UW1kyoCSqKEVtyu+rTIyk8eUwJT4M4KCxRiop0neQ75nSSaUF0AhSQ8PFohGihoYLQCBBDRFXjQhhZLKlEUPtqhChjIvcKE5ojkuc8Dvwc1JDJGoUoT5DcFJ/D26ctpxfj1oClOq7tj421K+7K91UHDDWyKWI6Ljy5H4AoO79lklU0chRQ8Ph0QhRQ8MB0AiQgKVmTw/5yppDhEjF9OKmi6KGCGElSHKJAyDHXEWCAMqPsSLpAY4PGtUV4omShi7ul5O2qYpQCebEGS1NjBLHd6WIkcdMgpRcb+jQpAgj5eIsuTcn/n7do/9uuXE1NDQAQCNEDQ2LoZEghkOkxT4UMkQoVpuRVntpQpQiQpp7nD8uy+rWqEFTSRCAToS4yxGK8zHbXv1N/NsTKEx4LPstF493WVkZD02MvFIkkKKkKXDIuJtSzCBGs4he6b783CydWVFBI0cNDcugEaKGhhloJAjhIozIQ2S5I6pPhdF1WWSIxPZUZI7rOhY3xBZZBUaEpFTb2JDubJpQJGNbBMMfjcP0Q4wR2vbpmKB+oIQntZbUlHtHi/WbiynEyNoR8UkSoxxpQtfkSqpDEiqeUeccFC/aWkuKcGruknOD65am/M7VZWjkqKFhOhohamioQCNACIckQBoOmUmuNKV2zRpDl0CE1KxxHiv6t1tVrDlUGxeBkSNECCRzXCbpQLLdQ+IiXEBTvy1FjEriia4KGfI4lPpS60J32eclcx4aQWpoKEcjRA0NGTz/xhfFPy7IDeJKYqoBmJr9LMWc11Ruhn/O2kKk8kLqUGq8KSLEs8JhIsRJjbSQKnavS6XTLlVcJOLiZPIyWkcIu7Zh490Y6hKH44ukeKISBUtSs2ru9SWJkZYKPKV09VRBc/gcSG50Wha6wZW5zV0VNFI0Bk/7jdc9uv3vL2lQDQ3XA40QNTQIICTIQ/MRl4z82t+kvy8bSxAgDTUxCZLhKhmOtSlwa4gQwOHJUGq8pUQIgLrGhdghFEPkXYg46fG/W4X8SONLXQ9fDvEripLj3HgtIewWx++NXvhN6n+J5+0yiBFGyfn1YOcpSYwwkWQZ6BxPYqG0Xw3pPZiKv6npb+n35nUmRQVo5KihYYxGiBoa9hBJ0EXiKpCjQ5IgCVMNiTkz+gD1ZCjsN420JLEkEQr1eIrt+Jvjawzx+gl1yBkDplQVSmWHS7nI8d9H7l6J37Q2crjqxIijkBi5EZlExGh0fdB+Eilayui/iHfFEu/OA5EiHNd0FdDIUUPDDldoOrqhoaGhoaGhoaGhoeFi0RSihnsal64KeXAXkYtSh5aYqbwMdahk3BnFTctGJbd1AHe5i1CGUCY5l4kjyilDYbNz4e+RWuTc2FVO+o3tZ3gsUI9SbePfeNxQKhvb1PsrdT/XKkWl7ptTkFi7abL7nPD7yEQodW8txaHfH7Xt19xDFefGn0e+FlJTixoargYaIWq453BlSJCGiyBDS32E5xgzqdiqA4+r2AiZQoSy+y1EhDCp4TFDQvpsJ8QRkT6MGY3NFZwnkzDESSIFwYAPrnI4FkiKGeK/hTWH+nhMPVuvqCT2LEmCC4hRLQGYul8KiTWcRuSmlBjx34ARI+kZlUyJq0SMeD9LvYMmkCINhyRHEiHjKcnxbz9z5xUHG0tDw1VEI0QN9wSed/qFV2omTsV1IUOHiHfiCplmWEhqWsFiiNnrjxfy9H+rjU0gQ0sSIY9USm10LkZxQ6mFV4ERIQsACfswSYg0NQeTIawc+X3wOSxRhKTfalCagCN3r2vt5FTNIsWT3Z+p3xJptjEpMsaA225RPeFC432nnv/iCYgLVpuXwoKkyOMQ36up5l4jRw33Ahohanjc4nmnXxjKjQztsRQZOqR7XynBSixgWOUOBzBtvaCaJApa/0sRIbzIKidCeP/UwqsgECGPFCGqSYCgpNpWkzGUushJv03F0sa7lPJ7St/a/TU4+ptGjPqejhkTHUyKAOrc6KZcgxkZIFVcBikqOd4FyBHAMt+wJcy9Ro4aHq9ohKjhcQNMgDg0N4GUy0Dpb4uQrYskQ0u661ylNOF7FMUCeaOxOBPc/jh9Ji5JIZLaImmrE22wfUdrCoV6goscdoVDv5G1hfxvfL2hPVQi5CHYdEEZyqXaLokbIm5eiex0F0GIwgALY4BKXLCktlP9qn0V3q9S/JZU5kTHEyNjAThJYvWTLnRLESOAunfMVSVFAFdONVrK9GsEqeHxgkaIGq49UkToIrAIObpoYoHJ0ZQxXxEiJJFUEVMUoNBJ4bFq6/ek2qglQtLfzB3OcRUokCIaI+RGbcpDBIARITKage0cNcYVwmL4Iq24XqkxP9EIn/WcTnWJ01zu8D68jaWJEVeplHgiMeU2catbWC3y4ymB9t6R1piqBT7/uevJf7+mpKimX6JEChNKjRg1XHc0QtRwLXHZJMij2CBP4SLJRY37joYrRIYAZmaIS3YwgQjtBlbWhuYex4/FWrnM3OFGREipN0qc0JUa16gZTlKIUawbyEYz0A9IiHhGr0UyfHH1qOSZSrmaptQotb0KUqS51CXWKRoRo5Fb3cJqkcch3HpLwa+jloyDg98DKRSM6yLJURUh8uDEiOFnzn5o5qgaGi4ejRA1XBs87/iv7Ar4ZazNWEl/S7+V1ktg0kfpKpCKKSpR5binuCqWtKmPT7iORY0WuMTx9vHfu4GN20u1AZk4IY0IAYxigUIGOewOl0ickHWRk6ARosLMcqZ0odYDEiINi6dC1txT+bNWmqBBGk9JzJp27KmFcLkCJBEj3/dmG8YyqjfXnfEi4z65OnQRqFjItQQXQo60pB4JNHLUcF3QCFHDlUcgQnPghvIZf4yE0XFtiRDHwmRoynlJzeIXt33RSlDY/4DucVzRUVQgx8mPlm1ONKzl4Y5QSoiUJAiXRYh2P037zJXcy5Nd8OYSo9IkHprqAaCrRVLabRLz1at1nRQbxsdRg4siRpdpCi1Ijg5OjCaQIoBGjBquPhohariSmESCHPuoGEtn/HOz/xyNDEUcmAzl9kvWqU2MUItSw3Ouexw/x1LiBF5Pc5WrjRcqmR3nhEgN1Jczy5mUKqEZ6fy3mfEqS3zuuOpZonIm7+8SYpRUEiuIkXSdU9cFQHejG/g6Rlq9mS50AIclRZrr40Vigntf6l4+KCmaSIgwGjlquIpohKjhSuF5R19A3ZckVyZObDgRyiFnGD9eXeQwao5hqUVODwFVtSl0gdPay7lLHjJOSFOEWD2ythBWktg+hAzhn1IJAjhSZAjvk0iWcFBClBo7+fnAn7uMq6Ya95a6H2gDiX0KFUyMErUIIKMCyWpRkQtdDQmZ8p6RSGBNbNBlYEFyNPfdPNuFTvpWo/LPnL9q1vgaGpZEI0QNl47nHX3BrP3d4MAsoRIUtHGtydCCY78S6zrlyNBS7Y3aLyBDU7PH1brH8f2Rq1w1EQo7YsMY7aaRIAB9rSBm3BnN6NYM81SfmuF4ANe5YpQu7ItQfG9IdUb7FKpFGKWkCKBMLSp1oUuNQ4OmeKVwFUycqYtXV5KjQ6pGk93oCicsGzlquGw0QtRwaZhChNz+xWusIeViFBqwo91qPyZXgQQdiLxdOhlKGn0T3CFLEzAskTSBtwOgxwzxNYOIC5yRM8mhes6YOiIUGq8gRFgZkrazfYyScGESIQr1612yZn32tKQsmlEoJW9hKE6uwX/TtpWqRTOTLoxVIF0tCuoYXiA2RWqlRBScBKWywl2kKxxed6qkPLX9CixNjiarRZUeHI0YNVwWGiFquFBwEoTVnVQ5hSJCNFEZujJEKPWxBxj/XYMDxgctjimqUIFBKrcpnOdUX0LbWUKkZZLjWeNSrnJ8YVaYQYYAVEIEAHQx1hJlgRMiTUkqJUTatkOSolTa6qkoIUapRBvyzkV9qIQCQ3JbJIpgvQsdbnN07ucuqHoZZoy0EG8t5pCjitTiOZe6msQgh1aKMBo5arhINELUcCHAREgjOFj1KUWWDE1UhAAqCMAhSZCEUleRFK4TCfKoJUNTVCCAhMFZT6onrS+E2+qQC5zmKsfUIpJJrnSNIYyRsRqLpsTN7dCESNzngO5zSxAgCXPVotS9VdCPCul41QQalS50rO3k+kW1uCxStBTmfkcuaX2j6uQLjRg1XFE0QtRwUDx39SIAmEZ2SpAkRNyAneLTn0PNRyznArIk0dFWbj+US1zKZWguprjILaEEzeynarYfKz24jp/Bxe5ziqucuLaQplDlXvtMJSLKkFhHUY7228yQ2f+CCVHVZ+9Q97VHabxZqJ9Qi7R7eYpKmktu4c852l6ahU5Vi6RYmxrSUWvO8PfilFifJUmRxwHJUa3Jl8qkmF0/bgYpktzjX7/94cJRNzTUoxGihsXhSdChsTQZOoh73JIKy5I+6QyTSZDHdSRDKfKDP9iV/Uya4S9NoCBkkkum1E4Z19qrXyND/LeSpApQqAodihAl2rh0hQijdLHeUL8grii1HffJF6PmmRY9+PnCBEcjRW7QXe1SLnQaSshHSVul7m6l79ZDkKLaMUhQxnWhZt8CpEhCI0cNS6MRoobFcBFESCVBF5U9rvTjtBQR0vqbmrUIYTYJCmNJGFFzcKBrvWtjQtsFfVTFDPG/McnBC6viesboZKiUCIWdMwavz5hbS4jYbwchRKqbzuPUdS7lbqnVKf0NjyOVJEK6Xux8O21x10JShGNaspibsW4KiSlJmnAoHEg1ujATcAIxKvEqacSoYSk0QtQwG1eGCPGP+EUQoRJ3q1JUqj4lC0Ti46sJnKXjqnSxWcJ9bk68UApJozHRdqG7UXZ2vySjnLU7FzlehyVTCC5yeNi+/RL3yxQh0rLLaWUAVSW6UEIEcDj3uatEiADS76TU9iluurnkFsh9zmnkJ5AoR41g5byWLHg76r9k3CX7XXUcQDUCuAByVEmKatzsGzFqmItGiBom49BEqNglrjZoGAqJUK3BMQWVH7YLS3Iw4ZwGXEUyNIUIlbZNuqmIGwKgrnJaAgUAsr4QdalLqE85zCVE/O+rQIiuo+vcVEIEsOw7KrVPyXXACRY0UsTd6TwKz+0s5WjKPXPVcd1UowlZ6GpjjxsxapiKRogaqnFpRGgmCQK4ACIkBedq5YJxSkrPwTCHBHnMdZ+7KmSoQl1Ur1GNOoRc4og65LfzTHIFRMgrSKP1g0KFCYSI13scEKL48yUSo1RihbhR2TfxPuEKdk7NlupI14kn5tAUopBMA8USketbT4riUGaqhBfp7pZBjdKv4rrEGh1QJcJoxKihFo0QNRTjQokQDmy/DmrQQqm31bFq/v0l5Vy9qgFa9cM1Qu14U31KuGAyVG2gaAoRjxvCbnB4TSG8/wqrR+VkCKCCEPFttW5zF0mIUr9NdZ8K1UpUiIU+m4lnQL3HcsSoNL5wigtdwTkncUQkHbuefvtCidEoVu5qKEQl993BiRHAYchR6UTZwqQIoBGjhnI0QtSQxIXHB3kj1Q1XkwgdmviQvma6rWnr8NSsyeMhXZcJ60lM6pPj0PFCYlNRDVqUDPm6vn2mFqlptREpGmWZyw2tVPG56oQoV+ciiBHpb4YiqjyTk0hRTfbJlIKEj5//jaGsO5WNJQJYTC0S+9TGyMeg1blgTEmHLWKpdfGWJkY1MaZziZGSJbSRo4YUGiFqEPHc7vN2hZKsW4XwxAevL4B+lHeaE8ORwuOVCM2Fpsxx4DpS+VB9z1GFtFTszBidsnp7sm+s9khJFDAhwooRKhPSo5EhC5HE4DIf4qEJkTHEmPKEyFlTvzAr/03DVSNFc1XRPbL3X+mkTy4zWipjWmk9jQxhtzleVyNE/LdKFBGjKxhTNMUcU99XByZGvs/0voXKkNh4JSnKfYfQ9tf3/6FuLA33BBohaiAIRAhgMTJUnSq7kaCLxVKkdy4ZyuEQZGi0+4zroO2LkiWo6w3hpAnEPQ7vmyBCEi6aEBH3qBlqkWrwXCNitBCq1cjLRI4QAdB3hJZgAaORosm4MuRojnvpVFJUiEaMGjAaIWoAAEaEPGYayocmQqG5nEFwgUSoWl14PBAhDO5SV1NOYSkyVLuGUClS9xJWgoR02kQVsjbWsTa6ydWSIYARISqKJSolRH5carzIAQiRVLe0Ts7ALWgzF/h+KByMFOVc5WraFM5BkhQdWCESx0DavrqkaOn7aVFiNFctKkGBx8FShMijEaMGgEaI7nmIRAhglrF8UUQIIGMsHJAIVQfYk34mxO8s5aJ2CBJ0aFw1MlRiNObihvbbxSQK2FWuo6514tpDmkGbyhSHUUuIMC6DEPH6JXVKjNuZn8JDk6QqYpRLjuDrlHWcr6O0pZIiLcHCAnFEyTFgXHdSpMWFlsSjXeY6RhPjh2iVZQmRRyNG9zYaIbpH8bgmQqF9luY4VyfTF19J/UKIEEBaXUntN2VsJR/Zuam1p4ylBPx6FJChorVePLCRmTI4C8kQAKSTKHhVCKtJxozJkDQ2jxK3Nw6FUIlpvIch9ovJDt7O44kkdUkaV8l9ph232mahwTTxs8jfEUujmBRpyRGmd5xXlBiybnMHTK6A+08S1BwpuuqucxPj1A5NjtKZ/0omMy6PFAE0YnSv4hpOFzfMheoeN5EMGWtkMqS1aU2Voetf3saY8E+FtfHfbifZcMV1hL5wf9pvxag83tF5k8pS8oEp15CPrbY8db+p/Wg4FBnSSLVmUGj17Xhf16F7sLOBDDlrIxlCypHrEBni9/Uh4kjQoZBU3xjis6U8c9qzyI8DJ57AbUr3hrav1r52rXJjksribmXvj6nAhqZqdJYS34L2w98F5aKxYajPR5mqq4Er97OI6VKxNxXIeh5IRGBQyOXgxPrk2g7DdOLHv7d7FH2rJ2BO+m31uRDK6oRxw+MaTSG6h7B0nNAhFaF69YX1WakIzVJ+cqglQzmUxt0sMZ6LwpRU4B4T3OWqyFDKWJDuJ9zenCQKK1S/KzfKF1OIOKS2cN1+iOdZUYuKXOZyYylVjmq21xqEMz6bl6YcZXBwU0BTgQ6gFGXVodokGxeoFB10HaxDK0YAZarRRJWoiBBpClHN/Y3OR1OL7h00QnQPIDnbMcGwvnQipK21MSGeaHHyM+q3sv3StNelffPFWZN9K+5XS7ndHBKFCtHoenNDQFvDBS92yRe+1NzoNDJUmkSBxwxJJE5yGcPuTH28bksTouBC5wkPNoRqUnD7+ytHYlKuWhpJqiJaE4zeEpe90S6HeZamxDUe2sWPILUY60xSNCl+a0rmwQMSo+pjmOuufMFxRjIxTb2HJiRUSLmTT7m/0bP9+uHV9fs3XCs0QvQ4RpHsW2F0XwkiJO9ctc/BSVDoe0Y/U8nQlD5LzsfSMQlLg5CFiWTIb5s4k0iQIkN+m98XK0RYFVLWHlL71Ma9J0VLEiKMUUwRQFmCBY241N5fOUOrVi0CkA1fvu5ObZuhysU8P7n33IV/+iVDdiFSNH2x0KtJioqwVPzmIVSj2tii3L1BNicIUQ4L3PONGD1+0QjR4xD3NBFKvLgvjAh5THYBm5EUIdmuomTkwOtLCtLUcg4li1jWkCF+3Dmlp6Ts93WOEiHUp5MIkjFqEgWRDKH+nN+ET6F2biWVaCohsqjM2wRYhhDhbSlVqGjMM4iRpgoukLHuIknRZaULF9FIkdJVhVInJU9YAim34lCHTQpo39slCBFAndvcBREij0aMHn9ohOhxhKtOhKpdOnJEKOXixPq9cFwEGVKvDzMiryqWIEQZMpSMFSp1t0xBDQxH5AXHC+E+JWUIu81hNzmBDAEwQoQhESILYHqFIOB7pui64DEo5Mdfu6mEKAWNJC2hFpWohAul8Z70+Z0TbzcHNf2m6l4VUlRCci8opqj6PqghQrXrvqVUdXWf8omDKte5JVSiCW6tNWjE6PGDRogeB1iaCO2qCy/Cihcp2W1ugoTYEP2dx3LM7fcQmJpqe0qbUxWgy0TJbOhVIkPaOVbIkJheG6tCfptFdY1Rs8m5xFBHapFH70J7IiFKGQuF8URxu0KIfB84nkg0jCuMF63uVLWo5HyM2swYgEuRooqUygcDv16pVM+5MR6QFMUmCq8fwFj5qNl3IRw0bkhbxy6FqcQoc14uxW3uwGZuI0WPDzRCdI1xYUSopJ2pZKhE5eFESOhj8iKph0bNmjpTzrF2vHzR1tyCrlMWeV0CU18/EhnSPuApX3jp/GluWtq5lsiQlkSBL8zKkijs6gtt4K414xMQKVIIgidEzpjxYquHIkTK754QOWtkcqT1X+o6V6oW5RSh0noAk9yvZhnCE0nRJJe5uZnNirIDTiRFivtYFSmiO6br17hPZpB1l1ti3bfUu30CMZrzvb0Ut7kLNHMbObq+aIToGqI4R/4S7nG5tuYQIYC0ylNAhADoB+VKoWY2t9YNMUWEAMpcIzCuKxnyQOmqq8nQnHtHWg9HSqKA44VQHWdMiBHCCRWSZAhANZJElYgRInGBVVYvu72GEOE2GCFyXs2bbOhlSFzVbHSGFJUqR5WkaBFlYIG4zYOney7dt5YUZcZ2MFIEUJZoowAHixuqea9XfIPmEqODqURXgBB5NGJ0/dAI0TXCtSVCpSoQn4m/rFTZS6NEJdIWsB3Vm+DKWAJPoGqJkd+HE7FDBrjyc2Bi6uqDkyFvkGRc5ABgnEgBL1jqkyh4w8Ja0U1OIkNY3XEGpa+2BilAIMfoaEQG1+EoJUTOJQxYN/4dYTIh0saXO7ZcfzlVqEQ1qjCyJxnEE93nUu/PC0n3XIJSUsTTLE8lRZecWGGR867FCi1BigCK7rGSeyupTh5KJbpEM7cRo+uDRoiuCS4sYUKuvVoilO2jfL9rR4Q45iSpOBQR4pjy8dTUqFxbS7rLAYCRMrwB0KxuWjs5lCh1WnptDzQ+kl7bq1soiYLD/aGyE8Zs8IKoWC3SYma85+RShEiLvZAyzR2CEEl950hSbX8l8UwSKgzti/gUl7xDrxUpkupeFCm66BiimkVJ57hAT3SPJ01MVSEfJ25zHI0UXQ80QnTFoRIhPjNfgSpVSJgRV13VckqQGpCe3u/SssTlZmWntMmRIp05tzg8Hs2VihvKqfHnZhWnLBqbU4xKXz+SgsjOg5haew4Z0tQgKaYIJ0/wv+HxYDKE1SAfR4TUoSIyZAAAnbpAbiRCZAxzZaOHmU3FPVJX2L4aERnQb4k+FiFDmT7E7bXPdIkqJJLHIV8n/LT853iKa/EixvkSSJEi/m4rJEVpheJySdGuqwn36VSFX8ISmU59U+zeSypD2vVMHNdVd5sjMAZe3/+Hyx1DQxKNEF1RJInQRFQTIf6zGlSeGVPFfpeeICF3jpYkQwDxnOfUIK1uLabOMi7lliduz4wpp45hso7vKYkMlRKh0nGgfiiRQePA6bX9dqIQIdLTjY/LWRPJDx6CRIgAwjUm8UQlhAigQFkR9tP27wVjFsczLW1U1xIijqVUoxwpKvjkLvlZnvoerXZrOhQ0UuSxdBa6qfFEC8MJz7ReeeEx1L7vp3yTapNsiD9X7HfZpi56Dhsxupo4gM9Nw1yIZMjYapc4T4BwedQmb9uacjJkbVoJYimDc/t5MmSMuRgyhI9VOe6DwJ/vkuuJ617UGPm4lnLNS7XDFZVUjE9u8VUObrCnPoxFKb79PWPzZAgnVcAZ5XwMUCfsh67zSC2SzosXXo1BaxgZ2rZ0HCWoMSKwSoUzzJWQIaXeouPLwZ93/E7Av3Fo77fcOc7d3xDv5anvwiXen2rfuXeQG6JBSsjMAi5cufFI74aabxqA/k1L1c9NCuI6Ja7kqfFh+HO9tPs0voaHwowU8ioRumpQ7pviePCGC0VTiK4QllKFJiVKYIZlUqXha7hILkS4biahwoUrQVNJxRLqUC4uS3EHS6E4he4Sbn9zMfcjW0KGpKQcJS5zNWQIlbNkCMcWreRyIFZYLRLuC2ei8kMSJyhqkZhkoafXXlWIErFDo30Elz0pbqgqvTZAPN/czTa131SFqBQ1GerCeZkfT1f6qa56n6bc/3J9T5zVn2y8T1WKpN9xsyVujnQH/bfUvtL3r2bNnqnney5Kr9dUlSgFdGxucMG2yRKiy3Sby9lEDE0tujpoCtEVQSBDWDnIqAhc+VGVoFghaZD7GcGRSiPNbvmZD2+opMhQQhG6UDK0hMJSsz/vj597/7vB/9JqHT5n2vUSz6l3T7hMMgQwzRjCz4PHVDKk3qsZMqTsJ5EWUpckWkDKEH+O/O+JdnHGOZJ9zvj7CACEwxAXc7XoXwkG0MlQqFOoCvHfU0aK1FduHw1LvWtKsz/i7SVuxZnxSarRJCWJ95VT9FE/BNJ5KMouidSjUmN+tG5ahVIk/U6aykz6jXfQf/P7lipCvG5qbBfpxYBReo2wMlwK7XgE5ctYcz2UIW3yRkFTi64OmkJ0yXju6kXxhZMxFvELoShLHN15978iU09Sgrj6k0mMcGmxQSWKWc0s25Q1QTTFxwgf8Rr3DgVZ//+pxGiJBBO5hA18uzQG/3OODOHtqXOYM3IlMiRltdNih9Biq9GtLe5HlCMhqYZIakxc0BQrQESFKcg6Z3p5e1Q3UJcaQcFkJ/Q9JPsdbePnuNKwSPZRW4e/76oUkoyCVKoW5dSbmt8rZ621drNK0SEym9XM9o9cMYf076Ep7X15CUqD0OfBznspDhlTNHftIb5fLt34Ia4dVrLx35VoatHlohGiS8RzVy8qqodl4qp02dy3OGdoS4ulai4r3OhkC6xeiUVTS10HD0mGSrPI1cbFJKCufF4SxJoDP75cVjt1kILfu7aOhtJ/ERnCv/Gy0q5Yj/1NFlwNbcixQ4EA7UmPllUutknbHalB6Fk0gwu/U+Kx34YSG0wmRADlrnJM/RH7TBn82rYalH7S8Dst5ZLHjR2MOaQIv29T/ebGi9vVfl+QWGbduJZwiy1NH83HOJEQ7ZoquG8qk2PMQgkxyh3vkjgUKVoi1Tbfp/a+mQv8fE193vZopOjy0AjRJSBHhLJKUOqDUegqIBKh3Q95JUho61Izw2GUvoTxeapZu4G/kFOBoZKLXPgtrwyNzmVqxld4jPGjTeKM+HhzxzQl8PUQ8Uo5MgSwDCGS6mCCIpEh7G4kkSG8CCsiRL4tKbvcri7E/f2taSGWJZc0Q8+5J0UppSaQolJCpMUNoe2BjGlt8m25d8cUgrA0csprrm6pEoHfuTXjWvL9W6oSHYIUlaKWnE3NPEfauEBSxPuDSzz/U9ydU9+M3ARabart2gnOJa9d7XOXI/3Gwuu3P7zM2BqK0QjRBaOEDGUqlHcmGJDi2kG7CrCvkDcw8XAumwBh1KhnHjUvUr4mTWk/c13kcrO+ChnCbSQfc03lkX6figXTlatkCEB3lxs3Mu6jpK5/jiR3OWNiWz5JgjE7MrP/fawWyWSIJmrY/z+wsocnIAO6JxYmRKKKVOIqp7nYAeQVIo2YznEjWwJzSZG2nansYVvNuJZ6HyfOYXGChUORIun+qUk4sDQp4uM6FFCfl+ZCtyQpmpgYIbn2UK37+1LXbAohAhjbH+z8NlJ0sWiE6IIgEaGqmKCSF1EuPgjPOnbdYZUgSWWYqBYUud0tcf6W+ojkyFCNG2PuuKeqRBMxuQ1NceL3hXAPq/eddG5yhEjcJ0GIJDLkE2Hw34UU2w4rQ35sHf0dp8oG2KtCYdt4SM6YSFAsxKxxJsYUSYQIAJEmZtCphAcAYADZVU5zh/OucikyJM0O1yQruAooJgYVpEiCFqeZUpVqFaaKsRWvT1RrmDJ3ULFcRUaV/g9FiHY75/edg+tKigDk53sCKapajLUEl6EUVZ7DRowuBo0QXQA0MgQAelxQaSxFYvY+qQSN2pMJEEAhIeHjwpgYu1JFvjSUvngOtcL33Hih0vNe8BgvQYZ8O2KMUilyihP6Xb32JWSI16t1lxNID0l4kCFFOJFC2H81/h2rQaR9/woQxm16J6pFWULkN5cSIil2yO8rpdjG/Un74P2kCZJctr+rhlJSpNWt+T20LyhJJb9PccFTfy4gJnNcl2qUvgXVoTikq68SxS7xc3aBSh3AfMVoKUKk1C3GIWOKyPaJZBIaKboINEJ0QGjucUVxQRx4Nl1BSMHcdbLSIyhBpusI8ShWY6bGmBR8kPgtOZkQ1bx8llwfByDvJsfqiPFCNeAzqMyg4ORSuuZ8G/9d71rffwqySmQFqc8SoilkyG/HpAggkiHYq0EWSB2qFhkAa2QyBBDc7AgZMgBhvSED+4QKhpAZknWud7t62wmECJGh3X5UAdq1IWzT1KGU0Sa5el20WqQZ4IlnKqCWFKWM/dRzjBWUqc9XCSmaOrkyVSGaO6kS7kPF/TnjnYDfX9UTPZdBioR+LzWua45idAi3uTnIPes1EL9d0wmRRyNGh0MjRAdCShViG9MNZUjGyGBMZYpDv0uG5iKuaSlcJBkCuDh1qCReiNctSRBQC+5iUrxbGeGp/X3KqyWrSmbvB2ECILW/qOAVkCHeFydDADF2CJgy5NVhKdU22m9Ehjj8t1vJEhfScGNCVJJpjqg5+98Z6dn9hsmRoBDhuhoh4m67GBdJinLt5p6tGleu3D5Sn1P213CoRWKnGKlz3G9L+sokd1lkEueySBHr+9Jiu+YY+RNJ0cEI0ajNGdfxQIQIoJGiQ6ERooWBiZAYI1SqBPkygzh7LsVN+Mvq1SIhJXay31yg/RRM8N1OEqLrRIZqFhWdC22WS/PHz81CT5wtW0SF4mNOoTZ+aA4ZwuoQiykKWeSCGmSje5u1uxghrA4ZE+OGJDc5E7fRWB5URUiKsFNq/O+JxAo8RogRIkKGyH4uqj/+WmKSlCJDmhqDkXOfq7lvS36vQS0pShl+c5631LGmMCEGhj/D4zYTRCWVuKbkWGsykgnnm6s/S8RT0vFdYVIEcHhilHPxn4vLJEUA066l9k5Z8Pw0YrQsGiFaEJwMjVCxxoqEohW1NZKk7Z/rdyky5NtKoJgQTckmN+psYRc5gKp4ofCzYIAvBo1ElMw8a/tNHsrE9ahK96l1l5tLhjy0RAp+/26/OCtWg3DsEHahY7/v2t1vQ31G9zVUTSJE2JVOIkQ9vZ6hXaL2CAQGK0De9VZShXBbiQx3dBDo2HMKUem9UUKmpyDl9qYhOxueUaJy+5SOA6DKiM+aCaWxoVMXyyxVERIqEMbihMjjKsYVkboXSCIugxgdMl6q9jrm3jlNLbpyOMAde2/CkyFjTd41jrtN7eMJACgB8GVjzFgN6rrdv10FNmM9dosz0jonqF8VF0CGnHP16pDWnrHybKQvu6H+pcmvnRQvlLvmuWxyKfhrjo1+vE36fdeB3F72RT3zd3GXwn2mGLw1ZAhfq7lkSBifk363+PfxUEUyZEAkQ1n4d8ZUG6zEjau0nSmGoLaPpMxpv6f2yVxztY42ptKxeOD7j6RWz9xfqTZzz7k6EXYJn/8pRqBmxON3Ov9ZdB8bAnlwfU+34/95uQa5d9EhgL8BoUtkM+QgfdOWwEWtRYVxiOMIbSvvEQ0XpDXklnJpKEdTiGaiWBXCKMkKN9pHiI3gM4OSW1wu69tFoXDmDuOg8UwlmBLfJalDueu9lMEyJ81uLQ7x2phiOGjnSDq3uQQKqFxMhojKg2OK9tuIMhTvhxBHhGOPMBny24RzIrnNSYkVkqm3AcYKkb9/crFFQnY5I6hGpK1ShQiAnlu+bSrJ56hVjeYQxZpnpVhpWYhsFiwyupg6RBqtUFJKVQ3mIjf+fcL7cSppvCIudLFrwW1VwnVQiy7bfW7UT8F1FScylidvTS2ah6YQzUCSDGmzLopSoCZHwGWuAhkDpuvCv1FbGkGzho5PUq+0banfNUz5YF42liJDUtO52Tthxq8KXD3KKUzafiWY6wY3xWVQU8R8OykyxGf1BRVhijJE+4J9OzZmasOpt6V+/M8aGUoJFc7F/UnMGPo91EX1bOzXiAYkKmcMzHAsOZevUjJUsi2h6mnZ+0QiWuSCW0jIcuPPKV2SepTqLzWm1D5TfscY3Lz3uvR+VCeGEuPKjUEjJlJ8W+oe9+rSnEmnQytFHoq7fNIuCBXZN34po11T9A6dEvyQilHox+jfnYu65ns0tWgemkI0EfzGI0kTJJS6TOUkd5RFzpOgkr4O+mI4wAJ4l6YOHYIIpdJr8/0vw41l7rolNa+QOR+I3LnRPkSSOxL+WzCotd/FdjHZ8coQfjaRSjTsyyROSFqPSCJDmOugOKJQFlQiQ1QiQe1JbA8Z5vC2fhjXI4qS5H4kGJ8ScmpextAoIjawOydSXVNj4GtkL0UGa9rymDumXL0CJaM4e9kU1MQUSbEiOc+DUqXGmLi95B2VexctkMlvEcxRi8hOCydgkNqbmQhJXZ8osc9BUKM+H8gua0rRNDRCVAmVCMUN9G8WG6QGl5cSIdRWcqV3/9K5iBmSygXwSm65SWshTSFJM7P+jY1s+frH6opRHupfIdHWE6XSj7s3KrhL59RMXgCx/wORIa8UmMHtynysJe36tozZqy42/o3XHup8BjpfH2hqbovaCX2y4/TD44TIXyLndirQ6Pc9QfK/EaMIYia54OK274cTH772ECZDPMNcrbtcylUOlxmBDdfOt8/vudw96cbkMbTr39+iS06BG11Bv9nscLWkSGtHGzt/vi+SEIVOCogLXm9IGIeYPY7fvyXnBmB83SRcB1JUknAhk5qc7jzohGYJ8MRT+Nucy1YIGVKU2C85Hj6GQ6ARoyuBRogqUBUvJCRJEJGLgdDSZaspaS/BoC4kRDW32qSMZLWEaOYaUEm/4IuKG7ooXGR8kscUt71Soxqo21SxqxNumxjm+7ZwzJBQJq5aq0oyBEBVIk9ypPghgEiCpPghAKYoDent+NmVsswJcUXU6M6QohyJFcqimjcVJZM0U0jRlH6XIiBTSdF+e/J9fQg36BwpKiBEI0j34hSk7q/Ue+qySVFNBrqwT+WYLiN5QgaLESPNRrhGxKiRonJcUevr6qE4XmifRUiNE5HiNPjH3hjy+8j/V4oB4mPAdfE2Xp6LwhfDFN49iat73/bUCzHnW5zLvif5/2faJNdQuy9SKqHko5zzWy7xbZaO5bIwN4ZpCTJUowzx37s4++yMCcSCxLU4uo38XkOG8LOB4odCFjvy+35yxqGx8mcLb+dxRQXEhsQQ8TbRGMQ+c/X28ZIAynVDv2fv8ZL7vuZ5yE1wTNlfGuMk9TtDGBUPBL9d/YbVGMzSd6ckK2dln1k3OdKWkAAExwel4o5qkzXk3mWHfv/OzUBXgsuYhM1AzfYbK5Q1pNk3NTHUl4wWV1SOphAVoCheKBcnUpOOU0ibPXKHE/ereMmlPjAl0rnHlGw/FZj84p6qoM1RhZR2souvXkaqVo6s286BZwGnKGMTyBAxqLU2tN8zykVQgXBM0RopQ54zCCpRUQIF7i4HSLUYQHT9klQkfi3Db7m4IkkFAtSvthaR5DonQbt23gWxJEvgFGjvKGF7Ns4oF58iQXKf09qdq8zkFCklNmxS3AlA/n2ayw4mul2OFaKquKGad1nOg6Okbmm/V0ktmnqfPV7UopwrfW17NWjuc5eGRogSuBZEaMrMIV/1m5dzq4ID6A89q3+lCZF0Dmjnu/81P/IMMZ2cQOEyFBse78CB43iWJke1ahC/HkuSIa2PkSpMZ3ZH8UL7v0lWM4OMemN2iRUM2h8AaJY5oOsJcYXIIXK0J0Qkixz5ff+bRnoA/ebtgFFcETPatRgiiQyFPtjfUoyevx+cowkrtN85mffXuR92ZU/U/O/8Psf78zELcSdFsUX8PiqNaZL252MqeT+nkG1fjimqJkWl36appEibeONucvz81r6/Sr/hpe8xrf+LMsVKidFS6dQnwg0OjDWB0CQVn0w7hRXjNx3HME0lKFPPRaY/fx6Kj4uhESMdjRApUF3khBiRYiK0q5ysK6bGnEqEcjOTJZiwBkSotsCttSghyiyUOjJckgM7ABm6Kq5rWR/zhT56NapQqXqDt2suckodfaIi/cwGMqPEDw3rbj+GsZoEgElSbB4v4CqRIjF7HCZEwhpEOOlBjgzt6gvZ5RTD0mCylFM7UklKAERXYpqiXHA1Jvuja5tSVqyh8VAYpbE9kFaNfHKGot9z6tDSs/m8fVxOJFpwuXOau74SppAitLhqkhCN+prw/ipZ9LrmfXaZ6xQp/S+iFi1MiCRMIUZTycNsNFJ0rXC1nR8vCZ4MET9UHyOC/J/V9YNS66PwdWF4nBD2rxZik0IZt8n78OVDkCGpzoHIUDUsO38Y0nkkv1eQoSmQyJAU23Cv4LLIkHbOtfYy90ogQzh+CJfRMxvISmeCcpMjQxKMcyCtMRQbYL/zYxiAuugJCugouxxvA+2jGvype5pfszARNL4vRDLE25JiJaX+pOdfiuPI3XMCcKyYGCOW+Z3clyn1koMfOz8fuThSUW3VCcBo0o6f0ykz+VP3kSagpPerh0KG/PfKOacnZ8gtYjt3okga7wVCj3uuGNPMtX/c4LJGvv8d183tl40pOhRq1nXKxSELx4C31RxjiyuS0RQihueuXjRNEQKgL2LJuFYWTIu/IyLEt9GdtOFT5OJCcsjN2h2YCFWpQzUucrSTukFJ7Qrti3FDQuDyaCyl12zu7ylMUYhy6bnx75dJhnLlihiyECtk43ai/HQofsgbwyiz3ODHVkCGoitcJEFSxjiccpuoSFs0ay6l1EZtkN/wvSDFCDknKxwptzlyYPlrMnKV43UlRYgTPv47Bn+P5cY+973qIbjiqX3h8pQ+tXeLlCTDGDnxAOv7IKaDFCukueoJaxFllaIMIcLIfud3ldK/a7iC8US0+4LnJIeJ6shcNQerJxJBuDS1iGPCWkw1pA67GmrH3JQiiqYQNTQ0NDQ0NDQ0NDTcs2iECOF5R18wdpEDSLvIAUTXNy95e3cSrAykUl9yNzm+je5Yd1DSeKZK83hG7qq5yUk4hDqkydqSOqS5AuVUD2n/nKtX6vdDuGJw10++PfV7KUrclvh9yI49zLrn3JEAqtSheF3p7yE2x1owjipUzpqgzjhrRu5uOVc5nFQBHHJ7G/Z9K7+bXnCJ4+8E54Ck2+bqh5ZBjjSqnFf/d+r9k1OHtLolz3XueZBc6LSxJ8aaRMn9B2N3uirXOanP3Lix21unPKfKu2vR1M0cOXVhyVgV5X5W3edopWlqTs1C04dAzdIGF4y57m3efU5TRqa6mS2OUle6yc2bcA6kYzTWwPOOvmDxfq8zruYTcQkIN0btmkLaWkL89/BTgghx9zzpQ04aK3ypTvmAc9cE5p7gmOvEePXraR+s2W5y0ppMJTEDU8HaF9caSvm087o1v+eu79RjzO2nGUtifMeCZEgci0aGCwxJze0q1UbJ2HyaaJxEAe1CDV4Y1c0RMxL/U/OYFRhuYkyStqhqqSFYcx41MqTFDvH9VLKbSWKikaKp90Du/hNIhhhXVNJWzftDeh5xX5wUSZMamBRpC4cL27Lv9pwrU42r0yGXCahZ5yiFy16jyI9B7PqSSAIeQw1REQhyLr4It3/ppIiXF+0iTf4aKYq452OICBHyyMULTfQhzmaQ0z6CYmP7/abOlKUu+5wVwSfGivhz45zLv4xLFCFcD8+Cz33RZ1Qngz9iNarQRaDmUZdS814EagxNzSCWjOpUlqjUfcLvGX+fhmtM+/bExvnMcmgbkDIKsvfbEunwcQwRAIyzzPG4IRxrhH5XY4icS689xGfCpdiXisxsBNL5Lbi2IomV2s3dy6PJHHQ80n5qIovMe2bCeEyOjM7pl49Bi9XBv/V9fJb6Pl6vYRi9t/G7nJdFTIkfQtvVtYhCvFR5/BDGQWOJPEpiig71Pk70PXn9KYBFVLziNYQq1g3KkZ8rE2OEkIuLGqUL9+UEpLZ+5vxVs8d6nXFPK0TPO/oC0NSEbAY5afaGZY3zGKlCAGq/WSWoRF6dM+vAyRByj0tm4JHKhcjOIuYyGEnnMjfjPwU1ZIj+kN4mHdPcrE0plJyHVJ1DEbmp6qBiUI+yd/nygZQhJ15nPGZUl5OhRNlI32elXXlc6A+8xhCMt+92KHAT8sPIGQ9TlJSS/ae4N5bUxW3X3AcFLmbZtgT1R1WKpvSbU3bxPjxNvf+762K9rovdCX1r7/XshFeNIV21SOwBzZ1DZJ3DmKpUzu72gN+hkv6lPqX7g6RozxOBXJ9LK0aay1qunG2Hk58SW3G/zVgzqn+vq0X3rEIUyBCArghl3Sz2v6NFK/XZJPwSE1wV1FnOxEucLxqmLSImvkByrjGDPPNG6mde+JkPUJEsXzobwusu/aHQ1KfQnWBEIYOBVRbbAABdJeB1pmDqLKM28zz31VFzjXLKECqLmeXECQzhmlWMlSg/OOPcvjys965z1uzScsNeMRIyznnSYhwth+57gYQgFYhkiCPl8RpEMDBCtI3PMckuJ6kT0tpDGNo9kYs7ypEAzViforyWjFFdkHqiOlQDQbERz/Uw5PstUT15v7hdgF38mL8mUiwZV2MK3zGq+iCtP4Tr5DwXJqbH1r5zRQpRrJz+XcNc8rSEGVdzXlLfoAXju2KTyv2Rg2I/lRIerKLMUY4khUdVe5S+i5WhHKQFaNnv96pSdE8qRM87/cLdTaApQlJsEDaouO8vJ0N8dj8XJ2TQ7x61SpD0N0D5y6OEDAU3muFilKDUCwCXcwrbXKTWBsD3TQmZTpEhvj330rbK/aYPNt3e1P2k41cJfgUJKe1fq5var9TdSqlDYn6EusNKNtqJse+fMbSJxJHg7Z0wTrypVgWRqtSSmSn9XMTs9lTXPQztmcopLxnFp2qmH983PDkH71cZQ1Qi0f5SW3g7n8hZob+lxAu4Pi7PvdYV7lrqpN3Me2xWLE3NN3KuekXsiInn/brEE9V4vSj2Tym54cpNrXIkrRuk/Zbrm/04/lt7Z3E7AddVFKTnnX5hcmyPV9xzCtHzTr+QzLyripA0m1bywsgZ8eLs5yGl/IKV2IXZF4dnAqfOXmUCbmldE8eSO4fSfod8aZfEl0n3kfr7gT8wpTNZh370cftLkjHNQLWy0UcMhSJVVnj2EWgChL0KZExQgYZ1NArxukReMQIAcH6CTiNWPv4npxIBgNlGRSHUR79bpAB5NciwmCCzVZ53Ze0haRyjerXQiKP0Xq6KtzT1iqgE7VglRURTYErVqwJySmK3pPtUctMZXNiOy7wOAMT7wLc9yMqMGNukfTNQXVEhyqlDuE5u/SGl30XWIgLIK0SpehoOmQyi5hkQxlEcT3QAhWjXrPT8zVOLprrG1RKqnBpUDUnhybVf63FiDfzMnVdMH+M1xD2lED3v9At3LzhOhrTYIJ9K25eBKgJqxjiPkjihTArnItavqSkSsCGE02cLmeRUJSj3YmWxVEk1iI9dmrmQzqEWJ3SZyGYdVMacK9fMKvt+8P8plMwsSippCaaqQTX7+XuxViGZOGvvtN/998ma4KaGzz+JD8qRIdLfvjC4WMaPHy4LpNtIxqrUjx8LNq41o9d3p31Il1T/NDIjjY0nfuC/zx2T9FzVzMaXTIpIk2/Ks0gW/t0jl52O1F3Jak5od9Xt/vl98Jg6pSyNf8m03UsY20spIaXk5SKVohRq3uO5cdTYHAthNqHANk7YNG3yRkrdjf+W6hc0mi5LXkNY7VGOBduoqi2m2Az3mlJ0zyhEz7/xRfIPkgFb88JUP2yCqkA+UBnFowalszU1/th9L7RVMOOfU4Vyx1d7Xi6CDJUoRJKriGYAzR3zlFigJTPnHOqVUXJepPtAcxfKGXKlffr2yPVG/awEwxSpRFgZGlbeMC24H7BK5FcdR4/rKNMc226QuoMVIKIGAQSDjWSj0xTimoQKuftEI4G5GKKsIr/QOyE3/qnPlOA2WTSGGpfGEiXKPxeF7Yb7SRuTFl+EY22F/YgJ4r87S2SXw5gYS1QW55qJabsqCpGE7D0ex5M0FafG+EzA5HgiDPRNn0u0FlN/cp5CWpxQzvVOe89WfMfvFaXonlCIAhmSFpAEoLNaJUpQaMN/rBFzT6lCqd8vcsYlQYZc3+fJkAQWV1VMhvi5E9tWjJ4lDB/p485nmoWXrrj4qqZu5MhQTqXhv5e6ahwaU5UjvP8UFUkaAwPJMOevpTW6iuD3MyYQH14OQKc/JlOwwV3NrWzogyROEOKAnDVB+XEGSDmOCdcXjlE7FjRzGMrOUTVIU1RQ/Wry7ZG7p1NjlsYklXMuezn1KIXc/Z1S7KWyhNz7v+Z9kFOV8DsaZ4tL7ZebYCCTBOh7muvHt8mvZc4oDN4LC6h+mYnPqxA7c3CUKEU5b49Rm4c1K0fxRDP7U1UiyaYT+ptNhkrHj9Ug5X0hxWmnkoVI97pUVgWFxxke9wrR8298kT5DI6hCRVniSBuI3AxuXFdThZYkP7UKESY8NaoQRkZRK0rXmXsRHFIVKrnthWtntAxXkkJUE6/Ct+XGp80KazOMSypE+F7PjQkDH9fUa1jgrlStDEmkR+0/Fp2/5l00HEmcEFGGBJWo4B0gqUBFKpGgDmmK0ehvvAZRJiYkqxJVQD0fmjokPWclmPP+uIjP5dxnK1WHAz/LKTVKUga1bG65+CL0nVHjUoZ+vE36Po3aKFjPR8ICcbIlXhNZXLRChDFHLZob31OJQ8QT7TYr9po8iPL+JoxFhEKC/PWoW9jeVt9vr7v976vqXzc8rhUiQoa0mXxl7aAAdeaOKT0+YE2LE5JUocsAnmHLrS808eMvkqHMLEuom5pRnaMK4RniqUaNNfJ5kj54JXEGOWWpVjmS9kuNK4eamW4+rpLx14L3za8F7w+Tr8GN66CxqGTIQnxL4sscZsAxETPBWHSdDWv7DJ0FH+sTFm4l98f+Hy/zemGb/DtRfgQEojggZWtfP7mvErS/JBlSwftNxRPhmEhc1jCH3Gj3+BKTNalYpVR/qeevS8wuj7wYzNjQxwlLQjtIcSLeF+Xvu/CtkMhQAv49XEWGNCxFQqaokByHjCHKoeLeHalFj4N4ogmDqCMzJfvmlGYBZYvZs2fVkyG+LVN+vCtFj1tC9PxbXyK7xPkXcdflpWBszHukXN5CnStChLg6JLgbqGs3THixq0kmcgvFah9o2nj1eALELEgZtxsO1eWlkAxphkyGLDkb67ou3r9aQHSSCJWQGn4MuevCUXhc2X6n9J0aj9S3RIYI6dHKdrSNpshGahBJdyyQIa0PAVJihlF73lDERAmnAOeGrhnvOyKQuP4EkLEo17FELRvvpKkLBS51UydHKp7dUbkGqe8KL0sJDrS6VtmPkyIAagz5v/cQswCWkCIMTopScGN14nHr3HLZpGgqMaq0cbDKMyW5wSJxO0uoPDUubyXb2HcvmxTBN8V/E20T4Xnm2wR7mZCiW1+ijuG643FJiJ5/35fuClwJgh0RMl0XWLX4MOeMeVUJwuVy97hi39waSK5yaFaEqEK5heww+DmV1DVJFdKQe6ktpQph5Awmfh3FF1mC9AxON5yUNpw15J/fhn+XyrPOj7+PpX8l++I2pkIjaiUEWTi/o3PD44fwb1BIhsh4dz9QcoLKnUUqEVKM9m5yQ6f0Z1g5pwIJMM5Rxcrv5/bjcqwuBlaNtBgigNG9xu9XqZz7O0mGJBVQ+j01iePVoprFVjWUKkJLqUUAZbPGvIx/RxMpqqok7SfWUUiR8E1QSZGWRt2a3fdJUo14exylKo848cmIXw1K1uS7TDe4qZDul8R5Kv3+u8GpRGjOwqdaf7NQoyL5vnNxRyUTwlLz6PyKse2kPUW5jQ2kJ2qdYr+gbcHGfpzhcUeInn/fl46ZrWC0q0qG9DBbQ8u7BpjRrOyXuNG1Gzq7gGkOEhkqWbOhxgddUtc0IimhxJCeY1CkjCOpXANpBkWbhdX29wY5NhSxYa8tnijcf+qaLamP/BKza1PaKCE9SyhDWp/4vGlkSMsAh9ccEn5XEy+shGPQCI+mHgnAKhEhVHj80i3OSVWJmiD2L49bWwRU/F3ro+bZ12JfcpMhWhslqFGEliBGmrKTTX9d8G6Qxp8iRakJiFw7OQTDseD7MBXa9VhKmanIaHelob4XKkgRALEF8Lo8HrxcQ4xElWgGKZpNynj/paoQgKoAkfggbMsKZbldm38v1bzDHsek6HGVVOH5D/w1cbv4oOJFqnLZzfiCVkZ+2Ef7KeMo8vlEyF4i/hBjQoRToe6DUqsJkfIyVGeFJGjnMtdfLUqIkISC60sSKviAej7jKrme1BgTeEYe7yccl+mHuMhij2dWB9oexqEe9zluh1MhzFxhF0NybZhhTmJoCLEQroNzMhkiiRLiJIgnQM6Y6CbXIUUEeTtKsUtEvSlIoGClBVt7ukirb5Ok397QWI3wW25hVl4mjSjnTyuXtiH9XgLV+E20IT2v2lg0LBiTqY6jZExTr4EWNK+4G5J4MumbMrD9hDp0MXB0bwpJgMZB/RMIx5IJFnKZP2vJ1lUmUIm4rexiu7hu5pthrAl1cu5xo7aWXLD1wFnz8LtIshGJvZi7j3BcEMcSEzMCXvfIyw/S7mXgcaMQeTJUvHBqyoBX62JjS5Fn7bhvrgRNUX2mKUXYgBFeECUv3SVUoZoZ/6kPLXeZWUQJqvSJryFDxH8fzYpKLz7lw4rjiJyW/W4J5GaPAORrXHLdc+eqZhZLA1EybJ4MAYiz6eo6RLiMOawdb3cWgmozSqwQ6uJxjNszLh6T0W5to7SNXOHcysb4IsGdsKhM3okV+9W2MRU1EyR8ckN7dpXyqK2lUDJTP2GGV60rbdfcVvcoUoqkvg45H5tTy9V32ePGLCpHzTHzezC33MZEQlHjTjciTDV9CrZRkVIkualKv+X2FVClAJF2Wb3ce0h7RnJldN01IeI64nGhEGEyBMAZtfbCLzDeSf1yo/9Q6xeol4o/vCWzaxIZ0oyinCoEkCSHxZhDhjzmSN7khdaNthuSxllJaqARE39vlhAXaTue+VFm6MgsbUoZqo2ZkLDEa2Pq7LvUhjGiOyEQ962O7quRIWFcuUVZAVhq7SOvIIK4GKsaCyTF+TCVyJMgaTFWAACzxUqSkH4bz9YDEKWIpN/OqUNzrhtua4riUYsSIs/rCPtoBGgUkwWwnDo7VyUrQWps+LfM4qxGu2e0hX5xCm5fJ/P92jWdcUvTDMgFFm5NomAiqwoXoRThsdX2p3yL1HTqODnGxG+1phYtnYo79FNrK2Jox5jxItrV2febUn1yyL1b59yXbN/XPfxvp7V1hXDtp0Ke/8BfGykWIhnKLZxKlA72kZTIkLDfQZIj5KBJxUoQcRH/rVWFliBDNZACqZNB04NcxpCMaQTxRVXSBiqrZEgjVPge82qQNawOUpeWxkUpTbnU+DXj432EtcEsNVrxJVSMGK8kqWTIxvZJXMwKkzDBqGbZ4nwskBoTpBC3mCobjdGBnEIbPxrsvAWiyNNxC/E/BNJ5066hpgLl4lq0/WohvfcWfEcVrWE1BQXtagsJ5xYY1mLhYgVBdc89nzniiQ0z5NpLvktkXOP3ofoNK0mOUBJHNRXXiQxp56o0BtUD3we5JEsA5HpOzRJXlYihJtECsg0WyWAHoNuYCEUps6e+X2Mn4zYLIcfe29H2x4NSdK0Vohc84cuQwaPcVDXsXp2xV1ynyK4XQ4QcJgBhI3tx9jIB8DNwxpi4CKu18ou3RhVChuEsIyM3mzElPkgiQCWucCWxQ2Fb/iObJUOdrZtBVmZi1RnaWoUodz/PCUIv7SPVj3AOSfwQvg7EtbDswxCMRQtRodEyy61j+3hh1uEIq0d4jL4NsevEwqvC9sGF+lQlQh93HG+EFSC+OCtWivw7QbufamDMfEVxiTZ8Ox6VbpwlpMfgyRoJCz83VUQM38u4udL3hKRAI9KUjSMCEGNaAQAcWQxYuvfG37HFoC4wW9nPREKEF9ZUx7U0DhHTNFEtWiSRQQlyapFG1uYoRAVQbUcxG6Nir9ViIiHKt2vgP7/z/zNhQFcD11shShnhpUqQxKpzahLu5jJUoRlQlQ5MgPZGv+lsJANdh8gAOy+hjQXOQ60hkVKFcmQI7y9d/6J7xdA2hHGKrly4zAmV4KdbPSMbOndpI0dCyf1cc8+XKDnazHNqBgxtUzPtIaKZIkNk5tzXw7cKyzzn3dZ2C7C6MAZPPnBfg7D+0EgNQs2H35jyEysIkyKofZx+m8YbsQVYO4PqKfeFROTnzFLWtpG6d0rramPi7w7t3oNy4uFSx88Nw5JFZBPP6yjWzGbKAOIXX1WK+PnAKg8GegaljJlREWLukcgFmHyXCr65U5BMU8zHyreXoIJYFcUV16QD5+/5HKaSvdSYlHNX5WaPgb/hS60XJKW/rhnHQihKmZ0jSpqtcMjx5XBR5PZAuJYK0Que8GXpCjlFp0QJwqh5KWOjeKlZTYSiLC7KzJrkg41npwwy7opeXDUEqCS7HIZRPr64PQmpF5fm2heMGPm+qYodYoaASob4fnw7Br6f/IfMGNkv3zmkHrBzsRQZKm0v9Yzk6lS0PSJDYTYNEaYVu/YSGeKuafi8C/3imCESS4SUod6XLXJtWgHgxAqejDgT1y0S1SAAGje0LxsX2zMooxwMaF90XxiuDAmqkeEGlr/XsBo8FUu0kYJ03VJj8eD1/fWqNAyKFJea2IISklZrC9UoRfhvFn+mZpyTlLJMHNEuthV900if4+9YjenCv9dZRebASpFmP+hxwpkxaC6HOcw1oktisiS1CNsiPc12GX9Q2j501jcA3WWuYn3J0a7Y1sqRnV2l9O8p5O4XoZ2i8ZVgf16uo1J07RSiERnSFsBSZpfkWUTFz7R2hqrE0DsEJi5IRmaoxFXLC1S2Ekw1fpYiQyVxThoZwoaxtWNjIBV7lisLZMj7++N/yTYw+NgUA28RHJIM4d88keT//DA0ZYhllgsGIJtJU8lQpuw6RGS6eI+4VSQ1gy/715NzOzIkjJ0b3SQ1d5iZh1GmuZBlzgBzWcKNUUMcZ5oDSTWSjr2zZc+89p6ozcI0B6X3eWVChaKu55Ah6bdDkCFhn5FCiNtP/VYyMQgwdr0MqtFA2yhwYeYxu1pG19Qsd3J2fg4ZKkDK2CwylHOoVYvmYI5a5LdZU7ee0MJqzUViEtHw92XNPTBRRap1j0vZhFnh4griWhGicIL5qsDWyIY7f3FLSkBG/eCydvhba5v/dhmQgqHZByUcR9dFMoQXpu3GWdZG5Rw0V5ASgiTO4KVcSypnk7RYKClBhjGyjF1r9IdzbqmiJM1Eo2HTIH10XfB1rnWL01Cy78JkSFqcE8cDaYt3qql+VaOKkY5wPbR25Nk64nqH7UbsJidklhtWchv6AqdosHjoklFR8EylguirDGztfTCnvHR72YQQM8nQIb+cWrbIpY1c/Pqo/WZpRGOi8lWW7Cc9O6+5oImTfayONq5ZCsrEdopc+64SNEMb20UFY68mRRlihNtbLElCJUQCyLfNTXCglUvSaGf6GKHmnQ3XjxRd0SdsjBc88St2Bf6AaBeDzzD7fSU1ibenkKFR27x8leCPo+v0Dwlx/xLcwmqVIAztwzhVLZqyX0718/eGG/QP5cSy62xMpIA/GIqLnGqQ5owWPxuIVQ/ex9L3a4myk9qukCEfgxAWMGVlDJUMaQkuWPzQiAxp54krUhqRwS5znSGubeAQGUIqD4kdwsSKHSuevSfrDg2OrHsEBtW1yDg1JrrodTa24e9LTU3y+0rlOYoxR0o9KlGcckpU6Tj5PeA383Ni2f8IyXgcPKYcUin0+ZjmTJiXkKLCyYZsUgVrmGqkuEoB6N+sqS5Lyv11EFK0kKpUFVc0VXlYEjm1iKgV+DscbbFq4lJAinybqhJVCin+uMAuKVJd+LnLqIiaIlrV51RUnsNgu18DXAtCNCJD/mGSXnLKRy1rHGvqAKCba45xKRI0VpbaXerGtgZgvffX6bpYxupaZ+UsajXjSb0klshEp4ET3VzSB2JEd2hz5ljJrFfeyC8xJojioJSpIb4/NmVWNakWLKEAzcmURY47qmROUMyKFCXV6MSGk9/PUjdErgxJ/SKQRVcLCR7A3r3Oh3hpi7hqj4RRymRg8f8wrgGoa5w/NO66pMQeOE01y5HG2vcbyeColKf2oygDatye4mqUVM9qSFENUgrW0tBIkXZeaxVbsTKaxMFJFWonvnJqYQHRLiZFtQRCcL3TXeLkcVa50BW8wwgOkcWuRAlSv4mRFBVleZsITTnCxGlpFBGUrpv9vlA9mkrHkGg7uY17XbFrdl1I0bUgRAGpGb4UEcrFj9TOGNWghvRoH/m50FQh/NHQDNKa8dSu7rw0NPWQ3zcCGRq5yEmzWiXkhhihqCxsd8ZEwxNl/Co61/5jyxQRogpgGLOMy00tWRLuc6KeVTwTrrMJsrlvb+Bq2X5f/qEuMfjxYfnNg2Nr/uw/4n2MxTEupt/WFmP17TmDytgwtYhEWRMVHqz84Dp43Iri48mQM3Q7oHgo6dztdi4wlJciTjWEqnbtopL32QLPyYhYlMYQTWl/ia94SinSSJGQPMgp2wGAxhGFdmLH4rfXmPQSE34smlqYgzQJmgpsX4AUJccijL06rqjGbhiG5YlRYaxKcr1IgIOTIkk5unDXuqXUPgDVPtZUpCXaph0xW3tibPtl4sqP9gVP/uu7AjeE1I+vHZcL3CZUv90liclUCCx/NMsivTxKDA3b7f75/XIuhWw8AYdOt1j7opIUQ3ysKI24qgrxDyN2/ZDqVxiBxbPIguGjpkiWtvtZ7xojr3Q8qd+149bc+UqJuGS08DTbsDPmY/pstCgrJp7seAg5YeVQp5MJg0PxQSR+yKFtiNQQVzncPrrGIYYIJ1PAyg/OPie5VZE0x4i8OXrcJLECQJ4ULf0+nEOOeDupcmo/Zd8i4iHZNKkEJ3Nc5sTYynxzRVBIkTMmTijgc5Vbf40kT2ATRB54LSIycYQOSnGvqkLq2yaRj6XSGLPviRgrpd0PCa8V3OZsHCI2iZMs5bsqLvauQbv2itvcha1vpGBepraC+y913/j/CwjS5HFWPofBlr/CuNKE6AVP/uu7B0lzh7NIYkxlmwv15QtfRYQmBqpVIzH7E25mlvnJrFaUDKF9xLJVYoikGz1181/mi0dyg8D3S/gNJyMocJFTU6dmDHVeFjDHpUaayScztKk03iV9TX45Ks8LNqxqiGRqLNg4k8iQdh35LczIULYskSHnAhkyg4uxQmQ/VMZGJ3GDRMMiBjDajr/7Ye0jVN8AjV2SkDA6iu7LJUhRwfXGip6TnsVa4lTYJ+m3hAyV/s77zbl61WIpUsQUTdFVFyA+VyUK9Yz3HYGmGNQYZtp+JYpMKTK2QPVKJ7mxLbwGzSLIKR8l6xRpuEqk6NCKUgkpkmLBFfdQjEXc6RKTC9LfV50UXbGnKCKQIQ/DXoYVyREwithxzhDTyjg9ovQP18mVJSjjGh0Hfki8EiL983UzMwqLyZ5LvzxShgS/X4R6IhniLnIVhlZp7BAOfBdnfFNki2PJF37pS7GUaJWSoRLDFj8b/DqgrH2i0QZM6eBj0w4bPQ+OxaOExAQdSrO9T6YQXOeGmGabKD5AzwfvfwhkK5IpM7ioHqE1vcwQDXec4hucnnABpwmPnaIy+2107kKbM0mRsj9XJ3A5rOVUUCZjrHimRm2Uvv4UhUWfkCokRcL+aqKHJTBawDgWVVK0XwA5PCdYHcqsP7Srzl1tMxNSozo2/U9Dzbch1JtwsksIQK2KlehjyrgWR0nmuX2dYMMMjhx70XpAU6Gd79p76MAIqeX9BLhkp1VkTj44+PiuESm6soRI/IikbsxKJagofXZoj83ATFWGStqQ2sNGIJstHb24kcQuuYRp6Ui11KTybExlrJCm2lQrAwUGBDGk0f2iuR/wF3TNeCaQIYC9sWSFugkjMfRTkCJ6NJY55zyHgv20tNlk31xAPQAiReiYsGqjXL/ROdPIkHJPUdVNHv8gkIZhjX7HKbetvB+PIcqBZJwj5ZyLlR7npSaLWIoU5e5vjQxpsVhqjBY+r/I9oqpBJVBJTixm1RWAsqQSNahVipR3CPCFjJVFiKVvlxojiKGRodo41KUM42wdo5+rpTFHxbqkjHiLQbi2yXWKpl5/7RwvSHyqlUABVcpNSfxOiWuir1faV851z5fnTKBdEIxb4qotjBc85W/QDambtMRwyBm00iKWof0rwhmHIY6l79Wxu2EIx+tQ9h5c1qB+mJyQQnU0PrQdxzhIRIEnHNDKNRipFpUzfyVkSHGXI+m1PRT/emJ4aeQGQzBuTY9igvjsq6+jrSh/EZDODd4+Mi6E+4XfO7l+yLlH2zXjDRQyxPqlBCH2GwiLBRiCOhWTKQxHiPSs8ThlMoYzA1qUjdieo+1bVN74bApxX+McAHKZw23SlMhuvA2A7Ss/86pLXtE6MvL1DAqXczoxqXkNL2njaf3WvLPQeNSFW0ugEVcPi/oqPV/SxGAK6L4g98IW3bSI7JjNFm3396wrI0S5785S6jjuB7UZxsVJQ0miBPI+Uly0a4ldbpwYtUTnUHaONg7lHMZzLt8HtS5wB1WYAObZn6nkHX6zth4kqZQ5Fi01ec2aYak+S5Undoz/+e0vLdvvAnFFrP2IFzzlbxTNkIh/+138B5YrKLGCbPRqLmx834soE6XDUD/R4O5mWdY4u4sj2u+DVRBVEVsa0iy7dr6NBZLQAcf5SGMsKhe6GuTIEFGO0KwKd9nCZZxdSeoHY8aTR0mVoorwcy+5AWqYc1/UXi8rHIsxZVkPUXvEDXEPTTEC0JUhEickkSG2r6RiuM6A2dt7OJnC0BmaUS4QLFmB0QgNKSvr0ajqEemAE1PUpnS9BsUQx3W0bRkyxMvaWlxFsOj/kjII2/lvc97p+J6USHzqHvcTWtYSt0ARQ0EZo+CaAHAVLr6jyWTDar8dpdM2PZrEw0kVhiEe15xJuKVcgObEEpUQiTkqjEaahHGOMuVd1mRuyfEq318xyQJzoTtoJrgSLxQcYrAUlHtc1Stq4+Yqlp2pbie5j97mSPi4ArhSCtELnvpV8g+FN17RC6yErdfue1EovVS1L2AnzYpVfpw0qAaUcr4zC62l+zqgKpSo77RsSxpZqUz5TLMy+dl9dJ7w7CyeweUzQCWz03gMS683BEDd3qT9aqGcV0cmEASiGMajGOSkj1jUFmPtj727UFSP+uNYF7vMaesJ4Rn3boPUoJxKBABmKxMmLRPdSOnRZv6DEqmQMAxlTSMNi6hBtcATFzX7TEXBAqrq+cTN5BShEhQQvGTsFCbc+H7Zoh+QIkTUIfyO2sbtzrcz53tzaKWILyCrKoE4M97YZVCd7S8JA9DOj3LsrkTFIn0t9NDNsD1EpQhgllqUVYisOez6iJCwS0tixTFZJPaEQnBy52Qp+4r3q+6TP6dXSSm6cgoRAOjMnKFKCdJmxktmUkpm1Uv2TcxwF5dTx0RUDUXtKp05UoNXM+MgY+jivriNTlCCMEpmIlJZBeeQIYD4kuZGu6AAjdbdCO2Xzb6G/SrvL6J+rKhKSMbG++Fl7Z4sqVNQFhdcnZtgQRgLTxtN0mz7OjPJEBkrapek2fbb1nQxVq/YOAtEJZKyzhkX2zQ92o5SbpveoVTcLqo7PF2zP1XMwCAKWVFMIKqeU4lqyZCm2Ey5H0ruaz5eqVyyb0m/2DCW1hyzVFnUyqK6BVD3BZdsIf4M+fZWdvzd8BMAnQG3jgt4hzJAXPDbOXBYNfLvAeT67ZaKX1nCkE25o/HvZc7AVb6vzrl8XIk2U59TilLfvalJnC4apYknQjF93Yvd5S4q2UAt+PnIrccFkFd8SpdWyY5Naz9xLiXPr0tMViHhyozmBU/9qiIJL2TcQGRIRMnM+xKqUMlHVavX2bqyFpjL+1oiAUQKomFtadmiLHZe7l6tYqIHdRX5glTgGrli98skMiS1pRn7khudMI5Q39eZE/isBWpPQckzUkPKUdlZIwdWF51XW1dW1tA5BBkyLrZrHE6zjQ3LuBtNlBDLg1pHGXPBN3tEhvx2dbYVxZlp5BJPBNSQIoYi17gS5XRquZZEJY6FoOS+xW5mmDzgRAVruQ5xS8Pnp1POYQ4D5I+Lt6ckW9DGjCdonJYcYo6rnITSYPGp4BOJJTaF9s1R+8h8Q7gbWTf+xmZJUao8FyUEN+elkCJFBS50k93pFrx3ZqWzztWvIUW8TPrJqE2lkL7n/j0qLevCCZk1umfYJeBKEKJAhjIodonLvvBnqELa7GHth7TGV1UaAx+Pto3/C23LL+7kmgDajEJJVpwu8aLT+qtofxIZAhi/lP158j7v/CF3u5l5QoakfmrJxlys4oxt+FAaQzI+jUhKyiiU7pkUJKLIY1G07HGKsVxUTi0oioz9EFPDDKdaZchZEwjt0NmdarM3Es0QEyjs1iTyOzmRAJFYJAugrTlUEksEPVJ92DpGlIDQYxGzI/JYIWJAoaYL7w01JTZXg/z/c56LWuKj3fu5eujYiu5ThSwlZ+0rxlGVGlwiwavYn+ssW3+LKVer+A5RSZFXigCiUuSPC/zuC77/QvsT2yyNIyohRSUoMWw15CYQ0Ttu1sKbh8KcKI0CtShJiqYkA5iAonN+URn+SmKFcmnrp563ErJ1hUjRlSBE+OH14OVZShDpSznkEmNWK3foRYTLoU9WzhEgo9y0Fn0Mcbn0WOZAU26kZA/ACBD6IBqrbJcUIzzzhftVziFXD5MkMLSpnKsCJaP2PBfFXqg74/tNNrSI6xxzS3SYMHnDxybKuTFohMYq57tk30oClCRDUl/suLSkCZoaIyVTcCg2aFDKdMwF/Vi5vrpeUgE0UrQbR/56aMZ3dbpq6fU7591bdE/WKY7F+2gpv5UU1SUqkNpOUbwjpCERUN4nGtewtiFrIgDAcNRly2pWx5L7ZE6s6hIoNfpKjkvZPksx0J5h7ducInYXCelalsRhaaglRZUKSMoOzZW1dlTMIUW1JKVk8rlkXzKGgnZKXBSviNvipSdVeMF7/c3dQLyBUZAeepKRX0KEavs4xEXE/dYGlJaksNaCLaXECr59f5xSau3R8CvJmNYvRm2/qb4PnUgBk1ppP2OiYTLjXKkpkvuEUVGZ8neUlCE3vBIypCWaKHretO0KGdK28/580aEyhkHZ4VbYQIzlHpdxMgWyFpE8fKwGWRSH3p3HH+yZk7ejgHacWIGrRKFOKrFCyf2lZrVTgrslg30A1ThX319SuQDVhK0U2r04p785absLkjfQ2CPh2TBI/RkcudfNEBddNf0Q49e2+B5FCRXubmL5PJYBld0Wp+RGiQvmmCRzEizUpLUO9ZRnQ7oPrAXVO0JweSPtFKV3zydeOJi5V5Jee0Y7RbaBprT5c+uGIhKRW7akdjmTJApcLItStc+xRWvX/sJIHXsuCYOwtMZ/fuu/yo/lgLhUhegF7/U3R+rPYmSoxE+2lgxNcWcrLXM1A/+eq+MVkwKXJFUxEa5BWB0Z9wMAprO0ji9jN4+u011BJJTcA6UkrIQMlUAjNdp5xpDcUnjdDEEZuRgRYoHalTLb8fuB7y/dU+zceaMHu1alygFzyBAx2pSycg+XkKHxOQWljPfx44/pvXeptXflAZXdCsD67STlNoQyHoMzJi7O6mJs0c7lbv9c9VGJItuHmFgh5TKHwdU2VU3TFmLNoDpWSJtwKJm4KBgDgUX/p8q5ep3yzChubqXPD1nPTEtmsC87Y2jabsWtUQS7B0JZUbMAAAasHB0rStcRcpM7vqIuc26IhjMvK+2o4+TGO772WvdS7JRmOKa+4VJfBcbylXOfK0SRTaDFqfDf+X5KP3PUoUkoybhXi5J3Z23IhtpX4sWDvX58dcGO9ALJZeFSCVEV+UkZuhglGdVKyAdp09ALKvpgKh/J0rKE2pt5QagysBILZIhRLn8ARVKEzoOx9AGJ+ynnnNdL3R/SfZB60QjtqjE4tSiJPZ3zoi29JwrOnRbkrwb/L0GGNEMU78uMwFIyRKCdJsGQpecqFokbm1ImSRMEwjmqQ8pyvzx+KO6gk6GpUMkJO67qWCErP0vZ9XZSY82NoYRwl9ZLGax7ECKxzrucDYhUDIRgFCRdyJEi/N5xTnWV4+84EoPoMyquI/lz6y5mUTxahXvQHa+CYedWXUy9bW1QhIwxy6lDHiXvP+Kelw9OL47FKSHsWkIJrR3VqB+7QWvJBw4aV3RgdcijihTx8nUBTnQzDPH5KclQyFEw6SneNyl7V33nMTKqZEKUruHBCOYEXNod88Knf3W6QuWsIACUKQAl5IO0mahfQmjmkKTcTSwZ5bXKlWTs+Hb3/4y14d+o366LBAiXNWJKXt4KYSXDphkFxVTrc8gJPm4A9eEXg88L9y3qVyMJwIw8KYuaBRLoPFoLqRN+S91rJXWksmo4m7xixg1NrX3hmVPJkIFgcCTJELvfw77CseD7gMQJqfFDsRmV3JCMcGg7dpXCLmy9C6qSGZyeTc+g/9FmbeFNZ9j+mgqpEY2cmoKuH1loNJFiOo5NJly8TMZVoujwd5SmameSHTiL3CqZ8kYW+8VlJdZoUMp0IdT8ZID6dXdudz0H2CXQ6Gx8TtD4fAxRuAYrpGgZI8cXOReUItM7gKP1vjzERAvDEL4TrmduTLn3Zsm7XiMZtckLhHay6aw1pFyg/LhSRK4k46r6LTqwWlRy/BjI0CflAqhkLjFpKtZV2j44Kr1l1NTbc93lptjXU+uPdk/vn+UGB8SlEKLFydCcrHFaH2SmhY1HMwy1vnJkpoT8lIx5LvDHXnM5xOrPaqWU5RSstIzqa657ykekOk4J4OIyunBo6Y+16gpJcJpxqhlM/HnQrkNl4oMqYg2gE8wUGapoP0mGAPYZs/w9bQg5IIkkCGGQx0PdwXAdEOsUKUYFypBTzg/pSyNFCgnjiTOI4V1CiiRizsvEaFeSCGj3r5awQFH86H0Qi5p7HiEmzD1MVEt4GV8fjcys5T5KkhP0x0odkpihkhThR0gi4QOanWbACw6TSQEl6QJ2n/OkCABI9jl9iYWCd/pFGK9q19q5zpeTWVzFzhTyU3LuZiQWmI2SpAlauQBFatEc968S8Gtcci+ktpVicFCyOG8WtTYr3zcVI5Q531eVFF0KIRrNyAoztMWYowp58IdXMuK0GyZFZkrGM4epL4nKF7vqFqetLzRHPZlTZ8r+h74+yi1bFEuDUXqOCghK9f2dmgyQ+iJkhRnQvB3lneDVAGcMnYVHHyNnKBkajWXfXpzpRvVRmR9L6MtBVGf66HZkehrzE+N8IqExzpGU276voTOAY428MjSsUJwSXuh1ZWMdfIycFInXBwgh3CkbZnS+kqQIT5po9wNSGV24NviaoXZL7ius+PDnwQp1Rscd2yTXni2ESv4W7otRORwPci0z2NUS4r1nUftaLNFILYvXxl+nYWXFezxJisj7ZPeHcS6QVuMQsXOOEB3ctrO7mLdhtfsHZpdcZDiyu/2Ouh0x6h0MR6ud29+2B7degVuvdu5xq273r++jC7aWYU67H6S/w/EJ22vVIa2d0LXWd8YQTkFZR0yF6iqmve8vx9w7FK4cKeJ/z7kXGEQinSJFU22Vku89AIxc5PjYfLlWkZzKAxbChWeZe+Ezvma5xlKSo+Cio6LEYNTqp/rVyiWQ9k1tx78BJNwGMm1pZWvjLI61cTtyt4DO5tvhY/NtGhN9yXFfqXFOQUoRscLDT4wb/lLIvGxZ3ahUsDrI4M9OUaAMXSRLGDpfRosp4X+n7hE/1tJyWIkeldkq75qigdtxyFjz9Q2OdxjQvrz9UAdlyHJArs0odXXu2HC7AMiIjQaks7HOzlCM+wUCZIEY4jiznZ+hN70LZbuFECdkNw6MfzS2Lmw3Wxdm+s3gYowIm/33x2wGdowY2AZFmQrJPtuB3Hvh+gxDvG7DENdl6tF16KPxDcMQM5ahxBC8HPodBvna9E4mQPi+cKhNx+6Rbnyv8b9Nj8aqlVEf5H5zjh7nKo47nKPtoJbDAsDbmDDD9C7cOzjDG7lm/L0gnRcA4mYblC0TladIwOL5i6Q/9mF7F+4fe97H+/OsB+Njhc62MW5os43ZMLfbGBvBY4lq3vH8fi7JPubrlBjKiVn4UhNKdfXSDMrwDbJxu5CZa7S972ObQ0/reKBzvYgJyBUeqc0DeWn48Rtjqo4F1y8y1rkNdAjwcUjqYoE7pG6j2vg8aGV1bKy+hCmTCAm77qff/JL0mBbG9Zsy4L7eGClGKwHX4S5y0r4l20sZdg61Y5iCkrFqvvQ4NoXHqUy+Bgtd1ylYKnZIgb4AKG4n28zFPLHacWplolLIs2JZMgRA13hRCInuAoXqr+SPhEqGEmWJDPE+cB2cWrsoOYJTyngBVmwnWq0snyO6ppGiAAHQ81QSt1Kyvg4uExcwnDhASTqgLfipuItqs7GaOxu9flwNqTs2td21cr5L1iwiZeV+VI5BVYq0d1AiRTt2reOLtXoMuHwkX3OSdW6tuFoTN7DKd/ycb0Jp2uFDxJ6U9I0NVe1bQ+4v/Lx02ToHiZ25wFl+Nba4ct8i1MZLzcXcxAoSeBY+Te3J7bskLvB+SeFCCdFsdSh1I855gfKXjHTTcYMJG+gZFKddFcpqH7kx5pIrlJChDs1McQKESUyOPBlDy1pqaDJ+oR2tXANNeRpQGW030na8L4D8UWP3C4kfGlAdn5HJGDn7XIIMFi9MmiNy+GOvffi1OgWEkQTKa2SIE0NcX7jXeBB7aMfScqhj2XlgwftSmZ5HiCm3V/G+cF0kL8PagO3jvtGtzQRD07FbNvyNXfEGoO53a7+9QN2TFBNWThLDexUJglhS1rMu7rehhARDZ4u+Ad4d0lkTyVWHysYk4p2Ea8+fyXA/W3Rv2/AeGlYWhpWNGeRYm5Rs+vvVBTJrtkNMsLDpQ/yQ2fYxjrHvY6zo4OoMMm6c+eNLrcfjf+PPT2kchvKezBnkSfcuKakCeVdR8pJNMsTbkkiRG+rcmaRECPhvCUoa6YtA7hxVk8BDKkI5W1JLrACQv3dIX4XHkEtfrmGqOpTAoh5lBbgeClHK+C1VIbT6Ba5OqjqBjDOPkUFW8NFUP6Ya5s4SzJn1VxckVcozVJVD+eMS1L4Ya0gR72pq2sxEmRIJxSBKtVVp+BWpQdo4NDJUFJRfMOuvBr3jslXVHTr7TsmQWEbgREeso+1rlDI5hrh9UGbnyZhVFU5/P4WkE7A/xyiuJdZBEyCdif3gMpsACa6FXXTNcl28Dm5lY/xNF8vDCmc4s/J7mE+8SPeVLYjv8cdfS4SUbHIk2cBavl9xNkK8yC9Z8FdLWqAkbNBIkaa+au8C/h0qUkq1/QveYzRRjp1eLsGcxVsB1Huheq2a3KQlADk2bZkLtUzez4pSVEOKAMbE5rKSFRXgQtYOWgq1Y+KkqDb+DEO6H7CbJi5r9ZfGRapwCBcWQzSZ6c1VhXwdzSeZX9ASsoBQRGByY/Pjk6poN3rqsh16IS/FwFKblGKGAOg4e+TrrsUMpDLXhFnGzAtaImsGGUKMAMvr0BSQixSBsWi7J9V4O99fgosxI0aZiSOxBH4fqayB+6tr14TEa+CPMIz3ZWV1YVBN0bDsXIrbUf3UOkQaVNKDDFhkkPbHcXt/hOug7Wt8bLjRWLRbHJcBQWGym+i6ZM9RvMZmQPWRi92AY2Bo4odwTXpHzg2JU0HxO6YfQlt2O8S2toMa+4NjiPx5MihmZxe/I+zLx4rGQ8bgt+P4KFb2xIPH95B+hTgm8Xgy5V0MnX93oT6cCyrPaBz42dDeodhtEntN4XghdM+YTfStxDFF6rpnmJyRbHf0m9ujv8l5wvfueeyku7uN5cfOY/3bZ7F8N26HzSa2388wsN0Q32splUjDnG+50q5zrowQ4fWCJEJkmQKkvYv992QYQn1yTnFMUS/HF41Mwimk5xAxRNVJKmb0d5mTrso4VAWwNI4oF/eDv/dzygKqFSJmz11ULNHF0bApLk5TVKFKQlO7b7WaUzueQ81eFBn0eZVHS0M7+1yHGV9KSFS3O1yHZ7yrcbFLjXsKgaipX3sPK9BmfMdr71ReI+3lqsVrqOl+C9SjAsKkKkCVs9ejeiM3u70hYVAZk6GVCdfXdZHIOGvAbmM7PvZnQO5zI7KF/qbHgbcrdbBBS1SjvFLhWBYx7TctjXTJgqMkdTSuo6WUxjEnBamstfV6yLFo6/4o52XUB25LWXdKi/fRz51+j0oZ8MDGBVHBxHb5WkDq4qo4s5+vjlzmdoOihBpjNLHi+8D3Lj4fyphIym2c+r/LqxfVs9K15EZVa6z+dyq7lq9SQ4Z2O4jbSTsFS18YXNaUIrJuoJHPwVRScRVUmNrMuVeFBCkoWtBXQ8G9uliZdz2VDPnyBapFF6IQvfCZXxf/KHnAUkRIQ+0NWCnpVytBXP3JKVUcTvlATVGJ5pBB3GSJn6oyhqJjqM2SV7I9BS1duEIAiwKUyUtCcVOxid80kqCeJ1QdP1vMiDEl51xDyb3Bjy+UE+cg07625oy6no6qPCnjLAXaRVuMFc+iY5UIlzGxIXBsth3N+nfnqHyGFKQNerZwtrGC1+vIddMpv/Xa86s1jKqUXBetGSVLYu0Y1Pc3JpuF94Pm7lpyX9L7WB7fSH3CzeLrwxbo9cBqIVGKtPcu6psksFDc9Xb15O8yVie7s9h391hUfuxtpBTdiUoRnCN1aBuVpSJoKhC5h5UsaxilZEhDLotdqj/eRycTLkJqSpJPKOegRC2idWaqOkvFEV2SC9UkLEmGlONWCbJq1yqE6AIwixAh/PQffO9CI9Jx8LuMkKESXCcyxJUKXJbGl1I5DjGjkupDmfHXZ+ELiEGiHHz4kT+/uo8xNPGCH4dF2/mx8fMqnU++T0gpbkAkCaYwqYIHv69wwgQPlCQAKxCjtUIqoRIejoXIEFFPeNKEcEwFZKg0UYL/EymIDif3QGNwq1ifKD6+Hd9WQdlZIGMKAebWoOBzmmTBG4i4DIaSFW1hV0JOBrmskgGidAEp4/TfXk0K6xCF2B9ACgUKmh89v/G64xifUGdtA7F3axuI47BGyQT4mj94nRuf9rmTx7B73tE7AZele2mF7o0u3g9ScgMxsQ06L/63bBldU32h37iZxBOtaJvhehn2G1YFNaVI+tbhMeCECp0JJHjodmtdhbWvOjNSjgB2ZC0QuS1yEdwMQf0zmz6OabMF59WhYYhK0TCE+JdJiQO8wccn1UoMwbkxRSUpiDUFhtcP355KMqR9D9k+olqEz9PAXPzmEBH+fZna1nUiQ3PBvVoEjJ4BySW0kgyVPHM15cnJKxKo5hITcPF3WkquzKVcrvlN7V828CaRoVy5tn7JGFJ9aS8yXvZGw6oLv7lVRwObrRlth66jDys2fHNlfhwatA9e5XVLtqv1UYJaQoGhPW3a9oL2eWpcbR9XQuhGjSv3Iy6XpMROkSFfp8QFDm8nrkyKi5OSfGC3j6kra8pdAQxRORDBwkazBYiLs6IMdStUXptYh7tsheeVr33E+ghl/u5AvynXnQT14yQAx4o7HCr3xzZbJskEyHbZxU5NU624DGrKUJU7JSJMg0QSFQLjMKkyzDVOuF67NaxkkqSRIuq2Jp8n7ZkrVVG1NPF0bTl1dzQm7PaFDHYlZkINik+pLdL2UlKUUoek75KWjpgTIW28ynaVDGneDbi8kl3rVBc6zUVvSUJyKLe0pcpLjklDiZte7XkqjZPLoOSZK01WkSRD2m+XTH4vr/eSm2IuEfIvI/wPgxuIqN1RBqbavvmMzSHBx6S9zIghKxsQRaQKH5dWltrj/ft9PBn2//B237eWtltSj3w9vA/ejscpzqjoxlIVNCJQsj0MwKlERnQtMoa60e0Jk+GumiX3pNBvidubs7ZSPULddBakuB01a5wSO0P3BVJfVCaUMn9vhNlwF4/fbnFigEi+8PpBQUGy1JAMx+7iOI1zcT0jRxMyDDhpAzK2ieqDsrppx0eMar4/VoxWcZ8AdR2d2EaIc8EEwcb4md0CtrEclaZI6AacqnodM84RpUm5RyQCTxShzgBRARlxDH8bIH2RfvH+vtzF+wVnxiOL9HZAFStFlQI0Bg5OinBK+LB93YljwYQMtIQYiTgio9hb9DlD94UQR2T6IRr4uLwfX/hfKkOCFGkppj1q3dg0G4KXpX1TWGItl5LJwxJSpKwFNZsUpYze0vZytuEMG+RgpKgEkm1VcE6KEytgu8ENwNOsq23e4zgoIXrhs/6W0utMMqRBeyloqH0gSh8s6bfa+qysqkT8/GkB7yS4uBPLmsyuzkZp57tWhUu56Ukuhtaij5GNL31jdmX/tzUseFc5jpL7YE7cUwlqCcqgbMeEaRQrMkPd4kiQoVAuUY+0pAlKWQtyH5QEA06ZWd+NVX6+itJgY0VHcZnbbYAsRkpROA5UJimaUXmtlJU0zkSFObIs9gnVU1NCKwkRjuRrRNph6p2oqiBCB6CTX6e0W5QcQlEBh7XRz2dBogX1WDV1Rzu2gvKoP/WcKc8jfkcrMUocRYsIJ5IzxB+U9y3+5mhlTIrIt26GcTtn0kvs3+bL2r6I0BWpQ4rSppcVUqT0NSJFtcQoNYF86OQGF6kazT3OKcdca29UJ2K4YCJZwAVUTrEQDppU4YXP+lv1htdcIpRJ/ye2V0tCpjwsORQY3OoHJtUsOgaS+palSy46vtoPR20yiJLU41r9lPGvIXXMgkqh1RmVCcHDHxqZOEBXeX9oiRQ09YjvP8ddLrG+0ZyU22oKbcVlTg1gx8PTtvMxYWjnhhxn3Kwa0EwRiCqAMBbfBU6tjBMrbOTtJLFCScIBDO4hNMj3DlEDtHbxtVASCGjuWaaPCoXtx+mvxTHNSPBQfH/gpqpJLb6XcR35HKj94vTpyrkAYPcETrCBU3Ir6ayJ66Dierr7TX4m8bi01Nv2TryBzR2UXAElVIAtklNTyysIcANTgLAihI9bU4pK3NhKUfuNnkOGtEk9Mh7lXLAEFiShBa6Hky3MTZCwlKl5aEWjZKkPjqR9ugzBU5WcGUkVihIeaEnBuN045fqWqJBsjD/9xn9R308hDqYQTWJyJRdHkq4xci+xlMSKjOBZZEirr0nuuJ4xVBVBZRLYzNwsRLcOHHRubVSDrI0PEe6js7o7WqXqQ5BSt6RjZdulRRtJcgZ+zqS/pXJu3MCNr4IHXjtWjQyVPIGVZAgGGMcB5F7weBV3Xg+7y4X00YYcX1nKbYUMTdge3aCM6q4U3K2wW9JemRDjNgzIz5FFfWAD18bU2rgMUE8kyGY2Ez/gRVmZorE7JuaKtqbHOipjtzgAAAvU3Q0lNRiQy1ysg84ZcncbVvE84XPu+winw+JjkBUqLd7JdWh8Vjk+1De+P6hrHnO701R7o7xbrVHvr+BKhxI4kMQgAEBTqctlnlwBnwOMGqWIJENh36bwrrNA1joCIxNSQoY2Qzg+uxlCf2bTRze8TU/VihLjXlOQlFij3QY86ecvBjPgc+5u/D2ufUc4cvZHynYpQel32P+NU2tj74nVSk3TXa0WlSpHc4hMyb4l8ekl4068C7K2RGpMCkbJQmqxUPyQel/zZ1AKRcB/8+cl1Z9HhafYIVWigxGigNILXUqGMGpfKFNUoRpjmryIrD52bdyV40sGA2tZ4Upk9ZRrGSJYajn0i17+jJypmepKYp5KyWrBx7SEGBWTIju+VwxetBEU4lCaFa6QDFWDBETXK0nhmCzIZAgblUYhPWg7CUAHnSQR1zgl45bmosR/K3JlUox0qnjE32wf99kpIfuyQ/tgI9lGMoQz2qWADejtCSIXuEwSFBhSpu53uJ5MVDT3u5QyFM6nBUrKGEkF8HFDgMomjK2ELKvjVlzeeCyO5qKm3SsaadGTVAC4lW8/Xr9RGamLUvtJUkTco0veoSDCDE5X6bbKiwYft7IGFKw6MF4Rsja+Z7RvDTfwBYN2kkFZSoYwaicAS/oGKFOHJFdwY+JEJy4DUHd4qR2AeaQIoN7ta8p10oioFoejEZ45rmu1k8ATkLqHs+tZpUhRiTqklWuTPqSel2uAg7jMjRhcSlqbQoRKgWfFp5ChVDklHc7xSS5dr0frm7vC4TJaKT6U+yGWS6VRbTtG7XpBeBy4vO3jMQxDLPdxu9n2cUbSf2j9uPA+wzD5mEbJFTRShT9Iqaxr+H0iPRvG6GQoBEu6fB3eLt8uzSgljlU9JmU7ADOQ/XVyTif3vq0BGXQO9eHQ9sGF7cahhAYOERgHiHzS/vD6L35ccVAggiZ4wMdpolFrTYgBcoQIoPOBTzP24EFKk93GNWm6DaByJFh268Jx2208H3bjgqG82y73BwBiAghejyhX24EE4IfzPjh0beJ1MkMci+njeTPbaPSbPp4T0ztUjsdt+3g+8LGanpZJvBh+x+NzXviaNgMitkoZ358G3ZO7ezUeRzgHzon3oO4mh8eTcJ9DbpRY5cHucym30HBvW0rkRkQxqEkmtG2cA7NfD8k4AHvuVyYewtpIZjsE9ziz7eNYuGuX9h3CQH9Tly+8vo7iMjc69kJCJEEbI3bf5678uH4NGQJg713lO4RgtHWFsJsiOn/V7nMc/JsrIWVfaDh0BrKScddAGe+iSQxypN6YekJE2hdsL4xDnrPMeTqE69zh7rCSk70kGdKUGvybth0qyRAva4kGatvRoB2bMePZDXUmqKBcMmtCzhkz8oVy0cyDtchVD5WNiaubd5audI7KjpX536GszZ7NuR4YnXw+RsTB/8nvRzVZA+p67vxF7cu44LrqxE8mQwCQJ0PAZ7eV7VoyBeKGRNuhahI+JrSPMj46Sw+UWOD9CwxvNZkCus1xhrn+KG7fHhtUltWg7QnaF9UfpSBnxxRc7ixXTNAYseqkJnPAY9dVKrkdZTs+H/i4FWVoNH4bt5eq7VRFAnm7lvRCWaRXVZxUFUweGyXzbByVqnoyjgqTMBLHlo9Z0hbapS6VmAgo5cT3myRYqI0DKiFDPK22sUo9xXZR3cYVMjQF6vtZ+ZZrChIpK0pRZ8l41Yx0mmKDbRfJjpHKCkrTQGdxqOQHh0KJwqnUV8mQdqxdJ99f3DvoUOfnQKrcqJulFaIXvs/fjn/MDrIqPPAppGKPaiLEUeL+VoKSbGUFAd+jMZUcx4TZmpIV3mcZ7yUKU8K9i6hG/TBWeHy9Ap/bonsEky3y0VFUFI0IcWhkaAp5KsmOpxyrmhxCW+NEIUK7dtFvGhlSSYiyHV9e1F0qkB2TEKNNbmm3IVZbTBwLXvgUAGBYx2rU8JXbJSoMVoqwuxJRC+R9abZBvF3ed/c3NnRxKnFXNHU2ysInbFdVGaJE5ZURUI6JAHc7oGs2sGexEHhc2n2lEpcCgqwvyps4Hy6WqYKnkBblfUfGlyLM2ODE14n0FwdpUXIFc4aSKGzQdk3B4KqK9r7HygVWPYZerENQSoY0aKpT6p2utD1LHdIMUfIsKed5o6lDitLW92O7B12bA+bpGqGE9BxsPClF5NDqkEaGRr/h76vi+qgRIoxSpRSjVjFKqUOKffrTv/89dX3khrBoaxyaMqPVnTI7fwgyhFkvJ2g4IFIyshOzWNVl3od0PjtL6/FYHeMNNbS+i6GBtd7YHZUVdUBfaFMuq8HdfBzSmKylZf9QWxs/FB0rdxbc8TrUwyqRrnbly7sNyKXNo7Nh+4g4+O0aGZL+BtgRm/37pHTxVQL2ZI/UHR7rhf/n/Zi4zglYoMeKkyyE5AuoCTLDC7PIkBpkbmO7WiA7jsvwf+M4HjGWwyrbGZmhzwbrw48dkyS8v4V4rXB/BilFJh77LukBIl8oHsWXhw5IMoSw3g9OkrDfV0vYoMUdaddjWEd3QRz7M1rvB5ctKqNzPqD3QzwOWbkaq1gF946i+PhrHLbh+9XE9nbJGXxbsf6wVpI5kJggJUmDEe5P6ZgKlKLd2kL7YTsHUoY4rN5SsmZGcYiBRLlYJmQMK0PbQV+4ucDrYKQU4W+e5B7G3MIDqXDI7W5wMqmZ4yYntUG2s/Yke6LrQr+LkSHeF95H8wbBC+MqaxKRhEtdByPFTFAfcLKA2sQBqX1rSQXfNze+4rFy5Qv/nRnHuC0jl7U6Je1w4i2R1qXIkFRvKWXtgtQhgEMTIoB6EpBqhxOCQ5EhcTszgDPti+OFvREplAkJ8yQndzx85l15SWprw5SW8SKb4WOHXb+YUUfcUrR2C8gWGTdWWvAq7Iob3ejv9SqeEyT/us7KBoqlLjUEyjVQVZSSex1vT6lCEhniBBWff0w08T3GMSfuDSFJhvx2fm4ryNAo4QIj3mI72Ohna81o7nMlZdKPi0RnF0Piy4gMoToAoE8g4FsBuclhlyvsAodd42jZitv5ekzDKp5HmshAITmWLqpKzo+QBc/3IdZR6lNXQXzc+rtMzagXSABd+FQiuwH4fsUujJpL4LER6/SKy5w+ARP7xqRdJUWEaBtq9OB7SiOE2mOfUA9L0p47Y0LckOtiGayNaoO1sS3+DZ6TalrDlMVQS/ZJkSJyXLJbWlGK7VqDUpngHZEi/z1hpCgQI5ylDkCwOfLHpLrWFR2GIeUi0iJ8y1KkapbLHb8uUwx/aZKdT4Zr24sIOapzKCVPs83xs1ya5OICCRDHoi5zL3yfvx0vVsrtC8/ulNzUU05KCRHi9aRZ81QwpHYcyng1N7Oi2f9+oGOS1hPa/+0Nc+NQcO8A0eiaUwaovx7auepdNIZTZWEcpsfBx3g20Msq2KIpcLMrVWAEkrt7Se0G5oyRs8pZyJ8358pc5KTxAIwDHPFv6DwSn36eaEJqG5EqfBzO2nhtDCU5KTIUkHLNyShDJGkC3xeRkWA8Omo88mQKKrTTzgPnibITjW5C5FCdMEZ0HCRgfwvh3NpN3G639Li1pAeaC5rdxL59AD5OwiD1oyVqwOeAJlYARgjR8ZW4quHx4nHgNYtwwoiNU5M0kPJqvB0cxPvTd2uEesAnNtB25T40vQskDyd6sH08J+NMhL4OJiBA2oxldG2HeP15BjirreGkLcI6mulFx2eiWuyMUTPPBbc552JChd7F93M/hOusrZHk9xfL3P3Lt+scOP+bi33Q9/4A1a5y3HVPs3M0F7pEjAcxvCVChL4vAOzdmpvA5d877Zxj97gtdkHMuND5fvo+HiN2qVPOlXMuHLdWHh1H7aTdnBTUCKmxppA9plKkjl0iRNYU3ccG2zLhd9ZeLTmR3PQl+4LbKrWECN0XS7rNLasQFTFapaxJhociQ5zFkpcPfkEVXCjNDUspF2H0UUJj3c/mEBcy3w9Zh0JWLGaVC1Q+ouygMY7GS1Kx1pW143RdR/pw6oxE4THVqjvEODrADIh2njvDlDN2X+Df2Plaelz03KIx8HM+yL8VxQxprkNa0HsiTTE1aPUyTXyACRuqx2fspfGSMcZyT5IKoO3HcpmqLrSMY5dwuzzRAlE2iMqhlLU6WuIDZXvq3OJz2CuJGbRxqwkblCQNqYQbJAkCu5YqGUfbtTFuyTmM9VWlrcB9jrsoe+wIt/INTLnxYmiEDC8CiwxssjhsAeniyVaKYjZrlSJtVl3rS1vskv+dmrEvUJdIMoiCpSGqyBAvGxMn7tCafqO2FBc64k7H1jEi5bXidoeNcU1B0hJUjSayC86ztn9lWVO4JPUKK1hSvUmoIUO7DuU6EhnimJIpLmWvl7jGlthGXD2T+l4AyypEz/6/9R81tp46oEOSodB/wcuxpD+mEtUSIDUBAd6utc+fC63v0vSWJahUwciuqWMtUQ8LEgok++SBu7l2SUPsHlHW2lCJnwYyJtSFMo7k9ff7bgdCmkzf0/GTmWNtZlMzHuXjUwmM8mzxtYHU9WU6+XhpvILcjjabXwz8CGIVx+nGKiUCsQ4lT6iMP6A4EJoE18tj0lQiu6H94f0tM1SpCoG3o7Hgx0N7zMk7Cm9XqmtprAHU4ypJCz4X2vER1RF0MqSWK68zJhQ4HTvZTrK7AVIBnHreyDmcki3XyW2RBA4ouQIuk3TP/L2jtKu+m0tSR1cmkCFGfI0yUaJIYKO0xH2IfF/yhIn3oY4PnXejXY+tnJTCcXUJq2KqN4aSLGOK8qMRgVRa9alIJfaYgqUM+BTZ7hSyqBGigsn9Ik+u1Lmp9cAZjUs/bz/9e/9vvb1KLKYQvfDZ//d4Rp30hNidxPQwUu1IdTPlWWQIj0Upp5IRlCQd8Pvx/UfJBdD2gM7QcfGEEH4frM6klI8CtYSMhfnu5+KKyOKM2rGi8uh4MUbkhJ0X/zfvE5+HkO7byLOO/JqH9i25Z6hao5AFEw0tnpKa3ouA9hHOFT7Pq6hu4lk/11kYjmlMVUg0wcY7cocUjtdhRceYSKAshI+oMxBeis6YaKwatMgoJ1jEyFbIF5kR0uqDWB8H8g8duwZoNnroTAzmtyyWDBMzJRZGrwPhGPm+0vV0PCHCOo7PkyysAHE1CJe3p+icKAoVb9vZ2AZJZNDRuCEpXmdYxbWXBpRsgCsqmET2a7k8sPHihBE9Oidy8oi4f2059KkQGlXFQXFY/TreS6MySYIxvrYkUYZJKEWpGCRfLnBJ3b0P43ty9M6WLASFtOwSKuz/SCZXSBhg/m9j4rvMxnKo58eBXce9JwIqk/q471LDVHBvq4ld0X6vJUMACYJYOgblvJckW1BjnqzJn2sAapj7pAyp8eKkDbysQao/BXh/TR3kdixXCnH9rL3LxltS1vq4CDKkHYd0rvy2Aju6mgzt900KMZVYjBA1NDQ0NDQ0NDQ0NDRcNyxHiEoUnRLfv5J2PKvMMU5YQB0K7Vi5nHJj89XwjD5XURCKsq1xdQhDG6MWb6NlvEueT8U9SnFp0mKRijLcMQUpQFPEfB8F7lVkHzITVunGgNOCs/glrg5JZRXKTC+5fsexL6wGDSdxqn04XcFwugpjcUerON51F5WJldXv/RLpHKFkYV7tOvPkBziJwhR1yIMrANgFr9eym7FYE5omOj4fkjpknNNjfLQMdiRuKG4nmeNO5fKwhpA0YFgjRWUdzw8u90eGqGL+uOT+LSqbfB0ldmaXUns/lhLlZkWv7bYks15JHBQ+59g7qqP9j1OD+3flOH25NJaNcq36E7m+NvaRSuT8mExwr3PWxO2dvG+oF9rC3wXlXQ5QbSXQd52JCnIXyyO1QnnXksW0S7O7epQoF6l9SJXC1M8lcSiTMpHt9jGDEqQ+BeQdqnzrEiqRmh2Pn+uw0Lpl9QqUEG3BWA2VMVzF49DGlIovK9nOx6GpYpr6pca7K3XmQlLIAJA9ZmiKdt6/aoPPUfSWO77DKERTB1hKhgp+I8GZ3IDWyBAnBb6tgjIBPqs5adCyf1BY5gGx2hgFckBSaXO3NeVfaAv3Lx0bPr8lhrQVyspdqY4P98fPM/4Nu9CthDFiSGM3hpIhnLxhzYgQj6vxLio4mJW5Y4kvBYVc+v52blV7grOycfu6I+RpWNvg3hSIlEXjNibUV4mohfAR1hJGOOVFWJIoYfc3RLc7Tm68wVdJhngAPF6LRTJ+uYEefsduYqiuNwD7dTxvagwRJlkCYcIpoIcVGgchPMg9bB3/90b0sDYhicCwitt3LnDxeIY1/Tu6bWGjOR5PIFlo/aJhhVzYVnTNo3hs8XcxNXaiLLWHCZ4fR7/GREpvL7SBXSItrZtzB8R9EZc4dJ59soRhFYmuW+mk1UNLQqEl8QjbcfIElkhBIkXiWl1Wee4BxG+acaiMYi3M4MK7CmcA3S3wmzDUUpNefuwFE1aBcPD1h8TvFXLfYgtX8kB5jmpSJNVHS0Co7nJkotNAyBYnEaPaGJcaUmRMTJ6wP4f+XBtjYrpuY3fn1aJjwy7mmitdTXIEyWVNPD5GJKR/+Hdt/9Kx8jFqYypxATwAZrnL5UQMfn9r++YmM3g70j29IAnCWORqvPA5f0f/kRnryXpz6jAyJO7DX8bhxo1GfCp+pXpx0inHpLWFDWeu8iBoaoKaUUjrj/Ud2rLc2M+X9UwjSn8TMDoPJTE9OPOathgemQXLt4nLw8rCUJQZT7lHyVhRu0dIDULHMBzhMjsfawvDsc/2Z3aqkf8NxxaRc6Jcq5IXJirSWCmIweSGlrV9tKD0IjKkqZh8f0RE+OKsJM6FqA7admSM4ixiyvZU5rhAWHisENp/e8PUlU/oeVAVC7J2Eaq/jjEvmCgBsBgmpS01+5q6npI2JnptB0TMNBWoV7LN4e38b00hwwrQ5gY+ptjOcIRJGx0X6QPFe5FzpYxXjWVTJiEwWSWLwBp9H57xLbm4dA244S/FcXK7QSNFyruIGn74W9TJZUaGSJsJQ6+EFKnqUOVaSyO7Rk0uNEM50uwl/E3EGeUAdiSoaF0l7buqqECa+qGVOXEKE+KFxoXmwaSNjxMkTUUqJVVa/yVl9X7XngnlOgOU3Vfqfc/aMgXXMGVPFKpbSQ5SgUWyzBUNpiRrVwpLkyFhe3VqbADdkK9tqzSrGarPSUA1GSu59Er/RW5fAGxtlMJMIx4zk8YY58g1Vdf10bKtaRn+VNKCCAkmSalbFwclKylqtcVOVVKFi+zjaFAWKJwRavdbIvtT2KmA4CkGVskCrABjQ1fcp5YM8Xe+lcu0krIdALR04ho50IxZmmlO6So1Di3LGsuMF8oo+dYo0xzJLie3lcQMG7no2NWsc7wx/Js8+KKMecC/J7HIkz6IZX7PaUoDztKGr88mlrsNzuSm1ZffJaN3AP5NPb/svOHfyFpIOFsZzjCHU2+jbHO98g7mf2sJBLTsaFq2udQaRx5C4gT0h74fGpdmRqltaS5miXTi1S6DmjGpZZvrtWxxaLt0Psm3FGWjK8k4V2uDpKC1VZn9rwjJjGpsnasSzHFrKyBDu2qFhEhsV7lHtfoA+vXAa2oC6OeyMqzmp3/3u+X6FVhGr6tRQrhLU8l+hWQIAL38+cX0F6eEDFmoc1+T+tPGmvqN19HICFZsfMyMpjKkZrtEF4KolpEVrq2J2bmQC1ixdK0dr4ZaMsSvh0UGMfttZJhornTieagjQzv3KnQOFcLO3Rxp5j4T+9iXh+Mu1OmPbSAR/bEN67UMawv9cQf9XhkaOgv9ySqMpUcxSCO/fzxGfJ94l7kOla0BKbvcFDKkutOZaKTVkiHs1ubd4cLfKznTHM5g5uvhcqi3iu5z/Rq1q5GhNQTDeljHMZOsbMi1aqQMJcrBTWsdFaRhFbe7DmA4juX+CLnZdbJrHclot070f0S3+9/6o9h/qiz1oR4T2u73D30zsjkI7nxaxjxfB7sjiu55R/FaDUf0fiT3CVaDjk0c/xE7luM4rlC2SGkyeaXIOEdcMJNuqeF9h94zBj0/hj1XRlGKHFrc2EWDnbjMsYXDkyoTfs9o2T9xLI1vV8k2BwBRreDfJmXm3Chu8yIEpUhbi0YlQ6UwRs4yl7I7fP3B0TJug3x3NE8OZBPw+BD8nTSGuNQZbRI658aYtJMSqoy2f85WSRneJWTTt+W3dZ3eJt8n1X8KlRPuSZIvTX6mjrtUQ9GuaWfLro/WZs32SsxWiF74fl+/Kyy3nFHExINXH2zNL5eToRpMUbhSahB+0aF4DYMNUa1vpuCoM8sFahTef1jZMHvkOjQWG1/SpGwMnTmsVYmmkCEN/JwWqEGqUtOZODaNDK1tJAQrG9vtUN+dAYPWDsEfKXXdIXTv9sddONf9SRdmZvuTLqg+w5GF7iwe37A20N3ZX8OVge72fhbVGLBncUaVzOwqKhFxxbQWEWX6AQwky5hwjZwxgRDQMpCXoLbukO4ehMbHyFDcDmSme1jFdOBDBzFAvQOilqhAQyTB+et4z/dHBpWBlgc/Dlr2680MK6oAqFCUk6GLKoNbAXRncbsv+9/sGa7n9sdhwJ7vy0exPILyCsQkG+8/pezHNDpebf0evOzJKp6HYQXQ7cv9mpbxuR6O4j79UfytP6bKjb4QMKqD798jAHuOyvi83437dnejK6m/Vs4ArNB5wIoQVpCwCqgpRc6aoBA6a8I7xHUmrGvkn6PwrjKQWJgVj6sX61A1Ao3FxDT+ztr43jFGVSeMskaOunZOiYLTdbE/a+Wy9LfwzSZl/zfuR9yeV4DUxeVxvdL1BpVvsRmtMySoRb59X9caqh7hc7/fxxhDFbvadYNSqotvy1gQFSh+PYr6S5zD0nb9M4cmDWcnOeCKkD/erhP7SCpD+B5X+1CIoFYH34f+b83uq70+GU7w07/zXfk2ElhGIQJYjKFl20v0QwLW+cviIsmQ7xv/k/YrUYNKZtdYH3ytm9H6N3bcP1GAsCGjxQsJqgcJysV18eGnZioAlidD/v8wO2GCYiSqQQYlF1ACspNkCADAsLY71Ldvb2XitQkZy+TzOqwi6cCqTn8yLg9rG+KH+mO7C7D38R6nNmST6m+swjnBGepwrNIoWYXf5q9RJpkCDrqGAT1rjpf9CUQGmn83Etc2llUrbEd1UmQIAHysEo6noIkTaH0ttognPPDjJAHyR7GPoNLgso0z/LhMyJWSyICUkZrj453IsXtl4zhu74+BBvkf43ooHofEPcVtvtwfR2WpP44Kx04RMep+teXQ7lHsY1ijMlLCeJmfy34dzxMu+/MqKVGSK2R/HNWk7UmMpeqPgZZ9+ySebP8/Pu8n8f7qT0wgmv1xfEZwJjp/jYxjZExSitB7Biui4X2zskQpo7GocSxqxkukCGmutJJS5NB7Ba+5RzwWPLRFStX4z5gMIAT/W0vK8bvgE80wDwlexn975AzDrkMKC4ujCarCBDIEkDc0NST2S3kyjLO6KseAVTqc8ELLhCZBSn6Qq8vbzdkbmoqRs2dL62oxPyVt8vKIAKPjDfev0cmQOD7hvC5BhqRjqNlXwkSBpAbLESKA5QY2hQxpF4sEbVrxpbyrN+FiV45RracRIG2sPOsMwmgBPCRBElcJ5aOFCdCAjWMSbK+8cBB2rhLouHwxOZui/1SN1HVAD6mWWIFsLyiTc8XS2Yrk0SSuAW5XIUDbG6h8C9VRUvcC7Ayd7ene6DCoDQssyQI6Rs240V6UijucGgvE3kCUPKPtSixHCRkaubshA4+npSbJA46VMklCgOsYtB1dBxZkH/pGi3nicYz6OC0o38iXnY2GuFvtxuXHNqxQeU3HvLkVj2VzXyyf36+UH0D10XZ8TP1J/Fsr831wH3gcZHw3UZkklYjtcLc8THD6Y5Qw4sgQ9zTSDyqfk7HEfjY3lTKqQ877Kl5TZxOpugVStNsfkxVAZSOWAU8AWEqYiEIL9P1G+lnL36giUkS2A2B3dDXRTC0pQgkADC6v17QOJmASIQo7auNSxtLJY6kOMAfQF2adU+bIETBhXGpCCO3ca6SodhFS/7dU1hJpqMY+S/5QkvKaEy+t7dprzcdVuUCtqghp965G7gHovSKFo2RQdA+l+s9t52OcieVc5jwWzI1ftB3YSS9JXblUthyOyracMcRFqiiNN1G3eL0F+yeGaUG7yurlxB0stdL2HDKEz8+U62kMAHb/0NzWcNsacVTW9qAN4b6Bus9hoOPCRLU/Rn3jGXy+fghuCvXR3cW+RQZWd6KPjT1D7i4bxW8MfzQzCuJueyEZUjLC0XKsPyh1NDKE9939Rsuj4HwJmIwphE2LsyFptvEYj4C66GGSV3k7E/dU7OWD3ajYcQ4dQHeu/M7uVXFcWnlJaG5yfUGZGINy8/2xIa5wux3RbpoLnJYgw8plmvAEtbOOLnMA1KURuwviOth9rkPujPhZp4ky5IMfVoa43/FzRBJYoPckTspBkrXgd6lSLjXQiftyrfucliRA+0Z0FtQA71QCiBKo8TQJW0QZZzFRqUHi+JLfbQx8fZTEDcSVriThBUeJjaNeQ6U/noigNktfretfCtzlryQ5Q4l7HKmvtFkyiQxQTODxfVp0D6WesZJ725jLdZmbTYY0iVCqp2AxMiQx/JoXjPbyMvqaP1Kd3XhRA3i9H40MsVmTVJ9i/1wiZ7P8wZWOu8cFtYMbuuO2iPvUBNJsnFOJCiFTfo2GUQPKvcavGzOyaXKD/Q+qimaR65Qla32Q84bcWDC4m4rfp0cJFLanXdi+PbWBFGxPbHSNO8auRDtFxKcOdtZEZShzfwcFTEu0wTPL4SQLwjHxNNve0MLnObYllGeQoWFFnxmS3IBmkR0F1uO1fsRgfBx8jxUgXOYJFyyqg/teOxg6F8puFcvDWigfORiO4vbel1dxu1s56E/8duQG1tHzxX/vj6J60R/H7dsTtP00qhfb06iYbU+j2rE9QduVMv8bq1f9MVKQjlCdo9jHsI51RmVpfSbkjheOHStHx/Ha9CdIRTqJ27enWF2S3eRw/f7EQX8cr5u/Jh5+zDt1CJfjO5sszJtZyNUZvoAsfSfQY4/vOT+R459L0sbeHdd1JiRvccbQlP+ZpQb40haqKoNUdGdMVPCNISqQqBThOp2N5VU3nrGXUjdzJUJTAFLfFeG7PQoon2DzFClFc8DaEQmYPz5ppt8Y1f5S03Pz8y1tZ4a/lMiC1BtdwwIFSts/VeYptnNrG+WQU4FQ/6azkE3iobl6Fo+HndtMQo+RPQnA7B9FWUs9YyVwbsxJKjGLEBHMCVhLvRRKyVCBTDjKnqWVa2daEmSopjzKYqe5yaHN5OYCnZioZbK2DnrQjaluSz3XJUjciSoRwkhN0hhl7HydnxDfY1WFIkmGhO1qGRvrR5YQL6ws4Zgh7Ca3uRnbOsflW3KZ70Nc7pArHnbRAwA2maAYOgVucqqKoLw4x23FOtVkCMf1IEN79zfuj++HjE9siGJ3OFxGLmzYxUlbcwgbxLuMaPFvXMb1+tNY3t6oLN9E7TAi1qP1cvjvm/tj+fyB2Mb5Q7F89sRYvvuEfFkjQgD0HJ2hPs4fRGU8DjS+zX1K+RZ+3mgZ3wMAEDLx8bbP75O30z7juDb3O3G7J0UAu2uL78/NLbQPcb9T7kWFFGnrHYnuo2EsVizv/sb1sIsuendgUrSWy/S9QcmB6r5MVGjZNQ6TIrdGN/LRWqw/IkJ4H20dOv635nakrd+DYQwlECVuQ3j3JUlRwT6azbAbjGynlJKiETHKlElWQKWcdKWTYm94H3jtqIIydF3Z2kMcWr3acZUQHR7/VUvMNXWu0NbbLQLt7Rw7JkY141I7mTcpMMtl7oXP+Tu7AS+ZvaOgDmef8qwMZZ7EQJ/jMoczuCSyucwiBIkbIhiAg4tpTvnMvIOR+iCCEBilf+fi+RrQOJkqE9wqnAO6ZgXOWlbw4tZU7RLXQgB6bQH0Y8T3EMnyhscyxBf5MKDznSBDJS5zSn+mdzE4eXBhBtY45CbnokFkBn2hSg6chWp1B5VvRxeG1d1Ytmd9OM92O4RzZxyM1Rxf5uQ6HBgo9em1UX8jrmbTyRAu83qmdzFIvY917TYSBVweHZeQCGG0HfVvBghqjhlMIECmB3BrCOWQVrmn56Fo3R7sMoc8ieyZCcpT+Nsf71kkcPY8kgN7RsmYuvaOPCyC1W0TiNrqtoF+X+5QefWYIWROdZPbxhNB3AJRne5uPKbuLBIuXLbnlMR255Sk0Vg1rSyfH3tuAgmyGzqWUL5jYFjFc4L3J25yt1EZP8dK9jm7jWO3W/R+6eXybvBAgN+9ZB0r5Jpnz+X1zewGvUc2fXwfb4eYmns70P5JtkDsbuXk7Vuc1a4P7xGz7eP7u+/Ju1wsc6SIRsq1DtsH/p04OCh1NarBbPe5UvclBUXErB/i386BmKEPQM0ESPorOC7nXKg3WgupwOVuVh+8nymL5CpjxOPC/e9/9D9EMsXv7bkT/Sml0I9Ls805SlwyJ1KTOesRzVeILpAMidlPapUhhQxprmXJsZWoPhi2oKy1z92KWLyG5vKWlDVNLIffkGsYWe8IqIFfEodFPqT8NsmdI6yWQSHBTNzNGhnauWJ4NxBLk0ocrZQyno3Eqg9Wg9i5xpIxymJH1kY5QjO0OJkCihnCs8ObG2g7JkZonROfGQ3/TmaYNaVISRgxaMqQQoZI5kFNPWK/gWJ8zlKGjug9MKwNITSa0qMlMeAZw0J2sKNogOJ1hvpjalRj1Wc4xmVUhykJcezIiFg7cPu/3Rq5z2GXuY4qPphoAABssSqhKBxYndnejO5etDxAf3OfAv7WAP2taPjg8tlTogF79mRUflIs330S2hcrZMcujL8/iscyHMXt2GVud0yxfK6UsQoGAHD+QCz3py5co/4GKp/Gc8yVHkyKN/fFY1HPNaqDtzubSJhRohRVlocVchHdZ93zapOz0c3QdVFddYbHNeL3oKwgOSVhz87daj8eCzRbpy/j7QBUKUJKj0PqUFGZZ6nlCo7qEobtC0UdwmWmuqvr1C2FFFEqsXMSKAuaZ9uVtOMaEVEJitIfyWrHMtxp60WJbmelfbB9VFfAkvLoEJXtpQk9MHGpRcHyLKR6KRlivx0kJm4iJitEL3zO35nQ2zwypNbhMzyELOAbp4Aw4aEUnpq5xro0Jk6GQhnFVOzqJdpQoKpB2BBlcRxaYLK6ajlWQbTVyXE5te5DScwiP7/aA2eV624NiGsGjPpB+xP3E9kdTlcQ4znCa4Lw8RK3LUxqsHsLdn/CE0IsJ8LqLj0mP8NsnAtrFAFQ1YiuXo52RoeVIkOxDCRmCKNkzaFBIeMaGeJr/oQ6e4OOr1MT20Zl7VEycnm0FpFfW+jIkcawOqMH4jtxu9a3WzswGxPaN+fo493jMtqd3+La9cXjUsY+3LcFc3u3wd3agnmMBWZJcFoZjVdRhoYTB92ju4ENRw5Wt+M+diMfrypfsXcHvSby8fYnDuz+HOPybh/cFn5Zyt3jMeJ2urv4PQKwekwoA1WKaHIFtHvJTLXBzxtVmlxnQtu7JBxYHcL9I3UIlcm3gSSwQf07+g4M+xijr2eEt2tJFEq+49bGgH9raaKGVLB3idGYmJTUUHK9akMGCKyJ58sYEBfnBCie8FZn+ZVEGLu/5XOMTdIiMlSKpda8kdpUf95/Y40pUsBo9wXHrqmb1tYfrz6QWFZUzpLMwyIOpBRNVYnmK0SlSF3cDIstJkPML3gOGcr95n9PqkFY7ZCgHXuKDAHsPqx+VkFTfQyo5QCuBkkz+dJL2w/DuXhsjq1a7sc1OJmA4Rm4VApINmOonkv+Pkcvg7imDTsuM94+CuBEsze7c7Tfv4AMURUuGkpqdrK9T39UGArI0AmEczKgOJCBqQLOAGxOx9fSE93+FLnnncZ03GEm1xh6Tvy9UkiGpDq+nrTmECdAEpmiBCReT3zcEhnCY+qPo6GLlZ5hDXGNHp6mGa8B5JUhpAYRpeDI34devYjPA070MKxcML6HtaPj8KmRUZIFXg7H5behhArD8YDKVE3CCRlC+RgpH1gduTXAcOLLPQynO4NmuG9nebsbKIPUzb01fmu7+yeV/X63tuB8+WYP7lZsb7i17+M0Kk4DVsv248TqEFaNvJtffxyVrP4ElU9jooPtjZ3KFP4+dcGlbnuKkk2cxPb5OPoTdB5PhqjeHbtwTYbjIV6TtQvH41YQXAZ3ypC/d/ZjQKm7Sdk/1wbFxJl4H+LYOOxpMEoegu7rsG0d64uqkgEYjnH/glLE3iNeEcKKPPZGCIqJELPIkyuEtqyN6hBOosATKkhlYY0gH5MkBoFLsT/4W87XUULvSnJs3MMFIacUFa0ThNcI4oqE/x3vJ2GuUpSwz3JKUTEhKFk3iu+H7RCtnOtDaoddUzXGSTwsRalKjYvXyRHj1PFK4+OTxlJChRxS/UgTBIdIFFKIwxOixENfMnOSJEP8YqHt1WRIORNFyRA4rFLWblZlXSHNwOTngUvtRQkQ+MJ7ewwFBi4AFKtnYX+FBJSs8bP78KDGFEWheCzaOebHq9TTXMg0FUONOVAC+PnfZG0hUo71e0KYaJn/LbUFQGdrsWFD3Ft4IgrhWEaLOvpjYjFOmpucfh5xW6g+CSDHxwBJqGv64AD/U6WsrEU0KEkTduNErl+EtFGXsNgWKp9Exj+cDvL2EzorgNWc/mYkK9h9DWDn6hbK2HXrwbjP9glRbhieFHN026egABeAQGYAAE7f69Fs+eS9otRx9LQYILN6aiybp8Qc1MOTYm5sfhybB+Pf57iMEjBscDIG5AZ49hBtC/99jso8GcXmAXSOULm/L5Y9qUuV8bHgazB2b0RlTIpu5J9xrYwnWPC+Ejan8n5aQgZKkLQEDPL7BaDs++CQO7M7Udzhjo/E8ijpAd4Hu9+tOpq4QVsDSSBVozInO4rRrpEiNbOu6qLH7CRtn0OSogLbRyMSRft2ieOoXS9Ka6t07R62TXOvU8ta2x27V5X+1MQWc9ZDwuCZfFP7FFzrSWrfgXBYl7nUgdbOjKROoJZim71ci8jQUuvhcPj+eCIGMibcVp4MiS49Uj+8T+Kao5wT7TLwdYX8+XIu/uYYYSpwP9MwWofCj7FH6hRO9hB2VEihEgOj7WsGR2Yu/P7GuSIyVL0ui4sGvhm4n37e6MFqTMplbn3boe1DqNudDeF6dRv2MOA/tXsokTQhjMtFN7ldkgbUheYax1JoS9t7osygsbp4joIb3Z647JIb4GNB+xWQbfrMovIQVQMzoPEMVEHSAvGBuGqhZ6BgTGYbkyaYc5pAwQxowPxdhyct0D6A9z+KN1W3Rob7nRWc3L8jLncfPYIb91OiJMGhkzcMSrlHhvMGHfyjK3BHu/7to11QXwAguA4CAEm6gAk/zdRJ30/adbB3LQw39n3eNdAjYqpeF7S/+i7ALo1o7N1jNrS7esyE/bG7HABNtNChZ7xD6yppLlj4nW97F54nu3Xk2erOHVFksTtep7nMneG1idD1wS5zvQvHZQYXxmP6gXwftPWIVHfsXj5e0/dBYTI40cK2p3YEdu/i7mSamw+ugseOEiCBc7FP/l1WZsZxH0XLjOAEDrg/HmTPEx+E/Rd2nyvpR0m0kLQhJQM7dU4PASkpx5zzx8cuEYphUNU1gpJ4tJLkILwtbTI/lX2w4D6nNiQbV+V1vHoucylV6CLIUGfiSWR9upkKg4gSMpQol5AhNRGCJJd2cll3a4ofXGdBdLcjrnC4XArsfrai7gM4sUEoWxNmD11nqGrEVznXYLC7lQWyvg2qE90MDHEjVLPJlShDLKFAOF6jJ/AYtHS52H1OmekdVtGgd5Ya3sY5QgIIoVrL/ZAECuz58X8PnUVlg1zAlHsVgCVHiGM8CBkCnjI4oe6wRAnRdUhZA4ivE4QMa5oIALeLjBuWHMEbz249BCN9t31fqXPRqu/c7p/HKn6E3QlyXcNGOyZfq50LV3CtO0LJGU6GQILMjW0gQev7zmB1HC3hk9OoFD35aQ+H8jPe611x+32PkbL/+4m3bsOT9uWHbt2GJ96/Kz946w484f6dhX/rxhncf1+09jHJWj0xlt0TouXvEElzRy4QmOF4gH6voPWnQ1DThhsDOL820I1h/zc+l0gdegipUw8iRoDqw9Gw+wcAcNwD7MdjjgYwodyHc2rWAxh8vXB/WK1DyRiwMgRAEy2Ee91Eop9agwg/T/idwN1r8d+uM8Q1r9dc5nzZ0oQxRFk+kt+pRAEyhrrWofXRovsddrmz6rfCHWMFCSlAx+hEGIPc6QxVUYwhbnLSd8uPLR4LajulZGQ8ZlQyxEATS9CyE1wUyfFqbVcYpKNvq0TcNGPf74P/l6ARAqxGsWtV7TZWUsaJC/ix5NzrpD61Y9TKnLRwt8hcfyU2dypWDWc4VuztpGqUKl+CinQYhShFhvZw1ugzH1pbNWQotz2F0iD+AZXxGEtmOCaQIbFNPA68TYCmAFGViI2FKEL7/3lqbT7jB6ieNA7lWIYjGwJxh7UFe74zFFxndylbhT7U2RgAcu0HQqCisc6JMklhjoevnK8UGZL23f2ItgeyRqsQYx+RHmyY9CTlNtoZ3RPefvYB0qbfpRQG2M3adihd7/p2PJfdXWUWFh8GTzDhk0SsLHlRajPzJW5ys8kQJoz8N6zU4MQK5HlGbmtrALuRyzgdcVFa5pWyHZOczsUT1iE1du2IqjDOjuAbQ3UGZTvAzoA/3yufp1tw57tBr25uoN+rMjfuO4Pz83gwx4gYnR5FonDUoTTuVn42n37zYXjTow8CAMDTbr4H3vzoAwAA8NQbj8Bb9uUnnN6Gtz0S08Cdb+MJOz+L5S0quzPkmrLFBukA5u7eEDwZwOzrudMezNneoL6xBThjDyFJiFCg9ODX8lEfFK3uaAhlvH3XMbrv0XZzHsv2diyvH4v1VaXIRKXI2fi8c9DYTmU7AElsgdO3OxtVZ2di6m9ndqpz2AenAUeqM1ESyHcDdY7roEQLzhiw+++O6wwY9H0gabtL0kqz77X/njljdirSfjsAxBTfxujfnlpDDic40MbG7QpFHSLrNCn2jlvZeL4MS1iBk0loqk0hVKXIOf14U99zD811jBvxUpA+P49LQ+un5LgwStJldzYeY2f1vrX9a714NMLOlaEU0df615SiVL0EpipEkwjREmQobMYuSbhewrVstFjakmTIA7thaYSDu2qlXn7Kcc0mQwkE9wPnppEhgNGDgrOhma1yExM7wtFxoBkiP1Noti7MINrzgagy2Bi3m7jGhN2gtXH6gZ5fADIjEhY9NXEGxRkAToZip+iAXTxHxtF7NbaLzqPh1wuycOw64nbDCvI2KkZDF417Z82YDAEADGM7uVNc5rozFwydncvcvnwez7HdxmPfuYD48w0xTmhw1CWR2ezhOF08xp3r4eHJUFDHHP0bBgixOqY30c1tG8t2Q9U2DWYb65kBkR4HcZ0h5DJnHETXNFYGzU0Ob+9NUB3c1oDxCRVweWPjPhsT3d82NioZAADnFsxpJDnYHa7fWLhx384d7vy8CwrOY2dH8LT7HwEAgIfvnsB73/duAAB4++37Qvltj90PT7/5MAAAvOWxB0L5TY8+CE+7+Z7Qx3aIB/mWRx+AJ5zu+njbI/fB/Se7vt/x6M1Avh5+5BTWR7vx3nnkBOxecekfWYfjMrdXQTEydy1RX7ArmznrdoTI46wDe3PXz3B3Bd3+t/5Oh8or6PbKTn+3A3u8T/5w3oWxALBPAibXGwt2P7bhvAOzV/iGO6twvcydDtx+n+6xaASuH4uTNdhdDgBgdQcdInFli88QXk9rtOaWvze3lLTb80juu3P6zsKTKquzmDRkdXcI7378LtmV9+/xPpYNWZvIofe7o4YZ+iZZtIaR2WAXuCEoQ2bTR1fn7RDLmz7EGpu+pxdLW/MIYEcafF1tTSPn5DWI+oGW8XGlSBH+vkkxQM5FNah3QSEzwxDL6Dz4cyGVlyBF1VnnnKsnQ/iccJsw9Jc4j0uU+fFx8GPPrYWF3eFSNrBmE6bGmR2fo3ZfYfy+poyqY06RnQWzzk0hRcu6zFWSodHfOQkVYHzjE3KhkKFSKU4jGyXlEjI0Gi9uazoZ8m5XagKIkoQLnXDjsjJJgTs4MgZ1kpqoKdidAq1/czN+eTe38Ho/6BquDPSnylpA/IEk114el0aGRvcnyWqmESiFABHimS/z/tV6Bdv5k01S+26pO55KQrCL4JFSXsv1xyQPl+X+1AxyWmrtSjIEsHORo0kT4o27RWW6XTsO+ndPkisg41fIRrYrI9cs5D4HSvwOAJAHzRyjhXRx+QSXo6FvTpGhjgkAAHT3IZXndAPdKtZ94MFodT/jiQ+H8gc96e2h/Kee9JZQ/r+e/IZQ/vgn/65Y/rin/F4oP/P0XfDsm38c/v6IJ78plD/kSX8Yys95YqzztCdEMvXAQygxw4MxAYN5AEkjD8bjs6dber4eivsAABw9FN3xTh+KDOMGKp8+EOsc3xf3P7oZ+8TnEACg6+L1XqPrsj6NY+tuosCfm7EOToqBEy1gdzkAeq+SmEMtaQh2H1XUZ/4bWbDWjJO4xHJ8CfTaGmvkHaMkWjiiLxPynsD7ILe34aSgfCy7lu1cyPC3h73MsHsZdofTylqyA27LlAS6d3LfxBXwNJb7G0diGYCdL+xah8c+Z2FPab9q9Qwzb8VVjJ837bfapAIl+/J9ku3NSOigET6OksQPJcebij/SyFDqPCg25WgsSoKxi3KfW04hmkCG1H1TEqHaNp41UcgQWY07wZ5rT0nBsY+6WJAMpcem1MXbC9QzrAZZEhjJmDwuE0KAjgt/BPGHDw8PT5Djlc/P6EwedpXgpIwGTssfOI0METUIqxsA+vUi65fIxCYFSh7jdmrYyMYHns3FsMxdhq9ZgoOjV2gtIjzrqwdky2PnCpt2v6okSSFAJL5qAhniWecIOZFUNtDvSQzT8/1jRW1NGpK0gNxbaDtWgwZD4oQM+s1o7lxkUk1/xi1qa7VGRvi2g1s3o+H/4I1ICJ54EknIQ0dx+/1Ioji2lHSFdtEB/95jT4Rnnr4rlJ92+kj47T2bE7H87rvRun/kbryot+/GG2G7QRMmKEmDu9uBRUoYPo+YsPC/8TnWkkHg7WTite9G5EhC36P3InJPdLdjefUoKmP3OaYUdSinhSVKPqqkPb8c+Fbd4vcHfT5W6J3RKWU1uQKfbPNlPGO8dfrz6ORjVF3meHIgX94wpYipFkRJ0VBisKVmvDWlSMkOp2XfwxOQdtOHRXLt+ZZ8Dw12Y8Tf0w16ficoRaPvhqYOackVSgx6ft/W2nS1CZ+4cpJaL2qOax5XfTRCNIcolLiTJvpQydAoy1/iXGr94sQpE5Wiy1OIaskQZvHF7FqfBRil2PbxCxoZSo25Fpr6xNqnxjm9qbLr/zA1Awfk07GArlAUkCGSQAFjcMGww5mAdjspNygnI/t9huMuHNv2pAuqS39sg/IwHNkQnDusDGxP0YwiUok4qdSymoFFC8vi2DULNGbI72uZGlRChiyED7Ezhn6US9yHiXESy8PKBHVnWJkYt9Ih33wDo4xyALttWMWwW0cznKHxE0OlZ8oNcjOUEiW4zsTxW9DvL408lpChVTynhAytgZxrslZKigwduzDO4QjCm3A4cjCgRAlhXZ9VTKawGw9Sk5Aa5FbxWSFJLlByBLd29Hx5dGg7y3xmkAubRcTIdg6MfzY7B2ZPqIx1wdg3nQv72NUQyqt1D6t1DxbF+mAS8OD90cp+yq1H4WjvV/nMW++CG6sd036/W++AJxztyNEH3nwbPO34YQAA+IDTP4RnHe8Unfc7eTu838lOTXrfk3eEMgDAJz3ht0L5454QFaQnHz0C73fzjwAA4AlHj8H77hWkG6tzePqtXR/Hqy086dau71U3wP178rZa9SHhw2rdwxrFO63vR2oOUmlu3DiD4+MNHB/vHrCbp2dwsnfPu3lyDjf2228cb+Dmya7t4/UWTvfb1+sejo5QP+v4QB4dR9VntephtSdHuNx1Q9jfGkeSVxi0vtPWp+p2TClCChAGdrXdBdLvyyu0HtHaxHWvVpHc+zJdVwtPyNC+tGQvNPFLfJeEyTAbxwWGvw/kyTPAx2JRcgP8HbBy0gNnDZ0UU5I57Npg6hRO3CAE7DuLvudozSdc9vUCCAFT3KQUMjQcrWJSm5NV6KM/7kh//U2qGnl1yHWWqGbBvc45PdFCwnZSF5Qduf2Z8XbcDzequSu82Llii+Hf+HachEBKSMDBf+P7S3Yb71Mbe4kQgOvxBBJSHa0s7aPtr9QJ17qGDJWS2UtSiuYrRFPIEC5rN7p24jjRUNYbSq5DVHLIWh1tzPh4TZy9GhEMErOD90ddJ8gQqe9QOYFSMoQRZt+wv3bvQp+mT/h74r7Rw9wf29Du9rQL8UHbGzakbt2emBCo2x8ZplowpciXySrmwjhQdrdQtiYaqCQbnHgYpJ2wPz5O4samXdf9poH1g7+H+CNGjHtKGuKii4YF6O+bZATJbhwhZjjWgCZToLOzvh1n4jXGiRJcB5EIdixRinp/4/Easj0QLpaxLhz7GtVZ0fuWGGHYLQhneTum90d/FO/14ciBj59yaxdSNruVI+mbQXt9KMcIq/jcOFQG6+IBrIZY7hzpg6hBWLUg3hEDDPv9rR1g2MfkaOXVqoehpzf7Ghn0N5AR7+N5AACeeiO6qn3gzbfDI/sT/YEnb4N39rv0Zx9w/Ifwts0DAADwnKO3wx9snggAAM9c/zG8YfPksP8GseLbSOZ7FF28h1aPwe/e2e1z2m3g928/AQAAjuwW3np710dnBvjj27u+V10P77kd999u0ew5Ft/QOV2vqZJ138kZ3DnfPWD3n5zBY+e7sd06PoNHz3Y30/FqC4+d7bavV32oD6CrRlhl6rohKEJdN4RxGuNgc+4DfBxs767j2O8gdegRRSkiMUTooCzEyZQVBGV4WAOacIlltwKSKAQASEIF7DHQIY9D41AablwGpBQZtL/hkzGK0qOoRs6a0JbrUIKADm1Hk2D4PTZqV4mpIckVAHbfZD9OG8fsOhPeH3hidgSihimqCYBsZzAyFMqnK3IsJIkQthuw0LMyYO/65AoA9k684PYcXXwfU8RTaOMxQoYM4bL/e3Dj33IgLmGFhrKUbMCYqEKU2oQapP3DpKuRY2b4PpodTVzNrG57+ondztLvdMk10baX2Lq5xX1TsU4YBTFntUrRFIVoGiF6v68fM3vM/kvJkDqqA5KhUInNWEgoDapjZEjFkmSoEGo/vowzrjGQhAYlyRR434wMAew+mETx0dbQIcZ7DJxd3e5Dubu9DecIZ6EDAODZiYirFpkdxESDnQglwFDMUMcntAoSK3BShElZVBlMLK9NUFCGNe1DdZnb0GtjhmgY2W38vdtE8mM3Lhgdpk/c0woJNENMlOBVKt93sIHdmAx50DghSoZCfROP2Zk4c+0MhMVRd9tRWSBDoT2cAruT72ezNeE3stYPLvdo3Z/BkBggp2Utw9udiX87CMH24AwqI5LkTFB4BlROwVp6fENv4WivSDgHcN/pzsLtBwtPvvloKD/r1rsAAOBs6OADb0aV573W7w7lJ67ioqs3TLSU/2DzRHjmeqfyvGHzZHjWvvw750+BZ6x37f7/zp4KT109vNt+9lR4aJ9G7XfvPBlO0aI6b717fyi//U7MRPfwGXKxu30Cqz15vHu2DurL2dkKTk92bZ1vVnBrf6xn2w7uO6GxRGt0LjGZ2aC1kR47O4L1XuW5c74OmfXOt11Q27aoPAwmlPveEkUOu8xtkMvf5g668e90YPYPZPeohZhcIU5SdHchvHPsGVAVEl966XsA+2cWh9Rs43OLEyqQpA1n8Zbuzimhp+sUyeQHJ22xG5QoYRsVV1KnH+g7ljxa2KBC2weUqAEpMaaXiZDZDsC9MEyJ69gA0e7ASRCUdfSIGx4nRRgKGQLYESJ/XN6LwmwG6E92+3SbIcRrdWcD+e6RycUUKfLHKxCjYjLkkcuqJ2EKGcoBX5O5yRVS408ld8DJN7DNIa0lxaHY2jhZGS+r45C2p/rLZZdLJWXgfQLMJ0Xsuvz073yXdARJTHeZK/DvLCJDKRkvtT+pB3I9CzLDzY0nV9ZWlsZdcPm0gAzpLHwBMkS25/clYQlDbGuUTIHcoKiI42FQUCwmQ9sbaPuJCYpIf2xIrMz5/cg4uA+RqRtohowHvmqyN54t7EwYM08PTa6XpqQpfusYxrHse+y8SvtraW55YgTSzzbui/fnyTZwGzqRlcuEAGHXTXaucawPNqz0FOWoDnOfi9eKHRd2rVNIE8lMd0SPtT+ivwXVCbu2rRyJ9Rnw+jTYTQ6XyTpDqD7JGudAc43DfxscM6TED1mU5hob19a6QHxwuevc6FV4fBLJhidDABDIEAAEMgQA8KG33hrK738ckx58wPHb4Andbp/3Xf0xPKWL+3/8aXSH+zOnvxPKH4vK/9eNWP7TN34/lD/kRkzYsDY9PGsfc9QZB++FFKuHTqI88uBNFNeE4qAeuBXLT8BrJN2iOawfOL4LN9Y7ieXW0Rnc3JdPVxu4/1iOq7qFCNUJSkW+RvFDK3SNjtB2g34zBuAIZarDCRgAr1N0A5VxQhAlacLQxWfCdXjShT1PI/dS1B5ZUwu/41GdNb3BiNKtrK1G11+zch1tzSIT13jjWT6dkiSGxJRq8aX8m4JhDHXvIusOKfE9OGCeLBCOJ3CZ0e+PBbuvMQzIjXyLXOM296EySlaEy84Y6E+o0hTKmHQlgvpVMqQBu8wBTLC/Cu2yElcxLQlBSVmyr0qUnpJkDZrygo7FdXb07fUoS6SlHAt3xSvob0RWubKl9YO3F8Qkac+teo0qMU0hev9vyNYpJkMaCmcAitJsTzlBKZc5qTonQ1qzBWRIzf62BBnCp0JSPYCRIezOMDga5LrBFioqYqMWZ5NTyBCOCeHHSIL+0doWK+zmdRvNaiWCXp3mj84/oglXQrFdTQ0i5Emvp7nb6YuxxvrYwBhNb7BTgWdnV3flMlkzZKsQJkLWdaKi7aPGS5Hsc2j7yMBC5YIECsRYTCRW4BndHFZSyAx0/qZwJCsI+sE6uczqEdc4TJLQPpYoGGhfLfsDq7digf43j6OPFXaTe8aNh0P5/W9EZeh9jt4Ryk9fR8L0zO5ReBgx02PEwgd08e+im+UxFy/qO/tboexd7wAA3nT+BDLeN999MJT/UFGK8PpFGEcrtMDsis4uHHfofcLO5YCu/Z1tPMa7eJ0k5Ka37eUHAreL27TGEQUKr7mElSKD0nCvHo03zuo2agu5zJGJEHZ7aO67HGRCBiXDIwkUUDIH/L7hf+N3C3nPqMkV8Di0STjqyUCg7E/6UJQiYG2qiRqAvefwecXHhfcniSUKkinA2FUuDBOXcWY+ZRzYBR0MQIfVIVw+Qxd7Q58Vk1K0PJTZ/t3fheqQR2kgv29yittYCXL7HiIx18hDqsIgTHWtTYzaxFqhKqnkBlyB7V2aVEQpa+P/6d/+5/m+GaZTKQZn4yzNJDKkqCmzydBU/1BpdoGpQWFW+YLJkJRiW0u5TWDYx1D44Iw+PP7Q2U1ntliiZH34Wf119GfFZGhz04ZztrlhgsG7PTUkc1p/ZGBzY/f30AGc30SKkidUgwtuAQC7mcORWgT7c4L9yBXi5Ayo50UqA8TjNQ6RAwfx48NuP64aeUPDDMg4MLHsDDImDF1o0W83g6PkdUtdGTu2Jkl0T4lExPRx+85VbnwfpbIaEmXJKMk/EkQQxyWFuB6UTGH3dzzHJOHEGm3H5eMYOzUc0WuHyZA7GggBcjjBgXVRubFR7XGdi2Xrwv6uiyrTbDJkXTh+jQxZ6wIJ2pX39dGri9fjZOj0aBMM8weO70K/jzV66ukjsN1fqGefvgN6Xz5+O9j9iX3O0dvhxGxIew/sLeanr7bwxP05enLn4Kn7Y3uC7eHp+xv5QXsOz9irSTfNOTxz9U4AADgxG3jfPemyxoUkDRy9M/Ckk6hGPbBXcDrj4HS9G8fRahtI0M2j8+AOd9/RGaz3MuwDR3fggaM7cLJ3z7v/6C7cWkfV58bqPPy9sgPcd3QWxnZjjdKWE0WoD3U8CcJkyBgHHXNzXO/3cS7GdQ3OQOeVot6ENZVMbyLhdzR1fFBtDFJqLVODcOIPrBp18R/A7h1EJykg9BkmZRxd7wtPZPC/B5REIay1ZlDiARO/f86a8I7ajWNfRokVOIg9ghUkYBNe0ow5XxuRuVJr317Xmfgcd8xuCIkeUP/OxXWXEm74pO91FwgVUYZurMI3dXsaEyr0pzFBUX9kod+nQnedge0NbfYKQqIFvI7Rbt0k5MblXN4oz7li5dyqMEoUBGtGY8J2qWqb1iJ3rTT7MWNXku1a0gQQbOza/gSbM3fuxOMtJEPcHhgthYPhr7M1RenRU+OvxWRCVCTDlaRNBIgnUsvSwcqpE5o80bVQ+wCxPJsMkbZwHb3NFDHSoKYPVskSMhSNYTFESickOYBAZADg/Fasc/aA7D4HACTzGCFFp0jxOaIvd/XBIGlcB0L41Fgqly+TGCtSRvWZwqals9XKHfPZ98AKj9lSYtSduxEZim3jscllbT0rgGhYOWZk6dkScbtyWY2nc8wgI1nwxmMCAJpsggkFJGYIrwdkI8kBAEpc8D7YHW4ll4k7nBKXtOsjFjHpIWX8DTLKdqW+MfQ3ToawWnKKDPsHUTrtpx5H17T3PnpnKL/vOqpEJ2YDz0Ruck9H7T5nHdWNZyP3n+egOu+L4o/edxXJzzOPYhmTomecvBt6dPPg8XqyArAjQB63juP2B5DrG04jDgCBFAEA3Fqfhax6qX6w0rRGpBYTHk6GcB38G35NrFDGOrzoK76HMbnHWQ9J3B1LvkKfJ7kMACzzo1ZG73vsVremrsijzJGoXhynXNbWSHM4zrIzum1SQoq0d1dnyDdt9O3Fk3ArxQZSlntQXf53D67YB84Mh5WhzS008XgLfWvvk7dvb3Thndufrsg3yZF15TKuYhJKvWxKSEqllxE3jouWM6m1FxMkAwDKXMVK3ckQisZfuR4RPz9FNr3q6slcSBX7vIgUSW0LZdWVrhKT9szeXPhB5jdK6mHAKCE8A/rNoXTQAyT75OpOiVsU3lcENxYLZshFMuTi7PJu1mjcVUqyT4Ib89q5lzLy+Eu7jSuOixndXHyRmsHBdq/emN4FMmQcwObm/txYCCqQFEM0rGJd6Vi2NzukAHQ70oGyrMTjFdSuDmcfMpEIVMwyEOUIZc2hmYzQmFE5KkvjfbDrWofLZ1Ex6M5i257o2G0kOt05kJgiSVkCg9o3VKHy4D76AGMCJMYTGfS/RIAcve9xFr7QhM8jgFzzdirRfpZ0b/CZHpWHODtuehPLw85w9MajcZQM7U6MiyRIUnrw7xZdfIu2czmxY+eUqE/oWDUy5Os4E41mZ9CrzyS/5Ty7mQdWTfrBBOJwPnSBIJz1K3jGybsBYJcJ7n2OdwRog6zrYX/hnt6dgbdrn9yt4IbZ3SQP2N0FuM8ewQ2zDttO9gf2BGvRfufQ7W/wp3XvgX5/op6xfue+3w7e62g3nrNhBU893q1btEVWu1e6bqzPw/la2wGO9sqLMS7EB1nj4P6jfbpuO4SkCLfWZ3C0f5BOuw3c3BOilZBD/+b6PPR5stqGzHLrbgjllBujh68zOBPiifz+R0fbsJ6SPd0C9Pv348kQVVKkhvbH8T0R4oZMJDcDUoPC/wZNLrD7iSY9gdg2UWb3xzogt1aHYoqEU0CWN1gBer8Y+ozg7WFM2AAUvqUe+N2TIkU+UxeJ7+GGmoljsmybZvfwWf9wvDb2KSV/UghX7xdedZEMGbf7Fu7aiuvVDR39rnqEGF0DUSnC7e3dlobjVXAZdOtVJDl7o7cqfqjUDuS/BbtOUdGEpTNyKF4Gpha8He1YcmSKjTWoIGgJkyx5LDmu3PFqNr1Ehvh2YLavgCQpwn/j47ZKGT8vE0nRLJc5NSiLl7WLUulaNzq5FuIDavBaM3S7On7JSBPKqmscVrZIu8qYlaHQGXITjGa+ng0GieVxbvS3VB71Kb3MEi844rutKEj4XPTHXVBOtjds2P/8ZjyuzU1DjOvz+41Y3iA1aYNUJrt10J9GAjYcdVEtckBJqaLuqNv5grOewPQuHAsuw+BAzcynqEbqookOYhYnh1zjnL4AIk65i8sAVEUivvwblHmpj6REy0YFMCZDUrnsXo/ne2eQyPsQGLnscCphlDJ4OHLIrW5XpqodNqrwtDxOc6jcIAbiG9Sg8eAyf8MS9Qk1ZVm7qBweL+NivIlxzDU//yHHRjmPjTlZb+F8H7ty39EZPLrdTfM/6fhReM9+wZn3Ono3vLu/EfZ5ShcXUX2yRckYukiWnmjjAjnHJsoVa9PBLXu8H4uBB+yu795Fd7vd/lG5ebCL5ftQsMotpN5gZad3NrifYQXmuNtG0rQ6JzE8AAAPHKEkDOs7qIz7jMe7HSycrnb9bvoukKp+sNB5N8qaWbc9sKrX9zYoRW5rwZzsyV1vYDhxscyShYSyouyQmD/+3bOUCIUJCwdBbTIDU6Eq1SQwyAXOmFi2dHuZyxv+7gJFeGwcLYdJGGZspwx0TF6ULLbJSVdtlluze3BsJfKEGE666JJ+I04Mbk9i8Pv2xJIkF3hykSQ1Qi7tOO7X9AO4/d9mGGJyB+8ypxmeJeoQmdx2cj1+TTR7ZoLqoxKoEjUqPQMl/50iJYoxX+x9VULoao+rpKxxAAlWLifX58IkTHKl4yRsRkIFPsSKvRgrqz1xAPILJ9HWKFixZOTKw6NN1qVeYqprXIIM0U7l8Y3IkDgwpUmBCAW1gZVxW6RPbvQjiKm2jaHGPe7Dx59sHfTopUoX88MnFRW7mBGpP44f2e0NE87d5lZ0v9jctHT9CjZ23WUOwnnerXxu4v6IGIRzgYhQ+M2XsWsbXu27d6pqFLdD+ICZPp4Lg9Z6AqCBrytSjkpYd4ZTZkMIeDY9dZkzgxuRIem4UsSkZL0ldd8Sm9DFPiwiaDh9t+3jS9RugWWyQ21pz69vb+3Pi4lkyAFVejQ1iLwPlDI/XoX0GCG2yDmjnlNsXJeQop2C5EIdTwy2fQfbvoMTtA4PdgFboRSHJ4ikvLu/Ac9YvQsAAO66NTy125GGjQN40MYLcGp21vkKukCGbtgjWJv4bjg2sf4Jev89YDdwd39hn2gfg8f2qc6evHpPWKfoSetH4bG9f9aDR3fgbr+rf2N1HmKdAKjL2hE6JkyEBmfg5uo8KEGdcSHV95HdBmXoJiJft1ZnsB3Q5IzyYdHIEN/u/7aI+OL1igB2ZCgemEJ4juK7hcTJdSCTdlwGnUzwMnnu1kBUWxLP5+L2OF56f2vuc9IC0bsykO14/TLtOFTPCrb2Sly4G7n7SbaJaqugptXFwuMEIVhLJ0Hx0FC8kV9M1fQDDChu1scFAewIUNgXT06uTbhH+uM49u2pDe/7Hana/dHfWNOECdryJSDMxuc8WPh50yZhNYLKl3aRjPJCkpAkRTk1p0ZNKnE5NGyB4RzJ4/dgYR/i+FOK1UQyJCYYsXKZZq217Pri7IyozAmiNv4KTCNEnLlpJzj0YuT/eT3exx5q5hat3oB+Ex7OCZN1qP/Ew5W6CNIzb1iqZ6xwwZjIzAEhTtzrgxn9vo6Uatv0KO6mH5B7XXyxDUc2EAQc57PZx/94m2R7Mx5/fxo/sMNRJEfOolktF+OO7BZgc9O740FIrGC2Q0iYgD9GdG0KP2aIyRUMJVVaMoUAF//3+3kCaYZIlkzvAnEzvQv9Ydc+cEhxQokVJKWvOx/CPp7c2D6qRt3GBRe47pwqInYTx61lk+MLuuJj5dmowvgKn6eRvYjtEOSaGdzkbDynzkJUfbpI4IgahFQitze+7CYaAnhx1WHtAPx6gx2aJeAKDjYayfELD6Rh/3MSxevt28EKEJkk2BMcSWR2yBCXSBFfKsQvyGoMhIQJq66HVdfD3c3uBJ2stvDYZkdiHjzaZZl79yYqPO/a7hY/fdrqYfjjfSa4J3S34ZH9g3ufNXDX7U7qsVnDsD+YztCXtidEm33dNXRw5vaEY/9+ve06uG+fJu09wwk8aHfjeef2FjzQ+fJNuG+1U23eszmBG3uV5m6/DokSMOnxpMYTj5NuG1ztdiTKhJikIxRg1xlH2vNE6XzoQmzRWY8C3PfnlydL8Pv7MQ3OhGvhGDnz5AqvVdT3NsQQuc1+P+Ty6WOHiMvowBZuxu5xRi57kOQxJpbDe2CIRMz0kbzsyr5/RGocI2583bd9PwCMSKiKNN7PhDGL7nMOfZ/9cUgkBicKwHGlwto7vO8w7oS9E93NB5CSK+BxOewtsu6IG5v/vnh3NzM44jkBsJt8jGvYRdc5Z2nyouDK3rugFNnNAMPJ7iUqrpOE40R4coWcMcoTLdQGwmO7zrAscpXZgQESpKh0LP7/HHHStknjKLGrpXEobRePn5cx0ehsvFYJl7RRLDt/TlVCR9sg/3M3Ob+/phpdKCEKeyckPHWfyoubQmm9OekVMUpd4ypR4F6+7yRRTv0W+kmQIjweLfUpTkuKZ49wakZ0GsgM1RE9P2StjGhzwfaGVkYvcJxqGSVsyL3YtDGraViVRANETWEgCRHO406EgGwGuXwubyfpUWG3UK3H+k5sd41SkeMyAHOZwy53ZKFEeizqjOqc70cJKeLb8T74sNT7fOrgassKyUnVK4FyXI4pQAMmRei3vpfLuD53E+uH+k9Bjw5yINuRcoHKngDxMscGtXsOKBgcWfYbZCVvUPzQFm3nCpAGruxYNOaOuBkWpBhm6NF1wWoSLuM02zhJhKYEcpDsiCRTIq6DyiZfnvoMiSQDGJHBbnUK8dn9rfymjFkflFIGYO+TCQetKkMJjxjcpWI3UIOSxR3tQVJrM5BsrSfydlwma0qR9eIqXKIwSox4jITXzWKLsM6w0araLRyj5hpXpPqUlEvHogoZQpwQL7N9HJ/kECYtkuUu0RaCqhol1usqwUSXuQST5Se9xE8zs3208rTCAA1TWNS85VNe9nPJkFSFj4krXCAYpZj8SERI+i1DimhigFjXYgKEXcKElNWmR6uLb4bgMoeNb08KNjf9Po6QHh+Ii1PB9idxbNubJriDnd80ob3tqQ1kAscQSTFPlNS5OLPI3e+U8xiVHCfX3W8LvyMXODOg84xij+wWKUTbIdwXxCXPu73t7cjVXReUtp0StG9r48J5sVtHFCPbY/c5IGUO4grpH+8BmDFiyHGXIvX8mR7HNMUPhe3jPWE3aPsmGkukvPdsGlYu3DN4kVW7MeBtbdObqOAMJh6jRt5KyQ6xkIR29nXC64PV925uDvN4rwAJ/bjBhFfKMJhQlxIkG9o9367gfLsKGdEeOz8KC5C++3z3YD6IYmgeWu1ieN62fSDE8/xRfxNu7iW6hwcH670adNtF17KN6wMB2rgebg8ouwcAPOqQO97+WNdmgD8edjMlJ3YDf9TfDwC72KF3bO8L5Xee714mp90G3rPZWX4rOxDFxuN8T5z88d/tV3C0X3Pobr+GtRlgvX8YtkNHyJAnKivbw539wmlHtofb291LC69d5GOIyHpEewLEFSJf3g429OEgElRrHWy3vjzAcL4/Bp/lEKme/j4fVjRuLqgMFoqeVfGWdvH2jMlnkCLbxXcTSYePkqG4jqbW9yCkiHtfMVJEVGnfloHwzhwtm6BM7gGkJsK8HZFwmfPb/Nh8cXCj2W2yi28Pu8lZO1rrKGAV1RvsMheUof03YnMDLXFBiM6+D5REA6/jtj0xYRKvP8WeHR2YzV4VPUbPkjc4hwHCmkJcpQkHy2xDvF0qS3HZBUShSp2SrkntwrILoCgVuGZXp+xtCdp1yO3jUZLwAtCzatE/bb/UGHH6evR/SMOvqUaSklWJ6S5zWKrS2H1p0oTMxRrJbyn5OjVm/OeMZ2CSMqSSGPmlrJEiLU5o9BsO/Ofr3pSoIOjFDn2UxHfuc/syIlJgTVgU1a0tdGcoPSxOwY38yLHq0x9DMDTdKr7IwQHsY7rBbnakCGBnzG/w/if6rMXIHdCTIoPKlp0X5RxjkLghHkOEzr0nlmZwhFDRa+L7ZSoTUoe6u/Re8cqRQUSHZJnb7Nz1fHt2E/u0G0fuQxJPlEysgcqSS2eOsIc+5DIYE4geX4speDFZlBnPslTieDkc8gzR43AdgNn4F6sLWbvAwI4UScclHEcVlDYcdnPzfTsDDsWODFjpIWWqiHgVaBhsVIScgX7rXbMANptIDIxxcPs8PpTvvhvl2rvoYb2NrKj77B148+YhANil2n4bSrTwjt4TnwEeHnbubI8OZ/DosItNeni4C7cRAXonIkd/jI7rbf3NUH7L5iHo9hfzTedPgPX+JnzL2YPBle2Pz27Aar/du/15nKFFUzFRskT9cfBYfwSPoeP0dbFqc6dfh9iq29sjEpPUE9VHVoMwUeVlHyvU9zZ8Fjabjn4ucbIP5T40WxOyyZltTFqDJzS0ddU0MiSVDUrbb7cQrAm7daTPMJaBJm3R4hEJKWLvjFDPoWNR1X7hWKR6pA+5LdHmwCTMwxryXlTtg2GIbujDQNYjIhO7g/+mduF7Mxx30XUaaMwV9sQg6c9ZmvU+ZOF0sDn1k0sO+r3LXLcZyDpHJNidG5ultlipqiH1w+tLdlOJLcbGeplkaIRaNWcqcm5yGhlKjGWUJTFFhkv6J+oU6oektI/FXeIV5DI3MbnCPJe5jj0kmNVXJk0oIkOjH+kLaxRD5OsobRSTIuIDPOOGVGeJy0gRIT8sgxkN9pfVHHEWzI9F+SiQmStcRylb1F931gf/5NVZJDD2PJIh0/N1K/Jl7BO/uWECMehPdjNc/sPhVlZdSVtz/xspReEYnfixJHFB24FmmSPucGgtEXSOLLk+gLYj1ed8CL9hUoPHAUDd5FZ36M2N3ez4tddImlif/6bcu+r9hcojUoSeLWRnUoKobO/OqVLkP/72PMZQ2M3OOKSuRPh5M0oZdOR8dvjv+FRi2xaRAUyEXG+D65QbTJwV701oexgscQnrN51Y3pzHB+f8nCoot8/XIS31u++ehmxtb7t7P9zaL3r15rOH4D4bFaO3bR8M5TfvY4oAAN6EDOU3bmN9T4oAAG67TSBD584FMtQ7MyJDsRz7e/v5faH8rvNI4h45Ry8TiGRo03fhPN7drgMZenRzPHKZw6ToDiKFuHyO3PSObA+39yRsZQe4s4/JMsYRdzic9AKf/w26RufkGqFsXwag3ytOZjWAO9/fI50Dsy8PayBxcqSsvbsTkwbj78J+s4lkyCGVaFcn/1GlrnSx3xEpQts1cqO9Cy1TXHTSFI3pJBmqxIgUobjVoKzAngxl9qc/xHPUnQ8hw2q3cSGhghniNxWnWgdg39ROLpOsdqerMNk3HK3i2Ffd7l9tyutaUlRTrxL3JBnK9ZciQ0o9MWV8TT8plz2JOyAFCSdjAGCEaQIm7S0u0qXJd0tfXP7+kNJu43psNmE0jNwzwW6KyWsASciRIuciIRkgHhP+H5+PAWJ9PE7UhvQxIMoS/ihgY90HtxuaZW70exfd17YnHXR7Q3xzakIcS39qwsKi/TEgV4v90A2EczMcRSNYiila3XUhcUN3d4BhbcOifXbTRzVrcKMXIDm+zRDOpbTwLF5Ulbi1kcxxLpAriVSa7UDOc0zGICtIIUmDi+TKDNElDoboSufJQXc+hN/NduxCtzsvsktfWtHxHz7hNyWjoXSspOycmpqco9s48DPCdhONKn/8zsbFanEZLEB3d08oDIA9M2DP9n9bF1Si4AaHiAkgAhL+HyIRGbnEqedRIEWhPda2r4JVIz+mIapGbjAw7A3eoTcweAWIEKs9ydhGtWi7WQVicHa2hrOzdTj8h+/spNjODvBHd3YE56TbwJvuPggAAMd2C7939pRdHexOtv+MvLm/BXf3bPMPewsP76/zO/dG1DuHIWzb/b6r+5b+GB7ZZ8H4g+0DcHdvtf3B5omh7T/YPAEAAKwZ4M1nu/GsTA9vv3trvz2Ox5PDx86PgjqzHSzc3ZOjwRl4FBGn95yjIIs9HuuPYNjfFOfDipAhD68UPbY9Cum9b2/WIdX2OVKmttsuXgPkSodVIVz2JMk/TltEmoazLiT/MBsb0sLbc0PdR61/7vc7GkqARvc2m6zAypHtUXkL8VncxneCf286G9/pu8QovswID+zajO8U5C6L1awBr1GmEBuBDPn3j+3Re1dzk+Ou1GGgie+9d7cmkxzC+w9nYEXpvbHLNqDvKxnH3tby7msAEL+vp114/21PbFDN+yN0/nlmwdD2vtsjE7wLtieGfLsBAOxZH9Nub/oYu9EPu39+fEusR6TZhFLoAzaCg2qYGQP7XSQnWAmc4omU6v6qkKESlJIhY8ri8CaMH6s+zlpZATKGrg2GxzUBk+mUK0mocKiLyImAYISFekIdfqPPcZ8rhbo2UI4UAVCVJiHjY+Oct0GUD/LxGMSy9uGwPH4Iz3BpL0VtM5spjB26XeavPbAtwjOdadDUCq4YxSxzRj9fWnptTenhRMuXHSNbmppE2o11sBtidxerQVThoinA48eP78dThYcyJ9ke5N5C7Tr+G75f5pRR14a69VE3OXweQSwb7EoHEIkQAJlJBwBKiuaU8bnjRMvDGfo3Sqvs0Lh8VjEAgAErQGf5sustDGj/LVIeAADu3o0P2CN3I1F411mcgfjDs/tD+Y3nTwrl3zl/SijfHo7hDxTV6H9tIun4n0jd+Z/nT4x1zp8Wyv/77Omh/LtnsY/fvxP7ftPtB4ky9s67UVl6953Y32NnUfF5BJXfcxbrvPsMZXYB6uZ2p1/DOfI3enQTz9GdbTx3dxEBwmRoo6l0Z3HfftsFBQgASBZBQobwtUP3FH5WsIpKXFyJkkO/e3RtNCAgbW/k7eSbwsbC44JqoH0rR2p6IG70Y6O9r1UPARJ3iiVcN7YhBvpuz41fTQ5D3r3xB2cMgBCvG37zZW35A/J9HZNRgN1Ek1+wdXXXwZBI1FALdY06gHpSNHswBUaeEnOulmu6r42lr62zJGrI0ELgmek01YeUSWIFvH36uIxz9Vf4+R/2/8INxB9mxvVoSJ54/Pxqi5xxSQ+Pk1wErY95N4G+OKr2IisYk9hPvg5d3VuphN0oMIFwjBDhlzdyn+xvxg/92YPI5eQJsc7ZQ3Ec22jHECIEAGE2HwDgKK4DCSfvHFA5fs2PHqaWrz3DVnVsm2R4WVkQZ5wYqDujTHC1a+osTbGurj+lzXJoH7fkYoRcmSi4QZR7j8rieDuohLckKReJI8CuGijTEZ+cJz7zyEMqrL4OAFuSuRCRayYGDCfoHl6zA9GyyJFJDO1Dp50UVLaubH/FyCnpb+TB0CGX1jXN9HbzNLLMJ92Ki6A+6+a7QvnZN94Rtx/F8lNW8eF85urdISECAIT4HwCaKe6uixfWrzMEACGlNwDAOzaRPL1lrwwB7JSiN92Of2MyhEkPzqxnURrsU7T20i209hIAwK01XouJ3sTnyAXuMUSMHj6TCRgmQwN2hVSue7fqCTHCbnaEDJ3FtrrbqHwXkST07iSTA/xWccpv/HFQSJM6ITEiVnhiCm0nCyXLkyM0XkmeSHIG5LXzANTJRtVNTnFlE2Hzxhhpm0yYxYMnZAhPMq8suDUi1ffF++v8QUSwbyESjd5/OGkFPnfr23iyzZFMpEfviReye098L9i7NCEKbOKFweey6BsKUEY8CshTMrGC8t0rStetocIOrCZDF0EQNUwhQ6XJE6aExZTYqE5+bl/3a/+P3m5ld8V7aasrL4mkm5riGkf2Sb3ohBkckiwAQDV+S8Y7Wv/Gt4Xdq1jSg1DHya5G/m9cxguA8n5Ie57g5NzxfB9EwpfJEP7NrSzYvZLRH3dBvdiemPAC7k8MrPahBcMaQkawXZ905t67gHRnMRB0dduFTDrr2y4kVFjd6WE4smGWy573cfy9U4keyZrnqNtbdC0b6PnF7SD3M08YTT+ILoehj+A2hq4lviY4Nql3cV2jAfUxUDWIry3EZ0dJ3JNUZmMRY6b4djJLHA0dstis5jI3oDWaBjR+x9QgZsx5Fw9n4r3jDEo6YQD2y9PsyndMKHdnyJ3OOGI0mnNF3cEqDnaZ4y51uIzro0QJmhoEvYkz/gPEcm9iJjFc3rKyV4A2NpYBYqwJMMWpt7C9u4atV4ecgcduRwP/HY/uCIYFB2967MGw/fdu7xSajevgd86eCgAAjwynRCn673efGcpv2TwEf7DZqUBv2DwZ3rx9aF9+Erxt+8CufP4k+KN95rjfPX8yPLzPw/+Gu0+CR/eM9/fuPAnOkErzhseisvT22/cFReddt09huyctd86O4Gwfz3O2WcGdPVHZ9l1QwnpnApnpnYXeWXgYxSRhNQiXH9mcBJe695wfg89cd/t8Hcrn///2/j3ouqWqD0bHnGs972WzN5vLh/JB3Kg5IHogicQyFQkhBJSNVCpWKokVy0oZQXLhU+I5lSCnPDEnnhAsySdWHRNFOBKj8ValEZOwJRVNfWU0URSNHj4uChFEwpbL3u/9edZas88fa3X36DHH6B49L2ut53nGr+qtt5+5enb37Nmze/x6XPosmieu14ugzdps2hhMYdMkQTJWp/EZN6s2mD12p4s4vhAZau+1MfriWZOksYkpRuI3RAIjhO93nX7P7SreJ59nBoBN6ZI6E9IT823Pu/PplDCFc/AUZIj+1qyQWfOmY02EmzWau9d4fsfrHPTN0jNcKczzaN3tES1v7bPZQBJYAZdDtVP+9pMWFve2HbK52gaTdGz6tjmJfbb10YrzrR8fi7N00wnLO4u7yDzv7hrcSTTbk0zmtnU1yf8csr5GkiypIE0iuaEWNGjtYfNrUXGPaE7IlTFkE3MqHAMZaoU0dclp4//JJsTAYApclfu6c4tK8iRFUwMAnfncBhEGTv3t70nIDypXSYrE6GSS86dkaoUFdo78kHT4He844bRAACQTrrTQJh522kB/wfDZ8KaOaDYV8yyjv/VWsA0LY5OYMbWC2YdksrH9WyA8EilabdJxIJpUlM3ketd9sZ0jdQj1SSZ6mTOLGuQflO6spsRsIZ2NRO4J6ZwzshcsiFleErEueZbydSm9WJFFG52fhAl1csYS2vjHO+fb+1F7TyOxac6aOEZQ4ILtb3HSa1Y43QhpNEnSgA3+b0yEAADQ/YDqw0Jwkr6H0neRBgERI3fWBjLUnS6SoA0AAKs7ccf51u2o6fCkCADgo7efHNLvvxVN2zwpAtiazz26Izb/4+x/SQIi/NLtL0Lp58T0rZj+r7f+eEj/5q2HQvp3bkbzudNuCR+9sy137Rbw6B0UXOEOCq5wC6XRM+H0Yyj/p+8gNTUAPH52PUTZu7W6GsjQWbeEm8j8D2uGcLS+JGgCSmNzxfUp1h5FYtRtGthgE0mUD7/v9i5KIzKfpAkZ8nPp9vDoXXpDND6pwiz9jlC6xd9gRjMU/FmaNDhCI63bgslfjgyFuckBifiJ50wk6K/I3O8hbWJxxCikhbb0ysDzKp9OZZEuRp87WwffWIAtGWLr6/h+bBOZAzVpiXx7rzaBDG1OWmjvIu2PIMtQaLQhVWGy2Ur4+nskRxXwpzKtaEcVak35hpQ7xIqrlgwNaRcFIjmq84ukM4tGkKLRdGqwydyAl8yFmQ7AwQQS216BONE2UGe6cD/KLzhMcg7lPS0NKS8JdbrBu0mMMOqA3YnuaY2wdmKD0miHCFCdOBgA7ZOe3w3jFJpolVofyKALO0rLu+tg3nTlVnyuk1vbsrsTRIrQbn+DHHi94OqWAMvtAfWwudLAlV0ZmysNLG/vJvErLSzurmGxm8jxRxL7gGpuBOLk+4KZVBuHtDSO5N/9jzVAMS8TxQ2RpCRAAx4fmEgxJiHbAAxIq0UCM/jFEP8fwnx30jgUFhDfRS7tDxqUA7djG8zD1wHpuMF178plSZFzyXWKxSkEQr24F52zF/cip1ncbcg9UXPTepLhmkBkmk0TCI4n6M06kvVm0/DX1w00m5hn2x/ptQZrgxjtbKIh8ul1w2uOsA+UpEHy5Grdgru3c9jvmhC8YXX3JGgzMCl69Nb9QRPy0dtPDlqa37v9tG3e9VX48N1t+lOrB0LQhT84e2rw/fl95HP0kdOn7X5/Cvzuvc8N6d+7t8376NkT4SO78h5DUVRu7877+djtJwWztUdv3x80Q4/duR7CXt+9u9MErRaBmJydLcN5PnfvnYS8N+9eCxqlx+5eh8fubknS6XoZfIzurk+Cr9Cts6shctzN06gxwmZyp8g3yPv/uK4Jflw48IUPhtGt25g+W4DzQTJOF/GdhzGKyJBLyX5iMkesm9o1IO1IJCRUM4Tze+F5q8HFafy9QkhTSEJ5qjHaXneNQICakmYornHtqkvns/C8/Q2rxqH5n1hMYI24/z+7EcuY2KWyA7POoI3G0Ab8P0SytrW82L6M7soCljvikh6ouv1/eeoAawfxkQ5hPd0Nn+U9FzRFyztdsK5Y3NuE8/wwkWy8iZzfsdeYFuLAW/5ROVKkMZnDvzPXOW2MSJS4+ujvXF7aDgWyQSemJl+a5+Kg0bLl5OlSm1j5ulBeyaxQina317DbSCAeZTI3AcPWmMYluzF012fDDBjSNo2mKKcNYgXbzA6GqDWSNBIo1LQvKxFMfV5kptdvJ68V4Mjc9jqk8BqkRRNM5gAAlndQIAC844928oN5E6S7k3g3cnkbgvnclVsunLdwcqtLds7cok1P107ID5rYFaQo6UdkXrGtiO87EMptBa3Ltiz0P2fqSO4RNUV4B/QsfUELLERQMoNIWrKDq9h5TLWdZNx3mIClJI2tIwmjzWu1sGZoeZr242I3jlzThHRiPgdbgVESIBd4911IJ8RnxRMi/3e4H2l0GpxGO/lJ+lSob40I2lmbaqmQdqi9w6eb2yjU9u007DZsGljf3gryzjVBw7JxDXzyJgqpfetJIf3bj0fNzXtufH5I/5cbzw7p/+NG1Az9H49HbdBH7vwv8Il7DwIAwP+489SQ/v07T4FPnUZtzW8+9sdC+gOPRbO8P3j8wZD+1I2Y/9atSObWyPysO1sE88DNegF3d1qx9bqFm3fSUN2Poud99DbyZ0JapM8g7dItFIji3r2TMDWsz6KZW7dq4xlTANDdQ9qhe6idd9DZL3djukHvcYE0Q4tTfixTMpRqRNH1RIvKp7flpYc/c+ZztF4pWIpGc5FqrOMGB0eGYt0bPp3Ml6iSdRfWse067eeojszvqa+dLE/wcz9Lhnw6mHST9QXfLxypIZlLJzKZiySXagsTLTvehBIPrCXPVEOGpL+HIhM9WKUNErRyWcxFirRmcrXarFy7uN+GHGYqaHlr6teEmO+F4xba4jhyXYFhQRW+9B9tExvhoWqLpPaiA0P0BWjUbQPuoQewsZAIxABVpSagQt9BlhDE5BRwzKZxZEC+fhBIWiL0O5f0ow/RCQCwxsEVnoycqZ8U6149EO9dI4d3LJh7zRDAVruETehwQIWrn02lgPZOXAGSRU2KYIL6pHFxx6HZuORdyJMsrhyneafbJMQq6ccE0jiQxkpGrd2rUwgYIgU7kOqUxvo2dCz/AGmUQb7NOIBCEmgB7Yyur6bl4+AKGxxcIQ0kBptrsZ0dOsuzW2IJj216IgQ26wYcvkd4X+k7qpsj21UDHQ76IEwOUrFJ9mWayV1BhPO+KDB2mwbuf2K0a33KfSh9LQZdePBKlJ6vIKk2Cc2NGrBGh5589PaT4XOvbwMyfPz2g/C067fCb4n/DgqTfQtpY+7cQwEMkGmaW/Mvzq1aaK/HNp5ciemrV1Jbr6so8AIO640PXcXR5E4T/x8SGQ6fd4VNJPGLSYQL9J0iM0rJNG5xt0nGXWJGin00SaQ5Lt0LppAImGm5+PyaNLqcsIHSlfNQMhTrk8lQI0WTSzbxsECP2kQFZcl/BUCWDRSRraQNTVhvmNy7ck8QWb4vrqerJ6LACg8i88z7kFkdmtMW6Gw2HDwBAODkdmzLlRvxJS5vomAKd9AgWhGbSI1AS3/aCIREoyXK+RpJdY6RTykG+MokTdGYDO4jmEIiJ2SIqyayXE61ouwv8TwjzTtlIjX+/Hv/SaZRPIabzDkX7h5Fhvw9tepLqmGRBNNM22rvYTVFBdM4Frnn8pO2kx3RE8dAjpVzA8XhIA6CGRd+XqI9CuszcgqNz7rL20JU8bdNMF3rTlo42ZnMdYsGrtx0uzwAy9u+fdF8bnEWF1dMhjz8InzlZhcE5pNbqY11e28Vx+dqk+4EFvy2EpOL8Iy7/zvSt9wOo3OZncPYv70Q4MQ8I6Ql00kmAAIbpEE4hyp5Hges4LMdK3zZ3DhMzP6wg7HvIxTMIZS7iQEgthrN2Kbgp+CIT1FGU4QPpV3sxtQ26EKSLe6ou7hr3nQAi52g2a6bIHQ2K6SdWaXaIADgtTj4nnXcoW3XW4IDsP1fk07+P2tiWStU7lmsrz2LbW/PmqBJaFcArTcd3JnVBe3DpoHNzTSk360bWxa5Xi/g0Rtbbcmd1Qn8wc0nAcDW1+ajt54MAACfvPsAfGzna/SJuw+GKHAfvf1k+Pgu/fu3ngIfv/NguE7hzz/6+K0Hg3/OJ2/dD7d3/jmfvnVfCJRw89b1EJHt9PaVYJLW3VmGYBLu3iKaCK7SicutWzjbaYo26wXcuXMV7uy0Rav1Am7d3abvnp0Ek7jbp1cCCbp7eiWcHXTv7pUQKnuNgimEyHBeO3TWIhNIlF41Id2s2jCe2nttMK9s77WhnMW96I/TNwWN89XiFMKc0Z7F77pdRRLSrlLtTzjTbOVgsYobUPieBaOBCu3BGqR1bEu7RlrjtYNoLhvLaVfxeruKc0mPDJ0h7c5Zh+7BJnNRi9GsNnHuWXdBaEq0QVTjgQPxeNNWzjTfkQA4TLAiNRkimpdgorZogsmcO0EmcyctLHcHcrsWYHkvrut+XsRBaSgZWt6Nm2LL25sQkW5xexWuN/fWMerdGgUq8v3AIScEk424oslc7jfJDEwyEaPpkqxZC0UZrLyVsVCaDYJVUy6fqM2h3wknTwt9QkNu99pWGmOUi4wgk2NDI6QYorqrvT/zoYiqbHq/xpxONL9zfP7cgMITrVSHFJZTcu7n7GJzqnmfTtTsvAmZHFIaPRPxH0vSWK2fmM/F6ye3Y37vUwQAcOUGqoJsROF8J6is5d3UVCK1eRbSimAW2d8EMwadOQUeQ13ad/gdC32qOVCQPkfSXkTetmXjbyimU3MW4f2u+DTdEGgFM7/EHO6UNwFpk0AJfFpDigC2pCgxDULCJE4vhev0/CJMjBLzu7v89aRcHC5ZSLerdHLHWoHlHZS+LaRvxfQJSi9vplP/4gY6w+jmSRL57OZnoy/PH376wZD+0KefFtL//Y/+15B+7x9FM7f3PBojzv0GSr/30WeG9CfvPgAfvx3L/T//KAZq+B+ffkpI/8/PPDGkH/tsNF87fSyqlrsbiNDdQGaBN9FO+91lokE6vZGazN28EVWJn30cmcndiP2AgzbcuR3vX92N9fdCa+OgHMhkrsHBEbBp3K14fXkbjw/+XYOTAyDgMY+FYvydSOnt33y63aTkCH+H+HpiLi0FThECvuB5AYCYCaP1BR+xkKwByExOXA9wYAW/keRBptJGspaQ1hdpneXIEIMGh7Ze8fMlPovuBKdRaG2c3t6D3zffp0m/UK3OQDIUkpKVjVSuJAeWzouqSddqrmraiTBZYAdt3Zo+VUbeE+U+GpQLD+ecPM7lPxAGmcwB7MzmhAPFACA+KLb1pOkpgcp2bRtelFs0saMXTfoCRoQVxOfKuAbStMakSgNaN+473/cL4piZgXQ2k2hKB2jA4wAOzokmB9gEbXMNqfKfiMznHkRnKtwf6149Ie58b66h3f1FSoau3oyVX/0sMn+5kW5bNncFkzlswiYc+gVtq/pwe+M+/CCogpOzslD+tkknJLxYSNcRHFV/h29ht8vnXx36DfC3QduJ5azErI6tfus7to7fHD61PjksEc82uI7EjDGm8Rka+PrmahPKwmkfjt0jOZvovuSn5AwjbDKHzd+w6WC3jCRdSvcg9ZeQPclz4gIh6nB66VKihKc0XLDU1+m5rLC+7kL7N09AO+/3r0MAgOsPnCYHhF69Fr+tK0tkJtfyT4bJwVPvuw2P3tpqgp76hDvBZ+cpT7gTIts98fo9+Oyt+MJw3ThSm8MR2AQfLnfFBSLrrnUhX3N9E6LvLe9bw4aY2S2WSKjF5xGhZ9kg8zl8+G2zcLFtrYtkqHUk+mBMNoiEpiZkmJCj9iH/oa12IKYXOI0jwwm+PHmTOT7tFpG4uLYJRMe16fcgmdzJ/oeovVgz1BAy5K0RmibxDcpuhnpI69eiCfdvo+J57Uub5HVk7hRN7iWBkZIhvz7hdR4dPOmunSRnE23uR6aiD6AohthkDpkbJ2fgtSkZOtkFJYLOwfLOth+bdZcQzOYeGnjEpyqBRq5LNrEJgRnil6SpW0MOFOvsoDOCMvlGH9hakrO15UrmcxkZOXwLKO3/FiHK062cZ4DJ3BBzOVr1uLslNWqtuhKjpEYUPiRplx6fxZJVfwu2xr0PuZDOTcBJ1DMhKh5tO5teZVTuJO1JQeOcTuOQ7AQAi8TkwLnYnqaBhd9pWjRwcjtOrlcQofHmcwAAVx5H6ccQAULXMRm6cmMThPjl7VUaVe4u8SDthLEihlnld4p6zrc4jzQeldpG0SSTew4adEHY6elFIqRaLma89c4akoIuoHSyu4u1PoltPzn/iIuS59D5SZ18ztIC7XKnATowOyC74cj8snFRgGy6KEA2RvIKHQAAqV9JREFUG0jOJsJCZ6KREdKJqdoq+nK0ZzHdYDM3lPZ/h7pFDVDqVO9N/BanqO7T1GTOP1N71vRMrE5uoLIfRwTjMXSo8meiRmS9WsDtm1utzOm9k6AtuXXnGjy+S9+4fQ1u7KLVPX7rekgDAHz4kyjq3CfjeUIfexRpg/7owZC+d+tqCJCwunUF3I4QudvLSG7uLgLRWNxpU/+am0jrgjRhWIO0voEYMQC4sxbWuwAHGxSQYX26DIRsfRo1Td09FA0OABwKjpBog3Aa+wOdIjO506h5XJw20UztXgPtro7l3TSENR7baZr/TtqzSDywiXK7iunFmYPFWWpChzc3km9L0NzSiJHBNO/MJSZ7MRpcnJNoYBhRG3SP1wDBugtrfHIOW8ZkLj2qIk0nf+N8dJ1HZ8lhk+rYLqx12SQEo1njOtBz4WAQJNwwDlzkrTCaLr6TxVkaoRP7DAUyBH1Li1B3hgz1jv6o3V8XCStJa+qo1bQIwaPYvzXl1rYLQezHIeVq3kFOttZEm1OEjQegMqQTNytEmZu2udSuYfodfP9ADdGf+n/GQiRBUkLndAx8SNOUDnc6LVCGtZaQ0yhIzzg2St/GRVvKjUuDAkhaCqwhSRzb8W5lRtDHHy7uuyvIwfg+dJr2A8gxFJ2svbqO+z1Wh+2fr9zqwm8nNzeBQCxvrnofQnsraovwwpKMO9wP6CTwpK86SPo0Xs+8x6QhfECFfLCP3WXHp/t1COM6t2GG369Dfzsnaw+F8Zn6EArXk28g2pA3nYuanw4y2iG0E081RT6NAy1cT9tKNUch2IIjmiLsQoMDS1R+mu0ZQHfVC3YNdFd26VUDmyt181qq9eF3fWmkL/8ci7PUuRqPiY4EV8Bass31+MLcNfTNX0MC1ElMr+6ewJUnbL+5szsncPUJ8fvD2qEk0loSVQPnQZeRBgb7ADV3FuBOthkXd9rkvSXRtHAdSHuFA1Q4+j6wZghrC0/b8Pzu3gKaq6iPktDnqJ04gALW9CSRGvnri9MYrGNxtwG3m0YX99I5UgqgkJwTRA5QDteJ/47/thZnDtA5uIlTPoC8MZJGpsR58MYLqnMdDwttz7owRy5Ou2TukSLIpWcOoYIFDRCsNwDeCmLTpekhUbYSjb8wP242MR8lQ0k+3Gj0PVyNg7t7Qpys1khLtL4PEe0uaoraMxfmyOXdLglSg83klmjDcnEbrZ130YDCxI0QBvXZQskGnCBIU3NvD8nxn8gemrqzLg5cfVRmHRlYQTyoFK/LXcbXaspofdLfY8+Lkp6RyleJvIGFv7p3iueen/+N/5e6mRijfYhEMkSDDeB//hoHLGBz4MqRmLXXkDBlqg529btIjjhKcqG6fTrH6HPPiLVUWLMjadL8cznXc5wP7efCG3eQ2j2vYz04qADeyU/auFNhhuuSeQDa0Vrs1PCuaeDk1k4l7xxcubkJdfhzipanDk526vyTO3Fny/+emGwk8tRud/XO2TYiTgiogCQB59LJ1ptDNA1/IJ+/1JF+oM/LOd+SOpJy8b00DZCeQeTS69zvXKCGfrAMSMkKCsIQ/sbPQ/N15KyjEFIbnQKPNUDJ7mz/hPA0pDmqDwdUQMEcgqYIaZAa55ATcbpL3fOBIM7EiV8RDqiwS7drotFhND25tEeipVl5YTP+r0mzwRTOIJhPtaf9uttVFI7x/+H5Vlstg/dpatdN0HQ1G4Dlzn+lXTVBw9KsWoBd0AV3bwGrm1uBzPvNnN2+Amd3tunT29vfTm9dhbNd+uzmFVjtQnuvbl2BzS69uXUCm10Y8M2tZQg93d0+CQER4PYyHIzrg0A0qzb4W/l+Wd5tgolZL/jETkvWrBp0XwOLncbNB8EIIcxXLbhd2p0yQRrQtUCCztqoFThrALzCHGl62rN4DtU2Hd+PJyheM9mso0aPixC3uBfTy3v4egxskAQ8wHWQUNoePmCJP4fIb0phzZH/NmlAhhhMAc0Rq1QblARWAN8nu+9444JvjM+3OI2bXzjdnm2ith4HzsEaoM0mzsEJGeni/z7t50t8Dae5/L5MbIHRkfo9tGQIywIA0Jz6A6CaGO2taWB5OzJ/ryVKovid+f5zgfz497y8vQnPK5Kh01UUiqcgQ+j35DxDDRkC4GXGnPaEyk5cOTlLpZKsKoErT9LIkOt0nSyWLdWRq5srT/NMtfVxMiww8pWEDVOn0PZqpYyAUYQoS4a4NIWUTxq8ObUmvT+JBtYXggEi4QEgz5IQiU0xz7Y+3K6YTHfM+HZIARXENKOWFB3wRYdOhhRBOjGLAjyQ3TAn9B1DigAArtxE/gePx/Zd/yxOp6ZSeMG+cgPtUt+KZbXETC4hQ9LCJLyT7Tk6Qp8L7653xpVQLlsm/eCZSTKbFgIq9FXxkPyGkWgchPOBxCAK0vUzfpwBQGraJ5S1UARj8KQIgJAiQoIosDmRbHLEp09ul9OJwzukROkE/aZJL5PrqI4YpRpOUJrWd+UmynczzXflJiobmc9deQw59X8GmYB9Gu1MfwrFygdIzjo6ezT6AK0eRSZ3KO0ejfe7P0Kquk/FdPOZuEO+eCyWv6Smf/g5UEACHEziBAWTOLmBnu+x1LFq8ThShzwe68dnRAFAYnaHn73FgTFwwAwhcAc2u8TvnUZGxO97iceBYCaXBkOI108Eh3ocrIaD5IiPA+bg73Ehpjf8dXLO0AKZw+F0YjJ3inxFsd/LGVoPcBqvC1R4wmsDzrdap3/jfKhsXGdD7/egZEhajzZ8W/A6h0nRyU20xj6O+y01i1ve5tfPHhli2tEL1jPSREll9iXJg5oACLn7a+vT3FtVNt9+KXiWeJ34YUmBuEb1NU1LJJaOD2FsJ7JALhaBBFHuGk6GAGCcyZyKENVCciafAkpnsZgf31tWjVOI4cgl7ZSERZMEURDPf8rVI5kCJufw8OZkvbIEwpg8C1aDCuZzK5y+vw1Ouav72kSYlSIOSZM5AMh2z/jdLbGZ3CK+bxpQAUN4d6JToTSGJPO5IZDOIyImBqI5nWCyp25bonlF16mTqv+bBpDA3Bq3GfVRh4J9JGZ1yARkczXmWV9tQrnYXM6n8fvCpnYakznNEUKbk7ij3p0QM67a1427KulflDyJmqDNldSRPnGoxn1Nz2ZFz+7N/Xx53PUk+MQTNkFz456wTg+BTdosmPxhOD6NTcu6Ky4Qim7p0kNJsfkaLkswF+xIP7gT4TfUYHe1C+TIXXHpYboKczhsqpYc4ou1QFi5vUCBEpaphjPxO0sO20R58KZG0j4sjMTr3bJJosF1yyYGUFikc3LyvNL8KG3eYI0GEqa2gRKiP2ri4C9Fh9MKyBzaNsowTZMXrDSO6dKGYSIUknUJ14/XE3QWEVyNH2N3X0zjAEbdFT5wD/b/6hZNCKAATSOTIezHlNHepOcaCv1DN/mkDUepHvEMHOWEWuvrNLa+sUEXRsgFrm3CNycGbqB1DAkY4UHXd4D++s+ULZnIie4qgsy1/S3++PO/+Z3alicYrCFKKpTI0BAVnoYEcepHTT1YBeo/OqqeVjnDI5U40s7QdNI+Lk2+e00Y62YdwzTTE7UT80B88jV53lSNL7B2abJyLpqjYT8aMlATUzw/wToHi2RHK6avfWaN0mgH6/YmaAaWtzdBW7G8uQrCTjKZ31slZKhZrWWnzw3/3oH2K3dv5sMUzTE1Id6HqMA1hIS0q6E7Pl0smzvTSDwLC5vMbVxSZ1KfFO5206GxEvulcUgz1UFiJicGWsBkWdAULe+61JzORSdwyWSOmp9hs7XUPC6mE60R2tVPzNYU5neLU1Q3No07TQVeXAfWBiURxojJ3OJuFKzbFcDJnfjsXiPVrpqgscDXAdLgDstPRTa1/KMoqC1uR7O2xe02aEiWd5tAYhZ3o1nYAl+/F89PWt5tEv+YK4/zWp+EGNF35U0j1zFfu8JmgzsTsbv937Zlo3qQZigJ2nAaTfYWZw0yT4MkHUzIcNCEU0jSmLhI4ykZ29hM7jSSjcWZS9O7b2xxFs8YogETqKYo0QDhEM2Jn1JqGteGerrUxM63ZdUFEtSebZJ5MNEG4fkcR5M7W8e5b7WO8ysyk2vWm2hGvOmiUI/m0GbTpQEM1rJGhO6+N5wc0XVxE462JZgJk2BI+O/MQa1wyhyW6hwsdlqjpnNBI9SedWFOXNzbBM374u4aTvBm4q04SWCfIUyMmvWmv/74v5tGXmOla5JMlAvtrZHrSmmpfRzGyKj0fg1B1zyvMp3VJtW0V1u3ZFZaA0ZThN1V6FmPAeTsrqFkaFfuMA0RAMDDz/92ouLFAjJKOzcdC+Y+LK4emqYaDw+N1khyAsPlSnXTNiuFaha0Dq5MgPwHm4TYRmYiggN78rwkaEMkX2QgC32XaIrwjtZVdKo7Olx1eXcN62vb35a319Bd2aVvnYUdqcWdjGYIIFno0qARWEuGNEXKZ/fall6QDIRB2kb/U6dIA8hjljZJE64bIO6iO3SPNLY7B4m2Aw07KeqdhMYBdMsY2jbsONI0Gh9dkhY0RVg7dDV9VhxMoeligIZ2HR2R2xWEYAPtGSSBB1SxszHwcDiL9S9O5XSo+1SuO3Fed3wejMWZS/qlXTnY7IJQNOsYnrxF6WYNsH5CLBBrl5y0rSa0ZXm3gc31nbB8B6XvNbC51k/3nlGhgUk0DyggQLuJGq92Hfu6XQGs70PC/VkDG/Q3fkYpwEYjvJMWBUfopXdTz+IU2LRvG592xTyLsxi0IEmvosN2e+aS99lQeVz8rvF1lO5wP8ZACe26C5re9mwT5tYG5fH5Qlmac4MwgVlvwnzRrFEwg65L1uqQZyPP31nBOdnlxmOwi2Xj4DFUNvLImaBhrbikJbqO1LobB91927/bs01YY9vTuHYu7q6SAELY/I5uJMZKMsItkatKB672tExSX+B+GBPAQJKZtMiGkEbroBSAQRtATFunR07eVJQl+n3lvgWNnE3l3kTTU6clEoOiJTJIf5P5kd/+f/PPoMA4QvR//X+kF/yAltS/NB1akcmTax79aEplYFMofH3RRqFt0ab5cXU5AVfT/mRicKFMUZukRY4QSc/rf14sYjz5JZ3ceEmn117OBhTV55bR0dhdW4brm+snoR829y3TMKu4anxeBYow5BZtQohyZCi0Bav22zaOw0WbfqSKiGr4nAppbPfGjP9bUVcPLUQhhJIiZozjs7IAduSUqrVL9eOf6DP6spooBLmmiYtei8/0QHmIOr/XRp+m52P551KSIi+44kh0nhT5OtfXUuEVC6K4/u5K1M50V6K2oXe9lL4a05urqQZHAq3Pa7Q2V5qQ7k5QGl3HeTZXm8SkqiPnEeH+w+RrfR8E8631E1wIFLG5z4VABZvrLph0bc8Q212/Fk3b1igNACCZs2FsrrlQVnc1msZ1Jzgd+7FbRo1at4zkoFumGpeE4JBpDpvJ0WdM3h02UfR1nsR35U4g3OuWLgnnnkZaQ21ZxGdJzOQWEELNu0V8p/icoW06flf+XbuWmNIl/oGo7mXU+LhFkxCurclct8sXf+sW+Hob5nC3bGJ60SQkR7L/3z7XJqQbH2a7BZL2McKbaNLVNEHr4hZt1MBgU7hdPha9uY03X+vNtT4wz3IR5j23aNP5TRtNjatzuQjzLI421yNFu37s7jtJ10gsZm14oglNk5Ih7wfVNMCej9TbxEPyRMY8K+kHSrKkPkJtFGVHCTlNjFSuRj71KJmJSaDEYKhMnHsnEgQiP7pu5eZBT9YObSGkqCSz428U0nlkDCEaHWUuQBrsUpqqvLjrnDZIgqZOMagBSq83KIpMqooTY6Wr6uAXAdFxH6skud+4ttO/pbYkJgFp0IX0fCKUVkwuPTWmv44m3xYRmOXNKA2ePH4a1P7t6Rrau8Kp4+j5FreRql9BhrbPlOlTzfPiOhTjVmU+J5hg0vvZqIEAqcmdcM5R7x7JWZPWL+XDaTRmWlWwDj4NzvXMQ9m0EGgh2TFHAiA9pyg1oYvVN5tIVgBSIRIfDDxVGp/B5c982VfdWBAG2JnDIVNC7KOCgzAkpmoofeWxcvoqSmMiiM0I6W+paRxKo0AJcnABlBZ8btpVn5QuUSCDE+l5b/DtWibt4tPY9A+byfXanAToQGNWCpqQmM917PWEGJ2m54IskCnc4m6qJsJn1OB8+PoSzdn4fuzU3yTnlW3S+RxpK7DmIjlnCAvup7xGQwxmkDGzSfxMpQA89G9cp9QWMWACWZultuC1GtdxNw7aFq2Di5tx8CbrLjm3KZgh3T2D5g5aR5FJXhoIIkNYpPVCWDt6/bARnl3qE41cpCFDQ8qSZC9qlpcD58pAy9bIxGP6ATKykKZujVzP3S8ExUhkTU1gMY2rxwCM0hAB7LREtc6MQ1SgWk1Rbbm5tgiOgqLDl4TEtEBJ8jTPRD/AWk3TkmwRC+cTiX2k8LdKgMrprp8kAzk5B0jYZZJ2uJLIQisi6dHdIH+Zaoqk84nQPdWavJymCNcltFEDzXla/bbg+pt0HNWexZH4DOGGVfYVbSPVDoU0uo7PJkKOxBucFs4pon9vrqaCqeq7rp05JS3IlVRzo6oPD5lKkzmqEdlcTbUUSZAJHFABB11Igg2U26sJRKEFft7UcV/Ik9wck7gfaB8ApBq0pM9qzecEU75e0ATs7yWZxuEj1ZK0U+THhDimHdLybNtLNlLEcVfe+On5KoY6hE0RkDdCQEM0HF+fal6j2qQhQZ2kXXepXXStxH+3LZ9G5nNYa4TX0CQ/Jiy4P3HkvbZNyZD2LKBWISdIgrREhOh7qK1PwhBRV1NHbTsoJI3RFGVz5eS0RJq6x/Zjog0SZOxFA5qAY3RT+pH/3xvr24YwXkOEne0AsrsF8cR7F/NJmhCaB/8u/EZDDIs7FPh+6cwfgPS8AYbN9s4nqiWnkkaolgzltElcPR7rDTpHwRFbbNQn0plIuwGcJUNU+7ZDe+s07PY16y7sCDZn6+BE256uw85We28VSFCyw3VvFdrUI0M0OEIuLYVm92Xn7i2NZXo/1RTh+7FjbintnDwW6VlZguaod75ShYPq1skRlYm/KZ/GZzSR+nphypnzj7b5eGEtjNEGEoEOh+TG2iFKOtJzi+J1GlAhOcsGO+mvfLlp0AUxTQIceJyg3X91fSidnA+zE4YXZy5ECaPaJ/zc2/pjOo2EFgNQbDVIsV0+LQWJkIJBLE5lbRDtHynIRNIn4dn5dK8/hSAYWBvj8+K0b9tilT5vuE7edXJe1AalfRtJ0ASsGVpgjc6pdJ5QXOt6QROcb2vU9i7OYvCTduUSkpOEwMYanLXbBUrwYwAFQVh16PyhLhCsZhUDDbSrqAFqzzZBe9yerZPryTd9irVJaD4/I/O8n19W6zh3Y+uODZlXpXOH8DoqaUT8nKuYj1mZAQc4wu2iGhBJC0LXVE4ztemS9dT3XXO2Dutmc28V1+DTs9ifZyto7qGPby20wz9X8ndGO5B7DokMOSf3Q65s6XdOppLe31Bo5AEqG2BIGqNcHbX1KWR01ea8IG9zaZUGigtK4qKlSNZihpYzQVTq8RqiL3p9/CPX0QwrVZ3ES+5VqwAz4OpvutR5OwmWoGG00k69pB3S7KDnnPNyAzkzgNnnBQAxyADn5EbeiaiylD7urgPwAR26DuDKbpdrvQF3dbv71aw2IQhDc7YOu1/N6TrVbEm7hrQtknaoaeJvTcNrivDz0mAhEqQdmdw4qQmo0AEf3CNXR6Zd4NDYcBB2vsV0J/SJbw9+Ll+d0F89Hyb0XMFB2UEIugCQjkvJp0jSFG3zIe0QSmNNQLt2IV+7iunFmQv3LM4yeYhGKj4v+kPYhMP3S/X1ri8hm4fW15GTwLHWB2uGmg3Axocr36CAEyQogQ9WsDiL2qQWpQF0miJJ65KUiwMlnEEICtCuXHTiXznolr6tMQ0AWR8i/M1gLdHibOsfBQDQnsb0AgXIwIE3FqeoT05jexenkAYxwFochTYoDZQQ29+uXHi/SfosvZ4EAcDmrkm0S0ggaoDWXZgzm9UmaG3bVQyU0KxicINmtWGvAwA5HFsOmsBdT+agzSauLzhN5QoccGHsbjhe02jZXD3Jxmsmqhxu1xINGqwlwushXk9X65jvbBXa15yt4ryKD19db+R+oL4zGJLWppIMua6DZne/cy6k+/VXaqUwNAEi8DvL1aEFlWEl2TZpiyD31SJjKVKSyaW0/1sDeg8rczoX5eoOpTXfEUAynh75P/+Zql0SpiNEGtZJXgAbJ73CcYtz0h6CpC00qAJOewiBF3LO6dVkCCCSntwZLhVkiMMgUoTfSQiT7ORJT2FCJ0UjcVeWYbfLnSyiedxyEVX+yKE2WycmP5B59pyzoeRsywQrkIMdtPK5RRrg4AqCA2IvIIZkTjdERU/z4z7xQlULaeCQmuATtL3oWbSkyAvVCUG6mgZw2FxpguC3udIEgXBz0iTmRRgak7TuJJrAba4gB/STmN5ciee8YJM5KU3r05gxJe1Az9SdNImAvb4an319tQnahs01CNqNzbUGqAN8SEt2BvjzQOckdSdRO9MLPuE3vFGgApzuQSDc9Eyd8Owojd/N5mqTaIW6q7Et62uoLdcgBE0AAJDM56T30y1REIRlLGtrMue/XRJYAaeTQAmoPhx4RjSfQ++vRUEPWggHorq2CT56mNxs/0a/LdpIptomNWHGz64xq27bOMe3bdT006AJKI2vp/OPQC6kKLMY+P7FIqbbNi0X/7ZYxPoXi3Qu1mgeMCHA47dpwt9Nsi7HoERw5STU4VAarpzE/jlZpgfHChYbok8IfSYPv8415H+fHkCGOKhJUUZOZNuhgTRmcvXl5FcpzxhIsqEmipwgj6uRe26cjcrXoe1IjpYCm+XAmJ4+8oHvqnoEitEmc74Btao31Wm8UpqaxmE1NK1fozaU7Jk1QRiQylU6k2gQBNvrYjx9ZgcqN9DF5+XM5wBSB356fk64zpeZnNsA6W6f5Ajb3EZOosj5E5/H0AsRmpv4AmFo5LFRo+ql+RX3JudHOWT2hoIrhHxcWrKxFwJiABBhhAomWM0umY9qFhnOnA3Ibq/wTfUCSwjCUxK0AdeXnE3EpxfEVCwNthDznaDgAv5sGoCtuZTkk4EPsTy53fHpO0I6yePYdLtyob4FSuPrAKkZVlJH4gif9gP+DT976uCf9kk4u2ntQgCLduVSAXyFy6pLYzPC1KQQpc9on/g8kJj+JSZo98r1AZDgFzdQPpROAhRg8zl8XhQyn6P1qAIl4PdBTOlC3WshLZCh7f3ITA6d39Xi6/fW6XlAOGgCvo59OCU/zxU6j2cVzeSa1SYNFoDndXwd+7vg9CqmHU5LplzYNA2vFZsNwBrvEqDjGvB1AHCofifck6RFOYInQ9A5cPiQWnwPesZkDcTpO/f4tBRsQmoraWNvjdSsk9Kaifs347flxDVaeL+admg3pPG92vs1sqemrFwar9fY5EySSTQysIYM1Ty3Rr5OAplUylaMjDmWDAFMoCECAHjF/+UfxD9qi8upPLXsefwj9NoihiQEkLUJml0olZBZOTjZMnjCKRYnaUuk0IgIVPiWdp7Ek66lfldADGlaqkd63pxpgEdtaM1MO0ZB0rBIsfxpvtxwrdUU4Z36kl15qS7qXOlRqSnCJnNYU7T9O96TBgjAfUqahR8FT/jJdeCBLUmkrlWaf4jaIZyWNMJJ36a/YZOyjdA/2NSLhu2WzqRKskw0VWcDNmjeBwbtduFdJZqw5Lrue0438YBNi4ESkvyK6xkylARQwIEWhE1KAEjmPE3wFPFQ85y/qXQgqhT1TSIUCI30TSnN8HvlCoEaRE2GXDBfRyYQRFIHPkMQm8xp5hCpbyUsyIfeM3EWFhKpTkyGFM+u0hJRSJui0rvWvDONfOfr1mokp0ZOflFoikSMlbEZrVFArXmiMOdMQYjGB1XAyLDELFsu7UpTVoz/pjvcNelMu7A2g2o2xEg00nOU+mBqEDIZBl+mH7JhMX0eEmyA1YDhA+hQO7JBLdCOndcaNetNTOfehRZkAggLPlV5cxM0DSrAPQd953Rng9uxke7Hjr9SmmhzUgdDl+aRNE2bTFCQYhtdyJ+cIC2RIVo+TlNNo0KA0miKEgfxVarF9b81ziXaHWm3va+Vka67cG+SXsX0IqSjANyuoxDb07QQX5LgpL92wdQNB1Roz1zwS8FlNbiOtYPFqYuani5qPJouBl5oOpdcT8OSp+0KgQTWUVBPnnEFoV3Neni6XfFl+nxJm7h29PodlYsCL7Sr+IxJYAUcSGIVtTU4eEUvjDrW6KBAC4uz2Mblafo+Q6CEFYR0u4rX2zUEwpdc15KhhBh1oaxm3aUEaB0DMjQbNJ+su2gyve4SrY+kDQr34mAI/u/QLqLJ8G2RyBB2qCZztde0OOeC8O2cC1oJ13XpdUxUKHHYbACcn3PxukXq4eQAmvZ1SGsG/puuH0meLmrMNl3sI7xW4GATOAgW1f5IaxlHmtom/sNlhHvQO5HIUJKnsm/9s/v/NUEScjKX9OwYmvpoWmOml5MXa2VbPPZq5SRJfpf6o9SmGnm3hi8wsv8gmZDBJBoigJ2WKPdAnCMZEdyLeWj+sU3X1I+vA5Sdwkh+sb3iR6fsNwkSweucfJ9Gc+Jc3IlyDlgHt4ypHPtxbTpInAelnaaxOxg5R8LSrgkdC5o6c+3lnCVxWiCUvfSQkPA5TYwnri46pWcDOvgicmOaEiINBN+hKk1R04DD2o4rKDDDSdoH3QkZDz6Nq1sLjvorlzjz4+tcoAUapMG3C+fRAvd7exbb1+C2rl3QAjWbqAFqNi7pH3AAnQ8AgfvIpYEhkqAEUkhq/AmtY752HTVK7Qal11EDpUkvUDAF314OkhYNB1eQ0uHv5F01u/pjul3FYAo4sEIPUluwWR8KlNCuYp8uUBCEdu3CuGw3LnyzOICC7EuUfoCNEGY7NXnzjMyPLRQoYd2FuabZoOAI6y58w80azWXrDXDO+81qnaw5iS+ouEmHyNB6DdD4dbiL6W4D0C7idS7IQjLvkkAMDV77MpMXzkeCHjW758IBAmga50/q454JIJS5/UPQGEkyB35Pm/gOVMEM8CHmAOn6ow34RMkQfl6cP6mf798Gy16a9bIWtA+1dUhrvxSwIVdnCTTQgKRp0cimtajp05z8Ra9j2RL3Lw2kQGTbd/3ud+vbk8GynEWJkpnMGLKUI0W0zJxTHQfpwxHqbDZdnMDxINx0aXQMeu8QMsS1aQykvkFtxKd9J06lANuFDD87vp/TlGnqpmRg0caF0DvX+Y8El6v9mEsfY82Y046x3OSY8w3D77zUJt9XnQOASJCarotBGzaQkhsvjS2YcY0nGCRsiVqdEgQy5OtxTZOkk7yBeMXvq9lgohavt+sukKKtoL9Lr6PQvzjrEvIBsBP63ZZMdFearQYCdumNgwYgccBvNnhn3kHcTY/PhK/3fGmamI4R4LoeKeKc/7slH5jBLSH47zQb1CYcDj0xx4oCNSZOALt+yETLa9yODJxsgy40HUB3AjG9jHW5JfQ0NQApAWg3EPtKPFsnTVOC5H/vFii9jP5cSR8u0kAZWHtHr4W/0TtcoEhti7P4fSxOIV4/3ZIiNmAECiqxOYkauG6ZBs7A/kb+ObY+s9trjYOorXFREwjoeu+5MmTIa1pd00C78/nBgRXCPYzfYkN3a32WDqKmGO9Udy7VaiMLALdo06AJnhg1TRSk2zb47DRNk/rvYKG628T/w3xJtEuBOLl4b6Ix6dI5jBN8nQNwO+LlOoAN7IIsxPsSjZOQ7pEh+jyIFDm8iejclhg4t+2j5TI+w3IZ+7pp+s8fio71YE1Zg5+Xi9K3QWXTZwDor9VaMqQEJnEqzQKQPkdgzSpLcptGnsWgmiOOFLHykV90Wj5Nyy5BI0tr2jUH8FyC24jkIlWsghGY1mSuhErn86Iq0t9H1bOSqllSO1cOeo15WfIiqVnfsUBqIyifUepPjVYs2bnCKnViL45V/XN9DFK7NGORfLBsWdL1XFo6OV2yp0/s73HaJSZt2zJQuwQzTzH2v5CWvxWUzgSM0ARUUJnPJWks0KaLRiLsJk73Md8SBRtoV7FdTXI2iwtEAF9PzBFpW7BjP6oD161Lp/0czplB6WbdIQE2mmQ1DhKzPoC0j3A6Oa8Jn+uUpIFPJ5HQImlqNhAJ5ia2K0mT9uGgAkn6lL++ENq9TAISoLau4j/8d0ijc4Z8GYtVahqHgzEkgSGEYBk4aIJ0Zlbqb+QSMs5dryVDAAAtOvOnPduQezZsWhVEBZloNat4/lByltA6DayQOPyv+AAGCRnqcH34umKe7Tb8PE3lCGyC5n/n6hQE/yRdIkMUzsVnpOZkfgPTuSSoRBJ8AbevQIYACEHQbjxSWQLXt6vfbbqUDOH3Jq4lCnlDbJJj01I+ajJZvWb3C1a3FQCiXEvTzsX3htMAclqSr2rbmrvOfTc+rZENhGBqGKJfo/YdVGK/hMhgMBgMBoPBYDAYjgiT+RABALziC//vMluT2H0ukpc24lht/HRNucqIHL1DPj0kfxgJU2o/coxcw6w1PkUavxq8uy+dfq11hsP15SIASvdItqtSfg1yKuchZXFpCdKYpOOO+IGJPkZjbIsV2iH1mE7GHn7nlf5ESTrmp9HmEr8hxSfbrl040LRddUk91e8Nt6OyyzUR75q1S5+plb8B7BOURuAT0okPER47QoOl6X8T29hs0nZUR6obkV8b/Y76eyUHvOJnV/QDPisp2S3tFHmE6HJNh8wl1+SUd0E7lGiAct9sMrfjdglmT8IRC6LFQe83IYpcLhQ0h9qDLSV/Hu5vqZ6WhmBk8mi1Qx4K35pttvLzqszHGn6eza4PwnsSNUM5OU/jSyTNpyNkKFxmz6dqWIH8ddynQwJBhCykjZI/mSSrYmj8mAas5Tn/5aRozeGvRN5414f/ua49CswXZQ5AR1RoBC/OxI3Lg03kcqo7qc5cfbmyqGmRFPY5sZtm2pGLXDYnNIIv83xNF22+E1Mrqubl1Oa5upqm3o5V01+Z5yx+aJzKV2P+JrVX+h33lTcr2aCITp2T01y0OYC+aUcmyhwbVQ6npW+I9gdThihY5fo2V0bie8CbL7Kmc871zigKEec2Lqa7aJ6Fzd2o6RsABJMuXE+76uQIc0m0uS7cx5qyCe+cmpUlJnGJ+V7a1uB70kWzPfzcsU/jfVKUspB20dSscZC2nek3bM5Hn4kiRtADMUJcI1yP+dM+59qEI/TRfkvuR1H6cL/4fAt0BlOIMLdKryfRA/G5SRucRs/XxfJDX61TH7YQ1ZGQoZAm/lAqMrRG87ePIMdFkVsjE9cNjlqGzMywqZyGDNGIXFIUOXp2iRSlTIhYlpUpfDpU3KXp3N/0Xmzixpl9ifUIcyv9u2BK1ouqV2k+1qtPc5TCEDKE09qNbcZHiz4vW25O1kweo1+O1J89Mzu+QOE5uvT/zH25+sWya3yLaJ1jyRDNW5IjEJJzRnPy1gyy8nwmc9LAkx5Iss+V0gCpD0Vtp2FtSe5DUZRbJEW+XKkdGmifb8wgESbA5ABVzenWpA1JiGuMWs2eBkqClSNF+GPUHBSsmjwUC414WLGUzgoU8s4rDb0d71EsgFNNTnSiEyMUojzSgbQafyLiS4EPpkwOck3OZUnTqT9LvF865DJJ4xDgQpoLE06v43Q6FtJ0cr4MenR6aK10Jo1IirDvFRMAoHevUA7ViEhn8WBfGsl/SfQnEnxyUt+i9H3hd0Z9yHBa7pOYFg/ixYfk4voE/6dkXEjjUxgLrmn0ZMhjnX4rkg9REh4brwtSCG3R/zE9+FQUpsWDHBU+FVI7RB8MoXz6Wy4CnfRbjgyFOgXZIVk7MmHIhbTDMs8Y9ObvcltEMqTxg8n0sypYhVSfkCfXh2y6gnQmUJKhmrbI41shs+R+G0tAxsjS1A+/RNwGYlKTOQCAV3zB/y3/sfnqpKhd2jRAHEy5qF8a7YOo0lSYzUnmZaLquZH7Zy72iwdczmyO62sfxYak3XKhamNCPHIBKDTQmM0NUM0m2WsdNzXme7kIdfTd0OtNE/sNvwtquikddEZN6KSxm/RtJr9issxqhzw05i3YTC5R/aN2Y5O1ioNbfV93yzamT9pACnoR30Jkt6bnqB4L5y+nB31KYwTnQWkUHc0tmtC3btGEtro2altci/K08bwt1zaJ+RQd/0lI7cTEEJvJ8eaMktmYayMZo2mvEXFtJEP967Ht/vlotLjqg15R/jQoSJoNk0gpyl93JaY3V9B4QWNnc9IEkoTTFJgQim3EQO2TosuBQwTYIU2ZczIZEoKgJPMQQEZIFzaNpLlfEoBBEKabhqwdTJvwGovTi0WewHCg85Ro3iWYsFGzL18/TgPwcyN9DgmSaZkGOfMzyWSO5sHRaGvJkPQ+JLMvzfNlZSzU/1x+KV2qT0D1wcBkjWUJntBGVUh2AJ3pHMZQWZQre6SMRNv1ro/878PaJmC/QRW0O+ZhF0NIr9fbf36S3Wx4Ey7/W039ktAmTPpZdssx2pyJH1fXIaB4H816k5rTCaZdCYb4AdXcqyRDuG1ie6X3J5QT8pXS0tiRiCNN43eRaH0yxFMin7j+pI3A51dojarJEO1b7jmccPAsKDVF2BzqrJM1NBpNzykWJKMmRoowh7U1W9O4/jfj/w5twu1NNBNCu6XIYfh6Mgagh4RkSJqiDfOenSOaClwmn8aaJUm7kmh0Ei2RrC0R+58x3UujAxJCAumYkSIPLu+U01gzhCPKJWHJV+k4iIccu/iuHMS0hgxB+s5Tc7qunKZaEc35QBORoV40Mle+v3rnXNIeSGl6rWdJoiCLkmZJo9UotWsoGPOzfH5CYGo1Q5IWTtE+cA5YU0TJRFLKQ+uWNCpD+rnW4oeQn3BgMP4G/KHAAOnzkfY6xTpfbM+Qe2ug0T4pydAcmF5D9Kxv5X/QVjPko9RAcxiWdJ06Qkq78RptkQZzaoe4OrQfgDLQRKkdqp1Gqd4JyJAKlRpHVaAGDamipIM7MwCnAVJNijQ2AVQHtImaIgVUZIgePJsUUH7PSVCISk0R3clL+wpdF96xRBqbLh6eidM9SHUI2XEeSZuh0SBI9SbBKSDVEgGATlOEy1Y4r6uCQSSEHN/L94EG9BDWpK10GHZSX/Nli8EUFJpB8f1Jz5f0EyGE6LdWMBfFIbVFLRFdX8eYkA8gQ/EPKnwLZEhjqTB2PZCQzFM0oA0zh9G5W6M1V9U9g5aItlN6Bn/NJzVkSAON1m0MuOfg6h4CReCHtCnCONCQRtLWRFOkCbAwFzSytQQlETp6DdG7fv978updCklLgkEd93P3S7v63DlG2vvpblBOgN2BdXqXNA05TZHm2XJAPjWubaIgoPG1ob5V0jNp+hI/0xhN0VzQvAP8G7muCtQwtF2lNKcp4szbxmiKOHQxT1VEudJk55zY1qKmqIPEB8ILhtvzjVIijoMaBK3IBl3HgQ+8k3loR/oMnLan5xzq7+8gNV8KeQCwRiDRXLpYduJQ7x8JOcDDhoxlpl5/Pw0mICFoMVzMtw2oACjdf+6eBhZpP0I0tC4+d7PBaaTRWcVDSLEPTzaABXP4KgXVGtHgBSHwwiqOhSQwxzqm2w0JzBHSkF5HGit8mGn8liIp9AffhjQaB/gZ6DOF9DrOt+0qbkY0a5L24LTL0rzIpGchQz0tdxfWDUfnQcFSpMoJXgsq55SEV2ld4bRNkvajRhPFBX7gIGmJSu+dPEei1eg2MhmicsVQrZtGPtLIJBK074FDheZNRYZyz9FVEE1tECsJufdFoVnna97NzGQIYN8mczloBig5PHR7W+xEKR0nHqJurHUclxwdNSZ0tVFapOs5YT1XhgbSh9kJfSAFWMhNoB45UlSrfRoLiThrxkQNKWLyZbVDQ9O0bnHCFZ6jhhSV8ojfj/CsCj8zlflcYjqGAiicbZJd8jbZJefLoj4W2AROZYqUhB+W8js2LQU9EO9dKerNCNCS6RwAANZOpNHn4vWFFIxBqD81q8PPHdNJUAHxYFg+TdvQ4neXIYPJgbWCyeQCBdZIgmyIB+miPEkADb7PKXkN+YXrrol/u6bJjCNhbGvDYUuBYOYiQ/g6+q1Hhrg0guT0PrGRDGpHpRyBn69zIJp4aSCa5wnllEgRSbuuSw92zfkLcVH+SJ3V2jGNjKZJi5uMm3K6FHWQbbYgvwLkyRCXFvpcNBPVyHcYNM+UZptD5Jg9YHKTOY9q0zlpcsvcW60q5wIzAOjM6cR7y+ZzAKBzvk9uGPlaMqZarOlcTnDmkDir8oEXsqipi6vbYwqzOe6DlAIISOMgMesq+y71oCHMEpIzejKmmphsKvqwZz7XMWkgBEozeWueT1Lva8zn8PUlDgTSJgJkt2xD292iDeOwF7yASaudbxMTKty3wrNqkJBXdLmJ46sfUAFCOuQnJnP4726JNMv4jKIluR8/dmIiVn6MRhhDyRk7ySKM8/NlukW8X5VuI/kJZo+eJLTlwBXdskkIimQKmfSHMD+o+gw/NxlzoR0uPkPjIJjG4TRAms6SITzfoUBG2YhQXFljyRCXn9bHoW1jHjQ3NE0TZIjBJnU5kzkuj7hpJpAkTV3SWpwL6FAoP9cfPbkr+UYVkeQ00PYrNwdr06F8sqaXZAD/m4TMGVEsJCIkndEoPQc6+0o0m2uFcUPbqVnbaJskjNnUFvp/Du0QwJwaoikPv9RAYK/JTpBmV5rm4dR4idYJMeeMyl4Ml6xgx5oQzD3MwXPxc2NTCnr+BDatq1GJztHeUlozJnLXmedTB5nA5Wi+C4UGSvQTy5VVqymaigxJ40N5v6gpwt+dJABCX3NUkxZDETtk0uaIORwynwtjwqF3lumP5LvHrzUhEoo09TtRhG5OQ2LH64lmI3l3Mdkz+fJy6YYPHtCsAaVdNCNbO3kexNrAUyEthQInATbEgBtSQItTYY6X0i72bdL/nWOvNy6+762JHcqD+lnSGolaG41miAYokoImiGtpeW5wzkVZge6Kc9c7dAilZPpO6xOsQkZricYe+MqliezCahCw1qXnZC/NtcO1RNl+Upm4lTV2ubaogieU0gBywISpghEMgYYMaZ4bQKclEr91ZpzR9L6xLzkRYTYNEUAhBHetgJrcmvkoKfyk1TkQd0AkYVRzOrPGH0bQQKmckBUDUlNOttzcYqIRsMX+GyHkS9BqhzSQnmfT8eOGjKFRQSakdki7nbifFOOsNyaksVyrKUIQyRD9u3bBkfqyUlOUBjnJaA8lzU0t8PyycbHOzgXNXeOcqC2W6hZDSwskRNM+Oj6SAApCsAqsKUo1Tei6YuxTbZAPzNCuXRpIQiJr+FnH7F4mpIW0MakPf59SHTEpaokqNUONi+O22biQj44H6UDWViLtOFKiJExntC7ipotEhqQDVyXSIpIZJJhnwnWLUKzJak2RJvy2hEpCIrYppzHCZfp5k268aTRaEuh3p9DsjXq+qZB7P5o1XyyXri8KLZGWDJWQaIAUWqIhAbFyATVC3RNqiTLf9FzaIYB9+BC1TXlAJaY8bZysxjqAAag0R7LZGCPIDSEPwi7WIM0PA6+FYJ251YUwH0luhw/3h7RLh3e0pHQtFLuO7N8lSG3PpTXakVJd9D5uvGvIEFLv9wRujblnpo09rYfm+Tw0gRzoeJ1CU0TGZTAh2u2+B63CxsXd8q5ThZKXD8pN+0XaqS9qjahW0T8r/XZcLC8GWkDPQN9VZo5JBGnBL4s1ZXMQgh0kwQNyWlLFp0l9ZjwJaHF4cxQAQdJENV18tkTzgoMnbNJ+ajdd7E8UTANrqXrPxwXlIBrCUHdHrvu2ukh2kqh7+H2QvpPIULPuAjFLAiisNmHV15Kh7NEEOM2tG2PIUOeiYDmWDCkwmgwByNoMnPZA3zM+NFXyMxE1Rly5vd+FfpJ8X6Q1m5ZL664kQ9zfvXto/aU2Svlpm3J1cukptSW1ZCj3fLVaopLsm5NPxoDKWNx1Kc+eMKuGCGCnJfIofaAKTVFRZas9uGsH1cFZ2pDdlTvvRdYtMfMcYyd/c+GA1eG3u8qPYo5gCNodCdwfUluSRbvr3wPQH6NSPw99v+LCRBcZoU0ajU7Oj4jaEGNovgUOlQRG2hQAYMgcly5oihqHtTMQtUbO9b5l1YG0Gkj5qUYIa1a8kIrzOICgVUDppovak2bThXfcrjtRiyBqqEjI1VB3G9OuaWJIbRydEiBqhByaX8hzOsU0nPgQJcJHTEqmYDT8tDTPJWncT3gu9H3mCYVvO9VQYYGf20FGfdA4iFq3Lr4L+q7Z/hPGQJImfSYF3Ei0RGcxgkViPiqQIbVJdm7dCGS+ixs2dG4LZEGY8yiR6rj8Xfy2cZoCb7yGSxXf+lRaC4kgSM9Bnsm32TkXNQGdi5oAKgvh8VrSGElyFL5OiUXy3nVECEP1DjS+WNI9VNPDPasmnStz+yD9Oug9HtRElOk/t+nSd829d4BxWqJaZOTN7BE1XBmV9GNO7RDAPjRESW0zCMwUfsdD+geQ7szsdl3wv90P6WTOmRBQNpsTrKU0x8RpHTXlkN/GaJ6qJ3/8LL7PfNuG/qPPikH7WNvPJY0W90w0Xaspqvnwad4gsOpIWBJ6G8NrisK4dvJz5Noj/TaSDPWuVZad+A5h4Rmnid+Bv2cbltuFexMNEg5nzaWlMcX1G/4eneIQThf7BIcObzZdDCmu8jnpEi0SRtO5qDXAxKuDMOZSTRi5l6ZdzNNs5DQOr43DbgdtEA0f7fN0pN9ybUHppJ+olgZHmeuAD7GOhZaetg6V69uJfaAknyn6LMIYCED3Je0LWp8ukKaWaoYYjdHkZIhLC347of8aEognR4YAoBe4h/PbzQVm0pAhb9lC/02BHBkqpRGqz67h5lZH7uM0WfhvTqMU3ksziAxpfg/lkTULy2xiSHWNtmhEVD41cmQIoNd/XsMjPaPsJ7QJ49V5wtI0opKhGlQ+o9Bq08a0YSbsP+w2nlioSZxGKzMWimguYthJTfQ7SXDThBwesdDkyu2FRmUnQyENIL8jXK+ve7PRPV8tNMSkp8qvvKe6/yvf0RjiNMR3CZeVy1dLika8R01o8jlIURJeGCBxKsemQ2KwBCkthPoWA6o4SIlX4lQfyQ5OR1KDz+5BC5IUzMUR8z7J2R6AmMx17HUp1LcUqlsMZCCGmY7t6ZEh5hlwKGlNOvVdkseG2GeYvDiSRuSKNU10TnUOVa1pZtI3SR689uD5CD2o8J3NRYYSSMKhcL02xLYIIhiyAvSUvitUONSQISkQACaHG4VplJiW+ltBHHq/ZdbfgcgFdJDID5d2zpFw4HGuTU3IKomRFJxhWyl/T4kMkXKdJC9qxvsYf50xMgqAfgwcIRkCgPlN5gCI2RyGSvDJnEit2RWRoHB6EwMvaE3opN+mCgyQe3VTfRS1Qj/GkH6qQa4cjSMjRu1noHmfUn7aj9JvmrolszltUIUkz0RjUSIrUhhRgbiNMZ+T2t9z+pf2XTTPj9uqMb3DaWwC45wqMIoUXU4cM6JJZVoXNqFLgyvgIB04v1AuLlYzfPBrx2nJFEwgBSrgd4KHIR6ftEiizSvBCXOCGGKdtCkxq0veHa4EXZaCTiTkvROuowOgpOhxFBoBae4w2xJxkCAGkxG0RFOTIQYiEdKuQZrnwKgNDa6Z+7SyWIWWaC7MErQhJz9KZnNjiBAFfu94DVwuYxqZyDWJqfxEygat7DrRNzW3uRzAnjREqgfJCZJe1d80/ckraJta/mPHqr0kjVS/GhUfvjezI8vW5f/2KJEMsc0kXWpvqU1cGwB4Yb+WDOHfqMlhzXPm6s4JhbUHsWFo+z+MBzR+tM9E68u1B6OWDPnvR/PckklFKY3DrmvIUG4cSzvVXPubRm6zFMjEkZ19TlsDkO6qb4R2JFogXjPVM9cTUArgsNUUoe8p9L1LzbKQFoI16UPtc02zFbwFApJoilDTE/M8NO7TUOLxvnCvA4gmX8Bqu6rJkEvvFUOYY1NHZuyFNuBv2v9G527ObI7Lx/YL06bMFNoI34McLp0nN4kWlBIVZM8vEvPcGoF9q7BvACL8sRiH1hQyJ2jCbCf5FeILt+7MRYbo2AjVppqNbNsG1RvnhqzZWBh7HahMwbRr7dxkSJK3NOlc3ZL5q/B9J8hZGjmmPyQy1DnAgUPYsS4gkYcl+VfCgH48JPZBhgAOYTKXg1bDMgTix50Z2KVyJFWmZiIZY6qlnVzG3D/VQpHrIyy0SukQcz+TpvcG871uey4STUv1+b+HphPbd2kCrCRnGEPIUC2kZ6hNa1AiiKAgRQDyt5QROETzKUQwej5DLBmO5KTpsJ8OKQfn54gNedZ0Z1/a5edN96R0aiaYEWqSCG8dSqPridkbyoPN1QRTN1GYF9qXJUNsno6/vi7n6f22EdqkOPdHbIfQ14mfkUt9i1I/ssJzt+jQ1BYRoCSt3CQp/eah+E5TU3RpHhTW4yHHcewTCrO4JDqe9DwaPyKVGd0Akzq8qeUKaU8WJJI1lAzl3ABq06r6hHVkIvM/AMiTITatI0PxD0GMl75JaRzWpnMykeY5jxB7MZnzYE3nJHadEWyqTeekRyxFBAEy8KR7MYRTsVkHd/b+kaprDTIRsViMMZubG1P6mlFNiiY/l8anO9P36cuvrStXn5YQ1Zhn0mcopQHEsSEe4lhCSetF8qj6ne5aC+/EtW3Q+ri2DcKpWzRRw7JoIulZkDpwOZp7vZArpVtI7u35RHGQTPqW6TfTJWcNYXNEvv9d8l6EuiWTMampQmhpiXikWj9gr9fOcz3fmU6oQwB+TrdA7z1z7pQv12GCohkPDSI9OA2IWDonpiWNtsbHr/c3FpLx+o02ndgAAC7dEEiucwJ1R/P3tQC99Zpbg6fWENWYxmH5YJspn0dKLxbpvBWeIeZpFgu+X/A8uVikMlONliE8Q1nbpAuaoJjTNLIcxtBogjnkTBBrz3CSXEJoXzDvusFR4xYL4pvvD3fDWqSGHzMaaORaKtNo1mYF9qUdAjgGDRGN3oJfHp7A0NlErOlcuJ95JM3CWIhCx97LXadsWjDdkSdFBfnQCpUSMx8qoOYgEZMxGheVViazO1S746HZOcGQ2iQ5rYpBNkbsoAwhQxgaEqwZR0J/iWRIM541Y1OzE0XbqRgLkomRqMUQNTEKjU5tIIdTvLPr+PSQ+QLiMzUOaVQ6lHaQaCu81ig5+8ehvul4s0SaDvXj9bRzEEJiOxdXK6oZ4jbR8N+JRs8BG8mtBhLxT4icoIESNEUpoXF8GmsK1/w3Jo3PnFmeClMJk6I2l09rAhxJzvV7QQ0ZAsicucTPQ6JWSXGQbbXGaEpMRYZq5zFFHqk9pSANk0DYvM+aUkrEN6SpDM2HZ2f7RitvlciqVL4H950cobZorxoigEyABQAdGSAfsCr0ZO2uwlTaIgxNgIGp7ZmLbarczdBMTlPZRWsw1SKtRW2QiDHtK8XvJ+1RBSDIobatiolUZe6maIN4rlLtc479phT1icEVpHI0wP3VtpFw5TQJgrYqoKAlCpqLZdRkuWUTCIRrm6AB6RZNIEOuRVqPRdwVpNoxLg3AECKALQkLhAb4MSZpXOmuaMgPkQw1FdohSbPof8avlow3MVACbS+H5PtB2XFfqEwlZzp/SBH4IHUYFyJ1aQ5vVfiHNJLwiB3Nx663tWRIs2YK5ciBASrXJI12bKyWaA4yVAvp/SdZ0HerqEvdX5qATpqgIaK2RQioIJxFpJJhNVD0qXojFiPz7e1TOwRwDBoijFxIbg9/ffdboi2SgixQE5vSSxqjLZLStYEYcg59EqR7pDo2XVzINM6Etf2oyTMG0nPlfhu4cw4A9RP3KM3XNLthaoxp6xxtQFAfJFxCRuhVpRWCjhj2WxOwQQzGEJO12qREGO54IRkAwplGvXZLIbWxb5EQgjsNfy3kweVzZAhSoV/SyEiEQXqXku8SAHn+yrHXaOoWNw0q2y1phsTw74JWesi3rJrDBOIyc5htkQyNWYvomij5Cc1AhjTXZyEVmsi9tcGpMCSnfUnbMIPDvyjTjYUkT0n9lbMmYiAGVEgsqxqWbIjnGglpcjMv0+ageJ5jwd41RAAFLZGH5GQm2VYCnYyECbgWtdoisZxdfudkpj1UW6Td0aPXufrw9VxaqkOa4AroncI8Ir19nHy+HqT3I6G0Q6LtR6lecTeq6f/eNOM1RB617x9dbzZdaMf2gMhd/q4r3pukhfarnnEuAq7R2Cmu98J+V0AiBhISjVDiD0TGLtIOYU1R4geEnx9HkhWfX8ijeHxVAAINGZLKF9aJnp9Q7dIoaYowhHGkGRdiuyVyh8kQvq7Ykc5qiSRBXzDFcmJAAC8ApgQp8RnC9TBrCxVfimQo51PCvZtMP6jIyUREiEJc0/zzdZ0sW9T6UHkZyHVpmoLpq1EEDj9DTvDm1uLeu62MwCb042itGiZD/hId274PBC10z3copAVt0QiorKK0mw6i1pK/vm/tEMCxaYg86O5VwnpJk/FAmVIFTO+j5g+1i6ViF22UtmAIptIKaFSpquaUd920dr7V9sDV2oZKm+cxacVubnYnWztWfT58j5Qm+cNBol1MJ0JM5t4knakzRNuiEyuXv/QMtc/K7fZ1Dgl15F5BA+x36Zuuq0vjA4+xcznW8uK0c8E8qnHEuZ76DeAocbt049L3mLxfr9XZxHITnyAnHDZKrnO+PFRjEohCB5F4K8hQL7w6SgdoydCQ7yE8cyyb+lbhcSQdyqs6oNdjg84voppKvPGAj1JQbD64Fm24cPf4Z/ECnHPRVNML7CFPi/I0PTK0LbLh10WytnBzeVZDU+tgf6RkqKoNU0E6pDR3y1gyVMovYZQmcES96joU8oi4OdrGe/D3g4OyNO1kMqOoMdLKsBq56oh8iQ5CiKqYHzcwfJAFFGihyoRuCGp2PyRIg2WICd2QQcQNYufSENZUOM2lJVSSolFECO1KJra49DdFWdXPKQHfqzo5XHCQ1bRBO/mPeU4hf3YXuVTOGNSUk3tWTZ8k71LYZZfS6w2bFgM2oMMypTTgtFC+WJfkSwKQkiJsfieZZSXmcJLpVuy75EwjKWy0ZD6mASFDbFoIZFIkQx7VZ1MJzymYt+F+l9KN4t2k7QEepW9op3UOGl8cvEIqR+gHle/QiEAKabMH7FzXtIf+LQnQU811AlRmeqVodr17hTbPRYY0AraGlAwlLlIArDFlAsj9JUVPpMjJvLAb41iu5aLLYdSahpN0ddh0SoQ4FH4/hHYIAA5jMuchms5JfjBcGkD8yEab0HGDayoHtaQexSQ+pC7NhINR66Ap1YWhWCTGHdom3KsI89g0Tah7UMCMmoMBpfCpUnm4XimogCaowlhIgoe4eI4gXgozuMlMA2tBzRdw2kMKSb5oI1FatHI5OA+XbhuoOusJjxs8VhZpX7nE7AL1NQ60IJm9SWZiSb+gujTmcwK5EU3mJH8j4PNgiNom+rfU7aXAGcK4cW0TviF1esPMH00Mwe6aJvoJORfa3EgbXcpoo2KkyMQUDqeRuRwm6ocKpKAxFxOQXZvG+O1MpCXyUAVdGGM2l4NGyB+hOVNBQ35xntq69tFfCrksqVsyl0Mht9n1aEiaq5+OJyzfYNB7pLVzh0ORIYBDm8xNpSoboy2SNEcKbdJkDnla9eMcUCxAozQYGMJEVUUsqclSLh93D8Lod8c5eEq7TBqNkLijVyYZ1doaCsV7LZIgbMqlVZXXOq2X8mt2pyiowFizE67RICk0OWJa0ghJ40wSUhOtUfp8aeQx1Nde64BNuhwxe0vMvnabCw69J+dimR2IZnWJ+ZyvnxISyWQOTR+sL46gDUrDYRNhREOGkjqkNP9uEu2OeAivlBa0fkldQjuDSZ3jNxSwefruW2A3IZzjy3IurMWu65B5Xpfm93AxT084ZMz/tk2Yb/NDHW55BjI0BtVEpFZLJIHkZ9/NRGaEk+3dz2UKp6q74nmIVoiVZYXACbSuqdKs9ta5vuzIvXPN2nxg87mDaogAAF7xrG/dJlpmssTQCuK12qKkDnSvRIgy2oZJMJW2SKMdIv3Dsn+88NX6B1UuGroQnSOHa+37G/pecb8J/Sz2OUDa1y3a8eF+x7v0iwF7HIp+r9YIacrHZVYGTFBpxLgxTHencs/O3b9P1PYnhjR3LOOuolpTlIw7rBGSdmLjXO7raBykfii+/A5QnugD0yNDodLoP5OOvZhU+Qmp1xP5pyI0n2Jl+aIGTNSkCRsU3MYC3r1lhJeE5PrfhAANbo2IvBTqWxN6WDgnZw4tkVoUmpkMYauFGvFsr1oirX/VDD5V1c9ZAl0fpHl/ov5SkVdNXXi+TtbJGfQcQ46fqTlqZtfX7/r97xnRyPE4eFCF0AE1gq7fxSoNeo22KMk/0s9oChxQW1T0p6kNdYk1d1NhpvOZ2ElqrBCsIH4qR8WgfUKCTE6TUTM+Mtqg4BhOhaeSFkjKk9PuTaUpwsh9M5o+KmmgpGtD01TT6AUj6miP3guXDvf78vFY8poitw2IwPkV9YMwdLEOFEQhBGDA7UP5fb6QJgEAJOTIEJ+W7q0kQx36t2u7FJhBlVYcSBvyK4NsiOOG+95Kz4uB57rct0HL4oItdB00IUqXi2sqzg8Qr3doYygTCCFeHkGGSB3YaZwFtQIo+fpOhNoN1snIEEBZFpuKDAnyRLXlzRg5Q7HWqODXtpwJ/w7Fd1Ub1S5odxXyKw77rUlLxUjvyH8LNTLjLu+hyRDAERAiAECdN2Bi0UwcjTAYhZ3Pg2mHPLSkaAZipAoysI9ILDlQQltLkmpI0RBgwiOYJkgBH1TvvrIN2t84LZBKM1TbBskP5ryQIpzWfC+V6Qabt0nphHQIacnEbp3uukvBFtKzjXiTrcT5f83nEcmIQDyqMCUZQkiJHG+WpkoLARSS/qksc5I5QqthHaE5T7XfcsTWGkweTKHrYpmSk33OnLJ2vHKaf4JGkFc0abGuoX5Uguk5FYiTvyXimJRbpxWqxhRzuxaazXzthn/JRI6SHu795YI61KQFqCL1AuiI0Awy7BgcBSF610ffMm5AYki7BRptUc4e81hRsyOoMSeEOLnhf+EeafGowRS+RADDSZGG2E5IcuXdR+EdaAkxky6SBGFXU9Q04B0fiZBLO9Q5jZCiTyYjRYeGtJuM0ljzA5B5rlyaKasRTZGIXwY9v8aXte4iWdgI7xwI6ZC0f44ZWyEP+r8j12hegPz3OZYMScS3lM7VkdtQ8r9tXNScadO031DR4TlEs1zSh1z+3d/hvfUcqUcIldJBrBQKAX6QmZbkA5pbz6aaYyo1GlVkiJOBhP7Jrk147hbWqp6mYAYTOYxJNp9rBPHafuNQaeav0gpJ8s5AjU+2LIBUA9b13/+oiMuw4wBHgKMgRAACKeKELArpN4X9oryzMkL7MBWkSUbKO9VELTnTYY0GY9ZTHbZS2H2clBQd4j0KRNOhc0Sqw82Obc/Iyap3XbMAJuZRdaRu8kAL+4bUToUmR8qjCqKgqLdHirjQzR2kfijeZEsgEVL450RjhPNIxE8R1roXIjtcL7xrBRnCJm/Ze7REx2PNp8XgCLVpHKjCxTTbRoD6zZ7SfJBDbfRLBVFomI3NvtnXBJYLkjwyFpKWaITGqFTGYA0RgTrQRAUZ0grUg8mQZk2Y0upFCk6AII3holYouU43NAa2u3LzIkHON4qbG7uu5xd4LGQIAGB56AYUMWYSkk45Ro5c2ME9vfdISBG2rfaH3QEIqtI9kCIfEajr4sdL2xnuVXyg2JE3XBLeiQY0OIci/DauM7RpLnATJGpfEgacTuQNejYfPMG5ZIFz4s6R3JcsoZAmt6FjLCdUsePI8f4JQrrpXOq0z5W/T9AxzfhjJWe75BbtUh7peXH/bLoYcMPPJR6bLoynZt2BY4SqIGjjwz83Lm6poahg+PDcdt3FoAnoHeE8TediyO5MP7DanoaMX0k7xIHTpnB11/Y/TmPtGqoX9yfXBk0a/y3mKX2veH7Ec07TpDviLdES+d8WbTTBbJoo7DRN3Dhr0+uBhDetGDQh2WhjoDIZw2UNJYH72FSZys/2UGRoZq0QzitGseOeXfsdSKaRY6DQColjWKMVmkpTVsxTJkJqcP17qE1LAUejIQIgWiK8I8Olp+jIWptctgghL9aASGkNNLvxI+7NntXEqVwlO+Ipd9B2KO6i5KAgtOqyBqC6X0k+Jwgmpe9jdPhtDtJOKX1GTgNWO07Ffiuni/5OdO6YYcyOKk96t/j30vzI3bODqCkCYP26emZ0/jpOc1od59L8mzguYrAGYE3pGheJTJLG5LFzAPh6aKNAhgqCkYoMAfTN+Zi0NmgCK/BXagGbkgCX24QIZWfGDVmrnLRBId1fqgNB9AEaShYkkzHpm68hkXMCO9Zr0vQ+gFS+kPq1AqJ/kP87ZkyvM0QDl3WQAMda80iNz174+biEehHSukLzFMvJzztZVwuCd33se8v17REHD7vN4RWf97ppC9Qwf6EbuO4ZfaBnoU4RGsdRabECiP2gJURsG/gdi8EalhHDb+zQZd/dGII0R7/i9+zDbDZEbY7JNm6OQrM5OjCBh4aMFLQ8/cYh8wF6LZPWPLdY15Dd5FCxIOxpAlPUEkcJmv5ZMAIVgHgAcBKeWyozmZtQmb4Ol55n49vQ4OsOUg0vTgcNEqpe+MZq/YZEQpTJj8ODhzTSkrHlaa9LkMpGfSzO/VKdHfOsGYIokmocqAMftJrkZw5mdR2wG0HER606umkJdM2cGozlw+wQXQDKpngSVAeHbjMW800haqoCSEio1QApglJQTLLBOoWGSDMXSNA8gzJISu5YkWMjQwBHpiHyeNfHvjfP3iXUOEdSCINAGuCTDPwptUUa4Yo5vLYaJY1Grv6J4TU80j+ch0vvBRoyRH/zu+V4UcXmkr1y6wTxXuCETBmTkKFSWaW6sfZJowmRAkTkMHb8at6BtEOXe/7Sjl6uHaU6aDQoFJKb1/AArwVyLvEzSrRGiWaJF6wbpPHZ3iON85ichQxJO5lC/iQtzcc04IhPU59CTXrTpeVI5GEIAZM0PhIZwgJX51IhEZ2P0mCS3aJzUwDk+XC0D4dyAzSzcz0KhzDRnYgMiRocbnxz43CEj1AJ2TU7984V7ZqqjaOg8RvSYKq1rOb7IMEWSjhGMgRwpIQIAOSPTDPZDXWQE4iCZFo1y2GsGubvQfumhhRRaAV3/3utCd0BJpvqMKVjgJ5PNbFyeWi/5vIqQUmB6NA+NTSCeW26Y8aWRIoyTvzVGptaIldCrfBaW0/h3oaax0k7/euy038SJEAypVsL74IlH4p3mGgdJiRDGFy/CQSokdYbKarfWjioVOj7qrlAsx5UmqICZDTJrE9kaiLFQjBprjqoep+gskFteo72cOnKIA0eXBhtAOhvmijkMvGcvRGoWrMV8p/UxoORoin81KeUuVj5RJARFXLEITbMh+AoTeY8XvGM/63/seMBTv+eEkK3iI59GHM7vE2lNsYTgXCCeBEaE7rzgn2Zy+HfpTrxLusIs7mkidgxWmi7eF3KM5U5GAdx0S8IIFizRkzp8PMPMq2rgKqvSwvPqAYwY4IznWN+gwUKqSyZ0iX5C6Z0C/IePJ9dNHFDZdEG0uGahk2LUZumJEOezLXCPbUamBKhaZo4L+M1jQbRceh9KALFqNuC62fa2HAbETgfXjuwuVwnCE0db14XxgG+RjcApUBJHnOQpZxJeo2p7dTfNa0T9w0XGCWjFWKh8aMhMhh2JZhatCzKFPTbGejvozrTaoQZYgLp+605t2uf5pmieTvSZiXZkXvJbj571x/+f+Zs4Sgcr4YIYNtxdFcCv/jNJt0pltJDkNEW1eRPUBNuM1debgLjIqZoSKPmYFqNVgNpi+JtR8u5U0yw41/tO1QrRGl2egVMrhEaQ4Y043PoDrekNSLtnVNbpiqvdrxxpmQaU4WMFk11TpGQJyEVQkCF3u9AtT0xLYbpxmkX/2cDLowhQ0Tglw5nZfNL41PqX7qOcemStsm5mJaCmojmh4KAS76Xoja1I6RgAkLSoM0gkNKlIAPVlSq1PMekDfJpeu7QvsgQ+lvUMO0TzPcya5sYU7xZA0aUvuXaOWAo6MZIuN71NjioZuiYyRDAkWuIPF7xjP9tmxjLhCfSAAwue6jjn1T32Em4JMg7YVIs7RIAZCO7HT1q21hLiKRd4pBGoVHx7jwnEACkO/i1QsEhtEO1u7tDNUVSGRlMpTUqaofGaBkkcG1XCnDJc4u7onyeRAvk28/97vMIbYj52ctsGG3XKPpaS4ZwXcI5SGIdoS5d+cXruY03bV4Jij4QfQxFrY9gPjVQS7StkqlzDnFln2tSTfsnkimqyFBFdLVsOTNg0jOTtPVIcyHGmCALGg2R5t4aojOVZUSlHPjIJ75vmnpnxFFriDwC6+66HuOvGvRjNEfY/IRLS+BOjS7l5+rm6uFMGAZMAqIQL7Uht0NQKIdzYqxNz46B/ZighgzROpHWrRjlpyXmYfsSGOYwldOEc63VFEnfu9C2QQEZhDLymYTvmcOYXT0tAeCEW6ztwdoImsdDCqZQ0iSR98S9A8mHpXiG1gAyBB0icRoi49uw6fg2SHO05vtg51lm3ufK5tJSyO8xZMg53pzIEfPyoYKYRiitQWnzRApznftNs87Xzoel/BVyhWotPWIyJNU5WFaoDAIwBtn2FLX7BeueMc9R0iJprQ9yfb2nPp4K50JDBADw8P/6WkhCsTLAB3pW7SbMuUNUmrRyQmyNtogrl7uXWeh7Q4DTEEltqNklwO+v8C5z2KuWqWQvLvVjLSGi9QFs+9AfZIkJ6WKBzCUqd7MoJIGrlHdq7ZAE1fkazHUqpNXsuBNwWiN6yGhy4ChbyND+qpyexR1HnRmQ02jdvEYyuQ9/77g9fU1R41wM5d1B1BpJ35gGbN+h5mvIEBma4jk/3HdAy+QI1ZilVpp7pJDbJcJd2BAAGkJcIkO4rIT4Il8iad7gtETksFZ2Q2hoP1LSxvibNIvFOCF/zJrNYYBWYhAu4rk7EvAY1FiytP35LoHyXYjyaUkm0miLPFxXl18DjZwmWLj4+8+DdgjgnGiIAJC6LSMgDN45kHbT9oWaD02jlQKIzyHtJubAhX7M1cNel0wlFEJ1AXudkLW7yrVlaaE1waHEegxx1oCbJKcS/jBmippVvI4gaY3UPkhDyVAtcgtXri5JO1BqX3If/t5RHiY0NwD0D3TNvbeS1mPjgD0w1dc1hAxpSEWNWSTpY0kLJmoopT7JPhPxKd391mw6vk6v4RL8RMRnDg+GSTMKCiOaXZIw3FpBTjtnUWuOUC9vYtyQNtPjGqoPBwcY/13vY63TRJELzTlnZIj61YzVtkvyoe+vwobfKE0Rd6A7Tc+FEX13XsgQwDkiRAAAj3zyX2wT/uUwwrVzTpUWiRGXnhqSHXhJfV8qI4ehpAhAXqiKZiUk4ILHmLQv2u3RiVMhfFQHU6iAaNPMgROcpugbrozqCFcKciMtNqW8kvCIMQEp0qaL0LyTqc0NhpAiDvQ8mnBfgRTl8nDtoqSpkG6ENIsSGSreoyeLUt9WjyNPaHDeJDR6ZRqXs0HEyaMXWnnGOVYInlA192n85SQCJNQZ0ruzYIrHbwzV3MwVLbdUZ4XW7VySIS49BQpaNO46139YLk3vFWQILE9x15PCB44pel+pfRkEmf2c4NyYzGE8/Dl/Z5uoUQ22TXyJJDw0DhXJYoyJ1hAyI+4iKEw4BoC3J64Q6qXdVIyhalzhvSVFa97hzJjFXM4nucAKmEC3jSwASOVjlAQ6KU+NUAjAExvJZLSkNdWYz+XKkTYlcLumhKY/S9oHDWrNG+jf3qyjxnSOXBfN55jd+iTgAg5zTUJel1AM1w3AkxTJrE7KD6DX2pJrQ33SxHD5Ffe5tomkh45zjVBcayLLlFk0ncPXSmZzQ4DJEGe+pN3gQRuruBy2jbVt18gLU5jLlQJVaM6SOlbUfCs1JnP9TEKZxBxTKH+QzKKQh6Bpo9xRK3fV3CetETs88uj319V9BDiXhMgjIUZDbCe1kdD2TYg8JKGRTqxzEyKAadSx/v3gd6VJUyhJEkB/0cql6RkKtWUESD5YmvfEkSK8M9k02zGV/K0kRPg3TGKnIESle4ZEipJ8ImpIkaYvaurXkH8P6fut1UDUYgwpQs/pzylqOpeeWTSUFAnvK/EtyqQp0cG/x8KEdyUK7tAvI5t/GBkCUBCiXNspiSnlBYDeuT30eocI0qaTfRmkAAqa772GENHrnhS1TXpOHm2/BEEw7RGgzm03mrAwyKX936hdiQWKb1t84LTNGmiEb/9cNcSIO8NJufF6mBDarj8eJR9kmq4F5yPKrTe0zzVrAncvKWeITJK0O+ePnZOt6LXSfb1n4+fz80iEPJaHbsAkoDaUWmIkCNXVQRnmAhUg/MQ054G0YluED6cGkoqXpksfI1WFM5MBNafjiEspnfudJUK0bRQlE0P/W8jXBY2Qcy4e0NrF69uyMsISVz6XLqFHypl7JW3PUEiCrl9QpGfGY6LUF7nvPCdQ18wPmj6Zigz5+0ukiD4DFro90dh0STqQInzvpoukCN/bdSkpovfhvFiLIqQx/HWRxOTG+IHIEADkNT1c26Xrped0Lv4t+QNx5xqVTIykNuaA5oTksM5kU2uRkiIPaQzjyG6aEP67tOjLFLTuWNgV0uT+yTRDNcDvsESKNJE7pfyHQMlsPjdG5zLpHGuZw31zSTF6mSQtV7OuKGWu3H2XCOfKh4jikUe/X1iMFE5nBaf/xEcFLzAazHFaNgCkZlLIt8hfLwhpJaE/wc5mut+GPQwZ+p5K75K+P8HnaNIm7mvXTCOEcXlqxyy9d0ooFmKVP1hJ+NAIr7kya36XBNSxfZgTmDUCPy0n5wwrjRGmb13byPVumMUTz0X4Z02/Mc/ZSGOo1N9Sv0n+S7VkqAKjIhDia6XxJvXVGpmm+bbQUOElYiaB/j40VLbgu+rNhsWNysKh5yIZks7Ok9IAqY/TglkPhXehCvQ0hJDQ4BkFAbxYBsLs69xUfj5DNUNTncnjQb+hDUP0MaT3Nldwhl5ByjGCZS+5UedaOwQA59tkzuPhp/3tbWKoVkehEkxMlkqocf4citwkqhA6qyAu5EeyiyBplKaY7DS77TS/B7vzongHJbM56YDWnKkYN+bojn0JkoDI/a4R0MIlvm6VT9++zOemhkbw5n6XoJqXFP0pXBdN5sKY5AXSno8QvY+OwbHvQTOmJb+hMWRIQVKLB8iWUPuNYgSCjLQKY5Z+VT/z332VL5Gw8VWzllWRIUnLnTEhT8z5kkNmO3VbR/msDIGChO2VDO0bijWdXX+GbHYPfW+SqV4oVtocYK5LJoa1yMhXj/zRDwwr84hwrjVEHuFFDP2AJfbLTcBDdt579U1QBobXFlGNEcHkZoB70RYp+krSKOGd0Fw697smD6fOBxjeP4lw1d9hlHcEM0KZNH5L2pOS9qWEjFBUWnDZ3zWCA4djIkMYvZ31gW3RzCc1GgrSJ40QWY4tWzqUVdIUce3RaI9y2iFab4fSXNs0O641mhwtSmOPe0apHzYdPz9JEeS0fUzboJ0/JtYSab+NJET2oo33LRaxPL+ptGjZc7V6ayjVJvhyMNGcUsOi0BIMRk6btw/ktNZzYwqtUKU2BwD4b0b67mhdXDoUJR2yy8gnPk39rXKyj4QLSIYALgghAiCkaOgunpYUSffXYo6FtLAIzUKKpiBGNSYZmnenOQdpg3YkuXCWJXtmnJZ2EOciRQA82cATmkSKtOnctWx79eNa3C1Gvw8WKqYyhxi6i1/Tx1PXXQvNLrak4WjIAkvKK5IiidxI6Q1zXSTvqP0boU257yR3TbouzLHcAb9ZlPok0UwI852/vl7HaziNNRqaPplgDRQ1NgPLENNcdM62SclQaAfSumvWSNcVBcfivCXJFiUBe+bvfFYcuVaoiAJBYfPUzHP4moIM8fUrZBWNTxaFIMtcFDIEcIEIEQB5MTU7i8k1Rlt0yI8YQPYPypGigraoiNpdnClJkURqS7vCvfyM/xF9vzWOhrUYEmWOQ9Mm78NpHGU70pdTCdZU6NWWi/JlBQVhzDnuvWvOJwKYRjvE7ZZL45WmNfmmQoUQlr231If+91ywDYkUjUFH0l0hzdSfNZOTviEOuWeqGVfa61I/S35AXhhjzLjYNN31pv9qUXsPJiWac/BAJkPs4eJiKHkSQKEpaLakDSoyN/U2HyVBNIcxEWXxnFW7BkDUtE2yiXoOtUKDNuM0hKlc8bD7DoCLRIYALhghAmBeUGlwicILEZxRsAV12VNDIkUS6RG0RVUT3KFIEU1LeTX5S1FUxqRLSEK2DjWHYsYh3nkqkSLut5rvojQGkl1rQfgqQaGNK5IiTfumgEaLMbTOGuf9IYJ6CYVnaKT21bSFkppSeuh9TBmNZjMBoG7MT41aMhSuM+kkmtymnNZ8T0PzlMiLBpxfL05Lwq+WDA0Fnos536EpggfUyjITYhQp2jcRygXEGIFs4B+6aZD7RnL5tO/tUH5fCBeNDAFcQEIEMMGLosTIA5GiSX2KapDT+JQmLXTvZDs/x4DcLu/osomWCV/P3SNhaLhmyQTQ59lsomBDF+KcEKvdQSyRK7ozLT4S0zZuwdSQolJ9JXKhfRdzfSelkN/S9aFERAuufKxhEfyFwLk03DlBz3ROo91htD0aNM71w3Pj//FZLDkyVCInEkpkUnMf911qCOlm0xfQpPWqZu6s0RTV+qX4eXaMOZ0YppshQ7Wm3qJf6a5Pmibpm5IpMPdblTCbm7uPRcOwb60QJsMTR5BTRUGVIEX+05hGshtKvPncZGRI0W8XkQwBXFBCBLB7YSU7ydKuDactwqZLlBiFsiYwt+LagZEjRRWO51WRSo4ZtI9qdvETAlwShggp4sjSlKgVvjApSq53cTdZ8jco+UZx4ZUl4JPmO6E+DE04dZ+11CfnlejXaCXmJEVS/0mkiI6z3H1CmgVWrjL+PyzpoWluLs7t3JcIxyGFTS0ZyvyeCHalcPg5glTSRg3VDkuYOnqotr7eutJNay0yR9jnQe2YWBQ8pFZoYpTIkJqIlL6PCbSzQ85brMUjn37roPvOAy5E2O0cHn7qa+pu0ISmZSbnhFjURMKqEd4Ugor4W+VZMAG1E9tQYrDvYSiFV83lnwpD6xWEAjYkPA7NnSuzBr7duO+kjQBm4m0acuJ8yCCMmcyBiNuf82ePVIchlzDn2Azf5wQEp8rPsNKvSpjf2HDcpRDdBK7wLjji5JqmTKhK/VjrT1U7Z5S0RCXtU61mCGu92OYw7dmnltQxRCJ5Lmb+kH6X3h3ne6Qxl+PQCWaFAHEeE0yXVRoi5htUnbM0F4aefdMrZ49r+ZFs3E5mbcO955nGRPVmeNNeaDIEcIE1RB7VL1BSjSdaBKIxghG7RSUzBU3enB9RsK0eGJb7SCacyVEr5EomJ3PDlQUC1oyMHghX0oxp6g91d+o+SHakktDNGt+fgtaIEwax0Fq7MA81Ra2BpI0snZdUqymcE16wpYe1ekghugvt47Q8EulhAyNoNL2SBktB7MeSIQDQR5qbgAzRA0D5alwvr7pdA1ElPAYTTMV8MTSQAocc+cLmcuHaAHO5WswZirsA1djYh4kcNYubA4cKAFFDcPAZRfvAJSBDAJdAQ+RRrSnigA9v82BO0+7lmeq8FG1ezQ5zzW5izeRwXjREU2CspmVMfcyCL2opAfgDTKWyPWo1FYJQFn8XyF0Nds8tfmsLJnyulLdXNvqttHs/FKUyaoMWcOA0hhgaQUKj2ZHOb/Hg+n1qc8YaQs/6qiG/lanmoBLx07zjkuZQQYaGQEVWJpj3ivNCQmLJ5g69T3Nu0VAyFMyMqYaI1x5VrZs1GqLkvvyBnYMx5hylfRCIfWzOcmOqgFm1Q9sKtv87x397A8dAzQb4I59526A6zhsuvIbI45FPv3W4EEYh7KzvzacIt4NDSVsEUBeWe66J6DySIIwpiM3Q+gSfNrFtOSdynL/0Oy2zQwJDrj9ypjGlXf2kHUwEJ59uW1kTxtWHoTGpG2JmJz0fh5oIcxJKpG7It1zqr5I2hgvCQPtFq+XRjBefpgeV5p6HXiu1SdNmBsdMhvC92TJKc0Xuntq8nVOYtg3YaCkFy0neaZdoJqqsQTiNhuDwXxf9dT+agWKb9q0VmhI0DPqA55g8MJWkBZTIEHffFKG/ES4LGQK4RBoij4ef8uptYkiITTGKTf/8hL34FEn34o+nRluErqsO/WLLrfgAj3noda5uEh7y3jQCMteGoX5FAHwo9tJkK7W14JfmNl3/VGyAPiHKgSUmLf+dcdqhBi2mOdJTo22t0UrUYGx0M432r1Y7xF3HPkTiLjyT5vJqxl6ozNXNcdjcmcurmRsnRBUZAkjbz/4+LRmSUBT6JO1y4f2EtiaEGYcALxAd/HtJS6SZ37j2jvEdqsBgwfpQGqJ9mZTNaRY3st7ZovSWNEUTlKf1H7pMZAjgEmmIPMILHqItknYRBJ8iMURwjrXX7LpJ92qcf7FmiBGSxbDc3ETBHWZbauPUoJou/PfQiaRm92gucidFP8S7l0ze3thjFm/1DnzFs/V8ETrUziEH1RYW5KQ+7XlMFFozOk3+oaBtnKreqcgQADseqs4lmsIckM4f9D1TjRAlEJJ2iX4nE6MXcltDxn3buLRg8nywoxQ0mrtwCX+zhPRo218jkHcuaitLGw1Yq+jJED0egK7fI0jJURx/IcgkYpClfZnHHbH/8t7J0AFw2cgQwCUkRACEFA05fFMKz1pjxjQ0Br0GNYJsIeiCihSFEKXCMw3Z7dZAEho5YUNjGsihFJodY5+kCNfHEPLtz47PjxfA0k71QNKS1J0c/Cj4A4TfCzvkQt4iKRqDfZGi2nq1QjXArOF9GxSooCmE3U6CGpTylkiTJnx8uCaYkQhjBBMY1flBU0EzrvbsWF/UetS8M7GMkWG6pXfErdNS0I9AmrqUDCXlDQyXzODgRAhAJEKTRJwdirmJ0CECJpSA5a+py1Xnjf1+GckQwCUlRADkhYdD4Vo+LWlAMDGShNNu5IFZ3M79nKDECIRdLIkUSZir7bWLythFqLRDNtd7ErWTZIeV5O0tbhwp10YvkuyUpfZKoP0jRXbEabyDL5jVONo2qimVCGLNxkHpWu56Dppw/9y1Wu0W/b1Wkyr0Z7Pp+toiTLrxeMG78FK5WsGa25zKvVep/Z0L/+g17m/6Ww5svhKJyJU99Gy5YwZdPyRzuVKfdw6dxcSs2/h+Pw6TdVzQuG82MZCCoHGvWedHv6OpBGhSxoXXCo18joNp9PxaNoFsUWr/ZSVDAJeYEAEwL76kISoRo4wp06hgCzlhYQrkIpeg34qTgUSKJFvy0k6fViMzhBRNQYxyGLprqlnwc3WJzSmQoly614aOrbOK+HPagRIpwmnR1wAJKjnzKIqhpGhKTEmKpjSVoyiM50RLVBpTJY2RpAUqaZcK9ea0WoHASFow5huUNEqTk6FexfsVzmZzORatC/JkqBitjt1c6VJtkMemP6ckRGhbIcrTJ0MNWS8pJhGoZ/IbuvBaIe2zCAEveGsZ4V1Mre3Zx2Y4XG4yBACXL6iChBBsoQaFgyO3gncaHnlwsAW2/vnMYABAtFPfXiosRKWy8X1tw6c9phboSu3CbSuhNvACJnHaPtHUG3b55RPd2QldmuQ5O/lSEIXSmOB+Lz1n0gYyTgB6AU3CM5bCb/vrQ/zMtAR36NQ6kPQmKBGiKeaOwnhiAy7Q+Y9uapTmAgD+G8JpfA1pC7PmfPR75L7Pij5zbTOeDGk2MehvMCNpQRgq1Iu+QzGD/HvHP6do1u3zLxb9dclbgPg0E9pbJEIAvXfgnAvtwOnZMFbg1mi29mladqjgCYo2ZIkQDX2O/64xpdS+T27OrCyTe55HHnu7rv4LjkutIcIYxIxLkW+cA858blCwBbb+ibVFPbM4OTR3UxK4alC0/6/Y3amFpC3SPlNN2+bWFAHUmZeIZRfs5GvGXMk3QBSMlBqkbsMLTJwwU2PGNwWmFIpqytoHGQKQNXC+mh0BSYjBUI1RScNeCDlb9G2SzCm1+QnYYBNTaIaUa8Qxms0NOtNGmD+4soqHQHPzAzKxS+/XkyGAsmboqKDRCs1NhtoJ5QcJI8kQ7ypATBUp6aBkSEN0agjUyHXKyFAeRogMBoPBYDAYDAbDpYURIoTJ7Cd7DsP9KGBZTVEt/P1z7HJz59bkMOR8Jy3m1hRR1OxcHTpyTcZ/TQywMBeGarcA+lqiUlCT4J+2/T3ZGZa0RBqzJLF9lWZU+9IScZrOfYatLfhpNZsuneNofqqB5OZGrj7ud3Ktp60ZM1fSe0tlabVDHDQ+C5wPVy5C6AFQNe8UgilIZeEDZYu+MEG7jDRCnHZorjX1kNh9ZweNJDe3dmiknFDtLyRBm3+IddBAc7k0T2PaIQIjRATVpEgyCaLRsXBeIqT27x3wgYT2jJzEWcGqZX8Xzea0pGjoZDiFj4UWtaSIWWxV9w2BlljkMFG/VYXmLRZWcLBOHKH7pjEiKer6AlavbaV2HioEN1eX5JejvX8oJLM1RvjnghGIJnQcgc35zmR+D3VJIZYloqLJU1Oe9ncORyyMYwKiySdnkN6Pcq0ERGAEc0k/HzjHl4XvT8gQhz2HPGcxxH8IyRR7N5ML/p7NfshQLUrtGBLRz/vczuFHNAA9ktc2lz6AAgcLqiCgKshCiQCwzsXxnmZR0MIM/VDGCj8Vwoh4GCdXFsbYSbgmMpcGc+yalSbcIQEGpPK54Aokjzq4goSC/b46oEJSwABBAz9j8g1t08l3hYMsAMRvSvr2Sv1R8jHRXM/h2L4LDO55MDnzvxf6003RRk5D4oXetjKQgtSW3PMObGNxnikRpwqfvkMFWSg660vBFDRnqgHwaxIO/lJaNyVhVVvXvjFUDsgRIYD5idA+MBERSknDCIIyZLzU1KfUEElaYtMM8TANkYBHPvO2Cmf5Csdx5h636VLzud79AzVGU2iLPLhdkpIjacNrlqowpG8Bjmt3tWCuwea7CBhCcjBKGjdsSsdpirBZiBSZa9Pxp9hPNX6OaRzORYbwdUljxESsLJ7pw5nFMe+Ing8UysfvNadxkjRD9Hk4KNvI3gPAj+/SmKlYC/a534m/t6IWohRZjpTbL0uyzCgEhPFpKWgCN46PgQzVgDlfbi9aoX0ESqCY8BkmMzE9JBlSaLOMDMkwDZECDz/pVeUPfKSWiN3Blwb+PjVGFbuTRS0RV2ZpMsP31/Qxxtjd3GMnKvvUEElmK5xQUyH0FKPKeYjvmNH4IK1QEzRCRFOEn9vfW9IU1WiCjkU7NCcZ4lAaYzUao1JVNeGtc9eylRT8t7TlcXMf1gwXCVRhPk0uH9G8NSTMNkBq/hrKGklQShpCrGE6JjI0QOO1F63QPjVBGGOeobQenjftEHM/fS4jQmWYhkiBRx57e53gzoENw0qCLVD7ZknDM4V/kbTw0t+HThYtEsypcE59j7QT6hhtUem5x4ALF43fbandY+9PysoQUZhgF2yops9j7GnkJUKF3yXaBXZ4Z5jbHW4bfoyUvkWa7xgwpY9dUVshbG6U+pLTGKEw3azGh9EosT5CuUN5Nc8koUbTVKqX67eh7TqS4AkiaoKsMOthmreir0sau5I26JjIkAe2Fim0de9aoRwkbT++VrKe4PIeC/x7mXPMiEeElOUxI0M6mIaoAkW/oiEajGTXtK8xEg9yDfkm4LS4XO1wYLREg2zGuXwUnHCvCdxQ1Oo1cls07fKoISxcu8fer9EI7DQjIiEaoT2s8h/CyGkRaVkcuOf2GqBE88Noish11pdoDj+REuYWVmrf85BvQ1vv2LFY0+fHtMzVEFbthhiT7yiW9pK/YOG8oHRuKcwng9p3hKRnJGbXCtVuaI3175mD/HDyVfJ7RYS40W0p1DUgohx+LiNDepiGqAJFv6JBvkT5yUsMzx3yTbAzUdr9pvUBiB9hVgNR8ikqmUNx2qZsW0tEZkLNUO09UijpIXVqFgxuPO0L3Luu2TWuycOFzCWaokRbFO4TfF80GNqfc+54St9STVuHbhTk/GJqtG+53f6SSRxXjgT6HnI72SVodsK17TvvZIiDJqpc+BlpcIaQIcaXhr2Gm4c2eY62DzOYXSs0NOrqEGjvr7GmKFkoaCPKza0N8qj0F6IymJGhOpiGaCBEv6IptUTMPUWNEcCs4RsH2bBL9uPc/ccY8aZGc7UvlDRFdGz4/DW+aiVoNUTMPcV8NeMgpykCiM9H/IdYvyKtpsi5vIZxrNZRC9wODK12NFduDmPfz1Thy4eQoc7FNtW+h1y/Dn2n2vFzXslQzkIgCYsvkCF6T7G++nlZ6rNjOctJg1nPFdqHVmgItNYjQvvD+62RmaYkQkO0Q+YvNBtMQzQQol/RWC0RpzkgC0U2Ih3AvLsX3AdcVOkSwsf5FIWJaaSPiQTtbi+3w3sop9EchmqYJqtfseBptXljD/OVbM49GBLWYIdq/Cw5TRHVZNQKnjU7piXtSI3WY0hdUplDBJ0xGqOSTwgHLh/X9qFCW8nfoab9F5kM4X6SAimQbz8bGVJV53Rk6LyA1WadV62QFhOsfz2yWxo7U8pVJU2U0leXs8oxMjQcpiEaCdGvKCfk1URDY3b201v24GNEMWRxriGPnBZhLnD9WjKL9O9EOyHjHWktau7hxsjcGiL0btXvuWY8jLU75/qkRb5E0hlFQZtUOBushNxuraTVyd1bQs2mRAnS2Mt+F4VnKrUFa9uG+DnltHVTziND3l3NM10kMuRR+v65A5UrLBGy9xRQ6rNj1xAdjVZon0EOcuuuJHeVzhwK+Xb3d12angoT+QvZ+ULzwAjRRGCJUcXHGe8pmOFpPuy5iVHFgXbszlWSQVHWGBMXDXDZmsNRh5IiXxetJ3cNty+HEikaGuJdAnmvrHkkAL8z7FEaC2NIkfTNlEgRF4bbX9cIwzSULzem/O+4THptCEqkQhpf/m/cZpwn901I7a8laEPK8PXT+zFqNXK5tkjt49671D7pntJ7L5iOZR3ppblmarBjXdAM0d+Rj2Msb15zuVnJ0BzCNMLREKEp69WgtN4qzOWy79WHWp8j5PoYMoTu5dpvRGgaGCGaEGpSNNS+v6At2t6aEXDnJkXahbrkP1Ioc68TMIehqvox7a45B6sVxoA2iuGAXXCVH1FWazIw0hyHHClq0t/UpAgLkZJPEYcaJ3ou3xhtScn3iSK36SDdV3qWMZqrffk5DV0C59D0ScgEFRgcVWxKUlTS+ObIELp+LIRoMBnCa+wM5xnNSoQA6sJoHwIjCdFBNH5D/YSYAFZGhuaF+RBNiEc+87Z5Kyid0QBowuT8AfYVGaWEkk8RhhSNzpcxl88RBo0MV+vzMsXiodFa9a6VtXHJAjuFAFdDdnHesX5EXLk5EzxvpoOfGUeoC9eYMnLfGNcOTV6pzJIvSs4vRXq3QwVo7XNz90jQ1Fl6XlqWND9qy5Huo2WMLTcHLhralGRoSmjJkPR7iQzVoHLTD/tgFKOk5uqjPiFey4A1DiM3JGffu9aso/vyEaIo+QxxcgSRDc4VGSJpaWwaGZoWpiGaCUFbNJXZXC/PgbVFQ6PNlUzfcpPeVDvCXJ05gXxs8IJ97eDlTCuJZoTmYRcLTmM0VDsUM/fzJb+PjDjnwfkTAaRmcAD985maJn4bkn9eKdIYN8ZLYzf0S9f/Nrlrmt9LGj98bW5th1ZTVDLnGurflEPu2XPvJal/wO/SPWN9hrTfyxQbSTVkqLBRUSREM2iJBmPI+jlSY3RQ7ZAqOMuAzUIN5vQZmgtDzeMUEeQAjAjNBdMQzYSgLZJ2NsZOZFRbxEQ9YrVFeIEvnMlQDfThspFvNP45tdoiWv4QjVHT9rVAOD12kt+HRgs/A4COcGg1AtLfFLQ82m9FwXQGQYYSQEG7UTwAUiJ9HHraKOldCNqE3En0pZPqJY1CScPEtadGE1SCRnvSMX0sRXSr0QaV2kXbiP8BjH8P0u/4Gncdg8x7R0eGuHNghpKhHDTRtyStzRj4soaWSTVGFdjLmUh+bS59d2wD0TpZcyaQBr5c7izCOcjXFJA2p0ob1MpxZWRoPpiGaA8YpC3S7mYoo9llNQDJPSPj8bvCIldDBLX+RTmHZLUfwYFMCSUnd4pSkAXN2CoEWfBjxDnHpj3o771nSTIXBCQpby6fBqXgCgCxP1CUuYYxV6jSFGGzulzkM3G8KsdhSaMDMM6JV1PH2N81bahFjTYo9w5yTvFTPPcQ7No7iZncWEJU0gRvOkFT2vWuyc9T6V8qBtZgNDMcMZGuTYkJgz4c3JcWoLxuHoK0HEI7VAqhPfReiG03IjQ/jBDtCUnAhZpAC0WBQjHhcA70pTq0pzVT1JhUlaAlKV4AyQ1lrcr/UOBMgaj5VcmsSDOuOFJEiDOdEvA17vfQJg5cyF3unlzfz02KmhagRTbaCelhwm9TUpTTUOBxKRH4GhJE76dpCk4IpN+2NqramN9zGCKs5NpA80ltpMDvQdrJr+0HjCEBMnqXRm4yeYwhRBoy5OvwfnlYg63VDGkIkdKst2iyKKWnRkU456PwD/Pw745aIkg4EiIEcEAyNBERAjAytC8YIdozetoiapKVE2AlVJCibZHM7n+FTWvAED8igP1obYYsJockRFMBkxwprHLOn2hoSN4hjtVDAzBoIfkR4d88IQJII85pSVGNUFYSwkvQTNU5vyF6TfJfyQmGYwTH3FymbfdYDVBOCJbKIOXValCzc2zN+AFGSB67WVALIThJ/Nvlv+taM7khptway4Ea0HJK5WrqHUKGDkmEanBZyJBphS4cjBAdAMXw3ENIEVcOB6Qtwrv+2bqEEJCDzyOaQ0sk3l9JjM47KZLGkRQ2ekhYeF+ezzuWDHH3lPJqUGM2t9MSbS9VaIpqhK8arZDWHIhDraaiZD5U87vGTI/THEntnEMDVNL+ZMrgNKUarWoPtWOH1L99ngOTIQD+Oy+E1t5mVbZdQ2BzGCLelDYSxpL286AZGroO7psMaYJKzVKvaYUuIowQHRBqYlT7YStJUe+2EjFKyigsTGNI0ZCDT0sYYuY1N7D5gdYUQVuWh8YUk9NWlkz1JOGIvrdaM8Y5oswB9J8rXO8Tou1l8u1xZmYacIJSLRkKl10QtIf6e7FkL6elGCJU1GiQSsJnqX0UNQK0UiPD+suF+jLfR8Y3bwgm0Q5NSYYA+O+8ghCJJrjF9ij9gnDbxpp2aqAhuceoHZpiza0hQ5oAS6X7c02ZkgyVNny0dZlW6OhhhOjAePgpr+ad5TkBbt/EqLRYaCLmuP4imGDfpOQY2oAhmU5q28DdzxEb9l5u55qQKdo3Go1Qcr20WzoTKSr5WNHvSvCnCr8PWQhrBCLFNDzIt0vIW4Qk0I0hSLm6AIZpiDBqwhoXNmzEvuXGIQ14Qubz6r5nmzuBkHwkZKhXzJQiyFC/o6kx0Bxw79qhKTbkaokQwKzazcnJUL6y0WWYVuh4YIToSPDwk161TUh+D3smRlUBGHIgw0u9sM9JRg5FiiSNkGZBwWFNh9xfE7QjR7Ik4jWEENX6c42NoqXwI6L3hu8ARaJLyyTClcZ0ptL3bvAuegb4+67ROO1ujm0uPb9kdghQ9lHirnHpnJaaa5/w3CxKWtEcRmiL1G2rbcsQ5OZnDRmSysDFEfIpEVLVt8AFEdFolGrzlcaepo3JLYX3PFarMoflRSnKrRQZdaroqrgpcxOhIdpE0wqdKxghOiIEUgRwGG0RM/Gow3XnMMR8bt+EaF/tmOvguqGkqOZdDt1FHCrQTUmKJDIEkJrNMb+zobiHYqiJ6R6QE0KZzHrtDSVFWv8PjTmUhELfqQTssYJoQZiTBLhJwy1PdeYZe+aQkgzR3xnUmBNWfRdDI8Zp7xui7RXGscokcwjmXEuHHDyPIT1TRZCfvWiEhmoVhfJMK3ScMEJ0hGCJUU5bhF9h6WMdot6GdOeuV1dpksjsfgPAYUzWak1QhkbboRqdQx8mNzS8ey00mhKAeUmR5EfE/Z4hRU3T8EL9mNPqKYYQIiqw53xZpLw0v4CcBonb3RcK4X040ofOX8tpfQoaoCL5oX1CkdOOljS2GfNklTYo164S5jhzKLehNXVwFAZjfJByQTDU7wFgfjKU3Deg7+ZaP5VnH6qgOU5CasbUa9YY/yBteaHYxojQEcII0ZGiqC2i1zFUPgL1xEhlC89dLxEigOPWEiX3VbTp0OSHg2bBGbvQVO3gKvIOJUU1ZnMALCkSQ3EnZVS856Gh6tmyJp66K4WRUvsGCyz4voHLU50WYeAYlDA0cmMJh44qpyFDNG+uvIkwhBCNLq/GVE6h2Zz0Wz8PRAigmgCFZpxjIrQt2sjQscII0ZGjyoyOYiZtUVpFYTc4oyU4uD/RsZGi0q7+VNCSIu1uvNZ3RoLmOXMClhT8IQdNgIXdb6roizmt0UB/g4OdVJ/TKJW0TwQlbRLOg24q+lSVyhSh/abG+FvkIj4OFAIPToYA0n4YupmVm9u4saZEyQ9OG9RC57tV6Tc0VCsU7j8wGZqaCI3EZIRoaOjsIWXu8POP/3+Hl22YHUaIzgmKZnT4OsUhiVEBB408tw9CBDBJ/wZMJQQfYCFTY+j7x/epSJ9AitpF73pVSHqA1PG/hKH+Q3OH4h0CzfhV+tNUmzAV6pj8u9ag5GOhIUjHQIYA6ggRzT9lO/aA7HirMZWrCZ4g1ncgQjTWP2gmjCZEUxMhhYWAEaHzgSO06TFwSFSsfoJ0XToBdk7YrZtwYRHqcM4NcgJvmqY/wc0x4ToX+8Gnxd3+CQhk005LhHA+/28MjlGY9hCJvTJaYm3f9Hzy+uGCk/GNx3ntLjLFUOFIa+YVzJy6/rU5gOeHThCa8e/oOu5jPJeotD7aOiUc4kBmqU017ZYw9RxK+yfxqctZKaB5UEpLwN/z1M+TKdMTcVbw1pChrov/xuIQZCj3bg5IhsR3UgPJPG5IuW1rZOiCwTRE5xCiGR1A2ceIjRg1ghdPqDFSHTw4ZtLXCFY15hpcW2rDYXtMvZtbW+9QU56hKEUmA5DNm6Y8zNaXj9tFfyd5RkdeVJgXTnLujLZvtOO0FFSgtgyMnEleDlMQ+7nJkFbwPxbtr3be5bREtaa+NX1fG11PahMtT2hn6uOqNJMbcuiqhLm+dwljjm+YEZOYyE2pFVL6jBoROn8wQnSOkRAjAN6UTmtGNzYAwEShMWfxKxqyCI1ZzGsExaGEZGr/ooIvyOTQ+htJJHWqMzW4b2UoKaL3ShCiosWfB5pyAgzvC+mMq5q8tWVg1AjStWO+tHExN2qOPJgCY77fWvM3ab4eu7EkoSaYSo5cF9pYJEMDgicMFrXm/O4B9GvUgTDFwcajCBF3BloGRoTOL4wQXQBMFpFuiqhoI8L3+jSLMaRojohTJWF8Lu3QQKfjwZhjMeTCKmsxtb/CmPOJmPGb3JcLF53BYEI0t4BfCn9N09x9FLT/p9A8zXEA5RgMeZ6x0H63NfNJTkuU0/iWiO5chGhgeVkyNFcUuRy0/ach+TUWDEfmZ6o91LiHoVHkKqKHGgm6GDBCdIFw3ojRoOhQFFORolqNi2bhqcEhtUMaTLU4lhYiDXGYkhSVQiQXtEXi7qXGJFDALJsCUyAXYTCXxqjd4dV8R0M0VPvEUDPaqSB9u1PPeQDDNUaasqV7x2rZIffNZQjRXBqhpP6JtG1DrBaGYg+WBipCNFQrVHm+nJGhiwMjRBcQg4jR1CZ0XB1TYOiCOkXUriE7z9p+1PTVvrVDHMaEDgaoF4jnJEUax+Hcd6GMlqZBUUtaay5Y0uDgOqQQ61x6CtT00VCTvGMGPaR5Ct+sHCQTsiHQzrMajVFt2SWfoBqUyBAmO5VaoVlEKg15lb6THMb2pR9TtE0z+qaqNEVDtEJGhC49jBBdYFQToz0FXJgEQxbVoVoobfk5TOWwegjtEMaYBXSo/fdcpKhEiDRmXhMEFakOsV2zUz9CUzU7pj5g8aLg0BqlHGrnv0MeqyBBIkMlEsTlQ9ibKDWVz+i+6j6EpgiTGyNCBiWMEF0CVB3uOoQUDY0QNQZjyEt2scss1lNFNcshZ95Sa9pC28vtsI/djT5mUpTzKdGGldV8DxlSJB1EqjIXzQWU4MBpf/YBOjZrSbMRozxKWrJ9kyY6F+bmRe13uw8yROpUk6GR2qDaeaBqTtCmJ9SoVWEmGUCtGZqQDBkRuvgwQnSJUDzcVeM7IeEQDpjaSbo2QlJNGbUYar99jCFYPfZFigDq3tkQcM+iMSfdl3koPRyTM2fbZwh1bd+X2mOkaBxqzO/mIlFD59m5z8VioCJDI4jQmFDRRyWSjZ1bZzKX69dT6S9UIEKYlBoRujwwQnQJEYhRrRldbhG9KIQoV+4UC/dYLVEJU/tYTOkDlZQ7Ayka6x+hDVEPoNcw1UAyh5TeqWQWJ2lqpPK1O8icn0BNX+fKpgEZDHWoDYWeSw+Fdp6tJUNDtBslIlTpI6QVk6Y4M6c6AuscmGqT6VCEaCARwnU88tjba5pmuAA4MgNlwz4QPvTOxYnPdXFxSq67uGDgPIdE7QIpLfLipDmjQDZFNKUcpg43rH3n1RqsEQsu995w37RN/+99YQpBIkfIuX5zjr8HX5PS2nyl8nPQENWLQobw+5kqraq3myY9N2q/j9IY5PILobSHkKHkvgyapsmTISyIF9K4HEqGuN+0aRWE/qsGnYMngNpfiF0fWpVWyMjQ5YZpiC45RgVeUPpSTI6xE/YYjdG+TOcA6jVFGu3QFGQrh0NrinLIjZsa7RDAcNPHHDSayRqt0LHgsvgRDQ1LnksfAkO0RJo5tVbzzuWv0WCGJgw3j8uJR1Whn/Ghnrm00AbN+X2DtUpzmxyPxKjACQIJkiLVGRG63DBCZAAAwYwOoJ4YzR1IYcqw02N8i/ZhjjaUEOXu0QjMRX+PAUE2suUhP5ipwnJLqDUVm5MQDTWRq723FEBjbsf8i06I5lxCS8RJEyq9lO7VqQxA4rEvMuRREUZ8CBnSaoTk9g34lnwb2racVmKvZGifwRMmIEIURoQMAEaIDAQPP+XV/A/HQIzm2vmeY0HXYE4tUc09tXVjHIPWaK4pbCgZAqgjRBSHGo8A8xCji0yIzvvyqe13aVzsmwxVoJYMjfYTGkKEanCMhGhmq5Ckr40IGWaGESIDi6MlRnObA+1bGD12UlRqA8C8pEi72z0VNCZLUwWamIoQSRqloWGwfVljoNESajWDufDph8JFWTbneAcHJEMiCYoZ2N9zZmajtUFTzF8DzOzKZSr7el9HaezQ628jQoY9wQiRIQuRGAEcjhwdihQBzEOM5oo8N4fQIQq3RxqanYIKIVoCVBOFS0NAxpAhev8c/mIA40hRjgRpfWRy9R+SEA0x06w5O2aOMrV11Zqv0nwHIkNVREjKg8op+gfVEKEcxohfYw+I1USj3CNEbdD2x/4NlSQIwIiQIQ8jRAY1jk5rNCcx2meo7rk1Dlw7DkmKDrTg9hbVIT4VNcQvJ3hOrR3KlanFmPeK759SKyThENqiqXbdxwqgNWHVa+uiwTr8NQ5TzoVzkSFFSG1cTlWgBA41pp85MqnBWO3QFMR8AmSJUMxUzGPaIMNYGCEyVMOIEQwXBmrP/xiyUO2DGI0VnmlZc5GkIVG7hmiEAKZ5RxeBEPXun0grJGEfhGif/hg5YVUD7YGsWoG4ZOYltVFDWucykRPn54FjZSoSJGGfZGggpj4PyYiQ4dhghMgwGEdHjAD2H3gBoJ4c1WLKEM4A0wknU5IiTbm1GCqo1La/tr1DdtDPOyEqYY4DQafAvsMWj8EYbTSNVjgXsdfcq8TsZKhkFjdVIJAjJ0OYcExRhxEhw7HCCJFhNCYjRj7fGG3BPoSTqbRGNZhK6PaYmxR5DBV0p7JrrxVa5tIIcdAKkxoyVCqzBrnQ+1y+saHLx4b9noIQ4T7mzMYwhmht5kZNH2g10xxB0jz7eSdDU/kH5TBE7Co8wxTnFTVNk/WjomaFmmAUPVNErbbNiJBhzzBCZJgMKmIEUCZHkmlHDfZNjHJnxmBI58docN40RRRThXSekhTR97bv4BDngRSVCFEJY6P1laARwHP+YrVO6KW2TEX0tHWMgXQeVe6sqlK+Eo6RDNWEzB5DhmYgQscA/E6qw5IryZIRIcPcMEJkmBwPP+XVsvmFVmvE7WDWRmHaJyQhZUphC2C8MD5X5Kd9k6KqOhXO+znhdS4n4zn8iHLl1mAMIaJkQ7PpMQRaMpA72FSDGt8dgHoftBpIIdYxtIEdPEp+jZo6cxizCYTQE1XOCxmaIZLcucIMZnEARoQM08MIkWFWPPykV8U/SsSocwALvwgzTtglh2CKYzBnqSVH1PyIM1GZixQB1AtZQ8zH9kmKhkYy21c0vBpSVBN6e6iWj3vmMYSo99sE776WCGlBN3FqiZCEKQiS9plrNzCmMEuV5qiJ5t8sEdpmEII97PK1rZzWQiL5c52NNiURyj0/7QvFGUfqOjnkzhhKspk2yLB/GCEy7AUqYpQzlcv5HXH5AY6DEGEM0RzNhTlIUQ32QYqGRjTbdzhwAB0xyp3xMqeG75gIkdY8rhZD5oq5DmIeUs+Ucx03j+5500kUS3JC+qHn1LGYmgSNgdQWTKJq6jWzOMM5gBEiw16RECOAvOkGm0fp8O3vOzZSBMD7h0y1s1iDIaQI3zs2uMAUpEhTL7fIngcyBFDWFJX8iXA+6X1lzw0qfF/sPQciRHMSoZy/YA1qnn+kVkhylNf5ezBBFWbQ/nC4kGSopKGpgaTNGUuCMKSyaT3075y5rJnFGY4cRogMB4OoNcIYEpCBu+8YURJ49vFpjiFFU2DMexriQ1SqT1EmJ1SOnkbnCMU9VHDXmnhNrZkrYUoyVCPQT/0daPyoKrVCXPQvVVOESGDqQ0onRjUZOgbxJUcepsIQspPzmavxodPWxcG0QYZzBCNEhoNDRYwA9Fqj3H3HhrlMgGpwaFIEMOwdDdEODRHwe0Xy+WYjRQC6QAu5MmrDMmsw5tyhmnqm/EYOSYQ40D4YoBXax/kzcyP7DMdIhvYV7KCWCOU0NBhj+640NkwbZDiHMEJkOCoUyREnRBk5Go9DkaKhDucH1A6VMHhK1YZ15ivVlcNFQ9RqV7UmkkPPfpLak8McRCiUvcfNgCMiQhTc2TRjNUiSCV8PhyJDXLCBfaHmHCQu+FAJNX1XU49pgwznHEaIDEeJLDGq8f+Y+wyUuXAIcnRIUlSDoeG2B2iH1D4XBIOm1SmimmmI0VAfkBr/qrm1CzX9e8xkKIfMIajDxtf0Pic5bWnOHE/VVr7g6jaqccgQ19p3McV3pQk9nzOBo/2E2l462NXDiJDhGGGEyHD0UB/4SqHVHJ1ncnTZSNEUZw/R+jJlDtkFn9V0LqlowLjgtDu5+kYHzpiYGB2KaO4TyvDfgzQrQ8NOKzHYn+5QARMuCwnikDOpo1Bqf3KaQyNBhmOHESLDuYFIjACm0RrlyjkWaH1JaqGNIHVeSFGNZjCjHRqKUdNqrUajNCY0EQxz51+NwVTC3D76c6pDR8ee6aPAoEhsHGYgRWqU2jqbefAlJkE1GGACt70v1WoaETKcFxghMpxLVGmNDnWA5JyYQ2t0LDvpmr4f6sOSi1rYK2a8UDKr6VyvspkOLB0L7uBKLaZo61zjesghqCPP8xmkFSphn6RI28bJNd9GglTQkiDOlBON7Uc+87apW2YwzA4jRIZzD5YcaTVGRopSnAdSdE7IEIYRIwIaEhi3Z+qQwADzRJerIUQDzvBRj5mxwv6+CNFlIkNjosPtG6StNdofI0GGiwQjRIYLg4QY1QrU55kYAUxrSncsoYmnJEUVJpVzhBveqwldqJSJKCfmdX1icpFQQ0imJkSV2BsRApiODElR2WoOH51j3I09BFWLof24TyLEvZvQDAUJEmBEyHBRYITIcGHx8FNfI/94Ec3oAKaLTncspAhgGDEaEWHu6AiRxxQCeM27mvMgx0PiiAjR0ANVj5IMjcG+wmgD9ANLaAJQSL8PwSFIENsMYgInmL/RsPBGgAwXFUaIDJcCPXI0ldnVMWKo0MvhWEIW15CiCQIqbIuZ3mxukPCbw9xmdQB935+LsGSMIUUD+1x631WR2abWctQK9RKxGIN9kCEp3HgmhHSvjNzvJRwjCQKQ/dvwXOk6I0GGSwEjRIZLh0COxhwueR6IEcC0/iSHIEeaQ0O1JpA1kQhhHk0Rh4Nrj4a+o/O8dMxIiLhDTEdjDnMvKjhT4kDzTd0GjQ/ZnP5lE53FFDAmeMhYDCFBbOZYziOffuvYVhkM5wpGiAyXGg8/7W/LP2oXtfNCjjymCMagPCslWzc2xSBmGb3fJNSQ2spyVISICmhUmKuYXrEgPXha3ofGqHfvOVxCZiJEk5GfuUiIR05LcszQfmtDv8PSfRxZOxSGkiBurt3BSJDhMsMIkcGww2BydN4IEcYhI9VxbRnalzXRAwGmO5hV+n2gmdlkZnVTnWVUVcY5Wkr2oCGqxhzmaBcVOS1Mzbd3aFJTi9qw2OHH1ATOSJDB0Mc5luQMBoPBYDAYDAaDYRxMQ2QwMGC1RSoTqnO6x6CNTjckNDM9s2KMv4t0DgZ36GWtH9hQTVHNLvPAPqyepg+hIUrKOwfLysRaokk0Q4ZpwX1vl1ErRGBaIYOhDyNEBkMBPXJ0GYgRtTMv3jciRLN0RkzuQMvC2RhJW7K/H4AUUVT0XdV0fWhSBHDcxGgoIZqKDF1GIkRNAWkIbAA5JHYuXPY+yuHyTwWuXgbFAAlGggyGwTBCZDBUoIocnVdSJGEfjvdTRpEaEymw5myiuXacLxIxAjg+clRLiKYKpnCZiNCUUdyOAVO9u4p+KQZIyMBIkMGghxEig2EEEoJ0UUJ1a0GDIAw924Zzgpb+HpNXwkUnRsdCiEL5R7LkaPoF98XYYAoXhQjlzvS5aATIg9PelM43qugbGkjFTOEMhv3DCJHBMBFE7REnmGvO1ymB86fJ+evU5h8LzvxOeu6hebX3enAEbqpw3CVCVDLrwX9zkM5mCT9n3t2xkaJQz4GWnwnN5cItWkJ0jBHkNKZiI0HPZcLh5bnf8N9TYV/11LSFBXu2Gv8OjAQZDNPACJHBMAMSclTr8F9DjrS+NEMx9LyhMcj5Eu0Thb7tCTQaQqSF1m+Bmb73RoxyZ0fVYowPWg1qtUKV9x+96RznMzMR6PlZYw42puXU/E3bpK2Hu5f+XnNGWFV/lOZxsiYYCTIYpocRIoNhD3j4qa9JLyR24CNN7eYmRTWYkrjknmtuglRLhtIfC2WPEEKpEF1jTrdPUjnGnBJgHCEa+5yltp5HX6KJTdnGkJ0x6JmTHbAs7sywqvKyh0obATIY9g0jRAbDnpElRwCTBgM4OKh2DP9dCp3NadZy9dCycmVzeSrrHHRo61SCqYIYiVP7IbRtGNoQ77WY6rk0hIiOGXz7MZGiAeONjuspScjBMYdp8Jh2cNjN70aCDIb9wgiRwXBgqAkSd47GhOTomOzrKWrMZvb5HEaKBqJEOrTvaq7nKPmiZdpQPe7mCuOcgfSNDKvrgCaupVD9HDSbJ9zfU7Q1g0c+87Zp6jEYDINghMhgODJkCVLJH6niXB0OGsFIa78/Nebapc75H5RIWBb7NJ0DOF7zOQk5klEkEXtu/wgzOoAZSVGlT9Agk67a87/mIke12u+xPm5j220EyGA4VzBCZDAcOXoEiSLnj8RpkBSCxVQO0VPgQpjr9M4SGakl0kSjC38eIRmioILqsREigHmDLdQSosrxU/yG5jC1nZlQ9FDytawlQxmzSBZGgAyGcw0jRAbDOUMVQfIoEaWa8NIDwDkg12J0e+j9+5r6stGlZiBGNeG4AaYhFzkt5pDIbsdKiHKBIqYgRSPOsgEonGfjsY/IlKX3X+u3R/u9JhLn2AAf0ns1AmQwXCgYITIYzjkCQcqdqyOZ2SlN7PZtriZhsnZI5RTO+pm8Pg/pXCKK0rlFtWQolLun3XypHokQSe/hWLRcU5OigTiIBkiDkj+PhLkOsR5KhhTtNwJkMJxvGCEyGC4YHn7Kq+MfWnJU4Xt0ochRbRljzssZ2l7Noa0eQwjR1BoiDWidtUEWpvZTGVpGJSECGEeKin5sXJABdeEjzpEaA82xAqUDpvHfEiZ+NiNABsPFghEig+ESoBjJDqDarG4fvj1jTevUIYPHPoumnXP317Frh3J1ThF1LvccHOGRwrDXYqSWaHTwDoDxGhj6DHORoznOVBt72K4CRn4MhosPI0QGwyVF9XlICm3THCTpYGZG/E3lPKX2zkGMakJuexwq+pem7lqfIq5MjvDURknTYoCmqBpD+lkTaKBEjoZiHwdKz0CGjPwYDJcTRogMBgMACMEaaklS2xyNSd1QDCZKU7RvCOFi6t6bqRzAfggRgC7Qwr6EbIDRobjV0DzTFD43Q4mQpu5DRLFTPo8RIIPBAGCEyGAwZKA2tStoj6aOWJdFzt8AX6/0tdh7+G9KdJSka69kCKNG6J2DEE2JqTQP2n7WRF0bE2ktBy4Km6Q1OlbyQyEcrGvkx2AwSDBCZDAYqhBIUs4Paeaw3scULOCYzkk6GBniIDm/a9pwCEI0halcrtxcf0iYK9raFNhH5LoRY/WRT791woYYDIaLDiNEBoNhNB5+2t/uX9yDD9Ixa0OkZ/FtHkukaDl7C6KwLwzxI6rFmL6YKyLbsZKgIyZARn4MBsNYGCEyGAyzoUeUOBJQqU3iCMXkxEg6zHEGkyFKjKRDbMcebAsA54cMAcxDiI6FAHFR3A5JhMaE6x4Kzbsg7TLiYzAY5oIRIoPBsFeotEkAVWcjVYMTxsZE3NIKs4c6IBPgfJOhcP0ARHBfUde0kEKIl85mOuaxx7TtkT/6gZkaYzAYDH0YITIYDEeBwUQJYNoQy4c4fwVgfoH1mAmRts+HLFdjn3vMeBhKgoaO52MC1+9GfAwGw5HCCJHBYDhqjCJKYzGXnwjGIbRLx0aOpiZEh9IITT0GzwMJMuJjMBguAIwQGQyGcws1WZLACbBzHlapwdzapGMjQwCHI0RTvNd9+P5w75vTGo255q+PaJORHoPBcF5hhMhgMFxIVJEl5+qIlAZzlAlwvFHIxmAsIaoNmDE1LuI78SDEx0iPwWC4iDBCZDAYLi1Y0iSBkhuJ8HDXc9PsGNJ03gRxKVrfmCAKhyJD563vFbAobgaD4bLCCJHBYDAI6BGmmkM1p0ItYTpmQb2WkByrRghAJnVH3P9GeAwGg4GHESKDwWAYgYef+hr5R0+c5gqBrCFL3HlK9Pq+oCEnU2mF9uX3penf2usDYGTHYDAYhsMIkcFgMOwJWfIkYQx5GmqON0Y454gIdxBpck9hGaoNBLHPIBhjUOhnIzkGg8GwHxghMhgMhiPG3kkUwDzBIHJBJnLL0DEcqqpFhuAYuTEYDIbjhREig8FguMBQE6oaEoWJjbSE+Dy1S8wUYcE1/jyVPj9GaAwGg+HiwgiRwWAwGAwGg8FguLQ43nA4BoPBYDAYDAaDwTAzjBAZDAaDwWAwGAyGSwsjRAaDwWAwGAwGg+HSwgiRwWAwGAwGg8FguLQwQmQwGAwGg8FgMBguLYwQGQwGg8FgMBgMhksLI0QGg8FgMBgMBoPh0sIIkcFgMBgMBoPBYLi0MEJkMBgMBoPBYDAYLi2MEBkMBoPBYDAYDIZLCyNEBoPBYDAYDAaD4dLCCJHBYDAYDAaDwWC4tDBCZDAYDAaDwWAwGC4tjBAZDAaDwWAwGAyGSwsjRAaDwWAwGAwGg+HSwgiRwWAwGAwGg8FguLQwQmQwGAwGg8FgMBguLYwQGQwGg8FgMBgMhksLI0QGg8FgMBgMBoPh0sIIkcFgMBgMBoPBYLi0MEJkMBgMBoPBYDAYLi2MEBkMBoPBYDAYDIZLCyNEBoPBYDAYDAaD4dLCCJHBYDAYDAaDwWC4tDBCZDAYDAaDwWAwGC4tlodugMFwEXHv3j04Ozs7dDMMBoPBcMFw5coVuHbt2qGbYTBcKBghMhgmxr179+DB60+GM7h36KYYDAaD4YLh6U9/OnzkIx8xUmQwTAgjRAbDxDg7O4MzuAd/Dr4als1VaNpm+0PTovTu/7YJ6aZt0fU25vO/N+02P76/aUheQNdpXnq/3BbXNNGgFteV/X13fZdO8tJrLf4dlbNL4/Jdcj3mdeDTEJ4r/k7youshH67fX2/5+wOS+4U00xdJ/WxeJg3C76Qt4v3StUL9HuI1piyuL6Bx6rZAs32q8Gy9vI6vE18P9cdrTe5+cOgTiDU3wv3+elImur8h96PPBdrk/vh7i661u6fH5fi8LUkDALSQXmuZtC9L+t3Xub3WxbqA/t7BAt0T827LX4CDBt0f86JrOL3L6+tZNF0oc7Grz5cb6mLKWjRdaOMC5fOf8QJwuf4eF8ra3u/vi+Us0PMvUFv8ewllQexL//v2GsS+8m1pABa7NxKvNdCGazG9aPy1Fl3bpm/c7OBZf/p/wNnZmREig2FCGCEyGGbCEk5g2ZxAgwgJTm//j1JT0yBChH9v0e9FQtT07hMJUUN+H02ImkgCEsITicGkhAgLxjMTIv5+IR3ub1Aa3V8gJCUSMTshYn73oIQo1y+DCBGqa++ECKeZ+ykhovfE4RIF50GEiLlnKCFKCY+eEOHr2/8lQoRJQD0hallC5IS0nhAtQrsaaHcd6snIlhD5dINIikPXHCoLQlti/fFajhAtKgjRQkWIzO3bYJgL9nUZDAaDwWAwGAyGSwsjRAaDwWAwGAwGg+HSwgiRwWAwGAwGg8FguLQwQmQwGAwGg8FgMBguLYwQGQwGg8FgMBgMhksLI0QGg8FgMBgMBoPh0sIIkcFgMBgMBoPBYLi0MEJkMBgMBoPBYDAYLi2MEBkMBoPBYDAYDIZLCyNEBoPBYDAYDAaD4dLCCJHBYDAYDAaDwWC4tDBCZDAYDAaDwWAwGC4tlodugMFwUbGGFYBroXHN7gpO7/53TUg3rkXX25iv2/3eoN8b/H8b06H4hslL7ye/uyakXdMAOCD3l37fXQcA6CDN6x/ZX2vx76ic0JQmPJZLrse8vnpoAKClZZG8bLeje5huT9oF3P1CmvZFk17n8zJpEH4nbRHvl64V6vcQrzFlcX0BjVO3BZrtU4Vn6+V1fJ34eqg/Xmty94NDn0CsuRHu99eTMtH9DbkffS7gkvvj7w5dc7un9+V06J6WpAEAWkivtUw6zDzC7y3ga12sC+jvHSzQPTHvtvwFOGjQ/TEvuobTu7y+nkXThTIXu/p8uaEupqxF04U2LlA+/xkvAJfr73GhrO39/r5YzgI9/wK1xb+rUBbEvvS/b69B7CvflgZgsXsj8VoDbbgW04sm5ovXtuXduNmBwWCYHkaIDIaJ4ZyD+++/H37p1n/YSnibQ7fIYDAYDBcF999/PzjnyhkNBoMaRogMhonRNA3cunULPvaxj8ETn/jEQzfHYDAYDBcEN27cgM/7vM+DBmuuDQbDaBghMhhmwhOf+EQjRAaDwWAwGAxHDguqYDAYDAaDwWAwGC4tjBAZDAaDwWAwGAyGSwsjRAbDxLh69Sp8x3d8B1y9evXQTTEYDAbDBYKtLwbDPGichSoxGAwGg8FgMBgMlxSmITIYDAaDwWAwGAyXFkaIDAaDwWAwGAwGw6WFESKDwWAwGAwGg8FwaWGEyGAwGAwGg8FgMFxaGCEyGAwGg8FgMBgMlxZGiAyXEm9605ugaRr4+3//7wMAwGc+8xn45m/+ZviiL/oiuH79Ojz00EPwLd/yLfD4448n9/2n//Sf4Cu+4ivggQcegKc//enw+te/Htbrdfj9Ax/4ALzkJS+Bz/3cz4Vr167BF37hF8K3f/u3w2q1yrbn137t1+ClL30pPOlJT4InP/nJ8PKXvxx+67d+K8njnIM3v/nN8JznPAeuXr0Kz3zmM+Gf/tN/Ok2HGAwGg2EwPv7xj8PXf/3Xw1Of+lS4fv06PP/5z4f3vOc94fdPfvKT8A3f8A3wjGc8A+677z54+OGH4UMf+hBblnMOXvGKV0DTNPBv/+2/TX4rrUEYv/u7vwsPPPAAPOlJTyq2/1u+5VvgT//pPw1Xr16FP/Wn/pT2sQ2GCwMjRIZLh1/7tV+DH/iBH4A/8Sf+RLj2h3/4h/CHf/iH8OY3vxl+53d+B97xjnfAI488Aq961atCnt/6rd+Cr/7qr4aHH34Y3vve98JP/MRPwDvf+U74tm/7tpDn5OQE/ubf/Jvw7ne/Gz7wgQ/AW97yFvjBH/xB+I7v+A6xPbdu3YKHH34YHnroIfhv/+2/wS/90i/BAw88AC9/+csTIvW6170O3va2t8Gb3/xmeP/73w/vfOc74cu//Msn7h2DwWAw1OCzn/0svPCFL4STkxN417veBe973/vgn//zfw5PfvKTAWBLcL7ma74GPvzhD8PP/uzPwnvf+1541rOeBS972cvg9u3bvfLe8pa3QNM0veuaNchjtVrB3/gbfwNe9KIXqZ/jG7/xG+Frv/ZrK57cYLhAcAbDJcLNmzfds5/9bPcf/+N/dC9+8Yvd6173OjHvT/7kT7orV6641WrlnHPuDW94g/uyL/uyJM873/lOd+3aNXfjxg2xnG/91m91f+7P/Tnx91/7tV9zAOA++tGPhmv//b//dwcA7kMf+pBzzrn3ve99brlcuve///2axzQYDAbDnvD6178+O8d/4AMfcADgfud3fidc22w27mlPe5r7wR/8wSTve9/7XvfMZz7TfeITn3AA4H7mZ34m/FazBv3Df/gP3dd//de7H/qhH3IPPvig+lm+4zu+w/3JP/kn1fkNhosC0xAZLhVe+9rXwitf+Up42cteVsz7+OOPwxOf+ERYLpcAAHB6egrXrl1L8ly/fh3u3bsHv/7rv86W8bu/+7vwyCOPwItf/GKxni/6oi+Cpz71qfD2t78dzs7O4O7du/D2t78dvviLvxg+//M/HwAAfu7nfg6+8Au/EP7dv/t38AVf8AXw+Z//+fDqV78aPvOZzyif3GAwGAxz4J3vfCd82Zd9Gfy1v/bX4HM+53PgS7/0S+EHf/AHw++np6cAAMn60bYtXL16FX7pl34pXLtz5w583dd9HXzf930fPP3pT+/Vo12DfuEXfgF+6qd+Cr7v+75vsmc0GC46jBAZLg1+/Md/HH7jN34D/tk/+2fFvJ/61KfgO7/zO+E1r3lNuPbyl78cfvmXfxl+7Md+DDabDXz84x+Hf/JP/gkAAHziE59I7v+Kr/gKuHbtGjz72c+GF73oRSEfhwceeAD+83/+z/AjP/IjcP36dbj//vvhkUcegXe9612BjH34wx+G3//934ef+qmfgh/+4R+Gd7zjHfDrv/7r8Ff/6l8d0hUGg8FgmAgf/vCH4V/+y38Jz372s+Hnf/7n4e/+3b8L3/It3wL/6l/9KwAAeO5znwsPPfQQvOENb4DPfvazcHZ2Bt/1Xd8Ff/AHf5CsHd/6rd8KX/EVXwF/+S//ZbYezRr06U9/Gr7hG74B3vGOd8ATn/jEmZ/cYLg4MEJkuBT42Mc+Bq973evgR3/0R3s7bBQ3btyAV77ylfAlX/Il8I//8T8O17/qq74Kvvu7vxv+zt/5O3D16lV4znOeA1/91V8NANvdPoyf+ImfgN/4jd+Af/Nv/g38+3//7+HNb36zWN/du3fhVa96FbzwhS+E//pf/yv8l//yX+B5z3sevPKVr4S7d+8CAEDXdXB6ego//MM/DC960YvgL/yFvwBvf/vb4Rd/8RfhAx/4wMBeMRgMBsNYdF0HL3jBC+CNb3wjfOmXfim85jWvgW/6pm+C7//+7weArW/pT//0T8MHP/hBeMpTngL33Xcf/OIv/iK84hWvCGvHO9/5TviFX/gFeMtb3iLWo1mDvumbvgm+7uu+Dv78n//z8z60wXDRcGibPYNhH/iZn/kZBwBusViEfwDgmqZxi8XCrddr55xzN27ccH/2z/5Z99KXvtTdvXuXLavrOvfxj3/c3blzx73vfe9zAOB+9Vd/Vaz7X//rf+2uX78e6qB429ve5j7ncz7HbTabcO309NTdd9997sd+7Mecc879o3/0j9xyuUzuu3PnjgMA9+53v7uqLwwGg8EwHR566CH3qle9Krn2L/7Fv3DPeMYzenkfe+wx9+ijjzrnnPvyL/9y9/f+3t9zzjn3ute9LqxHeI1q29a9+MUvTsrIrUEPPvhgUkbbtmHte/vb3158FvMhMlxWLA/IxQyGveGlL30p/PZv/3Zy7W/9rb8Fz33uc+H1r389LBYLuHHjBrz85S+Hq1evwjvf+U5Rk9Q0DTzjGc8AAIAf+7Efg8/7vM+DF7zgBWLdXdfBarWCrutgsVj0fr9z5w60bZtEFfJ/d10HAAAvfOELYb1ew+/93u/BH//jfxwAAD74wQ8CAMCznvWsip4wGAwGw5R44Qtf2NPUf/CDH2Tn5gcffBAAAD70oQ/Be97zHvjO7/xOAAD4tm/7Nnj1q1+d5H3+858P3/M93wN/6S/9peR6bg36lV/5FdhsNiHvz/7sz8J3fdd3wS//8i/DM5/5zJFPajBcXBghMlwKPPDAA/C85z0vufaEJzwBnvrUp8Lznvc8uHHjBnzVV30V3LlzB37kR34Ebty4ATdu3AAAgKc97WmByHz3d383PPzww9C2Lfz0T/80vOlNb4Kf/MmfDL//6I/+KJycnMDzn/98uHr1KrznPe+BN7zhDfC1X/u1cHJyAgAAP/MzPwNveMMb4P3vfz8AAHzlV34l/IN/8A/gta99LXzzN38zdF0Hb3rTm2C5XMJLXvISAAB42cteBi94wQvgG7/xG+Etb3kLdF0Hr33ta+Erv/Ir4TnPec5e+tBgMBgMfXjfnze+8Y3w1//6X4df/dVfhbe+9a3w1re+NeT5qZ/6KXja054GDz30EPz2b/82vO51r4Ov+Zqvga/6qq8CAICnP/3pbCCFhx56CL7gC74g/F1ag774i784uf8973kPtG2brH90DQLYBgC6desW/M//+T/h7t278Ju/+ZsAAPAlX/IlcOXKlfGdZDAcOw6tojIYDgUcdvsXf/EXHQCw/z7ykY+Ee17ykpe4Bx980F27ds39mT/zZ9x/+A//ISnzx3/8x90LXvACd//997snPOEJ7ku+5EvcG9/4xsT87od+6Icc/fTe/e53uxe+8IXuwQcfdE9+8pPdX/yLf9H9yq/8SpLn4x//uPsrf+WvuPvvv9997ud+rvuGb/gG9+lPf3raTjEYDAZDNX7u537OPe95z3NXr151z33uc91b3/rW5Pfv/d7vdX/sj/0xd3Jy4h566CH37d/+7e709DRbJpCw286V1yAKLuw2twa9+MUvLq5/BsNFRuOcc4cgYgaDwWAwGAwGg8FwaFiUOYPBYDAYDAaDwXBpYYTIYDAYDAaDwWAwXFoYITIYDAaDwWAwGAyXFkaIDAaDwWAwGAwGw6WFESKDwWAwGAwGg8FwaWGEyGAwGAwGg8FgMFxaGCEyGAwGg8FgMBgMlxZGiAwGg8FgMBgMBsOlhREig8FgMBgMBoPBcGlhhMhgMBgMBoPBYDBcWhghMhgMBoPBYDAYDJcW/3+hPIRJx3rgkQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sky = cro.Sky.gsm(beam.frequencies, lmax=beam.lmax)\n", "hp.mollview(sky.hp_map(nside)[0], title=f\"Sky at {freq[0]:.0f} MHz\")" @@ -73,10 +104,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "9a5e0c5e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(sky.frequencies, np.real(sky[:, 0, 0]), label=\"Sky monopole spectrum\")\n", @@ -89,26 +131,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "10ca4c8e", - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [], "source": [ "# let's do a full sidereal day on the moon\n", "loc = (20., -10.)\n", "t_start = Time(\"2022-06-02 15:43:43\")\n", "t_end = t_start + cro.constants.sidereal_day_moon * seconds\n", - "sim = cro.Simulator(beam, sky, loc, t_start, world=\"moon\", t_end=t_end, N_times=300, lmax=lmax)" + "times = cro.simulatorbase.time_array(t_start=t_start, t_end=t_end, N_times=300)\n", + "sim = cro.Simulator(beam, sky, lmax=lmax, world=\"moon\", location=loc, times=times)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "a077a8e9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# the simulator view of the beam and sky after moving to MCMF coordinates\n", "hp.mollview(sim.beam.hp_map(nside)[0], title=f\"Beam at {freq[0]:.0f} MHz\")\n", @@ -125,12 +187,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "394a8fe8", - "metadata": { - "scrolled": false - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# dpss mode\n", "sim.run(dpss=True, nterms=40)\n", @@ -139,10 +210,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "9e0b5493", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sim.run(dpss=False)\n", "sim.plot(power=2.5)" @@ -150,10 +232,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "79fb8cac", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(sim.frequencies, sim.waterfall[::10].T, ls=\"--\")\n", @@ -166,12 +259,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "65f0df23", - "metadata": { - "scrolled": false - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQcAAAHqCAYAAAC5qPh5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADjW0lEQVR4nOzdd3hc1Zk/8O+drt57dzc2uFBNKIbQDKGnkixsIIVNYVk2m8S7CYEkhGQ3bLKbkLZJ8C8kBEhCC92EgOlgsLAx7pYtq3eNZqTp9/fHzLmSrOIZaW6d7+d58uwijzTHxzpz733Pe95XkmVZBhEREREREREREWUcm94DICIiIiIiIiIiIn0wOEhERERERERERJShGBwkIiIiIiIiIiLKUAwOEhERERERERERZSgGB4mIiIiIiIiIiDIUg4NEREREREREREQZisFBIiIiIiIiIiKiDMXgIBERERERERERUYZicJCIiIiIiIiIiChDMThIRERERERERESUoRgczAB33HEHJEnCypUrp/3zV199FWeccQays7NRWVmJm266CT6fL+mf/5vf/AbLly+Hx+PB4sWL8ZOf/CSp79u0aRMkSYIkSXj55Zen/Lksy6irq4MkSfjQhz406c8kScKXvvSlWX/u1q1bk/47EJnVCy+8oKyjo//3+uuvT3k91zuRub3zzju47LLLUFxcjOzsbKxcuRL/+7//O+V1XOtE5vWP//iPM17bJUlCe3v7pNdzvROZ1759+/Dxj38ctbW1yM7OxrJly/Dtb38bo6OjU17LtU5qcug9AFJXW1sbvve97yEnJ2faP29ubsYHP/hBLF++HP/93/+NtrY2/PCHP8S+ffvw1FNPHfPn//KXv8SNN96Iq6++Grfccgteeukl3HTTTRgdHcXXvva1pMbo8Xhw33334Ywzzpj09RdffBFtbW1wu91J/RyiTHbTTTfh5JNPnvS1RYsWTfpvrncic3v22Wdx6aWXYs2aNfjmN7+J3NxcHDhwAG1tbZNex7VOZG6f//zncd555036mizLuPHGG9HY2Iiamhrl61zvROZ15MgRnHLKKSgoKMCXvvQlFBcX47XXXsO3vvUtvP3223j00UeV13Ktk+pksrSPfexj8rnnniufffbZ8ooVK6b8+YYNG+Sqqip5eHhY+dr//d//yQDkZ555ZtafPTo6KpeUlMiXXHLJpK9/8pOflHNycuSBgYFZv/+ee+6RAchXXXWVXFpaKofD4Ul//tnPflY+8cQT5YaGhinvAUD+4he/OOvPfeutt2Z9fyIr+Pvf/y4DkP/0pz8d87Vc70TmNTw8LFdUVMhXXnmlHI1GZ30t1zqR9bz00ksyAPmOO+6Y9HWudyLzuuOOO2QA8nvvvTfp69dee60MYNIa5FontfFYsYVt2bIFf/7zn/HjH/942j/3er3YvHkzPvWpTyE/P1/5+rXXXovc3Fw8+OCDs/78v//97+jv78cXvvCFSV//4he/CL/fjyeeeCKpcX7iE59Af38/Nm/erHwtFArhz3/+M6655pqkfsZsZjt22djYOO+fT2QUIyMjiEQi0/4Z1zvXO5nbfffdh+7ubtxxxx2w2Wzw+/2IxWJTXse1zrVO1nTfffdBkqRJ64frneudzM3r9QIAKioqJn29qqoKNpsNLpdLeR3XeuO8fz7NjsFBi4pGo/jyl7+Mz3zmMzj++OOnfc2OHTsQiURw0kknTfq6y+XC6tWrsW3btlnfQ/z50d9/4oknwmazHfP7hcbGRqxbtw5//OMfla899dRTGB4exsc//vEZvy8QCKCvr2/K/46uu7B8+XLce++9k/73k5/8BE6nE+Xl5UmNkcjoPv3pTyM/Px8ejwfnnHPOlNodXO9c72Ruzz33HPLz89He3o6lS5ciNzcX+fn5+Kd/+icEAgHldVzrXOtkPeFwGA8++CBOP/30SQ/IXO9c72Ru69evBwDccMMNaG5uxpEjR/DAAw/g5z//OW666SalNBjXOte6Flhz0KJ+8Ytf4PDhw3juuedmfE1nZyeA+M7E0aqqqvDSSy/N+h6dnZ2w2+1TFqrL5UJJSQk6OjqSHu8111yDjRs3YmxsDFlZWfjDH/6As88+G9XV1TN+z29+8xv85je/OebPrqiowKc+9Snlv2VZxmWXXQa3241NmzYlPUYiI3K5XLj66qtx8cUXo7S0FO+//z5++MMf4swzz8Srr76KNWvWAOB653ons9u3bx8ikQguv/xy3HDDDbjzzjvxwgsv4Cc/+QmGhoaUG3Wuda51sp5nnnkG/f39+OQnPznp61zvXO9kbhdddBG+853v4Hvf+x4ee+wx5ev/8R//ge9+97vKf3Otc61rgcFBC+rv78ett96Kb37zmygrK5vxdWNjYwAwbeFQj8ej/Pls3y9Snefy/RN99KMfxc0334zHH38cF110ER5//PFpuy9OdPnll0/b+ejZZ5/Ff/3Xf834fd/5znfw+OOP489//jOOO+64pMdIZESnn346Tj/9dOW/L7vsMnz4wx/GCSecgI0bN+Lpp58GwPXO9U5m5/P5MDo6ihtvvFFZL1dddRVCoRB++ctf4tvf/jYWL17Mtc61ThZ03333wel04qMf/eikr3O9c72T+TU2NuKss87C1VdfjZKSEjzxxBP43ve+h8rKSmV9cK1zrWvBVMHBLVu24L/+67/w9ttvo7OzEw8//DCuuOKKlH7GM888g29961vYuXMnPB4PzjrrLNx1112WOsP+jW98A8XFxfjyl7886+uysrIAAMFgcMqfBQIB5c9n+/5QKDTtnyXz/ROVlZXhvPPOw3333YfR0VFEo1F8+MMfnvV7amtrp3RyAzCla+NETz/9NG6//XZs3LgRV199ddLjIzKTRYsW4fLLL8dDDz2EaDQKu93O9c71TiYn1tgnPvGJSV+/5ppr8Mtf/hKvvfYaFi9ezLXOtU4W4/P58Oijj+LCCy9ESUnJpD/jeud6J3O7//778bnPfQ579+5FbW0tgPjGXywWw9e+9jV84hOfQElJCdc617omTFVz0O/3Y9WqVbj77rvn9P0tLS24/PLLce6556K5uRnPPPMM+vr6cNVVV6V5pPrZt28ffvWrX+Gmm25CR0cHDh06hEOHDiEQCCAcDuPQoUMYGBgAMJ6WLNKUJ+rs7Jw1NVh8fzQaRU9Pz6Svh0Ih9Pf3H/P7j3bNNdfgqaeewi9+8Qts2LABhYWFKX3/sbS0tOCTn/wkzj///Elp2kRWVFdXh1AoBL/fD4DrncjsxBo7umi5OCI0ODgIgGudyGoeeeQRjI6OTjlSDHC9E5ndz372M6xZs0YJDAqXXXYZRkdHlVqAXOukBVMFBzds2IDvfve7uPLKK6f982AwiK985SuoqalBTk4OTj31VLzwwgvKn7/99tuIRqP47ne/i4ULF2Lt2rX4yle+gubmZoTDYY3+Fupqb29HLBbDTTfdhKamJuV/b7zxBvbu3YumpiZ8+9vfBgCsXLkSDodjSuOCUCiE5uZmrF69etb3En9+9Pdv3boVsVjsmN9/tCuvvBI2mw2vv/56WrodTTQ2NoarrroKhYWF+OMf/wibzVS/+kQpO3jwIDweD3JzcwFwvROZ3Yknngggfp2fSNQJEmVEuNaJrOUPf/gDcnNzcdlll035M653InPr7u5GNBqd8nURm4hEIgC41kkblprpL33pS3jttddw//33Y/v27fjIRz6Ciy66CPv27QMw3o3nnnvuQTQaxfDwMO69916cd955cDqdOo8+PVauXImHH354yv9WrFiB+vp6PPzww7jhhhsAAAUFBTjvvPPw+9//HiMjI8rPuPfee+Hz+fCRj3xE+dro6Ch2796Nvr4+5WvnnnsuiouL8fOf/3zSGH7+858jOzsbl1xySUpjz83Nxc9//nPcdtttuPTSS+fy15/RjTfeiL179+Lhhx9GUVFRWn82kZ56e3unfO3dd9/FY489hgsuuEC5oHK9E5mbqDV2dEHvX//613A4HErHQ651Iuvo7e3Fc889hyuvvBLZ2dlT/pzrncjclixZgm3btmHv3r2Tvi6CYieccAIArnXShqlqDs6mtbUV99xzD1pbW5W02K985St4+umncc899+B73/sempqa8Oyzz+KjH/0oPv/5zyMajWLdunV48skndR59+pSWlk5bh/HHP/4xAEz5szvuuAOnn346zj77bHzuc59DW1sb7rrrLlxwwQW46KKLlNe9+eabOOecc/Ctb30Lt912G4B47YLvfOc7+OIXv4iPfOQjuPDCC/HSSy/h97//Pe644w4UFxenPP7rrrsu5e85lieeeAK/+93vcPXVV2P79u3Yvn278me5ubkp160kMpKPfexjyMrKwumnn47y8nK8//77+NWvfoXs7Gx8//vfn/RarneudzKvNWvW4Prrr8dvf/tbRCIRnH322XjhhRfwpz/9CRs3bpx0JIhrnWudrOGBBx5AJBKZ9kixwPXO9U7m9W//9m946qmncOaZZ+JLX/oSSkpK8Pjjj+Opp57CZz7zGV7budY1ZZng4I4dOxCNRrFkyZJJXw8Gg0rx3q6uLnz2s5/Fddddh0984hMYGRnBrbfeig9/+MPYvHkzJEnSY+i6Wrt2LZ577jl87Wtfw7/8y78gLy8PN9xwA+68886kvv8LX/gCnE4n7rrrLjz22GOoq6vDj370I/zzP/+zyiNPnsis+stf/oK//OUvk/6soaGBHzJkaldccQX+8Ic/4L//+7/h9XpRVlaGq666Ct/61rewaNGiSa/leud6J3P7xS9+gfr6etxzzz14+OGH0dDQgB/96Ee4+eabJ72Oa51rnazhD3/4A8rLy6ct5C9wvXO9k3mdddZZePXVV3HbbbfhZz/7Gfr7+9HU1IQ77rgDX/3qVye9lmuda11tkizLst6DmAtJkiZ1K37ggQfwyU9+Ejt37oTdbp/02tzcXFRWVuKb3/wmnn76abz11lvKn7W1taGurg6vvfYaTjvtNC3/CkRERERERERERLqyTObgmjVrlA48Z5555rSvGR0dnVLQUgQSY7GY6mMkIiIiIiIiIiIyElM1JPH5fGhubkZzczOAeIvr5uZmtLa2YsmSJfjkJz+Ja6+9Fg899BBaWlrw5ptv4s4778QTTzwBALjkkkvw1ltv4dvf/jb27duHd955B5/+9KfR0NCANWvW6Pg3IyIiIiIiIiIi0p6pjhW/8MILOOecc6Z8/brrrsOmTZsQDofx3e9+F7/73e/Q3t6O0tJSnHbaabj99ttx/PHHAwDuv/9+/Od//if27t2L7OxsrFu3Dj/4wQ+wbNkyrf86REREREREREREujJVcJCIiIiIiIiIiIjSx1THiomIiIiIiIiIiCh9GBwkIiIiIiIiIiLKUKboVhyLxdDR0YG8vDxIkqT3cIgykizLGBkZQXV19ZSu3+nCtU6kPy3WOsD1TmQEXO9EmYP38kSZYa5r3RTBwY6ODtTV1ek9DCICcOTIEdTW1qrys7nWiYxDzbUOcL0TGQnXO1Hm4L08UWZIda2bIjiYl5cHIP6Xy8/Pn/F14XAYzz77LC644AI4nU6thmdonJOpOCeTJTsfXq8XdXV1ynpUQ7JrHeC/49E4H1NxTqZKZk60WOsAr+3zwTmZinMymZGu7QDX+3xwTibjfExlpPXOe/m543xMxTmZSs17eVMEB0VKcn5+/jFvKLKzs5Gfn89fngTOyVSck8lSnQ81jwgku9YB/jsejfMxFedkqlTmRO3jQLy2zx3nZCrOyWRGurZP/Plc76njnEzG+ZjKSOud9/Jzx/mYinMylZr38mxIQkRERERERERElKEYHCQiIiIiIiIiIspQDA4SERERERERERFlKAYHiYiIiIiIiIiIMhSDg0RERERERERERBmKwUEiIiIiIiIiIqIMxeAgERERERERERFRhmJwkIiIiIiIiIiIKEMxOEhERERERERERJShGBwkIiIiIiIiIiLKUAwOEhERERERERERZSgGB4mIiIiIiIiIiDIUg4NEREREREREREQZisFBIiIiIiIiIiKiDMXgIBERERERERERUYZy6D0AIiLSjyzL2N/jw/udXnjHwijJdeOkxiKU53n0HhoRERERERFpgMFBIqIMFIvJ+Ov2Dvz8hQPY3TUy6c8kCThrcRk2XrwMyyrzdRohERERERERaSHlY8VbtmzBpZdeiurqakiShEceeWTW17/wwguQJGnK/7q6uuY6ZiIimof2oTF87Fev4Z/vb8burhG47Dac3FiEC46rwIrqfMgy8OLeXlz8Py/hNy+3QJZlvYdMREREREREKkk5c9Dv92PVqlW4/vrrcdVVVyX9fXv27EF+/ngGSnl5eapvTURE87T10AA+87utGBoNI8dlxxfOWYRPndaAgiyn8prD/X7c+eRuPL2zC995/H30eAPYePFyHUdNREREREREakk5OLhhwwZs2LAh5TcqLy9HYWFhyt9HRETp8fK+Pnzmd28hEI7hhNoC/PQTa1Ffkj3ldQ0lOfj5p9bi1y+14I4nd+GXWw6iIt+D689o0mHUREREREREpCbNuhWvXr0aVVVVOP/88/HKK69o9bZERATgvfZhfP7erQiEY1i/tAwPfG7dtIFBQZIkfPasBfj6hmUAgO888T7ebBnQarhERERERESkEdUbklRVVeEXv/gFTjrpJASDQfz617/G+vXr8cYbb2Dt2rXTfk8wGEQwGFT+2+v1AgDC4TDC4fCM7yX+bLbXZBrOyVSck8mSnQ815muua33iePjvGDfbfPT7Q7hh01vwh6JYt6AYd398FRxSDOFw7Jg/9/p1ddjdMYxH3u3ELQ82469fXIdctzl6WfF3ZKpk5kSt+eK1PX04J1NxTibT89oOcL2nE+dkMs7HVLyXtwbOx1Sck6nUvJeX5HlUmpckCQ8//DCuuOKKlL7v7LPPRn19Pe69995p//y2227D7bffPuXr9913H7KzZ850ISL1jI6O4pprrsHw8PCk+qHzwbWuPlkG/m+PDTsHbajIkvEvK6PISjG2F4gAP9hux0BQwlmVMVzddOygIpmXGmsd4HonMiKud6LMwXt5osww17WuS3Dw3/7t3/Dyyy/jtddem/bPp9uBqKurQ19f36x/uXA4jM2bN+P888+H0+mc8XWZhHMyFedksmTnw+v1orS0NK03FHNd66mMO1PMNB/3vt6Kbz+xGy6HDX/5/KlYVpk3p5//6oF+XLfpbdhtEh77wmlYUjG3n6Ml/o5MlcycqLHWAV7b04lzMhXnZDI9r+0A13s6cU4m43xMxXt5a+B8TMU5mUrNe3ldzoY1Nzejqqpqxj93u91wu91Tvu50OpP6pUj2dZmEczIV52SyY82HGnM137We6mszwcT5ONTnx/ef2QsA2LhhGY6vK57zzz17WSUuWlGJp3d24c6n9+H3nzk1LePVAn9HppptTtSaK17b049zMhXnZDI9ru0A17saOCeTcT6m4r28NXA+puKcTKXGvXzKwUGfz4f9+/cr/93S0oLm5mYUFxejvr4eGzduRHt7O373u98BAH784x+jqakJK1asQCAQwK9//Ws8//zzePbZZ+c0YCIiOjZZlvGtx3YiFInhjEWl+MfTG+f9M//jkuX42+5uvLy/D68f7MdpC0rmP1AiIiIiIiLSVcrBwa1bt+Kcc85R/vuWW24BAFx33XXYtGkTOjs70draqvx5KBTCv/7rv6K9vR3Z2dk44YQT8Nxzz036GURElF7P7OzCi3t74bLb8J0rVkKSpHn/zLribHzs5Dr8/vVW/Pi5vbj/c+vSMFIi0oI/GMETOzrx/K4eHOr3Q5Ik1BZl4bzl5fjQCdXIMUmjISIiIiJKv5TvBNevX4/ZyhRu2rRp0n9/9atfxVe/+tWUB0ZERHMzFori2399HwDw+bMXoKk0J20/+wvrF+GBt47g9YMDeO1AP9YtZPYgkZFFYzL+8MZh/GjzXgyOTu5et6vTi83vd+OuZ/fiPy5ZjstX1+g0SiIiIiLSE7eJiYgs5t7XD6FjOICawix8Yf2itP7s6sIsJXvwf/62F+sWMnuQyKi6vQHcfH8zXjvYDwBoKMnG1WtrcXxtAWyShO1HhvDg20dwZGAM/3x/M95rH8bXNyyH3Tb/TGMiIiIiMg8GB4mILMQfjOAXLx4EANx83mJkuexpf48vrF+E+9+MZw++1z6MlTUFaX8PIpqf/T0+XPubN9AxHEC2y46NG5bhE6fUw2G3Ka85e0kZPnf2Avz0+f34yfP78X8vtSAclfGtS49LSykCIiIiIjIH27FfQkREZnHv660Y8IfQWJKNK9eoc0SwujALl5wQ7zj/21daVHkPIpq7g70+fOyXr6FjOIAFZTl4/Mtn4B/WNU4KDApuhx3/esFS3PWRVQCATa8ewj2vHNJ4xERERESkJwYHiYgsIhABfp14qP/n8xZPGwhIl09/oAkA8Pi7negdCar2PkSUmj5fENfd8yb6/SGsqM7Hnz6/DgvKco/5fVefWIt/v3gZAODOp3ZhZ8ew2kMlIiIiIoNgcJCIyCJe75UwPBbBgtIcXLZK3cYCq+sKsaa+EKFoDH9447Cq70VEyYnFZPzLA804MjCGhpJs/L/rT0FJrjvp7//smQtwwXEVCEfjPycYiao4WiIiIiIyCgYHiYgsIBaT8VJX/CP9+jOaNGkoILIHf/96K0KRmOrvR0Sz+/XLB/HSvj54nDb8+tqTUJpCYBAAJEnCnVcdj9JcF/Z2+/Dblw+pM1AiIiIiMhQGB4mILGDL/j70BSTkeRyq1Ro82oaVlSjLc6PPF8Tzu3s0eU8imt6OtmH859N7AADfunQFFlfkzennlOS68fUNywEAP3l+H7q9gbSNkYi0J8uy3kMgIiITYHCQphWLyTjU58frB/uxo20Y3kBY7yER0Szufb0VAPCRtTXIcWvTiN5pt+GqtfFA5INbj2jynkQ0VSQaw9cf2o5ITMaGlZX4+Ml18/p5V62pwdr6QoyGovjxc3vTNEoi0oIsy/j7nh588b53sO7Ov2HBvz+JVbc/i0/9+g3c/yYz/YmIaHraPEGSafSMBPCrFw/isXc70DOhyYDDJmHdwhL80/qFOH1hqY4jJKKjtfT5sWVfPyTI+OSp8wsKpOqjJ9Xhly8exAt7etA1HEBlgUfT9yci4PevH8bODi/yPQ5854qVkKT5lRWw2ST8+8XL8eFfvIY/bW3DF9YvQl1xdppGS0Rq2dE2jFsfew/bWocmfX14LIyX9/fh5f19+MWLB/CfH16FU5qK9RkkEREZEjMHCUB8l/GeV1pw9n++gF+/3IKekSDcDhuaSnNQludGJCbjpX19uOb/3sA/378NYyEWKScyCpG1t7xQRr3GD/ALy3JxcmMRYjLwl3faNH1vIgJ6vAHc9Ww8u++rFy1Luc7gTE5qLMaZi0sRicn46fP70/IziUgdsizjV1sO4MqfvYJtrUPIdtnxj6c34oHPnYbXNp6LJ286E19LfD4c6h/FJ3/9OjP+iYhoEmYOEgLhKP75/m14Zmc3gHgX0i+dswhnLSmDyxGPH7f0+bHplRb8/o1WPNrcgYO9ftx7wykozHbpOXSijBeNyXj4nXYAwKnl+tQV+uhJdXjr0CAe3HoEX1i/cN5ZS0SUvB8+uwcjwQhW1RbgE6fUp/Vn33zeEry0rw9/fqcNXzxnEepLmD1IZDSRaAzffHQn/vhmvLzIhpWVuP2yFSjPH8/kryrIwnHV+fiHdQ342l+244ntnfjqn7cjy2nHpauq9Ro6EREZCDMHM5wvGMG1v3kTz+zshsthw+2XrcDDXzgd5x1XoQQGAaCpNAe3X74S933mVBTnuLCjfRif/d1WBMLMICTS0yv7+9DlDaAgy4GVRfoEBy85oQo5LjsO94/indZBXcZAlIkO9fvxl8TmwK2Xrkh7l/ITG4pw1pIyRGMyfv7igbT+bCKaP1mWsfGhHfjjm62QJOD2y1bgZ59cOykwOFGu24GffmINrl3XAAD41wffxTZet4mICAwOZrRQJIZ/+v3bePPQAPI8Dvz+hlNx3emNs2b9nLqgBPd99lTkeRx469Ag/v3hHRqOmIiOJo7yXnpCFRw6faJnuxy4YEUlAOCx5g59BkGUgX7y/EFEYzLOWVqGExuKVHmPL65fCAB46J02DPpDqrwHEc3NjzbvxZ/eboPdJuHua9Ye8z4eACRJwrcuXYELV1QgFI3h5gea4Q9GNBoxEREZFYODGeybj7yHl/b1Idtlx+9vODXpwsTLKvPxy384ETYJeOiddjza3K7ySIloOt5AGM/s7AIAXLla32NBlyXe/4kdnYhE2QmRSG1do8Bfd3QCAG45f6lq73NKUzFWVOcjGInhvsSxRSLS34t7e/G/iXqg37tyJS4+virp77XbJPznh1ehusCDw/2j+N6Tu9QaJhERmQSDgxnqwbeO4IGtR2CTgJ99ci1W1RWm9P2nLyzFl85dDAD4xiPvoXdCZ2Mi0saT2zsRCMewuDwXx9fk6zqWMxaVojjHhT5fCK8e6Nd1LESZ4Nl2G2QZuHBFBY6vLVDtfSRJwg1nNAEAfvfaIYQZ/CfSXc9IAP/6YDMA4Np1DfjYyanXGy3IcuKHH10FALjvzVbsaBtO5xCJSCOyLGNv9wgee7cDD751BC/s6WE2MM0Jg4MZqKXPj1sfew8AcMv5S7B+afmcfs5N5y7Cypp8jAQiuJM7jkSaE0eKrz6xVvcmIE67DRcfHz9a/CiPFhOpqmckiOb++Jr/0jmLVX+/S06oQlmeG93eIJ5MZCsSkT5kWcZX/rQdfb4QllXm4d8vXj7nn3X6wlJcsboasgzc+th7kGV9ahcTUeqiMRkPvNWKC3+8BRf8aAtu+uM2fPUv2/GP97yFtd/ZjK/++V10DQf0HiaZCIODGSYWk/G1P29HIBzDBxaV4AvrF835ZznsNnz3iuMhScBD29qx9dBAGkdKRLM5MjCKtw4NwiYBV66p0Xs4AIDLV8fH8czOLjYrIlLR/W8dQVSWcGJ9oapZg4LbYcenTo03MPj964dVfz8imtlj73Zgy95euB02/PSaNfA47fP6eRsvXo5slx3bWofwzM7uNI2SiNS0u8uLD/3kZXztLzuwt9sHt8OGkxqKsH5pGeqKsxCMxPDg1jZ88K4X8PR7XXoPl0yCwcEMc+/rh/HmoQFku+z4/lUnwDbPzoar6wrxsZPqAAD/+cwe7jgSaeSJRPbOaQtKUDFDV0KtnVhfhOoCD3zBCF7a16f3cIgsKRiJ4o9vxbOGrz0t9aOEc/XxU+pgk4C3Dg1if49Ps/clonHDY2F85/H4aZ0vnbMIi8rz5v0zK/I9uP4D8dIBP35uL2Ix3ssTGdlD77Thsp++gl2dXhRkOfEfFy/HW984D3/+p9Ox6dOnYMu/nYO//NM6rKkvhD8UxY2/fxv3vnZI72GTCTA4mEG6hgP4wdO7AQBf37AMdcXZafm5N31wMVx2G95sGWBAgEgjT2yPBwcvOSH5AuRqs9kkXLgyfrSYu5RE6nhyRyf6fCEUuGScf9zcyoLMRUW+B+cui7/fg1uPaPa+RDTurmf3oM8XxIKyHHzu7AVp+7mfObMJeW4HdneN4OmdvH4TGdUvXjyAWx58F6FIDOcsLcNzt5yNz561APkep/IaSZJwYkMx/vT5dbhuXTzr/9bHdirPDkQzYXAwg/z35j0YDUWxtr5QOR6UDtWFWfjUafGf98NnmT1IpLbD/X7saB+G3SbhohWVeg9nEjGe53Z1s3EBkQp+/3q8Y/AZFTE47drexommB395uw2hCNc3kZZa+vzKsf7vXr4Sbsf8jhNPVJjtwvWJxkM/2rwXUWYPEhnOva8fxvefiif6fP7sBfjNdSejLM894+sddhtuu2wF/uG0Bsgy8K9/ambmP82KwcEMsatzBH96O34M6RsfOm7ex4mP9oVzFiLbZcf2tmE8v7snrT+biCZ7PLHzd/rCEpTkznxToIeTGotRkuPC8FgYbxxkHVKidDrY68Pbh+O1Rk8t1/7h/ZylZSjPc6PfH8Jzu1ibjEhL//v8AcRk4Lzl5Th9UWnaf/71ZzQh3+PAvh4f/sb1TWQoL+7txa2PxhuK3nTuImzcsDyp53lJknDbZStwxqJSBMIx3PzANm7u0YwYHMwAsgx8/5k9kOX4EcS19UVpf4/SXDf+IZG2/H8vHUz7zyeiccqR4uONc6RYsNskXLCiAgDw1Hs8vkCUTqJD+ZmLS1Hg0v79HXYbPnJSLQAeLSbSUocfeCJRruNfzl+iynsUZDlxTeJk0W9eblHlPYgode1DY7j5/m2QZeBjJ9Wl/Blgt0m466OrUJjtxHvtXvz6ZT6r0/QYHMwAB0aAVw8MwGW34esXLVPtff7x9EY4bBJePziA99qHVXsfokx2uN+P9zu9sNskXGiwI8WCGNczO7t5NIkoTaIxGQ+90w4AuHpNtW7juHptPDj40r4+9PmCuo2DKJM81WaLb/IfX4UV1ep1KL/u9AY4bBLeaOG9PJERyLKMrzz4LgZHwzi+pgC3X74CkpT6CcCKfA9u/dBxAICf/G0/OofH0j1UsgAGBzPAc+3xf+aPnFSbtiYk06kqyMKHEs0Rfs3sQSJVbH4/ftTn1KZiFOXokDqUhNMXliLP40CfL4jmI4N6D4fIEl490IfO4QAKspw4d2mZbuNYUJaLE2oLEI3JLG5OpIEDvX5sH7BBkoCbz1us6ntVFWTh4sSphN8ye5BId3988wheO9gPj9OGn16zBh7n3GuNXrmmBic3FmEsHMUPErULiSZicNDidneNYNeQDTYJ+NxZ6etqNpMbzoi/x+PbO7kjQaQCUefrvOUVOo9kZi6HDWcviQcvWIOUKD3+nKgbfNmqarjn8XCQDpevrgEAPNLcrus4iDLBvYkmRB9cWobFFXmqv98NicYkf93egR5vQPX3I6LpdQ6P4c4ndwEAvnLBUjSU5Mzr50mShG9dugIA8Oi7HdjbPTLvMZK1MDhocb96Kb7rd9GKinl/oCTj+NoCnNpUjEhMxn1vtKr+fkSZZHg0jLcOxTPxjBwcBIAPLi8HADy/u1fnkRCZnzcQxtOJemMfPrFW59EAl55QBZsEbGsdwuF+v97DIbKs4bEwHm7uAABcl6jtrbZVdYU4saEI4aisNDMkIu195/H3MRKMYHVdIT79gaa0/MyVNQW4aEUlZBn4n+f2peVnknUwOGhhbYOjePK9eJbR585MzwdKMj51Wvzm5U9b2xCJshsSUbq8sLcH0ZiMJRW5qC9Rr0RAOpy9pBySBOzq9KJjiFnERPPx5PZOBCMxLC6PH+nVW3m+B6cvjHdLfSwRuCCi9PvT1iMYDUVRlSXj1Kb0NxScySdOqQcA3P9WK2KsHUykubcPD+DJHV2wScD3rz4e9iQ6Eyfr5vMXQ5KAJ3Z0YlenN20/l8yPwUEL++ObrYjGZCzOj2FFdb5m73vBigoUZTvR5Q3gxb3MGiJKF1Fv0OhZgwBQnONSOqP/fQ+PFhPNx1+3xwNwV66tmVMhcjVcvjreFEWMjYjSKxqT8f9eOwQAOLsqpunav+T4KuR5HDgyMIZXDvRp9r5EFG9CcscT8ePEHz2pDssq0/scv6wyH5ckaosye5AmYnDQosLRGB54K34U4IxKbXf83A670s3wj28e0fS9iawqFInhxT3xYPt5xxk/OAgA5y6LHy3+O+sOEs1Z70gQrx3oBwB86Hj9uhQf7YLjKuG0S9jb7cP+Hp/ewyGynFcP9OHIwBgKshw4sVTbe/kslx1XronXFv3jmywTRKSlZ97vwTutQ8hy2nHL+UtUeY+bPrg48V5dLA9CCgYHLWrz+93o8wVRluvC8UXaHwf4+Cl1AOIZQ90sZkw0b28fHsRIMIKSHBdW1xbqPZykiODgy/v7EAhHdR4NkTk9/V4nYjKwqrbAUOUECrKdytHip99j12KidPvT1vgm/6UnVMGlQw+ij58cP1r87M5u9I4EtR8AUQaKycD/Pr8fAPDZsxagPN+jyvssqcjD+qVlkGXgnlcOqfIeZD4MDlrUH944DAD48Ik1sOvwr7yoPA8nNxYhGpOVDotENHcv7YtnDZ65uBS2NNYdUdOyyjxUF3gQCMfw+sF+vYdDZEp/3R4PvH3oBONkDQobVlYCAJ5KNEshovQYHgvjmZ3xdXV1IoNPa8dV52NVXSEiMRmPvcvyAURa2DUkYV+PH7luBz6jcs+Az5yxAADw4NYjGB4Nq/peZA4MDlpQS58fr+zvhyQBHztJv66GHzkxnj34aHM7ZJnFjInm46V98Zo/Zy4u03kkyZMkSRnvy/tYs4goVV3DAbx1aAAAcMkJVTqPZqoLVlTCbpOws8OL1v5RvYdDZBmPb+9AMBLD0oo8rKjO020cV6+NByYf2dau2xiIMsnzHfHwzDWn1iPf41T1vT6wqATLKvMwGorij2+xfAAxOGhJD70Tz9Q7e0kZagqzdBvHRcdXwuWwYW+3D7s6R3QbB5HZDfhDeK9jGEA8c9BMzkiM9+X9DA4SperJHZ2QZeCkhiJU63g9n0lxjgunNhUDAJ7i0WKitBGnbj5yUq2uTYguOb4KDpuEHe3D2N/De3kiNW1vG8Z+rwSHTcKnP9Co+vtJkoQbzohnJ/7u1UOIsjN5xmNw0GJiMRkPvRPf3btqrX5ZgwCQ73Hig4maY480c8eRaK5e2d8HWY4f01Wr9ohaPrCoFJIE7O4aQQ/rjxKlRHQo33C88bIGBTG2p3fyaDFROuzvGcG21iHYbRIuX63PkWKhJNeNs5fETwA8so1Hi4nU9JtE7b9LT6hEVYE2G4KXrqpGYbYTHcMBbNnbq8l7knExOGgxbx0aQPvQGHLdDlxggI6m4qbmseYO7kYQzdHEeoNmU5zjworqfADMHiRKxdBoCG8mjhSfv1z/6/lMxL1G85Eh9PnYtIBovv78dnxD/ZylZSjLc+s8GuCKRM3DR5rbEeO9PJEq+nxBPPt+DwDg06c3ava+HqcdVycSiv7wBo8WZzoGBy3m4URNkA0rK+Fx6tDa7CjnLCtDvseBLm8Ab7SwIQFRqmRZVur1nWGieoMTnbGIdQeJUvXCnl5EYzKWVuQZqkvx0SryPTi+pgCyDPx9d4/ewyEytVhMVur7ffhEfU8ACectr0Cu24G2wTG83Tqo93CILOmhd9oQicloyJWxvErbOqOfOCXeJ+D53d3oGuYpn0zG4KCFBMJRPLEjXvNH7yPFgtthV4qo/5WdzohSdqDXj47hAFwOG05pLNZ7OHNy5oS6g2xORJQccaT4fAOcAjiWcxMlRP62i8FBovnYengQXd4A8jwOnJNYV3rLctlxwYr459AT21lblCjdZFnGA28dAQCcVh7T/P0XlefhlKZixGQo46DMxOCghfxtVw9GAhHUFGYpBcKN4JLjqwEAz+7sRiSq/QcekZmJI8WnNBYjy6V/NvBcnNhQBLfDhp6RIPZ2+/QeDpHhBSNRvJio/XOeCYKD5yWOPb+0rxfBSFTn0RCZl9hIv2hFJdwO41zzL0nUFn3qvU4eLSZKs7cPD+JArx/ZLjvWluqzvq45pR4A8ODWI1zjGYzBQQt5eFu8s9nlq6ths+nX2exopy4oRlG2E/3+8fpJRJSclxJHcc1Yb1DwOO04JbFh8eoBHi0mOpbXDw7AF4ygPM+NE2oK9B7OMa2ozkd5nhv+UBRvHOR1nmguItEYnkycALp0VbXOo5nsjMWlyHM70O0NYtsRHi0mSqf7E9l6F6+shEenPYGLVlYiz+1A+9AY3mjhdTxTMThoEUOjIbywJ55lcNVafTubHc1ptynHop5+j90MiZIVjsbwxsF4rc4zTBwcBIDTFpQAAAMHREn42674keIPLq8w1GbfTGw2CR9cHj8C+TzrDhLNyWsH+9HvD6E4x4XTF5boPZxJ3A67ksX8xHbeyxOly0ggrBzX/8iJ+j3De5x2XJzIEBYJR5R5GBy0iM3vdyMSk7GsMg+LyrUtYpqMDYkPm6ff62KqMlGS3msfhj8URUGWE8sr8/UezryIUgdvHhpg3UGiY9iSOFJ8zlLzNCE6d1k8cPC33d1c40RzII4Ub1hZCYfdeI9oG1ZWAuDRYqJ0+uu7nRgLR7GoPBdr6vQ9KXBlIsHoqR1dCIRZIiQTGe/KQ3PyVCIjT0T8jeYDC0uR53GgZySId9jpjCgpIq3/lKZiU2QPzeaE2kJ4nDYM+EPY18O6g0Qzae0fxaH+UThsEtYZLHtoNh9YVAKnXcKRgTEc7h/VezhEphKOxvDMznjG8IdOMNaRYuGsJWXIcdnRORxAc9uQ3sMhsgTRnfyjJ9VCkvS91z+lsRg1hVkYCUaUpmiUWRgctABvIIyXE3XJxK6e0bgcNpyfKFj+5A4eRyBKhjhSbKQGQ3Plctiwtr4IwPjfi4im2pJoQrS2vgh5HqfOo0letsuBExvia1w0UiKi5LzVMoDhsTBKclxKjV6j8TjtODdxL//sTgYOiOarfWgMbx4agCQZo86ozSbhijXxcTycCFpSZmFw0AKe39WDUDSGhWU5WFxhvCPFwgUreOSIKFnRmIyth+JZtqJen9md2hT/e7zOQsdEMxKBNTM2ITpzcfwY9JZ9bDxElIpnE1k65y4rh93AJwVEDXFRF5WI5k6UEji1qRhVBVk6jybuyjW1AOLlTYZGQzqPhrTG4KAFPPVevIipUY8UC2cuLoPLbsPh/lEc6OWxQqLZvN/hxUgwgjyPA8urzF1vUDh1QTwb4o2DrDtINJ1wNIZX98cza89aYp56g8JZieDgawf6EY7GdB4NkTnIsqwc4RPBN6M6e0kZHDYJ+3p8ONzv13s4RKb2WHM8OHjZKuM0E11UnovlVfmIxGRmCGeglIODW7ZswaWXXorq6mpIkoRHHnkk6e995ZVX4HA4sHr16lTflmYwGoooXYovMuiRYiHH7cBpifpJz+1iN0Oi2bzREg8QnNxYbOgsglSsriuEy2FDny+Ig318qCA62rtHhjASjKAw24mVNfoWJp+LFdX5KMp2wheMoPnIkN7DITKF9zu9aB8ag8dpU7Jvjaogy6kce+a9PNHc7esewfudXjjtkuHKgl1yfHw8j+/o1HkkpLWUg4N+vx+rVq3C3XffndL3DQ0N4dprr8UHP/jBVN+SZvHq/n4EIzHUFGbhOBNkF523vBwAjyMQHcvrB+NHb09bYMzaQ3Phcdqxuq4QAPAmjxYTTSG6FJ+xqNSUmwI2m4QzEsGNl/ay7iBRMkTW4JmLy5Dlsus8mmP7YKLu4HNsWEA0Z48ljhSfvaQMRTkunUczmTiN+Or+Ph4tzjApBwc3bNiA7373u7jyyitT+r4bb7wR11xzDdatW5fqW9Is/r4nvmt37rJy3TscJePcZfHg4NuHBzHo54cN0XSiMRlvtohmJNaoNyic3BhvWPD2YXYtJzqaqNV3lsGzh2YjaiW+yLqDREkxy5FiQWz0v3loAMOjYZ1HQ2Q+sizj0cSRYiM0IjnagjIeLc5UmtQcvOeee3Dw4EF861vf0uLtMoYsy8qRYhF0M7raomwsq8xDTAZe2MvjCETT2d3lhTcQQa7bgRXVxs8IToXoWPxOK4ODRBMNjYawvW0IAHDmEvM1IxFEcHBH2xBGAgwcEM2m2xvAzg4vJMk89/INJTlYXJ6LaEzmvTzRHGxvG0brwCiynHbDbgrwaHFmcqj9Bvv27cPXv/51vPTSS3A4knu7YDCIYDCo/LfX6wUAhMNhhMMz32iKP5vtNVayr9uH9qExuB02nFiXP+3f24hzcs6SUuzuGsFzO7vxoZXafyAacU70lOx8qDFfc13rE8djxX/HV/fHg/5r6wsgx6IIx6LH/B6zzMfKqlwAwMFeP3qG/SjKVu8ohVnmREvJzIla88Vr++y27OlGTAYWleWgNNth2jkpzXagoTgbhwdG8fqBXqzXqLGKkedED3pe2wGu92T9fVcXAGBldT4K3DbT3MuvX1KKfT0+/H1XNy5eoW1Q04jzoTfey5vLk9vjWYPnLC2FU5KnzIMR5uOC5WX44bN78er+PvR5R1GQ5dRlHEaaE6NQ815ekufRMlKSJDz88MO44oorpv3zaDSK0047DTfccANuvPFGAMBtt92GRx55BM3NzTP+3Ntuuw233377lK/fd999yM7OnutwLedv7RIea7VjeWEMNy43T1fAg17gf3Y6kO2QccdJUZiwrFJGGh0dxTXXXIPh4WHk56cnm41rfXq/3WPDuwM2fKg+ivNrrNfV945tdvQEJHxuWRQriqz39zM7NdY6wPV+LH8+aMNL3TacVRnD1U3muaZP5/4DNrzWY8O51TFc3mDuv4vVcb3r6//tteGdfhsuqInhknrzrJW9wxLuft+OPKeM75wYhQkqGxF4L28U32u2o3tMwnWLo1hbatz74Dub7egak3Dt4ihONPA4aaq5rnVVg4NDQ0MoKiqC3T5eXDcWi0GWZdjtdjz77LM499xzp3zfdDsQdXV16Ovrm/UvFw6HsXnzZpx//vlwOvWJbmvpk795C28eGsStlyzDP5xWP+1rjDgn4WgMp9z5AnzBCB668VQcr3FHRiPOiZ6SnQ+v14vS0tK03lDMda2nMm6zkWUZZ/zXFvSMBHHfDScrNfqOxUzz8bWH3sND2zrwT2c14ZbzF6v2PmaaE60kMydqrHWA1/Zjufgnr2Bfjx8//fgqXLhi9qx6o8/Jo+924it/3oETavLxlxtP0+Q9jT4nWtPz2g5wvScjGpOx7gcvYHA0POv13ohzEozEcPL3nsdYOIbHvrAOy6vyNHtvI86H3ngvbx4He/248H9fgdMu4Y2vr0eeZ/zvbbT5uGvzPvxiSwsuOb4SP/7oCbqMwWhzYgRq3sureqw4Pz8fO3bsmPS1n/3sZ3j++efx5z//GU1NTdN+n9vthtvtnvJ1p9OZ1C9Fsq8zM28gjLdbhwAA5x1Xdcy/r5HmxOkETl9Ygmff78arBwextlGf2kpGmhMjONZ8qDFX813rqb7WDNoGR9EzEoTDJmFtYwmcztQ6F5phPk5uKsFD2zrQ3ObVZKxmmBOtzTYnas0Vr+0z6/cFsa/HDwA4fXG56T//PpBoqPJehxeBKCY9/KjNqHOiFz2u7QDXezLePzKEwdEwct0OnLygFE777KXgjTQnTiewbmEpnt/dg1dbBnFCfbEOYzDOfBgF7+WN7+/74g0H1y0sRXHe9JmVRpmPC1ZW4RdbWrBlbx9kyQ6XQ5N2FdMyypwYiRr38in/C/t8PjQ3NyvHgltaWtDc3IzW1lYAwMaNG3HttdfGf7jNhpUrV076X3l5OTweD1auXImcnJw5DZqAl/f1IRqTsaAsB/Ul5kvZPjNRg2gLuxkSTSK6+K6ozocnxcCgWYimJO+2DSESNc8xKiK1vNkyAABYWpGH4hz16nBqpaogCw0l2YjJwNZDbD5ENJ0te+P1hU9fWHLMwKARnZVoPiT+HkR0bM/ujNcZvcCgjUgmWl1biNJcN0aCEeU+hawt5SvR1q1bsWbNGqxZswYAcMstt2DNmjW49dZbAQCdnZ1KoJDU8/zueHewc5aao7PZ0cQNxTuHB+ELRnQeDZFxbEtkBK+pT+44sRktLs9FntuB0VAUu7tG9B4Oke5ePxjPJDhtgfbZN2o5rakEwPjfjYgm27IvHlQ7e6k2TXvS7azERv/WQ4MYDfFenuhYerwBbDsyBACG7VI8kc0m4bzl8VjDc7u6dR4NaSHl4OD69eshy/KU/23atAkAsGnTJrzwwgszfv9tt902azMSOjZZlpVduvUmvaFoKMlBQ0k2IjEZrx/ggwOR8E5rPMtmbYN1g4M2m4TV9YUAgG2tzCoiev1gfEf+tAUlOo8kfU5bGA90MjhINJU3EMY7ic3Asxab816+qTQHNYVZCEVjXOdESfj7nh7IMrCqtgAV+R69h5OU85bHg5ib3+/GPFpVkEmYL4edcKDXh56RIFwOG05uNG+WwZniOMI+HkcgAoBAOIr3O7wAgLWJ4JlVnZgIfopj1ESZqt8XxJ7ueAbtKU3mvaYfTQQ6d7QP84QA0VFe3d8fLw9UmoO6YvOVBwLijSlF9uBLLBNEdEwvJpJ7zl1m/KxB4YzFpfA4bWgfGsO+Hp/ewyGVMThoQq/sj+/OndRQZOqaZGcsit9QvMrMQSIAwPa2YURiMsrz3KgpzNJ7OKoSwUGROUGUqSbWGyzJnVrU3ayqCrJQU5iFmAy8mzhGRURxYmNcBNfM6gOL4psAr/FenmhWkWhMCaKftUSfZpxz4XHalc2+F/cwocfqGBw0oVcPxD9YPrDIPB8s0zltQTEkCdjf40PvSFDv4RDpThwpPrGhCJIk6Twada2uK4QkAa0Do1z/lNHeaBFHiq2TNSgwQ5hoeiKYdobJ7+VPTdQW3d01ggF/SOfREBlX85EhjAQiKMx24oTaQr2HkxJR+uBFNh+yPAYHTSYak5UbinULzV2bqDDbhWWV+QBYk4gIiDfoAca7+VpZnseJRWW5AIAd7UP6DoZIR+L6d6qF6g0KIji4lcFBIkXXcAAtfX7YJOAUk28KlOW5sbg8fi1/s4X38kQzEf0CzlhUCrvNXAkAomnSmy0DbD5kcQwOmszOjmF4AxHkuR04oaZA7+HM27oF7GZIJGxvGwYArKor1HcgGhE7p+8eGdZ3IEQ6GfSHlI7dVqo3KIjg4LbDg4jFWMicCBi/511ZU4B8j1Pn0cyfSFbg0WKimYmsu7NNWEpgwYTmQ28kGqiRNTE4aDKi3uCpC4rhsJv/n08co2JwkDJdjzeALm8ANglYUZ2v93A0cUJtfINjRzuDg5SZth2JZ9QtKMtBqYXqDQrLKvOQ7bJjJBhhIXOiBHHPu84i2cKiHtlrvJcnmtaAP4TtiXtdM9YZlSRJyR7k0WJrM390KcOIeoOnLzR3jRLhlKZ43cEDvX70eAN6D4dINyJrcFF5LnLcDp1Ho43jE8HB7W3DkGVmFVHmedvipQQcdhtWJzKhtx5mtgERMB5EO81iwcG93T70+VhDmOhoL+3rhSzHN8wq8j16D2dORMbjFgYHLY3BQRMJRqJ461D85trszUiEwmwXlou6gy18cKDMJXYUzVakeD6Oq8qHwyahzxdE5zA3ByjzvHN4CMD48VsrOolNSYgUHUNjONw/CrtNwkmN1lj3xTkuLKvMAwAeOSSahpmPFAunLyyBwybhYJ8fRwZG9R4OqYTBQRPZ1jqEQDiG0lwXllTk6j2ctBG1Sni0mDLZjrYhAONHbTOBx2nHkor4A4XInCTKFJFoDM1HhgBYOzi4NvF3e4fBQaJJ9QbzLFBvUDiNNcSJphWLydiyN37yz8zBwTyPU6mJzvqi1sXgoIm8qnQpLoUkmavL0WxOTRRhf4M3FJShZFlWgmPHW6DRUCrG6w4O6TsQIo3t7hrBWDiKPI9D6dxtRWvqiyBJwKH+UfSO8MghZbbXlSPF1mpAJBoqiRNORBS3p3sEfb4gspx2nGjybOF1rC9qeQwOmsibLdYqYCyc1Bi/oTjQ68egP6TzaIi01zEcQL8/BIdNwvKqzGhGIkysO0iUSd5pjWfSrakvgs1mnQ2/oxVkObGkPJ4hLP7ORJnq9cSxW8vdyycyhPd0j8AbCOs8GiLjEFl2JzUWwe2w6zya+Tl9Qmdy1gq3JgYHTSIUiWFb6xAA4JQmc+86HK04x4UFZTkA+OBAmUkcKV5SkQeP09w3DqlalaixyKYklGnGm5EU6jsQDfBoMRHQPjSG1gFRb9BamYPl+R7UFWdBlqE8rxDReJadKKNlZmsbiuCy29DlDaClz6/3cEgFDA6axI72YQQjMRRlO7HQgsePTqxnwXLKXO8msuZW1WXWkWIgHhB12W0YHgujlQWOKYOIzTAr1xsUTmRTEiK8nsggOr6mALluh86jSb+TGuIBz7d5tJgIABCNyUrZLCtkC3ucdqxJbGjyaLE1MThoElsTF9qTGostVW9QEB3btvLBgTLQDqXeYKG+A9GBy2HD0kSXw/c7vDqPhkgbPSMBHBkYgyRBKfBtZasTGx/vdQwjEo3pPBoifWw9HL+XF7W2rYb38kST7er0whuIINftsExN8dMXlgIY74VA1sLgoEmIAr+nWOwYgnBiYrfx3SNDCEX44ECZQ5ZlvN8ZD4qtqM6seoPCcYk6i2IeiKxu+5H4hsCislzkW6hj6UwWlOYi1+1AIBzDvh6f3sMh0oXInLVqtrDIHGw+MoQwNwGIlHqDJzcWwWG3RthFHI9+4yDrDlqRNX5LLS4Wk/HWofgNxckW3W1cUJqDwmwngpEYAwSUUbq9QQz4Q7DbJCWDLtMclwiK7uLapwyxvT0eHDwhUXPT6mw2Scma2J6osUqUSYbHwtjbHQ+Mr7VocHBxeS7yPQ6MhqK8nhPBWvUGhdV1hfA4bejzhbjZZ0EMDprA/l4fhsfCyHLaLZtZZLNJSt3BraxVQhnk/c54kGBhWU7GNSMRRIdmHiumTCECZJlUZ/SExN/1XXYmpwy0LVFjtLEkG6W5bp1How6bTVICn1sP8WgxZbZINIY3W0R38lKdR5M+LocNaxPP7G/xmd1yGBw0AfHBsrahEE6LpCRP58RErRJ2LKZMIgJiIkCWiZZVxTMmO4YDGBoN6TwaInXJsoztSp3RzAkOjncmH9J1HER6eEc5UmzNE0DCSWw+RAQA2NnhhS8YQb7HoZyQsQrRbZ2bANZj3UiThSjNSCx+QzGeOTjIGgaUMXZ1jgAYr7uXifI9TtQXZwNg3UGyvvahMQz4Q3DYpIzaFDihNh4I3d05gkA4qvNoiLT1doZ0J1eCBocHeC9PGU0cKT6lqQR2m7WaiYpNANFkiayDwUETaD4yBMC6NUqEVXWFcNol9IwE0TY4pvdwiDQhgmFW21VM1fIqdiymzCCyBpdV5WVUKYGawiyU5LgQicncBKCMEonG0Nw6BMD6wcFVtYVw2CR0e3kvT5lNNCOxUr1BYU19IWwScGRgDF3DAb2HQ2nE4KDBDfpDONQ/CgBYbfHC5R6nHSuq45kFPI5AmcAfjOBQvx9AZh8rBoDjquJrn0EDsrrxI8WF+g5EY5IkKdmD2xObnkSZYE/3CPyhKPLcDiwuz9V7OKrKctmxIlEugWWCKFNFY7LyLHuqBZuJ5nmcynMLswethcFBg2tO1OZZUJqDgmynvoPRgNhR5Q0FZYLdXSOQZaA8z23ZAuXJGu9YPKLzSIjUpTQjqc2ceoPCqrpCAOMBUqJMIOoNrmkogs1ixwunsyaxzpu5CUAZak/XCHzBCHJcdstu/p/MuoOWxOCgwYljCKsTF1qrEw8O7GZImYBHiseJY8X7e0YQisR0Hg2ROmIxGTva49e3Eyx+GmA6SlOSdl7jKXNsSwTJ1mTMvXyiMzmDg5ShRI3RNfVFlqs3KJzUyI7FVsTgoMGJXbfV9YW6jkMrIpNiV4eXAQKyPFFfL5ObkQg1hVnI9zgQjsrY18PsQbKmwwOjGAlE4HbYsLjC2scLp7MisRFysNeHsRCbklBmEJmyImhmdWITYGeHF+Eo7+Up87ydCJhZucaoaJS6qzPelZmsgcFBA5NlGe8qx48KdR2LVuqLs1GY7UQoGsPuLtYeI2tj5uA4SZKwLBEk3dvN4CBZ086OeJBgeVU+nPbMuwUry3OjNNeFmByvw0Zkdb5gBAd6fQAyJ1u4sSQH+R4HgpEY9nRxnVPmyYTu5JUFHtQWZSEmA9tYDswyMu/O1EQO949iaDQMl8Nm2XoFR5MkCccnChnzaDFZWTQmY08iAJ4p6/tYllbEjxbv6fLpPBIidSjZwhm6ISBJEo5LNB4TgVIiK9vRNgxZjmfHZ0ptYZtNmlAmaEjXsRBprccbwJGBMUhSvKuvlYm6g2+x7qBlMDhoYOJI8YrqfLgcmfNPpdQkYq0SsrCWPj8C4RiynHY0luToPRxDWFIZDw4yc5CsSskWzuANAfF3F4FSIisTDYhOyLAGROLvy7qDlGlEl+KlFXnI81i7maioO7iVdQctI3MiTiak1BvMkALGArsZUiYQQYJlVXmWLVacqiXl8RpsPIZEVpXpmYPA+N99J4ODlAHEvWymHCkWlI1+3stThhHBQRE4szJRd3Bb6xAirC9qCQwOGti2TA0OJnYb9/WMYDTEAqdkTbs6eaT4aEsSx4rbh8ZY3Jgsp3ckiJ6RICQJWJbIks1EoinJ7i4vojFZ59EQqWu8dnhmZQ6KZ5e93SPw83pOGWTrYevXGxQWleci1+3AWDiKfT0sCWQFDA4aVDASxa7ErnqmBQfL8z2ozPcgJgPvtTOzgKxpbyI7LpODBEcrynGhPC9ek2kfjxaTxYhs4abSHGS7HDqPRj+NJTnIctoRCMfQ0seHCbKufl8QbYNjAICVGRYcLM/3oKpA3Msze5AyQzASVU4IrK23fnDQbpOUEgLNLCFgCQwOGtT7HV6EojEU57hQX5yt93A0Jz5otrOQMVnU3p548GtxOYODE4nsQdYdJKtRjhRneLaw3SZheVV8nfNoMVnZ9kRQbEFZDvItXntsOuJefgeDg5QhdneOIBSNoSjbmTHP70rzIQYHLYHBQYMar1FSAEnKvHpkrDtIVjYaiuDIQDybYElFrs6jMZYl7FhMFqU0I8ngeoOCmAM2JSEr234kfg+7KsPqDQorlM7kXOeUGcYbEBVmzPO7OOHIzEFrYHDQoEQK/gk1mXUMQVAeHDp5Q0HWsz9Rl6M014WSXLfOozGWpZXxYCkzB8lq3u+IX9czPXMQGA8a8BpPVrYzseZXZui9vKgvymPFlCnebRMbApmz5llf1FoYHDSonUpHw8z5cJlI3FAc7PVhLBTVeTRE6SW68fJI8VQ8VkxWNBqK4GCfHwAzB4HxRky7GBwkCxP38isydM2LTYADvJenDDExczBTVEyoL8oSAubH4KABBSNR7EvUI1tZk5k3FOV5HpTmuhGTgV1dfHggaxEdvXikeKrFieBgz0gQg/6QzqMhSo89XSOQZaA0143yPI/ew9HdkopcSBLQ5wuhzxfUezhEaTc8Gkb7ULx8yPIMzRauyHejJMeFmBzvTk5kZb5gRLm/P6Eus5J7ROkE1h00PwYHDWhftw/hqIyCLCdqCrP0Ho5uxE4ra5WQ1YisuCXsVDxFrtuhfO7tYfYgWQTrDU6W7XIoxdqZJUxWJNZ8XXEWCrIyrxkJAEiSpHzm8V6erO699mHIMlBV4Mm4TcDV9YUAWHfQChgcNCBRo2RFdX7GFDOdzgoWLCeL2tctMgcZHJyOyKg80MumJGQN7FQ81XjzIQYHyXqUDYEMX/NsSkKZYvxIcWZlDQLjmYMMDpofg4MG9F57/AKaqQWMhfFuhqxfQNYxEhg/arSENQentbAsHhwUjVuIzI6Zg1MtZX1RsrCdSgOizL6XX8F7ecoQSjOSRIOOTHJ8bQEkCegcDqB3hKVCzIzBQQOamDmYycRu4+6uEUSiMZ1HQ5Qeoh5JRb4bBdmZedToWBaWi8xBv84jIZq/WEzG7s54AOy4Km4ICEsrmTlI1qVkC2f4vbxIdOC9PFmdyBxclUHNSIRctwNNpTkAxuMYZE4MDhpMNCZjV+IhYkWGdioWGoqzkeOyIxiJKV0eicxun6g3yCPFMxKZgweYOUgW0DY4hrFwFC67DY0lOXoPxzBEcHBvtw+yLOs8GqL0CUaiSuZ7pm/0NxRnI9ftQDAS44YfWdbQaAhHBuKngjL15B9LCFgDg4MG09Lnw1g4iiynXYnAZyqbTVI6vHEXgqxib6Le4GIeKZ7RokTmYPvQGMZCUZ1HQzQ/4tjswvJcOOy87RIaS3LgtEvwBSNKqQUiK9jX7UMkJqMw24mqgsxqTHC0+L18/H6H9/JkVWxABKys5jO7FfAu1WB2TjiGYLdlbjMSQelY3M5dCLIGpVNxoukGTVWc40JR4sj1wT5mD5K57eGan5bLYcOC0vicsO4gWcnEZiSZ3FhQEE1ZdrOEAFkUm44xc9AqGBw0mPfaWW9wIlGrhTcUZBVKcLCSmYOzUY4W8xgSmRxLCcxsvO4gNwHIOkSggPfycUsreS9P1ja+5jPzSDEw/nl3uH8U3kBY59HQXDE4aDAi2r4ygz9cJuINBVnJ8FgY3d54F6/F5cwimg3rDpJV7EmUEljK4OAU43UHeY0n62AzksmWVsav53u6mFFE1rSTmYMoynGhpjALwPhnIJkPg4MGIsvypGPFNB5A6fMF0e9ja3QyN5FBVF3gQZ4nM2uSJGthebzm6v5eBgfJvCLRGA4kfoeZOTiVmBNuAJJVxGLyhGPF3OgHxtd5tzeIodGQzqMhSq9AOKrcq66oyeznd5E9KE5CkvmkHBzcsmULLr30UlRXV0OSJDzyyCOzvv7ll1/GBz7wAZSUlCArKwvLli3Dj370o7mO19Lah8YwPBaG0y7xISIhx+1AfXE2gPG6TURmJYIEi7i+j0k0JWHmIJnZ4YFRhCIxZDntqC3K0ns4hiOyKQ/0+hCNsWMxmV/b4Bh8wUi8pmZZZjcWFPI8TiWjaA83Ashi9nXHr19F2U5U5md2AyJxrJqZg+aVcnDQ7/dj1apVuPvuu5N6fU5ODr70pS9hy5Yt2LVrF77xjW/gG9/4Bn71q1+lPFir292Z6GhYlguXg0mdwnhNIt5QkLkdTNTPW5DhnciTIY4Vt/T5GTQg0xLZwosrcmFjk7Epaoqy4HbYEIrE0DY4qvdwiObt/c54xszSijw42Z1csUzcy3OjnyxGdOddUV2Q8Q2IViYyJ99jx2LTcqT6DRs2bMCGDRuSfv2aNWuwZs0a5b8bGxvx0EMP4aWXXsLnPve5VN/e0sQFcxkbFUyytCIPm9/vZk0iMj3RXIPZBMdWW5QNl92GYCSGjqEx1CUyiInMRDTa4GmA6dltEppKc7C7awT7e3xoKOFnI5mbWPO8l59saWUe/ra7hyUEyHKUMgIsCYaVNfHMwf09PgTCUXicdp1HRKlKOTg4X9u2bcOrr76K7373uzO+JhgMIhgcry/n9cYXXTgcRjg8c/cb8WezvcbI3k9E2ReV5aTt72D2OQGARWXxoMCuTm9a/h5WmJN0SnY+1Jivua71ieMx07/jwd74TXF9kSft4zbjfBxLY0k29vb4sKdzCJV5qddotOKczFcyc6LWfGXitX13IotoYWl2Wsdv5jk52sJEcHBvlxdnLSqe88+x0pykg57XdiAz1zswvuYXlaVvzZt9ToD4ZyAA7E7DvbwV5iPdeC+vH1Ffb0n5/J/fzT4fRR4birKdGBwNY1f7kJJJOB9mnxM1qHkvL8myPOfzWpIk4eGHH8YVV1xxzNfW1tait7cXkUgEt912G775zW/O+NrbbrsNt99++5Sv33fffcjOtm72yPeb7egck/C5ZVGsKOIxOqFrFLjzXQfcNhnfPyUKnszSx+joKK655hoMDw8jPz89u2OZtNajMeArb9oRkyXctjaCIrfeIzK+e/bY0DxgwxUNUZxTzc9Eraix1oHMWu/Cnc12dI1JuHFZFMt5XZ/WU0dseLrNhlPLYrhmUUzv4WQcrvf0+l6zHd1jEm5cHsXyQq55ocMP/GC7Ax67jO+fHEWGn77UDe/l0ysmA197045QTMLGVRFUWvuvm5Sf7rRhn9eGaxZGcWo5PwP1Mte1rllwsKWlBT6fD6+//jq+/vWv46c//Sk+8YlPTPva6XYg6urq0NfXN+tfLhwOY/PmzTj//PPhdJqrE2goEsOq7/wNkZiMF//1TFQXpqdwuZnnRAhH43MTjsr4+y1nzruouxXmJJ2SnQ+v14vS0tK03lDMda2nMm6jaOnz44L/eQVZThuav/HBtNcfM9t8JOPHf9uPu184iI+dVIPvXr4i5e+34pzMVzJzosZaBzLv2j7xur7lK2ehqiB9hcrNOifTeWJHF25+cDvW1hfigc+eMuefY6U5SQc9r+1A5q13AAgm1nw0JuOlfzsrbc0JzDwnQjqfc6wwH+nGe3l9iHt7t8OG5m+cC8c864yafT4A4DtP7MbvXm/F9ac3YOOGpfP+eVaYk3RT815es2PFTU1NAIDjjz8e3d3duO2222YMDrrdbrjdU9NqnE5nUr8Uyb7OSA70exGJycjzOFBfmpf2gqZmnBPB6Yw3J9jdNYIDfWNoKk/PxczMc6KGY82HGnM137We6mv11DoYv3FqKs2F2+1S7X3MMh/JWFIZX+stfWPz+jtZaU7SZbY5UWuuMu3afrB/JH5ddztQV5KrSqFys83JdJZWxWsUHej1w+FwzHuerDAn6aTHtR3IvPUOAPv7vIjGZOR7HKgtTv+aN+OcCOJefk/3CA70j6GhbP738maeD7XwXl5be3vjjbSWVeUjy5O+I0FmnQ8AOC7RsXhvjz+tfwczz4la1LiX16WNViwWm7TDQOOdeJdWpD8waAXsckZmd7AvXqSczUiSJzoWH+j16TwSotSJ69WSSl7XZ9NUmgNJAobHwujzhfQeDtGcicZ5S7nmp7U0cS/PpiRkFTs7Es1IqtiMRFiWmAuuc3NKOXPQ5/Nh//79yn+3tLSgubkZxcXFqK+vx8aNG9He3o7f/e53AIC7774b9fX1WLZsGQBgy5Yt+OEPf4ibbropTX8FaxALaAm7m01rCW8oyOQOKp2Kc3UeiXmIQGq/P4Sh0RAKs9XLuCRKt30iOFjBNT8bj9OOuqJstA6M4kCvD2V5LMhK5iSCg4vZnXxa4rNwfzc3/Mga3u9gp+KjLanIhSQBfb4g+n1BlOTymm4mKQcHt27dinPOOUf571tuuQUAcN1112HTpk3o7OxEa2ur8uexWAwbN25ES0sLHA4HFi5ciB/84Af4/Oc/n4bhW4fIHFzG4OC0lpTH52V/D28oyJxEcHAhMweTlu1yoDLfgy5vAC19fqypZ3CQzEMJFJTzun4sC8ty0Dowiv09Ppy2oETv4RDNyZ6u+D3qUgYHp7WoPBEc5GkAsghxnT+uimteyHY5UF+cjcP9o9jTNYLTFzE4aCYpBwfXr1+P2XqYbNq0adJ/f/nLX8aXv/zllAeWaSYeK6apxA3FgV4fojEZdrYsJpNRjhWXMosoFY2l2ROCg0V6D4coaQcSGwLi+kUzW1Sei7/v6WUJATK1vUq2MO/lp6Pcy/f4IMsyj16TqQ2PhdE5HADAbOGjLa3Iw+H+UezqGsHpi0r1Hg6lQJeagzTZSCCM9qExAOP1OGiyuuJsuBw2hCIxtA2O6j0copRMrKXVxMzBlDQlgqmH+vw6j4QoeZFoDIf7RSkBrvljEfVFeTqAzGo0FEHrQPz+lKUEptdQkgOHTYI/FFWCKkRmJUqHVBd4kO9ho4yJRN3BPV1enUdCqWJw0ADETmNFvps1tWZgt0lYUBp/wOLDA5nNwUQ2THmeG7luzZrEW0JTaTYAoKWfmwJkHm2DYwhHZXicNlQXZOk9HMMTGUWi/AKR2exL1NErzXWzxtYMnHYb6kvi13Tey5PZTWw6RpMpjUTZK8B0GBw0ANFkY2kli5nORqlVwhsKMpmWPmYQzVVjSXzOWvq47sk8RBmBxpIc2FgG45hE5mD70Bj8wYjOoyFK3R42IErKorLxMkFEZraXJcFmJE5C7u2OlwMj82Bw0ADYjCQ5DA6SWR1OZL2JQBclTwRUD/WNzlrvlshIxhsQMVCQjKIcF0py4icnmD1IZiQCBaw3ODvey5NV7GGN0Rk1luTA7bBhLBzFkQGe/DETBgcNYDd3HpLCLmdkVqIOkThOQ8mrK86GTQJ8wYhSt5HI6A6wO3nKFpYzo4jMa28i2MXa4bNjcJCsQJbl8WaiXPNT2G0SFrCWsCkxOGgA+7jzkJSJNxTMICIzEY0JGooZKEiV22FHdWG8ZlsLm5KQSYg6owuYOZg0NiUhM2PmYHIWcROALKDPF8LgaBiSNP47TZMtTszLPl7TTYXBQZ31+4IYHA0DABaWM3Awm6bSHNgkYCQQQe9IUO/hECVNZA42MHNwTppKxdFiBgfJHA6yzmjKGDQgsxoeC6PLG+++u5g1B2clNgH6fCEMjfI0AJmTaCbaWJIDj9Ou82iMiVnC5sTgoM7E0aOawixku9jFdDZuhx31xexyRuYy8TgsjxXPjQgOtvQzOEjG5w2ElQ0s8btLx7ZArHNuApDJiIB2Rb4b+R6nzqMxthy3A9UFHgC8lyfz2tPFBkTHwnJg5sTgoM7EDcVCpiQnhR80ZDatiWYkRdlOPjTMkdKxmI0KyAREQ43yPDfyuOaTpmQI9/sRY3dDMhGx5heU8l4+GQuZUUQmJzIH2S9gZsppAJYDMxUGB3UmLowsWp4c3lCQ2bQOxB8a6tmpeM4mBg2IjG683iDXfCpqi7LgsEkIhGPKEU0iMziobPRzzSeDxw3J7JROxWxGMqPGkhzYbRJ8wQiv6SbC4KDOROYgi5kmZxELlpPJHE5kDjYU80jxXDGjiMxEySJiM5KUOOw2pXQI64uSmYh7eWYOJoengMjMZFlWGhAxc3BmLodNqbXO53bzYHBQZ8qxYj5EJIW7jWQ2h9mMZN6YUURmcrBPBAqYRZQqsRFwkMFBMpHxDQGu+WRwo5/MrH1oDP5QFE67hEZe52fFtW4+DA7qKBCOom1wDAAzB5MljhX3jAThDYR1Hg3RsYmag/XMHJwzh92GOmYUkUm09MXXPAMFqWtkUxIymUg0ppwQ4EZ/csQzT/vQGMZCUZ1HQ5QaUW9wYVkunHaGUmYjurfvY3DQNPgbraODvX7IMlCQ5URJjkvv4ZhCvseJinw3AO5CkDkcTtQcbGDNwXlhx2IyA1mW0drPNT9XSgkBBgfJJNoGxxCKxuB22FBTmKX3cEyhJNeNomwnZHn8BBWRWezpiv/OLuaR4mPiiT/zYXBQR+NHinMgSZLOozEPftCQWYSjMXQMxY/B8ljx/LBjMZlBvz8EfygKSYofh6fUNDFzkExGlBFoKs2BzcZ7+WSJe3mWECCzEc/vi3nq75gWlcUDqAf4zG4aDA7qSAS3eKQ4NeLYxkEGCcjg2gfHEI3J8DhtKM9z6z0cU2sqTRwrZuYgGdjhxO9ndUEW3A67zqMxHxEcbB0YRSQa03k0RMcm7kV5pDg13PAjsxLdyVk65NhEB/d+fwgD/pDOo6FkMDioIzYjmRtR5P0gjyKQwYlmJPXF2cwOnqemRBdIZhSRkR1mjdF5qcz3wOO0IRKTlZrMREZ2gM1I5qQpMV/c8CMzkWVZWfN8fj+2bJdDKbfAE3/mwOCgjvjhMjdNZQwSkDmI2mP1xXxomK/GROYgM4rIyERwkGUE5sZmk8YziniNJxM4wCyiOVnAzuRkQgP+EIbHwpCk8Ux3mh3LgZkLg4M6icVktCTqlCzkseKUiBuKw/2jiMZknUdDNDOR+VJXzNpj81VdkAWXw4ZwVFbqOBIZTavIFmZwcM5Yd5DMRBwrXlDKe/lUKKcBen2QZd7LkzmIxJ6awix4nCwdkgwGB82FwUGddI8EEAjH4LBJqGPR8pRUF8aDBKFoDB1DPHZExtWW+P2sLWKgYL7iGUXxeWTHYjIqUXOwkZ2K56yRwUEyCW8gjD5fEAAzB1PVUJINSQK8gQhrkZFpjNcb5GZAskTjln09IzqPhJLB4KBOxE1vbVEWHHb+M6TCPiFIcIB1B8nAROagqLdB8zNewJzrnoyJNQfnT2QOshYZGd2hxL18WZ4beR6nzqMxF4/TjuqC+L0RNwLILMb7BXAzIFkic5Adi82BUSmdiAeIRtYrmBMeOyIzaB+Mr/NaZgenxXjQYFTnkRBN5QtG0J/IgGHNwblrUpqO8fpOxiauRY1c73PCe3kyG6WMADMHkybmqmM4gEA4qvNo6FgYHNSJ2G3k0aO5WcCmJGRwY6Eo+nzxQEEdjxWnhajjJuq6ERmJOFJcnONiFtE8iIBBx/AYHyTI0Nh0bH4YHCSzYeZg6oqynSjIit8T8USA8TE4qJNDSl0iBg3mgpkFZHTtQ/EAVp7bgfwsh86jsQaxmcKbCzKiVh4pTouSHBfyPA7IMjcCyNjYnXx+GBwkMwlGojiSKBe0kJmDSZMkaXyt87nd8Bgc1MmhPh4rno8FvKEgg1PqDRZlQZIknUdjDSLo0jYwxk7lZDiHBxgoSIeJDxLcACQjY3BwfprKeC9P5tHaP4poTEau24HyPLfewzEV8dx+kGvd8Bgc1EEsJuPwAI8Vz4c4Vtw+xGNHZEwiOMh6g+lTXZgFp11CKBpD5zA7lZOxiGPFDbyuzxubkpAZiHt5rvm5aSoZDw7GuOFHBndAqTeYw03/FDFL2DwYHNRB90gAgXAMDpvEwMEcTaxfwA8aMqLx4CAzCtLFbpOU+o2tbEpCBqNkEfFY8byNdybn9Z2MKRCOotsbBMA1P1e1RVlw2CQEIzF0egN6D4doVuP1BnmkOFXMEjYPBgd1II4U1xZlwWHnP8FcTKpfwA8aMqA2dipWhTi+dZi1yMhgjiTWfB0DBfO2QDxIMHOQDErUw8z3OFCYzQZEc+Gw25RGY4d4L08Gx2aic8dndvNgZEoHSjMS1huclwXchSAD47FidTSwKQkZUCQaQ+dQPPOlrphrfr74IEFGJwIFDSU8YjgfrEVGZiE2pRtLuQGYKhFQHfCHMDQa0nk0NBsGB3XAnYf0EDcUIs2byEjah3isWA2iKQmPFZORdI8EEYnJcNollOd59B6O6YnN096RIEYCYZ1HQzSVyBysZzOSeWEXUzILUVe4nqcDUpbjdqAyP35vxE0/Y2NwUAdK5iBvKOalqTRe84EfMmQ0gXAUvSPxWkQ1hcwiSiexY3uIwUEykLZEoKC6MAt2G7OI5ivf40RJjgvAeC1HIiMRv5e8l5+fRiVLmBv9ZFwTa4wyuWdueCLAHBgc1IGoOchjxfPDY8VkVCJrMMdlZy2iNKsvjq/71n4/ZJndDckYWEYg/URGVivri5IBiSOGDcW8l58PBgzIDMR1KI81RueMTUnMgcFBjcmyjMMDPFacDmL+hkbDGPCzfgEZx8ROxaxFlF51xVmQJMAfiqKf654MQlnzhcwiSpdG1hclA1OOGDJzcF4WJE4BHRkcQzga03k0RNObWBKM9/Vzw/qi5sDgoMZ6R4IIhGOwSUANMwzmJctlR3WBqF/A4whkHOxUrB63w47qgvi8HmbQgAyifYhrPt2UzuR9zBwkY4lEY2hPbAhwo39+KvLdyHLaEY3JOMIsYTIo1hidP9YXNQcGBzXWOqEukdPO6Z8vkaJ8kB80ZCAdiWPF1aw3qAolaMBaZGQQSuYgOxWnjbLOB3h9J2PpGAogEpPhdthQnufWezimJkkSjxaT4YkM9gY2I5mzieucZYGMi9EpjR1JZBTVsYNpWojjCExRJiPpHAoAAKoK2bVUDSJowKYkZBQTSwlQejQkMrK4CUBGo9zLF2fDxgZE88ZaZGR04w2ImCk8V3XF2bDbJIxNaO5CxsPgoMaODMQfIOqYXZAWTFEmI+oYTmQOFnCdq2FiUxIivUVjspItzO7k6SMyNDqHAwiEozqPhmhcm7LRz/WeDk0lrEVGxsZjxfPntNtQn7iuH2Q5MMNicFBjyocL05LTgruNZESdw4nMwQJmDqqhkZmDZCDd3vgRQ4dNQkU+13y6FOe4kOd2AABrkZGhMFM4vbjRT0YWjsaUNd/A4OC8sISA8TE4qDFxg1vH4GBaLEwcK27p9yMaY/0C0p8sy0pwkDUH1SF2blsZMCADEA8N1YVZsPOIYdpIkoSGUm4EkPGMBwd5jU+HxlJe08m4OobGEE3UGK3I4wbgfHAjwPgYHNQYdxvTq6YoC067hFAkphzrItJTvz+EUCQGSQKziFQiapEN+EPwBsI6j4YyHbuTq6ehWNQd5IMEGcf4mue9fDqIa3rH8BiCEZYQIGMR9QbrWWN03pg5aHwMDmooFIkptchYczA97DZJuangBw0ZgWhGUprrhsvBj1g15LodKM11AQBamVFEOmMWkXrYmZyMiGs+vUpyXMhx2SHL47XZiYxCbE41sBnJvC1gcNDw+OSqoY6hMcgy4HHaUJbr1ns4lsEPGjKS8WYkzBpUEzuZklEwi0g9SnCQxw3JIEKRGLq88U1ABgfTQ5KkCdd03suTsYj7TNYbnD/RK6B1YBThaEzn0dB0GBzU0BGlu1k2JIlpyekiPmgO9rLzEemvS2lGwocGNYlOpof4IEE6YxaRehgwIKPpHI5v9Gc57SjOcek9HMtoZH1RMqgj7E6eNhV5HmQ57YjEZOXeiYyFwUENtbIZiSqaEg8PvKEgIxCZg1WFzBxUkwga8Fgx6U3c4NawAVHaiUyNtsExZhmQIUzcDOBGf/qMX9O5EUDGItY8n9/nz2aT0FjKpB4jSzk4uGXLFlx66aWorq6GJEl45JFHZn39Qw89hPPPPx9lZWXIz8/HunXr8Mwzz8x1vKYm6mjU88MlrRqU4CBvKEh/ouZgNTMHVTV+3JDrnvQTi8lKtjC7k6dfRZ4HbocN0ZjMpmNkCGxApI7x0wDc8CNjYTPR9GpkLWFDSzk46Pf7sWrVKtx9991JvX7Lli04//zz8eSTT+Ltt9/GOeecg0svvRTbtm1LebBmd4Q3FKoQnY+YWUBG0MnMQU3U8+aCDKDfH0IoGu9OXsk6o2lns0nKRgCDBmQEDBSogyUEyIi8gTCGx8IA+PyeLlzrxuZI9Rs2bNiADRs2JP36H//4x5P++3vf+x4effRR/PWvf8WaNWtSfXtTO8Jjxaooz3PD47QhEI6hbXBMCRYS6aFjiDUHtSCyDLq8AQQjUbgddp1HRJlIbAaU5brhtLNSixrqi3Owt9uXOG5YpvdwKMOxxqg6RM3BtsExRKIxOPh5SgbQnljvxTku5LhTDpvQNBq54Wdomn/yxmIxjIyMoLi4WOu31p0IDvJYcXrZbBIaebSYDCAak9HtFcFBZhGpqTjHhWyXHbI8fvNGpDVlM4BHilXDBwkyEnYnV0dFngcuhw2RmKx8rhLpjZsB6cfMQWPTPAT+wx/+ED6fDx/96EdnfE0wGEQwGFT+2+v1AgDC4TDC4fCM3yf+bLbX6MUXjGBwND6uyjynZmM08pykU11RFnZ3jeBgzwjOWFA062szZU6Slex8qDFfc13rE8djpH/Hbm8AkZgMmwQUeWyajs2I86G22sIs7O3x4VDvCOoK3VP+PBPn5FiSmRO15suK1/a2gXhB7co8F9e7SmoTa7ul12fa3xM96HltB6y53oHxjX7ey6dffVEW9vf6sb9nGFX5zhlflynzkQrey6vjUN8IAKC6wKPJGI0+H+lQUxDv8t42OIaxQPCYWcKZMCepUvNeXpJlWZ7TdwKQJAkPP/wwrrjiiqRef9999+Gzn/0sHn30UZx33nkzvu62227D7bffPu33Z2ebc6euYxT4wbsOZDtk3HlyVO/hWM5jh234W4cNZ1XGcHUT6w6qYXR0FNdccw2Gh4eRn5+flp9ptbV+aAT40XsOFLpk3H4i17na/m+3De8N2vCRpijOqJzzpYyOosZaB6y33gHg0UM2PN9pw9lVMVzVyGuPGnYPSfj5Ljsqs2RsXM3P1XTjek9eJAZ85Q07ZEi446QIcmeOX9EciGv6h5uiOJPXdFXwXj41Dx2y4cVOG86tiuFyXuPTIiYDX33DjrAs4ZtrIijlQStVzHWtaxYcvP/++3H99dfjT3/6Ey655JJZXzvdDkRdXR36+vpm/cuFw2Fs3rwZ559/PpxOY12xX9jbi8/euw3LK/Pw2BfXafa+Rp6TdHpgaxu+8ej7OHtxKX597dpZX5spc5KsZOfD6/WitLQ0rTcUc13rqYxbS0+914WbHtiONXUFePBzp2r63kacD7V998nd+H+vteIzZzTiaxcumfLnmTgnx5LMnKix1gFrXttvfmA7nnivCxsvWoLrP9Co2fsaeU7SrXVgFB/80ctwOWzY8c0PwmaTpn1dJs1JMvS8tgPWXO+HB0Zx3o9eRpbThne/+UFI0vS/i+lm5DlJpzuf2oPfvnoY15/egI0bls74ukyZj1TwXl4dX7ivGZt39eBbH1qGT51ar/r7GX0+0mXD/76C/b1+/Pa6tThzUemsr82UOUmFmvfymhwr/uMf/4jrr78e999//zEDgwDgdrvhdk89IuZ0OpP6pUj2dVrqHomndtYUZesyNiPOSTotLI//0h8eGE3672n1OUnVseZDjbma71pP9bVq6/VHAADVOq1zwFjzobaGklwAQMdw4Ji/u5kyJ8mabU7UmisrXtu7RuIPRLXFuby2q6ShNA8Om4RQJIaBQPSYzZ4yYU5Soce1HbDmep94L+9yuTR/fyPOSTo1lcWv6a2Ds1/TBavPx1zwXj692hP1LxtKtb3GG3U+0qWxNBf7e/1oHwqa/ndET2rcy6fckMTn86G5uRnNzc0AgJaWFjQ3N6O1tRUAsHHjRlx77bXK6++77z5ce+21uOuuu3Dqqaeiq6sLXV1dGB4entOAzap9KF7QtKaQubNqmNjlLBxl2jfpoyvRubQqn+tcC6Lz+5EBNiQhfXQmru1VvLarxmG3KcXgD/WxKQnpR9zLV7MBkSrYqICMRjQgqmMDorRiozHjSjk4uHXrVqxZswZr1qwBANxyyy1Ys2YNbr31VgBAZ2enEigEgF/96leIRCL44he/iKqqKuV///zP/5ymv4I5dIjgILsdqaIizwN3ossZO5eSXrq98SyiSnYq1oTo/N46wJsL0l40JqM7kTlYfYxsNpqfegYNyAA6E1lE1bzGq6Ixsc5bB0YRi7HmIOlreCwMbyB+IojP7+nVUCqu6bx/N5qUjxWvX78es5Up3LRp06T/fuGFF1J9C0vq4G6jqmw2CY0lOdjTPYJD/X40Jj50iLTU7Y0/OJTlTT1eQeknsoniN3Bh5Ht43IC00zMSQDQmw26TuOZV1liSjS2Ilw4h0kunOB3AzQBVVBd64LBJCEZi6B4JcJ5JVyLZpCTHhWyXJpXYMobIHOSGn/GknDlIc9MhdhsZHFRNg0hR7uMHDemjN5FFVMFjxZrIcTtQkhOv+3SEQQPSmLiuV+S5YZ+hSQalB7OEyQg6huNrnmUE1MESAmQk4khxLbMG066hOJE5yCxhw2FwUAORaAxdiYyiGgYHVdOUyBZk/QLSi8gcZHBQO7WsO0g6UbKIeF1XXW2i3lMbg4OkI1FjlGUE1MO6g2QUbYnMwVrWG0w7kSUciozHSMgYGBzUQPdIENGYDKddQlkujx6phTcUpCdfMAJ/KAoAKOcRQ83UK8FBBg1IW6L+WBXrj6lOWeesKUw66mTmoOqU44a8ppPOxoOD3AxIN4fdpjQVZN1BY2FwUAOi3mBVQRZsPHqkGtGxmJmDpIeexM5XrtuBHDdrk2ilLnHTdmSQ65601THMWsJaqSuOz/GAPwRfMKLzaCgTeQNh5XePmYPq4UY/GYU4VsxmJOpoYN1BQ2JwUAPjzUi406gm0eXsyMAoItGYzqOhTNOTqDfIrEFt1TFzkHTSNczMQa3keZwozI43HOJaJz2ITOHCbCeyXHadR2Nd4/XDuc5JXyJTmJsB6hDP7UzqMRYGBzUg0pJrClmzQE2V+R64HTZEYjLah3j0iLQl6g2W5zM4qKW6IjYqIH0ozQn44KAJNiUhPXWwU7EmROZg68AoZJmNCkg/43WFuQGohvpiZg4aEYODGhCZgzX8cFGVzSaN7zhyF4I01uMVmYNc51oSNxdtg2N8kCBNdfJUgKbERgAzB0kPInOwmpnCqqorzoIkxes49/lCeg+HMlQwElV+/5g5qA6WAzMmBgc1MH6smB8ualNSlPu4C0Ha6hkRnYqZOailqkIPbBIQjMTQmzjaTaS2SDSGPl/8962S3ck1wRICpCdmEWnD7bArwRhmCZNeRNkQj9OmlLSg9FKyhPv93Nw3EAYHNdDO4KBmGktF/QIGB0lb3cwc1IXTblOOebEpCWml3x9CTAZsElCSyw0BLYimJOxYTHroGGIZAa2I7rBtvKaTTpRn94IsSBKbiaqhtigLNgnwh6LMEjYQBgdVJssy2kXNQXY7Ul2j0uWMNxSkLZE5yJqD2hNBA2YZkFZEjdGyPDfsNj44aIHHiklPncMsI6AVpb4o7+VJJ6KMADOF1eN22JXEKdYdNA4GB1XmDUTgD0UBsGaBFhqVLmf8kCFtiZqDFTxiqLl65bghM4pIG6wxqj1lnQ+yUQFpr5MNiDRTN2GtE+mhkw2INMFeAcbD4KDKxIdLUbYTWS67zqOxvobS8S5nkWhM59FQJukZEcECZg5qjRlFpLVu1hjVXHVhvFFBIBxDr4/1RUk7siyP1w9nsEB17ExOeutIbAawJJi6GpQTf0zqMQoGB1UmCpoym0gbVfkeuOw2RGKysstLpDZfMAJfMAIAKOda1xyzDEhrInOwjJmDmnE5bEpghhsBpKXB0TCCkfiGc0UBNwTUptQX5WkA0kmnshnAa7yaxIk/lgMzDgYHVSbqElXyw0UTNpuE2mI+PJC2ehLrPMdlR67bofNoMg8fJEhr7E6uD9GogGudtCSyBktz3XA7eApIbWLDr3N4DGGeAiIdKGUEmDmoqvpiZg4aDYODKhuvUcLgoFZ4HIG0Jo4UM0NYH3yQIK2xxqg+lCxhXt9JQ53KEUOudy2U5brhcdoQk8cDs0Ra6mDmoCbGawlznRsFg4MqE5mDfIDQDoODpLWJnUtJe3yQIK2JmoOsMaotXt9JD7yX15YkSUotYa510po/GIE3EC8VxMxBdYmTPwP+kFKeifTF4KDKRM3BSt5QaIYPD6S1XmYO6kqSJNTyQYI01M3MQV0oJQRYX5Q01ONlGQGtjWcJc8OPtCWaieZ5HCwVpLI8jxNF2U4APBFgFAwOqqxLPEAwLVkzPHZEWhNZBcwi0k9dohZZG48mkMoi0Rj6fexOrofxzuRc56QdUTqknA2INMONftJLx1CijAA7k2uCa91YGBxUmdKQhNkFmuGHDGmNNQf1V5MIDrYzOEgq6/eHEJMBmwSU5DI4qKV61hclHXQzc1BzSvMhZgmTxkTmYBVrjGqCST3GwuCgioKRKAb8IQAMDmpJfMgMjobhDYR1Hg1lAiVzkA8OuqkpjK/7dtYcJJWJZiRleW7YbZLOo8ksZXluuB2sL0raYuag9uoZMCCdiMzBKmYOaoLBQWNhcFBF4gHC5bChMHGentSX63agJMcFgB80pA2x1vngoB9mDpJWxssIcL1rTZIk5UGCpwNIK6LGKDcAtcOAAelFZA6yU7E2eOLPWBgcVFHXhCPFksTsAi3xpoK0NH6smA8OeqlJHP9g5iCpjetdX6K+KOsOkhYi0Rj6/dwA1NrEU0AjPAVEGupMNBNlp2JtKLWEublvCAwOqkh8uFRy50Fz3IUgrfiDEfiCEQBAOcsH6EYcK+7yBhBhLTJSkcgcLGOgQBfMHCQt9flCkGXAbpOUUymkvly3A8XKKSAGDUg77BegrYklBGRZ1nk0xOCgirqH+eGiFwYHSSsiiyjHZUeu26HzaDJXeZ4bTruEaExGd+LfhEgNPSNsTqAn5UGCjQpIA+NlBNywscaoprgRQHpQaozyGq+JqkIP7DYJwUgMvbx/1x2DgypSjhUzc1Bz9SXihoK7jaSu8WYkXOd6stkkpXg06w6SmkSNUXYn10dt4ghSGwMGpIHxZiQMFGhNlBBo40YAaSQQjmJoNH6MvYKnAzThtNtQlYiVcCNAfwwOqkgEB/kAoT0lc7Dfr/NIyOr44GAc1Ym6g+xiSmrqHhnPJCLt8WQAaYkbgPrhWieticw1l8OG/CyeBtIK17pxMDioIh4r1o/4kGkbHEM0xvoFpJ4ePjgYhqg7yKYkpCZmDuqrtjieTTQ4GoY/Ue+VSC09Xm4G6IXNBUlrE8uGsJmodpSmJDzxpzsGB1U0fqyYNxRaq8j3wGW3IRKTlZb0RGoQWQUVfHDQXY1yBIlrntQRjcno8zFbWE/5HifyPPGMDm4EkNrGu5NzM0BrzCYirXWLzT8eKdbUeDkwrnW9MTioElmWmV2gI7tNQm0iUMAPGlITHxyMo7YwUXOQAQNSSb8viJgM2CSgJJfBQb3UFLK+KGlD2QBkcwLNiWyitsExxHgKiDQwfhqI611LzBI2DgYHVTLgDyEUjUGSgHLuPuiCHzSkhW7eSBhGdSJgwJqDpBaRVVCW54adnUt1Izb/2rjWSWXjdYV5L6+1SV1MfexiSurr5nrXhWg+dITNh3TH4KBKOhP1Bkty3HA5OM164HEE0gIfHIxDHCtuHxyDLDPLgNKvR2lGwvWuJ2YOklbEhgA3ALU3sYspN/pJC9zw14d4Zu/yBhCMRHUeTWZj1Eol3aw3qLvx4CAfHkg9PXxwMAzxEDEWjmJwNKzzaMiKlHpEXO+6UjYCmDlIKopEY+j3cwNQT9zoJy2JbsWsOait4hwXsl12yDI3/fTG4KBKlGYkrEOmmzreUJDK/MEIfIlumaw5qD+P046yRJMI3lyQGsTGXxkfHHSldCbnESRSUZ8vBFmO17EuyXHpPZyMxC6mpKXxGqO8xmtJkiRuBBgEg4Mq6R7mh4ve6llzkFQmjhRnu+zIdTt0Hg0B43UH24e47in9xhsQMXNQT8wcJC0omwG5bthYY1QXdcWsRUbaUUoF8RqvOfYKMAYGB1XCzEH9iRuKAX8IIwEeMaT04w6j8Yx3LA7oPBKyIqWTITMHdSVqDvaMBBGKxHQeDVkVNwP0N7GWMJGaAuEohhIlaXisWHtKljDXuq4YHFRJl6hLVMAPF73keZwoThwD4XEEUoN4cBBHWUl/fJAgNTFYYAyluS64HTbIMtA5zLVO6hhvTsB7eb3UJgIGbTwNQCoT9QZdDhvys3gaSGv1iaSe1n6udT0xOKgScayYmYP6Yt1BUlMPMwcNp4bHiklFzBY2BkmS2LGYVDeeKczNAL2Idd45FEA0Jus8GrKynhFxfXdDklhGQGvKsWKWENAVg4MqUY4VM3NQV+PFTf06j4SsSMki4oODYYzXHGTAgNIrGpPR5xOdS7nm9SayhNu41kkl45nCvJfXS0W+Bw6bhEhMVoI3RGro9rIzuZ6UZ/b+UcgyNwL0wuCgCgLhKIbHEjULeEOhq1oeMSQVjR85YqDAKESWQQdrDlKa9fuCiMmATQJKcrnm9cbMQVJbNzMHdWe3SUqiBdc6qWn8NBDXux5ECYGRYESJo5D2GBxUQVfiSHGW0458D2sW6KmGWUSkIh4xNB6RTTTgD2E0FNF5NGQlIqugNNcNOzuX6o7Xd1IbMweNQaz1NgYHSUXdI8wc1FOWy67UcGevAP0wOKiC7glHilmzQF/KsSPeUJAKRLCADw7GUZDlRJ47vinD7EFKp/F6RFzvRsDmQ6Q2cY1n0zF9iYwibgSQmngaSH+sG64/BgdV0MW0ZMOoZWYBqUSWZSVLmMECYxF1BzuHGRyk9BnfDOC13QgYMCA1RaIx9Pu5AWgE3OgnLfQqdcS53vXCta4/BgdVwKOGxiE+ZEYCrF9A6TUSjGAsHAXAruRGU10Y//foYHCQ0khkDpbxwcEQxPW9c3gMMXYxpTTr84Ugy/GadyU5Lr2Hk9G40U9aYOag/moZHNQdg4Mq6BqO7zwwYKC/bJcDxYmbOh49onTqTgSe8j0OZLnsOo+GJlKOG/JBgtKImYPGUpEXr/0YjspKbTiidBGBgrJcN2ysMaqr8WwiHjUk9bDGqP64EaA/BgdVwMxBY2HRclID6w0al3KsmDUHKY16R0TnUq55I3DYbcomLOsTUbqNBwq4GaA3kU3UMTQGWWaWMKVfIBzF0Gj8hBmPFeuHtYT1l3JwcMuWLbj00ktRXV0NSZLwyCOPzPr6zs5OXHPNNViyZAlsNhtuvvnmOQ7VPCY2JCH9KcFB7jhSGnVxnRuWWPM8VkzpxMxB42F9IlKLkjnIQIHuqgqyIElAIBxDvz+k93DIgkS9QZfDhvwsh86jyVw1hawlrLeUg4N+vx+rVq3C3XffndTrg8EgysrK8I1vfAOrVq1KeYBmxIYkxsIjhqQGpTYJHxwMRwkOcs1TGrFbsfHwCBKppYf38obhcthQnugYzYwiUsP49d0NSWIZAb2IZ/bhsTBGAuwVoIeUQ+MbNmzAhg0bkn59Y2Mj/ud//gcA8Nvf/jbVtzMdWZbRw+OGhsLipqSG8QxhPjgYjThW3OUNgn0KKB2iMVnJLBAPqaQ/HkEitbD+mLHUFGah2xtE2+AYjqvM0Xs4ZDHiZAA3/PWV63agMNuJodEw2ofGsKzSqfeQMg5rDqbZgD+EUDQGgB8wRsGag6QG1hY1rop8D+w2CZGYDC9PIFEa9PvigWa7TUJJLoODRsHrO6ll/HQA17sR1BSJ44YsEUTp181MYcMYLwfG67oeDHmoPhgMIhgc7zzn9XoBAOFwGOHwzCmm4s9me43a2gf8AICSHBckOYpwOKrbWABjzIneKvLiuw5tg6OTfocyeU4mSnY+1Jivua71iePR69+xczh+0SrNdhrid0nv+TCaynw32ocCGAxxTiZK5vdErfky87W9bcAHACjNdSEWjSCm76XdEHNiBBV5LgDxmsKck8n0vLYD5l7vwHiwoCTHoftYjDIneqpOBG2O9Ps5H9Pgvfz8dCU2mEpzXLqOxSjzoafqAg92dnjR2u9DOFzMOZmGmvfyhgwO3nnnnbj99tunfP3ZZ59Fdnb2Mb9/8+bNagwrKTsHJQB2eOQgnnzySd3GcTQ950RvoxEAcGDAH8Yjf30SLnv865k8J9M51nyMjqZ/t3a+ax3Q79+xtccOQML+97YifEiXIUyLv9dxnmj832cwKHFOpjHbnKix1gFzX9t3DMSv7e5ogNd2A+keAwAHWvt8ePbZzZAkzsnR9Li2A+Ze7wBwpC9+Ddn77lsY3a/rUBR6z4meBrrin8Hb9h7GZlsLgMyej5nwXn5u3tlvA2DDQEcLnnzyoK5jAfSfDz2FBuP/Fi+98z6K+99Tvp7JczITNe7lJXkePeElScLDDz+MK664IqnXr1+/HqtXr8aPf/zjWV833Q5EXV0d+vr6kJ+fP+P3hcNhbN68Geeffz6cTn3OqD+wtQ3fePR9rF9Siv/7h7W6jGEiI8yJ3mRZxpo7noc/GMXTN30A9YWujJ+TiZL9HfF6vSgtLcXw8PCs6zAVc13rqYxbDdGYjBW3P4doTMZL/3YWKg1wtJhrfbKv/HkHHn23E5fWR/GDfzyPc5KQzO+JGmsdMPe1/Q9vHsFtf92F85eX42fXrNZlDBMZYU6MIBCO4vhv/w0A8Nq/nYE3X34h4+dE0PPaDph7vUeiMRx3+3OQZeC1r52NUp1LCRhhTvT24t5efObebVhakYuHP39yxs/H0XgvPz//uOltvHKgH/951UpcuaZat3EYZT70dM+rh/G9p/Zgw4oK/O/HV3FOpqHmvbwhMwfdbjfc7qkXYqfTmdQvRbKvU0OvL57CWVWYbahfYD3nxAjqirKxu2sE3b4wFpbFCxln+pwc7VjzocZczXetp/radBkcCSAak2GTgKrCHDjsxinfyt/ruNri+G71YFDinExjtjlRa67MfG3v98ev7ZUFWYb6Xcr0322n04mSHBf6/SH0+CPK1zJ5To6mx7UdMPl6Hw1ATtQYrSjIgc1mjO6lmfy73VCaBwDoGAooc5DJ8zET3svPTa8vHtysKjLG87ve86Gn+pJcAECHNzhpDjJ5Tmaixr18ysFBn8+H/fvH8+tbWlrQ3NyM4uJi1NfXY+PGjWhvb8fvfvc75TXNzc3K9/b29qK5uRkulwvHHXfcnAZtZKIVuhEyiWhcTWEWdneNoG1wFGgq1Hs4ZHLdw/GbiNJct6ECgzSupjARHGRDEkqDrmHRnZzXdqOpKcpCvz+EzqGA3kMhixD1Bsty3YYJDGY60Zl8JBiBd4y1xyi9RLdiNhnUX20RG5LoKeXg4NatW3HOOeco/33LLbcAAK677jps2rQJnZ2daG1tnfQ9a9asUf7/t99+G/fddx8aGhpw6NChOQ7buMQDBLsdGUsNP2gojbq8DBQYXXVh/N9mIMgHO5q/LnYuNazqgixsbxtG+3AApXoPhiyhZ0QECrjejSLb5UBxjgsD/hDauRFAaRQIRzGcCDhX5PG+Xm+iW3GfL4hAOAq7zuPJNCkHB9evX4/ZyhRu2rRpytfmUdbQdLrEzgODBoaitEUfYnCQ5q9bCRRwnRuVWPNDwWO8kCgJPYlrOzcEjEds/nUMjTE4SGmhZA7yGm8oNYVZieAg7+UpfXoTmwEuhw35WYasuJZRCrOdyHbZMRqKomNoDHWF3KTREs/DpZm4oeCxYmNh5iClk7LOC3jBMqrqRHBwLCphJMAjSDQ/InOQR46MR6z1DmYTUZr0eHkKyIjEpl/HMNc6pY8oCVaR74Yk8bSJ3iRJUtZ6G5/bNcfgYBoFI1EM+OMFrhgcNJbaonj9Me42UjqI4CCPHxhXjtuBwqx4MV4GDWg+Jh054rXdcBgwoHTr4ka/IU3MEiZKF1FvkKeBjEOpO8i1rjkGB9NIHDtyOWwozGY3HSMRDw9d3gBCkZjOoyGzY/kAcxB1Bxk0oPkQmwEepw35Hh45MppaBgwozdicwJiqlRJBvKZT+nQzU9hweOJPPwwOptHEDxemJRtLaa4LbocNsjy+I0w0V+IhVASdyZiqE8FbBg1oPkSgoDLfw2u7AYmAQa8vBO79UToo9/PcADSU8SxhXtMpfUQDImYOGkdNIU/86YXBwTTiMQTjmli/gEcMaT5kWVaCTdUMDhpaFY8bUhoonYp5bTekomwnspzxfoaDbEBEacBMImMazxLmNZ3SR2kyyPVuGCJzsG1wVOeRZB4GB9Ooa5gFy42shvULKA2Gx8IYDUUBAFXMKjC0GnGsmA8SNA893PgzNEmSlBICAyFmdtL8BMJRDI7Ga4xyzRuL2JDt84UQZpYwpYnoVsw64sYhEnp4rFh7DA6mkUhLZnDQmJg5SOkggsuluS54EtkqZEzKsWJmDtI8jG/8MavAqGoSTceYOUjzJQIFLocNBVmsH24kzBImNTBz0HjqisZ7BYSj3AnQEoODadQ5zOwCI1M6H7FWCc2DCC7zSLHxVReyUQHNX5eXpwKMTmQJDwaZOUjzM7FEEGuMGoskScopIK51Shc2IDKe0lw3XHYbYvL4vw9pg8HBNFKaFBQxaGBE7HxE6aDUGyzgOjc6kTnYMxLkziPNWY9oSMIyAoYlTgYwm4jmi/UGjU2s9QGudUqDQDiK4bF4GQEGB43DZhsvF8JyYNpicDCN2KTA2MY7H/GIIc1dOzcBTKMkxwW7JCMmjx8NJUoVMweNr5oBA0oT1g83tupCZg5S+ojNAI/ThnyPQ+fR0ETsFaAPBgfTJByNKR8wItJNxlI7oX5BTNZ5MGRa7dwEMA2bTUJRIvmDR4tpLmRZVq7tLBliXErmIBuS0DyxfrixiXv5wZDOAyFL6BpmGQGjUpqSMKlHUwwOpkl3IuDksttQmsOjCEZUke+BwyYhHJXh5U0FzZFSPoCbAKZQ5IrvBHDnkeZieCyMYCR+JL0sj9d2o6qecKw4xt0/mocu1g83NB4rpnTqTmwGlHO9G4448cdGotpicDBNxC9uVaEHNht3HozIbpOUB4h+3lTQHLF8gLkwc5DmQzQaK8p2sju5gVUWeGCTgKgsod/P3T+aO3YuNTY2JKF06uZmgGGJtc77d20xOJgmbFJgDuI4wgBvKmgOQpGYcuSIwUFzKE483/FYAs0FG42Zg9NuU46BMkuY5oNlBIxN3HsNhYAos4RpntiAyLh4rFgfDA6mCeuQmcN4cFDngZApdQ6PQZYBt8OGkhyX3sOhJBS5eayY5m68jACv7UYnupN3svkQzVG8xihrDhpZRZ4bdpuEqCyh18ebeZofNhwzLvHM3jE8xl4BGmJwME1Yh8wcRP0CZg7SXLQOjAIA6ouzWbjYJHismOajjRt/piGawTHLgObKG4hgLBwFwGCBUTnsNlQmsrxYi4zmq4ebAYYlyoWEozJGwnqPJnMwOJgmrENmDswcpPmYGBwkcxANSTqGxiDL3Hqk1IiHT2YOGp8o68KNAJqrnkQWUb7HgSwXa4waVVUBSwhQeojMwcoCBgeNZmK5kEE+t2uGwcE0EQ8QDA4amxIcDDDri1IngoN1DA6ahsgcHA1FMTTKrUdKDTf+zENkDnbwWDHNEQMF5iA2a5g5SPMRLyOQOFacxzVvROPdyfncrhUGB9OEDxDmUJsI6gyGgBgLGFCKWvvjwcGGEgYHzcJpA0pz4/UhmWVAqeK13Tx4rJjmi/UGzWF8I4DXdJq74bEwgpEYAHYnN6rx7uQ6DySDMDiYBsOjYYwEIwB49MjoKvLccCQKGfewkDGliMeKzUl8LrcNjuo8EjKTcDSmZBVUs56w4dUkjhV3MmBAc9TN5gSmwC6mlA5iM6Aw2wmPk2UEjIiZg9pjcDANRMCgLM/NGiUG57DblOMi7YN8gKDkybKsZA4yOGgudYmdR/FZTZSMbm8AMRlw2W0ozWFWgdFVJQK4w2MR+BIbtkSpEIHlKh4rNjSlMzmDgzQPShkBbgYYVg17BWiOwcE0YDaRudQmHiDaeFNBKRgeG88Qri3iWjeTumIGByl1op5VVaEHNht3rY0u1+1Atn28ARFRqsSmMU8BGZso89A+zEZjNHciU7icwUHDEp/Fg8wc1AyDg2nA4KC5iF0IZg5SKsQ6L2eGsOnUJYK5rQNc85Q8pd5gAQMFZiEaEPH6TnPB5oLmIDIH/cEovGPMEqa56R4WmYM8GWBUSiPRELgRoBEGB9PgSKKOlTi6RsYm6hKxOQGl4jCPFJtWfSJz8AgzBykF7WxGYjpF7vjDA6/vNBdsQGQOWS47ch1c6zQ/3SOsMWp04rM4GJUwEuBGgBYYHEwD8cBZx6CBKdQUiWPFvKGg5DFD2LzExk3b4Cii7FJOSRq/tjNQYBZK5iCv75Qib2C8dAgbEBkf1zrNF7uTG1+2y4GibCcANiDSCoODacCggbkoXc4G+SFDyTvY6wcANJXm6DwSSlVFvgdOu4RwVFYKUBMdC6/t5lMsMgd5rJhSJLIGi7KdyHY5dB4NHYuSJTzIEwE0N+xObg7iuZ21hLXB4OA8RWOychNaX8IHCDMQ9Qs6hscQYxYRJelgnw8AsKAsV+eRUKrsNklpIiM6ThMdC4OD5iOyifgQQanikWJzKWbmIM1T1zC7FZuByORuH+bmvhYYHJynzuExRGIyXHYbKvL44WIGFXlu2CAjHJXRM8Le6JSclj5mDpqZKPvAuoOUjHA0pgQLGBw0j2JXfMPvCLOJKEXtbEZiKiJzsINHDWkOQpEYen3xZ8AqlhEwNGYOaovBwXkSmQW1RVmw2dhm2wwcdhsKEzuObXyAoCQM+EMYGg0DYHDQrERTklYGBykJ7YNjiMmAx2lDWR47GZpFSeIZr9sbRCAc1XcwZCriFFANg4OmUOSK/1/WD6e56PYGIMuAy2FDSY5L7+HQLJTMQW4EaILBwXkSR9RqmVlgKsXsaEgpaEkcKa4u8CDLZdd5NDQXIvuLwUFKxsQjxZLEjT+zyHEAOe74Z3Qb6w5SCkRWCoOD5sD6ojQf7RPWO6/xxlZTwMxBLTE4OE8t/fGjhguYTWQqxUrmID9o6NgOJJqRsN6geYngII8bUjJYb9CcJAmoE/VFB/w6j4bMhDUHzUXcx/f5mCVMqRtf7zxSbHTMHNQWg4PzxA6m5iR2HFl/jJLBeoPmx5qDlArxe1LH4KDp1CWajrH5EKVCZBKx/pg5ZDuALGf8MbaTjQooRUpwsICbAUYnsrn7/SFuBGiAwcF5YtDAnERdIh4xpGQc7BWdirnOzUoEefp8IfiDEZ1HQ0bHzEHzGq8vypMBlJxgJIoubzzAxDVvDpI0nuXJo8WUKjYgMo+CLAfcNpYD0wqDg/MQjck43M/goBmVJjIHDzOzgJLADGHzy/c4UZTtBMCjxXRsDA6aVx3ri1KK2gfHIMtAtsvO5gQmUqMcN+Rap9Swxqh5SJKEokQZAW4EqI/BwXloHxxDOCrD5bBx58FkShOZgx3DYwhGmKJMMwtFYkqG8OKKPJ1HQ/MhAj2H+vggQTOTZRmHEmu+oYTBQbOpTxwrZgkBShYbEJmTCOywfjilijVGzYWNRLXD4OA8HEx0MG0qyYHdxpsJM8lzxneIZZk3FTS7Q/1+RGIyct0OVBewFpGZNZTEMz8P9bNRAc2sZyQIfygKu01CfTGzhc2mTjlWPApZlnUeDZkBM4XNaeJaJ0qWLMtsSGIyzBzUDoOD88B6g+YlSePZBYcZKKBZ7O0eAQAsKs9lRoHJic9qkRVGNJ0DiRqjdUVZcDl4m2Q21QVZkCRgLBxFry+o93DIBETzGgYHzWW8MzmDg5Q871gE/lD81BgzB82hiJmDmuFd7zwowUE2KTCl+sRxMdYdpNns7Y4HCpZU5Oo8EpovERxsYXCQZiF+PxaUcc2bkcthUzpQ8mgxJUPJHGQZAVNhZ3KaCxFgKs11weO06zwaSkYxMwc1w+DgPChNCkoYHDQjsUPM4CDNZl8ic3AJ6w2aXmMpjxXTsbEBkfnxuCGlQvye1DFz0FREZ/J+fwi+YETn0ZBZtCWa0jFr0DxYc1A7DA7Og3LckBlFptSgBAcZKKCZ7WVw0DLERk63Nwg/HyRoBgcTx4oX8FSAaYnNv9Z+PkjQ7GRZVjJMeazYXPI8ThRlOwEwS5iSx80A8ylKNJHv8gYQicb0HYzFMTg4R0OjIfSMxGvZLC5ncNCMxI7jYd5Q0AyCkSgOJTJLGRw0v4JsJ4pz4ncYzB6kmSjHikt5bTcr0XyImYN0LAP+EPyhKCRpvPstmYeyEcC1TkniZoD55LsAp11CNCajczig93AsjcHBORJ1yGoKs5Dnceo8GpoLcVE4MjCKaIwdDWmqlj4/ojEZeR4HKvLdeg+H0qAxUVPqUB8fJGiqUCSGI4maNswcNK86JWDATQCandggrsz3sP6YCSlrnSWCKEnsTm4+NmlCjVFuBKiKwcE5EkcNF/NIsWlVFXjgtEsIR2V0DvPoEU21q9MLAFhemc9OxRbRqDQl8ek8EjKi1oH4hkCOy47yPG4ImBVrClOyRPf6BjYjMSXx78aAASWLwUFzqmOWsCYYHJwjERxcyqOGpmW3Sagr4o4jzez9jnhw8LjqfJ1HQumyQAkOcs3TVPt74kHjheW53BAwMZEh3DPC+qI0O9GAiN3JzYnHiikVsZisnA5gcNBc6pk5qAkGB+doPHOQwUEzqxdHDBkcpGm8n8gcPK6KwUGrYMdimo0oGbK4nNd2MyvMdimNCrjWaTYHE1nkC9id3JTqJpQIIjqW7pEAQpEYHDYJVQUevYdDKWAJAW2kHBzcsmULLr30UlRXV0OSJDzyyCPH/J4XXngBa9euhdvtxqJFi7Bp06Y5DNVYxAMEMwfNrTFRtPww6xLRUWRZVjIHlzM4aBlizYumE0QT7RGnAiqZRWR2TaVc63Rs45mDDA6akVI/fJD1w+nYRGCppigLDjtzpMyEmYPaSHlV+P1+rFq1CnfffXdSr29pacEll1yCc845B83Nzbj55pvxmc98Bs8880zKgzWKPl8QA/4QJAlYxE7FpqbUJeIRQzpKlzeAwdEw7DaJtUUtRAQMBvwhDI+FdR4NGc0+ngqwDCVLmMFBmkEsJiuZpexObk5VBVlK/fAuL7uY0uxYb9C86ooZHNSCI9Vv2LBhAzZs2JD063/xi1+gqakJd911FwBg+fLlePnll/GjH/0IF154Yapvbwh7u+IPD/XF2chysbOZmTGzgGYisgYXleWyg6GF5LgdKM9zo2ckiEN9fqyqK9R7SGQQoUhMySJawuCg6Yljogd5facZdAyPIRCOwWmXUJvISiFzsdsk1BZlo6XPj9b+UdQU8t+RZiaOn9cxOGg64jN6eCyM4dEwChKlQyi9Ug4Opuq1117DeeedN+lrF154IW6++eYZvycYDCIYDCr/7fXGH9LD4TDC4ZkzPcSfzfaadNjVOQwAWFyWo/p7zZdWc2ImE+ekrijejbKl349gMASbLfMK0Cf7O6LG79Bc1/rE8aj1u739yCAAYFllrinWD9f6VDPNSUNJNnpGgtjX7cVxlZl1lCyZ3xO1foeMfm3f3+1DJCYjx21HWbbd0GuJ632qo+ekviheT+pgry8j50nPaztg/PUOAPu64mOqK8qGHIsiHIuq/p5zwfU+2dHzUVvoQUufHy29IzipPjPLwPBePjktiRqjNQVuQ64nrvWpxFw4JRlluS70+kI42OPFyprMXOuAuvfyqgcHu7q6UFFRMelrFRUV8Hq9GBsbQ1bW1B2eO++8E7fffvuUrz/77LPIzj52pH/z5s1zH3AS/nbABsAGaaQbTz75pKrvlS5qz4kZbd68GTEZsEt2hCIx/OGRp1CSwbVpj/U7Mjqa/jTu+a51QL3f7ed3J9b5UBuefPKIKu+hBq71qY6eE8do/N/2udffhbN9mz6D0tlsvydqrHXA+Nf2bX0SADvKnBE89dRTqr5XunC9TyXmpM0PAA7s6xwyzb2aGvS4tgPGX+8AsKUzvuZzoiOm+B3hep9MzEdsJH5Nf/6tHcjpflffQemM9/Kzaz5gByCh/9BuPDmyS5P3nAuu9ak2b96MXMmOXkh49PlX0FrCGqNq3MurHhyci40bN+KWW25R/tvr9aKurg4XXHAB8vNnjhKHw2Fs3rwZ559/PpxO9VJN/9//vQlgCBtOX4WLT6hS7X3SQas5MZOj5+SnB17BgV4/Go8/BWcuLtV7eJpL9ndE7ASm01zXOqD+7/b33nsRQBAfPe80nNxYlPafn25c61PNNCdtL7XgtWf3wVlcjYsvPkHHEWovmd8TNdY6YPxr+96/7Qf2HcTJS2tx8cUrVHufdOB6n+roOfEHI/iv7c/DH5Gwbv15KMp26T1ETel5bQeMv94BYOvju4BDR3DqigW4+MIlqr7XfHC9T3b0fHS/ehivPLUHjsIqXHzxKr2Hpwveyx+bLMv493eeBxDFhy88E4sN2DeAa32qiXPy/OhutLzbidKGZbj4rCa9h6YbNe/lVQ8OVlZWoru7e9LXuru7kZ+fP23WIAC43W643e4pX3c6nUktlGRfNxfRmIzdiZqDK2uLTLNw1ZwTsxJzsrAsFwd6/WgdDGT0HB3rd0SNuZnvWk/1tcnqGg6geyQImwSsbiiG02nIfZRpca1PdfScLCyP36weHhjL2Lma7fdErTkx8rUdAPb2xGvTLasqMM3vBdf7VGJOCp1OVOZ70OUNoG04hPKCzCohIOhxbQeMv94B4ECiGd2SinxTrCOu98nEfCyuiF/TD/WPZvz88F5+Zj3eAPzBKGwSsLAiH06HceuJc61P5XQ60ZhoHNU+nNnP7IIa9/Kq9/Bet24d/va3v0362ubNm7Fu3Tq131oVLX1+jIai8DhtWFhmvB0HSt2CxL8ji5aT0HxkCEC8KUG2yzyBQUrOgrLxRkSyzGMJFCeaEK2oztw6NlbTxI7FNIu9ie7kSyvZgMjMlHXe70csxms6Te9AouFYXXE23AYODNLMRJdpdixWT8rBQZ/Ph+bmZjQ3NwMAWlpa0NzcjNbWVgDx1OJrr71Wef2NN96IgwcP4qtf/Sp2796Nn/3sZ3jwwQfxL//yL+n5G2jsvfZ4M5LjqvJhz8DmFVYkAgWiSyXR9rYhAMBqdrK1pPribEgSMBKIoM8X0ns4ZABDoyG0D40BAJZXMThoFY2l4xsBRBP1+4LK5/8iAx4vpOTVFmXBYZMQCMfQ5Q3oPRwyqIOJZiQimEzmU18SDw4e7mdwUC0pBwe3bt2KNWvWYM2aNQCAW265BWvWrMGtt94KAOjs7FQChQDQ1NSEJ554Aps3b8aqVatw11134de//jUuvPDCNP0VtCWCg8fXFOg8EkqXBaUiOOjTeSRkFO8mgoMn1BbqOg5Sh8dpR11R/AZjfw/XPY1nDdYVZ6Egi0dVrEK5vjM4SEfZ2x3/7K8rzkKOmycEzMxhtylBA24E0ExEEsiCUm4GmFVDInOwY2gM4WhM59FYU8pXw/Xr1896DGvTpk3Tfs+2bdboCLkjERxcweCgZYhjxR3DAYyFoshyMdU8k0VjMrYfia/zE2q5zq1qUXkuWgdGsb/Xh3ULS/QeDuns/c7EkeIqrnkr4bFimolypLiCR4qtYEFpDg72+nGwz48PLMq85oJ0bCJwLE6MkfmU5bnhcdoQCMfQNjjGLFAVqF5z0EpiMVnJLmDmoHUU57hQmB3PFOGOI+3pGsFIMIIclx3LWIfIskSXugPMHCQAOxPX9uNYb9BSJh4rZn1RmkgEB5cwOGgJjSWJtc4SQTQDcUKMwUHzkiRpfK338f5dDQwOpuDwwChGghG4HDbWJ7GYJuXoET9oMt3WwwMAgLUNRXDY+RFpVQsTn+E8VkwAm5FYVX1xNmwSMBqKomckqPdwyEAYHLSWpjIGDGhmoUgMRwbjdYV5rNjc2CtAXXzyTYGoN7i8Kh9OBg0sRVwouONIb7bEg4MnNxbrPBJSk9jg2dczovNISG9joSj2JzIKVlTzVICVuBw21BWzFhlNJsuyUnOQwUFrGO9YzEYFNNXBPh+iMRl5Hgcq8t16D4fmQXlm5zVdFYxwpUAEB1cys8BylF0IftBkNFmW8dYhBgczgQgOdnuD8AbCOo+G9PRexzCiMRnleW4+NFjQ+BEkXt8prmM4gOGxMBw2iUcMLUIEDFoHRtmogKbY0zWeKSxJks6jofloKuU1XU0MDqbgvQ52KrYqdiwmAGgbHEO3NwinXcLqukK9h0Mqyvc4lUAQ6w5mtubWIQDA6rpCPjRYEJuS0NF2Jjb7F5XnwuNkEzorqMh3I8tpRzQm48gAswdpMpYRsI7xEgK8pquBwcEkxWIytrclMgcZHLQc0bH4IIuWZ7TXD/YDiK9xdq22vkWsO0gAmo8MAQBW1xfqOg5Sh8gMO8DNP0rYqdQY5f28VUiSxIwimtGervjn/9IK1hs0O5HQ0zkcwGgoovNorIfBwSTt7/VhJBBBlpMdTK2ooSQbkgSMBCLo84X0Hg7p5OX9fQCADyws1XkkpIVFiU2B/QwaZDQlOFhbqOs4SB3KOucmACXsTJwEYgMia2FGEc1EyRzkM7zpFWa7UJTtBMC1rgYGB5P09uFBAPFjR+xgaj0epx01hVkAeLQ4U8ViMl5JBAfPWMzgYCZQMge7ueYzVe9IEO1DY5Ak4PhaZhFZ0aKK8VpkgXBU59GQEexkd3JLUkoEMWBAE4yGImhNHDVfymPFlsAsYfUwypUkERw8saFI55GQWiYeLabMs7trBH2+ELJddqyt5zrPBIvK4zeJzBzMXCJrcHF5LvI8Tn0HQ6ooy3Uj3+NATOaDBAED/hA6hwMAgOMYHLQUJWDQy3VO4/YlNoBLc10oyWXTMSsQz+xc6+nH4GCS3mFw0PIWJo4j8OhRZnp5fy8A4NSmYrgc/GjMBCJz8AgzijLW1kR3cm4IWJckSVicyBbZx+t7xhNHihtLsrkhYDHMJqLp7EkcKV5czqxBq+BaVw+fgJMw4A8p2WRrWLDcskQHK1GXgjLLlr3iSHGZziMhrZTmulCY7URM5qZApnqjJR4cPKWpWOeRkJoWs/kQJYjmgivYXNByRMCgyxuAP8hGBRT3fqKMADOFrYMlBNTD4GASRGbBovJcFGa7dB4NqWVJoi7RPtYfyzjDY2GlU/G5y8p1Hg1pRZIkpcHU7i5uCmQafzCC99rjgQIGB61tvDM513mm29Y6BABYU1eo6zgo/QqzXSjOiT+nMaOIBDYgsh7RfOhgrw+yLOs8GmthcDAJrx6IBw1OW8CHBysT9ce6vAEMj4V1Hg1p6cW9vYjEZCwsy1F2nikzLK+K3yzu7vTqPBLS2rbWIURiMmoKs1BblK33cEhFIjjIzb/MJsuyUmeUJ4GsiRlFNFEsJiuZgyuZLWwZjSXxde4NRDDgD+k8GmthcDAJIqNo3QJ2MLWygiwnKvM9AJhdkGk2v98NAP+/vfsOj6rM/gD+vVPTeyONhBASAiSEACGAYImiKCt2wYLooqhs0V1ddVHcquvuspb1B4oiroogiCKKKIIgJQQICZ1QUiGk9zb1/v6YzEgcwJSZ3Cnfz/P4h8kkc/KSk7lz7vueg2tTIiSOhAba8AhTcfB4JYuD7mZvsem1nbsGXZ+5OFhS1wadwShxNCSVsw0dqG3VQCETMCKShQJXlNh1Cug0WwQRTH/z27QGeChllsIxOT8PpRxRAZ4AuEvY1lgc/Bl1rRrLcTPuHHR95ouKk9xd4Da0eiO2FVYDAK5NCZc4GhpoyYNMO4aPn2/h0QQ3s6eI/QbdRaS/J7xUcugMIkrr2qUOhyRi3jU4fJAfPJRyaYMhuzCfAuLwIQKAI127BpMj/KCQs+zhSoaEcpewPTBLfob5zUNyhC/Hn7sBDiVxP9tP1qClU48wXzV7ELmhYeG+kAmmwVM1rRqpw6EB0tKpw4GyBgDA5KE8FeDqZDIBCaEcSuLueKTY9VlaCDDPCT/2GxwZxX6DroYTi+2DxcGfseuMaYLphCHBEkdCA4FDSdzP5wXnAAAz0iIhkwkSR0MDzUMpt1xgHD/PmwLuYveZOuiNIuJDvBETxH6D7iCRQ0ncXl6p6YbAaN4IdFnmPC+pbYNWzxYC7u7oOdPOQbYRcD2W4mANi4O2xOLgZYiiiO2FNQCAKcO4s8AdJIabjyPwzYM7aOnU4buufoO3pEdJHA1JJZlDSdzOjlOm1/YrEvna7i6GhnNHkTtr0+hxuGs6+bg4thJwVYP8PeCtkkNvFFFax6KBOzMaRRw82wgAGMVhJC4n3jJ8iK/ptsTi4GWcrGrFucYOqBUyDiNxE+Y7jlXNGk4sdgObjlRCozciIdQbIyJ55MBdDY8w3RQw95cl1/fDSdOpgCmJoRJHQgNlWFcvskLmuVvKK22AoWs6OXcLuy5BEDA0nH0HCThT04qWTj08lXIkd13nkeswtwoprm2DnoPGbIbFwcv4vmtIQVZCMDxVbFzsDnw9lIj0N00sPsW+gy5vfUEFAGDm6CgIAo8Uu6tk88Ri7hx0C2dqWlFW3w6FTMCEBLYMcRfm4UNnalp53NAN5XZNJ8/kACKXZ77RzxZB7i2/rBEAkBrtz2EkLigq4MdBYyUcNGYzzJTL2HrCVBy8OjlM4khoICVahpLwosKVVTZ1YndXT9GbR/NIsTsb3rVr9HQ1iwbu4NujplYCWQnB8FErJI6GBkpUgCd8PRTQGUScqeHru7vJ7RowmDmExUFXZykOskWQW8svN/UYTY8NlDgSsgeZTLAMIGIvYdthcfASGtq0lsbFVyWxOOhOkixHDLmLyJWt2lcGowiMjwtCbDCPGLmzSH8P+HoooDeKfDPhBr45WgkAmDYiQuJIaCAJgoDh3CXsljq0Bkvvscx47hZ2dYnhnExOP+4cHMPp5C5rKHcJ2xyLg5fw7bFKGIwiUgb5sTeJm0npGk5wrIJvHlyV3mDEqr3lAIB7JsRKHA1JTRAEjOyaZHekq2E9uabKpk4UlDdCEIDrUsKlDocG2PBB7C/qjvaW1ENnEDHI3wODeTPQ5SV29RctqmEvMnfV0qlDYVd7qNEsDrqsYewvanMsDl7CxsOmnQU3pg6SOBIaaCmRP+4sMBpFiaMhe/jueDUqmzsR7K3C9SO5e4iAUdGm4uBhFgdd2rfHTK/t6TEBCPPzkDgaGmjmyeTcOehetheappNPHRbK/sJuICrAEx5KGbQGI8rq2YvMHeWVNkAUgZggT4T58rXeVZlbCJzknACbYXHwIhrbtdh12tSL7AYWDtzOkBBvqBUytGkNKOVFhUv6KLcUAHDH2BioFRw2RMCoqK7i4FkWB13ZZ/nnAADTR/HGnzsabikO8o2EO9l20tRDfOowTid3Bxf2ImP/cPe0p6vH6AS2EXBpll3CnFhsMywOXsQ3RyuhN4pIjvDFkK4x2eQ+FHKZZXfB0QoWClxNSW0bdpyqhSAAs8fzSDGZpHbtHDxe2cKhJC6qqKYV+WWNkMsE/GJ0pNThkASSwn0hCEBtqwY1LRqpw6EBUF7fjqKaNshlAiYODZE6HBog5uOG7B/unvYUmaaTTxjC4qAriw7s2iWsN6K8oUPqcFwCi4MXsTbvLADwzYMbS7EUB3lR4Wo+3lsGAJiSGMpBJGQRG+QFPw8FtHojjye4qHUHTLsGpySG8JiRm/JUyREf7A2ARQN3se2k6UjxmNgA+HsqJY6GBkoKWwi4rVaN3tIihtPJXduFu4RP8drdJlgc/ImS2jbsK2mATABuTY+WOhySyIhIDiVxRR1aA1bv7xpEksldg/QjQRAsfQc5lMT1GI2i5UjxrWP42u7OhrNo4Fa+7ZpOfmVSmMSR0EBiCwH3tb+kHgajiJggT0QHchOAqzMfLeZQEttgcfAnPj1g2jV4RWIoIvy5s8BdmYeScOega1l74Cwa23WICfLENcM5qZS6G9nVd/AQi4MuJ7e4HucaO+DrocC1nFLs1pIjuo4bsmjg8pradcg5YzpeyB7i7sVcHCyrb0erRi9xNDSQzDmfyX6DboE7B22LxcELGI0iPu06Unx7BncWuLPhEX6QdfUlqm7ulDocsgGjUcTyncUAgAcnxUMu48RC6i41KgAAh5K4otX7TO0Ebhw1CB5KDiFyZ7z55z6+O14FvVFEUjh7iLubIG8Vwv3UAIBCthBwK9u6ppNP4QAit2DuL8qdg7bB4uAFdp+pQ0VTJ3cWEDxVcsuF5FEePXIJ3x2vQnFtG/w8FLhzbIzU4ZADMk8sPlHZDI3eIHE0ZCu1rRpsPGw6WjiLQ4jcnnmH8KnqFnRomeeu7Osjpry/nrsG3ZJ59+Ax7hJ2GxWNHSisaoFMMPUXJtc3LNz0fv10dSsnFtsAi4MX+Ci3FABw8+hI7iwgSzNj9h10De907RqcnTkY3mqFxNGQI4oJ8oS/pxI6g4jCSr6ZcBWf7C+H1mBEWrQ/0mICpA6HJBbu54EwXzWMInDsPHcJu6r6Ni22n6wGAEwfNUjiaEgKyRHsL+puzLsG02MDEeClkjgaGggxgV7wVsmh0RtRUtcmdThOj8XBLuebOvDtsSoAwH0T4qQNhhzCyCjTRcWhs43SBkL9duhsI/YW10MhE/DAxDipwyEHJQiCpXiUX9YoaSxkGwajiI/2mI4U3zthsMTRkKNI7Ro+dIgtBFzWFwXnoDOIGBnlh6SuPpPkXoYPMv27szjoPrYVmm4IXJXEI8XuQiYTLH/juUu4/1gc7PJxbhkMRhHj44N4EUEAgLToAADAwXK+eXB2b20vAgD8Ii2Sg4bossbEBgAADpQ1SBsI2cT3J6pxrrEDAV5KzEiLlDocchCj2F/U5a0x9xDndHK3ZT4BVFjZAqNRlDgasrdOnQE7T9cC4HRyd5M8iLuEbYXFQQBavREr95YDAO7P4s4CMhkV7Q+ZAFQ2d6KyiUNJnNWpqhZsPHIeAPDw1CESR0OOLmNwIAAWB13Fe7tN7QTuHBvDdiFkYdk5yMnkLulYRTOOVjRDJZfh5tFRUodDEokP8YZKIUO71oCy+napwyE721ZYjXatAdGBnhjRNXiK3MNwFgdthsVBAF8fOY/aVg3CfNWYNoJNi8nES6WwTEAqKG+UNhjqs/9+fxqiCFw/IsLSf4boUkbHBEAQgPL6DlS38KaAMzta0YRdp+sglwm88UfdmIeSnKlpRatGL3E0ZGtr8kw3/LNTwhDozb5j7kohlyEp3HzckEUDV/dV1+Cx6aMGQRAEiaOhgZTCFgI24/bFQVEU8c4O86CCWCjlbr8kdIHRXf3HDrLvoFM6U9OKDQcrAAC/umaoxNGQM/D1UFreTBwobZQ2GOoX82v79FGDEB3oJXE05EhCfdUY5O8BUQSOcvegS+nUGfB5/jkAwB0ZMRJHQ1Iz7yA7wjx3aZ06A7YcN80OuIHTyd1OUtfmj6pmDerbtBJH49zcvhKWU1SHw+eaoFbIcB+bldNPmIuDBRxO4JTe3HoaRhHIHh6GEZH+UodDTiI91nS0OJ9Hi53W+aYOy42BeVfESxwNOaJRXbsHD7No4FK+OFiBhnYdogI8cUViiNThkMRGRTPP3cHWE6YjxZH+Hpb3buQ+fNQKDA423QTm7sH+cfvi4Ns/mAYV3DE2GsE+aomjIUdjnlx6+FwTDGxm7FRKatvweYFp98Cvrk6UOBpyJuahJHmlLA46qxW7SqA3isiMD0Jq13ApogtxYrHrEUUR7+8uAWCaTq7gaSC3l9o1fOjQ2SaIIq/jXdXargFEM9OjeKTYTQ2PYN9BW3DrV83CyhZsK6yBIAC/nMxBBWQtMcwHnko5WjV6FNW0Sh0O9cLizSdhFIErk0ItRV6injAPJTl0rglavVHiaKi3Wjp1WJlbBgB4eApf2+niRnUVjdk2xHXklTbgaEUz1AoZ7h7HI8UEJEX4QiWXoalDh/L6DqnDITuobu7E9pM1AIDbMzid3F2Zh5Kwv2j/uHVx0Lxr8PoREYgL8ZY4GnJECrnMciQhn0NJnMaRc034outI4e+vS5I4GnI28SHeCPRSQqs34mgFdxU5m49yy9Ci0WNIqDeuSgqTOhxyUKO7ioOlde2obdVIGwzZxIquXYM3j47kIBICAKgUMgzvGlZw6FyjtMGQXXyWfw4Go4iMwYEYEuojdTgkkeGWoSQtEkfi3Ny2OHi+qQNfHDQdOeTOArocS99BFgedxj82nQBgeoNgnkpJ1FOCIFh2D+YW10scDfVGu1aPZV03/h67cihkMh4voovz91IiMcz0RvIAWwg4vXONHfj6iGla6ZyJcdIGQw7F0neQLQRcjsEo4qOukwJ3cNegWzPvHDxd3QKN3iBxNM7LbYuDS7edgc4gYnx8kKX5PNHFmPuP8c2Dc/jhZA12nKqFUi7gd9dy1yD1TVaCqZF9zpk6iSOh3vhoTxnq2rSIDfLCzNGRUodDDs58EyCPw4ec3rs7imEwipiYEMwBZNTNhX0HybVsK6xGWX07/D2V+AVf891adKAnAr2U0BlEFFZy92BfuWVx8HxTBz7eWw4A+G02BxXQ5WUMDgIAFFa1oKldJ3E0dDkavQEvbjgKwNSMPLZrchVRb2UNCQYA7Cuph87AvoPOoENrwFs/nAEALLhqKIcR0M8yFwd588+5NbZrsWqfaffQI1MTJI6GHI155+CRc00wcrigSzG3Erh7XAy8VAppgyFJCYJwQS9h3gjoqz5dOb/55puIi4uDh4cHMjMzsXfv3ks+VqfT4c9//jMSEhLg4eGBtLQ0bNq0qc8B28KSbWegNRgxPj7I8gaQ6FJCfdWIC/aCKAIHuLvAob2zoxhFNW0I8VHjt9nDpA6HnFhyhC8CvZRo1xpwiAMLnMJHuaWobdUiJsgTt4yJkjoccgLm4uDBsxw+5Mw+3FOKdq0Bwwf5YUpiiNThkINJDPOBWiFDi0aPkro2qcMhGzlV1YIdp2ohE0wbAohSo8wtBBqlDcSJ9bo4uHr1ajz55JNYtGgRDhw4gLS0NEybNg3V1dUXffzChQvx1ltv4Y033sCxY8cwf/583HLLLcjPz+938H1R0diBVRfsGuS4c+qJsXGm3YP7S9l/zFGV17fjja2nAAALbxwOf0+lxBGRM5PJBEzounm0+zSPFjs6065BU6/Bx68cCiV3DVIPcPiQ8+vUGfDerhIAwPypQ3hdT1YUchlGRJr6kfFosesw7xq8NiUcMUE8KURAatcuYeZ53/X66nnx4sWYN28e5s6di5SUFCxduhReXl5Yvnz5RR//wQcf4LnnnsP06dMxZMgQPProo5g+fTr+/e9/9zv4vjDvGsyMD8LEBN5dpJ4ZF2faXbCvhDsHHZHBKOL3aw6iU2fEhCFBuJl9R8gGJiaYioM7TtVKHAn9nOW7ilHTokF0oCduHcOm5NQzFw4fyuPRYqe0Nu8s6tq0iArwxPRRg6QOhxxUWtdwwXyeAHIJTe06rDtgGiz6wMR4iaMhR5Hadaz4VHUrOrQcStIXvSoOarVa5OXlITs7+8dvIJMhOzsbOTk5F/0ajUYDDw+Pbh/z9PTEzp07+xBu/5TVtVt6kvDIIfWGue/gwfJGHj1yQEu3n0FucT28VHK8fGsqdw6QTVyZFAbANKyA/UYdV32bFku3mXoN/v66JKgU3DVIPTfG3HeQRQOno9UbsXS7KfcfmhzPHcN0SWMHm08AMc9dwcf7ytChMyAp3BcThgRJHQ45iHA/NUJ91TAYRRw7z92DfdGrzp21tbUwGAwIDw/v9vHw8HCcOHHiol8zbdo0LF68GFOmTEFCQgK2bNmCdevWwWC4dDVXo9FAo9FY/r+5uRmAqX+hTnfpN2jmz13qMS9tPAadQcSkhGCMjfW77PdyFT+3Ju6oL2sSG6BCoJcSDe06FJTVIb3rDqQr6Ol62ON3qK+5fmE8+4tr8Z/NJwEAL9yYjCh/lVv+vjPXrfV3TSJ8lRga6o3TNW3Yevw8bkp1/l0pPVkTe/0O2eu1/fXvCtGi0WN4hC9uSAl1ixxgvlvr65qkRfkCAPYV10Or1brMzSUpX9sB++X7hVbvO4uzDR0I8VHh9vRBLpsPzPfu+rIeqVE+AIDj55vR0NoBH7VrDa9w9mv53sSl0Rnw7g5TG5G5E2Oh1+t7G7LDYq5b6+2ajIr0w9bCGuSX1iM10teeoUnGntfygiiKPR7bVFFRgaioKOzevRtZWVmWjz/99NPYvn07cnNzrb6mpqYG8+bNw4YNGyAIAhISEpCdnY3ly5ejo6Pjos/z4osv4k9/+pPVx1euXAkvr771FChuAV49ooAAEU+lGhDl3advQ27snRMyHG6Q4ebBBlwd6X7Tztrb2zF79mw0NTXBz8/PJt+zv7nepAX+fUiOJp2A9GAj5iQa4SLv68hBfFEqw5YKGTJCjLg/0T12Ddsj1wH7vLbXdQJ/K5DDIAp4dLgByQHu97eZ+kdnBJ7dK4dOFPBsmh4Rbta6ypny/UJ6I/CXfDkatQJuiTPgykHMfbq8Px2Qo14j4LHhBiS56WuFI17L99bOSgFriuUIUIl4Pt0AHhagC20qF/D1WTnGhhhxn5tct19MX3O9V8VBrVYLLy8vrF27FjNnzrR8fM6cOWhsbMT69esv+bWdnZ2oq6tDZGQknnnmGXz55Zc4evToRR97sTsQMTExqK2tvewPp9PpsHnzZlx77bVQKn8cRmA0irj7nb3IL2/CHRlR+PvMET39kZ3epdbEnfV1TZbtLMYr35zC1UmheOvedDtGOLB6uh7Nzc0ICQmx6QVFX3MdAFraOzHz9e0oaxOQEOqNNQ+Ph6+H+/6OM9et2WJN9pU0YPa7+xDgqUTOH6ZC4eTH1nqyJvbIdcD2r+0A8MQnh/Dl4UpMTAjC+w+MtVmsjo75bq0/azLnvf3YXVSPF25Mxn0TYu0U4cCS8rUdsE++X+ij3DK8+OUJhPuq8d0Tk+GhlNssdkfDfO+ur+vx5JpD2HCoEr++OgG/uirBjhEOPGe9lu/tv6XeYMR1r+1CeUMHFk5Pwpws15pSzFy31ts12X6yBr/8IB9DQrzxzW8mDUCEA8+e1/K92lOtUqmQkZGBLVu2WIqDRqMRW7ZswYIFCy77tR4eHoiKioJOp8Onn36KO++885KPVavVUKvVVh9XKpU9+qX46eNW7ytDfnkTPJVy/H5aslsmW0/Xzp30dk0mJ4bhlW9OYV9JAwSZ3OmLBD/1c+thj9+fvua6KIp4/suTKGsTEOCpxPIHxiHI1822e1wCc91af9Zk/JAQS0uBvPIWTE503kFWB8oacLi8AQG4/JrY6/fH1q/tu07X4svDlRAE4LnpKW75e898t9aXNZmUGIrdRfXYU9yAB69wraKBFK/tgO3z/UKdOgOW/FAMAHj86qHw9fK46ONcDfO9u96ux7j4YGw4VIn88iaXXUdnupbvy2M3Hj2H8oYOBHopMXtCHJRK1zoebsZct9bTNUkfbBomWFzXhnY94O/puutoj2v5Xlc3nnzySSxbtgzvv/8+jh8/jkcffRRtbW2YO3cuAOD+++/Hs88+a3l8bm4u1q1bh6KiIuzYsQPXX389jEYjnn766T4F3Fs1LRr87avjAIDfXTcM4X7ucQFBtjci0h9+Hgq0aPQ4dI5NTqX0zo5ifHW4EjJBxH9npWFwMPsEkH0o5DJcP9LUa/DLQxUSR9N3Z2pa8dCKfVi04Tj21Tj/2ftOnQELPz8CALhvwmCMjPKXOCJyZpOGmor+e4rqYDC653FDZ/JRbhmqmjUY5O+Bu8bFSB0OOQnzZPL8skbmuRMSRRFLuoaPzZ0UDy+VaxYGqX+CfdQYHOwFUeR08r7odXHwrrvuwr/+9S+88MILGD16NAoKCrBp0ybLkJKysjKcP3/e8vjOzk4sXLgQKSkpuOWWWxAVFYWdO3ciICDAZj/E5fz5y2No7tRjZJQfHpgYNyDPSa5JLhMwMcH0BmL36VqJo3FvN4yKQHKEL+6INyIznlPKyL5mpJmKg5uOVkJncL7+JaV1bZi9bA8a2nVIjfJDapDzvylauv0MimvbEOarxu+nJUkdDjm5UVH+8PVQoLlTj8O8+efQmjp0eGPrKQDAr69JhFrhuseJybaSI/zgrZKjVaNHYWWL1OFQL31ztAonKlvgrZJjTlac1OGQAzPfCMjjdPJe69O5yAULFqC0tBQajQa5ubnIzMy0fG7btm1YsWKF5f+nTp2KY8eOobOzE7W1tfjf//6HyMjIfgfeE18crMCGgxWQywS8fGuqyx0DpYE3aahpq/JOFgclFR3ohbWPZGJiuPMXOcjxZcYHI9RXjcZ2HXaecq7cP9vQjtnLclHVrEFimA/evm8M1E7+Xjq/rAH/3XoaAPDCjBT4uXGvUbINuUzApK6bf1tPVEscDV3O/31/Go3tOiSG+eCOjGipwyEnIpcJSI81Fw3qJY6GesNgFLF4cyEA065Bfy++7tOljYszbRzZX8LiYG+5bLWsvL4df1x3GADw2JUJPHJENmE+enSgtBHtWr3E0bg3NceT0QCRywTclGraPfjJ/nKJo+m5yqZOzF6Wi3ONHRgS4o2P5mUi2FsldVj90tSuw4KV+dAbRdyYOgg3jhokdUjkIrJTTCdgthyvkjgSupTy+na8t6sEAPDc9OG86U+9Nr7rtElOUZ3EkVBvbDhYgZNVrfDzUGDelCFSh0MObqy5hUB5g1Oe+JGSS76qavVG/OrjfLRo9Bg7OBC/uSZR6pDIRcSHeCM60BNag9HpdhARUd+Z+1ptPlaFmhbNzzxaetUtnZi9bA/K6tsRG+SFlfMmIMzXuXvuGo0inv70IM41diA2yAsv3ToKguD8/RPJMVyVFApBAI5WNKOisUPqcOgi/vVtIbQGIyYmBOPKpFCpwyEnZL7Jv/sM+4s6C53BiP98dxIA8MjUBJceMEG2kRDqA39PJTp1RhyraJY6HKficsVBUQQWbTiOgvJG+Hko8Ordo3lnkWxGEARkDzftLviOuwuI3EZyhB9GxwRAbxTx6YGzUodzWXWtGtz7Ti6KatsQFeCJlfMyEeHv3IVBAFj83Wl8c7QKSrmAN2al8zgx2VSwjxoZXUcOt/BoscM5UNaA9QUVXdPJh/PGAPVJWrQ/fNQKNLbrWDRwEmvzzqK0rh0hPirOD6AekckEy+7B/ew72CsuVzXbdl7A2gPnIBOA12elIzrQS+qQyMWYi4NbT1TDyLuORG5j1njT7sHV+8ohio6Z+43tWtz37l6crGpFuJ8aK+dlusTr4O4qAW/tKAYAvHRrKtJiAqQNiFyS+WjxpiPnf+aRjs9R/0b1hVZvxLOfmloF3T4mmq2CqM8UchkmDGH/cGfRoTXg9S2mAUSPXjkU3mpOKKaeyYjrKg6WsL9ob7hUcXDbyRqsLzX9SAtvTMGVSWESR0SuaHx8EHzVCtS2alFwtlHqcPqlQ2vAn786gTad1JEQOb6bUiPhrZKjuLbNIfsVNXfqcP/yvTh2vhkhPmqsnDcBg4O9pQ6r33acqsWaItNr+6+vScTtHEJAdmLuYZlzpg7VzZ0SR9N37Vo9Hng/D/l1rrG7btmOIhRWtSDIW4Xnpg+XOhxycpO7hgvuYnHQ4b2zowjnmzoRFeCJezJjpQ6HnMjYwV1DSUobXOpmmb25THHwbEM7fvvJIYgQcNfYKMydFCd1SOSiVAoZpnb1utl0pFLiaPpOozfgkQ/z8MGeMrxTKOcfTqKf4a1W4Ob0KACwNMV3FK0aPR5YvheHzjYhyFuFlfMykRDqI3VY/abVG7Fw/TEYIWBm2iA8kc0ewmQ/MUFeSI8NgFEEvjzknLsH27V6PLhiH3afqccnRTK0dDr33b/T1a14rWvn0PM3DUegkw9VIuldMcx0Db+3uB6tGg4XdFTVzZ1Ysv0MAOAPNyTDQymXOCJyJqnR/lDJZahp0aC4tk3qcJyGyxQHowI88dDEOCT6GfHCjexFQvZ1U2okANP0LGc8WqwzGLFgZT5+OFkDT6UMN8UamDNEPfDgpHgApsEkp6tbJY7GpENrwEMr9uFAWSP8PZX44KHxGBbuK3VYNqFSyPDu/WMwLtSIv84cwb9TZHc3p5le39cfrJA4kt5r1+ox97192FNUD2+1HI8kG+DrxL0527V6PPZRHrR6I65IDMHM0VFSh0QuYEiIN+JDvKE1GLG9sEbqcOgSFm8+iXatAemxAZiROkjqcMjJeCjlGDM4AAB3CfeGyxQHBUHAr65OwKMpRqgULvNjkYO6MikUvmoFzjd1Ol2jU4NRxJOfHMTmY1VQKWRYck86EvykjorIOQwN88G1XX3J3v7hjMTRdO0YfG8vcovr4atW4H8PjseISNfqxzU0zAf3DjVCzdd2GgA3pkZCLhNwsLwRp6papA6nx8yFQfPfgvfmZCDOie8RiKKIhZ8fwcmqVoT6qvHvO9N4c4BsQhAEy+v45mPOewLIlR2raMbq/eUATK3CmPvUF1ckmnYJ7zjF4mBPudyVtpx/O2gAeCjluH5kBADg84JzEkfTc0ajiGc+PYQNByugkAlYeu8YTEoIljosIqcyf2oCAOCz/HOokrAvWVOHDve9m2spBqx4cDwHdRD1U6ivGtnDTT2rP8otkzianmnX6vHABYXB9x8aj3Qn/1vw/p4yrDMPGLw7HWG+zj9xnRyHuTi49UQ1dAajxNHQhYxGES9+cRSiCNyUOggZXVNniXpr8tAQAKY+wnrmeY+4XHGQaKDc3HW85cuDFejQGiSO5ueJoogXNxzFmryzlmneVyeHSx0WkdPJGByIcXGB0BlELN0uze7BhjYt7nlnD/K7jhJ/NC+TF9BENjI7czAA4NMDZx3+9b1NYyoM7jXvHn5oPMbEOvffgvxaAX//uhAA8Ifrk5HFm5hkY2NiAxHsrUJzpx45ZxxvwJg7+3hfGfaW1MNLJcczNyRLHQ45sZFR/vD3VKJFo8fBs01Sh+MUWBwk6qOJCcGICfJEc6ceXx5y7N5Eoijipa9P4H85pRAE4N93pmH6KPbvIOqrX11tGozx4Z5SlNe3D+hzn2/qwF1v5+DIuWYEe6uw6uEJSI0OGNAYiFzZFUNDEBPkiRYHf31v0+gxd0X3wmC6kxcG9xTV44PTMogicH/WYDw8ZYjUIZELkssE3DDKdAJofYHj5nhPaPQGbD5WLXUYNlHZ1ImXN54AADw1LQnRgV4SR0TOTC4TMKlrOvn2QtfIEXtjcZCoj2QyAbPGxwJw/KNHr353Cm//UAQA+NvMUbglPVriiIic25RhobgiMQQ6g4h/bDoxYM97uroFt/3fbpysakW4nxqrH5mA4YPYNJTIlmQyAbPHm3YPOurre5vG1GPQlQqDx88349GVBTCIAqalhGHRDA4hIvsxD7jZdOS8w+8QvhSt3jRg8LGPC7DtvHPnisEo4qm1B9Gi0WN0TADuz4qTOiRyAeZTct8eq5I4EufA4iBRP9yREQOlXEBBeSOOVjjmduWl28/gtS2nAADP35SC2ZmxEkdE5BqeuSEZggB8eeg8tg3AHcm80nrctiQHFU2dGBLqjU8fnYihYU48cYDIgd0xNtry+n6gzLEGj1kKgyWmwuAHv8x0+sIgAPh6KBDmq0KCr4h/3z4KcplzFzvIsWUMDkR0oCfatAZsPu58hQOdwYhff5xvGTAY4Sl1RP3z2pZT2HGqFh5KGV65PZX5TzaRPTwMcpmAE5UtKKsb2JM+zojFQaJ+CPVVY9oI07EER9xdsGJXMV7++sft+Q9Njpc4IiLXMSLSH3MnmnLqj58dQUunzm7P9eWhCtzzTi6aOnQYHROAtfMn8rgNkR2F+KhxS7ppZ9GSbdJPJjdrvbAw6GEqDI528uEjZtGBXlg1bzx+mWyAWimXOhxycYIgWHJ8TddkXGeh1ZsKg5uOVkIll2HJ7NFIDhClDqvPthbW4PWujQwv3ToKw8J545NsI8BLhcz4IADAN0c5nfznsDhI1E/3dDUu/+zAOdS3aSWO5kfLdxbjxQ3HAAALrhqKx68aKnFERK7n99OGISbIE+caO/DMusMQRdtenOsNRrz89QksWJmPTp0RVyWFYuW8TAR5q2z6PERk7ZGpCRAEYPOxKpysapE6HNMgomV7fiwMPuQ6hUGzQC8VvBRSR0Hu4s6xMRAEYMepWhTVtEodTo90aA2Y97/9+PqIqTC49L4xmJIYInVYfVbSAjzxySEAwH0TBrP1EdmceSPPJhYHfxaLg0T9NGFIEEZF+aNDZ8B7u4qlDgcA8M6OIvz5S1Nh8NErE/C764ZJHBGRa/JSKfDqXelQyAR8deg8lu0ostn3PlPTituX5lgmIj8yZQiW3T8WXiq+cyYaCAmhPri+603FUol3D1Y1d+LOt3Jw8GwTAr2UWPnLCS5XGCQaaDFBXrg6KQyAY54A+qmWTh3mLN+L7Sdr4KmU490Hxlp6qjmjU1WteOuEHO1aA65IDMHzN6VIHRK5oGkjIiAIQF5pw4APEbQ1URRtvhHhQiwOEvWTIAh4/KoEAMCK3SV2PVrYE+/sKMJfvzoOAHj8qgQ8PS2JDb2J7ChjcCAW3jgcAPD3jSfwWf7Zfn0/ncGIJdvOYPprO1BQ3ghftQKvz0rHs9OHQyHnyzbRQHr0StPr+/qDFSipbZMkhrK6dtyxNAenqk2DiD55JAujov0liYXI1dybZToBtGZ/uUMPJmlo0+Ked3J/7DX60HhckRgqdVh9Vl7fjrnv56FdLyAt2h9L782ASsFrHLK9CH8PTEow7a79LP+cxNH0nSiKeOnrE3htq/1uVjIDiWzgupQIJIR6o6VTjw/3SHfncen2M5bC4K+vHorfX8fCINFAmDMxDg9OMvUf/P2aQ9jcx6loeaUNmPHGTvxj0wlo9EZckRiCb56Ygl+kRdoyXCLqodToAFyZFAqDUcQr3wzcZHKzgvJG3LpkF8rq2xEb5IW18ycikf24iGxmamIoYoI80dypx4aDFVKHc1HVzZ246+0cHDrbhCBvFT5+eALGxgVJHVa//GnDUVS1aBDhKWLZfenwVvNUBNnPrWNM/UXXHThr15139mIwinh23WG8/UMR3txWhHI7dUFgcZDIBmQyAY9daerpt2xHEZoHePegKIp4+esTluEjv7kmEU+yMEg0YARBwMIbh+PW9CgYjCLmf5jXqwbnTR06LPz8MG5fuhsnKlsQ6KXEv+9Iw/8eHI/IACcfQUjk5J69YThkArDxcCX2l9QP2PN+e7QSd7+dg9pWLVIG+WHN/CzEBHEQEZEtyWQC7u3qH/7OziIYjY5VODjb0I473srBySrTzuHVD0/AyCjn3zn8yu1pmJYShkeHGxDoxT7KZF/TRkTASyVHSV079pU0SB1Or2j0Bvz643ys2lcOmQD8feYIxPjY57lYHCSykV+MjsSQUG/Ut2nx5venB+x59QYjnvn0sKUv2TM3JOOJa9ljkGigyWQC/nF7Km4dYyoQPrX2EP6z+SQMl3mjYTSKWF9wDtmLt+PDPWUQReD2jGhs+d2VuC0jmgV+IgeQFOGLO8fGAACe++wwNHr7Hz18b1cxHvkwD506I6YOC8Un87MQ7udh9+clckd3j4+Fr1qBk1Wt+O5433b+28OZmlbcsTQHpXXtiA70xJpHXGfncJC3Cv+dNRoBaqkjIXfgrVZYTuF8sKdU4mh6rl2rxy/f34+vDp+HUi7gzdljcEdGlN2ej8VBIhtRymX443RT37H3dpageAB6E3XqDHh85QGs3m+6k/DKbamYPzXB7s9LRBenlMvw7zvS8MjUIQCA17acwl1v5eBAWfe7lJ06AzYcrMD013fgN6sKUNOiwZAQb3w8bwL+dUcapxETOZinr09GsLcKJ6ta8d+t9rsBqNUb8cL6I/jThmMQRWDW+Fi8O2csfHjkjshu/D2VuK+r9+Cb3592iGOHxyqacddbOTjf1ImEUG+snT8RscHcOUzUV+Yc//rweVQ3d0oczc9r6tDhvnf3YsepWtMAojnjcMOoQXZ9Tl5pENnQ1clhuCIxBDtO1eKpNQex+pEsyGX22fnT0KbF/A/zkFtcD5VChjdmpVtGtRORdARBwLM3DEdSuC+e//wI9pc24Nb/2424YC8MCfVBm0aPoxXNaNXoAQC+agUemToE86YMgVohlzh6IrqYIG8V/nzzSDy+8gDe/P40soYEY+LQEJs+x7nGDjz+0QEUlDcCAP5wfTLmTx3CHcREA+DByfFYvqsYB882YdfpOkxOtG1+98au07WY/2EeWjr1SBnkhw8eGo9gH26xI+qPEZH+GBcXiH0lDVi5twy/zXbck3Y1LRrcv3wvjp9vhp+HAu/NHY+MwYF2f17uHCSyIUEQ8PdbRsFHrcD+0gbLUV9bO1nVgpvf3IXc4nr4qBVYMXccC4NEDubWMdH49smpuHNsNBQyASV17dh6ohq5xfVo1egxyN8Dv756KHb84SosuDqRhUEiBzd9VARuz4iGUQR+9XE+yuvbbfJ9DUYR7+8uwbT//ICC8kb4eSjw7pyxePTKBBYGiQZIiI8ad4+LBQD857uTku0eXLO/HHOW70VLpx7j4gLx8cMTWBgkspH7s+IAAB/llkGrN0obzCWcbWjHnW/l4Pj5ZoT4qLH6kawBKQwC3DlIZHMxQV54/qbh+MOnh/HvbwsxMsofU4eF2uR7i6KIVfvK8ecNx9ChMyA2yAvvzBmLYS7Sf4TI1UQFeOKV29Ow8KYU7CuuR12rFgq5gOQIPyRH+EJmp53FRGR7giDgrzNH4lhFM46db8a97+ZizSNZCOtHL8DCyhY8s+4Q8ssaAQBjYgPw2t3pHDxCJIH5UxOwal8Z8kobsOlIpd2P8F1IFEUs3nwSb3S1LZiRFol/3p4KDyVvHBLZyvUjIxDmq0Z1iwYbDlbgtoxoqUPq5nR1K+57NxfnmzoRFeCJj36ZibgQ7wF7fu4cJLKDO8fG4M6xpt0FC1YewJFzTf3+nlXNnZj3vzw8u+4wOnQGTBoajM8fn8TCIJET8PNQ4prh4bhzXAxuHRONlEg/FgaJnJCHUo735o5DTJAnSuvacd+7e1HXqun19+nQGvCPTSdw4+s7kF/WCB+1An+5eQTWzp/IwiCRRCL8PfDwFFPv7pe+PoFOnf2HDwGmaaRPrC6wFAYfvyoBr901moVBIhtTymV4cHI8AODNbacvOzRwoB0+24Q7u/qMDg3zwaePThzQwiDA4iCRXQiCgL/MHInxcUFo6dTjvndzUVjZ0qfvJYoiVu0tQ/bi7fjueBWUcgHPTU/GBw9mcmgBERHRAAv388CHD2Ui1FeNwqoW3LZkN0p6MYTs+xPVuPY/27Fk2xnojSKuTQnH5ien4L6sON40IJLYI1OGIMxXjbL6dry25ZTdn6+6uRP3LMvF5wUVUMgEvHJbKp6alsy/BUR2cu+EwfD3VKKopg0bD5+XOhwAQM6ZOsxatgf1bVqMivLHJ49kIcK/76cS+orFQSI7USvkePeBsUiLCUBDuw6zl+2xNBnvqZLaNsxelotn1h1GS6ceqdH++GLBZDw8JYEXDURERBIZHOyNVQ9PQHSgJ0rq2nHrkt344WTNZb+mpLYNj32Uh7kr9uFsQwci/T3w9n0ZWHb/WAzy9xygyInocrzVCvxl5kgAwNs/FOFgL6/de2NfST1ufGMn9pc2wNdDgRVzx+POcTF2ez4iAnzUCjw4ybR78L9bT8Mo8e7BNfvLcf/yXLRq9MiMD8LKedJtAGJxkMiOfD2U+N/c8RgZ5Ye6Ni3ufjsHm478/B0KvcGIt384g2mv/oCcojp4KGX44/ThWPfoRAwf5DcAkRMREdHlJIT6YN1jEzEqyh/1bVrcv3wvnlpzEKV1P+4iFEUR+WUN+P2ag7hm8XZsPFwJuUzAw1OGYPOTU3Edh4kROZxpIyIwIy0SBqOIx1ceQGO71qbfX6M34PUtpzDr7T2oadEgKdwXXyyYLOmEZCJ38sDEOPioFSisasHXRyolicFoFPHKphN4au0h6Awibhw1CO8/OB6+HkpJ4gE4kITI7vy9lFj1cBZ+tfIAvi+swfwPD+D+rMF4alqSVfKLoohvjlbilW8KUVRjenMxMSEYL906CoODB7bnABEREV1emK8HPnkkC3/feBwf7CnFmryzWJN3FoODveDroUB5fQeaOnSWx1+VFIqnpiUjJZI3+ogc2V9njsTB8kaU1bdjwcp8vPvAWKgV/e8BuLe4Hs99dhinq1sBADelDsI/bkuFt5pvy4kGir+XEg9OjsfrW07hH5tOIDslzCb53VMdWgN+t6YAGw+bCpO/unoonsgeJvnJQP4VIhoAPmoFlt0/Fn/beBzv7SrB/3JK8Xn+OdySHoW0mAAIAnCisgXfHKlESV07ACDQS4lnbxiOO8ZGQxB4hJiIiMgReark+MvMkZiZHolXvzuFXadrUdr1Wg4Anko5rhsRjgcmxiE9NlDCSImop/w9lVh6bwZuW7IbO0/X4jcfF+C/s9OhkPft4F1Tuw4vbzqOj/eWAwBCfFR4/qYU/CItktf5RBJ4ZMoQrNpbhrL6dry3qwTzpyYMyPNWN3di3v/24+DZJijlAl6+NdVhpiazOEg0QBRyGRbNGIGrksLwpw1HcaamDe/nlAI5pd0e562S48HJ8Zg3ZQj8JNxWTERERD2XMTgIHzyUiaZ2HY5UNEGjNyDM1wPDwn2hUrCTD5GzSYn0w7L7x+LBFfuw6WglfrfmIP55e1qv8lkURawvqMBfvzqO2q7J5rPGx+AP1ycjwIuDBYmk4q1W4KlpSXhq7SG8+t1J3DAywu4n9faV1OOxjw6gpkWDAC8l3ro3A5lDgu36nL3B4iDRAJsyLBTfPjEV35+oxg+nanC6uhWiCMSFeGF8fBCmjYiAl4qpSURE5Iz8vZSYNJS9w4hcweTEEPx3djoe/egA1hdUoKZFgyX3ZsDf8+dv4J+ubsUL649g95k6AMDQMB/8/ZZRGB8fZO+wiagHbhsTjXUHziGnqA5Prz2ElfMmQG6Ho72iKGLF7hL87avj0BtFJIX74q37MhAX4lhtw1iBIJKAXCYgOyUc2SnhUodCRERERESXcN2ICLw7Zywe/+gAdp+pw8w3d+E/d43G6JiAiz6+pkWDt384gxW7S6AziFArZPj1NYn45RXxA9rXjIguTyYT8I/bUjHt1R+QW1yP1747iSevS7Lpc5ypacVz6w4jt7geADAjLRL/uG2UQ24GcryIiIiIiIiIiBzElUlhWDN/In75/j4U17bh1v/bhVvSozE7MwYpg/yhMxpx+GwTvjp8HusOnEWnzgjANITozzePREyQl8Q/ARFdTGywF/5+60g8sfogXt96GkkRfrgxdVC/v69Gb8CSbWfwf9+fgdZghIdShqenJWPupDiH7TPK4iARERERERHRZaRE+mHjb67AC+uP4ouDFfj0wFl8euDsRR+bFhOA316TiCuTQh22EEBEJrekR+NgeRNW7C7Bb1fnw1Mlw9XJfT/ht6eoDs99dhhFNW0AgKnDQvHXmY5/k4DFQSIiIiIiIqKfEeClwuuz0vHg5Hi8s6MIO0/XorFdBwCICvBEVkIwbh0ThawhwSwKEjmR529KQV2bFhsOVmD+hwew9N4xvS4Q1rVq8PLXJ7Amz3TTIMRHjUUzUnBT6iCn+HvA4iARERERERFRD42OCcB/Z4+B0SiiTauHTBDgreZbayJnJZcJWHxnGjQ6A749VoVfvr8fL9yUggcmxf/s1xqMIlbtK8MrmwrR1GG6WXBPZiyevj65R8OLHAX/ghERERERERH1kkwmwNfDed78E9GlKeUy/Hf2GCz8/DA+2X8WL244hoNnm/DiL0ZctMgniiK+L6zGfzafwuFzTQCAlEF++MvMkcgYHDjQ4fcbi4NEREREREREROTWVAoZ/nFbKoaE+uCVTSfwWf45bD9Zg4cmxyN7eDjCfNWobO5Ezpk6rMk7i+PnmwEAvmoFfnfdMNw7YTAUcpnEP0XfsDhIRERERERERERuTxAEzJ+agHFxQXhq7UEU1bThn98U4p/fFFo91kslx70TBmPeFUMQ6quWIFrbYXGQiIiIiIiIiIioS8bgQHz72ylYX1CBz/LPYX9pPTp1RvioFRgV5Y9pI8Jx8+goBHqrpA7VJlgcJCIiIiIiIiIiuoBCLsNtGdG4LSMaAGA0ihAEOMX04d5icZCIiIiIiIiIiOgyZDLXKwqaOWenRCIiIiIiIiIiIuo3FgeJiIiIiIiIiIjcVJ+Kg2+++Sbi4uLg4eGBzMxM7N2797KPf/XVV5GUlARPT0/ExMTgiSeeQGdnZ58CJiIiIiIiIiIiItvodXFw9erVePLJJ7Fo0SIcOHAAaWlpmDZtGqqrqy/6+JUrV+KZZ57BokWLcPz4cbz77rtYvXo1nnvuuX4HT0RERERERERERH3X6+Lg4sWLMW/ePMydOxcpKSlYunQpvLy8sHz58os+fvfu3Zg0aRJmz56NuLg4XHfddZg1a9bP7jYkIiIiIiIiIiIi++pVcVCr1SIvLw/Z2dk/fgOZDNnZ2cjJybno10ycOBF5eXmWYmBRURE2btyI6dOn9yNsIiIiIiIiIiIi6i9Fbx5cW1sLg8GA8PDwbh8PDw/HiRMnLvo1s2fPRm1tLSZPngxRFKHX6zF//vzLHivWaDTQaDSW/29ubgYA6HQ66HS6S36d+XOXe4y74ZpY45p019P1sMd69TXXL4yH/44mXA9rXBNrPVkTe60XX9tth2tijWvSnZSv7QDz3Za4Jt1xPazxWt41cD2scU2s2fNaXhBFUezpgysqKhAVFYXdu3cjKyvL8vGnn34a27dvR25urtXXbNu2DXfffTf++te/IjMzE6dPn8ZvfvMbzJs3D88///xFn+fFF1/En/70J6uPr1y5El5eXj0Nl4hsqL29HbNnz0ZTUxP8/Pxs8j2Z60SOxx65DjDfiRwR853IffBansg99DXXe1Uc1Gq18PLywtq1azFz5kzLx+fMmYPGxkasX7/e6muuuOIKTJgwAf/85z8tH/vwww/x8MMPo7W1FTKZ9cnmi92BiImJQW1t7WV/OJ1Oh82bN+Paa6+FUqns6Y/l0rgm1rgm3fV0PZqbmxESEmLTC4q+5npv4nYXXA9rXBNrPVkTe+Q6wNd2W+KaWOOadCflazvAfLclrkl3XA9rvJZ3DVwPa1wTa/a8lu/VsWKVSoWMjAxs2bLFUhw0Go3YsmULFixYcNGvaW9vtyoAyuVyAMCl6pJqtRpqtdrq40qlske/FD19nDvhmljjmnT3c+thj7Xqb6739rHugOthjWti7XJrYq+14mu77XFNrHFNupPitR1gvtsD16Q7roc1Xsu7Bq6HNa6JNXtcy/eqOAgATz75JObMmYOxY8di/PjxePXVV9HW1oa5c+cCAO6//35ERUXhpZdeAgDMmDEDixcvRnp6uuVY8fPPP48ZM2ZYioREREREREREREQ08HpdHLzrrrtQU1ODF154AZWVlRg9ejQ2bdpkGVJSVlbWbafgwoULIQgCFi5ciHPnziE0NBQzZszA3/72N9v9FERERERERERERNRrvS4OAsCCBQsueYx427Zt3Z9AocCiRYuwaNGivjwVERERERERERER2Yn1NBAiIiIiIiIiIiJyCywOEhERERERERERuak+HSseaOapxs3NzZd9nE6nQ3t7O5qbmznNpgvXxBrXpLueroc5/y41ZdwWeprrAP8df4rrYY1rYq0nazIQuX7h9+dre+9xTaxxTbpzpNf2C78/8733uCbdcT2sOVK+81q+77ge1rgm1ux5Le8UxcGWlhYAQExMjMSREFFLSwv8/f3t9r0B5jqRI7Bnrpu/P8B8J3IEzHci98FreSL30NtcF0R73yq0AaPRiIqKCvj6+kIQhEs+rrm5GTExMSgvL4efn98ARui4uCbWuCbd9XQ9RFFES0sLIiMju00kt6We5jrAf8ef4npY45pY68maDESuA3xt7w+uiTWuSXeO9NoOMN/7g2vSHdfDmiPlO6/l+47rYY1rYs2e1/JOsXNQJpMhOjq6x4/38/PjL89PcE2scU2668l62HNXAdD7XAf47/hTXA9rXBNrP7cm9s51gK/ttsA1scY16c4RXtsB5rstcE2643pYc4R857V8/3E9rHFNrNnjWp4DSYiIiIiIiIiIiNwUi4NERERERERERERuyqWKg2q1GosWLYJarZY6FIfBNbHGNenOWdfDWeO2F66HNa6JNWdcE2eM2d64Jta4Jt0563o4a9z2xDXpjuthzVnXxFnjtheuhzWuiTV7rolTDCQhIiIiIiIiIiIi23OpnYNERERERERERETUcywOEhERERERERERuSkWB4mIiIiIiIiIiNwUi4NERERERERERERuyqWKg2+++Sbi4uLg4eGBzMxM7N27V+qQ7OKHH37AjBkzEBkZCUEQ8Pnnn3f7vCiKeOGFFzBo0CB4enoiOzsbp06d6vaY+vp63HPPPfDz80NAQAAeeughtLa2DuBPYTsvvfQSxo0bB19fX4SFhWHmzJkoLCzs9pjOzk48/vjjCA4Oho+PD2677TZUVVV1e0xZWRluvPFGeHl5ISwsDE899RT0ev1A/ig2s2TJEqSmpsLPzw9+fn7IysrC119/bfm8s6+Hu+Q6wHz/Kea7Nea7a2CuW2O+d8dcdx3M9+6Y69aY766D+d4d892aw+S76CJWrVolqlQqcfny5eLRo0fFefPmiQEBAWJVVZXUodncxo0bxT/+8Y/iunXrRADiZ5991u3zL7/8sujv7y9+/vnn4sGDB8Vf/OIXYnx8vNjR0WF5zPXXXy+mpaWJe/bsEXfs2CEOHTpUnDVr1gD/JLYxbdo08b333hOPHDkiFhQUiNOnTxdjY2PF1tZWy2Pmz58vxsTEiFu2bBH3798vTpgwQZw4caLl83q9Xhw5cqSYnZ0t5ufnixs3bhRDQkLEZ599Voofqd+++OIL8auvvhJPnjwpFhYWis8995yoVCrFI0eOiKLo3OvhTrkuisz3n2K+W2O+uwbmujXme3fMddfBfO+OuW6N+e46mO/dMd+tOUq+u0xxcPz48eLjjz9u+X+DwSBGRkaKL730koRR2d9P/8AYjUYxIiJC/Oc//2n5WGNjo6hWq8WPP/5YFEVRPHbsmAhA3Ldvn+UxX3/9tSgIgnju3LkBi91eqqurRQDi9u3bRVE0/fxKpVJcs2aN5THHjx8XAYg5OTmiKJr+aMtkMrGystLymCVLloh+fn6iRqMZ2B/ATgIDA8V33nnH6dfDXXNdFJnvF8N8vzjmu3Njrl8c890ac935Md+tMdcvjvnu/Jjv1pjvFydFvrvEsWKtVou8vDxkZ2dbPiaTyZCdnY2cnBwJIxt4xcXFqKys7LYW/v7+yMzMtKxFTk4OAgICMHbsWMtjsrOzIZPJkJubO+Ax21pTUxMAICgoCACQl5cHnU7XbU2Sk5MRGxvbbU1GjRqF8PBwy2OmTZuG5uZmHD16dACjtz2DwYBVq1ahra0NWVlZTr0ezPXumO/M959ivrsm5roJ8/1HzHXXxXxnrv8U8911Md+Z7z8lZb4rbPdjSKe2thYGg6HbYgBAeHg4Tpw4IVFU0qisrASAi66F+XOVlZUICwvr9nmFQoGgoCDLY5yV0WjEb3/7W0yaNAkjR44EYPp5VSoVAgICuj32p2tysTUzf84ZHT58GFlZWejs7ISPjw8+++wzpKSkoKCgwGnXg7neHfOd+W7GfHdt7p7rAPPdjLnu+tw935nrP2K+uz7mO/PdzBHy3SWKg0Rmjz/+OI4cOYKdO3dKHYrkkpKSUFBQgKamJqxduxZz5szB9u3bpQ6LyGaY7z9ivpOrY76bMNfJ1THXf8R8J1fHfP+RI+S7SxwrDgkJgVwut5rYUlVVhYiICImikob5573cWkRERKC6urrb5/V6Perr6516vRYsWIAvv/wS33//PaKjoy0fj4iIgFarRWNjY7fH/3RNLrZm5s85I5VKhaFDhyIjIwMvvfQS0tLS8Nprrzn1ejDXu2O+M9/NmO+uzZ1zHWC+X4i57vrcOd+Z690x310f8535buYI+e4SxUGVSoWMjAxs2bLF8jGj0YgtW7YgKytLwsgGXnx8PCIiIrqtRXNzM3Jzcy1rkZWVhcbGRuTl5Vkes3XrVhiNRmRmZg54zP0liiIWLFiAzz77DFu3bkV8fHy3z2dkZECpVHZbk8LCQpSVlXVbk8OHD3f7w7t582b4+fkhJSVlYH4QOzMajdBoNE69Hsz17pjvzPdLYb67FnfMdYD53hPMddfjjvnOXO8Z5rvrYb4z3y9Fkny3ySgVB7Bq1SpRrVaLK1asEI8dOyY+/PDDYkBAQLeJLa6ipaVFzM/PF/Pz80UA4uLFi8X8/HyxtLRUFEXTOPSAgABx/fr14qFDh8Sbb775ouPQ09PTxdzcXHHnzp1iYmKi045Df/TRR0V/f39x27Zt4vnz5y3/tbe3Wx4zf/58MTY2Vty6dau4f/9+MSsrS8zKyrJ83jz++7rrrhMLCgrETZs2iaGhoU47Dv2ZZ54Rt2/fLhYXF4uHDh0Sn3nmGVEQBPHbb78VRdG518Odcl0Ume8/xXy3xnx3Dcx1a8z37pjrroP53h1z3Rrz3XUw37tjvltzlHx3meKgKIriG2+8IcbGxooqlUocP368uGfPHqlDsovvv/9eBGD135w5c0RRNI1Ef/7558Xw8HBRrVaL11xzjVhYWNjte9TV1YmzZs0SfXx8RD8/P3Hu3LliS0uLBD9N/11sLQCI7733nuUxHR0d4mOPPSYGBgaKXl5e4i233CKeP3++2/cpKSkRb7jhBtHT01MMCQkRf/e734k6nW6AfxrbePDBB8XBgweLKpVKDA0NFa+55hrLHxdRdP71cJdcF0Xm+08x360x310Dc90a87075rrrYL53x1y3xnx3Hcz37pjv1hwl3wVRFMWe7zMkIiIiIiIiIiIiV+ESPQeJiIiIiIiIiIio91gcJCIiIiIiIiIiclMsDhIREREREREREbkpFgeJiIiIiIiIiIjcFIuDREREREREREREborFQSIiIiIiIiIiIjfF4iAREREREREREZGbYnGQiIiIiIiIiIjITbE4SERERERERERE5KZYHCQiIiIiIiIiInJTLA4SERERERERERG5KRYHiYiIiIiIiIiI3NT/A7mzzuunBd08AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Temp vs time\n", "fig, axs = plt.subplots(figsize=(13,5), ncols=5, sharex=True, sharey=True)\n", @@ -195,10 +297,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "3e2b917b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "SimulatorBase.__init__() got an unexpected keyword argument 't_end'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[16], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m t_start \u001b[38;5;241m=\u001b[39m Time(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m2022-06-02 15:43:43\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m t_end \u001b[38;5;241m=\u001b[39m t_start \u001b[38;5;241m+\u001b[39m cro\u001b[38;5;241m.\u001b[39mconstants\u001b[38;5;241m.\u001b[39msidereal_day_earth \u001b[38;5;241m*\u001b[39m seconds\n\u001b[0;32m----> 4\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mcro\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSimulator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbeam\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msky\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt_start\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mworld\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mearth\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt_end\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mt_end\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mN_times\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m300\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlmax\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: SimulatorBase.__init__() got an unexpected keyword argument 't_end'" + ] + } + ], "source": [ "loc = (20., -10.)\n", "t_start = Time(\"2022-06-02 15:43:43\")\n", @@ -206,6 +320,21 @@ "sim = cro.Simulator(beam, sky, loc, t_start, world=\"earth\", t_end=t_end, N_times=300, lmax=lmax)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac00860d-a805-45c0-9086-f731c0a6c98e", + "metadata": {}, + "outputs": [], + "source": [ + "# let's do a full sidereal day on the moon\n", + "loc = (20., -10.)\n", + "t_start = Time(\"2022-06-02 15:43:43\")\n", + "t_end = t_start + cro.constants.sidereal_day_moon * seconds\n", + "times = cro.simulatorbase.time_array(t_start=t_start, t_end=t_end, N_times=300)\n", + "sim = cro.Simulator(beam, sky, lmax=lmax, world=\"moon\", location=loc, times=times)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -266,7 +395,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 9d66c43..0000000 --- a/requirements.txt +++ /dev/null @@ -1,124 +0,0 @@ -argon2-cffi==21.3.0 -argon2-cffi-bindings==21.2.0 -astropy==5.1 -asttokens==2.0.7 -attrs==22.1.0 -backcall==0.2.0 -beautifulsoup4==4.11.1 -black==22.6.0 -bleach==5.0.1 -build==0.8.0 -certifi==2023.7.22 -cffi==1.15.1 -charset-normalizer==2.1.0 -click==8.1.3 -commonmark==0.9.1 -coverage==6.4.3 -croissant-sim==3.0.0 -cryptography==41.0.6 -cycler==0.11.0 -debugpy==1.6.2 -decorator==5.1.1 -defusedxml==0.7.1 -docutils==0.19 -entrypoints==0.4 -ephem==4.1.3 -executing==0.9.1 -fastjsonschema==2.16.1 -flake8==5.0.4 -fonttools==4.43.0 -h5py==3.7.0 -healpy==1.16.1 -hera-filters==0.1.1 -idna==3.3 -importlib-metadata==4.12.0 -iniconfig==1.1.1 -ipykernel==6.15.1 -ipython==8.10.0 -ipython-genutils==0.2.0 -ipywidgets==7.7.1 -jedi==0.18.1 -jeepney==0.8.0 -Jinja2==3.1.2 -jplephem==2.17 -jsonschema==4.9.1 -jupyter==1.0.0 -jupyter-client==7.3.4 -jupyter-console==6.4.4 -jupyter_core==4.11.2 -jupyterlab-pygments==0.2.2 -jupyterlab-widgets==1.1.1 -keyring==23.8.2 -kiwisolver==1.4.4 -lunarsky==0.1.2 -lxml==4.9.1 -MarkupSafe==2.1.1 -matplotlib==3.5.2 -matplotlib-inline==0.1.3 -mccabe==0.7.0 -mistune==2.0.3 -mypy==0.971 -mypy-extensions==0.4.3 -nbclient==0.6.6 -nbconvert==7.2.8 -nbformat==5.4.0 -nest-asyncio==1.5.5 -notebook==6.4.12 -numpy==1.23.1 -packaging==21.3 -pandocfilters==1.5.0 -parso==0.8.3 -pathspec==0.9.0 -pep517==0.13.0 -pexpect==4.8.0 -pickleshare==0.7.5 -Pillow==10.0.1 -pkginfo==1.8.3 -platformdirs==2.5.2 -pluggy==1.0.0 -prometheus-client==0.14.1 -prompt-toolkit==3.0.30 -psutil==5.9.1 -ptyprocess==0.7.0 -pure-eval==0.2.2 -py==1.11.0 -pycodestyle==2.9.1 -pycparser==2.21 -pyephem==9.99 -pyerfa==2.0.0.1 -pyflakes==2.5.0 -pygdsm==1.3.0 -Pygments==2.15.0 -pyparsing==3.0.9 -pyrsistent==0.18.1 -pytest==7.1.2 -pytest-cov==3.0.0 -python-dateutil==2.8.2 -PyYAML==6.0 -pyzmq==23.2.0 -qtconsole==5.3.1 -QtPy==2.1.0 -readme-renderer==36.0 -requests==2.31.0 -requests-toolbelt==0.9.1 -rfc3986==2.0.0 -rich==12.5.1 -scipy==1.10.0 -SecretStorage==3.3.2 -Send2Trash==1.8.0 -six==1.16.0 -soupsieve==2.3.2.post1 -spiceypy==5.1.1 -stack-data==0.3.0 -terminado==0.15.0 -tinycss2==1.1.1 -tomli==2.0.1 -tornado==6.3.3 -traitlets==5.3.0 -twine==4.0.1 -typing_extensions==4.3.0 -urllib3==1.26.18 -wcwidth==0.2.5 -webencodings==0.5.1 -widgetsnbextension==3.6.1 -zipp==3.8.1 diff --git a/setup.cfg b/setup.cfg index bc61012..abb7764 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,11 +1,11 @@ [metadata] name = croissant-sim -version = 3.0.0 +version = 4.0.0 description = CROISSANT: Rapid spherical harmonics-based simulator of visibilities long_description = file: README.md author = Christian Hellum Bye author_email = chbye@berkeley.edu -license = GPLv2 +license = MIT url = https://github.com/christianhbye/croissant classifiers = Intended Audience :: Science/Research @@ -15,18 +15,17 @@ classifiers = [options] -python_requires = >= 3.7 +python_requires = >= 3.8 packages=find: install_requires = astropy - healpy hera-filters == 0.1.1 jupyter lunarsky matplotlib numpy <= 1.23 - pygdsm - scipy + pygdsm == 1.5.0 + s2fft @ git+https://github.com/astro-informatics/s2fft.git [options.extras_require] dev = @@ -45,4 +44,6 @@ hera_sim = ignore = E203, W503 per-file-ignores = __init__.py:F401 + croissant/core/__init__.py:F401 + croissant/jax/__init__.py:E402, F401 max-line-length = 79