From d25b8f7b8e8df2beb0d889657423531a18c535ed Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 6 Apr 2026 10:34:32 -0700 Subject: [PATCH 01/43] Implement initial Nautilus sampler --- orbitize/sampler.py | 68 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 5ee50f21..0b68fdb0 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -7,6 +7,8 @@ import dynesty +import nautilus + import emcee import ptemcee import multiprocessing as mp @@ -1447,3 +1449,69 @@ def run_sampler( num_iter = self.dynesty_sampler.results["niter"] return self.dynesty_sampler.results["samples"], num_iter + +class NautilusSampler(Sampler): + def __init__(self, system): + super(NautilusSampler, self).__init__(system) + + # create an empty results object + self.results = orbitize.results.Results( + self.system, + sampler_name=self.__class__.__name__, + post=None, + lnlike=None, + version_number=orbitize.__version__, + ) + self.start = time.time() + + def ptform(self, u): + """ + Prior transform function. + + Args: + u (array of floats): list of samples with values 0 < u < 1. + + Returns: + numpy array of floats: 1D u samples transformed to a chosen Prior + Class distribution. + """ + utform = np.zeros(len(u)) + for i in range(len(u)): + try: + utform[i] = self.system.sys_priors[i].transform_samples(u[i]) + except AttributeError: # prior is a fixed number + utform[i] = self.system.sys_priors[i] + return utform + + def run_sampler( + self, + n_live: int = 2000, + n_update: None|int = None, + verbose: bool = False, + sampler_kwargs: dict = {}, + run_kwargs: dict = {} + ): + + sampler = nautilus.Sampler( + prior=self.ptform, + likelihood=self._logl, + n_dim=len(self.system.sys_priors), + n_live=n_live, + n_update=n_update, + **sampler_kwargs + ) + + success = sampler.run( + verbose=verbose, + **run_kwargs + ) + + # TODO: use weighted posterior for higher accuracy + points, low_w, log_l = sampler.posterior(equal_weight = True) + + self.results.add_samples( + points, + log_l + ) + + return points From eb63949ea68a7a0280cbb42fdf4756eb7119a107 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 6 Apr 2026 10:38:03 -0700 Subject: [PATCH 02/43] Add nautilus to requirements --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 81bb6acd..8e4e0e38 100644 --- a/requirements.txt +++ b/requirements.txt @@ -14,3 +14,4 @@ pyerfa astroquery rebound dynesty +nautilus-sampler From 851221345f1078ff852a18fc1204f1ddb8a3d628 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Thu, 9 Apr 2026 16:23:35 -0700 Subject: [PATCH 03/43] Add multithreading for nautilus --- orbitize/sampler.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 0b68fdb0..781a2619 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1488,6 +1488,7 @@ def run_sampler( n_live: int = 2000, n_update: None|int = None, verbose: bool = False, + num_threads: int = 1, sampler_kwargs: dict = {}, run_kwargs: dict = {} ): @@ -1498,6 +1499,7 @@ def run_sampler( n_dim=len(self.system.sys_priors), n_live=n_live, n_update=n_update, + pool=num_threads, **sampler_kwargs ) From 66eca225a7956bcbee38d1e564ab97691fe964e7 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Thu, 9 Apr 2026 17:14:58 -0700 Subject: [PATCH 04/43] Add option to save nautilus progress --- orbitize/sampler.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 781a2619..122e5af3 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1489,6 +1489,7 @@ def run_sampler( n_update: None|int = None, verbose: bool = False, num_threads: int = 1, + savefile: str = None, sampler_kwargs: dict = {}, run_kwargs: dict = {} ): @@ -1500,6 +1501,7 @@ def run_sampler( n_live=n_live, n_update=n_update, pool=num_threads, + filepath=savefile, **sampler_kwargs ) From 34aa0af4dedbc2983af846a52f04d505a1874948 Mon Sep 17 00:00:00 2001 From: Quinton Blackston Date: Sun, 12 Apr 2026 20:10:41 -0700 Subject: [PATCH 05/43] This is a pytest implemented using test_nested_sampler but implemented with the Nautilus_Sampler --- tests/test_nautilus.py | 48 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 tests/test_nautilus.py diff --git a/tests/test_nautilus.py b/tests/test_nautilus.py new file mode 100644 index 00000000..71afef81 --- /dev/null +++ b/tests/test_nautilus.py @@ -0,0 +1,48 @@ +import pytest +from orbitize import sampler, system +import numpy as np +from orbitize.system import generate_synthetic_data + +# This is top part of the test is a direct translation of test_nested_sampler.py + +def test_nautilus_general(): + # generate synthetic data + mtot = 1.2 + plx = 60.0 + orbit_frac = 95 + data_table, sma = generate_synthetic_data( + orbit_frac, + mtot, + plx, + num_obs=30 + ) + + #assume eccentricity + + ecc = 0.5 + +#initlialize the orbit + + mySys = system.System(1, data_table, mtot, plx) + lab = mySys.param_idx + + #set all paremeters except eccentricity + + mySys.sys_priors[lab["inc1"]] = np.pi / 4 + mySys.sys_priors[lab["sma1"]] = sma + mySys.sys_priors[lab["aop1"]] = np.pi / 4 + mySys.sys_priors[lab["pan1"]] = np.pi / 4 + mySys.sys_priors[lab["tau1"]] = 0.8 + mySys.sys_priors[lab["plx"]] = plx + mySys.sys_priors[lab["mtot"]] = mtot + + my_sampler = sampler.NautilusSampler(mySys) + _ = my_sampler.run_sampler(n_live=1000, n_update=False, verbose=True) + print("Finished 1st Run!") + + nautilus_eccentricities = my_sampler.results.post[:, lab["ecc1"]] + assert np.median(nautilus_eccentricities) == pytest.approx(ecc, abs=0.1) + +if __name__ == "__main__": + test_nautilus_general() + From 91cd1790257fcd40f72b73c02e69f5e136006b0c Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 13 Apr 2026 10:08:20 -0700 Subject: [PATCH 06/43] Vectorize nautilus likelihood and prior transform --- orbitize/sampler.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 122e5af3..a45f4852 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1475,14 +1475,18 @@ def ptform(self, u): numpy array of floats: 1D u samples transformed to a chosen Prior Class distribution. """ - utform = np.zeros(len(u)) + utform = np.zeros(u.shape) for i in range(len(u)): - try: - utform[i] = self.system.sys_priors[i].transform_samples(u[i]) - except AttributeError: # prior is a fixed number - utform[i] = self.system.sys_priors[i] + for j in range(len(u[0])): + try: + utform[i, j] = self.system.sys_priors[j].transform_samples(u[i, j]) + except AttributeError: # prior is a fixed number + utform[i, j] = self.system.sys_priors[i, j] return utform + def nautilus_logl(self, u: np.ndarray): + return self._logl(u.T).T + def run_sampler( self, n_live: int = 2000, @@ -1496,8 +1500,9 @@ def run_sampler( sampler = nautilus.Sampler( prior=self.ptform, - likelihood=self._logl, + likelihood=self.nautilus_logl, n_dim=len(self.system.sys_priors), + vectorized=True, n_live=n_live, n_update=n_update, pool=num_threads, From 1e66635a4cee3434670964b5aa55265620127081 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 13 Apr 2026 18:58:30 -0700 Subject: [PATCH 07/43] Improve vectorization of ptform --- orbitize/sampler.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index a45f4852..078d047b 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1469,19 +1469,21 @@ def ptform(self, u): Prior transform function. Args: - u (array of floats): list of samples with values 0 < u < 1. + u (np.array of floats): MxR array of uniform + samples with values 0 < u < 1, + where M is the number of orbits, + and R is the number of parameters. Returns: - numpy array of floats: 1D u samples transformed to a chosen Prior - Class distribution. + numpy MxR array of floats: u samples transformed to + a chosen Prior Class distribution. """ utform = np.zeros(u.shape) - for i in range(len(u)): - for j in range(len(u[0])): - try: - utform[i, j] = self.system.sys_priors[j].transform_samples(u[i, j]) - except AttributeError: # prior is a fixed number - utform[i, j] = self.system.sys_priors[i, j] + for i in range(u.shape[1]): + try: + utform[:, i] = self.system.sys_priors[i].transform_samples(u[:, i]) + except AttributeError: # prior is a fixed number + utform[:, i] = self.system.sys_priors[i] return utform def nautilus_logl(self, u: np.ndarray): @@ -1509,6 +1511,8 @@ def run_sampler( filepath=savefile, **sampler_kwargs ) + + self.naut_sampler = sampler success = sampler.run( verbose=verbose, From 9e154b0bfc9dcb1e3bb13f62291a1aa73f591a25 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Wed, 22 Apr 2026 14:40:41 -0700 Subject: [PATCH 08/43] Allow weighted post in results --- orbitize/results.py | 35 +++++++++++++++++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index cecacaff..b605dbb5 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -36,7 +36,7 @@ class Results(object): def __init__( self, system=None, sampler_name=None, post=None, lnlike=None, - version_number=None, curr_pos=None + version_number=None, curr_pos=None, weighted_post = None, weighted_lnlike = None, lnweight = None ): self.system = system @@ -45,6 +45,9 @@ def __init__( self.lnlike = lnlike self.curr_pos = curr_pos self.version_number = version_number + self._weighted_post = weighted_post + self._weighted_lnlike = weighted_lnlike + self.lnweight = lnweight if self.system is not None: self.tau_ref_epoch = self.system.tau_ref_epoch @@ -56,7 +59,25 @@ def __init__( self.param_idx = self.system.param_idx self.standard_param_idx = self.system.basis.standard_basis_idx - def add_samples(self, orbital_params, lnlikes, curr_pos=None): + @property + def weighted_post(self): + if self._weighted_post is not None: + return self._weighted_post + return self.post + + @property + def weighted_lnlike(self): + if self._weighted_lnlike is not None: + return self._weighted_lnlike + return self.lnlike + + @property + def weights(self): + if self.lnweight is None: + return None + return np.exp(self.lnweight) + + def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post = None, weighted_lnlike = None, lnweight = None): """ Add accepted orbits, their likelihoods, and the orbitize version number to the results @@ -86,6 +107,16 @@ def add_samples(self, orbital_params, lnlikes, curr_pos=None): else: self.post = np.vstack((self.post, orbital_params)) self.lnlike = np.append(self.lnlike, lnlikes) + + if weighted_post is not None: + if self._weighted_post is None: + self._weighted_post = weighted_post + self._weighted_lnlike = weighted_lnlike + self.lnweight = lnweight + else: + self._weighted_post = np.vstack((self._weighted_post, weighted_post)) + self._weighted_lnlike = np.append(self._weighted_lnlike, weighted_lnlike) + self.lnweight = np.append(self.lnweight, lnweight) if curr_pos is not None: self.curr_pos = curr_pos From 4fbd6d7d305859aac83d746ed935b04eb8cf981d Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Wed, 22 Apr 2026 14:40:57 -0700 Subject: [PATCH 09/43] Save Nautilus weighted post to results --- orbitize/sampler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 078d047b..d5cceebf 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1519,12 +1519,15 @@ def run_sampler( **run_kwargs ) - # TODO: use weighted posterior for higher accuracy - points, low_w, log_l = sampler.posterior(equal_weight = True) + points, _, log_l = sampler.posterior(equal_weight = True) + weighted_points, log_w, weighted_log_l = sampler.posterior() self.results.add_samples( points, - log_l + log_l, + weighted_post=weighted_points, + weighted_lnlike=weighted_log_l, + lnweight=log_w ) return points From e9ef51f12c377e72575bf7822e43db29053e0a15 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Wed, 22 Apr 2026 14:50:20 -0700 Subject: [PATCH 10/43] Make corner plot with weighted post if available --- orbitize/plot.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/orbitize/plot.py b/orbitize/plot.py index a02cfc1e..f06db7e6 100644 --- a/orbitize/plot.py +++ b/orbitize/plot.py @@ -124,7 +124,7 @@ def plot_corner(results, param_list=None, **corner_kwargs): secondary_mass_indices.append(i) samples = np.copy( - results.post[:, param_indices] + results.weighted_post[:, param_indices] ) # keep only chains for selected parameters samples[:, angle_indices] = np.degrees( samples[:, angle_indices] @@ -159,7 +159,7 @@ def plot_corner(results, param_list=None, **corner_kwargs): corner_kwargs["labels"] = reduced_labels_list - figure = corner.corner(samples, **corner_kwargs) + figure = corner.corner(samples, **corner_kwargs, weights=results.weights) return figure From d5c2d5730e5716a52940eb43b7ec1c55a095790d Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Thu, 23 Apr 2026 11:40:06 -0700 Subject: [PATCH 11/43] Print results with weighted post --- orbitize/results.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index b605dbb5..bbc17876 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -349,9 +349,9 @@ def print_results(self): print( '{}: {:.3f} [{:.3f} - {:.3f}]'.format( l, - np.median(self.post[:,i]), - np.quantile(self.post[:,i], 0.16), - np.quantile(self.post[:,i], 0.84) + np.quantile(self.weighted_post[:,i], 0.5, method="inverted_cdf", weights = self.weights), + np.quantile(self.weighted_post[:,i], 0.16, method="inverted_cdf", weights = self.weights), + np.quantile(self.weighted_post[:,i], 0.84, method="inverted_cdf", weights = self.weights) ) ) print('-------------------\n') From 250e5447e841b44ad59886d646d8337f33917c6a Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Thu, 23 Apr 2026 12:00:19 -0700 Subject: [PATCH 12/43] Add saving and loading weighted results --- orbitize/results.py | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index bbc17876..3a71da07 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -154,6 +154,12 @@ def save_results(self, filename): if self.curr_pos is not None: hf.create_dataset("curr_pos", data=self.curr_pos) + if self._weighted_post is not None and self._weighted_lnlike is not None and self.lnweight is not None: + hf.create_dataset("weighted_post", data=self._weighted_post) + hf.create_dataset("weighted_lnlike", data=self._weighted_lnlike) + hf.create_dataset("lnweight", data=self.lnweight) + + self.system.save(hf) hf.close() # Closes file object, which writes file to disk @@ -185,7 +191,15 @@ def load_results(self, filename, append=False): post = np.array(hf.get('post')) lnlike = np.array(hf.get('lnlike')) - + try: + weighted_post = np.array(hf.get('weighted_post')) + weighted_lnlike = np.array(hf.get('weighted_lnlike')) + lnweight = np.array(hf.get("lnweight")) + except KeyError: + weighted_post = None + weighted_lnlike = None + lnweight = None + try: num_secondary_bodies = int(hf.attrs['num_secondary_bodies']) except KeyError: @@ -325,14 +339,14 @@ def load_results(self, filename, append=False): 'Unable to append file {} to Results object. version_number of object and file do not match'.format(filename)) # Now append post and lnlike - self.add_samples(post, lnlike)#, self.labels) + self.add_samples(post, lnlike, weighted_post=weighted_post, weighted_lnlike=weighted_lnlike, lnweight=lnweight)#, self.labels) else: # Only proceed if object is completely empty - if self.sampler_name is None and self.post is None and self.lnlike is None and self.version_number is None:# and self.tau_ref_epoch is None : + if self.sampler_name is None and self.post is None and self.lnlike is None and self.version_number is None and self._weighted_lnlike is None and self._weighted_post is None and self.lnweight is None:# and self.tau_ref_epoch is None : self.sampler_name = sampler_name self.version_number = version_number - self.add_samples(post, lnlike)#, self.labels) + self.add_samples(post, lnlike, weighted_post=weighted_post, weighted_lnlike=weighted_lnlike, lnweight=lnweight)#, self.labels) else: raise Exception( From 38da696f0c159f780ef74167172c6d9914fc5ccb Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Thu, 23 Apr 2026 12:23:38 -0700 Subject: [PATCH 13/43] Add end-to-end test --- tests/end-to-end-tests/GJ504_naut.py | 79 ++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 tests/end-to-end-tests/GJ504_naut.py diff --git a/tests/end-to-end-tests/GJ504_naut.py b/tests/end-to-end-tests/GJ504_naut.py new file mode 100644 index 00000000..66bde312 --- /dev/null +++ b/tests/end-to-end-tests/GJ504_naut.py @@ -0,0 +1,79 @@ +import os +import matplotlib.pyplot as plt + +import orbitize + +# Based on driver.py + +import numpy as np +from orbitize import read_input, system, sampler, priors +import multiprocessing as mp +import orbitize +import time + +# System parameters +datafile = "GJ504.csv" +num_secondary_bodies = 1 +system_mass = 1.22 # Msol +plx = 56.95 # mas +mass_err = 0.08 # Msol +plx_err = 0.26 # mas + +# Sampler parameters +likelihood_func_name = "chi2_lnlike" +n_threads = mp.cpu_count() +n_live = 3000 +n_update = None +sampler_args = {"n_networks": 10} +run_args = {"f_live": 0.01, "n_eff": 10000} + +I = 1 + +naut_file = f"GJ504_naut_{I}.hdf5" + +results_file = f"GJ504_results_{I}.hdf5" + +tau_ref_epoch = 50000 + + +# Read in data +data_table = read_input.read_file(orbitize.DATADIR + datafile) + +# Initialize System object which stores data & sets priors +my_system = system.System( + num_secondary_bodies, + data_table, + system_mass, + plx, + mass_err=mass_err, + plx_err=plx_err, + tau_ref_epoch=tau_ref_epoch, +) + +my_sampler = sampler.NautilusSampler(my_system) + +print(f"Running sampler with {n_threads=} {n_live=} {n_update=} {sampler_args=} {run_args=}") +# Run the sampler to compute some orbits, yeah! +my_sampler.run_sampler(n_live, + n_update, + verbose=False, + num_threads=n_threads, + savefile = naut_file, + sampler_kwargs=sampler_args, + run_kwargs=run_args) + +end = time.time() +print(f"Processing time: {end} - {my_sampler.start} = {(end-my_sampler.start) / 60} minutes") + + +my_sampler.results.save_results(results_file) + +# import orbitize.results as results +# my_sampler.results = results.Results() +# my_sampler.results.load_results("hr8799e_gravity_chains.hdf5") + +# make corner plot +# fig = my_sampler.results.plot_corner() +# plt.savefig("", dpi=250) + +my_sampler.results.print_results() \ No newline at end of file From bb5d3c1f81111765e1b90c7240650f0d8533f109 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Fri, 24 Apr 2026 09:54:47 -0700 Subject: [PATCH 14/43] Make Lux compatible --- orbitize/sampler.py | 41 ++++++++++++++-------------- tests/end-to-end-tests/GJ504_naut.py | 2 +- 2 files changed, 22 insertions(+), 21 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index d5cceebf..373a68c6 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1492,7 +1492,7 @@ def nautilus_logl(self, u: np.ndarray): def run_sampler( self, n_live: int = 2000, - n_update: None|int = None, + n_update: int = None, verbose: bool = False, num_threads: int = 1, savefile: str = None, @@ -1500,27 +1500,28 @@ def run_sampler( run_kwargs: dict = {} ): - sampler = nautilus.Sampler( - prior=self.ptform, - likelihood=self.nautilus_logl, - n_dim=len(self.system.sys_priors), - vectorized=True, - n_live=n_live, - n_update=n_update, - pool=num_threads, - filepath=savefile, - **sampler_kwargs - ) - - self.naut_sampler = sampler + with Pool(processes=num_threads) as pool: #TODO: 1 thread + sampler = nautilus.Sampler( + prior=self.ptform, + likelihood=self.nautilus_logl, + n_dim=len(self.system.sys_priors), + vectorized=True, + n_live=n_live, + n_update=n_update, + pool=pool, + filepath=savefile, + **sampler_kwargs + ) + + self.naut_sampler = sampler - success = sampler.run( - verbose=verbose, - **run_kwargs - ) + success = sampler.run( + verbose=verbose, + **run_kwargs + ) - points, _, log_l = sampler.posterior(equal_weight = True) - weighted_points, log_w, weighted_log_l = sampler.posterior() + points, _, log_l = sampler.posterior(equal_weight = True) + weighted_points, log_w, weighted_log_l = sampler.posterior() self.results.add_samples( points, diff --git a/tests/end-to-end-tests/GJ504_naut.py b/tests/end-to-end-tests/GJ504_naut.py index 66bde312..5d0b56b0 100644 --- a/tests/end-to-end-tests/GJ504_naut.py +++ b/tests/end-to-end-tests/GJ504_naut.py @@ -52,7 +52,7 @@ my_sampler = sampler.NautilusSampler(my_system) -print(f"Running sampler with {n_threads=} {n_live=} {n_update=} {sampler_args=} {run_args=}") +print(f"Running sampler with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") # Run the sampler to compute some orbits, yeah! my_sampler.run_sampler(n_live, n_update, From 8ed95fff509c857ac813c42dd01cf29c5a9f7c31 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Wed, 29 Apr 2026 14:35:36 -0700 Subject: [PATCH 15/43] Update GJ504 run parameters, fix Lux threads issue --- tests/end-to-end-tests/GJ504_naut.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/end-to-end-tests/GJ504_naut.py b/tests/end-to-end-tests/GJ504_naut.py index 5d0b56b0..8bfd4f76 100644 --- a/tests/end-to-end-tests/GJ504_naut.py +++ b/tests/end-to-end-tests/GJ504_naut.py @@ -1,4 +1,5 @@ import os +os.environ['OPENBLAS_NUM_THREADS'] = '1' import matplotlib.pyplot as plt import orbitize @@ -22,9 +23,9 @@ # Sampler parameters likelihood_func_name = "chi2_lnlike" n_threads = mp.cpu_count() -n_live = 3000 +n_live = 2000 n_update = None -sampler_args = {"n_networks": 10} +sampler_args = {"n_networks": 4} run_args = {"f_live": 0.01, "n_eff": 10000} I = 1 From bc0cf8318443d3ac3994976f5065128fdde7670f Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Wed, 29 Apr 2026 14:36:01 -0700 Subject: [PATCH 16/43] Clean up Nautilus pool fix --- orbitize/sampler.py | 33 ++++++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 373a68c6..ad6dc958 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1500,28 +1500,43 @@ def run_sampler( run_kwargs: dict = {} ): - with Pool(processes=num_threads) as pool: #TODO: 1 thread - sampler = nautilus.Sampler( + if isinstance(num_threads, int) and num_threads > 1: + with Pool(processes=num_threads) as pool: + self.naut_sampler = nautilus.Sampler( + prior=self.ptform, + likelihood=self.nautilus_logl, + n_dim=len(self.system.sys_priors), + vectorized=True, + n_live=n_live, + n_update=n_update, + pool=pool, + filepath=savefile, + **sampler_kwargs + ) + + success = self.naut_sampler.run( + verbose=verbose, + **run_kwargs + ) + else: + self.naut_sampler = nautilus.Sampler( prior=self.ptform, likelihood=self.nautilus_logl, n_dim=len(self.system.sys_priors), vectorized=True, n_live=n_live, n_update=n_update, - pool=pool, + pool=num_threads, filepath=savefile, **sampler_kwargs ) - - self.naut_sampler = sampler - success = sampler.run( + success = self.naut_sampler.run( verbose=verbose, **run_kwargs ) - - points, _, log_l = sampler.posterior(equal_weight = True) - weighted_points, log_w, weighted_log_l = sampler.posterior() + points, _, log_l = self.naut_sampler.posterior(equal_weight = True) + weighted_points, log_w, weighted_log_l = self.naut_sampler.posterior() self.results.add_samples( points, From 4c45a90189f3aa49713ea4bec958630a0f210b2f Mon Sep 17 00:00:00 2001 From: quintoon Date: Wed, 29 Apr 2026 15:40:37 -0700 Subject: [PATCH 17/43] This is a pytest for Nautilus Sampler! --- tests/test_nautilus.py | 50 ++++++++++++++++++++++++++++-------------- visualizations | 1 + 2 files changed, 34 insertions(+), 17 deletions(-) create mode 160000 visualizations diff --git a/tests/test_nautilus.py b/tests/test_nautilus.py index 71afef81..f268f64c 100644 --- a/tests/test_nautilus.py +++ b/tests/test_nautilus.py @@ -1,48 +1,64 @@ import pytest -from orbitize import sampler, system +from orbitize import sampler, system, results import numpy as np from orbitize.system import generate_synthetic_data +import matplotlib.pyplot as plt +""" This is pytest for Nautilus_Sampler, it assumes values for all the priors except -# This is top part of the test is a direct translation of test_nested_sampler.py + eccentricity and trys to calculate the true eccentricity """ -def test_nautilus_general(): +def test_nautilus_general(make_plot=False): # generate synthetic data mtot = 1.2 plx = 60.0 orbit_frac = 95 + ecc = 0.1 + inc = np.pi/4 data_table, sma = generate_synthetic_data( orbit_frac, mtot, plx, - num_obs=30 + num_obs=30, + ecc = ecc, + inc = inc ) - #assume eccentricity - - ecc = 0.5 - -#initlialize the orbit + #initlialize the orbit mySys = system.System(1, data_table, mtot, plx) lab = mySys.param_idx #set all paremeters except eccentricity - mySys.sys_priors[lab["inc1"]] = np.pi / 4 - mySys.sys_priors[lab["sma1"]] = sma + #mySys.sys_priors[lab["inc1"]] = np.pi / 4, + mySys.sys_priors[lab["sma1"]] = sma mySys.sys_priors[lab["aop1"]] = np.pi / 4 mySys.sys_priors[lab["pan1"]] = np.pi / 4 mySys.sys_priors[lab["tau1"]] = 0.8 mySys.sys_priors[lab["plx"]] = plx mySys.sys_priors[lab["mtot"]] = mtot - + my_sampler = sampler.NautilusSampler(mySys) - _ = my_sampler.run_sampler(n_live=1000, n_update=False, verbose=True) + my_sampler.run_sampler(n_live=800, n_update=None, verbose=True) + print("Finished 1st Run!") - + nautilus_eccentricities = my_sampler.results.post[:, lab["ecc1"]] - assert np.median(nautilus_eccentricities) == pytest.approx(ecc, abs=0.1) + assert np.mean(nautilus_eccentricities) == pytest.approx(0.1, abs=0.1) + + nautilus_inclination = my_sampler.results.post[:, lab["inc1"]] + assert np.median(nautilus_inclination) == pytest.approx(inc, abs=0.1) + + if make_plot: + myResults = my_sampler.results + myResults.plot_corner(param_list=["ecc1","inc1"]).savefig('nautilus_test_3.png') + print("Made A Plot") if __name__ == "__main__": - test_nautilus_general() - + test_nautilus_general() + + +# TO DO +# fewer live points +# verbose = false +# Test < 1min diff --git a/visualizations b/visualizations new file mode 160000 index 00000000..14fef5ac --- /dev/null +++ b/visualizations @@ -0,0 +1 @@ +Subproject commit 14fef5ac189a1271a45c5f640a7af6a1905a9a09 From 5a5e55e403162c7e6414b50c80937b2f02949155 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Wed, 29 Apr 2026 16:15:14 -0700 Subject: [PATCH 18/43] Fix Nautilus threading for different python versions --- orbitize/sampler.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index ad6dc958..98784f31 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -23,6 +23,8 @@ import orbitize.results import matplotlib.pyplot as plt +import sys + class Sampler(abc.ABC): """ @@ -1499,8 +1501,7 @@ def run_sampler( sampler_kwargs: dict = {}, run_kwargs: dict = {} ): - - if isinstance(num_threads, int) and num_threads > 1: + if sys.version_info < (3,9,0) and isinstance(num_threads, int) and num_threads > 1: with Pool(processes=num_threads) as pool: self.naut_sampler = nautilus.Sampler( prior=self.ptform, From 469610b94bb911a30d48648fcaae81261962f8d9 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Fri, 1 May 2026 10:15:14 -0700 Subject: [PATCH 19/43] Add OFTI GJ504 fit --- tests/end-to-end-tests/GJ504_OFTI.py | 74 ++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 tests/end-to-end-tests/GJ504_OFTI.py diff --git a/tests/end-to-end-tests/GJ504_OFTI.py b/tests/end-to-end-tests/GJ504_OFTI.py new file mode 100644 index 00000000..5694ad5f --- /dev/null +++ b/tests/end-to-end-tests/GJ504_OFTI.py @@ -0,0 +1,74 @@ +import os +os.environ['OPENBLAS_NUM_THREADS'] = '1' +import matplotlib.pyplot as plt + +import orbitize + +# Based on driver.py + +import numpy as np +from orbitize import read_input, system, sampler, priors +import multiprocessing as mp +import orbitize +import time + +# System parameters +datafile = "GJ504.csv" +num_secondary_bodies = 1 +system_mass = 1.22 # Msol +plx = 56.95 # mas +mass_err = 0.08 # Msol +plx_err = 0.26 # mas + +# Sampler parameters +likelihood_func_name = "chi2_lnlike" +n_threads = mp.cpu_count() +total_orbits = 10000000 +prepared_samples = 10000 + +I = 1 + +results_file = f"GJ504_OFTI_{I}.hdf5" + +tau_ref_epoch = 50000 + + +# Read in data +data_table = read_input.read_file(orbitize.DATADIR + datafile) + +# Initialize System object which stores data & sets priors +my_system = system.System( + num_secondary_bodies, + data_table, + system_mass, + plx, + mass_err=mass_err, + plx_err=plx_err, + tau_ref_epoch=tau_ref_epoch, +) + +my_sampler = sampler.OFTI(my_system, likelihood_func_name) + +my_sampler.results.load_results(results_file) + +start = time.time() + +print(f"Running OFTI sampler with {n_threads} {total_orbits} {prepared_samples}") +# Run the sampler to compute some orbits, yeah! +my_sampler.run_sampler(total_orbits, prepared_samples, n_threads) + +end = time.time() +print(f"Processing time: {end} - {start} = {(end-start) / 60} minutes") + + +my_sampler.results.save_results(results_file) + +# import orbitize.results as results +# my_sampler.results = results.Results() +# my_sampler.results.load_results("hr8799e_gravity_chains.hdf5") + +# make corner plot +# fig = my_sampler.results.plot_corner() +# plt.savefig("", dpi=250) + +my_sampler.results.print_results() \ No newline at end of file From 5476754eadccaeed3c8f412fa9371b7f850a98c4 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Sat, 2 May 2026 16:51:44 -0700 Subject: [PATCH 20/43] Fix loading unweighted results --- orbitize/results.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index 3a71da07..f0a06859 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -9,7 +9,6 @@ import orbitize.plot import orbitize.gaia, orbitize.hipparcos - class Results(object): """ A class to store accepted orbital configurations from the sampler @@ -192,9 +191,9 @@ def load_results(self, filename, append=False): lnlike = np.array(hf.get('lnlike')) try: - weighted_post = np.array(hf.get('weighted_post')) - weighted_lnlike = np.array(hf.get('weighted_lnlike')) - lnweight = np.array(hf.get("lnweight")) + weighted_post = array_not_none(hf.get('weighted_post')) + weighted_lnlike = array_not_none(hf.get('weighted_lnlike')) + lnweight = array_not_none(hf.get("lnweight")) except KeyError: weighted_post = None weighted_lnlike = None @@ -425,3 +424,8 @@ def plot_propermotion(self, cbar_param=cbar_param, # fig=fig ) + +def array_not_none(raw): + if raw is not None: + return np.array(raw) + return raw From ea2e847b2acd31ad0f5a2d3862afb21042c409ac Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Sat, 2 May 2026 16:59:38 -0700 Subject: [PATCH 21/43] Undo changes to print_results for python version compatability --- orbitize/results.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index f0a06859..073e0274 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -362,9 +362,9 @@ def print_results(self): print( '{}: {:.3f} [{:.3f} - {:.3f}]'.format( l, - np.quantile(self.weighted_post[:,i], 0.5, method="inverted_cdf", weights = self.weights), - np.quantile(self.weighted_post[:,i], 0.16, method="inverted_cdf", weights = self.weights), - np.quantile(self.weighted_post[:,i], 0.84, method="inverted_cdf", weights = self.weights) + np.mean(self.post[:,i]), + np.quantile(self.post[:,i], 0.16), + np.quantile(self.post[:,i], 0.84) ) ) print('-------------------\n') From 504be4d2d240748831792c783e5ec533f340c419 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 4 May 2026 19:34:53 -0700 Subject: [PATCH 22/43] Add downsampling for corner plotting --- orbitize/plot.py | 17 +++++++++++++---- orbitize/results.py | 13 +++++++++++-- 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/orbitize/plot.py b/orbitize/plot.py index f06db7e6..ba4fdc35 100644 --- a/orbitize/plot.py +++ b/orbitize/plot.py @@ -28,8 +28,7 @@ cmap(np.linspace(0.0, 0.7, 1000)), ) - -def plot_corner(results, param_list=None, **corner_kwargs): +def plot_corner(results, param_list=None, downsample=None, **corner_kwargs): """ Make a corner plot of posterior on orbit fit from any sampler @@ -55,6 +54,9 @@ def plot_corner(results, param_list=None, **corner_kwargs): sigma: rv jitter mi: mass of individual body i, for i = 0, 1, 2, ... (only if fit_secondary_mass == True) mtot: total mass (only if fit_secondary_mass == False) + + downsample (int): + amount of samples to randomly draw from the posterior using ``results.downsample`` **corner_kwargs: any remaining keyword args are sent to ``corner.corner``. See `here `_. @@ -123,8 +125,15 @@ def plot_corner(results, param_list=None, **corner_kwargs): if label_key.startswith("m") and label_key != "m0" and label_key != "mtot": secondary_mass_indices.append(i) + if downsample: + post, _ = results.downsample(downsample) + weights = None + else: + post = results.weighted_post + weights = results.weights + samples = np.copy( - results.weighted_post[:, param_indices] + post[:, param_indices] ) # keep only chains for selected parameters samples[:, angle_indices] = np.degrees( samples[:, angle_indices] @@ -159,7 +168,7 @@ def plot_corner(results, param_list=None, **corner_kwargs): corner_kwargs["labels"] = reduced_labels_list - figure = corner.corner(samples, **corner_kwargs, weights=results.weights) + figure = corner.corner(samples, **corner_kwargs, weights=weights) return figure diff --git a/orbitize/results.py b/orbitize/results.py index 073e0274..e70caba8 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -75,7 +75,16 @@ def weights(self): if self.lnweight is None: return None return np.exp(self.lnweight) + + def downsample(self, amount, duplicates = True): + """ + Samples from the posterior an amount of times. If the posterior + is weighted, samples proportionally to weight to get an equal-weighted posterior. + """ + indexes = np.random.choice(len(self.weighted_post), amount, duplicates, self.weights) + return self.weighted_post[indexes], self.weighted_lnlike[indexes] + def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post = None, weighted_lnlike = None, lnweight = None): """ Add accepted orbits, their likelihoods, and the orbitize version number @@ -369,11 +378,11 @@ def print_results(self): ) print('-------------------\n') - def plot_corner(self, param_list=None, **corner_kwargs): + def plot_corner(self, param_list=None, downsample=None, **corner_kwargs): """ Wrapper for orbitize.plot.plot_corner """ - return orbitize.plot.plot_corner(self, param_list, **corner_kwargs) + return orbitize.plot.plot_corner(self, param_list, downsample, **corner_kwargs) def plot_orbits(self, object_to_plot=1, start_mjd=51544., num_orbits_to_plot=100, num_epochs_to_plot=100, From 2d4aacfba7ec80f2995b7426b69c466cd486c958 Mon Sep 17 00:00:00 2001 From: Aniruddh Date: Wed, 6 May 2026 15:17:18 -0700 Subject: [PATCH 23/43] add a basic nautilus tutorial with orbit generation and plotting --- docs/tutorials/Nautilus_tutorial.ipynb | 588 +++++++++++++++++++++++++ 1 file changed, 588 insertions(+) create mode 100644 docs/tutorials/Nautilus_tutorial.ipynb diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb new file mode 100644 index 00000000..3363b4aa --- /dev/null +++ b/docs/tutorials/Nautilus_tutorial.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Nautilus Introduction #\n", + "\n", + "by some fellas\n", + "\n", + "This is a tutorial for using the Nautilus sampler in `orbitize`! ([Paper here](https://google.com))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import orbitize\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Orbit Generating\n", + "\n", + "Before we get on with orbit generation, lets get some data ready. Already have a file? Lets convert it into a format the sampler can understand." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from orbitize.read_input import read_file\n", + "data_table = read_file('{}/GJ504.csv'.format(orbitize.DATADIR)) # path to data file, now we can input this data into the sampler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not done yet, you have to put everyting together." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from orbitize import system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now put all the data and parameters together:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mySys = system.System(\n", + " 1, # number of bodies in your system (int)\n", + " data_table, # the data you got previously (table)\n", + " 1.22, # mass of the system (float)\n", + " 56.95, # paralax (float)\n", + " 0, # mass err, default is 0 (int)\n", + " 0, # plx err, default is 0 (int) \n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is cool and all but if we run the sampler on this data, its going to take time. Im a tutorial we dont have time for that, instead lets generate some synthetic data with the `generate_synthetic_data()` function\n", + "\n", + "Cool thing about this function is that it calculates the semi major axis for you" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from orbitize.system import generate_synthetic_data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "data_table, sma = generate_synthetic_data(\n", + " 95, # orbital fraction, how much of the orbit is covered (0-100%)\n", + " 1.2, # mass of the system\n", + " 60, # paralax\n", + " 0.5, # eccentricity, default is 0.5 (float)\n", + " np.pi/4, # inclination, default is π/4 (float)\n", + " unc=2, # uncertainty, default is 2 (int)\n", + " num_obs=30, # number of observations to be made, default is 4 (int)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "mySys = system.System(1, data_table, 1.2, 60)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the sampler" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from orbitize import sampler" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + " mysampler = sampler.NautilusSampler(mySys)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nice, now its time to run the sampler" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting the nautilus sampler...\n", + "Please report issues at github.com/johannesulf/nautilus.\n", + "Status | Bounds | Ellipses | Networks | Calls | f_live | N_eff | log Z \n", + "Bounding | 17 | 2 | 8 | 100700 | 1.0000 | 1 | -418.51 " + ] + } + ], + "source": [ + "sampler_arg = {\"n_networks\": 4} # number of active networks you want, default is 4 \n", + "run_arg = {\"f_live\": 0.01, \"n_eff\": 10000} # f_live is the fraction of the evidence in the live set and n_eff is the total effective sample size\n", + "samples = mysampler.run_sampler(\n", + " n_live=2000, # the number of live points you have, default is 2000 (int)\n", + " num_threads=4, # the number of threads you want to utilize, default is 1 (int)\n", + " verbose=True, # choose wether or not to see live updates of the sampler, default is false (bool)\n", + " savefile = None, # put the name for a file that you want to create / already exists here to save nautilus progress, default is none (str)\n", + " sampler_kwargs = sampler_arg,\n", + " run_kwargs = run_arg\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting ##\n", + "\n", + "Now that we can generate possible orbits for our system, we want to plot the data to interpret our results. Here we will go through a brief overview on ways to visualize your data within orbitize. For a more detailed guide on data visualization capabilities within orbitize, see the [Orbitize plotting tutorial](https://orbitize.readthedocs.io/en/latest/tutorials/Plotting_tutorial.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Histogram ###\n", + "\n", + "One way to visualize our results is through histograms of our computed orbital parameters.\n", + "### One thing to keep note of: ###\n", + "Weighted posteriors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can effectively view outputs from by creating a histogram of a given orbit element to see its distribution of possible values. Our system.param_idx dictionary is useful here. We can use it to determine the index of a given orbit that corresponds to the orbital element we are interested in:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'sma1': np.int64(0),\n", + " 'ecc1': np.int64(1),\n", + " 'inc1': np.int64(2),\n", + " 'aop1': np.int64(3),\n", + " 'pan1': np.int64(4),\n", + " 'tau1': np.int64(5),\n", + " 'plx': np.int64(6),\n", + " 'mtot': np.int64(7)}" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mysampler.system.param_idx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to plot the distribution of orbital semi-major axes (a) in our generated orbits, we would use the index dictionary `mysampler.system.param_idx` to index the semi-major axis element from each orbit:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sma = [x[mysampler.system.param_idx['sma1']] for x in samples] \n", + "\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.hist(sma, bins=30)\n", + "plt.xlabel('orbital semi-major axis [AU]')\n", + "plt.ylabel('occurrence')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can use this method to create histograms of any orbital element you are interested in:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAEpCAYAAACZXBMsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAV79JREFUeJzt3XlclOX6P/DPsMsyg5AwkoBrKoqiaDhumZGkZHbkezKOuXQok8CNkxaluZWQ5VahmeFSapSlVu6IWwluKKVoJKihxVJ6BNHY798f/XiOI8w4MwwMw3zer9e8dJ7lfq57mOea53pWmRBCgIiIiIiIiHRmZeoAiIiIiIiIzA0LKSIiIiIiIj2xkCIiIiIiItITCykiIiIiIiI9sZAiIiIiIiLSEwspIiIiIiIiPbGQIiIiIiIi0hMLKSIiIiIiIj2xkCIiIiIiItITCykiIiIiIiI9mbSQmjdvHmQymdqrS5cu0vjS0lJERUXB3d0dzs7OCAsLQ0FBgVobubm5CA0NhaOjIzw8PDBz5kxUVlY2dleIiIiIiMiC2Jg6gG7dumH//v3Sexub/4U0Y8YM7Ny5E1u2bIFCoUB0dDRGjx6No0ePAgCqqqoQGhoKpVKJ1NRU5OXlYfz48bC1tcWiRYt0jqG6uhq///47XFxcIJPJjNc5ItKbEAK3bt2Cl5cXrKzM46A5cwhR02GOOQRgHiFqSnTOI8KE5s6dK3r27FnnuJs3bwpbW1uxZcsWadiFCxcEAJGWliaEEGLXrl3CyspK5OfnS9OsWrVKyOVyUVZWpnMcV69eFQD44ouvJvS6evWqYYnFBJhD+OKr6b3MKYcIwTzCF19N8XW/PGLyI1IXL16El5cXHBwcoFKpEBcXBx8fH6Snp6OiogLBwcHStF26dIGPjw/S0tLQr18/pKWlwd/fH56entI0ISEhiIyMRGZmJnr16lXnMsvKylBWVia9F0IAAK5evQq5XN5APSUiXRQXF8Pb2xsuLi6mDkVnNbEyhxCZnjnmEIB5hKgp0TWPmLSQCgoKwvr169G5c2fk5eVh/vz5GDRoEM6dO4f8/HzY2dnB1dVVbR5PT0/k5+cDAPLz89WKqJrxNeM0iYuLw/z582sNl8vlTF5ETYQ5ndpSEytzCFHTYU45BGAeIWqK7pdHTFpIDR8+XPp/jx49EBQUBF9fX3z55Zdo0aJFgy03NjYWMTEx0vuaqpOIiIiIiEgXTeoqTFdXVzz00EPIzs6GUqlEeXk5bt68qTZNQUEBlEolAECpVNa6i1/N+5pp6mJvby/t8eGeHyIiIiIi0leTKqRKSkqQk5OD1q1bIzAwELa2tkhJSZHGZ2VlITc3FyqVCgCgUqlw9uxZFBYWStMkJydDLpfDz8+v0eMnIiIiIiLLYNJT+1555RWMHDkSvr6++P333zF37lxYW1sjPDwcCoUCERERiImJgZubG+RyOaZMmQKVSoV+/foBAIYNGwY/Pz+MGzcOixcvRn5+PmbPno2oqCjY29ubsmtERERERNSMmbSQunbtGsLDw3H9+nW0atUKAwcOxLFjx9CqVSsAwLJly2BlZYWwsDCUlZUhJCQEK1eulOa3trbGjh07EBkZCZVKBScnJ0yYMAELFiwwVZeIiIiIiMgCyETNvb8tWHFxMRQKBYqKini9FJGJmeP6aI4xEzVX5ro+mmvcRM2Rrutjk7pGioiIiIiIyBywkCIiszVv3jzIZDK1V5cuXaTxpaWliIqKgru7O5ydnREWFlbrTp+5ubkIDQ2Fo6MjPDw8MHPmTFRWVjZ2V4iIiMjMmPQaKaLG1Pa1nXUOvxIf2siRkDF169YN+/fvl97b2Pwvrc2YMQM7d+7Eli1boFAoEB0djdGjR+Po0aMAgKqqKoSGhkKpVCI1NRV5eXkYP348bG1tsWjRokbvC5mepjwBMFcQ0f8wVxDAQoqIzJyNjU2dz40rKipCYmIiNm/ejKFDhwIA1q1bh65du+LYsWPo168f9u3bh/Pnz2P//v3w9PREQEAAFi5ciFdffRXz5s2DnZ1dY3eHiIiIzARP7SMis3bx4kV4eXmhffv2GDt2LHJzcwEA6enpqKioQHBwsDRtly5d4OPjg7S0NABAWloa/P394enpKU0TEhKC4uJiZGZmalxmWVkZiouL1V5ERERkWVhIEZHZCgoKwvr167Fnzx6sWrUKly9fxqBBg3Dr1i3k5+fDzs4Orq6uavN4enoiPz8fAJCfn69WRNWMrxmnSVxcHBQKhfTy9vY2bseIiIioyeOpfURktoYPHy79v0ePHggKCoKvry++/PJLtGjRosGWGxsbi5iYGOl9cXExiykiIiILwyNSRNRsuLq64qGHHkJ2djaUSiXKy8tx8+ZNtWkKCgqka6qUSmWtu/jVvK/ruqsa9vb2kMvlai8iIiKyLCykiKjZKCkpQU5ODlq3bo3AwEDY2toiJSVFGp+VlYXc3FyoVCoAgEqlwtmzZ1FYWChNk5ycDLlcDj8/v0aPn4iIiMwHT+0jIrP1yiuvYOTIkfD19cXvv/+OuXPnwtraGuHh4VAoFIiIiEBMTAzc3Nwgl8sxZcoUqFQq9OvXDwAwbNgw+Pn5Ydy4cVi8eDHy8/Mxe/ZsREVFwd7e3sS9IyIiU9J2i3MigIUUEZmxa9euITw8HNevX0erVq0wcOBAHDt2DK1atQIALFu2DFZWVggLC0NZWRlCQkKwcuVKaX5ra2vs2LEDkZGRUKlUcHJywoQJE7BgwQJTdYkaATeOiIjIGFhIEZHZSkpK0jrewcEBCQkJSEhI0DiNr68vdu3aZezQiIiIqJljIUVEREREFolHqKk+eLMJIiIiIiIiPfGIFDUr3LNERERERI2BR6SIiIiIiIj0xEKKiIiIiIhITyykiIiIiIiI9MRCioiIiIiISE8spIiIiIiIiPTEu/YRERERUbPFO/pSQ+ERKSIiIiIiIj2xkCIiIiIiItITT+0jIiLSgbbTg67EhzZiJERE1BTwiBQREREREZGeeESKzA4vGiUiIiIiU+MRKSIiIiIiIj2xkCIiIiIiItITCykiIiIiIiI9sZAiIiIiIiLSE282QRaPtzQmIiIiIn3xiBQREREREZGeWEgRERERERHpiYUUEREREYD4+HjIZDJMnz5dGlZaWoqoqCi4u7vD2dkZYWFhKCgoUJsvNzcXoaGhcHR0hIeHB2bOnInKyspGjp6IGhsLKSIiIrJ4J0+exOrVq9GjRw+14TNmzMB3332HLVu24PDhw/j9998xevRoaXxVVRVCQ0NRXl6O1NRUbNiwAevXr8ebb77Z2F0gokbWZAop7gUiIiIiUygpKcHYsWOxZs0atGzZUhpeVFSExMRELF26FEOHDkVgYCDWrVuH1NRUHDt2DACwb98+nD9/Hhs3bkRAQACGDx+OhQsXIiEhAeXl5RqXWVZWhuLiYrUXEZmXJlFIcS8QERERmUpUVBRCQ0MRHBysNjw9PR0VFRVqw7t06QIfHx+kpaUBANLS0uDv7w9PT09pmpCQEBQXFyMzM1PjMuPi4qBQKKSXt7e3kXtFRA3N5IUU9wIRERGRqSQlJeH06dOIi4urNS4/Px92dnZwdXVVG+7p6Yn8/HxpmruLqJrxNeM0iY2NRVFRkfS6evVqPXtCRI3N5IUU9wIRERGRKVy9ehXTpk3Dpk2b4ODg0KjLtre3h1wuV3sRkXkx6QN5a/YCnTx5sta4ht4LFBMTI70vLi5mMUVE1Ixoe9A2UY309HQUFhaid+/e0rCqqiocOXIEH374Ifbu3Yvy8nLcvHlTbXukoKAASqUSAKBUKnHixAm1dmuu566ZhoiaJ5MdkeJeICIiIjKlxx57DGfPnkVGRob06tOnD8aOHSv939bWFikpKdI8WVlZyM3NhUqlAgCoVCqcPXsWhYWF0jTJycmQy+Xw8/Nr9D4RUeMx2REp7gUiIiIiU3JxcUH37t3Vhjk5OcHd3V0aHhERgZiYGLi5uUEul2PKlClQqVTo168fAGDYsGHw8/PDuHHjsHjxYuTn52P27NmIioqCvb19o/eJiBqPyY5IcS8QERERNXXLli3Dk08+ibCwMAwePBhKpRJbt26VxltbW2PHjh2wtraGSqXCc889h/Hjx2PBggUmjJqIGoPJjkhxLxARERE1NYcOHVJ77+DggISEBCQkJGicx9fXF7t27WrgyIioqTHpzSbuZ9myZbCyskJYWBjKysoQEhKClStXSuNr9gJFRkZCpVLByckJEyZM4F4gIiIiIiJqUCa//fndDh06hOXLl0vva/YC3bhxA7dv38bWrVtrXftUsxfozp07+OOPP/Dee+/BxqZJ14dE1EDi4+Mhk8kwffp0aVhpaSmioqLg7u4OZ2dnhIWFSddS1sjNzUVoaCgcHR3h4eGBmTNnorKyspGjJyIiInPCioOaJN66mPR18uRJrF69Gj169FAbPmPGDOzcuRNbtmyBQqFAdHQ0Ro8ejaNHjwL4+yY3oaGhUCqVSE1NRV5eHsaPHw9bW1ssWrTIFF0hIiIiM9CkjkgRERmipKQEY8eOxZo1a9CyZUtpeFFRERITE7F06VIMHToUgYGBWLduHVJTU3Hs2DEAwL59+3D+/Hls3LgRAQEBGD58OBYuXIiEhASUl5fXubyysjIUFxervYiIiMiysJAiIrMXFRWF0NBQBAcHqw1PT09HRUWF2vAuXbrAx8cHaWlpAIC0tDT4+/urPdw7JCQExcXFyMzMrHN5cXFxUCgU0osP9CYiIrI8PLWPiMxaUlISTp8+jZMnT9Yal5+fDzs7O7Vn0QGAp6cn8vPzpWnuLqJqxteMq0tsbCxiYmKk98XFxSymiIgIgPbLE67EhzZiJNTQWEgRkdm6evUqpk2bhuTkZDg4ODTacu3t7fmIBSIiIgvHU/uIyGylp6ejsLAQvXv3ho2NDWxsbHD48GG8//77sLGxgaenJ8rLy3Hz5k21+QoKCqQ7gCqVylp38at5f+9dQomIiIhqsJAiIrP12GOP4ezZs8jIyJBeffr0wdixY6X/29raIiUlRZonKysLubm5UKlUAACVSoWzZ8+isLBQmiY5ORlyuRx+fn6N3iciIiIyDzy1j4jMlouLC7p37642zMnJCe7u7tLwiIgIxMTEwM3NDXK5HFOmTIFKpUK/fv0AAMOGDYOfnx/GjRuHxYsXIz8/H7Nnz0ZUVBRP3yMiIiKNWEgRUbO2bNkyWFlZISwsDGVlZQgJCcHKlSul8dbW1tixYwciIyOhUqng5OSECRMmYMGCBSaMmoiIiJo6FlJE1KwcOnRI7b2DgwMSEhKQkJCgcR5fX1/s2rWrgSMjIiKi5oSFFJEWvIUpEemCuYKIyPLwZhNERERERER6YiFFRERERESkJxZSREREREREemIhRUREREREpCcWUkRERERERHpiIUVERERERKQn3v6ciIiIiMyatkcQEDUUFlJERGSWuOFEROZGU97i8+bMEwspMhlz3wjiAziJiIiILBevkSIiIiIiItITCykiIiIiIiI9sZAiIiIiIiLSEwspIiIiIiIiPfFmE0RERA2IN6YhImqe6nVEqry8HFlZWaisrDRWPERkQZhDiKi+mEeIyFQMKqTu3LmDiIgIODo6olu3bsjNzQUATJkyBfHx8UYNkIiaH205ZOnSpSaOjojMgaY8MnPmTBNHRkSWwqBCKjY2Fj/++CMOHToEBwcHaXhwcDC++OILowVHRM2TthyydetWE0ZGROZCUx4ZMmSI6YIiIoti0DVS27dvxxdffIF+/fpBJpNJw7t164acnByjBUdEzZO2HHLlyhXTBUZEZkNTHunSpYsJoyIiS2LQEak//vgDHh4etYbfvn1bLZkREdWFOYSI6ktTHrlz544JoiEiS2RQIdWnTx/s3Pm/uxDVbPh88sknUKlUxomMiJotbTmkb9++pgqLiMyIpjzy6aefmiokIrIwBp3at2jRIgwfPhznz59HZWUlVqxYgfPnzyM1NRWHDx82doxE1MxoyyE7d+5ESkqKqUMkoiZOWx4hImoMBh2RGjhwIDIyMlBZWQl/f3/s27cPHh4eSEtLQ2BgoLFjJKJmRlsO6dWrl6nDIyIzoCmPJCcnmzo0IrIQBj+Qt0OHDlizZo0xYyEiC6IphxQXF5sgGiIyR3XlEX1zyKpVq7Bq1SrpRjfdunXDm2++ieHDhwMASktL8Z///AdJSUkoKytDSEgIVq5cCU9PT6mN3NxcREZG4uDBg3B2dsaECRMQFxcHGxuDN7OIyAwYdERq165d2Lt3b63he/fuxe7du+sdFBE1b9pyCPcmE5EuNOWR/fv369VOmzZtEB8fj/T0dJw6dQpDhw7FqFGjkJmZCQCYMWMGvvvuO2zZsgWHDx/G77//jtGjR0vzV1VVITQ0FOXl5UhNTcWGDRuwfv16vPnmm/XrIBE1eQYVUq+99hqqqqpqDRdC4LXXXtO5nVWrVqFHjx6Qy+WQy+VQqVRqhVhpaSmioqLg7u4OZ2dnhIWFoaCgQK2N3NxchIaGwtHRER4eHpg5cyafbk7UxGnLIfPmzWv8gIjI7GjKI/oaOXIkRowYgU6dOuGhhx7C22+/DWdnZxw7dgxFRUVITEzE0qVLMXToUAQGBmLdunVITU3FsWPHAAD79u3D+fPnsXHjRgQEBGD48OFYuHAhEhISUF5ernG5ZWVlKC4uVnuRdm1f26nxRWQKBhVSFy9ehJ+fX63hXbp0QXZ2ts7tcC8QkWXSlkMuXbpkgoiIyNxoyiOdOnUyuM2qqiokJSXh9u3bUKlUSE9PR0VFBYKDg6VpunTpAh8fH6SlpQEA0tLS4O/vr3aqX0hICIqLi6XtmbrExcVBoVBIL29vb4PjJiLTMKiQUigUdW7sZGdnw8nJSed2uBeIyDJpyyGOjo4miIiIzI2mPGLIzpizZ8/C2dkZ9vb2mDx5MrZt2wY/Pz/k5+fDzs4Orq6uatN7enoiPz8fAJCfn69WRNWMrxmnSWxsLIqKiqTX1atX9Y6biEzLoEJq1KhRmD59OnJycqRh2dnZ+M9//oOnnnrKoEC4F4jIcmjLITUXeBMRaaMpj8yePVvvtjp37oyMjAwcP34ckZGRmDBhAs6fP2/McGuxt7eXLm2oeRGReTGokFq8eDGcnJzQpUsXtGvXDu3atUPXrl3h7u6O9957T6+2uBeIyPJoyyFvvfWWqcMjIjOgKY+0bNlS77bs7OzQsWNHBAYGIi4uDj179sSKFSugVCpRXl6Omzdvqk1fUFAApVIJAFAqlbWu3655XzMNETVPBt2XU6FQIDU1FcnJyfjxxx/RokUL9OjRA4MHD9a7rZq9QEVFRfjqq68wYcKEBn+or729Pezt7Rt0GUSkmbYcwlNtiUgXmvJIQEAAFApFvdqurq5GWVkZAgMDYWtri5SUFISFhQEAsrKykJubC5VKBQBQqVR4++23UVhYCA8PDwBAcnIy5HJ5nddwEVHzYfADDmQyGYYNG4Zhw4bVK4CavUAAEBgYiJMnT2LFihUYM2aMtBfo7qNS9+4FOnHihFp73AtEZB6MlUOIyHLVlUf03RkTGxuL4cOHw8fHB7du3cLmzZtx6NAh7N27FwqFAhEREYiJiYGbmxvkcjmmTJkClUqFfv36AQCGDRsGPz8/jBs3DosXL0Z+fj5mz56NqKgo7rQlauYMLqRSUlKQkpKCwsJCVFdXq41bu3atwQFxLxCRZdCUQyoqKnRugw/SJLJsdeURfXIIABQWFmL8+PHIy8uDQqFAjx49sHfvXjz++OMAgGXLlsHKygphYWFqeaSGtbU1duzYgcjISKhUKjg5OWHChAlYsGCB8TpKRE2SQVsK8+fPx4IFC9CnTx+0bt0aMpnMoIVzLxCRZdKWQ/R5DlzNIxQ6deoEIQQ2bNiAUaNG4cyZM+jWrRtmzJiBnTt3YsuWLVAoFIiOjsbo0aNx9OhRAP97hIJSqURqairy8vIwfvx42NraYtGiRUbvNxEZj6Y8ou+zJBMTE7WOd3BwQEJCAhISEjRO4+vri127dum1XCIyfwYVUh999BHWr1+PcePG1Wvh3AtEZJm05ZDi4mKdr28YOXKk2vu3334bq1atwrFjx9CmTRskJiZi8+bNGDp0KABg3bp16Nq1K44dO4Z+/fpJj1DYv38/PD09ERAQgIULF+LVV1/FvHnzYGdnV//OElGD0JRH9MkhRET1YVAhVV5ejv79+9d74dwLRGSZjJVD7lZVVYUtW7bo/AiFfv36aXyEQmRkJDIzM9GrV686l1VWVoaysjLpPW+QQdT4GiKPEBHpw6Dbn7/wwgvYvHmzsWMhIgthzBxiikco8Fl0RKbHbREiMjWDjkiVlpbi448/xv79+9GjRw/Y2tqqjV+6dKlRgiOi5klbDikvL9erLVM8QiE2NhYxMTHS++LiYhZTRI1MUx7RN4cQERnKoELqp59+QkBAAADg3LlzauMMvfEEEVkObTmkqqpKr7ZM8QgFPouOyPQ05RF9cwgRkaEMKqQOHjxo7DiIyIJoyyH1vVCcj1Agsgya8ghvNkFEjaVeD0rJzs5GTk4OBg8ejBYtWkAIwSNSRKSzunKIPvgIBSKqbx4hIjKUQYXU9evX8cwzz+DgwYOQyWS4ePEi2rdvj4iICLRs2RJLliwxdpxE1IxoyyFOTk46t8NHKBBZLk15JDo62tShEZGFMKiQmjFjBmxtbZGbm4uuXbtKw8eMGYOYmBgWUkSklbYcMn36dJ3b4SMULEPb13aaOgRqgjTlkX/84x/YuHGjCSMjIkthUCG1b98+7N27F23atFEb3qlTJ/z6669GCYyImi9tOeTq1asmioqIzImmPNKhQwcTRURElsag50jdvn0bjo6OtYbfuHGD1xUQ0X1pyyF2dnYmiIiIzI2mPPLf//7XBNEQkSUyqJAaNGgQPv30U+m9TCZDdXU1Fi9ejEcffdRowRFR86QthwwaNMiEkRGRudCUR1asWGHCqIjIkhh0at/ixYvx2GOP4dSpUygvL8esWbOQmZmJGzdu4OjRo8aOkYiaGW05ZM+ePfj2229NHSIRNXGa8sj169dNHRoRWQiDjkh1794dv/zyCwYOHIhRo0bh9u3bGD16NM6cOcNzk4novrTlkPbt25s6PCIyA5ryyPfff2/q0IjIQuh9RKqiogJPPPEEPvroI7zxxhsNERMRNWP3yyHFxcUmiIqIzIm2PMIcQuZI291Jr8SHNmIkpA+9j0jZ2trip59+aohYiMgCMIcQUX0xjxBRU2DQqX3PPffcfZ/fQkSkCXMIEdUX8wgRmZpBN5uorKzE2rVrsX//fgQGBsLJyUlt/NKlS40SHBE1T9pySHl5uQkjIyJzoSmPMIcQUWMxqJA6d+4cevfuDQD45Zdf1MbJZLL6R0VEzZq2HFJVVWWKkIjIzGjKI8whRNRY9C6kqqqqMH/+fPj7+6Nly5YNEROR2eNFo5rdL4cUFxdDoVCYIDIiMhfa8ghzCBE1Fr0LKWtrawwbNgwXLlxgIUVEemMOIfof7nQxDPMIETUFBj9H6tKlS8aOhYgsBHMIEdUX8wgRmZpBhdRbb72FV155BTt27EBeXh6Ki4vVXkRE2jCHEFF9acsjRESNwaCbTYwYMQIA8NRTT6ndXEIIAZlMxgs9iUir++UQIqL70ZZHiIgag0GF1MGDB40dBzVT2s7/J8ulLYfcvn0boaG8NoSItNOUR5hDiKixGFRIPfLII8aOg4gsiLYcwtNyiEgXmvIIcwgRNRaDCqkjR45oHT948GCDgiEiy6Ath9y+fbsRIyEic6UpjzCHEFFjMaiQGjJkSK1hd5+fzGukiEib++UQIqL7YR4hIlMz6K59//3vf9VehYWF2LNnD/r27Yt9+/YZO0Yiama05ZBt27aZOjwiMgOa8kjv3r1NHRoRWQiDjkjV9cTwxx9/HHZ2doiJiUF6enq9AyOi5ktbDpk2bZoJIiIic6Mpj1RUVPBmE0TUKAwqpDTx9PREVlaWMZskIgvi6emJ7OxsU4dBRGbMw8PD1CFQPfBuv2RODCqkfvrpJ7X3Qgjk5eUhPj4eAQEBxoiLiJoxbTnE398fx44dM1FkRGQuNOWRt99+20QREZGlMaiQCggIgEwmq/XQu379+mHt2rVGCYyImi9tOeSDDz5A3759TRQZEZkLTXmE+YOIGotBhdTly5fV3ltZWaFVq1ZwcHAwSlBE1LxpyyF8BgwR6UJTHikvL6/z+ikiImMzqJDy9fU1dhxEZEGYQ4iovjTlkfLy8kaOhIgslUG3P586dSref//9WsM//PBDTJ8+vb4xEVEzpy2HvPbaayaIiIjMjaY88vHHH+vVTlxcHPr27QsXFxd4eHjg6aefrnXjrNLSUkRFRcHd3R3Ozs4ICwtDQUGB2jS5ubkIDQ2Fo6MjPDw8MHPmTFRWVurfMSIyGwYVUl9//TUGDBhQa3j//v3x1Vdf1TsoImretOWQb775xgQREZG50ZRHHn74Yb3aOXz4MKKionDs2DEkJyejoqICw4YNw+3bt6VpZsyYge+++w5btmzB4cOH8fvvv2P06NHS+KqqKoSGhqK8vBypqanYsGED1q9fjzfffNPwDhJRk2dQIXX9+vU6zz+Wy+X4888/dW6He4GILJO2HHL9+nUTRERE5kZTHnFxcdGrnT179mDixIno1q0bevbsifXr1yM3N1d6JmZRURESExOxdOlSDB06FIGBgVi3bh1SU1OlO4zu27cP58+fx8aNGxEQEIDhw4dj4cKFSEhI4KmGRM2YQYVUx44dsWfPnlrDd+/ejfbt2+vcDvcCEVkmbTmkbdu2jR8QEZkdTXlk//799Wq3qKgIAODm5gYASE9PR0VFBYKDg6VpunTpAh8fH6SlpQEA0tLS4O/vD09PT2makJAQFBcXIzMzs87llJWVobi4WO1FRObFoJtNxMTEIDo6Gn/88QeGDh0KAEhJScGSJUuwfPlyndu5NwGuX78eHh4eSE9Px+DBg6W9QJs3b5aWs27dOnTt2hXHjh1Dv379pL1A+/fvh6enJwICArBw4UK8+uqrmDdvHuzs7Gott6ysDGVlZdJ7Ji+ixqUth8TFxWHatGkmjpCImjptecRQ1dXVmD59OgYMGIDu3bsDAPLz82FnZwdXV1e1aT09PZGfny9Nc3cRVTO+Zlxd4uLiMH/+fINjJSLTM+iI1L///W8sWbIEiYmJePTRR/Hoo49i48aNWLVqFV588UWDg2msvUBxcXFQKBTSy9vb2+CYiUh/2nLIxIkTTR0eEZkBTXlk6dKlBrcZFRWFc+fOISkpyYiR1i02NhZFRUXS6+rVqw2+TCIyLoMKKQCIjIzEtWvXUFBQgOLiYly6dAnjx483OJDG3AvE5EVkesbIIbzOksiy1ZVHwsPDDWorOjoaO3bswMGDB9GmTRtpuFKpRHl5OW7evKk2fUFBAZRKpTTNvXml5n3NNPeyt7eHXC5XexGReTH4gbyVlZXo1KkTWrVqJQ2/ePEibG1tDbrGoWYv0A8//GBISHqxt7eHvb19gy+HiOqmLYeUlpbq3E7NdZZ9+/ZFZWUlXn/9dQwbNgznz5+Hk5MTgL+vs9y5cye2bNkChUKB6OhojB49GkePHgXwv+sslUolUlNTkZeXh/Hjx8PW1haLFi0ybsdJo7av7TR1CGRmNOWRnJwcvdoRQmDKlCnYtm0bDh06hHbt2qmNDwwMhK2tLVJSUhAWFgYAyMrKQm5uLlQqFQBApVLh7bffRmFhITw8PAAAycnJkMvl8PPzq083iagJM+iI1MSJE5Gamlpr+PHjxw06Laex9wIRkWlpyyEvv/yyzu3wbltElktTHjl16pRe7URFRWHjxo3YvHkzXFxckJ+fj/z8fPz1118AAIVCgYiICMTExODgwYNIT0/H888/D5VKhX79+gEAhg0bBj8/P4wbNw4//vgj9u7di9mzZyMqKoo7bomaMYMKqTNnztT57IZ+/fohIyND53aEEIiOjsa2bdtw4MABrXuBatS1F+js2bMoLCyUpuFeIKKmTVsOOXv2rMHt8m5bRJZDUx7p06ePXu2sWrUKRUVFGDJkCFq3bi29vvjiC2maZcuW4cknn0RYWBgGDx4MpVKJrVu3SuOtra2xY8cOWFtbQ6VS4bnnnsP48eOxYMECwztIRE2eQaf2yWQy3Lp1q9bwoqIiVFVV6dxOVFQUNm/ejG+++UbaCwT8vfenRYsWanuB3NzcIJfLMWXKFI17gRYvXoz8/HzuBSJq4oyVQ+7Gu20RWRZNeUTfHRtCiPtO4+DggISEBCQkJGicxtfXF7t27dJr2URk3gwqpAYPHoy4uDh8/vnnsLa2BvD3dQZxcXEYOHCgzu2sWrUKADBkyBC14evWrZNOEVy2bBmsrKwQFhaGsrIyhISEYOXKldK0NXuBIiMjoVKp4OTkhAkTJnAvEFETpi2H9OvXz6DnwDTmdZaxsbGIiYmR3hcXF/Pun0SNTFMeqc9d+4iaIm3XkF6JD23ESOheBhVS77zzDgYPHozOnTtj0KBBAIDvv/8excXFOHDggM7tcC8QkWXSlkO+/fZbvQupmussjxw5ovE6y7uPSt17neWJEyfU2tPlbls84k1kWprySM0pvkREDc2ga6T8/Pzw008/YcyYMSgsLMStW7cwfvx4/Pzzz9IpNUREmmjLIfpc28jrLIksl6Y8cvLkSVOHRkQWwqAjUgDg6OgINzc3tG7dGgDg7OwsHVonIrofY+QQXmdJzRlP57k/bosQkSkZdETq1KlT6NChA5YtW4YbN27gxo0bWLZsGTp06IDTp08bO0Yiama05RB97vzJu20RWS5NeSQgIMDUoRGRhZAJXS5UusegQYPQsWNHrFmzBjY2fx/UqqysxAsvvIBLly7hyJEjRg+0IRUXF0OhUKCoqIhPFjcyPmRTP5ayl1lbDrl48SJSU1PNan1kDqk/5gr9WEqu0EZTHpkwYQI2b95sdusj88jfmAv0w1zQMHRdHw06te/UqVNqiQsAbGxsMGvWLL2f30Dmj0mP9MUcQkT1pSmPTJs2DZs3bzZhZHQ/3G6g5sKgU/vkcjlyc3NrDb969SpcXFzqHRQRNW/acoizs7MJIiIic6Mpj1y7ds0E0RCRJTKokBozZgwiIiLwxRdf4OrVq7h69SqSkpLwwgsvIDw83NgxElEzoy2H/N///Z+pwyMiM6Apj0ydOtXUoRGRhTDo1L733nsPMpkM48ePR2VlJQDA1tYWkZGRiI+PN2qARNT8aMshr7/+uvSwbiIiTTTlkYiICKxcudLE0RGRJTDoZhM17ty5g5ycHABAhw4d4OjoaLTAGhMv8KwfnutsPJZ20WhdOcQc10dzjLmpYR7Rj6XlCm3uzSOVlZVmuT5aUh7h+m48zAUNo0FvNlHD0dER/v7+9WmCiCwYcwgR1de9eaS4uNiE0RCRJTHoGikiIiIiIiJLxkKKiIiIiIhITyykiIiIiIiI9FSva6SIiIh0xQvMiYioOeERKSIiIiIiIj2xkCIiIiIiItITCykiIiIiIiI9sZAiIiIiIiLSEwspIiIiIiIiPbGQIiIiIiIi0hMLKSIiIiIiIj2xkCIiIiIiItITCykiIiIiIiI9sZAiIiIiIiLSk42pAyCi/2n72k6N467EhzZiJERERESkDY9IERERERER6YmFFBERERERkZ5YSBEREREREemJ10gRERGZGV5PSURkeiykSCfafrSJiIiI7sVtB2ruWEgREREREZkhHp02LV4jRUREREREpCcWUkRERERERHpiIUVERERERKQnkxZSR44cwciRI+Hl5QWZTIbt27erjRdC4M0330Tr1q3RokULBAcH4+LFi2rT3LhxA2PHjoVcLoerqysiIiJQUlLSiL0gIiIic8VtESIylEkLqdu3b6Nnz55ISEioc/zixYvx/vvv46OPPsLx48fh5OSEkJAQlJaWStOMHTsWmZmZSE5Oxo4dO3DkyBFMmjSpsbpAREREZozbIkRkKJPetW/48OEYPnx4neOEEFi+fDlmz56NUaNGAQA+/fRTeHp6Yvv27Xj22Wdx4cIF7NmzBydPnkSfPn0AAB988AFGjBiB9957D15eXo3WFyIiIjI/ptoWKSsrQ1lZmfS+uLjYyD0joobWZK+Runz5MvLz8xEcHCwNUygUCAoKQlpaGgAgLS0Nrq6uUuICgODgYFhZWeH48eMa2y4rK0NxcbHai4jME0/LIaKG0pDbInFxcVAoFNLL29u74TpCRA2iyRZS+fn5AABPT0+14Z6entK4/Px8eHh4qI23sbGBm5ubNE1dmLyImg+elkNEDaUht0ViY2NRVFQkva5evWrk6ImooVnkA3ljY2MRExMjvS8uLmYxRWSmTHFaDk/JIaL6sre3h729vanDIKJ6aLKFlFKpBAAUFBSgdevW0vCCggIEBARI0xQWFqrNV1lZiRs3bkjz14XJi8gy3O+0nGefffa+p+X84x//qNVuXFwc5s+f3yh9INJX29d21jn8SnxoI0di/hpyW4SIzF+TPbWvXbt2UCqVSElJkYYVFxfj+PHjUKlUAACVSoWbN28iPT1dmubAgQOorq5GUFBQo8dMRE1LQ52Ww1NyiCwDt0WISBuTHpEqKSlBdna29P7y5cvIyMiAm5sbfHx8MH36dLz11lvo1KkT2rVrhzlz5sDLywtPP/00AKBr16544okn8OKLL+Kjjz5CRUUFoqOj8eyzz/KOfUTUYHhUm6j54LYIERnKpIXUqVOn8Oijj0rva65bmjBhAtavX49Zs2bh9u3bmDRpEm7evImBAwdiz549cHBwkObZtGkToqOj8dhjj8HKygphYWF4//33G70vRNT08LScxqfptDKiporbIkRkKJMWUkOGDIEQQuN4mUyGBQsWYMGCBRqncXNzw+bNmxsiPCIyc3efllNTONWclhMZGQlA/bScwMBAADwth8iScFuEiAzVZG82QUSkC56WQ0RERKbAQoqIzBpPyyEiIiJTYCFFRGaNp+UQEZkOr4tsurT9bfg4BONgIUUSJkMiIiIiIt002edIERERERERNVUspIiIiIiIiPTEQoqIiIiIiEhPLKSIiIiIiIj0xJtNEJkJ3n2HiIiIqOlgIUVERGQBuDOGiMi4eGofERERERGRnlhIERERERER6Ymn9hERERERWRCe6mscPCJFRERERESkJxZSREREREREeuKpfURERESkkbbTwIgsGQspomaA5zoTERERNS6e2kdERERERKQnFlJERERERER6YiFFRERERESkJ14jRUREeuGF50RERDwiRUREREREpDcWUkRERERERHriqX0WhqfkEBERERHVH49IERERERER6YlHpIiIqBYevSayLFznifTHQoqIiIiIiABoL6qvxIc2YiRNHwupZoh7lehuTIhEdD/ME0RE+mMhRURERGQBuKOVyLh4swkiIiIiIiI9sZAiIiIiIiLSE0/tI7JgvC6CiO6HeYKIqG4spMwYz3UmovpgDiEiIjIcCykiIiIiIrovHqFWx2ukiIiIiIiI9NRsjkglJCTg3XffRX5+Pnr27IkPPvgADz/8sKnDqjeeekOmoum715z3ODXXPELUUAz9jWqueaQp5BBuN5CpWOLRqmZRSH3xxReIiYnBRx99hKCgICxfvhwhISHIysqCh4eHqcMjIjPQXPMIN6qIGkdzzSFEpJlMCCFMHUR9BQUFoW/fvvjwww8BANXV1fD29saUKVPw2muv3Xf+4uJiKBQKFBUVQS6XN3S4tXBDh8yJtr1KxtgbZar1sT55hDmESD8NuXfaHHMIoF/cXOfJ3JjbESld10ezPyJVXl6O9PR0xMbGSsOsrKwQHByMtLS0OucpKytDWVmZ9L6oqAjA3x/a/XSfu1fjuHPzQ3QNW0112R2D5iMyBZ8ZWwyaT5f16+7pGnMfj755pD45BNCcR7TlEG25h8jcGJpHdPmdNYccAtQvj3C7gcyNoeu8Job+Xuq6ra5rHjH7QurPP/9EVVUVPD091YZ7enri559/rnOeuLg4zJ8/v9Zwb2/vesWiWF6v2YmaNX3Xj1u3bkGhUDRILPfSN48whxCZhj7rSFPOIUDD5REiS2Do76Wxt0XMvpAyRGxsLGJiYqT31dXVuHHjBtzd3SGTyQD8XYl6e3vj6tWrJjlVxxQssc+AZfa7KfdZCIFbt27By8vL1KFopEsOqUtT/tzvh7GbhjnHDpgmfnPIIYDheaSxmPt3r6ng52g8jflZ6ppHzL6QeuCBB2BtbY2CggK14QUFBVAqlXXOY29vD3t7e7Vhrq6udU4rl8st7otviX0GLLPfTbXPjbUXuYa+eUSfHFKXpvq564Kxm4Y5xw40fvxNPYcA9c8jjcXcv3tNBT9H42msz1KXPGL2z5Gys7NDYGAgUlJSpGHV1dVISUmBSqUyYWREZC6YR4ioPphDiCyT2R+RAoCYmBhMmDABffr0wcMPP4zly5fj9u3beP75500dGhGZCeYRIqoP5hAiy9MsCqkxY8bgjz/+wJtvvon8/HwEBARgz549tS761Ie9vT3mzp1b67B7c2aJfQYss9+W2Of7aYg8ci9z/twZu2mYc+yA+cevj8bIIY3Jkv52DYmfo/E0xc+yWTxHioiIiIiIqDGZ/TVSREREREREjY2FFBERERERkZ5YSBEREREREemJhRQREREREZGeLKKQiouLQ9++feHi4gIPDw88/fTTyMrK0jrPmjVrMGjQILRs2RItW7ZEcHAwTpw4oTZNSUkJoqOj0aZNG7Ro0QJ+fn746KOPGrIrOmuoPhcUFGDixInw8vKCo6MjnnjiCVy8eLEhu6IzQ/q8detW9OnTB66urnByckJAQAA+++wztWmEEHjzzTfRunVrtGjRAsHBwc2+z1u3bsWwYcPg7u4OmUyGjIyMBuyF+UhISEDbtm3h4OCAoKCgWuuHJklJSZDJZHj66afVhuuyPpWWliIqKgru7u5wdnZGWFhYrYd+NtXYhwwZAplMpvaaPHlyg8a+fv36Wst0cHBQm0aXdfrGjRsYO3Ys5HI5XF1dERERgZKSEr1jN1X8bdu2rdVOfHy8yWPXJbcY6ztPtenz96xr/ZXJZAgNDZWmacrbQQ1J33y6fPlydO7cGS1atIC3tzdmzJiB0tLSerXZHBj7czRkm6jehAUICQkR69atE+fOnRMZGRlixIgRwsfHR5SUlGic51//+pdISEgQZ86cERcuXBATJ04UCoVCXLt2TZrmxRdfFB06dBAHDx4Uly9fFqtXrxbW1tbim2++aYxuadUQfa6urhb9+vUTgwYNEidOnBA///yzmDRp0n3bbSyG9PngwYNi69at4vz58yI7O1ssX75cWFtbiz179kjTxMfHC4VCIbZv3y5+/PFH8dRTT4l27dqJv/76qzG6pVVD9fnTTz8V8+fPF2vWrBEAxJkzZxqhN01bUlKSsLOzE2vXrhWZmZnixRdfFK6urqKgoEDrfJcvXxYPPvigGDRokBg1apQ0XNf1afLkycLb21ukpKSIU6dOiX79+on+/fubReyPPPKIePHFF0VeXp70KioqatDY161bJ+Ryudoy8/Pz1abRZZ1+4oknRM+ePcWxY8fE999/Lzp27CjCw8P1it2U8fv6+ooFCxaotaNvnm6I2HXJLcb4zlNt+v49r1+/rva3PHfunLC2thbr1q2TpmnK20ENRd/PcdOmTcLe3l5s2rRJXL58Wezdu1e0bt1azJgxw+A2m4OG+BwN2SaqL4sopO5VWFgoAIjDhw/rPE9lZaVwcXERGzZskIZ169ZNLFiwQG263r17izfeeMNosRqLMfqclZUlAIhz585J01RVVYlWrVqJNWvWGD3m+jKkz0II0atXLzF79mwhxN8bjEqlUrz77rvS+Js3bwp7e3vx+eefGzVeYzBGn+92+fJlFlL/38MPPyyioqKk91VVVcLLy0vExcVpnKeyslL0799ffPLJJ2LChAlqxYgu69PNmzeFra2t2LJlizTNhQsXBACRlpbWpGMX4u9Catq0aTrHaYzY161bJxQKhcb2dFmnz58/LwCIkydPStPs3r1byGQy8dtvvzX5+IX4u5BatmyZXrE2dOx305RbjPWdp9oMyQN3W7ZsmXBxcVHbKDWn7SBj0fdzjIqKEkOHDlUbFhMTIwYMGGBwm81BQ3yO9zJ0m0gfFnFq372KiooAAG5ubjrPc+fOHVRUVKjN079/f3z77bf47bffIITAwYMH8csvv2DYsGFGj7m+jNHnsrIyAFA7VcPKygr29vb44YcfjBitcejbZyEEUlJSkJWVhcGDBwMALl++jPz8fAQHB0vTKRQKBAUFIS0tzfhB15Mx+ky1lZeXIz09Xe17YGVlheDgYK3fgwULFsDDwwMRERG1xumyPqWnp6OiokJtuV26dIGPj4/O3z9TxV5j06ZNeOCBB9C9e3fExsbizp07OsVdn9hLSkrg6+sLb29vjBo1CpmZmdI4XdbptLQ0uLq6ok+fPtI0wcHBsLKywvHjx5t8/DXi4+Ph7u6OXr164d1330VlZaVJY9eFMb7zVJuhf8+7JSYm4tlnn4WTk5M0zJy2g4zBkM+xf//+SE9Pl05bu3TpEnbt2oURI0YY3Ka5a4jPsS6GbPvqy6bBWm6iqqurMX36dAwYMADdu3fXeb5XX30VXl5ean/0Dz74AJMmTUKbNm1gY2MDKysrrFmzpsltkBqrzzU/ZrGxsVi9ejWcnJywbNkyXLt2DXl5eQ0VvkH06XNRUREefPBBlJWVwdraGitXrsTjjz8OAMjPzweAWk+m9/T0lMY1FcbqM9X2559/oqqqqs7vwc8//1znPD/88AMSExM1Xl+my/qUn58POzs7uLq61lqurt8/U8UOAP/617/g6+sLLy8v/PTTT3j11VeRlZWFrVu3NljsnTt3xtq1a9GjRw8UFRXhvffeQ//+/ZGZmYk2bdrotE7n5+fDw8NDbbyNjQ3c3Nz0Wu9NFT8ATJ06Fb1794abmxtSU1MRGxuLvLw8LF261GSx68IY33mqzZC/591OnDiBc+fOITExUW24uWwHGYshn+O//vUv/Pnnnxg4cCCEEKisrMTkyZPx+uuvG9ymuWuIz/Fehm776sviCqmoqCicO3dOryMo8fHxSEpKwqFDh9T2wH7wwQc4duwYvv32W/j6+uLIkSOIioqqVXCZmrH6bGtri61btyIiIgJubm6wtrZGcHAwhg8fDiFEQ4VvEH367OLigoyMDJSUlCAlJQUxMTFo3749hgwZ0vCBGpEl9rmpunXrFsaNG4c1a9bggQceqHOapro+GTP2SZMmSf/39/dH69at8dhjjyEnJwcdOnRokPhVKhVUKpX0vn///ujatStWr16NhQsXNsgyjclY8cfExEj/79GjB+zs7PDSSy8hLi4O9vb2Ro25hrl/9qRZYmIi/P398fDDD6sNN5ftIFM6dOgQFi1ahJUrVyIoKAjZ2dmYNm0aFi5ciDlz5pg6PLOh7+doyLavISyqkIqOjsaOHTtw5MgRnfeOvffee4iPj8f+/fvRo0cPafhff/2F119/Hdu2bZPuYNOjRw9kZGTgvffeazIJxJh9BoDAwEBkZGSgqKgI5eXlaNWqFYKCgtROgTE1fftsZWWFjh07AgACAgJw4cIFxMXFYciQIVAqlQD+vkNZ69atpXkKCgoQEBDQIPEbwph9ptoeeOABWFtb17pzWEFBgfQduVtOTg6uXLmCkSNHSsOqq6sB/H1kIysrCx06dLjv+qRUKlFeXo6bN2+q7aHXtNymFHtdgoKCAADZ2dk6FVL6xl4XW1tb9OrVC9nZ2QCg0zqtVCpRWFio1k5lZSVu3Lih83JNGX9dgoKCUFlZiStXrqBz584miV0XxvjOU231+Xvevn0bSUlJWLBggdpwc9kOMiZDPsc5c+Zg3LhxeOGFFwD8vVPp9u3bmDRpEt544w2jrGvmpiE+Ryur/12tZMi2r6Es4hopIQSio6Oxbds2HDhwAO3atdNpvsWLF2PhwoXYs2dPrY2DiooKVFRUqP3hAMDa2lra6DClhujz3RQKBVq1aoWLFy/i1KlTGDVqlLFCN5ihfb5XdXW1dA1Iu3btoFQqkZKSIo0vLi7G8ePH1fa8mkpD9Jlqs7OzQ2BgoNr3oLq6GikpKXV+D7p06YKzZ88iIyNDej311FN49NFHkZGRAW9vb7XpNa1PgYGBsLW1VVtuVlYWcnNzdf7+mSr2utScKnh3AWDM2OtSVVWFs2fPSsvUZZ1WqVS4efMm0tPTpWkOHDiA6upqqRhsyvHXJSMjA1ZWVrVOWWzM2HVhjO881Vafv+eWLVtQVlaG5557Tm14U98OagiGfI537typ8zMC/v4NN8a6Zm4a4nOs+dcY20R6abDbWDQhkZGRQqFQiEOHDqndyvPOnTvSNOPGjROvvfaa9D4+Pl7Y2dmJr776Sm2eW7duSdM88sgjolu3buLgwYPi0qVLYt26dcLBwUGsXLmyUftXl4bq85dffikOHjwocnJyxPbt24Wvr68YPXp0o/ZNE0P6vGjRIrFv3z6Rk5Mjzp8/L9577z1hY2Ojduex+Ph44erqKr755hvx008/iVGjRjWZ2583VJ+vX78uzpw5I3bu3CkAiKSkJHHmzBmRl5fXqP1rSpKSkoS9vb1Yv369OH/+vJg0aZJwdXWVbu987+d8r3vvfCeEbuvT5MmThY+Pjzhw4IA4deqUUKlUQqVSNfnYs7OzxYIFC8SpU6fE5cuXxTfffCPat28vBg8e3KCxz58/X+zdu1fk5OSI9PR08eyzzwoHBweRmZkpTaPLOv3EE0+IXr16iePHj4sffvhBdOrUyeDbnzd2/KmpqWLZsmUiIyND5OTkiI0bN4pWrVqJ8ePHmzx2XXKLMb7zVJuheWDgwIFizJgxdbbZlLeDGoq+n+PcuXOFi4uL+Pzzz8WlS5fEvn37RIcOHcQzzzyjc5vNUUN8jrpsExmbRRRSAOp83f0shEceeURMmDBBeu/r61vnPHPnzpWmycvLExMnThReXl7CwcFBdO7cWSxZskRUV1c3Xuc0aKg+r1ixQrRp00bY2toKHx8fMXv2bFFWVtZ4HdPCkD6/8cYbomPHjsLBwUG0bNlSqFQqkZSUpNZudXW1mDNnjvD09BT29vbiscceE1lZWY3UK+0aqs/r1q2773fBEn3wwQfCx8dH2NnZiYcfflgcO3ZMGnfv53yvuooRXdanv/76S7z88suiZcuWwtHRUfzjH/8wqKBt7Nhzc3PF4MGDhZubm7C3txcdO3YUM2fO1Ps5UvrGPn36dGlaT09PMWLECHH69Gm19nRZp69fvy7Cw8OFs7OzkMvl4vnnn1fbqdSU409PTxdBQUFCoVAIBwcH0bVrV7Fo0SJRWlpq8th1yS3G+s5TbfrmgZ9//lkAEPv27auzvaa8HdSQ9PkcKyoqxLx580SHDh2Eg4OD8Pb2Fi+//LL473//q3ObzZWxP0ddtomMTfb/F0xEREREREQ6sohrpIiIiIiIiIyJhRQREREREZGeWEgRERERERHpiYUUERERERGRnlhIERERERER6YmFFBERERERkZ5YSBEREREREemJhRQREREREZGeWEg1AfPmzUNAQIDWaSZOnIinn3663ssyVjvGdOjQIchkMty8edOilq2Ltm3bYvny5QbNO2/ePMhkMshkMoPbuJ+az08mkzW57xWRNrrk3bvJZDJs377d6HHUrD+urq5Gb/te69evl5Y3ffr0Bl8eNR9Dhgwx6nfm3vWvMbdN6vO72tRcuXIFMpkMGRkZBrfRGHnh3r93Y2yfNBYWUmZixYoVWL9+vfTe2EnNlPr374+8vDwoFAqLWrYuTp48iUmTJhk8f7du3ZCXl1dnG3FxcbC2tsa7775ba5ymjcx7k3bN5/fMM88YHCORseiTF1955RWkpKTo3HZeXh6GDx8OwDgbL3dbt24dfvnlF7Vhhw4dQu/evWFvb4+OHTuq5f+6lJaWYuLEifD394eNjU2dG6VjxoxBXl4eVCqVUeImy7F161YsXLiwwdq/dxvHGNavX1/nDor6/q42R3K5HHl5eQ36N77bK6+8gry8PLRp06ZRlteQWEiZkBAClZWVOk2rUCgaZY+lKdjZ2UGpVEImk5nlssvLy40YkbpWrVrB0dHR4PltbGygVCrrbGPt2rWYNWsW1q5da3D7NZ9fixYtDG6DqDHV5F1nZ2e4u7vrPJ9SqYS9vX2DxOTq6goPDw/p/eXLlxEaGopHH30UGRkZmD59Ol544QXs3btXYxtVVVVo0aIFpk6diuDg4DqnadGiBZRKJezs7IzeB2re3Nzc4OLi0mDtN+Y2Tn1/V5sjmUwGpVKp9W9szG0dZ2dnKJVKWFtbG61NU2EhZURlZWWYOnUqPDw84ODggIEDB+LkyZPS+JrToHbv3o3AwEDY29vjhx9+kMavXr0a3t7ecHR0xDPPPIOioiJp3N2HvSdOnIjDhw9jxYoV0qHRK1euoKqqChEREWjXrh1atGiBzp07Y8WKFXr14ddff8XIkSPRsmVLODk5oVu3bti1a5c0/ty5cxg+fDicnZ3h6emJcePG4c8//5TGDxkyBFOmTMH06dPRsmVLeHp6Ys2aNbh9+zaef/55uLi4oGPHjti9e3etz0Xb6XU1R0jWrl0LHx8fODs74+WXX0ZVVRUWL14MpVIJDw8PvP3222rzLV26FP7+/nBycoK3tzdefvlllJSUaF32119/jW7dusHe3h5t27bFkiVL1Nps27YtFi5ciPHjx0Mul2vcs7Vnzx4MHDgQrq6ucHd3x5NPPomcnBxp/KeffgpnZ2dcvHhRGvbyyy+jS5cuuHPnjrSsmsPeQgjMmzcPPj4+sLe3h5eXF6ZOnarxM9Pm8OHD+Ouvv7BgwQIUFxcjNTXVoHbIclRXVyMuLk7KLz179sRXX32lNk1mZiaefPJJyOVyuLi4YNCgQWrf+bVr10rrVuvWrREdHS2Nu3nzJl544QW0atUKcrkcQ4cOxY8//iiNr8kBn332Gdq2bQuFQoFnn30Wt27dAqA5L2rKu3UdddUW392n9rVr1w4A0KtXL8hkMgwZMgRHjhyBra0t8vPz1dqcPn06Bg0apNdn/dFHH6Fdu3ZYsmQJunbtiujoaPzf//0fli1bpnEeJycnrFq1Ci+++CKUSqVeyyO6n3uP9rZt2xaLFi3Cv//9b7i4uMDHxwcff/yx2jzXrl1DeHg43Nzc4OTkhD59+uD48eN1tn/vqX1DhgzB1KlTMWvWLLi5uUGpVGLevHlq82j7fT906BCef/55FBUVSfmgZv57T+3Lzc3FqFGj4OzsDLlcjmeeeQYFBQXS+Pvlnrpcv34d4eHhePDBB+Ho6Ah/f398/vnntT7T+/Xx559/xsCBA+Hg4AA/Pz/s37//vqcZ3287TVeatnVeffVVPPTQQ3B0dET79u0xZ84cVFRUqM0bHx8PT09PuLi4ICIiAqWlpXov31ywkDKiWbNm4euvv8aGDRtw+vRpdOzYESEhIbhx44badK+99hri4+Nx4cIF9OjRAwCQnZ2NL7/8Et999x327NmDM2fO4OWXX65zOStWrIBKpcKLL76IvLw85OXlwdvbG9XV1WjTpg22bNmC8+fP480338Trr7+OL7/8Uuc+REVFoaysDEeOHMHZs2fxzjvvwNnZGcDfGzpDhw5Fr169cOrUKezZswcFBQW1TuvasGEDHnjgAZw4cQJTpkxBZGQk/vnPf6J///44ffo0hg0bhnHjxknFgq5ycnKwe/du7NmzB59//jkSExMRGhqKa9eu4fDhw3jnnXcwe/ZstURtZWWF999/H5mZmdiwYQMOHDiAWbNmaVxGeno6nnnmGTz77LM4e/Ys5s2bhzlz5tQ65eC9995Dz549cebMGcyZM6fOtm7fvo2YmBicOnUKKSkpsLKywj/+8Q9UV1cDAMaPH48RI0Zg7NixqKysxM6dO/HJJ59g06ZNde4t+/rrr7Fs2TKsXr0aFy9exPbt2+Hv76/XZ1gjMTER4eHhsLW1RXh4OBITEw1qhyxHXFwcPv30U3z00UfIzMzEjBkz8Nxzz+Hw4cMAgN9++w2DBw+Gvb09Dhw4gPT0dPz73/+WjrqvWrUKUVFRmDRpEs6ePYtvv/0WHTt2lNr/5z//icLCQuzevRvp6eno3bs3HnvsMbX8mZOTg+3bt2PHjh3YsWMHDh8+jPj4eACa82KNuvLu3e4X391OnDgBANi/fz/y8vKwdetWDB48GO3bt8dnn30mTVdRUYFNmzbh3//+t16fdVpaWq2jSiEhIUhLS9OrHaKGtGTJEvTp00faXomMjERWVhYAoKSkBI888gh+++03fPvtt/jxxx8xa9Ys6fdPFxs2bICTkxOOHz+OxYsXY8GCBUhOTpbGa/t979+/P5YvXy6dspaXl4dXXnml1jKqq6sxatQo3LhxA4cPH0ZycjIuXbqEMWPGqE2nLffUpbS0FIGBgdi5cyfOnTuHSZMmYdy4cVLu0KWPVVVVePrpp+Ho6Ijjx4/j448/xhtvvKH1M9N1O01XdW3ruLi4YP369Th//jxWrFiBNWvWqO3k+fLLLzFv3jwsWrQIp06dQuvWrbFy5UqDlm8WBBlFSUmJsLW1FZs2bZKGlZeXCy8vL7F48WIhhBAHDx4UAMT27dvV5p07d66wtrYW165dk4bt3r1bWFlZiby8PCGEEBMmTBCjRo2Sxj/yyCNi2rRp940rKipKhIWFSe/vbede/v7+Yt68eXWOW7hwoRg2bJjasKtXrwoAIisrS4pr4MCB0vjKykrh5OQkxo0bJw3Ly8sTAERaWpoQ4n+fy3//+1+Ncc2dO1c4OjqK4uJiaVhISIho27atqKqqkoZ17txZxMXFaWxny5Ytwt3dXXp/77L/9a9/iccff1xtnpkzZwo/Pz/pva+vr3j66ac1LkOTP/74QwAQZ8+elYbduHFDtGnTRkRGRgpPT0/x9ttvq83j6+srli1bJoQQYsmSJeKhhx4S5eXlOi1v7ty5omfPnrWGFxUViRYtWoiMjAwhhBBnzpwRzs7O4tatW/ed9/LlywKAOHPmjNrw+32vyLyVlpYKR0dHkZqaqjY8IiJChIeHCyGEiI2NFe3atdP4/fTy8hJvvPFGneO+//57IZfLRWlpqdrwDh06iNWrVwsh6s4BM2fOFEFBQdL7uvKitrx793dcW3xCCAFAbNu2TQiheT145513RNeuXaX3X3/9tXB2dhYlJSU6tVujU6dOYtGiRWrDdu7cKQCIO3fuaGyrxv3WR11/P4hq3Pud8fX1Fc8995z0vrq6Wnh4eIhVq1YJIYRYvXq1cHFxEdevX6+zvXvXv7q2ce7elhBCiL59+4pXX31VY4z3/r6vW7dOKBSKWtPd/bu6b98+YW1tLXJzc6XxmZmZAoA4ceKEFOv9co8uQkNDxX/+8x+d+7h7925hY2MjbQcKIURycrLWXKTLdtq9tH1OumzrvPvuuyIwMFB6r1KpxMsvv6w2TVBQUJ3bFHf/LcwVj0gZSU5ODioqKjBgwABpmK2tLR5++GFcuHBBbdo+ffrUmt/HxwcPPvig9F6lUqG6ulrau6OrhIQEBAYGolWrVnB2dsbHH3+M3NxcneefOnUq3nrrLQwYMABz587FTz/9JI378ccfcfDgQTg7O0uvLl26AIDa6Tt37+21traGu7u72pETT09PAEBhYWGdMdzd/uTJk6Xhbdu2VTt/19PTE35+frCyslIbdne7+/fvx2OPPYYHH3wQLi4uGDduHK5fv67xaNiFCxfU/oYAMGDAAFy8eBFVVVXSsLr+hve6ePEiwsPD0b59e8jlcrRt2xYA1P4eLVu2RGJiIlatWoUOHTrgtdde09jeP//5T/z1119o3749XnzxRWzbtk3na+zu9vnnn6NDhw7o2bMnACAgIAC+vr744osv9G6LLEN2djbu3LmDxx9/XG39/PTTT6V1PyMjA4MGDYKtrW2t+QsLC/H777/jscceq7P9H3/8ESUlJXB3d1dr//Lly2q55d4c0Lp1a4155F7a1tn7xaeriRMnIjs7G8eOHQPw98XuzzzzDJycnOrVLlFTdPdvfc01NjXrY0ZGBnr16gU3NzejtA/UXt/1/X2vy4ULF+Dt7a129NrPzw+urq5q22765p6qqiosXLgQ/v7+cHNzg7OzM/bu3Vtre0xbH7OysuDt7a12qu7DDz+stT+6bqfpqq68+cUXX2DAgAFQKpVwdnbG7Nmz1fp14cIFBAUFqc3TnG9wY2PqACxRQ/2oJiUl4ZVXXsGSJUugUqng4uKCd999V+M5yXV54YUXEBISgp07d2Lfvn2Ii4vDkiVLMGXKFJSUlGDkyJF45513as3XunVr6f/3bkjJZDK1YTU3dtB0iP/uO2HJ5XKd260ZVtPulStX8OSTTyIyMhJvv/023Nzc8MMPPyAiIgLl5eX1uthUl7/hyJEj4evrizVr1sDLywvV1dXo3r17rQs2jxw5Amtra+Tl5eH27dsaL/b09vZGVlYW9u/fj+TkZLz88st49913cfjw4To3XjVJTExEZmYmbGz+t/pXV1dj7dq1iIiIAPD35373NXo1aq4la6p3OaSGUXPdwc6dO9V2+ACQbsCg7YYj97sZSUlJCVq3bo1Dhw7VGnf3Beja1vf70bbOGutmKR4eHhg5ciTWrVuHdu3aYffu3XX26X6USqXaNRoAUFBQALlczhu7UJOhbX00xvfUVL/v+sZSl3fffRcrVqzA8uXLpeu4pk+fXuv3vz45rS66bqfp6t68mZaWhrFjx2L+/PkICQmBQqFAUlJSrWvJLQkLKSPp0KED7OzscPToUfj6+gL4+/z4kydP6nQ73tzcXPz+++/w8vICABw7dgxWVlbo3LlzndPb2dmpHSEBgKNHj6J///5q11YZsgfC29sbkydPxuTJkxEbG4s1a9ZgypQp6N27N77++mu0bdtWbSPc2DRdl6Cv9PR0VFdXY8mSJdJRq/tdL9a1a1ccPXpUbdjRo0fx0EMP6XV3mevXryMrKwtr1qyRLjS/+8YiNVJTU/HOO+/gu+++w6uvvoro6Ghs2LBBY7stWrTAyJEjMXLkSERFRaFLly44e/YsevfurVNcZ8+exalTp3Do0CG1PYU3btzAkCFD8PPPP6NLly7o3Lkzrl27hoKCAukIIgCcPn0aDg4O8PHx0fWjoGbAz88P9vb2yM3NxSOPPFLnND169MCGDRtQUVFRa+PAxcUFbdu2RUpKCh599NFa8/bu3Rv5+fmwsbGRjtwaoq68qIv7xVfXcgDUuawXXngB4eHhaNOmDTp06FDrCLcuVCqV2k1+ACA5OblZ79Wl5qVHjx745JNPcOPGjXodldJEl993XfJB165dcfXqVVy9elU6KnX+/HncvHkTfn5+Bsd39OhRjBo1Cs899xyAv3dW/vLLL3q12blzZ1y9elXtd/juG5jVpaG301JTU+Hr66t2rdavv/6qNk3Xrl1x/PhxjB8/XhpWc5S+OeKpfUbi5OSEyMhIzJw5E3v27MH58+fx4osv4s6dO9Jefm0cHBwwYcIE/Pjjj/j+++8xdepUPPPMMxrvvtS2bVscP34cV65cwZ9//onq6mp06tQJp06dwt69e/HLL79gzpw5913p7jV9+nTs3bsXly9fxunTp3Hw4EF07doVwN83orhx4wbCw8Nx8uRJ5OTkYO/evXj++ecN2nhpaB07dkRFRQU++OADXLp0CZ999hk++ugjrfP85z//QUpKChYuXIhffvkFGzZswIcffljnRaratGzZEu7u7vj444+RnZ2NAwcOICYmRm2aW7duYdy4cZg6dSqGDx+OTZs24Ysvvqh1J7Qa69evR2JiIs6dO4dLly5h48aNaNGihVS46yIxMREPP/wwBg8ejO7du0uvwYMHo2/fvtJNJ0JCQtC5c2eEh4cjNTUVly5dwldffYXZs2dj2rRpzeKWpaQ7FxcXvPLKK5gxYwY2bNiAnJwcnD59Gh988IFU+EdHR6O4uBjPPvssTp06hYsXL+Kzzz6TTk+eN28elixZgvfffx8XL16U5geA4OBgqFQqPP3009i3bx+uXLmC1NRUvPHGGzh16pTOcdaVF3WlLb57eXh4oEWLFtKF3HcfvQ0JCYFcLsdbb72F559/Xufl323y5Mm4dOkSZs2ahZ9//hkrV67El19+iRkzZmid7/z588jIyMCNGzdQVFSEjIwMoz3rikgf4eHhUCqVePrpp3H06FFcunQJX3/9tdFumKLL73vbtm1RUlKClJQU/Pnnn3We8hccHAx/f3+MHTsWp0+fxokTJzB+/Hg88sgjOp3Cr0mnTp2QnJyM1NRUXLhwAS+99FKto8z38/jjj6NDhw6YMGECfvrpJxw9ehSzZ88GAI2PbGno7bROnTohNzcXSUlJyMnJwfvvv49t27apTTNt2jSsXbtWej7e3LlzkZmZWe9lN1UspIwoPj4eYWFhGDduHHr37o3s7Gzs3bsXLVu2vO+8HTt2xOjRozFixAgMGzYMPXr00HqXk1deeQXW1tbw8/NDq1atkJubi5deegmjR4/GmDFjEBQUhOvXr2u8858mVVVViIqKQteuXfHEE0/goYcekuLw8vLC0aNHUVVVhWHDhsHf3x/Tp0+Hq6ur2nVKTUXPnj2xdOlSvPPOO+jevTs2bdqEuLg4rfP07t0bX375JZKSktC9e3e8+eabWLBgASZOnKjXsq2srJCUlIT09HR0794dM2bMqPXg22nTpsHJyQmLFi0CAPj7+2PRokV46aWX8Ntvv9Vq09XVFWvWrMGAAQPQo0cP7N+/H999953Oz8IpLy/Hxo0bERYWVuf4sLAwfPrpp6ioqICNjQ327dsHHx8fhIeHo3v37pg7dy6mTZvWaA/so6Zl4cKFmDNnDuLi4qT8sHPnTulW4O7u7jhw4IB0t67AwECsWbNGOjo1YcIELF++HCtXrkS3bt3w5JNPSrf+l8lk2LVrFwYPHoznn38eDz30EJ599ln8+uuvakdE76euvKgrbfHdy8bGBu+//z5Wr14NLy8vjBo1ShpnZWWFiRMnoqqqSm2PrD7atWuHnTt3Ijk5GT179sSSJUvwySefICQkRJpm/fr1tTamRowYgV69euG7777DoUOH0KtXL/Tq1cugGIjqw87ODvv27YOHhwdGjBgBf39/xMfHG20nnC6/7/3798fkyZMxZswYtGrVCosXL67VjkwmwzfffIOWLVti8ODBCA4ORvv27et9zfDs2bPRu3dvhISEYMiQIVJRqQ9ra2ts374dJSUl6Nu3L1544QXpSJCDg0Od8zT0dtpTTz2FGTNmIDo6GgEBAUhNTa115+IxY8Zgzpw5mDVrFgIDA/Hrr78iMjKy3stuqmRCCGHqIIhMZe/evRg+fDhKS0ub3UMq582bh+3btzfKHumJEyfi5s2bWp9tQWQpIiIi8Mcff+Dbb7+977QymQzbtm3TeyNr7ty5OHz4sEHXYA0ZMgQBAQFqz9Ihoqbv6NGjGDhwILKzs9GhQwejtLl+/XpMnz5d67M8G0rbtm0xffp0nS6Baaqa3mEEokZSUFCAb775Bp06dWp2RVSNs2fPwtnZucGe4fD999/D2dkZmzZtapD2icxJUVERfvjhB2zevBlTpkzReb6aa6r0sXv37jr3sGuzadMmODs74/vvv9drPiIyjW3btiE5ORlXrlzB/v37MWnSJAwYMMBoRVSNoqIiODs749VXXzVqu5osWrQIzs7Oep010FTxiBRZrMDAQNy6dQsrV66s9fDL5uDGjRvSw0xbtWrVIHfa++uvv6TTEJ2dnTVe00dkCYYMGYITJ07gpZdeUntApTbZ2dkA/j6Np+Y0yYZy69Yt6ToNV1dXPPDAAw26PCKqn08//RRvvfUWcnNz8cADDyA4OBhLlizR+ZR+XZgiLzTG9kljYSFFRERERESkJ57aR0REREREpCcWUkRERERERHpiIUVERERERKQnFlJERERERER6YiFFRERERESkJxZSREREREREemIhRUREREREpCcWUkRERERERHr6f0GtSlNWUAnKAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ecc = [x[mysampler.system.param_idx['ecc1']] for x in samples]\n", + "i = [x[mysampler.system.param_idx['inc1']] for x in samples]\n", + "\n", + "plt.figure(figsize=(10,3))\n", + "plt.subplot(131)\n", + "plt.hist(sma, bins=30)\n", + "plt.xlabel('orbital semi-major axis [AU]')\n", + "plt.ylabel('occurrence')\n", + "\n", + "plt.subplot(132)\n", + "plt.hist(ecc, bins=30)\n", + "plt.xlabel('eccentricity [0,1]')\n", + "plt.ylabel('occurrence')\n", + "\n", + "plt.subplot(133)\n", + "plt.hist(i, bins=30)\n", + "plt.xlabel('inclination angle [rad]')\n", + "plt.ylabel('occurrence')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to our `orbits` array, Orbitize also creates a `Results` class that contains built-in plotting capabilities for two types of plots: corner plots and orbit plots. \n", + "\n", + "### Corner Plot ###\n", + "\n", + "After generating the samples, the `run_sampler` method also creates a `Results` object that can be accessed\n", + "with `s.results`:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "myResults = mysampler.results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now create a corner plot using the function `plot_corner` within the `Results` class. This function requires an input list of the parameters, in string format, that you wish to include in your corner plot. We can even plot all of the orbital parameters at once! As shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Too few points to create valid contours\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "corner_figure = myResults.plot_corner(param_list=['sma1', 'ecc1', 'inc1', 'aop1', 'pan1','tau1'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note about Convergence\n", + "\n", + "Those of you with experience looking at corner plots will note that the result here does not look converged (i.e. we need more samples for our results to be statistically significant). Because this is a tutorial, we didn't want you to have to wait around for a while for the OFTI results to converge.\n", + "\n", + "Its recommended that the Nautilus sampler runs with 2000 live points for convergence. Increasing the number of live points past this does not have much of an effect on accuracy or time taken. \n", + "Furthermore for the number of networks, 4 networks are recommended and increasing the number of networks can increase accuracy but tends to make sampling take longer amounts of time." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Orbit Plot ###" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What about if we want to see how the orbits look in the sky? Don't worry, the `Results` class has a command for that too! It's called `plot_orbits`. We can create a simple orbit plot by running the command as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1059: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " fig.tight_layout()\n", + "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1059: UserWarning: Tight layout not applied. tight_layout cannot make Axes width small enough to accommodate all Axes decorations\n", + " fig.tight_layout()\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "epochs = mySys.data_table['epoch']\n", + "\n", + "orbit_figure = mysampler.results.plot_orbits(\n", + " start_mjd=epochs[0] # Minimum MJD for colorbar (here we choose first data epoch)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving and Loading Results ##\n", + "\n", + "Finally, we can save our generated orbits in a file that can be easily read for future use and analysis. Here we will walk through the steps of saving a set of orbits to a file in hdf5 format. The easiest way to do this is using ``orbitize.Results.save_results()``:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "mysampler.results.save_results('orbits.hdf5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, if you had given the option previously, you can use the file generated by nautilus that has all your orbits already saved.\n", + "\n", + "Now when you are ready to use your orbits data, it is easily accessible through the file created. One way to do this is to load the data into a new `results` object; in this way you can make use of the functions that we learn before, like `plot_corner` and `plot_orbits`. To do this, use the `results` module: " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import orbitize.results\n", + "loaded_results = orbitize.results.Results() # create a blank results object to load the data\n", + "loaded_results.load_results('orbits.hdf5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, you can directly access the saved data using the `h5py` module:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "orbits array dimensions: (2812, 8)\n", + "orbital elements for first orbit: [ 2.31187088 0.50436102 0.81617422 0.80350192 0.80036463 0.87742062\n", + " 60. 1.2 ]\n" + ] + } + ], + "source": [ + "import h5py\n", + "f = h5py.File('orbits.hdf5', 'r')\n", + "orbits = f['post']\n", + "\n", + "print('orbits array dimensions: ', orbits.shape)\n", + "print('orbital elements for first orbit: ', orbits[0])\n", + "\n", + "f.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now we can easily work with the saved orbits that were generated by ``orbitize!`` Find out more about generating orbits in ``orbitize!`` with tutorials [here](https://orbitize.readthedocs.io/en/latest/tutorials.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Nautilus API documentation ##" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nautilus Sampler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "e899b22145868d3cd465733d82c36c2ae3ac0d3591d6a0807ec2e5e577a9cf5c" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 9218abe50e981a0e51abb034eaa80f54a932083c Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 11 May 2026 09:36:20 -0700 Subject: [PATCH 24/43] Add hr8799e nautilus end-to-end test --- tests/end-to-end-tests/GJ504_naut.py | 16 +++--- tests/end-to-end-tests/hr8799e_naut.py | 78 ++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 9 deletions(-) create mode 100644 tests/end-to-end-tests/hr8799e_naut.py diff --git a/tests/end-to-end-tests/GJ504_naut.py b/tests/end-to-end-tests/GJ504_naut.py index 8bfd4f76..ad39075b 100644 --- a/tests/end-to-end-tests/GJ504_naut.py +++ b/tests/end-to-end-tests/GJ504_naut.py @@ -12,6 +12,8 @@ import orbitize import time +savedir = "" + # System parameters datafile = "GJ504.csv" num_secondary_bodies = 1 @@ -30,9 +32,9 @@ I = 1 -naut_file = f"GJ504_naut_{I}.hdf5" +naut_file = f"{savedir}GJ504_naut_{I}.hdf5" -results_file = f"GJ504_results_{I}.hdf5" +results_file = f"{savedir}GJ504_results_{I}.hdf5" tau_ref_epoch = 50000 @@ -53,13 +55,13 @@ my_sampler = sampler.NautilusSampler(my_system) -print(f"Running sampler with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") +print(f"Running {datafile} sampler {I} with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") # Run the sampler to compute some orbits, yeah! my_sampler.run_sampler(n_live, n_update, verbose=False, num_threads=n_threads, - savefile = naut_file, + savefile=naut_file, sampler_kwargs=sampler_args, run_kwargs=run_args) @@ -69,12 +71,8 @@ my_sampler.results.save_results(results_file) -# import orbitize.results as results -# my_sampler.results = results.Results() -# my_sampler.results.load_results("hr8799e_gravity_chains.hdf5") - # make corner plot # fig = my_sampler.results.plot_corner() -# plt.savefig("", dpi=250) +# plt.savefig(f"{savedir}GJ504_naut_corner_{I}.png", dpi=250) my_sampler.results.print_results() \ No newline at end of file diff --git a/tests/end-to-end-tests/hr8799e_naut.py b/tests/end-to-end-tests/hr8799e_naut.py new file mode 100644 index 00000000..9c5d58aa --- /dev/null +++ b/tests/end-to-end-tests/hr8799e_naut.py @@ -0,0 +1,78 @@ +import os +os.environ['OPENBLAS_NUM_THREADS'] = '1' +import matplotlib.pyplot as plt + +import orbitize + +# Based on driver.py + +import numpy as np +from orbitize import read_input, system, sampler, priors +import multiprocessing as mp +import orbitize +import time + +savedir = "" + +# System parameters +datafile = "hr8799e_1epochgravity.csv" +num_secondary_bodies = 1 +system_mass = 1.52 # Msol +plx = 24.2175 # mas +mass_err = 0.15 # Msol +plx_err = 0.0881 # mas + +# Sampler parameters +likelihood_func_name = "chi2_lnlike" +n_threads = mp.cpu_count() +n_live = 2000 +n_update = None +sampler_args = {"n_networks": 4} +run_args = {"f_live": 0.01, "n_eff": 10000} + +I = 1 + +naut_file = f"{savedir}hr8799e_naut_{I}.hdf5" + +results_file = f"{savedir}hr8799e_naut_results_{I}.hdf5" + +tau_ref_epoch = 50000 + + +# Read in data +data_table = read_input.read_file(orbitize.DATADIR + datafile) + +# Initialize System object which stores data & sets priors +my_system = system.System( + num_secondary_bodies, + data_table, + system_mass, + plx, + mass_err=mass_err, + plx_err=plx_err, + tau_ref_epoch=tau_ref_epoch, +) + +my_sampler = sampler.NautilusSampler(my_system) + +print(f"Running {datafile} sampler {I} with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") +# Run the sampler to compute some orbits, yeah! +my_sampler.run_sampler(n_live, + n_update, + verbose=False, + num_threads=n_threads, + savefile=naut_file, + sampler_kwargs=sampler_args, + run_kwargs=run_args) + +end = time.time() +print(f"Processing time: {end} - {my_sampler.start} = {(end-my_sampler.start) / 60} minutes") + + +my_sampler.results.save_results(results_file) + +# make corner plot +# fig = my_sampler.results.plot_corner() +# plt.savefig(f"{savedir}hr8799e_naut_corner_{I}.png", dpi=250) + +my_sampler.results.print_results() \ No newline at end of file From d9601597417df6ded82dbc1e4fe464aa00dec6e5 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Mon, 11 May 2026 09:47:27 -0700 Subject: [PATCH 25/43] Fix datadir --- tests/end-to-end-tests/hr8799e_naut.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/end-to-end-tests/hr8799e_naut.py b/tests/end-to-end-tests/hr8799e_naut.py index 9c5d58aa..3a89fefc 100644 --- a/tests/end-to-end-tests/hr8799e_naut.py +++ b/tests/end-to-end-tests/hr8799e_naut.py @@ -40,7 +40,7 @@ # Read in data -data_table = read_input.read_file(orbitize.DATADIR + datafile) +data_table = read_input.read_file(datafile) # Initialize System object which stores data & sets priors my_system = system.System( From 9e87bd484e1544a127881538b93d77632eb7b343 Mon Sep 17 00:00:00 2001 From: Aniruddh Date: Mon, 11 May 2026 09:59:59 -0700 Subject: [PATCH 26/43] add quick description and demonstration of weighted results in the tutorial --- docs/tutorials/Nautilus_tutorial.ipynb | 233 +++++++++++++++++-------- 1 file changed, 165 insertions(+), 68 deletions(-) diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb index 3363b4aa..5c721b32 100644 --- a/docs/tutorials/Nautilus_tutorial.ipynb +++ b/docs/tutorials/Nautilus_tutorial.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "tags": [] }, @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "tags": [] }, @@ -112,7 +112,7 @@ " 1.2, # mass of the system\n", " 60, # paralax\n", " 0.5, # eccentricity, default is 0.5 (float)\n", - " np.pi/4, # inclination, default is π/4 (float)\n", + " np.pi/3, # inclination, default is π/4 (float)\n", " unc=2, # uncertainty, default is 2 (int)\n", " num_obs=30, # number of observations to be made, default is 4 (int)\n", ")" @@ -120,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "tags": [] }, @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "tags": [] }, @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": { "tags": [] }, @@ -167,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -177,7 +177,7 @@ "Starting the nautilus sampler...\n", "Please report issues at github.com/johannesulf/nautilus.\n", "Status | Bounds | Ellipses | Networks | Calls | f_live | N_eff | log Z \n", - "Bounding | 17 | 2 | 8 | 100700 | 1.0000 | 1 | -418.51 " + "Finished | 57 | 1 | 8 | 221600 | N/A | 17688 | -150.98 \n" ] } ], @@ -209,9 +209,7 @@ "source": [ "### Histogram ###\n", "\n", - "One way to visualize our results is through histograms of our computed orbital parameters.\n", - "### One thing to keep note of: ###\n", - "Weighted posteriors" + "One way to visualize our results is through histograms of our computed orbital parameters." ] }, { @@ -223,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -239,7 +237,7 @@ " 'mtot': np.int64(7)}" ] }, - "execution_count": 23, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -257,12 +255,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -291,12 +289,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -332,23 +330,150 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In addition to our `orbits` array, Orbitize also creates a `Results` class that contains built-in plotting capabilities for two types of plots: corner plots and orbit plots. \n", - "\n", - "### Corner Plot ###\n", - "\n", "After generating the samples, the `run_sampler` method also creates a `Results` object that can be accessed\n", - "with `s.results`:" + "with `mysampler.results`:" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "myResults = mysampler.results" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Weighted results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the difference between post and weighted post?\n", + "Weighted results are results that are well, weighted. They can be used in cornerplots for example, to get better convergence. There are cases where non weighted results are better or are the only type accepted." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7867, 8)" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myResults.post.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(219590, 8)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myResults.weighted_post.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Incase you want more points than that of the unweighted results but fewer points than the weighted, you can use the downsample function." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((150000, 8), (150000,))" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Samples from the posterior an amount of times. If the posterior is weighted, samples proportionally to weight to get an equal-weighted posterior.\n", + "post, lnlike = myResults.downsample(\n", + " 150000, # amount\n", + " True # allow duplicates, default is true\n", + " )\n", + "post.shape, lnlike.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You might be wondering what kind of cases you might want duplicates to be true, it would be when you want more points.\n", + "For example look at this error:" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Cannot take a larger sample than population when 'replace=False'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[51], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m post, lnlike \u001b[38;5;241m=\u001b[39m \u001b[43mmyResults\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdownsample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m250000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# amount\u001b[39;49;00m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# allow duplicates, default is true\u001b[39;49;00m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m post\u001b[38;5;241m.\u001b[39mshape, lnlike\u001b[38;5;241m.\u001b[39mshape\n", + "File \u001b[0;32m~/new/new/codeastro/orbitize/orbitize/results.py:85\u001b[0m, in \u001b[0;36mResults.downsample\u001b[0;34m(self, amount, duplicates)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdownsample\u001b[39m(\u001b[38;5;28mself\u001b[39m, amount, duplicates \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m 80\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 81\u001b[0m \u001b[38;5;124;03m Samples from the posterior an amount of times. If the posterior\u001b[39;00m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;124;03m is weighted, samples proportionally to weight to get an equal-weighted posterior.\u001b[39;00m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 85\u001b[0m indexes \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoice\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweighted_post\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mamount\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mduplicates\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweighted_post[indexes], \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweighted_lnlike[indexes]\n", + "File \u001b[0;32mnumpy/random/mtrand.pyx:1020\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.choice\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Cannot take a larger sample than population when 'replace=False'" + ] + } + ], + "source": [ + "post, lnlike = myResults.downsample(\n", + " 250000, # amount\n", + " False # allow duplicates, default is true\n", + " )\n", + "post.shape, lnlike.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to our `orbits` array, Orbitize also creates a `Results` class that contains built-in plotting capabilities for two types of plots: corner plots and orbit plots. These cornerplots can also take in weighted results, in addition to downsizing them.\n", + "\n", + "### Corner Plot ###" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -358,7 +483,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 52, "metadata": {}, "outputs": [ { @@ -370,7 +495,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -380,7 +505,7 @@ } ], "source": [ - "corner_figure = myResults.plot_corner(param_list=['sma1', 'ecc1', 'inc1', 'aop1', 'pan1','tau1'])" + "corner_figure = myResults.plot_corner(downsample=100000,param_list=['sma1', 'ecc1', 'inc1', 'aop1', 'pan1','tau1'])" ] }, { @@ -389,7 +514,7 @@ "source": [ "### A Note about Convergence\n", "\n", - "Those of you with experience looking at corner plots will note that the result here does not look converged (i.e. we need more samples for our results to be statistically significant). Because this is a tutorial, we didn't want you to have to wait around for a while for the OFTI results to converge.\n", + "Those of you with experience looking at corner plots will note that the result here does not look converged (i.e. we need more samples for our results to be statistically significant). Because this is a tutorial, we didn't want you to have to wait around for a while for the results to converge.\n", "\n", "Its recommended that the Nautilus sampler runs with 2000 live points for convergence. Increasing the number of live points past this does not have much of an effect on accuracy or time taken. \n", "Furthermore for the number of networks, 4 networks are recommended and increasing the number of networks can increase accuracy but tends to make sampling take longer amounts of time." @@ -411,16 +536,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1059: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1068: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " fig.tight_layout()\n", - "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1059: UserWarning: Tight layout not applied. tight_layout cannot make Axes width small enough to accommodate all Axes decorations\n", + "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1068: UserWarning: Tight layout not applied. tight_layout cannot make Axes width small enough to accommodate all Axes decorations\n", " fig.tight_layout()\n" ] }, @@ -435,7 +560,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABL8AAAK8CAYAAAAOOB0DAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xl8U2XaN/DfSZo2XdOVtlAoO1I2BYsgiOigIoyKyMjM6AzgrvUZGBi3UTbRRx+VTa3zdkQEd8aCMCPKCG4gBSwgIBQoe6EUum9p07TJef84TchyTtazpb2+8+lgT5KTO+lpmvPLdV83w7IsC0IIIYQQQgghhBBCOiCN0gMghBBCCCGEEEIIIUQqFH4RQgghhBBCCCGEkA6Lwi9CCCGEEEIIIYQQ0mFR+EUIIYQQQgghhBBCOiwKvwghhBBCCCGEEEJIh0XhFyGEEEIIIYQQQgjpsCj8IoQQQgghhBBCCCEdFoVfhBBCCCGEEEIIIaTDClN6ACRwVqsVFy9eRGxsLBiGUXo4hBBCiGqwLIuGhgZ07doVGg191kdIR0LvgQkhpHMQ8/0chV8h7OLFi+jevbvSwyCEEEJU6/z588jIyFB6GIQQEdF7YEII6VzEeD9H4VcIi42NBcAdCHFxcQqPhhBCCFGP+vp6dO/e3f63khAS+nJzc5Gbm4u2tjYA9B6YEEI6OjHfzzEsy7IijIkooL6+HgaDAXV1dfSHnxBCCHFAfyMJ6bjo95sQQjoHMV/vqQkGIYQQQgghhBBCCOmwKPwihBBCCCGEEEIIIR0WhV+EEEIIIYQQQgghpMOi8IsQQgghhBBCCCGEdFgUfhFCCCGEEEIIIYSQDovCrxCUm5uLrKwsZGdnKz0UQgghhBBCCCGEEFWj8CsE5eTkoKioCIWFhUoPhRBCCCGEEEIIIUTVKPwihBBCCCGEEDGYTMBrr3H/EkIIUY0wpQdACCGEEEIIISGtrIz7+uorYP58oLUVuP12ID2d+yKEEKIoqvwihBBCCCGEkGDk5QEjRnDBFwC88AL3fV6esuMihBACgCq/CCGEEEIIISQ4jz4KZGcDv/0t931YGPDDD0Dv3ooOixBCCIfCL0IIIYQQQgjxV3ExMGUKUF8PWCxgGxrA2C5rawPuvhuIjOS+j44GNm4E+vdXZqwhrrKyEpcuXUJsbCwyMzOVHk6H0tLSgrNnzyI1NRXx8fFKD8cnVqsVZ8+eRWRkJNJVPq24paUF4eHhYBjG+5VVoK2tDcXFxQgLC0O/fv1CZty+oPCLEEIIIYQQQvyVmgoYDMDRowAAt1PEioor/z1qFJCWJtvQOppLly4BABoaGsCybEickJtMJpw8eRIAMHjwYIVHI+zkyZNgWRYXLlxAXFwcNBr1d0Y6ceIEWltb0dTUhJSUFISFqTPWsIW24eHh6N+/P44ePQqLxYJBgwap9hguKSmB1WqF2WxGY2MjYmNjlR6SaNR/ZBNCCCGEEEKI2hgMwI4dwF//Cpbvco0GYBhg4ULuenFxco+Q16lTp3D48GGcOnUKLS0tSg/HK6vV6vT9+fPnFRqJ76xWqz34AqDq55llrxy9Fy5cgMVigcViUXBEnrEsi9bWVvv3x44dU3A0ntlCW7PZjBMnTtif1yNHjig5LI+amprs/33u3DmcPHkShw8ftj+WUKbOiJQQQgghhBBC1Mo25dFoBABYo6KgdThp5DZauYDsX/8C/vhH1Ux5bG5utv974sQJAEBiYiK6du2q5LAEuZ5019fXKzQS72pqanD58mW0tbU5bT9x4oQqq79cg8X6+nr789u3b1/o9XolhuXRuXPnlB5CQNQcgNrYXhscmUwmAFwVW1qIV69S5RchhBBCCCFE9XJzc5GVlYXs7Gylh3JlymNJCVBS4h582dTVcddTyUmjY5WPo+rqaplH4ju+sTlW/qhJaWmpW/ClZpcvXxa8zLFyTQ1qa2tx5MgRNDY2ul2mxmpAb9VzajuGm5qacPr0aaWHISkKvwghhBBCCCGql5OTg6KiIhQWFio9lCtTHhcs4J/y6OiNN+wVYkqrqqoSvMxW4REKjh8/rvQQOgRPx4PaXLp0STC8raurs/fTUgtvgbKajuGqqiqcPn1a8Pm1UXNI7gsKvwghhBBCCCHEXxUVwF13oTU52fP1xo4F8vLkGZMXnvr2qK3SBwBvlY+N2ipnXKcQuiovL5dpJB2Tt4o6i8WCM2fOyDQa73wJFr0dM3LxdSrxxYsXJR6JtCj8IoQQQgghhBB/5eUBI0YgvLLSabNb7URCArBqFZCZCWRlcf3CiE/Onj0reJmaKmcAbiVKT9QWfpnNZq/XUUsllbeKJBs1VS/6Mv21pKREhpF4x9frqyOihveEEEIIIYQQ4gvHRvcWCyx6PbQuJ9yM621qargvABg1SjX9vzqC5uZmREZGKj0MAFxD8FBSUVHh9TpVVVXo0qWLDKPxzJegTk187fvW2NgIlmXBMG6vGrLypwLNarVCownNGioKvwghhBBCgmAymUR/Yx4eHq7KVbYI6fRsje6PHgUAaH25jVbLrfy4YAHwwgtAmDpOwXr06IGwsDDVNrluElpEwMGpU6dUs4qiL9UzJpNJNa/ttbW1Xq9TXl6uivDLqJKeeb7yZ0XS6upqJCUlSTgaz/yt7quurkayt6neKqWOV15CCCGEkBBkMpnQvXsmKivFnc6SlpaGM2fOqOYkiRDSztbo/je/AbZvd7uYBU/ll8UCLF8OzJkjwwB9Fxsbq3jFiScXLlxQegiiO3XqFAYNGqT0MGC1Wn2eSqgGnnq/uTKbzQgPD5dwNN75EizalJWVKRp++fvh3eXLlyn8IoQQQgjpbMxmMyory/H1lkJER8eKsk+jsQG3T8yG2Wym8IsQNfFxyqNjAMYCYLRa4MABWYfKx3UqFl/wVVNTg4SEBLmG5BHfSXlGRkZIhWI6nc6pMb9aAid/KpPUwJcqQJtLly6hR48eEo7GM5Zl/Rqv0vwNv9RyDAeCwi9CCCGEkCBFR8UiRqTwy71bNiFEFXyc8shb+ZWfD/zzn4CCFSllZWVer1NaWqqK8IuvB1FsbCwMBkPIhF8RERFISkpyWyGvra0NYQpPfa2urubdnpSU5LZKoRrG62sPLUD5YK+lpUXR+/dXIM3u1XBMBCI0O5URQgghhBBCiJxsUx4XLADgW05tD8KMRqCgQKqR+aSurk7R+/cHXzVKWlqaaqdp8oV1aWlpMBgMbtvPnz8vx5A84qtMioyMRGJiotv2S5cuyTGkDsOfKZo2jtWBcgsk/PJlsQQ1ovCLEEIIISRILMuK+kUIUamwMGDxYuCJJ9wrvByUP/IIjAMHAgCs11wDPPooEKJ9cpTA1zPJ1scpPj7eabs/K9VJhS9AiI6OhlbrXh+odPN2ob8xBoMBERERbtv96V8lN77nV2mBhF9ClXhyCKRSzbU6MFRQ+EUIIYQQQggh/qisdK/80miA229Hy/XXo8s//4no9umRml9+AfLyuKmPKtS9e3elh+CGr0rNVvWVlpbmtL2mpkaWMXnS0NDgtk2jUeepttDqfjExMTKPxDeeViOMi4uTcSS+8dTvS6gRv5IBo7+rPYYydf5GEkIIIYQQQogamc3Al186V35pNIDVCnz9NcLPnkWr63S3pCRg1SogMxPIyuKa5yvIscLHdWqeGqpPPU0Dc+015EsvM6kp3WfKH0INzpVeIVGI0Hi1Wi1iY/l7bSrVd4tlWY+ViNHR0bzblZz2GOjvuxpeJ/xF4RchhBBCCCGE+KqgAHCt7nA44WUuXoTOtXKpqgooLQVKSrjeYS7VS3LLzMwUvKy0tFTGkfiGbzqemrgGNDqdzv7fUVFRcg/HI6EeT7ZKNb6KNZPLqqZyErrvuLg4wRWRKysrpRySIE/BV1RUlGD4pRRvVV+emtqH0oqWNhR+EUIIIYQEiWXF/SKEqNigQcD8+ai8916c+ugjnFy3Dti3D/jxR2D8eIBhwLo2ZtdqAYYBFi7kmubLPF3LNfBwDGdcqbHHU3p6utJD8ItjX7Jknl5vSlbNeGtwzhcoKRmICvVIi42NFTyOlTqGvU3RVFt1nbeKM09hnRpfJ7yh8IsQQgghhBBCfFFWBpw/DzY8HMn/+hei9+zhtqenA+PGAd9/DyxdCsY13LBYgGXLgEWLuKb5MnNdYVCtqyYKUVv1lDeOvaj4AoRAVtgTi7cqLr4VKpUcr9B96/V6MAzDeywrFS62tbUJXhYdHa268EtoSinAVQAKVdYBgTX2VxqFX4QQQgghhBDii7w8YMQIMPPnAwDS3noLfadP57bbHDgA1mHqGAtwlV8HDsg6VEeeTnJDgVqbxwP8U90cQw6+FQkrKiokHZMn3vphRUZGyjQS3whVJ9mqvtQ0Xk/hV0REhMfVKZVoPO/pdSEiIsJj+KVkn7JAqfdVhBBCCCEkRLAsK+oXIcRdbm4usrKykJ2drdwgHn0U2LrV/q1Vq8WptWu57QDXDD8/H4xjIKLRcJVf+fnc5SrkuoKi2rlOd1NyxTq+MMlbWMe3OqRcvP2NUVt/NaE+WraKL6Gm90rwVFWn0Wg8VlwqUUnlKQiNioryGH6FIgq/CCGEEEIIIaqXk5ODoqIiFBYWynvHxcXcCo2ZmcCoUcB999kv0lgs6DFvHrc9MxPo18+tGb49CDMauWb5KpSYmOj0vdqrOlz7aNW5LjAgI76eVK4hh5or1wDnPl9qGqsvHwYJVX4pseKjLxWWQtVf1dXVYg/HK2/hl6eG96GoYz0aQgghhBAFsO1fYu2LEKIiqancCo1Hj/JerHNcWW7ECOD++4FJk3DSoUl4ZmoqdD/+yDXLVyHXwOPUqVO46qqrFBmLa+DB1+8rLi4OZWVl9u8vX77sFuDJxZcqrtjYWEUDOm8ce5QJVSdZLBaP0/ak4G3KIyBcqVZTUyN7RaMvgVtkZCRvlZdQY38peRpveHg4GIZBWFiYx+mcoUQ9sS4hhBBCCCGEqI3BwK3QuGABt2Kjp5Ucd+8GXn4ZGDMGpqwstPTpg5jdu3GhSxfu9ikpsg/fdUog3+qDrpQ82XUdb1JSktt11DTt0VsDeYC/ibyaeFrVz6bJpaJRDkKVVI5THYWqk5SopPLl90ZNPco8/d7Yfsc60tRHCr8IIYQQQoLFivwFIDs7G1lZWcjNzZXxgRBCeIWFAYsXA0uXAr6s5FhWBn1REZLWrEHa8uWI/Mc/gP37udUiZVZTU+P0fYoCAZw/XMMkX4IZJfkSvKl9tUrX6im+Cq+qqiq5hmMnVJnkeEwIVaoJ9QqTktCx4Eulmty8Hbe2Y6AjNb2n8IsQQgghRIUKCwtRVFSEnJwcpYdCCLEpKHCq/GIBrqG9ay+vvDz0nT4daW+/DYBbFRIjRjivCikT15UF5Z665q/6+nqn79U+Xl/wVScpsbiJ0H26Psd8gYcS0/KEqupcx6eWPmVCgZtj4OW4EqiSvAVXtlDR03iVXLghEOo4SgghhBBCQhit9khIJ2A2A5s2OVV+MQBgtXLbHadoPfooTv/zn/ZvrVot8NNPV1aFlJGvUwLVMjXP9YTa0wp5SgumusiX5uhiE5qW5/oc862gqMTfpubmZt7troGMWgIlIY5hneuUXUdyPse+Vm15Gq+a+9jxoYb3hBBCCCGEEOJNQQHQ2gpkZqLkySdh7tED4SUl6PHWW0BJCbBuHfDKK9yqjgB6OlStaCwWYNo0wHaSHh0NbNwI9O+vwAPhl56eroqT2UCnUqmlIbuvYV15eTm6d+8u9pA88vW5VUtfKqGA0PU5joqK4q0SY1lWFeGp47RXTysoGo1GxMTEyDEkn8NXT+NVog9cMCj8IoQQQggRARVsEdLBDRoErFgBPPww6k+fBgCYsrKAJ54A3n0XuP56p1Uh3abYXLp05b9HjQJkXonOG08nuWqk1Wqdqtpqamp8auYvJr4AwdcG4a7TO+Xga+ChlkoqXyvrhMK65uZm2fqtearacnw+GYYBwzC816+rq5Mt/PI1CPX0uhBqleo07ZEQQgghhBBCvElJAWbPhlutQ1QUMHs20KeP76tC7tgBxMXJNfIOKc7l+XPtbSYHvj5YruOyca1KUyI48GVlSkAdQag/K3gKhXWNjY1iDccrT+N1fT6Fnl85e2gJLSYAOI9PDceCWCj8IoQQQgghhBAfnW6v+uLl76qQMvPnRFaJBuf+SExMdPren7BELHwBglDljq8VYVLiC7/4giM1TBUUqkziG5vQcS1ndZ1QPzXAPfgUqlTztA+xeaoCdK1U6ygo/ApBubm5yMrKQnZ2ttJDIYQQQgghhLjiWRWS5VsVUmZpfky1PHfunIQjCZ4awiS+AEGoQbhc09k84QuU+JrbC5GzWk1oyiNfWCcUfvla6SYGT8GVa4Ck1mPXxjWc6wgrrgIUfoWknJwcFBUVobCwUOmhEEIIIYQQ0qkwLS1IXr0aTEsLevTo4X4FgVUhGb5VIWUmNCWPTzArGcpBDRUpfAGCUFAQHR0t9XC84gu/hMbF9ziEVl+UglAlX0REhNs2NYQzYkzTlIvVavUYZLqGc55WfFSi4jJQFH4RQgghhASJFfl/hBD1itu6FWnLlyNu2zb+MMlxVcjXX8fJdetQ8vrrMKelccGXgtVfGg2d/omJL0AQCuX4Ag+5+37xBZp8YRLAX51UXV0t+piECFVSqWUlSlf+rFLqKUyS45jwNr3S9Vj1FNbJGYgGi179CCGEEEJCWFNTEzZu3IgHH3wQAwYMgF6vR3R0NIYNG4YXX3zRY8PfNWvWYOTIkYiJiUFiYiImTZqEAi8n5jt37sSkSZOQmJiImJgYjBw5Eh988AHvdWtqavDcc89hwoQJyMzMRFRUFKKiojBo0CA8/fTTqKysDOgxHzlyBL/73e+QkpKCyMhIDBkyBCtWrFB9pQoJcWVlwP79iF+/HgC4f/fv57Y7sq0KWVSE+okTYcrKQv3EiTjx739z2wcNkn3ooaIj/w7zVSf5uvqilISCGL7pkHL2gROasigU1inNn5+lp/DLUyN6sXj7PXMdn6dpmkqsWhooCr8IIYQQQoLEsuJ++eOTTz7B3XffjdWrV0Or1eLOO+/EDTfcgDNnzmDhwoXIzs5GeXm52+3mzJmDWbNm4fDhw5gwYQJGjhyJrVu3Yty4cdi4cSPvfa1fvx433ngjtmzZgqFDh2LixIk4ceIEZsyYgb/97W9u1y8tLcWrr76KX375BZmZmbjzzjtx0003obKyEq+//jqGDRuGM2fO+PV4d+3ahezsbOTn56N379648847UVlZib/+9a/4/e9/H3JLr5MQkpcHjBiB2L17AQCxhYXAiBHcdkftq0IiKsppMxsZyW1PSZFrxH5TuheRnD2a5MZXEVZVVaXASJwJVQPyhUz+VDcFSyhMEgq/lF6VUKzwS44wydtURV9XpwTUvzCGIwq/CCGEEEJCmE6nwyOPPIKioiIUFRXhX//6F7Zs2YLjx4/jmmuuwbFjxzBnzhyn22zbtg0rV65EUlISDh48iI0bN2LLli3Yvn07tFotZs2ahdraWqfbVFdX44EHHoDFYkF+fj5++OEH5Ofn49ixY+jbty+WLl2KH374wek23bt3x969e1FRUYHt27fjs88+w+bNm3Hu3Dn86U9/wsWLF/HUU0/5/FhbW1tx3333obm5GcuWLcOePXuwbt06nDhxAqNHj8bnn3+OtWvXBvhMEsKjuBjIygIyM4FVq4CEBOfLk5K47ZmZ3PWKi50uzsjIkHGwwUtPT1f0/l2nUHkLNFwDJTnDGTHU1dUpPQRBSvelEvpZCvX3Unq8/oRfnvrVyREmeav8cg1EPf0eylGpJhYKvwghhBBCQtiMGTOQl5eHgQMHOm1PT09Hbm4uAGDDhg1Ob8yXLVsGAHjhhRfQr18/+/bRo0fjscceQ21tLd577z2n/a1atQr19fW46667MHXqVPv21NRUvPbaawCApUuXOt3GYDBgxIgRbm+k9Xo9/vd//xcA8N133/n8WL/44gucOXMGw4YNw1//+lf79piYGLz99tu8YyAdhyIrnqemAgYDUFIClJYCNTXOl1dVcdtLSrjruaym6M9KemqgdFN21xN/g8Hg8fpRLtV1rqG92snZLNzfKaWeqpPkINSXSij8EuoFJlc1sNDPUqiyTuhxyFH9GGrHglgo/CKEEEII6aCGDRsGgPtk1ja9prm52R44TZs2ze02tm3/+c9/nLZv3rxZ8DaTJ0+GXq/Htm3bfH7jbnsz7c+n9Z7GMHz4cPTu3RuHDx/G2bNnfd4nCR2KrHhuMAA7dgALFgAMw3050mq5bQsXctdzaYCv9Cp0oVSVAbiHX97Cw/j4eKfv5WzIHmr8DdqUXhxBKKARqpoSmrIrVzWg0HiFgiOh6ZtyBKL+3ofSU0rFQuEXIYQQQkiQlOz55cnp06cBcG++ExMTAQDHjx9HS0sLUlJSeKdkDR8+HABw6NAhp+0HDx50utxReHg4Bg8eDJPJhGKXaV98WltbsWjRIgBccOYrT2PwNHZCghIWBixeDCxd6v4LarEAy5YBixZx1xPAtLQgefVqWGTuj+NpwQtfyN1Dz/Wk3FsPspiYGKfvlZ726C0wUjJE4Kuk8jT9Tmn+HntCIZNcDdmFxiv0AY+S/fW8rfboqqOEXx3jURBCCCGEdDCub9gjIiL8XuVq5cqVAICJEyfab1tSUgJAuBdRdHQ04uPjUVNTg4aGBsTGxqK+vt7em0bodhkZGdi7dy/OnTuHoUOHul3+4IMPwmKxoKamBvv27UNpaSnGjBljnzLpC29jt20/d+6cz/skxGcHDoBlGDDtJ7ksAEarBQ4c8HrTuK1bkbZ8ORoHDkTMww9LO04Hga6oamM0Gt0CJjl5q5xT20m56zRMV+Hh4X4HD2LhCwa9BTAMw7iFOizLyhKa+Rt+CR0L9fX1SE5OFmNIgjyNVeiYUDL88hQS84WI3n7ech0TwaLKL0IIIYQQFerevTsMBoP965VXXvHr9l999RXee+896HQ6LFmyxL7dVgni6STN1venoaHB6Taebud6G1dr167F2rVr8e9//xulpaUYP348PvroIyQlJfn8mLyN3dsYCAmY2Qzk59uDLwCARsNVfuXnc5fzKSuDvqgI8evXAwDYd98F9u8HyspkGHTwlVDnz58XaSSB8XZCreQJN1/g4S0oVLKnGl9Ddm9hHV/46LoogVoIhV9yjNdTDy01rk7p6XVBqFKtIzS9p/CLEEIIISRILMuK+gVwJ511dXX2r+eee87n8Rw7dgz3338/WJbF66+/bu/9paS2tjawLIuLFy/i888/x4ULFzBkyBD897//VXpohHhXUAA0NTltYmwnvEYjdzmfvDz0nT4dsXv3AgBiCwuBESOAvDwpRysaORuyhxq+wMNbmMQXfsk1tZSvH6NQk3gbvuqkYKfSSkWoSlCO59fT74nQdEy1hl9CYZ2npvdyrFApBnXViRJCCCGEEABAXFwc4lyaZ/uitLQUEydORE1NDebOnYvZs2c7XW6rTGhyOZF3ZHsja2s27VjN0NTUxDsu19sISU9Px7Rp05CdnY0hQ4Zg5syZOHnypE8VETExMaipqREcu69jIMRvgwYBixfjVK9eYNtPDnv37g1NSwvw7bfc5TbFxcCUKVwoZrGg1WCArn3aMAAgKQlYtQp4/30gOhrYuBHo31/Wh0OCxxd4eFvAg+/y5uZmr6GZGPiqc7xNvYuKinILu+rq6tClSxdRxyYGJasAPU1lFQq5lFwMI5BKNb1eL1hF19DQ4FcVt1Ko8osQQgghJEhqaXhfXV2NW2+9FefOncOsWbPwxhtvuF2nR48eAIALFy7w7sNoNKK2thYJCQn2ECkuLg4Gg8Hj7WzbMzMzfRprZmYmbrjhBly6dAl79uzx6Tbexu7vGAjxWUoKsGABmq+5BqasLJiysqC59lpgzBhuJciUlCvXTU3lVoksKQFKS52DLwCoqgJKS7nLDQYgLU3ex0JEwRd4BNKjrM71+JAI33i9VR/xBSFqnuKmVADmqfJL6Jjw9Nx7CqfE4Gn/gUx79HWVZ6VR+EUIIYQQ0gE0Njbi9ttvR1FREaZOnYp3332X90RgwIABiIiIQEVFBUpLS90u379/PwC4Na23TZ20Xe6otbUVhw8fhl6vR38/KlhsTYgrKip8ur6nMThu52u4T4hsDAZgxw4uFGMYsK6/h1otwDDAwoXc9QKo8JSSUgGC3CtLBosvBPL23PGtBinXNEK+8Mvb6pTeKtmkEuixoFQ1lafKL6Hn2NNzL3WY5Cn8Epre6Gnao1KLOPiLwi9CCCGEkBDX0tKCu+66Cz///DNuu+02fPrpp4InAZGRkbj55psBAJ9//rnb5fn5+QCAO+64w2n75MmTnS539OWXX8JkMmHChAk+r2BlsVjw008/AQD69Onj0208jeGXX37B6dOnMXjwYPTs2dOn/REimbAwYPFiYOlS5yb5ANckf9kyYNEi7nqyDcm3+1JqShtfQ3ZfuJ6UyxWiidVIXa5KKr7nxVtYp1SYFGivOX9XRBZLIOP19NxL3UPL0++I0OuE2lZWDQSFX4QQQgghIcxiseAPf/gDvvvuO9xwww3YsGGD10/r586dCwB46aWXcOLECfv2Xbt2IS8vD/Hx8XjwwQedbvPQQw8hLi4OmzZtwoYNG+zby8vL8fTTTwMA5s2b53Sbzz77DL/++qvb/VdXV+ORRx7B6dOnMWTIEIwYMcLp8j//+c+46qqr8MUXXzhtv/vuu9GrVy8cPHgQy5cvt283Go3IycnhHQMRtm/fPrz66quYOnUqMjIywDCMxxOyRYsW2a/D9/Xss88K3nbnzp2YNGkSEhMTERMTg5EjR+KDDz6Q4mGpy4ED3KqQ7ViAq/w6cED2oSQmJvp0vYSEBIlHwi/QahfXFRblCpMCDevUxFv4pVTgIVSZFMg0TUD6QDTQVVWFnn8lFxUQCjw9VX6FitCP7wghhBBCFOa4SqMY+/LH22+/bQ+JkpOT8cQTT/Be74033rBPM5wwYQJmz56NlStX4uqrr8Ytt9wCs9mMrVu3gmVZvP/++4iPj3e6fWJiIlavXo17770X06ZNw/jx45GUlIRt27ahtrYWc+fOxfjx451us2XLFvzhD39A7969MWTIEERFRaG0tBT79+9HY2MjunXrhnXr1rmdAJSUlOD48eNuvXB0Oh0++ugjTJgwAXPnzsW6deuQmZmJHTt2oKysDNOmTcOMGTP8ev46syVLlmDTpk1+327MmDHo27ev23bXENNm/fr1mD59OqxWK8aNG4fk5GR8++23mDFjBg4dOsTbm65DMJuB/HzA9UTeYuG2//OfgIzTymx9+7xRKvAItNolOjoaNTU19u9ra2uRJkMftUADj1DibVqkVIQqqbx9sCNUedza2irpFM5Ag1CtVss7ZVDJvmpCgVxHqPwK/UdACCGEENKJOZ70uVZKOVq0aJE9/AKAFStW4Oqrr8bbb7+NrVu3Ijw8HBMmTMD8+fNx/fXX8+7jnnvuwfbt2/HSSy9h9+7dMJvNyMrKwpNPPskbOj300EOIjo7Gzp07sXPnTtTW1iImJgaDBw/GHXfcgZycHJ9PyG2uv/56FBYWYuHChfjhhx9w8OBB9OnTB0899RRmz56t6IpfoWb06NEYOnQosrOzkZ2djZ49e/p00vXQQw9h5syZPt1HdXU1HnjgAVgsFqxfvx5Tp04FAFy+fBljx47F0qVL8dvf/tYtOO0QCgoAl5VJ7Uen0chdLuPjDvTkn2VZWX6vAp1GGBkZ6fS92sMvrVYb8LS+QIndQF3qY0JovN6OYaHqJKPRKGn4FWjPK51Ox3tbKXtoBfpBHYVfhBBCCCEk6FUaXfflj0WLFmHRokUB3dfMmTN9DjFsxowZg6+//tqn644dOxZjx471e1w//PCDx8sHDRrE2/eL+OeZZ56R/D5WrVqF+vp63HXXXfbgCwBSU1Px2muvYerUqVi6dGnHDL8GDeL6fg0bhvNHjyLxgw8QffQorFdfDc111wEOYbQcAg0rGhoaECdDU/5Aq2dcQw25mm8HGiiFh4eL1i/MV2I/J1JXUgmN1zXodCUU0NTX10s6nVfo2PX2O6fEsRDocdsRPliinl+EEEIIIYQQSWzevBkAMG3aNLfLJk+eDL1ej23btkm+upkiUlK4FR9/+QXdn3sO0UePAgA0Bw4AeXnc1McQwLcqrBRcq6G8BR02ajkp97UyxrVHmRzEDr8aGhpE3Z8roao6b4Gb0M9A6oBJKFDytmCArwvEiCmYKkBPfb/Eri6UAlV+EUIIIYQQQnz23Xff4cCBAzCZTMjIyMDtt98u2O/r4MGDAIDhw4e7XRYeHo7Bgwdj7969KC4uxtChQyUdt6yKi4EpU7jpjRYLWg0G6Bx72CUlAatWAe+/D0RHAxs3Av37KzVaj+SeomejREgUDF/DOl+vJ6ZgfoYajcYt2Kivr0dSUlKwwxIkFNZ5a7ouFH5JXQ0oNJXQWyCqxFTCYMMvoWDSZDIhKioq4H3LgcIvQgghhBBCiM8+/PBDp+/nz5+Pe+65B2vWrHEKLOrr6+2LFmRkZPDuKyMjA3v37sW5c+c6VviVmgoYDEB7tZfbKXtV1ZX/HjUKkKFHVagJtfDL1/HyVS9J3UMrmOb8Op3OrReg1A3ZhaYRequkUqIK0FMPLW+VXd4ejxQ8BaHexhMREYEmlz6GNkajUfXhF017JIQQQgghhHjVt29fvPHGGzhy5AgaGxtx/vx5fPzxx+jWrRvWr1+PP/3pT07Xb2xstP+30ElRdHQ0AM/TqFpaWlBfX+/0pXoGA7BjBzftkWHAup6Ua7UAwwALF3LXk6Cnlly9r6QSERGh9BD84uuJP1+1j9Q/q0D7qQH8AY7U4xXavy9hkdwBmKcwydsxrLbKr0Ar6wCExNR1qvwihBBCCAkSy7IBr6DEty9C1Oj+++93+j46Ohp//OMfcdNNN2HIkCHYuHEjdu/ejVGjRol6v6+88goWL14s6j4D4fd0obAwruF9fDyYuXOdL7NYgOXLgTlzRBufK6EKjVChRFVMMHwNMvgel9FoRHx8vMgjuiKYyi+9Xm+v4JSLUKDkS7Cl1WplDX493Vcw4ZfVaoVGI36tkqewztsx7CkcC4Xwiyq/CCGEEEIIIQFLT0/HrFmzAABbtmyxb3ecBuZpqgwAxMbGCu7/ueeeQ11dnf3r/PnzYgzbbwE3fj9wAKzDSSwLcJVfBw6IMSxBwVTIefp5yEUtjex95Wv4xfe4pA6XxK78klow4ZeUq1DyCSZM8nS5VE36PYX4wYw3mIBVLhR+EUIIIYQEiWXF/SIk1PTr1w8AUFZWZt8WFxcHg8EAALhw4QLv7WzbMzMzBfcdERGBuLg4py8lBBRQmM1Afj4YxxNOjYar/MrP5y6XSDDhV3JysogjkZ8SFbTBhHVSV+kFUwmltql53ghVW0l1THh6br09d54qu2wfDIjN03PrLTgM9dUeKfwihBBCCCGEBKWmpgbAlR5eNsOGDQMA7N+/3+02ra2tOHz4MPR6PfqrdKXDoBUUAC7Bhj0IMxq5yyUSzMmo2htXu3I9KZeqasZG7CBF6hU1+fbva1inxPTTYI5doUo1qaZCehprMM+dVMdwMGFdqE1FdkXhFyGEEEKICmVnZyMrKwu5ublKD4UQj1iWxRdffAEAGD58uNNlkydPBgDk5+e73e7LL7+EyWTChAkTFJlaJYtBg7i+Xz/9hJPr1tm/8NNP3PZBg5QeIa9Qm3LoGtbZwlipBFvlIvfzyxfWeWtubqNE5VcwhB6XEpVUvvTsEgqUpOqh5SloDabhfSig8IsQQgghRIUKCwtRVFSEnJwcpYdCCCoqKpCbm+u2KmNjYyMef/xx7NmzB2lpaZg6darT5Q899BDi4uKwadMmbNiwwb69vLwcTz/9NABg3rx50j8AkTAtLUhevRoDPEzTdJKSwq34OGYMTFlZ9i+MGcNtT0mRdsAiUfvKka49yqReETTYSi1fgyex8IVfvvbGkqLpupSEAhrH1WfF5Cn88rVBPx+pemgFU/kVaqG4q9CO7gghhBBCVIBWeyShaPPmzViyZIn9e1tTbMfVGufPn4/JkyfDaDTiySefxLPPPovs7Gykp6ejoqIC+/fvR1VVFeLj45Gfn+9WgZOYmIjVq1fj3nvvxbRp0zB+/HgkJSVh27ZtqK2txdy5czF+/HhZHm9QysqgLypCzI4dSHv7bSApCbj9diA9nfvyE8uyIXUiWVFRgfQAHqdcXI87qacRBhsG6vX6oJrQiyHYaku1HsNCYZJU0wiDPdbCw8NlPRY8HbvepjWq8eftj9CKcSWwb98+vPrqq5g6dSoyMjLAMIxPP9Q1a9Zg5MiRiImJQWJiIiZNmoQCL3P2d+7ciUmTJiExMRExMTEYOXIkPvjgA7EeCiGEEEIIIT6rqKjAnj177F+24NVxW0VFBQAgKSkJzzzzDEaMGIHi4mKsX78eO3fuRFpaGubNm4fDhw9jzJgxvPdzzz33YPv27bjtttvwyy+/4KuvvkLfvn2xZs0aLF26VLbHG5S8PPSdPp0LvgDghReAESOAvLyAdqf2SipXVVVVSg/BI7mnYwUbVrj2xlOCUGN4X0kV2AT7AZDQsdDS0hLUfoWIEYTKydN4fanyC7VKQEedvvJryZIl2LRpk1+3mTNnDlauXInIyEjceuutMJlM2Lp1K7755hvk5+djypQpbrdZv349pk+fDqvVinHjxiE5ORnffvstZsyYgUOHDuGNN94Q6RERQgghRHZs+5dY+yJEBjNnzsTMmTN9um5sbCxeffXVgO9rzJgx+PrrrwO+veIefRSnu3VD70ce4b4PCwN++AHo3Tug3VVXVyM1NVW88YW4YAMPuU/Igw1+1NDjztdpjwBX8eP6MzIajUEHaHyEjgVff8ZyHwvBTk+UO7j1VKnmy3MXFhYmePy3tbWpui+Yekcmk9GjR2Po0KHIzs5GdnY2evbs6TEV3rZtG1auXImkpCTs2rXLvqzzrl27MH78eMyaNQvjx49HfHy8/TbV1dV44IEHYLFYsH79ensvhMuXL2Ps2LFYunQpfvvb34ZGyTchhBBCCCGdQXExMGUKtyojgO6ODbPb2oBp0wBbgBAdDWzcCPi4amVFRYWs4ZfaV2kLtoG83IINv9QQEPjTd0yr1bpVDDU2NiIxMVHsYQkeC74+Z3JPzQt22qPcv5uegmZfnjudTid4/Dc3N7v131OT0K1ZE8kzzzyDF198EXfccQfS0tK8Xn/ZsmUAgBdeeMEefAFciPbYY4+htrYW7733ntNtVq1ahfr6etx1111OTUBTU1Px2muvAUDolHwTQgghhBDSGaSmAgYDUFIClJRA5zr179Il+2UwGAAfziWUkpycrPQQPHKtnlF7WCdF+CV3v0d/nmO+KjG5e2jJvUiAr4SmEfpagSZ3EBpsg35PFYNSHRNi6fThlz+am5vx3XffAQCmTZvmdrlt23/+8x+n7Zs3bxa8zeTJk6HX67Ft2zbJljMlhBBCiLRYkf9HCFEBgwHYsYNblZFhwLqeGGq1AMMACxdy14uL82m3thUjIeN7fzVXYwDu/ZgiIyMVGolvgu3zxBeMyB0c+DM9kO/nIdVqhELhjBRTLMUgFFr6Gmp5up4aKyI9jVfteQaFX344fvw4WlpakJKSgoyMDLfLhw8fDgA4dOiQ0/aDBw86Xe4oPDwcgwcPhslkQnFxsQSjJoQQQgghhAQkLAxYvBhYuhSM60muxQIsWwYsWsRdz4ukpCQAQNzWrUhbvhzYsEGCAfPzp7+TTUxMjAQj4ecapKihIbwnwYZffBU2jY2NQe1TiFA448/0QDl7lAlVfvkTfslZOSgUUPn6O+dprGqspPIUfqlxvI4o/PJDSUkJAPAGXwD3Ih0fH4+amho0NDQAAOrr61FXV+fxdrbt586dE3vIhBBCCCGEkGAVFLjXZGo0gJfV3h0lmEzQFxUhfv16bsOqVcD+/UBZmWjDFBJIE3Ap+jkJca38EiN4C7YXkydSVOTU19eLvk9AnOmUck7NCzZMAtQxRVKMyq+mpiaxhgNAnOPWU1gn5e+cGCj88oMtjY+KihK8ju1TClv45ZjgC93O9TZCWlpaUF9f7/RFCCGEEEIIkZDZDGzaBLc6GasV2LSJu9wHEWvWoO/06Yjdu5fb8P33wIgRQF6eqMMVi5zVV64VI4GEF66VTGIHB1KTasqYGIGHnOGXUFWdP2MQCsqk6KsmtE9fq+U8BdNiV1JJHX6pcZqmIwq/Qsgrr7wCg8Fg/+revbvSQyKEEEIIAJYV94sQoiIFBUBrK1rS01Hy+us4uW4d8NlnQI8eXPDlqfqruBjIygIyM8G89x5aDQbny5OSuAqwzEzueiK1QRGjAkPOqWNiNLx3Dcxqa2uDGVKHIXXgITah8MufMQhNkZSqTxkffwJcoSmoagy/1LBSaaBCd+QKsJXfevoUwdi+BLKtqaRjyW5TUxPieBphut5GyHPPPYe5c+fav6+vr6cAjBBCCCGEECkNGgSsWIGT118P1tb4e/Bg4I47gHff5S4XYlsx8uhRAIDb6bDjCpKjRom2YqTrNEK1cw3r/OlHZRMZGem0CqPtHEsOgUwrlUuoTXsUI/wSqvxqbm4OqP9dIPx5zrRaLe/jFjusC7VQXGzq/S1VoR49egAALly4wHu50WhEbW0tEhIS7EFWXFwcDO2f8AjdzrY9MzPT4/1HREQgLi7O6YsQQgghymOtrKhfhBB3ubm5yMrKQnZ2trx3nJICzJ59JfiyiYoCZs/mLhci0YqR3kgR/EgxZUxMrudGwTal90cg4ZBcgZkY1T5yhntmgWnE/oxBKKCRcyqsPyGRXD3KOnvlF4VffhgwYAAiIiJQUVGB0tJSt8v3798PABg6dKjT9mHDhjld7qi1tRWHDx+GXq9H//79JRg1IYQQQgghoS8nJwdFRUUoLCxUeij+EXHFSF9J0RtY7Su5RbqGkzIKJLyQK/CQsgm5FIGoUGjpTzWgUEAjdvjl6fGLUakmNjGOhUCqMtWCwi8/REZG4uabbwYAfP75526X5+fnAwDuuOMOp+2TJ092utzRl19+CZPJhAkTJsi6hCwhhBBCCFGHiooK7NmzB5s2bcInn3yCzz//HFu3bsXx48dVv3oW8YPLipEs4PeKkb6SIqiqcpyiqUJKTscK5DxOrrBOqJJKDFJU10nZo0zs58JT+OVPpZpc4Zen59bXUMvb9dTc9D50a9YUMnfuXHz99dd46aWXMHnyZPTr1w8AsGvXLuTl5SE+Ph4PPvig020eeughvPzyy9i0aRM2bNiAqVOnAgDKy8vx9NNPAwDmzZsn7wMhhBBCCCGKMBqN2LRpE77++mv8+OOPvDMKbCIiInDNNdfg1ltvxd133+02w4CECJ4VIxnAecVImU6AA1VXV6fqfsNyTc3jCzwCDb/kaMovVkCl0Wjcgo2mpiZ7ix+xSNmXSuwPE8QIkwD5gltP4/VnDFqtVvC5bGtrky3M81enr/zavHkzRo0aZf+ypcGO2zZv3my//oQJEzB79mxUVVXh6quvxpQpUzBp0iSMGzcObW1teP/99xEfH+90H4mJiVi9ejU0Gg2mTZuGm2++Gb/73e8wYMAAnDx5EnPnzsX48eNlfNSEEEIIIURuv/zyCx544AGkpaXhT3/6Ez755BNcuHABLMsKfplMJuzatQsvvvgirrnmGgwdOhR5eXmy9q4hIuBZMbLk9dd9WzGS+ESu6Vh8J/2BnOzzrUgoxTRCsZqm800llKK3XCitTilW+CVXHy1P4Z8/4bGn8ap5enSnr/yylZm7ctxWUVHhdNmKFStw9dVX4+2338bWrVsRHh6OCRMmYP78+bj++ut57+eee+7B9u3b8dJLL2H37t0wm83IysrCk08+iRkzZoj7oAghhBAiK5blvsTaFwBkZ2dDq9UiJycHOTk54uycKOKXX37B/Pnz8fXXXwO4coKblpaGkSNHYsSIEejSpQsSExORkJCA5uZmVFdXo6amBsXFxSgsLMShQ4fsvWKfeOIJzJ8/H08//TT+53/+h/ckmogr6BM6nhUjTVlZwBNPeF8xkqgKX+ARSP8uvgChra1N9F5gYlU7hYeHu00bVOvCCnIFoZ7GqsbwS6zKL51OJ7iibHNzs+jVgGLp9OHXzJkzMXPmTFluN2bMGPubHkIIIYQQTwoLC2ll5w5g1qxZ+PDDD+0nHcOHD8d9992He+65x76SuC/MZjO2b9+Ojz/+GF988QUqKyvxzDPP4J133sEHH3yAsWPHSvUQCIBTp04FtwPbipGHDztvt60YSUIGX5gUSKURX+AhxTRCvmmPgYxXr9ejsbHRaZtQANJZiNXfylP41dbWJlo45mkKrD+hq6dKR5PJ5NeY5NTppz0SQgghhASLq/wSnrrm35fSj4aIae3atQgLC8PDDz+MY8eOYe/evfjrX//qV/AFwD7T4P3338fly5fxwQcfYMCAATh79iy+++47iUZPxBYdHa30EEiQ+AKEQPqN8QVQUqzSyTfeQMKUUKswlaP6S6zwy1MYKWbA6Gm8/oRfco1XbBR+EUIIIYQQIpEnnngCJ06cQF5eHvr37y/KPiMiInD//ffjyJEj+Oyzz+wLMBH1S01NVXoIfomKilJ6CEGRoocW34qBgQQtfLeRopcfX+ARSI8yOabmCf28AqlUk6PvlxyVX2JWUnmq/PLn5+utUk2tOv20R0IIIYQQQqTy9ttvS7ZvhmFw7733SrZ/wi+YipJAVgVUUmJiYkgtrsAwjFOAYrVaRQ9B+MIvsYjVnN4RX0ATSBWXHOGXUJgUyH3rdDrJgxixwi9PrylNTU1ISkoS5X489X8Tq/JLisBZLFT5RQghhBBCCCE+CqaCL5DpccEKpMrHJiYmRsSRSM/1sUoR3EkZfklBrPBLyUqqQBYBELqNWIGV2PsSIuY0Qk/hlz8Bo1yraYqNwi9CCCGEkCCJ1++LVfWnpkR+LS0tuHz5siwnWcQ3Yq/GJ7VgGqiH2kluZPtKmja1tbWi34cU1VlyE2t1SrEJhTOBhHVCt5Grh5a/hIJxMY83T+GXP8G8XKtTio3CL0IIIYQQQmTW2NiIr776Cl999ZXbCmoAUFlZiXvuuQdxcXHo2rUrEhISMG/ePFU3EybqFBsbG/Bt5WgaLibXxypF5Zeaexr5KpDwQo6qRTkqv8Q8JsQMpoSCZk+Blb88hXX+BN2hForbhGZkRwghhBCiItxqj+Lti3R869evx6xZs5CRkYGzZ886XWa1WnH77bdj//799krAhoYGrFixAmfPnsX69esVGDGRAsuykgdMYvYZs1gsop/4ilnt6vpY5eqhFSiNRqNIVaeYP0Mxj2ExK7+EAj4xG8iL+bPT6XSKVhX6E26GavhFlV+EEEIIIYTI7L///S8A4O6773Y76Vi3bh327dsHABg+fDj++te/Yvjw4WBZFhs3bsSWLVtkH29nx7S0IHn1ajAiV97JEXyIGa7xVSkGyzX8Cma8obTCH6DcFFoxq7jkqEwSc7XH5uZmv/clRMywKpjefL7wFjL7c0x4u65ap+lT+EUIIYQQEjQx+31R6VdncPjwYTAMg+uvv97tsg8++AAAMGLECOzevRtLly7Frl27MHLkSADA2rVrZR0rAeK2bkXa8uWI27ZNlP3ZwrTGykpR9ufxvkQMvyoqKkTbl43riXIwwUyoVaS49iiTi5jhl5hhklCQFsg0TaFjQcwFC8QM/qQOv7wFUv4cE95eU9Q6NZjCL0IIIYQQQmRWXl4OAOjVq5fT9tbWVmzfvh0MwyAnJ8d+0qfT6fDYY4+BZVn8/PPPso+30yorA/bvR3z7VNP49euB/fu57UGwhWn1a9aIMEj5iDllzMb1RDmQKW42odajTKnwK9DniS8gMRqNwQ7HTihMCiSsEwrM1Lrao9TBrbegzt9jwlMgKcXrhBgo/CKEEEIIIURm1dXVANw/7S8sLLRXUkycONHpsv79+wMALl26JMMI1Sc3NxdZWVnIzs6W707z8oARIxC7dy8AILawEBgxgtseiLIy6IuKRA/TQpnr1LGoqCiFRiI/vqBPzSv+8gU0YjaQFwpoxJz2KKZQCr/EnoroacouhV+EEEIIIYQQAFdO8G0VYDbbt28HAPTt2xepqalOlylVJaIWOTk5KCoqQmFhobR3VFwMZGUBmZnAqlVAQoLz5UlJ3PbMTO56xcW+7zsvD32nTxcvTOOh1n47QlxXMO1Mxzlf9YyY0/LExjc1T8wVaIV6aAVSqSZHFaAcPcrEIvbrgqfKLzGnwoqJwi9CCCGEEEJk1qdPHwDADz/84LT9iy++AMMwGDdunNttbP2WunTpIvn4OrXUVMBgAEpKgNJSoKbG+fKqKm57SQl3vbQ0z/tzCdPa4uOdLw8mTOMhZh8iObiGPVL3PlITvsBDzGmEYleR8a0cKubxptZeUULEDL88hUliPMdivy54qvxSctVKTyj8IoQQQggJkljN7q80vScd3S233AKWZfHOO+/g66+/RmNjI9566y17VdMdd9zhdptDhw4BALp27SrrWDsdgwHYsQNYsABgGO7LkVbLbVu4kLteXJzn/bmEaWG1tc6X+xumeaHWE08hruGXUisgKkHq8Evsap9g+rH5QuzwS8zG/nyE/l6LXfklxjRCsY8FT+NV62sQhV+EEEIIIYTIbPbs2YiLi0NDQwN++9vfwmAwYM6cOQCAgQMH8oZfmzdvBsMwuOaaa2QebScUFgYsXgwsXQq4nuBaLMCyZcCiRdz1vHEJ09hgwzQvxOzBBEg/DdE1/BI7sFDzBwpSN5CXs8+TGMT+WUk9lVBovGKuTgmoM/ySulJNChR+EUIIIYQEiWXF/QKA7OxsZGVlITc3V9kHRySRnp6O//znP0hLS3Oq+uvduzfy8/Pd+tWcOnUKO3bsAABMmDBBiSF3TgcOAA4BBQtwYdWBA/7txyFMY4IN07wQO/xKcO15JjLXah+xezWp9URciJjVT6EWJon9swokhFLqfj2FvmL8Tov93MqxoIDYlDkaCCGEEEKIR4WFhYgLsgKEqNsNN9yAM2fOYOfOnbh06RLS09MxduxY3hOnsrIyzJ8/HwBw6623yj3UzslsBvLzAceKCY2GC6vy84F//hPwtz+VLUxr3ycLgAkkTPOgsbFRtH0BQGxsrKj7c+VakRJs+BUWFuYUIDU3N0v6GNQcAsg51U0MYod14eHhvM3XLRaLpI8lkL51no57MaYRhtqxIAUKvwghhBBCCFFIeHg4brrpJq/XGzt2LMaOHSvDiIhdQQHgUnHB2E4gjUbu8vHjfd+fFGEaDzmnN6lRZGQkGhoa7N/X1dWJFn7xhTNqfn5CLfAQO/wS6lHW3NyMmJgYUe/LUaDPE8MwvM+BGCtqeqr8CiRwVvNxLyT0RkwIIYQQQgghUhs0iJuq+Jvf4GRpqX1z327dgG+/5S73h9hhmkxcT4xZlhV9aqKYoqKinMIvqVdP5FsBUS06e/glFNA0NTVJGn4F2htNo9HwhlRiTFn0dCwE0mePKr8IIYQQQjohMVdpVHNzZkI6lZQUYMECWK1WmIqKrmwfPBgYM8b//YkdpimktbU1oGldcomKinL6XsyV5/hen4NtAq/VaiXrS8bXPyyYBQWEQk+1BqJCAY0YDeQ9/a0OtCoqLCxMsmPB03gp/CKEEEIIIYRIjmVZHDhwAAcPHkRlZSWam5u9hqALFiyQaXSktrZWnB21h2kAYDp82L7ZmpUFTSBhmkLq6+uRnJys9DAESbkiIV/1TLCVXzqdTtbwS4rnp6WlRZUVcEIhlBjTCD1VUgUaBIaHh4syNj5iV355u40aA1EKvwghhBBCCFHI2rVrsXjxYpw7d86v21H4JZ+LFy9Ktm+mpQXWV1+FZu5cQIXhAZ+KigpVh19SVqTwhdJCfaV8FRERIUolEh++qjcpejU1NzerMvwSOhakbiAf6DEoZUWlp4A1kEDUW7DV1tYmaRAdiMBrHgkhhBBCCIAr0x7F+iKdw/PPP48HHngAZ8+e9emYoGOk44nbuhVhzz8PbNig9FB8JlWVkliCmdbnDV8lVbBhm5ShEd94gw3r+EIPvhUV1UDoZyNGLzQpKr+kbCIvdvgFeB6vVIFuMCj8IoQQQgghRGZ79uzBK6+8AgC45ZZbcODAAezfvx8Ad+JksVhQUVGBr7/+GnfeeSdYlsXYsWNRVlYmehNrIr+wigroi4oQv349t2HVKmD/fqCsTNmBdQBSTrWSK/wSK+DmCzyCDb/4wsUml4Uc1ELKMEnsaYSA/FWLNoGOl8IvQgghhJDOhhX5i3R4//jHPwAAmZmZ2Lx5M4YOHer06TvDMEhKSsJtt92GjRs3Ijc3Fz/99BMmTpwIs9ms1LA7Pddm6oFK/Pxz9J0+HbF793Ibvv8eGDECyMsTZf9EGnyBR7BhG1+AIFaTfil6fvHdXozXJCkqWqUMQj2NN9D7lTL8kqLyy9PtKPwihBBCCCGEoKCgAAzD4C9/+YtP1QmPP/447rnnHhw6dAjvvPOODCMkfLp37x74jYuLgawsIDMT8evXo9VgcL48KYmrAMvM5K5XXBzcYIno+EKeYAMWvsBDrEoqvrBOivBL6mmEaiTFtEdP4Vew0409jVeKaY9q/JCGGt4T4gXLsrBYWLS2WmButcBsboPJxH2xVhZms6W9/4bjba7c1nlfV/5bq2Wg1Wqg02mh03H/hoVpoNVq2v9l7P+t02mh0ahrtQxCCCFXiFmwRYVfnUNZ+/S2QYMG2bc5Tj1pbW11OyH505/+hPXr12PdunWYM2eOLOMkzoIKDlJTAYMBOHoUvG2tq6qu/PeoUUBaWuD31S46OjrofZAr+AIIKSq/jEYj4uPjg9ovwB94iDFNs6GhIah98BGqpAr2+dVoNJIEa1Ls09s0wmB+nz1VqgV6TFD4RUgIslqtKDlWCbPFAl2sHmZzG1pbLbBYWFitrgEWG9CZCcs6v+hwfzstaG52L2t2fJFnGMBiYaHVMtDrwxAZqUNkpA4REWHQ68MQERFGwRghhBASYmzTmrp06WLfFhMTY//viooKdO3a1ek2GRkZAICTJ0/KMEIiOoMB2LEDWLIE7JIlAADG+ZNRwGoFFiwAXngBEKFfkeMxFQy9Xq/KaUy+YllWlClwYk1HdMQ3LqPRKMq++QKaYBcEkGpFQqFwJtjxarXakAm/PIVQzc3Nqgu/PN1OjZV8FH6RTqnF1IpD28/hx/zDKPzmFBrrTEjrk4Tfzr4OPbJS0Gq2IFwfBgbtf4wc/iYxYMAy3IsHwzA+h2EMc+WPm1ug5nJd+4uTQ2DW1saisdGMxkaz/b5tNJorwRj3bxiiosIRHq6VdK47IYQQDmtlwVrFqdkSaz9E3VJSUnDx4kXU19fbt6WmptpP1I4ePeoWftmqxaSouggFubm5yM3NVf1qgx6FhQGLF4OJjwfmznW+zGIBli8HRKzqE2slQYPBENLhl8ViEaX5uRTHHt97dbFCNr7AI9gwKdhpk0KEwpJgK9W0Wi3v82m1WoN6LuQOv6T8/ZOiQb8aVyWmnl8hKDc3F1lZWcjOzlZ6KCGj6lID1r+5C3NuWo2JMUtwW+QSPHXbB/jy3f24fK4OSRlxiE+LxofPbUNjTTP0GgtS1/4DjNlkD76clhdvn9/CWoWDL5blqsb4vgTxNDxmGAZ8+ZXj/trarDAazaioMOL8+ToUF1fhwIEy7N1biiNHLuP8+VpUVzehpaVNlS9EhBBCSGdjm+547Ngx+7bw8HD79nXr1rnd5sMPPwQAt1Css8jJyUFRUREKCwuVHkrwCgrc30JqNEBBgah3I1aD/ri4OFH240qq96WuJ/PNzc2i7JevgbwUxHpe+PYjRY8yMQg95mBDS6FKtWADRimOXU8hlJTTCNW4OqUUqPIrBOXk5CAnJwf19fUwuDbKJAC4F6OfvjiK/Ld24dcdJbBaPL84lRyuQMnhCgDAp4t+wPDSAjxydg025Z/HsavG49KpGsz9aCrCI33/pMOX10PW/n+erhPINEsWLACLlUVDYwsaGlvsVWwaDYOYmHDExkYgOjoc0dFchRghhJDAcVPbxdsX6fhuuOEGfPPNN/j+++/x8MMP27dPnz4dhw4dwurVq5Geno57770XRqMRa9aswb/+9S8wDIPbb79dwZGToJnNwKZNcIsgrFZg0ybucpGmlgVb5WMjd7VPsMLDw50qZerr6xEbGxv0fuUKv6Sk1vBLqsovofDLZDIhIiIi4P3KXYHa0tIi2b4DfZ0Qo5pSTqE1WkK8OFdUjuU5X+LAD2cD3sexnedxH7hP3YZdLsT2iKuRMTAZzQ1mr+GX3ycsDtdnGL7b28q/+K/veJ/Ot2Vc3lCx7XEYF4jV1ZtQV2+yXysiQgt9pA4J8ZEwGCIQERFG0yUJIYQQCU2ZMgXz58/Hl19+ifr6entlzezZs/Huu+/i7NmzeOmll/DSSy853S4hIQHPPfecEkMmYikoAFpb0ZKejstz58Lcowf6sizw9NNASQl3+fjxotyVWO/nXE+OxeqhJVXlV0REhFP4JdbqiTSDIvQqv4SC2+bm5qAKSaQKboUa9AcTtnk7bqnyi5AQ0VhvwuoXtuHf/9iLtjbnFwp7Ty5fMABYQA8zrsMpAMB17Ekc+0N/dL0mE4YunhsMuq746K8r43R8I+EcYtl6jdm/9/qay7oXjTncDctylzeb2tBsakNNDVcSrtUySEiIRHx8JAxxeqoMI4QQQkQ2aNAgfP/992hra3OqJomKisL333+P+++/Hzt37nS6zeDBg/Hhhx/aG9+TEDVoELBiBU5efz3YyEhu2+DBwB13AO++y12uci0tLaL0E5Oqkio6Ohp1dXX278WqmpE78FAjoaAk2EBU6PEHW3UoFJ4Fe0xIdexKcSx4Ox8O9OdG4RchMrBarfh69X7kPbcVDVXOzf9sv7y2X3LHAIwvDMtAFV7COuhZbt63DlaEg0vWwyytuP+dmWDDwqEJY4CoKFS8+zE0Vw2ATqdFeLgWOp0WYWEahIVpnPZvW93R8V+Addve2mqBydQGk8mClpY2tLRwK01are5hGgMGVp9Xm+SZ4w/mSg2YYxVZ+3NjdWiuX1nZhMpK7lOy8HAtEuL1iI+PRFycHmFtZuDNN4G//AUQqZEqIYQQZ9nZ2dBqtfZ2B6TjufHGG3m3Z2ZmYseOHTh+/DiOHDmCtrY29OvXD9dcc43MIySSSEkBZs8Ge/iwfRPLsmCiooDZsxUcmO/q6+tFCb+k6mMkVqN/uYSFhUna00lMQkFJa2trUCtBShV+CQU0wYZfUk17DA8PFz1YkypY9RZ+iVUhKhYKv0hIqasyYsl9+dj3zWney11/uVx/4fhS7xpEwwg9eqKKd58RNZVXvhk1Ct1GDAA8NP203R/3j2+/7J4qbrmG9raArA3NzWY0NrbCZGpFW5unFMx9rqSt0ssVC+fnxnVKZUuLBZcuG3G5nFt2uet3/0Hm88+gOSkV+gf+rKoXNUII6SgKCwslazJNQsOAAQMwYMAApYdBZGC1WkOqiqKyshJdunQJej9SBT5S9SiTil6vD5nwS0hTU5Mk4Vew0x6Ffq+Cfb6lDL/EmqZrI9V0XW/ngGKtsioW9YyEEA9aW9vwaPY/cOZQpfcrtxP6ZdRoGXTrm4js2/oi+9a+GHZjT0Tp/xdYsoT7Yhiu4aiNVst9v2AB8MIL3BLVMtJoGISHhyE8PIw3c2tttcBoNKOurgVGYwuam9ucpn/aq8X85HwT1mEbg5gtmwAATR98ikNDbkZyUhSSkqIQF6eHRkNBGCGk87GvBizSvgghnUtNTQ2Sk5OVHobPxKokcV1xT6wAMJSCRIALv+rr60Xdp9x/S5qamhAfHx/w7YWqnYL9WUp1LEgVfkkRFkk5pdbTNM2WlhYKvwjhZTK5TaVjWRZP3f4h9m3jenDBNsXcCtfWWO3lS/y77pIRhzseuxaTHhyBpDSBlV4WLwbi44G5c523WyzA8uXAnDmBPCrJ6XRaxMdz/bkctbVZ0NBgRn29CUajGQ2NLfDldc/2d9Kx+svxb6em2YiE3T8CABJ2fQ9rQyPKWq24dLkRGg2DxIRIJCVHIyFeD61WnBWGCCGEEEI6skuXLoVU+CUW1/BLrIotsVa5lAvfqoPBThmTMvziCzyam5uD2qdQmBRseCVV+CIU+AQ7I0aK8Up5LHiastvc3IzoaM99s+VE4RdRj/XrgWeeATIygD/+ER/+7w94f+EP/P26HP+eseANvvpenYbfPzUGN04bhDCdjy+aBw5wlV6OL75aLbc9xISFaZGQEImEhCuhmMViRU1NM6qrm1Df0ILWVvcX7SuhF/cHV19yClc98zA0Ju4PmqatFZpW7gVO02rGiOk3whrGvVGx6iNR9Mq7qOjRGxoNA0NcBJKTo5GQGIlwX38GhBASilw/KQh2X6TTaGtrw+bNm7Fjxw6cPn0aDQ0NXisKGIbBt99+K9MICZGOa/gVar26xMIX+rW1tQUVBkpZ7aPVat32L1UD+WCDTKmCUKHnV42ValKGX57G67jiqhpQ+EXU4/PPAQC1/28tps4stodZrg3s7VwCL42WwbW39sH9z43DkLGZ/t+/2Qxs2MAFXzodMGsW8P77QGsrt/2f/wSCmMeuBlqtBsnJ0UhOvpLANza2oLKyCXX1JjQ3t9rPuewN+ROT0RYTh7hzp3j3GV5VYf/v+kHXoC05BQDXq6ym1oSaWhMXhBkikJAQhZTkKOgoCCOEEELw448/YubMmSgpKbFv83SSYvsgkHptko7CNfziq4DqDPiqfZqammDw1BjYCynDr/DwcLefXbD3JxT6q7WKT+i1OtjxegqTLBZLQOGY1MeCUNWf2vrYUfhF1MFoBPv112AARO34FnrtCJgY56DJrZk9uFUPew3pgr+snISrx/cKbgwFBUBjIzBgABfEDRkCPPkkMG0aUFzMXT5+fHD3oUIxMRGIibnyRqO11YKKSiMqK41obDSjLToOv77zObqveRPd17wFMAwYhxdQVqMBWBbnZ/4FJTP+B4wuzK0Kz2plUVNjQk1NM06frobBoEd6WgwSE6OoRxghhJBO6cCBA5g4cSLMZjNYloVer0e/fv0QHx+v2pM9Iq74+HjU1tYqPQxFuZ6Uh1rll5Q9ypqbm4MKv6Ss9gkPD4fRaBR1n1JNI5SKVJVfnqY9mkymgKYRevtQJRiexiv2qpXBovCLKKO4GJgyBWh/0ay/XIe49mQ4HBZ8aHkLbeBeOEzQYb7297jAJDntYuyUq/DE6xOR3itBnDENGgSsWAE8/DAQFcVtGzIE+OUX4N13ucs7AZ1Oi67pceiaznXXb24242JZI8pznoIlJg693nrJ6fqM1YrTf5mPsukPAj7M+mFZFrW1zaitbYZGwyAlOQqpabGIi41Q7R83QgghRGyLFi1CS0sLIiIisGzZMsyaNSvkTvxJcFJTU0UPv6Ss8NDr9aJPY3Idr5SVX1JUTYoVVPPtp7GxMah9SnksSPFzEqr8EuNnptVqJWtQz3dfUt0+0B5ano6FYJ9fT+N1rQ5UGoVfRBmpqYDBABw9CgBwXcQwCVde7I8gA9WIsX9/65+H4dFXbkFClxiIKiUFmD3bfXtUFP/2TiIyMhx9eicCSIR1xTmw7T3RbGsMQKNFdHGRW2821mXaKuAejFksLC5dNuLSZSPCw7VIS4tBapcYREaG1vLUhBBCLb+Iv3766ScwDIPnn38ejz/+uNLDIQKkrJ4Rq7m7IylP8OPi4iTv4SPlKo1ms1n00CZcpJYofAFEsFPGpAy/pDh2paz8Egq/rFar6JW2wTas9xZ+BcLT61iwj9/T41Xb6tVUU00UYYmOwcu9Z2MtMw5WABY4v6hZwMAKYC1zI2ZrZ6GJicDdT2bjy+rn8Ox7d4sffBHvzGZoNn4BxmIBo9MBjzwC6HRgrBYkb98CTZsZLMtNcXR8neOCMNbpxc/2R4xhrjTYN5stKCmpQ+HeUuzbX4qLZQ1obVVXqSwhhBAiFluIMHHiRIVHQjypr69Xegh+kbLSIi7O9eNq8Uk5C6CpqUn0fYoVfvEJNrySMvwKtRUJhcI6KXpSBRsMegq/Al1UwNOxIGVYpzYUfhHZNTe24A99l+Pbfx3DB2E34f9pboXWpUmUFiz+obkNH4SNxx+eH4ctjS/gf5ZPRlRs52yCqQqOPdH27QPy8sDs2wf07w9tkxHXtV1Anz6JiI72/oLvGoS5vs8xGltx8mQVdu2+gCNFl1Ffb1LdJweEEOLIMegX48sfTU1N2LhxIx588EEMGDAAer0e0dHRGDZsGF588UWPU2fWrFmDkSNHIiYmBomJiZg0aRIKCgo83t/OnTsxadIkJCYmIiYmBiNHjsQHH3zAe93Lly/jvffew913342MjAyEh4cjPj4eN954I9auXev3Yz179mz73w3+r7S0NL/2p6SePXsCUN+0EOLs/PnzSg/BL8GuuOeJlEGPjZjhl+tJeUNDg2j7tpGiAkosUlYBShF4SN2UnY8UlVTBhkmefgcC/XshZeVXKIVfNO2RyOpySS3+nPUm2sxWe+DRh70ECxhowNqn0lnBYEz3Zjx8/AWER9BhqgpeeqJphw5B1xSuV5jFYsXl8kaUlTWgqUn4Rdq2oqTwazyLysomVFY2ISIiDD26G5CaGgOtlnJ7Qgix+eSTT/Dwww8DAAYOHIg777wT9fX1KCgowMKFC/Hpp5/ixx9/RJcuXZxuN2fOHKxcuRKRkZG49dZbYTKZsHXrVnzzzTfIz8/HlClT3O5r/fr1mD59OqxWK8aNG4fk5GR8++23mDFjBg4dOoQ33njD6frz5s3Dxx9/jLCwMFx77bUYO3YsSktL8dNPP2H79u348ssv8dlnn/n95jk1NZW3YiqY5tBymzJlCo4ePYrt27dj9OjRSg+HdBBSVDfZuJ4kS9FDS8z96fV6p6bswfbQ4qPm1SmlDJM6UviVkOB//2hPYZIYz42tjYyrQANNKcdL4RchPI7sKsFfblzttC2MteAG9hi0YNEKDbYwV2MiewA6WHF19S8AI92LIPGTHz3RtFqNvWm+xWLF5cuNKLt0JQhj2SvTHa+8x2EBuL7hsXcWQ0tLG06crMKJk1VIS41BRoYB0dHSfwJJCCFqp9Pp8Mgjj2DOnDkYOHCgfXtZWRkmT56MX375BXPmzMEnn3xiv2zbtm1YuXIlkpKSsGvXLvTr1w8AsGvXLowfPx6zZs3C+PHjER8fb79NdXU1HnjgAVgsFqxfvx5Tp04FwFV3jR07FkuXLsVvf/tbjHdYGTkpKQkvv/wyHn74YaSkpNi3FxYWYsKECcjPz8d7772HRx55xK/HfNVVV2HNmjV+3UZtZs+ejTVr1uCNN97A9OnT7ZVgRFhubi5yc3Nla1wdiqQMv1yZTCZERkbKdn/+ioyMdAq/pAhXxKyGEwo8AsVXJSTl6pSANIGoGISqsQLtYSflNEKAC5rFfJ3ztK9gxyvFFFipUPkEkcXX7+9zC74AYBB7HlEwowRJeDzsEfzn2odh/mk30L8/0NDATbUjIU2r1aBr1ziMGN4N14/ugT69nadGXmmOb/tD6fhH3/0PKNPSgrDlS7Fv52ns3XsB5eWNsFppSiQhRFm2hvdiffljxowZyMvLcwq+ACA9PR25ubkAgA0bNjj1Nlm2bBkA4IUXXrAHXwAwevRoPPbYY6itrcV7773ntL9Vq1ahvr4ed911lz34ArgqrNdeew0AsHTpUqfbrFy5En//+9+dgi8AyM7OxrPPPgsA+PTTT/17wB1ESkoKvvrqK0RGRuK6667Du+++i7q6OqWHpWo5OTkoKipCYWGhrPfLtLQgefVqMBJNKbTtHyI0k5dy2qMrtfdDC2RVPH+J2Sxd7BCBL/yScnVKofv0lZQtToSeWyl6aInxHIs9ndbTcytljzJv9y230InpSMh6c/aX2PSPvbyXnWVSkKu5DZs1I/BY7hTc+Ug2d0H7VDoMGiTjSInUbEFY165xaGuzovRiLS5ebITZbGkPua5Uf11ZPdJ5Hynbv0afvP9DS0oayifchaKjFdAwFejaLQ4Z3eKg16u39wIhhMht2LBhALg3+FVVVUhPT0dzczO+++47AMC0adPcbjNt2jS8+eab+M9//oN58+bZt2/evFnwNpMnT4Zer8e2bdtgMpmg1+t9HtvFixf9f2AdxNChQ7F9+3Zcd911eOyxx/D4448jOTkZUbb2AgIYhsGpU6dkGiWJ27oVacuXAxkZwIgR4u24rAz6oiLE7NiBtLffhjUxEZpJk4D0dO5L5SorK5Gamqr0MATJESCIOeUrIiJC1B6AfNU+UlfpNDU1ydIbzl9CP6dAq6s8hV9iHBM6nU7UlVXb2oQXEQv2mPAW9lksFtVUh6ljFKRDslismHfL+/j1J+FGoXVMNL6OG4v3Dz6J1B7xVy7gmUpHOpawMA0yeyQis0cijMYWnCupQ1VVE6xWtn0VSOfUyzZVMuWHrwEAKT9+jfIJdwEArCxw4UI9LlyoR0KCHr17JSKWFkcghMiKBSDWp5vifUp6+vRpANwb6cTERADA8ePH0dLSgpSUFGRkZLjdZvjw4QCAQ4cOOW0/ePCg0+WOwsPDMXjwYOzduxfFxcUYOnSoz2MLpEn95cuXsXDhQpSVlcFgMOC6667DnXfeqcqTLk/Wr1+PBx98EA0NDfbFDsrLy73eTo3Tijqk9nAqfv16AECXf/8bGD9evHAqLw99Fy+2f6uZPx+YPx9YuBBYtCj4/UtMTRUdfMQ+4eZ7vGJWfun1elH7kvEFHlKHEM3NzU7T5dVC7L5UoVb5JXVY52nKrtlspvCLdGzNRjNmDX0LFecbrrRt4pnVduM9WXj+o2nUwLyTi46OQNbALrBaWVRUGnHhfB0ajWaHajBAo2HANBmRuOdHAEDS7h+gaW6CNdLx03EWNTXN2FdzEXq9Fv36JiExMYpOEgghndbKlSsBABMnTrQ3Zi4pKQEA3uAL4KYKxcfHo6amBg0NDYiNjUV9fb19Sp7Q7TIyMrB3716cO3fOa/jV2tqKd955BwBw1113+f24jh07hhdffNFpW48ePfD5559j5MiRfu9PCbt27cLvf/97e+VBZmYmhg4divj4eFFPqEkQXMOpH3/kKr/ECqcefRSnu3VD7/aed1atlruP3r2D3zeRJfAQ8z0mX/P8YHpo8Y1XzBCCL/CQc9qtP8QOXzyFSWIcE3KOV4zfE089ykwmk9dqZrlQ+EVE11hnwqyhb6H6stG9q5zt9ZEB3tj6Z1wzjv64kys0GgapXWKQ2iUGLeY2lO/Yj6QH/wiNiVuGmGlthaaV61mjaTXjuvtuAtv+yYglIhKHX85Dc/deAACTqQ2Hfr0MrZZB3z5JSEuLhUZDIRghRBqB9OrytC/AvZ9ORESEXyuLffXVV3jvvfeg0+mwZMkS+3ZbZYGnN6PR0dGora21h1+O1QhCt7P112loaPA6tvnz5+Po0aPo1asXHnvsMZ8eD8A9B48//jimT5+OgQMHIjIyEkeOHMGSJUvw1Vdf4bbbbsOBAweQmZnp8z6V8tJLL8FiscBgMODjjz/GpEmTlB4SAYDiYmDKFMBoBCwWtBoM0Dn2YktKAlatAt5/H4iOBjZu5HrVBrJ/AN0dGrJrLBZg2jTAVsEYyP6JndgffvJVtoh5H3yVqy0tLT5NI+fDF3iIWVEUFhbmNk2zublZtP2LSewPFDxVPYpxX54CKYvF4ndgJXX4FRYWJhh+qemYoI+ViKgsFiv+esv7XPDVzv5Hof01ggljkH/+KQq+iEcR4WHofu0ARKanQH/5IvSXLyKiusL5OtUV9svaYmJhTkwG4NgvjIHFwuJ4cSV+3H4Gp8/UoLWNVogihISG7t27w2Aw2L9eeeUVn2977Ngx3H///WBZFq+//rq9v5YafPbZZ3jttdeg1+vxySef+PWJcHp6Ot555x3ceOON6NKlC2JjYzFq1Chs3rwZf/zjH1FbW4v//d//lXD04tm7dy8YhsHixYsp+FKT1FTAYABKSoDSUufgCwCqqoDSUu5ygwHwd9qu4/5LSqCrqnK+/NIl+2UB7Z9IRorVIh3xVfsEs3qnHOGXK7WuxCp2EKpk5VcgvcA8/VzEGK+n48pxsR2lUfhFRPWPp/6LM7+Wg2EY+xcAMBqGm/aoAT45PgcJXaRffYV0AAYDmB07gAULAIYB6/JJilWjAcswODvjLzjw5r9giY4DwIBhbFUYV0IwADh3rgY//XQOR4+Vw2QSr6EoIYTY+jWJ9QUA58+fR11dnf3rueee82kspaWlmDhxImpqajB37lzMdumhGRMTA8DzSZWxvRolNjbW6Taebud6Gz7fffcdZs6cCY1Gg08//RSjRo3y4RH55u9//zsA4L///a9o+5SS7XkcO3aswiMhTgwGwPG9h+uJoVbLNSFduJC7XlycuvZPJCN1+MVXgSN2+CXmdDp/KpE7mlALv5TsUaam3oAUfhHRFHx5HBv/8bPg5YyGwfuHctClu0HGUZGQFxYGLF4MLF0KxuWFW2O14tQTz+PsrDlgff1jzgKXLjVi1+7z+OXARTQ1UQhGCFGnuLg4py9fTjSqq6tx66234ty5c5g1axbeeOMNt+v06NEDAHDhwgXefRiNRtTW1iIhIcEeZMXFxcFgMHi8nW270JTDwsJC3HXXXTCbzXj33XcxZcoUr4/HH/369QMAlJWVibpfqfTqxU3TD+bklkjE8b2H64mbxQIsW8b1/Ao0SJB6/xIKdAoeHyVOij2teueN1FVNfOGX0WFarBg6c/gl5tRHJYJQm0CmEUo9TdPTcSV2771gUPhFRHHpXC0W/n6dx+u89eOD6NE/RaYRkQ7nwAHu01BHWi0ya84iOTnS5cqM06cuLMs6L8TW/t+1tSbs2XMe+/aVoqlJPSW5hBASiMbGRtx+++0oKirC1KlT8e677/J+Aj1gwABERESgoqICpaWlbpfv378fANya1tumTtoud9Ta2orDhw9Dr9ejP09/oqKiItx+++1obGzEsmXLMGvWrIAeoyc1NTUArvQeU7upU6eCZVlFK9X27duHV199FVOnTkVGRoZT1b4na9aswciRIxETE4PExERMmjQJBQUFHm+zc+dOTJo0CYmJiYiJicHIkSPxwQcfiPVQpHHgAH9l1oED4uy/oMBp/ywAaDSAl+dSSXEiVqJJHSDwCab/UDDBmS/4fvdce2r5gy/wEDOIEHMKpRxBqNBjD+Q4lHq8oVb55em4UtPCYxR+kaCZTW34y03vgbUIvwgs/nw6Bo7kXx2KEK/MZmDDBu7TUJ0OeOQR7l+LBbr/bMLgfokYc30P9MyMh1bDuE13BAAWPMdn+6a6ehN27zmPPXtK0NiozlVqCCHEk5aWFtx11134+eefcdttt+HTTz8VfDMaGRmJm2++GQDw+eefu12en58PALjjjjuctk+ePNnpckdffvklTCYTJkyY4FYZcvbsWdx6662oqqrCokWLMGfOHL8fny/Wr18PABg+fLgk+xfbvHnz0K9fP6xYsQJ79+5VZAxLlizBc889hy+++II3COUzZ84czJo1C4cPH8aECRMwcuRIbN26FePGjcPGjRt5b7N+/XrceOON2LJlC4YOHYqJEyfixIkTmDFjBv72t7+J+IhEZDYD+fnOlVlaLfdeJD+fuzzY/W/a5LR/BgCsVmDTpuD3LxFP05r9pUTlV51rDzc/BBNEqYWY1U9iVpHJcSwIjTeQ6lslK78COQ49Pb9ihFOexqum1YvVMxISsl6euR7VZY2Cl//PikkY89urZBwR6XAKCoDGRmDAAGDfPiAvj/u3f3+goQEoKIBOp0XPngkYOzYTgwd1QWRkGIArFV8M95bSLQRz/N7Y1IqfCy9gz55zFIIRQkKGxWLBH/7wB3z33Xe44YYbsGHDBt5VwxzNnTsXALfi4IkTJ+zbd+3ahby8PMTHx+PBBx90us1DDz2EuLg4bNq0CRs2bLBvLy8vx9NPPw2AC3QclZeX49Zbb0VpaSnmzZuHhQsX+vSY/vznP+Oqq67CF1984bT93XffxbFjx9yuv2HDBjz77LMAgJycHJ/uQ2mxsbH49ttvMXjwYIwbNw7PP/88Dh06FNCn+oEaPXo05s+fj3//+98oKyvzOo1p27ZtWLlyJZKSknDw4EFs3LgRW7Zswfbt26HVajFr1izU1tY63aa6uhoPPPAALBYL8vPz8cMPPyA/Px/Hjh1D3759sXTpUvzwww/SPchAFRQArifFtmlvRmPw1VkFBUBrK5CZiZLXX8fJdetQ8vrrQI8eXPAlQvWXFBUXYk51k6M5umt1UjCVX2pt5u4PMY8JOcIvqVfTBMRvIC8GT487kPuWOvwSu1JNKuqbSE5Cyn/e3Yudm9zfhNrcO/d63PVotowjIh3SoEHAihXAww8DtlXBhgwBfvkFePdd7vJ2DMMgJSUGKSkxaGgw4fTpGlRXX3mj4xiC2f7blbGpDT8XXkB0VBgGDUpDTExo9TQghMiPW2RDvH354+2337aHRMnJyXjiiSd4r/fGG28gOZlbFXfChAmYPXs2Vq5ciauvvhq33HILzGYztm7dCpZl8f777yM+Pt7p9omJiVi9ejXuvfdeTJs2DePHj0dSUhK2bduG2tpazJ07F+PHj3e6zaOPPooTJ04gKioKlZWVmDlzptu4kpOT3XqTlZSU4Pjx425VGh9//DEeeeQRDB06FP3794fVakVRUZE9EHvqqadw9913+/rUKcrxk3KWZfHqq6/i1Vdf9em2DMOIMgXrmWee8ev6y5YtAwC88MIL9h5rABeiPfbYY3jzzTfx3nvvOYWgq1atQn19Pe666y5MnTrVvj01NRWvvfYapk6diqVLl7odO4obNAhYvBinevUC2x749O3bF2huBr791um9R8D7b39vU3/6NADAlJUFPPGE23ubQEVGuraFCJ7ribLVag24skPqaYQA16PMsVKmpSXwDzflGK/U1Fr5JVRJJeZ9iBl+yTFlV6PRiHY/UlfWear8UlPDewq/SMBO/XoJK/+yWfDycfcMxCMv3yLjiEiHlZICuKxWBoALwvi2t4uN1WPYsHQ0NbXi9JlqVJRfaRoqFHzZsOyVECwqKgyDslIRGytek1dCCBGLrdcVALdKKUeLFi2yh18AsGLFClx99dV4++23sXXrVoSHh2PChAmYP38+rr/+et593HPPPdi+fTteeukl7N69G2azGVlZWXjyyScxY8YMwbE1NTVh7dq1vPvMzMzkbczP5+GHH0ZKSgoOHDiAb775Bs3NzUhJScHUqVPx+OOPY8KECT7tRw1cTwjUdILAp7m5Gd999x0AYNq0aW6XT5s2DW+++Sb+85//OIVfmzdvFrzN5MmTodfrsW3bNphMJlGbqQctJQVYsADNhw9f2TZ4MPfvmDHi7D+A9zb+cFylVSyu4VdLS0vAIZsc0wijo6PR0NAgyr7kCL8YhlH9a4GNUODBsqzf1URCj1mOsC6QQFSOY0Gn0wUV1srJU/ilpopJCr9IQJoaWvCX8e8B4FZxZK0styxz+wvXVdnpWPDRvUoOkRC7qCgdBg9KRUvfNpw9V4OLpQ32yi/e6ZDt/2n7O9xkbMPPhaWIjg7DsKFdERkpXoNPQkjHwFpZ7m+hSPvyx6JFi7Bo0aKA7mvmzJm81ViejBkzBl9//bVP1w10OpvQ7e677z7cd999Ae1TbXydAqoWx48fR0tLC1JSUpCR4d7H1dZr7dChQ07bDx486HS5o/DwcAwePBh79+5FcXGx2yILnVEwlVSupKj8clVbWxvw/chxUizmcyDHeLVaraTBipjTCIX21dra6nXqvSuhCic5GvQHEjDJUfkVFhbWIcIvNa32SOEXCchrD29ES3MbGE37ix4De1IQHhmGt7c/otzgCBEQERGGAf1T0LtXIs6fr0NJSS2s7JXpjwwYsDyt8W3fG42t2FlwDgZDBIYNTUd4OL2EEkIICUyohV8lJSUAwBt8AVyFTXx8PGpqatDQ0IDY2FjU19fbp64K3S4jIwN79+7FuXPnKPwCYDQaRWsqL0f4VV1djfT09IBuK0fll5grEsoRfoWHh4sSfilZPdbU1OR3+CU0XjGDEzFXe5TjWIiIiIDRaPR+RRVQU8DlCTW8J347+vMFFHxZ7LActnPq/8/Cx5QZGCE+0um06N07ETfc0BP9+iZB0/56zbKs9147LFBX24Lt289i3/4LsFjkX6abEEIIkVtjI7e4UZSt9yaP6OhoALBPM7PdxtPtXG/Dp6WlBfX19U5fHdW5c+dE25ccq6wFE7LIEX7J0ZdKTHwLCgQShskVfvFVfzn+3vtKaLxihpdiBjRyVX6FCk8VhWqaxkvhF/HbqgXfArDNSUf7f2sAhkHPwV2Q0SdJwdER4jutVoPu3eNxw9heuOqqFOj1nv8osiy4rLf99b2m2oTvvz+NY8fKYeWbpmQyAa+9xv1LCCGEkIC88sorMBgM9q/u3bsrPaSQIMVqj2JyDXWkqB4RMwCUI/Dg63sXyAqVcowV4A9oxJxGKGYAJOa+hCq/5FpN05/KM7nCJ6HfNQq/SMg6c6Qcv/7Elb27HscMw+CdnQ8pMCpCgqPRMOiaHodRozJx1VXJCAvj/8N1pdoRTiHYhQv1+O67UygpqXZ+gV+/HnjmGWDDBmkfACFEcSzY9upREb7cJl8Tojxb8/SmpibB69im6Nim7Tk2XBe6nett+Dz33HOoq6uzf50/f96/wXdSag+/XCu/1D51SqnKLzErqcTGV5kVSFgnNF4xAysxjy8lG/QD/q1QKdexIDReNa2SSuEX8cuq+dsEL7vr0REID6dG4CR0aTQMunU14IaxvTCgfxKc/0ay9n8ZxuFbhxCsuLga3357Cpcucf1N8Pnn3L/5+VIPnRBCiEptkPgDkIsXL2L37t2S3gcA9OjRAwBw4cIF3suNRiNqa2uRkJBgD7Li4uJgMBg83s62PTMzU/C+IyIiEBcX5/TVkURHR4NpaUHy6tVgQqTBtRhcT4r97ROlNCnCRb4AIZC+T3JVfvGFdYGQo/JLzJ+Xkj3KAP8CRrmOBaEpqmoKtSn8Ij67dK4Whd+cAsBT9aUBnlw2SYFRESI+jYZBRgY3HbJfv0RwH+I4/sFkwNhePXn+9h0+XIHvvzwE1rYa2ldfASHSsJIQEhiWFfeLdBzTpk3D1VdfjXyRPwg5f/48nnjiCfTp0wfffPONqPvmM2DAAERERKCiogKlpaVul+/fvx8A3JrWDxs2zOlyR62trTh8+DD0ej369+8vwahDQ48ePRC3dSvSli9H3DbhD5o7GteTcjka9PPdb6Ck6KnGFxQEMo1QrmofqcMvNQUnjqjyy53QeOUK33xB4Rfx2T//vlXwsvkfT5NxJITIQ6vVoEf3BIy7oRf69kkEwziflDJMewjGAlEXzmDUAxMx5r4bMea+G3H9jAlgzGbuii0tQN++QGYm95WVBRQXK/KYCCGEyKtPnz44dOgQpk+fjl69euH555/HkSNHAtqX0WjERx99hEmTJqFPnz74f//v/8FisaBPnz4ij9pdZGQkbr75ZgDA57bKZge2cO+OO+5w2j558mSnyx19+eWXMJlMmDBhAm+vo06hrAzagwcRv349AHD/7t8PlJUpPDBhUoVUch0D/gQHnsgVfgUSXig57TEQQj2sxA6/pJ4KLFePMn8CUSX7vwHyLLzhK/WMhPgsNzcXWVlZyM7Olu0+a8qN+GnTMd5PpGPjI3DDnQNlGwshctNqNcjM5EKwPr0TwTBs++8CC6uF+51oiU9GW3QsIssvIrL8IiKqK5x3cukSUFLCfRkMQFqaMg+GEEKIrIqKivB///d/SExMxLlz5/Dqq69i6NChuOqqqzBz5kzk5uaioKAAJ0+eRFVVFaxWK4xGI86fP49Dhw4hPz8fzzzzDG666SZ06dIFM2bMwJYtW9DW1oapU6fi8OHDuO+++2R5LHPnzgUAvPTSSzhx4oR9+65du5CXl4f4+Hg8+OCDTrd56KGHEBcXh02bNjlNAS0vL8fTTz8NAJg3b54Mo1epvDxgxAjE7t0LAIgtLARGjOC2q5RU006lmvboevIdSA8tPlKsxidWUKD0VDd/CYVfYgcnQmGaWCuPinlMeHrsZtsH7D6QKwgVem7V1PA+dNbPJHY5OTnIyclBfX29vY+C1PKe+y8AuFW+AMA7ux+WZQyEKC0sTINevRKRkWHAhQt1OHmq2n5ZW3Qs9i7/FL0+zkXvj3PBMgw0Dm88rBoNGJZF7f88hYSlLwMhtHwxIcQ7W7N6sfYFANnZ2dBqtfa/+yQ06XQ6PPXUU3j88cfxzjvvIDc3F+fPn0dxcTFOnDiBDz/80Kf92I6LiIgITJ06FbNnz8bIkSODGtvmzZuxZMkS+/e2E6pRo0bZt82fP99evTVhwgTMnj0bK1euxNVXX41bbrkFZrMZW7duBcuyeP/99xEfH+90H4mJiVi9ejXuvfdeTJs2DePHj0dSUhK2bduG2tpazJ07F+PHjw/qcYSc4mJgyhSuJYLFAiQkADU1Vy5PSgJWrQLefx+IjgY2bgRUNC00JiYGly9fFn2/Uk1xi4iIcOqR5GnRBn+IFfxIQempbv6SK/zS6XS8Ddibm5t9/nl6em7FPIY9VampcbXHUJj2SGdfxJ3JBLz5JvCXvwB6PYz1Lfhu3RHeHiT9hqchrXuC/GMkREE6nRa9eiWia9c4nDxZhYsXGwAArDYMp/88G23RcRiQ979Ot9FYrTj26N9RMnkmmO/PIDs7A/Hx8vS2IISEpsLCwg7X2Lszi4mJwdNPP42//e1v2Lp1K/71r3/h+++/x9mzZ73eVq/X47rrrsNdd92FP//5z0hMTBRlTBUVFdizZ4/bdsdtFRXOlcwrVqzA1Vdfjbfffhtbt25FeHg4JkyYgPnz5+P666/nvZ977rkH27dvx0svvYTdu3fDbDYjKysLTz75JGbMmCHKYwkpqalcFfjRo/yXV1Vd+e9Ro3yuFleq2sdisYhy0i9V+BUZGekUfgXSQJ6PWP2upOBPOBIMocDDbDb7VcknNF6xpynqdDreZvEmk8nnv7eewiSxqwE1Gk3Qv9eebi/m80uVXyQ0rV8PPPMMkJEB/PGPeOepLQD4q75WfjdLgQESog4REWEYNCgVmZnxOH68EtXV3B/T2FNFsGq0YKwW2BaGZDVaxJ0+av89+vnnC9DrNRg9OhM6Hb0UE0JIZ6HRaHDbbbfhtttuAwCUlpaioKAAFy5cQEVFBaqrq6HX65GSkoKUlBQMGTIE1157rSRVJjNnzsTMmTNlud2YMWPwtW0hmM7OYAB27ACWLOG+AKc32axWC8ZqBRYsAF54wedqcbkCD9eT3MbGRlFmo0jVjyk6OhrV1Veq9cU6GVdz5RdfdZMUhCqzGhsb/Qrp5Qq/hAJLf1ZPlKvyy7a/YMMvT+MVs7JOrYsTOKIzLuLO1sQ0Px/mqfdi68eHwLJc+OVowh8H00k7IQBiYiIwYkQ3VFU14fivF9Dlp2+gsVpgDQtD6a33oOs366Fpa0OXn75B0ZwlYMO4T8JMJiu+//4M0tKiMXRoV4UfBSGEECV069YNv/vd75QeBpFbWBiweDEQHw+091KzYSwWYPlyYM4cv3YpVt8ib1wDiaqqKlWHX1JVaEkVfjEME3RAJ1cQKsRoNKoy/PJUqeYrOSu/wsPDg/699hSeybU6pVpQw3vizGgEtnCVXvjqK6x/lVvh0X2VO+CZd+9WYICEqFdSUhRGs6UIMzXB2L039uR+gaNzXsLut7+AMaMXwpqNMBz5xe12ly4Z8c03J3DpUr0CoyaEiKK955cYX7x9BgghHVNBgdMnzFy1uIbb7iexVjH0l1g9tKQKv6QKqaTaL1+I4G+YJVfllxB/ViMEhAMasY8JoeoksVZPFLv6SYxFIDyFdWI+v2quhLRRfzxHpOXYcBMAzGbA9svf0oKJL03HzVYuI22BDgsi/oiL2mRERKn/4CZECczgwcCKFdA/8CBSK1pgPF2Dxl4DsPudTej21To0ZvYTvO3Bg5dw5MhlXH99T0RG0u8YIYQQ0qGZzcCmTU6BNwMAViu33WwG/Dj59Tdw6CzEbpou9X4jIiLcqn1MJhOio6N93oec4RdfpZq/Qaxc/erEqE6SaxohIE6gJFdYR9Meifp5abiZYGmw//dRTQbqtLFgGAbT/nKdXCMkJLSkpACzZ0MLoHdsDDIyDDh1qgoXLgAldws39bX9IW1rY7F9+xkkJUVixIgMyT4FJYSIS8yCLSr8IkQdJG/UXFAAtLYCmZkoefJJmHv0QHhJCdKWLkX4pUvc5X6shKlU5ZfaSfVeSqqTfb1ej8bGRqdtjY2NfoVfcq6wp9Pp/Jo2yEeupuhSh0lyhl++LjQhZ48ynU4n2/TrQNC0x87O1nBzwQKu5NrlF9YCBlYAH+puwtzIh9DE6AEAf/r7jQoMlpDQEx4ehoEDUzF6dA/Ex+t9vl1VVTP++98TuHixTsLREUIIIUSIY5N0SQwaBKxYARQVIeaBB2DKykL9xIk48e9/c9sHDfJrd1T5JS+pQjW93v39or8rVMrZ80vqQElMYoxVrmmEgOdwytewW87wS4xpmlKi8Itcabi5dClXZu1ACxb/DL8dH0XcDCvD/XJodRrJynwJ6ahiYiKQnZ2BoUPTBBdtsv3BdPzDeejQZXz77Qm0tKj3UxRCCCGkIyorK5P2DtqrxREV5dQcnI2M5LanpPi1O6X7PHVkfAGCVOEX39Q8tU4jBMRZUECuyi9P57C+BoZyVn55mqbp6wqVnsYrdp8uCr9I6DhwAHBIf1lwlV+9rc5/+G+ePljecRHSQTAMg7S0WIwb1wc9e8a7XWZjewPALTTBwmzmVoX89dcy2d4cEEIIIYT4KtTen4gRDkkVfvEFCP6Oly/IkbNSTc2EAiVfF26Qs+eXGOGX3NMe1YzCL8Ixm4ENGwCLBdDpYHnwYbRBAy1YjG0rQhh75ZOkx/7vNgUHSkjoCwvToH//FIwdm4mkpCj7HyXXP07O37MoLW3AN9+cQE2NOKsqEULEI9ZKj/YVHwkhRMUiIyOdvg+1KZf+rlApdw8tKYjR7J2P1FMJxSY03vp631Zd93QsyDnt0dc+a54q2tTYoF9KFH4RTkEB0NgIDBgA7NuHXXfOxZORj+M8k4QomJFlOc9dTwPExAVf2koIAaKiwjFiRDcMH94NOp3zlEeWZV2qwbhtViuL3bvPY+fOM2hrk++NGCGEEKK03NxcZGVlITs7W+mhdHrx8fFO39fVqbtHqetJub/jlTOcESNA4Qs8pGpbIxR4qHUBBqFKNTEqv8QOvzz9zHwNnD2NV+xAlMIvEhpsDTf37weGDMEXuXtwVpuGnKgn8I/wSTin7QIAGHFzL2XHSUgHlJISjRtv7I1+/ZLBTTjmwi6rVfiPVX29GVu3nsCZM1VUJUIIIaRTyMnJQVFREQoLC2W/b39W2gsG09KC5NWrAZUGBzaxsbFO31dVVSk0Et9ERUU5fd/Q0CBwTX5yVn5JRarKL6H9uq5YqRZCfal8XaVQzmPBU5jm6zg89QLsbNMepfkNIKHH1nCz3fG9FwEALUw4NoaPtm9//HWa8kiIFDQaDXr3TkR6eiyKii6jvNy3VX2OHavE6dPVGD26J6Ki1P0Hh5COjKvOFG9fhBB16dGjh7R3UFYGfVERYnbsQNrbb6M1Lg66O+8E0tO5L5VxPclVezgUHR3tVO3l7+IAcn/QGB4e7vO0Nj5845Uq/BIKUIxGI5KTkyW5z2AINej39RiW+1hgGCao+6SeX1dQ+EXctLVZ0Grmnxvcva/6XsAI6UgiI3UYMSID5eWNOHSoDK2t3v8Qt7RY8OOPp9GzZzyuuqqLZA1NCSGEiO/kyZNYtWoVdu/ejerqauh0OmRmZmL48OGYMGECRo0apfQQCcQ/SXSTl4e+ixfbv9UtXsytxr5wIbBokbT3HYBQe68RbFN2ucO9yMjIoMIvPlKtxCd0LPjakF1uwQY0vq4KKRatVhvUSq5yrk4p1dRasVD4Rdx8veYX3u19r06VeSSEdF5dusRg/Pg+OHGiEmfP1vh0m7Nna1FSUovRo3sgLi7S+w0IIeKh0i8SgGXLluHZZ5+1n0zZPqE/cOAANm3ahIULF6Jfv3546qmn8OCDDyo5VCK1Rx/F6W7d0PuRRwAAVq0Wmh9/BHr3VnhgHUOwwY/cgUdUVJRbXzKr1RpUuCB3MBFMYCOlYMMvJaoAhZ7LtrY2rxV9no5dKULssLAw1f7s1R3NEUX8O2+v+0YN8OCLv5F/MIR0YmFhGgwc2AXXX5+JmBjPb9psK8RZLCx27izBoUNlHnuGEUIIUdamTZvwt7/9DW1tbWBZFlFRUbjmmmtw7bXXIi0tzf66XlxcjEceeQTXX389Ll68qPSwOx6TCXjtNWV6bBUXA1lZQGYmMGoUuj/3nP0ijcUCTJsGjBrFXZ6VxV2fBISvcs+fyiq5wy++SjVfe1IJEZru19l4quL05ecsd7DjKazzpXednKs9Auqe+kjhF3Fz4YRLw8r2QHj4TfTJEyFKMBj0GDOmJ666KoX3ctdPbViWxYULdfjmm2LU1Pi3lDchJDCsyF+k41u+fDkA7lPylStXorKyEvv27cPPP/+M0tJSlJWVYfXq1Rg1ahRYlsWePXswatQolJaWKjzyDmb9euCZZ4ANG+S/79RUwGAASkqAkhLoXJvGX7pkvwwGA5CWJv8YPQimakSJvkmuamtrfb693IEHX6VasA3kpZy6G0yIooZjwcaXMEnuKbCeQktfVi2Vc3VKQN0hK4VfxIm5pQ1WC8sFXrbfBQZgNKE1r5+QjkajYdCrVyJuvLE3UlKurDhlqwzgY7Wy2LWrBL/8chEWi7ob0RJC3GVnZyMrKwu5ublKD4VI4ODBg2AYBnPnzsX//M//uJ0wpKamYubMmSgoKMBHH32E6OhoXLhwAXfeeafqm4uHhLIybpXzd9/lvl+1ivu+rEy+MRgMwI4dwIIFAMOAdT0R1WoBhuH6fu3YAcTFyTc2HyQmJjp9789xqYaVqn0JDmyCrbryF99UNjWHX8E00xc6bqScphnMCpVyVwF6em596avm6fdSivBLqt5yYqDwizg5tPOcc/AF7pdCH0nt4QhRg6goHUaM6Iarr+6K8HDvL+EsC1y8WI9tX/6KxgVLVL90OiGhimv5xYr0xe2zsLAQRUVFyMnJUfbBEUnYTrLuuOMOr9f94x//iC+//BJhYWE4cOAA3n//famH1/Hl5QEjRgA//sh9//333Pd5efKOIyyMa2y/dCkY10DIYgGWLeMa3refAHv60MuR5A36AcTHxzt9bzT6tlI1oI7VIVtaWny+rtzj5Qslgg2/pAyTggk8hI5nqVanBITH60uYJHf45WkaYbBjofCLdGrHfr4ARsOAYRjuXy33C5HcNVbhkRFCbBiGQXp6LMaO7YWMDIPg9RzfS3TZ8Q1ilixAyYr30NYm7x9tQggh7mJjufdWvp4ojBs3Dg888ABYlsWHH34o5dA6LsceW6tWAQkJzpcnJXHb23tshZ89K9/YCgq4Kq92LABoNNz2dk1NTThy5AiOHDnidXdyTD1yvY+Kigqfbyt3gBAsNTTw5guJDh8+jMOHD/tUmSZl+CW0mibfz7mmpgZHjhxBfX09AOFgUcoVRSMj+ReGcgxErVYrb184uYNQf0LAtrY2lJSUOB0Pck97pJ5fJGSUn+ef59x/eFeZR0II8SYiIgxDh6bj2mszoNO5//FimCvvo9N3/hcAEP7vjfjmmxOorPT901lCiA+o6RfxU79+/QAAe/fyLDQk4J577gEA/Prrr5KMqcNz7LFVWgrUuKymXFXFbW/vsdWWnCzPuMxmYNMmp0+tGACwWrnt7Sfgp0+ftl/urWopOjra4+VicA1Tmpp87zPqGibJvRIhn/LyclS59l1rp0RYx1e95xi8mByq+Y8fP+51f1KGSUJhK99xWlpaCpZlUVJSAkA4nJGyelEorHN04sQJFBcXu1WDyR3WeXseHJ/jY8eOob6+3ul4kHuKMYVfJGRUXeIPv665qZfMIyGE+KpLlxiMH9/XqQrM8e9cWEsTUvbtAACk7N0OTXMT9uw5j4MHqRcYIYQo5f777wfLsli+fLnTSawnye1hjD+r1BEHDj22WB96bFljYuQZV0EB0NoKZGai5PXXceqjj1AzaRKQkcEFXw7VXzbeVv4UqmxRQlVVlT3wsHGtVJJyipsNXzhhCzJqampQXl6OsrIy3nBDifCLL6CpcQhsT5486df+lJj26DpVk2/qphLTHr1VRprNZvsxeurUKafLhMIvqcI6b8+D7ZhQQ3UiIM/vcqDUOzKiiJpy/mqQ/tdQ5RchaqbTaTF0aDpSU2Nx8qufMHRBDsJauE+qmLZWaFu5EyVtqxnjH74N1jDuU5lmfSTYLzYidsQQxcZOCCGd0RNPPIH33nsPv/76K6ZNm4Z169Z5rdYpKioCAPTqRR9KBqy9x9al5makv/6682UWC7B8OTBnjrxjGjQIWLEC+O1vYd63DzE7diDhq6/Q+vzz0JlMQHKyWz8tb/211BJ+GY1GlLUvImAwGBDTHii6hklyTNOMjo52C18aGhpgMBicVlG9cOECevTo4XQ9JcKvmJgYt59zVVUVkpKSPN5OicUEhKp9bOO3BUh8PbWEwiQpQxRv1UnFxcVu2ywWCzQajeyVahqNBmFhYYLhVn19PQwGg1tIpxQ1VHEKUe/IiCIaa/mb/HXr6/lFlhCiDqmpMRh5x0hoEuIRWVGGyIoy6Gsqna6jr6lEVEUZoirK0BoVi4LTLTh2rBxWK821IoQQuWi1Wnz66aeIi4vD119/jWHDhuGzzz4T7N1TWVmJF198EQzD4L777pN5tB1MWRmid+/mn2G8b5/cowFSUoDZs4EPP0Tf6dOR9vbbAADdyy8DS5cC+fk4c+aMX7uUo+G9NyzLOo3bMWBynQ4nV/jlqrq62m2brReVIyUa9EdFRblts1V9eurxJRTOSDntUeh4a25uRllZGZqbmwWbyStR+eVp33whU1VVFY4dO4aysjJFpmnaekTyMZvNTlOi1cAxAFNTGKaekRBVaGrgL6MPC6NDhZBQoUtORPT+PWic+yxYhoHV5Y+OVaMByzAo/sMTKPi/D9EaGY2TJ6vw/fcn0NDg+8pHhBBCgjNw4EBs2bIFKSkpOH36NO677z6kpaXhnnvuwcsvv4wPPvgAa9aswdy5c5GVlYUTJ07g9ttvx7x585Qeemh75x3E7dgB3ihg3Tpgzx6gvVpJVo8+itP//Kf9W6tWC8uPPwKPPur3rqQMOhwJhVYWiwUnTpxw2uYY2LiGN770YAoWXzWc0WhEZWUlz7WdKRF+eWoi76nHlxKVX1qtljdQslqtgn3UHK8jtE+pePr9qK2tddtmC708VVxKGdbFeJmCzfczb2lpUeRYAJwr69QUftG0R+LEbFLHXGFCSJDCwhCz9BW0pSUj7Om/OV2ksVpx5KFnceauP9u3sSyLpqY2/PjjaQwcmILevZNke+NMSEfAsqxobzKVerNKlHHdddfh119/xV//+ld89tlnqKmpwcaNG7Fx40an67Esi2uvvRaPPvooLl686DYti/jh6quFL2ttBUaNAhYuBHPHHUj6+GNUSVlpV1wMTJkCtJ9Ud3c4udZYLGi95x4wkZHo39YGq16PkjffhLlnT6+7letveEpKCi5cuGD/nmVZlJWV8VZUOXLtW+frqqfBEArqLl265LaNZVmn51CpQImPtzBJqb8h8fHxPgWJroTGq1TjdL7jwcbTQhNShl+BLGBRUlKCPn36SDAa78LDw70uyqEECr+Ik7bW0Fp2mBDiWdjhQ4BWC9ZiAYP2heQ0WsSdPup0PYZh7CfvRUXlqKgwYujQroiKUu+KLYQQ0lGkpKTgo48+wosvvoiPPvoIW7Zswb59+9yqY/bt24cpU6YA4PonDRkyBEOHDrV/DRkyhHeqFIFzyGSxwBIZCa3ANCxkZAATJiBu61akLV+O1tRUYMQIacZlW4HyKPd32fWvrq49TAgH0DR0qHwrUPrIdTrW+fPneacNunKdWibHNE2dTgeNRuNTFVd1dbXX3lpKKS8v93i5ElVqAPeaFEj4JTReqSuGtFqtqL3cpAxww8LCPPb94tPS0qLYsaDX69HQwC2kJ8eUZl+ppwaNqAJfzx+dng4TQkKS2Qxs2ABYLGB0OrQ9+BDYMB00VgvSd20D0yq8WlhFhRHffnsCFy96fwNLCOFWWBXzi3ROvXv3xoIFC1BQUICGhgbs3bsXq1atwpNPPomxY8ciNjbW/kFFbW0tduzYgXfeeQePPfYYrr/+ehgMBu930lnZQqaSEqC0VDj4AoBLl4B77kG3BQsAAIkffwzs3y/NVEiHFSjBswIl296qoPzxx3F67Vr5VqD0kWto5UvwBbg3kJdrhbhkH8NDT72d1MoWlis17kCmrrIsq8i0R0D8qbZSj9dT3y8hSoVfjoGXWhbfACj8Iq54XisTU/3/RSOEqEBBAdDYCAwYAOzbh7BV74LZtxfmXn0Q1mxE4rEDTld3miLR/lqwb98F/PJLKdralPnjSQghnVV4eDiGDx+OBx54AG+++Sa2b9+O2tpanDx5Evn5+Xj++ecxefJkdO3a1R6IKXWiI5fc3FxkZWUhOzvb/xs7hkzgfct7RVsbUF4OTXuYEP3rr1zlV16e//fri/YVKLF0KRiX4IKxWtEwbhwqHnyQu14HJVdfIH+quZTq7xQoW/Co1OsAwzB+T89ra2sTDOukPibEDmWkPibi4uL8vo3r9GK5OFbBqWn6o/p+a4lihF54uvdTZ8kvIcQL29LpDz8MtE+DYYYORfjhQzC99Q9YBwx0u4lt+qN9jiSACxfqUFlpxMiRPWAwSN+QlhBCiLDevXujd+/emDp1qn1bVVUVDhw4gAMHDig3MBnk5OQgJycH9fX1gVW52UKm+Hgwc+f6d9ukJGDVKuD994HoaGDjRqB/f//H4ElBAcAw9vJP2zvzuB9/RNLatWgcOxZtKSloS0lxu2moB59y9SjTarU+T3crKytDv379eC+TK6zT6XQeV3Z0VFNTg6SkJEWPheTkZI+hoauWlhbBqXxSHxNih19SV34F0vfL10pMsTn2awtk3FKhyi9iV325kXd7nyFpMo+EECIK29Lprv1foqKgf2YeRt1xLfr04cJtx2bdbm82WMDU3Ibt20/j9OmqkJsGQAghHV1SUhJ+85vf0CqQvrKFTP6oqgJKS7lpkwYDkCby+2OzGdi0yWneM9P+BQBpb72FvtOnI/Hzz3lvLmbvoo6ua9euPl2vpaVFMMiRo0E/4F+1j8lkAqBsEOptVUJXRqNRsZ5fYveikjr8CuT5UCr8UmNlJEDhF3Fw8TT/qix9r6Hwi5COSKvVYODALhg1qgfCw6/8OeALt9j2/zt8+DJ27y5BSwutDEuII1uALNYXIUQiPCGTT7RaLjBbuJCbPhnAFCSPCgq4lSYzM4F//AP1r7yChmuvtV/MMgzOrlyJ6t/9jvfmvlYHEf8CpcZG/uIAuVYiDKTPkz9N0cXmb7VWU1OTYHArdeWX2AGmHNWA/larKXUsMAxjDwOp5xdRpbIztbzb+wxJlXcghBBZJSdH4+ab+6FbN8OVk26ecwLbJAyuGX4xKir43xASQgghquUQMpW88gqsvlZrWCzAsmXAokXS9N4aNAj4+98BvR545hnEPfccYvfutV/MsCx6PPccet93H/rfeiv63nknt4JlOyXDL75pTQMHurdWUAt/QhWh8EuuFewCCQ6U6vNkwzdmoefcZDIJBjRSh0kajUbUgE2O8Cs+Pl60fckVLioZxrqi8IvYlZ+v492elhkv70AIIbLT6bS45pquuObqbl66AHNaW1ns2nUOR49e5l0llhBCCFElWz/MoiLE9O8PjcWClvR0nH/5ZWDePOCf/3RrF8ACXOWXlD3VUlKAp58GEhIAgalKmqYmhJeVIbysDNbYWKepl0oGHunp6W7fa7Va2fp4BSLKtSWEANtUQldyTXsMZCqd0v3funXr5rZNKMSzWCyC45Xj+LGNKyEhIeh9hVr4JbWYmBjExcVJPh3UHxR+ETuLhf8EtrlR2U8PCCHyYBgGGd0NGH9TH0RF8X2q3d4TrP2LZYETJyqxY/tpNDfTdAvSubGsuF+EEIk49MNMGDsWZc88g5ObNqHuzjuBN94AZsxw/yXUaLjKr/x8btqkFIqLgdGjub5iHqblsQDa4uNx4cUX0eYQ4DQ1NUkzLh+4VkHZVlRU84l6Zmam0/dXXXUV7/WEpqHLNe0RuBK0paeno0uXLgC492xCUyKVngKr1zsvjtSjRw+3bY6UDOu6du2Krl27ugW4KTyLSngjR1jnGiTxBY2B7ktsqamp6NGjh9994KRE4Rexi4rh/wTjbFG5zCMhhCgpNjYC42/qi8zMBJciMC72sjfGB3d+UFtrwrfbTqC8nKZBEiKm7OxsZGVlITc3V+mhENIhMV26oOr++8G2V39YrVZuWmRzs/P1bCfnRiN3uRRSU7lG+ufPC1Z+AdzfXnOPHmhLTUVd3ZVZG80uY5YTwzD2Btc9evSwb09OTlZqSF65nvj726Bbzobeffv2Rf/+/ZGUlIQuXbrgqquuQlZWFhITE92u66mSSimxsbEeK+2UHK9er0diYiI0Go3T9F1byKhGtmOXYRgkJCTwHge+kGvFUjVRZxt+ooj0XvG8ifX5E1UYNKoHzy0IIR2VVqvB0GHpSEqOwv59pQDawy6wYBiXAIwBLFYWuwrOYcBVKRgwIEXVUx0IkQILn2YM+7wvACgsLPSrMTMhJDjHjx/HwEGDgMWLgd/8BidLS+2X9e3WDfj2W27apBQMBq6R/pIl3JdAxVFz7944vXYtEBaGiooKe5WV0n11+vXrB4vF4jQdUK6+WIGKi4tDfX29PejQ6XQ+V03JGRxoNBqn59UWvPFV1JjNZsWPBQBITExEdXU1EhISwDCMx2NBLYu89OzZE+fPn0dcXJyq38d27doV58+ft1erpaWlobqaf+E6Tyj8IiEhNzcXubm5oi9p3L0//6czJcerRL0fQkjo6NbNgHhDJAoLS1DfwE31cHyT4vRhHQMcP1aBqkojrs3ujogI+hNDCCEkdFgsFm5a5IIFYFkWpiNHrlw4eDAwZoy0AwgL44K3mBiu/xePiJISMCzLTX9UQchho9VqeadRRUdHw2g0KjAi77p37w6r1Woft16v5w2/+MIZNYQjfGPwtHqinNLT05Gammp/bj1VyqmlUo1hGKfKRbUyGAyIjY21h1eBhlhq6sUll84X93UAOTk5KCoqQmFhoaj77dqbv9EfTXskpHOLjgnHDeN6o3evRLAu70+c3nexXMVKZWUTvv/uJKqqlOs/QojsWJG/CCGKUjRY2ryZf3tkJDRtbYiSsvG+yFwbiaulygfgwg7HAEBoap5awy8+RqNRFeGX63PrKWhR0zHhSM2VUWKMTc2PTyqd7xETQbpw/kT+8tlaeQdCCFEdrVaDwUPSMPK67k5v+Nzer7AAGMBksmDH9jM4ebJStW9qCCGEkJ49e/Jur6pSaOaD2SzcV6ytDWV/+xtMffrIO6YguE7NU3JVSm86QvjV1NSkmkoqR56CFrW+TwylcCiQHnRy9q1Ti9D5iRJ58LyO11cr10CTEKIu6elx+M2EvuiSGgOh91aO1WGHf72Mn/eUoNWs/KeQhEiJZVlRvwgh8hBaiayyslLmkbQrKABaW4HMTOCzz4B9+7h/e/QAWlthysqCJcAG10pwPcFubFTv4jiOfbUcqTFMEqKmqbC+UuvfPKHjQY0CWX2Uwi/S6WnD3A8JU7N6P6EhhMgvKioc2dnd0asX/1RpV2Vljdi37wLq60wSj4wQQggJjuJBx6BBwIoVQFERMH06MHw49+/Ro8CKFSFV9cXHcYVKtREKAxQ/JkTQGYOOYAUSKCklkKCOen6RTk8f6f7C2GZWZxpPCFGOVqvBsKu7Yvjwrh6uxb12sCyLsrIGfPfdKZSWqvdNLyHBYFlxvwghyigqKlJ2ACkpwOzZgOsUvKgoYPZsxIV4+NXcrN4ZJUJTGX1dAVLN1DCFT61TRYWEUvgVSLgZSo9PLMr/FhBViUmIVHoIhJAQ0iMzAeNv6g2hv5+Opewsy+LnPedRdOSyakvcCSGEEDVLDKEpj3z4/v5HREQoMBLfqblPma/UUOXjTwCnhqBM7celo0DCLzUcE3Kj8Is4SUqPVXoIhJAQEx8fiVtuHYDUVNe+KcyV1SBZFhpzC/ptXI0Tv15Awc6zMFMfMEIIISEgOTlZ6SHYdcRqDb1er/QQPGpqUu/q1b4GGGoIOvwZgxqmaYbS71ogP181VAPKrfM9YuJRaneD0kMghISg8PAwjBrdA1cNTAEA3qbdXXdtxeAPl6Pr7q2oqDDi++9Por6e+oARQgjxTW5uLrKyspCdnS3qfnv16uXx8pSUFFHvLxhqCAXEJrTogFqoeaqmr72e1NC83Z8xqCF4UsMYfBXI6wKFX6TTy+gb2qXUhBDlMAyDq67qgtGjeziUq18pW++265v2f7eCtbJoMprxw/encPFivQKjJYQQEmpycnJQVFSEwsJCUfcbHR3t8XI1VM14EuoN2dUefql52qOvU/PUcAz7E36pYbyhFA5R5ZdvOt8jJh517UPhFyEkOKlpsbjl1n6Iiwvnqr9YFlpTE1J/+Ym7fP8OaE1NAAtY2qzYs+scjhZRHzAS2mzVjmJ9EUKIL1iWDfmG7GoIOjxR82uyr1NG1VD55U8PLTVUOIZSj7JAni+lx6wE5Y8qoirdevOHX3VVTTAkRfFeRgghrqJLz+Lm/7kL5tp6WNpYaNpaoW3j3pxr21px65O/hTWMKydvi9BjzzMrUVs7FNdmd4NOR3+aCCGEEF9YLBY0NjYqPQy/uIZJnfEkXCy+hl9qCJP8GYMaxutP+KV0gEuVX77pfI+YeJTg1rAaAANcPF0t/2AIIaErNRVMfDwiLl1EVGUZ9LWVThfraysRVVmGqMoytEXFwhSfjOqqRvzw/SkYjeqdXkCIEBZAe6Fj8F9KPxhCSMior69Hfb1z+wA1BAeeqDn8CrVAwNeKLqXDGX/HoIbx+nNcKj3eQO5fTb93cgmt324iubikSOcNDMAwwKlDl5QZECEkNBkMwI4dwIIFAMOAdXkzadVowDIMjv7uMWx/aQ1ao2JgNlvR2GDG99+dQFWVUaGBE0IIIaGjpqYGRqPz30w1THFzFBvrvJq8mnuUqT04dOVr6KGGUM+fgCaUms0Dyv/OMQzj98+Ywi/S6YVH8LzgM8Deb0/JPxhCSGgLCwMWLwaWLgXj8kZXY7Xi1xl/w7HpT4DVhgEOVS+tZit2/Hga50tqFBo4IYQQEhr4ViKMjIzkuaZy4uLinL63WCwKjcQ7pUMMf/kaeChdmeTvGELt56CGsM7fMVD4RQgAjdb5F4FhGBzZc16h0RBCQt6BA4DDGx4WgFWjheHMcd6r20KwvYUXUHSEGuGTzis7OxtZWVnIzc1VeiiEkBDibfVKubmOp62tTaGReKeGEMMfvgYYagg6OnL4pYbxqiHgVDsKv4ibxPQYwOX10VhHPXgIIQEwm4ENGwCLBdDpgEceAXQ6aKwWdN2zDUxrK1hw06s5XNBly7uOHytH4c/nYbGod4oEIYA0qz0WFhaiqKgIOTk5Cj86QjoXNYczvvBnVT05uAZKan5+1fbciUUN4VcoNZD3lxqOm1B7zpRA4Rdx0zMrBWABRgsw7UcIFV4QQgJSUAA0NgIDBgD79gF5eWD27QP694fO1ITE4wfsUx5dcRVgLC6cr8WOH0/D1BzaS7kTQggJDceOHVN6CEFRW98q1+DFbFbvh+q+rp4YatTQ80sNAZxU1FAxqLbfezWiZ4i4mTTzGuz79rTTNoYBLpyqREafZIVGRQgJSYMGAStWAA8/DERFcduGDAF++QV4910Muu1mbD/S4BB+Ob8xsm2vrW3C99+dxPVjesIQr65eJoQA7as9irgvIp2SkhJZ7qdHjx6y3A8hrtQQdHjS0tKi9BAEqSHE6Mg0Go3XBQ9CMSRTQ9WVGsagdhR+ETfDbugJhmHAsqz9xYdhGOT+7b945Yv7FB4dISSkpKQAs2e7b4+KAmbPRhKAWzJa8N23xWhrZcGFX1f+tb0WWSxAS0sbtm8/hWuzeyA9Pc59n4QQ4oOePXtKfnLFMIyqp3YRd927d8f589TjVg4mk0npIQhSe3AYKLUESlqt1mv4pYYphP5SQ/BElV/edczfbhKUqJgIaMMYtxfJQwXyfFJKCOlcYmIiMPH2gYiNDYdj8HXlX47FwqLVbMXOHWdx+lSVMoMlhHQIYvdoE+rbRkKHwWAA09KC5NWrwai4MskXagk6hKg5GFZDiNGR+RLQxMbGyjAS33TUBQU6K4oHCa8eVyXjzOEK543Ub5oQIpHw8DDcPKE/ft5TgrKLtmmQLBiGm3ZtO4+0Wrnv9+8rRXNzK7IGpariDQchNO8xtDAMgyVLlqBbt26i7re0tBQvvPCCqPskMigrA8rKkLRmDdLefhtoa0Pj2LFoS0lBW0qK0qNz48vUMTVTc/jVUSu/1EKn06G5udnjdWJiYmQajXe2GQi+XE9pVPnlHT1DhNftf74G7zz9jdv2tlYLwnSUKhNCxKfVajBqdCaOHL6E48e48J1l4RKAse3bGBwtKkdTUytGXJsBjUb5Nx2EkNAyZcoUZGVlibrPI0eOUPgVivLygMWLkdb+bdpbbwFvvYXyxx9H+RNPKDo0PgaDATU1NbyXRUdHyzwaQnznS3WSmqY9+jJNUy2o8ss7irYJr+xb+vJuX7d8p8wjIYR0JgzDYPCQdIy4NsNxa/u/Vz55s30Kd+5sDXb+dAatrRb5BkkID1bkL0KIjB59FNi61f6tVavFqbVrUf273yk4KGGepoWlpaUJXkbEQSFD4HypTlLT8xtK1VShNFal0DNEeHXJMLi22wEAbPpnIe57epwiYyKEdB49eyUiKjocO348bV98g6soZx1WhuT6gpVfbsSPP5zG2LE9oY+kVZoIIZ79+c9/BsMwSEhIEH3fCQkJ9v0TlSsuBqZMAYxG7nuHJuwaiwU95s0Da1v5Lz4e2LgR6N9f7lHy0uv1gpdFRtKKyFKjFSED50uwpabXz1AKlNQUGqoVVX4RQcnp7p8qGevMCoyEENIZdekSg1tu4040rFYu9HJvu8DCamVRX9eM7747ifp69a4gRTo4MRul+9ksvampCRs3bsSDDz6IAQMGQK/XIzo6GsOGDcOLL76IxsZGwduuWbMGI0eORExMDBITEzFp0iQUFBR4vL+dO3di0qRJSExMRExMDEaOHIkPPviA97qXL1/Ge++9h7vvvhsZGRkIDw9HfHw8brzxRqxduzbgxvBHjhzB7373O6SkpCAyMhJDhgzBihUrfJqesmbNGrz//vtIT08P6L496dq1q33/RHy5ubnIyspCdnZ28DtLTQUMBqCkhPsqL3e6WFdZifCyMoSXlXHXU1FFVSidkHdE9PwHLtQCmvDwcKWH4DONRqOq4FCNKPwign5zZz/c07QdOrbVaTutYEQIkUtcnB6T7xiIiAiNx9cei4VFi6kV3397EpWVRhlHSIjyPvnkE9x9991YvXo1tFot7rzzTtxwww04c+YMFi5ciOzsbJS7nNgDwJw5czBr1iwcPnwYEyZMwMiRI7F161aMGzcOGzdu5L2v9evX48Ybb8SWLVswdOhQTJw4ESdOnMCMGTPwt7/9ze368+bNw0MPPYQvv/wS3bt3x9SpUzFkyBD89NNPmDlzJu69915YLP5NW961axeys7ORn5+P3r17484770RlZSX++te/4ve//z29T+nAcnJyUFRUhMLCwuB3ZjAAO3YACxZcaS7pgNVowDIMyh9/nLteXFzw9ykSasouLW/PL1XXBY7CL+kwDBNyz6/c6JWTCLo18iQeaNqC61uOOG3f/8NphUZECOmM9Hodbp+chdg4/gaotvOVtjYWLICDBy7iYmmdfAMkBLBXJor15Q+dTodHHnkERUVFKCoqwr/+9S9s2bIFx48fxzXXXINjx45hzpw5TrfZtm0bVq5ciaSkJBw8eBAbN27Eli1bsH37dmi1WsyaNQu1tbVOt6mursYDDzwAi8WC/Px8/PDDD8jPz8exY8fQt29fLF26FD/88IPTbZKSkvDyyy/j4sWL2LVrFz777DPs2LEDu3fvRlxcHPLz8/Hee+/5/FhbW1tx3333obm5GcuWLcOePXuwbt06nDhxAqNHj8bnn3+OtWvX+vcEtnvxxRfx4osv4r///W9AtychKCwMWLwYWLrU7RePsVpx6amnuIb3IVLpM3jwYKWH0CF4C788TTtVQigFHqE0VkB9P2tvqCrRMwq/iKDUPVzjz7Hmw07b353/rRLDIYR0YmFhGtxy6wCkdPG8/HWr2YKGehN2fXccNc8ucurhQkhHNWPGDOTl5WHgwIFO29PT05GbmwsA2LBhA8zmK60Lli1bBgB44YUX0K9fP/v20aNH47HHHkNtba1bKLVq1SrU19fjrrvuwtSpU+3bU1NT8dprrwEAli5d6nSblStX4u9//ztSUlKctmdnZ+PZZ58FAHz66af/n737jo+i3Bo4/ptN750mEHoJHaRLEWmCVFFUFEHAhgriVa9XEUTsiKAGRaRb6byAoPQWSigB6Z2E0NN723n/WHZJr5ttOd9792My9eww2Z058zznKfZ7Xb16NZcvX6ZFixa8+eabhunu7u58//33+cZQXFOnTuWjjz4iLS2tVOsLKxYSkqPll4qu5ZdLWJjZQhLmU1QCwdISOJY0OmJRLO3YFcXakknFPb4VtXukJL9E/pKSUP7eBMCD6WdxUu9fMEecjTJXVEKICkyjUejarQ41anoXulx6ehY1D23D54uPuBm8yCSxCWGpWrRoAUBaWhpRUbrv75SUFLZt2wbAsGHD8qyjn7Zu3boc0zds2FDgOv3798fZ2ZktW7aQWsyksz6269evF2v5omJo3bo1derU4cSJE1y5cqXY29Tz8/MDoGbNmiVeV1ix9HRYuzZHyy8FXcsvz23bUDIyCl5XlJkltqwpKuFhackma+qGKcmv8lXceCtq12mj/mveuXOHS5cucfPmTZKSknBwcMDb25uaNWtSr149qzvZK5TcI96kp8O9J5+OZPFz9AwyFd2/X6riCOcet5gRb4QQFYeiKLTvEIiLqyNnT99GUXL3VNH9UjVE120p889lnOwzmKAmlSvsUy5RsV26pCtV4ODggK+vLwBnz54lLS2NgIAAqlevnmed1q1bA3D8+PEc048dO5ZjfnaOjo40bdqUQ4cOce7cOZo3b17s2KqUoJB4YTHop1+6dInjx49Tq1atYm8XoF69ehw8eJCbN2+WaD1h5UJCICMDAgMJf+010mvWxDE8nCpff43jzZu4hoVBq1bmjtJm+fv7mzuEPIqq82RpiQM3NzfDww1LZ235AEv7ty5KcY+vtb0vYylT8ispKYm1a9eyceNGdu7cSWRkZIHLOjk50apVK3r37s2QIUOKdVEkTEg/4s3p0/nO9lUT9feUnLavwcU7UFdyX0IIM2nevCouzvaEHY0EFEMSTFXBLjWFqmF7Aah6dA8HD18hPT2Llq2qSQJMVDizZ88GoG/fvobWCuHh4QD5Jr5AdyPl7e1NTEwMCQkJeHh4EB8fT1xcXKHrVa9enUOHDnH16tUir/MyMjKYM2cOAIMGDSr2+ykqdv30q1evFnubesOHD+fAgQMsW7aMvn37lnh9YaWaNIFZs2DcOOLvJWRTg4JI6NYN35UrSa1b17zx2Thvb29zh5CHtSW/LLH1XEH0IxJay8Ak1nbd6O3tTWpqKsnJyYUuZ23vy1hKlfw6evQo3333HcuXLzcc2KJO4NTUVPbt28f+/fuZNm0aTZo0Yfz48Tz33HO4urqWJgxhTPoRbz7+WPdSFMg2XHgWCgoqv7v04A/Xh2n7QxgfdpbslxDCfOo3CMDZxYF/V+zkoRlvYpeeAoAmMxO7TF03FbvMDB6dOACtvT3pdhocfTxR1q6VlqvC6FRVNdrFvH478fHxOaY7OTmVqLvNX3/9xfz583FwcODjjz82TE9MTAQo9PrLzc2N2NhYQ/JLv05h67m5uQGQkJBQZGyTJ0/m9OnT1K5dm5dffrlY76c4sZckhtxeffVVFi9ezJIlS+jatSujRo0q8TaEFQoIgAkTAF3B+BMndLVuVRcXop591pyR2ZSAgADu3Llj7jCKxZpG+APri9fOzo7MzExzh2GTXF1dDd3/C2NtLfCMpUTJr6NHjzJ58mQ2btwI3L84q1KlCu3ataNNmzZUqlQJX19ffHx8SElJITo6mpiYGM6dO0doaCjHjx8nIyODEydO8OqrrzJ58mTeeecdXn/9dYvrP13h6Ee88faGSZNyzLJD5Se3/qx16QzAoW0y4qMQwvxq1PDGZcCDpM9xx//65XyXcYm9a/g53q8Sbv6VqJhf+cLa1KhRI8fvU6ZMYerUqcVa98yZMzz77LOoqspXX31lqK9lCf744w++/PJLnJ2d+e233yzmIejNmzf5+eefGTNmDGPGjOG3337jmWeeoXnz5vj4+BR5syC1woQoWOXKla0m+VXU37q1tZqxtHgl+WV+kvwqwujRo1m6dCnae62BWrduzYgRI3j88cdL9GWfnp7Orl27+PXXX1m9ejV3797l3XffZc6cOSxZsoSHHnqo5O9CGFdYGNjZQVYWoOvtqEWhTub9grRZGdbRVFUIYfv86z1A7N49nHzlbYJWz0NFQaPeb7mq1WhQVJVTQ1/kzOPj8A27y0MPeeDgWDG/+EX50He7Nda2ACIiIvD09DRML+5DwsjISPr27UtMTAyTJk1iwr1WLXru7rpRUwvrFpF0rwaoh4dHjnX062WPq6B18rNt2zZGjRqFRqPh999/p0OHDsV6T9ljj4mJKTD24sRQkFq1ahluElVVZevWrWzdWrwRrhVFkZs5IWyErSUGLK2bpq0dX2tkaeeEqRT7XS9evBh7e3vGjRvHmTNnOHToEG+++WaJn3I5OjrSs2dPFi5cyK1bt1iyZAkNGzbkypUrhpGHhBmlp8OqVbrEl4MDvPgiqp09dqh0SjuJvXr/wu7qGet4eiOEsH3elTypuWg2x56dlCPxBaDRagl79i1OPP4yWYodCfEp7Nt3lbQ0uVEVls3T0zPHqzjJr+joaHr37s3Vq1cZPXo0M2bMyLOM/trt2rVr+W4jKSmJ2NhYfHx8DEkkT09PvLy8Cl1PPz0wMDDf+aGhoQwaNIj09HTmzZvH4MGDi3w/JY29qBiKkr37qv7n4r4qku7du6MoSoGvTZs25bveokWLaNeuHe7u7vj6+tKvXz9CQkJMHL0QhZPkTPkq7Pg6ODiYMJKKq6Ie52K3/Hr11Vd599138zTBLwsnJyeeffZZRowYwfLly8m619JImFFICCQmQsOGsHw5NGtG1JCRpD02mOpZd2mcEc6/jnUA+OG9v/l8tdRCEEJYBg8PZ5pm3dS19NJqUdC1XFU1dnhfOQvoWtSkpmZx53YC27ddoPvD9XB2tq5hrIUoSGJiIo8++iinTp1i6NChzJs3L9/uLg0bNsTJyYk7d+4QGRnJAw88kGP+kSNHAPIUrW/RogW7du3iyJEjBAUF5ZinL2nh7OxMg3xq6p06dYpHH32UxMREvvnmG0aPHl2q99iiRQuOHTvGkSNH6NevX575BcVeHAsXLixVTBXZ448/nqNVoF7ucwpg4sSJzJ49GxcXF3r37k1qaiqbN2/mn3/+YcWKFaVKhgpRHmytVYy9vWVd5xSW/PLz8zNhJBWXpZ0TplLsd/3999+XWxCKovDkk0+W2/ZFCWQb8YZ7NTj8+3TiyYAJ9EzYz1X7SoZF/90TYaYghRAiH+np2P/fWtBq0drZc6n7IGrvWIsmK5PqoVs5NG4yWnsHtFoVFUhOSmf71gt071EXF5eK+QRM2I60tDQGDRrEwYMH6dOnD7///nuBNxguLi706NGDjRs3snz5ciZOnJhj/ooVKwAYMGBAjun9+/dn165drFixgmdzFQJfv349qampPPbYY3lGHrty5Qq9e/cmKiqKqVOn5tlfSfTv358lS5awYsUKPvjggxzzjh49yqVLl2jatCm1atUq8baff/75UsdVUc2YMaNYx3rLli3Mnj0bPz8/9u3bR/369QHYt28f3bt3Z/To0XTv3t0iR/4TFY+tJb8srZWPq6srsbGx+c7z9fU1bTAVVEVt3Whbf9kVRHBwMEFBQbRt29b4G9ePeJOt+KyiKLTsG8T/uXQmXuMOCrrRIIFb4bHGj0EIIUojW8vVrIOhHH3xAzZ/+hvxVQNxSE3G79wxQNX9X6uSkaElNTWD7VsvkJycbu7ohbXTF/0y1qsEsrKyePrpp9m2bRtdunRh1apVRY7+NenewDbTp0/n/Pnzhun79u1j7ty5eHt7M2bMmBzrjB07Fk9PT9auXcuqVasM02/fvs0777wDwFtvvZVjndu3b9O7d28iIyN56623mDJlSrHe08iRI2nUqBGrV6/OMX3IkCHUrl2bY8eO8c033ximJyUlMX78+HxjEOY3c+ZMAD744AND4gugY8eOvPzyy8TGxjJ//nxzhWeVcrfc0HdLFmWnKIpNJcAsbVA5X19fGjdunO88azzu1hiztPwqZ2lpacTGxhIQEGCVJ4glGT9+POPHjyc+Pt5kX3Rjpz1CyIZz6DoR3aPA1GeX8cOuF00SgxBCFCpby1UHV1cGNcti3Vr459PfqbNtNfHV69zPKaigopKenoWicK8FWD3c3KxruHAhQNc6X58k8vf359VXX813uRkzZuDv7w9Az549mTBhArNnz6Zly5b06tWL9PR0Nm/ejKqqLFy4ME8rHF9fXxYsWMCTTz7JsGHD6N69O35+fmzZsoXY2FgmTZpE9+7dc6zz0ksvcf78eVxdXbl79y6jRo3KE5e/v3+e2mTh4eGcPXuWuLi4HNMdHBz45Zdf6NmzJ5MmTeLPP/8kMDCQ3bt3c+PGDYYNGyYtuCxMSkqKoa7vsGHD8swfNmwY3377LevWrZPEZQm4uLiQkJBg+D2/QShE6dnb25OebhsPxizx3tuWWh5Z4vEtii0d/5Ioc/IrMTGRXbt2AdC1a9c8/f7v3r3LSy+9xPr168nMzMTd3Z2xY8fy6aefWlwWWhSscg0vnFzsSUvJXiBaIfxMtNliEkKIHPQtV+9xcLBj0JDmrPu/E5zr+7SuEDNqngRYWloWqqoaukC6u8t3kyi58hjtsbhiYmIMP+duKZXd1KlTDckvgFmzZtGyZUu+//57Nm/ebBiUaPLkyXTq1CnfbTz++OPs2rWL6dOns3//ftLT0wkKCuK1117LN+mkjy05OZnFixfnu83AwMB8C/MXpFOnToSGhjJlyhR27NjBsWPHqFu3Lm+//TYTJkzIt86ZKB/z588nKioKjUZDgwYNGDx4cJ7BsM6ePUtaWhoBAQFUr149zzZat24NwPHjx00Sc3EpaWn4/for9vdaSVoaNze3HMmv/GqvidKzxoRGQSyt26O1URSl0EFNrDGnYUvnd0mUOfm1cuVKRo8eTfXq1bly5UqOeVqtlkcffZQjR44YTpiEhARmzZrFlStXWLlyZVl3L0zosTFtWPn9gTzTD/5zgXa965khIiGEKJydnYaBg5qyYf0pkhIzyHNPrOpGdEtLzUKjUdi29QIP96iHh4f1XciIimvq1KlMnTq1VOuOGjUq39ZYhencuTMbN24s1rI7duwoeVDFWK9JkyaG2mTlISEhgS1btnDs2DHu3r1LSkpKoTc/iqJUyG5706dPz/H7f/7zHyZPnszkyZMN08LDwwHyTXyBLonj7e1NTEwMCQkJhhFGs0tLSyMtLc3we3x8vDHCL5Tn5s1U+eYbtK1bw7OWN8CTi4tLjt8rakuO8mJLx1OSX2Wj0WgKHZjPGpNftnR+l0SZk19///03oKvBkDuD+Oeff3L48GEURaF169Z069aNnTt3cuTIEdasWcOmTZvo27dvWUMQJjJ8Ysd8k18zXl3LsgvSTF0IYZk0Gg39Hwti44bTJMQX3IUhJTkTV3cHtm09z8MP18PTy7nAZYXIzZwtv4TxaLVaPv74Y77++muSkpKKtY6qqhUu+dW1a1fGjh1Lp06dqFq1KhEREaxYsYLp06fz4Ycf4unpyYR7LXETExMBXZHrgri5uREbG1tg8uuzzz7jo48+Kp83k4v9nTvY37mD972H9JoFCyAoCKpW1b0shDXecFsTW0oOSGvYsikq+ZV7kBdrUFHPiTK3dztx4gSKouTbPH7JkiUAtGnThv379/P111+zb98+2rVrB1Bg83dhmdw8nfEOyHvhkhSfQXpaZj5rCCGEZdBoNDzavzHuHoXX9EpOzMDBXsP+fVeJj0s1UXRCCEsxatQopk2bRmJiIhqNhoCAAEOLr+rVq+Pm5oaqqoZp/v7+BAYG5unqZ+umTZvGs88+S506dXBxcaFBgwb873//Y82aNYCuNWJKSorR9vfee+8RFxdneEVElN+I477Ll1Nv+HA8Dh3STdi+Hdq0gblzy22fpVFRC1abin7QEFtIEtjCezCnohKhltjluKh/84ra7bHM7/r27dsA1K5dO8f0jIwMdu3ahaIojB8/3vAB7eDgwMsvv4yqqhw8eLCsuxcmNvJ/3fKd/uesvSaORAghSkaj0dDvsca4FZIAU1WV+LhUUlLS2bblPAkJkgAToqL4+++/+eWXXwBdEuz27dts2bLFMP/q1avEx8dz+vRp3njjDTQaDT4+PmzcuJHLly+bK2yL0rt3bx588EFiY2M5cEDXW0B/Y5icnFzgevpWdvm1+gJdKydPT88cL6M6d07XuiswEN9Vq8jIPaCUnx/8/DMEBuqWO3fOuPsXFqdSpUrUqVMHNzc3c4dSavr774qa6DCWohLNltit1MfHp9D5FTUhWua/hOhoXcHz3ENqh4aGGp745O7a2KBBAwBu3rxZ1t0LE+vxRNN8py/7Zp+JIxFCiJLTdYFsjJt7wRcqqgopyRmgqGzbfJ7EhLQClxXiPtXIL2FqCxcuBHT1xBYsWICPj0++NwgNGzZk1qxZrFq1iosXL9KvX788o1JWZPXr1wfgxo0bAIZWcdeuXct3+aSkJGJjY/Hx8Skw+VXuKlcGLy8ID8f+1i0ccv97RkVBZCSEh+uWq1LFPHEKk9FoNLi6uhaZRLBkVapUwc/Pz2K75eUeUdhS5c5z5GaJiSQ/P79C51tizKZQ5uSXvv++vgWYnn4EyHr16lG5cuUc83IXaBTWw8HRjsBG/nmma7Vw82qs6QMSQogS0rUAC8LV9X4CLHcha1WF1BRdfYetW86TlCgJMCFs3f79+w09FopjwIABPP/881y9epVvv/22nKOzHvoRPvUtZho2bIiTkxN37twhMjIyz/JHjhwBoHnz5qYLMjcvL9i9Gz78EBQFNfeNoZ0dKApMmaJbztgtz4TFsuaWX97e3lStWtViEx25cwSWyhrr6xUVs6WeE+WtzMmvunXrAnlH5Vm9ejWKotC1a9c869y5cwfQNScV1uelT3rmO/2H//1t4kiEEKJ07Ow0PDaoCS6u9obEl6qqkO1aQFVVUlIyUbVaXQIsqeBi+ULoC94b6yVMT/8gV99DAXLWesk+2qDesGHDUFWV1atXl3+AVuDOnTvs3r0bgNatWwO6h949evQAYPny5XnW0Y/aOWDAABNFWQB7e/joI/j6a5Tcf4RZWTBzJkydqlvOwlTUG1lTsJbC99bYtdESuwvmxxqTXyJ/Zf4r6dWrF6qqMmfOHDZu3EhiYiLfffcdoaGhQP5fZMePHwegWrVqZd29MIPmDwWiscv7JXto8+VChwEXQghLotEoDBjUFJdsLcDIlXxQVZXU1EwyM7LYtuU8ycmSABPC1vn6+hp+zt4NL3cvB7j/IPfKlSvlHpelCAkJYc2aNXlGP7ty5QpDhgwhKSmJgQMHUr16dcO8SZMmATB9+nTOnz9vmL5v3z7mzp2Lt7c3Y8aMMc0bKEpYWP4tv8LCzBJOYfRJLyl+X36sJbFYVNc8UXpybG1HmZNfEyZMwNPTk4SEBB577DG8vLyYOHEiAI0bN843+bVhwwYURaFVq1Zl3b0wA0VRaNWtVr7zDvxzwbTBCCFEGWg0CgMHN8XFJe+Ngz4BptVCenoWmRmZbNtynpSUDBNHKayBtPyyfvouOPp6tvpp+hsf/cPb7K5evQpAamrFGRzj3LlzDBkyhOrVq9O/f39GjBjBQw89ROPGjdm7dy9NmjRh3rx5Odbp2bMnEyZMICoqipYtWzJ48GD69etH165dyczMZOHChZZR/yc9HVasyNnyy85O1/JrxQrdfAuib5Fi9AEAhNXRlyISxmctLdRE0cqc/KpatSrr1q2jSpUqhqGfVVWlTp06rFixIk+2/OLFi4bm0D175t99Tli+Fwvo+jjvg80mjkQIIcpGo1EYMLgpTs52eZIO2RNgaWlZpKfpE2CWdQMkhCi7Zs2aAXDq1CnDNHt7e8PDWn1B/Ox++OEHAAIDA00QoWVo3749r7zyCtWqVSM0NJRly5Zx4sQJWrZsyddff01oaGi+pU1mzZrFwoULady4MZs3b2bfvn307NmTXbt2MXjwYNO/kfyEhEDuUSn1LdySknTzLUjdunWpV68eVatWNXcowsysuTaZpbOW1n+iaEZpI9ulSxcuX77M3r17uXnzJlWrVuWhhx7KtwnujRs3mDx5MqAbDllYp+p1/XB0tic9NTPH9JtX40lNTsfZVZqHCiGsh52dhoGDm7FyeRhZmbnn6jJgWq2CVgsODnbs2nGJhx+ph6OjdDUR5adt27bY2dkxfvz4YhdhF6XXvXt31q9fz5YtW3Ic72effZYDBw6wevVqnn/+eZ588kmSkpJYvHgxW7ZsQVEUBg0aZMbITatx48bMmTOnVOuOGjWKUaNGGTcgY2rSBD76iIu1a6Pea1VVr149SEmBrVt18y2IoigWO5KfMC1p+SVE0RRVijRZrfj4eLy8vIiLizNLc+cf/vsP6xccyTP9mf90ZsQ7XUwejxBClFV6WiarVhxHq809R/9VqeDgqEHVqnj7uNKjZ33s7XM1ok5NhW+/hTfeALkpMRtTfUfq9zPtw/U4OxvnyXtqahIfTnvMbN/vFdXly5epW7cuTk5OXLlyxdANMjMzkw4dOnDkyJE8LQBUVSUwMJAjR47g4+NjjrArpPL++z5x4oTh56ZNmxp9+xXV3bt3uXnzZo5p1nB8s58PYJkxq6rKyZMnc0yzxDhzs4ZjC3njzE5iLl/G/Ly3vmEhhMUoKMG1Ini/iSMRQgjjcHSyZ9DQZuRt4a6foJKeloW9vR3RUUns2nGRrKxcmbKVK+Hdd2HVKhNELCyFauT/CdOrXbs2ly5d4sSJEzkusO3t7dm8eTMjRozA3t7eUOIDoH///uzevVsSXzamZs2aAPLvamT+/v7mDsFm5U7Mu7u7mykSISyXJL9EqXn6uuDp55JnenpKFhHn7pohIiGEKDsXFwcGDAq695ua40ZX31Y6JSUDN3dHbt6IJ2TPFbTabMmK5ct1/12xwnRBCyGMolatWtStWxcXl5zXNz4+PixdupS7d+9y6NAh9u/fz507d1i3bl2OUQ2FbfD09KRp06Y88MAD5g5FiFKRGmCiIBW5hplRi5WoqkpYWBjHjh3j7t27pKSkUFSvyg8//NCYIQgTG/5mJ+Z9sDXP9IXTt/PhkifMEJEQQpSdu4cz/Qc0YsO6M+i7POb+OouPS8PPz4WI8BhCD9jRrkNNlORk2LRJt8Bff+kKJMsFqBA2w8PDg9atW5s7DCFsgn4kVWuSX01rSyRd5kVB7OzszB2C2Rjtr3fx4sV89NFHhiGfi0uSX9at38hWeZJfigIH/tZ1BbKzk8aFQgjr5OXtSq++Ddi86VyBD3LST55h4PdvQ3IyGQ52OJIFaWm6mWlpUK8e6C/u3dxgzRpo0MA0b0CYlKrmTZCWZVtCCGHr6tSpY+4QSsxakl9O9wZsEEJPURRUVUWjqbj350b5633//ff5/PPPi2zlBfcPurANjs72VK/rw7WLMTlnqLB33Rm6Dg7Kf0UhhLACAQHudH+kLtu3XMgzT1VVUj39SHF0JSDiUv4byF7Yt0MHqFKlnCIVQhiTVqtl+/bt7Nu3j5s3b5KcnMwnn3xC1apVDcukp6eTmZmJnZ2d3GgKUQrWkkjKTv7WhbWyt7cnIyMDBwcHc4diNmVO+x04cIDPPvsMgF69ehEWFsaRI7oRABVFISsrizt37rBx40YGDhyIqqo89NBD3LhxA23e4bSEFXrho4fzTFMU+OnDf8wQjRBCGFe1al507lIrxzRVVVEUhQxXd/753zyODxqLqiholVxfq3Z2ug/EKVNg926Qbgi2SzXyS5jN+vXrqVevHr1792bKlCn88MMPLF68mJiYnA/6fv75Zzw8PKhUqRJJSUlmilYYXWoqfPml7r9C5GKNXTWFcVlj0hYwJL0q8jlc5uTXDz/8AEBgYCAbNmygefPmObKJiqLg5+dHnz59WLNmDcHBwezZs4e+ffuSnp5e1t0LC9CuV30cHO/3HdY37Iu9lUrUjQQzRSWEEMZTq7Yfrdo8YGi5nKMVs70Dx4e8xOGnJqJRcz3UycqCmTNh6lSw0oslISqSefPmMWjQIK5cuYKqqvj5+RXYY2Hs2LF4eXmRmJjI6tWrTRypMLobN+DIEZgxQzdi79df636/ccPckQkLIoXkK6bsReKt9RzQ1/qqyAXvy5z8CgkJQVEU3njjjWJlQV955RUef/xxjh8/zpw5c8q6e2EBFEWhz3PN7/0MGo1i+KP6bNxKc4YmhBBGE9SkCvUbBuS4Ec4+EqTP1bNoNRpDox0VdC2/wsJMHaowA9XI/xOmd/78ecaPHw9Ajx49OHXqFLdv3y5weUdHRx5//HFUVeWff6S1uykEBwcTFBRE27Ztjb/xuXOhTRuYPFn3+wcf6H6fO9f4+xJWJXuB8IrcaqYiy54wstbBBPS1vipyza8yv/Mb956GNGnS5P5Gsx3QjIyMPOs899xzqKrKn3/+WdbdCwsx7uOeaOzyZpHPHrpFXHSyGSISQgjja98hkKrVPPO0BNFkZlDz8HY0Wi1aO3vC+zyBameva/m1ahVIS2chLN4333xDZmYmTZo04a+//qJRo0ZFrtOlSxcAjh49Wt7hCWD8+PGcOnWK0NBQ42/8pZdg8+b7v9vbw549uumiQnN2djb8XJETBxVZ9gSoq6urGSMpPf17qMjncJnfuT65ValSJcM0d3d3w8937tzJs0716tUBuHAhbwFhYZ3s7e14aEBDgBzdggA+HSOtv4QQtqNHz/p4ed0veKsoCgHnj+OQlkJclUD+mrKUvc++y44Zf5BQNRASEiAkxIwRC1PQj/ZorJcwvW3btqEoChMnTix264569eoBEBERUZ6hifJy7hwEBUFgoG5QkhEj7s/LzIRhw3TTAwN1y507Z75Yhdlkv7fNngQRxuXh4WHuEAqUvYebNRaMt7Ozw8/PD19fX7y9vc0djtmUOfkVEBAAQHx8vGFa5cqVDR8Mp0+fzrOOvrVYQoLUg7Ilk75/LN8+xKf2XSdeWn8JIWyEoij0G9AEJ2e7e4kKlbjqdQl9ehIbpv5CbI16ZGaqRFety5Yv/uDEmHdJr9/Q3GELIYpw7do1AFq0aFHsdfS1X5KT5TrHKlWuDF5eEB6ue+Xu5nrz5v15Xl4yYm8Flb3GU0Wul1TeLLlF1QMPPICiKFbV5TH7QxwPDw+cnJyoVq1ahe66W+bkl76745kzZwzTHB0dDdPz69q4dOlSAKpVq1bW3QsL4uBoT5setfP9Uvjq5bVmiEgIIcqHnZ2GQUOaYWenoKqQ6uHNub7PkOV0v2tESkom9p5unHj4SXb8G09WloxwbMv09d+M9RKmp79+KUkiKyoqCgAvL69yiUmUMy8v3Ui8H36oK1yb+xpWRuwV3G/1Y+ndxbK3ULMW2T87fXx8zBhJ4ZydnWnSpAk1a9bMMd2SR37MnqiryK29sivzX3CXLl1QVZXt27fnmD58+HBUVWXBggVMmTKFkydPcvDgQV599VWWLVuGoig8+uijZd29sDDvzhuc7/SwXeHEx8hTUSGE7XB0tGfQkKZoNLpualpt7oSFSkx0Kv4Bbty5nUjIniuS1BDCgj3wwAMAXLp0qdjr7NmzB4A6deqUS0zCBOzt4aOPdKM75v6MlhF7BbpubgEBAVStWtXcoRSqevXqeHp6Urt2bXOHUmy+vr6Gn62xS2n20k+Wxt/f3/Czi4uLGSOxHGVOfg0ePBiA9evX5+j6OGHCBGrVqoVWq2X69Ok0b96cjh07MvfeiCk+Pj689957Zd29sDAubo4Edaie77xvXltv4miEEKJ8ubk78Wj/xnkaC8D9e6jrkfEE1vLhyuVojhy6ZtoAhRDF1r17d1RVZfHixcVaPi4ujh9//BFFUejRo0c5RyfKXUhI3pZfGo3UbDSypk2bUqtWLYKCgswdSrEpikLlypUtumUS6Foh1axZM0c3TUvn5uaGu7s73t7eVtWltG7dulStWjVH8s7S2Nvb06hRIxo1amSVicXyYJRuj9u3b2f16tVkZmYapru6urJ9+3Y6d+6cpyl/06ZN2bp1q6HwvbAtHy4Zmu/0Q1svkxCTYuJohBCifPn6udHt4br3flMN/1UUxXAhd+liFPXq+XHnbhJnTt/OdztCCPN66aWXUBSFnTt3smjRokKXjYqKYvDgwdy8eRN7e3tefvll0wQpykd6Oqxdm7fll1army4j9hqVu7u7xXchFKZTq1Ytq8sLuLi44OfnZ+4wimRvb2/RXTNNzSifOt26deORRx7Jk/kMDAxk9+7dnD59mhUrVvDHH39w+PBhjh8/XqJiosK6uHm6UK9F5XznzZqwwcTRCCFE+atR04eWraoCCtkTYNm7OZ4/fxc3VwdCD1wlMjLOHGEKK9O2bVuCgoIIDg42dygVQqtWrZgwYQKqqjJmzBiGDx/OsmXLDPNDQkL47bffGD9+PPXq1WPXrl0oisLkyZMJDAw0Y+SizEJCICNDN6rjH3/A4cO6/9asqUt8SesvIYSweooqBUhMKiUlhc8++4w//viD8PBwfH196du3Lx9//LGh1kRxxcfH4+XlRVxcnMWNPBF1K4FRLebkO++302/g4SP9joUQtmfntguEh8eiS4DpEmH6b1lV1fWgqVzFg6i7yTzavzHe8llYbkz1HanfzwfvrcXZ2ThdTVJTk5j+2SCL/H63daqq8tprr/HDDz8U2gVHf/k8ceJEZs6caarwxD1G//u+cwd++w3GjYPsI84lJ8O8efDMM3BvhHshhBCmY8zPe2lvakKpqan06NGDjz/+mMTERAYNGkSNGjVYuHAhrVq1KlGBVUvnV9mDGg3ybwo6e9JGE0cjhBCm0fXhunh5OaOq+tH/dNP1/9VqISYmBVc3B7ZtOUdKSob5ghVC5KEoCsHBwfz99990794dRVHyHYmzY8eObNiwQRJftiIgACZMyJn4At3vEyZI4ksIIWyAdAA1oenTp7N//346duzIP//8YxiOdubMmbz11lu88MIL7Nixw7xBGtGUX4cxtu3cPNMPbDxPfEwKntLiQQhhYxRFod+Axqz48xhpaVmG2smKok+AqaSmZOLu7kBampYdW8/Tu28j7OzlWZS1y54YMca2hHn16tWLXr16kZCQwNGjR7l9+zZZWVn4+fnRsmXLHKNoCSGEEMLyGS35lZmZyYYNG9i9ezeXLl0iISGBrKysQtdRFIWtW7caKwSLlp6ezvfffw9AcHCwIfEFMGnSJBYvXszOnTs5fPgwbdq0MVeYRlW5hjdVAr24eTVvbZvv397I/37OvzC+EEJYM3t7OwYObsrK5cfRalUUBUPrEX1XyLt3Uqhdx4eI8Fj27r1Ml651rGqUIyEqCg8PD7p27WruMIQQQghRRkZJfu3cuZNRo0YRHh5umFbYU0v9TUBFutDfu3cvcXFx1K1bl1atWuWZP2zYMI4fP866detsJvkF8MGSx3mt24I80/etP09CbAoe3tL6Swhhe1zdHHn0sUb8te60oQvkfboE2OWL0TRuWpkzp27j5elMi1Ylq/sohDCuQ4cO8eCDD5o7DCGEEEKUgzInv8LCwujbty/p6emoqoqzszP169fH29tbhrDN5tixYwC0bt063/n66cePHzdZTKYQ2DAAv6ruRN1IzDPvu/9I6y8hhO3y93enc5fa7Nl1+f5EfRJM0SXATp+4RaMmlTkWdh1PL2dq17H8YbOFsFXt2rWjWbNmvPDCCzz77LNWMYy9EEIIIYqnzMmvqVOnkpaWhpOTEzNnzmT06NE4OzsbIzabom8VV7169Xzn66dfvXq1wG2kpaWRlpZm+D0+Pt6IEZaf//48mLf7/5Jn+r7150mISZGRH4UQNqtuPX+i7iRy+tRtXcJLl/OC+//h3Jnb1K7jy5lTt/DwcMI/wL2gzQkLpnI/t2mMbQnzOHHiBJMmTeLdd99lwIABjB49mkcffbRC9VYQQgghbFGZm2bt2bMHRVF4//33eeWVVyTxVYDERF3LJ9fco8jc4+amGx49ISGhwG189tlneHl5GV41atQwfqDloFGbB/Dyz/99B78tIz8KIWxb2w6B+Pm53suM3LuBzpYl0Wap3LgeT2aWlm1bzssIkEKYyezZs2nZsiWqqpKens6qVasYMGAANWrU4P333+fChQvmDlEIIYQQpVTm5FdqaioAffv2LXMwonDvvfcecXFxhldERIS5Qyq2//wwIN/pe++1/hJCCFulKAp9HwvCwVGTo/aXvh2JCiQlpePkZI+qwvat58nK0polVlF6utpuxnsJ03v99dc5fPgwYWFhvP766/j6+qKqKtevX+fzzz+nYcOGdO3alcWLF5OcnGzucCuk4OBggoKCaNu2rblDEUIIYWXKnPyqVasWABkZ8qS6MPrRHQu6WEpKSgJ0owoVxMnJCU9Pzxwva9GySy3cvJxyTrx39s15Z5PpAxJCCBOyt9cwcHCz7L0e4d7gL/qE2PXIeOrU9eXunSQO7g8vaFNCiHLWvHlzZs+ezfXr11mxYgX9+/dHo9Elr/fu3csLL7xA1apVGTduHCEhIeYOt0IZP348p06dIjQ01NyhCCGEsDJlrvk1ePBgTp8+za5du+jYsaMxYrJJNWvWBODatWv5ztdPDwwMNFlMpvbGN4/y2Qtr7k+4dwe4Z905XolOxtM3/66RQghhC9w9nOjZuwFb/jmn+/i7N+qxPvmlqionT9yiecuqHA+7gZ+fKw0aVTJrzEJUZA4ODgwdOpShQ4dy8+ZNFi9ezOLFizlz5gwJCQksWLCABQsW0KBBA1544QVGjhxJ5cqVzR12haD/3LSW+rdCCCFKR/85rxqhWXyZk18TJkxg0aJFzJgxg+HDhxtagomcWrRoAcCRI0fyna+f3rx5c5PFZGqd+jXE2c2B1KR7rQRVdK2/tPDDe//w7tzBZoxOCCHK3wM1vGneqhrHj17XfYkrSo4EmCY9Fe3nX1Jv3Cvs33cVbx8XKlUuuEWwsCQqxitVL/0eLU2VKlV49913effdd9m3bx8LFy7kzz//JCEhgbNnz/Lf//6X999/n379+vHyyy9LOZBypq+Ray31b4UQQpRNQkICXl5eZdpGmZNfAQEB/PXXXzz22GO0b9+e6dOn8+STT5Y5MFvTuXNnvLy8uHjxImFhYbRs2TLH/BUrVgAwYED+tbFsxWtf92XGy+tyTtTAnrVnefnTZLz8pPWXEMK2tWpdnTu3EomMjEO5lwDTCzy8nQdXfM++SlXw7zuE7Vsv8NigJri5OZoxYiFEdunp6aSlpZGVlWVIXquqSmZmJuvWrWPdunW0bNmSH374gXbt2pk7XJtUrVo1IiIi8PDwMIzE2bZt2xJ1h4yPj6dGjRpERESUuJRISfdlLevJMclLjkleckzykmOSl7GOiaqqJCQkUK1atRJtIz9lTn6BrrXSrl27aN++PS+//DKvvPIK/v7+BY5sqKcoChcvXjRGCBbP0dGR1157jU8++YTx48fzzz//GEZ4nDlzJsePH6dbt260adPGzJGWr26Dg/jh3X9IikszVHtWFAUVlc9fXM1nK0eYN0AhhDCBnn0asGrZMRIS03NUN691eBsAVUM2kzx4GIlJCtu3nqdvv8bY25e5TKcoR8YsVC8F7y1PeHi4odvj5cuXAd0FuUajoW/fvjz33HOcOHGCJUuWcO3aNY4ePUrXrl3ZuXMn7du3N3P0tkej0VC9evUc0+zs7EpVD7c0dXRLuy9rWU+OSV5yTPKSY5KXHJO8jHFMjNWwyijJr5UrVzJmzBgSEhIMT79u375d5HpKtqfdFcEHH3zAli1bCAkJoX79+nTp0oWrV69y4MABAgICWLBggblDNIn3Fw3hf4//kbNXhwZO7LtG+Lm71Gzgb7bYhBDCFDQaDf0GNmHZb0cNH4X2aSlUP7EPgBonQth99gbNO9Xj2rU4Dh0Mp0OnWmaLV4iKKC0tjZUrV7Jw4UK2b9+eY4CKwMBAXnjhBV544QUeeOABwzrTpk3jl19+YdKkSURHR/Phhx/y999/m+stVCjjx4+3+H1Zy3qm3Je1rGfKfVnLeqbcl7WsZ8p9Wct6lrQvRS1j5bB9+/bRtWtXsrKyAN3FQPPmzfH29kajKfop9cKFC8uye6uTkpLCZ599xm+//UZERAS+vr707duXjz/+OM8TrKLEx8fj5eVFXFycVY38CPDaw/O5euZujtZfAM5u9iw7N8mMkQkhhImcO0dG/wGkResKeWqyMnCNizLMTvb0Q2vvgKOjHck4ELfodwL7dDBXtFbHVN+R+v389+3VODu5GWWbqWlJfP7VEKv8frcFBw4cMNT0yl5o19HRkUGDBjF27Fh69uxZ6EPcpUuX8vzzz+Pr68vdu3dNFbooAWu+ji4vckzykmOSlxyTvOSY5GWJx6TMLb+mT59OVlYWXl5e/Prrr/Tr188YcdksFxcXpk2bxrRp08wdill9vmYEzwR9q2v9le3aMTUpk//7+TADx9p2908hhKByZRz8fXG4cC7f2a7x9xNhqUEtCbmQgkfbZHxlZFwhysWXX35pGM0R7o8sFRQUxJgxYxg5ciR+fn7F2lbbtm0BiImJKZ9gRZk5OTkxZcoUnJyczB2KxZBjkpcck7zkmOQlxyQvSzwmZW75VblyZe7evcs333zDG2+8Yay4RDFYYja1JH58fzN/LTqKqqp5np4uOz8RZ1cp8CyEsHGZmajTpsH06agoaFStYZZW0aCgEtb/Ba6Pfo0MVUNWlsrAwU1xcLQzY9DWweQtv/6zCicjtfxKS0vi8xlDadCgAXZ2dowfP96k3Q0qKo1GYyhg7+bmxpNPPsnYsWPp2LFjibd18eJF6tevj6Ioht4RQgghhDCfMlfPTU5OBuChhx4qczCiYnlpek8cnOxQUPKM6j51xHLzBCWEEKZkb48ybRpZX3yZI/EFoFG1HHxiAmEDx3E7Ko0aNX1ISU5nz+5LlPG5lbASoaGhnDp1ShJfJvTggw8yd+5cbty4wfz580uV+AKoW7cuWq1WEl9CCCGEhShz8qt27drA/SSYEMWlKArv/Tw433mnDkZy9sh10wYkhBBmYn/iX1Q7O8NzABXQajT4Rui6RKqqyvGw67RsU50rl6I5ffKW2WIVwlYdO3aMAwcOMG7cONzd3c0djhBCCCGMqMzJr6FDh6KqqoxkI0rlwR51qVbXR/dLroYM7z/5h7RuEELYvvR0WLUKJSsL1d6Bs10Go7WzR6PVEnhkB0pmOqBLgIUeCKdRUCVCD4Rz53aimQMXwrY0a9bM3CEIIYQQopyUOfn11ltvUb9+fWbNmsWhQ4eMEZOoYL5Y+2yOovd66SmZ/Dpjt+kDEkIIUwoJgcREaNgQzZHDXHrnE9a9v5C4yjVxTEum0oV/DXURVa3KnTuJ+Pm7sX3LeVJTM8wcvBBClI/k5GTWrFnDmDFjaNiwIc7Ozri5udGiRQumTZtGYmLBDwAWLVpEu3btcHd3x9fXl379+hESElLo/vbu3Uu/fv3w9fXF3d2ddu3asWTJkkLXuXbtGqNHj6ZatWo4OzvToEEDpkyZQmpqaqnec1Es/ZgoilLoqzyOi6mOSVJSEkuXLuX111+nffv2ODk5oSgKU6dOLTJGWz1PSntMbPk8OXPmDF988QUPP/ww/v7+ODg4UKVKFYYOHcru3YXf19rqeVLaY1Ie50mZC96D7h/qiSee4NixY7z55psMHz6cBg0a4OzsXNZNi0JYe8H77L77zyY2/348z+iPAL/8+zqevi5miUsIIcrdnTvw228wbhy4upKVpeW3pYfRJibRcPdaLrXrTaqHj2FxVYU2D1YnIiIWT09nuj5cN8+gIcL0Be/fnbTSqAXvv5j5uE18vwtRWj///DPjxo0DoHHjxjRt2pT4+HhCQkJISEigUaNG7Ny5k0qVKuVYb+LEicyePRsXFxd69+5NamoqW7duRVVVVqxYweDBg/Psa+XKlQwfPhytVkvXrl3x9/dn69atxMbG8tZbbzFjxow861y4cIGOHTty9+5dmjZtSlBQEIcOHeLSpUt07tyZrVu3Gn2UM0s/Joqi4ObmxrBhw/KNf968eTg4OJT9QGRjqmMSFhZGq1at8ux/ypQphSZ7bPk8Ke0xseXzpHr16kRGRuLu7k6HDh3w9fXl1KlTnDhxAkVRmDlzJhMnTswTny2fJ6U9JuVynqhlpNFoDC9FUXL8XtTLzs6urLuv0OLi4lRAjYuLM3coZabVatUhtb5SB1T9Qveqdv/1es8F5g5PCCFMKupukjp/7r48rwU/7Vd//nGf+vOP+9Qzp2+oP/+4Tz1x/Lq5w7VIpvqO1O/n3Ukr1Q/f22SU17uTVtrM97slUhRFtbOzU0+ePGn0bZ84ccKwfVE2ixYtUl988UX11KlTOaZfv35dbdWqlQqoTz/9dI55mzdvVgHVz89PPXfunGF6SEiI6ujoqHp7e6sxMTE51omKilI9PT1VQF25cqVh+s2bN9V69eqpgLp9+/Y88XXu3FkF1DfeeMMwLSMjQx0yZIgKqFOmTCn9my+ApR8TQA0MDCzz+ywJUx2TCxcuqGPGjFF//PFH9fDhw+q0adOK9e9sy+dJaY+JLZ8njzzyiLpkyRI1JSUlx/Qff/xRBQr87rHl86S0x6Q8zpMyJ78URSn1S6PRGOM9VFi2lPxSVVUN+etsvsmvAdW+UI/suGzu8IQQwqTCDkeo8+fqEl36xJc+Cfbzj/vUxfMPqCG7L6kLftqv3r2TaO5wLY6pk1/vvLlCnfzfjUZ5vfPmCpv6frc0+mvQ8kx+yTVu+QoJCVEB1cnJSU1LSzNMf/TRR1VA/eabb/Ks88Ybb6iAOmPGjBzTv/jiCxVQBw0alGedVatWqYD62GOP5Zh+4MABFVArVaqkpqam5ph38+ZN1cHBQfXx8VEzMjJK/yZLyNzHRFXNk9QojDGPSW6fffZZkUkJWz9PcivOMVHVinWeZNe7d28VUKdOnZpjekU7T7Ir6JioavmcJ2Wu+TVlypRSvz788MOy7l7YkI6PNqBKLS/dL7k64057fjlZmVrTByWEEGbSonV1fP1dURRdV0f1XpUCfbGCjAwtCQmpePu4sH3reTIysswYrRBCmE6LFi0ASEtLIyoqCoCUlBS2bdsGkG83Gf20devW5Zi+YcOGAtfp378/zs7ObNmyJUd9Gf06AwYMyNMVqXLlynTp0oWYmBj27NlTqvdXGuY+JpbImMekNGz9PLEVpjom+v1cv349x/SKfJ4UdEzKi31ZNzBlyhRjxCEEAF+ufZaRLYPzJL+yMlTmTdnKy5/0Mk9gQghhBv0eC+L3pYfJzFRRVVAUDMkwgIjwODp1DuTggQj2h1ylS7c65g1YCCsyevRo3NyMU6dNLykpyajbE/m7dOkSAA4ODvj6+gJw9uxZ0tLSCAgIoHr16nnWad26NQDHjx/PMf3YsWM55mfn6OhI06ZNOXToEOfOnaN58+ZFrqOfvm3bNo4fP0737t1L8Q5LztzHRC8pKYlPPvmE8PBwXF1dadWqFUOHDsXd3b3sb7KEjHlMSsPWz5OyqIjniX4/VapUyTG9Ip8nBR0TPWOfJ2VOfglhTN4Bbjw8rAnbV5zMU/z+r0VHefzVdgQ84GW2+IQQwpQcHe3p3a8xG9edutf6K3cCTGVfyFU6dK7Fvj1XqF7di9p1/cwdthBWITQ01NwhiFKaPXs2AH379jW0lAgPDwfI96YMwM3NDW9vb2JiYkhISMDDw4P4+Hji4uIKXa969eocOnSIq1evGhI9Re1LP/3q1auleXulYu5jonf37l0++OCDHNMmTZrE4sWL6d+/f+nfYCkY65iUli2fJ2VV0c6Tixcvsn79egAGDhyYY15FPU8KOyZ6xj5PJPklLM7EWf3YteY0WRnaPAmw/z3xB/O2PQ/ffgtvvAEyoqgQwsZVrepJ4yaVOXXiFnC/1Reohu6Qx45eo3YdX/bsuoR/JXc8PIw7IpAoBpU8rZbLtC1Rbrp27SojpFqxv/76i/nz5+Pg4MDHH39smJ6YmAiAq6trgeu6ubkRGxtruDHTr1PYevrWgQkJCcXeV37rlCdLOCYAI0eO5JlnnqFZs2Z4eXlx/vx5Zs6cydKlSxk6dCh79uyhbdu2pX6fJWHMY1JatnyelEVFO08yMzMZNWoUaWlpDB8+nDZt2uSYXxHPk6KOCZTPeSLJL2FxFEVh0neP8dXL/5dn3q2rcZz537c0+uZdqF4dnnnGDBEKIYRpdehUi8hrccTGpBhu2nWtwBRUVSUpMQOP+k44Otqxc9sF+g0IQqORm3sh8rNjxw5zhyBK6cyZMzz77LOoqspXX31lqBdTkVnSMVm8eHGO31u2bMmSJUuoUaMGn376KR988AF///13ucdhScfEUljSMalo58kbb7zBnj17qFOnDnPmzCmXfRiLJR2T8jhPil3wftWqVSXacEldv36d/fv3l+s+hPXoMrARAdXvZYtzPQGP/eHeH8KKFaYNSgghzERRFPoNCLrX3fH+h6KqqoZk2LGj12nboSZarZbjYaYpHCruU7WgalUjvcz9boSwPJGRkfTt25eYmBgmTZrEhAkTcszX14BJTk4ucBv6mmz6FgnZ68YUtF7udYqzr/zWKQ+WdEwK884772BnZ8eOHTtIT08v1jqlVR7HpLRs+TwpD7Z4nnzyySf88MMPVK5cmb///ttQP6sk+7K186Q4x6QwZTlPip38GjZsGC1btmSFkRMOERERvPrqq9StW5d//vnHqNsW1u2rdc/m6PII4KRNp3XqWd0vf/0FUlhWCFFBuLo68lBXfUF7FX2vreyjQO7afpFqD3hxKDSCu3cS89+QEEJYmejoaHr37s3Vq1cZPXo0M2bMyLNMzZo1Abh27Vq+20hKSiI2NhYfHx/DjZmnpydeXl6FrqefHhgYWOx95beOsVnaMSmMl5cXlSpVIj093TByXHkor2NSWrZ8npQHWztPfvzxRz744AO8vLzYtGkT9erVy3e5inSeFPeYFKYs50mxk19169bl+PHjDB8+nNq1a/P+++9z8uTJEgcLugPzyy+/0K9fP+rWrcuPP/5IVlYWdevWLdX2hG3yrezBY13cCb4zg59vfsbPtz5j7u0vcSRLt0BaGtSrB4GBuldQEJw7Z96ghRCiHDVsXJlKld0Nxe+zUxTIyNCSlJiGr68r27deIDNTmhAJIaxbYmIijz76KKdOnWLo0KHMmzcv35ptDRs2xMnJiTt37hAZGZln/pEjRwDyFGjXd+vRz88uIyODEydO4OzsTIMGDYq1TmH7MhZLPCaF0Wq1xMfHAxh9hFW98j4mpWHr54mx2dJ58scffzB+/HhcXV3ZsGEDLVu2LDCminKelOSYFKYs50mxk1+nTp3iiy++wNfXl6tXr/L555/TvHlzGjVqxKhRowgODiYkJIQLFy4QFRWFVqslKSmJiIgIjh8/zooVK3j33Xd5+OGHqVSpEs8//zybNm0iMzOToUOHcuLECUaMGFGydy5s3tgfniZJ40IlbSyVsmLx1eYq9HfzJoSH615eXlDAMKlCCGErHu3fGI2dkif5pVV1vcTPnb1Li1bViI9L5fDBcLPEWCGpRn4JIUhLS2PQoEEcPHiQPn368Pvvv2NnZ5fvsi4uLvTo0QOA5cuX55mv770yYMCAHNP1I4bl17tl/fr1pKam0rNnT5yzDbKkX2fdunWkpaXlWOfWrVvs3r0bHx8fOnfuXNy3WmyWekwKs2nTJpKSkqhbty6enp7FWqckTHFMSsPWzxNjs5Xz5K+//mLkyJHY29uzevXqIv99K8J5UtJjUpgynSdqCSUkJKhffPGFWrNmTVVRFFVRFFWj0RT7pV/H2dlZfeaZZ9QDBw6UNARxT1xcnAqocXFx5g6lXG3/86j6m/sjahaomSj6Bg+qCmqWolFVRVHVKVNUNSPD3KEKIYRJXL0arc77IUT9aU6IOu8H3eunH0LUuXN0r/lz96lhR66pP80JUa9H2vZ3REFM9R2p38/br69QP/jPX0Z5vf36igrx/S5EYTIzM9UhQ4aogNqlSxc1KSmpyHU2b96sAqqfn5967tw5w/SQkBDVyclJ9fb2VmNiYnKsExUVpXp6eqqAunLlSsP0W7duqfXq1VMBdfv27Xn21blzZxVQJ0yYYJiWkZGhDh06VAXUKVOmlPQtF8mSj8nvv/+uHjx4MM/+d+zYoVarVk0F1JkzZ5bsDReDqY5Jbp999lmx/p1t+TzJrTjHxNbPkz179qguLi6qvb29unr16mLHZ8vnSWmOSXmdJ4qq5n52XDxarZbNmzezbNkytm/fzpUrV4pcx9nZmfbt2zNo0CBGjhxZ4uJmIqf4+Hi8vLyIi4srl+y4JRnXaS7tT65nbPz6PPPSPvsSp/++bYaohBDCfLb8fYYrl2MMLcA0GgWtVkVFVy6xZk1P0jNUkhLTGfpkCxwd83+SZ6tM9R2p389/Xl+Ok1PBw3+XRFpaMjO+e4IGDRpgZ2fH+PHjGT9+vFG2LYS1mD17NhMnTgRgyJAhBf4dz5gxA39/f8PvEydOZPbs2bi6utKrVy/S09PZvHkzqqqyYsUKBg8enGcbK1eu5Mknn0RVVbp3746fnx9btmwhNjaWSZMm8fXXX+dZ5/z583Ts2JGoqCiaNWtGUFAQoaGhXLp0iU6dOrFt2zacnJyMciz0LPmYjBo1isWLF9OgQQOaNGmCg4MD586dIywsDICnnnqKX3/9FY2m2B2PisWUx2TIkCHcuHED0A3WFhERwQMPPED16tUBqFq1KqtXr86xjq2fJyU9JrZ+nvj4+BAbG0vt2rXp2rVrvvt46KGHGDt2bI5ptnyelOaYlNd5UurkV26RkZGEhIRw7do17ty5Q3R0NM7OzgQEBBAQEECzZs148MEHcXBwMMbuBBUr+ZUQm0JotYfolnIUDSoKul4hWhRCK3egw80Qc4cohBAmpdWqLF0USnpalmFaji90FXr2rs+ef07R5dgGas/+CIrZRcUW2ELyqyJ8vwtRkKlTp/LRRx8Vudzly5epVatWjmmLFi3i+++/5/Tp0zg6OtKhQwcmT55Mp06dCtzO3r17mT59Ovv37yc9PZ2goCBee+01nn/++QLXiYiI4MMPP2TTpk1ER0dTs2ZNnn76af73v/8Vu0tgSVjyMdm4cSO//vorhw8f5ubNmyQmJuLr60ubNm144YUXGDZsWInfb3GY8pjUqlWLq1evFriPwMDAfBuE2PJ5UtJjYuvnSX61snJ7/vnnWbRoUZ7ptnqelOaYlNd5YrTklzC9ipT8Ij2dTE9v7NNSyMSOLa5t6Jl8GHuySFac2L1gF31GtTN3lEIIYVJRd5NYu+pfsrLUPIkv0BXBfzT+CNX/+xp3Z/+E/xvjzBGmWZg8+TV+mXGTX8FPVozvdyGEEEIIEzBue0IhyktICPZpKdx0qcKblV5njs/jTKr8BpH2/riqaex6ewExd5LMHaUQQpiUn78b9RoEGLo65qaq4LBmFQCZv/9JWlqmSeMTQgghhBDCEkjyS1iHJk1g1iy8rp4iwqkaiqJw1aEqEytNZJ7XQMIdKvNK15+QhoxCiIqmS7c6ODnZoarZEmD3frBPS8H/0G4AAg7tInTrabPEWBHkGI3FCC8hhBBCCGE89uYOQIhiCQiACRNwAd5fOJTpo3QtGdI1jqz3eEi3TGIm307ayIRv+pkvTiGEMDFFUeg3IIjVK/7F82Y4vX96F/v0VFBBk5WJXWYGAHaZGbR6+mEyPVywt9OAmxusWQMNGpj3DQghhBBCCFHOpOWXsDptH6lLq26B+c7btuIkpw9dM3FEQghhXgEB7tSr70+yly/pzu54RN/CI+YWbvFROZZzi4/CPvIahIeDlxdUqWKmiIUQQgghhDAdafklrNLkxcMY3mAWGelZeeb9d+jvLD/3Jo7OcnoLISqO7j3qsfhKNP836Qdab1xI602LUFHQqFrDMqrGDlQtkaPfoPrcGWAvn5NC5OfYsWPs3r2bS5cukZCQQFZW3uuN7BRFYf78+SaKTgghhBAlJVe9wirZ2WmYuXEkrz+yMO9MFd56bAnfbXnB9IEJIYSZaDQK/R4LYu3qExx6bCxpru50WvldjmUUbRaRb01lY93eDIpKpVJldzNFa3tUVTVa3UmpX2k+Z8+e5YUXXmD//v3FXkdVVUl+CSGEEBZOkl/CatVs4M+AsW1Y9/PhPPPCz0axftERHhvV2gyRCSGEeVSu4kHtOr5cvhSNX8R5tBoNilaLAqiAqtHgeOpffNsNYdeOiwwd1gyNnVRAEAIgMjKSrl27cvfuXUMC0t3dHR8fHzQa+TsRQgghrJl8kwurNnZKDzx9XfKdN2/yVqJuJJg4IiGEMK9HejXA1V6l9rGdaLRatHb2nOo8CK2dPRqtFq9tG+nYtgox0cmEHb1u7nCFESQnJ7NmzRrGjBlDw4YNcXZ2xs3NjRYtWjBt2jQSExMLXHfRokW0a9cOd3d3fH196devHyEhIYXub+/evfTr1w9fX1/c3d1p164dS5YsKXD5DRs28P7779OzZ0+8vb1RFIXu3buX6r1euXIFRVEKfFUpQx27Tz75hDt37gAwduxYzpw5Q3x8PFevXuXy5ctFvoQQQghhuaTllxUKDg4mODi4yPoTFUXwjjE81/z7fOeN7zGf305OQKNRTByVEEKYh0aj0MsjCse0FGIq1WTLmOlEVavLia6P03v++3jfjuDkT6tpNaQf4VdjqFvPDy/v/B8iiBLQqrqXsbZVAr/99hvjxo0DoHHjxgwcOJD4+HhCQkKYMmUKv//+Ozt37qRSpUo51ps4cSKzZ8/GxcWF3r17k5qayubNm/nnn39YsWIFgwcPzrOvlStXMnz4cLRaLV27dsXf35+tW7fy/PPPc/z4cWbMmJFnnREjRhAXF1ei91SUypUr07dv3zzTvby8Sr3NTZs2oSgKI0eO5KeffipLeEIIIYSwMIoqhSWsVnx8PF5eXsTFxeHp6WnucMxq8x/H+P7tf/Kd13VwY9767jETRySEEGZ05w7H3plBaLM+ZDk7o2pBUcAuLZXGIf/H+Ta96Dy0LQf2R+Dj40K/AY1RFNt6SGCq70j9fia99AdOTq5G2WZaWjIz5z5V7NgXL15MSEgIEydOpHHjxobpN27coH///hw9epSnn36a3377zTBvy5Yt9OrVCz8/P/bt20f9+vUB2LdvH927d8fV1ZXLly/j7e1tWCc6OpratWsTHx/PypUrGTp0KAC3bt3ioYce4sKFC2zfvj1Pq64xY8bQuHFjHnzwQTIyMujduzfdunVjx44dJT42V65coXbt2qVevzDOzs5kZGSwZcsWHn74YaNuWwghhBDmJd0ehU3o9VQLAhv55ztv15rTHN931cQRCSGEGQUE0OiHT8hy0iW+AFQVMh2d+bf7E6S4e7N18wU6d6lFRHgsly9GmzdeUSbPP/88c+fOzZH4AqhatSrBwcEArFq1ivT0dMO8mTNnAvDBBx8YEl8AHTt25OWXXyY2NjZPAfeff/6Z+Ph4Bg0aZEh8ga4V1pdffgnA119/nSe++fPn85///Ifu3bvj4eFRxndbfnx8fAByJPyEEEIIYRvKnPyKi4tj2rRpTJs2jRs3bhS5/I0bNwzLJyUllXX3QhjM/GskSgHdGycPX0Zqcnq+84QQwhY5OdvTrkPNAuerqsq5M7cJrOXD3j2XyUiXrvS2qEWLFgCkpaURFRUFQEpKCtu2bQNg2LBhedbRT1u3bl2O6Rs2bChwnf79++Ps7MyWLVtITU013hswoQcffBCAc+fOmTkSIYQQQhhbmZNfv/76K1OnTuXXX3+latWqRS5fpUoVfv31Vz766CP++OOPsu5eCAN7Bzs+XfFU/jNVmNR/qWkDEkIIM2vVpjqurg45pmXv3nj5Ugwt21QjNSWTw4ciTB2eTVHRta4zysuIcV26dAkABwcHfH19ATh79ixpaWkEBARQvXr1POu0bq0bKfn48eM5ph87dizH/OwcHR1p2rQpqampJkke3bp1iylTpvDiiy/y9ttvs2LFihwt20rjjTfeQFVVqfclhBBC2KAyJ782btyIoig8+eSTxVpeURSeeuopVFXN80RRiLIKaludDn3r5zsv8kI0q388YOKIhBDCvB4b1CTH76qqq/+l+1ll04YztH7wAY6H3SA6KtkMEYryNHv2bAD69u2Lk5MTAOHh4QD5Jr4A3Nzc8Pb2JiYmhoQE3ajJ8fHxhqL1Ba2nn371avmXGjhz5gzTpk1j3rx5zJgxgyeeeIL69etz8ODBUm+zV69evPvuu2zfvp1XXnmFjIwMI0YshBBCCHMq82iPYWFhAHTq1KnY63Ts2DHHukIY039/GsSTDWaRnpqZZ96iT3bRqX8jKtco/WhQQghhTXz9XKlT15dLF6PJb4yblORMXN0c8fBwYvfOSwwc0sTmit+bgqqq+R7f0m4LdAmn7JycnAwJrOL466+/mD9/Pg4ODnz88ceG6YmJiQC4uhZcoN/NzY3Y2FgSEhLw8PAwrFPYem5ubgCGhFl5cHJy4pVXXmH48OE0btwYFxcXTp48yccff8xff/1Fnz59CAsLIzAwsMBtLFmypMB5jRs3plOnTvz000+sW7eOYcOG0ahRo0KPld7IkSNL9Z6EEEIIUf7KnPy6ffs2QLG6POpVqVIF0DVZF8LYFEVhzo4XGNsh/24Lr/dcwO+nJmBnJ+M9CCEqhkd6NyByQSgpKZloNEqeJM32LRd4bFAQf607zflzd2nQMMBMkYrsatSokeP3KVOmMHXq1GKte+bMGZ599llUVeWrr74y1P6ydlWrVmXOnDk5pnXo0IENGzYwYsQIfvvtNz799FPmzp1b4DZGjRpVrATvjRs3+O6774oVl6IokvwSQgghLFiZ7/6dnZ0BSE4uflcJ/bJ2dnZl3b0Q+Qp4wIvhEzvmnKjoXmnJmXz5yhpzhCWEEGZhZ6ehU5faADkSX9lzYGdP36JpsyqEHYkkPT1vy1lRBKMV/FIN/zARERHExcUZXu+9916xQomMjKRv377ExMQwadIkJkyYkGO+u7s7UPi1m35QIv3ojPp1Clsv9zqm9r///Q+Av//+u8hl9S31jPkSQgghhOUqc8uvqlWrcv78eQ4dOlTsro+HDh0C7rcAE6I8PPPWQ/zz63Fi7twbVVR/XaqB/RsvcnjHJdp0r2O2+IQQwpQaNqrEgX3hJCakoSi5a3/B+XNRPPFUC06euMXRw5G071hwtzFhGp6ennh6epZonejoaHr37s3Vq1cZPXo0M2bMyLNMzZq6UUCvXbuW7zaSkpKIjY3Fx8fHkMjy9PTEy8uLuLg4rl27RlBQUJ719NsrrMtheapfX1fzs6jRxy9fvmyKcIQQQghhQcqc/OrSpQvnzp1jzpw5vPLKKzg4OBS6fEZGBnPmzEFRFB566KGy7l6IQv24ZyzDG82+n/hS0P2swLTnVvL76Qm4ujuaMUIhhDCdxwY25o9fw3K0+Mr+86a/ztCydTXCjlwnqGkVPDyKX19KmF9iYiKPPvoop06dYujQocybNy/f7n0NGzbEycmJO3fuEBkZyQMPPJBj/pEjRwBo3rx5juktWrRg165dHDlyJE/yKyMjgxMnTuDs7EyDBg2M/M6KJyYmBrhfe6wg5krOCSGEEMJ8ytztcfTo0QCcP3+eZ555ptAm9MnJyTz99NOGIbD16wpRXpxdHflw8dD7E+51fVQ0CijwStd5ZotNCCFMzdfPjZo1vQ2/5+6plRCfRrUHPHFysmP/3ismjc3qqUZ+lVBaWhqDBg3i4MGD9OnTh99//73A8hIuLi706NEDgOXLl+eZv2LFCgAGDBiQY3r//v1zzM9u/fr1pKam0rNnT0NJDFNbuXIlAK1btzbL/oUQQghhucqc/OrUqRNPPfUUqqqyatUqGjduzPTp09m5cyfnzp3j3Llz7Ny5k48//pjGjRuzevVqFEVh2LBhdOvWzRjvQYhCtXm4Lh37189xtquqCgrE3klm5pvrzRecEEKYWJ/+jcjdGOh+90eV9f93ivYdAzl/7i43b8Tn3YCwOFlZWTz99NNs27aNLl26sGrVKhwdC2/VPGnSJACmT5/O+fPnDdP37dvH3Llz8fb2ZsyYMTnWGTt2LJ6enqxdu5ZVq1YZpt++fZt33nkHgLfeesso72nkyJE0atSI1atX55g+b948zpw5k2f5VatW8d///heA8ePHGyUGIYQQQtiOMnd7BFiwYAF3795ly5YtXLt2jSlTpuS7nL4YaK9evVi8eLExdi1Esbz7wyCebzOHuKhcLRM1sHPVadp0r0u3QY3NE5wQQpiQg4MdD7arQeiBCMM03deziqIoaLNU0jOy8A9wY++uywx9snmxRsar6IxZ9Lyk2/n+++8NSSJ/f39effXVfJebMWMG/v7+APTs2ZMJEyYwe/ZsWrZsSa9evUhPT2fz5s2oqsrChQvx9vbOsb6vry8LFizgySefZNiwYXTv3h0/Pz+2bNlCbGwskyZNonv37nn2+/HHH7NhwwZA1zUTdF0rO3ToYFhm9erVOUYODw8P5+zZs8TFxeXY1q+//sqLL75I8+bNadCgAVqtllOnThkSYm+//TZDhgwpwdG77+bNm4ai+R9//HGe7qC5RUZGMnnyZBRF4auvvsLX17dU+xVCCCFE+TNK8svZ2Zm///6b7777jhkzZhRYQLVGjRq8/fbbjB8/Xi6khUkpisK8kBd5Kmg22izVME3vmwkbqNe8Mg/UlgtXIYTte7BdDY6FXSctNTPbZ6Huvyqwe+clhjzejLWrTnD+3F0aNAwwW6yiaPpaV0CellLZTZ061ZD8Apg1axYtW7bk+++/Z/PmzTg6OtKzZ08mT55c4CBGjz/+OLt27WL69Ons37+f9PR0goKCeO2113j++efzXefixYscOHAgx7SEhIQc09LS0or1XseNG0dAQABhYWH8888/pKSkEBAQwNChQ3nllVfo2bNnsbaTn6VLl7Jo0SJatmxZZOIL4IEHHiAsLIxjx47RokUL3njjjVLvWwghhBDlS1GNPDazqqqEhYVx9OhR7t69C+ieQrZu3ZoWLVpI0suI4uPjDSMvlXQ0qIrqRngsr3T9GVVV856LCvx5egJOzoUP2iCEELYgIjya/1t9CtA9DMh+OaACQU0qk5aWyZ3bSTz9bCscHPKvH2WpTPUdqd/PG6N/xcnR1SjbTEtP5tuFI+T73cR69erFtm3b+Pjjjw0twIryxRdf8N5779GnTx82btxYzhEKIYQQorSM0vIrO0VRaNWqFa1atTL2poUos6o1vXnj60f59q18LlBVGN32B349/rokaYUQNq9GTV+8vJ2JjU3NUflenwg7dfIWTz3Tgr83nuP4sRu0ebC6GaMVovydOHECgHbt2hV7nQcffBCA48ePl0tMQgghhDCOMhe8F8La9Hi8Ce371Mt3XnJCOh8M/8PEEQkhhHn0HxBE7lS/qqqGaTt3XOKB6l4cOXSNtLRMU4cnhElFRUUBEBBQ/G6++m6k+nWFEEIIYZmMnvy6ePEiv/zyCzNmzGDatGmGro9CWJL35g7Gp5JbvvNOHozkz29DTByREEKYno+vK1WreaCC4WWgwo3rCTRtXpmsLC1HDudfz1MIW+Hu7g6Qp8h+YeLjdSOiFjW6phBCCCHMy2jJryNHjtC1a1caNGjA888/z7vvvstHH33E7du3cywXHBxMpUqVqF+/PhkZGcbavRAlNm/vi2js8u/e+PvMEE4cCDdxREIIYXqPPpaz9ZdKtgFBVNi4/gzNW1bj2NHrJCWlmyNE66Cqxn0Jk6teXde1d9++fcVeZ+/evQDFKpAvhBBCCPMxSs2v9evX88QTT5Cenp6jYG5+dZNGjhzJf//7X6Kioli/fn2ph6MWoqzsHez4ed9LvNDux3znfzB8GYsPv4qXn3EKGAshhCVycXGgXgN/Lpy7a8i5qKgoii4HExebRoMG/pz89waHDkbQ7eG65g1YiHLSvXt3Tpw4wXfffccrr7xS5GAD8fHxfP/99yiKQvfu3U0TpABAq9Vy/fp1PDw8pE6rEELYMFVVSUhIoFq1amg0ZWu7Vebk140bN3j66adJS0ujSZMmzJgxg4ceeggPD498l/fw8GDgwIH88ccfbNy4UZJfwqx8K7nzzo8D+PLldfnOf6H9Dyw7+yZ2dlIeTwhhu3r2bsDF87rklz7pZZ+ZRrOdKzjWdRhrV/9L6zbVObA/nFatH8DTy9ncIQthdC+99BLBwcHcuHGD/v37s2LFCipXrpzvsjdv3uSJJ57g+vXraDQaXnrpJRNHW7Fdv36dGjVqmDsMIYQQJhIREWFooV1aZU5+ffPNNyQlJREYGMju3bvx9vYucp3u3bvz+++/c/jw4bLuXogy69S3IV0Hn2fXmjN55mVlqrzS/Wd+2v2iGSITQgjTsLPT0KrNAxwOjTS0/qpzbCed1/9IonclzrXpRY2anhwLs+fA/qv06tPQvAFbIFVVc7R+L+u2hOk1adKECRMmMGvWLEJCQqhXrx7Dhw+nS5cuVK1aFdA99N21axfLli0jOTkZRVEYP348LVu2NG/wFYz+IXtERESRLfSEEEJYr/j4eGrUqFFg46qSKHPya9OmTSiKwltvvVWsxBdAo0aNALh8+XJZdy+EUUya9RinDkZy93pCnnm3I+KZOWE9k2Y/ZobIhBDCNDp0qsWxsOtkZKhoFKgbtgOAese2c65NT1avPEmnzrU5sP8qUVFJ+PnlP2iIENZsxowZxMXFsXDhQpKSkli4cCELFy7Ms5w+QTl27FhmzZpl4iiFvqujp6enJL+EEKICMEYX9zL35bp69SoA7dq1K/Y6+i+pxMTEsu5eCKP5ac+LaOzz/6PatfYMW5edMHFEQghhOoqi0LZDIAB2qSkEntkPQODp/dinpZKWloV/gAtOzvaEHogwZ6iWSTXyC2jbti1BQUEEBweb8I1UbBqNhvnz57NmzRo6duwI3G/Vl711X+fOnfm///s/fvrpJ6k5JYQQQliBMrf8yszMBHSFJ4tLP4S0fkhpISyBRqOw9Mh4RjT/Pt/5372zifqtq1Cznr+JIxNCiHJ27hwMHkybpCQaJKShyczAPlM3IrN9ZgYjP3mKLDsHlI/hCW8Plg3/iJgONfHxlQFBylNoaKi0ajGTgQMHMnDgQKKjowkLC+Pu3bsA+Pv706pVK3x8fMwcoRBCCCFKoswtv6pUqQLApUuXir3OwYMHAahZs2ZZdy+EUbl5OjNlybAC57/RaxGpKekmjEgIIUygcmXw8oLwcDxibuGWEJ1jtltCNJ6xt/CIuYXGxxuqViH0oLT+yk5VjfsSlsHX15cePXrw5JNP8uSTT9KjRw9JfAkhhBBWqMzJry5duqCqKsuXLy/W8unp6cydO1eGhRYWq1XXWvR+uln+M1V4oe2PUoxYCGFbvLxg92748ENQFLRKzssDraJBVRQO9B7FgpEzaN6lIWfP3CYuNsVMAQshhBBCCFF8Ze72OGrUKJYsWcL//d//sXnzZnr16lXgsunp6YwcOZKLFy+i0WgYN25cWXcvRLl49bM+HNsbzq3wuDzzkhPTeXvwL8xY+5wZIhNCiHJibw8ffQTe3mgmTcoxS6Nq2TXoNcK6PQlaqFLVAxcXBw6FXuORXvXNFLBlkdEebc+tW7fYsWMHJ06cIDpa1xrS19eXpk2b0r17dypXrmzmCIUQQghRXGVOfnXv3p3hw4fz559/MmDAACZMmMDjjz9umH/lyhViY2PZu3cvP/30E5cuXUJRFF5++WWaNGlS1t0LUW5+3DmWYfW/ISszbz27C8dusejTnYz6XzczRCaEEOUoLAzs7FCzslC4V39do8E/8gKqCooCq1ccp32HWoTsvUK79jXw8HQ2c9BCGM+NGzeYNGkSq1atMtS2zc3e3p7HH3+cr7/+mqpVq5o4QiGEEEKUVJm7PQIsWrSIfv36kZ6ezowZM+jYsaNh5JsBAwbQpUsX/vvf/3Lx4kVUVWXIkCHMnj3bGLsWotwoisIvx14tcP6an0I5uPWiCSMSQohylp4Oq1ZBVhbYO3Ci4wC0dvZotFrq/bsTTWYGqgrp6Sq1avvg6GjHoUPXzB21ZZCiXzbh2LFjNG/enGXLlpGRkZFnpEf9KyMjgz///JMWLVrw77//mjtsIYQQQhTBKMkvJycn1q9fz9y5c6lTp06BFwrVq1dnzpw5rFixAjs7O2PsWohy5eLmzPRlwwuc/+mY1dwMjzFhREIIUY5CQiAxERo2RDlymF1Pv8vvb84jJqAGjmkpVL1ywrDoyhXHaf1gdWKiU0hKkoFAhPVLSkqif//+REVFoaoqPXv25M8//+TKlSukpqaSmprKlStXWLZsGb1790ZVVe7evUv//v1JTk42d/hCCCGEKESZuz1mN27cOMaNG8epU6c4dOgQt2/fJisrCz8/P1q1akXr1q0NLcKEsBZN29Vg+ISO/Dl7H6Dr8gP3H8y/3G0+f5x4A2c3RzNFKIQQRtKkCcyaBePGgasr7VIj2Juh5fe35tNk3zqiq9Q2LJqclEn9Bv4c3B/O8bDrdOxcy2xhC2EM33//PdevX0ej0TB37lzGjBmTZ5maNWtSs2ZNhg0bxoIFCxg3bhyRkZEEBwfz9ttvmyFqIeNqN2sAANJXSURBVCyPVqvl7t27eHp64uws3eKNSavVcvXqVXx9ffHy8jJ3OMUWFRUFgJ+fn5kjKZiqqkRFReHm5oaLi4u5wykRVVUlz1IMRk1+6QUFBREUFFQemxbCLJ5+szPnj93g6M4r92reKCiKCiioqspzrb7nj9MTsbMzSmNKIYQwj4AAmDDB8GvrNg+wb+9VMhycCev6xL2pusy/qsL/rT5Bk6ZVOH7sBg+2q4GDg7TqFtZr7dq1KIrCqFGj8k185fbCCy8QEhLCggULWL16tSS/TCA4OJjg4GCysrLMHYooRHx8PLdv3yYlJYXAwEBzh2NTLl68SFpaGklJSVaT/EpLS+PGjRsAeHt7W2wPsMTERG7evImTkxP161vHYD6qqnL69GkAGjduLAmwIsiduhDF9OGiYVSr7QPoR+LSlYJWFIXMDJXnWn4vI3QJIWyKRqOhWQtdMW/951v2klRRUSk0bVaZtLRMTp+6ba4whTCKc+fOAfDUU08Ve52nn346x7qifI0fP55Tp04RGhpq7lBEIdLS0gBdKyVhXPpja030rb4AUlJSzBhJ4fRxWtMxTkpKQqvVotVqLfrYWgpJfglRAsHbxuDh43wvq65PgOmkJGYwrtNcs8UmhBDloUvX2igK+T5NVBSFvXuuULeeP0ePRFboBwCqVjXqS5heYmIiAL6+vsVex8dH91AsKSmpXGISArC6z9b0dF0dSGuLW5SPuLg4w8+WnKCxxs/x27fvP3i0xvhNrczJr6ysLPbv389XX33FuHHjGDZsGH369OGJJ57gpZdeYubMmRw8eFAy/8JmLD78Kg6OGvQtv7KLupnEm/0WmSMsIYQoF3Z2GurV9wfy1pRQVZVLF6Np3eYBYmNSuHwp2lxhClFmAQEBAIYuJMVx5swZAPz9/cslJiFuh4dz6623iLt1y9yhFFtGRoa5QxAWJHs3ZUtuVWWNydrsg61YcmLRUpS65ldmZibBwcHMmDGD69evF7l8jRo1ePvtt3n55Zcttp+vEMWh0Wj49cQbDG80C1WbtyXEldNRfDR6BVMWDjNDdEIIYXw9e9Xn/Lm7QN6LQ1WFiPAYqlb14MjhSOrUtdxituUpe3dQY2xLmF6HDh1YuXIlM2fOZPjw4djbF36ZnJmZycyZM1EUhQ4dOpgoSlHRpP32GzW++YaIypXxevddc4dTLNbS8ktVVTIzM3FwcDB3KBVGZmamuUOwWZacWLQUpWr5FRUVRY8ePZg0aRLXr19HVdUiXxEREbzxxhv07t2b6Gh5MlwWwcHBBAUF0bZtW3OHUmE5ONix5MirBc4P23GV4Pf+NmFEQghRfhyd7KkZ6J0jKZM92bN3z1VatalO5LU4bt1MME+QQpTRyJEjAQgLC6N///6FPty9fv06AwYM4MiRIwCMGjXKFCGKCsjzn39y/NfSabVaQ4LD0pNfUVFRnD17ltjYWHOHUiyWfjyLQwarKD/6pLMoWIlbfmVlZdG/f39CQ0MN3R969+5Nz549ad26NX5+fri7u5OQkMDdu3c5evQomzdvZuvWraiqyo4dOxg4cCC7du1Co5GSY6Uxfvx4xo8fT3x8vNWM8mGL3L1cmLPjBV7tviDf+Vv+OEFAFXeenNDZxJEJIYTxPdKrHvN/yllkWlHuJ8Ccne0IDPThWNh1evdtaIYIhSibAQMGMHjwYNasWcOWLVuoU6cOvXv3pn379lSqVAlFUbh16xYHDhxg8+bNhhuNIUOG0L9/fzNHL2xSUhIee/YA4LF7NyQlgZubmYMqnDV1edTX+UtNTTVzJMUTHx9v7hCKTavVkpycjKura57plsgWknK2kBwtbyVOfn3++eccPHgQRVFo1aoVS5cuJSgoqMDle/bsydtvv82JEycYOXIkYWFh7Nu3j6+++op3raTprhAFqRrow8d/DGPyUyvynf/7rP34VfPkkSeamTgyIYQwLk9PFzw8nUiOiqfV3pUc7fw4WQ5Ohvlr15ygXftA9u8Lp2u3Oji7SDcSYX1+//13Ro4cyfLly0lPT2fDhg1s2LAhz3L6m4wnnniCJUuWmDpMYavOnYPBg3VJrqws1NRUNPeSSZqMDAgMBGdnsLPTJcHWrIEGDcwacm7ZW59Y+s24vl5S9rpJliwiIsLcIRRbdHQ0N2/epFKlSjmmW2ryS+plVQwlanqVkZHBt99+a0h87d27t9DEV3ZNmzYlJCSEVq1aoaoq33zzjfT5FTahaftAXvuid4Hzv3/nH47sumTCiIQQonz0eKQu9f/dRZcNc6l3YheoKrrBb1Uy0lXq1PVF1aqcOmU9hZmNRqsa9yXMwsnJiT///JN169bx6KOP4uLikqeUh4uLC48++ijr16/nzz//xMnJqegNC1EclSuDlxeEh0NkJEpUVM75UVEQGamb7+UFVaqYJ85CWFPyS5+IsZbklzXRJ5Nyt6qz1ORX9hEpLV1WVhbR0dFW1crSUpQo+bVu3Tru3LmDoij88ssvODs7l2hnzs7OLF26FEVRuHPnDuvXry/R+kJYqkeebMbQVwuuwfbx86u5fOp2gfOFEMIa1KnrT4N/dwJQ/9hOUBTdzc29sT+2/nOeevX9OX7shsXf9FiDtm3bEhQURHBwsLlDqXD69+/Phg0biIuL4+zZs+zbt499+/Zx9uxZ4uLi2LBhA/369TN3mMLWeHnB7t3w4YdA7jHF0fU1B5gyRbecp6dJwyuO7Dfklvw9YAvd3CyZ/jywluSXvgusNYiKiuL69evcuHHD3KFYnRIlv/bc63Pes2dPGjVqVKodBgUF0atXLwB2795dqm0IYYmee7srHfvVL3D+pMeWcue69fTVF0KIPJKSqH32AAC1z+zHPj3l/t2ZqnI9Mp7mLaoQE53CtQjreYpqDCpFD/5T7Ne9gxoaGsqpU6cYP368md9dxWVnZ0f9+vVp37497du3p379+jJquShf9vbw0UfQuzd5xhRXVejTB6ZO1S1ngayl6La1xGmt9Emv3MfZUhOi1tSKSj+qozUl7CxFiZJfhw8fRlEUHnnkkTLt9JFHHkFVVQ4fPlym7Qhhad4JHkjdZpXzneeQlcHGps+QeDvGxFEJIUQpnTsHQUG6OjOBgVCvHpoM3YWsfVYGoz9/hjGfDmfMJ8MZOWMkXnciuHUjDl9fF44fkyeSQghRap6eqIpy//kCgEZjka29srOWbo9S46n8aLVai23hZQv0iTo5xiVXokcG+iJ7zZs3L9NO9etfvXq1TNsRwhLN+L9nGdNxLtE3c2bjOyb/y8iYDXzT7DVeu7YEBwd5ciyEsHD6+jOnT+c72z0h2vDz9ZpBJLv7smf3Vbo+XI/dOy+RlJSOm5ujqaIVwqiOHDnCli1b+Pfff4mO1p3rvr6+NG3alJ49e9KmTRszRyhsVno6bNqEoqqoGg3Rgwbhs24dZGbCpk26+Y6W+dlqLS1oEhISzB2CzbKWc8BaSavF0itRyy99ITgfH58y7VS/vjUVlhOiJH4OeREn15y55U5JxwDomHicEU2/lWy9EMLyZa8/oyi6VgfZaBUNqqKwr+fzLHvlW9Kd3dBqoWagF94+Lpw/d8dMgQtRekeOHKFDhw60bduW9957j99++41NmzaxadMmfvvtN/73v//Rrl072rdvz6FDh8wdrrBFISGQmEiGvz+KVktS+/Zc+PNP3ciOCQm6+RYoKysrRy0tS275ZW1dxiz5WOZmC8kvSz3eWq1WBg0sgxIlv+LjdfWK3N3dy7RTNzc3QDLuwnYpisKvx19HY6er1uCkTaN1yhkA2iSfRpOawsiWUsBYCGEF9PVnvv4aciXtNaqWnQPGs6/XaLSa+wn/v/86g7+/G0cPX7fYC0gh8rNixQo6depEaGiooQabg4MDlStXpnLlyjg4OBimh4aG0rlzZ5YvX27usIWtadIEZs0iOSgIAM9//iGtQQM4ehRmzdLNt0DWUt8JLDu2/FhTsk5fk8pa5Df4gaWeH7aQWDSnEiW/jD0qhrR8ETbr3DnsmjVlefos5kZMZ07k5zig+/txIIs5kZ8z89SHRDn56erpnDtn5oCFEKIIYWGQrdC3iq7lV0Dk+RyLqSrcvJFE46BKREclc/uW9Vywl4WqGvclTO/s2bM899xzpKenY2dnxyuvvEJoaChJSUlcv36d69evk5SUxKFDh3jllVewt7cnIyODkSNHcubMGXOHXyEEBwcTFBRE27YFj7BtEwICyBo9Go99+wDw2L0bJTkZXF1hwgQICDBzgPnT35jLoBDGZ03lgqytnlruESnBckcDleRX2ZQo+SWEKKZ7dXI0ERFUyorFNytnK0ffrAQqZcXilx7N5etpUKWKmQIVQohiSE+HVasgKwscHODFF8HBAY2qpf6JXWgyMwwJG+Xe8GQJ8Sm4uTly8sQt88UtRAl88cUXpKWl4ezszD///ENwcDBt2rTJcSNvZ2dH69atCQ4OZvPmzTg7O5Oens6XX35pxsgrjvHjx3Pq1ClCQ0PNHYrxZR9gpHp1tIGBaO7d6GoyMmjQpw9Ur66bb6EPTvUtvxzv1SOz1NYztsJSEzTWlvzKrxSTpbZek3pfZVOqMXLnzJlDpUqVSr3T27dvl3pdIayCvk7Oxx/Dxx+jKgpKtpaOWSgowDLvniz36knd59fx5eoR5otXCCEKc6/+DA0bwvLl0KwZymuvEd97AJ43r1L1ygki67W6t7AKKOzYdokWrR7g1MlbdHu4DnZ2Nv68TavqXsbaljC5LVu2oCgKEydOpHv37kUu361bNyZOnMjnn3/Oli1byj9AYdtyDTDikGu2Q2wsxMbqfunQwSIfnOpvzJ2cnEhJSbHY5Jet9D5KS0vD1dXV3GHkYW0JmvxKMVnqOWJtx9bSlCr59cMPPxg7DiFsj75Ojrc3yqRJOWbZoTLfdyDrvboCcOHYTd5/6g8++eMpc0QqhBCFu1d/hnHjdN1uAJo1I2XvAQ5PnE5U5dr3Wn6paDQKqgqZmVrqN/DncOg1rlyOoW49PzO+ASGKdueOboCGfv36FXud/v378/nnnxvWFaLUsj84nTbt3mOE+wy/T5kCH3ygu860IElJSYa6VI7ZRqJUVRVFUQpazSwstVVPScXFxVlk8stSk54Fya8rYUpKCp6enmaIpnC2cu6aS4kfw+qLfJb1JUSFkU+dnCwUaqdFonD/wub0wUgmP/2nGQIUQogiBATo6szkusiuXKcyJ3o8SYq7173ujsq9mvgqqgonjt/AP8CNUycrQNdHI10fqVL0y2wC7tVRcnZ2LvY6Tk5OAPj7+5dLTKKC0T847d2b3OkiBaBPH5g61eISXwCRkZF5uj1aKmvrllcQSxw8zlJbTJWUpbawyq8+mSi+En1ybt++vbziEMI25a6TM3o06vwF2GVl0jH5BD+qmWRqHAw3OicPRvLu0F/5YpV0gRRCWIcWLasReiAix4Mt/Y//Hr9Jt4frErLnCmmpGTg55+7II4Tl6Ny5M8uWLSM0NJQHH3ywWOscPHgQgIceeqg8QxMVjacnqqKAqqKge3CKRoNigS1RQNc4InuyQJ8U1s+ztJZf+dV4smTx8fH5TrfEBI2tFGS31CSTrRxfcylR8qtbt27lFYcQtimfOjma114jqfcA3G5epWHaVU661LtfIRo4f+wWkx5bwsz1I80YuBBCFE/7DoGEHojIMU1RFEMy7IHqHjg52XHhQhRNmlpejRoh9CZNmsTKlSv59NNPGTZsmKElWEFu377NZ599hoODA2+++aaJohQ2Lz0dNm1CUVVUe3uiBw/GZ80alMxM2LRJN9/CWlbl7opl6S2/kpOTzR1Cidy6ZT2tp20lOWOJ3QttpVWdOZmt+uzRo0flQkHYPn2dnCNHoFkz3bRmzXC7eIozI98mwjH/G8Erp+/yRu9F0kVYCGHxnJztcXNzQFX1Sa+c9T5C9obj4enM+bN3zRilEEVr27Ytc+fO5fbt27Rv3541a9bke7Oh1WpZu3YtHTt25M6dO/zwww+0a9fODBELm3TvwWlqrVpc+PNPrk+ZwoU//yQtMBASEnTzLUzullTZW3pZ4rWsJcZUEFVVLTIRUxBLbI1WmLt3refaxFYSi+Zk0g7jN27c4JdffmHp0qWcPHkSgG+++caUIQhhWvo6Obm5utJo8Zc8u/w4c/6b/whR1y5G8+rDC5iz/QWLay4uhBDZtWpTnT27LqO9N0qhqoJGo6DVqly5FE3Xh+sQsvsK6elZODraFbE1IczjhRdeACAoKIhjx47x+OOP4+PjQ6tWrahUqRKKonDr1i3CwsKIjo4GoEWLFuzZs4c9e/bku01FUZg/f77J3oOwAU2akPX111zs0gXVxQWAtAYNuLB8OU1CQnQPVi1M7gEfLD35ZU2sLeGRlJRk7hBKJCoqytwhFJu1JRYzMjLQaDTY2VnOdV+5J79SUlJYtWoVS5YsYdu2bYYnaJbY/1sIU+v5RHNQFea8tznf+bci4nipyzzm7h4nfy9CCIvV+kFd8is73fe8LhHm5+tKZqaWy5eiaNiokpmiLF+qVkXVGucmz1jbESWzaNEiw3etvutudHQ027Zty7Gc/mZeURSOHTvGsWPH8t2e/lpXkl+iRAICONOtG36//krUiBGo9+pnqS4u+T9QFTbN2hIe1tSlVFVVq0ouWlOsANevXychIYFq1arh6+tr7nCAckx+bd++nSVLlrBq1SrDsLfZLxaEEDo9n2yGRqPw/bv/5Dv/7o1ExnSYy/z9L8nfjhDCIjk42OHp5URcbJoh4ZVdaGgEAZXcOH/urs0mv4T1q1mzpnzPCovguXkzVb75hozKlYnr39/c4ZSYJbf8sra6SdaUTALrStBYU6xgmXXICmOJo78aNfl15swZlixZwq+//sq1a9eA+x949vb29OnThxEjRpCSksKYMWOMuWshrFqPYU1Bo/D923/nOz/2bjKj2v7AwoOvoNHIhbkQwvK061CTLX+fv1f7K2cCLOJqHA91rUXogQgyM7XY25ut5Gj5Ue+9jLUtYXJXrlwxdwhCAOD5zz+G/1pj8gvut560tOSXtSU8rK0bYX7c3Nws8n1YW6s6Sx2BMj/ZR4C1pORXma8+o6Ki+P7772nXrh1NmjThiy++ICIiwvBh16lTJ4KDg7lx4wbr1q3jqaeewtXV1RixC2FTegxtwutf9S5wfkJMKiNbf09WlnU9sRJCVAzNmldFo8nb6kuvUiV30tOzuHolxrSBWbG2bdsSFBREcHCwuUMRQphKUhIe92rIeezejWLhLX8KSm5ZaitKS0zCFCYlJcXcIRRbQeeCl5eXiSMpHkl+lZ+MjAxD138HBwdzh2NQqpZfGRkZrFu3jiVLlrBp0yZDBl1/wjdu3JgRI0bwzDPPUKtWLaMFK4Ste3hoUxSNhm/f2pTv/OSEDJ5r+T1Lw17Dzs4GW04IIayWRqPBzd2ZuNjUfLo+qhwLu079Bv5ERMRSt56fucK0KqGhoXh6epo7DCFEeTp3DgYPhqQkyMqC1FQ09+6tNBkZNOjTB9XREezswNsb1qyBBg3MGXEORbWksrSWX7lHprR01tRNs6BzwdPTk+vXr5s4mqJZUzIJICsry9whFJu+i6ajo6NFJcJLlPzav38/S5YsYdmyZcTE6J7c6j/QHnjgAZ566ilGjBhBy5YtjR6oEBVF98FBKCrM/k/+CbDU5ExGNP+OX4+9jp0tdh0SQlitVq2rsWPbpXvXBtkvdhQuXoii9YPVOXPqFt2617GoiyEhhHUIDg4mODjYqm4Ci1S5Mnh5wenT+c52iI29/0tgIFSpYpq4iik2e3zZ6D/jLS35ZU0tvyzt2BWloJZU9vblPsZeqVhTPTVrSoLC/XMhIyOD+Ph4i3mQV6I7506dOjF37lyio6NRVRVPT0/GjBnDtm3bCA8P56uvvpLElxBG0G1IEBNm9i1wfnpqFk83/ZbMDBu6+BNCWL3mLasB+lZfaq7/QZVqHsTHpxEdbT0XnMWlL/dgrJcoX5MmTWLSpEncvn073/lZWVmEh4cTHh5e6HYuXbpE69atadOmTXmEKXIZP348p06dIjQ01NyhGI+XF+zeDR9+mO9sfTnB26+8olvOQm4i9Qr6GxJll5mZae4QSsTauhFaU7zWVqtO3/JLq9Vy9+5dM0dzX6majSiKwtixY4mMjGTevHl0795dnuAKYWTdBhWeAMvM0PJ0029JT7WuD0MhhO1ycrLH2dn+Xr32bNcF9+7eIsJjsLNTuHJJ6n4J85o1axazZ88u8KL8zJkz1KpVizp16hS6nZSUFMLCwggLCyuHKEWFYW8PH30EvfPWflWAxE6duP3qq7rlrISltvyyJvklZ1xcXMwQSfEkJiaaO4RiU1XVqlpTWVOiDnKOTGlJeaISJ7/0H2Dz58+nbt26vPHGG+zbt8/ogQkhik6AZWWqPNP8e9IkASaEsBANGwcAoMlIo92uP7DLSEdRFBRF4dyZO1Sv4c3ly1FmjtL4VC2oWtVIL3O/G6EnN+7CpDw9URXFMOCrCqgaDVnu7uaMqlQk+VV2+XXR9PX1NUMkxWNN3QitrSWVtcWbvZ6aJRW8L1Hya8eOHYwaNQp3d3dUVeXWrVsEBwfz0EMPUbduXSZPnszpAvqrCyFKp9ugICZ+82i+8xQNaLUqzzT7jqSEtHyXEUIIU+rQsSYKCg1P7qL7pp9ocHK37gmrqpKSnEVgoA8R4bFkZkqGRwghDNLTYdMmFFUFe3uihw0De3sUrRaPPXtQrOzm1xJZU0sfyL8llYeHhxkiKR5r6qZpzS2pLJ1Wq81Rl9GSYi9R8qtr164sWLCAW7du8euvv9KnTx80Gg2qqnL58mU+/fRTmjZtSqtWrfj666+JjIwsr7iFqFC6DmzMpFl5E2CqFjQaBVR4rmUwsXet54mLEMI2eXq5YG+vocG/OwFoeGIn90qAAWBnryEjQ0vktVhzhSiEEJYnJAQSE0mtVYsLf/7J9SlTSNmzh7TAQOySk3G1sq61ltjyy9oSHvm1pLKzszNDJLbHkhIyxWFNrepy/51Z0gAlpar55ezszNNPP83GjRuJiIjgyy+/pHnz5oYircePH+edd94hMDCQ7t278/PPPxc4EogQongeGtCYt769nwBTFNDYKbqLCkX3+wvtfyTiouUUFRRCVExVfeyoc+4gAHXOHsAhPcVQAuzc2dsE1vLh5o0EM0YohNCbOXMmQ4cOpX79+nh5eeHk5ERgYCAjR47k33//LXC9RYsW0a5dO9zd3fH19aVfv36EhIQUuq+9e/fSr18/fH19cXd3p127dixZssTYb8k6NWkCs2Zx6ZdfdC290tJwbd+eC8uXc+Pdd0mtW9fcEeZR2E2tJSa/EhKs/3vHkuonZWdtreqyd8uzBtaUrMud/LKkFoGlSn5lV6VKFf7zn/8QFhbG0aNHmThxIpUqVTIUkdu9ezcvvfQSVapUYciQISxbtsyqMpdCWJLO/Rvz37kDAd1oaqqq3v8SVHTdICf0XsK/B66aMUohRIVz7hwEBUFgIAQGMuy9odhn6bro2Gdl8OLXz/Hyl0/x8ldP0eetofhGXeP8Odur+yWENfr000/ZuHEjvr6+PPLII/Tv3x9nZ2eWLl1KmzZtWL9+fZ51Jk6cyOjRozlx4gQ9e/akXbt2bN68ma5du7JmzZp897Ny5Uq6devGpk2baN68OX379uX8+fM8//zz/Oc//ynnd2kFAgJgwgQ8du+myjff4LllCwCqiwtRzz5LlgXWeoqPjy9wniUmaaKjo80dQrFZUtKwOKytVV1+9dQsWUHJRUv8O8t9LlhSa8UyJ7+ya9GiBTNnzuTatWusX7+eJ598EicnJ1RVJT09nf/7v//j6aefZty4ccbcrRAVSrue9fj4tyfQ2GHoRgQYCkorGvjouVX888cxs8UohKhgKlcGLy8ID4fwcOzv3s4x2z0xGq+423jF3SbNyQ2vBoHcvJFgU3W/dA8kjPcSwlTWrl1LTEwMBw4cYNWqVaxatYqzZ88SHBxMRkYGY8eOzfHkfsuWLcyePRs/Pz+OHTvGmjVr2LRpE7t27cLOzo7Ro0fn6fERHR3NCy+8QFZWFitWrGDHjh2sWLGCM2fOUK9ePb7++mt27Nhh2jdugbRaLZ7//ANg+K8lK06JG0tK4lhT0XBL6ipWHIW1pLKkc0DPmpJ1hZ0Lbm5uJoykeHK3UrOkvzujJr/07Ozs6NevH3/88Qc3b95k7ty5PPTQQ4D1DSsqhCVq0r4G3/w1EkWjoNXm/ELRPwH46cNtzPtoqznCE0JUNF5esHs3fPjhvT7ZOS8vtIoGFYU9D4/kl3GzSVCcyMrScvOm9XdBEcLade7cGWdn5zzTX331VerWrcutW7c4deqUYfrMmTMB+OCDD6hfv75heseOHXn55ZeJjY1l/vz5Obb1888/Ex8fz6BBgxg6dKhheuXKlfnyyy8B+Prrr436vqzR6UOH8NizBwCP3bshV+sUS0wiFMQSuz1aE2tKzoB1taSytnOysMSil5eXCSMpnpSUFHOHUKBySX5l5+npybhx49i1axcXL15kypQp1LXAPutCWJsa9fz5OeRF7Bx0Lb7y+yD/+9fjTB7xp9V9yAshrJC9PXz0EXz9NeR6yKVRtWzt9wp7e45CtbMj/GoMDg4aIiPizBRsOZCmX8IG6Yeod3R0BHQ3Ndu2bQNg2LBheZbXT1u3bl2O6Rs2bChwHX03yy1btlhdHZ4yy95lvHp1GvTpg+ZeKwlNRgYEBtLgkUdo0Ls39QYOJDNbElKUTFGNLyztWjm/kR4tWWHxWtqxtaSWSMVR2Oeiq6urCSMpHkv+HLc35c5q1arFlClTmDJlCnv37mXp0qWm3L0QNsfb340lh8YzttOPpKXk3yT2dOh1Xu7+M8FbXsDewXL6XAshbFRYGNjZoWZloaDrna0qGirfuKC7AFbh5s0katXyIfKaDSW/hFWaM2cOlSpVyjP99u37XXenTZtW4PrZl7M1S5cu5ezZs9SvX9/Qwuvs2bOkpaUREBBA9erV86zTunVrAI4fP55j+rFjx3LMz87R0ZGmTZty6NAhzp07R/PmzY39ViyXvsv46dMAOOSeHxWF470fk5s351JCAkGmjK8MLK3llyXfkOcnLs66vh8LSyhZWq8vayoeD4Wfu/oHFJbC0rvrmjT5lV3nzp3p3LmzuXYvhM1wcXNk8aHxjH9kIVEFdCGKupHIyAfnMD/kJVzcHPNdRgghyiw9HVatgqwscHAgrEUfmh3ZhJ02kwYnd/PXwElo7XUXapWreHDy35s5B+6wYqpWRdUa5ybPWNsRRfvhhx8KnKc/Lz/66CNThWNWX331FSdPniQpKYnTp09z8uRJqlWrxu+//24oWBweHg6Qb+ILdPVnvL29iYmJISEhAQ8PD+Lj4w038gWtV716dQ4dOsTVq1crVvJL32X8449h2jRUDAPj6txr2X/nlVe4/eKLuha2VsLSkl+569DllpWVhb0FHV9rStAUlfCwluSXs7OzRSZJralVnaV31y33bo9CiPJn72DHjzvHUKdJ3qfXeukpmTzXKpjo29bVjFoIYUVCQiAxERo2RDl8mK1PvMXCV+YQ5Vcdp/QUakScJPtIHT6+LsTGWG5tCGHbVFU1ystW/P333yxevJgVK1Zw8uRJAgMD+f3332nTpo1hGf1NWGFdbfQFmBMSEnKsU9h6udfJLS0tjfj4+Bwvm6HvMt67N3keA6gqiZ06cfvVVy0u8WVpCY2ixMTEFDrf2rrCWZKiEkaW1hqooPpkllg/S1VVq2pVZ+nJL8v6FBXFEhwcTHBwsMV9kAjzUhSFL1eP4IvxawndfKnA5V58aB4z1o6gVuOCE2VCCFEqTZrArFkwbhy4ulLt+FEup9Vh4atzaXFoA7crBaIouoE6bt5MIDw8lps3E/DxtbyaFcK2bd++3dwhWJwtW7YAuhYy//77L9OmTaNbt25Mnz6d999/36yxffbZZzbfAk/r7q5rLaWq95NgGg1Z7u7mDKtABSUq9Syt5VfuOLy9vXO0BktNTcXFxcXEUdmGogqcW1piMTk5Od/pPj4+3Lp1y8TRFK6oFoCWlvyy9BaLkvyyQuPHj2f8+PHEx8dbZIZamNe7wYNY9NlO1i88UuAy/xn0K/8JfowOveoXuIwQQpRYQABMmGD4tWnTKly5HEOmozOHOj2OqqqGJueRkTG4uTty+3YijYMqmydeC9e2bVvs7OwM3/vCeLp162buECyWt7c3Xbp04a+//qJjx45MnjyZ3r1707ZtW9zvJWIKunmE+60qPDw8AAzr6Nfz9PQscp3c3nvvPSZNmmT4PT4+nho1apTwnVmw9HTUjRvRqCqqvT3Rgwfju3YtZGTgsWcPSkYGqoXV9omIiCh0vqUlv3KrWrVqjuRXSkoKPj4+5gsoG2tr4FBUfTJLaw1U0PG1pG6vetbWqs6SR3oE6fYohE0a9V43xnzYvdBlZoxfz/I5+00TkBCiQqpbzw8AbbbuYfoaXxnpKpUquXP7lm10xS6PwR5DQ0M5deqUJL6EWTg4ODB8+HBUVTWM3lizZk0Arl27lu86SUlJxMbG4uPjY0hkeXp6Gh7WFrSefnpgYGC+852cnPD09MzxsikhIdjdu2m89dprXJ8yBQ4fhgYNsEtOxjUszLzxWbn8EgT6OnZ6BXWFMwdLSxYVpaiEhyW9H0tNxhakqOSXpbX8kuSXEMIsHn22Ff+dO7DQZf6ctY+vJ6wrdBkhhCgtVzdH9LXscxa11118urvpWn4JISyTv78/AHfu3AGgYcOGODk5cefOHSIjI/Msf+SIrtV57qL1LVq0yDE/u4yMDE6cOIGzszMNGjQwavxWo0kTUurVA8Dl+HGaNm0KzZrB0aPcePddUuvWNXOAJWdJLb+Kk9iypO5a0dHR5g6h2Irz72tJyS9LiqU4ijp3MzMzTRRJ8VhaPLlJ8ksIG/bgw3X5cvWIQpfZt/ECkwYssYiLEyGE7XHLNcJs9tZN6RlZxMWmkppq2RdLQlRUO3fuBKDuveSLi4sLPXr0AGD58uV5ll+xYgUAAwYMyDG9f//+OeZnt379elJTU+nZsyfOzs7GC96auLridPUqAB67d4P+htfVFd+PPiLL19eMweWV+5oxv5Z4lpT8un37trlDKBFrGtChOPW8LCnhZElJzuKwpnpqlp74Akl+CWHz6jSpxI87x5B3CKH7ws9GMbr9D2SkW1a/cSGE9atVS1dDJb8boPh4XXP+27cLL5xsFcqj36MQ5Wzv3r1s2rQpT9eZjIwMvvvuO5YuXYqLiwvDhw83zNPX3po+fTrnz583TN+3bx9z587F29ubMWPG5Nje2LFj8fT0ZO3ataxatcow/fbt27zzzjsAvPXWW0Z/fxbr3DkICoLAQKheHQID0dy7idVkZOSY7tSqFY5Xrpg33lxyF7u39PprubuOVapk2YM+WVodp8IU1S0PLCv5ZU2JxeIkkywp+WUNiUVJfglRAfhX9WTJoVdxcCr4Tz4xNo0RLb4jPsay+2oLIaxLo6AAQy4ne17HLiONuqvmU6uKC7HyuSOEWZw/f55HH32UypUr07dvX0aMGEGfPn0IDAzkjTfewNHRkUWLFuVIbvTs2ZMJEyYQFRVFy5YtGTx4MP369aNr165kZmaycOFCvL29c+zH19eXBQsWoNFoGDZsGD169OCJJ56gYcOGXLhwgUmTJtG9e3fTvnlzqlwZvLwgPBwiIyEqKuf8qCjd9PBw8PIi8173U0sRHh6e4/ec3dpzTrOEll+5BQQEmDuEAllD65nsiip2b2kSE62n1EJxEouWlCgtbCAUSyHJLyEqCFcPJ5YcHo+3v2vOGfp6PBoFrVblhfY/cvm0dTUPF0JYrqrVdIWus9//qCo0Or2Hrn/9hP+ev22m6L0Q1qZbt27873//o2HDhhw/fpzly5ezd+9efH19ef311/n333958skn86w3a9YsFi5cSOPGjdm8eTP79u2jZ8+e7Nq1i8GDB+e7r8cff5xdu3bRp08fjh49yl9//UW9evVYtGgRX3/9dTm/Uwvj5QW7d8OHHwL6KojZ6JNJU6bA7t1os42YaS0sOfmVX7LOUlhS4f3iyN0K0JJptVqrSi4WJ/lVnGVMxRrOBcsbz1MIUW4cHO35ac+LvD3kF66evmuYrmgUwwhsKipvD/qVl6c/Qs8nmxeyNSGEKJq+5peqqmjuJdkVBRqf1NUSanRiFwdihpozRCEqrNq1a/PJJ5+Uat1Ro0YxatSoEq3TuXNnNm7cWKr92Rx7e/joI9i/H+Wff3LOU1Xo0wemTjVLaMZgKQkma0p2gHUVu4f8Rxt0cHCwqO54epY+EmFuxWmlZinJZVVVpeWXEMLyaDQKX699jra9dKMKoXI/8aX/AFXgx8lb+eq1/0OrtYwPVSGEdVIUBXt73eWG/iPGIT2FuudDAXjg+F4Sb1rXxX5+VK1q1JcQooLw9Mzb8kujgXyKyFuC3N2sqlatWujy5r45z51MspSkXEGsqeVXfokvgGrVqpk4kuKxhuRMdsWJ11KSjJbUAq0w0vJLiArq3eABLJ+znz9n7zNMy91E/eCWS7zY5Se++3s0Lu6O+W5HCCGKUiP1Fr1/eAeHDF0xVE1WJvZZugs2u8wMnpg8DHWmu64XtpsbrFkDDRqYLV4hhDCJ9HTYuNEwJpGq0aDY2UFGBmzapJvvaFnXX1dyFd/38/PLdzlL6faYe6TH2rVrmymSopn7WJVUQQXO3S20m25MTIy5Qyg2VVULTC7mXs4SWEtiUVp+CVGBPfFqBz5cOFTX6itbSwNFUQwXLXFRKYx8cA6Rl63nC0MIYVl8G9cm1dkdr7jbeMXdxiMx55N494RolPBwQ3FnqlQxU6Slp2LEwR5LuO/k5GTWrFnDmDFjaNiwIc7Ozri5udGiRQumTZtWaNeJRYsW0a5dO9zd3fH19aVfv36EhIQUur+9e/fSr18/fH19cXd3p127dixZsqTA5Tds2MD7779Pz5498fb2RlGUMhc3P3nyJE888QQBAQG4uLjQrFkzZs2aVaybBSHMKvtIj9WqQbaWPopWC66uYGcHCQlQv75ueQtibV3HcnN1vV/71snJyYyR5JVf6xl7e8ttq1LQd4sltq5TVdWiRp0sijWMnJhdYdcZlnQ+SPJLiAqueadAftw5BkcX+0KfHkx8dDF7NpwxYWRCCFtR78E6LB79Dbu6PYuKglbJefmhVTSoimIo7myp3X0s1W+//caQIUNYsGABdnZ2DBw4kC5dunD58mWmTJlC27Zt87R+AJg4cSKjR4/mxIkT9OzZk3bt2rF582a6du3KmjVr8t3XypUr6datG5s2baJ58+b07duX8+fP8/zzz/Of//wn33VGjBjBp59+ytatW40yMti+ffto27YtK1asoE6dOgwcOJC7d+/y5ptv8tRTT1nMk3Ah8pV9pMfcozwCxMWBvmthQIBVPgwAy2j5VdS+syfCLEFUPudD9pFWLU1+8To4OJghkqJZWzLJWroRgu7vrLBi987OziaMpnCS/BJC4FfZ4//Zu/P4Jsr8D+CfJL1b2tKDFiyHHEXLjYICIogICCIKiOsJeLBqVVx0ddmVQ8DFVVBwqccPOcRVV+VyEUU55RKonGK5Qcp9l95pmzy/P9KEHJOzSWYm/bxfr0A7k5k8eTpJZr75Pt8Hn+Y+i/pN6rq838yXV2DGy8t5YUFEXklKioXQ6bD+juFY2ffP0Arb7BytMOLC394wFXdW8LfcLvkt7UvYTo3pgfDwcIwaNQp5eXnIy8vD119/jRUrVuDAgQPo0KED9u/fj5deeslmm1WrVmHmzJlITk7G7t27sXTpUqxYsQLr16+HTqfDyJEjUVBQYLPN5cuX8cQTT8BgMGDhwoVYt24dFi5ciP3796N58+aYPn061q1b59C+IUOG4J133sHatWvxk31hby9VVlbikUceQVlZGd59911s3boVX331FQ4dOoQuXbrgm2++waefflqjxyAKKLuZHp2aMAHYskVRXwbYn/+lpKQ4va8Sgl/uCoZHR0cHqSWesX/PBYDY2NjgN8QDQgjJyQSUGqxTy7A8s8LCQrmb4DF3GXVKqgHH4BcRATDNBPn+iuHo1t91nZ1Nyw/hmR6fQF+mjAKLRKR8deJNQ0uEANLPHjZlelWvEzBlfun27JGtfWo3fPhwfPzxx7jxxhttltevXx85OTkAgMWLF9ucoL777rsAgNdffx0tWrSwLO/SpQueeeYZFBQUYM6cOTb7++STT1BYWIhBgwZh8OBrM3SmpaXh7bffBgBMnz7doX1z5szBK6+8gp49e6JOnTo1eq5LlizBsWPH0K5dO/zlL3+xLI+Li8OsWbOctoFCQ05ODrKystCpUye5m1Iz5pkenc3mOHGiIr8MsL8gT1d4VtqJEydsfrcf5qi04JeaOMtMMmfTKWmoG+B8Fk2lDX0FTIFFV8EvpQ2FdTdJAzO/iEiRNBoNXnq3P0a90cvl/S6fL8GjHXJwNr8gOA0jIlULD9cBALSGSrTctwlaYYRRG4btHQfAqA2DVhiRsOYHU3Fn8qt27doBMA35MA9RKSsrw5o1awAAQ4cOddjGvGzZsmU2y5cvX+50mwEDBiAqKgqrVq0K6HANV23o2LEjmjZtir179zoU5abQkJ2djby8POTm5srdFL8o2LbNscafTgccOyZHc9yyDya5ooTML/sagE2bNrX5PUJBkwlIZVFptcq9VJfKUrOmtMCis88lpQWSANdDHuPj4xV13AJwOeTRuo60Eij3FUVEsrnrwbZ4e9FDcPde9UKf+djy46HgNIqIVE2n06DhiTxEVpThYnJDfDLqA3w/8CXMfvoDXEltiLCyEsBNoXXy3tGjRwGYhkYmJSUBAA4cOAC9Xo/U1FRkZGQ4bNOxY0cAwB67bLzdu3fbrLcWERGB1q1bo7y8HAcDWKDbVRusl9u3nUgRrIvdX3cdEr7/Hg6nWgYDsGABcOONiit27w25g19SwSSdTufydzlJZSbZB+uURKq98VZDdJU0XLOy0vloFSUFZsxcZX2lp6crLrDoanhxWlpaEFviHoNfRCTp+lZpmLf1GcTGu04Hnj56OT74+4+sA0ZELkVE6HAhtTF+7Pcs/m/UBzhXrwkAgfNpTfD1a/OxZ+RrQKtWcjcz5MycORMA0K9fP8vwjvz8fACQDHwBpouWxMREXLlyxfKNbmFhoaVYvbPtzMuPHz/uvydgx13bg9EGIp9ZF7s/fdox8GUmBKDRKLrYfUJCgtxNcOn06dNyN8ErUpOSKGm4mLWqqirJ8/7rrrvO8rOSgl/OgjNarVaRwS9XWXURERGK6tvKykqX14DmL92UgsEvInIqNj4Kc375M5q3dR21X7t4H7J7z0WF3vFbNiIiAIiJjURpbCK23TIYVeGmE3ohTCedhsgo/N7rQdPMZioljP69AaaAk/XN29mqvv/+e8yZMwfh4eGYPHmyZbn5QsDVTGfmk2tz8Mv64sHZdvbbBIK7tgejDUQ+syp2L3m5aL4Q79sXWL1aUcXu7WdqdVfYXO7ML/vsGaUGktTIWXDGOpNOSbM+Oqv3lZGRobjgV2VlpdNMNfMXWEo6lt3V+1La0F1ltYaIFEen02Lq1w+h//D2Lu934VQRHu2Ygwun1TM7CREFT0pydPVFkPl27YRTU72EbDVs2BAJCQmW29SpUz3edv/+/Xj00UchhMA777xjqf1FRDKrLnZfVVdihm0hTIGvFSuA+vWD3zYXvKn3Bcgb/JJ6zGbNmgW9HZ6S+mKjUaNGMrTEMxcvXnR7H/taWnIFmYQQKCsrk1xXp04dxQW/XH1xY85sVlLNL1dDNOPi4oLYEs8w+EVEHhk5tif+OmuA8ztoTB8wz/Wai22rWQeMiGzFxzv/prKqSqCgQPrkVC2EEH69AaaLzatXr1puY8eO9agtp06dQr9+/XDlyhWMGTMGo0ePtllvPiF1NfW7+dtc8+yM1iexzraz3yYQ3LU9GG0gqrFLlxB25QoAu8C/VquobC+1krogV1qQw9rJkycdlsUr9DgQQkjWU6tXr57N7/b11OTqf2eBL8DUJqVlJpknppHiSa0v+0keAsndrJTWw2CVQll/bSJStM69W2DWyhEIj3Dx1qEF3slejumjl8FoZC4HEZkkJJpO2oQw3669PxgMRhgMfL+wFx8fb3PzZEr2y5cvo0+fPjh+/DhGjhyJadOmOdzHnFEgdcEFmAJIBQUFqFu3riWIFB8fb6nx42w78/LGjRu7f3I+ctf2YLSByGvWhe4zMoDGjS25rxoAML+2jUZg0SJg716ZGirNXGvPrL4HWWlyZn7ZZ6m5GuItN1eZSUrkrH5WqpuyBdbBr2AGaC5cuCC5PF2B9fSMRqPT8gaeDiOVCkwGirvyAkoa+mrG4BcReSWtYSLmbX0WyelWqawaQKO1+kZHC2z56QhG3PIBrl5ynllARLVHfPXkGdbXQaYsJ6CqygijIXgnw6GquLgYd999N/Ly8jB48GDMnj1b8tv2li1bIjIyEhcuXMCpU6cc1u/YsQMA0LZtW5vl5qGT5vXWKisrsXfvXkRFRSEzM9MfT0eSqzZYL7dvO5GsrAvdnzoF2NfJsb7gNRoBhU3YYJ/dkZyc7HYbuWt+WVPyrIlSAQQlZ66eO3dOcrm7zC7rDKtgBWiMRqPTAI35GFZS5perWRM9/UKnoqLCX81xy1WWmlIzLZXz1yYi1YiMDseHa5/Ezb2rTyYEIKqzvMxvdhqtBlVFpfhf1oPY+dM+uZpKRAoRV8dJ1lJ1Fhgzv2pGr9dj0KBB2LZtG/r27Ysvv/zSYdiJWXR0NHr16gUA+OabbxzWL1y4EAAwcOBAm+UDBgywWW/tu+++Q3l5OXr37h3QYryu2rBz504cPXoUrVu3RpMmTQLWBiKvWRW6d+nvfwemTwc6dw5OuzyghOCVN7ydGERuUrXUlFzvq7y83GGZJ8E66yCTs4Lu/uYqM8l8vaKk4JerWmqefq4G6/ivqqpyWexeiUMeAQa/iMhHGo0Gr826F89N7Q2N1fWVEAIajQZCCNxavAePnf8O65+Yin8+swSGKmZ2ENVWUdGO6e/m+lZGoxEGtWd+XRvP6Z+bFwwGAx566CGsWbMG3bt3x+LFi90WxB0zZgwAYMqUKTh06Fqdxl9++QUff/wxEhMT8eSTT9ps89RTTyE+Ph7ffvstFi9ebFl+/vx5vPrqqwCAl19+2au2O/P444/jhhtuwJIlS2yW33///bj++uuxe/duvPfee5blJSUlyM7O9msbiPzCPOSxWTNg/nwYnQ3Bi48HliwB7rlHUTPf/v777za/t27d2qPt5Mr8sn4/A5SdRWU0GiX7R6lZM86GZ3oSrLP+MiZY2Ulnz56VXH799ddbfrbuazkDvUaj0WktS28CdFLByUBwNuOnmblMgtKEub8LEZFzd9zfGlmdGuLlQf+BvrTSMoGbRqPBrYW7AQC3Fu7C9A034dGbZ+HfP4xESn3lnogQUWBERupMJ5YCgPWJvQYwGAUE53v02axZsyxBopSUFDz33HOS95s2bRpSUlIAAL1798bo0aMxc+ZMtG/fHnfddRcqKiqwcuVKCCEwb948JCYm2myflJSEuXPnYtiwYRg6dCh69uyJ5ORkrFq1CgUFBRgzZgx69uzp8LiTJ0/G8uXLAVwb1rFjxw7ceuutlvssWbLEpo5Qfn4+Dhw4gKtXr9rsKzw8HP/5z3/Qu3dvjBkzBl999RUaN26MDRs24MyZMxg6dCiGDx/uXQcSBZJ5yOM+Uxa808vYwkJTkEyBtYh8IUfwS6qWlJLr/0ll+rjL8JEzQONsxk9PgnXWsz8GI/OrsrLS6ePExsZafnaWIR1s9p911rzJZA5W8MtZLTXANBulUgO4DH4RUY2lZSRg/pZnMOmJRdi//QwggEihR4di04lex+J9iDTqoa+MxHO95+LPk+/EnYM9++aQiEKDTqeFMNrGvcyEANLT1R0U9yFhy+W+vHGletY4AA6ZUtYmTpxoCX4BwIwZM9C+fXvMmjULK1euREREBHr37o1x48aha9eukvsYMmQI1q9fjylTpmDLli2oqKhAVlYWnn/+eadBpyNHjmDr1q02y4qKimyWeTNUo2vXrsjNzcWECROwbt067N69G82aNcNf//pXjB49WrEn3VRLmYc8Tp4MTJrk/H4REcDq1YCCirPbB5M8LRwvV4Dm6NGjsjyur86fP++wrFmzZi63katvKysrJTO2mjdv7tH21sXPg5H55WwIoXUQDlBG5pcQwmmWGuDdhA3B6NuysjIYDAan660z65SGwS8i8ouwY0cwaftElJ2/guJCPcKEAeHCVNAyXFTh/cNvoqp6fKT+oal4p9df8dK3oxEewbchotpEAJboTlhVBW7ZthTbuwzGhfPOC72SaxMnTsTEiRN92nbEiBEYMWKEV9t069YNP/zwg8f3nz9/PubPn+/VY6xbt87l+latWknW/SJSpLAwYOxYGKdOhVYqGyU6GigrA7ZtAySyJ+WSl5dn87unheMrKytlyfyyz3qxz15VEmfBA3fBe7kCNFKTowCe16KyzrByFTjxF2fF2Fu0aGHzuxK+LCkpKXHaJ9ZZap4IRt+6qk0GKHOWRzPW/CIi/6hO64++dBaplVdQt8p2ZqC6VYVIrbyC1MorKNVFYe+xKjzSMQcnjzqfKYSIQoflBFNcu924byPuWjMHLfdtRHi4MoYeEJFy5eTkICsrC506dZK7Kd77/HNL4MsmfKHVAnffDcyYAbRqJUfLJNUkyFJUVBT04JdUFlVGRkZQHtsXx44dc1iWlZXldrtgzZRozWg0Ss5EWLduXY/3ERl5bdKbQD8HZ7WzAMdhjtaZYFLDZoPhzJkzTtcpbdiu0Wh0OURTyZM1AAx+EZG/WM9kpNFA2BVnNEADIzT4JqUvxjd5EWW6KEAAYwb+Bws/2iJTo4lITln71gMAbshbj/BwlZ+SCD/fiMhBdnY28vLykJubK3dT3DMXum/cGMjIgPGZZyyrNABgDgYYjcDSpcCddyq60L2nWV+A+2LYgWAf/FJy9onBYJCszeRJYfNgZPbYkwosAt7N6Gcd/Ap0kCk/P19yebpEPT3rzC85+ra8vNzpsP+IiAhFzUYJ2JZZkBIfHx+klvhGWb1JROoWFga88QYwfTo0dh9sOggsSBuEb+rdDaPG9luXr/+9Fdl95qK8JDizvxCR/MIrytHiyK8AgBaHtiHayNc/EYUQc6H7/Hzg1Clo7bNdrC94jUbg+PHgts8FqWwtb+oOlZWVBTXzS2oWwpYtWwb8cX0lVZvMVa0v62ylYBU0NxNCuB3m5gnr5xDI4FdxcbHTzDLrmpdm1plfcgwpdVXry9N6asFiNBpdZqlJ9a/SsNgOEfnfrl2ATgdUf4MiABihRZNy6XoBAHDhVBEe7/wh3vxyGFq0re/0fkSkTtrDB5H90VMIrzRd8OkMlQgzmIYAhRkq8aeJDwDvVde2iI01ZUJkZsrUWu8JIfx24iznbF5E5AcHDwL33QcUFdmcD0lKTgaefhro3DlozXPHPuvLl+GDwayldOTIEZvflZYtY81gMEhm+kRHRzvdRqfTWbKSpAJ9geQs0yfTy89n6+BXoD7jhBBOs76sZxN2JtiZX1VVVZLDSQHT60dpx7G7IGhaWlqQWuI7ZfUoEalfRQWweLHpRC88HBg1CprwcOhgRJeS36ATrsf5/+Ohr/HRuJW8+CMKMZVJqSiPjEVi4XkkFp5HnRLbE+qYq5dMGRL5+aZsCYnhCUREqmDO+jp50nXgCwBatADGjlXMkEep86+aFI4P9PmcVPDAk9pZcjl06JDDsnr16rncxjo7KZgBGiEETp8+LbkuIiLCq31ZB0MDlflVVFTkdN/JycmSy4OVkSbFVRaVN8HFYASaDQaD0+GvgCl4q4TJA9xh8IuI/GvzZqC4GGjZEti+Hfj4Y9P/mZmIrCrHmKGJbnexZnEeRtz6IQqvOC9YSUTqUhoWjbmPTcfabg9DQAOjxvYUxKjVAhoNMGGCqX6gwutGOBDCvzciUq+EBGDlSlNWlyvt2inu/c4+66tJkyY+7SdYwx7/+OOPgO7fnyorKyWH5LkLflnXL6uUmi00QJwNyWvlw8QMgQ5+ucr6clWbLBhBOSnl5eUuC8d7U7POOjgaKOfOnXO53puagHJi8IuI/KtVK9OMRTt2AG3amJa1aQPs3AnMmIFOL9yLWT+NQGS08zd1jUaDsuJKPHXbbCz/z87gtJuIAqqwsBxGrQ5rb38MK3o9Da2wPcnUGo3Au+8CEyea6gcSEamNdZH7hg2BS25mtD582FTvSyGksori4uJ82lcwgl9SWUmtW7cO2OPV1IEDBxyWeTKk1DrLKlgBGoPBgEsSx294eLgiM3xcTbLgalZK66GFwepbV4E6wPtaX4Ge3KGqqgqXL192uj45OVmRx4QUBr+IyL9SU4HRowH7wqgxMablqamod10C5v3yZ9x4UwOHzc1vnub/P526Hs/e+QmKrga3xgER+Vfh1eoaJwJIP38EBo3WMqmhACC0OlO9QJVi4hdRLXfwIDBwIHDkiGn4trsZD7VaoKTElDGvEPv27bP5XclF44UQLi/IlaakpERyuSdDSq1nSgzWsEepovyA97W+gsFoNOLUKem6wo0aNXK5rRzBr8LCQlRUSE/yExYWhqioKK/2F+jgl7O+NfOknppSMPhFRLIIC9fhjQUPYNTEXk7vo9FooNFocPlcKZ7qNhurFv4WxBYSkT8VFV0rdJ91YBN0wgijNgy57e+GURsGjdFgqhfo5ISQiEjR0tKApCTP38Oio4Fp00wZ8wpw4sQJh2U1uagOdOaX/fBMQLlZX0IIHDt2zGH5DTfc4NH21plfzmYy9KeysjLJovwJCQmKzPA5efKk03XxXgwptg9+BeLYNRqNkq81M18CzoEc9lhaWoqioiKn6xs2bBiwxw4EBr+ISFa9H2iDD1ePREJd0yw3rj5oZk9ci+f7zENJYXCneSaimisu1EMIgYYn9yGyshwXkjLw4Yj3sazfi/hwxPuobNrcNDOagrIg5NapUydkZWUhJydH7qYQkSsHDwJdugCnTpmCWq5ERQFNmpiyvm66STGF7u3rD3lb18m+oHggg19Sda+UfBF+/PhxyeWeBi28LS5fE0IIh9kzzZTYx2VlZSgsLJRc520gyf5YDUSWnbM6aoCp9psvwcVAZX4ZjUa3NfUSEhIC8tiBwuAXEckuOT0e/7fhadz9aHu3b/oXThfhia7/hzVLHL/xIyLlKigoAwRwPrURvr/zz/hoxL9xvt71EEKgsmUWyjdvM9ULVEgWhBLk5uYiLy8P2dnZcjeFiFwxz+544gRQ5qZMQ1wc8Msvinq/27t3r8Myby/Cg3kRLFU7S6kX4RUVFZIzUnqTpRaMguZmzmb0u/7664PWBk8JIZwOz4yJifE6KBTozK+KigqXQ3XdTXzgjPWwWH86d+6cy6GgSh4W7QyDXyqUk5ODrKwsdOrUSe6mEPmNRqPByLE98O6yRxEVG+72A+fjcavxwt3zUVLkmJZNRMpz8UIJBARKYxKx5eb7UBFWfbImTFlhcfUSLXUBiYhUJSHBNGvjK6/A7eVyeblpeKRC3u+kalH5MnzQvk5RoDK/Dh8+7LDMl9kHg+XgwYMOy1IV8HeXUlFRgQsXLkiui42NDXJr3Dt37pzT48uX2Qft91XmLpDt5b6dBeoA74vcW9PpdD5v64xer5ec8MDMl+CiEjD4pULZ2dnIy8tDbm6u3E0h8rvrrk/CvM1/xm33uP824fyJQjzR5WP8/G1eEFpGRDVRXFwBCNMJoDCaTjCFEIAA0urXUWQdEW8Io/DrjYhUwDy7Y6NGQHIy8NFHcPlOptEAxcWKGt5tX4vK0zpU9qwLhwPeZ455orKyEuXltqUvIiMjFfv54WyIW1pamt8ew18BGiEEDh06JLlOicHFyspKXLx4UXKdL4EvILCZX+fOnXNary08PNzrIvf22/uTEMLtcEclZgJ6gsEvIlIcrU6LF//VD29++QDCI9x/m/HBP1bhpQELUFbCLDAipaqqrK6dYT6XtLpWSUuvE/T2EBHVmPVwx8JCU2DLGa3WNJVrdraihzv6e4idPwMIUsMdW7Ro4bf9+1NVVZVkcMbfgaQCd7OKeshZFtV1112nuOCiq0CdVqtFjP2M817s15q/AosVFRVOA3VAzWfQ9Pff5+LFi5J19cyaN2+uuGPCUwx+EZFiNW9TH/O3PoN23Rq7ve+Z4wUYccvH2PDd/iC0jIi8YTQKCAFL4EtAwHpsUCgEv4QQfr0RkSPFlf5ISABWrgRSUtzf1zy744QJihjuWNM6VO5YXxz74z1NasiYr1lqwbB/v+P5aGpqqt+DBlLDVr3lKouqbt26Nd6/v50/f95pLaobb7zR5/3a79M+y9AXriYQAExZajU9Jvw57FGv1+PcuXNO10dHR9coS01uDH4RkaKFhevw948H4e//dy90OvcfDrP+9hP+MvAzlBZ7ONU4EQXcxQtWJ+fmAJhRANXnmWnpccFvFBGpjqJKf5iHPDZuDLjI6kBsLBARobjZHe2HNTVr1syv+/dn8KuyshKlpaU2y6KiooJaCN4bp0+fllzuz+GOZjUN0AghJDPqAGUOd9Tr9U7rkjVp0qRGgST747SioubXEufPn3c6a2RUVJTPWWrW/BVQFUI4DIO25+uQUqVg8IuIVKFd1yaY+8szaN4m3eX9NBoNzhwvwBNdPsZPX+0JUuuIyJUjhy5CGASgsc36EkIgLi4C9UIh+CX8fCMiZTIHvXr1Mv3sYvY2AKagV7t2wFtvKXq4Y3R0tAwt8YxUcKYmBcIDqbKyUnJGPyUGkgA4zfJp0KCB4oa2CSEkJzwATNlPcXE1O5fwd/DL1QQCgP8DzjV1/vx5p3XJAP9kqcmNwS8iUo2omHC8+eUwvPhOP0i+95ovrKt/njvlZzzT6xOcP3U1qO0kIluHD16EQHUhd/NLtPpFrNFoEBsbmGm6iYj8zlzn69QpwElGh42ICGDdOuC11xSR9VVUVOSwzJ/DHc38lfklNWSsJkPbAk0qUBeI4Y7+4Gq4Y1JSUpBb497Zs2edHkv+GALrz5ID7mZ3bNasmaKOifLycpeBuujoaL9kqcmNwS8iUp1ud2dizqY/47pmtnUINBqNzWxDGq0GBRfL8GK/Bfhw/E9O6wMQUWCdzC+49otRmIo+V2ve0oNaOURESnDwINCliynw5cmQuzp1gIoKYNu2wLfNQ8ePH7f5vWVL97Nr+8IfF/Z6vd6h6HhMTIxfaxz5UzCHO9aU2oY7VlRU4NKlS5Lr/BVI8mfw68KFC06zqCIjIxWVaVkbhjuaMfhFRKoUGx+Jd799DE/+o4dlmTDaFoq2/KwBfl56AI92/AA71rt+cyci/ystrZ41yPL61EBXqcdt2xYis4n6i90TUS1hPbuji+FBFv36ATNmKHq4Y3h4eMAf19eggtSMfkq9CDcYDJLDHbOysmRojXvOhjtmZGQoKiPJzFnReJ1O57dAkr+CXxUVFTh//rzT9Uobsnvp0iWndckA5WWp1YQyqwQSEXmoz0PtcEufFvjnM9/i+P6LpiFV1e/P5jdqIQQ0Gg2EAN55YTmua5qI8XMGIz5J/em7REp39UrZtRpWllGPAq0ObkK/9fNQ/lsPoPP18jXQT4Sxelinn/ZFoWfSpElBeZzx48cH5XFqlYMHgfvuM9XvqqoCwsOBykr3261YAfznP6ahjzKTyn4PxHBHs5oOezxx4oTDMiUPd9y3b5/DsrS0NJsRCUpRVVXldLhjYmJicBvjgcuXLzsNzvhzxk9/Bb9cZVEprW5WVVUVzp4963R9TEyMorLUaorBLyJSvYTkGPzrm4ew/n/78OG4VRBGWAJggGPq/amjBfjzHXMxcGQHPPxSt+A2lqiW+W3PGQhhlZVZ/V+rAxsBAFHLvwWeHC5T64iCZ+LEiUG56GHwKwDMGV8SAQ5J0dFARgZw6BCweTPQs2dAm+eJvLw8m9+vvz7wXzqYvngUXgcVhBC4etW2XmtkZKRihzvat9UsVQE13qQ4y6JS4nBHo9HodDhp48aNFRVIAoDCwkJUOgmMh4eHK65u1smTJ12uD8b7RDApLxRNROSj2++9EfN+eQZtuzXy6P7L5u3E450/wP6d0h+qRFRz+347C2EU0OBaTDqishyZf2w3/fL996ZsCqJawhwMCMSNAiQhAdiwAfAksBgXB5SVAe+/r5ghj1LDHWNjY2VoiWd+//13h2UtWrSQoSXuCSEks9SUOtxRr9dLBmeSkpIUF0gCHGvUWatTx79lE2r6HiqEQH5+vtP1mZmZNdq/vxUXF6O4uNjp+kaNGinymKgJZn4RUUiJignH3z8ahCN7z2HK00tRXup6WEKl3og3RixGyw7p+NsH9yIqRv6hCUSh5MTxAiRfOYVH/zcZ4ZV6AIDOUIUwQ/VrU68Hmje/NiwoNhZYuhRQ2Ekikb/s3bvX7xfGe/fuRdu2bf26T6pmPeQRACIjTe9bzhiNwLRpwE03mWp+KVAghzta8yXzS2p4m9KCBtakgjNarTagwx0jIiJQUVHh07bOsr4aNGhQkyYFRHl5OUqcfDkWiOBiTYNfV65ccbouPT1dUYEkd4E6AIiPjw9Sa4KHmV9EFJKatU7DnI1PY8Dj7T26/4GdZzGyy//h+892BrZhRLXIhfPFMBgEimMSUR4Ri7pFF1C36ALiS+1OEM+eBfLzTbeEBCA9XZ4GE6mUki6qQo55yKP5PcpV4CsqCigtNQW+FDLk7ejRoza/161b18k9/c+X41KqdlaEAmqmSRFCSGbOBDrry9caTEVFRZK135RWgN3MWdZXQkJCQIKLNQl+uRqeCQApKcqa2bqgoEDyWDBTcsC5Jhj8IqKQpdVp8ejLtyHnpxGo19Czby8+m7YJf+71CY7tcz5LCxF55pf1fwAAyiNiMPvBt7H6lj9BQAOjxu70Q6cDNBpgwgTT0CIVftsohH9vRKQQng55jIgwzQKpkKGOZqWlpTa/X3fddUFvg6dBBfu2Av4taO5vFy5ccFiWlJQU8MeNjIz0ehshhNMstaioKH80y6+qqqqc1s5q2LBhQB6zJsEvqWPBrFEjz8qxBNOZM2ecrouMjFRswLmmOOyRiEJeUlocZn73ODZ8tw8fvL762sxzThRdKcff//Q1bry5PsZM74+4xNCZ5YQomPL2nrWcTBo0Wqy+5WGUR8ZiwPo5tnc0GID33gNeein4jVSwTp06QafTITs7G9nZ2XI3h2po7dq1AAJTQPj666+37J/8yHrIoxDWE0o7qqgAfvgBGD06eO1zw74Qe7DrfFnPuu0J+yw1AAgLU+7l6vnzjl+UBmP4oC/BqsuXL0suV2pw0VkWldIKxgOmobqugl9KGz5YWlrqMutLqZmA/qDcdxMiIj/rfs+N6NSrGWa8vAK7Nzsf5y4EoNEB+3ecwdM956Dvn9rg0ZdvQ1i4MmcZIlIivb4KhQVlpmCzVmP6X6NB/QtHYdBooRXGaxeROh2wa5dsbfUPf6ZsmfaTm5uruJNm8l2PHj0Ctu+YmJiA7r/Wspvl0eUgvsaNgW7KmkHavhB7sGdu82bYo1SA7MYbb/Rnc/xKaobHQGUk2fMl88tZpk8ga5P5ymg0orCwUHKdEmcfvHjxotN1SmzvuXPnnK6LjY0N6WH0yjvaiYgCKComAn/78F5M+WIYomPtUno1gEZrGn1lzg7TaIEf//sbht/6IX78ag9n0yLy0MY1R2yzLIWAzliJVod/gU4YoQkPB0aNAsLDTZlfixebMieIiJTCmyGPeXlA06bBaZcHysvL5W6ChSfnTmfPnnVYptMp90tHqRkeExISgvLY3mbDOcvyadKkiR9a43+XLl2SXB4RERHQwIyv5/iugl9Km1W1srLS6SQCQPACuHJh8IuIaqVmrerhkw1PYeCIDtcWSiVuCECr00AI4NN/rceoO2bjty2uZ0chImDLxj+u/WI0vbAan9mPyMpyVDVvAWzfDnz8sen/zEygqAjYvFmexvqDUUD46WbuLyKylZOTg6ysLHTq1Cl4DxoWBrz6qvOKCdHRpsD9tm3Ba5MHDh8+bPN7sGZ4tObNsEf7gEegi8bXhFRtsmDyNlvLWXAmLi7OH83xKyGE08ykZs2aBfzxve3bqqoqp8e3EoOLrgJ1gLKHGfsDg19EVGtpdVo8/JduyPlpBDI7pJnGM0h8fgmjAITpJK6ksAJTn/sf/jr0c5w+5nxKY6La7PKlEpQUm7K4LOeEWg3OJTXCijv/jLDdu4A2bUzL27QBdu5UXJFoIlKe7Oxs5OXlITc3N7APdPAgkJVlGsqYkQE0bux8yKNWC/z973z/kuBp8EsqM0mJw/HM/vjjD4dlLVu2DNrje5v9JFWbTGkZSWZFRUWSy7VabVAyAb0t9C41/NVMacFFo9HoNKsOUN6MlIGg3HcVIqIgSUqLwxvzH8C42fchOj7cVPNL63hiYQ6ChRsr0eGXbzD2/vl4+8X/objQxbTnRLXQT8v2A7gWSxYCgFGgJCoeYa/8BbAvWBsTYyoSnZoa1HYSEUky1/rKzwdOnQJcXDCirAz4y18U9f6l19uel7RSeGDu1KlTcjfBK1LBuvDwcBla4p6zIY+NGzcOcks8IzX8FQBatGgR8McWQngdYHOXSaUkBQUFLtfXq1cvOA2REYNfRETVsjpl4JOfR+HxV28zLdBAsrpt5yu78PDpb9GpYDd2bczHn+/4BJ++sx5VlYagtpdIiYQQ+P23M6Zv+oWAOQRm/ub/jrsCfwJLpHR6vR5lZWVyN4Ocsav15ZC3ZM68SU4GjEZg796gNs+dQ4cO2fwuVwFrTzO/7LNngplF5S2pYJKSa5NduSI9SiHYmXWe1tOqcFL7M1jBRW8mEzAYDKisrJRcV7duXX81yS1P+9Zd8EvJ2Zb+EvrPkIjIC1qtBnc/3B5zNo7Cbf1bmk7c7IJgna/uMv1fsBOA6UPnxy/3YHjXj7Dym99YFJ9qta2b/kBVpTBlUGo0NnX0WrVLh04Xmqce5lifv24UmoqLi/Hoo48iLi4O8fHxGDZsmNNZzUhmYWHAG28Affo4fg8mBNC3rykzLMhDtp1l8iiRJ0E3g8Hxi0OlZlEB0gGE5s2bB78hHpIa8ijHDISenBvLdWxbB2m9OfaKi4udrlNiFpWrWnX169cPYkvkE5pnoERENRQVHY7nptyF978fjsYtU6DRaKDRahBp1KN9YR4AoENhHiKr9JZ6YMIgMP+t9RjV6xNsW3WYQTCqlX78337LsW80mjK/NBrTteLQRzq43pgoxL3yyivYv38/tm3bhu3bt+PEiRN4+eWX5W4WuRIT45j5pdUC8fGyDNl2NVObFCUU3XZ1PqSkIY+enLdJFWNXarDOaDRKBhflqPflSd86C854W4erJrzJ/Lp8+bLTdcE8JjzpW3f3SUpK8ldzFI3BLyIiF5KvnsbU3ZMw//RUvP/7eLybNwnhogoAEC6q8O6+SZj5+3jM+G0c3smbgvTycygtrMDM137ECwM+xc6Nx2V+BkTBs3fXaZSXV9ksM2V/CTRrkYzIyNCeRYjIncWLF2PGjBno0KED2rZti3feeQdLly6VpS2lpaVYunQpnnzySbRs2RJRUVGIjY1Fu3btMGnSJJdZDfPnz0fnzp0RFxeHpKQk9O/fH5vdzNa6adMm9O/fH0lJSYiLi0Pnzp2xYMECfz+tmrMudt+oEcTSpY6ZX0YjsHAhcOONpvsH0fHj3p1XyFl025Nhj/aZj94EH/zNk8wj+2CSkmfHc1WMPdg8CdA4K3afnp7u7+Y45WmgzWg0Og1EB3sYrCd9a18H0FpYWJhsQ6ODjcEvIiJXqovehp89hWT9ZdStsj1Jq1tViNTKK0itvIJSXTSuhsdXD5PU4Mq5Ekwb/R1eGDAfuzczCEah79uFv12r9SUEYBQQQkBA4MHhHeVuXmBx3CN5ICYmxqZA8qVLlxAdHS1LW7744gvcf//9mDt3LnQ6He699150794dx44dw4QJE9CpUyfJIVMvvfQSRo4cib1796J3797o3LkzVq5cidtvv91pIG/RokXo0aMHVqxYgbZt26Jfv344dOgQhg8fjldeeSXAz9RL1sXuT5xwPsujaWw3EMQLc09I/c3k4ssFddOmTQPQEs/4MuyuWbNmAWiJfyjpWHBWG8uasyHgderU8XdznPI0cOUqA7NBgwb+ao5Hahr8qi1DHgEGv4iIXLMueqvRmIY6WDFAAyM0WJR+Nya1/AvKwsyz2AlLnbDLZ0vw9ovL8eI9n+K3LfnBbT9RkBzadx5FV/WAsfqCsPpcTAigWYsUxCfIc4FPpCTPPfccnnnmGbz//vvIycnBc889hyeffFKWtoSHh2PUqFHIy8tDXl4evv76a6xYsQIHDhxAhw4dsH//frz00ks226xatQozZ85EcnIydu/ejaVLl2LFihVYv349dDodRo4c6VAT6fLly3jiiSdgMBiwcOFCrFu3DgsXLsT+/fvRvHlzTJ8+HevWrQva83bLrti9U337AqtXm4Y/KoiSAh5mzi7Oq6qqHJbJWTzeWbF1M7XVJ5MKOMnVXk8Ci84CZMHMSvK06Lur4vHxQX5P8CT45SpYF+z2yonBLyIid8xFb6dPNw11sKKDwOcZg7G4wQAYNbrqrA3AUiXfqlj+pbMleOv57zD63k+xd9vJID8JosD6cv52CIMRQgNACMvLQAPg8advkbdxRArx6quvYvz48fjvf/+LBQsWYMyYMRg3bpwsbRk+fDg+/vhj3HjjjTbL69evj5ycHACmYZrWAYF3330XAPD666+jRYtrM7d26dIFzzzzDAoKCjBnzhyb/X3yyScoLCzEoEGDMHjwYMvytLQ0vP322wCA6dOn+/fJ1ZT5c79HD+n1PXsCK1YAtShjwhfuhj16W78s0FwVBAdcFzhXGmd9npKSEuSWmLjL/JKzTq71cepp8MvZEE3r/QWLVBDZnqtjt7YMeQQY/CIi8tyuXYD9N5I6He6/OQzJDexTss0f4nZTRQK4eLoEU5/7H/5y32fI+1U5hV6JfLVh9WGUFldfIBsFRHWheyEEbr+zOSKjlFsThSjYnnvuOWzevBlbt27Fyy+/rMjp5du1awfANFTm0qVLAICysjKsWbMGADB06FCHbczLli1bZrN8+fLlTrcZMGAAoqKisGrVKpSXl/vvCfhLaiqERmNb8F6rDWqB+5qQ+9hyd1FtXzw+mMPbpLgaGgbA8lpQA2eZVnJl+bh7fTvLugvGsHDr49TTQJCz/pXjGK5JVl1to7xPWyIiJaqoABYvBgwGIDwcGDXK9L/BgLjV3+P9RX/C6/93H+ok2X9IO/8m6/zJIrz5zLd4ecjn2LfjdGDbTxQglZUGfL/09+qZHW2FR+jQ994bJbYKPaI66OevG5Gcjh49CsA0RMo8C9iBAweg1+uRmpqKjIwMh206djTV9duzZ4/N8t27d9ustxYREYHWrVujvLwcB4NcON6tigrghx+gEQIIC8PloUNNn/tGoynry80QOTnYX+C2bNlSppbYcpbVYx/wuO6664LRHKdcDWUD3GeGKYmzQJ5cwx7dBRadBcdSFRhodpWlVq9evSC2xMRd5pfRaOQM9NVqdfCrpKQEn332GV544QXccsstiIyMhEajwcSJE91ue/LkSYwcORINGjRAVFQUMjMzMWHCBJdR7bKyMowfPx6ZmZmIiopCgwYN8MQTTyhqil8icmLzZqC4GGjZEti+Hfj4Y9P/mZlAURGweTNuvOk6fPjTSLz673sQEx9ZXbTa/TdIZ49fxZRRS/Hq0C+Ql3si8M+FyI++nPsrDFWmkyqbWu0CePDxjtDpavWpBpEqzZw5EwDQr18/y+x7+fmmmpVSgS8AiI2NRWJiIq5cuWIZElRYWGiZcc7Zdubl3s5iGHCbNwPVw/LOPf88Tk+Y4PC5rzT2fShn/SzAs9kerSl55kQpUVFRcjfBKaUF6tzVU3M2BFbO2UqdcZVpJccx4S745S7wWJvU6jPSQ4cO4fHHH8esWbOwbds2ty9Ks8OHD6NDhw6YP38+kpOTMWjQIBgMBkyaNAm9e/eWPMDKy8vRq1cvTJ48GcXFxRg0aBAaNmyIefPmoUOHDpZv2IhIoVq1AmbMAHbsANq0MS1r0wbYudO0vFUrAKYTvXZdG+P/Vj+Jl6bdjcgYz0/kTv1RgDefXYaXBn2GX346BKPB+1mHiAKuvBx4+22gvBwn8wuwd+eZawmOVkXuGzZJRJsO8n6LH0yc7JFCxffff485c+YgPDwckydPtiw314yJiYlxtiliY2MBXKuHY11nxtl29ttI0ev1KCwstLkFXKtWQOvWAIBoczabxOd+MHiawaW0oaOhVEtIKsCQkJAgQ0s8o7T6ZO4CMM5e/3IP3ZUiNfGBmRzHvLsYBoNf1yjvaAqiOnXq4Mknn8RHH32E7du3Y9KkSR5tN2LECFy8eBEvvvgifvvtN3z11Vc4cOAA7r//fmzatAlTp0512GbKlCnYsmULunTpgoMHD+Krr77C1q1bMX36dFy4cAFPPPGEv58eEflTaiowejRgf/IeE2NabpeWrdFo0OmOpvhk3dN4dnJvRES6f7vVaEy3i2eKMOvvK/FMn7n4/vNd0JdznD4pyKJFwGuvwbhwIT6ctr46UiOu/Q9AowWefKGbrM0kIu/t378fjz76KIQQeOeddyy1v+Q2depUJCQkWG4NGzYM/IPGxACHDgEA6mzYAI05k8bJ534gKXlGQU+EwpArqcwkJQe/lBYIdUfOmlTeBqw8KTAfTK6CcYDrY0Hu7NBgq9XBr2bNmuGTTz7Bn//8Z3Ts2NGjD5Zt27Zh06ZNqFevnmWGGsCUpvvhhx8iPDwc77//vs2LoqKiArNmzQIA5OTk2KRvjhkzBm3btsXPP/+M7du3+/HZEZESaLUa3HZ3JuasH4Un/9EDujCJD1gNoNWZpsXTaE3rtToNSosq8PmMzRjV6xN8Nn0jrl5SVgo71VLffAMAyH9nNir1BlO4yxz3qj68H//zLYiOVvfFmteEn28AOnXqhKysLMvMe6Ru+fn5yM/Pd3uh4guDwWDZv69OnTqFfv364cqVKxgzZgxGjx5ts958/upqOJU5QGAu+mx9zutsO/ttpIwdOxZXr1613E6cCECJgIMHgawsoHFjICPD9H91xoS2shKZffteW56VZbo/ueTNsEelZ4lJ1QNTclBSKkCjxCwqwHkwKVjF47099jwdLRYs7gKdrtabh7XXFsp8BSiYecaagQMHOhwsaWlp6N69O65cuYKNGzdalm/atAlXr15Fs2bN0KFDB4d9Opsdh4hCh1anRa/7W2HuxlF47OXbYPM5KyBZLBwwBc+MBuCnr3/D8/0/xYxXf8CZ41eC02gieyUlpkLPADL2bkZYRdm1dRrTPze2SUOrtvVlaV6oyc3NRV5eHrKzs+VuCvlBkyZN0LRpUxw4cMDv+96/f79l/764fPky+vTpg+PHj2PkyJGYNm2aw30aNWoEwFT3VkpJSQkKCgpQt25dy0VrfHy8JTvG2Xbm5Y0bN3bavsjISMTHx9vc/C4tDUhIAPLzgVOnALuZ/cILCkzL8/NN90tP938basBcW82sfn11vQ8nJyfL3QSXpDK/lB6wsyf3bJrOOAvO1K1bNyiP7+3fUWlZde5meywrK3O6ztUw9lDE4JeXXM1YY73ceqYbX7YhotAUFqZDv4faYt6mP2NY9i2IiNKaggaWkWPXgmBS35hu//kPvDrsv5j4xCLs33EqJIYSkIJZZ0I0bgw0b27JhAgzVuFvX2Xj71+MwtgvRuHlr15Ao4rzeOSpTjI3mki5Av2e7cv+i4uLcffddyMvLw+DBw/G7NmzJS8GW7ZsicjISFy4cEFysqYdO3YAANq2bWuz3Dx00rzeWmVlJfbu3WuZPEpWCQnAhg3A+PGSqy09O2GC6X6BCMDVgP3fxDxLp5y8yfxSQntdcRdgUAOlDtN0Fkwy1wNUGqVlfrkahmkwGFxmG0dH289SH9oY/PKSu5lupGas8WUbIgpt4RE6DBp5Ez5e/RQe+UtX6CKqLzSE6WRRKghm7cjv5/Hms//Dy4M/x+YfD8FQpf6TMlIg60yI/Hzg7Fmb1fFlBahbfBF1iy+iPCIWD78+EBER6pqty38CMO6RQpKSskX0ej0GDRqEbdu2oW/fvvjyyy+d1oCJjo5Gr169AADfVA9/trZw4UIAptER1gYMGGCz3tp3332H8vJy9O7dWxkz54WFAW+8AfTp47BKAwB9+wITJ5rupzD2wRklHGfeBL/UNoRQjZSa5eNspsdg1aNS+7BHV4FZd8Xua9uwR+W9cyucu5lupGas8WUbKXq93uYADspMN0QUUBGRYej/cHv0e7Atfll5GPP/9TPKSjwv+nnhdBE+HL8KCz/aiq79WqD30DZITFbmyQ2pkDkTYvJkiMmTIaCBVlw7yTJotNAIgVUdH0DTT2cg6Xp1DbMhkkOfPn38fqHvS7Fog8GAhx56CGvWrEH37t2xePFiREREuNxmzJgx+OGHHzBlyhQMGDAALVq0AAD88ssv+Pjjj5GYmIgnn3zSZpunnnoKb775Jr799lssXrwYgwcPBgCcP38er776KgDg5Zdf9rr9ARUfD2i1EEajJTlbo9UqLttL6VwFFZQYrHNGzmLs/qTU4uZKG0bojpqOB3fBrzAFBvIDSdXP9v7778e+ffu82mbBggXo3LlzgFoUWFOnTsUbb7whdzOIKAC0Oi269ctE174tkPfrKcx+cy0unfF8muoLp4vw7dwd+HbuDrS+pSEGPNoeWTdfB61WuSeTpBDl5cD77wMvvghIZV5UZ0Lk7i1A58Xv26zSCSO+vXUk6k4ai+ata3fgSxgB4aeXm2AiZ8gSQkgOGZTDrFmzsGTJEgBASkoKnnvuOcn7TZs2DSkpKQCA3r17Y/To0Zg5cybat2+Pu+66CxUVFVi5ciWEEJg3bx4SExNttk9KSsLcuXMxbNgwDB06FD179kRycjJWrVqFgoICjBkzBj179gzkU/VORYWptqHRCISF4fJ996Hu0qVAVZVpeUUF4CZISLakMr+Ukj0THx/vNqHAVc0kNVFigNFoNMoeTPK2X5xlWikxuOgusKjENgeSqoNfx44d87poqKsZajzhbqYbqRlrfNlGytixYzFmzBjL74WFhcGZ6pmIgkaj0aBVpwzMWPoYjh+8iDn/XIdj+y642ACWWfbMwyX3bj2BvVtPICE5GncNa4s7Bt2I+Lq1a0w/eWHRIuC110yzmD38sORdln29B+m7d8Og0UIrrmVCGDVatNNdQJO7WgS1yURqNHz4cLmbYOPKlWuTp5iDYFImTpxoCX4BwIwZM9C+fXvMmjULK1euREREBHr37o1x48aha9eukvsYMmQI1q9fjylTpmDLli2oqKhAVlYWnn/+ecX1CzZvBoqLgZYtcfif/4Q+MxOXHnoILcaONdVB3LwZUFKwToJShhC6GvZY02syf4mOjnYb/HI2LI9qTglDSr0Nfjkbxusuc1YO7oJfSgyIBpKqg1+7du0K+mM2atQIO3fu9GrGGnez43gyyw1gGpNb28blEtVmjTNTMGn+UJw/XYjPZ2zCjp//kLyfRmsKepk/jM2/F14px6KPt2HRx9vQrmsjDHikPVp2qF/rPujIDXPtnoULJYNfy77egw3Lf8fk41uhE0ZUaXXIzeyFTgfXIMxoQOM9PzMTAoAQntW18XRfFHrmzZsndxNsTJw4ERMnTvRp2xEjRmDEiBFebdOtWzf88MMPPj1eULVqBcyYATz9NPRHjwIA9JmZwM6dwOzZpvUKZ772kJur8w2lBL88qYMld2aSt9RUnF8JbfXXeXEwr9N1Op3LQvZm7oY91jYseO8lVzPWWC+3nunGl22IiMzqNYjHX96+GzkrRuDOIVm2KwUgjLbF8YUQDh/kuzfn45/Z/8Poez/D8v/sQvFVddVXoAApKTEN4wGA7783/W7lm892YN2Kg2hy/iAiq8pxLqEBZgx6G4u6/RlLx8yByMyEpqjIlAlBRBQKUlOB0aMB+6BITIxpeWqqPO3ygtJmcFNy5pcnAQu1BRCkgiJyJFB4chyGUvArmJN2ePL3NBgMisisUxIGv7xknrFm2bJlDm+E586dw4YNG1C3bl1069bNsrxbt25ISEjAkSNHJLPVnM2OQ0RkLb5uNEa82gOz1z6Fx17phrAIq7dwce3D29WHeMn5qyj6xySM7jMbM177Afu2n4LRyDSTWuPgQSArC2jc2HRr3hwwf5bp9abfq9cVpDXB4SUbIACcrZuBpZ1HYMZ97+BsUmNk3lgPQ95+HJqdO00ZEirIhCAi8oZSgjNq5mrYo1JqfnlS80gqmKTkQuFS7XVXXicQPMmqc5a9FMxRCv56rGAOe/RHYLE2jgRh8MtLnTt3Rrdu3XD+/Hm89tprluVVVVV47rnnUFlZiRdffNFmrH1ERASef/55AEB2drbNuPF3330Xe/bsQY8ePXDTTTcF74kQkWpFxYSjzwNtMefnUfjrzHtQ//pEQOPZkKubL+/En/KX4ObLO7Fj/XFMfX4Znh/wKb6c9QtOHLkU+MaTvNLSTDM45uebbmfP2q4/e9ayrkBEoCimLiAESqISsKHVAFRoI5DVLh1Pj7nNdNKkokwIIiJvHK0e8kihzdcAgJJL0Uhl+3gSiPI3Tx7TWRA0mIEkNQ579EfwS8kB3ECpfc/Yzv33348zZ84AAE6fPg0A+OSTT7CiehhI/fr1HYqAzps3D126dMHMmTOxZs0aZGVlITc3F0ePHkXXrl0xduxYh8d5/fXXsWrVKmzevBktWrRA9+7dcfz4cWzduhWpqamYO3dugJ8pEYUarVaDtrc2xNv/fQiXzhVj2fztWLPU9Qy4nS+Zhll3urQDv6SYZr4tvlqOHz7fjR++2I3U6+Jxx703ostdzZGcHvxvCSnAEhKADRuAyZNNN43GNKNZNaHTQRiMWNluCFa1HwoDtIBGY55TAbf1bob7HmpfK78tdMe67p4/9kVEpHauMr/ULjY2Vu4mOCUVUJJjKKwnwwCdFWQPZnu9OadxFVAKZjDJk8Ciu+CXEgv0B1qtz/zauXMntm7diq1bt+LEiRMAgFOnTlmW7dy502GbFi1aYOfOnRgxYgQuXLiAJUuWQKvVYty4cVi9erVk1DcqKgpr167FuHHjEBMTg6VLl+L48eMYMWIEduzYgaZNmwb8uRJR6EpOi8OI13pg7vqn8ewbdyI+yfGkIcKgR9uC3wEA7Qp+R4RRD422eqhk9f8XTxfhm4+2YcyQLzB+5CKsWfo7SgrVVeuC3AgLA954A5g+3SbwBQAagwHf3vw4fmw/rDrwZQp6QQg8MqoT7n+4AwNfRFTrZGRkyN0EVWLwSx5SNcrkyPLxdUgpoNzML1dF5rXa4IVWPOkfd8EvJWcvBkqtz/z6448/fNquYcOGXs/aEx0djUmTJmHSpEk+PSYRkTth4Tp06dMCXfq0wNlV2xDxp6EwFpmGWoeJKoQLUyp8uKjCtJ3jUaUxfQzodRGYecOzOBedZtnX8YMX8ek7G/HptI1odfN1uGNQFtp1bYSIyFr/0REadu0CdDoIgwEaAAKAUaPFdZf/sLmbMAq8Mrk3GjSsK0MjiYiuycnJQU5OjkeznPlTYmJiUB8vVITylyXWJW6URir4JcffwpOAm7OZNIOZ+eVN0MrVe4/SjncGvxzxCoaIKESld2oJtLgO2LJFcn1iZaHl58Nx1+NqeLz0jgTwe+4p/J57ChFROrTr2hi39GqG1p0zEB1b+1KmQ0JFBbB4MWAwwKDVYVuznuh8ZB3CjAa0zd+Kbwx/hkEXhqgoLf7xzj2Ijat9J0heM6I6Tc5P+yIiB9nZ2cjOzkZhYSESEhLkbg55KBQzv5RcL0mpM/xptVqHgIyzYJJSAzPBDrz7wmg0QqvVun3d1cZhj8p91RIRUc3Y1XcSGg00VicdBmigAfBtRn/8r2F/GDXu09Mr9Abkrj2K3DVHoQvXIrNdfXS+oynad22EpHpxAXwy5E9lq9YhurgY5+Ib4NPuf8GZ5EbY2LIfRqx/F/UKz6DxhQOoO7gfHn76FsV9k0lEROrgbNiju4wUNQjmEDdvKTX4JXU+4exY8GTIpL/4K/NLKaqqqhAREcGC9xJq3zMmIqpNzPWdEhOhGTPGZpUOAss6PIYlUV09D3AIQKMz3ddoFNi34xT27zyNz97ToEHjRHS6oyk6dm+Chs2SGDSRQ3k58P77wIsvAhKFZvXlVXh/ymoU7M/HTTc/ji3Ne6MyLBIwAmeSGmHaPf9Cl0NrMPifD6NBx0wZngARkTJo9Hokf/45Lj3yiNxNCTlqCCComX3/KiXIYX1eWFVVhbCwMKfHQjCDi6EW/KqoqEBERITTIaVmSjkugqn2PWMiotqour4TrD+0dToMbKvFHTNHYNOKA1g6fwdKC6WnnIbGdNIihDAVhzIv1mgsy0/9cQWn5m3Ht/N3oE7dKHS6/Xrc1ON6ZLarj7Aw5X5DqjhuAlguLVoEvPYakJEBPPywZXGFvgofv/MzDu+7CI0G0EQnYP0N/YHq7D8AgACSGiVh0GdzodUycElEtVv8ypVIf+89VKalATfdJHdzVMlZ5pfUbITkP/b9rZThbdZBpsrKSoSFhTkdmhfML1CtH8vdUEGlZtVZ0+v1iIuLcxv8CmZ2nVLwaoSIKNRZ1XdCeDgwapTpf4MBWLwYcdFa9H2wHT78YSTe/upP6DOsDbT2n4ei+oTA/lxEmAqiQ5h+NgfCCi+XYfXSPLwz5nuMG/ENpr/yPX765jfkH74Eo9HqxKK8HHj7bdP/ZGIOYC1e7P2233xj+n/hQgBASbEeMyeuwl+fWIjD+y5a7mYfxASAZ17rjr9NHcDAl4+EEH69AUCnTp2QlZWFnJwcmZ8dKdHOnTvxl7/8Re5mhCSDwYD4n34CAMv/5D1nwa+ysjI5mhMyvK2hFhMTE6CWeMc62OIuMBNM3gSBlNRuZ8qrz6ndBeqUPHQ3UJj5RUQU6jZvBoqLgZYtTcGRNm2A558Hhg4FDh40re/ZEwCQlpGAR0Z3xcMvdsHhvefw/Re7sHtzPgxV1cESDSAgrPOFbAhzYEtz7aT37IlCnD1RiL25p6DRAJFROmTdnIHWnTLQ/o+NqCuRqVSrWQewvOmTkhJgxQoAgPG75Rj32GcoqgyDRquxCVoKAWg0qP4H6Ny9Ef7E2l6KlJubi/h4JxNRUK105swZ/Oc//8Fnn32G33//HQDw3nvvydyqEHPmDPJXr0bjDRsAAHXWrwc2bQKaNgXq15e5ceohhHD6uVJaWhrk1tQeUoGxYM6c6Ip1kElJ2X+hlvllDn6FQm09f2Pwi4go1LVqBcyYATz9NGD+9q9NG2DnTmD2bNN6OxqNBi3apGP01H4wVBlxYPcZ/LTwN+zenF8dPNFcO0GQOk8QADTV0bLqcwpN9WJ9uQE7Nx7Hzo3HkbD3A9QFcHTyBzhV9ybc2KEBUtLr+LsH1MMqgIXvvzf9Hhsrfd+DB4H77jPdB4DQV0BTPb25trICry58EQat6WO+IiwCn9z+Ci7EN7BsHlsnHOPevQdRUcqdrl1NhDDd/LUvIrOysjIsXrwYCxYswJo1aywXNK6CC+Ql6/fTggJcX3htNmRtVRVw221AfDyQmGh6T166FMhUTl1EJV7kWtdGcjfsUSnD8tTC1d9bap1S+jc8/Nr5hlKDX+6oIfPL3LeuAnW1MesLYPCLiCj0paYCo0c7Lo+JkV5uRxemRdZN1yHrpusghMDxQ5ew9ts8bPrxIAyVAqI6+qXRaGwyvwCNObnIFBiwO7eIMOjR5rIpc6Hhga14+58rUaGLRHL9ODRqloxmrdJw/Q2paNwiBTFxyjhx8zu7ABYqKoDqABb0eqB5c8B80mp/wZWWBkNcPHT79gFwHJGaUF5g+flYcnMURieY7qcDxky8C42aJgXkKRGRf6xduxYLFizA4sWLUVxcDOBaEKF+/fq4//77MWTIEDmbGDrS0kwzJFe/n0oqLDTdbr0VSE8PXts8oKRAgllZWZnTYY/2AYRYZ1/ykCRXRdelAh5KKWxunfmlpAwq6/5xF0hWUrudMR8fro6T2ljvC2Dwi4iIvKDRaNAkMwUj/3o7Rv71dpw9eRWbfzyENUt/R0lhhc1wR+BaBotGA6SVnsMLe3MQYTSdpIeJKoQL00lEuKjCW9v+gSpNdaaSLgL/bp2NRbH1AQ2QVC8WzVunodmN9dCkZQoaNU9GRGQIfIS5u+A6e/baz9UXXJcvFOOrOb9i/67TQMNs9CtugL77lgIaQGt1gWHQaKERAj+2HoyfWt8PhIfh2Vduxw1tOWwnIJj6RX6wf/9+LFiwAJ9//jlOnjwJ4FrgICMjA0OGDMHQoUPRtasXs/SSewkJwIYNwOTJwOTJ1cnLVq9DnQ4wGoHx44HXXzfNpKwgRUVFcjfBweXLl5GUJP0li/1FudqCX3IHDlwFNaTWyd1es8jISMvPSgoiWb+XupvN0dl6pfSxNVdDOJUSEA222vmsiYjIL9IzEjD4yZsx+MmbcfVSKXLXHcPmlQdxzFxc3erarDCiDkrDotGg6KzkvhIrrg0zORLfFIVRiaZfBHD5XAm2nTuKbauPWvablhGPNrc0RFJqLNIbJiC9YSJS0uOg06koldvuggsajekCy0yngzAasbvPCHyRchdKn1hWPZK0umO1OvzQ9gGURcRi8O7/2OxaJ4xY3OExbG43ANmv3oHmN9YL4hMjIk9dunQJX375JRYsWIDt27cDuHbRkpiYiIKCAmg0GkybNg3Dhg2Ts6mhLSwMeOMNQKuFZuJE23UGAzBxIjBhghwtc+vcuXNyN8FBUVGRJfjlro6SUgqyS5FquxzDCLVarSUryVWmn1RQSSmBcut+U9JQXetAkLtj1Vm7lRj8ctXHShkKG2wMfhERkV8kJMeg95BW6D2kFaoqDTj021ls/PEgdm44jrLSSpSFxeCtDq9h4PHvMPD4cggAOquCYYbqkM6yJvdgWeMBMGp112Jn1udt1ZucO1mIcyd/t6zXaDSWLLFGTZPRoEki6jdMRHqjBKRdF4+YuEgoUvUFlzE+AdpXXrZdZzBgUdtHsS7uTqC8+iSmupSamTAIXFfwBwwaLbTCaKmtJjRa9GlSgcHzHgzSEyEiT1VWVmLZsmVYsGABVqxYgcrKSstFV0REBPr3749HH30UAwYMUEyx6lrD2Uy7S5YoNvilVM6GPdpTchaKVNvlyFTT6XSWYEa5ixmypTKTGPzynLvML2eUeAy7et0x+EVEROQnYeE63NjxOtzY8TpgLFBWUoG9uSex+cdDWB55H0rDovHQkW9sttFB4Mtmw7Cy0V3Q2M8n6eTzW6O1O6GrzhK7fK4Eu37JtyyOjA4zTV1fNwZJ9eKQml4HSamxSEiORmJSDBKTY5CYEoP4ujEIC9MC5eXA++8DL74IREXVuD+EENCXVaG4sBzFheU4f6YYR/adw6Hfz+Py+WJUVhrx2K+L0ckugGXUaJFR8Iftc7Y7idUZq9DuVC50wogqjQ75Pe7F9Zu+g7ayEnGrvjfVEaulJzlESrNlyxYsWLAAX3/9Na5cuQLgWuH6bt264dFHH8WwYcNQt25dmVtaS1VUAIcPAwCETofCnj2R8PPPQFWVaTnfTwNCycW3pYI01sP3giUsLMxSK83bzC+lsP47Kyn4ZZ215apdoRRMsp58oDZh8IuIiAIuOjYCnXo2RaeeTQEAFQ+ugTimA4yGa4EeaNGw+IRpA/NCKdXnTvbfKLv6ZlNfXgWNBrhyoQRXLpTgaN55yftFROpQWWnALWe24Ild/4f/LMnH7y1vR2RUGKJjIhEZHYao2HDodFoYq4yorDLCUGlEZaUBVVVGVOmrUFFpgNEoUFJUgYrySkieR2nMgTtTm3XGKrQ//aslgLWlye249Y/1CBMGtD/9K740VllmbgQAAWEJD15/8SCiqvSoaNIcEf9bjKZt2gC//QYMHWoqqL95M9Czp9O+IaLgMdfqMr9vtWzZEo8++igeeeQRNGnSRN7Gken9srQU5U2a4MT06dBnZiJBCL6f+kgq80tJQQ9PSM3uJ1fwy8zVjIMMfnnP+vzRVbtcZYXJHUyyHhZrxppfjmrnsyYiIvlUVCDi+/8BRgMQHg6MHAnMmwddZSU6X9mFxfFhuFpkcJy+EDBHyQANbGaZlFS92Jts/4oK04lNh9O5AICso79gfeLNNvvUAEB1xpnTXdvNdmm/3PJ/taaXDiHKoMfZuPqYc8sLOJPYCOub9cGTW2Yirfgsml46iEOpWVbPyTTxQLc7m+Gmlr2Ab1IR8fTTphk8AaBNG2DnTmD2bKBVK887gHwmhLg226kf9kWhrU6dOnj//fcxfPhwuZuiKjk5OcjJyfF5aJJbrVoBM2bgSNeuEObhpnw/9ZlU8EvJwRkpUllWcgQOPB0yqMSZP81sJ0QSivms8zQo5+p9R+7Mr/DwcOjNs4V7oLYGv5SbY0pERKFp82aguBho2RLYvh34+GNotm8HMjMRUVGGd19qgk9WPYE35w/BA6M64caO9REZXf0hfS1ZynlmGK6t12o10Gg0lhMu65+dbRNRpUfri78BANpc3IOIKn11plZ1IE1j2wwLjdXNeVjMYUZMADgTfx2+afMo3uo1GacTGgIATic0xFt3vomFbR/FmfgMRMWEof2tjfDSpN7499cP4+UpfXDrHc0Q3iAdGD36WuDLLCbGtDw11XU/keqVlpZi6dKlePLJJ9GyZUtERUUhNjYW7dq1w6RJk1BcXOx02/nz56Nz586Ii4tDUlIS+vfvj82bN7t8vE2bNqF///5ISkpCXFwcOnfujAULFrjc5uTJkxg5ciQaNGiAqKgoZGZmYsKECS5r10j5448/LK9jqVt6erpX+5ODEALFxcV44okn0LFjR7z77rs4c+aM3M1ShezsbOTl5SE3NzcwD5CaCowefS3wZaai91MlzZwo9XkbsMBlgEgFk+Qobm4dXHHVh66ywpRECKGY7C/r4Je3M2mayZ355e0xqcQC/cFQO0N+REQkn+pv1uEiU0mj0SC9YSL6PZiIfg+2BQBUVhhw4ugl5P16Gkf2ncPxw5dRdKUMrr44NBqqV2pMgTAp9UrOInvnvxFhMJ3g6kQVwo2mb6bDjVWYsuE1GDSmj8sKXQQ+vHk0zsdJXGBbFaJ3Gl/TaBzvDKA4Mh5rm/WFRmM+CROIi49Ck8wM1H/+dozv0ggxseqqJ1HbCAGXx6K3+/LGF198gaeffhoAcOONN+Lee+9FYWEhNm/ejAkTJuDLL7/Ezz//jHr1bGf8fOmllzBz5kxER0ejT58+KC8vx8qVK/HTTz9h4cKFuO+++xwea9GiRXjwwQdhNBpx++23IyUlBatXr8bw4cOxZ88eTJs2zWGbw4cPo0uXLrh48SJat26N7t2749dff8WkSZOwevVqrF692uthRGlpaejXr5/D8oSEBK/2E2zr1q3D/PnzsWjRIhQVFWHXrl3YvXs3XnvtNfTs2ROPPfYYBg8ejLi4OLmbSiqVkpIidxMcWGf4KDkzSYpUNo0cNcqirOqPusqeU0vwC1DW0EczV9loroJfcgeTIiIiUFpa6vH9a2vmV+181kREJJ/qb9YdmL9ZdyI8QoemN9RD0xtsL+ArKww49ccVHNh1BscOXMCpP67g8oUS6MtMJ4emjC3nmVhFEfEoDYtG/RLpzItE/VXLz0cTm+FqRLyrZwfAFLyQfEijALSARqO13E+rBWLqRCL9ugQ0b1UP7To3RKNmSYqZnYmULzw8HKNGjcJLL72EG2+80bL8zJkzGDBgAHbu3ImXXnoJX3zxhWXdqlWrMHPmTCQnJ+OXX35BixYtAAC//PILevbsiZEjR6Jnz55ITEy0bHP58mU88cQTMBgMWLRoEQYPHgwAOHfuHG677TZMnz4d99xzD3ra1UQaMWIELl68iBdffBEzZ84EYLp4GzZsGJYsWYKpU6di4sSJXj3nG264AfPnz/dqGyW4/fbbcfvtt+ODDz7AkiVLsGDBAqxatQoGgwFr1qzBmjVr8Nxzz2HgwIF47LHH0LdvX7mbTCojZ+ZXQkICrl699pkpNeyxrKws6O2qCansVDk+n60zi1wFaJQYUHJGiW2171vzhCSA66Cj3MEk+2GX7oaUKnmSiUBi8IuIiFQtPEKHJpkpaJLp+G13eVkFTh27gtPHC3D25FVcPFuMKxdKUHCpFCXFehiqjChDDN7pPBb3HFuG/oeXQcA086SZAVpoILC8+b34vsW9EDoXH51COMxAqdGYZr+skxCFOknRSEmLQ8OmSWieVQ+NmyUjLLx2pp6T/wwfPlyydlT9+vWRk5ODrl27YvHixaioqLCcIL/77rsAgNdff90S+AKALl264JlnnsH777+POXPm4OWXX7as++STT1BYWIhBgwZZAl+AKQvr7bffxuDBgzF9+nSb4Ne2bduwadMm1KtXD2+//bZleVhYGD788EN89913eP/99/H666/LfvEQTFFRUXjooYfw0EMP4ezZs/jPf/6D//znP9izZw9KS0vx9ddf4+uvv0ZycrLcTSWVkfOiNj4+3ib4JUVtmV9KyaTytKaUUupoeUKJbbUPyBkMBstnk6vML7mDSfbDLt31bW39grX2nGUQEVGtExUdgWZZaWiWlebyfpWVVSgpfAhX352Buv983WadDkbsGDoaV7o9gC5aQKvRQhemgU6nhTZMizCdFrpwDSIiw1AnIRqJydGoVz8edVNjodPVzm/WSDnatWsHwDR059KlS6hfvz7KysqwZs0aAMDQoUMdthk6dCjef/99LFu2zCb4tXz5cqfbDBgwAFFRUVi1ahXKy8stQ3TM2wwcONBhaGNaWhq6d++ONWvWYOPGjQ4ZY7VFeno6XnnlFbzyyivYvXs3Pv30U3z55Zc4d+4cLl68aLlIGTNmDDZt2oShQ4eie/fuMreayJF91plU5pfagl9qqlGmxGCSK84yqeQcQiiV+WWmpuCXErPqlIDBLyIiqvXCw8OQmBwGnDwI6HSA9QmOToeOsQXo+FI3+RpIyidn0S8Xjh49CsB0YpyUlAQAOHDgAPR6PVJTU5GRkeGwTceOHQEAe/bssVm+e/dum/XWIiIi0Lp1a/z66684ePAg2rZt63Yb8/I1a9Zgz549XgW/zp07hwkTJuDMmTNISEjALbfcgnvvvVf2Gbdqql27dnj33Xfxzjvv4Mcff8SCBQvwv//9D+Xl5Th9+jRmzZqFWbNmoV69erj//vsxZMgQ3HnnnXI3mwiA49CvUJjtUU3U1rfO2itnFrB90KisrMwSWHIV/JI7k8q+z1wFQuVuq5z4lTQREREAVFQAixebAl/h4cCoUab/DQbTcpV9W03qV1hYaHPzZhpzM3ONrX79+lkyr/Lz8wFAMvAFmLI3EhMTceXKFRQVFVnaYh7O5Gw78/Ljx49blrl7LKltPLF//35MmjQJs2fPxrRp0/DAAw+gRYsW2LZtm1f7USqdTof+/fvjv//9L86ePYuPP/4Yt912GwDTRc25c+fw8ccfsyYYqQ4zUvzPXJdMTVlqgPMsQOvi/sEmNexR6melsc+Wc/U6k7s4v5wY/CIiIgKAzZuB4mKgZUtg+3bg449N/2dmAkVFpvVETpgTv/x1A4CGDRsiISHBcps6dapXbfr+++8xZ84chIeHY/LkyZblxcXFAIAY82yrEszDl8zBL/M2rraz38aTx5LaxpXIyEg8++yzWLduHc6dO4fCwkL88ssv6N+/P/Lz89G3b1+vA2lKFx8fj6effhrr16/HkSNHMGHCBDRr1gxCCNUNc1IDJV/gqo1U5pfag19KDBwUFhYCUF/ml7N6avZD+ORkPeGBkvuXwS/PMPhFREQEAK1aATNmADt2AG3amJa1aQPs3Gla3qqVnK2jWujEiRO4evWq5TZ27FiPt92/fz8effRRCCHwzjvvWGp/qV39+vXxwQcfoEePHqhXrx7q1KmDW2+9FcuXL8fDDz+MgoIC/POf/5S7mQHTpEkTTJgwAYcOHcKGDRvw9NNPy92kkBNqwVM5WQ+vCpVArZICM2bmLxnUFrh1Fvyyrw8ZTFLDHs2U3L/2QxldBb9q0+Qy9mrvMyciIrKWmgqMHu24PCZGejlRgMXHxyM+Pt7r7U6dOoV+/frhypUrGDNmDEbbHb9xcXEAgNLSUqf7KCkpAQDUqVPHZhvzdlLtst/Gk8eS2sZXf//73/HFF1/gxx9/rPG+gmH58uVYsWIFjh8/DoPBgAYNGqBnz54YNmyYRxfY3bp1Q7durEXob65eF0RyBmacMR+zSg7OSHHWXjn72D5Ia53tpeTML2+CX0oM4AYLg19EREREIeLy5cvo06cPjh8/jpEjR2LatGkO92nUqBEA4OTJk5L7KCkpQUFBAerWrWsJSsXHxyMhIQFXr17FyZMnkZWV5bCdeX+NGze2eaydO3c6fSypbXzVokULAMCZM2dqvK9AOnfuHO677z7J+mRz587F+PHjsXTpUrQxZ6ASqZR95lcoFNpWYvDLTG1DSpVY8N4++GVdl0xNwUVXbeWwRyIiIiJSteLiYtx9993Iy8vD4MGDMXv2bMmLzZYtWyIyMhIXLlzAqVOnHNbv2LEDACwzNpqZh06a11urrKzE3r17ERUVhczMTI+2cfVYvrhy5QqAa3XElMhgMODee+/F1q1bLTW77G/Hjh1D3759cfHiRbmbS1QjoTjsUW3BLyUHOpwFaORss7PjVG01Fl0Fv2pz5heDX0REREQ15CyQ4evNW3q9HoMGDcK2bdvQt29ffPnll04vIKKjo9GrVy8AwDfffOOwfuHChQCAgQMH2iwfMGCAzXpr3333HcrLy9G7d2+bmbrM2yxbtsxhtspz585hw4YNqFu3rl+G7y1atAgA0LFjxxrvK1C+/vpr5ObmQqPRoHnz5pgzZw5+++037N+/H9988w1uvfVWAKa+mT59usytpZYtW8rdhJCntgtxJddLksqkUnJ7nX3WabXyhSictUltBeRdBb+UfEwEGoNfRERERCpmMBjw0EMPYc2aNejevTsWL16MiIgIl9uMGTMGADBlyhQcOnTIsvyXX37Bxx9/jMTERDz55JM22zz11FOIj4/Ht99+i8WLF1uWnz9/Hq+++ioA4OWXX7bZpnPnzujWrRvOnz+P1157zbK8qqoKzz33HCorK/Hiiy86XAA//vjjuOGGG7BkyRKb5bNnz8b+/fsdns/ixYvxt7/9DQCQnZ3t8rnL6euvvwZgKly/bds2jBw5Eq1atUJmZiaGDBmCDRs2oEePHhBCSAYma7ucnBxkZWWhU6dOQXk8tQVmlMaTzC9371VKo+TAgVSAxvrLCKVxdkzIOTzWWZtc1ftS4nBeZ5MJAMoM1gWLcl+9RERERGrhz1IrXu5r1qxZliBRSkoKnnvuOcn7TZs2DSkpKQCA3r17Y/To0Zg5cybat2+Pu+66CxUVFVi5ciWEEJg3bx4SExNttk9KSsLcuXMxbNgwDB06FD179kRycjJWrVqFgoICjBkzBj179nR43Hnz5qFLly6YOXMm1qxZg6ysLOTm5uLo0aPo2rWr5CyW+fn5OHDgAK5evWqz/PPPP8eoUaPQtm1bZGZmwmg0Ii8vzxIQ++tf/4r777/fuw4Mop07d0Kj0eDll1926F/AdFHyxhtvoGfPnjh27BiKior8MhlAqMjOzkZ2djYKCwuRkJAgd3MUQclDsTwJfil5mLIUJQcOpAI0Sg5+qYnaMqlcBeuU2N5gqb3PXMVycnKQk5OjqqJ7REREFBjmWlcAHDKlrE2cONES/AKAGTNmoH379pg1axZWrlyJiIgI9O7dG+PGjUPXrl0l9zFkyBCsX78eU6ZMwZYtW1BRUYGsrCw8//zzGD58uOQ2LVq0wM6dOzF+/HisWLECS5YsQaNGjTBu3Dj8/e9/96qGztNPP43U1FTs2rULP/30E8rKypCamorBgwfj2WefRe/evT3elxwuXLgAALj55pud3sd63cWLFxn8IpeUfj2g0WgsgS+pAFh0dHSwm1Qjagt+qS2zTm7OgrRqC365aq+cw0rlpry/FLnFb72IiIiUxZ/FcL3dz8SJEzFx4kSfHmvEiBEYMWKEV9t069YNP/zwg1fbNGzYEPPmzfP4/uvWrZNc/sgjj+CRRx7x6rGVpKysDBqNBnFxcU7vExMTY/m5vLw8GM0iFbOejU7JnL1HKrmAvBQlDnEzkwp4MPjlHV9qfimxj121tzYHv2rvMyciIiIiUjAlD2kjZSgsLJS7CS6Zg0VCCNXNRqhkUgEXqeCXErOSlMyXzC8l1gZ0NeyRwS8iIiIiIiJSFfu6eEomdUGu5AtxJQefpWp5SbWXwUXv+JL5pcQAo6tjV8mvuUBT3l+KiIiIiCiEffDBB6hXr55f7jd+/Hh/NYtUyNWsbkpgnfkl1VYlDyNUevDLPutPqr1K7l81UVvNL1fButp8TCjvL0VEREREFMI+/PBDl+vNFyfu7gcw+EXKZh38Ukt9MjNXAQS5eVorrTYHOvzJ1bHA7Dr1YPCLiIiIqIbkLHhP6uLPvy8vbElN1Bb8UvJMmvbDHvm54R++DHtUYvCLx4M0Br+IiIiIiIJg7dq1cjeBKKjUnPml5CGl9kPtGOwILFeB0NpcQ0ttGPwiIiIiqilRffPXvigk9ejRQ+4mEAWVdXaiqxnolEjJwTr7gIuSh2iqTUREhMPf3lX/MvilHvxLERERERERqVydOnXkboJTzgreK5mSg1/2Q56VPERTTYQQCA8Pd1jO4Fdo4F+KiIiIqKaEn28AOnXqhKysLOTk5ATxiRCRWiUkJMjdBAfWwx7VFqCxD34pucaeGjK/1DI0Uyr45SprUQnHhVr6Vm4c9khERESkQLm5uYiPj5e7GUSkEkrM/LIOfqntAl2v19v8HhERIVNL3FND8EvJNBqN5Rj1NvOL1IOZX0REREQ1ZD5p9teNiBzl5OQgKysLnTp1CthjaPR6pMydC41d4ENJnF2Ic/hVzVm//9oP05QKiiiFGoIznny2KeEYjoyMdFim9P719LxBCf0rp9r97ImIiIiISBWys7ORl5eH3NzcgD1G/MqVSH/vPcSvWhWwx6ipy5cvSy5XwvAre9aZX2pjH/CQCooohdKDM4BnbVRCgNG+DUIIVfSvJ3Q6ndxNkBWDX0REREQ1FYCaX0QUfPE//WTzvxKdPXtW7iZ4TG3BL1dBDiUHv9Qwk6YnASQlDC21b4Majl1P2xgWVrurXjH4RUREREREtduZMzBu2IA6GzYAAOqsXw9s2gScOSNzwyiYXBXlV0Jgxhk1TCbgSRuVkPllPzRQDTM9epqZVtuDX7X72RMRERH5gT8TtpT/HTNRiDh4ELjvPqCkBCgogLaw0LJKW1UF3HYbEB8PJCYCsbHA0qVAZqZcrVUltWV+lZaWOg1yKTlwYF+fTIk8aaNcAUbrgvf2AS1XQTsGv9RFGX8tIiIiIiKiYEpLAxISgPx8wCrwZaOw0LQ+IQFITw9u+0KAq+CXUgIH1srLy52uU3LgQA2ZX/azZ0qRM/gl9TPgOrCklGPC07+/EjLr5KS8dxwiIiIiIqJAS0gANmwAxo8HNBoI+4LxOh2g0QATJpjuFx8vTztDlBKHEZaUlDhdp8RgnZkaan55EvxSSjDJmhoyvzz9+zP4RUREREQ1I4R/b0RBsH37drz11lsYPHgwMjIyoNFoPJoxcP78+ejcuTPi4uKQlJSE/v37Y/PmzS632bRpE/r374+kpCTExcWhc+fOWLBggb+eiu/CwoA33gAmTIDG/rVnMJgCXxMnmu5HXnOV+RUVFRXs5rhVVlbmdJ0SZ9M0U0Pwy5Nhj0oMfrnK/FJKMImZX55R3tFFREREREQBN3nyZHz77bdebfPSSy9h5syZiI6ORp8+fVBeXo6VK1fip59+wsKFC3Hfffc5bLNo0SI8+OCDMBqNuP3225GSkoLVq1dj+PDh2LNnD6ZNm+anZ1QDixdLL1+yxBQAI5+4Cn5FR0cHuzk1ouTgl1SARilZSWauhpSa6XS6ILTEO66CX0ppryd9CyinvXJR1iuCiIiISIWY+EVq1KVLF4wbNw7/+9//cObMGURGRrq8/6pVqzBz5kwkJydj9+7dWLp0KVasWIH169dDp9Nh5MiRKCgosNnm8uXLeOKJJ2AwGLBw4UKsW7cOCxcuxP79+9G8eXNMnz4d69atC9yT9ERFBXD4MABA6HS4eued1zK9Dh82rZdZy5Yt5W6C37k73shzUgEapQ0r9SQ7Sa6AnavAphpmAPW04D2DX0REREREVOu89tprmDRpEgYOHIh0D4q5v/vuuwCA119/HS1atLAs79KlC5555hkUFBRgzpw5Ntt88sknKCwsxKBBgzB48GDL8rS0NLz99tsAgOnTp/vj6fhu82agtBTlTZrg8Ndf48SMGcCOHaaZHUtKTOtlJjVcSQ1Fzs1BBamL89o+BMufpDLr1BhclCu7ztXjqiHzq8LDAL3SsgGDrXY/eyIiIiJ/YOoXhbiysjKsWbMGADB06FCH9eZly5Yts1m+fPlyp9sMGDAAUVFRWLVqlcfDdgKiVStgxgwc+fpr6DMzTcvatAF27gRmzDCtVyA1Bb+kgjNKCRyEglAYViontQe/PK35xuAXERERERGRCwcOHIBer0dqaioyMjIc1nfs2BEAsGfPHpvlu3fvtllvLSIiAq1bt0Z5eTkOHjwYgFZ7KDUVGD0awj5YEBMDjB5tWq9AroqzK43UxXltvxAPNKUMyVO7UJrtUcl164JBGX8tIiIiIiJSrPz8fACQDHwBQGxsLBITE3HlyhUUFRUBAAoLC3H16lWX25mXHz9+3N9NDnnmflYy88W2VAChtl+IBxqDX55Te+aXp1mgtf01x9keiYiIiIjIpeLiYgBATEyM0/vExsaioKAARUVFqFOnjmUbV9vFxsYCcB3I0ev10Ov1lt8LCwu9anuoKikpkbsJbpkvtqUyU5R8IS41jFBtwsJ4qe8PrgJLSgl+kWeY+UVERERUQ0IICKOfbiFw0UXkT1OnTkVCQoLl1rBhQ7mbpAiVlZVyN8FjSm6rVGH4UHgfZmDGc77O9sgAo7ow+EVERESkQJ06dUJWVhZycnLkbgoR4uLiAAClpaVO72PORKpTp47NNq62s99GytixY3H16lXL7cSJE941nmTjarZHpTBnH1pTcns9peTMOqXxddijUmp+kWcYqiQiIiJSoNzcXMTHx8vdDCIAQKNGjQAAJ0+elFxfUlKCgoIC1K1b1xLIio+PR0JCAq5evYqTJ08iKyvLYTvz/ho3buz0sSMjIyWzc0j5XA17VAqpWRFDIfhFnnMV/FLqsavT6VQx46uSMFRJREREVFMCEH66Qf2jbSgEtWzZEpGRkbhw4QJOnTrlsH7Hjh0AgLZt29osb9eunc16a5WVldi7dy+ioqKQmZkZgFYTuScV/LIPKjCLyjfh4eFyN8EjvmZ+yYlfCHiPwS8iIiIiInIpOjoavXr1AgB88803DusXLlwIABg4cKDN8gEDBtist/bdd9+hvLwcvXv3RlRUlL+bTAqghqCRVIDGvkYZZ070jfXQZyXzJfgl97HN4Jf3GPwiIiIiqinh5xuRAo0ZMwYAMGXKFBw6dMiy/JdffsHHH3+MxMREPPnkkzbbPPXUU4iPj8e3336LxYsXW5afP38er776KgDg5ZdfDkLrSQ5yBwg8IVW3qaKiwuZ3Bhp842p2WCXx5TiVe0IBfmHgPQa/iIiIiIhqoeXLl+PWW2+13MwX/NbLli9fbrl/7969MXr0aFy6dAnt27fHfffdh/79++P2229HVVUV5s2bh8TERJvHSEpKwty5c6HVajF06FD06tULDzzwAFq2bInDhw9jzJgx6NmzZxCfdWiSKtpOnpEKfNgHvxho8I3UkFIl8iX4JfeQTrVk1SkJC94TERER1Zg/U7aY+kXBceHCBWzdutVhufWyCxcu2KybMWMG2rdvj1mzZmHlypWIiIhA7969MW7cOHTt2lXycYYMGYL169djypQp2LJlCyoqKpCVlYXnn38ew4cP9++TqqWSkpLkboIkZ0EFpQ8jZPDLP+TOjvKUL8GvsDB5QyneZiOqIQsz0Bj8IiIiIiKqhUaMGIERI0YEZbtu3brhhx9+8PqxyDNKHV7m7IJb6RlBHPboH95kR8kZTJIa+uqO2o4JuTPVlIDBLyIiIqIaEsKPeV9M/CIiL8mdheItpWdSVVVV2fyulgwmNVNbH6stmKS294hAYM0vIiIiIiIiFVPqkCa1Zn7Zz/DnS2YQOXJ1nKot80ttwSS1tTcQ+CpWoZycHGRlZaFTp05yN4WIiIgAzvZIpHL2wQ7yD2fBDrVlzTD45R+ugl9yHhO1IfilttdcIPBVrELZ2dnIy8tDbm6u3E0hIiIiIlK9vLw8uZtQq6gtcED+4SrIJGdwxjooJzysPaC2Y1jpk0wEA4NfREREREREKqKWTDVnmT7MpKoZTwM0SqPU4Jcv9cbUVqNMbQX6A0Fd4UoiIiIiBRJCQPhpvKJaL2qIAi0nJwc5OTkwGAxyN0V29rMRKpEQwmnwS6k1yiiwXAWM1Jb5pbbgl9oy1QKBIXciIiIiIlK8YJX+yMjICOj+/aGkpETuJrilluw0NVJr3yo1+OVLJqLaArhqC9YFAsN/RERERDXlz2QtJn4RySoxMVHuJrhVVFQkdxPcKisrU12AQC3UmiHsKvtIzuCM9WOrNbDoDocaM/OLiIiIiIgIGr0eKXPnAuXlcjfFreLiYrmb4FZxcbEqg19qCCxVVVW5XK/UQIer4JecbbY+TkN1WLVSj4lgYg8QERER1ZAQwq83AOjUqROysrKQk5Mj87Mjqh3iV65E+nvvAYsXy92UkHDx4kW5m+ATpWb+WAcv3AW/lDqzn6t2yRkotc78UkPw0xdqDET7G4c9EhERESlQbm4u4uPj5W4GUa0R/9NPph8WLgQefljexoQINV5wV1ZWyt0ESVqt1hKYKysrc3lfpQa/XNX1UlPmF7Oo1Il/NSIiIiIiqtU0paWos3Gj6ZfvvwdUUFBeDaSCX0oNzJi5y6qSi/WQQb1e7/K+sbGxgW6OT6KiouRugiRva36xeLw6MfOLiIiIiIhql4MHgfvuMwW5DAZklpRAa8740euBxo2BqChApwNiY4GlS4HMTDlbHDLi4uLkboJLSs38sg5+uWujnDMnuqLUjCnrIK0nwS+l9i+5xuAXERERUQ0J4b9JGkO03AiRsqSlAQkJwL59AACHS9lLl679fOutQHp60JoWSqQyv5Qe/HKXVSUX64CLu6F5kZGRgW6OX8mdSWUdlPMk+KXE7MWwsDDFZi0qhTJDr0RERERERIGSkABs2ACMHw9AInhtDtpMmGC6H+vv+UQq+KX0wEy5Qmf7tB4y6C745WpWRTk5C87IPRwyVIJf5BqDX0REREQ1JYR/b0QUeGFhwBtvAH36wCFEIwTQty8wcaLpfgqm9GCSPaVfpFdUVNj8rpQhbtZ/Z3fBL6UOL3Q2XFPu4Jc1T4JfSnzNKf11pQTKfFUQEREREREFQ3w8hEZjm/2l1aom2ystLU3uJljYZ8RIZX4pNTBjZh+gUUpgxrpv3QVolDrLprPMr+jo6CC3xDnhwRdQSgmIWlNim5RG2e88REREREREgVJRAaxYAY0QQFgYLg8dCoSHA0YjsGKFab3CKWlmv5SUFJvfpYIwSg3MmNkHP5RSo0yJQ+285SzzS0nPzZPMLyVmWcldN00NGPwiIiIiqiEhhF9vRBQkmzcDxcUob9IEh7/6CqcnTAC2bzfN7FhUZFqvcErKpFJSIM5flJSVpHbOgl9Kylry5DNYiYEmpQeVlUB5IUsiIiIiIiI7OTk5yMnJcVvvyCutWgEzZuBI164Q5iBHmzbAzp3A7Nmm9QqnpIteT4Y9qo2SspLUzr6empmSMqk8yfxSUsDZTIltUhr2EBEREVFNCT/fiMhBdnY28vLykJub67+dpqYCo0dfC3yZxcQAo0eb1pPH7INdoRD8UmKWj1o5C34p6TjxJPilpPaaMWvcPQa/iIiIiIiIiCQoMdChVs6GPVLNOZtMAGAA10w5+YVEREREKiWE/xK2+OUtEYUKBo7ImlR2ktKOEU8yv5TIVfArMjIyiC1RLmZ+ERERERFRrabR65Eydy40er3cTQkpSgts1AZqq/2kpHpfgHqDX66y6li3zkRZRxoRERGRGgnLP37aFxEFy969e5GwciXS33sPlWlpwE03yd0kj9WpU0fuJnglKipK7iaEPLX1sdraq1Sugl9Kmk1TTuoKCxMREREREflZ/E8/2fyvFvXq1ZO7CS7ZZ36pLVinRnFxcXI3wSvR9pNNyEytheNdDXtUWh/LhcEvIiIiIiKqtTSlpaizcSMAIH7jRqCkROYWeU7pWTP2wa/4+HiZWlJ7qC34FRsbK3cTbLgLfqlxKC8zv0wY/CIiIiJSoE6dOiErKws5OTlyN4UotBw8CGRlAY0bAxkZyOzbF9rqIUOaigrLcjRubLrfwYMyN9g5pV+IGwwGm99Zeyjw1FbcXGmBGXfBLzVmUSmtj+XCml9ERERECpSbm8ssCaJASEsDEhKAffsAAA6XhZcuXfv51luB9PSgNS3U6O0mEFBbMXY10ul0cjfBK2oLzCg921IKX3cm7AUiIiKiGhLCvzciCqCEBGDDBmD8eAASc0yYs6kmTDDdj0FonxUWFtr8rvRMNQo+pR0T7jK/GPxSL/YCERERERHVLmFhwBtvAH36wOHSWwigb19g4kTT/chn9sEvIqVzF/xS27BSuobv5kREREQ1JIwCQuOflC21zjRFpEb6qChEaDSAENeCYFots738xNUMdGqgtGLs7qhtyKMShVrwi8fENcz8IiIiIiKi2qeiAmGrVkEjBBAWhstDhwLh4YDRCKxYAVRUyN1CklndunXlboJX1BasUyJ3wS+1BZNiYmLkboJiMPhFRERERESKl5OTg6ysLHTq1Mk/O9y8GbrSUpQ3aYLDX32F0xMmANu3A5mZQFERsHmzfx4nQBISEuRuQsiLi4uTuwleSUxMlLsJXlFbsXtAeTXK3GFA9BoOeyQiIiIiIsXLzs5GdnY2CgsL/RP4adUKZ157DZeHDIGIjkarVq1Mxe537gRmzwZatar5YwRQWlqa3E0IeWEqq/kWHR0tdxO8wqykwFPbMRFIzPwiIiIiqinh5xsRBV5qKi4/8ACSv/wSGr3+WkZHTAwwejSQmipv+9yIiIiQuwmkMGoL1ikxsy7U6m6qcXbKQGHwi4iIiIiIaqX4lSuR/t57iF+1Su6mENWY2obkMfMr8NRWoyyQGPwiIiIiqiEBASH8dGPqF1HQxP/0k83/FDj16tWTuwmkMGqr+aW29pItBr+IiIiIiKjWMRQWos7GjQCAOhs2ACUlMrcotKWkpMjdBK+wUHjgabXKC0e4GvaoxGGariixf+WkrkHBREREREREvjh4ELjvPlOQy2CAsaQE4ZWVAABtZSXQuDEQFQXodEBsLLB0qWnmR/ILtV2IJyUlyd0Er7AGnH+4Cn7VqVMniC2pORa7t8XgFxERERERhb60NCAhAdi3DwDgMIDp0qVrP996K5CeHrSmkfKoLcvHLzOg1mIajcZSfsAZtdUoU9sxHGjqCr8TACAnJwdZWVno1KmT3E0hIiIiAAboUeWnmwF6uZ8OUWhKSAA2bADGjwcgMbGquVj4hAmm+8XHB7V5pCxqKxQer7LjVW2BJEB9xwSH7tpi5pcKZWdnIzs7G4WFhYzwExERySgiIgLp6enYcnamX/ebnp7OISxEgRAWBrzxBrBlCzT2Re6FAPr2BSZOlKVp3khNTZW7CaQwkZGRcjfBK8nJyXI3wWtqm01TbcdEoDH4RUREROSjqKgoHDt2DBUVFX7db0REBKKiovy6TyKyEh8PodEAQsByOavVKjrbKyMjAydPngSgvpkT1ZYxo0Zqq6nGJI7A4+vOFoNfRERERDUQFRXFQBWRmlRUACtWQCMEhFaLy4MGIem774DKSmDFCtN6BWZeJiQk4NKlS4iIiFBdBkr9+vXlbgJRjTAbW/3UFR4mIiIiIiKqic2bgeJiVKakQGM0ouSWW4Dt200zOxYVmdYrkEajQbNmzdCwYUO5m+I1tdWjYq2kwFLiLITuAspqm+lRbZmAwcAeISIiIiKi2qNVK1waNw6lWVkAgPiffgLatAF27gRmzABatZK3fSFIbRfiaqtHpbbhbSkpKXI3wYG74JfaZk5kRrojdb0LERERERFRreS3Gc9TU3H2nntQ55dfAAB1NmwASkqAmBhg9GiAxeRrPbUFOtSWWae2LCpAfbNTqu0YDgbW/CIiIiIiIsWr0YznBw8C991nCnIZDMgsKYG2shIATP83bgxERQE6HRAbCyxdahoGSbWS2jLVlJhJ5Yra+hdQX3Ydh+46YvCLiIiIiIhCW1oakJAA7NsHAAi3X3/p0rWfb70VSE8PWtOIaqJ58+aIjIyUuxmkMEqsqyY39YVciYiIiIiIvJGQAGzYAIwfDwAQ9uvN9X4mTDDdT2XDyJQsPNwh1Eh+wtmG/UdtM6i6o8bsukBjjxARERERUegLCwPeeAPo0wcOl7lCAH37AhMnmu5HflO/fn25mxCy0tLS5G5CyHAV/FJbZl2oBfL8hcEvIiIiIiKqPeLjIbRa2+wvrZbZXgGihsLb1sXM1dBeMzW11Uypw/FcBYzUVqBfbe0NFga/iIiIiIiodqioAFasgMZohCY8HBg1CggPB4xGYMUK03ryKzUMv7KeQCE5OVnGlnhHjRk+qSqcTVUts2nGxsYiMjISSUlJcjdFkZT/TkRERERERKpXVlaG8ePHIzMzE1FRUWjQoAGeeOIJnDp1KniN2LwZKC4GWrYEtm8HPv7Y9H9mJlBUZFpPtY51pgxnyQsspWarWQcS7QO2aqmr1rBhQ7Ro0UKxfSw3Br+IiIiIiCigysvL0atXL0yePBnFxcUYNGgQGjZsiHnz5qFDhw44evRocBrSqhUwYwawYwfQpo1pWZs2wM6dpuWtWgWnHaQoERERqFevHho0aKCKTDU1U0P/htnV/VNDmwHHdpMtdfwViYiIiIhItaZMmYItW7agS5cuOHjwIL766its3boV06dPx4ULF/DEE08EpyGpqcDo0YBVjScApt9Hjzatp1qpXr16HC5Wi1kHjtRW4J48w+AXEREREREFTEVFBWbNmgUAyMnJsRmSM2bMGLRt2xY///wztm/fLlcTKUAiIiLkbkLICg8Pl7sJHlFLNpJ1dpf10FedTidHcygAGPwiIiIiIqKA2bRpE65evYpmzZqhQ4cODuuHDh0KAFi2bFmwm0YB1qBBA7mbELLUUjheLTXUrGt+qaUGHDPUvMPgFxERERERBczu3bsBAB07dpRcb16+Z8+eoLWJgiPGfngp+Y31DJVKFh0dbflZyceDdYZXeHi4JbCUmJgoU4vcU0shfqVQRw4iERERERGpUn5+PgAgIyNDcr15+fHjxyXX6/V66PV6y++FhYV+biEFiloKhauRWobjWQe8UlJSZGyJa9aBJK1Wi4yMDJSWltpkgSlNYmIirl69CgCIj4+XuTXKx3cjIiIiIiIKmOLiYgDOsz7Mw4qKiook10+dOhUJCQmWW8OGDQPTUPIL899HyVk+atWoUSMA6qn3BZiCShqNBlqt1qben9LUrVsXiYmJluM3OjoaycnJNsMhlcb6NcYhxu4x84uIiIiIiBRr7NixGDNmjOX3wsJCBsAULCEhAfHx8YoOGqhVfHw8WrduLXczvKLVatGqVSu5m+GWOdtLTXQ6naVv+Xpzj8EvIiIiIiIKGHO2R2lpqeT6kpISAHA6vCgyMpKFnVWGF+JEwcHXmuc47JGIiIiIiALGPFTr5MmTkuvNyxs3bhy0NhERUe3C4BcREREREQVMu3btAAA7duyQXG9e3rZt26C1iYiIahcGv4iIiIiIKGC6deuGhIQEHDlyBLt27XJYv3DhQgDAwIEDg9wyIiKqLRj8IiIiIiKigImIiMDzzz8PAMjOzrbU+AKAd999F3v27EGPHj1w0003ydVEIiIKcSx4T0REREREAfX6669j1apV2Lx5M1q0aIHu3bvj+PHj2Lp1K1JTUzF37ly5m0hERCGMmV9ERERERBRQUVFRWLt2LcaNG4eYmBgsXboUx48fx4gRI7Bjxw40bdpU7iYSEVEI0wghhNyNIN8UFhYiISEBV69eRXx8vNzNISIiUgx+RhKFLr6+iYhqB3++3zPzi4iIiIiIiIiIQhaDX0REREREREREFLJY8F7FzCNWCwsLZW4JERGRspg/G1ndgSj08ByYiKh28Of5HINfKlZUVAQAaNiwocwtISIiUqaioiIkJCTI3Qwi8iOeAxMR1S7+OJ9jwXsVMxqNOH36NOrUqQONRuPVtp06dUJubm6N21BYWIiGDRvixIkTfis46q+21YZ9+bv/lfgcA7E/9r98+/Ln/tj/8u1LDe/927ZtQ1FRERo0aACtllUeiEKJ1Dmwt+8hNXkf8/X9SunbsU8csU8csU8csU8c+atPhBB+O59j5peKabVaZGRk+LStTqfz6+w48fHxftufP9tWG/YF+K//lfwcldy2UO9/Jf8tAfa/XPsClP3en5CQwIwvohAldQ7s63uIL+9jvj6WWrZjnzhinzhinzhinzjyR5/463yOX4XWUtnZ2XI3wSl/tq027MuflPwcldw2f1Hqc1Ty39KflNpnSt2Xv9WW50lEgRHM172vj6WW7YL5WGrZLpiPpZbtgvlYatkumI+llu2U9Fgc9kg1UlhYiISEBFy9etWv2QTkGfa/vNj/8mL/y4d9T0Rqx/cxR+wTR+wTR+wTR+wTR0rsE2Z+UY1ERkZiwoQJiIyMlLsptRL7X17sf3mx/+XDviciteP7mCP2iSP2iSP2iSP2iSMl9gkzv4iIiIiIiIiIKGQx84uIiIiIiIiIiEIWg19ERERERERERBSyGPwiIiIiIiIiIqKQxeAXOdWzZ09oNBqntxUrVkhuN3/+fHTu3BlxcXFISkpC//79sXnz5iC3PrSVlZVh/PjxyMzMRFRUFBo0aIAnnngCp06dkrtpIW/dunUuXxe33nqr021PnjyJkSNHokGDBoiKikJmZiYmTJiA8vLyID4D5SspKcFnn32GF154AbfccgsiIyOh0WgwceJEt9v60sd8Pdnytf9dvS40Go3TvwH7n4iklJaWYunSpXjyySfRsmVLREVFITY2Fu3atcOkSZNQXFzsdFtfzkU3bdqE/v37IykpCXFxcejcuTMWLFjgcptgf64rvU98/RyoiWD1SbDPTWpC6X0SysfJ/v378a9//Qt33HEHUlJSEB4ejvT0dAwePBgbNmxw2cZQPU587ZOAHCeCyIkePXoIAGLIkCFi+PDhDrc9e/Y4bDN69GgBQERHR4tBgwaJvn37irCwMKHT6cSSJUuC/yRCUFlZmbj11lsFAFG/fn0xbNgw0blzZwFApKamiiNHjsjdxJC2du1aAUA0a9ZM8nUxadIkye0OHTokUlJSBADRunVrMWzYMNG0aVMBQHTr1k2Ul5cH+Zko186dOwUAh9uECRNcbudLH/P15MjX/gcgYmNjJV8Xw4cPFxUVFQ7bsP+JyJnZs2db3n9uvPFG8cADD4i+ffuKOnXqCADihhtuEOfOnXPYzpdz0YULFwqdTic0Go3o0aOHGDJkiEhMTBQAxMsvvyy5jRyf60rvE18+B2oqWH0SzHOTmlJ6n4TycXLdddcJACIuLk707t1bDBs2TLRu3VoAEBqNRrz33nuS7Qvl48TXPgnEccLgFzllDn4dO3bMo/uvXLlSABDJycni4MGDluWbN28WERERIjExUVy5ciUwja1F/vGPfwgAokuXLqKoqMiyfPr06QKA6NGjh3yNqwXMwa/hw4d7tV23bt0EAPHiiy9allVWVor777/foxOF2uTw4cPiySefFB999JHYvn27mDRpkkd95Esf8/XkyNf+ByAaN27s1WOx/4nImfnz54tRo0aJvLw8m+WnT58WHTp0EADEQw89ZLPOl3PRS5cuifj4eAFALFq0yLL87Nmzonnz5gKAWLt2rUP75PhcV3qf+PI5UFPB6pNgnpvUlNL7JJSPkzvvvFMsWLBAlJWV2Sz/6KOPBACh0+nE77//7tC+UD5OfO2TQBwnDH6RU94Gv+6++24BQDJ6++KLLwoAYtq0af5tZC2j1+tFQkKCACB27NjhsL5t27YCgPj1119laF3t4Evwa+vWrQKAqFevnsM3N2fPnhXh4eGibt26orKy0s+tDQ1Tp051+8HvSx/z9eQZT/pfCO9PUtj/ROSrzZs3CwAiMjJS6PV6y3JfzkX/9a9/CQBi0KBBDtssXrxYABD33HOPzXIlfq7L3SdCyBPUcMWffWIvUOcmgSZ3nwhRu44Ta3369BEAxMSJE22W17bjxJqzPhEiMMcJa36RX5SVlWHNmjUAgKFDhzqsNy9btmxZUNsVajZt2oSrV6+iWbNm6NChg8N69rMyLV++HAAwcOBAREZG2qxLS0tD9+7dceXKFWzcuFGO5oUEX/qYryd5sf+JyFft2rUDAOj1ely6dAmA7+ei5s8PqW0GDBiAqKgorFq1yqa+jBI/1+XuEyXyZ5/4ItSPk1ARrD4xP87p06dtltfm48RZnwRKWFAehVRtzpw5uHTpErRaLTIzM3HfffehUaNGNvc5cOAA9Ho9UlNTkZGR4bCPjh07AgD27NkTlDaHqt27dwO41p/22M/Bc+jQIYwdOxaXLl1CSkoKbrvtNvTr1w9areN3Cp783dasWYM9e/agZ8+egWx2yPKlj/l68r+SkhK8+eabyM/PR0xMDDp06IDBgwcjLi7O4b7sfyLy1dGjRwEA4eHhSEpKAuD7uair96KIiAi0bt0av/76Kw4ePIi2bdu63ca8PNif63L3iZk3nwOB5s8+8UWoHyc1URuPE/PjpKen2yyvzceJsz4x8/dxwuAXuTVlyhSb31955RWMGzcO48aNsyzLz88HAMkXAgDExsYiMTERV65cQVFREerUqRO4Bocwd/1sXn78+PGgtam22rx5s8OsJm3atMGiRYvQokULm+X8uwWeL33Mv4v/Xbx4Ea+//rrNsjFjxuDTTz/FgAEDbJaz/4nIVzNnzgQA9OvXz5Ip4cu5aGFhIa5evepyu4yMDPz66684fvy4JdCjxPcvufvEzJvPgUDzV5/4KpSPk5qqbcfJkSNH8N133wEA7r33Xpt1tfU4cdUnZv4+TjjskZy6/fbb8dlnn+HIkSMoLS3FgQMH8OabbyIsLAzjx4+3vCgAWKZCjYmJcbq/2NhYAEBRUVFgGx7C3PUz+zjwEhIS8Ne//hVbtmzBpUuXcOnSJaxevRq33norfvvtN/Tp08dy0mjGv1vg+dLH/Lv41+OPP44VK1bg1KlTKC4uxs6dO/HYY4/h0qVLGDx4MHJzc23uz/4nIl98//33mDNnDsLDwzF58mTLcl/ORc3buNpODZ8fSugTwPvPgUDyZ5/4KpSPk5qobcdJVVUVRowYAb1ejwcffBA33XSTzfraeJy46xMgMMcJM7/IqUmTJtn8npmZib///e+4+eab0bdvX0ycOBGjRo1CdHS0TC0k8t7999+Pffv2ebXNggUL0LlzZwBAhw4dHOoT9erVCxs3bsQdd9yBDRs24IMPPsDYsWP91ma1qWkfU83I1f+ffvqpze/t27fHggUL0LBhQ/zzn//E66+/jh9//LFGj0FEtdv+/fvx6KOPQgiBd955x1IvpjZTUp8o5XNASX2iFErqk9p2nLz44ovYuHEjmjZtig8++CAgj+EvSuqTQBwnDH6R1/r06YObb74Zv/76K7Zu3YqePXtaxt2WlpY63a6kpAQAOOSxBtz1M/vYvWPHjuHAgQNebePquDbT6XR47bXXsGHDBvz44482wa/a9ncLVB+74ksfh+rfRY7+d+XVV1/Fv/71L6xbtw4VFRWIiIgAELr9T0SBcerUKfTr1w9XrlzBmDFjMHr0aJv1vpyLWteNKS0tRXx8vNttPHmsYL1/KalPXHH2ORAIgegTX4XycRIIoXicvPnmm/jwww+RlpaGH3/80VI/y5vHCrXjxJM+caUmxwmHPZJPzDWNzpw5AwCWAvgnT56UvH9JSQkKCgpQt25dXsjUgLt+Ni9v3Lhx0NqkNrt27YIQwqubp8Ul7V8XZrXt7xbIPnbGlz4O1b+LHP3vSkJCAurVq4eKigrLjEFA6PY/Efnf5cuX0adPHxw/fhwjR47EtGnTHO7jy7lofHw8EhISXG6n1M8PpfWJK84+B/wtUH3iq1A+TgIh1I6Tjz76CK+//joSEhKwYsUKNG/eXPJ+tek48bRPXKnJccLgF/nkypUrAK6N623ZsiUiIyNx4cIFnDp1yuH+O3bsAACHopjkHXPqqbk/7bGf5WX/ujDj3y3wfOlj/l2Cw2g0orCwEIDta4P9T0SeKC4uxt133428vDwMHjwYs2fPhkajcbifr+eirt6LKisrsXfvXkRFRSEzM9OjbVw9lr8osU9ccfY54E+B7hNfhPpx4m+hdJz897//RXZ2NmJiYrB8+XK0b9/eaZtqy3HiTZ+4UpPjhMEv8tqFCxewYcMGANemNI2OjkavXr0AAN98843DNgsXLgQADBw4MEitDE3dunVDQkICjhw5gl27djmsZz/La9GiRQAcpyo2z0aybNky6PV6m3Xnzp3Dhg0bULduXXTr1i04DQ1BvvQxX0/BsWLFCpSUlKBZs2Y2w2fY/0Tkjl6vx6BBg7Bt2zb07dsXX375JXQ6neR9fT0XNX9+mNdb++6771BeXo7evXsjKirKYRs5PteV2ieuOPsc8Jdg9IkvQv048bdQOU6+//57PP744wgLC8OSJUvc/n1rw3HibZ+4UqPjRBBJ2LRpk1iyZImoqqqyWX7s2DHRrVs3AUDce++9NutWrlwpAIjk5GRx8OBBy/LNmzeLyMhIkZiYKK5cuRKM5oe0f/zjHwKA6Nq1qyguLrYsnz59ugAgevToIV/jaoH33ntP5Ofn2ywzGo3io48+EmFhYUKj0Yhff/3VYTvz62b06NGWZZWVlWLw4MECgJgwYUKAW65eU6dO9aiPfOljvp7c86T/v/zyS7Ft2zaH5evWrRMNGjQQAMS7777rsJ79T0TOVFVVifvvv18AEN27dxclJSVut/HlXPTSpUsiPj5eABCLFi2yLD937pxo3ry5ACDWrl3r8FhyfK4ruU98/RyoqWD1ib1AnpvUlJL7JNSPk40bN4ro6GgRFhYmlixZ4nH7Qvk48aVPAnWcaIQQwrtwGdUG8+fPx8iRI5Geno6OHTsiMTERx48fx/bt21FeXo5WrVphzZo1qFevns12L730EmbOnImYmBjcddddqKiowMqVKyGEwMKFC3HffffJ84RCSHl5OXr27ImtW7eifv366N69O44fP46tW7ciNTUVW7ZsQdOmTeVuZshq0qQJTp48iY4dO+L6669HeXk5fvvtNxw7dgxarRYzZ87E888/77DdoUOH0KVLF1y6dAlt2rRBVlYWcnNzcfToUXTt2hVr1qxBZGSkDM9Ime6//35L7bTTp0/jxIkTuO6665CRkQEAqF+/PpYsWWKzjS99zNeTNG/7f8SIEfj000+RmZmJVq1aITw8HAcPHrRkdP3pT3/C559/Dq3WNuGc/U9EzsycORMvvfQSANN7krNv+KdNm4aUlBTL776ciy5atAjDhg2z1EBMTk7GqlWrUFBQgDFjxmD69OkO28jxua7kPvH1c6CmgtknwTo3qSkl90moHyd169ZFQUEBrr/+etx+++2Sj3HbbbfhqaeeslkWyseJL30SsOPE63AZ1Qp5eXni2WefFR07dhSpqakiLCxMJCQkiFtvvVVMnz5dlJaWOt123rx54qabbhIxMTEiMTFR9OvXT2zatCmIrQ99paWlYty4caJZs2YiIiJCpKenixEjRogTJ07I3bSQ9/7774t77rlHXH/99SI2NlZERESIxo0bi0cffVTyGwpr+fn5YsSIESI9PV1ERESI5s2bi3HjxomysrIgtV49GjduLAA4vTVu3FhyO1/6mK8nR972//fffy8eeeQRccMNN4jExEQRFhYm6tWrJ+6++27xzTffuHws9j8RSZkwYYLL9yHz7dixYw7b+nIuunHjRtGvXz+RmJgoYmJixM033yzmz5/vcptgf64ruU9q8jlQE8Hsk2Cem9SEkvsk1I8TTx5j+PDhktuG6nHiS58E6jhh5hcREREREREREYUsFrwnIiIiIiIiIqKQxeAXERERERERERGFLAa/iIiIiIiIiIgoZDH4RUREREREREREIYvBLyIiIiIiIiIiClkMfhERERERERERUchi8IuIiIiIiIiIiEIWg19ERERERERERBSyGPwiIiIiIiIiIgDAH3/8AY1GA41Gg/nz58vdHCK/YPCLiIiIiIiIar1169ZZgj6e3l566SW5m01EHmDwi4jIDyoqKtCiRQtoNBosXLhQ7ubIJjs7GxqNBsOHD5e7KURERERERAAY/CIiP/n5559tvgXbvHmz221cfbsWExODhg0b4p577sHcuXOh1+uD1i5fzJw5E4cPH0br1q0xZMiQgDyGGrz22muIiIjAZ599hu3bt8vdHCIiIiKfPPvss/jtt9/c3v72t7/J3VQi8kCY3A0gotDw6aef2vy+YMECdO3a1ef9lZWV4eTJkzh58iSWL1+Od999F9999x2aNGkia7ukFBUV4V//+hcA4PXXX4dGo/Hr/tWkUaNGGD58OGbPno1x48bh+++/l7tJRERERF6rV68eWrduLXcziMhPmPlFRDVWVlbmMNTv66+/9ipby/7btdWrV2PmzJnIyMgAAPz++++49957YTAYfGpXXFycT+3yxIcffohLly6hUaNGeOCBB/y6bzV6+eWXAQA//PADs7+IiIiIiEh2DH4RUY0tWbIERUVFAIAnn3wSAHDlyhUsW7bM432Yv10z33r16oUXX3wReXl5lmyv3377DUuWLPGpXe+//75P7XLHYDBg1qxZAICHHnoIWi3fVlu2bImOHTsCAP7973/L3BoiIiKi4GnSpAk0Gg1GjBgBAMjNzcVDDz2Ehg0bIioqCg0bNsTIkSOxf/9+j/a3bNkyDB06FBkZGYiMjERycjK6dOmCt956C8XFxR7tY+/evXjhhRfQpk0b1K1bF+Hh4UhPT0fv3r3x9ttv48yZM273sXLlSgwcOBDp6emIjIzE9ddfj2effRYnT570qA1EcuNVGhHV2IIFCwAAqampmDFjBhISEmyW10SdOnXw+uuvW35ftWqV1+1q27YtRo4ciZYtW/qtXWYrV67EiRMnAACPPPKI3/ardua++OabbywBSCIiIqLaZO7cuejatSv++9//4uTJk9Dr9Th58iTmz5+P9u3b45tvvnG6bXl5OQYPHox7770XixYtwqlTp1BRUYHLly9jy5YtGDt2LFq2bIldu3Y53YfBYMCYMWPQtm1bzJo1C3v37kVBQQGqqqpw7tw5rF69Gq+99hrGjh3r8nmMHTsWffr0wXfffYdz586hoqICf/zxBz766CN07NgR+/bt87WLiIKGwS8iqpEzZ85YAlIPPPAA4uLiMHToUADAihUrcOHChRo/Rps2bSw/mwNN3rTr0UcftfnfX+0CTMMoAaBFixY27bQ2ceJES8F9ACgsLMTEiRPRpk0bxMXFoV69eujfv79DMf7z58/j9ddfR6tWrRAbG4vk5GQMGjQIO3fudNmmvXv3YsqUKejbt6/lW8K4uDi0aNECw4cPx5YtW9w+r9OnT+Nvf/sbOnbsiISEBISHhyMtLQ1t2rTBQw89hPnz56OwsNDp9uai/6Wlpfj222/dPh4RERFRKNm1axeeeeYZ1KtXD//+97+xdetW/Pzzz3jttdcQGRkJvV6PRx55BL/++qvk9sOHD7eMeGjXrh0WLFiA3Nxc/Pjjjxg5ciQ0Gg1Onz6NO++8E6dOnZLcx6hRo/Dee+9BCIH69evjzTffxNq1a7Fjxw78+OOPmDx5Mtq1a+fyecyePRtvvfUWevTogS+++AK//vorVq1ahccffxwAcOHCBTzxxBM16CmiIBFERDXwzjvvCAACgNi4caMQQog1a9ZYls2cOdPptmvXrrXcb8KECU7vt3PnTsv9Bg0a5FW7tFqtOHnypBBCiKNHjwqNRuO2Xd5o0qSJACAee+wxp/eZMGGCpf35+fkiMzPT8rv1TafTia+//loIIcTu3bvFddddJ3m/yMhIsWbNGsnHsu5TV7e//e1vTtu7fv16ER8f73Yfy5Ytc9k36enpAoB4+OGHPehJIiIiInlZn0c9++yz4rfffnN7q6iosNlH48aNLfto3LixOHPmjMPjrFmzRoSFhQkAolOnTg7rv/vuO8s+7rzzTqHX6x3u83//93+W+wwbNsxh/bfffmtZ36VLF3HlyhWnzzs/P9/m92PHjtmc8z399NPCaDQ6bPfUU09Z7rNjxw6n+ydSAmZ+EVGNfPbZZwBM9Q3Msyj26NED1113HQD/DDG0TqX2dLZHc7t69uxpacv1119vaaM/2nXy5En88ccfAIBOnTp5tM0DDzyAkydPYuzYsfj555+Rm5uL9957D/Hx8TAYDHjyySdx7Ngx3HPPPSgrK8Obb76JjRs3YuvWrXjjjTcQEREBvV6PESNGoKKiwmH/VVVViI2NxbBhw/DRRx9h3bp12LFjB1asWIHp06ejcePGAIC33noL8+bNc9her9fjT3/6EwoLC1GnTh28+uqrlsL1v/zyC7744gs8//zzlj51pXPnzgCAn3/+2aO+ISIiIlKKDz/8EG3atHF7c5Z1BQDTp09Henq6w/I77rgDTz/9NABTTTD77K+cnBwAQHh4OObNm4eIiAiHfTz99NPo3bs3AGDx4sUOdbveeustAEBMTAwWLlyIxMREp+1s2LCh03X169fHv//9b8nZzF955RXLzxs2bHC6DyJFkDv6RkTqZZ2RNXbsWJt1L7/8smXd77//Lrm9J5lfVVVVokOHDpb7bdiwwat2zZ0712bdhx9+6LZdnvrqq688apd15ldkZKTYsmWLw32sv+FLTU0VKSkp4vDhww73y8nJsdxv8eLFDusvXLjg8ps9vV4v7rrrLsu3kVVVVTbrV69e7VFmV2Vlpbh69arT9UII8cYbb1j2dfbsWZf3JSIiIpKbpxn01rdjx47Z7MOc+VW3bl1RWVnp9LFyc3Mt+5g6dapleWVlpYiJiREAxIABA1y21/pc9IsvvrAsv3jxomW0w8iRI73uB+vMrxdeeMHlfePi4gQAMXr0aK8fhyiYmPlFRD6zzp6yL/Zu/bsvWVYXLlzAmjVr0KNHD0uNq6FDh+K2227zuF3R0dGW2lNmw4YNs3x7VtPsL+vZberVq+fRNi+99BJuueUWh+UDBgywZGVduHABkydPRrNmzRzuN3LkSERFRQGQ/oYtJSXF5Td7EREReOeddwAAx48fdyiSevbsWcvPt99+u9P9hIWFIT4+3ul6wLZPjh496vK+REREREoyYcIECCHc3pyNSujQoQPCwsKc7r99+/aWc9LffvvNsvzo0aMoLS0FAMlzRmvW6/fu3Wv5edeuXRBCAAC6d+/u+om6ccMNN7hcX7duXQDgBEekeAx+EZFPqqqq8MUXXwAwzabYqlUrm/UdOnTAjTfeCAD4/PPPYTQaXe7vjTfesBSF12g0qFevHu68805s2rQJMTExGDNmjOXxPG3XwIEDHQI0SUlJ6N+/v8ftcsW6aL75g9+dP/3pT07XtW3bFgCg0Wjw4IMPSt4nOjoaLVq0AOBZQEmv1yM/Px95eXnYu3cv9u7dazkZAoDdu3fb3L9+/fqWn6WGRXojKSnJ8rN1UI2IiIgo1Ln7YjQsLMxyrnT58mXLcuuf3e3Dekil9XYXL160/Gx9bueLmJgYl+u1WlNIwWAw1OhxiAKNwS8i8smPP/6Ic+fOAXDM+jIzLz958iTWrl3r82O1b98eL774IsLDw71ql3l2R3vm5TVtl/VJhqfBr8zMTKfrzBlbKSkpLvdnvp+zb9hKSkr+v737i6m6/uM4/uSvh2mtgbgdY8CsrOHBA5JwljiZZbEpKSRs5ZApbkWxLlzNSRdd2OCm5VwzpAWRMEUoSJE2cbkgMBElEq1mY1IpbY5CV8mRjvC7YHx/B+EczjlS6PH12Ni+O9/P93Pe33PF3p/35/2hpKQEq9XK3LlziYmJYcmSJUZvisTERGOs8z9HAKmpqSxatAgYq1JLTk6mpKSE9vb2KXuMueP8Dn///bdXz4qIiIjcy6bqkTUbc4jIGCW/RMQn41sGAwICePHFF6cc89JLL00a70pBQQE9PT309PTw7bff0tjYSF5eHoGBgZw8eZK0tLQJlVbTxRUREUF6evqUY9atW2ckkO5k6+P49kOAoaEhj55xt3o2vnJ2JytsfX19xMfHU1RUxLlz56Zdhbs97pCQEBobG42qvc7OToqKikhNTeWhhx4iPT2dAwcOeLS65zy3J4lLEREREX8xvhjrisPhMBZSnavlna+nm8O5st75ufnz5xvXtzfCF7lfKfklIl67fv06R44cAcYqhVydEON8umJ9fb3b6p8FCxZgsViwWCwkJCSwbt06KisrqaioAMaSOtu2bfM4rt9//53Q0NAJWynH/0wmE9euXfMoLnciIyONa+cqsNmUm5vLpUuXCAgIYOvWrTQ3N/Prr79it9sZGRlhdHR0QuLKeQvkuLi4OHp6emhoaGDr1q08+uijwFgy69ixY2zatImUlBSuXr3qNhbn38RdHzIRERERf9Pd3Y3D4XB5/7vvvjOq6i0Wi/H5okWLjIXQjo4Ot99x+vRp49p5jsTERKNqrLW11fvgRfyQkl8i4rXa2lrsdjvgesvjuPH7f/31F/X19V5/V15entG0/siRI5w4ccKjuDzla1wwMfk1ODjo0xwz6ccff6StrQ2AoqIiysvLWbNmDVFRUcyZM8f4J8iTRF1QUBAbNmygvLycn376if7+fioqKkhKSgLg7NmzvPzyy27ncP5NoqOjfX0tERERkXvOH3/8QWNjo8v74wu8AM8884xxHRwczKpVqwA4fvz4hAOWbvfRRx8Zz6SlpRmfh4eHGwvQtbW19Pf3+/QOIv5EyS8R8dr4VsGQkBCys7Pdjs3JyTFOuvF1i2FxcTFBQUHAWFJnurjMZjMHDx6c9i8qKuqO4oqPjzeuL1686NMcM+nChQvGtauG+QBnzpzxem6z2cyWLVv45ptvWLZsGQBHjx51u91z/DeZM2eOUT0mIiIicr/Yvn37lFsXW1pa+PDDDwFISkpi+fLlE+6/9tprAAwPD5Ofn88///wzaY6Kigqam5sByMrKmtTYfseOHQDcuHGD7Oxsrl+/7jJOdwk2EX/h+uxVEZEpXLp0ifb2dgDS09Mn9BeYyvz583nuuedoamrixIkTXLlyhYcfftir71y8eDE5OTkcPHiQjo4Ojh8/zpo1a1zG9cILL7g9VXHcqVOn2LNnj89xPfnkk5hMJux2O52dneTk5Hj1/ExzLq13t5Vz3759Pn9HSEgIq1atoqurC4fDwbVr1wgLC5tybGdnJzBWeq+eXyIiInIvuXr1KufPn592XFhYGI888sikz61WK99//z1JSUns3LmT5ORkbt68yRdffMHu3btxOBwEBwezd+/eSc+uXbuW7Oxs6urqaG5uxmazsX37dp544gkGBwepqakxKsfCw8N57733Js2RkZFBfn4+5eXlnDx5kri4OAoLC1mxYgUPPvggAwMDnDlzhkOHDmG1WqmsrPT+RxK5hyj5JSJe2b9/v9EnyrmhvTubNm2iqamJkZERqqurjZUobxQVFVFTU8Po6CjvvPPOpOSXc1wbN270aM6NGzeyZ88en+MKDQ0lJSWFlpaWCT0XZstjjz1mXFdWVmKz2SaNKS0t5fDhwy7n+PrrrzGbzS4rtYaHh2lpaQFg3rx5E7Z+Ort58ybnzp0D4Nlnn/X4HURERETuBqWlpZSWlk47zmq10t3dPenzhIQECgsLKSgooLCwcNL90NBQPvnkE1JSUqacd//+/TgcDhoaGujq6pryFPOFCxfS1NTkcgG3rKyMsLAw9u7dS39/v8sdFFar1c0bivgHJb9ExCtVVVXA2CmPN27coKamZtpnhoaGCAgIYHR0lKqqKp+SXxaLheeff57Dhw/T2tpKW1sbqampk+JasGABK1eu9GjOp556CrPZzG+//eZzXOvXrzeSX3/++ScPPPCA13PMlMTERCwWC+fPn6esrIzBwUFyc3Mxm81cvnyZ6upqPv30U1asWGFUyd3uyy+/ZNeuXaxcuZK1a9eydOlSIiMjGRoa4uLFi+zbt4+uri4A8vPzjS2tt2ttbTVK9DMzM/+dFxYRERG5i23btg2LxcLu3btpa2tjYGCAyMhInn76aXbs2EFcXJzLZ00mE/X19TQ2NlJZWcmpU6cYGBhg7ty5LF68mA0bNlBYWMi8efNczhEUFMT777/Pli1bKCsr46uvvuLKlSsMDw8TERHB0qVLSU9PJzc39994fZG7ipJfIuKx9vZ2ent7gbFTAvPz872e48KFC5w9e9ZonO6Nt956y6ha2rVrF8eOHZsUV2ZmJoGBnrUzDAwMJDMzkw8++MDnuDZv3szOnTux2+00NDSwefNmr56fSQEBAVRVVbF69WoGBwepra2ltrZ2wpj4+Hjq6upYuHChy3lGRkZoaWkxKrymsn79ekpKSlzeP3DgAABLliwhISHBuxcRERERmQVpaWlTnoR9J2w2G4cOHfL5+YyMDDIyMu4ohmXLllFWVubx+NjYWI9/h76+Ph+jEvlvqeG9iHjM18bwMzXP8uXLje2Ozc3NRk8p5/nGT4b0lPN4X+KKiIggKysL+H/CZzYlJCTQ3d3NK6+8QkxMDCEhIYSHh5OcnMy7777L6dOnJzVEdfbGG2/w2WefUVBQgM1mIzo6GpPJhMlkIjY2lpycHI4ePcrnn3/usteX3W43TtB89dVX/5X3FBERERER8VTA6EyntkVE7jMdHR3YbDaCgoLo7e0lJiZmtkOaVdXV1eTm5hIREUFfX5/bcnwRERERfxIbG8vPP/9MXl6emsiL3EVU+SUicodSUlLIysri1q1bbrcC3g9GRkYoLi4G4M0331TiS0REREREZp2SXyIiM6C4uJjg4GA+/vhjLl++PNvhzJq6ujp++OEHoqOjef3112c7HBERERERETW8FxGZCY8//jgVFRX09vbyyy+/EBUVNdshzYpbt27x9ttvs3r1apc9wURERERERP5L6vklIiIiIiIiIiJ+S9seRURERERERETEbyn5JSIiIiIiIiIifkvJLxERERERERER8VtKfomIiIiIiIiIiN9S8ktERERERERERPyWkl8iIiIiIiIiIuK3lPwSERERERERERG/peSXiIiIiIiIiIj4LSW/RERERERERETEbyn5JSIiIiIiIiIifut/9xNq7T2KWTkAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -463,7 +588,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 54, "metadata": {}, "outputs": [], "source": [ @@ -481,7 +606,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -499,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 56, "metadata": { "tags": [] }, @@ -508,8 +633,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "orbits array dimensions: (2812, 8)\n", - "orbital elements for first orbit: [ 2.31187088 0.50436102 0.81617422 0.80350192 0.80036463 0.87742062\n", + "orbits array dimensions: (7867, 8)\n", + "orbital elements for first orbit: [ 2.29155763 0.49614047 1.04955172 3.89938158 3.94543876 0.79254779\n", " 60. 1.2 ]\n" ] } @@ -531,34 +656,6 @@ "source": [ "And now we can easily work with the saved orbits that were generated by ``orbitize!`` Find out more about generating orbits in ``orbitize!`` with tutorials [here](https://orbitize.readthedocs.io/en/latest/tutorials.html)." ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Nautilus API documentation ##" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Nautilus Sampler" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 66960e31cf977c968ec45d6294f30808d1976d36 Mon Sep 17 00:00:00 2001 From: quintoon Date: Wed, 27 May 2026 10:19:17 -0700 Subject: [PATCH 27/43] Remove visulizations. --- visualizations | 1 - 1 file changed, 1 deletion(-) delete mode 160000 visualizations diff --git a/visualizations b/visualizations deleted file mode 160000 index 14fef5ac..00000000 --- a/visualizations +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 14fef5ac189a1271a45c5f640a7af6a1905a9a09 From 99a8e51cac77c83ebd2cf5bf36be4e2568492ec2 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 2 Jun 2026 15:43:12 -0700 Subject: [PATCH 28/43] Add nautilus to pyproject.toml --- pyproject.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 1e7ec9b6..2698bd55 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,8 @@ dependencies = [ "rebound", "dynesty", "pymultinest", - "tk" + "tk", + "nautilus-sampler" ] [tool.setuptools.dynamic] From 969a15bf5a07ee7af4d2ac23f41085fe83c95835 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 2 Jun 2026 15:44:58 -0700 Subject: [PATCH 29/43] Add BaseNestedSampler and document Nautilus --- orbitize/sampler.py | 142 +++++++++++++++++++++++++++----------------- 1 file changed, 89 insertions(+), 53 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index fc535409..55758df9 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1312,7 +1312,29 @@ def check_prior_support(self): return -class NestedSampler(Sampler): +class BaseNestedSampler(Sampler): + def ptform(self, u): + """ + Prior transform function. + + Args: + u (array of floats): list of samples with values 0 < u < 1. + + Returns: + numpy array of floats: u samples transformed to a chosen Prior + Class distribution. + """ + utform = np.zeros(len(u)) + for i in range(len(u)): + if hasattr(self.system.sys_priors[i], 'transform_samples'): + utform[i] = self.system.sys_priors[i].transform_samples(u[i]) + else: + # prior is a fixed number + utform[i] = self.system.sys_priors[i] + return utform + + +class NestedSampler(BaseNestedSampler): """ Implements nested sampling using the Dynesty package. @@ -1355,26 +1377,6 @@ def __init__(self, self.start = time.time() self.dynesty_sampler = None - def ptform(self, u): - """ - Prior transform function. - - Args: - u (array of floats): list of samples with values 0 < u < 1. - - Returns: - numpy array of floats: 1D u samples transformed to a chosen Prior - Class distribution. - """ - utform = np.zeros(len(u)) - for i in range(len(u)): - if hasattr(self.system.sys_priors[i], 'transform_samples'): - utform[i] = self.system.sys_priors[i].transform_samples(u[i]) - else: - # prior is a fixed number - utform[i] = self.system.sys_priors[i] - return utform - def run_sampler( self, nlive=500, @@ -1680,8 +1682,36 @@ def _loglike_multinest(param_cube, n_dim, n_param): return post_samples[:, :-1] class NautilusSampler(Sampler): - def __init__(self, system): - super(NautilusSampler, self).__init__(system) + """ + Implements nested sampling using the Nautilus-Sampler package. + + Args: + system (system.System): system.System object + chi2_type (str, optional): either "standard", or "log" + like (str): name of likelihood function in ``lnlike.py`` + custom_lnlike (func): ability to include an addition custom likelihood + function in the fit. The function looks like + ``clnlikes = custon_lnlike(params)`` where ``params`` is a RxM array + of fitting parameters, where R is the number of orbital paramters + (can be passed in system.compute_model()), and M is the number of + orbits we need model predictions for. It returns ``clnlikes`` + which is an array of length M, or it can be a single float if M = 1. + + Thea McKenna, Sarah Blunt, & Lea Hirsch 2024 + """ + def __init__(self, + system, + chi2_type, + like, + custom_lnlike + ): + + super(MultiNest, self).__init__( + system, + like=like, + chi2_type=chi2_type, + custom_lnlike=custom_lnlike, + ) # create an empty results object self.results = orbitize.results.Results( @@ -1693,41 +1723,47 @@ def __init__(self, system): ) self.start = time.time() - def ptform(self, u): - """ - Prior transform function. - - Args: - u (np.array of floats): MxR array of uniform - samples with values 0 < u < 1, - where M is the number of orbits, - and R is the number of parameters. - - Returns: - numpy MxR array of floats: u samples transformed to - a chosen Prior Class distribution. - """ - utform = np.zeros(u.shape) - for i in range(u.shape[1]): - try: - utform[:, i] = self.system.sys_priors[i].transform_samples(u[:, i]) - except AttributeError: # prior is a fixed number - utform[:, i] = self.system.sys_priors[i] - return utform + def nautilus_ptform(self, u): + return self.ptform(u.T).T def nautilus_logl(self, u: np.ndarray): return self._logl(u.T).T def run_sampler( - self, - n_live: int = 2000, - n_update: int = None, - verbose: bool = False, - num_threads: int = 1, - savefile: str = None, - sampler_kwargs: dict = {}, - run_kwargs: dict = {} - ): + self, + n_live = 2000, + n_update = None, + verbose = False, + num_threads = 1, + savefile = None, + sampler_kwargs = {}, + run_kwargs = {} + ): + """Runs the nested sampler from the Dynesty package. + + Args: + n_live (int): Number of live points. A larger numbers results + in a more finely sampled posterior and a more accurate + evidence, but also a larger number of iterations is + required to converge (default: 2000). + n_update (int): Number of points added to the live set before + creating a new shell. When None defaults to `n_live` (default: None). + verbose (bool): Print progress when running sampler (default: False). + num_threads (int, tuple, pool): number of threads to use for parallelization. + If a tuple of two integers, the number of threads for + likelihood evaluations and sampler calculations respectively. If a thread + pool, the pool used for parallelization (default=1). + savefile (str): File used by Nautilus to save progress. + If file already exists, resumes from saved progress. + sampler_kwargs (dict): dictionary of keywords to be passed into nautilus.Sampler, + such as `periodic` + run_kwargs (dict): dictionary of keywords to be passed into nautilus.Sampler.run, + such as `n_eff` + + + Returns: + numpy.array of float: equal-weighted posterior samples + """ if sys.version_info < (3,9,0) and isinstance(num_threads, int) and num_threads > 1: with Pool(processes=num_threads) as pool: self.naut_sampler = nautilus.Sampler( From 0e6e5c8325005ac73bea38958bea1d87b07b2fda Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 2 Jun 2026 16:05:44 -0700 Subject: [PATCH 30/43] Document changes to results.py --- orbitize/results.py | 46 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 41 insertions(+), 5 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index 32e47e33..c42cd6d6 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -27,6 +27,15 @@ class Results(object): data (astropy.table.Table): output from ``orbitize.read_input.read_file()`` curr_pos (np.array of float): for MCMC only. A multi-D array of the current walker positions that is used for restarting a MCMC sampler. + weighted_post (np.array of float): RxN array of orbital parameters + (posterior output from weighted orbit-fitting process), where R is the + number of orbits generated, and N is the number of varying orbital + parameters in the fit (default: None). + weighted_lnlike (np.array of float): R array of log-likelihoods corresponding to + the orbits described in ``weighted_post`` (default: None). + lnweights (np.array of float): R array of log-weights corresponding to the orbits + and log-likelihoods described in ``weighted_post`` and ``weighted_lnlike`` (default: None) + Written: Henry Ngo, Sarah Blunt, 2018 @@ -35,7 +44,7 @@ class Results(object): def __init__( self, system=None, sampler_name=None, post=None, lnlike=None, - version_number=None, curr_pos=None, weighted_post = None, weighted_lnlike = None, lnweight = None + version_number=None, curr_pos=None, weighted_post=None, weighted_lnlike=None, lnweight=None ): self.system = system @@ -62,32 +71,56 @@ def __init__( @property def weighted_post(self): + """ + Returns the weighted posterior if it exists, + otherwise returns the unweighted posterior. + """ if self._weighted_post is not None: return self._weighted_post return self.post @property def weighted_lnlike(self): + """ + Returns the weighted log-likelihoods if it exists, + otherwise returns the unweighted log-likelihoods. + """ if self._weighted_lnlike is not None: return self._weighted_lnlike return self.lnlike @property def weights(self): + """ + Returns the weights of ``weighted_post`` and ``weighted_lnlike`` + if it exists, otherwise returns None. + """ if self.lnweight is None: return None return np.exp(self.lnweight) - def downsample(self, amount, duplicates = True): + def downsample(self, amount, duplicates=True): """ - Samples from the posterior an amount of times. If the posterior - is weighted, samples proportionally to weight to get an equal-weighted posterior. + Samples from the posterior, or the weighted posterior if it exists. + + Args: + amount (int): number of samples to draw from the posetrior + duplicates (bool): whether to replace sampled orbits from the posterior, + which may cause duplicate samples (default: True) + + Returns: + tuple: + + numpy.array of float: orbital parameters of the samples (``amount``xN, where N is number of varying orbital parameters) + + numpy.array of float: log-likelihoods of the samples (length ``amount``) + """ indexes = np.random.choice(len(self.weighted_post), amount, duplicates, self.weights) return self.weighted_post[indexes], self.weighted_lnlike[indexes] - def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post = None, weighted_lnlike = None, lnweight = None): + def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post=None, weighted_lnlike=None, lnweight=None): """ Add accepted orbits, their likelihoods, and the orbitize version number to the results @@ -502,6 +535,9 @@ def plot_propermotion(self, ) def array_not_none(raw): + """ + Returns a numpy.array of the input if it is not None, else returns None + """ if raw is not None: return np.array(raw) return raw From 9f611cc8f4d779dafdd80c18b57f2788027b0c27 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 2 Jun 2026 16:25:38 -0700 Subject: [PATCH 31/43] Standardize load_results with array_not_none --- orbitize/results.py | 31 ++++++++++++------------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/orbitize/results.py b/orbitize/results.py index c42cd6d6..b55a4024 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -131,6 +131,12 @@ def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post=None lnlike (np.array): add corresponding lnlike values to results curr_pos (np.array of float): for MCMC only. A multi-D array of the current walker positions + weighted_post (np.array): for Nautilus only. Sets of orbital params + associated with ``lnweight`` to add to results. + weighted_lnlike (np.array): for Nautilus only. Corresponding weighted lnlike + values for ``weighted_post`` to add to results. + weighted_post (np.array): for Nautilus only. Log of weights associated + with ``weighted_post`` and ``weighted_lnlike``. Written: Henry Ngo, 2018 @@ -239,21 +245,11 @@ def load_results(self, filename, append=False): else: version_number = "<= 1.13" - try: - weighted_post = array_not_none(hf.get('weighted_post')) - weighted_lnlike = array_not_none(hf.get('weighted_lnlike')) - lnweight = array_not_none(hf.get("lnweight")) - except KeyError: - weighted_post = None - weighted_lnlike = None - lnweight = None - - post = hf.get('post') - if post is not None: - post = np.array(post) - lnlike = hf.get('lnlike') - if lnlike is not None: - lnlike = np.array(lnlike) + post = array_not_none(hf.get('post')) + lnlike = array_not_none(hf.get('lnlike')) + weighted_post = array_not_none(hf.get('weighted_post')) + weighted_lnlike = array_not_none(hf.get('weighted_lnlike')) + lnweight = array_not_none(hf.get("lnweight")) if 'num_secondary_bodies' in hf.attrs: num_secondary_bodies = int(hf.attrs['num_secondary_bodies']) @@ -375,10 +371,7 @@ def load_results(self, filename, append=False): if 'ln_evidence_err' in hf.attrs: self.ln_evidence_err = hf.attrs['ln_evidence_err'] - try: - curr_pos = np.array(hf.get('curr_pos')) - except KeyError: - curr_pos = None + curr_pos = array_not_none(hf.get('curr_pos')) hf.close() # Closes file object From 963f7194cff4bc9fc209ca395ffa46e925808d3e Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 2 Jun 2026 16:39:36 -0700 Subject: [PATCH 32/43] Fix misconfigured ptform and initialization of Nautilus --- orbitize/sampler.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 55758df9..caba0ca4 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1324,8 +1324,8 @@ def ptform(self, u): numpy array of floats: u samples transformed to a chosen Prior Class distribution. """ - utform = np.zeros(len(u)) - for i in range(len(u)): + utform = np.zeros(u.shape) + for i in range(u.shape[0]): if hasattr(self.system.sys_priors[i], 'transform_samples'): utform[i] = self.system.sys_priors[i].transform_samples(u[i]) else: @@ -1681,7 +1681,7 @@ def _loglike_multinest(param_cube, n_dim, n_param): return post_samples[:, :-1] -class NautilusSampler(Sampler): +class NautilusSampler(BaseNestedSampler): """ Implements nested sampling using the Nautilus-Sampler package. @@ -1701,12 +1701,11 @@ class NautilusSampler(Sampler): """ def __init__(self, system, - chi2_type, - like, - custom_lnlike + chi2_type="standard", + like="chi2_lnlike", + custom_lnlike=None, ): - - super(MultiNest, self).__init__( + super(NautilusSampler, self).__init__( system, like=like, chi2_type=chi2_type, @@ -1767,7 +1766,7 @@ def run_sampler( if sys.version_info < (3,9,0) and isinstance(num_threads, int) and num_threads > 1: with Pool(processes=num_threads) as pool: self.naut_sampler = nautilus.Sampler( - prior=self.ptform, + prior=self.nautilus_ptform, likelihood=self.nautilus_logl, n_dim=len(self.system.sys_priors), vectorized=True, @@ -1784,7 +1783,7 @@ def run_sampler( ) else: self.naut_sampler = nautilus.Sampler( - prior=self.ptform, + prior=self.nautilus_ptform, likelihood=self.nautilus_logl, n_dim=len(self.system.sys_priors), vectorized=True, From f071dac6778f74eeda81120ca60ff2565247c59d Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 2 Jun 2026 16:46:08 -0700 Subject: [PATCH 33/43] Fix mp.Pool import --- orbitize/sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index caba0ca4..16463ac7 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1764,7 +1764,7 @@ def run_sampler( numpy.array of float: equal-weighted posterior samples """ if sys.version_info < (3,9,0) and isinstance(num_threads, int) and num_threads > 1: - with Pool(processes=num_threads) as pool: + with mp.Pool(processes=num_threads) as pool: self.naut_sampler = nautilus.Sampler( prior=self.nautilus_ptform, likelihood=self.nautilus_logl, From 71953116d5a0909f7567404ba10b36cb98597dde Mon Sep 17 00:00:00 2001 From: Aniruddh Date: Wed, 3 Jun 2026 11:20:11 -0700 Subject: [PATCH 34/43] added more on weights, faster plot params and fixed language --- docs/tutorials/Nautilus_tutorial.ipynb | 116 ++++++++++++------------- 1 file changed, 57 insertions(+), 59 deletions(-) diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb index 5c721b32..80529fd1 100644 --- a/docs/tutorials/Nautilus_tutorial.ipynb +++ b/docs/tutorials/Nautilus_tutorial.ipynb @@ -6,14 +6,14 @@ "source": [ "# Nautilus Introduction #\n", "\n", - "by some fellas\n", + "by Quinn Blackstone, Aniruddh Chalagulla, Eshel Dror and Niklas Naworal (2026)\n", "\n", - "This is a tutorial for using the Nautilus sampler in `orbitize`! ([Paper here](https://google.com))" + "This is a tutorial for using the [Nautilus](https://arxiv.org/abs/2306.16923) sampler in `orbitize`!" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": { "tags": [] }, @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": { "tags": [] }, @@ -111,8 +111,8 @@ " 95, # orbital fraction, how much of the orbit is covered (0-100%)\n", " 1.2, # mass of the system\n", " 60, # paralax\n", - " 0.5, # eccentricity, default is 0.5 (float)\n", - " np.pi/3, # inclination, default is π/4 (float)\n", + " 0.1, # eccentricity, default is 0.5 (float)\n", + " np.pi/6, # inclination, default is π/4 (float)\n", " unc=2, # uncertainty, default is 2 (int)\n", " num_obs=30, # number of observations to be made, default is 4 (int)\n", ")" @@ -120,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": { "tags": [] }, @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": { "tags": [] }, @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": { "tags": [] }, @@ -167,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -177,16 +177,20 @@ "Starting the nautilus sampler...\n", "Please report issues at github.com/johannesulf/nautilus.\n", "Status | Bounds | Ellipses | Networks | Calls | f_live | N_eff | log Z \n", - "Finished | 57 | 1 | 8 | 221600 | N/A | 17688 | -150.98 \n" + "Finished | 52 | 1 | 4 | 71928 | N/A | 4316 | -157.59 \n" ] } ], "source": [ - "sampler_arg = {\"n_networks\": 4} # number of active networks you want, default is 4 \n", - "run_arg = {\"f_live\": 0.01, \"n_eff\": 10000} # f_live is the fraction of the evidence in the live set and n_eff is the total effective sample size\n", + "sampler_arg = {\n", + " \"n_networks\": 4, # number of active networks you want, default is 4\n", + " \"n_batch\": None, # the number of likelyhood evaluations per step, default is none (int) \n", + " }\n", + "run_arg = {\"f_live\": 0.01, \"n_eff\": 1000} # f_live is the fraction of the evidence in the live set and n_eff is the total effective sample size\n", "samples = mysampler.run_sampler(\n", - " n_live=2000, # the number of live points you have, default is 2000 (int)\n", - " num_threads=4, # the number of threads you want to utilize, default is 1 (int)\n", + " n_live=500, # the number of live points you have, default is 2000 (int)\n", + " num_threads=12, # the number of threads you want to utilize, default is 1 (int)\n", + " n_update=None, # the number additions to the live set before a new bound is made, default is none (int)\n", " verbose=True, # choose wether or not to see live updates of the sampler, default is false (bool)\n", " savefile = None, # put the name for a file that you want to create / already exists here to save nautilus progress, default is none (str)\n", " sampler_kwargs = sampler_arg,\n", @@ -221,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -237,7 +241,7 @@ " 'mtot': np.int64(7)}" ] }, - "execution_count": 20, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -255,12 +259,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -289,12 +293,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -336,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -355,21 +359,25 @@ "metadata": {}, "source": [ "What is the difference between post and weighted post?\n", - "Weighted results are results that are well, weighted. They can be used in cornerplots for example, to get better convergence. There are cases where non weighted results are better or are the only type accepted." + "Weighted results are results that are well, weighted. They can be used in cornerplots for example, to get better convergence. There are cases where non weighted results are better or are the only type accepted.\n", + "\n", + "myResults.weighted_post returns weighted posteriors if it exists, and unweighted if it does not. \n", + "myResults.post is always unweighted. The same goes for lnlike.\n", + "Weight can be acquired from myResults.weight" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(7867, 8)" + "(1972, 8)" ] }, - "execution_count": 41, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -380,16 +388,16 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(219590, 8)" + "(71195, 8)" ] }, - "execution_count": 42, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -407,7 +415,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -416,7 +424,7 @@ "((150000, 8), (150000,))" ] }, - "execution_count": 49, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -440,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -450,7 +458,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[51], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m post, lnlike \u001b[38;5;241m=\u001b[39m \u001b[43mmyResults\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdownsample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m250000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# amount\u001b[39;49;00m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# allow duplicates, default is true\u001b[39;49;00m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m post\u001b[38;5;241m.\u001b[39mshape, lnlike\u001b[38;5;241m.\u001b[39mshape\n", + "Cell \u001b[0;32mIn[46], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m post, lnlike \u001b[38;5;241m=\u001b[39m \u001b[43mmyResults\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdownsample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m250000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# amount\u001b[39;49;00m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# allow duplicates, default is true\u001b[39;49;00m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m post\u001b[38;5;241m.\u001b[39mshape, lnlike\u001b[38;5;241m.\u001b[39mshape\n", "File \u001b[0;32m~/new/new/codeastro/orbitize/orbitize/results.py:85\u001b[0m, in \u001b[0;36mResults.downsample\u001b[0;34m(self, amount, duplicates)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdownsample\u001b[39m(\u001b[38;5;28mself\u001b[39m, amount, duplicates \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m 80\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 81\u001b[0m \u001b[38;5;124;03m Samples from the posterior an amount of times. If the posterior\u001b[39;00m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;124;03m is weighted, samples proportionally to weight to get an equal-weighted posterior.\u001b[39;00m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 85\u001b[0m indexes \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoice\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweighted_post\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mamount\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mduplicates\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweighted_post[indexes], \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweighted_lnlike[indexes]\n", "File \u001b[0;32mnumpy/random/mtrand.pyx:1020\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.choice\u001b[0;34m()\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: Cannot take a larger sample than population when 'replace=False'" @@ -483,21 +491,14 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 18, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:Too few points to create valid contours\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -505,7 +506,7 @@ } ], "source": [ - "corner_figure = myResults.plot_corner(downsample=100000,param_list=['sma1', 'ecc1', 'inc1', 'aop1', 'pan1','tau1'])" + "corner_figure = myResults.plot_corner(downsample=100000,param_list=['sma1', 'ecc1', 'inc1','tau1'])" ] }, { @@ -536,16 +537,16 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1068: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1154: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " fig.tight_layout()\n", - "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1068: UserWarning: Tight layout not applied. tight_layout cannot make Axes width small enough to accommodate all Axes decorations\n", + "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1154: UserWarning: Tight layout not applied. tight_layout cannot make Axes width small enough to accommodate all Axes decorations\n", " fig.tight_layout()\n" ] }, @@ -560,7 +561,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABL8AAAK8CAYAAAAOOB0DAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xl8U2XaN/DfSZo2XdOVtlAoO1I2BYsgiOigIoyKyMjM6AzgrvUZGBi3UTbRRx+VTa3zdkQEd8aCMCPKCG4gBSwgIBQoe6EUum9p07TJef84TchyTtazpb2+8+lgT5KTO+lpmvPLdV83w7IsC0IIIYQQQgghhBBCOiCN0gMghBBCCCGEEEIIIUQqFH4RQgghhBBCCCGEkA6Lwi9CCCGEEEIIIYQQ0mFR+EUIIYQQQgghhBBCOiwKvwghhBBCCCGEEEJIh0XhFyGEEEIIIYQQQgjpsCj8IoQQQgghhBBCCCEdFoVfhBBCCCGEEEIIIaTDClN6ACRwVqsVFy9eRGxsLBiGUXo4hBBCiGqwLIuGhgZ07doVGg191kdIR0LvgQkhpHMQ8/0chV8h7OLFi+jevbvSwyCEEEJU6/z588jIyFB6GIQQEdF7YEII6VzEeD9H4VcIi42NBcAdCHFxcQqPhhBCCFGP+vp6dO/e3f63khAS+nJzc5Gbm4u2tjYA9B6YEEI6OjHfzzEsy7IijIkooL6+HgaDAXV1dfSHnxBCCHFAfyMJ6bjo95sQQjoHMV/vqQkGIYQQQgghhBBCCOmwKPwihBBCCCGEEEIIIR0WhV+EEEIIIYQQQgghpMOi8IsQQgghhBBCCCGEdFgUfhFCCCGEEEIIIYSQDovCrxCUm5uLrKwsZGdnKz0UQgghhBBCCCGEEFWj8CsE5eTkoKioCIWFhUoPhRBCCCGEEEIIIUTVKPwihBBCCCGEEDGYTMBrr3H/EkIIUY0wpQdACCGEEEIIISGtrIz7+uorYP58oLUVuP12ID2d+yKEEKIoqvwihBBCCCGEkGDk5QEjRnDBFwC88AL3fV6esuMihBACgCq/CCGEEEIIISQ4jz4KZGcDv/0t931YGPDDD0Dv3ooOixBCCIfCL0IIIYQQQgjxV3ExMGUKUF8PWCxgGxrA2C5rawPuvhuIjOS+j44GNm4E+vdXZqwhrrKyEpcuXUJsbCwyMzOVHk6H0tLSgrNnzyI1NRXx8fFKD8cnVqsVZ8+eRWRkJNJVPq24paUF4eHhYBjG+5VVoK2tDcXFxQgLC0O/fv1CZty+oPCLEEIIIYQQQvyVmgoYDMDRowAAt1PEioor/z1qFJCWJtvQOppLly4BABoaGsCybEickJtMJpw8eRIAMHjwYIVHI+zkyZNgWRYXLlxAXFwcNBr1d0Y6ceIEWltb0dTUhJSUFISFqTPWsIW24eHh6N+/P44ePQqLxYJBgwap9hguKSmB1WqF2WxGY2MjYmNjlR6SaNR/ZBNCCCGEEEKI2hgMwI4dwF//Cpbvco0GYBhg4ULuenFxco+Q16lTp3D48GGcOnUKLS0tSg/HK6vV6vT9+fPnFRqJ76xWqz34AqDq55llrxy9Fy5cgMVigcViUXBEnrEsi9bWVvv3x44dU3A0ntlCW7PZjBMnTtif1yNHjig5LI+amprs/33u3DmcPHkShw8ftj+WUKbOiJQQQgghhBBC1Mo25dFoBABYo6KgdThp5DZauYDsX/8C/vhH1Ux5bG5utv974sQJAEBiYiK6du2q5LAEuZ5019fXKzQS72pqanD58mW0tbU5bT9x4oQqq79cg8X6+nr789u3b1/o9XolhuXRuXPnlB5CQNQcgNrYXhscmUwmAFwVW1qIV69S5RchhBBCCCFE9XJzc5GVlYXs7Gylh3JlymNJCVBS4h582dTVcddTyUmjY5WPo+rqaplH4ju+sTlW/qhJaWmpW/ClZpcvXxa8zLFyTQ1qa2tx5MgRNDY2ul2mxmpAb9VzajuGm5qacPr0aaWHISkKvwghhBBCCCGql5OTg6KiIhQWFio9lCtTHhcs4J/y6OiNN+wVYkqrqqoSvMxW4REKjh8/rvQQOgRPx4PaXLp0STC8raurs/fTUgtvgbKajuGqqiqcPn1a8Pm1UXNI7gsKvwghhBBCCCHEXxUVwF13oTU52fP1xo4F8vLkGZMXnvr2qK3SBwBvlY+N2ipnXKcQuiovL5dpJB2Tt4o6i8WCM2fOyDQa73wJFr0dM3LxdSrxxYsXJR6JtCj8IoQQQgghhBB/5eUBI0YgvLLSabNb7URCArBqFZCZCWRlcf3CiE/Onj0reJmaKmcAbiVKT9QWfpnNZq/XUUsllbeKJBs1VS/6Mv21pKREhpF4x9frqyOihveEEEIIIYQQ4gvHRvcWCyx6PbQuJ9yM621qargvABg1SjX9vzqC5uZmREZGKj0MAFxD8FBSUVHh9TpVVVXo0qWLDKPxzJegTk187fvW2NgIlmXBMG6vGrLypwLNarVCownNGioKvwghhBBCgmAymUR/Yx4eHq7KVbYI6fRsje6PHgUAaH25jVbLrfy4YAHwwgtAmDpOwXr06IGwsDDVNrluElpEwMGpU6dUs4qiL9UzJpNJNa/ttbW1Xq9TXl6uivDLqJKeeb7yZ0XS6upqJCUlSTgaz/yt7quurkayt6neKqWOV15CCCGEkBBkMpnQvXsmKivFnc6SlpaGM2fOqOYkiRDSztbo/je/AbZvd7uYBU/ll8UCLF8OzJkjwwB9Fxsbq3jFiScXLlxQegiiO3XqFAYNGqT0MGC1Wn2eSqgGnnq/uTKbzQgPD5dwNN75EizalJWVKRp++fvh3eXLlyn8IoQQQgjpbMxmMyory/H1lkJER8eKsk+jsQG3T8yG2Wym8IsQNfFxyqNjAMYCYLRa4MABWYfKx3UqFl/wVVNTg4SEBLmG5BHfSXlGRkZIhWI6nc6pMb9aAid/KpPUwJcqQJtLly6hR48eEo7GM5Zl/Rqv0vwNv9RyDAeCwi9CCCGEkCBFR8UiRqTwy71bNiFEFXyc8shb+ZWfD/zzn4CCFSllZWVer1NaWqqK8IuvB1FsbCwMBkPIhF8RERFISkpyWyGvra0NYQpPfa2urubdnpSU5LZKoRrG62sPLUD5YK+lpUXR+/dXIM3u1XBMBCI0O5URQgghhBBCiJxsUx4XLADgW05tD8KMRqCgQKqR+aSurk7R+/cHXzVKWlqaaqdp8oV1aWlpMBgMbtvPnz8vx5A84qtMioyMRGJiotv2S5cuyTGkDsOfKZo2jtWBcgsk/PJlsQQ1ovCLEEIIISRILMuK+kUIUamwMGDxYuCJJ9wrvByUP/IIjAMHAgCs11wDPPooEKJ9cpTA1zPJ1scpPj7eabs/K9VJhS9AiI6OhlbrXh+odPN2ob8xBoMBERERbtv96V8lN77nV2mBhF9ClXhyCKRSzbU6MFRQ+EUIIYQQQggh/qisdK/80miA229Hy/XXo8s//4no9umRml9+AfLyuKmPKtS9e3elh+CGr0rNVvWVlpbmtL2mpkaWMXnS0NDgtk2jUeepttDqfjExMTKPxDeeViOMi4uTcSS+8dTvS6gRv5IBo7+rPYYydf5GEkIIIYQQQogamc3Al186V35pNIDVCnz9NcLPnkWr63S3pCRg1SogMxPIyuKa5yvIscLHdWqeGqpPPU0Dc+015EsvM6kp3WfKH0INzpVeIVGI0Hi1Wi1iY/l7bSrVd4tlWY+ViNHR0bzblZz2GOjvuxpeJ/xF4RchhBBCCCGE+KqgAHCt7nA44WUuXoTOtXKpqgooLQVKSrjeYS7VS3LLzMwUvKy0tFTGkfiGbzqemrgGNDqdzv7fUVFRcg/HI6EeT7ZKNb6KNZPLqqZyErrvuLg4wRWRKysrpRySIE/BV1RUlGD4pRRvVV+emtqH0oqWNhR+EUIIIYQEiWXF/SKEqNigQcD8+ai8916c+ugjnFy3Dti3D/jxR2D8eIBhwLo2ZtdqAYYBFi7kmubLPF3LNfBwDGdcqbHHU3p6utJD8ItjX7Jknl5vSlbNeGtwzhcoKRmICvVIi42NFTyOlTqGvU3RVFt1nbeKM09hnRpfJ7yh8IsQQgghhBBCfFFWBpw/DzY8HMn/+hei9+zhtqenA+PGAd9/DyxdCsY13LBYgGXLgEWLuKb5MnNdYVCtqyYKUVv1lDeOvaj4AoRAVtgTi7cqLr4VKpUcr9B96/V6MAzDeywrFS62tbUJXhYdHa268EtoSinAVQAKVdYBgTX2VxqFX4QQQgghhBDii7w8YMQIMPPnAwDS3noLfadP57bbHDgA1mHqGAtwlV8HDsg6VEeeTnJDgVqbxwP8U90cQw6+FQkrKiokHZMn3vphRUZGyjQS3whVJ9mqvtQ0Xk/hV0REhMfVKZVoPO/pdSEiIsJj+KVkn7JAqfdVhBBCCCEkRLAsK+oXIcRdbm4usrKykJ2drdwgHn0U2LrV/q1Vq8WptWu57QDXDD8/H4xjIKLRcJVf+fnc5SrkuoKi2rlOd1NyxTq+MMlbWMe3OqRcvP2NUVt/NaE+WraKL6Gm90rwVFWn0Wg8VlwqUUnlKQiNioryGH6FIgq/CCGEEEIIIaqXk5ODoqIiFBYWynvHxcXcCo2ZmcCoUcB999kv0lgs6DFvHrc9MxPo18+tGb49CDMauWb5KpSYmOj0vdqrOlz7aNW5LjAgI76eVK4hh5or1wDnPl9qGqsvHwYJVX4pseKjLxWWQtVf1dXVYg/HK2/hl6eG96GoYz0aQgghhBAFsO1fYu2LEKIiqancCo1Hj/JerHNcWW7ECOD++4FJk3DSoUl4ZmoqdD/+yDXLVyHXwOPUqVO46qqrFBmLa+DB1+8rLi4OZWVl9u8vX77sFuDJxZcqrtjYWEUDOm8ce5QJVSdZLBaP0/ak4G3KIyBcqVZTUyN7RaMvgVtkZCRvlZdQY38peRpveHg4GIZBWFiYx+mcoUQ9sS4hhBBCCCGEqI3BwK3QuGABt2Kjp5Ucd+8GXn4ZGDMGpqwstPTpg5jdu3GhSxfu9ikpsg/fdUog3+qDrpQ82XUdb1JSktt11DTt0VsDeYC/ibyaeFrVz6bJpaJRDkKVVI5THYWqk5SopPLl90ZNPco8/d7Yfsc60tRHCr8IIYQQQoLFivwFIDs7G1lZWcjNzZXxgRBCeIWFAYsXA0uXAr6s5FhWBn1REZLWrEHa8uWI/Mc/gP37udUiZVZTU+P0fYoCAZw/XMMkX4IZJfkSvKl9tUrX6im+Cq+qqiq5hmMnVJnkeEwIVaoJ9QqTktCx4Eulmty8Hbe2Y6AjNb2n8IsQQgghRIUKCwtRVFSEnJwcpYdCCLEpKHCq/GIBrqG9ay+vvDz0nT4daW+/DYBbFRIjRjivCikT15UF5Z665q/6+nqn79U+Xl/wVScpsbiJ0H26Psd8gYcS0/KEqupcx6eWPmVCgZtj4OW4EqiSvAVXtlDR03iVXLghEOo4SgghhBBCQhit9khIJ2A2A5s2OVV+MQBgtXLbHadoPfooTv/zn/ZvrVot8NNPV1aFlJGvUwLVMjXP9YTa0wp5SgumusiX5uhiE5qW5/oc862gqMTfpubmZt7troGMWgIlIY5hneuUXUdyPse+Vm15Gq+a+9jxoYb3hBBCCCGEEOJNQQHQ2gpkZqLkySdh7tED4SUl6PHWW0BJCbBuHfDKK9yqjgB6OlStaCwWYNo0wHaSHh0NbNwI9O+vwAPhl56eroqT2UCnUqmlIbuvYV15eTm6d+8u9pA88vW5VUtfKqGA0PU5joqK4q0SY1lWFeGp47RXTysoGo1GxMTEyDEkn8NXT+NVog9cMCj8IoQQQggRARVsEdLBDRoErFgBPPww6k+fBgCYsrKAJ54A3n0XuP56p1Uh3abYXLp05b9HjQJkXonOG08nuWqk1Wqdqtpqamp8auYvJr4AwdcG4a7TO+Xga+ChlkoqXyvrhMK65uZm2fqtearacnw+GYYBwzC816+rq5Mt/PI1CPX0uhBqleo07ZEQQgghhBBCvElJAWbPhlutQ1QUMHs20KeP76tC7tgBxMXJNfIOKc7l+XPtbSYHvj5YruOyca1KUyI48GVlSkAdQag/K3gKhXWNjY1iDccrT+N1fT6Fnl85e2gJLSYAOI9PDceCWCj8IoQQQgghhBAfnW6v+uLl76qQMvPnRFaJBuf+SExMdPren7BELHwBglDljq8VYVLiC7/4giM1TBUUqkziG5vQcS1ndZ1QPzXAPfgUqlTztA+xeaoCdK1U6ygo/ApBubm5yMrKQnZ2ttJDIYQQQgghhLjiWRWS5VsVUmZpfky1PHfunIQjCZ4awiS+AEGoQbhc09k84QuU+JrbC5GzWk1oyiNfWCcUfvla6SYGT8GVa4Ck1mPXxjWc6wgrrgIUfoWknJwcFBUVobCwUOmhEEIIIYQQ0qkwLS1IXr0aTEsLevTo4X4FgVUhGb5VIWUmNCWPTzArGcpBDRUpfAGCUFAQHR0t9XC84gu/hMbF9ziEVl+UglAlX0REhNs2NYQzYkzTlIvVavUYZLqGc55WfFSi4jJQFH4RQgghhASJFfl/hBD1itu6FWnLlyNu2zb+MMlxVcjXX8fJdetQ8vrrMKelccGXgtVfGg2d/omJL0AQCuX4Ag+5+37xBZp8YRLAX51UXV0t+piECFVSqWUlSlf+rFLqKUyS45jwNr3S9Vj1FNbJGYgGi179CCGEEEJCWFNTEzZu3IgHH3wQAwYMgF6vR3R0NIYNG4YXX3zRY8PfNWvWYOTIkYiJiUFiYiImTZqEAi8n5jt37sSkSZOQmJiImJgYjBw5Eh988AHvdWtqavDcc89hwoQJyMzMRFRUFKKiojBo0CA8/fTTqKysDOgxHzlyBL/73e+QkpKCyMhIDBkyBCtWrFB9pQoJcWVlwP79iF+/HgC4f/fv57Y7sq0KWVSE+okTYcrKQv3EiTjx739z2wcNkn3ooaIj/w7zVSf5uvqilISCGL7pkHL2gROasigU1inNn5+lp/DLUyN6sXj7PXMdn6dpmkqsWhooCr8IIYQQQoLEsuJ++eOTTz7B3XffjdWrV0Or1eLOO+/EDTfcgDNnzmDhwoXIzs5GeXm52+3mzJmDWbNm4fDhw5gwYQJGjhyJrVu3Yty4cdi4cSPvfa1fvx433ngjtmzZgqFDh2LixIk4ceIEZsyYgb/97W9u1y8tLcWrr76KX375BZmZmbjzzjtx0003obKyEq+//jqGDRuGM2fO+PV4d+3ahezsbOTn56N379648847UVlZib/+9a/4/e9/H3JLr5MQkpcHjBiB2L17AQCxhYXAiBHcdkftq0IiKsppMxsZyW1PSZFrxH5TuheRnD2a5MZXEVZVVaXASJwJVQPyhUz+VDcFSyhMEgq/lF6VUKzwS44wydtURV9XpwTUvzCGIwq/CCGEEEJCmE6nwyOPPIKioiIUFRXhX//6F7Zs2YLjx4/jmmuuwbFjxzBnzhyn22zbtg0rV65EUlISDh48iI0bN2LLli3Yvn07tFotZs2ahdraWqfbVFdX44EHHoDFYkF+fj5++OEH5Ofn49ixY+jbty+WLl2KH374wek23bt3x969e1FRUYHt27fjs88+w+bNm3Hu3Dn86U9/wsWLF/HUU0/5/FhbW1tx3333obm5GcuWLcOePXuwbt06nDhxAqNHj8bnn3+OtWvXBvhMEsKjuBjIygIyM4FVq4CEBOfLk5K47ZmZ3PWKi50uzsjIkHGwwUtPT1f0/l2nUHkLNFwDJTnDGTHU1dUpPQRBSvelEvpZCvX3Unq8/oRfnvrVyREmeav8cg1EPf0eylGpJhYKvwghhBBCQtiMGTOQl5eHgQMHOm1PT09Hbm4uAGDDhg1Ob8yXLVsGAHjhhRfQr18/+/bRo0fjscceQ21tLd577z2n/a1atQr19fW46667MHXqVPv21NRUvPbaawCApUuXOt3GYDBgxIgRbm+k9Xo9/vd//xcA8N133/n8WL/44gucOXMGw4YNw1//+lf79piYGLz99tu8YyAdhyIrnqemAgYDUFIClJYCNTXOl1dVcdtLSrjruaym6M9KemqgdFN21xN/g8Hg8fpRLtV1rqG92snZLNzfKaWeqpPkINSXSij8EuoFJlc1sNDPUqiyTuhxyFH9GGrHglgo/CKEEEII6aCGDRsGgPtk1ja9prm52R44TZs2ze02tm3/+c9/nLZv3rxZ8DaTJ0+GXq/Htm3bfH7jbnsz7c+n9Z7GMHz4cPTu3RuHDx/G2bNnfd4nCR2KrHhuMAA7dgALFgAMw3050mq5bQsXctdzaYCv9Cp0oVSVAbiHX97Cw/j4eKfv5WzIHmr8DdqUXhxBKKARqpoSmrIrVzWg0HiFgiOh6ZtyBKL+3ofSU0rFQuEXIYQQQkiQlOz55cnp06cBcG++ExMTAQDHjx9HS0sLUlJSeKdkDR8+HABw6NAhp+0HDx50utxReHg4Bg8eDJPJhGKXaV98WltbsWjRIgBccOYrT2PwNHZCghIWBixeDCxd6v4LarEAy5YBixZx1xPAtLQgefVqWGTuj+NpwQtfyN1Dz/Wk3FsPspiYGKfvlZ726C0wUjJE4Kuk8jT9Tmn+HntCIZNcDdmFxiv0AY+S/fW8rfboqqOEXx3jURBCCCGEdDCub9gjIiL8XuVq5cqVAICJEyfab1tSUgJAuBdRdHQ04uPjUVNTg4aGBsTGxqK+vt7em0bodhkZGdi7dy/OnTuHoUOHul3+4IMPwmKxoKamBvv27UNpaSnGjBljnzLpC29jt20/d+6cz/skxGcHDoBlGDDtJ7ksAEarBQ4c8HrTuK1bkbZ8ORoHDkTMww9LO04Hga6oamM0Gt0CJjl5q5xT20m56zRMV+Hh4X4HD2LhCwa9BTAMw7iFOizLyhKa+Rt+CR0L9fX1SE5OFmNIgjyNVeiYUDL88hQS84WI3n7ech0TwaLKL0IIIYQQFerevTsMBoP965VXXvHr9l999RXee+896HQ6LFmyxL7dVgni6STN1venoaHB6Taebud6G1dr167F2rVr8e9//xulpaUYP348PvroIyQlJfn8mLyN3dsYCAmY2Qzk59uDLwCARsNVfuXnc5fzKSuDvqgI8evXAwDYd98F9u8HyspkGHTwlVDnz58XaSSB8XZCreQJN1/g4S0oVLKnGl9Ddm9hHV/46LoogVoIhV9yjNdTDy01rk7p6XVBqFKtIzS9p/CLEEIIISRILMuK+gVwJ511dXX2r+eee87n8Rw7dgz3338/WJbF66+/bu/9paS2tjawLIuLFy/i888/x4ULFzBkyBD897//VXpohHhXUAA0NTltYmwnvEYjdzmfvDz0nT4dsXv3AgBiCwuBESOAvDwpRysaORuyhxq+wMNbmMQXfsk1tZSvH6NQk3gbvuqkYKfSSkWoSlCO59fT74nQdEy1hl9CYZ2npvdyrFApBnXViRJCCCGEEABAXFwc4lyaZ/uitLQUEydORE1NDebOnYvZs2c7XW6rTGhyOZF3ZHsja2s27VjN0NTUxDsu19sISU9Px7Rp05CdnY0hQ4Zg5syZOHnypE8VETExMaipqREcu69jIMRvgwYBixfjVK9eYNtPDnv37g1NSwvw7bfc5TbFxcCUKVwoZrGg1WCArn3aMAAgKQlYtQp4/30gOhrYuBHo31/Wh0OCxxd4eFvAg+/y5uZmr6GZGPiqc7xNvYuKinILu+rq6tClSxdRxyYGJasAPU1lFQq5lFwMI5BKNb1eL1hF19DQ4FcVt1Ko8osQQgghJEhqaXhfXV2NW2+9FefOncOsWbPwxhtvuF2nR48eAIALFy7w7sNoNKK2thYJCQn2ECkuLg4Gg8Hj7WzbMzMzfRprZmYmbrjhBly6dAl79uzx6Tbexu7vGAjxWUoKsGABmq+5BqasLJiysqC59lpgzBhuJciUlCvXTU3lVoksKQFKS52DLwCoqgJKS7nLDQYgLU3ex0JEwRd4BNKjrM71+JAI33i9VR/xBSFqnuKmVADmqfJL6Jjw9Nx7CqfE4Gn/gUx79HWVZ6VR+EUIIYQQ0gE0Njbi9ttvR1FREaZOnYp3332X90RgwIABiIiIQEVFBUpLS90u379/PwC4Na23TZ20Xe6otbUVhw8fhl6vR38/KlhsTYgrKip8ur6nMThu52u4T4hsDAZgxw4uFGMYsK6/h1otwDDAwoXc9QKo8JSSUgGC3CtLBosvBPL23PGtBinXNEK+8Mvb6pTeKtmkEuixoFQ1lafKL6Hn2NNzL3WY5Cn8Epre6Gnao1KLOPiLwi9CCCGEkBDX0tKCu+66Cz///DNuu+02fPrpp4InAZGRkbj55psBAJ9//rnb5fn5+QCAO+64w2n75MmTnS539OWXX8JkMmHChAk+r2BlsVjw008/AQD69Onj0208jeGXX37B6dOnMXjwYPTs2dOn/REimbAwYPFiYOlS5yb5ANckf9kyYNEi7nqyDcm3+1JqShtfQ3ZfuJ6UyxWiidVIXa5KKr7nxVtYp1SYFGivOX9XRBZLIOP19NxL3UPL0++I0OuE2lZWDQSFX4QQQgghIcxiseAPf/gDvvvuO9xwww3YsGGD10/r586dCwB46aWXcOLECfv2Xbt2IS8vD/Hx8XjwwQedbvPQQw8hLi4OmzZtwoYNG+zby8vL8fTTTwMA5s2b53Sbzz77DL/++qvb/VdXV+ORRx7B6dOnMWTIEIwYMcLp8j//+c+46qqr8MUXXzhtv/vuu9GrVy8cPHgQy5cvt283Go3IycnhHQMRtm/fPrz66quYOnUqMjIywDCMxxOyRYsW2a/D9/Xss88K3nbnzp2YNGkSEhMTERMTg5EjR+KDDz6Q4mGpy4ED3KqQ7ViAq/w6cED2oSQmJvp0vYSEBIlHwi/QahfXFRblCpMCDevUxFv4pVTgIVSZFMg0TUD6QDTQVVWFnn8lFxUQCjw9VX6FitCP7wghhBBCFOa4SqMY+/LH22+/bQ+JkpOT8cQTT/Be74033rBPM5wwYQJmz56NlStX4uqrr8Ytt9wCs9mMrVu3gmVZvP/++4iPj3e6fWJiIlavXo17770X06ZNw/jx45GUlIRt27ahtrYWc+fOxfjx451us2XLFvzhD39A7969MWTIEERFRaG0tBT79+9HY2MjunXrhnXr1rmdAJSUlOD48eNuvXB0Oh0++ugjTJgwAXPnzsW6deuQmZmJHTt2oKysDNOmTcOMGTP8ev46syVLlmDTpk1+327MmDHo27ev23bXENNm/fr1mD59OqxWK8aNG4fk5GR8++23mDFjBg4dOsTbm65DMJuB/HzA9UTeYuG2//OfgIzTymx9+7xRKvAItNolOjoaNTU19u9ra2uRJkMftUADj1DibVqkVIQqqbx9sCNUedza2irpFM5Ag1CtVss7ZVDJvmpCgVxHqPwK/UdACCGEENKJOZ70uVZKOVq0aJE9/AKAFStW4Oqrr8bbb7+NrVu3Ijw8HBMmTMD8+fNx/fXX8+7jnnvuwfbt2/HSSy9h9+7dMJvNyMrKwpNPPskbOj300EOIjo7Gzp07sXPnTtTW1iImJgaDBw/GHXfcgZycHJ9PyG2uv/56FBYWYuHChfjhhx9w8OBB9OnTB0899RRmz56t6IpfoWb06NEYOnQosrOzkZ2djZ49e/p00vXQQw9h5syZPt1HdXU1HnjgAVgsFqxfvx5Tp04FAFy+fBljx47F0qVL8dvf/tYtOO0QCgoAl5VJ7Uen0chdLuPjDvTkn2VZWX6vAp1GGBkZ6fS92sMvrVYb8LS+QIndQF3qY0JovN6OYaHqJKPRKGn4FWjPK51Ox3tbKXtoBfpBHYVfhBBCCCEk6FUaXfflj0WLFmHRokUB3dfMmTN9DjFsxowZg6+//tqn644dOxZjx471e1w//PCDx8sHDRrE2/eL+OeZZ56R/D5WrVqF+vp63HXXXfbgCwBSU1Px2muvYerUqVi6dGnHDL8GDeL6fg0bhvNHjyLxgw8QffQorFdfDc111wEOYbQcAg0rGhoaECdDU/5Aq2dcQw25mm8HGiiFh4eL1i/MV2I/J1JXUgmN1zXodCUU0NTX10s6nVfo2PX2O6fEsRDocdsRPliinl+EEEIIIYQQSWzevBkAMG3aNLfLJk+eDL1ej23btkm+upkiUlK4FR9/+QXdn3sO0UePAgA0Bw4AeXnc1McQwLcqrBRcq6G8BR02ajkp97UyxrVHmRzEDr8aGhpE3Z8roao6b4Gb0M9A6oBJKFDytmCArwvEiCmYKkBPfb/Eri6UAlV+EUIIIYQQQnz23Xff4cCBAzCZTMjIyMDtt98u2O/r4MGDAIDhw4e7XRYeHo7Bgwdj7969KC4uxtChQyUdt6yKi4EpU7jpjRYLWg0G6Bx72CUlAatWAe+/D0RHAxs3Av37KzVaj+SeomejREgUDF/DOl+vJ6ZgfoYajcYt2Kivr0dSUlKwwxIkFNZ5a7ouFH5JXQ0oNJXQWyCqxFTCYMMvoWDSZDIhKioq4H3LgcIvQgghhBBCiM8+/PBDp+/nz5+Pe+65B2vWrHEKLOrr6+2LFmRkZPDuKyMjA3v37sW5c+c6VviVmgoYDEB7tZfbKXtV1ZX/HjUKkKFHVagJtfDL1/HyVS9J3UMrmOb8Op3OrReg1A3ZhaYRequkUqIK0FMPLW+VXd4ejxQ8BaHexhMREYEmlz6GNkajUfXhF017JIQQQgghhHjVt29fvPHGGzhy5AgaGxtx/vx5fPzxx+jWrRvWr1+PP/3pT07Xb2xstP+30ElRdHQ0AM/TqFpaWlBfX+/0pXoGA7BjBzftkWHAup6Ua7UAwwALF3LXk6Cnlly9r6QSERGh9BD84uuJP1+1j9Q/q0D7qQH8AY7U4xXavy9hkdwBmKcwydsxrLbKr0Ar6wCExNR1qvwihBBCCAkSy7IBr6DEty9C1Oj+++93+j46Ohp//OMfcdNNN2HIkCHYuHEjdu/ejVGjRol6v6+88goWL14s6j4D4fd0obAwruF9fDyYuXOdL7NYgOXLgTlzRBufK6EKjVChRFVMMHwNMvgel9FoRHx8vMgjuiKYyi+9Xm+v4JSLUKDkS7Cl1WplDX493Vcw4ZfVaoVGI36tkqewztsx7CkcC4Xwiyq/CCGEEEIIIQFLT0/HrFmzAABbtmyxb3ecBuZpqgwAxMbGCu7/ueeeQ11dnf3r/PnzYgzbbwE3fj9wAKzDSSwLcJVfBw6IMSxBwVTIefp5yEUtjex95Wv4xfe4pA6XxK78klow4ZeUq1DyCSZM8nS5VE36PYX4wYw3mIBVLhR+EUIIIYQEiWXF/SIk1PTr1w8AUFZWZt8WFxcHg8EAALhw4QLv7WzbMzMzBfcdERGBuLg4py8lBBRQmM1Afj4YxxNOjYar/MrP5y6XSDDhV3JysogjkZ8SFbTBhHVSV+kFUwmltql53ghVW0l1THh6br09d54qu2wfDIjN03PrLTgM9dUeKfwihBBCCCGEBKWmpgbAlR5eNsOGDQMA7N+/3+02ra2tOHz4MPR6PfqrdKXDoBUUAC7Bhj0IMxq5yyUSzMmo2htXu3I9KZeqasZG7CBF6hU1+fbva1inxPTTYI5doUo1qaZCehprMM+dVMdwMGFdqE1FdkXhFyGEEEKICmVnZyMrKwu5ublKD4UQj1iWxRdffAEAGD58uNNlkydPBgDk5+e73e7LL7+EyWTChAkTFJlaJYtBg7i+Xz/9hJPr1tm/8NNP3PZBg5QeIa9Qm3LoGtbZwlipBFvlIvfzyxfWeWtubqNE5VcwhB6XEpVUvvTsEgqUpOqh5SloDabhfSig8IsQQgghRIUKCwtRVFSEnJwcpYdCCCoqKpCbm+u2KmNjYyMef/xx7NmzB2lpaZg6darT5Q899BDi4uKwadMmbNiwwb69vLwcTz/9NABg3rx50j8AkTAtLUhevRoDPEzTdJKSwq34OGYMTFlZ9i+MGcNtT0mRdsAiUfvKka49yqReETTYSi1fgyex8IVfvvbGkqLpupSEAhrH1WfF5Cn88rVBPx+pemgFU/kVaqG4q9CO7gghhBBCVIBWeyShaPPmzViyZIn9e1tTbMfVGufPn4/JkyfDaDTiySefxLPPPovs7Gykp6ejoqIC+/fvR1VVFeLj45Gfn+9WgZOYmIjVq1fj3nvvxbRp0zB+/HgkJSVh27ZtqK2txdy5czF+/HhZHm9QysqgLypCzI4dSHv7bSApCbj9diA9nfvyE8uyIXUiWVFRgfQAHqdcXI87qacRBhsG6vX6oJrQiyHYaku1HsNCYZJU0wiDPdbCw8NlPRY8HbvepjWq8eftj9CKcSWwb98+vPrqq5g6dSoyMjLAMIxPP9Q1a9Zg5MiRiImJQWJiIiZNmoQCL3P2d+7ciUmTJiExMRExMTEYOXIkPvjgA7EeCiGEEEIIIT6rqKjAnj177F+24NVxW0VFBQAgKSkJzzzzDEaMGIHi4mKsX78eO3fuRFpaGubNm4fDhw9jzJgxvPdzzz33YPv27bjtttvwyy+/4KuvvkLfvn2xZs0aLF26VLbHG5S8PPSdPp0LvgDghReAESOAvLyAdqf2SipXVVVVSg/BI7mnYwUbVrj2xlOCUGN4X0kV2AT7AZDQsdDS0hLUfoWIEYTKydN4fanyC7VKQEedvvJryZIl2LRpk1+3mTNnDlauXInIyEjceuutMJlM2Lp1K7755hvk5+djypQpbrdZv349pk+fDqvVinHjxiE5ORnffvstZsyYgUOHDuGNN94Q6RERQgghRHZs+5dY+yJEBjNnzsTMmTN9um5sbCxeffXVgO9rzJgx+PrrrwO+veIefRSnu3VD70ce4b4PCwN++AHo3Tug3VVXVyM1NVW88YW4YAMPuU/Igw1+1NDjztdpjwBX8eP6MzIajUEHaHyEjgVff8ZyHwvBTk+UO7j1VKnmy3MXFhYmePy3tbWpui+Yekcmk9GjR2Po0KHIzs5GdnY2evbs6TEV3rZtG1auXImkpCTs2rXLvqzzrl27MH78eMyaNQvjx49HfHy8/TbV1dV44IEHYLFYsH79ensvhMuXL2Ps2LFYunQpfvvb34ZGyTchhBBCCCGdQXExMGUKtyojgO6ODbPb2oBp0wBbgBAdDWzcCPi4amVFRYWs4ZfaV2kLtoG83IINv9QQEPjTd0yr1bpVDDU2NiIxMVHsYQkeC74+Z3JPzQt22qPcv5uegmZfnjudTid4/Dc3N7v131OT0K1ZE8kzzzyDF198EXfccQfS0tK8Xn/ZsmUAgBdeeMEefAFciPbYY4+htrYW7733ntNtVq1ahfr6etx1111OTUBTU1Px2muvAUDolHwTQgghhBDSGaSmAgYDUFIClJRA5zr179Il+2UwGAAfziWUkpycrPQQPHKtnlF7WCdF+CV3v0d/nmO+KjG5e2jJvUiAr4SmEfpagSZ3EBpsg35PFYNSHRNi6fThlz+am5vx3XffAQCmTZvmdrlt23/+8x+n7Zs3bxa8zeTJk6HX67Ft2zbJljMlhBBCiLRYkf9HCFEBgwHYsYNblZFhwLqeGGq1AMMACxdy14uL82m3thUjIeN7fzVXYwDu/ZgiIyMVGolvgu3zxBeMyB0c+DM9kO/nIdVqhELhjBRTLMUgFFr6Gmp5up4aKyI9jVfteQaFX344fvw4WlpakJKSgoyMDLfLhw8fDgA4dOiQ0/aDBw86Xe4oPDwcgwcPhslkQnFxsQSjJoQQQgghhAQkLAxYvBhYuhSM60muxQIsWwYsWsRdz4ukpCQAQNzWrUhbvhzYsEGCAfPzp7+TTUxMjAQj4ecapKihIbwnwYZffBU2jY2NQe1TiFA448/0QDl7lAlVfvkTfslZOSgUUPn6O+dprGqspPIUfqlxvI4o/PJDSUkJAPAGXwD3Ih0fH4+amho0NDQAAOrr61FXV+fxdrbt586dE3vIhBBCCCGEkGAVFLjXZGo0gJfV3h0lmEzQFxUhfv16bsOqVcD+/UBZmWjDFBJIE3Ap+jkJca38EiN4C7YXkydSVOTU19eLvk9AnOmUck7NCzZMAtQxRVKMyq+mpiaxhgNAnOPWU1gn5e+cGCj88oMtjY+KihK8ju1TClv45ZjgC93O9TZCWlpaUF9f7/RFCCGEEEIIkZDZDGzaBLc6GasV2LSJu9wHEWvWoO/06Yjdu5fb8P33wIgRQF6eqMMVi5zVV64VI4GEF66VTGIHB1KTasqYGIGHnOGXUFWdP2MQCsqk6KsmtE9fq+U8BdNiV1JJHX6pcZqmIwq/Qsgrr7wCg8Fg/+revbvSQyKEEEIIAJYV94sQoiIFBUBrK1rS01Hy+us4uW4d8NlnQI8eXPDlqfqruBjIygIyM8G89x5aDQbny5OSuAqwzEzueiK1QRGjAkPOqWNiNLx3Dcxqa2uDGVKHIXXgITah8MufMQhNkZSqTxkffwJcoSmoagy/1LBSaaBCd+QKsJXfevoUwdi+BLKtqaRjyW5TUxPieBphut5GyHPPPYe5c+fav6+vr6cAjBBCCCGEECkNGgSsWIGT118P1tb4e/Bg4I47gHff5S4XYlsx8uhRAIDb6bDjCpKjRom2YqTrNEK1cw3r/OlHZRMZGem0CqPtHEsOgUwrlUuoTXsUI/wSqvxqbm4OqP9dIPx5zrRaLe/jFjusC7VQXGzq/S1VoR49egAALly4wHu50WhEbW0tEhIS7EFWXFwcDO2f8AjdzrY9MzPT4/1HREQgLi7O6YsQQgghymOtrKhfhBB3ubm5yMrKQnZ2trx3nJICzJ59JfiyiYoCZs/mLhci0YqR3kgR/EgxZUxMrudGwTal90cg4ZBcgZkY1T5yhntmgWnE/oxBKKCRcyqsPyGRXD3KOnvlF4VffhgwYAAiIiJQUVGB0tJSt8v3798PABg6dKjT9mHDhjld7qi1tRWHDx+GXq9H//79JRg1IYQQQgghoS8nJwdFRUUoLCxUeij+EXHFSF9J0RtY7Su5RbqGkzIKJLyQK/CQsgm5FIGoUGjpTzWgUEAjdvjl6fGLUakmNjGOhUCqMtWCwi8/REZG4uabbwYAfP75526X5+fnAwDuuOMOp+2TJ092utzRl19+CZPJhAkTJsi6hCwhhBBCCFGHiooK7NmzB5s2bcInn3yCzz//HFu3bsXx48dVv3oW8YPLipEs4PeKkb6SIqiqcpyiqUJKTscK5DxOrrBOqJJKDFJU10nZo0zs58JT+OVPpZpc4Zen59bXUMvb9dTc9D50a9YUMnfuXHz99dd46aWXMHnyZPTr1w8AsGvXLuTl5SE+Ph4PPvig020eeughvPzyy9i0aRM2bNiAqVOnAgDKy8vx9NNPAwDmzZsn7wMhhBBCCCGKMBqN2LRpE77++mv8+OOPvDMKbCIiInDNNdfg1ltvxd133+02w4CECJ4VIxnAecVImU6AA1VXV6fqfsNyTc3jCzwCDb/kaMovVkCl0Wjcgo2mpiZ7ix+xSNmXSuwPE8QIkwD5gltP4/VnDFqtVvC5bGtrky3M81enr/zavHkzRo0aZf+ypcGO2zZv3my//oQJEzB79mxUVVXh6quvxpQpUzBp0iSMGzcObW1teP/99xEfH+90H4mJiVi9ejU0Gg2mTZuGm2++Gb/73e8wYMAAnDx5EnPnzsX48eNlfNSEEEIIIURuv/zyCx544AGkpaXhT3/6Ez755BNcuHABLMsKfplMJuzatQsvvvgirrnmGgwdOhR5eXmy9q4hIuBZMbLk9dd9WzGS+ESu6Vh8J/2BnOzzrUgoxTRCsZqm800llKK3XCitTilW+CVXHy1P4Z8/4bGn8ap5enSnr/yylZm7ctxWUVHhdNmKFStw9dVX4+2338bWrVsRHh6OCRMmYP78+bj++ut57+eee+7B9u3b8dJLL2H37t0wm83IysrCk08+iRkzZoj7oAghhBAiK5blvsTaFwBkZ2dDq9UiJycHOTk54uycKOKXX37B/Pnz8fXXXwO4coKblpaGkSNHYsSIEejSpQsSExORkJCA5uZmVFdXo6amBsXFxSgsLMShQ4fsvWKfeOIJzJ8/H08//TT+53/+h/ckmogr6BM6nhUjTVlZwBNPeF8xkqgKX+ARSP8uvgChra1N9F5gYlU7hYeHu00bVOvCCnIFoZ7GqsbwS6zKL51OJ7iibHNzs+jVgGLp9OHXzJkzMXPmTFluN2bMGPubHkIIIYQQTwoLC2ll5w5g1qxZ+PDDD+0nHcOHD8d9992He+65x76SuC/MZjO2b9+Ojz/+GF988QUqKyvxzDPP4J133sEHH3yAsWPHSvUQCIBTp04FtwPbipGHDztvt60YSUIGX5gUSKURX+AhxTRCvmmPgYxXr9ejsbHRaZtQANJZiNXfylP41dbWJlo45mkKrD+hq6dKR5PJ5NeY5NTppz0SQgghhASLq/wSnrrm35fSj4aIae3atQgLC8PDDz+MY8eOYe/evfjrX//qV/AFwD7T4P3338fly5fxwQcfYMCAATh79iy+++47iUZPxBYdHa30EEiQ+AKEQPqN8QVQUqzSyTfeQMKUUKswlaP6S6zwy1MYKWbA6Gm8/oRfco1XbBR+EUIIIYQQIpEnnngCJ06cQF5eHvr37y/KPiMiInD//ffjyJEj+Oyzz+wLMBH1S01NVXoIfomKilJ6CEGRoocW34qBgQQtfLeRopcfX+ARSI8yOabmCf28AqlUk6PvlxyVX2JWUnmq/PLn5+utUk2tOv20R0IIIYQQQqTy9ttvS7ZvhmFw7733SrZ/wi+YipJAVgVUUmJiYkgtrsAwjFOAYrVaRQ9B+MIvsYjVnN4RX0ATSBWXHOGXUJgUyH3rdDrJgxixwi9PrylNTU1ISkoS5X489X8Tq/JLisBZLFT5RQghhBBCCCE+CqaCL5DpccEKpMrHJiYmRsSRSM/1sUoR3EkZfklBrPBLyUqqQBYBELqNWIGV2PsSIuY0Qk/hlz8Bo1yraYqNwi9CCCGEkCCJ1++LVfWnpkR+LS0tuHz5siwnWcQ3Yq/GJ7VgGqiH2kluZPtKmja1tbWi34cU1VlyE2t1SrEJhTOBhHVCt5Grh5a/hIJxMY83T+GXP8G8XKtTio3CL0IIIYQQQmTW2NiIr776Cl999ZXbCmoAUFlZiXvuuQdxcXHo2rUrEhISMG/ePFU3EybqFBsbG/Bt5WgaLibXxypF5Zeaexr5KpDwQo6qRTkqv8Q8JsQMpoSCZk+Blb88hXX+BN2hForbhGZkRwghhBCiItxqj+Lti3R869evx6xZs5CRkYGzZ886XWa1WnH77bdj//799krAhoYGrFixAmfPnsX69esVGDGRAsuykgdMYvYZs1gsop/4ilnt6vpY5eqhFSiNRqNIVaeYP0Mxj2ExK7+EAj4xG8iL+bPT6XSKVhX6E26GavhFlV+EEEIIIYTI7L///S8A4O6773Y76Vi3bh327dsHABg+fDj++te/Yvjw4WBZFhs3bsSWLVtkH29nx7S0IHn1ajAiV97JEXyIGa7xVSkGyzX8Cma8obTCH6DcFFoxq7jkqEwSc7XH5uZmv/clRMywKpjefL7wFjL7c0x4u65ap+lT+EUIIYQQEjQx+31R6VdncPjwYTAMg+uvv97tsg8++AAAMGLECOzevRtLly7Frl27MHLkSADA2rVrZR0rAeK2bkXa8uWI27ZNlP3ZwrTGykpR9ufxvkQMvyoqKkTbl43riXIwwUyoVaS49iiTi5jhl5hhklCQFsg0TaFjQcwFC8QM/qQOv7wFUv4cE95eU9Q6NZjCL0IIIYQQQmRWXl4OAOjVq5fT9tbWVmzfvh0MwyAnJ8d+0qfT6fDYY4+BZVn8/PPPso+30yorA/bvR3z7VNP49euB/fu57UGwhWn1a9aIMEj5iDllzMb1RDmQKW42odajTKnwK9DniS8gMRqNwQ7HTihMCiSsEwrM1Lrao9TBrbegzt9jwlMgKcXrhBgo/CKEEEIIIURm1dXVANw/7S8sLLRXUkycONHpsv79+wMALl26JMMI1Sc3NxdZWVnIzs6W707z8oARIxC7dy8AILawEBgxgtseiLIy6IuKRA/TQpnr1LGoqCiFRiI/vqBPzSv+8gU0YjaQFwpoxJz2KKZQCr/EnoroacouhV+EEEIIIYQQAFdO8G0VYDbbt28HAPTt2xepqalOlylVJaIWOTk5KCoqQmFhobR3VFwMZGUBmZnAqlVAQoLz5UlJ3PbMTO56xcW+7zsvD32nTxcvTOOh1n47QlxXMO1Mxzlf9YyY0/LExjc1T8wVaIV6aAVSqSZHFaAcPcrEIvbrgqfKLzGnwoqJwi9CCCGEEEJk1qdPHwDADz/84LT9iy++AMMwGDdunNttbP2WunTpIvn4OrXUVMBgAEpKgNJSoKbG+fKqKm57SQl3vbQ0z/tzCdPa4uOdLw8mTOMhZh8iObiGPVL3PlITvsBDzGmEYleR8a0cKubxptZeUULEDL88hUliPMdivy54qvxSctVKTyj8IoQQQggJkljN7q80vScd3S233AKWZfHOO+/g66+/RmNjI9566y17VdMdd9zhdptDhw4BALp27SrrWDsdgwHYsQNYsABgGO7LkVbLbVu4kLteXJzn/bmEaWG1tc6X+xumeaHWE08hruGXUisgKkHq8Evsap9g+rH5QuzwS8zG/nyE/l6LXfklxjRCsY8FT+NV62sQhV+EEEIIIYTIbPbs2YiLi0NDQwN++9vfwmAwYM6cOQCAgQMH8oZfmzdvBsMwuOaaa2QebScUFgYsXgwsXQq4nuBaLMCyZcCiRdz1vHEJ09hgwzQvxOzBBEg/DdE1/BI7sFDzBwpSN5CXs8+TGMT+WUk9lVBovGKuTgmoM/ySulJNChR+EUIIIYQEiWXF/QKA7OxsZGVlITc3V9kHRySRnp6O//znP0hLS3Oq+uvduzfy8/Pd+tWcOnUKO3bsAABMmDBBiSF3TgcOAA4BBQtwYdWBA/7txyFMY4IN07wQO/xKcO15JjLXah+xezWp9URciJjVT6EWJon9swokhFLqfj2FvmL8Tov93MqxoIDYlDkaCCGEEEKIR4WFhYgLsgKEqNsNN9yAM2fOYOfOnbh06RLS09MxduxY3hOnsrIyzJ8/HwBw6623yj3UzslsBvLzAceKCY2GC6vy84F//hPwtz+VLUxr3ycLgAkkTPOgsbFRtH0BQGxsrKj7c+VakRJs+BUWFuYUIDU3N0v6GNQcAsg51U0MYod14eHhvM3XLRaLpI8lkL51no57MaYRhtqxIAUKvwghhBBCCFFIeHg4brrpJq/XGzt2LMaOHSvDiIhdQQHgUnHB2E4gjUbu8vHjfd+fFGEaDzmnN6lRZGQkGhoa7N/X1dWJFn7xhTNqfn5CLfAQO/wS6lHW3NyMmJgYUe/LUaDPE8MwvM+BGCtqeqr8CiRwVvNxLyT0RkwIIYQQQgghUhs0iJuq+Jvf4GRpqX1z327dgG+/5S73h9hhmkxcT4xZlhV9aqKYoqKinMIvqVdP5FsBUS06e/glFNA0NTVJGn4F2htNo9HwhlRiTFn0dCwE0mePKr8IIYQQQjohMVdpVHNzZkI6lZQUYMECWK1WmIqKrmwfPBgYM8b//YkdpimktbU1oGldcomKinL6XsyV5/hen4NtAq/VaiXrS8bXPyyYBQWEQk+1BqJCAY0YDeQ9/a0OtCoqLCxMsmPB03gp/CKEEEIIIYRIjmVZHDhwAAcPHkRlZSWam5u9hqALFiyQaXSktrZWnB21h2kAYDp82L7ZmpUFTSBhmkLq6+uRnJys9DAESbkiIV/1TLCVXzqdTtbwS4rnp6WlRZUVcEIhlBjTCD1VUgUaBIaHh4syNj5iV355u40aA1EKvwghhBBCCFHI2rVrsXjxYpw7d86v21H4JZ+LFy9Ktm+mpQXWV1+FZu5cQIXhAZ+KigpVh19SVqTwhdJCfaV8FRERIUolEh++qjcpejU1NzerMvwSOhakbiAf6DEoZUWlp4A1kEDUW7DV1tYmaRAdiMBrHgkhhBBCCIAr0x7F+iKdw/PPP48HHngAZ8+e9emYoGOk44nbuhVhzz8PbNig9FB8JlWVkliCmdbnDV8lVbBhm5ShEd94gw3r+EIPvhUV1UDoZyNGLzQpKr+kbCIvdvgFeB6vVIFuMCj8IoQQQgghRGZ79uzBK6+8AgC45ZZbcODAAezfvx8Ad+JksVhQUVGBr7/+GnfeeSdYlsXYsWNRVlYmehNrIr+wigroi4oQv349t2HVKmD/fqCsTNmBdQBSTrWSK/wSK+DmCzyCDb/4wsUml4Uc1ELKMEnsaYSA/FWLNoGOl8IvQgghhJDOhhX5i3R4//jHPwAAmZmZ2Lx5M4YOHer06TvDMEhKSsJtt92GjRs3Ijc3Fz/99BMmTpwIs9ms1LA7Pddm6oFK/Pxz9J0+HbF793Ibvv8eGDECyMsTZf9EGnyBR7BhG1+AIFaTfil6fvHdXozXJCkqWqUMQj2NN9D7lTL8kqLyy9PtKPwihBBCCCGEoKCgAAzD4C9/+YtP1QmPP/447rnnHhw6dAjvvPOODCMkfLp37x74jYuLgawsIDMT8evXo9VgcL48KYmrAMvM5K5XXBzcYIno+EKeYAMWvsBDrEoqvrBOivBL6mmEaiTFtEdP4Vew0409jVeKaY9q/JCGGt4T4gXLsrBYWLS2WmButcBsboPJxH2xVhZms6W9/4bjba7c1nlfV/5bq2Wg1Wqg02mh03H/hoVpoNVq2v9l7P+t02mh0ahrtQxCCCFXiFmwRYVfnUNZ+/S2QYMG2bc5Tj1pbW11OyH505/+hPXr12PdunWYM2eOLOMkzoIKDlJTAYMBOHoUvG2tq6qu/PeoUUBaWuD31S46OjrofZAr+AIIKSq/jEYj4uPjg9ovwB94iDFNs6GhIah98BGqpAr2+dVoNJIEa1Ls09s0wmB+nz1VqgV6TFD4RUgIslqtKDlWCbPFAl2sHmZzG1pbLbBYWFitrgEWG9CZCcs6v+hwfzstaG52L2t2fJFnGMBiYaHVMtDrwxAZqUNkpA4REWHQ68MQERFGwRghhBASYmzTmrp06WLfFhMTY//viooKdO3a1ek2GRkZAICTJ0/KMEIiOoMB2LEDWLIE7JIlAADG+ZNRwGoFFiwAXngBEKFfkeMxFQy9Xq/KaUy+YllWlClwYk1HdMQ3LqPRKMq++QKaYBcEkGpFQqFwJtjxarXakAm/PIVQzc3Nqgu/PN1OjZV8FH6RTqnF1IpD28/hx/zDKPzmFBrrTEjrk4Tfzr4OPbJS0Gq2IFwfBgbtf4wc/iYxYMAy3IsHwzA+h2EMc+WPm1ug5nJd+4uTQ2DW1saisdGMxkaz/b5tNJorwRj3bxiiosIRHq6VdK47IYQQDmtlwVrFqdkSaz9E3VJSUnDx4kXU19fbt6WmptpP1I4ePeoWftmqxaSouggFubm5yM3NVf1qgx6FhQGLF4OJjwfmznW+zGIBli8HRKzqE2slQYPBENLhl8ViEaX5uRTHHt97dbFCNr7AI9gwKdhpk0KEwpJgK9W0Wi3v82m1WoN6LuQOv6T8/ZOiQb8aVyWmnl8hKDc3F1lZWcjOzlZ6KCGj6lID1r+5C3NuWo2JMUtwW+QSPHXbB/jy3f24fK4OSRlxiE+LxofPbUNjTTP0GgtS1/4DjNlkD76clhdvn9/CWoWDL5blqsb4vgTxNDxmGAZ8+ZXj/trarDAazaioMOL8+ToUF1fhwIEy7N1biiNHLuP8+VpUVzehpaVNlS9EhBBCSGdjm+547Ngx+7bw8HD79nXr1rnd5sMPPwQAt1Css8jJyUFRUREKCwuVHkrwCgrc30JqNEBBgah3I1aD/ri4OFH240qq96WuJ/PNzc2i7JevgbwUxHpe+PYjRY8yMQg95mBDS6FKtWADRimOXU8hlJTTCNW4OqUUqPIrBOXk5CAnJwf19fUwuDbKJAC4F6OfvjiK/Ld24dcdJbBaPL84lRyuQMnhCgDAp4t+wPDSAjxydg025Z/HsavG49KpGsz9aCrCI33/pMOX10PW/n+erhPINEsWLACLlUVDYwsaGlvsVWwaDYOYmHDExkYgOjoc0dFchRghhJDAcVPbxdsX6fhuuOEGfPPNN/j+++/x8MMP27dPnz4dhw4dwurVq5Geno57770XRqMRa9aswb/+9S8wDIPbb79dwZGToJnNwKZNcIsgrFZg0ybucpGmlgVb5WMjd7VPsMLDw50qZerr6xEbGxv0fuUKv6Sk1vBLqsovofDLZDIhIiIi4P3KXYHa0tIi2b4DfZ0Qo5pSTqE1WkK8OFdUjuU5X+LAD2cD3sexnedxH7hP3YZdLsT2iKuRMTAZzQ1mr+GX3ycsDtdnGL7b28q/+K/veJ/Ot2Vc3lCx7XEYF4jV1ZtQV2+yXysiQgt9pA4J8ZEwGCIQERFG0yUJIYQQCU2ZMgXz58/Hl19+ifr6entlzezZs/Huu+/i7NmzeOmll/DSSy853S4hIQHPPfecEkMmYikoAFpb0ZKejstz58Lcowf6sizw9NNASQl3+fjxotyVWO/nXE+OxeqhJVXlV0REhFP4JdbqiTSDIvQqv4SC2+bm5qAKSaQKboUa9AcTtnk7bqnyi5AQ0VhvwuoXtuHf/9iLtjbnFwp7Ty5fMABYQA8zrsMpAMB17Ekc+0N/dL0mE4YunhsMuq746K8r43R8I+EcYtl6jdm/9/qay7oXjTncDctylzeb2tBsakNNDVcSrtUySEiIRHx8JAxxeqoMI4QQQkQ2aNAgfP/992hra3OqJomKisL333+P+++/Hzt37nS6zeDBg/Hhhx/aG9+TEDVoELBiBU5efz3YyEhu2+DBwB13AO++y12uci0tLaL0E5Oqkio6Ohp1dXX278WqmpE78FAjoaAk2EBU6PEHW3UoFJ4Fe0xIdexKcSx4Ox8O9OdG4RchMrBarfh69X7kPbcVDVXOzf9sv7y2X3LHAIwvDMtAFV7COuhZbt63DlaEg0vWwyytuP+dmWDDwqEJY4CoKFS8+zE0Vw2ATqdFeLgWOp0WYWEahIVpnPZvW93R8V+Addve2mqBydQGk8mClpY2tLRwK01are5hGgMGVp9Xm+SZ4w/mSg2YYxVZ+3NjdWiuX1nZhMpK7lOy8HAtEuL1iI+PRFycHmFtZuDNN4G//AUQqZEqIYQQZ9nZ2dBqtfZ2B6TjufHGG3m3Z2ZmYseOHTh+/DiOHDmCtrY29OvXD9dcc43MIySSSEkBZs8Ge/iwfRPLsmCiooDZsxUcmO/q6+tFCb+k6mMkVqN/uYSFhUna00lMQkFJa2trUCtBShV+CQU0wYZfUk17DA8PFz1YkypY9RZ+iVUhKhYKv0hIqasyYsl9+dj3zWney11/uVx/4fhS7xpEwwg9eqKKd58RNZVXvhk1Ct1GDAA8NP203R/3j2+/7J4qbrmG9raArA3NzWY0NrbCZGpFW5unFMx9rqSt0ssVC+fnxnVKZUuLBZcuG3G5nFt2uet3/0Hm88+gOSkV+gf+rKoXNUII6SgKCwslazJNQsOAAQMwYMAApYdBZGC1WkOqiqKyshJdunQJej9SBT5S9SiTil6vD5nwS0hTU5Mk4Vew0x6Ffq+Cfb6lDL/EmqZrI9V0XW/ngGKtsioW9YyEEA9aW9vwaPY/cOZQpfcrtxP6ZdRoGXTrm4js2/oi+9a+GHZjT0Tp/xdYsoT7Yhiu4aiNVst9v2AB8MIL3BLVMtJoGISHhyE8PIw3c2tttcBoNKOurgVGYwuam9ucpn/aq8X85HwT1mEbg5gtmwAATR98ikNDbkZyUhSSkqIQF6eHRkNBGCGk87GvBizSvgghnUtNTQ2Sk5OVHobPxKokcV1xT6wAMJSCRIALv+rr60Xdp9x/S5qamhAfHx/w7YWqnYL9WUp1LEgVfkkRFkk5pdbTNM2WlhYKvwjhZTK5TaVjWRZP3f4h9m3jenDBNsXcCtfWWO3lS/y77pIRhzseuxaTHhyBpDSBlV4WLwbi44G5c523WyzA8uXAnDmBPCrJ6XRaxMdz/bkctbVZ0NBgRn29CUajGQ2NLfDldc/2d9Kx+svxb6em2YiE3T8CABJ2fQ9rQyPKWq24dLkRGg2DxIRIJCVHIyFeD61WnBWGCCGEEEI6skuXLoVU+CUW1/BLrIotsVa5lAvfqoPBThmTMvziCzyam5uD2qdQmBRseCVV+CIU+AQ7I0aK8Up5LHiastvc3IzoaM99s+VE4RdRj/XrgWeeATIygD/+ER/+7w94f+EP/P26HP+eseANvvpenYbfPzUGN04bhDCdjy+aBw5wlV6OL75aLbc9xISFaZGQEImEhCuhmMViRU1NM6qrm1Df0ILWVvcX7SuhF/cHV19yClc98zA0Ju4PmqatFZpW7gVO02rGiOk3whrGvVGx6iNR9Mq7qOjRGxoNA0NcBJKTo5GQGIlwX38GhBASilw/KQh2X6TTaGtrw+bNm7Fjxw6cPn0aDQ0NXisKGIbBt99+K9MICZGOa/gVar26xMIX+rW1tQUVBkpZ7aPVat32L1UD+WCDTKmCUKHnV42ValKGX57G67jiqhpQ+EXU4/PPAQC1/28tps4stodZrg3s7VwCL42WwbW39sH9z43DkLGZ/t+/2Qxs2MAFXzodMGsW8P77QGsrt/2f/wSCmMeuBlqtBsnJ0UhOvpLANza2oLKyCXX1JjQ3t9rPuewN+ROT0RYTh7hzp3j3GV5VYf/v+kHXoC05BQDXq6ym1oSaWhMXhBkikJAQhZTkKOgoCCOEEELw448/YubMmSgpKbFv83SSYvsgkHptko7CNfziq4DqDPiqfZqammDw1BjYCynDr/DwcLefXbD3JxT6q7WKT+i1OtjxegqTLBZLQOGY1MeCUNWf2vrYUfhF1MFoBPv112AARO34FnrtCJgY56DJrZk9uFUPew3pgr+snISrx/cKbgwFBUBjIzBgABfEDRkCPPkkMG0aUFzMXT5+fHD3oUIxMRGIibnyRqO11YKKSiMqK41obDSjLToOv77zObqveRPd17wFMAwYhxdQVqMBWBbnZ/4FJTP+B4wuzK0Kz2plUVNjQk1NM06frobBoEd6WgwSE6OoRxghhJBO6cCBA5g4cSLMZjNYloVer0e/fv0QHx+v2pM9Iq74+HjU1tYqPQxFuZ6Uh1rll5Q9ypqbm4MKv6Ss9gkPD4fRaBR1n1JNI5SKVJVfnqY9mkymgKYRevtQJRiexiv2qpXBovCLKKO4GJgyBWh/0ay/XIe49mQ4HBZ8aHkLbeBeOEzQYb7297jAJDntYuyUq/DE6xOR3itBnDENGgSsWAE8/DAQFcVtGzIE+OUX4N13ucs7AZ1Oi67pceiaznXXb24242JZI8pznoIlJg693nrJ6fqM1YrTf5mPsukPAj7M+mFZFrW1zaitbYZGwyAlOQqpabGIi41Q7R83QgghRGyLFi1CS0sLIiIisGzZMsyaNSvkTvxJcFJTU0UPv6Ss8NDr9aJPY3Idr5SVX1JUTYoVVPPtp7GxMah9SnksSPFzEqr8EuNnptVqJWtQz3dfUt0+0B5ano6FYJ9fT+N1rQ5UGoVfRBmpqYDBABw9CgBwXcQwCVde7I8gA9WIsX9/65+H4dFXbkFClxiIKiUFmD3bfXtUFP/2TiIyMhx9eicCSIR1xTmw7T3RbGsMQKNFdHGRW2821mXaKuAejFksLC5dNuLSZSPCw7VIS4tBapcYREaG1vLUhBBCLb+Iv3766ScwDIPnn38ejz/+uNLDIQKkrJ4Rq7m7IylP8OPi4iTv4SPlKo1ms1n00CZcpJYofAFEsFPGpAy/pDh2paz8Egq/rFar6JW2wTas9xZ+BcLT61iwj9/T41Xb6tVUU00UYYmOwcu9Z2MtMw5WABY4v6hZwMAKYC1zI2ZrZ6GJicDdT2bjy+rn8Ox7d4sffBHvzGZoNn4BxmIBo9MBjzwC6HRgrBYkb98CTZsZLMtNcXR8neOCMNbpxc/2R4xhrjTYN5stKCmpQ+HeUuzbX4qLZQ1obVVXqSwhhBAiFluIMHHiRIVHQjypr69Xegh+kbLSIi7O9eNq8Uk5C6CpqUn0fYoVfvEJNrySMvwKtRUJhcI6KXpSBRsMegq/Al1UwNOxIGVYpzYUfhHZNTe24A99l+Pbfx3DB2E34f9pboXWpUmUFiz+obkNH4SNxx+eH4ctjS/gf5ZPRlRs52yCqQqOPdH27QPy8sDs2wf07w9tkxHXtV1Anz6JiI72/oLvGoS5vs8xGltx8mQVdu2+gCNFl1Ffb1LdJweEEOLIMegX48sfTU1N2LhxIx588EEMGDAAer0e0dHRGDZsGF588UWPU2fWrFmDkSNHIiYmBomJiZg0aRIKCgo83t/OnTsxadIkJCYmIiYmBiNHjsQHH3zAe93Lly/jvffew913342MjAyEh4cjPj4eN954I9auXev3Yz179mz73w3+r7S0NL/2p6SePXsCUN+0EOLs/PnzSg/BL8GuuOeJlEGPjZjhl+tJeUNDg2j7tpGiAkosUlYBShF4SN2UnY8UlVTBhkmefgcC/XshZeVXKIVfNO2RyOpySS3+nPUm2sxWe+DRh70ECxhowNqn0lnBYEz3Zjx8/AWER9BhqgpeeqJphw5B1xSuV5jFYsXl8kaUlTWgqUn4Rdq2oqTwazyLysomVFY2ISIiDD26G5CaGgOtlnJ7Qgix+eSTT/Dwww8DAAYOHIg777wT9fX1KCgowMKFC/Hpp5/ixx9/RJcuXZxuN2fOHKxcuRKRkZG49dZbYTKZsHXrVnzzzTfIz8/HlClT3O5r/fr1mD59OqxWK8aNG4fk5GR8++23mDFjBg4dOoQ33njD6frz5s3Dxx9/jLCwMFx77bUYO3YsSktL8dNPP2H79u348ssv8dlnn/n95jk1NZW3YiqY5tBymzJlCo4ePYrt27dj9OjRSg+HdBBSVDfZuJ4kS9FDS8z96fV6p6bswfbQ4qPm1SmlDJM6UviVkOB//2hPYZIYz42tjYyrQANNKcdL4RchPI7sKsFfblzttC2MteAG9hi0YNEKDbYwV2MiewA6WHF19S8AI92LIPGTHz3RtFqNvWm+xWLF5cuNKLt0JQhj2SvTHa+8x2EBuL7hsXcWQ0tLG06crMKJk1VIS41BRoYB0dHSfwJJCCFqp9Pp8Mgjj2DOnDkYOHCgfXtZWRkmT56MX375BXPmzMEnn3xiv2zbtm1YuXIlkpKSsGvXLvTr1w8AsGvXLowfPx6zZs3C+PHjER8fb79NdXU1HnjgAVgsFqxfvx5Tp04FwFV3jR07FkuXLsVvf/tbjHdYGTkpKQkvv/wyHn74YaSkpNi3FxYWYsKECcjPz8d7772HRx55xK/HfNVVV2HNmjV+3UZtZs+ejTVr1uCNN97A9OnT7ZVgRFhubi5yc3Nla1wdiqQMv1yZTCZERkbKdn/+ioyMdAq/pAhXxKyGEwo8AsVXJSTl6pSANIGoGISqsQLtYSflNEKAC5rFfJ3ztK9gxyvFFFipUPkEkcXX7+9zC74AYBB7HlEwowRJeDzsEfzn2odh/mk30L8/0NDATbUjIU2r1aBr1ziMGN4N14/ugT69nadGXmmOb/tD6fhH3/0PKNPSgrDlS7Fv52ns3XsB5eWNsFppSiQhRFm2hvdiffljxowZyMvLcwq+ACA9PR25ubkAgA0bNjj1Nlm2bBkA4IUXXrAHXwAwevRoPPbYY6itrcV7773ntL9Vq1ahvr4ed911lz34ArgqrNdeew0AsHTpUqfbrFy5En//+9+dgi8AyM7OxrPPPgsA+PTTT/17wB1ESkoKvvrqK0RGRuK6667Du+++i7q6OqWHpWo5OTkoKipCYWGhrPfLtLQgefVqMBJNKbTtHyI0k5dy2qMrtfdDC2RVPH+J2Sxd7BCBL/yScnVKofv0lZQtToSeWyl6aInxHIs9ndbTcytljzJv9y230InpSMh6c/aX2PSPvbyXnWVSkKu5DZs1I/BY7hTc+Ug2d0H7VDoMGiTjSInUbEFY165xaGuzovRiLS5ebITZbGkPua5Uf11ZPdJ5Hynbv0afvP9DS0oayifchaKjFdAwFejaLQ4Z3eKg16u39wIhhMht2LBhALg3+FVVVUhPT0dzczO+++47AMC0adPcbjNt2jS8+eab+M9//oN58+bZt2/evFnwNpMnT4Zer8e2bdtgMpmg1+t9HtvFixf9f2AdxNChQ7F9+3Zcd911eOyxx/D4448jOTkZUbb2AgIYhsGpU6dkGiWJ27oVacuXAxkZwIgR4u24rAz6oiLE7NiBtLffhjUxEZpJk4D0dO5L5SorK5Gamqr0MATJESCIOeUrIiJC1B6AfNU+UlfpNDU1ydIbzl9CP6dAq6s8hV9iHBM6nU7UlVXb2oQXEQv2mPAW9lksFtVUh6ljFKRDslismHfL+/j1J+FGoXVMNL6OG4v3Dz6J1B7xVy7gmUpHOpawMA0yeyQis0cijMYWnCupQ1VVE6xWtn0VSOfUyzZVMuWHrwEAKT9+jfIJdwEArCxw4UI9LlyoR0KCHr17JSKWFkcghMiKBSDWp5vifUp6+vRpANwb6cTERADA8ePH0dLSgpSUFGRkZLjdZvjw4QCAQ4cOOW0/ePCg0+WOwsPDMXjwYOzduxfFxcUYOnSoz2MLpEn95cuXsXDhQpSVlcFgMOC6667DnXfeqcqTLk/Wr1+PBx98EA0NDfbFDsrLy73eTo3Tijqk9nAqfv16AECXf/8bGD9evHAqLw99Fy+2f6uZPx+YPx9YuBBYtCj4/UtMTRUdfMQ+4eZ7vGJWfun1elH7kvEFHlKHEM3NzU7T5dVC7L5UoVb5JXVY52nKrtlspvCLdGzNRjNmDX0LFecbrrRt4pnVduM9WXj+o2nUwLyTi46OQNbALrBaWVRUGnHhfB0ajWaHajBAo2HANBmRuOdHAEDS7h+gaW6CNdLx03EWNTXN2FdzEXq9Fv36JiExMYpOEgghndbKlSsBABMnTrQ3Zi4pKQEA3uAL4KYKxcfHo6amBg0NDYiNjUV9fb19Sp7Q7TIyMrB3716cO3fOa/jV2tqKd955BwBw1113+f24jh07hhdffNFpW48ePfD5559j5MiRfu9PCbt27cLvf/97e+VBZmYmhg4divj4eFFPqEkQXMOpH3/kKr/ECqcefRSnu3VD7/aed1atlruP3r2D3zeRJfAQ8z0mX/P8YHpo8Y1XzBCCL/CQc9qtP8QOXzyFSWIcE3KOV4zfE089ykwmk9dqZrlQ+EVE11hnwqyhb6H6stG9q5zt9ZEB3tj6Z1wzjv64kys0GgapXWKQ2iUGLeY2lO/Yj6QH/wiNiVuGmGlthaaV61mjaTXjuvtuAtv+yYglIhKHX85Dc/deAACTqQ2Hfr0MrZZB3z5JSEuLhUZDIRghRBqB9OrytC/AvZ9ORESEXyuLffXVV3jvvfeg0+mwZMkS+3ZbZYGnN6PR0dGora21h1+O1QhCt7P112loaPA6tvnz5+Po0aPo1asXHnvsMZ8eD8A9B48//jimT5+OgQMHIjIyEkeOHMGSJUvw1Vdf4bbbbsOBAweQmZnp8z6V8tJLL8FiscBgMODjjz/GpEmTlB4SAYDiYmDKFMBoBCwWtBoM0Dn2YktKAlatAt5/H4iOBjZu5HrVBrJ/AN0dGrJrLBZg2jTAVsEYyP6JndgffvJVtoh5H3yVqy0tLT5NI+fDF3iIWVEUFhbmNk2zublZtP2LSewPFDxVPYpxX54CKYvF4ndgJXX4FRYWJhh+qemYoI+ViKgsFiv+esv7XPDVzv5Hof01ggljkH/+KQq+iEcR4WHofu0ARKanQH/5IvSXLyKiusL5OtUV9svaYmJhTkwG4NgvjIHFwuJ4cSV+3H4Gp8/UoLWNVogihISG7t27w2Aw2L9eeeUVn2977Ngx3H///WBZFq+//rq9v5YafPbZZ3jttdeg1+vxySef+PWJcHp6Ot555x3ceOON6NKlC2JjYzFq1Chs3rwZf/zjH1FbW4v//d//lXD04tm7dy8YhsHixYsp+FKT1FTAYABKSoDSUufgCwCqqoDSUu5ygwHwd9qu4/5LSqCrqnK+/NIl+2UB7Z9IRorVIh3xVfsEs3qnHOGXK7WuxCp2EKpk5VcgvcA8/VzEGK+n48pxsR2lUfhFRPWPp/6LM7+Wg2EY+xcAMBqGm/aoAT45PgcJXaRffYV0AAYDmB07gAULAIYB6/JJilWjAcswODvjLzjw5r9giY4DwIBhbFUYV0IwADh3rgY//XQOR4+Vw2QSr6EoIYTY+jWJ9QUA58+fR11dnf3rueee82kspaWlmDhxImpqajB37lzMdumhGRMTA8DzSZWxvRolNjbW6Taebud6Gz7fffcdZs6cCY1Gg08//RSjRo3y4RH55u9//zsA4L///a9o+5SS7XkcO3aswiMhTgwGwPG9h+uJoVbLNSFduJC7XlycuvZPJCN1+MVXgSN2+CXmdDp/KpE7mlALv5TsUaam3oAUfhHRFHx5HBv/8bPg5YyGwfuHctClu0HGUZGQFxYGLF4MLF0KxuWFW2O14tQTz+PsrDlgff1jzgKXLjVi1+7z+OXARTQ1UQhGCFGnuLg4py9fTjSqq6tx66234ty5c5g1axbeeOMNt+v06NEDAHDhwgXefRiNRtTW1iIhIcEeZMXFxcFgMHi8nW270JTDwsJC3HXXXTCbzXj33XcxZcoUr4/HH/369QMAlJWVibpfqfTqxU3TD+bklkjE8b2H64mbxQIsW8b1/Ao0SJB6/xIKdAoeHyVOij2teueN1FVNfOGX0WFarBg6c/gl5tRHJYJQm0CmEUo9TdPTcSV2771gUPhFRHHpXC0W/n6dx+u89eOD6NE/RaYRkQ7nwAHu01BHWi0ya84iOTnS5cqM06cuLMs6L8TW/t+1tSbs2XMe+/aVoqlJPSW5hBASiMbGRtx+++0oKirC1KlT8e677/J+Aj1gwABERESgoqICpaWlbpfv378fANya1tumTtoud9Ta2orDhw9Dr9ejP09/oqKiItx+++1obGzEsmXLMGvWrIAeoyc1NTUArvQeU7upU6eCZVlFK9X27duHV199FVOnTkVGRoZT1b4na9aswciRIxETE4PExERMmjQJBQUFHm+zc+dOTJo0CYmJiYiJicHIkSPxwQcfiPVQpHHgAH9l1oED4uy/oMBp/ywAaDSAl+dSSXEiVqJJHSDwCab/UDDBmS/4fvdce2r5gy/wEDOIEHMKpRxBqNBjD+Q4lHq8oVb55em4UtPCYxR+kaCZTW34y03vgbUIvwgs/nw6Bo7kXx2KEK/MZmDDBu7TUJ0OeOQR7l+LBbr/bMLgfokYc30P9MyMh1bDuE13BAAWPMdn+6a6ehN27zmPPXtK0NiozlVqCCHEk5aWFtx11134+eefcdttt+HTTz8VfDMaGRmJm2++GQDw+eefu12en58PALjjjjuctk+ePNnpckdffvklTCYTJkyY4FYZcvbsWdx6662oqqrCokWLMGfOHL8fny/Wr18PABg+fLgk+xfbvHnz0K9fP6xYsQJ79+5VZAxLlizBc889hy+++II3COUzZ84czJo1C4cPH8aECRMwcuRIbN26FePGjcPGjRt5b7N+/XrceOON2LJlC4YOHYqJEyfixIkTmDFjBv72t7+J+IhEZDYD+fnOlVlaLfdeJD+fuzzY/W/a5LR/BgCsVmDTpuD3LxFP05r9pUTlV51rDzc/BBNEqYWY1U9iVpHJcSwIjTeQ6lslK78COQ49Pb9ihFOexqum1YvVMxISsl6euR7VZY2Cl//PikkY89urZBwR6XAKCoDGRmDAAGDfPiAvj/u3f3+goQEoKIBOp0XPngkYOzYTgwd1QWRkGIArFV8M95bSLQRz/N7Y1IqfCy9gz55zFIIRQkKGxWLBH/7wB3z33Xe44YYbsGHDBt5VwxzNnTsXALfi4IkTJ+zbd+3ahby8PMTHx+PBBx90us1DDz2EuLg4bNq0CRs2bLBvLy8vx9NPPw2AC3QclZeX49Zbb0VpaSnmzZuHhQsX+vSY/vznP+Oqq67CF1984bT93XffxbFjx9yuv2HDBjz77LMAgJycHJ/uQ2mxsbH49ttvMXjwYIwbNw7PP/88Dh06FNCn+oEaPXo05s+fj3//+98oKyvzOo1p27ZtWLlyJZKSknDw4EFs3LgRW7Zswfbt26HVajFr1izU1tY63aa6uhoPPPAALBYL8vPz8cMPPyA/Px/Hjh1D3759sXTpUvzwww/SPchAFRQArifFtmlvRmPw1VkFBUBrK5CZiZLXX8fJdetQ8vrrQI8eXPAlQvWXFBUXYk51k6M5umt1UjCVX2pt5u4PMY8JOcIvqVfTBMRvIC8GT487kPuWOvwSu1JNKuqbSE5Cyn/e3Yudm9zfhNrcO/d63PVotowjIh3SoEHAihXAww8DtlXBhgwBfvkFePdd7vJ2DMMgJSUGKSkxaGgw4fTpGlRXX3mj4xiC2f7blbGpDT8XXkB0VBgGDUpDTExo9TQghMiPW2RDvH354+2337aHRMnJyXjiiSd4r/fGG28gOZlbFXfChAmYPXs2Vq5ciauvvhq33HILzGYztm7dCpZl8f777yM+Pt7p9omJiVi9ejXuvfdeTJs2DePHj0dSUhK2bduG2tpazJ07F+PHj3e6zaOPPooTJ04gKioKlZWVmDlzptu4kpOT3XqTlZSU4Pjx425VGh9//DEeeeQRDB06FP3794fVakVRUZE9EHvqqadw9913+/rUKcrxk3KWZfHqq6/i1Vdf9em2DMOIMgXrmWee8ev6y5YtAwC88MIL9h5rABeiPfbYY3jzzTfx3nvvOYWgq1atQn19Pe666y5MnTrVvj01NRWvvfYapk6diqVLl7odO4obNAhYvBinevUC2x749O3bF2huBr791um9R8D7b39vU3/6NADAlJUFPPGE23ubQEVGuraFCJ7ribLVag24skPqaYQA16PMsVKmpSXwDzflGK/U1Fr5JVRJJeZ9iBl+yTFlV6PRiHY/UlfWear8UlPDewq/SMBO/XoJK/+yWfDycfcMxCMv3yLjiEiHlZICuKxWBoALwvi2t4uN1WPYsHQ0NbXi9JlqVJRfaRoqFHzZsOyVECwqKgyDslIRGytek1dCCBGLrdcVALdKKUeLFi2yh18AsGLFClx99dV4++23sXXrVoSHh2PChAmYP38+rr/+et593HPPPdi+fTteeukl7N69G2azGVlZWXjyyScxY8YMwbE1NTVh7dq1vPvMzMzkbczP5+GHH0ZKSgoOHDiAb775Bs3NzUhJScHUqVPx+OOPY8KECT7tRw1cTwjUdILAp7m5Gd999x0AYNq0aW6XT5s2DW+++Sb+85//OIVfmzdvFrzN5MmTodfrsW3bNphMJlGbqQctJQVYsADNhw9f2TZ4MPfvmDHi7D+A9zb+cFylVSyu4VdLS0vAIZsc0wijo6PR0NAgyr7kCL8YhlH9a4GNUODBsqzf1URCj1mOsC6QQFSOY0Gn0wUV1srJU/ilpopJCr9IQJoaWvCX8e8B4FZxZK0styxz+wvXVdnpWPDRvUoOkRC7qCgdBg9KRUvfNpw9V4OLpQ32yi/e6ZDt/2n7O9xkbMPPhaWIjg7DsKFdERkpXoNPQkjHwFpZ7m+hSPvyx6JFi7Bo0aKA7mvmzJm81ViejBkzBl9//bVP1w10OpvQ7e677z7cd999Ae1TbXydAqoWx48fR0tLC1JSUpCR4d7H1dZr7dChQ07bDx486HS5o/DwcAwePBh79+5FcXGx2yILnVEwlVSupKj8clVbWxvw/chxUizmcyDHeLVaraTBipjTCIX21dra6nXqvSuhCic5GvQHEjDJUfkVFhbWIcIvNa32SOEXCchrD29ES3MbGE37ix4De1IQHhmGt7c/otzgCBEQERGGAf1T0LtXIs6fr0NJSS2s7JXpjwwYsDyt8W3fG42t2FlwDgZDBIYNTUd4OL2EEkIICUyohV8lJSUAwBt8AVyFTXx8PGpqatDQ0IDY2FjU19fbp64K3S4jIwN79+7FuXPnKPwCYDQaRWsqL0f4VV1djfT09IBuK0fll5grEsoRfoWHh4sSfilZPdbU1OR3+CU0XjGDEzFXe5TjWIiIiIDRaPR+RRVQU8DlCTW8J347+vMFFHxZ7LActnPq/8/Cx5QZGCE+0um06N07ETfc0BP9+iZB0/56zbKs9147LFBX24Lt289i3/4LsFjkX6abEEIIkVtjI7e4UZSt9yaP6OhoALBPM7PdxtPtXG/Dp6WlBfX19U5fHdW5c+dE25ccq6wFE7LIEX7J0ZdKTHwLCgQShskVfvFVfzn+3vtKaLxihpdiBjRyVX6FCk8VhWqaxkvhF/HbqgXfArDNSUf7f2sAhkHPwV2Q0SdJwdER4jutVoPu3eNxw9heuOqqFOj1nv8osiy4rLf99b2m2oTvvz+NY8fKYeWbpmQyAa+9xv1LCCGEkIC88sorMBgM9q/u3bsrPaSQIMVqj2JyDXWkqB4RMwCUI/Dg63sXyAqVcowV4A9oxJxGKGYAJOa+hCq/5FpN05/KM7nCJ6HfNQq/SMg6c6Qcv/7Elb27HscMw+CdnQ8pMCpCgqPRMOiaHodRozJx1VXJCAvj/8N1pdoRTiHYhQv1+O67UygpqXZ+gV+/HnjmGWDDBmkfACFEcSzY9upREb7cJl8Tojxb8/SmpibB69im6Nim7Tk2XBe6nett+Dz33HOoq6uzf50/f96/wXdSag+/XCu/1D51SqnKLzErqcTGV5kVSFgnNF4xAysxjy8lG/QD/q1QKdexIDReNa2SSuEX8cuq+dsEL7vr0REID6dG4CR0aTQMunU14IaxvTCgfxKc/0ay9n8ZxuFbhxCsuLga3357Cpcucf1N8Pnn3L/5+VIPnRBCiEptkPgDkIsXL2L37t2S3gcA9OjRAwBw4cIF3suNRiNqa2uRkJBgD7Li4uJgMBg83s62PTMzU/C+IyIiEBcX5/TVkURHR4NpaUHy6tVgQqTBtRhcT4r97ROlNCnCRb4AIZC+T3JVfvGFdYGQo/JLzJ+Xkj3KAP8CRrmOBaEpqmoKtSn8Ij67dK4Whd+cAsBT9aUBnlw2SYFRESI+jYZBRgY3HbJfv0RwH+I4/sFkwNhePXn+9h0+XIHvvzwE1rYa2ldfASHSsJIQEhiWFfeLdBzTpk3D1VdfjXyRPwg5f/48nnjiCfTp0wfffPONqPvmM2DAAERERKCiogKlpaVul+/fvx8A3JrWDxs2zOlyR62trTh8+DD0ej369+8vwahDQ48ePRC3dSvSli9H3DbhD5o7GteTcjka9PPdb6Ck6KnGFxQEMo1QrmofqcMvNQUnjqjyy53QeOUK33xB4Rfx2T//vlXwsvkfT5NxJITIQ6vVoEf3BIy7oRf69kkEwziflDJMewjGAlEXzmDUAxMx5r4bMea+G3H9jAlgzGbuii0tQN++QGYm95WVBRQXK/KYCCGEyKtPnz44dOgQpk+fjl69euH555/HkSNHAtqX0WjERx99hEmTJqFPnz74f//v/8FisaBPnz4ij9pdZGQkbr75ZgDA57bKZge2cO+OO+5w2j558mSnyx19+eWXMJlMmDBhAm+vo06hrAzagwcRv349AHD/7t8PlJUpPDBhUoVUch0D/gQHnsgVfgUSXig57TEQQj2sxA6/pJ4KLFePMn8CUSX7vwHyLLzhK/WMhPgsNzcXWVlZyM7Olu0+a8qN+GnTMd5PpGPjI3DDnQNlGwshctNqNcjM5EKwPr0TwTBs++8CC6uF+51oiU9GW3QsIssvIrL8IiKqK5x3cukSUFLCfRkMQFqaMg+GEEKIrIqKivB///d/SExMxLlz5/Dqq69i6NChuOqqqzBz5kzk5uaioKAAJ0+eRFVVFaxWK4xGI86fP49Dhw4hPz8fzzzzDG666SZ06dIFM2bMwJYtW9DW1oapU6fi8OHDuO+++2R5LHPnzgUAvPTSSzhx4oR9+65du5CXl4f4+Hg8+OCDTrd56KGHEBcXh02bNjlNAS0vL8fTTz8NAJg3b54Mo1epvDxgxAjE7t0LAIgtLARGjOC2q5RU006lmvboevIdSA8tPlKsxidWUKD0VDd/CYVfYgcnQmGaWCuPinlMeHrsZtsH7D6QKwgVem7V1PA+dNbPJHY5OTnIyclBfX29vY+C1PKe+y8AuFW+AMA7ux+WZQyEKC0sTINevRKRkWHAhQt1OHmq2n5ZW3Qs9i7/FL0+zkXvj3PBMgw0Dm88rBoNGJZF7f88hYSlLwMhtHwxIcQ7W7N6sfYFANnZ2dBqtfa/+yQ06XQ6PPXUU3j88cfxzjvvIDc3F+fPn0dxcTFOnDiBDz/80Kf92I6LiIgITJ06FbNnz8bIkSODGtvmzZuxZMkS+/e2E6pRo0bZt82fP99evTVhwgTMnj0bK1euxNVXX41bbrkFZrMZW7duBcuyeP/99xEfH+90H4mJiVi9ejXuvfdeTJs2DePHj0dSUhK2bduG2tpazJ07F+PHjw/qcYSc4mJgyhSuJYLFAiQkADU1Vy5PSgJWrQLefx+IjgY2bgRUNC00JiYGly9fFn2/Uk1xi4iIcOqR5GnRBn+IFfxIQempbv6SK/zS6XS8Ddibm5t9/nl6em7FPIY9VampcbXHUJj2SGdfxJ3JBLz5JvCXvwB6PYz1Lfhu3RHeHiT9hqchrXuC/GMkREE6nRa9eiWia9c4nDxZhYsXGwAArDYMp/88G23RcRiQ979Ot9FYrTj26N9RMnkmmO/PIDs7A/Hx8vS2IISEpsLCwg7X2Lszi4mJwdNPP42//e1v2Lp1K/71r3/h+++/x9mzZ73eVq/X47rrrsNdd92FP//5z0hMTBRlTBUVFdizZ4/bdsdtFRXOlcwrVqzA1Vdfjbfffhtbt25FeHg4JkyYgPnz5+P666/nvZ977rkH27dvx0svvYTdu3fDbDYjKysLTz75JGbMmCHKYwkpqalcFfjRo/yXV1Vd+e9Ro3yuFleq2sdisYhy0i9V+BUZGekUfgXSQJ6PWP2upOBPOBIMocDDbDb7VcknNF6xpynqdDreZvEmk8nnv7eewiSxqwE1Gk3Qv9eebi/m80uVXyQ0rV8PPPMMkJEB/PGPeOepLQD4q75WfjdLgQESog4REWEYNCgVmZnxOH68EtXV3B/T2FNFsGq0YKwW2BaGZDVaxJ0+av89+vnnC9DrNRg9OhM6Hb0UE0JIZ6HRaHDbbbfhtttuAwCUlpaioKAAFy5cQEVFBaqrq6HX65GSkoKUlBQMGTIE1157rSRVJjNnzsTMmTNlud2YMWPwtW0hmM7OYAB27ACWLOG+AKc32axWC8ZqBRYsAF54wedqcbkCD9eT3MbGRlFmo0jVjyk6OhrV1Veq9cU6GVdz5RdfdZMUhCqzGhsb/Qrp5Qq/hAJLf1ZPlKvyy7a/YMMvT+MVs7JOrYsTOKIzLuLO1sQ0Px/mqfdi68eHwLJc+OVowh8H00k7IQBiYiIwYkQ3VFU14fivF9Dlp2+gsVpgDQtD6a33oOs366Fpa0OXn75B0ZwlYMO4T8JMJiu+//4M0tKiMXRoV4UfBSGEECV069YNv/vd75QeBpFbWBiweDEQHw+091KzYSwWYPlyYM4cv3YpVt8ib1wDiaqqKlWHX1JVaEkVfjEME3RAJ1cQKsRoNKoy/PJUqeYrOSu/wsPDg/699hSeybU6pVpQw3vizGgEtnCVXvjqK6x/lVvh0X2VO+CZd+9WYICEqFdSUhRGs6UIMzXB2L039uR+gaNzXsLut7+AMaMXwpqNMBz5xe12ly4Z8c03J3DpUr0CoyaEiKK955cYX7x9BgghHVNBgdMnzFy1uIbb7iexVjH0l1g9tKQKv6QKqaTaL1+I4G+YJVfllxB/ViMEhAMasY8JoeoksVZPFLv6SYxFIDyFdWI+v2quhLRRfzxHpOXYcBMAzGbA9svf0oKJL03HzVYuI22BDgsi/oiL2mRERKn/4CZECczgwcCKFdA/8CBSK1pgPF2Dxl4DsPudTej21To0ZvYTvO3Bg5dw5MhlXH99T0RG0u8YIYQQ0qGZzcCmTU6BNwMAViu33WwG/Dj59Tdw6CzEbpou9X4jIiLcqn1MJhOio6N93oec4RdfpZq/Qaxc/erEqE6SaxohIE6gJFdYR9Meifp5abiZYGmw//dRTQbqtLFgGAbT/nKdXCMkJLSkpACzZ0MLoHdsDDIyDDh1qgoXLgAldws39bX9IW1rY7F9+xkkJUVixIgMyT4FJYSIS8yCLSr8IkQdJG/UXFAAtLYCmZkoefJJmHv0QHhJCdKWLkX4pUvc5X6shKlU5ZfaSfVeSqqTfb1ej8bGRqdtjY2NfoVfcq6wp9Pp/Jo2yEeupuhSh0lyhl++LjQhZ48ynU4n2/TrQNC0x87O1nBzwQKu5NrlF9YCBlYAH+puwtzIh9DE6AEAf/r7jQoMlpDQEx4ehoEDUzF6dA/Ex+t9vl1VVTP++98TuHixTsLREUIIIUSIY5N0SQwaBKxYARQVIeaBB2DKykL9xIk48e9/c9sHDfJrd1T5JS+pQjW93v39or8rVMrZ80vqQElMYoxVrmmEgOdwytewW87wS4xpmlKi8Itcabi5dClXZu1ACxb/DL8dH0XcDCvD/XJodRrJynwJ6ahiYiKQnZ2BoUPTBBdtsv3BdPzDeejQZXz77Qm0tKj3UxRCCCGkIyorK5P2DtqrxREV5dQcnI2M5LanpPi1O6X7PHVkfAGCVOEX39Q8tU4jBMRZUECuyi9P57C+BoZyVn55mqbp6wqVnsYrdp8uCr9I6DhwAHBIf1lwlV+9rc5/+G+ePljecRHSQTAMg7S0WIwb1wc9e8a7XWZjewPALTTBwmzmVoX89dcy2d4cEEIIIYT4KtTen4gRDkkVfvEFCP6Oly/IkbNSTc2EAiVfF26Qs+eXGOGX3NMe1YzCL8Ixm4ENGwCLBdDpYHnwYbRBAy1YjG0rQhh75ZOkx/7vNgUHSkjoCwvToH//FIwdm4mkpCj7HyXXP07O37MoLW3AN9+cQE2NOKsqEULEI9ZKj/YVHwkhRMUiIyOdvg+1KZf+rlApdw8tKYjR7J2P1FMJxSY03vp631Zd93QsyDnt0dc+a54q2tTYoF9KFH4RTkEB0NgIDBgA7NuHXXfOxZORj+M8k4QomJFlOc9dTwPExAVf2koIAaKiwjFiRDcMH94NOp3zlEeWZV2qwbhtViuL3bvPY+fOM2hrk++NGCGEEKK03NxcZGVlITs7W+mhdHrx8fFO39fVqbtHqetJub/jlTOcESNA4Qs8pGpbIxR4qHUBBqFKNTEqv8QOvzz9zHwNnD2NV+xAlMIvEhpsDTf37weGDMEXuXtwVpuGnKgn8I/wSTin7QIAGHFzL2XHSUgHlJISjRtv7I1+/ZLBTTjmwi6rVfiPVX29GVu3nsCZM1VUJUIIIaRTyMnJQVFREQoLC2W/b39W2gsG09KC5NWrAZUGBzaxsbFO31dVVSk0Et9ERUU5fd/Q0CBwTX5yVn5JRarKL6H9uq5YqRZCfal8XaVQzmPBU5jm6zg89QLsbNMepfkNIKHH1nCz3fG9FwEALUw4NoaPtm9//HWa8kiIFDQaDXr3TkR6eiyKii6jvNy3VX2OHavE6dPVGD26J6Ki1P0Hh5COjKvOFG9fhBB16dGjh7R3UFYGfVERYnbsQNrbb6M1Lg66O+8E0tO5L5VxPclVezgUHR3tVO3l7+IAcn/QGB4e7vO0Nj5845Uq/BIKUIxGI5KTkyW5z2AINej39RiW+1hgGCao+6SeX1dQ+EXctLVZ0Grmnxvcva/6XsAI6UgiI3UYMSID5eWNOHSoDK2t3v8Qt7RY8OOPp9GzZzyuuqqLZA1NCSGEiO/kyZNYtWoVdu/ejerqauh0OmRmZmL48OGYMGECRo0apfQQCcQ/SXSTl4e+ixfbv9UtXsytxr5wIbBokbT3HYBQe68RbFN2ucO9yMjIoMIvPlKtxCd0LPjakF1uwQY0vq4KKRatVhvUSq5yrk4p1dRasVD4Rdx8veYX3u19r06VeSSEdF5dusRg/Pg+OHGiEmfP1vh0m7Nna1FSUovRo3sgLi7S+w0IIeKh0i8SgGXLluHZZ5+1n0zZPqE/cOAANm3ahIULF6Jfv3546qmn8OCDDyo5VCK1Rx/F6W7d0PuRRwAAVq0Wmh9/BHr3VnhgHUOwwY/cgUdUVJRbXzKr1RpUuCB3MBFMYCOlYMMvJaoAhZ7LtrY2rxV9no5dKULssLAw1f7s1R3NEUX8O2+v+0YN8OCLv5F/MIR0YmFhGgwc2AXXX5+JmBjPb9psK8RZLCx27izBoUNlHnuGEUIIUdamTZvwt7/9DW1tbWBZFlFRUbjmmmtw7bXXIi0tzf66XlxcjEceeQTXX389Ll68qPSwOx6TCXjtNWV6bBUXA1lZQGYmMGoUuj/3nP0ijcUCTJsGjBrFXZ6VxV2fBISvcs+fyiq5wy++SjVfe1IJEZru19l4quL05ecsd7DjKazzpXednKs9Auqe+kjhF3Fz4YRLw8r2QHj4TfTJEyFKMBj0GDOmJ666KoX3ctdPbViWxYULdfjmm2LU1Pi3lDchJDCsyF+k41u+fDkA7lPylStXorKyEvv27cPPP/+M0tJSlJWVYfXq1Rg1ahRYlsWePXswatQolJaWKjzyDmb9euCZZ4ANG+S/79RUwGAASkqAkhLoXJvGX7pkvwwGA5CWJv8YPQimakSJvkmuamtrfb693IEHX6VasA3kpZy6G0yIooZjwcaXMEnuKbCeQktfVi2Vc3VKQN0hK4VfxIm5pQ1WC8sFXrbfBQZgNKE1r5+QjkajYdCrVyJuvLE3UlKurDhlqwzgY7Wy2LWrBL/8chEWi7ob0RJC3GVnZyMrKwu5ublKD4VI4ODBg2AYBnPnzsX//M//uJ0wpKamYubMmSgoKMBHH32E6OhoXLhwAXfeeafqm4uHhLIybpXzd9/lvl+1ivu+rEy+MRgMwI4dwIIFAMOAdT0R1WoBhuH6fu3YAcTFyTc2HyQmJjp9789xqYaVqn0JDmyCrbryF99UNjWHX8E00xc6bqScphnMCpVyVwF6em596avm6fdSivBLqt5yYqDwizg5tPOcc/AF7pdCH0nt4QhRg6goHUaM6Iarr+6K8HDvL+EsC1y8WI9tX/6KxgVLVL90OiGhimv5xYr0xe2zsLAQRUVFyMnJUfbBEUnYTrLuuOMOr9f94x//iC+//BJhYWE4cOAA3n//famH1/Hl5QEjRgA//sh9//333Pd5efKOIyyMa2y/dCkY10DIYgGWLeMa3refAHv60MuR5A36AcTHxzt9bzT6tlI1oI7VIVtaWny+rtzj5Qslgg2/pAyTggk8hI5nqVanBITH60uYJHf45WkaYbBjofCLdGrHfr4ARsOAYRjuXy33C5HcNVbhkRFCbBiGQXp6LMaO7YWMDIPg9RzfS3TZ8Q1ilixAyYr30NYm7x9tQggh7mJjufdWvp4ojBs3Dg888ABYlsWHH34o5dA6LsceW6tWAQkJzpcnJXHb23tshZ89K9/YCgq4Kq92LABoNNz2dk1NTThy5AiOHDnidXdyTD1yvY+Kigqfbyt3gBAsNTTw5guJDh8+jMOHD/tUmSZl+CW0mibfz7mmpgZHjhxBfX09AOFgUcoVRSMj+ReGcgxErVYrb184uYNQf0LAtrY2lJSUOB0Pck97pJ5fJGSUn+ef59x/eFeZR0II8SYiIgxDh6bj2mszoNO5//FimCvvo9N3/hcAEP7vjfjmmxOorPT901lCiA+o6RfxU79+/QAAe/fyLDQk4J577gEA/Prrr5KMqcNz7LFVWgrUuKymXFXFbW/vsdWWnCzPuMxmYNMmp0+tGACwWrnt7Sfgp0+ftl/urWopOjra4+VicA1Tmpp87zPqGibJvRIhn/LyclS59l1rp0RYx1e95xi8mByq+Y8fP+51f1KGSUJhK99xWlpaCpZlUVJSAkA4nJGyelEorHN04sQJFBcXu1WDyR3WeXseHJ/jY8eOob6+3ul4kHuKMYVfJGRUXeIPv665qZfMIyGE+KpLlxiMH9/XqQrM8e9cWEsTUvbtAACk7N0OTXMT9uw5j4MHqRcYIYQo5f777wfLsli+fLnTSawnye1hjD+r1BEHDj22WB96bFljYuQZV0EB0NoKZGai5PXXceqjj1AzaRKQkcEFXw7VXzbeVv4UqmxRQlVVlT3wsHGtVJJyipsNXzhhCzJqampQXl6OsrIy3nBDifCLL6CpcQhsT5486df+lJj26DpVk2/qphLTHr1VRprNZvsxeurUKafLhMIvqcI6b8+D7ZhQQ3UiIM/vcqDUOzKiiJpy/mqQ/tdQ5RchaqbTaTF0aDpSU2Nx8qufMHRBDsJauE+qmLZWaFu5EyVtqxnjH74N1jDuU5lmfSTYLzYidsQQxcZOCCGd0RNPPIH33nsPv/76K6ZNm4Z169Z5rdYpKioCAPTqRR9KBqy9x9al5makv/6682UWC7B8OTBnjrxjGjQIWLEC+O1vYd63DzE7diDhq6/Q+vzz0JlMQHKyWz8tb/211BJ+GY1GlLUvImAwGBDTHii6hklyTNOMjo52C18aGhpgMBicVlG9cOECevTo4XQ9JcKvmJgYt59zVVUVkpKSPN5OicUEhKp9bOO3BUh8PbWEwiQpQxRv1UnFxcVu2ywWCzQajeyVahqNBmFhYYLhVn19PQwGg1tIpxQ1VHEKUe/IiCIaa/mb/HXr6/lFlhCiDqmpMRh5x0hoEuIRWVGGyIoy6Gsqna6jr6lEVEUZoirK0BoVi4LTLTh2rBxWK821IoQQuWi1Wnz66aeIi4vD119/jWHDhuGzzz4T7N1TWVmJF198EQzD4L777pN5tB1MWRmid+/mn2G8b5/cowFSUoDZs4EPP0Tf6dOR9vbbAADdyy8DS5cC+fk4c+aMX7uUo+G9NyzLOo3bMWBynQ4nV/jlqrq62m2brReVIyUa9EdFRblts1V9eurxJRTOSDntUeh4a25uRllZGZqbmwWbyStR+eVp33whU1VVFY4dO4aysjJFpmnaekTyMZvNTlOi1cAxAFNTGKaekRBVaGrgL6MPC6NDhZBQoUtORPT+PWic+yxYhoHV5Y+OVaMByzAo/sMTKPi/D9EaGY2TJ6vw/fcn0NDg+8pHhBBCgjNw4EBs2bIFKSkpOH36NO677z6kpaXhnnvuwcsvv4wPPvgAa9aswdy5c5GVlYUTJ07g9ttvx7x585Qeemh75x3E7dgB3ihg3Tpgzx6gvVpJVo8+itP//Kf9W6tWC8uPPwKPPur3rqQMOhwJhVYWiwUnTpxw2uYY2LiGN770YAoWXzWc0WhEZWUlz7WdKRF+eWoi76nHlxKVX1qtljdQslqtgn3UHK8jtE+pePr9qK2tddtmC708VVxKGdbFeJmCzfczb2lpUeRYAJwr69QUftG0R+LEbFLHXGFCSJDCwhCz9BW0pSUj7Om/OV2ksVpx5KFnceauP9u3sSyLpqY2/PjjaQwcmILevZNke+NMSEfAsqxobzKVerNKlHHdddfh119/xV//+ld89tlnqKmpwcaNG7Fx40an67Esi2uvvRaPPvooLl686DYti/jh6quFL2ttBUaNAhYuBHPHHUj6+GNUSVlpV1wMTJkCtJ9Ud3c4udZYLGi95x4wkZHo39YGq16PkjffhLlnT6+7letveEpKCi5cuGD/nmVZlJWV8VZUOXLtW+frqqfBEArqLl265LaNZVmn51CpQImPtzBJqb8h8fHxPgWJroTGq1TjdL7jwcbTQhNShl+BLGBRUlKCPn36SDAa78LDw70uyqEECr+Ik7bW0Fp2mBDiWdjhQ4BWC9ZiAYP2heQ0WsSdPup0PYZh7CfvRUXlqKgwYujQroiKUu+KLYQQ0lGkpKTgo48+wosvvoiPPvoIW7Zswb59+9yqY/bt24cpU6YA4PonDRkyBEOHDrV/DRkyhHeqFIFzyGSxwBIZCa3ANCxkZAATJiBu61akLV+O1tRUYMQIacZlW4HyKPd32fWvrq49TAgH0DR0qHwrUPrIdTrW+fPneacNunKdWibHNE2dTgeNRuNTFVd1dbXX3lpKKS8v93i5ElVqAPeaFEj4JTReqSuGtFqtqL3cpAxww8LCPPb94tPS0qLYsaDX69HQwC2kJ8eUZl+ppwaNqAJfzx+dng4TQkKS2Qxs2ABYLGB0OrQ9+BDYMB00VgvSd20D0yq8WlhFhRHffnsCFy96fwNLCOFWWBXzi3ROvXv3xoIFC1BQUICGhgbs3bsXq1atwpNPPomxY8ciNjbW/kFFbW0tduzYgXfeeQePPfYYrr/+ehgMBu930lnZQqaSEqC0VDj4AoBLl4B77kG3BQsAAIkffwzs3y/NVEiHFSjBswIl296qoPzxx3F67Vr5VqD0kWto5UvwBbg3kJdrhbhkH8NDT72d1MoWlis17kCmrrIsq8i0R0D8qbZSj9dT3y8hSoVfjoGXWhbfACj8Iq54XisTU/3/RSOEqEBBAdDYCAwYAOzbh7BV74LZtxfmXn0Q1mxE4rEDTld3miLR/lqwb98F/PJLKdralPnjSQghnVV4eDiGDx+OBx54AG+++Sa2b9+O2tpanDx5Evn5+Xj++ecxefJkdO3a1R6IKXWiI5fc3FxkZWUhOzvb/xs7hkzgfct7RVsbUF4OTXuYEP3rr1zlV16e//fri/YVKLF0KRiX4IKxWtEwbhwqHnyQu14HJVdfIH+quZTq7xQoW/Co1OsAwzB+T89ra2sTDOukPibEDmWkPibi4uL8vo3r9GK5OFbBqWn6o/p+a4lihF54uvdTZ8kvIcQL29LpDz8MtE+DYYYORfjhQzC99Q9YBwx0u4lt+qN9jiSACxfqUFlpxMiRPWAwSN+QlhBCiLDevXujd+/emDp1qn1bVVUVDhw4gAMHDig3MBnk5OQgJycH9fX1gVW52UKm+Hgwc+f6d9ukJGDVKuD994HoaGDjRqB/f//H4ElBAcAw9vJP2zvzuB9/RNLatWgcOxZtKSloS0lxu2moB59y9SjTarU+T3crKytDv379eC+TK6zT6XQeV3Z0VFNTg6SkJEWPheTkZI+hoauWlhbBqXxSHxNih19SV34F0vfL10pMsTn2awtk3FKhyi9iV325kXd7nyFpMo+EECIK29Lprv1foqKgf2YeRt1xLfr04cJtx2bdbm82WMDU3Ibt20/j9OmqkJsGQAghHV1SUhJ+85vf0CqQvrKFTP6oqgJKS7lpkwYDkCby+2OzGdi0yWneM9P+BQBpb72FvtOnI/Hzz3lvLmbvoo6ua9euPl2vpaVFMMiRo0E/4F+1j8lkAqBsEOptVUJXRqNRsZ5fYveikjr8CuT5UCr8UmNlJEDhF3Fw8TT/qix9r6Hwi5COSKvVYODALhg1qgfCw6/8OeALt9j2/zt8+DJ27y5BSwutDEuII1uALNYXIUQiPCGTT7RaLjBbuJCbPhnAFCSPCgq4lSYzM4F//AP1r7yChmuvtV/MMgzOrlyJ6t/9jvfmvlYHEf8CpcZG/uIAuVYiDKTPkz9N0cXmb7VWU1OTYHArdeWX2AGmHNWA/larKXUsMAxjDwOp5xdRpbIztbzb+wxJlXcghBBZJSdH4+ab+6FbN8OVk26ecwLbJAyuGX4xKir43xASQgghquUQMpW88gqsvlZrWCzAsmXAokXS9N4aNAj4+98BvR545hnEPfccYvfutV/MsCx6PPccet93H/rfeiv63nknt4JlOyXDL75pTQMHurdWUAt/QhWh8EuuFewCCQ6U6vNkwzdmoefcZDIJBjRSh0kajUbUgE2O8Cs+Pl60fckVLioZxrqi8IvYlZ+v492elhkv70AIIbLT6bS45pquuObqbl66AHNaW1ns2nUOR49e5l0llhBCCFElWz/MoiLE9O8PjcWClvR0nH/5ZWDePOCf/3RrF8ACXOWXlD3VUlKAp58GEhIAgalKmqYmhJeVIbysDNbYWKepl0oGHunp6W7fa7Va2fp4BSLKtSWEANtUQldyTXsMZCqd0v3funXr5rZNKMSzWCyC45Xj+LGNKyEhIeh9hVr4JbWYmBjExcVJPh3UHxR+ETuLhf8EtrlR2U8PCCHyYBgGGd0NGH9TH0RF8X2q3d4TrP2LZYETJyqxY/tpNDfTdAvSubGsuF+EEIk49MNMGDsWZc88g5ObNqHuzjuBN94AZsxw/yXUaLjKr/x8btqkFIqLgdGjub5iHqblsQDa4uNx4cUX0eYQ4DQ1NUkzLh+4VkHZVlRU84l6Zmam0/dXXXUV7/WEpqHLNe0RuBK0paeno0uXLgC492xCUyKVngKr1zsvjtSjRw+3bY6UDOu6du2Krl27ugW4KTyLSngjR1jnGiTxBY2B7ktsqamp6NGjh9994KRE4Rexi4rh/wTjbFG5zCMhhCgpNjYC42/qi8zMBJciMC72sjfGB3d+UFtrwrfbTqC8nKZBEiKm7OxsZGVlITc3V+mhENIhMV26oOr++8G2V39YrVZuWmRzs/P1bCfnRiN3uRRSU7lG+ufPC1Z+AdzfXnOPHmhLTUVd3ZVZG80uY5YTwzD2Btc9evSwb09OTlZqSF65nvj726Bbzobeffv2Rf/+/ZGUlIQuXbrgqquuQlZWFhITE92u66mSSimxsbEeK+2UHK9er0diYiI0Go3T9F1byKhGtmOXYRgkJCTwHge+kGvFUjVRZxt+ooj0XvG8ifX5E1UYNKoHzy0IIR2VVqvB0GHpSEqOwv59pQDawy6wYBiXAIwBLFYWuwrOYcBVKRgwIEXVUx0IkQILn2YM+7wvACgsLPSrMTMhJDjHjx/HwEGDgMWLgd/8BidLS+2X9e3WDfj2W27apBQMBq6R/pIl3JdAxVFz7944vXYtEBaGiooKe5WV0n11+vXrB4vF4jQdUK6+WIGKi4tDfX29PejQ6XQ+V03JGRxoNBqn59UWvPFV1JjNZsWPBQBITExEdXU1EhISwDCMx2NBLYu89OzZE+fPn0dcXJyq38d27doV58+ft1erpaWlobqaf+E6Tyj8IiEhNzcXubm5oi9p3L0//6czJcerRL0fQkjo6NbNgHhDJAoLS1DfwE31cHyT4vRhHQMcP1aBqkojrs3ujogI+hNDCCEkdFgsFm5a5IIFYFkWpiNHrlw4eDAwZoy0AwgL44K3mBiu/xePiJISMCzLTX9UQchho9VqeadRRUdHw2g0KjAi77p37w6r1Woft16v5w2/+MIZNYQjfGPwtHqinNLT05Gammp/bj1VyqmlUo1hGKfKRbUyGAyIjY21h1eBhlhq6sUll84X93UAOTk5KCoqQmFhoaj77dqbv9EfTXskpHOLjgnHDeN6o3evRLAu70+c3nexXMVKZWUTvv/uJKqqlOs/QojsWJG/CCGKUjRY2ryZf3tkJDRtbYiSsvG+yFwbiaulygfgwg7HAEBoap5awy8+RqNRFeGX63PrKWhR0zHhSM2VUWKMTc2PTyqd7xETQbpw/kT+8tlaeQdCCFEdrVaDwUPSMPK67k5v+Nzer7AAGMBksmDH9jM4ebJStW9qCCGEkJ49e/Jur6pSaOaD2SzcV6ytDWV/+xtMffrIO6YguE7NU3JVSm86QvjV1NSkmkoqR56CFrW+TwylcCiQHnRy9q1Ti9D5iRJ58LyO11cr10CTEKIu6elx+M2EvuiSGgOh91aO1WGHf72Mn/eUoNWs/KeQhEiJZVlRvwgh8hBaiayyslLmkbQrKABaW4HMTOCzz4B9+7h/e/QAWlthysqCJcAG10pwPcFubFTv4jiOfbUcqTFMEqKmqbC+UuvfPKHjQY0CWX2Uwi/S6WnD3A8JU7N6P6EhhMgvKioc2dnd0asX/1RpV2Vljdi37wLq60wSj4wQQggJjuJBx6BBwIoVQFERMH06MHw49+/Ro8CKFSFV9cXHcYVKtREKAxQ/JkTQGYOOYAUSKCklkKCOen6RTk8f6f7C2GZWZxpPCFGOVqvBsKu7Yvjwrh6uxb12sCyLsrIGfPfdKZSWqvdNLyHBYFlxvwghyigqKlJ2ACkpwOzZgOsUvKgoYPZsxIV4+NXcrN4ZJUJTGX1dAVLN1DCFT61TRYWEUvgVSLgZSo9PLMr/FhBViUmIVHoIhJAQ0iMzAeNv6g2hv5+Opewsy+LnPedRdOSyakvcCSGEEDVLDKEpj3z4/v5HREQoMBLfqblPma/UUOXjTwCnhqBM7celo0DCLzUcE3Kj8Is4SUqPVXoIhJAQEx8fiVtuHYDUVNe+KcyV1SBZFhpzC/ptXI0Tv15Awc6zMFMfMEIIISEgOTlZ6SHYdcRqDb1er/QQPGpqUu/q1b4GGGoIOvwZgxqmaYbS71ogP181VAPKrfM9YuJRaneD0kMghISg8PAwjBrdA1cNTAEA3qbdXXdtxeAPl6Pr7q2oqDDi++9Por6e+oARQgjxTW5uLrKyspCdnS3qfnv16uXx8pSUFFHvLxhqCAXEJrTogFqoeaqmr72e1NC83Z8xqCF4UsMYfBXI6wKFX6TTy+gb2qXUhBDlMAyDq67qgtGjeziUq18pW++265v2f7eCtbJoMprxw/encPFivQKjJYQQEmpycnJQVFSEwsJCUfcbHR3t8XI1VM14EuoN2dUefql52qOvU/PUcAz7E36pYbyhFA5R5ZdvOt8jJh517UPhFyEkOKlpsbjl1n6Iiwvnqr9YFlpTE1J/+Ym7fP8OaE1NAAtY2qzYs+scjhZRHzAS2mzVjmJ9EUKIL1iWDfmG7GoIOjxR82uyr1NG1VD55U8PLTVUOIZSj7JAni+lx6wE5Y8qoirdevOHX3VVTTAkRfFeRgghrqJLz+Lm/7kL5tp6WNpYaNpaoW3j3pxr21px65O/hTWMKydvi9BjzzMrUVs7FNdmd4NOR3+aCCGEEF9YLBY0NjYqPQy/uIZJnfEkXCy+hl9qCJP8GYMaxutP+KV0gEuVX77pfI+YeJTg1rAaAANcPF0t/2AIIaErNRVMfDwiLl1EVGUZ9LWVThfraysRVVmGqMoytEXFwhSfjOqqRvzw/SkYjeqdXkCIEBZAe6Fj8F9KPxhCSMior69Hfb1z+wA1BAeeqDn8CrVAwNeKLqXDGX/HoIbx+nNcKj3eQO5fTb93cgmt324iubikSOcNDMAwwKlDl5QZECEkNBkMwI4dwIIFAMOAdXkzadVowDIMjv7uMWx/aQ1ao2JgNlvR2GDG99+dQFWVUaGBE0IIIaGjpqYGRqPz30w1THFzFBvrvJq8mnuUqT04dOVr6KGGUM+fgCaUms0Dyv/OMQzj98+Ywi/S6YVH8LzgM8Deb0/JPxhCSGgLCwMWLwaWLgXj8kZXY7Xi1xl/w7HpT4DVhgEOVS+tZit2/Hga50tqFBo4IYQQEhr4ViKMjIzkuaZy4uLinL63WCwKjcQ7pUMMf/kaeChdmeTvGELt56CGsM7fMVD4RQgAjdb5F4FhGBzZc16h0RBCQt6BA4DDGx4WgFWjheHMcd6r20KwvYUXUHSEGuGTzis7OxtZWVnIzc1VeiiEkBDibfVKubmOp62tTaGReKeGEMMfvgYYagg6OnL4pYbxqiHgVDsKv4ibxPQYwOX10VhHPXgIIQEwm4ENGwCLBdDpgEceAXQ6aKwWdN2zDUxrK1hw06s5XNBly7uOHytH4c/nYbGod4oEIYA0qz0WFhaiqKgIOTk5Cj86QjoXNYczvvBnVT05uAZKan5+1fbciUUN4VcoNZD3lxqOm1B7zpRA4Rdx0zMrBWABRgsw7UcIFV4QQgJSUAA0NgIDBgD79gF5eWD27QP694fO1ITE4wfsUx5dcRVgLC6cr8WOH0/D1BzaS7kTQggJDceOHVN6CEFRW98q1+DFbFbvh+q+rp4YatTQ80sNAZxU1FAxqLbfezWiZ4i4mTTzGuz79rTTNoYBLpyqREafZIVGRQgJSYMGAStWAA8/DERFcduGDAF++QV4910Muu1mbD/S4BB+Ob8xsm2vrW3C99+dxPVjesIQr65eJoQA7as9irgvIp2SkhJZ7qdHjx6y3A8hrtQQdHjS0tKi9BAEqSHE6Mg0Go3XBQ9CMSRTQ9WVGsagdhR+ETfDbugJhmHAsqz9xYdhGOT+7b945Yv7FB4dISSkpKQAs2e7b4+KAmbPRhKAWzJa8N23xWhrZcGFX1f+tb0WWSxAS0sbtm8/hWuzeyA9Pc59n4QQ4oOePXtKfnLFMIyqp3YRd927d8f589TjVg4mk0npIQhSe3AYKLUESlqt1mv4pYYphP5SQ/BElV/edczfbhKUqJgIaMMYtxfJQwXyfFJKCOlcYmIiMPH2gYiNDYdj8HXlX47FwqLVbMXOHWdx+lSVMoMlhHQIYvdoE+rbRkKHwWAA09KC5NWrwai4MskXagk6hKg5GFZDiNGR+RLQxMbGyjAS33TUBQU6K4oHCa8eVyXjzOEK543Ub5oQIpHw8DDcPKE/ft5TgrKLtmmQLBiGm3ZtO4+0Wrnv9+8rRXNzK7IGpariDQchNO8xtDAMgyVLlqBbt26i7re0tBQvvPCCqPskMigrA8rKkLRmDdLefhtoa0Pj2LFoS0lBW0qK0qNz48vUMTVTc/jVUSu/1EKn06G5udnjdWJiYmQajXe2GQi+XE9pVPnlHT1DhNftf74G7zz9jdv2tlYLwnSUKhNCxKfVajBqdCaOHL6E48e48J1l4RKAse3bGBwtKkdTUytGXJsBjUb5Nx2EkNAyZcoUZGVlibrPI0eOUPgVivLygMWLkdb+bdpbbwFvvYXyxx9H+RNPKDo0PgaDATU1NbyXRUdHyzwaQnznS3WSmqY9+jJNUy2o8ss7irYJr+xb+vJuX7d8p8wjIYR0JgzDYPCQdIy4NsNxa/u/Vz55s30Kd+5sDXb+dAatrRb5BkkID1bkL0KIjB59FNi61f6tVavFqbVrUf273yk4KGGepoWlpaUJXkbEQSFD4HypTlLT8xtK1VShNFal0DNEeHXJMLi22wEAbPpnIe57epwiYyKEdB49eyUiKjocO348bV98g6soZx1WhuT6gpVfbsSPP5zG2LE9oY+kVZoIIZ79+c9/BsMwSEhIEH3fCQkJ9v0TlSsuBqZMAYxG7nuHJuwaiwU95s0Da1v5Lz4e2LgR6N9f7lHy0uv1gpdFRtKKyFKjFSED50uwpabXz1AKlNQUGqoVVX4RQcnp7p8qGevMCoyEENIZdekSg1tu4040rFYu9HJvu8DCamVRX9eM7747ifp69a4gRTo4MRul+9ksvampCRs3bsSDDz6IAQMGQK/XIzo6GsOGDcOLL76IxsZGwduuWbMGI0eORExMDBITEzFp0iQUFBR4vL+dO3di0qRJSExMRExMDEaOHIkPPviA97qXL1/Ge++9h7vvvhsZGRkIDw9HfHw8brzxRqxduzbgxvBHjhzB7373O6SkpCAyMhJDhgzBihUrfJqesmbNGrz//vtIT08P6L496dq1q33/RHy5ubnIyspCdnZ28DtLTQUMBqCkhPsqL3e6WFdZifCyMoSXlXHXU1FFVSidkHdE9PwHLtQCmvDwcKWH4DONRqOq4FCNKPwign5zZz/c07QdOrbVaTutYEQIkUtcnB6T7xiIiAiNx9cei4VFi6kV3397EpWVRhlHSIjyPvnkE9x9991YvXo1tFot7rzzTtxwww04c+YMFi5ciOzsbJS7nNgDwJw5czBr1iwcPnwYEyZMwMiRI7F161aMGzcOGzdu5L2v9evX48Ybb8SWLVswdOhQTJw4ESdOnMCMGTPwt7/9ze368+bNw0MPPYQvv/wS3bt3x9SpUzFkyBD89NNPmDlzJu69915YLP5NW961axeys7ORn5+P3r17484770RlZSX++te/4ve//z29T+nAcnJyUFRUhMLCwuB3ZjAAO3YACxZcaS7pgNVowDIMyh9/nLteXFzw9ykSasouLW/PL1XXBY7CL+kwDBNyz6/c6JWTCLo18iQeaNqC61uOOG3f/8NphUZECOmM9Hodbp+chdg4/gaotvOVtjYWLICDBy7iYmmdfAMkBLBXJor15Q+dTodHHnkERUVFKCoqwr/+9S9s2bIFx48fxzXXXINjx45hzpw5TrfZtm0bVq5ciaSkJBw8eBAbN27Eli1bsH37dmi1WsyaNQu1tbVOt6mursYDDzwAi8WC/Px8/PDDD8jPz8exY8fQt29fLF26FD/88IPTbZKSkvDyyy/j4sWL2LVrFz777DPs2LEDu3fvRlxcHPLz8/Hee+/5/FhbW1tx3333obm5GcuWLcOePXuwbt06nDhxAqNHj8bnn3+OtWvX+vcEtnvxxRfx4osv4r///W9AtychKCwMWLwYWLrU7RePsVpx6amnuIb3IVLpM3jwYKWH0CF4C788TTtVQigFHqE0VkB9P2tvqCrRMwq/iKDUPVzjz7Hmw07b353/rRLDIYR0YmFhGtxy6wCkdPG8/HWr2YKGehN2fXccNc8ucurhQkhHNWPGDOTl5WHgwIFO29PT05GbmwsA2LBhA8zmK60Lli1bBgB44YUX0K9fP/v20aNH47HHHkNtba1bKLVq1SrU19fjrrvuwtSpU+3bU1NT8dprrwEAli5d6nSblStX4u9//ztSUlKctmdnZ+PZZ58FAHz66af/n737jo+i3Bo4/ptN750mEHoJHaRLEWmCVFFUFEHAhgriVa9XEUTsiKAGRaRb6byAoPQWSigB6Z2E0NN723n/WHZJr5ttOd9792My9eww2Z058zznKfZ7Xb16NZcvX6ZFixa8+eabhunu7u58//33+cZQXFOnTuWjjz4iLS2tVOsLKxYSkqPll4qu5ZdLWJjZQhLmU1QCwdISOJY0OmJRLO3YFcXakknFPb4VtXukJL9E/pKSUP7eBMCD6WdxUu9fMEecjTJXVEKICkyjUejarQ41anoXulx6ehY1D23D54uPuBm8yCSxCWGpWrRoAUBaWhpRUbrv75SUFLZt2wbAsGHD8qyjn7Zu3boc0zds2FDgOv3798fZ2ZktW7aQWsyksz6269evF2v5omJo3bo1derU4cSJE1y5cqXY29Tz8/MDoGbNmiVeV1ix9HRYuzZHyy8FXcsvz23bUDIyCl5XlJkltqwpKuFhackma+qGKcmv8lXceCtq12mj/mveuXOHS5cucfPmTZKSknBwcMDb25uaNWtSr149qzvZK5TcI96kp8O9J5+OZPFz9AwyFd2/X6riCOcet5gRb4QQFYeiKLTvEIiLqyNnT99GUXL3VNH9UjVE120p889lnOwzmKAmlSvsUy5RsV26pCtV4ODggK+vLwBnz54lLS2NgIAAqlevnmed1q1bA3D8+PEc048dO5ZjfnaOjo40bdqUQ4cOce7cOZo3b17s2KqUoJB4YTHop1+6dInjx49Tq1atYm8XoF69ehw8eJCbN2+WaD1h5UJCICMDAgMJf+010mvWxDE8nCpff43jzZu4hoVBq1bmjtJm+fv7mzuEPIqq82RpiQM3NzfDww1LZ235AEv7ty5KcY+vtb0vYylT8ispKYm1a9eyceNGdu7cSWRkZIHLOjk50apVK3r37s2QIUOKdVEkTEg/4s3p0/nO9lUT9feUnLavwcU7UFdyX0IIM2nevCouzvaEHY0EFEMSTFXBLjWFqmF7Aah6dA8HD18hPT2Llq2qSQJMVDizZ88GoG/fvobWCuHh4QD5Jr5AdyPl7e1NTEwMCQkJeHh4EB8fT1xcXKHrVa9enUOHDnH16tUir/MyMjKYM2cOAIMGDSr2+ykqdv30q1evFnubesOHD+fAgQMsW7aMvn37lnh9YaWaNIFZs2DcOOLvJWRTg4JI6NYN35UrSa1b17zx2Thvb29zh5CHtSW/LLH1XEH0IxJay8Ak1nbd6O3tTWpqKsnJyYUuZ23vy1hKlfw6evQo3333HcuXLzcc2KJO4NTUVPbt28f+/fuZNm0aTZo0Yfz48Tz33HO4urqWJgxhTPoRbz7+WPdSFMg2XHgWCgoqv7v04A/Xh2n7QxgfdpbslxDCfOo3CMDZxYF/V+zkoRlvYpeeAoAmMxO7TF03FbvMDB6dOACtvT3pdhocfTxR1q6VlqvC6FRVNdrFvH478fHxOaY7OTmVqLvNX3/9xfz583FwcODjjz82TE9MTAQo9PrLzc2N2NhYQ/JLv05h67m5uQGQkJBQZGyTJ0/m9OnT1K5dm5dffrlY76c4sZckhtxeffVVFi9ezJIlS+jatSujRo0q8TaEFQoIgAkTAF3B+BMndLVuVRcXop591pyR2ZSAgADu3Llj7jCKxZpG+APri9fOzo7MzExzh2GTXF1dDd3/C2NtLfCMpUTJr6NHjzJ58mQ2btwI3L84q1KlCu3ataNNmzZUqlQJX19ffHx8SElJITo6mpiYGM6dO0doaCjHjx8nIyODEydO8OqrrzJ58mTeeecdXn/9dYvrP13h6Ee88faGSZNyzLJD5Se3/qx16QzAoW0y4qMQwvxq1PDGZcCDpM9xx//65XyXcYm9a/g53q8Sbv6VqJhf+cLa1KhRI8fvU6ZMYerUqcVa98yZMzz77LOoqspXX31lqK9lCf744w++/PJLnJ2d+e233yzmIejNmzf5+eefGTNmDGPGjOG3337jmWeeoXnz5vj4+BR5syC1woQoWOXKla0m+VXU37q1tZqxtHgl+WV+kvwqwujRo1m6dCnae62BWrduzYgRI3j88cdL9GWfnp7Orl27+PXXX1m9ejV3797l3XffZc6cOSxZsoSHHnqo5O9CGFdYGNjZQVYWoOvtqEWhTub9grRZGdbRVFUIYfv86z1A7N49nHzlbYJWz0NFQaPeb7mq1WhQVJVTQ1/kzOPj8A27y0MPeeDgWDG/+EX50He7Nda2ACIiIvD09DRML+5DwsjISPr27UtMTAyTJk1iwr1WLXru7rpRUwvrFpF0rwaoh4dHjnX062WPq6B18rNt2zZGjRqFRqPh999/p0OHDsV6T9ljj4mJKTD24sRQkFq1ahluElVVZevWrWzdWrwRrhVFkZs5IWyErSUGLK2bpq0dX2tkaeeEqRT7XS9evBh7e3vGjRvHmTNnOHToEG+++WaJn3I5OjrSs2dPFi5cyK1bt1iyZAkNGzbkypUrhpGHhBmlp8OqVbrEl4MDvPgiqp09dqh0SjuJvXr/wu7qGet4eiOEsH3elTypuWg2x56dlCPxBaDRagl79i1OPP4yWYodCfEp7Nt3lbQ0uVEVls3T0zPHqzjJr+joaHr37s3Vq1cZPXo0M2bMyLOM/trt2rVr+W4jKSmJ2NhYfHx8DEkkT09PvLy8Cl1PPz0wMDDf+aGhoQwaNIj09HTmzZvH4MGDi3w/JY29qBiKkr37qv7n4r4qku7du6MoSoGvTZs25bveokWLaNeuHe7u7vj6+tKvXz9CQkJMHL0QhZPkTPkq7Pg6ODiYMJKKq6Ie52K3/Hr11Vd599138zTBLwsnJyeeffZZRowYwfLly8m619JImFFICCQmQsOGsHw5NGtG1JCRpD02mOpZd2mcEc6/jnUA+OG9v/l8tdRCEEJYBg8PZ5pm3dS19NJqUdC1XFU1dnhfOQvoWtSkpmZx53YC27ddoPvD9XB2tq5hrIUoSGJiIo8++iinTp1i6NChzJs3L9/uLg0bNsTJyYk7d+4QGRnJAw88kGP+kSNHAPIUrW/RogW7du3iyJEjBAUF5ZinL2nh7OxMg3xq6p06dYpHH32UxMREvvnmG0aPHl2q99iiRQuOHTvGkSNH6NevX575BcVeHAsXLixVTBXZ448/nqNVoF7ucwpg4sSJzJ49GxcXF3r37k1qaiqbN2/mn3/+YcWKFaVKhgpRHmytVYy9vWVd5xSW/PLz8zNhJBWXpZ0TplLsd/3999+XWxCKovDkk0+W2/ZFCWQb8YZ7NTj8+3TiyYAJ9EzYz1X7SoZF/90TYaYghRAiH+np2P/fWtBq0drZc6n7IGrvWIsmK5PqoVs5NG4yWnsHtFoVFUhOSmf71gt071EXF5eK+QRM2I60tDQGDRrEwYMH6dOnD7///nuBNxguLi706NGDjRs3snz5ciZOnJhj/ooVKwAYMGBAjun9+/dn165drFixgmdzFQJfv349qampPPbYY3lGHrty5Qq9e/cmKiqKqVOn5tlfSfTv358lS5awYsUKPvjggxzzjh49yqVLl2jatCm1atUq8baff/75UsdVUc2YMaNYx3rLli3Mnj0bPz8/9u3bR/369QHYt28f3bt3Z/To0XTv3t0iR/4TFY+tJb8srZWPq6srsbGx+c7z9fU1bTAVVEVt3Whbf9kVRHBwMEFBQbRt29b4G9ePeJOt+KyiKLTsG8T/uXQmXuMOCrrRIIFb4bHGj0EIIUojW8vVrIOhHH3xAzZ/+hvxVQNxSE3G79wxQNX9X6uSkaElNTWD7VsvkJycbu7ohbXTF/0y1qsEsrKyePrpp9m2bRtdunRh1apVRY7+NenewDbTp0/n/Pnzhun79u1j7ty5eHt7M2bMmBzrjB07Fk9PT9auXcuqVasM02/fvs0777wDwFtvvZVjndu3b9O7d28iIyN56623mDJlSrHe08iRI2nUqBGrV6/OMX3IkCHUrl2bY8eO8c033ximJyUlMX78+HxjEOY3c+ZMAD744AND4gugY8eOvPzyy8TGxjJ//nxzhWeVcrfc0HdLFmWnKIpNJcAsbVA5X19fGjdunO88azzu1hiztPwqZ2lpacTGxhIQEGCVJ4glGT9+POPHjyc+Pt5kX3Rjpz1CyIZz6DoR3aPA1GeX8cOuF00SgxBCFCpby1UHV1cGNcti3Vr459PfqbNtNfHV69zPKaigopKenoWicK8FWD3c3KxruHAhQNc6X58k8vf359VXX813uRkzZuDv7w9Az549mTBhArNnz6Zly5b06tWL9PR0Nm/ejKqqLFy4ME8rHF9fXxYsWMCTTz7JsGHD6N69O35+fmzZsoXY2FgmTZpE9+7dc6zz0ksvcf78eVxdXbl79y6jRo3KE5e/v3+e2mTh4eGcPXuWuLi4HNMdHBz45Zdf6NmzJ5MmTeLPP/8kMDCQ3bt3c+PGDYYNGyYtuCxMSkqKoa7vsGHD8swfNmwY3377LevWrZPEZQm4uLiQkJBg+D2/QShE6dnb25OebhsPxizx3tuWWh5Z4vEtii0d/5Ioc/IrMTGRXbt2AdC1a9c8/f7v3r3LSy+9xPr168nMzMTd3Z2xY8fy6aefWlwWWhSscg0vnFzsSUvJXiBaIfxMtNliEkKIHPQtV+9xcLBj0JDmrPu/E5zr+7SuEDNqngRYWloWqqoaukC6u8t3kyi58hjtsbhiYmIMP+duKZXd1KlTDckvgFmzZtGyZUu+//57Nm/ebBiUaPLkyXTq1CnfbTz++OPs2rWL6dOns3//ftLT0wkKCuK1117LN+mkjy05OZnFixfnu83AwMB8C/MXpFOnToSGhjJlyhR27NjBsWPHqFu3Lm+//TYTJkzIt86ZKB/z588nKioKjUZDgwYNGDx4cJ7BsM6ePUtaWhoBAQFUr149zzZat24NwPHjx00Sc3EpaWn4/for9vdaSVoaNze3HMmv/GqvidKzxoRGQSyt26O1URSl0EFNrDGnYUvnd0mUOfm1cuVKRo8eTfXq1bly5UqOeVqtlkcffZQjR44YTpiEhARmzZrFlStXWLlyZVl3L0zosTFtWPn9gTzTD/5zgXa965khIiGEKJydnYaBg5qyYf0pkhIzyHNPrOpGdEtLzUKjUdi29QIP96iHh4f1XciIimvq1KlMnTq1VOuOGjUq39ZYhencuTMbN24s1rI7duwoeVDFWK9JkyaG2mTlISEhgS1btnDs2DHu3r1LSkpKoTc/iqJUyG5706dPz/H7f/7zHyZPnszkyZMN08LDwwHyTXyBLonj7e1NTEwMCQkJhhFGs0tLSyMtLc3we3x8vDHCL5Tn5s1U+eYbtK1bw7OWN8CTi4tLjt8rakuO8mJLx1OSX2Wj0WgKHZjPGpNftnR+l0SZk19///03oKvBkDuD+Oeff3L48GEURaF169Z069aNnTt3cuTIEdasWcOmTZvo27dvWUMQJjJ8Ysd8k18zXl3LsgvSTF0IYZk0Gg39Hwti44bTJMQX3IUhJTkTV3cHtm09z8MP18PTy7nAZYXIzZwtv4TxaLVaPv74Y77++muSkpKKtY6qqhUu+dW1a1fGjh1Lp06dqFq1KhEREaxYsYLp06fz4Ycf4unpyYR7LXETExMBXZHrgri5uREbG1tg8uuzzz7jo48+Kp83k4v9nTvY37mD972H9JoFCyAoCKpW1b0shDXecFsTW0oOSGvYsikq+ZV7kBdrUFHPiTK3dztx4gSKouTbPH7JkiUAtGnThv379/P111+zb98+2rVrB1Bg83dhmdw8nfEOyHvhkhSfQXpaZj5rCCGEZdBoNDzavzHuHoXX9EpOzMDBXsP+fVeJj0s1UXRCCEsxatQopk2bRmJiIhqNhoCAAEOLr+rVq+Pm5oaqqoZp/v7+BAYG5unqZ+umTZvGs88+S506dXBxcaFBgwb873//Y82aNYCuNWJKSorR9vfee+8RFxdneEVElN+I477Ll1Nv+HA8Dh3STdi+Hdq0gblzy22fpVFRC1abin7QEFtIEtjCezCnohKhltjluKh/84ra7bHM7/r27dsA1K5dO8f0jIwMdu3ahaIojB8/3vAB7eDgwMsvv4yqqhw8eLCsuxcmNvJ/3fKd/uesvSaORAghSkaj0dDvsca4FZIAU1WV+LhUUlLS2bblPAkJkgAToqL4+++/+eWXXwBdEuz27dts2bLFMP/q1avEx8dz+vRp3njjDTQaDT4+PmzcuJHLly+bK2yL0rt3bx588EFiY2M5cEDXW0B/Y5icnFzgevpWdvm1+gJdKydPT88cL6M6d07XuiswEN9Vq8jIPaCUnx/8/DMEBuqWO3fOuPsXFqdSpUrUqVMHNzc3c4dSavr774qa6DCWohLNltit1MfHp9D5FTUhWua/hOhoXcHz3ENqh4aGGp745O7a2KBBAwBu3rxZ1t0LE+vxRNN8py/7Zp+JIxFCiJLTdYFsjJt7wRcqqgopyRmgqGzbfJ7EhLQClxXiPtXIL2FqCxcuBHT1xBYsWICPj0++NwgNGzZk1qxZrFq1iosXL9KvX788o1JWZPXr1wfgxo0bAIZWcdeuXct3+aSkJGJjY/Hx8Skw+VXuKlcGLy8ID8f+1i0ccv97RkVBZCSEh+uWq1LFPHEKk9FoNLi6uhaZRLBkVapUwc/Pz2K75eUeUdhS5c5z5GaJiSQ/P79C51tizKZQ5uSXvv++vgWYnn4EyHr16lG5cuUc83IXaBTWw8HRjsBG/nmma7Vw82qs6QMSQogS0rUAC8LV9X4CLHcha1WF1BRdfYetW86TlCgJMCFs3f79+w09FopjwIABPP/881y9epVvv/22nKOzHvoRPvUtZho2bIiTkxN37twhMjIyz/JHjhwBoHnz5qYLMjcvL9i9Gz78EBQFNfeNoZ0dKApMmaJbztgtz4TFsuaWX97e3lStWtViEx25cwSWyhrr6xUVs6WeE+WtzMmvunXrAnlH5Vm9ejWKotC1a9c869y5cwfQNScV1uelT3rmO/2H//1t4kiEEKJ07Ow0PDaoCS6u9obEl6qqkO1aQFVVUlIyUbVaXQIsqeBi+ULoC94b6yVMT/8gV99DAXLWesk+2qDesGHDUFWV1atXl3+AVuDOnTvs3r0bgNatWwO6h949evQAYPny5XnW0Y/aOWDAABNFWQB7e/joI/j6a5Tcf4RZWTBzJkydqlvOwlTUG1lTsJbC99bYtdESuwvmxxqTXyJ/Zf4r6dWrF6qqMmfOHDZu3EhiYiLfffcdoaGhQP5fZMePHwegWrVqZd29MIPmDwWiscv7JXto8+VChwEXQghLotEoDBjUFJdsLcDIlXxQVZXU1EwyM7LYtuU8ycmSABPC1vn6+hp+zt4NL3cvB7j/IPfKlSvlHpelCAkJYc2aNXlGP7ty5QpDhgwhKSmJgQMHUr16dcO8SZMmATB9+nTOnz9vmL5v3z7mzp2Lt7c3Y8aMMc0bKEpYWP4tv8LCzBJOYfRJLyl+X36sJbFYVNc8UXpybG1HmZNfEyZMwNPTk4SEBB577DG8vLyYOHEiAI0bN843+bVhwwYURaFVq1Zl3b0wA0VRaNWtVr7zDvxzwbTBCCFEGWg0CgMHN8XFJe+Ngz4BptVCenoWmRmZbNtynpSUDBNHKayBtPyyfvouOPp6tvpp+hsf/cPb7K5evQpAamrFGRzj3LlzDBkyhOrVq9O/f39GjBjBQw89ROPGjdm7dy9NmjRh3rx5Odbp2bMnEyZMICoqipYtWzJ48GD69etH165dyczMZOHChZZR/yc9HVasyNnyy85O1/JrxQrdfAuib5Fi9AEAhNXRlyISxmctLdRE0cqc/KpatSrr1q2jSpUqhqGfVVWlTp06rFixIk+2/OLFi4bm0D175t99Tli+Fwvo+jjvg80mjkQIIcpGo1EYMLgpTs52eZIO2RNgaWlZpKfpE2CWdQMkhCi7Zs2aAXDq1CnDNHt7e8PDWn1B/Ox++OEHAAIDA00QoWVo3749r7zyCtWqVSM0NJRly5Zx4sQJWrZsyddff01oaGi+pU1mzZrFwoULady4MZs3b2bfvn307NmTXbt2MXjwYNO/kfyEhEDuUSn1LdySknTzLUjdunWpV68eVatWNXcowsysuTaZpbOW1n+iaEZpI9ulSxcuX77M3r17uXnzJlWrVuWhhx7KtwnujRs3mDx5MqAbDllYp+p1/XB0tic9NTPH9JtX40lNTsfZVZqHCiGsh52dhoGDm7FyeRhZmbnn6jJgWq2CVgsODnbs2nGJhx+ph6OjdDUR5adt27bY2dkxfvz4YhdhF6XXvXt31q9fz5YtW3Ic72effZYDBw6wevVqnn/+eZ588kmSkpJYvHgxW7ZsQVEUBg0aZMbITatx48bMmTOnVOuOGjWKUaNGGTcgY2rSBD76iIu1a6Pea1VVr149SEmBrVt18y2IoigWO5KfMC1p+SVE0RRVijRZrfj4eLy8vIiLizNLc+cf/vsP6xccyTP9mf90ZsQ7XUwejxBClFV6WiarVhxHq809R/9VqeDgqEHVqnj7uNKjZ33s7XM1ok5NhW+/hTfeALkpMRtTfUfq9zPtw/U4OxvnyXtqahIfTnvMbN/vFdXly5epW7cuTk5OXLlyxdANMjMzkw4dOnDkyJE8LQBUVSUwMJAjR47g4+NjjrArpPL++z5x4oTh56ZNmxp9+xXV3bt3uXnzZo5p1nB8s58PYJkxq6rKyZMnc0yzxDhzs4ZjC3njzE5iLl/G/Ly3vmEhhMUoKMG1Ini/iSMRQgjjcHSyZ9DQZuRt4a6foJKeloW9vR3RUUns2nGRrKxcmbKVK+Hdd2HVKhNELCyFauT/CdOrXbs2ly5d4sSJEzkusO3t7dm8eTMjRozA3t7eUOIDoH///uzevVsSXzamZs2aAPLvamT+/v7mDsFm5U7Mu7u7mykSISyXJL9EqXn6uuDp55JnenpKFhHn7pohIiGEKDsXFwcGDAq695ua40ZX31Y6JSUDN3dHbt6IJ2TPFbTabMmK5ct1/12xwnRBCyGMolatWtStWxcXl5zXNz4+PixdupS7d+9y6NAh9u/fz507d1i3bl2OUQ2FbfD09KRp06Y88MAD5g5FiFKRGmCiIBW5hplRi5WoqkpYWBjHjh3j7t27pKSkUFSvyg8//NCYIQgTG/5mJ+Z9sDXP9IXTt/PhkifMEJEQQpSdu4cz/Qc0YsO6M+i7POb+OouPS8PPz4WI8BhCD9jRrkNNlORk2LRJt8Bff+kKJMsFqBA2w8PDg9atW5s7DCFsgn4kVWuSX01rSyRd5kVB7OzszB2C2Rjtr3fx4sV89NFHhiGfi0uSX9at38hWeZJfigIH/tZ1BbKzk8aFQgjr5OXtSq++Ddi86VyBD3LST55h4PdvQ3IyGQ52OJIFaWm6mWlpUK8e6C/u3dxgzRpo0MA0b0CYlKrmTZCWZVtCCGHr6tSpY+4QSsxakl9O9wZsEEJPURRUVUWjqbj350b5633//ff5/PPPi2zlBfcPurANjs72VK/rw7WLMTlnqLB33Rm6Dg7Kf0UhhLACAQHudH+kLtu3XMgzT1VVUj39SHF0JSDiUv4byF7Yt0MHqFKlnCIVQhiTVqtl+/bt7Nu3j5s3b5KcnMwnn3xC1apVDcukp6eTmZmJnZ2d3GgKUQrWkkjKTv7WhbWyt7cnIyMDBwcHc4diNmVO+x04cIDPPvsMgF69ehEWFsaRI7oRABVFISsrizt37rBx40YGDhyIqqo89NBD3LhxA23e4bSEFXrho4fzTFMU+OnDf8wQjRBCGFe1al507lIrxzRVVVEUhQxXd/753zyODxqLqiholVxfq3Z2ug/EKVNg926Qbgi2SzXyS5jN+vXrqVevHr1792bKlCn88MMPLF68mJiYnA/6fv75Zzw8PKhUqRJJSUlmilYYXWoqfPml7r9C5GKNXTWFcVlj0hYwJL0q8jlc5uTXDz/8AEBgYCAbNmygefPmObKJiqLg5+dHnz59WLNmDcHBwezZs4e+ffuSnp5e1t0LC9CuV30cHO/3HdY37Iu9lUrUjQQzRSWEEMZTq7Yfrdo8YGi5nKMVs70Dx4e8xOGnJqJRcz3UycqCmTNh6lSw0oslISqSefPmMWjQIK5cuYKqqvj5+RXYY2Hs2LF4eXmRmJjI6tWrTRypMLobN+DIEZgxQzdi79df636/ccPckQkLIoXkK6bsReKt9RzQ1/qqyAXvy5z8CgkJQVEU3njjjWJlQV955RUef/xxjh8/zpw5c8q6e2EBFEWhz3PN7/0MGo1i+KP6bNxKc4YmhBBGE9SkCvUbBuS4Ec4+EqTP1bNoNRpDox0VdC2/wsJMHaowA9XI/xOmd/78ecaPHw9Ajx49OHXqFLdv3y5weUdHRx5//HFUVeWff6S1uykEBwcTFBRE27Ztjb/xuXOhTRuYPFn3+wcf6H6fO9f4+xJWJXuB8IrcaqYiy54wstbBBPS1vipyza8yv/Mb956GNGnS5P5Gsx3QjIyMPOs899xzqKrKn3/+WdbdCwsx7uOeaOzyZpHPHrpFXHSyGSISQgjja98hkKrVPPO0BNFkZlDz8HY0Wi1aO3vC+zyBameva/m1ahVIS2chLN4333xDZmYmTZo04a+//qJRo0ZFrtOlSxcAjh49Wt7hCWD8+PGcOnWK0NBQ42/8pZdg8+b7v9vbw549uumiQnN2djb8XJETBxVZ9gSoq6urGSMpPf17qMjncJnfuT65ValSJcM0d3d3w8937tzJs0716tUBuHAhbwFhYZ3s7e14aEBDgBzdggA+HSOtv4QQtqNHz/p4ed0veKsoCgHnj+OQlkJclUD+mrKUvc++y44Zf5BQNRASEiAkxIwRC1PQj/ZorJcwvW3btqEoChMnTix264569eoBEBERUZ6hifJy7hwEBUFgoG5QkhEj7s/LzIRhw3TTAwN1y507Z75Yhdlkv7fNngQRxuXh4WHuEAqUvYebNRaMt7Ozw8/PD19fX7y9vc0djtmUOfkVEBAAQHx8vGFa5cqVDR8Mp0+fzrOOvrVYQoLUg7Ilk75/LN8+xKf2XSdeWn8JIWyEoij0G9AEJ2e7e4kKlbjqdQl9ehIbpv5CbI16ZGaqRFety5Yv/uDEmHdJr9/Q3GELIYpw7do1AFq0aFHsdfS1X5KT5TrHKlWuDF5eEB6ue+Xu5nrz5v15Xl4yYm8Flb3GU0Wul1TeLLlF1QMPPICiKFbV5TH7QxwPDw+cnJyoVq1ahe66W+bkl76745kzZwzTHB0dDdPz69q4dOlSAKpVq1bW3QsL4uBoT5setfP9Uvjq5bVmiEgIIcqHnZ2GQUOaYWenoKqQ6uHNub7PkOV0v2tESkom9p5unHj4SXb8G09WloxwbMv09d+M9RKmp79+KUkiKyoqCgAvL69yiUmUMy8v3Ui8H36oK1yb+xpWRuwV3G/1Y+ndxbK3ULMW2T87fXx8zBhJ4ZydnWnSpAk1a9bMMd2SR37MnqiryK29sivzX3CXLl1QVZXt27fnmD58+HBUVWXBggVMmTKFkydPcvDgQV599VWWLVuGoig8+uijZd29sDDvzhuc7/SwXeHEx8hTUSGE7XB0tGfQkKZoNLpualpt7oSFSkx0Kv4Bbty5nUjIniuS1BDCgj3wwAMAXLp0qdjr7NmzB4A6deqUS0zCBOzt4aOPdKM75v6MlhF7BbpubgEBAVStWtXcoRSqevXqeHp6Urt2bXOHUmy+vr6Gn62xS2n20k+Wxt/f3/Czi4uLGSOxHGVOfg0ePBiA9evX5+j6OGHCBGrVqoVWq2X69Ok0b96cjh07MvfeiCk+Pj689957Zd29sDAubo4Edaie77xvXltv4miEEKJ8ubk78Wj/xnkaC8D9e6jrkfEE1vLhyuVojhy6ZtoAhRDF1r17d1RVZfHixcVaPi4ujh9//BFFUejRo0c5RyfKXUhI3pZfGo3UbDSypk2bUqtWLYKCgswdSrEpikLlypUtumUS6Foh1axZM0c3TUvn5uaGu7s73t7eVtWltG7dulStWjVH8s7S2Nvb06hRIxo1amSVicXyYJRuj9u3b2f16tVkZmYapru6urJ9+3Y6d+6cpyl/06ZN2bp1q6HwvbAtHy4Zmu/0Q1svkxCTYuJohBCifPn6udHt4br3flMN/1UUxXAhd+liFPXq+XHnbhJnTt/OdztCCPN66aWXUBSFnTt3smjRokKXjYqKYvDgwdy8eRN7e3tefvll0wQpykd6Oqxdm7fll1army4j9hqVu7u7xXchFKZTq1Ytq8sLuLi44OfnZ+4wimRvb2/RXTNNzSifOt26deORRx7Jk/kMDAxk9+7dnD59mhUrVvDHH39w+PBhjh8/XqJiosK6uHm6UK9F5XznzZqwwcTRCCFE+atR04eWraoCCtkTYNm7OZ4/fxc3VwdCD1wlMjLOHGEKK9O2bVuCgoIIDg42dygVQqtWrZgwYQKqqjJmzBiGDx/OsmXLDPNDQkL47bffGD9+PPXq1WPXrl0oisLkyZMJDAw0Y+SizEJCICNDN6rjH3/A4cO6/9asqUt8SesvIYSweooqBUhMKiUlhc8++4w//viD8PBwfH196du3Lx9//LGh1kRxxcfH4+XlRVxcnMWNPBF1K4FRLebkO++302/g4SP9joUQtmfntguEh8eiS4DpEmH6b1lV1fWgqVzFg6i7yTzavzHe8llYbkz1HanfzwfvrcXZ2ThdTVJTk5j+2SCL/H63daqq8tprr/HDDz8U2gVHf/k8ceJEZs6caarwxD1G//u+cwd++w3GjYPsI84lJ8O8efDMM3BvhHshhBCmY8zPe2lvakKpqan06NGDjz/+mMTERAYNGkSNGjVYuHAhrVq1KlGBVUvnV9mDGg3ybwo6e9JGE0cjhBCm0fXhunh5OaOq+tH/dNP1/9VqISYmBVc3B7ZtOUdKSob5ghVC5KEoCsHBwfz99990794dRVHyHYmzY8eObNiwQRJftiIgACZMyJn4At3vEyZI4ksIIWyAdAA1oenTp7N//346duzIP//8YxiOdubMmbz11lu88MIL7Nixw7xBGtGUX4cxtu3cPNMPbDxPfEwKntLiQQhhYxRFod+Axqz48xhpaVmG2smKok+AqaSmZOLu7kBampYdW8/Tu28j7OzlWZS1y54YMca2hHn16tWLXr16kZCQwNGjR7l9+zZZWVn4+fnRsmXLHKNoCSGEEMLyGS35lZmZyYYNG9i9ezeXLl0iISGBrKysQtdRFIWtW7caKwSLlp6ezvfffw9AcHCwIfEFMGnSJBYvXszOnTs5fPgwbdq0MVeYRlW5hjdVAr24eTVvbZvv397I/37OvzC+EEJYM3t7OwYObsrK5cfRalUUBUPrEX1XyLt3Uqhdx4eI8Fj27r1Ml651rGqUIyEqCg8PD7p27WruMIQQQghRRkZJfu3cuZNRo0YRHh5umFbYU0v9TUBFutDfu3cvcXFx1K1bl1atWuWZP2zYMI4fP866detsJvkF8MGSx3mt24I80/etP09CbAoe3tL6Swhhe1zdHHn0sUb8te60oQvkfboE2OWL0TRuWpkzp27j5elMi1Ylq/sohDCuQ4cO8eCDD5o7DCGEEEKUgzInv8LCwujbty/p6emoqoqzszP169fH29tbhrDN5tixYwC0bt063/n66cePHzdZTKYQ2DAAv6ruRN1IzDPvu/9I6y8hhO3y93enc5fa7Nl1+f5EfRJM0SXATp+4RaMmlTkWdh1PL2dq17H8YbOFsFXt2rWjWbNmvPDCCzz77LNWMYy9EEIIIYqnzMmvqVOnkpaWhpOTEzNnzmT06NE4OzsbIzabom8VV7169Xzn66dfvXq1wG2kpaWRlpZm+D0+Pt6IEZaf//48mLf7/5Jn+r7150mISZGRH4UQNqtuPX+i7iRy+tRtXcJLl/OC+//h3Jnb1K7jy5lTt/DwcMI/wL2gzQkLpnI/t2mMbQnzOHHiBJMmTeLdd99lwIABjB49mkcffbRC9VYQQgghbFGZm2bt2bMHRVF4//33eeWVVyTxVYDERF3LJ9fco8jc4+amGx49ISGhwG189tlneHl5GV41atQwfqDloFGbB/Dyz/99B78tIz8KIWxb2w6B+Pm53suM3LuBzpYl0Wap3LgeT2aWlm1bzssIkEKYyezZs2nZsiWqqpKens6qVasYMGAANWrU4P333+fChQvmDlEIIYQQpVTm5FdqaioAffv2LXMwonDvvfcecXFxhldERIS5Qyq2//wwIN/pe++1/hJCCFulKAp9HwvCwVGTo/aXvh2JCiQlpePkZI+qwvat58nK0polVlF6utpuxnsJ03v99dc5fPgwYWFhvP766/j6+qKqKtevX+fzzz+nYcOGdO3alcWLF5OcnGzucCuk4OBggoKCaNu2rblDEUIIYWXKnPyqVasWABkZ8qS6MPrRHQu6WEpKSgJ0owoVxMnJCU9Pzxwva9GySy3cvJxyTrx39s15Z5PpAxJCCBOyt9cwcHCz7L0e4d7gL/qE2PXIeOrU9eXunSQO7g8vaFNCiHLWvHlzZs+ezfXr11mxYgX9+/dHo9Elr/fu3csLL7xA1apVGTduHCEhIeYOt0IZP348p06dIjQ01NyhCCGEsDJlrvk1ePBgTp8+za5du+jYsaMxYrJJNWvWBODatWv5ztdPDwwMNFlMpvbGN4/y2Qtr7k+4dwe4Z905XolOxtM3/66RQghhC9w9nOjZuwFb/jmn+/i7N+qxPvmlqionT9yiecuqHA+7gZ+fKw0aVTJrzEJUZA4ODgwdOpShQ4dy8+ZNFi9ezOLFizlz5gwJCQksWLCABQsW0KBBA1544QVGjhxJ5cqVzR12haD/3LSW+rdCCCFKR/85rxqhWXyZk18TJkxg0aJFzJgxg+HDhxtagomcWrRoAcCRI0fyna+f3rx5c5PFZGqd+jXE2c2B1KR7rQRVdK2/tPDDe//w7tzBZoxOCCHK3wM1vGneqhrHj17XfYkrSo4EmCY9Fe3nX1Jv3Cvs33cVbx8XKlUuuEWwsCQqxitVL/0eLU2VKlV49913effdd9m3bx8LFy7kzz//JCEhgbNnz/Lf//6X999/n379+vHyyy9LOZBypq+Ray31b4UQQpRNQkICXl5eZdpGmZNfAQEB/PXXXzz22GO0b9+e6dOn8+STT5Y5MFvTuXNnvLy8uHjxImFhYbRs2TLH/BUrVgAwYED+tbFsxWtf92XGy+tyTtTAnrVnefnTZLz8pPWXEMK2tWpdnTu3EomMjEO5lwDTCzy8nQdXfM++SlXw7zuE7Vsv8NigJri5OZoxYiFEdunp6aSlpZGVlWVIXquqSmZmJuvWrWPdunW0bNmSH374gXbt2pk7XJtUrVo1IiIi8PDwMIzE2bZt2xJ1h4yPj6dGjRpERESUuJRISfdlLevJMclLjkleckzykmOSl7GOiaqqJCQkUK1atRJtIz9lTn6BrrXSrl27aN++PS+//DKvvPIK/v7+BY5sqKcoChcvXjRGCBbP0dGR1157jU8++YTx48fzzz//GEZ4nDlzJsePH6dbt260adPGzJGWr26Dg/jh3X9IikszVHtWFAUVlc9fXM1nK0eYN0AhhDCBnn0asGrZMRIS03NUN691eBsAVUM2kzx4GIlJCtu3nqdvv8bY25e5TKcoR8YsVC8F7y1PeHi4odvj5cuXAd0FuUajoW/fvjz33HOcOHGCJUuWcO3aNY4ePUrXrl3ZuXMn7du3N3P0tkej0VC9evUc0+zs7EpVD7c0dXRLuy9rWU+OSV5yTPKSY5KXHJO8jHFMjNWwyijJr5UrVzJmzBgSEhIMT79u375d5HpKtqfdFcEHH3zAli1bCAkJoX79+nTp0oWrV69y4MABAgICWLBggblDNIn3Fw3hf4//kbNXhwZO7LtG+Lm71Gzgb7bYhBDCFDQaDf0GNmHZb0cNH4X2aSlUP7EPgBonQth99gbNO9Xj2rU4Dh0Mp0OnWmaLV4iKKC0tjZUrV7Jw4UK2b9+eY4CKwMBAXnjhBV544QUeeOABwzrTpk3jl19+YdKkSURHR/Phhx/y999/m+stVCjjx4+3+H1Zy3qm3Je1rGfKfVnLeqbcl7WsZ8p9Wct6lrQvRS1j5bB9+/bRtWtXsrKyAN3FQPPmzfH29kajKfop9cKFC8uye6uTkpLCZ599xm+//UZERAS+vr707duXjz/+OM8TrKLEx8fj5eVFXFycVY38CPDaw/O5euZujtZfAM5u9iw7N8mMkQkhhImcO0dG/wGkResKeWqyMnCNizLMTvb0Q2vvgKOjHck4ELfodwL7dDBXtFbHVN+R+v389+3VODu5GWWbqWlJfP7VEKv8frcFBw4cMNT0yl5o19HRkUGDBjF27Fh69uxZ6EPcpUuX8vzzz+Pr68vdu3dNFbooAWu+ji4vckzykmOSlxyTvOSY5GWJx6TMLb+mT59OVlYWXl5e/Prrr/Tr188YcdksFxcXpk2bxrRp08wdill9vmYEzwR9q2v9le3aMTUpk//7+TADx9p2908hhKByZRz8fXG4cC7f2a7x9xNhqUEtCbmQgkfbZHxlZFwhysWXX35pGM0R7o8sFRQUxJgxYxg5ciR+fn7F2lbbtm0BiImJKZ9gRZk5OTkxZcoUnJyczB2KxZBjkpcck7zkmOQlxyQvSzwmZW75VblyZe7evcs333zDG2+8Yay4RDFYYja1JH58fzN/LTqKqqp5np4uOz8RZ1cp8CyEsHGZmajTpsH06agoaFStYZZW0aCgEtb/Ba6Pfo0MVUNWlsrAwU1xcLQzY9DWweQtv/6zCicjtfxKS0vi8xlDadCgAXZ2dowfP96k3Q0qKo1GYyhg7+bmxpNPPsnYsWPp2LFjibd18eJF6tevj6Ioht4RQgghhDCfMlfPTU5OBuChhx4qczCiYnlpek8cnOxQUPKM6j51xHLzBCWEEKZkb48ybRpZX3yZI/EFoFG1HHxiAmEDx3E7Ko0aNX1ISU5nz+5LlPG5lbASoaGhnDp1ShJfJvTggw8yd+5cbty4wfz580uV+AKoW7cuWq1WEl9CCCGEhShz8qt27drA/SSYEMWlKArv/Tw433mnDkZy9sh10wYkhBBmYn/iX1Q7O8NzABXQajT4Rui6RKqqyvGw67RsU50rl6I5ffKW2WIVwlYdO3aMAwcOMG7cONzd3c0djhBCCCGMqMzJr6FDh6KqqoxkI0rlwR51qVbXR/dLroYM7z/5h7RuEELYvvR0WLUKJSsL1d6Bs10Go7WzR6PVEnhkB0pmOqBLgIUeCKdRUCVCD4Rz53aimQMXwrY0a9bM3CEIIYQQopyUOfn11ltvUb9+fWbNmsWhQ4eMEZOoYL5Y+2yOovd66SmZ/Dpjt+kDEkIIUwoJgcREaNgQzZHDXHrnE9a9v5C4yjVxTEum0oV/DXURVa3KnTuJ+Pm7sX3LeVJTM8wcvBBClI/k5GTWrFnDmDFjaNiwIc7Ozri5udGiRQumTZtGYmLBDwAWLVpEu3btcHd3x9fXl379+hESElLo/vbu3Uu/fv3w9fXF3d2ddu3asWTJkkLXuXbtGqNHj6ZatWo4OzvToEEDpkyZQmpqaqnec1Es/ZgoilLoqzyOi6mOSVJSEkuXLuX111+nffv2ODk5oSgKU6dOLTJGWz1PSntMbPk8OXPmDF988QUPP/ww/v7+ODg4UKVKFYYOHcru3YXf19rqeVLaY1Ie50mZC96D7h/qiSee4NixY7z55psMHz6cBg0a4OzsXNZNi0JYe8H77L77zyY2/348z+iPAL/8+zqevi5miUsIIcrdnTvw228wbhy4upKVpeW3pYfRJibRcPdaLrXrTaqHj2FxVYU2D1YnIiIWT09nuj5cN8+gIcL0Be/fnbTSqAXvv5j5uE18vwtRWj///DPjxo0DoHHjxjRt2pT4+HhCQkJISEigUaNG7Ny5k0qVKuVYb+LEicyePRsXFxd69+5NamoqW7duRVVVVqxYweDBg/Psa+XKlQwfPhytVkvXrl3x9/dn69atxMbG8tZbbzFjxow861y4cIGOHTty9+5dmjZtSlBQEIcOHeLSpUt07tyZrVu3Gn2UM0s/Joqi4ObmxrBhw/KNf968eTg4OJT9QGRjqmMSFhZGq1at8ux/ypQphSZ7bPk8Ke0xseXzpHr16kRGRuLu7k6HDh3w9fXl1KlTnDhxAkVRmDlzJhMnTswTny2fJ6U9JuVynqhlpNFoDC9FUXL8XtTLzs6urLuv0OLi4lRAjYuLM3coZabVatUhtb5SB1T9Qveqdv/1es8F5g5PCCFMKupukjp/7r48rwU/7Vd//nGf+vOP+9Qzp2+oP/+4Tz1x/Lq5w7VIpvqO1O/n3Ukr1Q/f22SU17uTVtrM97slUhRFtbOzU0+ePGn0bZ84ccKwfVE2ixYtUl988UX11KlTOaZfv35dbdWqlQqoTz/9dI55mzdvVgHVz89PPXfunGF6SEiI6ujoqHp7e6sxMTE51omKilI9PT1VQF25cqVh+s2bN9V69eqpgLp9+/Y88XXu3FkF1DfeeMMwLSMjQx0yZIgKqFOmTCn9my+ApR8TQA0MDCzz+ywJUx2TCxcuqGPGjFF//PFH9fDhw+q0adOK9e9sy+dJaY+JLZ8njzzyiLpkyRI1JSUlx/Qff/xRBQr87rHl86S0x6Q8zpMyJ78URSn1S6PRGOM9VFi2lPxSVVUN+etsvsmvAdW+UI/suGzu8IQQwqTCDkeo8+fqEl36xJc+Cfbzj/vUxfMPqCG7L6kLftqv3r2TaO5wLY6pk1/vvLlCnfzfjUZ5vfPmCpv6frc0+mvQ8kx+yTVu+QoJCVEB1cnJSU1LSzNMf/TRR1VA/eabb/Ks88Ybb6iAOmPGjBzTv/jiCxVQBw0alGedVatWqYD62GOP5Zh+4MABFVArVaqkpqam5ph38+ZN1cHBQfXx8VEzMjJK/yZLyNzHRFXNk9QojDGPSW6fffZZkUkJWz9PcivOMVHVinWeZNe7d28VUKdOnZpjekU7T7Ir6JioavmcJ2Wu+TVlypRSvz788MOy7l7YkI6PNqBKLS/dL7k64057fjlZmVrTByWEEGbSonV1fP1dURRdV0f1XpUCfbGCjAwtCQmpePu4sH3reTIysswYrRBCmE6LFi0ASEtLIyoqCoCUlBS2bdsGkG83Gf20devW5Zi+YcOGAtfp378/zs7ObNmyJUd9Gf06AwYMyNMVqXLlynTp0oWYmBj27NlTqvdXGuY+JpbImMekNGz9PLEVpjom+v1cv349x/SKfJ4UdEzKi31ZNzBlyhRjxCEEAF+ufZaRLYPzJL+yMlTmTdnKy5/0Mk9gQghhBv0eC+L3pYfJzFRRVVAUDMkwgIjwODp1DuTggQj2h1ylS7c65g1YCCsyevRo3NyMU6dNLykpyajbE/m7dOkSAA4ODvj6+gJw9uxZ0tLSCAgIoHr16nnWad26NQDHjx/PMf3YsWM55mfn6OhI06ZNOXToEOfOnaN58+ZFrqOfvm3bNo4fP0737t1L8Q5LztzHRC8pKYlPPvmE8PBwXF1dadWqFUOHDsXd3b3sb7KEjHlMSsPWz5OyqIjniX4/VapUyTG9Ip8nBR0TPWOfJ2VOfglhTN4Bbjw8rAnbV5zMU/z+r0VHefzVdgQ84GW2+IQQwpQcHe3p3a8xG9edutf6K3cCTGVfyFU6dK7Fvj1XqF7di9p1/cwdthBWITQ01NwhiFKaPXs2AH379jW0lAgPDwfI96YMwM3NDW9vb2JiYkhISMDDw4P4+Hji4uIKXa969eocOnSIq1evGhI9Re1LP/3q1auleXulYu5jonf37l0++OCDHNMmTZrE4sWL6d+/f+nfYCkY65iUli2fJ2VV0c6Tixcvsn79egAGDhyYY15FPU8KOyZ6xj5PJPklLM7EWf3YteY0WRnaPAmw/z3xB/O2PQ/ffgtvvAEyoqgQwsZVrepJ4yaVOXXiFnC/1Reohu6Qx45eo3YdX/bsuoR/JXc8PIw7IpAoBpU8rZbLtC1Rbrp27SojpFqxv/76i/nz5+Pg4MDHH39smJ6YmAiAq6trgeu6ubkRGxtruDHTr1PYevrWgQkJCcXeV37rlCdLOCYAI0eO5JlnnqFZs2Z4eXlx/vx5Zs6cydKlSxk6dCh79uyhbdu2pX6fJWHMY1JatnyelEVFO08yMzMZNWoUaWlpDB8+nDZt2uSYXxHPk6KOCZTPeSLJL2FxFEVh0neP8dXL/5dn3q2rcZz537c0+uZdqF4dnnnGDBEKIYRpdehUi8hrccTGpBhu2nWtwBRUVSUpMQOP+k44Otqxc9sF+g0IQqORm3sh8rNjxw5zhyBK6cyZMzz77LOoqspXX31lqBdTkVnSMVm8eHGO31u2bMmSJUuoUaMGn376KR988AF///13ucdhScfEUljSMalo58kbb7zBnj17qFOnDnPmzCmXfRiLJR2T8jhPil3wftWqVSXacEldv36d/fv3l+s+hPXoMrARAdXvZYtzPQGP/eHeH8KKFaYNSgghzERRFPoNCLrX3fH+h6KqqoZk2LGj12nboSZarZbjYaYpHCruU7WgalUjvcz9boSwPJGRkfTt25eYmBgmTZrEhAkTcszX14BJTk4ucBv6mmz6FgnZ68YUtF7udYqzr/zWKQ+WdEwK884772BnZ8eOHTtIT08v1jqlVR7HpLRs+TwpD7Z4nnzyySf88MMPVK5cmb///ttQP6sk+7K186Q4x6QwZTlPip38GjZsGC1btmSFkRMOERERvPrqq9StW5d//vnHqNsW1u2rdc/m6PII4KRNp3XqWd0vf/0FUlhWCFFBuLo68lBXfUF7FX2vreyjQO7afpFqD3hxKDSCu3cS89+QEEJYmejoaHr37s3Vq1cZPXo0M2bMyLNMzZo1Abh27Vq+20hKSiI2NhYfHx/DjZmnpydeXl6FrqefHhgYWOx95beOsVnaMSmMl5cXlSpVIj093TByXHkor2NSWrZ8npQHWztPfvzxRz744AO8vLzYtGkT9erVy3e5inSeFPeYFKYs50mxk19169bl+PHjDB8+nNq1a/P+++9z8uTJEgcLugPzyy+/0K9fP+rWrcuPP/5IVlYWdevWLdX2hG3yrezBY13cCb4zg59vfsbPtz5j7u0vcSRLt0BaGtSrB4GBuldQEJw7Z96ghRCiHDVsXJlKld0Nxe+zUxTIyNCSlJiGr68r27deIDNTmhAJIaxbYmIijz76KKdOnWLo0KHMmzcv35ptDRs2xMnJiTt37hAZGZln/pEjRwDyFGjXd+vRz88uIyODEydO4OzsTIMGDYq1TmH7MhZLPCaF0Wq1xMfHAxh9hFW98j4mpWHr54mx2dJ58scffzB+/HhcXV3ZsGEDLVu2LDCminKelOSYFKYs50mxk1+nTp3iiy++wNfXl6tXr/L555/TvHlzGjVqxKhRowgODiYkJIQLFy4QFRWFVqslKSmJiIgIjh8/zooVK3j33Xd5+OGHqVSpEs8//zybNm0iMzOToUOHcuLECUaMGFGydy5s3tgfniZJ40IlbSyVsmLx1eYq9HfzJoSH615eXlDAMKlCCGErHu3fGI2dkif5pVV1vcTPnb1Li1bViI9L5fDBcLPEWCGpRn4JIUhLS2PQoEEcPHiQPn368Pvvv2NnZ5fvsi4uLvTo0QOA5cuX55mv770yYMCAHNP1I4bl17tl/fr1pKam0rNnT5yzDbKkX2fdunWkpaXlWOfWrVvs3r0bHx8fOnfuXNy3WmyWekwKs2nTJpKSkqhbty6enp7FWqckTHFMSsPWzxNjs5Xz5K+//mLkyJHY29uzevXqIv99K8J5UtJjUpgynSdqCSUkJKhffPGFWrNmTVVRFFVRFFWj0RT7pV/H2dlZfeaZZ9QDBw6UNARxT1xcnAqocXFx5g6lXG3/86j6m/sjahaomSj6Bg+qCmqWolFVRVHVKVNUNSPD3KEKIYRJXL0arc77IUT9aU6IOu8H3eunH0LUuXN0r/lz96lhR66pP80JUa9H2vZ3REFM9R2p38/br69QP/jPX0Z5vf36igrx/S5EYTIzM9UhQ4aogNqlSxc1KSmpyHU2b96sAqqfn5967tw5w/SQkBDVyclJ9fb2VmNiYnKsExUVpXp6eqqAunLlSsP0W7duqfXq1VMBdfv27Xn21blzZxVQJ0yYYJiWkZGhDh06VAXUKVOmlPQtF8mSj8nvv/+uHjx4MM/+d+zYoVarVk0F1JkzZ5bsDReDqY5Jbp999lmx/p1t+TzJrTjHxNbPkz179qguLi6qvb29unr16mLHZ8vnSWmOSXmdJ4qq5n52XDxarZbNmzezbNkytm/fzpUrV4pcx9nZmfbt2zNo0CBGjhxZ4uJmIqf4+Hi8vLyIi4srl+y4JRnXaS7tT65nbPz6PPPSPvsSp/++bYaohBDCfLb8fYYrl2MMLcA0GgWtVkVFVy6xZk1P0jNUkhLTGfpkCxwd83+SZ6tM9R2p389/Xl+Ok1PBw3+XRFpaMjO+e4IGDRpgZ2fH+PHjGT9+vFG2LYS1mD17NhMnTgRgyJAhBf4dz5gxA39/f8PvEydOZPbs2bi6utKrVy/S09PZvHkzqqqyYsUKBg8enGcbK1eu5Mknn0RVVbp3746fnx9btmwhNjaWSZMm8fXXX+dZ5/z583Ts2JGoqCiaNWtGUFAQoaGhXLp0iU6dOrFt2zacnJyMciz0LPmYjBo1isWLF9OgQQOaNGmCg4MD586dIywsDICnnnqKX3/9FY2m2B2PisWUx2TIkCHcuHED0A3WFhERwQMPPED16tUBqFq1KqtXr86xjq2fJyU9JrZ+nvj4+BAbG0vt2rXp2rVrvvt46KGHGDt2bI5ptnyelOaYlNd5UurkV26RkZGEhIRw7do17ty5Q3R0NM7OzgQEBBAQEECzZs148MEHcXBwMMbuBBUr+ZUQm0JotYfolnIUDSoKul4hWhRCK3egw80Qc4cohBAmpdWqLF0USnpalmFaji90FXr2rs+ef07R5dgGas/+CIrZRcUW2ELyqyJ8vwtRkKlTp/LRRx8Vudzly5epVatWjmmLFi3i+++/5/Tp0zg6OtKhQwcmT55Mp06dCtzO3r17mT59Ovv37yc9PZ2goCBee+01nn/++QLXiYiI4MMPP2TTpk1ER0dTs2ZNnn76af73v/8Vu0tgSVjyMdm4cSO//vorhw8f5ubNmyQmJuLr60ubNm144YUXGDZsWInfb3GY8pjUqlWLq1evFriPwMDAfBuE2PJ5UtJjYuvnSX61snJ7/vnnWbRoUZ7ptnqelOaYlNd5YrTklzC9ipT8Ij2dTE9v7NNSyMSOLa5t6Jl8GHuySFac2L1gF31GtTN3lEIIYVJRd5NYu+pfsrLUPIkv0BXBfzT+CNX/+xp3Z/+E/xvjzBGmWZg8+TV+mXGTX8FPVozvdyGEEEIIEzBue0IhyktICPZpKdx0qcKblV5njs/jTKr8BpH2/riqaex6ewExd5LMHaUQQpiUn78b9RoEGLo65qaq4LBmFQCZv/9JWlqmSeMTQgghhBDCEkjyS1iHJk1g1iy8rp4iwqkaiqJw1aEqEytNZJ7XQMIdKvNK15+QhoxCiIqmS7c6ODnZoarZEmD3frBPS8H/0G4AAg7tInTrabPEWBHkGI3FCC8hhBBCCGE89uYOQIhiCQiACRNwAd5fOJTpo3QtGdI1jqz3eEi3TGIm307ayIRv+pkvTiGEMDFFUeg3IIjVK/7F82Y4vX96F/v0VFBBk5WJXWYGAHaZGbR6+mEyPVywt9OAmxusWQMNGpj3DQghhBBCCFHOpOWXsDptH6lLq26B+c7btuIkpw9dM3FEQghhXgEB7tSr70+yly/pzu54RN/CI+YWbvFROZZzi4/CPvIahIeDlxdUqWKmiIUQQgghhDAdafklrNLkxcMY3mAWGelZeeb9d+jvLD/3Jo7OcnoLISqO7j3qsfhKNP836Qdab1xI602LUFHQqFrDMqrGDlQtkaPfoPrcGWAvn5NC5OfYsWPs3r2bS5cukZCQQFZW3uuN7BRFYf78+SaKTgghhBAlJVe9wirZ2WmYuXEkrz+yMO9MFd56bAnfbXnB9IEJIYSZaDQK/R4LYu3qExx6bCxpru50WvldjmUUbRaRb01lY93eDIpKpVJldzNFa3tUVTVa3UmpX2k+Z8+e5YUXXmD//v3FXkdVVUl+CSGEEBZOkl/CatVs4M+AsW1Y9/PhPPPCz0axftERHhvV2gyRCSGEeVSu4kHtOr5cvhSNX8R5tBoNilaLAqiAqtHgeOpffNsNYdeOiwwd1gyNnVRAEAIgMjKSrl27cvfuXUMC0t3dHR8fHzQa+TsRQgghrJl8kwurNnZKDzx9XfKdN2/yVqJuJJg4IiGEMK9HejXA1V6l9rGdaLRatHb2nOo8CK2dPRqtFq9tG+nYtgox0cmEHb1u7nCFESQnJ7NmzRrGjBlDw4YNcXZ2xs3NjRYtWjBt2jQSExMLXHfRokW0a9cOd3d3fH196devHyEhIYXub+/evfTr1w9fX1/c3d1p164dS5YsKXD5DRs28P7779OzZ0+8vb1RFIXu3buX6r1euXIFRVEKfFUpQx27Tz75hDt37gAwduxYzpw5Q3x8PFevXuXy5ctFvoQQQghhuaTllxUKDg4mODi4yPoTFUXwjjE81/z7fOeN7zGf305OQKNRTByVEEKYh0aj0MsjCse0FGIq1WTLmOlEVavLia6P03v++3jfjuDkT6tpNaQf4VdjqFvPDy/v/B8iiBLQqrqXsbZVAr/99hvjxo0DoHHjxgwcOJD4+HhCQkKYMmUKv//+Ozt37qRSpUo51ps4cSKzZ8/GxcWF3r17k5qayubNm/nnn39YsWIFgwcPzrOvlStXMnz4cLRaLV27dsXf35+tW7fy/PPPc/z4cWbMmJFnnREjRhAXF1ei91SUypUr07dv3zzTvby8Sr3NTZs2oSgKI0eO5KeffipLeEIIIYSwMIoqhSWsVnx8PF5eXsTFxeHp6WnucMxq8x/H+P7tf/Kd13VwY9767jETRySEEGZ05w7H3plBaLM+ZDk7o2pBUcAuLZXGIf/H+Ta96Dy0LQf2R+Dj40K/AY1RFNt6SGCq70j9fia99AdOTq5G2WZaWjIz5z5V7NgXL15MSEgIEydOpHHjxobpN27coH///hw9epSnn36a3377zTBvy5Yt9OrVCz8/P/bt20f9+vUB2LdvH927d8fV1ZXLly/j7e1tWCc6OpratWsTHx/PypUrGTp0KAC3bt3ioYce4sKFC2zfvj1Pq64xY8bQuHFjHnzwQTIyMujduzfdunVjx44dJT42V65coXbt2qVevzDOzs5kZGSwZcsWHn74YaNuWwghhBDmJd0ehU3o9VQLAhv55ztv15rTHN931cQRCSGEGQUE0OiHT8hy0iW+AFQVMh2d+bf7E6S4e7N18wU6d6lFRHgsly9GmzdeUSbPP/88c+fOzZH4AqhatSrBwcEArFq1ivT0dMO8mTNnAvDBBx8YEl8AHTt25OWXXyY2NjZPAfeff/6Z+Ph4Bg0aZEh8ga4V1pdffgnA119/nSe++fPn85///Ifu3bvj4eFRxndbfnx8fAByJPyEEEIIYRvKnPyKi4tj2rRpTJs2jRs3bhS5/I0bNwzLJyUllXX3QhjM/GskSgHdGycPX0Zqcnq+84QQwhY5OdvTrkPNAuerqsq5M7cJrOXD3j2XyUiXrvS2qEWLFgCkpaURFRUFQEpKCtu2bQNg2LBhedbRT1u3bl2O6Rs2bChwnf79++Ps7MyWLVtITU013hswoQcffBCAc+fOmTkSIYQQQhhbmZNfv/76K1OnTuXXX3+latWqRS5fpUoVfv31Vz766CP++OOPsu5eCAN7Bzs+XfFU/jNVmNR/qWkDEkIIM2vVpjqurg45pmXv3nj5Ugwt21QjNSWTw4ciTB2eTVHRta4zysuIcV26dAkABwcHfH19ATh79ixpaWkEBARQvXr1POu0bq0bKfn48eM5ph87dizH/OwcHR1p2rQpqampJkke3bp1iylTpvDiiy/y9ttvs2LFihwt20rjjTfeQFVVqfclhBBC2KAyJ782btyIoig8+eSTxVpeURSeeuopVFXN80RRiLIKaludDn3r5zsv8kI0q388YOKIhBDCvB4b1CTH76qqq/+l+1ll04YztH7wAY6H3SA6KtkMEYryNHv2bAD69u2Lk5MTAOHh4QD5Jr4A3Nzc8Pb2JiYmhoQE3ajJ8fHxhqL1Ba2nn371avmXGjhz5gzTpk1j3rx5zJgxgyeeeIL69etz8ODBUm+zV69evPvuu2zfvp1XXnmFjIwMI0YshBBCCHMq82iPYWFhAHTq1KnY63Ts2DHHukIY039/GsSTDWaRnpqZZ96iT3bRqX8jKtco/WhQQghhTXz9XKlT15dLF6PJb4yblORMXN0c8fBwYvfOSwwc0sTmit+bgqqq+R7f0m4LdAmn7JycnAwJrOL466+/mD9/Pg4ODnz88ceG6YmJiQC4uhZcoN/NzY3Y2FgSEhLw8PAwrFPYem5ubgCGhFl5cHJy4pVXXmH48OE0btwYFxcXTp48yccff8xff/1Fnz59CAsLIzAwsMBtLFmypMB5jRs3plOnTvz000+sW7eOYcOG0ahRo0KPld7IkSNL9Z6EEEIIUf7KnPy6ffs2QLG6POpVqVIF0DVZF8LYFEVhzo4XGNsh/24Lr/dcwO+nJmBnJ+M9CCEqhkd6NyByQSgpKZloNEqeJM32LRd4bFAQf607zflzd2nQMMBMkYrsatSokeP3KVOmMHXq1GKte+bMGZ599llUVeWrr74y1P6ydlWrVmXOnDk5pnXo0IENGzYwYsQIfvvtNz799FPmzp1b4DZGjRpVrATvjRs3+O6774oVl6IokvwSQgghLFiZ7/6dnZ0BSE4uflcJ/bJ2dnZl3b0Q+Qp4wIvhEzvmnKjoXmnJmXz5yhpzhCWEEGZhZ6ehU5faADkSX9lzYGdP36JpsyqEHYkkPT1vy1lRBKMV/FIN/zARERHExcUZXu+9916xQomMjKRv377ExMQwadIkJkyYkGO+u7s7UPi1m35QIv3ojPp1Clsv9zqm9r///Q+Av//+u8hl9S31jPkSQgghhOUqc8uvqlWrcv78eQ4dOlTsro+HDh0C7rcAE6I8PPPWQ/zz63Fi7twbVVR/XaqB/RsvcnjHJdp0r2O2+IQQwpQaNqrEgX3hJCakoSi5a3/B+XNRPPFUC06euMXRw5G071hwtzFhGp6ennh6epZonejoaHr37s3Vq1cZPXo0M2bMyLNMzZq6UUCvXbuW7zaSkpKIjY3Fx8fHkMjy9PTEy8uLuLg4rl27RlBQUJ719NsrrMtheapfX1fzs6jRxy9fvmyKcIQQQghhQcqc/OrSpQvnzp1jzpw5vPLKKzg4OBS6fEZGBnPmzEFRFB566KGy7l6IQv24ZyzDG82+n/hS0P2swLTnVvL76Qm4ujuaMUIhhDCdxwY25o9fw3K0+Mr+86a/ztCydTXCjlwnqGkVPDyKX19KmF9iYiKPPvoop06dYujQocybNy/f7n0NGzbEycmJO3fuEBkZyQMPPJBj/pEjRwBo3rx5juktWrRg165dHDlyJE/yKyMjgxMnTuDs7EyDBg2M/M6KJyYmBrhfe6wg5krOCSGEEMJ8ytztcfTo0QCcP3+eZ555ptAm9MnJyTz99NOGIbD16wpRXpxdHflw8dD7E+51fVQ0CijwStd5ZotNCCFMzdfPjZo1vQ2/5+6plRCfRrUHPHFysmP/3ismjc3qqUZ+lVBaWhqDBg3i4MGD9OnTh99//73A8hIuLi706NEDgOXLl+eZv2LFCgAGDBiQY3r//v1zzM9u/fr1pKam0rNnT0NJDFNbuXIlAK1btzbL/oUQQghhucqc/OrUqRNPPfUUqqqyatUqGjduzPTp09m5cyfnzp3j3Llz7Ny5k48//pjGjRuzevVqFEVh2LBhdOvWzRjvQYhCtXm4Lh37189xtquqCgrE3klm5pvrzRecEEKYWJ/+jcjdGOh+90eV9f93ivYdAzl/7i43b8Tn3YCwOFlZWTz99NNs27aNLl26sGrVKhwdC2/VPGnSJACmT5/O+fPnDdP37dvH3Llz8fb2ZsyYMTnWGTt2LJ6enqxdu5ZVq1YZpt++fZt33nkHgLfeesso72nkyJE0atSI1atX55g+b948zpw5k2f5VatW8d///heA8ePHGyUGIYQQQtiOMnd7BFiwYAF3795ly5YtXLt2jSlTpuS7nL4YaK9evVi8eLExdi1Esbz7wyCebzOHuKhcLRM1sHPVadp0r0u3QY3NE5wQQpiQg4MdD7arQeiBCMM03deziqIoaLNU0jOy8A9wY++uywx9snmxRsar6IxZ9Lyk2/n+++8NSSJ/f39effXVfJebMWMG/v7+APTs2ZMJEyYwe/ZsWrZsSa9evUhPT2fz5s2oqsrChQvx9vbOsb6vry8LFizgySefZNiwYXTv3h0/Pz+2bNlCbGwskyZNonv37nn2+/HHH7NhwwZA1zUTdF0rO3ToYFhm9erVOUYODw8P5+zZs8TFxeXY1q+//sqLL75I8+bNadCgAVqtllOnThkSYm+//TZDhgwpwdG77+bNm4ai+R9//HGe7qC5RUZGMnnyZBRF4auvvsLX17dU+xVCCCFE+TNK8svZ2Zm///6b7777jhkzZhRYQLVGjRq8/fbbjB8/Xi6khUkpisK8kBd5Kmg22izVME3vmwkbqNe8Mg/UlgtXIYTte7BdDY6FXSctNTPbZ6Huvyqwe+clhjzejLWrTnD+3F0aNAwwW6yiaPpaV0CellLZTZ061ZD8Apg1axYtW7bk+++/Z/PmzTg6OtKzZ08mT55c4CBGjz/+OLt27WL69Ons37+f9PR0goKCeO2113j++efzXefixYscOHAgx7SEhIQc09LS0or1XseNG0dAQABhYWH8888/pKSkEBAQwNChQ3nllVfo2bNnsbaTn6VLl7Jo0SJatmxZZOIL4IEHHiAsLIxjx47RokUL3njjjVLvWwghhBDlS1GNPDazqqqEhYVx9OhR7t69C+ieQrZu3ZoWLVpI0suI4uPjDSMvlXQ0qIrqRngsr3T9GVVV856LCvx5egJOzoUP2iCEELYgIjya/1t9CtA9DMh+OaACQU0qk5aWyZ3bSTz9bCscHPKvH2WpTPUdqd/PG6N/xcnR1SjbTEtP5tuFI+T73cR69erFtm3b+Pjjjw0twIryxRdf8N5779GnTx82btxYzhEKIYQQorSM0vIrO0VRaNWqFa1atTL2poUos6o1vXnj60f59q18LlBVGN32B349/rokaYUQNq9GTV+8vJ2JjU3NUflenwg7dfIWTz3Tgr83nuP4sRu0ebC6GaMVovydOHECgHbt2hV7nQcffBCA48ePl0tMQgghhDCOMhe8F8La9Hi8Ce371Mt3XnJCOh8M/8PEEQkhhHn0HxBE7lS/qqqGaTt3XOKB6l4cOXSNtLRMU4cnhElFRUUBEBBQ/G6++m6k+nWFEEIIYZmMnvy6ePEiv/zyCzNmzGDatGmGro9CWJL35g7Gp5JbvvNOHozkz29DTByREEKYno+vK1WreaCC4WWgwo3rCTRtXpmsLC1HDudfz1MIW+Hu7g6Qp8h+YeLjdSOiFjW6phBCCCHMy2jJryNHjtC1a1caNGjA888/z7vvvstHH33E7du3cywXHBxMpUqVqF+/PhkZGcbavRAlNm/vi2js8u/e+PvMEE4cCDdxREIIYXqPPpaz9ZdKtgFBVNi4/gzNW1bj2NHrJCWlmyNE66Cqxn0Jk6teXde1d9++fcVeZ+/evQDFKpAvhBBCCPMxSs2v9evX88QTT5Cenp6jYG5+dZNGjhzJf//7X6Kioli/fn2ph6MWoqzsHez4ed9LvNDux3znfzB8GYsPv4qXn3EKGAshhCVycXGgXgN/Lpy7a8i5qKgoii4HExebRoMG/pz89waHDkbQ7eG65g1YiHLSvXt3Tpw4wXfffccrr7xS5GAD8fHxfP/99yiKQvfu3U0TpABAq9Vy/fp1PDw8pE6rEELYMFVVSUhIoFq1amg0ZWu7Vebk140bN3j66adJS0ujSZMmzJgxg4ceeggPD498l/fw8GDgwIH88ccfbNy4UZJfwqx8K7nzzo8D+PLldfnOf6H9Dyw7+yZ2dlIeTwhhu3r2bsDF87rklz7pZZ+ZRrOdKzjWdRhrV/9L6zbVObA/nFatH8DTy9ncIQthdC+99BLBwcHcuHGD/v37s2LFCipXrpzvsjdv3uSJJ57g+vXraDQaXnrpJRNHW7Fdv36dGjVqmDsMIYQQJhIREWFooV1aZU5+ffPNNyQlJREYGMju3bvx9vYucp3u3bvz+++/c/jw4bLuXogy69S3IV0Hn2fXmjN55mVlqrzS/Wd+2v2iGSITQgjTsLPT0KrNAxwOjTS0/qpzbCed1/9IonclzrXpRY2anhwLs+fA/qv06tPQvAFbIFVVc7R+L+u2hOk1adKECRMmMGvWLEJCQqhXrx7Dhw+nS5cuVK1aFdA99N21axfLli0jOTkZRVEYP348LVu2NG/wFYz+IXtERESRLfSEEEJYr/j4eGrUqFFg46qSKHPya9OmTSiKwltvvVWsxBdAo0aNALh8+XJZdy+EUUya9RinDkZy93pCnnm3I+KZOWE9k2Y/ZobIhBDCNDp0qsWxsOtkZKhoFKgbtgOAese2c65NT1avPEmnzrU5sP8qUVFJ+PnlP2iIENZsxowZxMXFsXDhQpKSkli4cCELFy7Ms5w+QTl27FhmzZpl4iiFvqujp6enJL+EEKICMEYX9zL35bp69SoA7dq1K/Y6+i+pxMTEsu5eCKP5ac+LaOzz/6PatfYMW5edMHFEQghhOoqi0LZDIAB2qSkEntkPQODp/dinpZKWloV/gAtOzvaEHogwZ6iWSTXyC2jbti1BQUEEBweb8I1UbBqNhvnz57NmzRo6duwI3G/Vl711X+fOnfm///s/fvrpJ6k5JYQQQliBMrf8yszMBHSFJ4tLP4S0fkhpISyBRqOw9Mh4RjT/Pt/5372zifqtq1Cznr+JIxNCiHJ27hwMHkybpCQaJKShyczAPlM3IrN9ZgYjP3mKLDsHlI/hCW8Plg3/iJgONfHxlQFBylNoaKi0ajGTgQMHMnDgQKKjowkLC+Pu3bsA+Pv706pVK3x8fMwcoRBCCCFKoswtv6pUqQLApUuXir3OwYMHAahZs2ZZdy+EUbl5OjNlybAC57/RaxGpKekmjEgIIUygcmXw8oLwcDxibuGWEJ1jtltCNJ6xt/CIuYXGxxuqViH0oLT+yk5VjfsSlsHX15cePXrw5JNP8uSTT9KjRw9JfAkhhBBWqMzJry5duqCqKsuXLy/W8unp6cydO1eGhRYWq1XXWvR+uln+M1V4oe2PUoxYCGFbvLxg92748ENQFLRKzssDraJBVRQO9B7FgpEzaN6lIWfP3CYuNsVMAQshhBBCCFF8Ze72OGrUKJYsWcL//d//sXnzZnr16lXgsunp6YwcOZKLFy+i0WgYN25cWXcvRLl49bM+HNsbzq3wuDzzkhPTeXvwL8xY+5wZIhNCiHJibw8ffQTe3mgmTcoxS6Nq2TXoNcK6PQlaqFLVAxcXBw6FXuORXvXNFLBlkdEebc+tW7fYsWMHJ06cIDpa1xrS19eXpk2b0r17dypXrmzmCIUQQghRXGVOfnXv3p3hw4fz559/MmDAACZMmMDjjz9umH/lyhViY2PZu3cvP/30E5cuXUJRFF5++WWaNGlS1t0LUW5+3DmWYfW/ISszbz27C8dusejTnYz6XzczRCaEEOUoLAzs7FCzslC4V39do8E/8gKqCooCq1ccp32HWoTsvUK79jXw8HQ2c9BCGM+NGzeYNGkSq1atMtS2zc3e3p7HH3+cr7/+mqpVq5o4QiGEEEKUVJm7PQIsWrSIfv36kZ6ezowZM+jYsaNh5JsBAwbQpUsX/vvf/3Lx4kVUVWXIkCHMnj3bGLsWotwoisIvx14tcP6an0I5uPWiCSMSQohylp4Oq1ZBVhbYO3Ci4wC0dvZotFrq/bsTTWYGqgrp6Sq1avvg6GjHoUPXzB21ZZCiXzbh2LFjNG/enGXLlpGRkZFnpEf9KyMjgz///JMWLVrw77//mjtsIYQQQhTBKMkvJycn1q9fz9y5c6lTp06BFwrVq1dnzpw5rFixAjs7O2PsWohy5eLmzPRlwwuc/+mY1dwMjzFhREIIUY5CQiAxERo2RDlymF1Pv8vvb84jJqAGjmkpVL1ywrDoyhXHaf1gdWKiU0hKkoFAhPVLSkqif//+REVFoaoqPXv25M8//+TKlSukpqaSmprKlStXWLZsGb1790ZVVe7evUv//v1JTk42d/hCCCGEKESZuz1mN27cOMaNG8epU6c4dOgQt2/fJisrCz8/P1q1akXr1q0NLcKEsBZN29Vg+ISO/Dl7H6Dr8gP3H8y/3G0+f5x4A2c3RzNFKIQQRtKkCcyaBePGgasr7VIj2Juh5fe35tNk3zqiq9Q2LJqclEn9Bv4c3B/O8bDrdOxcy2xhC2EM33//PdevX0ej0TB37lzGjBmTZ5maNWtSs2ZNhg0bxoIFCxg3bhyRkZEEBwfz9ttvmyFqIeNqN2sAANJXSURBVCyPVqvl7t27eHp64uws3eKNSavVcvXqVXx9ffHy8jJ3OMUWFRUFgJ+fn5kjKZiqqkRFReHm5oaLi4u5wykRVVUlz1IMRk1+6QUFBREUFFQemxbCLJ5+szPnj93g6M4r92reKCiKCiioqspzrb7nj9MTsbMzSmNKIYQwj4AAmDDB8GvrNg+wb+9VMhycCev6xL2pusy/qsL/rT5Bk6ZVOH7sBg+2q4GDg7TqFtZr7dq1KIrCqFGj8k185fbCCy8QEhLCggULWL16tSS/TCA4OJjg4GCysrLMHYooRHx8PLdv3yYlJYXAwEBzh2NTLl68SFpaGklJSVaT/EpLS+PGjRsAeHt7W2wPsMTERG7evImTkxP161vHYD6qqnL69GkAGjduLAmwIsiduhDF9OGiYVSr7QPoR+LSlYJWFIXMDJXnWn4vI3QJIWyKRqOhWQtdMW/951v2klRRUSk0bVaZtLRMTp+6ba4whTCKc+fOAfDUU08Ve52nn346x7qifI0fP55Tp04RGhpq7lBEIdLS0gBdKyVhXPpja030rb4AUlJSzBhJ4fRxWtMxTkpKQqvVotVqLfrYWgpJfglRAsHbxuDh43wvq65PgOmkJGYwrtNcs8UmhBDloUvX2igK+T5NVBSFvXuuULeeP0ePRFboBwCqVjXqS5heYmIiAL6+vsVex8dH91AsKSmpXGISArC6z9b0dF0dSGuLW5SPuLg4w8+WnKCxxs/x27fvP3i0xvhNrczJr6ysLPbv389XX33FuHHjGDZsGH369OGJJ57gpZdeYubMmRw8eFAy/8JmLD78Kg6OGvQtv7KLupnEm/0WmSMsIYQoF3Z2GurV9wfy1pRQVZVLF6Np3eYBYmNSuHwp2lxhClFmAQEBAIYuJMVx5swZAPz9/cslJiFuh4dz6623iLt1y9yhFFtGRoa5QxAWJHs3ZUtuVWWNydrsg61YcmLRUpS65ldmZibBwcHMmDGD69evF7l8jRo1ePvtt3n55Zcttp+vEMWh0Wj49cQbDG80C1WbtyXEldNRfDR6BVMWDjNDdEIIYXw9e9Xn/Lm7QN6LQ1WFiPAYqlb14MjhSOrUtdxituUpe3dQY2xLmF6HDh1YuXIlM2fOZPjw4djbF36ZnJmZycyZM1EUhQ4dOpgoSlHRpP32GzW++YaIypXxevddc4dTLNbS8ktVVTIzM3FwcDB3KBVGZmamuUOwWZacWLQUpWr5FRUVRY8ePZg0aRLXr19HVdUiXxEREbzxxhv07t2b6Gh5MlwWwcHBBAUF0bZtW3OHUmE5ONix5MirBc4P23GV4Pf+NmFEQghRfhyd7KkZ6J0jKZM92bN3z1VatalO5LU4bt1MME+QQpTRyJEjAQgLC6N///6FPty9fv06AwYM4MiRIwCMGjXKFCGKCsjzn39y/NfSabVaQ4LD0pNfUVFRnD17ltjYWHOHUiyWfjyLQwarKD/6pLMoWIlbfmVlZdG/f39CQ0MN3R969+5Nz549ad26NX5+fri7u5OQkMDdu3c5evQomzdvZuvWraiqyo4dOxg4cCC7du1Co5GSY6Uxfvx4xo8fT3x8vNWM8mGL3L1cmLPjBV7tviDf+Vv+OEFAFXeenNDZxJEJIYTxPdKrHvN/yllkWlHuJ8Ccne0IDPThWNh1evdtaIYIhSibAQMGMHjwYNasWcOWLVuoU6cOvXv3pn379lSqVAlFUbh16xYHDhxg8+bNhhuNIUOG0L9/fzNHL2xSUhIee/YA4LF7NyQlgZubmYMqnDV1edTX+UtNTTVzJMUTHx9v7hCKTavVkpycjKura57plsgWknK2kBwtbyVOfn3++eccPHgQRVFo1aoVS5cuJSgoqMDle/bsydtvv82JEycYOXIkYWFh7Nu3j6+++op3raTprhAFqRrow8d/DGPyUyvynf/7rP34VfPkkSeamTgyIYQwLk9PFzw8nUiOiqfV3pUc7fw4WQ5Ohvlr15ygXftA9u8Lp2u3Oji7SDcSYX1+//13Ro4cyfLly0lPT2fDhg1s2LAhz3L6m4wnnniCJUuWmDpMYavOnYPBg3VJrqws1NRUNPeSSZqMDAgMBGdnsLPTJcHWrIEGDcwacm7ZW59Y+s24vl5S9rpJliwiIsLcIRRbdHQ0N2/epFKlSjmmW2ryS+plVQwlanqVkZHBt99+a0h87d27t9DEV3ZNmzYlJCSEVq1aoaoq33zzjfT5FTahaftAXvuid4Hzv3/nH47sumTCiIQQonz0eKQu9f/dRZcNc6l3YheoKrrBb1Uy0lXq1PVF1aqcOmU9hZmNRqsa9yXMwsnJiT///JN169bx6KOP4uLikqeUh4uLC48++ijr16/nzz//xMnJqegNC1EclSuDlxeEh0NkJEpUVM75UVEQGamb7+UFVaqYJ85CWFPyS5+IsZbklzXRJ5Nyt6qz1ORX9hEpLV1WVhbR0dFW1crSUpQo+bVu3Tru3LmDoij88ssvODs7l2hnzs7OLF26FEVRuHPnDuvXry/R+kJYqkeebMbQVwuuwfbx86u5fOp2gfOFEMIa1KnrT4N/dwJQ/9hOUBTdzc29sT+2/nOeevX9OX7shsXf9FiDtm3bEhQURHBwsLlDqXD69+/Phg0biIuL4+zZs+zbt499+/Zx9uxZ4uLi2LBhA/369TN3mMLWeHnB7t3w4YdA7jHF0fU1B5gyRbecp6dJwyuO7Dfklvw9YAvd3CyZ/jywluSXvgusNYiKiuL69evcuHHD3KFYnRIlv/bc63Pes2dPGjVqVKodBgUF0atXLwB2795dqm0IYYmee7srHfvVL3D+pMeWcue69fTVF0KIPJKSqH32AAC1z+zHPj3l/t2ZqnI9Mp7mLaoQE53CtQjreYpqDCpFD/5T7Ne9gxoaGsqpU6cYP368md9dxWVnZ0f9+vVp37497du3p379+jJquShf9vbw0UfQuzd5xhRXVejTB6ZO1S1ngayl6La1xGmt9Emv3MfZUhOi1tSKSj+qozUl7CxFiZJfhw8fRlEUHnnkkTLt9JFHHkFVVQ4fPlym7Qhhad4JHkjdZpXzneeQlcHGps+QeDvGxFEJIUQpnTsHQUG6OjOBgVCvHpoM3YWsfVYGoz9/hjGfDmfMJ8MZOWMkXnciuHUjDl9fF44fkyeSQghRap6eqIpy//kCgEZjka29srOWbo9S46n8aLVai23hZQv0iTo5xiVXokcG+iJ7zZs3L9NO9etfvXq1TNsRwhLN+L9nGdNxLtE3c2bjOyb/y8iYDXzT7DVeu7YEBwd5ciyEsHD6+jOnT+c72z0h2vDz9ZpBJLv7smf3Vbo+XI/dOy+RlJSOm5ujqaIVwqiOHDnCli1b+Pfff4mO1p3rvr6+NG3alJ49e9KmTRszRyhsVno6bNqEoqqoGg3Rgwbhs24dZGbCpk26+Y6W+dlqLS1oEhISzB2CzbKWc8BaSavF0itRyy99ITgfH58y7VS/vjUVlhOiJH4OeREn15y55U5JxwDomHicEU2/lWy9EMLyZa8/oyi6VgfZaBUNqqKwr+fzLHvlW9Kd3dBqoWagF94+Lpw/d8dMgQtRekeOHKFDhw60bduW9957j99++41NmzaxadMmfvvtN/73v//Rrl072rdvz6FDh8wdrrBFISGQmEiGvz+KVktS+/Zc+PNP3ciOCQm6+RYoKysrRy0tS275ZW1dxiz5WOZmC8kvSz3eWq1WBg0sgxIlv+LjdfWK3N3dy7RTNzc3QDLuwnYpisKvx19HY6er1uCkTaN1yhkA2iSfRpOawsiWUsBYCGEF9PVnvv4aciXtNaqWnQPGs6/XaLSa+wn/v/86g7+/G0cPX7fYC0gh8rNixQo6depEaGiooQabg4MDlStXpnLlyjg4OBimh4aG0rlzZ5YvX27usIWtadIEZs0iOSgIAM9//iGtQQM4ehRmzdLNt0DWUt8JLDu2/FhTsk5fk8pa5Df4gaWeH7aQWDSnEiW/jD0qhrR8ETbr3DnsmjVlefos5kZMZ07k5zig+/txIIs5kZ8z89SHRDn56erpnDtn5oCFEKIIYWGQrdC3iq7lV0Dk+RyLqSrcvJFE46BKREclc/uW9Vywl4WqGvclTO/s2bM899xzpKenY2dnxyuvvEJoaChJSUlcv36d69evk5SUxKFDh3jllVewt7cnIyODkSNHcubMGXOHXyEEBwcTFBRE27YFj7BtEwICyBo9Go99+wDw2L0bJTkZXF1hwgQICDBzgPnT35jLoBDGZ03lgqytnlruESnBckcDleRX2ZQo+SWEKKZ7dXI0ERFUyorFNytnK0ffrAQqZcXilx7N5etpUKWKmQIVQohiSE+HVasgKwscHODFF8HBAY2qpf6JXWgyMwwJG+Xe8GQJ8Sm4uTly8sQt88UtRAl88cUXpKWl4ezszD///ENwcDBt2rTJcSNvZ2dH69atCQ4OZvPmzTg7O5Oens6XX35pxsgrjvHjx3Pq1ClCQ0PNHYrxZR9gpHp1tIGBaO7d6GoyMmjQpw9Ur66bb6EPTvUtvxzv1SOz1NYztsJSEzTWlvzKrxSTpbZek3pfZVOqMXLnzJlDpUqVSr3T27dvl3pdIayCvk7Oxx/Dxx+jKgpKtpaOWSgowDLvniz36knd59fx5eoR5otXCCEKc6/+DA0bwvLl0KwZymuvEd97AJ43r1L1ygki67W6t7AKKOzYdokWrR7g1MlbdHu4DnZ2Nv68TavqXsbaljC5LVu2oCgKEydOpHv37kUu361bNyZOnMjnn3/Oli1byj9AYdtyDTDikGu2Q2wsxMbqfunQwSIfnOpvzJ2cnEhJSbHY5Jet9D5KS0vD1dXV3GHkYW0JmvxKMVnqOWJtx9bSlCr59cMPPxg7DiFsj75Ojrc3yqRJOWbZoTLfdyDrvboCcOHYTd5/6g8++eMpc0QqhBCFu1d/hnHjdN1uAJo1I2XvAQ5PnE5U5dr3Wn6paDQKqgqZmVrqN/DncOg1rlyOoW49PzO+ASGKdueOboCGfv36FXud/v378/nnnxvWFaLUsj84nTbt3mOE+wy/T5kCH3ygu860IElJSYa6VI7ZRqJUVRVFUQpazSwstVVPScXFxVlk8stSk54Fya8rYUpKCp6enmaIpnC2cu6aS4kfw+qLfJb1JUSFkU+dnCwUaqdFonD/wub0wUgmP/2nGQIUQogiBATo6szkusiuXKcyJ3o8SYq7173ujsq9mvgqqgonjt/AP8CNUycrQNdHI10fqVL0y2wC7tVRcnZ2LvY6Tk5OAPj7+5dLTKKC0T847d2b3OkiBaBPH5g61eISXwCRkZF5uj1aKmvrllcQSxw8zlJbTJWUpbawyq8+mSi+En1ybt++vbziEMI25a6TM3o06vwF2GVl0jH5BD+qmWRqHAw3OicPRvLu0F/5YpV0gRRCWIcWLasReiAix4Mt/Y//Hr9Jt4frErLnCmmpGTg55+7II4Tl6Ny5M8uWLSM0NJQHH3ywWOscPHgQgIceeqg8QxMVjacnqqKAqqKge3CKRoNigS1RQNc4InuyQJ8U1s+ztJZf+dV4smTx8fH5TrfEBI2tFGS31CSTrRxfcylR8qtbt27lFYcQtimfOjma114jqfcA3G5epWHaVU661LtfIRo4f+wWkx5bwsz1I80YuBBCFE/7DoGEHojIMU1RFEMy7IHqHjg52XHhQhRNmlpejRoh9CZNmsTKlSv59NNPGTZsmKElWEFu377NZ599hoODA2+++aaJohQ2Lz0dNm1CUVVUe3uiBw/GZ80alMxM2LRJN9/CWlbl7opl6S2/kpOTzR1Cidy6ZT2tp20lOWOJ3QttpVWdOZmt+uzRo0flQkHYPn2dnCNHoFkz3bRmzXC7eIozI98mwjH/G8Erp+/yRu9F0kVYCGHxnJztcXNzQFX1Sa+c9T5C9obj4enM+bN3zRilEEVr27Ytc+fO5fbt27Rv3541a9bke7Oh1WpZu3YtHTt25M6dO/zwww+0a9fODBELm3TvwWlqrVpc+PNPrk+ZwoU//yQtMBASEnTzLUzullTZW3pZ4rWsJcZUEFVVLTIRUxBLbI1WmLt3refaxFYSi+Zk0g7jN27c4JdffmHp0qWcPHkSgG+++caUIQhhWvo6Obm5utJo8Zc8u/w4c/6b/whR1y5G8+rDC5iz/QWLay4uhBDZtWpTnT27LqO9N0qhqoJGo6DVqly5FE3Xh+sQsvsK6elZODraFbE1IczjhRdeACAoKIhjx47x+OOP4+PjQ6tWrahUqRKKonDr1i3CwsKIjo4GoEWLFuzZs4c9e/bku01FUZg/f77J3oOwAU2akPX111zs0gXVxQWAtAYNuLB8OU1CQnQPVi1M7gEfLD35ZU2sLeGRlJRk7hBKJCoqytwhFJu1JRYzMjLQaDTY2VnOdV+5J79SUlJYtWoVS5YsYdu2bYYnaJbY/1sIU+v5RHNQFea8tznf+bci4nipyzzm7h4nfy9CCIvV+kFd8is73fe8LhHm5+tKZqaWy5eiaNiokpmiLF+qVkXVGucmz1jbESWzaNEiw3etvutudHQ027Zty7Gc/mZeURSOHTvGsWPH8t2e/lpXkl+iRAICONOtG36//krUiBGo9+pnqS4u+T9QFTbN2hIe1tSlVFVVq0ouWlOsANevXychIYFq1arh6+tr7nCAckx+bd++nSVLlrBq1SrDsLfZLxaEEDo9n2yGRqPw/bv/5Dv/7o1ExnSYy/z9L8nfjhDCIjk42OHp5URcbJoh4ZVdaGgEAZXcOH/urs0mv4T1q1mzpnzPCovguXkzVb75hozKlYnr39/c4ZSYJbf8sra6SdaUTALrStBYU6xgmXXICmOJo78aNfl15swZlixZwq+//sq1a9eA+x949vb29OnThxEjRpCSksKYMWOMuWshrFqPYU1Bo/D923/nOz/2bjKj2v7AwoOvoNHIhbkQwvK061CTLX+fv1f7K2cCLOJqHA91rUXogQgyM7XY25ut5Gj5Ue+9jLUtYXJXrlwxdwhCAOD5zz+G/1pj8gvut560tOSXtSU8rK0bYX7c3Nws8n1YW6s6Sx2BMj/ZR4C1pORXma8+o6Ki+P7772nXrh1NmjThiy++ICIiwvBh16lTJ4KDg7lx4wbr1q3jqaeewtXV1RixC2FTegxtwutf9S5wfkJMKiNbf09WlnU9sRJCVAzNmldFo8nb6kuvUiV30tOzuHolxrSBWbG2bdsSFBREcHCwuUMRQphKUhIe92rIeezejWLhLX8KSm5ZaitKS0zCFCYlJcXcIRRbQeeCl5eXiSMpHkl+lZ+MjAxD138HBwdzh2NQqpZfGRkZrFu3jiVLlrBp0yZDBl1/wjdu3JgRI0bwzDPPUKtWLaMFK4Ste3hoUxSNhm/f2pTv/OSEDJ5r+T1Lw17Dzs4GW04IIayWRqPBzd2ZuNjUfLo+qhwLu079Bv5ERMRSt56fucK0KqGhoXh6epo7DCFEeTp3DgYPhqQkyMqC1FQ09+6tNBkZNOjTB9XREezswNsb1qyBBg3MGXEORbWksrSWX7lHprR01tRNs6BzwdPTk+vXr5s4mqJZUzIJICsry9whFJu+i6ajo6NFJcJLlPzav38/S5YsYdmyZcTE6J7c6j/QHnjgAZ566ilGjBhBy5YtjR6oEBVF98FBKCrM/k/+CbDU5ExGNP+OX4+9jp0tdh0SQlitVq2rsWPbpXvXBtkvdhQuXoii9YPVOXPqFt2617GoiyEhhHUIDg4mODjYqm4Ci1S5Mnh5wenT+c52iI29/0tgIFSpYpq4iik2e3zZ6D/jLS35ZU0tvyzt2BWloJZU9vblPsZeqVhTPTVrSoLC/XMhIyOD+Ph4i3mQV6I7506dOjF37lyio6NRVRVPT0/GjBnDtm3bCA8P56uvvpLElxBG0G1IEBNm9i1wfnpqFk83/ZbMDBu6+BNCWL3mLasB+lZfaq7/QZVqHsTHpxEdbT0XnMWlL/dgrJcoX5MmTWLSpEncvn073/lZWVmEh4cTHh5e6HYuXbpE69atadOmTXmEKXIZP348p06dIjQ01NyhGI+XF+zeDR9+mO9sfTnB26+8olvOQm4i9Qr6GxJll5mZae4QSsTauhFaU7zWVqtO3/JLq9Vy9+5dM0dzX6majSiKwtixY4mMjGTevHl0795dnuAKYWTdBhWeAMvM0PJ0029JT7WuD0MhhO1ycrLH2dn+Xr32bNcF9+7eIsJjsLNTuHJJ6n4J85o1axazZ88u8KL8zJkz1KpVizp16hS6nZSUFMLCwggLCyuHKEWFYW8PH30EvfPWflWAxE6duP3qq7rlrISltvyyJvklZ1xcXMwQSfEkJiaaO4RiU1XVqlpTWVOiDnKOTGlJeaISJ7/0H2Dz58+nbt26vPHGG+zbt8/ogQkhik6AZWWqPNP8e9IkASaEsBANGwcAoMlIo92uP7DLSEdRFBRF4dyZO1Sv4c3ly1FmjtL4VC2oWtVIL3O/G6EnN+7CpDw9URXFMOCrCqgaDVnu7uaMqlQk+VV2+XXR9PX1NUMkxWNN3QitrSWVtcWbvZ6aJRW8L1Hya8eOHYwaNQp3d3dUVeXWrVsEBwfz0EMPUbduXSZPnszpAvqrCyFKp9ugICZ+82i+8xQNaLUqzzT7jqSEtHyXEUIIU+rQsSYKCg1P7qL7pp9ocHK37gmrqpKSnEVgoA8R4bFkZkqGRwghDNLTYdMmFFUFe3uihw0De3sUrRaPPXtQrOzm1xJZU0sfyL8llYeHhxkiKR5r6qZpzS2pLJ1Wq81Rl9GSYi9R8qtr164sWLCAW7du8euvv9KnTx80Gg2qqnL58mU+/fRTmjZtSqtWrfj666+JjIwsr7iFqFC6DmzMpFl5E2CqFjQaBVR4rmUwsXet54mLEMI2eXq5YG+vocG/OwFoeGIn90qAAWBnryEjQ0vktVhzhSiEEJYnJAQSE0mtVYsLf/7J9SlTSNmzh7TAQOySk3G1sq61ltjyy9oSHvm1pLKzszNDJLbHkhIyxWFNrepy/51Z0gAlpar55ezszNNPP83GjRuJiIjgyy+/pHnz5oYircePH+edd94hMDCQ7t278/PPPxc4EogQongeGtCYt769nwBTFNDYKbqLCkX3+wvtfyTiouUUFRRCVExVfeyoc+4gAHXOHsAhPcVQAuzc2dsE1vLh5o0EM0YohNCbOXMmQ4cOpX79+nh5eeHk5ERgYCAjR47k33//LXC9RYsW0a5dO9zd3fH19aVfv36EhIQUuq+9e/fSr18/fH19cXd3p127dixZssTYb8k6NWkCs2Zx6ZdfdC290tJwbd+eC8uXc+Pdd0mtW9fcEeZR2E2tJSa/EhKs/3vHkuonZWdtreqyd8uzBtaUrMud/LKkFoGlSn5lV6VKFf7zn/8QFhbG0aNHmThxIpUqVTIUkdu9ezcvvfQSVapUYciQISxbtsyqMpdCWJLO/Rvz37kDAd1oaqqq3v8SVHTdICf0XsK/B66aMUohRIVz7hwEBUFgIAQGMuy9odhn6bro2Gdl8OLXz/Hyl0/x8ldP0eetofhGXeP8Odur+yWENfr000/ZuHEjvr6+PPLII/Tv3x9nZ2eWLl1KmzZtWL9+fZ51Jk6cyOjRozlx4gQ9e/akXbt2bN68ma5du7JmzZp897Ny5Uq6devGpk2baN68OX379uX8+fM8//zz/Oc//ynnd2kFAgJgwgQ8du+myjff4LllCwCqiwtRzz5LlgXWeoqPjy9wniUmaaKjo80dQrFZUtKwOKytVV1+9dQsWUHJRUv8O8t9LlhSa8UyJ7+ya9GiBTNnzuTatWusX7+eJ598EicnJ1RVJT09nf/7v//j6aefZty4ccbcrRAVSrue9fj4tyfQ2GHoRgQYCkorGvjouVX888cxs8UohKhgKlcGLy8ID4fwcOzv3s4x2z0xGq+423jF3SbNyQ2vBoHcvJFgU3W/dA8kjPcSwlTWrl1LTEwMBw4cYNWqVaxatYqzZ88SHBxMRkYGY8eOzfHkfsuWLcyePRs/Pz+OHTvGmjVr2LRpE7t27cLOzo7Ro0fn6fERHR3NCy+8QFZWFitWrGDHjh2sWLGCM2fOUK9ePb7++mt27Nhh2jdugbRaLZ7//ANg+K8lK06JG0tK4lhT0XBL6ipWHIW1pLKkc0DPmpJ1hZ0Lbm5uJoykeHK3UrOkvzujJr/07Ozs6NevH3/88Qc3b95k7ty5PPTQQ4D1DSsqhCVq0r4G3/w1EkWjoNXm/ELRPwH46cNtzPtoqznCE0JUNF5esHs3fPjhvT7ZOS8vtIoGFYU9D4/kl3GzSVCcyMrScvOm9XdBEcLade7cGWdn5zzTX331VerWrcutW7c4deqUYfrMmTMB+OCDD6hfv75heseOHXn55ZeJjY1l/vz5Obb1888/Ex8fz6BBgxg6dKhheuXKlfnyyy8B+Prrr436vqzR6UOH8NizBwCP3bshV+sUS0wiFMQSuz1aE2tKzoB1taSytnOysMSil5eXCSMpnpSUFHOHUKBySX5l5+npybhx49i1axcXL15kypQp1LXAPutCWJsa9fz5OeRF7Bx0Lb7y+yD/+9fjTB7xp9V9yAshrJC9PXz0EXz9NeR6yKVRtWzt9wp7e45CtbMj/GoMDg4aIiPizBRsOZCmX8IG6Yeod3R0BHQ3Ndu2bQNg2LBheZbXT1u3bl2O6Rs2bChwHX03yy1btlhdHZ4yy95lvHp1GvTpg+ZeKwlNRgYEBtLgkUdo0Ls39QYOJDNbElKUTFGNLyztWjm/kR4tWWHxWtqxtaSWSMVR2Oeiq6urCSMpHkv+HLc35c5q1arFlClTmDJlCnv37mXp0qWm3L0QNsfb340lh8YzttOPpKXk3yT2dOh1Xu7+M8FbXsDewXL6XAshbFRYGNjZoWZloaDrna0qGirfuKC7AFbh5s0katXyIfKaDSW/hFWaM2cOlSpVyjP99u37XXenTZtW4PrZl7M1S5cu5ezZs9SvX9/Qwuvs2bOkpaUREBBA9erV86zTunVrAI4fP55j+rFjx3LMz87R0ZGmTZty6NAhzp07R/PmzY39ViyXvsv46dMAOOSeHxWF470fk5s351JCAkGmjK8MLK3llyXfkOcnLs66vh8LSyhZWq8vayoeD4Wfu/oHFJbC0rvrmjT5lV3nzp3p3LmzuXYvhM1wcXNk8aHxjH9kIVEFdCGKupHIyAfnMD/kJVzcHPNdRgghyiw9HVatgqwscHAgrEUfmh3ZhJ02kwYnd/PXwElo7XUXapWreHDy35s5B+6wYqpWRdUa5ybPWNsRRfvhhx8KnKc/Lz/66CNThWNWX331FSdPniQpKYnTp09z8uRJqlWrxu+//24oWBweHg6Qb+ILdPVnvL29iYmJISEhAQ8PD+Lj4w038gWtV716dQ4dOsTVq1crVvJL32X8449h2jRUDAPj6txr2X/nlVe4/eKLuha2VsLSkl+569DllpWVhb0FHV9rStAUlfCwluSXs7OzRSZJralVnaV31y33bo9CiPJn72DHjzvHUKdJ3qfXeukpmTzXKpjo29bVjFoIYUVCQiAxERo2RDl8mK1PvMXCV+YQ5Vcdp/QUakScJPtIHT6+LsTGWG5tCGHbVFU1ystW/P333yxevJgVK1Zw8uRJAgMD+f3332nTpo1hGf1NWGFdbfQFmBMSEnKsU9h6udfJLS0tjfj4+Bwvm6HvMt67N3keA6gqiZ06cfvVVy0u8WVpCY2ixMTEFDrf2rrCWZKiEkaW1hqooPpkllg/S1VVq2pVZ+nJL8v6FBXFEhwcTHBwsMV9kAjzUhSFL1eP4IvxawndfKnA5V58aB4z1o6gVuOCE2VCCFEqTZrArFkwbhy4ulLt+FEup9Vh4atzaXFoA7crBaIouoE6bt5MIDw8lps3E/DxtbyaFcK2bd++3dwhWJwtW7YAuhYy//77L9OmTaNbt25Mnz6d999/36yxffbZZzbfAk/r7q5rLaWq95NgGg1Z7u7mDKtABSUq9Syt5VfuOLy9vXO0BktNTcXFxcXEUdmGogqcW1piMTk5Od/pPj4+3Lp1y8TRFK6oFoCWlvyy9BaLkvyyQuPHj2f8+PHEx8dbZIZamNe7wYNY9NlO1i88UuAy/xn0K/8JfowOveoXuIwQQpRYQABMmGD4tWnTKly5HEOmozOHOj2OqqqGJueRkTG4uTty+3YijYMqmydeC9e2bVvs7OwM3/vCeLp162buECyWt7c3Xbp04a+//qJjx45MnjyZ3r1707ZtW9zvJWIKunmE+60qPDw8AAzr6Nfz9PQscp3c3nvvPSZNmmT4PT4+nho1apTwnVmw9HTUjRvRqCqqvT3Rgwfju3YtZGTgsWcPSkYGqoXV9omIiCh0vqUlv3KrWrVqjuRXSkoKPj4+5gsoG2tr4FBUfTJLaw1U0PG1pG6vetbWqs6SR3oE6fYohE0a9V43xnzYvdBlZoxfz/I5+00TkBCiQqpbzw8AbbbuYfoaXxnpKpUquXP7lm10xS6PwR5DQ0M5deqUJL6EWTg4ODB8+HBUVTWM3lizZk0Arl27lu86SUlJxMbG4uPjY0hkeXp6Gh7WFrSefnpgYGC+852cnPD09MzxsikhIdjdu2m89dprXJ8yBQ4fhgYNsEtOxjUszLzxWbn8EgT6OnZ6BXWFMwdLSxYVpaiEhyW9H0tNxhakqOSXpbX8kuSXEMIsHn22Ff+dO7DQZf6ctY+vJ6wrdBkhhCgtVzdH9LXscxa11118urvpWn4JISyTv78/AHfu3AGgYcOGODk5cefOHSIjI/Msf+SIrtV57qL1LVq0yDE/u4yMDE6cOIGzszMNGjQwavxWo0kTUurVA8Dl+HGaNm0KzZrB0aPcePddUuvWNXOAJWdJLb+Kk9iypO5a0dHR5g6h2Irz72tJyS9LiqU4ijp3MzMzTRRJ8VhaPLlJ8ksIG/bgw3X5cvWIQpfZt/ECkwYssYiLEyGE7XHLNcJs9tZN6RlZxMWmkppq2RdLQlRUO3fuBKDuveSLi4sLPXr0AGD58uV5ll+xYgUAAwYMyDG9f//+OeZnt379elJTU+nZsyfOzs7GC96auLridPUqAB67d4P+htfVFd+PPiLL19eMweWV+5oxv5Z4lpT8un37trlDKBFrGtChOPW8LCnhZElJzuKwpnpqlp74Akl+CWHz6jSpxI87x5B3CKH7ws9GMbr9D2SkW1a/cSGE9atVS1dDJb8boPh4XXP+27cLL5xsFcqj36MQ5Wzv3r1s2rQpT9eZjIwMvvvuO5YuXYqLiwvDhw83zNPX3po+fTrnz583TN+3bx9z587F29ubMWPG5Nje2LFj8fT0ZO3ataxatcow/fbt27zzzjsAvPXWW0Z/fxbr3DkICoLAQKheHQID0dy7idVkZOSY7tSqFY5Xrpg33lxyF7u39PprubuOVapk2YM+WVodp8IU1S0PLCv5ZU2JxeIkkywp+WUNiUVJfglRAfhX9WTJoVdxcCr4Tz4xNo0RLb4jPsay+2oLIaxLo6AAQy4ne17HLiONuqvmU6uKC7HyuSOEWZw/f55HH32UypUr07dvX0aMGEGfPn0IDAzkjTfewNHRkUWLFuVIbvTs2ZMJEyYQFRVFy5YtGTx4MP369aNr165kZmaycOFCvL29c+zH19eXBQsWoNFoGDZsGD169OCJJ56gYcOGXLhwgUmTJtG9e3fTvnlzqlwZvLwgPBwiIyEqKuf8qCjd9PBw8PIi8173U0sRHh6e4/ec3dpzTrOEll+5BQQEmDuEAllD65nsiip2b2kSE62n1EJxEouWlCgtbCAUSyHJLyEqCFcPJ5YcHo+3v2vOGfp6PBoFrVblhfY/cvm0dTUPF0JYrqrVdIWus9//qCo0Or2Hrn/9hP+ev22m6L0Q1qZbt27873//o2HDhhw/fpzly5ezd+9efH19ef311/n333958skn86w3a9YsFi5cSOPGjdm8eTP79u2jZ8+e7Nq1i8GDB+e7r8cff5xdu3bRp08fjh49yl9//UW9evVYtGgRX3/9dTm/Uwvj5QW7d8OHHwL6KojZ6JNJU6bA7t1os42YaS0sOfmVX7LOUlhS4f3iyN0K0JJptVqrSi4WJ/lVnGVMxRrOBcsbz1MIUW4cHO35ac+LvD3kF66evmuYrmgUwwhsKipvD/qVl6c/Qs8nmxeyNSGEKJq+5peqqmjuJdkVBRqf1NUSanRiFwdihpozRCEqrNq1a/PJJ5+Uat1Ro0YxatSoEq3TuXNnNm7cWKr92Rx7e/joI9i/H+Wff3LOU1Xo0wemTjVLaMZgKQkma0p2gHUVu4f8Rxt0cHCwqO54epY+EmFuxWmlZinJZVVVpeWXEMLyaDQKX699jra9dKMKoXI/8aX/AFXgx8lb+eq1/0OrtYwPVSGEdVIUBXt73eWG/iPGIT2FuudDAXjg+F4Sb1rXxX5+VK1q1JcQooLw9Mzb8kujgXyKyFuC3N2sqlatWujy5r45z51MspSkXEGsqeVXfokvgGrVqpk4kuKxhuRMdsWJ11KSjJbUAq0w0vJLiArq3eABLJ+znz9n7zNMy91E/eCWS7zY5Se++3s0Lu6O+W5HCCGKUiP1Fr1/eAeHDF0xVE1WJvZZugs2u8wMnpg8DHWmu64XtpsbrFkDDRqYLV4hhDCJ9HTYuNEwJpGq0aDY2UFGBmzapJvvaFnXX1dyFd/38/PLdzlL6faYe6TH2rVrmymSopn7WJVUQQXO3S20m25MTIy5Qyg2VVULTC7mXs4SWEtiUVp+CVGBPfFqBz5cOFTX6itbSwNFUQwXLXFRKYx8cA6Rl63nC0MIYVl8G9cm1dkdr7jbeMXdxiMx55N494RolPBwQ3FnqlQxU6Slp2LEwR5LuO/k5GTWrFnDmDFjaNiwIc7Ozri5udGiRQumTZtWaNeJRYsW0a5dO9zd3fH19aVfv36EhIQUur+9e/fSr18/fH19cXd3p127dixZsqTA5Tds2MD7779Pz5498fb2RlGUMhc3P3nyJE888QQBAQG4uLjQrFkzZs2aVaybBSHMKvtIj9WqQbaWPopWC66uYGcHCQlQv75ueQtibV3HcnN1vV/71snJyYyR5JVf6xl7e8ttq1LQd4sltq5TVdWiRp0sijWMnJhdYdcZlnQ+SPJLiAqueadAftw5BkcX+0KfHkx8dDF7NpwxYWRCCFtR78E6LB79Dbu6PYuKglbJefmhVTSoimIo7myp3X0s1W+//caQIUNYsGABdnZ2DBw4kC5dunD58mWmTJlC27Zt87R+AJg4cSKjR4/mxIkT9OzZk3bt2rF582a6du3KmjVr8t3XypUr6datG5s2baJ58+b07duX8+fP8/zzz/Of//wn33VGjBjBp59+ytatW40yMti+ffto27YtK1asoE6dOgwcOJC7d+/y5ptv8tRTT1nMk3Ah8pV9pMfcozwCxMWBvmthQIBVPgwAy2j5VdS+syfCLEFUPudD9pFWLU1+8To4OJghkqJZWzLJWroRgu7vrLBi987OziaMpnCS/BJC4FfZ4//Zu/P4Jsr8D+CfJL1b2tKDFiyHHEXLjYICIogICCIKiOsJeLBqVVx0ddmVQ8DFVVBwqccPOcRVV+VyEUU55RKonGK5Qcp9l95pmzy/P9KEHJOzSWYm/bxfr0A7k5k8eTpJZr75Pt8Hn+Y+i/pN6rq838yXV2DGy8t5YUFEXklKioXQ6bD+juFY2ffP0Arb7BytMOLC394wFXdW8LfcLvkt7UvYTo3pgfDwcIwaNQp5eXnIy8vD119/jRUrVuDAgQPo0KED9u/fj5deeslmm1WrVmHmzJlITk7G7t27sXTpUqxYsQLr16+HTqfDyJEjUVBQYLPN5cuX8cQTT8BgMGDhwoVYt24dFi5ciP3796N58+aYPn061q1b59C+IUOG4J133sHatWvxk31hby9VVlbikUceQVlZGd59911s3boVX331FQ4dOoQuXbrgm2++waefflqjxyAKKLuZHp2aMAHYskVRXwbYn/+lpKQ4va8Sgl/uCoZHR0cHqSWesX/PBYDY2NjgN8QDQgjJyQSUGqxTy7A8s8LCQrmb4DF3GXVKqgHH4BcRATDNBPn+iuHo1t91nZ1Nyw/hmR6fQF+mjAKLRKR8deJNQ0uEANLPHjZlelWvEzBlfun27JGtfWo3fPhwfPzxx7jxxhttltevXx85OTkAgMWLF9ucoL777rsAgNdffx0tWrSwLO/SpQueeeYZFBQUYM6cOTb7++STT1BYWIhBgwZh8OBrM3SmpaXh7bffBgBMnz7doX1z5szBK6+8gp49e6JOnTo1eq5LlizBsWPH0K5dO/zlL3+xLI+Li8OsWbOctoFCQ05ODrKystCpUye5m1Iz5pkenc3mOHGiIr8MsL8gT1d4VtqJEydsfrcf5qi04JeaOMtMMmfTKWmoG+B8Fk2lDX0FTIFFV8EvpQ2FdTdJAzO/iEiRNBoNXnq3P0a90cvl/S6fL8GjHXJwNr8gOA0jIlULD9cBALSGSrTctwlaYYRRG4btHQfAqA2DVhiRsOYHU3Fn8qt27doBMA35MA9RKSsrw5o1awAAQ4cOddjGvGzZsmU2y5cvX+50mwEDBiAqKgqrVq0K6HANV23o2LEjmjZtir179zoU5abQkJ2djby8POTm5srdFL8o2LbNscafTgccOyZHc9yyDya5ooTML/sagE2bNrX5PUJBkwlIZVFptcq9VJfKUrOmtMCis88lpQWSANdDHuPj4xV13AJwOeTRuo60Eij3FUVEsrnrwbZ4e9FDcPde9UKf+djy46HgNIqIVE2n06DhiTxEVpThYnJDfDLqA3w/8CXMfvoDXEltiLCyEsBNoXXy3tGjRwGYhkYmJSUBAA4cOAC9Xo/U1FRkZGQ4bNOxY0cAwB67bLzdu3fbrLcWERGB1q1bo7y8HAcDWKDbVRusl9u3nUgRrIvdX3cdEr7/Hg6nWgYDsGABcOONiit27w25g19SwSSdTufydzlJZSbZB+uURKq98VZDdJU0XLOy0vloFSUFZsxcZX2lp6crLrDoanhxWlpaEFviHoNfRCTp+lZpmLf1GcTGu04Hnj56OT74+4+sA0ZELkVE6HAhtTF+7Pcs/m/UBzhXrwkAgfNpTfD1a/OxZ+RrQKtWcjcz5MycORMA0K9fP8vwjvz8fACQDHwBpouWxMREXLlyxfKNbmFhoaVYvbPtzMuPHz/uvydgx13bg9EGIp9ZF7s/fdox8GUmBKDRKLrYfUJCgtxNcOn06dNyN8ErUpOSKGm4mLWqqirJ8/7rrrvO8rOSgl/OgjNarVaRwS9XWXURERGK6tvKykqX14DmL92UgsEvInIqNj4Kc375M5q3dR21X7t4H7J7z0WF3vFbNiIiAIiJjURpbCK23TIYVeGmE3ohTCedhsgo/N7rQdPMZioljP69AaaAk/XN29mqvv/+e8yZMwfh4eGYPHmyZbn5QsDVTGfmk2tz8Mv64sHZdvbbBIK7tgejDUQ+syp2L3m5aL4Q79sXWL1aUcXu7WdqdVfYXO7ML/vsGaUGktTIWXDGOpNOSbM+Oqv3lZGRobjgV2VlpdNMNfMXWEo6lt3V+1La0F1ltYaIFEen02Lq1w+h//D2Lu934VQRHu2Ygwun1TM7CREFT0pydPVFkPl27YRTU72EbDVs2BAJCQmW29SpUz3edv/+/Xj00UchhMA777xjqf1FRDKrLnZfVVdihm0hTIGvFSuA+vWD3zYXvKn3Bcgb/JJ6zGbNmgW9HZ6S+mKjUaNGMrTEMxcvXnR7H/taWnIFmYQQKCsrk1xXp04dxQW/XH1xY85sVlLNL1dDNOPi4oLYEs8w+EVEHhk5tif+OmuA8ztoTB8wz/Wai22rWQeMiGzFxzv/prKqSqCgQPrkVC2EEH69AaaLzatXr1puY8eO9agtp06dQr9+/XDlyhWMGTMGo0ePtllvPiF1NfW7+dtc8+yM1iexzraz3yYQ3LU9GG0gqrFLlxB25QoAu8C/VquobC+1krogV1qQw9rJkycdlsUr9DgQQkjWU6tXr57N7/b11OTqf2eBL8DUJqVlJpknppHiSa0v+0keAsndrJTWw2CVQll/bSJStM69W2DWyhEIj3Dx1qEF3slejumjl8FoZC4HEZkkJJpO2oQw3669PxgMRhgMfL+wFx8fb3PzZEr2y5cvo0+fPjh+/DhGjhyJadOmOdzHnFEgdcEFmAJIBQUFqFu3riWIFB8fb6nx42w78/LGjRu7f3I+ctf2YLSByGvWhe4zMoDGjS25rxoAML+2jUZg0SJg716ZGirNXGvPrL4HWWlyZn7ZZ6m5GuItN1eZSUrkrH5WqpuyBdbBr2AGaC5cuCC5PF2B9fSMRqPT8gaeDiOVCkwGirvyAkoa+mrG4BcReSWtYSLmbX0WyelWqawaQKO1+kZHC2z56QhG3PIBrl5ynllARLVHfPXkGdbXQaYsJ6CqygijIXgnw6GquLgYd999N/Ly8jB48GDMnj1b8tv2li1bIjIyEhcuXMCpU6cc1u/YsQMA0LZtW5vl5qGT5vXWKisrsXfvXkRFRSEzM9MfT0eSqzZYL7dvO5GsrAvdnzoF2NfJsb7gNRoBhU3YYJ/dkZyc7HYbuWt+WVPyrIlSAQQlZ66eO3dOcrm7zC7rDKtgBWiMRqPTAI35GFZS5perWRM9/UKnoqLCX81xy1WWmlIzLZXz1yYi1YiMDseHa5/Ezb2rTyYEIKqzvMxvdhqtBlVFpfhf1oPY+dM+uZpKRAoRV8dJ1lJ1Fhgzv2pGr9dj0KBB2LZtG/r27Ysvv/zSYdiJWXR0NHr16gUA+OabbxzWL1y4EAAwcOBAm+UDBgywWW/tu+++Q3l5OXr37h3QYryu2rBz504cPXoUrVu3RpMmTQLWBiKvWRW6d+nvfwemTwc6dw5OuzyghOCVN7ydGERuUrXUlFzvq7y83GGZJ8E66yCTs4Lu/uYqM8l8vaKk4JerWmqefq4G6/ivqqpyWexeiUMeAQa/iMhHGo0Gr826F89N7Q2N1fWVEAIajQZCCNxavAePnf8O65+Yin8+swSGKmZ2ENVWUdGO6e/m+lZGoxEGtWd+XRvP6Z+bFwwGAx566CGsWbMG3bt3x+LFi90WxB0zZgwAYMqUKTh06Fqdxl9++QUff/wxEhMT8eSTT9ps89RTTyE+Ph7ffvstFi9ebFl+/vx5vPrqqwCAl19+2au2O/P444/jhhtuwJIlS2yW33///bj++uuxe/duvPfee5blJSUlyM7O9msbiPzCPOSxWTNg/nwYnQ3Bi48HliwB7rlHUTPf/v777za/t27d2qPt5Mr8sn4/A5SdRWU0GiX7R6lZM86GZ3oSrLP+MiZY2Ulnz56VXH799ddbfrbuazkDvUaj0WktS28CdFLByUBwNuOnmblMgtKEub8LEZFzd9zfGlmdGuLlQf+BvrTSMoGbRqPBrYW7AQC3Fu7C9A034dGbZ+HfP4xESn3lnogQUWBERupMJ5YCgPWJvQYwGAUE53v02axZsyxBopSUFDz33HOS95s2bRpSUlIAAL1798bo0aMxc+ZMtG/fHnfddRcqKiqwcuVKCCEwb948JCYm2myflJSEuXPnYtiwYRg6dCh69uyJ5ORkrFq1CgUFBRgzZgx69uzp8LiTJ0/G8uXLAVwb1rFjxw7ceuutlvssWbLEpo5Qfn4+Dhw4gKtXr9rsKzw8HP/5z3/Qu3dvjBkzBl999RUaN26MDRs24MyZMxg6dCiGDx/uXQcSBZJ5yOM+Uxa808vYwkJTkEyBtYh8IUfwS6qWlJLr/0ll+rjL8JEzQONsxk9PgnXWsz8GI/OrsrLS6ePExsZafnaWIR1s9p911rzJZA5W8MtZLTXANBulUgO4DH4RUY2lZSRg/pZnMOmJRdi//QwggEihR4di04lex+J9iDTqoa+MxHO95+LPk+/EnYM9++aQiEKDTqeFMNrGvcyEANLT1R0U9yFhy+W+vHGletY4AA6ZUtYmTpxoCX4BwIwZM9C+fXvMmjULK1euREREBHr37o1x48aha9eukvsYMmQI1q9fjylTpmDLli2oqKhAVlYWnn/+eadBpyNHjmDr1q02y4qKimyWeTNUo2vXrsjNzcWECROwbt067N69G82aNcNf//pXjB49WrEn3VRLmYc8Tp4MTJrk/H4REcDq1YCCirPbB5M8LRwvV4Dm6NGjsjyur86fP++wrFmzZi63katvKysrJTO2mjdv7tH21sXPg5H55WwIoXUQDlBG5pcQwmmWGuDdhA3B6NuysjIYDAan660z65SGwS8i8ouwY0cwaftElJ2/guJCPcKEAeHCVNAyXFTh/cNvoqp6fKT+oal4p9df8dK3oxEewbchotpEAJboTlhVBW7ZthTbuwzGhfPOC72SaxMnTsTEiRN92nbEiBEYMWKEV9t069YNP/zwg8f3nz9/PubPn+/VY6xbt87l+latWknW/SJSpLAwYOxYGKdOhVYqGyU6GigrA7ZtAySyJ+WSl5dn87unheMrKytlyfyyz3qxz15VEmfBA3fBe7kCNFKTowCe16KyzrByFTjxF2fF2Fu0aGHzuxK+LCkpKXHaJ9ZZap4IRt+6qk0GKHOWRzPW/CIi/6hO64++dBaplVdQt8p2ZqC6VYVIrbyC1MorKNVFYe+xKjzSMQcnjzqfKYSIQoflBFNcu924byPuWjMHLfdtRHi4MoYeEJFy5eTkICsrC506dZK7Kd77/HNL4MsmfKHVAnffDcyYAbRqJUfLJNUkyFJUVBT04JdUFlVGRkZQHtsXx44dc1iWlZXldrtgzZRozWg0Ss5EWLduXY/3ERl5bdKbQD8HZ7WzAMdhjtaZYFLDZoPhzJkzTtcpbdiu0Wh0OURTyZM1AAx+EZG/WM9kpNFA2BVnNEADIzT4JqUvxjd5EWW6KEAAYwb+Bws/2iJTo4lITln71gMAbshbj/BwlZ+SCD/fiMhBdnY28vLykJubK3dT3DMXum/cGMjIgPGZZyyrNABgDgYYjcDSpcCddyq60L2nWV+A+2LYgWAf/FJy9onBYJCszeRJYfNgZPbYkwosAt7N6Gcd/Ap0kCk/P19yebpEPT3rzC85+ra8vNzpsP+IiAhFzUYJ2JZZkBIfHx+klvhGWb1JROoWFga88QYwfTo0dh9sOggsSBuEb+rdDaPG9luXr/+9Fdl95qK8JDizvxCR/MIrytHiyK8AgBaHtiHayNc/EYUQc6H7/Hzg1Clo7bNdrC94jUbg+PHgts8FqWwtb+oOlZWVBTXzS2oWwpYtWwb8cX0lVZvMVa0v62ylYBU0NxNCuB3m5gnr5xDI4FdxcbHTzDLrmpdm1plfcgwpdVXry9N6asFiNBpdZqlJ9a/SsNgOEfnfrl2ATgdUf4MiABihRZNy6XoBAHDhVBEe7/wh3vxyGFq0re/0fkSkTtrDB5H90VMIrzRd8OkMlQgzmIYAhRkq8aeJDwDvVde2iI01ZUJkZsrUWu8JIfx24iznbF5E5AcHDwL33QcUFdmcD0lKTgaefhro3DlozXPHPuvLl+GDwayldOTIEZvflZYtY81gMEhm+kRHRzvdRqfTWbKSpAJ9geQs0yfTy89n6+BXoD7jhBBOs76sZxN2JtiZX1VVVZLDSQHT60dpx7G7IGhaWlqQWuI7ZfUoEalfRQWweLHpRC88HBg1CprwcOhgRJeS36ATrsf5/+Ohr/HRuJW8+CMKMZVJqSiPjEVi4XkkFp5HnRLbE+qYq5dMGRL5+aZsCYnhCUREqmDO+jp50nXgCwBatADGjlXMkEep86+aFI4P9PmcVPDAk9pZcjl06JDDsnr16rncxjo7KZgBGiEETp8+LbkuIiLCq31ZB0MDlflVVFTkdN/JycmSy4OVkSbFVRaVN8HFYASaDQaD0+GvgCl4q4TJA9xh8IuI/GvzZqC4GGjZEti+Hfj4Y9P/mZmIrCrHmKGJbnexZnEeRtz6IQqvOC9YSUTqUhoWjbmPTcfabg9DQAOjxvYUxKjVAhoNMGGCqX6gwutGOBDCvzciUq+EBGDlSlNWlyvt2inu/c4+66tJkyY+7SdYwx7/+OOPgO7fnyorKyWH5LkLflnXL6uUmi00QJwNyWvlw8QMgQ5+ucr6clWbLBhBOSnl5eUuC8d7U7POOjgaKOfOnXO53puagHJi8IuI/KtVK9OMRTt2AG3amJa1aQPs3AnMmIFOL9yLWT+NQGS08zd1jUaDsuJKPHXbbCz/z87gtJuIAqqwsBxGrQ5rb38MK3o9Da2wPcnUGo3Au+8CEyea6gcSEamNdZH7hg2BS25mtD582FTvSyGksori4uJ82lcwgl9SWUmtW7cO2OPV1IEDBxyWeTKk1DrLKlgBGoPBgEsSx294eLgiM3xcTbLgalZK66GFwepbV4E6wPtaX4Ge3KGqqgqXL192uj45OVmRx4QUBr+IyL9SU4HRowH7wqgxMablqamod10C5v3yZ9x4UwOHzc1vnub/P526Hs/e+QmKrga3xgER+Vfh1eoaJwJIP38EBo3WMqmhACC0OlO9QJVi4hdRLXfwIDBwIHDkiGn4trsZD7VaoKTElDGvEPv27bP5XclF44UQLi/IlaakpERyuSdDSq1nSgzWsEepovyA97W+gsFoNOLUKem6wo0aNXK5rRzBr8LCQlRUSE/yExYWhqioKK/2F+jgl7O+NfOknppSMPhFRLIIC9fhjQUPYNTEXk7vo9FooNFocPlcKZ7qNhurFv4WxBYSkT8VFV0rdJ91YBN0wgijNgy57e+GURsGjdFgqhfo5ISQiEjR0tKApCTP38Oio4Fp00wZ8wpw4sQJh2U1uagOdOaX/fBMQLlZX0IIHDt2zGH5DTfc4NH21plfzmYy9KeysjLJovwJCQmKzPA5efKk03XxXgwptg9+BeLYNRqNkq81M18CzoEc9lhaWoqioiKn6xs2bBiwxw4EBr+ISFa9H2iDD1ePREJd0yw3rj5oZk9ci+f7zENJYXCneSaimisu1EMIgYYn9yGyshwXkjLw4Yj3sazfi/hwxPuobNrcNDOagrIg5NapUydkZWUhJydH7qYQkSsHDwJdugCnTpmCWq5ERQFNmpiyvm66STGF7u3rD3lb18m+oHggg19Sda+UfBF+/PhxyeWeBi28LS5fE0IIh9kzzZTYx2VlZSgsLJRc520gyf5YDUSWnbM6aoCp9psvwcVAZX4ZjUa3NfUSEhIC8tiBwuAXEckuOT0e/7fhadz9aHu3b/oXThfhia7/hzVLHL/xIyLlKigoAwRwPrURvr/zz/hoxL9xvt71EEKgsmUWyjdvM9ULVEgWhBLk5uYiLy8P2dnZcjeFiFwxz+544gRQ5qZMQ1wc8Msvinq/27t3r8Myby/Cg3kRLFU7S6kX4RUVFZIzUnqTpRaMguZmzmb0u/7664PWBk8JIZwOz4yJifE6KBTozK+KigqXQ3XdTXzgjPWwWH86d+6cy6GgSh4W7QyDXyqUk5ODrKwsdOrUSe6mEPmNRqPByLE98O6yRxEVG+72A+fjcavxwt3zUVLkmJZNRMpz8UIJBARKYxKx5eb7UBFWfbImTFlhcfUSLXUBiYhUJSHBNGvjK6/A7eVyeblpeKRC3u+kalH5MnzQvk5RoDK/Dh8+7LDMl9kHg+XgwYMOy1IV8HeXUlFRgQsXLkiui42NDXJr3Dt37pzT48uX2Qft91XmLpDt5b6dBeoA74vcW9PpdD5v64xer5ec8MDMl+CiEjD4pULZ2dnIy8tDbm6u3E0h8rvrrk/CvM1/xm33uP824fyJQjzR5WP8/G1eEFpGRDVRXFwBCNMJoDCaTjCFEIAA0urXUWQdEW8Io/DrjYhUwDy7Y6NGQHIy8NFHcPlOptEAxcWKGt5tX4vK0zpU9qwLhwPeZ455orKyEuXltqUvIiMjFfv54WyIW1pamt8ew18BGiEEDh06JLlOicHFyspKXLx4UXKdL4EvILCZX+fOnXNary08PNzrIvf22/uTEMLtcEclZgJ6gsEvIlIcrU6LF//VD29++QDCI9x/m/HBP1bhpQELUFbCLDAipaqqrK6dYT6XtLpWSUuvE/T2EBHVmPVwx8JCU2DLGa3WNJVrdraihzv6e4idPwMIUsMdW7Ro4bf9+1NVVZVkcMbfgaQCd7OKeshZFtV1112nuOCiq0CdVqtFjP2M817s15q/AosVFRVOA3VAzWfQ9Pff5+LFi5J19cyaN2+uuGPCUwx+EZFiNW9TH/O3PoN23Rq7ve+Z4wUYccvH2PDd/iC0jIi8YTQKCAFL4EtAwHpsUCgEv4QQfr0RkSPFlf5ISABWrgRSUtzf1zy744QJihjuWNM6VO5YXxz74z1NasiYr1lqwbB/v+P5aGpqqt+DBlLDVr3lKouqbt26Nd6/v50/f95pLaobb7zR5/3a79M+y9AXriYQAExZajU9Jvw57FGv1+PcuXNO10dHR9coS01uDH4RkaKFhevw948H4e//dy90OvcfDrP+9hP+MvAzlBZ7ONU4EQXcxQtWJ+fmAJhRANXnmWnpccFvFBGpjqJKf5iHPDZuDLjI6kBsLBARobjZHe2HNTVr1syv+/dn8KuyshKlpaU2y6KiooJaCN4bp0+fllzuz+GOZjUN0AghJDPqAGUOd9Tr9U7rkjVp0qRGgST747SioubXEufPn3c6a2RUVJTPWWrW/BVQFUI4DIO25+uQUqVg8IuIVKFd1yaY+8szaN4m3eX9NBoNzhwvwBNdPsZPX+0JUuuIyJUjhy5CGASgsc36EkIgLi4C9UIh+CX8fCMiZTIHvXr1Mv3sYvY2AKagV7t2wFtvKXq4Y3R0tAwt8YxUcKYmBcIDqbKyUnJGPyUGkgA4zfJp0KCB4oa2CSEkJzwATNlPcXE1O5fwd/DL1QQCgP8DzjV1/vx5p3XJAP9kqcmNwS8iUo2omHC8+eUwvPhOP0i+95ovrKt/njvlZzzT6xOcP3U1qO0kIluHD16EQHUhd/NLtPpFrNFoEBsbmGm6iYj8zlzn69QpwElGh42ICGDdOuC11xSR9VVUVOSwzJ/DHc38lfklNWSsJkPbAk0qUBeI4Y7+4Gq4Y1JSUpBb497Zs2edHkv+GALrz5ID7mZ3bNasmaKOifLycpeBuujoaL9kqcmNwS8iUp1ud2dizqY/47pmtnUINBqNzWxDGq0GBRfL8GK/Bfhw/E9O6wMQUWCdzC+49otRmIo+V2ve0oNaOURESnDwINCliynw5cmQuzp1gIoKYNu2wLfNQ8ePH7f5vWVL97Nr+8IfF/Z6vd6h6HhMTIxfaxz5UzCHO9aU2oY7VlRU4NKlS5Lr/BVI8mfw68KFC06zqCIjIxWVaVkbhjuaMfhFRKoUGx+Jd799DE/+o4dlmTDaFoq2/KwBfl56AI92/AA71rt+cyci/ystrZ41yPL61EBXqcdt2xYis4n6i90TUS1hPbuji+FBFv36ATNmKHq4Y3h4eMAf19eggtSMfkq9CDcYDJLDHbOysmRojXvOhjtmZGQoKiPJzFnReJ1O57dAkr+CXxUVFTh//rzT9Uobsnvp0iWndckA5WWp1YQyqwQSEXmoz0PtcEufFvjnM9/i+P6LpiFV1e/P5jdqIQQ0Gg2EAN55YTmua5qI8XMGIz5J/em7REp39UrZtRpWllGPAq0ObkK/9fNQ/lsPoPP18jXQT4Sxelinn/ZFoWfSpElBeZzx48cH5XFqlYMHgfvuM9XvqqoCwsOBykr3261YAfznP6ahjzKTyn4PxHBHs5oOezxx4oTDMiUPd9y3b5/DsrS0NJsRCUpRVVXldLhjYmJicBvjgcuXLzsNzvhzxk9/Bb9cZVEprW5WVVUVzp4963R9TEyMorLUaorBLyJSvYTkGPzrm4ew/n/78OG4VRBGWAJggGPq/amjBfjzHXMxcGQHPPxSt+A2lqiW+W3PGQhhlZVZ/V+rAxsBAFHLvwWeHC5T64iCZ+LEiUG56GHwKwDMGV8SAQ5J0dFARgZw6BCweTPQs2dAm+eJvLw8m9+vvz7wXzqYvngUXgcVhBC4etW2XmtkZKRihzvat9UsVQE13qQ4y6JS4nBHo9HodDhp48aNFRVIAoDCwkJUOgmMh4eHK65u1smTJ12uD8b7RDApLxRNROSj2++9EfN+eQZtuzXy6P7L5u3E450/wP6d0h+qRFRz+347C2EU0OBaTDqishyZf2w3/fL996ZsCqJawhwMCMSNAiQhAdiwAfAksBgXB5SVAe+/r5ghj1LDHWNjY2VoiWd+//13h2UtWrSQoSXuCSEks9SUOtxRr9dLBmeSkpIUF0gCHGvUWatTx79lE2r6HiqEQH5+vtP1mZmZNdq/vxUXF6O4uNjp+kaNGinymKgJZn4RUUiJignH3z8ahCN7z2HK00tRXup6WEKl3og3RixGyw7p+NsH9yIqRv6hCUSh5MTxAiRfOYVH/zcZ4ZV6AIDOUIUwQ/VrU68Hmje/NiwoNhZYuhRQ2Ekikb/s3bvX7xfGe/fuRdu2bf26T6pmPeQRACIjTe9bzhiNwLRpwE03mWp+KVAghzta8yXzS2p4m9KCBtakgjNarTagwx0jIiJQUVHh07bOsr4aNGhQkyYFRHl5OUqcfDkWiOBiTYNfV65ccbouPT1dUYEkd4E6AIiPjw9Sa4KHmV9EFJKatU7DnI1PY8Dj7T26/4GdZzGyy//h+892BrZhRLXIhfPFMBgEimMSUR4Ri7pFF1C36ALiS+1OEM+eBfLzTbeEBCA9XZ4GE6mUki6qQo55yKP5PcpV4CsqCigtNQW+FDLk7ejRoza/161b18k9/c+X41KqdlaEAmqmSRFCSGbOBDrry9caTEVFRZK135RWgN3MWdZXQkJCQIKLNQl+uRqeCQApKcqa2bqgoEDyWDBTcsC5Jhj8IqKQpdVp8ejLtyHnpxGo19Czby8+m7YJf+71CY7tcz5LCxF55pf1fwAAyiNiMPvBt7H6lj9BQAOjxu70Q6cDNBpgwgTT0CIVftsohH9vRKQQng55jIgwzQKpkKGOZqWlpTa/X3fddUFvg6dBBfu2Av4taO5vFy5ccFiWlJQU8MeNjIz0ehshhNMstaioKH80y6+qqqqc1s5q2LBhQB6zJsEvqWPBrFEjz8qxBNOZM2ecrouMjFRswLmmOOyRiEJeUlocZn73ODZ8tw8fvL762sxzThRdKcff//Q1bry5PsZM74+4xNCZ5YQomPL2nrWcTBo0Wqy+5WGUR8ZiwPo5tnc0GID33gNeein4jVSwTp06QafTITs7G9nZ2XI3h2po7dq1AAJTQPj666+37J/8yHrIoxDWE0o7qqgAfvgBGD06eO1zw74Qe7DrfFnPuu0J+yw1AAgLU+7l6vnzjl+UBmP4oC/BqsuXL0suV2pw0VkWldIKxgOmobqugl9KGz5YWlrqMutLqZmA/qDcdxMiIj/rfs+N6NSrGWa8vAK7Nzsf5y4EoNEB+3ecwdM956Dvn9rg0ZdvQ1i4MmcZIlIivb4KhQVlpmCzVmP6X6NB/QtHYdBooRXGaxeROh2wa5dsbfUPf6ZsmfaTm5uruJNm8l2PHj0Ctu+YmJiA7r/Wspvl0eUgvsaNgW7KmkHavhB7sGdu82bYo1SA7MYbb/Rnc/xKaobHQGUk2fMl88tZpk8ga5P5ymg0orCwUHKdEmcfvHjxotN1SmzvuXPnnK6LjY0N6WH0yjvaiYgCKComAn/78F5M+WIYomPtUno1gEZrGn1lzg7TaIEf//sbht/6IX78ag9n0yLy0MY1R2yzLIWAzliJVod/gU4YoQkPB0aNAsLDTZlfixebMieIiJTCmyGPeXlA06bBaZcHysvL5W6ChSfnTmfPnnVYptMp90tHqRkeExISgvLY3mbDOcvyadKkiR9a43+XLl2SXB4RERHQwIyv5/iugl9Km1W1srLS6SQCQPACuHJh8IuIaqVmrerhkw1PYeCIDtcWSiVuCECr00AI4NN/rceoO2bjty2uZ0chImDLxj+u/WI0vbAan9mPyMpyVDVvAWzfDnz8sen/zEygqAjYvFmexvqDUUD46WbuLyKylZOTg6ysLHTq1Cl4DxoWBrz6qvOKCdHRpsD9tm3Ba5MHDh8+bPN7sGZ4tObNsEf7gEegi8bXhFRtsmDyNlvLWXAmLi7OH83xKyGE08ykZs2aBfzxve3bqqoqp8e3EoOLrgJ1gLKHGfsDg19EVGtpdVo8/JduyPlpBDI7pJnGM0h8fgmjAITpJK6ksAJTn/sf/jr0c5w+5nxKY6La7PKlEpQUm7K4LOeEWg3OJTXCijv/jLDdu4A2bUzL27QBdu5UXJFoIlKe7Oxs5OXlITc3N7APdPAgkJVlGsqYkQE0bux8yKNWC/z973z/kuBp8EsqM0mJw/HM/vjjD4dlLVu2DNrje5v9JFWbTGkZSWZFRUWSy7VabVAyAb0t9C41/NVMacFFo9HoNKsOUN6MlIGg3HcVIqIgSUqLwxvzH8C42fchOj7cVPNL63hiYQ6ChRsr0eGXbzD2/vl4+8X/objQxbTnRLXQT8v2A7gWSxYCgFGgJCoeYa/8BbAvWBsTYyoSnZoa1HYSEUky1/rKzwdOnQJcXDCirAz4y18U9f6l19uel7RSeGDu1KlTcjfBK1LBuvDwcBla4p6zIY+NGzcOcks8IzX8FQBatGgR8McWQngdYHOXSaUkBQUFLtfXq1cvOA2REYNfRETVsjpl4JOfR+HxV28zLdBAsrpt5yu78PDpb9GpYDd2bczHn+/4BJ++sx5VlYagtpdIiYQQ+P23M6Zv+oWAOQRm/ub/jrsCfwJLpHR6vR5lZWVyN4Ocsav15ZC3ZM68SU4GjEZg796gNs+dQ4cO2fwuVwFrTzO/7LNngplF5S2pYJKSa5NduSI9SiHYmXWe1tOqcFL7M1jBRW8mEzAYDKisrJRcV7duXX81yS1P+9Zd8EvJ2Zb+EvrPkIjIC1qtBnc/3B5zNo7Cbf1bmk7c7IJgna/uMv1fsBOA6UPnxy/3YHjXj7Dym99YFJ9qta2b/kBVpTBlUGo0NnX0WrVLh04Xmqce5lifv24UmoqLi/Hoo48iLi4O8fHxGDZsmNNZzUhmYWHAG28Affo4fg8mBNC3rykzLMhDtp1l8iiRJ0E3g8Hxi0OlZlEB0gGE5s2bB78hHpIa8ijHDISenBvLdWxbB2m9OfaKi4udrlNiFpWrWnX169cPYkvkE5pnoERENRQVHY7nptyF978fjsYtU6DRaKDRahBp1KN9YR4AoENhHiKr9JZ6YMIgMP+t9RjV6xNsW3WYQTCqlX78337LsW80mjK/NBrTteLQRzq43pgoxL3yyivYv38/tm3bhu3bt+PEiRN4+eWX5W4WuRIT45j5pdUC8fGyDNl2NVObFCUU3XZ1PqSkIY+enLdJFWNXarDOaDRKBhflqPflSd86C854W4erJrzJ/Lp8+bLTdcE8JjzpW3f3SUpK8ldzFI3BLyIiF5KvnsbU3ZMw//RUvP/7eLybNwnhogoAEC6q8O6+SZj5+3jM+G0c3smbgvTycygtrMDM137ECwM+xc6Nx2V+BkTBs3fXaZSXV9ksM2V/CTRrkYzIyNCeRYjIncWLF2PGjBno0KED2rZti3feeQdLly6VpS2lpaVYunQpnnzySbRs2RJRUVGIjY1Fu3btMGnSJJdZDfPnz0fnzp0RFxeHpKQk9O/fH5vdzNa6adMm9O/fH0lJSYiLi0Pnzp2xYMECfz+tmrMudt+oEcTSpY6ZX0YjsHAhcOONpvsH0fHj3p1XyFl025Nhj/aZj94EH/zNk8wj+2CSkmfHc1WMPdg8CdA4K3afnp7u7+Y45WmgzWg0Og1EB3sYrCd9a18H0FpYWJhsQ6ODjcEvIiJXqovehp89hWT9ZdStsj1Jq1tViNTKK0itvIJSXTSuhsdXD5PU4Mq5Ekwb/R1eGDAfuzczCEah79uFv12r9SUEYBQQQkBA4MHhHeVuXmBx3CN5ICYmxqZA8qVLlxAdHS1LW7744gvcf//9mDt3LnQ6He699150794dx44dw4QJE9CpUyfJIVMvvfQSRo4cib1796J3797o3LkzVq5cidtvv91pIG/RokXo0aMHVqxYgbZt26Jfv344dOgQhg8fjldeeSXAz9RL1sXuT5xwPsujaWw3EMQLc09I/c3k4ssFddOmTQPQEs/4MuyuWbNmAWiJfyjpWHBWG8uasyHgderU8XdznPI0cOUqA7NBgwb+ao5Hahr8qi1DHgEGv4iIXLMueqvRmIY6WDFAAyM0WJR+Nya1/AvKwsyz2AlLnbDLZ0vw9ovL8eI9n+K3LfnBbT9RkBzadx5FV/WAsfqCsPpcTAigWYsUxCfIc4FPpCTPPfccnnnmGbz//vvIycnBc889hyeffFKWtoSHh2PUqFHIy8tDXl4evv76a6xYsQIHDhxAhw4dsH//frz00ks226xatQozZ85EcnIydu/ejaVLl2LFihVYv349dDodRo4c6VAT6fLly3jiiSdgMBiwcOFCrFu3DgsXLsT+/fvRvHlzTJ8+HevWrQva83bLrti9U337AqtXm4Y/KoiSAh5mzi7Oq6qqHJbJWTzeWbF1M7XVJ5MKOMnVXk8Ci84CZMHMSvK06Lur4vHxQX5P8CT45SpYF+z2yonBLyIid8xFb6dPNw11sKKDwOcZg7G4wQAYNbrqrA3AUiXfqlj+pbMleOv57zD63k+xd9vJID8JosD6cv52CIMRQgNACMvLQAPg8advkbdxRArx6quvYvz48fjvf/+LBQsWYMyYMRg3bpwsbRk+fDg+/vhj3HjjjTbL69evj5ycHACmYZrWAYF3330XAPD666+jRYtrM7d26dIFzzzzDAoKCjBnzhyb/X3yyScoLCzEoEGDMHjwYMvytLQ0vP322wCA6dOn+/fJ1ZT5c79HD+n1PXsCK1YAtShjwhfuhj16W78s0FwVBAdcFzhXGmd9npKSEuSWmLjL/JKzTq71cepp8MvZEE3r/QWLVBDZnqtjt7YMeQQY/CIi8tyuXYD9N5I6He6/OQzJDexTss0f4nZTRQK4eLoEU5/7H/5y32fI+1U5hV6JfLVh9WGUFldfIBsFRHWheyEEbr+zOSKjlFsThSjYnnvuOWzevBlbt27Fyy+/rMjp5du1awfANFTm0qVLAICysjKsWbMGADB06FCHbczLli1bZrN8+fLlTrcZMGAAoqKisGrVKpSXl/vvCfhLaiqERmNb8F6rDWqB+5qQ+9hyd1FtXzw+mMPbpLgaGgbA8lpQA2eZVnJl+bh7fTvLugvGsHDr49TTQJCz/pXjGK5JVl1to7xPWyIiJaqoABYvBgwGIDwcGDXK9L/BgLjV3+P9RX/C6/93H+ok2X9IO/8m6/zJIrz5zLd4ecjn2LfjdGDbTxQglZUGfL/09+qZHW2FR+jQ994bJbYKPaI66OevG5Gcjh49CsA0RMo8C9iBAweg1+uRmpqKjIwMh206djTV9duzZ4/N8t27d9ustxYREYHWrVujvLwcB4NcON6tigrghx+gEQIIC8PloUNNn/tGoynry80QOTnYX+C2bNlSppbYcpbVYx/wuO6664LRHKdcDWUD3GeGKYmzQJ5cwx7dBRadBcdSFRhodpWlVq9evSC2xMRd5pfRaOQM9NVqdfCrpKQEn332GV544QXccsstiIyMhEajwcSJE91ue/LkSYwcORINGjRAVFQUMjMzMWHCBJdR7bKyMowfPx6ZmZmIiopCgwYN8MQTTyhqil8icmLzZqC4GGjZEti+Hfj4Y9P/mZlAURGweTNuvOk6fPjTSLz673sQEx9ZXbTa/TdIZ49fxZRRS/Hq0C+Ql3si8M+FyI++nPsrDFWmkyqbWu0CePDxjtDpavWpBpEqzZw5EwDQr18/y+x7+fmmmpVSgS8AiI2NRWJiIq5cuWIZElRYWGiZcc7Zdubl3s5iGHCbNwPVw/LOPf88Tk+Y4PC5rzT2fShn/SzAs9kerSl55kQpUVFRcjfBKaUF6tzVU3M2BFbO2UqdcZVpJccx4S745S7wWJvU6jPSQ4cO4fHHH8esWbOwbds2ty9Ks8OHD6NDhw6YP38+kpOTMWjQIBgMBkyaNAm9e/eWPMDKy8vRq1cvTJ48GcXFxRg0aBAaNmyIefPmoUOHDpZv2IhIoVq1AmbMAHbsANq0MS1r0wbYudO0vFUrAKYTvXZdG+P/Vj+Jl6bdjcgYz0/kTv1RgDefXYaXBn2GX346BKPB+1mHiAKuvBx4+22gvBwn8wuwd+eZawmOVkXuGzZJRJsO8n6LH0yc7JFCxffff485c+YgPDwckydPtiw314yJiYlxtiliY2MBXKuHY11nxtl29ttI0ev1KCwstLkFXKtWQOvWAIBoczabxOd+MHiawaW0oaOhVEtIKsCQkJAgQ0s8o7T6ZO4CMM5e/3IP3ZUiNfGBmRzHvLsYBoNf1yjvaAqiOnXq4Mknn8RHH32E7du3Y9KkSR5tN2LECFy8eBEvvvgifvvtN3z11Vc4cOAA7r//fmzatAlTp0512GbKlCnYsmULunTpgoMHD+Krr77C1q1bMX36dFy4cAFPPPGEv58eEflTaiowejRgf/IeE2NabpeWrdFo0OmOpvhk3dN4dnJvRES6f7vVaEy3i2eKMOvvK/FMn7n4/vNd0JdznD4pyKJFwGuvwbhwIT6ctr46UiOu/Q9AowWefKGbrM0kIu/t378fjz76KIQQeOeddyy1v+Q2depUJCQkWG4NGzYM/IPGxACHDgEA6mzYAI05k8bJ534gKXlGQU+EwpArqcwkJQe/lBYIdUfOmlTeBqw8KTAfTK6CcYDrY0Hu7NBgq9XBr2bNmuGTTz7Bn//8Z3Ts2NGjD5Zt27Zh06ZNqFevnmWGGsCUpvvhhx8iPDwc77//vs2LoqKiArNmzQIA5OTk2KRvjhkzBm3btsXPP/+M7du3+/HZEZESaLUa3HZ3JuasH4Un/9EDujCJD1gNoNWZpsXTaE3rtToNSosq8PmMzRjV6xN8Nn0jrl5SVgo71VLffAMAyH9nNir1BlO4yxz3qj68H//zLYiOVvfFmteEn28AOnXqhKysLMvMe6Ru+fn5yM/Pd3uh4guDwWDZv69OnTqFfv364cqVKxgzZgxGjx5ts958/upqOJU5QGAu+mx9zutsO/ttpIwdOxZXr1613E6cCECJgIMHgawsoHFjICPD9H91xoS2shKZffteW56VZbo/ueTNsEelZ4lJ1QNTclBSKkCjxCwqwHkwKVjF47099jwdLRYs7gKdrtabh7XXFsp8BSiYecaagQMHOhwsaWlp6N69O65cuYKNGzdalm/atAlXr15Fs2bN0KFDB4d9Opsdh4hCh1anRa/7W2HuxlF47OXbYPM5KyBZLBwwBc+MBuCnr3/D8/0/xYxXf8CZ41eC02gieyUlpkLPADL2bkZYRdm1dRrTPze2SUOrtvVlaV6oyc3NRV5eHrKzs+VuCvlBkyZN0LRpUxw4cMDv+96/f79l/764fPky+vTpg+PHj2PkyJGYNm2aw30aNWoEwFT3VkpJSQkKCgpQt25dy0VrfHy8JTvG2Xbm5Y0bN3bavsjISMTHx9vc/C4tDUhIAPLzgVOnALuZ/cILCkzL8/NN90tP938basBcW82sfn11vQ8nJyfL3QSXpDK/lB6wsyf3bJrOOAvO1K1bNyiP7+3fUWlZde5meywrK3O6ztUw9lDE4JeXXM1YY73ceqYbX7YhotAUFqZDv4faYt6mP2NY9i2IiNKaggaWkWPXgmBS35hu//kPvDrsv5j4xCLs33EqJIYSkIJZZ0I0bgw0b27JhAgzVuFvX2Xj71+MwtgvRuHlr15Ao4rzeOSpTjI3mki5Av2e7cv+i4uLcffddyMvLw+DBw/G7NmzJS8GW7ZsicjISFy4cEFysqYdO3YAANq2bWuz3Dx00rzeWmVlJfbu3WuZPEpWCQnAhg3A+PGSqy09O2GC6X6BCMDVgP3fxDxLp5y8yfxSQntdcRdgUAOlDtN0Fkwy1wNUGqVlfrkahmkwGFxmG0dH289SH9oY/PKSu5lupGas8WUbIgpt4RE6DBp5Ez5e/RQe+UtX6CKqLzSE6WRRKghm7cjv5/Hms//Dy4M/x+YfD8FQpf6TMlIg60yI/Hzg7Fmb1fFlBahbfBF1iy+iPCIWD78+EBER6pqty38CMO6RQpKSskX0ej0GDRqEbdu2oW/fvvjyyy+d1oCJjo5Gr169AADfVA9/trZw4UIAptER1gYMGGCz3tp3332H8vJy9O7dWxkz54WFAW+8AfTp47BKAwB9+wITJ5rupzD2wRklHGfeBL/UNoRQjZSa5eNspsdg1aNS+7BHV4FZd8Xua9uwR+W9cyucu5lupGas8WUbKXq93uYADspMN0QUUBGRYej/cHv0e7Atfll5GPP/9TPKSjwv+nnhdBE+HL8KCz/aiq79WqD30DZITFbmyQ2pkDkTYvJkiMmTIaCBVlw7yTJotNAIgVUdH0DTT2cg6Xp1DbMhkkOfPn38fqHvS7Fog8GAhx56CGvWrEH37t2xePFiREREuNxmzJgx+OGHHzBlyhQMGDAALVq0AAD88ssv+Pjjj5GYmIgnn3zSZpunnnoKb775Jr799lssXrwYgwcPBgCcP38er776KgDg5Zdf9rr9ARUfD2i1EEajJTlbo9UqLttL6VwFFZQYrHNGzmLs/qTU4uZKG0bojpqOB3fBrzAFBvIDSdXP9v7778e+ffu82mbBggXo3LlzgFoUWFOnTsUbb7whdzOIKAC0Oi269ctE174tkPfrKcx+cy0unfF8muoLp4vw7dwd+HbuDrS+pSEGPNoeWTdfB61WuSeTpBDl5cD77wMvvghIZV5UZ0Lk7i1A58Xv26zSCSO+vXUk6k4ai+ata3fgSxgB4aeXm2AiZ8gSQkgOGZTDrFmzsGTJEgBASkoKnnvuOcn7TZs2DSkpKQCA3r17Y/To0Zg5cybat2+Pu+66CxUVFVi5ciWEEJg3bx4SExNttk9KSsLcuXMxbNgwDB06FD179kRycjJWrVqFgoICjBkzBj179gzkU/VORYWptqHRCISF4fJ996Hu0qVAVZVpeUUF4CZISLakMr+Ukj0THx/vNqHAVc0kNVFigNFoNMoeTPK2X5xlWikxuOgusKjENgeSqoNfx44d87poqKsZajzhbqYbqRlrfNlGytixYzFmzBjL74WFhcGZ6pmIgkaj0aBVpwzMWPoYjh+8iDn/XIdj+y642ACWWfbMwyX3bj2BvVtPICE5GncNa4s7Bt2I+Lq1a0w/eWHRIuC110yzmD38sORdln29B+m7d8Og0UIrrmVCGDVatNNdQJO7WgS1yURqNHz4cLmbYOPKlWuTp5iDYFImTpxoCX4BwIwZM9C+fXvMmjULK1euREREBHr37o1x48aha9eukvsYMmQI1q9fjylTpmDLli2oqKhAVlYWnn/+ecX1CzZvBoqLgZYtcfif/4Q+MxOXHnoILcaONdVB3LwZUFKwToJShhC6GvZY02syf4mOjnYb/HI2LI9qTglDSr0Nfjkbxusuc1YO7oJfSgyIBpKqg1+7du0K+mM2atQIO3fu9GrGGnez43gyyw1gGpNb28blEtVmjTNTMGn+UJw/XYjPZ2zCjp//kLyfRmsKepk/jM2/F14px6KPt2HRx9vQrmsjDHikPVp2qF/rPujIDXPtnoULJYNfy77egw3Lf8fk41uhE0ZUaXXIzeyFTgfXIMxoQOM9PzMTAoAQntW18XRfFHrmzZsndxNsTJw4ERMnTvRp2xEjRmDEiBFebdOtWzf88MMPPj1eULVqBcyYATz9NPRHjwIA9JmZwM6dwOzZpvUKZ772kJur8w2lBL88qYMld2aSt9RUnF8JbfXXeXEwr9N1Op3LQvZm7oY91jYseO8lVzPWWC+3nunGl22IiMzqNYjHX96+GzkrRuDOIVm2KwUgjLbF8YUQDh/kuzfn45/Z/8Poez/D8v/sQvFVddVXoAApKTEN4wGA7783/W7lm892YN2Kg2hy/iAiq8pxLqEBZgx6G4u6/RlLx8yByMyEpqjIlAlBRBQKUlOB0aMB+6BITIxpeWqqPO3ygtJmcFNy5pcnAQu1BRCkgiJyJFB4chyGUvArmJN2ePL3NBgMisisUxIGv7xknrFm2bJlDm+E586dw4YNG1C3bl1069bNsrxbt25ISEjAkSNHJLPVnM2OQ0RkLb5uNEa82gOz1z6Fx17phrAIq7dwce3D29WHeMn5qyj6xySM7jMbM177Afu2n4LRyDSTWuPgQSArC2jc2HRr3hwwf5bp9abfq9cVpDXB4SUbIACcrZuBpZ1HYMZ97+BsUmNk3lgPQ95+HJqdO00ZEirIhCAi8oZSgjNq5mrYo1JqfnlS80gqmKTkQuFS7XVXXicQPMmqc5a9FMxRCv56rGAOe/RHYLE2jgRh8MtLnTt3Rrdu3XD+/Hm89tprluVVVVV47rnnUFlZiRdffNFmrH1ERASef/55AEB2drbNuPF3330Xe/bsQY8ePXDTTTcF74kQkWpFxYSjzwNtMefnUfjrzHtQ//pEQOPZkKubL+/En/KX4ObLO7Fj/XFMfX4Znh/wKb6c9QtOHLkU+MaTvNLSTDM45uebbmfP2q4/e9ayrkBEoCimLiAESqISsKHVAFRoI5DVLh1Pj7nNdNKkokwIIiJvHK0e8kihzdcAgJJL0Uhl+3gSiPI3Tx7TWRA0mIEkNQ579EfwS8kB3ECpfc/Yzv33348zZ84AAE6fPg0A+OSTT7CiehhI/fr1HYqAzps3D126dMHMmTOxZs0aZGVlITc3F0ePHkXXrl0xduxYh8d5/fXXsWrVKmzevBktWrRA9+7dcfz4cWzduhWpqamYO3dugJ8pEYUarVaDtrc2xNv/fQiXzhVj2fztWLPU9Qy4nS+Zhll3urQDv6SYZr4tvlqOHz7fjR++2I3U6+Jxx703ostdzZGcHvxvCSnAEhKADRuAyZNNN43GNKNZNaHTQRiMWNluCFa1HwoDtIBGY55TAbf1bob7HmpfK78tdMe67p4/9kVEpHauMr/ULjY2Vu4mOCUVUJJjKKwnwwCdFWQPZnu9OadxFVAKZjDJk8Ciu+CXEgv0B1qtz/zauXMntm7diq1bt+LEiRMAgFOnTlmW7dy502GbFi1aYOfOnRgxYgQuXLiAJUuWQKvVYty4cVi9erVk1DcqKgpr167FuHHjEBMTg6VLl+L48eMYMWIEduzYgaZNmwb8uRJR6EpOi8OI13pg7vqn8ewbdyI+yfGkIcKgR9uC3wEA7Qp+R4RRD422eqhk9f8XTxfhm4+2YcyQLzB+5CKsWfo7SgrVVeuC3AgLA954A5g+3SbwBQAagwHf3vw4fmw/rDrwZQp6QQg8MqoT7n+4AwNfRFTrZGRkyN0EVWLwSx5SNcrkyPLxdUgpoNzML1dF5rXa4IVWPOkfd8EvJWcvBkqtz/z6448/fNquYcOGXs/aEx0djUmTJmHSpEk+PSYRkTth4Tp06dMCXfq0wNlV2xDxp6EwFpmGWoeJKoQLUyp8uKjCtJ3jUaUxfQzodRGYecOzOBedZtnX8YMX8ek7G/HptI1odfN1uGNQFtp1bYSIyFr/0REadu0CdDoIgwEaAAKAUaPFdZf/sLmbMAq8Mrk3GjSsK0MjiYiuycnJQU5OjkeznPlTYmJiUB8vVITylyXWJW6URir4JcffwpOAm7OZNIOZ+eVN0MrVe4/SjncGvxzxCoaIKESld2oJtLgO2LJFcn1iZaHl58Nx1+NqeLz0jgTwe+4p/J57ChFROrTr2hi39GqG1p0zEB1b+1KmQ0JFBbB4MWAwwKDVYVuznuh8ZB3CjAa0zd+Kbwx/hkEXhqgoLf7xzj2Ijat9J0heM6I6Tc5P+yIiB9nZ2cjOzkZhYSESEhLkbg55KBQzv5RcL0mpM/xptVqHgIyzYJJSAzPBDrz7wmg0QqvVun3d1cZhj8p91RIRUc3Y1XcSGg00VicdBmigAfBtRn/8r2F/GDXu09Mr9Abkrj2K3DVHoQvXIrNdfXS+oynad22EpHpxAXwy5E9lq9YhurgY5+Ib4NPuf8GZ5EbY2LIfRqx/F/UKz6DxhQOoO7gfHn76FsV9k0lEROrgbNiju4wUNQjmEDdvKTX4JXU+4exY8GTIpL/4K/NLKaqqqhAREcGC9xJq3zMmIqpNzPWdEhOhGTPGZpUOAss6PIYlUV09D3AIQKMz3ddoFNi34xT27zyNz97ToEHjRHS6oyk6dm+Chs2SGDSRQ3k58P77wIsvAhKFZvXlVXh/ymoU7M/HTTc/ji3Ne6MyLBIwAmeSGmHaPf9Cl0NrMPifD6NBx0wZngARkTJo9Hokf/45Lj3yiNxNCTlqCCComX3/KiXIYX1eWFVVhbCwMKfHQjCDi6EW/KqoqEBERITTIaVmSjkugqn2PWMiotqour4TrD+0dToMbKvFHTNHYNOKA1g6fwdKC6WnnIbGdNIihDAVhzIv1mgsy0/9cQWn5m3Ht/N3oE7dKHS6/Xrc1ON6ZLarj7Aw5X5DqjhuAlguLVoEvPYakJEBPPywZXGFvgofv/MzDu+7CI0G0EQnYP0N/YHq7D8AgACSGiVh0GdzodUycElEtVv8ypVIf+89VKalATfdJHdzVMlZ5pfUbITkP/b9rZThbdZBpsrKSoSFhTkdmhfML1CtH8vdUEGlZtVZ0+v1iIuLcxv8CmZ2nVLwaoSIKNRZ1XdCeDgwapTpf4MBWLwYcdFa9H2wHT78YSTe/upP6DOsDbT2n4ei+oTA/lxEmAqiQ5h+NgfCCi+XYfXSPLwz5nuMG/ENpr/yPX765jfkH74Eo9HqxKK8HHj7bdP/ZGIOYC1e7P2233xj+n/hQgBASbEeMyeuwl+fWIjD+y5a7mYfxASAZ17rjr9NHcDAl4+EEH69AUCnTp2QlZWFnJwcmZ8dKdHOnTvxl7/8Re5mhCSDwYD4n34CAMv/5D1nwa+ysjI5mhMyvK2hFhMTE6CWeMc62OIuMBNM3gSBlNRuZ8qrz6ndBeqUPHQ3UJj5RUQU6jZvBoqLgZYtTcGRNm2A558Hhg4FDh40re/ZEwCQlpGAR0Z3xcMvdsHhvefw/Re7sHtzPgxV1cESDSAgrPOFbAhzYEtz7aT37IlCnD1RiL25p6DRAJFROmTdnIHWnTLQ/o+NqCuRqVSrWQewvOmTkhJgxQoAgPG75Rj32GcoqgyDRquxCVoKAWg0qP4H6Ny9Ef7E2l6KlJubi/h4JxNRUK105swZ/Oc//8Fnn32G33//HQDw3nvvydyqEHPmDPJXr0bjDRsAAHXWrwc2bQKaNgXq15e5ceohhHD6uVJaWhrk1tQeUoGxYM6c6Ip1kElJ2X+hlvllDn6FQm09f2Pwi4go1LVqBcyYATz9NGD+9q9NG2DnTmD2bNN6OxqNBi3apGP01H4wVBlxYPcZ/LTwN+zenF8dPNFcO0GQOk8QADTV0bLqcwpN9WJ9uQE7Nx7Hzo3HkbD3A9QFcHTyBzhV9ybc2KEBUtLr+LsH1MMqgIXvvzf9Hhsrfd+DB4H77jPdB4DQV0BTPb25trICry58EQat6WO+IiwCn9z+Ci7EN7BsHlsnHOPevQdRUcqdrl1NhDDd/LUvIrOysjIsXrwYCxYswJo1aywXNK6CC+Ql6/fTggJcX3htNmRtVRVw221AfDyQmGh6T166FMhUTl1EJV7kWtdGcjfsUSnD8tTC1d9bap1S+jc8/Nr5hlKDX+6oIfPL3LeuAnW1MesLYPCLiCj0paYCo0c7Lo+JkV5uRxemRdZN1yHrpusghMDxQ5ew9ts8bPrxIAyVAqI6+qXRaGwyvwCNObnIFBiwO7eIMOjR5rIpc6Hhga14+58rUaGLRHL9ODRqloxmrdJw/Q2paNwiBTFxyjhx8zu7ABYqKoDqABb0eqB5c8B80mp/wZWWBkNcPHT79gFwHJGaUF5g+flYcnMURieY7qcDxky8C42aJgXkKRGRf6xduxYLFizA4sWLUVxcDOBaEKF+/fq4//77MWTIEDmbGDrS0kwzJFe/n0oqLDTdbr0VSE8PXts8oKRAgllZWZnTYY/2AYRYZ1/ykCRXRdelAh5KKWxunfmlpAwq6/5xF0hWUrudMR8fro6T2ljvC2Dwi4iIvKDRaNAkMwUj/3o7Rv71dpw9eRWbfzyENUt/R0lhhc1wR+BaBotGA6SVnsMLe3MQYTSdpIeJKoQL00lEuKjCW9v+gSpNdaaSLgL/bp2NRbH1AQ2QVC8WzVunodmN9dCkZQoaNU9GRGQIfIS5u+A6e/baz9UXXJcvFOOrOb9i/67TQMNs9CtugL77lgIaQGt1gWHQaKERAj+2HoyfWt8PhIfh2Vduxw1tOWwnIJj6RX6wf/9+LFiwAJ9//jlOnjwJ4FrgICMjA0OGDMHQoUPRtasXs/SSewkJwIYNwOTJwOTJ1cnLVq9DnQ4wGoHx44HXXzfNpKwgRUVFcjfBweXLl5GUJP0li/1FudqCX3IHDlwFNaTWyd1es8jISMvPSgoiWb+XupvN0dl6pfSxNVdDOJUSEA222vmsiYjIL9IzEjD4yZsx+MmbcfVSKXLXHcPmlQdxzFxc3erarDCiDkrDotGg6KzkvhIrrg0zORLfFIVRiaZfBHD5XAm2nTuKbauPWvablhGPNrc0RFJqLNIbJiC9YSJS0uOg06koldvuggsajekCy0yngzAasbvPCHyRchdKn1hWPZK0umO1OvzQ9gGURcRi8O7/2OxaJ4xY3OExbG43ANmv3oHmN9YL4hMjIk9dunQJX375JRYsWIDt27cDuHbRkpiYiIKCAmg0GkybNg3Dhg2Ts6mhLSwMeOMNQKuFZuJE23UGAzBxIjBhghwtc+vcuXNyN8FBUVGRJfjlro6SUgqyS5FquxzDCLVarSUryVWmn1RQSSmBcut+U9JQXetAkLtj1Vm7lRj8ctXHShkKG2wMfhERkV8kJMeg95BW6D2kFaoqDTj021ls/PEgdm44jrLSSpSFxeCtDq9h4PHvMPD4cggAOquCYYbqkM6yJvdgWeMBMGp112Jn1udt1ZucO1mIcyd/t6zXaDSWLLFGTZPRoEki6jdMRHqjBKRdF4+YuEgoUvUFlzE+AdpXXrZdZzBgUdtHsS7uTqC8+iSmupSamTAIXFfwBwwaLbTCaKmtJjRa9GlSgcHzHgzSEyEiT1VWVmLZsmVYsGABVqxYgcrKSstFV0REBPr3749HH30UAwYMUEyx6lrD2Uy7S5YoNvilVM6GPdpTchaKVNvlyFTT6XSWYEa5ixmypTKTGPzynLvML2eUeAy7et0x+EVEROQnYeE63NjxOtzY8TpgLFBWUoG9uSex+cdDWB55H0rDovHQkW9sttFB4Mtmw7Cy0V3Q2M8n6eTzW6O1O6GrzhK7fK4Eu37JtyyOjA4zTV1fNwZJ9eKQml4HSamxSEiORmJSDBKTY5CYEoP4ujEIC9MC5eXA++8DL74IREXVuD+EENCXVaG4sBzFheU4f6YYR/adw6Hfz+Py+WJUVhrx2K+L0ckugGXUaJFR8Iftc7Y7idUZq9DuVC50wogqjQ75Pe7F9Zu+g7ayEnGrvjfVEaulJzlESrNlyxYsWLAAX3/9Na5cuQLgWuH6bt264dFHH8WwYcNQt25dmVtaS1VUAIcPAwCETofCnj2R8PPPQFWVaTnfTwNCycW3pYI01sP3giUsLMxSK83bzC+lsP47Kyn4ZZ215apdoRRMsp58oDZh8IuIiAIuOjYCnXo2RaeeTQEAFQ+ugTimA4yGa4EeaNGw+IRpA/NCKdXnTvbfKLv6ZlNfXgWNBrhyoQRXLpTgaN55yftFROpQWWnALWe24Ild/4f/LMnH7y1vR2RUGKJjIhEZHYao2HDodFoYq4yorDLCUGlEZaUBVVVGVOmrUFFpgNEoUFJUgYrySkieR2nMgTtTm3XGKrQ//aslgLWlye249Y/1CBMGtD/9K740VllmbgQAAWEJD15/8SCiqvSoaNIcEf9bjKZt2gC//QYMHWoqqL95M9Czp9O+IaLgMdfqMr9vtWzZEo8++igeeeQRNGnSRN7Gken9srQU5U2a4MT06dBnZiJBCL6f+kgq80tJQQ9PSM3uJ1fwy8zVjIMMfnnP+vzRVbtcZYXJHUyyHhZrxppfjmrnsyYiIvlUVCDi+/8BRgMQHg6MHAnMmwddZSU6X9mFxfFhuFpkcJy+EDBHyQANbGaZlFS92Jts/4oK04lNh9O5AICso79gfeLNNvvUAEB1xpnTXdvNdmm/3PJ/taaXDiHKoMfZuPqYc8sLOJPYCOub9cGTW2Yirfgsml46iEOpWVbPyTTxQLc7m+Gmlr2Ab1IR8fTTphk8AaBNG2DnTmD2bKBVK887gHwmhLg226kf9kWhrU6dOnj//fcxfPhwuZuiKjk5OcjJyfF5aJJbrVoBM2bgSNeuEObhpnw/9ZlU8EvJwRkpUllWcgQOPB0yqMSZP81sJ0QSivms8zQo5+p9R+7Mr/DwcOjNs4V7oLYGv5SbY0pERKFp82aguBho2RLYvh34+GNotm8HMjMRUVGGd19qgk9WPYE35w/BA6M64caO9REZXf0hfS1ZynlmGK6t12o10Gg0lhMu65+dbRNRpUfri78BANpc3IOIKn11plZ1IE1j2wwLjdXNeVjMYUZMADgTfx2+afMo3uo1GacTGgIATic0xFt3vomFbR/FmfgMRMWEof2tjfDSpN7499cP4+UpfXDrHc0Q3iAdGD36WuDLLCbGtDw11XU/keqVlpZi6dKlePLJJ9GyZUtERUUhNjYW7dq1w6RJk1BcXOx02/nz56Nz586Ii4tDUlIS+vfvj82bN7t8vE2bNqF///5ISkpCXFwcOnfujAULFrjc5uTJkxg5ciQaNGiAqKgoZGZmYsKECS5r10j5448/LK9jqVt6erpX+5ODEALFxcV44okn0LFjR7z77rs4c+aM3M1ShezsbOTl5SE3NzcwD5CaCowefS3wZaai91MlzZwo9XkbsMBlgEgFk+Qobm4dXHHVh66ywpRECKGY7C/r4Je3M2mayZ355e0xqcQC/cFQO0N+REQkn+pv1uEiU0mj0SC9YSL6PZiIfg+2BQBUVhhw4ugl5P16Gkf2ncPxw5dRdKUMrr44NBqqV2pMgTAp9UrOInvnvxFhMJ3g6kQVwo2mb6bDjVWYsuE1GDSmj8sKXQQ+vHk0zsdJXGBbFaJ3Gl/TaBzvDKA4Mh5rm/WFRmM+CROIi49Ck8wM1H/+dozv0ggxseqqJ1HbCAGXx6K3+/LGF198gaeffhoAcOONN+Lee+9FYWEhNm/ejAkTJuDLL7/Ezz//jHr1bGf8fOmllzBz5kxER0ejT58+KC8vx8qVK/HTTz9h4cKFuO+++xwea9GiRXjwwQdhNBpx++23IyUlBatXr8bw4cOxZ88eTJs2zWGbw4cPo0uXLrh48SJat26N7t2749dff8WkSZOwevVqrF692uthRGlpaejXr5/D8oSEBK/2E2zr1q3D/PnzsWjRIhQVFWHXrl3YvXs3XnvtNfTs2ROPPfYYBg8ejLi4OLmbSiqVkpIidxMcWGf4KDkzSYpUNo0cNcqirOqPusqeU0vwC1DW0EczV9loroJfcgeTIiIiUFpa6vH9a2vmV+181kREJJ/qb9YdmL9ZdyI8QoemN9RD0xtsL+ArKww49ccVHNh1BscOXMCpP67g8oUS6MtMJ4emjC3nmVhFEfEoDYtG/RLpzItE/VXLz0cTm+FqRLyrZwfAFLyQfEijALSARqO13E+rBWLqRCL9ugQ0b1UP7To3RKNmSYqZnYmULzw8HKNGjcJLL72EG2+80bL8zJkzGDBgAHbu3ImXXnoJX3zxhWXdqlWrMHPmTCQnJ+OXX35BixYtAAC//PILevbsiZEjR6Jnz55ITEy0bHP58mU88cQTMBgMWLRoEQYPHgwAOHfuHG677TZMnz4d99xzD3ra1UQaMWIELl68iBdffBEzZ84EYLp4GzZsGJYsWYKpU6di4sSJXj3nG264AfPnz/dqGyW4/fbbcfvtt+ODDz7AkiVLsGDBAqxatQoGgwFr1qzBmjVr8Nxzz2HgwIF47LHH0LdvX7mbTCojZ+ZXQkICrl699pkpNeyxrKws6O2qCansVDk+n60zi1wFaJQYUHJGiW2171vzhCSA66Cj3MEk+2GX7oaUKnmSiUBi8IuIiFQtPEKHJpkpaJLp+G13eVkFTh27gtPHC3D25FVcPFuMKxdKUHCpFCXFehiqjChDDN7pPBb3HFuG/oeXQcA086SZAVpoILC8+b34vsW9EDoXH51COMxAqdGYZr+skxCFOknRSEmLQ8OmSWieVQ+NmyUjLLx2pp6T/wwfPlyydlT9+vWRk5ODrl27YvHixaioqLCcIL/77rsAgNdff90S+AKALl264JlnnsH777+POXPm4OWXX7as++STT1BYWIhBgwZZAl+AKQvr7bffxuDBgzF9+nSb4Ne2bduwadMm1KtXD2+//bZleVhYGD788EN89913eP/99/H666/LfvEQTFFRUXjooYfw0EMP4ezZs/jPf/6D//znP9izZw9KS0vx9ddf4+uvv0ZycrLcTSWVkfOiNj4+3ib4JUVtmV9KyaTytKaUUupoeUKJbbUPyBkMBstnk6vML7mDSfbDLt31bW39grX2nGUQEVGtExUdgWZZaWiWlebyfpWVVSgpfAhX352Buv983WadDkbsGDoaV7o9gC5aQKvRQhemgU6nhTZMizCdFrpwDSIiw1AnIRqJydGoVz8edVNjodPVzm/WSDnatWsHwDR059KlS6hfvz7KysqwZs0aAMDQoUMdthk6dCjef/99LFu2zCb4tXz5cqfbDBgwAFFRUVi1ahXKy8stQ3TM2wwcONBhaGNaWhq6d++ONWvWYOPGjQ4ZY7VFeno6XnnlFbzyyivYvXs3Pv30U3z55Zc4d+4cLl68aLlIGTNmDDZt2oShQ4eie/fuMreayJF91plU5pfagl9qqlGmxGCSK84yqeQcQiiV+WWmpuCXErPqlIDBLyIiqvXCw8OQmBwGnDwI6HSA9QmOToeOsQXo+FI3+RpIyidn0S8Xjh49CsB0YpyUlAQAOHDgAPR6PVJTU5GRkeGwTceOHQEAe/bssVm+e/dum/XWIiIi0Lp1a/z66684ePAg2rZt63Yb8/I1a9Zgz549XgW/zp07hwkTJuDMmTNISEjALbfcgnvvvVf2Gbdqql27dnj33Xfxzjvv4Mcff8SCBQvwv//9D+Xl5Th9+jRmzZqFWbNmoV69erj//vsxZMgQ3HnnnXI3mwiA49CvUJjtUU3U1rfO2itnFrB90KisrMwSWHIV/JI7k8q+z1wFQuVuq5z4lTQREREAVFQAixebAl/h4cCoUab/DQbTcpV9W03qV1hYaHPzZhpzM3ONrX79+lkyr/Lz8wFAMvAFmLI3EhMTceXKFRQVFVnaYh7O5Gw78/Ljx49blrl7LKltPLF//35MmjQJs2fPxrRp0/DAAw+gRYsW2LZtm1f7USqdTof+/fvjv//9L86ePYuPP/4Yt912GwDTRc25c+fw8ccfsyYYqQ4zUvzPXJdMTVlqgPMsQOvi/sEmNexR6melsc+Wc/U6k7s4v5wY/CIiIgKAzZuB4mKgZUtg+3bg449N/2dmAkVFpvVETpgTv/x1A4CGDRsiISHBcps6dapXbfr+++8xZ84chIeHY/LkyZblxcXFAIAY82yrEszDl8zBL/M2rraz38aTx5LaxpXIyEg8++yzWLduHc6dO4fCwkL88ssv6N+/P/Lz89G3b1+vA2lKFx8fj6effhrr16/HkSNHMGHCBDRr1gxCCNUNc1IDJV/gqo1U5pfag19KDBwUFhYCUF/ml7N6avZD+ORkPeGBkvuXwS/PMPhFREQEAK1aATNmADt2AG3amJa1aQPs3Gla3qqVnK2jWujEiRO4evWq5TZ27FiPt92/fz8effRRCCHwzjvvWGp/qV39+vXxwQcfoEePHqhXrx7q1KmDW2+9FcuXL8fDDz+MgoIC/POf/5S7mQHTpEkTTJgwAYcOHcKGDRvw9NNPy92kkBNqwVM5WQ+vCpVArZICM2bmLxnUFrh1Fvyyrw8ZTFLDHs2U3L/2QxldBb9q0+Qy9mrvMyciIrKWmgqMHu24PCZGejlRgMXHxyM+Pt7r7U6dOoV+/frhypUrGDNmDEbbHb9xcXEAgNLSUqf7KCkpAQDUqVPHZhvzdlLtst/Gk8eS2sZXf//73/HFF1/gxx9/rPG+gmH58uVYsWIFjh8/DoPBgAYNGqBnz54YNmyYRxfY3bp1Q7durEXob65eF0RyBmacMR+zSg7OSHHWXjn72D5Ia53tpeTML2+CX0oM4AYLg19EREREIeLy5cvo06cPjh8/jpEjR2LatGkO92nUqBEA4OTJk5L7KCkpQUFBAerWrWsJSsXHxyMhIQFXr17FyZMnkZWV5bCdeX+NGze2eaydO3c6fSypbXzVokULAMCZM2dqvK9AOnfuHO677z7J+mRz587F+PHjsXTpUrQxZ6ASqZR95lcoFNpWYvDLTG1DSpVY8N4++GVdl0xNwUVXbeWwRyIiIiJSteLiYtx9993Iy8vD4MGDMXv2bMmLzZYtWyIyMhIXLlzAqVOnHNbv2LEDACwzNpqZh06a11urrKzE3r17ERUVhczMTI+2cfVYvrhy5QqAa3XElMhgMODee+/F1q1bLTW77G/Hjh1D3759cfHiRbmbS1QjoTjsUW3BLyUHOpwFaORss7PjVG01Fl0Fv2pz5heDX0REREQ15CyQ4evNW3q9HoMGDcK2bdvQt29ffPnll04vIKKjo9GrVy8AwDfffOOwfuHChQCAgQMH2iwfMGCAzXpr3333HcrLy9G7d2+bmbrM2yxbtsxhtspz585hw4YNqFu3rl+G7y1atAgA0LFjxxrvK1C+/vpr5ObmQqPRoHnz5pgzZw5+++037N+/H9988w1uvfVWAKa+mT59usytpZYtW8rdhJCntgtxJddLksqkUnJ7nX3WabXyhSictUltBeRdBb+UfEwEGoNfRERERCpmMBjw0EMPYc2aNejevTsWL16MiIgIl9uMGTMGADBlyhQcOnTIsvyXX37Bxx9/jMTERDz55JM22zz11FOIj4/Ht99+i8WLF1uWnz9/Hq+++ioA4OWXX7bZpnPnzujWrRvOnz+P1157zbK8qqoKzz33HCorK/Hiiy86XAA//vjjuOGGG7BkyRKb5bNnz8b+/fsdns/ixYvxt7/9DQCQnZ3t8rnL6euvvwZgKly/bds2jBw5Eq1atUJmZiaGDBmCDRs2oEePHhBCSAYma7ucnBxkZWWhU6dOQXk8tQVmlMaTzC9371VKo+TAgVSAxvrLCKVxdkzIOTzWWZtc1ftS4nBeZ5MJAMoM1gWLcl+9RERERGrhz1IrXu5r1qxZliBRSkoKnnvuOcn7TZs2DSkpKQCA3r17Y/To0Zg5cybat2+Pu+66CxUVFVi5ciWEEJg3bx4SExNttk9KSsLcuXMxbNgwDB06FD179kRycjJWrVqFgoICjBkzBj179nR43Hnz5qFLly6YOXMm1qxZg6ysLOTm5uLo0aPo2rWr5CyW+fn5OHDgAK5evWqz/PPPP8eoUaPQtm1bZGZmwmg0Ii8vzxIQ++tf/4r777/fuw4Mop07d0Kj0eDll1926F/AdFHyxhtvoGfPnjh27BiKior8MhlAqMjOzkZ2djYKCwuRkJAgd3MUQclDsTwJfil5mLIUJQcOpAI0Sg5+qYnaMqlcBeuU2N5gqb3PXMVycnKQk5OjqqJ7REREFBjmWlcAHDKlrE2cONES/AKAGTNmoH379pg1axZWrlyJiIgI9O7dG+PGjUPXrl0l9zFkyBCsX78eU6ZMwZYtW1BRUYGsrCw8//zzGD58uOQ2LVq0wM6dOzF+/HisWLECS5YsQaNGjTBu3Dj8/e9/96qGztNPP43U1FTs2rULP/30E8rKypCamorBgwfj2WefRe/evT3elxwuXLgAALj55pud3sd63cWLFxn8IpeUfj2g0WgsgS+pAFh0dHSwm1Qjagt+qS2zTm7OgrRqC365aq+cw0rlpry/FLnFb72IiIiUxZ/FcL3dz8SJEzFx4kSfHmvEiBEYMWKEV9t069YNP/zwg1fbNGzYEPPmzfP4/uvWrZNc/sgjj+CRRx7x6rGVpKysDBqNBnFxcU7vExMTY/m5vLw8GM0iFbOejU7JnL1HKrmAvBQlDnEzkwp4MPjlHV9qfimxj121tzYHv2rvMyciIiIiUjAlD2kjZSgsLJS7CS6Zg0VCCNXNRqhkUgEXqeCXErOSlMyXzC8l1gZ0NeyRwS8iIiIiIiJSFfu6eEomdUGu5AtxJQefpWp5SbWXwUXv+JL5pcQAo6tjV8mvuUBT3l+KiIiIiCiEffDBB6hXr55f7jd+/Hh/NYtUyNWsbkpgnfkl1VYlDyNUevDLPutPqr1K7l81UVvNL1fButp8TCjvL0VEREREFMI+/PBDl+vNFyfu7gcw+EXKZh38Ukt9MjNXAQS5eVorrTYHOvzJ1bHA7Dr1YPCLiIiIqIbkLHhP6uLPvy8vbElN1Bb8UvJMmvbDHvm54R++DHtUYvCLx4M0Br+IiIiIiIJg7dq1cjeBKKjUnPml5CGl9kPtGOwILFeB0NpcQ0ttGPwiIiIiqilRffPXvigk9ejRQ+4mEAWVdXaiqxnolEjJwTr7gIuSh2iqTUREhMPf3lX/MvilHvxLERERERERqVydOnXkboJTzgreK5mSg1/2Q56VPERTTYQQCA8Pd1jO4Fdo4F+KiIiIqKaEn28AOnXqhKysLOTk5ATxiRCRWiUkJMjdBAfWwx7VFqCxD34pucaeGjK/1DI0Uyr45SprUQnHhVr6Vm4c9khERESkQLm5uYiPj5e7GUSkEkrM/LIOfqntAl2v19v8HhERIVNL3FND8EvJNBqN5Rj1NvOL1IOZX0REREQ1ZD5p9teNiBzl5OQgKysLnTp1CthjaPR6pMydC41d4ENJnF2Ic/hVzVm//9oP05QKiiiFGoIznny2KeEYjoyMdFim9P719LxBCf0rp9r97ImIiIiISBWys7ORl5eH3NzcgD1G/MqVSH/vPcSvWhWwx6ipy5cvSy5XwvAre9aZX2pjH/CQCooohdKDM4BnbVRCgNG+DUIIVfSvJ3Q6ndxNkBWDX0REREQ1FYCaX0QUfPE//WTzvxKdPXtW7iZ4TG3BL1dBDiUHv9Qwk6YnASQlDC21b4Majl1P2xgWVrurXjH4RUREREREtduZMzBu2IA6GzYAAOqsXw9s2gScOSNzwyiYXBXlV0Jgxhk1TCbgSRuVkPllPzRQDTM9epqZVtuDX7X72RMRERH5gT8TtpT/HTNRiDh4ELjvPqCkBCgogLaw0LJKW1UF3HYbEB8PJCYCsbHA0qVAZqZcrVUltWV+lZaWOg1yKTlwYF+fTIk8aaNcAUbrgvf2AS1XQTsGv9RFGX8tIiIiIiKiYEpLAxISgPx8wCrwZaOw0LQ+IQFITw9u+0KAq+CXUgIH1srLy52uU3LgQA2ZX/azZ0qRM/gl9TPgOrCklGPC07+/EjLr5KS8dxwiIiIiIqJAS0gANmwAxo8HNBoI+4LxOh2g0QATJpjuFx8vTztDlBKHEZaUlDhdp8RgnZkaan55EvxSSjDJmhoyvzz9+zP4RUREREQ1I4R/b0RBsH37drz11lsYPHgwMjIyoNFoPJoxcP78+ejcuTPi4uKQlJSE/v37Y/PmzS632bRpE/r374+kpCTExcWhc+fOWLBggb+eiu/CwoA33gAmTIDG/rVnMJgCXxMnmu5HXnOV+RUVFRXs5rhVVlbmdJ0SZ9M0U0Pwy5Nhj0oMfrnK/FJKMImZX55R3tFFREREREQBN3nyZHz77bdebfPSSy9h5syZiI6ORp8+fVBeXo6VK1fip59+wsKFC3Hfffc5bLNo0SI8+OCDMBqNuP3225GSkoLVq1dj+PDh2LNnD6ZNm+anZ1QDixdLL1+yxBQAI5+4Cn5FR0cHuzk1ouTgl1SARilZSWauhpSa6XS6ILTEO66CX0ppryd9CyinvXJR1iuCiIiISIWY+EVq1KVLF4wbNw7/+9//cObMGURGRrq8/6pVqzBz5kwkJydj9+7dWLp0KVasWIH169dDp9Nh5MiRKCgosNnm8uXLeOKJJ2AwGLBw4UKsW7cOCxcuxP79+9G8eXNMnz4d69atC9yT9ERFBXD4MABA6HS4eued1zK9Dh82rZdZy5Yt5W6C37k73shzUgEapQ0r9SQ7Sa6AnavAphpmAPW04D2DX0REREREVOu89tprmDRpEgYOHIh0D4q5v/vuuwCA119/HS1atLAs79KlC5555hkUFBRgzpw5Ntt88sknKCwsxKBBgzB48GDL8rS0NLz99tsAgOnTp/vj6fhu82agtBTlTZrg8Ndf48SMGcCOHaaZHUtKTOtlJjVcSQ1Fzs1BBamL89o+BMufpDLr1BhclCu7ztXjqiHzq8LDAL3SsgGDrXY/eyIiIiJ/YOoXhbiysjKsWbMGADB06FCH9eZly5Yts1m+fPlyp9sMGDAAUVFRWLVqlcfDdgKiVStgxgwc+fpr6DMzTcvatAF27gRmzDCtVyA1Bb+kgjNKCRyEglAYViontQe/PK35xuAXERERERGRCwcOHIBer0dqaioyMjIc1nfs2BEAsGfPHpvlu3fvtllvLSIiAq1bt0Z5eTkOHjwYgFZ7KDUVGD0awj5YEBMDjB5tWq9AroqzK43UxXltvxAPNKUMyVO7UJrtUcl164JBGX8tIiIiIiJSrPz8fACQDHwBQGxsLBITE3HlyhUUFRUBAAoLC3H16lWX25mXHz9+3N9NDnnmflYy88W2VAChtl+IBxqDX55Te+aXp1mgtf01x9keiYiIiIjIpeLiYgBATEyM0/vExsaioKAARUVFqFOnjmUbV9vFxsYCcB3I0ev10Ov1lt8LCwu9anuoKikpkbsJbpkvtqUyU5R8IS41jFBtwsJ4qe8PrgJLSgl+kWeY+UVERERUQ0IICKOfbiFw0UXkT1OnTkVCQoLl1rBhQ7mbpAiVlZVyN8FjSm6rVGH4UHgfZmDGc77O9sgAo7ow+EVERESkQJ06dUJWVhZycnLkbgoR4uLiAAClpaVO72PORKpTp47NNq62s99GytixY3H16lXL7cSJE941nmTjarZHpTBnH1pTcns9peTMOqXxddijUmp+kWcYqiQiIiJSoNzcXMTHx8vdDCIAQKNGjQAAJ0+elFxfUlKCgoIC1K1b1xLIio+PR0JCAq5evYqTJ08iKyvLYTvz/ho3buz0sSMjIyWzc0j5XA17VAqpWRFDIfhFnnMV/FLqsavT6VQx46uSMFRJREREVFMCEH66Qf2jbSgEtWzZEpGRkbhw4QJOnTrlsH7Hjh0AgLZt29osb9eunc16a5WVldi7dy+ioqKQmZkZgFYTuScV/LIPKjCLyjfh4eFyN8EjvmZ+yYlfCHiPwS8iIiIiInIpOjoavXr1AgB88803DusXLlwIABg4cKDN8gEDBtist/bdd9+hvLwcvXv3RlRUlL+bTAqghqCRVIDGvkYZZ070jfXQZyXzJfgl97HN4Jf3GPwiIiIiqinh5xuRAo0ZMwYAMGXKFBw6dMiy/JdffsHHH3+MxMREPPnkkzbbPPXUU4iPj8e3336LxYsXW5afP38er776KgDg5ZdfDkLrSQ5yBwg8IVW3qaKiwuZ3Bhp842p2WCXx5TiVe0IBfmHgPQa/iIiIiIhqoeXLl+PWW2+13MwX/NbLli9fbrl/7969MXr0aFy6dAnt27fHfffdh/79++P2229HVVUV5s2bh8TERJvHSEpKwty5c6HVajF06FD06tULDzzwAFq2bInDhw9jzJgx6NmzZxCfdWiSKtpOnpEKfNgHvxho8I3UkFIl8iX4JfeQTrVk1SkJC94TERER1Zg/U7aY+kXBceHCBWzdutVhufWyCxcu2KybMWMG2rdvj1mzZmHlypWIiIhA7969MW7cOHTt2lXycYYMGYL169djypQp2LJlCyoqKpCVlYXnn38ew4cP9++TqqWSkpLkboIkZ0EFpQ8jZPDLP+TOjvKUL8GvsDB5QyneZiOqIQsz0Bj8IiIiIiKqhUaMGIERI0YEZbtu3brhhx9+8PqxyDNKHV7m7IJb6RlBHPboH95kR8kZTJIa+uqO2o4JuTPVlIDBLyIiIqIaEsKPeV9M/CIiL8mdheItpWdSVVVV2fyulgwmNVNbH6stmKS294hAYM0vIiIiIiIiFVPqkCa1Zn7Zz/DnS2YQOXJ1nKot80ttwSS1tTcQ+CpWoZycHGRlZaFTp05yN4WIiIgAzvZIpHL2wQ7yD2fBDrVlzTD45R+ugl9yHhO1IfilttdcIPBVrELZ2dnIy8tDbm6u3E0hIiIiIlK9vLw8uZtQq6gtcED+4SrIJGdwxjooJzysPaC2Y1jpk0wEA4NfREREREREKqKWTDVnmT7MpKoZTwM0SqPU4Jcv9cbUVqNMbQX6A0Fd4UoiIiIiBRJCQPhpvKJaL2qIAi0nJwc5OTkwGAxyN0V29rMRKpEQwmnwS6k1yiiwXAWM1Jb5pbbgl9oy1QKBIXciIiIiIlK8YJX+yMjICOj+/aGkpETuJrilluw0NVJr3yo1+OVLJqLaArhqC9YFAsN/RERERDXlz2QtJn4RySoxMVHuJrhVVFQkdxPcKisrU12AQC3UmiHsKvtIzuCM9WOrNbDoDocaM/OLiIiIiIgIGr0eKXPnAuXlcjfFreLiYrmb4FZxcbEqg19qCCxVVVW5XK/UQIer4JecbbY+TkN1WLVSj4lgYg8QERER1ZAQwq83AOjUqROysrKQk5Mj87Mjqh3iV65E+nvvAYsXy92UkHDx4kW5m+ATpWb+WAcv3AW/lDqzn6t2yRkotc78UkPw0xdqDET7G4c9EhERESlQbm4u4uPj5W4GUa0R/9NPph8WLgQefljexoQINV5wV1ZWyt0ESVqt1hKYKysrc3lfpQa/XNX1UlPmF7Oo1Il/NSIiIiIiqtU0paWos3Gj6ZfvvwdUUFBeDaSCX0oNzJi5y6qSi/WQQb1e7/K+sbGxgW6OT6KiouRugiRva36xeLw6MfOLiIiIiIhql4MHgfvuMwW5DAZklpRAa8740euBxo2BqChApwNiY4GlS4HMTDlbHDLi4uLkboJLSs38sg5+uWujnDMnuqLUjCnrIK0nwS+l9i+5xuAXERERUQ0J4b9JGkO03AiRsqSlAQkJwL59AACHS9lLl679fOutQHp60JoWSqQyv5Qe/HKXVSUX64CLu6F5kZGRgW6OX8mdSWUdlPMk+KXE7MWwsDDFZi0qhTJDr0RERERERIGSkABs2ACMHw9AInhtDtpMmGC6H+vv+UQq+KX0wEy5Qmf7tB4y6C745WpWRTk5C87IPRwyVIJf5BqDX0REREQ1JYR/b0QUeGFhwBtvAH36wCFEIwTQty8wcaLpfgqm9GCSPaVfpFdUVNj8rpQhbtZ/Z3fBL6UOL3Q2XFPu4Jc1T4JfSnzNKf11pQTKfFUQEREREREFQ3w8hEZjm/2l1aom2ystLU3uJljYZ8RIZX4pNTBjZh+gUUpgxrpv3QVolDrLprPMr+jo6CC3xDnhwRdQSgmIWlNim5RG2e88REREREREgVJRAaxYAY0QQFgYLg8dCoSHA0YjsGKFab3CKWlmv5SUFJvfpYIwSg3MmNkHP5RSo0yJQ+285SzzS0nPzZPMLyVmWcldN00NGPwiIiIiqiEhhF9vRBQkmzcDxcUob9IEh7/6CqcnTAC2bzfN7FhUZFqvcErKpFJSIM5flJSVpHbOgl9Kylry5DNYiYEmpQeVlUB5IUsiIiIiIiI7OTk5yMnJcVvvyCutWgEzZuBI164Q5iBHmzbAzp3A7Nmm9QqnpIteT4Y9qo2SspLUzr6empmSMqk8yfxSUsDZTIltUhr2EBEREVFNCT/fiMhBdnY28vLykJub67+dpqYCo0dfC3yZxcQAo0eb1pPH7INdoRD8UmKWj1o5C34p6TjxJPilpPaaMWvcPQa/iIiIiIiIiCQoMdChVs6GPVLNOZtMAGAA10w5+YVEREREKiWE/xK2+OUtEYUKBo7ImlR2ktKOEU8yv5TIVfArMjIyiC1RLmZ+ERERERFRrabR65Eydy40er3cTQkpSgts1AZqq/2kpHpfgHqDX66y6li3zkRZRxoRERGRGgnLP37aFxEFy969e5GwciXS33sPlWlpwE03yd0kj9WpU0fuJnglKipK7iaEPLX1sdraq1Sugl9Kmk1TTuoKCxMREREREflZ/E8/2fyvFvXq1ZO7CS7ZZ36pLVinRnFxcXI3wSvR9pNNyEytheNdDXtUWh/LhcEvIiIiIiKqtTSlpaizcSMAIH7jRqCkROYWeU7pWTP2wa/4+HiZWlJ7qC34FRsbK3cTbLgLfqlxKC8zv0wY/CIiIiJSoE6dOiErKws5OTlyN4UotBw8CGRlAY0bAxkZyOzbF9rqIUOaigrLcjRubLrfwYMyN9g5pV+IGwwGm99Zeyjw1FbcXGmBGXfBLzVmUSmtj+XCml9ERERECpSbm8ssCaJASEsDEhKAffsAAA6XhZcuXfv51luB9PSgNS3U6O0mEFBbMXY10ul0cjfBK2oLzCg921IKX3cm7AUiIiKiGhLCvzciCqCEBGDDBmD8eAASc0yYs6kmTDDdj0FonxUWFtr8rvRMNQo+pR0T7jK/GPxSL/YCERERERHVLmFhwBtvAH36wOHSWwigb19g4kTT/chn9sEvIqVzF/xS27BSuobv5kREREQ1JIwCQuOflC21zjRFpEb6qChEaDSAENeCYFots738xNUMdGqgtGLs7qhtyKMShVrwi8fENcz8IiIiIiKi2qeiAmGrVkEjBBAWhstDhwLh4YDRCKxYAVRUyN1CklndunXlboJX1BasUyJ3wS+1BZNiYmLkboJiMPhFRERERESKl5OTg6ysLHTq1Mk/O9y8GbrSUpQ3aYLDX32F0xMmANu3A5mZQFERsHmzfx4nQBISEuRuQsiLi4uTuwleSUxMlLsJXlFbsXtAeTXK3GFA9BoOeyQiIiIiIsXLzs5GdnY2CgsL/RP4adUKZ157DZeHDIGIjkarVq1Mxe537gRmzwZatar5YwRQWlqa3E0IeWEqq/kWHR0tdxO8wqykwFPbMRFIzPwiIiIiqinh5xsRBV5qKi4/8ACSv/wSGr3+WkZHTAwwejSQmipv+9yIiIiQuwmkMGoL1ikxsy7U6m6qcXbKQGHwi4iIiIiIaqX4lSuR/t57iF+1Su6mENWY2obkMfMr8NRWoyyQGPwiIiIiqiEBASH8dGPqF1HQxP/0k83/FDj16tWTuwmkMGqr+aW29pItBr+IiIiIiKjWMRQWos7GjQCAOhs2ACUlMrcotKWkpMjdBK+wUHjgabXKC0e4GvaoxGGariixf+WkrkHBREREREREvjh4ELjvPlOQy2CAsaQE4ZWVAABtZSXQuDEQFQXodEBsLLB0qWnmR/ILtV2IJyUlyd0Er7AGnH+4Cn7VqVMniC2pORa7t8XgFxERERERhb60NCAhAdi3DwDgMIDp0qVrP996K5CeHrSmkfKoLcvHLzOg1mIajcZSfsAZtdUoU9sxHGjqCr8TACAnJwdZWVno1KmT3E0hIiIiAAboUeWnmwF6uZ8OUWhKSAA2bADGjwcgMbGquVj4hAmm+8XHB7V5pCxqKxQer7LjVW2BJEB9xwSH7tpi5pcKZWdnIzs7G4WFhYzwExERySgiIgLp6enYcnamX/ebnp7OISxEgRAWBrzxBrBlCzT2Re6FAPr2BSZOlKVp3khNTZW7CaQwkZGRcjfBK8nJyXI3wWtqm01TbcdEoDH4RUREROSjqKgoHDt2DBUVFX7db0REBKKiovy6TyKyEh8PodEAQsByOavVKjrbKyMjAydPngSgvpkT1ZYxo0Zqq6nGJI7A4+vOFoNfRERERDUQFRXFQBWRmlRUACtWQCMEhFaLy4MGIem774DKSmDFCtN6BWZeJiQk4NKlS4iIiFBdBkr9+vXlbgJRjTAbW/3UFR4mIiIiIiKqic2bgeJiVKakQGM0ouSWW4Dt200zOxYVmdYrkEajQbNmzdCwYUO5m+I1tdWjYq2kwFLiLITuAspqm+lRbZmAwcAeISIiIiKi2qNVK1waNw6lWVkAgPiffgLatAF27gRmzABatZK3fSFIbRfiaqtHpbbhbSkpKXI3wYG74JfaZk5kRrojdb0LERERERFRreS3Gc9TU3H2nntQ55dfAAB1NmwASkqAmBhg9GiAxeRrPbUFOtSWWae2LCpAfbNTqu0YDgbW/CIiIiIiIsWr0YznBw8C991nCnIZDMgsKYG2shIATP83bgxERQE6HRAbCyxdahoGSbWS2jLVlJhJ5Yra+hdQX3Ydh+46YvCLiIiIiIhCW1oakJAA7NsHAAi3X3/p0rWfb70VSE8PWtOIaqJ58+aIjIyUuxmkMEqsqyY39YVciYiIiIiIvJGQAGzYAIwfDwAQ9uvN9X4mTDDdT2XDyJQsPNwh1Eh+wtmG/UdtM6i6o8bsukBjjxARERERUegLCwPeeAPo0wcOl7lCAH37AhMnmu5HflO/fn25mxCy0tLS5G5CyHAV/FJbZl2oBfL8hcEvIiIiIiKqPeLjIbRa2+wvrZbZXgGihsLb1sXM1dBeMzW11Uypw/FcBYzUVqBfbe0NFga/iIiIiIiodqioAFasgMZohCY8HBg1CggPB4xGYMUK03ryKzUMv7KeQCE5OVnGlnhHjRk+qSqcTVUts2nGxsYiMjISSUlJcjdFkZT/TkRERERERKpXVlaG8ePHIzMzE1FRUWjQoAGeeOIJnDp1KniN2LwZKC4GWrYEtm8HPv7Y9H9mJlBUZFpPtY51pgxnyQsspWarWQcS7QO2aqmr1rBhQ7Ro0UKxfSw3Br+IiIiIiCigysvL0atXL0yePBnFxcUYNGgQGjZsiHnz5qFDhw44evRocBrSqhUwYwawYwfQpo1pWZs2wM6dpuWtWgWnHaQoERERqFevHho0aKCKTDU1U0P/htnV/VNDmwHHdpMtdfwViYiIiIhItaZMmYItW7agS5cuOHjwIL766its3boV06dPx4ULF/DEE08EpyGpqcDo0YBVjScApt9Hjzatp1qpXr16HC5Wi1kHjtRW4J48w+AXEREREREFTEVFBWbNmgUAyMnJsRmSM2bMGLRt2xY///wztm/fLlcTKUAiIiLkbkLICg8Pl7sJHlFLNpJ1dpf10FedTidHcygAGPwiIiIiIqKA2bRpE65evYpmzZqhQ4cODuuHDh0KAFi2bFmwm0YB1qBBA7mbELLUUjheLTXUrGt+qaUGHDPUvMPgFxERERERBczu3bsBAB07dpRcb16+Z8+eoLWJgiPGfngp+Y31DJVKFh0dbflZyceDdYZXeHi4JbCUmJgoU4vcU0shfqVQRw4iERERERGpUn5+PgAgIyNDcr15+fHjxyXX6/V66PV6y++FhYV+biEFiloKhauRWobjWQe8UlJSZGyJa9aBJK1Wi4yMDJSWltpkgSlNYmIirl69CgCIj4+XuTXKx3cjIiIiIiIKmOLiYgDOsz7Mw4qKiook10+dOhUJCQmWW8OGDQPTUPIL899HyVk+atWoUSMA6qn3BZiCShqNBlqt1qben9LUrVsXiYmJluM3OjoaycnJNsMhlcb6NcYhxu4x84uIiIiIiBRr7NixGDNmjOX3wsJCBsAULCEhAfHx8YoOGqhVfHw8WrduLXczvKLVatGqVSu5m+GWOdtLTXQ6naVv+Xpzj8EvIiIiIiIKGHO2R2lpqeT6kpISAHA6vCgyMpKFnVWGF+JEwcHXmuc47JGIiIiIiALGPFTr5MmTkuvNyxs3bhy0NhERUe3C4BcREREREQVMu3btAAA7duyQXG9e3rZt26C1iYiIahcGv4iIiIiIKGC6deuGhIQEHDlyBLt27XJYv3DhQgDAwIEDg9wyIiKqLRj8IiIiIiKigImIiMDzzz8PAMjOzrbU+AKAd999F3v27EGPHj1w0003ydVEIiIKcSx4T0REREREAfX6669j1apV2Lx5M1q0aIHu3bvj+PHj2Lp1K1JTUzF37ly5m0hERCGMmV9ERERERBRQUVFRWLt2LcaNG4eYmBgsXboUx48fx4gRI7Bjxw40bdpU7iYSEVEI0wghhNyNIN8UFhYiISEBV69eRXx8vNzNISIiUgx+RhKFLr6+iYhqB3++3zPzi4iIiIiIiIiIQhaDX0REREREREREFLJY8F7FzCNWCwsLZW4JERGRspg/G1ndgSj08ByYiKh28Of5HINfKlZUVAQAaNiwocwtISIiUqaioiIkJCTI3Qwi8iOeAxMR1S7+OJ9jwXsVMxqNOH36NOrUqQONRuPVtp06dUJubm6N21BYWIiGDRvixIkTfis46q+21YZ9+bv/lfgcA7E/9r98+/Ln/tj/8u1LDe/927ZtQ1FRERo0aACtllUeiEKJ1Dmwt+8hNXkf8/X9SunbsU8csU8csU8csU8c+atPhBB+O59j5peKabVaZGRk+LStTqfz6+w48fHxftufP9tWG/YF+K//lfwcldy2UO9/Jf8tAfa/XPsClP3en5CQwIwvohAldQ7s63uIL+9jvj6WWrZjnzhinzhinzhinzjyR5/463yOX4XWUtnZ2XI3wSl/tq027MuflPwcldw2f1Hqc1Ty39KflNpnSt2Xv9WW50lEgRHM172vj6WW7YL5WGrZLpiPpZbtgvlYatkumI+llu2U9Fgc9kg1UlhYiISEBFy9etWv2QTkGfa/vNj/8mL/y4d9T0Rqx/cxR+wTR+wTR+wTR+wTR0rsE2Z+UY1ERkZiwoQJiIyMlLsptRL7X17sf3mx/+XDviciteP7mCP2iSP2iSP2iSP2iSMl9gkzv4iIiIiIiIiIKGQx84uIiIiIiIiIiEIWg19ERERERERERBSyGPwiIiIiIiIiIqKQxeAXOdWzZ09oNBqntxUrVkhuN3/+fHTu3BlxcXFISkpC//79sXnz5iC3PrSVlZVh/PjxyMzMRFRUFBo0aIAnnngCp06dkrtpIW/dunUuXxe33nqr021PnjyJkSNHokGDBoiKikJmZiYmTJiA8vLyID4D5SspKcFnn32GF154AbfccgsiIyOh0WgwceJEt9v60sd8Pdnytf9dvS40Go3TvwH7n4iklJaWYunSpXjyySfRsmVLREVFITY2Fu3atcOkSZNQXFzsdFtfzkU3bdqE/v37IykpCXFxcejcuTMWLFjgcptgf64rvU98/RyoiWD1SbDPTWpC6X0SysfJ/v378a9//Qt33HEHUlJSEB4ejvT0dAwePBgbNmxw2cZQPU587ZOAHCeCyIkePXoIAGLIkCFi+PDhDrc9e/Y4bDN69GgBQERHR4tBgwaJvn37irCwMKHT6cSSJUuC/yRCUFlZmbj11lsFAFG/fn0xbNgw0blzZwFApKamiiNHjsjdxJC2du1aAUA0a9ZM8nUxadIkye0OHTokUlJSBADRunVrMWzYMNG0aVMBQHTr1k2Ul5cH+Zko186dOwUAh9uECRNcbudLH/P15MjX/gcgYmNjJV8Xw4cPFxUVFQ7bsP+JyJnZs2db3n9uvPFG8cADD4i+ffuKOnXqCADihhtuEOfOnXPYzpdz0YULFwqdTic0Go3o0aOHGDJkiEhMTBQAxMsvvyy5jRyf60rvE18+B2oqWH0SzHOTmlJ6n4TycXLdddcJACIuLk707t1bDBs2TLRu3VoAEBqNRrz33nuS7Qvl48TXPgnEccLgFzllDn4dO3bMo/uvXLlSABDJycni4MGDluWbN28WERERIjExUVy5ciUwja1F/vGPfwgAokuXLqKoqMiyfPr06QKA6NGjh3yNqwXMwa/hw4d7tV23bt0EAPHiiy9allVWVor777/foxOF2uTw4cPiySefFB999JHYvn27mDRpkkd95Esf8/XkyNf+ByAaN27s1WOx/4nImfnz54tRo0aJvLw8m+WnT58WHTp0EADEQw89ZLPOl3PRS5cuifj4eAFALFq0yLL87Nmzonnz5gKAWLt2rUP75PhcV3qf+PI5UFPB6pNgnpvUlNL7JJSPkzvvvFMsWLBAlJWV2Sz/6KOPBACh0+nE77//7tC+UD5OfO2TQBwnDH6RU94Gv+6++24BQDJ6++KLLwoAYtq0af5tZC2j1+tFQkKCACB27NjhsL5t27YCgPj1119laF3t4Evwa+vWrQKAqFevnsM3N2fPnhXh4eGibt26orKy0s+tDQ1Tp051+8HvSx/z9eQZT/pfCO9PUtj/ROSrzZs3CwAiMjJS6PV6y3JfzkX/9a9/CQBi0KBBDtssXrxYABD33HOPzXIlfq7L3SdCyBPUcMWffWIvUOcmgSZ3nwhRu44Ta3369BEAxMSJE22W17bjxJqzPhEiMMcJa36RX5SVlWHNmjUAgKFDhzqsNy9btmxZUNsVajZt2oSrV6+iWbNm6NChg8N69rMyLV++HAAwcOBAREZG2qxLS0tD9+7dceXKFWzcuFGO5oUEX/qYryd5sf+JyFft2rUDAOj1ely6dAmA7+ei5s8PqW0GDBiAqKgorFq1yqa+jBI/1+XuEyXyZ5/4ItSPk1ARrD4xP87p06dtltfm48RZnwRKWFAehVRtzpw5uHTpErRaLTIzM3HfffehUaNGNvc5cOAA9Ho9UlNTkZGR4bCPjh07AgD27NkTlDaHqt27dwO41p/22M/Bc+jQIYwdOxaXLl1CSkoKbrvtNvTr1w9areN3Cp783dasWYM9e/agZ8+egWx2yPKlj/l68r+SkhK8+eabyM/PR0xMDDp06IDBgwcjLi7O4b7sfyLy1dGjRwEA4eHhSEpKAuD7uair96KIiAi0bt0av/76Kw4ePIi2bdu63ca8PNif63L3iZk3nwOB5s8+8UWoHyc1URuPE/PjpKen2yyvzceJsz4x8/dxwuAXuTVlyhSb31955RWMGzcO48aNsyzLz88HAMkXAgDExsYiMTERV65cQVFREerUqRO4Bocwd/1sXn78+PGgtam22rx5s8OsJm3atMGiRYvQokULm+X8uwWeL33Mv4v/Xbx4Ea+//rrNsjFjxuDTTz/FgAEDbJaz/4nIVzNnzgQA9OvXz5Ip4cu5aGFhIa5evepyu4yMDPz66684fvy4JdCjxPcvufvEzJvPgUDzV5/4KpSPk5qqbcfJkSNH8N133wEA7r33Xpt1tfU4cdUnZv4+TjjskZy6/fbb8dlnn+HIkSMoLS3FgQMH8OabbyIsLAzjx4+3vCgAWKZCjYmJcbq/2NhYAEBRUVFgGx7C3PUz+zjwEhIS8Ne//hVbtmzBpUuXcOnSJaxevRq33norfvvtN/Tp08dy0mjGv1vg+dLH/Lv41+OPP44VK1bg1KlTKC4uxs6dO/HYY4/h0qVLGDx4MHJzc23uz/4nIl98//33mDNnDsLDwzF58mTLcl/ORc3buNpODZ8fSugTwPvPgUDyZ5/4KpSPk5qobcdJVVUVRowYAb1ejwcffBA33XSTzfraeJy46xMgMMcJM7/IqUmTJtn8npmZib///e+4+eab0bdvX0ycOBGjRo1CdHS0TC0k8t7999+Pffv2ebXNggUL0LlzZwBAhw4dHOoT9erVCxs3bsQdd9yBDRs24IMPPsDYsWP91ma1qWkfU83I1f+ffvqpze/t27fHggUL0LBhQ/zzn//E66+/jh9//LFGj0FEtdv+/fvx6KOPQgiBd955x1IvpjZTUp8o5XNASX2iFErqk9p2nLz44ovYuHEjmjZtig8++CAgj+EvSuqTQBwnDH6R1/r06YObb74Zv/76K7Zu3YqePXtaxt2WlpY63a6kpAQAOOSxBtz1M/vYvWPHjuHAgQNebePquDbT6XR47bXXsGHDBvz44482wa/a9ncLVB+74ksfh+rfRY7+d+XVV1/Fv/71L6xbtw4VFRWIiIgAELr9T0SBcerUKfTr1w9XrlzBmDFjMHr0aJv1vpyLWteNKS0tRXx8vNttPHmsYL1/KalPXHH2ORAIgegTX4XycRIIoXicvPnmm/jwww+RlpaGH3/80VI/y5vHCrXjxJM+caUmxwmHPZJPzDWNzpw5AwCWAvgnT56UvH9JSQkKCgpQt25dXsjUgLt+Ni9v3Lhx0NqkNrt27YIQwqubp8Ul7V8XZrXt7xbIPnbGlz4O1b+LHP3vSkJCAurVq4eKigrLjEFA6PY/Efnf5cuX0adPHxw/fhwjR47EtGnTHO7jy7lofHw8EhISXG6n1M8PpfWJK84+B/wtUH3iq1A+TgIh1I6Tjz76CK+//joSEhKwYsUKNG/eXPJ+tek48bRPXKnJccLgF/nkypUrAK6N623ZsiUiIyNx4cIFnDp1yuH+O3bsAACHopjkHXPqqbk/7bGf5WX/ujDj3y3wfOlj/l2Cw2g0orCwEIDta4P9T0SeKC4uxt133428vDwMHjwYs2fPhkajcbifr+eirt6LKisrsXfvXkRFRSEzM9OjbVw9lr8osU9ccfY54E+B7hNfhPpx4m+hdJz897//RXZ2NmJiYrB8+XK0b9/eaZtqy3HiTZ+4UpPjhMEv8tqFCxewYcMGANemNI2OjkavXr0AAN98843DNgsXLgQADBw4MEitDE3dunVDQkICjhw5gl27djmsZz/La9GiRQAcpyo2z0aybNky6PV6m3Xnzp3Dhg0bULduXXTr1i04DQ1BvvQxX0/BsWLFCpSUlKBZs2Y2w2fY/0Tkjl6vx6BBg7Bt2zb07dsXX375JXQ6neR9fT0XNX9+mNdb++6771BeXo7evXsjKirKYRs5PteV2ieuOPsc8Jdg9IkvQv048bdQOU6+//57PP744wgLC8OSJUvc/n1rw3HibZ+4UqPjRBBJ2LRpk1iyZImoqqqyWX7s2DHRrVs3AUDce++9NutWrlwpAIjk5GRx8OBBy/LNmzeLyMhIkZiYKK5cuRKM5oe0f/zjHwKA6Nq1qyguLrYsnz59ugAgevToIV/jaoH33ntP5Ofn2ywzGo3io48+EmFhYUKj0Yhff/3VYTvz62b06NGWZZWVlWLw4MECgJgwYUKAW65eU6dO9aiPfOljvp7c86T/v/zyS7Ft2zaH5evWrRMNGjQQAMS7777rsJ79T0TOVFVVifvvv18AEN27dxclJSVut/HlXPTSpUsiPj5eABCLFi2yLD937pxo3ry5ACDWrl3r8FhyfK4ruU98/RyoqWD1ib1AnpvUlJL7JNSPk40bN4ro6GgRFhYmlixZ4nH7Qvk48aVPAnWcaIQQwrtwGdUG8+fPx8iRI5Geno6OHTsiMTERx48fx/bt21FeXo5WrVphzZo1qFevns12L730EmbOnImYmBjcddddqKiowMqVKyGEwMKFC3HffffJ84RCSHl5OXr27ImtW7eifv366N69O44fP46tW7ciNTUVW7ZsQdOmTeVuZshq0qQJTp48iY4dO+L6669HeXk5fvvtNxw7dgxarRYzZ87E888/77DdoUOH0KVLF1y6dAlt2rRBVlYWcnNzcfToUXTt2hVr1qxBZGSkDM9Ime6//35L7bTTp0/jxIkTuO6665CRkQEAqF+/PpYsWWKzjS99zNeTNG/7f8SIEfj000+RmZmJVq1aITw8HAcPHrRkdP3pT3/C559/Dq3WNuGc/U9EzsycORMvvfQSANN7krNv+KdNm4aUlBTL776ciy5atAjDhg2z1EBMTk7GqlWrUFBQgDFjxmD69OkO28jxua7kPvH1c6CmgtknwTo3qSkl90moHyd169ZFQUEBrr/+etx+++2Sj3HbbbfhqaeeslkWyseJL30SsOPE63AZ1Qp5eXni2WefFR07dhSpqakiLCxMJCQkiFtvvVVMnz5dlJaWOt123rx54qabbhIxMTEiMTFR9OvXT2zatCmIrQ99paWlYty4caJZs2YiIiJCpKenixEjRogTJ07I3bSQ9/7774t77rlHXH/99SI2NlZERESIxo0bi0cffVTyGwpr+fn5YsSIESI9PV1ERESI5s2bi3HjxomysrIgtV49GjduLAA4vTVu3FhyO1/6mK8nR972//fffy8eeeQRccMNN4jExEQRFhYm6tWrJ+6++27xzTffuHws9j8RSZkwYYLL9yHz7dixYw7b+nIuunHjRtGvXz+RmJgoYmJixM033yzmz5/vcptgf64ruU9q8jlQE8Hsk2Cem9SEkvsk1I8TTx5j+PDhktuG6nHiS58E6jhh5hcREREREREREYUsFrwnIiIiIiIiIqKQxeAXERERERERERGFLAa/iIiIiIiIiIgoZDH4RUREREREREREIYvBLyIiIiIiIiIiClkMfhERERERERERUchi8IuIiIiIiIiIiEIWg19ERERERERERBSyGPwiIiIiIiIiIgDAH3/8AY1GA41Gg/nz58vdHCK/YPCLiIiIiIiIar1169ZZgj6e3l566SW5m01EHmDwi4jIDyoqKtCiRQtoNBosXLhQ7ubIJjs7GxqNBsOHD5e7KURERERERAAY/CIiP/n5559tvgXbvHmz221cfbsWExODhg0b4p577sHcuXOh1+uD1i5fzJw5E4cPH0br1q0xZMiQgDyGGrz22muIiIjAZ599hu3bt8vdHCIiIiKfPPvss/jtt9/c3v72t7/J3VQi8kCY3A0gotDw6aef2vy+YMECdO3a1ef9lZWV4eTJkzh58iSWL1+Od999F9999x2aNGkia7ukFBUV4V//+hcA4PXXX4dGo/Hr/tWkUaNGGD58OGbPno1x48bh+++/l7tJRERERF6rV68eWrduLXcziMhPmPlFRDVWVlbmMNTv66+/9ipby/7btdWrV2PmzJnIyMgAAPz++++49957YTAYfGpXXFycT+3yxIcffohLly6hUaNGeOCBB/y6bzV6+eWXAQA//PADs7+IiIiIiEh2DH4RUY0tWbIERUVFAIAnn3wSAHDlyhUsW7bM432Yv10z33r16oUXX3wReXl5lmyv3377DUuWLPGpXe+//75P7XLHYDBg1qxZAICHHnoIWi3fVlu2bImOHTsCAP7973/L3BoiIiKi4GnSpAk0Gg1GjBgBAMjNzcVDDz2Ehg0bIioqCg0bNsTIkSOxf/9+j/a3bNkyDB06FBkZGYiMjERycjK6dOmCt956C8XFxR7tY+/evXjhhRfQpk0b1K1bF+Hh4UhPT0fv3r3x9ttv48yZM273sXLlSgwcOBDp6emIjIzE9ddfj2effRYnT570qA1EcuNVGhHV2IIFCwAAqampmDFjBhISEmyW10SdOnXw+uuvW35ftWqV1+1q27YtRo4ciZYtW/qtXWYrV67EiRMnAACPPPKI3/ardua++OabbywBSCIiIqLaZO7cuejatSv++9//4uTJk9Dr9Th58iTmz5+P9u3b45tvvnG6bXl5OQYPHox7770XixYtwqlTp1BRUYHLly9jy5YtGDt2LFq2bIldu3Y53YfBYMCYMWPQtm1bzJo1C3v37kVBQQGqqqpw7tw5rF69Gq+99hrGjh3r8nmMHTsWffr0wXfffYdz586hoqICf/zxBz766CN07NgR+/bt87WLiIKGwS8iqpEzZ85YAlIPPPAA4uLiMHToUADAihUrcOHChRo/Rps2bSw/mwNN3rTr0UcftfnfX+0CTMMoAaBFixY27bQ2ceJES8F9ACgsLMTEiRPRpk0bxMXFoV69eujfv79DMf7z58/j9ddfR6tWrRAbG4vk5GQMGjQIO3fudNmmvXv3YsqUKejbt6/lW8K4uDi0aNECw4cPx5YtW9w+r9OnT+Nvf/sbOnbsiISEBISHhyMtLQ1t2rTBQw89hPnz56OwsNDp9uai/6Wlpfj222/dPh4RERFRKNm1axeeeeYZ1KtXD//+97+xdetW/Pzzz3jttdcQGRkJvV6PRx55BL/++qvk9sOHD7eMeGjXrh0WLFiA3Nxc/Pjjjxg5ciQ0Gg1Onz6NO++8E6dOnZLcx6hRo/Dee+9BCIH69evjzTffxNq1a7Fjxw78+OOPmDx5Mtq1a+fyecyePRtvvfUWevTogS+++AK//vorVq1ahccffxwAcOHCBTzxxBM16CmiIBFERDXwzjvvCAACgNi4caMQQog1a9ZYls2cOdPptmvXrrXcb8KECU7vt3PnTsv9Bg0a5FW7tFqtOHnypBBCiKNHjwqNRuO2Xd5o0qSJACAee+wxp/eZMGGCpf35+fkiMzPT8rv1TafTia+//loIIcTu3bvFddddJ3m/yMhIsWbNGsnHsu5TV7e//e1vTtu7fv16ER8f73Yfy5Ytc9k36enpAoB4+OGHPehJIiIiInlZn0c9++yz4rfffnN7q6iosNlH48aNLfto3LixOHPmjMPjrFmzRoSFhQkAolOnTg7rv/vuO8s+7rzzTqHX6x3u83//93+W+wwbNsxh/bfffmtZ36VLF3HlyhWnzzs/P9/m92PHjtmc8z399NPCaDQ6bPfUU09Z7rNjxw6n+ydSAmZ+EVGNfPbZZwBM9Q3Msyj26NED1113HQD/DDG0TqX2dLZHc7t69uxpacv1119vaaM/2nXy5En88ccfAIBOnTp5tM0DDzyAkydPYuzYsfj555+Rm5uL9957D/Hx8TAYDHjyySdx7Ngx3HPPPSgrK8Obb76JjRs3YuvWrXjjjTcQEREBvV6PESNGoKKiwmH/VVVViI2NxbBhw/DRRx9h3bp12LFjB1asWIHp06ejcePGAIC33noL8+bNc9her9fjT3/6EwoLC1GnTh28+uqrlsL1v/zyC7744gs8//zzlj51pXPnzgCAn3/+2aO+ISIiIlKKDz/8EG3atHF7c5Z1BQDTp09Henq6w/I77rgDTz/9NABTTTD77K+cnBwAQHh4OObNm4eIiAiHfTz99NPo3bs3AGDx4sUOdbveeustAEBMTAwWLlyIxMREp+1s2LCh03X169fHv//9b8nZzF955RXLzxs2bHC6DyJFkDv6RkTqZZ2RNXbsWJt1L7/8smXd77//Lrm9J5lfVVVVokOHDpb7bdiwwat2zZ0712bdhx9+6LZdnvrqq688apd15ldkZKTYsmWLw32sv+FLTU0VKSkp4vDhww73y8nJsdxv8eLFDusvXLjg8ps9vV4v7rrrLsu3kVVVVTbrV69e7VFmV2Vlpbh69arT9UII8cYbb1j2dfbsWZf3JSIiIpKbpxn01rdjx47Z7MOc+VW3bl1RWVnp9LFyc3Mt+5g6dapleWVlpYiJiREAxIABA1y21/pc9IsvvrAsv3jxomW0w8iRI73uB+vMrxdeeMHlfePi4gQAMXr0aK8fhyiYmPlFRD6zzp6yL/Zu/bsvWVYXLlzAmjVr0KNHD0uNq6FDh+K2227zuF3R0dGW2lNmw4YNs3x7VtPsL+vZberVq+fRNi+99BJuueUWh+UDBgywZGVduHABkydPRrNmzRzuN3LkSERFRQGQ/oYtJSXF5Td7EREReOeddwAAx48fdyiSevbsWcvPt99+u9P9hIWFIT4+3ul6wLZPjh496vK+REREREoyYcIECCHc3pyNSujQoQPCwsKc7r99+/aWc9LffvvNsvzo0aMoLS0FAMlzRmvW6/fu3Wv5edeuXRBCAAC6d+/u+om6ccMNN7hcX7duXQDgBEekeAx+EZFPqqqq8MUXXwAwzabYqlUrm/UdOnTAjTfeCAD4/PPPYTQaXe7vjTfesBSF12g0qFevHu68805s2rQJMTExGDNmjOXxPG3XwIEDHQI0SUlJ6N+/v8ftcsW6aL75g9+dP/3pT07XtW3bFgCg0Wjw4IMPSt4nOjoaLVq0AOBZQEmv1yM/Px95eXnYu3cv9u7dazkZAoDdu3fb3L9+/fqWn6WGRXojKSnJ8rN1UI2IiIgo1Ln7YjQsLMxyrnT58mXLcuuf3e3Dekil9XYXL160/Gx9bueLmJgYl+u1WlNIwWAw1OhxiAKNwS8i8smPP/6Ic+fOAXDM+jIzLz958iTWrl3r82O1b98eL774IsLDw71ql3l2R3vm5TVtl/VJhqfBr8zMTKfrzBlbKSkpLvdnvp+zb9hKSkr+v737i6m6/uM4/uSvh2mtgbgdY8CsrOHBA5JwljiZZbEpKSRs5ZApbkWxLlzNSRdd2OCm5VwzpAWRMEUoSJE2cbkgMBElEq1mY1IpbY5CV8mRjvC7YHx/B+EczjlS6PH12Ni+O9/P93Pe33PF3p/35/2hpKQEq9XK3LlziYmJYcmSJUZvisTERGOs8z9HAKmpqSxatAgYq1JLTk6mpKSE9vb2KXuMueP8Dn///bdXz4qIiIjcy6bqkTUbc4jIGCW/RMQn41sGAwICePHFF6cc89JLL00a70pBQQE9PT309PTw7bff0tjYSF5eHoGBgZw8eZK0tLQJlVbTxRUREUF6evqUY9atW2ckkO5k6+P49kOAoaEhj55xt3o2vnJ2JytsfX19xMfHU1RUxLlz56Zdhbs97pCQEBobG42qvc7OToqKikhNTeWhhx4iPT2dAwcOeLS65zy3J4lLEREREX8xvhjrisPhMBZSnavlna+nm8O5st75ufnz5xvXtzfCF7lfKfklIl67fv06R44cAcYqhVydEON8umJ9fb3b6p8FCxZgsViwWCwkJCSwbt06KisrqaioAMaSOtu2bfM4rt9//53Q0NAJWynH/0wmE9euXfMoLnciIyONa+cqsNmUm5vLpUuXCAgIYOvWrTQ3N/Prr79it9sZGRlhdHR0QuLKeQvkuLi4OHp6emhoaGDr1q08+uijwFgy69ixY2zatImUlBSuXr3qNhbn38RdHzIRERERf9Pd3Y3D4XB5/7vvvjOq6i0Wi/H5okWLjIXQjo4Ot99x+vRp49p5jsTERKNqrLW11fvgRfyQkl8i4rXa2lrsdjvgesvjuPH7f/31F/X19V5/V15entG0/siRI5w4ccKjuDzla1wwMfk1ODjo0xwz6ccff6StrQ2AoqIiysvLWbNmDVFRUcyZM8f4J8iTRF1QUBAbNmygvLycn376if7+fioqKkhKSgLg7NmzvPzyy27ncP5NoqOjfX0tERERkXvOH3/8QWNjo8v74wu8AM8884xxHRwczKpVqwA4fvz4hAOWbvfRRx8Zz6SlpRmfh4eHGwvQtbW19Pf3+/QOIv5EyS8R8dr4VsGQkBCys7Pdjs3JyTFOuvF1i2FxcTFBQUHAWFJnurjMZjMHDx6c9i8qKuqO4oqPjzeuL1686NMcM+nChQvGtauG+QBnzpzxem6z2cyWLVv45ptvWLZsGQBHjx51u91z/DeZM2eOUT0mIiIicr/Yvn37lFsXW1pa+PDDDwFISkpi+fLlE+6/9tprAAwPD5Ofn88///wzaY6Kigqam5sByMrKmtTYfseOHQDcuHGD7Oxsrl+/7jJOdwk2EX/h+uxVEZEpXLp0ifb2dgDS09Mn9BeYyvz583nuuedoamrixIkTXLlyhYcfftir71y8eDE5OTkcPHiQjo4Ojh8/zpo1a1zG9cILL7g9VXHcqVOn2LNnj89xPfnkk5hMJux2O52dneTk5Hj1/ExzLq13t5Vz3759Pn9HSEgIq1atoqurC4fDwbVr1wgLC5tybGdnJzBWeq+eXyIiInIvuXr1KufPn592XFhYGI888sikz61WK99//z1JSUns3LmT5ORkbt68yRdffMHu3btxOBwEBwezd+/eSc+uXbuW7Oxs6urqaG5uxmazsX37dp544gkGBwepqakxKsfCw8N57733Js2RkZFBfn4+5eXlnDx5kri4OAoLC1mxYgUPPvggAwMDnDlzhkOHDmG1WqmsrPT+RxK5hyj5JSJe2b9/v9EnyrmhvTubNm2iqamJkZERqqurjZUobxQVFVFTU8Po6CjvvPPOpOSXc1wbN270aM6NGzeyZ88en+MKDQ0lJSWFlpaWCT0XZstjjz1mXFdWVmKz2SaNKS0t5fDhwy7n+PrrrzGbzS4rtYaHh2lpaQFg3rx5E7Z+Ort58ybnzp0D4Nlnn/X4HURERETuBqWlpZSWlk47zmq10t3dPenzhIQECgsLKSgooLCwcNL90NBQPvnkE1JSUqacd//+/TgcDhoaGujq6pryFPOFCxfS1NTkcgG3rKyMsLAw9u7dS39/v8sdFFar1c0bivgHJb9ExCtVVVXA2CmPN27coKamZtpnhoaGCAgIYHR0lKqqKp+SXxaLheeff57Dhw/T2tpKW1sbqampk+JasGABK1eu9GjOp556CrPZzG+//eZzXOvXrzeSX3/++ScPPPCA13PMlMTERCwWC+fPn6esrIzBwUFyc3Mxm81cvnyZ6upqPv30U1asWGFUyd3uyy+/ZNeuXaxcuZK1a9eydOlSIiMjGRoa4uLFi+zbt4+uri4A8vPzjS2tt2ttbTVK9DMzM/+dFxYRERG5i23btg2LxcLu3btpa2tjYGCAyMhInn76aXbs2EFcXJzLZ00mE/X19TQ2NlJZWcmpU6cYGBhg7ty5LF68mA0bNlBYWMi8efNczhEUFMT777/Pli1bKCsr46uvvuLKlSsMDw8TERHB0qVLSU9PJzc39994fZG7ipJfIuKx9vZ2ent7gbFTAvPz872e48KFC5w9e9ZonO6Nt956y6ha2rVrF8eOHZsUV2ZmJoGBnrUzDAwMJDMzkw8++MDnuDZv3szOnTux2+00NDSwefNmr56fSQEBAVRVVbF69WoGBwepra2ltrZ2wpj4+Hjq6upYuHChy3lGRkZoaWkxKrymsn79ekpKSlzeP3DgAABLliwhISHBuxcRERERmQVpaWlTnoR9J2w2G4cOHfL5+YyMDDIyMu4ohmXLllFWVubx+NjYWI9/h76+Ph+jEvlvqeG9iHjM18bwMzXP8uXLje2Ozc3NRk8p5/nGT4b0lPN4X+KKiIggKysL+H/CZzYlJCTQ3d3NK6+8QkxMDCEhIYSHh5OcnMy7777L6dOnJzVEdfbGG2/w2WefUVBQgM1mIzo6GpPJhMlkIjY2lpycHI4ePcrnn3/usteX3W43TtB89dVX/5X3FBERERER8VTA6EyntkVE7jMdHR3YbDaCgoLo7e0lJiZmtkOaVdXV1eTm5hIREUFfX5/bcnwRERERfxIbG8vPP/9MXl6emsiL3EVU+SUicodSUlLIysri1q1bbrcC3g9GRkYoLi4G4M0331TiS0REREREZp2SXyIiM6C4uJjg4GA+/vhjLl++PNvhzJq6ujp++OEHoqOjef3112c7HBERERERETW8FxGZCY8//jgVFRX09vbyyy+/EBUVNdshzYpbt27x9ttvs3r1apc9wURERERERP5L6vklIiIiIiIiIiJ+S9seRURERERERETEbyn5JSIiIiIiIiIifkvJLxERERERERER8VtKfomIiIiIiIiIiN9S8ktERERERERERPyWkl8iIiIiIiIiIuK3lPwSERERERERERG/peSXiIiIiIiIiIj4LSW/RERERERERETEbyn5JSIiIiIiIiIifut/9xNq7T2KWTkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -588,7 +589,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -606,7 +607,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -624,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": null, "metadata": { "tags": [] }, @@ -659,11 +660,8 @@ } ], "metadata": { - "interpreter": { - "hash": "e899b22145868d3cd465733d82c36c2ae3ac0d3591d6a0807ec2e5e577a9cf5c" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "codeastro", "language": "python", "name": "python3" }, From 960ae555a8905515a7b46bb62cf9f3bb87b56151 Mon Sep 17 00:00:00 2001 From: Aniruddh Date: Mon, 15 Jun 2026 20:12:55 -0700 Subject: [PATCH 35/43] add improvements to the tutorial and trimmed it down --- docs/tutorials/Nautilus_tutorial.ipynb | 400 +++++-------------------- 1 file changed, 75 insertions(+), 325 deletions(-) diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb index 80529fd1..d79b739f 100644 --- a/docs/tutorials/Nautilus_tutorial.ipynb +++ b/docs/tutorials/Nautilus_tutorial.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -74,8 +74,8 @@ " data_table, # the data you got previously (table)\n", " 1.22, # mass of the system (float)\n", " 56.95, # paralax (float)\n", - " 0, # mass err, default is 0 (int)\n", - " 0, # plx err, default is 0 (int) \n", + " 0, # mass err (int)\n", + " 0, # plx err (int) \n", " )" ] }, @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "metadata": { "tags": [] }, @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 23, "metadata": { "tags": [] }, @@ -111,16 +111,16 @@ " 95, # orbital fraction, how much of the orbit is covered (0-100%)\n", " 1.2, # mass of the system\n", " 60, # paralax\n", - " 0.1, # eccentricity, default is 0.5 (float)\n", - " np.pi/6, # inclination, default is π/4 (float)\n", - " unc=2, # uncertainty, default is 2 (int)\n", - " num_obs=30, # number of observations to be made, default is 4 (int)\n", + " 0.1, # eccentricity (float)\n", + " np.pi/6, # inclination (float)\n", + " unc=2, # uncertainty (int)\n", + " num_obs=30, # number of observations to be made (int)\n", ")" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "metadata": { "tags": [] }, @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "metadata": { "tags": [] }, @@ -149,25 +149,42 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "metadata": { "tags": [] }, "outputs": [], "source": [ - " mysampler = sampler.NautilusSampler(mySys)" + "mysampler = sampler.NautilusSampler(mySys)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Nice, now its time to run the sampler" + "Nice, now it's time to run the sampler\n", + "\n", + "A bit more on the hyper parameters\n", + "\n", + "Sample arguments-\n", + "n_networks: The number of neural networks used to determine the shape of shells. A greater number of networks. Greater number improves sampling efficiency and gives averaged shells from the networks, reducing effects from individual error but increased computational cost per iteration. \n", + "n_batch: Number of likelihood evaluations performed per sampling step. \n", + "\n", + "Run arguments-\n", + "f_live: The fraction of the evidence in the live set. This can be used to act as an ending point, larger values lead to faster convergence but may not converge fully.\n", + "n_eff: The total effective size of the sampler. Larger values produce higher quality posterior estimations but take longer to run.\n", + "\n", + "\n", + "n_live: Number of live points used in the sampling process. Greater n_live yeilds greater evidence estimation but increased run time and computational cost.\n", + "num_threads: Number of threads used in parallel, greater number increases speed.\n", + "n_update: Number of additions to the live set before recomputing the likelihood contour. Increased values give faster per-step computation but more infrequent updates.\n", + "verbose: Lets you choose wether or not to display live updates of the sampler.\n", + "savefile: The name for a file that you want to create / already exists to save nautilus progress to." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -177,22 +194,22 @@ "Starting the nautilus sampler...\n", "Please report issues at github.com/johannesulf/nautilus.\n", "Status | Bounds | Ellipses | Networks | Calls | f_live | N_eff | log Z \n", - "Finished | 52 | 1 | 4 | 71928 | N/A | 4316 | -157.59 \n" + "Finished | 47 | 1 | 8 | 89316 | N/A | 4584 | -148.95 \n" ] } ], "source": [ "sampler_arg = {\n", - " \"n_networks\": 4, # number of active networks you want, default is 4\n", - " \"n_batch\": None, # the number of likelyhood evaluations per step, default is none (int) \n", + " \"n_networks\": 4,\n", + " \"n_batch\": None, #(int) \n", " }\n", - "run_arg = {\"f_live\": 0.01, \"n_eff\": 1000} # f_live is the fraction of the evidence in the live set and n_eff is the total effective sample size\n", + "run_arg = {\"f_live\": 0.01, \"n_eff\": 1000} \n", "samples = mysampler.run_sampler(\n", - " n_live=500, # the number of live points you have, default is 2000 (int)\n", - " num_threads=12, # the number of threads you want to utilize, default is 1 (int)\n", - " n_update=None, # the number additions to the live set before a new bound is made, default is none (int)\n", - " verbose=True, # choose wether or not to see live updates of the sampler, default is false (bool)\n", - " savefile = None, # put the name for a file that you want to create / already exists here to save nautilus progress, default is none (str)\n", + " n_live=500, #(int)\n", + " num_threads=12, #(int)\n", + " n_update=None, #(int)\n", + " verbose=True, #(bool) \n", + " savefile = None, #(str)\n", " sampler_kwargs = sampler_arg,\n", " run_kwargs = run_arg\n", " )" @@ -202,132 +219,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Plotting ##\n", - "\n", - "Now that we can generate possible orbits for our system, we want to plot the data to interpret our results. Here we will go through a brief overview on ways to visualize your data within orbitize. For a more detailed guide on data visualization capabilities within orbitize, see the [Orbitize plotting tutorial](https://orbitize.readthedocs.io/en/latest/tutorials/Plotting_tutorial.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Histogram ###\n", + "## Plotting and results ##\n", "\n", - "One way to visualize our results is through histograms of our computed orbital parameters." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can effectively view outputs from by creating a histogram of a given orbit element to see its distribution of possible values. Our system.param_idx dictionary is useful here. We can use it to determine the index of a given orbit that corresponds to the orbital element we are interested in:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'sma1': np.int64(0),\n", - " 'ecc1': np.int64(1),\n", - " 'inc1': np.int64(2),\n", - " 'aop1': np.int64(3),\n", - " 'pan1': np.int64(4),\n", - " 'tau1': np.int64(5),\n", - " 'plx': np.int64(6),\n", - " 'mtot': np.int64(7)}" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mysampler.system.param_idx" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we want to plot the distribution of orbital semi-major axes (a) in our generated orbits, we would use the index dictionary `mysampler.system.param_idx` to index the semi-major axis element from each orbit:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sma = [x[mysampler.system.param_idx['sma1']] for x in samples] \n", - "\n", - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "plt.hist(sma, bins=30)\n", - "plt.xlabel('orbital semi-major axis [AU]')\n", - "plt.ylabel('occurrence')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can use this method to create histograms of any orbital element you are interested in:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ecc = [x[mysampler.system.param_idx['ecc1']] for x in samples]\n", - "i = [x[mysampler.system.param_idx['inc1']] for x in samples]\n", - "\n", - "plt.figure(figsize=(10,3))\n", - "plt.subplot(131)\n", - "plt.hist(sma, bins=30)\n", - "plt.xlabel('orbital semi-major axis [AU]')\n", - "plt.ylabel('occurrence')\n", - "\n", - "plt.subplot(132)\n", - "plt.hist(ecc, bins=30)\n", - "plt.xlabel('eccentricity [0,1]')\n", - "plt.ylabel('occurrence')\n", - "\n", - "plt.subplot(133)\n", - "plt.hist(i, bins=30)\n", - "plt.xlabel('inclination angle [rad]')\n", - "plt.ylabel('occurrence')\n", - "\n", - "plt.show()" + "For a more detailed guide on data visualization capabilities within orbitize, see the [Orbitize plotting tutorial](https://orbitize.readthedocs.io/en/latest/tutorials/Plotting_tutorial.html)." ] }, { @@ -340,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -360,24 +254,27 @@ "source": [ "What is the difference between post and weighted post?\n", "Weighted results are results that are well, weighted. They can be used in cornerplots for example, to get better convergence. There are cases where non weighted results are better or are the only type accepted.\n", + "Nautilus is able to construct a posterior by calculating their importance weights.\n", + "The main advantage of this being that more samples from the posterior can be used, in fact all the samples Nautilus generates can be used.\n", + "\n", + "myResults.weighted_post returns weighted posteriors if it exists, and unweighted if it does not, so you can still get the posterior from Nautilus without weights.\n", "\n", - "myResults.weighted_post returns weighted posteriors if it exists, and unweighted if it does not. \n", "myResults.post is always unweighted. The same goes for lnlike.\n", "Weight can be acquired from myResults.weight" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(1972, 8)" + "(1964, 8)" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -388,16 +285,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(71195, 8)" + "(67856, 8)" ] }, - "execution_count": 16, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -410,12 +307,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Incase you want more points than that of the unweighted results but fewer points than the weighted, you can use the downsample function." + "In case you want more points than that of the unweighted results but fewer points than the weighted, you can use the downsample function." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -424,16 +321,16 @@ "((150000, 8), (150000,))" ] }, - "execution_count": 17, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "#Samples from the posterior an amount of times. If the posterior is weighted, samples proportionally to weight to get an equal-weighted posterior.\n", + "#Samples from the posterior a number of times. If the posterior is weighted, samples proportionally to weight to get an equal-weighted posterior.\n", "post, lnlike = myResults.downsample(\n", " 150000, # amount\n", - " True # allow duplicates, default is true\n", + " True # allow duplicates\n", " )\n", "post.shape, lnlike.shape" ] @@ -443,34 +340,29 @@ "metadata": {}, "source": [ "You might be wondering what kind of cases you might want duplicates to be true, it would be when you want more points.\n", - "For example look at this error:" + "For example this would return an error:" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 18, "metadata": {}, "outputs": [ { - "ename": "ValueError", - "evalue": "Cannot take a larger sample than population when 'replace=False'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[46], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m post, lnlike \u001b[38;5;241m=\u001b[39m \u001b[43mmyResults\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdownsample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m250000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# amount\u001b[39;49;00m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# allow duplicates, default is true\u001b[39;49;00m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m post\u001b[38;5;241m.\u001b[39mshape, lnlike\u001b[38;5;241m.\u001b[39mshape\n", - "File \u001b[0;32m~/new/new/codeastro/orbitize/orbitize/results.py:85\u001b[0m, in \u001b[0;36mResults.downsample\u001b[0;34m(self, amount, duplicates)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdownsample\u001b[39m(\u001b[38;5;28mself\u001b[39m, amount, duplicates \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m 80\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 81\u001b[0m \u001b[38;5;124;03m Samples from the posterior an amount of times. If the posterior\u001b[39;00m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;124;03m is weighted, samples proportionally to weight to get an equal-weighted posterior.\u001b[39;00m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 85\u001b[0m indexes \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchoice\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweighted_post\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mamount\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mduplicates\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweighted_post[indexes], \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweighted_lnlike[indexes]\n", - "File \u001b[0;32mnumpy/random/mtrand.pyx:1020\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.choice\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: Cannot take a larger sample than population when 'replace=False'" + "name": "stdout", + "output_type": "stream", + "text": [ + "Downsampling error: Cannot take a larger sample than population when 'replace=False'\n" ] } ], "source": [ - "post, lnlike = myResults.downsample(\n", - " 250000, # amount\n", - " False # allow duplicates, default is true\n", - " )\n", - "post.shape, lnlike.shape" + "try:\n", + " post, lnlike = myResults.downsample(250000, duplicates=False)\n", + " print(post.shape, lnlike.shape)\n", + "\n", + "except ValueError as error:\n", + " print(f\"Downsampling error: {error}\")" ] }, { @@ -513,149 +405,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### A Note about Convergence\n", - "\n", - "Those of you with experience looking at corner plots will note that the result here does not look converged (i.e. we need more samples for our results to be statistically significant). Because this is a tutorial, we didn't want you to have to wait around for a while for the results to converge.\n", - "\n", - "Its recommended that the Nautilus sampler runs with 2000 live points for convergence. Increasing the number of live points past this does not have much of an effect on accuracy or time taken. \n", - "Furthermore for the number of networks, 4 networks are recommended and increasing the number of networks can increase accuracy but tends to make sampling take longer amounts of time." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Orbit Plot ###" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "What about if we want to see how the orbits look in the sky? Don't worry, the `Results` class has a command for that too! It's called `plot_orbits`. We can create a simple orbit plot by running the command as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1154: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " fig.tight_layout()\n", - "/home/wsl/new/new/codeastro/orbitize/orbitize/plot.py:1154: UserWarning: Tight layout not applied. tight_layout cannot make Axes width small enough to accommodate all Axes decorations\n", - " fig.tight_layout()\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "epochs = mySys.data_table['epoch']\n", - "\n", - "orbit_figure = mysampler.results.plot_orbits(\n", - " start_mjd=epochs[0] # Minimum MJD for colorbar (here we choose first data epoch)\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Saving and Loading Results ##\n", - "\n", - "Finally, we can save our generated orbits in a file that can be easily read for future use and analysis. Here we will walk through the steps of saving a set of orbits to a file in hdf5 format. The easiest way to do this is using ``orbitize.Results.save_results()``:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "mysampler.results.save_results('orbits.hdf5')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Alternatively, if you had given the option previously, you can use the file generated by nautilus that has all your orbits already saved.\n", - "\n", - "Now when you are ready to use your orbits data, it is easily accessible through the file created. One way to do this is to load the data into a new `results` object; in this way you can make use of the functions that we learn before, like `plot_corner` and `plot_orbits`. To do this, use the `results` module: " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import orbitize.results\n", - "loaded_results = orbitize.results.Results() # create a blank results object to load the data\n", - "loaded_results.load_results('orbits.hdf5')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Alternatively, you can directly access the saved data using the `h5py` module:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "orbits array dimensions: (7867, 8)\n", - "orbital elements for first orbit: [ 2.29155763 0.49614047 1.04955172 3.89938158 3.94543876 0.79254779\n", - " 60. 1.2 ]\n" - ] - } - ], - "source": [ - "import h5py\n", - "f = h5py.File('orbits.hdf5', 'r')\n", - "orbits = f['post']\n", - "\n", - "print('orbits array dimensions: ', orbits.shape)\n", - "print('orbital elements for first orbit: ', orbits[0])\n", - "\n", - "f.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And now we can easily work with the saved orbits that were generated by ``orbitize!`` Find out more about generating orbits in ``orbitize!`` with tutorials [here](https://orbitize.readthedocs.io/en/latest/tutorials.html)." + "Find out more about generating orbits in ``orbitize!`` with tutorials [here](https://orbitize.readthedocs.io/en/latest/tutorials.html)." ] } ], From 180517a67953df9d2b6d0d6ca8390e6d146fceaf Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 11:31:24 -0700 Subject: [PATCH 36/43] Clean and add tests for downsampled plot_corner --- orbitize/plot.py | 4 ++-- tests/test_mcmc.py | 1 + tests/test_nautilus.py | 16 ++++------------ 3 files changed, 7 insertions(+), 14 deletions(-) diff --git a/orbitize/plot.py b/orbitize/plot.py index 0332f92e..77976e67 100644 --- a/orbitize/plot.py +++ b/orbitize/plot.py @@ -127,7 +127,7 @@ def plot_corner(results, param_list=None, downsample=None, **corner_kwargs): else: fixed_indices.append(i) - if downsample: + if downsample is not None: post, _ = results.downsample(downsample) weights = None else: @@ -170,7 +170,7 @@ def plot_corner(results, param_list=None, downsample=None, **corner_kwargs): corner_kwargs["labels"] = reduced_labels_list - figure = corner.corner(samples, **corner_kwargs, weights=weights) + figure = corner.corner(samples, weights=weights, **corner_kwargs) return figure diff --git a/tests/test_mcmc.py b/tests/test_mcmc.py index 329434c2..3f85c3ed 100644 --- a/tests/test_mcmc.py +++ b/tests/test_mcmc.py @@ -96,6 +96,7 @@ def do_mcmc_runs(num_temps=0, num_threads=1, make_corner_plot=False): if make_corner_plot: assert myDriver.system.plx_err == 0 # (check that we're actually fixing at least one param: plx) plot_corner(new_sampler.results) + plot_corner(new_sampler.results, downsample=1000) # Test unweighted downsampling # clean up os.system(f'rm {output_filename} {output_filename_2}') diff --git a/tests/test_nautilus.py b/tests/test_nautilus.py index f268f64c..0da3921a 100644 --- a/tests/test_nautilus.py +++ b/tests/test_nautilus.py @@ -39,9 +39,7 @@ def test_nautilus_general(make_plot=False): mySys.sys_priors[lab["mtot"]] = mtot my_sampler = sampler.NautilusSampler(mySys) - my_sampler.run_sampler(n_live=800, n_update=None, verbose=True) - - print("Finished 1st Run!") + my_sampler.run_sampler(n_live=800, n_update=None, verbose=False) nautilus_eccentricities = my_sampler.results.post[:, lab["ecc1"]] assert np.mean(nautilus_eccentricities) == pytest.approx(0.1, abs=0.1) @@ -51,14 +49,8 @@ def test_nautilus_general(make_plot=False): if make_plot: myResults = my_sampler.results - myResults.plot_corner(param_list=["ecc1","inc1"]).savefig('nautilus_test_3.png') - print("Made A Plot") + myResults.plot_corner(param_list=["ecc1","inc1"]) # No downsampling + myResults.plot_corner(param_list=["ecc1","inc1"], downsample = 1000) # With downsampling if __name__ == "__main__": - test_nautilus_general() - - -# TO DO -# fewer live points -# verbose = false -# Test < 1min + test_nautilus_general(make_plot = True) From ac3de45bf80b8b93c49fe9d9ff4fa57c3d03e972 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 12:42:30 -0700 Subject: [PATCH 37/43] Remove extra end-to-end tests --- tests/end-to-end-tests/GJ504_OFTI.py | 74 ------------------------ tests/end-to-end-tests/hr8799e_naut.py | 78 -------------------------- 2 files changed, 152 deletions(-) delete mode 100644 tests/end-to-end-tests/GJ504_OFTI.py delete mode 100644 tests/end-to-end-tests/hr8799e_naut.py diff --git a/tests/end-to-end-tests/GJ504_OFTI.py b/tests/end-to-end-tests/GJ504_OFTI.py deleted file mode 100644 index 5694ad5f..00000000 --- a/tests/end-to-end-tests/GJ504_OFTI.py +++ /dev/null @@ -1,74 +0,0 @@ -import os -os.environ['OPENBLAS_NUM_THREADS'] = '1' -import matplotlib.pyplot as plt - -import orbitize - -# Based on driver.py - -import numpy as np -from orbitize import read_input, system, sampler, priors -import multiprocessing as mp -import orbitize -import time - -# System parameters -datafile = "GJ504.csv" -num_secondary_bodies = 1 -system_mass = 1.22 # Msol -plx = 56.95 # mas -mass_err = 0.08 # Msol -plx_err = 0.26 # mas - -# Sampler parameters -likelihood_func_name = "chi2_lnlike" -n_threads = mp.cpu_count() -total_orbits = 10000000 -prepared_samples = 10000 - -I = 1 - -results_file = f"GJ504_OFTI_{I}.hdf5" - -tau_ref_epoch = 50000 - - -# Read in data -data_table = read_input.read_file(orbitize.DATADIR + datafile) - -# Initialize System object which stores data & sets priors -my_system = system.System( - num_secondary_bodies, - data_table, - system_mass, - plx, - mass_err=mass_err, - plx_err=plx_err, - tau_ref_epoch=tau_ref_epoch, -) - -my_sampler = sampler.OFTI(my_system, likelihood_func_name) - -my_sampler.results.load_results(results_file) - -start = time.time() - -print(f"Running OFTI sampler with {n_threads} {total_orbits} {prepared_samples}") -# Run the sampler to compute some orbits, yeah! -my_sampler.run_sampler(total_orbits, prepared_samples, n_threads) - -end = time.time() -print(f"Processing time: {end} - {start} = {(end-start) / 60} minutes") - - -my_sampler.results.save_results(results_file) - -# import orbitize.results as results -# my_sampler.results = results.Results() -# my_sampler.results.load_results("hr8799e_gravity_chains.hdf5") - -# make corner plot -# fig = my_sampler.results.plot_corner() -# plt.savefig("", dpi=250) - -my_sampler.results.print_results() \ No newline at end of file diff --git a/tests/end-to-end-tests/hr8799e_naut.py b/tests/end-to-end-tests/hr8799e_naut.py deleted file mode 100644 index 3a89fefc..00000000 --- a/tests/end-to-end-tests/hr8799e_naut.py +++ /dev/null @@ -1,78 +0,0 @@ -import os -os.environ['OPENBLAS_NUM_THREADS'] = '1' -import matplotlib.pyplot as plt - -import orbitize - -# Based on driver.py - -import numpy as np -from orbitize import read_input, system, sampler, priors -import multiprocessing as mp -import orbitize -import time - -savedir = "" - -# System parameters -datafile = "hr8799e_1epochgravity.csv" -num_secondary_bodies = 1 -system_mass = 1.52 # Msol -plx = 24.2175 # mas -mass_err = 0.15 # Msol -plx_err = 0.0881 # mas - -# Sampler parameters -likelihood_func_name = "chi2_lnlike" -n_threads = mp.cpu_count() -n_live = 2000 -n_update = None -sampler_args = {"n_networks": 4} -run_args = {"f_live": 0.01, "n_eff": 10000} - -I = 1 - -naut_file = f"{savedir}hr8799e_naut_{I}.hdf5" - -results_file = f"{savedir}hr8799e_naut_results_{I}.hdf5" - -tau_ref_epoch = 50000 - - -# Read in data -data_table = read_input.read_file(datafile) - -# Initialize System object which stores data & sets priors -my_system = system.System( - num_secondary_bodies, - data_table, - system_mass, - plx, - mass_err=mass_err, - plx_err=plx_err, - tau_ref_epoch=tau_ref_epoch, -) - -my_sampler = sampler.NautilusSampler(my_system) - -print(f"Running {datafile} sampler {I} with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") -# Run the sampler to compute some orbits, yeah! -my_sampler.run_sampler(n_live, - n_update, - verbose=False, - num_threads=n_threads, - savefile=naut_file, - sampler_kwargs=sampler_args, - run_kwargs=run_args) - -end = time.time() -print(f"Processing time: {end} - {my_sampler.start} = {(end-my_sampler.start) / 60} minutes") - - -my_sampler.results.save_results(results_file) - -# make corner plot -# fig = my_sampler.results.plot_corner() -# plt.savefig(f"{savedir}hr8799e_naut_corner_{I}.png", dpi=250) - -my_sampler.results.print_results() \ No newline at end of file From 50f6b88dfde564ca5b4608b21403864ed2cc4ef6 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 12:43:04 -0700 Subject: [PATCH 38/43] Improve ptform and Nautilus sampler docstrings --- orbitize/sampler.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/orbitize/sampler.py b/orbitize/sampler.py index 16463ac7..7be67596 100644 --- a/orbitize/sampler.py +++ b/orbitize/sampler.py @@ -1318,11 +1318,14 @@ def ptform(self, u): Prior transform function. Args: - u (array of floats): list of samples with values 0 < u < 1. + u (np.array of floats): RxM array of uniform + samples with values 0 < u < 1, + where R is the number of parameters + and M is the number of orbits Returns: - numpy array of floats: u samples transformed to a chosen Prior - Class distribution. + numpy RxM array of floats: u samples transformed to + a chosen Prior Class distribution. """ utform = np.zeros(u.shape) for i in range(u.shape[0]): @@ -1697,7 +1700,7 @@ class NautilusSampler(BaseNestedSampler): orbits we need model predictions for. It returns ``clnlikes`` which is an array of length M, or it can be a single float if M = 1. - Thea McKenna, Sarah Blunt, & Lea Hirsch 2024 + Eshel Dror, Quinton Blackston, Aniruddh Chalagulla, & Niklas Naworal 2026 """ def __init__(self, system, @@ -1738,7 +1741,7 @@ def run_sampler( sampler_kwargs = {}, run_kwargs = {} ): - """Runs the nested sampler from the Dynesty package. + """Runs the nested sampler from the Nautilus package. Args: n_live (int): Number of live points. A larger numbers results From 58b135cac58c218d483f5ea18be534de82b3f5ef Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 13:03:06 -0700 Subject: [PATCH 39/43] Clean Nautilus end-to-end test --- tests/end-to-end-tests/GJ504_naut.py | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/tests/end-to-end-tests/GJ504_naut.py b/tests/end-to-end-tests/GJ504_naut.py index ad39075b..58948f9f 100644 --- a/tests/end-to-end-tests/GJ504_naut.py +++ b/tests/end-to-end-tests/GJ504_naut.py @@ -1,5 +1,3 @@ -import os -os.environ['OPENBLAS_NUM_THREADS'] = '1' import matplotlib.pyplot as plt import orbitize @@ -30,11 +28,9 @@ sampler_args = {"n_networks": 4} run_args = {"f_live": 0.01, "n_eff": 10000} -I = 1 +naut_file = f"{savedir}GJ504_naut.hdf5" -naut_file = f"{savedir}GJ504_naut_{I}.hdf5" - -results_file = f"{savedir}GJ504_results_{I}.hdf5" +results_file = f"{savedir}GJ504_results.hdf5" tau_ref_epoch = 50000 @@ -53,9 +49,9 @@ tau_ref_epoch=tau_ref_epoch, ) -my_sampler = sampler.NautilusSampler(my_system) +my_sampler = sampler.NautilusSampler(my_system, like=likelihood_func_name) -print(f"Running {datafile} sampler {I} with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") +print(f"Running {datafile} sampler with {n_threads} {n_live} {n_update} {sampler_args} {run_args}") # Run the sampler to compute some orbits, yeah! my_sampler.run_sampler(n_live, n_update, @@ -72,7 +68,7 @@ my_sampler.results.save_results(results_file) # make corner plot -# fig = my_sampler.results.plot_corner() -# plt.savefig(f"{savedir}GJ504_naut_corner_{I}.png", dpi=250) +fig = my_sampler.results.plot_corner(downsample=10000) +plt.savefig(f"{savedir}GJ504_naut_corner.png", dpi=250) my_sampler.results.print_results() \ No newline at end of file From 7a96491b4395634be1b5a9b0b7db63137d3d80e3 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 13:21:12 -0700 Subject: [PATCH 40/43] Fix downsampling for no lnlikes --- orbitize/results.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/orbitize/results.py b/orbitize/results.py index b55a4024..0d7533b1 100644 --- a/orbitize/results.py +++ b/orbitize/results.py @@ -118,6 +118,8 @@ def downsample(self, amount, duplicates=True): """ indexes = np.random.choice(len(self.weighted_post), amount, duplicates, self.weights) + if self.weighted_lnlike is None: + return self.weighted_post[indexes], None return self.weighted_post[indexes], self.weighted_lnlike[indexes] def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post=None, weighted_lnlike=None, lnweight=None): From 4c2a18c0fde45c5f8aeeea43c36e59f3c800641e Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 13:25:27 -0700 Subject: [PATCH 41/43] Add tests for downsampling and weighted results --- tests/test_results.py | 88 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 80 insertions(+), 8 deletions(-) diff --git a/tests/test_results.py b/tests/test_results.py index 0840a993..3f380f70 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -75,7 +75,7 @@ def simulate_orbit_sampling(n_sim_orbits): return sim_post -def test_init_and_add_samples(radec_input=False): +def test_init_and_add_samples(radec_input=False, weighted=False): """ Tests object creation and add_samples() with some simulated posterior samples, and returns results.Results object @@ -96,8 +96,18 @@ def test_init_and_add_samples(radec_input=False): n_orbit_draws1 = 1000 sim_post = simulate_orbit_sampling(n_orbit_draws1) sim_lnlike = np.random.uniform(size=n_orbit_draws1) - # Test adding samples - results_obj.add_samples(sim_post, sim_lnlike) # , labels=std_labels) + if weighted: + n_weighted_orbit_draws1 = 4000 + sim_weighted_post = simulate_orbit_sampling(n_weighted_orbit_draws1) + sim_weighted_lnlike = np.random.uniform(size=n_weighted_orbit_draws1) + sim_weight = np.random.uniform(size=n_weighted_orbit_draws1) + sim_lnweight = np.log(sim_weight / np.sum(sim_weight)) # Normalize + # Test adding samples + results_obj.add_samples(sim_post, sim_lnlike, weighted_post=sim_weighted_post, + weighted_lnlike=sim_weighted_lnlike, lnweight=sim_lnweight) + else: + # Test adding samples + results_obj.add_samples(sim_post, sim_lnlike) # , labels=std_labels) # Simulate some more sample draws n_orbit_draws2 = 2000 sim_post = simulate_orbit_sampling(n_orbit_draws2) @@ -108,6 +118,12 @@ def test_init_and_add_samples(radec_input=False): expected_length = n_orbit_draws1 + n_orbit_draws2 assert results_obj.post.shape == (expected_length, 8) assert results_obj.lnlike.shape == (expected_length,) + if weighted: + expected_length_weighted = n_weighted_orbit_draws1 + assert results_obj.weighted_post.shape == (expected_length_weighted, 8) + assert results_obj.weighted_lnlike.shape == (expected_length_weighted,) + assert results_obj.weights.shape == (expected_length_weighted,) + assert results_obj.tau_ref_epoch == 58849 assert results_obj.labels == std_labels @@ -132,8 +148,15 @@ def results_to_test(): n_orbit_draws2 = 2000 sim_post = simulate_orbit_sampling(n_orbit_draws2) sim_lnlike = np.random.uniform(size=n_orbit_draws2) - # Test adding more samples - results_obj.add_samples(sim_post, sim_lnlike) + # Simulate some weighted draws + n_weighted_orbit_draws = 4000 + sim_weighted_post = simulate_orbit_sampling(n_weighted_orbit_draws) + sim_weighted_lnlike = np.random.uniform(size=n_weighted_orbit_draws) + sim_weight = np.random.uniform(size=n_weighted_orbit_draws) + sim_lnweight = np.log(sim_weight / np.sum(sim_weight)) # Normalize + # Test adding weighted and more samples + results_obj.add_samples(sim_post, sim_lnlike, weighted_post=sim_weighted_post, + weighted_lnlike=sim_weighted_lnlike, lnweight=sim_lnweight) # Return object for testing return results_obj @@ -173,8 +196,11 @@ def test_save_and_load_results(results_to_test, has_lnlike=True): assert results_to_save.sampler_name == loaded_results.sampler_name assert results_to_save.version_number == loaded_results.version_number assert np.array_equal(results_to_save.post, loaded_results.post) + assert np.array_equal(results_to_save.weighted_post, loaded_results.weighted_post) + assert np.array_equal(results_to_save.lnweight, loaded_results.lnweight) if has_lnlike: assert np.array_equal(results_to_save.lnlike, loaded_results.lnlike) + assert np.array_equal(results_to_save.weighted_lnlike, loaded_results.weighted_lnlike) # Try to load the saved results again, this time appending loaded_results.load_results(save_filename, append=True) # Now check that the loaded results object has the expected size @@ -200,7 +226,8 @@ def test_save_and_load_results(results_to_test, has_lnlike=True): def test_plot_corner(results_to_test): """ Tests plot_corner() with plotting simulated posterior samples - for all 8 parameters and for just four selected parameters + for all 8 parameters, for just four selected parameters, + with fixed parameters, and downsampled """ Figure1 = results_to_test.plot_corner() @@ -213,10 +240,15 @@ def test_plot_corner(results_to_test): # test that fixing parameters doesn't crash corner plot code results_to_test.post[:, -1] = np.ones(len(results_to_test.post[:, -1])) Figure3 = results_to_test.plot_corner() + assert Figure3 is not None results_to_test.post[:, -1] = mass_vals - return Figure1, Figure2, Figure3 + Figure4 = results_to_test.plot_corner(downsample=1000) + assert Figure4 is not None + + + return Figure1, Figure2, Figure3, Figure4 def test_plot_orbits(results_to_test): @@ -245,6 +277,25 @@ def test_plot_orbits(results_to_test): assert Figure5 is not None return (Figure1, Figure2, Figure3, Figure4, Figure5) +def test_downsample(results_to_test): + """ + Test downsample() with simulated posterior samples + """ + size = results_to_test.weighted_post.shape[0] + post, lnlikes = results_to_test.downsample(size*2, duplicates=True) + assert post.shape[0] == size*2 + assert lnlikes.shape[0] == size*2 + post, lnlikes = results_to_test.downsample(size, duplicates=False) + assert post.shape[0] == size + assert lnlikes.shape[0] == size + try: + post, lnlikes = results_to_test.downsample(size+1, duplicates=False) + except ValueError: + pass # Expected error when taking too many samples without replacement + else: + assert False, "Expected ValueError for drawing more samples than possible without duplicates did not occur" + + def test_save_and_load_hipparcos_only(): """ @@ -339,17 +390,20 @@ def test_save_and_load_gaia_and_hipparcos(): test_save_and_load_hipparcos_only() test_save_and_load_gaia_and_hipparcos() + # Not weighted test_results = test_init_and_add_samples() test_results_printing(test_results) test_plot_long_periods(test_results) + test_downsample(test_results) + # TODO: Update failing test with radec_input=True test_results_radec = test_init_and_add_samples(radec_input=True) test_save_and_load_results(test_results, has_lnlike=True) test_save_and_load_results(test_results, has_lnlike=True) test_save_and_load_results(test_results, has_lnlike=False) test_save_and_load_results(test_results, has_lnlike=False) - test_corner_fig1, test_corner_fig2, test_corner_fig3 = test_plot_corner( + test_corner_fig1, test_corner_fig2, test_corner_fig3, test_corner_fig4 = test_plot_corner( test_results ) test_orbit_figs = test_plot_orbits(test_results) @@ -357,11 +411,29 @@ def test_save_and_load_gaia_and_hipparcos(): test_corner_fig1.savefig("test_corner1.png") test_corner_fig2.savefig("test_corner2.png") test_corner_fig3.savefig("test_corner3.png") + test_corner_fig4.savefig("test_corner4.png") test_orbit_figs[0].savefig("test_orbit1.png") test_orbit_figs[1].savefig("test_orbit2.png") test_orbit_figs[2].savefig("test_orbit3.png") test_orbit_figs[3].savefig("test_orbit4.png") test_orbit_figs[4].savefig("test_orbit5.png") + # Weighted + test_results_weighted = test_init_and_add_samples(weighted=True) + + test_results_printing(test_results_weighted) + test_downsample(test_results_weighted) + + test_save_and_load_results(test_results_weighted, has_lnlike=True) + test_save_and_load_results(test_results_weighted, has_lnlike=True) + test_save_and_load_results(test_results_weighted, has_lnlike=False) + test_save_and_load_results(test_results_weighted, has_lnlike=False) + test_corner_fig5, test_corner_fig6, test_corner_fig7, test_corner_fig8 = test_plot_corner( + test_results_weighted + ) + test_corner_fig5.savefig("test_corner5.png") + test_corner_fig6.savefig("test_corner6.png") + test_corner_fig7.savefig("test_corner7.png") + test_corner_fig8.savefig("test_corner8.png") # clean up os.system("rm test_*.png") From 4410b0dc64d3e523d5b2574e8d08b09da447ce6a Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Tue, 16 Jun 2026 15:38:54 -0700 Subject: [PATCH 42/43] Clean up tutorial --- docs/tutorials/Nautilus_tutorial.ipynb | 46 +++++++++++++------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb index d79b739f..a5129b5e 100644 --- a/docs/tutorials/Nautilus_tutorial.ipynb +++ b/docs/tutorials/Nautilus_tutorial.ipynb @@ -83,7 +83,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This is cool and all but if we run the sampler on this data, its going to take time. Im a tutorial we dont have time for that, instead lets generate some synthetic data with the `generate_synthetic_data()` function\n", + "This is cool and all but if we run the sampler on this data, it's going to take time. I'm a tutorial we don't have time for that, instead lets generate some synthetic data with the `generate_synthetic_data()` function\n", "\n", "Cool thing about this function is that it calculates the semi major axis for you" ] @@ -164,22 +164,23 @@ "source": [ "Nice, now it's time to run the sampler\n", "\n", - "A bit more on the hyper parameters\n", + "A bit more on the hyperparameters\n", "\n", - "Sample arguments-\n", - "n_networks: The number of neural networks used to determine the shape of shells. A greater number of networks. Greater number improves sampling efficiency and gives averaged shells from the networks, reducing effects from individual error but increased computational cost per iteration. \n", - "n_batch: Number of likelihood evaluations performed per sampling step. \n", + "Sampler arguments-\n", + "n_networks: The number of neural networks trained to determine the iso-likelihood shells at each iteration. The likelihood scores prediceted by the neural networks are averaged to determine if a point is included in a shell. A higher value of n_networks leads to greater sampling efficiency at the cost of higher overhead per iteration. Neural network training is not parallelized.\n", + "n_batch: The number of orbits evaluated in each iteration, must be a multiple of num_threads. Each thread evaluates a set of n_batch/num_threads orbits. Higher n_batch takes advantage of the vectorized prior transform to improve computation speed, at the cost of some extra likelihood evaluations being performed in each shell (i.e. if n_update is 2500 samples and n_batch is 1000 then 3000 samples would be taken).\n", "\n", "Run arguments-\n", - "f_live: The fraction of the evidence in the live set. This can be used to act as an ending point, larger values lead to faster convergence but may not converge fully.\n", - "n_eff: The total effective size of the sampler. Larger values produce higher quality posterior estimations but take longer to run.\n", + "f_live: The maximum fraction of the evidence left in the live set before switching from the exploration to the sampling phase. This can be used to act as an ending point for the exploration phase (when shells are created), larger values lead to faster convergence but may not converge fully.\n", + "n_eff: The total effective size of the sample. Larger values produce higher quality posterior estimations but take longer to run. Acts as the ending point of the sampling phase.\n", "\n", - "\n", - "n_live: Number of live points used in the sampling process. Greater n_live yeilds greater evidence estimation but increased run time and computational cost.\n", + "n_live: Number of live points used in the sampling process. Greater n_live yields better evidence estimation and shell accuracy but increased run time and computational cost.\n", "num_threads: Number of threads used in parallel, greater number increases speed.\n", - "n_update: Number of additions to the live set before recomputing the likelihood contour. Increased values give faster per-step computation but more infrequent updates.\n", + "n_update: Number of additions to the live set before creating a new shell. If None defaults to n_live. Greater n_update leads to better shell accuracy but increased run time.\n", "verbose: Lets you choose wether or not to display live updates of the sampler.\n", - "savefile: The name for a file that you want to create / already exists to save nautilus progress to." + "savefile: The name for a file that you want to save or resume nautilus progress to or from.\n", + "\n", + "See more on the possible hyperparameters in the [Nautilus docs](https://nautilus-sampler.readthedocs.io/en/latest/api_full.html)" ] }, { @@ -209,9 +210,9 @@ " num_threads=12, #(int)\n", " n_update=None, #(int)\n", " verbose=True, #(bool) \n", - " savefile = None, #(str)\n", - " sampler_kwargs = sampler_arg,\n", - " run_kwargs = run_arg\n", + " savefile=None, #(str)\n", + " sampler_kwargs=sampler_arg,\n", + " run_kwargs=run_arg\n", " )" ] }, @@ -253,13 +254,12 @@ "metadata": {}, "source": [ "What is the difference between post and weighted post?\n", - "Weighted results are results that are well, weighted. They can be used in cornerplots for example, to get better convergence. There are cases where non weighted results are better or are the only type accepted.\n", - "Nautilus is able to construct a posterior by calculating their importance weights.\n", - "The main advantage of this being that more samples from the posterior can be used, in fact all the samples Nautilus generates can be used.\n", + "Weighted results are all the points that have been sampled by Nautilus weighted by shell sampling density and likelihood. The main benefit of weighted results is that they contain all points instead of equal-weighted results which are downsampled from it with no duplicates. plot_corner is able to make use of the weighted results for better accuracy but plot_orbits is not and therefore defaults to the unweighted results.\n", "\n", "myResults.weighted_post returns weighted posteriors if it exists, and unweighted if it does not, so you can still get the posterior from Nautilus without weights.\n", + "myResults.weighted_lnlike functions similarly for getting the log-likelihoods\n", "\n", - "myResults.post is always unweighted. The same goes for lnlike.\n", + "myResults.post is always unweighted. The same goes for myResults.lnlike.\n", "Weight can be acquired from myResults.weight" ] }, @@ -307,7 +307,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In case you want more points than that of the unweighted results but fewer points than the weighted, you can use the downsample function." + "In case you want more points than that of the unweighted results but fewer points than the weighted, you can use the downsample function. Note that if you do not allow duplicates, you will not obtain a completely true posterior (especially if your `amount` approaches the weighted posterior size); if you want a true equal-weighted posterior without duplicates use myResults.post." ] }, { @@ -327,7 +327,7 @@ } ], "source": [ - "#Samples from the posterior a number of times. If the posterior is weighted, samples proportionally to weight to get an equal-weighted posterior.\n", + "# Samples from the posterior a number of times. If the posterior is weighted, samples proportionally to weight to get an equal-weighted posterior.\n", "post, lnlike = myResults.downsample(\n", " 150000, # amount\n", " True # allow duplicates\n", @@ -378,7 +378,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can now create a corner plot using the function `plot_corner` within the `Results` class. This function requires an input list of the parameters, in string format, that you wish to include in your corner plot. We can even plot all of the orbital parameters at once! As shown below:" + "We can now create a corner plot using the function `plot_corner` within the `Results` class. This function requires an input list of the parameters, in string format, that you wish to include in your corner plot. We can even plot all of the orbital parameters at once! You may wish to use the `downsample` keyword if you want a quick graph as the full weighted posteriors tend to take a while to plot. As shown below:" ] }, { @@ -411,7 +411,7 @@ ], "metadata": { "kernelspec": { - "display_name": "codeastro", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -425,7 +425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.20" + "version": "3.10.19" } }, "nbformat": 4, From 2d7181d50f3337c879f13b803cdf2f0e75612bf8 Mon Sep 17 00:00:00 2001 From: Eshel Dror Date: Sun, 21 Jun 2026 18:31:01 -0700 Subject: [PATCH 43/43] Generalize nautilus tutorial thread count --- docs/tutorials/Nautilus_tutorial.ipynb | 51 +++++++++++++------------- 1 file changed, 26 insertions(+), 25 deletions(-) diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb index a5129b5e..8f95425f 100644 --- a/docs/tutorials/Nautilus_tutorial.ipynb +++ b/docs/tutorials/Nautilus_tutorial.ipynb @@ -13,12 +13,13 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import orbitize\n", - "import numpy as np" + "import numpy as np\n", + "import multiprocessing as mp" ] }, { @@ -32,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 5, "metadata": { "tags": [] }, @@ -101,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, "metadata": { "tags": [] }, @@ -120,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 7, "metadata": { "tags": [] }, @@ -138,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 8, "metadata": { "tags": [] }, @@ -149,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 9, "metadata": { "tags": [] }, @@ -185,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -195,7 +196,7 @@ "Starting the nautilus sampler...\n", "Please report issues at github.com/johannesulf/nautilus.\n", "Status | Bounds | Ellipses | Networks | Calls | f_live | N_eff | log Z \n", - "Finished | 47 | 1 | 8 | 89316 | N/A | 4584 | -148.95 \n" + "Finished | 49 | 1 | 4 | 113100 | N/A | 4503 | -166.17 \n" ] } ], @@ -207,7 +208,7 @@ "run_arg = {\"f_live\": 0.01, \"n_eff\": 1000} \n", "samples = mysampler.run_sampler(\n", " n_live=500, #(int)\n", - " num_threads=12, #(int)\n", + " num_threads=mp.cpu_count(), #(int)\n", " n_update=None, #(int)\n", " verbose=True, #(bool) \n", " savefile=None, #(str)\n", @@ -235,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -265,16 +266,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(1964, 8)" + "(1954, 8)" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -285,16 +286,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(67856, 8)" + "(111635, 8)" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -312,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -321,7 +322,7 @@ "((150000, 8), (150000,))" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -345,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -383,12 +384,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ]