From 1266c44878d2c0ec7dad4ffb421b3b9c03ecdba9 Mon Sep 17 00:00:00 2001 From: Samantha Wong Date: Tue, 7 May 2024 16:53:13 -0400 Subject: [PATCH 01/14] update to flux calc - now just part of spectral analysis --- examples/analysis_notebook.ipynb | 10 +- gammapy_tools/analysis/data_products.py | 134 +----------------------- 2 files changed, 11 insertions(+), 133 deletions(-) diff --git a/examples/analysis_notebook.ipynb b/examples/analysis_notebook.ipynb index ca2643a..6555dce 100644 --- a/examples/analysis_notebook.ipynb +++ b/examples/analysis_notebook.ipynb @@ -130,8 +130,9 @@ " - **`type`** : spectral model (string): \"PL\" = power law, \"LP\" = log parabola, \"EXPPL\" = exponential cutoff power law\n", " - **`params`** : normalization and spectral index in an array: e.g., [3.48e-11,2.4]\n", "\n", - "- **`lightcurve`** information for LC analysis (1D reflected regions). No need to specify bin size if you're just running an integrated flux analysis (see section 3ii)\n", - " -**`bin_size_min`**: temporal bin size [minutes]\n", + "- **`lightcurve`** information for LC/flux analysis (1D reflected regions). No need to specify bin size if you're just running an integrated flux analysis (see section 3ii)\n", + " - **`bin_size_min`**: temporal bin size [minutes]\n", + " - **`threshold`**: energy threshold for integral flux calculations\n", "\n", "- **`sky_map`**: \n", " - **`e_min`**: sky map energy threshold\n", @@ -518,7 +519,7 @@ } ], "source": [ - "spectral_points, flux, flux_err, spectral_model, cumulative_time, cumulative_sig = make_spectrum_RE(config, plot=False)" + "spectral_points, spectral_model, cumulative_time, cumulative_sig = make_spectrum_RE(config, plot=False)" ] }, { @@ -593,7 +594,8 @@ "metadata": {}, "outputs": [], "source": [ - "#flux = get_flux_lc(config,'flux')" + "flux = get_integral_flux(config,[])\n", + "#lc_points = get_flux_lc(config,'runwise') # light curve maker" ] }, { diff --git a/gammapy_tools/analysis/data_products.py b/gammapy_tools/analysis/data_products.py index 6fdd9dd..9efc223 100644 --- a/gammapy_tools/analysis/data_products.py +++ b/gammapy_tools/analysis/data_products.py @@ -212,6 +212,9 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): spectral_model = LogParabolaSpectralModel( alpha=float(alp), amplitude=float(amp), reference=1 * u.TeV, beta=float(bet) ) + #calculate integral flux from spectral model + integral_flux = spectral_model.integral(e_min * u.Unit("TeV"),e_max* u.Unit("TeV")) + integral_flux_err = spectral_model.integral_error(e_min* u.Unit("TeV"),e_max* u.Unit("TeV")) model = SkyModel(spectral_model=spectral_model, name="my_source") datasets.models = [model] @@ -237,135 +240,8 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): else: plt.clf() - return flux_points, result_joint.models, time, sig + return flux_points, result_joint.models, time, sig, integral_flux, integral_flux_err -def get_integral_flux(config,spectral_model): - """Outputs integral flux calculated from a spectral model - - Parameters - ---------- - config: configuration file - - Returns - ---------- - flux_points: flux points object - """ - if config["run_selection"]["pos_from_DL3"]: # get position from DL3 header - hdul = fits.open(config["io"]["out_dir"]+os.listdir(config["io"]["out_dir"])[0]) - source_pos = SkyCoord(hdul[1].header["RA_OBJ"]*u.deg, hdul[1].header["DEC_OBJ"]*u.deg) - else: # get position from ra/dec [deg] - source_pos = SkyCoord( - config["run_selection"]["source_ra"], - config["run_selection"]["source_dec"], - frame="icrs", - unit="deg", - ) - - threshold = config["lightcurve"]["threshold"] - # exclusion regions - should be upgraded to exclusion_finder code eventually - - # apply exclusion regions - exclusion_regions = [] - - exclusion_regions.append( - CircleSkyRegion( - center=source_pos, radius=config["sky_map"]["on_exclusion_region"] * u.deg - ) - ) - - if ( - len(config["sky_map"]["exclusion_regions"]) > 0 - ): # should be a list of CircleSkyRegions - for region in config["sky_map"]["exclusion_regions"]: - ra, dec = region[0] - radius = region[1] - exclusion_regions.append( - CircleSkyRegion( - center=SkyCoord(ra, dec, unit="deg", frame="icrs"), - radius=radius * u.deg, - ) - ) - # exclude bright stars - star_data = np.loadtxt( - environ["GAMMAPY_DATA"] + "/catalogs/Hipparcos_MAG8_1997.dat", - usecols=(0, 1, 2, 3, 4), - ) - star_cat = Table( - { - "ra": star_data[:, 0], - "dec": star_data[:, 1], - "id": star_data[:, 2], - "mag": star_data[:, 3], - "colour": star_data[:, 4], - } - ) - star_mask = ( - np.sqrt( - (star_cat["ra"] - source_pos.ra.deg) ** 2 - + (star_cat["dec"] - source_pos.dec.deg) ** 2 - ) - < 2.0 - ) - star_mask &= (star_cat["mag"]+star_cat["colour"])< config["sky_map"]["min_star_brightness"] - - # append stars to exclusion list - for src in star_cat[star_mask]: - exclusion_regions.append( - CircleSkyRegion( - center=SkyCoord(src["ra"], src["dec"], unit="deg", frame="icrs"), - radius=0.3 * u.deg, - ) - ) - - dataset_empty = SpectrumDataset.create(geom=geom, energy_axis_true=energy_axis_true) - - dataset_maker = SpectrumDatasetMaker( - containment_correction=True, selection=["counts", "exposure", "edisp"] - ) - - geom = WcsGeom.create( - npix=(150, 150), binsz=0.05, skydir=source_pos, proj="TAN", frame="icrs" - ) - - for i, exclusion_region in enumerate(exclusion_regions): - if i == 0: - exclusion_mask = ~geom.region_mask([exclusion_region]) - else: - exclusion_mask *= ~geom.region_mask([exclusion_region]) - if len(exclusion_regions) > 0: - exclusion_mask.plot() - if plot: - plt.show() - - # create reflected regions background - bkg_maker = ReflectedRegionsBackgroundMaker(exclusion_mask=exclusion_mask) - safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10) - datasets = Datasets() - - for obs_id, observation in zip(obs_ids, observations): - dataset = dataset_maker.run(dataset_empty.copy(name=str(obs_id)), observation) - dataset_on_off = bkg_maker.run(dataset, observation) - dataset_on_off = safe_mask_masker.run(dataset_on_off, observation) - datasets.append(dataset_on_off) - - # construct spectral model - spectral_model = PowerLawSpectralModel( - amplitude=float(norm) * u.Unit("cm-2 s-1 TeV-1"), - index=float(index), - reference=1 * u.TeV, - ) - - - model = SkyModel(spectral_model=spectral_model, name="my_source") - datasets.models = [model] - fit_joint = Fit() - result_joint = fit_joint.run(datasets=datasets) - - # get flux by integrating spectral model - flux = result_join.models.integral(threshold*u.TeV, 30*u.TeV).value - flux_err = result_join.models.integral_error(threshold*u.TeV, 30*u.TeV)[1].value - - return flux, flux_err def get_flux_lc(config, type="flux"): """Output run-wise flux points and the overall flux of a 1D dataset @@ -389,7 +265,7 @@ def get_flux_lc(config, type="flux"): else: observations = datastore.get_observations(required_irf="all-optional") - amp, idx = config["lightcurve"]["params"] + amp, idx = config["spectrum"]["params"] if config["run_selection"]["pos_from_DL3"]: # get position from DL3 header hdul = fits.open(config["io"]["out_dir"]+os.listdir(config["io"]["out_dir"])[0]) From 66608ce43bf174f4a63b8779498497ac8d2d10ad Mon Sep 17 00:00:00 2001 From: Samantha Wong Date: Wed, 8 May 2024 13:45:05 -0400 Subject: [PATCH 02/14] updated notebook --- examples/mrk_501_v5.yaml | 114 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 examples/mrk_501_v5.yaml diff --git a/examples/mrk_501_v5.yaml b/examples/mrk_501_v5.yaml new file mode 100644 index 0000000..3aa02de --- /dev/null +++ b/examples/mrk_501_v5.yaml @@ -0,0 +1,114 @@ +io: + runlist: "/raid/romulus/swong/ED490/Eventdisplay_AnalysisScripts_VTS/scripts/mrk501_v5.txt" + search_datastore : "/raid/romulus/dl3/ed/dl3_fullenclosure_moderate2tel/" + in_dir : "/raid/romulus/swong/mydl3/mrk501_v5/" + out_dir : "/raid/romulus/swong/mydl3/mrk501_v5/bkgs/" #"/raid/romulus/swong/mydl3/mrk501_v4_bkgs/" + results_dir: "/raid/romulus/swong/mydl3/mrk501_v5/results/" + + # Whether or not to generate the background from the run + from_run : false + # Whether or not to analyze runs from a runlist or all runs in the results_dir + from_runlist: true + +binning: + # Energy binning + e_min: 0.1 + e_max: 100 + e_bins: 10 + # Offset/wobble binning + off_min: 0 + off_max: 2.5 + off_bins: 5 + +config: + njobs : 16 + +exclusion: + star_cat : "./Hipparcos_MAG8_1997.dat" + # Exculde region around a simbad resolveable source name + # Expecting name, exclusion + exclude_source_name : + # Exculde region around a given ra, dec + exclude_regions : + # Exculde region around a given ra, dec + # Exculde region around a given ra, dec + # exclude_source_pos : [ ("287.10 deg", "6.39 deg", "0.5 deg"] + # Exculde entire run within a distance to a given ra/dec + # Expecting ra, dec, exclusion + # exclude_source_run : [ ("287.10 deg", "6.39 deg", "3.5 deg"] + + +background_selection: + # el_min : 40 + # el_max : 30 + nsb_diff : 1.5 + # 1/sin(el) difference + el_diff : 1.5 + # az difference + az_diff : 45 + # Minimum number of telescopes + n_tels : 4 + # Maximum time between runs in days + time_max : 180 + # Whether or not to smooth the background + smooth : true + smooth_sigma : 1 + # Whether bkgs should come from same season as data + same_szn : true + time_request : 20 + KL_DIV: true + #max_runs : true + #n_runs : 50 + + +run_selection: + # Runs of interests + # Source of interest + source_name : "Mrk 501" + pos_from_DL3: false + source_ra: 253.4675000 + source_dec: 39.7602778 + # Maximum offset to select data from + offset_max : 3.5 + # Number of telescopes to select + n_tel : 3 + # elevation min/maz + el_min : 20 + +spectrum : + e_min : 0.2 + e_max : 30 + e_bins : 8 + type : "PL" + #array of [normalization, spectral index] + params : [1e-11,2.72] + +lightcurve: + #light curve bin size in minutes + bin_size_min: 1000 + +sky_map: + map_deg: 2.5 + bin_sz: 0.01 + e_min: 0.1 + e_max: 100 + offset_max: 1.5 + aeff_max_percent: 0.1 + #exclusion regions are lists of lists of [[SkyCoord, radius], [SkyCoord, radius], ...] + exclusion_regions: [] + #theta defines the ON region size + theta: 0.0894427191 + #exclusion region around the source + on_exclusion_region: 0.35 + #RBM parameters + ring_rin: "0.6 deg" + ring_width: "0.133333 deg" + #whether or not to truncate the skymap colourbar at +/- 5 sigma + truncate: true + #safe mask max aeff % + #dimmest visual magnitude for stars to be excluded + min_star_brightness: 8 + +#where to save outputs +results_file: 'mrk501_v5_results.yaml' +plot_names: 'mrk501_v5' From 9683181d114f66f676357afebb3084ec650153c3 Mon Sep 17 00:00:00 2001 From: Samantha Wong Date: Wed, 22 May 2024 13:40:07 -0400 Subject: [PATCH 03/14] added ExcessMapEstimator fixes to RBM script, minor updates to notebook docs --- examples/analysis_notebook.ipynb | 344 ++++++++++++++---------- gammapy_tools/analysis/data_products.py | 2 +- gammapy_tools/analysis/rbm.py | 74 +++-- 3 files changed, 259 insertions(+), 161 deletions(-) diff --git a/examples/analysis_notebook.ipynb b/examples/analysis_notebook.ipynb index 6555dce..5436ad0 100644 --- a/examples/analysis_notebook.ipynb +++ b/examples/analysis_notebook.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "26f6e150", "metadata": {}, "outputs": [], @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "f01f9e8f", "metadata": {}, "outputs": [ @@ -55,7 +55,7 @@ "'/homes/wang/swong/.local/lib/python3.9/site-packages/gammapy_tools/__init__.py'" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -76,86 +76,14 @@ "\n", "This should be a \"full\" config file containing background generation information as well as analysis (RBM + 1D spectra and lightcurve) information. \n", "\n", - "An example config file is [example_config.yaml](example_config.yaml).\n", - "\n", - "Even if you have generated bkg headers elsewhere, the `'io'`, `'exclusion'`, `'analysis_selection'`, and `'run_selection'` parameters are re-used in the scripts needed to run this notebook.\n", + "An example config file is [example_config.yaml](example_config.yaml). Instructions for setting up the config file are listed as comments within the example file. \n", "\n", - "### Here are some details for setting up your config file:\n", - "\n", - "- **`io`** defines your directory structure - **this should be changed for every user to match their directory setup**:\n", - " - **`runlist`**: a typical EventDisplay runlist with 1 run number per line. This is \"optional\" but is helpful if you're using a large input directory (e.g., a directory containing all pre-processed data) and only want to analyze certain runs.\n", - " - **`in_dir`**: the directory containing your DL3 files (either pre-processed data or from V2DL3). These are the files we will be appending bkg headers to (if they already have bkg headers, the headers will be overwritten).\n", - " - **`out_dir`**: the directory containing the final DL3 files with bkg headers appended. This is the directory referenced for RBM analysis.\n", - " - **`results_dir`**: the directory where plots and high-level output will be saved.\n", - " - **`from_run`**: whether or not bkgs should be generated in a run-wise fashion or with similar data. For bkg generation in this notebook, this should be set to False. If you want run-wise backgrounds, [prepare_dataset.ipynb](prepare_dataset.ipynb) should be used instead of step 2 of this notebook. \n", - " - **`from_runlist`**: whether or not the bkg generatioin and analysis should only use selected runs defined above in `runlist` or if all runs in `in_dir` should be analyzed\n", - " \n", - "- **`binning`** defines the energy and camera coordinate binning of the bkg files - **this generally should not be changed except for experimenting with different bkg techniques**\n", - " - **`e_min`**: minimum energy bin [TeV]\n", - " - **`e_max`**: maximum energy bin [TeV]\n", - " - **`e_bins`**: number of energy bins\n", - " - **`off_min`**: minimum offset from camera center [deg]\n", - " - **`off_max`**: maximum offset from camera center [deg]\n", - " - **`off_bins`**: number of offset bins\n", - " \n", - "- **`config`** is used for multithreading - not used in this notebook **not used here, no need to change**\n", - "\n", - "- **`exclusion`** defines the exclusion regions masked out in bkg files - **the target source of each observation, gammacat, and HAWC sources are excluded automatically, so there is generally no need to provide `exclude_source_name` or `exclude_regions`**:\n", - " - **`star_cat`**: the catalog of stars to search for exclusion regions (this is by default the Hipparcos catalog used by ED). This generally should not be changed but the user can substitute for another catalog if they wish.\n", - " - **`exclude_source_name`**: exclude a source with a given, SIMBAD-resolved name\n", - " - **`exclude_regions`**: exclude source(s) given source coordinates in an array of tuples (one tuple per source) `[ (\"RA deg\", \"DEC deg\", \"radius_to_exclude deg\"), (\"287.10 deg\", \"6.39 deg\", \"0.5 deg\"), (), ...]`\n", - " \n", - "- **`background_selection`** defines the criteria that runs should fulfill to be included in bkg data. Ideally these should match run criteria as precisely as possible, but can be adjusted iteratively such that there are at least 10h of background data for every 30 minute target data run (i.e., each run you are appending bkgs to). Default values given here are similar to [Ruo's extended source validation memo](https://veritas.sao.arizona.edu/GammaWiki/images/9/99/Mimic_data_method_memo_v2.pdf) but slightly loosened to find matching runs in the same season as the target data.\n", - " - **`el_diff`**: maximum 1/sin(elevation) difference\n", - " - **`az_diff`**: maximum azimuth difference [deg]\n", - " - **`n_tels`**: minimum number of telescopes\n", - " - **`time_max`**: maximum difference in time between target run and bkg runs (not used if using `same_szn = True`\n", - " - **`smooth`**: whther or not to smooth bkg files by the PSF in camera space (default should be true)\n", - " - **`same_szn`**: whether bkg files should come from the same season as target runs (true is recommended)\n", - "- **`run_selection`**:\n", - " - **`runlist`**: not used in this notebook \n", - " - **`source_name`**: source name for output - should be a string\n", - " - **`source_ra`**: source RA (ICRS) [deg]\n", - " - **`source_dec`**: source DEC (ICRS) [deg]\n", - " - **`offset_max`**: maximum offset of events from camera center (default = 1.5)\n", - " - **`n_tel`**: minimum number of telescopes required for every run\n", - " - **`el_min`**: minimum run elevation\n", - " - **`KL_DIV`**: whether or not to use KL divergence criterion for finding closest bkgs in parameter space (if false, will attach every run within the above criteria as a bkg)\n", - " - **`time_request`** : if using `KL_DIV`, how many hours of bkg runs to use (will select $n$ hours worth of closest matched bkgs)\n", - "\n", - "- **`spectrum`** information for creating the source spectrum (this is a gammapy 1D reflected regions analysis)\n", - " - **`e_min`**: minimum energy bin\n", - " - **`e_max`**: maximum energy bin\n", - " - **`nbins`**: number of energy bins\n", - " - **`type`** : spectral model (string): \"PL\" = power law, \"LP\" = log parabola, \"EXPPL\" = exponential cutoff power law\n", - " - **`params`** : normalization and spectral index in an array: e.g., [3.48e-11,2.4]\n", - "\n", - "- **`lightcurve`** information for LC/flux analysis (1D reflected regions). No need to specify bin size if you're just running an integrated flux analysis (see section 3ii)\n", - " - **`bin_size_min`**: temporal bin size [minutes]\n", - " - **`threshold`**: energy threshold for integral flux calculations\n", - "\n", - "- **`sky_map`**: \n", - " - **`e_min`**: sky map energy threshold\n", - " - **`e_max`**: maximum energy in sky map\n", - " - **`map_deg`**: map size [deg] (square map => height = length) default = 2.5\n", - " - **`bin_sz`**: sky map bin size [deg] (ED default = 0.01)\n", - " - **`exclusion_regions`**: regions to exclude from significance calculations, formatted as lists of `[[SkyCoord, radius], [SkyCoord, radius], ...]` where SkyCoord is defined [here](https://docs.astropy.org/en/stable/api/astropy.coordinates.SkyCoord.html).\n", - " - **`theta`**: square root of theta^2\n", - " - **`on_exclusion_region`**: source exclusion region [deg] (0.35 for point sources is ED default)\n", - " - **`ring_rin`**: inner ring radius [deg]\n", - " - **`ring_width`**: ring width [deg]\n", - " - **`truncate`**: if true, truncate the sky map colourbar at $\\pm 5 \\sigma$, otherwise, show full significance range\n", - " - **`offset_max`**: Maximum allowed offset of events from camera centre\n", - " - **`aeff_max_percent`**': percentage of the maximal effective area to be used as lower energy threshold for method (see [here](https://docs.gammapy.org/dev/api/gammapy.makers.SafeMaskMaker.html)) (default is 0.1)\n", - " - **`min_star_brightness`**: dimmest B-band apparent magnitude to exclude stars in the FoV from significance calculations (ED default is 8)\n", - " \n", - "- **`results_file`**: yaml file to save results to (this will save within `[io][results_dir]`)\n", - "- **`plot_names`**: prefix of plot names (this will save within `[io][results_dir]`)" + "Even if you have generated bkg headers elsewhere, the `'io'`, `'exclusion'`, `'analysis_selection'`, and `'run_selection'` parameters are re-used in the scripts needed to run this notebook." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 10, "id": "31d9c848", "metadata": {}, "outputs": [], @@ -166,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 11, "id": "39e108e8", "metadata": {}, "outputs": [ @@ -191,15 +119,16 @@ " 'exclude_source_name': None,\n", " 'exclude_regions': None},\n", " 'background_selection': {'nsb_diff': 1.5,\n", - " 'el_diff': 1.5,\n", + " 'el_diff': 1,\n", " 'az_diff': 45,\n", " 'n_tels': 4,\n", " 'time_max': 180,\n", " 'smooth': True,\n", " 'smooth_sigma': 1,\n", " 'same_szn': True,\n", - " 'time_request': 20,\n", - " 'KL_DIV': True},\n", + " 'time_request': 50,\n", + " 'KL_DIV': True,\n", + " 'store_KL': False},\n", " 'run_selection': {'source_name': 'Crab',\n", " 'pos_from_DL3': True,\n", " 'offset_max': 3.5,\n", @@ -211,24 +140,25 @@ " 'type': 'PL',\n", " 'params': [3.45e-11, 2.6]},\n", " 'lightcurve': {'bin_size_min': 1000},\n", - " 'sky_map': {'e_min': 0.1,\n", + " 'sky_map': {'e_min': 0.01,\n", " 'e_max': 100,\n", - " 'map_deg': 2.5,\n", + " 'n_bins': 30,\n", + " 'map_deg': 3,\n", " 'bin_sz': 0.01,\n", - " 'offset_max': 1.5,\n", - " 'aeff_max_percent': 0.01,\n", + " 'offset_max': 1.75,\n", + " 'aeff_max_percent': 0.1,\n", " 'exclusion_regions': [],\n", " 'theta': 0.0894427191,\n", - " 'on_exclusion_region': 0.35,\n", - " 'ring_rin': '0.5333335 deg',\n", + " 'on_exclusion_region': 0.45,\n", + " 'ring_rin': '0.6 deg',\n", " 'ring_width': '0.133333 deg',\n", " 'truncate': True,\n", " 'min_star_brightness': 8},\n", - " 'results_file': 'segue_ps_results.yaml',\n", - " 'plot_names': 'segue_ps'}" + " 'results_file': 'crab_test_results.yaml',\n", + " 'plot_names': 'crab_test'}" ] }, - "execution_count": 24, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -263,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 29, "id": "1b75f049", "metadata": {}, "outputs": [ @@ -309,14 +239,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 30, "id": "5ba318d7", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e85f4f598d2f4570a982135770c88fe9", + "model_id": "0bb01e0a968f4994bcc6987cd9b33719", "version_major": 2, "version_minor": 0 }, @@ -326,6 +256,49 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64080 used 29.812705993652344 hours for background generation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gammapy.data.data_store:Observations selected: 90 out of 90.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64081 used 43.38678741455078 hours for background generation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gammapy.data.data_store:Observations selected: 135 out of 135.\n", + "INFO:gammapy.data.data_store:Observations selected: 157 out of 157.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64083 used 40.86215591430664 hours for background generation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gammapy.data.data_store:Observations selected: 127 out of 127.\n" + ] } ], "source": [ @@ -346,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 31, "id": "1224dc28", "metadata": {}, "outputs": [], @@ -361,12 +334,14 @@ "source": [ "## Peek at data to make sure everything worked - optional\n", "\n", - "All plots should load, in particular make sure the background rate histogram is filled, since this is the only part of the DL3 file we've changed in this notebook." + "All plots should load, in particular make sure the background rate histogram is filled, since this is the only part of the DL3 file we've changed in this notebook.\n", + "\n", + "This will take a while to download for long runlists, so feel free to skip this or terminate it early if everything looks fine!" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 32, "id": "a258c073", "metadata": { "scrolled": true @@ -388,7 +363,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -407,7 +382,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -426,7 +401,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -445,7 +420,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -492,22 +467,17 @@ "\n", "If a spectrum type is not provided, this script will do a power law fit by default.\n", "\n", + "The **integral flux** is calculated by integrating a power law fit to the spectrum between `config[\"spectrum\"][\"e_min\"]` and `config[\"spectrum\"][\"e_max\"]`.\n", + "\n", "The first plot produced shows the exclusion regions used, and the second is an $E^2 \\frac{dn}{de}$ spectrum." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "1e3141d3", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:gammapy.data.data_store:Observations selected: 4 out of 4.\n" - ] - }, { "data": { "text/plain": [ @@ -519,15 +489,7 @@ } ], "source": [ - "spectral_points, spectral_model, cumulative_time, cumulative_sig = make_spectrum_RE(config, plot=False)" - ] - }, - { - "cell_type": "markdown", - "id": "f5c1ef48", - "metadata": {}, - "source": [ - "Write normalization and index from spectral fit to config file to use for flux calculations" + "spectral_points, spectral_model, cumulative_time, cumulative_sig, flux, flux_err = make_spectrum_RE(config, plot=False)" ] }, { @@ -540,7 +502,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "id": "54c1b078", "metadata": { "scrolled": true @@ -552,7 +514,7 @@ "" ] }, - "execution_count": 12, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, @@ -589,12 +551,43 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 37, "id": "31569f55", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gammapy.data.data_store:Observations selected: 4 out of 4.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbUAAAE6CAYAAACRTMzQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsZklEQVR4nO3de7wVdb3/8debe4iiIFABgorHNENQUMlMrTCvaJYoWd5NTSu7/I6amtrROsfKo1beOpqaHlExFfFWehJLEUHUvEF4Z5OFggqkiMrn98fMhsVmb9iXtWbNmvV+Ph7z2GtmzZp5rzWz9md956qIwMzMrAg6VTuAmZlZubiomZlZYbiomZlZYbiomZlZYbiomZlZYbiomZlZYXSpdoB6tvHGG8fQoUOrHcPMrKY89thjb0REv+aec1GroqFDhzJz5sxqxzAzqymSXmnpOW9+NDOzwnBRMzOzwnBRMzOzwvA+NTOrW++//z4NDQ0sW7as2lGsGT169GDQoEF07dq11a9xUTOzutXQ0MD666/P0KFDkVTtOFYiIli4cCENDQ1suummrX6dNz+aWd1atmwZffv2dUHLIUn07du3za1oFzUzq2suaPnVnmXjomZm1gYHXz6Ngy+fVtZpfvjhh4wcOZJ99913rePdcsstSFp5fuv111/PiBEjVnadOnXiiSee6FCWiODb3/42w4YNY/jw4cyaNWvlc9dccw1bbLEFW2yxBddcc80ar/3Sl77EiBEjGDZsGL17916Z6+GHH15tvJdffplBgwaxYsWK1YaPGDGC6dOndyi/96mZVUnjP8YbjxtT5SRWbRdddBFbbbUVixcvbnGcJUuWcNFFF7HjjjuuHHbooYdy6KGHAvDUU09xwAEHMGLEiFbPd+jQobz88surDbv77ruZO3cuc+fOZfr06ZxwwglMnz6dRYsWcc455zBz5kwksf322zNu3Dg22mijla+99dZbAXjggQf4+c9/zpQpU1qc7yabbMKf//xndt11VwBmz57NkiVLVnt/7eGWmplZFTU0NHDnnXdyzDHHrHW8M888k1NOOYUePXo0+/wNN9zAIYccsrL/D3/4A2PGjGG77bbjoIMOYunSpa3Kc/vtt3PYYYchiZ122om33nqL1157jXvvvZexY8fSp08fNtpoI8aOHcs999yzzum9/vrrfPnLX2b06NGMHj2ahx56CIAJEyYwceLEleNNnDhxtfzt5aJmZtZKry58hycb3mL6S4sYe8FUXl34ToenefLJJ3P++efTqVPL/45nzZrFvHnz2GeffVoc58Ybb2TChAkAvPHGG5x77rncd999zJo1i1GjRnHBBRe0Ks/8+fMZPHjwyv5BgwYxf/78Foevy3e+8x2++93vMmPGDG655ZaVxXv8+PHcdtttfPDBB2vk7whvfjQzW4vS/WdPNrzFsveT/UBzFyxljwunsu2gDYH2bUaeMmUK/fv3Z/vtt+eBBx5odpwVK1bwve99j6uvvrrF6UyfPp2ePXuyzTbbAPDII4/w7LPPsvPOOwOwfPlyxoxJ8p144okrW0t///vfV26uPOiggzj99NPb/B7W5b777uPZZ59d2b948WKWLl3KgAED2Gabbbj//vsZMGAAXbp0WZm/I1zUzMxaqbGgtdTfVg899BCTJ0/mrrvuYtmyZSxevJivfe1rXHfddSvHWbJkCU8//TS77bYbAP/4xz8YN24ckydPZtSoUUCy6a60lRMRjB07lhtuuGGNef76179e+Xjo0KFrHFgycOBA5s2bt7K/oaGBgQMHMnDgwNUKb0NDw8pMa7NixQoeeeSRZjebNm6CHDBgQFlaaUDy5t21vwM2A64EJqX9WwGXAZOAE9b22u233z6sfo2/7OEYf9nD1Y5R15599tk2jf+FXzwQQ06ZEkNOmRKbnjolvvCLB8qW5U9/+lPss88+6xxv1113jRkzZqzs//DDD+PjH/94vPDCCyuHLViwIAYPHhxz586NiIilS5fGnDlz1pjWkCFD1hg2ZcqU2HPPPWPFihUxbdq0GD16dERELFy4MIYOHRqLFi2KRYsWxdChQ2PhwoXrfC8TJkyI888/f+Vzjz/++MrHb775ZvTv3z+GDh26Wv5SzS0jYGa08H+15vapSfqupGckPS3pBknN7zVd93SukrRA0tPNPLenpDmSnpd06tqmExEvRsTRJf3PRcTxwHhg5/ZkM7N8uvLw0fTomvzb3LxfL648fHTF5vWjH/2IyZMnr3O8Bx98kMGDB7PZZputHNavXz+uvvpqJkyYwPDhwxkzZgyzZ89u1Xz33ntvNttsM4YNG8axxx7LJZdcAkCfPn0488wzVx7w8aMf/Yg+ffqsc3oXX3wxM2fOZPjw4Wy99dZcdtllK5/bcMMNGTNmDAMGDFgtf0coKXq1QdJA4C/A1hHxrqSbgLsi4uqScfoD70bEkpJhwyLi+SbT+iywFLg2IrYpGd4Z+BswFmgAZgATgM7AT5tEOioiFqSvmxQRX0kfjwNOAH4XEf/b0vsZNWpU+H5q9cuH9Fffc889x1ZbbdWm13i5Zau5ZSTpsYgY1dz4NddSI9kP+BFJXYCewN+bPL8rcJuk7gCSjgV+2XQiEfEgsKiZ6e8APJ+2wJYDE4H9I+KpiNi3SbeguYARMTki9gIObe+bNDOztqupA0UiYr6knwOvAu8Cf4iIPzQZ52ZJmwI3SroZOIqk1dVaA4F5Jf0NQItnA0rqC5wHjJR0GjANOBDoDtzVwmv2A/YbNmxYG2KZWR64hZZvNVXUJG0E7A9sCrwF3CzpaxFxXel4EXG+pInApcDmEdG6sw7bISIWAsc3GfzAOl5zB3DHqFGjjq1ULjOzelRrmx+/ALwUEa9HxPvA74FPNx1J0i7ANsCtwFltnMd8YHBJ/6B0mJkVUC0dV1Bv2rNsaq2ovQrsJKmnkss3fx54rnQESSOBK0hadEcCfSWd24Z5zAC2kLSppG7AIcC6D0Eys5rTo0cPFi5c6MKWQ5HeT62ly4K1pKY2P0bEdEmTgFnAB8DjJAWsVE9gfES8ACDpMOCIptOSdAOwG7CxpAbgrIi4MiI+kHQScC/JEY9XRcQzFXpLZlZFgwYNoqGhgddff73aUawZjXe+bouaKmoAEXEWa9mkGBEPNel/H/hNM+O1ePp6RNxFCwd5mFlxdO3atU13Vbb8q7XNj2ZmZi1yUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTMzs8JwUTOrglcXvsOTDW8x/aVFjL1gKq8ufKfakcwKoeau0m/WXgdfPq3aEVZ6suEtlr2/AoC5C5ayx4VT2XbQhtUNlbrxuDHVjmDWbm6pmVVBY0Frqd/M2sctNasbeWqBjL1gKnMXLAWgk2Dzfr1ylc+sVrmlZlYFVx4+mh5dk6/f5v16ceXho6ucyKwY3FIzq4JN+vZcuQ/NLTSz8nFLzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCsNFzczMCqPi136U1KcVo62IiLcqncXMzIotiwsa/z3ttJZxOgObZJDFzMwKLIui9lxEjFzbCJIezyCHmZkVXBb71FpzXw3fe8PMzDqs4kUtIpaVYxwzM7N1qWhRkzRW0m8kjUj7v1HJ+ZmZ2eoOvnwaB18+rdoxMlPpfWpHAScAZ6RHQY6o8PzMzKyOVXrz45KIeCsifgDsAYyu8PzMzKyOVbqo3dn4ICJOBa6t8PzMzKyOVbSoRcTtAJI2Tvt/Wcn5mVmx1dv+IWu7rC6TdVVG8zEzszqWVVFb29VEzMzMyiKrohYZzSdzkjaTdKWkSWn/VpIukzRJ0gnVzmdmVk9qqqUmaUtJT5R0iyWd3M5pXSVpgaSnm3luT0lzJD0v6dS1TSciXoyIo0v6n4uI44HxwM7tyWZmZu2TxbUfAU4rx0QiYg7puW6SOgPzgVtLx5HUH3g3IpaUDBsWEc83mdzVwK9ockRmOt1fA2OBBmCGpMkkF13+aZNpHBURC5rmlDSO5Py837XtHZqZWUdk0lKLiDVaQ2XweeCFiHilyfBdgdskdQeQdCywxlGXEfEgsKiZ6e4APJ+2wJYDE4H9I+KpiNi3SbdGQUunPTki9gIObf/bMzOztsqqpYakUcDpwJB0vgIiIoa3c5KHADc0HRgRN0vaFLhR0s0kVzUZ24bpDgTmlfQ3ADu2NLKkvsB5wEhJpwHTgAOB7sBdLbxmP2C/YcOGtSGWmZmtS2ZFDbge+H/AU8CKjkxIUjdgHC1s1oyI8yVNBC4FNo+IpR2Z39pExELg+CaDH1jHa+4A7hg1atSxlcpl+Xfjcb45hVm5ZVnUXo+IyWWa1l7ArIj4Z3NPStoF2IZkf9tZwEltmPZ8YHBJ/6B0mJmZ5VyWRe0sSf8D3A+81zgwIn7fjmlNoJlNjwCSRgJXAPsCLwHXSzo3Is5o5bRnAFukmzDnk2zm/Go7MpqZWcayLGpHAp8AurJq82MAbSpqktYj2Ud2XAuj9ATGR8QL6fiHAUc0M50bgN2AjSU1AGdFxJUR8YGkk4B7SY54vCoinmlLRjMzq44si9roiNiyoxOJiH8Bfdfy/ENN+t8HftPMeBPWMo27aOEgDzMzy6+sTr4GeFjS1hnOz8zM6kyWLbWdgCckvUSyT62jh/SbmZmtJsuitmeG8zIzszqU5ebHHwNvR8Qr6VVAFpMcbm9mZlYWWRa14RHxVmNPRLwJjMxw/mZmVnBZFrVOkjZq7JHUh2w3f5qZWcFlWVR+AUxLr8cIcBDJNRPNzMzKIrOiFhHXSpoJfC4ddGBEPJvV/M3MrPgy3fyXFjEXMjMzq4gs96mZmZlVlIuamZkVRqZFTdIpWc7PzMzqS0X3qUm6qbQXGAH8VyXnaWZmiVcXvsOTDW+x7P0VjL1gKlcePppN+vasdqyKqvSBIosj4pjGHkmXVnh+ZmZVc/Dl06odYTWNBQ1g7oKl7HHhVLYdtGF1Q6Uqdef3Sm9+PA9A0sZp/+kVnp+ZmaUaC1pL/UVU0ZZaRLyUPrwKGBcRiyo5PzOzaqpU66O9xl4wlbkLlgLQSbB5v165y1huWR0ooozmY2ZmqSsPH02Prsm/+c379eLKw0dXOVHlZXXydWQ0HzMrqHo86KGjNunbc+U+tKK30BplVdTcUjOrQXk68KEeD3qwtstq8+NpGc3HzAqqHg96sLbLpKUWEU9nMR8zK688tUDq8aAHa7vMrigi6SBJ66ePz5D0e0nbZTV/M6tt9XjQg7VdllfpPzMibpb0GeALwM+AS4EdM8xgZjWqHg96sLbL8tqPH6Z/9wGuiIg7gW4Zzt/MzAouy6I2X9LlwMHAXZK6Zzx/MzMruCyLynjgXuCLEfEW0Af4fxnO38zMCi6zfWoR8Q7w+5L+14DXspq/mZkVnzf/mZlZYfgmoWZmVhi+SaiZmRWGbxJqZmaFkclNQkv4JqFmZlYxFS1qjTcJbbzztW8SamZmlZTVgSJXZTQfMzOrY77ztZmZFUZWRc13vjYzs4pzS83MzArDd742M7PCqHhRk/RrYMNKz8fMzCyLltrfgJ9JelnS+ZJGZjBPMzOrQxUvahFxUUSMAXYFFgJXSZot6SxJ/1bp+ZuZWf3I7ILGEfFKRPxXRIwEJgAHAM9lNX8zMyu+zIqapC6S9pN0PXA3MAc4MKv5m5lZ8VX8JqGSxpK0zPYGHgUmAt+IiH9Vet5mZlZfsrjz9WnA/wLfj4g3M5ifmZnVqYoXtYj4HIASXwM2i4gfS9oE+GhEPFrpDGZmVh+yvPP1JcAYkk2RAEuAX2c4fzMzK7gsNj822jEitpP0OEBEvCmpW4bzNzOzgsuyqL0vqTPpxY0l9QNWZDj/ipC0GcnNT3tHxFckbQV8B9gYuD8ifLdvM6uaG48bU+0Imcpy8+PFwK1Af0nnAX8BftLWiUjaUNKk9ATu5yS1a4lJukrSAklPN/PcnpLmSHpe0qlrm05EvBgRR5f0PxcRxwPjgZ3bk83MzNoni0P6u0TEBxFxvaTHgM+TXLX/gIhoz8nXFwH3pK2ibkDPJvPrD7wbEUtKhg2LiOebTOdq4FfAtU1e35lkX99YoAGYIWky0Bn4aZNpHBURC5oGlDQOOAH4XdvfnpmZtVcWmx8fBbYDiIjZwOz2TkhSb+CzwBHp9JYDy5uMtitwvKS9I+I9SceSnOS9V+lIEfGgpKHNzGYH4PmIeDGd50Rg/4j4KbBva3JGxGRgsqQ7SU5nMDOzDGRR1Mp5L7VNgdeB30raFngM+E7pidwRcbOkTYEbJd0MHEXS6mqtgcC8kv4GYMeWRpbUFzgPGCnpNGAaSRHtDtzVwmv2A/YbNmxYG2KZmdm6ZFHU+kn6XktPRsQFbZhWF5JW37ciYrqki4BTgTObTPP8tIV1KbB5RCxtR+5WiYiFwPFNBj+wjtfcAdwxatSoYyuVy8ysHmVR1DoDvShPi60BaIiI6Wn/JJKithpJuwDbkByYchZwUhvmMR8YXNI/KB1mZlVWb0fyWdtlUdRei4gfl2NCEfEPSfMkbRkRc0gOOnm2dJz0fm1XkOz/egm4XtK5EXFGK2czA9gi3YQ5HzgE+Go58puZWWVlcUh/OfepAXyLpFD9FRjBmqcF9ATGR8QLEbECOAx4ZY1Q0g0k+7+2lNQg6WiAiPiApGV3L8mtcW6KiGfK/B7MzKwCFBGVnYHUJyIWVXQmNWrUqFExc+bMascwM6spkh6LiFHNPZdFS+2+dY0gaVYGOazCDr58GgdfPq3aMcysjmWxT22rdFNhSwT0ziCHmZkVXBZF7ROtGOfDiqcwM7PCy+J+amscpGFmZlYJWV7Q2MzMrKJc1MzMrDAyK2pKfE3Sj9L+TSTtkNX8zcys+LJsqV0CjAEmpP1LSG7xYmZmVhZZ3vl6x4jYTtLjABHxZno/NDMzs7LIsqX2fnoDzgCQ1A9YkeH8zcys4LIsaheTXDW/v6TzgL+w5nUbzczM2i2zzY8Rcb2kx0iurC/ggIh4Lqv5m5lZ8WW5T42ImA3MznKeZmZWPype1NZ212to852vzczMWpRFS2399O+WwGhgctq/H/BoBvM3M7M6kcW1H88BkPQgsF1ELEn7zwburPT8zcysfmR59OMAYHlJ//J0mJmZWVlkeaDItcCjkm4lOfpxf+CaDOdvZmYFl+Uh/edJuhvYheQE7CMj4vGs5m9mZsWX5QWNu5PcMHQ9YENgv8aLG5uZmZVDlpsfbwfeBh4D3stwvmZmVieyLGqDImLPDOdnZmZ1JsujHx+W9KkM52dmZnUmy5baZ4AjJb1IsvlRQETE8AwzmJlZgWVZ1PbKcF5mZlaHqn7tR8DXfjQzs7LwtR/NzKwwfO1HMzMrDF/70czMCqNa134EOAC4OsP5m5lZwVXr2o/gaz+amVmZZdlSIyJmAbOynKeZmdWPLPepmZmZVZSLmpXFqwvf4cmGt5j+0iLGXjCVVxe+U+1IZlaHMt38aOVz8OXTqh1hNU82vMWy91cAMHfBUva4cCrbDtqwuqFSNx43ptoRzCwjbqlZWTQWtJb6zcyy4JZajcpb62PsBVOZu2ApAJ0Em/frlbuMZlZ8bqlZWVx5+Gh6dE1Wp8379eLKw0dXOZGZ1SO31KwsNunbc+U+NLfQzKxa3FIzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFEzM7PCcFHrIEmbSbpS0qS0fytJl0maJOmEauczM6snNVfUJL0s6SlJT0ia2YHpXCVpgaSnm3luT0lzJD0v6dS1TSciXoyIo0v6n4uI44HxwM7tzWdmZm3XpdoB2mn3iHijuSck9QfejYglJcOGRcTzTUa9GvgVcG2T13cGfg2MBRqAGZImA52BnzaZxlERsaCZDOOAE4DfteVNmZlZx9RcS60VdgVuk9QdQNKxwC+bjhQRDwKLmnn9DsDzaQtsOTAR2D8inoqIfZt0axS0dNqTI2Iv4NDmnpe0n6Qr3n777fa9QzMza1YtFrUA/iDpMUnfWOPJiJuBe4EbJR0KHAUc1IbpDwTmlfQ3pMOaJamvpMuAkZJOk7SbpIslXQ7c1ewbiLgjIr7Ru3fvNsQyM7N1qcXNj5+JiPnpZsY/SpqdtrpWiojzJU0ELgU2j4illQoTEQuB45sMfqBS8zMzs5bVXEstIuanfxcAt5JsLlyNpF2AbdLnz2rjLOYDg0v6B6XDzMws52qqqElaT9L6jY+BPYCnm4wzErgC2B84Eugr6dw2zGYGsIWkTSV1Aw4BJpcjv5mZVVZNFTVgAPAXSU8CjwJ3RsQ9TcbpCYyPiBciYgVwGPBK0wlJugGYBmwpqUHS0QAR8QFwEsl+ueeAmyLimYq9IzMzK5ua2qcWES8C265jnIea9L8P/KaZ8SasZRp30cJBHmZmll+11lIzMzNrkYuamZkVhouamZkVhouamZkVRk0dKGL5duNxY6odwczqnFtqZmZWGC5qZmZWGC5qZmZWGC5qZmZWGC5qZmZWGC5qZmZWGC5qZmZWGC5qZmZWGIqIameoW5JeZ9VtcTYG3qhinObkMRPkM5cztY4ztY4zrd2QiOjX3BMuajkhaWZEjKp2jlJ5zAT5zOVMreNMreNM7efNj2ZmVhguamZmVhguavlxRbUDNCOPmSCfuZypdZypdZypnbxPzczMCsMtNTMzKwwXNTMzKwwXtSqStIWkT1U7R6mcZtpa0u7VzlEqj5kgt8svj5lyt/z8OZWH96lVgaTOwKXA7sB8YApwU0S86kyrZeoEXATsQXKS+qPA7RExw5nWyJXH5ZfHTLlbfv6cysstterYBNgwIrYAvkFypv43JfV0ptX0TrutgQnA68D3JW3gTGvI4/LLY6Y8Lj9/TmXkopYRSZuVrKTdgdGSekTE34DbgY8A451JW0kakPZuCOwM9IyIhcDvSS7T8616z5TmyuPyy2Om3C0/f06V46JWYZI+KmkqcD1wu6QRwFzgTuDr6WhPAo8D20jaqE4zbZxm+i1wm6TdI+Il4F7g++lorwG3AJ+SNKgeM6W58rj88pgpd8vPn1PluahV3kHArIgYA/yRZCUZAzwEjJI0OCLeAeYBg4B36zTTbsDTEbET8BvgEEkHAdelmbaIiA+ABcAykl+y9ZgJ8rn88phpN/K3/Pw5VZiLWoVIUvqwK9ANICLOJ9k2vQPJL5/XSH8JRcT9wECgYtus85ipxIYkX2Ii4irgKWC79LkHgfPT554h2QexvN4y5XH55TFTiQ3JyfLz55QdF7UyS48aKvVP4J+Shqb9E4HhJCvGlcAXJF0o6Wngr8DiOsnUqDHbs8Arkkam/X8EOgNDgQuB/pJ+lWaaB7xZ8o+isJnSXHlcfnnMlLvl588pey5qZSBpsKRDJfWMiBUAsepciceAISTbohURjwIrgD0iYh6wL3AfcHZEnBgRywqcaYikkyR9FOgUiRVKDmn+G8mmll0kdYqIOWn/dhGxHDiQZD/E6RFxeEQsLnk/hcqU5srj8stjptwtP39O1eWi1kGSTiJpon8FuEDSEenwnSWdHRGzgeeAnUi2XQNMBvqkK/XLETElIiYVPNMRJF/WTwPnAj9Mhw8nOUdnITAT2BQ4OH3Zn4CPpV+0f0bEtIi4vciZ0vnncfnlMdMR5Gz5+XPKgYhw14EO+C9gt/TxF4FpwFZAL6BvOvyjwAkkv9JOJWnCH1gPmVh1gv/pwNfTx1sCrwKj0/7GTBsA+wEvAmenmY6o4OeUu0zpPM/Py/LL4zqV5+WXp88pz9+9SnZVD1BrHbAj8I30cXfgAeAzJc+fBkxu4bV7Az8CPlvmTJ8APtkk0y5VztQv/duJZPv8b4EDSp7/HjCzhdd+BjixApn+DdgifdwlD5nSaX8S2D593C0n69R2wCHp4x7A1Bxk2hk4NU/Lz9+9/HVVD1ArHTCApKk+vfHLng4/E7i3pH8jkh2tn0v7NwD2r1CmbiTbup8F/gycnA4/GbivSpn6ADeS/BocXDL8e8DUJuM+Dnw5fbw+cHSFMvVLv9iPk2wa+k46/FvAg9XIVLJOXZHO866Sf9inV2udSqffKV2nngFGpsPOqeJ63g+4LP3uHV0yvJrrlL97Oe28T631bgV2iIgdI2JiyfCfAxtJGpf2LwdmkGxigOQXb2dY7bDectkU6BwRWwMnAR+XdA5wNdBd0gFVyHQ4yRFbtwL/0TgwIi4ABksqvUrCtSS/dEmzLSt3Jknd0hyLI2IkScH4nKRNIuKXwCZZZyrxE2BpmuuHwJckrQ/8giqtU+kRcT2AP5Asw5NLsvat0np+KUlx3TEirmwcWLJOHVwyblbLz9+9vKp2Vc17R7LiAuwKvJg+HgccQ7o5huRyNi8C66X9NwB7pY87VTDbSOBvJf2fBS4h2ayxV5aZWLX9vg9JC2QAyT6D3UrGOYDkHJit0/5LKGn1VvBz2prkcj+N/Q8AX61WppLPqjTTMcBtJevUl6uxTqXTXw/4P5LNfROBL6bDDwJeynCd6pT+HQM8UfK5nALsm/bvBTxdhXXK372cdm6ptaDkF0sARMRUYLak5cBxJBcd/a2kgyLiJpJfthdKehT4GMlhskR6SG+ZszUut7nAXyR9Ne1/Iu12j4i7SS5zk0kmQOm0F0VytNQ/gauAMxpHiIjbSDaPnJxm2pbkXJyKKPmc/hYR70jqkg57t3G+WWdqjJbO+50054EkLbUHgNMlfTsibiHZJHlRluuUpC4kV4yYFREPAZOAf5f0q4i4mWSd+u+M1inSaU8DnpL0OnAsyfI7Q9IP0vX8Wiq8/Br/H+Tpu1fyPyp3372qqnZVzVNHclXqb5NsWvhIyfDGX1z9gVNKhh8N3Jw+/gjJ2fZfKnOm9YGPNTO8a/r3GJL9DRun/fsAE6uUqUf6t/GX43rA/cCRTcbbCNgz60wkm326kBzePKDSmVqTq5nhewI3kfxo6pHx8vtI+rc/yYnAm5AUjCXAjelzvTLO1Cv92xf4ZpPPaWL6OXWu0Dq1AUkRHdrk/0E1v3stZarady9vXdUD5KUDxgJzgJuBy4GL0uEDgf8BBjXzmo8B9wDrVyjTkSQnZv6m8cudDl+f5NyWASSHC/8M+M/0ufVIfvFvVIVMtwObNBl/R5JzYM4m+eXYu5qZSDap/TZ9fHL6j+kj5c7UjlyN/4x6kfzK71ulTEPSbjLJtf4uIdl0dT8wpEqZNm3mNRuQbB3pU6FMJ5EcKDOJpLCfXZKpWt+9tWWqyncvj13db34sacIPBH4XEQcBZwG7STo0IuYDZ0REQ5PX7Uty1eqHgH9VIFc/kl9Vx5MUz+0bn4uIJSS/wP4JzCb5tXiApJ+TbEufUcVMTW9s2J9kU8euJL/2365ypuEkV3P4I8kPmfsiouwXjW1LrvQE15C0P3A3yb6PpRU4CGRdmY6KiFdIitltwKcj4pskBe1/gXfKmaeVmY6M5Irxpa/Zn2TT7JPA0gpkGk5ycvS+EfEV4BpgiJKLDVfru9eaTJl+93Kr2lW1Wh3pLzxW/UL+T9LDctP+vYGGZl7XjWSz42PA3pXIVNI/KP17KslRVRuv5bXDgP2BcTnKtBXJr9r9c5TpbKCBkp3o1c5FcpHbr5P8Q8zNOpWOJ8p8cEMHl9+BwKwMPqcRJY9HkmyR6dLCa7P67rUlU0W+e7XQVT1A5m84+QfyS5JfozuXDN8XmNNk3DtZde5QV+Dw9HHvSmdK/5k0FtzuJJukJgDd02GdSc4n+n7jeDnK9L1y/yMsUyaR3GE4T7m+m47b7D62KmRS42eVs8+pcfl1rnSmZsb5JEnLcP3GvFl/91qZqXHZVfTo2Lx39bj58cskJ3NeSnLiNAARMQV4Q9KZJeP+luT6Z53T13SW1C3K34xfI1OkJHWOiPdINjdMIDnQAZIv9wqSTULdK3B+SUcyvQt005pXKK96JqASm2A6kmsZyT/z93KSKUg+qzyuU91J9r1VNFOjkvV3B5LzCZekn09jpn+R0efUykxB8v+gEt+92lHtqppVx6pfgz1Ijm7sRnIuzlEl43wSeJlVvyJ/CPx7tTLR5FcpyY70q0k2Ux3hTNXLlNdczlT+TCSbRfcBRpAckLFfvWSqxa7qAar65pNNjo9RsumH5EKjl5Jc+uZJKrDvpS2ZSlb0ziTnwbwATHCm/GXKay5nanemxgsv3E6yH3Ya6aWl6jlT3ruqB6jgynAG8FVWXWx0jR2qJNugrwd+0mR4d8q8I7q9mUpW4s9Tco6cM2WbKa+5nKmimRr3nc0Avl8PmYrQNf46Koz0UPtzSS6d8yTJEY0D1zL+YJLDlycDPYELI+K1HGVaj+Q8mEXOlH2mvOZypkwybUBylf1OUaabdeY1U6FUu6qWsyP5YhzB6rfImAT0Tx+vcVQQyXkxb5McJvxpZ3KmvOdypswyNXvkYdEyFa2reoAyrCQbsvoO1G7p3/VJDsl/huQCqGuc+0Jy6Z1JwLHO5Ex5zuVMzlTOTEXuqh6ggyvLySSH+J7ZzHN7AP9Ocv21XwA3pcPV3F9ncqa85nImZypnpqJ3NbtPTdIWJPcP+jvwTWBsRLwmSRErz3v5MB23M/APkk0cc53JmWollzM5k7VRtatqRzrSC52S3GbhN2sZb3uSI4h6OZMz1VouZ3Imd234zKsdoEPhVzXP+5Kc17JjyXM9gC2Bi0muVJ3J7cqdqXYz5TWXMzmTu9Z3ub+UiqTDJe0iqXfa33gzw8YmfNeIWEhye5jSW5gvAz4FLAI+GyW3gXem+s2U11zO5EzlXs/rVS73qUkS8HGS26AvJ/mF0ws4KSLeVHL9xeXNvG4aydn3WwDnRsSfncmZ8prLmZyp3Ou5ka/Nj5Qc5UNy64TfpY+7kFy66saS5zcjuV3MJml/d+B5kht9HuhMzpTXXM7kTOVez92VLKNqByhZAZpe1PRA4NqS/u4kt2LYCRgNzAW+1fha4DjKfPFhZ6rdTHnN5UzOVO713F2T5VTtAOkCPwZ4DTirZNh6wDxWvzHed4DJ6ePeTaZR7hsZOlONZsprLmdypnJmctd8V/UDRSR9AtiPpJm+v6QhABHxL5JbpV+SjtcJuAVYJmlIRLwtqXO6bZtI7m/kTHWeKa+5nMmZyr2eWwuqXVUj+QXzifTvz0i3UZc891fgm+njnYDrnMmZajGXMzmTu8p3VW+pAUTE7PThfwNbSdq95OnjgW0k3QlcS3JRz8ajj5zJmWomlzM5k2Ugq+oJjAQGtWK8E4E/NTN8d+CjzuRMec7lTM5Uzkzu2t5V/Dw1SduRNNlFsmP1DOCBiHhfUpeI+KBk3MaTFW8DXiY5TPbqiJjpTM6U51zO5EzlzGQdUMmKCQwA7gFOTPu/TXINtG4l4/Qhub/Q4LR/PeBhkkNjT3QmZ8p7LmdyJnf56Soz0VW3Zu8OfKpkeFfgJVZd5PNzJIfJnsqqq5v8jOQ2DF2dyZnynMuZnKnc67m7MizbMq8o44Fbgb1KhnVK/3YhuW/QvcAG6bD+wJAm0+jmTM6U51zO5EzlzOSuvF2Hj35sPMJH0k7A6SS/dLaX9HFIzs1It0N/QHKl6iURsTh9+cKIeEVSl5JzOda4Xpoz1U+mvOZyJmcq93puldGhoqbkop2R9j4H7Av8GOhHciQQACXj7E6yLRpJPwG+0LgylYzTIc5Uu5nymsuZnKnc67lVTruLmqRvAY9K+g9J+0bE2xExLyIeBV4EhkvaOh23c/qyfwPGSXqYZOfr1DL/Q3SmGs2U11zO5EwuZrWlXUVN0q7A14CjgGeAsyTtXDLKPSRN/M8DRHrLcmBIOs8jIuL4SO4nVBbOVLuZ8prLmZyp3Ou5VV6X1o4oqXPJgu8H3BsRs4BZkjYiue3CcICImCPpEWBrSV8HNouIc4AjI+If5QrvTLWbKa+5nMmZyr2eW7bW2VJTckHOnwA/kfTFdPAHwGcbx4mIS4EVkr5R8tK/kBxpdAHQMx2vLCuLM9VuprzmciZnKmcmq6JYy6GRwK7AEyS/cI4GZgCfSZ+bA3y9ZNx9gLvTxwJuAm4D+q5tHm3tnKl2M+U1lzM5U7nXc3fV69a1wuzSZKW4CPhZ+ng/4BWgR9q/Hckvnm5pf++KBHamms2U11zO5EzuitOt9dqPknoCHwIfRMSHkiaQXPTz1EjO7fgtsBy4DzgIeDsijm1xgmXgTLWbKa+5nMmZrDjWuk8tIt6JiPdi1c7XLwLzYtXN7k4GJgMHA3OyWFmcqXYz5TWXMzmTFUhrmnNAZ5ICeDeweTpsG6BX+jjzy8Y4U+1mymsuZ3Imd7XftfY8tRUk53S8AWwr6Q7g+6SnBER1LhvjTLWbKa+5nMmZrNa1tvqR3KZ8BclhsEdXuxo7U21nymsuZ3Imd7XdtfomoZIGAV8HLoiI99paPCvBmVonj5kgn7mcqXWcyfKq4ne+NjMzy0qHbz1jZmaWFy5qZmZWGC5qZmZWGC5qZmZWGC5qZmZWGC5qZmZWGC5qZjVIUl9JT6TdPyTNTx8vlXRJBeZ3taSXJB2f9h8v6bB2TOdgSc9LmlLujGbg89TMap6ks4GlEfHzCs7jamBKREwqw7R2A34QEft2dFpmTbmlZlYgknZrbAVJOlvSNZL+LOkVSQdKOl/SU5LukdQ1HW97SVMlPSbpXkkfa8V8zpb0g/TxtyU9K+mvkiamw/pIui0d9oik4ZV832aNXNTMim1z4HPAOOA64E8R8SngXWCftLD9EvhKRGwPXAWc18Z5nAqMjIjhwPHpsHOAx9NhPwSu7fA7MWuFLtUOYGYVdXdEvC/pKZLbs9yTDn8KGApsSXKLlj9KIh3ntTbO46/A9ZJuA25Lh30G+DJARPxfug9wg4hY3P63YrZuLmpmxfYeQCR3gX4/Vu1EX0Hy/RfwTESM6cA89gE+C+wHnC7pUx0JbNYR3vxoVt/mAP0kjQGQ1FXSJ1v7YkmdgMER8SfgFKA30Av4M3BoOs5uwBtupVkW3FIzq2MRsVzSV4CLJfUm+Z9wIfBMKyfRGbgufa2AiyPirfSIzKsk/RV4Bzi87OHNmuFD+s1snXxIv9UKb340s9Z4G/iPxpOv20vSwcAlwJtlSWXWhFtqZmZWGG6pmZlZYbiomZlZYbiomZlZYbiomZlZYbiomZlZYfx/0TVH9sE4W2AAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "flux = get_integral_flux(config,[])\n", + "flux_points = get_flux_lc(config,\"runwise\")\n", + "flux_points.plot()\n", "#lc_points = get_flux_lc(config,'runwise') # light curve maker" ] }, @@ -612,21 +605,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "4cf9e4f5", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "INFO:gammapy.data.data_store:Observations selected: 4 out of 4.\n", - "WARNING:gammapy.analysis.core:No background maker set. Check configuration.\n" + "Setting logging config: {'level': 'INFO', 'filename': None, 'filemode': None, 'format': None, 'datefmt': None}\n", + "Fetching observations.\n", + "Observations selected: 4 out of 4.\n", + "Number of selected observations: 4\n", + "Creating reference dataset and makers.\n", + "Creating the background Maker.\n", + "No background maker set. Check configuration.\n", + "Start the data reduction loop.\n", + "Computing dataset for observation 64080\n", + "Running MapDatasetMaker\n", + "Running SafeMaskMaker\n", + "Computing dataset for observation 64081\n", + "Running MapDatasetMaker\n", + "Running SafeMaskMaker\n", + "Computing dataset for observation 64082\n", + "Running MapDatasetMaker\n", + "Running SafeMaskMaker\n", + "Computing dataset for observation 64083\n", + "Running MapDatasetMaker\n", + "Running SafeMaskMaker\n" ] } ], "source": [ - "counts, excess, background, alpha, sigma, excess_map, exposure, significance_map, exclusion_mask = rbm_analysis(config)" + "counts,background,alpha,sigma,excess_map,exposure,significance_map,exclusion_mask = rbm_analysis(config)" ] }, { @@ -634,6 +647,7 @@ "id": "535e4e6b", "metadata": {}, "source": [ + "\n", "## Plot results\n", "\n", "Makes RBM maps (significance & excess) and RBM significance distribution. 1D cumulative significance from spectral analysis is also plotted.\n", @@ -643,12 +657,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "e054c9ef", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsUAAAFDCAYAAADSynNAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9e3QjWX4eCH43EHgSBEEQBEEmkslisbKysrKrS9mlfqmlabe97ZYsW1p7VmutX/LI6/eMfew5fs3uzpyx54w96xnbO7P2WLbGb69HxzN+rFe22y253W5L3a2qUnV1dlZWFovFZDL5QIJIEATBQCAQsX9898YNRkUAYD6qip34nUMCiLhx7417LwLf/e53fz/heR4mNrGJTWxiE5vYxCY2safZjA+7AhOb2MQmNrGJTWxiE5vYh20TUDyxiU1sYhOb2MQmNrGn3iageGITm9jEJjaxiU1sYk+9TUDxxCY2sYlNbGITm9jEnnqbgOKJTWxiE5vYxCY2sYk99TYBxROb2MQmNrGJTWxiE3vqbQKKJ/bYTQjx24QQX35Mef1LIcTvCnz+c0KIhhBiTwixLIToCCESj6OsiU1sYhOb2MQm9vSamPgpntjDmBDicwD+OwAvAhgAeAvAH/U871eeYJnLAN4GcMnzvPqTKmdiE5vYxD6qJoTYBLAAPneV/W3P8/7wh1OjiU3se8fMD7sCEzt/JoQoAPgXAP4AgJ8DkALwgwB6T7joZQAHE0A8sYlN7Cm33+h53lc+7EpMbGLfazaRT0zsYewyAHie9//xPG/ged6J53lf9jzvTQAQQvyUEOLrKrEQ4otCiLeFEIdCiL8qhPh3QojfE0wrhPiLQogHQoj3hBA/HLj2q0KI3yOE+HUA/g2AJSmZ+NtCiBUhhCeEMGXakhDibwkhdmRe/1QenxVC/AshxH15/F8IIWqhMv6sEOI/CCGOhBBfFkKUA+c/J4T4JSFESwhxVwjxU/J4WtZ7SwixL4T4n4UQ2agGk/f5H4QQf0nmsyGE+Kw8flcIUQ/JRH6DEOJXhRBtef6/CpxT9/175b3uCiH+80foz4lNbGLfAyaE+GtCiP8t8PkvCCF+QdASQog/I4R4Vz7nXhNCXJTprggh/o0Qoimf1T8RyONHhBA35TX31LNGCFGWz9KWvO7fCyEiMYV8Xv1BIcQ7Mp8/K4R4Vj5X20KInxNCpGTacZ7X/60Q4lvy2n8mhCg9qTad2NNlE1A8sYex2wAGQoi/I4T4YSHEbFxCCS7/MYA/DWAOlD98NpTsU/J4GZRk/KwQQgQTSFbkhwHseJ6X9zzvpyKK+3sAcqCkowLgL8njBoC/BeASyDafAPifQtf+XwD8bnldCoB68F8C8C8B/I8A5gG8DOANec2fBycILwNYA3ABwP8jri3kfb4p2+EfAvhHAL5fXvvbAfxPQoi8THsM4HcCKAL4DQD+gBDix0P5/RoAzwH4IoA/KScOE5vYxJ5e++MAPiYn2z8I4KcB/C6POsk/BuAnAfwIgAKA/wRAVwgxBRIO/xB8/v1WAH9VCHFV5vmzAH6f53nTAK4B+MVAWdvgc3EBwJ8BMEyP+esBfALApwH8CQA/Az73Lsp8f1KmG+d5/Ttl/RcBOAD+X+M1z8QmNsI8z5v8Tf7O/AfgBQB/G3woOgD+OYAFee6nAHxdvv+dAH45cJ0AcBfA7wmkXQ+cz4EP1qr8/NVA2s8D2A6kXZFpTfDh6AKYHaPuLwN4EPj8VQD/t8DnPwjgX8n3fxrAP4nIQ4DA9dnAsc8AeC+mzJ8C8E7g88dk3RcCxw4AvBxz/V8G8JdC930lcP6/A/CzH/a4mPxN/iZ/T/YPwCaADoBW4O//Gjj/KQBNAHcA/GTg+NsAfiwiv/8zgH8fOvbXAfyX8v0WgN8HoBBK818D+GcA1saoswfgBwKfXwPwJwOf/3sAfznm2qjn9Z8PfL4KwAaQ+LD7ZvJ3/v8mTPHEHso8z3vL87yf8jyvBs7yl0DgFrYlEASr6zwQSAdtL3C+K9/mcTa7CKDped6D8AkhRE4I8deFEHeEEG0AXwNQFKe9VuwF3ncD5V8E8G5EefMggH9NLh+2APwreTzO9gPvTwDA87zwsbys86eEEP9WLiEeAvj9IJMetLuB93fAtp7YxCb2vW8/7nleMfD3N9QJz/O+CWADnLj/XOCauGfZJQCfUs8x+Sz7bQCq8vxvAdnlO4LSt8/I4/9PAOsAvizlYH9qRJ3Dz7q4Z984z+vwsy+J9z8fJzaxM9sEFE/skc3zvFsga3wt4vQugKAeTAQ/P0a7C6AkhChGnPvjAJ4H8CnP8woAfkhVZ8x8n4043gAf5C8GfphmPM87K5iPs38Isu8XPc+bAfA/R9T3YuD9MoCdx1T2xCY2sXNqQog/BCANPg/+ROBU3LPsLoB/FwLZec/z/gAAeJ73K57n/RgorfinkEDb87wjz/P+uOd5qwB+E4A/JoT4tY/hFsZ5XoeffX3wmTyxiT2STUDxxM5sclPGH1ebH+RmjZ8E8I2I5P8/UOP244Ib4v4QNAPx2MzzvF1Q+/tX5UaNpBBCPUynQQDbkhsy/sszZP0PAPw6IcRPCCFMIcScEOJlz/NcAH8DwF8SQlQAQAhxQQjx6x/TLU2DzLclhPgkqHkO2/9dsiovgnro//UxlT2xiU3sHJoQ4jKAPwdqdX8HgD8hhHhZnv6bAP6sEOI5ufHuJSHEHOhJ6LIQ4nfI52ZSCPH9QogXhBApQb/zM57n9QG0QZkahBA/KoRYk0THIegizn0MtzHO8/q3CyGuCiFyoIzjH3ueN4hIN7GJnckmoHhiD2NHoG7tm0KIYxAM3wBn+KfM87wGgP8TqHk9APVfr+LJuG/7HSBjcAtAHcAflcf/MoAsyCR8A5Q5jGWe522BS4d/HNTpvQHg4/L0nwSXD78hl/m+AjIcj8P+IID/WghxBG7e+7mINP9Olv8LAP6i53mPJWDKxCY2sY+8/X8FvfCov38iSYe/D+AveJ73bc/z3gE3v/09IUQawP8APke+DILbnwWQ9TzvCNys+1tBdnkPwF8A2WaAz9VN+Yz7/aC0AuAm36+A+uZfBvBXPc/7t4/h3v4yRj+v/x64OrkHIAPgP3sM5U5sYpPgHRP7YE267NkG8Nse0wP0qTMhxAqA9wAkPc9zPuTqTGxiE5vYB2ZCiK8C+Pue5/3ND7suE/veswlTPLEnbkKIXy+EKEq24s+A2rAoqcXEJjaxiU1sYhOb2IdiTxQUCyEuyh30N4UQ3xVC/BF5/M8KId4UQrwhGChhSR43hBB/V9Ch94vy2CdlujeEEN8WQvwfA/l/SdDR+Hpw56ugc++VJ3lvH5RJvdZ5t8+Au54bAH4juHP65MOt0sQ+aPseGcsfiE2enY9uk/E2se8Vm4zlD86eqHxCCLEIYNHzvNeFENOgb8IfB33NtmWa/wzAVc/zfr8Q4kvg7th/DOC/9TzvP5FCetvzPEfm923Q9ZQHBpH4P4DL8b8C+mS8KZdXfsrzvM0ndnMfkAkhup7n5T7senxQJoQ49jxv6sOuxwdhT9O9Ak/f/T6KTZ6dj25P07PzaftuTe736TVBD1N/E/R25YFBXN4GN5qvgH68f8LzvAdyMvFXwH1BXfDZ9vqw/J8oU+x53q6qgBTzvwXggnqoS5uCjoKTAHevupDuVzzP6wZ0k5lA2k+CQR82PM+zwehgPybPNcGdsN8LNhF9T2xiT5lNnp2PxSbPzolN7HvP/goYXOsKuOn9LQB/CsAveJ73HLjxXK1+/TC4IfQ5AL8XwF8blfkHpimWS3LfB+Cb8vN/I4S4C+5kVaFx/zWA/wj0z/o/BK79lBDiuwC+A+D3ywf9BZx24L0tj8HzvN/seV7w3MQmNrGJnUubPDsnNrGJTQwQQsyAfqt/FgA8z7M9z2uBk/q/I5P9HXBVDfL43/Vo3wCDwCwOK8N8AvV+nwkh8gD+NwB/VDEdnuf9FwD+CyHEnwbwh8GQkg7oFuaUyQg9LwohXgDwd4QQ//JR6zQ3N+c+88wzp3Q6x++8BgCYmkkALt0tegNNNihVz+Hh+/MLqlDC6p/gZ8/Tnwsz0FxGOsX36ZRO6HkoTZt4ZS3noRfwYJZK62v6/dOFWT1mKiNr2paHVMaAbUW7j/QCb4467z/hecD09Ol0XuCcskxGVllXHQDQs3QbpNM6a09Wx7J0Hp0TIJ8Ans0KD2C5hnG6LPUqBJBIGuTEkklACHhdnVkv5PBNCHapqoNtvz9dJsPX9FQgcJIwZId5gN0HUklWIpl8f8U8D4Ou7ZcHAEYq4feF29d9YBjAbAb4xKLw7D670raBREKPEZW1ZeljwbGk6uuXlUnpG0slgbQkB1Vmpqxz39aZux7T9Gz0bRfJtJonCyCVYgMJeX+pFOA4vB8hAEPmKwwgYbCiqRRvLtwBnodSFnjl2azn38ypNhSsszLX1WNb3WCvd7oBhECv3VO19V37p7IJ9K2B7+lfjSH2hQcYCWD+JYTtvffe8w4ODk4RBV/60pe8RuNsMQFee+21f+153pfOdFGMnZdn56++9tqjZvtELCHEU8MWP033Ckzu98Oy7/vEJ9537AN8dj4D4D6AvyWE+DgoK/sjABZkrAKAbvoW5Ps4AmAXMfbEQbEQIgk+1P+B53n/e0SSfwDg5zFGQAXP894SQnRALck9nI5qU5PH4uohQH+KAIBSqSReffVV//w3f1igPwt87kdmgO4x4AoMbBcnFgGcafLHVWJlfFl6hHVd/QfoH2CVPpXiOcfha0K2+K//Il8dhzhm5socsLYG2D3+aHcCCNXp60JqF4HN94CVZ3jx1hZgShBvGCx4fV1XtrYMb/MOAODWLV0/VfdgnQHgq18F+o4GrQDw2c/qtD1bn3McfW2txvswTR435X2+fZvpn1nl52RgxHU6rKqqumonYQDPrjLPYFuqOheLPJZcXuCJUomA6sYNwEyiUz/GextMY9tMotq/VuPnbRloenNT57u2xnSf+LTgxa4LLC/ztboI1PeBpQsszxCcgNT3CZZ3OPR232xgcQm4u8X7qK0Iv/K7mwSsizUDyGQBV65SGwkgl0V/p+HX7dIKcGeTl1arup6qnQwDePYy+/v+to1UCphZK/CEkQBqF3SjVRZk4/Z1x21uAs7A78TB5l24LpCslYF6XXZqGYPNu0ikDKC2zHsGgMYB29t1dUcvXWCeq8/wc/MBkEmz7Pq+LM8BVmu6wZcvcexaPeDll9mGpslJX6cDbN89PUjr9/ndXF5mIxkJwDBw48ts+2yGyZ65kgCMJO7csmAYQC6nqjnAzNIU2z3zLvBHTkcEn5ubE4J+t5XlP/GJT+DVV7+Fs5gQiccSbva8PDunhcBZhLuPGt0hannTGCNflUZdf5Z6PI6IFB8FC7ddVFsMu9dR7Tysb+KWpd3AazB/IyLNqKXtqDyi6jssn3HKeJwWNy6HtfVZl/jj8gy+HzfPt197DUehvWiP8dl5RQjxauDQz3ie9zOBzyaA6wD+U8/zvimE+CvQUgkAgOd5nniECcQTBcXyYfqzAN7yPC+4pPecdCwOkN6+NSSPZwDclZtFLgG4AgqpWwCek+fvgSxJVNQvAGwoUIMHAHjllVdONZrrAp/74hRg9zCwHB+sKuDnODqd6wKf/zzwla+cBsTqvMIJrkvyTIEYABg4wBe/KIkwh6SdbQMzdg9otwFLOmVQaE5ltHyJiO7228C1jxFAuC7TG5LZNE0CtOoiTtbvIbtcBrrHENUKOht11GoEoaZJADgI1DspMeArrwBf//ppsH9isd4A20GB3mAbFQq6HdT9plK8v+VlvgLASVe35cAFLtSAizV9TbVKvLO0BGSLKRw1bB/AmiZQqWh2ebb1AMjnOZGwe0AuB6/ZQr5gwLZdnzQ1JIlpGMBClex1uUzQqo4DzHtzE+h1HJimg0RtEWg0WKl2m38vvaQ7OG8CmWVgbx9YXQX29tFqNVAsArMl4H4dOGk7yGR4z5bFLhzYLmAfS7B50QfU3S6zLRaBwxbQarFdcjnWd2tLt32tBnTaLtIpG+UysLcHzLTbrMf2PY4DQ5AJLpfZUTsyCnTrAQvZ3pYdOEC7DcxWU0C7jYMGy5jJ3Ee3C5i2i6xqyEwWWJ7itWaCAHZlhe2fSrK8fJ43k88D1QUC2bXn2LiptAbnhmA9HUezxN0TPUC6JwSwZlLPhq6+wPFu9fyOu7R8D7fkEyRhwGfLL62ZeOemA2HoyZi1cQzDAOarNsL2zDPP4ODg4NRmllde+QQ+DEh0np6dZ7VxAOywa6NsXKD2sHrBOLA2bh0+CIsCnw8Deobl/6jXRIHw8Hh4GCA7LE1U/o9ijzJ+o/J6HHmE6xP+HFdO8NqosTNu/R7js7Phed4rQ85vg5uNvyk//2MQFO8LIRY9z9uV8gjJ7JyNAACePFP8A2A0nO8IId6Qx/4MgJ8WQjwPttgdMEpOnH0OwJ8SQvRl+j8oo6RBCPGHQS1dAsD/4nnedx+qlv99AZ/5QgawTtC3XFgWAUyQ8VS/04Beof4tv9XEe7cdP50CgqmUTvvVr54G1ADxggKTwgBqV6YJXFotgtwwdbp0geDMTDBNJssCzaT+DBCYSCSbzQFevQFhADAMPGjy1HyFzG02z+HuOS6EqYf+J15xUSzy/d//+2zwVouf+zbzUHVX5jg6jaq6YmavXSO7PHBOg2UAuH6dt7W9rW8V4Kr/9jZQkQ1dq2lsmgooBGAkdEGpNJCbQuN2C67r+v2xt8emqlYJwg9bTN5sso/rdV2fTEaziomMyTfLlzSNXJknGHO7QGmOBXSOgfyUnBmc4IVXpjBoH8N1mV8mA9zbIVgrFomrUylgeqUk0foJTtoOBq6DnR1N9pdKnEzU65qB//grpm5EBVDb1PIsflpOmpoHGLSOkLBOOG4AprEkaN3c9IEwUmk/v2QKOKzbmKlmYJpsn1TKQr3Osi+VJVIuFDgOX34Z6BwBuSm5siIHdy7H990Tto1pklnO54HLz3HmsbNLYJybkhMamw1j9/W9uQM2WH2f16rZZudYDrC+P2gO2+xfALizxT6eWS0BAJ77nAlvrw6Rkm2XyQJOH3fXbZi/T2Dxr4+D7z4UuHMunp3TD+kpKgiOnjTIDLKHDwNCxq3Hw4Clh63TMCAUzPMs9/0kGNDgqyrDwPvrP2oMnIW9DeY/7vXB8fioY3IY4z1OXeIsbnzFTSDG6fezsv7KpoV4H1t89hLObp7n7Qkh7gohnvc8720AvxbATfn3uwD8efn6z+Ql/xzAHxZC/CMwCu9hQGYRaU8UFHue93X4Sr9T9vNnyOPvgSEdo879/FnyCtuv/AYB1wU+9UPUSp50XJ+FnL9cJOsFaLrYdTXwTKUw6FinNLE+G+xqycWnPg38wlcom/BcgmDbZhqF52D3+GOvkGFgWRuQ5wECG0XVKpbYcQh6DIMgyDAIUgwDQuVnmphtN5BOkW1ULGPCH/V64No2QbvrAr/5NwN/938Hjjv8rO5LBEBv8DolTwD4vlLhNaZJcGjbwN1tsnYXaoAoTKNgH+Hll1mvhAnMSMZ5Oi8JRCljfeaziwR8XdsHxVl3ALgSwVUqgNPHfNXA/o7rs9yVCglSxcK227q+W1uanc5kCERdF0isrfBAoSBvVBAAttvsm1KJy/upJCvYkQ2UzwNdMsCdpovpAk/1bWB+SQNw1wWm7T7lBd0T2LZudwXmV1eZ/vJlgupSQTHYgGHIiYx1AmQyOGlayKr6ZTJIFKaYYZAGd/pSbw4NPh3HP9aXybsblt8+qk8NAxxTpsl7NgyC1VqNbe+6BNu5qVNg1f/udI/5mknzxpYWgdu3gfV3KK9w+oF6Br5rTp/ng98BdZ92X8qGPH+82TZXHWbKcsXEdQGjj04HyOfJGKvvxsW1FLY3bLz9kwK5HHDxZ4c94D94UPxRf3Y+LBgOmht6jQIPw1r+YQHlWW0cAB9lcekfN8sY1X5hYBxnUQB6WNrw+3EAXxz4HVbesHThMuKA4qNMhKJs3LYZJ584Nn+UBcH+uEA/XPbjsikhYAAjwPETeXb+pwD+gRAiBWADwO8Gb/fnhBA/DZIFPyHT/jzojm0ddMn2u0dl/oFstPso2vE7r8Gdl0vxhoG+pZfbZ5en+aMK6B9jAHAcgsIVaiGN9Q1fRqCILIUFguqHz32OjLEiwRT4Ub//g66NhNM/jUiVua5kJ+UxZ6CXn+2+D26zy6VTTDFBxcBPl68VAQALdguWBcxUUqdZR1lW1nFg3Xb9+/jNXyR+URhKASUlvVD64k6HGEnhsHJZ3yegj1+sMZ+5EtDZOwJAGUmpRHb4uEOCMJUC5srAgyYwW9bMod2qI2FqOQe6x0AmC+/mLYilRcB1sVAl4FW3V6lonKaacWOD76tV+CsDauMaGgdAeY6sZ26KCQsFsp/VBbl8b5Gpz2QJFDc2gL199CzANF3kcmTP5yUoT5enMescIWkC6ZzBfFwXSPUwUzrG9hb162qZ37aBqTyLmSlodrzvMI3huEhmOICyxRQbu3MEZDLwOscQhsG6p5LA+rusvwKbanIXEMmrvjUM+Ozw5qYeHgMHSFTn2bFOn42VSku2u0dJz8YGAauZ1DIgNXatE5a5taU72LJ4TbEopRISCGfSgC1XSNqHHFyqrnv7cqwOADcJmCY8V3aHXBFAqcSlBVl5NXHNZNQhF8JwUVvL4P6WhVYLuPvTAsD7N5BwV+EHD4o/yvarr712Jg3xOBYEMGGmLWjDzj1pOyu4Ghf4nBW4xU0egkD1YRnicdp2GPsaVeawuozq52C6s9RxnAnBsPLOYmdhb6PsLEA3XMZZ0w+zhxnfLjhBfj5i892TenZ6nvcGgCiJxa+NSOsB+ENnyf+pBcUAAYZhALh2Dcm9fep6l5f5A22d8FfW6sHbvAOhgMGyXJLunviM6cDVDKBhaACjZBWuy81qX/+6BhkKoCnNbt62gVbrlMwA4KtwHIKAdpsgUOlFzQSyGSBRlft6goDY9fSmPXfAY0tLyHc6mm0OiKU9h0C4ZxP3bG/rOq6uErsE2cMwbg8C5qUlvq9UThXhA+TpcgoozeHghl7FcBytJ97Z4XvPBWZXZuC1DmUbuKcmG6qhD7ePkDCBvN1DT2q4SyVgd08z2wmD/eS6LEOBy6AtLck35Tk2QqlE9rcwQ+Cm9K+GuuEe29buExzbPViWXhXo2cD+HtleWCdIqPmHkhcAgNPHwHbRkxs6lQOHfkjDrdo8ldITghxcmKZLBrRUkvUb4LgL5GsFjpWubPjusWSyTzQgVuMKeqypPvz3Xwd+7DdpOVDiyhoTZNIA0rzfTkez5NYJkMsSUZdKWidinZzS/8Luc8McQJTaPuKGunKZY1qBbKU1cXT9AGj9jD9JdPwJaaXCdkuX53lvuSnAMDCPXU5wpDZlsFOHYTsQckAq5VK8TUDxk7Yw2B3GID4NvTEKoITbINx2Chh/UBYFQuPeR9k4wHhY2nHyPUsdotr3LGUG22Ncpn5UHca5/mFt3NWCuOvi7fx9W59aUKxW/4QB+ePrcMNQEDRI0CVWLgFb9OBAQCN1jaurcN7c8DWpQUwKnCbmALmCnIG/1DtwCXB6FnB8q+Uv39u2BnKGAaS7XQKG4DKzzDxRW+RxX7jsaV0yADiWz+YKu681Ao0GPEezhEHdb0eytWpf1u3bfFWgMsi4BrXF29uaea1USAouLWmQ76/mFwqA0yepGNiU2Hf0xkTLYj2mcz0pFSBjH1QEAMD9PVbEcIDBRtMnIA2DkoCkBJGJFL0TNJvER0lT4jCDDLdik2fKJmcBrkdQtbJCEGedcNn/1tu6DZW+uH3EY9evY6bxZb+CrutgZqWI3ZstpFIOUineb98GkqrPJNAvlU63Zb6kB9XAcrC7x4/zVUMvS6hNa6k027S6CGxuIl8wCFD9NHICZPepf27c1+7ZpGC5VNJa8Xod+MHPAYdt4NpLhtawBAX27TY11lt3WbZCleUydr+2jsWXZOOWShrYGoLfreoiXaGUSoDTx4ONFmYr98gMq1WQ5gHztXtkwBWQVjKMTh9SFwGAfei6QLY8pScqZo+rCJZN5jyVBpwBEp+87m+OnP9iCajXuWkzUlU7YYo/KBsXBJwnG7e+w8BR0OJAyFnbLgx+HoUFj2OAw2VEAbgggA88/oZKQ6LKepRJ1LhlxeUV7rfwBGEUuB+37sPyGQW8h9lZ+l7VaZyxel6fnU8tKPY8MnM/+KUpgpvlixrBKulEcNdYdRH2xi6ySjMJAFYPV67opXhlRmiUBSWWKt3A1TpOxbICBIaKlYaUWKSDu/PtvgTtGaJWBW4Ago/yHGDnWYliETAMChNdlxudbr/jg2t3p+7XTTGsQZdy1So1wAMXeK0BXMtrD2X9wBPsotQR2zaB8UsvERArrwvB+y4Wgc5mA/mi6XtNUJMH09Xv63W+n64mCKIK00D7CKUSvb4kUwTE82sz6De42SyZMXB/z0WjobXMuzuarQ9KVj79abZ9ocD79DdiqZtXy/l2X4O+wjRB8u3bQHGGaZtNsvFqub5cxtF6HdPVKczUCExTKbLWKyssUxhAsnMMpJI42Wlh4AKzSxnMlm3ceNPFhSUA5XkoOUHCcTDvtChjsF3frR89jxi6nnu7wPJF9Ld2kfQlNJINtk44Pur7Gv2q5Y18Hgmji6zr4rBu4+WXeTuzJeCo5WJ6SW7otPta124Y1PQqVlh2cmejjsXPrlB7USppX3KZLAD5Xdq5x8aQ+vfZly4CV1+Uqx+y7dtt6olreQ4mNXjMhL+Co2QgasxmlzjesbdH4Cy/WI4DJJXcZWmR7fDKK3qQuQO2N7qItvP3YD8P9rhY34dhyx4FKMSxmg9jcYBqVNpRbRcGZ1FAJgqgxn0OljcuAxzHZodB6OMYA1H3GDw3zILA3I3JZ9w6xtXjYZjnuHF2lglDVJpR42aUnWXMnsdn5+Ng3s+leR7wg7+pqMGmokgdKU1QppCiaSK7JjeyBZBjMmOc8pzWCyzvGwY/B71TAMQkyhVbUHbw9m1drGI6HQfa1VppjlrU0hzRVXmeQKG6SKqzVDqt4fTrL0iLAvBdS7guEuUiLEtrSYP3oY5frHHy4IAEqkqXTvFPbdarVAiYf8dPGb4UYrogq2RpuXTPlixoeR7TBeC5y6zSc1cMPHMlhXKZm/AUGeuz45YFtFrY2eFc4O4Wb6nfOESyPEMZi+1iv36afV5c0syxcuusujSVos9g3/uGKT1O7OxKgDvH460WGVZLekrIZQmEW4EoLu022c1iEdPVKVZO6obnqiauXWN7TVcyyJczvhwjW8ogXzT9DWWLVdkP9f3AGPSQvrKCZHFKs8kK5QMEdU6fMo833kCyOKVpfutEiqZ7QPcYg46Fky5w2HRxsG2hbwO9nSZ6LQv3t21/PJpStz1dmyEb6wz0dyXoIUX5yHYc3N844r3t7XFApNI42migv9PQ17gux21hmjOoUolt8eqrGnCXSnqT4+Ym3bmZCQJdtfm1dgEwTbz3rQZsG0gvV3R7mCZ62w0fNANyklkqsc4VOeGoVLjqA3BmG2mK7TjL38Q+KDsLsAqDOQOP7wfwceQTZqhG5RkEveOCrDjQNyx/de2w82e1YfkZMe8f1sa9Pg6EjjO2Pqhvfph9HjU5GjZJeFz1Hc0Un69n51PLFOdnEvyh7xxpDwKA1nqmkkBZbqpyB5ryLJUImnJZsoTQuuKEBIsnFgKeHbhc7zjUFauVZ9cFLi4T+CrJQasFvCOBsWmSUfRcYLbmYH/jGKnt/wDXBeaWNrkUXJlnwvK89BPb01IKtWmp2STKKbY0+lau3AwD00UC/gd7NkyTeCZh0k9TcBPhK0W98UpJPFxXL1urzXUD28XC2jRZw/oxkvkULl1N8uTergZEzSYLyOcxlx+g3zyCadoolXi4LeUNDORwBOSngWIRjnOMdIbtq8hZs3uIhMnYHdWqZKM7lEuUSsAnrrPuS0u8P9X2uzvQTKfrEtUriUmpxDYyTY6PTFa6fcvRa0KrxTp1joBmnQDLtrmprXsMuCWCvkwGD+p02zd//SLQbuPd1w9RLN7DXC3DCiutcnURc6kDvi/P64nN5ed4rFhE2vWA9XW5mU4+RNae0wBwaYlSg5UVgnblvsy2cbLT8sfkzEoRcD0cbR/6PpQBPVkAgJkiOMYAn6n3tbpqErm97VPx8xXoqIJdC7dvc4Kztwd01htYXQXSK4v0tV0sEvh2OnpZ4Ru/zHb9wheky5I0K9NuA1euAMVZXuu6GHzrdSRMdtnWFjTLLyUl6Qwkuz+D5GdfYRvLjZgozWkd0zfeol/nTHrI0+Kj8bA+TxYHRNSP+eNq0eAPfBzQGgUahtU1XM6TtnA5YeATvp8o1nYc0BtmEOPyN/H+Potq02Hs8bjMcNz5OHZ0WFuEj8UBwXC9H2Z8xqUdl52NyzPc5kB8HwxjjeNY63HucxwWeridv2fnUwuKAQBOHz0L6NysY+6H5rWeUSE8mcZHgpalmVbD8JeGFSA2A62p3JepFerVVeCNN3SagUsArDaxLS2dZpj9yLk2cLB1fGr5/6hhY7pi4PD1Dcz8ulcIhtTGr/I8M2g2gVtvAUsX0N+uIyn1m7BtAoCXXyZ4kuzdbBlAqwXDOIbjEMg4rsaKGxt01Qvo1XPl+3e+TEw4WzaoUzYTgAPkq9O8oFjUDKHdA5wsQVtArmCaRxClIqaNFmCayGTkJKQyT0BTniPgBAOAqMh6rksQf9DQUfV2drQ6QGHvF66SLXz+CoNqoFzGYsmVzOQcQfDermY/m00eU0v5zSbwfZ8BTpqsuzMgsFJOhbvHlKao93YPvZaFZtNCKsXDqO+j07RRqdCf7tzVAplP1Q7uQG8IK84wxILayKY0wbJedvMYacPR9TaT7ISOZD53drF98xALFfj9qaxchj8Q9/a0w5NikbKU7W3eIgDtFziV5LixemTEV5/leDJNwLLQs/RYB6hMaLcBe4PlvfCSCc920NvchWEASTX5NAxsr1vIZizMrRUJuK0eYA6kHGieFepIt26pNPCtb8IwtOeT5WU5KF1PB/oAZFCRPvXDSkqSSjL/XJZplW4pqH96n52/B/uHaVE/pOOyk3H5DQNSj5JvnI0C0sOYzjBQiwN149Zl3PLDeY0DeqIAaPhzVH5RYDL4PgwI4yYfKn0UGB1V1jAwGnVu2LFwvlF9Fq5LXH7DxkE4jygL31/c9ylc3jg2bFIwLP3DTwrP37Pz6QXFAhh0LPTVprGde3rn1fKydm/m+0wdkDVOpfTy+eXLwO3bSJoa7Npyw5pi3EwTeHaNml11HtCb2m7eJCBeX2exm5vwvQz0XZ7b3NTuzgC5qvwtiz6BT9XPYN0APwzve1+7i2oV8JXHqZQO5KDYb6kteLBNQDVbTWG24mJ7ky7oFFt8/TrB+r1tHSzBcYBnr6Yw6NpAsQi33kTCMICUof3hKiCi3EIEvV9IMCKqRG+eCzT3HMxVTRw1HUxvbVFasLMD5LIol498ianK4n5dYu6yJn0rFQKzRkOCwEwGTsvyN7X55nqcmTh9Dd5bLelzN+AConYB6B0C2YIErdMEv6ksz+enmfHGBgOiuK4/fOaulFkR16W8wHVxreSSfS4UWEYue9ojSPMBy7z9jpZ01Pcl6BugXmcfGPUmEksVAup6ndHqjARgnaBn6XDWSmoLyPtvt9Hv2P6Q6HY51pTLZ+XiLOn7yD7xPWx4XQvOG9/lakaljKO6hcO2jlqYTAWa12XXTRcc5CtTMNvH2NkBLhYGvm5HfTdgWZwUvP46fN9whkHvFN2uf+9w6XGjH/REosa8msRWKhx/jfsy4Ij0r+x68P0zZ0DpkWK7I+18bhb5sGzUj+dZf1zHSR/H7g0DR2fJ92HqPA57GPV5WF5nqbN6H3yNqpf6bI5IF6xP1OeHB03xLG5cvuOUOQw8R/X/uCB6nPKiLArsP0w5cXUfBcSfhI3O/3w+O59eUOx5MAwusedrRe58t06AT35/wPG/QRZObbxTu/kB/tKnksDyMoxbm75c0jTJniqgvLKi9cPqvB+RTdrmpsaJ6rPS7ioCa3uboNkwWLTr8tjsrbelD1hbLjUfETw5Du5K8Li3BzxTPSA6VJqHxv3TiKJ5wCX+quGDs8Uq8QlAQKy0phdqGtQDABwHiXIRAJColN4PMNptGZXMk+1skQktl4nC1CsANL7FahWLyNsNtnf3GHA97N8+RN/R8SJk0QCkPLSryXzb5n0LA9ivA89JLw9+tMF8nkz5535AbpYzpL/cQJSPXJYFXXtR7niU3llfeJHUtGoQwyDoBYBSCWL7Lo42GsjlgIXPrmoKtVKR1HVSMsyz9Imck76OC3LzXr1OIHfrbcm6S7C8tMQ2LBZxEW9LVGwQ2JkmVwYAf0Jn26yWbXPsVCr8nMsBJy0blkXGPWHwWLcLLC5zjD/Y5uqE3x5mkt+D7jHu7QBTOd5SuttghL68ZIZtPQFU3wnXBY7aQDp1rOYGvmPoQYeJexYkSE6wPbonMqzhPO85kwW6x+h3HSTzKXiWjWQK0i80NNj1PWUk4W3fo15caaKV2T2dTk2Clf/jSDt/D/YPw0aBFGXjtuajMGCjjo3LoJ6F3RvGnj6sRYEgBdTDk4FxQVn4WBxDG2dRbPCwtFGf44Bc0MxQ2ijAF1eHOHY37tijfsPPOtEK12VU3z0MwP1oPLU+GrU4iz3VoNhxgORLVySLNwBqF4lIq4s6XXle785KJemabWdHh7N1PTx3xcA7t1w8/xJ/aAc2B0Ji+QKQSiJh9dBb3/W9IPib983Tbrg2N0larq6SOQZ4fip/GoSqpW3XBUGDciPXaAB7u+h1XaQzpz1onewdYrDzLeR/3WcIiBsNiS7lEnVlAfPOPd67lJG423V8/xem0dk78qUgfYcgKluewtHeMep1SPZcbi5TkR+UHlZVoPmAFc/lCH5ah9y8ptraZAhiUSpitjDw/c/ajWNkiyn02jb29hg2+rjDYpSp0NWA3th465Zu66UlNpbSQgNAwhkQfFm904FajASBe6cjXVMsMJPpEoB5ACkADWCuopnv+r7Umt8DUkm8fYsANKHYctVxrUPmHxwExSLLLRY1cMtlZTjmHnoNG+lKhwBaAT+li1UCbID9ufqsnGH1gVYLtu2iUIC/AbRns/22tzVB7bmMk6Gqo1YbZi9nmWdxlnIJuwcUCjjYPPJ9Kis/3QurU7B2jpV3NHQ62qd1MOT5zZs6UKCaKJxY1OBnM0DfcpHEidQSJ9keO7scozLyhmkCD/ZszJZY13SO1yVSyVOT2cE2fWAn1ExUbdBTk93gKknwS/U+O59sxwdtwwDBMAB0FoD1KPawrG/4evU+bOMAr6g8g2njRlmw7i6i72UcAB4FLEfVLSrNsG9D3GQg3Hbhc07E+Ydp81H1i7NxQOdZGPQoi5q8hFnvYWPg/Nn5fHY+1aA4ef1jerk1uKS/c+90WtflMQlATrYayF65BGRSgMFrnrvKYa0AsetysxrsPk42duG51OR+54b29qAi8fqABHoT/DdvySElf9PX1ojNszm9iW/gAjNLu4B14pfrOAR/fVuHklZp80szwJtvAleeJ+AoFgn6AILD/JRkBHvA3j6SBe5Uy5fn0LmxiXQGSEnmD5k0pmsmMplDGdktTVazdoFAxpSb61QktfwUGbvlZQJkVlZ6/JCvKyt6o+DOLhLFAbJ2DyctItmESaC5suJiKk+yFgAWKpqIbbXoMc22CeAXq3x/f4cNodo9rbwhBKORuC5BeqMh6ys10c0HwHQZwAB8fE8B/RY7Rk2Y9vbJ+rZaWFtjPT3HhdjbJXhdWQF2duHt7EqpSF+7HZPt7Q+CG98BKhUc1m0cdYCanHz5evb2oQ4uYhhcHajJoDLXXuRkp9HwfUWr+waAb32L1Z2vcKLlz/dSrOKDPRuFboO69pTJCZQcoF69oeXNcgz3LKB/+9ifNKVS7Gblb1qBY+V6T0mAqpYNkUkhneKqyolkrQGXUh/lccUdYH/TwsJqAjCTOO7aMAzgziaQMBnNsdMBercbfvjwbCawyqJuPJVkxdR4U9rjjQ32ddiP4ukHwJBzExtm47CY4zKO4/ZCHKCLAuRnsSg2eFj5Ks0oIGVEpI0q53Ew8XH1iWKch01k4izcRsMY9HGA7llZ0jDjfZbJylmB6VmAepyFx8rDMMJntfDEI1j+w+TzOFJ9lOzpBcU5uRSuwJDSrqpjgATLUqurgjg4fbJfW3fgOym+fBnY2MCga/tMpPqN7W3cw0CxanJzmMLgytdvUAqg3g9AUG0YLEat1HsuzwFSwyldSqlys5VpnNSP/PPqOj96WypJnerl5zTi7p4QcDXuaxbz6lW5zMzd/PmrHtBl+OBEve5XNFma1m65lDZEiXYbDeZbLvM1lyO4KxRY784Rr20fciOd1KwyFPAM0Olg0LXRbpMZVn5zOx1GijNNHk8ERrHaZKc2Yqk27dkMGV2RnrsGew0kSjPwo/2pTYrtQ95zo0HGWAH4996W4D4v5Q4yxHGtpgNXrKwAnSMkuscY7DXQbALzNUO7ypNSBG+PNLcolXyXYVobrgOszFyuoPWtOsddQbHJjgx/3Ja62LTWRDebHK92H8hNwbKO/Sh9xSLJ1v06pQzKVV63y+Y2DK1yUeG5M3Agli/C27oLUSpC2H1ku0fo2dzsqMbug6ZeIFCgGOAxNde8fJnHMhnpqzk/Ba9z7I/3dEpHAUy221IHbAJWH64L3N88xvyS6QdkUY4rBmCZb74JpDNyO4Aa8ylGahSlEseWWlVRGxpNk2Ow3Z6A4idko4DGebNxWO1HYb2D7RXHBofrE3VdHPCMA41uRNqHtag6RLVbXJ2Dxx6lLYP5BMuMAoLjTNqiJgdnabNR6eP66lHbIK4e49R91ERsdB7n75v/9ILiE0sDke4Jo15tbBBc1Go64kMmrYFiZR69b7wBwwASqRQ1DqkUsHUX79ywfQCgXLA9n9tFOgP0Ozo0r3K68J0b/Kw25Plg2JWR7GQ1V1f54x8MqqECbQDwdcOzJeo8YRiM6mWawPahL9HY2gIWnUNKH5aKBE7bdyWIkoBwb5deKUxTuyTITcmdVxKU1etkU8tlXm8mWUGlC778PEGHbetAC8rfL6CpXNPUniXUev76uxpgdzo42jnC+jrvvVQiaJoup9BscgZw1CEAO2rrecvly8xKkqW+jHoqRyC9sxNgOhuHWMhsaoCr3PLZfV+C4IPeTocdW5olsNrbZ103Nviqot61WsDLL8P48lewXwfm17Lao0QqSfbVcfREQQmki0VOVpSlkkCjQalBNTBZU15E6vval6+zA0Y8lO1uUYLwzPUkDjdbyOfByIetB7hgWugU9J626YIGrEruoCQPolIGHAcil6G0KJ9HfrWD/MYGBq0jfwKi5ki2zT557XW2dz6vNfZK5aGY4k79GNmMxPbyq6jk2QPLQQJtZl6YQS5H/fPdDccfD/n86ZWWlGSc391g/s+tyUiGSxU98bX7WjLTOIC/QbWyQLYYBxEPivO5BPhB26gf8GE/oI+DcXsYGxd0RAG6s9Q5DKrGAROjWOhh9RnGxMaVEcVWx9m47GJcXsOAugmcimw3rsX1xyhmP+5ehzHMcfc/qv/HKTfYv2cF0cNsnLQPA8KHpz2fz84P4tnzETWPy9Q23Ur5m8ZSab3pRoHmwG43Fd/hnRs2f5nlxjsV9EAYAYBrk9VUQTjUnyU1mUlTgwklc0hLUGKyhqeCfvhepVJaj6yWp+/XJVsc8JgR3u92vx4gxIJsuPpck1H9DEFwV5nnX3kOuPoC3xdn6LO2UODGMKt32g1Wq0Udqtrpr3wpZ7IEy91jApBMWoPCfN6fdPgNXFnwN2WpjXOWBXiW7cu5FROswk8rnetMycAzq5ScFAr8my0buHyZe9Ncl8v5lgUcrdd1Q6pohco1n3VCv7h7uwSpuayUSTT0ZjDlWSOVlCsJDmD3IQrTuPZKRnumyMj0uSm2cyZLN2OZLMfgzu7p8qXO2XXlPzOpteBbd6UPZemNYW9X65GVTll+nlkt+fcy6FgQBsHw9jazUm7t1EShXif+T2fA++p02FD5PPvN7gFXX0CitoiLn1/123N9nd12b5vj+lgyyb2QxzPFJvcslr+9rb9iSnKRMAHPdrgS0jnyFyGC+XS7OLUZ9dXXufKSloD+HQme+9t1+kLcvsuNiPX7epbZuM+xrr5Yseae8e/ptXGA70ethc4CGM6Sn4HTwCz8PsrGAVmj6jQusB0XEA5jbIflEwV+oyYYUWz4sPYZZ4IyrPwnNf7GyTtqLMRNYh4XIB5lw8qNa7Pxyz9/z86nlynOZoFrzxGULS8jUTnRYdS2trTYMkNXWUe3d5HJ8MdfeZdQjKKSTSh8qX7cFdmqfsiV+zf12XW53KuW+xVbps4BvhtYACzXX2WXYHBnB/4S+dYWYGwfYaFKcKC8WijQoyLS9estJIObjwyDIFVOENBoEKCmUvD94+am2FaZjAZg5TlmXt/X7td27hH4OgOpjZ2HHwAF4HuAgOvW29Knb1/v/ALI3KVSeOalLczvHSFflO7ZZJJymTKAYlF7T6hWtWthuC76tmaMXRd4+6brR9mzbR6v15n+wc1dbtxSUgqFEHM5XbdUWrruShIcBnf6ZdLa95nd55J8LgusvKA7q1hkYUp64boEZeV5Xt88ZkcrmtZ14bnAXBkEwJ/8lPaSIScNvkzFTOrJBcC+SiX9ACQJE/7g7FlM2mpRXiAjgaNalWT9uh579PrhSp9tx9xwp2J3X74MWCfIXnWxuLGJzU3g574GfHKZTZc0iT2Ve7bNTR3ZOZnSXzN1y5kMPz+7xvTCNODaLt5bd3130MIgWFeu2NR35Rvf4Os3XwWev0ygr8KRJ1Py3nd2yPrv7XKlY29X95870N+F99n5ZDs+aAv+wI8LUp50Xc5io8BYVNq4c2ctP3hNGCCNYozjbBRjHwUsw4DcDZ2LAttuzPFhdRkHYI3D8I5qZ1UvM1RGFCCNuzaq3DhgP+74jir74UGnTj+qT8e9ftiYO8t9ntdn59MLioHT6FSBF9PU0SokHXuywR/Qnk1gmUrJTUhra4B1gkTnGNfAzXm3b+vd/MH9WwooLy1pUmplhcBZ6YEVMAD0j77CJK5L178KFCsALgwNjNW5+3WCgTjyy3W5WXAgb//uFvDCS9saHNcuak8MqTSPqdDHygexcllWKuHBm3cxW5GZl0pkkG/dYj6dY+DKCzynvCoUCoApvQw0ZKXtntzsl+f77W36xHW5nD5dm/EZ7EaDoF/50i0W+X5pidVS7GfP1nurymUyyKguIr/ax6VGA4dNF9PVKQzax9Squq7cZBfQSdsySuDGBkFsPg+sPKO9dyjG2zrRDZ7JnvZg4rpknOv7erNco8F22HhXeuWYOu2OJJVmgI6S3KBY39cR9owEQa8C0Ckpsm0ekKWv7/Maw4DvWzuV9rtvexu4t8OgK32bobYBTrKeWaUc5aABzJVdP1Kf9/oblFEUCszT2JeMq0A6IP/5xhbwuVW9f/G4oycvb98GnpXfn298g5KfpSX5fTK4QQ6A7wEl5TT8fPJ54N310wsbrRajQxsGH9aOS1Cv5CAnFugXWs06FTJ/89vA8iX2mfqSBUO7v/8bM+TcxII27EdzFDs6CkwH04WvOduPdbw9ChiJAyHjAK+oe4pKG8WqnsVG1SUOGAePDfs8qsyofouqS/j6OIAaB9aDeZ21nc5yT1Ht9Tj6KZxnsKxRk4ignWXyMI6dHRifv2fnw0yqvzcsk+Fms1pNg729fS5NS7qss1FHf4uAWBhAfrWCdIbvT+kXwCVfxyFODrKzhkFAENQMC4NhhlU6taSs/BoDmgVTx4NgICEVBgpEOA6wu6eB9PY28N4GgbH/m28Q3yTLM+g73JCXr0wBYF2wvKzBXFBOoLS1nQ5BqzOQDml7vq52tiIrW5plYe1DgkXDYGjd7jEBcbtNhNRuE2Cuv0uQVSySMb3yPAF1Ks365HKYXqsgcfUyz9UuArkp5POamA3u6VOf63Wy8mpzoQLHfcvFYOueL2MoFIBf/foxErkU27fZxP06sL9+hN5eS89kmk3OXpT0QXWEYfCciriSnyLQqkqPErbNttvbJfNrUeuiNtoB0BEzVPQ8KZs4vLXLjZh2jyxmswnvtqRxXbmZzhAE7wrQleYYglppTlJpLXUpzkCUikgWp/yxdV+22UGD7ZUvpZCUGmAVhEYteWxtAQfblv+dGGzdAzpHONxs4bnr07h+HXhZBnT5+sbpr5pijgFqfpXkR4FpNSn0yXfrBP0derq4fJnnb93S3wH1+svfOD3xVN+F27cpj7m7BWyvW9jedLC9YWN/x8WDV+Vkd+ee9jmeSg9higH9Uzfu3/e+Bdk24PHc/bg/RmEgMorhehw2CtA/avlR+QRfg+A5CLyCf3H5htvorAByGOAKfx7W/6MY0nEAXDi/s4C5s6Z5XONqWLsM6zt17ahJY9y5h71u1BPtbN/x8/fsfIqZYqGX/IM7/wNahvzaIvpbu3RTu1KCv/Tvh6+TngN27vlR7BTR57qSLK1pH7qXVogt89VpHG4f+Zvs1G559eMeBMBKlqH+AB0xLwwSlBcBlYfa3GearIfjAAcbhzLYgYvDHXquSMjPvs9cgODX6mkPBwoASm8XPoWnQugqX731OtF3fprplR/gW28Da88SXCq2tFAgEFxa5LGNDd2AUlbRr7eQXHuO52X84ezyAJ8zb6HVAuaXTPzqtxysrek2nMoTi86VAhsXZRslUgZ6jSOky9O+GuHuui0nJuyoZpN/L6zJ0MIZCZ6U/9xUmiC/WKTbg5ShN965Hj1W2Lb03OFIuckAIj8FuB5EqcgKqmAdSiQNAE4f++tH/r34euvOEf1qq+Af7TbdsCnhtfJhrPxMK91s+4hluS769RZ6khlutfRYWVri6911bhZtNnksIb103L4NX7rSs/S4SqVcHHWA+uv0dnL9OoDXgdf3gG9t03tKGkAPwGdW1TVkcH/Lf8wqJgwgW8qg07CwWOUtvPOtFqpV7dJa7fvM5+WE1CXT/KlPct5y+bL+7g1cstHZWgn9vaY/SVRm20Bnk7OBwXrD31hIV4ifwPvtyS0BCiESAF4FcM/zvB99IoWcUwszUueRvRkG8uLASBzTbES8KhsFDsPXmBid16j2dkOvw+obVZ9ReYyyOMDqhtLEAfBheYbTR+U5bt7DQP+wukblMQ5If5iJxbC8xwHU8Wkm8onzZZ4rfZb2dUhnpfVU7wEkVy4g6fQJiDPpU7Tt4NY6AH1J36Grqk98YQZwXdzfIJC5uGqSCbV7yF8uA/W67xGu29UyTSVjVgoO39eqLENFugP0uVYLp/TMbmAMvroDvFwhUHjzTZ67dg34zGd5fqaawaml+HyeWtX6vnaVpihYFcSi1SKQBQDrBHc3GXL3ft2G+eq3MVsC5su7SFdm4COs/BQRjvLuYCZZTi4LlGXF6/clZZ4kgHYYPc0wwMrn89RASC2oafJjv+ugVmP2wiDIShhAbcVEp+XgqK3bw3W1S7f6rSM0m8y6VOJS/kJF4vQu8z544y4AYO4LH9du5F5/XftfdgdcbQjORK59jK9duYnOOkHnxm3kKwx2Mr00zeeE0mirsNe338Z3XiVlqrIHwMlFrQaUy0hubbF9Oh32V6vFCYjc3OdH6tjb1W7GXLoU9BpNfy7X7bK9MhlmYVmSuZXeIG7eBBaqlOGoCHiA7r6ESeZXkeSKuS8W6cnv1h7QBd2lvbyiJ34vvcTX1VXgndt67Kf2LH+SpyLw3bql+1N95Vot4MYN4NOfBl55hasy3a6caCq1iEE2+lk06UscQMW+4/tJVl4q1JxOBcmJjfLMkTPs5KPYHwHwFoDCqIQfRXsSrRL+UR73B/5h6nKWaxTYGAbyRpUxjHEbBZLDACoqHwWs4vIdlgcizsXVSb0G6xfOz4k4PgrcRYHzYUAxWM+oewu+RuUTNekaZ0wMA6dRgDl8Pu6aYdfFgelxyxjXzjLhGq+cCSg+P6ZcFgAy+AQI9hTAsaVXBfXZTJ4W/AZiNSuvEioiLgDAZRCNgUtNrL2xi2ytRLC9sgKj8YbvAisYvEP9OCel39ZUSvuNDbLDQa8VilwN/rC7rgbEgAx8AW6oursFvFCUPojVhjvFaK6sEMS221yDBojSqos87/SBjNyUuLeLi/ke4DjoWcdqXxf6DtDfOUS+lJJa2Ad01dbpsGKZNMu2+wTfuSm2fXWRGuTaBWD7Hg5bBGQJ64THCgW/XCGDjyTbhygZLSRKM7i/foj5CplHAGi1HKRT1LIeNHkruzu6C+t1DY7298iAWpbenHfUoe725BvfRvblyzxRq+mNh6bJNmq3+T43Re1weV76KtsH9vaRzQAPto/piKJ9BFGc4Wa8pQtyg6MA8nk8s9rEQUPv90yXptiguSz7oDynvXt0JIvdOiSyVDvmrBMy0O229klXXYToHAE7O0gWZzHj9HEFDNBx2OZ9K1/WritlNiaBZqEApHOG1lm32xzPtt4opzbPKawOEOVdXtKa4dUAU6w0xgrXAxIcpxhU5J3bbOZ7sq/UZkrTJBvtusxPfQWVw5Lg5HDgAt7mHQgZ1ERtxMwo3XLgu6s2A0bbk2E7hBA1AL8BwH8D4I899gK+ByzqB1od/7BsGBMXV78oljcO8J6lvKi81TEn4jrFEMfVIQ54jWYE4wF3VFlR14TrEAS6YeAafq8+R93DOBOWYeA2rq7DwGJcnuH8w2B4nAnhqHKfhI07MX2/TZji82VKJhAUJAKndqf1NvUOdbXvjpfYvlvbK1e0BNcwgPmVqVP5qWAdANDbaSJtGDjZIvsa9g6hglAocOK4ZMyUb2O1D1C9V38K+DqWljrfaAKvLAGQaYTBfBQIPCUbMRMET4oJLpXgO4RVN91uE+QBZI03N/k+lQQcB7t7un6eq+QmEkyV52Qo49nT6D+f1+Vl0kxTXeAxp49CgUEeUCwyhHGzSYCYyZJKb7eBwgwSNmUv5TI3iaUsC+lixo/8N5UjGC6VtN/iE0tLAra2CARffQNYKPOY2qCnhgjeuE3mUWlP1SatHHXZqF0kIC4UCHjtvnaiC+1WTlSl39y1Nd4HwAmXM0C+2EY+7+DOJpupgmOkCyntCFjJIVIp6QHjPqUnKkqGGr87O+iv30GyPEMU2O1K4J7kZjw5YXNdRvxTwVFkJGWfqT5oAtN5oNNxkescnvLB7TgaYHa77LKZAu+xC84xF5cIaBeX2BRBByPpFOAYvoMMDqWUHvvHXeBijZtI1W0phU+lovMZuKf9fBuGdncoTAPe9j30HfZ/oUC9sUqv6uQ4OiDOB2h/GcCfADD9wRf9wdo47NdZ8zk/wOD9gPFx1D2K5QyWF2Qzw2VGMaijwKMRSBPuh7MwsVHng+ni8hn1OWpiEFfXqPcIpRv2OXh9FFiOm/xEWdyYfpTx9rhtWB9/L9rTC4oB/kLWLuhl5gh3DabJ5eSgqzS1icswmIUCrfOr0xr0gW+FoYGrYcAHxAOXbNjmpvTL6mrtq/qBF4bGpUHMozYqKYA7cDSgtm3g9RZZ4eDtXKxRD6o8U33nVRsrK6TapqtTWv+r3IZ98pNkIfNTPN5uE4g2GsDNt+gZwnYgCtOA08eCXMUvl6VnsLU1XmcIokszyYqUZCCPrmQ6KxWWbfc1RQsAjQaEKW9eRWxbXfU3rflIynWlD+EpCLuHbtfxNdNKHqA8UezusY0Vw9hoAO912VY7e4DcJ+ZrwA2Dm9CKRSCbN7g5q9XiDe7c4/25LoH8t76pOwiQPozpFeKkfox8ZQrpTJrUaX5aS0qUR4l2AUojUKsd0ldwrSwDptzXoLhSkWxwQfuVUz7LHIcbGEuzSF6XCNTusy6FApBjcI/e5q6Wxdta4u04dAF3P7APUN2ObXOMqWBzAMdRt8tq9Cyg6eiNj31Q033QpIeLdEoHB1HdpupQLGovLJmMjlanxriKggdojyOBhRoGB4GelKm+g2HAdV1M5Xi875xmkwHWx7JGscVn/jkoCyFeDXz+Gc/zfkZ9EEL8KIC653mvCSE+f9bMPwo2bouMYhcf9sf/UX+kz3LtKFY1mJ8RcS54fhx2cRjIDR8b9z7GYZuH9ceofow7HgaeisVG6PM442BY28YB44cBmnEgPArgD+uDYJ9HAeTzBDQfvp7n5Q61Pb2g2JOM3+amdp8VpJskiFPB19QPad8hsFI/0o5DUvUTn5fLy8ocFz1bB+5ImqfBbXZ1EbB7+NiqcQooJwy+bm7CZzoVWxwM8qEkFwpsq813N1rA90u28+IyAV65rF3B5XIExpUK72H+WkUe3JVBNWRQieaBBKH7BID1umZF7R4e1B0Ui8Ddm0c+g1cqEXjOvHSJgFGJUZVuu+Vqn71qnX5zk+maBwSbW1ta6JlKcXOe8sllnUB5YtD+6pJAx/MZfyVdzmTI5ivsOE8pNwaBbnZd4GIK2LH51d0G8GyRQDgo193cBBYqLpI5Q5fZuM9MFEJUrHerpYXJ7Tbg9Onlo1BgG6y/y0AouXnKUZpN4OqLOt9MGonaImbabfieL2o1DN78LsNS5/Nk1VstwEhIYO5x7LUesBO278lQiEfAXkPfrN0Duie+jhgg4FSqFlV116UEZQ4WBi6ZdiX58BwXwjTgOC6SKY6rIJvbaFC2sySlE2qSFAz/nExpnTGg3eopfbyybpd/jqPDTytf35bFul+snV58GLhaDoKlC8DGnVNhv1VTqDlGkPGOtzM/2Bue570y5PwPAPhNQogfAUn1ghDi73ue99vPWtBH2cZptTggNs61DwPgHjbvYUA1ilmMOxdXDwWQ4n6QxwFULt6f51ktqj/GBW9xdRpVj2FANngsDEpV3nGMdNTEIep8XH2j7vlRJiGPAoifBJj+YNjoCSg+X6YkBBsbgHWCXtf1o9IlTQJi9aOpXKt5rgZWQQXCweYR5taKkspKAnYPA+c0e7W1RXYtWZV0WioNuANKQWUQg4HLMi7WtKQXIFuNQLnq/XNrGkjc2QJ+4rMaML/8MstUEg+1oe/qVabPZECkuBTQ65bLBFjFGV2460qXYRKhrKxgNt/A7k36DC6VdDvULk9RZpFiG2DtOVYiJaOv1e/zL5Uk4FY+gJeXWZdWC2i3cdJxkV2WGgZbgurlZaInFQDD7wAJCgsFWHstZHOaUVfe1NRtOPZpQDRwgYoBbMjv7r7ckGXbuv1NE/ja14CVFQfPXuvrMGyGwbqpWUGrJbW3ErC7A064useUOSgfza4LP7z21Rd5P+o6dV4x6B16j0hcXgU2N9HZOSRINQDkuHnvsA3Umk1u+nMctu3rr0t/0Epv0wcaDT9atRrngHQ5nQOevwJ8+w1usgsuM7gukHAcIJOF0zqGY7nI5g3srBMYV6vU/yZNTt6UazU1LksldqOSo6SLGQCWr6dXRZVKDMqixmZwEhh8b1lkratVvvYs3U8Aj7kukNi5h0RxGolMGstmw7/fXE43S7HI73n//YtE0h6/Ls7zvD8N4E8DgGSK//OnERCfNb+zMH1R4Cwq3aj8z1JmHNMbVbe4+gTrEb6PqPfjtMuwNOOA/7g8R6VRppjgUWBuFBiPOh8FiKOYXTd0LKpu4bTDAHpU3c8y5oeVEZVvOP045Z2l34dZeBISLiPeJpri82WeZhdVJLPgRjUF8tSyqmJ7LQtImcCJo4GVWpY9WG9Jva8F2+aPbRA82zaQrElNqWnKwBCOv6SrNi2ptMvLjFCrjv/yBoeZwOnhppaUn13VrnVVHteuAdmCqYM+OHRDd9K0IC6vEXjt7dKvVaFARJNKadC6c0+DOCV5yE2ht9fytcxzZXrdSJam4e8A9MPLQbtqA/zyfVbd6nETXvOA0grnACgUkC2nJcNskyYsFgmuV1Z0eGjDIKvtDiSY9Hw3yAmDAMtz6VliIHXVirlXbscaDWq3r5eAHVnlZlP66XV13yuQvbtn4eMvqQ1aLvLGCQCplc5PE+AqKrpaZbu/8kNkiPPTLLQgVxVWXyD7ncsBjQNNpbouwbYKIgOw/VdXkd/cZHS/pWmge4zpkol63WFb3XobJ41jZHME933nGLVVDmDPsiFMA/kC/TVffKVCWYXrYsE6wYOGiwdN4OMvy0GVmwLahwxqYgIJ2W/JjAGn42J320VZsu8HTbLJ1erp8RicECqNtm0D/baFZIp9EdxA6jg81rPpg1v5S1YWXCVR/ryB0yswA0cHYoTj4GjnCNOX89QXO+6pVR913fNXgL/xMwAC8VZO2/l7sJ9nOwvgirNxQUMwfVQe4+QfBRrGvYdR7OpZgeSwMqLSRpUVZiVVuqg8x62DAnZxE4e4z2pzYPi6s7Kco9rxLGMuChjGAcZhbR43OYoqL2qsjgOQo+pw1rYbdt3o79n5e3Y+vaBYCPmr2Ceb2TlCwhmQEQMAp49n7YavHb51i7hRLd3Olo3TQuOlC5Id7eO9r945xSIDTFqtAv3tOplihbJkHrYNzFVNHx1My1/uz37Wwfo6Afb3LdHNGgB8sgZ/w93aGuukZLYXl8k0X/ysDDSxtsbEjQYlEgCyrRbdoq2uErGUSjIIxYBIxzBkVDvJhu7tkgEvFoG9Xdg2UFs2MJVzsb8nN9i1jyAMMndptLRbsEYDfmhoNREpFIheynNkljMyuEcqqW+kXCYLnMmyDksXKPPITWmXZqbJerfbQHEWyWoCabuJgyZD/ioHEbkcX+83+D6fZ5t++tMsam8PeK+pAXBDaolTKcAwA44v9oBvv0m9bKkE5MuqffbRuX0PfanRFcUZLdZtPmC4a7XbLjelXUw4Ds87Dv2MKSfJgAbElXm2484u+l0HzSZw2D7CgyaQybjcWPmqhaTUzT5oysCANrC7Y6NaJfNaKnElJLtUlH3D8Nu9LjfezVXpxg4A8uYxsgUT2QL0LjfbxgPZRsoriuvSld1ilW22vc3hFmSJ01dWALuPNADs7cJzXCQrsm3sPk4ax6cY475NcKtkDcLQLPPyspxXFADx0sd0kBS5WpCVkyNV+HSz6fty3t7maooKGmKaHAuGAXzpS8Bf/3bUg+LJsh2e530VwFefWAEfkgV/QMdhM4NpR+V3VhsHVMaxjaOAcfj6cUfKKFA0LL+HaYs4FlW9DwOsYWxrVD2iQGUYXAfBY3hMxAHLqDpHpTERfU/hOkW156g+iCszqo7Djg1ro7h2HjahGadecRY1DuIAfDjd+HWYMMXnyzxPU07tNny3ZAEXbG/JDXZra8DHfuQi+ht30e0Cs0vy1zpIYwE+olpZAX7xF3mo7+jQs2rTXH+vqSUUgA9IfJN12N0mWKnVCKgHLvBJR29WMgzgnXW9tGwYTKeCIADQmlfl1iy4tp3LBtBfmgB5c5NAI5WWMhBbizqV+LSyALQY9rnRcP0w064LJHIZpE2H19cuEMXk8xrEtts+MCc4ljKNToeuzJpNXrOzo69T8g1FgTca8B3XSh/TnaaNRHMX2aUiBo4O9dxsAosrKRzs2H4EN9Vtq6tsr57NNla+bheXgO+8qaMn53JUMxSLWg4NSCJcue1rt5EvSuoxP83Mmg84vmo16f2hJ/XIDd6j3dP67dyUZsU7xzxXLnNToyEpTKcPx+EEKOgFQmnLOx0WUyrpTZhK9ZLLsS2yOaC310J6ucI+6hwhXc0gnZsCaheQ754AjQZ6m4yoly8YeNAETNPR1etott002TY3b552kqHGaC4HP0of7B6Qn4a1d4is3feDwmSXyzjaYOcoiY9hBPTEcoXm1U3g858HFl+uaD/Xl5/jhMtxpJg8zdWH8hxvvj0PrDNkd83d9Zli1yWAV5PXD8lP8fesBX/kz/LDPZp5Olv5Ks9x0j4KoxZX74e9l2C7xeUdB1SHgaizgPBRjOawMsKAOJw+CrBGTUiMiPPh64J5DgPGo2xUu0WBfOA0iArXKWrCEZV30Eb1+1ks3H7h7+MwsB03gcGZ6nX+np1PMSiG3L0mXbMZQksaAHz7ywSP/g+83UOyWsKs1SObCgCuC8+V2kyFQl2ycSsrmugzDALjalXrOHs7TXoXADCzLANdqGhxoAupgctr3lknyFPL0/NVAw8aZAhffpnH7m0Tzy4t8XOlAiK4fJ7IRLGWeekhozgrwUNZ1z2VJjir1wkoVOQ060SjFABIpSAM4LDhqFumS7miCilcZL5KA7J0QaO0pUXtHqxU0gE7MlntaaLdJuDNZOF7XDAE3ZG122z/YpEsfwdAeR75IqUWDzZamF2eRvsmg3NUKkCnyUhtKsKd8tZxYUk6xjApkymVePyd29RhJ1NkXYMB5wyDRRcK0mUwjmC2jyBSJvpdh6C1eYTZFUNLRNRkwO6xP0xTA/vtbU4SXJcTM6X/VdHwlhYJKtttAJTCWNJPsOuyS9IZeoxQbsxKJYLIbE7q0y/LSVx5nhsEl5f1zRiGjlRYKgFuA1hbQ7pUAl7/Lk46LmarKfQ7tn8bpqm9zaVSZM+VzDoIapV3imx9n9rqTBbonpCpbrW0Gz6nj+nqFMzGMdpt6WzE0W2eyTBox098AVi8VqLcJiUDwPjf2TQ7Zkf63ltZ4bmlC1AbEoXTx2L+BPc3j9GXKyxKCz0Y+uw+fw/2J23DfrA/7NYah92MYuOCn6OA3Kj7Gqe8Ye02CpRHAcRRgCsOfEa9D4PgccBT2MYBosPqHNcvZwW46vpxLS7/qHYO18/F+2UeUUD+LN+LUZObuPThY8H3ceM6XL9RY2vYeIvP9fzY0wuK0ykoLbEfuEJKFr795ToSJmA4wLNSeXC0Xsf0p18kQJSh5dRuds8FhCPZMPlLXqvxo3KkYBiUxKogBgDds2WvXyGqcPo+wH5vg+mXl4klLyxRF+tTXKUSZkuAV2/g3g49KwwcgmZ1O64L1lVt8rJ6umAl27j2IpnIQoGsm9XTbdE9AdxjShuU6DmVligygYOG9vFq25I1VfXLT/F9qURQohjd2gUpIehTq6wiCdoqLLEMvZ2fIrVuJgkQWy0yf1ZP+zt2XTKqgTZ/sNHC7FIGgxbDDh80Nbk9lefnizXdBMdd7X3hvlSMHDSIp5pNHqtW9Ya7oBxGLb93OmyHBLS7sk4HmO0cnXapoFws5Ka0lwpbhtAuFHTbq/YA5GY8m+dUY4NNowj+VotjZleOg1xO/zkO7xu2jb7lIplqE5SrMjJptnl5TsspFDO/cw/ppRI6W02ctGx/FWJnR4NhwyAgV2oP/6skpQ/TRQMwTfQ7NpJq06XSmVuWbg/HATJpZE0TZfsQW1u8p3vbTH7jhgbYWF3l2Hn5ZX5/u3JVQzkfvv59Utfh8X7ULHRpEb3Xv4t0MYP5WgrbG7YfZrrvUMMcbedzCfBJ2ziA+KwgJnhdHOM2Trpg2Q/LhJ2ljnEAIe5YHJup3seBUXVuVFnDAM+weoWvi6vnMAvfS9S1UUA3rvyHmZzE1Svc36MA9zhljgL2w9JFpY2753BdosbfqO/NON+JcW28Pjifz86HfW6df+v1CG7ln7d1F9i6g7e+SkCsPEcAZJGmV0pEtT5g0SypbcNHA8q9mrIrV/R7tbFHAcmBC2BnF4ebLdzftrG1BfzyL2kQZttAujKD2araOSRNog/HoVTCMIBL16ZRrWowPlM2WVdnoEMoA1onrHQAKytkj/18+/wLlAOAQEOFOOt0cNQhrul0CCrqddkG5TLBqiGkC7J15qe2+qfSzOfqi0zXbmumcnOTIPz2beDGdyUVegJs3+W59Xd0AIqdHQ0uWw+AZhOzq0UAQKI0g1aLzHBPepF40AQuLWvPBfm87uNmEyrmhY89g5u5lJa8UNBSaD9ymwTBnu34sm1hgAnabda9INs3p1yz2QR0yi+zCqVtS9BvCB43hNRPS7313i4e1B0/+Z4MmHLQ0AEt9qWE4cQCFl6qoG8Du9vywaTYYAW+rZ7Wei8vcxJl26yDaQKZLPLLJWQLJlIyhojSaO/tsdo9i2DZMAiElWT82TXgsMkPyYwRYP8lEF9akiHDj3mxMwCuPI9UivlsbjKfW7fkooADXKiBbXbtY9oBNSAnbFLvPj0DLFwjS28YFChXKsDePpNLir1WYz9duaI1xvHmnvHv6bQP+s7DoO2s5QdBQhiMRpURdd2otA9Tn6j8ohhKhF6jRmDcqAwfjwMC45wf1kbDLIqBjCo7Ks+4+4mz8P2OmkQEWeBh6YYdD5f/sNdGXTPOhCXqXofVJao+wyYL49X9/D07n16mGIJMklpChot31+F7gQA0Du3bgB/iePsu7m6dxouuCzgbTd8vsAJMpkkAFvTJurmp3UF1u4CxfugDa+V7Vfl4TVRKLDdAT/ZtIGnTE4Cqn/L6kF5ZBKoLeO5qh+BzSYZmzuc1Q9i4r4Gv62qPB1aPqFBpiLvHOqiGTwH2gXwevY6DniWVDBJXl8uQbtdcosT1DhG6ZQE3d5jIcYByloClcUDGT0Wz29tlwyjaUUlblL+32+/weOdI+uaV7SIb4aTtIFuQyExu1HMcDXy7XQK5fJ7gThicUKigEYZB0HXS1eqPVkuzscWiZoVNE5itTeHB9jHBd5nsvnJVnM8DsCx0OkD+ygXZJkeBjXZZ+hLuHvNYJisHU1r2s8f7M01mKN3S9S3X7woV2rheB168BrwlXfZ5EmNfvgyg1cJs2cDutot2G5i7sqzbzJZSGDMJFEp6wNb3dSzmVBoorQKdI4jtbVxczuLk9l1UKvSKosa0YdCNm8Kp5TIZWNeVnXDlChO328CV55lv84D3/Y1fZsLKPNCiR5OvfAW+T+2Fql4FGTjQ4+HyZcppclmO8QuXQJe/AwAtYOoicHxXT5zyean+cZHNs51qqyn02jaeu5bC/lZof4Bv55Pt+KBt3BZ6FHAwbhmPwlCPAwrCdpZ6DQN64fzC6eNAc1yeUcAuKv0oOyvojWNFw+fdEWlHMc3j2Ki0UYxxVPtF6YbHBclnqf9ZVg2ciOPh8RIuexQjHrxuWF3HA8bn89n59DLFyiRCFSnTZ3CDlq8VMVubIsBcXgZqF3FxmW+VGykFVO5tE5OlUtrV1FSO+ail94FL9tK2qTkOg2sVnCBRLvJgSYdGHihZhNQ9K0AHgBuOrr3I5eXyPAWTameYChwBsLC9fUara7UIkgMb1uAMyODeuKEBsXWi6W2777OBwOloaCjMEPWnkkSGiikNIkt13ExQZ5qTEfOsHgZ7DfS6LhlG6a8Yb37bZxQHLRni2B0QMSl2EEB2ucx7N014rmZ8FbCayuv2d12GL1bBHtTmNU/2jeqTIDnfbmsPH44DHO4cY3a1CNcF3l2nFOPt20x72Ga46XxNNo5aYXBdZrS1pTXTzkA78TWkBjmf56zIMNhGhoFB8xDJ8ozPmloWQX6ppMlQFUFxb49j66TFwVEuS+mBqnyhAFy/ztDZy8uMyLckIzteeYF+/FTkE1fO8mzKWFRkuKtXdWS5nR2O84s1DrtGg+06W5G78KT3B5TnuPnQHch+P+Hkp1Jhm2xsIF8wfK8Qtk0WV61+2Db0xGJnl4C4eyJnIQUAFQB5AJcAlICpaT2mDcPvf7guJ76uS//E6jXWzh/b8VG1h2Fkn7SFmeJhzDFwNkbyLHUYBl7HbYtg2VFDOgiSRoEldfysE4VR9x6sQxT4GvZ+nEnVWRjdKBAZ1e7BYybeP1bC74dZGMQGx1sYcA9ri+A14042P/gn1Pl7dj69TLGAjPF6Apgmem3bXy6/cUMvmfs7ipS20zohYwW9bLyxodnhzU1is4Rk8o67p4HzQC7TD1zqMZUfZNuG77u1WIQEUQPfK4Hy3+q5QNowAOsEpglkayXg05+RO+3b+rpWi2AHg9Nb66uLwGd/QIdt7nTIzlYWyOBt39UguHssNzTNk72s7wOWhWythOV2E/cblCUUCsyuvHGH4aYl+PKaLYaB3tsn6F59VgYHkWvw1okPGHuNI9/1cKEATcsWi4DVw0nH5Wa+rS0AwPbrdaRTQD7fora1UKBUQ7LEKjywwoGLSwRYz72UwYMdywde7bb2XawwoPJGcP26nngoPKswIgC8860WUimW8Yu/yHPVKrvCc4FiqwXn9RZqNeaZyEtXcisr7KfKvN6xZxgEeTsPCCJvfIeFSxBo2wD2DnHQ1HE9XnmFqwS9xhFmKyYuXU3jcOcYRx26SUvmTKBQgFFvUpOem2L/v/QxORi2CCgd6Ybv6gtk8Ntt1lG6gfMFypm0P9GzLI7hvT3tR/uVV5j0oEl3fb6HiKULfG0dMrHasWckeK+KDTcMeLaDL3yB38GElGE/fyXgoi0/zTfVKnwNerMJ2N9leXYPyE6BIDmpZ6NO3+83Ff1Rzex6HcffHxBtH42H9UfZ4li9cdIj8D7M0j1sPc6SfhSzF04bBnVR9xKuT9RP/ihwGE43DpAcBg5HgeW4Y3GgzY14RUTaKAueC9cnCPTC9xP+HNWmUdcC769vVJ3iJgHqWBRgcnHaJdyw8RC+LqrcYfc5bOIUTHuWiU9UHg/7/Rud+0ffnl5QrExqF/oOd6Gnlyv4xGdrksb1yNQ6A/7gWic6pi2kJwNXh7pVv79bW3y/uUks8a1vAZ/8JHfor6wQNCuWuVol6Nre1uDLdUFg6ziA3UNPBuRIStkFZR8JmKZNbW6zSQmCulixcoVCYENVltctL2uQrPwIq12Atg0sX+Lxy5cJVlSUuWKR13ePcX/LQr3OYpU0uVyWdXMA7DVY36LUwypZBUDQ0m4DlQq8f/rPALAIde9zZQlYcjkCoGYTyGWRzTP4AioLQOcItcsJ3Ll57EuVlUuud27r+YGSwZRKwEyBGmO4LmbLBo5arE+jIQlwm8C5WCQYy2Z0fBAVi0Rt2gPYjM9dMXBQZ2jpK3K/ZHD1YH2d+8E6HblRsrKgQzQrRF5d5GQE0KGjFUhUPtYcB5YFvPkm7+WozVPJFJBoHHH1YdvBQtXxPe71bCC5VAQaDSRWLyHvOJQuLF0gOO4ccXwYCUo58lMc57kcwWanww2N5XlKW6SYOmEYwNpzyN64gUvLR8jl6I7tlVek/+NSCfM3N8iCNw+AtU9JLxM2oyS2DmXAFZevVo9pU2nAOoFwHBSLLpaX+Z1QUox8Ve6E29sDXv64/v6mGI7dD0Gelfpt9TMlJ1V4/XV/fKpNklxVsH2GPdrO5xLgh2VBcKBsFGiMAnfj2KP+cMd1+SggEQc241i5MDOIiOPDLAqkKSDpDkkXlU8QGI5Tt7jX8DXhc3HgLWrSEwdug/WNA2pxk6vwaxi4x+UTtjigGq7nsGuHTR6iXoPXDJskxo39YeB32BiJa9+hi2hD7Xw+O88NKBZCfAnAXwE3+v9Nz/P+vBDiGQD/CMAcgNcA/A7P82whxH8FYNPzvL89MmPXRc/iD296ZZE0nOvyVSEMAP5aemUB7jaPK1+4hkGwq3AlwB/drvRu8OlP681bbuAa5QbKlcBahZU2Tfjr94Odui/zVYEGAADVBSQzLR1VIpMmiFQBOpT/5fw0wTwAzMvdWCgBcyng+FCjvFaLyC+VJGpvNoF8Hv0bt7lMvteCZfH+fvEXgddvAZW89t+r3CErUJjPg8BeRk3T/nyP/I1nojCN+xtHcF1KDi4t68AN6cKMpHn7QJsbvwQcoH0oddYDXFqjG7RkQeuIFSA+sbQnOmHwfSJj+ohouujItufSuTA4BlSgi3r9tE9exSQr8O+6AHJTmFt20W8d45lV3ZQAx0K1qr3b9W0guX2XDdZqSS8beeDWW9qncWkW+CWpsTUT6LUs9B0ys7dvs15KrvLCFy+it37XlwT0bXrLUBsCj9pA3u5zHDQOyAKXSpKdv6ODpRQKTLO9TY13dZETrZ17AT9rWT0jME2C99VVXOx8Gyddzp+6XSArfU6nr6wQvKqQgYqWb7UIflsPtKTCGQCrz+joHFKiAWgFif8lSaXZAY0G66kcS6eSMprHMoAuABtADkARmCoB5QHw0kuYbdznOMxl/QA1w/0TKzt/D3ZlT+y5GWHjgrJxjz8piwImwXPD2MS4uo4CeOrVjTgfviYKXEbVKXyN+mxGnI9KP8rigPBZbVhbxqWPOzasnePAWzhdeOIW7pMgIA3WPWrMhIFvXJnD+teF7rO4MkflNaxdosqNOx5+HwbyZ7fH/80WQmwCOAI3kDie570ihCgB+F8BrADYBPATnuc9EEII8Pn3I+CPw095nvf6sPwfdbx/ICaESAD4fwP4YQBXAfykEOIqgL8A4C95nrcG4AGAnx4702yW4O/y80ivXkD2h16hbrhW0z56FYuq2CipC01WSzo4BgioFMBVS7QKrKyuEkj2pLeJW7cIsHo2gYzyQqEAp28SXSaWKpiuTmF2KYN0IUXAUV3QbG+5rEFv+5CAOJ+nxwnb5rnKArCwSBSPEgAH6HWl+y2P1wGSlZSSDSmaTl5egTA0Y3rjhvaOsd3R+/JOAiqTtPRC0GlYZCSDTKgCJtJFm2Vxud1zicHabeCoAwK37bt4cKsOOA43QuWnMWi00GscodeycNR0kFwqo9eyCNwyWbRaxEfzZfgeBvp2AFwVi+g02dCHTddXaMwU2GxTeWCmkgp6QIPrckgoFUGzSZB6Uj8CnD6SOeqYP/lJpl9dBV56SYPn+WsVJD//A+yr9hFfU0m90S4IXi8/x3GYm0K6QpB565b02mbx7+KVKaB77LPhJ109EbnfCIRH7hyxL7/wBekWLqlnZE5fjnGpY15a1G4e9nY5ZlZW2K6NBvNaWQHWnmV6xwEqFWQvX0S5TIYf7UN+ASoVSnqUuB7QmnbT1F5M8tNkr8tlHltbA8pl2DYB8YkV+E4pDXm5zDHaaHDSVZpjPqIAblSsAVgD5RMuAOnWzvcfKLXz1UUEv8SJ2CehYjvO8vfRsCfy3JQWZrHOww9JuJ6jQFkUeB23nHD6cUdGHEgflS4K5MXdR9yxuLyjLAjCRo2DYXUNpwnnYeL9Gl6VRxTTGr4+DFYVwIv6tkbVK04uEWWjwGpc2wybFEVZ1H0OA9HjmIHofMepT7w90Wfnr/E872XP816Rn/8UgF/wPO85AL8gPwN89j0n/34vgL82KuPz8CwDgE8CWPc8b8PzPBtkOX4MwBcA/GOZ5u8A+HH5vgPgZGiOSivs9HUwA9eVP5oefeo6A71JSgHPvV0AQLYy7WfluZQ2BFmn9XXghSssQm3iSUpvFJub/GyaWo2hgh0AEtD4lLIELaYMVqA0Gnv78L0aAKxrYUbeQ58F1y4SNAgJFsQSgBQAQ7K4xxIo9DVT3GxSOqKkFc0HQCaD/TrBmWnK6HXyPnf3dFTmfeJXHLW1G7ROB2zj1gPml89rDxNGAhdXTQwcvenNssgUv3Mb2N8joffe6y3kcoDXOjzlE3e6kgEMA+liBrBO4HWOT/mBPmxLbW9RFimp+vzlC6c669Ky9OZ15QLyVy4CtRoWPn8FC9cvYHmZIPf5qwamCxpfXb4sMZXjALkp5PNkS69f167bVDQ83vMBfUJ3OsAb32b/NR9woHSPgZvf1f3hOL6AeeAA0wXWM6U2nZVKQLGI+esXMVubwvzKFOZXpzG/Oo0XrgB3t9iOh02XjO+eDI1d3/d9bHPM9PWOUMfRjHCrpbUnahysrGgZTE76oU6lgVIJidIM51tqJcC2tS5IyTF8ba+jJ0mVeRk5UfZF9xioLmJ+yfS/L0pW4/shVpodu8dViE5HNnIXJA7y4OjsATgG+nu8//o+vz++J5cBUKv5qze/8IsYYucTFONJPDcDFgYcys7CAD6KPWx+44LTcUF/HLAKg9JxwGEUoI3Lf1g7B6+PAkxnAT/jlKmAq4HTQDaunGHAOPw+7tsVJSEJfo6a1ATrGAaCcWXGAc7wGAmniet3POTxUWkfZnI6DEyP+0Qbfv4De3b+GPgsA04/034MwN/1aN8AUBRCLA7L6LzIJy4AuBv4vA3gUwBanuc5gWMXAMDzvL84MkfPIyBZWuQPpBUIJAHwc3WBAHH7rvbrpZi2yjymAckmC8D1ULYOYRjA179OjanjaI8ESdnSapPPO7fhu2J7801iDtfV3it84CI3Avq7wFxXo1C1lq7AwtKSBra5LPDqq0yztAhYu8DcCggW5EY8FSHOMEh9plL0CqGc3iq/ut1jLFYtnHS1x4NKTrslvnKFel1VnYELLNYIgnoWZN0uUJ+qaNd229fLLi/DD0JSKpFFP5Eew/oO8PxLdJml8JtlyTYKThzy0+hsHxIfyesSBtBq63r59yTlHIZh+4H6CgXZnt1jpsmkAcuCuLyGdCoNbG/jpHt4SgYDAPf3XMzXTpDJSM8iFrshW8pg9toc+0FpS/J5TlRyWeppCwWC1FZLRxe8/TbTmkmfDT5s01tGLgdkr65w0mb32VcqGl67DVx+HnPOO/jMcgInjWNO3JYuSBA9q1l6FSgE0K+VCgFqfZ9tkMkyfX2fx7tdqHDWWLqgPYrIcSjsnm7obpe0//Xr1CtnsvCDsCzJ4CW5KQlSBzoYi5JTlOexUBrAtuuYLQHJWkUHONm5J8X4clNdbooTjnwemHIBtEBs1wFX2CBlONKFX3VRfz+kqciT8faRArpnscf/3JQWBUQeBQw/KtM1rsUBlTBQc0PH484Dp+89ipUMspPhMqPeh+2s6cIgNgzsztrWUfd2luviAHDUmBlWVvgehk0Yoq4dt43HvWbcyU6wvnHjLgzI4yYO4euGnTNCn6PqGz521u/f6PRP5BvtAfiyEMID8Nc9z/sZAAue5+3K83sAFuT7qGfgBQC7iLHzAoqfnK2/S/9SQVNaAQBwHPRtYPNru6jVgGxZumcLyipkAAS1YUcB3Js34csw1UY+RZi5rl4edl1io5UVEmx3toD5ro2FKjQgduTGu709JlLL7vlpH1xiY+M0w9c5JtOdy0oUtwnMLVBLbPX8Hf+Kfu3dvoP0KwV6HAiKZw3DdwOWyxF/qI1llQqLLhYhvUCkmEieSEtvEWg0dPQ25dXCTPi7/q9dI7OcTAWIZINAude2/bmIjHYM1wVWUjYSRgeHe5bvblm1o/qsotpNF0AwF7DpApnoXE7i1sb9QMQ1CVK3toClJfTqh9yXZmgMmkqxnH7HRrnMup90gezliwRtaqKlHAqnUsDme9LXbkKKztOUuly/zv4LaDY8x8VsCbh4bUZulkwAK89I6cUJAfHenvYksrfPNJk0sqUBVxHUbjUVqVD62sbSBZavgrKEfQM2m8zLcXTUjp0dfldyUyx7bU2OtUPgk5/Svq0Bvndd6sfrdV5z9UUGYFHhmfNTLKM4I79zckyurQE3voPZEnXS+VJLC+pbLQlsH1BqokKGT5VAIKzA7iEAQwPim9/VQVJyUxjsNZBIsa5f+5qWPb3fzudmkY+SRYHGx9WicT/qUeWdBbgPq18UEBsFnIN1CVscMAznHWdGKO0oGwaSowBTXB3jQGH4/Kg6DAP94XszIo5Fbe4M5vWwoD6q3cPHRuUZ1Ydx/R22cBvHjae4OkaVGQbKw8oP5vdw9lDPzrIQ4tXA55+RoDdon/M8754QogLg3wghbp0q1fM8CZgfys4LKL4H4GLgc00eKwohTMl6qGORJgXXHfW5NGXIIBYOf6i7J/xsnRDMpJK+tkGFtjUMoN86htu8jXS1iMPNFgANlO5uE/i+uwH8+i+SMXx3Qy8DA1J/LAGmaQJv3dLYU4HjjQ34gUCWlxv4+A/1ZSCLObJq3S5/xZXAtdOhtmH5IgFHq0X5R2mOsgUVtQwADg8IYr7yFY0wU0k8WJduu5Q7ia70DNA8AIqzsKxAhGCb3gbyeeKM9XXgG98Afs0XAg1u9chkLl1gou4xEyp0K0G9qsL+nmzDLY3JNjZkNOprGlcqN8fKP+5sycLGBo8rv7lbW5rJfVtGRFtZAXrWPRgGMLs8Ddg93K8Dz14xtc5VOcdNpfleMautFtLFDBZKCZTbx+h02H9K01utsitml6eRxRFBb6OhffECBHIKdCsEtrQIvPoadbW2TSHy9l0/eIZoNpFfmmdfui5w620y+qUSx6eSzigNfKmkb1y973SYrtPheFBsqwKLhQLroTbSKWDcuE/AaskIiOV5Au9MVpcLSN/QUuLThR8JD67LCB/tNjUfiuZ/6SV2yM23JNst70ttlrN6bIOVFeQLD5Aw7uCdGzaeM/aAy88Dr3yC7Xrzu9qLhWEAgxMg0QcObkvgf495qklfrQav3oDIpADDQCJlYH/HhZqzuS7w3nvvQQhxHBjF+U98YhXnGBQ/8nMTeP+zM2ijmLpxwWYUAHuYVh/FskUBvzDYGsYQuoG/uDyjrglauHwH0T/EUWA3DpDHnRv2OaqdR72PA9BBGwbg4vIf1t5RbGocGxp1LlxWnEWBy7hJ1zAbNRkaBnTDZUcB8Lh+iQK5wWOj7iEoR4lq66g6KnuMz85GQCccaZ7n3ZOvdSHEPwFlYvtCiEXP83alPEJ5SYh7BsbaWSdPH5b9CoDnhBDPCCFSAH4rgH8O4N8C+I9lmt8F4J/FZSA1JVPq75l56YlARUZzGCXOly24nGh4EicoH8YquMPRVgubmwRg6vXddWKWlRWmcxwGNAhuoPMkqFRBOhSrrJbllb27ztfNTeBo+5Bg15Hg2Bdagj/4O/cIYgoFLnfbPYKyugzS0T3WwMhMcAJQmQcMgwEx2m0SfCqCWvNABvZoSFD4AAlTuy5TMTgsi+9XV/n5tVehQ/M1GnqZvlyWkoQsDhoAXBdeownk85hZK2P2SgULV0tYXCJ+Wl7mJWtrxHbNJrM7bBP7A7qterIO2RyLLZW0WqHd5i0pnK/8DKN7jH43wIoWCnLz14wMFZfQM6GM1L/KzYGJfMZ3pODL0h3pcs3pUy6ytysnFE3mp3wzWz3tdQJgfyhf0YVp4MYNnHSBo4bNG15Z0VH+2m09VlVUv8IMJ0hWT7POhWntnk95e1AuNOr72vNFQ/bxzj3ONm69RQDfOebYV+G0FXvrDrSkwrJ4vFjUTLcjPY2oYBqlEicC7TbPd46Y1vd6If0NZ7K8T+XMuVjU/WAIZK9c4nfPTHLzpRqjhRmy4GaS9XZdLjUYBgGxMqW9tyy6XZOePba3XNy+rYeAYQDPPPMMgs8Iz/O887zRDo/huQm8/9l51h+NqPTjtNjD/jiNAiVR6cIANAr4PqyNYnnDoCMOLIaPx/0Frwvex7gTlLNY1ARiWL5RbTGqfeI+R7VNFJgctx5BGwaqx/3Gn7Udos5F5RFugzjGOA4Ix30fw6+jAHvQPqhnpxBiSggxrd4D+CKAG+Bz7XfJZMFn2j8H8DsF7dMADgMyi0g7F0yx53mOEOIPA/jXoGuh/8XzvO8KIf4kgH8khPhzAH4VwM+eKWMfAMvOsG3tQkwiQMuizMGyuDw+cADPOO1TWO0TUlrTC0tAvjLFJXTXxcdKW34iFU7WdQmkkybB33dv6vyUJ4qbN3luZwcw63dQKjEYSNIEFqoteC4glHSiUNBL19I1FrW7m/p+ldyjOOOzxK4LJFwXzSbw7Oqq3sRk22QH198B3DTyrotMw/Yxrq/rBS+5fZvM+De/AXzykwQgXudY+39NpXBYt33PW3PL0oexZcj4wNwo2N46RKOhpQlLS0zfapGR9dzTbtIAYqvFJW7wa7W0AkLNcVSbKi8aqZTrT1T6lotkqwVvrw6Ry0gq+gi+PMaSfpVzWTmh6PoTI+VWz3VlAJCuBccB0orqLpV4vaqQih4oN8rBNFnW8rKvMc6WMjoCiJKwlEps4OVl7UWh+YDyAzXxMAzAlf5+DcP3Aew1mhDLFzW47xwB1QX0b3LWlUxB6oUTrEunwzbIcANcZ6OO/EpZM+eWRbBblJKOxQtkf9fXeU+VCmAILiXU7+uZyJUX5GxqSq4cnHAVw99dKrX8O/c4/jJpX6aR7B6jt91A+vIlssr5PAG+mdTLBlW5CVWFdVa+DW++5ffl9jaQNB3U6y3s7OjFloGrHwXR9pECumPbE3tuPkEbBoLiAMIoFssdki4u71Hpo+pxlnRR9QsyxnEANgjWhoHpqDqNw+zGMY5xZYwDtsZty2DaqHuMmsSEyzQD59WrE1O3cesTVb/gsbj0cRY1cYk6H/wclzZoo9r4rOcfz6TwsT87FwD8Ey5ewQTwDz3P+1dCiF8B8HNCiJ8GcAfAT8j0Pw+6Y1sH1zJ/96gCzgUoBgDP834evMHgsQ2QOn+YDAkauhaEkQBcFwPbhb1+D9klSiPUpi1AgkcD6Lta+qCOO472KPFDPyRlveWyXnqWINtzgYUlLtuqDf3b2wQmz63hFGOsLrt9m/IB26Z8NOjbGAA66w08d0Umvvw8EaIrv55q012ppBGiiioi0WlyqQy02yiVJDuZSpORzmT0UrhNn2aX1kx4tgOxcglJxyFIchycdFysrgLvrDNq3OuvaxkrQInCYd3GTFErNvqtYyRTTcAZYH/jmJGEbUaaU21gmmzLWYkPVeTAVIqMsZpE2Db1wa0Wr1EbpxRGymQ4mfBcfk6YOmT2/AolDo4DJFWHqw1czkD7Ss7R5RtME16jgYELNPb0/kfljs51oSsGMIiKIXjt5ee17zQV/lhFkXMcoGNoxjqTJXC05RhausAJipnk+0yWE4mcDMoSBPE7u0D3GHc3HJgmsJhi8I2D201ORlotX6KSSgFzVQeAg/7WLn0+1/dlaGdGUvzVLzfwfT8uJzHlsh5j+WkuaTTu83irxfqXy2Roc1nWK5NmmlwWaA+Ai89QWrF0QfrDntZhvXNT8Cnc4iyws4P+TgPdLtB+9Q7m1fKKCpOt5CnNB5y0KHS7syPDGqbZj80mkiarXqvB14fn89zoOtzOJygGnsBz8xFtFHAYdj4IhEaBsah8o96PwyKHj8WdiwIzYYA5qrw4cB4HxkaNzDgQHleXUUBoVN/FlamOOSPSRl0TxYwOA9txQPYs4yQKIEYB9GH1j2rnqEleuH5x/a3uPQrkR02aHqbPoz6H6x41gYq3x/vslM+uj0ccPwDwayOOewD+0FnKeJgJ1PeGpVLA8jJE7QJZpmIRiUoJ2eoMDjcJGpQEQlnQl3BgDxqD37kk8vqSSaVfWKmjNOnHVpRLQKmEhesXUC4TIH/iFWCxymvDAT768vPWFsHz9jY1t/e2CZC3t1nEQd3F/ToIOoKZOAPft7KKgofWIUGx0qUaBrC6SgynpAPFWZ5Xegllatnfdcn4SeYyW56CbQPf/wrJwHKZ9Ws0+P6o6cBxgIOGjg6XTMkGdfp+PAvDAOaWUnj+pRRyOfo7ni0B+ZUyxNIinr0+4ysdVlcJbpRThHyeZedy2sMeQOxZKOhAKwmDbZiQMmLlPzdZkCHsVNjgvV3eo/KtpoDn6iqmV0ro21qG7DgcTpmMHC+KHVau1RQ9DsjNZQZ13bWalD4cs6+qC5IdzWtmNyUZU6cv0dw02dQw+lf9bVG+4NkOZkvSxXBLD+L9jWMglUY6Z/j1V9cnS9P+5PCobuHd2y7efFOmUaHAKwsE+fk86wGwXisrbPjaBTmGitQwKwZXSTY4ayAgVu4PWy0eL8/JCHQWsHWXoL8y7w+9TEaO8a0t7U7R9eR3LKGlJpaUD7mc+A6ah4Bp+isGatOoWuX59KeHPSjOtXziI2ejfnDGPR9kz5Q9TMuftcfC4CqqvuOwesNY3GCdRoHfKMAYPhd1PK78UenGaasgaIoDtFFlhfMI900YNCJ0Lqq+UdcGX+PSxYHHUX2v0kX14bC6xfVbVF3jxlwUaA2ff5Sn09mvPZ/PznPDFD928zwCCKcPOFJfbPdxtMNNRJalscbAOe1vOGFo0nVdan/X1shG9iUW9i8GyK5WytoXrN1DolrGyRYZx0pFOx6Yr2hZrnKCoVy+ui4JMKXvVaC52eS5+fV3qTdQNLaZIPDd2uLy9eam1E4n4GtEK/PAzq5mOJsPgMtlAqztbebTPJD60SxETnrfAPT9NJtoNo/9iG+Oo7XArgvMlAwcNl0fqxcKMsJbBoCRgCgVUXNaSOZMP5z2xbW21E9IkJVKAVYPi93votdxTkk4SiUAlQqmSw5BUPsYy8u83Xpd49pul/hLheYulIGB5SCRz/jg/3DrkGDZcZBoH2lNrePIENMEsAoAKyI+kc8gYSSQd48J3HJT2h3b5qZ29+Y4QDHJdlPtC7BC9X2N6JXnCgX4yvOsS6vFeqgAG3ZP101tFEUPwmAkvI+9RI8Yb329iRdeYgRAFKaB5gHbyzQBI4FB10YibwCZLLZv25Qb7+i9hyjPaSa4WKQ0QrHT+Wken1sATtqSDZ+WfoqntCQJYHsMHI67rS05MUv4zDQaB1wa2dv3l0ySpWn0m0fSgcom88pkZRCbJKkTxeorn9tqZlmZh9M8his15H2HqxnKXJffp89/HvgfvxP3sPhoPKzPi4XBwzg/6g9rYZA1rKdGgZO4a4YxkuPe2zDwrJi/IBga956C+YQZx2EAD4G0UdcFIcq49xkFVqPyiAO3UeDQjUkfBstRZYfrGdeXo8BnHAiPsijQHdUmcUB4XItr62HjxQ2lG5bmLDa87ufv2fn0guJeD976Bo679HygojsHl+4B/gavr2tPZ65Lxmp9nb/jhkEco1y2zlcIjqe271FPu7YGceWypqW6crnXMOi6a/suBg5dnB11ToeOVra5qcHmXJnHNjaIo3qSyL1fBy7cvAPcvIN8OUOWTvkgLhaBN7+t9ay5KTJ7nY5P51Yqu1ru8ZWvSFCjPF4U4YcZ63bJXrbbBDR2D3D6uH6d9VhfJ3Go5KUztWnATKDgtPzId7mclG2ohnMGSKZSzHNvlw1Qu0hGMpPWm8XMBLC2hnR1EdjYQNZ1kXUc3H9zF/NLCSCV8LWpMoovLIteQeZK8H0JT+e1HKVUAvKG5cs6ZpamAACD9jH7a3VVgrqBnkwYwmeHV1akLrVjIZEykK2VePMKvH36M3RFJqUXyGU5g1LR1aRfXgBs840NrZdVg3B5WW6y7FMaoXxXL11gaOjmA7aVOaXlGc0DiGoV97+16Y/Zgz2H3jd2dnH3tiXHrINMhuPrxi8d+hMZxdw7DvDyy8D+NzaxcP2CXl2oLhLk7+2zLjNLwPE+MFUEMAUMmtQlqIG8vMz+/epXeZ+qX5W3iVRaS0VyUwTNrutrpFU2D/ZsJFNA0jxC/eYRLso5xO4OdeUDNXEtzXCgWT0/MuBiyZVeOzqYv5IHclM4vHEX167Jto8ExROXbMMsCgDHgQyMOD4KeAy7blhZUczbWfOOyidc9jhcV7iuLt6vI44DtaOAVhxDGDwe/uxEHA/XL8qGgd24OgavDYPCuLyDAGUUGxo3cVHnhrVf1HWBReKRbRI+H8xfacXjJgVRk6CoujqBz8O+Y+MA7KAEYxhIjspzfDB/Pp+dTy8odj1/g5TrEossLwNztYyvoYVhYNkh6qzVCEB3d3ScC0D/5itiOGFofWm6InfRK5TrBgaI1GUoFjpdmcHdrUMsLRGgNBoEcEpju70t9zDJyysVEm2VCsFdsSjZ1xRwVLcwbe9KxDY4XdGNDYZja7ep83RdwExitpoCqgvovLGOqRzQ3DxCPg+kS7JA04TvlUCxl60WmdNSCcoDSrHIIl5+WVV0HqjfhyhMI2n34O3ZWmKgdKGtlnYR4fePy41fmQzQllKGVFp6LEgz3PD2NrCzi1IJGGzvIlFbBDJptFpHyOXIAF6+THLy1VfZriqSsZpMTC9RMjCTY4Qz2H3AEEgoDw4bG2zk9pHc7Uc5wPIy210YWvfsOS6EM0DvxjrSq9KNmpJB1PflBr6E7Lh56VfY4Oa3tTUZPbHHxms0dIAO1R5BsTlAV26tQ15vGOybVBpYfweDjoXmtzb9rq9WeclBE+jcOMSdLa2Dnylo1t112U6GwfZbrHI+QonuPVz8iWXZHm2tj+kcAyf3gakyAAfwWnJyI9nb/BTvTWl+Vf2Vb2LD4FiUqwS+FET1cXUBCddFY5OrOGrzZb3OvwV5b9vb9GudrhY5VtVExpSu5QCcbDeRzRts24yr5VHusIf3+Xuwf5A2CjAOA62Puw5RZQ1j1eI+R/3YD2Maw6ByHGASlV+4LR+23Ya1exjoB9vOCaVTeQU/h8+HAa5KHwe8hrVNVL+E34fvK24SMMyCQDOqvePaIfgXLjucPti2ChiH22MYGA73z1ks/N0bNYl4mDLGs/P37Hx6QTE8H6ue2nmuwioDgOue+v1WsongJrugtth1CWSFIUGx9D6Bel37p1Xu32QGts2Q0f3GoR9IbnmZ2M+WmmZ//5etswA0MK5WtTRAOSx4b93FM0tSH+sO0GtZSKUAYRo4evU2Go3bvn/dep345sqVdbTbOppcqwUsdDpkBIHTwS9cl4ykjG+s2sQweKvb28CzazJtdYEHDMN3l6Y8cyimGa5L9lHRlN1jvdPONLUfXuuE75WPWjMB1wWlF60H2N2wfIZYsZ2qzRqNU/Md2DZQqx3poCNKf10oElR1jsggbt0FikUM2sdIdDeAVIpewQocE7kcGX5RnAG6x0iXpH/ipQvMZ0dGdStMAxvvEmXu7cqAJpTT+NKWVJr3ZhiaEd7a0g3r9HWYZbURL5Ml6M7nmU+z6fvfbbW0Z7dkCvBkGyQMHYDuuAOfFV6octXBMPSqRaGgpdEX3/hVyhvUiodyzya9XVDjc0967TjipCKXDcTahvZdrUI8K3nK9rZcfZCTga0tyjTq+ziqWyiXCc4tC5hdyuCllyzGGDH0hkfFCsPk5ll/4yiAk8YxdclyQPQ27nHjoRprMc+J8/hgP+82CpDFpR8nrbI4IDAMUAbBJEJpzgoy4gDVKGA8DIiF6zHsmqDFAbJwmnHyDAOyqLYKpouqS1y/ROUzLN9RU92otONMbsYdY8PqEtU2wddhY2uUhfOLmkiM+916eDufz86nFxR73ilyaHX19KY6OA729/Reue1tMlSuy7RqdVzlodx9Ka8Gs0sZjcSUPlciD892/H14OzvAEo4wcAmGezbzDjLQii1WLqSUx4WBS3AD6DR16bK6UgHQbOKkcYyDJrBQYR1hGJguAqbJih+2mX5vTzOKCrtcvgwCHtOULrka3EhVntMb9awesLeL7JVLQPcYRbuBRoMY6M4mcOmlaS6PA/C6Fje4FeQMwpKAWMk6zASQyspQyzIAREbqck1TRnI7lj6QJaOYn0Z3s4WZlIPdLQeLyyY6Lccn6JWCRIFg1ce3bgFf+AInE8UiWI4h9KY2Q8iGTZDVdQZIFKYAu4ejho1aTXsh63Yp0Xh29ZAsZH6KAN9M6N14ygXb3p7MV+qK1ebIep0bHDNZnndd1gXQ+mHrRII8h3nbNj1VKMCs2tHqATjmXMLUY1cFOPmlX5IRveW337J4D7mcjo2p5ECq62UcG/zqL1lY3XsVM6XA7NDpS3lLUje6cv9XXdADd+UZTjRqF+BH9FOi7+IstetmkjO7zff4KjcVCgOYqU5h5qpsx+4xkmvPYaFzRPlIeU4G/7B0+yp3dje+g079GEn5HUm6LjoNi6HXU0mgfImTilg7fw/2D9KGAcvg+7O24igg8DDs1iiQBIxmfeOATFSaKAsD2Ki2iTo+qp2jWMVhZSkGMwq8DusvF1oOcFbgH5V3+B7i8hhWHyPm2lHANnw+qr2DaZyY9OP26ag2i2uLUXWNyytoqo3ciPfj5nF2O3/Pzic3SfiomxAwTS4Rq8Acs0sZvjEM7CvsIkFBKkVgsLZGDHLligaoytSSs+uC4EUBYpXIdTGwHF+zrACa42hWTr2qiM2WRdwgJGAtlwluHIeMnmKXAR3kQgGak8YxGg3qaQHm7dka+TcalFwoMKziVVQqBP70ljHHD5WKDk+soqQpCYR0aQfDwEwl5bvldV0QxHa76Lct1OuQQCQlN0X1yDgahgR7Ul9bLPJVBb4olwk0i0V5gw8IBiUA60pdeD5P3WxfSiMyGe1lQAUdcRzg1jbvd28v5EYtP63vpdXSm8Tk0ju6x3hQd7CzI+NtFEhmFoucdGxvg3kUClKsPM1NicUiWWLb1u7xlIcLRWfnpwnQMmktk7B7BMK5KRmS+UQGVZGb3By5EqDkLGoQdo+RTFHSkZFDWgVBzOXgB/BT4zuVktIcg/2TTOmxqZQS169rjx/5PDCw3UAmSbLCitkul2VbBoBzYUYC3KQOrpGRLG7nmH2qqOvWAz1ATRMnTQv55ZIMdW1IKUpbfkl6lFnYfYJjNcHY2wVuvw3c+A6OtlrY3WFfNRrAwY7t3ztnBwmOv1hzz/j39Ni4QOSsAPZhW3FUb8QBxri84tLEsW5RZZyFVRxWl+D7YSMtDlSpa8dlJ4fVY9TkIm5chF+jAK8R+gseD+cVPh5Xn6hjowDzOMeH9e+wfoirX9ykYJx2H8fCfR01QQmPr0d7sp2/Z+dTyxT3LA+3b+uobPMV4HDP8jfBKzlEUALpugQ+tRoBZN+RIA9kbG2H4KxUYhS66apk+tyB76dYeTlLmFrPrEI/G4Z8L9MpzaeKb6BAuGEQrCg21HU1ZlVxC4QBZEsZXLw8DzTuo9+2KOkoc+NbNtPHxdLAD//2TL0OFOmfeaZs0ltFPs8gDbYNuB6w+oxG3DdvSo1Hn4DV7hFxuS5m86zUnFwWP2la/mWGAc2SppI6olutxnaqXdCR+ZwCmdR8HqciDhYKBDKSSR24hxi4zGbgMsqdbfOzbRMj2dINc98BSiniqUaDGxdtGyhZR5guykp2j5m3lHd4jSbEyiXANNFoOOg7xKLHXepx222Oh3weuPPmIS69LFnm6iI3xuXzBILdY15YmNH6YRW/Oifdv2XSbFOlf8ikgbXnCN66x77LNRRmmH5vH+i6TNc5InDOTSFhkBlVkQeVvEA5wmg0gKk820ttGJ2V4ydh6OApypGDYRAYJ5ek4NiQLtBKJU2379Afsp9hcJOdyuj116iZtiyy8SrATPuI116+zPu4/Q5gGDhpWsiWMujvNZH85Ms6pCEgZTcDSiwa9znTaTTQr7fo8s8w0Nlu+QFnmk0dbGXgAImMqTXyamXgfXY+lwCftA37IY9joKJ+hKPOn7X8s1pUHaKOmRHHgunjPg9j+hCRZ7BdRoGmYWUH2b9x6zmsL6LqF1WfYL7hexjVp3HgzIg4HvU5bpypPOJApsrnYcDmqHuKAvpm6Fw4fdSkYFRbBu8h6p6GlRHMM+r9ONeOtvP57HxqQbGypPQgYFkAzNN+ggG9aU4BUMviRru1NeDbbxJk9R3+yNo2vSvc22FUO/phdX1wEIyelTCAQQBwz1RSsCwyWEdt6jwB/pinUgR629s6YrDjAFevarkyoDcdPWiSRc6XXKkfSKAndaTUfzxHILG2poHaygrQOYax1dIi0mKRDJoSljoDHWghl6P7rNIsC7/8vA5r7Dj0HrG+DhUue7FmwHNc1rHoSiBt+67efEY1N6UlDFZP+6drNlmHpQuSfZYMc24KMwXee7dLYKfCO3e7+rKgi+WESd20ZbGtT+Qq/jXzLg6amrD0XGC6xKV7dI7woO4QKG5zA5pp6iAQuRz7Ya4MzlAqUjNdLBLIVuaBVpIVWl/nJrmtLd6Hum+FXHd2Cca7FqPRlUoa4S8vS3ZYEDzX930dsZZ+JLB4mW7MzMBKyM2bzEIFNElKaVA6pV3bqcnD2hrbT4FJpf5Ap0MthoqklykSxALAtRd5b0Htj5pcAED9Pl2/qah0KkBJoUBQXK+zf3d2gWIRJ+v3yHQbCSSvrukJmbLSHF9VAA9nADgDFlep4MGtOmZrUzjYOvbZcJWF2ijrfzHVhtRIO38P9g/K4kDcMIb1cQDjuDyCx8PgZBhjF6zXsDqeBbyepc7h1yhgGwWK1OswUBouf1ifRYHhcP2igFQUwDRizo0C9VHtEcwnqo+j6ha0OEA4rD/i0sYB23A544LJcSYdUe037lNpnO/Tw47dR8/5o2dPNSg2TaDb1sBXgd6BC9RWU/AsG8LQuPa4qzfbOQ7w2jq7/D+sA9eX4AfyWFkhoJqtyGVmOTAMA8iX5K9xJou9N+htIr+2COztMupvm3UolVi/5y4z+UyBYCW4qcgMgHilCVZ64NVVyKhnLlAuI7+2RkBV3yfoMAy6aVtZ0aAslcb0f/576apBCZu7xwTCgGRvJU3qDDQi3NsnMGk2CaLzU7y+9QCwLGQLMhJeuYSFly/qSHsvvURmMJUGZssAcgBSgHGkkf7GBgG8dcLyr14F7CKZ0TffBNr0NJHPE6/dr+tgKko2oTSzTQuo5Hksn9cAUQG/9XWC6gdN3ubSEgDHwWELmDFaVI10AsH+pDxjoWaiZDmU1ZrAzNYWfD3rze/yotKc3mx57UWCysoC78P1yHx3jjmRkhvBREbqGG6/Lf0U93UgkFaL1+3s+hvWDrePfJdySCWRvLqG+dyU75/uY7UODrf0hk6lK+7KjZWWpT07qHspFIAvfYkrDyJlaoa4KsdM474GlFaPLugMg9H3Osfat7HdB1ZWkCgdMv3mZkB+Y+Bo5wiWBcxvbQGFAjrbLeTXFnF0exdO6xj51jqS1ZKWoCgZiupoFU66VAIa9BQyWzZ8wDxdnQJME9OrdMmGlRW2fz7Pm7x5M+YpcT7Zjg/DhoHPMJAaxUqN+iEflSZ4bhjjG84zLp8wEIsqPwVqTqPOjQN4Rh0zA+fMUN2Cr3FlBUFn+F5U+vA1YTDoIvr+w1rbOJAetjgwGJ6gBPMMvw/WNepYXF/ElaOOx00uhlnUhCYORIfzDPZv1OQkXJdgmnD7h9OGyx6VJsqi+mH49efz2flUg2Il3VTaYsjPizUiX5FTIcqcU94nlH32KvA1+Vv6+g6BsbKlJQCGgUTKwMCmF4tktSRDsCVw581D31ME9nYxkF4mlJJga0tGxgMBMaA38Ct5x0zJQL3OQVepnPbNW68Dc8uOXpJfWiTgajRYwBu/Kjdv9chaAlqwXLsILF8i0m4fyg1hOcDs0QWY9PoASC3m6iqwdQeDnToSEqic3L5LP8wdAhRx7UUd5a08J5nGgRRspwEkAfSBQQuYLkm/vkmCnfYR86ku8ppMWjOrjoNELoWpvI1CQbePbfN0p8Pq3rIAAeB+B5gD0JFAUHkzUF4+Dtvs5+nC6UB0Jx0XpsmmU+GRAfqW7rQczC+Z2N500G4DM9eXJFBNapY0qIVttbQfYrWT0+5Td9wx2D7tQ4Le/BTv37Z1FLhOR8+A1IbE8jxmqibLcF2gKLfMpZIy8Ak9VWQyHOszBT0ZXFrS6oZuF35guEKBsqKBwwfhSZvfhay9IT2RHDB/5VJERZkrz7OhvvFN+N4oclPsf9dlXzabbPhMBmo1odMBCl0X6ZTcBNe4D8cBZqspDLo2x0Smh5OtBrKqY+WM9ahhYzrTAVJJpKtFPNho0c0ggLmVtHaNp4KPpNJsk0KBdVhdBbAV86Q4fw/2D8vGAaphZuysFgV04vKLq89Zyo8CAXGANAg648BMVN5RICgIRoNANA4cRk1KhtU3nD6uPYIgbBSIDb6PA4NRwDGu7lH1CF4X9TkK2IfLjAKuo+oQNWaGjaOoc+OM/ag2jmv3YRbXB4/7aTZ8Anv+np1PNShWJgwuJXsusLCS0bSxmcT9He5mD0a4M01KJtpt4JUV4JubQB/AqzvAK9JDheNwQ89c1UQiBSRU9I1UGid7h7h0JYMHO9x8ppb2By5/r994Q+NHz9WaY+UFTeEsz3H9yHEqRsft2/qe7tw8xqXVE+3yzHWJPFIpGeLtmOClfl/Tz+02CzEMYPkicPMtIvTlZbJ/qhKKHaxV+DmVREJFVWs0kH2pCN/fbH5aBpuQkfA6x9o/cacDLJYATAEnd4HsAoHxqXrK5fFmk3l0T0gHt9vMR+4Ka7U0Manc2KlNjVLkgQMANshJG6DcpS43LHa72h3eM5dNH3CZJvNfvDIjyzpGtmCiu8fjnkvAOJWTMhwVbrktHxeZLMFt44SF5acBR/om7hzxXnM5wJau1UyTmmGAFfrWr+gdcSrIietKFl8OnozU1yovDnZfu71zXaBzjMM9uqubzuvmrFR0lMTbtzkvUsA4nWF7TuWAmSKr6bkM2z1dlGWrPsjngRs39JdEhaDudABD6PFiJnShcmnmpMnvmJrMpI0E7jeAdNvxJx+JSsl335ctnfYlDtelzEJ98QDMlg082LPJFhsG4EofzuWynu3IcRu8LtrO34P9w7C4H8cgEBgFwM5SThS7FwcExrEoUBfH2IXvKQ4sDQNBcSxinI2bNqqdXWjGPKouYZAYPDZun0UxieFjcSBxWH2i0kbVMVxfA/F+iKMs7nxcm40CqlH3Gr42CpCPk9cwG2eC8TD2cPmdv2fn4263c2VqCRymCdOUgRyCfopLJczXUphfzmBhdQoLNRPVKtmzBblb33GAj1eBAdj9r0rXVcqF1f0dRzsPNk306oc8Icvpy83yCug2GlQUBPeUea6WSShiEdDu11RghlKJXjEqFXqcKBahl5qDoloV93hlhexksSgBVVEvaQMsdHVVbv7qEXCV5/UmLwWelVcAd0CQpBhB1yXrWV1gXircb7fLv6VFAuQ77wIHt4HsFNBryAa8p4FVZZ5Mo6Izt+8S2KyvU1qQn8ZBg6dOZCCNSoWgTkVZ7gO4L7vVln2lYJAiXTsd7dWs13HQabs42HOwtSUxk/Rnm8sByGQxtzLtM/xZ7jFkX7SlRCDokq3Voii822Vb5qUv4+1tDS47HbZRs8k2rS7IYCIGr9nbZR0yWWD9XbaJLSPdKddutpRlmAntASJHN2+qKjkJ3pX/4rky2fFKRSpjAvjQcwkwUZhBvlZEswlMFw09YItFluX04VP1W1tacpPPyxCQ7zBd/T7w+us4adk4bDi4e5sTw1NugqVf7J5yoadcZjQaOk1lQY9R6OrQ24sHmCZmK4FMnQE3jQJyo6fc0Kg2fO7tItrUEuBZ/iYWtCiWchwbpyXDoHXcfKKAQxCkDqurEfoblm7UdcNsnHRRIy74bItKH74uChCr9+E0w9o43BdRdRvWvmFAGLz/UUAxrpxx0gaPB+sVNTbi6h/XT1FjIPx+VN3izo962jzOJ9GwcRhfzvl8dj61TLEQgUAYpomE6Ug/uJImW1qifEAyxgDTCdCtmZJdLC9rTSZAoNF3uNlOaU63tupYWiITDJD1nXP5w78g9Z1qNVkF6FCbvZQpQKz0zY3G6dDUq6ss07a59N9uSz/DxaJcIs5qn7/VRc2++m61FOOYlq4sZqnd3dvlJjqA17XbcoNVWkeicwbabVk+H1gm73CZ3XEIvtUxyyJQ63SAgkFgaCaAz/2gDK0m2btmU2ps5VK30ycbaSYBM4mBA3TbDtA8RL3O5NN5vUnxuMOsXZfx9hLg5MWRfwIEfb7XsALnL3t7wIUaN+EFIwo++9kSYCaRUDIBy/Ij56l8Wi1g1myznQoFzo7UpEGFYFabCwG9IU8G6TjYOMTclTJO3riNbIWeQvqNQ8p3HEd6aZgm+5rLsR4KgKakrKR9qAdVJs1rusewbfoovnZNOn1oc8zMlQjm1WZBNUkolYCLr1R4ovkAMAwUi8DdTRcX1zp6M6ZhEIimpNylvq8BMoCT9XvIlqeYhyw4e3kZePW7KJcZvOakfsRghRlquk+6gfDphgFvr84NjwAnZiU585FC+3S7zTZR4SDzeY3ylT69VtMhw1VAGqcPfP01uWnPet9zQn77Yo4/vTaKdRvnemVRAHUYCBsGeIalizIFhMYpJ8zqjVMvM3BuFHALpxu3/sHrotpQWRgojwN0h50P2jAAH2yHUSDOQHSfjKqDglRRbHhc34bbK6ouQVOscxR4j0oflTZ8b8P662HqHh4PURY30QjXa1j7BMsbnub8PTufWlCcyiZw6Uev8kd8eVn7g1UeA15//f0XOc4pGu2zn5W+aaWtrMD3New4wLsbwG/4Ef5G92z+JvthnUtT8DrHkJ7QcL/BABAq2nHwL+iKDdAMscJZwQjJqnpKfzzvupJJnNLgwHW1LlcxkYD0AjEFiAVQaFBgRvV9AmLlJsw60Tv+1TK+mdBSBtOUGtmCBL/HROvVRbrkKs3B35V4+Xm5jC39pPl19PRNdI4k01eE32DOAIl8BinHokzbgK+nnsoTTB21pUu2DgExQMYYAFoAigC2m0CiCTxbIzBUrsiOO9rjgvrrb9eRLGSAfB6DvYY/f1LtbhgKJ7IzxMaGH3Tk/s0G5quynVXEttpFqS9OEDC2D9l/nQ67xHWB1hGS+VRAt9une7dikW2ZyzEfNZFoH/KcAn6NBuAOgEwG796wkM7o+rou3QIWi4DIpGDV6f1EKVdmZVcgk/HzVxO9TtOm72DluSSV5jipXdQxo1engNdfR/baKidN5TlNxe/t+hNAAMheuYQl8w6SxSkUzWP/3MLlGSCThUjJzZrK2bTj8L6Uj2bX5fO30QCufYwrCLkc28qpyw2geb42D/i+cZ+rDsrdHQKrRL6dz80iH4TFAaGHaa0wOAgDimFM3ChQN2654WujWL2z5BcH8MLljJt/sE7h/MZpg6h7GheIRdUjru5R9QyDrXHKUOmDEohR9R0GIoN1GyaWGjffINiPKnNYPaKOh1/jgPawydVZJ1VRbRN138MmovF9eT6fnU8tKAYArL+DQcdCIiddQ+VPuKy9t8ulawDY24XXOYYwCCBU1GHl73SuDHS3dJZBv8bzkrQql8nI7e7oKHRF99gnTff2SCje29bEG6A3Qqk8bVvrhwENlG1iGQzkN71aBQ6axB/zylVXLktAVZojmFBAykgQ9OTzZGWzF8GB/Cx8wUFuSgs+y3NQ/nvp2uGEYHjnLTaMJduwVJIBN2ZlxAfJFH/+89ys1+3qjWOlOc3Qq4AV23dZbn5K+/S1baDdxv1bTcxX6GkCIBBtSPmE0hUrn7x1G+iAcMcBB/wBgHkQGOflOTWxULJdw2AbqkAgijEuly2kWpa/OqAiMAPcdKfAZrMJzOcGQLcHWAYMAzhqccNlwTmCMCWCbtxnH1jSxRxcwLLo97hNNnN+Na2Z13abWmS5uY4bERVjK8iOKkba9fi+08FR3UI2AxybHG9qIlEocEzubtq+qqVSYXbp0hTLyE8RYG5s+LLzchno7TS5MtFu87xhaPdsKu745efoui+jgrOU/ftQHvwuVgB0jpBMAQdbx5irmjAMB8KQ/r5fWQCcEpztOpJWj/epVhAAHV5aOfBuNlnv4EzSNHV6JZEqzxM8m6bUPEeBYuA8Ptg/KIv60XxcLHIYIETlH/5Bf5wWBOdR9Qt/Dr6OAmfB/J1QmjgwHm6XuDyHtYUCmOOAy2F9OKq9h4H2cN8NyzsKVMeVEXU8arKljo8zRqPaIVyXOJA6qqwwCB12r1HXhvMeF0RH5ROu7ygb/zt+/p6dTy8oTiaBWg2JVku7wnrlE1IeMCAwzmWB3BSc5hGSxSkkc0BSRe0yDGRbFrI5LtnfuqXdWC1J92xd6QtXBeHwTKkUkMvsKiKtZel9R5ub9HF83CXIzWQ0yC6VdISyToeaWc/VmwAvrWgvFCrfk50WsrkpAuBOB7jxXTJ7rRbBjmJqXVcC4lkA0yBAOKY2oFAARAmoDYDsBaBwhx4ijlvA1EUAbbaXabIhVPzjXFZ6W3hAmUCpREC8ukoQ+MYbBCZq89jGhvSUcYE30D32tZ6DnTpclyBU7ePa2uKlt27Ru0QGfOivpjS7m7L5BVayiTqACvhVbQF4sQxcrNE7XKHANs2XMxh0LDgOJzDKO8Uzl00c7Dm+2zuA5SvXvM2mBuZsUsorhAHs7hFgJ1PsX8NwkbPu+A4YksuLQOsBikULnQ7TFQpAOmdwgmaa0iPIrgaqSv+tJjSpNNss5JkB7UNsbGgJeD7PiVN2RTrurSwgL6UwJ7fvIluUuqJcVk8OrR5w9UVk13p4bmuLMpLuMdKdTmBj5jIboXZRBkDJEQSvPKNXEJaWgFtvAdVFPFO764doHtze8FdF/v0vOnj5ZeCgAcwtpThhLc8j6W8qzEr3GAa8rbv0PX1ljZOoWo33lEqRNS/PoX9rA4bRRKIyz+vW1vidLxaBH/1RuhR0B9Cq87Cdvwf7h21nBcZxIGsUeAt+DoOpOHAZlW5cJjJowevC78PlRAEOA++vSxTgGgWMg3WMuo8w2HJCx+JAZByID6c1Q5/D5QfzipvchMuIqn/Ygn0XV7dh7R+sw1nGa1SZUdcH+8LE+/t61FgYBnDj6u1GnAvnM+y7EVfeWa57f2nny55eUAzwx9buo7/TQLJS1JueLCsQnKKEpFrGt05wf8/FfMXGQUNLIQAtnQD0K6DZ3lRK44KeDWTkcnvQLdyJRRCmvE4oSWqxSLCr9MJ3t3gsXzAA16WHihS7ck96RHjjDeqVV1bAjWoq6kdlgRvcpP9if8NXZQGnVVMdAF1WpHsMTJWkDlbKTPryFSUAMqhE44B5qptSS/5mUobSTTJiHUAJQSqlo7q5Ay23cF3pNznJ/FqHSDSbSKSSyDdbKBa5sa3VouwEIJR/AOl2zQZWC5RAuADa0Dpixcw0AMj9iXBdvYerswO464xs2Gjo/qV3D35ImNThWhbZYbUHbKGqx0SzSbC7vQ08f4XNqHwcK5/S5TInQUtLQMndhWEQ6Fer9PiQLmZ05YrFgPs6aUo2AJCJzwSkAUoWI8NVf/z6CQa26+9Zy9ZK0s90gulS1M1nCyZOWjayeTkQlVbY6QTKTWpNruuybOW7unaRs7LCNFcmlFzCdbVLkCsv6HOFGaB9iESlhITrYiHVQqulx/39bRvzBbqTg5GgR5TOMVAqwbvxXfZHuQjfK8rOPTlTeot1sftIFqfQbx0D33odicur3OyXSWtvKnu7sh0n8onHZcOYsbCdFUCPU3bcD/YosBx8DQOeOCAdVcYw9i5s49z/MAAZlTacLupcGGA9rKl6KMZ7VH6jzg8DdME0cZOjqLyG2cOeHw8U6npEvY8DukB03dW4c2LORY29uPE8rK6jJibjTSTO57Pz6QXFnieZNIZ37Wy3kL+S0G4I1JKs68Lb2cW9HR0BbH9PA1pFxlmW9G4mWVoFpsIhoxU7DPB939Hv9/coudjZ0SBbOYtQASeUl4VGA7AsF/NrM3Cbh0jkpoDOEZ55eQYHG4f4jT8qN56tlIiydnYJjq2e1u5m0qcrePc7wMUy6J+hD+CEBZVKAGRlEtDspEgDsIAH2/pYsaj1C80m9Z1KYpFKA4ki8871tVeGVovnVXCRZhN+GOfuMQFzuex7xdiRGwrVpqy+Q24bstZTIAjtO2SDAb7aAC6DrPH1MiO5XbsmY1FUWfV2m+k3N9mfjuPHl/CxfrGowSygicmBw1tQm/saDY0D83mCYRVkREV3Vp8VIFYa5WQKlPZkTK397nSAqy8wQSYr21WCZLVLLpUmiG0ckKEH/JWBhHWCot3kMbVr05YbJCXF/d5th/sAMy5Euw187d8BP/obgZWiBuBmUrtXqV3UwvZqVd78gCsS1QXtG7u6QMBekD2lVmcyWTLJW3d43DBQLjf9787ODtBsNvD8NZOu4NyBH2VRVOVGO7vPe28esB1uve1/rympmEcyleQKhWlKv9tZYPVZgnPfIbUaRSFzz9+D/cO0YWBlGHAZB8CMU/YwIBV8HcYaxh2Ly38cRi7qmIv35x8sO1y/YJ2C6cOAKHxdOP04FscSGoG/qHqOKiPufLieo+432GbD+jTq/ahz4fzC9Qkfi6qDkuuF+3tYPYJlx6UPt1/U2Im6fpy+H9Y3wz7HZ3j+np2P+gw6/yYDBwwckDGy+9q1FQDYPR/guq6WOTiO3gBfkrizUuEyvPocxJsKUKVSXE5XmAIggFOSXZX/rVsETe02l+cBgioVzvhYSjbhOEgsX0C/wSAbvfoh5panYFkEaHBdDVBUSF3lgUK57HIGBFC5KRD17gI4Ag73NRocNBmd7Z3vsJ3abaB3BOy/Jv3megS0dl/7Jc5NSd+yjtaa4gSABHLKm4VCnQoRNhoSaUqvH7Uatcy1mr/8r75rV69yIuECkA63yAQ3gUOHm+nU3xdAXvsLa2R6y2XqaXu2noDk81IBUNOOOYpFTlrabfgb1UxT+4RWWmS10U5t1lMeR/J5pUdm+kKB+R00uSlQKUeUCYNMcWLlIjvRNDX43dggqNu6Q2AJEGiqCpRKesOoM+BEqFDg6kB1EdnLF+kFJZPVIbUz9N97Uj/y20DkMvAcl/lt35UxoOU2xeaBHNyC5SwtssGUe79Gw3cDByPBY92uZJjlBs3lZd14gJQs7QP5aV9Xr+TAtk3XhtPllJaIWCfMt1QiC7yxQWnOrbd5P3l67oAhKNGoVjVjnUlrV3GpNDXtcX6K1eT5LH9PoZ0VdBmhP+Dx/Ri5ob9h9RoGPNV1YbbNiLguWHZUeWHJgjoWvm7cNhgGgqOAfVS+o9o+eEyBuzDIi0s/Ks0wAK9ehwHIYFuGJxJxfTTOWIhqt7j8otpunIlRXNmjjg8bI6qcuHOj8o3rj2F1G3XuvD47n16mWFmwI3Z2qNdUP/q1i+jvNbG9Dd+XajqjgW4yRZ3ovR19LJjlygqzUbIJpTEO/uAXi1zmV6F3L18mw9mTOuNKhV4A7jcInlX+CVOyznYPaB4guXYJ3uYdbo6SkcsMAxg0WkhYFvCmQ6lE84D3uLWlqVC1rl8uA3gXgAAOZbSyVJJsmtPXemu1dH7zJm9g+y6BkIoLXCwS8CqhrYreVt8nCCkUCOjUBrF6nSB4c/P/z97fBkmSpOlh2BORkZEfFZWVlZWV9dHVNTU1NT29vbOzc3tzu3t7hwN5IGkQCRE0iSRglCDCSKMZJJMMIiEKAvWDkAw/BAM/BNJkoGAEBYCE2UGCQAEGASYBAnCHw+Gw2Jubm5vt7enpqa2prq7KysrKzsrKj8jIyAj9ePwNj4qJyMyemZ6Znj03667MSA93D3ePiOd9/fHn1bwDf8KIaKLVe3oGeGO8+67GWGJ09Hq8ObugF/gEQB16cvsAvlfhZb55wGPi8a1WaRBVq6RCOA5Daz/taA+uUCQAevMrFa241u9r+TzPo+EiOsASBfE3fsBLlPKCADhvEcyfqVWB4ZD0i5UK4FQt/ZAQ769SsYA/ZX/vvUxDQ4wWO39TzNrOa+BXX2O/DkeAlYOzuay5IbKEEQQRhcT3gXwQwKiu6CArnscyPbVZ08oTDPd6wNffBJ4cab1lkQD0xmp+dvRAeWN+3laWSK/HciXetmkgt93AarGDH73rRw7t9QYw6npA9zEuO8DOHon5J8cBCjawXu5h3GewD8Md0Ujodnnt21vsw25X89XtAkFzT+0R2LkNUobmPCN+J2WmLID2rOd80pTmEZsHSJKgN+33tLzJuuJlxDezZeVNA8Ty2yxgkwToaUAvXn68HbPGJ/k3DegtCnpnAax4nyTzpJ3jJ35LG4+s9iwCNOedm9XOLMC9SP3xcoVrnJWS47qoEZR1D8T7fh7IzvotmWbmeQGfnT+5oFiEiq1cFCwMponw5AnBQBAA7uhj0mimAmJLDrVUz1s62txU/curXhXFiJxSLjBMfaxW0xzihgoEMvH5r1qlEkWjQZC1v0+ALN5m39dSVu+/56Na9WGdfIQ15Ym8avtY2asSEO/e0hvegoBgVdzSvgLK4oUEgKsOQdfm1k3ZtTiS96cEqUFA0FVeAswOwbagTbvAertdBcYsknsb6zzmqyXvfl9tvFObxoYDHc5ve0spUDi0Fg4PsbPTQbFITLdaI3iVYHwXLhfAVwDY4M16BSpNVKvAm2/eDJRnWeRdd7uaJdLpENRubvL3oyMaI0UV3U1EIApF/u44mgEiSQJgHB/relotRbEImFfoHQDwK7/CLuh0gLfeAk6OfKxUgGXznI0SkOlPgGBCHq5IuYlXtNfTlB8xOkQyw8orz+klz3VpSKGlyldhl2VuDoeAbXuMUCig9dd+jUYUwHZsbmgP/+U5OemHh/RgCxekUuGF+VM9h8RC7McsjeFQc84Bzp1iCcXiNTxPGYzlJdj+gAahCcD3cd7kvRYEAGo1FHbVYDgK9NfXeHKvp8pXXuZKJeaGnmgaR1oKoQXGfyd9JmkWCH0e5S0CzM2Uz8ljaeAizeOWbE8W+EsC3PjftPPSrjML8MwCtbOAVtY1zio3mdLqSQOSs0BemjGRloSiIH9n9U9Wepa5mDR2sgBzmpGULCOeP7mSkCzjWds3Lz3r3PpE6QV9dv7kgmLRN7Ws6H0dDl2qjB1TL3atyqxBgEgloF5XMrm+ju2xVufvY1d939GBO2yb+QDFKCgTDElAuKMjjV0+fKQBryy3mybw7rs8XzyjE5+gSjCKRAm+aAGVygA5C8BwCM8DSp1LAMqz1+1q72y7zcrlgk4es7DXv8G/jz4A5doKBFHDIfkCYvmVS/S6iR6aaVJezHEIMER1QvS/6us8r93Wm6YEhYp8lwAm4SQ7yyxLRa8bPXrCvWY2QellW/N5t7eB4EQJXHTZ9x+BegLfU9xhgMIDrquBq2CzvBLAME1g60BtPrRtFIsuvv99RGoihSK9uScnpDhctKmHLNJ4Ep1w7HE+yLjL+eUyx/66T2PKNDmO+/sE4sMhPciFIpQBMybArK9rT3wwZWXlJfJ1Tp8A5R0CvpOTm979xgYNn3pdU4J6V1Qd6fUoOeh66HSUEEUDWHtdheN26VmOXOHvvqs7UojT1aoOvnLnNbbt/o+0yHNjQ3N2hwNEOmzeRM+NahVXhx2suGMaTYrD8fK9Ca/TsoBaDbliATl3DL85wEQ5miVYZHRzFEtsi6hm9AfAmz+l1TpqNU38l0glQcC5m5rCF9Lb8UWmNAAkaVHP0yd5scc9tIsAqmRZs4BvEggl/wKz68wCIUHi9yRgetZyk8BKPs86N8tTmOwTK/ZbVkqCv6RHPAv0p11Hsk/S2plsW5ZBk5aSIDrrutLmRDx//LxkH0leP+U3+RxAA/sswyM5hllgPG1Ms+6nWf2Z9T1tnmanF/PZ+ZMLioHIW+T7GijVavo9jFYLzSbf3SKlBmiQLE65x8c8Hp0Hcn5lab5cJv44OdHcY4AKEeI8m/hAswvUHR2boNkEtrZvht+VOixbX4aIY+zuUsKrEARAYwOl6lgDmtoavYPumGBLPGNCeN3f12K/pknQ2r5QXruC/s1ZItAoluhhFC+zq5bFbVvLs/UHXJZunin9tLwOzyueSvFAOw6m7/4QueoyAbd4Rk+fAN0ups32DQ1ikcV1HCWfXNfGAQCcNEmlOIgNdblM7/Jlm32atwlAJz4B7tERZdei0Ngnj1Eql7F90gGgx1aAWLdLbrJ4K2WvYa9HSoznAV6gaR3qynHYoSd7J+DqQalIkFzuKYrObkMbERI+OZgCphp0UaEwTQJNXwWxCELmHY4YtOLb31bW17Iio4+0dx9g/xdL+OHbHl7ZB145UKsc7Qslb+JoF7iaUzQm88r7rLjLpsHxPzriXCqXuJJQX4vq4Ia7SwLyndt6UJTIdk6eRJ2n2r0eX6ZpngF2AR/dH6DTYb9tNLhSkzOBrWKX1y8TQwZsc0MLK9fXCcKF8O/7WqXDyqtRSknhi/dg/7xTEijKsfjfZwG7nwTUJv8+i6crDUSkgZOsY1kgBSm/ZbUvWU4SOC8CjpMALkj5nAXs0+pPa1/yuuN/k23MAllpIC4NZALZ2sqfBNTNA9hJYyBrzmbNs6y5Pm8uPut9MauMZN1Z98Yi92XWfbBwegGfnT/ZoBgAfJ/eYaVFe3qqVdlC9T4W6oPkOzqid1gCPmwqbS8BuACws28DnhepRTgOy67V9IY519U0gIkHNCpa0QzgOz1nEux1OsDRMdUVpiCoevN1XffurjLK6nUCg+1bDEwgGrKSyR0TJDTWWbDwfIVrfPKY5/YVqrMUj7VY0BrCvSvFSb7NXYDehKClWFL15VS5yv0qYY5bFyzLcZQ2bEBgrcIUdzqA410DuEbpjQNunAqmCFvtaAObBM0YDtlveUtL09brxHvDISf2PkifuHtXg2IZUwmiN/FpuPR6wMuvL2HcGXAbYO8Kws/d2uZ5ok/s+3Sa7+5yLpgmPcMAPceDvpo3AXWRe6Bk3BWAocu2PQQw6QDrtg4Q0u2S4oHNLRX8xGG/Osua0ysW1eEh8N3vAKVlYLkBoACsjoDzY5539zUNEvt9AljZvNhuA8MRpn0X3a6LZQXkBStPuj4mrTZWt/safAPKGlQSetUqAbuA8eEAmjfsaTe8WCvtNj3PQagoGWuRF+HqYYtMnmAKVOuRPl6/w465bPvwfaDR8CPDcKOhRS8uWuRmb9XznGvinaiusq5aTW/Ou/US8OFDfZPdv6+VTtJS+GJ6Oz7P9GkBaTKlgb8s8JF2XlqaBaiSn2cBsDigSAOws8BWEnSlgcB5wDjtWpLtSrYhDbBL2VnnZAHgtHJmXXey/rTrT5aV1e748TQDLOktzmpP/HO8D+JlzKozq82LGHJZeWadkxz/rLbNmiuzjLlnuV+f6Un4gj47f3JBcRje+BptglceWgkMJl5i2ZMkkmq9Q64kx4GwrOBu7RcRDhn8oVAERl2+uCWYV1yb+M03tYMtvlHPNAnEZekdAKzYXVmvflzuDQArkE1uohMcBIhC4tp5evb8KUFSp0NQK5umqlUCXsfREeWsPD22ssmufUnkeXgI9K+pk+wsxXSGpzo0n1qiF23bsHcNwwRgWZgM2XH5IACGgwi/2zYiou51h3mE+dHrEYAWhDIR6H/SZ/2+FhrYrUQiBVHwk/WGHveCDQQWUNgheCts1/hDZUUpkUzg1GxMh160B7Df1zJ5e3s0dsae3rD30q7uWscDekOg6ugxP+zcnIr1OkH3/j4YRnpzQ3nwp6QkSDCOnVvAxisAxsBLr4AM6j0APwRQAQZPFGL/QNMcfCV9VyzQehBNXmcJnaMB1hts08pelfUpisV128Oo46K0v4pow5/vc/yrVQL1oVoxGKpNk86y3vxXq3HO7O7qyIcAO06440GIqy4Pmya4mtHtRtrVYaCZDjK1ZUUkX19BXtFwnAZUeaqdrQt9rRI23DR5XyDQ0QOLJUTSbbPSC/hg/7KkLJCzKHCZBR5mebg+bVoEJMQBRxKozQPwaaA7rc44H3URsBXPlwXgsupKJiuRNw2wx4/PMjTSxnER4yP5W1YfJEFuvB45LnQJM/YvTu8AbtIc4mXH65bzZhlCSDmeNDKSx9OMwFnzfR6wXsTASBunedf1TOkFfHb+BINiRAMm0c9cl+DGMAmEhS4JaOAroFg8tEJ1kKX1Wg24OHajzV/5RA9HcUBcDbw3N4F/+v2bYgDxVKvdlHDbqun2CL/5vKVC85aX9Dq+s0wAW63qzVm+Tw9a96lSIJgyFO/JCeD49JBWVlihqFOIlNtwxGXxfh/h0MXhoQvTJFVkpTJAuTzA2nBIoFGtKm/zJOKPvPduQHUFBwD86BqKLsNoP+0At3e5gRHH7UjB4fT0pvEx8YCf/haPXbTpTZc+Gyj6ahAQNEvANWGRCH8Yto3Q9Wi4HNzGjY2EongxHACvfwPhr/yjKCzycKi1i2WMNzf5fRrwWK1GoHvZId/45ERzyG2b418Fhem2t+nxfustBs6g+klHhZ3bYH93u/T8VleBaQ/IbQEYA1gDH8+vApgCS18D/PdIc8jv8lryQwA9ckZsm5Ou2wWa5zBN4KoLrNRMTXguVoBOB+UykKssKc6v2pwn1Ad3zHmzvU2rsbbKNp8+YSf1+5qT9PADdr7wzFvnBKcnj3HZCm5EAlwVuo4a7DggFqaFyOjxRsnRAIunkxNevzdmW4sF/l1ZA3t9GbhHI4zgWeWx8qD/PpFiz4nPKhmGcRvAXwYZNSGAPx+G4Z/9TCv5HFMWWFnkRZx2zqzfky/secB4EeC8aJ3xz2keuCTwTJ4fJPJktSEJDIOU/GntmwfE4/kXzTPveLLN8fZayG77LEAdT/NAp4DdtLYFiXxpfZwFgONlJMc6a5yRkm9RQ2GR+2fR+ZBV3ryU1j9pIH7h8p/Ds/PzSD/BoDiI3JJCXwToORTw9d57dIYKhcIL9DL5ekN7lOMb49Z2l9RLfRIBnJ3iADu7Jn78iLJXApCkzmYTeGWfK7mKYhmpSwi2WG/wfb9ev0nTkbb7aqNfoX2FvJXT8ld2XkliGbrQ7lPg8McYt65Q2KwSOIv6g13QSLLbpVdNPM+nT4BKBdPOVeSNPTxk9qcd5ZwU3oAAo1gQhUFft11UHGxbh7kuFvUmtCXFDT49JQiSvXj9PukQopJw3kQUfe7oSNNRPS+m8qUA1foeN9BN3AB5GzCqK4xWKAi6eUaDoFhS4sT0bhqbDSx3OvB9H0dH7BqR2JP4I74vqg2sbxoAW5s3jSKhcPzCLwD4FWCojokXvFSzlMdVGTZBqMNlmyYBYG4Z3D64A8LqWwAeA3AAHOkGrS+BYUwKeq6bBikprQvAzkd2wFUngG17KKloeVedIFpkgJVj53Y6SuN6RUfSEz6JeI5Pn5BHXi7xr1JwQWvMThPjqnWO9+8HsCzeY2t1GjavxsMHBkG0Vw9gE85bnBc7O6pdgQlUatpisvMcgCDgjsrhiPehnQfx5y32iWECS1fAy1VgZ6QHIQ0UP5/NIj6APxaG4duGYSwD+A3DMP5uGIb3P+uKPo/0LIB4VsryWs3K91mBgzTPXFoZaYAk+T0JotPKSB6bd02zwGEW5zatvrQXvlzTPMMg61iaRzP5OVnHrP7Oqg/QG9IkxctNtiENwM8zqNL6IXkNs/IvapykAfa0PGlgdB4ol7So8ZNlxMW/zzNk09Pv0CderORNCAAdB3m7FalFiLPwrAn89R8AXytr6SyAS+Tb2wQ7whAACL5W6ya5usqt23/wGE6DIHnqBdGSu2zssiwCYnn57+9rmVfLUpjD0hLAb7wBPD7R2DYeGKTdTvCKJYOVJzjv9Qj2Ai/i+RbKppbIUME1fvPXPdRq17DtNhkUZSB3eAhUq7hoBih2u5FnD9AcX9lgtirivb6vJeF8yl7t7tJ76vsK+DraCBHt4ZWqKqdu4qNDViLL6L0eldlEg7nfV/xhS3lv+zomhOtqyeSNTeWd3twAmufINyo6uESxpL2Ntk3EZduaFwtELuFyvx3FGhHKrwDg1VoUOI6O+YqWXAYYnns01O3e3yeI/9Eh8J03WV2/7cJxXHruhaoSBASA/QE9oNdtYPklAB0wFIm86i6A8RU9sZUVkHnuAbhWDSloPnK/D3hjrAYhjYS+h7EHnD+6hmmyXbUa8ModBRi9saLSLPPCfF9zxvsDhlQG1GScACeXgF3AuOfB7LeRry0jbLZwcgL0+4PIwfzb7+n76t490FjZXQOCKcJmK7q/goDze2tT05ODoIuNu1Wg28Wkc42xBzj1Im9OK694y4UolDtKAYBD0H3hAqjwszcGlpaBtVvpz4nnICsUhuEZGCEHYRheG4bxIxCxv5CgOAtcPGsZ8XIWPX/WyzqZb5EyFy1P0iyw+6zXswi4nHVenB6wCHjLAoBJwJbmaU1LcTCRdh1xQDcPsKb1VzzPrPYj47es9ge4WV5WH2aBw7Q5kNauWQZS8nPy2Kxz5hmOaWUm2zKv72cB8cy6fkeS7cVKvhfg7O/9EL4PfHRMMDMa0hP8y49ojRoAfnMIfLMIXLl6NUCoi/LCfuWOSSDabkc6bVPXR8EG4I5w1Qng+wTaU5+ezn5fy3cZpqZOiOdUgjkUbK1cJXQMic9w0WbkO/GGCuAq9AdA/5wgUPgYdl5FDxkBnQ7CTlcBDBeVCukezSY90mEAbN1dUbsDn2DiAf5pF/U6YFSWcdW7jrC18GpfOSBv+ul7T2gcVKvIOSoIR6+HSd+jQeABRy02aX+fYyEyawL2V2sAnGVsb1+h0wH+2Q8UpQI6AF7e1pvmul2O23feApYVRWFrm9Jp9Tr7zFaUCezcIhCu1bQsiGURTQsIFh1ly+JmxV4PcEkV+d73gPcf8ppzJlAqa5y4XGHbS0V+LxZJrXjlgOPeaOgpItcsgT6GQwXcIw3ivNYhtvK8UAl7ZxeAwhIYHfCHakYrQFpRcf2etlVHqnNPz9iAnduUVjs+BjwP1z3d7/fva5U8ytMFsKxrbG4CY8+DI3Irdl6rWgxHaiUixxUIFdhj3LrCRZuXUrCvI3q5ePuPj4Gv3dX3UeQVdkdAt3sjDgnAuSLqI42GwvdK6i2/u4V8ZVndQAV6iYsF4OBVIP8NcJvjB+DjewPEniYwHhIQ84mQ8aR4vt4OwzD2APwUgH/63Cp5jumzAMOzzk0DJs9ax6xy07x8s8BfFgBK86xlAcPkuZI3zh+eVV+y3fHv8b9xsJdWRlY7ssBf/HgaeE6WmaxbvLxpoCPZ/rTjs8Z93tilzaPkHZ81F9IMinieZFmzxj1+PA3czjKiku14FoMwXuYsUJv8/OkM3t/xFL9Q6foa+P/9fQKr01OC3gmAAehj89XfKYAfuGRtBgAe94Cf+bbWE67VwP/abYR+AKOYA3yXALZoYjwMsFIFPnhIgGspEFQu6435OZOMA9mAJ+oI3S69Y+I1rtWA0yYnaqOhzlObAQ8ONICIqAvDEcGBP9G765Vb1ti5jeXjYyw3xsD+K8Dhh7h9d1tzEJxloNuNIusBaiXfu2ZIbDCbYMmzU17XYAicnAT4xptdhgkeujCcJeTvHWDNexQ5YSXadM7SOr/Ccc1ZQNi9QrdL4L9S0RrQpqn1fE9O1L7CTYLmalWXLTh3rQ44FVMFI3G159M0FDF4Wcdzls1gtg28/TbGR2eMkFa0cd4kyG21CHoHfZ6+5JA6cnDAogtlk5q63S7KHiOyTQNGqet3fQQBaQAFWwNBoY8QGF8hD2gPtpChAT2O/gSwxkDuCahD0gOmHr3L5XJkiOCiRY+4q+ZBpaL5QKYJOMsoetfwffZfpcLhd132ab8PvLwP5KtLyAdTTljLiknABUqCpaJUMhyqmJg59oXNsR2YrNayWO55i4ahAPDNTdbpeUDvYfeG0Sn3maGe1vfu8bhRq+qxArgaEgS8MQ4PuaximiCFpAXGOLwC0AawDeAcKCwDMIHJtSKaZ6Rnf7DXDcP4Qez7nw/D8M8nMxmG4QD4fwL4X4dh2HvWSr7INM/DFT8ef7E+6wsny2O3SP2LpDjQWARwxwFGHDSIlzZZThaQzTIG4u2ZBdzT2pt2blr7k2A1q2z5+0kMh1lgPvlbnBOcBNtpgDTepiAlP5DdtmSbZvXDPIMira/T+nBee7LasggwTsufZRTM65Nkfy9y781NvwOKX6yUMwFPvXTzLgFwCP411d+JOvZDkAP6DQD/9NeB73yXZXgesFrvIPQDFW3LRBjwHTv1uJHoohXhZpgmsFK3EHo+wZKjo+BJRLFOh3+LRQK/bhdoegS/EwDblpYNbjTotZS9WaQDX8GoLBNR9MaKVxGqgpWesD+hjqw34fE3f4qVyS4xVeDw+DoCL+Kp++F96vPeucM+kJDLxSL7tFoDrrsBlhtFNqpSAewCnP0GnP4AjcYAuR0Gppg0O3DuruD65ArLjSJGHReuCxj7DQStVgTANzYlOImWZhP+7lB5+JfKbIN4r4tFwNmpqmX+vu6oalVtFpto/eZej1QAb0zObWUZ3e4ZNr51C/DG2NjuALaNlbqPfteHUy+iMXTx8CEvseSYBLLSwCBAcdgBwJts1PMx8Uh/Watp2od4mQ8Pydzo94HVypj0BMehBF6xFJMsyfFvrgJMusqLrcB8K6YvXCxxgvhTrcAQU4GY9l14novhUGtzi/depAODAAwJDbCxvSvNGZElk3KZ80YMMDOHi6NBxLmeBsCv/iqBb7tN46Fe51CI4RKtcDgWTh/42NzkMG1s6tWAXKOO1YYybjodzl2ZeP0++cz1OqkcOzsc02oVWH8Eeofjr7oxCJZHwHTAcvrn6Q+JEJ9Ea7MdhuFbszIYhpEHAfFfCcPwrz9rBS9SygINz3puPKWBp2c5P15OPG/yuxX7nHVeEhDL36QnMgngslIS+CXLnQUc4wB9Vv8kgbuV+C1ZVxrQi7c3+TlZZlpK9nfW9UretLkTb1+yH7L6OAvwmsju92dp/6KgNG1c0r7HDa95bZpVV5aRkfwcrzMtLWyUfrJn5xeefqJB8TTQG9kAAk5JAQiK8yAzE+BkyIEva4Cb3up1AI0NGMMhcspzZgwHCH0C4laL4Ew8Xtd9YDKkx3CsPMY5S4NiXy2zn57qPUM7O8BHXWBVzeZIPxnMJ9zZdpvgwzABBAGmJ2fI1at0/7UvCfg8T6/bVyrkEu/vI+LVSjAPRYpdrZvRxqvDQ4KlZYeAeG3bxsUJe2fs6ShuwyE33T09dVEuuyjsmgRvALC9hdxeIZJq832gd3iFahWUAHNMDIcBTt5uYUntGZPob75PULmkWA8ydm8fAXcbiDbUrdXZhkoFiAJaBF1tSXS7wI6SFLNtAq3jjzQgtnJAq4WNbZPgNAgw6gcoVXxcd3waHrUADx+yv995B9jcDFCyp/TM+lPAsqKVAtEAPjkBbm1r+V7Zu2bb9Ii7rgLFnkeAXquRI1ssAMurwERN1PwmAAfwL5SBMyVgPX3Ca1ASd9GmOPndWWa0OQA524TpBzeGu14HrtQw+T6pNB++c41X3lhSVA7ldVa60qgs69DSdj5S7HAcbbRc94Cf/R67/N49XnOjQW75Wk2rdhRs4LLp45vfMrVBZeVh+BPkTKUjbOc50SVkoRDZq1Wi7XablAnbJtpe3QA9xMvqzp2ov2P1F0AuB5y+n61T/BySYRgGgL8A4EdhGP5nn1vFn2P6JK/ChV+2Kb9lvegXAcxpYCYOENLOT4KxtPOTwDML2CbrTAPZyc/JeuIpiwgk+eP1plE2kinLcMgaryxQlQbS54HFtDLT+j4NEKddV7I/F51vQDbdIllPGkhf1BBMtknOS/LFswydrDKz8mR9TzNK0tr54kHe+eknGhQL/SCeLOjXpyQDehLsVAkKJ15MQziY8oXtjiOPnmEB/V4QRVgTb1gQEKNubeuIs5YFhEXNK65WNd210eAO/ZeqBMcnJ0C7yzLrVdJGz2PSVd2uyMUNcPvuEs4fdLGx2cVoCJTq6sVfqSgwE2q1BdkhJrGOfR9wljFpdiJpWdMk7hDnb+h69OJZBOqW4u6KXN3q3gqmnSuMj1tUuajVeGKkjGGj3/IiIYNqlcoHa3XgN37ArJubQO8hge5IeVeLRS18EAQExMctzTUdDcm2BYCVnYD1CWWg19PRUDxFR5DIcM1zVUFJ0xbKS4BloaQ2qy1XgeVuF2hsoFx+jG6XgeOKRQCm8uL2u9RY7gbRZkDX1Qp3ola3vU0genxMSsbmJn8bDwMU9rfY5tY5ecBXHb0UtXrN2eiOlS6wod34wxEHqazCGtfrij5RYoVvvhlZXIXGhgqzPQAsC7edJ7ht5/G6BLyw8uQJS8hob6L7bvuW9hbv7vK4mjt+7wrlMqnLjkOD5huvc96LTN6ywz6REOgAQfhFk9fonbhY24G+eUyD9dRq7BMrz+M7twn4W2oCiDe9fw2s1gGovoIH4FTufABqo+XgnOOWucz3XHhxPwfgDwH4bcMw3lHH/qMwDP/2Z13Rlykt4uFKOyfLozfLk5UscxaIWKTerHqy8mUBt2T70tqT1rYsQCx/4/UJ0M0C7GntTAOVs+rL+i1eZhpITfZJGgBJA1tpYC2rvfOuI9nmWYZP/HMWRSarnVmAOwukxsv2E3mS17LIGKS1bdacXmTMFwX3TM+PU2wYRg7ADwA8CcPw9xmG8TKAXwJ1Sn8DwB8Kw9AzDKMAyl/+NIBLAH8gDMOjWWX/RINiABGXNQC9/ZLks6k+BwDeBAGg5/EdLFTUVRWBK/QDGGoSTNwAORMY+7qe1Rrw5ITAcexqBQqAZVarOrqd7GkSrCqr55ubOkqtAOhb28RBArL7fdYx7Q2iiF/FIhitzbHQP2zBqSrXdK2m5QasnArnN1Juahf5+grQv0agJLKEwyxeTlJGdHs2N/l34gN29wq56jJyQtmQCBp7e3Q7d7tY3ybXFiDlZKVRxcXDbiSnK17nd97Rer/CPw0CXlexCNzZZaAUkccThQpR1Ri3r1GoT4D+NaXryqYmhTsOwV+xRBA5HLCNP/jBzXDY7kih2VuResVane0p7W8xPLJpYtLsyD42TAOOT7PJIiRi4WqD1y2GVb3OPvN9YLlqEtwC3CBXqxGQFgs6jjV8YHUX8A+Bww8JDr0JASOUkVMukeu7vw/0rplPZPLKZUSSad6E3vLeNftBVCa8iSa37+1pb3+lQtk4b6I1AZWxc3V8hV6PqxXi1JVThcUx9mJRlr3Y9XsqZPN+EdO+qwXAgwDYfYl9sl9VOsSelvbYfQn45s8AH/xQBY8JaPBdPwWW9xApdYxUsBGjAJq9BWBpA/CPdFlp6TN+sIdh+Kugrf2VTlkv4XlgJZl30fMXASpZ56QBj1mgMstbl5XiQC0L4Mzqk/g1+IljyfYm250G+uJAdRHgOKtNyfplQ928c+L50wBqclyyQGFW+7OAdfxz3FOeVm+SipJW3zwDZt5cTxuj5HxMA/pp98GzgdZswy5+7c8yzz+Wnh+n+I8C+BEoIwQAfxrAfx6G4S8ZhvFfAfh3Afw59fdpGIYHhmH8QZXvD8wq+Fn78JmSYRi3DcP4B4Zh3DcM44eGYfxRdfzPGIbxwDCMdw3D+O8Nw6jGzvkzhmH8wDCM362+v2QYxtuGYbyjyvgjsbw/bRjGbxuG8cgwjP9CLUvCMIy/aBjGP7dIG03zpuSaD/qRxDs8BifE19X3nOoxoToAiJCtYRKIwrKQd+woghlAzHBOYQrU64jEBHo9Ou7E8/n4mABKvMYTRadYrbGMifI01usEGWs1fhfgsb9PHLOhgHOhWkRRgcVCtQhUq3C2V9R6+ZoK4KECVfhTRKF7a2usYGcHsCys7S3jlXs2bu3oKG6uqxVXgoAqC/JZ+mnavUZEWfB9FVUM9GRubwOVCpydKpydKp52gIuHXViW9kYvOYhkhEVyThQ75LoBjdcmvgafjtoEBzsP2wbOHl5jNFTjXanwGr2xEkG+4mCdPiEobF3oSdHva+S2u0tQeXSEIOCy/2rDYgPKS0B/gPcf8utlB3hV9cntXeJQwwTyOw2gWkWpqGJjVNnVBaU8AmdZB7ooFoAH7wP3f0jqw6MPCf4uDoHRuZatEOqEEMv715ou0rvWWn/CMd7cIoDcvsXAIIeHiqSd4/WZJuUFiyVG1bMsglFAW1/v/TbbJRHtTCNSmJDh3tvTKyQyTjlTh1WXe0PuxXIZQLFIKT+5yQRNV1fYBvHimwb/9a8BTIFXv8ENd0LvsCwQEOcAFIHSut6xh1UAZTAiIKLQ0h9LEqr0Wf59BulFeHbOSrMA5bOUEf8b79mkByv5OVnGs9STBE+zwPQiINxM/Es7b147kwApDaQnQdU8kJ3Wr0gcTwOMkid5LA1AxfOn1ZfM70NfS3IDXvzzLKCWBNbxf36ijjQDIllWPKXNjax2zBqDeBvSzk8DvM9qgMU/ZxlAs+7RefNp7r31nJ6dhmHsAPhXAPzX6rsB4BcB/DWV5S8B+NfU59+vvkP9/nvkWZeVnren2EeKSD2AvwvgT4Rh6BuG8acB/AkAf9wwjLvqvF8A8BcB/DKo5/mzYRiO1W7t9wzD+JthGJ6ClsC/B8oZ/W0AvxfA31mkYYahAV3eIlD67l0CSS/mybrq0dMXBMCHJzznvMVzWkparNH2sFwnAdgMfHJjlUNP9gG128Qve3v0lF33eL6AYdtmXVNfMwwEdG00mOf0lG2p1/luDwOe47p6f5x4SQGg1FjGqEVPaaFiY9x1Uaiucul59zZPqlYZKU20bO++Rrds+4L5lOyVLLEfHanNdFW274OHur0fPKT6xLKjJeSqVWD9bkUvfZ8+4Q+dS4WClgBvjLDZguNQseOyFWDtTg2rwyHCoYsnatVbWB3S7087erPd7q72NCpZ5YhrbR52IvBZKqvOVrQIeBNdeLGg43AD6ncFNBsNvaFNnbvde4T8Zo0Xu7kBFEvof/+HWK8DG6/XEbbaMCwTBcfUXs+iCmzhjm5ENhTPu2kC/dMr5C2gcHePXvw7d0gRePhQc6DFYxxMCQSLJQLG1jlBoe9rnm2/TwB8cqLC6hXU3WmTMtK74u8iht065/HGBoFxt6sGs6gHW4wEu0AKjuKF3P7nTNzudvHR2x2EgVqAsIBHj24ahLd32YTVmt6LsVxXg9loKM77MudgrUbt5mKJkfp2usBP/SIwUZqGhSXwUeYAhQAoNADzmOeGHcDIA+EFeSrVKudyWYUlN2yt9xbRKxLpi9lB/aV9dqalLMCT9lnyLQIE5W8yfxJ4zQOAaS//Zx3VLLAh5YiHdBZYi587D9BL3iT4Sisn7XMy7zwQn2yHiY97pZPgaN44JNue7MP4OeK1zeJUx+ub9Xu8zvh1p41ZVlvSwH3S2El6w+Ne5fg1pKU0Ayx+ftYYZp07r1w5FoB6RbPmQVr9WflnGQU8+bk8O//PAP634GYRgJSJbhiGMiQnoO47oKNbQT0zr1T+DC/IcwbFWSL1YRj+f2PZfh3Av64+58A+DqGWF8Mw9GJ5C1DjZRjGFoBKGIa/rr7/ZdA6+Dug9lL8vJS26Q1rQQB899saiAYBwW98PIMAeHVXe3BlU5dspms2PWxtE5S123ofm+tqMFCtgpu3ggDvvUcqhjAKXt5nJF6RaxMnmQT4KBQ1xUIiqQEEoNUqN2q9dkd75fIWEPauUdokrxf1dRTMS2YQl+twREDTuyL4s9SGps0tgle5cBV8xB96EeVDrv2NN7RDUqTQXFdTPtY3TQ2kLIvL/L6vN/R5E25OrK8j740BAGs7kwi8GI8eYaUCXFdoFASBxjDlMsdJFAwePdL9krN030tUvK1dSwVsWdLqDkLqHg6Ak4kKZz1ARAK/85oayBH7p6m8t40N5E9OELk3VUhrZ7cGp1gCigUYxRJw8pgNqqygf3qFMLjG8uYSpl4gkta46nEVYX+fuLdYVMoeD45QqC8rKYiQNIH6GutqNNgeu8Br2d9Xmykn3DS4+xKpE6KoYalob+/8Fj2utTVed7vN661Wo/DL0cRvnsU21a2wDZbFc4cDGlOex/oAjnGvh37Xjzjo1319T4lknmkCKC8h7A8invhqQ+g8a/wrxkpjnXNGGU/ARHuO8zUAfT4SwhFglBA9wldq3JhoOEDYJzC2ctoKtfLqzu6wruTmguhBgS8EFH+Zn53JlAbyFk1ZQDELXCXrWejFHMubBm7iv806LwkWZoGrRVIWqI3/ngUiZ/WTpHieWZQLyZvW7jRAlmxjGrgXYJiWbxZIngVKk+1NHp8F9NL6Us5P9lmaAQKk92EShCfbm9aetPGeN2eS58XPyQLJWaB5kboWSXPn+Sd7ds6UszQM4/cBaIVh+BufxYpWWvrcOMUzROr/HQB/FQDCMPyhYRhlAL8K4D+MnXsbwP8bwAGA/zAMw1PDMN4CLQJJkXUQhuEfndce8exLQAahKApXNWdSfaJgk+sqYHhrm7xg01QxC0ytGHHZ1h5bzyNGOFEtrNUIXG2boZ6fdrSMWuT0C5hP2iGUVwF3r79OQGyaBMqVCqJIfLd3dNCFapVYzzCBpe4VZeA6l/Rg75SBRx+QFuFNiC4lBO/urvqugHHrnA3wfeQqU+T6A2wGA5yess2OQ+fba2/Y+NE7DM6xs8O2R2GshT/S79PzKLxlCa0rm6jqdS6D777EC+lfA+4YYaDxyvY2PdEXykFYLgMv7RLXFZX6W7Opg/SZJikMt3d47McPfezs+Mj7E4z7PpqPunip0eB1KuUEuCoUcfuCgNMb699lwCwLOD1EOHRhVCpAu42xy8M52wQaBaXUwM2EKJYAK4epz69njwYol7VH3zRViGxEbBX4PlCoKU3i5jnHZGeHyN+ylCdXeYidJbrHKysEsk0lqryzo8m8dp7nVFc0SrVy9MYOBwS8QlVoKoPBHWtaiGmoKCMjwDvT3Ot2G5OHRzeG2bJ0oJJqlffFwcHNVZFpbxAxFioVaHkW4SoDN8Nt2+uKJtFTd7A83itA2AWMChjq2kSED/PqgWxUgWmHBoKzROMBYN9WR0p5JL619saT4guPyvRle3ZmpWcBhEC6hzMOQNPyI+O3ee2ZBSaSZc4qPwmasupKA3FpeWaB/7SUBXSS9Wa1L15/2nUk+yGr/fHv8wBrWllp9WWlRYyBrGPzQHM8T/Jastq8SDuzUrLMWeXOMuJm9UNWvcly0+p61jT7nE/07JwnZ/lzAP5VwzD+ZQBFkFP8ZwFUDcOwlLd4B4Dy6uEJgNsATgzDsACsgBvuMtPnAoqzROoNw/jfgwbYX5FjYRj+r5Lnh2H4GMAbhmFsA/h/GYbx15J5njUJKPaUT8T3bzqLpgGdb66rl3zl929/m6Dzg0cEvaenmh3QVB4/39fMg3odeHLKIBRSVxAA3/qWLnfsEnxLtDPT5HfRNpZzdne5oi5ybRIh7eBAA3JRgahUAENAULGA4tBF2O7AcJbImW1fsjIBv6I/271S0hcbBNDuGJP2FQAeLigw1+0qRYxDD/0+qQl5OwaIAQLL01Mi2mCqgKJavhcPslNhYcWSjpZm5YBuF0ZlGZXgGpWKDvVcrZLhUbd4veWy3mAowHjJId96osbXsti24RBY2a6g4LUJSlstpaQw1Vq7tq2VOJpNekS7T1mRNwaGtEr6fWDZ9zH1Sb8JAsAfBlh+Y4MgyzR1UInWOWybRQ6HmoEQVyWRCNnSfz9+bwAAePlNdcvc/5GyBpQh8fAD0jbaJj2fD95nwJWui8LDhxxHd6R3YfoxYO8sqSAcOV7/cKA3XVYqHHe7oNy6Ay3t5o44lsMRywsYrVHGRea3GHU5E3hpD/jxoQ76KHLRQQBs7dnKi63k1spLDExi5rS8XaBu1vIScHnGStYaiB5fRglUkygA6AJhT1EmAsAYMk/O1tFypJHta15jEPL6Ux8U+CTejs8sfRmfnYukNFCR9lJfBLRklZ8sK5nmlfesACvtvDQQlAYYk+1J5skCw7OA6SJpFlCU3xctL0A6LSAN2M/KM8voSaNOzLrurDk27xp9pI9b2t9ZadacTv6ezBf/nnV9swwXM5FvVnpWQ2temgf+ATyXZ2cYhn8CpIxBeYr/N2EY/k8Mw/h/gKtmvwTg3wbwN9Qpf1N9/yfq978fhmGIGem5g+IskXrDMP4wgN8H4PfMa6Qk5eV4D8DvAvCPQYtAUtw6SGuHAa61AgCWTL64f9cvcOnadYGRkoG1LODWjg7Nu73N42MPUTCJN97gOY+Vv0XUBt54Q8uoGibB9dtvE7S2XIaUnvo6ynDc4yx8YoC4RZaaJQyuOFb39ymMsFYnGBHFBWEkSChco1zUSMVxYJSXWKhlYXr0GLmyrbXfHIcbsmxbLVODAMn3MWpeoVRjYI2JT6AjG9uCgGD/R/e1WkbOZMjjiQeUhgN6nbtdYO9loqKH7/NYfY3Ax1NSdk5MK1Zp/cKfILdZx+S0jdNTtY+sSdqIqFOI0dBuK2ooKMt2CSp8PHyoaKo9nvf0IQFxvw+YD7tY96f0usoywdGPNYLbvkVKQXmJ3mMl4XbdcqlmNuyg0WCQi3Gb0eHQugC2t+i1VR7o8TDAyQkNB89Te/u6yjkau5ZOR1W7TWfv8THw8j16q6dDD7nKEvnYvk8j4ugo8kSjWAJMExMfsLwAOVERAQj6BXnv7ytUrrR6RR2kda5XC+rrnDt2nqARUB7lgB0n+sSt8wjgS9/LeEx8oFThI6ZW86N7yzDZDzkTOrShTPRigYD/4IBecU8ZUf2+rqC8BOChXnHI28DT94HVHQBDjtftb6hNdSYAF7g81lwl02DHmiZpQr4P+FP8+Mc/hmEYcXTs/PS96hcmQP9lfXbOS2merXkv0KyXbBrQ+SQv8Xg70kBIGrDKqmfWbEjzOs7Lm/VdZm+8TX7i+LyUBs6lrkUNi3gb4mAy3pZZ5aYZSGl548eSZKZZQDXN2EjWnZZmjX/WfPwswWV8XBZ9wqQZIGl55s2trN9mjYl8Tmvzl+DZ+ccB/JJhGH8KwG+COvBQf/9bwzAegbuu/+C8gp4rKM4SqTcM4/eCROnfHYbhcE4ZOwAuwzAcGYaxCuDnQemNM8MweoZhfBdcVvyfAfgvs8pRL48Ide3ZRhgEuLE8D/A9v7PDF7pstpPjYYCIS9xqMR9AR6inPIWtlt4It14nZqnXNVB42iEOlYjDEoNAKBQS3ED4xN2u1kNWTIYIJI8ViC8Wo1gbVMtyCPCdckDPnplTm6LykcJArtcjkLIs4O7XuPxeXlJL7QWCHtME3DGjtbkuSlUbS66HwVB72Ce+pogIl9k0+bdgQ0VYWyLYeviQns0gIHDZ3yfgOnnM+qQQ8dS6I4Kzw0N0OvRQCyValC/EQynj1O0B5SJB19mpDiFcVPbB4xOGzm619KbEUesaaF2jtNdAeHwG481vaguk02H7hwMdWe60Qwqx8oa2WsDS8BpOvYiHD12sbl4w/3CIx4+8SDauWNTKDAXlNY6vIojnX6jOm5u8VtG+y+1WteVhWRFf+PqwDcsCSlUbVy0PnQ7w8utLGDe78DxguaZucwGdvZ721ssGu94VDQCJemjnmRfQgLq8xD7wxuzMTgcolrCxPcDJcYD1umZrBAFgDxERzVfKNHyuHw4QBppaURKX8eYW+9kmXxvOMttjWcpw44ZRtNuA3dO89+1bwNoG2ytBOTa3+Dkc4YbMS7vNAet2aXR120p9ZQq899t4+eWfwuXl5Y0oHm99ffUL8RR/mZ+dOcNIBeJpgCQrLQLq5gG1ZylrXtmz2psF6pJ1LwpW54H75HHxnib7Ng54k+1Axu+LArcscJkFuOR43NOb9Td5brKtWfnTwNusdiYBe1rbfdysO+23efMiq+xFUrJfs4w1pLQxef1ZxlxWPy4C+hcB7QGAl19++XN/doZh+A8B/EP1+RDAt1PyuAD+jWcp93l7ilNF6gH8F+Ba599V6hi/HobhH0ktAfgagP/U4IPYAPCfhGH42+q3/wW407oEbhJ5pt3TppoBsvS9t6dB8q0dYNDnb5al/0mkLt/XG7+2t+l4ajb1MeEAX7Z1uFvZFOf7VLCQyF8SzEEoEhLZTJxyAngBDTiE/ikeZYDYQTzFxSJw3vTwyrd9YHNdS04J8P3ud7hsPRySq/nzP8dNTsfHinc6BTodTHsD5BySnH/0jodul15gAefvvEOA993vsq1LDvtw4lNhY8vp4/x+hxsMAVzdf4KVzSLrOjrSkdD8CSIKgzsGtlVnnZ4BnUuKZFSpviF8bdnYJ/0k8l/NpuZ9i5qacnpjf5+XKLQUkc0LAsBqteC6wK3hbzG8sZ2nQVEuk2fbusDFoyus7y9HYyRGjW0D7/3AxVUPeO9tD8uOF+URHOu6/CxBYzY3eR3LjuYXC7jf2dEGTjToQcC+6XY5Nj6Qc4oRn/fHDzzs7CijqE3ut2UByxWf4wwQBHc6RNuNDfZ5eYlleh47pnWuFCuW9DKGndeiw84avebuKNK0nnguTk6UQVi0YVketZkfdbB6p84Vh/Ygkurb3ua1T70AOX9Ky0okTdwRga0YRoBS7bjmpjvpeFeB91DRQvwpO+30lAbf6RnPD0I9aYYDFbBkBHQu8eF9L4oumJqEZ/X5py/1szMtJQHIrDQLID3L8U8DRrLqyQK9kpIvzSQYzgKOSVCaBWIRy5vlmV0UrCwKhOd5ApPtS2svwB2a8etJgt2kYRG/NvmbBnKz2jsL2KUBvLRritcVz5v8nATcyfOTY5esO9kfyd9nfU+2OctASNaTbHdaShuXWW1IXmdmW7+4Z+enSs8VFM8Qqf/bz1DG3wXwRsZvPwDw+idrHW5wigGtE3twwPdusQjApdfulvIKixRasUiPriSR1mo2tSdZ9Ibjy/ueR2Am1AjZTBfnLAvQ6nT0RjrXZcQv3wc2dgk6KhXN3xR52iBgG30feOWerQMxiLyYZemNZLKprlhi49wxvYPdq4gzmmvUIo7CZSdAGGjJtX6fXtdaDXjwQAN84WdXKkD3HQ/TACiXg4gu8vTUxardB0yDYLN5xobbBZ44VIoJ3S7gjjHq0ts6GCK65jh/tddTkf2aPOXY443aA3BPqXns7nKVXeguYaDBbFwK91pxeiO1CcvSXmzfx/qmiafH11GE4dUaaS/vvst6zk7pwe8WSR9pNnXI6Z0dDcZlM2S1yjHOWTQi3npLbxp0HCDv2HoSiBVlmggDkEoBXkO7zfkRBDfVSXyf/VLzrpDfu8VG7+yosV/WyxTDgebVFks6ep2E/+52CZL9qQoXrqIB2gXAHaFed7FcAdvmejdWWMYnbRQqNg3DCiktnQ6wfrCCp0dXWG3k2JYg0BSJ4YCGkvCNoxtpQmvi/n1SXtwx59D2FttmVHhc1E4aG+y7d3+Ln4fKe1xdATqXeOV7DZy/22IUxh/OeFB8zunL/uz8tCkLgGSltJf6J/F6poGZtBd7mqcRGXmB+WAiC0ymActkm7LA5Kw6076nAZ9knmQ743/TfkuenwQUswyMZLlp150Ez7NSvO6koZH8m9XGNHCcBoLj9cybv7OMgWe5vrQ5ayJ9fObNjTRjIO26085P69PM9AKC4kWfK1/JZFmkGQhPWDxusjQvoNWy6Hm0LNICLIvvZdmXJuoQIuVmmuQfS5nxeSGeXJFdq9cJ1mTXvuR98EBTOITqKnrKZ0cEHbmiRQ+nBRiWiXIZWKkRMHkeSD0wDYIYJSMWLYsXS7w4iZwmslSmCRx+iNH3fxvodHB+v4PzIxc/fugjbyEKWyySc+KptmJPpCCgx1h4pgJgxRuet4Hrkytyb4UzWizpSGn+lEDHmwDuiPQNEMjmaisoVOyoPNMkxnvaYT3tPsMyyMS2LB3sZEnk2kyt8gBoegtANQvSDEpKQWJE76qzRIBompHBIlrJh4e85qMjRAoig76OfNzt0hH67rsEwgPFHb61w7qLRYZ5vnuX80a84r0elERZyA63C9z0VyzBsMm3HrUHOGvqvi9UbHge52S7HamkcT6KRrSAWSEyB1Ot9CA84p0ddZE5Akh/qgZ/wAsVebP2BcJOF45aIQj9IArcIQZSp8M5O4lx8k0TCLtXWN1b0RahWirRAV+UfrIQ50ULsH2h1TFa54iWCopFYNolF9nM6UiF7oge7uNjFbSlFtExpqet6L7NTHJzL/rvd9LMNO+lMwu0LVLWzKHMOD8JgOcByKwyg4x/yZQGuGfVnVZHVnnPMgPnGRppxsG8dsc/zyo/fh1ZQHVWP5qJf0mDIQnaZs2VtHalgfPkecm2xOvPup5kmWkGopnIl3X9i6Ss605r4yL33jM94V7AZ+dz32j3pU0G36Pxl7SMi3Bi5buA0maT3mB52Yt0Vvz8nAk8OqS3tlYjIJjGxvyyo/dwib5uqaipE5bFPEGgPHw1eq49T8vhCugoFv2I07ppBcjbAIIAtw9sjLoewc3mlg7vFqgNZSJdARBUtNv01Lkj8lRbLZQqFkY9H7Wa5rl2u2yLYOf9fb2ZXzzfcTAkHtHHx8DSXU0hWK6ogCTtNrBziwCm39eR0kRC7N13gYNXAW8CIwiwbA0ir+buLk+XkNeOoiDsbVL6buJTq0X42ACx3OYm8ZHn0cubszTtpFSxFG94gknnGvkgICg7OlKecx+h5yPv2Dg58SLNaAnQIoojv/IrnCfffwg01D43wXSWxfF+7S7VMaZqzpTu7eHp20fY2+N3w7awVve5qc6yFK95qCeK6nRhxXge0DsFGj4NpqMjLTTx6h3AqZgY9QOUfJ+eeQH8wwE7rtejF9Yb8zel4xyensEwTcCjx95qXyF/74BGizvCdTcQNgc2NzVL48kp8LW7WvtbKddhc1PTtQ3boocXINVhZwfoPqWsnTdhpx0ekvPebiv+kvLgD4ecq/1r/u6OCZbF2yw353AU0U1QrXJO7dzSqxNgtlzWGyb84iXZvkppnmct7bdP0vtxcJEETfJ7mqdrEWAXLyNeTrKtWZ7R5G/Jz8k8WcByVhk+Pl7WQp69jCRlxznDyfYm80t98wBl/Lu0O9n+eEoD6T7SdZFnzbd5Rkdy/J/V2Er29ay5kixrVr/G65iVP0A6xzutPWljlTaXn2nuvKDPzp9cUKzSKwd8Z068KOowSg21lOtPcH7sYeJTzUCAr2lqDqht3xz3aQB4gT4mHj8Bz3m1ea5SoeNKwJx4GmVXfk6NjIAtAaWi+iAYoVrVYHm1BuDe14HDD1GqL+ldT+223jRVXiLgtCx6kYXH6U2YT6KMuC5KToCJG0S827zC0uIlzyugd3TEuoWOEAQswrL0xkPBvA8eKE+8D7zkXPKEppLZOl3X2rh2ngNi54HaKtB5qqI/jIHyEqrVKzq6hwSgItnmeaR3rNnA4xaL73Q0nUD6VIK0yYa3tU0NiAEgX+YATE7bODmhd7dalYAvXAY4Pua1CMizlCe91QPud4EqgJ4H7DY0RhNDoVTUhkSpYuL63SN6Ta0c+6BW0xptxYIK5XzG9pkM2tHv+pERBdA7Xalw7rVaejhHQ8DZXkapXtB8odY5DSYrTzApKwWuotg4DsLDIxhFG+PDJxHw3zpYYjssC+NhAM+jAZiztJpbt0vALzi029XKIPfvawrMt7/tY6V8xk1+psmQ0eUlpe1c0Ij66IhKJScnbK9pEszbNhVNvDEngQRi6fUoN1gsML/vcx71+wThJ08Q+gGOjkg5EV3wzPQl8WB8mdMsL1xa3kV7dNaLPO34IvWlgZMkcE4Dqcmy0gBPVpoHHme1PZ437Xz5m7yeeHtnAehZ4H0RQDvPaEjLk9ZWOZYG6NPKlt/m5c+aL0D2dSdTVh/NAtbyN63fkynLSEsrO+v8tO+z+lnAX9r9kZay7pnZDXvxnp0/saA4CBi0A9CqIRJxS4CRuBjDgO/a9QbBsygXCGdYQg8HAfVYp6BEnyhMbG4i2vTk+wwAMlIetW6XogzCDZaIdmOXagvLiissG4GOj/V7v9sF3nxTR5ATialp3yXdopEHHn1IxYedW/QGmyYBpoAviYX84H3NMXXJGZ24QSQG4fvas1mpALmdLbU2P8DL++TDCs+2WNSAvVolIKpUeH137uggI8IlCV2PXkNRvJC+r9cJavon9HD7PhCEgDtCrmxj2TFhd120WsDGJusxTGB3hyB2TRkypknP8f6+Bm8ADRARuoiS60ZR3K5OB1Hbu11SaMpl/pMNe0dHxO45i8aM5wHnPcaR7ACoQxsEY+Xt9zyu8B8cAGvb1GRbrgS8tmKJm8laLR1q2wVg0iV//agV9bPrEhCHgaZq9Pt6s2ezSYnA4RD0qNbXYpwRRa3xJ1p55MGPGMEPgMiwXbe9aINguQz0W1SPWK5ZKFRsNJseTJPGxVKDY9Bo3JQTlMB5jx5pI/GNNxR3WxBysUBg3ljX5HixBIOAVJvGBtsr6hH7OwocF9SNkQPe+U16kEVFI4qEB2V9hkC5BK8zQLVK4yweGv1j6QXdLPJlS8kX8iyAlzxvFnCZ9TKfVecsoJb8PsvblwQy8wB/EoQmPa9pbc8CS4tee5rHMw3UJfPMOz4LFM3qy7R2yG8CcJO/Jdts4uP1pwH8eN1+4vd5RkYauH6W/Mk5kmVoxfNk1ZEcx3nGzDwQn2b4zOqXtPZK3kxg/II+O39iQfGyw7/vPyD2Enm1IEC0eQimiY1tE+enQbTBTqJ1vf028wvGMEy9PL6uXrAS9U1AWc4k1inYiGSplhxEUm5rdb6kPY/v+LfeuqldK57IXo9hoQEtNbbcKALVVVw9OEOxCBQciycLAVa0y9w4h3gCeBYBU7lEMCHeyHIJeXeE0A8iKTSnqrgI+/sQlYDlBi/WqQURgDJMVidRAktljXFaLR3842k7wGrAoCCToY+8bPQaDjggvlpCt/IsQDyHrot+x0PB1oEwnpzwVFEQKdganA2HVK0Qp/nWNqPijV328+Ym0G/7cN1rTHygYJNv+s47BEx7e2y367Isy+KcievzyoqB7BN7BHKbHwF4wyV3fdnRG+giHna5jEmzg/z33lLcEyVj8+2fiTYaRvIIxx9huV4HWi147TNctGlciVEknljBkiJBZ5rA46MAxvFh1IZcUfGDTBNT1488pcd//YekFdt6k6BsFNzeBk6P2K/drh8xFSQootB6ZDVlX81RCcQnLB6hAg2HwHL/muPsAti9zeu08vRS12uM0ied1e9j9OAjlKqkB5WcM+av1bSn2PN0aG2Qt2xYCp33+zQ66nUEx+3Ic+952lBKTV+QTvGLkrJeimkAZR5onFX+oucFuCljNg8MC8BIW7JPApJkO9IAWBI0J+tKfp4F5LLyzAIjs8BbWhvT2joLuCaBYBa4TAPf887JypsFwGWs4ykN1MTzxQFqWnuz5g0wey76KWXK33nlZtWziEEEpM/PZzH6FgXEcYC/0H35Aj47f2JBsRgw8hIfK96wbUMv56rABxu7/Dvpe3j0iIe3t+lgE0/x1FfBPRQgiHNVxRlbKmqgPByyjGaTkfEEzAnVYnNTcZ4DBjALAnoAhbrx5ITc2esewUbp2EW1ehaVETR9NBqA2eugUC0Cv/qPgcpvs6LtLYLjbhfYcQgURP2heUYgNhwg9INoRbrVAm7Dx1IZMERktlbTYPvkBMsHDSz3erg8cSO6iIDFacBgIkuOi7NT9sFAAVqJH/LKntZGjkSa3THBUvOcHtzjj3DZ1lQSCVgiwNA0gffeY9/duaOiEQ+1x3Jvj3kLiuYhnOPrPuXzrhVHeqy8/EdHBHTtDlCv8ZycpT3f7TbrPx7qh+IU1LkKwagIlQrB6+//V/XmxNz+S/TUbt9C/ntVevIBYGtfnW0Ct3LARMVUEG5P6xywclgvFnD8145w3iIlR+R3LzukURwccJ5sNMhdV1LHDK5StDB1fQJjy4JpsuUC/D94pJVYrnqcY0JDKRbZJ2IQlMra9pI6RMnDtsl4EE66qLX4PrDx1m0WItEEq6sEx74PNM9h1KocnE6HHu56HRiOiG07Hj58BOy6Z+j3gdt3mkrer8Cy7t7l55PHMIIA/ZMuCnaA/E6Dc11dq0glXqr2zX1Y/E5KTYsCtEV7MQuEZXqkUs7PqivrRT4LIApYTl7LPM/kLOCSLEtAfJCRR75nAaokiE0CnjiYiV9Tsgw/9jmtzVljPQsYZ6VFgRhwc6nfTHyWdiXBTFa5Figdl2bsxI/Fy5/XzqxrzZobWSkLyMaPxw0++S1t/s4aqzRAHK8nrZ1pBs7c9AI+O39iQXGxSNAkXi7X5fFSg/q0YbsDA2oNGABME80mcHtX84tlk9nJCUM/D4c6BPPtXU0l6PV0uOHNTR575YBe6jt3OG/aba2B3O8TKFoWYAba0btcIeAZe5oHLZ7Jep1/yXlVdIe62hDYdwnCABb+4H3lJfYYKng40ORl08TjQ5+OWp+0hH6f7V4qA0ajrkLxWoCZ03JlwgvY2cGadY5Jh97WvGMDpomnp+zgqc+2ui7bKhuwtrZBwGcXqI386/9EyWmNNJqr19Hva11noWfIhrJymZ7fclkHypDV+VaLzRTgBmiVMwHJwyHbJPu0jo4U6A3oyHy7A2yBIrEiy9ftkSbhg3mGAHIA1kFOsavq2d3VBliusqQ3PorYNABs7QK4BZZYBNDTkiTNM17scECPfrEYSQcKlabbZbseuUD5lDxv2Qwo89WyAPi+9hTbBRiVCkruGJvmVQT6C7ae34O+5pR3u3pz4MTXc1Pk+EauNjaCgHNWAtaIGlylAkRLB8GUKwGtc86royOEng/D5Py2LMBwR9FGunffVbx7i0YV7zcXG5vCVdpioyREtTeBs1vDpNnRSiv9a+TUio8od8QD+NxIL+gS4PNOWZ6vrJQG1mYdj5+XrDd+XlqeePsWASVp4CjNQ5lWVtqxNLAyD9DPMizm9XPyt7jHOw70kn+T7UoC7qwxSrYt7fusfpk3dsl2LWJwWciek2n1ZQG8+O+LgOEs8DnLuEnmSxuDLGNk1rilGUxpBlFWXbOAdLL8hdIL+uz8iQXFgH7pCyA+PgbMk2tUKnxhPj4K4DhBtMy6ucl8E+VVNk16i3d3CVRbLeCVfeWB8jUQERWKO3cQ8Swv25pfK9Fnxx69nOK9NE3lVbQ031m8k4LV7z8E7t3RescSXjdnKbpDtUqAUC4RxMrmo47a5NZ6AgRTjHseClWGchYn7ep37wCHh5j6PlbrJq46AVYsBTiCgOBMgBpAr5/a1Z+3AdmZOOnTIpj2XazULVy1fWzt2Tg/9iJ+ru8DqNUwOaFEVufEw7qnwiu7I/R7AcJuC+UygddanWBNeNvCs11yWN77D3Uglu1t8rZlI+DOjg6qUakAy3s1LPtTVCpXkUKF6EqftgCnCPRcwAHwGEAeQHFI7/GvAdhT88kGoex+GREF4fgY+PrrpE68fE/tqDw4IP+1WtUu1NVXQQ9xHsAu+AiyAWMC5HJAdURqy+5LKspbCab5APfukTJxesqNhT8GaRunHYLiTofzShRUqlXgqgsAPlaq0AE4amsobBrYDLq47Gjvc7GoqRSAipJs6n/9Po2cgwOOxUWb32UeAvwunHuRh9tp9BFt9OxfIx7vXFRKJIrjeOjj+vgsWpiwbf7LmaQReR7H2jjYZ4W9iVJS6Udk4XyNfPqw2YJRqyJnshvPTnV5mekFfLA/75QFJoB0cJLl1VoE/CR/TwOt8Zf+swC4tDrjbU1rXxbwi5cb5wrPAxvxPLNSFrBNnp9WTho1JC0lOc7xvo33tfyWpKlIHX5Ke5L9kdamJBg1E8eSgCXt9yyQmlZXWvuQ+D4LtKYZHMlzZqW0652V5oHttN+zeNpZnxd52i0yX1nYi/fs/IkGxYapvVqiNWya+gUuUq2WRYAhXlhZim82NT9WdIzHyrkcl8pqNgkMPjrmsZWK9pAOhlyyHw2B798HtivARY9eOZFuE0GIdpvL2TLP8jYn5yWxBDY2Wbbvc1MgwdOSPsEd6V34QpVQSKNQCQDHQfuhC8NUShbiXgVw3Q0iIK4/gNq3e3s6SEivp73HzjL6p1fRUny5DLSOfSVRx4hn4kkvFoHqCeuT4GYACLidZXSPryMPsQA8CWoimsFBwM2AsslvrDaInZwgkrIV1TfxXFYqiCggE5/gSHjIJyfAAMDUpQe4C2AC4CmAvAscAmgBaINANA/gHjTzA2A94tFGY0NF8LjQEdt2bwOl2wC+qUqzQB9zHiRiAMAZN5q1zrUu76/9GoZDqnm8+y7HfKDOzgGoOwTiE//mRlJA03cAIHQ9eB5QsOl6L+2Y2Kn2MeryuKiodLtc3RCFi+1tpTphEpD7agVgydGbSKc+z1upaIArVCNyi1QkurKi7zhLQPsCg2EsXHh1CXl3hLwVoFAt4s4dN1LcEGOz3lD613KzCGHZzJE7L8sopgGjUgGGAzQaQK5sY2vbi7jQqekF9XZ8kSkLuEkycZN/Oat342VkecLSflsUlMwCS2nAKnleWpuyjmfVnQRGWW2LX+usMrOOzfstrR+ygGKyjcnxjAPptHOzjKmsY3FAbib+JYFwHNgHiX+ItTVIfF4kZfXJvLmSRnlI5ptnNM1qw6yUNp+T92ea0ZPWpme5t17UZ+dPNCgWkCs6woL1RFlCPLarDa4FBz4HuFjUVIeRq7m+jQbL2d7WS/CyzN/pEGx1OsRFAuw6Ha1hmwcB8RQEDqenuq3xZX+RPZv65LnmTHroLlq8pm98ixrD466LQvGKm5WGIxbSPAcqy/RU3vu6oiWsRfpwq7U2nJ0qRqddlMoTXJz60UbAb7xpMiyviC6LKLHwEFrnQKeDUXtATNK5ivqgXNaex8GQgN736Wmv1xGpJfgKmBaKiAYk7F1T1xhAVwGuk5NIOQy1GpsvG8JECzhnao9jvU5DwXXpCXZdnlcuI/JSCniUDXU7O4B/xDyjPnWPW6A32AVQVp9NAJcAvg71oFX88jBg97x2h0v+UShDCaJSWQFKFQDXIOQeg/DbBGH2ECRrKFQpBs5wAHz7O9hwfxknJ9ohaqr2DKA3AjoO4CoO/GDIPqlWSWtAZQWGaaAgwUqcJf6zLJQcH1W/A4BA+Bd+gdrDMhcdh+GcYZqouW600W6tBpT2OP+KRY6TbLgUHrZtAwimBKxWnnOzTK4v6utYbj3BcMhrmHQHkRSgpHabRlucE56zoHZ3TjSJv9Oh8SFpc4tKFP0SQ0u7I7z+VhEfPXDpUD7PeFC8gA/2LzrNe3nKyzcJJJMgKs1zCTwbKJiX4m1I1p91DVke0rRy5TqSKQ5WgkT+ZBlZ7V6kP7I8omkgKK09aW2dB3azjKGsdmb1c9JoyPJuSt1ZdcT7wMJNT/aibcn6fR5gzZrDyXNmAetFUrzuhYFror6k8TGvjrltfAGfnT+xoNgw6OmSQB0DRXeIR6c7PgZ++ueLuDxxo98ARJvdGg2+9De2+QL3PAIt8UjKUr2cB2i1imKRygASjTYI6OGzTQ0gRKatUtGAXYCbSEhNfAIciU+w3gB+8/sEsoUiUDjuotHoolIBNy85y6Q9bG6xgsY6v+/tAYeHcHaqQLertZqhl8GftgN6VrtdFTI6DwShirJWZIcVCygWB1G0OQHCeZu0EwH3osohcmcCmoU+7LpAww9g2zHJOWhdYNsmn/TOHR21rdu96XkWYCVpqawlwbpdeujbbeAtx8PIJUCP5ofJNgm4NMDNGbdA+BqCsmsKo2MXNGoEFE98wClrak2lAtIEAILbzS1l2YyBXB0EwT4IjB0AS6B5tMpSa6tahUHUKCor2Nu7wjfeAH74HrBZJJ84BxpU9+5xfv7iL2rgvOQAxmZDGzQA54SVU7seGTp62upguUJDpVrl+H3jdXqmZSOdRLCJbyjtdIDSXg2l7RKmhx9he5ttGA45HyXAif2IVJjIwOo+VTdInvi/rKlFgPJYm7mIxiH0JPkX3USmqSM23v0aV0McRy3tnPFaGxtKZcUHiiVsbmr974+lEHgRBei/LCkNqGQBmyyw8UmA8CcFBwIGkx60tPZkAcOsctPAxqLeQfm+CBCflW8W8E5rW3Lc0oB1EkDPSklwHT+WlTfr+DzgNq+uJABM9kOaMZM1hlmGxSxjAhm/p7Up/jltk2QyzTNK56VZcyyZLzO9oM/On1hQDCDiFdp0eEXR0UQvOK94hhKp7Z13gG+8QUwiahXb28Drr+sId2dN4OU7FuD7uO7x5X56SkBSLBKEiZN1a1Mvs0tErWqVgKxYpHdWFBWSgbqEjlCw+W+txnbHN98VPeWD7NJJuVYc8sS9PYVIl+mlM02Iy3Hq+vx6/xq3v1WH7w+QMwnuhFpQElWA8hIbWFkmIFZcY8O24Dh+xDmtVMhjNU0C+LV9Bqn4qW918LRzU5Y2COh9F46wqBr0+/x8pYyIy44G1AAivizAtgpf3PfZT4ap5cBkLGybY3x8TPAltAkZhx8Pdf6R4hTn1D+ANIoqCF1tkFrhA+h4wIqlJcgkQMh6vU4DZHubnlG7AORsEG5fgL7nPHhbdoFocXCDlBR/wr6WSVRbRaV9hZUKdX/few+4o4C/GE3b2zfnEQDFOVCRDSsVGjcyudptPH3QiiTa2m2O2bIDrGwv4Tu7FgF0rUavLICCeR4B0q1721yNKJcZta5WxUvFPi5OfeRMrapnqClX6V1HRij5yS6Wqyb6vQCOrTYlWhacWg6wLNRqA3Q65JQPh8DagRr0zU1ehwBg31d86TENEBWhD9Uqg4SIeoppwO4PsL5bBP5p2lPixVwCfN4pC3hlgYP49/jnJGBLvmRnefOe5bdFvYJpoDFe5iJAQ8BUHNCkAdNkn6X1ZRIYyW9S/iyQnQWQnwXspP1NA9SLpHlATsozcfNak+1OM0qyDJQs8JpmcCXHaR6wTZvzSRpJPG9au+PnJj3KyTbPOhb/Let41jybNxdm3d+z04v57PyJBcWmbWHr53f5Yt/ewupwpLbRDwBvgv7pFQGXXcBqzQXqdfwPDriB52nTw+qmjW++FVDa6t4d5NSms52DQYRiy4+OAPAdveTQy3twwHfxo0ecLxuKctHp6MGY+jokruio5iwCWwnMAOiIyCLhJpvD+n0tPQZoVYxej0in1nyAlf0WLh50MPbIAZWobJUKlSAsC+gftbG1Y5Jm0TzD6LiN01Og0LlCqQhUq9cEiO/9kN45kXW78xpKyh3redc4UR7xtTqwXDUB0wA6HVwqbCcydeLhXVfc1LzibR8faz3mtRqvT/ptONS8a0lCZ3FdRFHvxLOfs7R6yKt3Cb7OTtn//b4GkY8eAb95SIi6U2MQDoD8YRs0NhrgcQcsX+p7/XWqkUx8XkOtBuRqK8qK2mJm3we2bgGhDxhjUK9iCUAP9EGXAJyB9Il/rHkhJ485mAqQCv6bBpwfEuTlrbfYHs/jdX90zH44OIAKg1hSgUHG5Fw4S0oKb4TVuw1cP2pheXsZtdo1jcPNLZ4sE8XOq2WOPD2wb/0MVw+8CXCnAjjLMBp6cq9XukClgledYyAIcN4EXto3AdPE+YmPkxO2u1oF+r0Al20JGjMgnaZi4+KEgUK2tgHn7m3g9An6J10VTETdCN6YgN+fsAO2txiUpLER8d2nrQ5yzpCTbm8Phj/l9WelF1Br8/NIcfCSBfTix5Lnyt80QJLW48m6stIsj9ysPGleuWRbkkA1eV4WyArw8T7JusZ4mWnAN1nnrDLSNlmlgfFkmgWg542D1JssOw3cpZVtJb7H2yOfZ3lw423zEr8nxyFZT9rnWcZNsj6hZiRB8Kz+mmVApbUp2ReL3Ht+yrF5Kd7mrD6ba2C9gM/OhUCxYRg/B+BPAnhJnWMACMMw3H9+TXvOyc7z7+aGfmE6DlUZfB9OfQ1OEDBcbK1Gj+rOLcAdY7XuM1+1ilylwvNrPpeA63UCg4fvM6pcdQn1YBDxZcX7LBvtTk9Z/N4e8UatRjC1pZZ01xv0UNfr9AJLuOJ+nyCo2STQEykygJjl0SPga/fIMxZqRa0WKZvh5F2ip7HarCYbA3d3ySG97CjeKUDQ0+3i6IjH12qqDSeA071GrXYNo2hjOvSQ272lXbbDAcplvTFLvLBCtPabXUx8vTGu2dTGg7O5jFGL0lnCG5Z9f8Oh5qaKgSDGg+PoMM4R9cFk+TmLfSie9qftIAo/LFH7JFRxoUg4ur+ttZDzNrBtAsctAuPoYWSy78Xbfe8egahEncvZJqadK+RMk55i0QH0p0qgesJGogOC4QFIcHUAnIK1QQWnmLDw48fA7kswjo8BBFgqc0PbyKVRcXzMvhSpOYD9GwTAN8ttLRCt6BIoFtieO68Ch4dY/nYNKBaRd13tdpadbe02QXWxxGuRlQdbRaWTFYTTJ7ixzBEEJH2k9QABAABJREFUkfY1qw+wvFtBEHTxxhvMVqgzqmKpeIZuVwelQfsC1Sqwvm2p8HolwFnG+cMrrkC0LhD2rkkNAZSluAXRvR49+AgAJRdNE2yrXYjF3l6FfoXG0qfcLPKVfHaqlAUk5HvayzntWBbgSytn0fbEy8oCGVnAPQ34zjqezJOsNw7G0voh3oYkCBMAOKvOWW1KgspF+nJe3jSDIA1gpwG8efVbC9RtgiAvi9ftx/Jk1ZtlyM0CeFJnWhnx78/iaYzfA7PqT/ZzPO8sI2JWufOMg3i7PlH6im+0+wsA/n0AvwG9Jf7FT9u3dEAEu0DvkkhLNDbodTJNTB4cIn/vQEfq8MZ6c1mnQyQJaJevaQK1NaD3JAoZLXqxssEOIGiT6lotoNnSxzsd/ms26RVtt3nu6akGiQL+1urkx7ou4xZ0OkqNoE/cI5vSjo+Jp4RasKToFyNX75cTb/NVD3h8DNTrAdbNLs6OfVx2CCoFSArdwbKACjwudW+r8M/+BLALaLc1L9RxoEJNGwg7XQAEchKVbntbe7cnHXqYZcV7MKSxUCpqAOx5GvgeHhKbTQNuanMcXvfdu7wWifgGsIzVGsuUICDxDYGnp8q7DN3HJWVwlMvAkgWM1RPXAuu96vF7saiNE98HNrY5wDmnpDc7ChG2VuPKxFIV2r9yBhIxAOAYBMgujTBAA9OdW/xbraJe70ShlCUs+P6+Vn6Qa15S3N8IwG5uAmZOEZ6hJse13vkYBPw9bn0EUwLoXo/XY9v6PrAsrSrRPCM4Pj4GelcYDwMU0Is23u3sKODe66JajQFiOw8EU+TKNtZ214H2BS7fO9PzZ3eX7e8PgNoqXvmX1nD19iEmnWu8/xBYOmrBcVqo1wHj5AQwTZwfuRHVpte7pi0QXJHPbOeB448YsAevpD8nPt2D/Sv57FzE25R8IWeBzKzz0r7PA6TJupJgN3ksqy1J8DHXI5ZSVryMtPYny00CNT/x26L1JevJSnJO8trS2pU8L6uONKCZPC+tDVntyzoWb6OcnwTB80BfWr8vOs7JvkmbI7PAaNa8TH5OG9OscYvnEYMh7rFPM1j8xHlZ1zDrfpo5177CoPgqDMO/81xb8kWn9gVf6GZOuwYVYMg7tiYNWxbQOsfUj28S6mrvGBDxM00TLLPvRRQKV1EGPMX9Xa3pKHgAMY/rspqJz/DEcZqkSHwBLKdSISAsKGdiu62V0YQm2mholQsJArJW00EtwkDz4cVjHAZaDWJ9rwDAx0pFq2jU6yxbMJrjgF7zXo+ApUJd2CVHdx2A6ItRq6LqdXHRJp9662AJ180Bcha927LZUMIqL5VJK3lp38RFM4jAvRgbr7+utWbFIypAf9nRGyiHQ92H5TI95cWi5nGXy9oA2dxERO84Pib4NUwaKb95SsKDBKPwPJa1v6+UGSwTa3XVqbU19od0RLHA4yeP1YbHS2BFwPAA9Az7APrAuElA3DxXSwAfIEKRQYDH73SisMkiuCCgfL3Bvl1yiCVLFQtR/OVyWRkoJjvn/n2lTTii/NvmBr2+3hjAErBzW0V6zNGYfPg+829vM08wBZwqr7PZpLJG70rxel1yxfuBVr6oVvFauYuTE9JZnG2LBoJd1dZLt4vp0IsClHzjTRPRDtj6eiT9t7KzDAwH2NsL8OEjevQNS91QZg62TaNG7o3TU45lbjgAgho1jv0ZePXTPdi/+s/OzyEtAvqywNus7/NGNg0gLHLeLHD1rOAwq4w0MDUr/yLtmQV+kvnngaVZdaS1J83jmdXmOFjLAudJ0JbM5+PjKQ00J9uVbFPcg5xmoCTLzwLBaXmy2jcLGEs70lLSSEkby6z0rMYhK/zqguJ/YBjGnwHw18Ht8QCAMAzffi6t+jySYRAIR1vpQTDgLBEoiNe4sqLcbleANeU5AHINdZ4/RRSOtlxSmmIMkJGz+LuoMIiX2DR1BLDLjmqOyWVvAXauSy9fr0fw12joWA/CMYbP8nZ3gQ8PyV+VDUviGQY0oI7nGQ0R8YkBguqxy3asVLQ6xEsHnCJb+0X4vnujfb6v9tfZQM4p4uLdM1QqZwwr3esh7F1jSdEKRi7rhjtSBkQNk5MuAAXigikMk95tkUyToBGepx2rME2s79r4rV/X3j/xdJ83dZjsZpNe4m6X/SNKFLd29HA7VQtXPR+ex3G4tc22NBrAq3eADx4SWI7dm5HhBgHwWhXodLXowfY2KRcSGBCVCsJOl+DMtglq6+sEipUVJa9wqWk7+EC1aoMDi3NgqgJQCNJtNglk7QIr/sFvRPWLzq5IDD45Bd58k6BYNhUS4S/pcInVql4a2FQrI+5YWQ9K03o4AspjelMlJPPpEyWPMiVlyHHUykiP90B5SdMSzJxaMaD+9c6epSVAwD4/PARM04dtA8tmj/3UfYqwz6AwnQ7nxKgfoCTLHmJlqXqetgN0uxwHSaHrwVDMD1gWKhXWUS5zXmxUbaB1TuZK1sP70y8BfvWenVjcK/asYG/RNK/cRV/cWeVkAbt5wDxedxawSwITIDuQRVb5aUA1CcjSxkS8g7OAVPy8LCCUbMMsUJcFqpPfZwG8ZDtmAcu0upN5UohSN+qaZ0CkgdI08D3rPkleQ1a9acA5qw2z7ouscha5Pxe51z+WvuL0ie+ov2/FjoUAfvGzbc7nmAxD77pvtbQO2OkTra8WhHQptVpqZ/5TTWYVSQorp6WyRCJB3JIAYOUiNQVT4YQHD3SEOkAHQCgVeZpta44toEHNRVtzY6e+ztdWxweqegnDK8oP0pRBn8CyoegYS47OLyF1JVmKujl1feQsC/22i81NIF+2EHo+ej222bZpM8BxYJr0CI67LizLjTZ9CVsgDADPC7BcLwHtNgo2Abhh8pxBn3SDq04QbbwTydnVGgi21G6yb751jsnQR7erAes5tLdUVtl9n+XUatrjbFgmrrsBRj0fGw3yiG/v6L4VHu56g2My9ekRNk2CzeNjThGRf2s0WLYEZel0gNUDE0ZlmZJ37ph/hWsCKEtnQ4PHcEyDwbxWZOSRMrhynJv+VJ1PFQYMB8BwEOn0Tnw93qen9Jxf92gYGNUVPD26wuq2TS+1OwY2q2pjnMfOaZ4pnV8hXY+U7J6lyO6rPFfxe+GO9eY04Q0HASeWZfHesgvsqOYZtrcZLAOVCrCzg8n338HYA5yKiXI5QKHI+Tkc+mh4Z9E8fPddJSxhsXnTwAfgo9R/TMPUmwB9BnZ5+JBN2NgE6Rplk+0ArVEJqnN79+b+j6mvFUVS06eTFfrqPTtjaR74+bxeic/kvYqd86ztSwMwzwoqksfT2pFVZha/OAkck0Ap/jfp1Uw7P96G5PlpYA6JY2m/J4+nnZt2XpaxJSkJRtMAczxl9XUW0I+Pd9LwiF9LVgpws8/jKQtspoH9tDZmHUvWlTYOaefPuo8WBsPx9FWVZAvD8J9/3g353JNpxjy7NjcN+VPtAjVNzoAHP2L+OIqVv8Oh3rUlZFjXZTnNM1z3ACfoYtAn0BLK5fa2Br+S9vZYnETOE9UAKbbVYpOqVeBpR6/E371LOa5CkcfFC1atAz/zbR7rdBBFgAP4vVhkPpHJqlR06OS1mubg2jaAjoucyc17m5s+BkPm29mJVLxQRzuifgiteuLTy/rKASkRQcA60GrhvMnrcxxye8WDB8vCynf3gd41VhvrWD0+pne0XNKb1Ir0lFqWj/W9JTw9GcBxqFlcLusNeeKRB9gGAECxiHHXxfIbe1wZqFTw83dLBFfDQeRBXeldYzg8i4QixMv/yj4NiB/e55gdbOpNequq33Z2oEPvVSoEj/0B0fTmBlD1CRZPnxBcvvsuj7cuFHdDaUAXC4rcrCK+bW7Q46w8uE9bPoZDrTghqxEyv0TWr+ZfAQBGHRfTtgtHosjcucOyyuoCyks6jKMAXeFifPvbSpc60EoVIjps5Tk+nUsVNVFxkPsDoH2B99/1UK0CG9vKnX10hPx2HflOB9fdILJHhd8tAVeuetrzK4ZInJItZPCpD+S2G7h7t8WNmfUirSJ3jMmjjxh8xy4gCAao1wmCh0PAGLpwNpeRK6r7PS19Sm/HV/LZiWfzTD1rmuVp+6zTPI+gtCH+eRYweRaQmwZG5gGWOJhMa7sV+zuv/2eBoTSwGq9D2mDj48nEbGrCrPbPAnhpoNSfcU5auUngnNXGeJ2S5nG8s+aMlfJ7VhuSc23W/MgyBj5pSjN+Zs2Duemr7Ck2DGMFwH8M4BfUoV8G8H8Mw/DqeTXsuSfDQLSJSPgNVg7RzjfZNFcs8UUvZFvTROj5MOyCBg6+T6+yaRDANenpEt7wxAfOW1wqtm0l0WVzyXejoekNheLNoATCHZboer5PQAZoFQvZlFcqAl1TS591uzwmQRUksIU4/nZ2SNd4+FB7e0X1YuQSAL+8D5Qck30wHETe1lKRXlFRp5gqEF+oFlGEi62DJYT9QVT2eRPY2LFw2eSj8qMjRB7eQrUIxyYgW94skGPbu1Ic3Ck7q74OBFOCLwGPe3swFJl51aTywFCpbMX3ffX7VIMQ9/ioo6KX9XoEhI0GQWhjg1QAob/gmg7UJvtYDISrHpXJdnY0ZhwOEXGYZTynQ248DE+eRFzmVgvY338CY+cWUDzSO/uGQ2rnWhY+vO/hlbsWxn1fz4uD2wTIp2cEn8MR4E+QtxkA5viY4yeGjMjX5W163vu9AE9OaezUauBcdUes81vfYnm1mgriYellglPlsRVKkRDVxUvsKYqRPwE8S0XFc8h77vUQDl08eMB+63YZ5Iagelnxh20sVz103wuiPga4aRTQOuLiDe/1iHV9H5ryEAQYDoFlKx8ZBaOOi5LTwbTZRr5o4r13fLz+JiJPsehUl4osY+r6yAnNIi19OvWJr96z8zmmtBd8GohKvrA/zat3EVA165x5YCLr/Pjf5PF4P5iJ72nlJ1/ki3j+kvnTAL2Vcize1izPafxvWh1pKQs0xstOa0t8s9i8/kyWn/SgxtuXPDfr+6w+njVH09o6D7gn+3pRo2BWmgXW0zzMzwSOv6qgGMB/A+A9AP+m+v6HAPzfAPyPnkejPpcUhPxrqYVTWR4uloDqChFMva42Ek2oUNFuA/v7MACthVpUcgiNdXrajo4i4GxZwErNhHcaRCvLcT1dedn7PkHcRZtgU5zV8SAh8ehdQcCJKbJukl/CVl+2+X2prOtyHALdwRD4+j3yix8f68Bmh4dqn6HJeldr9DI7ToBxZxBxfAFgbW85Uu24OCWFodEAJm0XTsXEtDfAyYnGe5YFjPs+1u7U0D/uIGcp4YUhYFkugV9NAWJx9bpjNkQiUUjEs9MzTUEQ7/72Fgw7j9vFvgpKkcdW5yngjlAselSO6HYR+gE/2zbR1fGxCj5SYZnemI0aDoDNDRTKJbz0vSrQPMeakuy4HQQIe9d4cqrDGvd6HPaC2tCVqyxFig7G3deQGw6xfHqGcvkKRmUZ0+MnyL1+lyDfo0rH2UmA+/c91OvAB/d9nLdooAQBsOk9jjbvIQi46c2bYKrG7t491XyP4yxd+I03yMPtdjk3Ljv890pwhdJuneD//o+I8kVPTkjRErXQcdjOt9/W0oQixwbQsOh22Wf1NT2hy2WcPHSjzZ6lMvWHnSoUTWOMcddFr6cpL7L6cdFCFGVOAKzQVAD1nK0o3Wcrh+VagPHhE1x2CKSv+0ChTyO2WOTmvotTBpNZrXGVA2BT+y2uMlweXWc/Kz6d1uZX79mZSElQMQ9ExI8tUma87Pjvn5WH7Fm8jEngEs+TLDMNkMWBXVYZWWAo2Z4kKEuCo1ltSisrC+zMulYrkS9eh4Wb12mm5JPP8XKyrifrGpJ9mQZ042Vn9VH8nCTdIQnMs9qSlhaZn2nzfd59k7zfkscWbWfaXExr0ycC319VnWIAr4Rh+D+Off8/GIbxznNoz+eXJh5w+CF3I21v6zVo4UlWqxp8BVPtCmye85ggWYAAW5ArAJg5GJaJlSonxMa2ialHj5bsip+4AQyTQKbX00UBuloBzUtlTWv21dJvrabUEzytqCX84SBgftl8JQHQXA8o+1ytP+8Caw7LkaX23V0NPnLKy/q0o429gpL1wt4eAVNxF+vlS+DRVeSle9oOINK25TI9q45DjzD6fTztaIrI8vYyJp1rFO68xAqELlAu0Ru8v8967DwbKqoD7QuCs25XAzqAYykabu1LwDSxLAoPjx7RmKnVOJ6VFeDnfxdw8AqwvAo8bdPTPxwyv9LVRa0GbLfpVa1UgONjGHsvYSug7q3I/e7uKi/1TpW0hE6H/WRZBPhmDrnaKuXZ6mvcmFYuK2A/Qbf7GPv7mv98rsZ7Z4dREpdr5HIb5SLC48cwijZ6PYJA8bKKQSPg8bxJfm21qrSfFeadBtDz1R2R5L65QcNPwG6/T9As1I1OBzh5wj5unbP/xVtcXqLRcnLCPtrcAk5O0G7r4QAAZ08ZOa7iT3fdiGYtEfdsW1FsoIPOFWpLqFYHkeZ04eC2QsyF6J4rVIvoPnKxVmNfrCvO93LVxHKNRmqnw82VToPqH9PeAKUi+6mY5Sn+9EuAX71nJ2Z75eaBq+RLflFPW1Z5nzbNetmngbJ5ZUm+NPCV5oXMAslpbZkFiOP50jzHSUMiTrGIL/EnDZG0dokHOWkEJUF2gNnezCQojVMzssY+7Xha+VmgOlnOosfS0izgOssozCojaYDFU5bRlJwT8bLivyc/L5LmXcPM+/erTJ8AMDIM4+fDMPxVIBKkHz2/Zn1O6eBVeh5FMBjg32KRCK9aJboUubW24kwWS/wMAEGAsHsFY3tLcxX8iVavUNIJuX4fGJL7cNkKIimz27vAP/oVFiXKEIJXhJnhujoUsjjxBDh943WeK3v7fF//bbfpGSwVufnKU/nOXaBmEbAUi7z8zU0daG3k6g1movwAKOms3ZrahDWBRGhbV7rNpVoRjx9SZUCCmb16oHSRrTz6zWsYJnB2CsVSuUZpu4rJo4+Q31Y8ELug9NKWyFHdf4Xgp31J9QMrpzeCVat649jBAc9tbKjxmyi+bJmd9d3v0B1erdK7bOdZx/LPAQiA1SON1o08ULnQ1wkQoJ+cAHdeA/wJcv1roNnBksOfbRuM/ldZYT0Nxf/d3dW7BVW0xGgXYfuSKwzeBMsV9reEGi8pkHbWpCHytOVjdb8KBCEMz0PoetjZYTFNpbrxrW9pj+vpKat9cnIzqMvODmA4S0rBQoVrdhwF3E2e5KpbW0J4i6TJ/j6pQfK9ecbraV9gOtT7uXO2idAPIqApSiuRzjeA0XE7ijItutmyelCtEuwfH7M/UKnA6nJTId271zRgej2Mup5aQfFRsLkCsl7Xt95VJ8BK3Yzui6ctH6vbFlBbQ84d4fFREN0HmenTPdi/ks/OtBfxvLySZvXmvJd2EhguMjJJQJD2Ys+qI6veeHuT4HBWu+MpWc4sgLVoW+MgJm1DXVrdSc5r8m8cqMaT8InnAXoLH1e8SILOrD5MA97zQGOyjqy8WcA3a14vCsbT8mbly7ovnvW+SjO20up9lidZsh/mfU8v5KsLiv/nAP6S4scZYOitP/y8GvW5JMsicN3e0gDPyvOY8AGKJaXP2tObh0wTo9Y1SrUigYU7YrQz8Rz7Ux1CV1IQAMUSlrcLuD69xtomXb71OoHr3bsaAHie9gpLyimP8cjVABXQnGG5HEAHFxMPcLVKz+CdO1zid13go1Pm9Tz+1m7rSwR4+Y97LENASxAoD6QsjwPaRW3mAGcZ16fXtCGU/m+9zjILReDq5JrL1GqJXDZTjZtdFIpQ/FrlpQ/UhkdnWQdWEXBWW1PCyGrzXaUC7FZ5cWLcVKsETRLZY2MHwAbwjVcB9EFlrACYjgHcAoM27wGwAGMAIFTr7Iccz8Y6jafGhg5wUSxhx34EtC8w7vu8hntfp/ZweYlgffsW55OlgL47Au6+pmJxKwDaPGeAirb62uQYFoqaWyue1qeHXaw2LFx3A1z1CP5yFlVEvvUtdpnwvm/vUn0CoHd1NCSVB86ykoCDFrIWEvadO5o3PBxxDkuUGInUaBd0rPH2Ba6abuRUF3uyWAyioC2y2hEBWmV5lao2xj0vCk/94IHW53bqRKi7cGFUV6JJb1lciUCb/fC05Ufqcp7HVRMBxKKSaFlUtDBNvRrT7booFp9gGuhndtY+u8/A2/HVe3aqlNZliwLlT1tnEhg/qwcsWeYiICstJetOApukF3BWObMA4bxzk2Ao/jlZRvxzEvAm85pILxu42aYkWErWbcXy+LF6JcWBc/K642Ukry8OkNP6IXnNaYZHsm+T9cTzpPVhPKUB8WTfxtv+adOioDzetkXmVPKcrO8z01fZUxyG4TsAvmkYRkV97z3PRn0uKQwJctwRUaizpJFava6VDu5+jXlOnwAARl2+yEcdF6UGgVq+vkIvol2Iot097eiqBDBUq1wGv+74WK6aaLeDCLiKGsTmJiKwLI7L01MVZli96KcBN8UtOQQDAlp3drQSQrxeQEfjDQLg0Skw8IFpR22QK+rgFJSxsrSr2nFQ6sWGW6QsZLOUO1aecWrAvnaX3kmxEQQYl5SGr2kSyAnFQwJPbN0r6tDb/QE7pX9NwKY2ZaG2ygLEYGm36bltKUrLN38GDM7sACsTACZQqgL4WRD0JlKqDpc8skfA0gTAYwB94JULAG0AVWClTRB+cAA4SyhYFsdeQg2KREKxAPjqN9PUHlkrr8WY3REmPZeKFVALDT43ZYpBkld36WhIvrFs3BM5u503yNUG9EYyQO0dVTSYUlkmhKG9w6KeIpp2MnHsAvN6Yx2qefsWAX+xpPWLrTzefpuSJk9OgW++oYvxfY21AUVlUCh1etpCrmyjUC3C6rtRQJnLDucgAMDMobS5wrosixtLh7p/Hh/6DMddW8K0Rz3jMODvts1+aLfZ9Dt3NB6PlBIt4OSIU+noiO3PTJ9OfeIdfNWenTNSEmws8vJf5MWb5QWM15MGWOZ5ydJAUlqKl5cGuLJepEmwmFXXLAMjDfgkr39WSgIgAX1Z9Il4spG+2S4NLCeBZ3wDXJxCMQtwZoHVNECb/J4sJzkP0gwXAePxlDWX0tq1aEorJ96eJDc7q46sebAIyM0ybualWQbn3LK+aqDYMIz/aRiG/51hGP9B4jgAIAzD/+w5tu35JsPADa6CuEuDQKIJELSIFtpwiItjbgrb2uYmtdvla4xdoNe6UkHG+IIvKVm0J6d8UYts2cv7wNYmvYoXzSDiUp41iVNMk96uMGBekV8THeLj41i0sjpBcbtNTdrV7SJg5hD2BxHQFYm2apUYrNvlpd3b08ExnpySUl2rERxsbwdYbqjbRyQWJG1uEaAK6qqu0quruKUF30ehc4nX9itAu43f+H4QeQuHQ9Yp2su9Hj2E0gcolmKuaVXH3h4R3etfV3SKDr22rXNe2Jtvsn7TBF7/BrjBfwvADgAXQOUTTAy5JUrq39dT8rwH/NwF8OP3FdVD8XBrNSKwR4+UXEUBCEb0csvKgetCQn+L8ZGvLqHgkd+aqyxpXnulgpXhiEbZcIjeiRvRCwRjG/Ua4E3gVEzANGFZ3OApAVVQLGLlnuKy+D6NmU6HChG+zzFuXdADb5pKPq6v7wnRSev16C0PAqBcwui4HUU0fPBAzy3PA752j0Wcnuq5KysZxkkLazWgVAwAK49cbQUV8wpBAPz8v1BEOHRx3XKxvF9XYaI/Aop9UnccUjNMk5vnTk4A1x3AtoEf/IC/t9uczw8eaCDcbmvakeuS0SLGqG1zmlUqAH6UMtQhPtGD/Sv97EykRV6YWV6qWQAkCbKAj4OjNKCZBJJpL/WkJ3JWioO5eWAlzaOYbF/a92RdcbpBGphLAsC08uNgK9mXViKvnSjHih0vJ+oxY78BOii9/PVVPV7ib/Jz2vUkAeqiADTZ7/HPSeCYBPSzAHAaQJI2JudyPKUZCrOMMvndShxP5p03zsnjWfdH0kgw8fE5gpTvyTTz90/47Pyi0zxPsXo7Yznlt/AzbsvnmkYXA75VfZ8gS+nKjvoBSlW6Wy/bgHfaBaDDGTcaVHe46gHFFkHsrW0wUAMAt3WN9b0lOM4gcrzdv683DwHkjq5vW9HOuZ27JQWUXDqtHXrN1uv0FtdqwHvv6Y1wonF8dAT8zFsKKKvdbYZtIXB95NRdIA5fkc11HOL8736X2O1f/Bd01DfZmIT6OjdeicfcHenIEJsbwMMP2ChvrMHs/R9pfV2lQ3xwAKzULcqtFQewbT/ybIsRIBHYIvrE6ZlGM48+oCdYVCLKS0Dnqdb+Xd/kBrndXWDpLQA/FxvhNAXNzyq9DiAHvPx3gL0elRnKJeW2v9ZUiZMTfpcIdO5YgeSKjlFtmkDvGo5pIuxd4+nJAKsHhUgWMDx5AqNRx6hDb7LnsVjHAYyiusZiIZKVW8YZJcacIsdi57bmT0tqngHlMkYnHZgPjlB48y4nwfaWDmSjdnSOOi4uO8CO94jqEQ4VG+J88yWHbep2eWkXyo58911ENIr1BvOsKuPr1raPl+9ZgJmHsXsbq5UuYOdhNDaw3DrH5LSN/GYAlJcw6Q64KmPngWoVxnCE5fYFvlbxcXZKWUHXJbgtlXl/SqBK4S3bNg2znR2tciGLDr0esukTCD+pAP1X9tkpaVavZAG4JMBL6/bkC3oWoJzl/YoDrTSQvAggTrY1rV2zAOosI0B+jwPBOPhOA3rz2hYvM8nlTYJC+W7hJiiOg14LQBFcVMur44Y6VlCfAUCCpLsgOB6BYNpV5biJaxdwnLz2WQAynrKAaJpRlZV/FhiW35PHk4bePGA8CwibiXxp9wdSjmfNjazz035PA7OLGm6L/v4pnp1faJoJisMw/L+qj38vDMN/HP9NbRh5YZNhgMvBm1v6jWiaKG1Xos1YVfcxcrUVLtv7U7z2RilSJahW28hVSZ/otwYo+Nc4V3hitTWAU7XQaHDH+717iHi+lQqQO9gj0DNzQF1FCCuWUC67KJX5gl+v09u1VudLf3NTe7wEWC6V+bLv9QCzD5imC4nLcHSkHb0SZtkwCUr29ljG669r1TnXVd4yZ1lzhVWfMJhJThOPX/86cPyYXmOlW/v0+FrFqvAwVMvclx0VoaxxhVaLOLfZVHEVXB1K2qkXCcgOD8m5PT5WaGotBtBGdC0PB8DuS4BpAKEPrG6AHt3XPr/JA6j6lgDjb7Jd7TY5t6KsUKsplKg4sd5Ya48VizSCnGWet7cHHB3BAFDFteLRcF4am5SSKNWp/Rztd2tCURkKMc9zDtjZQa7ZpBe/3yf94c032X/FopKb2wJOHqOkuN9otdREmbK8TgfoX+OqSyBZsCnt5jSW0G+RqiC8XdumkRcJtahnoMh6iyRfscgxv+pRxs5vQEWCzLPdVo4IdTgCzBwVJMo9jHo+SvUlXmN9jeB++5aqbIpipwWA81gCUa7VNXUkCDQo/um3gA8faWNMJA5Xd5bQ7Q7Sh/kTeju+ys9OYHHQEvdkLeJpzSpHPmd5ppLH07xgaXUt6pFLticN/KalNDCTrDMLdKcBpTTg8iznpbVZvMLyz4IGymVwvc0GgXAeBMNyTg68RQwQGA8BDFSeAHwyD6CBugsNOrxEm+N9sWhKAttFgPCsuZbWj7NS1lgucn+knTtrfsh5WeUly0n7/VnBcLLcZ0pfUU+xpP8SwLcWOPbCpGIlryIBTAkSKhUdqENFN8s1akQgKvIZ0WcO6HSoUetMADMXRYXLqZets98ArDxWgjM4ThAFqggCtaQN6J1wAD2CvWv0etwcJbrDohT3tXukQtTrjKS2vU2QLEvAEoAPIPgFuNHqXFEV4rvrPU/L/9ZqBBATxevt94HCnarm9g7VJnkhpgrX4eQxPbWB4vX2+1itAVdd4qvNTXq2BYz86AHraDbpoRZH8ErD5pftbYLJ/jUtgL2XWa8oHYiXuHVOz7GVA5Y2ANTBx/Q6gDc/6ykyJ5ngK+N7wGqXbvdigfQOifLW2CDAFbUHO6+9tiIyLbJzwyHgjWGUi9rqibjtTwG7AMMy4TgBCtUiqoqPHCUJNS4GjFgm3pgqF/H5ZucjYFlwlnVURyXR0G9e41LxcU+VUsjWNjBpDqgGAcCyY4Ef1bxvtbQ9JfNwd5cbBkWeberTWKp1gB8/ClAuX6PSumaQGDXxRz0f6/vkrJeqNibdAYIAKLhH7LsyjVMJcPLGG5xvAC9T+PcSl6dUK3I3a6+HVw5MuqzNHNaDaaQZt915BPwwbZzDT6u1+ZV7dgIfBxBxcBLPE8+LWJ55L9t5XrxkWhToZHnZ4uWkbbTKal+8jrSXaZp3Ln5taSAs7t2N83KTlIf43zTvY/J7nDccP9/GTe6wBT7ZyiCoXQHggKDYAaLNrXlb3xqyj6A/JPBtgQA5vm3Dw81NdvI32dZ4ygJ7aZ/TjIBZgDJrjLPqwYzjaeVmgc9FgG1WmtXmWeXMu8fSvifzzTJI09OnfnZ+IWkep/hnAXwPwHqCG1dBxjalFyaF0OizvETKQPepBn6ep9dga6v8KwigVoPZakXxdEu1GkqnTzBxGZmLXj4DaJ4hZ2mPVb66pMssLxHcKf6yUD4tS4fp7ffpPHv3XQ2qRYJNNg0ZJpB3bFy1vEhObWcHgGXhouXf2F2/XOHSdrGoGAgOQXhc/o2yaAoUW3nKojU2gIM6vY++0qVtX/D7zm027v595CwPL91bwqg9QKGouaQ7O8Cv/ZqOviddECH5oQoN7CzTujg8ZCeI8LKrIs4FAYHz7a+DvgiAgPh7n/38WCjVwVvou8DOY0QbENuXQKNC40rUTOwCO+D2HQABcHVBKspwCLiK2Nq74jmixdy7UuoVeaB3hasuX0jhkIhz0veQl7+7W2reTmjoCSegXuc8k52YzTP2Z7FEsP6DH3A8fSpLhN0rTDxuhhz0Nc4GNHVjaxuYKu67ROpzXa6UdTqRncS4HxaBcE49aSoVUikaDTbNdRVoFbK8P0WpkmMb9/aAXg/5eoEF9q4goe2u2j5yllqZqZE2sdpQN5obRPN+pQpaacMh55AvChpPgP44aoQ160n4yTjFX91nJ7JfwknglzwunxcBHWllp+WZ185n8fbNAixZ4C0JxtJAeBq4k39xjmoyJSkQWSmrf+PlChBNAmKhSJixzxX1bxnAGoBKmffzcoUbfAF1bwc6aNR1nytPwyHgdQioR+CTOgegq8p2Y3XFQXHyWpLjkuRHx68pyfNNplnzQPorCa7lt2S5yXFL1pOV0gyitOvPSvNAdTJv2vVktSfLIJl3H89t+1fQU2yDxqGFm9y4HoB//Xk16nNJdp7Ay1lmAIfOUw7g8TEB7fd2CS5EnaK6yjymCVh5rN5taJ5omdJt+d4VEIQahGzfAlrnME0P+SLBNNoMUYzhSEdq6HSiuSPyWwBxggRlAGiZNxp6w1CpDLbfG2OlZmLUD8hdVtpqwvkUqa6LFqsUTzHA32VfVbkMxU+daFdyZVk3wBvzmptnaoldRTFT0QGdnSqm7W4EMFzlLbQsHaFM9jFS4c7F2u4Sv7gjDR7713yydjrsW9Mkv/j111lI2AOMHfCWvANO0S8qVQEsAVv7wKjDNv/Ud4DLM+3VDAJ+XvkW6C855fyTlQeJqlgssj/7fQI4b4Kw1SZfffsWVkxVpp1H0esgbwPXbQ/Lu1VNnu31FBVhXSNaf0raxOGhDg/njaMof50jyuW5MmBQYcO7Ohx3qUhvv6w4hIFWljBNTR07awLXPlAr6mkj5UnI5usecKRWDmwbqNddhk2vr3FVxszTg66UJzgv8oCzTDnE7SoAL6JtLJWB17+7HD2A88EgUpojdWWiJCkuaLCqgCnRhKzXgUdH6cP7yZcAv7rPTqS/TKWXrMT35Oe0crKAUfL7swDitLqezdP18fNm5U0DEMmU5s2cVW6aFzTtnCzvpBxLe9Gn0SZK4GStAqip7zubfLQsV0jrK5f5HBCe/jQgGJYFrn6fNKlrn2DYAAGkMntv6Bsn+d5xmk38+tLmlPRBcmwWMazk93kG3az+T/t9XpoHmpNtnFdGFmhPHpuVsgDxrPwLAeOvIn0iDMNfBvDLhmH8xTAMP/qc2vT5pXpdaTxNCYT9gC9mWff3fYJeQHndFMdVvHn+RIG2HLC9xhf5/R/q6BpWDqivw+g80V5OKw90r/TLWgEmK+AS8cTXQTwk1LOn4iLs7rLoaUCgMvbANikdrJIz1Ru9zBxu7ZxFIXMFXAsYls1uwr2UkLoMLmHQk1ap8MRiQS/32wo0F0ts4PExKQ3VKjAcIVevIgfga2YXueoyTh5co9PRTkvRO3Zd6aYBjL09oHmGcc9DEHgEPe/9tu53x6GB8eB9AuPmGVDzgMLvwidTmPis088CKACl94BbRwBMYG0fOH+f4y1gFW2Q7uEAvSfUKHYcrfAQBPQyFwuYHn6E3MEelUSsHOCNEfoBjP41UF6CbdNrK16biLYhnGUhlHe77DsJYd7tcmyDgJSMchF2n1x0obOEQ+oD2za9xrJKUa3SKzv1EYVnvu4rWT8bOBvyObhmMUDMnZrOJ0uuolZnmIjUK4xaldxrOSCu6U5HSfHVgN410OvR4Op2sVIzcdUJonsjAretc6C8hHp9AMOERuayDCPixY0NGnXq99zOVsbYfjKtza/8sxPzX6ZpL+osj928F3gWmFy0fWmAJw1gzwJE81IWoErWkfw9WUcaAJzl0UsDavFk4iZtIYDeWCfc4TggroCguArS6w4OeA/Lv7WGqVbxQhrXZg4YDjAa8hXRavE2y7WAwCPXeAqtSlEBvcYB6DlG7Ddpbxb4TLvG5NyYNUdmGRfzQHTyvKy2zSsreZ3J600rb9a9NmtuLGpEZhl+z3K/fTx9hXWKAQwNw/gzoD6VzGOEYfiLz6VVn0daWQe+9nPAtA3kNoDVPoAAGHUJ/ASk9HqKmznRL+1IIUFJcUm0Mt8iWH74Pne6KSSRM8EXNoD+SRfOG+uI5K86HcDKo/mI3i1fyZbducOiXZdYO+/YQBBgOPSRt3j6RkOVG+f+DtWGoU4HoyGd4Rdt8p3F6fbqPQv9Rz66XaVze1CE3VJLyO4I8CsMROF50Y5/+FMdNMP3b4Ksww/Vhikv2vmXq3BJPmcCKzVNcS0d3KLHzspj1B7QC9o6B3wfhZ06xidtjJtdvPeeCF4EALq4d6/L8L7tC/6w9R1Qe7j2vGfKgulbAL4GOgLfBtAByo8V+W4JWGsAkxbd/XCAjVvai1tT6NFxSKkIAuSsPNDvM4jHcRfLFTCQheMAjXUYroudyhOC4Tff5Lj0rxml0Z8QcMfjf4uXv1YDvvdzfHO1zoFiAc7wEbnMjgM4Dgx3DHSfYnm/jnt2G62WUksplvD0+PpGdMXLNot9OuRS6Sqogf3aJvDOu8DuDquSdOcO5QJfPaCRV3JMtt3OM4y0ZbEP+tc6uIi8jS0L+U4HYe8a3U4Q0ZKCADD7AxiWRf3wzRVej+sygt2eWm3oXbMRlqWUUwo8dnqGsHsFYDt9aD/dg/0r9+w0sPhS7qIvZcm7yMs7mTcNBMrxrPbNAz5ZgDh5bBbYzgJxybqyyk7WO+93+S25rG8lfo9TJuTvKiiXUgPpEi9tArd2qKz0U98CVze3b3FDtOy/sW2+I9wRaU/DAW4fHuL26RkqlTMcH3Pl6OwUaA1Zf3zuuCDvWNoTQIPjNGNqVj9ljWfyvCT4S+NpzzKGsvjmyTrjBkjWPTBr/ibbEDeg5F+yzbO+p5WV1pbksaSBllbezPQZg2LDMIoAfgV6v+dfC8PwPzYM42UAvwRO398A8IfCMPQMwygA+MsAfhrAJYA/EIbh0aw6FgXFfwXAXwXw+wD8EQD/NoCLZ76iL1UKAQSK7CgKSQFQqgEYA6t1YDzk4eY5X6rCSfR9ul8fPFARv9Ry/85t7ZES/m0QEAg6S5Teqhe5e0l2LNkFoHMZObSKReCb37ZxduShWtXBx0Tn1nEYxct1iVE3BKRK6OLWgJSH4TCKVj3xgHyMijEZ+tjc1M0Ihy6WN5e0VzYItKdY+Ba9jo7YBxDImAbrAojkNzcJbERrGOSforyEYndATrVpYtzz4HkeDBM4f3SNjbs5ekFVSOVCfRnV6jU3TCl1gyBALLiERAt85TOcD59FugAf9QUAyptuWYjEjNoXpFlcHhGU+VN6+h9+oHetKV3isN2Bsb0VccCxuUUQu7mheSlCLTk8BN56i4Fm3n1Xg19xo56ekiJUqykN6AL/KSqQUanQ43/wKst85x3N3QGHdTL00W9dY1XZIN0uTxEZtq0akO8AZUUP/q0m8IpDQDwNaJQJVSeiiruA7wdYfr0GNM8Q9pV3V3TTpP+EZgRg2r2Ogr8EgdYjtm3g8v4VHh8D33jjCmEQ7RvEautCaTQvIdIzVPfM+PAJCvU01TSVwk8tK/QVfHZ+PCW9dLPAW9bxRQBf/IU+C7TGgUOybgErWQAHsXyz2pPlqcvyQiaBW5aHM81jN69di4LrZLvEY1wAwXERwGpZcf/rypdz9y7ffXt7fP6UquoMW9U0AMIxn09q383m5hlcl7fb2AV6Q5YtUmyLgLKsa096WtPKSfZjEoAmx2VW/uRcSssrv8c3RqbVM68daXnj+dKuMy3NMwzj/YgZeRcx5jLTp392pqUxgF8Mw7BvGEYewK8ahvF3APwHAP7zMAx/yTCM/wrAvwvgz6m/T8MwPDAM4w8C+NMA/sCsCuYZ+pLWwjD8CwAmYRj+chiG/w6AX/yEF/WJkmEYv9cwjPcNw3hkGMb/Th172TCMf6qO/VXDMGx1/E8ahvGHZ5coNmkOmLZA4CLHHQCbQOEWPUkWFSeiyGmWBZg5IAgJaIJAAWafG9PMHAEQoDVpDw8Bb4zLExejjkugcnyM0aMnODt00WzqwBbToYdaTfM3TVP9509QqC1F3MxKBWpbvwrdKyoCSoeqWASW6zaKRUSSaACB5v37ih6s6uy3Bhi1FLgXcNa6IGg/eaI2BiobqlYj8mldkAoi2rYnT9hXrvJK1tfp5t69jfzBS/QylEsoVGwEAb2M1SowOu2SXeCOMBwC8Cd0mm7Sy+B5ET5j2XYB9GtcPtMcer5J2HGn4ALhNpCvK+5zFYDBOfL0jN78/kDtXHtCgFxZJggsMpqcYVtA+4IbJBtF7ek9PeOc9Dz2hWxSbF2Qd12tcjyaTY1cpb54LG8J4VwsAo8+5LHTU87VgwN+r1RQ2K4hX11CfrOGvM0xcxwWdXTE26LZVLrdSu3hxx29DXIaAFe+lmWTzXHdLs+96gGjX/8tTE5akYwbnCXOadEwlE2WjqPtIpuCH5JaLS0Nd95k9nxEXgwQxYIGaMwpqUHTxHxvhiDwRf/dTF/os/Ozf27eTEHicxIgJvPEjy0K3JJAIkj8yzpvVrlJMJP2e1Y5SeCDjO/xY1mgKpkvnj/NM5hsZ9q5yfqy2hUfK5Ffq4K33XKFf1droEF+8IoSAn8FXKHbV39fAfAqn3Mbt3i/7u5ieXsZjYZ+VVQdli8gXJ6W8b6IHzNxc1OgtDk53+aBtjQgmtYnybmVlictJedClpcxafQk52+aQYXEb8m2xts7y4Bb5NhzS5/u2fmxFDL11de8+heCz9S/po7/JQD/mvr8+9V3qN9/jyERlDLSop5iCVZzZhjGvwK++WsLnvupk2EYOQD/FwD/IoATAP/MMIy/CeBPIt06WCxNOnxzBgHgnpEiYZrAitrENT0HHvyIHj1vjIijKevBVg43dhMVC9TWPT3TABJAJIrqTeD7yniqVgErD+voSRTDQfiWcYUsy4pxLlU5eQD5YKrLP3nMpS3bZpskTC+gPMxe1PRKBYBpolgMcHTElXfBStNAtbV/zfJ6PYL7nR3WIfzY1jnziRZvr4fRENR49ida361cInCrFJUHlBq+456HlbqFYtFHocINYqVOB7ALWL1TAdwxikU36rZOB/iZb0OXaVmg4ZLFA/0ikgWgqf6eA/gQeHqkQjuPVHS2YxUIZYAozCHAY+6Yc6x5DnhjPG35lBUeAmuNDQI5d6yMnwkQ5JVaxZiec+msYgl44xsMpmLngW9/h79VVzgGGzvAoEuyYLHAcd3ZAYIpIuupXtdShO4IYb8Do1aDsws4/T4+euhFFN5ul0ukEafY073R7gPVImAqqaaaTY9xsUiDp1JhN5RqlFJZ31vXHH2hfgwHai4XgONjeB775B//Grn3zSabn1NgWG67bpfcdcsCInkVqL+B4rr1ehh7QP9kQOWKtPTpN4ukPjsNw/i9AP4suBfpvw7D8P/0aSpJS8/tuZlIz+JNEmCwiDdzVkqCjFkv+lkAMV5GVp5nqTutLbPAcxpoTqsreSzt86yl/SQITs72HJQmsROpFHKlcnuFN+vtl0F6UQM0+vMghJ4CuEakX9Fw+R6t1bDkXMO2+TooFIFy/6ZMW/za4+AySaGI5501Xsk88f5ZZFyAm0oW0kdSX7x/Z419PF9ynqSB9bS2JAF01pjH2x3/fRHQn/b7Z5qe00Y79Vz7DQAH4PPtQwDdMAxl6E4AKDF73ALwGADCMPQNw7gCKRZtZKRFQfGfMgxjBcAfAzU2KwD+/We7lE+Vvg3gURiGhwBgGMYvgRbALwL4t1SevwQ+7P8cgD5IcZyRlLfooqUAgVIJWK0hmoa5Gt+svs8lZdF63dzUElt7eyxOonO4Y+DOqzx2dAQcHZG+UCni6uQ6ioxXOGkhX1uOsIw4s/IOnyLnD7qo13UYXwwHfFopigHMnPIe5vj0OjxU8lJqWd4dc19cb4DhEBEHtNPhkrXr8mF1/z55nq2WCvt8co3XXreA0ycIO10YzhK94XYesAuYvsMNcDkJ5mFZmPYGKFWs6ELCwyMCeeG1CmcW3JBRuLtHviy6vBYxRjY3gF4PYe8a5TLltESvOQwA4403SES9dRv0VHyZ0gh8MZwC0x/owBnOMjt6OKSx0XnKzh4OlDZzH2HvGobJZUZX7eIeDtllL+0B44cfobCtbNDWOcscjigBOXRhDNUOl0aD86HdZvlenm8ib6yjszw5Am59HcAY6J9pvriorMgqgWkCVg5hs0VKQ5M8+unQg20T2K7WFL17k6eu28CFAsVPAPxsDfhRB7hXVwE7fK20d2NaCAjudtmOxgZ5+Vae7VC8n3HrCq4LvP9QUYIsTZGwLR3l8c03eeyyQ+/xS/1rIAh4jg12brkM+BNctHhbhV6awBLwGWhtpj07/xhSwGoYhvc/TUUp6Tk8N589pYGU5Ofk9zRQlAYu5tWX9j0t/6xjswBGsi1ZbZsFiLLqfRbvcFa/ymcLN9Um4oDPhKZPyL29rMAx6mvAzi0QDO+CvjATBMQV0ObLgdv0AiA/BGpDoFyCU6HzpVik0Sz8Zak3DfxG+2ZTriVI5J9nbCxq7MTnx6wyZbNi8px4vllgXVKWoZM2j2aNa9p8kn5Nu55Z98yiRmpaH2enT/TsrBuG8YPY9z8fhuGfv1FqGE4BvGkYRhXAfw/g7rNWMistBIrDMPxb6uMVgH/+s2zAgilC+yqdAPgOMqyDMAz/k/lFWgS96xaAHXAqyeJORX1f1goRtRrBxt2vaQ1YUa4QVYp2WysJFEuAN8FoqPCI6UZez41tE5etAE5wfcOhbJoAiiVMWl00GoBhmUC1iunDQ+Sq0BvbJLOsY1cqBET9ax7vXQGI9k1FSRTnBCBLUe+8o/brDbm5YtTzUSpOGUZ4OGDZnofH3z/D7btLSs7rKU8ejpErWjxnE5ictjEcAitFRcNQurIRP/nggJ7S3ZcItDsdyijs7anwyGMYlWXklT6vYV6j3QY27qxoIBk9xr9MqQTOH08BUqVP5E91R588JuCUYB2VCg2y3jVg2+i1vGgTG8Du6Pd5eqHXiVYZnnauuKdyCGxsAltBi1ESrbzaEJpXFBOozZFL9DT3ekSlAGkcQicoFuihPTpS59oEwYo/fnYKWJYfNblcZjtOThSGHnL+NJt8Rcqa1lWPvOKColUUi7ymnNo7Z9gWymXF9ZUk86VY0iGyq1VNXQLw9XvAA4WVd3Z0m2QBp92+GZTxqhNgZa+KvIThs/Kkq/QHWG88hlMxMXFnPLw/hbcj7dmpNIzTwOpnDYqfw3PzZpoFbOPHsl6g8ZdxFjg1cbOMeS/jOABfFBSk5UnWleZlm9cm+S0LqCTLSisn7dqTZWWBmmT7zdi/JEi2gMizm7OU5KdtA0vLIBhego5tVwGfefK+vFR/izpalGXBcbxoMbVgAXlfe4rT+jfZ7vjcmAUkFzEykuWmGWqzzp01D7LO/TTmdBIEJ9ub1e55BtiiAHhWu+YDYpWe/dnZDsPwrUUyhmHYNQzjH4DyT1XDMCz1XNsB/TJQf28DODEMwwJj0czkXS4Eig3DWAfw74EkougcxY97QZPsg11X3+XR4IFcbgdAD9GONLtAl2rnkgPtjgjqZNNTfFm2rF7yB6+gVLlAqXMJ2AUs71WwrHbVi7CFov8C4DL0mncVUSjye7cBEBitOBNE2mau8uR5wA2CcaUCvPceRj2fUYc97R2Wunyfn9cbmqtrWcD3v8/LE2ULeGMNmpReW7kMPD2hSsZyxcdlm8tiAHVo+w8eo2Cr66mvE2xJZLYgYAUSuc6fave4RH7zxoCzhMnhY+QrRaBSwcS7xs69FcbKjqJ+5ABsPI9J8SlSB1wcnJB2EATs+EqF86HT0WRaABFnxspzrE0TjsNsIpvn+0DnlEUMh7qmICDnT4TzT0+B29tDAkfZZPfoAwLLcokUmO1tzs9yGTAPOXdFVFQiOVp5AnrRpi4XYPSucKnaJF7srW3Ok/19rWp42aG9Yx9TVnAj9mQRpbg33iDu3txUc7oIBh0Ry9D2yF8US662qjSKbaC2hkJ5BCfoRrR3gED49dfZB2t1bfR1OmybaQIrNVNRbxQvXowxd4yC4h3ndxrpwxoCYRCm/5ad4t4OC8CPwc110it7AA5j+QWsfmVSEtQs9AKNpXnAJVnuLK9aPH9aG5N5sv4m2yYpDnjT6kh+TgMV8d/Sypr3os5qYxz8xn+LA2L5bpsRlqXUo1iyyIFgOA+9Ha8EOiby0CrEXR7PWZFDZBroe3Xqc0Xdg04WuDU57Tric2getEoDerPOSc6becZFWkoD7lkGWbKdWWM/r754ObMM0nkG6Lw6FgHcc9Mne3bOTAqLThQgLoGrbX8awD8A9d9/CdzM/DfUKX9Tff8n6ve/H4bhzEYtSp/4GwD+EYC/B5KIPu8kaF+SWAJZ1sHHkiJXC0EbtdoSgNdB/uc59KPBBwHOBagn26MneHeX4KKxQfB2/0d8yW5vUVu2+5THRDbLWVY8XIs843IJODmJNGCd4RUePtQr1rUagWqzySXeahUY3/8ITtXC4xOg2XQpYVWxblhfTx+2sbozAgKigeuOf0NEvd3WHsfHJzwnZ+qowEriGIByFFps/sv7HkpKvaLfcmHbbhQMREJ6jlxdvrPfgCMKCpUKlTiaZwRj4rUU1GeawN5ttVs5R45sY5353BHyd/bYmH4f6w0575KNfeMN0JC5BD0XX5ZUA18UTwgs7YLWdN6uaq85oHjWFY7jo0fo9wGv42JjE3jtnompF+Af/kMaHKUi8PbbnB/DIfHhh4d0rI8VI2JnBzh7p4VGg67SnGjwAsxQrZKTfqDUOtqXWrrPUnxkb6LCShfY35WK4iZM8fr3xvjo3StMfNIgBn2l8uYRKMtLVERZhkOg2QJ+4ecVPQJsr+cRk29uKqC6uYXIOtzbYwHemHdp65xzp1hUQU0YjKRUfIhSr4dKZYB332WWw0NeYhjwNhWlqG6Xv/d7AXJmgP7pFfp9dazP+bu1iWhz6o9//GMYhjGIDarz01ufyFEceTsMw/g1AA9BDpw8O78LqmA97/Spn5vAx5+dcVmtZEoDNVnH4y/YNGCZ9JAmjwdIryPNg5jW3iygnHbePFCdbN+z1JHkqmYZE1nALc0ASMtr4WbfSTLkmHKaeJ7yhwQBb+anF8BqB6RMlEBQPFGfh+C0HoLc4gFw1QV6PUz7Lq57vM98n+A3PvYAAXLympMpa3yT1yn54kSo+PxJXruck/TiJ8GtidnzAIm8yZQF9LOuL0A6RzjZpnh5yXmSBpCTx9Pan5WyjDtJn+Gzc17aAvCXFK/YBPB/D8PwbxmGcR/ALxmG8acA/CaAv6Dy/wUA/61hGI9AYPcH51WwKCguh2H4x5+5+Z9d+mcAXlVadE/AC/u3QHHYNOvgY0lZBxGKeuutvZBgWFQnrsHln/ij45gva1knBviyFs6lnY8i4YVvvwPjzgFRgsg81Ne18oSKLmZYJtC7iuTRBJCK5uudO8QI1wpMOJUAYcCHVLsNrAY+ciYwVbONqhIDblZSbXz4UO2TUsvJ777LQB9T9cAbe9rBLV7JjU3WKbSKixbBgwDsbhd49Q4Bta2Ww09OqHMcBFCBPWzqxDodpRKh+tZWy/rHx/QQO47yeI8VLzkfU7tg5DLc+zrQ6cCpjbi8XizRAOn1SF5Fb5F58zmmEcj3X9KecdOkV/zBj9Suspy+9m43WibwTruRSMnUD/Db7xEQ/+bbBLyS3bbpkV12gNFQrzCIUZWz+D5aefiQnl+p0/c5J/t9YONVbgQVWoLdjeQCARBVAjriXq0GPPwAa/UrvLRv4vw0iPCyoW4J8WKbJr21nYfAwT7bLN5agO0X8YvQD2C0LygDV1lmeyXzyWPAHWPy/XeQ/95bKnqi8vQGU8A0o/g4773HS5PIe5ubOlJeucziLtt6T6itlFckWE0YAI7jotl08fLLP43Ly8sbltZPbxkIPp0b4GPPTsMwTgH8ydihucD0E6ZP/dwEPv7stAzjhqcl62W7qOdr3ss667y0+pKgJ37OIu1J8+JleSDjICUNTGeBnHi+WZ+z8iePJX9LMy6S5wlZUJJIpY1i+xque8Byf8Bn2GobXD3NgSupAJ95Y/Dd2VXfe8zfH0Rg+LrHZ0QAQulA1Rf3EAuQTQLGLGMo7friv6WVkWVIpJ2fzJNsm5mRJ54vrd/ngf9F76U0MCzH47+npUUMxmQ9yXPjvwUAXn755efx7PxYCsPwXQA/lXL8ENxDkTzuAvg3nqWORUHx3zIM418Ow/BvP0vhn1VSuwb/lwD+P+Bd+d+EYfhDwzD+ONKtgwWSDwLiIdgNIbghsap+fwp88FBF7DEVX/iKgMIb08sFKE2qMxiVZYQPVRCEzlNgZ0L6AIBJd4B8raZUIabot12cnGj87LpaiEAYBfU6/069AI4TYU487fC3qa+BwDQArltu1JzNTRVRyNLg6eFDnpezCIpbLeYbDOmNPG9GEadRrUZ7BCMpLd+nZ1Kim/V62itYLoMb7voueWhBoIMjdLvcqGcamjLR6fD3chnYvU1ALCGdxQXpVFmZ6sNItcG2oeMhfZmSgPQSsHUbuGhqPeBHj8hP2X2JloYYB70rXLY16HUcArYwAD46RrQZUlKzyS5ptxGpP5gmx6FQIzVgpaH6S6IyehMVeOWSgNI5Ux7ha/b3mppMG7vaxVpZ5jzf3OLqiGnAaZBLvnGvivFpB/0+PcYA51ROPTl9nzSKTodtbLeJs9cVO0HoNcbeS5FRELXn0Yeq3QWMTjooba5Qsi6YckWhWML0lNJtsjn19deBH97XwDsI2MXnLc75RoPzV3jGolQny8SWxeGI93MyfcoVwLRnZxZY/UzT83luLpZmgZK0l+wsMPIsdc3LlwVKFgEIs8pbBEgv4m1Mpqztn0gpbxYISub1QVBqgn5f+T711Z5gtdK47I74fJ72gFwX9A4DpMib4HNvBOAMwCUw6SqpzqcYKGdKv8/nwgT85+Hj3lxpf5rXNA4AZ82r5DlWSt5ZaZbhIikNGMv6cla++LF5aRZolt/TAPksYyorX9zIyALds8qe9xvwqZ+dX0haFBT/UQD/kWEYY3BeG6ADofLcWpZI6qXytxPHUq2DhdJ0AkpoDYBwpF1HZpcu0E6HKOXRI7qjHEeDumqV4Zz911hWpcINYs4Snp4MsFpzyRKsVBi+2APyp08w6gcR9UA2wS1X6JUVGTZxIALAN75Lw+vle1O8LNQE38fE5Y7eZlN7yZ52NMYIAi6xhwEi5QnD5KVI7IL9fZ5vmkDX5CX1egQ41wrs5BUgljgQnsfzpd6452869JArWrhs+gzdK55gFQI04mUAiKgEzpLeoCh5BP3v3KaHHWDjOh0CYwDar/FlShvQt0aRoL+2xmuMS/g1z9Qmsj5pEx6NmrylPZjf/z6VHYbDmxTkRoMvGNsmEDZNAk7PU4bXdp117e8TjFerWhEF4FgIlaWyApSWgadtYHWfbS4/0eoVog9o5jjYotBimig0VtA95GY/WXGQFYZqlXNNNtP11VwqFTVVx7LA8azVohUUbG7xvjt9ApgmSndU9MJKBWhdRpbao0eIgtxF2tVQewObBMRCSQK4iVQEYmRVRuLTyMbTyvN9iqU+O0EgfAOsPo/KP/PnJqKwRzdSlgcpC4CmeVnTzk8rW1KWlywLOMTPSys7rY55wGhWOWl1zwMYWcApy2uZ1tY4SJsFsnzoJ6l8Hg41LarXA7a6XRX5sghsB0B+DD7rRqqmAcisOQPGbeZttTDquDg95T3pusDQ5eR3oT3EMk7S3uTYmonjixg1aRsak4A6bW7EjZs0DywSeZPG0DwwOy/PrLFfNG/8+mYZD1ntyrqfknm/6mkhUByG4YyQTy9omkyAs9/mG/L0jE8DxyGYaV2ot+7TiB6BRoPgQlylw4FWDwiU9Xx6hmqVILfUv0J4chUFE1gqB2g2NcD0fU1dyNuacSHqavfuAWePBliu8OW/0dAvcjn/te9WcfGwi8fHfPjs7zPvk1N67oau9tYZpton2FFWe4y2UVHAvFbT3FBpF6D1jX2fwFq4xeJty9vkK4eBj3pdeZuDFnK1Fb2pSbgi5SUCL+Gy9q7Zh9u3NAm6VmP/ClD2PN3vpgE+Xk9AetGXacNdC4AJPP4RvSvBlIOp+A39dw/h7NYwaXYw9oAnJzq689ERu+ejY47VxOPCZJznV6+zz3s9zZf1PALC4RAwD9twHMA4PqYumWz4LJfYv2L5iPv/gwc8cTigzJ1p8l4A6KGVc8VKG6poeP1r7O0RUMbZINUq23h0RO6x6xK0WxaXZUWvNLf/0s1uEy5EbU13RhDwu+Koj49bVGxzIzEU+L5mqhSLOn6NMFdkj+yvv8OXpQ8tC1WwSENZq/Ov3H/J9GmlNuc8O7+QlbfPIiUBStqLOPlblucpCTKzvs97IS9yXrJNSaA0DzjMyzMrzQJEaZ8X9TbG277IOQKCbWgw7ILQtqS4+Fc9PlfOTgJsHR/r53djBCx3ofdQ9AFcAZfnfHafngLNsygYVb/PsjwQPouXOI3HC9z0uKZ5k+Pfs4yvLCMrnjfpRY6XlQRFaSBZ2hbPv+hjYtYYJedr8vMsj24a8I/ny2pLWv2fxXx/TjLFzz3NBMWGYdwNw/CBYRjfSvs9DMO3n0+zPo9kaBBg25omISFhrRzw3kNuAKutEmB4Y60a4E8IelotrhGYDJIiCmO+T5DqulrxQcQTxNM3VttwC7YGvK4LfO97xCov7xOsrlQQeeV8n164lYM6wlYbv/7rBFF5WytMlBTdoVDU+sMCwIVuMeiznGFP0yMAeiinqg6RGJT2//KvEOyIjq4AY8fRDr9mU+1JbAPl8hVu3yniqunCtoFSFPZY0SpEviAKeW1zU2O9To1jy6Jn05/y4g9e1TrNaIKbIb9MoPgUgHJTBtOPhcXudjv40f0ODg/ZR8fHHI/zFvs6CNi/63UNglstAjcZv1fvAB8+YndIeGPf58tHWD6bmz5KwxH7qlymd7q+rgalpAyVS7UJdJUT8/qKgLdSURrBluZ8D0c83/fpCbJt2LYbGUA5S69yGKbSBw6A3/0L+l4AOE8KjRXWGYlz51i/o+4vCTzTVtEUazX0j8gtEu60hI0+ONCLDqbJdoh6iqyk7O4CJ11uBZIwRj4Ay1/wgR3iE/HivtrPTqZFPGPzPqeVlwVqFklJgJA8Lw0gp9UZP/ZZeMeSIDCrzDTjItnm+DXOAjOIfU4DgVKGD5IIB6DBmOsCTlMH2tk6PNQvgV4PqCinkePwwTMc8HndvgA6HUwfHUUh4Ntt4NonyUK8xEGs3vg1Z4FcyZvMk5U32VdJ4JeVsgy9WUZZlmGY1qZZ90vSaLRw83pnzZesMf8k83ZRML1Q+oTPzi86zfMU/zFQiu0/TflNQuu9mMkbA8ePeZMLkXY4INprt7mMe+cOdzo1lUZqpcKXd3kp2g2PWg2ortKrXK9j7Y4P6x++g4cP+VAQcJyvr+Di0RWpFOq0fNnCuO9Hy8AihyyrymenKs7DUGPxep1Ao9ZpY7UG/A//TUpE/PhRELETLAvR0vCrB8BFm17JINACEJL29vQxxyFYln2BgltE3tXzgKang57ZdkwbtgPcvaPBsXgxgwcuXnqzyqX3/f8/e/8f40iW5wdinwgGgz+SZLKYTCYzi5WdnZ1dU1Pb2zsatWZnZ/dWi9X5ThJk6XCwBRjwnSUfJB/ubJwPh/PJOsMwYMA4/4bsA84W/EMSIOMk2zppTyfbp9291UIazY76+np7emqqq3NysrOyMplMJotJMpnBYDDCf3zeN15UdATJrOrq7ureB1QlGfHivRfvPUZ83vd9vp/vrpKTy3Cx4SjNXjGX7r2hkM8aVT4aSi5vfE3AZprA2l0wIM0VgB+Du8/ffIkTZZk0AHAE4PcZLe7998NocMgXMDv4BL5P4CusAaERWJamGFw7XJCIYMRoxLH/eJ87BYUi8OMPNehzXcr4rVZoPY0GgQmjDu7tAffu6UWfEMKFzjIaETyLCXr/Y2327fXY78IrDNUzHIzHrLtUYhslSp1lUUd4exu4s817Wd1aQSglaGXYN/kcKRMShdHMhCTpSbsPADBNl1J1zTKCwRCFPOts3V3BbHAV/r6qVWJ/x2HAl1qNi8RvvG1jOnLxve8Bf/tvs20nar6Ks2jO1gpSaek5rR1f3WdnQoqDgfjLepkXdBQoRY9Fy42XlWRxiwKleVauRRa+ONiIf086tgj4zMsXB19RQJS0qIi3Lb4gSCpf8giHGGA/jNQ1DvhkvTrWoNZxfFQfHKLZPMRqFXz/iRyp+nFMRy7OOqTxdRSfv9Mh87iv/j0FwbcAYy/2z4/8Teunm4K2eH/Gr5sHOOP1pc3t6Pkk8JyWL6me+HjfdDGY1ndJcyt+bVKZSW29SfrKWYqDIPgL6u8XEbDj5SZRQxgNqXbQPgUGA4wOuyjVbODtX6BlMp8jIBAz73oTuFQgWvih/adaUqpzDlNZsbpd0hRGI6DoX4YOdWIYHfU9ZJUFuN+nRbBYRLjKbjR47s42V+2NBl/gAm4LJTNEV6WSi4mrneFE5arT4fey2louFvnAEt6w6xLACB/Z84Bf/3XugsnWvW0TUAhX03EITm5vaQOCD97b3bsExIZJgL23B/ZRQ3laiQTbBx9wSx9gP25v66iCuaJC3Gc8VipzS/3eN6B1pQGC4y86PQItxAeULhpf6dVQpQJ0zpGpV+F3+mHoVAnfLPgUUNxihQjEESy0sBZJa//Wtzh+vZ7eZSiVgPZYK0EUFMf8jW9tMGOrxf6TSkplznnX1VsLIqMnZt18QdMoPCW1X6th+IBxIC4HdODMmMBFn+O8UiLAFDBvmnxB3tqr0VrueVzojEYE6Ds7OpCG0CdUMJrRKBJ0ZnAJlMphc1vfuY3Z0RNk1IJCggX6PrDaoKOg9Jvlu2SHjIF33gHefRdoNYGTtgpprtK8oEtBgOdyFvlKPzuRbB1D5FjSSz0NrEXPJYHMm1i85pX/POUlXTcPqFkJ56PXL8IIcWthUluTrM7x/o73YbysaD4BpQ7oej4ETQ1PRtr/Zaqe84UiUC5dhe8BofNFnfO6XeBxh6zjS1XeU2jgHeUxx4HwsguMZc5LEtpU9Jp51ts0QJoEEtPmbPy6pMXevAVWfJ5G654H5NPmt8yBRYu8pLRsvnh63mfnF50W0Sf+5XnngyD4O59tcz7H5LoYfv9HKDfyQHEAjEaYDFyUmmXNJ65Wad2qrhLIVSrA8KkKEaumuXOtwHCHzmHj63B1tL1NK5/n0fr6wQcKJ3V0YDHf1851u7t8oIilVxzhrhVVQV7+jgOsb+fZjkoFyOdR6D1UFAVgbcvG2hZX71mbL/2oJnGtpuWqBHzcv68pHkLhjToyXQ54zHU1N7nXA84HfJC2wUCgnQ7LvlUjDi78+i9p6/r4Suk1P3nWu+nuN7j46HbZ11eXjKJUXNGLkt3XeX5jCgrFN8Cf6tzgNC85vQd6XT8BZscqUp0KU/zgx5gcPEGumgfMDLKNKpwjAuPzLmkSgkGrVa3iIfFSZAHT6ejYFkJPFopfvc4FU1nRcN/YZb5KBczwK79MECz6v0K6bWyQPiF0Ftkq2N4Gjj7hNqjrYtLuh4oXwmO2bWYtVwh6LwesXxZ3E5dzu90GXv/VOxy/Uklf2LrNPioWNFXCzumJP77GWiuP2cgJI1cb4Mt24iKclIFPq7AA2kKjHHLQTdMLnUsBKl8cHbFd3S6w3eKiDtAv9TROseS5afpKPzsjaRHIjX5POp6W4gAh7Ro5ngZGk/LG2xQ9l2TlSwJH8e+LwHbS/UcBVfS4gJ6kl3O8Hit2PHo+baERBYQCSt1I3lnk2LUDmPv83cjP2LJonJl52nAii8/BQBl5QFA8AjWdxnjWIuxG6o/3RxxARtud1FfLzKck0B0vM5rSgFEcTEev92Ln0sDzMotDO+FYGlhPAtJJi7i03+O89LyAOGzbi1z8BaVF9In/+pxzAYBX+sHueeo/Fco5t1XTyLNe19HrRldEi+0zvuR7T9WWrwm9Xw3FL/ZDQ6HrEvw8eMAHxdTT9AIJnpHPI9y6FYAk1wttQSgXAphsG1pn1rKAwRDnrBpvvKXe7r6P7P09ZN0pt7oODmBZPrLVFUy9K3z0kNmkbtnCHwxYvoQbFs1Kkf8672rQfHioIxTdr2gnJ/GTKrSgdJ3LAM5JhxCnu/GYbd+6rU3UzjWfvmaGwAlg30dlDHAI4G1QU9oFH7+PAOzhZjagF00/ASkTHoAOkKkAVU9LyxVXkKsp3nljHRiPw3EXjvhbb/F2ez3+DSknvqalVCrAw0Ngu6Gd6kyTXbKzQ9BYq3HcZj53G2DbOqy2RAt0JtoqXCwo4etzUn/ks4R2zhcAM4N+vx/uFEgUOtclIJ4qR7eZp6kLvs/vpkkDdegc6c2AkuIrj681QXowAJobus7jYx6vrcHrP9EBDN0JX8QmQu1ro0FCsyGPbKGHmGZogY8CXem3rS329xu73A2R5KW8iV/AWeQr/exclOJdtmwXxl/gN71OPqcBB0mLAHESsEwrKwmUzEvzLIJpYC+eJ8laGAdcSd/jL3yZ9lZCfgt0ae6MtR+6bSt1GVNH1HRdgueh96zT3pX650ADYnG0i49vGtCNA3hJVsKxpP6ZNzbxPPExjy+0ov0T/xwfqyhfOun6pDaljWu8zfPSMgu0RelFr5f0lXS0C4Lgz39eDfm8k+MAt3ZWtcxXfV29WNV2sTuNIFcVrlgcv3zFsfR9WtfEpFpicAHRPBUrcLVKy1nGpFPVZlO3QRTIZPJ4nrYgrjdojatUCIyvHTph9XogOOheEHC5EzgOwcqo66BUMTVgthUXt1aD1ekC3hRrNU2tKBSZNWvpWyyV9APv2gFWIobx1YqmVtTrwOAIaNSAox5wr6U5s48eKSt051yHEpaLfJ9gyJ0qEGyoQBI2t8tHIy468jnAV+oV3pRlAAgjJ2ENBMUfgBbjX/rM50l6OlV199T3KQfO90k9OHmCayVv5J8c4tbOKvJ5WlYBgtlzBYSjobiLRS4qXFcJo5zQUjrztUOmbFREtXlrNdJZ6CTp69WXZdE62+3qMMeFDeBOjd8lZLj0fa9Hi+tggKmnZZVlZ8MwOX9P2xp0SvAO2yYoL5XUuUqFY2hZXNxsqXZIUJfSCufH1ha5zONrwLnG5OBJuAZiABCXqn1jYFP247pdBD6LW99SpGC1arjoccckYzFwx5pa0El32Db7UxhP1ryn4HM6i3yVn50vKyW9iOdZqtIAUfRzHOimAcabtnEecFi2zWllJYGmJMA0D/zHrYRJ56NgzoG2Tkbz2KCmzhWA/ojfMyDgMUCrsg+C4CgNYww+pWeR4wKGk8Bs1Mrqxz7HwWv83uPHk+47CRBHPy8aSzOWN9rO+JgsWtikAVczlmde+6Mpfv83WUjOWzy+MDj+ijraAQAMw/hfAPhfBUHQV99vAfh3giD4n7zEtr3UFAB4eniJWw1LSYRZBMWSTFN52lZoGbaz2sJlWcDgnCGH26cEF6MhLV7FItYbBCePHvHlKy9eAZZiBRSHNVESyNoaN4o18GlPqxPMPP61bWjJL+U1d2eb0m/XYyBr+XD7PZSLysFJiRcbFj+bA0p3XStPixUF4ut18jKv+y42Grz9X3hbywWLpbOhtqMdB/jWWzwm9Ipvf5tAZXdX0YgtpY1rGmyrldFSYe1T7UQHUDvXmRAVSlhid6q5BY8+Uo3MALgNPor7IJ2iB9o1fvWzmiJz0hUomHYKWqynwOUZLbCPPlJ9voqCOUT30EexCIxOLjFxOH6ex1sUbnF0brTbvMWLHvv1Vg3wuuTtXkGHe7YsAmbbplU2n+fcydimlr1zJtqrUkLmDS6BvSxBqj9j/1oZzl9nwjlcrZLGUHPhODossmhsHx8TcA4GGk9nLO2ouVYDjNZt/p4qZS40K2WEnI/RiE/bwZBz4Ie/B9Gznikm0sGB1mKWRaNhAvB99HoIlS9MdUys4B9/6IZgPeAhZExOn0JRW7hEpSJyaWIA+wB4IV7cV/HZ+VmkNOCYBuaiKe26RSBxGYC4rKUtDcBLuWn3kdSOOChbBoikget5+dPuNw5Io/9s9deBBskCir1IWVGe8ATkEgMaJEfPS13x/oqWl3av0e/z5kHS/S9aUCRdM6/MeN74mCSBdTk3Ly0LRJMAcHRc09oxr4+WTcu08UWfnV9UWgoUA/gTQRD8ZfkSBMFTwzD+JIBX+sFumsDZsYeN+6bmUY595PwZ8P1/Avzar2lZreYGnYLGYxV1S8la9Z5qRONOgIcfhWEtm02+4HMVHTVLXsKyXS7ffZ9qE+KIJVvlApBE+ky+P6MmUCpj4vRC366pp7ieUvBYhSRXe8i5io3egYtqlYD4+FhvK6/WvDAgR6tF4LWzQ5AiEfh8n9Y394RtevQIeG2bbev3eZ1IyFknfRSaAYEXwMrEWnxwwIrzBWUmVWF8m5tU/zg4oCWxVGJfuy4jW7z1c0C1DxQ2QeUHQ/19X43sywLGT0DgfQYCYh/ABXD6hDQFzyO4K5XYCQc/xZ09H3BdzDxaere3nxU8qVQ4V7a3OW7CL35jV8t++giN/aFwhKN4sFlb01kyJYUGq1WCXQGmgPboq9dZsCz4xooaZOeI1AFIDHKZT+OxVkUBgFzFxiePXNy/z3m2ovjpQqEoVG29AyMOe1G6kYT6FkURcb5sbqL3wSlu1YCm4tGLqoZoE8O5ZkQ8tWjM2GY48R4f+uECQygoEhrbUwtK0+I4FIqaBw0A3/8BgD+cMOQBXnQL8Cv57JyXkkDfojzRY8/T3csA5TRAmrTVnZSWAUdJdacB47Rz0bTMfaUtBuJ1COg0Y9cCBK3Ra4XmYKnPIzzLc7XBNaQEcjFBMByAVuIoZ1joE/I9DsKTLKppoDUKVKPfk66bB1IROxf/HAfQSZ/nlRtfYN0EkC+aY2kLMg/p9xLvt0XzLOm3uGjh+an04s/OLyQtC4ozhmHkgiCYAIBhGAUAuZfXrJefRkMN9AaDXsiXpCXUwdYWUD48pMnTBsLQxeIBJd5qdlZZQVWQj3wujBqXtbUV8GpMWa0PPtAv+IcPiQkljygOCH7p9WhUy5jEMRLe1/OA40MPGRPYvFeA7KPXagRWGWUdC1QABsO2cD3wFJ534Hl0lstUy4A3xa2mD+QLWDMNwLaRAbDe9AF3ih37EkaljIw1DKPmiZPFRIFkAerC45R+tG2gsFUl6BWu9rZCz8ePFfEUvLFQJ7qjtMiuNY9Y+r17wZs8OgI++BGwtclK6+t6D/9+G8g9BAftXwTVKpad5knJBd0IfwjqImeB8/eB9Xcov+Ypa2v3nIum3V1GOzw+VgM6A+7fR2YwQKZ7gaZ/idd2TUwdP3Sw3NvjwkIoChIFyrJ0tOZqFfj+ESXzTQBFk923VtNOLrlGTvOzhQZx9xss8O6b2rFtpBQyrCz//eD3dJxxdxLOdc8DMpUV5P0rHB9r7/KdHRe9np7TQhd67TsNWpvtrKa6iEenbYfR6lBb401L9I3v5jimrot12waOPgmDdNg2nVVztgLldg6m6QHFFWSEUuO6GHb5WpdAIuI8Nx6zL3s9doPICFYq7N/9Y86U7Jwp8oJbgF+5Zycw/8U974WfBAjnAb94nfOAYFob0174NwEmy1j64iAkCVjdxDoZLQux72nAZB64kWvjgC2aV34GNvjks0Bzg6XyWpE8USc/AdLRv0j4LkA7CWhG2ycpyh1OAvPLgLw0wBifS0llJ52L9luUH52U4veUBFCBZznd8+5H2iJ5o/0T71ckfH+RlAaU5/6Ovqr0CQB/E8BvGYbxf1ff/zyAv/5ymvT5Jd/nVmo0AIBwDgHQsa5Y5NvZyioL14oWmPUDvpSFFjC4ChGCaZLOAJA7+vNv8WUsUm1Sh2yXZ21Gi3vnHa06IdJb4szgutoBLgyxrFQbqlVijFyFpkPXBYxiHpO+g1yjCgy6WGvwJk3HQ6ayoqKVqUAatVvaZHlySkBVX4OhAFLW0rK2hbzWodzaYh+uKCu4RDiTaNjIF7h1Xl3lwdZt9uW9b9IaX69rrWLx0BOlgr09oH/J7yqSGoN5eATEfqB5BK2W4iDPQH6xCVp0s+AjvnKDmdEHHekuQEbdGLh4RKfBfp9W4cFvcy6MrzVx3PaeVdowTbZXyY588gEB8fXIDyOySTQ6kenL5zkEh4dcuJy2geGA+V6zgCuPP1pRVpj5Wkc/DIZRrLAfBgN6eQqVQqgSh4fsq8NDtndwqcMW2tQlDhyXZZZWkLWzqDt9XI1J0xHQeTUCzCbbvFozeX09x9/LyRPltanUJ6Q/BkMN3Ctltms0VBSmgmrHKt7YuwwXg2s1vV7yvCvKg1tXpCU5LozSCsqNPAzTwY8/ZHumHgN0iNOo9LXv8zclURkBwFKLyKQUvLi14yv57FyUntcatqyFKskqmGbdS2vXPItkPMXzpFnf4qAzKX8cWKXVFwdI0b9RkJcEuhaVLSmt36IgNnpfHvg0NfFp8JvEHQY+DRzdWNulTUkLoTS6Rdr9pN1/Un/EAW/8XFKdSX+T8iXdzzKLqSQQPe+aaL74jsdNFoNJff+i6TN4dn4haSlQHATB/9IwjN8H8M+rQ//zIAj+fy+vWV9MEpAsbIiLg0us7QQEaL6vNHNLgJlRb2jN6cVYqSS89154SNQi1mp6K9f3gY2mBsyWpRkFWYvW41pN0WorOuBDlOIMhDRhXD7qMDgCFADouShVTHieT6e77Rquj7ooFIHA82FUyzDdS41cPY/8CHEc7JzrwA/5Aqa9Ic46DP4BEGCID5/8yyrL8b17CGXeNreg0NoKLYO2rZ26AO04Z1mad1GrEZCbJiYjD7l2m4hRZBnqdXbC3h7LaJ+yc/p9grA//ac5NvCB2TWQ+TFolJuBLLcqCHhrAMoAboHA9xSMjGep84/VX5V/qgbg+IkO8mJZwPv7ihSuVDO2Ngk8j4+VBXOCSXfIce/2CTIbG8h7pyGwFKOuqCO021xXlUqcM4HPbrl/nxEKs2oNUFcObbe3QF58vkBwCQCVKRc84gBqmuwfyyKgz+dodTcNLkiOjwleVd7JSQ+5io1svgBUKhi+tx+qZjw5piaxRD63bWC1pXSQRdQ/r5RRRkqCz7nmArO6Sku6AGSJHFmpEBy3T9mmyipKVgbXx73QsVBCin+oQO/urv7d1nEF1yWwbTa1BjegJQLPuyrynslFnTCLZP07N3jHC/Divi7PznkpyUoGpL+0066PpzRgnJQ/CQDFrYc3SUkAIwpm0o7Nu5dFn9Pyy/doXWmA3Yqdl2ui1AgBuFHLowBbE5pfLMejYC4KzOLtSer7ZedAtMyk/PNAnZVSX3w+JIHpJFA7D6DH06LFyjyAmrawSloEzOuHRYu1RelFcO1XmVMM0HTmBUHwm4ZhFA3DKAdBMHxZDXvZqVQitnJdYP3tTeoSOw4mSjqtVM9rfazRSKNQQYJ2DvCVh9z4io5hDz8CBoPQ6pzP8zLRlW23dbS6RkMJLygQedHjC/yNPeD3fgh84y7bmc9r7WDxlq/XEVqG+31gvK9AgQKo12OfvN+KidFRD6V7dwAARmkF8Dxaf8XpCeD+cmkFcCxaDYsrId904lLx4qkCbltbxFATlyBYAlJsbfGebu2sMlSzN0NoOvYVJ1u4IdUS4Nk6oMdgyJvs93mT7VPkKjYm7T5ytRUCJoAW5mJBRUNRpmnTZF3dMwLqRoMd3D4Fbm+DWsI/BwLfn4KAeAKC4TEYeMMFVTWfAPgZAB84U06Arks+8+iKAPLgpwT5vs/Bca61lbXXY98JTaBYRE7xSPonLnJ5AP4MRnUV5fElztpKlW5Lx9G43aJl2HV5/KcHPFavs2tOFcd7NCIwXK0rQLyzw3l4cqJUUHz2lxDYa2sawDc2qF/c6+lwykJa3v8YAHB25KLRcGGYRhhK2lBZRiOCTwn4QuCrxsj3FfXliuVXKpxf9+5pUezdXX6uVFhvtswfSb3ONrdPgUoFhW0Tr7V8PN3vhXxrgL+TRgOhQ6vvA7mShacdDw3lIGqY2hHxBz8ghxhAGKlR0hQc7igoiKbPSFboK/XsBJ4fTKal5+3i6Es+bkGN54t/TgKx866Ta5KOx8+l5YtbEuN1zWt7GhhLA1Fp5cRTGmCKAuOkfo0CXrEQx49H/8bLiC8W5i1o0lISQIyfj/ZrtK+ix9LqSQKhcSAab2f0XuJzIQ3UJpUTzSPJSjiWVmZS3dF7X6b/X+TR95WUZJNkGMZfAPAXQUTxBuj6/38C8MdeXtM+n+T7IGhTo2eatM49PXFwqwa+oOt1vmHvfoMX2Vn1djUQRsN4+BHQu8DTro9mk5ap9QbL2trii9xx+GLvdDQXt60sxhmT9sx/9i5Qr/G4YAbRLxaLca9HTChUimpVc1AFdxwdAU+7akZ2z0kvcF3FJc1wCVcsam3Yeh3wesBggOuRj4K6x1LNBqws9vauwvVApQI8PiYA39tjG1ZKCrTcfVPp3JoE2NVbSppLcUztHK3EYg4VS2W/T96Ac41Zp4efPKSFvehcYVX6u1Yj4BpfqUgWhnIoa+mIbP5MWRwzwOUDdnT7t5g3X2DdjQ02Onsb/NkPAKwDw58QYHc6NNWLxbxeZ73dc7bBUVq7fkDw53naI7HbxbDnoVyzgNEIUxc4O3axVlNR1OxcuLuQy2vlD7n942M9hqbJkMn1OqMXZi0fOzsqsluLWNfzPKzVh+wTd4rZyEHm+Aml+mo1trnRIFXBmwLNXfbdaBRGA5n26YiZtU8xG7uhw5znAdnBALmKDdelY+ZqRRugbVtFkQO01XnkcoHoz1jfgwdUadl9nbsQReEaF7R8BQY60l77lPmqVd5kv49qtRfygm2bc/3HD4CfN/VD1xx7z9CSztp6Z8Y0RaqO/RsFxRmQPpGaXnAL8Kv87FyUoi/rZS1SceCQBjCAF3uBzwOwccCzyCo4zzoXvT7puujn6Ms4DnSS8kfbmgY243mjZaeBbEAD3CjVIVpWfHziznNJ/ZuWfHyaOxw9t6iMtDkS7c9oe63YdUllxa+Tz3Hgj9j3myyy5v0mpC+Ey73sXI8D/vjxeQvB+Px44fRVpk8A+DcBfAfA7wFAEAQfG4bReGmt+pzSwQHwh35lRfMlTNIODJMY7LIPrDazOoDE/j7wvV+KeNRbtIA6E/7t93FrCwjGTqjlulLU+rOWpejHltb6FWuW6wLHAJrQUYN+53cIqMUIKf8EGCkMFhpN83nAsExc9nxsb7OJvg/A8zD5cB+5ezvKkqdc+wUQq3tHcQXY3kbBNAkgRU+21ULhwQNaG8dXWN0uA3hMDd3SCur1K5RKgFGvEaSK+kH1FkKeq4BkQG/VF5V2ca1GEDcaAc4EmXoV5VIfeaU1i3yB1ATL0tvyvg8cPQbe+nlu10tZnXPtwDe+0vWPrgi8xmPKplWrQFE557kucPC7bK8MTPecW/6ukoiTlYdImd39BsI9+M4ZpiddZHs9XB92lM+fF4Y/rVaBQsVC4NJSfj3wcKW42abJe5RQ2xLvwraBN+6qcXCuAdtGtUqphGZTO9fZtgJ8AJDPIXNvj/20va3Dk0vo5r03eL8Snk6B+2x9NUTimWoZq1VgdXyluNx5wJ2i3MwSnedzKFtZLhjcKa+r1dhPwhcaDRHSjXZ2NJ3izmu0wNfWSKLv99lGWWBK6LzSCgG1Ow3l+0QOznW5YJRFwd4esNrMA3tvotw5C+9vNnLQ7xOTS4S9w31Nw8jlgffbjIsYtx7H0ws6i3wln53LvjiTAJikOCCLW/OSylq2PUlANylvUr5FQCktzbs/uSfZyp+XDwl/56UozSGpTUlliBU4rf7o9dHjSTSEJAtxGkiMg1L5m2RpTmpHUkrqs2UWIovKiR5fdtGRVP48kBqvL20hJWM8b4G2CNQu6r/o988Ky36VHe0mQRC4hmEAAAzDsEDr+CubTJM8zYujK9j2Fcp1kjoty8dMvds9Dyoq2Loy2U6B3/gN4Lu/pAFX94Kotd9nPmcC4+QJBl0fhby2qvk+cYBQeeVFXSppKkTDZwCOTbU13Wyy+rU6gxAIe2M8Jih48IBVP3qkaRmDth9ifNFr7Z146PeBpnsYKh5sbdEFDVaW4LfTIWj0A8BWKCFfYNg1MU331L12z5HPK+cwb0qQUS/z+lpNoTrlmChu/qMhyxyNaEkcXCq5igJ/OSengHON0WE31JU9PuauO62OM5bT6SgL6ITBIEZDvagpFkiDEXBWWtFBQ7ypAlsq78kpj42utHLEw4dc4FTKQOccwegqtD5W/D6MvE2e9m5DeRkqoD4oILtVx/S4E0oql7fKmHSHOpR2tUraSqWCgmmg3e6HRujhQEc2FOvmWiuvbh4hmXwjfxiaQsuDAT5632H1A+CWO6VFtt8nCBU6g1y/tclzYcAOQzm8zYB3/jDHRSYHEInpmkGwfwDj/j2tplEsAPWf46pSUWVmDx4h89Y9LlS8GdvQjNA0jo7CMOjIj4HVPBdHsr3hXHNMBBgLV2I0Cq3W0ejqIr/9zA9a6CKeB9PUkaM9T2sel0o89vgY+FaTRvRqlUp/Sekz0Nr8yj07geezJMV5qknlpVmy0l7UUdC2rBUuXlb8exL4mJc/rY749UnWzGj+RX06D7QuAp9xcJtW1zxgFe8LH8n3E88Xt9JGxyvp+jjInAdIk5KJT997kmNi2tyJpnmLOiTUk3Z9tG3L1pE0T+Yt0NLa+VkB3HibFs3Xr7pO8T8yDOMvAygYhvFfA/BvAPhPX16zXn7KFQwAAX2QToCGRyB1q6YNgAAA5xqX7x/i8THlp9YbAP6+unXhS9bXyZNsn9Iq2dzErXwfcK6x9p0dVWCAzQef4KxNPDXzgT/0beCjh3wpKwpqWK/gumqVIXWbTc2AkBd7q0W8kc/TiE3vfE3TGI2YVyLUtdvkAq/VEFby9IQWtdfvjwFbBSk5+gTYfo2g8cMPCXxEScF1gcYGcjWPulK7u1h9+BNg701g+w7zdM/ZGCG/AlxEOBP+PX7Cfnr4EDAzmPav8PCh0AGUepdyJnNdAB90sLPTwdpelYCpVuPN27ZSN1DBQJyJ/hV2zoCjCRcqANFPv09wBijR32EYSW3WH2I8Jhf1yfFpiN+PjrRE3q2ai+sxUKl0UKkAxeIp1uo6EIQwPIxiHqhWkauvIedOlWxcPeSoX5/08fpdC+cnXqgxnM+z7pkHZPIW+1NCdDsToK/aLeobvo9v3DeBeh0FAfa/+7tsQLWqKR6lEnD/m1wcHB5qh8rxmH0lEQVbd7jIaHjPmk2daxj1OsdMqC9miXNdHPZGQy7+/vFD2DZQ3tsjr7pU4txprKvJq6JEdrvA6hqv75xzEh8csI31OoF0q8V7KO4iUyrh1vgKOD7G3bseqlVaeuU20HZg934f3S6HudPhUBum5mKH/PsxF1s7O7TUy9j+8q8A/8+nCQ+KF98C/Mo9O6NpGStq1PkqbiWV40nflwVDywD0JGtimjUzemxe2UnANgpw4n0TB6VJQDV+XRxsJrU5DoqjQDBaV7SdafczD/BH+8RP+BcvI6mcKDhdNO6LFkJJZQCftqqmzbkkkBxvixXLE03RNiwCqknXRcuN9218ngCfbmNS25PassyYzlusxfMvvSD+itMn/hKAfw3AjwD89wD8AwD/l5fVqM8lBcEzMmxPTgg+Dw40fvE8oDb2cXJCK+9Zh/lP2z42GsDkqI+JA7xx90kEzU5ojTNNggwgtJytFPky39rSQQN+9Vep2BX14ZMIdxKgYK1GC/LHj/jSF/+1fl9r2Ipcm4Bgifr1+FiDZPlbrgDZWhmoVlH1HjO6Xc9B4TtvAsePEfiAYRqKclAiipB9/UpVWSJVP3oe79Od6EAb42uCLIk0YWcBrGilCJGvAIBKBf3Dq5DuLNJkgudKJRaTy0Ob3YsrOtjH9jaBWX1NqxlIHglG0Woh3M4XKkGnE9IILjtu2Kx+Ty9SBgMtrwzQ2RCgskaxyD4P/AgYNqFFqMViDvCz6Nm5ExTqKxi2r57pBiNvA5UKMp6nLPY+LbLFFR3CzvcJMG0le9Y+JXgWK2+3y7/9vrLUe5rzLpSRfB44ueB1ShsYlVVFQVGRGS1LORlOCMiLRe2kZ2Vpjbeyul41XhkLLOvgQK/Kjp/otts5tYhcAy4U1WF7m/nvfVNpvanfj1iPxeJdYkQ8mf+yCyKLR0Ar+ck0A2g8z6sdm60tLWYiQUfWG8Dv/SDh+aBSALzoFuBX79kZS8u+9xYBnKTv81ISOEqyOM4DV2ntQuxcGoBLakvasWXBaJK1MKmPBPimAZm0+5ZjUfCYBODT2pwEhuN1p6Wk8/H2pvV1HMDF86TdyyIQLmWmAdOkBUdSHUngNwlUxj+nLZySrolf5yNZ43iZ31pS3YuuWXTP0fQZPDu/kLQUKA6CwDcM4+8C+LtBEJy/3CZ9TimfR3b7Flada6zetYHxNc4PhiFYBYgnpp6Wz7Us4GcHfI+Ls/zWFvQWvT/T0dpEgaG4AvhDYH8fhm2hkPcoyODTeeqyR+epU+UYJCGhJYxtv08lCpFoE1WCdhuhXFWppII3KKBQrSpK6VjvQgtf9cmJEn3I0+FLBDZsG7Tujce0WO4fIpO3cHbsUXq510V5p6ain2UBe6IA7ioLfPSRcuiqEE2OhoxM1z1XJGrFw/YDFeziApO+g2n3FL0eQ05nbbZZFDZE8EOECwjWQcumaRIA7+9rZCmAWLbkZSu+qxy8uuesoN9XihVdjHoujo5Y1/4+8fPU4wJJ+NqWpdUexJGrWOQ/w1R/i4oO0OkQGHa72iGzsaEdyzwPKBZQbswwHTgwqqts59EnBJrNTR0NTqgOElquVlPSf6s0dVoZ9nnrNkHso49CjenTYx+buyNtHjWlb7JscFvRR/I5FZ2xx/aLvEQ0UI3oxRWLnPilFeYtFhhde8xFTcE2Oe7b20oX2UUoB1FU1BU7y/5wJ5ru8I37wHmb91YsaJ6xlQVsX69Qamtwu6ehIbte5+/GU050gNYdl3nj+0ChvoK+ciaUWwK4ACu0avhj91Zw/t5jxfqNpRe0dnwln52RtOilOg9cLbIUJpW7CEDEz8/j26a1Y5m8i6x/8WPLWBLTPsdTUvlp7UyzYkbLTwNK8bbE71H+zQPV8jnu9JYGCOPXJrUl7T4WcasRyxftm+jiIsqbTpuTSe1LA5DLLL6S2hk9lrbgWmZ+p9UTHb9oSjqWdH30b2J6RS3Fc+/JYPqfGYbRBfARgI8Mwzg3DON/+vk07yWmICCIFVd738d60wydeSbKApUx+Y6XF63va4m1ZlPhsXxO8xmam7R6bd3m961NArDmJlCrhbzRQi0PNDdDUCs8YsE/4jW/0aCFulDUUr2i29psEr8MBjyXtfAMj9l1eXsC4DyPurbjMfD0EUHbaKSt1qGMl2WRH2qaqNWActVE+Z27wNu/oIJU5DTwtxk8JNRvdifawifOUienCpxeEMg9+ghwJ+j3gesx23k9ZoS8fl8bmAHgm9+hBm7g8/hFF7RI5wvkWLhT1hVdzQwutVXTndBhzptpQqoC7dP+FZ4c8/APf6jDKv90XztEiuZtq0V812zqf4Ui0LpXRqFR1k6F1SqBnzvRHpPOtaIuXCk5uRWgegvZEjm7GFxi6qp2tVVfib6vM9FqHiKbZmX1Etz3mUfoLfkcJmNGyxt1HQTdHgOgeFP2w8EBJ0BxRW9JOBOE5GQh3o6v2QmiLV1RToqOol+4E453rYZh38dgAMxcnxbdfl9pSD8l2HddRjDsnLGTHzxgnYOBug/ybWFZepdFNJdFLq5SAaqrKDdXwvDYmWoZrXtl1Gr8nVqW5meLr+Vag484AdLyu7qj2DfSr+u/ei/1UeEHN/sHfMWfnTdI80BZ0vdFVrJF5cbz3NSSuShFwWGSpTRah7TRglYRmFd/2qIiDXCngdR4O5LOJ+Vftk3xJIAyrcwkgB7/nNTmtDZEr0vqj3kLpXn9P2+Bl9ZXaWA1bXzS8sbzpfXnvAXRPPC9aAzS8ialm/yGnufZ+UWnRff3bwP4ZQB/JAiCWhAENQC/COCXDcP4t196615mCgKiIdla96YIPD8EwDlb0xlMBYwl2p3vk1HQ69G6SYS8oeLQAs+EnPv+P0WIhPMF0iJqVQRjB7CzyNbKYXStUkk56ytgKy/ywCfXVJrqOLqqZpNFSzRdzyOQXqtrIO84lEybuNoSnbUBjEZYa1q41bCQ2WqQR9xYJ4Bvt6lMULIJdNpnjHpXKulFQEVFqSsWeE2xwHxiRXSnumHONZFM51xZQychVUR8unJKk3l3l30gYY+FQiFdq/XpMqynUtErlMoqFyQqeEZoCt/fZyHHTwB3imm7h16PhySwyvY269ra0rJoG8oRS8Iti3PXaAS0vlXHrD8E8jmM9k9VhwcIOl1m6vfJW/7wQ1JRnAn7ZnylvSUVjzZbstmvQu8ANIfHzuqQ4rU1bdntXiiLr8cy26e8NzXG10pcA5WyttSHwVNUpu4F+0lULno9jpugR+GPjNX47e5qHetGA7AyoSG51wNmvUvMun1STWSeeFO1/bGuLfx2lhbnQgWYKstwvoAwmIdS9cBgwIF5+22Od7WK8r3bKFTVYFQqMHZ30OlouTWRqm42oVdXkbTeoGU5Y6sfjGnMfUzIYnjZfyp9dZ+dKelGL8slrhOLVfTf86a4RW+ZvIu+x9sm/+J1zAMpSeWnXSPlppWX1E/x/PFzaf06D4inAfB5ICt+3Iqci3J+4/eWxAeO9m8SQE7KF82btEAAPn1PaW1KOz5vkbFoQZDU34tS9J7TgOy8eqPzNZo/qZz4+WXSCzw7v9C06B7/FQD/rSAIfiYHgiA4APDfBvCvvsyGfS6pdYcj4U4BaEPi1tazXu7yTzzYxQDoedRDPf2gS+vdYKBD5vZ6wMOf8OXf7YZVrjapCWWYoMnZziKf19at9aYJ26bow/a2UrLaBl57p45yI498Hig38uEEsixg8341pBvUaiwDlVXUalrAACDAk2h712Pg/MTDdEwQNj3u6G17RTOYnXTYqLHS4u1eAP6MHdDc0B1UXyeKLK4Q1VerPCaqD2Ih3f+YoKd9iqB/GdJDxJktY2rJrLGyIE+6wxC0CjAOLZriVFYsKLCuZOSEqiAXCBAUC2w+h2yzhnqdoZTrdRVM74T1Cy0F0H0qFGGh6NbrtLabJnC530WpsRJayY284sHYOVJS8gVMDk/Zd0pPeNq91IB0dIXzYxezTo8N8jxFgxjzfoTOIBbikPOrAP94rMNNO9cIfL3IMop5nisWtCTe/j5vtnOOWe+SqwLX1Yhfot9VKmpeX6pth2stjm1mlNTdKJxfEqn75IRT/uyDDhdJ7TO24fBQb2P0FC/54owrtFs1LeU3vtKOgUJ9GY/Z8b0LzilJatUqv4epx7orFcoTyo93o0mr8Rv3baBWQ6lV5SA2Gs/yvxPScz7Yv9LPzmVemoteLkkgIgmopF0brzfphX4TkJh0bdLneLvTAOSyfRQHlEmAOq0/FoG4ZQB6tM400J20QElrbxIIi9clYNdLyDPvntOO+fi0U1wSaIyntH5NmzNpgDot3QTnzSs37bcS7+N5AH8eaI9fH01pC5608X2mvFcQFC/iFGeDIOjGDwZBcG4YRvYltenzSXYOITcVADwvBD2Ow3flyYnGHcIpbjTIy82YfPm2WsoYJaoGFeUkJS9236dltF4niBDzZ3OTf60M1p0JrrvkZeZKJja2OSyFkkegWavRStu9wKrZA/I5lEoOMjVxkCpitTHGqjhpKUuiWIrv7LK8s2MvBPXl7SowGuGy6yHjDlF6ayd00gocF8buDjLOhAW0Wiw3n9MSbn6gwW+9Tl04KwOY6vzJibZoKkvjZOAit70NvPXzMB59BPuog0KReKjfJ2gXS/yHH+pLBegAwHrLBu59g30bBb6lMtswGITIfzr2YFmAsbNDQDe+RtDuoNfTKhfixCdc5sNDNVQWj089hDJrwi0uFBWlJU/rpGUBvQ+vUKmAChmlMsGcUDpMA7nGKn76/U44/P0+UPUuUahYmIw8bdAcXWnpONESEyttpaJB6N27BIiyFQBAIi1alhsGuSh4Hi2uUYu9mncYX+HaAQrdPjK9C+BkwpVYcQXoHGqOtiQJay7caCWpdnLC040GnThRKmPaG6pdBlJFcHSEMKKhiGwPLmnVD3zSJcZXrPPoSG+VHD/hv+YGj1tcZF72fKxa/dAa/fpdC6O+h6c9HQUSjQ0Fpm+xfAn+IlQaMXELvQkjxJOwrJ4jfXWfnQuSgIhl33FJwEXKuAnIjuaZZ/FadC4JNCe1MQ5K0u4jqfxoG+LAMA0URi1788DevOut2DFJXuxvUvvnjek8ULls++YpPUT7KA54F7UhbQySUrR/4/kW3fsi4C2f08p8XuA+r43zFhZp5cxbRCaltHa/wLPzC02LQLH7nOe+/MlVPEwxCatliudpnOz7CF/4Qp04PCR3V3aX5S8AfhgMucVtmrR6VSo67K7vs4CdHQJGCZjRuo1CfUKQXlSBCzodvqzrazrMtJ3FbHCFTGkFmcoKAUSppLi6Wd1oOwfYNlzXQfnuJiaHp8jVy9jYA+yjIbmUgwGedqlpXMkD00eHyFby+PhDF2/eheKy5khH6PeVGoBSBuj3eW8iuzAYKC/BGeBNaAUUDax+H9cPP4FlKeDb79MKappwHISSZNWqpnd4HoHyaAS8eZ9gp1ShUyKamxrsSFSTep3WTcXJnY49jMfAahUEXb7Pa5xrGCdPkMt7MJW03dWYPFTPI6gLRSJcOlXW67y1Todb7ms1HjdM4IkalpnPUNjFIlRo6mnIZ544QM4PaJEFcXulwoXVzg4w63Ax5ro0mJakcttWK64sUAQB4+Gh5tg4DueZN9WR60olXO530W6TLnOrxgn9tAfcqnvsO1vtaDgToFZD0OtQ59iZKIlBxRk2DXZEY+PZ342ZAcwMpmMHg7aHtYaJYlHTeTgPpqTn1NaUBfuSzoHHTwhO87s8Xl/nquJEyb2NFd/j+Al/M6MrvU3z3ntaAaNSgdnv67lnmrge8Hd8q8ZdEN9XAU323tCrmcYG/+ZzrL9aZZmDy8iP+NPpObluX91n52eY0qyM8XNJ55PySD45l3RNUt60tsXLSrouCjzmgfCkvGnXpAHHZRYaUu48dQkzdi6pbXFQGQdw8e9JZSVdm9TeZcCXNyffvLkTBblJiyY5F10QxAF4EnD0EvIum+ILo3hatACQc/OAelq70vo7bUEYPbfMb+qZdnxJeMI3SYtA8S8YhjFIOG4AyL+E9nx+yQ+0pIPvI/CTzfdiwctYzD7z+S9jahqFbYNWu2aTv5TeBV+6dlZvf1sZZdW7VkEQlBPa6ExbB60skaPs5w8GBJrOhOCvUmbEMnE8EsuwO1WarnWFKsnlzeUdoHfBwBoq4tutBtUMRgM/lGgbDFRI6rGDfJ6OZhujU4Z4FqrC+/8VOR0A7yWfI5AZDLUEhjcF2n21mngStqtQtTEZuNjYtjFrd5GxTQz7fhi2Okr7LFcIODebwFqTHJVSgzrEvn9Fk/HBT7Xls7SiZch8H6M+o8WtlBiRMDN6gtJb2VAy7nrgoZCncXKsAPFoREBeqWi1OMHa0YAR5x1yu4tFUq7zeYJliUY3GrFJuR0FLl1am4P+JTJql8E0iXnXamyytMM0gWIPKPX7tGze/zmtDuGatLYKZcSbas5JPh+qS1zud5HPsz0zH5wbVgZep4/A8+nOJgFVKmWg20W5xUAqww8/4e7B/Z/TnJadHcUNdzmWwg0eX4VqJ2cnPuO69NiMUskNpdGyx6fImMDm3bJyMCzQgjy4JBAtFhSXecKFnQR0AXQ0PkfRQmo1Tb0YjynJNhqGkSQLVZu/H2+KlaLL6Iq7u8pRUP32LItz18oC5kQD4ebmMzSQTz0qbvK20+mr++zEzQDA85S99EsXyQAmqX1p4CMNbC8C10nH5wG2Rfc0DwAngbz48WiyEs7Hr0kD+nI8CqyTziUtBuL9hoQ8Sfclx9Is2Wn3Ej0ndUQVGZKAchQkS764JXpRit6PXBvtq0ULsaRFSTwPUs4nlZ/UH0nHk9qQdN2ixd2y6ctCibhJmguKgyDIzDv/SicDfNEfH39q5MTx7eSEfN6pC5wc6fM/OwBe39VgqVw1aRWTaGiOQ4c1CbHbOQd8gwXWaqwgjP2c5TWAFsg9eULgUlxRslbrCmQrnVfRsTVNAoXRkC/1bpeWXeU4VKpamv9hmjzueQh8oFQxUarxfKEIoLKKq5PLUMu11KoS7d/9BssXBK0UDp6JmLb/Uy2WrDjDcCbctlfKCb0e0H3kYm8P+OlDH1nlZFepaFCYtYHHRzSQrjUVp1Uc5qpV3CoNtNawgJzxNTAaYvjhJ7gccLEifGRAWUsVD+ZMyd6Nx+wq4XLXlVOi7KZLfImZr2kVgDKQu8DtFps2HGmfMPGJA4DK0SmyeRPwfZyeAJstfi7XLJRrpHWcdYDWXh4ff+DAMDU4Rj6nF0SjIRcd/oxWTtHyda5pARdJsxEl/1bryivU9zEZKee7Wg3rb29ienSKbPdcK1S8/xC5PUaYux4rOk1lldePr4B33tFUB4nY6M3w9IPHGI043BeqDx2lGvLDH3LdVKlwAXn3LmBa0KGgAWSbm8wgdKJqlZxjy9VmhXyOTp9RKRLh0vi+imT4JLxXTqJr7qoAMPp9ZfZfIdWmfaaDt1gZzktxGBRB7J0dAJ8WLH7eLcCv9LNzTlr0DpxnIZv3Qk4DGmnWrGUtWkkANC1PUr1JoEs+pwHEeNlJYG8eWE1qW/ze57UtCRDOKzPeHsTOz7u3+PdFYxO/73lzxY/lj/d59D7SgDLwafpKtM54PUlgNr7gSeuPqGU5aQEUX9wllZU03+MpqW/SromPRdoCLg7k09oUTV9V+sRXNwXQliLThK+AsWCtdpunHh9py7Bs7QN86W82qfIQeD4M2XYeDGi9qlYjgQdKdDKrVvlCr9WYZzymWa/XU9ZkBXLG1yoK2rrel/72t2m9GynQUlTby8UC4DiYjLgNX7CuVKi7p9r0eXLCYyoanCEhvTodbXH2A5Sa5COXhQ5RLGpup6f4zcIzdZQlbzzmMQkRPL4Ko4dcdHx4HvVhu12EPmEbDd6u3Fq1yiAjT48JYns94M79QmjppLLCmdr6v9T3ZGXDENzlnRpw2MNoRNq2RDezbQDFIi47LlZKXOAAWqau03km2By6XVIcDg81j1gou4LJHh+xCRsNDegzSu2hWgWyRSopTHtDcmyjMmOVCrLmGK2KidnIQaNBZoAwIrhTsE6Lrq0CZbRa7NPOmZ4bYjU9OEAwGMKormLmeMiU8oDrKqu1j6ya49lWI3Soe3o0xK27pJwEnk95wFJZUVAulbMbrc/wZ7zOsjDc7+BKMRxkWshiYDRS8UTaDFQoFv9qFbqTajUtvi0Shg8/0tsVAK22lqUCjeTCe4RlMcR2ldylbKOqF4X1OsGv7yMMB16psB8rq7RC2zkdE73Z1D9m2c1JUKmQ9CpaO76olPaiBpIBQPz8ouPzQG68/Og1yw5hHOwkgdZF5UUBxryUBjjTAE0czCTlj9/7MhbEF7nnJICZ1uZ5190kLQLISeAyqa+TlC3i10XLl2vSgOWiPo2Wn1ZvNM0bi2j+pHmRNv5Ji455C7t58yKePym9is/Ory0o9idTnD26xNTjtrjwW6MWv/19Pai7u3zJCz4UPD2LfIbj4OmJg1vWheaySrzge9/k53yOwCMEPX31Is8qQLlCoIsCt6tPntDk1j5jnvaZolpwGxt7e0C+gNzxY4KP+jrNd6Jj5k4RjB0YAspHQzrS9XoEQqMhQVDrtmqLhzC6iEMLLQ4PCSTcCVC8RaTpTnk/JWW5HV3wOtdSnOYcajX2YberDIJtZhGRA0AHHrlQoPlpD3htm6oTuUqFQBCghXswhFGr0vLuKBmvzpmy8ik95QoHLJ8HclWl69brYbXOsMpiXBSpPQmSMvU4loCineZ1oIcQP9laps+22V0FxeJYKXLhVKuBIBgKLJsINXevx0DBUoRX4YCDTdzaAnIVmzsO7kSHrt7eJlCMgGoA7NTjY4zaQ2QtIAfq9j49GuJW3USx6JPXWyxqGo5lYdjz0O0CV+MuozK6AMYOcoPHVF/r9FXbr5CxwIUSAPS44JgpqvjduzwsWFYs5r/3Q/Krs1YkcKHvk1IEcM5XVrX1WYCy/NAOD1Voa0V78DygvobrB4fsw4GHwt0azwvf2TT5OxA+ztEnKriJxc+mSSvy4SF/h0IJEgqQbBEkpAB4JXlxn0ea975Le1EvAxTTXrxJYCSeL8lKmHYsvlWfVk8SsFgEeuZZ/dKui9+TAK00QJKU4tfHU1p9SWVH6112rOeVMe9YWhsWJTP2L+lc/JiHZ/tWUhJIlOPxv2mLkqSUBJiRcCxqsU4Dwkllz/u+6Dczr655c3OZ9Ko+O7+2oDgICIQmKn6BWPtMT4MgL7KU/OSIgv++rzR+QcPt1hYtZN5JL4wDEvQvYZw84Uu7e06gamcpAffoERFXFPBJ4AXZNq9WaQX2ZxqUfutb2gHJpuIEWneU3NmQoAcgkH74UFmlNwHPg2FbbGg+D/QvYdRNZSGeEbwrDjI6HV7XvdCWs5MT5jt6rKLVDVnumBbgUIpOgnR4KpiGOv/ee7xMLMUiXiC73q5LS7yoYgk2ytVWNGd2NFI0CnWf4qA4GjLKnURAM01cj3xc9BikhJq+NlCt4vqkHzr7iYVTaACmCZwqObZbNW2AlEBqUSOijP3EBcolrhVEAEIAdGb3dcA0kTk5RYFEW4Z3Vs5ss6MnGPc89Ho0lq6UFCCWOTC+inDSc7ofZHw7Z2qczjF1gdKWiop38gS3mjau+y4KrRr7ajQi8ldjW3K7sCzgagSMVBCYwQDI1Tj/PUffc78PtFyC7NGI9/rjB1wgFkomRgMOlusy//6+Dnvt+1wQZLZvPxueEFCBQK6UGV4F8RDJObHaqiAyov1caJS5ULr7Gn94zQ2EnJfaLe4o1Ouqjzz+5qpV0qPsLG/UtlUI8tucx4CqQ+kmJz4oXk1rx8tONwFJScAqDkSj+ZJSEghNA1ZJ4HcR8I23O816lgRyk+pOK3deSgJfSX+T6n7eOqWsOOC7yUImXs68PlhUXtpCJTqHFpWVBm6j55LaNK9P49fEFyuL5vfzLCySrn2ehUO0vKQFyjJ1Ptcj8BV9dn5tQTEAtLZNTB0f3a6WYpuo6Grf/z7z+D7fpTMl1/V7fXq1v1Plri5AoDR1NbDb2wPuFE9o4ZNt4HxBh0kTuoEEanj/fYKC5qY+J44/3S7OTnxUj/5z5EpqW7hYJAgVDeTKqkI3Q4QScCKfli+Q6NnvK96lMo3aNtBcY76Oij67/ZqOYAZw6144xGJi9VRgB1kCjsdai1gkHFSo46vjPr71LV56cKDEDdTCQXbMQ2rwWMuxFUVtobkJeFOcHXvw/SFmPtAq+aRMqMWDUa0yX2kFk7//m8yza+toK64LeDM4DkIptnyeYymKZ76vu0Ui7AFUl9hQusXXDrBaoRU0n2cbxblOqOOOA6zWTMUh97moaayzMDsbRgTJNOso+z5Gox7GY1qZsbPD8SkJz1UFyGifcUwGg5CWEqLW+jpuvZUlhxuAhLc2B11cHvSw2rBxcXAJ1+2iXFG6xY06rh50Ua2GrAR4HrGj7IB4Hhcqgc977fX8UPzB84D/4reBvT0/jGguDoSNhqboGiZQqFhs6/hKc91rNVYmdB5vqtU2ej0NiqMrEwWoc411TQly1cLLtoEPPmCl/T6/Hxxw/Ot1/m0PCJJlQSdUCkcpvgh9KSW9ig/2l53SrElpaR5QSgMq0b/ReueB4zgw8ZG+TR4tc9lzcUCRBlbmgbWkPHGQlXZP8XrTUhJAjYO3KHCM9uOie0mre5k2RdsWPZZURhJ4k/Z5mD9XkoB+fK7McyKUOtJStOy0+04ag3mgdNk5dNN0kzrmzcO0xcS89Co+O7/WoPjxoY9mUxsjAW77/qwNvLH3LJ8YAH7Y4Ta1D+3rdXhIECyOeZ6nAm7sKhRdrfJicf6Rz90uX+CPPiJAODxUOr+mtnS5E8CZoFi8RK6oQKlEHKsFygFuQjm1+qq6rs6y3RzzifVs53We7/Vo6pOGhlzoK20Srd0Ky5z1LpGpVxXdI0cQc3ysTazSEeIU2L8MwWjOJugUfrZIrc084N13afxutXSEPseh9X6tDq3P/OgjFIu01G80oNobaM4rwM/9p6RL9GMOgfk88OGHoeXfNNmeWo3Y6ckJwa6A86MjAjpRB/vEAd4ocQ4IfRXQKnmmqbWMq1XgsufD7D/hvbaUFF+tRo43oGT0ykD7FJs7Nmkhnq+4GkrpobhCwFbyCeKciV4oVau8f+eaYyGWYCsLuFnM2t3QgXHYdUPKOOsmp+Gtb3M10rpXQDAYwnXZfgns0uvRYiz8brHgC41ZuNq9ntolUeWLQITvA995BzpEc7+PoNenIgRA+tCBq0nllkWrfrfL/LL7IBSgfl8tEE41LeL4iY6iUl9Ti74xnpE0MTNcoEiYSlnsCfnZnHJXJJ97JsBONL2qziIvO0UB1POAtrT8SZbB+HEkfF5UXvSatPalXZd2j4vqTjoeB0WLrkuqU7bZ08q5SUoCzdH2pAHipPtIA1hJdcbHWT6nAXakXDMvJQH+ee2L5kvKnwbS5wHLtDYlfZb8cVAWB6GL+jQp+Ui3wsuxZccvbW7E06v67PzagmLD4Iu93dYOVbZNdoOkO9vcVgeAH55QsGIG9YNVGNXzCNgUrRXb27QcXw88FKwLvdUtTniARmB2jhf6Pi2DIr3mzZi31SJolmTSsp2VkMlKpSJbmWmQm88BpRUE7Q6M3R1t+e31CKK3XyMi3dlRmrIKSHfOCMjqdWB//xnKwLTTR7ZW1mWZpqJ3+Pp+RkMiylJJ7b0/RdYG+kpw4+FDzQAQ4LS7y9vM2gyrLRZYNBo6uMm9b6L0wY+QtYSC4aM6/gSuKxHbCiFwmjo+RiMgN7rSg6qCqJjmMOS4CjVAJNemXuQhZ1JdpNEAPLUIGoyArSbzCbCWMNBTj20X62i/p4L7qYh4VOHoaF3qWg2zDx8iU1QSYsUiDDFjl8paYUS0dSVIydZtdoDExXZd3sTu68yjJNYygwFWLfIZSiUvZMTQ8c5DbqzGcHeXVBrTRG5wiVxtBZ3OVShFJ0C3WuXYiUqIRNi2bWCjSfrRm/eoIb25xUVlrrYS6gwH/UtGbwQwbfeQLZUJ6k2T0no7O6GUGup1/iAHA0y7l8jWypozXS9rEWnR0BaHOtEzBnTjJHkeKUwS7XAw4I9cbqRWI3CWxWtCehV5cS87zXtBR88vSkmWqOi5RW1IqmseKFlUVlKKgogo7zOpnrQ657UlDXguaktSSgJdfsLfeYuMeX23aNzTLIxx8J30Oa3dcfC2TJ3xY0kgLr6wSGpz0v0mtS8KqOcB5ngZ0fJvsqBJatOi+Z42BsvWs2juJV7/GT87DcO4A+BvANgAact/NQiCv2IYRg3A3wKwA+AQwJ8NguCpYRgGgL8C4E8CGAP4c0EQvDevjq81KBZlAXmfnpxonCigYOICv98Fvh2xiAmgiyqDATzWbPLdXWjViKxGV/pl7PvcDq9UgO07OhqcgKDuueLtDpSqxDVQKsEe9cOKs3kTKK5g+t6PkK2uAL0enirjmHt4hfW7Vcy6fWRsBV6dCS1pyvkL773H448+Yv0NpXQg0cZqNWB3F4aiLmQAZOprCoCs8l6qVW71S4Q0b0ZCKaBA4BE/WxZc18NwpJXoPnqosfeTE27RF4ukLYjFvrytpCDsLDCewCitoFq9Co2AjsN/5UZeBxNpbgKHT4hthC99/JgVWxms1VmHWFGFZiuMBKELfHKk/Pc6QK2iqRG+TwdAgHOkUuFYn5xoEJy1eKzTUZZk5wqlEtcKuTwt0uXGgGPj+0qDeKrGPxsGaAk552HglhYXQEJNca6Vw+ZADfwE6M+0o6U3BXo9GJaJjd0CML4i9UYQfbNJjrmp9KZNA+j3Q4Nqu831mMjWvbHHcOb1uhaSqFQIiOt14PTY52LDVwoc5hWylgX4s2ecUrM2uHiylcqKldUWX9NU8nojjPoerscA+kN4ntI5vvcNpVqRBRoVDYhrNUWDMNWg1bTqi1jR+5fAVlGrXphKNlAoTMVC6nMiAF7JLcAvc4q+wNMAcRyUIHZNUv5lUxIQXMb6KBsu866fB7IWtWcRsIkCr3l5lqkrmpKAWVLb54GiNHCN2OdFQDkKXuNgdtH4JPV10jySeqzY97T7jJeXVGYaGJ+XN1rXMveYtHhaNBbzfitJv61l0jLzEHhpz04PwL8TBMF7hmGUAfyXhmH8QwB/DsBvBUHwHxiG8ZcA/CUA/x6APwHgTfXvFwH8R+pvavraguLJhDhuPNaWy2uHwEi4xVMX+GAAfKehgiGoZNsIrV+mqemrnxxRw9ayQKS1dVtzJGs1HeFr+46W6QKetRIDRNfdLjmQ3gy5PBSvMlDeXFNkt0iCnbo6+q9lAUGvryinPspHRwRJ0e13MXECykmvoNsh1IuSCvZRu63N4SIh4Re0PBpA0O9N8fSgT9+vR334/rOA87xLdQkx4AmoBLhFP1HGT89Tx6VvxmNyHHw/9AO0hKY6BmoDB9nSFUGdku/q9YD1/HlI9Zi2e8hubwLoh0oRuRb7znE4qKUSx/ysQ1DneQSF4mgnwO6fvge80eIQjMcInc8uFKgWUC/34vtsvnDSyzs1DA97KO/WNRAEWHm9HkaZw0jJ6rlThBSRfIFATrSZZdfh4EBZQW2et3M6lLOQuKtVllVcoYNa55wdJVxa5fRWqACtloeJqyktoxFgk6ocOuVJsI7dXf0byOf12JgmQgpQFueYDhzOTR9UPQE/A/wdTXtDZO/uAM41jg89bDQ4DqL2wd+Q4seLF5+dUxKBapH28Cc832hoVQnL4rXFotYpFou8WjjAm3GuS3/G0yu6BfiyU9rL9EXfgfOAVPzzvHqXbUccCC0CO/I5yVKXVG607HieeJ1xDmtSHy8LDOPXLZPSQFd8MeIn5F2mDUmgPwmMzrs2CbAsWkzEk+SNW/1ven38mmXmqVyXlHdRX8Xrj5a1LFCNp+i8u+m1C4H8S3h2BkFwCuBUfR4ahvETALcB/BkAv6ay/XUAvwOC4j8D4G8EQRAA+IFhGFXDMDZVOYnpawuKA/Cdef++ioegJNkEDLuu2lbfj/CKTR3RTlKrhTB4w2YTeHKsrYVvmj8msrBz3N72ZwTApZLeVzh5QiunOyEYsizNp83nyDWu1TA56RHMiRNSl85x2foqAGC1kQm3g2+ZPVp1mxsqap+KKCYcT8/jOddl3WI6Fc8xO6s4rSWExOleT3FdHd6HWJaLlGS7tZXHJw8p6Htywj5qt/k5YwH/6BAoA7jfZFWjEfc/pq4GoFkbypK5wXpPToHGBoKjx/A8BkwRana/z7HK2krL1qNVcuKCYaG3K8BoqiTBqFgxGfvIbdUgJFnB3RLQQ6JZA8DRMX/sa3XeZhdAVY35YEAdXnHcu3ePIE6sqNUqwd5ln+wA8SODaaJ8/w4LGV1RBcH3CXxLZWZuK4m5MKReQRN4LYt8bglRLHxwd4Lg5JSKD7I0L5WeBdWt21wgiQVekuhOq22QwnYdb6AL0+RiRqgXe3u0eNdqXB+tN7TT5HisLe+1GqXhQoe4SgXZ42NgNMRlz8fq9irg+zBkQZDPISurDjODrJrelgUGIwEikezUros4pAoHX6zOAojzBc6hwUCrWAhnuNlU2osT/gYlwt2c9AeW4uSU9OK+CShbZOWK50uyes0rO61ti+qIXz8PAEfblFSfv+BzUl2IfZ4HPuYtEtL64CYgO6ncZfMsAwzjfRdfhETzzQOSVsI1wKfvN94vy9zPvDFOyhvPl9a2aIq3Gfh0O28yVml50xZm8b5dZgyXSS/z2WkYxg6APwTg9wBsRIBuG4QXAAHz48hlx+pYKih+0XuemwzDuGMYxn9hGMYDwzB+bBjGv6WO/zfVd98wjHdi1/yvDcN41zCMP6q+v2YYxnuGYbyvrvnXI3n/sGEYPzIMY98wjP+D4o/AMIy/ZhjGry1q3927CKWEM+r9m4lYveQFvbPz7L839yjP9t3valAsBtWtLQ0WLjq+5i0C+rO85N0JMx4dEcD4M61TFlqXa4AzQW5nE6PDrg5mAWiVCQkWsnUbsHOhFQ77+1oPVhopUgt2TqlWqOslnK5wRPI5Wh6FUqEkv3B8TEDXu2D+hx8RFfk+Xts1Q8nYOy1ecvcu5dHWVJM+amtZ2PMOQhlnxyFAHg1Uf4iUWb8PY2sTt2qM0Lep1CIqFbVQkXb0aSF/cky5sclJD2huwri7F4oj53Y2eS+lMmDbsBWPWQKnrdX41zD5UKjVaOH2ANRAOkVUpk8wqoR8fqL450beBkrl0KLs+0pyTfgJYxV0pdvlzR8fa3C6tUmuLaCDdezv66AXzkRJ6BVC+sDoiFSJTIUUmVGfjZz0rpRaSMC5UVrhAqlUYjv6T9W8Y5hzFFfCG8xVbGRM7p6IgVWcDAGGx+71aCX/5lsmTk54Pley2DZZ/NVqoUdiqQTAucbwZIhJ5xJB/1JzTfp9oHsezgfLIi//euAR5J6c0MLd76tF2lNt6Y42TrhPIiljWbQiezP2g+sqS7GnBxHgAiwhBQEvu8m/zyJ92Z+dNwGn8X/LXJ/2Ul72HZsGoOPlJgGuaL5FFtGolS6trrTPSeA03kdpi4xoGUnHkwBlvO/9lH9Jdaf1U7xd0fyLxipa37LgPX7fixYXXix/NO9N5nA83QTrxfNG2z4PKEfrXrTASLomKU/SXJ0HlG+yCIqn53x21tUzTP79xaSyDcMoAfh/A/gfBkEweLbeIADtns+VXralOI3/8SGAfxnA/zma2TCMe+rjrwL4awD+EYjofykIgonqiA8Nw/iNIAhOQH7IXwBXCv8AwB8H8P9ZpmGFogHLCkLDacbURtQwmuyWlpsS+SqA79WDA+7KimVQlAtEQSFjamC8Vn2ircXCLe6cEzzU13nxB7+vFR1ESuzkHDg5xen+FTbfqTJYxP4htZJ3brM82cuWvf5qFcbuDiYPmc/rd2GYQOneHZbfuq07oXoLqK4SdJTKBA/FFb2882Zsh+OogB2ubr9IaSlQPxu7cF2CQxEB8DydBQBWAJwjZESE+L/Z5Pl799hv05Musv0+VxyN9Wes45m8BW/shdb9bdOhMbxyiQcPtONcrmKHnGw6fY20o6DShMuPOqEUmfiu3b/P9pkm6TAAfyQisyuUgpmieuzs8O/WlrYQ0zqZQba+ilvNDGadHk+K9J2E0CuucCEkVl1ZsAj/u6OiynTOycX1fR3yu3NOZZC8hVJjBRhfYdS5Qqmex0XXQ7/fx8wDWpaLTH2dZfkzlkedNT0AdhVGvR4uigoVCygWsbnt4/jQC9d04tu3ucVx6nY5ZudtP/ydjPoeSvWMNrt7U44jAP/gMQZtN5TdEy3jUGXCslCtesje2+UgfOc7mk5iWTqG9HisNL0veR97e1zV3n0T+PBDhJ6Q3QuuWDwP+O3fZjuKBc5rkdXg5MGs3QXQTHxWfEGW4i/ts3PZlPYiX9bqlQSK4sfnXSv/LDxLTUgCGtE2pYGGeJuTLHqL2hTPuwhMLzqXBoDiIDgNiC8C/9E+SQPVScBuUX+kAf+0PGmLpDhwj9c/D1gnpSTgvAj0J+VJOhafY0n9Nu9YWh8ktTfe9iSgFx/TKI0iWl+UZgIsHttn6rj5s7MbBME78zIYhpEFAfHfDILg76jDZ0KLMAxjE0BHHX8C4E7k8pY6lppeKihO438EQfAPAUAZJ6IpA/Z5AIo9IAgCN3I+BzU+6sYrQRD8QH3/GwD+JfDBfgkgel1isiziA5HVigaPME0CnaMjvlO3t2nQE8c6y2I0s6mr9XW3t/XurFieSxVT8xvl5d4+VUTgoXa8832+xAECBOE7OtdUMuicYVOVXajlaSH1fQIk55qNHA3x9GiIYpHR3IYdJ2wrAL1dX1/XHSDcD3eiI4S5Ew3gSmX+O36idGBztBgXVzAbMOoZ8nmMRsRdgDZMX/TYP90uIBvUTdW3YjAfjYhL3npL9y/PeyiNDxme2MwAnTMEHjWlhf4pKlwC1koljuPVCCxIlBskoIhp8N6USLJY90cj0j2uRuqWFUZbr2sKwcxjm0nZ4PiKEbRWAzKVFZSrJkbtIetT4HvavSQtZKwitDlKi7ikFkiiSiEgrXvBQkW8uXtOy7Jympw8PESumsd04KDdBu68tUKFB9tCqWbieN8JnUXF6roq5YtznjvVHbi1pRY/qo/EkVJZd9dqPfz0gLsjMj4Xqk/eeYdj3PqOWmh5U5QAAnvT5E6EleG8r1aR3TPhv/dJ2D5AUS2EuG1Z6HaBTW9Gvb74E9VVDnRbm/p3I46psjLd3QUe/ITXDi41Zaixzt/d3W+oxZ9a0VpZXB91USglv2q+KEe7L/uzc1GaBxQXgaCklAQo065JAn5JL/V4efGX/7JtWybNA5/zQHLawiB6fh5wS6vbR/r4xMtPyzfvnqL9nrYISgJ+afXMKyfejjTwG7//eFnzQGz8+7yFXdK9+7HrhFJhRY5Hr4/fw7z7j7dv2bmatMBIGu+k+1gmvYxnp9rR+r8C+EkQBP+7yKnfAPDfAfAfqL9/L3L8v28Yxn8MOthdzuMTA58jpzjG/0hMQRD82DCMIoB/DODfjVx7B8B/BmAPwL8bBMGJ2jo8jlwuXBEEQfBvLdEgAAFsm0AqUGBMXtgihyogTV7iYmgsFhmSWN7/AN/LuWoes66DrOrZwPNhVMoIHj6CsberPeW7XQQKlJm9S2SqjNhl7n+CrE1qQVQWLXC1vBYAvTUMEHD5Pp72VNyMCrBZz8IwHXJ1915jo0dXOsKIOHqt1YGzU4IMMQkCCv1ngJEC3N4U05ELx3FRrlmANw2Bl+G6z/STGLoDXzvFZQFMQUm7apX9fKvG/Lu7OuIvoEEuAGQPOgh8bX0eDHiP+Tz/HR9rp71iESgoS3VoLXSuNeg3FQd1fI3hfifUIr7oUVZN5HClW32fYHAwAGDTyHq7Revm7q7GYatVhIEzcj0VKU0B2WxRFeZcA+MrzFwfGaUXDNPQE2t8xTwiLNxoKJqDCnjR6QDja+RqK7g4ugppxv4Hl6hWgYzlhaGVZ15kUVa1qMKxswN0zhGMrmBIYJDamgLmBMvB6ApGo66t1qpvZh7w8T7CRdk77yDcFWjdX9VRFq0MgbBMDN8HauuaA12vY200xNN9Bi3Z2CsjkMhyAAzfDwOnoHqL7RagLj++apVUB9PUYa9v1QEYgOmyHXtvkG5RXAEe/BizTg+ZJilDP/t//FO8vscf+qTvYDRS8nnyI46nL4Gj3Zfu2fkS0rIAI56WOZZmfUu6Ji1f3KoWv3YZwLAI1ETbGm1TFKzELYBp5aYB4UVpXhvlXNwhMO26eH8l9V9anyaVv+h8EshOWxgkLTbSFlBJoHYZoDivrqTPixY30fPLAN9FcyQpJc0/SfMWjYnp5Tw7fxnAvwLgR4ZhvK+O/WUQDP9twzD+NQCfAPiz6tw/AOXY9kFJtj+/qILPBRTP43/EUxAE/4OEY48BvG0YxhaAv2sYxv/rOdpgABjJ91rRCKN5ZS1tKTZNboELz1gUE+R74CvOqc9ztq2CTbTuhJaskoSrBXB93MPsvUfImEDh5ESBkzNM6JMGywIytVVMOpfodAiyT060pu+TEyU/nGdbOx1gy3LgeUBBccUvu15IOQWUxFlniFLNpmVMOJdRQCweVE8eK7P4ZggYMb4mz/jDHytZNBJjRSYX8ML2DQZApeJrg3PESVF88QD+wDIgA/6++mVlLe3fJ0DYdRGGYR4M2OflkjJ05rWFWRQSRiPq6H7nOwgllCsVYDpykZXKPQ+jroNSswz0+/jZfi8E8P0++bHTfLhWAaDp3+Ox9tNqtZi3XtegPHQGU5zg7O4dhNHYAKUNvR1GMMlU8kohYqKcvCzQ4UutwEYjtQNwpfmzsoUxGuFp2w3VHgTHuS5wcqgNpzJfx2Mga3l00Dw+BiwL778P3L9/hWnnCqUKw2IXiiDtplbVYFbxtKeuxu2nbfaz4wAb2zZXBr7/TDjtMNqepRw/q1XSG5SmNr71Ldxy/xmmvSGmvWF4D6YJ/PSBqxwSDeDwZ9ymaamdL1NpKMrirXaLxztntIA7E61L7U7ZpvfeC8vmoF7g9e82OJhWFrlmHjk/4PWVCn72s5/BMIwr6FTazeML1Sn+Mj47P6t0kxf7MgBkETCdB5IWtW8eeEs6Ns9KmdSeRfkW1ZkEvNKAXPSaqLUyqdx4igPiZUB33GqaVle83XJsWWNjEoBN+huvN40eEG+PBzwTMjze1qRjSYspE+n9EF+ERc/FaUBpdcbrTTuW9ptJW/jMmxuf17MzCIJ/DLUTlpD+WEL+AMC/eZM6XjooTuF/PFdSVo4PAfxzAP4JyA+RNJcrojpnRb6/s5MLjGoBaF+GlsGJSbA1UwA5Y2pqRFSBQvDL7ZaSljJNvpzV2/ey7SBj6euvFXgrVNX0q1RgjgnMMpUVjE4uw6h5Ev1NAN/1mGGAxYIm4BgAhBs7POwB4HFpr+sCBbGUAgQVgFa1yBaAEjQwO35CvmW/T2DxwQfcfnYcTAcOul3tuzQa0cq7VlNW0nodRYehg10XGI50BDhD/epmoLXYBLff1+oI84vVUUCtAG6JtPazA831bjSIu846wFmX5eVt4p9f/3XNYc5WFTfazgL5HAFxrYZJdxhGGAaIOUVGTYCk+GrJoinstrzGp7atAHFxhYshd8obEpO3neWx5mbIJxn1XAAOSpUBqR3iMLl1Gxi4GpDaOR25UG58MMBFxw/HuN9XEfQGSmq3SNwr4y9Rj/f2gM1iDyiVcd2+xPY2KSGtHQuTkYeLHlD1gazTD7e6BNfKQqvXIy1ovc45sLUFVr6zQ6utNyU3fTDgPMuryHy1GhcFx495T4eH4W/k6EhNS7WIefRI05K29g+RadRiWw9TDr6r5AVFoaS+rnY8doGgr8DzmNrE3/lF4O//p2i3AavbxfoOHQnPTnzY9jCU0CsUgZViB6+//odxcXERPiMAYDdvfGHqE1/WZ2fGMF74VXcTi9OyVq7PapiWrS8tv4DN6Pf45yjgSbIAJgGVOMiNnosfTwPlSYuBZe43CmqT2hYvex74TTs2r660sU0DfsuMQby+pO/x+4j38bzFSdpiJmmBkpQvrYxFC7/o50XAGPj03JVjPj7dD2lz5fXXX/9SPTtfJL1UUDyH/3GTMloALoIguDYM4xaAXwHwv1eE6oFhGN8FtxX/VQD/xxsVbhooFPV2v6WAbDavo90BPD5T0mFbWxq7lO7eVtJmUwKDTgfo9fDgATmyUCCrXLcBuAgcF8b+Pi7aHumjXWDmXyHwtVGtViOQnEV2oIWrG5VStW3g8NDH3bs9fTum/rfasLWZ08yQqxrlg+QLBBjlVWqHVcqkVwhp1/fJNY13maljIGw0qDF8/j7Nq9dKu3cwIIAcDtifGZtW4g74o1qrk2u8VmOZ0qeC/zxPqzb0+1qvdjQiCAS4GPEA9ACYLlCN+ADu7kKpLvi8yPMAd4Lp/idh+x2Htzoeawur7PrLXwlJ7fvA1Vh330qJkmxs6NWzEQuF3yoBRQCFqAsouacqGsiM+bdu6wk2viLALpU08BO93fYpJmqR1Omw2nKF/S1SaNUqgevREY9VKgTK+TzIX3auUahYGI89ZEzg/MRDqQS0dtVWSKnEOeH7KHTPQbUIN8T4stBaKandk3xBBxwRBG3ndGCOseJOAzzePVfeqI9DTWnpz4MDHc1ZJN82qor3rBZ+4UJjpBYSvR4t8O4UKNQAXBGA956yQ0wT2P8YaDRQczpcYHavYJpXlFo0n5VWnJe+CPrEl/7ZuSAtA2KSXsbzXtpxoPM8bYmDn6QUByRxkJbUvmXblgSgk9qaBtLS2hr/nFZvUlnzQHEamE4DfNF6ovnS7iEJ7Efbs2iM5rU5XmcaGE7ql2X7cl7+RfMhqY+i5S9bXtoiJX5s3pxKG9ebLA6T0hdNPXue9LItxWn8jxz4EF4H8J8ZhvF+EAT/YkoZ3wTwvzVonTAA/G+CIPiROvdvgJ7WBdBJ5Abe00oDJJ9HteqEke0si9vxU4+yYpZFMJyr2Lg4IXd2rQ6NPkWJQV7elQrw/UPZuaWi2kM3dMjq9bzQ8nyhtuoFDDoOgbgwHERUwjSpylWtKuc+j59LJQKKw0PiA9smMKrVwEKam9rUORgQpBwcEF25rnL6KvP8aKhUDkbAaIjg6DFcl/edreQx6zi4VCC3WiWY/MEPnrWwznwCNbkX6c+zDi3F9xUIfrBPkHzvnqZLSFC/alX3h1hD83mOyczXlstDh4ZuqEnRBQGhDMNZx8VF95RjBXKGFa01pMRUKsC/8C+wTOGVj5XeMKBVvi4HBPgyFvfu0Slv5gGrTYtb9+MroF7HRdvDmn8IWBaCo8cwivmQbzscAGVrgMuuRyuzhMtzXQSdLozdktIh1rtQTzt6ASUhyR2HoHhvT/fP8bGeb6YJfP/7HPLtbaB1fEnrLniv1w7w1rdVJ1SrXJXU6wSc4zFBqzdDrmnij9S65BqbjGonYwrX5byXnYWoaklxBWiuAEefIJRuUQP6tAd0u1c4OGBWmesrJYQ7AdUqf1/Dnoey9ZRP1lpNaw5XqzogyeGhppqIAsvhof5h1WrIeR5ygwGQL2DUHuLwEPimaDVAUaKs5Md/EOjb+pzTl/jZqVPSy3UR8E0rR/LcpLvjgCItT7xNfuRfUnvj7Z4HTNPaNK+d0S37ZcFi/PMyKV7OovZJSuKPxvtpGbAezRMHy/NAaxKAS1uUpI3PIkCc1P8mFgeziM+RtLGJgqtl+jwJoC8CrkljklRmPP+88qN5X+TR9wU+O18ovVRQvID/8Z8sWcY/BPB2yrl3Abz1PG3zxlMcP7jExCGHF9BqBobJF+XJCXV2cyULgeOGAI5WXB+GqAcAka3uGapVhFJfYr08OSEIEy3b21v8vNF41qHONEnhePiQAEGMcLKVnzF5LUBw9+CBzjPzCZpsG/AHHm75j3XYW0dxhYVfHEZHU6bS9hktlIPLkA87GAB514VhEmeI6sCjR6xfqAyVCh2yhC6Sz+uAFWcdWoR3Kry+2ycgNqH1aMdjhKBNlCBEy1gsiVaMUHUG8pO70D/85iFQLZFKUSiSiyzWR8ehBVluF2CduWoeDZuLooueVhtpNjkPrkZ0qMznuTiSNotK3KjroLSVC63Fa1t2SJnwRi6ssQNDcUMMk5Jlpgnl3HaJoNeHYVvY3wcag8OQvuG6XHCMxzoctljQhXstc0gAu1hzo86fR0eapiyUnqwFfPyhize/J4TuqYqYd8Z54kyA0Qiz/jBU5BM+92CgLLmVgQqYsQ4cT7TFuFRiX3TP6XQH8MKjI8A0YZp+KMEtiz55cN67py3GG00D5bqN6cBB1syQY9xosN9kUL2p/tHU65yksq3i+1zwuRNeU18H+k9R2lrFa71LHB4y9PbViHOtVEp/en8RnOIv87NTUhqYS/o87924DGBY9gWdZHWLl7OoTfOOp70wk4BnUhvmLSDS0jzwvOj8sseknOiiJNq+eP8nAcJlFgOLgPS88/P6cdmxTBuXedfOA+HLjnG8b+P3Om8BEs2TtgBYtGhKGtOk88ukG+X9Av0xnjfdZNH5lUwC3oTbKuFoAYKQtYYJeF7IOpDAHK4LXB5dPuOpDwDodsOt7NCQ7Ont+pnHF/HBAakHE5db84MBLYHicNZqEeCKYUz85MoVwCjmw4AXKyXmcRy91X9ywr8z1wcGA8z6QwZ0GA3JIW6fKuBzxb9C6FS82Fm3D8dhuw2ToCuI3OJpW/kqqTeE7/O8bIf3egRvDx/y/Mynmka7T60nE4BlaqO1cHXLVQb/yJh6q/7oSAPQdhvYV4uKDQB56B+oKMxKGy66mm4ivFuJTTIYELsVWrUwhJ1tM/CHALV2W/u4RYNW5PNAoWSG1uaJAwT9S0zbPSW7xvky6Vzi6EitL2wbGAxC6zIpDaQWGJVyWH+7rUQmxqGfGw4OqKghfSTccjHAPlWLoWs1L4UKFHW46/WAH/5QBSJR1IHtbeD6qEvAWFrRMoDOhNxyd4KMbYY0lkKrBoBzsVgEwebJE95zfZ2NbZ+SW985QxhJTyTZFPdX6CmOozW9LYvKFoAyCFtQq48sspWIR2H7TG8jCEe+Wn2W/CwWa8ljZZVkoVq0muS5tVrkqsvveo74RFjcsv9eNKkgHA8Nw/jAMIz/xDCM6ouX+uVLn+WLOAmwyed5Fr951sqk8pNA1rLtku83Affx74tAGGL50sq46Yt/HiCW80ltmlfPvHuQ8pLAeFqZSQuTeXUvWmRIPi+hDfF889oTvS5tETFvUZEEytPa+0WktPq/iGfnZ5G+6P78wlIAApQosJOAAoA+Puwz2tdpWw/cRKkrACAAEGCstHQB/dIHtNXz5ITAR5SlPI/WzEJe6912u8DP3Wdx7Tbw/vt81/d6rPNpD/jRD6lFe3REUOb71M4V4OR5vC6Tt0IgMnGg0CAVGHDyRBGAL5Up9ZoAplZDpl4NeasCzgw1U370oQ500u2yvn/6A4SU2rMO83/4Ifvwm/doKa5UgEYFaFbosOX7bO/hoaaAHB+x7yTCnNAnWi0dHG2q+rYB4HXwrwvSM2QcZQwFK8m2vwBiOiHqqe95irWgaBMSrjljEnCWK2z/0ZHuB8PUVuMnJ4p10rkK9X0lfHSxCMxOOkC+AN+nY2LWhlqFTcOAIuIgOB7TEc73Q+NqeO/i4Cf6w50OAX/WIj1EFgTFItu8vc1AG7KoknHs9zkXT06Aj3/nCZ7+f38IvPceZkdP2B61Grge0ao7GAAwTTovqj7myuFMmd7LmrdhKU6xPyMoPTnlZ5dhwwXUyzjJQg7QC1MA+PiBx/60snToq9V0MBBB/2ZGeZfmtLRc91x3lOgxyyBHnrpHRwwbbllaRSYxBV/Ig/0fAngrCIK3ATwC8D/+TEr9gtIicPJZ1hMHHfNArB+7Jq1NUYDnx/6lWfuSrHlJ9+ol5EkCr0lgMJp3GYCV1oZ5aRH4XqbMRdbf+DjE+ztazqL64v2R1m+LUrzvk9rrRf6lzbe09iXVk5Y3aYyXrWMZgPfSsOgX8+x84fSyOcVf3qTM+qHhSVknJ+ql/OgRt9vzeW7Hb21pK9unUvsU8AmeOx1tcQa4ZT3zCBbjgNtxgMfHGmR2Oqznww9Vse1nX9iiPxv4tPwZ6hoBSmKdtixGZkOtBrgujFIJNSik1e/rgBFWhs5eItDrTLjl3bqDcrWKx797iHweyNaAnx5QkKJaBUyLdd2q0fq42eR32fqXdu/t6Yh17TaBnGlSNcJWVnTX5blqldZkiWHRbut+Ou8S+HW7pF70wR+yAz6Q6iBYLtpaKq1YRBjtVwLI9Xo6ZsP1yIft9jAaESAJgBaqwWjEdn/rW7SUDwZclHz8CMiYfqhnPRyxjU9OFK2l0wFKZZQUR1Z286vjSwwGwOaOTYdL5UEYuF5IywFI4chawOlA7xLIYkfmgVi8N5ps23DA9kINebsNfPQQYRtmvp4XHz/iIkMWCaUS25i1h5h5gH3UVTsc/jMSefE06rko1dSTbDDUJuruOS3PvR6tw5UKfx8qSl+l0sdpxIFVUtRiKzrUT3tAqaFOVFYBqGAc+ZzOLHIs/UsGtIlqJFtZguhotBBvFs6trAXMbO3ImZY+b2eRIAj+88jXHwD4b3y+LXj+FAeIN3nP3TRvHKwkgS8zJe+8suLTPe1ekkCTfE4Cu0nlJ9WVBNSXSVHwlAbWb1peEqCM32MacI7327KAMbr4eJ50k/uOL0Ked0GxaI4te13Ssc+q3JeRFlrL/8DR7tVJAtBka17er8Kh9H0C4+1tAgfhHV87GihQussNZbKenGjromyFy/s5a9FCKtvRXeHXWpp60Gpp6yugrcu9HrDeQKihDLDuJycEyp5HMC1OYmt11t9sd+joVSzyb22NFmJRn7BzNCm3WsDYj2yhXwPtNppNOvhd9HS/SRC0el3xiC1SPWs1StSdd/h5e1sDYlF3EIm1aol8TtMkZ9tQVudCUd+3YbLckxOEgSoqFfb/zGOs2zJoJZ6C9ImPXeDNPuC4QKWkgVZHLUiKRYTBGgTA93q0tvo+aSy5PIF+Z6ADiwgNQ/y4jo81UJWIeo5DELe3B2zuTJCtldE/GobBCi8Hqv19lxEJ7RwwvoJRKSMHYNce4gc/4K7BwQHHzzCB17Z1PWKNFx73Wk0rKMx8XitjZJp6NyNjakxoWSz7wQP2b73OYz/d5/m7d3V5Una4gjfNsGzTB8Hu7q42Y5fKQH2N97a9zUWWPBVHQ0zafUw9/g4k6mHG4qJH9Kqjc79eBya9K+T6fS7g+n2gNCO9Y3wNWC4XeOLtaecYlVEaaWVUmPCsMpU/BQ4P8Yu/okjhlQomRx3kShaOD+MwhulL4Czy3wXwt77QFtwgPQ+wiIPZ5+nupJfzTdqwCETMs/wmtT+tH5LqWFRvtK5lz0XzJIG+JNCV1i9p5UXPp91/Unlp56JtuUky8SxAX+Y+blJnvL+iTojz7mVeG6TMpHFIAsnLti1e1oumpIXnsulL8Ox8rvS1BcVBAPzO7wDf+x6/mybBV6GoAYTQH2Rb2vcR6glHHYSEgyoWX7kmqhncbD4LTGyb1tJ+n5ZWoRNsb2vrom0Tb5ycMN+dFuC5BKXHx7QibirrsOCS1+9a+NkjL3QuM10H9piOZAVcAKaJYd9HeVdJsr39Nv9aFsFwvU7TeH0dWZxjZ8dBvU5r6mkT+OZ9rTi2XteWat/nrvtqhWAul6fsWqnE+xKcIrKzF11SOtbqwBu7BN+DQWjcxnpdA+l+H7izTWWLUgn4wSOgBkq8ddV42qDjXcYFigDOR8DrRZZh2/ybtdlfIl4gam0Th2A7qxZIlQoXLL6vHSRlXF2X11UqCHnXYpy8HHChsHmPGsQC/CVAzImiWfhHDhoNR5U5DOmwjQbwm79JkCgG0PGY1J07Le4qCD0GIGhdUbzzdeVcd3TEPpJ+Fz61JLkPCZJXrugAeicnLFOsqDkbmEAB4EoFcC/CvsjkLe1QV63yYLFIykJllbJzpRKBM4CnB/1QkaTf50LQtllf1tKShAcHDBCyWrcIcv0ZKT57b/B7scAbGA35vVZT0QrVj0+8UsdXz+7L9XqcZGISNjOAmQmpIK23a8B/lfyseA5nkbphGO9Gvv/VIAj+ajSDYRi/CU2Fj6Z/PwiCv6fy/PvgO/hv3rgFLzl9lu+6RcBr3nXLAMq0/GlW2rS6FpUv4EzKSQMrfkKe6OebAI+kNsfLiedJA/hJ95NU5k2A4KI6bnLtonI94FOge5k6kxYFaQud6Lm0sUwqf5l2pOW5CeiOA7rn7fP4dc/7e38VHe2+tqAYIMD5zd/kFrl4/AvP2FMOUSIVNhhoiyWgX+YXPYI/AaWipztWznMS/axY5Eu/09H0gtd3Ncie+Xq7e3ub17TbtKRJMItikfSOfp/HbJtGXiWPjHoduB54aLWYTyzhRjGPwq5Cz40NlC1Lgwtvqk2Pvg/89m9jOvaQrVM5IJ+nFXdnh1ZQgHUVlFVdQh2ftoHTEwJXkWzb2SG9YKLA8a2apjWs1Qm6Zp4KXNbSlliA/S6KGqUS+9i26bxXN4GeD1QB3AJwocbzDZBbfA5gFcBgrOknrktQLAuOqNwdwDYPB7SuVirA/btceIiVWRYeEjhDLM+GqXcOztqcE7cPLzEasQ7RYO73eZ+1GufHeZd9tbmllSX293n+7l29C+A4Olx24GsVN8/jGGRjXNhqVVFnoIPMRfnf/T4XLBmT4yHqC1Fd6Jytx0AoFjg4wET9FjIWNDdFaBL1OgHs0QkBa6msG+rNQl68KGM8eMC5JYoYwrOXIClUjKirmOBZ8pfzOXaOrFwArsR6PVqEG+sqgIipb7peBx78RHVIVgdbUVtEhbt3+FtonyU+IwI81xZgNwiCd+ZlCILgn5933jCMPwfgTwH4Yyp4xiuVXsRSlQZA46BlXn3zQOxNgPSiuqLgIYlOkHRNvB1J1tZ54D0NTC+yhiaV7yd8n9c/i8BREpBaZmyWAelp4D96zkq5VvLPm0NyvRf5nNbem4DXRceT5tNNQKhcM2/OpB1Lmz/LzKlF6TmfnV94epFn1yudAhVZ95d/RRuTZr62/gp4E8vc9raOHPbTA+bJ5wlUBGx5Hi1zrqutc6b5LOCTqHCuy2tlm3q1orWG83mEAQamygFrd5ffxTJo2xowi0TYrRrLchwCrvFYAZitLUVEnWn0E4ojTxgK2pvRVGhZyNbKEE7mYKDbv1rjdKlUtPNWFFiKxqxImmWUMTGr2rvZVBrKkSQOZrKVLlLPoj5RyBN4Zm2NccTY1wDFWu+BluNVECj/YpUmuHpVA3RRFRFnrmjwDoCAWLSjq1Ue29nhPYXAENoae3BA0Dx1ed3UA955h/fd7WprrYA8USszTA7HqaLjnHe09fxczN6gVN9wRAzYaLC9lwPyzV2XwHY0IiYsqPILRc4T4UXLYsr32S4JurLZZLnyt9nkvB6OWJZQNARIj0YE/DkFYkOJCEGyoxGpCp6ntxF6PXbU4SEuDi5DfCyOdKKmkjH5+dvfVvetdk1O91UgGVlNAFp9wjSAW5uQ0Nqws8zXvaBjX69HIBxajjP8FzX3Wxkt6eb7wO7r8UcE0xfgLGIYxh8H8D8C8KeDIBi/eImfb5r3Ur9p93wWL+dlXnJxYBIFLPPqnmdVilsXl003fSmngc9l8sS/WynHo2Usm5LqivZt/Fwc1KXdT3QRMW9BIWXIuXk8b8TypgFMM+HfonTTfku6v3kpafEQ75d5i4F4PfMWHzdKf+Bo92olwwB+5Ve00oAACIkkJ8fln++T13vWBn7hbc1xlVDFwlHdaGiNYoA8Wwl5LNbkckVbB00TeGOPYCRjkSbw+EirCQDah0n+Fops5+06r7EsApsVxckVmblcNa+/mCa3oRvrtJTlc5TKqq5yi3s0JGoTS5uVAbwZVndrgDfDreIEyOexao0xGbjIVWycH7shtWStRmBVLLJvajX2z9TjvQiNBODnwOd9TBwNrvt9Lg56Pd7XxNG8bNl6FzWGce/Zh9yKpRYS0LSTP/Rtgs6oxVQsvBLBTugfspX/2jbngnSF7BoIZUJw33BE50n5XquF8s4AaNGOUitETaNe5+dNBYz39rjoODmhUocA0Xqd5UtI7amn6SNine90tOW5UmE/S0C9ZlNbuEWyb2eHc3NrCyhUbay1zHArZOawN6tVyhBedHwaaZXVuFikhNnr79QwOuqhVFGPSllkdc65sJKoMt//J4BtYzZ2n3ngTT32Q6OhnQMLRYL9fB64XeTuy0ZDAeP9K9JDWn3ysTt/i/G822caWQv49Twec6418b3bpW70w58Avo/Z0RNkSnlF7yjrTrJtaA2TZ9MX8LD+D8EgHf+Qge3wgyAI/vXPvRXPmeZ112cNDpcFJctYDueVGS9Dvs8DLnFAnGTZTKsvvhhYBCjT7jFe1zIpDibTgH3aPaR9TgJeaX2aVs+88tNSUv/4KcfTylzUx9Hr0sD2orYumk/LlD1vXiZRe5L6O96/L/L4+7IA3Zukry0olkBukl7fpbUwas0Sw1KrRTCRMUm1OG3rYAYCpq5G+rpeT1Mkzju8VhzkhGsrNAmxfFarWqpso6GjLQtNwve1Mx2g68/awJtvK6+v2howGiFnZ/nSLxb1DQpqs3NKfs0iMun3NQJUYX4JLtb0NZ6n5a38ADkrC/gzVCoaCLZamjfcaPCYbWsaRK1GcNdus78aDQK5nR3db2LtFvUJAZRiNRddW9k57/X4gx1ANRGkVlz0uHCZONpIXippyT0ByMKrFe74qgK9lYqmywgQl2AT1wqcDwcanNq2BngPHpCmLewC4TOL5F7UUr7R0PciSQB8pwO8ucfzIqf2829p+ofMTaHyViqaEtLpEGiaPuedLPBsWy3AqurGqrdCbklmNMIbe0MAQOBRik20qGXB0mwCv//bPezuUr2DDqYOcr2eDrFcrQKDS0xdwBu74e6LqGJ4HscY4NiIrGAuT6t11KK+ucXfjyTLAqkaDz9SQt6K9tDc0PO0tAKYGb19srUJ/OZvAc0NDN99xPDcvk9rs53V89rKIgkUB5zyn2sKgmDv863xs03LvFQXgaX452XqiV6XBlDi+W8CqtLqnteuaIqDyDjgnZc/qfyk+4+XNQ9Ep7VxnrV4WWD3PCkNNC8LKuPtuOk8XKbMpM+L2hYH+0mLCz/yOa2MpHrjADfavrQ5FQfQ81LaQiWa0sr4Ip6dn0X62oJiQFvymk2+mOUFLv+mnuYQb209a+K3LFr3Gg1tIZVUKhFr1OsaxAC8NmeTTiB0SbEod7thULQQiGw0qWiwu6tB1tYWQWQ+D2SLlg53WyopQGDSElzMaee50RWPAZStsrLA8RMdvaxWoze/06NVrb6m0YkzYaPyM8peuZMQOEvUNQnAIdZ2sR4DGsQLMBUQKIodoh1cr/PzTPXHeVdb4VXsC1gWKRVZi5baHkiXMEBA7AN46gN/ZE9bIwFtsZYxkEAeElJbgqQIf1zURyQ4iglNifnpvh43kfISa6rvE/CpAHZhX0hX7uxohzrhmj854c6A5JVYFLIeEQfG+/c1z136U8CmOAzOfFpzpZ7BQBtPxXKfsYDZ2EWmtUl9YZEta24QYJomjMEAq+Yw9E+TnYiHD1mO+KuJtXezMSLIdK4RHF4CIL1EOOfyG5IFUzSandx3Ti0s6nXAqFXDrZdazVcBUHKwLFdf5PukS3TOENI4RM/PUpKDwkvxfVy//+jZH2K+QEReXwfMQrpJ4xX1oP6ypCQLXfRvFPTcJC0LZpKAwjxLYNL3eNsWgY2k8pLyP09a5r6jQOamfbssAF0E3pKOx9t1k4VF0nVRMDmvLfPGJQkkpi2A0hZSSQA5bS4Bi/tu0WJo2bRo8TOvrqS8N06v6LPzaw2KhVsK0FLleTpy29Qj+ApsWnqbTWD13ibQu4DruiF1Ut7REpFMIs3m83xH7+zw3ev72gIpMmW+/yygEoetias5x8IpFSWE8TgSYU0su411gtd8gf86nZB7MT3pMiqYmEnNDK16gEZYdpZWNzFfj4bM580UjQJgMAYCjcD1YFhmaP3e3tbtXq1oysFgoDVy63VKnt27pzWBhT9cLLKPBbB2Ojw3dTX1Wc5Jfz3t8cfqIJScRh/AO1VeL1QBsUSLXJlQGa7GpCMIX9r3lSSbTcCdi9TTaGjxgoxFZYp/6U+xLZfKYhz47M7xmIBQKAxZWwcjkXHe3ydNBqaJi64fcoAbDYLkalXTLUyTdJujI62CEQZT8YFPjrSW8dVIA/bz7rMUnGqVnPDA8/mgGo81daZef1as1/cxdYFbO9QG3t9HGIxExlwcEBsN4OLgMhzzqO43oOnF0vdRKomMZSZy7U8PgLf2VugQ1zlDpmhhrQhMukOYJpAFuGhrn2oNxZMnXDlaGe6EeFM1V6eh+kWhuYrRySUCHzDsHK4PTmkxtyxec/BTAHfwB+nlp+ex/EWvTUpJACj6PQrK0spLatey7/SbgvukuhaBvWWtkYvan3bMin1Pqi8O9uaVmXSd1LPMHEjqzziInVdfPN+LgMQ04JvW/kWLqmXuYZnziyzWi75/FukVxL1z09cWFAcB36mtFsKws7YdiVSnUrFI66xtgzqntTVsgEECaqYfWhcBYgvhRgqHE+Bf5cMWBueSICFh8jToKNXzyJhO6Nxl1KrIeDPcqZm4bl/irEOqBawM8NbPR8ytawSywms4eYJs3sR04CBrKscicYoSVFKrAXtvEtEPLrndPK4qIWcVSldFXRPgbJgATBM520emqnm5F10uJABebtu0nK4rEH+rYeF64IVR6kwTyNiUiNvZIfVAQJUoeoQUZ4vUBcsiyLpVA7wuUFTMEccF1lXdrZa2RD54oFU9hM4hY12pkGpxe4vHJg67Za2mF0uuS5Ar64zBGNhrsTzD1JZ/QFtyd3YQBr5Yb2gHPwGKzaZYxP2QZ769TRC/2dR9J7QZUfoYjliWaGzn8wS712NgVuX9zHx9PwLEBYRWKgTgWRvIdi6RG1wCrTuaViOI25siW7KBfA637m/inkVgKXQScUQU6sxpWy8MhPcu+s1Rbr5Y7sXxTxYjIptn28qhUay8zU2gfYrLroeMpfq5WqUzXT6nIrI85aLuH/8TFi6Fmiat3yp0OUwTOLmkwsbRFXd27Jye49vb0MsrnV5VD+rPIy37Yk+6Jull7SXkk/IXvczTwGXSsbQ2pF0bT/Ey0oDiorTIgpgGSp8HtM+rd15dadcsA2pvmj8pzevfeJmLxmFeXy3Tp/G64nXE65c5nTTXlxm3RffzvH25zBy/yQIvLb2qz86vLSg2DeDNb5eB8RUuOj6KRYKuVUtJRKlt/1YL2NiihS0YOzAqM0xHbuhM5zh6u9x1uc394YeaTpFVxqg39siPjBrlogoVYg1dba4ApRUUHIeWLJEw6PWAfAGFJtBqMRwztm5r4q1YixsN3lxzIwQD2ZMnmjv5ve+RAuFOgbtvEkT3ekDtFsvY3qa5W5IfUHd2NOR2dWMDs+NTwPOQzZvIWhbu1EwMOw4aDd7X2vYKiu0rckPzNqYjl4oWpolCLYcCADgTPD28xK1WAcXiFd57T4dT9n1alAVEnpxoo3a5oqPTOQCyyrpvggua7W32eVVd225rPrHwfre2uDMguwKdDoHjR48Ics872jL9UZseTz6A732LGroCBiXKYanE8maepnw0ldLGeMx7Go4I9AFec3LCOkTpQXSnHcWvXavpCIeywwDwfL/P+5F2j0Yc9omnFEfMZ33QhM+cbTVwy4yqMCgqTLFIkHnQ5cJHUC8ADC7D9dPxMUL9a6H5dLrMdjVS8n+mtgCL5VyCz4SBP0y2+/59ViUUpEyjxgtLK7y4cw40NjA4eBIuQNY7Z4ryMVMhDHP8PhjgZw9d1OtAuaEmizvlvO49BawMshb1ldda1rOdKj/CJEe7V3QL8GWnJHCyKJ+keXnTLKTPC6iSQNU8696i8uJlLAOQ51kq0/KkgSA570e+x4FX0oIi+ndeSmtjtH3RNM/CGj1m4dNgY95YzGvTTeZa2j0nWW/T2mQmHJ93ffzYZ/34mLewi8+ntHtPGscXmTeJ6RV9dn5tQbFhIDQfmqYD19UOcIAGTbYNwDRhFJWZ0c4ha2sgK3Jbsk0vW8oHBwQmh4daXcD3CaDiW8y5vA4cMe1fISumZ4lcUa+zAt8nCCiVuV0M0EoG8AXvB0phYoOFbW0SWLTu6BvrXdAy7E6A8jcAKDPf4SFB8UqZ34+PScWwMsDY1ajdnSCzt0OA7FyHJOGy58G2PVgWo5CVW9Q5xmhIYGgNYVRXiX66F8BoqAQDrtDvK9aGsoBKFDlRUJDQzLZNq2jGIsg6HwBDD6grZsjU04EnAAK1vT1tKZVuHY1o3VyrcTwEZM48BqsoFHmtaTJqXtYCfvE7CEG/yLz1+1r9Y+oRjJYrzN/pkAO+u8uuFIuyqJRUq6ReCLccAO7smLge+Yx4Z2XRbA5hWJwk61Ubw46D8VjPod1dRl1cKXFq1mqaty0ydEJdydy/qwSuc1w8jUYEwNLxgwGX9cUVrQ2sNOsMk3xicQCUqSS/gV5PU2gkiTZ0t/vs707atN4APt4HvnFXR2JsmD0V6MTSlmsrgztvV3H+qM965cdTWuH8RB8wTVx2XLguUN4qc0fEn2lufGMdyBfoEFhc4b3VavwdyQLQ80B2+qfTq+gs8mVIy4LYZQH2Z9WONKA+D+Ai5XwcxM5r/zyAsQjURr/HPyf1Xxw0LVpwJB2LAvB5dS5K80BGUluTFhHxxQBi18xrzyKgP2/BlQSSowuSRdbcReU/72Iven302DxwnnT9ojrSFhpJ5SalV/HZ+bUFxVbeAu5Rn/eWfQi4E5wecM88l+eW/2gE3GrayhnHVCFlKeNknzwJLb2vf7vK64orwPgKBcfBju+EertHRwhDJh8fqyByijecsZS82pYGG0H/EoZFWaxKxUe2WCSQKa3wZd7YINporNMatvcGHeUePCBQGAyImEQqq3aLljUx1R0d8drhR7wfoV6MrwkavBnL8TyCk6Mjnuuea94DGCik4HV5jWkilwdQJdVjdHKJ0ls7OHt0iZUSYOztqsgXl4oEm8MbZg/nbf8Zi+ZoxL4aj8mXFUcywwSqFVp+AfbZegXoD4DeGKiXdP8JyBWNYN9neaLkcXRErCRBVe7e5aJFdtnF4nt0BGwrqoQ4CE5cglsJYnGl+MfemIA4YwK52gqa5hUAHRdFxl+o3YYJtLZNnB77cF1NLSjcvcOx6PdhiNXW9wF3ivL9NeR/8B4cR1lWS3nU6w4OD5+VaBOLs+xGZLZvEy03N7lo6pyrnYYtLrY6KnBFpcJ5BijnzTJQKmGt1gP2NL9a+llAr4TqzlrPAuZ+X03TBqk1cq1l8dxr29rSLr8HywIg1ux8Llw91moKYHszoLKiVzj5QihfsrUFXB4PsdqwOW+j0UJkFer7nK9y/dYWB+nwEMDep54TQfBqbgF+3in6opwHMJZ9Qd8EHKeB3LQXehqIvQkAiFpn54GMZYBXUjIjdaSB3nkW02UtwkkWwWid8f6aBy6T6lgmpQHdOCBOA8/L1JcEqpOAcRrQjc+TJLCcVu/znL/J3F/UD8vOh3j9834Py5T7qj47v7agGABfqOLl5PvY3LFxeuii1dKHQ0Kr52mlBtPE5hZVA+7cWyGAyCvL1v2fA7rnWPMPgUoFjXEXjQYB1ve+96xerQC2wUDr8Ar3df+BHwKMtZMTLSOwdVuhvoKSWNjQIsh7b2hZAt/n5703tKeTc83P77zDBtk2cPAz4Bf+MPD0XH0/QMgdqFSA/Y95bfecYEXVdbY/DAONeP2r0BGrYA6AUhnDAXDxO4eUra3nNVgXaYriCs4fdLG+ncfZoRNGiotGnwtG2pBnQgOw42Ot+lCvEyhfjIDXmsxTqRCkCcgWfyzRUF5vkD8skrq2rWXNogB4pUTg1mzSehx11jN2XgPGV3RkbNaUvts5M2xvI2tlgJMTrHY6+P33dfAX4RaXqjSZbu6Aus+tOjPJXDNNbS0VcWbTRPZ772D8m+8yiEZ9HRmzh2r1KlSskAVA1iZAv7NrcW7u7rJ9W7cRmpsrZS3FJ0i1dZucXYDX1evAcQ8bDZY39Whhn/lcPLRaLM4wuUAANL3ENHUwk0YDobSdLHqk7yXEc6Zaxqw/VPdsKK9L9ul4rOTsigUuTvN50iI8D+ieY7WZx2Wbi9qnbRe3dgosR3SKRQZErpfBaDToKxCNhR1Lr+IW4MtOSS/EZYFfHOREjyd9TwJN84bEj/2NlxUtcxGITys/7doocPJix+JgNu3+4tbZpHYJYL7J1IzXEa9/EbhNa/+8hUUSeEwCnmnXR/siqd54PfPuwQRVitLagJRjSfcZz5tW5qIxX9T3SfeRNHZJad69LFPfTRdyiWW8gs/Ory0oDqIaXa3b/Ox52Pz2OnB8jJKVQWk8JhC2swQIAoyLBaBex52G+aw8QrWqpc/sHDAaYbVKC9vru8D772srowRpEBCztUVrZa3GvwLM1nZXEe5R12p8gecLbIdlcat4fA2Y/dBiyygTM4TxqU0T6F8Q8DY2aLL0PO695wvA7/+X2klvfBVyMHF0pMi4V/w7HgPja5w/eBRulYtSxHCkHOpME3Cuw6pX6xYd/TpnkS1xemOt761i2r2kgdIhWDo44HWypd7vAweHQK1KECX6zwcHrL9Y5PfsmABY5OuylmIIFLVkWbuttZHldja3CO7yea1pPBiwy99+m3VYFlCqKW50yUbgaC/J7Ld+jmMuiNqbkbaiwhtjfI1GY4jBgM6BYiENVRKggqzYOTbsgw84jiJO3NjQVk7PAyplrP7pPwq8917oJbr2dhXmh09wa1tRB1wXk7GPXENRWPIFzp/jx5xD9XUtsizcFICA2bnmXHAmSrfuDI5DkL25Y2PUc0N5vdUqO8dwPBTypLYIIO52CZQ7HR0VUDSaL3pUKRH9aVEcqftDhheXSHPKmjtqD0PFjarbQalVVbHB7+j7q9WwavU4FsKxFxpRva6cSLcUfcLm78ifUbkC0DHM488JvJoP9i8iWUi3WqVZ/eL54ikJNCQNR9KxZV/oi4Y3amGcB3Cj5aQtsaLHF4GOecAnDtTibYv+TSovrb55fWtG/s1rK7AcsIiD2kVtnLd4SWp7Un4bn7byJznDxVMSaE/rh2j/y9jExzIJ2MfrSmtH0sIhbcETb/syj7J543uT9Ko+O7+2oNjIGHwhfvvbtEa5E4KF8ZiW1E5HoyqAL9KTJ9r86Hlq3/1UW3EBOv20WgQVrovZ8SluNRnZ641dHcxCJNhmCku32wRmYujt9/kOx/gKqG8j6HRhyIXeTIN0QRsS1au4AhRnWkxWIn21T7Vuq3PNe5Yytl8jaAi1wJ4qUmqWptrmBvMPBvjJB05ovBSdYVHWuBoBlYoXRv6t1YDLrqdUGDy2TazQADC4DHV463WqU1S6HgYDSoqVSyqcdI19tb2tKRC7uxwiwwTW6pqGIpb2j/eBOy1yh1/bRgjsdnefdZAbDnRo7ajig+BECfcNK4tsCYDvw9jaRCgZIRrRoxHBWVR8uloFtjZRPB6iXGH/vPUWrdSXJ1dYbea1VIlpUifYslRY4sg8yivN6XxVNW5CJ0mxfLpT3KoBw5Mhudz5PEynr2U3Siu0llYUp9ubqljaU4JHb0ZHSneiosmoHYESaQbm0e+jtLUKmAZKrhta9B8fAbdqHmYe8JOHmsstet+9rlasuH+fEfpyNm/LsphPFjmyiFqzL4HiJgvy/RAg+z6VRvp9YDjoY/OtGg92zpQMoXLAs3ME9UCERD7Uv89SmYtcoU2YJqPdpdAngJtZ474uKQ3QzQMu8e9p1sFlyou3Je06qWcZMDGvvHn1JgHSeFv8lHNpVtC0Y2nXJ6W0Pk6yaEpZcZC9CMDdNM0rKwlwxtsCpI9bUjnLnE9aqEXbmbQAWbbetPG5iYU4rd74QjFp7iTlv+k4LtvOpPQqPju/tqAY5TLwq3+UL8ZvfUsB3lWCUN/XTmp2ln9LSju1WFAgY4PlNDYIOAWsuor721gH2mfIVMuAOwn1ZuXlX6/TMipWSYmuJlJVnqcijzU2AGcCI29rUDkYAOOM6GzRAlgqEwDbWR1LWLbhiys6/q9zrbeOXZdt7XZ533l1b/0+cHyMmePB94Fs+xSXfYJfcdiX9UKno1gW+6QYZEyCnvv3GS545jLyGUyT4EQB+osHHViW3hav1wHUanj9WxPMepfIWHR0rFYJegtK91m4v0JBKVcIbC+6bI+EJhZZNNmel/DIopG8UqIFf2+PBnORDhsM2J6339bc5GIRBGetFvvy+DGtqt0LwDQIbJub7FuZJwA7p1TC6lt3gNEQ14/6+PiRBtyO42Cj5RFcDwakM4zJRSa/JgfsvgE8+gjwAxWKu4zQtH54qDjm60DnDOXdSjhHsuMxVwCVCv8618oKXGcnjK+1NrVp6K2JpgKk7TP+OzjAaquMi4NLrNXZ1+vKiH1wAFS6bELgk9Iu0msZi7rPa8qRsFoF3nzLDkOEM4IcULpf55wdDIBOhzrC7VP2r0k5wZmnlV56Pf5GPvzdHjJmj5To/SGaTSC3VVTzKw9GtcvoxcaHP+YYlkpqMbESUlLo3fl66qPiVXywv+z0IgBpEchKs/rFgVwclN4EeKdZfpNSvC3xMtPOx78vM4/iQDSpzrgVelnQmgQw42XPKy+pv5OAWRq4jOaJtz+tb6K7D2l1pZWZthhJmztJbUwqNynFr48uxJL+LppT8ZQE1OTYvIVYUpr3u0mqP22+LZNexWfnZ7H4e3XT0RFfyAcHfAm3T1WM5jOChtFQm3WPj2mBOj5WOqkF/WK1lSXPNBByIiRiRz4H5AsYDAgozjq0jhkmsWivx3+djnY08jwGG0B9PQxNNh252hIsW/MCvixLgdqcAszXun5nQsCfLyiQr8I895+GVkZ4UwK8g58SISpvNgGQga/VGwTU9/vcBu92gb/7u2xGRgGi13fVtomvedGhk99oiPMPOyF/WiS5ACgQbyDT2kTWIk7rdpUjm0dsJw5c0XDJ1ar+vr/PvvU8GgNFhk0i0lmqXHEKa7f1ZkCvRzwlvlki9zweA+Lshs4ZGyIebaUygeTeG8B3f0lzvJ1r7SimJPA8T4VfNrWO8mXXUzGUN3mwsqr51wC53ACBeK+ngV5pRTtTHh1xFWBlVQCLLOeO7AoIvcObsdztbeDNb+pY56OR1rcWzWt3oqlA3hSVChcR0k++T8Ar3HvD1FO/22Xeqcs5sVZTKi52LoxwGC7ehDtcqwHNTWpgqy2T4+9/gv19lmea/OkdHZE5klFY9t13gcfHLDLo9jDtXtKZs9fTFCJPzXHhTgMI9Yll4qS4SQd49iW3zL+vW/qsXyJJfTgPeC56+SflmQfMlhnPOKiM508DY/PamJYnmqIAJQk8J4Hd6PFlwX8aqEorP63ceBkWPg3CzITjaddHj0WBZ7Ss6Lk4QI3fxzwgn5SS+nxRe5MWEWn9O28+JI1n/LMkD4ufR2n1f1bPsFf12fn1tRRL6vdpAfR9ApN+n2BTNFzrda3x680IKkXSqVIhcBbnMfnbOUeIBq0spifdkEr75Bi43QJWinzB12paCcF1gUxtFQXZ9hax2YMD6vw21glYugrcWhlc7PextldVelnnBLpHR+TxVidKdiGnrZuyECiVCBxErq3VUrzYGUNAV8pYbwwxPXwCo1JGozFEu/1sQA0A+PExkIGmp9br5JZmlaVXugXFFWXJtuH7DopFIFc0IbICgQ+CFpsatLdbCFUVopHyKhX2VbtNa29GAeB33qE+tGCeUomWxXfeYZS44QAhLULAPUBrZkYBup0dgjyJtBc6OjZUOz2PFsjBQEt7SabxNYGVndVAzw/UYimD6+5VGNwjZ7PewYDdjvGY1uD798nftiytBmJluWCxstozs7kBjCtqh6AE5Otc0MnA9KgnTQvskB0p8nrtU6VaMuH3UCdwpjnpvQteIw6dZglZPMWtWhY/fX+IjSbHd+ZzXAwTmPZ1/0qgE9FZFm3pn30w5BiOXWRaLfZbOEHACHveFOj3MRk5eNpTsWYszUg5PNQKIvfva01kQClgyPdGQzvUmZnQMv0MN8aynh3DlPRleVh/VVLai37RNWmAIglgREFP0nf5HLUoLmpPGghMAiUvCoDmpbT6kuqOnksDxhY+DbZ9JHPEF7UpDkzjIDKpzxeVm9ZPSWMaPZ70PakPoqA53jfLLL7idUQBXhwQL7M4STqfBoijxxb156Iyljl30/QqPju/vqBYPPrHV7SYCRe0WOQevchCFVcAp4eQ6NvvE5ScPKHUWXGFAKb3FBjPWMbBgdKDvUbQ7SGbN+F5PkyT2/X7+5Rgy1iae5vPA7d2qwSpylkttPyKWdWZcIu9q74jg7U6CNr9ADBNco+bDWRHyotfXvqyvV+7pfiiZYKizhmtirUa6+t2lTmYYD97bxdwpyiMr/D6ro/jY6o3rDeAf/ZDAmIAIQVEQjELFUEkyDIAJmMfbt/Bxk4ewdgJUWjgA0ZpRY/N+AoZE3hjl7xi2yawKlUtvHY/h4ujq7DOix6jwImwhVh7L7oMmDIYEJwLPUIozcLfLhYJun/+LVo+P3707PqmUgFgWbh81MHqd+9xl2A81ouJfIFtHo10GLzBIAwogZMnuD7ph1xlsVYHCouOx0Cu4tOJTxY13lQ7UrrkpqNe5/HmJhcu+RzHvVJWIZE7mlteWyMwr61pMDgasj07O8rLU1lGq1WeEz65cFNkoSTRRRobwPFjmCb7VoQdajXg0UP2YZQf7HmkOdTrwEZD6053u1SZCAdQth6AsHNGfU+Hso5kA3SgnFyelmPZPbBt6EHzZ7x/UQOJRGN8ZsyEuy0UkoQk1o4/SPNTGkCJpjTgEc/zvPXfBGQg4fsydaQBm0XAPOnaeSmtj+bVFy03CQguC849fJq2EG93/N5NpG+zx8ub1xfLgtB4G9LOL8oTb2taXy0LYtP6P23RldSfck108bDs2KUdi6YXAb03ufZVfXZ+fUExDL2l6lwDxgbgK/7CvXu0xoqDU6vFN3Bzg99PTmlZa2wwz3isqRbOhOU1N4DBAEatCgAolAIUAKwNLkNAAWgRAM8D8PYvaKTkuioIgU91jLHihPYvCWIHA9UGxT04eYJR30PWAnKeR6ApXvx2ToNfiZBRqShPfQVriwWtUWtltIaYN2X+8RWCbg+tXRuZQxff/z5BTrsNtF1a7SQww3CkwZHvEyu6/SGqVaBcp+aakbfDMNMGQAupbPX7PmybOrz5gUNQbSpd5EYhpEscH9OZDuBtSVALkfqaeVx4iCJdNICZAPeJS5w4GGift6ux5iEPBkChZmJ1a4UW9GpV837zSvbLNLRiguwiDIa0yrpTag93z/Hat/JqATNDPu/ACAGmC9MEsuMrbb08PqZFd3RFqoRzrTTXZhrUSdQP09DKJ5UKLcvNTRU3WXGcDw6UV+Sp5jzIjoR0Tq/HxZ50Zr+vF4jOBCiuwDSHoaFV6Li9Hh0jez2E4ZgFUwPakVIWJdedIQq1mgaiAsQVDSmryjjv0PIrQDhj6ciGAMdNLP8Sejy8L8siDQpQqzUFlKP6xn7A31rUepyQXsUH+xeV4i/vOFBIAxc3sRqmWUEXAdM0cLHs+KblSwLbSXmT2p9WRrzORdbBZe8hDZSnjVO8/Dh4jJeVVEZSeWn3GwXS8XLiKW0uROtIam9SnfPGNg2ox/vgRefVvHtJS/PanpR32bRonG5azquUXvSeX90UKIuRP1PoaEiEZ5oEkIMBrb/tMwKUYoEvVuE/+j7BQ/uMQFV9v3zwBPB9zB4dKCDrKG6jcvyxbfplNQn0LnoML10qgQoQJ0+UQ5oC7LU11jm+InjonmOy/xjwfRw/HNJC2O/j4wdUAXAcAOMx/3oe2xgFxHaO7QG0I55oxAkwaN0hILMsBfxoNReecKlEFYWTE26h/8nvqmBped21FxEgulplUVnFK4VpUtas1yN47HRweXKlVT0qq8js3AHMDBoNYHPbQmGrikKF/InM9m3s7QH/3K8Su7/9NvuzUuE/0TAGgJ8d6AAagiFlQ8CyqEyxojjFYpEsl5g/V7FJOW1scMx3drSSQftUV+LN9ByQkHUSwjCf01QcAbyuC8NkPwlQL1dNrV4hQPXgQPGTJ0SWBwfA0WN+brcVBcLSHIPGBsvYewPYljHManWLogLXdk4Da6nLmfB6gJOxVOY/19UqJVYmpJXIP+HB52wNiCXV67ToCg9cxdhApwPON4nu0euxnT1GOrRtbfnPKiCczxMkCzd8Z0ePpeMovrPclzdj40SFIp/TAFyQvCw426d6DFOSf8N/X7cUve9FwCAOUp8nLQJk8RQFVUntfNExmwfS4yl+fBnr46I64/WntSFqfbRif5PaEl1ILAKx8+pfxuIZrzfpc1pKal98Ti7i2MbbGq9/UbuXHdNF1y5KL/K8uUn+tLl70/QqPju/vpZiQ70ko5q/rZYyEZa1LIRsvUpUCAnRsrWpFRu8aWjuFdUE3wcyzrVWjBB9450dbFpPgJ0dfPPRRyyrVFKOfmehhRnNTWXJmxEsALQa3v0G/Hd/jMcPhmi1WNeo64Y7564LPD1xCFB7PZx36NxV8k6BWg3B8RMYzYYOxlFSjnuDS1oYt7ZYUFfV2T0HBkPM2sq07fthWGvTJE4TazegFL0s4h2x0I7HwGt3KUuH/hCZvAXDMnF92EFhd5NY3QYpBCJz1u8D3hSuC+TqColVqyHntNBcxejkMlTquN3SALNY1NHmDFNzkQUYOw7razSoqtfpaAGIzS2C4mze1IBxcKkcKxVoFSQo5mS5+cGA/fnhh6ohK9pRDtB8dRDs9XrAz393JaTJXB+copDPUSLv+DHram5ornVllfWdcOGFSkXRG4Yq6smE4HI0IsAdX7Ne2YqQ+Toaagk574wUjHyB502TSg3yubERSrgFJ6fo99ks0YkWPN5sPitnZ5r8Oa3X1c8sr+kVYfIDglWx8ConRQkl7XkcP8fRfpqWRVqMhEUXOoplKQt0fUVZ7hUwbm7QOh43b0etw76vbujupx4Tr+oW4OedokDoZfVXGnhLsiYmgeCopTbN8hi/dpl80WNJ+eLpJgBqHjCOl7GMdTHpXHzMksYwqQ1CiZhnjU0D1fP6dhnwHL8+Wk+8zvjcTBurtHkUv2Ze+5L6cZnfRNKcjpez6PplgOVNgO2L/pZf1Wfn1xcUW1kCDWdCi5qE1corS2rnnJZdsajJtrTj8JxwODvnfAnnC0BzEyVvhqB/iWzeROD58PtDRh+TQAONDSKwUpm0CNmCH1zyu1hPo7GKKxUCHCUHUSiZuFMCLjoEqKvNPIYdJ4zxITSAnx4QlGRMEMWenJC2UK2yDm+qwNI10U2rxWODSWg5Cx48DIEPAJieojZUy9izh+EW+UWPIFSCN1gWnaHqdWKO7vddlEp0juv3PZxTrQzbg1P0esTihZKpNaOtLGCayNXL2vHRzITBKaYjN4yg5vscjolLAC6BMopF4Be/w1sUusr2tjbmvnnfAooraOASU49tdRxl8Va6blnhoLZPleObpZ0tD37GSpobWtnBuX4WOH/3l5Sp9CmEaH3dvkShYmGzBJZjWQhcjxSazjl3KIpFgtV+H6goB77RkHNN0U7w7rsIrdESxMVWpG6R3ZDBENlBWcT1+7wnkW0TcD2+4nEFHq8POyjUV/Dx++zA/X2OtTAebm/py11X7xY0m5E5Y2quOaCm+A+uYJjAW2+bkR0JAyiVsLEzRb5NPWy5DQHd3/0uv5+caG1p3wfKrVUMjy9xcXQF//AK629v6sm3tcmgKFYW6JuAaWDW7SNTtEOJk8dH6Y+KV/HB/mVM84DXsi/gNKBzE0AYvyYJsMXrnGcxTKt/HgCPgrZ5IC3pfBIoT+u/NBDkx/7G60xa5CSB+TjwW7ZP542TXCvgJN7GpPLlXLzfkhYuJpKDqyTVM6+upHtMui8vcv550jLjn7Sgi6d4f86bG0nj/zztfxWfnV9fUBxNwgNuX9MaJw5HiksLQCsCtE+1KdSZ4CfvXuGb3ylr7m0+ByOvop/ZgO8Bma3bfDn3LliGO2EdW7cVATarLdQS2ayjZOEGAx4bX2HaZ1vabQ0Wvvm2Fe5Ldzo8Jnzec/V9Y9vWIduEQ+lOaCodX2snK8vid+HHHh3BcYDLAYF1s4mQNbJazxBgOy4K9RUUxldYKbIpg4GioiqDXEY1MaSomtrwC2ju7uqWslZ6HlCLcBq65zrkX6UCFFfgDK5CRoIoDmQtOgCuVvj9Vk3H1ZAt+fGYRdg2MHM8eKNL5Opl5HwfcK7heT450B0H5VIXmvaQ08BY+gvgOLkTzDo9Cn3kgWy+oK3MQl0RweTxNfWn7RzBdLUKWFkY3/42yu++q6XThJ8QasJBiy/XalqjWPKVVoDREZCvEIDvvRmCcNg2215REe4OD3Xwlm6Xg1OrsX1HR9qKnM+hULFwdnAVqkrMfC60BgP2t4yr0FHkpyLGadGT7vW4Y5Gzmbfd5vU/2/fRbLqwLJfc4KaN656DDz7QIFr+SvmiFKKUA8Pj5dYqnh4yIAy65whOTmHs7gCmiVHXQeA74XwslRBKWnz4IXcHktKrau34vNOyFrFo/jTAuGxKAoXLWnmXPR4vP6nuReUt065l2nKT+uN1L7NwiFt0kyydaQA/3sYkq2u8rKQ+Ssqf1tboZy8lbxqAvMlCaN6iJ3o8bXGTVP5nkW46xyUt8zu9ye84bYxe1Wfn1xcUBz5CeS0xcwHAo3cZLaxYJIiVLeh8jpZixa1EcQVPjxg04PJ4iNX7FVqclRNb1p0CoyGyogs8GrEO06TDFkAgImiisc5j4vBWr2uU606AUhnZ0ghP225II+31gFaLATbef1/jt7OOsg6rNOq5KNUutWX45BTB6Ap+p0drWW0NwWAIQ1QIeirUs52DZVFRQax25YqyBjoOZmOXqg69qxC/nSqgElW5mqmlshhQLwfUsHUcAiXxKxy9exV2CQa9EMBMHKDUP0Auz4Kv+27IC/Y8li9AC2C/rNU1v/WsQ6Ac0kmV5bhYBNa3LIzaQ4Kkeh3l/DUwvuKiYzTiHGnVQ/AZdLowBM0r/u+s0wuFSRoNIJvPaeQv5nvLwvTBPrKNKmZjF/7IRVaoFw21xV+rcb6J4sRoiFm3j24X2Pi1e0qjLqsimNzizoJoVfd6JHofP1EKE+facVIiMYoj6GCA4OgxjOoq61P0gunB41CDeObz95CztRhFo6HXgwJ47979tFFaHEklct3+Pm9N5qTMDdPUKiBg9yPb7eLddzUlW2g6psn54vsEyYbJsNOXHTopXh5dYnV7FbdaK1QnEQ23dhuwcwh8TaEvNcv8ndk5jB4+xjfvgb+DH8UfEqq9yYf/IMXSTfsp/jK9qbU3rZyk83HQsgxIjNcZ/bxMG5PSsqDvpikOmJMWKcuMT1qb5lkl45+XqSsJHM8Dq/OA/Lyx9JEsLRcF4PMWDh4+3dY48I8fT2tntNy0dt00xcci3r5F7XnR9LwLvC9z+qz65tVLk4naK89pjubBAcIgDf4s4rWV1eGcm5uAN8N1Z4jRiDjF84DhwyfkBJ88Yd5uNwTc03aPjmWWpWgZFoHP4aEiZSrZLJGGq1bVFr3Ntij+6ieP3NDaKSIS4qsUpUpKajZp1cvZoPVQBQKBZeEHP2CcjtNDF5cPT0P+b2gBtTKIylSJNe74WMmcjR10uwQv512En9dqrLNa1YoDGcU5rVb5V8Bqvc68ArZqNWDqEQ+WqyY8j2sXgPd8rYJoCLAtlfhPnL/eeosG5WoV+OY9zR/ebGpLpWmyDumrUd9DIa+AnZ0LZc0yJu+RkeUKmjoB0JmyqHR/LSsch2pVAXpFpQk90fwZ0O/DNIFZl3+ztbI6fklrsu9zQEwT0+OO4hHbyNzdxcY7d/QN5nO8yWZTAdonyukvS0BcLLDM0ZWeFIMBLcASzGI0pAVVAn0opOt5ev4M1cJFQO54HGL7kBox84G/8xvP8oRnvtYpBrTCn+NoC7I4QkYty80mPweeH3bb1hbLc12OGUCMm7HARllZrLYo72aaUMh9HWvffg2wLBg7r7Fgj9QUiWfz9GjIPj5+HIYGn6dV7N/w3x+k5BQHVkkA5iZgcx7QWVRuElBeNj3vmEfzpv2Vti0Cpknfk+qLlx2vw4x9j35eBEjj55dpX5pFN5p/GVCyqP/kr5VwLAlAJi0i4nXFy087Py9Fr02icDxPWmauAC/2bHrea1/FZ+fX11J8NQZ+4++RZJrP05xVr/Ntnc8R/bkut/MPD/FMxKvBZejg43nMms8DjX/841DuWKxnt+7VkPWmuO67sH0PGd9XAR4UKjtRMl/ORKEq5ZhXq6nAIFnAn2HSpVf+zEdoEZb6bVtzKz1PB7QQjqxlAZO+g1xVhb/1PMx8ckNFWxgAAbi0zeLeeLfL8mxbR7UDtNXN86hDO3FIVxAZNtPUOrMAQgvfpooyd3ysRREEbIlDVa0GrFkW1nZyuO4M4XmkSFgWC/J9YH2HFtKMaWLWH+K1XROPD/2QTisaukKfqFbJec7neT+BpVXI7t0DSo0VHe2te47BQDkryuJAOWUZpRWsmopS02gA4/EzFk2jmGfFW1sItXKVKTTT2qSVdnSl1A9yHI9uF2hsKBk9j1rAH56iVgMMq6sJvK5LJ7zGBlcgVoYdKYoVjYaeEP1Lfu719GAdP9YeaxK4ZTTiuCvVB+BZaWyJuPjxPhczzaYOy/3wIbC9xWsMhb/P2kBXcdC3tvR8MUxa7GWBImB75vMhJHNFAn5I99qKbpHP66jMnxwCr+34ofqG46j54E7YL81NZpTFrmXB84BfeMfC2bEXztvjY71wS0uv6hbgy06LgEJavpueX7YtSZbhl5WWscTF86W1J26hnJeWtWzH8y4Cq0kW5SgwXtS2JCvrssA3aeyS7nMeYI3XFbfuxuuOXhuvM3ov8T5Zpj1J7Utrw7z2PE9aZnGy7FyLp5uMsaSX8ew0DOP/BuBPAegEQfCWOlYD8LcA7AA4BPBngyB4ahiGAeCvAPiTAMYA/lwQBO8tquN5+/8rkALMXB/XDw75Vby1TFNbhX2fNIIwKIBCncUVFIvKLy/PQ2J9/OADvpe7XWJpdLsIHBeOo75bllK7yOrIFkdHbMPBgVYIKJUIVkwTOHqM3HYDzSYBaL1O7NZqPQtqTVOHLI6CEQGf04Gj+cIgODw50TRjmKZeGNg5wGHkuWJRgxPbpsVVttHFwhd37i8WdYjfjGpDSfE215XqQ7fLW99QXGUR/PA8sH+qVRT2btMi3CwjW13BZEzgOxuQY/30iGoWT7s8ns8rarSi4WZrZXK7fU0FLleeDf9sWKZy4JsAjz7C+ZGDfp9jOXz/gMBW+ALOtb75/X1gMCDTYaSM7I7DeeRc63EsqUhxLhc+RqWMSd9RHJgLzodejwye0Qiuy/7rdkGAB9AcHm4HKGnA9hmvldDM/T7PDYbaSU8AsMwz6eBSmaBdLNqmicFAq0mEanNqbmUtDWTl1kWA4+FD6i13u5Rg21KLo/Muy6lUWEbOpjG81wN+8pD5zzu0/p61NY3i+PjZhZ+s0WQjZ2uLeeReTBNaYs11ERx+AgA4P/Fw3vbDOQfPw8aWGTqBRtPPHqXbbV5Fa8fnnZaxsEVTmiUrrR/TyvKXPG9G/s1rw7Jp3rXPe27Z+pYFn/H7jaekvlsEoJOuj36XYx6etYTGAaYXqz/p8yIwlzZH4gAuba6llRMFvPPmV7x9y6Q0oB1diCwqb16/L7rmRRaMN1mURev9jJ+dfw3AH48d+0sAfisIgjcB/Jb6DgB/AsCb6t9fBPAfLVPB19dSHE0np1R/KK7g9PuH2Py1uwSF4tkvQEJoFQAytglLafYOBtzaj+LmEKBaFgzfxa0az033P0G2WdOqFkKZOH7MCzvndMACdJAFxWE1LBNZ20S2WUE+3wut1RlL+1wBGgOtb1mYOR4ytVXA9zHtDTEZuMjVsiGFIZ8nx9fzgHUrQ8ul6LeaJjIWwYxo/WZL2iQtQTTEKn38PlBQVr7QP02BK9MkkBJgbNsEU5bFwB+Vit4ir1Sg1BS4QMjWVwF3gmDsUKKtaOKy50fyehiNaKkWrvLPvw1a3a0MVorArMayX9/l4mQ8puXy9ha37D2HjpFieRQgdzkAyoOBkl5TUQ4bGwSzKuy3aToh66RSAYzRiOM4vtJBNHo9Wv5PngCWRVUNWaB4U8C2kduqAZUKxgeXoYRc6OTX3EBoupWBHl9x3o6vOBD2NdD1dSREb0qLsTvl6qe+zvnb7SLwfBi2irqnoh+KNV8WP8IT7/XUbSuai1AiLIvjLnzqYlFZfi3uCDztkcvdaHAOnXWAQp7lZkyuHYSKIYsqCaoicyajzrXbem1qWbQ4Hx/5yNmk0xwfuMiYrD9nAycnbvh7XN/ycd6RbvOxEnGqM0wC9Wek4iLpDyzFy6cvop+SAMyitswDmEmAbN71SSleRhp4jYK2ebSCaJlp35PyJ4HItHuU4z7SQUG8r5fpo3i+m1hYBSQuWvhEy5Z+TALE8bYsCxRvuuBbNi0735JSUv+n3Uca6E8CufEy4nnS5lRSehnPziAIftcwjJ3Y4T8D4NfU578O4HcA/Hvq+N8IgiAA8APDMKqGYWwGQXA6r46vLyj2A/g+GG2sWiWv08pic3dGk1RxhQ53x71Qa3Y6plNbrlUHAGT7fZgmweHDh7xMgguIXJR4E81GDmo1Zbw76KFUUiGSK6vaAQoqf+ecNIbOGc1ioqPc3FS85DMMBpoiUKsx+hs8L5T2siwgcD1kbBNBn3SPbImOSR/+7hWOjzXYcF0Cl9bDA2RPTgAAjw+8EKxcgfeSbdaA0QiTkYdcNY/1nQxQLCBTq+HBf/wIrRbvu9OhJRjQlkcB7aUSpeImTkQSuYtQli3w6TS4O3AB9AAQ5Nbrmqbtuj76faqMiTiD62oRhb09NcbjK0z7vG481gsIoVJUKmyPUV1F1rkOdwF8/zJcBMx84PTREDN/SH52q05gu7dHcNnrI1c0ceeujdlIgfZeTztOuhM9SMePNefFmype8FhFPskpuoyFWo333G4DrxcfUzbN99kJxRWiz0cfscyjI4S84dqa4gybBPC9HuAHCk2amB6dPiNqUR530e+zzw3T//+39/ZBbpz5eeDzNhqNBgaDGQ5BcAiC0HB2NOJyuYqslbWyLMvJWt5snL1z6pJy4nxuzsnVVex81CW5pHLnSq4uV+W7S10uV5XL1Z7tnOuSeJM4SWWd26zXsqzI8npX0mq1EsXlckej0XCIAUEQxAAYDKbR6L4/fu+v30arG8B8kRxNP1XkAI3u96tfNJ73eX8fXjIRti/nxZ1pqigTvNDhDIDZLPB9qbqmQOObNild9tISRXawbeCpp2gBwjsYTH7Z1IYjlnwgy/In7eCMdv6wwppGuybJUgE336h55aZN9RXn8+9Wbc9cR9fVbgLnRuHyIx8V0R/FiMBeFalJCE/w/HF1jPo8+CM/KSmJUrQmJeSMUYQ4SpEL608YAY9qh7/tUWRzlBo76rwocJ1Ri49gWWFjF9bvqHsbReJG1RG1gIjCJHNvHKLIeVgbwshvGOwJzgl+Psk9jZoDky5u7gPO+ohuFYBUFXEewE3feRvyWEyKw7C1RXFte9duQmg3kV0s0K9tJqNCYrG3/9wcUK9TQgcz7SU6uFezYRj0Y7u8TMQhlyOekzLlD7Tc601kiRizgtzpAIkbt5Bau0VkU9OIYfR2fbGoUrRFzlvDZhqdahu3NogwFYvAmcVpmZL3HpDLQdgDnMna2G1sQ+TICclukF3u+jXLc4B74w36u90lAlKvA9+7AXzicg83bpBqy1vmliXNJFot7LToq7fT6FFoMW0KuHHDC7vFBJjJNkBlscB57Rodsyyl+gFUPquNbMkyP0/DwjbTbNHC16yskK0xKYPAk0+qIB+ZDN0DQI23psFTE7kc0wT69S0kM3IFYNvI5ZRC6UezCfSqdRSLQFJ6PFJCQQePXep5/Upx9AkuwLIUOWY2WSwqJ766tBsungfmTpFd8fU1JA1gp+MgvbamjJYB1XjJUjsNCykD0LqbQ7bcd+v019+PWo04NmcH39ZJKb24qKI6sCKbzlBkD78JA49DQqex1DRa3BmaMs/ne8g2xVzXjRuqbI4uwWrwDz1DxzhCBSvRhYIMcyfvc3JuGhz6MGHbgG1795vXGwzetVlfV4FfgqTcf5uiEJPiveOgYzYJ6RqlcEW1YRwJmIQYRH2+H6K0FxUyysBnL+rduDqOCmEEL4zQa4i+L8Hzdd8xP5EJEregMjqqfVHv/e0I9mHSBcIohBHfqLInXSCElbvXcw46T/ZxfV4I8Ybv/Rdd1/3ipBe7rusKIdzxZ0bjMO7nfYEQ4nNCiO8JIVaEEH9bHrsohPimPPYvhRCGPP73hBBfGFUeb48zcbt3vQY4A5neNku/qN0d+lV2HElY5ujkTBrI55GUZI1tVv1e9rvSaQzdHckOkkjMzSAhHbwyGVIrV1eBD96U0lyrBczKWLK2LRNWaF762p0aEWKO9WsYkBnPUorMd7cxaG179pk7tTYcR/kNblaVQtdoEHFnUvDdayrTdbuluPn8PPVxp2UPkYh23UJ7pYb3V+kcFjR7PbLhlNHpcLtKbX77bV+7oXzA2BqAbYFbLZUxjUkMJyXJ59XwtFq0Rf+9G9R9oanwYZqmTCn43vDnfUuGh5b3rdOhXQBGtapiHfsJE+8ENJvA7noN333Lwvo6rZ1ef43698E60K/U4YVQ6O4oA2eO/rD0qFR0t2lHoLtNjcmf9qTZ1OJ5b1HiNUSXk6e66aXLhqYhO6t7fWbbcL5/p6V5w/q6MoNg8sj3gsdUlypvJkPj027Bi1PNBPduQ4W+Y5VfB5Fq06TkLGx+0WgAF8pUVsqkrIO6r09MtpO6crDzO3Jy9AnHIXK+awGdaluNLQAsP4ZiETi9MI2Z0jROFw2cLplYXCSl2jConIUF+lcq0d/FRXKw5DkbBd4C3Mu/hwmH/dw8TBzkx3AFJnUAAGtpSURBVDg43vshgpMS4EkVsf0QkzAiGCRdTsR5e8UkBGuSz8Ypu6PKCvu+hNkf72UsJ1VS/eM4DpOO9WGcE3Xv93Kv9zMvRi1AwsY07N8o7PPZWXdd9ynfv0kI8W0hxDkAkH9r8vgtABd855XksZE4FkqxECIB4B8D+HGQBP66EOLLAP4egH/ouu6XhBD/F4CfwYTG1IBKx+w6RPr6GzUkF2X4q6yMRlCvEwGRJhT3Kj2cctaxsdLDTI5+dLtdeIoxAI8sWxbQX99EsnyOCE/9LvpSIW211PmWBdx8s44LV2a8XLi76zX0bcB16CQOc+WPDOA4kGphUklwRgoJTYNhWICe8EjduSKR026XtrQrNbr56xVgAPpngso+O0+qXKMBfOo5KbdqCZWFAcCg2cZ16Sz1/PPwFMpslpo0kKSrVqPyvn+DSBOrd4UCEeVGg4odOHRtt6sS+d24AXz8slL/OA+FX23f6RF5S5vALUn8mXSzvfSFkhJWBzaNOyf8SOikciYzOmCm0a60AVA72Ma53VLhrPN5+iydGVbC2WRlYNMtvFDZlNJpaljhLRaJBDsO3bfr35OvKfY1utsUgziXoz2g+h2Vn7rZJCc6gOZnd0fe+yRSGQ3QBBIypNw0ey0CONOpexEX2HQil5MOhqCsiEldzSle+HQ6Uh3v0Xy4dg2oNgEBIAn5YNSIXAJ0T/zmC6USjcXiIs0txwFmFknh53oAWmxwxIn5eZoX50vy/mhqVyEr79lOrY10OU+TRNeRnp+RnRt4i0jD6HnfL//Chs0/WE0Xsv1Bxzs/HjaiOymO6rn5IBFGavxqYNQ1ezkepdrxNaPmwyiC47+Oywn7AfafF6w7rKwwBMcpatzCXo8qk+v3/x1XxiRlc1mjyP+o+oJjouPD9Y6bJ/42RJU7KakOG9uwevdLgsPAbQ1btEy6cAgr8yCf36dn55cB/DkAvyD//nvf8Z8TQnwJwKcBbI2zJwaOCSkG8DSAFdd1VwFAdvInAXwGwJ+U5/wK6GH/TwB0AOxMUnAuRz/87HzTuX4T2SXpkc/xvOalY5XjUNSCSg+uA0znDbTrZJLgT68MyOAR8sfcI8aFM9ArbWx3gc2Kis/K13QqW0ibpOYOpFLG0RmKRSIYMuyqp/TBkil7M1NEvHu7gN3HKY0YZGqOQlWlAPQtG6urVE5Kbn+zf1HXAnTNyySNxx8nArjToMbpOqB3tiHyc3DrDVy7RuT68cfpmukcKbCapiKEcRvbLWo3B/fgUHEcYq7VGna4mptT4bK++Q0l3LOVAQuvfM92uvQZc0fbJmJVLpMdq2FQGdwuP0HMLhbQXqkBto33324PiZB9S5mXcLvZNjqpq/TGrLZz2Z0OxTKeAciYlm2Ilx9VdgMAEd7ONrYq25i59BgRaMtS0Spsm+TOqvwe60nF+OU9dyVJFrqmzDMA5Siam8Zgpe6p5fx3p0ckk6NJ8BzmxIZsW8zKMhPL81JVTpsqdbbjKNtfXhzwnMlm1Y4AIH1JazJ6BIiUstMdK8VsKVKvKxMaDt8GyLjb3MfabVLbfWy+X6esdjc3iJgz2ed+BJVh2wYeWTZCk3ccc0e7I3tuHhbCSMpBfmiDxFFDeB2TtGNUvVHnR5GmMEKsBf5O0rZJSEoUCQsbZ39b/OdpgXPC6tYQHf5sEgTbyuXbIGIyblHBf43AeXw8SIyDxDuIsLkTNFnZKyGe9NpJSeq4Obdf8juqzEkXAkEcUUi2XwU51eWFEBsA/i6IDP8rIcTPAPgAwE/J078CCse2AgrJ9ucnqeO4kOIwg+lPA2i6rmv7jp0HANd1/8G4Al1pdcI/kKwaA8DW9U3PvLhvA9nWFlyHfshffRV47jngwuOzQLeL6TyldOZEEawQb7XIEYgDF6C3A+SmMT0/hel8H+eLFm5VlPLJ2/Bra6ody8vD3visbmoaqW8JQ/NitXqKpJkCnKTnuNdvblPECMvyyDR7/zNsGygWaKsbIFvUTofUUFZ3u11JclcanmD8A08qm9O7dWW3ye2/cUNtzQNEekyTyA2TLV32J2iPzDbE+TyRm5mc2rZntXYqQ/9qNSJQ+TxFOBjYND63KtSP5WUau6kMKDW1baPTcpCdMwAtgekc3VtbbtFLAdIjcnfqRMTYibLZVM5mTCIzGaVSM1m07Vs47RmuykQonY4qWNcps6ADWtxUb9Nxjkxiponw8eqK7VE49beZgpibxaDeRGJhYWi3ABsbQPEckMthZmEWjtOkuMsA0gtkEtRerXu20+xwdr5EpiD5vLqfsqkolYaJcrFIpPZuA/jY4jCB5td+0xherPjDBTLY6XNxUS1KLEstBHW5iNN16fDpOMDVd2jLQaZI36luoVJRc/xCSc2halXOe9m+gU3z0JXDOsqw+BiT4kN/bh4EUT+uQUIWdl5QBQuSSQfRhGFUfWHH93q/o8obR3RHnRccg1GkZBLSMuk5XNcoouXHOEI86p4E6/O3k4nxuLJGHY/COOIYtiiImrdB0n2QRUJUe/ztijp/FNEft0gLO3YY8ymqnoPAdd2fjvjox0LOdQH87F7rOC6k+EjB4luno15zvN9sTkO7SaHX/DaO/pOSmQxmOh2gbns2rOUS/ejncnJrXteBjVsYtLaR0EnZO1twvGx0i4vASy/BC4tlyx/tnR59zioaJ7JA6QIRYs6yV7tNUSt4K761BfQMsrFtWJjKyhwRBSIxgCItxaLqW7tFxIHNNVyfwsbksF6nLedKhdrCSjegFGLf7r0XJiubVcS13VFj7z+v0VDRKPwEfmUF2OwCuS5F+mDl2EvW4SiSWiqpceJYutM52bYWpcne7gDZWQfo7WCzQu8NA0OqP6ulu5ZyKqvV6L6yZc3srFJEk4YiWax01l+8icVFkFmOtUtpovNz3k6EMNM4VQZFnsikqeG5GXrP3oF8A4rnZAziHA1Y5RbQ7dLiaH2dJFZdp3mRP03zs3AWaLVwyupjt7FN3E9PYmflFoQGvLeixo0zQV++TGPMUSgchxZMhkHq+526Us/PFYF3rxIH54gjpqlMT3gsHGc4rBoTYk/1hVocsikFIMMxS6dSLwKKPSDnSNPH2K1dL3YyMLwDIzRlPsSLQXa69Ij5CMPiY0yKjyUm+RH3E4+o16PKC5YziiREEaRR5GW/Ct1BMQkJHXXNKIIYPBY1bqPqCn4eHEt/XUwwR93TcYsF//mj2hq2ABlHhP3998+NUXN1kuNRGLVoO+h8C5sD3J8w0j1pfcfx2XlcSHGUwfSsEEKXqsdII2qZ3aTD7+dMSiXcaTlefFuh0Y+04wCprO7lD57OAXBcoLGFjy0SYchmmzi9OKMUwGwWM1lgRspu/Z5DiSOkStiv1D2OY9vATs/xHKkch1TVUklF2DIMYDorOe+87IOuAbaD3R6QYjLMGTx4P7peJ1Ik0WpZ2OkpR7uBQ+XesYALcrs7ZSqCycqw7BJyOaUYfuKySrBgmkSQajVSxc/khxVe5nHcdg633GwSoTo9R2pdpaIylbFaz/1n57iUSWHcpmU5uk4xiQEqJ2kAWpXaUywq8j1wyLTizMKUVOpz6Kw1vcgW/a6N+nrTUxMbDeKhnQ71j5OacEY/xt06OVIWCtQ+Xji4jiLWAJWXy5GZiblyE8vLtBOQbzXgOMCpJY0cOzttoJuWcbAddSGT4I0NKasnqWELC3QNQBnuVlZoYDc20Kn3kH1ymcxpervAm2+SmYaRQuryIhnwVm55Wf8yGUV+S9KOV9PodUKnRRLPGe4zc+9r1+j4s8/SfeR5YRg0L6aztAACaGzYvIJtlAE1V/yJOtjChD8zTeUAurDQ8DkLOsBKzbuWnVy5XMehtt+uKltixvo6vec5l9CTeP/99yGE2PY9NrKzOJ4PdokDPzeBDz8794tRipb/nHEIEpEogjWqvFHEJ3i/w94fhIQcVEk8KKLIXnBMgv0cNy5h14R9HtUGPu4vl+/vKLIZ1l4t5Fot5Li/jmC7wkjvqIWAv118fdhx/2dHtXgK9m8/1/vLCbY92O6P0rPzQS1o94rXATwqvaYNAH8CZET92wD+mDzHb2D9IbiEKf538TR13e8YNJXxXeBXjmSK58QshTjzEiv4PvOQy1HCiYXzHqneqTS9j9bXiePsdOnv2priPLZNxI4VroRO71NZ3QsZljQ1cqrKTRP5zcr0tpkMbbXPzRF50jTAHnjmC0w0U5L4PlpQBILJKcf65d16JiZMVJOGUqyZtDLRqNVUdAEvKoFv+5wdvByHlMZ6nV5zcA8vO3FTmYxwiul2S4bjkgp2Pk9tTurU1rSMSsGOegAdn8oAZ5ZmqCGLi8DsLGbKMygUaEFUrxNp2mpRuZypj53yNjboH6vCrRZFl+CQe6aplOVOR+0MTM9S1rRymcZsYUHx1rk5YKZg4NS8lLhbW6rB1U0qLJNWuwDMsAE61t2mf3xTW1tUaC6HQadHJiFraxTHWCYKGXSlPULtDlwH2GoOpwYvlZRpBB/nSBTz8zTOCWk+wVE7OK40n8+ZD/3h2NbWaLEJKDLsz77otz9eWaG/fd98S/m+m4AvEgfUQq1apX9sbxxmM8xmI6xUb2wMh9zTdfrv4sWL8D8j5Pbb0I/hJP8eIhz4uQl8+Nl5UEK4XwTHN4qUjatrEpUx6vMgQZgUwesmVTj38vkkc2+cYur/6x+nIGmOKiOMVEaV6z82qr4gOQ0je2HtCY7xJN/PqO9xsA/+OqLu66j7fZjEa5K+7xfBsY4av4/Ss/NYKMWu69pCiJ8D8BugsKi/7Lruu0KIvwXgS0KIvw/g2wB+aeJCBQBNQ8LUsNOykc7pcC36xU5ldcXiPParMHCA5OwU7qxsEeli5yaAtr4LZ+gXt7cL9HYonq8MpHrJqXsKZDariCMrYZaljjWbMjSYpimiC9DWuGdvKrOi9aR/jJ4YMuy0bVJTKxVy4ANI6Vyr0SS0AGh1RXBZzeNtbyZOc3NAtjAFmCkU9QYSs9NIOw6AbVgWhSNjm81Gg4hv31JR7Po2qclcf69HxMmyKGzY3fqws5aMTIarV+ElBeHu1+vDiT/m5qheHrdGg8ic0CATckgbXanEzizOYbfSQKFAH7+/qgjXdA5edAtdV06BvGjJZEjVLxYBI0tKY7msHPIsC0g7DtIFyliX6PVwp0nmJuzQttuibGvpOZPaZO3S/czNqHubzdJxZpicCtBxgPWbNOe62+pGZae8zIUAcG+9jVNzPaDZRKsFnMrQ7gFP1YRvYcPjnc/TOKfnTHS7PW+MdZ3mIZNNNq3xJ9XwL5D8ZfIOAKv+ro+8BhN4vLcKPFJW7xMakPDNSUDVYVlK7bVtDO26+OMq6766AOArX6F7ofvKE0b0Y/A4O9odyXPzAWKUahl1zkFJeFR9e1H6RhElJgOTqnphpMwJec3naoHjYWOyF8IWXFDYgfdhbQv7G1ZX1P2a9B5Ocm0UgQwbt7B7M+o+HaTtB8VB53oQYWWFjdEoHNdn57EgxQDguu5XQN6E/mOrIA/rvUMI72V6zsRus4eUj3h5dTSaELOKbATx/ltbQ+/nOx8gnZMyISfdmD9HZNXqI2lqMB3HC+PGNsQLCyr+8MABYJM6SgTEwrlF2bDSeWIEZorsRXM5RYitvopUAGDQ2EJKEoqz0ou/RoEWkAD9G0CRCI71yw5jrJguLADTc7rHHPl6BodYYxU3n1db4Gxzu9NTPmLsyMYOdxy+jZ3lACJC7JTFTlJMvDgJHBM5y1Jki+17Ox2q63R+G9krZ7B7dYWctXQi66lZE1tVSlRyao5siu82hhXNbJaODWy1WGGiXK0SmS89Je25s9NK3S2VZJbEO0jjLi7OgQodkiah7BU620rxz+dpMcWhMno7pHKzx6Y9oMXQ6ntwqzUIXcO9uuMp1hxNBQCgkT18JgPKdqdpmLE3vXYkNEo+U6nQGLA99J31nje+vDjrdmmhc046vSUlGRUavJThrPZzmfPzyvExaB7j/2fbdF8AUpfLZSqXy+eh838FeYHHuwxra/SelWoeZv9uB6cVZxOllEl9S5s2Mpnh77Efx/HBzjj05+YhIozgTYogwYoiff73QfIzaR3+tkUR0FFlTFpPkMCOK9OvrkWRlL3213/NqPb4CWPw9Th1kc/RQz6bdFGzF3IaLMcO+cz/N6ysqIVD2HwLw2GT1gdVR7A+jKnzOD47jw0pPhIYKc/+NpUh++Js3idVyl9Xt0khnl58UV2629jGmbIJrPcoTJtEOqtRGmQAnnde/S7guF7oKMMg5XRgK7LHocBsW4X48oIJGMDttR7OLk0rVlE4S69bLSJQ2V1KI2ymiUg5Dv3wGwCkonlHhr36+jeora7857fhHThkRpA2FQEUmjxJqtCGAUnyHSR0lTaXiTGg+nX9OpFHJq0JH7k5PaeI+uyssjkuFNRfjgpR6wAX8orMVCoq0kehQIT6u9cpBBsTYoDOmVpdI0KcNYFsFknHoagMuS4uaTVyxMtSmd2utGDI0JY+h9ar1Yis6VINZjON3TVahKR0ihnsWj0Ivt8AxRyu38HdOnB6cVqZPkiS6nm3OVM0AB2p/q6tKduMt99WKQELZ2lVoSUoEkbd8cKc8ZRlcnq35uD0vI5O00aKVyNmGu3qNqbzhrcQuXB5Gp1q27MvZvLP90lI8npunj73jwOg4jSzasupmpkI83zw/+XX/G/gI8YAp54e/rqyGcTamsq8B6hF3dracNQQL2whpN25ptRpvymGP8JLEMdV7XjY4B/DSUnqJJ+POxamTvrbNI5EjCJfe2nXJNdEkcdRCmqQpIcdC74O3osoQjiqrWHt8Jc/SVlRZDs4P/ZK9vzl2oFjfqIfRdqD7RhVzySEmOs9LjisuX5cn50nlhR3mjLQv5kGOm30ZYSBdq3nKbgcsslxgJdfhhemjbHT6IUS41RWJ1a2/Jj6te31gOYWYBgQjoOsZmOnq+oAlKOdn3CwE1yxSNm8smyaoetEsBYWAGeg5FrLIkLW2YYonoO2sYm0qdpeq9FEToImrIAiCJwul53t7jaAjz9OZiW7LQspuYPvJyvc9oGPxLBKyPaeHAqObUg5CobhUxtd37dnbY3G4laF+l2pUJtv14FcBljtUrvNHtCXph93WsCjyzKs9Lwih4DcXp+dUvfCSBHhlMy5UKCt+2yW2nu3oSJPrDeA+SyVmc2qNMZLSyo7HgBkWxZ03ULSAO6stXHxknR2zGbR79poNoHTmiASrGlyMTat5G49Sec7A+rElSvUAH/QZ8Mgp7nsFABq66k5pQzXasppsdORsXchlVxN8+LHCY2yEXLYQDgOsoUp3F3fHopJzAub21XqL9u412pqEeePtMHxipnc8jQdONSGvg2YulrX+e2LARXnenVVlctKNC/aALXDwgqy32yDr+P3fL4/CgYjoSmfAn3Ek/A4PtgfJuyH+AYVunH3YJSiGaXqHTZRiVITDwI/cQvrR7DfUcR4L4R3UnIXbM8k12mIvqd7IeZh7eEywxTo4Dnj2hxWbvB9kBCH9WtSch1W534waX/uF47js/PEkmIhgFe/2sbABn70MxqSWR1J24Zrk/LW7dIP/IsvqWs0TSmEX/kK8LnPETHOZoEzZTLBQC5HjKRUkk5RXXVx857HNAY9G+kMefQzAedoD+vr9DqTUT/wrASmrq+SvWX1tsokYQ+IQFm7ykuu2wX0BBLl84DjIFG/g1bLhmkCTzwxrNIVChQLOJejOs+XiKBcfHwamJuDsG2k2A5CTxC5kkyMicl2h8jrmQLw9NOk8PrbzoS4WKShyeeVCr6wQPW9/TYRqrRJQ5gyiLjUGxSgfRVAqQtkoR5oaZPqciHDpkmTD1Y67zZkUpU6hSM7W9yWNrtTgK5jumACvR5Oz1GdPq6MhA4UpW0xxyM2DFLSu13qA4efY3MCxwEuXjJICW7eA3I5JM00PmZu0gWcmaJWU6EqtATdy2ZT2Q7XbpMZxfo6cOWTFEWityOz3u0ArRYuXJrCbmMbpSUT0BIYOKRCN+Rihk139K4MVes46DfaeG+FPkoalCZ7fn4bZwrA6ScuAPU7aNd6kInxoGnAk09Ss1stIuJsHsNmEqUShsg05L2oVunzxUWl4DoOKfBLS8MpvjWN7iObDpXLNBRra/CcPF1HLZiYUDPYfML//tIlScRNpfoDVBY7nLLtekyKDx9R4zaOnEaR2HEYRYxHfR527iR1+FXHsD6EfRYkTP7XkywAwsZjVL/22t9R76P6Omk7xt3XUfMijEz72xN2j5kgBx4VQ2WHjXnUgiN4XnAe7KUOfh88J+rzUceCZYeN01FgknKP47PzxJJigH64BwB++0UHtq2SW7Dy1O2qH2OGX236yleAz3+e3nPmN+8kLoDfs/zFdZu0R+10e0QofHVwBjcmYUxekwb92+kC6dlZIqj2AF5YOC2h6tCETP+240l26Yw9ZHubzyvy+EPPkJ3mp5+RW9lzM1Q+O6l1t+F5ps3PA7U7uLexDcMg8nNHKrZsP8pjxGowoJJsPPEEvedzEhoAg4plZzSOVFGtAgtlUo0XbUC6FcIA3btbHeCMAdjSDnqnp0KoZTLSskTaGJ+aAwaWg4Te9zJsDDo9ivMLZ0hNnJsDdm1gxqfaOw71oVAY7qNtU6SLpAFki9LRMn8G6BaUpyFHBrEH9K0z01K9bSt7BT86HeDad6ksPSFXSIJslwFSlLNZpHo7MiRECqfntpHO6VhctOFaNjmQNZs0P6ttLxye41D3y2Vqwpl5jezeNY0WdlCRHzhpCTuG5nJqgcb3l6OnGAYtJLiOgUNjwyGUHYe+BgzOZsdxqPl7lzCUA+XSEl2f0ICevMerq0S0OYSi/6vlV47X1ug8v/LM8Id8G0WIj+sW4P3CfsdmHOGNIo9HjTCiFXZO2PtRxChYvv/1pP2bhJAG2z3JQmAUxhH7vWAUyQsbw3Gka1Q7wj4bNXZhrydZwIQR6L2Q0EkWLeMWS1FkO7hAGLeoOWwc12fniSXF7GfHP6KsDrOjGRMeVnLDbCIHDvCvfw341JP03jSBi9mW+vXNZEhKrVaBpUeJWHLcsc42YCSRXpakZ2MD79+wsbBAl/rj9CY0MhsAiKCnFwrkaKfrFK+W96L9hsj+0BE1ilN7odTznIzK5WG1uF4ne1zXARL5WSJvhXOqs6xuahpQraJd66HRUPGP/WD1jV/bNlCpAeUiHevbUiDV1L9MRiXI4HH2J3tISXWv06UvGwBsAjgl69CgHM36Ng1xsUhklRcAbLOdsG1ySuztSKXX8RJEbGwQgZudBeZyKk4zQH9ZHd61lEpcLlP7UyVpBmGk1J69maKFST5P9sAAzQNebNgDuofzZ+ncXI4U4mYTmDulop/YfYpOYdvor90ic5CFBZJNOx3ASCGdbwKzs0gZTeV8CdlnTY0vZysEZBxpKdvvXP/Au3eaRgR3IBc0CWn3cK4EGIaDVovmpuMoB9GlpeF5wAk+bJuI6ZvrdPyJEhFWf9pmNtkxTeXoubZGCUEuXQK+v0LncrjCD9aBR5eA792gepaX1fX+xY1pAo9doiQlPK8MTTkLsiPfq68CSCMUx/HBfr8w7gd7FILXhJGTcQQVgfPCEEVi94K9ksuoOpzA30nqmqRvk56zH4wiU1HtnISURhHisLGOmhthn4eR0+A1UQuYScYojMBPet1hfE/GlbGXhcVhYK+Lk4cdJ5YUu+7wFqyQZMDpkgIZ+gCQXJOz1jG+/nXfSS85+OxnHVzQrpFaCJBc1duli7NZGZIhSUSnsy3tClxc1Dbx6kvWkArH3JbjB58qmpJ0pej6lRXKbtfbUaqx1adt9somETBdBxzNI8CVCvX3fFGV78/+RYxcMopCQaUf7mwDrXvYbfa8JA0AvPBZAwzbCXOkh6rP+a5QIIetToeUwKA9MZMZv9LMgruu031hUwodIIdGAKZBxMiyFOE7kwdOLc4C5UeQrtWQ5uwpAKAnsNvY9nYDNI2cAi9fpvFpNJQJSyZDaiWbFOTzRMRaLSKCjgOkcnIw5uaI3HJnACLAjQYdt/p0nyyL7IN1ne4TO01qGo1z8RyxbW5z4SyZfNy4QdnxAJVxJH+GzmN7ZCNJ5zab6DfanjnIuSLFfOa1UrEIMh/xhRRstcgEhpJ/7KDVIsdQ/wrmdAkotXp44w3ffdGUAxxnjbNt4GpDqfomgB9YHA7XxvOCTWn8w6ZpFP4OoLnEpBogm/jXV4CnFtX5SUMRbcaNG0SKFxfpq8JZDvmahAa88kq0Wnxc1Y77jf3+4PsRpXSGvd7Ldf5zxl3n/2xUXXvFQdTVMBw22QkjvhpG1+Mfv7BxGUWQD2scw1TxUe0YRbxHzYNJSHWYoh7WFh6vcXUHcdDvWHBBdhhzaFR7juuz88SSYgBDzkK2TQpjUh8mvUyc/aYUwW3YoOd6twvcXreQ795C4qkn6ICWoC3zQoFeW7tAc5eIUmUT0HXcXrfw8UvAL/8y2eW+two8tkztMU1JXHs9lbGOFcnqJm1/W5J41+7QtjvbYOhJQE9A04jwlctEHjY2lCkAJ9FwHQDVGsR8AXBcFZy30wYaDezUtzFwKJIFk1xOcgEQCbZtqud2VaapBv0rFMh/LJ+nZnP6515Pqbgc/ouTRHBot/UulSH5MTKgGMscWI+VYE0j4sfb9UQ0haqUoz8YKaRyBjY2LBSLVG8mQyHEWGEEVBt4m51tzZtNuke9nnS+1JMqtjBAxJeNWPkzxyHCyhEnOLpEixwwkc8TIZ6fJzvimrQb7+0A1/pkV7y4SGWyaYyZptec8INjqC0sAJVNJK2bnj1vu0ViP8fEpgQrPS/t97l5+rvVBGYyQKflKNWfHQHlZK/VaBVVrRJh9av8TDBZwddAdn07UN+tICHmseZdGr6XvFPgWMqBJgHgB5dp/iQ0NSRsulMqq1jKj12C52h65Qopy1//urq/HI96FI7jg/1+4CjGJUhcEPI6qg1+0jAp6QojMqNwlEQiSNLD1NJxJHUvx/3lOoG/UecEX3P54whx1Odh70e1dxQxDCrP/rKi7vOoxVMYcY2ab1FjdpiYdFwOModHLS73Q+SP47PzxJLiMJvXhKZ+jPnHmaND6Do5k7HKxmU4IXf95ZeBP/WnpRnC9evA4seo0MVFMpXgX3tdJylLmkKcLRu4W7Hw3HPAa68Bzz1H6tu8VFYdB/hgDXhkVjbSF5MYlVtEjGu3FeMwZMIPPYHdSgP1OnGljQ1Ak22vVlUqZjbX8Ew8cjmgKSMSZ8ipy7JUFAImsrxlzU5RfqRNZYZ8+TId40WI4wCObwZyuuWqjEHLDlyVyrB6r/v+3gLw2LyyQ15eVu2ZnYVU0Xs0Nvk8jVOjATTuenYRX/861bNrkSLsOHSrmk1SnTMZGhKO1tBqAc88o/ouNEhiOiXD7rlExOt3ZArum7Qi4PjDVl/JlZkpxcrW1kj1XVqiezt3mohu7TaR38ufUFnuymU6ruvUJzMNGCnsvPYOOWR2d6gtoCbUasoMZH6e+sOLAQ6/x7bVAPD+1W0Ui76Mj6x+A9itNLzm6rqKyOLf1dA04M0q3bM+aPHiQn1f2EzIn9WOTShWVoYXpUyid0Fq86cvqfm6tKTmnGmq99N5A7fXraHvqG0DH79EJjXf+MaHF7dROI4P9vuBw1CHR2EcsR1Xd9iPeBjhCZLR/dS1F4SpiWHlj1oUjFIhRym0o+rwv9cCr/31+su1A58F2xGm0uqBc8fd4/0sboKIGsvgPAgeCyq7YUrzJPfmMBFV9iTfx0nG6CDlB3Ecn50nlhQDivj645QKqW55yiyIkAHqx99vdhEM88RIaPLDTIbI0bM/LCvtwzOjWKuTa3+nQ0xgYQGnyw6WsYJLl4gvv/IK8PzzKq4xkYQmLnLOYCMFONTCnTfe9SJknLL7HqPYWHc85zNWPc8UpPOSVGlLJSBVlOU17qqO1CSxq24iVZhBv7I1FEfZr/gtLJAyXKuR453ftvPJJ9V5tk2qO6QiOF0g5pVs9FAoqLBfAPHYtTXg0Ry1dd0ClnOKeOVyKmEEq92MTgc41WySJNrrkU0uALdWR6NBdXS7VF+1CmxWVBtv3CB1GhVVnm1TtIYrV6jv0zmqI6mD0m6bKWUsresUgm99XRom94nkcuQOIwm0yK4c5TKwcUvlgW42pcFyW63C8qdJfW42lZlF4Szd0Ow0nd9pK5Le3QbmFwFNg1NrIJ9XGeB4HrdawNmihrs1BzN5HSicxZmCAzTvYaYkF1SaADJTuPv2LZzO0xjZtnKu8xNSv9kDoB6IbD7Bny0s0AIkIRdHvGPA97RcJhtkXrCyWUUKpBDznFpeHlapFxd9KrRt4+w8tdeU0Uy4vZcu0fz75jfUveU6gjiuW4BHjfs1JqMIRhj5G0cID+t4WDvCrp2USATJV1T5YWpo1Ll+chpGWKOu43qiMIo0+j8ftSgJa/8o8h3VrrDxnXRuTqq8RtURPD6OVI5SciddyIwj22FtiiLveyk3qvxROK7PzhNNivnH2x/k33UU6WU/OY4MwYSL4/Hu9j689co/rvU6cGGuSxeVy8DVd+gDq09EY3lZstRNZfZgpoFazYtTvLxMZPi112irfrdHl2SzZJqAagNnn5DOcGYa6cVzGGxsetv5W9UeEjolpmAPfHaGmp0FpSK2dkmdvPSYzPOcVoy02STilUkT4XMcZC8nvewYycotYHYWF836UCS4zSoReE7owSQml1PZ4pIGMDOnqQEzTZTKapVyKm/jTtXB3Bz1vVolcrwL4FqLFMPnL1OZ3S7VUSyq+8qRRKAnyImNlfVcDmJ2BqeNbWxWbc92uF4nVfjWBjyzkHJGrjsMZSvLbWcziuy8jAZhpIhldjrE+jgVs6aR6cnCAq1wMmlgYwP9Vg/Jy/JmbGyQkl04S51gVbZxV7E8W9LKbJZsya1dFfqvUqGFl+N68bKnL18A7AF2NmiHwDBUIIz/9Ar1ZasFnFmaxuliTk7aO9hp9OQisQfHkTGHu12cXpjG1kYb1epwNA6/jS6rum9skDKcgXoofqpEpJXvEUBzm+2P+fvHTnuXLlFZa2vqe/fk4nBMYn5t28Ann5a29nqC1Hcp95/L0HyeXnkPnvmKmcaVzCauPDONf/P/tL2U1V5okwAe1INdCPHXAfwDAGdc160/oGY8cIQRoSBGkYFx145CWDnjCGXw+CjCOY58TYpRaqWfwO21/GAZfMwJHJukTWFtCzs+igwHCd6ossZhkjkSrM8OvN/rfNpLO6LaNEl5QLjCPWnZYWMQVv44xKT4GMF1VepeJsV9ezgEGh/flSQgGRgtf9gqYFil1HVgc7WHc0tTw8zZtomdNBrK+c62iYzW64C16zmxDRxgJgf82T+riLquAzOlaRVdoHabTASqm4Btk/3tOlBG24tgsV5VySd6PYqpTHvVLrEUZkvcCX6fz8sgwwMibRs3lcptJEm9rGzCdZS6u74OPFKmbHXV6nAIr4FD1bIjHEzp7m+m4NYbXhMEABgGzhRtDHo2Tkt/skIBWFmnSWuB7H9ZlDUMshdNScI6O0tjdqbQULmluzvorBLhv1snQsahgZOGUhVP52kBUu9SGcUiPQh0qUi3W4qIo9mm67U1FVh64xbV2WqpSeE4RGY37mKnQWH40GgAmoZOw0Jz9QOUnl8E3nqLVgF6ksgdQCsaTudtpqWNeJIWM7waaDQAIwVd/4AWO7LOdH4KorE9pISmDKXY8vjDcTDokAOl0El6TXhRTMipc2beRK7ew8oK8fi3O4DRAZ6aH7YBfqqk5uo314BnlyhSRN9WCyS2X7ed4WQw8/PKPl3TKCHLzXVlZsHmGUzEHb5eSxAh5jYvLtIChNP0LSwQwzbTpOo37wEAXnhBJeYJw4NSO4QQFwB8FsD6A6j+ocUkhHjc+aMQJFn7JX6jECQVYWreQfuz336H9T/4ei9K7DjVNGpRME799b+3oUwygmR1ErI5TpGe5P4f5BkxTrHeL/Z7bdiiL2rxMKrtsVJ8zMAh2XpS7WXVilUwv/lE2iSzgL5NP+TBrVYmrP7sdHzt+1e3cbHQUydzhjKrr6IROAPA0ZSTFihdNBzy/J9ZLgCWha21Jn0o00XTdQ4RY2kmMbCVI5g/ssK5MnksTfMeM+9NLz9GZCs3Q+yw0SAyDBCpu/xx4OpV+qzVIiIPEOGo3qYMfYaO2rqNmxtUV7NJRXS7anHB6YMLBYqzfGZxmhRcAKjdgZibhdtoEsGxbSL6lVtImDru1m3MzRE39LbhQcQVIL7DqZp7PXimEZcukaI+N2cjqbcA0MKGCVxFkmC+byVJ5jQNuN2kOloWYNSVfTPbPV+4NIWd+jbqdRqWR+SQefLm7CwRsm6XdgbW14HCWew0KPvhmQI8eTRbnEHa3KJ04PNnifBy5sL6XXqdnVaku7dDDZ87RY1aXSVCCKn+6wlSjmX0k1KJxpzBJgpnC6Bzm01g/hwSGUORSnbSNKRqrSextdHG2Xn6LqytkRL8hLRH938nPHHbBv7476fEMGz+w4ow7yxoGh1Pmuo9E95SaThOOEcC8feD++ep67OzRIg5DjSn22aizMbV8ktrWcCPSWIchQf0YP+HAP5bAP/+wVT/4BBFSA5DlZukzrD3fkQpxVHq7Lj69kI4uNxRZCx47bhFQ9RCYBJSOw5hZQSVzHGLkOBYRZG2qLaOUkJHjXFUmcHx38tCZS/PkqOc71F1jBrD/RDjmBQfI0zPCPyhzwvsdBzPsc62h1WjXI4IAECqsOsoshsJqYjyD3avBwxW1pAonaMwW4WC/MEW8LbFezukLhopwNr1CMbAlp71kpiwOUdnvYFsYYrIk8xi59oOSgs6Ntfpx/5sScfNVXs4Wka5rMLBtVpA/hQpqNYubd3rOpEyHoDZWdr6L5xV2R5qd+iczjYVPHcKsG1UXrkFgLjzwFGWA5kMkdYrV6iIel069rHBcatNJN+2IeZmMag3kTBA42OkcHd9Gwmdol2Uy8C714adOzhdNEcTmJKqby7H0RXIyqBcphvnOESa29LMQGi06LnrqLXA9esyKh3oX6sDXL0OnM1TGLtWC9i4sY2zBWX++0h3m8aRozRwspPcNBHi0gWg2USvR+bjnQ5wMbMDzM3h9tU6DAM4NZ9U9sb1uzKahZRFC2ekg54ksZc+Lu2IO/Keyq8yJwmp3lbxkO0+0rMZ9GvNIdKp63JuMbE2Uj5G2x8yFO5XG8hmieOnpGL+dHlY+QXUAtEwaFGiaeTcttMjUwzPB9RQi0wug6fEwoLP6dMHv+MrAFwo03fEceSHZpp2NPzGzrzK1RM0fqXzXuIWQA3bH/ws8Pd+A6G43w92IcRPArjluu53BK/eHzKE/Xge1jiFEZaDKLKHde44ArFXAj+OUIwicxhzrf/zcapz1L0cpxyHlTWKZEa9D5YdtbgY9XlUPXtta7CuqGvD2n1YeBBkeJJ6RxHjKMSk+DhBCMAwkM6Qcsdxil94Afja1+g3tdORNpWgUGMAPALtj4f6I8/RX/8WbLEYsDfWdSIqmSkilFwYS2peVAoiVQPLoZi7i5RpDEbKSyU8cIBObRvZ0ixg05RkAnGurOP2ho3NdZsyzDnSbnNe2h5z7DJd92VbS6nGTuWB3S2w8x4uLMlMGOdUirC1NZk0RNBnFSLEnMmMx6JaJRvm6RzxNk7MAABYvEjEz0wBHRmNobeLhKFR1jmrj0FrG7pOai+TJhkLAzZURj6A+CP3dyqjlH4mf37zk0JBhebd6aroGLZNaaE9sxpQogcNtM3Pob10nYjh7RplybtbBz5YsfHIJWabspXV2/TaSNHCRxM4JYe8VgMu2n1svnYTdxtU9imrr65zHOD6d4n8zhUo/JrjkN1IuUxp37rSUc9MAcXzNOC23D0wU9SW7o63qEoWaNHBZkHNJnAq26J7baTQqWx5pkAAoHXUQoKnq2mq6CD+cfWDHVd5rGybFhMcuq9YpPH2zxW22+adjjv14eyIa2u0sBrY9J10HWnPrWlob2ypbDd+uwp+z4tHgF4vL1MnTBPAcB+D2OcWYF4I8Ybv/Rdd1/2i/wQhxIsA5kOu/e8A/B2Q6cSxwl6VML4GEddNQqSOCvvty6QKLSb4LIq0+slqFAnl80K+ngdCWJ2j7mEUxqm/YUp6sO4okhxsVxT2ssDwn3cY83A/88t/7SgEyz3M785e2h2bTxw3BBSYgQ3syG31F14AXnxR2vXa6gczaRA59ptWPPdcePHJDA1tv2sj+fwP0XY2QBXwdjjv4/d2AGsOKD8CVG7BXt+ErgPpywukblkWEZdCAWn2ZtJ1YjWlEm0RG0lwurqzCzrubvTQ7fqcCB2HnpDcGU7NxoFg63UqY6YEpPJA+5Zy7uIwYkaKyLCeIPV4Y4NMN6D4vWEA211F3h2HiGevp4IrVKvAzPXrVEahIMOWbXgMNqEDaDZhWXQNOx7aNiVt6EPakDnD2fRMU3Vpbk7lvQCo/lN5Dbtdx+NMbD/OcaA5fi+nihYgMmwaqr5GQ8VhNgwatkaD7JAtq4dCoeeRNv+i6G5DqcxM1L/zGiVqaTSo/nJ9i6JyrHyfFjHF88D6BzTen/x9xL4BmeUuCUx/AnRT7wLaqiLkhkHzYvV9QE94CrGmUajj9XVS8JMGcKuyjStP6ECxiCybIJhp5TWn60hs3PQy2zEh9qu73F9eTPjvCydeAVTGQL4nbBrBU5JV49T8LNxa0yt3bY3qYEXaS4ku+zu9mKe5yZ3kdOdsZgQMS9G2TedI04pg7PEg9vFgr7uu+9SoE1zXfSHsuBDikwAuAmCVuATgTSHE067rVvfelPuLvfxoTqKsTlrefojZKByEsIQRs4O2K0iC/YQ5quzDIl2jSNUocj4OQbI7ro6wa0edy6/3Om7jFhv+13shm6P6O26RcBDcz8VkEDEpPm7Qk4DhIJu1iEDZigt85jPASy8NC0+sFielmvbMM8OK8dDkk05kyeUyZRcrFIAb31OZBpgQa5qMVSsZhZFEsrIJd+OWr506ULxA7IDBYQbsgWd+gIUFT2XMZHq4epWq89Q8I0nmCrlpIrqtLS+WLScQQaFOpHj6FNC+J68zlO0zQHbFuu4xxDs1NU69nspulzKIe+/0FEHtyQgaFK1hi9RO2yabZul4uNvsITWfQbowjVmrjR97QSUC4cx+jkNl53KKjCflP9OkrflMhs4rlUD2spaFVFaXXbK9PBeZDJlTJA1q+3QWWF0DzuSG0waXy1TuOem0yAlGOPEfZ+hjh0y/E2dCA4Sho9WyUS4r0456Xa1x2L5Wq9YgSiUaH2b47S3g9FlgpwUkpyF1bNBX+Ayd192mRnLoNnlvkwYA08S9Ss8j4KZJ6nShAOy0bMr2x46PHKUBoEY98QQSlQpQqyGTAS4uKsKvaSrrnD/mt+ejZygHO0AlVWE12Z88J2kA2TwNeKFAanqlAnxsica0XFb3wzRBB/SETGOeVERY15Va77i+ZDdJZfzsDABbtTGKFN9vtcN13XcAFPi9EGINwFPHKfrEJCRpLz/UB1HVDuP6ceUFSfBe6pvkvHEELaq+vbaFrxn1PgxhymTUtVELof3UMymiiHvUAmZSTHJ+kJBHjc1hztFR8yH4+iifbbFSfBxh9z1JK2XQD2/fJgcu26b4wK+8Qqf6Q0ABwI//hO/31fmwSUW70sb0pfPE2jrbRAKffZY+5KgCmqYyrPV2gOvfp2PFcxCOowhvdpokxu4OOMRXv+fAcYBUdVOZP9g29SmTwbVrpAqyUHbxSlOxOwBYzhJxYMc/dkzSddBXJgtkLAADRYKZ6VQ3gUIBg9a2pwSy+QLbPSekkJ0y6V+nQ2arCwty3MyUSkTBZedyQCaN1GybSItmY2YpDzgOsnny2mu3LKysKCXSsoj4M+GenaXjs7NAdo6I8E4XSM+lZQSHXfQbFIbrdJ541d0G3ft8nsLJLS4SEdvt+cRHjWxkDYPUUseRif46qn4mdqmMuighieacs4VvfcP2YkIDZEJQr9M1Oz0qM1nM073mcBuPPw6cfwRwbeDOJpWbTgGYAlAD0KEUdEaKsuC1WjTQc3NEFjUNyM2gU9mCaVIfprLAp58GkvNz1BB573dvfOCRXcuSTnuOQ8zUtnG7SrcqqQ+bSFy5QrbeAJFVvp383XAdUol3LQp55x/DYMpnoIek3sMd6dxYKlGiDYZpyvE1DBXdY2GBJhv3heE4NMc5jrPdVxFUdDI7Sejbgfo/jOP4YH/QGKfETVrGfq6ZhDCOwiQq5CRtiyKzk5KpceVNSqyiFEn/Z37iuFeyFzweRf6iCKK//knrGnVf/QpxFPlzAn8nnSf+MifBQRYkwePBNo86L3hNsOy99ntUvYd9zYPGCSbFwlOKmWHxD7mfGDz3nPJ4dxwZW9dxgEuX4F67DkApVxyn17JUuDbc+B5lIstO0Y9zEFxZLkc/6FLV6q9vIrl4gbJeXL2qzrd24dqOpy4CoB97u0/9kexwaYmcBtmkYMg7v3yByHhuBkjnALcP2C2lDrpNumhtjRy1VleJtK+s0DWNBpCZgqaRvTCgTBH8i4eERuHLCgUiRpkM8atMBrhg29IMANRuu69snMtl4Np3FcHREx6hNYxNzM+rbXwef74/zSaRtuyc4cmAaVPDoLGFRGEO6O14aua0dAqcnSX19623aIegWpVZmbPKbGNhQTkRni+R41+zSX1rNlVWQMcBOdVxzmpNALo+lP3txg311zBkCL2yjKrWqePUvEGNKp6nhdBuVxlIr3xfnmjQPb32XRo3dh5jxfTG98nuvDCFTrWNhFzvcF1JA3KHIuENopdS2QHS8zNqEUSTDGdLOu5UbO8Qk2Ien5vrPn8/Q5kZcbZAnu7+6/o22YBzVZwYplTWvPhruk5fzGpVThFvAWhLp8Q71IBaTSnFWkJVyMy7XlcMXJpW+M03ovAgH+yu6y48wOoPhL0qb0FMStBG1b+fezcJuYzCOPIVfH2QNoa9jyK2+1WkJ21LsM5x7Ysi4WHjEbW44L/BcqIWAWHlTlrfYWG/93uvdQQR9V2a9Du23zbHpPg4QQgZ15R+HJOmjqT8oWXvdrG8hHuvrcCyFNHbatCHM70exOVLwPXr3vmJrInpLLxQWF7Ise42kRxWhRnsWGVZZJvbk85UVbLTJYPXXS8qBew+oCUgdA26Ix3xdHvYwcja9RyrUqbK9uYx1nyeCEPhLKmx201galoRVJEFsAs4FplZMNE20zIdWpqIcbMJYRqAnsQ0ttFo0OWc+ti/pc5b9mwbXKkAn2o0qMzGPSJ3hbNkr7y0pJKHMJiF6TouX6ZkJvPzREgtC7h2jXyn5ubI+S3F/eVwYgAS81m4tbpn05vOkEkGO3ZVKsDnP09Vl0rwtvgBOWQakMhNAZqG2yttj0ButagtLFqmM0Cq05adT8JtNL1wdJkM2dTygon52fPPq7E6VTTp/hTPUxzoZlOxSFY4OQV3d5vm8Oqquu+aAK5/F7stC9kiZfDLlmYBx8VubQvz88AjT+VJ3jZSXoxiAEjkckhsbCjDbJ6fcuw5DjbDT3iTOt269XU1D3o9RThvV9UugdBoevltrnn6ahogSue9rIpbDcczcdB1SeaZ5PICQNPoO1MqgZ1SvZVP5RY1YmNDEWYZZeP29SamsuGRLhjHdQvwuGO/ZHgviuJhI0qVPIq2BIn1OASJYpiSeBDiM07l9J8bvG5UG8a1KYwI+8sKq3+Ucj5JfVF9HXftUYzv/cB+231cn50nlxQDw3um/AsvIS4tA46DbJZ+9NkZxzOhcFxS8S5dgli/SQSz16P9aYaZVqyAWWNvdygesUc8NEGvq5uA4xDR6O3As+OtbCr1S5ap65BGlgnVF+lwFFS/7txo4szv/4QytfCIZpIcuE7nZayrAQAdSJ0H9I6XFMQrG0CnsiWJlvTqz0zBsrY97uZ3puLmskhnmjQU33oD+NTTm5KsS6Uzkyab50qF2G52WjlLSRKkadRUgBKEbMjt+JUV4AefJr54ek46OJog0qjrgJkeiiZyu0qmEhzK7Ykn4Nkp89Y+E18OAzbv0KKGybcGItXVqnII/PgVTTpH7gKOg1ZLLQZ42DktcalE17KqattAp96jqAosQy8uqkQtjYYKn1e7rbKi8CJCGvV2Ghayz3zSiwoCTcOgWleZ23I5YvFs4MsqKkBkXBO0S+CFDZTzxEhhY2OLi/S+Lv6sdJaP7HLsb9umhUCtppJvcNxnJqOs2IpCXpLdBLYq297ihNd9N9eBCwtyLvKX0UiRWcTGTWLmPPlrd2QscEtFeHEcwNrFxtUmUoZyEPRZRn0Ix/HBfhLxsNwnvxp62PATSP+xcYTcj70SrHFkdVR5wfYGy5qEhI46Z1TdYZ9NUv9B1fujvO/+evZTRtTiIVjuUSzejgtOLilmeddQ4ZoGPRsJXRJiHzhMVa+nbFlTHBGitwNkp7CzVkP60iNElDOSDGfk9j+HYLP6iqj0fMSYFd5m0/M8ch3Q9vbaGimBDMcByo8gYVlI6DrV4e1nJ0g9rN/FygoRNhbVslkQkSpfIFbHZIj/MjFGGsBpAH1St3sypFelIsN8JYgEaRq85CHWrrftXqmoLvm32TMZ4PsrZKbA3RhCVqbmbdylyAtselA4Swq54wCdDlIZDeeLjuew54+5++qrZNZwd45iDc/PtzFwKEkFO8G1W4qkcVs4RJgoX8Dmazc9UsdtTEnTkKRJ4eJ4+vDOPBO7j1+GNGaWZjKWhRmNFM+EbuGtt4iUXyir8HVsyjBwlAlKp9pG9oqsvNlUKw3LUh6LjqPk6eI5IoDsJQrQPOObUKt5l1wogxZrmbRKktJoEBl2HLqnepKOv/WWJOR0n9uVtmd+wffbr/AG7XKTOo2tYRC/Fxp148JThWEPQ12HsCwkeKLqOrYq2155QlOkGAA2NxycW/Yt6lgBBoA33gCe/WFazGXScpfFF08RGHZYlYe/9jWE4riqHR9F7PU+HESZi8JeCMn9Uqm1iNd7AZN4DbQGDisnipixempj/xhHbqPI6yQII8H7UaeDKvGodh3mffeT7aNUjIPK/V6uC8NxfXaeYFLsAo0GxT3NEOvVNBA5sCxwuCa2hXR9d9ey4CmBrFaln39K/dgyMWEy3NshQtxpk9FxMAOIPVCJH3RSRh0HMgfx1DDbKJVkEgfJRnq7ioSzomv3vbeOQ45V760CVxY0kiaf/JTagjcM6XDYB+41gFOPgoKebao6Wy0iGbU7aG9sYXphToVok3Vqmuq+f7ubec/qKpHLWk3FqzUMB6UScLo0pZR0zrCnCRqX+h0ixlXZnuw0tMYW8fWeJJSyn7dlSLWEDtg9mZDvMt2vnZ7MTNglPiZ8qr9hUGQIWLvI54FzV+aws9HwnMlEbpoWBHoSibk5uFff9WyJr18nMnzpEs0R4bdhdQaApqFdo7TOaWlCUioTy7tbscj8oKdUVHbYe7R2m1RPdhSbPSXnnEv3PH9aMlNXmdvIXYa+BQxqDdRqwLmiuo0JQ6OFFpurAGTnUi4rWwc9ReNu28CVTwBX36XzzBQMYxsvvABMF0xVqONgY9XCVIYuuU5m9lhYoPfVKhUvdJrDpbL8XhTPqzCFc6fVHJ8/BzTvYebpZU8Jr1YbnqKfydAY7tTa6K23ceoSBWrYXSfiv7oK4Nrv4LFLkDY7SbitNtn5y8gjH6zY6t5KQqyPeBIexwf7ccL9Io/7xWGRkcNW34LK5CRtjFIzD0ruJhkjDeHEa68LjbC6R50XNk5BchxW5rh2jVs8BT+PavukCvMk4zuqnHFj518YTYpxbX6Yv9dROLmkGMKT+joNYr4DG5ixdpU66gyQlj/GfmXT24Jmr7ryI3LLXG6bswrMdrqsKDuuNF+QDm2ZNPDWW3B7FmW+c2i7udkkEpu83sbS0nXYNnB2cUpmn+uTMtbbJdZh7VLoLjMNVDexsUEK3cICee1/603K1mWaIEZRvwu8/Ta1rVIh8pnPU7n508Cd3yW2wEpjRZo4VDbxwdtb6PWA81oDCQ1I56dwr2Z7YjOHLLtTIxtfhmUBj10C3luh8zhjWaVC708XbsnIE1OkhHa3qX/dLtCUA8/ZNhwHM0VaKGj1Nna6RLAvX6b1QqOhIonk8zSWQgNOP/kIBqsfACD10n8/bRvYqtuYWT6DJADMzSGdmSJl3bLgJeCwKSyduPIJpFa+j7M54IeyFrKLBaXotlrSS8/BbqWBRkPxvcVFEpLvVB2cmbdxel7HVt32VFCOYvLxp6ZkEGRJGvWkNC1pKXOQToeiTcg40ZSkgzLhmd22Z8KysUGbAIuLgK47MKw2Eo6jrjNSyhBYpgsfiulbLtNqx9pFqjgHZ6OB3WaP7KdLNB9Ll2lHZGt9Cz/xE3T52hrZV7sOcVvTdDAz7zOmrt2Wdu0OzTXTRKfew+DqTSLEepK+V70dlMsNLyY0N2vg0DDvrte88UuYOkyT5uP7q4Cm9fDIkg2ha0hpDt6/YavQdw5wenkOnfUGXniBvh8///9N9OCIccgI++EcR5qiCNt+yRZfy2pgWDnjyFcU0XJ8xw5KroP1TaLojiK8YX0eRSJHtWsSpdF/3jhE3YNxqnLY/QuSv2AZ49TkvbQ1qt4wjCLve4X/XvrfT4r9zM2jVK4fFE4uKXZdwDCRcBwkLGcoxioAoLeD29ebnprIsYkB+qFPWn1fPClpD8xJAWxpJ7z6HpEKy6LPzRQRPmZk1U3sNImQW5YSkG/cgBdibKcnQ3hZu2QzCXiJFLpdteWuaU3PFjYpScLzzxMxfvVVSkiCzBTV/+abwKXHiGRrGjHJ5cfoYtMh0sxJQySja28QIV5YkCHXDOD7b21jfl7tTvdtYCYHfGxRhTlbW6NrLEttu+/0gO0OEbVqFZS1rXab+pjPA9W+WnRkMuSMx8lGKkrBThXnoF1t4IkniHj5Ix/YtnLqOluAN3YsSPvtXT/5hKYiXwBUWGaKxqReJ4dDI0UsjBnuZz5DsmhjTRqlpsixMpslwtrZRmrxPM7NkvkE28jatsxVsu4gqTte1BLekTg3D1pEdXdkTmyZiZC99bSEMsyt18mps3ZbRZGw+6hW1Xy9XR0OJZgoyIWVPZBh8XzzmMPz+Z0y9aRMQ77hzVu2s26vNTBdnvXaM/PMJWx9g6TicpkWPUIjgrqwAGxVObFJD9Nzuo+YG+jUe14IPM8kwnFp8aPRbs7ZpRTurbe9zIXJ5QXAHmCwdhOJpQVA0/AI1r179MENC+9dpy/Lyy+r+ZDQgM99Dri30kDSGO1oBxxPteOjjknuyV5IwX4V0bD3UZiE0O5VNZ9EkZyU1E9a/qjrg0Q6qo/B9oSN4bjxGdXPSe9JEPv9rkeN46T3M9ivw3jmHEY5+5kz465/2HFySTFcwO6j33Ng2yrzViozRQkp3rrlOQ55CSd82HrtFkrLU/Ac7NgecyiMFeT29CN0Dqd183n1+zN+ASTaZbPKXBQghXVxkRSvfs/xHP+EBs9Molodtrtk5y3eJn75ZeDPfF5XUQWaTcUQAZVamMlPd5vIXSYDWH28/DKZCHx/hZRYDlCwsUER40olOjaVkcnxDCKeS0s0hheWDAy6lmfS0enQ9cUilMoKENG0pT2zmaYTebHBVmvOwLMDPztPi4T5eeCdqxQHF1CK4uIijfFMzkDCAObnex6/ZG6JpSV1z3Ry8kLtNtXLau18hgryTGOI1d99eQ1ps0kmON0dItPNpmcG45Vp98l3kERkL3V1uUxVu45KNe2FG7NtMomYnYXnDDc7q+YZoNq58h6gadhp9HCrQveII34AMoWyAzVPOUpDd5tez5+TGRHlAo/tzns7ZBCsacD6+ofCsfVrTQodKCfiTGka99bb5DQnCTFAi6OiNOVwHARCTyQBWOo7xiqytIdO5Qy6kaaJU9nbND84ekblFhLLi9R2I4WNNZoj7Pz3e99Q8aYdh47/yPNq/ibGPOGPq13cSUSUcjzuR3zc/R1XRpRCPO7zSZTuKFXTr/QGr52EfI9ro19xDLYneGxceaPOCRLZUWM4St0dV9coHPX3exJyOurzvS7uohYdwfmxnzbtZXyP67PzBJNiALaKueqJovU67q5vewoepwAGpJBqKj7ixf7lE0wTbIsMaxewLOz2ANz4ACmOIODZ/dqAMxgyBV5fVwomb6f/6r8AfvpPknjZkwS+0xkm6UHHMMMgLj47q9QxAESwOGxV9TYRHzbFCIwLACLE9gA79e2hdMqswnI6ZF1XocxqNWrHpUuqD6YJ3NmwcKaoAz0b3e5wvFrk82RvXbujPiicpY4yi2T1fW5OZtLrAWYKp+fImS4lt9eTuuKQjy6TYx3FtiWTlZnZnheCzXGkAyKbuRTPA29/h1TU+XNqgVOUr82UGiudIn4UCkBidhpuqw1s3IJYWpI7AvJ+a5o3zmcKdwHLQqJ2G+WyelzwfRuKblKXiTfyp2lMertEVjkVHt9DGQ95p06OaRy/OS1ja2dMRbq9nZBqlUiltUv2ynNzMuSfrSaTLwyeSpucQkraZXNbHQfYXblJ5hS9XWxttHFLOluuralFG6fGLhZl0VyXDPmXkL/CXvhAVpEzU3KBZKp+864GO6364E+vrWnAjz5PKdsZP/q8iv7B5wQdBIM4jg/2jxLGEYaDlrHXc8PI3GFiXNlaxLmjyuLXUepssL4oQh5F8KLI7aixGde3vY7tXq4dtyAZdd1h3+9J2rBXYuzHXuZL8LpR82U/bTkOONGkeGA53g8289qNG9sY2CphB4NNG5gkDxxg4+0GSkumUorZxljCdRTJeefFGpaWZFIEtgXGMA/pS9LCwuXbbwNPPaWiJDCZ5EQQuxaRQWVCAS9BAzskMVIGiNysrUl73W30124hWT4nFdCByqHM5KO7ja2NNjSNbHZZaWNylTaJtyYNpcaZJnEsL9StL2nD7Q3bs9Zgc9X1dYp14aUldhwVX5jj0OZyVJHjEFmcPUUK5uws7NU6HW4pkn2nDvzgU1TE7CzVd66Y9BqSyiiNpdcDXZiZIhMLTk/H0RzMFLVtdla9dxzPBIGzvvV6QLooK5udJbJ343tE+B2HiHbhjAytp0HXHY8Ms0DPc0XTKPMdKjdx+nGH+uupx301OWViEGgaBg5x3WqVFgaPLsGzggBkprzeLqm+9Tq1Y2GBTD7sAc0NNlloNqWnnDStMJMq7Nv8OaSrm3AdFcWQ73O70g5+xTww8axUVEY/aAlvceEvx6k2PIdJLC6SHXz9LvU3N0Nz2B+j2HGAxUVsvHTDWwAOmUJJPP88hj43TbUYTkQw4+OqdnyUEEUIwlSxqPeTkIEgmZuUjN+P+TGKbO5nYeAvK9iXccR4VNnB8d4vgvVO0vfgNfslklHXcBsmVb/Dyj4IDkMJ329b9lPvcX12nlhS3N5y8eKLyjyCExC88AJxRN4pZ/7hV4iZICcN4OaNHsVN5VioEv5oFZzIYmUFKHYpzitzT47YYPsIseOQFYGuU12rqxRFgG05SyVFjPm3nNu5tqZEtYSuzCcA4O7VTZx+4oJK22zZaN/YhOMAM4BSC23bi+jAzlp+zuBXeQ2DyHFfkt/FRXj9O1U0cXej56mFpgm0O6qtGxvAo8/myVHQSNGgaw4VzNEx7L6M9+zSVr+RIqezSx+nAqAcsLg9jiSIV65QOwoFUFmaBk6dXSrV1YJES5DqyDGc2a7W9L3vdomcckWOAxTOYNBsIzE7jfTSebJ5YdtoTk7S3KIFB9sCs1lCbdPjdBy3l60UpgtyslmWtLM+DWzcotelC/ImJNQNmT+LdPM17x4tLNCcuVAGBvK+JDlOLyDT592TC6H+0CIN9TqNeeUW2XPwJOh0lIPolU9C1G4j7TieaQjW65guURa89XUix2z77ldj2QnvVCmlVnFQ49C3KQiKrgPnnnlEXaRpahfGX5jj0IJm9T2ULk1j4/qHifmzz5JdPSvmA6h5YkolfZRcfBwf7EeNUWrhJNftlayMIsbB+kcRpTCyuxf1bK/YS5lhqqz/dVi/9trmYF/HkUEt5JrDUErD2h7sU9h9iurvOCI76vyodgQxbsz3o77uFeOI8X6J81HhOD47TywpDiIhf5SbTbmlDiKkfZvIsh+sFG9L8ZJZ73s3aAr4IxvsWkQY2ZZ2ZWXYtICh6yqM1eoqvHBR/Lv/3gp9zmT74iKwWVEZ6ziLHBNW29dux6F+OA5w7+2bOLU4CzgDaJpPTjNleDWHWJRf2WNzCVay06YiMJyi1zSJEAuN6jUMALbtKZUsdKZNMrtISlXQrdUhlh8D3vyWUoB5YBp3SXUFiNBxBArAi8TACisnweh0iPMVCrKthWlSaHM5uqHlMlCve4sgAGqrXtOIJLa2FIFm5qwlSKVmhzxNA9bJbCCRP60ij0g7WOTz1EYjBVgDeElY7D4wOwPLIlLMcZ05i56uByZQ4SypunNzKjCyrpPpBKflrmzSekKjnYWkoXzm0sVZupbjEC8skBkNE17OssirHya+ABHxfB5Y/wCeCQvb+moJ+ucM0K/UyV5Zpl1mJzsmun6wTx8ZdQ/vDPBC8cKCJMtVqWbzZDSS6iQORWgYNLa2DehJlC7PYOPalve9sX2LO6476Vso8jkJROM4PtgfBCb5QR6n7B6k/FFkZZzq+LAR4qhz9kIUx7VlEjI4bkGxX/jHfy9kX8Pk8ZAnae+4RUHY8XGLs1HtmeScg4zxYRLiUYvL/ZRxWBBCfA7APwI9tn/Rdd1fOMzyTzQp9nMPJqGvvkrvn3uOfnvbkocFTS39/nS/9EUHzz2nCACrvkxy/CJU3yazCNumyBCMZ59VUSfYAUyDUn1zOZXvgAW2XI4INMcENk3lXQ+okMiszL7yCvDZzwLt9Samy7NIaAlMm7vYadkUO9bue8SrWnG8reVaDfj0M4rIAsrUN2GQKYBlATOzso9SfU/lcjA7DfR6w2PA2QGzWZnBrHYbg04PCXNHejWSAxUyKn6xW6tju0vqo7WyBc5G7LejZgsHTjFsWUCaTSE4TrQ0x8hm1aLidG9X2QG3toiEGgYRRmZS0gETtTuAJsjBLGug1wO6b61hpjiFTsOC61gUkcEfi01LKNuA7jZQOIuzRQ3/4csOzhelUGsRT63VgM6ahXOfuSRV0DRFv2CnyFZLlV3dBGfrm14+h2lW1fUE+lfXKM2zptFKLzNFiwNdJ5Jc2aSVg+NQedfeRXut4Smo6e4OoCew+8Y7SBV9CwHp2LdbbQ75HBoGvCQamQyF5OMdEk5rLeQ9X1gAjTebyVi7numNF+WlcJbKW19Hu0ZbM0HHQS9ls92n/kmGu9tTcyNoJs3xov3fzVTOGEoJ7sdx3QJ8UIgiO+PO32v5e0UUmZy0vL2QgiglepJzJ8G4sR312ShCuRey5yevo1TXcZiErAfrjOo/HxtFavaqNE+CsMXFXuoOa8tRtHMSHGa9R/HsFEIkAPxjAD8OYAPA60KIL7uue+2w6jjRpBhQSmzfVhngAOCll4AfelbZ0DIZDBLpr3+dVOOvfhV4+mkZKirg+OYnbwmNtm/ffHM4WYMfTCL9DlhcnmGoVMV8PX+uVDh677fo4HjLL70EfP7zwO3rTSJ0XTpnwd721MZdi9qZ0IG1G6QAe+qvbI/ngOhQKuxmE152NKe37TlMpTL0FfdH2WDidXbBlCROJ4Kt6ySZdraHQ6TpOkQ+j+Rb15HNm7hX6Xkcs1pVcYf9yULOFOjvTnWLYtqaKdXoxj1A03CuBNyuOCo0HTP93DQpptksKdetllSBE7TC6O3QvSkWMa1VvWZmC1Nqm1+TKrihq4bZNna7DrRKHdeuARdKam5UKtSMvi1tyJtbUh1OKhMMDpsxN6fsfr304TuK5TXuIfvUJZWv2jCIQHNYkJ7PVAIArr7Dw+xZbaQBdDaaKjqDjNvNJ7IpDzu2sU0+HMebP8vLZDNuWcAH68Bjy2o3hMk7J4HhrHXeBPM5sToOhXLjthkGlDEzR9HQhPzV1Dzyy3OBvydJYzglNZsX0QXRWnFMiveO4z5mUaQrjAAGj+1F7duPMhhF0MNIqv+aYH2jyhkHLidIIILXjiJZ+5kj4xYyo8Yg+PmkbQu7z8HP7geOmhBzHUH1/CB9PILxeRrAiuu6qwAghPgSgJ8EcGik+H6M80MJ1x0mnoAimHzsd19VpMVPCPnvSy/R52zS8PWv01/LUnbJzaYMWyv/WRaV69/eZfjJt/9H+1aFSAdHk0gZKiwak2p/UAuA2vTKK4ocpHzh2f7jVxWx5f7cuEF1+MtZWyNC7FfFuQyObsAR3Lxt/3xeRVCQ7MRvm82mFt75egJotckRjFXLTJqI3/xZ2r7PZoH5c0g9/zQAIjfFovL94ogLjQbFR96sUgKRep3Gv9mEupGOq26w43hmFtAEdSaTpoIrtyjOdHeHiGmtRuYTHM4MIOcv0yRSZiTRrm6rPjmknns3VV5jGMC1a6Tw81j7HQQ52QWqm8C1d4mQN+/JMG86tYVtnQ2DFiJ+gsiD7MXQ1ojMsxL69jvqhhbOKNMRdhqU7WlX2pSgpZwnRXl2hga9eJ6c7UpzyBZnvK71bdqBQLfrxcm2bTpuGLSo4n7y3PFMKGS2QsfB8BewehtwXMwsziEh62DV2TNpMVOesx6PO5tH8D82MWKnVMOgKZUyAJGdontophEGVjv28i/GwwUt5N9+4QT+Bl+HvR9X1l4QbH+wHaPIYFjdwev3Mp/D2jHptfv9nkSVG+zPJOVHjVXUtQe5X4cx9+4XDquNR/TsPA/gpu/9hjx2aDjxSjErjkMhq3x49VUZ3xUygoMEO47xZ7YkB6+/BjzzDLwEAwCZE/BvPZtMBMkwe/J7P/pQoaMyGbJFXloavtb0neu3mRzItqUzKmQaxzV2HWW+wN73nLxgdZW28JM6vX50SanNug4Ik5h4wnE88sb2xfk8SGHt7kAsLSK1uuo1Np3TMejZFPLYorpmilOq8cVzFOw4f4YU2eJ5GSfZgZdkordDCmc2i6yWwL3r2yiXgZvka+eRbV4sMPH2CHuzqVh/Jk0OcrpMP3z9uzLNXoJI8Nwc1dvpKKJZPK9e12pImcC99TZOFXQK32bbmJ5tUbsXF4FGA6mcjEbCEqeu4923LSSksrpZJbWY25/QAJsXYJyB5Pp3SXI109I8ISltZ/rKtoUJr6apqAxVmdBD15WtM5/Dk6VxD0PZFXu7FFVlgy579OlZwLbRfu06pp/5hEovzis6I4nTJdPLcDcA8L23emQeAZq3TIZ1nd7fqQOlBV0ZPa+teRM6kTHgJe6o173U2jAM6HoDaakQC65fT1KbHAdwKNsgHIfCIPq6yvXzuoG/N55Jj+MqFTwEMdE93hhFFveLMDVR8x2fRGHTAn8Pox0Hue4gqvVhje+oNoxSbKPOH6WEH8X3OtjGvcy9cYua4Bw7Cux1jCctbw/ICyHe8L3/ouu6Xzyk5kyEE0uKhVAKcLcLb/vW7xjEaheDFVl/9iuO0uCPG/zaax9WoBn+KBZ+csuhcrleJnWGQQpoNktb0UtLPt8vX7lMqvlH/623lMkDc4heV53z8svDWfSYuz399IeVYdOUihpA5Ky3g/qG5ZFcJhxotYkY8x737Kw0OE0hYbc95dtTBI0kEcpOh8qu3QY++wdVJARAJZfQNCCjUYzaN173lOKPLQ5H4vATfX+UjHsNYLvbQ6kE3Fkj5zIK1+bAMBwkmyvIPiFXHa0WBtU62Zlbu1RALkcF1sjZ7v03GpSMIpulGzR/VkbLkIlFslPYWbnlRRBxHAf1uoWkrsZX15XKzaS+UuGEHhYcBzhdNKgA2wbsFJCRY8cOcr0dUovZQdFIeaYHndWap9pyHQCAjRqS83NE9Gu3sVNpenN9s0Lnl0rATqWp5jsPJEcoAWiRYqQA9DynQdP0goL4g0vQd8Uhx8ydlo30+geSZHOoPJnKGsDuRh2phXNDF+s6OZt+7BLUAoE/sOQCwaZyMhnLazcvAP1rAr+dMZWRUN61IYhJ8fHHYRLjSZXEo1YFg+WPqy9I2KOIcVhZwfPDypqkbn9Zk5zrr38/CKvLX1ZYn8aVF3XuJIRy3NwZ9flByPyk8/+w5+w+2lp3XfepEZ/fAnDB974kjx0ajoOafySYfuxT0HXakjVNUjyZGPt/RIHh135CnNDk1rChIkUIDZ4SyP8AOuYvlwkvmyOwklYokFCZySgCzWGjpiQx9tsicxm8JZzLAa+/obaNASVUAh92TmPyyCT8tddUfVy3aQKd2jaRFj2BrZqlkkNkpJmqJNdotSkhhJGSdqMca3gGMAwI0yBFUJpEoNVScvhTP6hCmc3OEvHJTpMTlZaQIc6awMICEoU5lMvEp5eX6fJaTS0wmk01hqZJ1U1lSJA2DOBM2UQyZyqSDqDz1gpQv4NBtY5ExoDImFRQuUztMNOkKBsp2n7PGdS27JSMhqFTRQbFNk4vFLyuZTLDW/n++8/jz/eVlVrDAKUBz0ypm8th4zJTRErZNnd2VpqaTMmOp5Gd1ZEyae4ldCCZ0ZE0NXJmazQ8Zze+3/x3cZF2GapVGtOkDlqwmCm6D5kpalwmDZgppBbOoVJRIvL6Ov1Lyv5lMtT86axypPvOy028/vI27q5v417VQru6jUG1DtTrNG/lXOO/a2vyu8PjzYMHAJqgv2bKI8uGoXZJeIxfeUV99zSNnERhJGkM/8x7oc+J2Hziw/iBT33qQTdhXzgO92bSH+S9EuLDuC6oCvuvjRrbsPPH1XmY92mUUux/f5hKNzD8LAiS8CDC+jvqPu3nOXPQ/o2qr+26oceP6Nn5OoBHhRAXhRAGgD8B4MuTXToZTqxSDAA//rt0M3/9U4IccfRhRxzehvfb//rNNgHlWKdpAHwk1G+fyzvh/JkeMurZrDruD2PGpg0JjUwDpjIqtrGmKVWaf/z5ej+RZ2WSia6/DaapHOtY7GYTD/8CQdeBRb3u2Qf7nbIMw5dCWNO8dMQ7b7xLNqlex5OqYdkpstE1UipkWG5asqoP5Dlk4zqkipopQEsDKyuYm1PK5HSO7ImZ5DMxPjuvTEeqVZX5LpsldbPVUve1WgW0qyv49DNy8LPTRAK7XWDutLc9f+/aJsVcrluYXpBRKdi4GqBQcrLP/gzWbG5zUy5shAaYPhMPJo8ySR1KJWneUSgoRzA2lei01U0wDGVWkc0C16Q5SGuLlGu/xyaHVtM0WiFAZSHkRVa9rtR2QJo8XMqQDXWxSDbAZlqR0WoVF5c0bKw7WF9Vc3ZtjRxKNY3es5NoQlPN3qwCn7gs+ynb573OSMfF1VUVT5hXF2wSwnNKk+Nj9705wNPxd16lel2HzKH+0E9Alf9X7334yxjAcSBT9xvb8odwSogH3JJhjFLTJlECDwv7VY0nbZ9fldwP4RmnOgaVxTCVN0wpjVKYo9pwWIrwpHVOgr0oxmHvg6+Dqvok9U0yLgft5yQI6wsjigxHXX8YcF3XFkL8HIDfAIVk+2XXdd89zDpONClm/GffcvH6Hxa4XSP7X1YPmciybbAh/zJZGATuuBt4zyRVaEAK8LbO/aYWTIgWFobJsP9vpquc4nSd7H7Z3MFP2v3h2ADFP3O5IV+voe1jVvOYQHS7KqoAp0vmzzj4wZklStKQsPtI60kirZkpcgiTjXnvuk1OVY06SstTRGKMlNp+72yTUry6SgyweI5UZsOgeMXcUNtWCSscB/jG79F18+eQsHYx3enAWu3hrgykwJYGHN54s6LGI58nBXS3BySyphybnrfdz46Mv/k1wHEcLC5uwTCAR3orcG2KLyYWHsGpeQODLpk3vP/VGyiXgUSxAOhJDNZvwbaBVIkWA9lOfUhB1TTilTduqEQnPKd6PWqjpklCnJHbDBwlolyGF5PXcZRdLscOrtWI5RfOUEHdbTXBOEmH3VcE0hlgd72GapXUdv+Q+3c40iaATgf3btSBtz4Yml9+v7jbVRXljQk2O1hy0AxeaPVttVi5VQGSugPLcuTnDvTqChwHOPP4OSCbRSbTpljZ6+SUl7yyLMmxRQTd7mP37RvQNDVvAeBrX1O2+fz9+Z1XAF138EO/0cI4xCHZRmPbdTEtxAMdo0nUwLDjR9nmg5AVP+EdVb4z4bn+cvfSrnEK5yRkbhTBtPfYnkkRvMeTtn0/4PL9dUT16SD1HTX5DcN+1GE/jurZ6bruVwB85QiKBhCTYg+aBpwt0I/53QbZCrPC66nEuiIAwLCqzI5GgCK/euD8oG2nZ4sL4LdeAn74WfVjnvBd6z+fCUVCBzRHnZsI1MvnCm3YlCKIpE7q6a6lHPRYAfaHsMpkFDneWt/ygioMnJ50QGxj11LjkjJVOLs7a9s4szwLOK50mtslhlSrKccwkm/l1riMPevIzzi+sJGiSiu3vLTPg66lsh77CDwnsAPoEo5UwQuAbLbnBbvwVEgoUwbAV0ZmCoIraDRwe91C3yYbV02SuseWazizMIVEbgoJZ0DktFxGqrsDaBoSmoZck0j2O1eHCSNAJHl5Wd2rVguYKWSpsZk0EVkOv+YMyJGOWV6zSSmql5aIeXNUB7/9jC7TOCOtBkrXsfZKDaap7NX9fnTpLJ03sMnOl5VuJrMcetAwSOmdnXWgaSryHe9e+M1wuGq/0yofy2YDNuoA2jc2MX3lEU8gThjy5JUV4PHHVaFvfZfC//lWlr/5Vcf7Hvh3TvaKmBSPxzjl8ShxPxSz+4lJCe5+MMl1YWpvGEEeVdaoPoxSH8eVF7YIGKdGj6rff/1exzRMPT8I/G24n7saYRi3INpPOccFMSmW+NSvu/j2T5IZxZk8bRkPfFGt/Opx0IQCGCbAUT/AftOF4A+1PyVuEH6HMYAIhePQVrD/M+ZIflXM/9pvS+zvB/OIXajMXroOzOSUquzPaDeQobH8bWKiw/W99BLw/PNq3NiZy3FIjT5lbhI57u1gYDlILFwgtbmzDVgNem1ZShllppsjlbpfqSO5cB6JTgfZ2pbXL0AGVmiQ2sp8O5NRW+gAZPxkIJdzhhwLr19X5bCym8u1adHjDB9noqZpdMw0t72oI64DGK2VIZKZy1E4trQ0rVlfBy5fHrYN5zIBUB+XHqGx4LBjmkZ2CdkpdWJ2iuTRN95Q8jOz/eCkchx46ZKlWQIfXlkJmt44nnK8vCx3OTS12PJO1jlpB8WE5sXUyy9/2G7e7/Dmh98pzp+aXNOAweoHSGb0D1909ao3eX/7Rf4yWh/6HvrNlVj5/tSvj1c61CjEGIW2VIuBB/9jPikOq41H0d/7SfLDCK4TcTzqWv91wdejzgmrbxT2Q6ZHlTGq7EkQJOaTHBtX1oNcXIbVG9b2SVTiqPKOA4S7hw5+lJDP590Fjh31EOL999/HxYsXH3Qz7iviPp8MPKx9fv/99927d+8O/Q4IIb4KIL/Houqu637u8Fr2cCF+dj58iPt8MvCw9vmj9Ow8saT4YYcQYtt13anxZ350EPf5ZOAk9jnG/cNJnF9xn08GTmKf7zc+SqZYMWLEiBEjRowYMWLsCzEpjhEjxv3GwxXHK0aMGDGOB+Jn5xEjNp94SCGEEG58c2J8BBHP7RhHiXh+xfioIp7bR49YKX4AEEJ8QQjx+VHnxBM/xkcV8dyOsV/Ez84YJxnx3D56xCHZjhhCiDUAbVAYY9uX1/unhBCfA3Dbdd3/UQhhAngFlOdDB/Brruv+XVnGXwXwF0FbJ/+367r/uzz+BQB/AMAOgE0ASQBXAPyU67rWfengBBjTt1kAvwhqtwvgvwTwGI5Bv8Yhqt8jjn8Bx7zfY+715wD8I1Dkv190XfcXPgp9jnE0iJ+dJ/PZGT834+fmA4XruvG/I/wHYA1APnDsCwD+lHz9L+VfASArXycBfBPAM6CJfhVABvRleRHAkq+cPylf/5b8+3cA/MCD7negv6F9k+9/BcBfkK8NALPHpV/77feI48e+3yP6lgDwHoBFeZ+/A+DyR6HP8b8jm0vxs/MEPjvj52b83HyQ/2LziQeHLfnXBWhbxHXdjjyWlP9cAB8H8E3Xdbuu69oA/hOA/8JXTkv+vSP/WqDV5kODqL4JIWYAPA/gl+R5luu6TXneQ9+vcYjq94h7DRzzfo/o29MAVlzXXXVJyfgSgJ+U5x3rPse474ifnR/hZ2f83Iyfmw8SMSk+ergAviaE+JYQ4r8adaIQIiGEeAtADcBvuq77TZDS8SNCiNNCiAyAnwBw4agbfdiI6NtF0Bf6nwohvi2E+EUhxEcqBmNEvyOPfxQQ0bfzAG76TtuQx2LEiEL87MTJfHbGz834ufmgEEefOGIIIc67rntLCFEA8JsA/rLruq+MuWYWwL+T514VQvwMgL8EYBvAuwB2Xdf9a0fb8qOBv28ATADfAPDDrut+UwjxjwC0XNf9+QfYxCNB8J6OO/5RQOBeXwLwOdd1/4L87M8A+LTruj/34FoY42FG/Owcxkl8dsbPzfi5eb8RK8VHDNd1b8m/NdBEf3qCa5oAfhvA5+T7X3Jd91Ou6z4P4B6AG0fW4CNGoG8bADZ8q/1fA/DkA2rakSJ4T8cd/ygg0LdbGFbpSvJYjBihiJ+dwziJz874uRk/N+83YlJ8hBBCTAkhpvk1gM+CtvTCzj0jV4gQQqQB/DiA6/J9Qf4tg2zi/sWRN/4QEdU313WrAG4KIR6Tp/4YgGsPppWHj6h+j7rXxx0j+vY6gEeFEBeFEAaAPwHgyw+soTEeasTPTsJJfHbGz834ufkgEYdkO1qcBfDvhBAAjfW/cF33qxHnngPwK0KIBGix8q9c1/0P8rN/I4Q4DaAP4Gd9DhXHBaP69pcB/HP5hV8F8OcfUBuPAqH9FkI8Hnb8QTb0EBF5r4UQPwfgN0Ae1b/suu67D66ZMR5yxM9Owkl8dsbPzfi5+cAQ2xTHiBEjRowYMWLEOPGIzSdixIgRI0aMGDFinHjEpDhGjBgxYsSIESPGiUdMimPEiBEjRowYMWKceMSkOEaMGDFixIgRI8aJR0yKY8SIESNGjBgxYpx4xKQ4RowYMWLEiBEjxolHTIpjxIgRI0aMGDFinHjEpDjGfYEQYiCEeEsIcVUI8eu+7D1FIcSvTXB9J+L4HxFCXB5z7VtCiC/tq+GHhEn7GSNGjBh+xM/O+NkZ4/4hJsUx7hd2XNd9wnXdKwAaAH4WAFzXrbiu+8cOUO4fARD5YBdCfByUCehHZLrYB4JD6GeMGDFOJuJnZ/zsjHGfEJPiGA8CvwfgPAAIIRaEEFfl64wQ4l8JIa4JIf6dEOKbQoin+CIhxP8khPiOEOIbQoizQohnAfznAP5XqWh8LKSunwbw/wL4GoCf9JX1V2Q9b7MSIoTICiH+qRDiHXn8j8rjnxVC/J4Q4k0hxL8WQmTl8TUhxP8gj78jhLgkj/+obM9bQohvCyGmA/00ffV8WwjxB+TxLwgh/q0Q4qtCiO8LIf6XQx73GDFiHG/Ez8742RnjCBGT4hj3FYJyu/8YgC+HfPyXANxzXfcygJ8H8CnfZ1MAvuG67u8D8AqAv+i67tdlOX9TKinvhZT5xwF8CcCvgh7yjL8N4Adc130cwH8tj/08gC3XdT8pj78khMgD+O8BvOC67pMA3gDw3/jKqcvj/wTA35DH/gaAn3Vd9wkAPwJgJ9CmnwXguq77SdmmXxFCmPKzJ2SbPwngjwshLoT0KUaMGCcM8bMTQPzsjHHEiElxjPuFtBDiLQBVAGcB/GbIOc+BHsJwXfcqgLd9n1kA/oN8/S0AC+MqlEpJ3XXddQC/BeAHhBBz8uO3AfxzIcSfBmDLYy8A+Md8veu69wA8A9pi/F3Z/j8H4BFfNf82pE2/C+B/E0L8FQCzruvaGMZzAP6ZrOM6gA8ALMvPfst13S3XdXsArgXqihEjxslD/Owc7mf87IxxZIhJcYz7hR25+n8EgIC0i9sD+q7ruvL1AIA+wTU/DeCSEGINwHsAcgD+qPzsD4Me4k8CeF0IEVWeAPCbUk15wnXdy67r/ozv891gm1zX/QUAfwFAGvSDcGmSDgbKGyozRowYJxbxs3MyxM/OGAdGTIpj3Fe4rtsF8FcA/PWQh+nvAvgpABDkFf3JCYpsA5gOHhRCaLKsT7quu+C67gLILu6n5WcXXNf9bQB/C8AMgCxIgflZXxmnAHwDwA8LIZbksSkhxDJGQAjxMdd133Fd938G8DqA4IP9dwD8KXnuMoAygO9N0NcYMWKcUMTPTgDxszPGESMmxTHuO1zX/TZoC+6nAx/9nwDOCCGuAfj7AN4FsDWmuC8B+JvS6cLvLPIjAG65rlvxHXsFtJ13HsA/E0K8A+DbAP4P13Wbss5TgkIffQfAH3Bd9w6ALwD4VSHE2yBHl3HqxV+TZbwNoA/gP4b0U5P1/0sAX3BddzdYSIwYMWL4ET8742dnjKOFULsqMWI8WEhHkqTruj35kH4RwGOu61oPuGkxYsSI8dAifnbGiHE4iG1uYjxMyAD4bSFEEmSP9pfih3qMGDFijEX87IwR4xAQK8UxYsSIESNGjBgxTjxim+IYMWLEiBEjRowYJx4xKY4RI0aMGDFixIhx4hGT4hgxYsSIESNGjBgnHjEpjhEjRowYMWLEiHHiEZPiGDFixIgRI0aMGCceMSmOESNGjBgxYsSIceLx/wNPsPgOIaGBPgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "ename": "IndexError", + "evalue": "boolean index did not match indexed array along dimension 0; dimension is 89904 but corresponding boolean dimension is 90000", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mrbm_plots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43mspectral_points\u001b[49m\u001b[43m,\u001b[49m\u001b[43mexcess_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msignificance_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43mcumulative_sig\u001b[49m\u001b[43m,\u001b[49m\u001b[43mcumulative_time\u001b[49m\u001b[43m,\u001b[49m\u001b[43mexclusion_mask\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.local/lib/python3.9/site-packages/gammapy_tools/analysis/rbm.py:329\u001b[0m, in \u001b[0;36mrbm_plots\u001b[0;34m(config, spectral_points, excess_map, significance_map, c_sig, c_time, exclusion_mask, save, plot)\u001b[0m\n\u001b[1;32m 318\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots()\n\u001b[1;32m 319\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(\n\u001b[1;32m 320\u001b[0m significance_all,\n\u001b[1;32m 321\u001b[0m density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 325\u001b[0m bins\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m10\u001b[39m,\u001b[38;5;241m50\u001b[39m),\n\u001b[1;32m 326\u001b[0m )\n\u001b[1;32m 328\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(\n\u001b[0;32m--> 329\u001b[0m \u001b[43msignificance_off\u001b[49m\u001b[43m[\u001b[49m\u001b[43mexclusion_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflatten\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m,\n\u001b[1;32m 330\u001b[0m density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 331\u001b[0m alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m,\n\u001b[1;32m 332\u001b[0m color\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mblue\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 333\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moff bins\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 334\u001b[0m bins\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m10\u001b[39m,\u001b[38;5;241m50\u001b[39m),\n\u001b[1;32m 335\u001b[0m )\n\u001b[1;32m 337\u001b[0m \u001b[38;5;66;03m# Now, fit the off distribution with a Gaussian\u001b[39;00m\n\u001b[1;32m 338\u001b[0m mu, std \u001b[38;5;241m=\u001b[39m norm\u001b[38;5;241m.\u001b[39mfit(significance_off[exclusion_mask\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mflatten()])\n", + "\u001b[0;31mIndexError\u001b[0m: boolean index did not match indexed array along dimension 0; dimension is 89904 but corresponding boolean dimension is 90000" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "rbm_plots(config,spectral_points,excess_map, significance_map,cumulative_sig,cumulative_time,exclusion_mask)" ] @@ -669,12 +720,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "id": "6fdf4611", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "======== RESULTS ========\n", + "analysis notebook version : 1.0\n", + "source : Crab\n", + "gammapy version : 1.2\n", + "exposure (min) : 80.13333333333328\n", + "on : 615\n", + "off : 17.86\n", + "alpha : 7.348e-02\n", + "significance : 48.06\n", + "flux : 2.83e-10 1 / (s cm2)\n", + "flux_err : 2.83e-10 1 / (s cm2)\n", + "flux_UL : n/a\n", + "norm : 3.46e-11\n", + "norm_err : 1.86e-12\n", + "index : 2.48\n", + "index_err : 0.06\n" + ] + } + ], "source": [ "write_validation_info(config,spectral_model,flux,flux_err,counts,background,alpha,sigma,exposure)" ] @@ -689,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 44, "id": "3c2c167e", "metadata": {}, "outputs": [ @@ -697,7 +771,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "||notebook v1.0||80.13333333333328||619||18||3.281e-04||55.77||2.54e-10 cm2 s-1||1.22e-11 cm2 s-1||3.46e-11 TeV-1 s-1 cm-2||1.86e-12 TeV-1 s-1 cm-2||2.48||0.06||\n" + "||notebook v1.0||80.13333333333328||503||8||7.260e-02||45.96||2.83e-10 1 / (s cm2) cm2 s-1||2.83e-10 1 / (s cm2) cm2 s-1||3.46e-11 TeV-1 s-1 cm-2||1.86e-12 TeV-1 s-1 cm-2||2.48||0.06||\n" ] } ], @@ -713,7 +787,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a3bb3312", + "id": "4c28d8bc", "metadata": {}, "outputs": [], "source": [] diff --git a/gammapy_tools/analysis/data_products.py b/gammapy_tools/analysis/data_products.py index 9efc223..be5ff39 100644 --- a/gammapy_tools/analysis/data_products.py +++ b/gammapy_tools/analysis/data_products.py @@ -240,7 +240,7 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): else: plt.clf() - return flux_points, result_joint.models, time, sig, integral_flux, integral_flux_err + return flux_points, result_joint.models, time, sig, integral_flux, integral_flux_err[0] def get_flux_lc(config, type="flux"): diff --git a/gammapy_tools/analysis/rbm.py b/gammapy_tools/analysis/rbm.py index f3fde87..b2aed60 100644 --- a/gammapy_tools/analysis/rbm.py +++ b/gammapy_tools/analysis/rbm.py @@ -7,6 +7,7 @@ from astropy.io import fits from os import environ from astropy.table import Table +from scipy.optimize import fsolve # %matplotlib inline import astropy.units as u @@ -18,7 +19,7 @@ from gammapy.analysis import Analysis, AnalysisConfig from gammapy.datasets import MapDatasetOnOff from gammapy.estimators import ExcessMapEstimator -from gammapy.makers import RingBackgroundMaker +from gammapy.makers import RingBackgroundMaker,SafeMaskMaker from gammapy.data import DataStore from gammapy.modeling.models import PowerLawSpectralModel @@ -27,6 +28,32 @@ log = logging.getLogger(__name__) +def estimate_alpha(S,N_on,N_off): + """ + Numerically estimates alpha from significance, ON counts, and OFF counts + + Parameters + ---------- + S: significance + N_on: on counts + N_off: off counts*alpha + + Returns + ---------- + alpha: estimated alpha + """ + + # Define the function to find the root of + def equation(alpha): + return np.sqrt(2) * np.sqrt(N_on * np.log((1 + alpha) / alpha * (N_on / (N_on + (N_off/alpha)))) + + (N_off/alpha) * np.log((1 + alpha) * ((N_off/alpha) / (N_on + (N_off/alpha))))) - S + + # Initial guess for alpha + alpha_initial_guess = 1e-2 + + # Solve for alpha + alpha_solution = fsolve(equation, alpha_initial_guess) + return alpha_solution[0] def rbm_analysis(config): """ @@ -55,7 +82,6 @@ def rbm_analysis(config): source_config = AnalysisConfig() source_config.datasets.type = "3d" source_config.observations.datastore = data_store - #select only observations from runlist, if specified if config["io"]["from_runlist"]: source_config.observations.obs_ids = np.genfromtxt(config["io"]["runlist"],unpack=True).tolist() @@ -194,36 +220,34 @@ def rbm_analysis(config): dataset_on_off = ring_maker.run(dataset.to_image()) stacked_on_off.stack(dataset_on_off) - # we'll convert our map dataset into a spectrum dataset, - # which is more helpful for extracting info + # spectral model for estimator + #amp, idx = config["spectrum"]["params"] + #spectral_model = PowerLawSpectralModel( + # amplitude=float(amp) * u.Unit("cm-2 s-1 TeV-1"), + # index=float(idx), + # reference=1 * u.TeV, + #) + output_dataset = stacked_on_off.to_spectrum_dataset( CircleSkyRegion(center=source_pos, radius=config["sky_map"]["theta"] * u.deg), containment_correction=True, ) output_dict = output_dataset.info_dict() - # spectral model for estimator - amp, idx = config["spectrum"]["params"] - spectral_model = PowerLawSpectralModel( - amplitude=float(amp) * u.Unit("cm-2 s-1 TeV-1"), - index=float(idx), - reference=1 * u.TeV, - ) - estimator = ExcessMapEstimator( config["sky_map"]["theta"] * u.deg, - selection_optional=["all"], - spectral_model=spectral_model, + selection_optional=[], + #spectral_model=spectral_model, + correlate_off=False ) lima_maps = estimator.run(stacked_on_off) significance_map = lima_maps["sqrt_ts"] excess_map = lima_maps["npred_excess"] - counts = output_dict["counts"] - excess = output_dict["excess"] - background = output_dict["background"] - alpha = output_dict["alpha"] - sigma = output_dict["sqrt_ts"] + counts = lima_maps['npred'].get_by_coord([source_pos.ra, source_pos.dec, 1 * u.TeV])[0] + background = lima_maps['npred_background'].get_by_coord([source_pos.ra, source_pos.dec, 1 * u.TeV])[0] + sigma = lima_maps['sqrt_ts'].get_by_coord([source_pos.ra, source_pos.dec, 1 * u.TeV])[0] + alpha = estimate_alpha(sigma, counts, background) exposure = output_dict["ontime"] #significance_map_off = significance_map * exclusion_mask @@ -231,7 +255,6 @@ def rbm_analysis(config): return ( counts, - excess, background, alpha, sigma, @@ -312,8 +335,8 @@ def rbm_plots( ) # Now, fit the off distribution with a Gaussian - mu, std = norm.fit(significance_off) - x = np.linspace(-8, 8, 50) + mu, std = norm.fit(significance_off[exclusion_mask.data.flatten()]) + x = np.linspace(-5, 10, 50) p = norm.pdf(x, mu, std) ax.plot(x, p, lw=2, color="black") ax.legend() @@ -376,12 +399,13 @@ def write_validation_info( norm_err = spectab["error"][1] output_dict = { - "analysis notebook version": 1.0, + "analysis notebook version": 0.2 + "gammapy-tools version": 1.0.0, "source": config["run_selection"]["source_name"], "gammapy version": gammapy.__version__, - "exposure": float(exposure.value) / 60, + "exposure (min)": float(exposure.value) / 60, "on": int(counts), - "off": int(background), + "off": f"{background:.2f}", "alpha": f"{alpha:.3e}", "significance": f"{sigma:.2f}", "flux": f"{flux:.2e}", From 2adddc8a0038b567829a389b754414ca03bd0e70 Mon Sep 17 00:00:00 2001 From: Samantha Wong Date: Wed, 22 May 2024 15:01:29 -0400 Subject: [PATCH 04/14] fixed sig dist bug + updated example config --- examples/analysis_notebook.ipynb | 87 +++++++++++++++++++------------- examples/example_config.yaml | 81 ++++++++++++++++++----------- gammapy_tools/analysis/rbm.py | 30 +++++------ 3 files changed, 115 insertions(+), 83 deletions(-) diff --git a/examples/analysis_notebook.ipynb b/examples/analysis_notebook.ipynb index 5436ad0..5927ece 100644 --- a/examples/analysis_notebook.ipynb +++ b/examples/analysis_notebook.ipynb @@ -7,7 +7,9 @@ "source": [ "# Basic RBM gammapy analysis for VERITAS data\n", "\n", - "Versions: gammapy (1.1) and V2DL3 (0.5)\n", + "Versions: gammapy-tools (1.0.0), gammapy (1.1) and V2DL3 (0.5)\n", + "\n", + "This notebook is version 0.2\n", "\n", "Uses [rbm.py](../scripts/rbm.py) and [data_products.py](../scripts/data_products.py) for 2D RBM and 1D spectral/LC analyses, respectively.\n", "\n", @@ -18,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "26f6e150", "metadata": {}, "outputs": [], @@ -45,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "f01f9e8f", "metadata": {}, "outputs": [ @@ -55,7 +57,7 @@ "'/homes/wang/swong/.local/lib/python3.9/site-packages/gammapy_tools/__init__.py'" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -83,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "id": "31d9c848", "metadata": {}, "outputs": [], @@ -94,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "39e108e8", "metadata": {}, "outputs": [ @@ -143,7 +145,7 @@ " 'sky_map': {'e_min': 0.01,\n", " 'e_max': 100,\n", " 'n_bins': 30,\n", - " 'map_deg': 3,\n", + " 'map_deg': 5,\n", " 'bin_sz': 0.01,\n", " 'offset_max': 1.75,\n", " 'aeff_max_percent': 0.1,\n", @@ -158,7 +160,7 @@ " 'plot_names': 'crab_test'}" ] }, - "execution_count": 11, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -193,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 8, "id": "1b75f049", "metadata": {}, "outputs": [ @@ -474,7 +476,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "id": "1e3141d3", "metadata": {}, "outputs": [ @@ -502,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "54c1b078", "metadata": { "scrolled": true @@ -514,7 +516,7 @@ "" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -551,24 +553,17 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 11, "id": "31569f55", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:gammapy.data.data_store:Observations selected: 4 out of 4.\n" - ] - }, { "data": { "text/plain": [ "" ] }, - "execution_count": 37, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, @@ -665,7 +660,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -676,20 +671,39 @@ "output_type": "display_data" }, { - "ename": "IndexError", - "evalue": "boolean index did not match indexed array along dimension 0; dimension is 89904 but corresponding boolean dimension is 90000", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mrbm_plots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43mspectral_points\u001b[49m\u001b[43m,\u001b[49m\u001b[43mexcess_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msignificance_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43mcumulative_sig\u001b[49m\u001b[43m,\u001b[49m\u001b[43mcumulative_time\u001b[49m\u001b[43m,\u001b[49m\u001b[43mexclusion_mask\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.9/site-packages/gammapy_tools/analysis/rbm.py:329\u001b[0m, in \u001b[0;36mrbm_plots\u001b[0;34m(config, spectral_points, excess_map, significance_map, c_sig, c_time, exclusion_mask, save, plot)\u001b[0m\n\u001b[1;32m 318\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots()\n\u001b[1;32m 319\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(\n\u001b[1;32m 320\u001b[0m significance_all,\n\u001b[1;32m 321\u001b[0m density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 325\u001b[0m bins\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m10\u001b[39m,\u001b[38;5;241m50\u001b[39m),\n\u001b[1;32m 326\u001b[0m )\n\u001b[1;32m 328\u001b[0m ax\u001b[38;5;241m.\u001b[39mhist(\n\u001b[0;32m--> 329\u001b[0m \u001b[43msignificance_off\u001b[49m\u001b[43m[\u001b[49m\u001b[43mexclusion_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflatten\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m,\n\u001b[1;32m 330\u001b[0m density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 331\u001b[0m alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m,\n\u001b[1;32m 332\u001b[0m color\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mblue\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 333\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moff bins\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 334\u001b[0m bins\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m10\u001b[39m,\u001b[38;5;241m50\u001b[39m),\n\u001b[1;32m 335\u001b[0m )\n\u001b[1;32m 337\u001b[0m \u001b[38;5;66;03m# Now, fit the off distribution with a Gaussian\u001b[39;00m\n\u001b[1;32m 338\u001b[0m mu, std \u001b[38;5;241m=\u001b[39m norm\u001b[38;5;241m.\u001b[39mfit(significance_off[exclusion_mask\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mflatten()])\n", - "\u001b[0;31mIndexError\u001b[0m: boolean index did not match indexed array along dimension 0; dimension is 89904 but corresponding boolean dimension is 90000" + "name": "stdout", + "output_type": "stream", + "text": [ + "Fit results: mu = -0.04, std = 1.09\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -720,7 +734,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 14, "id": "6fdf4611", "metadata": { "scrolled": true @@ -731,7 +745,8 @@ "output_type": "stream", "text": [ "======== RESULTS ========\n", - "analysis notebook version : 1.0\n", + "analysis notebook version : 0.2\n", + "gammapy-tools version : 1.0.0\n", "source : Crab\n", "gammapy version : 1.2\n", "exposure (min) : 80.13333333333328\n", @@ -763,7 +778,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 15, "id": "3c2c167e", "metadata": {}, "outputs": [ @@ -771,7 +786,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "||notebook v1.0||80.13333333333328||503||8||7.260e-02||45.96||2.83e-10 1 / (s cm2) cm2 s-1||2.83e-10 1 / (s cm2) cm2 s-1||3.46e-11 TeV-1 s-1 cm-2||1.86e-12 TeV-1 s-1 cm-2||2.48||0.06||\n" + "||notebook v1.0||80.13333333333328||615||17||7.348e-02||48.06||2.83e-10 1 / (s cm2) cm2 s-1||2.83e-10 1 / (s cm2) cm2 s-1||3.46e-11 TeV-1 s-1 cm-2||1.86e-12 TeV-1 s-1 cm-2||2.48||0.06||\n" ] } ], diff --git a/examples/example_config.yaml b/examples/example_config.yaml index ef5a77c..70f8cc5 100644 --- a/examples/example_config.yaml +++ b/examples/example_config.yaml @@ -1,8 +1,13 @@ io: + # ED style runlist with one run number per line runlist: "/raid/romulus/swong/ED490/Eventdisplay_AnalysisScripts_VTS/scripts/crab_test.txt" + # Where to search for background/mimic data search_datastore : "/raid/romulus/dl3/ed/dl3_fullenclosure_moderate2tel/" + # Where to find your runlist's DL3 files (no bkg header) in_dir : "/raid/romulus/swong/mydl3/crabtest/" + # Where to store your DL3 files with appended bkg - this is your DataStore for the analysis out_dir : "/raid/romulus/swong/mydl3/crabtestbkgs/" + # Where to write results & plots results_dir: "/raid/romulus/swong/mydl3/crabtest/results/" # Whether or not to generate the background from the run @@ -11,19 +16,21 @@ io: from_runlist: true binning: - # Energy binning + # Energy binning for bkg generation e_min: 0.1 e_max: 100 e_bins: 10 - # Offset/wobble binning + # Offset/wobble binning for bkg generation off_min: 0 off_max: 2.5 off_bins: 5 -config: +config: + # Number of cores to be used for parallel bkg generation njobs : 16 exclusion: + # Star catalog for finding star exclusions star_cat : "./Hipparcos_MAG8_1997.dat" # Exculde region around a simbad resolveable source name # Expecting name, exclusion @@ -37,47 +44,56 @@ exclusion: # Expecting ra, dec, exclusion # exclude_source_run : [ ("287.10 deg", "6.39 deg", "3.5 deg"] - +# Selection criteria for generating bkg headers background_selection: - # el_min : 40 - # el_max : 30 + # Maximum difference in NSB values nsb_diff : 1.5 - # 1/sin(el) difference - el_diff : 1.5 - # az difference + # Maximum 1/sin(el) difference + el_diff : 1 + # Maximum azimuth difference az_diff : 45 # Minimum number of telescopes - n_tels : 4 - # Maximum time between runs in days + n_tels : 3 + # Maximum time between runs in days - this doesn't need to be set if you're using same_szn time_max : 180 - # Whether or not to smooth the background - smooth : true - smooth_sigma : 1 # Whether bkgs should come from same season as data same_szn : true - time_request : 20 + # Whether or not to smooth the background & by what width (in pixel space) + smooth : true + smooth_sigma : 1 + # How many hours of bkg headers to create + time_request : 50 + # Whether to use KL Divergence criteria to pick nearest runs for bkgs + # If time_request is set, this must be set to true KL_DIV: true + # Whether or not to store the nearest bkgs as FITS files + store_KL: false run_selection: - # Runs of interests # Source of interest source_name : "Crab" + # Whether to get source position from the DL3 header pos_from_DL3: true - #source_ra: 253.4675000 - #source_dec: 39.7602778 - # Maximum offset to select data from + # If pos_from_DL3 is set to false, provide source coordinates in deg + source_ra: 253.4675000 + source_dec: 39.7602778 + # Maximum offset in deg to select data from offset_max : 3.5 - # Number of telescopes to select + # Minimum number of telescopes to select as valid runs n_tel : 3 - # elevation min/maz + # Minimum elevation to select as valid runs el_min : 30 spectrum : + # Energy threshold for spectral/integral flux calculations e_min : 0.2 + # Maximum energy for spectral/integral flux calculations e_max : 30 + # Number of energy bins for spectral calculations e_bins : 8 + # Spectral type type : "PL" - #array of [normalization, spectral index] + # Spectral fit parameters (initial guess) - for power law: array of [normalization, spectral index] params : [3.45e-11,2.6] lightcurve: @@ -85,12 +101,20 @@ lightcurve: bin_size_min: 1000 sky_map: - e_min: 0.1 + # Energy threshold for events to be included in the sky map + e_min: 0.01 + # Maximum energy for sky map e_max: 100 - map_deg: 2.5 + # Number of energy bins for the sky map + n_bins: 30 + # Sky map size (deg) + map_deg: 5 + # Sky map binning (deg) - ED default is 0.01, VEGAS is 0.02 + # Larger bins run faster bin_sz: 0.01 - offset_max: 1.5 - aeff_max_percent: 0.01 + offset_max: 1.75 + # Safe energy threshold (as a %) for effective area - ED doesn't use this, so it's set fairly small + aeff_max_percent: 0.1 #exclusion regions are lists of lists of [[SkyCoord, radius], [SkyCoord, radius], ...] exclusion_regions: [] #theta defines the ON region size @@ -98,14 +122,13 @@ sky_map: #exclusion region around the source on_exclusion_region: 0.35 #RBM parameters - ring_rin: "0.5333335 deg" + ring_rin: "0.6 deg" ring_width: "0.133333 deg" #whether or not to truncate the skymap colourbar at +/- 5 sigma truncate: true - #safe mask max aeff % #dimmest visual magnitude for stars to be excluded min_star_brightness: 8 #where to save outputs results_file: 'crab_test_results.yaml' -plot_names: 'crab_test' +plot_names: 'crab_test' \ No newline at end of file diff --git a/gammapy_tools/analysis/rbm.py b/gammapy_tools/analysis/rbm.py index b2aed60..2561daf 100644 --- a/gammapy_tools/analysis/rbm.py +++ b/gammapy_tools/analysis/rbm.py @@ -309,50 +309,44 @@ def rbm_plots( ) plt.show() + # create a 2D mask for the images significance_map_off = significance_map * exclusion_mask - - # significance distribution - significance_all = significance_map.data[np.isfinite(significance_map.data)] - significance_off = significance_map_off.data[np.isfinite(significance_map_off.data)] + significance_all = significance_map.data.flatten() + significance_off = significance_map_off.data.flatten()[exclusion_mask.data.flatten()] fig, ax = plt.subplots() ax.hist( - significance_all, + significance_all[np.isfinite(significance_all)], density=True, alpha=0.5, color="red", label="all bins", - bins=np.linspace(-5,10,50), + bins=np.linspace(-5,10,100), ) ax.hist( - significance_off[exclusion_mask.data.flatten()], + significance_off[np.isfinite(significance_off)], density=True, alpha=0.5, color="blue", label="off bins", - bins=np.linspace(-5,10,50), + bins=np.linspace(-5,10,100), ) # Now, fit the off distribution with a Gaussian - mu, std = norm.fit(significance_off[exclusion_mask.data.flatten()]) - x = np.linspace(-5, 10, 50) + mu, std = norm.fit(significance_off[np.isfinite(significance_off)]) + x = np.linspace(-10, 10, 100) p = norm.pdf(x, mu, std) ax.plot(x, p, lw=2, color="black") ax.legend() ax.set_xlabel("Significance") ax.set_yscale("log") ax.set_ylim(1e-5, 1) - # xmin, xmax = np.min(significance_all), np.max(significance_all) + xmin, xmax = np.min(significance_all), np.max(significance_all) ax.set_xlim(-5, 10) print(f"Fit results: mu = {mu:.2f}, std = {std:.2f}") ax.text(-4.5, 0.5, f"Fit results: mu = {mu:.2f}, std = {std:.2f}") - plt.savefig( - config["io"]["results_dir"] + config["plot_names"] + "sig_dist.png", - format="png", - bbox_inches="tight", - ) if plot: plt.show() else: @@ -399,8 +393,8 @@ def write_validation_info( norm_err = spectab["error"][1] output_dict = { - "analysis notebook version": 0.2 - "gammapy-tools version": 1.0.0, + "analysis notebook version": 0.2, + "gammapy-tools version": "1.0.0", "source": config["run_selection"]["source_name"], "gammapy version": gammapy.__version__, "exposure (min)": float(exposure.value) / 60, From df63b9bd545b0a5b5d86bbea546ee2bf14ecd53f Mon Sep 17 00:00:00 2001 From: Samantha Wong Date: Thu, 23 May 2024 13:55:30 -0400 Subject: [PATCH 05/14] Update example_config.yaml changed required tels from 3 to 4 --- examples/example_config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/example_config.yaml b/examples/example_config.yaml index 70f8cc5..4f5be76 100644 --- a/examples/example_config.yaml +++ b/examples/example_config.yaml @@ -53,7 +53,7 @@ background_selection: # Maximum azimuth difference az_diff : 45 # Minimum number of telescopes - n_tels : 3 + n_tels : 4 # Maximum time between runs in days - this doesn't need to be set if you're using same_szn time_max : 180 # Whether bkgs should come from same season as data @@ -131,4 +131,4 @@ sky_map: #where to save outputs results_file: 'crab_test_results.yaml' -plot_names: 'crab_test' \ No newline at end of file +plot_names: 'crab_test' From 8eec9ec446a37973dbd5a126030377b021e5cea7 Mon Sep 17 00:00:00 2001 From: Samantha Wong Date: Thu, 23 May 2024 13:55:41 -0400 Subject: [PATCH 06/14] Delete examples/mrk_501_v5.yaml --- examples/mrk_501_v5.yaml | 114 --------------------------------------- 1 file changed, 114 deletions(-) delete mode 100644 examples/mrk_501_v5.yaml diff --git a/examples/mrk_501_v5.yaml b/examples/mrk_501_v5.yaml deleted file mode 100644 index 3aa02de..0000000 --- a/examples/mrk_501_v5.yaml +++ /dev/null @@ -1,114 +0,0 @@ -io: - runlist: "/raid/romulus/swong/ED490/Eventdisplay_AnalysisScripts_VTS/scripts/mrk501_v5.txt" - search_datastore : "/raid/romulus/dl3/ed/dl3_fullenclosure_moderate2tel/" - in_dir : "/raid/romulus/swong/mydl3/mrk501_v5/" - out_dir : "/raid/romulus/swong/mydl3/mrk501_v5/bkgs/" #"/raid/romulus/swong/mydl3/mrk501_v4_bkgs/" - results_dir: "/raid/romulus/swong/mydl3/mrk501_v5/results/" - - # Whether or not to generate the background from the run - from_run : false - # Whether or not to analyze runs from a runlist or all runs in the results_dir - from_runlist: true - -binning: - # Energy binning - e_min: 0.1 - e_max: 100 - e_bins: 10 - # Offset/wobble binning - off_min: 0 - off_max: 2.5 - off_bins: 5 - -config: - njobs : 16 - -exclusion: - star_cat : "./Hipparcos_MAG8_1997.dat" - # Exculde region around a simbad resolveable source name - # Expecting name, exclusion - exclude_source_name : - # Exculde region around a given ra, dec - exclude_regions : - # Exculde region around a given ra, dec - # Exculde region around a given ra, dec - # exclude_source_pos : [ ("287.10 deg", "6.39 deg", "0.5 deg"] - # Exculde entire run within a distance to a given ra/dec - # Expecting ra, dec, exclusion - # exclude_source_run : [ ("287.10 deg", "6.39 deg", "3.5 deg"] - - -background_selection: - # el_min : 40 - # el_max : 30 - nsb_diff : 1.5 - # 1/sin(el) difference - el_diff : 1.5 - # az difference - az_diff : 45 - # Minimum number of telescopes - n_tels : 4 - # Maximum time between runs in days - time_max : 180 - # Whether or not to smooth the background - smooth : true - smooth_sigma : 1 - # Whether bkgs should come from same season as data - same_szn : true - time_request : 20 - KL_DIV: true - #max_runs : true - #n_runs : 50 - - -run_selection: - # Runs of interests - # Source of interest - source_name : "Mrk 501" - pos_from_DL3: false - source_ra: 253.4675000 - source_dec: 39.7602778 - # Maximum offset to select data from - offset_max : 3.5 - # Number of telescopes to select - n_tel : 3 - # elevation min/maz - el_min : 20 - -spectrum : - e_min : 0.2 - e_max : 30 - e_bins : 8 - type : "PL" - #array of [normalization, spectral index] - params : [1e-11,2.72] - -lightcurve: - #light curve bin size in minutes - bin_size_min: 1000 - -sky_map: - map_deg: 2.5 - bin_sz: 0.01 - e_min: 0.1 - e_max: 100 - offset_max: 1.5 - aeff_max_percent: 0.1 - #exclusion regions are lists of lists of [[SkyCoord, radius], [SkyCoord, radius], ...] - exclusion_regions: [] - #theta defines the ON region size - theta: 0.0894427191 - #exclusion region around the source - on_exclusion_region: 0.35 - #RBM parameters - ring_rin: "0.6 deg" - ring_width: "0.133333 deg" - #whether or not to truncate the skymap colourbar at +/- 5 sigma - truncate: true - #safe mask max aeff % - #dimmest visual magnitude for stars to be excluded - min_star_brightness: 8 - -#where to save outputs -results_file: 'mrk501_v5_results.yaml' -plot_names: 'mrk501_v5' From 39ecdbddcb135f47b8b6ba1914bbcebf45958888 Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 11:11:16 -0400 Subject: [PATCH 07/14] docs(examples/example_config.yaml): adding units #46 --- examples/example_config.yaml | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/examples/example_config.yaml b/examples/example_config.yaml index 4f5be76..e822eaa 100644 --- a/examples/example_config.yaml +++ b/examples/example_config.yaml @@ -94,6 +94,7 @@ spectrum : # Spectral type type : "PL" # Spectral fit parameters (initial guess) - for power law: array of [normalization, spectral index] + # Assumes normalization is in units of TeV^-1 cm^-2 s^-1 params : [3.45e-11,2.6] lightcurve: @@ -101,9 +102,9 @@ lightcurve: bin_size_min: 1000 sky_map: - # Energy threshold for events to be included in the sky map + # Energy threshold for events to be included in the sky map (TeV) e_min: 0.01 - # Maximum energy for sky map + # Maximum energy for sky map (TeV) e_max: 100 # Number of energy bins for the sky map n_bins: 30 @@ -117,9 +118,9 @@ sky_map: aeff_max_percent: 0.1 #exclusion regions are lists of lists of [[SkyCoord, radius], [SkyCoord, radius], ...] exclusion_regions: [] - #theta defines the ON region size + #theta defines the ON region size (deg) theta: 0.0894427191 - #exclusion region around the source + #exclusion region around the source (deg) on_exclusion_region: 0.35 #RBM parameters ring_rin: "0.6 deg" From 9124cda546177fa30bbc99280a1b0c3665eeaf2c Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 11:14:55 -0400 Subject: [PATCH 08/14] refactor(gammapy_tools/templates/config.py): updating config template #46 --- gammapy_tools/templates/config.py | 174 ++++++++++++++++-------------- 1 file changed, 96 insertions(+), 78 deletions(-) diff --git a/gammapy_tools/templates/config.py b/gammapy_tools/templates/config.py index 964f75e..8b3433b 100644 --- a/gammapy_tools/templates/config.py +++ b/gammapy_tools/templates/config.py @@ -1,121 +1,139 @@ config = """io: - search_datastore : "/path/to/datastore/" - in_dir : "/path/to/input_dir/" - out_dir : "/path/to/output_dir/" - results_dir : "/path/to/results_dir/" + # ED style runlist with one run number per line + runlist: "/raid/romulus/swong/ED490/Eventdisplay_AnalysisScripts_VTS/scripts/crab_test.txt" + # Where to search for background/mimic data + search_datastore : "/raid/romulus/dl3/ed/dl3_fullenclosure_moderate2tel/" + # Where to find your runlist's DL3 files (no bkg header) + in_dir : "/raid/romulus/swong/mydl3/crabtest/" + # Where to store your DL3 files with appended bkg - this is your DataStore for the analysis + out_dir : "/raid/romulus/swong/mydl3/crabtestbkgs/" + # Where to write results & plots + results_dir: "/raid/romulus/swong/mydl3/crabtest/results/" + # Whether or not to generate the background from the run - from_run : False - use_runlist : False + from_run : false + # Whether or not to analyze runs from a runlist or all runs in the results_dir + from_runlist: true binning: - # Energy binning + # Energy binning for bkg generation e_min: 0.1 e_max: 100 - e_bins: 20 - # Offset/wobble binning + e_bins: 10 + # Offset/wobble binning for bkg generation off_min: 0 off_max: 2.5 off_bins: 5 config: - njobs : 1 + # Number of cores to be used for parallel bkg generation + njobs : 16 exclusion: + # Star catalog for finding star exclusions star_cat : "./Hipparcos_MAG8_1997.dat" # Exculde region around a simbad resolveable source name # Expecting name, exclusion exclude_source_name : - - [ "MGRO J1908+06", "0.5 deg"] # Exculde region around a given ra, dec exclude_regions : - - ["287.10", "6.39", "0.5"] # Exculde region around a given ra, dec # Exculde region around a given ra, dec - # exclude_source_pos : [ "287.10 deg", "6.39 deg", "0.5 deg"] + # exclude_source_pos : [ ("287.10 deg", "6.39 deg", "0.5 deg"] # Exculde entire run within a distance to a given ra/dec # Expecting ra, dec, exclusion - # exclude_source_run : [ "287.10 deg", "6.39 deg", "3.5 deg"] + # exclude_source_run : [ ("287.10 deg", "6.39 deg", "3.5 deg"] +# Selection criteria for generating bkg headers background_selection: - # el_min : 40 - # el_max : 30 - nsb_diff : 0.7 - # 1/sin(el) difference - el_diff : 0.15 - # az difference + # Maximum difference in NSB values + nsb_diff : 1.5 + # Maximum 1/sin(el) difference + el_diff : 1 + # Maximum azimuth difference az_diff : 45 # Minimum number of telescopes n_tels : 4 - # Maximum time between runs in days + # Maximum time between runs in days - this doesn't need to be set if you're using same_szn time_max : 180 - # Requested number of hours for producing a background - time_request : 10 - # Whether or not to smooth the background - smooth : False - # Sigma of the gaussian smoothing kernel - smooth_sigma : 1.0 - # If we should use the KL divergence to find the background runs - KL_DIV : True - store_KL : True - bright_sources : - - "Crab" - - "Mrk421" - - "Mrk501" - - "1ES1215+303" - - "1ES1218+304" - - "RGBJ0710+591" - - "1ES1440+122" - - "PG1553+113" - - "IC443" - - "Boomerang" - - "3C66A" - - "W Comae" - - "M87" - - "OJ 287" - + # Whether bkgs should come from same season as data + same_szn : true + # Whether or not to smooth the background & by what width (in pixel space) + smooth : true + smooth_sigma : 1 + # How many hours of bkg headers to create + time_request : 50 + # Whether to use KL Divergence criteria to pick nearest runs for bkgs + # If time_request is set, this must be set to true + KL_DIV: true + # Whether or not to store the nearest bkgs as FITS files + store_KL: false run_selection: - # Runs of interests - runlist : [ 64080, 64081, 64082, 64083] # Source of interest - use_name : False source_name : "Crab" - source_ra : 83.6333 - source_dec : 22.0133 - # Coords to search around - # coords : ["287.10 deg", "6.39 deg"] - # coords_galactic : ["40.39 deg", "-0.79 deg"] - # Maximum offset to select data from - offset_max : 1.5 - # Number of telescopes to select - n_tel : 4 - # elevation min/maz - el_min : 40 - # el_max : 90 - # Time range (d/m/y) - # time_min : "01/09/2007" - # time_max : "01/09/2025" + # Whether to get source position from the DL3 header + pos_from_DL3: true + # If pos_from_DL3 is set to false, provide source coordinates in deg + source_ra: 253.4675000 + source_dec: 39.7602778 + # Maximum offset in deg to select data from + offset_max : 3.5 + # Minimum number of telescopes to select as valid runs + n_tel : 3 + # Minimum elevation to select as valid runs + el_min : 30 spectrum : + # Energy threshold for spectral/integral flux calculations e_min : 0.2 - e_max : 10 - e_bins : 10 - # Defaulting to a crab-like spectrum + # Maximum energy for spectral/integral flux calculations + e_max : 30 + # Number of energy bins for spectral calculations + e_bins : 8 + # Spectral type type : "PL" - params : [3.48e-11,2.4] + # Spectral fit parameters (initial guess) - for power law: array of + # [normalization, spectral index] + # Assumes normalization is in units of TeV^-1 cm^-2 s^-1 + params : [3.45e-11,2.6] + lightcurve: + #light curve bin size in minutes bin_size_min: 1000 + sky_map: - map_deg: 2.5 + # Energy threshold for events to be included in the sky map (TeV) + e_min: 0.01 + # Maximum energy for sky map (TeV) + e_max: 100 + # Number of energy bins for the sky map + n_bins: 30 + # Sky map size (deg) + map_deg: 5 + # Sky map binning (deg) - ED default is 0.01, VEGAS is 0.02 + # Larger bins run faster + bin_sz: 0.01 + offset_max: 1.75 + # Safe energy threshold (as a %) for effective area + # - ED doesn't use this, so it's set fairly small + aeff_max_percent: 0.1 + #exclusion regions are lists of lists of [[SkyCoord, radius], [SkyCoord, radius], ...] exclusion_regions: [] - theta: 0.08944272 + #theta defines the ON region size (deg) + theta: 0.0894427191 + #exclusion region around the source (deg) on_exclusion_region: 0.35 - ring_rin: "0.7 deg" - ring_width: "0.1 deg" - truncate: True - bin_size : "0.02 deg" - aeff_max_percent : 0.15 - min_star_brightness : 8 -results_file: 'results.yaml' -plot_names: 'my_source' + #RBM parameters + ring_rin: "0.6 deg" + ring_width: "0.133333 deg" + #whether or not to truncate the skymap colourbar at +/- 5 sigma + truncate: true + #dimmest visual magnitude for stars to be excluded + min_star_brightness: 8 + +#where to save outputs +results_file: 'crab_test_results.yaml' +plot_names: 'crab_test' + """ From 01caafd3b6dbd8a002fac245acbc532bb5c4fefb Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 11:44:03 -0400 Subject: [PATCH 09/14] docs(__init__.py): adding versions --- gammapy_tools/_version.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/gammapy_tools/_version.py b/gammapy_tools/_version.py index 8f32dc2..c1b1168 100644 --- a/gammapy_tools/_version.py +++ b/gammapy_tools/_version.py @@ -3,6 +3,7 @@ TYPE_CHECKING = False if TYPE_CHECKING: from typing import Tuple, Union + VERSION_TUPLE = Tuple[Union[int, str], ...] else: VERSION_TUPLE = object @@ -12,5 +13,5 @@ __version_tuple__: VERSION_TUPLE version_tuple: VERSION_TUPLE -__version__ = version = "0.1.3.dev82+gf90456e.d20240402" -__version_tuple__ = version_tuple = (0, 1, 3, "dev82", "gf90456e.d20240402") \ No newline at end of file +__version__ = version = "1.0.1.dev9+g9124cda.d20240527" +__version_tuple__ = version_tuple = (1, 0, 1, "dev9", "g9124cda.d20240527") From bf9636db461890369a3a283e98d2fdd3a20e3037 Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 11:51:14 -0400 Subject: [PATCH 10/14] docs(gammapy_tools/analysis/data_products.py): type hinting #46 --- gammapy_tools/analysis/data_products.py | 136 +++++++++++++++--------- 1 file changed, 85 insertions(+), 51 deletions(-) diff --git a/gammapy_tools/analysis/data_products.py b/gammapy_tools/analysis/data_products.py index be5ff39..649c136 100644 --- a/gammapy_tools/analysis/data_products.py +++ b/gammapy_tools/analysis/data_products.py @@ -1,4 +1,3 @@ -from pathlib import Path import numpy as np import astropy.units as u from astropy.coordinates import Angle, SkyCoord @@ -8,10 +7,10 @@ from os import environ import os from astropy.io import fits +from typing import Optional, Tuple # %matplotlib inline import matplotlib.pyplot as plt -from IPython.display import display # gammapy imports from gammapy.data import DataStore @@ -20,7 +19,7 @@ FluxPointsDataset, SpectrumDataset, ) -from gammapy.estimators import FluxPointsEstimator +from gammapy.estimators import FluxPointsEstimator, FluxPoints from gammapy.makers import ( ReflectedRegionsBackgroundMaker, SafeMaskMaker, @@ -35,13 +34,12 @@ SkyModel, ) from gammapy.estimators import LightCurveEstimator -from gammapy.analysis import Analysis, AnalysisConfig -from gammapy.catalog import SourceCatalogGammaCat, SourceCatalog3HWC from gammapy.visualization import plot_spectrum_datasets_off_regions -from gammapy_tools.utils import exclusion_finder -def make_spectrum_RE(config, plot=True, return_stacked=False): +def make_spectrum_RE( + config: dict, plot: Optional[bool] = True, return_stacked: Optional[bool] = False +) -> Tuple[FluxPoints, SkyModel, float, u.Quantity, u.Quantity, u.Quantity]: """Make a RE spectrum Parameters @@ -56,6 +54,8 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): spectral_model: best-fit spectral model object time: time for cumulative significance sig: sqrt(ts) for cumulative significance + integral_flux : integral flux from spectral model + integral_flux_err : error on integral flux """ e_min = config["spectrum"]["e_min"] @@ -69,8 +69,12 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): observations = datastore.get_observations() if config["run_selection"]["pos_from_DL3"]: # get position from DL3 header - hdul = fits.open(config["io"]["out_dir"]+os.listdir(config["io"]["out_dir"])[0]) - source_pos = SkyCoord(hdul[1].header["RA_OBJ"]*u.deg, hdul[1].header["DEC_OBJ"]*u.deg) + hdul = fits.open( + config["io"]["out_dir"] + os.listdir(config["io"]["out_dir"])[0] + ) + source_pos = SkyCoord( + hdul[1].header["RA_OBJ"] * u.deg, hdul[1].header["DEC_OBJ"] * u.deg + ) else: # get position from ra/dec [deg] source_pos = SkyCoord( config["run_selection"]["source_ra"], @@ -135,8 +139,10 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): ) < 2.0 ) - star_mask &= (star_cat["mag"]+star_cat["colour"])< config["sky_map"]["min_star_brightness"] - + star_mask &= (star_cat["mag"] + star_cat["colour"]) < config["sky_map"][ + "min_star_brightness" + ] + # append stars to exclusion list for src in star_cat[star_mask]: exclusion_regions.append( @@ -180,13 +186,15 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): info_table = datasets.info_table(cumulative=True) time = info_table["livetime"].to("h") sig = info_table["sqrt_ts"] - - #plot exclusion regions and reflected regions - if len(exclusion_regions) > 0 and plot: - plt.figure(figsize=(8,8)) + + # plot exclusion regions and reflected regions + if len(exclusion_regions) > 0 and plot: + plt.figure(figsize=(8, 8)) ax = exclusion_mask.plot() - on_region.to_pixel(ax.wcs).plot(ax=ax, edgecolor="magenta",label='ON') - plot_spectrum_datasets_off_regions(ax=ax, datasets=datasets) #add legend=True to plot run numbers associated w/ OFF regions + on_region.to_pixel(ax.wcs).plot(ax=ax, edgecolor="magenta", label="ON") + plot_spectrum_datasets_off_regions( + ax=ax, datasets=datasets + ) # add legend=True to plot run numbers associated w/ OFF regions plt.show() # make spectrum model from user input @@ -212,9 +220,13 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): spectral_model = LogParabolaSpectralModel( alpha=float(alp), amplitude=float(amp), reference=1 * u.TeV, beta=float(bet) ) - #calculate integral flux from spectral model - integral_flux = spectral_model.integral(e_min * u.Unit("TeV"),e_max* u.Unit("TeV")) - integral_flux_err = spectral_model.integral_error(e_min* u.Unit("TeV"),e_max* u.Unit("TeV")) + # calculate integral flux from spectral model + integral_flux = spectral_model.integral( + e_min * u.Unit("TeV"), e_max * u.Unit("TeV") + ) + integral_flux_err = spectral_model.integral_error( + e_min * u.Unit("TeV"), e_max * u.Unit("TeV") + ) model = SkyModel(spectral_model=spectral_model, name="my_source") datasets.models = [model] @@ -224,7 +236,10 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): energy_edges = np.geomspace(e_min, e_max, e_bins) * u.TeV fpe = FluxPointsEstimator( - energy_edges=energy_edges, source="my_source", selection_optional="all",n_sigma_ul=2 + energy_edges=energy_edges, + source="my_source", + selection_optional="all", + n_sigma_ul=2, ) flux_points = fpe.run(datasets=datasets) @@ -240,10 +255,17 @@ def make_spectrum_RE(config, plot=True, return_stacked=False): else: plt.clf() - return flux_points, result_joint.models, time, sig, integral_flux, integral_flux_err[0] + return ( + flux_points, + result_joint.models, + time, + sig, + integral_flux, + integral_flux_err[0], + ) -def get_flux_lc(config, type="flux"): +def get_flux_lc(config: dict, type: Optional[str] = "flux") -> LightCurveEstimator: """Output run-wise flux points and the overall flux of a 1D dataset Parameters @@ -259,17 +281,24 @@ def get_flux_lc(config, type="flux"): """ theta = config["sky_map"]["theta"] datastore = DataStore.from_dir(config["io"]["out_dir"]) - + if config["io"]["from_runlist"]: - observations = datastore.get_observations(obs_id=np.genfromtxt(config["io"]["runlist"],unpack=True),required_irf="all-optional") + observations = datastore.get_observations( + obs_id=np.genfromtxt(config["io"]["runlist"], unpack=True), + required_irf="all-optional", + ) else: observations = datastore.get_observations(required_irf="all-optional") - + amp, idx = config["spectrum"]["params"] - + if config["run_selection"]["pos_from_DL3"]: # get position from DL3 header - hdul = fits.open(config["io"]["out_dir"]+os.listdir(config["io"]["out_dir"])[0]) - source_pos = SkyCoord(hdul[1].header["RA_OBJ"]*u.deg, hdul[1].header["DEC_OBJ"]*u.deg) + hdul = fits.open( + config["io"]["out_dir"] + os.listdir(config["io"]["out_dir"])[0] + ) + source_pos = SkyCoord( + hdul[1].header["RA_OBJ"] * u.deg, hdul[1].header["DEC_OBJ"] * u.deg + ) else: # get position from ra/dec [deg] source_pos = SkyCoord( config["run_selection"]["source_ra"], @@ -277,18 +306,19 @@ def get_flux_lc(config, type="flux"): frame="icrs", unit="deg", ) - + e_min = config["spectrum"]["e_min"] - e_max = 100 #config["spectrum"]["e_max"] + e_max = 100 # config["spectrum"]["e_max"] nbin = config["spectrum"]["e_bins"] - selection = dict( - type="sky_circle", - frame="icrs", - lon=source_pos.ra, - lat=source_pos.dec, - radius=2 * u.deg, - ) + # Currently unused? + # _selection = dict( + # type="sky_circle", + # frame="icrs", + # lon=source_pos.ra, + # lat=source_pos.dec, + # radius=2 * u.deg, + # ) # energy binning energy_axis = MapAxis.from_energy_bounds( @@ -302,8 +332,12 @@ def get_flux_lc(config, type="flux"): # exclusion regions exclusion_regions = [] - exclusion_regions.append(CircleSkyRegion(center=source_pos,radius=config["sky_map"]["on_exclusion_region"]*u.deg)) - + exclusion_regions.append( + CircleSkyRegion( + center=source_pos, radius=config["sky_map"]["on_exclusion_region"] * u.deg + ) + ) + if ( len(config["sky_map"]["exclusion_regions"]) > 0 ): # should be a list of CircleSkyRegions @@ -340,7 +374,7 @@ def get_flux_lc(config, type="flux"): "dec": star_data[:, 1], "id": star_data[:, 2], "mag": star_data[:, 3], - "colour": star_data[:,4], + "colour": star_data[:, 4], } ) star_mask = ( @@ -351,8 +385,10 @@ def get_flux_lc(config, type="flux"): < 2.0 ) - star_mask &= (star_cat["mag"]+star_cat["colour"])< config["sky_map"]["min_star_brightness"] - + star_mask &= (star_cat["mag"] + star_cat["colour"]) < config["sky_map"][ + "min_star_brightness" + ] + for src in star_cat[star_mask]: exclusion_regions.append( CircleSkyRegion( @@ -361,7 +397,7 @@ def get_flux_lc(config, type="flux"): ) ) - #create exclusion mask + # create exclusion mask geom = WcsGeom.create( npix=(150, 150), binsz=0.05, skydir=source_pos, proj="TAN", frame="icrs" ) @@ -387,11 +423,11 @@ def get_flux_lc(config, type="flux"): if type == "flux": time_intervals = [Time([start, stop])] lc_maker_1d = LightCurveEstimator( - energy_edges=[e_min,e_max] * u.TeV, + energy_edges=[e_min, e_max] * u.TeV, time_intervals=time_intervals, n_sigma_ul=2, reoptimize=False, - selection_optional='all' + selection_optional="all", ) short_observations = observations.select_time(time_intervals) @@ -413,9 +449,7 @@ def get_flux_lc(config, type="flux"): if type == "runwise": lc_maker_1d = LightCurveEstimator( - energy_edges=[e_min, e_max] * u.TeV, - selection_optional=None, - n_sigma_ul=2 + energy_edges=[e_min, e_max] * u.TeV, selection_optional=None, n_sigma_ul=2 ) short_observations = observations @@ -432,7 +466,7 @@ def get_flux_lc(config, type="flux"): spectral_model = PowerLawSpectralModel( index=float(idx), amplitude=float(amp) * u.Unit("1 / (cm2 s TeV)"), - reference=1 * u.TeV + reference=1 * u.TeV, ) sky_model = SkyModel( spatial_model=None, spectral_model=spectral_model, name="model" @@ -440,7 +474,7 @@ def get_flux_lc(config, type="flux"): sky_model.parameters["index"].frozen = True sky_model.parameters["reference"].frozen = True - + datasets.models = sky_model lc_1d = lc_maker_1d.run(datasets=datasets) From 82e34b2a9f01e201a842ec1be8d4ba66bc54de52 Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 11:52:39 -0400 Subject: [PATCH 11/14] style(gammapy_tools/make_background/make_background.py-gammapy_tools/utils/run_details.py): pre-commit formatting #46 --- .../make_background/make_background.py | 22 ++++++++++++++++--- gammapy_tools/utils/run_details.py | 5 ++++- 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/gammapy_tools/make_background/make_background.py b/gammapy_tools/make_background/make_background.py index 798b41b..d621c65 100644 --- a/gammapy_tools/make_background/make_background.py +++ b/gammapy_tools/make_background/make_background.py @@ -5,7 +5,8 @@ import numpy as np import yaml from os import listdir -from os.path import isfile, join, getsize +from os.path import isfile, join + # Astropy from astropy.io import fits from gammapy.data import DataStore @@ -418,12 +419,27 @@ def run_make_background(config: dict) -> dict: return config + def write_index_files(config): dl3_dir = config["io"]["out_dir"] - dl3Files = [dl3_dir + f for f in listdir(dl3_dir) if isfile(join(dl3_dir, f)) and (f.endswith(".fits") or (f.endswith(".fits.gz") and not f.startswith("obs") and not f.startswith("hdu"))) and (f.strip('.anasum.fits') )] - create_obs_hdu_index_file(dl3Files,index_file_dir=dl3_dir) + dl3Files = [ + dl3_dir + f + for f in listdir(dl3_dir) + if isfile(join(dl3_dir, f)) + and ( + f.endswith(".fits") + or ( + f.endswith(".fits.gz") + and not f.startswith("obs") + and not f.startswith("hdu") + ) + ) + and (f.strip(".anasum.fits")) + ] + create_obs_hdu_index_file(dl3Files, index_file_dir=dl3_dir) return + if __name__ == "__main__": with open(sys.argv[1], "r") as f: config = yaml.safe_load(f) diff --git a/gammapy_tools/utils/run_details.py b/gammapy_tools/utils/run_details.py index 9c8da53..1107765 100644 --- a/gammapy_tools/utils/run_details.py +++ b/gammapy_tools/utils/run_details.py @@ -141,7 +141,10 @@ def find_data_mimic( # mask in time if config["background_selection"]["same_szn"]: - sub_table = obs_table[(obs_date > list(season.values())[0]) & (obs_date < list(season.values())[1])] + sub_table = obs_table[ + (obs_date > list(season.values())[0]) + & (obs_date < list(season.values())[1]) + ] else: sub_table = obs_table[np.abs(obs_date - tobs) < time_max] From ab1209ad842cc7f705e0669045faedb078a88e66 Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 11:54:05 -0400 Subject: [PATCH 12/14] build(pyproject.toml): adding tqdm to requirements #46 --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 481539d..6d9c301 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,6 +49,7 @@ dependencies = [ #"pyV2DL3", "PyYAML", "regions", + "tqdm", ] [project.optional-dependencies] From cd8ab31a53813594a32a14d922f2a80944a51633 Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 12:05:39 -0400 Subject: [PATCH 13/14] fix(pyproject.toml): require gammapy >= 1.2 gammapy 1.2 resolves issue with plot_at_energy --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 6d9c301..2627c26 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,7 +38,7 @@ requires-python = ">=3.9" #] dependencies = [ - "gammapy>=1.1", + "gammapy>=1.2", "pydantic", "scipy==1.11.4", "astropy", From 094d05591d7154b7fa2b8121403ab4272c1eb77f Mon Sep 17 00:00:00 2001 From: Ste O'Brien Date: Mon, 27 May 2024 12:07:33 -0400 Subject: [PATCH 14/14] fix(gammapy_tools/analysis/rbm.py): adding type hinting, applying region masking to histograms and infinity mask in the one step #46 --- gammapy_tools/_version.py | 4 +- gammapy_tools/analysis/rbm.py | 183 +++++++++++++++++++++------------- 2 files changed, 117 insertions(+), 70 deletions(-) diff --git a/gammapy_tools/_version.py b/gammapy_tools/_version.py index c1b1168..ce61932 100644 --- a/gammapy_tools/_version.py +++ b/gammapy_tools/_version.py @@ -13,5 +13,5 @@ __version_tuple__: VERSION_TUPLE version_tuple: VERSION_TUPLE -__version__ = version = "1.0.1.dev9+g9124cda.d20240527" -__version_tuple__ = version_tuple = (1, 0, 1, "dev9", "g9124cda.d20240527") +__version__ = version = "1.0.1.dev13+gab1209a.d20240527" +__version_tuple__ = version_tuple = (1, 0, 1, "dev13", "gab1209a.d20240527") diff --git a/gammapy_tools/analysis/rbm.py b/gammapy_tools/analysis/rbm.py index 2561daf..d337604 100644 --- a/gammapy_tools/analysis/rbm.py +++ b/gammapy_tools/analysis/rbm.py @@ -2,12 +2,12 @@ import yaml import numpy as np from scipy.stats import norm -from IPython.display import display import os from astropy.io import fits from os import environ from astropy.table import Table from scipy.optimize import fsolve +from typing import Optional, Tuple # %matplotlib inline import astropy.units as u @@ -19,16 +19,19 @@ from gammapy.analysis import Analysis, AnalysisConfig from gammapy.datasets import MapDatasetOnOff from gammapy.estimators import ExcessMapEstimator -from gammapy.makers import RingBackgroundMaker,SafeMaskMaker -from gammapy.data import DataStore +from gammapy.makers import RingBackgroundMaker +from gammapy.maps.wcs.ndmap import WcsNDMap +from gammapy.modeling.models import SpectralModel -from gammapy.modeling.models import PowerLawSpectralModel +# importing package version +from .._version import __version__ as gpt_version -from astroquery.simbad import Simbad +__notebook_version__ = "0.2" log = logging.getLogger(__name__) -def estimate_alpha(S,N_on,N_off): + +def estimate_alpha(S: float, N_on: float, N_off: float) -> float: """ Numerically estimates alpha from significance, ON counts, and OFF counts @@ -45,17 +48,27 @@ def estimate_alpha(S,N_on,N_off): # Define the function to find the root of def equation(alpha): - return np.sqrt(2) * np.sqrt(N_on * np.log((1 + alpha) / alpha * (N_on / (N_on + (N_off/alpha)))) + - (N_off/alpha) * np.log((1 + alpha) * ((N_off/alpha) / (N_on + (N_off/alpha))))) - S - + return ( + np.sqrt(2) + * np.sqrt( + N_on * np.log((1 + alpha) / alpha * (N_on / (N_on + (N_off / alpha)))) + + (N_off / alpha) + * np.log((1 + alpha) * ((N_off / alpha) / (N_on + (N_off / alpha)))) + ) + - S + ) + # Initial guess for alpha alpha_initial_guess = 1e-2 - + # Solve for alpha alpha_solution = fsolve(equation, alpha_initial_guess) return alpha_solution[0] -def rbm_analysis(config): + +def rbm_analysis( + config: dict, +) -> Tuple[float, float, float, float, np.ndarray, float, np.ndarray, np.ndarray]: """ Performs a basic RBM analysis @@ -82,15 +95,21 @@ def rbm_analysis(config): source_config = AnalysisConfig() source_config.datasets.type = "3d" source_config.observations.datastore = data_store - #select only observations from runlist, if specified + # select only observations from runlist, if specified if config["io"]["from_runlist"]: - source_config.observations.obs_ids = np.genfromtxt(config["io"]["runlist"],unpack=True).tolist() - + source_config.observations.obs_ids = np.genfromtxt( + config["io"]["runlist"], unpack=True + ).tolist() + if config["run_selection"]["pos_from_DL3"]: - #get RA and DEC from first run - hdul = fits.open(config["io"]["out_dir"]+os.listdir(config["io"]["out_dir"])[0]) - source_pos = SkyCoord(hdul[1].header["RA_OBJ"]*u.deg, hdul[1].header["DEC_OBJ"]*u.deg) - + # get RA and DEC from first run + hdul = fits.open( + config["io"]["out_dir"] + os.listdir(config["io"]["out_dir"])[0] + ) + source_pos = SkyCoord( + hdul[1].header["RA_OBJ"] * u.deg, hdul[1].header["DEC_OBJ"] * u.deg + ) + else: source_pos = SkyCoord( config["run_selection"]["source_ra"], @@ -98,7 +117,7 @@ def rbm_analysis(config): frame="icrs", unit="deg", ) - + source_config.datasets.geom.wcs.skydir = { "lon": source_pos.ra, "lat": source_pos.dec, @@ -118,17 +137,26 @@ def rbm_analysis(config): source_config.datasets.geom.selection.offset_max = map_deg * u.deg # We now fix the energy axis for the counts map - (the reconstructed energy binning) - source_config.datasets.geom.axes.energy.min = str(config["sky_map"]["e_min"])+" TeV" - source_config.datasets.geom.axes.energy.max = str(config["sky_map"]["e_max"])+" TeV" + source_config.datasets.geom.axes.energy.min = ( + str(config["sky_map"]["e_min"]) + " TeV" + ) + source_config.datasets.geom.axes.energy.max = ( + str(config["sky_map"]["e_max"]) + " TeV" + ) source_config.datasets.geom.axes.energy.nbins = 30 - source_config.excess_map.correlation_radius = str(config["sky_map"]["theta"]) + " deg" - + source_config.excess_map.correlation_radius = ( + str(config["sky_map"]["theta"]) + " deg" + ) + # We need to extract the ring for each observation separately, hence, no stacking at this stage source_config.datasets.stack = False - source_config.datasets.safe_mask.parameters = {'aeff_percent':config["sky_map"]["aeff_max_percent"], 'offset_max':config["sky_map"]["offset_max"]*u.deg} - source_config.datasets.safe_mask.methods = ['aeff-max','offset-max'] + source_config.datasets.safe_mask.parameters = { + "aeff_percent": config["sky_map"]["aeff_max_percent"], + "offset_max": config["sky_map"]["offset_max"] * u.deg, + } + source_config.datasets.safe_mask.methods = ["aeff-max", "offset-max"] analysis = Analysis(source_config) @@ -139,14 +167,14 @@ def rbm_analysis(config): analysis.get_observations() analysis.get_datasets() - #simbad = Simbad() - #simbad.reset_votable_fields() - #simbad.add_votable_fields("ra", "dec", "flux(B)", "flux(V)", "jp11") - #simbad.remove_votable_fields("coordinates") + # simbad = Simbad() + # simbad.reset_votable_fields() + # simbad.add_votable_fields("ra", "dec", "flux(B)", "flux(V)", "jp11") + # simbad.remove_votable_fields("coordinates") - #srcs_tab = simbad.query_region(source_pos, radius=1.5 * u.deg) - #srcs_tab = srcs_tab[srcs_tab["FLUX_B"] < config["sky_map"]["min_star_brightness"]] - #srcs_tab = srcs_tab[srcs_tab["FLUX_V"] != np.ma.masked] + # srcs_tab = simbad.query_region(source_pos, radius=1.5 * u.deg) + # srcs_tab = srcs_tab[srcs_tab["FLUX_B"] < config["sky_map"]["min_star_brightness"]] + # srcs_tab = srcs_tab[srcs_tab["FLUX_V"] != np.ma.masked] # get the geom that we use geom = analysis.datasets[0].counts.geom @@ -168,7 +196,7 @@ def rbm_analysis(config): radius=radius * u.deg, ) ) - + star_data = np.loadtxt( # environ["GAMMAPY_DATA"] + "/catalogs/Hipparcos_MAG8_1997.dat", usecols=(0, 1, 2, 3, 4) environ["GAMMAPY_DATA"] + "/catalogs/Hipparcos_MAG8_1997.dat", @@ -221,12 +249,12 @@ def rbm_analysis(config): stacked_on_off.stack(dataset_on_off) # spectral model for estimator - #amp, idx = config["spectrum"]["params"] - #spectral_model = PowerLawSpectralModel( + # amp, idx = config["spectrum"]["params"] + # spectral_model = PowerLawSpectralModel( # amplitude=float(amp) * u.Unit("cm-2 s-1 TeV-1"), # index=float(idx), # reference=1 * u.TeV, - #) + # ) output_dataset = stacked_on_off.to_spectrum_dataset( CircleSkyRegion(center=source_pos, radius=config["sky_map"]["theta"] * u.deg), @@ -237,21 +265,27 @@ def rbm_analysis(config): estimator = ExcessMapEstimator( config["sky_map"]["theta"] * u.deg, selection_optional=[], - #spectral_model=spectral_model, - correlate_off=False + # spectral_model=spectral_model, + correlate_off=False, ) lima_maps = estimator.run(stacked_on_off) significance_map = lima_maps["sqrt_ts"] excess_map = lima_maps["npred_excess"] - counts = lima_maps['npred'].get_by_coord([source_pos.ra, source_pos.dec, 1 * u.TeV])[0] - background = lima_maps['npred_background'].get_by_coord([source_pos.ra, source_pos.dec, 1 * u.TeV])[0] - sigma = lima_maps['sqrt_ts'].get_by_coord([source_pos.ra, source_pos.dec, 1 * u.TeV])[0] + counts = lima_maps["npred"].get_by_coord( + [source_pos.ra, source_pos.dec, 1 * u.TeV] + )[0] + background = lima_maps["npred_background"].get_by_coord( + [source_pos.ra, source_pos.dec, 1 * u.TeV] + )[0] + sigma = lima_maps["sqrt_ts"].get_by_coord( + [source_pos.ra, source_pos.dec, 1 * u.TeV] + )[0] alpha = estimate_alpha(sigma, counts, background) exposure = output_dict["ontime"] - #significance_map_off = significance_map * exclusion_mask - #significance_map_off = significance_map[exclusion_mask] + # significance_map_off = significance_map * exclusion_mask + # significance_map_off = significance_map[exclusion_mask] return ( counts, @@ -266,16 +300,16 @@ def rbm_analysis(config): def rbm_plots( - config, - spectral_points, - excess_map, - significance_map, - c_sig, - c_time, - exclusion_mask, - save=True, - plot=True, -): + config: dict, + spectral_points: Table, + excess_map: WcsNDMap, + significance_map: WcsNDMap, + c_sig: np.ndarray, + c_time: np.ndarray, + exclusion_mask: WcsNDMap, + save: Optional[bool] = True, + plot: Optional[bool] = True, +) -> None: """ Makes + optionally saves significance/excess maps, significance distribution, and cumulative significance @@ -308,33 +342,37 @@ def rbm_plots( config["plot_names"] + "sig_excess.png", format="png", bbox_inches="tight" ) plt.show() - + # create a 2D mask for the images - significance_map_off = significance_map * exclusion_mask - significance_all = significance_map.data.flatten() - significance_off = significance_map_off.data.flatten()[exclusion_mask.data.flatten()] + # significance_map_off = significance_map * exclusion_mask + significance_all = significance_map.data[ + np.isfinite(significance_map.data) + ].flatten() + significance_off = significance_map.data[ + exclusion_mask & np.isfinite(significance_map.data) + ].flatten() fig, ax = plt.subplots() ax.hist( - significance_all[np.isfinite(significance_all)], + significance_all, density=True, alpha=0.5, color="red", label="all bins", - bins=np.linspace(-5,10,100), + bins=np.linspace(-5, 10, 100), ) ax.hist( - significance_off[np.isfinite(significance_off)], + significance_off, density=True, alpha=0.5, color="blue", label="off bins", - bins=np.linspace(-5,10,100), + bins=np.linspace(-5, 10, 100), ) # Now, fit the off distribution with a Gaussian - mu, std = norm.fit(significance_off[np.isfinite(significance_off)]) + mu, std = norm.fit(significance_off) x = np.linspace(-10, 10, 100) p = norm.pdf(x, mu, std) ax.plot(x, p, lw=2, color="black") @@ -342,7 +380,8 @@ def rbm_plots( ax.set_xlabel("Significance") ax.set_yscale("log") ax.set_ylim(1e-5, 1) - xmin, xmax = np.min(significance_all), np.max(significance_all) + # unused values + # xmin, xmax = np.min(significance_all), np.max(significance_all) ax.set_xlim(-5, 10) print(f"Fit results: mu = {mu:.2f}, std = {std:.2f}") @@ -380,12 +419,20 @@ def rbm_plots( def write_validation_info( - config, spectral_model, flux, flux_err, counts, background, alpha, sigma, exposure -): + config: dict, + spectral_model: SpectralModel, + flux: float, + flux_err: float, + counts: float, + background: float, + alpha: float, + sigma: float, + exposure: float, +) -> None: if not os.path.exists(config["io"]["results_dir"]): os.makedirs(config["io"]["results_dir"]) - + spectab = spectral_model.to_parameters_table() index = spectab["value"][0] index_err = spectab["error"][0] @@ -393,8 +440,8 @@ def write_validation_info( norm_err = spectab["error"][1] output_dict = { - "analysis notebook version": 0.2, - "gammapy-tools version": "1.0.0", + "analysis notebook version": __notebook_version__, + "gammapy-tools version": gpt_version, "source": config["run_selection"]["source_name"], "gammapy version": gammapy.__version__, "exposure (min)": float(exposure.value) / 60,