From 86b86206888948b2850a45599ed9c6cf94552168 Mon Sep 17 00:00:00 2001 From: Tennessee Leeuwenburg Date: Tue, 4 Nov 2025 18:04:25 +1100 Subject: [PATCH 1/4] End-to-end demonstration of point database using Marimo notebooks. TODO: Tidy up jupyter notebook versions and work out how this affects docs --- notebooks/scorecard/ChunkByDecade.py | 114 +++++++++++++ notebooks/scorecard/CombineAllGroups_copy.py | 109 ++++++++++++ notebooks/scorecard/Data Visualisation.py | 105 ++++++++++++ notebooks/scorecard/DataAccessor.py | 160 ++++++++++++++++++ notebooks/scorecard/Introduction.py | 74 ++++++++ notebooks/scorecard/MakeLargeGroupings.py | 109 ++++++++++++ notebooks/scorecard/StationDownload.py | 130 ++++++++++++++ .../data/download/weatherbench.py | 19 ++- 8 files changed, 814 insertions(+), 6 deletions(-) create mode 100644 notebooks/scorecard/ChunkByDecade.py create mode 100644 notebooks/scorecard/CombineAllGroups_copy.py create mode 100644 notebooks/scorecard/Data Visualisation.py create mode 100644 notebooks/scorecard/DataAccessor.py create mode 100644 notebooks/scorecard/Introduction.py create mode 100644 notebooks/scorecard/MakeLargeGroupings.py create mode 100644 notebooks/scorecard/StationDownload.py diff --git a/notebooks/scorecard/ChunkByDecade.py b/notebooks/scorecard/ChunkByDecade.py new file mode 100644 index 00000000..6870e5fd --- /dev/null +++ b/notebooks/scorecard/ChunkByDecade.py @@ -0,0 +1,114 @@ +import marimo + +__generated_with = "0.17.6" +app = marimo.App(width="medium") + + +@app.cell +def _(): + import tarfile + import gzip + import shutil + from pathlib import Path + import numpy as np + from datetime import datetime + import warnings + warnings.simplefilter(action='ignore', category=FutureWarning) + import marimo as mo + import os + + from dask.distributed import Client + import xarray as xr + return Path, datetime, os, xr + + +@app.cell +def _(Path): + UNPACKED_DIR = Path.home() / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives + PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing + return PROCESSING_DIR, UNPACKED_DIR + + +@app.cell +def _(UNPACKED_DIR): + files = list(UNPACKED_DIR.glob('*.nc')) + len(files) + return (files,) + + +@app.cell +def _(xr): + + def simplify(ds): + lats = xr.DataArray(data=[ds.latitude.values[0]] * len(ds.time), coords={'time': ds.time}) + lons = xr.DataArray(data=[ds.longitude.values[0]] * len(ds.time), coords={'time': ds.time}) + elev = xr.DataArray(data=[ds.elevation.values[0]] * len(ds.time), coords={'time': ds.time}) + ds = ds.reset_coords(names=('latitude', 'longitude', 'elevation'), drop=True) + ds['lat'] = lats + ds['lon'] = lons + ds['elev'] = elev + + ds = ds.drop_attrs() + return ds + return (simplify,) + + +@app.cell +def _(files): + filegroups = [files[i:i + 10] for i in range(0, len(files), 10)] + print(len(filegroups)) # We come up with 134 such file groupings from the test data + return (filegroups,) + + +@app.cell +def _(): + decades = [('1800', '1930'), # Just in case there is undocumented early data + ('1930', '1940'), ('1940', '1950'), # Dataset begins in 1930, start by decade here + ('1950', '1960'), ('1960', '1970'), ('1970', '1980'), + ('1980', '1990'), ('1990', '2000'), ('2000', '2010'), # 1980 is a common time to start from + ('2010', '2020'), ('2020', '2030') + ] + return (decades,) + + +@app.cell +def _(PROCESSING_DIR, datetime, decades, filegroups, os, simplify, xr): + # This takes around 20-30 seconds per grouping. If you just want to get the hang of it, limit it to three groupings + # Otherwise, the test set have 67 groupings, so will take around half an hour to run + # The full set of stations will take several hours. + + # For testing, just try three file groups + + # for i, fg in enumerate(filegroups[3]): # Use me to test three file groupings + for i, fg in enumerate(filegroups): # Use me to process all downloaded data + print(f"Processing group {i} of {len(filegroups)}") + print(datetime.now().time()) + loaded = [xr.open_dataset(f, engine='h5netcdf') for f in fg] + simplified = [simplify(_ds) for _ds in loaded] + merged = xr.concat(simplified, dim='report') + + for d in decades: + decadal = merged.sel(time=slice(*d)) + if len(decadal.time): + filename = PROCESSING_DIR / f'{d[0]}-{d[1]}-sg{i}.nc' + if not os.path.exists(filename): + decadal.to_netcdf(filename) + else: + print(f"{filename} exists, skipping") + return + + +@app.cell +def _(): + + print('done') + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/notebooks/scorecard/CombineAllGroups_copy.py b/notebooks/scorecard/CombineAllGroups_copy.py new file mode 100644 index 00000000..f7485904 --- /dev/null +++ b/notebooks/scorecard/CombineAllGroups_copy.py @@ -0,0 +1,109 @@ +import marimo + +__generated_with = "0.17.0" +app = marimo.App(width="medium") + + +@app.cell +def _(): + import tarfile + import gzip + import shutil + from pathlib import Path + import numpy as np + from datetime import datetime + import warnings + warnings.simplefilter(action='ignore', category=FutureWarning) + import marimo as mo + + from dask.distributed import Client + import xarray as xr + return Path, datetime, xr + + +@app.cell +def _(Path): + UNPACKED_DIR = Path.home() / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives + PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing + return PROCESSING_DIR, UNPACKED_DIR + + +@app.cell +def _(UNPACKED_DIR): + files = list(UNPACKED_DIR.glob('*.nc')) + len(files) + return (files,) + + +@app.cell +def _(xr): + + def simplify(ds): + lats = xr.DataArray(data=[ds.latitude.values[0]] * len(ds.time), coords={'time': ds.time}) + lons = xr.DataArray(data=[ds.longitude.values[0]] * len(ds.time), coords={'time': ds.time}) + elev = xr.DataArray(data=[ds.elevation.values[0]] * len(ds.time), coords={'time': ds.time}) + ds = ds.reset_coords(names=('latitude', 'longitude', 'elevation'), drop=True) + ds['lat'] = lats + ds['lon'] = lons + ds['elev'] = elev + + ds = ds.drop_attrs() + return ds + return (simplify,) + + +@app.cell +def _(files): + filegroups = [files[i:i + 10] for i in range(0, len(files), 10)] + print(len(filegroups)) # We come up with 134 such file groupings from the test data + return (filegroups,) + + +@app.cell +def _(): + decades = [('1800', '1930'), # Just in case there is undocumented early data + ('1930', '1940'), ('1940', '1950'), # Dataset begins in 1930, start by decade here + ('1950', '1960'), ('1960', '1970'), ('1970', '1980'), + ('1980', '1990'), ('1990', '2000'), ('2000', '2010'), # 1980 is a common time to start from + ('2010', '2020'), ('2020', '2030') + ] + return (decades,) + + +@app.cell +def _(PROCESSING_DIR, datetime, decades, filegroups, simplify, xr): + # This takes around 20-30 seconds per grouping. If you just want to get the hang of it, limit it to three groupings + # Otherwise, the test set have 67 groupings, so will take around half an hour to run + # The full set of stations will take several hours. + + # Let's just do 3 filegroups and 3 decades + # for i, fg in enumerate(filegroups[3]): # Uncomment me for testing + for i, fg in enumerate(filegroups): + print(f"Processing group {i} of {len(filegroups)}") + print(datetime.now().time()) + lista = [xr.open_dataset(f, engine='h5netcdf') for f in fg] + listb = [simplify(_ds) for _ds in lista] + listc = xr.concat(listb, dim='report') + + for d in decades: + decadal = listc.sel(time=slice(*d)) + if len(decadal.time): + filename = PROCESSING_DIR / f'{d[0]}-{d[1]}-sg{i}.nc' + decadal.to_netcdf(filename) + return + + +@app.cell +def _(): + + print('done') + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/notebooks/scorecard/Data Visualisation.py b/notebooks/scorecard/Data Visualisation.py new file mode 100644 index 00000000..f283c6c1 --- /dev/null +++ b/notebooks/scorecard/Data Visualisation.py @@ -0,0 +1,105 @@ +import marimo + +__generated_with = "0.17.6" +app = marimo.App(width="medium") + + +@app.cell +def _(): + import xarray as xr + from pathlib import Path + + DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' # This will hold the final form of our data + return DECADAL_DIR, xr + + +@app.cell +def _(DECADAL_DIR): + list(DECADAL_DIR.glob('*1990s*.nc')) + return + + +@app.cell +def _(DECADAL_DIR, xr): + ds = xr.open_dataset(list(DECADAL_DIR.glob('*1990s*.nc'))[3]) + ds + + + return (ds,) + + +@app.cell +def _(): + + # ds = xr.open_mfdataset(list(DECADAL_DIR.glob('*1990s*.nc')), combine='nested', concat_dim='report') + # ds + return + + +@app.cell +def _(): + import matplotlib.pyplot as plt + return + + +@app.cell +def _(ds): + sample = ds.sel({'time': '1990-06-01T00'}) + sample = sample.assign_coords({'report': sample.report}) + return (sample,) + + +@app.cell +def _(sample): + sample.sel({'report': 0}) + return + + +@app.cell +def _(sample): + sample.report + return + + +@app.cell +def _(sample): + + import folium + + m = folium.Map(location=(45.5236, -122.6750)) + import numpy as np + + for report in sample.report: + lat = sample.sel({'report': report}).lat.values + lon = sample.sel({'report': report}).lon.values + + if not np.isnan(lat): + + try: + + folium.Marker( + location=[lat, lon], + icon=folium.Icon(icon="cloud"), + ).add_to(m) + + except: + print(lat) + + raise + + return (m,) + + +@app.cell +def _(m): + m + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/notebooks/scorecard/DataAccessor.py b/notebooks/scorecard/DataAccessor.py new file mode 100644 index 00000000..b27295cd --- /dev/null +++ b/notebooks/scorecard/DataAccessor.py @@ -0,0 +1,160 @@ +import marimo + +__generated_with = "0.17.6" +app = marimo.App(width="medium") + + +@app.cell +def _(): + + import pyearthtools.data + import pyearthtools.pipeline + from pyearthtools.data import Petdt + + from pathlib import Path + DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' + + from mpl_toolkits.basemap import Basemap + return Basemap, DECADAL_DIR, Path, Petdt, pyearthtools + + +@app.cell +def _(Path, Petdt): + from pyearthtools.data.archive import register_archive + from pyearthtools.data.exceptions import DataNotFoundError + from pyearthtools.data.indexes import ArchiveIndex, decorators + from pyearthtools.data.transforms import Transform, TransformCollection + import xarray as xr + import numpy as np + + @register_archive("ISD", sample_kwargs=dict(variable="2t")) + class ISD(ArchiveIndex): + @property + def _desc_(self): + return { + "singleline": "Hadley Integrated Surface Database", + "range": "1930 - 2025", + "Documentation": "https://www.metoffice.gov.uk/hadobs/hadisd/", + } + + def __init__( + self, + disk_location, + *, + transforms: Transform | TransformCollection | None = None, + ): + + self.disk_location = Path(disk_location) # Location of the large groupings files + super().__init__(transforms=transforms or TransformCollection()) + + def filesystem(self, querytime: str | Petdt): + ''' + This is quick, no need to cache it + ''' + files = list(self.disk_location.glob('*1990*.nc')) + return files + + def load(self, from_files_list, **kwargs): + + ds = xr.open_mfdataset(from_files_list, combine='nested', concat_dim='report') + + # Arguably, this should be a transform, or handled in the pipeline, but it works for now + ds['temperatures'] = ds.temperatures.where(ds.temperatures > -1000) + return ds + return ISD, np + + +@app.cell +def _(DECADAL_DIR, ISD): + stations = ISD(DECADAL_DIR) + return (stations,) + + +@app.cell +def _(stations): + ds = stations['1990-06-20T01'] + ds + return (ds,) + + +@app.cell +def _(Petdt): + Petdt('1990-06-20').datetime.year + return + + +@app.cell +def _(ds): + import plotly.express as px + + px.scatter(ds.temperatures.values[0]) + return + + +@app.cell +def _(DECADAL_DIR, ISD, Path, pyearthtools): + workdir = Path("~/dev/data/wb2era5/") + era5_source = pyearthtools.data.download.weatherbench.WB2ERA5( + variables=["2m_temperature", "u", "v", "geopotential"], + level=[850], + download_dir=workdir / "download", + license_ok=True, + ), + + station_source = ISD(DECADAL_DIR) + + data_pipeline = pyearthtools.pipeline.Pipeline( + (era5_source, station_source) + ) + return (data_pipeline,) + + +@app.cell +def _(data_pipeline): + data_pipeline['19900620T00'] + return + + +@app.cell +def _(data_pipeline): + grid, points = data_pipeline['19900620T00'] + return grid, points + + +@app.cell +def _(grid, np): + # Transform gridded data for plotting + lats = grid['latitude'].values + lons = grid['longitude'].values + data = grid['2m_temperature'].values[0] # Replace with your variable name + lon, lat = np.meshgrid(lons, lats) + return data, lat, lon + + +@app.cell +def _(Basemap, data, lat, lon, points): + map = Basemap(projection='merc',llcrnrlat=-80,urcrnrlat=80,\ + llcrnrlon=0,urcrnrlon=360,lat_ts=20,resolution='l') + # draw coastlines, country boundaries, fill continents. + map.drawcoastlines(linewidth=0.25) + map.drawcountries(linewidth=0.25) + + x, y = map(lon, lat) + + + # # Add station data over the top + x2, y2 = map(points.lon, points.lat) + + map.contourf(x, y, data.T, cmap='viridis') + map.scatter(x2, y2, c=points.temperatures, cmap='viridis') + + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/notebooks/scorecard/Introduction.py b/notebooks/scorecard/Introduction.py new file mode 100644 index 00000000..35537b25 --- /dev/null +++ b/notebooks/scorecard/Introduction.py @@ -0,0 +1,74 @@ +import marimo + +__generated_with = "0.17.6" +app = marimo.App(width="medium", auto_download=["ipynb"]) + + +@app.cell +def _(): + # https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html + return + + +@app.cell +def _(): + import marimo as mo + return (mo,) + + +@app.cell(hide_code=True) +def _(mo): + mo.md(r""" + This dataset holds the world's weather station data up until late 2025. + + ![Image of weather stations]([public/image.png](https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/images/hadisd_gridded_station_distribution_v343_2025f.png)) + + For futher information please see: + + - Dunn, R. J. H., (2019), HadISD version 3: monthly updates, Hadley Centre Technical Note + - Dunn, R. J. H., et al. (2016), Expanding HadISD: quality-controlled, sub-daily station data from 1931, Geoscientific Instrumentation, Methods and Data Systems, 5, 473-491 + - Dunn, R. J. H., et al. (2014), Pairwise homogeneity assessment of HadISD, Climate of the Past, 10, 1501-1522 + - Dunn, R. J. H., et al. (2012), HadISD: A Quality Controlled global synoptic report database for selected variables at long-term stations from 1973-2011, Climate of the Past, 8, 1649-1679 Smith, A., et al. (2011): The Integrated Surface Database: Recent Developments and Partnerships. Bulletin of the American Meteorological Society, 92, 704-708 + + + For the product manual, see [https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf](https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf) + + It's an amazing scientific archive. The data is held in a collection of .tgz files, based on station ranges. These files contains smaller station sub-ranges, themselves gzipped netcdf files. We need to download the ones we want (potentially all of them), then double-unwrap them, and then put them into a more performant file format for quick access by time index when performing ML training or long historical verification runs. + + Eventually, we want to present these efficiently as a PyEarthTools data accessor which can be quickly indexed by time. An alternative data accessor based on station ID rather than time could be imagined, but we will focus on access by time in this tutorial series. + + Despite being packed into NetCDF files -- which is often used for lat/lon/level/time gridded data -- this data is better visualised as just one massive long list of report entries in a big logbook. Each report is a slightly more complex version of "time, station_id, lat, lon, elevation, bunch of obs data". + + Many underlying issues have been sorted out, like stations reporting twice under two ids, changing ids, station upgrades/replacements, plain old errors, sensor quality control and more. Many stations only report for some of the time period, some only once or for a short time, some for a very long time. What we want to do is get this into a good form for time-series use by an ML algorithm. The files on disk are roughly organised by nominal station number, for all time. So if you know what stations you want to work with, you could just pick those files. But let's face it, who wants to take the time to understand the mysterious workings of station numbers - at least at first? + + Singe station time-series modelling is a totally valid use case - e.g. fetching "station data for Melbourne from 2020 to 2025". That's fairly straightforward - manually look up the station number of interest, find it in the files, open that files with xarray and then select the time-frame of interest. + + Doing the same thing for a handful of stations is also not too bad. Each station file is only a few megabytes, so opening 5 of them isn't a big deal. However, opening all of them becomes a bigger deal, and trying to merge them all together using simple merge and concat operations will cause a computational failure on most platforms (including HPC platforms). Some data processing is required in order to prepare the data for the time of query we want to use. + + Translating between the 'gridded world' or global and regional modelling and the 'station world' is often done by performing a site-based forecast based on gridded inputs (e.g. siteboost or model output statistics). The translation of station data to a gridded model is done through data assimilation. These two ways of working with the data have significant implications for the data structures which will be used, and for computational efficiency. It would be really nice to have a simple API which could abstract away the messy choices, implement the tricky bits and make it easy to just 'get what we want'. + + From a PyEarthTools perspective based on wanting to develop model architectures which include both gridded and point data at the same time (rather than having a 'translation step'), this means getting the data into a structure where the primary index is date-and-time, and all relevant stations are loaded into that data structure. However, the data still can't be simply gridded, as it more represents a point cloud at each moment in time. A few decisions need to be make still. We will keep things "simple" by representing the data for each time step as a list of observation reports from all stations reporting at that time, with a small time delta allowed for stations reporting a few seconds off the base time due to engineering tolerences or other reasons. The "list to grid" step will be handled either the model, or in an observation operator step to be developed at a later time. + + This tutorial series contains the code (and explanation) for how to download the data from the Hadley Centre website, unpack it, and then re-process it on disk to have a structure which is well-suited for efficient access in the manner just described. + + The tutorials are structured in a sequence, each with a specific scope. They are: + + 1. Downloading the data in the form distributed by the Hadley centre + 2. Manual unpack of the data on disk for efficiency reasons (see instructions at the end of StationDownload) + 3. Re-processing of the station data to break it up by decade for file size reasons + 4. Grouping of individual stations into large station groupings to reduce the number of files on disk + 5. Data visualisation of the global station data to demonstrate what it looks like this way + 6. (to be done) Integration of this data into PyEarthTools data accessor + 7. (to be done) Integration of station data into a PyEarthTools pipeline + 8. (to be done) Presentation of gridded data and station data to a neural network for training and prediction + """) + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/notebooks/scorecard/MakeLargeGroupings.py b/notebooks/scorecard/MakeLargeGroupings.py new file mode 100644 index 00000000..588cc76c --- /dev/null +++ b/notebooks/scorecard/MakeLargeGroupings.py @@ -0,0 +1,109 @@ +import marimo + +__generated_with = "0.17.6" +app = marimo.App(width="medium", auto_download=["ipynb"]) + + +@app.cell +def _(): + # https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html + return + + +@app.cell +def _(): + from pathlib import Path + import numpy as np + from datetime import datetime + import warnings + warnings.simplefilter(action='ignore', category=FutureWarning) + import marimo as mo + + from dask.distributed import Client + import xarray as xr + return Path, xr + + +@app.cell +def _(Path): + # A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work. + + PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing + DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' # This will hold the final form of our data + return DECADAL_DIR, PROCESSING_DIR + + +@app.cell +def _(): + decades = { + 'early': ('1800', '1930'), # Just in case there is undocumented early data + '1930': ('1930', '1940'), # Dataset begins in 1930, start by decade here + '1940': ('1940', '1950'), + '1950': ('1950', '1960'), + '1960': ('1960', '1970'), + '1970': ('1970', '1980'), + '1980': ('1980', '1990'), + '1990': ('1990', '2000'), + '2000': ('2000', '2010'), + '2010': ('2010', '2020'), + '2020': ('2020', '2030') + } + return (decades,) + + +@app.cell +def _(PROCESSING_DIR, decades): + files_for_decades = {} + + for ix in decades.keys(): + start_dec, end_dec = decades[ix] + _files_for_decade = list(PROCESSING_DIR.glob(f'*{start_dec}-{end_dec}*.nc')) + files_for_decades[ix] = _files_for_decade + + # Uncomment this to see values for debugging + # the1950s = files_for_decades['1950'] + # the1950s + return (files_for_decades,) + + +@app.cell +def _(DECADAL_DIR, files_for_decades, xr): + # This doesn't break because it's a lazy-load + # the1950s_all = [xr.open_dataset(f) for f in the1950s[:40]] + + decade_of_interest = '1990' + files_for_decade = files_for_decades[decade_of_interest] + groupings = [files_for_decade[i:i + 40] for i in range(0, len(files_for_decade), 40)] + print(f"{len(groupings)} file groupings to be used for decade {decade_of_interest}") + for i, grouping in enumerate(groupings): + loaded = [xr.open_dataset(f) for f in grouping] + print(f"Loaded group {i}") + combined = xr.concat(loaded, dim='report', data_vars='all') + combined['reporting_stats'] = combined['reporting_stats'].fillna(-999.0) + # combined = combined.chunk(time=xr.groupers.TimeResampler("MS")) + print(f"Combined group {i}") + filename = f'all_{decade_of_interest}s_group{str(i)}.nc' + combined.to_netcdf(DECADAL_DIR / filename) + print(f"Wrote group {i}") + return (combined,) + + +@app.cell +def _(): + print('donezo all') + return + + +@app.cell +def _(combined): + combined.sel({'time': '1990-01-01'}).temperatures.plot() + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/notebooks/scorecard/StationDownload.py b/notebooks/scorecard/StationDownload.py new file mode 100644 index 00000000..31421458 --- /dev/null +++ b/notebooks/scorecard/StationDownload.py @@ -0,0 +1,130 @@ +import marimo + +__generated_with = "0.17.6" +app = marimo.App(width="medium") + + +@app.cell +def _(): + # A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work. + + import requests + from pathlib import Path + from tqdm.auto import tqdm + + DOWNLOAD_DIR = Path.home() / 'hadisd' / 'as_downloaded' # We will download data here and keep a copy + + # For testing, we download just under 4GB data + testing_download = [ + "000000-029999", "500000-549999", "722000-722999", "800000-849999", + ] + + # Download list for all files + full_download = [ + "000000-029999", "030000-049999", "050000-079999", "080000-099999", + "100000-149999", "150000-199999", "200000-249999", "250000-299999", + "300000-349999", "350000-399999", "400000-449999", "450000-499999", + "500000-549999", "550000-599999", "600000-649999", "650000-699999", + "700000-709999", "710000-714999", "715000-719999", "720000-721999", + "722000-722999", "723000-723999", "724000-724999", "725000-725999", + "726000-726999", "727000-729999", "730000-799999", "800000-849999", + "850000-899999", "900000-949999", "950000-999999", + ] + return DOWNLOAD_DIR, full_download, requests, tqdm + + +@app.cell +def _(requests, tqdm): + def download_wmo_range(wmo_id_range, download_dir): + wmo_str = f"WMO_{wmo_id_range}" + url = f"https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/data/{wmo_str}.tar.gz" + tar_name = f"{wmo_str}.tar.gz" + filename = download_dir / tar_name + + head = requests.head(url, allow_redirects=True) + remote_size = int(head.headers.get('content-length', 0)) + local_size = filename.stat().st_size if filename.exists() else 0 + + if filename.exists() and local_size == remote_size: + print(f"File already fully downloaded: {filename} ({local_size/1024**2:.2f} MB)") + elif filename.exists() and local_size != remote_size: + # Users may have done this deliberately, so just print a message + print(f"Local filesize of {filename} does not match, please delete it and re-download it") + else: + headers = {} + mode = 'wb' + initial_pos = 0 + if filename.exists() and local_size < remote_size: + headers['Range'] = f'bytes={local_size}-' + mode = 'ab' + initial_pos = local_size + print(f"Resuming download for {filename.name} at {local_size/1024**2:.2f} MB...") + else: + print(f"Starting download for {filename.name}...") + + response = requests.get(url, stream=True, headers=headers) + total = remote_size + with open(filename, mode) as f, tqdm( + desc=f"Downloading {filename.name}", + total=total, + initial=initial_pos, + unit='B', unit_scale=True, unit_divisor=1024 + ) as bar: + for chunk in response.iter_content(chunk_size=8192): + if chunk: + f.write(chunk) + bar.update(len(chunk)) + + final_size = filename.stat().st_size + if final_size == remote_size: + print(f"Download complete: {filename} ({final_size/1024**2:.2f} MB)") + else: + print(f"Warning: Download incomplete. Local size: {final_size}, Remote size: {remote_size}") + + return filename, tar_name + return (download_wmo_range,) + + +@app.cell +def _(DOWNLOAD_DIR, download_wmo_range, full_download): + # for wrange in testing_download: + # download_wmo_range(wrange, DOWNLOAD_DIR) + + # FOR FULL STATION DOWNLOAD + # Note, if at NCI doing the hackathon, use the pre-downloaded data + + for wrange in full_download: + download_wmo_range(wrange, DOWNLOAD_DIR) + return + + +@app.cell +def _(): + # The next step is easiest to do manually, and is a bit awkward to put in a notebook step. + + # First, go to your top-level download directory. Make a new directory called 'unpacked', then run the following command. + # This will result in a lot of individual .nc.gz files on disK + + # `for file in *.tar.gz; do tar -xzf "$file" --directory ../unpacked; done` + + # Once this is down, change directory into the unpacked directory and run + + # `gunzip *` + + # This is much faster for some reason than trying to use Python to get the job done. + return + + +@app.cell +def _(): + print("download completed)") + return + + +@app.cell +def _(): + return + + +if __name__ == "__main__": + app.run() diff --git a/packages/data/src/pyearthtools/data/download/weatherbench.py b/packages/data/src/pyearthtools/data/download/weatherbench.py index a90d2f99..3bd97f37 100644 --- a/packages/data/src/pyearthtools/data/download/weatherbench.py +++ b/packages/data/src/pyearthtools/data/download/weatherbench.py @@ -1,8 +1,9 @@ -import sys -import logging -import textwrap import hashlib +import logging +import os import shutil +import sys +import textwrap from pathlib import Path from typing import Literal @@ -11,11 +12,11 @@ from numcodecs.blosc import Blosc from tqdm.dask import TqdmCallback -from pyearthtools.data.time import Petdt from pyearthtools.data.indexes import AdvancedTimeDataIndex, decorators from pyearthtools.data.indexes.utilities import spellcheck -from pyearthtools.data.transforms.transform import Transform, TransformCollection +from pyearthtools.data.time import Petdt from pyearthtools.data.transforms.coordinates import Select +from pyearthtools.data.transforms.transform import Transform, TransformCollection def _extract_dataset_infos(url: str) -> tuple[dict[str, str | None], list[int]]: @@ -106,6 +107,8 @@ def _save_variable(darr: xr.DataArray, path: Path): logger.info(f"Incomplete download of {varname} found, removing folder {zarrpath}.") shutil.rmtree(zarrpath) + zarrpath = zarrpath.expanduser() + compressor = {"compressor": Blosc(cname="zstd", clevel=6)} zarr_kwargs = {"encoding": {darr.name: compressor}, "consolidated": False} @@ -113,9 +116,11 @@ def _save_variable(darr: xr.DataArray, path: Path): logger.info(f"Saving {varname} under {zarrpath}, it will take at most {dsarr_size:.2f} {unit} of storage space.") disable_bar = logger.getEffectiveLevel() > logging.INFO + with TqdmCallback(desc="Writing", disable=disable_bar): darr.to_zarr(zarrpath, **zarr_kwargs) + canary_file = zarrpath / ".completed" canary_file.touch() logger.info(f"Saving {varname} finished.") @@ -155,6 +160,8 @@ def open_local_dataset(path: Path, variables: list[str], level: list[int]) -> xr """Open a locally saved dataset made of 1 zarr folder per variable and level""" logger = logging.getLogger(__name__) + path = path.expanduser() + dsets = [] for varname in variables: filepath = path / f"{varname}.zarr" @@ -164,7 +171,7 @@ def open_local_dataset(path: Path, variables: list[str], level: list[int]) -> xr else: filelist = [path / f"{varname}_level-{lvl}.zarr" for lvl in level] if any(not (fpath / ".completed").is_file() for fpath in filelist): - raise MissingVariableFile("Missing .zarr folder for some variables") + raise MissingVariableFile(f"Missing .zarr folder for some variables - see {filelist}") logger.debug(f"Loading {varname} variable from folders {[str(p) for p in filelist]}.") dset = xr.open_mfdataset(filelist, concat_dim="level", combine="nested", consolidated=False) dsets.append(dset) From dd0ccd6202ebdc19a5f1b2a6627c876b6ed06d87 Mon Sep 17 00:00:00 2001 From: Tennessee Leeuwenburg Date: Tue, 4 Nov 2025 18:28:29 +1100 Subject: [PATCH 2/4] Replace marimo notebooks with jupyter notebooks to align with docs and general tech stack --- notebooks/scorecard/ChunkByDecade.py | 114 ------- notebooks/scorecard/CombineAllGroups_copy.py | 109 ------- notebooks/scorecard/Data Visualisation.py | 105 ------- notebooks/scorecard/DataAccessor.py | 160 ---------- notebooks/scorecard/Five-DataAccessor.ipynb | 287 ++++++++++++++++++ .../scorecard/Four-MakeLargeGroupings.ipynb | 147 +++++++++ notebooks/scorecard/Introduction.py | 74 ----- notebooks/scorecard/MakeLargeGroupings.py | 109 ------- notebooks/scorecard/One-Introduction.ipynb | 92 ++++++ notebooks/scorecard/StationDownload.py | 130 -------- .../scorecard/Three-SmallChunksByDecade.ipynb | 191 ++++++++++++ notebooks/scorecard/Two-DataDownload.ipynb | 196 ++++++++++++ 12 files changed, 913 insertions(+), 801 deletions(-) delete mode 100644 notebooks/scorecard/ChunkByDecade.py delete mode 100644 notebooks/scorecard/CombineAllGroups_copy.py delete mode 100644 notebooks/scorecard/Data Visualisation.py delete mode 100644 notebooks/scorecard/DataAccessor.py create mode 100644 notebooks/scorecard/Five-DataAccessor.ipynb create mode 100644 notebooks/scorecard/Four-MakeLargeGroupings.ipynb delete mode 100644 notebooks/scorecard/Introduction.py delete mode 100644 notebooks/scorecard/MakeLargeGroupings.py create mode 100644 notebooks/scorecard/One-Introduction.ipynb delete mode 100644 notebooks/scorecard/StationDownload.py create mode 100644 notebooks/scorecard/Three-SmallChunksByDecade.ipynb create mode 100644 notebooks/scorecard/Two-DataDownload.ipynb diff --git a/notebooks/scorecard/ChunkByDecade.py b/notebooks/scorecard/ChunkByDecade.py deleted file mode 100644 index 6870e5fd..00000000 --- a/notebooks/scorecard/ChunkByDecade.py +++ /dev/null @@ -1,114 +0,0 @@ -import marimo - -__generated_with = "0.17.6" -app = marimo.App(width="medium") - - -@app.cell -def _(): - import tarfile - import gzip - import shutil - from pathlib import Path - import numpy as np - from datetime import datetime - import warnings - warnings.simplefilter(action='ignore', category=FutureWarning) - import marimo as mo - import os - - from dask.distributed import Client - import xarray as xr - return Path, datetime, os, xr - - -@app.cell -def _(Path): - UNPACKED_DIR = Path.home() / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives - PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing - return PROCESSING_DIR, UNPACKED_DIR - - -@app.cell -def _(UNPACKED_DIR): - files = list(UNPACKED_DIR.glob('*.nc')) - len(files) - return (files,) - - -@app.cell -def _(xr): - - def simplify(ds): - lats = xr.DataArray(data=[ds.latitude.values[0]] * len(ds.time), coords={'time': ds.time}) - lons = xr.DataArray(data=[ds.longitude.values[0]] * len(ds.time), coords={'time': ds.time}) - elev = xr.DataArray(data=[ds.elevation.values[0]] * len(ds.time), coords={'time': ds.time}) - ds = ds.reset_coords(names=('latitude', 'longitude', 'elevation'), drop=True) - ds['lat'] = lats - ds['lon'] = lons - ds['elev'] = elev - - ds = ds.drop_attrs() - return ds - return (simplify,) - - -@app.cell -def _(files): - filegroups = [files[i:i + 10] for i in range(0, len(files), 10)] - print(len(filegroups)) # We come up with 134 such file groupings from the test data - return (filegroups,) - - -@app.cell -def _(): - decades = [('1800', '1930'), # Just in case there is undocumented early data - ('1930', '1940'), ('1940', '1950'), # Dataset begins in 1930, start by decade here - ('1950', '1960'), ('1960', '1970'), ('1970', '1980'), - ('1980', '1990'), ('1990', '2000'), ('2000', '2010'), # 1980 is a common time to start from - ('2010', '2020'), ('2020', '2030') - ] - return (decades,) - - -@app.cell -def _(PROCESSING_DIR, datetime, decades, filegroups, os, simplify, xr): - # This takes around 20-30 seconds per grouping. If you just want to get the hang of it, limit it to three groupings - # Otherwise, the test set have 67 groupings, so will take around half an hour to run - # The full set of stations will take several hours. - - # For testing, just try three file groups - - # for i, fg in enumerate(filegroups[3]): # Use me to test three file groupings - for i, fg in enumerate(filegroups): # Use me to process all downloaded data - print(f"Processing group {i} of {len(filegroups)}") - print(datetime.now().time()) - loaded = [xr.open_dataset(f, engine='h5netcdf') for f in fg] - simplified = [simplify(_ds) for _ds in loaded] - merged = xr.concat(simplified, dim='report') - - for d in decades: - decadal = merged.sel(time=slice(*d)) - if len(decadal.time): - filename = PROCESSING_DIR / f'{d[0]}-{d[1]}-sg{i}.nc' - if not os.path.exists(filename): - decadal.to_netcdf(filename) - else: - print(f"{filename} exists, skipping") - return - - -@app.cell -def _(): - - print('done') - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/CombineAllGroups_copy.py b/notebooks/scorecard/CombineAllGroups_copy.py deleted file mode 100644 index f7485904..00000000 --- a/notebooks/scorecard/CombineAllGroups_copy.py +++ /dev/null @@ -1,109 +0,0 @@ -import marimo - -__generated_with = "0.17.0" -app = marimo.App(width="medium") - - -@app.cell -def _(): - import tarfile - import gzip - import shutil - from pathlib import Path - import numpy as np - from datetime import datetime - import warnings - warnings.simplefilter(action='ignore', category=FutureWarning) - import marimo as mo - - from dask.distributed import Client - import xarray as xr - return Path, datetime, xr - - -@app.cell -def _(Path): - UNPACKED_DIR = Path.home() / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives - PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing - return PROCESSING_DIR, UNPACKED_DIR - - -@app.cell -def _(UNPACKED_DIR): - files = list(UNPACKED_DIR.glob('*.nc')) - len(files) - return (files,) - - -@app.cell -def _(xr): - - def simplify(ds): - lats = xr.DataArray(data=[ds.latitude.values[0]] * len(ds.time), coords={'time': ds.time}) - lons = xr.DataArray(data=[ds.longitude.values[0]] * len(ds.time), coords={'time': ds.time}) - elev = xr.DataArray(data=[ds.elevation.values[0]] * len(ds.time), coords={'time': ds.time}) - ds = ds.reset_coords(names=('latitude', 'longitude', 'elevation'), drop=True) - ds['lat'] = lats - ds['lon'] = lons - ds['elev'] = elev - - ds = ds.drop_attrs() - return ds - return (simplify,) - - -@app.cell -def _(files): - filegroups = [files[i:i + 10] for i in range(0, len(files), 10)] - print(len(filegroups)) # We come up with 134 such file groupings from the test data - return (filegroups,) - - -@app.cell -def _(): - decades = [('1800', '1930'), # Just in case there is undocumented early data - ('1930', '1940'), ('1940', '1950'), # Dataset begins in 1930, start by decade here - ('1950', '1960'), ('1960', '1970'), ('1970', '1980'), - ('1980', '1990'), ('1990', '2000'), ('2000', '2010'), # 1980 is a common time to start from - ('2010', '2020'), ('2020', '2030') - ] - return (decades,) - - -@app.cell -def _(PROCESSING_DIR, datetime, decades, filegroups, simplify, xr): - # This takes around 20-30 seconds per grouping. If you just want to get the hang of it, limit it to three groupings - # Otherwise, the test set have 67 groupings, so will take around half an hour to run - # The full set of stations will take several hours. - - # Let's just do 3 filegroups and 3 decades - # for i, fg in enumerate(filegroups[3]): # Uncomment me for testing - for i, fg in enumerate(filegroups): - print(f"Processing group {i} of {len(filegroups)}") - print(datetime.now().time()) - lista = [xr.open_dataset(f, engine='h5netcdf') for f in fg] - listb = [simplify(_ds) for _ds in lista] - listc = xr.concat(listb, dim='report') - - for d in decades: - decadal = listc.sel(time=slice(*d)) - if len(decadal.time): - filename = PROCESSING_DIR / f'{d[0]}-{d[1]}-sg{i}.nc' - decadal.to_netcdf(filename) - return - - -@app.cell -def _(): - - print('done') - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/Data Visualisation.py b/notebooks/scorecard/Data Visualisation.py deleted file mode 100644 index f283c6c1..00000000 --- a/notebooks/scorecard/Data Visualisation.py +++ /dev/null @@ -1,105 +0,0 @@ -import marimo - -__generated_with = "0.17.6" -app = marimo.App(width="medium") - - -@app.cell -def _(): - import xarray as xr - from pathlib import Path - - DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' # This will hold the final form of our data - return DECADAL_DIR, xr - - -@app.cell -def _(DECADAL_DIR): - list(DECADAL_DIR.glob('*1990s*.nc')) - return - - -@app.cell -def _(DECADAL_DIR, xr): - ds = xr.open_dataset(list(DECADAL_DIR.glob('*1990s*.nc'))[3]) - ds - - - return (ds,) - - -@app.cell -def _(): - - # ds = xr.open_mfdataset(list(DECADAL_DIR.glob('*1990s*.nc')), combine='nested', concat_dim='report') - # ds - return - - -@app.cell -def _(): - import matplotlib.pyplot as plt - return - - -@app.cell -def _(ds): - sample = ds.sel({'time': '1990-06-01T00'}) - sample = sample.assign_coords({'report': sample.report}) - return (sample,) - - -@app.cell -def _(sample): - sample.sel({'report': 0}) - return - - -@app.cell -def _(sample): - sample.report - return - - -@app.cell -def _(sample): - - import folium - - m = folium.Map(location=(45.5236, -122.6750)) - import numpy as np - - for report in sample.report: - lat = sample.sel({'report': report}).lat.values - lon = sample.sel({'report': report}).lon.values - - if not np.isnan(lat): - - try: - - folium.Marker( - location=[lat, lon], - icon=folium.Icon(icon="cloud"), - ).add_to(m) - - except: - print(lat) - - raise - - return (m,) - - -@app.cell -def _(m): - m - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/DataAccessor.py b/notebooks/scorecard/DataAccessor.py deleted file mode 100644 index b27295cd..00000000 --- a/notebooks/scorecard/DataAccessor.py +++ /dev/null @@ -1,160 +0,0 @@ -import marimo - -__generated_with = "0.17.6" -app = marimo.App(width="medium") - - -@app.cell -def _(): - - import pyearthtools.data - import pyearthtools.pipeline - from pyearthtools.data import Petdt - - from pathlib import Path - DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' - - from mpl_toolkits.basemap import Basemap - return Basemap, DECADAL_DIR, Path, Petdt, pyearthtools - - -@app.cell -def _(Path, Petdt): - from pyearthtools.data.archive import register_archive - from pyearthtools.data.exceptions import DataNotFoundError - from pyearthtools.data.indexes import ArchiveIndex, decorators - from pyearthtools.data.transforms import Transform, TransformCollection - import xarray as xr - import numpy as np - - @register_archive("ISD", sample_kwargs=dict(variable="2t")) - class ISD(ArchiveIndex): - @property - def _desc_(self): - return { - "singleline": "Hadley Integrated Surface Database", - "range": "1930 - 2025", - "Documentation": "https://www.metoffice.gov.uk/hadobs/hadisd/", - } - - def __init__( - self, - disk_location, - *, - transforms: Transform | TransformCollection | None = None, - ): - - self.disk_location = Path(disk_location) # Location of the large groupings files - super().__init__(transforms=transforms or TransformCollection()) - - def filesystem(self, querytime: str | Petdt): - ''' - This is quick, no need to cache it - ''' - files = list(self.disk_location.glob('*1990*.nc')) - return files - - def load(self, from_files_list, **kwargs): - - ds = xr.open_mfdataset(from_files_list, combine='nested', concat_dim='report') - - # Arguably, this should be a transform, or handled in the pipeline, but it works for now - ds['temperatures'] = ds.temperatures.where(ds.temperatures > -1000) - return ds - return ISD, np - - -@app.cell -def _(DECADAL_DIR, ISD): - stations = ISD(DECADAL_DIR) - return (stations,) - - -@app.cell -def _(stations): - ds = stations['1990-06-20T01'] - ds - return (ds,) - - -@app.cell -def _(Petdt): - Petdt('1990-06-20').datetime.year - return - - -@app.cell -def _(ds): - import plotly.express as px - - px.scatter(ds.temperatures.values[0]) - return - - -@app.cell -def _(DECADAL_DIR, ISD, Path, pyearthtools): - workdir = Path("~/dev/data/wb2era5/") - era5_source = pyearthtools.data.download.weatherbench.WB2ERA5( - variables=["2m_temperature", "u", "v", "geopotential"], - level=[850], - download_dir=workdir / "download", - license_ok=True, - ), - - station_source = ISD(DECADAL_DIR) - - data_pipeline = pyearthtools.pipeline.Pipeline( - (era5_source, station_source) - ) - return (data_pipeline,) - - -@app.cell -def _(data_pipeline): - data_pipeline['19900620T00'] - return - - -@app.cell -def _(data_pipeline): - grid, points = data_pipeline['19900620T00'] - return grid, points - - -@app.cell -def _(grid, np): - # Transform gridded data for plotting - lats = grid['latitude'].values - lons = grid['longitude'].values - data = grid['2m_temperature'].values[0] # Replace with your variable name - lon, lat = np.meshgrid(lons, lats) - return data, lat, lon - - -@app.cell -def _(Basemap, data, lat, lon, points): - map = Basemap(projection='merc',llcrnrlat=-80,urcrnrlat=80,\ - llcrnrlon=0,urcrnrlon=360,lat_ts=20,resolution='l') - # draw coastlines, country boundaries, fill continents. - map.drawcoastlines(linewidth=0.25) - map.drawcountries(linewidth=0.25) - - x, y = map(lon, lat) - - - # # Add station data over the top - x2, y2 = map(points.lon, points.lat) - - map.contourf(x, y, data.T, cmap='viridis') - map.scatter(x2, y2, c=points.temperatures, cmap='viridis') - - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/Five-DataAccessor.ipynb b/notebooks/scorecard/Five-DataAccessor.ipynb new file mode 100644 index 00000000..437655fb --- /dev/null +++ b/notebooks/scorecard/Five-DataAccessor.ipynb @@ -0,0 +1,287 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5499eafc-803d-46f1-9b12-5f6fff5f3e64", + "metadata": {}, + "outputs": [], + "source": [ + "import pyearthtools.data\n", + "import pyearthtools.pipeline\n", + "from pyearthtools.data import Petdt\n", + "\n", + "from pathlib import Path\n", + "DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade'\n", + "\n", + "from mpl_toolkits.basemap import Basemap" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e0072369-5c34-45ed-8582-85a401d2979f", + "metadata": {}, + "outputs": [], + "source": [ + "from pyearthtools.data.archive import register_archive\n", + "from pyearthtools.data.exceptions import DataNotFoundError\n", + "from pyearthtools.data.indexes import ArchiveIndex, decorators\n", + "from pyearthtools.data.transforms import Transform, TransformCollection\n", + "import xarray as xr\n", + "import numpy as np\n", + "\n", + "@register_archive(\"ISD\", sample_kwargs=dict(variable=\"2t\"))\n", + "class ISD(ArchiveIndex):\n", + " @property\n", + " def _desc_(self):\n", + " return {\n", + " \"singleline\": \"Hadley Integrated Surface Database\",\n", + " \"range\": \"1930 - 2025\",\n", + " \"Documentation\": \"https://www.metoffice.gov.uk/hadobs/hadisd/\",\n", + " }\n", + "\n", + " def __init__(\n", + " self,\n", + " disk_location,\n", + " *, \n", + " transforms: Transform | TransformCollection | None = None,\n", + " ):\n", + "\n", + " self.disk_location = Path(disk_location) # Location of the large groupings files\n", + " super().__init__(transforms=transforms or TransformCollection())\n", + "\n", + " def filesystem(self, querytime: str | Petdt):\n", + " '''\n", + " This is quick, no need to cache it\n", + " '''\n", + " files = list(self.disk_location.glob('*1990*.nc'))\n", + " return files\n", + "\n", + " def load(self, from_files_list, **kwargs):\n", + "\n", + " ds = xr.open_mfdataset(from_files_list, combine='nested', concat_dim='report')\n", + "\n", + " # Arguably, this should be a transform, or handled in the pipeline, but it works for now\n", + " ds['temperatures'] = ds.temperatures.where(ds.temperatures > -1000)\n", + " return ds" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0b99769d-6202-4cf9-94ea-7d4f3e4bb492", + "metadata": {}, + "outputs": [], + "source": [ + "workdir = Path.home() / \"dev/data/wb2era5/\"\n", + "era5_source = pyearthtools.data.download.weatherbench.WB2ERA5(\n", + " variables=[\"2m_temperature\", \"u\", \"v\", \"geopotential\"],\n", + " level=[850],\n", + " download_dir=workdir / \"download\",\n", + " license_ok=True,\n", + " ),\n", + "\n", + "station_source = ISD(DECADAL_DIR)\n", + "\n", + "data_pipeline = pyearthtools.pipeline.Pipeline(\n", + " (era5_source, station_source)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "533f2964-c4dc-4d94-86c9-7b5dd69e7551", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "( Size: 34kB\n", + " Dimensions: (time: 1, longitude: 64, latitude: 32, level: 1)\n", + " Coordinates:\n", + " * time (time) datetime64[ns] 8B 1990-06-20\n", + " * longitude (longitude) float64 512B 0.0 5.625 ... 348.8 354.4\n", + " * latitude (latitude) float64 256B -87.19 -81.56 ... 81.56 87.19\n", + " * level (level) int64 8B 850\n", + " Data variables:\n", + " 2m_temperature (time, longitude, latitude) float32 8kB dask.array\n", + " u_component_of_wind (time, level, longitude, latitude) float32 8kB dask.array\n", + " v_component_of_wind (time, level, longitude, latitude) float32 8kB dask.array\n", + " geopotential (time, level, longitude, latitude) float32 8kB dask.array,\n", + " Size: 464MB\n", + " Dimensions: (time: 1, report: 1334, test: 71, flagged: 19,\n", + " reporting_v: 19, reporting_t: 1140, reporting_2: 2)\n", + " Coordinates:\n", + " * time (time) datetime64[ns] 8B 1990-06-20\n", + " Dimensions without coordinates: report, test, flagged, reporting_v,\n", + " reporting_t, reporting_2\n", + " Data variables: (12/30)\n", + " station_id (time, report) |S12 16kB dask.array\n", + " temperatures (time, report) float64 11kB dask.array\n", + " dewpoints (time, report) float64 11kB dask.array\n", + " slp (time, report) float64 11kB dask.array\n", + " stnlp (time, report) float64 11kB dask.array\n", + " windspeeds (time, report) float64 11kB dask.array\n", + " ... ...\n", + " quality_control_flags (time, report, test) float64 758kB dask.array\n", + " flagged_obs (time, report, flagged) float64 203kB dask.array\n", + " reporting_stats (time, report, reporting_v, reporting_t, reporting_2) float64 462MB dask.array\n", + " lat (time, report) float64 11kB dask.array\n", + " lon (time, report) float64 11kB dask.array\n", + " elev (time, report) float64 11kB dask.array)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_pipeline['19900620T00']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "95838f20-084a-40d3-bd1d-6934c78f2482", + "metadata": {}, + "outputs": [], + "source": [ + "grid, points = data_pipeline['19900620T00']" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cb011eda-fc95-46bc-a798-97fa90676fb7", + "metadata": {}, + "outputs": [], + "source": [ + "# Transform gridded data for plotting\n", + "lats = grid['latitude'].values\n", + "lons = grid['longitude'].values\n", + "data = grid['2m_temperature'].values[0] # Replace with your variable name\n", + "lon, lat = np.meshgrid(lons, lats)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "24cdb456-b534-4216-9878-53a82508d16d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAGFCAYAAAACQ6GUAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QeYXVXVPvA1JTPpCYGQQu+9SrdhARQ/K1bs/q2o2LFhb58o2FE/FUUUC9hBBFGKdJDeewkJCQnpbdr5P78z2eHkcu/MvdOT3Pd5hpDJzL3nnrP3Ku9619oNWZZlUUcdddRRRx11rFdoHO4LqKOOOuqoo446akfdgddRRx111FHHeoi6A6+jjjrqqKOO9RB1B15HHXXUUUcd6yHqDryOOuqoo4461kPUHXgdddRRRx11rIeoO/A66qijjjrqWA/RXM0PdXV1xezZs2PChAnR0NAw+FdVRx111FFHHRspsiyLpUuXxsyZM6OxsbF/Dpzz3mqrrQby+uqoo4466qijjh7wyCOPxJZbbtk/By7zTi82ceLEqAXt7e1x6623xvz582PRokUxevToeM5znhNXXnlldHZ2xqabbhr//e9/Y/PNN49XvOIV+e888cQT8eCDD8b+++9fNjL5yU9+Eu985ztruo46esZZZ50V22+/fX7PL7jggthiiy3irrvuimOOOWbtz3z3u9+N1tbWeNvb3ha///3v4/Wvf339ttZRxyDg73//e0yZMiUOOeSQ3Ob1xnz+5z//iZ/97GfxP//zP/HsZz87pk6duvbfzjnnnHjooYfive99b4+v8cc//jF+/etfx9FHHx0vetGLYtq0afG///u/8clPfrLi7/zud7+LVatWxZvf/ObYkLFy5co48sgj4yMf+Ujuvy6++OL8z1r9YbVYsmRJnjQn31sJDdWMUvVikyZNisWLF9d8wf/4xz/yxYgOOOigg/KFeOONN8Z+++0X73jHO3J64LTTTssXCwfPqV911VUxefLk+OpXv/qU1/vVr34Vz3rWs2Lrrbeu6Trq6BmeEQNw8MEHx4wZM2Lu3Lnxxje+MX8upeUUz+w3v/lNvO51r6vf1jrqGATYZz/+8Y/jec97Xr4vv/71r/fqYP7whz/EihUr8mTopS996Vqnv3z58njXu94Vb33rW+OBBx6Il73sZbHZZpuVfZ0FCxbkNvbxxx+PnXfeOfbcc8+yiVTCmWeeGccee2xsDLjzzjvjtttuy+8rx3rEEUcM2ntV63MbB3sRypY/+tGPxiabbJJHaoz/d77znfxm3H///Wspen9/5StfuTZb//znP/+U1+NUvE7deQ88jjrqqHj729+eR99//etf841e6ryhp3pMHXXUMTCwzyQ5bKWsujdcf/318b3vfS9nSW+55Za4+uqr1/7buHHj4hnPeEaeNXIGRefNIa1evXqtvX700Udz5/GlL30p3vSmN/XovEH+t7Ecp7HrrrtGW1tbzhQPpvOuBYNqjUUqPiyH++Uvfznn8jkGNKzIzkIDzht9K0u3YD71qU9Fc3NzLFy4MI8sgfO3uFDudQw8mpqa4oUvfGHsscce+WYXxc+aNavX37N5b7755rxUUkcddfSMjo6O3AlUA/buta99bV5SVLLae++9cyd9/vnnP2W/HXroobnT9jPsLJtaxLvf/e7cKb/61a9eZ+9+61vfite85jU5df7//t//i5tuuin/2WrFyjL+urB5A3bg8J73vCfPtl/1qletLciPGTNmrXM++eSTc5qHc7Zgly1bli9YVLoai4X2/e9/Px577LG8JlTH4D6zD3zgA/H+979/bYBVir/97W9rn+03vvGNnGVRBqmjjjrKQ6b7gx/8IK8zn3766RX3VhH0J36ObfR7P/zhD/N9xi7efffdazPnIjPGxh522GFxxx135OXInsChn3vuufnrq5ErmaHDi/XznnDZZZfF05/+9I3qkX/uc5/Ly4cjBVWJ2PoDtIysWwYNSUiBKh81alT+/6jaXXbZJY8Cd9999zwDLNbQ1WQIptRm6xgaENCI/BkB2XkR99xzT15j82+enej/vvvui//7v/+riwvrqKMM2EAOMtUz2bSddtopF/X2hOOOOy7/E2OJ6WIf1UVR5WxmgmRIUkQczLnLxGXS6ujlyl6cP0p9xx13zCl1r3/55Zfnzr90vxd/R2381FNPzevj/q62vrEgy7Lc9o2kMuKgO3B17WuuuSanwxNWLl8d73zbcfHpz3587fcOPPDA/AulYzG1tLTk33/BC14w2JdYRwWMHTs2vva1r8U222yTU+upHvahD30ozjjjjDwCv/fee+P5z39+HH/88XHiiSfmtB8Fex111PEkZLU///nP42lPe1oe8HLCHCGHrqujJ6fAWXOumMw3vOENT/l3Dvu3v/1tTmerzVKEE775PR0+ypPf/OY3872cYL9yRikgkFAl0VS5oEJGf8UVV+SlNQydMuhgKbBHKq677rq8TEGMPVIw6KGExSALR4s/dPdj8dX3/CJeucfH443P+EQ8emlz/O/7fhGzH3h87c+rw6AoLrnkksG+tDp6wctf/vLcKWM/tJQRG8KcOXNyYYzn+rGPfSxnSbSayMrRgwxDHXXU8SR0d9D1qF/LfGWwslf76Nprr833Utpb6uRFEO7K/tLPlELLra6d7bbbLneqP/3pT/P3eslLXpLXzKnPi9k6yMwF5q6H9gUbKnEqJ1wVIJx00kn5a7/4xS/Of8b7jaRMdLDB/p199tl5ADOSMOgZuFqpuvdeOx4QH3zxybFi5Yq4a+EVkWWdsfX4feK8P10U1110Z5z8pw/GNjtPzxeJr9tvvz3vZ6xj+GGjErqcd955cdFFF+WRuixCj6g6nX9jiDxr5Q80Hnqwjjo2tlZMwk891OVYKG2X/p1Dlc3ZL5TmWCstYOrXnATn6N/sLbT4+PHjcydtX5WrOevOoUvxvhy3bhJQ2xYsyP7f8pa3rPM7ggHCYqB3ASXMUvh9P/vtb3873/cbK77yla/kDEql8sJwYUhCKJHgq178hrh93uURXRHtXatiTPOkeGT5rbF89aKcUv/ux3+b13gI2mRwakYp46tjZDhxBkI2rq2FKBFVJ9hiYJKoTY8+I1JHHRsLUNecn95gsy20YZbLlmWy//znP/NSVNovWpP0esvwKMtl32rlunc4WLMxQLaODuf8/SwoN+rcsRftTToUAQGccsopeVD9i1/8oqzw134+/PDD88wePe+12dx03UpjMnnC4ec+97kbtfMGn7/a7oENzoE3t4+PtsVNseWYPWPB6kdj4qipMaZ5YowfNSXmrrovVrevjNuveyDO+s0fc/GUCTQGF/z73/8eisurow9gLPbdd9+nfJ8BYNDqqGNjAOdHD0L8JVsG9Hi55EN/NbZKm6x6chHobzS27DvpT9Savbbf22GHHdZmguhwjpeuiOP1XmhtCmmDWHwfG5BeR1BRCQIJWaUAROaeaHElTH/XFVRH5EFQer4bnQN/5N65seW43WP2ijvj0eW3xzbj942lbfOjqaE5thq3V4xqbM1/rqlrdB5hEl+og1uYqKY6RhZEoja6jS/6lzUYJMEIEM9gXOqoY2MAB+mLI7UXknisHIUu09Yea1SxfmstYWrQnDFFty9slqDA91K91feAbdSyiRr3PkakaikjXLMHdYUYmnXppZfGbrvt1msbGXD2dEqEqIJy8N5JRFzHyMaQcJ1jxrVGY0NTbNq6VazqXB6PLL8lZozdJcaP2mTtzyxrXxDjJ+yY/z/VpKjT0AE1mAMOOGAoLrOOKkG0Rvjyy1/+Mjcy1Ogopvps9Do2NqCsfQlq2SrtshjEcsNNBLwf/vCH1/mePm8OW2autUyt2r5S10aj21dsocwcRa8N98ILL8xfn2BUkuP9/YlSB4pyczNoiHQB0RNRm5cDNbmhL1TmX/jCF/Lvoc0ffvjhPCiol8MiZyO0z220DnzfZ+wSLaNHxeiu8bGiY1HsONFM9Mbo6GqPJ1bPis3HbBcrGufH8R99d/7zai6cxLbbbhv77LNPHq36s46RAXU3gyXUwh13V0cdGyvUtbUWob+f+cxn5g5RK1a12GuvvfI6NfEnVsuXrFht/IYbbsgFbsV2LT3buj2Kvw+ybe2dBGvKj7J8NW41dwedfPGLX3zKdfu+AFywQLuSYN6GHnKiLQEAFfzGjOnTp+fPBONRzVjbDc6Bj5swOo5513PjN989Pya3zog5K++OFR2LY2n7/BjfPCV34M984dNyJw/q4In+EV2KSIk56qr0kYFKmbZnxgDVRyvWsbFA6YjoLGVq6Otyp3fJcNHa5aBjAzWu1czekYWbge77AgKZuQCBM03Dr4qgYJehy5hlimh6HSNOy6JOT6r0IlDkEiQBgNawUpiK6XwEB0p5TXPRJVYbI6677rpco6C0YJqe7gBOfSRgyBr53vDhF8RL3vKsmD52h3yRMvQHTH1x7LbJs+LV731+HPS8Pdb+LAUkGl0WThSVZqfXMXKhvUxbGerOaXOlvax11LG+gwHvSaApweAQ09TJIjhhTrUctIYRmpmelhKYE044Iafl0/AW9fM0whNdrr973rx5+d+pzU1U43A5eAp050/4d19Eb36+CM5bzb6nvuZ0hgVnr0NIL7hrkrn7fnE414aMqVOn5s/eccrsGvZxpGDIHDiH/Z4vHhPP+X87xl5P3zb2PmDX2OOoTeP0qz4XzVssWksFgShW3cZCln2jbDd2GmckwyAKhuPTn/503lNqBKtBEXXUsaGA4+JAjQtGbSdINFCrRpmirdWOk+isCDVoteZqW5HSXIU///nP+XkQaHYOGijYOXyZN/g+MRyov2vDlX1z/gIBCRCRna8E1Hy56yyF3zWsSS0ew+Y6/GlqJvZhY8CRRx6Zly5oD9xXk/NGCoa8YXevfXePj378Q2sXj8Ugwis68HSDTCUi1PjQO0+I3558brStao/t99wqDn3RfjGqpd5rPBLg6Fd9qcURjwIuBqKOOtZ3SCY4ZQmILguZJ8ephZKDNVZTPZlzpwavdMykZMQYVQ65eCJYT6A6LwfvKQvUNy4gYD9RvOamy7S1nGHDUO7q2YRy6ugCbNMVZc4ySX+vBpy4ursWNtkou6xNzeEqGwuOPvroXOugTCKgoncYCWO+h9wLalfQAmFxqbOgeCrNzm5tGhPjHt4y3vesL0RjU2M0NDZEZ3tnTNpsQnzqF++JfZ6561Bffh0FoJUYrnRADbWsDIXzVify7/V6eB3rKzhHw00MLAIndalVv/Od71xnXev79tUT0OuyV462WmCyZOIcaCm1rS+ZE+a8CdWUHZWu0gFDSZGeggcBx8c//vE8g7Rf1dmr2ZtocxQ8hs37yvSNxXZvlAqqyeI3BDQ1NeWBkzMhnNxGWD0S0JBVcRo7w5wG3Q/EAHtvKVIkjqB+VN8uPWlM7fujL/jfuPO6+6Orc92pRhx5c3NTfPfiz8Z2e3QfT7q+41//+lc+ZtGmJBLr7ZSikZKdCL7SkAmbGk1Iu8A4qBdSbco86qhjfYNMS5ZVnEKGLmcHB7tlUglKv7cuDzZBKy1lerlrNNlNDbwah4wdY3tRwvauCW492en3ve99+QhYde9y4ryNAe3t7flhMZgL5QoBzZlnnpkHdIOFan3usEyjt9BEc9SP6Kdyx4TeeMkdcfvV9z7FeUPWleXf//23u6cNre/g8LARIn3zkClH1wdgT9LkKJANEOKou6mbMSwiV89YJqNdRZ3QtKg66hjJUN+VdTKiykRODgNUuiy2t32BbvZ7fYVsHYtlEhrWUpmKkKyINPzFxMpKzltAXYReco4YFZ7GtFaC12ST/vKXv2y0bbyzZs3KW+oMyBHwEBAKmjj1kYBhKyS/7GUvy2meStOC/vOna6OpuTE6O8qfwNPZ2ZX/zMd+/OT4v/URPr9Fkuopoi2R9/oAVJ2oVPBRzogZCMEIMBoWvM9JcauephYoC6ijjpEG61TAyYGCoNM6ttaxhqjtnuYfCMjLZcQYKYGtIUjFfmJ7gbNHTXMODi3hZGX7Mn0tS0a1Gq2ahGzU4+hce9BwGH+XpZvMxraaBudaP//5z+eCN45ecmAwi+vyema29wa0McEa4ZxsnFhPCXRjwW233ZbX/JUpUpcAuzZSBtwM61UQq1WqoSxfsjK6unpm9zvaO6OjrTNaRq+fDtzoQmKU4glDFks5RmKkQK3NxhfBo9DVvCtBIIJWL+3f93uUnfpV1efqqGOkwFQ0kwU/+MEPrqWR9XCrXXO0nLp/p+iWoZfSqMRdnLvstnQcqb+rRatrc4he234SEHDogngCubPOOit3tlTkKG8slxYmDlyvuLO9ZehOLvM6OnZ8D9XNgauPc+oU8tgu10QkjJZX/zapDSVcrj+8HDh8dslRz5UycddZPNRoQ4F7r/0PZZ4wUnrAh92B93TCzcwdpuWLIYvKTnyTaZNiVOvIiISqoeTQWWoaGAOD8f2JmkmLXhRO6ZqMx0htGbOZGZc0wKIcZASVPofPzSD5fdOehvuMXUaO5kJQAnXx3cYJjtTaJvayFzloZT4KZCU//2adyIy1S3KeHKF1o08bZLpauQStTvOyTxJkbVTMbIG2Mu8hm5NFq0ujyf0MhwyGhngtr+F9OWcOHGvn1EZtTanf2xwGWhQO1v/LnD/xiU/ke801EcJpySVCczRpOkq0WnBaaVATsRyhKjGXQIMgWWCjvc79MgJ2Q8HBBx+c2yifyToQaJXTIgwXRqz3e8Ebnxm/Pfmciv/e2NgQ//P256wXEZ8sW6Yqc7XwUcdo5QQiFdG0CB0rMZz0jM3u7F8UnHoPqs00PPXsz372szk9d8011+SDKXo65ag3oBhlBgwaIzBckPGYAe2+H3/88blRtVFlYqXq3zo2bHCsnK5slYPGEHFcnLM555wTFbq55TJnRl02LeimyCY81ablBDF7mUOTmVpLhLpbbrllHHrooXnJyTrjZDlvv0NMpsyUKG7gLA1bSevQ+3CiqHPCUL+PFRBAFFvTtDgVkX7f6/psiYavBUa92vOpl52uxesqg8rqXRM2Ausm0/de1PobihN/zWtekz8L7GHdgVeB6dtOjbd85pj4xRf/ENZzUSuvpWyb3WbGK447MkYybF5OW8Qr0079mkWg42wKUWxREDacNR+RO+Mk8Pja176WZ8tqgig8xsxXFc0Lvd4bwYIRjT77cARijCh1rf5O9Ud9rQyyz/ujH/0oj7Y9k3I1/jo2PFjX1rkMWMBqvTtZT6bNcXLQ2odk6hxxGi7FuDuvW8aszi2T9j2OlKDTa6mrW+ecXerd1qKFLhfI2gcpcC9OMSwGkSh2wYERq9Bbd0d6H8wBbU1PjFk1MOsBg5jOqdCKJsgolgokJxy3gEcdnwhuJDm8vkAfvefo+VTbwx8bewYOr/3Ii2LqllPizJP+Go/eOzf/3uixrfGCNz8z3vipl8eY8SO31UobgEiUESithTEGqCxZrgy32lrUYEHUjBoneuHIZAwMFDBMVJilk/D663AZNAZBRj9cEKCoVypn+DKrWkaulvinP/0pvw+MtgynN+VxHes/rOnEKlmXSiuCa2yR/SH7MlyltAbKsNsvsnI1biI1gTsn5/socAOpZOTWEXtA/yKjE0QKGjk7lL3gwOCYIlJJRyDJoXPggl+vh8IXLBRFdYRmaraCZGVK/6YDhN6kv4dxeD3v19t99DkFv5hF6u1KQ2nWBxx44IFrHTetARs5UvrfR4wDt0iJ1pqa1hWkPe81h8ZzX31IPPbg49G2uj2mbb1Z7sRHOmwgautS5y06R0WZ2FQ6EGKowVig9jkv9B4HVjpzfrBEZmp16mbqS1/60pdiOKA1SD0vgZiQQUWHMniMLyaCAtXAGuJCRgkNqT2ujg0X9qVskqPEksk2zfnHpsk6sTUcPKdqj9vLTgGTrfldWbyDQNg1ztwaIi5Dk3PURGjWm59F22O6OAn1bO8HXkvdm/pdkG8vch5JM2LfCjRdk6QAu8dZCo4lBr4SZPWuQTDhOgdinkdvUHoT0JTOYV+fcNttt+U2EfMh4TCwhx5hxOhksiqwePFifGn+50Djtuvuz77wjp9lL9rhI9kLtv1Q9o7nfy372xmXZR3tHdn6iK6uruzUU0/NvvSlL63z/fb29uwd73hHdtFFF+U/M9zo6OjIDjvssOxf//pXfm3DhTPPPHPY3vv1r399tmzZsrL/9uIXvzhbsmRJ/v9//etfs7lz52ZnnHFG9s1vfjM77bTTsu9973vZ0qVL8/tYx4aPRx55JDv77LOzRYsW5fvXny94wQuyT37yk/nagIULF679+ba2tnV+39phPz/72c9mF1544Tr/dswxx6y1rccdd1xuO7zHDjvskL+ONfbd73436+zszF+niNmzZ2fLly/P5s+fn7//u971ruyqq66q+Dluuumm7PTTT8+GCq7v1a9+dbY+Y+7cudk+++yTfec738n+8pe/5Pvfs3/iiScG7T2r9bnD2n/17z//Nz76qu/H1f++Pe/rhln3zYsffPYP8eXjTo/OjvI94iMVqOjPfe5zeeR+4oknrv2+aE3WLcJ2Ru9wRm6iR0Icwi1RvyMC+yKaQwmWnkakJFA6bKInyDaGUyhmCmCl98eQYAc8O2I+2c/YsWNzehQdKAtXC5RJycYqzTOoY8OArFnGjWLH3FCAy85kvLIyugnlpmLG6+fR2WnfKZvJpNXZi0A3U6PLrlHUSjZqyFTj3hfbg7bHBpTS61gh6xITgB2i3SC6qgTvsc0228RQwfXZZ+k+rG+44447cp2MUqjWQM/dM3GPq+mjH2wMmwNf+PjS+NYJv+2mzgvT1nJtVBZx1YW3xnm/vSrWJ3BIHLVRe0Wom6C5TFQabggeiG3UdWysvgK9l05DStBeY4Gj8HqDejtaejhr4AIqSuM0rEN/rM1q+AVD6XvEh1S7ghx0urol46pNiCiJeh2lWqfUN2xQiyeaXNBnHQjgqK8d34mS5sQ5arVpe0sbpXO9TzvttJw+V1LTwUFjUYR/02tsyIvebWvK65TOWLAG04wI9e0EIrVKIjZlsiI+85nPPCUIGGyouxv+MtTvOxBQVkSfu8cCH8/Yn/QNgq6NchY6/PYHF8YvTzkvH4ta9sIaIrbYfvP4yYWfiPUF6qdaotS00nxwDo2jkpnr2RxO6B1V21VD45j6AxtSUPLFL35x7aAHKlfKWBGq16+kqpcFyFzV44bb8cmKXD/jIkug9PXstOxQEcuwfJ7SdiO1c7VP24cBTsrgOjYOeO6mpnG0HLI1RDuhBdO6KQ5n6itMZCNS06qF8bK/zj333Py4UOIw9XEORReF9Vq01/aVQIM9UidPME2NKLVU6zLYEPBoeTNgZn3E8jXtcYI4jMdgT/+s1ucOmwP/6ntPj8v+cXNFB57wt7u/Ec2j1g/BEGqasZeBy3A5OZsQ7TYQG7q/EEx84xvfiA996EP9PgoPfUiZa5gDg4JeIvIwu7kS0MyU36hFBg9VqE1nuMcS+gzKAQQ3dWy84ICtaRS3/Sv7qgRmU+nEmmcTzSP3e5w5Az9QkOV5bZm38htgvjhopR17x34iQpXdK9/J5pWAJAwycGvb7/o5wbspiEMNex8TQbyqf319woknnpi3w+kcwL4po5VOl9zoHPg3PvTruPhvN5Q9rCShsakhd+Drw6xzt9GmoTxNC1TWjT5iDEYC0MOoPVnydddd1+fXkTnrh1UyYAyoTQ1x0A5TCdS3el2dU4wFkLFzmGrmBmTUUcdwweFBbJyWQXuV43M6IAfJIdvbHKmpaEWoc+vjloX7vd6OFB0s2Eu6W1ynWjknTaGeAgm96fYq2nc44R5hEQxMWl8wZ86cfLCTQTYCfTbdveTEBxPV+txhS30Oet7uuYitEgxrOfDw3dYL5w3qYWmT6AflqETOxGIjBRYhKi4N5e8rZB7oZq+llk3Q0ZPzBsaQs1c/YvhQ0PQC6n511DGcYCQ56mI5x1AXGZeAlwZCS5a5AEWGSfZbWs8ejMwVbS74JpzkTEoPAZKd93R+Akc+3M4bE6lun8bEri/IsixfC+49xlDy4RmMFAybdzzsyL1i2lZTckddDqj1V75r/RiegT42ZtQMYhuNGMqDLtaeRgI4XRE6Sr+/k9RE+CJDhqO3gMC9EMzIwim7ZfBpzGJpn/xIoFE9x/XN0NTRd3DOqfe6CFoIQaaxqtg188tNTRtI2Ic0FWrngO5WK5bVp2BZ+c3scieTCZqp0/0pUSgVrdlr6XdHEuhEsH6SHGr6kYrf/e53ZZ8PfRM2dSQ572Gl0GHOwwvik2/4Ycx95InckXPaxGsNjQ3xwf99TTz/mJFBPfcE2aRTetS90cHpRCF0HHptuOCxCixkEVohXKdoHvVDkDEQdJ95yOi5SrVjG9W/E+KoFRLRJfoJJSnYoYo16crpTmqIVL3uZU/iNr8nIKB2pzsYSFCcauvhwK35nlpy6thwQAxWDbWbHD02q1qg4zlW+0/GXtR8yK6xU9YyB0xchsLnyJXitKYRngkgivB7SmHpkBFO374muuTYiSq1iFLE2/9AVIox83veC9Wudj6UsL8J8HrSFwwnTj311DzRUJLAXNAM0eloGRNMHXfccUNyHSO+Bp7Q3tYRV1xwS1x94W3Rtrojdth9izjqtQfHlKmDPylooGAzUTNTn6KJOXGRe1Ki9wU2JdEZ6qans4dLYXNYgB6r8aemM3GIw9F7TsSnP5Uh0q7FaMh20gQqAYDpVmpjjIr7RRzn+4yRtVbuoBOvJ5PXDicwkRkRlajF91cpKzBIo21lOtrchmJqVR3DB/tFpwiNRjWw7rBY1bBHHLeAU8sh+8lWpCNIrV1TCK15+zZN9zIvXWmJAI0olpMtjjJGRZv0mPrOdXQ4DAXFK/u2p4w71QkiuSBgwwpqS9PWJlh2mJL17jOkk9SGAn/5y1/yz9PbHPehxsUXX5zfJwwcm/uRj3wkb5UlDDQvQ+Cj68bI26FA1T53IKfCbIxYsGBB9v73vz879thjs6OPPjo7/PDDs2984xv9fl3Tkh599NHsDW94Q02/d8opp2QjAaZN/epXv8onSpke9cUvfjG/V0X4+5QpU7I77rjjKb//y1/+Mp9+VQ4mVxUnS3VPDuj+uvPOO/t0vSZeffCDH8zf16QlE/OuvPLK7D//+U+fXq+O9Qd/+MMf1pmiVgnWsql8P/vZz7If//jH2Z/+9Kde97A9cMIJJ2Q33nhjPvXPNLcirLfp06dn559/fv530/1MYnM9JoBdcMEFT3ndk046ae1euvbaa/OpgMXPct1112UzZszI3zdNGjQ57n3ve1/+b0WcddZZZfffYOJtb3tbNtLwne98J3vhC1+Yvfvd786/2JK3vvWt2f/93/9lP/jBD7I5c+YM6fVU63NHzCz09RWiWn2aKF8RGqp4IHodRckidJmlbLzafmktXcM9p1cWgC5HF8psRNvuSylMN5MZlBPgoNllKzIEjEbKQFDwShTuDSpS/T2RSIRxsnntMqW9273Bz3uOkKavyVCcJFXHhg1rqreTAGW9KFTrUclHxouhkSFZ79andaNkhfWyXx0dbB2jtf2sFiqZeHpPR+naF7I/mR+odWOAXI/XKtdiae2nMwrUlYtnjrtOmbmsTQkriUtlc0pdKPVi9ms4kfLBUJ0YpkyGcUjHr44EzJs3L5+0phvGfWI7PQctr0S3su6RptVJqDvwfkA9jPpcX7UNa+Ka2k5/lfNoJg7F5vVaJpxZXP6fEE1tXTtGOSeNnkNBl06DGyowGsY5cnzVHF9YST1Laav3UiDzla98JReRMJIMpvtezrAxUAIqE9QY2L7ApmVo0fkMbx0bNgRqtCI9Bb32kz2nHGSMbhq/S99hgIo6tJKPNUeMJqjkhBn/pA9xJKlaeKLp/b+Sm2DUyVapTKb+TUhlihvH4jU4ZUNbOG3XmGY42Gtq5Sm4d53Wrfo8+j1R9QmoYe9L30GYJTHwetqjakkS+gPBjT2K5u/vMKmBAi0Au43aN9CJUE3AlWYBmLTniOWRiLoD7weIs2xm0aQvxmAgTt5R/xAMJBB8me5GuW2jOdaQQMWCE80yIOnMao6uv7XgvkL2T/DBgfdnTGsRsgUO1ef3udX+KoERltGn05r6AgZRj7vpVsmg+5OIqH4u+IYHGarss5Lz5uxkrerLqXMiTRMUSMpgfXHgdBnYH3ZADbvI3hiPWuxskCF7DbVo758cPZEUh6qGzclpvxKMSxQEtARq3i8xTgcccMDa18QA0oPQiGh3K525LiD1Wq6RjdAWp5uE4M2xqQRmQwHZ7Ehy4KDeLSnwjDB/2EP32/MQaI1U1B14P4Dm4lDQLiJeysX+Zm3osdJImINOVJhoHYVHWSpLF0lrbTFnWauGjUnUIgrn+IYKDJbo3iSrgT4r18Yy/pFz/fjHP57Poy4HIjnDNsyTrhXKHoIhG1a7SPEZELZ5f88AEyKTEbgN5aEQdQwOtHoKOitB5su5lzI6FMpauRITpGRkyEea3GWNCChTZm+Wuv2R4PVQ8i9/+cvzPvMirCusnsCdwE4goMOFgy22bAqYi6UpQaZrkrETplm3CWh+wbAgxP9LBLABMkyvw/nLPgd7QAk76T11ehD3jRTn2NTUlLMpxGvsgIBLgqYrgHMfqRjRU1LmP740fnX6ZfHlL/wpvvn1c+OqK+6Jjo7OuPmqe+N7n/p9fO24X8RpX/tbzLp/3pBfG2pXpJyyMvTWQLQYcIDlRg2m3k5OSuAgere5RdGicBk5Ck2WapNSwae62mADPSjwEEwM5kH3alEcdPHUpyJkQTZiuZ7e3sDIyrQEQkXnLWhAi3oujKMAgoGU3ZxwwgkVD5KoY+QDBS0Qq3TmPRZMuyVaWz26COWsYhlHcGd+AIdNWa40ZB1Roaf1VdrwI5P2s8U55gkyYlk5O4MR8rulgb3XxtYl+BnZrc+lvl58P8yU1/N+1rJBU6hiaxitnQ7yYV8GE+41hs61KBOMJBx77LF5QIVFFVTRMLAltXQBDTVGrAP/65//G8e++vvxy1/8Jy656M745/m3xImfPCteftQ34oTXnRrn//aq+M/fb4o//N9F8Y7Dvxq/+Po5/R5OUi1Er8QjjHkCZ0r01F8wFDLsIkTiIngRsvoRJ2kjqJWLZmUDacaxDFHLls0hgixu8MEAykmrlX7JoYCeWBFyOfisDBeDVARGguHqCQywnyuFujvHnUoC9AgyGS0nrqX0RLY61h84/hZr5qsc7DlzAARpvZWEZG5pVjlgw+zXYkmNEy8OWfH6WtLsZckAJNpbW1ly2F67HL2Nfi+2GAkqOH6MoOybniNB5u61BdkEW4Bux2Yl4a0MXu13MCHINm7adSsdFMsSw4HZs2fnz4q2BmTeGBnPXYCDIRjJo19HpAO/6sp74zvfOT/aWhti5YSmWDWpKVaMa4yO1sZY0d4ZHdMmRUdHVz74Jc1S/90PLoxzz7h8SK6PeAWtrX6UgM4eCMpaZl0KkT0DYpiAHlEblXGgPtVXXTymVHbuiyNjFAZj8Ynw9cGi2wjMRKhDeR62DLhcpmBcJGWr/vliYEXl6z4lEAIWj2P0/yJvLEI5oNCwGQKipNb1dzTlSDhSsI6+QaDs6FiBN+FjEZIB+0ypSg9wcU1VA04Ue1M89ct6MXe9FERpqHzOXfnGesUy+X32APXO8ZaiXKcF4ZVrFswmxXuCwFeJjWPymQyPEVTIwn2PE1eXdj/Q6oOxp7F1AhLvhTF0DRIOtf7hwMyZM+PTn/50ft/R+ylocl+UMpy2mKbkjUSMyBr4T0+7ONomrrm0JC5pzKJzTGN0tTTEqKUNkY0eFQ2r2tf8W2P+9X9fOyfmzV0SL3rdITFty/K02EBA5GvhGZKQhGMpW/P/pbOKqwURTOnMYo6Kg0F7ifAtLIGDOq9snNCidCOneh2j0NuM8r5A5mkTJmdmsxN+JHHNYEKtUe2utK2DsXP/XVdRLKSGqTZpIIPygufDUdMNYCvcX05YdlKppn3ooYfmv6NMkSBQYIBkME5ZOuaYY3KjPZKgJIApwtj43DKt4kCQwYZ1a6+MdAhEORFOz/ViWawJGak1waE5O54CPWXHJgD2dqoXXUjx8wv6ywXoqcYuiPCM0sljauSydMGEIJ6wsjgZsJzwjiNim1C/pbX9IuXPRqHmQY2do0qCOBmyGr6ft6d7mrNeK7BXJ510Uv5eghS2S73fvbXPhhrz5s3LmTfPyfNUEtX6ihVhYzwP+3ykYtgnsT3lvRavjBe94XtruYGGjiwaV3dG46pOVxtdrU0RTY3R/NiSGLVopTD0yV9uaMjHsML7vvDyOPq1hwzqtTLqHr6NIEpzK9GtybHXAtkdY1FuEVNgi5zVZGxK0bjRidSjauCuw88UoabFgFuEFK0bCkxx85lLwRmn7EaNjegMGAl9rmqdFLwcfTodjjAIa4Ii5dhSe1AtQFXaF4ymtrne+omHCkoxPh9mAWRT+tyHSvkri1RiolvgVIb7yNhqWKU0xRClqsMj6Tnsa5/HutOmhXruC9vmdUxCq1T7tadlhDQw9i6HzR6k90JvF6fFeb5JYGXdCQKsQwpqtoQOphZg8th3gT/2zj0QnKbJhAPduqf8x4FKRoxUHq5WrYVrgn9IPfRspiCDrfU8ZOdDOZFxxJ9GVooVK9vyBX7NjQ/kzrt5RWc0reyKFGPOfuyGWLFsbmy/ySHxxIpH4tZZf42tJuwdO015ejQ2oD0MUe8+BAW+95k/xhbbbhb7HLJuPXkgwSiJqtVX9QqKJkWYsrtah97LkCqdpW3TqmcxLpy1iDlRczaBrBQtXKT0Ubxq42pOGwqsDwdLVELqZWWAsRmcvSAnOeZSbYG6oFYcWU5fBt9wkoIF2RsBkDUgk+EMOHY0JRqWofVeAjDPeCjU69gGRkiNHquDlRiq8ZXKOz4zcRbDLIiwvjE1PvtAZnQDBWvEfdJFUsqCCYY5RsFIf3qlUeRpzHG59UZLUnRyhjgVZ4aXMm0CCcGpn0NBc7yuzwmIfRn5+c9//jPP3GWh7IxMGROBXUPzD1SfuCAlCcNodyQfBGSYkKHsnAF2U7atlMKR+7sgS3cRB057wK6M1ANYhtWBW8j/uuzO+M2fro277+9Wa04Y3xqjFndEY0e21nl3ZZ3x0JzLo7GhOVa1LYmGto5ojMaYvez26Opsj3GjNomZY3eL5qaWiOamnE53OMrZP7lkUB14MlYUixSrokpO1OdCzRY3ZG+gKEX3cj6lkEXb/CJk9TDvlyhkiwydV0opCy4IaIp9ous7GL1KQY7Nl+anU7gydrKHNPSiEvpiMGggnAzlGXPeoG1P0IR+Y+hQoKX96JwatkbGX+45DyRQpDQTav+obFTgYE7n04aE9fB+7r9Ay2dVmqCkNgjF+iUSYhyHksqvFgK+clAqUgOXhXnmAhDBm+CPgedIq4F1oX1Kds1J9hTIlXOW3p+9oYpPe9w6wvywD8UBUj11Ygim2Ci97UVYH0RbvuwjJyyyK7Q2mD/lusRe9ReCO+/HYer8kPB86lOfyoOFocSYMWPywNu9xJx6roInn9s9Ui50PwRwpfdro6XQ733o8fjnlXfG1Tc8EPfcNzcaO6XO3ZeBKm9Ztq544qFHL4umppZ4ZPZVse2Wz4p77v97bDN+37hn8RXx/C2Oi7kr742l7fNjp4mHRlNjs5Wd0+yNjQ3xtzu+NiRnihOIoNjQcDINNVf1Lves0mldRVggIv1KDofRI0rhMMqNJS1Fak9BfxG+FbPzDQkoYaId9aukrh1scNYOOOhrD6vAQs1vOMfdDiQwC+hWLERvp3S5b6nflulhONmWNGlwsGGPKbXUmqEKugTPMjF6FM9P8EdjIHhBAxeFkj3B+xNxCegq7UvsDYdWPG3P/bL3i/3n3p9TlyxgWzjE3g5lke2yVUn5Xg7qvn6OXcPkoeq9Lzp5IA4/sQYwBzJxtg3DiEEYqk6i9EwFmgbbYDVl2hgPwQRGxkQ8eogkdCtl8Da608hWt3XEF089L/599d25c00Kcmha0RXNq7NoWtURWXtHXH6dSWRZTJ64XUyZvH3M3Hz/uOamH8WBe78z2pc8EeOWNEZn1hYrO5fFuObJ8ciyW2PT0VvG+FHdfdnRMiqviZ9zx9eiSVY+DBC5ooXQuL0dnyfCd4/LRbg2kcUmIKBGr9S3WoRskOBFb3qlvukNAeqr6PKhio4ZcNmI0+f6ClmG51zrxDi0Jic3FI6uGnBcWvaIBBk3hr0aehyDobZofWJKZOmCGoEuh4bCTlltGmzUn2CHo8JwCTKooBltJ+WlMpegWHDc2311LYRm2J7SzFhdm9it2vKI/ckhCvaJxkoZNNckMy3qMtLMdUxHcZiR2rks0nUJaNMIY58HC+Ne+8xpZoXvEY5Rn/dkG7SGCo7dKxQzxsFzFnz1pzeaH7Fn0xwNwQwnquwkyx8qrF4ziva8887L7a/gRyJgXStR+n/iNsFUYj026hr413/6z7jomnvy/+9Sqy5sys5xTdHY2RErFj8aK1fOj7b2ZTF2zGaxeOnDscv2L4qOzraYPnWvnE5ftGpOzF86L0Y1jY2Fqx/NqfbtJh4YY5snxqLVj8Xk1ul5Rr/tLjOGzXkDJSdjJWL3MHpa9ChGm6ocbGKCGvWoapx3UkmLGtXD0Ja1Hu6xPgDbQWU/lNRWqdagLzAWs9pZ7YwLI8PZ+P/UR6yWylkwLNaV8oHrGoyug3JwHT/+8Y9zx1hrICKjK2bqggCMESOeHAzaHThvxkwHQF/OsBdoGdspU+WwPD8Bg1IHMNy0AliE3pySmjCalWaiFD1pMyrtT89PpovSTu8tSPeZZbrWCSee4JlLBkrFXrLvVK4jXLMGsFF0F+yPYEFJRZDh9TlgtoFd0YcuyC8XIBHQCWzcH2UYjs09oPHpj7CNU/IMCH/VmwVvkhTPSBljqDLd1tbW/DMJyjhs9yTB5/V9z5vAeKgdeLUYMgc+5/El8Y/Lbk9M+TrIujrzwyAfeuTSeOSWf0RLy/jYa5fXRWdXW8yYuu/axbXtls+OWXOuiekTdovR7VvGglUPx+SWGXHrwn/GwtVzYkrrFvHw8ptjp0mHxfabHBwve0vPdN5gQ6+0xYkqQy+mQQ82qDp2sQ7IQRPElQMDJwiotS9T6wslq1YQdR3GQF1rQwEHUtq/O9hgePubAcsECYasB0GZeqXsjgMu9u7KnNB42pEM7aGxYGwFY37e+qI4RvNx8gRYaqICx8EGFoEj6GvLZDmkDDG1axXhOXPsBHF+rpLaX7sVx2NICw2ILB8zwClwPrJJz5A2xJ7iwGX7ap9mJyRH6RkV2wbBew5E7d5nUQd3PWlsajGQp4WhqeHoZOnml3uubAh63DqodB0odhm9z5Ta4twLNsj9k1UTvLEFAmCOnjMtnr2QkIIs9w+db51Zq4Kg/kA3CAfpPlvPggjv77kPdaJxyCGHlNWjCHzc62p0NMOJIaPQz/rH9fGtXxo1uO7377v6d/H4A9dG6/hNY/Wy7gh8my2eGTtuc0Q0NKxrKLOsK+Y+fnPMbNohGpevisVtc2PuivtyFXpL45gYN2py3LXo8ljSPi/ecuSJ8bPzvjBgdKP6jEWnLlRrS0wS8KRNh7phADnyFGGrA3l9hqM0O2PICYL8fKVTyHoCQ6UNTa+yGmS1opuRDFmLKU7FaVNDAduFmrvcYI1a4HkqsYjwfXldhlZtMs2qltkqnYj+OWVO33Ps6fkJ2EwW83oCuMHSPggqhmr6XoKMFNPAyMvWi47e56Vm5sCxAuhsTosDe9WrXpXvr1R+SPtHAIiOVo+1nvxsek17xmsIqJKgDJUqw5Vt12IDdCpYq8kWofFlmq4XO5auh0NDpVsb6u3WhYwZW8DZophlqm95y1vyP90LbEYpOHAOF3RFKHGUmnn0tXKHDDSNYS73WuC90Nxeg1bBfZIU9NUXsH+O6/TlM1mvglH31HqvlMgMFW655ZZcpIrmH6rOjT773IE8XLwSurq6svd/4+zs4Nd+Mzuk5Mvrjpk4LWsdv1m2yczds913f222/55vy7bZ8lnZ4Qd/Jnv+07+89uuZB5yQ7b/rm7OjtvlgdvDmr8x/d3LLjOz5W7wne8FWH1j7tduUZ+X/9stf/jLbe++9s4985CNZe3t71lfcd9992cUXX5wtWrQo+9SnPlXz769atSq/llJ89rOfzd71rnet/Tf39+yzz37Kz82dOzc755xzsl/84hfZpZdemv3617/Ofv7zn2eXX355Tdfxile8InvooYeyDQEHHXRQNn/+/CF/3xUrVmRHH310v1/HnnjrW9+a/9kTLrvssvx5WxsdHR3ZmWeeWdXr33DDDdmHPvShbPXq1dlA44EHHsiOP/74bKhxySWXZLNmzcr//+67787e8573ZMuXL8//bp/PmDEje+yxx7LvfOc7+Z4pXm85uPdXXHFFtnDhwuy8887L92kRjz76aH6/f/zjH2dLlizJv+f1f/WrX+Xf/+lPf5p961vf6vGa//3vf2cnn3xydvrpp2f33ntv/r0HH3wwv/bDDjts7eu6hg984APZf/7zn/zvbW1t2RFHHJH//29/+9tsr732ylauXJn//Uc/+lG+Bl3vSSedlN1xxx3rvOcLX/jC7MILL1z79z/84Q/Z97///WzevHn535cuXZo961nPWnuPvI7X7AkPP/xwblNnzpyZfxbX1B94bu7r1Vdfnf/95ptvzl//tNNOy4YT1tczn/nM7P777x/W66jW5w46hd7e0RmnnH1JXH7ng1GUaSx45KZYseix2HKvF8QTs26JfV/wkTwSfeLai+PhhTfGbju+LOYvvDOmb7Z3tLWLusfF8hXzo6ktYln7E3Hnosti4qipseW4PaK5cV0ByFZ7TIqLzuqeHy6SQo2JtmW7MtxagXrSvkTEURzBCSg4VCKqpRitiXBlDKJ4ghOqdFFrsUap5iKqFSWrs8iYZF56Z4uzu1O7BcEWqlRURjijvueaZHLVZOWDedDIUEKULgsdjuM90a9Om+oL0HIyYs/KlzXTG2Rq1tUZZ5yRU52yc7R5byAIUy/1eyjY3tThvQHtSu0sS3Ttwz1e0mcj3LJv3FfiTnPA7fnS8cGlfd0JPkcanFSOJlWXdq99ZqUM2bD7IJOWHVOdp1p6KWTQ7pfrUbv3O+yA68awofa1oCXxGgpfPTgdiIRl8DNYFxmqvWvtAeEZloGaHYOQarQpgyY4w5AktbhynZp66l5RWlDDxvCwP8pqxHTGInuvcqwNyh+U4tTE+zL0qAjXWpyD7nNCT8r4wUZnZ2f+TLECpecpjFQMmgPv6OyKX/zt6vjNBdfH0uWroynLy9zdyLK45/Iz8v/ddOt9o7FpVP69ppVZNDW2xO47vzLmzLs+xo6aHLNmXxVNja3R1rY0RrdMjM022TNi+epYNueJ2G3ys2LT0Vs9+WFGNcXrjj8y/0oOzcbRe6neaJKRPyspRRk7tTEUDvoiUV4cq82HvjY4AdShUGmcpxoWI4v+5LBNF7Lh1bLUuVCNgodS2i1tXhuH2pM4hJMvPUWMSAuNYnGjdywyhkCLiYAA/VeNkMvnSDXVStQWwzFSVM6VwNilMa5DjaLRrwUCLs/Mn8RUqFqOtZrAK9VsOZTSoyd7grXB0RjJifLvz1x8wYP1M5Imqrkv6GQOVnuYz6dG63MrNQwU7Ink/FDqHBx6Hl3veQqqaBIE8oRjrktwaR9xtJ47u2GfCyaUOTjXYjLBfhDSpXHKSZEvCPBZ7HuBSnLS7BM7gc52bZy558MhU6JrHU1wbehqegu/hw5PDpjTIoxVh7ZOBCxEf6WJTjo0ye+j7vvrwIs2h01OpUTBx2DhvPPOe8pxqe4X8ZySpsTIAKT16ZjgQbHUFOYnnnpu/OTPV+bOO4eTeNbs/eVPPJL/2Tpu01jw8I3R2NgUc+64OJ646+pYtWphtDSPji2mHRAdbStifOvU2GLK3rHNtENi+iZ7dCvXx7bE87d7fzQ1t0Rry8S85zuamuJH//pEHPuBo8oaRd8jSiCWqJQ92ChqTRyvhcRJA8NpDKVeQZuIEEZdi6O2sUSvomAbzmaiCE2RukWvR1QNvKdFb4MIHPSnlssGbHAZvc/BIID6GQPC8VcDSubSwxRE/GaqC3I4lKEepNBXPULx5Kf1AWr1jGiqTVsvtWgZrE2ZW18cqGDB2rMm+9JnqybL+I8k513qYN0fIi+fEds1WCDaEyAIqLFv9qXEAEvnudqTAn33S4CutmxegOxd5sqZYkPKMYGeDb2MyYqO+8QyCcB8Ng6uWKMWtKRhLRwTu0QXYJ4EBq84Ppn4DnNnf0PRDiXFO9U/Zsm1ShRK1wmb4zNJHgQnxbPG+wpJi2BH0CPJGUznnbQB7i+baQS2e0yZLxESCLLx65PzhkHZkZffdH/8+7rudrF10NgQzSvaY9KYLaK5dVysXr4gpm53UIxrnRIzxuwW4yZ1t0hZOs0No2KLzfaN2QtuihWrFsTY0SV06ajmmDJxh3hk6W0xc8LusfOu28QW2/achTKYHpIs1Maz8IstMFoJRNaiNMIOP1ts2SAyQnt74DaBWc/UwZSi6DAOHsxLTqgl65FliQbLZdOct/fjrG0kzl6AYCNVyqjLff5Sp4FBsJGIfEbiiMtS+OxENcVDHUYyGFbZKyGRDAusvaEUxzCSaFd0L2fDWNZSTmFglY70JhOEjeQBNAz0YJ9sJXCXsXLW9mxxgAuhG4fJEWLfPPs0XhkNzYkIODjLUqaLTREsYfEMOfGMOH7O1z4tAvvHViVaW4Lgs/vd0p/VSlrpOFRBiGCCwBbLKAvFEMjKS2dXyPYxCewTBkH/efqsfWHt0sEuEoikTh9MvOpVr8rZUqyDpIwgUXljoEbEbjAO/E8X39w9qGXNXPJ13nBFV1x72cnRsbp7Rvf0lh1i/JjNY8zYTaN9dFN0NTWQxkfTio5oaI+YOmnnWLD0/hg9fmoeADSs7ojGle35uNTWlvGx9ZSnxSMLb4zRD02Iqy66Iw55Ts8DU2QR6uKoMJGqNgrtNwkoKw9YplqksmXvfkctPUWwFpwoDjU2ENOJIB3CUQrG30JDHYuyOXDRvOutVOMrh9JWNOrmoWg7GihwIiP5fN4iPJ80YWwgzorvL9CjRoHSc2Ciqi1DcNiyRpkZ5kn9dDjmClQTOKCeObaBpNBLwVHacwJ6TtZzxtqpwaudKvGwKxgvDn6rrbrLfK6JUxQMoav9rkyXElzQn86kVmLhKGl3OBgZcinYoDT0ifPVJoeBoJUprd9iBFxbuf5qdsWpa67D55CBcqymupXTenB8tAfWQeo991kq2a2eUNrFwKEKIvozJKYSBEFKjez6YK6NDcKBPzRnYVnnnaPBRLZuIdhO2x4dUzbbObLxo6PNKWNy78bGfDF1tbZGx/jm6Hp0UTQwFk4Z6+yKxhXd50CnrazVDAXf2dkVX/ngmfGz8z4Sm8/s/UQoG8BikZVoDQPva/FYvDLw1JNrwVrYJvMkIYlNKvJE5w72MXhouLQpRcyp1SUdxUfohCkoikIqOe/SKVLrG7AFpcckjjQwvNr10pnS1tNA1Qz7C5OufGGNMC61HIFqD3AG2JqhnJhVRG8lACUodLM2MMCYKQ9VOzinGqT6slqw9SgpkDGno31l4UppvmTHyYED++FL6SqduY2+BfVyWb0RrYIsNkZGXs6BF4Ex1ArHDpQbOMJ2eB0BR/FaIJVF0MqYgrS3vF4lpPMeOGAME6dYbJOrFq4HHS8pSicnDobzhtS2tqGNlB6UGvjk8ZVv0pLOBfmAljGjN42GsaMjmzS2e265w0s68pNL1k5oy5obo3HmjFjdvjz/XuOa87+LcfjK9sUxurm7T44T/8YXf1i1klFEXzyfVzarvmUhJrrTQkWzU4Un5w3qUTbtUJxhK+JnlBxpKFouXgc2QXbXm/MGGbx6/PoMwYvofyTDulDy0CVAXTuUxxDWQicqIVnnsvJqIWu0b2RrIxGcFYeC9hdwc6JKZoKOgQZbIcNOiv/ESqCYOXlaGwF3mp5XhHsouy7S1BTr7ArHbmaDQFBm3xvQ3QS0yniVumw4xnIDWDxPSYxSYPEERdR4b3ZU6c71Kw9IdnzWWoDBdM8MiMEODNaQqblz5+YsxYbmvAfNgb/gsN3WOtlM4jyq+2v5krlxw79PjkMO+nA87dkfia6Gp0bTHHl0rvl+Q0NkLQRq3ZfZ0P7k8aIJC5Y/FJuO66aQHSX6rwsvzmtAaOZqBDtFYYgMQ4YqorVx1IK0+iTxRxGyl9KWsoGAa0alaecgVEF1isgFFerjxfp6XyDKHalH41UDOgNHY9bRP1hbAgz1R7VM9GVq5ekNsjT6EDTySJyzbx/bPxwg50rZjXGoFrJiIkOBolqzmnetUJ6g/EdD91UzQER76qmnVvWzyniyaE4cJe8905AjTIHpb0n8WgQaXGlF5p+ycXYN61fN+NA0YAgTiXXyvtXeL5S2gMv7qa8LaAYjMHzjG9+43pTdRoQDP/rpu8fUTcZHx+iItgkRHWMb8q/b/3xSNDQ2RdPm0+KJebfHlM3XrcFZ5lxuAweenK8/R1Vm+psaR0Vn1p2Zw7TW/fPMQisESiv1L1aKzESAat1p4YjU0EIoLIpTD7/SEXq1ZC49gbHRHiRw4KhtKEIcinj0mpoNZaraY38FRDZ1Ghm5PoKRGanZ3/oERp2jY0Cpp2WqDCnRVU/QdSG4lX1pV5K5EWv153CXwQbmiYgrlcp6onQ5TCJVnSAyW1kpO6AmXW7dCfjLBfKckX3MQfZ1z/q9aksvsn7Xhypn14jlZPFYRdcuEKnmOiQQ2mk5/CSSK103gpM0wlgGTv8je/b/KPFq5hsA1oCdk0RhSSj5B7qF9Wc/+1neGjZYLBhfIRDZoBz4WRfdGI+2L49Obc4li2aTnfaPxk7nZS+L0WOeWqv20/lvFFinlEej1Etz6s3H7xjzlnYr3vPRNdEQb3vj+/L6thoNilx2YYHIyoubFTWNSjTS0M972LJfm0FtULZbekpQEaWjB9VyiJbKUWY9bRiGRSYkS+DMXVd+Lxoa8mDEdTGWleY/1wL1OWMLB4M9GCoQ8Hl+dfQOa5HAyGCRItIBKNppEswZ14JlOFAp0K+cmz2kCwCclcw5CghH+npSC1faKBVmCcLtL0Is+8/exzDY/zJoxl8ygA4vRylz7pxlOaDtdbZUi1rsRjm4XsEV+2HYEfbBM9OfXo3WgS2yHtgwdgfzVwqaGzaKbcVsCBjYV0p360IrW7WjmiUTKHyMGvssMOiPA+/o6Mg/s8AAi8J+eqbGkvYFPo/XsDZK38e9snZ8dv7DGhCArPcitj9ecnN898+XRdfota44x5IH78j/nDB9x3jgrvNii20rT4bKioec5Bl5Vz4HvWv0qGhu73xKBu7fcuedZZE1dcR+uz43HnvsxFyxrI+S2MxNV6NRR071JnVlm9eEM3Sg+cG1tNeIvhIYMcaPiIazJXyrBqgqkWvqP0xtbUnY4jOJogeq1YHBYdCTql6GMRAHNAwl0LbuLxq3jp6h3YkBK2fEGOFijZWxwgK5v35PBmr9MbRoUcGsfyfcUjdlrDk77FFSJI9kcErYgiJ8BuwW5bf/t4+VFNDBOkyAM0ARlytfYcVQ1wIc9oXzK6I4UbFcMO162CLBucCaDanE+BXhOrEhfidl6Z6DXmo2iO1zXekzVAOfgZ0pFboluA/slRIllT3RnN/xOSQ+bKv3r1ZkyvlJsNgfosPexHq94aabbsq/dExglgQSnklPSVglcM4p+CJEdE/pKuwj9thzUs5zvwRI9stw9JA3D/T0tR//5YrIckH5useFzr3m/Nj2xW+PyTN3i1WLro3W0b1TGndcc0YsnHtHjB8/I+bOuTH23OmYaBgzOppWtndT7Wt+bkX74ujq6ojHV9wXNz7yx3jNuPPyTcEpG1NqEaNeiwNSRKg2ZXEMqSiq2kEX6lNp46gnEpGJgGUitbQMeZ2e2sBc20AvDAvOtdvwqEWUmch1fYEe8L6OM93YwJCpU6buA+utyOQ4iUn2Q+CjdirjVP+1XwSo7jVmCR2bYJJXgv0ykvvCi7DXOTyiKTXXpGURxCSKVVDDZgCn4t64F5V0I+4NuG8cl0ydc6tWBOdaqL89F0FStV0BBq/Yx5wn+0HcybFwVgJbNV/Bg3KAz1wNMIrspql25ZgD2bHAgXCWLkiQYHKkMmQaEZ3OIq8GggGfN00M5BBr0SoU1yBVP+GodWo2hiwcU9fXtVnssmB/vSaqnAhYsMfeF89k93fBC6X7QJ7QN6QO/MrbHoz5S1dEVyvxWsNaB9vV2REr5z4cYzffKjqbs3wiW9EBl0JGfdnfPhWbztgznvHCr0ZH+8poWtIWDz98Sey03Qujgzp9VUdER1f+Iq2jJ0Q2dnRMa9ktdlz9rHj4cSdFvSCnAosjBUuj8XIzxKt94DYOh23T2nicoIXoq3QAQm/iEwZzKGGTYx1k4mhTztBGX5/Ql6h6Y4QhIyZ2CSzRoxwVp1GsUyojCehkk7LvJGZyj+0R7UyypHLren1x3iBg9flljowt5wPJeav5EnrpmRbMuG+yQrXs3mrRaRY7GphNqGaWNoeJzegLBFHq2uh9WSe6XlKSzohPCvierkPWzBm5DwIaot2cxcyy3IHLqAX2KeDzrNW6OStrxWf2Gol14EBr6XJx3zEdsluK9L4KdN/61rfmdLfnhMrv74yC1BNvmp1xuT6v79F9uFYotdmCBYJj+6enFrwR6cDbOzvjW2dfGmddelN0NTesycCf/PdFd12/1pGvevS+GLP9dhHLn5qlJ2QtTbHJjN1i1wPfGNGRxajmMRGbjImOB9eI1Zqbomv8k5TyqiWrIlqbIzraYodpz4zXvfqNa41XEppRSqqbih5tRlGvDYpe7wtsdDUxdatiWxdYlNVC9D8cs8eT4XXtwynC6Cs8P+1CpZTlxowie5SerwxSdlMMeIg2UZepXGT9ydrUtIvgyGU2BJ2y0XQOQCmKM7pHOrR9cnj2KIeexhO7dzIqehR7UtCitYnAr1ohGeEaB8KJsQuDHdxwVBwGoS7xYTouFYXs/WXpJheWnmuewCZSn3M+nLeymrJJum5BjHtF4JgODvL5vJ/Pqt3N6OXUY1/LnP4Eo0w5RYGMcp76erXIsiwX0LFhErKBynx9fjoCnx/L4U9zNgS6xZ8phSBCIDWUDnxAPMfnT78gfnfJjdHZpQYdkTU+mV3Pv+nSmPWv38Zub/1ctEzYJNqWLIjG6ZtF+9gyNW91llENsXDR/TFhs+26X0urWRbx2KPXRWNz+ayrsbE5OrL2yAx7YaBMaovIJ6ylzFI0KaISTRqsITLt741mFEudd61AbxZ70YcC6NREeaGwbHZ02PoEmQD9gnrlxg6BpOwYrcnQcrSCUwImRrGUrWBolYuSHkSW1dMkQfuktMRiDXHc6GLZWIJykqxuJIPxpXfxJRBnrH3P55R5ck4CRFluLYGJ12DwCeZqcd6oZBmoeyeI4EQ5jWrg+jAKxHdayGSO3ptgD50tgSE289pFCNrVyJVIZO2ck755Pd3YxZTZChJKRVxKj67X+1hf3jOVEmpFsp8CcfeBfqhadHZ25sGK5zfQtLWWXYGr+rfPW3TeleAeVPNzI8qB3/nIvDjv2juf7Pryig3d/d8r5s2K2Zd2G9hR4yflorSOVVLvhmha2RlNyzvz3u2uUQ3R0arVrDG6Whpj0oSto33+3BizoD1al3bGqnmzYkzH6Nhl2xfmGftNd/4m7nnw/PyYUWgZNT66OttzlXpDY0NstV33w+SkRaRqOmgtwhuZhEWLRiRAEMH2VaU4EEBRckRDCdmWyDdBK5BoHJ3eXyXsUEF2qM0OhVipTLKxgAEmaOJ8GBGZtTVtbZXTT3DyHDjBJKpVllXpWEywT9CyykQcGwGhvZXo16LqWAZbbc11uMHJyfxkqgnul/KSzLQvEBirg8rgq5ntLYt0P1H67rFMTzZpfcuei0LZnl5D5soBlwYOdD/EqpiY0jWgBKjlDAvBTiqz+OxJSOveEG6VisusB5/Ntcru/b2aQVKVIHBKrCVBYbU6pOXLl+fBQ1/69HuDAT1J0W9NGFPbE7ARSral93nEU+h/v/qOaGpsyLPvHPkfMvGGmP2fP8VWR70xWidtFl3tbbH4gdu6FePNEU1tWTRmWXSObVrj9Ncc/9nWFUsfuCO22bJ7+H776uXx+OO3x/ZbP0kDTdtsr7j17t/l4rbNtt4vNttm/5jzyNWx9WYHxqGHbRebbt5d00p1PcII9V4RqgcismRofFnEFqj61XBABGsTOKhkqGCTl9aJMBXriyAJjce4aL2T7bh/sqZqxUMbIhh8anHP0MEpgpviZK1y4HhlLlTHvanIHZZRFCm514RdMsBitsjplBsYMlJhH9Si1K4EGS5WgqpcVqm8g1K1r+lcKsF+S5MFU5+5Zym7xKp4RvQHrtM53kU6355FfXM2HLVsu5iMmLKH0hXgCtAEA8opHK73dRaE11D/9t6+T4lPKyFr1wlTaV6+erURtV6fEr0/U85Mj1PahFqSmcvXHN88EO21lWBtW8+VDh9y3wS2snQ97UNtP/ucgV91+0Nx/Hf+FL/59w3RoejfEtE+JtYeGTr7oj/GitkPxCPnnxEdHStjwV3XxoSd9ogp+z0jmlZneZ2b0I2jX1sHz7KYffOFMWfuDTFuzKb50aKXXXtSbD3zsHUEb9On7hXPf/qXY/rUffLJbUuWPRpjJkyLjgktMWrmxLURnIzSolRjoSK0KEt7FGUfwzlNSuRWrt9yMCE7KHfy2Eh13lgTamkGQ+ufDYVqRFeh/hk797HaU9k2ZHiGnGu1ZRnZFuWufYKF4QAY8d7g5xO9nFgb9Kc+4Y0RbAwFN0fu//UESxYIm6pltTjuJCB0fwUAHAOxmkxZYIAy5mA5a//OeWNB7AmZvGQkZaSuwbG7Al5MC2pcEJCgxEjAar2kNlWZudIBFkVWXhy/KijULpXWlrHOlO/2Xn+QTkqzlzEf1dqhhx9+OJ9LMJh2i+1xPyR9xSOM+Q33QukJw+FeD8d5Bw1ZFXyFTa1WSnFIOfizc6+OU/98RZ55rx6VRUdJmejRc8+Mxbdfl///qElTYrtXvTdWPzEvJmyzc/69MfOyaF6Zxdj5bbFiakt+UAl6/Z6rfh2bjdkmZk4/IBoamuLaG34Y++7+pmgd1V2vTbjr/r/HppN3iM2m7BJXXP+d2HWfV8fiRQ/HzC0PisamUfGJjxwdLzhir7UqTdef2kbKfTYPRiY+HLAwZDWVhCaDRR2uD9PY9Ik6/lImgZ7qTV1qoAKj6bMRZAnWRMgyTEZ0IA+0GOlg1BjsamuDDDUKVkuSEhM6l3FKWolywICoowpA9YczxNqpBgtoTNR9pXnfgwUUs/VnTVWaE4HOFdDU4kw4wtQCVnoyVyVwuBwFDYhAPKm+mXEJijJK6hqQmQp8ZakydUGAbNw+ci85Xu1S5WZMEDrKqjkvtHZy4IJmX4IUEyJ9Xs4+HQnaV6T7phSATesNgvbmNcHOUAgGwT1LZ6X7/HxG8TjqgUSpzx2wDPzGex/NnTe0Nxacd0NE+9KFMfv83+fOe4c3fzR2fONHY5f/d2K0L14QLZM3jYbOiDHzs2gmDF9zv5tXdcXq5Qvjqj98PKZtsX9sOfOQXJR2652/ixmb7xctBed94x2/iodnXxFjRm+S//+ChffEHjsdE9df9YOYvsWB8djs6/Nk/vd/vHZtrRe1VMl5g5vDIFicQw3Ruvr8UDpvULsUtFRbaxouUL8a2SjTqKY1RLnESE+dBX6X87YJGCq1vXSK28YAJSEBTbVgrFGBKWNkSMuN0pT9yfRkdOhVdVDOmwq6mtnZIxmVMmVT64iZKK4rQaBTqxNx7/ScU7pXO6JZfR31rSxYbNny3rJXGbhuG6/BeYOgg4CX7iXto9RFU0n/I9vnpDznZCcwNfaVzF3PdiqnYDr7i6Q+LzIEPUHLGPicQ8UcJrvic8v8B8t514KaHPj9jyyI7//m0mg2DA1tngTYDixZtTLu+dGXYtHN3ZOdWqfNjJbpM2PU0q4Y0z42WuaujHFzsmh2xLZjFtu7N0vz8o645+pfxZSZe8YmM7rp7eUrHo9pU/eKrWZ2L8CEHbc+Iu5+4O9x9wM2UhYLFt0bE8fPjK23OzyeePz23PFba/c/8HisXt2eCyMs8t4O70B/pJnOQwmRL+FIqUJ0sCETNeiBMdgQQcXL6BLWMFw+azJCMhdB00iD63NdA3XQDEW6+1ALZINoYMbRvSt30h7Dpf5JU5KoT5DZ9TcL6w2p3WuwwDiXAyEXZb+1RL2th77U2WMw/Jxr9JVqugIbzEY5YDrcN7R1qn+rmfekh/Fs1Mx76u8WoBPtysTV943RLR3zqXUMtd7TFEZCR0mQ1xPg+cxspC4egXI6Z6JSfbgWyLoFCxjT3qC7AtN20kknDcu59CMJNTnwd554Ztx+y+xoWtYVo5ZSj+vjjsg6O+Ku7346/5ktX/aW2O0jiQ4ytKUhWlc3R6xoe7KOTUS1onsDrFo+P1oaxsQuh745V6NTr3dlXbF06aP5a+cHnDgfvKsjmpvXrTE8PPvyuOrGH8SihQ/GlM12iaamJ9tlbrvt1txYe9jVOCrZh/dhtIaKXlZjooa3eLVQDCXUzYrq2w0Jspo0TasIFKOshCALBTdSgCazVgWRapx9cVJ+x1qSmVH1ypTRun1BOgugFPYF2jQJtYpwP9f34xqrqf0LiuhptKClNry0n9L9JgxLY345PdqCcoOSZHLKHGhsLUsgs60UxPk5A0Q48WrmV7hO9W1BBwYKBInKHK4LNc5hCkh8TzJhDam7Jwh+0ftYAnM1PGOzyzlbtPwVV1wxYJmoe4DN6U1VnvbHx+qal76L2PKTQBsa4okbrog7Tj4hmsaMi+ZxE2PCTntFQ6GmkkUWrWOn5DR5nh5nEc1L2qJxdbcBbWxojqmb7BKtT7RH4+qu6BjbFBPGTYum5m4D4W3+dcVn4t9Xfj4enNUt5X/uoV+IA/d5T/7/y1fMjRXL5sXc2TfEppvvnr/HjjtsHvvvv1/+7+pS1UZpIl/9s9XWowYChkXYECJxQcRQYkPtodbLWhybWwRltoxnuMoHjLz3VjtO0JJDBa5dhWimVkqQElh5gHNl5GV/vvraClUJgkzsjYDTa3PkMkc9sxxROqFqfQWthHWjpavS+khDb+xbQYu2PYEhxocj9HtKOcmpYSuwFij4cqBRkOGmeq4sv9wRohTO9CBq8dWOW3WN1obrSa8vaKes5sB9T13fmqFS19GBuXHNBFpFCAxlvQJNX8p+KPlyLE1fkUSA/uwp+DRcCPuTjfAS4Ih14PkZ36MjGjqyeOyf3bXjrKsrtn/bx7qNTxbR2B7RvCKiMWuI5WPb8uza9xvcdBNQ27od+H0P/jPGjZ0WTR1d0bq4IxrauqLDz+bpd0N3i1lEHLTPcTHrsatj951ekQcFt9/zx5g8cduYMH5mzJx5YDQ3j47FCx/Mf+dFR+29NipmKGsRvaC1RaFDCVEt44fSKhr2OmoHw8TYVBKsoTS1+ySDNhTQWoX2ZOAZQYM30uAc2YZaqFnYtQ4FMubRAAy/K+NWm0wQtFZr6KsBY50yQw4LhU4c5X3UzdUu+zKJaySBZoBgTftWGplZDjJPIi8iP86RCtkBJMSh5eC5aO2rBM+wt3HKXpsDr6VjRdeGtrEiM0I4x0anVjX7hc0zrEWZQG1cKUBLIqaqWCqgcfAzNBDKAtrMvvOd7+QM0kABPQ89iSElWf69YYR2zQwlarZiYp4O66EhovnJDoPY6hVvi0f/+suYdvjLY/z46d2O2s83NUTjhDH57yxrXR7j28ZH58RR0d4QMfrxlfHYvBtjt+1emjv0rtamaOjqriHNmnNlzNj12dG2YlHupMdPnJm/HuHaZpvtnmfeLS0TYvOpe0VH24q8X7y9fUVk7cvjJS/qbiey4PVgitbQWNoeRip8ZouS43HN6C9tEoyE/5c52nQifZlWfyfAbWhgjBhgVCUjU2lzq/MOpGOrBoyhVsWk9uW0PVdZq6wH40NQVMvRk7JAhlm/8VCA6BFTkMamEktxWrIhBr9WuAdq5lgnTpPQyvoeCSfjyYJ9FUFIKePD7vgTWyegEZi55oFmO4og1BJA1XJQSCXItlPwKhBBm5fbD9YVYZ73LmdrPHPBAMcvgBmoPZUU1+wdut/sDvZPzT61AKvvD8fJXxtEBt61lo1Wx45oGd8tlHnoNz+I5Q/dE63Z6LX0+tr+7oaGWLVoXjRMHBftROUNDdExsSW6mhpix+mHR0NnZ7RPHJXPOO8WqnRFe9vy6Bo3KkZtsmnsv+8781azyZO2jbnzb4nmljGx5+7Hxrhx02PihC2iqbklNtlk+9hy22fEvnvsG+ef/4/8bW00J/JovVgfFLKcs8XJuBOG6HUW6fsMRDKoL98TsdtA5ai2jc1pmzYm6FHjU58krimKq0qBoitmqkPhvNGMxVYdWU066QoFa0yp+nK1A1A4b9O6ZMFDBRS/yVSMOio9Df3pi/PmDK1dtLJnhhFBOac53OXO3R5uEI3RVdiPeq9ligJGtWgzxKs5XMd6xVIUj3AtQq06idmKsKb7etBHKQRKHHLS+1RqixOkcfCEbJy+EbHlXkur50DvJ9dG2S6gxfCwhxx5WjsYp9K5/Rsras7A80EtORXenY13dXQrqPd62SdiweN3RsuE8lNxTGNTG28fm8Wo5Vmeoa+aPi6aY+u4d+V/Y4vpz4jWFd0nmDU0NMaY8ZvHqmVPxJjRk6OpqTtq2H/fd8TqtqUxf8GdsXjxQ9HWtjTGjp0a06btG7MeuybGTZ4Zb33bC+Oa687NIzgLjLEkThnKI976A9SdrEYtTt0rDZlJ54OnjcQYEKGoRzp1aH0IUCpBUIIOlt1hTUqPV6WmVeMVnaeDXxhSUK8krqkWRGxFkc5gggEEjEkRaFdsEKetNxedzoElJ+/ZCjQYMsI2r4PWRYfSLajhM+pDCdfCkKvnCiAJ5TiyWuFz+V0Zmzqr55imwHHcnqXnz0gPNVPSEzg0z8n1akv0TGtV+bNFSmVeC/tAAGYwEShBKKE5Uaz0vgvczbQYSGAPCPGsxUpOHMvii/3saZrcYEBbL+W8YDwdpGKdYFKhP6NbR7otLI657g19LAQ2rP3vdoe9Ou7598/ilj//b+z48uMrHhPKKecwtKU5i6wrYvXU5hgzc99oXrE0rvvzN2PPV34qRi/JonVRZ+x+2P+L+2/9W4weNyV2nP7smDf31njiiXti7rwbY+edXhJjx02NyZO3zb+XZZ0xfuIWsXj+HfHwrBnrLEgRfXLexvSJpIe677pWMFzlhisU4d+JX6hEUakMvex9fYPhCAIVNKoMhApbv62Mg+PW2iNj8Wd/RX6MIWHPUAwCUQ6RTaUjK4uwHrXgcGYof9PLBCacg7IJWta98Hf/j84VrHGc2JiBaNupFhyKuj3KW7aNuhRsWXOeiYCr2tP00LF+h5EyBMPeFKzIZs1qEIQKEAQ26GIZGMeh1EAZLxuzBvysjHc4JijKXh1A1Be4fvoBjohmgdYmOXClFFqIUsGtNVvJwfb3c2AQqmlh5UArUdbWJhGjvTqQsKZSYCewp4Jn4xJ6Gm6yPsMaqGW2fE0OPGn+ig560hbdZwRP3n6fGLvFtuscI7pywexY/uh9MXqzLaKp9UkhRVdjRPuE7k1vAlv7iiUxeds9Y9Z1f40tD3t5dI5ujFHLJ8QuB78+rvjDx6KhvTPali6MPXZ7Vey+6yvX1jfnL7grGhqb47G5N8b0bQ6LXXZqy6cEVWpnETUPxmYoQmRtxnp/3gddbs5vtRtRZM/4rW8OnJMSgKR+Uo6NYSe+kd0Rq6CaGWvDKfoL62YgT10zIY6TLmfcOCrOuCcwoJwQYyXqRg8yTFgYoibisAR0uSx9KJ03qO+izdHcQCBoZKq9JMhyiEpvwipiN8+S2EmAZm1bryh09Kt+aCWBomDLl/dyj9xfAYRgQcnBPdO5IRBPZQfiT8+jr851qJCYNM87lQrcH7XocsGe+67+OxhwXwWIPQn27E2DY6zR0rMGEnsEAoHB6slmz4nlqNOVMbzvhoof/vCHa88dGPBRqk875svROG5d57hi4Zy47W/dhmbv40/Jp60l3Pun78fkHfeLhsbG2HSPQ2PF47OiuXVcjGmaHNmoiPsv+Hksfvh2XjyaWsfGLq/4cLROmJK3go1e2BXdhHrEqmULYt6dl8XKJXNjwoQtY3TrpIiG5li+/LHYfvsjIkaPiq998ZVx6ME7xnDD8BgLrT+iFs4fbZrqPtVAZE+8xeANtZHvCwhUGG5Gt/QwgiQWUgYZLqWpa0BxJsOERnQtrlUWf8011+TZoHKHIMSfomYCIRkDp6dPuJIyWeaNRkcXcz5YB1mnYGw4zofvDcXzw4v3CPXr81eCf5PBc05YCeta/dLzZYgJ+Ko9QhLtK6BTRhDUcUBqpQJetVgdBgLo4bx/np9rMAlPkKP0IcDpaU624EQ/tvtQmlm672j3cs59IISJng12ozco3Qkoi/uRUyV2w2gJuOt16RE+SvU1R+//lO+1jltXNZqt+Zp3w0WxfPb9seD2K6Nz9cpYOf/RmH/zf2Lu5efmzpuQbfuj3pZ/tUzcLDpXr+h23mvQ2dIQS+c/FEvmPxAP3fr32GKfo2LXZ749tt71iNhs5j7R1rE0Nt/hkGifOjpO/NzLqnLeNrkFOFDTrkohG1FX6s/MbQ5NL2YtzhvUiFGPFKEy8ZHeI4kW5RTLnSTkGbmHw+W8OWD1WZtHlqk/WC2Q0xacyRY5Ca1BskAUIoZAvQ4dzNjJWrSPlYMavN9LtX50qnvBmQ00FTlQKMco6dXVUiTIsfZQ5By6skhSrKuxWtP+3/5T/8W0oM7tw1rOf+YEZfAoeBBgcZaCJ5m3Ellfz6UeCKTzvN0HY2bdH3VcPfkCj0rArMgsyxlqLMVgZJzWprVdjfMWlHjOdAlFYBFQ277U6KsZhFPHwKImCv05B+4UZ11yxzrfa2oZHWOnbxub7Pa0bm69KWLV/Lmx+L6bY493fDUW33tTtGwyNR79z59j0tZ7RGvz+Hj4ot/ENs9+XTx+91Ux/44ro7l1TOzxzlPWeV3tZ4/ec3E0NYyKxqaWaBo1Og8M2kc1xvzFt8XClY/EUYe/Od72ysPigD23rmoRynBkUwxKcY7wQEGfb1Fg1ReIYolZ+gIGQBYiGxcEmC88Unsl0eQjEQIfjobjKW2fUX+G0sMW/Jz6sN5YBtHM6EpgBGWMSVXseaGUGXHZ2kiYr1wtElvAuHPKFPe+ZMUYBWr1pFLn2KxL2agBMP0ZW6xGSB3t3pkIJpv3lfYAZmQgWq6qBaaFqt6QFDVtrENPh8Aou3D21Uyus9bQ7u415megeu21AFZ7hLLnBp6pgFtwLegEzttnFYBgCdaHQ5JGip1RNrFmsHZKJX0pgdbkwKdtOiE2mTgmnliycp06+IyDXxSL7r8hlj1yTz6Rbcn9t8UOx7wvP1GssaU17v/j92PCjJ1yoRmHv2T2XdHYQdQxLj89bOeXPLUlYOWCR2PJ4/fFZts9LZpaxsVjj1wX03Y4MF5x5L5x1EEvj1e85Kj41idfXvURbgyNth0KUlnqYJw+hkJlUDjyvjphxqC/B6ukQztkeM7NTsc+1tE7PDuOuNY++3S4Qk9gtNVxTd1L4HjQmP5M4y7XFxCT6YBIwTCHqn6HrYAkxOSwDK+x/wSUygrFMaR9BUGqvax0xA4whLQDMlYZMCc1FFDP1wIqcPEMe3LeoJtACYDTr6ZujKUg6DJVbaCARcJe0Fb0Fki4XiyCe8yOctS+dCUkBk0tHVswUktAIwnuuTWqdIYJofUo7T4YlBr4c95zSixdnUWsaVVMTryzxc88FPf+/rsx45kviU33OjQaR7XmUUbTso648bSPx4Fv7j6S7uFr/xpTdzooxkyeHnPv+E888fAtsfOLjov5910XoydNjXHTCOGyGLW4Mx667k+x7xGvi21mTo0HrvtL7LnTFvGSF/9PXrvRDiRbrXQAQSXYBIxINQa3FqADU38rQyW66gvQtgPVPkMcI5NkZOubqndQQDuBS+19ICETpbRXNrB5i3Q0GpJIyXNaX1odewPnjGVQYjDwBNWdpn0JJgnaqu15rwb2XekQHJQuxz4SkEwsu5Mmn+m60CpKiV5tyY1gTIY/UOdOo/ixBUoP1Tp9gaY1W9qXrlTg2gQkPZ2mVkfk64Dmgf/CkmLsZOLFWQLV1sBrE7G96asRDhTRB27CXvbkaNV279HdxJ1/r23xgph9yZ9jm/1eGo/ecF5sc/Arorl1bN433tjcHXXOv//6WPHEo7H5Xs+OR67+U8w48OgYPXlzp5nEsntvi/YlT8Qn339MvPMtb8hn9XK6WorMA1Zv0XrRXxDVGAYiYrex+tqqRGxiUhBlqVopgdZIgAMCtB+l05HqKA+1Z73VHOxABzuEhYz0jBkznvJvaudEWbLWkbJm+guDTSiWOXK1X4dOGBqSWpZuuummPg2AqYTkFIGxS0dkChwGclZ3X8AWKB94voIZ16rMgBnDYNifSWWexI/0AeXWoNIfg08/MVCZrmCKrmMgAirPVeA0mGfCbwh44xvfmOtmdCuB8oOSBKZK1wcqfVBEbJ1dazy2seZNEVlz5EeKdo6JaOjsnl+edWXx2OXnxoPn/DzGz9gpV5dvud8LY/Gj3fWW5Lxh1eJ5sXz+w9HZvipWL30iF7E1eI+uLNral8fuz35hTBozKu//S7VBmTcja9EPxIlSjCbRjcygr6cpydpcnwciuhpJhtjQDCzFSBe1DScEhYwPMdRAO2/3Xd27nPMGAjkZy0haM/0BgR7n7fPqNEBpYx6S80bbDqTzBs8stewxfE60gjT0YziBBdNtkFqwXCvaH4XKYSfn7f5IAJQgKulWGHPBkJq0oNC97uuJcwkCnIE6ldBzxYSkmnkd5UHgSn/gUBj/79lLsDjvak6ZK6Lf1kotGzjehvaIRXf8N564/droXLUiVi+YndPhrRM2jc721dG2Yt2h9ysXzo7JW+4eLeMmx/bPfXM0RlM+4W3JI3fEpK12iQ8ee3guklDLMk6vCFEJ1fdAQNSL7kvCjFrBUOlpdvbuSIPMxHSrkSpmG25wLqjJwWjTSSWb3gRVqPOReEZ5rSUk4j/MGLGTTCwJ1WgKtDYq5bzjHe8YlPcXCKX1nnrKlbKKwz8qofTkrYGA9cRIy7AlHEVNhezLexaDRZoZbXEo9Up7FXXu32lc6G0o8n1WuorS88l7AmYiwf0aqOBeKUOZpJYDVzZG7LzzzmsDtxSAeQb8Wa1nAfTbgVtqjW3dlHqeg3dlse2Rb4qdXvnBaB43KebcfGF+cSuemJUPbYEVT8zOFeic+tRdDstnmY+Wfa95zY5Vy2LJnRfFH356Sh6ZUP+qE8hw01mxomwRdi0LtyfoZZStioBRQDYUWkmUpH7ZE1zXSBaKDeYpUXpDKd6JWNY3WJdEa57xYL2+9YmirAQUurqhstD6DO1baqActOyQEDO1KHFUnFZpED7QcOhFYuVMtFJjlF2qhVdq6QPCVvPlMSUDkY165qkHvFLZTlnLJMWEL3/5y7mCu6f6trpzkclxf2Xz9ndvp5klJEFhKj/6e6pZ6+nuj4o86RDqFHp1uhhQTlF+9dwrzYzoCTXVwPd9w1dyFXk5TJ08Ps7+ylviF6efEec8FvHgAw/GY1ecGxOmbJvXtyfO3CW2etqLoquzI1YtnhvjNt06msZOjObRY/PWsyLm33NdnPSRt8SrX3LkOt9HkxFQGBpARS7qVsPRM63GhALtL0weIsjYf//98yBBNiGAIDAwUIEASZsYg0UAsjFntlSUxizKMtT+i5F9uTUkIxqsDKxWWPaEJAxp6ez1gQJlqVpnT6N7CYi0BzF+aebz+gKGh+PAPLEPlNjKSdgE9d3hgPvtvuupZxRl4Ca3qR9XOrktaVZktAJ4AV1/9jUBn4Cek+SYhwI+J4qdMt/nqHT91qJRuBhD602wRbTp2ckAsVGpXbIvUKOnJ8IQDGdP/kiHYDFl20oOAkd2iJjVXhpcEVsZfPDVz4o3HNV9Ss95V98cv/nVGZF1duRU+jYHvSJm/fecGDtli2gdPyU23/Xp0Ty6W4nb1fTkoWUJUxfdGMe+9Iiy1KNapWEpHGsyIm4GKb5FU81gglrhFnHWHLuomtjJhq90qlB/nSLRixnDDFCtA136A3QOoQ3HVi3U5GThgp3Ui1vJUVlH5n4PNzxPVJ/WHIZrsMCZyT4rHRMqUyPOLBUYyoIMJqn1sIyhhGcp+HGNHLbPwAClUaHDfW2lnRzup+fRExOiu6W3QTooaw5ewtAT9S6wsYeLjlSAa70NVsAIaHv2iVPWCWPtVTopzTqTCZYLqvsjkpPRs11sNfvV27kOGxPOPffcnLH0bLB//j9NsMOGKONy4oMiYps0fvQ6zraxsfsvLzhk13jdEd1T2izsy/72+2hbuihaN9k8Ntn1gLjnwp/EtD2eHdse9prYYt+jcudNud45qvt0s/bVzvNeEXvvODPefOi0+McfzshbekQmIurionKogwgzQUaM/lZ3IQoZDNiEsiQUlo2Jphto5+1BcYCoe/QfYQPa0USrSvBvHn6luemGA1RzWEHq9eTQUg95tZDp6AfFSlSKBVOZo69DSrq6srjyrofiq2f/Oz575gVxxsXXx6LlhcPoa4A1YlqYGqVMTdDXXyFQJfQWGzOQ5Y6PtPb7M+hkMOFkLIaHcUGVWjMoaKfCjQTnDQxeEo2lU9tklz3tBWyeWnJvEKjK2A2v6QlYqdIs2P2RaNQKZUNajWog+0Wry7Ctb/aqNBHiHFyHYKWc86aZoYTuaWJl97HP5dd3ChjYZL35RML11rLIg1xzAiSDtAySQdoITl1C4V4pp9VSFq4pA3/40cfi4psfifOvvjOWrlwd282YEq88fJ94+t7brV2smvlFFc99/Tvikn9dFBO33TMW3nF1TNph7xg3fdsYM2XmmmK5YS1zYuW8R6NpzNhYfcu/4mc/PjWPHEXKFJkMmYefer3R5ZxauePWGBH0N9HbQEOWjxIUrQ5U/6rbbvCFaB7dps1I8FOscXE2KC0HtJQOh/D76SACjry0hxhNxrkbLEMF2xssJoFAX7M+hqPSZCc1P2uIw6q1Drpg6fJ474//HHfMmhfNjY2RRRad5gs0NsTbnn9QHPvMfWPK+Or1B5y1wJBxkiW49+Xm1qe6VH8OaPAa//rXv9aeOFWEEpC6t80q4i59thTGgyWs6w8wNPaAABb9OpKhNsxQ2lfu9frQiWHNWJMp+7U+ZNFsIOaxLyAuTDaUTeG0BWH96Sdn79lbXQVYw3I1eLabg8K6SVAGSnS8viHLslzciR1WzsGwYmPMDHGYj7IH5y4RVYLAyhGBsukDSqH39mLFjXPqz34RL/rYV+PRy86PlklTY9X8R2PS9nvGuJk75G1iq5cuiOaWsbH3wU+P9774sNh5Smv+4US2ok2iE9m1dgu1Au0YFov6TCUnzTBzVgN9XKQIGAWHNudQa53SlepiMhZBgI1jY3odD6nSBC5RtIzcZhNVe8gUvShLwYwaUzrJqwiHDFggNlW1tTylD+/VE83YE7yPgKQcPej6tZj4vJXo5EqZ97GnnBl3z348b2HM5+w3drcwJsVjY0NDHLn3TvHxFz87pk6s/gQ4waEMwWf2TFB91luis91nhk7w1F8Veur3TCBcERAKZtaHATsyNY7F/aJ1MHlspGs/lIE4DCN7iYNQ12yJ+z3SBubQEOiXtwcp0Y2JTeuQw/U5+tNmiJYtsiOCbR0B/bGTEopSxlMdl3YooTgPw/kAPqcsc2NDQ0NDLlik4dIGzcbSZLDpgnfO3ZrEUkgYMKf0QuaT9OZzB+xuygId8ccYynKOOvyZ8du//zPe8/3psXx5R7SM6b6IRy46K5paR8cJJ3423nP0YTFu9JP1GdOJSsHRyZBsQnR6TwbPohfdoIEH0omjflFKqPO+Rq0oUYsX/e/Qi2oMoIeK7kVPurcctmxWG4Jgx2Y3LEPtrghRnQVQC/Qf9nXYS4oBZf2lFDxnJXjxDGsNDq6+5+E8807ozDqis21VdCxbEq1Tp+dnzHdlWfzjprvj/FvuiVc+Y6941zMPiumTehdQ2SgESzJd6mWfwZ86G1IngrJJfx14ORjcUg1dO9xgPBgT9wHco0rnQo80yDrtFSUSwRoI0gi3tDuNlLos+4ZFc10YNTameMCPZMbekTj0VQ9jrSvVJOdplC/RW3Gkb61g4wUahHoctS+saQL6nj1hD9gtDKPPRdRXjkHdUNG1hg7HtCYW1ff4qcS8efaY5/R8lFKrLdH224GLGjwgkbkIUvuI2chpnvTlp3w8Lrj5nrj8jgdj+cq2mHHwx+KgLTeJ5z1nXadTCRy2KFqdtTcwuhw38cRAZ+EYAZ+RMUg9p7VALyhaxKKuNXvxgLV+CCRkbkl4pR7nQcvGi7oAkV2t8Nro0b7A5xHhlx5jKiDzurI3dFGtuOiW+6KpsTGWPHp/rF40P6KlKRpHj47msRNjwbWX5HP3J+y4RzSPGZdn67+/4uY499a74oy3vCp2md6zmFFrFwpYcKF+709DFTgpQqWvfOUr+XoeSKDtlRk48EThj1S4D0Z9Mjr2kgByfQKmhwPHntk72APBCIqSfShmisMJ64EyXPDItiQKNUHAJODoD9I5EMpkPjeWsq+zt4tQW7dOzOkozp33PVk+555a5Th7rXU+z8bkwIE/NDDHumMrPQ82EWTlWhixLNanEiYfIeCpRi/RWGtUqwZdfFDqSxScBqFQJDPianfoSBFFS3Nz/M/+u8XXXv/C+O7bXxq7TWiIrbfcour39B7pw/YGGbp6Y3+O86wELSgyyL44bxBduy99FXN46LQFpapplAwjMFD98H0FZ1icsGVhovcZCrR6McCoFivb2mP1onmxYs5DMWnPA2LSrvvFhO12izHTtohNDzw8Ju2yTzx++T+iq72tm1HviFi+anW8/3d/yx16bxAMCTBQwgK0ZIzUpOgH/DkQSM+GMXNPOJVKyuCRAi2TxDaoVvt7uNrC+grlNpBpoiDVwFNQby8XxbHDCWuB87a3rT+Bkr0+kKIvz07ZLWkW7MeBaG9jC8uNs+aksDfFPnetv7qFUMcbExobG3MdkvIiB53geSdm1rpkL4v6o2qPvK7JgavliRAT0CbqIJy2+lI1tWGq1VqGBciCqCJ7g8UvWxDJWKjU6tUqNwcb6Ctf2kpKj6IcCKD3tbgNBdJRiKUoUpIyia997Wu54RTtKxn0BTtO3zQaxk2Mrs72XLxWRB7JtrTGZoccEYtu6w4qOXGa7ocWLo4r7u8erVktOGujdFFZar6y477qAYqQdRBSgftBv2GfDHcNWVCh86BSbzQdy0Af+DPUhpNtwg6m4SwcpUxISaroXIYTyl9sKhvKGRI3CnbTmhkI0NhwCBwJWH/9EWf2FZw6FB3Zho77778/t89abQVS9GRFrZESQ7nW52rHetfkwInJikMpCHRQjbJANEBpLbYSajFeMmrq6J/85Cc5DeSwERPTUotUym44MEaXIEBtQRtJrXXgcsaXirg0UEDVe59qx18S5jGIg2W0E009WO1Qxc9OIEeU5hkoKRSByieY8SxQlmpsxXpere91x+zHIxqbokFtKCvPMIwaPzEf15v/TkHkdvE9PffzlgMDr4vCs4WBqPeiEj0b61SmP1Im9gmyGPLhPuxjMMEIop9T0Mw+pGFDKN2RdJ1sqT2F+pfkDMRxq0WowSpjsZmy/lqPrk0jXvvSBlf8nEptA3Xa4voA4kTwTAXMWoT5AgeY8FOE1+YpsHeV2oF7Qk0qdGIWFI8mdI6VwXbykFoI51GuXaYcZMh+rxoa0eVpQ0A1pJ8XTRJ3iSL1partoECLIzH9nizQTetplGUlKAmImKgnk+NlhDkwhsD7UaarnSojMNTlrt3vygRkOkoKRsIOBlwHtkLQ4fqS8GgggU51L31uzo7ewWcnXvGnz4gmw4RYpL2di1wJHZ1d8fPLrotTzr88ltx9c4zbaocY1TzuKQN/EhbefFW0TtsyWrfYMjr5xyxi4ujWuPoj785r6L2BkE2LDtrSZxMh+xzWk7JRX8smxSE21gAGa32btrYhwp70LDzb4WZCEmRoSpCCYlm4s8XRqv1de0UYCa00IuPHpBHGlQN2wqzuD3/4w2u/J1khdJVN1uLEsaD77rtvrsvhI+wFwcr6zO7UAj4AG8TuU5UX22iVPrFDklL22/NPgVW1nV81idhEDB4AWoCKFmfPyfk+tWdvEP35fSIeG4cT743K8XNqNsUaLwflkPsiSuMQv4eeEOFwwrVSRhTVsv60wS0+LWyCiWJA4LosaANNRPUEKG6+TMvndZ10A4R4Pnc18DAFK7UoZUW3nATWQc3SWFm98bI/zrSabNJ1i7TRyOUyZ8aFQjt1HWBcUMIWIAcukuwrZi9aEn++7ra4b96CuGbW7Hh8+fLImrLoXLU8mkePiwbceNZ9dG2pyR2/016x/IE7Y9QOa4SLDRFLVq+Oi+55IJ6/y7rnFhfh+VCDMmgpMBWkqOUzMhw7kWB/jKhsh3iFQK7uvIcfibr0fKl9BW72xmDMj6gF7AT7olYvW1NuwwaVW3vWaV80CVq6zJngECrV2AUSbFnpPHNBuqSAYr5asMlq32w+G85OclAbi/PubeCNpE8ipEffbAXJg+l+7H9RFNgTanLgxGF6kxlqVCmnpD5t4XFcqPRysFg4L7SdSIwi2+KkLNcepkZaafC/D8959ibSKhdJW6xqsOh9Nwc1mgYa9AZUG8ERhbKMX8Cirl6qHE7RlZYv6mWbL/VCG3CABdD+4aFU06Yl6mZQ+nJmMrbB/XK9mAnlDpE0tuItb39HXPXQrFi6anVsu+kmsd+WM9beM9fm+fisPreygalz1KJFypcBsLE9L85elgCYBe1X3k8AwMAImFx/peea4Hq/ePrv4ne3PxJNTaOioynLaXBOeMV9d8X4TbeJ5tVrj57vLvo0RHQ50tbqbYxobBkX7U3t0dXYzXjkP9wQcdWDD/fowAVJaMV0BryI2DV7boJTX/2p14muUWYj4VjLOrphbSaRm6Qj1cIFrYS3wwnOW31eYGxPlfarC+jZQeXBVM+2f7TuJlFUT2CrehvjKgsUxJYea+l3MXzKQOk+ShCSfRac2iv+XYAgcFUS0Eaa6vvKNfWTyp4EW8lnSLgwG+6vzg+2t1r2siYHrrbJAeszFomhwhl+RronB+shq0WhJhOoqWWs1HlqqiKOclGwYSQy6Wpqh5xW6QK1eNDKWANCJVS8jcHRVpo6RikpcpRpc1gWpGCgUtuPfy+XfXr9Wk+68jtqIX05Mzll7DZ/6hnNz6OeukXs+qrXx/iDnhEdSxZH0/gJMbp1VOy51fQ4sKUhxix8Il79qlfl7y0rVYcTcTNyPrPXVWdnKNJAiCIDIqL2b56VBWgzYwOIFdMkvXLPD7124je/ExfMWRar5jwcDS2tEaNbYsIe+0Tb43Oja+HSGLVtd1adwjOn3nW0RLRjlQrseMO41ujqaIvGUa1rqfZZi9Y9vrYIwYn2juIUNp/TNftectz9OXNeENaX9rk6Bg+pHTP1h2s1k3HKaNmw4aTU2S7Dg1wLej+BIxT8c4qC66IOiT1jV9Hu5cp4tULAWUnLlJy3xEbQKwFjHzghNhDTd9ZZZ+V7x95yj/kKiZPPxImj4tnWwSjxrU9gHzHQgiUJVBJqszfstwSpGvR7EhvqETUiQuOQK20AP4N+9UBL4aKJ4WT3srsUJXPqMlLRcTUwU9ZiFo2mrKrS5+FsOKlie5NNY4axaxAN+bx+1nWoGQ2HcrO/2Hn/A+Lx0eNj4t5Pi9Xz5sTKh+6PyQceFllXVyy/585oGD8mnvayl8VvX/fq2GTsmJxyFxEyBsVnyXh49rVOodNGJgoXVTI82AFGyH21iP+0eFTMWti9WDs622LhLVdG1tYerZvNiClbPnVwhdn5q/NDfLJ1TsHpXLE8lt92S3QsXhwtU6fF+D33idGjm2P7LafExNGj44U77Bwv22W3GLvmGQrO0NrpIIFkmKxFWQL6HMMkaNVvP5iHntQx9BDsC+glEBg6R44KXEfauE8MIiOvlFNuGptgU5mQJqcvWp9aoYwmc1SiYx+xWO4le2mPCN4lR0Wo/bLhSlUy/FTyo6Gp1rZvDFi6dGl+PwRr/BLWeMhGqXqIBndoJzvxxBOfUr/1Nmh3i5Az8DBFw0nVjZ4XgXoN9I0HLGLjPGuZCZ1PgTvqqNwRqSd4j3IQMBDdFUd7oqZkoOpkBHp6RS1YWeX6hHvnzo/fXnVzXPPArLj8z7+OFffeFdu+/vhoiIZY/ugDsfzhu6Orqy02O/LFeRbbNSpibMuo+MHLXhy7TRiXZ9n6RIlPBgJKKGhp2a1ASB3Menrg8Sfif05+UhCz6K4bo2XG9Jh99i9j2uH/E5O23P0p9e5Vk7PI+OAKgWJX1hWrHnow2mbPjgkHHBDZ+FERufaxIWaOnxC/fukr46ZL/5OXFRjGIqw1Qh9Bqeu0LmUdnHlPAWEd6yesR9kmg4my9Jw5mIEUjvUXbJiAWkcHu1aOmZN4sKNKmJxoT/SrYAVjprRWjnnETkhU7Fm2sPhaWCsBLruQWDlBOMW8MqqDYwTsBlalqWJsvcAiHV/qOgXyrsOfsvORIiQcLvCrghklUIkultszx2wP2ShVztd4T3R4OfGVh+QBymhk4agi9JVoDh2v/uThWhzpNTjxUuftZ6gn0V2cc6J1Eiw4ztcHp45X10yHpxfhphQPJtHTLgp3fSJGYOBl5OsTfn3FjfG1v12UnxTX1tUZC6+4OLZ/y0dy573ikfui7fHZMfXg58eiW66Jtrlzo2VN1L6ivT3e+tuz4iWdq3M1+UBuKlE6g0GYU8Sq9nVP4sra2/Pe7imHPSfG77B7RGGWQefoLFZt2hmN7T0vWdc9ZrvtIouOWLlqTrSuGd7R1d4Zt/z8F7Hd294dX/7Sl3I1bimsX4aHkSLSE2yq29XFZxsm6G9krkSuHIkSkgSitHV0OMH+sJGEsJgh5SiJUJro5RQr2bBylDKh8ltPp8LRuUhc2N5yxwILrHVgSGLYAYxmCmbdH0yaem0S0UnuOB8txqW2kq3mvNnVtIdcN4Ewp49qR9kTkm6saGhoyIWUWGNjmwVgShPVMn4DepiJbFUmjpoubU63uDw4UUaCCI8wLImiiCLUp9P8aYIqtLio02JF33oPNQOvI/LksBneSpBhl/ZrW+Rq97JMNRwiI6NfCUPSMYRg4WITiO4G8wzfgcJ1D8yKN//fWWv/3r5sacz++2+iqWV0bPGiY2PxnTfG5D0OyP/NQ1985/XR0bEiWnfdOVo23zxW3ndvzP7JqdHW3h6jhuDQgWWrVsczv/zjaOvojNWLF8SSu26I5slTonn8hOhYtCgmTNkmWqdsHh1jslixVWdEZ8SopT1fVz7wpcHaWhLLH7gjxh64Vyz46e9i9UOPxoQjnhGNDaPiD1/9Zhy+zbpT1hghBlJQx4EzcgMdyNQxMqE1VMYpeBf8D+SpZTJUpUNBQRrOoSQjUFBaSkLQSlAnxQhgDEGtW2+x68UUyZatVbZTRsv+cuZKYKWjjXuChEi5kmMuDVixqhwMp5/Eclg09lhAgD4vpw/ioIl/BR0SNEkZrRD1v8+hFk4AbO9trBg7dmwexAjCiqLFan3ugDlwRk87mQzaJCvRmqwWp+9BE7Ep1BcPh0BLWuD4ftS3B5oOK/F3IirZsN9HwXoPgUFShcvitSig30spITUj2ZPrKZ7Ypc3KAlVf8Lo+lwhXLYyIrrSORElsAdt8aqIjGe8/469xyZ335yd38WPGiXI/yx+6O8Zvu0ssvu2/MWmPdTd1W2tnLLrpiph48GF5Bgy/eesb4uCth4ZG/Pwf/xlnX39rrBqfxeo5s6Jl6vRou++hGLv1DrH0iitj3BY7RMcBm3bT5llE86KmnE3ozYFno7J4/Py/xNIL/hNNm24SW37jE9E2a050PL4w9nv64XH+a57MUqwtGUFie4jPsC9KJ309QKKO9QfKJoxnGvgyUA5c4sGxsjHo+qJSXHlOosNwo8lrgdfUfoTR0u4p0GSj1PQ5YQECJ1numNxawbHLCJWXXK+xn0ks531l48qV5Wh7zl1Wz8FzVGmITinY+pEy4Gio4bMnuhwjlAb4VOvAB+wsQw9JtiqDRZlw4JSG6cFw0kXnLfvm4DlhRlIfcfGkMdFpct7g9VJWL9rj7EXL6gUod/DhZdcCCM4bLZact/cy/cZsZMpw/dzosxRNqtuUE4Go3biZfl8AYTSjQz/UpETuIsnegJISLTMU/YXrofoU0WMiwHVxOFfc81DuvLuas2gf05X3Ri+8/rLoXLEs5l32j2ie8NQJSI0NTTFu731j+e235geF+Prp5U/Oux8sLFi2In588TVx45w5sWpilq9EdHdDa3O07rZDtDWsjNb99oyl8+6JTA2bzzZlrZmL7tnAZg1ZLLrk4uh47PHY5NiXxBYndR/S0vbgozF2393jrsXz4ppHu0+oSj3BDFHRaKknagGsdiZxHesvdKmkTLjIwPUXAkF7lJ0pbfNisAUKjj2tZe6518QUKkNKOpyxIEtnGw0JYWPZYmXGciOPawG7hd3ETLHjHAm7k17X++nOwaIWjxb1mbXnsd18AhvMLqfPy94nZ25YzMbqvEHgIyBybyS4pUe09oYB4UlFfx6iiEy92YL1pW7CaYoStRNpPUoHRKg1+j2RacpsGU60tddIlHlPm04WzvhyaqJEVDgRBbpJn7n39doCCdG1hS7K4YyrVWyi1tH1MnDXbCFa1K7Vlwizp5ONiPUEGagu19Cf0ZWia6yFTSG4QUep0wpcUPyTjn1/tE/IYvmiRyObvSwaViyLKU/r7ufMMi0yT43XDEZpHjchMkZkTf/0pXc/GHfPnR87Txucc5Ovf+jReOcv/hirOjqjrbWrW2S2JqlefscdsfqRh6NlRneferbpuJw6D7KKLrXwrmhe1pQ78bKZuG81REw48hkxYeyTvax5VuXLvzdFnH7zDXHQFlvmGgnBYPGcYtmRdSSLYTAFl5XAmFGPVmpJrGPkIzGEnnk5cVdfUW35hY2pdnQqm8aOJtW38h67Zs2qjVvnvi9ZYHc4TI633PhSgX85vRIb7D2UHincUefU8F5DtphahjleiYykxuRKzojw2D0UQHDipb3sft6XfaPlbKSdzT6ccHiQe6msUO0I6gHJwD1Qh7XLvGWC6svoSE47XYgMnGrRw0Ubcd6Gv1hAatmyaBmP6WcCgWrEYyJEDtlrGH5CRSlCRDugP33fxvCaRBoWi4yqlshUNo+q0s+rbzT16wkwUET6HSuBs3cfvL+os7/zl903rIJ753pEa3QFIvhTzj4nVo2J6Bgfka1eHYtvvG4dpXZZ5+3ZtRgz3hVZ6nfuimjuyuJH/7gqLrn+3rj3kYE7EEZQ8KGzzo1jT/t9LOvqiI6GLA8gElbPeiSaJ0yIKUceFeP32jvG7blXjN97n2ha2RANjV3d0UZTROe4ru5hL+t8Fq9lCEx3Nh9j1jWeq267J1p3WqNjyCL+O2d2bqgEfaXtOYJDRtDa6enwGY5bFjLSWo/qqB0c1HC0iXLySjjVgp2TBHGwKXHgSNW7JUzq3+xD6q7h4CUNWEv2tTivQxbs/TllYBd9Uean9jX1d3YmBQB+vzgbgVDY77OD6GD2nVqdVkmPeiW41wKMas/P2Bgwffr0vNNAi/OQZuBpPB/lIidTCo7OoqP2NJRAzZlDRwFxhJytRSKLF8GJJNV5ehtMIJOWPRG6pcZ32RKnKaK20Cx4C5fSzyKXxdZylCOFPKddHPIguxdkeC1BSRGcqY3kZzgA7RLoWOIQD8br9VUYhcpyn0vf8/J7H4lPn31+tG2eRdbRvbnG7Lh9tC9ZXjFTzR3e5M5o3LItOhe0RdbVnjvxUSsbo6Et4p833x2XXH53NLVF7LrN5vHxNz8v9th+RvQVV9z3ULz713+JjnUG/mTR2Bax7M47czFdQ2NDjNtn3da1/No7GyJbtSYLj4Z8AlvnBIake7BL/vHaI5o6G/P/75zoH7p/f9nl10XD6NboXLQ0xuy5c3fU0tkQTY1ZruCVvZQ+D6wQJ15pmI52I2uU2heFqTZYx/oNdmO4ug0EgILJIgtUK9gcTpctVSaU5abTvyQtSn3EZNhEWTVo18VechpsIidNXIfZpCtChQsUiqVP76FmL6mR5cu8U/ZIjCxbZ4vtrWrGa9exLiSZSrMCr2owYFJjVGO5Y9ESRSUiRHM7mQvFzQlx5BSUIj1RYzr3m2E0fU3WTBVcKTK2kGT4xVPHqB1l4qbEUX9SmotsLErRqQVbrUSfipLDVC9PQLMZAIJtKBVuoJwYf/U0DgCtmjJ24g/UN6FfqQOuFu4JNf9T7sOFV0bDqIZY9ciDseTiS2OT/zk6xm6ySZ6B85dNq7odNmeY/mxoyKJzi1XRMC6LprFNMe6Z28Wya2/qTk87u6JpwoQYu8uuMWpJFnfOejze9bXfx08+/drYbdvahkV0dnXFH665NT7/j393n9FtROrD9+eT1nKGoKsrWmZsEeN22TW6yg+6y6+5sSOiq5Tta+o+eSx3yo0Rne1deRaeO/osYtll10bHE4ui7dG5MfnlR66dx9rU0RiT7rw9Xvupz5SlFq0hwaXso3StoAZpKARwxTbEOtZvDMQUs76As4Wi/qdWyJolBhIZvdjsBCpdAoMZVV7jrDlYgQqBbxp7LWjRokbXgznVNqZEiL2UeOnvTuWhdMYDapytxoCyaWwSZlA2zSZiXosDsuqoHkohBIPVssQD5sA5LHQkytki4nQNDEjzhZ3+w8HLTGXqFJIEbDLzVBeXraYTvIw35MA5w1KBEUGYrN/C4VxLR7BaRBYYyrt44LwFZ8NwoJSavUFLhoizNPuyoH2GcvVslD6jz/nLxtPnt4nU6/vqvEEtv3QEoUNAbp89Lxeujd52m+jYc49o3uzJTGK1+9nRFY3cYFNEY3vE6DlN0bSiIUZdOzZWHbIisqaGaO7cIibsu8Va2r1t3txYcvWVMWqzqZFtsUNMeLgzPvrdv8Q3P/jSuH/Fovjl9TfEnfMej9bm5jhq553izU/bL3Zck8F4hivbO/Jw4UOnnxP/uefB6EJpr0l02+bPi8lPW/feZe3ZOrXwp6An0mLNv1k3eZCyIotsrMilKSYe9exof2ROtExfc99XNsTK2++Od77iVRUDTpBhKOsog4iIOW7ZtnUjWK00VreO9RP9FXz1FdaTrLg/DpxNZHc4V043qejZILbVv9PwYD8NVknO279zugJViQq9DrDf7HURsvlUDlW7Fryy32hyCRo7jTbv6/HBdXRDOQUTXW05p18OnJNMDsoC4ZwsEtGc+qDab8peLS4G0cLQwiVK5IQthkTRaI1IynNUguyVgpHjtcBRTDJgwjSLDC1UnK9eRNFxJ1hcWADOlyOWfYlKK1FXghIiNcML0ukwSgQ+V6WDWxIMNhCpou7RSSgymwftJEL13lgHAUJ/hG2LV+CWIxow51rHOjq6g6DGNYd6NGaRtTTkh4TE6C7scbRP7YqWuQ0x9sGmGHVva6zkx3IB25NesmXzafnXossvjTE77BgdY7OY98SyePlPfh0dE6nXG6LLQQbt7fGbm27Ov155wO6xfcuUOOu/t8aseYuidUHkFHwI4NcI5GD09C1i2d23x/idd1+XKk8isxL4t65xHRGjsohVRscVjF1XROsTDfkXOj7vAZ/QEKvYkY6GaGxuidbttolo8w8R2cIlsd8Ti+Nlz+s+Va2cIUc5CgYYVqUP7YzWKc3Gxj7DeUOE5z1cB5mgrrGF/YFgksqdky0GpXQyaHCZuHJQYgOtZVk3+80Wst2JCYB04mACmpwYWcky2UG/54ut5vh70orU8WSphA2RkErudBLQDrA5HDabQ0fA31Q7C71PDpxzRl9zsuhE9Q+Tq/yZ6oYeqvoz58txymgsGDQPlR2On3jNRCwZM6fjw6CgqTJ9GAIhiyYJ2tIHTQ5Sht2XjZdOnBLpcK4+h8jVRKDSDFmNvZRGFX36HOns1kqgpve6ftZJQ15H7VRvvM1GhOIaRL/V9BurqWM4CEfaO7M49ZxL4k/X3pHTx5xc46osupYty0VsDWNGr3GGazwiz72yKWJsd41cvbxrVGeMu6c5YkzlFHf0VtvEqocfitaJW0dna0THmlMMOe9Smvus626Lzskd0bSyOcasbMiFZp0ljQTLH7gnulYuj/G77dPr502vm4vSRq+pnY/rjNBpod7dFTH+wcZoXlEMAvSKd8S4hV2xZElnPPLRr8Smx7w0xu23T3TMmh3vmbFVfPT0z5R9LwGkoLDYVeAZqy+qBdYVsxsm1H2HKwMfKEhw2FldFWm+uAEh7KUEKSUJ6RwIDleCglXS0lZUoxeTInYSe1jaG8+Gcvpeoz+s4saCb33rW3mply3h0ySvdF7KGZ6ZIEuZ1ZAe5Q7+bcAduGxUPVlW4k+1ajVdArRi2xdltJ/l5PUsqpPIcjlbtRKUjgUjG/ZBOHfRIQm9n0XriCqpJFPUCEVaQU2bUKOvgjDvIfvmwIk7XI96vCxZoCHAwCSg+tU7i8eQ+l033ihXFGsl540FcDxgUQSSxrQm2EBEJKWjDUHwI4pGccng3TvCkN+fdVac+tdL4r4HHoiO1Stj+WP3x+R9DonG7WdE54qV0ch5lyB3boTcHHlzd6bbsUkWS3bK8ppwJYzeeptYeuP1sWjW/OjUg/3YGip8zYZubGmJsXvs2d3ypb7e0RidUzpj5ajmaJ7fFU2PLolsdUO0rWqPlbMeiubxE2PC7iUz1rM1avT8dZ+MJdJQlq4p7fmfa992dGfE8sYY/XhD7rxLRXoL77o+Ft7z31g2656YecKHY+lVV0fHosXx1iOPjE+9+70VszCtORw2DQWthM8kYmYYZTK1HuRSx/oBz763iWgjHewX+1hsj5XdS6TYak5WCyoBm+zP1Da2uzf4ndIyYgK7VUd1oJsirPZMkj6gnIbGs6nl+OGaHLgMm1BLFIc+SShtxEejq0uL3NTB1RAJIzhwrQOcuuxcVCjbVouR4Wiz4pQJL0QjHFZSUiaIBA15oQBnZMv13xICoN4TTV1pIpGgg2OW9aM10gzkdCKVqJwTFkzoay/2iKLQ1a+8tu+LRNPZ115PnV6Ao+avnzidwlMKzsHrCByKkax7oh2DqtQ95MAxDg8tWxF/X9EUc6fPiGzh3GgeMyWmP/sZ0Tx1aiy667pomlR5ag+H2PbQ3Fh5+60x6cVrjiRs7Yqso7t2XAkT9tkvp8NXlykZdyxZEkuvvSYfADNmp51yB9s5ri1WXH9vNC+KGNM0ORq7GqJrk+aYuPt+0dD81L5T1P2opVk0rY5on5x1i9Uk02O7IkOdF1ZpHq8Rr0VXtC5oXue6l895IFbMfzSaWsfEqHGbxI6vOD4aJs6MlmNeHh899Onx3gMP6dGIp5PSCHcMy/HcBJXlemXr2HCAfpYF2cPrK9gstq6UkVRu5Cg4DpQtMbHDW8qdbFYKtpaNZa/1k9fSvVPHuuDfDAmSFLLjTmwrV+d2j3UAVEuh16Sc8OLUmpyS7LkSODT0QNocppypI/o9DlddXDYj+03UjIwdRcmxc97qj2rIlOqodnVnr+kGyIbQPGYXF3soZb1+TubK6Yl0iDgYZPWHciMSUf+yaDUevwd+1ohW/+ZPUS2qGx1eBEftoXgPh6qYDKcnUpAj0/YgRK82Ftah0pQdrAPWIkF9X+QrcBAcEdNxIr+84/545c9+E/99bE40bzY5Jj/z8Jh8wCHR4PzYa6/KhVqTDn9yeEk5NLa2xOjdd1x3BeT+qefpZi3dt+YpaJ44MSYedHCM2XGnWPnA/bH0yqtj1S33xNgD94kpux4QkzbfMcbP2DEmTNk2GhrXOMJs3a/m5RHNbQ3RsqwhRq3uiq6ZbdE1oy2ySes673U+R3TlgQHMv+2KmHP1ebHwnutjsz2fHl3tbbHVs14R46ZvE6OWN8Szpm/To/MGZQwskUBKmUIrIqNVd94bPpSv+trLzxalOeXDCTZICahY1ktDXSQiWDzlQMlUb86brVImla3r4mFTJRR19B1YW8kgHyOxleQOBGrKwIktLBTZdCXq2uxwi4ZD5jj9HMfP0XHGsmNnMHNuBEEoZFGiwIDh5MSpyzl8EQp1pe+plTOoIk0/z+HJzjl8AYGajlo6ZWSCDNzPcuScq/dKp5ylmpebqfbt7zJmryHb9r76e9Hs2s+I0VCsotcEQYY6k/ck0MMeECEkoUeC60PFiqpQV6VjFTkOn9X95eRtNvQU+gsLQXB342OPx5XjNlvnvq+8/57oWLY0sq7OmHTgodFhJGmBgl6LzogWR6wTZk+YEp1brlGK+rmuhu5WrLynWr258Mu5qKwhRj9uaH5E08o1Ne0yj75p7NgYv/ue0TmxI7LRWTQsbYrm7kmv0THWbPLIM2x18fz98vfWHtaQfz+hoaNMz3pXVyy77IbIVrXFxCPXCP7au2PPhffcEKOnzIhNdz8k/7n85zvbo6E5P3M0Ro9qii8fWZ4CLIXgUsbt+chU6pT5xgE2oa+BmiCbMeYsBeLDhXJtW2wFsVpRO9QbHCzCyWujZI8wf/Ugtv/AzqpvC7B0WJWWUofEgROVoZZ7AgfG8Snao1+SKjLVmAmEOHO1XQ4cHe7/UQqoBRshZeCpjsyBUW5zlJy/f9fP6HdEz4xtaStZERYvR97TYSR+htNUj0flez/XhmZPCksUq8yeM05ZG5ZA+4RItVJbEuqK4/fZBCalDhxkfCJfbIO+eMEJ4+C+3XLrrXF1Z3M07DA1Vj36SCy7/ebIOjuidfoWMXHf7tPFoLEtW7eXOosY81jEmHkccCoyR3SMa4ilO3VGpzZ2DjOfM57F+Ac7Y/lWzXlbWf7MVmYx6d62GP14V6zabFS0LGyMlTMb1nHuxfcyBS1ryqJpUUO0PtoQje3dQrbGzjU93E1rBq+sneXSXTfvHNWdgUPz4saIjidXpnu29KJrY/Su28Wyi66NrLOLXC86lq6IOTdcHZtsv3+MntQ9jrGhqTEW3H5VjJ+549pA56RXHR1bTX5qr3cp0roTIHpGdWw8IFxMk8tqBftAmNTTGdzDjVomzNH+aA1T1qNPqmNgIHFNJVJ+Y6C6Hmpy4LJvhg69S2Amoy2FujZHSwlZ7hQV2aWaCsqaCEzLAseFrjYxjeLcIuK4GGE1Zo6XcZXBiibRnMlZGmAwkFGsaxN1qk1zzKhxUSzayWZ14Hoxw+f0UeTVbGCfhwBQjV/mXgriKdm4epxWO3V89+HYdx0Xl59/aSy/546cht7siBc95XfXHvGRmPCGiLGPRoye/1SRV9Pyhph0S3Ms3iWLrJlKLIuWxZ2x2S3tMeWOjugaxbF2RfPyLGfYvWTrstXR+kRjjL+/I8Y/vCqaV3RFZ0tDLNl5dCzac2x0jm6KUYsjWh4clTvu/FIauofGaO/STtYxOp4yrCXv227Ooqsjyynxhq6GGD2rOVZt2xGdi5fFsitujLH77JJPiWvZYcv8NLGFPzkn2hcsjEkHPj262rrLGquemBtLZ90Vk7bbM1omTImmxobYY5vp8dw9dqjq2VtTugW0CVpryjX1QS0bByQlaOLekpNKWN+7EwinKMrpkyRMA3GKWR3rQomGAFk3UjWH11R78FWfpgeoOztIo1JNiBPSmlFp2AUnhpJWDxC9co4yVIpzfeIyd04UrW5RoRtQ3SJC1HlPB9aDLIrirxYITEj31XpEShyn0a+U9Kh/FL4oqijkEIBgHGo5DtDnk4ELclLNPQFlxXmou/vT59YT+JvTfx5LbvpvLL/3rhizXeU+5LVdY50RjavKO+/uH2nI+8bHzu5+/C1Ls5h2VWd0tUiRG/KpZ02dTZG1NOXq8Fz9bRjE7BUx4f7V0bSyO4Vuasti8m0rY+s/PhET7umIlsWy7u68ujvf737vdAXNqyIaKnTrrJzZGYt374hFe3TE0qbFsfSfN8fSi66LCYcfFKNmTI3Hv//bmP+D30X71Q/H1i97R2z31o9ErFgVCx/vHj7x2H//GeO32iV33rD9jE3jlHe+uOouBToH7Aqo/aWT6urY8MFelZvItzGA3WOnBa7sr5JkHQN/j+mn3GdJaE+HX6WfLzdxc0AcOINIHa2GXQ5EVzIXtHhP4Oi1TpVGr9o5SO45SyIxmTaqXJYL6geCAw6+EijAa2lx8FrU3nobOVdqe+p4C5oAz+ehThZ0lAJ7UOvm9xmVEThowUECYSAmQrCiVoIRMKv7e9/6Vmx+wMHRuvn0WPzfq6JzzTGiT8lkU225KWL8Qz1fg59vWZRF0/KumH5ZR05zd/8Dj51Gm0V0jWqKrqaGyFqbo3PKuOjcbHy0T5sYHRNau8vtyuZtWUy5eUk0dGb53yv1lPunYr27+3tZtG2SRfvkhjWtZA2x6o57YsxuO8ek5x4RTcvGRtO85mjddEbMeOnrY9MdD42GxsZoah4Vq+fOjtYttoplMyNmHvOGiAX3xiHbbJI77jM//vrYdGL1tCaNBBWyjWbSml7MOjYe2PvsysYG+h9QFiQyVsqrY2ChHKrUStzMn/WWgXPg1Z6KN2DngRejWUrxUgGQ2i7q2CATGY6FIuMtisISbCTUOienLo5aTkpPWSun2VOGhH6uNoIB1LiFLLuX/RtOg/4n/RewcKLq2OVKAokWJ3TzucxI9zkpQoun9pRCzc2mUefHKGjyV6JI7QMCFip7pYaxLaPiVfvtGZOfdkiM322vWDXrwafS5+rPxXYrJeriUV8VnPjU/3ZEY0dJPfspN6jg1Nf8vWt8a3RMHrNWMzdqaUc0r+hZyd5QmBiX0Dkmon2TNd9Y8x6jd94xVtxwcyw694Loam2IbEFbzDzqdTF596et/b321ati6Z03xcKrL43F114WL92kI77xvjfH06Z0xHP22TGam6pf2taUtkh6CiWSeg1844P9qIOETmdjQkq0dMtIVuoYeCjHEnRLDtIo8J5ALJ1akntDQ1aut6oEnIosUyRRzomVwktywmjJRBf4O6erxs05yXLUycuNMfVBLSyCNbSDFi7OPKkhKdwJysqNS+0LRJ4yfpm492bM9QGnQ+fBtXOoBG2lR+BpaXN/ZO5pprEaKiGc61TTL0flej9Bg3qHIEUpgYJdtu8eulfum7Gz/7rkknj3yd+JRc7EXrI4ph7R3S6ypvIdHRO6Z52v+WZMvDdi1LIn54+XRZbFhIfaKveA52dol3+Jtrbl0dIyLpofXxaN7Z35VTzxtE2jY3w3DV/xLTlfS2jNpNeVMzqjq4KyfclFl0XLVltE+x0PRSxZHc0tY2PU5CkxcZfuaX+Lbrk2Vs2bHQuvuSQv6wgIZdL+7G2ynWE9npvATQkEhWh9mVdfOge6jo0HymfaNktnW2yoMOsgsalVuII6+gjCZOJuOhs2ft99S4ZZFboABJJE3NX43JocuEwF9S2CsMjVg4nKLHaZKyNKzCVrpgrngFHTFNrgd2Wafk6rWU9nfmtl0Eal5YsDL4KzUyMGDpBDVaNWv0Y9J0EZwYDr01ctK9cmpFXNCTxoDDcHU+DzEN/pkyTm4KwrzSjnbF0XZ8vxo7xlbUVnX3qtPrNrRNMVAxashCNOBQXax6jt/buIDYXv/zEW3s+9Hj9xYnzjnHOjrb0zJu17ULROn5Gf593ZumbcaEIWMf7+iNYlPTjwLIvmZV0xdn5HZYerrayMb12xckHcddefY6stD4vNx+wQzYu7Kf1Fe0yO1Zu1VHy9vO27ac2Z5f6/MWLFNk8e/VmK9jlz8wlqo7fYJhb//pxYettNMXG3fWPGC56cbLfysVnx4M9PWWdOM5GlcbM9QbujrgrrzJpJR0nKvuvHIG68EHQL4itNH9vQwEYqHZmPTm9Ux+BAuZgYmm+UzCkL66Tij3RBsO98BR+hdFpt0lyTA6c61/qlRktcBRyPl0hOkyPjNPVRU1GjljmjckK33tobnADltUppdu+nJ5xjQ1/7Iss3GpAQTKTjpqhdm6+uT1NmjKpW43ZNrtcXY8/wF48T1D6GUqs0oN81YRDQ6tW0WrhHsmo/nxgJWT4nIrvuCY5fFa3pH4d7FiyIo39zeiy8/MqYcFiZ4SQy5q6IKfmgvMoO3LfHPbw6Gtso3hxTVuYHu7rFaOU/k1GjjTG2YUKMemJF7pCX7rZJrNx8zTOt4MRXT4zoGkOh3l3AWbV5ZQeeX8KKVTH7i9+MaUe/IiZst2c0lpQFNhs3Jv5z4nvWWeicMsamErAi+r1RhkVmhOHGsvTUkljHhg1lL+zfxkIns03Jdtcz8KGB+2wCqESNI+cr2SSJcGKZq3XgNdXAqXRlLcl5gzcttlD5/zSInaJRhloKWXU1vYkMKTpT9ioyRnuqITC6smOZvdYzAgH0tWux8QgAqOQ5Ta0hfscoU07a76LJitdcehawjAyVypGXg2uXrVfbJ+m6XAe6CvugHuLP3px3eq9i//pOm24av3/la2Pc1lvF4gsvimXXXBdtj3UL/FJBepQyOkfn7wTjJSHaXjvMiN996c3x1S+8MsatWFneeff6mTaLMaM3yYe/5LT45NaI5qZoWbqmybsQFyaav32sMatrBrmsWXmNRG09hJAL/3ROTH3Vq/Pafzmq/7jndbMkRc2FSLYIbXm0CYI1WgrrU3mn6LyxKdYStqaOjRcMKHYN5bkxgLCqjqEFu4PtkI1z3rLvdD6IwV3f+973Kp6xMWjngSeoWctwAWXd3yk+ohXDVXwo0QhjjL7nQBOKtLSDRxhjU29Su5kMNlGkpSh3Dq8bmrL3gdwooi1sgLnr1fac+vzpjHTwgPedNiP+/YkT44On/yyuvPraWPXgQ9EyvfsQg4aO7kEti3fWJvak6ruxpTHec/Sh8Zx9d4ztZ3bfC38+e6+Zcd5/H4ls00lrThRd08O9phWs+N5PgZazle3ROX5UrNqiezBBU3tE66Ku6BjTEJ0t3c5aXzna3GlmpT64eUVjtKWTxkqw6p4HYvwhB8aEidt2D4pZGxQY5RLxvucfGq8+aK/Q/EWzIOu2RoqHAaCoMB3a9mRXIl3BnjKJPx02QyiISnRvMTd1bNxAbeoLl51u6LXw5Ch66uqpY2DBjilH8wVOhlPONVacf5Bt0+NgqYfcgTOQMpg0zlTtt7dzs3sDB6vdqtrRc+oH3pfALTlgRlwdXV93EYKBBDdUHT+xC0YJllPI9wVJ1IfarWXiE4eCrUhBhhq5SM3D9dBfP32r+OGP3xlf/tWv46Ibboj23XbNled6wEcti+hqachr5AfusGV88uXPiZ1mPHXgxJY7z4ymMy6Jzi2mRWy1eUTLkxS43zWEpdx0Vhl2w8q2aG/pitVbTV4ni2/simhZnkUsz2Lxto3RMb6yyr2xrSGaFzVEx6SkRH8yI28cOzbarr872rYfG6OmTY/GFh3mETtvvmn89PUvj2mT1pxtGpEv/tTdkCgnoy2pOQV8OgkIC50MZzgPIaWgUHCixGMgUPEkpzo2bpjxwI5YS9ZUX089HMnQKaOUJ+mpj0sdOmCTrS9lX3YJlH9TaRjrOiwO3LQZDjtFrYykbLavE476All/0dnLxNXIi7Q/+ho9LstOTlpdmyJZRCpbNsy/x+yzBqD+Oe5aXgvNbmqdkYYJShKEEKUiqx8dd1w+b/1/j/9AzFqwOC6/56FYunJ1zJg8MZ67+/YxeVx+4HdZHPHmw+Pnn/ltND78WGSPPBbZ5AnRucOMyKZOFD3lR4i2OGCkM0+Bux2x+7JwWTTNejwaxrZEbFP57NrRT3TFsgmVWRhMf2NnYzQvyaKrRStct/K9a+6iGNM0JcYfcngsuPiC2GTG9DyDf/Huu8S3Xtp93nGCiXlEkYmJkTkppVCka82j2cDYcOiU50ofBvDU5zzXUQl0NL7mzJmT2wUlO3TnhgBaD9kfNkrQW8fQgD8RNEkUnbFRqSW5FgxoHzhHXex/pkInRPMnh+jCqxVKoDgZ5v6CqpwgQH+n9/7zn/+cz/pFrxc3pAZ79XbZGCWyWv9ALW4PpZbTfDgXEbFrSGr75MA5qXL3UDDy4H33xQ7TNo03PWP/eO8Rh8YrDtyjR+cNm87YJN59cvfJco2o6YVLY9R1d8eof98ULVfeEVs+/Fj84ffvjR/++K3xwsN3jaaH50XLnY9E88Pz8vp307LVMfruuevUvGEt2d2GEVjj/EvQfd63HvbunvWm1Y3RvLQxGuasiIe/+pVYcOF5+Qz1UdM2j87VK+PYp+0dp7zkyYAGRKqf+9zn1rm/9A0ElKb8mchHsIZG10GgxxIzYyhPPeuoozcI9ow9JijaEOrigla2kJ4JVVvH0IAPwsBKJpSEK6Gn2SGDnoGLIDhB2S2qEvWLpmQ0CcpQA5w4lDqnBBEvJ+uDoo85YAutXL94b0Azq4ejKvTXmXdt8bpJbmjpWeImv5kyR+jkQBNMAgfh/fubicsQq4V6rjJE6eEo6vg+g/t7zDHHrP3+VVddlX9fwFPuoJTe8PLjj44p0yfHGV88Kx66fVb+vdaGiCNeeUi87Suvi4lTJuRfH/38K+KI5+0evzn53Ljxkjvyn5uwybh40asPi71f8rT428W3xrU3PxTtHZ0xcdKY6BrTEPOWr4yOJ9qibVJDdCJmCrdxszFjY6eZm8Wt8+fF4lXdxfqGxoZoHD8+tjzuQ/mhKk/8+x+xxxFHxX7LFsUXjnjuU56DNVIaaKHDCdKsP0GaL0LINNu8tI+/jjp6Ax2NPWefAc0Eka020PWFXtdFJDlR5tzQa/sjDb/85S/zRLY3P4Z1xRxqJxu2QS5o6KQKRquTzJdeuN7pcmeKy5ZQxGlTyKRQ2oyx2qU2Nirz0k3DWasPF9XIesP1UTv+FDvg+rW5+TwMv2jUpqw0CpUjlT37vUqjY6sFyqq3mrrrQvFSyZtmVw6ySirrNLcbiAbV2HvrfS6F++8rtahZCo89OC9Wr2iLadtsFmPGV87eVyxdFatXro6JU8ZHU3MPFHmWxd2zHo/Fy1fF2LEtMWf5sujKsth3yxkxbWK38K29szPmL18RLc1NMWn06PjP/Q/G6aedFjdecnF86qMfiePe8Y48q3ZPqs0aPvzhD+diQfXv3mbn11FHNbj44ovz9awrJNWNOXR/CgoZ3yK0JGLTlBGHu45OB8R2KhX2JRmqo+9gg+itzEQpB51aOpSMFWfLJcHE4NX43EF5kmaIa8NSY6l0so3FZJCJxa+gzzkDB1xc6IYM+EqUqNdE09s46tpGrqLptWTJnlGlbhjBmgEt6j02lgCAkM1XamGzmGWziVYqPeJN/VlgQJHaX/h85rhzLKXUreuQRfqMpsyVHnJShGzbiNciZOqCJj3mlSaQuQ82cfHfU0sVo5TaGGZsV52Qa+yE0flXb/AsdyGOW4NyEr5R3nfik7WfaW2r4vSvfWVtycMzdzwtUV8tES/2J2VMddTRX5iPzxZw4HQ0jOzDDz+cB5b2HwdfdI4MsEBbwC3zxaqV63oZCrC3BFJ15z30sC7KJasJnouybvGgrDRSu1dkVWDx4sX54Cx/VovTTjst+7//+79ef669vT274IIL8p+/8847s1/84hdlf+7GG2/M/vvf/679e1dXV/bEE09kv/vd77IFCxas/f6b3vSm7LHHHsva2tqy008/PfvlL3+ZdXZ25v/2n//8J/vHP/7xlNdesWJF9v3vf7/sv3mfZz3rWdl3vvOd7PLLL6/685d7ne9973trr6WI3/zmN+t8hkp44IEHsl/96lcVX//f//539uUvfzl75JFH8vtVhHv1zne+s+zvfvzjH89OOumkbLjw5je/OTvrrLPy///Xv/6VTZs2LVu2bFn+d3+ecsop2de+9rXs2muvrfo13Y9Vq1YN2jXXsXHCXv373/+e2xZr7LLLLsvtVm+wv7/97W+X3f99gdd59NFHs/POOy/78Y9/nB199NHZDjvskB1//PHZ0qVLn/Lzz372s/PrrWPowQ92dHQ85fuLFi3K/+3cc8/ts88dNAfOKSQjXA2WL1+eb4ZKC5zj4ux7g831mc98Jv//Sy+9NDv55JPz//fa3/3ud3PH3pODLcXPfvaz7KUvfWk2derU7AMf+EDu6PsC13HJJZc85fuPP/54fq96A2f0xS9+seL1J5xxxhn56/3lL3/J/vjHP1Z1z4Yb7v3Tnva0/GuvvfZa599Wr16dG59TTz117XOto47hgv0kmGdPrrjiinzt/uQnP6nqd+++++48iUjBuGTltttu6/F35syZk91zzz3Z+973vuzKK6/M/vSnP2VXXXVVdv/99+c22ZfA1t5xTRyC773lLW/JPvaxj2ULFy7MX0eS5LXqGHpITosOXILJn/EllexztT53UGrgYJiGNgzjQwcCTu1CLRuy0BP0+qIkUK56uVHWeoTR6Oj2nqBOgYIHIg9KeIpl7Ufa0cAIVcPmTWurBabuoHVdB6o6DU5AfxNZ9SYqIQTUelAqbCul4r2HQfiA3vN3rX29ffZy99FRp4R+Prt7OthAt6P4y02HUmahX6iPe6xjuKHUxU6wDbQZSnuOL65GeKTcR3/jtETtrsS1JkFWOiNaGY8AWO8wPY7DMNRLqeOdZgile4KtZCf8vJIc3YjSpL72WnUydfQPyrjssPo3gbaSLTGyI6WVYPrtcwcrAxdtXn311dlAQaYqiqwGMtDrrrsu++Y3v5ln5H0BRuDBBx/M/va3v2UnnHBCdtFFF639N9FtX4Am9jrVUFnFn5FNi7qroelkqbfffvs63z///PNzBkA2W+59fNbi32XxqEJRI5rnRS96UU7Ju47BhDXz7ne/u+y/veENb8gZhTrqGAmYN29enkF//vOfz/+UISvFVQOZsH2VUC6DnzQpn2yUZ9zlgImzn5XNegI6PbGQL3jBC9Z53zr6jwsvvHCtn8OK/P73v1/7b8obvsCzUgqstowx7Bm4LFUWlxTO/YX2M5FvNacEJWGJHmDiNOd7VzN7vSeImExCSyfLyBLNW6cYrwVU+cRkWIFykO1iGUTdonT3m/CllpOC0olqWILEgHhPx2YS5Tm8xf0kmvD4vX5iALAQRowWW/y8ljPOtahp/6t0yMtggcADA6GroFLHQB11DCVkv9TCxJ8/+9nP8rZZIlVCN9l4LWArsUupP5hIzt+1sPZX9CZzd232sOxfO9xQ798NGSeeeGLOGrKj/B2GQ5bNzrKXqa3Xs9TSXO1588OegYtK7rjjjmw4MnAg5lKDl5XKJvuLf/7zn+vUZ2Wn3/jGN9YRtoluReM33HBDxddR83jve99bMVp2n2+66aa85uva+yrEEqHL+L/+9a9n//u//5tdf/31a/+NzsB1qpEVxXOf/OQnn/KMlyxZkv385z/PWQev+f73vz8bSohY99lnn7oAp44RBczcBz/4wXxPEL9iyOyr17zmNWVFZL3ht7/9bb4XrXc2YKAEZ67pec97Xv4nTdBQ79+NAW1tbWu1SUmncMstt6zzdc0112Rf+cpXBjwDH7SGQJGpqK/0pK+hgtqRbNKgBe1h6uHGavYVasiyQBGUDFcdWzuXti4tYCKub3/723k7m7aBcge2i9L0j6aWuVIYPiLylv3KkF13sbWgFmAcUtbuWRiab5IUxkC2rYan5uwcYJ/F+6jnFd/PPaNl8JlkG16zv7Pta4UMxLX31kNLU6CmpOWs3ipTx2ADu8WeYATpbbTLsgtsAdvjWGOtW7W83mmnnZYP+1AbH6iecfuHPXFoj7o49i3hjjvuyOdbYPrq6DsSu4v5ZVff+973PuVnjHfGIDu0xEwAs0wGBAMZDRTxgx/8YEAV0LVm4CKdH/3oR2v//6tf/eqARLXPec5z8tfSElIKEbT7pHVNO9T8+fPX+fczzzyzbMuJLFuErHZNcQ2iuNJa9kBApDhr1qy8LiYD93677LLLOi16CWefffY6nwHr8K53vSsbKni/bbfdtur1gSmoo46hxjnnnJOryxPTp9ZMeVwr1FD9nt+nBxlI7L333nntvdjxwh4edthhA/o+Gyu6urpy1jT5GLVx9j59YTyxNP4dM/rXv/61R3807G1k6OTU2zscDhw4pdQPrTca7dVfvO1tb8uOOuqop7SccXTEbvqVOWNUigf32te+NqdOvvCFL2THHnts3outb/O5z31u9tGPfjR39lpA/AzMmDFjrfP61re+1WvbWF8hODjyyCNzelqw9etf/zoXr911111rf0aJoAifubS/fLDgHlpzL3zhC/O/M44XX3zxkLx3HXXUAonKhz/84bVtQQLkV73qVRVnWlSz7ssJTvsD9snrPv/5z8//TnBnhkYdA4Nbb701F04nsP2VsHLlyrz3m2C3Upl52B04WND63fS9DYcDB86yWBcv11BfC9TVn/GMZ2Svf/3r135PP+j++++fR+JqxTZwpaCmEithmMnTn/70XM3qoYqWOfDeVKZ9hWEpHLZAYu7cufn31Mk5cnj44YfXKihBIKGePhTw2a23pDmg3KcL+OlPfzok719HHbWAQbZe1ZiLnRKHH354PruhFhi4dOihhw7aA0hZ3yc+8Yn8musYGOi/L3bz9OTA9evLwG+++ebcBpfzayPCgQOHVaQWhsKBf/azn137/wQm3h/uu+++fEP1RWRShEjLdDY0uij7He94R+6cv/SlL+WCBd8T3d57771VvyYHmQYzCHzQ15zWYA1isdg4SEGNa3dvsQUPPfRQnmn7fnGojuf3nve8J3v5y19edbtMKfxeb5mFARfuAVYglRc+97nP5ffcgq+jjpEIe0WAaSJaShrsmT333DO3CbXsy75k7n2BfSZQr6P/ZdUic9mbA9eenAb6gGE+1kzRrg67iC3BgfEGjDjMg5jq4IMPzv908hfxlFO6iD4Gakaw1/7iF7+YHwoCXt+BAmDwwsc+9rF8RrY/+wrCOHON/emEK3NufUYnqDn325fZ42a2ax3QWlKNEMKecugKARwBm4EPgyXIImTTEvbpT386/zvRXJoz78/0/QSimlNPPTU/ktNQl3L3z/UbdGPYhFYaAsbifHm/+5nPfCafVU/g4+hWz8dhI+6XYTdaXIhqkuDQ61kz2vbqQyjqGKlgvwxQYn/SiYv2jLZRLZiGdxi+0hvSIUsDAacuammytxySQVTs8KYDDjggt731oUj9B7vv7I9iax6hck+wDq655pq1fzfwjG8ydMtr8R/VYtAm63Oa+iM5A33FTiR705velE8JoobWH84JOqiEclOPb08LqhpVpoMGLEz9znD99dfnN9NCvuiii/LvmUiUpqr1B3o29faZpCQ48VmLG8/7HH300fmhB66jWnBYTmNzCIIeQHDPBuKai3B+tulPDlo45ZRTciOjrx0ccFIJhx566DoThJy45Lxk/ZDUs5StjvO0sCkui/DMHfrgPQVwngn1bupD9/POjS92C7hGr+lnhusgiDqqg+e6scOJg29/+9vX+d4JJ5yQ24dqQMk8EKpwr/OlL30ptxv+nwM3G0N/sf3ulMa6A+8/dMjwb6W2tXhaZCl0+rCPRfAX7P7cuXPziXnVPptBSe+0UcmyOO3ScXGchA+o/UrUIgMTuTrL2iL3PSNDy4HxL0a3xQ8p8uVInHDm35x963g2zsTfnQYkE5bRWsx+tz+tGjJmzqU4ArH0XGqQgdY6fER7mtGhKarTwiUQGKh2D2cZu+7i/RMRfve7380Hvwg8eoJT4BgBUaNWMxGjIOnLX/7yOo7eyEfBlNYYz0HrBOMmWBBtCt5k9bvttlvFM7o9LxFqtefj1jE8YJAcBYxhEZzVOrp3Q4FAtHQsssBzr732ytk49q4naDH96le/mp8UWA3sYXtX5m7ssZYx3zMM6v3vf3/uLOxFY6gxZ4aC2G8SKyyaUZ/2aR21QwInYSwd5tUf1hQriikxnrcqVMPxJz4+1SV7Gi/4wx/+sNcB/epFqS5dCgIu9YDSFioqSiNBe3pNApBKUOtRqwYCAqr0gYR6lxOKilDDrjQKsTd4LYpvIjb/P1CCE3V5wgnCG19FqL294hWvqOp1DCYg2NNWltr0HNZCq+DZUo3vvPPO2cEHH7xW3NPS0pKr7I17HahTmeoYWSASNfbW8zUitHSNbaxgQ6s99OTVr351r/uDrWMniU7ZSraGhqUUhkolkWqCPaqNlCBXW5nDmhzQYh8b3KQzpS96p40N//rXv3JBM1uXvtS+i/XtSkhi4UoYFBEbNbBjJznqcj2MRBzVGmYfvqeJZYw+ZR8Fu4XlPcsd91kLtGyB1zPDuLdAoxbYRJxagrnhH/rQh/r1mvoGkxDOHN2BAIdr6lM5pClQW265ZY+v4fe1yRSFGwIibXuMAUHedtttlxuCIpzoRhxXx8YBgaIAtn6MZZb94Q9/WHsaoT+d01AJjgntrcVLi24xONI3LjGpFsSkAvZPf/rT+d/9aWIjG9vfTp2NBUuWLMmD1VIBWzUYKAdeU1ER7fqRj3wkp7L//Oc/598zgUy6jxJHhVdbp0QJ9zSTF93t9QifXvva1+YTwVCu/QHqHFDnn/vc53IqmciurxAAmbxz+umn538ShySkWlN/QLyFroZUOugrUGWoOfR4mrlcCveFdgE1RKBXCrUZpQhlAZOdlDzSPUXdqV+bC+zZqmObPARe0yx5tUA067x58/r1WepYP0CcqpSmNLOxwwRD9U1QHnv1q19d8WfR7JMnT87vXSXQx6ibFu1lb6WvIlDr7C8x6ZlnnpmL7JRBlKs+8IEP5PokU9rUyk2VM+dbmbKOJ+G0NyVhEz+HCzWT9Ry0caLqmAQSVNO+KtWtK4Hj7+0ITe/l0A8OQB24vzAqVO0n1eW9phptNfVVi9ehA5TSxDq+1J2e8Yxn5Cr04s8Jbig/BxK11MVKofZGzPepT32q15/1TDjqcjVMQQmhRYIAi8o2HVjD8Qs4BHOCl6QxUGMj9FMvsthrPQBGfT2NSq1j/YGaLKdF+byxg1OmPrYvJCSOFe4JDjQRALGzKTGwB+wfyvLiIVGOqUzK8lqgNu6rmJDQJ+nS0YXCuesQ8X2OnZ374Ac/uE7gsLFjiz4el8028hX9FeY29/XNiZKcyNNTJNnba1SLgVIfu1bng2szE3GCNrB77723x7nFsmvZupNlbDwCkdSiUZT8i2DNQzZveJtttomBBMFYX8DBmnee2uqqFVL4Hae5yaiB4SjNCJxwZjNrG3PusCyf4l6WbW2Y7SwgcD9k7u6NaL5W+F3Gy/u4LpFvHSMf9rj5/nV0Q7Av+yZ2JSbjdLWeVhLJ2kMYwg996EN5UEx8JtngNLxWct7aK2t1qjpbBAfsnmtIQlntn17TexDeYdl0xnDo9rcERkCOeZOkOIFtY8bTn/70nMHwZy2QxLiH06ZN69f7D3ofeCUMRwsDdR9lOul/GjjvMAJOBS0sS7WxOAtqUI7CDebgZZulG4zD5shFvv6UJTuUYKCdN3h/11/LEHxlB1mxgKVWOICeoSk6cDS518M8QKIEGRVlBPdNcKM9zCZ3JCqKiYEQufvqC6g6tagJuuo0Xh3re1CjdRKrqPToS0Ze7tAih48IpmXbxYRHIG0vKbFRoGMp7Y9agD5HlevWSQcv2V+OHxUMeL/zzz8/Z71KbZ/343wG7ECO9RhZlvXJJrGlgqH10oGjz53OMpQQyaqny0TRuamNzJdTu9DLnI/ygEWLLl+wYEGeZb/rXe8q+5rqxHotOSgP8d3vfne/H0hPDtV5vqU9h5UgGFEn08rXF6hfJ80B1sKJSxyzrPq4447L7xt6rRQ+P+Ogzi1jdrpaf7OwRJ17Pl4PtVhHHeszlPOsY5Q1G8OhC/w561LGsZStNBeBHin1GnuNWulzUPosndWQgnOodK655KbSiYpQDPI3dFx88cV5OVUpAmvBRlfDGHPgEqykNWJXlS4lgsqQEs1Bd+B9ccIcHYpVFFoNfCC11/5CBpnq6BYf+jfR5gaXmBrm35OzSIu0knDONYmeOf6+HvlZC9Bn1YjifC41eAaCEKWvQHeffPLJ+SZWJhAMCFZE3umw+XKQccva0e9oP4FQOoK1L8CUoBqJ+GQCNkwddWwoYHtk4BIKA1ewgZg/cxFQ1IJmbJ/Sne/ZezQt7NmyZcvyP9kh9XWUtwza76PBzVwYakfqyGUBiSRpY8DJJ5+cs7bKEZ6LQEqAVXqMduncEfbZzwO2kn3FeCRgLzG6vaGBFL23H0oGW3SBNkaVct7oYpFELTjjjDNytWSqQfcGH0KUUikarBYinBQ0+MjPfvaz882SlPAveclL8qlivUF0KQtEq4uge4pEBxpqXa65kpjLsAaDbAgK+zv4xHM+55xz8qwgDauRSVuEBub0BD8jkLCwrRnXi6VAB9YKA1+o5v/0pz/la6CnKXF11LEhwN7juFHZ1OVpJKsatE4PEy1T0kCbY49gxTCGaqtYMKpx1LiAl62rozbwcRwqJX5PP0MjUGRoDbZi52TXSpDslWyajqB4FjsoQRArep3i8BfBl+dMc8Wxs6MDkoFbQNqv+gofzqKs1nmLTNSoSz94XzeFzBSNThFKdPDtb387pz7QzFSWNkCla0MJc2hEWTZEX5xRfyEDx15UotEFVepmAzG1TNSv9asI2TcauxzQSIIawZGau3uqTifKlLmrkfcFDJjPQ8jDiGFNeptmVUcd6zPsPecEFCG7lk2bXOjfUymSgCoxc4lRVC5kq0466aQ86B5qB/6qV70qF72l2vr6iMbGxl67XrRUl5ZXU/usUq0vr9ETQ6t0wqYrU9I4KTty+NUmhjU58NLDJBh0kYYIUZbcU1836Aet5aESaHz2s5+N/iK1R7i5WrGS6ODqq6/OVdPoDw7isssuy+neIlDBMm4PQs13OOdxc84CiSScKwVapr8tHu6VYKfcotObyiE78IRjxUaIDjnW6667Lo8mwf1CB6K+3WvrQyZermbeGzwz3QOCq6IhUv9jvOqoY2MBB22eucyOPZJQYTM5ag7eXkFfY0uV9lDsgyGo7Q1Ewus7Ghsbex0HLAH0M4SAzvfw/xyv+y8h7KlbBpPq95VPnCPhNWTh7Bo7Xm3ZuCZvxMkVwYCiN10E3l906MJkznfddVf+/37GMABRosXEiBONJf6/EtDBbsZAOEw0k4UuqnWTOCdfnBAanNPSssE5cjgiKOIO124TqCWjrUbCYRqcWKV7Z+G43v7AffBZy4Fq1etTwar9pPUgiPNcUXlqdVoMtaRofdN3D6gkgUdfoOVFLV2Wr9Shv7i3Pto66tgQgR5XCnRoii9UObqdfXOYk71HNyJotmfSIKihhOSiL6K69Q0NDQ35+RTYXJS34VZphjntVLkBRuwivyP5lfhITpwVISCjWeC8a0FNGThaxOJBo3LGnEl6UDLX1Jie6FSio1IFpUjFz/WmsmP4Od6+NLvLAEWkIiC0hFoG2hmFrgWiCKwB9oACUCuZGr2H4aZWA7+HHjb8YCg2i/o2oUi5wTbaEmTp/YFFValMIkAQjKF7aB/UaL7+9a/nPeDEa+ko1e985zt5NsDxpkjSARcov76IagQLqCprRi1cJqKFTeRqjRVPL6ujjo0FsjxfEgyZtwmZhq1w5ByCEpbOmHJTFXsDFo59Z9cEy5i2+gCXp0IyI4EVWKmXK11gI/1dyVg5gw/8xz/+kScwlOqEhgnYFIdAYTf7gpo8o4siXGPITTArVSInR+siPfxyw1o4UYImp4/19l7ORq111KnMmRgt9Sgz+EZ4yugp+8qB4EpGTslpA5Rz3m4+ygrLIMpN2SQGAuMwVJGujSkw4RxLYfHQDPQHosZSBWURonpRpA2tRo7SE/SIPl/xilfk98U9sZixMk5EwnBwsn1x3oIpwYJ1I3BQXxMseB/3oJajWuuoY0OFvSfIJWJDqdun7HBpSbA3SJyIqFC6HDc7rXSKvRTc17EusKECmzSxjj6Hf5DoSrLcPzZM8sGGFcvQtEIYxb4675ozcEY6jdjzppyli692UIgP4kg7tYLeWq84CYvpvPPOq6luzsG5KbJR2bf3EVi4saLJcvA+ghEZuBtu4XOGxCLpAWEafG4DEygPh5MiEkSp21soRVAz9ueIVJAx9/QaFOnq29ZBsUed+MI60D6iFs65aoMhQLNwZe61Qu+5Wp5au2chsEA9MSz0CtagrKM+qrOOOrrZRPtTBs4Js1tEUj2pmBP8PCU71bPjjO03TCoNELEWIbGyKB/g3/08FpZ9ZWu1efqTLRU8eK2haK8dbkj63G/2LbXQJRTF15jn5KjZReVaTj2NsqX3wloXz6OoCtWcnJJORvn617++zslejq879thjazoi0+laF198cfaFL3yh4s85zcrxlE7FcQLaddddlx999+1vfzs/8ayIVatW5cec+pmrr746P8rNiWi+54g8/14NfJ6FCxdmf/7zn/NTlBYsWJAfu1cOjsksdyLbUOJHP/rROtfnNLQvfelLg36S0CabbJKfWlQKJyMdeeSR2RFHHJGvlfT197//vU/XtGLFivz3nZiU4EjST3ziE9mhhx6aHXfccfm/148lraOOdY9jfuUrX5mfVuYI5a997WtV3R623F5qb2/P5syZkx/d/NGPfvQpRzg7XY6NvPLKK7Njjjkm++53v5vtscce+elq2267bfa6170u22233fLTzjYmdHR0ZPvuu2922WWX5afvXX/99dmFF164zkl8TnE88cQT8yNcP/e5z2Wf+tSn8qNeH3roodyeF499dQpnNaeRNdcabcjQtFKJwPRWiz6qAfGT30U3m+NbabqZDMvrqt3IctV81ZhR6X5HPx3KVo1GTdXrEnPICkUuaci/uo/DVqo9AEMdQ+1W5NjTISve9zOf+Uy/a839BUrrggsuyGka90GrFgWjqJtiu5qou1agxJU/KPrd72Krg/elNTCrXHnF4BnsSV8ofdEnQQeVZvGgGK17hsMQxMnCZQdKNWefffagTcCro471CXQpBG0yPvtI+ckBRGaWYxhlz7I8AlP7yT6V+dGuYCp9YRhRvZit0tJgUUNk34EyGXgtWSj9kdpwb11JGxKamprycp77h+nFPGIoKPLTxDwtymZZpDn2fAmf42exFmwqv6I8WHW5sZYM3Dm1siDndM+fPz//NxHY9ttvX/b8WmeEJ3zve9/LI0KR2fe///08wihCxvuOd7wjz9iWLl269vsyb98XoVQLWfcVV1yRR6G1wO/JxDEF1157bdlzjEVRrnUk4M1vfnMeNTvbXNT8+9//Pps9e3b2jW98Y1DeT4Qoy3/iiSfyP8sBQ+JZFc8qrgXu+f77759/lnLwXN7znvfkzMwLXvCC7LzzzsuZmTrqqGNdfPnLX86e/vSn5/bMnvn5z3+e7bfffnm2/e53vzt73/vel33rW9/Kfvazn63zew8++GDOXmI12exq9+2//vWv3E846/qQQw5Ze/75xoS77747vwcJn/zkJ7Mzzzwzz9Dd1w984ANlf49NxWywaSnzHvAMPNVZcflp4Inoy5doTV1UZCcbUi8WTagZy9hMnUmtP7JcmbvIQ+Ff7UTWqNVMlFgEWT0Vsj5i7UrVZHSiQHWGYvZWDWTrSWQgu5Ppp5oERsB1qutoYxoJcF+wFdry3F9/J/JS7zdisScxWl8gq/cMPF/PSeZfWucqPfigVlgPolanxJXCEB6qd62A2meIFf2/+nsdddSxLmTb2px05WCtZHyyc6pnQ0bYciLfUhZV5sjuqqdX0sPQBpmpwQbYr+aqs+/+rn7O9tNIySyxhP3V5qwv2HrrrXMGNzGU7BlbyW7K0NM5DukUOUwJEF3L4rGWbGqlUdVPQTVRRYoGZM2iOZFcKd7+9rfnGTqk+vB///vf7KabbspOOumkdTIyr6eOqkagbl0tTjvttLz20hvUcbw2tqA/UIvHMCxatCj/+49//OP8tUcqRHoJmITBgEh7xowZ2bnnnptH+KVMSn9x8803V9QXyBywDmpz733ve/Oo9jOf+UxFNqCOOurohj118skn5+wnsMdveMMbKu412TMdkZr3v//973XYyL/97W/ZgQcemNt2NfclS5bkTGDRnXz4wx/O/7zvvvtqZkLXdzzwwAPZQQcdlJ166qnZDTfckN9rdupDH/rQ2p8555xz1rlffFuCOrpMvZoMvKY2MlGEs7GpEdVGzCmnpktjPBNvL/oyHk70RV2nNlLsIRSxGQqiBlNpNGc5vPWtb817w3sbAiMr89oyZdeboCakfl0N1CG0UmgPEA2p6WAVijNrRxrcYzoDeoFqx9XWCpG0djw1NdGle3TrrbcOyGsboIM1MYii3NAXkb2zwY2HVGezvrS2aBGso446KoNN1oaZjlFmK6jLzbEoB9ojtk9HCcZNvzINjK4PcyJk9RhULJ+2VrXf1GYmo5fpg0z0Yx/7WD6zYTiOkB4O0AmZ8slP6saRUevQweTKvEGbbaWhW3Re5mZUhVoy8FNOOSXn6hNEXS9+8YtzpeNrXvOatf929tlnr1P/LkIG63X6Aspk0Z73q/T6pRB1+h145JFH8oixN4g2RZ9U6Qmy78FWePcXqYav/j8QEDmKDOkQSiG6pBD/yle+kkf1tTAp5eB5Hn/88fm9x9hMnjw5f49yOgQQ2b70pS/NtReVfqaOOuqoDNk3JXS1+9Mep0GhgeoJ2FXsZRG0KuzE4Ycfnj3jGc/I//95z3vegDN4Iw3uG40O7Rc79dnPfrasvXI/EkvNjl966aVVZeA1nUZW7mQU/X/qw+odog0qcnXvFGmUg2hONl2E+ox6rgxXzUQ279L0++oJF82IZNRm1FnUDPQkmtQmkinXDK/mYJyr1zItrKc6jPdSS/VZ1eONuEvKZiyC3x2IQ1XWJ4gY6Qncd/fcM0o1bkwI9ar6O1BTmgjVk4K/HNThjII0FMbkoqTud6qamevWVbWdBHXUUUf1oBPS4VOpI6gcjJemd+ppT2Jl1djN46C65hP8nY1Q5zWCmW3FwvIFbLz5ERtqnXzx4sW5nspxsGwdHRc2W8+8mSNppoWOAbaWv9Jd4+8DehpZOWhGNwvWBCBArRqgYjKQh11u/J4LJEIqCpU8SK1cFoYP64N48Kaxkd2XThQyZMCC4PANiOFY0jWgytHIBAGoChQOYQYhB0l/+h1nVLsWAYCb6Wfd0NL3IQirNB98Q4ZgySIS3ChJuF9aJIgWiVbQccmBK4W4V6XiMwJGrV9JvFEKz5qjNrnI/yt7oJsES6bC1Z13HXUMDgyt0qpZiwMnyGJf075MB0Jp2xXks+vsNspcOykHTnyKdk/DrwjrtLuxvQTNyY9IykZyibKvkPya7ikRlBRJEP09BSypzYwPUiZUjqj2MJOaKPTe0nlADzz3uc/Nf57YoRxQstrKbrnlllwQ98Mf/nCdAn+tQNcQ0RGcEVb95je/yduMCAfgf/7nf7Lbbrstp8RRwmhmbRIoC1TFX/7yl4oUk5aojZ2iRVcn2oyI8Cc/+Un+DLWrpTaTX/3qV7l4o1zZw9CCcnDvDd5xfz2fa665Zu0Ag2L5oo466hh4aNet0gWsxfLly3PbWSyjGvCFXi8VNytDQrmBMlddddXashub/KY3vSnf/3XU5nMH3IED465nWE934vRLayKp79sC8O+19HmXA+edetMTOAeLxJSyF77whWV/r5yiHryWBbixT/qiIFWzUssRkO2www65E586dWr+TE0WEgiZsPeHP/yhqtd8y1vektfPi7V69e9UAzLZSc9krRBw1Y1AHXX0Dg6UTTc/otbfM6my1IYK8kuhYymBHdaVJGnz+4IA/kTnErsi0B+szpn1EYPWB14t9erEFepkykS0AGqacvHggw/OKQS1UvQ6usCBGHvssUdOeaNNUS3qrZTIeunUxnsDhTgqH92tBkOhjHpHy+q3c9RlOZRStIIadV/vjVoaCUeIDidQ5J6Nw0g8S1PvTOSjlNRdoBvB5Cbz6qnBlSbKnYPrZ/TWm4NPbU6bkI4atS6UXFK5xQx09JtDGXpCsQyjRx+lT2lbRx11VIZ9pySIzq1Gs8Im6ldml3UQKTnSKSXbaIqbKYylZ1ag6GmU2AV6GXZVGVMfuv7zVPemnfHaSnBO8jrggAPqj69KDFrBgdN9wxvekLcRqGMbCsDIagEjENP0n2T06ih+TkuCOmtxOIgH7YFaIJVaowjmtEQY7MHxE0g4NUytJh012dvxpakVznUbhlIfzfkkOGo1LEGYmjgHrVZtU6pvObaQ0MLgCI6dNqHUAAjoHH2obUVdzGEsAr10upq1Umxh8dydTa4+ZOOnI2INCiL48HejHNMgBGIcLS6COAKQOuqo46lQW9WGmY7kreYoXrVtdllwTONkqJYDiuxFbbpeUxJWCgkQO0wsR7RcPAKZ0LkUXp8d8Pp1VImBTOeL8POoa3WWYg3ZmD3N/UXssssu+UEYlaAe2hPFroaeBqygYgwR2GqrrdbWYKoZfuL3yP2rPfxkY4P74j5rh1CuKD5TbSPG6V5wwQVPebbg2WgJU464884789foqTSBYkPLWT+e4bOe9ay8TqaVT9uL53vCCSesM+YRfe8wBcMp6qhjQ0Z/9CHKV9p97d+//vWvOZWthUmLbSUodfm5YlnLwCV7Mg3v6i/YA5oaGqaRPCxro6iBq2+bRKMuWgpihtKH7rWdZtMX6Es8+uij8//34Dluxt9Mbq9bzqGUOnC/x3n3dX73xgYTmExoKm4+/Z3q2JWgjl6tnmD06NFr/3/rrbde5xnOmjWr7PQo6+eoo45a+wzTaWh33XVXHhD4M71/XSBXx/qMl73sZX2a9WAehnMTimD77BmOXY9yuXMe1K5NYytCTfv5z39+fvqg+d0mJBbPsKgVb3vb2/IkzimDkjV7lhB5Y92ri6v0uYNS4HU+tFOpSk+yAfJ5bUVrsv+8Jn788cfnFHhfgApSo9VnaCqYs7LRsk4i05qU5q9XgpqttiVTh8q1vNWxLmgJ1L70J9IZgL+jy8xjv/TSS8veMhR7Na14zotXJwNaBhOd1N2UNvwb2q4cXYcKVJtXBkm/q95uehRaTmvjCSecsLacYoogbCzToerYcKCPWDmyVihJaZUtQtsWu0cvpBZtgmbppEvlT5Moi9A2qpfZ7AwnTNqThxxySE7PK2PWAqVPZTL90LQvWtW0q5oCxxaok+sZR+XXUYKBjAZ6ah2S6Tq/mloxtW05O1ZGTpm4+eabZ33BjjvumP3jH//I25z++c9/5q9vdrnrla05aceZtuVawUSk1NSy+Dqqg8hbtG0qXekpRuCs7t133/0pbYEU61oHe4LTjIoUuOeJttPR8M53vjPPskXnTvjBsOyzzz7Zs5/97DwbMfce/QbW00te8pJ8TVgHMgzZgal84Npk66n1UFtcNRP6dFdQ3WMg6qhjfYM9U84OpvZaSNPCwJ5JdLY20d7gd9n2gw8+uOK/sx2+lMde/vKX59k7Gz5+/PjcFtvTjY2N2bRp09aWM+27xKhtLFg8nCp0DfoiJ5GVaTyGrDhHVoZsWhvBERi2YtgLkUPxbOlaYGgA8ZII0bCW/fbbL/8+wQTRlSzcv5nPazhI+ncQbRJT1VWP1UPknebXe8b33XffOkwLMSJluD9l69SlZgMTl1G83n777fmfno3Iuji4gRimOMGPUE0WTagmGpdFyxJk/DLn0pPPsDnYHdPdrDFiN+/vmetOABk6QR5xDbaGMA6I7ExJ8h7eU0ZSOhlKZuGzFFkdanrvSYBDpFdHHSNZfU4gbL0avGK/yaL9mdgxa56tlgkTAfu7aZtYTiBcJUJOXUKYN9lx+l323sCS1P0DlOX2mlMSTVz87Gc/mw9v4h8o1w899NCcQTWJ0c9g9whjE4hd+QhMgb1niBTm9bDDDsv/bo+z7RvqJLceMZDRQCn0+sq8jznmmLKRX6UBH7VAL7lIUQ3FexBIpf5z0SPhVQKxhmwOCK4qnTldR/UgLCsVwMh4Zbky6g9+8IN5Jg3Wj6ydAM0XBuatb31rPkcfdt5557xWneA1ZODmresRlUHrQy3t9Tc7XXZujb7yla/M18Kxxx6bZ+IifZm2YT6yeyeZlZ6OV4T16kxfOgp1uHvuuafXeyBDsMb/3//7fxv90J86Ri5k2s4Bl9neeuutOftZrm5tBoa9ZOYDNpMA9eMf/3i+h3y/KDLbf//9c1aK7fV99hdLljLmZz7zmbk+pniOxHOe85x13s8eTftRLX727Nllr599uPzyy/P/d11XXXVVdvHFF+fsGdtuGNSGgmEVsRXBgTK+aHULx0AQTpQhHwgqEtXiUPpyog4Pmeo9wSKxuDzwngRXdVQPGxc1XjzwhMispwMPUqCVYHIeh4m6U2ZJ8DNf/epX83/zp43ueReNAaNBgW7zFg3LjTfemCtl00EKXnu//fbLKbrSzohKR7KCg3fQ972pbQ23IcJhIOuoY6TB/hTkmnjGDrO/vU2YtKf23XffrKGhoSJ9rTTGxiaHv9tuu+Vq8p4Ewaa5VYJBTH0dnnXWWWflhxttCKjW5/b7MJNq4EAKvd56q1EeBoJo5k8HV/QHBHBEa/oTqwW6k9DuyCOP7Pf719HdJ4qyRrOhtVDYhrGYQd8fGAKBivP6aDPrSP8pQRsqri8gbtO7juI3XMa6IQpKSL3nRaALlXpQ66Wz8s2BRsN/+tOfzilF/fH+v446RhLQ0+yuspdyETGosycq7TvzGqxnFDebjU4nUq0EpdGdd945hht/+ctfcoEfX2PAjNki6yOq9blDMjneYBRG0xQvNUgGU62TitkC6c+0M/VXdZlawMimmk4d/Ye6mtr0P/7xj7yWZkAE7YFN79/SIQa1wil0HCSnqe5uQetuKOoYaoETzkyDo5QFBswBOAKC0tPxijBJkPNmHOglBBMCULqNX/ziF/kUOZvMmkqBBYfve2p/ddQx3LBWTznllFzd/cxnPrPHn9W5wWnTgSTYez1hJDhvcOiVBII2h6qdxka9fEPFkMwJ1bbzxz/+Mb+ZDKYJbJy2G33BBRf067VFlKI/p15VC6P93v72t/frfet4KrAaBCqf+cxn8olsRIJEXgSECRdffHEuZKt23Zjqltq/nGBk7RCS9QWeucwiAQMkyHA6UoKsoxwEEU5OsoYZQf8vUPGnSXL/v71zAbdyTPv40zcYBp9GKDk1JAbjMOOsGZTImUiKhCKHFCPkNHKhS1NoEJEOKBM6jE4O1TgfGsZpHAs5RFHk1Ehkf9fvnnn297Zaa+137f2u9R7W/3dd+9q29mHttd/13s993//7fyOoC1YFEN2RzU+ZMsWsg4WIEw7RiHwRDtcFr1FEp2lltdVWs3sFYjvsubNMxYy+URyiTqd0gwKS8gZZFaVMD1k6GQ03bG58lHLqgiyK0+JVV10V+rGwDpNgI6KH0y5/aw5oWJoSNNmDe/vtt1s5nL8pnseowDnhU3InEJYDyk8EUQ9ZMXvMg9B+IZsmswfvzx4sn6NM92DzSBbOzDkrE6kqnX766fZxED6mhYDfNMpc1uUKESdYHfNaYxdBIfBxwDo5C4rudddd11q3WaZiAZyb+eOPP77K/yf4cmPlBs/NkRJs//797cbHW11QoiXr43tzw2aUiD5nXaXZ4E1ZRAtLSPr162d/D8rWlNb5+9DLpgLTpk0by1zPO+88y1wJnmQGBHcyYLLsoFFF8CBHtsxICRUX2jDXXXedaRnymUfQumGUzONL3UHI8BlZYYSMcj0jK348kVEXri+CMWOJ/Dufy00hTMWH9hAHTL43NxP8/I855hhb8iBEHNC+ZDyzkNkKr7tive60seeee7osUxERm2fgwIF5XbQIppRLgzPBzA4yL1xsthZhBoIh3wOnH05mx9flbhkLwlw4YqjgrKEoP1xqzIgyt0/rg7Ie1xZBlPlP3vxGMz4H+HsS+Aj89LUIqj6b4IBHqQ/XPUpmuQsS+Hl1ZRKU+QmuiF38YgZcAakC8XPJnHGi4nvRCiAA8/m0Bvh5YTIVDiX0CGfNmmWHGJz/OCiQuVONEqKS8BrDQY3qUS5c54MHDzahb321K0lh2bJl1roNLlFJC2FjbkUDONkItphh4OaJWIkbdyFQ/3Khsb2K0jyPjy1WnCKx1uQtXy+HGyr9oPrYEYro4RKkdI2okUwdK0UEYWSqrAzlEEfApw9NkKftQjDE8pHtaFwHUQVCAjOGEWTgHCqxYfVBmn45lrsYEnF4pNKAERBfQxk+LCj0eR1Rdcp6iU8kE1qOJD/5BMRUQnlt0WrkMI0JUr5MlsoYr40kltt/+OEHO4jze9YlwEsiiQzgjBoxohNcF1oILhyCcTH/bE6ROPDkBnnKrNdcc42NTZDx5YP+Jb1MXIdEMmGfPBk3mTFBEw0FcE3QkiGrrUtRGzUc/gjWTFPQK6Svz6GC92FBJESFgQPmwQcfXOv9LkSl4BCM2pzVvvngME2VkgBPSZ3Kk4dDJy0vDt20l4L/lhTuvPNOEzcTB9JIosbIPIh56HfmK93kQpmSi4ybHeI2btrM9gXL7JyyuMDIvrjJe7jgyNpQQtOrzL1BUkIia6OErgCeXBA68kaw9MGbFyZ/X64HxrsKwbVBCZC/NddMKQdPzrQI7zggUg0IwvfEipXPIUunn1jqmArfmzeua5a1cEjxv58QlRorQ5tSqM2ENokMHL0QmiTEb9x/0Z2QNDE2+vbbbydywmL48OF2qO7WrZvLOhUN4KVmGpwOuVlTSqVMycWC+ImLiOyF4Eygx3s7CDdtbqpkSKigydLoOVLy4dRIKZbMBzV0blZerBQapqcqogdNgyfMi5K/k6/ycB2gkUAwd+yxx5rvsu+PFQqalO25PrzoLB9cB1R+KIPXFx4LQVyIOGAChE1iuRvKcj0z8E3gOuUeSsLje+Pcm6dOnWrfJynMmzfPslYOGNVAxVTogNiI3nNYOOlxEiTLRmmO4pg/DkGY0yNz5FxcKM9zsy/KQ/wx6VmSafMHRTSEcxs3ZTKyXCV6MTMPhB0NMZwRlYPg6uc/L774YhsZRPTGzYr3/B05FDDPnQ8EcdzUqP5o3ajIKlS3SIZoVxaDwN22bVuraAaFbZR4aWMhNKVVyf04TpYuXWq+IhzWq4WKRSSyGnoSQXefYqDWRZ3MHC+lGm7KlEwJ1tyQzzjjDLsAEbqRTQUhc6L8Q3+GDN2Tmz1zQw+Sb3+5hzIs5X8uYpF8eBGjIMcRjmBOSY3qCodAyoJARl6oUoQ4jmsN57ZqQAeV6gSFtvdAKAb3znzXyOGHH25CT6Z+OBDTUoqrZ7zFFlvYiGra1fOJDOCohsP0vj1k2QRURG+FytqUILkxczrM/VmcBimhkzkXujnh1BMGyrEok8ncwzgZicqBDSp6B6on/u9Mz46bCdWXfBDQuRbJsPNBxYYgjn1qbpsli3Ao5XV28803x/1QRIWhEhVmGifYlsqFaib2whyaaVPymgw7bRQV48aNM8V5bjs161QsgAcz4SihzI6jG6UgsnV2UHMzwveXkxglnqB9ZhBM/fHLLQYZGAGCjJ9TaDWd7pIOL1qMYNBDoF+gzYLwkd3CxbzuaZ2giyjUEuH7+R4f5i0cIGndVJJKVnq4+fLaKbTcQmQbKk20N4uBDokkpi6osFL1yq2KlpuNN9644hMpVRPA8b5G9VguELdhwUo5h6wJH2pu4pRUCOSU4/PBzb6YghgVMmV6308lG6vL5U1UBkYEOahRbeHvRLWGQOs1FsVKwhzCmFzo1KlT3n8POr/RQ8cStRSr3ijA9GjIkCEV+3kcTpl7F9UHYmFMkjisFipPU5Xi3hoW9EdhrLCjolmzZlWZXFUkgJPlevVvKYS5AFgxiaCNHjuzwYiUfNkTcQZBOtff2s8yepV7EPqjZHMEbkxiGE/zPtczZsywTF/EB4GZQ9mOO+5ohzR6Xh7GujBX4bqhtVKIPn36mFHFgAEDbN419/vn3gjo71V6LSG/G4+xIcIgRn+kchdhoPpC1sxUBa+jXOdKNvGVkuFiroWbJglPGEvshrL++uu7xYsXu2qjIgGcWVpuipzySvkaLpxCpRiWnZA1EFDpZ9J3oafJXO3MmTNrDw5du3a1kk7wBs2/c/PGESvf9yVwYyKCeA4bTQ89IJTsIh6opFDJwWEJcicaeBGTtYYZ9cOTAFtfrhG8+NFRcK0R8PAwz4XvGVy8U27o5aHh8JaypcKcPIdTqhNChIFxMHQjvAYY2yXzBg7LlNhLOUzigInpEZqhoUOHVqTl9LsqtCWuyBw4GTElbm64lDzz9cPpRyIq8zdf3hN48Y2mn8m/45zGjY3Mmhswm6Xo33n4vigix44dax+jQuZm7DMqRgyw6uT/caIsZOlJICgmrBPxQKBlMQg3FMZWqJIE4RopRXTGdUEZnhsNB0GqLdxwcj3V/fw5NzW0EJWi2FhjIfg9eK0xBjdixIiiZjdJgNckN3u/REbEC0kK91aCNfdREhhMr3AaLCUBo1/uq64kQhx+y9lG/eyzz1byi6gWKhLAyQQo0XAzCZY8g3gRGuVPSjiIJpjnZmczPW5utoMGDbILCmOO3OAdxPe8+YMyJ873JuPmMRSz1uPQkOu8FURz4PFCSZjtYjizRQnXFlk9bRhEcYXGCIstyEkKtIZ4vVG9SnrwBtT+HLoQm4rkwPVO9ZIgTvaNPoJrC0907qks+wnbcz777LPt3o2WpL5QISP5y8eyZcvMPrsqqQnBV199hSLI3teHxYsX14waNSr0548ZM6Zm+fLl9t8//fRTzccff2z/vWDBgpqJEyfW+fWXXXbZSh8PHTq0ZvDgwaF+dqHHOWfOnJpx48aF+h4ieubOnVszevToWJ/aG264oebzzz+P9TEIUWlGjhxp9+Fhw4bZx+3bt6+ZN29e6K9ftmxZzR133NGgx0D8mTJlSsF7w+zZs2uyRNiYW5EMvEmTJiYqQjCEs1pdkOn67IGs2AuSyCzIxhkDKraz1pfjGAGj340tZtgTPo+RUnlutkV5NYmm/VmG1y2lPE7+TDLEbY9Iaf3GG280nQTZQBoyXCGiKKtzH+a+SPuS8c1CI2WYddHe8lvK/JbBfG2pUuA+UCjjnzt3rulFqpGKzYEzgoBDWkOhxIlYjU05+aAE7wM4vRdsMUspz1HSyyeCKqUkyUXM+JGoXy+LtZ0sJKBMRwmPJQqIB+P2oedQRxmQyQeWkaCyjQr68HgaeJc4IZKGXyqEhWqhdhKLedAhISzG5Q0dB6/nhrSfvv3224LjuzU1NXafb9GihatGKhbAyaqjkPpzE6eXTd8s35gZN1WvRqTfjhNbWAjS9M1zHYcw8cDMpa4bMKpmTpxcTOzaFeHhhYjoCq0CARKbU/pmqGKT5q6EqJJRNvYmRwXZBdcPExAYDHE9IR4SIm68+hzDl5deeqno56FRyQW7a7Lk+oI4udBY6PDhw6vagKii2znYZDNx4sSin8Mmsdw5xHwcffTR9sfjxOdB9EZ2jloduJjIlMKCaIPTYy4TJkyocwaSGzClesQfHACKieHE/8PJevLkyabwZo6fMTCCWNJ3ZHMzY76V7CIqOLQgEurYsaNdcwg1hYgb7mkkSxhkke0CHgVUGn3gJqGiXYkrZi4I4Hirr98+B3j8HfKx5pprFm2nZp2KrhMlC6dMSNAtpEYnCwuzno4TGYr08ePHW4+F8vZbb71lZddgBo2KnUNDhw4d6vyehx12WF6/Xy7gMAGllMOC+A+33XabZdp+5jRNMGtNxYaqUFSuU4ypYYLBARXzGEbmhIgT7tt+AockCe90RjqZAkKfwmgnrwV6396GOAijtwR3qpOUwzFSKqWk7g8KQdU5r7cRI0aYGVc1U9EA7v+Y3JwKBXACc12ubZzkEBKRYWM56WFWMTfzJasL62NNiT9353c+Zy4RHbQb0hi8gWyDihEbzqKEdo3PdISIE7Lr4IgWSdO1115r17wPwmzuI3nhjQM5zpUsOPHg/+HHMzHIQlwcNMgK+zioetFSQ0BK/GjTpk3Vjx9WfME1IogePXo06HuQUVNWIVMJgmAtdwkEtqhhTPiBLJ4TYhC+XzkNCKqdSi89iBIOegh6MJS54oorrG8tRJYggaEC6aEiRE87mEFTWvcQqMeMGWP21vkEmWTorHEuJELOhaydtdIkahhzsSaar+3du/cqRk7VSMUDONlsoeUiUFefBJEaash8YwNkRCy5CAYHtuNsueWWoR4bn4dZSBAc28LuMBeu5FN12MNVksFBkD4cBhdUexTIRVYgePvRXwyxWNObmzjlfv5ZZ51lGTY6DiaPgvd0JoQwdgkjZiZTx5ud8V1EwWonJSCA00spNA5EeQVhEDPXHsoluLIBpVbmgRGbFTsgsAkHlfCkSZOs5BJ2lSlCtcsvv9x66Vj/oYimDxn3+FJW4cVOxaO+4pYkwZwrpcN27dqF2q8sRBrg3ucPpCjQsegNMxWy0UYbmW8Dn8tUSXDkEj1RMVdLfh7J2JtvvmkZNyV6kZAeeF3Q/8a6j1EwAjY9RrJqb6NXaGSAbI7+C6pmxnsos5caePl8xBmM8VC6YZZbwbt8UO3gtI72oNBqzzRB+ZC1i2q5iKxA/9uPcHHgLnW6hqpm+/btbceAnw4Cb/aSz+8fgRqHehlnJTSAcwIjKBeacyULJ4smg6bcEkaxyOcS3FGlk0HXN/DydcVKRCI66JNBGHe+tIDCVoc+kRWokHlBGklSvtXMdfHggw+u5MRGdZOtkSRn+aB3HlxsJRJUQgfUipTLC0Gvg/7HeeedF3rcgMMAy1BQ7wZPeiK5sOHrrrvuylRviypQFloCQgBeBIjW/Ox3qUZc+HKgWGc8kn42E0j0xumFB8VxQXBezNUiiQQFcHrSZNmI2fKNy5ABM5NdygmMXnWvXr2sb527J1okFyx22T+cFcg2mI0VIgtgVESgZZUovehSx79oQ+LChlKdVc70tL3uBavVQiTNfTGpxBLAgT3MGHgMGzbMzPFRjJciaOLzGCfI3f+M6pH9wiIdoN5uiM1i0kC7gdBSiLSDmMxXQDmY0ssuFTJthMXc7/HpoG1GNs7BvRAkYVmYTsl0AOcPS18E1zXmt6dOnWqitTD+zwTvW265xUo7iNW8UQvfA8u+TTbZpAK/gYgCqiwIFxG1ZAFGbdJqTCNEEIRnzFozVRF2FDcI9shBd8r777/f2qK4YxbixRdftEMw7TWR4AAOqI8p0RCI8YE+8MADQ30dpRgsWfl6snZK8vRMODEq+04f/P3feecdlwWoJlS7vaPIBrQluZ6XLFlSNOgWgmkgjLSAzJv7NKOW+UC0TGLGCLFePykJ4N5Ks9SbN/aozBXecMMNrmfPnjZTiLXq4YcfXrbHKSqz8SjtoLDlxidE2mGkFl8DWkJhvDT4/OC93M96k1whZmPEt9CCHn8fJzETKQrgmKdgdF9q2ZXyO6c7svAnnnjCsrhi5gAi2fA3LebQVx+iWjBS6u+h8ReRBbC9piWJgC3MoZR+ue9d09bEMRMY62XZCaZaBHI2i/l/8wGeTJ/RsZ133rmMv1H2iN3IhZsdpvSUxcmsS/k63thsRuD2O8BFOqF6wpgJkwT1hdM/JjxeeMPmJOZWmUrgGkNNW87gymSFEFmBYPz555/bxr0wBI1XWMjj91KQwSNcA4yOCO681imVY4nt14FqgU8KA7g38qiPiAnBA6XXsL1zkVy4SQRP5WEFYwgX+Vr6ZyxK4JQfDNIEcDIILHKZYUVYE4TqTzFFbFj4+eyDHzlyZIO/lxBJgNcTq5pLWf3pD86Mm5G9Q5MmTew1ycQQGqU777zTAjmvxWuuucZErBy8tfWxdBJRc0aZWGoGPXnyZDsdKnhnA8SIYSYQPBjAYLnLZrsTTjjBnXjiiXZzyM2wufmQDbACkWCN2Y8HY4qLLrooksfPz2Y/csuWLSP5fkLEDV7k2AIzMVSKvz+VruB4Ly6Z0KpVK9tr4Z0uCdokYWwbU/BOcQbO4hEsUHM3jHGS81kUF9H7779v/W56pZRE2S0ussGVV15ppg+5oIDlRY8nMwpWrgUObowesh+4FLh+br75Zpt84MDAClB6cw2FKhBmNM8880yDv5cQSYHXCRojSt1c32GXinCIfu655+y/sUul752vxUSPnS1jEq6lPIBTAiUz4g986qmnWomFExkfN27c2P6dvglBHCu+4LJ4kQ3Yq80NIwh7hdmARFmc8jT2unwePbP6Kr0RTV5wwQV2GMBn/8YbbzQBTUOcn7h22bhUSVD8ItzMt1ZXiCjwomBGvEodI1tjjTXsPa/phQsX2gx427Zt7UAAJGEcwqmeifrTqCaE9RnGFNw4CaLlDJ5kMCgWUSOWuvVGpB8Obpz0UaKyh52yNz7pUQrPyOi5iSCanDZtmmX0LNchG68vBFIOGpWEFtKRRx5po5T0E4WIEpThzGSzdAR/f8a86gvVVSZCEKkRbni9MZaG6C3squdq4+uQMTdRAVwIIKhyWZbTThFB25AhQywTIPji1XzJJZfUy62KG1PHjh1dJeGGiMsVfcSnn37aHA2FiAoOz3379rV+NlWq3r17N+j7UU1j0oQ4IuombMxNhIhNiELzpOUCkQ0aCm5QjzzyiPXiKPWVCl8bx95iyptjx46t9Y7WBjQRFWiPaDHx2sCYiIy5odAG9X1xER0K4KIqQTF+yimnWPCjRI/AjR319bkxxWUgxPglZXRaATIxElFBS8YrxdF3HH/88Q3+nmiXsrS0KCkogAvxX0XsF198UdJzQdaLx3OckIUzb0sgZ97dj/+U+rsIAUxnICBmBhy4tlZfffVIKl5hVewiPArgQjjnNtpoIxPt0KsLjrsQpBHweFcpPiZjpy/I59JHjxMmMxB8okqfMGGCu/DCC+33GDhwYKyPS6QTyuZBPUUUwZvXDM5rHDJFBsfIhEgCeDQz9sKqWvp+iEcQkSB4Y5QN0xhGanCA8/aPccPN8eqrr7ZSPsHb727u2rVr3A9NpBC0J8ED7KJFi0rqnfvRX65LKkI4bC5btsx2V2hHQPQogAuRU0o///zz7b8xjIHu3bubWcvuu+9uqm+y3iTAYWPYsGGuc+fOK5XUcZwbNWpUrI9NpBefdTNKhs4iLBx08SXgAAzsEGckmKxelAeV0IUoAB7O3qCFmxC2jwRvMlwy8SSo9SmfBx3g6H0reIv6smLFilrrU+a3MV8Ji9didOnSxd723HNPBe8yowAuRBHyefRTPr/vvvtifd6Y/Wb5y2mnnWY3SexmKVdqHlw0BASQ3hiI9hGH2FK+FndDUTkUwIUoAhaujJphakGAHDFihK2wZdtSXFAJoKfIQhd63yyawF0O8ZrW6oqGgBOiv7bDqMYPPfRQ2yqGLuSFF14oeaOgaBgK4ELUQfPmzU3VjUgHYRs9csrocYA4iIMEb4z70AenGjB8+HDrNwrREMi4uZZ69eq1ym6CfFDxQTD52muv2WEXd0BROaQuEKIO2rVrZ9aSuLV5sQ7z32zRqzQ4v7G6FLUw5XN6lmTjBHaZuYiGMnr0aKvoYC/cv3//Oj8fxTl7C1gVinubqCzKwIWog0022cTWkHplLqtPmbuuNARpxHN+bzouWR06dLDxHAVvEQW0YPAsB7aFhfFPIFv3I4yisiiACxECjFvIuDt16mTBvEWLFhV93ihnEqR98KYPT2k/KfPoIv2w2AcdBa5pf/zjH0NNWtDzRvSGHkNUHgVwIUJw7LHHWlmRUiGZMKXDSsHsOdaWeElTPucQwR5lLTARUc9/sx/g97//va35rGulMwGfa5AtfjpIxoN64EKEgDL13XffXfHnil3MzHu//PLLdpMcOnSolS1nzZpVksmGEGGucZaOELwvu+wy80VHXV6ot834ImttRXwoAxciobCmlPEwbFx9hjN79mx30003ue22285utEJEDYGbyYaPPvrITZ8+Pe/nYI+KWt1vLRPxoAxciAQyePBgN3HiRFtQ4iHb2WOPPWJ9XKI6YPkI0xZUf3KhT45l72GHHeZatmwZy+MT/0EZuBAJ5IILLljFEhUhnZzWRDlL6H7hCBWeN954w/rhQThEYiSEoLNNmzb6Y8SMArgQCQTjmG+++cZ169bNffbZZ27atGlur732crvsskvcD01kEIKyB4Og5557zg6RtGyCeDMjkQwUwIVIIMzVUqIkcGPe0rRpU5XPRdnwFryUxCmd46qGujxXKElJnXFGxhiXLFmiv0jMKIALkVBQmo8cOdKdeOKJbtddd4374YgMwzgYWfc777xj4kgy8s033zzvpEPHjh1tVSh9cBEvCuBCJJQePXq4I444Iu6HIaoAPA6YegBsevEeOPXUUwt+PoGdLFzEiwJ4ApFBhxCikrCBDAc22GGHHWz64fvvvy/oCnjrrbfafgARLwrgCYO+Ej2me++91y1cuDDuhyOEqAJ88Ibu3bu7GTNm5B0hQ4XOiBmfgyuhiBcF8IThl1Icf/zxbtCgQXE/HCFElSzs8dAHv/zyy/Nm4JMmTTJB5VprrVXhRyjyoQCeMJjDZE0kG4EY4xBCiHLDSlDPhx9+aEtK3nvvvZU+56ijjnKLFi3S/HeCkBNbwmDGkhKVEEJUijFjxqyUZUP79u3d9ttvX6vLwTaV/jhe/CIZKIALIUSVg/e5rwB26dLFlOhB06DXX3/dRsdat24d46MUuaiELoQQopZ77rnH9s6zbSwoXvvxxx9DP0tXXnmlOQdit4qzG6twRfQogAshhDAGDBhg78877zz3+OOPu/nz59sbUzEzZ84M9Swhfuvfv79ZAT/66KMW/MeNG6dnuAwogAshhDAQ0Hq22morN2/ePBOz4YH+9ttvuzlz5tT5TPkVpL5XzgEAVbuIHvXAhRBC2Oz3hhtuWPtMXHrppWanSuDeYIMNbEMZ++nr4uijj641o+K933AmokcZuBBCCFOYB4VrX375pRm80Pu+7rrrXIsWLex9KSh4lxcFcCGEEG7jjTd2y5cvr30m6IEfcMABtqGsX79+ZvbSrFkz9+233+rZSggK4EIIIYzVV1/dto15zjrrLHfHHXe4Pn362MedO3c2H/Rly5Yl8hnbbbfdLOtHdFcNNKoJsTnj66+/duutt5776quvtMxdCCGqgNzyd7du3dzo0aNtmcldd93lGjdubHvEydCTwvLly91tt93mevfubb37tPq1h425ysCFEEKswieffOKOPPLI2o+nTp1qbmx9+/Z1a6+9tnvjjTfcBx98kKhnbo011nDnnHOOGzJkiFuwYIHLOsrAhRBCFOTdd9+tzbK32GIL16lTJ5sXx6BFlAdl4EIIIRoM8+BLly418VqPHj3cwIEDFbwTgjJwIYQQIkEoAxdCCCEyjERsQgghRApRABdCCCFSiAK4EEIIkUIUwIUQQogUogAuhBBCpBAFcCGEECKFKIALIYQQKUQBXAghhEghCuBCCCFEClEAF0IIIVKIArgQQgiRQhTAhRBCiBSiAC6EEEKkEAVwIYQQZeGRRx5xG2ywgfvb3/6mZ7gMrFaObyqEEEJ89tln7s4773SHHnqonowyoAAuhBCiLJx44ol6ZsuISuhCCCHKytKlS91PP/3kHn74YffWW2/p2Y4IZeBCCCHKwoIFC9wdd9zhXnjhBbflllu69dZbz7300kuuX79+esYjQAFcCCFEpJBt0/v+7rvv7L+32WYb1759e9emTRs90xGiEroQQogGsWLFitr/fuqppyzDXn/99V2TJk3c008/7W666Sa366676lmOGAVwIYQQ9ebLL7+0UbFZs2a5d955x40aNcpdfPHF7p577nE9e/Z0m2yyiWXha665pp7liGlUU1NTU9cnff3119a7+Oqrr9z//u//Rv0YhBBCpJTrrrvOzZ8/37355psWK8aOHesmTJjgfv/737vNN9/cbbzxxnE/xNQRNuYqAxdF+eabb9ytt97q7r///oKfwxnwgw8+0DMpRBXSuXNnK6H/4he/sPvElClT3Kuvvur++c9/KniXGQVwUZTbb7/ddevWzf3ud7+zF2YwsI8ZM8YtW7bM/fDDDzbvibpUCFFdTJs2zXreZN6DBg1yJ5xwggnYfvOb31jpXJQPBfAICNGFSC2UvzhZMwLy4YcfWkAfMWKEvVAPOOAAN3ToUPu8I4880k7cpTxnzIOiUhVCpBN/kF+4cKFba6213Mknn+zuu+8+16hRIyuh/8//KMSUE/XA68mDDz7ovvjiCysdrb766haQ+G8yUS7erIAQpUuXLrUf83v++9//dmuvvbZ9vHjxYvf3v//dbbfddm727NnuoIMOcptuumnB70ep/YknnrD/btWqlXv++eddp06d3IYbbhj5jWWdddaxvwVZwLx58+xnILTZd999TSErhKg/n3/+uRswYIDbY4893HHHHVf7/99++207zAfvG6I8PXAF8BJ55ZVXrFS82267ue23336lf/vkk0/c9OnTXYcOHRIXIAi8Dz30kDkicTJu2rRpnV8zfvx4y74POeSQ0D+D5QWffvqpHWoIlM2bN1/pc1ConnLKKbUfE1xvueUW16tXr5J/px9//NFNnDjRgnTHjh1X+jvw/3/5y1/WjrdsscUWppDdb7/93GuvvWaHrzXWWMNtvfXWbvfddy/5ZwtR7VA2P/74493OO++8yr/99a9/td64KG8Al5FLiSDOoEyUD4LVEUcc4a655ho3ePDgxGTiCEs4eJx55pl2sHjyySctE8ZUYauttrKgTrAmmBIUCdpksLw/9thjQ/8cfl8ycFi+fLll2lOnTrUXOAeevn37rhIsKbHxb7fddpsFW07z9Ntz4XsReCnV8zjZbvT444+bwI6LnNL+6aefbp87c+ZMd/bZZ6/y/HOgAH7nJUuW2AvkxRdftBIgUEXAcMJXF3Ihs+DfhajmyuMf/vAH98wzz1j7K1/w9q9/DvRJuQdmFWXgISCw0Nch2BAsyF4JJPlgnALrQDJKZiPjBpEZgfMvf/mL+9nPfrbSvyFK4/chWz7qqKPcz3/+89p/I0hG1b/iuWNWlJ45vfRicHLn8fBYOUxwA+A0yjhK27ZtTRxDX/7AAw+0LBqjCKCMz+PlxsHnl3Lw8FBZIUvn6ym389wRzMna+f6IdXr37m2BXohq4/XXX7fEpF27dlZlo11YqPXFvYUKZV2vd5EfldAj4I033rBgTTAbN26c23///d0NN9xgN/Dzzz+/4NeRAS5atMj6rgTGOG74uB+9//777ttvvzULQ0rIaYFDEJWC1VZbrbYiEAbmUAn89NYbCoGcEjyVCg4V3LTmzJmTN7MXohpAvMr9hGodh2cCeiHuvvtuU6NLxFY/VEKPgBkzZlg2yEmSCxeVJRdxXZBpAspMAj59VsCJiHIx2ehHH31k5eZ1113XRQ2lZQ4diEjSGGyCIjj61GH59a9/HdljaNmypb0nw//tb39rgZtxujQ+n0JEsdebltOjjz5qrweEp4WgtM4SEwXv8qMeeA70g1Feo7Qm495xxx3dyy+/7M455xxTNZdCs2bN3MCBA2s/plxNH5egTVbMAYGfQ1CgX0T2iF/wP/7xD7fDDjvYzy6V77//3vr0PF4RHYzLIcDjkFCOQ5cQSYZqFPfB66+/3qp76Gj23nvvvJ/LPU1tpsqgHnig/MrKO4LsoYce6n71q1+5SkP/lj5sixYt7KSLwjMslOzpO1FupgKQhP571uBwdO2111rlZM8994z74QgRC8OGDXOHH364eZwXK6F37dq1oo8rS6iEXgJkrP/6179iv+AoF6PC9pWAUoI3Y1M9evRYRagmogOR32WXXWZjb2QjfMxBiX4gorlJkyZZkCcDoVWiIC+yCO05JlvOPffcgp+j+1BlyGQJnTlgxo4Ycdh2220Lfh43W8aXCJoILpIE6k0eG31z+vCosFu3bp33dxg9erT1u/WiKT88x7QneN7fffddC+BUTm688UarfBC4ucEhZORQiJ2kEFmCVmKxGW+mdoLrRUX5yFwAZ3558uTJ7rTTTrP33Gh32mmnVT6PkSCyXGa6k7hhjdElhFSMMaHIxuWM2WdU7UEI7vSnipWzRPSQfQf7fKxP9CDeYcyNLU0IFlHFhzHOESJJPPDAA1bKRcAWnLphOqeYxzkiNu5LovxkIoBjxoHymkDMhXXwwQdbpnT00Ue7m2++2ew6sfrj3zkZ8m/0upNs9YewbbPNNqv9mCoBJVqU7Yjj/LjVww8/bMYKInlQYkS0yDVIwCdDV1ldpAH2HiDWxO8CUS8LiwjKjHWSWBSbxsCNkQREZDCAYwCAgpFSYxSzydiDNm7c2ARf+fbOYqjC0gwycl9SJ7CncRyIx888ep8+fawH+9RTT7kzzjhDp92EwkGR6g9v3PgQSd50002m3s3nNidEEsDAiMQAr3PcGrFeHj58uI1U4o/AGFmx8U4ydp9kiPJS0VUx9GoRABFoUVpjYYlJxpAhQ+yEx02OLJOAG2bD12OPPWalZbKaYkvjCdoIvFBPcuHNnTvXLtK0MWHCBBNM4arGc0UvVqWqdIApDdcpB0o0GmTmQiQFKntkzkCVEiGmvwdTCUTrwT2b8VcqnMWg7YdVsSgd7JpR8FM1jjwDJwCSNbM4ggCIsQmZLD+Mvh/la8q62E5yo+I9/Vn+mJR5uSCuvPJK+17cwAisfD19a4I7m60oz2Cagh0pWbMvedPLfvbZZ83HmnEpvo6RqUsvvTTUY8dJC9ERvW/U5oxppQ2eUw46mkNOL1y3jOBwCGPWX4gkgEUxWo333nvPKpokBkFdB6Ja/i2M1gbdR6meGeI/sFOdGElMjHwOHAN7Ml0MSDhlEbhR2aK27dmzZ21Wsc8++5jtJBkHwRgwJ6FsHnY+mUDLBYPCl3IMP5MSDoeCkSNHWjm5vmVwSkPeQ1uIOKDSxGII/KQ5FKfJ6lZkDwSylMcJHCRMiNaCS31IpDBwoXxeV3BmlSgHgPoYUVX7lstGjRpZgkncLPs6UbLi4AKMcoEfNVk8QduLKYRIO9wsOYxSXseBjzImvXGmDnx1S4hKQShAcMlkTkOrfFRUC21trEa+/PJLqyDvsssuNh1FiwI7bQ5EQKU6uLa5IkYulQjeEMxQFLxFVuAmiSCR0zYl9ZNOOsmEbiiAUf4OGjTIAjvBXIhy8vHHH9v1hnqc4NLQAM6hVPx/dk2VmjYEVTdaw1EdzmWlKkQCwaMANS+TBnE7BIpsg2EUbUoOiuiEOFBSQm/IMhJl4M4Ex3hBoHUpZtCMjvcAAAwgSURBVHyTj7AZeEVV6EKIcNB/xI+fqQlGerxBhhDl2P6H1oiti2eeeaYJ1Sj5pqE6m1QojzNl9ac//ank4F0KCuBCJBjWNjJtgajzmGOOCTVeKUQpsLwJL39K52SMlHrRYYj6c99991mpvNwHGTUqhEg4GGnQQ6Mf7n0PRPZA+4DaO45NiIzVssObvffsX2goZPSMFVfjTvAff/zR3ldCu6IALkQKYFyTcjqBXGQDRmIx9aE1QqBjfAvTFP4/mRtB8JRTTqnINAI/g133UYmEefzVNkWxYsUKG5fu27evjeVVAgVwIVIA4iIEbaeeemrcD0VEIFAkcDMaiw9AIfgcForkLjAqB/vvv7+1aXgjiJ911lkNWvJEAEeAhSlM1vnpp59sHJSMm1Hn22+/3W244YYV+dnVV98QIoUwJ8oJv9qymiyCVTQW0h06dCj6ec2bN7dgSkZeyJCqPrBqmSDDXDK7KYK98Msvv9xcKwv9zLAcdthhZlaUdebNm2fBG3dFVlIjBOStUigDFyIFIGQrtkBCpAfMenArC3MYI6jSNmGJEfbViBiZsWbEEOMf3M6wl95rr71CH+5w06Sig1ANvwHed+vWrfbf8dxAa9EQOHhkcRa8pqbGyuM890CFoXv37rEdrLP3DAuRQSZOnLiSU5NIL4wFliJERP/AWxC2EVKuJaBgcUpGvfvuu9uO+rqUz4sWLbLsfptttrE3VjEzC87cMYtKsLtmlIxSf9BOtRQq5dIZx9+O5x2tQhIOKPE/AiFEUSid0y/daKON9ExlAErfBx54YIO+B0EEyPxat25teyYo544YMcLWJefbzjhr1izLvPE8b9q0qe2aQPHOhrF9993Xgu6AAQPc5ptvboGbLJPsvj5wsMiaa+bS/5or8XwlBQVwIRIMN0K27zFKJqKBfQqUjsmg2KxY6dYEwZK98AidjjvuOFOfNxSyXbY7Yspy1113mQgtCIEHhTRe3GTfBGuyST4/+D0uuugi8+hnpI1AXl/8UpSsVcGOO+44lyQkYhMigWClyA57Fh+QVVGyE9HAgYhSMepuAnmloTx9xhln2IplsuIoYVMYe7vpmU+fPt2yRsAeFaU52SMCM2a9Bw4caOKrXK0F2TkZfUMy6PHjx9vPyRKNGjWKZEY+SpSBC5HAEivBpV+/fpZVcTOuby9SrMpBBx1kQiRUw/SWb731Vhvneuyxx+zgBGSfW2+9tZlykLFGbUjSv39/m7vGgzxq0EoQuMmC//znP9vvRrk8uAYUcVy58D7eWTJxee+/7YakoWUmQiRsppTskOzI9zlFtBCoqWj4/i5BmkNSy5YtTVyG5oDtXAjFKK/TW+7SpYv5g997771Wnkalzf+nSlIfWNvJzycrLndWN3PmTDuQtGrVylUC/Ao49GDJmkbmzJnjnnzySWtfeSMdWh641FVKuBZ2mYkCuBAJgsyb0iOBhC1GIlq4KdOSKCXwchNldpqMkhnpsWPHWvDljYUV/M34vgjHuOmGhb70I488UtTMJY28/vrrNvLGuFzaGD9+vIlF0Zyw+pNxPyoX7CTgUFIpFMCFSCHDhg1zPXv2lGFLBDfAV1991cRYiMV4I3siOzzggAMs244CStVvvvmm2Z7ys1ghmSsgK8RDDz1kfea2bdu6LOErGmk8mIwePdpm4v1cNweR559/vuIi0rABXD1wIRICJdkPPvjAvfDCCyYiEqW1HgiIBFRU5tyAaUEQqLkJs2mL96effnqkvVm0CSyZgb333tsc1sIs8WAskBI9qu+swUx50tTaYcFFjb8Lan2gvZHkCRAFcCESwOLFi93VV19tb1mbny03qK3JfhFvMQqFijouCOYcJIKmOwjmOJAR2P00Ada4ZKhDhw51vXr1clkBkxjEf5XyAo8aqilHHHGESwvZkQkKkVKYyX3mmWfc9ddfb31UnLBEOOg9k80yloVQK87gDQQvFMtA+ZNslKBNX5iDRhD+zk2aNHFZgjYFIjCu6TTSuXNnN2HCBJcWlIELETP0ZCnZpenkHyd4g9Pf9jBPnSTwEkf5TXbNoguybcAFbdSoUbUWo4x5IY7KEvyubMwbPny4LWuppPArCjh4MAufFqRCFyJmyLxZKEHpnJ4tntbVvHUMHQCZNYGaIMe8NAccetu4eyE0SvJaVR47Y0iUY0877bRMzUOX8hwgZEOpz/WcBpYvX26eAGeeeWbsi4OkQhciJTc61Ka33HKLfcwaRzZMnXvuua5aV22i4r7wwgttwxYK3FdeecW9+OKLNptN2RmBVNZKz1mF8TuMifBnT/Jr8N5773XfffedXVtJME1SABciJWDniVEIcLNDMV1N1qncQNmIhQBqrbXWypwFZ7WDJoB5d6omcWe2+cBmlm1uffr0SYx/e9gAXn21HSESxqeffmpBDMgsqyl4eyg3s6FLwTt74MjWtWtXE/T5PdpJYp111nEnn3yye+CBB1zaUAAXIkZw43r22Wer+m9AnxvhUCkuZiJdUJZmXI7lLbibJY0111zTst20oQAuRIwwL4uArZrLqyzcSKvxhwgPwkwWyFAeZsteEvjhhx/c/fffb6tC0zgRoDEyIWK+qeHgVY2q8/nz57tp06a5q666qip//2qFBS5k4djatm7dOrbH8dxzz1nrBi97P+qXNpSBCxEzfoVltYHSHLtTBe/qg0UnzMXHde3Pnz/f3tg2ltbgDQrgQsRMUpSvleSjjz5yLVq0SLTPtCgvTF7cfffdNn1QSVasWGH2tsccc4xLOwrgQsQIJbwkjtY0BBT1LGQBdmjnK13OmDHDxncwzxDVCcZFHTt2NO94THsQkdGTLifPP/+8ueHhQ5+Fyo+c2ISIefUi3suNGzd2Bx10UO3/JytJ40IIFnZwU2Z5B+M5eLzze3GzZM/yPvvs4y699FLzzB48eHBVupSJVWHHOkGcnng5RgmXL1/uJk2aZK+rNCyP0TpRIVIAgQz1K/agQQYNGmSBD8FPmoIcjxUPbFTlHE6CN8vZs2ebwxw3UW7Safq9RHlBnY6NKSOFUbNw4UIL3syiJ8FlLUqkQhciIXOoZAmU0+nR4YlOKZr90nxMsOPmg90j2SxLIjDI4H3Seug8VsqjuWtR99hjD/PFxjAD5a8QQU466aSyjJdNnjzZttVloWSeiwK4EAmAbNUH4qVLl7ply5a5/fbbzzJ0/+/0B7EapUz9ySefuHnz5lmJmo/5Gvym4/YI53H7x5wPbqIK3iIfHFA5/LHMho1uUfDSSy+5nXbaKZPBGxTAhUgAmLlcffXV7oorrnBffPGFOVbRS2Y/OBAUfWDkJrfpppvam4csnV46mTxz5bwn2Fc6O0ec1rZt24r+TJEdaL1Q7mYJir921113XdeuXTu7pkth+fLl7sEHH3SXXHKJyyoK4EIkgEMOOcRUuNy82BfN+symTZuG/npudtz8FixYYFkHpXayYQI72Tvv27dv75o1a1ZWRT2/QzU7y4mGQaaMhsJDG4lJBpaNdO/efZUe9vfff1+7Xz2X8ePH22rQLKMALkRC4EbE7uttt93WAnp9IGP3WXsQAviUKVMsmylHhoyjGpUBxnOEiDKgY7RCIB42bJj1yTmsTp8+3bb2obMgiB988MErXfeouKlkpdmkJQwaIxOiikDd3qNHj8hubJQpmaulX7/NNttE8j2FyAeHUCpUBHWqSWv/NxtHA0LrhlW8QeU5wZ798WlE+8CFEKtAORLh25IlS2r/H8I35tC5Ifo3Pi5Umgy6qaHwZRVj1sZzhIgTBXAhRCjIXOhdo2T3bwR6SpNevYuArlWrVuYf7UuX9Naxo8yqwleIuJCRixAiFGTgdY2fUSqfO3euiev4XAI+zmpCiPiQiE0IUScYzGy//fa1Hyt4CxE/8jIUQgghUogCuBBCCJFCFMCFEEKIFKIALoQQQqQQBXAhhBAihSiACyGEEClEAVwIIYTI6hw4G2G8O4wQQgghyoePtT72NiiAf/PNN/Z+s802i+KxCSGEECJE7F1vvfUato2MbS+ffPKJrSKU77EQQghRPgjLBO/mzZvbmt4GBXAhhBBCJAuJ2IQQQogUogAuhBBCpBAFcCGEECKFKIALIYQQKUQBXAghhEghCuBCCCFEClEAF0IIIVz6+D9PATB7HLrkfwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First, just plot the station data so we can see where our data subset is\n", + "\n", + "map = Basemap(projection='merc',llcrnrlat=-80,urcrnrlat=80,\\\n", + " llcrnrlon=0,urcrnrlon=360,lat_ts=20,resolution='l')\n", + "# draw coastlines, country boundaries, fill continents.\n", + "map.drawcoastlines(linewidth=0.25)\n", + "map.drawcountries(linewidth=0.25)\n", + "\n", + "# # Add station data over the top\n", + "x2, y2 = map(points.lon, points.lat)\n", + "\n", + "map.scatter(x2, y2, c=points.temperatures, cmap='viridis')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "46c3cc32-bc88-4e19-8665-45ea03197381", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAGFCAYAAAACQ6GUAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsXQV4W+fZPWLZlpmZ4oDDzEkxZWbmru22rms76j9mard1a7utK63tysyYJg0zg5M4MTODbOH/nFe+jixLtsx2ovPMS2o7sizd+7103nNUTqfTiQACCCCAAAIIYExBPdJPIIAAAggggAAC6DsCATyAAAIIIIAAxiACATyAAAIIIIAAxiACATyAAAIIIIAAxiACATyAAAIIIIAAxiACATyAAAIIIIAAxiACATyAAAIIIIAAxiC0/nyTw+FAaWkpQkNDoVKphv5ZBRBAAAEEEMBJCqfTiaamJiQlJUGtVg8sgDN4p6amDubzCyCAAAIIIIAAekBRURFSUlIGFsBZeRMTnv4ONMEG9AVOmx3thVWwNbbC3twGlV6LkKkZMB8shsPugC40CC2Hy6GLDEb4wknyb/i91qoGBGUndn88pxN1n25H1Fmz+vQ8AugZDWv2QZ8YCWNWApq350MXHYr2khqEL3K9J0T1e5ug0mkRdcZ0+f6IU6YGXtYAAhgCNG05BI0pCMETU+TM663z2bK3AHWf7UDo3ByETEmHNjyk82uNm/NgrWxA9Hlze3yMhvX7Ub9qL0JnZyN0zjhoI0yoen0t4q5Y4vPf1H+9F06rDZGnTe/Hb+nl9ygIw3AjJL2x1+9xtFtx9GcvIubiBTBNzUDLngKJY32Nh55Yf87/ef18Y2OjFM1K7B1QAFcuHj7Zvj7hpq2H5cNhtiAoJwlOuwNVr6yWQBG1YhZUahUsVY3QhoWgcVMe+/VoPVgCTYhRXihP1K3chfAluQN+4QLoCm2UCTXvb0bQ+CRoo0LReqBYArT76xx/1VI4HU55z/j+BN6DAAIYGoQvmYzaj7dCHx+B2s+2I/HmM3r8ftO0TCmQGGjaCioRNn9C57kdPn8CSh77AOZDpbBU1CNswQRow4K7PUbU6TMQNnc86r/ajfqVu2FIikJEL2etxqhDxCAWU2qjEcMNc4URpsyGHr+Hr0Ha9y9DW2GVvI5MbvQxA082wsJ6fozeErchJbHxsK/9dDtiLlkItckomRqfUOIdZ6G9uAaW8jr5PlttE9qLqxG+eBLaCqpgb2xF3DXLuz2eta5ZslJ9bPhQPu2TEqEzsxG1YibC5uSgaWOe3Oi6SFO372PwDiCAAIYWvM+CshKk68Wg2hvMR8pR88FmWKsb0XasEuaDJZ1fUxv1CM5NQ/PuY1AH67sE77bCSjists7z2lrTBHtrO+KvO0Wqam9dUHfQSWOw7DSaj47uc92YEgNY7dKVDJ2ZhdEAvyrwfkMFhC2cKAE34fpT0bT5EMxHyqDWaWFMi5VMkVkeg3fYokmuKj07ARHLp0ClUcPebJaWrdqgg8Nik0CvDQ0a0qd8soKvd+jscXIzhuSmwt7SJoeBrpcsk9/PA8OYGgOVVjNszzeAAMYi2IFkoFTrer9XrLVNiFg6GfYmM+rX7EXVK2sQedZMGJKiYZqW0eV+Y6t93J9vk9GWvc2CtuJq+ZyC6HNmd38uTieq39koBVPY4ly07DyKkGkZ8r3+kpWd7dYAsXkEMaQVuHIRlDz+oVTbbH0rAUFt0MJpscrfE249E442CzShQYhYNkX+3rBmr7TSeUHyQpPssq65y0UZwNC8ZzEXzkf0+fMkwfIGGXV03N/Vb64XTkLt5zsCb0cAAfgAK12eYTJn/nIn2o5V9PpasdLjPehot6Bx/QEk3X2uzLlbDxajvbSms3J274zxjA2ZmCJFEZOFnlD5ytdo2nIYjjarzMg5MuP56z4/7wkt+woRPOnkIjdXvLQK9av2YLRgaCtwwumUdiwraEIhUrBVrtK68ge2ag0pMTJ7YWUekpvW+c85P+fnWZXronoe6AcweGCnw9ZklkOA1bk72ktrETZ/vHxNGxEiSRUTtNqPtyHq7AC5MIAAPMEzMOLUaZ3zZHJ59EnRUOt7PoKjz50jfxrS4iToG9JipcVtrWqEITmm8/s4+2ansuVAMSwlNTBmxKPkiQ+RfM95XsdeDP4tuwuEuKoJC4YxPRYt+4skIHve7+7/xt7QipoPt8CQHC3/HX1298r+RIWTsay0FhhFY8QhD+DMIs15pUKwUKBqcyLxzMUofPGjzs8F5yTJR/U7G+RiVVpMbOsGMDLggUAWqi4uXBIrZR4Wc9F81K/chdZ9RWgvq4VpRiZK//0x4q5aCmtNI3TRw88kDSCA0QySdOs+34GgcYkInpACR2u7BEIG9MgzZvTILbFUNwiplK3tyFOndfs6t0WEDd5uhWlGFiJPny7cIwZ5jixJhKt+az0Sbjq989+U/fsTWMpqYUiNkYSABRWJqRydqfXduS9tRVVo3V8sCXv0BfNkDKo+yYjE5sNlyP7zrQgen4yTRomNa2PMXNgW15bZEfmfFiQ+2Iiwn5Zg8qFpiHi6GZpKe+f3R545Ew2r96B5T8FQP7UAekH4wokSlMOXTxHSIQkuhK22WYgxfF9jL12Epq1HEHvFYmG+1n2xS9p7AQQQwHEET0iWyrZp2xFZQWL1HX32LEmSyWrmXFyZe3u2vjUhQdLJVL7HE5bKegm+uvgIqIL0Erz5s9glq3l/E4offVc6nO5I/uZ50MWGI/MX18naGLuhTNK9EVeZIHBUxmQjbN54+R6NyXhSEVrbi6vRsHaf3+OFEyeAq1SyUxyTnIPYPzRDt60VB2pXo7B5F1QOFRwbqxD3h2YJ7gQvEmZ23B0PYHSASkDhSyfDnF+Ouq92w5xfhqAJyWjLL5ev82vhi3Pl0CABjtVCAAGcbGjcckjGSOxCeUP4silyn5Q9+7l0rZgEG7MTpLhpXLdfvqdh3X7Ur94jLXa2xQlNkF5a8L7uK1t9C5o25bna6Bq1bJOwCo88bRqcFptU//xvdzAZiL/+FPl7zPnzJBEnx8gTZK6TzJp4+wqZrw8VRpqB3tzLz698bQ0SbjhNuhknnRY6s7aa33yC/JrN0DjVsDraEKQNR1HLHrRZGqFqByJeNMN8tAJVb62HpbRGLlil4gtg5MFsO2xuDiJPmSprLdaKelkzEW2AIH0nYZEiEr5maAEEcCKCgZOJrSbIICzxxo15Xqtlzqabd+TLKEq5X7iaZJqeKVUuRa9gd0ibnKPHyle/7hw9klvCdnjx396VapDguJHtb/JPKOBiLa/vHHNVvb1BEoSU+y6S6t/b/UydDXbRWvYVSXuY97TyvMlzYSVvq2uW58cK/2SGJtjoen9GGYblpA11RiHEHIa04CmoaS9BmC4WQdowmHRRqGg7AputHYZ8O8xfH5E9b11MOBJuPh3Nu44Ox9MLoB+wlNXBmBnf7fM8ABztx9mxAQRwIoPBj9Uymd8cFxIkeHHl1RN2c7ushcVdvlgIY+6Q9rdWA3VHoGRrPeaC+aj7apcEaUNilHw+/vpTpR3OwMvgzqDOkRZn03HXLOtQvDQL+Vd5nJ5UK5lIMJjXrdqNyBUzO9vibPOzkicrPQBIx5Gv5UkZwLXlDqSE5KK09QBKWvYh3TQDTZZqaFRapIZMhU7tIkMYEIKoM2dIy4ZUfV6YrYdKh+MpBtAHOKx2YWKy0mb2z5kdDxJWIXWfbZeOSwABnAzgOqzMsY+UwVJRJ2tePL+00aFe1dLq1+xD0458tB2tQO1nO2QmzmDstNqF1a0x6iUp4OcYlOVnGPXyp4uctk1a7vw5jZsPyaot2/GyX253oPyZz9Gyp1Aq+97WyAjR2tBrpcpmUk6IdKsfe+oBnAxrZLwgDCqoVRpEG1LRZm9BUctuJAZPgEkX2fk9zdYaqIyui0aXGAFHS7vMXJgJkp0ewOhB87bDsh1Q9+VOIXVwH5QtJrbXAwjgZAJb1vxgUtuy55jMnNlB9CaEwoQ39uIFXT7H1bDW/UWIWJor8qUM0qzobfXN0kbniIqMdZLG+Heu4TbvcHUmU++7ENbaZlFsI/mt5t2NXXbOQ6akycyd8p8kqHkDhbLYkudH/LWumTjb5vSi8LZCejKieU+BrM+dtAG8faIWDh1gdJjQaqvHuLB5UKnUsDmsqG0vRlxQJmqcpQi+ZLF8v2lqpgQJEgaYIZqPliMoM2E4nmoAfsBuJunmgMzdSFAMIICTFZxdt+aVuAick9PQrtPC0XJ8ZbY3cF+77oudLu0Ltq/VKmmNs03Oqp48IPd1LcqgUsvc/d8TTocD0RfOl4S66o21yPjFdTBNTUfT9ny07iuE8bpTuj3vlr2FUuWTBBcyOb3za9TbiDp7tqy9Ud6aY82TGbqIELS0mMUUxh9Z2xOvAg9SofkMA0I/AiIMiSgz56HV1oAmazVM2igJ4LaZIdDqVJ0iIgqZgtktKz17SztMU45fZAGMHHxV2tKyY2s94BkfwEkCBlllN5uVGjuG3ty7uEdtTPVeBesTo1D7yTYEjU+We4dVeM17G+XzrJDrv9oFlUYjwdSbXDGZ6ySZ8f6zNbSIeiVXOym32rQ5T1ZzPcHHYYFkTI/zOvJiomCalY3K19bKY/J3ZJv9ZETrYe7SRwJOSGeDst/e1u1GAsPWH2k6z4CWU/SID8qGk3FaBcyMOR8TIpeiaYUBbVOO5xJkQPIFIxFD3K86tNMDGL1o3nVMMn9e4Fw382f+FkAAYwmiZ9Gx2uUNLDCMGXGdqpPuoJqkQizzBFcvSTQL6iCFsoDhWpfT5hDxlohTXMGT62UEq/Lq9zdJ5UxwBk9FtdBZ3OfWIPG2FdDHhsnXGXwNKdHy/e5g8CZ/RZmzewM9LLhqxsek30HVG+tco4K9hSLDyu7oibBC1hu04cEuOe/3Nsm5Rlnb0YLhG3CoVWi4MghHlpeiZbwdzmwTCqeUoOJXoSgIz5NMUAEvkPaiKtFGp+IXTU5O9jbOaAaJhhSCiLtyqeyU0nyBVogBBHCigIGLAlPc82bVrUCfECmtVQb2pu1HRP2Ma5WeMKTGypxZCKB+QIhrKqBxw0E0fL1X2uymmdnytdYDRWLFzMqbYKXcvC1f/k6vCcp90quaUqpMBKiaxjUxfijgrrpCjuvxeei0iL10IdQhBmnT13+xU/6kNTQd0E4kNPtIJOjUyI5EM81epmaIct5J1ULv8gMzIxByaXbnRW4jUUKr6ZzlEGSiEyRm1H25C2lnn4agd5ugsjphTdOhbXYQoD15VIBGM7i2woPJXeKRCVdghz+AEwFsiVuqGmS9ipsxtNlsWH8AxqwEaXdTVlOkTFfvFTY4pUy9gVU1ZVQbNx5AxJLJfv3sKB+Bgq32xvX7pRpkQkDZaa6hMWAn3Xm2JBWsltly10aahChHAlz58ysRtnCCa7fc7kDsld1b/d7ADihVFqteXSMzdm4HsZtAc5WTBaGzx4mMasveAjHaImdhNMh8D3sAZytIVo0WTZKshi0eX0QoncaIybUzEPzjKjjZK1ABKmodhKpR9+0oWHJPbnGBkQbbSmzrRZ/rMqjhvipneQze4YsmutZRAvPwAMYoGBwpKKWomEUsnyrXN9vd7tc197750RMocMQqui9KXjQTUht1UgV7trYxIUUCOIM3iWrUNedqGkeOnM8m3b6i8/vZyTRmJiD2skXI/7/nxSCFv5M/9yYTAfndtGroYsNk7Y1rbBQ1cdINzUu34USESqOWZI2jXEtlg7zWowEqpx9u7I2NjQgPD0fuy9/vdNMZCJR5Aqs3sh/phNPNaczhRPSvq6A/bIHKY5wqM3QNUPWreNhSR99yfX/A9gz3R3lT0tavN5ei0VKdcN9VEZnggcdqvHnbEUm22FYka5OVRwABjDXQIIRzZXcVMrbLSagd6pXJmo+3is2nLsokZwJb1tzt9vYcg7ITXIQ3PwIyk+ya9zdL8cR7l+qKPZ3Tpf/6GBHLJstY0xs570SbgZsyG7p9jskKX2d2LkJnZrmcM1fRIXPg18CuC37ZY8xtaGhAWJhvc6gRWfITffS4cGE/UjbVm02ofl87DHndg7f8e6YcDsD0nnfN4bEGtqOYJTMr5u47dY3HAtg9cT/cWA2QiMNMn7M3kXVUq6TFSMIMtZY5J2TiFkAAoxmcc7Pq4vXN65XOYQKVS4K0J5A8RhnUgVznrNbZxaISGtvyluIakZp2B4VfWAWTQOoreLd1yK4qYAFG4yFNeLA4j/UEYcSfNk2kYb2pLp4MsFY3ouTxD1H+9OfSKebevTi/2UYHSXfEtvTDF0wUAQNvjE0iaKPZ1Tb3AQZ2fg8r9bEMZtdsOVOMgRDhhh6YrqMJ2ghTF5tYdwgDloIQNY0SuBnAWZmzhVjwm1cDQTyAUX1os3VOIRWiefsR+ZOsawp69Ma+bqKGRUdXyh28r0v++ZFU8e5o2HBAdMer39mIw997Wj5HudWmzYfk/mJLPHhSimx5MLDzg0k/7zHeg+xmci7PWT1XyFgx8n6jSlvZfz51GaSs2tO5GSKz+4kpYj/aG9g2pqw1hZr43IsffQ8navXtDRTB4fmV8cvr5Hrgah7HIdTAGA0YUZkdsvliLpzv9WvqVofs3fUEzsMxhmW36aUt/uepx1tjJO6ReDJawRU/GiVQLYofXF/xBbYAKRHJ9RrFp9iQFI2s392Ewj+9KTO+AAIYTaCMKdujygHNNnJbUbUQuRo2HETYwokSKBlE+X3eHMnYUSTpzXNnm//NDpXaoBctdNFR/2KnmIhQNY0rmMl3nytBmKQxenRTP52ofm+TaKPzHmJlX/XmOlkfIyO9vaha/L5ZKTduPCgBp+ypT1G/Zq9shEiwb2jp3AxpK3Aptfki3HmCAd9W1yTk4uRvne+zNe/HNHbMgR2Y5q2HXbyDDjCh4ghiNGBEB609OdzYErQyR/UVxKWLHq4GdGOnJcf5MOdnbCvLjFulQswlCzvbX7wxmSn7SmpGA+hdzMqa+6nuzHNPcL805iLvvwcPt6Q7zkLxX95Gyr0X9riLOhyQVie1pzu8fgPku5MTTCgZqGIvWyzXBMVTCn79srCNuVctdpsOp1TG0efPRev+YiFx8rpRRE6YsGpjwqRKY1VNwpgCtuQp9qI+UiaiLvamVtjqWEWHyFx6/BP3yPdwhZZIuuscHLj1b3Kv8fpsPVjschZzOJB465nCm6Gn96Tn7xfbT0NClCQILbuPISgnGbGXL5Z7ja12EuEoiEUSGv3DE64/tU+vDYsK0eRQq0TngV1Dyq2S6V74+9eFlEx7YSY+SudiLKL5aHiXOThf75TvXIiC372G0Dnj5PfzxkUYKYxaplTr8hCY3unBTlQFtJxhkiA42sEWVu0n25H+46tgq2mEJiy4CxmQrS2axTNDZ1diJPWHebNTU9lS1SiOSsGTUqW9T6JMxYurRMbRnFciwhQ9uRz1BrYYm7YcFiLcUPoM+/PeVL60Wl736Avmwd7YimO/fAlZf7i5G/s3gBMbbUfKUPvpDtGkKP33J0j7/mXSog6ZliEGIWHzcsRMJHzpZDH+4IxaZdBLJc5RIJPy8IUTpTPFe5mBjpUpR4V8TO5o07WMfBdbo1mCLIN3YUdwYOvbde+7zjQGywlPfqvzOqRZEM8KQ1osDn/3Pwgan4T0h66UBMJ9NY2Sru7ovI5VKnkeJOb1FVyb4u/FIoTzX3KXaHjCtn/UeXOEnR2xfIow1EnAU0ElFqgnAoLGJ8kZRbOa1g6jmNGCUXtC2eO0aLoyDGGvNkq17R6mORu3JWvRcs7obTUTvHkbN+XBWlmP2EsWCMmLO5ruoBFIe3GNy7jANPJrce2FVSh/7ktpFfJwoJE923ds8zHAsdLgx0DbZQ5zOya/8RCK//o2wigROQKJGKsssmu538mDp/ajLSJukXjHWaj9aKtk2+wSjZZ2WQBDixA6clXUS8ucCWvpk58gbP54tB4okaqXbXSuD7EtzRmyIi5Fi9CSxz6QiplzZZI2w5dMlkBa/uwX8liu1cpJYkai7G5zRYuJe8ZPr0bRX97pTNwplKLAPYlk4GXirMzXFe9vX1B+DsdyLBh66pj5A/57Et9YxeviIlzrdSqV/IxOhAVLYt+yuwDlz32BiNOnj6qA1x9w5MD3ke8PzWFGE0ZtACeaLwyDPUoD09tN0JW7ht0Ogwqtp4Sg6bIwOI2j1ylHdqI/3oroC+Z3vcA7Km5RbapulIycvrsjCQYvqqkJQafNItUnDyiCpgZs4Xkq4Q004JLcVvTI2zLrGynQkIXzSs4S+cH1EJKBwpdNFgUsVk60WtSGhQh5JYATG7ymla4SO00M1Kw4yfMwHyqTZI+dGm2kx8hHrZb7hbvY7FaFzhqHpk0HoY+LQPCEFJQ+8SFS7rtIKnJeRzwPyH9hRWdv5K63XpjhrNrZxmdr2h3KSIeJJL/HkBQlyS9b1lRpY7LgrqVBshxHcRRUooIar3G6m7HyH6gZBxNaJiy9vY78PTUhBjSu3Y/W6FCfojRsV492IlvwuKTODkfVW+vFzMmb2t7JHcBZ0bGo6zCUV2BeEgLz4mBoquyixGaP0cBpGL2BWwFvIAYnz+DNA4GtsNAZWQj1EIQYbvCwoDAFW39s75FM5y5pqyhIDQXoLhe+cJKQePo6jxss1Hy0BTl/u7Pzv4NzU2FrahVLSB546gnJUjVRKIPvpzbKJAcYX6OAzeKJDSVgtlntaNp3xGUw8sFm6UTxjCLZjB0cfg/vcQZ+ssRZrREkliXceJoEX47OmnfkSzCXNrlWI9c9x1MEZ+VVr6+VIEGyGcltnVajB0uEiR65Yqbci0y2Fc4Ik8uG9QdFWIRFATc8ZNWppkkSipCOxyf4dT4HrkS5WOUD1/PoDewQULGO8/2xApPHHjitWQ99619I+e5F0oFg8sRYNVp4MiMewPX5dpi+sMC41y6rYdZ4FVqW6dGySAtoOl4glUpa6mMBfGPZfmX27q7OxBuIUoecE1GOcaTffD6fgl+9LM+FhJuRCEjx1y7vVcFqKMG5HQ9ERROa7Uol02arUGHpcteWYwN2TURTOr9cGPY81Jn8BIL5iQtlZMRuGavr2EsWir0nPbrZQeLnSDplUI0+Z07nGIyBmuB9rjLopCPHgMv9cIpXuSetBb9/TUSyCAY7Bl6eIwW/fQ3jH79bzj8mm1HnzpHHUEDCWtr3L5WkklW3Sq1G+X+/QOTpM1xkNzfwGiUZTxsVisYNBxB5mktdbqhBwis7Wbhgns/vGc1VuDEtDpP+ez+O/uxFSaT0ceHCm+GmQNqDl4y4R8eIlrJBm62I+Zu5M3gT2gonwl9rR9TT1OsdW2sJDAaV/1slWXncVUu7So5+tRsRS3JFBGIkgzeZpKy6K19eLRUCD6f+BCBWEJ77sFyv8RSb6AncYyURZqTAg5RzTW9g8ObvyPdOZoihQdJm5yHIdiBdp+hZz++hyEfAfe0Eh0Yt7e6Sf7yP2g+3CAOcfBFWvAfvfkx4IiWPf9D57WLt2dh6XNPB6RQdBFp7cs7uDp4JDHTSmg02iMgKZ8is+lit8/7URZjgtNjFLMUdygiIZw6Th+R7zusWvD3PKM6vhwt8fuQCjBVtC282sOQpCcG1pU3ed0VWlWt7I40RC+DqRgci/9cubXN3tbUOp1EYd9sRsm5sLXkzILE9rveoKrmjyZvW373LIYUKEnAozcjKu79gq7BhXVdbPa7XKJKwvYGtQq7ghC2YiJECmaU0JiBYXfN34pyz4n+r5KBs3p4vCkx0IxICy6JJMrfkyg5320loiaTxDnd+R3BzIIChB3d/yapOuOl0SfoolJLx82uFEZ546woJvCQ/MkHmymj+j54TERUG9trPdkj7PHT+BFnDpDSpO/g17mqXP/O5kFxlXsxO3ifbunyfWquWMQ7Bil4BE0xfJDZPrYWKF7/qNmMfapAMyteACX5fJExHA4ypseKISQMX7oKLWUxchIwrOGYbaYxYXzp4g03kUHuqRUNWWdCydIwsevMGCzZIi4UGBAo4dyLLPO6aZRhpkIDBJINa65SxHQhI+OI+qTIL4iFCAhgZt1wjib14oU9WPSuN+q/3CSOXqzIjBT4/TWhwpw0k2cNk+sZdvUxWg7jDywrLXZCDJCAe0DyQaKFKBAhuJw8kwCZEynVPAhkDbeQZLmMQrpJRYIUrV+Meud3rv/e2I02vAE+/AOmMGXTChKe/N8mlbKVrTUFyHzes3Y9xf75VEoTWvBKkPXBJ57+Vdj2TSp0WJX9/T7ZJ3O9bRfVxuMCAFzZnnDzn2IsXjNpWuslHEpH+f1d1rMdtk7OL3AXPVb2TLoDrinvWkuWxrqt0utroyix8lING75wt2Rpa5aKt/Ww7Wg8Ui3evu5LPSIEzM978gyEUEzwxWapOtuLpP0yBGio1UbvZF9hW5GvEqoDBj6pRJPqNZPXKgM1EhLu07gdbTys3JOf0tsITwNgDAzArZHZZxDwkNbbH7+dMlMkwgzc7T+yyxVwwT1ragwFuqLDSa/h6j5wn7PSEzh8P57r94jdAUh1HUHyeFGlpzSuVVjqlXNnt08eEi/Vo2bOfu9r0ja2yFudJVB0OUHCGzG0mG2w/jyWUv7BSNOGNqTGoevVrmGaPkw7caIB2RH9yD0prhGIhOhYgc+41+5Bww6mdFyiFUFhlBuckYTSAGTnbwiTYDcTLlkxWMmRZzZtmZkkrnuQ8hQzmDST1cNc14abTXDrptc0wZsVL63Cg3YCBQg7H4T/TAhgloFYDq1YSEmW0NDlNAnLd4TJXQkoeRJ2rheq5ciba406n3OOKGttgt+49Xa88d5HZ/ZLd85hwWXGjSpyyGklw/sx7LrQPVqaDDSbpHAlEnDptTAVwa20TGjcfgqOlXRL9+GuWy/hvtGDEAnjbFA2Ct9h6DN5tuZpua2WjFSSo2OtbJBiIXvgba8UlKP7aUzBawDWplPsuhDFjYM5CyfecK4dC3Ze75GJmlt9T8FZuBAZ7vj6sxNvyK4TYF3PJogE9lwACGChITmKgdu8EMRhzV5uzbF63wRNThU3t3mHi9zNxHUqIZsSWQ7JaRtvl0Dk53YSFSBTz5uiogIG8Lz7kQ4GWA8Wyl67IxI7WNno3OF3XArsWJBcykevJgnW4MWK9S/M0LWzRKq+OY1KUO4Hm00fHsnxvYCuN5JDM39wgjEXuDjLjTX/oCowmcL+ZmsZk0g5USY2HgiZYLwcHW/M9gRc9kxnYHKj9fAdKn/hICEF8Cp578qOhjcrnSheiAE4OcG2L5iKeoM996v0XI/r8eS4f6NRYMSsZTPA+JKeCkqQENzvoTkYyHFHz0VaZucZff4pU4uJG9qXLkYyFgidpjfea8m9HE8iMz37kdjkXKdc82mDqmH/TKrQrnGg7Uu4aP8zNGVXBe4Rb6CpUfzMIMY+Zoa1xugK5ct2pgLprDbBkj67D3VeGLJKLCyai9F8fiQoT9wTZrqZYyYg9L6cTjpY2tJfVufSLaSXocCJ0djZSH7hkUFbZgsYl9bgeIn7F7VaZe3NWWP32BqnY2eJjO416yu2lNSINyf1qimSQ1cvd8J7m4mSKN+86KoIVKT7ckfoLSltyXsj1EVYMPa3kBHDiENPYJvU213SXPmaiSglgJukkqvkLtuPJWGZg9az06QfAUZu9xSzSo4b0OGnVN23Ok84WSbC8H5hAENxDJ/h81R1qYMIt2XjQtSIWHYbGsoOSfLByVEyUCHWIUdQWSZjjSIu8Dwo4DQd43nAGzlY/Gfy98QtGCvYmM6rf3SjPk0VKwi1nCCmZ5Dvqe4w27suIqqPYY9So+L9gBO2ywbjHpbRmTdGgZaEWjrCxsZYj60VLcqWFTmUxttvIwmbmPhCIctLOoy4TBDeZRH8CkMts3ikiA7r4iE6izWCjNxGW+pW7oQkLEqJa3Wc75IZgy5EVBZ8PZ+cUruDckTcGCTrcreXvQKEUruZ4Mzope/ozpHznAtR8sAXF/3hfDgPaMQ705uLBQjcpHmr8YKVDdbrhUK0KYOTAYEbZT3/AwE3yGI1I/OkesSJmVc3qma16ri0qM23e4+ZDJdLtSf/hFZ0bHfTdZqBmYE+4/pRuQZbzekoRK9UgR1E0Q2FAZpLAx2MiTKEZrjny54mF6MfbkHTnWZIsM5jycwxUQzG794WEG06Ds9026trozVwNnZohUrl53/6nBGzauR554CnRy2hYvVfev9GGkZc306pgnqWTj7EIMqq5hmRvbpW2VvWHW2RVhBnwQMA1JtP0LMnK+5IMcAc75iLfqxrDBRE80GslePOAoa8xCX3u0qx0ZaNEKRWmFMMDheFN5yNFj90TutgwUUiinCWFYw5/59+dX6NyFVdl+nOIVzOZyE6QNj9nhvQuJ1mvL9VWAGOTxBY2r3dNfgZYah3wuq7/Yic0EcEI70HHgAkgVGq0FVRAnxQlZ4K7cBCTf3af6FTIM4R6A1xTInGN6mpMeHl9e3JW6LFAQRhCPAzMlk4rXKqsMUE+/N0nJXFXCLSSBNDb/Eh55+dE+3/tPrQVVw+b4Qg15osffQ8p916A0YS2Y5WoenO9sOVDp2fJmC/ijOmIPGuWjCpo7hQROfrMs0Y+gI9xsBWcdNsKuRm5RsKsdzACqPlIOZx2p1SpzNT9XbXixTbSOr2sAqre3iCCFQ2r90jLzttaFoN5zt+/4ZWAQ5a8HJZajbT9FclCztBoQqK8JmxrTn33J/I1SpwefuAp5L74YJfdbX/A70+6fYXr+TudUv1YyusloAdwYoNrn705AbLq5TxaHAUTI4VMVv/lLldV5nR1u3jd0GaUyR+vTY54eB3rYkKF8MlrVWGQ8zqmlS6DLFXXyE8huKbE4MznQxKdt/ue176SCLOaFr/wDnDsU/r4B9AEGaSbpJBLmRBwTdKcX9Zl5zxs4STUvLdp2AI4u1zsECj2q6MB9qYmlD35CULn5XR2YigxTS4Cxxn0VR+t1sKj81mNEXAWxtZ5zEXz5UbjjjVbrgMVJ6ETFh9PHketlkAWOm+8/DdnzsyauY7hLUizRW0pqelXFToY4NybFQIDnz/2hb7Ys2TaUmucB1TFq2vEp5uHGtc5sn5/s9eDjQdU8jfPE/OR/pJNyF8wZsZLtcR5YgAnNhhkGYR7SnrZZuaKqFyTZ0zvPMwV1y/qoPPvDOqcnwZlxIv5CEWdFG0BsrDZlVI0yPl3rqs1rtsvs2xqlBOsANlmp1aDS08i3OUpfrDEFbRVLu0C+flWm7TnlXuBz5PJBStwV9u+K0Ne5H93HpUAytk4OTEUh6FCWl+KhIGAnALeoxxDKPP8kW6jh09zyLnN+50qddzzpvoaOxUkLpJgGHf5YoxGjI1B8yhF/eq9IqTA7JmHAKu2+EFQXGO7OfHWMyWAMQgGTUhG3afbO6tbkrhsNS75RGG8N7Z2/lv+fbiIKZ4gIY3tbAZAZrCDAVYLiTedLnKTrFpSvnMhQnKPuyy5g4cwDydm+QPZKKDnM0cYPJzlY/WeLq9xACcOSFAypET7DN68ntim1oXTrGR2Z/Bm25rMdQZvjszCF06Ua4UkKK5MUhbVfdGD8qjuBiJUbaS6mjrIIFwSJdBT/Y9VeeEf35RWOgM3bUpZKKCjy6dwPbiKSSKpAu4pi4Xp+CSkfOci0e93B7k0lHnmc6RLGCt0JgQM+u0lLqLbcIBnJgP4aELOo98Qkho9LLgOTLJh0l3nCllWP0LnqT8IVOADACtCMrrZnuIsnBnwQKs2yYQ9KnjeyKoOeVaSTzg3ayuqlhuarXbuiXLWzCDHg0CsCnNTh5UFX/bM55LdZz98+6B75bIy4OHJqoKqUok3n+Fzjs3kRR9/nDnsL0qf+lQIdHSUonazezXC34viNTzsKTojdqJspQ6jKUQAQwN2u9jd8gUGUKl653YVPuJ8OvW+izqvE46MaGRExF65RKpdd9tJBnpeRwrYIaInAWerSkWtgNcVu3o0OHHa7RKwOaOle577yiYTZvcuF9XXpK1vbsfRnzyPzF/f0Pk1Jv6Hv/sfEZ9pY2ZhdyBC1MVi5XEsFQ0iJzwQgSd/wHPy0D1PIGRqhhQio0WSVKVRI/WBi1H29OdyDrDTQgU8cm0Ui9jRiFFdgaubgOD1GoS9p0Pox1roj6hFWlV/yIbwl8yIfKoVYW+3QVvhsu4bTsjaU2VDp6gC21vMngcKZvtkuHZDRzrPXU+xD6Q2st0h4hLMwk3TMuVG5E3Bm7T+qz0yZxoOsBJh4pHz1zuG1Og+7ool0MWEo+Sx465P7iBznZaKrfsL+/zYKqhkhk6SjXvwZtJQ/d5GmA+XyuFY/uwXMmdkJcSkxZeRRACjH2xBk/vgy/NeRmLJUTIH5WzbHaI17nadMKBTB4J8DFqFUm+B1yK7RvL9rPA9tBcYvCtf+VoMkDzB1S9WyUzQzUfLXYmAR4ubj+1uaiLGUFq1VNacr7urXDIIGTMT5OdRLrbqjXU49ouX5Rpmwtte6DLy4fkylOBrnXTPuaLCWPqfT3r83uE2OIlYPhXhCyYIU5+EQktNk5wlynhjNGLUBvCgHRpE/9uAkHVaGPLUMO7VIOItPWL/qkPM39sQss6KoO028RKP/2ULwt5xkUmGAwxWrYdLRY+483M2u5CeBgq2y8Q03mMVhRk8Z1UkzbESZHuMu5+cdYudYESIXHQ02+C8LubCeWK20OUGHwKwxVjw21eReIv3qniwEXP+XJ8iK/Ro5sHlWYGzI1Hx8uoeH5evKdvzniA5iZWWUimk//Rqaetz5YT77J6ObAGMHSgGNsqetCd4T1H2k0lab859nOfymlBA/QBrdQNq3t90/JtUqi4iK+ysJd91jgQ1tr8JZfwjWhLSiXOi7KnPpfr2BIlq7iuO/P624hr5HKvvxvX7O7/Gyt1SWYdxf7ldrDEJY1oMEm4+HUWPvIWypz5zVfArd2EowcKj6rW18tx5dnENdCRhCCvG4Qef7lwR4xoZu5kcW9KAJTg3TfTtRytGZQBnpW36Uge7UQNLmA6WcB0soTrYDGrAoYEtPtzlZOZmRRr6qQUhXw+P5ywJK/Tn5TqJAmbyxsyBC2qzivREy65j4l1N/9no8+bIjUqyRdQ5c4SwYpqR2dVhK8QogYyHQum/Px7wc+r2HK02ufGO/vx/qHxtjRDRnI6ezWkG9eeb271WCsL+1WtF/MI9seKOJ9W2Ov99u7VLYsO/s/JmR8Mb2L4kzyH1e5d2snXZ3Tj64xdGhaVgAP0DE+X4a5dLN4VrXO4QpUKVSkZVJFC6X1P+gPcg+RRswSrgvnXTpu4e0qZZ2Whcf1CC+7FfvSzXK7to/PcOsxUtu45KJd4NHW547iDximthTGY9NdPH/+NuaceHzcnBpBcekJVTdgZiL10ke+RlT32Ksmc+kySC3byh8Lhv2V+MmIsXyAfJtiQR1q/ZKyS/kYAuOhRxVy6R111Mljq6HHxddLERqHr5606VvNGIUTkDD1qvgyWs46kp5BK1E/YgNRx6FXRNKjiNOqiUYKdWw6lWI/xdGzSNKrQs0sAeNXS5CTNcCikU//09+W+uLcnnTUFCdvLUKvYXsn8c15V5yUDFli3bXqap6XJhqfQ6GBIipBqnS47nypTCwKa9Z28a5f1B6b8+lhtQCWa82cmU92aVONhgW5MMfE8RDba6+frzeXGG5T7DjL96mYwmmNTw/WGyQQUszrPZbmQQ5iFOBrA3cB+dh5m74AVXYMb/8x5pRdJaNHzRRDm0RxPINOaoh9eArakVkadM7VzHGw4wMRoLIjic+zKIiKFJkF6uZc6fWZHq4sLFnazwj28g8vQZndVx8rfOk45XT4i5ZKGQ1Nwr7maOvjzAe5oz9ubtR4TAxu9jNc8ZObsAbMtT3pfXsrsyoDfiHfkbDMzUTmcl2eXnuLXgeUaRuEUwqNOz4fD9/5H/ZlIuPA+NWtr8Pems9xXsXlW/uU7+jDp7tvyMsv98JjNnuq8NNxvdVt8iHTq+T8d+9qJ0NlMfvFS6IjxX+X7wfButGHUVuIr+863HRV1UVgc0zVboatqhq22Dus0Gu1EFe5DW5VSm1wFajWsm5VDDtNKO+N9YELx+aOe/FCWZ9N/7kXDT6RLQeMDzICAppj8g05ktJU8SiQQqtUra5Ep7jUGeu9Bs+zJrLnm8+0yYMy+RVhwCBiXlS933Ril4MhzBm6Asq7f1EzqdEXxeXL9RQBEZbXQoIpZOllkWg3TEksnSFicZsOjhtxC+bIpIJvpaa+GN7E2tigcoKx52PSg8w4pptIA7xJbKBqnkuE5Ech4TjeECq8ijP33Bpes9BJXcYIPBjoIu5DlQdIXXhHR0VCr5WtoPr5D3mYEn/cdX9hq8lSDpnmiyqqeUqTfwHmJni9cZzwFZ81KpEL40t9Nz3pMpzhk55+f8oLQqIRXt6j195mbw9wqZnimdKKomMnCzw8dEdzDBwJhy30WS7FIljt0Htq+HotDwB0yQUr59PjJ/do14uJNAWPX6Wkn4+d5FnDJFCqWhHkWO/QqcxTStv4sZsABtqx0as6PTTbS0fDtamyuQFbkAta1F2FP8LlJDpyEnajHUKt4kKtf/OkZMka/ZYItRwZIzdHrqzB5p39f4Sh4SbztTDnreCDQ8YJuqL7A1mn16abPi5DyLByE/mDEbOlpzvNmpMc62sLsPsQglGHQustsJAh6AnDv7/HrHLiurFHYz2DbnYays/nhyCzgXHPe3O+Qm7o/wDYMkd97TfnC5EICq39kg63M8iDn2ENtBtmHJIM6IkzXD8KWTh4W9zufDpIXVIn8etd2HS8eZXA3+zqn3XyImP4W/fU1atvSNZ0U7mBXdYIHXCF8nWbXycO5qL6iUjhsFPQa0K+1wCqvc1865u6qbtbZZ5IHdNcNVmq5nGefinLFzPt96oEhU2Hi9xV2zHBXPf9nnp5f5y+vQuq9IFBI5Tqp6c510IpgckCk/WHvifI0VeWgJoN86XxJpCjYN5+aMKbNBzs191/4Zcdcsc40s2q1IvOMsWQmUPXByD/i+iQHL6OsmjWwAdwK6fC0Mu/XQ1LguTofeBl2DDWqbszN4O5x2FJSthVqlRZulESoGJ6hR2rwPDrsVIbpIJAVPglajl2rc1VIHQlfaUTOEAVwhwlD/nK1dySTZEYBTZq89ySx6gm3c1gPFXuVDJYt3OiU75yoKbyYls+dFlvyt87u10Xmzic64m+rSWAcPPV9JjnLzsWXLVTqyces+3yEZfk/oz4HBn8MDh+9x2vcvk89xbY9JE298aFQwTcmQw8kdlMXkjjm90H3JxA4WWP2R5EiOBDkDQ6WHr4AjCK7aBU9KkcSIiRZ/V36exKmGtfvl+qWMZtqDlwxrK99f+NIXYJLM+45jGjEBiQyFpbxW9rB5wHsjmHkD70muT7Xll0urtqdEzpsYFH8+kyPFl9yVrKbIKhnn5+7/xjT5Zp+PLZoGTmen/Grnz6Q/weQ0+dh71R8Qd/UyOVdKn/hQVu2oS6HIsA4U7BrwcnS026Tq5wy+4vmVyPjpNcPaRlfTsOTWM+W1ZEeARGQm2sLmdzqlu0oiG8cSnq/XSRvAVXVqaAt00JZooa1WA7bjzExtowoaMeM4jqLS9UhNXICi0g2IjpmIQ/kfIj10Jg41rENO+CJUmA/jcOMG5IQthIbkE60WKqhhOOhy4BpKT3FldYyCKq37iqXioZzpuPPmSsubrRdFpKHHxzl7dq/7hprQYK9m8t5Wt9gOZPbMdRbP6vxEAo1NyCIOXzypy7yV5CGON4YCR3/6ohgcuO+wyhyzwzHKFxjY+MFWNlmuQxlQOd8fLrA6PXjH35H1+5u66Mbzuh/351tdf++o/vmaHfnhc8JVkLUnjQqaYGOn0uBQg/cY7w2uJPoLBjF2Tpq2HRHOBFcKOQ/nc+bfOT6hwpg7UdIXGAD58ynUkvPonT7vSybe5c+v7OK2R88ASjW7759TNIlnDt0QG9bsg8NiFcGYnqSESWxt3V+MiU/d6/N72E5mksqNDz5Hvl7Udic5brDMT0jM5ViLokl8vv0dP/YXHDPwtbA3mmHMTkD1WxtEkY0dGI5IKDZDsrAhMbILl+HkDeB2wLA+CNpCPZwqpzDIHXwGWhVUrQ5o253QtNlhd9iwdsufpZKNCMtEVEQWkuJmobhsE+KicxGpS0BIoxrppmkw2xuRGDwetmYLzPYGmNTRgM3GslV2e913IYcSDBj8oM+1gpIXV0lbiKIfvdnnMQhJ68oLmBww+2vaekjkGv0BmaWKTOOJGryJ9uIaWf8aruyY7XFyDwYiQMHKnLNQzwq9N8gsmSTGYQh0/oDVNQM3K7WU717UxXrTFxgIKBPKGS9XtHhwM9Gt+N9Xrs6J3tXKVqpa+Z3JbxlAssNtDJKVKLLE+4ydKQY+ZcxFAlv4otweX1e2/dn9IVudFRnHJ/wg2HnL/9FzmPDvb/k1HmFyRYIcAyLHCvE3nNaNlEkOQdI3zu76D50Qgl358192ihkxIWioaUT+Q/8VS9LYixd2rqrx92EXhgx2dkQUci1HK+a8UnFNZOHgDVSHoxOgsagayfdegMqXVsGcXyHBjh2JvjgkekJUKxtbUfX2epmJx1y8UMYAnqS7IW+fW4OQ9I1zZM5PxTVaH/N3q/1wi3RWyJWJOnOmPFel63FSB3D9piBoCl3BROV0zawV2EM0UNttaG0ogdlcDYu1GcFBMWhoKsSErPNgs1uQEDtV2un1bWWobqqEThOMuvYSeZjMsLkI1oahvr0cEYYElyFFklramSMFzj1Z/ZJBrg42Qt/DRc8WY/RF871+TaXVCslD9sF9iE54gixpKkJVvrRaZBz7au4xFkBNeAbT4Wxt0QpxoCYMlMX0V6u9aethaZ2Gzs6Rv8t6E2F3CCGPzmwMLtJl0buuk+EAgwTn/yRy9jURYULpXqkz8FP8RJGrZYUqJK6OIGRvtQiJqzf7Wm9g1cxKimz82EsXSst2wpPfFqIXwfWwoj++iZBn0noNStw4YJuVLHFPxJzft11hvlciEFNSK2tq6o6fTYlW/s7BOclo3nrEtd7YAc7PyePw1OXmqE4Z17EbsPfK38uuN88fXq+c3+6//mFEXzhfODHsfsResaRT0pSVvbcEiWMeklOL/viGPC9rZT0Sbz5drsOoFS43tP5A7FAr6pF4+wrRjq/9bDvaC6ulm8GRjydXZSh5D20V9XINGNNjEXfl0i7PkZ/nplHag5cGAriqRQXt0Y6q2ANOh12yy4Ki1Sja/TH0ehOmTrgGdocFibEzOi+ujJTlUoUnhE6C0ZqCmrZCROgTsafuM9S1lyHKkIzCll3SVs+MnI/mpSPDbFTAi5xkKs4CW/YWIWSqSwyCNyjn2O5zQB683C33BrZ0Gg6VusYBfQAzSPPBUhT89jVY65okw+VK1YmC2o+3IeOX1w3rz5Td/wG2vulORcMVrgUyKSNxiKttPNTdd3cZxOq/3iuBh5UUKxeObJiMsTIt+cf7CF82WaoycgAYgEjg87SfHApQvpdrUv1dmfQG5bGYcHb7eduPoHHTQWkVa0ODfbqHcd2KgcclorIZQeOTRaWQGwe0i0z+9vnyOgePSxSmMWfbbJuyCyDqZR2BktW6Z6tYNBYGYXbP34VzcMW+krKp7kmp+WCJbEXYW9tkxYmJC3+nVhITT50m77Wv58F5OFnUxtQYOFqpta6TuTnb9UyMYm85Q7g2YfPHS+u99MlPpJNC7wVPKEkW2emcT6f/5GpZT2ObfiBg14GteKfNgehz56L2w81IvPUMFP/tXZk9DzVMbgpvfF3TvPBRhOfyl3fE9nSo5WXHRAWuKfbexj2y8RVUHd0Mgyka7c2ufbuE2OmIi54Elarrm+l0OoSopu9g9GvVBrTaijEubAH06iCE6CJQbymX2XjUxIlonTd4lRl3qoUMtHyq32xMHrRsUbFFFzojq/OmYxtWrDLV6s4MO2hcgnwfDw7P6oye1CL7qFb12SqU7HiRZ81KQMHvXpOZlr+km9EMVmscDwy3bSqrFq5nDQSxly0WeUy2Pan8xESP7yuJMiTBSZXtcEhnga1Fa12Ly151R77wK/j+8RpUlOPcV5q4Kyw+1E5IC3SoxidkuQ/nnJ2/o9PhMvDgIU/RDfdAz9eMhj9sPVe++rWQkRi0yIso+P3rQpwTtcCONjmTHLaQWVVTA5syuryelMfkPcPkiRWocr+TZ8FgE33+vD4xsmlDynU+pUXPZL38uS+FfMqKXrmGSZArefQ9jPvbnaj7bLvYilIDgt0CavVn/foGqEOMOPbrV0TrYPJrP/T6/vKMUoxTqEDYsHqvVJFKYsfxD8cKnONz3zz/x8/L9oSva4XkPs7kqfUulptBhgHt+JPwyfdp72W/FcU46lrQJ51dyMQ7PcYGgwyTH/KsPG+LHn4b2b+7adSTgIdnD5xklUrmCt0PWwbvoDBeWCpEJuUiN/dqREfm4HDh57DZuu7eWSzN0GtCoDK3S+t8fcXLqG0vRkboTKSFTkO0MQ2LEq7B+Mgl2LjxadSt2o1D9/5LiE4D2UVldk7WKCtYzur6tWPasaeptG54MNCblzvcbHvxpuOMzbWu0BUM6tImdkKqNZI+mJlTg9wfcE4m9qQatRxSJwKO/fIlOQCHG1Rk00V575T0BTxMWVnxACd4iLOlyp1tCq7wAGbQ5n6wvb5ZKn/OLtnN6QmswPlvOeMtf2HlkGhbs2JjsBluaAxaBE9MlvuJQaXkiQ+lUiLoglfx0iok3rZCvk7ynBJgGLiZTMs94JbwMahm/fEWGU+wbetuv8l7hhUoiWHs9DBg8R7kfjgDOxOt2k+396rSxY6A2I5+tatzZs5OSdQ5s2VLggGaYFVNXXISAYXFf95cFP7+ddfKVUwYnBSt6tAd4DybrG0mI1z1ovKaO3guKMYp7Lil/fByaZUrBFi2w4v/8g4cLW1yDXJ2zzPIF8jt4b3GlnLV6+vkGGcbvb/g+UcuRPI958kIjEZF7UUu8aWBPO5ggITMkn9+jPT/u3LUB+/hqcDJu9kXBNSyfX4cNUU70VpfjpSpZ6O2eDdmnP2A3Fy1m79CYd0OTBp3MarrDiAhZhos1hbodCFoaa2GxgI0W2txoH4NwnSxSAmZDK26a1BqSG7BxL9+V2ZVDIxsjXFexxu7P8ImlDBlq5JrQMoNp4AXNROElHsv7PKGM8Pl/I3Bn4QTkkZoOeg+o4y9gjMXJypfXi1ZdviSydJK5cHLmWAnyMWzWEVliTc6W2u0BKRyEw90Hgb+VKIjJZYwFOxRkgIHs33rLxhIY91mZX0BD3L+e1HTU6m8aq97goHKYUkUjWoGTtH79/B59gZ2XBiU6lbuFHEb95lzf0CpSzJyJXCrVDK/HEkwsWGwpt4/X1cymklQ4z3vqV3tudfdZW2qo33qrU3K4Mmgzt+ZQZsyx2w/s5Jm4hU8MbVzlu4JBlC2rskPoCEKfxarfb4nJKKSwCedlA7yGs+Jmvc2dW61iKbE+CQZtVCvXcioHdwLdvVIyqMsK9XM+Bow+VMqaFoa085UGQFwXHf4gadklZDg7jj9yvnc2Lngrj7b2lWvrsH4J+7xWomz5U8oWgaKtkJ/wZ/hTvht2uFKOGgQ1e21HKQVMlMv1TeLvCPffxaZv77eL0LmiR3AHYDmgAHaQwaorGqXtZ7yNacTh9Y+L3+NTpsBtUYnn9OYndCo9cgdfznKKrchWBeB4tIN0KgNsFiaYNSHISZyCtDSjuayWkyKWIZo4/HVDacGaDrHgLizz+ucU/JmIwGG82eqLPFPX0xRZqEMwjwESDpTWl5sRQqB5dSpSOpo8TCQcgWBwTPmogXy7zgfouwiby5m7tl/ulUyZH5w5kT7T3cozNOEG04ToQ2yzMMXTpIqzx3M/OkfbO0QyOCuLQ8wxdiEJBh/iFz8PXizk6Hu9S1jm17jUrUbzeBhRw/nkYD7od8XsOWbd9djknjFXLpQWuesfvxKvPRaub64cuNpPdnjvzPqEb1ilkhykok8EFMGa0WdJJiDJeYxGODrwt1kBliuh3Ge27KvUILDYIrWMJgqtp1so/Pnmo9VSnUtu+Ei0OJA+dOfCXGMSRpXPvne8ixg0GZwjr/hVDl7WvNKJLi6FxN8fyc+c5901qi0SLcuakrwnmcyxvvefR2U3QXqDvBPBubGzXnCeWFApiUmPRMU8LnFkyRY1ywKaCSxdQZgh9PFBL/rHPHDLvrzm8LM9ix0yBNQGXTQhBgkkRloAHc/czhKUhjo1KYfCpgyG6S690zU+HqR4Cg8ktZ2ZP3uxjFlE6wdMoGWjcFQl7iR1lQqOLROqG1AS62r9WsIiUZN4Q6ExWWjbP9XCLEEoa2tDnqtEcnxc1BVvgsmQyyiQjOEfS6PxQMvWI8zMr+N8qb9MOjDGKWlTK34cRDscWrfIiCnTUPZvz+R7MqdOKKANwrnMGxTMdNmYCZxhZl4UkfFIe2wVXtkBsuWFA8O3mQihZocLTcTAwxXZRgIecPx33NtpCewouSNUf7fL71KevJAYiuPBCgGb4JBgPM1rkHwIOsNbLsxEXEP4GxDUsyk/us9UuExQRnO2WZ/QOMHJiNjCZSA5ZyRFRYPDM4l+3JY8f0P8j92dwGvE87FWUWzxd5X3gDn9ZzDj6bg7Q6pVrMTkf37myVZZrLblwC+Iq3r/vGnhb7XmZSujyZYj6aNLi9xdkeYSPOaJCmKrxN3/Rno249VyFzbNHuc7H5n/+HmHrohTiGxcUGHbWvq65NdTm6EiES5VcbiiLi/SBIL2U5ot8mZxPMp7qqlXTQJ9l3zJyR/+wJZkSK6BF+1SuyLSZhkZ4nVOTkelB92v0545kx67rsofvRd7L/uz8j81fUD3gdn0XLom/+UUUb1W+tFDW0oUfnaGumgkpTH7gUJpExq5DW7YonPTs1JF8DVZVpoSry0a9UqaFutCA9KhtYQgvaWGsRmzkOIIQqJQZMQEu5aH2ClrlXpkBwzA6U1O9HaVoNgo0fFpdMiKiwbRU17kRiaCyQZfAZvBaqO1h/bYYe++yQyf3ZtlxUYCviTwMAsLWRahsy33Fc22BKreGGlzIN4EzgvWyTiA8ya2Q5TDg1D4vE1iL5UPUwceLhrwru3htmOp30pb1ZeeLLKolaJU1GMj4ra2+/veXZz/sQZWuoDl4xKiUtP8HcnES/RzdRhNIOHA7syFf9bhUnP3tdZbQ3nfI2BRMiUq/ag9MtdwnDui2875/VCpuK+9OLcYScO9gVMwLP/eEu/g7f753wFclbVNR9skcRIZuVuAi5M6lnlhkxOFZY5k2K+19TaZpBkEGHCwZUlz04XiVwciXEmzapUY9TL6y7bB+ccr6gJUbo7Vtkpu0pHQv7uLB54T7sj7trlPnULmncclaJAY4pB9RtrpQptzSuGJtTYTbuC1X7SHWdDGxaCoz95AekPXQm1ySgJSX+6dorzIjuJhKfn+mC3zcMX5woZULoOUSak3n+xJCajNTEdsQCuyTe4hFqYSnr+wFYHNq95GLZ2F6EiQZ8NU1AcgoKjYTVq4NCooGI7vdUGlRWIDR+PmqZ8GE2xLkEH7uGarSKXatCbkBY1G0V1O5BaOwvGfQ605fYSxCmZd8pUaYVVvPCV+GaTJKbAUtUo2S0zNPdWdtFf3hbimRAvOjJYenezok244dRBUyfyvPkU2Gqa5LmzdcyMXAK43SF/93Qw6wnufsTK4Twca0eDBY4moi/wrYc+msDriDaFDHgTnvzWSD+dznlu0Z/eRMKtZ3QxpOl1bJDrYi6zzUrW/IjoCviROJC8xyTcnwrcW/D2J5CzSmablfdeGxMhVsMHS2QGzyqunR24C+ZJIcDgrYiAiIcBO23mdtR+tKWTk8Igr0+MhL3FRdote/YLJN55Flr2FLpWyMZ3T1Z5BimypuwSsmjgZgDb6p7zW553nKN726/mTJvVOlvJDmoLxIVL0kCzJONV3bdV2E3kZgs5RQW/fVU+l3T3uT7PrZ5AVzJ30HiI6okDEYnxNe/mqIOjxowfXzVsngBjNoCrmtVeg7fri0C7xeWUk5NxLqJixsNpMsJi4IFA2VOXBq3DYIDNpIWjpB4qnc61/mF3QN3qIpEpj85VM7VaIzP3qBccqPieCvZIP+aKOq2Y2Tes3iNEN4I/lwzjhvX7ZXdU2cmtenuD7GuaZmZ3EknIKM3/4XNIe+jKfs1E+wLefEp7hxkzM//ONbUL5+PID55F3GWLu5BCfAUUXshjGe1F1aO+xd+8pwBVr62V65nBL+1HVwzazHCg4KiFH+waMQnsiwUqgxb3kFnJ+zOyGRL0IoXAjlnBb15F9iO3yX9zf5n64+6rmb0F7t4CORniBEVR6BcuGudT0jqtfVmFU/KU4zTq3rureInYjl4r4ikkjpG0qryW7C5FnTkDh+79N7Bssktv/WiF1wDezQ71q90ImZQCfWx3ki4DuvlYRRcd9eNPyHVWkpvB3XhlFk2tcl9gK58WpxxXsMPUtDmvy5qcv7BUN8p2T/I3z5M1Pr52Aw3eJh9EtcpX1iD+et+rcmMVQ3Oq6ElYoxlJ9ze00V4jAi1Bxmiogo1wdrSLaV7Ce9OpPa5d7tSqoU5KRPvBo5J9qztaLu6ParY2wKgNk89xT9T6+hHYLorxi4jAw9XBar4DnGVLVsyd3JpGmXcxqGvDgxFL7WZPNakp6UMevJWMP+aSRbI7yVm6uxKYrBx1sEt7Aw+ascKu9AX6BjP7Hyqd88GAaUq6fIxmcF5LcRi2VjVhId2kPH1BWu+q485vvuAeJHuaKfcFc+MLEZ5cg9D4HrYP0oDGJ+bi9bv/AYspUpyl6BLnaG2TRL2vwbsn8KzwZu5BQim5DtzB5uZJENc4PdvlKlU3ZTlF4W3Cv74pf9L4he1qBseeQBIaV8cohJLzD5fHtyc4HvMkx8rvEKSXhIyVOxMQBUzs2HHp6Rwll4ZjFao9Fv7+Nfmde+P6uIMtcwZtEsh4lg4kKTT1wDBnYsQuxYkWvIcsgNvTLNDWukRLWIiL3jlJCzUV2Pflw1gw735oI2NQXry5279lIHfwLKEEqkoFp17Vyd6mN7hnSlDTUoDkcFcAo5WoeWcxKks3I+Wb53UjYniDynD8JeDFygo3YtlkyUCdFhe7lW05bzcE9ykHG+IZ3NIuu78MttXvbZKfzwOA83Fe6AMBbxjR8x4lFWFfwfYXhToCGBjYSm/milJxteg+06RDG2Hq1ZCFCJs3QYIi2e0UWGEF5Q7PINlb0PQV4D3/nce6s+/nlxSCW985p+O/GuBYOgFvfutrrLjBv7k/W8l5nxWjvcmC6iONWHhnLoKjjPJ8/E1GSBhrO1IuH5Qt7Q9yX/qe3/v2HONR5pRiUYpGPfe/OfZjp4DvNaWVPeHNMZFzcEtpjWvXvBeQN0QbUhr88N/xT3/lddnSJunPbm6XROLgXY9h/GN3D/pMuvgv78hrcSJiaAJ4ugXqgwY4nBo4eM90BNF9T/0RKrUGmrh41JbsRlRc14tHqmj+aXeKHaj8O+699hBsNGod7E4rtCrXzTnOtAj5W//gcpKpbRI2uK+ZBzMzCWgWW6fQCTM1toUomkFWJ1uGvqqTwRKz4CHKFRj+vtTJpgWmGA4cKXetyVhtqH57PaLO8m/fuzc2NPfi3dW7xhL4Hjntw+RQcwKDBCKOhTia4foRQWlNkqB66tJwvmytaZLqiwpaVa9+Ld/PJLMvK27uGMyq2BvUVK2bFYsPfrgB5/2+ayfNHY3lrchfVSpLLRPOSkPB+gpkLUlEUIQB2/6XhxlXdg9oMpJSq7upkokZyLLJUvX2954V0qmfiTarfrbuuTHAwoMraxSCmfDUvdJeJ+nNn+fBAoLfz/1zEnk97XaZDBz+7n9kRs8zhEQ3Z0oM4q5eClujWVr+lI/21Gv3hqw/3Iz8HzyLiFOnynpr+o+v6pdMsamH6ptiOy17C/qtGtcbGCv4MRKaFMSQ0O9URw2wq7sGbwWRObOgtjtFVc0Y1L09w++Wf+EmnKYc12ypex7dcaZxqGxyqZxJ8IcaKaef5iKX3XyGHFTc7ybznKQTBZwHkbXJOTff5Ko31sqfrH55M7CFRGJIT61FtVv1TlCakaQlT6JYbzdM4cNvSRVDm0AKKaQr2WKH4hFXUujY40v/uS8H5KQXHkDJPz6QbHmsQhcRIu/faAoWfFzlYzSB1yLV/hRlLgWcNfLg4SxcQdjCiSIhynmkJ/i9rLgZvLkFQMScP1eCFw9IErOI0fb7K1hwRy5S5sRizT+6znbtVjt2v5WPHa8exr73jiEo0oDs5ckwhOpQcaAOxduqsP3lQ9j24iE0lrV2+/32Xf8wql5b4/VnUr6U3Q1/0ZdzwxuY8JNMx5Eb16OYVNFZS84OP7gOIkf7xU4RjMr8+bXdgjdR+p9PhZNT/eZ6CdRMGBjw4689RdTUOEunDru/xQQrb/JaUr9/mZAqPUcNfRFxcdodOPSdf4seB/+++8Jfoe7LXch9+QfoD+gCycfgde/5c4SnZbWjfuVuiRuVr66RkdSYr8DVx/RQHwyC3dj1jWg8tl/+DE0Yh6MHP0Jyhu+2ktPd5EQqcr5gDjjoPOUhDckKnF+T+Tln12oLUjLmwPTcdLmQaQfHOR9fdKqmcY5MsF1IcRVqDpPgwkqEO9h9USujs5E7cYlqa7GXL0bZM58h6Tb/lKosJTVy4SqzJqX1pMyD5HeqauhXW8n9sHEn4pDsVvzXdxC2aBLC5owbFIOG4QTVp7jip+zm9wZfLd3BmM32tIbkDYM1D/YXNR9ulmTNW8JGiVHqHXTxNJ89DiWPfYCku86R2SqvPx60XJ1it4pfJ3FLtBCazC5rzFlZXluxow1H15Rh2Xe7zlnN9RZseT4Pc2+aAHN9O1qq23B4ZQmW3jsVy74zrbOlfvjLEkSkdpfQ5flCUScmOEySPAmWXRQVPcCKmatmvOcZYGlOk/3wbV7n6p7gecM1sqizZnaOw9gB4boizyBua/D96QtXRLoFapekr9ev2x1CvBPxqgvmCXmW3cvcFx6QVbeW3QWyy+2vLSgDPxnv/N3p2NgbWa+36rvtaIV85P/wWejiI0R8hvvq/vI73MHgfOhb/5K/s5Nb/twXsq3Ddj/PY5719BCnnwWFcRjkyeAf2wFc1NeMsAuhnALox4N4xaZPkHHB7YhImoS2+s0wGHuXNN2/6XnUVeyHyZSIirIdmJJzGVRBRmjM1o5q24VWawMcDhuqWo9gR9GbWLD8h0IIYVCkTCkvYgZAdxUevinc4XaXIU248bTjdo29gDetcmGICcFj7yPnL3e4bPfK/d9nZMXPi80XRCO7j8pAPQUQfs1+bxT+OnelsOqP/Og5pH73YhGxGSugGAn38XuCP5VgfwP5QKrMoSB39QQmppxT8nolXE5Wx6sxziDZnSIxkgIerKbTvneZ3C8MSocffEpWJzlLVeBO6HQ31xmt1bcCtsA/++UWXPLoEuhDXIQmU2wQrv3v6TCYXP+9+dkDWHSPa6RQvqcWBz4tlBa8zXK8Jeg+C1fm/xxLFfz6FdGZ4NjOH7BYIIObIz6eA5Oev18UIP0B+TBUfrM3tkAXFyEmLOxKMcmiRSdb5uSKcMe6NxJc5/Mx6KSwEd5PepyXb1DJ78l1RM74075/GQp+/5pcK3uv+L18i6JY5w/G//Ob2Hf1H0UEh7adQVmJSP3uRegrnE4nSp/4SLQywhZNRMuuYyKYo4009Xt8wQKnCzdq11FJiHg/cXzEJFfxZCf4GtMznYp3w9lOH5QArty4NUfDscsSAaeB5LXjHHSH3QZzRSGC41Jh1zqF1OYegD3BinrNew8hOnEKlpzzW9isZmgaLSgsXIWczHNgIzu9zQbYKLQOGIyhcAYbEa+fhHHty1BSswMRmCutQK5reEPT1iNeNcT9fcNtjS3Ssjr265dhq2+VIMgbkh+K4pE/qHztazkwBwv+HKIanQZZyxJxyTdM+GDB9aKFnDICxiADgaIh7Yn+BJHeAvlQtt2HOphTr7t1X6G0uNkeZcuSrF93HXaOkfZc9lupJoVnoZBGuaZ4zhyXmY+pu7CHfM8oFnXxRMaiBOhDtHjp5i+x6K7JyDndtUGiBO+qvHpEpIWi9mgTGktbULK9GglTojDxnDRo9T1XcSSXjn/8buTd84RU4f5sezBgjn/8nn79LkyiOMIg14dVJw2OKOjCKpAVdM27m4Rcpo/3/TxYNZc/+4WMTnhdmPNKpO7i/zGAs1vJNrqS8PG95qybwYta6vydHS3tOParV+TrGT+/tk9bLpxLx994Gir++yXG/+ubXQSw+oLiv70r7mwkH1PdcKAaBUwI2G0IX5qLll0FUpwxYNE+l4ptROr3Lu3yb1gwJtxypoyr0h64BGMmgPMQcthVOLw+DcV7E+DUqkST3H1YXX9wW2cgbys5gqCsTKCle5WuwKnXIDJxEibOvQGwOaHTBgGRQbAd61j5IvHMdPxNamtsAziPtlmQHb8UVctU4HdSIUkhmpGUwRl4xClTpOVE+046e/lSKOoNVPCZ8J975XdwX+si+tK24sxqoP7S/QoyHT/zjKyj+NhaOaCfOdxtYYJVC/2N3VuWAw20I1lB+vuze3qt3btHSmAlOYi2lO5tRJIi2SlS1NjYNqUxiMy03cBAztWgwj+9IS1OxQfAE+4a3aMdSdNjcOOrK7Dpqf14/e5VuOzxZfJa8bXb9MwBTDonDWW7a1Bf1IyINBMmrEj1Gry9MdL1ydGienbwzn9gyjs/HvLkhoGK4yQWElT74/vIn0m7TtH4PlIOW12LT5EpjhSpKaGNDBF9dhJ2uZetPG8aizA54D67UlVy1s3CKO+ux2XdLf2nV6Pgly/L1/pDYmS3ggGcRF46DE54wrVC5w9CMuqR/38viPY8k4fBqnz5+5OHRDY/jaq4TkedDXf5Zm/vLZOIhlV7gGEM4OrBOHT2r8xC8Z4E2Rlj8CaDXPn1qneuRvEXL2PSLT+DPjQSlsYaqBNiYA32MvNmVqhToa4+H6Exma7H4m6YEygv2QK11vt8Wq3Wwua0wtlBgFB1bHdxjYwewUTLnmOIWJorusBk2zIzZdY6EPBQ9AzefQUzXTI7+4v+EKfaGi3QBbkOJUOoXm729P2f+0XE8vY9IxH44q5eJvyFhg0HRuw5jAS8/Z48YPLueRx5dz8uOtU0zqCph6x5zRnXbQbI0QmJVwofhMQf0/QMnz8z9f5LYPQgNJF9zcDN7Qm2P5XnZbc6sOovx4lxoxE8fOffnov5t03C0xd+hIOfFsnnzvvdAsSMC0dkeijicyMx54YJ0AX5f3/zMVgZc12rL8GbpDD6vLPYIJl237V/cjnP+QHRo8hNFeKtrAM6HPKzqUPAdjYfk2Qzz40ZbtjYm9pkHMUWMbswR3/2ovgqKLajrGyZJFB9zx3pP7pSVChJ8Aqbk4Mpb/2fjFn6A+X8LPjVK7CU1ErA9BsOp/zu6T+4bNDb1iRzFv7pTRm1UjLWH+8F6lNQ4XNMsdCbqoNRcZittQ7xFZeviOx/t1YWo3T12/J5nSlcSGm2Nl4cKmjMdmha7MK8dOhUsBlUsAWr4dCrER6aBmt1BYJqrDA02dFWWYwgmxETMs6RynHngZdw6NgnYjNK6HUmOOxWF0tdrYKto9Mn6mUqlcx0uLtav3ovxpEkMj5ZZk/8GttBI8nIpgQhA1F/0N+gtfWFPMy+7njlevFfl6BgQzne+e7aATNhhwusDtN+eIVoUqtf+B9OZvAAzvn7XaLH7/JY1ss1zRGRN/4EDzvyPXjokwzIKovmKj0KAMWGyTYHPQSoTHjgjr+LfzXbr+6t9Q9/tAHTLvVfzGMkkTonDje/eTYq9td12SHPXpaEqRdn9ev+42tP4hqVGhmUewOTZ+7Uc3564LZHUf7cl8j42bXymnPNVfE77+0xmAR4Ww0l74f8BfIc3MFK25xfJj+Dmy57Lvq1EMoKfvUy9t/wiHxPzuN3i7sabU3dwefGlje9GfL/73n5795UIHtC6gMXSyudqH57g188JJLXHG0WaXWTYDnYIJGQnvLpP7gcB297VGRqe0J7aY3YTZNNP5wYcAu9PC8GKhVZ4h25gLz2Tjg1KpR+/RZSz7oBhvAYOKwWNBzd62KMawGNxQk1RUuCNcd3vnkDWBxoOrof6SkuZxprewuqqvYhK831BhPxMVOxJ+8VIbfFpM1ETPoslBVtRGrMHNiyHHCEdTwWDU9WzBQnJraamKEKM/2MGaLKxA8aDBx54ClZ3xoJ0BuYN0HsZb3vTSoYjGpTre2au6342dwuhCRfUNqGw03GckfFS6uk5Zb8zfNlJrXzx88jKj0Us9ySkpMNPERZKfA9rPzfKukysTrqCQz4DOa62LBemcOKwpZCUiILmVUdK0BrRb1cA7wmWmrapIIdK9Do1J1s8/5AaaXztSBBkPKi5GeQZ8B1OwY52gX7Au83pXplMDqudeBA3jefkJUs2RLRqJH0jbO7CDCRoMbWd9C4JGlfkznNIKyAapLcFqD0K0cpdCyjj7loXnCefdVS6VBy/s0qmp9nZU6uBKt2bsKofPB5OK/mnjiLooGOUOhFUfSwq9Cja5pnoPa1Stay32Xf3N/1Wn8ganRJUT7Nh/g+MbFt3HAA2X+6Zdg5If0O4KpKLXbunIDaknA4VCrYqUDqNvsuXfkmWkuPykfGpXeh5uBmRE6eK1W4pt0pc25nu10CfSfIJtz1OZqbSjEt9xqxFl2/5a9YOveHXQhvCbFT5YM/ymFzos5cgqDQeNhDDbDQkcxpkS4AxfbJCo29fIkcaGz7Bed0XVVg1jSQ7HGgYOYW5EXpbSiDd0NxM0Jiul/0fbn4hjNos51V+q+PZe9eHWSQUQgPl8I/vI7scSrcv+0KfPmH7Vj1yE4sv3+ENLqHCb297nwPoy+Yh+YOo4newBUmhWFOnghbqgxGvbUkFeEjQqmYvnpkB2Zff/IlUbwnn/t5oVSPfO1JpCIrmTNoGsfEX3eqXzrh7quiUuX+4y4J3G355ZK07r3sdwielCpFSfiyKZIgMHhTrpUOhtS+4LybFSnf18aNeaIDz3/Lc5CrZTXvb+60UmbgZBB3B993rkXtueQ3YoM6+bUfdgZn2S+vb0HEadOFP8GkjitV7DT05QzzhKIuSVa7P61qZXXMWtUIazV9NYYuaJL7QVtpjhP4u2f99kbX54+WC4eKr2n6T66WonAk0K8Ars4zQnMgCLUqJ2x6tr67fr3kg5fQsM+1/K4Lj4I+Kla00dU0JYEO+konbAYN9E12mWNwPYGB/dCGFxETlI4pE6+QQ2HXvpeweM73oNN2DTYH8z9EdEQ2YqImYOPGv2Li9CvR1FKB8Mh0GA7rYE13wDLRJhfowdv/jtyXv+9TL5yHF637+CaNBMgWJUmkJwz2fLepwizrM6MdIsCzcrdUEjl/u7Mbu/QbzxzfMDj9R7Ow6818ISYVb63CjKvHITorDE6bE6EJwTIayFrW+37tiQAewjxcWE35OxtkFVX5ymppuQeNT5aWOYNBT7oI9Ke3NZs7D2+uXZ1y/8gcZEOJo2vLUHmwHjOvHgd9sPdK89ofJEH7syvwWZFrH15v1Ltmy28+5PNxSSQ8ePujQiTjTr4nlOudhM2MH18tfy9/YaWsi+297LdiO6qwvl2eDSFSBHEfnVUpV0PZCuY+P8myaoMe0ee57hm2hBl4xYDFQ2OCSeDkV3+IvZf/Thwb6T6mgIk0V8m4a64oXJIJPxhbLIV/fAPjM+O7acR7q8JZ+ZY+8aH8XR0yNCprhBIXOOrka8YziaBmCNeGFWObkUKfA7iqRiPBm6D1Z2fwVgHWxjpUrftMgnf2TQ9C5QCMsUloKToMfUQ0VHbAWOeE1nI8adK2OdDibMS2D3+D3Hk3I9Hoavvt3v8yEuNmQq87rqm7Y/8LiArPQpAxUv4+M/dGTM65DJs3PIbFp/8S5aXbkJg6D8YdWgngzDo5i+pJRo9fox8us0vFfWy4wEqH83kelMNJwqJoxSu3rcSV/zllVK8BsV3bl71Szl758do3ViH33HQJKPpQHeoKm7Dyjzsw+cIMnP3LeX2qcscqOY4rTVSI8kfSkmCVxVVIMnpZVXCmqgkP6WbWw/Yq92F53QRlJyCqo3riqllL6NjREvAGJnneKmUmuxSByf+6DBPP8r61opDd+rKZQXGQ+OtOEbMTd7AV7kt8RBGGoYWw+8oW3w86mREUVOFuNXf8CSZh4Usnd/nd2BZu3pkv64XehJxILmOQ5kiA1rN8fAo/sdjQhAWLnKpSeLADMFBwhEkSJjsEHBX0Vn0X/flN+XPKmw8N2xnGjSVla6kv59KoIbGp69XQ7gyCivvXTidsSmFMp882Mw7981eo37VBPmWIT4I+IQm6JgeCrMHQV5gRUuaElnoSXL2yuuY92hYbDm18AVFJUxCZ6AqgLa1ViI+ditSkrlXxuLQzkXf0Q+Qd/UB69TX1hxFmSkJa5imordonbHRun2trNICNO9ZrhMhG846ewOyW7Sa2oIYTKzIOwWhrxumJLpW64QIr0VnX5mDDk/swVtFTYDWG62GKC8K0y7PlwJ117Xg8sONK+drax/eg+rBvGVbPg5f/7f4xVBAy0+EG2Cy+9fX78vOpRaDto8Ie7xXus3Kfli1gb057tIBk4CBBzt1Yp+RfHyN5qLUEOqwRhgofPrTR6+djx0fgtB/Mkmupta4du9/O70b2tLbZ8NwVn+DhGa/Kh/WJ5+QaZWJDgw9v4Lii9J8fCaFMmX+XPfu5BHZfIDO65qOtPe53c+5OTgOLl8rX10pF3rip6/3C95krYT2pMJLoyPVC7orvufx30i2lBXPjuv3I+MW1nZK7g+GvzaqbBRer+d7A7QrKYCfcfPrI+NKPIvQpgAd9bIKhRAN9C6BrInuce9xsZ9hw8NH/k+9JufhmTHrgTx3/gqItKhjatUCr5fikQqWCrtV1wba1VEOvCsKEhTcJG13cy5wONDVxP7rD4IS6sw4btNqulXRh6Vps2PEY6uuOISpmAjSa4+2+tsIKIfNwBaLyld7dq1Lvv1ie7+HvPS0yhUMF9zUsZsRUhXr6oo9QW+DySB8uUMSiYp//inFjCYvvmYz1/+qenLD6TpwaLRU65TH7g6EI4nS9Wvf4HpHwfPnmL/1WA3SHSJ5uzpMKmU56/NPR3r/1RMULwBO8L4xZ8ah+c1339UmuLw1wpXKkYW7ofRslKFyPok2V+Prvu1G0+bh+wrsPrIPV7CoUzvzpHJz6PVc1vCQxX/atSTjzBKs4ehNQ9Yu79vL42Ymyp+8NRX95R8hoTLD80a+gIhnJhramVoTNdXET2PFjC5wJSNVb61H9/mbxWuDnuLnAa6hhvWs1k+C/Z3uf3ckjP3gGar0OOY/djep3NwlLO+uPt/jlPOYP2CUwzR7nlVXOyrtTNrXj/oi9dBFOdvSfxCZSairUbl+H8s9ehyYoRJzGQnOmdmlpcPZtCI5CU00hEM1dUxW0TRao26mipoJapUVs5AQYaq2wmjSwBWsQ6oxHTcfcmz/mi3U/kb+nJLjIF6ct/AWaWsuxeecTaGmtgNYSjIrS7UhMne/qDMQ65KCR52nQ+Z2lkQlO4f+C37w66H7OvirGyLRQ3PzmWXj7O2sx+YJ05J7vex93sMH1sbGI3traR78uQ8Zi7+3crKWJcgh3c8XpA7wx8f0FD3mtUSO7+EHhroSUoiHjTk1GzdEmXP+/M3v8md5APQMS0GgpSd6HMp7xZwWpL6BuPyvzpnUHhNTDKp+EJ1ZitoZWsaz8VOVio/f1dxgNowpyJd64ZzUSp0Zh4V2TvbZmmXSf8uAMHP6qFA6HEztfPwKNVi1t9nm3TJTVNHdQP/3OT87H7reOohndybLkKIivdocmBV0I+eGJlgPFqF+5C+P+dodfxiSEPjFKWOhU2FPm3JRgZVVEMhw/R/EemSf/62Oo1u0XCVZ6PLASdp/vUuKUs/eK/30lxDrTtAwxNhlMBUfxQ7fZsf/GRzD51R/45F9QXZNjHqcfWzMnOvoVwFkl2w2AyuaU4C2fcziQffsPXS8oeWk2roQBaqcKLcEWqa75eRX/j7GbrUKDFkeOfYbkxHnQ2BxQNzhFyMXG75XyWwWn2nXSzpt+DzbtfBy5OZdKUrDv0JuICMuA3WFBZFQOtFojGuqOITI6G+2TXBksd1RTH7wE9V/t8ft340Wd8VMXYWQw4M/BpDNqcfk/l4moRKYEmKEjZZzoYGWx970C3PCK90DYUNKMNiaQHmt0/YGyOtUbWqrNUl2rda71nV1v5EuyNv2KcWitbcPqv+3GvFsnQqvv23Nq3nVMdoi560snO3cwadUMYnuRgi0MCARlWLm+VPf5DmErU3KSKm0U1ehv18Kf72mpCILOEY7zE7q7pQ0GzvqZK2Ad+KQQXz+62+d6WdmeWtgtdqTPj0fqnFjY2uziauYZvBWExgeLdCvgfT5ONUFPExRPHH3oOaR89yKvDmG+wCALfriBu9PqYINrVc3hdM39NWok33Nu19/xqU/RsOEgMn9xXefsnBKtihoft3c4AqDuOjdC/E0qekPaj64QfXQSxty9K9xBgia/rjrJg3e/AjjDqY1jExWgNR//fOqlt6Lk3f8i/pRLYDIlQNXR5uCamDo0SP5Ns6EFJosJ9jAdrCrAWGVGeeUOTMq8SAK6w6CByuGSAywuW4/Eicthaa1HqCkJpjAX0aOm7hBiYnKl8tbrQxEXOxU2S6vsi1utrbBZmqCZktOZNVa9ukbaTaxQQmcOn8BEXysK/s5XPXUq3vr2Giz51hQUbqpEU3kr0ubFo3BThQR2miqYYo2ImxgJreHknP34el3ZEmeVs/vNfJz2g5k+b24KdSja14MBf6rxQ1+UYNrlWfL+Ea217fK+Mniv+ftuLP/uNLGqjB7nv5sRAzf9uDN+MnjJZk8ImZoOS1ld584vxZBIvoo6Z063FSIlsekpKLNNyrZy3Ve7kPmza2UXmYHEH2e8oSYZctbtSVZTeBMksvEUnHfLJOEr7HrtCAxheky52Ltc6WBIEJPUFn3B/EEhTnEFrLMazytxkdi8BF9eVzQoYSfH22iE7zlZ9BxRUn1ssAK4Qjg+9ouXkPOPb8CYFiczfBqTULdAvvbrV0bE+euECOCOzrOPc2xAb4qCpbkWBS89Jp81OI2d7fVOUA2tvhIR42bAagb0LSrYwvRw1LZhXMIpUNntsEYaoLa7DFAo9mK1tMARooPOEI1ZM+6UVbOI8AxUVO/G5MlXY0rutSgp24yw0GQ0NZciMjILIZHJaNaWo3rbIRGxYA7B+TfXYlLvO27eMNTo76FC4lX28iS8ducqXPjIIsy4ahyOrCrF4m+6Anpbgxn73j8Gq9kuh//0y7Ple05WMGh/+fvtEvzYTptyUaZoWwdF+O5gOGwOeZ0HG74C+aEvipE4PbozeBN8ruV7a6WNfuZP5kiFs+/9AjGY6emx3YM3zXhoVjFcoF0onafKn/kcOU/cLV4AwkT3sf/bU3Ciz3LDmv0i2cmATVMN6ocrmPCfb/vtwDeQcUZfEJ4cgo9/ukmkVpNmxCDv82LprCTPikX8pEi/r9c3v/U1Ft09BUnTorsFcq79MRB6rnU1bz8CfaL/JiE9QdG/5zUYPCHFZ5uaSVr2n28VyV261LHV775OpjxW6hDofk999yei4SF2nnwtOvgq/DyvHUdLG+KuHJvjv5EP4PwXbIW7JMrhsLnmbFMv/iFqqg5AH+r9xqMam0qjgTXYCV2LUyr0toQQaJGGw+atSE5YAkOrK4CrVGoEmeLQ1lyLIGMENBpX1jBrxh1otzShuuYAGhoKYLE0ITg4FvHxM1BcvgkhEUlwLg1F+/5dwJwcucBoKkCT+eGweBuMQ4T6zDOuzMYb3/xabA4ZpAkGJ2LOjRM6D4Mt/83D0xd+iMv/tRxhiYNDJBkJUP+5eVeBVHfsmogErhvIpi3+23uSnb8V4iK42NtdbG3OKpNn+O/+9r8bvsBFjyweMoKae0ChKQYRP7Hr4Tv1kiy8ftcq6bhQuSzv0yIERRk6gzzfWwoU8ZA98lUpStcViGc8VbQaNx4U1jJZwMMJPhdWbxTOoG0m9dH98a3u9jg2u4y0NCEG8RynBzUPa2LCU/fiyPefcWk3vPS9PlV1Qx3IuSZ2wZ8WwdZul7XEuIkRfR51OR1AwfoKGZmd+ZPZKN1ZI9wHPudtLx3C6scPYNJz3+36b5xOUQOLOb/39cc+PRerHeXPfymuYkpQ9wS7LPxgYsGNnuEEZZLJnA+ZnC76/sSx37yC5h1H5e/+WqSONfzhD3/AfffdN9Qktg7TEACZi67EoS+fwu63f49xl9zr0yaUQVlA0RYtZy9Ae6wWQUkzoG1twpa3/4wplz8EY6MThno7chfdhvw978EYEoVxCctRWbEHtbWHUFG5A+NzLkRwSCwiIjLkc06nHaawZFRV7kZjWUuXrJJVghK8uRfL4ODLnWcgGMyDgwYjvSk38bAnaYbrYH+b/wYu+utijDulq8rcWABnWa0HipH5i2vloMj/wbPicESpRgbuokfehvlgieyc3vbXSQMPQqkmmOKHXsTmrQ+NcNoT5VrL6Zh9KgiONODGV1aI8Qdb/lQv4/vN4NBY3iptWXN9u/z3GT+ejYJJU0Xli63DBO4N+5B1HArQzIErO6yWjRnxsn+c8p0bpEIrevgtpHB33A+VMaUVXPzIW+LWR+Ib700SwXhY77vqDzJjnfTMfcJ2L/rL29I+jb/hVNgbWkVpjNUYhX3UwXqX1enZs/vNS+gvOLqKzfGvO+BNtvWsX8yVoL333WPI/7pU/k6s/cduLLxlIuZnHe6aTJJP1IOYTn/BLYKUb58P2H2vLSrg+cn3xpf4ColxFJUZTPCaYteHoBocf07TxrzOr/ek7TGW8cMf/hAajQZ33nnn4AdwhbjrfruGJ7sO1Yis6QhOzujC7jXXlKKl5AiMMcnQGI4fmg41YA3tkGF02GFtbURExhQUb3kXKYsugd2ohq4lFBPmX4d1b3wPKqsdlqY6TJ50BXInXt4536yu4SqWFuUVO5CQvhDVpmOIXbLM5zoLhScG+2bwPCx2vX4EE89N86nY5A+4U1q6o9rvA+X+7Vfg32e/P+YCOAN26b8/FpU15aAY99c7kP9//xWJSPpYZz98u4hakAELDIy8xOuGVdRggQpxZPB6a/cy8Zj49Hd6DCq738qX2TgPq5V/3I7qI40wmLSYd+skIVIpqmaqBpVo+WvDg4c1eBNscTNYU+ebN3fKfReJYxRVvtjWbSuo6JVYJSIv+wpha2lHcG6aaFgzIFhrmnDglr/KiCvjZ9d0fj83QPghK3Gfbpd5J2fmDN4kW5U8/iHaiqqEpMVWPkFxGVtNoyQZQx3EBwKlk8akjcUGUV/cDEuLDeM6/MkJ5fkzkfuQ7OwhgC42QnbKFY9rb6BXRMWLq2ThmNaf7qARCtnghMzKh2gnm9df0h1noTI8RIRvbPXNOFHxxBNP4Iwzuqvy+YLK6cfSaWNjI8LDwzH7sl9DHdK1emmtK8Pe91wtjmn3PiJqawoOv/UPRIybCZVajejJC9FaVQytIQRBmgg4dUD+p8+goXCf9JY0hmBMuPR+GEKjXIbydQ4RZSHammtQeWANzI0VCA1NgdEQTpotWlrKkZV1JpxGLZrOa4Mtc3idtLwdEhuf2o/gaINfbka+8OjCN3Ht86fLvM1f7Hn7qLThzvrZHMTnutjCA8FQa51zH/Xwg09LxeVpRsBLkraGtMJ0J6MN9aHs/jvzObTuL4bTbpfRj72pVbgcbOsycJnzSoWAFX3OHGFo0zebbT3OLzkKIAEo87c3dllHdH/+u944gvQFCTJb5f4xV9+4QuipBjYSXuve4O4f7v4aibb2Bb7bu0zQWMGHLZwg3ZZxf75NxEvogMWgnHDLGYi9ZKFfz4GCTNSmbtxwENCqXVKlCybCYbGi/qvdYsFJgxvl9RuJIM73j+9t7VG22SMRlRmK2AkRXj3FFZDPsv3lwzIe8yRYWlqteOddTade/WCCEtJptOKkBGsvKHvqs05FNgVkoDduPgRddKgk3J5+8gH0jl0X/LLHmNvQ0ICwMNdqqDf0aW/FOrFdVrjcYQjpOt9zdnxUbl+JltJ81OxbD3u7GebqElTv+hoVaz+Q4M3DMOusW+VDHxYDe3urK3h3wK5Xoam6AI3VR1Gw50MkTz8LE5fejrSJZyImaTostibEZs+HJcaApvNtfgVv6tjSw7Y3ZTZ/4O1wqDpUL6zirKX919xuqmhFZEZon4I3QRYsZ6rvPrgeb31nTb/EQIYT3BvOffFBr05CIts4N2dYg7c7GIBpU2pvbRPVMbp1sUrk6hRFK0gg4ygo/upl0iIf98jtYuqQ/6PnxDSHhx1NImx13iuFQ18WCwudwZtgO7W1vh2bnz0gO+GjEd7mpI42qxDqWH2x7c0WefX7mzp1tvk6Rp45ExOfuU+csCiWxGqKUpwMdJPfeMjv4E3QiSskN01a8EzuWcnXfLINJU98BEN6HOo+2yGezCOV/HAksumZA/InAzd3/klCpcIbZX19ITjKiMX3TPG6HdFc1YYcdf6gP1dWz7y2/QnefK/4PpM85o6y/3yKiMW5YkBS9u+PpaMWwPCiTy10e6oVqqKu8y6N3ojghAxETprt6q1rgLbqCjQc2YXJd/wWDYd3Qh8Zi5Kv30Z42mQYtCYUrnwJ6cuvQVXeBlTvXw+tIQiT73R50Crg+lnJoa+gUemg1uih0RklMbDq1Khu2Is6cxGipiyHeboZ9gS7Xxdh8V/egUqrhq2mqYuOcF/hK5iwCnYnWPUHZFUvuru7kIM/4AFwx4fnyfN45qKPcMs754zaXUnZUR2FYOLDVi0dnzzVxhQdak+zBX4fW7emmdnS5u6pWiLznHvDnMUre+kcl/AQ56EfHDWGZntMElUqOdw1ocFoXH9APsIWTJAOCvWtFZY6g27dFzuk3U5lL2/mHf6CXQ7KfLI1X/XuRjRvPSwfBHecmagrK1fD0U6nItuOVw+LrzjHWLOundKpje5rE8JucwiZrTfQJvfjn2zCJMf7yDdOEtvQwYBYKD9+t1/fy31/gtU2E25aIHO8QTB4U3c97trlKPzda8j63U2D8vxOdDipLmq2YOXKldBqtairq8OFF/Z9U6pPFbgz2AmHwdFNxCpx/nloqy5Dc9EhmXs35O9C9mXfkuCu1huQ/+Y/oHaqhWhmjIgXTV0Kveh0IVBrdJhwcXfWnbmmBI1VR6AJCYE+LBrlRVtg1wFtk9uhuyURLc4ymE9r9Ct4E2yrpX7/UsRdvQwFv3eJzww2pl3murl2dwTy/qBoSyUyfaiI9aUa5xz1yXM/6JR37AtGS9t2OKtv5XdmFWeamdVdKrQXRCyfIkmJMT3O5+/AyoxrgBPOOi54wr1izuW550/NdhIYPZ/TaAV3t7N+db0oGDLhYSudzPLYK5a4xh+K3ajdgSM/eFbsJ9kBY+t2MMAknBUgQQ9uGHQiNVr93iaxoB0uhCYGixLb4m9OleS7p+BNfPLzzVj5h+1yPfhrPjTjynGYpDsySM8YwjngHr4/an18bye//iMhkhb86hUU/v51mXdHnDZNAjr/Tmc6dl48NeID6I6Sxz+QZKfgVy/jrrvugk6nQ1kZ9QUwtAFct8oEp002tbsE8fDYLEROmoP8N59Ac2EeYmctkxvKqXEiKtlVTU5ccRfCE8ehNn8bEqeeJsW6rble2Ol0LavJ24yWimOdjxlsSkB0ynQkLzgbCaedgkbtMRwxv4F6/QFoEo3QhBo7CRT+ImLJZGGh96Vt5y8o6kDW8JRLMrH1heNsyb6CFbT7zvBAgviVT56Ct+5d06ebarQHjaGEtboR2ihTtzW2gYLOXmyTb/tfnrwv7u9vfWEzNj17QDTax9r7wO6OeyeLf6eiWHtxtahoHX7gKdSv3S9mGKELxuPIQ8+Jw1nyt84btOdAkSYKfnAtCu1WNG0+hLbDZSI7OlyISDHh1O/PxKRz0qAP0XmttpSRFu9F7vyPPyMFf537OvJXl/rlW8AChJKtpyUMjgERE01yNiih6g+Y0DZvOyLyqjQRoT2zu/pf8t3nyJ97L//toDy/Exm1H29DyPRMSXjee+893HHHHbjlllv69Vh9ixQWl0oa29tiYtIx71ZZgeD4dEy792HEzjoFap0BloYaFLz3NOz1DYjKnAlbu2s+kjLzHARFuCpMjSEEIdGpsLY0orFgrxDZBE6grvIAgiLiUR29G5bTWxC0IBGJt54hczAyJ0Pnju+XMlHE8qlSLSmgT+6h+55E4Z/fFOZwf8G22DvfXYsVP52DK/61vN+P416BDcbBwpbsgY8KMVYxXLNvrqw1bspD6KzBF8bhjZq+MB5zb5rYbTth9o0TpGJrKG4eU8G7t5YrZ6uUWG1Ytw/hy6eg9r1NcJqtsDe0iNb2YMKQ4lLoIlQds3qS66gfPtKgFsB7D64TfoOCC/60UORYqaken3s8AWK3jE5mvhLupBnRMm7hPTEYlS43ciLPmI72UpdeQW9gUkarT654eoLuZ9RpDxrf3cEugK5gJ6P2g80ydnjllVdw4MABvPbaa3juuefw7rvvYsgCuIoi6PIXzqgBpxZiKWoPAlR2l345L6zytR/g2PvPwJSYI0GZQbuhxHUBq7XHD7C2hkq0VBfCbm1De1OtkNhUvDAdTlisLYiavxgOjUVYp4rjDT1uaa5O4XvFgm8goJ5v9u9vcpme9NNNqSqvHk+c9i4mnpMmCY5nNTWSOPe38/Hh/230i9Q21gNHf1G6qwZtRyuESe7vTrO/4OtOpTG2WL0hLCEYDquj85oZ6+8BnaxiLpgv0pftBVVI/95lErSdtCBmpfbN83yqt/UXfM8oAkM4zRaEzHJtgNAFbKRf04aSFqQviJfxiPJcx5+ZKnK6tjYbQmJc1wXb6c9e+jHS5sd7F9Jg/dRsxaq/7BKOS+KWj+S1prb5QEA1NjE4GQSQB2JMj0Vtx8w8AO8gwbW9uEbcMn/yk5/AarXiuuuuQ2RkJJYuXYq+YMC9Ws6yCQZeVuL1+7eidt9m2Nta0V5TKkQXQ2g07NZ2WFq7+jCb60oRkZILfUgEsk67CWpoROGtsWg/wlMnwDbdLCQJai57iq9wkZ+rSIMBZqJkFNd/6SJm9BXUSb5n5UU+zQ9GEmzXJk13yV4G4H2F59M3modkTYegG9TF1/esAkjpV15DYzl4c7OD5DGqHjZuOSTrY2y1EiT3cX8981fXD5mCVqfQiFqFlm2uwF3/9V7Xylkv2P7yoUF/Pu/cvxY1Rxsx8ew0Ma1x9y6gjO6OVw7Lc1Ww/l97Raf/kr8v8XmvavQasR/mGIZe9+ed2S7reHVf7uxTRU72vgLhKQzS2Lq9sEq00Qc7QTvRYEiOhibSVZC2tLR0Jvq7d++WID6sAZyXGl3HOMemPCoDecaKG5Fz+X3QhoSjbNfnrp3a2mIRbSFaa0uFgc6gHjthETRaPYysvjse09bWjPI976HorbdF7anildUo+N1r0uZWlvhDZo1D4/Z8OBwDr8IJXUwYUh64BPk/eUG8cSteWoWD33gMFS9+1aUV562lO+nc9F6JKyOJjEW9k+L6GzzoKXzw7sdkrDHW2ue8Lve8cxTxVy0bssdnAhsS7VsSlMpraq0KX6wdHDOIkZzrsY1a8o/3RXwl7YeXd64oserkqt1QKCC6I/PXN0j3joi9bBFizpuL1sOlqH5vo+iW+wJ5CFufPygbAhX7fK97+QsGU0qtPnvJxz7b6lnLkzDvZpfSGLHkW1NlDbSnfXFREXTr5HBz4YprNDj/AqDha/8cF9m1pNohZVSV/+YaIMEREtcB+wuFwNmyZ+yO7IYLE574pvz55ptvorm5GQaDAcuX9330OihRhxahBoMV827Ygb3vF6PBOgVNpWa0N1UjNCoDW/77IMKSJsBuMaO5qgBtDRUwxWYgPH2asNS7tYxUaiz6Rjqyl+q7BBaqcVGFidl865Fy6GLDkf/g0zCkxSJ4fBKiz+2/kACzXjJaDQmRciEHZSci7sqlQorhjiOZlhm/cJlHkKxGxbWZ13bdVR6tWPiN/q2l9QaqX9HcInzpZCENcbThC/bWdmEIjxYNYwZXimdMWJGGjfahCZ7cA9dFhfLK9fk9BevLcciQi9DZx+e4YwUUd+F7WvX6WqhDDNKy5j2Z8/dvjMh9wS2AnMfugrW2GdVvrUdbcQ2aNh5E5Fkz8ckvy3Hpo97bkxx9USP/0Jcl0sKOmxQ5oOdPQuu6x/di/u3euzozr86Rj8ECE8RZKSVo3/kJ8rSTEJyb6vP5H/3pi/JnzEUL5E+ugym2nZTJrV+zr4v4UF/B1bS8e54QIiPHJQH4QEeieeONN+KZZ57BN77xDWzcuBFTp04VARd/0TcpVbEZ847UmWXQ6p0ICnOi7uBXKPz0kKhYtVYUIueMO1C89X2U71sNgykKcRMXQ2s0dcqqHr/UXErqhuBDaKtncyCjW5ss9uplKHv+S2T/zGXmYGu1wNHahvovdohesz/CBD2BgZsfCrjTGjp/vATxovv+jjcyw3BsXTkSp0Zh1nU9e/j2B5ROJOFlwllp0OhViMkeXEa0NyhJEudpZc9+geS7XIzS3qANDULMJQvlsDT58O5VwI2BvszrhrL6ZvDe+eoRjD89xeVMVjh0YjUu7obFZ6XGisvzwGQVxGqGr+9oBRMyrsHQWIW74GFzxwt7f7jsTX3BmBoLXXSYMKYV1H2yHZoehJHIP7jj4/Px6u0rO3y7fePomjKsfXwPEqZE4YyHvCes3O8+7/cLuqwLEiU7qqWCVgR8BhOKpnrC0QoUrNmJzCWJWJ2fDENanEgRK8j6zQ2df5dq2+kUJTVlhp2Q4Wp/eyoC+gtDSowI9Oy97LeIOneOWIB6uqudzGjcfEha6LRxJaP/52ffiJtvvlk+bDYbnn32Wdx+++1DE8D1QVY4yFoTkInOFqEKcRNqkDLDpVPNC3vNY6thaVLDlJwtLmSHPn8SGUuuRnTmbKjVahd7XeVyNnOqAUeri6EenWGD3rAZW5/agricKdj9dj5mT2vEVq2rsma7nKIRobnHvXq1wXogWA9jVoJfO439AbPZabk2HK40yY1JwZTBJju1N1lQsqMGx9aVySFSV9iMqkON0Og0iExz3WCeoCvSthcPyZwteWZ3Ry62BNnap4lCbyh+9D1RE6PgRl9AQQ4mTtaqRgmM3jJ/ZT7HFaL+gJ3o2tJwVBVGwm5XwxTZisTsauiNfWczk+lLDfIJK1LRXGnGun/uhePqzCExjFASUl/gNbSrMh6RXtbZKEzS1/diOEC50uZdx1Dy9/fkv1O+cyHSH7oSownkx0RfMA81721Cxs+vwbGfvyQcAxLFfN0LJBOe86uuWt/ewMCYsTih1x1u3pOe+OSnmzDx3PRekwRvPA2lZd4bojPDoA/Woqm8FVM1B7D560px8KIKnnvyRcEd3pfeOmLVP34cQeF6XPDwInxZ7tqz9wT3+en06O1+VxKGw9/5t/xJcRcqGbonEicjCh9+Cw2r9kixQ/K0ITUaRqMRH3zwAQoLC3H33XfLTnhfxsJ9CuCzrtqL2oIkVB6Mgc2iQUikGUlTKxGVwX1u1/eo1So0V7Rg4iWnoWhjJfRhsTAl58CqtqKpvRxBUUmuM01FsZYymCtLoAkKRs2Ot5D9UC7e+tYa3PjaCkRnhaGpwoyS7VXAVNdjm/cXi4lCbEf7xx3Maih16a+PcF9wSswe/P1PO3DrO+fAGKYfPMWvkmasf3wvtEEaZC1JkuQna6mr+k+cahA51YOfFknW7jlj578v2FCB/R8UiKWmJwo3V+LL323DKd+bgYyFCb1W360HipD1h1v6VfVxHzTv7sd9tu2oX83Wqr9Jj3v13W7WYftnE9BUY4KKRAvpPqmQtyUNGdNKkD6pos+BnM9j/4eFUOvUqE2ejCgvwZvtYR44AzFo0CdEIaeUNozdTWao2rVyndGVnXiAa448YEcjaj7aIgYitDZN+fYFGK2g+QXbuKZpmTBkxaM9v6LXRNZbEuwN4nDYw6zaF25999xev4fa56zglXuFQfaV279C7rlpmH+792DqidD4YPkgspYB+z4IhsLiYZFT8sSHSLn3AlnJ9Xrv/fd44ujpWe4Obm5QDMbebEba9y7r8jV6d3N9kps9lFylLPH4v9+FkxFObqI0mSV4R509SxJzOjDWfLgFW5xbkJmZKSx0YsGCBfjlL3+Jb3/724MfwHUGO9JmlcuHL7AlmTQ9BgtvjkSrNROV61ZCHxGLuoNb4LC2wWG3Sv+/vakGWn0wUhZMRva8YgQZFuLTX2/BzW+eJSsWeZ8XS9CyW51oWL8flvJ6uVjirz/F68/lodK8rxCW6kboY3yLv/cHlL7kPvVXj+zEBX9c2IVR2heHsZJt1agtaIJWp5Y3lQfKhLPTkL0syee/qdhfiy9+t02EH0iWIyGN1UTxtirseiMf31pzSbd/t+3FPJTsrMFNb5zl9ywv/vpTcfSh/8r8sr9iJazOvImgtBVWwZgR55e6mXvwZmxj8G6udVXuDqdaOjZcX2TGeGRfKo7sS0FCWg0mzimAMaj3DgyvKc4fqTn/3ys/ReRV8cKYJo9C9mJPcWWLVEqiAhW3IAaiH+5NCe/QF8XQBWsRefp8r0kN37OhYsX3d0ee4w/KoHLVjskYX5vRjOr3N0syT236zJ9egwM3/9VVyapUYuc6mrDx6f2o2FuLCx9ejGcv+wRLvzUVk85L7+Tb0II0aQCrqdSo4H3FIEwtegrd0KJV7XFO9jS2cv8aH4drt4fve7Lzc7u/3odxf7m9y/iRYl6UbCViLl4ghLmTsZ2+56JfI+bShXKWcMRArwQ6GYYvzsU///5P1NTUICYmBhaLBRMmTMB3vvMd2Q/3B4NGnWY7t+ZIo/xpNdvx2q0f4uJ/XoLN0ZfD0W6ALihUDAiKVr4GjcGI+XfOQvbsEmj1imJSCC5/3MXCi87y0DD/6SY0ZE1DzuN3SwveFyKXT0PVG2sRdcYMYZUPBlwXrhHZy5PEu1ij798FuPnZg1BrVJLlp8yO9SuwBkcacfoPZ2PRXVNQk9+Ina8fQdmeGkSmh2L6FdkITwoRHebUuXHdkigmGr3BPaumSUTEKccFbvoCZce8efcxRMW7LDAV8AB1WqwoefS9XpMDzwOEbXNW3grsThvsljbYmhthiE3o8JhXoayQUrvRSJ5UgXETSxEU1PusXa1VC2GpZMMBtOw6JhVD886jaNqeD9MMqiQViOvYQAK4LxxeWQLNnTf20FwfHeD+Om1E877xmPw3X6Oh6HANBehOZs4rkRYxRxLEs5d9DGO4ATe/cdagqB0OBni+rXl0N4wReux87TCcdq7dHtfKMNe149Ofbcb5f1zYZ4MjBVRwcw/iUefNQePGgzKD7Q/fhN+/YuMleOHPVah4YSWyH75NXmtDamwXH/mih99G5OnThcx27JcvY981f0T8daci5qLeRxUnCpwd40OuKStjOhkFv7GuMwmOjo7GueeeK5roxIcffogNGzYMTwC3W+3Y+Xq+eNse+rwYF/55kSiAUXlKqzdjxe35KC+IQnVJO+wWDeIzJyA8ohBpc47vIvYEVih0bpp8YRA+Lez5puOhq4sJhfloeY8BvD8EqZaaNjSWtUpbn/OyvoIB98vfb5Mquq8MV+4JJ8+IQVCUAYZgnYt41TGPowgJxwzJM4/fPBSK6CtItqKmdX/A34c3qnv2TXBHlY/L6i2pQ2qxL+9JZSHZwA40lxaivb4a0GugNhqhDQ5DzeZV0ASFIHTcZGiDQqRaL8qLR2lJDBYu3Yew8NZembu0Xv38SKbsMLO1yJVBPhCfNzsSg93GJjuZNpMM4Dm32Ly2MEcLmJQd/fn/pGLjvZTzj7HV/qSgCIMK+RnBk1KFoKVtb0LdsSZU5TUgflL/zYwGE7VHG5E6Lw5FmyrlbOGYbr+bciJ3w29+8+yB/RA1xF8+OiscKyYdxLszsmCrbR4wWfTC60PwLk5BcE6SfLhfO2Si02ec63xE/A2nyvjzwO2PnjABfIWP185z3ECJ4SPfewbjHr1TzkoWoQqhl7Pvv/zlL7IDTkOTqKgoaaefd955oszWG/p0gux/vwAJU6OQMDmq84168bovJFgv+sZkRCSbxIu6qx+1E0lZNfJBcFUjNNb/6pg/g3MhQskgfYEzL84PtaHBg85qvsTHCoq/2PnaEdE0pgtRf8BEJjqj++uWNC0au97Ml7HFYBPr+oLkb53fpT3GlT9zfrnILrJqY4XfVzhsagncrWUFiJq73KVa0PErGuOS4LRaULH6fcQv5zxPD9hUsFo12LJxPE49c0cnL8MXqFutKPzR2Yog2YZjAM6q+PwHit01iZjYwehd/Zddsh+c89z3BjRbHw40b89HzPnzusgOjyXQF5zGNKw0uSaV8+idqPnJ42gqaxWLT47ByLMZaXBcyOBNC2HxVz/SyC1aKYxIYB0MUL6XDPjSHTWI/7/ZOHd2Jf5zx1Zcen77gB53g2Um4rzwFxmkJr/8/S6fY4Cn3SidIMcyVvgRRzy/Z9yPJuODH23AsojdCAp3jW/2TrNictpB/PGPf5QZOAO5O9rb/Xtv+tRHmnhummSwCuhxSzlA6vmyQtUYen+4nNOSUbS1yu+fyao+aUZMry8gL36Z7xyrRO2n20VghNm3tHuG0UvaG9i+4vyHayW0BxxsjDslCYe/6rv7Un9eF3fhB3e4B2+2LKteWytsYDpQhfSyV+rreYREtEITEiG8CU8feslk9QbELDgT9Xu3uD4n6aIKLS1GVFf6125UfjazZBJuyBBlMGd13HasAgMFtyOOdBhWGExaFOeeLlyAkdYPkNHUo++J5oE30LZyrAZvggnT5Nd+KAIzlArl+3zFk6cgcVo01v9zL1b/tX+qi4MNjr9o+8uOwILbc1FxoE66afmrB0felJDxn9UhhFaCyUusqau3d1/RH+EnR6srKJH0Ntawop9xpL64GW9/Zw2W3z9dEqn2ZqtsvlQdqpev08QkNra7BkRQkH9k4j5V4I8texvf+Ow485RM3sXfmoLEKdHiqDTnRv/e1L6cXdmnJMvslyQPVkwMhqmqAmkfr6rJJe1dblYKNkxLqILOWIOc21Nl3W3n6yuBqf0XTPjvVZ/KC59OfWK3RIEEspjscLRUt/k1l9r6fJ6Qz4bq0OZ6CclS7FR4mmUMJvi7V7+7UWwkOc8JyU3tMhNtIYmwrE7a0cbM+B6FXXr/WUBjXQigUUPF2ZCTnYvuFYnOFNbJ5Jb1RKnSnSiviEBsfFfp3t7AWTiDFhmjhD524PNekla2rY7FkWPjUadvQZRh6N6fvoAkGiYs9BY4UcGEnq3/s2cyEdMJc/za/54uhiFLvt2x2jIKwIBKw6HUObFyrtAUKX1+nHTsBgsL7swV7YMZV42TldWsZV3HXb2BSejb967B2b+ch8kXdtXn8Be83mhBqg4eXaqDK4awwKNsrrKn/+kvNguJNveCDMTmhOOTX2xGW9Iz+NWvfiVn67p167B4cd/GmH0K4BFpJpnHmhva8c531kpbpr3ZAkOYXlaVOPv2Bzxv/W0RUWayvqgJy787vfP7OUvc/tIhxGqPob60RVphpro25F55fJ1KpVHB0mKVzkBPUpa+QLGGSeemIW1eXJeqhQxvtV6Nwo2ViBkXJutAXP/i/mX339O1Fz3j6nHStsv7vAjjz+j7fNofsLNBdnPcxEgh2vnaHR8IWnYeRejMLJknNu08iqo31yE4h/uMMQgenyyEJ+o7sy3NCq6/Nw/XIPMPJqGoLBaNJbsQOmsuoNH4XKlWaTRorSiGITnF1VNyAsUlsZgytcCvZDHz8Bf45JGDUoU3bjqE+GuXicgFxRY4CujU2e4H+P7Tfavmw82IWDZ6Klr+Tv4K9oxlXLiEB2j3pGnT0wfE6GekOyEEOTXLvjsNn/1qK+746DyRVX33/rWYc9PEfvFtvIHrrxSf2vjUfumiOuwOn2pwq/6yEyExRsy54XhBFpYYIuS6ws0VKJlxlt8/l13QQ995EuGLJ8FhtqD+y10InTk6ujsrhqEzS72JD36wQTaJyINyLwZZ8C5sWYhrrrkGZrMZ3/ve9/r8+H0K4BTR3/N2PuqLW3DOb+bJRcGqmJnEtMt6P7ApfsB/f3hlqZzFzER6282UlZokk6sAU560XiPWjO7wdNuSOcyFfL5H5YXyR8zEHUVbKsUaVLnBWeGu//c+zL5+fJeEgEGdXs+bnzuApd+eJpk0EwedUSPz7jk3TkTFvjpJBA5/WeLXz+b6GJ9vX5iyzOy47sa9ca5ITb9yHOoLmmBttUn1TzJMbxCBh815CJudA42pe9JjqWyQlrg8x7I6aY3TY50mFgzg9ILuL8wtehTnx6K5MQjVdWFot+jh1Dhgb2uB1hgCFbexXLpB3eK4KWcqWo4egC67o2JRqWC1aVFeEYnEhDrfv6/VIap3tceakPPY3XLAUA6UCQpNSNIeuhKtB4sHFMBt9S3SiqcDkTZscA7jAPp/QNM5kOB9SlW1+bdNkuDkqZo23OB5tuHJ/ag8WC/JOJ9PS5V3wizPF2++472BinN0P9ObtNJS9waeY1ueO4irnj61y+djssOkgJt360T463rAM/nw/U8h5dvnQxcfgXrKts7NGfHgvWIYR6qMHw/s8C50xKKvYW0Drr/+euTk5IiM6mOPPSbBfO7cuYMfwLOXJcJcx/ZLkgQtzm/Ijl58zxQc+LhQCFXeYLfYcWhliShfcZ+Z7jz8+8c/2YSUObFImRXrk1DCi4DBsze3HW+ZNAVQMhbGY+sLedKyMDdYkNuxX9kbSnfWoPJAvexh2i0O7Hu/AMsfmN5NwIHt+5wzUhAUqZcDga0SRSqRnYpNT+9HdHa4PI6y29kTyOZ/8pwPcOOrKxA7vm8t3CmXZEqQY2BqKGmWpIE37LaXDmHKpTmoqYmEzaZFiMmMyMhmqU55MX98KEtcm8jGbt1fjOadx0QTnmxRtiEVUD2IRi8M3HZzO8IWujJ0lVrtWr+aliHa8fwaSVrc/aa0pS+Ir7HTiR2fGVFWOUVa5Xa+vB1ktdYjeTBFp0Pb7maY1PE1By1tefWqAbU+BFaNFQ51hxKcCKA5UV0V1mMA/+vc13H6Q7Nw7m/Iis3D25+bJHizhU5BG35IV6Gf4Oy1/LkvxIUrgNFxSFtaXHv5Z/5ktlS8q//qWmPNXJowpOMnf3DjK2di3RN7kTonTlZO2e10xyOzXpNzcNa1OTj1+64VJN4/dQVNiPJCcPUEz6reZFxJtLz8X8vlTPb8t9wwYrJD6WEm+5ayWrnXyKjWhLnuFWoEaIIMUnnXr9qN9B9dId4VNE/huIajtZHAihHmQfkaSxz89CMUFRXhwgsvxBtvvIGzzz4b2dnZCAkJGfwATqIUV5So8sPMdfebrKZLEJUV2mOAZXFMdiUDvQKuQnEO1VDaIlUyme3esuADHxdhykWZfrl90XvX8wIlI55tZZIJwuxOmdUHRegl0CqMQE+wgk3IjURwtAHF26phCNFJS8mX+hKlVbOXd1fb4uP31UjEGK7H1c+e1ufgTSgVO3ecY8ZFdL726uTpePUXtQifPwG2xgZoTKHQ6JwIj2lBWNtO1B3aLcIhosJmc8CQHiuBlwQgijEwQGsigmEpqZV1MSL2kuN75syoKeRC+0a2zllpcg7OYN+6twgRp07tkggoNxSFNTa9VIeatlloK9sAFY1tjHqETp4OS1U5HHVN0GW4qmolPaMYm00PWHleuTUoVCEGOGxUTzN0tM1VaG31Ldix8o/bEZ4SIl2lzsdQq+U5U2Wsk2gzALc789GKXtfnAhjeg5o6DBRlYvC+85PzUbanVrowf1/0Fu7ffsWIttTZJZt6WRb0IVqc+9vjapNUW2Tyf/eXF8rojmtnCvjc1/9rH65/6UyvY7y+ghU2Z/Fen19iiJDXzEfKUPfVbkSeNg0qnVZkf4WwOitLPA+oH6CPj5QdfOrSk32uDjKg/IWV4hEfNC4JhiT3TaWTK3ATLEo//vEmrF25XiruRYtc63Z2u132wRsbXdoFvUHl9Ow9ewEfjA4pVP1isHJHzZEG7H3vmLQtl9471ecNwIo9bX5cp8SfOziP2fCf/Wirb5fMT8mS46dEoqnM3Ckv2hvyV5fKxcyVDFdV5R1kArJjEJ0dhhS3/el9HxRg4lmpePnWlbjw4UXyfZZmq8y4HTaXctpYw7PXrYc9LAth02ajvbIM5oJ8RMxdBKfDgZZD+6EyBSPy9MUwpDdBrXWKhKi1ukHIV+7vJVvB6mCDX2pq7qCgA/epOV8OmZYJp9WG5l1HkRtUIC3/OsOlMLewXa+CzW5B3e71IvxiiElEVEr35If6+e2ywuvswoa0t7agZe9u2Bo4s46Hacp0qPV2BMe2Qq+1IzmmFmlxNdBqXAH5idPeEWKP+xzwnZVhkojSz7hhwwGYpmagcWOerCEphg8BjF705bBmsv+f8z7A7R+ch60vHMT2lw4LIfWm1/2f7w4HXv/GVyjYWIlrnz9dWuCe+Phnm7D3nWO464sL+8X16Sve3xIvXTYalTha2iXBpwIjBZvovMdKPHxB1/EmHSRD54yTJJ/uhQqhjZazYXMGz5VtNAdsX/jz9OOKa01NTSLowj3wJUuWSEu9oaEBYWG+E7MBK0mwPbzsvulyQ9Bis6WmHQvumNRtfpt7QbpcaNwjN9e2i6Qo2+/C6t5ahcnnZ0j1fHRtmTDMycxc84/dnTvn/oCtfbb1X797tchknv6jWV71jZmEUOHI6KZ4pKzFle6oknYR2+/tTVYxBGEg0+hGnuziL5oaglB4OB41lWFwxtSh7XAeEpZeiJDwFLQEx6Bl3z44HBbErLhAqlhHO9B2OByGlGY4Ha0of+YLkayl8IICZV+6r+BNHblillS0jRsOyBraxZcAhtAMNDca8fUHx9clmg/vQ0jWBJS+/l/En3K+VysQi6kj3/RIFDXBIQibuwAOpwNtBcdQv3EtQufMRn1tCJx6Jyrrw3CgKAlLJ+9HxaajiMkJ70biaXryDcT+5h6RfuX+ev1Xe6CLDZM2uLsZRACjC/05tHnWXPmfUySIk6w67bIsHPqyWCra0EEijg0GrO12hCUGy+aLrH95dObO/sU8pM2NE1taBnh2NnvqVtL3nPapHK156zxyo4WFCknGLFrcH4tdq+qGCGmDk4ymCQ+Gs92K5t0FSLj+FDRtOwJrRX0XyVQm/rUfb5XzhBwZSqoe/fHzSLxthfw56cUHB6XrsWKMBW53MEi//vrruO2228SJ7PLLL5e2uj8YNCko3hDTLs+Wdrg38hXfJMoFko0dGheEaZdmibE9q+Z5t02S+RODedyECOzmY5DNbNB0W6Xg95CoxUqJCYDMZNzAC+6aZ0+TVYkPf7wJdT9r9GoioDfpEJF6nDXP50Jm+0V/WywEMKJgY4VU5GMJBXnx2LctQ+KbjfOxdauQdfMDImPbWnQElqpSxM4/A/W7N8FSUQF9fMdMyqlC29EgmI9sRvpPrhrUViJNQdSRJkQsndzlRnPYu14nTqtVdrujFp0KU3Yu4KZlYDc60RZth9ra8yXL5x2UmQknbDC3lcOQ4rp+7FYbil54D//+egMWf3MKLn/CJdvrDl6/5bx2HQ7R/w6akIyQiSnQBMhnwwbPg9jXvvFgHNicNbNyXfXwDuGrUGaVVsFX/Nu738JIgK5mh1eVoHJfnRQlbKWf/cu5cp2z0Njx6iF88dvtuHvlhWgobpHNII4cfcFmceDt+9biuhfO6PL5VY/sxJb/HpTihp1WqtXxrObYk6u7TCCKkYSgCZESiNkyJzgLZ/WtMQV127LgWb3/xkeQeOdZnQROPu+s39wossucmTM5Try563M5mYK3SqXCQw89JBroV1xxBZKSknDTTTfJn/5gULUcqXLEoMjZpqf1HWfQrHrn3zqpy3y6aGulXCxkVtJCk8SNGVe4GO0lO6tFcCE2J8K1nmRQo7G0VcRjJl+SiQMfFopzD+n5njCE6nHJ35aI/rEnKD3K56pUccfWl+ONu1fj1O/NwDi3WTafx5rHdmP65eOGxMN3sFFbGYp921w3LwcjjuZmBKdmoerrj5B83rWwNtYhapZLUS5y+kI0HNgG87FDMEwcD31cHNqOHUXZ0+8j6vzpUGmHvuMQZGqHWu2Aw6FGe0MNbK0NMBcehS4sAvV7NyM0Kh2GqDjYgpxoTbUDdkDtp2OsLiUeLUf3Q5cWh5r/vIL2ghKEnrkEUddcioxLo6FSd90Rz/usCKmzYzEt7SA+seeg4sVVksgQnn7dAQwNvB3EQ304s+3MLp/NZkdLbTsKN1UO+qzztW+swhX/Xi5nFfHGN1fj2NpyXPjIIuSc1vOu90c/3ihjR/KFFt09RcyNdr91VCrk2vxGKZYu/9cyEbxKnRcvnUPOzKMyQz0UMV0gd4kfnlh23zTZEef8neBronQ/Sf599/51SP/j7TJaI6htrtJr4LTYkfajy70+d0dLGxJvXyGBnQRZckyO/eplZPzsGiG6uSsgnozBWxFsMRgM0jq/8cYb0VcMWgDnHJsKM7ETImQfmQGU4iuZSxOh0WtkVk65T3cc/KQQxjCDZH1kXc68alynHCgvfGadvGhZiTNDptB/zmlG2QPf994x2VOkt3NLtblbS4ga4S/d+IU8H3dQE5het7NvzIG93S7ENLK2T/3BTNnZcwfJYBPOTBUjEZLt2KoazTh6MFG0w51i2UU3LBPSLrsDLQV5UGm0UoUr4N8iJs6CxWBH/c510EVHw5Ccisyf/1YIaGpt3722+3qj6XR2JGVWoaggDkiPgkE/AfrYBFiOFCB05hw0rVsPB2vpOdGuJ6zhr0Wttd6TC21wKCzFZah5+lVooiOR8qcfyn/bquqwqyAFCVHHAzivLV53NIkh2gorETI1He1FVTCmje73/ETASB/C5LiwcPj6L7sH9XGfu+IT1Bc2S7eP/twKU/yyx5bJmfLspR9j+pXZOOMh34JH5/y6K5cnflKUdCtpF7zk29NklffIVyXSsubP4HZPxpIE2YjxFsD7ylBnp5PV+cJ7JiNGvRc7iyfDmBKDjJ9eLSp+Bb9+BbA7vK3aQ6XXyWrm0Z+8ICRWWmgq7lwKGtcdcJ03fRQ4GulrZrBQVVUl7XKqsS1fvhxfffXVyATwQ5+XYMEduZ1t6a0v5snfGXxZDVIekCtkChg0y3bX4rQfzPSq4c0kgK1sxbrTnTHOoBs/OQrF26vkMXe8cli8cunMxaBLxjiD9z2rLur8d2yRsz1We6zRxVZPMmHhXbmSaPiy8yTM9RbpDlQfrkfKrBjJfhuKm2FptYksavKs2F6NEThH504nSXGeSUxf0VrXLokRvayTpkdLVs/kqWhzFarL5kjwdpCMpnWibc9BWOuqxW+9cs3HCElzjQbcoVZpEDJtBlr27YFpqothHtVoRuMgNhy83WztbVoUHY1DXUMILGGuabfS7jZMyoal1QzDzClo2rMLRn0HeUdWx5yADT0GcafKifpVX8FWXoXIay9E6OkuhqflWAlMi+eg0QJUN5gQE97cuRM8/fLjXZwF8cewbkKKyMEm+/BNDmBgGE0HMLdUXrj2M/k7V7QGC1wF9TWK4tos94PFK7oPuufcE9/1xhHhCbGoYBH09aO7cfav5olISHuLVYobtr9zz+tdZ6O3c2sVO6Djw+Wc4e556t4NqEw4R9ZETdMzoY0yoertDbKVcnZOfqeOBdfhKL6F78Xh08LjPhI1H2xGzUdbxTsh//vPIOaiBX0K3qPpuhkMcF1s4sSJch2wld7a2orgYP85GINyMlHtbMvzB3HJo0uEnNZa3YbWmjZZwVp0zxTJEjlD+eqRHQhPNkl/l4GWrXYKptBtTMn2KH7CrJUXfk++2/ETI4X9zja6ub5dWk2cWbdUtYm8KyVfjaF6vHr7SkkkWF3lnp+BV25fKfMffxmbNGr55Oeb5bn8ZfbrsuLFw57PlR+b/3uwxwDOhOG9B9eLohyfw0ACOHfEuY++9rE9Mjagxm7ilCgUbamSFZTkG8+BLdSBlvoSOEuboWptRtRs183jdDo67De7gsIo2pBQOC2Wjv1poKosEqdM3InQcHO/NI97u9lqq0zY9PUkmYHb+DbQZa/jnGvZvx/tRYXQJ7KboIIzOkRa56Ki6uAs3AFts8Z3Jc5PqYDQFUsQGnz84JBlC350VPKHS+IlgNccbZRKhddj5/PLb0RqdSUKth5G29EKEanxBerCk7kvK3gB9PuaGEnw3uaa612fX+CV3NVf+Msjef2u1bjqqa7CKb5A4u3cmyYg7/NiaZdTU4PnGl3N9rxzVO5hEtlYHL334Fqc9qPZMIRopVDxBBN/b3wlzrxZdVcfaRAv8vLdtUhfEC+PQce001MOdq7URlyTgV2vb8Le/61CXpAW82+fJGdr3qdFmHvzRPFe7/Ke3x0G3H0q7NYmHPnTQul87B/D185g4t5778W//vUvXHbZZYiIiBi+AM5AtvQ707Dtf3kwxQajvqhZmI6ctSiKQWSDUxwlJNogxLQN/96H836/QBxyuL7FipytcLbTuUY29+beAweJahSC4S46A9g3Pr1AqnBW2m9+c7XM1okr/+O6OagVTlEWXqD+Qn6Xs9Lwxj2rZW9UWYNj14CZJh3YfKFkezU++9UWrPj5XOkSLLq7bzvhnvjit9skCeA+KDkGZ/zf7OPdjKJ4bN+jhY35UUU7GnZsQUTi8VmX1+DNm1XP949mKx0GJQ5AbXfiyI5kpKTUYHF4IUJijpsP9BTQe7vBGhuCcOhAMspKWFGrhAHPallBe3ERtKGhCFlxfJVHTEzMTjjC7HBS5UXjhD3EAbVZLTvhXb6PFbqai+9s2XQ9PNv2HoIhp0PDmboEjaFyHRRsqMDMq8d1q8hY6Vz39DJssXkXJ1IIPJwFkmEbmJOP7cOXAco9iRsuMMiz0vUXiqKiuxIlibtMQre/clja9KzoqZzGG4LnT2Npi6hnLrprMubdMrGz48nz+JVbV+KOj88XxTeeI8Srd3yF+bdO7BSLYXdPSQCkcLEfv2dzz0+XgoKaCiTRBccYhK3OM5yMfqnCvYCdAcX2OBWj+9oYLiQkJOCss87Cyy+/jLvuumv4AjgzQQbe6rx6IUJ4gipkXNeYdf14MUCh0w4DOlvZPGwzFsXLTvCW/+aJIw8zSRLaehMm4NoXndD4ePeuW9g5zyLh4qY3zpKLjapm1P9d8/fd8r13fnxen2z61jy6W1rV7iIPnDNRRYdEOIpCuIM3T/HWajRXmaW7cMqDM0ShTh+sxcGPC4Vx31+GN1dIKIPoSRCsqYzCrk1ZsMY5O53CgsZlwdrY4rNS5eedEXaoUyyw11jgdFgliOvMamgsQEVBNOr2RMvfTXHNGHf6MYQluNzd+oOqyjBsXjcRDkqodT4fJ9QWoPnAAdhsrXKwhEx3OSYpkOduV8FJQTR521SiwGYPdYA5hwRxPpwV0JDVzm8P4xdc/7557RaojAbY65sQNGW8K2uxq6By2rHjtSOYfH53f/birZUSxPl6n4OCbklLw/oDqPtip4jaJN9zLoxpvtXmTnaM9sDtOQcfCVQfapBkciAJBFdx0xckIHNxghQ0YlrSbJG732Gxo2J/vTDY2U2kIQlBzY17vrpIihP+bGqdk1x3zq/nyUouCxRW4uQBuSc6LEYoukWeEVvlxKxrcpA8Oxblu2skeJ/+f7Mw3Q957QC6IiYmBn/729+GN4ATrFiCIr3fAOK9mx2OKRdmiBnIkm9OlcDHwDvu1CRRF2qpMcNqdlGMuQbx8U83SasoIo2qYd4v7NN+NAuPLX0b5//huCoYCR5sn1MlLm1+vKwMsaVz9q/nCQueUrBsMfkDZsYkoMx2E/VnYKbRCWf3nvuW1YcbJGiTWUrfZ6qqJc1wVXCh8UFY89geTL00q1sA9heTL8qQLNcTh/akyGy4ragAjV+tRuT55yI4MlJY9hQS07QdJ38pf6pUTtiT26AKcUITrEHI0kw0b6bFIrVYHdCEhiJ4wkToGp1wloVg56u5mHHVXoTGt/bpOVPDvuhIHHbvznSZhqlUaC3Mh6WqwrUF4HBAn5iMkAkT4fBxfvI5q22AwzPvIqmNn+Pjioeyw1XRd3yuec1m2GrrYSmpQMQlKzr1WFVWwLFzFSZem+q1tagL1klyyW4LrxV3H/r6NXtR2cFQNyT5rs5PdoyVwK0gahBUzPoDBlvCGw/IX/C6//rRXbjk70tlo+aTn22W+Tpb5DRtCU8KEf4Oq20mKgy8iuw1k5br/3emzLqPrCzBwrsni0odnw/Jwjw/FR4ROTy6II3Iz5IDRJ0M8p7ICSJT/dXbv5KvX/XMqV0EsgLwH/v37xcddKvVOrwBnAGL7Ug6hx1bVyEzX7bRFX3hSeekSeC667MLxVCACkI0QOFMXObiHSIDioPXsu9OF1ec8acli6WoAlbVZHCSqMZgRnMRTwlWBlZeYKyUeYG5B+QjX5VK8kASSG8gSYQZpztoSMKZPn8Hb/Ns7pby0OfPomGA8vs/ee4HOPd38/sdvAk6jHm6jNEEpLHOBGidMGakwzZlMrQxxwNLO19PZvcMgxrXGpaxTANNqwq6zcFoW9AKp0YFrT0ZoTOSO1frLJUVaNy4HrqYWDiTsxFaCOx9bzxyL8pDo92I/MJ4NDaFyBpYUnwtstPKEdrhMSxuc6yGqXO+ejyqyiPgZEu744yyVFciYvbxpEv+jdXZZRbeDT2dbx1fk91YJimtTjiDmbloEHbWcliLyqBP6GCTmwHz/oOYsVDf43vBa4qaBtyrPe37M5G45SN8/b8SmGZnY9yjdwaIbSdA0HaHL3OPoUbmkgTxMBhIAOeZmTI7VoKnvd3RaZ7R1mgVZjm/rjVSnnU+WmvbO4M3zyhyhEzxwbI+dus7Lr2MgnXlmHRuerdx5T+Wvi1/v+BPC6Ww+uyXW8RF7W/z3sC405Jxx4fnydkYQP9RW1uLhx9+GDqdbugDuLv/NFmKQVF6aZHPvWWitFF2v5HfWb1qgzTY/XY+Jp2TLipYrLIZhCnKoqxvFWyu7GSek/yQPD1aDO7bmqxygXPVrLnajLQ5cTLnppWnr7mye+BWwIuLXrYMvnlfFAnJjW0kX60rEuXozEObVGauBFtTZIEm+jBucf9ZzFS//vtumVUzG6YCXenOape+ukknJD4mCAMhtlktrrdQxc45d79tNlcSxANBKlMnnHoVbBonYHSwewxrrAP6ChWCj2mgO2yAmclyR3WsQB8XLx/1a1cjKHscbBz9NxmwetVU2KRY6WC82TU4VhwnH6mZFQhTWVCUHw9zgwGGGkgLHnzp3GTVjAnJaM7bB9P43K6tcoVk5gF+zRFiA3ROoI1CK27vlwMw1Krkg+14/ntrqApt5IDYVFBr9TBkpgMWfgFw1NbBVLAW2XdO81nN0HyHycDUS7Lk+t71Rr7siV/zyHxsxpx+v1cnIsZy0FbASlMXPDKbBhznnfUz/5ynfIGEMs6+WRG7d0F3vnpYxpcOu1PMnCh8RRz8rBAVe+ukyCFPiGu+F//1uA81O5fuYMeRnCWSf5VzkGdo1aF6Cd63vHOObOQE0DP4enHjhQUpE0YWes5pTqm2GbB55rS0tIiZib9a6P26arlWRcIE2y/rntiDmdfkCNmLcxBF6o+esyRcMMtjMCMRjAE//+uyDkeybOz/oFBaPrpgjRzEEckhIuxCb3H+MryQOOemGpFyuCrtdD4mGZH9ufH4HM2N7dj6fB52vHoYQZFG2QmnmIFnVUZTk5DYrp9jFczfo6f1M+LWd86RG4jfe+MrZ8njUBOeWTc11tW6CGz9b5606WOye7esJEGPrzNlaSl+cnhzHEqOJEvlyiCnbnOKeIuzvR2qIGNHMOyIiIzcZg0Q7JqRW+KccOjsCDmkBWSi4L0CMKamo62wAIawNNgNgK3zPnX/fldrvvBoPOwRNmgcWgSZSSgja7zr47UcPQSHuQWmSd7JLZ4QchrfcmNHhRRiB9jFZ4XvAEzH1NC2uicBgLbehpA6Bxob7Sh68DeIvuwihMycDktxIbJVmzD7596TvsJNFZIUum8VZC1LlA2Kskdq5XpfEXa8nT7WAuZgPu8TIXAr4Ny3L8TW0QhyVDkO4taL4h1BYxIWJ2SjKwWHyweiCFHpJumaclYdkxXehY3ubjpFjQS24D0tMXmGXvzXJfIYA+kqnizY+vxBKVZp00oDHRavdYVN+N///ocDBw6IiUlKSgo2b96MpUuXIpIjUD/Qp+i35fkD8mYp7lxTLswUSVSKrrDiU9a+KDKw5dkDYtXImTerYV5IrGZoWMI2OC8YVsN8nPd/sF6q0DN+Mhtr/7FH2tDMKsmSJIFMgfssfO/7x6Qa7i8hLG1OPFJnxUkAp8WoSqOStSy2mPj7UFaTqnF0qzqyuqyLDSn11kUo5qYvcM1zp3t9fK7Trf37biy8a3IXgZgZHTKtCs748WwhkXhKGxJMfphFU5uZusS8mTh2yPusFIc2RaO+ZD/s7TvQUp6PiOkLoM5KhL3VDDWDtwckuDkAJwM5d6kptRrpRGOOExqbb/KMMS0dTTu2ob64WnbLneUdrfAODxy1Xo/gyVNcK1+cr9vUsEfZYdZpoa12QFPSCGe7CpY2K8zFBdCawhCa25WoxsfiOpvrcY/nBgqz3BFllT87f6zRDrSoYaxSSfD2JOnVHdyGukNb0Vx8CEnfvx9NGzbCVt+ACbNUmHeBKxn0VoVxNYdJGUcv3LfnpUXTGx6M39l4Wef1rQSv4Qjkgxko3R+rr8/9RArYnuBmClvAYxk8f3k+hrgFU1b3XC8Ljg6Sz+97/5gQhPn7UpRq2qW9k8z2v1/QbYyoIGPRca+EAHrG2sf34uY3zpL3ROEHcKPouunXdfk+i8WCzz5zaRIMuhsZ9XZJ1GJ7nK2XhXd2b1MTn/xiszxJBmhmhCSrTbvc1Y5kEGIVSg1zzmIUQhl3xG1muxC1jq4pF9IXRVS4h81WtgI+3UNflODY2jLMuXkCotK7k084I688UCdt6pbaNky9OMvn78bZTtHWKoxzm7MzG/rvFZ9h4rmpWHBbLvI+KxYSiOeO6Pon9wmBgyQ5spYVT3PupfM5cDWDgitVB+tlJ9IX1v1zjwR290yWwZvrGOmL4pF7boZUCOw4OEPisG9HBiry7Wjav0Mq7aD0TGhjY1F/cAscZjPCTzm+/+wOBkQLHcn27UH4Bae5DL1a1VC3aHpWN3M6pR3e7oWXYmtsROuB/VAbjQjKyYHTCNhDLGhffxjaeiBIEwG1QwVrpBaG1FQRgPAGbZNTVtqsEU4XWY3FdLADTrbOvaSZzkYNwvdp5bEVtJQdRWt1CTSGIDQVHUL05AVQzUqDNRTIzSjCpPQyn78iK5OvHt4hTFxWIKzK8teU4cwfz/a6K+uJwQ7mJ3LAHG0gAZfnivs5M9bA4Jy+MAFlu2rEKlnBP898FxGpodJV4plKLQmOMXsbARJ8TdY9vkcMqk7/0cw+be8E0BVrn9gjcYBrfDzH+R4x4XJ3I/MWcwfVjYxvIFe7yJxkcPYF7nrXFbp6+JzNkEix/eXD0kZnwCbx7OjXZdj52mERemH1dsr9M7D28d3ivEOzE84fifX/3isiC9Q/Z2W+6818meeQLcl5QtDFhk6WJKve4i2VYgtIAh3b1BUH6uUx+ILx854Ve11RsxCV+OJyFMDWPNc6zv7FXGx/5ZAor0Wmm0SoZvE9U7uIyxRvqcLy+6ejfE8NQhODRBmOiQmDurvTFccE7Dqwne7NKYirc3lfFMvrI9/foRinMaihD3IxojmOKKyZjGNbEySgamNUiFh6ioRdS10NGjdvgH58Egzp3itMBWqDHsZcty4AYxN/Jdnt9B3E9fXeA7g2LAxh8+bD3toK89F8WOuroI43IWTuDJiKdNA3cNdbJTN0qxIHPVJGVtFazqg5ww6ywzyudxlXNRydwbt67zpYmxtgb29F8tJLUbNvA1KXXQqVjpoCQHRCfY/Bm1DkfFtr2tFQ1CxaBSQ6+hO8fQXcQJU7NsCd6f0fFfYrgHPViqM4b5wbf3BD5Dq/vu/5OpeaoC+EJYeIjvuEFSldAjCLDib/PJ/4+82+YXyvXUueVexCHvysCBuedMmsuLZ5AgG8vyBvi6ONtnqLjCT2f1jQo+mMv+hTAKfuuOI65usiqNhXi5DYICF/Lf6myx+cgZ8ShazEa95vFOEM7hlGpJmw87Uj0pJmYlBf1CIkjPqSFux8/TA0Wo2wK4MjDDi2oVzm7hQR4PcXb66SAM09byYEbEeQhckWswK2PtkqInmDQZo/S1zOjBpRfCP4Yi6/b7rM1z/+6UYJsE1VbUibG4uY7Aj5+SSfzb8tVwwDuEupYOolmbK+wTHC3rddLX1e+EEeFqizrxsvyQZlDtPmxXVqIivgeIEfu948IvvwbJmzPUWVMHYsDq8sRn1jFFqS57t4Zh2vvTn/EGzNTXA67AifuxA2SpJ6i8N2QN/kInxpQqNgT+lQ+eH3OVSuVSzZqea82e0fC6lMBWMVWzWAxtwx0/by1muCg2HKnQJ7mA1OoxOqJg20HfovDN5OHaBpd83F5efJz+Z6mEo+r0Bl87Kz7nCgec12ONssCFvRwV7vyAbqDm2HMSoR0bkL5Pvk++1WqLQucqVG7cCM3GPwB0zedr1+AFEZoYjJiehRCdAfBKrosQGOz3gu9Acc9TH4E30N4v4Gb+V7ewri3ta2ePbe8NKZXbhDvYFBe/v/DknRsOJnc/DdrZf7ncQG4BtRWWEo31srIzoK3FADfzDQpwCeNj8OceN7zlKtZruQIk793kzZu1bawrwIWAXHTYrEyj/ukPk4JU7ZDuecl1/j7JEBiK0eVuB1Bc3iCc7VLe4W8nNf/n4b/n3W+8KGlKo6O0wIYJ6rZO7gxctA3pMZCb8nY1GiPM7G/+wXFbWLHl7sYnN3MCxtVjve/+F6nP97VxChyhxb41Q6Yobqi8zBfWIGfmbEZDR7BnBi/OkpkvmyFUZJWDJKdXqN3ITVhxvRGDIFRhXQVlKE5n274LTbYEhIRtiM46xotcXZdZfaCQSVA0GVDMDHBVRsISo05dhhp6gTAyY/rXbCdMyOllStrJXJa2J2IvywBcYqB9pidNDXqWFOUnUJ7u4/iypoTo0TmnoVDCUqqK0qCdhqe8cOt6ZDeKWTL+Sam9t1HRU4L8gGtWidK1cmX7OmlZthnJiJ5pWbXV7DUMPW1Iqy7RsRmTULxnAXu5aGDqy+TUnHuREz5h9GSLBbhuAD/Dl8n+7fdoVsGQRw8qByfx2ix/VOIvUGng+UQWXxMFTB2/Pf9FaNe6Iveuif/3qrrIZlLk4Uga4ABgeUZ+ZmFUHSsrK9NawBnAYgPOiox811qDN/3H2lhrMV7gey/cgn6gnOhWnbueFf+5A0I0YE+PmY1D9fcu8UIbRR31eyPhWERMaKOzQuWGbvrJwVKVHCmzVef0F1uK0v5MnKF4l6nBexGq7YV4fEqdESFM75lUvFSGm7koDG5+OtNe4J/ntdiBYbn97fxVZVQVOlWX7v2qNNiB0XLu1/2npOvnomtufNRsuh/VCpNYg58zzvymquv3T8MCC4BDBWdyd5aVpUCN+tRcMEJ5y0DXU4oW+wI2a3FVH7bXDoGFgd0LY4pcPOhzQ0t8NQq4Yp3wZTYRu0rQ7Y9So0jjeifkow7EYNdA2A/phOArc8FZVLNIbrXVwno+65p1iL7G1rnULSY0tc5VDBWKxFW4YN9oZmNK/bgeDpE0QlTp+dIm5idU++D2tNHcLnLobD4to9b6utQFPxQYRnToE+NEpaBmGxzYhL9c+ukORFbguwi8K92LqCpk53sgBObJBRzdFcnIdzoa9g6xlAlYN5KIO357/vaxDvCVSPPLyyFOPPTMGC2yf1yBkKoH+oOtyAaZdlCTdLkaztCevXr/frcfvVG2lrsPhcoeKcl0Hn6LqyTsF7T7Bypeg9CWRc0WFwZIWaPD1WBARIAuPchm319x5cJ77cbN0zI6Qu70c/29jj82MAJtmuL2ASwRYqK18KvbClTVITZQPzV5fKHJuMTnciBwM+W+ac7/uL3HPSpUX76S82d9NApnqcKSFI9kIZRBhMuIO+7508NO7cipbDBxGU2V2qVkHn1hh9s9u8B2/Xt6hkbzy41PX265uciN9gh4Pvl0olqmcauwZO+v0q7G+HA0GlrQjNb4fG7LoANRYnIvaakfZmLUIP2aBvYNXtqqtd9b7rZyvPQNvmUkHzBnOSHQ25NtRPtqFJ04Cmz3ahaeUWhJ4yD7rEWFT942VUP/YKrBsLkXbxHci85QGgtQ11Va7Zc/nWz2BKHQ99qKtDZIpsxbQVeV2aBD2BRETyJoi97xwVg54ATg6IjKiXYqOnAKp89BUDDd6ez2Gg4Ln317lv4IvfbcNLN33ZqbUewOBBHOc6rKtZhPbGteD35+e7nN0GPYCziuTMmTNsb9AZNYhMM/XocUtY2+zimOOpP0wZ0nWP7ZH5L2VJ+fW3v7u280ClQtuxNRU97m2SAc7K2F/wsfj99O+lIMGsa8cL+z1xeowQ26g6xLa2t2qfGulkLvcF/B1nXpuDz3+zVTTVFZAYyD1vJitMkDi7p9PQaQ9MQdiMWTDEJaBh6wbYzcfNRbpUsspsWQOYCnp+Dvx+fb0TmhYHEtbYpM3t+gIjtiJtBjh0Gjg0KjgNWtijQmCPMcEaHwZbqME1bufY3OJE1K5GqOxO+W9fZDh+yX3e7fqcE5ZIJ6wRqo5VMhX+v72zAG/rvN74KzAzxRiHmZmhkJSZcSut69p1XTvmdvt30G1dR23Xrl2ZmdOG2kDDcdABx4kxZgZZsvR/3qPIkW3JlmxJluTv9zxuHVuWrq7u/c536D2tB48gYsJYxJ25ArrGSOjK9QhLSkf6JTcgafQCaLRa6PQhMJSVyAzzxgwg44ob0HQyB7GJ+Zi68hDmXL4XYZGuyRESFiDSA+MGlB0WFPhRDC4vPH9jz4WO/TXmnjLennzOrc/myv8v+P18kYlm8abCs9AppKgXnUrWeNnqr3oy4Bxs4gp6b+xm597S3dBx4lhDWbN1jKcF0o/Igq4J53evmr7830tlnjcrKJkX55ve8vQBnPnjmWhrMFp1ritbEJvmeLeYMiYet39klQV0NY+19HtTRRSG+XYqD2VOS8bcUxN/Jl1k1XB3lBLghoaDSqiqxiI9itVwc8IxnyyAc1YAwmOkhjur2z/55RbJOTH/nrfOWoHNDUve+mLUlTSj9bKroEsyIG7WPJgaG9FadBxRYyZ0EzvhkI+O42KK2uY+O3vf0CBlhxFaU5d8dldYB2D/e60G5ugwWHRa6Gtb5CVCGkzQNzMH7/x55DenFOM69GUiAGOCTaTc+sPwsaPRvGsP2hubEH/BSmiKDMg45zro9KdlGo2GVjTk5sBsMiKioQxjxlZh7KXtaKr6GinD3QsBMhJSebhOIh45b+ZhxS973nwqgg92qDAt+O59G0SgpC/0lKP2hvF25XV7I+d1a73Hm99eL7lvhedhZJc1UnQOrKNr63qsx3rrrbcwZcoUl57bK/qB3EGwjzYyKbxD1SoiPlQ8XaqqcVZ4eHwoRrJNx4GMKUPllGNltTrDOxxZxyp2Yqv0PvDBiR6rPt3pWeRmgGF75kGZ9yw/zNazA5300mlcKQ3L3zMnbw8Vdfi3PEabpjFzqJxXTtEEqs45qtrn+eDCQWW7gm1lUoE+dO4QycOzSGzcudn48AOrEqmh7jDqNp6ERh+B9vq6DgN+KvMNU1RnGVLxxnuD/d21vRhv4uD3bcZmhEZGwdLUBo2x3araauxSRNfby/N54qku09lp1yclIGb5ItSv3YDWvHwYD54A6g3Qh0YiJD4RseOmIiQsHOkXXofW8hJUvv8OrvnyUuvc+V0VstPlee0JbrQ2P3FA1Pe4uZx+qiqUmzHbfHrF4IIdLBv+uU/WF1tNS3/D5DSq3jTe/TXklHl+57tfdRtRqvAsTBPTrh37qqRD0tYRb775JoqKimSsqMcNOA0zZ3YzRM1BHzSS1HSlzjkrzunJUBOdxVhUH+MsWrZDLb5niniY7JmkshUfxzfjTIOcuxS2dbBanX2Ls+2mgZFx5w3FU+d8JHNor35quRhU9k63Nlhz87abjwUDLI5i/jp5TCzCY8MkRM2wPAsJOG6POsB8PxSVSZuUKBN5yPIHOkt9MhrA9jnu0hk94AfCkBOfj699/fOdldRo6PnFqAMNMnvY2b9u/55zPyuUDQ43IjTeR9YUo+ponfzd8AXW+cQaTStKn1stwzNCssLRcqRSWr9aGT5OSxfxk/awU3KjdtjLhTv5MKFvNFtD3s7stxOJn+aWKhw69C6GZi3EkMhR0NZZvXBdaztM0c53Dnw6W5hfvqcaqpO2NBIxfowoqEUvW4C61z9E7faNiJ0wXQw4iZ8yBy0ni1Czdb0UQbIzge00rOTvzYBT6pc1B3wcB+3YIiXG5t570BXBy8V/WSgtp5Rz9gS+Mt59NeTRp2SiOaBE4T04LObImiKJKLNFj/aHNiQvLw87d+5EaGgoiouLMXXqVFx55ZXe0UI/9Gmh9G6zd9rmpXC3SmxGkxd/qsksBnHFr2ZLD7UNGnc2r9OQ99ZbOPOGsTj0WaHDXDcr0jlsnmInxzeVojinUjwntpmxVz1pZJxoWlOAhZPOqLJFWdZJF4+QwjNuNni8/OJiT5lU2+xxGukjq4sQ7mQ2MCVfUycmipg/lddYRT/tSuc9fWxN4u8pskBsEQn+PTc/NvW20CithOq7Mkp/AiemT0HMNGvTv7lNi8biKDRu2grtOAeLDB1qDvjo4fO3SZSG15gAzg/XcUyZYyvq6KeREUkYN/YSaDRaEWk59bKnVdG6tpjZPVdblNVoS767l01GSHoqdHFxKH7oEaSefznSzrkKWvnD0+8kLtu6m00YHtOpyLInKJvK6/Tury7tFBlhiMvReFHF4IHSzbtfz/OYAR9IXDHktk6LD364GQ/sdt6Kq+gfNNb8sjnCH/9sC8JijuOc24/hkksugcFgQGRkJHRci93ArSI2VunSYLF/24bNENr/2zZSjqpq9FC7QkPuSm8iw9bjz8/Ga7etlWp1hj3ZK81FlzcaPfsl35uGud8cL4VnfG0WnUUmhWHUsnSZMy6tIRaLhIdopPm3bEGzP2ab8bYfYJH78Qkx5I7gsdNbd7VPkq+VMjYO+RtKRJiFynA0MmyR6w164ZdfeHoTpA01Iyq9GaFZGaj7Yg0at25H28ky6y9PedMhNN40dPy3ubsnbUloh/HMBjReYIClvtap8e6JyMhkRIQniPgLn97IDY9eh9CGUxsuO4VeW5jfGEmZ1VNe+KmPX8u31oOYb807HyLlqqsRPWGKg4p6DcZMsRYe6cNOX0+MANnDgsidLx+WzdrXTx3Av5a+K+kde+PNnfGW/x6UaI1i8ELHgvUrHI1MPNmuNVD0FAVwt1tH0X+47nCgF6Ozy5YtE+/bbDaL8a6qqsI//vEPbNy40fs5cEf9kbpQrXi4hBKnVDnqFxarId/1yhHxpKuPN8jcWRpQG/Zh6bz1JWiqaMHJ/TUdcq8p4xK6VbvbcJSbZmqAE8dYDe4pKMYy+owsGbc6almm057TbtAQWk6ren28byh0MRFIXJiAuohRaDlaitbjJxCaZo2IaOhUR2lQN5ZtYqfUz/g0esAyugWWVCMQazWybbEcLVqL0HI9kBR3aqKozaO2toLZ5rM7hC1nLUa0R4eg9dRMd50RCKs1wxShQXuo1Vizr9wUzVB/d5de36xFm23SWBdaj+Qjev4cxMQOtwrFdGwKpOYeYyYXYehIq8Glfj6143mNXPnEso7n4Aay/EANplw+UjZ/rElgrUJTZSvW/HGnDJuhJgH1sLmpuvGVFa59LoqghZ4SxXyMLUmy+fZlHttbOOsdL9ldKf+n4prCN3AdY2U6K/9fffVVGWDy+OOP49JLLxXd8+985ztocdBp5BED3tOFfH3sRry6uxGXXxeFN1tTkPtZQUfYoK+wKIyDPrpO8XIGQ+QMvbPPnD3UtkV8+/OHMPvmcd08MxvMy7OQzRZdYI7fXja130V9m0ol7N9bbtYeHg/rAWyFccyhjDYXYdeOFFhMZmjD9Bhy5WQ07ipH846diJo6UyrP2QOubwTMoTSiFmjiTcDoZmiiuxtKU0YowtblAZlpwNAhQOipSnuNRvLrFGFxmCanYW9pgzHUDMPQ+E5evNYMhDZZgCYL6oZrYYp2XiinbdNAX6uBKc5WiX7aI9dGRqJt52G0jYxESGoatNwQQIOY2CbMW5CLCGkTsz7ve9/fiHMenCNtMLaeXqr4MbrCz/LTX26VwsKxK4eKmBCr/He9wv59jdQbzL1tgrVDQqHgOjLduo6w82TMWYE9qcxZSJ3jcyuO1OHSvy9Wcqk+pHhnJTJmJIsa28033yw/u/3228VO/POf/5TZ4F4x4NfGU0DFeej7SK4RU2eEIiJCi5siNuHllgak1epRDMcjN70BvX57Y8954syP24f9GcamhCv71W1Gmrn2bc/mojinCt94c6VUhvfofboBC6Mo9+rOczHMzvy5fSU8B6WU7a/GNd8I6zQsI37eEJTs3Y2oUaNgadUCtSEA9wlhZmiSTNCEOI9Rt54Zh+iXKqApOAlL4UlY4mPQPiodlpRYQKuVEaLaVpMopHXktnleahqhK6qAJjIUGOZcmCC82ozGmB4K2zSUWtVCX89pZFSGs0YczGW1iNAlInr+clStW4WE9DS0h2mQmVGBOdM7S53e8ckFnYoiWZex5o+7UMzhMhlREklJnZiAebdPxOYn98sIW0r+Kp1nhTOSRsXJFwtV2StdNHU0frbCdcEmf+bqiI345cvpEo0696HTypIK70J7wlooOmZsMe4K7UNMjHvqjx5VqR83MQRbNxnQLpOtgGu/EY1VHzWj6K8fiUHkjGUXppcKrHanxnh/ObquWHLn1E2XUaRrikVMfvLFw6Uy3Abz4uPPH4bh81OlXYxFeqw29wRUnmOFvKvQALEKP3teqhhxG6wpoMqd7RzaD8sITU9AW0kltJFmaDMM0A4zQJNm7NF4E3NiCBpuPd02pa1pQMj2wwhZkwPdpv3Q5Oai+rYm1NzQitaRTdAWlEOXewL6gnLJf+sosXqo7FTO2z7vbUXTxoiAxL+dFNNZpBqdkQOdQQt9gxaa0mYUPPx/qPriE9FQD0kdgnZDC4YPL8XsaZ2NNwsiNz2+v5Oq3d8XvC0dCNc8c6Z0GOx585jI4ZbuqZQq4/jMaBHlUUMaFL3BjSFljxnV+XpD4KvzmUwW3HdHJR68rkRachW+gam9nS8dkQJw29RJR3CUtTt4tA9ctMIvicTqT1uw8oJIMUI/fjAeX3zcgqT9X0KvBz4uGtUxGMXeONngjpfjSvlGGT6mAaZH7azlrDeNXxYnUX/88OeF0qs9anmG5EI5Gcw2htQGR5Gy+p2iMV//9yBCwvRSmczX768n7s5ggPwNpZKz7TochXl8vofDXxRj3IqsDiP+7qootNc1o62iDmFZznsMndFyUSLMCXpEvVqBkMJThtBigmFuFBpvTIElRgdTjAUNl+lgGBeKmPcNCDtgvdDMURoYZprQvKAR2WUG1OXHwdyugS7aJJPLNG1hCKvWoS1Og3Z+3B2n0YIwvRHRSc2obYyC0XQqdM/hJ9HRyPrOfTJUpXrNJ0hfNgORpe9j2mXDukXiWRDZ1YuYe+t4bH0mVx47dFaK7Ha5WbNV3Hbt41coemPI+AT8+YEw3FrZLP8+dKANKy+MxMQpIR6J0vmCN15sxFsvN+HfLyR3REmDoUgvEGABLXVNerNjQ4cOxYYNG6SdbECEXDKy9CgrbceBvW0dYfXLro2CnkMzKIWKErlo9r9/3OFMcRah2QufhMaESO+4hBfSI2Q4PUOgXW8aGmuL2dpDbqNgWzlMBqO8DqUSOX60aGcl2hrbRN/c3G6RKWC21qGFd02W/6/89ZwOQ0rjz9nlzqRjXcWVm5y7NIZ4qcU+doXjlg4qxDWUWxcRGytnV+F4WyuKpro3oq7w0feQcOZURE8bAcPiWBgWxUBbboTGYIE5JQSWiO4XW9vEMFRNDIOmxQwNp59FawEpVLRgzMLuEQs63o2VkTAZ9NCGt6O5jYlsDeITGxARYZU6NZs1MBhCoNWaERJiQkVFPPa9exSlG45i0U0j8MVDfxNDHRtvxAwXvIYl906V8CDnyDOK4Ym5uwrFzGvHICV6H+YsDEdUtAbVle14/8026HQazJ4fhrSMzsvpus9b0NJsQUgIcNZ5EQNq6AtPmPB/P6/F9rzMjrXYG4NRFN1h3zdTuM6M99GjR/Hxxx8jOTkZFRUVuP766+EqXlFimz47FB+/2wJjmwWXXtO9kpsXzR+GjhUFLBZoZU5PkvyuHNCpEZo2KPzOr7LcGhTvqEB7mwWFW8tFujRuaLS0tR1aVYjPfr0NM28YI6MBKT86+6axqDxWh3ajRSaK8XUoW7rs/ukdLWxspmdhmMVkwagzMrqNeGP+mRsDjgDtLzHpkRK6pzBN19Atj4MDNFgJvez+aZ3CwV2LBr+7J6GbYhI9dfY1t8aXIzzbsXdpbjOh7WR1p9+n3XQGdNHh1pA82/N0WphTXeuDpnG3RPQ++5ofZUzK6Q1HHLqnRbRaCyIiTr9nfeMJ7H58DR7YfbWkPGiMlz8wGa31vY8FtbH/w+PY9eoR3LXmEpf/RqHoicyZyXjt7WzMWViOulozQkM1OFlixje/HY2c7W3Y/rVBjLmN6BhrRLLsZLt4vizu7evc8f5y0dKT+MlD8Z2Mt8I3cKaHI2fVBgvX/vSnP0k7mQ2vCLm4Cg2wyWhBu9l5/vUnZx6WnR+Lx+gps2c7Y3pSj8+ZOTOlQwjFVopP/XGGxbnYE+qKX/jIAlFds3ruHIMaJQacFciF28pFHY7QkDMfwTzqvnfzpXXM9jsb3DVxyL2ZAvMTEnuUweutOp7iLY524ew3H7MiS0RkiDMZx+JCE84dUYxq7QSHkoiF2w+h5LONqJx1FtobmhEx4vR7sbQZUfXBNmTefXoUaUiytf/95HOrpTUt5fKB2YmzQpy994w6sDL2o59uweaDGXjTAKkQX/idSZJa4WbNVb6z9hLZGDmbiKdQuAs33ozWbVjbIuvKORdFYPf2NpQWtWPuIucdDKlpOqy4IBKv/K8R130z2iNG3Gy2oLLCjCMHjSgtMWHdqlacOGbE4jMj8N0fxiIyqrOTMGt+KK652XFbrPLCvQttnOiXdGmp5jTOp556CitXruxkvAesiM2e/Dwjzr+ke46764VDA0nVI/Z6t9S0ie65IygxSilSGzSEFIzh39nnssedk43dr+WJcWb1MQvnaLyLd1WiPLfWYf6T4VkWdFDTvCssZOO0MQqAHF5VKF5dX9j+wmEkj4nraAmzweOj5901H9/VeLcZLPjo7WasvDDCYSsfzwcF8ll1HfvVp5hkOYARR1fD0n5q9Gd0RCfjbU/aN87ql/F25n27yjkPzZFK3xev/xxrH9mNu1ZfjIhI66Wp1WuQt7ZEioiYXnEVng9lvBWehgIcbx0YiqxsPfbsbJNo486tvReoxsVrsfiMcOTsaOvYjL//ZhPyDvc8Ma+yvB0Fx034w69qsGenAWs+a8HeXQbZNKycW4q7v1GJCZNDJZz/0F8SMXqcHgsnluBXP6jGow/Xor7Oev/ffk8sqip6n0Ot8DxdI65sYU1c9wWi167DLbfcgvPPd33wlk88cDJvcTjq6y2I6NmGd+z+6HXSS3VG6uREkUftra88YWg0jm8slR0P9csLt5chPCZUwugzr7MORHGEGMB5qdawPk9MhE7EPrgJaCpvxd1rLpXH0dhyBGjXeei9CT2suNqED9/KR0K9Vef9y3prLjcyIQwLvjWx1+f6cnULrrwxCiEhznfv9Djb29qx9HtWHff60iZUffienLNDGUvhDoaSKtRvOwJ9dASaj5Qg89vnecV42879jS+vwF+mv46kUdaogC0vR1Gda/57Bl75xmqRw130HWudgkIxENDhYCQw/+gJZGXrsG93mxjJwwfbMHZCz17UsBEhyN3fjPVftKCowISrb4zG5x+3yOZ8whTHf/vrH1RjyyYDnn0jRbxqbhZefqYVyUNOG4VJU0Px8ofW6NSMOWGYPS8MCUk6REZp8Px/GnD1TdHys88+bMaFl6t5376Ek8eiUsLFiDOKyGjryswTOPP8CISGaaBnZXc/0Fhc6OtiPD4uLg4b9mUgOsY1p/1EvhH1dRZMme56aKCnYgrxVHNrXNIo/vKxPRi7IgtF2ytEa9y+l9qdVi4qylUcrUPxzgoMX5TeMQLu019txUv/cH/oxecfNSM+USsFLzRazt4vDbh9DzqLYZKStZgyo7OX3vXv2d/OVgVOfLNprBMOW6nMq5MqyK5T2vg6HKRiC9vz31SL0+o0cg7Zw07d3sX3TEZdaTNGL/eeqAWFVjj4hemArnz88y0iqMFZ6grFQMManPRdX6GkqB0ZWTrs39OG7/8sHuHhvYfH6VWHhVOQyLqWvv2KNT9uz+IpxWist+Cv/0nCmed072AxGq16Cbu3G6SozulxNpkl/37THTG4++YK/OGfSR2va48qZOsbJ7aUic4InaS64kZRAOUgL2KbL89BXqyl2v3qUcy8cSxuTtzc8ffTsgt7tLl1dXWizuZzA36yxISCfFOPuaGe6HpBuWPA6XlygDp7gEcvz8D8b01ySXvdETZv+PvfqsSj/7FGCBjCOnrIhGVnhyMx2b0cK6vyWRFqf1Pav9cZBetw48Xl+M/LySgqaEdUjEZEzphDc4SjG49teAzTjFyS3tGqRzW63a8dFS+dMrQtta3Q0phzo6DVQB/O7yFStZQatW/xY0/+lmdykTg8RqIUiafasXwFw+vcuV75+FI1bEThFxz8pAAf//Rr7DqeiXdebcaKCyLw3JMNmDk3DAuXubfmca1kaP2ci6z33O3XVCBnpwFbDmX2O1++c6sBP/xOFVZvzxAPfPzEEAwb2blY14Yy4u4jao+MGlo4VrpRUsBcq7jOsm3VNmfD1GpCY0UrHrz8RKe/768B91oIvaLcjJTUvhcQdZ2p6w6saKdk6cpfz7ZWmq8uEq/U3de155qbo3HVOWV447NU8YQnTg3Fi083YtqsUEyfbfWMG+rbpZhkzIQQjJ/kOPIwYrQeb77U2MmA216Tu+WFF5fj9U+HSHEMb+iICI2EWno63q7nh6I1fN9564pxsKhAWryGLUjD8h9Ml98zvcC+xIq8OhGpsOXfv/rHHhltapMiJRTgyd94UlrwOO1t/V9348wfz4Sv4P4y95MC3PTaioDpt1UMjvGQ7HoxmZqRlqHD8TwjvvNALH56b7XkxbsWkfUE289owFnZHhunkWp2bgw8cb3zWEaPDZGit5QhWrzyXCN+8qBz5USFe3CgFtdaQiexZE+VtIyxILorQ0v2wmKJ8eg65jUDbjlVJTlitOPdnjvQSD1Z0z2s2hMMm3PmM0d/hkTqJbzB0aK9vY4z5i8Ox5+f0OG+2yvxt6eTpV3kG3fGSGHJu683wWg04+X/NuHiqyJRV2d2aMBpjL78ohVpmY5P+3//1YDn3k5BaroetdWtiIzUICS0bx82LyZbLzk/C1bkF3xdJi1n+git1BMw2X94VZFUR/LxXafE8Zyd2FyGSZeMwITzs+V3/dW2d5e/zngDF/xxfqeL3tHnRIWpuWOKsfVI5z5XRyhPQ9FfWAPD7pZv37gWP/xlPH79wxr87ekkPPjnRNz9jQr8+o+JyB7u+vK69KxwvPtaM679ZhSuujHKY4s8Pfgh6To88Wg9EhJ1ki+3ceyIEd+9pRIfbXA/xag4jW3NZOS37EA1ZlzbvdbqyvAN+LhQi9dfaMJZ50YgeYhnumO8VoV+cJ9RCio8xdXxW916/JDx8Th5oEa+Zyg599PCHmVcXZk2xCKUpkYL/vuverz0jLViferMMFx6dRSuuiEG/3t7CB77Qz3iE7TYurEVtTWdZfE+fb8FI8foccu3O+/OWMTCHfIFl0Xi73+qk4rV0eNDJNTuCr0dO0PkE84fhjnfHC8jYTOmJiM2I1Ly4TTs2587JBELet/2QjhlB2sx5uwsuUD5WHO7Wca6+gq+Hqvq2erH92j7ckRDvRm//lOCS32uvT2XQuEKvGeWP3EpysvapceaXjRz4OFhGglduwO7LmjE33ujWSrUWUPkKX77l0Ss+7xVwvzHjpg6RQM9ZUgGOxaLBce+Ku2Qp2VunGkWfiV/+QU+/6gFYyeE4OqborBrm0EKGV2VFR8QA37+pZFY+5lrE1Vc5eyYAy4vutzBMtfLqnF+z9wET3B/yRyqw44tBui65KZorJ99vB73/ChW3nt4hAabvzTgJ9+twtP/rMeTj9VLJfkLTzfizZcb8a3rKvDX/6vFh2834ZtXlOOZfzdg5JgQFByz3mDMr2/6stVarOJBaIyZ3x6+KEP60qnRPuP60ajOr5cK/OoTDZ08cPsxrDlv5GHaVb7RT2bU4NFZb2LK2Hb5zD99v1lCi86gd3HJVe5X2Cpjrugv+VPPwJpPW1BbY5ZI0K/+lIiN61qlTcwdMrP1uPjKSGxab0CGkyhdX/nPK8k4e05ph0Jma6sFqz5qwXNvn26rVRvavkPVR86Rt0VOKHk94bxs+aKYz8VXRknqlb9felYE50Th4V/UIjc31z8NOCsdqyrN+OidZlRVuCfQ7iko+nJyb5X1eFIjUXGoVry6/kBt9+YmC/bsOt37mbPDgLturMSseWFSuMf8Pz1zfnB/+EeS9GDe+b1Y/Ox3Cfjpb+Nx5fXR+M8rKbj/5/HS1sEWkBP5JjHkZ50fgfyjbaipsh7n7m3u7eRd5Y071smmJjI+DONWDBUPncUYnHZG6k82dxp9yjwPJ3i5PMe8H7Bo7q8z38CY8SH413PJ2La5VSIXhcfdr/x3B7WAKfoCJZm5Mc/PmiEpMgq3PPLvJLz/RjP+85hrilo2GhssmDoztM+pM2fEJ+iw+0QWnnjRWojL4/rx3dZ73R51D/SNkpxKJJ4qWOvtfHITZTZD2vu2b9+Ozz//3P8MuG0aGdWKONzEE+ECVy+yjf/e1/E9Q7C7X7eOAWT4eMt/D8p0sr7mRRnq+vFv4nCy1CRhdO6yGfaiQc7dZ8TNd0Rjy4ZWqfjsGgLnpsZZiPdXf0iQwrVX/9eELRsN0h4yd2EYZsztPQ3Rl5zubR+ej23PHhJhG3rlxzefFKlX9uJTrObAB8c7VfxTUIXT4d67f6Mo1/UF/h3bKXrizMYv8cTZH8hGhwWDTC/Q8zaZgMlutCT2FbWAKdyFaaf7d14lbZBvv9okETby1KvJMo3x6CHXw+EhocCVN3ivV9vmId7747iOCnhF/3j9jnXImj2koxW3t7UkNV2H2DitOCg33ngjMjMz8Z///MflGeA+KWKzQak/hpU+fqeZctvSF87dx44trdJrnDJEJwpF7rZLOJP/uyFuI/7yn2I88XPrzvevyRPR1my9SOOzokVHfNcrRyQf3BU+nysL+IQpYbji2igRX8gewbBXlIS62Q86elyofBlaLdi6qRUVZe3SWtIbFGjhDvmqc09i3ERWsWqkV9RbBVmhEXqZCMe8N2mpbRPNcc6r5f9tP7e/8dmfzZ0m+xkdnT9u0hjlYKqCkrSJI2I66cuX7qnCxn/tQ31JM8aNbMf8JeHSqXDJVZEwGICyUhMuWF6Gj75Kk3AiOXTQKNcMF8ELL+9FFchDKGlJhbuwzoRdGpERR1Fbbe64Z95clYZn/l0vdS2udOUwh97uIZvKsc50nrgJZkSvsqIdZ58XIR00LMLleuMIdf27DiOTGdOSOrXW9qYYSZu3L+d0BHfixIkYOXIknn/+eSxcuBCTJ08eeAPe0mzuKNq6/pbTb47J+5IiExYsDcfwkSFSAPLe681IzdBhwRJrjsARjn7c1di+9UojZv6kVrw3cnBvG2K3fY3Jw3VIOHhYBA9o8E6eChP3h5UXReJorlFGpXKEK1vA7Nu9aHyXnBmBtata5DicKS115Y1P03D52Selr/C3jybKz6hx3NBgweRpoR6rpubAFKYYGsqaZRgMPe6Z14+1Hnus886BjGnJnc4fx73SqFNpyDqofojM2i7dW4Wc1/M6GXrOWOeX7XP71vUV2LrRgN/80FpseONt0dh0IKNTC86EySF45VkDEpK0Ph0EYTtGVbHuOryWHI0IHkyw/oUTyOz55rdj8N9/NuCOe53389ooLW4Xlbb+Ulpsku6Y1haLaHfwmG65K0aKi194qlHuJ+bbna23yoi7xqHPCkQ3o+va+oebnRtxpkdMXYIy4eHh+Na3voXVq1dj//79OPfcc116fa8IuTBnSYWi8y6OdNjDTOlBtl8tPuN0LzSN+tdfGTBspF5yyV1hkdjLzzZixCirceF1Z3/krOL+029q8aPfxMvvWC3OavCzz7eO8WNYi9Xi9GgplMDw1ou1izwaRuUNw9ewh+H0jKF6DB2md+t5ZswO7RBcuP7CMukRtW/36I9hoSDOC9d9LpsEGze8eDZ2vnIE0UMiMHJxuszQdgZHsVLwJT4rCrUlTYhMCIel3dJt4s7Gf+1FZFI41vxhl8zo5hjYh28tx7P/bsAHbzdj/KQQLFgSjpGj9Zi9wLn4BQuC2Fs/pB+6Av1BGXHXPBHOC2DkpmhHBYbNd33wTLDhaP3gRn7StNBer2EuxzOGFzv1jh09nnKudBjo5bMFlT9jwRpTmIwEzl0UhoY6C44cMsoY1GEj9OKVU8s974hJ6kycoa79nlOCR9cUS/2QPUnrv5CNXE98/G6zPMaRkMvJkyexbds2XHzxxZ4VcvnwnWZce7PzXurqqnas/qRFQsZzeliQOWaPBr7rHPHLr9Mj/6hRjO3MOWFSlW0PBVMWLnX8vDTg9HiZW3DE4uXhUvXHXPNNd0Sj/GQ7bkp3HIa3/5mrxpw3ja7LvUl95KYmi1vGm3AT8MFbTVIpWl9rxnW3ROOX99c4PD53oSJbZV49vvf1FfJv+7YxhtSPrS/t0XgTzkaPSKhCzhtHoQvVYdYNY7H1mVxZuBNHxuLw54UyaObQqiLx5q955gzxzj/68de4+H+Q+fAMk7vqUS9a3jc1P0+hvPHeYR0FdepZJLr/g+PInjsEe9/Nx8QLhnW6xgYrcxaEYdWHLd0kU7tCZ4MDi7ie9XR/0Alifj0yUisbYaYpH324Topm+RxUXiO5+9tk00DFSM4kJzXV7fjwrWbcdX8s/vP3Btx3R6XU23BSGgt0b7mqAs+8nuKy6uZgpXQP18C8TgOqFkceRlpm/673tLQ0LFu2zPMe+FOvJWP/bqOIlSQmdT7I4gKT5Hwvudq1mbfsk46N58XnOLTMPkpONFt+dgQSk7WoqTZLkZi7MoX2sGWLVd98y08+1oAV50dg1NgQlwxib4acogjNzafD3NQv377ZgB/8qu9V25RsjU/UyQbghacbgCvOQX/5/HfbpXDt/64t6va756sXiHBKdGoE7vzsIqfPkftZAY58UYRFd08ReVVb+JStE5uf3I+LHlmIZy75BKHRenzj9dPH/MxZb+D6W6Jxx3dPV7cHMso76Rm2JYZE6EQZcDCp6DlaK+jYcA4Co4tsQ92f04abvxXj8HpqLG+R6YmctOhs3eFcBbYj0fMm7Bs/nkd55+666Y4wtlnwyfvN0jVzzw/j8M9H6sQ7Z/3NvMVhneaaq+vcMYZGI1b/fifmf2ui5MDdidz25IF7TUp1wqRQzJobJqIAhHKgvBDYUkWP9rJre1Y6s4ch4SkzneeF6cVTBpCvxR7g5SsiMH9x/4RhbK1ZXEy+fV+snEQWetw0wbEn3ptXLoM/9hmlwIoT486/zE4/vMHcL+NN7IeXbCjJwOJ+TsWhRvqt59Zh+QrH4w8psm/afDn+c96HEmK/6ZUV3Qx3W4NRwuwLvj0J+949htk3jxN1N+Y+a4sapRWttd4g4fUrn1zWMRhm728+xjfvjJWZyFdcF+22hrw/0pdUy2BaDEcsSsOBD09g18tHMPMGa33FYIVrHTtLCNc16kk4uxZ4f3GEcV1xE16A48JatpvZjDe59aoKrNriuqIa87AMpdN94zoYl6BFa7NFapaYimxroxy2CSvOj0SU6XMUTZgvEqFdxyEPZsKiQ0SRjxoavp4P0eciNnrXZ6wMF+GRf+QYMHZiKMZNCHGYt+4JoxGIiND2+lrcJLS2mHvNKbhCRKRGcj+2vDyf89XnGrElbblLwiINJ5vRUNaCX5QPxbjGA3IDMdTPKnQbDH2t/axVqqo9CdvfFn93Sp/+ljv6uG2b8c8fcifX8w791oytKPnjArx55/puv6Me+tQrR3X8e/JlI1F5tA7Zc61REU41401eurcayx6Y3uF1sSr94ccSRfyGmtHuGm9usliZ25MmfKAwmMLx4XGhMrVrzFlqghzD2Kw+fuGpBpxzcSQ+j+h5vC+jZG/f8yWW3DsVtp07w+T0sllZzpC3DXa6TJxirSx3h2mzwuTLBh0STpCkqtw/HqlH9vAwEUfizy8/63NkXjBB0mUqJdJ5s9UXuDTSVvSXPlWhc2G+7e5YfPJeM865sG+G1Z2ImqfCbysvjMSff1uD7zwQJ8IGXESPJ59EXEGDQ/F5G9S3paJbwvAYxKZG4oElh2Buj5YbafS403l6tpKtO1Wswpy+J4nL6ltvaMWRWoR/tRnfvL/3Clgbw+al4qJHFohxtom5VOXXS/uXPXWFjdCF6aSobdvzh2T6242vrMDet47JAJJzfjNHeiOpiPfTp1vQuOGgyJ26C8ch0oB/tbZFBDKiov0vN+dqC+JgqvLlfSsGaBDR0zVAaWl63+y6OawplDkNcZlRTmsKLvj9fEwv3YRHHmrF3p1tIn1qK+a0yVTTeP/i+9UIdTM4yc4WOmFDh+tlraIzw6jod26qREV5O4ak6TBmXAjeebUJhw8acfs9Mcg7ehwNZVnI31Aqo5ZNBjOW3T8Ng5nMGck4+PEJ+b87JCZprRHhznW//tcH7gwP6rq4DOfwUnKT7W3Gi1fKz4YtSMXet4/JTFf274VGh8BisiAmPVJ+xirqmsJG6fG079lGiHVHTO+QO1/+n8NIqGfsaeNNplw6QhTKopJd3/FRnGVJyH4sfyDO7UXov4vmYN97xzsMeHV+g+TGWXnJoSeEI0s5ECVlTDzO++1cmE1mvHzjF7j66TOQ/1Wp9JSPWpYhi9SsG8fipu9Woi/o9FbVIob5qCHgD3jC+A4GIz6YcGUDx03NpddE4ZzmE3hktV5mC4w/d6jMGujKnaN2AqPCpYrc3omhVvqfHqwVfYR9OQYsXxkhGts2bNdUT8fDDpfrb43Gmy81YdxEqxNCp+aZN4cgLMx6nJvWt4qwDItOT7MX/wqZJgaca+Ngx2Kx9MmWUcyl7GT/FUoHxIAzb87+RF/CinC2Tdx1fxx+9mImxnMOtkYjX5zaxVGa6ZOSMHp5JnShWgmXt9S1ySjSaXZhY/ubYuKUEDz193qkZ+lhMQNX3RCFpBTv5HaHL0qXfm1br3ZvcDMyx7wfy8/vm+c+o3gDysdbBQXW/Xk3drx4GFc9tQz73s0XwX6et8mXjOj2d1FJ4ZIPYug078tS6RHvrxcWekpWkkpslK21bz/0NZ42uMqIBwfu1kNQ0fFXF+XjqROzcWR1sdSJcAwyq/dvTtrcYwSSnTrUR6BUs60i3RY+d+f6ZMHaz/8vtJuQjA1nBcN3T8zp8XXsN/nBTsH2CingfemmL5CT1Yw//TsRWgqdu2DAN391Os/6zDPP4LXXXkN7eztGjRqF5GTXPPp+neW+GGHG/bnru/Qa10Lv9GybGvvvduXnmeSC54UXk14h7VS2sDlbnjh4ffz52dCHWg0wbyZ+pY53HPJtbDBjx5Y2SSV4WrfYEVQ12/HCoV4fx/fFYrXFSSdwbi8tKz3BVMBrT60VRbWk0bG4Z8Nl+Po/B2TnzVx4WIzjAsSRyzLw7OWf4Ja3z5M2C26E3vneBlz22GK3w8zk4V/UiHIUW18e/FE1nn6t5xY3b+JKoWNfCtuUEQ9s+iO/y7Vn/LnZuDF+o4i4bPosB59EaTF7fpjU62zbbIA+xLrgszWX605FmVk6dCgexf/vZFV71ESJlhXvzJdZ5Y2VrbjqVksng+yL9/zLN7LF6WH4fzCw4/lDCIvWY+l9UzG9KQczR5Tg7dWpGNlljDY9dfuNGDdwTH+Qjz/+WKrNP/vss47fU9Dl4Ycf9qwB37i+Be0ma7iYxpvhYndhxeN5l0bIG+gNLohbnj6A1In0gI+hP7Q0WfC20VoNwnzFa7etxcpfz+moHjyxpdwl75a92TnbDaJzzvfvC+NNZEer0cDU1t6xyeh2bPVtyN9YirtXlmLsBNc7Ahzx3R/HSd99eqYZ27OmdxQlhceHOjXeZNFdk/H1kwdQW9SASRePwOFVhUgZGy/j9Zhbd5cpM0KlzmLNZy149KnkoG1HUkY8sPCUZv7p59FI6o2DjlhLQ8MdFqbBJVdb1dKO5Brx2QfNIlB10RWRHetO84J5MFcViPFurWvD0Dkp0hVSU9CI+eN24enXkjF7vu9C3b+9qgC4it8FdrGm2WTG8U0nRfOip8cwRWiL0FZhBT7asB7fuq4ST7yULLUO1CVh++DhA0apjbKHAlZk5cqVOP/88zt+XlpaiqFDh7p0nG4ZcM6Svev7fe/hZa84K4mZa3Hp9b4qxbD5aUibnIgXatL6deMwX31kTTFK91QiOiVCJEF3vnQYGVOTMOGCYUgaGStiI/bjM+1hSDh1+1dYF6GRivt5i32f/1n+wDTseTPP6UaDVeARCWEYO6H/Qz+Y5z/zXGuoesKpm/FkSy2mTAvFuQmnRWVsNynDSPT+qe624K5J+PhnWzDrhnForGjBorsnY//7x/t0HKzyv+rcMpFZ5SLGopvPQpf4fOiILxaiwVShHqj44rrjvddVsIqDL9j18trzjeKRk/+Vz0PuJ3txxg+sG2wbHBPMwtLv/yxWCtV8acDJD+6qkqI3anzYn69Auq41Wo2IVPXEur/kYNqVp2ujSObQELz6cSqefKxObCXTfz05eU1NTXjyySdx//33iwLbRx99JOHz7OxszxvwrsMkqLxG+VM6RcwH26Q/nfHysw0Ye6pgojdEs3zfPiy4c1K3n7t7IzF8sa50KFIn6LD4nikdk9HY7lR2sEZUxGbeOEbEEyg6YQ8rsZnH5Yd5x42RPtXj7gp31hRLodoVtce7QtGMsxOP9Noq1hM8N9TpdXTRxcZqRbueIjyckkaZRqo1zS9bj6c3Z0vrC9HlVMo40tRJ8ZIyoQdBT9xRzrw3ONRk5QXhqKttx21X15766ev46LxsCdMF4/QwT3jjXc9LIC2e/og/XGfZw/W49a4Y8ey2Gsei6th+DF+chq3P5iJ5TJwUix5dXSSFuPNunwBj8xhcktm9HdTb/PGf1hkOgRxl0mg1vcoBn/Gj6XjjznU4++ezUXAqwtgWaZGpkwyh99Qt8/YrTTLN8ps3PYpf/OIXeOKJJ6DX63HdddchKipKhFw8bsD/8lAd/vbf08l1tpFRb5c5ewqufL3BILvHlFStqIft3NqG8AiNhIQoCZqeqcevf1CLr1a34kcPJjjVBeaHzHAwK8GdCQe4Y8j/8vVEjFyikVCuPVkzU6SSktKfhz4pFAPIfu/yw7WSv2WjPvuap15hDZG8VDd8wG9kypw2VrQiNq17DQFD25RC7A+fvNciA2f++M+kbr+jihr16CmDuy+nQVScfvNIIr7+qhV/uL0Ed/+xWRaOubdNwNdPH0R8VgyKd1rnsYfFhuL62I0SKnSXE8facTIiHXeuWoYvHt4pG62Y1Ih+5Z3dxdefe38XO/vzEiiLpj/jq+usN1gkyyr2hpphIs5UvLsShdvL8dVjezDrprHS1mVLM7H+xF0ZZ0/QtR89WK8/jUaDuqImvPrNNSJotemJ/ai7eBR+ef4xjJ8cKg6r/SAvwla9+26vlAmcb65KRaThatxzzz2YNWsWbrnlFrePwa1P97Z7YvDrH1RJNTCNMUPJtg/rjJWn9XtZHl943ITLru0+7Yazrk3tHDTSs2HmcASOpqRB7Un9p+vFwZuMikcMOXEH9MSRGTi+6ThmXjdGQuhjzuzsYTMHnjoxQVTGwiJDRDmK88JnXDum19fjazEv9f6bzSJ+4IubhQacMqaxXQT0CcPYo5L61yN9JLcNd37PcU88d5bvv9GEm26PQWqaTqbJPft4PZ7/TyOWnh2OK6adxD+uPoRZDyxEXEYUqk80wNBkHbtTvasYRmNaN714Vxh+71k48tsdkh645K+L8N+LPkZTlQEb/rkXUy4bAbjfWj4oCNaFU3FqgzdqIZJGxYmDwcKxot0V+OQXW7Hy17OlTmbtI7tRfdVoPDSlwO1TRqfrtqsrZF1LS9fJWmqv/OaIwXi91XM08jlDpfsmekk68r4qxT0HEnD20CIUF7Tj8IE2aLSsH2uFuR3SX//sm9ZIJXn22Wfxu9/9DvHxfVPtdMviJA/Rif5uW5tFcjE/ebDzi9rCy1zc+eWIR59Kwt9+XycVl8NGaJ1eADwhzFMznzPESSW4Ix54cgjqS5sxJWSEVJkfWXMUc785Hk2VrSjYWtbNgJO6wibo9FpEpYR3m6hlg2HrmuMNKDzVNsC8rhzvYmD+YmAdH1TjfU+NN2ZoVIgYx67yfcx73XVH/+RmX/lfE+79sfM6h7LSdglnp2WESv8pw/UUl3jy0Xo8/Pck/P2PtVj1ky8x/vJxqD5WJxsnVtiuGarrU0Xsf4vmICY1BJc8ukja2RorWzByaboU7NScaEDZwVrA9fG5CkXQYB+lodpd0ug47H0rD9v+lysFpFQJG7U8Ay/UZLm8LrHynV7iw2+lojVZg1dyh2LP/x2DyWDEWT+dKZoPitPc+flF2PCPvfj0V1tx/v/NQ0xyOObeOgENmABkVKO0ZJdMiYuP18qQrhffs9ZykScfq8dNV17cZ+PttgF//NF63H5PrORi6I395uk46ML0MoWoJ2wXD9vBKF06b1GYVQylh91bS50B7W1m5G886ZYBZw83KwMby1pEaISKRvTgeTGf9ZOZDv+mva0d4TGhUuldX9Ikj2UPs06vkSIsSgfyORhOn3b1KOx9J99hDtr2PrxtxGnAmLfn3G17zO2dWxX6wsb9GT0+x/jJISgtacft3z1dGLN4eQQ2rGmVC/J3jyXgW9dWIarkBAoM7fjW7GN48a0WPPQXx3kxZ/A8sm1uwz/fx/e2XCGfI1vpmmsMklph6JApg5LdlaeqXoOPQMoZDgb8JYzu7Brhhj5lXAL2vpOHpopW6EO10l8eFh3a67GzpenhX9bgaHWshIN1+iY0lbeIuuLsm8ZJITFHCG96fB9mf2OcPH9sRqQI0NChYXtpQ3mLrKUNJ1sw/ZpRDsVpgo3olAis/NVsKdI9tLoQl/719MQKnrMCnCXfb169H42RVfI5GA0mtFQbcCysFAsWLJDfb926FUePHpW1l4VtLS0tnjfgNZmjsT5uvHiaB4qOo/5kqUvi9rYLjGMGM5Yk4auyFrzyYkW3AjUbDJ/vefMY5nxzHIp3VoqUaeKIWFFMC4nUd1JFY1vVvnfykT4lUQxYwrAYqSznmLf2dnMnERZnzLppHA58eFxaBjgSs2hXJUYsThNxlsiE7h7t9ucOYfTyDCkq8wVdF3F+yKIzTTWkU8fHG411AzZluL7S298WHDNJdXrXx33/Z/EylnDXVgNamikpy4E3R5F/TpLkzt05JrnIW01S5XnuQ3M73SwcknLk8yKkT0lCzut5uPKJpXihRut3C6tC4Svsax2YDsxbGy6CMGlTErH79TzMu9W60e/JiN/zKz0u+P1FmG62SDeOVqdB+tRkpE9OEi0IwnVVIplbyqV26Kt/7JWUHjtjWKC669WjyJiaKLLTNOCDBa1ei+/vuBIvXv+F1OdkTE+Sc8AoIT8HrtcLvjVJ0rQb/7UX7SaLOJoWkxnl5eVobW3Frl27cNlll2HIEGt4vaysDPfee69nDXhUcriMUAsJ10kh1TkPzhGj6grMK7c1GZG/4aT0YU/tUn5v36617718TLtqlHi5vEC4u6k4XCeDNBhSp7FtN5lhNprR1mySgeos2OBuM3uutXJwyMQElO2rdtoz3ZVx52Rj58uHMf3q0aLf7QxuLjg+rifj7Yud+vAFqTix+aS893Zju4isjD9vKOaN3Y91uzO8MsuXI1MzsnVoqLOgtNgkdRA2mB97/IUUmVH809/F4/KzyvDP55KxYIl7mxyb8V714Hac8cPpnVIa2fNSUbq3SjYvMWmR+Mab5+D129bhoj8vVHlwD+Po+lXRAP//zCzxFpQuzhDdBZOhXaYErnpoG5Z9f5o4P7f+LAITw0uRla0XidaRY0Lw95wpSB5VKM4YvxhhnHjhMLz/g02IH9pZDMo+BXkx7zu2el5nrRdihIz1Oclj4lFX0jxgE7oGAtqqm15dIeOYz/zxDCmYjk2PRO6nhZhwnrUlLCIuDMMWpiFrRkqHLXn++ecxdepUFBYWoqCgACkpKaLGFhHhWieRW6v8sHlDJI9MA8viIZu4yNMXfiS7i67UFTd2fE8jPGp5pvTNSdizSzUyQ+arHtqOsgM1ItVJhSLCi7BkT5UYKYay6XlNvHA4plw6EtOuGo053xgvnhl/bjPe9MphtsiGw1UYop3BQrfVRRIpOLm/uqPdzJ4ja4rEOx9o4jKjcWJzmRT5bflvLpb/YJoMF/hkU7oM//AG8QlanHVOJG65KwYfvtV5sImNpgYLtm0yYNOBTLeMN40Dv3jOX71lrbTzdR1Bya4Ayt7GZEQiY0oS1j+aI1Xvhz51v0hH4Rxnm0/+3P5rMOLvmxh6e3+8pRQrfjFbaoFy3jiKzBkp+Orve6VAlxHGbcUJyDtixENPR+O+fySLHvv8OyZ2PMfEC4aJmuM1Ty/HiCXOhUzs4X3L9ZnzE0afkYFPf7kVhTvKMZjQaDS45b1zseaPu8TxZA1W5ZEaHPy4QGqo4rOjcfjzok425wc/+IEIuTzwwAMoLi4WQZeQENdarYl7ZdMWqs9YJPdoEzzh7otf7z+wERv/uU+mZrEAjfliVg3To2Volz+ztT7RQHNiVfLYePngma9urTOIEQqN7Hzw9IYpYEIdcA7nGL6gd+PJXSCN+KSL3Bv1Qm+dmwNb/zcveKaD6dlzs8BcD086d1K94QsvfNkD07D33XyMPTtLhpwwZ5xyTSRSUnWilzyii5xff2El6tcbWpGYokVElEY07bv2i3cefNCHRdECXPiH+ZIK6Qr78dnzypBVTUEDLv3bYmj1GoRu3YlgdcF92Qrm7vWqcvT+DXPVtUWNct/QIaJy2IjF6aKFwZansHYzjq4twopfzen0d7EZUbLuDpmQ4LQehiOKv376gERBcz+zqi3GpEXgvm1XWtfI+DBJYzaebBGJ6mBVUOwK5bf14TrUlzbJ9xaLBiGROpz4ugzlB2s6nD/WVn3yiy3489foCJnrdDp88sknCA0NRVyca4JpGosjN7MLbCrnE965+iKc2GT1+rqKcqx6cBsW3jVZCsAYBmeImSIpzKVQko7erW2OLMPwOa8fReqkRJn4Re/ZFThII3FkrORieoIXauGOCgnZjzmz77OIGeLIeTMPky4cJpsWyfVcOkIMiCv014C7u2gf/KQAD19v3eF9+HYTLry871rozuDlsnJuKX71xwTk7jfi8mv7PsDF0fvj+FNu9hylKD78yWboQ3SyMWRkhkIKTc99JgWRd9zr+rjUYMCTBt3X12mw4G9RiJ4+B67JBz46YY00XjtG7h+G1pc/MN3hvUZPnU5MVEoEwmJCMHR2SocRzvuyROSS2a6mDdEiZkiEGPy/znwDD+y+Wh6z7i+75bm5gaDhYuRssFBX3IQPf7xZ0n+0Vazf2vL0QUn3Mi1o6xh6594NHVFetpPZ+sA3btyIN954A4899phopMfGxnrGAz/x9UmcPFArOXCGzTnicsrlI+UCMLa2y86D8N80fFyIWWhFo2s/BJ4hz5l9GAxP48mQED35ngap08BSFYcCByyA49xdwtzq1v8exKK7p/T6Wgx58D1Mvni4tG3xQ2EIxFXj3V/6sihSha2xIQwlRSZpXfDWsVzwRB3+9PBOZM/LhvmlEzjr3AiMHh/a7/dXlluDVb/ZJtGbC/4wv1ulP1v9VvxqliwkjDyc3bIBfz5kxNDswTH5yBtG1xNGaLB64r6qSvfEueWazGpyG1x7+W9GNh1pXjAEzII4OkP0tpk2zZiaLIVZGx/fhxtfOLvbWsiaFLLnrTzx9ElDaTPWP7pHirrYejsYPPG4zCjc8OLZWPunXRKtZXSC7/3z324Xz5spXxZM37v5cod/n5OTg/XrXVPQc2vla60xYuFdExERG4al35sqnvi739+IjGlJ8r2Nw18USZEV87Rd4QXBkLS7xttmgBmO2f1aHsafM9Th89szdPYQbH/hkIRjaYR58Y13IIDSFe6KWAXPXBD/jrBgbDJFQ3xAX29YqvuwiIyCMkvO7P/ITUql/uqVDIw7x9SpsC9pZBzGrhwqG7m95cMQt6UQLa2Q+cR9fX+sl9j/3nHc+MoKqfL/9/L3sPi7U6SY0XbTn/e7eR2Pv31hIR55qF4mzK28YODGiwYqnjY8g1X1LZDfL50gtoM5w3bPM/pI54wyzqyenn7lKIeODAeqEKZMJ820FmpRXvmOjy+QIUu7Xzsq6U12C1H8hMJalEOmoxeMnPGjGbKu7XrliLQfn/2LWdj0+H4svGuSrGn2a2pzc7NUo4eHh+O2227DlClTsHTpUs+G0DlSkoVE9tDD/uL/duCsn81E7YnGjn/ftfriHkPh9Ka7hqu5y2PIffx52VIgx0NjWT4NL3sQGf6h3Ckr0JsrWyVkz40DQxO2ojd76H3veeeYbBYYzulp98fX4vAUjsrkHPBxK63qOoSVz/xb9vV5e5Hs64LgDU/gmZK5shnjeefnw82XrYWvPLdGhpfYQmPadz7D5ddFISJC69b743MWbC3Hew9sxB0fXdARzmO4jwWTZ/98lsNOAn8LXyqCw6gNJhhGZ8GuK622Ng5+fAJjzs7qsbunqaoFm588gFHLMjFiUZqE7/lvprwYVVv7yC5ZW2dcP0Y27Vzjz//9vKD1zg0NbbKe0aEs2FYuGuvMibNn/ttzfoINGzaImEtWVpbkv1mBvmzZMvm3R0PojmAfcua0JDxx5vvy76Xfn4rmqla8d/9G2V058rS5m6OKln2h0v738sWr5tAQtolRBKC5plXU2Nh21nXICAvKOE1Mo9fC2GTE5MsYyg/rmMpVcaQO+RtLJFTx1V9zsCvjSMfsXe4emR8/uq5Ejs/YbBTRmBFL0qXtouvrcPPgbkFcX/An481jCYmAaI5zi8eUBCtTd75yRIoWU8bFY/Xvd3YY8KKRs1B+cn83db36OjP27DRg8RkRDt/f/g+Po3BrudRU8CLnZ8SbPW1yAs788cxBY7z9USSkrwzWkHqgwUIrrqHuGHC2onF9td2XdG5Y65Q6IUEcK5sTN/+OCRIppQFnF9GCOyd2pMSYjkwYHiNOGguaLRrgX8vfxXdWX+KzFKUvYQSDaQqeK0afW2vbMOPa0bJhuW7adTLAhBgMnCUSAq1W651hJj0JofDL5slSPe3ommLpRRzlYJ4qldLobZvazOIlcydSc6KxY860bXhIT9DQ2l6T3uHqh3cgeWwc2hpNkkONTAoDr4xRSzKw5408MUAsyGBlOSuXGebh65zcV4VWnabbBoFw50ivfOoVjnvWg9l422BrHr1t5rV4vngz7nn7mPQ2jj4zU6aOsSaBov4fJM/GPcjp9FwcH7t3d5sY8K6wfYWbOBrv6mP1MLa0i8raZ7/eJj2VjqIqwWLk7PFXY9efPLky4oERQq/Ob3Drb7iO7n3nWMdI47RJiVIwTGoLGjtFVpnrJVTSZM2KTVCG3SM0ZvxiAXNIqE7W6fLcWrejnIEE32tPBdthYe7LYHt8u8NdxWWPLcZday7u0EZnSxeNrA3G/hkmZ26Ani2r9RKG95zP7gmGeNmSNuHcYdLPSC87e04qhi2wCn8svW8a1v81RwwCLzC2ivECpPddW9Tk0HhTjYg9e1MvH+n10I6/Gm/CSW3sa2TYh9Wnn/x8i+S6njr/I8y8foxoLzMUlz41SQx917+n/jnn4tr/nLrB1AVguoSiBjy/OW8ek5GIDK0ljYqVVIa7cLztvpw2BCr+asj7SjButoIFrov/WPgOvv3FRW79XeWRuk4bawq/MArLNbhrZxK9dcINfvacIeKpS3vuRyfk9ROHx0iBXERimOSHq4+75nUqTuOV8l0aaGlDyKuTtiCGRWKGRKJ4TwXSJ7OS0SBhdGr18gL48rG9SB4di/wNpRKipeFnOIb5bSpunfvgaTlNZ9DrfuWWNbj13fPEc6YyG40Dw/E02OfaFUDZ03VoOyMIUmhhtohanCtSscGCIwPCEDknHrFgkGkJqr1RIOfm11fif5d/Jn3/3JEPGZeA1oY2SU28gM7hYD4vH8PrYdi8NNlpswWFaQtCXfMxZ2V2pFuW/2A6dr12VNSjeuJEvhHDRlhrMspKTfj9L2tx4+193wgOFDZv1d8Mnqcq1INxcxLI0KHi1DJWQfekOmm/JjJnyw03lcWYcqQCpG1t5IaeGh1dZ1YwRM81nOsC62UOry4S47/47sk4srZY2l7pG7GTieF1aqlTQItevcI1vNZ/s/e9fKnipiFlHps5kobyZjRVtEgFM3dllFclJ/dWSbsBpfgu/duiTiL4VD578frPccW/l3aIx3SFpfnr/7Iblz22SDz9x898X4rqjIZ2xGZae6EdaZp3hfkJhvZptDxRGenKohwIC1vSyFhs/Pc+6fdk6iI0Si/tEbd9cL6IRLAohcWNjHJUHKoTKUF7pBhxZyUSR8bg0KoCDFuYKsNYuHiwqpWV/rxW7FtYmILhDc5QPQvp+DpcKHZMMCAmVoOcHW344uMWPPmytdqVI113b2/DtNlGzJ4feFWt/ma8PY0y5P4BNTi2PnNQJFLp6PTWyUO4puatK5aU5bLvT0XuqkIxwPGZUeJVM1o295bOg5UIc+u7Xz8qETp65zT6NqZfNbrb42ffNBYf/2wLLnrE/9fEoDfgHDix6K5JIuZu2+Wx75BVjKw8JjbVtdYGI0KjQ7Dk3qndnodCLKzeYyCdLcAAAFN6SURBVL+is2ILXlw3v3GO9Amz1YyD7bc8cxDzvjke053M9e4K/4667lOvGuWyfnp/jXh/jbcnvbbejoWSpSw05I3IcLetCIObM35GVHa68I8LJBLSFUu7RQYr8POjghr7JLnjdhbdYOqCubAh4+Kl9YSfPVMtVH3atL5VRh7q9MCDfz694x85OgSRURoczXU/9K7wHSo33n9Yv+OoPsQV2JvMCBfFWY59WYq89SVyHzKN2LWA1waFWFirwsgo65SmXTFKIqtl+2swYlG6U00OdpQ46jF3BD31nS8fkZ5p2odgLGYLGANOXXMuwPSku0qjsuiJBtkeztlmrtkZvFidGW+GXPLWl4rUKT/4Zy/9VPrs6DVyIMbwxemIz+p5l8m/o7Qrh6V40nj3ZGgDwfO2h+eF55gMpYe8tqRjsMGcb44XtT0uCF29b8KbMfeTAvkME4f3rpj2+UPbZYQoeevuL3H1U8s7PsOGsnTckrIDiUmdP6fiQhOGj9LjV3+wGvXpw6yKdO+uTcX+3W2YPD0UQ4frZRFiZXxsnONZ9MHuCfsD3trQDhZY5MlJjdw8uwPTW5RJtRl/FhNz7WNfNlt/WUDKupauUtFMM3JACf/WBivRGSHL/bQAGp0GUYnhOPOnM7qt967CORj1Zc1IyIqWdBudPm4o2O3S183KYMArBvzt73yFi/68QLRgu0LPjUM4OICeodWXb1ot/YCcQdsXGApi0dOmJ/YhPC4MI5ekywVXtMPamuRsV2mDLWib/3NAwjd9EZfpixH3t4XKneNh3yjTIQyb2SrQuYPn5oftIax9YAi8KwyTU/v3/Ifn9/j8u149grBY6yLAEN/Ixemi3BeZHC6Lxvq/5KDssnA8+EjnPFlmtg7JQ3RobbXIZLQ1O9Px03urkX/UhAsuj8KOLQa89XIdUu4+H3+d9YZEh+bdPlGuQfsiRWXIB46udRMKx7CgtKHMtXnR9nATzfWx6+Zaq4e06rLolwJWjHbZe9W836ndATvJdFZTX/XkMgmvs6uH1excyxkml3niIa570EfXFUuarN3UjqseX4aDH52QyZAn99d0PIZS3MvunzooZoy7g1fiFFf/d7n1A7eDuzX2B7LVgDs28vHPvpbQDb3vx898r0+v9dINX0irE1sW6HWz5Wvk4jS5EBfdPQkHPjou3qEjvRruSDf8ay9GLUvvaGHzJraJW/5CX46HlaNUSptwQbZI69pg5f+82ybgy8dy8L/LP8WfH6rt9HeXPLpIKtV7gsItpXur8e3PrSJAHCE795bxUuRyci/bDc0448czUBqdjR89k4arzzuJ264uR84OAzTQiAIdJWSPHjLioR/X4JwLI/D9O6rw7Ml52J21GCdirVEc9rEX7azEZw9ukxnGbIuryu9cAevovLQ0m/GvP9fh8MHArXQPFFQkxDnsnabQlLtw3aU8qqOQPDexsWlRmHvreJGQJqxRsqU7nRlk/px/y7WXUqp0pl67dY3Dx3IN5pQyflUdqxetkLe+86VsyhlCD40IwfPXfIaPf7FFnIPvbb1CtNVZbMeOpb/Necvt9xzseKcKPVwvYQ/urEYvz8Rnv9kmhprDQCjgcu5v53Ys0Bf8foF1bu2pSWXuwk0BC5zqS5okxPPCtZ/Lz9mmFj0kUsaO0jNkiDx1ciJS7SoleaEu+d5UpE1ybZhKMNHXjYR9LyM/Y1aX2ue9G062iGb8luOh+OCtJmxuGYvYjErZ4bPzoCqvDvpwvezw6fja57oMjSY0VZ72LPi52lSLKMnYVNlqbevTamQxsKnC7eF/RgKXzPhKRGPa24GH/pKA98xLsLL1GF64dlVHvyu9eIpK7H49DyOXpiNlTHxHT/rubUdF4S97fqocb1dv3GgEMrL0SMs4fdu8/UoT9uwy4KbbY7ApZVmnxyv6h79GrAIVboD/NudNXP/8WTIfggVtvLcYTZt4kbXAjMaY+g6MhHFd5r/ZUstOFMIalg9/tFmmUrJTZ9oVIzvG/srfLs/EyX3VHd0/tjQnB3dEp4TLc2/6935RJGPBMivXX755NRbcNQn1xU3yGB7XrBtPR2QZTqcxf2zuW3jynA8wZGy8rDkZ05JlAhrXA6Zsg1XJbUCK2Pihstc399MT8oFwsWTOxR5K8slBhOlw48sr+vQ641ZmSz5o7Z92y2J/37YrULClXMT0Jbf9zjHJ3TLEy4uSldQsrmDbA0P8fdnJBjKeXAxZvMZNGSvJbamKO1ddJDf+hn/sQWqaASc/qkbkqYr+sWcPxeEvCqXmwWbsdWFaMaosgPvqsRxc+vclHc9vaDDKxoxiO9zg0WhzMeAGwnazFu2qQGlOldzEf/lrqYxWZUEkj2HebXUygCFzepXc8Iyy8Dn3vHUMs27snDLJmpkiX4wUsQNB+tT1WqRPSexoi2PevOu41KZzVyB7mQk/+eVWhMVsw8pfze52jpVB7x+q8M0z0KmpPFqLpNFx0o9NXQemNLvmrZkWe/EPu+SeufHls+WeqDxSi3fuLZA6l+9vv7Jj4/3CdZ+LgV/4nclSrMp7lPcq29T4lTkzWepO7lx1YYcSW+G2CqlrsXHOb+ZIYSvvR2pEcAaCoxocFtKd8+AcZE5PFnnS6uMNcp9zfWGxK3vNbRuNwUK/tdB7g20EbOjnwspFlm1k3FHx4kmbmChVh/3h8bPelzArF9quRR38kKmkZmtfsGn/Mkeb83qew4KrQGWg2tV4+fDmYb2BrduAuWvKrjpT1OPfcHNly2exEIafDSMlzHXZWv7aje3Y/vxh6Tun980ozut3rJVNgm0x4POwkpahfamUPbWwcPqRRgvxsDlIoSSnSkb4WczAtf87Q47V0Y7d1rpmgzPWuVAsuHNSjxPwqFC36d/7ZNGjfntXlBHvP8oT7ztskd39xlFUHq7Dil/Nlm4g3rM9ea2Vx+rw8U+/lkgpLOgYFWoPc+AUe2L7F699jhedfMlwqT53VlPEY3HWf07vnWH+vuhvHP68UO5vDkoJFP487bUebW5vWuheN+Bk1+tHJIdJz4a7M6r5cLyaozm07rL6DzukaG35/dY5q66w7s+7pRd5xMLOBR2KvkFDS4+Vu1/ujmlUd7x4WKrT+wPzYpS+5fNzo8cFKG9diezY+zrnnZsLGnPm2Pa9ky/a/cMXpDk14Nb3Z5YCoOx5Q7oVRbIPlv3pG/65VzyQ8LhQUQN0hDLi/UcZ8b7BqVhcd0NjQ1GyswJxWdFSt+Lsvsv9jMbQIq2c0akRaDe0IyrZ+Qa2+kQDEu1mWwwUR9cWy/wKUXQcHYekEb13vQSyAffJIOVxK7JRuqcaE84bJuIqDHXTo2IlJS+Q/qidxWfFSB7WHcJiQ5E8yEIt3oSeNL1terqsNG+qapXdPXvrWeTSda63q3AqHA0kPV+Gzdm7Sn0Bqr71BUo4Mgdv0xvg8ByK/nBD0HU6Xuf3pxXjzc0DvQO2tmx56oBsRrlxYUcFN7Ys4LFtLOjhMJTvaBaAou+ocHrf4LW6/YXDOOsnMzH01KhPZ7DAjLllKlmefoKen98fjDdhlI4ORG1Ro0w5o3pcQrZ/HJs38Em3PEOilCdluwEnhhmbTWK0eaKZi+4P9HhYWMFKSldpa2iTvkOFZ6Gow/xvTcSCb01ExeFa6QTY+06+DEKxUbitXIyoq9cN0xxMkRD2kN+7+QrJl/WFVQ9uw6HPCk8/f2K49JvTO7FhP9feHnrerP5liN4633e0zEeefjVziHrZANhHBVh0R6+dIkPMESo8h4pkuA830bHpkXJf9kbh9nKJpAUqWr1W1grWN3GwVjDjEw+cXPb3xVKF3FW6j0VQ9lXHzDdyB8iCIvYs9uadjz93qFQQb/7PfpzxA9dy2syzMtSi8Dzc7bJIjF5r1uwUpIyJk0ll/Jz5+dObpuZx4fYKCVfTYLLFzBPStV2RGogNJztC4hxvmz0vtdNjWID39VMHRaiCNzwn43UNn1O73xY+pCrciIVp0rboLFRO+Ps53xgn1/O739sgFfMvXOp/eueKwcOcb4wXh8mcW9OpG8ce6jiwJSwYKrpDo0JEphvXuaYGF4j4TK+OhWNctB2Fdhhu5AJvk8xc+O1JUujAL1fCt/T4eOFRNP+lG7+QPGdPtNS3SZhX4R04hIT9pG0NRhz8qAD5m07KyEEaQ3q9lNelN8tK8MmXDZfiE3oGZjNVoczSf8o8liOvmKExFrzRqFIDf/vzh/Dmt9d3mnZn44MfbkZ4zOmaDVuo256dLx3BzBvGSFsLw/X2hXjsS2fbzRNnf4CPfvK1/H7WDWNQyhG0LkR82CLDPOPVTy9HSJRe9AgeuLMKJUW9X9eKnlEbob7Beo+S3ZUO7xdiyx8HC+m9aE8EOnpfhnAcGVa2e7H3l4NKbBXEXERZ0chBKD21BdQVNeKrf+6VHDg9dcoBXvHvJdJn3BPhMaEeKaBTOIetKQwjd3DdGGsb2L5q0TzmZ0BhiXaDWYwo9c+j2APaYERbk0kWGcKhNDR8/Lz4eRdsLZefz/7GOEnFMNRHj4Htggxn23PF40t79SQYFeD0o4QRMTKb3tBk1VLf9twhnNh8Eje+skKUqHjs1BKIPTtLNh57387HtKtHueSp8Nr86rE9uOrJ5Yi9azn++ch6RERqcMX1UZg4RclEKnwLu3IOryrEBLsBQvatZhRqShge0+faFX/BZGgPehlWnxlwwjGSjnBU3dha14bY9J5bzN753gZZTBffPUXGWnLx5xQr7iL5b+ZKM6d3L9hggQY9N/6twnfQ2Dkaak9vnCIT3LAV7qxAaIQeZ/98powjpHIfDSUNPsPvEoIvbcaJrWVoqmiVsbMTLxwmwhSOXq837DX20yYkYs/beVLsFp0cLpKQQ8bHdzzXhAuH4dNfbcOKX8ySnT298iX3TpE8/+J7uveu2uBCePuHF3T8O3/UGMxJPYGHf1GDF9/rHNJXKLyNCDAVN0pkq2uKUhTZ0qOw65WjmHHdaNlMMw2U4cCTlciYxrX7zNe0G8348m85WPSdyQhm9L4ucmJLkCt6thnTknBkTbGE1J2x9D6qqCV2eNO8MFlMxDDrlqcPYtfLR3DDSyscLqiTLh4uz28byKEYOLgAsGeUfdz8sv858+e5Hxfg7F/MEoU/wtGmTMnIVy8Vte4y9XLHveuEr3/B7+dJztzUasLwhWkyMIeRA3dgaP2L3e3IvjoK9XWF3QarKHpHtZP1D66rVGHjNdwV9lGzzZJqhbTNXR2s0r1VkvKikeTvqPHhb+R+UiBRQF9IZA8kPl05Ri3PwOFV1ilRrhQgiEe2rRxb/ntQvGqbLq+NdqN1B0g1IHukB3BkLLhBpCffFeYvk8fEYe2fd/XzHSm8CfurZ14/VoRRbMabbVtUXqJMY0/Gm4sLPQROxqMSoDswXP7abWs75tV33fyxRoMSvCyyZD9t8mj3xIiYWmABHCNE19xowDOlVmlhhcJX0MumyqEzGRCqsXFmAEPqHAxFsSYOHKGaJWHbKNuBKbLkb+x5Kw8R8aEOFd2CDZ964O7mI1hwwSlUdaVNEqZk4RLbd9hDHpcRBUN9G0Kj9EjI7lzZzlA6c+hJI2JkYAUX+pAIHXitiu56aoREAxrLO0/0oRhHT6HQrpOrFL7BXrWJkZPe4OfE4jNCXXaG4ZkuoXQvIzuE14FtU9CVmoJGDF+UhuObypx6F7wOGPmhdGpfoXIgdak9Pds92FHet2fImJ6M/K9KMbIHrQKOFqVuAsWP9BE6jD4joyM3TkeJ0qr+1HJWV9woG3ZnKpDBhk89cBYwxWS4PrSEAvXcCVJLlwMolt0/XYT32epzfFOpVCxv/W8u0id3zn/SU+d0KX6YXPC5ePMD5aSyWTeMFU1uViNzI2APxUecse25XPx1xht9eNcKX0Pjetk/rZrqrIanMWY+O39DKdb/NUc+x7/Pfxs7X7F6E1159pJPxLtmP6wLQoVBO61OEfwRrsbKVpnK2NsGmkJGlYdrOxW2MTzNlBe9c4bVu0ZIfY2xxYTjm8sGVW2TzzxwTiHjl6PKR0cwV0698ojEcCmi4KKsC7EWQdn3jdMLYt+4PaxaZvin/GANwqJOtw119Z65oLPlyYb9VK2u8MK96JEForFN9TiFf7P+L7tl8AE3ZZxIR2zRFYav/7X0XafeNSNFFG7htVaVVy8LnS/x5ExyVzcEXaNL/hoNUBscz0KNhNzPCjruEWfw2nC0l+WAKnq8nGNAgaO0KUkD4pEbGo14+sKPcP1zZwV89bw7+OydsqfWVeNNWJUcNzRaLjBnYW2GICmYwb7izq9VLtXJHHCx7flDTr0oVyeRPTr7TejDtBKC5VQehf+w991jePbyT2WKke1z3vT4Ppz545lOIyrcuI0/P9uhLgFhXziN+LB5Q7qlWXxJXz1y29+5+rfclH74k6878pt9eQ5FYELvurGs92uc95azmeCMZtKpmXXTOGu75bvHZECRLzn0aYFUnNsXwQ4GfOaBdx1Z5ykYZicU9eCCzDAO1dk4RYp9xonDokU+05Fwf9HOShlH2Unztwscu8eCOI4kJf3RbVd4Fi4Sq36zXbQE6FVzGtiUy0di85MHcOfnFzn9O4r4sC6C08ocYZNqZYXtvveOywhTjl30ZUWrfaTHmRG195L7Y2j5Ohf+YT5aatu8HhHoD2oz4R0YaWJ607aWOqK+pFlGevYG11J+7XsvH74kKiWizxLLgYxPDDi1r2PSXc99uwu1plmdPP260TA2clSdDqPPzJKLiF4YR4g6glXuCT2EzTl+koPobcaAlfDUv1YMPBVHaqUP+6r/LEP2XGsvNdu7+CX0kLpmTQXFWdiC6AiOJLQx77YJMLW1S4GjOxPv+su2Z3NlQe0pn+dJgyZFeafGuPb19RwZ+L78jbvPoegfbCXjZpgOD+8LR+Fpduys+IXrBZsMqTvqM/cWUUnhg9K58okB51SYnqY9OcPZYImu88aZ5+ZAk9dvWyth8/m3TxRvqa3ZJGIgXfWtCYsuhi9M7dbjyLajHS8cFq10s8kiSlwM0xP2TVI1TjFwMETHUaXr/5KDhXdN6jDe5K61l2D/+/lSsNZTt8DMG8bi6LpibHn6ACZcOFwKJe2fnwuZPfQ8OBzBl/C97Xn7mESUbAqF7sJIA9XrmGryBX0N93s6oqBwH0Yoi3dXiqT16DMzOylVst0sb20JqvLW4Lb3z3fp+ajRwMgVvWKG6Z3N//YU4XGhEoUdbPjEgIdE6mVRpORpT4ViXf+GFw7bfRwNhueUp3fv2yjTryihyfw6qymPrivBiS1lIsHKjQOnoNFLs1+gC7aUS77v4r90XySOrS/FrJvGOsy7Mwc0WNoT/BEWNj594ccdOTv2stoTEReKnS8ekaENvTF6eaZUmh9aVYRiydvl4/J/LBG9c0dFitwPcDPY9TW9BXN5nGXMRXXo7M41Hq7Asa6cpT7v9gk+M+D9RRntgYXFZ2mTEmSCFyONrBFifjtlbDxuePlsfPCDzW49V3luDSoO18k9ZZso6C0qDtc6FKUJdnxiwFkItP+944jNiETBljKE2FWG22A+kheMzXPi/yddMkKmjMnsbg2QOikBidmxYqhpvG96bUWn2dAUf5l4wTCRwiTnPjgHz1+zqqMqkdXpHHrCec6X/m1xt2Ogcae3zt5HZ4V1rm5AFJ7n4McFuPqp5Xj+6lW44cWzu1WHM4TWU+67K7wuWCTJdkS2FJYdqJHQfFdNdZtyFfXWbbUQvqAvUSt6IUwncXOy8tdznBYe+Qu8JzNnJHvdQ1O4BlUyubll5If325AJ8UgZE48DHxzH7R+55n0TOl22jWP18Xqvb36bq1sH5TXkk3dMtZ5x52TLYmIf8uy68FD+joXELdUG1JU2wmKyIDwhVHLc9OC3/++wXFB1hU3djHdXT43wA6UIAZ+bam7jz8nuUZ2HmwZ6/k5/PwhzLP4Eb1KmRr739RUefV4acobd2eY45TLHRpNhbFckgAea0r3Vkg+sK2nye+NNWO3P8bKJg6x62N/h9c4ZA5wUeXJ/DSISwuTaoiY619I53xzncrvWjGvHYNv/cjHnm333wt/41jpc9Z/lDn9nMrSjtqgJgxGfGHBWCfNC6EkohXlmTskhBz86genXjpYFiF4xh1ZwiAXzzyV7qjC9Fy+I+tk22OtLoQEqt3Gn3xvOxuxxcdeF+f+CGKywxiEqKaLXQqv+0FsLCot5WCPhLELjDwSatn9Plc+KgYUOCyWL9717TLo89rx1DPviFyJ/4w6MP7fF5apvFoEyR90f2Bqc92UJRjlQjWsoa/ZLPfagMeAcFUoDTYF8+4Ihp2gp2qLt8IppvAkLztjqQkPuaIKZDZsXzRYwhuyHL053eYfPi4EXXNeWCeZxOE9a4Tu4eWMhIedvV+fVY8oVPYtNeBtOReOAHC4kHA0aCB6uQtFfGHniOry/LBkJzQZk//BybG7V41zkdXts9YkGaUmTWKXGmnasL2vG9Kv6Vzv0/R1XOvX4awsakTjCt0Wm/oLPkgYUvmeh0NTL+7cIM8TJvm56w2POyHJYuW7LhdBr5lxbd8JzDOk5KmB2JyTJi3j/e/kSvlf0IZcVqZcoTM2JRiSNipWCmJ569R2xqmCcS49bmX3I5efkpo5hQEaUXr99Lc740QynrWjuwjz8yzetlhnm/uzhKwYnvJ/Mho3QhoVAc8qQ8mdd75/CrWXd6kS+fGwPdKF93+xyqBDHmtq6gbpu8quPN8g9ORjR+jIcwyrh5pr+9VFzJ8iWB1YiO2ozO3mgGqkT4jumPnHutzu9i/pwXbdcp6GhTcRceluAOX+W3ntcRqRU/ypcRxSc3jkmY2Bz3sjD2BVDsez+aZJ2cVddyVXj7e5jbbB4bvkPpuPQqkJ4CnoXrNRd/+ccFO2skOvpuSs/89jzKxR9xdxuXWcjx2ai5dhJ548zmR2KHaWOTxAvua/8Y+E7eHLFBw5/t/etYyLcNVjxaQxw9BmZOLq653GiHPXZUtN5yIgjSsYtw6tPN4lEq33+unBbBdImJnZ40+604LD1hlXsXTm8uqjXudNcgDnhTKtj+F/nNeW5YPS42ZO99+1j0jtKr3b2TePcnlxnM8Z9Mch9+TuqV3F4grHVBE/BTUv61ER88MPNOPJFsRRqKhQDDdc0OkvRU4fDUFQpPzNWNcBQXNVhuJl6ZPuuo5qGiIRQSaP2dTAQp00uvc9xNFMXpusxnRrs+LTunl546uREMbrOqtH3vZvfMfLRGVxsQ5KAiFHpyN+0QXLrOr0W1fkNmHPLOOjs8tesnjyyusil/PXIpekOK41pnF0xKPT4Fe6R82Yetj93CN/deHm/Tl1fDHdPz+FKaJ2tZZxqxlzfA7uuhidg+JGbxffu34TEETHSg6tQDCR7qzMQf6oDx9JuhrGyHrXr9yF8RCpee86AuGM5mHThcMl9Oypsi8uKFuNuajPD2GySWQOuyLLauLWLeAyrzrmh2Ptu/qDs/bbH541z8VnReO/+jU4NODVtexKe4CLLnVzD1sPQRYXDcPnVmHxqsT3w4fFuni+9Oo4gdQUa6a5TmfhvSm8qvAO7A/zBePfFmNPbuOerS7H9hcMefW2KEN363nkefU6Foi/Qu24rq+n4d8SoNJS/uRHpt66ANtRqPsZPrBPnhV/ckNMjpgCM/T0+5bKRHYXFnPDnSLK1t+N46abVMh6ahckcYJU9N3XQtx/6vIyWDf7Oem1dXVTrN+ciNCMRUZOHdfo5c6UcAmHPxn/t6+SR99b7yB2iPRWHar2q4z7Y4W7a34y3o9dw9Drc6DHnR6Ghjf/eJ3lrhSKYYNTbVrRGwoenImJkWofxJrmpSzq+n3LpCClAzd9YKi2XXaGHzmmAR9YUu/T6rCna+dJhbH02V4S5OCaaIlwzrx/r8zG//oh2IPIpZmMPuRAneRLbAtp8tARmgxHhQ1Mc5iW5w7M3Dqxgjs+Kcjk6QP1oeyjN6kr/uMJ9uKt2JJPrzXx3f3D2euPOGSpiRVufyZWCR2XIFcGCVq9BSLK1gNdY3YCqD7chanJ2D4/XYvo1o8XDpow1lfbsc9/sEOLvKc7VG1zL2XvOMc7sQ1fpJD8w4KJmpnH+gRlb2lF2oLrjZ8ydfLjdGm5vbzbAUFCBhDOmOl1c+fx1xY3Y/sIh2eUx5EKJVVfInJksnlRVvlX6j8MumIfsaTCGou/wZufAGVeLW2xG29eGu+sxOILyqzTib357vUvzlRWKQIBrn63bhxXoMbNHIyyj5xolwmEonBsRnx2NnNfzZLBJb626NrgBfumGL1CdXy8ed0yqioA6w+/EY1nAxmKI1ImJonxlaDCita4cjTkcCWpB/NLJDv+OxRUcUEIR/sOrCnHxXxe6bXj5+At+Px/FOyvR0NaOubdNUMbbizDasfrhnaLSRJnbrgykoe4LzPOt/dMulXJRBA0fbh2CkERrWpKhdG2442JeRz3htqjm8EVpMtQkbdLpn9Ogc711pPfPcb7c1NPzVvihAecOjEMjKJLvCLbn0IumB1258HzEhvR+mMyLLz0/G4e+KBLx/L56zfw7Fr4pvM/xjdaeUkc7bH823s4WK9uoUhWxUQQL7S1t0EaGdThJFpP7NSvMedsPCGJ0k8IrdM6ctRLbD7ZSOGdAtCCHzk5B5dF6p79PHhuPyrx6zLpxLLQuGG8SNnyIDKWvOV4v3rvC/2F647zfzUXK2OApRmHOrq/9rgqFv9Gaf1KK1oipuhHt9c1OH+to012wrRw7XjiMVb/djj1v5eHd+zZIbjwkQif1UI7gMJ6m6t61QBQDZMCZk6aXzalh9Ja7MnRWiojWu7MDC89Klqk3S747FXE+mtms6D/Z81JRkmMVhAgknEUILv/nEpnapFAEA+Y2k4TODaXVCEmKEe0Nd+6LDf/Yi1vfP09avjjKecb1o9HWYgIsmo7hVY5IyFbT6VxhwKYxcA7ztv8dkgIHes6sGHenoImPq/s6F22V1g2ALaTJqseM6b0XWSj8AxZ+dZVZ9OfweW/HmToxAVXHTndCKBSBymf5YzoioA078hAzq+cpkDbsC02tnrZW1vvzfjcPxzeWYdqVo2Q2hjNYPOyO0MtgZsAMONsJON2JxpYDR459WSKCK87y4t0E7D/ejvCRaaj/OhftTdZwC6dEUbJPVS0GDoyypE9LQunewPPCHcHRt22NnpNXVSgGitbjZQjLThHltdA09xUBX326GYbREzv+fejzQkmLskLdGZz6yBQo02uK3hnQeYicumQymEXsnjrQrsriNe07gfDR6dBHR8DMIouIMKlotrRbVM92ACLDDgobA8r7ttH1eDm3fLDLOyqCg7CsZLSVVKO9sQX6OPfTknUbDmDINUvkHnnzHet8CEcTxeSxxY3imLGFWN0/rjPgA40ps8dFzx2owNZytBSV729B4rmzpPc7b30JRi3rPuxdEVgTjwKdhpPNoh2gUAQ61DuPnjESrYWV0Eb0Pguidv1eGErs6j9O1TAZaxrF6dp2NAHvrXNcsPr5b3fgrzPe8Nh43sHCgBtwiqdQ29YZjtp1GHZNOn82hly9BPqYCEys2IDU8fFWkRhFQMJ7nUWNnsTRuFmve+EajWp/UQQF2jA99LGRaCutkSLh3tCE6DskVpnWpGIm4dQyim8lnDUNTXtP4KVHq/DpEas2OmH0tKagEWNXDsWQ8e5ppA92BlzIhcZ46NxUFG4vdzr602bE7RdKqVDXAI05+bCkWVTrWIAzcmmGtGBh4emcmbtw9990oADaUxPlLCYzLMZ2hAyJk1GI0Gm9alzZWaFQBANcazUhB2Gsb4Y2zDUly7iFEzq+P3z3Exjz92/J91TPjDpvlnyffMk8Me7Vn+5ElU6LpJGxeOKs9+V3t753rlfeSzAz4AacxKRGiPpab3Q15C15pZiZVIChc1TOMdBhtSpldPkZu5oHpzZzw7Yj0HCBsVgQmpogu3x7I202msSDKHtpHUz1zcj67kWdnqNx9zFETz/tDfQV5u/euvtLnPObOf1+LoViILHdf6Gp8TBV1kPjYMRyT1DshVPL6L0TXWyE3JPGqnrk/fh/yLrvEjHkn6/ahdinvxb1zWueOUOq1RXu4RdnbN2fd7s1Xo6L/MhjazAt/LAqeAgS2EKYMsZ1QZeaNTloOVKChJUzkLB8ioTooiZ2V29iG0x4dgrSvnGWRGuY17NhrGpA6XOrPXL8r3xjjQxbUP2rikDGfvNsKKpESEoctOEhUonuMjqt3Fs26jdbHa9D3/43jOV1iJpklU1u2n8CeXuasfxH05XxDmQPfPkD03H4iyIJp9jTbrSOZ2RulG1n9SVNKNpRKf+mMED80OgBOmKFp9n8xAHMu228fG/vhbMCtq28Dm0na6BPjIHFaEJ7QwvCMpMROS6zx1qJrp78+KfvReWH2yQ3Z25tQ9kr6x0OxnEXSkyW7qnC9c+f1e/nUij8BbPBJDVG0TNGoflQEeJOTSXrDW6iRz1yq3zf3tiKxn2cYwFMfuMnnR8XpkfK1YuwN2Yq0uFYmlgRAAacxpliLswhUtz+wPvHodFp5N+ctxwSrpPBJnzc6DMzOw2LVwQHYTEh3WaD16zdg9ZjZUg4a6qISLQWVGDpqHJAq0HSCAaPer7puxp1GvSoSUNR+uwXCEmMlkLIqg+2wlBS5dKEJWfUfrkPZ/98JnzJwY9PSMFP102vQtFXuqWuThUFG8tqoY91r43MVodibjOivaZJWsqipo2QDYH83NiO8MxkJC7v/wZ6MKOxuCB9Vl9fj7i4ONyz4TKvGs/i3ZUirUohe/YMKgYX+98/jpI9lRgyLl7msOuvvggXL631aOEZByX8a+m7GPnwzajffkSK3HTR4Ui9blmfn/PI9/6Du9/p+9/3haPrivHefRux/AfTRRxDofCk8WbrF2uMYmePQdWnO5B0rrUIrS/UbTwgNSKGIqtYE+83XUQYYheMh+7UoBTibEBQMPPnaa/1aHPr6uoQGxsbGAZcoSCmtnZOjoU+zHtyis01Brz57ypYTCbx8qOmDMeQqxe7/Twt+WUYb9grm05fwha5125fK6Nvr/3fmcic3nubj0LhCEdFo+VvbkTKZQtEB73yg61Ivmhuv04eo2mxc8dCF+VchW0wGvE/99OA+0URm0JhD3WQvWm8SWN5C2ZOMkCj02H4Qzeg7MW14nW4/Ty7j2HsAMwtpubB+Q/Pl++3/vegmoCm8JjxZhV5SEK0GO+2ijrxmPsLW9GaDxX36XgUzlEGXDEoYZie9RY3/yJTQvTjnv4uWo+X92lhGigBodi0SIxanoFjX5WKipVC4Q7OjGXJ06s6KsXrvtyH+CWT+n+tLhjfWaVN4RGUAVcoeCOEhkjFuzsw+xR+MGdAz98Fv5+PiIQwMeQ2PfmqY/VoqTMM6HEpApP2ljbZkIamWdt6dTGR0Oj7Hw0zVTUgJDnG7Wlmip5RBlwx6GHeTR8fJfr6zNWxxczeSBf/6yO05J/s+Pfei38recHadXtxxg+nD+j5Y2cGv2jI2Yq5/tEcmei07dncAT0uhX/jzEAybB45/nRKSKPvv4mQ6ZGf7UTsPPeMsjLiAdJGplAMNNJ7fsvZ0iNe9fF26KIjoIsMRXuTQRTciv72PhJXzkBbWS3GP/d9yRFaC25OV9EOBFwcF989WYz43FusffT5G0ox8UI1jlHhPtQyN7daNcyJqa7Z9WvR1C5/y5w5r0sqILYcKYa5rR2J583qUzcJjfhgK2xzB2XAFf2ip11yIN54zGmz+pbQcBMaboq1HH3gvxj1h29AG977ZCZfYGw1Yc8beRh/njVfSQ5+dAIntpTh3If6VzWsCF5682xtXjeLOkNSXNcZ4P1y+O7Hkfnt8+TflDaOWzxJvPr+Hm8griV+Z8DXFI3p1LdnjzrBA3Oz+eK89zWUZfu7QLk2uuqwU8u5/LWvZKYxF6Exf7tDft6w4yjOnlsHIHrAq/VDIvUoyanCmLOsYc+W+ragNN6OrsFAua4CCW5U678+hIQzp6F+00HEuVHAxvsldu44xC+b4vHjCqS1ZJU76+U0P/HAg80TGyjcNZZdH+/pc+2JPJT9c7hyfO4+3ptEjE7v9rPFEypxaNVJzL3l9PQlX2B/XpoOFCJ8RCp0c8ajfsshHNqeClNtEzSps1BZkD7g580X15s3c6SBev76e86of5508Tz5nukj20ASV+Dc8KQLZsOb+KMhXzWABXc+CaH740kP1gIKT55rb5wDR8fX0+v42vPqOvGOEq7lr2+QCvW4xROl1awwtNync4u7ngMqZJU8/rHkFUuf+Rzpt64QIZqG7UdFHtbR3zhjoO5Jf7+/nB1fIK1hfTnnzblFHV63K1Xjxx96BbHzxyNm9mgpAg1Ni8dgsimrBvg69mkO3B9zGQP9AXiL/nqx3j4v/Xl+X0R77J/ntaQYpFyxUIQoZmRXYdzKcTJBb/iCNN+LbFgsaD5cglF/uU0mslnaTKIzbW4zIeFM93WlvRHBCdZ7ajCE8nUxEahetUuGB4UPH9Lr41mxHn/GFDTtK0DMrFEISXStVSwYDPkqP7jOfV7ENthP+EDQnxB2oOGN8Pv555ux//33oDnnMozLbhYZ1vxNJ7Ec3qGn89+46xiiJmRJtXDiypmA2SKeOKVnPSEo01fPM5CvmcHgrbv6+dSszpFRoK3HTmLIdUt7fTylUZnC4TAgXxvvgUy7+cv1PmBV6N425P5ygv2N3i70YDpvnrqpY1Ijsfu1oxh5DtBU1YqvnzqACx625gk9TU/nX1pzymoRM3NUxxQ0KlxJe46XxeCC6brwFf6exnBW8xE+Mk0MeFhm7xP69HFRKH7yE0SMSMOIh26AP7DKy8bcn+6FAW8j86eTMdgYTOe+r6Fi298l3XoBKt79Gi9sPYymfSew6DuTvX6M9rA/ff9Vf8DIP3xT/t2Yky8eD/vRFYGNtz14V+9zjvhkfQWNcvKl82Sz2OvfGIxIvmgeElYMrKCRL1JE/rheDrgBVyj8LZfp6Hexiyag6NH3EJqRKKNIv6wFVsZ6bnff0+LQtL8ABX98E2OfuBthGYko+NNb8rOh91/qsddXBKfxccfosP874azpMDcbxHhrI0J7NfikL1P8BopVfmiE+4My4AqFCzc3w9RdDWZf0kDuLiCcxawN0WP0Y98Sb7vqo23iIY347Y0ISXZdZEMR+Hjb+PAaj1swHvuu+QOGXL0U5pY2GKsbnOa2qY3AsbaKgUMZcIXCw90VnlpoT/z+DZkExfY1G82HizH0+8rzVngPS4sRdRv2I3JsprQmUomwK+x6YBdE9NQR6qMYQJQBVyj80DuqeGcz6jfnYthPr+r4Gb0dLqoKhbfJuvtCkUbVhHSfRCZDf9bvRezsMZLSUQwcyoArFH7IyWe/QNb3Lu70s6oPtiJq8mndc4XCk3DKno2woclo+nQHki7sLMvLTSQL3TJuW6lOvh+gxokqFH5I2jfOQnuLAYWPvicSqfXbjohoRsSo7tKuCkV/oVHuQKsR0aLSZ7+QlI09lvZ2aJ3Mw1D4HmXAFQo/hMpvDFE2bD+Chl15Mq88cpwKnyu8w9HvPy3/D01PxMQXH8DxB19GylWLuhVKsqCSxW5sY6S8sGJgUQZcofBTGvccR9a9FyHhjKmIHJMx0IejCGKmvP9LjHrkVrSVVkMbEYbRj96B0JR4hKbEdXssiypD0xJQs27fgByr4jTKgCsUfgqrf2PnBVffqsJ/Q+jHf/+6fL/vyt+j6UABEs52Ls5Cz7xpT74Pj1DhCGXA/RBKZioUCoUvQ+jt1Y3yfXh2iswCtxhNTtXXqj7ZIXUaioFFGXA/g3mlfZf8DrVf7YexxnpDKRQKhTcZ/+x9Hd9TFrVxdz40Id2blFiFXv3ZTiSumO6SVrrCuygD7m9wMAWAwkfeRuXbmwf6aBQKxSAg95a/dXzfVlqDlKsXi1hLV+q/zpWCSm1YiI+PUOEIZcD9DY0GCStnIGbuGCRfvmCgj0ahUAwCsn9+dcf3beV1MmfeWN55mMmJ/3sNprpmpb7mRyghFz9DFxmGrHsuHOjDUCgUg4i6dXs7vm/YcggNHKPLsbXZKR11OZGThiF8WIp44Ar/QBlwhUKhGORk//jKDjW2uKWToA3Vy1xwG4aCCoSmxSNqolIC9CeUAVcoFApFB3Vf7kf6bStk2pgNmTrWbnb5LJW9sh4NO/OgDQ1B0/4TGPvvuxCWoYrePI3KgSsUCoVCSL3pDPl/6X8/R+O+EzBW1ssXu2KovuYKZqMJ5a98KeNIm/YeB8wW1H65X51hL6AMuEKhUCiExHNmdpwJqq21ldWi7WQNYDbDUFSF1uLKXs8UR5ASzq0n45/9HlKvXarOsBdQIXSFQqFQoGHXMejjIjrORNmLaxGSEieGWx8bidChydBFR/Z6puIWjBdpVlvxG7XTFX5owBvzu+vk9pfoEXUef06FQqFQ9AwrzHO/ebofvL3JAGgbxPtmTrx27R5UvbvZLQU2Zbz9KITedCJWjLbtyxvYP7+3X0uhUCgUVkISYzD57Z91nI7mfScQM30EQtMTcPK51dAnxUCfEI32ljZ1yvwElQNXKBQKhaDR6xC3aELH2Sh5/BPUrNqN5IvmgoHw+KWTUf3Jdocqbf7A0fufllY4Ft0NBpQBVygUCkWnnnBbDluwWGTYieTI46OQdMEc1KzJESNpKKn2qzM38o+3IP1b54gUtaG4CsFOwBhwFUZXKBQK3zH+f/chdt7Yjn/XbzuCvJ/8D6XPfi5a6IbCChgr/KtmSRuiQ/KFc5F++8pBMQxKVaErFAqFwmFOfNjPr4GhtBqH7/wXzA0tMFbUI3J8loTS7YVe/I3ki+dhMKAMuEKhUCicEpaeiElv/ERC6ZXvbcGQa5aos+UnUWVlwAP0Q1btdgqFwlfYxocq4+1fKAMeoLuyro9TBl2hUCgGV02XPtDedDAZKk8W5tmeK5jOj0KhUAQbjR5c9wPKgAcD3q6mD7ZNjkKhUAQLjR5e//23jDAI8VUrnFKvUygUiuBf/5UBD+I+dtU7r1AoFMGLMuBBbkiVN65QKIKZxgCYl+Gt41MG3Mv4y4XlL8ehUCgU3ljXGv3UkHvzmAKuiK2/RVq+ar/y1wtJFbi5d748iTr3CoX378tGP1rnvG0HAs6A9+cDcnQyPflh+6PR7spgbDfzl8/F/jgG0/lXKHx9DzcO8DrnqzUnIA24ux+QKzs2V5/Lnef1ZwbiAve0qlwwnH+ijLlC0ft90p/7LNpH65yv16SANeCuGIW+7NqcfdCBbCx6wh/elz8cw0Ay0N6Crz6zQHp/ioEjENeDxgE65oA34J4+oYF48SiCA3/K3XnTG7Lhz+9V4Xu8ufY2evHeGkibEbQGXKEIRPzNiHt7UbXhT+9Z4XsC1XFqHODjVgZcofAz/CGk7uuFSRnzwYkvr7NGD2+OB9p4E9UHrlD4KQO1QAz0wjTQr6/wHA278nDghj+j7uvcTj/3155tV/GXY1cGXKHwYwbSEx5I/OU4FP3DVNuErPsuQdz88X6jTBlM16YKoSsUfo4v8uL+tCj5az2Awv3rKWT4klP/Do6z1+hn90mfDHhMXt8d94ZR5j7/rUIxWAnWKtreUEY8sHB2LZkNBiAkBK2HjkCfmIDQ1CEIBiGwgDLg0ce00IX1L+re1fgrg65QDN4iHFdQRtz/cXYtmerq0fD1FrQVFEGflAhtRDjaiooRuuJMBBKNfnqvDHgInQZdGXFFoGPbmHr7WvaUMfPXBckZyoj7L46uJYvZjMat22ExGgGzGfohKYicMA4RY8cgkK6nRj+/TwbcgBNlxBWBhrM0kqOfe9qo98eY+fuC5O/tdQrHnwkNtkZrvfZb8/LRvG8/wkYOh8VoQtPefTAcy0fCOWcH1OlrDIB7xS8M+GAx4oPhPQarp9yfug9veOd9MeKBsCAFgzfu7nn25/fiyntsb25B0UMPY8gtN0t+u2HLNiReeiGqXn8LLbmHEDllMlrNFmj0fmNueryOAuk+0VgsFktvD6qvr0dcXBwm3fkwdGHhXj2gYDJwPS36wfQ+/ZH+GFxv4+nPPhhCgX3BXwyfp86tv7wfd99v3Zp1MNXWwVhWBnOrASk3X4/mnL0IGzkC+oQE6ONi4a9Edznnvr5Pjt37QI82t66uDrGxzs+ff22JBpHhCBRv3NzaisbtO6GLikLUjGkOH8M9oKmmBiGJiRgo/Nlge/uzD0bj7K/qbb6SlvVHg+7svUfOnIH61WugCQ3FkOuuQVPOHrSVlEITEoLw4cPgzzSe8sIH4h7yxJrldwY8UAxboBsRV2nY9DViFi9Ee32D5LUiJ0/qMOzNe/cjcvpUaDQaVLzwCpKuuBRhWZk+O7ZAPt+BfJ37I44W4ECvE/CXnH9v56PlwEHEnX0mtBGRqPnwY8Sfcza0SxdL3ts+N+6vNPrJ5x0UBjwQiT6qESMWjIu4LjYW2tBQaJOT0HIwF/Wbvpb3So+bhr3hq42IXboYUVMmoa2wqFcDbjO69NoNNeUIjU2AVh+KwUggfP6BTCAvzP5gyF05f9zIN23fibChWdDHxSF67mw07cpB7OKFCB810ifHGYh4yvnwSwMeCAtb84GDMDe3IPykBbVaHU0SYLYgfvysPhnzQCB2ySIxvJa2NmjDwuRn0XPnSJVpxPhxMJwogKm2Fvr4eKcXaVt9NZqKj8n3YQkpqN6/BfFjZkAfGe3RY21va4U2JEw+C4vFjLa6augjotFYdBhRmaOgD4+CPxAI17picBhydzc87U1NqF21GjFLFooBJ9zAM3TOtFv07JleOU6Fnxtwf8ZQXCJCBImaYQhPSgMSTv/O2FgnBilu9BSXDYSvFnAaXnrQNL7hI0dCFxvT69807c6BNiKi089oEDWnjDfRRUchesZ0eR+WlAw07jwEU3MeoNXBmDkKIdGdF4XGoqNInDi3498RqUNRtWcjkqctcf89mdtRd3QvoAHix0zv9DnU5e2BLiySD5KfhcQkoKn4KKIyR6OpOB/thmZotDqExScjMm1g83TKiCs8aWjtDbw3oxB1q9ches6sblE3qqxxjVR4P/XntwbcXxc13a6TyJgwz+HvaKziRk5C+bYvkL74Yr/xxBnSMpSUIHbRQmgjI9F67BhM+2oQMXY0QpKTReaQhSeMIDBnxZA5Q2MsSomZPs3li4/vN2aYdWiBud0knnb98QOISM5ARGo2Sje8j8jU7C5/o5WfVe3dJJuMyLRsRA4Z2u25G4vz0Fp1Us4vH1d/bB+aivKQecaVaG9rQdW+zUiavMD62MLDSJq6uPv5zxot/6PRNrU2S0dFS3kxanK3W3+emIbwhBTx3B3RWlOO8IQhg+p6VwQe3jTajDwyNG7IPyEiLc5SZpZ2k9yn/rIGBit+a8D9CRq19k/3yMVobjeiLm8f4kZNdvhYc3u7GID21iYJ2Q704m02GtGSl4ekyy/tKCaJHD9O/s+iNN6I0OkQPXNGpz7N6KNW44q8vr2uVqdHTPZY+b728G60VJaIUQ2LS+r2WHrANi+45tBOCXdrtBo573SvzW2t4kEnTVmImoPbEBIVK88VP3Ym9BFREn43NtSKd29pb4dGH9rrwqEPj7S+dupQ+SIt5UWoP35QXk8XEQ2LyQRtSCiis0ahsfCobEYYKZDIixdQRlzhz7SVnhRngH3f5oZGKVZzhi4yEqaqaoQkd7/fBzMxHi689WsDPtALWsjWcugjYxh/Rm1rE6KzRqNi13qEJzpfwENj4hGVMRINBYdhrK9G7MjJLi34nn6vrcfyYaquEe867szlDitBbRXlclGd6PJLD26c48eeDm/3RsK4mWhrqLUaWB4zIwIhp4vc7MPvNN42ooeOQWt1mRjusD56yRFDsuSLGGorJATf1lCDk1s+Q8zQcfI5hiWmIpiveYXCGYbjJxCamYmGjZuk/ifujKVOH9ve0oqIRLv8osIr+LUB96XGtKPXrCw8LLnc8MRUmNsM0OhCMPTsa3v/+1Oep7GpHpW71yM0LkX+rdXrJZRsNrSIkYoZNg66UM8L47QczZNNR9SsGZ080UBpu+ImqAPWB7oIPydPERaf0rFJiBySheK1byFhwmyfhASVEVf4G+0NDTKIpOXIUYRlZSFqpvNNubnNiPb6er9vH/M13lh//d6A+9KQ8zXMRgOqDu2ExWREVNZoyd+2VBQjadoS6EId50adwVBv+qKLOv7dbmiRPK42NExyxY2FhyTELd6uBdAc1sI8O1OquUPT0xCameH2e2DYlyIKcUsXd3pfiv6RecYVqD6wVTxwb2y6uqKMuMKfYO0MC3iTLrsYrceOozXvGMJHDHf4WIuxDaGp3o1UKQLMgHt7YQvZVoGaskIpiIodPhGhdrnaiBTPiJPowiIQlTGi499xo6Z2+j0Lv6qaCmViT8vRo24Z8PbGRjTvOwBNaIjks4ky3J6FOfeKHasRnT0OUemOFy9Pooy4wl/Q6HRIvOC8Dm88evYsp4+lamN7S4sPj87/8dZaHHAGvOvJ6K8x53OxwKqlslRCpAMJC79S2kegIdYMi6HNLePdlLMXMQvmdYStBrvxTjjU+/mrGeeegAxTIEPmrEDV3o1orSyBRqeXdkGToRnxo6eiLm+vVN+aTUZEDBnqESM/ECkkb9P12gym9zYosFikxTRuufMcuKo+9w0BacDtcWSoapJrJMTDggv2JDp7vNlkQuW+DVIBnTDe+Y7S18imIjkJ9Rs3QxOil35lDgUIH3Xae7cPmXP6T/SsmYPOeLtipN35e1cMOs8xK9F57bTVVUqOnJ0Hlbu/QnT2WGmJo3BMY8ER2RgyBeMJAt2Q93RN+mIEq8JzUAciZpY1yucIdo+4MCNr0BDjxfU44A24IwUu89qDSJs0H/U5+6CPbXcYAq/PPwCzsQ0JE+Z6ZMKavTFw17NzRPjoUdKjzV5sXVQkWo+fQNOefYia2qV9TauVlg19fJxfGm53jKyj89ZfI+2tz5DeuH13wZA5p1tq2H7HAsWKnetgNrQiNCEFIexmGGSG3N9GsCrcgwqLnC5mbmiQThYbxpNl4oU7g/3hGp3/rUUDgbfX5KAw4M3lRWgqzpMiM+78WCBGT4k55sqcr9BcVihKXTTUNnF95roTxvXP63ZmXPjz/hrx2GM6NIw6XY3NqT4Mk5vq66E/NV6OsqUtBw+JsII/Ge++Gl1fGmtXj6U/n2Py9KVorSpFVc4GCbez1c1TuXNvGzh/uZ6UIR8Y2IJKueSoKZNFFlX0FXQ6+X9ISnKPf9uSe1gcEIX38bkBNzY3iEIXxTNCY/s/frLh+EFowyIQP3aGVH13heFO9gcXrXldwplhiUNOFY9pvGpkPGHEuxYxhWZloGnnbsQuW4K24hLp9c5MWwRNgxu9Vl7AnwyvPxlybhQZ/eEXZV+5keSGMjJ9uEO1uUA2tN5GGXLfwc6Y5txDMDc1S0EtHQROJdRGRcFUWYlQ6p3biT51hUVuNidDEUQGnG04HGYRkz0Ouf/7HYauvJ6rHEzNDUieulhsan3+foQlpIoYR2+FEFTeai4rQOq8c3rtD06cNA9Fq19H5vIrRKSDxUbeNlKeMOL2NOfsFYnT+vVfSQtHVqbzIhJvE8xG2xspEtYx0PtmvUVD/gG06koRnpTu4aMMfpQh9w6M7LH9VFQamcNuM1p7W2kkEuKhjY6SOhx637bBJT3lyNubmyW1N5iJ6cPm+tChQ9i6dSsyMjI8b8Cr9m1CaEwC4sZMk+IpjT5EjCyNKGhsLRYYG2tFdjJp2mI0FR6BLjwS7a3NMgGKpM0/V/4/9oYfWRWzNGz8N6D64Fa0tzQhND5ZctPV+78WbWtbyJtFQ80nj0t7F/PXNO2akNBOucee4KZh/Dd+hvr8gyj87CWMvOI7PiuU6o8Rt/fCY5YsAijVGh7uc89rsBlsr3nlGg1iR05C5e4vlQEPIEPu6v3mzvH402akcet2hKSkwFhZJQOMmMOOW35Wx+9DkpJgrKqSkaG9vSdDYSu0M93TzFBYeemll/Dggw+ioaEBrqCxuFAuWF9fj7i4OIy86rsIjYpDQ8EhkbdsKSuURYh5vsTJC0SkhLDXmbOeI9OGizAKoZFn2NxVfXAa6bb6Ksm5UM6UAyq4GeDmYOjZ1yA8JbPPrQqmFuqUR/nUYPXXE7e/yX1pvJXh9s5ny2lpDcdzZfwsN8WeSCcNZrxhBD1xn3Vsvr2wAfAkLJBleJxFa9BqEHfGso6RwYSOFFN29L7tf+7ofTWXF0rEyb4Doz/vy582Oq7i6ued89j3rf/PycGuXbvEpt10001obGwUm1tXV4fYHtIRbhnwSXc+3Klim14xq3G9DcPuVDGTXOKpYopANFr9MeK8eH1luJXR9s3ny46JmgNbJY3Eza2xqUG02KkDb4tuKfqOuwu+P9YT+NJoyZS/rzYiZu5sifL15zwxXWo/t8BTBIoRj+lyjmi/mkqPiw1jmphRZkar//bAHfL7hIQEnH/++d1sbm8GvF/W1xfGm9h7J4FqvPuLMt7BByVZWane3mZAZc6XSBg/Gy3lhTA21KD20E4ZSRuRmgWt3nN1FIMJfzTI/qrGZ6qtQ92adVI9LvlvJwbc1XPqDR30QDXeLRXFEqVm+rfhRC4SJ83v2JzfcMMN/XqtoGgjC3bjrQgM+lrvwPbH1Dkr5HuG0wmLLk3Njag7smfAFQIVwW3EKRili41BxMTxMFVWoWHbdgmhdzXC7myIrKOAB5/xtsfU2oTKnesRlpQmm3MSld5djKs/eGybFOjGL9CP3xOoc+A/cKY8d+yMOHHXTswmdY0OVryq5hUfB5jaEZqWhtjFC6VQzdzS2q/Xp+6BJ4y27SvQaGMULXcHhsxdKSOSvYXek4t9TwbAk+1UnkYZLnUO/BXqG1A3gUWdVXs2YPjFd6jc+CDFW5545KSJkv82VVRKGD1s5AhRf7R/XV8RiMbaHtu5qjuSg6SpC72eZnbr2eOPtkGv1/qF1KjCc6gNjH8TlTnSqqueOhTNJ0/4ZBKaYmC8NvZg209C9FVFduuRo2ivb5BWVW1ISLfXcxcKF3EmAGWFB4vxtn/vxBe1K/pAlan09LH46rX84T3bo4x3YHzGbMlhWLK1stTjz60YGBoLj8DYVCfT66SoSaNFSEw8GouOyGfNjpuEiXMdRlw87o1rNAhJHeKxImFOVuyr2mWgEn0EaCo7jtIN72P4Bbf65DX1/mg8fGXkBrvxGuzvP5Aw1FaiueQYEibOG+hDUfQTamMYm+rRbmjuKG5yhLGxDvXH9iFu1BSve+MRY0ajef8B1B44KD3csUsWIq6470pq3AiY21qhC4tAsGMxm9G4ZRtM1aHSJpZ15tXQR7qmd9Jf/LIKXRkWdY4VndGFR0ieUvWGBz6tNeUip8sCp54IiY6DpkInnjoH4TgTpLIPc7tizFuO5sFYXoHQ9DRRWGMFui0Xnho+WYRYjF/mAU42Dq4QO3wSag7t8EovuD9hrKpC6+GjSImejJAhnpk4GPAGPJjxhzC62iAF3mfMfBo9I0Xgw0E2LeVFLm3GYkdMlPqH2sO7JNROmFc2tTTC2FyPiKQMhMYnieoln88VY85BI2wX00ZGonHHLmijIpCRdDqyw1bG5pMF/XqP9MCDMf9tsVjQvGefDGwhlJ2Nnj8XIccG5t5UBnyQoYx3YELp1djhEwb6MBQegG2BHGrjTv2DvSypTRxElClpUErzUb1vMyJTsxGWmNZR+eysAK2ptBkhbfGIaUwDstNkKFTV3k0S7uYoZspdh0TFSaif7Yx9gSqdnmgl8zdacg/JVEh9fHxHvcBACgYF3xkOAAbKC/e18Y7YV9zxfcvkTJ++drDl2NpbW2QmgCLwocBHdPa4fj0HjTeh1x2VMRIRQ7JldkT1gS2SM3c0Wrmh8DDa6qrQVlsp1xK/p8plzPAJiM4aLUa3fPsXCI2JF8NNad+w+L4OJbHIQJRgwmwwoL2hEZETxsNfUAZ8kOBL421vuJ39TBl0N/Sp8/dLK5nCM7C6u+bwTgnxcrKitWLad0RnjkJVzlfQRUQjfsx0j8iO0uvm2OSQ6HjU5G5H8tRFnX7Pkc0tJwvE8NO4c5xyw4lD8nj75xgy60y0s8iuoaZDFbAvcMIkq+qDiaY9+xA1Y5pfyfUqA67wuvF25XHBZtD7G2VpN7Si5Kv3EDtiEqr3b8HQldd79PgGM9wQxQ4bLxMVqTnv60IrGs3EKQvR3tIoBWoxw/rnjXeV5Q2NTZCcuTY0TDYL9KbbjW2IyhrdoSFAYaC0RRfK4Bx7eE74FdLPaE/d0RwkTlmAYEIj56f/PfKeRBnwQRBG94X37arhHqwG3R1YXXz8o2cwZNZZCEsYgmHn3dTnXKSiOzSYdXn7kDB+FsKT01G1Z6OMdW0qypMJcURGvMYnS/oiJDrWrYIsVyjb8hnCE1Khj/J8WiR2+ETJX3NITvmOtfI+GS63v4ZYHOctuPnUhoV7/JwNJMbKKuiTEv3KeBNlwIMcbxvv/hru3p53sBlyqlcVfPYiMpdd3pHnVHiW5rLCjiIyVoSzQIwea2hcMmJHThKjTYGV5rICaLU6NOTvR/y4mTISsvbIbiRNWYTmshNoq6tG0uT5fToGhrF1EVGSv/YGNNb8Spt/LhoKDkuum5tBX9BaVSJV8YGKsbwCrXnH5PvoeXPk/837DkhvvD8Zb6IMeBB74cFQcR7Ihrwvn++Jj/6HuNHTvDKOUWGtKaAoDou2bLA9z15QhedePPBTOWCZ5Vx8TNTKOP6VYXfKncYOH4/y7asRy35pi8VqlF0ULkmetkTy0gw19yTm4glissfCl+jCIkWkBnAuCeuvLWRNu3OgjY6W1rCWA7mo/Xy1pCKiZk6TqnN/Mt5EGfAgJRDC5n19rUA05q7CNh6OElWCLf0P49ITpL4426L4RcPcVJLvUBSlJ2iU6ZnbsM+ZJ09bjNbqcljMJrRWlsDU2tytgMwZ7AXXO6gWD3TCElIkosHoRqBhNrQhctpIuf8iJ01A+NjRaCsolAlt/ma8vWrAXVncg3khHkiCzXg7eu1gvHakxae+Gi3lhdLTq3Av9cD+arOx7dQwCY2kIKLjkqXimj83t5uQOHm+R3OzDFNHpp4yVOlAzaGdLg3xoKGnQEvKrDMRbFTt3SzV9YFIaFoq2opLEJZlXV9YtBY+aqRfGm+PG3B3F3Vnjw/GxdlXYfRgN97B+vlSWats2+dIW3C+Cp+7Sf3xAzA21Eo/M8VD+ltB3R9ozLmRYCGZjbq8vfJzhu9tYXlWf8ePmyUjYhlODxZMzY0Ii0/xmRa4p2krK0fk5NPRFuKvxtujBtyTi7ry3vvGYDLeweSFU0CjqfQ4MpZcMiiGP3gSGkWK3CRNsRYYDTQ0XjTgRIreDu+SMbCtVWUitGJ/nNQx14VHIajQamGoLUcU29e8PAvbG0TPmoHGrdsRs2Ce3xtvog/URb2n1wyWhd0dBpPxDjaOvfu4hHvjRk4e6EMJCBh6th+r6m8iN6ExiVL5Te866+xrO3qtWTxXfWBrhwQnxU7ix85AMMH3mjhxHqr3b0bcqKkykCWQsFACNjQ0IIy3Rwy4Py7qvR2Tvxn4/obRB6vxDhYvPG7kFOjCI1GTuwNh8cmISM0e1EVsrAMgNNLtxlbpl44YkiUKatBq0FJWKIV+/krMiIloKjkmBYm6sPCOn/Oz5VewQyGYpKmLJfoQFpfklu77QBvvhs1bkZGxCFofGG9PrNv6YFvUg9HAD3SbWKB+zoGwQWMImKIemWdcIfrRVfs2I7z0OFJmLMNgpLW6DMXr3sKQmWeIZ60NDZfqbqrRsTdbHx6FOD8vkOLmiwpo/Bqs8BwkjJuJxuI8GcRDb9xfW8gsFguadu2Gpc2IjLT5PpfW7Q99PtJgXtQHwrNz1wsPhh5vTxDoXjgXuswzr0TCuFny75hhE2A2Da7PVhbQ4jwp5NPqQzDq8u90+j3TC0rUJjDhJsZQVyXTzhImzvVL42hpa4M+r0F6/ANNfyGwjtaHDMQGhUbZ9tXbY3xFMG/U/Klyl0bMVtjUnyESgYqhugwx2eNE+10RXDCMTjlXjjw1NtXD34grikDCxDmoP7bPZ6/pqTW8TwZ8sCzqA/k+7Y25K4bdGwTK5xwox+kIqnE1lx7HYIbFXJqQUFWBH8SwX555cQ5vaS4vhL8QcyrXrdWFdOjgBxLKAw9i46DwfzhSkgVsgxWGVyt2rkH8mM5jGhVBmhcfPwtmQyvqTnm7A1npHZOnlcJI6tszT+8r8RlPOmL+l5BQ+AVq4+K7RY0jHgdj1XlbQy0ajh9A6vzzBuX7H6xQypZeOCv1vTXMxRXjTe0FQ005YkdO7jZWNVBQHrgLKGOm8CaBGLrzBCc3foCI5ExlvAch1Eln9IWa9b72wmPytLJ5NDbWia59oBpvogy4ohtqw+JbgmlusqtwyEhIbKLfibAofEfC2Jmoyd0uRZy+xGI2o/7YXsSNdtzaFkgMvpWjjyijpvBW37NNmStYYEU9Z27b5ES7wtBlY8FhmI0GGTCiGJzwumftA6Vn9VtOwtzSYhXr8SK6TUWihscRrgORtvF0IbLKgSs6oTYqvoXKXBQq4SJG5S4b9EoCcSAEJ3Gd+Pg5mabWfPK4VNhHDxsPLpUc6RmZMQK1h3dCo9EhY+mlgzL6oDiNPjIGCRNmiwph/ec7ED5yBCInnx4E40mVNfPn+2FoaQyq4THKgCsUA4hGqxM9bHoF9lTsXIvoYeMQnTU6oIwcj5WqW6zotVjaOy2WzSdPoOTLd2FqaULsiIkB9b4U3kWq0/e0os1g8Phzm+rrYV69H/HjZ4vMazChDPggUv0KZu870D8bKpAxnEylKuboQqmZbQFqD+1i0o6WURYfs8kos65DomIRGpeEkKg4/1OP0mgkPKpB59QANbGp807BjLhRUwbs8BT+CT3xumP7pcjMkxKr5rUHkThl4YAXS3pDx0MZcIXCD7CY2zs8UrOxDRaTEdFZo8RDt/2eX1p9qISpjY31MNZXS4iaOWf+DY0ildwGEm4wetpQcBFVxlvhTOyF1weH2cTkJXrEiOs3l0CXnDHgxttbKAM+yDy9YPS+gwGKuZRv+xyp885Bu6FZFKs4tIOeNqEhtxlzGvrQmHj5skGvve7oHmj0emtfuS5EvHpfe+csTmOfr0LRF3jN1+ftRVPxMeCQ1ei2ZYcifNxYaENCXH6emDytRLQqT+RiyJyzg/bDUAZcofADYodPlJ5YKkJpdHqEp2S6VcRGQx0/drpoTbdUFIsnzMIdeuswm+X/LJKzbQi8VVHf3tYiE8MUngu59mfUcKAhERq79i5Gl9jJcHLT14iZPxfasLDu87v1nc2Yra+87miOhM79AW/JYCsD3geCzQtX3rd/wPx3WEIqwhNTxaD3BRpoR0Zael/z90MbGoaYoWPhaerzD0jum+05ioGdVBhsBp1CK5npi1H10Sbr9aXRorx1v4z/ZK0FjXjEhPHQx8V2GG9uhttbmwNapMUVlAEf5Cjj7X1cXXy9KSxBD5255/IdaxCRkuWxhY1hypoDWxGVNRrhCUM88pwKNS64KzTUSVMWoS5vL/eJSB02CdpYqzfO6FLjjsMwteah5tTjTU0NUhQX7CgDPoi9cGW8Bx9JkxegqTQf7a2nBVZozLVhEVLlzkIi/l8XGgFtl9CkIzW1+mP7kThxjvydwnvh1sHshXdKEzkYeqPRaDtpKAwmlAEfpCjjPTjRhUV0C8+zL5t67FRG43hTs6kNZkPLKZU0TcfiGRafIvrR/D0L6hiWT5q6KGgrfP0NZcQDkwQvjoFWBnwQeuHKeCvsYetZb+1nNOZttZWISMmELjwKZharRcYMihPpy2Ky3hZ7ZcQV9viZAoTC2wSz8Q7m9+YPBXbhSWkIiY6T0HpPxptGxptehy+xfx/efk+uPn+wnFvFABhwtUgG7vkIpGNVBCbBZFx8+V7cfa1gOs/BTIKXPyflgSsUin7jyOsOVCPTUwQhUN+TIjhRBnwQeLY8Pn8/RkXg0pNRCzSD58rxevo9Bdo5UvgPyoAHOcpwK7xJMBkfd96Lp953MJ0/he8/W2XAg9hQ+uMxKYIHVXTlm/Pnrb9XBD7KgAcpyngr/Al/NzZ9Ob6+vqdgqtJXOMZXn68y4EFoNP3lOBTBizJAfTsP6rwpfC7kwokwxGRqhcmsdo49EbInHy0T0zFQRBwoBfWzBiu8Rv2NdkP/5xr7GyaT++tAzP5W1I4ODZr3Y/++SG/vLf5om8fvzWC8toIBk4vXU319fY8/t9leZ2gsvT0CQFFREYYOHerSASkUCoVCoeg/hYWFyMrK6p8BN5vNKCkpQUxMjNI9VigUCoXCi9AsNzQ0ICMjA1qttn8GXKFQKBQKhX+hitgUCoVCoQhAlAFXKBQKhSIAUQZcoVAoFIoARBlwhUKhUCgCEGXAFQqFQqEIQJQBVygUCoUiAFEGXKFQKBQKBB7/D2WAbquPtxcIAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Then, plot the stations over the gridded data to see the overlay\n", + "\n", + "map = Basemap(projection='merc',llcrnrlat=-80,urcrnrlat=80,\\\n", + " llcrnrlon=0,urcrnrlon=360,lat_ts=20,resolution='l')\n", + "# draw coastlines, country boundaries, fill continents.\n", + "map.drawcoastlines(linewidth=0.25)\n", + "map.drawcountries(linewidth=0.25)\n", + "\n", + "x, y = map(lon, lat)\n", + "\n", + "\n", + "# # Add station data over the top\n", + "x2, y2 = map(points.lon, points.lat)\n", + "\n", + "map.contourf(x, y, data.T, cmap='viridis')\n", + "map.scatter(x2, y2, c=points.temperatures, cmap='viridis')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "957c60f7-0924-4ae1-ac57-b438fc99c83f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/scorecard/Four-MakeLargeGroupings.ipynb b/notebooks/scorecard/Four-MakeLargeGroupings.ipynb new file mode 100644 index 00000000..f38dc2e2 --- /dev/null +++ b/notebooks/scorecard/Four-MakeLargeGroupings.ipynb @@ -0,0 +1,147 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1b4ae39b-4f5f-4dc7-bee0-a798eba46719", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import numpy as np\n", + "from datetime import datetime\n", + "import warnings\n", + "warnings.simplefilter(action='ignore', category=FutureWarning)\n", + "import marimo as mo\n", + "\n", + "from dask.distributed import Client\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8bf7f65c-875c-47ff-9ea9-8ac81128be26", + "metadata": {}, + "outputs": [], + "source": [ + "# A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work.\n", + "\n", + "PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing\n", + "DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' # This will hold the final form of our data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "db156524-9c84-4257-b351-e960f8b1adcb", + "metadata": {}, + "outputs": [], + "source": [ + "decades = {\n", + " 'early': ('1800', '1930'), # Just in case there is undocumented early data\n", + " '1930': ('1930', '1940'), # Dataset begins in 1930, start by decade here \n", + " '1940': ('1940', '1950'),\n", + " '1950': ('1950', '1960'), \n", + " '1960': ('1960', '1970'), \n", + " '1970': ('1970', '1980'), \n", + " '1980': ('1980', '1990'), \n", + " '1990': ('1990', '2000'), \n", + " '2000': ('2000', '2010'), \n", + " '2010': ('2010', '2020'), \n", + " '2020': ('2020', '2030')\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e205d264-92cb-4a29-b3ae-3ef16a7404e1", + "metadata": {}, + "outputs": [], + "source": [ + "files_for_decades = {}\n", + "\n", + "for ix in decades.keys():\n", + " start_dec, end_dec = decades[ix]\n", + " _files_for_decade = list(PROCESSING_DIR.glob(f'*{start_dec}-{end_dec}*.nc'))\n", + " files_for_decades[ix] = _files_for_decade\n", + "\n", + "# Uncomment this to see values for debugging\n", + "# the1950s = files_for_decades['1950']\n", + "# the1950s" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7cd6885d-635f-4028-bd75-19fed284cca3", + "metadata": {}, + "outputs": [], + "source": [ + "decade_of_interest = '1990' # In the interests of saving time, we process only one decade here\n", + "\n", + "files_for_decade = files_for_decades[decade_of_interest]\n", + "groupings = [files_for_decade[i:i + 40] for i in range(0, len(files_for_decade), 40)]\n", + "print(f\"{len(groupings)} file groupings to be used for decade {decade_of_interest}\")\n", + "for i, grouping in enumerate(groupings):\n", + " loaded = [xr.open_dataset(f) for f in grouping]\n", + " print(f\"Loaded group {i}\")\n", + " combined = xr.concat(loaded, dim='report', data_vars='all')\n", + " combined['reporting_stats'] = combined['reporting_stats'].fillna(-999.0)\n", + " # combined = combined.chunk(time=xr.groupers.TimeResampler(\"MS\"))\n", + " print(f\"Combined group {i}\")\n", + " filename = f'all_{decade_of_interest}s_group{str(i)}.nc'\n", + " combined.to_netcdf(DECADAL_DIR / filename)\n", + " print(f\"Wrote group {i}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c2684bb3-0bf5-4b79-9c62-568bbdf5879d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed\n" + ] + } + ], + "source": [ + "print(\"Completed\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e6f340e-b2cf-46cc-8157-60926434f31c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/scorecard/Introduction.py b/notebooks/scorecard/Introduction.py deleted file mode 100644 index 35537b25..00000000 --- a/notebooks/scorecard/Introduction.py +++ /dev/null @@ -1,74 +0,0 @@ -import marimo - -__generated_with = "0.17.6" -app = marimo.App(width="medium", auto_download=["ipynb"]) - - -@app.cell -def _(): - # https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html - return - - -@app.cell -def _(): - import marimo as mo - return (mo,) - - -@app.cell(hide_code=True) -def _(mo): - mo.md(r""" - This dataset holds the world's weather station data up until late 2025. - - ![Image of weather stations]([public/image.png](https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/images/hadisd_gridded_station_distribution_v343_2025f.png)) - - For futher information please see: - - - Dunn, R. J. H., (2019), HadISD version 3: monthly updates, Hadley Centre Technical Note - - Dunn, R. J. H., et al. (2016), Expanding HadISD: quality-controlled, sub-daily station data from 1931, Geoscientific Instrumentation, Methods and Data Systems, 5, 473-491 - - Dunn, R. J. H., et al. (2014), Pairwise homogeneity assessment of HadISD, Climate of the Past, 10, 1501-1522 - - Dunn, R. J. H., et al. (2012), HadISD: A Quality Controlled global synoptic report database for selected variables at long-term stations from 1973-2011, Climate of the Past, 8, 1649-1679 Smith, A., et al. (2011): The Integrated Surface Database: Recent Developments and Partnerships. Bulletin of the American Meteorological Society, 92, 704-708 - - - For the product manual, see [https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf](https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf) - - It's an amazing scientific archive. The data is held in a collection of .tgz files, based on station ranges. These files contains smaller station sub-ranges, themselves gzipped netcdf files. We need to download the ones we want (potentially all of them), then double-unwrap them, and then put them into a more performant file format for quick access by time index when performing ML training or long historical verification runs. - - Eventually, we want to present these efficiently as a PyEarthTools data accessor which can be quickly indexed by time. An alternative data accessor based on station ID rather than time could be imagined, but we will focus on access by time in this tutorial series. - - Despite being packed into NetCDF files -- which is often used for lat/lon/level/time gridded data -- this data is better visualised as just one massive long list of report entries in a big logbook. Each report is a slightly more complex version of "time, station_id, lat, lon, elevation, bunch of obs data". - - Many underlying issues have been sorted out, like stations reporting twice under two ids, changing ids, station upgrades/replacements, plain old errors, sensor quality control and more. Many stations only report for some of the time period, some only once or for a short time, some for a very long time. What we want to do is get this into a good form for time-series use by an ML algorithm. The files on disk are roughly organised by nominal station number, for all time. So if you know what stations you want to work with, you could just pick those files. But let's face it, who wants to take the time to understand the mysterious workings of station numbers - at least at first? - - Singe station time-series modelling is a totally valid use case - e.g. fetching "station data for Melbourne from 2020 to 2025". That's fairly straightforward - manually look up the station number of interest, find it in the files, open that files with xarray and then select the time-frame of interest. - - Doing the same thing for a handful of stations is also not too bad. Each station file is only a few megabytes, so opening 5 of them isn't a big deal. However, opening all of them becomes a bigger deal, and trying to merge them all together using simple merge and concat operations will cause a computational failure on most platforms (including HPC platforms). Some data processing is required in order to prepare the data for the time of query we want to use. - - Translating between the 'gridded world' or global and regional modelling and the 'station world' is often done by performing a site-based forecast based on gridded inputs (e.g. siteboost or model output statistics). The translation of station data to a gridded model is done through data assimilation. These two ways of working with the data have significant implications for the data structures which will be used, and for computational efficiency. It would be really nice to have a simple API which could abstract away the messy choices, implement the tricky bits and make it easy to just 'get what we want'. - - From a PyEarthTools perspective based on wanting to develop model architectures which include both gridded and point data at the same time (rather than having a 'translation step'), this means getting the data into a structure where the primary index is date-and-time, and all relevant stations are loaded into that data structure. However, the data still can't be simply gridded, as it more represents a point cloud at each moment in time. A few decisions need to be make still. We will keep things "simple" by representing the data for each time step as a list of observation reports from all stations reporting at that time, with a small time delta allowed for stations reporting a few seconds off the base time due to engineering tolerences or other reasons. The "list to grid" step will be handled either the model, or in an observation operator step to be developed at a later time. - - This tutorial series contains the code (and explanation) for how to download the data from the Hadley Centre website, unpack it, and then re-process it on disk to have a structure which is well-suited for efficient access in the manner just described. - - The tutorials are structured in a sequence, each with a specific scope. They are: - - 1. Downloading the data in the form distributed by the Hadley centre - 2. Manual unpack of the data on disk for efficiency reasons (see instructions at the end of StationDownload) - 3. Re-processing of the station data to break it up by decade for file size reasons - 4. Grouping of individual stations into large station groupings to reduce the number of files on disk - 5. Data visualisation of the global station data to demonstrate what it looks like this way - 6. (to be done) Integration of this data into PyEarthTools data accessor - 7. (to be done) Integration of station data into a PyEarthTools pipeline - 8. (to be done) Presentation of gridded data and station data to a neural network for training and prediction - """) - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/MakeLargeGroupings.py b/notebooks/scorecard/MakeLargeGroupings.py deleted file mode 100644 index 588cc76c..00000000 --- a/notebooks/scorecard/MakeLargeGroupings.py +++ /dev/null @@ -1,109 +0,0 @@ -import marimo - -__generated_with = "0.17.6" -app = marimo.App(width="medium", auto_download=["ipynb"]) - - -@app.cell -def _(): - # https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html - return - - -@app.cell -def _(): - from pathlib import Path - import numpy as np - from datetime import datetime - import warnings - warnings.simplefilter(action='ignore', category=FutureWarning) - import marimo as mo - - from dask.distributed import Client - import xarray as xr - return Path, xr - - -@app.cell -def _(Path): - # A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work. - - PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing - DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' # This will hold the final form of our data - return DECADAL_DIR, PROCESSING_DIR - - -@app.cell -def _(): - decades = { - 'early': ('1800', '1930'), # Just in case there is undocumented early data - '1930': ('1930', '1940'), # Dataset begins in 1930, start by decade here - '1940': ('1940', '1950'), - '1950': ('1950', '1960'), - '1960': ('1960', '1970'), - '1970': ('1970', '1980'), - '1980': ('1980', '1990'), - '1990': ('1990', '2000'), - '2000': ('2000', '2010'), - '2010': ('2010', '2020'), - '2020': ('2020', '2030') - } - return (decades,) - - -@app.cell -def _(PROCESSING_DIR, decades): - files_for_decades = {} - - for ix in decades.keys(): - start_dec, end_dec = decades[ix] - _files_for_decade = list(PROCESSING_DIR.glob(f'*{start_dec}-{end_dec}*.nc')) - files_for_decades[ix] = _files_for_decade - - # Uncomment this to see values for debugging - # the1950s = files_for_decades['1950'] - # the1950s - return (files_for_decades,) - - -@app.cell -def _(DECADAL_DIR, files_for_decades, xr): - # This doesn't break because it's a lazy-load - # the1950s_all = [xr.open_dataset(f) for f in the1950s[:40]] - - decade_of_interest = '1990' - files_for_decade = files_for_decades[decade_of_interest] - groupings = [files_for_decade[i:i + 40] for i in range(0, len(files_for_decade), 40)] - print(f"{len(groupings)} file groupings to be used for decade {decade_of_interest}") - for i, grouping in enumerate(groupings): - loaded = [xr.open_dataset(f) for f in grouping] - print(f"Loaded group {i}") - combined = xr.concat(loaded, dim='report', data_vars='all') - combined['reporting_stats'] = combined['reporting_stats'].fillna(-999.0) - # combined = combined.chunk(time=xr.groupers.TimeResampler("MS")) - print(f"Combined group {i}") - filename = f'all_{decade_of_interest}s_group{str(i)}.nc' - combined.to_netcdf(DECADAL_DIR / filename) - print(f"Wrote group {i}") - return (combined,) - - -@app.cell -def _(): - print('donezo all') - return - - -@app.cell -def _(combined): - combined.sel({'time': '1990-01-01'}).temperatures.plot() - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/One-Introduction.ipynb b/notebooks/scorecard/One-Introduction.ipynb new file mode 100644 index 00000000..b53e8ba9 --- /dev/null +++ b/notebooks/scorecard/One-Introduction.ipynb @@ -0,0 +1,92 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a4423136-8374-43c8-bbff-a5eecef13b07", + "metadata": {}, + "outputs": [], + "source": [ + "# https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html" + ] + }, + { + "cell_type": "markdown", + "id": "51995928-e6e0-4e4b-a853-7eec52cf53a8", + "metadata": {}, + "source": [ + "This dataset holds the world's weather station data up until late 2025.\n", + "\n", + "![Image of weather stations](https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/images/hadisd_gridded_station_distribution_v343_2025f.png)\n", + "\n", + "For futher information please see:\n", + "\n", + "- Dunn, R. J. H., (2019), HadISD version 3: monthly updates, Hadley Centre Technical Note\n", + "- Dunn, R. J. H., et al. (2016), Expanding HadISD: quality-controlled, sub-daily station data from 1931, Geoscientific Instrumentation, Methods and Data Systems, 5, 473-491\n", + "- Dunn, R. J. H., et al. (2014), Pairwise homogeneity assessment of HadISD, Climate of the Past, 10, 1501-1522\n", + "- Dunn, R. J. H., et al. (2012), HadISD: A Quality Controlled global synoptic report database for selected variables at long-term stations from 1973-2011, Climate of the Past, 8, 1649-1679 Smith, A., et al. (2011): The Integrated Surface Database: Recent Developments and Partnerships. Bulletin of the American Meteorological Society, 92, 704-708\n", + "\n", + "\n", + "For the product manual, see [https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf](https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf)\n", + "\n", + "It's an amazing scientific archive. The data is held in a collection of .tgz files, based on station ranges. These files contains smaller station sub-ranges, themselves gzipped netcdf files. We need to download the ones we want (potentially all of them), then double-unwrap them, and then put them into a more performant file format for quick access by time index when performing ML training or long historical verification runs.\n", + "\n", + "Eventually, we want to present these efficiently as a PyEarthTools data accessor which can be quickly indexed by time. An alternative data accessor based on station ID rather than time could be imagined, but we will focus on access by time in this tutorial series.\n", + "\n", + "Despite being packed into NetCDF files -- which is often used for lat/lon/level/time gridded data -- this data is better visualised as just one massive long list of report entries in a big logbook. Each report is a slightly more complex version of \"time, station_id, lat, lon, elevation, bunch of obs data\".\n", + "\n", + "Many underlying issues have been sorted out, like stations reporting twice under two ids, changing ids, station upgrades/replacements, plain old errors, sensor quality control and more. Many stations only report for some of the time period, some only once or for a short time, some for a very long time. What we want to do is get this into a good form for time-series use by an ML algorithm. The files on disk are roughly organised by nominal station number, for all time. So if you know what stations you want to work with, you could just pick those files. But let's face it, who wants to take the time to understand the mysterious workings of station numbers - at least at first?\n", + "\n", + "Singe station time-series modelling is a totally valid use case - e.g. fetching \"station data for Melbourne from 2020 to 2025\". That's fairly straightforward - manually look up the station number of interest, find it in the files, open that files with xarray and then select the time-frame of interest.\n", + "\n", + "Doing the same thing for a handful of stations is also not too bad. Each station file is only a few megabytes, so opening 5 of them isn't a big deal. However, opening all of them becomes a bigger deal, and trying to merge them all together using simple merge and concat operations will cause a computational failure on most platforms (including HPC platforms). Some data processing is required in order to prepare the data for the time of query we want to use.\n", + "\n", + "Translating between the 'gridded world' or global and regional modelling and the 'station world' is often done by performing a site-based forecast based on gridded inputs (e.g. siteboost or model output statistics). The translation of station data to a gridded model is done through data assimilation. These two ways of working with the data have significant implications for the data structures which will be used, and for computational efficiency. It would be really nice to have a simple API which could abstract away the messy choices, implement the tricky bits and make it easy to just 'get what we want'.\n", + "\n", + "From a PyEarthTools perspective based on wanting to develop model architectures which include both gridded and point data at the same time (rather than having a 'translation step'), this means getting the data into a structure where the primary index is date-and-time, and all relevant stations are loaded into that data structure. However, the data still can't be simply gridded, as it more represents a point cloud at each moment in time. A few decisions need to be make still. We will keep things \"simple\" by representing the data for each time step as a list of observation reports from all stations reporting at that time, with a small time delta allowed for stations reporting a few seconds off the base time due to engineering tolerences or other reasons. The \"list to grid\" step will be handled either the model, or in an observation operator step to be developed at a later time.\n", + "\n", + "This tutorial series contains the code (and explanation) for how to download the data from the Hadley Centre website, unpack it, and then re-process it on disk to have a structure which is well-suited for efficient access in the manner just described.\n", + "\n", + "The tutorials are structured in a sequence, each with a specific scope. They are:\n", + "\n", + "1. Downloading the data in the form distributed by the Hadley centre\n", + "2. Manual unpack of the data on disk for efficiency reasons (see instructions at the end of StationDownload)\n", + "3. Re-processing of the station data to break it up by decade for file size reasons\n", + "4. Grouping of individual stations into large station groupings to reduce the number of files on disk\n", + "5. Data visualisation of the global station data to demonstrate what it looks like this way\n", + "6. (to be done) Integration of this data into PyEarthTools data accessor\n", + "7. (to be done) Integration of station data into a PyEarthTools pipeline\n", + "8. (to be done) Presentation of gridded data and station data to a neural network for training and prediction" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9e2c2235-5acf-4d42-95e1-96b247d91269", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/scorecard/StationDownload.py b/notebooks/scorecard/StationDownload.py deleted file mode 100644 index 31421458..00000000 --- a/notebooks/scorecard/StationDownload.py +++ /dev/null @@ -1,130 +0,0 @@ -import marimo - -__generated_with = "0.17.6" -app = marimo.App(width="medium") - - -@app.cell -def _(): - # A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work. - - import requests - from pathlib import Path - from tqdm.auto import tqdm - - DOWNLOAD_DIR = Path.home() / 'hadisd' / 'as_downloaded' # We will download data here and keep a copy - - # For testing, we download just under 4GB data - testing_download = [ - "000000-029999", "500000-549999", "722000-722999", "800000-849999", - ] - - # Download list for all files - full_download = [ - "000000-029999", "030000-049999", "050000-079999", "080000-099999", - "100000-149999", "150000-199999", "200000-249999", "250000-299999", - "300000-349999", "350000-399999", "400000-449999", "450000-499999", - "500000-549999", "550000-599999", "600000-649999", "650000-699999", - "700000-709999", "710000-714999", "715000-719999", "720000-721999", - "722000-722999", "723000-723999", "724000-724999", "725000-725999", - "726000-726999", "727000-729999", "730000-799999", "800000-849999", - "850000-899999", "900000-949999", "950000-999999", - ] - return DOWNLOAD_DIR, full_download, requests, tqdm - - -@app.cell -def _(requests, tqdm): - def download_wmo_range(wmo_id_range, download_dir): - wmo_str = f"WMO_{wmo_id_range}" - url = f"https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/data/{wmo_str}.tar.gz" - tar_name = f"{wmo_str}.tar.gz" - filename = download_dir / tar_name - - head = requests.head(url, allow_redirects=True) - remote_size = int(head.headers.get('content-length', 0)) - local_size = filename.stat().st_size if filename.exists() else 0 - - if filename.exists() and local_size == remote_size: - print(f"File already fully downloaded: {filename} ({local_size/1024**2:.2f} MB)") - elif filename.exists() and local_size != remote_size: - # Users may have done this deliberately, so just print a message - print(f"Local filesize of {filename} does not match, please delete it and re-download it") - else: - headers = {} - mode = 'wb' - initial_pos = 0 - if filename.exists() and local_size < remote_size: - headers['Range'] = f'bytes={local_size}-' - mode = 'ab' - initial_pos = local_size - print(f"Resuming download for {filename.name} at {local_size/1024**2:.2f} MB...") - else: - print(f"Starting download for {filename.name}...") - - response = requests.get(url, stream=True, headers=headers) - total = remote_size - with open(filename, mode) as f, tqdm( - desc=f"Downloading {filename.name}", - total=total, - initial=initial_pos, - unit='B', unit_scale=True, unit_divisor=1024 - ) as bar: - for chunk in response.iter_content(chunk_size=8192): - if chunk: - f.write(chunk) - bar.update(len(chunk)) - - final_size = filename.stat().st_size - if final_size == remote_size: - print(f"Download complete: {filename} ({final_size/1024**2:.2f} MB)") - else: - print(f"Warning: Download incomplete. Local size: {final_size}, Remote size: {remote_size}") - - return filename, tar_name - return (download_wmo_range,) - - -@app.cell -def _(DOWNLOAD_DIR, download_wmo_range, full_download): - # for wrange in testing_download: - # download_wmo_range(wrange, DOWNLOAD_DIR) - - # FOR FULL STATION DOWNLOAD - # Note, if at NCI doing the hackathon, use the pre-downloaded data - - for wrange in full_download: - download_wmo_range(wrange, DOWNLOAD_DIR) - return - - -@app.cell -def _(): - # The next step is easiest to do manually, and is a bit awkward to put in a notebook step. - - # First, go to your top-level download directory. Make a new directory called 'unpacked', then run the following command. - # This will result in a lot of individual .nc.gz files on disK - - # `for file in *.tar.gz; do tar -xzf "$file" --directory ../unpacked; done` - - # Once this is down, change directory into the unpacked directory and run - - # `gunzip *` - - # This is much faster for some reason than trying to use Python to get the job done. - return - - -@app.cell -def _(): - print("download completed)") - return - - -@app.cell -def _(): - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/scorecard/Three-SmallChunksByDecade.ipynb b/notebooks/scorecard/Three-SmallChunksByDecade.ipynb new file mode 100644 index 00000000..6acc7888 --- /dev/null +++ b/notebooks/scorecard/Three-SmallChunksByDecade.ipynb @@ -0,0 +1,191 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "00e4c340-5fdc-400f-a527-4d724166576e", + "metadata": {}, + "outputs": [], + "source": [ + "import tarfile\n", + "import gzip\n", + "import shutil\n", + "from pathlib import Path\n", + "import numpy as np\n", + "from datetime import datetime\n", + "import warnings\n", + "warnings.simplefilter(action='ignore', category=FutureWarning)\n", + "import marimo as mo\n", + "import os\n", + "\n", + "from dask.distributed import Client\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1ce7e96e-b49a-4a83-8269-bdb47064bc24", + "metadata": {}, + "outputs": [], + "source": [ + "UNPACKED_DIR = Path.home() / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives\n", + "PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1f34c861-e4d6-434a-8873-592e53a369f9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10393" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "files = list(UNPACKED_DIR.glob('*.nc'))\n", + "len(files)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d779c04-71de-4e90-8d88-fb4eecc91fd0", + "metadata": {}, + "outputs": [], + "source": [ + "def simplify(ds):\n", + " lats = xr.DataArray(data=[ds.latitude.values[0]] * len(ds.time), coords={'time': ds.time})\n", + " lons = xr.DataArray(data=[ds.longitude.values[0]] * len(ds.time), coords={'time': ds.time})\n", + " elev = xr.DataArray(data=[ds.elevation.values[0]] * len(ds.time), coords={'time': ds.time})\n", + " ds = ds.reset_coords(names=('latitude', 'longitude', 'elevation'), drop=True)\n", + " ds['lat'] = lats\n", + " ds['lon'] = lons\n", + " ds['elev'] = elev\n", + "\n", + " ds = ds.drop_attrs()\n", + " return ds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ebf5d389-d345-4f31-a46b-105cd2ef21a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1040\n" + ] + } + ], + "source": [ + "filegroups = [files[i:i + 10] for i in range(0, len(files), 10)]\n", + "print(len(filegroups)) # We come up with 134 such file groupings from the test data or 1040 for the full dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c3cb82db-d97e-46c1-b92e-d9545af7811e", + "metadata": {}, + "outputs": [], + "source": [ + "decades = [('1800', '1930'), # Just in case there is undocumented early data\n", + " ('1930', '1940'), ('1940', '1950'), # Dataset begins in 1930, start by decade here\n", + " ('1950', '1960'), ('1960', '1970'), ('1970', '1980'), \n", + " ('1980', '1990'), ('1990', '2000'), ('2000', '2010'), # 1980 is a common time to start from\n", + " ('2010', '2020'), ('2020', '2030')\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dedfafc9-e785-4209-9b69-6992e234e1f0", + "metadata": {}, + "outputs": [], + "source": [ + "# This takes around 20-30 seconds per grouping. If you just want to get the hang of it, limit it to three groupings\n", + "# Otherwise, the test set have 67 groupings, so will take around half an hour to run\n", + "# The full set of stations will take several hours!\n", + "\n", + "# For testing, just try three file groups\n", + "\n", + "# for i, fg in enumerate(filegroups[3]): # Use me to test three file groupings\n", + "for i, fg in enumerate(filegroups): # Use me to process all downloaded data\n", + " print(f\"Processing group {i} of {len(filegroups)}\")\n", + " print(datetime.now().time())\n", + " loaded = [xr.open_dataset(f, engine='h5netcdf') for f in fg]\n", + " simplified = [simplify(_ds) for _ds in loaded]\n", + " merged = xr.concat(simplified, dim='report')\n", + "\n", + " for d in decades:\n", + " decadal = merged.sel(time=slice(*d))\n", + " if len(decadal.time):\n", + " filename = PROCESSING_DIR / f'{d[0]}-{d[1]}-sg{i}.nc'\n", + " if not os.path.exists(filename):\n", + " decadal.to_netcdf(filename)\n", + " else:\n", + " print(f\"{filename} exists, skipping\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7bce54e4-ed2c-4400-bac8-fb7cc484f555", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done\n" + ] + } + ], + "source": [ + "print('done')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4da1b95-c11b-4101-b75b-f754907c3398", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/scorecard/Two-DataDownload.ipynb b/notebooks/scorecard/Two-DataDownload.ipynb new file mode 100644 index 00000000..45e14bd9 --- /dev/null +++ b/notebooks/scorecard/Two-DataDownload.ipynb @@ -0,0 +1,196 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "10f05488-d4f2-40cf-8edc-34e00815a3a6", + "metadata": {}, + "outputs": [], + "source": [ + "# A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work.\n", + "\n", + "import requests\n", + "from pathlib import Path\n", + "from tqdm.auto import tqdm\n", + "\n", + "DOWNLOAD_DIR = Path.home() / 'hadisd' / 'as_downloaded' # We will download data here and keep a copy\n", + "\n", + "# For testing, we download just under 4GB data\n", + "testing_download = [\n", + " \"000000-029999\", \"500000-549999\", \"722000-722999\", \"800000-849999\",\n", + "]\n", + "\n", + "# Download list for all files\n", + "full_download = [\n", + " \"000000-029999\", \"030000-049999\", \"050000-079999\", \"080000-099999\",\n", + " \"100000-149999\", \"150000-199999\", \"200000-249999\", \"250000-299999\",\n", + " \"300000-349999\", \"350000-399999\", \"400000-449999\", \"450000-499999\",\n", + " \"500000-549999\", \"550000-599999\", \"600000-649999\", \"650000-699999\", \n", + " \"700000-709999\", \"710000-714999\", \"715000-719999\", \"720000-721999\",\n", + " \"722000-722999\", \"723000-723999\", \"724000-724999\", \"725000-725999\", \n", + " \"726000-726999\", \"727000-729999\", \"730000-799999\", \"800000-849999\",\n", + " \"850000-899999\", \"900000-949999\", \"950000-999999\",\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0971f5fb-46b4-409b-8d41-fdfc0c5f5ae4", + "metadata": {}, + "outputs": [], + "source": [ + "def download_wmo_range(wmo_id_range, download_dir):\n", + " wmo_str = f\"WMO_{wmo_id_range}\"\n", + " url = f\"https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/data/{wmo_str}.tar.gz\"\n", + " tar_name = f\"{wmo_str}.tar.gz\"\n", + " filename = download_dir / tar_name \n", + "\n", + " head = requests.head(url, allow_redirects=True)\n", + " remote_size = int(head.headers.get('content-length', 0))\n", + " local_size = filename.stat().st_size if filename.exists() else 0\n", + "\n", + " if filename.exists() and local_size == remote_size:\n", + " print(f\"File already fully downloaded: {filename} ({local_size/1024**2:.2f} MB)\")\n", + " elif filename.exists() and local_size != remote_size:\n", + " # Users may have done this deliberately, so just print a message\n", + " print(f\"Local filesize of {filename} does not match, please delete it and re-download it\")\n", + " else:\n", + " headers = {}\n", + " mode = 'wb'\n", + " initial_pos = 0\n", + " if filename.exists() and local_size < remote_size:\n", + " headers['Range'] = f'bytes={local_size}-'\n", + " mode = 'ab'\n", + " initial_pos = local_size\n", + " print(f\"Resuming download for {filename.name} at {local_size/1024**2:.2f} MB...\")\n", + " else:\n", + " print(f\"Starting download for {filename.name}...\")\n", + "\n", + " response = requests.get(url, stream=True, headers=headers)\n", + " total = remote_size\n", + " with open(filename, mode) as f, tqdm(\n", + " desc=f\"Downloading {filename.name}\",\n", + " total=total,\n", + " initial=initial_pos,\n", + " unit='B', unit_scale=True, unit_divisor=1024\n", + " ) as bar:\n", + " for chunk in response.iter_content(chunk_size=8192):\n", + " if chunk:\n", + " f.write(chunk)\n", + " bar.update(len(chunk))\n", + "\n", + " final_size = filename.stat().st_size\n", + " if final_size == remote_size:\n", + " print(f\"Download complete: {filename} ({final_size/1024**2:.2f} MB)\")\n", + " else:\n", + " print(f\"Warning: Download incomplete. Local size: {final_size}, Remote size: {remote_size}\")\n", + "\n", + " return filename, tar_name" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "20e1e2b6-4225-40f8-8fa8-bd4e8185e147", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_000000-029999.tar.gz (1251.93 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_030000-049999.tar.gz (1181.60 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_050000-079999.tar.gz (1623.48 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_080000-099999.tar.gz (384.80 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_100000-149999.tar.gz (1723.28 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_150000-199999.tar.gz (1450.79 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_200000-249999.tar.gz (527.35 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_250000-299999.tar.gz (808.74 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_300000-349999.tar.gz (784.29 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_350000-399999.tar.gz (450.11 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_400000-449999.tar.gz (858.24 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_450000-499999.tar.gz (1733.11 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_500000-549999.tar.gz (423.88 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_550000-599999.tar.gz (528.65 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_600000-649999.tar.gz (742.05 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_650000-699999.tar.gz (327.55 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_700000-709999.tar.gz (678.02 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_710000-714999.tar.gz (911.36 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_715000-719999.tar.gz (1093.04 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_720000-721999.tar.gz (319.29 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_722000-722999.tar.gz (1798.31 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_723000-723999.tar.gz (1001.99 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_724000-724999.tar.gz (1261.04 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_725000-725999.tar.gz (1468.99 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_726000-726999.tar.gz (992.77 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_727000-729999.tar.gz (592.35 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_730000-799999.tar.gz (1108.93 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_800000-849999.tar.gz (453.07 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_850000-899999.tar.gz (553.23 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_900000-949999.tar.gz (1170.64 MB)\n", + "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_950000-999999.tar.gz (1357.84 MB)\n" + ] + } + ], + "source": [ + "# for wrange in testing_download:\n", + "# download_wmo_range(wrange, DOWNLOAD_DIR)\n", + "\n", + "# FOR FULL STATION DOWNLOAD\n", + "# Note, if at NCI doing the hackathon, use the pre-downloaded data\n", + "\n", + "for wrange in full_download:\n", + " download_wmo_range(wrange, DOWNLOAD_DIR) " + ] + }, + { + "cell_type": "markdown", + "id": "a2565195-6db7-447d-abea-139ba8521fc7", + "metadata": {}, + "source": [ + "The next step is easiest to do manually, and is a bit awkward to put in a notebook step.\n", + " \n", + "First, go to your top-level download directory. Make a new directory called 'unpacked', then run the following command.\n", + "This will result in a lot of individual .nc.gz files on disK\n", + " \n", + "Run `for file in *.tar.gz; do tar -xzf \"$file\" --directory ../unpacked; done`\n", + " \n", + "Once this is done, change directory into the unpacked directory and run\n", + " \n", + "`gunzip *`\n", + " \n", + "This is much faster for some reason than trying to use Python to get the job done." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c7db752-56c3-4071-b485-d88d3848fffe", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 7221bfa8a0c056f47ccc204fc1c5757bd2c25185 Mon Sep 17 00:00:00 2001 From: Tennessee Leeuwenburg Date: Wed, 5 Nov 2025 12:56:24 +1100 Subject: [PATCH 3/4] Update tutorials for downloading and working with station data --- notebooks/Gallery.ipynb | 24 ++- notebooks/scorecard/Five-DataAccessor.ipynb | 92 ++++++---- .../scorecard/Four-MakeLargeGroupings.ipynb | 35 ++-- notebooks/scorecard/One-Introduction.ipynb | 12 +- .../scorecard/Three-SmallChunksByDecade.ipynb | 75 +++++--- notebooks/scorecard/Two-DataDownload.ipynb | 166 +++++++++--------- packages/tutorial/pyproject.toml | 1 + 7 files changed, 248 insertions(+), 157 deletions(-) diff --git a/notebooks/Gallery.ipynb b/notebooks/Gallery.ipynb index 62b27fed..b2b6a704 100644 --- a/notebooks/Gallery.ipynb +++ b/notebooks/Gallery.ipynb @@ -41,6 +41,26 @@ "| **Radar Visualisation** | Shows how to visualise radar data as a time-series, in 2D and in 3D | ![Image showing a top down view of radar data](https://pyearthtools.readthedocs.io/en/latest/_images/notebooks_RadarVisualisation_10_1.png) | [Radar Visualisation](./RadarVisualisation.ipynb) | 23 Aug 2025 |\n" ] }, + { + "cell_type": "markdown", + "id": "a6f26875-9a0c-40b2-87ad-39cb1f8037e9", + "metadata": {}, + "source": [ + "## Working with Station Data (medium requirements)\n", + "\n", + "Working with station data and integrating it with gridded data is quite complex. This series of tutorials demonstrates how to download one of the key open station databases, re-process it to suit the time-series nature of most PyEarthTools use cases, create a Data Accessor, and then combine the data with gridded data to form the basis of a heterogenous machine learning pipeline. \n", + "\n", + "These tutorials can be run on some laptops and workstations and do not require a GPU as they do not yet include model training, but may require larger amounts of RAM than devices, and some user modification may be needed to run them on less than 36GB RAM.\n", + "\n", + "| Title | Description | Image | Notebooks | Last Tested |\n", + "|-------|--------------|-------|-------------|-------------|\n", + "| **One - Introduction** | Introduction to station data | (no image) | [One - Introduction](./scorecard/One-Introduction.ipynb) | 5 Nov 2025 |\n", + "| **Two - Data Download** | Perform inital data downloading | (no image) | [Two - DataDownload](./scorecard/Two-DataDownload.ipynb) | 5 Nov 2025 |\n", + "| **Three - Small Chunks** | Group the data by decade in small groups | (no image) | [Three - SmallChunks](./scorecard/Three-SmallChunks.ipynb) | 5 Nov 2025 |\n", + "| **Four - Make Large Groupings** | Group the data by decade in large groups | (no image) | [Four - MakeLargeGroupings](./scorecard/Four-MakeLargeGroupings.ipynb) | 5 Nov 2025 |\n", + "| **Five - Data Accessor** | Integrate the data with PyEarthTools pipelines | (no image) | [Five - DataAccessor](./scorecard/Five-DataAccessor.ipynb) | 5 Nov 2025 |" + ] + }, { "cell_type": "markdown", "id": "1f72b9c5-1d2b-4212-9009-ab147685ca83", @@ -50,6 +70,8 @@ "\n", "These notebooks start with the basics and work up towards more complex examples, showing how to work with the classes and functions within the package to achieve objectives.\n", "\n", + "These tutorials require a high-performance computing environment and work with very large data volumes.\n", + "\n", "| Title | Description | Image | Notebooks | Last Tested |\n", "|-------|---------------|-------|------------|-------------|\n", "| **ENSO Prediction** |The El Niño–Southern Oscillation (ENSO) is a major driver of climate variability, influencing regional and global weather patterns. It has been linked to extreme weather events across the globe, including droughts, floods, and shifts in precipitation. Weather centres around the world actively forecast ENSO to anticipate these patterns. | | | | \n", @@ -136,7 +158,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.7" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/notebooks/scorecard/Five-DataAccessor.ipynb b/notebooks/scorecard/Five-DataAccessor.ipynb index 437655fb..009f717b 100644 --- a/notebooks/scorecard/Five-DataAccessor.ipynb +++ b/notebooks/scorecard/Five-DataAccessor.ipynb @@ -1,5 +1,25 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "ca22f992-1245-4b56-ba15-d30d6e27ddb3", + "metadata": {}, + "source": [ + "# Integration of Station Data with PyEarthTools\n", + "\n", + "This tutorial demonstrates how to create a data accessor for the station data which will integrate with PyEarthTools pipelines. In due course, a similar implementation will be put into the relevant site archive packages for people working in supported facilities, but this demonstrates how you can easily connect your own station data archive into the framework from first principles. Working with custom station datasets is relatively common (e.g. hydrology-specific data sets, different temporal resolutions, region-specific datasets, data sources not included in the global data sharing etc) and so seeing the entire process is of value.\n", + "\n", + "This tutorial will show how to:\n", + "\n", + " - Create a data accessor on-the-fly in the notebook\n", + " - Access and plot data\n", + " - Access that data alongside gridded data, and plot the overlay\n", + "\n", + "\n", + "Note! The data visualised in this notebook is only showing a small subset of the total number of stations, as it was developed on limited data in the first instance. It will be updated in due course with the entire dataset.\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -12,7 +32,8 @@ "from pyearthtools.data import Petdt\n", "\n", "from pathlib import Path\n", - "DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade'\n", + "DECADAL_DIR = Path('/g/data/kd24/data') / 'hadisd' / 'by_decade' \n", + "WBERA5_DIR = Path('/g/data/kd24/data') / 'wbera5' / 'by_decade' \n", "\n", "from mpl_toolkits.basemap import Basemap" ] @@ -69,16 +90,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "0b99769d-6202-4cf9-94ea-7d4f3e4bb492", "metadata": {}, "outputs": [], "source": [ - "workdir = Path.home() / \"dev/data/wb2era5/\"\n", + "\n", "era5_source = pyearthtools.data.download.weatherbench.WB2ERA5(\n", " variables=[\"2m_temperature\", \"u\", \"v\", \"geopotential\"],\n", " level=[850],\n", - " download_dir=workdir / \"download\",\n", + " download_dir=WBERA5_DIR,\n", " license_ok=True,\n", " ),\n", "\n", @@ -91,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "533f2964-c4dc-4d94-86c9-7b5dd69e7551", "metadata": {}, "outputs": [ @@ -110,41 +131,42 @@ " u_component_of_wind (time, level, longitude, latitude) float32 8kB dask.array\n", " v_component_of_wind (time, level, longitude, latitude) float32 8kB dask.array\n", " geopotential (time, level, longitude, latitude) float32 8kB dask.array,\n", - " Size: 464MB\n", - " Dimensions: (time: 1, report: 1334, test: 71, flagged: 19,\n", + " Size: 17MB\n", + " Dimensions: (time: 1, report: 50, test: 71, flagged: 19,\n", " reporting_v: 19, reporting_t: 1140, reporting_2: 2)\n", " Coordinates:\n", " * time (time) datetime64[ns] 8B 1990-06-20\n", " Dimensions without coordinates: report, test, flagged, reporting_v,\n", " reporting_t, reporting_2\n", " Data variables: (12/30)\n", - " station_id (time, report) |S12 16kB dask.array\n", - " temperatures (time, report) float64 11kB dask.array\n", - " dewpoints (time, report) float64 11kB dask.array\n", - " slp (time, report) float64 11kB dask.array\n", - " stnlp (time, report) float64 11kB dask.array\n", - " windspeeds (time, report) float64 11kB dask.array\n", + " station_id (time, report) |S12 600B dask.array\n", + " temperatures (time, report) float64 400B dask.array\n", + " dewpoints (time, report) float64 400B dask.array\n", + " slp (time, report) float64 400B dask.array\n", + " stnlp (time, report) float64 400B dask.array\n", + " windspeeds (time, report) float64 400B dask.array\n", " ... ...\n", - " quality_control_flags (time, report, test) float64 758kB dask.array\n", - " flagged_obs (time, report, flagged) float64 203kB dask.array\n", - " reporting_stats (time, report, reporting_v, reporting_t, reporting_2) float64 462MB dask.array\n", - " lat (time, report) float64 11kB dask.array\n", - " lon (time, report) float64 11kB dask.array\n", - " elev (time, report) float64 11kB dask.array)" + " quality_control_flags (time, report, test) float64 28kB dask.array\n", + " flagged_obs (time, report, flagged) float64 8kB dask.array\n", + " reporting_stats (time, report, reporting_v, reporting_t, reporting_2) float64 17MB dask.array\n", + " lat (time, report) float64 400B dask.array\n", + " lon (time, report) float64 400B dask.array\n", + " elev (time, report) float64 400B dask.array)" ] }, - "execution_count": 7, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "# Here we see the pipeline returns the ERA5 grid and the station data as two separate datasets, at a matched time.\n", "data_pipeline['19900620T00']" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "95838f20-084a-40d3-bd1d-6934c78f2482", "metadata": {}, "outputs": [], @@ -154,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "cb011eda-fc95-46bc-a798-97fa90676fb7", "metadata": {}, "outputs": [], @@ -168,23 +190,23 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "id": "24cdb456-b534-4216-9878-53a82508d16d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -210,23 +232,23 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "id": "46c3cc32-bc88-4e19-8665-45ea03197381", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -261,6 +283,14 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c54822e-297b-4f69-bd03-62540cf42e36", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -279,7 +309,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/notebooks/scorecard/Four-MakeLargeGroupings.ipynb b/notebooks/scorecard/Four-MakeLargeGroupings.ipynb index f38dc2e2..e3f822a4 100644 --- a/notebooks/scorecard/Four-MakeLargeGroupings.ipynb +++ b/notebooks/scorecard/Four-MakeLargeGroupings.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 14, "id": "1b4ae39b-4f5f-4dc7-bee0-a798eba46719", "metadata": {}, "outputs": [], @@ -12,28 +12,27 @@ "from datetime import datetime\n", "import warnings\n", "warnings.simplefilter(action='ignore', category=FutureWarning)\n", - "import marimo as mo\n", "\n", - "from dask.distributed import Client\n", "import xarray as xr" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 28, "id": "8bf7f65c-875c-47ff-9ea9-8ac81128be26", "metadata": {}, "outputs": [], "source": [ "# A spot to put the data on disk. We keep both the data as-downloaded and the reprocessed version, so you might need up to 50GB free in order to make this work.\n", "\n", - "PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing\n", - "DECADAL_DIR = Path.home() / 'hadisd' / 'by_decade' # This will hold the final form of our data" + "PROCESSING_DIR = Path('/g/data/kd24/data') / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing\n", + "DECADAL_DIR = Path('/g/data/kd24/data') / 'hadisd' / 'by_decade' # This will hold the final form of our data\n", + "DECADAL_DIR.mkdir()" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 29, "id": "db156524-9c84-4257-b351-e960f8b1adcb", "metadata": {}, "outputs": [], @@ -55,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 30, "id": "e205d264-92cb-4a29-b3ae-3ef16a7404e1", "metadata": {}, "outputs": [], @@ -74,10 +73,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "7cd6885d-635f-4028-bd75-19fed284cca3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 file groupings to be used for decade 1990\n", + "Loaded group 0\n", + "Combined group 0\n", + "Wrote group 0\n" + ] + } + ], "source": [ "decade_of_interest = '1990' # In the interests of saving time, we process only one decade here\n", "\n", @@ -89,7 +99,6 @@ " print(f\"Loaded group {i}\")\n", " combined = xr.concat(loaded, dim='report', data_vars='all')\n", " combined['reporting_stats'] = combined['reporting_stats'].fillna(-999.0)\n", - " # combined = combined.chunk(time=xr.groupers.TimeResampler(\"MS\"))\n", " print(f\"Combined group {i}\")\n", " filename = f'all_{decade_of_interest}s_group{str(i)}.nc'\n", " combined.to_netcdf(DECADAL_DIR / filename)\n", @@ -98,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 32, "id": "c2684bb3-0bf5-4b79-9c62-568bbdf5879d", "metadata": {}, "outputs": [ @@ -139,7 +148,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/notebooks/scorecard/One-Introduction.ipynb b/notebooks/scorecard/One-Introduction.ipynb index b53e8ba9..83e698dc 100644 --- a/notebooks/scorecard/One-Introduction.ipynb +++ b/notebooks/scorecard/One-Introduction.ipynb @@ -1,13 +1,11 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, - "id": "a4423136-8374-43c8-bbff-a5eecef13b07", + "cell_type": "markdown", + "id": "329c0283-9192-45e4-80b0-910ce5625120", "metadata": {}, - "outputs": [], "source": [ - "# https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html" + "## Hadley Integrated Surface Database\n" ] }, { @@ -29,6 +27,8 @@ "\n", "For the product manual, see [https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf](https://www.metoffice.gov.uk/hadobs/hadisd/hadisd_v340_2023f_product_user_guide.pdf)\n", "\n", + "For the website, see [https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html](https://www.metoffice.gov.uk/hadobs/hadisd/v343_2025f/index.html)\n", + "\n", "It's an amazing scientific archive. The data is held in a collection of .tgz files, based on station ranges. These files contains smaller station sub-ranges, themselves gzipped netcdf files. We need to download the ones we want (potentially all of them), then double-unwrap them, and then put them into a more performant file format for quick access by time index when performing ML training or long historical verification runs.\n", "\n", "Eventually, we want to present these efficiently as a PyEarthTools data accessor which can be quickly indexed by time. An alternative data accessor based on station ID rather than time could be imagined, but we will focus on access by time in this tutorial series.\n", @@ -84,7 +84,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/notebooks/scorecard/Three-SmallChunksByDecade.ipynb b/notebooks/scorecard/Three-SmallChunksByDecade.ipynb index 6acc7888..4fff3699 100644 --- a/notebooks/scorecard/Three-SmallChunksByDecade.ipynb +++ b/notebooks/scorecard/Three-SmallChunksByDecade.ipynb @@ -1,8 +1,24 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "adacf9f5-fe40-4f67-b987-0b14f9845e7c", + "metadata": {}, + "source": [ + "# Chunking the data into small groups\n", + "\n", + "The ideal end goal would be to have one huge netcdf file with efficient random access to all the data within it. Unfortunately, practical limitations with merging large files make this somewhat difficult. In principle all the various merging algorithms should be happy working on disk, but in practise the merging component of the algorithm seems to happen in memory in the libraries we use. It's more common to use smaller files on disk and then abstract that behind a multi-file lazy-load interface. This is acceptable for small and medium data sets, but eventually the sheer number of files starts to prove a problem, particularly in supercomputing environments, which are typically optimised for large file transfers. \n", + "\n", + "As a result, we must jump through a few hoops to re-structure our data for efficient indexing by time rather than primarily by station number (or location).\n", + "\n", + "Step one is to take our per-station files, and then in small groups re-arrange them and write out files by decade. This doesn't immediately reduce the number of files much, but then we will proceed to joining those decadal files into much larger files, and then delete the various intermediate files. Instead of over a thousand small files, we will instead have around about 50 larger ones, organised in a way that we can work with more easily, particularly if we only want a decade or two.\n", + "\n", + "This notebook does the small-group rechunking; the next one does the recombining. " + ] + }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 8, "id": "00e4c340-5fdc-400f-a527-4d724166576e", "metadata": {}, "outputs": [], @@ -15,7 +31,6 @@ "from datetime import datetime\n", "import warnings\n", "warnings.simplefilter(action='ignore', category=FutureWarning)\n", - "import marimo as mo\n", "import os\n", "\n", "from dask.distributed import Client\n", @@ -24,28 +39,29 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "id": "1ce7e96e-b49a-4a83-8269-bdb47064bc24", "metadata": {}, "outputs": [], "source": [ - "UNPACKED_DIR = Path.home() / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives\n", - "PROCESSING_DIR = Path.home() / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing" + "UNPACKED_DIR = Path('/g/data/kd24/data/') / 'hadisd' / 'unpacked' # We need a place on disk to unpack the archives\n", + "PROCESSING_DIR = Path('/g/data/kd24/data/') / 'hadisd' / 'processing' # We need to cache some data on disk during reprocessing\n", + "PROCESSING_DIR.mkdir()" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "id": "1f34c861-e4d6-434a-8873-592e53a369f9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "10393" + "2089" ] }, - "execution_count": 3, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -57,12 +73,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "id": "3d779c04-71de-4e90-8d88-fb4eecc91fd0", "metadata": {}, "outputs": [], "source": [ "def simplify(ds):\n", + " '''\n", + " Here we move the latitude, longitude and elevation from a coordinate to a data variable\n", + " \n", + " This fits the structure of the data more efficiently, allowing simpler concatenation.\n", + " '''\n", " lats = xr.DataArray(data=[ds.latitude.values[0]] * len(ds.time), coords={'time': ds.time})\n", " lons = xr.DataArray(data=[ds.longitude.values[0]] * len(ds.time), coords={'time': ds.time})\n", " elev = xr.DataArray(data=[ds.elevation.values[0]] * len(ds.time), coords={'time': ds.time})\n", @@ -77,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "id": "ebf5d389-d345-4f31-a46b-105cd2ef21a5", "metadata": {}, "outputs": [ @@ -85,7 +106,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "1040\n" + "209\n" ] } ], @@ -96,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "id": "c3cb82db-d97e-46c1-b92e-d9545af7811e", "metadata": {}, "outputs": [], @@ -114,15 +135,25 @@ "execution_count": null, "id": "dedfafc9-e785-4209-9b69-6992e234e1f0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing group 0 of 209\n", + "00:28:28.093766\n", + "Processing group 1 of 209\n", + "00:31:28.043623\n" + ] + } + ], "source": [ - "# This takes around 20-30 seconds per grouping. If you just want to get the hang of it, limit it to three groupings\n", + "# This takes around 20-60 seconds per grouping. If you just want to get the hang of it, limit it to three groupings\n", "# Otherwise, the test set have 67 groupings, so will take around half an hour to run\n", "# The full set of stations will take several hours!\n", "\n", "# For testing, just try three file groups\n", "\n", - "# for i, fg in enumerate(filegroups[3]): # Use me to test three file groupings\n", "for i, fg in enumerate(filegroups): # Use me to process all downloaded data\n", " print(f\"Processing group {i} of {len(filegroups)}\")\n", " print(datetime.now().time())\n", @@ -142,18 +173,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "7bce54e4-ed2c-4400-bac8-fb7cc484f555", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "done\n" - ] - } - ], + "outputs": [], "source": [ "print('done')" ] @@ -183,7 +206,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/notebooks/scorecard/Two-DataDownload.ipynb b/notebooks/scorecard/Two-DataDownload.ipynb index 45e14bd9..edddbd28 100644 --- a/notebooks/scorecard/Two-DataDownload.ipynb +++ b/notebooks/scorecard/Two-DataDownload.ipynb @@ -1,8 +1,22 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "70473e3c-69ff-422d-b516-165b6d397b74", + "metadata": {}, + "source": [ + "## Downloading The Hadley ISD Dataset\n", + "\n", + "Note - if you are at NCI, you may be able to use an already-downloaded version if you are in project kd24.\n", + "\n", + "If you are working at another facility, it is highly recommended to start with just the test data, and run the entire sequence of tutorials from that data to get the hang of working with the data. This is just because of the download volume and processing time required. \n", + "\n", + "That said, this data set is entirely reasonable to work with on many laptops, workstations or general computing environments, it just requires a little patience to get up and running smoothly." + ] + }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "10f05488-d4f2-40cf-8edc-34e00815a3a6", "metadata": {}, "outputs": [], @@ -13,14 +27,15 @@ "from pathlib import Path\n", "from tqdm.auto import tqdm\n", "\n", - "DOWNLOAD_DIR = Path.home() / 'hadisd' / 'as_downloaded' # We will download data here and keep a copy\n", + "DOWNLOAD_DIR = Path('/g/data/kd24/data/') / 'hadisd' / 'as_downloaded' # We will download data here and keep a copy\n", + "DOWNLOAD_DIR.mkdir(exist_ok=True)\n", "\n", "# For testing, we download just under 4GB data\n", "testing_download = [\n", " \"000000-029999\", \"500000-549999\", \"722000-722999\", \"800000-849999\",\n", "]\n", "\n", - "# Download list for all files\n", + "# Download list for all files - these approximately map to station IDs\n", "full_download = [\n", " \"000000-029999\", \"030000-049999\", \"050000-079999\", \"080000-099999\",\n", " \"100000-149999\", \"150000-199999\", \"200000-249999\", \"250000-299999\",\n", @@ -35,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "0971f5fb-46b4-409b-8d41-fdfc0c5f5ae4", "metadata": {}, "outputs": [], @@ -49,90 +64,54 @@ " head = requests.head(url, allow_redirects=True)\n", " remote_size = int(head.headers.get('content-length', 0))\n", " local_size = filename.stat().st_size if filename.exists() else 0\n", - "\n", + " \n", " if filename.exists() and local_size == remote_size:\n", " print(f\"File already fully downloaded: {filename} ({local_size/1024**2:.2f} MB)\")\n", - " elif filename.exists() and local_size != remote_size:\n", + " return filename, tar_name\n", + "\n", + " if filename.exists() and local_size != remote_size:\n", " # Users may have done this deliberately, so just print a message\n", - " print(f\"Local filesize of {filename} does not match, please delete it and re-download it\")\n", + " print(f\"Local filesize of {filename} does not match. Attempting to resume. You may need delete it and re-download it\")\n", + " \n", + " headers = {}\n", + " mode = 'wb'\n", + " initial_pos = 0\n", + " if filename.exists() and local_size < remote_size:\n", + " headers['Range'] = f'bytes={local_size}-'\n", + " mode = 'ab'\n", + " initial_pos = local_size\n", + " print(f\"Resuming download for {filename.name} at {local_size/1024**2:.2f} MB...\")\n", + " else:\n", + " print(f\"Starting download for {filename.name}...\")\n", + "\n", + " response = requests.get(url, stream=True, headers=headers)\n", + " total = remote_size\n", + " with open(filename, mode) as f, tqdm(\n", + " desc=f\"Downloading {filename.name}\",\n", + " total=total,\n", + " initial=initial_pos,\n", + " unit='B', unit_scale=True, unit_divisor=1024\n", + " ) as bar:\n", + " for chunk in response.iter_content(chunk_size=8192):\n", + " if chunk:\n", + " f.write(chunk)\n", + " bar.update(len(chunk))\n", + "\n", + " final_size = filename.stat().st_size\n", + " if final_size == remote_size:\n", + " print(f\"Download complete: {filename} ({final_size/1024**2:.2f} MB)\")\n", " else:\n", - " headers = {}\n", - " mode = 'wb'\n", - " initial_pos = 0\n", - " if filename.exists() and local_size < remote_size:\n", - " headers['Range'] = f'bytes={local_size}-'\n", - " mode = 'ab'\n", - " initial_pos = local_size\n", - " print(f\"Resuming download for {filename.name} at {local_size/1024**2:.2f} MB...\")\n", - " else:\n", - " print(f\"Starting download for {filename.name}...\")\n", - "\n", - " response = requests.get(url, stream=True, headers=headers)\n", - " total = remote_size\n", - " with open(filename, mode) as f, tqdm(\n", - " desc=f\"Downloading {filename.name}\",\n", - " total=total,\n", - " initial=initial_pos,\n", - " unit='B', unit_scale=True, unit_divisor=1024\n", - " ) as bar:\n", - " for chunk in response.iter_content(chunk_size=8192):\n", - " if chunk:\n", - " f.write(chunk)\n", - " bar.update(len(chunk))\n", - "\n", - " final_size = filename.stat().st_size\n", - " if final_size == remote_size:\n", - " print(f\"Download complete: {filename} ({final_size/1024**2:.2f} MB)\")\n", - " else:\n", - " print(f\"Warning: Download incomplete. Local size: {final_size}, Remote size: {remote_size}\")\n", + " print(f\"Warning: Download incomplete. Local size: {final_size}, Remote size: {remote_size}\")\n", "\n", " return filename, tar_name" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "20e1e2b6-4225-40f8-8fa8-bd4e8185e147", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_000000-029999.tar.gz (1251.93 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_030000-049999.tar.gz (1181.60 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_050000-079999.tar.gz (1623.48 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_080000-099999.tar.gz (384.80 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_100000-149999.tar.gz (1723.28 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_150000-199999.tar.gz (1450.79 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_200000-249999.tar.gz (527.35 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_250000-299999.tar.gz (808.74 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_300000-349999.tar.gz (784.29 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_350000-399999.tar.gz (450.11 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_400000-449999.tar.gz (858.24 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_450000-499999.tar.gz (1733.11 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_500000-549999.tar.gz (423.88 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_550000-599999.tar.gz (528.65 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_600000-649999.tar.gz (742.05 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_650000-699999.tar.gz (327.55 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_700000-709999.tar.gz (678.02 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_710000-714999.tar.gz (911.36 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_715000-719999.tar.gz (1093.04 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_720000-721999.tar.gz (319.29 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_722000-722999.tar.gz (1798.31 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_723000-723999.tar.gz (1001.99 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_724000-724999.tar.gz (1261.04 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_725000-725999.tar.gz (1468.99 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_726000-726999.tar.gz (992.77 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_727000-729999.tar.gz (592.35 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_730000-799999.tar.gz (1108.93 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_800000-849999.tar.gz (453.07 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_850000-899999.tar.gz (553.23 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_900000-949999.tar.gz (1170.64 MB)\n", - "File already fully downloaded: /Users/munin/hadisd/as_downloaded/WMO_950000-999999.tar.gz (1357.84 MB)\n" - ] - } - ], + "outputs": [], "source": [ "# for wrange in testing_download:\n", "# download_wmo_range(wrange, DOWNLOAD_DIR)\n", @@ -140,8 +119,16 @@ "# FOR FULL STATION DOWNLOAD\n", "# Note, if at NCI doing the hackathon, use the pre-downloaded data\n", "\n", + "# Note - need to make the DOWNLOAD_DIR directory\n", + "\n", "for wrange in full_download:\n", - " download_wmo_range(wrange, DOWNLOAD_DIR) " + " try:\n", + " download_wmo_range(wrange, DOWNLOAD_DIR) \n", + " except:\n", + " # This is a fault-tolerant approach which will print error messages but continue\n", + " # to try to fetch the remaining files\n", + " import traceback\n", + " traceback.print_exc()" ] }, { @@ -149,10 +136,13 @@ "id": "a2565195-6db7-447d-abea-139ba8521fc7", "metadata": {}, "source": [ + "## Unpacking the Data\n", + "\n", "The next step is easiest to do manually, and is a bit awkward to put in a notebook step.\n", " \n", - "First, go to your top-level download directory. Make a new directory called 'unpacked', then run the following command.\n", - "This will result in a lot of individual .nc.gz files on disK\n", + "First, go to your top-level download directory. Make a new directory called `unpacked`, then run the following command.\n", + "\n", + "This will result in a lot of individual .nc.gz files on disk. Once tutorial three has been run, it is okay to delete these interim files.\n", " \n", "Run `for file in *.tar.gz; do tar -xzf \"$file\" --directory ../unpacked; done`\n", " \n", @@ -170,6 +160,22 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb09f28f-d8ee-4bc8-83bf-6397a10ca257", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a1f4ebf-29ab-45c0-bd02-f74e687fedef", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -188,7 +194,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/packages/tutorial/pyproject.toml b/packages/tutorial/pyproject.toml index a955285d..68561149 100644 --- a/packages/tutorial/pyproject.toml +++ b/packages/tutorial/pyproject.toml @@ -17,6 +17,7 @@ classifiers = [ dependencies = [ "rich", "ipywidgets", + "basemap", "hydra-core", "scores", "dask", From 6471edc5ffb22e66256760fec296cf7396287d8d Mon Sep 17 00:00:00 2001 From: Tennessee Leeuwenburg Date: Wed, 5 Nov 2025 13:02:23 +1100 Subject: [PATCH 4/4] Remove unused import --- packages/data/src/pyearthtools/data/download/weatherbench.py | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/data/src/pyearthtools/data/download/weatherbench.py b/packages/data/src/pyearthtools/data/download/weatherbench.py index 3bd97f37..b983141e 100644 --- a/packages/data/src/pyearthtools/data/download/weatherbench.py +++ b/packages/data/src/pyearthtools/data/download/weatherbench.py @@ -1,6 +1,5 @@ import hashlib import logging -import os import shutil import sys import textwrap