diff --git a/agnpy/emission_regions/__init__.py b/agnpy/emission_regions/__init__.py index f7c1919f..33b70cbd 100644 --- a/agnpy/emission_regions/__init__.py +++ b/agnpy/emission_regions/__init__.py @@ -1 +1,2 @@ from .blob import * +from .cone import * diff --git a/agnpy/emission_regions/cone.py b/agnpy/emission_regions/cone.py new file mode 100644 index 00000000..f7b50db2 --- /dev/null +++ b/agnpy/emission_regions/cone.py @@ -0,0 +1,277 @@ +""" This module describes a uniform conical jet emission region +responsible for the acceleration of particles to relativistic energies. +Besides physical parameters related to the emission region itself, +it contains the electron energy distributions""" + +import numbers +from typing import Iterable + +import matplotlib.pyplot as plt +from astropy.constants import c, sigma_T, m_e, e, mu0 +from scipy.sparse import diags +from matplotlib import cycler, rcParams +from agnpy.utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2 +import numpy as np +import astropy.units as u +from astropy.coordinates import Distance +from scipy.integrate import cumulative_trapezoid +from astropy.constants import c, sigma_T, m_e + +from .. import InterpolatedDistribution, ParticleDistribution +from agnpy.spectra.spectra import ExpCutoffPowerLaw +from ..spectra import PowerLaw +from ..utils.conversion import mec2, mpc2, B_to_cgs +from ..utils.numerical_methods import * + + + +class Cone: + r"""Uniform Conical Jet Model. + + **Note:** We will assume that the jet has an opening angle θ_{opening}, + initial radius R0 and length L, all defined in the centre of momentum + frame of the fluid. + + Parameters + ---------- + R_o : :class:`~astropy.units.Quantity` + Initial radius at the base of the cone + L : :class:`~astropy.units.Quantity` + Length of the Jet + theta : class:`~astropy.units.Quantity` + Opening angle of the cone + z : float + redshift of the source + delta_D : float + Doppler factor of the relativistic outflow + Gamma : float + Lorentz factor of the relativistic outflow + B : :class:`~astropy.units.Quantity` + magnetic field at the base of the cone + n_e : :class:`~agnpy.spectra.ParticleDistribution` + electron distribution contained in the blob + n_p : :class:`~agnpy.spectra.ParticleDistribution` + proton distribution contained in the blob + """ + +## Keeping the default parameters same as defined in Blob (CΟNFIRM FOR NEW PARAMETERS!!!!) + def __init__( + self, + L = 1e18 * u.cm, + R_o = 1e14 * u.cm, + B_o = 1 * u.G, + theta = 5 * u.deg, + z=0.033, + delta_D=10, + Gamma=10, + n_e : ParticleDistribution = PowerLaw(mass=m_e), + xi=1.0, + gamma_e_size=200, + x_size=100, + cosmology=None + ): + if not isinstance(delta_D, numbers.Number) or delta_D <= 0: + raise ValueError("delta_D must be a positive number") + + self.L = L.to("cm") + self.R_o = R_o + self.B_o = B_to_cgs(B_o) + self.theta = theta.to("rad") + self.z = z + # if the luminosity distance is not specified, it will be computed from z + self.d_L = Distance(z=self.z, cosmology=cosmology).cgs + self.delta_D = delta_D + self.Gamma = Gamma + self._n_e : ParticleDistribution = n_e + self.xi = xi + self.gamma_e_size = gamma_e_size + self.x_size = x_size + + @classmethod + def from_jet_power(cls, W_j, **kwargs ): + B = kwargs.get("B_o") + gamma = kwargs.get("Gamma") + u_B = ((B_to_cgs(B)**2)/(8*np.pi)).to('erg cm-3') + R_o_squared = (W_j)/(2*u_B*np.pi*(gamma**2)*c.cgs) + R_o = np.sqrt(R_o_squared).to('cm') + return cls( R_o=R_o , **kwargs) + +## 1. Jet Structure + @property + def V_c(self): + """Volume of the truncated cone.""" + R_L = self.R_o + self.L * np.tan(self.theta) + return 1/3 * (np.pi * self.L) * (self.R_o**2 + self.R_o*R_L + R_L**2) + + @property + def R_x(self): + """Radius of the cone as a function of distance from the base""" + return self.R_o + self.x * np.tan(self.theta) + + @property + def B_x(self): + """Magnetic field of the cone as a function of distance from the base""" + return self.B_o * (self.R_o / self.R_x) + + @property + def x_cc(self, x_min=0.01 * u.pc): + """Spatial grid""" + x_cc = np.logspace( + np.log10(x_min.to_value("pc")), + np.log10(self.L.to_value("pc")), + self.x_size + ) * u.pc + return x_cc.to('cm') + + @property + def x(self): + """Spatial grid modified for Chang and Cooper numerical scheme""" + return self.x_cc[1:] + + @property + def gamma_e_cc(self): + """Array of electrons Lorentz factors, to be used for integration in the + reference frame comoving with the emission region.""" + return np.logspace( + np.log10(self._n_e.gamma_min), np.log10(self._n_e.gamma_max), self.gamma_e_size + #gamma_max is computed through x_i ; based on Fermi 1st order acceleration coefficient + ) + + @property + def gamma_e(self): + """Array of electrons Lorentz factors modified for Chang and Cooper numerical method, + to be used for integration in the reference frame comoving with the emission region.""" + return self.gamma_e_cc[1:-1:2] + + @property + def gamma_e_external_frame(self): + """Array of electrons Lorentz factors, to be used for integration in the + reference frame external to the emission region.""" + return np.logspace(1, 9, self.gamma_e_size) + +## 3. Electron Properties: Number Density, Total Number, Energy Density, Total Energy + @property + def n_e_base(self): + """Electron distribution as obtained by agnpy.spectra, with modified normalization + imposed due to equipartition condition (check norm_equi) + units: cm-3 + """ + return self._n_e(self.gamma_e)*self.norm_equi*u.cm**-3 + + @property + def norm_equi(self): + """Modified normalization to convolve with input electron distribution + to impose equipartition. Obtained by equating magnetic energy density at the base to + electron energy density. + units: cm-3""" + e_energy_initial = mec2.to('eV') * np.trapz(self.gamma_e_cc * self._n_e(self.gamma_e_cc), self.gamma_e_cc) + e_energy_initial *= u.Unit('cm-3') + K_dash = ( (self.B_o ** 2) ) / (8 * np.pi * e_energy_initial ) + return K_dash.cgs + + @property + def N_e_xg(self): + """Solution to the Electron Evolution Equation using Chang and Cooper scheme. + Returns the number of electrons per cm """ + cc_solver = ChangCooperSolver( + gamma_e = self.gamma_e_cc, + x = self.x_cc, + R_o =self.R_o, + theta_open = self.theta, + n_e = self._n_e) + N_e_xg = cc_solver.run() + return N_e_xg*self.norm_equi + + @property + def N_e_gamma(self): + """Number of electrons as a function of gamma across the Jet""" + N_e_gamma = np.trapz(self.N_e_xg, self.x, axis=0) + return N_e_gamma + + @property + def N_e_x(self): + """Number of electrons per cm at position x along the jet axis""" + N_e_x = np.trapz( self.N_e_xg, self.gamma_e, axis=1) + return N_e_x + + @property + def U_e_x(self): + r"""Energy of electrons in a slice of width 1 cm """ + U_e_x = mec2.cgs * np.trapz(self.gamma_e[None,:] * self.N_e_xg, self.gamma_e, axis=1) + return U_e_x + + @property + def U_b_x(self): + r"""Energy of magnetic field in a slice of width 1 cm as a function of distance + from the base of the Jet + """ + return (np.pi * self.R_x**2 * np.power(self.B_x, 2) / (8 * np.pi)) + + @property + def W_e(self): + r"""Total energy of electrons""" + W_e = mec2.cgs * np.trapz(self.gamma_e * self.N_e_gamma, self.gamma_e) + return W_e + + @property + def N_e(self): + r"""Total Number of electrons in the Jet, + :math:`N_{\rm p}(\gamma') = V_{\rm b}\,n_{\rm p}(\gamma')`. + + Parameters + ---------- + gamma : :class:`~numpy.ndarray` + array of Lorentz factor over which to evaluate the number of electrons + """ + N_e = np.trapz(self.N_e_x, self.x) + return N_e + + @property + def Beta(self): + """Bulk Lorentz factor of the Cone.""" + return np.sqrt(1 - 1 / np.power(self.Gamma, 2)) + + @property + def mu_s(self): + """Cosine of the viewing angle from the jet axis to the observer.""" + return (1 - 1 / (self.Gamma * self.delta_D)) / self.Beta + + @property + def theta_s(self): + """Viewing angle from the jet axis to the observer.""" + return (np.arccos(self.mu_s) * u.rad).to("deg") + + def set_delta_D(self, Gamma, theta_s): + """Set the Doppler factor by specifying the bulk Lorentz factor of the + outflow and the viewing angle. + + Parameters + ---------- + Gamma : float + Lorentz factor of the relativistic outflow + theta_s : :class:`~astropy.units.Quantity` + viewing angle of the jet + """ + self.Gamma = Gamma + mu_s = np.cos(theta_s.to("rad").value) + self.delta_D = 1 / (self.Gamma * (1 - self.Beta * mu_s)) + + def __str__(self): + """Printable summary of the Conical Jet.""" + resume = ( + "* Conical emission region\n" + + f" - R_o (Radius at the base of the cone): {self.R_o.cgs:.2e}\n" + + f" - L (Length of the Jet): {self.L.cgs:.2e}\n" + + f" - θ (Opening Angle of the Conical Jet): {self.theta:.2e}\n" + + f" - V_c (Volume of the Cone): {self.V_c.cgs:.2e}\n" + + f" - z (source redshift): {self.z:.2f}\n" + + f" - d_L (source luminosity distance):{self.d_L.cgs:.2e}\n" + + f" - delta_D (blob Doppler factor): {self.delta_D:.2e}\n" + + f" - Gamma (Bulk Lorentz factor): {self.Gamma:.2e}\n" + + f" - Beta (Bulk relativistic velocity): {self.Beta:.2e}\n" + + f" - theta_s (jet viewing angle): {self.theta_s:.2e}\n" + + f" - B (Magnetic field at the base the jet): {self.B_o:.2e}\n" + + f" - xi (coefficient for 1st order Fermi acceleration) : {self.xi:.2e}\n" + ) + + \ No newline at end of file diff --git a/agnpy/synchrotron/BaseSynchrotron.py b/agnpy/synchrotron/BaseSynchrotron.py new file mode 100644 index 00000000..f66915b8 --- /dev/null +++ b/agnpy/synchrotron/BaseSynchrotron.py @@ -0,0 +1,478 @@ +import numpy as np +from agnpy.emission_regions import Cone, Blob +import astropy.units as u +from astropy.constants import e, h, c, m_e, sigma_T, mu0 +from ..utils.math import axes_reshaper, gamma_e_to_integrate +from ..utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2 +from ..radiative_process import RadiativeProcess +e = e.gauss + +# ============================================================ +# Utility Functions +# ============================================================ + +def nu_obs_to_nu_fluid(nu_obs, z, delta_D): + """Convert observed frequency to comoving (fluid) frame.""" + nu_fluid = nu_obs * (1+ z) / delta_D + return nu_fluid + +def nu_synch_peak(B, gamma, mass=m_e): + """Critical synchrotron frequency (Dermer 2009 Eq. 7.19).""" + B = B_to_cgs(B) + nu_peak = (3 * e * B / (4 * np.pi * mass * c)) * np.power(gamma, 2) + return nu_peak.to("Hz") + +def Z(eta): + """Synchrotron kernel approximation (Aharonian 2010, Eq. D7).""" + term_1_num = 1.808 * np.power(eta, 1 / 3) + term_1_denom = np.sqrt(1 + 3.4 * np.power(eta, 2 / 3)) + term_2_num = 1 + 2.21 * np.power(eta, 2 / 3) + 0.347 * np.power(eta, 4 / 3) + term_2_denom = 1 + 1.353 * np.power(eta, 2 / 3) + 0.217 * np.power(eta, 4 / 3) + return term_1_num / term_1_denom * term_2_num / term_2_denom * np.exp(-eta) + +def tau_to_attenuation(tau): + """Convert SSA optical depth → attenuation factor. + Eq. 7.122 in [DermerMenon2009]_.""" + u = 0.5 + np.exp(-tau) / tau - (1 - np.exp(-tau)) / np.power(tau, 2) + return np.where(tau < 1e-3, 1, 3 * u / tau) + +def epsilon_B(B): + r""":math:`\epsilon_B`, Eq. 7.21 [DermerMenon2009]_""" + return (B / B_cr).to_value("") + +def single_particle_synch_power(B_cgs, epsilon, gamma, mass=m_e): + """angle-averaged synchrotron power for a single particle of mass m_e, + to be folded with the electron distribution + """ + eta = calc_eta(B_cgs, epsilon, gamma, mass) + prefactor = np.sqrt(3) * np.power(e, 3) * B_cgs / h + return prefactor * Z(eta) + +def calc_eta(B_cgs, epsilon, gamma, mass=m_e): + """ratio of the frequency to the critical synchrotron frequency from + Eq. 7.34 in [DermerMenon2009]_, argument of R(x), + note B has to be in cgs Gauss units""" + eta = ( + 4 + * np.pi + * epsilon + * np.power(mass, 2) + * np.power(c, 3) + / (3 * e * B_cgs * h * np.power(gamma, 2)) + ) + return eta.value + +def eta(nu_fluid, nu_peak): + """Calculates ration of frequency to critical synchrotron frequency + for Conical Jet Model""" + eta = nu_fluid / nu_peak + return eta + +def P_sync( + nu_fluid, # Ratio b/w Observed Frequency Array and Critical Frequency + B_x, # magnetic field array along x (Quantity) + x, # spatial coordinate array (Quantity) + gamma_e, # Electron Lorentz factor array (ndarray) + N_e_xg, # electron distribution array shape (N_x, N_gamma) + integrator=np.trapz, + ): + + """ + Compute synchrotron emission for a conical jet. + + Parameters + ---------- + nu_fluid : array-like + Frequencies in the comoving (fluid) frame, shape (1,1,N_nu) + B_x : array-like + Magnetic field along the jet, shape (N_x,1,1) + x : array-like + Spatial coordinate along the jet (cm), shape (N_x,) + gamma_e : array-like + Electron Lorentz factors, shape (1,N_gamma,1) + N_e_xg : array-like + Electron distribution, shape (N_x,N_gamma,1) + + Returns + ------- + emission_x_nu : ndarray + Differential emissivity along the jet (before x-integration), + shape (N_x, N_nu) + kernel_Z : ndarray + Synchrotron kernel Z(η), shape (N_x, N_gamma, N_nu) + L_nu_fluid : Quantity + Total luminosity in fluid frame (integrated over x), [erg s⁻¹ Hz⁻¹] + + Notes + ----- + Implements Eq. 7.44 from Dermer (2009). + P_mu_fluid = ∫ dx [ √3 e^3 B(x) / (m_e c^2) ] ∫ d(gamma) N_e(gamma,x) Z(eta = mu/mu_c) + """ + + # Calculate Synchrotron Peak + nu_peak = nu_synch_peak(B_x, gamma_e) + #Calculate Eta + eta_ = eta(nu_fluid,nu_peak) + Z_eta = Z(eta_) + # --- integrate over gamma --- + gamma_integral = integrator( + B_x * N_e_xg * Z_eta, + gamma_e, + axis=1 + ) + # --- prefactor √3 e³ / (m c²) --- + prefactor = (np.sqrt(3) * (e)**3 / (mec2.cgs)).cgs + emission = prefactor * gamma_integral + P_synch = integrator(emission, x, axis=0) + return nu_peak, emission, Z_eta, P_synch.to("erg Hz-1 s-1") + + +# ============================================================ +# 🔹 Main Synchrotron Wrapper +# ============================================================ + +class Synchrotron(RadiativeProcess): + """Class for synchrotron radiation computation + + Parameters + ---------- + emitter : :class:`~agnpy.emission_region` + emitting region and electron distribution + ssa : bool + whether or not to consider synchrotron self absorption (SSA). + The absorption factor will be taken into account in + :func:`~agnpy.synchrotron.Synchrotron.com_sed_emissivity`, in order to be + propagated to :func:`~agnpy.synchrotron.Synchrotron.sed_luminosity` and + :func:`~agnpy.synchrotron.Synchrotron.sed_flux`. + integrator : func + function to be used for integration (default = `np.trapz`) + """ + def __init__(self, emitter, ssa=False, integrator=np.trapz): + self.ssa = ssa + self.integrator = integrator + if isinstance(emitter, Cone): + self._model = SynchrotronCone(emitter, ssa, integrator) + elif isinstance(emitter, Blob): + self._model = SynchrotronBlob(emitter, ssa, integrator) + + def __getattr__(self, name): + return getattr(self._model, name) + +# ============================================================ +# 🔹 Synchrotron Cone Model +# ============================================================ + +class SynchrotronCone(RadiativeProcess): + """ + Synchrotron emission from a conical jet. + + Produces: + - F_nu → observed flux density + - F_nu(x) → spatially resolved flux + - nuF_nu → SED + """ + + def __init__(self, emitter, ssa=False, integrator=np.trapz): + self.emitter = emitter + self.ssa = ssa + self.integrator = integrator + + def flux_obs(self, nu_obs): + """ + Compute observed flux density F_nu and spatial flux F_nu(x). + Returns + ------- + F_nu : Quantity (N_nu) + """ + self.nu_fluid = nu_obs * (1+ self.emitter.z) / self.emitter.delta_D + nu_fluid_reshaped = self.nu_fluid[None,None,:] + N_e_xg_reshaped = self.emitter.N_e_xg[:,:,None] + B_x_reshaped = self.emitter.B_x[:,None,None] #(N_x, 1) + gamma_e_reshaped = self.emitter.gamma_e[None,:,None] #(1, N_gamma) + nu_p, L_xv_fluid, self.Z_eta, L_v_fluid = P_sync(nu_fluid_reshaped, + B_x_reshaped, + self.emitter.x, + gamma_e_reshaped, + N_e_xg_reshaped, + integrator=np.trapz) #.value * (u.erg/(u.s * u.Hz)) + self.nu_p = nu_p + L_v_obs = L_v_fluid * self.emitter.delta_D**3 + L_xv_obs = L_xv_fluid * self.emitter.delta_D**3 + self.F_v_obs = L_v_obs / (4 * np.pi * np.power(self.emitter.d_L, 2)) + self.F_xv_obs = L_xv_obs / (4 * np.pi * np.power(self.emitter.d_L, 2)) + return self.F_v_obs + + def nu_peak(self): + return self.nu_p + +# ============================================================ +# SSA +# ============================================================ + + def evaluate_attenuation(self): + r""" + Compute SSA absorption coefficient kappa_nu(x) for a conical jet (vectorized over frequencies). + + Parameters + ---------- + nu_arr : ndarray + Array of frequencies (Hz), shape (N_nu,) + gamma_e : ndarray + Electron Lorentz factors, shape (Ngamma,) + N_e_xg : ndarray + Electron distribution, shape (Nx, Ngamma) + P_nu_gamma_x : ndarray + Single-electron power, shape (Nx, Ngamma, N_nu) + integrator : function + Numerical integrator (default np.trapz) + + Returns + ------- + kappa_nu : ndarray + SSA opacity along the jet, shape (Nx, N_nu) + + ::math:: + kappa_nu(x) = - frac{1}{8 \pi m_e nu^2} \int d\gamma \, \gamma^2 \, frac{\partial}{\partial \gamma} \left[ frac{N_e(\gamma, x) \, P(nu, \gamma, x)}{\gamma^2} \right] + """ + n_e_xg_reshaped = self.emitter.N_e_xg[:, :, None]/(np.pi * (self.emitter.R_x[:,None,None])**2) + gamma_e_reshaped = self.emitter.gamma_e[None,:, None] + prefactor = 1 / (8 * np.pi * m_e.cgs* self.nu_fluid[None, :]**2) + P_xgv = (np.sqrt(3) * (e)**3 * self.emitter.B_x[:, None,None] * self.Z_eta / (m_e.cgs * c.cgs**2)).cgs + integrand = np.gradient(P_xgv* n_e_xg_reshaped / gamma_e_reshaped**2, self.emitter.gamma_e, axis=1) + integrand *= gamma_e_reshaped**2 # multiply by γ^2 outside derivative + # integrate over gamma + self.kappa_xv = - prefactor * np.trapz(integrand , self.emitter.gamma_e, axis=1) + tau_nu = np.trapz(self.kappa_xv,self.emitter.x, axis=0) # optical depth along the jet + self.attenuation = tau_to_attenuation(tau_nu) # reduces flux + return self.attenuation # shape (N_nu) + + def sed_flux(self, nu_obs, ssa=False): + self.sed = self.F_v_obs * nu_obs + if ssa: + self.sed *= self.attenuation + return self.sed.to('erg cm-2 s-1') + + def sed_spatial(self, nu_obs, ssa=False): + self.sed_x = self.F_xv_obs * nu_obs + if ssa: + self.sed_x *= tau_to_attenuation(self.kappa_xv.cgs.value) + return self.sed_x.to('erg cm-3 s-1') + + def sed_peak_flux(self): + """#provided a grid of frequencies nu, returns the peak flux of the SED + """ + return self.sed.max() + + def sed_peak_nu(self,nu_obs): + """#provided a grid of frequencies nu, returns the frequency at which the + #SED peaks""" + idx_max = self.sed_flux(nu_obs).argmax() + return nu_obs[idx_max] + +class SynchrotronBlob(RadiativeProcess): + """Class for synchrotron radiation computation + + Parameters + ---------- + blob : :class:`~agnpy.emission_region.Blob` + emitting region and electron distribution + ssa : bool + whether or not to consider synchrotron self absorption (SSA). + The absorption factor will be taken into account in + :func:`~agnpy.synchrotron.Synchrotron.com_sed_emissivity`, in order to be + propagated to :func:`~agnpy.synchrotron.Synchrotron.sed_luminosity` and + :func:`~agnpy.synchrotron.Synchrotron.sed_flux`. + integrator : func + function to be used for integration (default = `np.trapz`) + """ + + def __init__(self, emitter, ssa=False, integrator=np.trapz): + self.blob = emitter + self.ssa = ssa + self.integrator = integrator + + def electron_energy_loss_rate(self, gamma): + fixed = self._electron_energy_loss_formula_prefactor() + return fixed * gamma ** 2 + + def _electron_energy_loss_formula_prefactor(self): + U_B = np.power(self.blob.B_cgs, 2) / (8 * np.pi) + return ((4 / 3) * sigma_T * c * U_B).to("erg/s") + + @staticmethod + def evaluate_tau_ssa( + nu, + z, + d_L, + delta_D, + B, + R_b, + n_e, + *args, + integrator=np.trapz, + gamma=gamma_e_to_integrate, + ): + """Computes the synchrotron self-absorption opacity for a general set + of model parameters, see :func:`~agnpy:synchrotron.Synchrotron.evaluate_sed_flux` + for parameters definition. Eq. before 7.122 in [DermerMenon2009]_.""" + # conversions + epsilon = nu_to_epsilon_prime(nu, z, delta_D, m = m_e) + B_cgs = B_to_cgs(B) + # multidimensional integration + _gamma, _epsilon = axes_reshaper(gamma, epsilon) + SSA_integrand = n_e.evaluate_SSA_integrand(_gamma, *args) + integrand = SSA_integrand * single_particle_synch_power(B_cgs, _epsilon, _gamma) + integral = integrator(integrand, gamma, axis=0) + prefactor_k_epsilon = ( + -1 / (8 * np.pi * m_e * np.power(epsilon, 2)) * np.power(lambda_c_e / c, 3) + ) + k_epsilon = (prefactor_k_epsilon * integral).to("cm-1") + return (2 * k_epsilon * R_b).to_value("") + + @staticmethod + def evaluate_sed_flux( + nu, + z, + d_L, + delta_D, + B, + R_b, + n_e, + *args, + ssa=False, + integrator=np.trapz, + gamma=gamma_e_to_integrate, + ): + r"""Evaluates the flux SED (:math:`\nu F_{\nu}`) due to synchrotron radiation, + for a general set of model parameters. Eq. 21 in [Finke2008]_. + + **Note** parameters after \*args need to be passed with a keyword + + Parameters + ---------- + nu : :class:`~astropy.units.Quantity` + array of frequencies, in Hz, to compute the sed + **note** these are observed frequencies (observer frame) + z : float + redshift of the source + d_L : :class:`~astropy.units.Quantity` + luminosity distance of the source + delta_D : float + Doppler factor of the relativistic outflow + B : :class:`~astropy.units.Quantity` + magnetic field in the blob + R_b : :class:`~astropy.units.Quantity` + size of the emitting region (spherical blob assumed) + n_e : :class:`~agnpy.spectra.ElectronDistribution` + electron energy distribution + \*args + parameters of the electron energy distribution (k_e, p, ...) + ssa : bool + whether to consider or not the self-absorption, default false + integrator : func + which function to use for integration, default `numpy.trapz` + gamma : :class:`~numpy.ndarray` + array of Lorentz factor over which to integrate the electron + distribution + + Returns + ------- + :class:`~astropy.units.Quantity` + array of the SED values corresponding to each frequency + """ + # conversions + epsilon = nu_to_epsilon_prime(nu, z, delta_D, m = m_e) + B_cgs = B_to_cgs(B) + # reshape for multidimensional integration + _gamma, _epsilon = axes_reshaper(gamma, epsilon) + V_b = 4 / 3 * np.pi * np.power(R_b, 3) + N_e = V_b * n_e.evaluate(_gamma, *args) + # fold the electron distribution with the synchrotron power + integrand = N_e * single_particle_synch_power(B_cgs, _epsilon, _gamma) + emissivity = integrator(integrand, gamma, axis=0).reshape(epsilon.shape) + prefactor = np.power(delta_D, 4) / (4 * np.pi * np.power(d_L, 2)) + sed = (prefactor * epsilon * emissivity).to("erg cm-2 s-1") + + if ssa: + tau = Synchrotron.evaluate_tau_ssa( + nu, + z, + d_L, + delta_D, + B, + R_b, + n_e, + *args, + integrator=integrator, + gamma=gamma, + ) + attenuation = tau_to_attenuation(tau) + sed *= attenuation + + return sed + + @staticmethod + def evaluate_sed_flux_delta_approx(nu, z, d_L, delta_D, B, R_b, n_e, *args): + """Synchrotron flux SED using the delta approximation for the + synchrotron radiation Eq. 7.70 [DermerMenon2009]_.""" + epsilon_prime = nu_to_epsilon_prime(nu, z, delta_D, m = m_e) + gamma_s = np.sqrt(epsilon_prime / epsilon_B(B)) + B_cgs = B_to_cgs(B) + U_B = np.power(B_cgs, 2) / (8 * np.pi) + V_b = 4 / 3 * np.pi * np.power(R_b, 3) + N_e = V_b * n_e.evaluate(gamma_s, *args) + prefactor = ( + np.power(delta_D, 4) * c * sigma_T * U_B / (6 * np.pi * np.power(d_L, 2)) + ) + value = prefactor * np.power(gamma_s, 3) * N_e + return value.to("erg cm-2 s-1") + + def sed_flux(self, nu): + r"""Evaluates the synchrotron flux SED for a Synchrotron object built + from a Blob.""" + return self.evaluate_sed_flux( + nu, + self.blob.z, + self.blob.d_L, + self.blob.delta_D, + self.blob.B, + self.blob.R_b, + self.blob.n_e, + *self.blob.n_e.parameters, + ssa=self.ssa, + integrator=self.integrator, + gamma=self.blob.gamma_e, + ) + + def sed_flux_delta_approx(self, nu): + """Evaluates the synchrotron flux SED using the delta approximation for + a Synchrotron object built from a blob.""" + return self.evaluate_sed_flux_delta_approx( + nu, + self.blob.z, + self.blob.d_L, + self.blob.delta_D, + self.blob.B, + self.blob.R_b, + self.blob.n_e, + *self.blob.n_e.parameters, + ) + + def sed_luminosity(self, nu): + r"""Evaluates the synchrotron luminosity SED + :math:`\nu L_{\nu} \, [\mathrm{erg}\,\mathrm{s}^{-1}]` + for a a Synchrotron object built from a blob.""" + sphere = 4 * np.pi * np.power(self.blob.d_L, 2) + return (sphere * self.sed_flux(nu)).to("erg s-1") + + def sed_peak_flux(self, nu): + """provided a grid of frequencies nu, returns the peak flux of the SED + """ + return self.sed_flux(nu).max() + + def sed_peak_nu(self, nu): + """provided a grid of frequencies nu, returns the frequency at which the + SED peaks + """ + idx_max = self.sed_flux(nu).argmax() + return nu[idx_max] \ No newline at end of file diff --git a/agnpy/synchrotron/__init__.py b/agnpy/synchrotron/__init__.py index 93b0629c..3035c043 100644 --- a/agnpy/synchrotron/__init__.py +++ b/agnpy/synchrotron/__init__.py @@ -1,2 +1,4 @@ -from .synchrotron import * +from .BaseSynchrotron import * from .proton_synchrotron import * + + diff --git a/agnpy/synchrotron/proton_synchrotron.py b/agnpy/synchrotron/proton_synchrotron.py index 4c0c5b6b..62521688 100644 --- a/agnpy/synchrotron/proton_synchrotron.py +++ b/agnpy/synchrotron/proton_synchrotron.py @@ -5,7 +5,7 @@ from ..utils.math import axes_reshaper, gamma_e_to_integrate from ..utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_p from ..radiative_process import RadiativeProcess -from .synchrotron import single_particle_synch_power, tau_to_attenuation +from .synchrotron_blob import single_particle_synch_power, tau_to_attenuation __all__ = ["ProtonSynchrotron"] diff --git a/agnpy/synchrotron/synchrotron.py b/agnpy/synchrotron/synchrotron_blob.py similarity index 98% rename from agnpy/synchrotron/synchrotron.py rename to agnpy/synchrotron/synchrotron_blob.py index 761da011..9da2ae8d 100644 --- a/agnpy/synchrotron/synchrotron.py +++ b/agnpy/synchrotron/synchrotron_blob.py @@ -68,7 +68,7 @@ def tau_to_attenuation(tau): return np.where(tau < 1e-3, 1, 3 * u / tau) -class Synchrotron(RadiativeProcess): +class SynchrotronBlob(RadiativeProcess): """Class for synchrotron radiation computation Parameters @@ -85,8 +85,8 @@ class Synchrotron(RadiativeProcess): function to be used for integration (default = `np.trapz`) """ - def __init__(self, blob, ssa=False, integrator=np.trapz): - self.blob = blob + def __init__(self, emitter, ssa=False, integrator=np.trapz): + self.blob = emitter self.ssa = ssa self.integrator = integrator @@ -275,3 +275,5 @@ def sed_peak_nu(self, nu): """ idx_max = self.sed_flux(nu).argmax() return nu[idx_max] + + diff --git a/agnpy/synchrotron/synchrotron_cone.py b/agnpy/synchrotron/synchrotron_cone.py new file mode 100644 index 00000000..568a8367 --- /dev/null +++ b/agnpy/synchrotron/synchrotron_cone.py @@ -0,0 +1,164 @@ + import numpy as np +import astropy.units as u +from astropy.constants import e, h, c, m_e, sigma_T, mu0 +from ..utils.math import axes_reshaper, gamma_e_to_integrate +from ..utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2 +from ..radiative_process import RadiativeProcess + +def Z(eta): + """Eq. 7.45 in [Dermer2009]_, angle-averaged integrand of the radiated power, the + approximation of this function, given in Eq. D7 of [Aharonian2010]_, is used. + """ + term_1_num = 1.808 * np.power(eta, 1 / 3) + term_1_denom = np.sqrt(1 + 3.4 * np.power(eta, 2 / 3)) + term_2_num = 1 + 2.21 * np.power(eta, 2 / 3) + 0.347 * np.power(eta, 4 / 3) + term_2_denom = 1 + 1.353 * np.power(eta, 2 / 3) + 0.217 * np.power(eta, 4 / 3) + return term_1_num / term_1_denom * term_2_num / term_2_denom * np.exp(-eta) + +class SynchrotronCone(Synchrotron): + """Class for synchrotron radiation computation + + Parameters + ---------- + emitter : :class:`~agnpy.emission_region` + emitting region and electron distribution + ssa : bool + whether or not to consider synchrotron self absorption (SSA). + The absorption factor will be taken into account in + :func:`~agnpy.synchrotron.Synchrotron.com_sed_emissivity`, in order to be + propagated to :func:`~agnpy.synchrotron.Synchrotron.sed_luminosity` and + :func:`~agnpy.synchrotron.Synchrotron.sed_flux`. + integrator : func + function to be used for integration (default = `np.trapz`) + """ + + def __init__(self, emitter, ssa=False, integrator=np.trapz): + self.emitter = emitter + self.ssa = ssa + self.integrator = integrator + + # Can be shifted to utility function? + def nu_obs_to_nu_fluid(self, nu_obs): + self.nu_fluid = nu_obs * (1+ self.emitter.z) / self.emitter.delta_D + return self.nu_fluid + + def flux_obs(self, nu_obs): + self.nu_fluid = nu_obs * (1+ self.emitter.z) / self.emitter.delta_D + B_x = self.emitter.B_x[:,None] #(N_x, 1) + gamma_e = self.emitter.gamma_e[None,:] #(1, N_gamma) + self.nu_peak = ((3 / 2) *(e.gauss.decompose() * B_x / (2 * np.pi * m_e.cgs * c.cgs)) * np.power(gamma_e, 2)).cgs.to('Hz') + nu_reshaped = self.nu_fluid[None, None, :].value # shape (1, 1, N_nu) + nu_reshaped_c = self.nu_peak[:, :, None].value # shape (N_x, N_gamma, 1) + self.eta = nu_reshaped / nu_reshaped_c + term_1_num = 1.808 * np.power(self.eta, 1 / 3) + term_1_denom = np.sqrt(1 + 3.4 * np.power(self.eta, 2 / 3)) + term_2_num = 1 + 2.21 * np.power(self.eta, 2 / 3) + 0.347 * np.power(self.eta, 4 / 3) + term_2_denom = 1 + 1.353 * np.power(self.eta, 2 / 3) + 0.217 * np.power(self.eta, 4 / 3) + self.Z_eta = term_1_num / term_1_denom * term_2_num / term_2_denom * np.exp(-self.eta) + self.L_v_fluid = self.P_sync(self.Z_eta, + self.emitter.B_x, + self.emitter.x, + self.emitter.gamma_e, + self.emitter.N_e_xg, + integrator=np.trapz ).value * (u.erg/(u.s * u.Hz)) + self.L_v_obs = self.L_v_fluid * self.emitter.delta_D**3 + self.F_v_obs = self.L_v_obs / (4 * np.pi * np.power(self.emitter.d_L, 2)) + return self.F_v_obs + + def tau_to_attenuation(self, tau): + """Converts the synchrotron self-absorption optical depth to an attenuation + Eq. 7.122 in [DermerMenon2009]_.""" + u = 1 / 2 + np.exp(-tau) / tau - (1 - np.exp(-tau)) / np.power(tau, 2) + return np.where(tau < 1e-3, 1, 3 * u / tau) + + def evaluate_attenuation(self): + """ + Compute SSA absorption coefficient kappa_nu(x) for a conical jet (vectorized over frequencies). + + Parameters + ---------- + nu_arr : ndarray + Array of frequencies (Hz), shape (N_nu,) + gamma_e : ndarray + Electron Lorentz factors, shape (Ngamma,) + N_e_xg : ndarray + Electron distribution, shape (Nx, Ngamma) + P_nu_gamma_x : ndarray + Single-electron power, shape (Nx, Ngamma, N_nu) + integrator : function + Numerical integrator (default np.trapz) + + Returns + ------- + kappa_nu : ndarray + SSA opacity along the jet, shape (Nx, N_nu) + + ::math:: + \kappa_\nu(x) = - \frac{1}{8 \pi m_e \nu^2} \int d\gamma \, \gamma^2 \, \frac{\partial}{\partial \gamma} \left[ \frac{N_e(\gamma, x) \, P(\nu, \gamma, x)}{\gamma^2} \right] + """ + N_e_reshaped = self.emitter.N_e_xg[:, :, None]/(np.pi * (self.emitter.R_x[:,None,None])**2) + prefactor = 1 / (8 * np.pi * m_e.cgs* self.nu_fluid[None, :]**2) + integrand = np.gradient( N_e_reshaped / self.emitter.gamma_e[None, :, None]**2, self.emitter.gamma_e, axis=1) + integrand *= self.emitter.gamma_e[None, :, None]**2 # multiply by γ^2 outside derivative + P_xgv = (np.sqrt(3) * (e.gauss)**3 * self.emitter.B_x[:, None,None] * self.Z_eta / (m_e.cgs * c.cgs**2)).cgs + # integrate over gamma + kappa_xv = - prefactor * np.trapz(integrand * P_xgv, self.emitter.gamma_e, axis=1) + tau_nu = np.trapz(kappa_xv, self.emitter.x, axis=0) # optical depth along the jet + self.attenuation = self.tau_to_attenuation(tau_nu) # reduces flux + return self.attenuation # shape (N_nu) + + def sed_flux(self, nu_obs, ssa=False): + self.sed = self.F_v_obs * nu_obs + if ssa: + self.sed *= self.attenuation + return self.sed.to('erg cm-2 s-1') + + @staticmethod + def P_sync( + Z_eta, # Ratio b/w Observed Frequency Array and Critical Frequency + B_x, # magnetic field array along x (Quantity) + x, # spatial coordinate array (Quantity) + gamma_e, # Electron Lorentz factor array (ndarray) + N_e_xg, # electron distribution array shape (N_x, N_gamma) + integrator=np.trapz, + ): + """ + Synchrotron Power of a conical jet (erg s-1 Hz-1). + + Implements: + P_mu_fluid = ∫ dx [ √3 e^3 B(x) / (m_e c^2) ] ∫ d(gamma) N_e(gamma,x) Z(eta = mu/mu_c) + """ + # --- compute R(eta) --- + R_eta = Z_eta # (N_x, N_gamma, N_nu) + # --- reshape electron distribution --- + n_reshaped = N_e_xg[:, :, None] # (N_x, N_gamma, 1) + # --- integrate over gamma --- + gamma_integral = integrator( + n_reshaped * R_eta, + gamma_e, + axis=1 + ) # (N_x, N_nu) + # --- prefactor √3 e³ B / (m c²) --- + prefactor = (np.sqrt(3) * (e.gauss)**3 * B_x[:, None] / (mec2.cgs)).cgs + emission = prefactor * gamma_integral # (N_x, N_nu) + P_synch = integrator(emission, x, axis=0) + return P_synch.to("erg Hz-1 s-1") + + def tot_power_synch(self, nu_obs): + P_tot = np.trapz(self.P_sync, nu_obs) + return P_tot.to("erg s-1") + +""" + def sed_peak_flux(self, nu): +"""#provided a grid of frequencies nu, returns the peak flux of the SED +""" + return self.sed_flux(nu).max() + + def sed_peak_nu(self, nu): + """#provided a grid of frequencies nu, returns the frequency at which the + #SED peaks +""" + idx_max = self.sed_flux(nu).argmax() + return nu[idx_max] + +""" \ No newline at end of file diff --git a/agnpy/utils/numerical_methods.py b/agnpy/utils/numerical_methods.py new file mode 100644 index 00000000..085e7d3a --- /dev/null +++ b/agnpy/utils/numerical_methods.py @@ -0,0 +1,86 @@ +import numpy as np +import astropy.units as u +import astropy.constants as const +import matplotlib.pyplot as plt +from astropy.constants import c, sigma_T, m_e, e, mu0 +from scipy.sparse import diags +from matplotlib import cycler, rcParams +from agnpy.utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2 + +def gamma_loss(gamma): + B = 0.363 * u.G + u_B = ((B_to_cgs(B)**2)/(8*np.pi)).to('erg cm-3') + prefactor = (4 * c.cgs * sigma_T.cgs) / (3 * m_e.cgs * c.cgs * c.cgs ) + value = prefactor * (u_B) * np.power(gamma, 2) + return -value.to("s-1") + +class ChangCooperSolver: + def __init__( + self, + gamma_e, + x, + R_o, + theta_open, + n_e + + ): + """class implementing the Chang and Cooper scheme in Chaiberge and Ghisellini (1998): + + Parameters + ---------- + gamma_min : float + minimum Lorentz factor of the electorn distribution + gamma_max : float + maximum Lorentz factor of the electron distribution + n_gamma : int + number of steps in the Lorentz factor grid + t_max_ev : `~astropy.Units.Quantity` + maximum time of the evolution + n_t : int + number of time steps + t_max_inj : `~astropy.Units.Quantity` + maximum time of injection + t_esc : `~astropy.Units.Quantity` + escape time + injection_dict : dict + dictionary with injection specifications (spectrum and maximum injection time) + """ + self.R_o = R_o + self.theta_open = theta_open + _gamma = gamma_e + # $\gamma_{i \pm 1/2}$ in Chiaberge et al. (1998) + self.gamma_midpts = _gamma[::2] + # $\delta gamma_i$ in Chiaberge et al. (1998) + self.delta_gamma = self.gamma_midpts[:-1] - self.gamma_midpts[1:] + # $\gamma_i$ in Chiaberge et al. (1998) + self.gamma = _gamma[1:-1:2] + self.n_e = n_e + self.x = x.to('cm') + self.t = x/c.cgs + + @property + def gamma_dot_midpts(self): + return gamma_loss(self.gamma_midpts) + + def run(self): + """solve the temporal evolution, return the result at each step""" + solutions = dict() + N_prev = self.n_e(self.gamma) + for i in range(len(self.t) - 1): + elapsed_time = self.t[i] + dt = (self.t[i+1] - self.t[i]).to('s') + loss_term = (dt * self.gamma_dot_midpts[:-1]).decompose().value / self.delta_gamma + V2 = 1 + loss_term + V3 = -(dt * self.gamma_dot_midpts[1:]).decompose().value / self.delta_gamma + cc_matrix = diags([V2, V3], offsets=[0, 1]).toarray() + N_next = np.linalg.solve(cc_matrix, N_prev) + R_next = self.R_o + c.cgs*self.t[i+1]*np.tan(self.theta_open) + area_slice = np.pi * R_next**2 + solutions[f"{elapsed_time}"] = N_next * u.Unit("cm-3") *area_slice + N_prev = N_next + N_e_tg_list = [] + for key in solutions: + N_e_tg_list.append(solutions[key]) + N_e_xg = u.Quantity(N_e_tg_list) + return N_e_xg + diff --git a/electron_evolution.ipynb b/electron_evolution.ipynb new file mode 100644 index 00000000..452e5086 --- /dev/null +++ b/electron_evolution.ipynb @@ -0,0 +1,1281 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "28e94ed1", + "metadata": {}, + "outputs": [], + "source": [ + "from agnpy.emission_regions import Cone\n", + "import astropy.units as u\n", + "from agnpy.spectra import ParticleDistribution\n", + "from agnpy.utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2\n", + "from agnpy.spectra.spectra import ExpCutoffPowerLaw\n", + "from agnpy.synchrotron import *\n", + "from scipy.interpolate import interp1d\n", + "from scipy.integrate import cumulative_trapezoid\n", + "from agnpy.synchrotron.BaseSynchrotron import Synchrotron\n", + "import numpy as np\n", + "from astropy.constants import c, sigma_T, m_e, e, mu0\n", + "#e = e.gauss\n", + "mec2 = mec2.to('eV')\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "740724fb", + "metadata": {}, + "source": [ + "*Parameters used in Potter and Cotter to fit the BL Lac (Table 1)*" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a6934e81", + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters used in Table 1 of Potter and Cotter; Fitting BL Lac (abdo et al. 2011)\n", + "z=0.0686\n", + "B_o = (3.63 * 1e-5 * u.T).to(u.G)\n", + "u_B = ((B_to_cgs(B_o)**2)/(8*np.pi)).to('erg cm-3')\n", + "R_o = 7.32 * 1e15 * u.cm\n", + "W_j = 7.63 * 1e36* u.W\n", + "L = (100 * u.pc)\n", + "theta_open = 9.7 * u.deg\n", + "Gamma = 12\n", + "theta_s = 2 * u.deg\n", + "A_equi = 1.0\n", + "# Electron Distribution imposed by Potter and Cotter\n", + "p = 2\n", + "gamma_minimum = (5.11 * 1e6 * u.eV / mec2.to(\"eV\")).value\n", + "gamma_c = (5.6 * 1e9 * u.eV / mec2.to(\"eV\")).value\n", + "n_e = ExpCutoffPowerLaw(k = 1 , mass=m_e, p=p, gamma_min = 0.1*gamma_minimum, gamma_max= 100*gamma_c, gamma_c= gamma_c )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "26db094b", + "metadata": {}, + "outputs": [], + "source": [ + "jet = Cone.from_jet_power(W_j = W_j , B_o = B_o , L = L, n_e = n_e, theta = theta_open, Gamma=Gamma,x_size=500,gamma_e_size=1000, z =z)\n", + "jet.set_delta_D(Gamma, theta_s)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "19607d77", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 1, sharex=True)\n", + "ax[0].semilogx(\n", + " jet.x.to_value(\"pc\"),\n", + " jet.R_x.to_value(\"pc\"),\n", + " marker=\".\",\n", + " color=\"C0\"\n", + ")\n", + "ax[0].axhline(\n", + " jet.R_o.to_value(\"pc\"),\n", + " ls=\"--\",\n", + " color=\"crimson\"\n", + ")\n", + "ax[0].set_xlabel(\"x / pc\")\n", + "ax[0].set_ylabel(\"R / pc\")\n", + "\n", + "ax[1].semilogx(\n", + " jet.x.to_value(\"pc\"),\n", + " jet.B_x,\n", + " marker=\".\",\n", + " color=\"C0\"\n", + ")\n", + "ax[1].axhline(\n", + " jet.B_o.value,\n", + " ls=\"--\",\n", + " color=\"crimson\"\n", + ")\n", + "ax[1].set_xlabel(\"x / pc\")\n", + "ax[1].set_ylabel(\"B / G\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "b4998849", + "metadata": {}, + "source": [ + "# Plots " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "239e39d6", + "metadata": {}, + "outputs": [], + "source": [ + "coordinates = [\n", + " (585945.3915069195, 6.65905647933771e+45),\n", + " (1180320.6356517298, 3.6753441641809446e+45),\n", + " (2421029.04673618, 1.8950291465743076e+45),\n", + " (5861381.645140285, 8.435148160601475e+44),\n", + " (14454397.70745931, 3.481142923888426e+44),\n", + " (23768402.866248783, 2.075324880373661e+44),\n", + " (46989410.860521704, 1.1534180805525196e+44),\n", + " (147231250.24327165, 3.8169973137017866e+43),\n", + " (325087297.38543606, 1.693846972334023e+43),\n", + " (831763771.1026742, 6.485157528062233e+42),\n", + " (1614358556.8264935, 2.865619626947542e+42),\n", + " (3076096814.7407174, 1.1725707943387419e+42),\n", + " (5445026528.424242, 4.4349366153056454e+41),\n", + " (10964781961.43192, 7.858944800779638e+40),\n", + " (18030177408.59577, 1.2817831835790027e+40),\n", + " (28575905433.749672, 1.2244668158998756e+39),\n", + " (39084089579.24041, 1.164019524379192e+38),\n", + " (59703528658.38415, 2.0753248803736612e+36),\n", + " (89536476554.96011, 4.373153302721358e+33),\n", + " (109647819614.31963, 7.740013565615246e+31),\n", + " (129419584144.9997, 1.4766294411828247e+30)\n", + "]\n", + "x_data, y_data = zip(*coordinates)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c04e7deb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[[1.8258458 \\times 10^{36},~1.7269498 \\times 10^{36},~1.6334103 \\times 10^{36},~\\dots,~1.9275423 \\times 10^{-18},~1.3089964 \\times 10^{-19},~7.8153668 \\times 10^{-21}],~\n", + " [1.8386764 \\times 10^{36},~1.7390855 \\times 10^{36},~1.6448887 \\times 10^{36},~\\dots,~1.7641498 \\times 10^{-20},~1.151764 \\times 10^{-21},~6.3053187 \\times 10^{-23}],~\n", + " [1.8517923 \\times 10^{36},~1.7514909 \\times 10^{36},~1.6566222 \\times 10^{36},~\\dots,~1.5808195 \\times 10^{-22},~9.9040085 \\times 10^{-24},~4.9952597 \\times 10^{-25}],~\n", + " \\dots,~\n", + " [2.7992029 \\times 10^{39},~1.3457486 \\times 10^{39},~6.2606424 \\times 10^{38},~\\dots,~0,~0,~0],~\n", + " [1.8615143 \\times 10^{39},~8.7567949 \\times 10^{38},~3.9855527 \\times 10^{38},~\\dots,~0,~0,~0],~\n", + " [1.2202278 \\times 10^{39},~5.6160137 \\times 10^{38},~2.5004711 \\times 10^{38},~\\dots,~0,~0,~0]] \\; \\mathrm{\\frac{1}{cm}}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jet.N_e_xg" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6db0cb8b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "for i, _n_e_g in enumerate(jet.N_e_xg[::30]):\n", + " plt.loglog(jet.gamma_e, _n_e_g, label=f\"x={jet.x[30*i]}\",linestyle='dashed',lw=1)\n", + "plt.xlabel('Gamma')\n", + "plt.ylabel('Electron Energy Distribution')\n", + "plt.legend(fontsize=4)\n", + "plt.ylim(1e-10,1e50)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b4fa2e2d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$1.0792528 \\times 10^{21} \\; \\mathrm{cm}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(10000000*u.h).cgs*c.cgs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "314bc1f0", + "metadata": {}, + "outputs": [], + "source": [ + "nu_obs = np.logspace(3, 25, 1000) * u.Hz\n", + "syn= Synchrotron(jet)\n", + "flux = syn.flux_obs(nu_obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cb35c4c6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/lib/python3.12/site-packages/astropy/units/quantity.py:671: RuntimeWarning: divide by zero encountered in divide\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", + "/opt/anaconda3/lib/python3.12/site-packages/astropy/units/quantity.py:671: RuntimeWarning: invalid value encountered in divide\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", + "/opt/anaconda3/lib/python3.12/site-packages/astropy/units/quantity.py:671: RuntimeWarning: overflow encountered in divide\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", + "/Users/usharma/Documents/GitHub/agnpy/agnpy/synchrotron/BaseSynchrotron.py:36: RuntimeWarning: divide by zero encountered in divide\n", + " u = 0.5 + np.exp(-tau) / tau - (1 - np.exp(-tau)) / np.power(tau, 2)\n", + "/Users/usharma/Documents/GitHub/agnpy/agnpy/synchrotron/BaseSynchrotron.py:36: RuntimeWarning: overflow encountered in divide\n", + " u = 0.5 + np.exp(-tau) / tau - (1 - np.exp(-tau)) / np.power(tau, 2)\n", + "/Users/usharma/Documents/GitHub/agnpy/agnpy/synchrotron/BaseSynchrotron.py:36: RuntimeWarning: invalid value encountered in divide\n", + " u = 0.5 + np.exp(-tau) / tau - (1 - np.exp(-tau)) / np.power(tau, 2)\n", + "/Users/usharma/Documents/GitHub/agnpy/agnpy/synchrotron/BaseSynchrotron.py:37: RuntimeWarning: overflow encountered in divide\n", + " return np.where(tau < 1e-3, 1, 3 * u / tau)\n" + ] + } + ], + "source": [ + "syn.evaluate_attenuation()\n", + "sed_x_nossa = syn.sed_spatial(nu_obs) * jet.x[:,None]\n", + "sed_x_ssa = syn.sed_spatial(nu_obs,ssa=True) *jet.x[:,None]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "70358537", + "metadata": {}, + "outputs": [], + "source": [ + "sed_nossa= syn.sed_flux(nu_obs, ssa=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6f2b1cfe", + "metadata": {}, + "outputs": [], + "source": [ + "syn.evaluate_attenuation()\n", + "sed_ssa= syn.sed_flux(nu_obs, ssa=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7a8de071", + "metadata": {}, + "outputs": [], + "source": [ + "nu_peak= syn.nu_peak()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e0c57665", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(6,5))\n", + "plt.loglog(jet.x, np.trapz(nu_peak,jet.gamma_e,axis=1), marker='.')\n", + "plt.grid(True, which='both')\n", + "#plt.ylim(1e-15, 1e-8)\n", + "#plt.xlim(1,1e20)\n", + "#plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "774e044e", + "metadata": {}, + "outputs": [], + "source": [ + "def Z(eta):\n", + " \"\"\"Synchrotron kernel approximation (Aharonian 2010, Eq. D7).\"\"\"\n", + " term_1_num = 1.808 * np.power(eta, 1 / 3)\n", + " term_1_denom = np.sqrt(1 + 3.4 * np.power(eta, 2 / 3))\n", + " term_2_num = 1 + 2.21 * np.power(eta, 2 / 3) + 0.347 * np.power(eta, 4 / 3)\n", + " term_2_denom = 1 + 1.353 * np.power(eta, 2 / 3) + 0.217 * np.power(eta, 4 / 3)\n", + " return term_1_num / term_1_denom * term_2_num / term_2_denom * np.exp(-eta)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2b2df5ae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[0.062369596,~0.063430441,~0.064509246,~\\dots,~0,~0,~0] \\; \\mathrm{}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Z_eta[0,0,:]" + ] + }, + { + "cell_type": "markdown", + "id": "69caf6bd", + "metadata": {}, + "source": [ + "# SED" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "425ccfd5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Data for the SED model of Synchrotron no-losses in Potter and Cotter in Figure 3 \n", + "x = [\n", + " 0.0003131660307862803, 0.0008840541623107365, 0.0029160081428143986, 0.001735547961136756,\n", + " 0.0014102489162420165, 0.0010879770097760172, 0.00781551761898938, 0.019888020057617743,\n", + " 0.048049640295616425, 0.1758208691205636, 0.6433550350871309, 1.7243273563482122,\n", + " 8.614126945081937, 16.05586850963554, 45.3250224803085, 109.50567327768607,\n", + " 238.4870429629985, 422.0385406871394, 639.1956383150009, 968.0894625777796,\n", + " 1392.0728770831072, 0.0000014950230456510178, 0.0000030912978018310354, 0.000007866375035417703,\n", + " 0.000027328746886507512, 0.00005093804274539881, 0.0001168437895408067\n", + "]\n", + "\n", + "# Power / Flux data\n", + "y = [\n", + " 2.040490199884694e-12, 5.3169639633078265e-12, 1.503111337089843e-11, 1.08492128602697e-11,\n", + " 8.495785518249259e-12, 6.6528671251731555e-12, 2.1691180377984993e-11, 2.8852070927376698e-11,\n", + " 3.4659557108295606e-11, 4.249311650934016e-11, 4.705073061902792e-11, 4.6101686610606826e-11,\n", + " 3.396045117358661e-11, 2.7141154583473827e-11, 1.472792598364928e-11, 6.929596780336585e-12,\n", + " 2.169118037798499e-12, 6.652867125173156e-13, 1.842836161290166e-13, 4.163600255825478e-14,\n", + " 1.0000000000000041e-14, 1.0000000000000041e-14, 2.125365508342596e-14, 5.316963963307826e-14,\n", + " 1.769243507691091e-13, 3.327544666280575e-13, 7.672833112592147e-13\n", + "]\n", + "\n", + "# Optional: sort the data by frequency for a smoother curve\n", + "sorted_data = sorted(zip(x, y))\n", + "x_sorted, y_sorted = zip(*sorted_data)\n", + "# Plot SED\n", + "plt.figure(figsize=(6,5))\n", + "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_nossa, color='blue', linestyle='dotted', label='Model SED w/o SSA')\n", + "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_ssa, color='red', linestyle='solid', label='Model SED w SSA')\n", + "#plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_blob, color='black', linestyle='dotted', label='Model SED w Blob')\n", + "# Overlay updated data points\n", + "plt.loglog(x_sorted, y_sorted, linestyle='solid', color='green',label='BL Lac C&P')\n", + "\n", + "plt.xlabel(\"Energy [eV]\")\n", + "plt.ylabel(\"ν F_ν [erg cm⁻² s⁻¹]\")\n", + "plt.title(\"Synchrotron SED\")\n", + "plt.grid(True, which='both', ls='--')\n", + "plt.ylim(1e-14, 1e-8)\n", + "#plt.xlim(1e-8,1e6)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b0a434af", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[3.1431606 \\times 10^{16},~3.2017145 \\times 10^{16},~3.2613593 \\times 10^{16},~\\dots,~2.973846 \\times 10^{20},~3.0292458 \\times 10^{20},~3.0856776 \\times 10^{20}] \\; \\mathrm{cm}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jet.x" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c3edd712", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot SED\n", + "plt.figure(figsize=(6,5))\n", + "plt.loglog((nu_obs.to(u.eV, equivalencies=u.spectral())), np.trapz(sed_x_nossa,jet.x,axis = 0), linestyle='solid', color='red',label='Model SED w/o SSA')\n", + "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), np.trapz(sed_x_ssa,jet.x,axis = 0), linestyle='solid', color='blue',label='Model SED w SSA')\n", + "plt.loglog(x_sorted, y_sorted, linestyle='solid', color='green',label='BL Lac C&P')\n", + "plt.xlabel(\"Frequency (Hz)]\")\n", + "plt.ylabel(\"ν F_ν [erg cm⁻² s⁻¹]\")\n", + "plt.title(\"Synchrotron SED\")\n", + "plt.grid(True, which='both', ls='--')\n", + "plt.ylim(1e-15, 1e-8)\n", + "#plt.xlim(1,1e20)\n", + "#plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "fe55ecab", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axes = plt.subplots(2,1, figsize=(8, 8), sharex=True)\n", + "\n", + "# -------------------------\n", + "# Top: without SSA\n", + "# -------------------------\n", + "for i, sed in enumerate(sed_x_nossa[::50]):\n", + " axes[0].loglog(nu_obs, sed, linestyle='dotted',label = jet.x[50*i])\n", + "axes[0].loglog(nu_obs, np.trapz(sed_x_nossa,jet.x,axis = 0), linestyle='solid', color='red',label='Model SED w/o SSA')\n", + "axes[0].loglog(x_sorted, y_sorted, linestyle='solid', color='green',label='BL Lac C&P')\n", + "axes[0].set_title(\"Synchrotron SED (No SSA)\")\n", + "axes[0].set_ylabel(r\"$\\nu F_\\nu$ [erg cm$^{-2}$ s$^{-1}$]\")\n", + "axes[0].grid(True, which='both', ls='--')\n", + "axes[0].set_ylim(1e-30, 1e11)\n", + "axes[0].legend(fontsize=5)\n", + "\n", + "# -------------------------\n", + "# Bottom: with SSA\n", + "# -------------------------\n", + "for i, sed in enumerate(sed_x_ssa[::50]):\n", + " axes[1].loglog(nu_obs, sed, linestyle='dashed', lw=0.5,label = jet.x[50*i])\n", + "axes[1].loglog((nu_obs), np.trapz(sed_x_ssa,jet.x,axis = 0), linestyle='solid', color='red',label='Model SED w SSA')\n", + "axes[1].set_title(\"Synchrotron SED (With SSA)\")\n", + "axes[1].set_xlabel(\"Frequency (Hz)\")\n", + "axes[1].set_ylabel(r\"$\\nu F_\\nu$ [erg cm$^{-2}$ s$^{-1}$]\")\n", + "axes[1].grid(True, which='both', ls='--')\n", + "axes[1].set_ylim(1e-30, 1e11)\n", + "axes[1].legend(fontsize=5)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "82c83cc7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[5.4530602 \\times 10^{35},~5.4721687 \\times 10^{35},~5.491633 \\times 10^{35},~\\dots,~1.8713986 \\times 10^{34},~1.1910152 \\times 10^{34},~7.4765792 \\times 10^{33}] \\; \\mathrm{\\frac{g^{1/2}}{s\\,cm^{3/2}}}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.trapz(jet.B_x[:,None]*jet.N_e_xg[:,:],jet.gamma_e,axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1d885d6", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot SED\n", + "plt.figure(figsize=(6,5))\n", + "plt.loglog(jet.x, jet.B_x, marker='.')\n", + "plt.grid(True, which='both')\n", + "#plt.ylim(1e-15, 1e-8)\n", + "#plt.xlim(1,1e20)\n", + "#plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54bf2ec5", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot SED\n", + "plt.figure(figsize=(6,5))\n", + "plt.loglog(jet.x, jet.B_x,marker=\".\", ls=\"\")\n", + "plt.grid(True, which='both', ls='--')\n", + "#plt.xlim(1e15, 1e16)\n", + "#plt.ylim(1e-5,1)\n", + "#plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2b74b34", + "metadata": {}, + "outputs": [], + "source": [ + "jet.x[1:20]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54888b17", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(jet.x, jet.R_x/jet.x, marker=\".\", ls=\"\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "358fbb29", + "metadata": {}, + "outputs": [], + "source": [ + "x_test = np.linspace(20, 100, 50)\n", + "plt.loglog(x_test, 3*x_test)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f77ca97e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/numerical_evolution.ipynb b/numerical_evolution.ipynb new file mode 100644 index 00000000..c42ed976 --- /dev/null +++ b/numerical_evolution.ipynb @@ -0,0 +1,1001 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "id": "39fbafb8", + "metadata": {}, + "outputs": [], + "source": [ + "from agnpy.emission_regions import Cone\n", + "import astropy.units as u\n", + "from agnpy.spectra import ParticleDistribution\n", + "from agnpy.utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2\n", + "from agnpy.spectra.spectra import ExpCutoffPowerLaw\n", + "from agnpy.synchrotron import *\n", + "from scipy.interpolate import interp1d\n", + "from scipy.integrate import cumulative_trapezoid\n", + "import numpy as np\n", + "from astropy.constants import c, sigma_T, m_e, e, mu0\n", + "#e = e.gauss\n", + "mec2 = mec2.to('eV')\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import astropy.units as u\n", + "import astropy.constants as const\n", + "import matplotlib.pyplot as plt\n", + "from astropy.constants import c, sigma_T, m_e, e, mu0\n", + "from scipy.sparse import diags\n", + "from matplotlib import cycler, rcParams\n", + "from agnpy.utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "06866917", + "metadata": {}, + "outputs": [], + "source": [ + "n_e_c = ExpCutoffPowerLaw(k = 6604 , mass=m_e, p=2, gamma_min = 1, gamma_max= 10958000, gamma_c= 109580 )" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "3923951b", + "metadata": {}, + "outputs": [], + "source": [ + "gamma = np.logspace(np.log(1),np.log(1e6),100)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "24643c2e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6603.939733803004" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_e_c(gamma)[0]" + ] + }, + { + "cell_type": "markdown", + "id": "95f4233e", + "metadata": {}, + "source": [ + "# Temporal Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7995460a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import astropy.units as u\n", + "import astropy.constants as const\n", + "import matplotlib.pyplot as plt\n", + "from astropy.constants import c, sigma_T, m_e, e, mu0\n", + "from scipy.sparse import diags\n", + "from matplotlib import cycler, rcParams\n", + "from agnpy.utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2\n", + "\n", + "def gamma_loss(gamma):\n", + " B = 0.363 * u.G\n", + " u_B = ((B_to_cgs(B)**2)/(8*np.pi)).to('erg cm-3')\n", + " prefactor = (4 * c.cgs * sigma_T.cgs) / (3 * m_e.cgs * c.cgs * c.cgs )\n", + " value = prefactor * (u_B) * np.power(gamma, 2)\n", + " return -value.to(\"s-1\")\n", + "\n", + "class ChangCooperSolver_time:\n", + " def __init__(\n", + " self,\n", + " gamma_min,\n", + " gamma_max,\n", + " n_gamma,\n", + " t_max_ev,\n", + " n_t\n", + "\n", + " ):\n", + " \"\"\"class implementing the Chang and Cooper scheme in Chaiberge and Ghisellini (1998):\n", + "\n", + " Parameters\n", + " ----------\n", + " gamma_min : float\n", + " minimum Lorentz factor of the electorn distribution\n", + " gamma_max : float\n", + " maximum Lorentz factor of the electron distribution\n", + " n_gamma : int\n", + " number of steps in the Lorentz factor grid\n", + " t_max_ev : `~astropy.Units.Quantity`\n", + " maximum time of the evolution\n", + " n_t : int\n", + " number of time steps\n", + " t_max_inj : `~astropy.Units.Quantity`\n", + " maximum time of injection\n", + " t_esc : `~astropy.Units.Quantity`\n", + " escape time\n", + " injection_dict : dict\n", + " dictionary with injection specifications (spectrum and maximum injection time)\n", + " \"\"\"\n", + " self.gamma_min = gamma_min\n", + " self.gamma_max = gamma_max\n", + " self.n_gamma = n_gamma\n", + " _gamma = np.logspace(np.log10(gamma_min), np.log10(gamma_max), n_gamma)\n", + " # $\\gamma_{i \\pm 1/2}$ in Chiaberge et al. (1998)\n", + " self.gamma_midpts = _gamma[::2]\n", + " # $\\delta gamma_i$ in Chiaberge et al. (1998)\n", + " self.delta_gamma = self.gamma_midpts[:-1] - self.gamma_midpts[1:]\n", + " # $\\gamma_i$ in Chiaberge et al. (1998)\n", + " self.gamma = _gamma[1:-1:2]\n", + " self.t_max_ev = t_max_ev.to('s')\n", + " self.delta_t = t_max_ev/n_t\n", + "\n", + " @property\n", + " def gamma_dot_midpts(self):\n", + " return gamma_loss(self.gamma_midpts)\n", + "\n", + " @property\n", + " def V2(self):\n", + " loss_term = (\n", + " self.delta_t * self.gamma_dot_midpts[:-1]\n", + " ).decompose().value / self.delta_gamma\n", + " return 1 + loss_term\n", + "\n", + " @property\n", + " def V3(self):\n", + " return (\n", + " -(self.delta_t * self.gamma_dot_midpts[1:]).decompose().value\n", + " / self.delta_gamma\n", + " )\n", + "\n", + " @property\n", + " def chang_cooper_matrix(self):\n", + " return diags([self.V2, self.V3], offsets=[0, 1]).toarray()\n", + "\n", + " def run(self):\n", + " \"\"\"solve the temporal evolution, return the result at each step\"\"\"\n", + " print(\"solving Chang and Cooper equation iteratively!\")\n", + " solutions = dict()\n", + " elapsed_time = 0 * u.s\n", + " # initial electron distributions, suppose it's 0 everywhere at the first step\n", + " N_prev = n_e_c(self.gamma) \n", + " while elapsed_time < self.t_max_ev:\n", + " # add the source term only for times before t_max_injection, strip units\n", + " # compute electron distribution at next time step, units have been stripped\n", + " N_next = np.linalg.solve(self.chang_cooper_matrix, N_prev)\n", + " print(\"check correctness of solution...\")\n", + " print(np.allclose(np.dot(self.chang_cooper_matrix, N_next), N_prev))\n", + " # store solution\n", + " solutions[f\"{elapsed_time}\"] = N_next * u.Unit(\"cm-3\")\n", + " # the solution becomes the spectrum at the next step\n", + " N_prev = N_next\n", + " elapsed_time += self.delta_t\n", + " return solutions" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "c9e609ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "solving Chang and Cooper equation iteratively!\n", + "check correctness of solution...\n", + "True\n", + "check correctness of solution...\n", + "True\n", + "check correctness of solution...\n", + "True\n", + "check correctness of solution...\n", + "True\n", + "check correctness of solution...\n", + "True\n", + "check correctness of solution...\n", + "True\n", + "check correctness of solution...\n", + "True\n" + ] + } + ], + "source": [ + "cc_solver_time = ChangCooperSolver_time(\n", + " gamma_min=1,\n", + " gamma_max=1e7,\n", + " n_gamma=200,\n", + " t_max_ev= 9265669.3*u.h, #equiavelnt to 1e21 cm\n", + " n_t = 6 ,\n", + ")\n", + "solutions = cc_solver_time.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "6a2d0cc3", + "metadata": {}, + "outputs": [], + "source": [ + "#getting Radius at each time step, to obtain number of electrons instead of density\n", + "distances = []\n", + "for idx, key in enumerate(solutions.keys()):\n", + " t = u.Quantity(key)\n", + " d = c.cgs * t\n", + " distances.append(d.value)\n", + "distances = np.array(distances) * u.cm\n", + "R_x = 7.32 * 1e15 * u.cm+ distances * np.tan(9.7 * u.deg)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "425bf25c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[1,~12.74275,~162.37767,~2069.1381,~26366.509,~335981.83,~4281332.4,~54555948,~6.951928 \\times 10^{8},~8.8586679 \\times 10^{9},~1.1288379 \\times 10^{11},~1.4384499 \\times 10^{12},~1.8329807 \\times 10^{13},~2.3357215 \\times 10^{14},~2.9763514 \\times 10^{15},~3.7926902 \\times 10^{16},~4.8329302 \\times 10^{17},~6.1584821 \\times 10^{18},~7.8475997 \\times 10^{19}] \\; \\mathrm{cm}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "distances" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "7c5de3ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "16\n", + "17\n", + "18\n" + ] + } + ], + "source": [ + "for idx, key in enumerate(solutions):\n", + " label = (u.Quantity(key).to(\"s\"))*c.cgs\n", + " y = solutions[key]*R_x[idx]**2\n", + " print(idx)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "b00780b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2.08886473e+35 1.38713534e+35 9.13069881e+34 5.96147962e+34\n", + " 3.86348312e+34 2.48710660e+34 1.59150915e+34 1.01301832e+34\n", + " 6.41789843e+33 4.04936354e+33 2.54581023e+33 1.59556175e+33\n", + " 9.97308522e+32 6.21916684e+32 3.87043927e+32 2.40455270e+32\n", + " 1.49162212e+32 9.24110518e+31 5.71882761e+31 3.53569111e+31\n", + " 2.18414901e+31 1.34827559e+31 8.31771154e+30 5.12851395e+30\n", + " 3.16060112e+30 1.94697857e+30 1.19890385e+30 7.37995296e+29\n", + " 4.54129398e+29 2.79363625e+29 1.71802190e+29 1.05622791e+29\n", + " 6.49165541e+28 3.98857939e+28 2.44984957e+28 1.50421435e+28\n", + " 9.23245367e+27 5.66430605e+27 3.47360505e+27 2.12910465e+27\n", + " 1.30428213e+27 7.98500628e+26 4.88511856e+26 2.98629910e+26\n", + " 1.82392445e+26 1.11287636e+26 6.78263175e+25 4.12855722e+25\n", + " 2.50943844e+25 1.52283668e+25 9.22441604e+24 5.57611877e+24\n", + " 3.36293669e+24 2.02288119e+24 1.21322724e+24 7.25221291e+23\n", + " 4.31887880e+23 2.56115028e+23 1.51156508e+23 8.87318014e+22\n", + " 5.17713515e+22 2.99994567e+22 1.72488217e+22 9.83062847e+21\n", + " 5.54713916e+21 3.09484638e+21 1.70459724e+21 9.25224644e+20\n", + " 4.93887483e+20 2.58665986e+20 1.32554491e+20 6.62546530e+19\n", + " 3.21813087e+19 1.51248113e+19 6.84377014e+18 2.96393997e+18\n", + " 1.22017414e+18 4.73632335e+17 1.71710982e+17 5.74946371e+16\n", + " 1.75465283e+16 4.80521886e+15 1.15926021e+15 2.41052069e+14\n", + " 4.20985669e+13 5.98864221e+12 6.69098233e+11 5.62340824e+10\n", + " 3.37765480e+09 1.36453037e+08 3.45093798e+06 5.02011497e+04\n", + " 3.80249551e+02 1.33430699e+00 1.89147977e-03 9.22592922e-07\n", + " 1.28273620e-10 4.07576585e-15 2.28271420e-20] 1 / cm\n", + "[1.58689456e+42 9.35644655e+41 5.43435656e+41 3.11396585e+41\n", + " 1.76296607e+41 9.87506806e+40 5.47974184e+40 3.01587300e+40\n", + " 1.64800227e+40 8.94960363e+39 4.83407503e+39 2.59899282e+39\n", + " 1.39173734e+39 7.42697818e+38 3.95165893e+38 2.09720183e+38\n", + " 1.11058086e+38 5.87006368e+37 3.09764894e+37 1.63235831e+37\n", + " 8.59162143e+36 4.51731867e+36 2.37296181e+36 1.24552927e+36\n", + " 6.53296819e+35 3.42446993e+35 1.79402538e+35 9.39369719e+34\n", + " 4.91623185e+34 2.57173529e+34 1.34469613e+34 7.02793559e+33\n", + " 3.67142724e+33 1.91707728e+33 1.00053458e+33 5.21913881e+32\n", + " 2.72096206e+32 1.41769128e+32 7.38160611e+31 3.84060934e+31\n", + " 1.99661709e+31 1.03703886e+31 5.38090796e+30 2.78884923e+30\n", + " 1.44359550e+30 7.46194189e+29 3.85097731e+29 1.98390536e+29\n", + " 1.02002380e+29 5.23283213e+28 2.67785071e+28 1.36656959e+28\n", + " 6.95234185e+27 3.52473370e+27 1.78008602e+27 8.95114236e+26\n", + " 4.47939364e+26 2.22955467e+26 1.10306496e+26 5.42077491e+25\n", + " 2.64396206e+25 1.27878273e+25 6.12706037e+24 2.90491002e+24\n", + " 1.36108943e+24 6.29346708e+23 2.86704729e+23 1.28444875e+23\n", + " 5.64701239e+22 2.43048408e+22 1.02126383e+22 4.17613056e+21\n", + " 1.65580966e+21 6.33881798e+20 2.33150400e+20 8.19249047e+19\n", + " 2.73185896e+19 8.57797529e+18 2.51324240e+18 6.79751228e+17\n", + " 1.67587615e+17 3.71041194e+16 7.24775973e+15 1.22308935e+15\n", + " 1.73908399e+14 2.02225163e+13 1.85579573e+12 1.28799424e+11\n", + " 6.42525849e+09 2.16819917e+08 4.60457553e+06 5.65001926e+04\n", + " 3.62224387e+02 1.07831457e+00 1.29856888e-03 5.38447790e-07\n", + " 6.36596581e-11 1.72016876e-15 8.19329805e-21] 1 / cm\n", + "[2.50131045e+42 1.29259421e+42 6.55074154e+41 3.26280003e+41\n", + " 1.60044929e+41 7.74560316e+40 3.70481515e+40 1.75402986e+40\n", + " 8.23104524e+39 3.83301341e+39 1.77316559e+39 8.15605720e+38\n", + " 3.73318551e+38 1.70155939e+38 7.72754738e+37 3.49853238e+37\n", + " 1.57968591e+37 7.11638703e+36 3.19957018e+36 1.43610237e+36\n", + " 6.43637174e+35 2.88100065e+35 1.28813978e+35 5.75385645e+34\n", + " 2.56791148e+34 1.14515841e+34 5.10325227e+33 2.27273484e+33\n", + " 1.01155303e+33 4.49965036e+32 2.00044128e+32 8.88856115e+31\n", + " 3.94723217e+31 1.75186953e+31 7.77045659e+30 3.44437398e+30\n", + " 1.52570913e+30 6.75312588e+29 2.98661091e+29 1.31964464e+29\n", + " 5.82503077e+28 2.56835309e+28 1.13102589e+28 4.97382843e+27\n", + " 2.18394211e+27 9.57297583e+26 4.18815594e+26 1.82840963e+26\n", + " 7.96329746e+25 3.45910194e+25 1.49814546e+25 6.46725052e+24\n", + " 2.78163103e+24 1.19155753e+24 5.08122292e+23 2.15595494e+23\n", + " 9.09673814e+22 3.81448371e+22 1.58850742e+22 6.56465147e+21\n", + " 2.68986499e+21 1.09176736e+21 4.38476428e+20 1.74044089e+20\n", + " 6.81846231e+19 2.63252722e+19 9.99956055e+18 3.72973252e+18\n", + " 1.36307676e+18 4.86898575e+17 1.69517232e+17 5.73396758e+16\n", + " 1.87745441e+16 5.92551138e+15 1.79396737e+15 5.18078096e+14\n", + " 1.41786877e+14 3.64954953e+13 8.75691836e+12 1.93844260e+12\n", + " 3.91043892e+11 7.08576937e+10 1.13368233e+10 1.56921335e+09\n", + " 1.83395880e+08 1.75777372e+07 1.33420230e+06 7.68991470e+04\n", + " 3.19986585e+03 9.04763655e+01 1.61687461e+00 1.67567534e-02\n", + " 9.09939640e-05 2.29891942e-07 2.35227667e-10 8.29208797e-14\n", + " 8.33654836e-18 1.91571061e-22 7.76003023e-28] 1 / cm\n", + "[1.85638506e+42 8.36025228e+41 3.67923943e+41 1.58651482e+41\n", + " 6.71967030e+40 2.80184113e+40 1.15241041e+40 4.68403806e+39\n", + " 1.88440706e+39 7.51411983e+38 2.97346175e+38 1.16893506e+38\n", + " 4.56944711e+37 1.77757969e+37 6.88629355e+36 2.65821291e+36\n", + " 1.02296728e+36 3.92635374e+35 1.50360217e+35 5.74682955e+34\n", + " 2.19275773e+34 8.35443191e+33 3.17898426e+33 1.20829386e+33\n", + " 4.58801804e+32 1.74056870e+32 6.59791403e+31 2.49919005e+31\n", + " 9.45996280e+30 3.57841561e+30 1.35272928e+30 5.11036126e+29\n", + " 1.92934245e+29 7.27905888e+28 2.74432408e+28 1.03388151e+28\n", + " 3.89185939e+27 1.46374357e+27 5.49995753e+26 2.06442616e+26\n", + " 7.73994973e+25 2.89815934e+25 1.08365557e+25 4.04554630e+24\n", + " 1.50766141e+24 5.60771797e+23 2.08127526e+23 7.70599415e+22\n", + " 2.84555438e+22 1.04764666e+22 3.84440688e+21 1.40556871e+21\n", + " 5.11809056e+20 1.85525453e+20 6.69152035e+19 2.40013370e+19\n", + " 8.55606192e+18 3.02936029e+18 1.06450100e+18 3.70940491e+17\n", + " 1.28065271e+17 4.37612412e+16 1.47839949e+16 4.93167927e+15\n", + " 1.62215468e+15 5.25297766e+14 1.67175927e+14 5.21844937e+13\n", + " 1.59420762e+13 4.75439060e+12 1.38024868e+12 3.88803165e+11\n", + " 1.05879827e+11 2.77573928e+10 6.97151157e+09 1.66816935e+09\n", + " 3.77852959e+08 8.04138420e+07 1.59398439e+07 2.91313229e+06\n", + " 4.85024397e+05 7.25376992e+04 9.58287565e+03 1.09625820e+03\n", + " 1.06042289e+02 8.42929754e+00 5.32004333e-01 2.55755851e-02\n", + " 8.90742687e-04 2.11564833e-05 3.18702746e-07 2.79271209e-09\n", + " 1.28532954e-11 2.75680795e-14 2.39704942e-17 7.18409507e-21\n", + " 6.14190484e-25 1.20028752e-29 4.13489965e-35] 1 / cm\n", + "[9.50960265e+41 3.72197126e+41 1.41916317e+41 5.28791897e+40\n", + " 1.93090392e+40 6.92743654e+39 2.44746756e+39 8.53255548e+38\n", + " 2.94062919e+38 1.00342687e+38 3.39479730e+37 1.14010485e+37\n", + " 3.80477622e+36 1.26286175e+36 4.17214817e+35 1.37286662e+35\n", + " 4.50202443e+34 1.47200224e+34 4.80075214e+33 1.56229245e+33\n", + " 5.07453508e+32 1.64558158e+32 5.32871595e+31 1.72338056e+31\n", + " 5.56746385e+30 1.79680798e+30 5.79367498e+29 1.86657654e+29\n", + " 6.00896279e+28 1.93299474e+28 6.21366552e+27 1.99596707e+27\n", + " 6.40683351e+26 2.05498461e+26 6.58618089e+25 2.10910382e+25\n", + " 6.74800083e+24 2.15691503e+24 6.88705567e+23 2.19650632e+23\n", + " 6.99646556e+22 2.22543230e+22 7.06763462e+21 2.24070313e+21\n", + " 7.09027222e+20 2.23881533e+20 7.05258965e+19 2.21585349e+19\n", + " 6.94177519e+18 2.16769861e+18 6.74486736e+17 2.09038150e+17\n", + " 6.45014356e+16 1.98061389e+16 6.04909924e+15 1.83650702e+15\n", + " 5.53898567e+14 1.65844027e+14 4.92567502e+13 1.44996308e+13\n", + " 4.22632337e+12 1.21850692e+12 3.47094527e+11 9.75575134e+10\n", + " 2.70172984e+10 7.36027756e+09 1.96896580e+09 5.16179351e+08\n", + " 1.32312460e+08 3.30776011e+07 8.04179677e+06 1.89515729e+06\n", + " 4.31325709e+05 9.44068479e+04 1.97763624e+04 3.94303420e+03\n", + " 7.43507576e+02 1.31614726e+02 2.16850703e+01 3.29232820e+00\n", + " 4.55226348e-01 5.65350635e-02 6.20367214e-03 5.89843770e-04\n", + " 4.74714411e-05 3.14436711e-06 1.65695145e-07 6.66693558e-09\n", + " 1.94876209e-10 3.89608157e-12 4.95439834e-14 3.67412085e-16\n", + " 1.43395381e-18 2.61170643e-21 1.92997714e-24 4.91797266e-28\n", + " 3.57545807e-32 5.94229106e-37 1.74092510e-42] 1 / cm\n", + "[3.85409292e+41 1.30914219e+41 4.31990860e+40 1.38960625e+40\n", + " 4.37130198e+39 1.34855558e+39 4.09045158e+38 1.22263912e+38\n", + " 3.60839220e+37 1.05335469e+37 3.04608037e+36 8.73750905e+35\n", + " 2.48891562e+35 7.04754113e+34 1.98535819e+34 5.56840167e+33\n", + " 1.55590740e+33 4.33341147e+32 1.20355584e+32 3.33472549e+31\n", + " 9.22047055e+30 2.54486380e+30 7.01284800e+29 1.92986034e+29\n", + " 5.30429170e+28 1.45631274e+28 3.99440413e+27 1.09459589e+27\n", + " 2.99699124e+26 8.19906390e+25 2.24130037e+25 6.12203501e+24\n", + " 1.67089041e+24 4.55666136e+23 1.24158459e+23 3.37998501e+22\n", + " 9.19251219e+21 2.49747158e+21 6.77755972e+20 1.83698470e+20\n", + " 4.97213674e+19 1.34376857e+19 3.62560464e+18 9.76412116e+17\n", + " 2.62419268e+17 7.03673799e+16 1.88214357e+16 5.02019820e+15\n", + " 1.33488605e+15 3.53734563e+14 9.33814389e+13 2.45480394e+13\n", + " 6.42320425e+12 1.67205716e+12 4.32791893e+11 1.11320717e+11\n", + " 2.84351596e+10 7.20780240e+09 1.81163188e+09 4.51100443e+08\n", + " 1.11170341e+08 2.70862109e+07 6.51676538e+06 1.54619638e+06\n", + " 3.61248679e+05 8.29745550e+04 1.87019347e+04 4.12803585e+03\n", + " 8.90268857e+02 1.87112397e+02 3.82145970e+01 7.55926957e+00\n", + " 1.44292352e+00 2.64659884e-01 4.64220494e-02 7.74387224e-03\n", + " 1.22077925e-03 1.80543761e-04 2.48374472e-05 3.14711836e-06\n", + " 3.63050576e-07 3.76133580e-08 3.44366682e-09 2.73306844e-10\n", + " 1.83750815e-11 1.01793387e-12 4.49326180e-14 1.51733319e-15\n", + " 3.73063936e-17 6.28869762e-19 6.75861870e-21 4.24495970e-23\n", + " 1.40553189e-25 2.17433051e-28 1.36569718e-31 2.95899076e-35\n", + " 1.82940050e-39 2.58566512e-44 6.44236296e-50] 1 / cm\n", + "[1.32427546e+41 3.90117352e+40 1.11345388e+40 3.09074892e+39\n", + " 8.37285663e+38 2.22052429e+38 5.78119077e+37 1.48125327e+37\n", + " 3.74312398e+36 9.34668773e+35 2.31004263e+35 5.65908851e+34\n", + " 1.37587389e+34 3.32340781e+33 7.98295254e+32 1.90837376e+32\n", + " 4.54337655e+31 1.07785845e+31 2.54933740e+30 6.01392452e+29\n", + " 1.41549431e+29 3.32512452e+28 7.79769804e+27 1.82588920e+27\n", + " 4.26979270e+26 9.97296868e+25 2.32689122e+25 5.42374770e+24\n", + " 1.26305644e+24 2.93876771e+23 6.83185005e+22 1.58688653e+22\n", + " 3.68285684e+21 8.53975646e+20 1.97838861e+20 4.57889389e+19\n", + " 1.05867682e+19 2.44503201e+18 5.64003502e+17 1.29928964e+17\n", + " 2.98882572e+16 6.86438185e+15 1.57375118e+15 3.60100121e+14\n", + " 8.22190298e+13 1.87276139e+13 4.25443302e+12 9.63665409e+11\n", + " 2.17570204e+11 4.89452186e+10 1.09671199e+10 2.44660211e+09\n", + " 5.43151702e+08 1.19934591e+08 2.63262893e+07 5.74101587e+06\n", + " 1.24293079e+06 2.66956067e+05 5.68342296e+04 1.19829489e+04\n", + " 2.49957734e+03 5.15274747e+02 1.04845565e+02 2.10287161e+01\n", + " 4.15121638e+00 8.05218819e-01 1.53187157e-01 2.85234062e-02\n", + " 5.18615287e-03 9.18388954e-04 1.57934844e-04 2.62887730e-05\n", + " 4.21976026e-06 6.50424295e-07 9.58096607e-08 1.34133963e-08\n", + " 1.77356000e-09 2.19873609e-10 2.53433316e-11 2.68944087e-12\n", + " 2.59770131e-13 2.25314050e-14 1.72714487e-15 1.14805003e-16\n", + " 6.46850543e-18 3.00576143e-19 1.11427922e-20 3.16507482e-22\n", + " 6.55757958e-24 9.33322705e-26 8.48577084e-28 4.51687192e-30\n", + " 1.26926523e-32 1.66807795e-35 8.90601381e-39 1.64074745e-42\n", + " 8.62642425e-47 1.03689933e-51 2.19713366e-57] 1 / cm\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1AAAALtCAYAAAAmOIUuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1CU19fA8e/usjSRIqKogGDHjhVFYFEUe0mxF2JvsZeYakyMGk3UxIZdozG2xNgiYhQ1ltijYu8dK70t8Lx/8HPfIMWlWHM+MzvjPuXc++yuM5y5956rUhRFQQghhBBCCCHEc6lfdQeEEEIIIYQQ4k0hCZQQQgghhBBCGEkSKCGEEEIIIYQwkiRQQgghhBBCCGEkSaCEEEIIIYQQwkiSQAkhhBBCCCGEkSSBEkIIIYQQQggjSQIlhBBCCCGEEEaSBEoIIYQQQgghjCQJlBBCCCGEEEIYSRIoIYQQQgghhDDSK0ug4uLiKFmyJKNGjTIcu3r1Kn5+flSsWJEqVaoQGxv7qronhBBCCCGEEBmYvKqGJ06cSN26ddMdCwwM5Ouvv8bb25vHjx9jZmb2inonhBBCCCGEEBm9khGoixcvcu7cOZo3b244FhYWhlarxdvbG4BChQphYvLK8jshhBBCCCGEyCDHCdSePXto1aoVxYsXR6VSsWHDhgzXzJkzBzc3N8zNzalZsyZ79+5Nd37UqFFMmjQp3bGLFy9iZWVF69atqVGjBt98801OuyaEEEIIIYQQL1SOE6jY2FiqVavGrFmzMj2/evVqhg0bxieffMLx48fx9vamWbNm3LhxA4Dff/+dcuXKUa5cuXT36fV69u7dy+zZszlw4AAhISGEhITk4pGEEEIIIYQQ4sVQKYqi5PpmlYrffvuNtm3bGo7VrVuXGjVqMHfuXMMxd3d32rZty6RJkxg3bhwrVqxAo9EQExODXq9n5MiRNG7cmC+//JJt27YBMHXqVABGjx6daduJiYkkJiYa3qempvL48WPs7e1RqVS5fSQhhBBCCCHEG05RFKKjoylevDhqdT6vWlLyAFB+++03w/vExERFo9Eov/76a7rrhgwZovj4+GS4f8mSJcrIkSMVRVEUvV6vVK9eXXn8+LGSkpKitGzZUtm0aVOWbX/xxRcKIC95yUte8pKXvOQlL3nJS16Zvm7evJmXdCdT+Vql4eHDh6SkpFC0aNF0x4sWLcq9e/eyvdfExIRvvvkGHx8fFEWhSZMmtGzZMsvrx40bx4gRIwzvIyMjcXFx4ebNm1hbW+ftQYQQQgghhBBvrKioKJydnSlYsGC+x34hZe6enUKnKEqm0+oCAwPTvW/WrBnNmjUzqg0zM7NMy5xbW1tLAiWEEEIIIYR4IUt78jWBKly4MBqNJsNo0/379zOMSgkhhBBCiLdPSkoKer3+VXdD/MdotVo0Gs1LaStfEyhTU1Nq1qxJSEgI7dq1MxwPCQmhTZs2+dmUEEIIIYR4zcTExHDr1i2U3NcoEyJXVCoVTk5OWFlZvfC2cpxAxcTEcOnSJcP7q1evcuLECQoVKoSLiwsjRoygW7du1KpVi3r16jF//nxu3LhB//7987XjQgghhBDi9ZGSksKtW7ewtLTEwcFBqiKLl0ZRFB48eMCtW7coW7bsCx+JynECdeTIEfz8/AzvnxZy6NGjB0uXLqVDhw48evSICRMmcPfuXSpXrszWrVspWbJk/vVaCCGEEEK8VvR6PYqi4ODggIWFxavujviPcXBw4Nq1a+j1+tcvgdLpdM8dlh04cCADBw7MdaeEEEIIIcSb6WWOPI0aNYq///4bFxcXlixZgqmpqeFccnIyvXv35vLly9SoUYOZM2e+tH6Jl+9l/u7yeVcpIYQQQgghXrzjx49z79499u7dS8WKFVm3bl2685s2bcLJyYm9e/cSFxfH/v37X1FPxdtGEighhBBCCPHGOXDgAE2aNAGgadOmGRKk551/8OABrVq1wtfXl65duwJQo0YN+vfvT/Xq1Zk/fz6BgYF4eHiwatWql/BE4k3xQvaBEkIIIYQQ/23xSSlcfhCT5zilHaywMM24piUiIoLixYsDYGNjw+PHjzOcf7o3aGbnv/nmG3r27Em7du1ITU013PPJJ59gb29PsWLFuHjxIqamprRo0YJOnTrl+VnE20ESKCGEEEIIke8uP4ih5Y9/5TnO5g8bULmETYbjdnZ2REVFAWmJT6FChXJ0/ty5c3zyyScAqNVqwz3Ozs4AVKhQgSJFigCQmJiY5+cQbw9JoIQQQgghRL4r7WDF5g8b5EuczHh6evLdd9/RvXt3goOD8fLyynB++/bt+Pj4EBwcTM+ePdOdd3d3Z9++fbRp04bU1FTUanW6QgRShl1kRRIoIYQQQgiR7yxMNZmOHOUXDw8PHB0d8fb2xsXFhdGjRwPQr18/goKCaNWqFRs2bMDb2xsPDw/q1auX7v5x48YRGBjI999/j6urK8uWLXthfRVvF5XylmwVHRUVhY2NDZGRkYb5rkIIIYQQ4uVISEjg6tWruLm5YW5u/qq7I/5jnv39vcjcQKrwCSGEEEIIIYSRJIESQgghhBBCCCNJAiWEEEIIIYQQRpIESgghhBBCCCGMJAmUEEIIIYQQQhhJEighhBBCCPHGiY6Opm7dulhZWXH69OlMr/nll19o2LAhPj4+HDp0CIDTp08TEBCAr68vQUFBQNpGu506dcLPz4/+/fsDoCgK48aNw9/fHx8fH/R6/QuLCTBp0iRq1apleJ9ZzHfeeQedToevry92dnYATJgwAZ1Oh06nw8bGhn/++YetW7dSv359GjRowODBgw0xx40bR7169ahXrx5///03AB06dMDX15c6deqwa9eu5/bTWEePHsXb2xtfX1/at29viLF69Wrq1atHw4YNuXnzZo7jvhaUt0RkZKQCKJGRka+6K0IIIYQQ/znx8fHKmTNnlPj4+JfSnl6vV+7fv6/06NFDOXXqVIbzt2/fVjp27KikpqamO96yZcsMfy8OGTJEOXbsWLpja9euVWbOnPnCYyqKokRFRSmdO3dWatasmW3Mp/bu3asEBgamOxYfH69UqVJFURRFuX79uqLX6xVFUZROnTophw4dUh49eqR4enoqiqIoFy5cUNq2basoiqIkJSUpiqIo165dUxo2bJhtP7PTo0ePdO/v3r2rxMbGKoqiKOPGjVPWrFmjJCUlKXXq1FESExOVv/76S+nTp0+O2sjOs7+/F5kbyAiUEEIIIYR445iYmODg4JDl+W3btmFmZkbjxo3p1q0bMTExXLlyBb1eT9euXQkICODcuXMAHD9+nDlz5qDT6diwYQMAGzdu5Pr16+h0Or788ssXFhNg5syZDBo0yPA+q5hPrV27lvfffz/dsT/++IOmTZsC4OLigomJCQBarRYTExMKFiyIvb09er2eiIgIw2en1WqBtD1Vq1SpkmU/ExIS6Nq1Kw0bNqR169ZERUVl+/04OjpiaWmZrg8XL16kUqVKmJqa4uXlxalTpzLcN3HiROrXr4+vry9nzpxh/PjxdO7cmYCAAFq3bs3s2bMJCAjgnXfeybb9F0kSKCGEEEIIkf+S4uDOiby/kuJy1Xx4eDgRERGEhIRQv359Zs2aRXh4OGFhYaxYsYLvvvuOESNGAHDo0CEGDBjA5s2bmTBhAomJiYSHh1OiRAlCQ0M5c+YMBw8efCExIyMjOXXqFPXr10/X98xiQtr0uj///BN/f/90z5tZUnX06FEePnyIh4cHWq2WSpUqUb58edq2bZtuap+fnx/+/v6GBCyzfi5cuJCGDRuyc+dOevTowfz58436Hm7cuMGOHTto2bIlERER6Ta1TUlJSXftP//8w5EjR9i3bx+7d++mQoUKAFSqVIng4GBsbGxITk4mODgYRVG4cOGCUX3IbyavpFUhhBBCCPF2e3gB5vvmPU7f3VC8eo5vs7W1xc/PD5VKRcOGDZk4cSJt2rShVq1aWFtbU7lyZR4+fAiAq6srNWrUAKB8+fLcvn0bW1tbGjVqBEDDhg05c+bMC4kZHBycLpl52vfMYgLs37+fWrVqYWpqajiWkJDA6dOnqV27tuHYrVu3GDp0KL/99hsAZ8+e5fjx41y8eJF79+7RpUsXQkNDAdi1axc3btygdevWNG3aNNN+njlzhsOHD7N8+XL0ej3e3t6kpKQYrjt37hw6nQ6AlStXUqJECaKioujWrRtLlixBq9ViZ2eXbuRKo9Gke+5z587h5eWFSqUCQK1OG+upWrUqACVKlEj37ydPnjz3d/AiSAIlhBBCCCHyX+FyaclPfsTJBS8vL6ZPnw6kTacrVaoUZcuW5cGDB+j1esLDww2jIZUrV+bq1au4uLhw+fJlHB0d8fLy4sSJE1SrVo3jx4/TsWNHChUqlO8xd+3axYEDBwC4ePEikydPZtSoUZnGhMxHmrZt20ZAQIDhfUxMDJ07d2bevHnppjlaW1uj0WgoWLAgMTExKIpCcnIyWq0WKysrQzuZ9TMmJoZ69erRrVs3APR6PRqNxpCEBQYGsnTpUkNbKSkpdOnShc8//5xy5dK+wzJlynDmzBmSkpI4fPiwIRl6qkKFCqxevdrwPjU1FcCQUD37b0VRsvkFvDiSQAkhhBBCiPxnapmrkaOcaN68OSdOnOD8+fP069ePwMBA+vXrR1BQEFWrVqVYsWLodDosLCxYuXIlJiYmjBgxAj8/P1JTU/nhhx+AtHU3PXv2JD4+nv79+2NpaUmvXr0IDAxk8eLFuLu7G0ZX8jvm07gAtWrV4qOPPgLINKaiKOzYsYNvv/023eewdu1ahg4danj/448/cvnyZcPI1pdffomvry/Ozs40aNCAxMREPv30U5KTk2ncuDEqlYqUlBQmTZoEkGk/PT096du3L0uWLAFg5MiRtGjRIsvvZs2aNezfv5/o6Gi++uorBgwYQIcOHRg2bBi+vr6Ym5uzfPnydPdUq1YNDw8P6tWrh4WFBbNmzcrR7+FlUSmvKnXLZ1FRUdjY2BAZGZkuSxdCCCGEEC9eQkICV69exc3NDXNz81fdHfEf8+zv70XmBlJEQgghhBBCCCGMJAmUEEIIIYQQQhhJEighhBBCCCGEMJIkUEIIIYQQQghhJEmghBBCCCGEEMJIkkAJIYQQQgghhJEkgRJCCCGEEG+c06dP4+Xlha+vLy1atCAmJibd+ZCQEBo0aECDBg3o1q0bKSkpPHz40HCPn58fd+7cAaBDhw74+vpSp04ddu3aBcDkyZPx9fWldu3azJgxI19iTpw4kfr161O3bl2WLVsGpG3F07p1a/z8/Bg5ciRAljF1Oh3e3t7odDp++umndM8bEBDAqFGjAAgNDcXZ2RmdTkejRo3SfWYBAQH4+voSFBQEwDvvvINOp8PX1xc7O7tcfRdLliyhfv361KtXj8mTJxuOjxo1Cm9vb7p06UJSUlKuYr+WlLdEZGSkAiiRkZGvuitCCCGEEP858fHxypkzZ5T4+PiX0l5SUpLh3+PHj1eWL1+e7nxiYqLh34GBgcqePXuU5ORkJTk5WVEURVm6dKkyYcKEdLGuXbumNGzYMN2x5ORkpWLFikpycnKeY16+fNnQt0qVKimpqanKt99+qyxcuFBRFEUZMGCAcvDgwSxj+vr6KtHR0Rk+i3379ikBAQHKyJEjFUVRlF27dhn+/W8tW7bM8m/lvXv3KoGBgZmee1aPHj3Svb9y5YqSmpqqpKamKl5eXkp4eLhy7NgxpUuXLoqiKMrXX3+trFy50qjYufXs7+9F5gYyAiWEEEIIId44Wq3W8O+4uDgqVKiQ7rypqSkAiqKgKApubm5oNBo0Gg2QNvJTuXLldLGioqKoUqVKumMJCQmUKlUKjUaT55ilSpUynDMxMQHgypUrVK9eHYAaNWqwd+/eLGOq1WqaN29O69atuX79uuFZZ86cyaBBg9I9//r16/H29mbmzJmGdvR6PV27diUgIIBz586lu37t2rW8//77hmsDAgLQ6XQMHz48u68BADc3N1QqFSqVCq1Wi0aj4cCBAzRp0gSApk2bsn///nT3xMfH06lTJ3x9ffH39wfSRtiGDh1K3bp1mThxIkOGDMHT05OpU6c+tw8vk8mr7oAQQgghhHj7xCfHczXyap7juNm4YWFikem5kJAQxowZg1arZezYsRnO//TTT0yaNAk3NzccHBwAOHXqFL179yYiIoLg4GDDtX5+fpw5c8YwtQ5g5MiRrFq1igEDBuRbTIAffviB9u3bo1KpcHd3Z+fOndSsWZMdO3ZQpkyZLGOuXbsWe3t7du/ezZAhQ/j999/Zu3cv1apVo2DBgob4tWrV4vz58wC0adOGBg0akJSURFhYGGFhYdy4cYMRI0awdetWIC0h/PPPPw2JytixY5kzZw6lS5fmww8/5MiRI9SqVSvb7wlg48aNlC1bFnt7eyIiIihevDgANjY2PH78ON218+fPp06dOgwfPpzU1FTD8fbt2zNjxgzc3NzYsGED06dPp0aNGowePfq57b8sKkVRlFfdifwQFRWFjY0NkZGRWFtbv+ruCCGEEEL8pyQkJHD16lXc3NwwNzfnzKMzdNjcIc9xV7dcTUX7itle8+2335KamspHH32U6flBgwbh7e1Nx44dDcfWrFnDzp07mTdvnuHYjRs3aN26NSdOnDAcS0hIoEGDBmzcuNGQEOQlZkhICHPnzmXdunWo1Wri4uIYOHAgt27dwtXVlerVqzN48OBsY0JaknTkyBHeeecdli5dyrFjx9i8eTPTpk1Ld93cuXMxMzOjXr16fPzxx/z2228A1KlTh0OHDgGwb98+FixYwNKlSwGoWrUqhQoVAiA6OprPPvsMZ2dnwxqtc+fOUaFCBRwcHFi7di0AJ0+eZNiwYWzZsgULCwvmzp1LgQIF6N69O0eOHGHp0qXMmjXL0K8BAwbQq1evdImZTqdj06ZNFCxYEE9PTw4cOIBKpTI8a3ae/f29yNxARqCEEEIIIUS+c7NxY3XL1fkSJzOJiYmYmZkBaSMczxYp+Pd5a2trChQoQFJSkmEano2NDQUKFEBRFJKTk9FqtVhZWRn+2H56v5mZGZaWllhYWOQ5ZlhYGF999RVbt25FrU5bSWNpaWlIXHr37k3Lli0zjQlpAwbW1tacPXvWUPDh8uXLtG/fnsePH/PgwQMaNmxIgwYNDG3u3buX/v37U7ZsWR48eIBeryc8PDxdUvHv6XsA5cuXZ9q0aZQsWRJFUUhJScHExITQ0FAAAgMDDX0GuHv3Lv369WP9+vVYWKSNFnp6evLdd9/RvXt3goOD8fLySvf9uLu7s2/fPmrVqkVqaqrh81CpVIZr/v3v14kkUEIIIYQQIt9ZmFg8d+QoL0JCQpg6dSpqtRoHBwfDH/T9+vUjKCiI5cuXs3LlShRFoUKFCrRo0YLjx48zfPhwNBoNlpaWLFq0iOTkZBo3boxKpSIlJYVJkyYBMGLECMLCwtDr9XTv3h07OzsWLFiQ55iPHj2iZcuWAPz+++9cvXqVYcOGodFo6N69O66urhw9ejRDTICGDRsaEpTZs2cD8M8//wBplfc2b95M8+bNWbhwIfPnz8fExAQvLy98fHwM7fv5+ZGamsoPP/wApE3f27FjB99++63hs50yZQr9+/cnMTERtVrN4sWLcXFxyfK7GD9+PPfv36dz584ABAUF4eHhgaOjI97e3ri4uGSYgtenTx8CAwMNSde/pz6+7mQKnxBCCCGEyLNnp1AJ8TK9zCl8UoVPCCGEEEIIIYwkCZQQQgghhBBCGEkSKCGEEEIIIYQwkiRQQgghhBBCCGEkSaCEEEIIIYQQwkiSQAkhhBBCiDfWqlWrcHBwyHA8KiqK1q1b4+fnZ9gAFmD48OH4+PjQrl07oqKiDDE8PT3x9fUlLCwMgFOnTtGgQQO8vb1ZtWrVC4v51KRJk9JtKjt9+nS8vLxo2bIlkZGRAHTo0AFfX1/q1KnDrl27APj111+pUKFCunvj4+Np2bIlvr6+NG7cmMePHwNQsGBBdDodOp2OU6dOAfDpp59SvHhxRo0alePP/qklS5ZQv3596tWrx+TJkw3HR40ahbe3N126dMmwT9ebTBIoIYQQQgjxRkpNTWXdunU4OztnOBcUFESbNm3YtWsX8fHx/P333xw+fJiHDx+yZ88eOnXqxNy5c0lOTubbb79l7969/Pzzz4wbNw6AcePGsXTpUkJDQ5k3bx4JCQkvJCZAdHQ0p0+fNvT9wYMHbNq0ib/++otOnToZ9nxasWIFu3fvZu3atXz99dcA+Pr6cvLkyXTP/scff1C5cmV2795N+/bt+emnn4C0DXJDQ0MJDQ2lSpUqAAwePJiVK1fm6HMPDAxM916n07Fv3z7279/P5s2buX//PsePH+fevXvs3buXihUrsm7duhy18TqTBEoIIYQQQryRfv75Z9577z3U6ox/0l65coXq1asDUKNGDfbu3ZvpsUePHuHk5IRWq6VEiRJcuHABgPDwcMqUKYNGo8HZ2ZnTp0+/kJgAM2fOZNCgQYa+Hz58GJ1Oh0qlomnTpuzfvx8ArVYLpI2EPU2A7O3tMTU1TffsZcuWJS4uDoCIiAjDCN3ly5fx8fFhwIABhuTN0dERlUqV4bMLCAhAp9MxfPjw534Pbm5uqFQqVCoVWq0WjUbDgQMHaNKkCUC6Z3gqPj6eTp064evri7+/P5CWiA0dOpS6desyceJEhgwZgqenJ1OnTn1uH14mSaCEEEIIIUS+S42PJz4sLM+v1Pj4TOOnpKSwZs0aOnTokOl5d3d3du7cCcCOHTuIiIjA3d2d0NBQFEUxHHNwcODGjRtERkYSFhbGpUuX0Ov1ODs7c+jQIWJjYzl48KDh/vyOGRkZyalTp6hfv76h7xEREYbNX21sbAxT8AD8/Pzw9/enadOmWX72pUuX5vTp01SuXJnly5fTtm1bAC5dusSePXsoVqwYc+bMyfL+sWPHMmfOHEJDQ0lOTubIkSNZXvtvGzdupGzZstjb22f7DADz58+nTp067N69m+3btxuOt2/fnoMHD7JgwQJ69uzJvn37WLFihVHtvywmr7oDQgghhBDi7ZN45QrX3n0vz3Fc16/DolKlDMdXrFhB+/btMx19AujduzcDBw7E398fV1dXHB0dqVq1Kl5eXuh0OurWrYujoyNqtZrJkyfTunVrXF1d8fT0RKvVMnXqVAYPHoxarcbd3R1HR0fq16+f7zFnzJjB4MGD0/Xdzs6OS5cuAWnJVKFChQzndu3axY0bN2jdunWWSdSyZcvQ6XR8/vnn/Prrr0yYMIHJkydjb28PwPvvv8+kSZOy/MzPnz9Pr169gLTphY0aNUKlUhnWfZ07dw6dToeDgwNr164F4OTJk8yYMYMtW7YYnuHperBnn+FpjKdt/Ps7rFq1KiqVCkdHR6pVq2YY1XqdSAIlhBBCCCHynVmpUriuz/u6F7NSpTI9fubMGY4fP86KFSu4ePEiw4cPZ/r06YbzlpaWLF26FEhLplq2bAnARx99xEcffcTSpUupWrUqAM2aNaNZs2ZcuHCBGTNmAGmjOH/88QdxcXF07tyZihUrolar8z3mlClTOHDgAAAXL15k8uTJ9OrVi6lTp/L5558THByMl5cXiqKQnJyMVqvFysrKMLqTlacJi62tLREREcTGxmJubo5Go2HPnj2UKVMmy3vLly/PtGnTKFmyJIqikJKSgomJCaGhoUDaGqinnwPA3bt36devH+vXr8fCwgIAT09PvvvuO7p37254hn9zd3dn37591KpVi9TUVEMS9e/phM9OLXxdSAIlhBBCCCHyndrCItORo/wyZcoUw79r1aplSJ769etHUFAQJ06cYNiwYWg0Grp3746rqyuQts7GxMSEatWqGdbWDBs2jJMnT2Jvb8+8efMAWLp0KcuWLcPExIQpU6agVqtfSMynBR6ePsdHH30EQKtWrfDy8sLOzo6VK1eSnJxM48aNUalUpKSkGEaQQkND+frrr7lw4QL+/v4sX76cLl260KlTJ9atW0dycjKLFy/m4sWL9OzZEysrK+zs7Fi+fDmQtv5q+fLlPHz4kNu3b7Nq1SqmTJlC//79SUxMRK1Ws3jxYlxcXLL8LsaPH8/9+/fp3LkzkFbAw8PDA0dHR7y9vXFxcWH06NHp7unTpw+BgYGGpCs4ODiHv4BXR6UoivKqO5EfoqKisLGxITIy8rkZuRBCCCGEyF8JCQlcvXoVNzc3zM3NX3V3xH/Ms7+/F5kbSBEJIYQQQgghhDCSJFBCCCGEEEIIYSRJoIQQQgghhBDCSJJACSGEEEIIIYSRJIESQgghhBBCCCNJAiWEEEIIId5IoaGhNGrUCF9fX37//fcM53/55RcaNmyIj48Phw4dAuD06dMEBATg6+tLUFAQkLbRa6dOnfDz86N///4AKIrCuHHj8Pf3x8fHB71en+eY48ePp0qVKuh0OsOmtPHx8bRs2RJfX18aN27M48ePuXHjBjqdDp1OR7Vq1WjXrh0Au3fvpl69enh5efHPP/8AcOrUKRo0aIC3tzerVq0C4PLly3h4eGBubk5MTAwADx8+xMvLC19fX/z8/Lhz547hc4qJicHBwYHNmzfn6ntYsmQJ9evXp169ekyePNlwfNSoUXh7e9OlSxeSkpJyFfu1pLwlIiMjFUCJjIx81V0RQgghhPjPiY+PV86cOaPEx8e/tPZatmypJCYmZnr+9u3bSseOHZXU1NR0x1u2bJnh78UhQ4Yox44dS3ds7dq1ysyZM/M15hdffKFs2rQp3bH169crY8eOVRRFUebPn6/MmDEj3fmvvvpKWbp0qaIoitKgQQPl8ePHyvXr15WmTZsqiqIoLVq0UC5evKgkJycrPj4+Snx8vBIbG6tEREQovr6+SnR0tKIoipKcnKwkJycriqIoS5cuVSZMmGBoY+LEiUpAQECGvmWlR48e6d5fuXJFSU1NVVJTUxUvLy8lPDxcOXbsmNKlSxdFURTl66+/VlauXGlU7Nx69vf3InMDGYESQgghhBBvnP3792NhYUGrVq1o164d9+7dS3d+27ZtmJmZ0bhxY7p160ZMTAxXrlxBr9fTtWtXAgICOHfuHADHjx9nzpw56HQ6NmzYAMDGjRu5fv06Op2OL7/8Ml9iAnz++ef4+vqyc+dOAMqWLUtcXByQNmrl4OCQ7jl+//132rRpQ1xcHFqtFjs7O1xcXHjy5AkA4eHhlClTBo1Gg7OzM6dPn8bS0hIbG5t0cTQaDRqNBkjbP7Vy5cqGf586dQpPT0/DtVeuXCEgIACdTsfw4cOf+124ubmhUqlQqVRotVo0Gg0HDhygSZMmADRt2pT9+/enuyc+Pp5OnTrh6+uLv78/kLYh8dChQ6lbty4TJ05kyJAheHp6GjYnfl1IAiWEEEIIIfKdPimFBzei8/zSJ6VkGj88PJyrV6+yadMm+vbty/jx4zOcj4iIICQkhPr16zNr1izCw8MJCwtjxYoVfPfdd4wYMQKAQ4cOMWDAADZv3syECRNITEwkPDycEiVKEBoaypkzZzh48GCeYw4ZMoRjx46xZs0ahg0bRlJSEqVLl+b06dNUrlyZ5cuX07ZtW8MzXLhwgSJFimBra0tERES6DWFNTExISkrC2dmZQ4cOERsby8GDB4mIiMjyOzl16hR169Zl1qxZeHh4ADBz5kwGDx6c7rqxY8cyZ84cQkNDSU5O5siRI0Z95xs3bqRs2bLY29un66+NjQ2PHz9Od+38+fOpU6cOu3fvZvv27Ybj7du35+DBgyxYsICePXuyb98+VqxYYVT7L4vJq+6AEEIIIYR4+0Tci2PNN4fzHKf9x7VxcCmY4bitrS0NGjTA1NSUhg0bMmnSpAzn/fz8UKlUNGzYkIkTJ9KmTRtq1aqFtbU1lStX5uHDhwC4urpSo0YNAMqXL8/t27extbWlUaNGADRs2JAzZ87kOWapUqUAKFq0KO7u7ty6dYvg4GB0Oh2ff/45v/76KxMmTDCsI1q7di3vv/8+AHZ2dkRFRRmeLzk5GVNTU6ZOncrgwYNRq9W4u7vj6OiY5WdZpUoV/v77b9asWcPkyZOZMmUKJ0+e5LPPPiMkJMRw3fnz5+nVqxcA0dHRNGrUCJVKZVi3de7cOXQ6HQ4ODqxduxaAkydPMmPGDLZs2ZKhvxERERQqVChdX86dO2doQ63+/zGdqlWrolKpcHR0pFq1aoZRrdeJJFBCCCGEECLf2Tpa0v7j2vkSJzN16tRhxowZQNp0uafJyVNeXl5Mnz493fmyZcvy4MED9Ho94eHhhhGSypUrc/XqVVxcXLh8+TKOjo54eXlx4sQJqlWrxvHjx+nYsSOFChXKU8yoqCisra2Ji4vj3LlzFCtWDMCQXDwdaXrq999/Jzg4GAALCwv0ej1PnjwhOjoae3t7AEqXLs0ff/xBXFwcnTt3pmLFipl+XklJSZiamgJpI0IFChTg3Llz3Lx5k6ZNm3Lp0iU2bdpE9erVKV++PNOmTaNkyZIoikJKSgomJiaEhoYCEBgYyNKlSw2x7969S79+/Vi/fj0WFhYAeHp68t1339G9e3eCg4Px8vJK1x93d3f27dtHrVq1SE1NNSRRKpXKcM2///06kQRKCCGEEELkO62pJtORo/xib29P69at8fHxQa1Ws3jxYgD69etHUFAQVatWpVixYuh0OiwsLFi5ciUmJiaMGDECPz8/UlNT+eGHHwCYOHEiPXv2JD4+nv79+2NpaUmvXr0IDAxk8eLFuLu7o9PpAPIUs1+/fpw6dYqUlBTGjRuHhYUFXbp0oVOnTqxbt47k5GTDc1y8eJHChQtjZ2dneOavv/6a5s2bo1armTNnDgBLly5l2bJlmJiYMGXKFNRqNU+ePOH999/nn3/+oVWrVowZM4YiRYowfPhwNBoNlpaWLFq0CEdHRw4ePAikVQisVasWTk5OTJkyhf79+5OYmGj4bF1cXLL8LsaPH8/9+/fp3LkzAEFBQXh4eODo6Ii3tzcuLi6MHj063T19+vQhMDDQkHQ9TRTfBCpFUZRX3Yn8EBUVhY2NDZGRkenmhwohhBBCiBcvISGBq1ev4ubmhrm5+avujviPefb39yJzg7eyiIQ+Rc/QnUM5fC/v826FEEIIIYQQ4qm3MoGKT4knVh9L3+19WXVuFW/JIJsQQgghhBDiFXsrEyhrU2tmFBlIp7Lt+ebvbxh/YDxJKW/R7sdCCCGEEEKIV+KVJVBxcXGULFmSUaNGAXDz5k10Oh0VK1akatWqhpKIuZH86BG3PuhF5zX3+arueDZd3kTP4J48iHuQX90XQgghhBBC/Ae9sgRq4sSJ1K1b1/DexMSEGTNmcObMGXbs2MHw4cOJjY3NVWyTAlqK61KI3r6dWj/uZGmjhdyJuUPHzR059eBUfj2CEEIIIYQQ4j/mlSRQFy9e5Ny5czRv3txwrFixYlSvXh2AIkWKUKhQoQw7FhtNY4p1q/dw8npEzK6d2H0yjVVNluNo5UjgtkA2Xt6YD08hhBBCCCFeldTUVHr06IG3tzc+Pj5cvnw53fmQkBAaNGhAgwYN6NatGykpKTx8+BAvLy98fX3x8/Pjzp07AHTo0AFfX1/q1KnDrl27AJg8eTK+vr7Url3bsN9UXmNOnDiR+vXrU7duXZYtW5bjmOvXr6d27drUrVuXBQsWAKAoCuPGjcPf3x8fHx/0er3hM5g0aRK1atUyvG/cuDG2trZs3rzZcGzVqlV4enri6+tLWFhYrr6LJUuWUL9+ferVq2fYBBhg1KhReHt706VLF5KS3qLlNEoO7d69W2nZsqVSrFgxBVB+++23DNfMnj1bcXV1VczMzJQaNWooe/bsSXe+devWyvnz55UlS5YoI0eOzHD/4cOHlUqVKuWoX5GRkQqgREZG/v/BO/8o0WPrKGfdyyvX2/oq8Y/vKp/99ZlSeWllZdrhaUpySnKO2hBCCCGEEJmLj49Xzpw5o8THx7+U9o4ePap06NBBURRF2b59uzJs2LB05xMTEw3/DgwMVPbs2aMkJycryclpf/8tXbpUmTBhgqIoipKUlKQoiqJcu3ZNadiwYbpjycnJSsWKFZXk5OQ8x7x8+bKhb5UqVVJSU1NzFLNmzZpKZGSkotfrlapVqyqKoihr165VZs6cmeHziYqKUjp37qzUrFnTcOzOnTvKF198oWzatElRFEXR6/VK9erVlaSkJOXWrVtKq1atnvOpp+nRo0e691euXFFSU1OV1NRUxcvLSwkPD1eOHTumdOnSRVEURfn666+VlStXGhU7t579/WWaG+STHI9AxcbGUq1aNWbNmpXp+dWrVzNs2DA++eQTjh8/jre3N82aNePGjRtA2o7K5cqVo1y5cpne/+jRI7p37878+fNz2rWMilXFauI+nIe1IO7CPe6/35Av7LwZW3ssy88sZ+iuocQkxeS9HSGEEEII8VI5OTkBaSMwERERODg4pDtvampqOK8oCm5ubmg0GjQaDZC2h2jlypUB0Gq1hmNVqlRJdywhIYFSpUqh0WjyHLNUqVKGcyYmJjnuZ4UKFYiOjiY+Ph4bGxsANm7cyPXr19HpdHz55ZeG5585cyaDBg1K95kUK1Ys3ftHjx7h5OSEVqulRIkSXLhwAYArV64QEBCATqdj+PDhz/0u3NzcUKlUqFQqtFotGo2GAwcO0KRJEwCaNm3K/v37090THx9Pp06d8PX1xd/fHwCdTsfQoUOpW7cuEydOZMiQIXh6ejJ16tTn9uFlynEC1axZM77++mveeeedTM9///339OrVi969e+Pu7s6MGTNwdnZm7ty5ABw8eJBffvkFV1dXRo0axYIFC5gwYQIAiYmJtGvXjnHjxlG/fv1s+5GYmEhUVFS611PJ+hR2rTjH47uxoDGhQN/vcJ4+ibhwuNW/H53D9jPb+1uOhh+l2x/duB1zO6cfgxBCCCGEyIY+MYHwK5fy/NInJmQav3DhwqjVatzd3RkzZgyBgYEZrvnpp5+oVKkSDx48MCRYp06dom7dusyaNQsPDw/DtX5+fvj7+9O0aVPDsZEjR1K2bFnq1KmTbzEBfvjhB9q3b49KpcpRzPfff5/atWtTsWJFw/OGh4dTokQJQkNDOXPmDAcPHiQyMpJTp0499+9pBwcHbty4QWRkJGFhYVy6dAm9Xs/YsWOZM2cOoaGhJCcnc+TIkWzjPLVx40bKli2Lvb09ERERhg1sbWxsMizNmT9/PnXq1GH37t1s377dcLx9+/YcPHiQBQsW0LNnT/bt28eKFSuMav9lUSlK7jdJUqlU/Pbbb7Rt2xaApKQkLC0tWbt2Le3atTNcN3ToUE6cOMHu3bvT3b906VJOnz7NtGnTUBSFzp07U758ecaPH//ctsePH58uy34qMjISM60lv049ij4xhffG1sLSOi2zjzt8mJt9emFmHY9zcxOuN/+UQRdXEKuPZYbfDGoUrZHbj0IIIYQQ4j8tISGBq1ev4ubmhrm5OeFXLrFi3LA8x+06aQZFS5XJcPyPP/5g3bp1LFq0iGPHjvHtt9/yyy+/ZBpj0KBBeHt707FjR8OxNWvWsHPnTubNm2c4duPGDVq3bs2JEyfSPVeDBg3YuHEjxYsXz3PMkJAQ5s6dy7p161Cr049lPC9mpUqV2Lt3L1ZWVjRq1IiNGzfSv39/Pv74Y6pVq0ZQUBBarZabN2/SsGFDvL29qVWrVroEaPz48dSqVYuWLVsaPsfJkyfj6urK5cuX+euvv6hatSqFChUCIDo6ms8++wxnZ2dGjhwJwLlz56hQoQIODg6GytknT55k2LBhbNmyBQsLC+bOnUuBAgXo3r07R44cYenSpelmsA0YMIBevXqlW6Ol0+nYtGkTBQsWxNPTkwMHDqBSqTI8Q2ae/f1FRUVhY2NDZGSkIZHLLyb5Gezhw4ekpKRQtGjRdMeLFi3KvXv3sr133759rF69mqpVq7JhwwYgLRt/OuT5rHHjxjFixAjD+6ioKJydnQEwszCh5eBqrJtyhC2z/6HtiBpozTRY1q6Ny9Ll3OjVi5s7FFyjB7GqVgeGW8fRa3svvqj3BW3LtM39ByCEEEIIIQAoVMKJrpNm5EucrNjZ2QFga2tLREREunOJiYmYmZkBYG1tTYECBUhKSjJMmbOxsaFAgQIoikJycjJarRYrKyvDH9tP7zczM8PS0hILC4s8xwwLC+Orr75i69athuTJ2JiQNt3PysoKU1NT1Go1CQkJeHl5ceLECapVq8bx48fp2LEju3bt4sCBA0Ba8bbJkyfz0UcfZfoZNmvWjGbNmnHhwgVDsYzy5cszbdo0SpYsiaIopKSkYGJiQmhoKACBgYEsXbrUEOPu3bv069eP9evXY2FhAYCnpyffffcd3bt3Jzg4GC8vr3Tturu7s2/fPmrVqkVqaqrh83g6Kvfsv18n+ZpAPfXswyqKkukH8O+h1gYNGpCammp0G09/0FkpWMicloOq8et3x9i+KIxm/augVquwqF4dl0WLuNGrNzdO18bFdAvzC1ozsaIXn+37jMsRlxlWYxgatcbovgghhBBCiPS0ZuaZjhzllyZNmvDTTz/h6+tLYmIi33//PQD9+vUjKCiI5cuXs3LlShRFoUKFCrRo0YLjx48zfPhwNBoNlpaWLFq0iOTkZBo3boxKpSIlJYVJkyYBMGLECMLCwtDr9XTv3h07OzsWLFiQ55iPHj0yjP78/vvvrFmzxqiYAKNHj8bb2xuVSkWTJk0oVqwYvXr1IjAwkMWLF+Pu7o5Op0On0xk+p1q1ahmSp549exIaGsqGDRs4ffo0H330EcOGDePkyZPY29sbRs6mTJlC//79SUxMRK1Ws3jxYlxcXLL8LsaPH8/9+/fp3LkzAEFBQXh4eODo6Ii3tzcuLi6MHj063T19+vQhMDDQkHQFBwfn9Sfx0rzSKXz5KathumunHrJ1zkmq6Jzw7vD/hSvijh/nZq/emJcvjXOjBFS3drOyoh9TE66ic9IxyXsSllrLF9ZfIYQQQoi3ybNTqIR4mV7mFL583QfK1NSUmjVrEhISku54SEjIcxexvSiuVQrj06k8J3fd4p8/bxqOW3p44LxwIQnnL3Nzjx1K46l0vXSEHyP1HLj9Fx8Ef8D9uPuvpM9CCCGEEEKI11OOE6iYmBhOnDhhWAh39epVTpw4YShTPmLECBYuXMjixYs5e/Ysw4cP58aNG/Tv3z9fO54TlX1K4NHEhb/WXeTK8QeG45Y1PHBeuID406e5OX8/qT134mNdhuU3r/PwyWU6b+nE+cfnX1m/hRBCCCGEEK+XHCdQR44cwcPDw1BOccSIEXh4ePD5558Dabsuz5gxgwkTJlC9enX27NnD1q1bKVmyZP72/DmiHz3k37MT67UtTZkaRdi+OIx7VyMNxy1r1MBlfhDxp05x86NJpL63igqNvuHnW3coFH2f7lu7sOfWnpfadyGEEEIIIcTrKU9roF4n/57naKKksnhYPzzf6UCtVv+/X1WyPoWNM04QcT+O98bWwrqwheFc3OHD3OjbD0uP6jjNmYM65hZxG/oyVn+DPZYWfFRrDJ0qdXsVjyaEEEII8dqTNVDiVXpj10C9LixtbKnSKIC9q5Zx+/xZw3ETrYbmA6piam7C5tknSYxP/v97atfGOWgecceOc2vIEFKtXbD8YDszKvWjS1QM3xz5lim7RpOSmvIqHkkIIYQQQgjxGngrEyiABh2741i6HJtnTiEu6v+n7JlbaWkxqCpxkYkELzhNasr/l04vUKcOznNmE3fwb24PH4GSqqDxGc2Y9zfySZI5P1//g5G/tiE+KeZVPJIQQgghhPiflJQUunTpgk6nIzAwEL1en+58VFQUrVu3xs/Pz7ABLMDw4cPx8fGhXbt2REVFAbBq1So8PT3x9fUlLCwMgFOnTtGgQQO8vb1ZtWpVvsQ8e/YsXl5e+Pj40KdPHwDi4+Np2bIlvr6+NG7cmMePHwMwffp0vLy8aNmyJZGRaX/LRkRE0KlTJ/z8/Az1BSZPnoyvry+1a9c27OO0ceNGQznzkiVLMnPmzCxjvvvuu3h7e+Pl5cXRo0dz9V0sWbKE+vXrU69ePSZPnmw4PmrUKLy9venSpQtJSUm5iv1aUt4SkZGRCqBERkYajkU9fKDM6tVJWf/N50pqSkq662+cfaTMGbBTCf35nJKampruXHRoqHKmchXl5tBhSqpen3ZQn6CEbuyj1F5cUem8pIby6O4/L/yZhBBCCCHeFPHx8cqZM2eU+Pj4l9LemjVrlE8//VRRFEWZMmWK8ssvv6Q7/+233yoLFy5UFEVRBgwYoBw8eFA5dOiQ0rVrV0VRFGX16tXK5MmTFb1er1SvXl1JSkpSbt26pbRq1UpRFEVp0aKFcvHiRSU5OVnx8fFR4uPj8xzzww8/VP744w9FURSlc+fOyokTJ5T169crY8eOVRRFUebPn6/MmDFDuX//vuLn56ekpqYqK1asUCZOnKgoiqIMGTJEOXbsWLrnTEpKUhRFUZKTk5WKFSsqycnJ6c77+/srV69ezTLm5cuXFUVRlPPnzyvNmzc36rPv0aNHuvdXrlxRUlNTldTUVMXLy0sJDw9Xjh07pnTp0kVRFEX5+uuvlZUrVxoVO7ee/f1llhvkl7d2BAqgoH1hmg8eydUTRzm0cX26c84VCuHTqRynd9/mVOitdOesfH1xmv490SEh3Pn4Y5SUFDAxw7fVfJbU+oTbShJdt3Tk2t8/wtuxhEwIIYQQ4o1y5coVqlevDkCNGjXYu3fvc89nduzRo0c4OTmh1WopUaIEFy5cACA8PJwyZcqg0Whwdnbm9OnTeY5ZsWJFIiMjURSF2NhYChUqRNmyZYmLiwPSRpgcHBw4fPgwOp0OlUpF06ZN2b9/PwDHjx9nzpw56HQ6NmzYAIBWqwXS1gCVKlUKjUZj+AwePnxIbGwsrq6uWcYsVaqUIY6JiYnhswsICECn0zF8+PDnfhdubm6oVCpUKhVarRaNRsOBAwdo0qQJQLr2noqPj6dTp074+vri7+8PgE6nY+jQodStW5eJEycyZMgQPD09mTp16nP78DK91QkUgFv1mtRt1559q3/i1tnT6c5V8i5BdX9n/lpzkWunHqY7V9DfnxJTvyVq8xbujR+Pkpo21a9Slc6sbL0WE1MruoXN5cQv70Lso5f2PEIIIYQQb4LUpBSSbsfk+ZWalPn6c3d3d3bu3AnAjh07iIiIeO55d3d3QkNDURTFcMzBwYEbN24QGRlJWFgYly5dQq/X4+zszKFDh4iNjeXgwYOG+/MS09/fn48//hh3d3dsbGxwdnamdOnSnD59msqVK7N8+XLatm1LRESEofCBjY2NYVrfoUOHGDBgAJs3b2bChAkkJiYCMHLkSMqWLUudOnXSfQa//vor7dq1A8gy5lOjR49m9OjRAIwdO5Y5c+YQGhpKcnIyR44cMeo737hxI2XLlsXe3v657c2fP586deqwe/dutm/fbjjevn17Dh48yIIFC+jZsyf79u1jxYoVRrX/spi86g68DPXf78Lt82fYMvNbuk35AUsbW8O5eu+UIeJ+PNsXhfHu6JrYl7AynLNu3hxFr+fOR+NQaU0p+tmnqFQqSthX4Kf2IQzd0pVeUReYtMiLJs1nQRn/V/B0QgghhBCvn+QH8dz/8Xie4xT50APTf/199lTLli3ZtWsXfn5+VK5cGUdHx3Tne/fuzcCBA/H398fV1RVHR0eqVq2Kl5cXOp2OunXr4ujoiFqtZvLkybRu3RpXV1c8PT3RarVMnTqVwYMHo1arcXd3x9HRkfr16+cp5ieffMKSJUvw8fFhyJAhbNu2jatXr6LT6fj888/59ddfmTBhAr6+vly6dAlIS3wKFSoEgKurKzVq1ACgfPny3L59m1KlSvHdd98xceJEGjRoQK9evShevDgA69atIygoCAA7O7tMYwJ88cUX1K1blwYNGgBw/vx5evXqBUB0dDSNGjVCpVIZ1n2dO3cOnU6Hg4MDa9euBeDkyZPMmDGDLVu2GNp7uh7s2faexnjahlr9/2M6VatWRaVS4ejoSLVq1QyjWq+VfJ8U+Io8b55j9KOHypw+XZS1X3+qpKSknxuaGK9XVn31t7Js3D4lNjIxw72P16xRzpSvoNybPCXdeqnE5ERl9I4PlSpLKytLvyuhKFvHKkrSy5n3K4QQQgjxOnl2DUpKYrKSeCs6z6+UxOTntKwoX3zxhbJ3794sz/fq1Uu5evVqumNLlixRfvrpp3THzp8/rwwYMCDdsdjYWKVNmzZKyjPr6XMTs3379sqpU6cURVGUzz77TFm1apUyZ84c5ccff1QURVH+/PNPpV+/fob1SoqiKCtWrFC++eYbRVEU5d1331WuXLmiJCcnK7Vr11ZiY2OVhIQERVEUJTU1VfH29lYeP36sKIqiPHjwQPH09DT0I6uYP/30k9KzZ890fX7vvfeUa9euGeLqn9YE+J9n10DduXNH8fT0VG7fvm049uwaqJ9//jndPTNnzlRmzJihKIpi+Gx9fX2V6OhoRVEUpW7duoZra9asqTzPy1wD9daOQOkfxGFSyAKVRgWAVSF7mn84inUTP+Pv39ZQ791OhmtNzU1oMbAq6yYfYevck7Qd4YGJ9v/nj9q9/z5KUhLhX32N2tIShw8Hp92nMWVywxkUPzqTaWGLCb+0hlFXQ1G/uwiKVnq5DyyEEEII8RpRm2oyHTnKL/fu3aNjx46YmJjg7+9vGD3p168fQUFBnDhxgmHDhqHRaOjevTuurq5A2jobExMTqlWrZlhbM2zYME6ePIm9vT3z5s0DYOnSpSxbtgwTExOmTJmCWq3Oc8yPP/6Y/v37o9FosLOz4+OPPyYpKYlOnTqxbt06kpOTWbx4MQ4ODrRq1QovLy/s7OxYuXIlABMnTqRnz57Ex8fTv39/LC0tGTRoEGFhYej1erp3746dnR0Av/32m2H6HpBlzF69elGrVi10Oh1ubm4sWbKEKVOm0L9/fxITE1Gr1SxevBgXF5csv4vx48dz//59OnfuDEBQUBAeHh44Ojri7e2Ni4uLYXrgU3369CEwMJD169djYWFBcHBw7n4Ir8BbuZFuAbU596YcpmBDF6z9nNNdt3/tSg6uX837n32Nc6Wq6c6FX4vit++OUbqGA/6BFVGpVOnOP1ywgAfffU+RMWOw7/lBunOrzq1i0t+TaJKs4Zs7tzFtPAHq9oNnYgghhBBCvI1kI13xKslGunmksTKlQP3iRO24jj48Nt05z3c74lSxMlt/nJZufyiAoq7WNOxegQt/h3N8+40McQv36YN9/37c//ZbnvyyOt25ThU6MV03nVAzDf1LuxO1/SNY+R5Eh+f/AwohhBBCCCFeibcygQKw8S+Jib05j9deQEn5/0E2tVpD88EjSUlOZtuc6Tw7AFeutiM1m5bkwIbLXDv58NmwOAwdil23btz78ksiN25Md65RyUYsaLKA86pkerjX4V74SZhbD87/8WIeUgghhBBCCPFSvbUJlEqrptD75dHfjiF6zzP7PBWyp+mg4Vw9foRjW3/PcG/d1qVwq1qY7YvCeHQnJn1clYqi4z7Cpl077oz7mKiQkHTnPYp48FOzn4hVQVdnZy6WqAKrOsLW0aBPyP8HFUIIIYQQQrw0b20CBWDqXJCCPk5pU/nupZ/KV8qjNjVbtmPPyqXcu3wx3TmVWoX/BxWxLmzO1jknSYjRP3NeTbGvJlCwSWPujBhJzF/70se2LcWK5iuwNS9ED9UDjvgOg6PLYEFDuH/2hTyrEEIIIcTr4C1ZXi/eMC/zd/dWFpH490IxRZ9K+I/HUJlqKDKguqEqH0BKsp5fPh9DfEw03Sb/gJmlZfqYD+NZO/kI9sUL0GpodTSa9PmmkpTErQ+HEPv337gsXIBlrVrpzsckxTBs1zCO3z/OlKqD8P8rCJ5cg4BvoFZPKTAhhBBCiLdGSkoKFy9exNLSEgcHhwzFuIR4URRF4cGDB8TFxVG2bFk0Gs0LLSLx1idQAEk3o7k/5wTWTVwzVOWLCL/HT2OH4OZRixZDRmf4z37n4hN+n34C9wbF0XUun6Hd1IQEbvbrT0JYGCWXL8O8YsX0back8fFfHxNyPYRPao2m/ZVjcGQRVGgJrX8Ey0IZYgohhBBCvIliYmK4deuWjEKJl06lUuHk5ISVVVrpfEmgjPC8Dynyj6tE/3Wboh96oHUskO7cuf172DLzW5r0H0IVvyYZ7j3z1x12rTiHT8dyVNE5ZTifEhPLjQ8+QH/7NiVXrMCslFu686lKKlMOTeHncz8zsNpA+ps6odr0IZhYwLsLwLVBHp9eCCGEEOL1kJKSgl6vf/6FQuQjrVaLRvP/+7hKAmWE531I2U3lA9ge9ANn/9pN10nTsXfKuFHY3tUXOLX7Nm2GVqdEebsM55OfPOF6t26kxsbhunIF2uLF07evKCw6vYiZx2byfrn3+cQ9EM1vA+DGfvAZAz6jQfPW7msshBBCCCHESyP7QOWD9FX5bmY47xfYF2uHImyeMQV9UmKG817vlaF4WVu2LThN1KP4DOdN7OxwWbQIlVrNjZ69SH70KH37KhW9q/RmQv0J/HrxV0Ydn05i17Xg+xHs+RaWtYLIWxniCiGEEEIIIV4f/5kECv5dle9Ghg12tWbmtBo2lif37rBnxZIM96o1agL6VEJrpuGPeafQJ6VkuEZbtCguSxaTEhvDjT59SImOznBNu7LtmOE3g72399Lvz4FE1R8AgVsg4jrMawDntubfAwshhBBCCCHy1X8qgQKw9i+JSSFznqy7iJKafvZiYRdXfLv14kTwZi4fPZThXgsrU5oPqEpEeBw7l5/NdIGkqYsLLgsXor91m5sDBpCakHHvJ52zjoVNFnLxyUV6buvJwyLloP9f4FIffukEW8fInlFCCCGEEEK8hv5zCZRKq8buvXIk3YomZt+dDOerN2lBqRq1CZ47g5gnjzOcL+xkRaMeFbl05D7Ht9/ItA3z8uVxDppHQtgZbg8dhpLJQsrqRaqztOlSniQ8odvWbtxMjoWOK6H5NDi6BBb5w8NLeX9gIYQQQgghRL75zyVQAGYlrbGqV5yo7ddIfmY9k0qlImDAMNQaDdvmTEdJTc1wf5maRajZrCQHNlzm+ulHGc4DWHp44DTrR2L27+fOuI8zjVPWrizLmy9Ho9bQ7Y9unH9yAer0gd5/gj4egnzg5Jr8eWghhBBCCCFEnv0nEygA6wBX1AW0PPn1YoapeJbWNjQdNILrJ49zdMuGTO+v26oUrpXt2b4ojIjwuEyvsfLyosTUqURt2UL4pMmZTvkrYVWCZU2XUcSyCB9s+4Cj4UehWFXouxvcW8GvfWDDIEiKzaQFIYQQQgghxMv0n02g1GYa7N4pS+LlSOIOh2c471rVg1qt3mHvquWEX8k4lU6lVuHfsxKW1qZsnXuSpPjkTNuxbhqA4xdf8OSnn3g0b16m19hb2LM4YDEV7SvSL6QfoTdDwcwK3gmCtnMh7FeY7wfhZ/LyyEIIIYQQQog8+s8mUADm5eywrFmUiC1XSInMWLq8QcduFHYpyZYfpqLPpBiEmYUJzQdUITYikZAlZzIUpXjKrmMHHIYO4cHMH3jyyy+ZXmNlasVs/9l4l/Bm2K5hbLi0Ie1E9c7QNxTUGljgB0eXwtuxdZcQQgghhBBvnP90AgVg28INlamaJxsuZZhipzHR0mLIaKIfP2TXsvmZ3m/nWIDGvSpx7dRDjvxxLct27Pv3x65bN+59OYGobdsyvcZMY8Y032m0LdOWz/Z9xrKwZWknHMpDn51QrSNsGgrre0FCVK6eVwghhBBCCJF7//kESm2pxa5NGRLOPib+5IMM5wsVd6JhYD9O7dzOhYN/ZRrDtUph6rR049Dmq1w7+TDTa1QqFUXHfYR1y5bcHj2G2P37M71Oo9bwRb0v6F2lN9OOTOOHYz+kJXZaC2g1E95bDBe2w3wd3D2Z6+cWQgghhBBC5Nx/PoECsKhcGIsqhYnYeJmU2Iwlxyv7NaZcXS+2z/+R6EeZJ0i1mrniWqUwIYuzLiqhUqsp/s1ECtTz5ObgD4k/dSrz61QqhtYYysiaI1lwagFfH/yalNT/bdxb+V3otxtMLWGhPxxeJFP6hBBCCCGEeEkkgfof29alUVIhYtPlDOdUKhX+fQejNTNn25zvMy1JrlKr8P+gIpY2Zmydd4qkhMyLSqi0WpxmzMC8XDlu9ulL4pUrWfYpsHIgX9b/knUX1/HR3o/Qp/wvubMvDb12QI1usGUErOspU/qEEEIIIYR4CSSB+h9NQVNsW5Yi/sQD4s9n3EDXwqogTQcO58bpkxzd+numMZ4WlYh5ksDOZWczLVsOoLa0xHneXDSF7bnRuzf68IxVAJ96p+w7TPOdxp83/uTDXR8Sn/y/fau05tDiO3hvCVwMgfm+cPefnD+4EEIIIYQQwmiSQP2LZY0imJW1JeK3S6QmpmQ4X7JKdWq2aMtfq5Zx/1rmI0d2jgXwD6zI5eMPOBZ8Pcu2NLa2uCxcCArc7N2HlMjILK9tXLIxsxvN5lj4Mfpu70tk4r+urfzO/6b0WcHCxnB4oUzpE0IIIYQQ4gWRBOpfVCoVdm3LkBqrJ2r7tUyvadCpB3bFndj64zSSk5IyvaZUdQdqNXfl4O9XuBH2KMv2tI6OuCxcQPL9+9wcNIjUTEqlP1WveD0WNlnIlcgr9AzuycP4f63Fsi8NvUKgRnfYMjKtSl9itFHPLIQQQgghhDCeJFDPMLG3wNq/JDH775B0M2MSYqLV0uLDUUSE32XvqmVZxqnd0o2SlezZviiMyAfxWV5nVro0TvPmknA6jNujRqEkZ752CqCqQ1WWNV3Gk4QnBG4L5E7Mnf8/qTWHFtPSpvQ9rdJ377RRzyyEEEIIIYQwjiRQmbBqUAJtsQI8+fUiSkrGghGFXVzx6RzIsa2/c+2fY5nGUKtVNO5ZEfMCWv4IOoU+KeOUwKcsPTwoMWM6MbtCufflhCzXTgGUsSvDsmbLSE5Npvsf3bkS+cxUwqdT+kwsYGEjOLZcpvQJIYQQQgiRTySByoRKo8LunbLo78USvfd2ptd4NG1FyaoebJs7g/jozCvgmVlqada/CpHhcexeeT7bxKigTkexr78mYu1aHv44K9v+ORd0Znmz5Vhprfhg2wecfXQ2/QX2paF3SNrGuxs/hA0DICk2+4cWQgghhBBCPJckUFkwdSqIVYMSRO24QfLDjFPwVGo1TQcMI0WvJ2T+rCyTI/sSVvh1q8D5v+9xenfmydhTtu3a4jByBA/nzOHxzz9ne20RyyIsbbqUYgWK0TO4J8fCnxkJe7rxbrv5cOZ3WNAQ7p/L/qGFEEIIIYQQ2ZIEKhvWjUuiKajlyYZLmSZIVoXsadL3Qy4e2k9Y6I4s45Sr40hVPyf+WnuRe1eyrrYHYN+7N4V6dCf8q6+JCt6e7bW25rYsbLIQd3t3+oX046/bf2W8qFoH6BsKqGCBH5xck21MIYQQQgghRNYkgcqG2lSDXbuyJF6KIO7Y/UyvKVu3PpV0/uxcOp/I+/eyjFX/3TIUdbVmW9Ap4qIyr94HaZUAi4wdi3WzZtwZPZq4I0ey7aOVqRVzGs3Bs5gnH+78kO3XMkm6HMpDnz+hYhv4tQ9sGgr6rCv+CSGEEEIIITInCdRzmJezw9KjCJFbrpASk3ni49ejLxYFrflj9nRSUzMvFqExURPQtzKKAsELTpOaSXGKp1RqNcUmT8LCw4ObAweRcOFC9n00Med7v+9pUrIJo/eM5reLv2W8yLQAtJ0LrX6AE6tgUWN4nPleVkIIIYQQQojMSQJlBJsWbgBEbM484TCztKTZoOHcPn+GI5sySV7+p4CNGQF9KnPvciQHfrucbZtqU1OcZv2Itnhxbvbpi/7u3Wyv16q1fNPgG94p+w6f7/+clWdXZrxIpYKaPaD3jrR9ooJ0cHZTtnGFEEIIIYQQ/08SKCNorEyxaVGK+BMPSLj4JNNrnNwrU7vVO+xbvYL717Ie2Sle1pb675bhxI6bXDqa+bRAQ7sFC+I8PwiVRsONPn1Iicx+/ZRGreFzz8/pUbEHkw9NZsHJBZkXtyhWNa3UeSlfWN0Vtn0MKfpsYwshhBBCCCEkgTKaZY0imJWySSsooc98ml799l2xL+HEH7O/J1mfdUJStaETZWsX5c/lZ3l8J/vy4toiRXBeuJCUBw+5OWgQqYmJ2V6vUqkYWWskg6oP4ofjPzDj2IzMkyhzG2i/HJpOhkNBsLQFRGZfJVAIIYQQQoj/OkmgjKRSqbBtV4aUiESidt7M9BoTrZZmg0fy5M4t9q3+KdtYfl0rYG1vzrb5p0hKSM62bbNSbjjNm0vC6TDujBqNkpL1prxP4/ev1p8xtcew+PRiJv49kVQlkzVXKhV4DoAP/oDIWxDkDZd3ZhtbCCGEEEKI/zJJoHJA62CJtZ8z0XtuoQ/PfOTIoaQbXh26cWTzb9w8cyrrWGYamvatTExEIrt+OpftJrsAlh4elPj+O6L//JPwid8893qAbhW78WX9L1lzfg2f/vUpyalZJGrOdaDfXihWDX56B0KnQGrWRS6EEEIIIYT4r5IEKocK6pwxKWTOk98uoaRmnsTUbNkWpwqV2DZnOolxcVnGsnMsQKPu7lw6ep+TO289v+2GDXEc/wVPfv6ZRwsWGtXfd8q+w7c+3/LH1T8YtXsUSSlZlFAvYA9d1oHuIwidBCvfg9hHRrUhhBBCCCHEf4UkUDmkMlFj27YMSdeiiDsSnuk1arWGpgOHkxATza6l87ONV7pGEar7O7N//SXuXop4bvt27dtTeOBAHnz/PZG//25Un5u6NWWG3wz23trLkJ1DiE+Oz/xCtSYtgeq6Hu6eSJvSd/OwUW0IIYQQQgjxXyAJVC6Yl7bFsmZRIv64muXeUDZFiuIX2I+w3Tu4eGh/tvE825WmaClrghecznaT3acKfzgYm3ff4c4nnxK7P/vYT/k6+zLbfzbH7h9jwI4BxCTFZH1xmUbQbw9Yl4AlzeDvIDBiyqAQQgghhBBvO0mgcsmmuRsqFURuuZrlNZV8G1GmtichC2YTFxmR5XUajZqAPpVJVWD7ouw32YW0IhHFxo+nQL163PpwCAlnzxrVZ89insxvPJ8Ljy/QN6QvkYnZlEW3cYLALVC7N/wxBtb3gsRski4hhBBCCCH+AySByiVNAS02LUoRd/x+lntDqVQqGvcZDIpCyIJZ2RZ+KGBjRtM+lbhzMZK/N2a9j5QhtlaL04zpmLq6crNvP/S3jStBXr1IdRYGLORm9E16BvfkYfzDrC82MYVmk+G9JXAhGBb4wf1zRrUjhBBCCCHE20gSqDx4ujdURDZ7Q1na2NK4z2AuHT7ImT3ZlwgvXtaOem1Lcyz4BldOPHhu++oCBXAOmofKzIwbffuREhFhVL8r2ldkadOlPEl4wgfbPuBe7L3sb6j8DvTZBSo1LGgIp9YZ1Y4QQgghhBBvG0mg8kClUmHbtgzJ2ewNBVC2bn3cvf3YtXQ+UQ+zT4yqN3amlIcDfy49Q8T9rCv4PWVSuDDOC+aT8ugRNwcPfu5Gu0+Vti3NsqbLSEpJoscfPbgZlXX/AXAoB73/hArN06bzbR0Nyc9fryWEEEIIIcTbRBKoPNIWsaSg7n97Q2WT8DT8oB9ac3O2B/2Q7VQ+lUpFw+7uWBQ0JXjBaZKTst80F8DMzQ2nuXNIOHWaO2PGohi5h5OztTPLmi1Dq9ESuC2QK5HPmTpoZgXvLIAW38GRJWkFJiKfX35dCCGEEEKIt4UkUPnAWueMxtYsbSpfFsmReQErAvoP5frJ4/yzfWu28cwsTGjarzJP7sWxd/UFo/pg2Gh3+3buT/nW6L47FnBkadOlWJtZ88G2Dzj/+Hz2N6hUaYUlegZD9D0I8oHLu4xuTwghhBBCiDeZJFD5QKVVY9emDIlXIonPZu2Sa7UaVGvcnN0rF/Pk3p1sYxZ2Kohvp3Kc2XeXs/vvGtWPgo0aUfSTT3i8bBmPly83uv+FLQqzJGAJRS2L0jO4J6cenHr+TU4100qdF6sGP7WDPVPByJEvIYQQQggh3lSSQOUT83J2WFQtTMSWK6TGJ2d5nW/XnljZFmLb7OmkpmY/Pc+9fnHc6xdjz6rzPLxlXAnxQl27UKhnT8InTSYqeLvR/bc1t2VhwELcbNzoE9KHo+FHn39TAXvosg58x8DOr2FVR4jPvCKhEEIIIYQQbwNJoPKRbctSKPpUIoOvZXmN1tycpgOHc+fiOY5s+u25MX06lsOmiCXb5p8iKZvE7N+KjBqJdbOm3Bkzhrhjx43tPtam1sxvPJ9K9pXoH9KfA3cOPP8mtQb8PobOa+Hm3xDkC3dOGN2mEEIIIYQQbxJJoPKRxtoM68Ylif37Lkk3o7O8rkSFitRq2Y79a1bw4Ma1bGOamGpo2rcy8VFJ7PzpbLYFKJ5SqdUUmzwZiypVuDVgAIlXst7s91mWWktmN5pNLcdaDP5zMLtv7jbuxnJN0qb0WdjBoiZwzPgphEIIIYQQQrwpJIHKZ1b1iqN1LMCTDZdQUrNOdrzad8XWsTjbZk8nJTn7kSXbopY07OHO5WMPOLnTuKp3alNTnGbPQlO4MDf79iX5YTYb5j7D3MScmX4z8XbyZtiuYQRfCzbuRruSacUlqnWEjR/C74NBn2B0u0IIIYQQQrzuJIHKZyqNCtt2ZdDfiSH2QNaFIkxMTWk2aAQPblzl799WPzduaY8iVPN3Zv/6S9y7EmlUXzQ2NrjMDyI1MYGb/QeQGvf8faWeMtWYMs13Gk1cmzBmzxg2Xd5k3I1ac2j9A7SZDafWwuIm8OSa0e0KIYQQQgjxOpME6gUwc7GmQB1HIrdfJyUq681mi5YqQ912Hfj7tzWEX7n03Lj12pWmiKs1wQtOEx9j3Ca22hIlcJ43j8QrV7g9YiTKc0a7/s1EbcI3Db6hTek2fPLXJ6y/sN7oe/HoCr22Q3xE2rqoiyHG3yuEEEIIIcRrShKoF8QmwBWVVk3Eluw3p/V8pz32ziXZNmc6yXp9ttdqNGoC+lQiWZ/KjiVnsp0i+G8WlSrhNHMGMXv3Ev7NN0atozK0qdYwvv542pdvz/gD4/n57M9G30uxatBvNzjXgZXvw65JUupcCCGEEEK80SSBekHUllpsmrsR/88DEi5mXdpbY6Kl2cDhPL5zmwPrnp+cWNmZ07hnRW6ceczR4OtG98fK2xvHLz7nyc+reLx4idH3AahVaj6p+wk9KvZg0qFJLDmdg/st7KDT6rRKfbunwM/vQ9zjHLUvhBBCCCHE60ISqBfI0qMIZqVsiPj9Mkpy1iMvDiXdqPdeJw7/vp67F88/N65LRXtqNXPl0MYr3D5v/L5Ldu3bY9+vH/enTiVq2zaj7wNQqVSMrDWSvlX78v3R75n7z1zjR7LU6rS9orqug9tH/1fq3Pjy6kIIIYQQQrwuXnoCFR0dTe3atalevTpVqlRhwYIFhnPTp0+nUqVKVKxYkSFDhuRoqtnrSKVSYdumNMmPE4jek331vDpt3qNoqdL8MWc6+qTE58au3dKN4uVsCV4URmzk869/ymHYUKxbtuTOmLHEHTtm9H2Q9jwfenzIEI8hzDkxhxnHZuTsOyrjn1bqvIA9LAqAYz/lqH0hhBBCCCFetZeeQFlaWrJ7925OnDjB33//zaRJk3j06BEPHjxg1qxZHD16lFOnTnH06FEOHjz4sruX77RFC2DVoATRu26S/Djrkt5qjYamA0cQ9SCcfatXPDeuWq2icc9KqICQRWGkGrkeSqVSUeybiVhUr86tAQNJvGr8HlFP9anah9G1RrP49GK+PfxtzpIoWxf4YNv/Sp0PTit3LqXOhRBCCCHEG+KlJ1AajQZLS0sAEhISSElJMfwBnpycTEJCAnq9Hr1eT5EiRV52914I60YuqC1NiNh0Odvr7J2c8erQjaNbNnDrXNhz4xawMaNJr0rcuRjB4c3GJ0JqU1Ocfvzhf3tE9SP50SOj732qe6XufFr3U1acXcHXB78mVclBcYinpc5bz4J/VsPiAIi4keM+CCGEEEII8bLlOIHas2cPrVq1onjx4qhUKjZs2JDhmjlz5uDm5oa5uTk1a9Zk79696c5HRERQrVo1nJycGDNmDIULF8bBwYFRo0bh4uJC8eLF8ff3p3Tp0rl+sNeJ2kyDTctSJJx9TPzZ7JOVmi3aULxsBYLnzECf8PyRmRLl7ajTuhRHtl7jepjxiZDGxgbnoCBS4+O5OXAgqfHxRt/7VIcKHZhQfwJrL6zl832fk5KakrMANbr9r9T5YwjygUs7ctwHIYQQQgghXqYcJ1CxsbFUq1aNWbNmZXp+9erVDBs2jE8++YTjx4/j7e1Ns2bNuHHj/0cYbG1t+eeff7h69So///wz4eHhPHnyhM2bN3Pt2jVu377N/v372bNnT+6f7DVjUbkwZmVtidh0BUWfdaKhVmtoOnAYMU8es/eXZUbFrhlQEpdKhdix+AzR2UwTfJap0//2iLp4iTtjxqCk5DABAtqVbcc33t+w+cpmxv01juRU4/eZAqB4dei7G0rUhBXvwe6pUupcCCGEEEK8tnKcQDVr1oyvv/6ad955J9Pz33//Pb169aJ37964u7szY8YMnJ2dmTt3boZrixYtStWqVdmzZw87duygTJkyFCpUCAsLC1q0aJHtGqjExESioqLSvV5naQUlypASmUjUrpvZXmtXrAQNOnbn+B+buHXm9PNjq1X4f1ARE1M12xeGkZJifAJiUbkSJb6bRvSfO7n/7VSj7/u3lqVa8q3Pt4RcC2HMnjHoU7LfzyoDy0LQeS34joVdE+GXTmkb8AohhBBCCPGaydc1UElJSRw9epQmTZqkO96kSRP2798PQHh4uCHZiYqKYs+ePZQvXx5nZ2f2799vWBcVGhpK+fLls2xr0qRJ2NjYGF7Ozs75+SgvhLawBQV9nYjefQv9w+ynzNVo1ooSFSqybZ5xU/ksrEwJ6FOZ+9ei+Pv37DfvfVZBPz+KfvoJj5ct4/FPzy9gkZkmrk2Y7jed0JuhDA8dTmKK8ZUBgbRS537joPMauHEA5uvg3vOTRyGEEEIIIV6mfE2gHj58SEpKCkWLFk13vGjRoty7dw+AW7du4ePjQ7Vq1WjQoAGDBw+matWqeHp60rx5czw8PKhatSqlS5emdevWWbY1btw4IiMjDa+bN7Mf1XldWPs5o7ExI2Lj5Wyr16nUagIGDCP2yRP2rjJuKp9jKRs825bm+PYbXDv5MEf9KtS5M4U++IDwSZOI3rkzR/c+pXPW8WPDHzl49yBDdg4hPjnn66oo1yRtSp+pFSz0h5NrctUXIYQQQgghXoQXUoVPpVKle68oiuFYzZo1OXHiBP/88w8nT55kwIABhusmTpzI2bNnCQsL44cffsgQ59/MzMywtrZO93oTqLQabFuVIvHCE+JPZ5/k2DkWx7tTd45v28TNsJNGxa/e2BnXqoXZsSxn66EAioweRUF/f26PGEn8qVM5uvcprxJezGk0h+P3jzP4z8HE6eNyHqSQW1pxiYpt4Nc+sHU0JCflqj9CCCGEEELkp3xNoAoXLoxGozGMNj11//79DKNS/2UW7vaYuxcictMVUhOzL9zg0bQVJSpUInjeTJISnj+io1KpaNTDHa2Zhu0LT+doPZRKrab4t1MwL1+emwMGknTrttH3/ludYnWY5z+PsEdh9N/Rn5ikmJwHMbWEdvOgxXdwZAksawlRd3LVHyGEEEIIIfJLviZQpqam1KxZk5CQkHTHQ0JCqF+/fn429cazbVWalLhkondmv/9R2lS+ocRGRLD356VGxTYvoCWgd2XuX4vm4IacrYdSm5vjNGc2agsLbvbrR0oui3PUKFqD+Y3nc+nJJfqG9CUyMTLnQVQqqN0bPvgDIm5CkC9c25er/gghhBBCCJEfcpxAxcTEcOLECU6cOAHA1atXOXHihKFM+YgRI1i4cCGLFy/m7NmzDB8+nBs3btC/f/987fibzqSQOdZ+zkTvvY3+fvbT3Owci+PduQcngrdw47RxU/kcS9lQ753SnAi5wdUcrocysbfHOSiIlIcPufXhEJSk3E2fq+pQlQUBC7gRfYM+2/sQkRCRqzg414Z+u8GhPCxrBQdmQzbrx4QQQgghhHhRcpxAHTlyBA8PDzw8PIC0hMnDw4PPP/8cgA4dOjBjxgwmTJhA9erV2bNnD1u3bqVkyZL52/O3QEEfJzR2zy8oAeAR0BIn98pGT+UDqNbIGbdqhflz6RmiHuWsoINZKTecZs8i/tgx7n72+XP7l5VK9pVY1GQR4XHh9Nzek0fxxm/2m45VEei2ATwHQPDHsK4nJOZiaqAQQgghhBB5oFJy+5fxayYqKgobGxsiIyPfmIISAPHnHvNoaRiFulTAsopDttdG3LvLsjGDqeTrj3+vAdle+1RCrJ413xzG0tqUdiNroDHJWc4cuWkzd0aPpvCHg3EYNChH9/7b5YjL9N7eG2tTaxY2WYiDZfbPmq2w32DDILB1gQ4roHCZ3McSQgghhBBvnReZG7yQKnzCeBYVCqUVlNj8/IISto7F8O4UyD/bjZ/K93Q91IMb0Rz47XKO+2fTqiUOw4by8MdZRP7+e47vf6q0bWmWBCwhRh/DB8EfcC/23vNvykqldtBnJ6TqYYEfnNuS+1hCCCGEEELkgCRQrwHbVqVJiU0melf2BSUAPAJa4OReme1BM43aYBegqJs19d8pwz9/3uTqPw9y3D/7fv2wefcd7nz6GbF/H8rx/U+52riytOlSklKS+GDbB9yJyUNVvSIVoM8ucPOBXzrDnxMgNfsEVAghhBBCiLySBOo1YFLIHGudU1pBiQfZF5RQqdU06T8krSqfkRvsAlRt6JS2HmrZ2Ryvh1KpVBQbPx7LWjW59eGHJF7JWWW/f3Mu6MzSpksBCNwWyM3oPGyAbG6dNoXPfzz8NR1Wvgdxj3MfTwghhBBCiOeQBOo1UdDXCY2NcQUl7ByL06Bj2ga7t86cNiq+SqWiYXd3TM1N2L4wLEf7QwGotFqcZs7EpIgDN/v2I/lRLotBAMWtirOk6RJMNaYEbgvkWuS1XMdCpYIGw6Hrr3DnRFqp8zsnch9PCCGEEEKIbEgC9ZpQaTXYtipF4sUI4k8/PznxaNaS4uUrEjxvJvpE46bymRfQ0qRPJR5cj+bvHO4PBaCxtsYlKIjUhARuDRxEqpFTCDPjWMCRJQFLsNJa8UHwB1yJyP2oFgCl/aDfHihgD4sD4PjKvMUTQgghhBAiE5JAvUYs3O0xr/C/ghJJ2a/nUas1BPQfSszjR+xb/ZPRbTi6pe0PdTzkBtdO5Wx/KABtiRI4z51Dwvnz3Bn7EUpqzkay/s3B0oHFAYuxM7fjg+APuPDkQq5jAWDrDB9sg6rt4feBsHk4JCfmLaYQQgghhBD/IgnUa8a2VSlSYpOI3vn8tUGFipfAq0NXjm7dyO1zZ4xuo1ojZ1yrFmbH0jNEP875KJJFlSqU+G4a0du382D69Bzf/2/2FvYsarKIIpZF6BXci7OPzuYpHlpzaP0jtJoJx1fA0hYQeTtvMYUQQgghhPgfSaBeMyb2FhT0dSZ6763nFpQAqNGiDcXKlEubypdk3GiLSqWiUQ93tKYaQhblfD0UQMFGjSj60VgeLVjIkzVrcnz/v9mZ27GwyUKcrJzotb0XYQ/D8hQPgJqB0HMbRN2F+b5w7a+8xxRCCCGEEP95kkC9hqx1TmisTYnYdOW5BSXSpvINI+rhffavMX7dj3kBLU16V+be1SgObbyaq37ade+OXefO3PtyAjF/7ctVjKdszGyY32Q+bjZu9N7em38e/JOneACUqAn9dkMRd1jWGg7Mhrdj32ghhBBCCPGKSAL1GlJpNdi2LEXihScknH1+WW57J2fqv9+Fo5s3cOfCOaPbKVbaBs82pTgWfJ3rYTmvqqdSqSj68TgKNPDi9tChJFzI2xqmgqYFCfIPopxdOfqF9OP4/eN5igdAgcLQ9TeoNwiCP4b1vSApNu9xhRBCCCHEf5IkUK8p84r2mJWzI2LzFRT98zeIrdWyHUVLlSZ47gySk5KMbsejsQslK9uzY8kZYiNyXnBBZWJCie++R+vszM3+/dHfv5/jGP9mZWrFXP+5VLSvSL+Qfhy+dzhP8QDQmECTr+D9pXB+Gyz0h0eX8x5XCCGEEEL850gC9ZpSqVRpBSUiE4nefeu516s1GgIGDCMi/B4Hf/3F+HbUKhoFuqPRqNi+KIzUXKyH0lgVwHneXEhOSStvHvf8tVvZsdRaMrvRbKo5VGPgjoEcvHswT/EMKrWDPn9CShLM90tLpoQQQgghhMgBSaBeY1oHS6walCAq9BbJRlTLK+xcknrvduTQ7+sIv3LJ6HYsrExp0rsSdy9FcHjrtdz11dER53lzSbxyhdujx6CkPH/ULNs+mVgwq9EsajrWZPCfg9l3O29rrAyKuEOfneDaAFZ1gF2TIA+l2IUQQgghxH+LJFCvOeuGzqgtTYjcYtxGs7XbvEdhF1eC584gJVlvdDvFy9pRp5UbR7Ze49a556+7yox5xYqU+G4aMbt2cf/bqbmK8W9mGjN+8PuBesXq8eHOD9lza0+eYwJgbgMdVkDDT2H3lLREKv5J/sQWQgghhBBvNUmgXnNqMxNsm7sRH/aIhAvP/yNfY2JCQP+hPLx1g0Mb1uWorRpNXXEqb0fI4jPERRm/jurfCvr5UXTcOB4vW8aTVatyFePfTDWmfK/7Hh8nH4buGsrOGzvzHBMAtRp8RkPXdXDzEMzXwb3T+RNbCCGEEEK8tSSBegNYVHPA1NWaiE2XUZKfP92sqFtp6rR5n4O/rubBjWtGt6NWq/D/oCIKsGNJGEpq7kp+F+rWFbuuXbn39URi9u7NVYx/02q0TPWdSkPnhowMHUnI9ZA8xzQo459W6tysYFpxiZNr8y+2EEIIIYR460gC9QZQqVTYtilD8sN4YvbfMeoez3c7YutYjOC5M0nNwXqkAjZmNP6gIjfPPeHY9uu57TJFx32Elbc3t4cNJ+F83sqbA2jVWqb4TKGxa2NG7x7Ntqv5WADCzhV6boeKbeDX3rBtHKQYP/1RCCGEEEL8d0gC9YYwLVYAq3rFidpxg5So55cbN9FqaTpgGPevXubI5t9y1JazeyFqNXPl741XuXMpIlf9VWk0lPhuGloXl3wpbw5gojZhUoNJNHdrzti9Y9l0eVOeYxqYWkK7edBsKhyaD8vbQEze+yyEEEIIId4ukkC9Qaz9XVBpVURuvWrU9cXKlqdmy7bsX7uSR7dv5qit2i1cKVbahu0Lw0iIyd1ojLpAAZznzoGU/ClvDqBRa/jK6yvalG7DJ399woZLG/Ic00Clgrp9ocdmeHQJgnzgZj7sQyWEEEIIId4akkC9QdSWWmyauhF34gGJ1yKNuqd++y5YF3YgeN5MUlONn8qn1qhp3LMSKcmp/LnsDIqSu/VQ6cqbj8l7eXNIS6LG1x/Pe+Xe4/N9n7P+wvo8x0ynZD3ouxtsXWBJMziyGHL5/EIIIYQQ4u0iCdQbxrJmUbROVkT8ftmoIg9aUzOa9BvC3QvnOP7H5hy1ZWVnRqMe7lw79Yh//szZCNa/Gcqb79zF/Wnf5TrOv6lVaj7z/IwO5Tsw/sB41pxfky9xDayLpY1E1QyEzcNh44egf/5eXEIIIYQQ4u0mCdQbRqVWYdu6NPq7scQevmfUPU7ulake0JK/Vi8nIty4e55yrVKY6v7OHPjtMvevR+Wmy8D/ypt/9BGPlyzhyS+rcx3n31QqFR/X/Ziu7l356uBX/Hz253yJa2BiCi2mQdu5cGotLGkKEblPJIUQQgghxJtPEqg3kJmLNZY1ihAVfI3UOOPWJ3l37oGltQ0h83/I8XQ8z7alKexckOAFp0mMT85NlwEo1L0bdl26cO+rr4j5a1+u4/ybSqViTO0xBFYKZNKhSSwPW54vcdOp3hl6BkPsI5jvC1d2538bQgghhBDijSAJ1BvKppkbSopCZIhxpcZNzS1o3GcwN06f5NTO4By1pTFR06RXJRJi9ISuPJfr9VCQVt68QAMvbg8bRsKFvJc3h7QkakTNEfSq3IupR6ay5PSSfImbTvHq0DcUHKvAT21h3w+yLkoIIYQQ4j9IEqg3lKagKdaNXIg9eJekOzFG3eNarQaVdP7s/mkx0Y8e5qg9GwcL/Lq5c+nIfc78ZdxeVJlRmZhQ4rvv0ZYowa3+A0h+mLN+ZBlXpWJojaH0q9qP749+z4KTC/IlbjoF7KHrr1B/CIR8Bus+gETjPnshhBBCCPF2kATqDWZVvzgmhS2I2HTZ6FEhXbfeaM3M2LFwdo5HksrULEIl7+LsXXORR7dznzhorArgPG8uil7PzUGDSE3In+IMKpWKwR6DGVh9ID8c/4G5/8zNl7jpqDXQ+EtovxwuhsCixvDocv63I4QQQgghXkuSQL3BVCZqbFuVJulqFPEnHxh1j7mVFY16D+TKscOc25fztTwN3i+LbRELghecRp+Y+5Lk2mLFcJo7l8QLF7kz9iOU1NRcx3rWgGoDGOIxhDkn5vDj8R/zNOUwSxXbQO8/ISUJ5vvB+W3534YQQgghhHjtSAL1hjMvZ4d5RXsit1wlNcm4hKZs7XqUr+fNzqXziYuMyFF7JqYamvSuTPTjBPauztsaJovKlSgx9Vuit2/nwYyZeYr1rD5V+zC85nDmn5zPD8dzXjjDKEUqQJ+d4OoFqzrArkmQj4mgEEIIIYR4/UgC9RawbeFGSpye6F3Gl9hu2LM/AH8uCcpxe4WKFcCnYznO7r/LhUM5K4v+rIL+/hQZPZpH8+cTsf7XPMV6Vs/KPRlVaxQLTy1k+tHpLyaJMreBDiuh4aewewqs6gjxEfnfjhBCCCGEeC1IAvUWMLG3oKCPE9F7bpH8KN6oeyytbWgY2JcLB/Zy8fCBHLdZoV4xytUpSujK80Tcj8vx/f9W6INAbNu35+4XXxB78GCeYj2rR6UefFTnI5aELWHqkakvJolSq8FnNHRZCzcPwnwdhJ/J/3aEEEIIIcQrJwnUW6KgzhmNlSkRm68YfU8FL19K1ajNnwvnkBCTs6IQKpUK387lsbQ2ZfvCMFL0uZ+6plKpcPzsUwrUqcOtIUNJvHI117Ey08W9Cx/X/ZifzvzE5EOTX0wSBVC2cVqpc60lLGwEp9e/mHaEEEIIIcQrIwnUW0JtqsGmhRsJZx+TcOGJUfeoVCr8+wxCn5jI7hWLctymqbkJAX0q8+hODAd+y1slOpVWS4kZ0zEp4sDN/v1JfmLcMxirU4VOfF7vc34+9zMT/55IqvKC1ioVKgW9Q6B8c1jXE4I/gZTcbz4shBBCCCFeL5JAvUUsqhTG1M0mrax5inEJQsFChfHt1pPTu0K4fvJEjtt0cClI/XfK8M/Om1w9mbc9nTTW1jjPm0dqTAy3Bn9IalJSnuI96/1y7zOh/gTWnF/DVwe/enFJlGkBeHchBEyCg3NhRTuIzZ/9roQQQgghxKslCdRbRKVSYduqFMkP44nZf9fo+6o0DMC5UlW2z/8RfS72ZKrq54Rr1cL8uewMMU/ytqeTqZMTTrNnkXDqFHc//TTfp9u1K9uOr7y+Yv2F9YzfP/7FJVEqFdQbCN1/T1sPFeQLt4+9mLaEEEIIIcRLIwnUW8a0uBUF6hYjasd1UmKMG8FRqVQ07juYuMgI/vpleY7bVKlUNOrujtZUw/ZFYaQaOfqVFUsPD4pPnkTUxk08nJv/m+G2KdOGb7y/4ffLv/PZvs9ISc39flbP5eYN/XZDwaKwuCkcX/ni2hJCCCGEEC+cJFBvIevGJUGtInLbNaPvsXMsjlf7Lhzbtok7F87muE1zKy2Ne1bi3uVIDm81vt2sWDdvjsPQITz84UciN2/Jc7xntSzVkkkNJrH5ymY+3ffpi02ibJwgcCtU6wC/D4QtIyE5f6cnCiGEEEKIl0MSqLeQpoAWm8YliTsaTtKtaKPvq9G8DY6lyhA87weS9foct1u8rC11WrlxZOs1bp3PexEI+/79sWnTmrsff0zcseN5jves5qWaM8VnCn9c/YNxf40jOfUFFnvQmkPrH6HlDDi6DJa1gui87aElhBBCCCFePkmg3lIF6hbDpIglERsvG72OSK3RENB/KBH37vL3b6tz1W6Npq6UKGdHyOIw4qPzNsqiUqlw/OorzKtW4dagQSTdNH6jYGM1dW3KVN+phFwLYeyesehTc5445kitD+CDPyDietq6qBt/v9j2hBBCCCFEvpIE6i2l0qiwbVWapBvRxJ14YPR9hV1cqdvufQ5tWMuD6znfj0mtVtH4g4qkpij8uexsnotAqE1NcfrxR9TWBbnZfwApUVF5ipeZxiUbM003jZ03d76cJMq5NvTdnVbyfGkLOLQAXtTeVEIIIYQQIl9JAvUWMy9ji0VleyL/uEpqovFrfOq0bY9dsRIEz5tJakrO1wYVsDWjUQ93rp9+xD9/5n3UyMTODue580h+8IDbw4aj5GJ64fM0cmnEdN10Qm+GMip0FPqUF5xEFSwKPTZCrZ6wdRT8Pgj0eatgKIQQQgghXjxJoN5yNs1LkRqXTPQu4xMZE62WgP5DCb96maNbNuSqXdcqhanu78yB3y5z/3reR43MSrnh9MMPxB46xL2vJ+Z7eXMAnbOOGX4z2Ht7LyNCR5CU8oILPWi00PxbaBcEp9fD4gCIyP9pikIIIYQQIv9IAvWWMylkTkGfEkTvvUXyw3ij7ytWtjw1m7dm/5qVPLl7O1dte7YtTWEnK4IXhpEUn/cCDQU861Js/BdErF7N42XL8hwvMz5OPvzQ8Af239nPsF3DSExJfCHtpFOtI/QMhrjHMN8Xrux+8W0KIYQQQohceWsTqCX7rnLzcdyr7sZroaDOGY2VKRFbruToPq/23ShgZ8f2+T+ipOZ8byeNiZomvSsRH51E6M/n82XUyPa997Dv3Yv7U74leueuPMfLTIMSDfix0Y8cuneIobuGvpwkqnh16BsKjlXgp7aw/0dZFyWEEEII8Rp6KxOoJ7FJzN51Cb9poYz79eR/PpFSm2qwae5GwtnHJFw0vry41tycxn0+5NaZ05zauT1Xbds4WKLrUp6Lh8M5dyB/ynY7jBhBQf9G3B41ioSzOd+zyhj1i9dnVqNZHL13lA///JCE5JewPqmAPXRZD/U/hO2fwvpekBT74tsVQgghhBBGeysTKLsCpuwZ48eYpuXZHhZOw+9CGffrKW5HGD+F7W1jUbUwpq7WRGy6gpJi/GhSyarVqaTzZ/eKxUQ/fpirtsvVdsS9fjH2/HKeJ/fynhCo1GqKT5mCmasrNwcMRB9+P88xM+NZzJPZjWZz4sEJBu8cTHzyS/j9aEyg8QR4fymc3wYLG8PjnI0cCiGEEEKIF+etTKAALE1N6OtTmr1j/RjVpDzBYffQTd3FJ7/9NxMplSqtrHnygzhiD97N0b26br3Rmpnx56K5uZ6G592hHAULmRO8IIxkfc4r+z1LbWmJ09y5oCjcGjiQ1LgXM8pYp1gdZjeazckHJxn05yDi9C9pNLNSO+i9A5LjYb4OLoa8nHaFEEIIIUS23toE6ilLUxP6+ZZm7xg/RjQuz9ZTd9FN3cVnG04THvXfKhttWsKKArUdiQy5QUqs8WW6za2saNizP5eP/M2Fg3/lqm2tmYYmvSsTER7H/nWXchUjQ8yiRXCeN5fEq1e5M/ajXK3TMkZtx9rM859H2MMwBv458OUlUUUrQp9d4OwJK9+HPVPhBT2jEEIIIYQwzlufQD1VwMyEAbrS/DW2IcP8y7Hxnzv4fLuLrzaf4WHMSygS8JqwblISUIgKuZ6j+8rV9aJsnfrsXBJEfHTuypIXdrLC670ynNp9mys52Nw3O+bu7pSYNo3oHTt4MH16vsTMTI2iNQhqHMS5x+cYsGMAsfqXtDbJwhY6/QK+Y2Dn17CmGyTk/2bCQgghhBDCOP+ZBOqpAmYmDPIrw96xfgzQlWbN4Zt4T9nF5D/O8ST2Be/78xrQWJli3agksX/fJeluzpKAhj37k5KsJ3T5wly3X9m3BKWqO7Bz+VmiH+fPCGDBhn4UGTOGRwsWErH+13yJmZnqRaoT1DiIC08u0D+kPzFJMS+srXTUavD7GDqugqt7YGEjeHDh5bQthBBCCCHS+c8lUE9Zm2sZ5l+OvWP9+MDLleUHruH97S6+D7lAVILx09veRFb1imFS2ILITZdztKbJyq4Qvt16cWbPTq6dOJqrtlUqFX7dKqA10xCyOIzUHBS0yE6hwB7Ytm/P3S++IPbvQ/kSMzPVHKoxv/F8Lkdcpt+OfkQnRb+wtjKo0Bz67ARUsKAhnN388toWQgghhBDAfziBesrW0pQxTSuwZ4wfneo4E7T7Mj7f7iJo92Xik/Je7OB1pDJRY9OyFIlXIok//ShH91bWNcalcjW2L5hFUkLuinGYF9DSuGcl7l2O5MjWa7mK8SyVSoXjZ59SoE5tbg0ZQuLVq/kSNzNVHKqwoMkCrkZepX9I/5ebRBUuC33+hNI6WN0lbVpf6tv5OxVCCCGEeB395xOopwpbmfFJi4rsHu1HiyrFmBp8Ht+pu/jpwDWSkt++hfsW5QthXqEQkVuuoOSgKp5KpaJx3w+Jj4rir1+W57r94mVtqd3SjSNbr3H7gvF7U2XbN62WEjNmYGJvz63+A0iJiMiXuJmpVLgSC5ss5FrUNfpu70tU0ktcl2RWENr/BI0+hz3T4OcOEJ8/n6EQQgghhMieJFDPcLQxZ2K7KuwcqaNBmcJ8vjGMht+Fsv7oLVJSc1fC+3Vl08KNlOgkovfcztF9tkUd8erQlePbNnPnQu43sq3ZzJXiZW0JWXyGhJj8mTapsbbGed5cUiIjufXhEJSkF7euraJ9RRY2WcjNmJv02d6HyMTIF9ZWBioVeI+Eruvg1mGY7wfhYS+vfSGEEEKI/yhJoLLgYm/J9x2qs22oD5WKWzNy7T80nbGH4LB7ud4L6XWjdbDEyqs40aE3SY7MWSXCGs1b41iqDNuDfiRZn7vkR61W4f9BJVL0qfy5/Gy+fa6mLi44zZ5F/IkT3B3/5Qv9vtzt3VnUZBF3Yu7QZ3sfIhIiXlhbmSrjD31DwbQALPSH0y+uiIYQQgghhJAE6rnKOxYkqFstNgzyooi1Gf1+Oso7c/dz8ErO1g69rqwbuqAy0xD1R87WDKnVGpr0G8KTu7c5tGFNrtu3sjOjYQ93rp18yKnQW7mO8yzLmjUpNvFrIn/9lUcLc1810BjlC5VnYZOF3Iu9R+/tvXmS8JKn0xVyg17boXxzWPcBbP8UUpJfbh+EEEIIIf4jJIEyUnVnW1b29mRFr7okpyh0nH+QHosPcfr2S5y29QKozU2wCXAl7sQDEq/nbB2PQ0k3ard+j79/W8vDmznbV+rf3KoWpqqfE/vWX+LBzfwryGDTujX2A/rz4Lvvidq+Pd/iZqZ8ofIsCljEg/gH9N7em8cJj19oexmYFoB3F0LAN3BgDqx4B2LfjiRfCCGEEOJ1IglUDjUoW5iNg72Y06UGNx/H0fLHv/hw1XGuPXxJG6u+AJY1i6ItXoCITZdRcrjOy/OdDtgUdWR70A+k5qEaXP13ylCoWAG2LwxDn5h/VeUcPvyQgs2acmfMWOJPv9g1QmXtyrI4YDGP4h/RK7gXj+JfcgKjUkG9QdB9A4Sfhvk6uPvPy+2DEEIIIcRbThKoXFCpVDSvUoztw32Y/E4VDl99jP/3u/n899M8jMnZWqLXgUqtwrZVafS3Yog7fj9H95qYmtKk34fcvXieE8Fbct0HjVZNk16ViIlIZM/q/NskVqVWU3zSJMzKlePWgAHo793Lt9iZKW1bmsUBi4lIjKBXcC8exj98oe1lys0H+u4Gy0KwqAn888vL74MQQgghxFtKEqg8MNGo6VjHhV2jdIxsUp7fjt/G99tdzNhxgZjEN2sNipmbDRZVCxO57RqpOey7U4VKVGvcnL9WLSfqQc4SsH+zcyyAT4dynNt/lwuH8y/RUZub4zx7FmhNuDlgIKmxL3a0sJRtKRYHLCYqKerVJVG2ztBzG1R+F37rB3+MhZS3e4NoIYQQQoiXQRKofGBhqmGArjR7x/jRua4Lc3ZdRve/PaT0KW/OHlI2zdxIjU8melfOizl4dw7EzMqKkIWz81T1rkI9R8rWLkroyvNEPsjdRr2ZMXFwwHnuXPTXr3N7zFiUlBe7+aybjRuLAxYTkxRDz+CePIh78ELby5TWAtrMhubT4PBCWN4GYnKf4AohhBBCCEmg8pWtpSmftKjIzlG++JRz4PONYTT+fjdbTt59I0qfm9iZU9CnBNF7b5H8KGfJi5mlJf69BnLtxFHO/hWa6z6oVCp0nctjYaVl+6IwUvIxATUvX57i339HzK5d3P/u+3yLmxVXG1eWNF1CnD6OnsE9uR/3CpIXlQrq9IEem+HhRQjyhVtHX34/hBBCCCHeEpJAvQBOdpZ83746W4d441q4AIN+Pka7Ofs5dPUlV2bLhYI6ZzQFtERuzVlZc4DSNetQvp43u5YtIC4q99UJTS1MaNKrMg9vRPP371dyHSczBXU6in40lseLF/Nk7dp8jZ0ZF2sXlgQsISElgZ7BPQmPDX/hbWaqZD3otxtsSsCSpnDsp1fTDyGEEEKIN5wkUC+QezFrln5Qh5971yU5NZX2QQfovewIl+7HvOquZUltqsGmmRvxYY9IuByR4/sbftAPFIVdS+fnqR9F3ayp26YUx7ff4MaZ/K1mZ9etG7adOnLvywnEHvw7X2NnxtnamcUBi0lKSeKD4A+4F/tiC1lkybo4BG6B6l1g42DYPAKSk15NX4QQ4v/Yu++wquv+j+PP7zmcwx4ishFwi1tzi4gCrkzL1LbbnDkyG7aHdZcrZ27LsmyamgNQAfdeiVtQQMHJ3uP3B3f+6g6UcRb6flwX13UH53zeb8z7ihffz+f9EUKIKsrgASotLY3WrVvTvHlzmjRpwrJly/7x9czMTLy9vZk6daqhW9ObDnWc2DCuE18+05wz11PpPjeKt347xY20bGO3ViLL5jXQ1rQlZeNligrKt/XQyt6BLi+N4OyeSC4fO1SpPloE18SrYTXCV58hM1V3P+grioLrW29h3aYN8RMnkhNT/qdt5eVl68WqHqsoKCxg6NahXE+/rveaJTIzhz5zoc88OLYGvn4c0owU6IQQQgghqiCDBygrKysiIyM5fvw4Bw4c4NNPP+X27f9/wvDJJ5/Qtm1bQ7eldyqVQt/mHuyYGsCbPRvwx8nrdPkigrnh58nMNa2JfYry37HmiRlkVGAanl/nrng3bUH4skXkZmVWvA+VQrchflBUxPbV0eW+o+q+a2s0eMydg5mTE3GjR5N/967O1i6Nh40Hq3qsoogihm4byrX0a3qvWapWg2HoFkiOKz4XdVX/T+KEEEIIIR4GBg9QarUaKysrALKzsykoKLg3YOHChQucPXuWXr16GbotgzE3UzPCvxZRrwXyQjvv/07si2DdoasU6DAgVJbWyxarls6khsZSmFm+8deKohA8chxZ6ansXle5szbW9uZ0G+LH1eg7HA+Pq9Ra/0ttZ4fXV4spTEklYeIkinL1v53N3cadVd1XoaAwbNswEtIT9F6zVJ6PwagIcPSF1b3h0AqoAsNOhBBCCCGMqdwBKioqij59+uDu7o6iKKxfv/5fr1m0aBG+vr5YWFjQqlUrdu3a9Y+vJycn06xZMzw9PZk2bRpOTk4ATJ06lU8//bRi30kVY2+l4a1eDdn+agDtalXn9V9O0XveLiLPG2HcdSnse/hSlF9I6var5X+vsyudBr3Isa2buHb+bKX68G5UneZBXuz//RI3rqRWaq3/pfXywnPhArKOHeP6Bx8YZFqim40bq3qsQqWoGLp1KPFp5R8brzO2LvDSBnhsKPwxpfhsVJ5pbi0VQgghhDAF5Q5QGRkZNGvWjAULFpT49XXr1jFp0iSmT5/OsWPH8Pf3p2fPnly9+v8/hDs4OHDixAliYmJYu3YtSUlJ/P7779SrV4969epV/LupgrwcrZj3bAvWj+uInYWGwSsP8uKKA5y5rtugUBFqOy22gV6k77tO3s3yb8Vr0bMPrrXqELpkHgX5lbvEtV2/2lT3sGHb8tPkZut2y6NVq1a4fvQhKb/8yp2Vq3S6dmlcrV1Z2X0lGpWGoduGEpeq26dr5WKmhV5fQL/FcPInWNUTUowY6oQQQgghTJhSVIlfuSuKwm+//Ua/fv3ufa5t27a0bNmSxYsX3/tcw4YN6devX4lPl8aMGUPXrl05evQo3377LWq1mvT0dPLy8nj11Vd59913S6ydk5NDTk7OvX9OTU3Fy8uLlJQU7OzsKvotGVVRURGh0Ul8tuUssbczGNjKi1dD6uFsZ2G8nvIKSZx9GI2LNU5DGpX7/TdiL/PdW5Np1/8Z2vd/tlK9JCdl8uOMQ9RqXoOgoX6VWqskN+bM5fbSpXjOn4dtUJDO1y9JUkYSI0JHkJWfxcruK6lpV9MgdUt17RisexHys2HA1+DT0bj9CCGEEEJUQGpqKvb29nrJBjo9A5Wbm8uRI0cICQn5x+dDQkLYu3cvAElJSaSmFj9dSU1NJSoqivr16/Ppp58SFxdHbGwsM2fOZOTIkaWGJ4BPP/0Ue3v7ex9eXl66/FaMQlEUujdyJXRyZ9573I/Q6ES6zIzgy/ALRhs0oWhU2PfyJfvsHbLPl3/QgrNPLVo/0Z8Dv67jdnzlnrI4uFgR8Gw9zh1I5Nx+3U+xqzHxFWxDQkh4bRrZ0dE6X78kLtYurOi+AkszS4ZuG8qV1CsGqVsq9xbF56JqNIBvnoD9X8m5KCGEEEKIv9FpgLp16xYFBQW4uLj84/MuLi4kJhZPc4uPj6dz5840a9aMTp06MX78eJo2bVruWm+++SYpKSn3PuLijLgFSsc0ahVDOvoS8d9BEwt3XqTrzEh+PhJPoREGTVg2dkLra0fypksUFRSW+/3tnnoGuxouhC6ZR1Fh+d//d/XbuVG/rSuR358nOaniE/5KoqhUuH/2Kea1axM3Zix5STd0un5pnK2cWdl9JdYaa4ZtHUZsSqxB6pbK2gleXA9tR8PW1+G30ZCXZdyehBBCCCFMhF6m8CmK8o9/Lioquve5Vq1acfz4cU6cOMHJkycZM2bMv94/ZMgQZs6ced8a5ubm2NnZ/ePjYWNvWTxoInxKAK28qzH1pxP0WbCbvZduGbQPRVFweLw2+TezyKjAkx8zrZaQURO4dv4MJ8K2VLqfzs/Ww8pOS+iK0xTkVy6Q/S+VpSWeixaCohA/diyFWYYJDjWsarCy+0pstDYM2zaMmBT93011X2oz6P4J9F8B0b/DihC4a+SnY0IIIYQQJkCnAcrJyQm1Wn3vadNfbty48a+nUqLsala3YuHzLfl5dHs0ahXPLTvAyG8OE3Mrw2A9aD1ssH7MlZTwqxRklH8ghKdfY5oG9WDX96tJvVW5SYNaCzNCRjTidnw6+3+/XKm1SqJxdsZr8SJyYmK49voblX5qVlZOlk6s6L4Ce3N7hm0bxuVk3X9v5dbkaRgRBtkpsLQLXI4wdkdCCCGEEEal0wCl1Wpp1aoVYWFh//h8WFgYHTp00GWpR9JjPo78NrYDXz7TnOhrqQTPjuTDjdGklPOepoqyC/GGwiLSKjDWHKDz80PRWliyfcWiSo8Ld/a2o12/2hwPu8qV07cf/IZysmjYEI8vPictLIybX87T+fqlcbJ0YnnIchzMHRi2bRiXki8ZrHapXJsUn4tyawZrnoS98+VclBBCCCEeWeUOUOnp6Rw/fpzjx48DEBMTw/Hjx++NKZ8yZQrLly9n5cqVnDlzhsmTJ3P16lVGjx6t08YfVYqi0Le5B9tfDWBycD3WHbpKwMydrN4TQ14FzieVh9pWi13XmqTvv0ZeUvmffplbWdN1+BguHz3E+f27K91P8yAvavo5sn11NBkpOQ9+QznZduuG89Sp3F6yhOQS7jvTl+qW1VnRfQWOlo4M2zaMi3cvGqx2qawc4YVfoMMrEPo2/DIccg33BFQIIYQQwlSUe4x5REQEgYGB//r84MGDWb16NVB8ke7nn3/O9evXady4MXPmzKFz5846abg0+hxVaMpupGUzO/Q86w7H4etkzfReDenawPlf59B0pSi/kMQ5RzCrbonT0EYVqrNh9gwSzkYzZPZiLG1sK9VPZmouP3x0ACcvW/qMb4ai0u33XVRUxPV33iHl9w14r1qJ1WOP6XT9+7mbfZcRoSO4lXWL5SHLqVutrsFq39efv8Lv48CxFgz6Fhx9jd2REEIIIcQ/6DMbVOoeKFPyqAaov0RfS+WTzdHsuXgb/7pOvN3bj/qulQsnpck6fZvba6KpPqQRlg0cy/3+9Lt3WD1lDHXbdqD76ImV7ufq6dtsnH+CDv3r0CJY9/coFeXmcnXESHLOn8fnx3Voaxrurqbk7GRGho0kKSOJ5d2XU6+aiVw0nXQafngesu7C0yuhTjdjdySEEEIIcU+VuQdKGI+fux3fDm/L8pceI/5uFj2/jOLt9ae4na77rW0Wfo6Y13EgZdNliiowBc+mmiOdXxjKnzvDuPrniUr3U7NRdZoH12T/+kvcuJJa6fX+l6LV4jnvS9T29sSNHkNBqu5rlMbBwoFlwctwtXZl+LbhnLtzzmC178ulEYzaCZ6t4bunYfccORclhBBCiEeCBKiHiKIoBPm5sG1SZ97q1ZDfj1+jy8wIlkVdJleH476Lx5rXIv92FukVvNC2SWAInn6NCVu6gLzcyoe8dn1rUd3DhtDlp8nN1v2lw2oHBzy/Wkz+7dskTJpMUb7hLjZ2sHBgWcgy3KzdGBE6grN3zhqs9n1ZVoPn1kGnKRD+Pvw0BHLSjd2VEEIIIYReSYB6CGnNVIzwr0Xka4E82cKDz7aeJXhOJNtOJ1Z6+t1fNK7WWLdxJbWCY80VlYrgkRNIu3OLfT9/X+l+1GYqQoY3IjM1l6gfzld6vZKY+/ri+eVcMg4eJGnGDL3UKI29uT3LQpbhbuPOiNARnLl9xqD1S6VSQ7d3YOAauBgOy4PgtglMDhRCCCGE0BMJUA8xR2stH/ZtzJaJ/tR0tOLlNUd4fvkBzibqZguaXbA3UERqeMUuWHV096B9/2c5vPFXkmIq/0O3g4sVAc/W49z+RM4dSHzwGyrAul07XN99h7trv+fOt9/ppUZp/gpRnjaejAgdQfTtaIPWvy+/J2DEdijIhWWBcCHswe8RQgghhKiCJEA9Auq52PLNsDasHPIYiSnZ9PpyF9N/q/z5KLWNFrtuNck4cL1CY80BHuvzFNU9axK2dD6FBQWV6gegfjs36rV1IfL7c6TczKz0eiWpNnAgjkOGkDRjBum7dumlRmnstHYsDVmKt503I0JHcPr2aYPWvy/nBjByB9RsD98NgKgvwECXEAshhBBCGIoEqEeEoih0beDC1kmdmd7bjw0nis9HLd9VufNRNu3dMatmQfKmyxXaHqg2MyPk5QnciLnM0c2/V7iPvwt4pj6WtlpCl5+mQIdnv/7O+bWp2HTuTMKkyeRcuKCXGqWx09qxJHgJvna+jAwdyelbJhSiLB3gme8hYBrs+Bh+egly0ozdlRBCCCGEzkiAesRozVQM7+RL5GuB9G3uzozNZ+g+N4rtZ5IqFIAUMxX2vWuRcyGZ7HN3K9STW536tOjZhz0/fkdyUuW33mktzQgZ3ohbcekc2HC50uuVRFGrcZ85E42HB3Gjx5B/545e6pTGVmvLV8Ff4WtfHKL+vPWnQevfl0oFgW8VB6lLEbCsG9wygcuAhRBCCCF0QALUI8rRWsvH/ZqweaI/7g4WDP/6MC+tPMiFpPI/LbBoWLmx5gAdB72Alb094csX6mTQhYuPHW371eJY6FXizugn3KhtrPFavIjCnBzix42nMEf3I+Pvx1Zry5KgJdRyqMXI0JGcvHnSoPUfqEGv4i19FBWfizq31dgdCSGEEEJUmgSoR1wD1+L7o5a+2IqrdzLp8eUu3t9wmuTM3DKvoYux5loLS4JGjOPKyWNER+2o0Br/q0VQTbwaViN8VTRZaWX/fspD4+GB14L5ZJ8+zfV33tHZlMOystHasCR4CXWr1eXlsJc5cbPy92rpVI16xcMlfPzh+0EQ8R85FyWEEEKIKk0ClEBRFEIauRI6uTOvda/PT4fj6DIzgjX7YskvKNsPu5Udaw7g27wVDToGELFmBZmpKRVa4+8UlUK3IX4UFRWx/Zszegs3ls2b4/bpDFI3bOT2kqV6qXE/1hprFgctpl61erwc9jLHbxw3eA/3ZWEHg76FwOkQ8SmsewGyDXcZsRBCCCGELkmAEveYm6kZHVCbna91IcTPhXc3nKb3vN3suXirTO+/N9Y8rGJjzQECB4+EoiIivl5W4TX+ztrenK4vNeTKqduc3BmvkzVLYt+7N07jx3Nz7lxSt27TW53S/BWi6lerz+jw0aYXolSq4sESz/4AsbtgWVe4qZ/7uoQQQggh9EkClPgXZ1sLPn+6GRvGdcLWwoznlx/g5TWHuXr7/mPB/zHWPLFiY82t7B3o8tIIzuyOIObY4Qqt8b98mjjRrKsXe3+9yM04/U2Ecxo3Frtevbj2xhtknTL8UAcrjRWLgxbTwLEBL4e9zLEbxwzewwPV7wEjdxZfwLusK5zdbOyOhBBCCCHKRQKUKFUTT3t+Gt2eL59pzsn4FIJmR/L51rNk5OSX+h6b9u6YVbck+Y+KjTUH8OvcFe+mLQhfsYjc7KyKtv8P7Z+sjaObNaHLT5OXU/n7pkqiKApuMz7BvH494seOJS9RP5f53o+VxopF3RbRyKkRo8NGczTpqMF7eCCnOjAiHGp3gR+ehZ2fyrkoIYQQQlQZEqDEfSmKQt/mHmx/NYDRXWqzYncMgTMj+PVoPIWF/w5IipkK+16+lRprrigKQSPGkZmSwt4fv63stwCAWqMiZHgj0u9ms/tH/W0dU1lY4LVgAWjMiBs7lsJM/Vzmez9WGisWdF1AY6fGjA4fzZGkIwbv4YHMbWHgGuj6DkT+pzhIZVf+3JsQQgghhL5JgBJlYqU1Y0pwPcKnBNDax5EpP56g/1d7OR6X/K/X/mOseRmHUPwvBxdXOgx4jqObN5J4UTeBp5qrNf6D6hG95zoXj9zQyZolMatRA6/Fi8mLvULCtGkUGeHpipXGigXdFtDUqSljwsdwOFE32yF1SlGg81R47ke4su+/56LOGbsrIYQQQoj7kgAlysXL0YqFz7fkh1HtyMotoN/CPUz96QQ30rLvvUZRFOx7/3es+b6KjTUHaNW7HzW8fQldMo+C/NK3DZZHww5u1GnlzM5vz5J6WzfbA0tiUb8+7rNmkr59BzfnzNVbnfuxNLNkfrf5NK3RlLHbx3Io8ZBR+nigeiEwaieoNMUh6sxGY3ckhBBCCFEqCVCiQtrVqs6mCZ34qF9jws8k0XVmJEsiL5H734t0tW6VH2uuUqsJeXkCt+KvcnjTbzrpW1EUujxfH3NLM8JWRFNYwSdkZWEbGIjztGncXraM5F910395WZpZMr/rfJrVaMa47eNMN0RVrw0jwqB21+Ix5zs+lnNRQgghhDBJEqBEhZmpVbzYzpuIqV3o39KDz7edo/vcKHacTQL+O9a8qIi07VcrXMOlVh1a9e7H/p+/5+71BJ30bW6lIXiYH0kxKRzaHKuTNUvjOGQwDgMGcP2998g8bJxtdH+FqOY1mjM2fCwHrh8wSh8PZG4LA7+Bbu9C1Mzii3ezko3dlRBCCCHEP0iAEpXmYKXlg76N2fyKP272FgxbfZjBKw8Sm5WLXbeapO+/Rt6Nig9T6DDgOayrVSN8+UKdXYbrVseB1o/7cmRzLNcuVGzYRVkoioLru+9g1bIl8eMnkHu14mGyMizMLJjXdR6tXFoxfvt49l/fb5Q+HkhRwP9VeP4niDtQvKXvxlljdyWEEEIIcY8EKKEz9V1t+W5EW756oRWXbqbTfU4UC1JSUNmbk/LH5QqvqzG3IGjkeK7+eZLTEeE667dVTx/c6jgQtjKa7ApuMywLRaPB88u5qO3tiRszloLUVL3Vuh8LMwu+7PrlvRC179o+o/RRJnWDi++LMjOH5d0geoOxOxJCCCGEACRACR1TFIUejV0JnxLAxG51+eZgHJ9kpZN97i6ZZ25XeF2fpi3w8w8kcs0KMpJ188RIpVIIGupHXk4BO789q7OnWyVROzjg+dVi8m/dImHyFIp0NBSjvMzV5nzZ9Usec32MCTsmsPfaXqP0USbVa8PwMKjTDX58EbZ/BIX6ucNLCCGEEKKsJEAJvbDQqJnQrS7bXw1AVc+Bo+Rz+rtojsXcqfCaAS+NQFGp2Pn1Mp31aetoQeCLDbh87Cand13T2bolMff1xfPLuWQcOEDSjE/1Wuu+fajN+TLwS9q4tuGVHa+wN8GEQ5S5DQz4GoLeh12z4Ptn5FyUEEIIIYxKApTQK3cHS+Y/1xLP/vVwyYc1Sw7z6o//HHteVlZ29nQZPJJze6O4fEx30+Rqt3Cmkb87u3+6wO1r6TpbtyTW7drh+s473F27ljvffqfXWvdjrjZnbuBc2rq1ZcKOCexJ2GO0Xh5IUaDTZHjh5/+eiwqEG2eM3ZUQQgghHlESoIRBtGztgfVjLkzQWHPgv2PPl0b9/9jzsmrYqQs+zVoSvnwRudm6u8ep44C62DlZErbiNPl5+t0mVm3QQBwHDyZpxgzSd+3Wa6370aq1zOkyh/bu7XllxyvsTjBeL2VSJwhGRYCZBSzrBtG/G7sjIYQQQjyCJEAJg3Ho7oNWUfilqS9Pt/Lksy1n6TE3iohzN8q8hqIoBI0YS1ZaKnt+WKOz3jRaNd1HNCI5KYu9v1zS2bqlcZ72Gjb+/iRMnkzOxYt6r1carVrL7C6z6eDegVd2vMKu+F1G66VMHGsVn4uqFwI/vgTbP5RzUUIIIYQwKAlQwmDUtlpsu3qRdyiJ6e192TzRH2c7c4asOsSIrw8ReyujTOvYO7vSccDzHN26kesXz+msv+oeNnToX4dTEfHEnLips3VLoqjVuM+aicbNjbjRY8i/U/GzYZX1V4jq6NGRiTsnEhUfZbReysTcBp5eBUEfwO45sFbuixJCCCGE4UiAEgZl29EDtb2WlM0xNHC14/uR7Vj0fEvOXE8jZE4Un289S0bOgyfUtezVFxff2oQumU+BDifaNenigU9TJ3Z8c5b0uzk6W7ckahsbPBcvpjAzk/gJr1CYm6vXevejUWuYHTCbTh6dmLRzkumHKEWBTpPg+Z8h/pCcixJCCCGEwUiAEgalaFTY9/Ql+8wdsi/cRVEUejVxI3xKAKO71Gb57hi6zYrk9+MJ9x0rrlKrCR41gdvxVzm86Tfd9acodH2pAWozhfDV0RQW6m+0OYDW0wPPBQvIPnWKxHff0+so9QfRqDXMCpiFv4c/E3dOJDIu0mi9lFmdbjBqJ5hZwvIguS9KCCGEEHonAUoYnGUTJ7Q+diRvukxRQXFgsNSqmRJcj+1TAmju5cDEH44zcMk+Tl9LKXUdF9/atOrdj/0/f8/d6wm6689GS9BQPxLO3+VY6BWdrVsaq5YtcPvkY1LWr+f28uV6r3c/GrWGmV1mEuAZwKSISUTERRi1nzJxrAUjwoov35X7ooQQQgihZxKghMEpioLD47XIT8ok43DiP77m5WjFVy+2Ys3wNtzNzKPP/N28vf4UdzNK3t7WYcBzWFerRvjyhTp9euPZwJGWId4c3BBDUkyqztYtjX2fPlQfM5qbs+eQFh6u93r3o1Fp+CLgC7p4dmFyxGR2Xt1p1H7KRGv933NR78t9UUIIIYTQKwlQwii0nrZYtXQmNfQKhdn/PsPkX7cGWyb6M723H78fu0bgrAjW7Iul4H+21GnMLQgaOZ6rf57kdOR2nfbY5glfnGraErriT3KzdHfOqjQ1JkzANiSEhNemkR0drfd696NRafg84HMCvQKZEjmFHVd3GLWfMvnXfVFd4cZZY3clhBBCiIeMBChhNPbdfSjKLSB1R1yJX9eoVQzv5MuOqV0IbujCO7+f5vH5uzkY88+JdT5NW+DnH0jkmhVkpiTrrD+1WkXIcD+y0vOI/EF30/5Ko6hUuH/2Kea1axM3Zix5SWUf764PGpWG/3T+D129uvJqxKtsv6rbgKo39+6LMofl3eDMRmN3JIQQQoiHiAQoYTRqe3NsAzxJ35NA/u3SL8WtYWvOFwOasX5cR7RqhYFL9vHK98dITMm+95qAl0aAorDz62U67dG+hhUBz9bn/IEkzh1IfPAbKkllaYnnwoUAxI8bR2GW7i4LrgiNSsNnnT+ja82uTI2YyvYrVSRE/XVfVJ1usO4F2PExFJbv0mYhhBBCiJJIgBJGZdPZE7WNhpTNMQ98bXMvB34b25HP+zdlz8VbdJ0VwaKIi+TkF2BlZ0/gSyM4uyeSmGOHddpj/bau1GvrQuTac6TczNTp2iXRuDjjuWghOZcuce3Ntygy8g/+fz2J6ubdjamRUwm/YtwzWmVmbgMDvoZu70HUTPjhWcgufSiJEEIIIURZSIASRqXSqrHv4UvW6dvkXE5+8OtVCgNbe7FjaheeaV2TWaHn6T4nih1nk2joH4h30xaEr1hEbrZun9wEPFMfSzstoSuiKSjQf6CxbNQI98//Q9rWrdxasEDv9R7ETGXGZ/6fEeQdxGuRrxF2JczYLZWNooD/lOL7oq7uKz4XdVP/2zGFEEII8fCSACWMzrJZDTRetsVjzct475K9pYZ3+/ixdaI/7g6WDFt9mBFfH6ZB/6FkpqSw98dvddqj1tKMkOGNuHU1jYMbHvy0TBfsgoOpMWUKtxYtJmXjJoPUvB8zlRmf+n9KsHdw1QpRAHWDYOROUGlgWTc4+4exOxJCCCFEFSUBShidoioea553LYPMo0nlem9dF1u+G9GWRc+35GxiGk+tOUdu0yCObt5I4qULOu3TxceOtn1rcTT0CvFn7zz4DTpQfeQI7Pv25fr06WQeO2aQmvdjpjJjhv8Muvt057XI1wiNDTV2S2VXvTaMCIfagfDDc7BzhpyLEkIIIUS5SYASJsHc2w7LZjVI2RZLYU75LkFVFIVeTdwInxLA6IBaLE+uyR2L6vz85Wzy8/J02meL4Jp41KtG2KpostJLvptKlxRFwfWjD7Fo3Jj48RPIS9DdhcEVZaYy45NOn9DdpzvToqaxLXabsVsqO3MbGPgNdH0HIj8vDlJyLkoIIYQQ5SABSpgM+x4+FGYVkBZZ8ljzB7HUqpkSUp+wKYGktOxHVlI8U9+fz9lE3V2Eq6gUgof6UZhfxI5vzur08t7SqLRaPBfMR2VhQdyYsRSkZ+i95oOYqcyY0WkGPXx78HrU62yN3WrslspOUaDzVHj+J7iyt3hL383zxu5KCCGEEFWEBChhMsyqWWDr70FaVAL5ydkPfkMpala3Yv4rfXHrEIz75SienfUH7284TUqWbp5GWTuY03VwQ2JP3uLPSMM8ETJzdMTrq8XkJSRwbepUigrK95ROH9QqNZ90/ISevj15I+oNtsZUoRAFUDcYRu0Elbp4uMTZzcbuSAghhBBVgAQoYVJsu3iislSTsiW20msNfHkkDo6ODC48zE+HrtJ1ZgTrDl2lsIyDKu7Ht6kTTQI82PPzRW4npFd6vbIwr1sXjzmzSY+K4sbMWQap+SBqlZqPO35ML99evLGrCoaov85F1QooHnMe8ZmcixJCCCHEfUmAEiZFZW6GfYgPWSduknO1clvvtBaWBI0YQ0H8OZb7q/Gv68Trv5ziyUV7OB6XXOleO/Svg72zJaErTpOfa5gnQjadO+PyxuvcWbWK5J9/NkjNB1Gr1HzU8SN61+rN67teZ0vMFmO3VD7mtjBwDQS+XRyg1r0A2brb9imEEEKIh4sEKGFyrFq5oHGzJmXT5UqfMarVojX1O3Tm2I+rmdGrFj+Nbk9eQRH9Fu5h2s8nuJWeU+G1zbRqQoY3IuVmFnt+uVipPsuj2osv4jBoENff/4CMAwcNVvd+1Co1H3b4kMdrPc4bu96oeiFKpYKA1+DZHyB2FyzvBrcM9+9UCCGEEFWHBChhchSVgv3jtci9mkbWiZuVXi9w8EiKCguJXLOC1j6ObJzQiY/6NWbb6SQCZ0awak8M+RW8HLe6hw0d+9fhz8gELh+vfK9loSgKrm9Px6r1YyS88gq5V64YpO6D/G+I2ny5Cp4pqt8DRu4o/t/LAuF8FZowKIQQQgiDkAAlTJJFbQcs/KqTsiWWorzKbY+zdqhG5xeHER21gysnj6NWKbzYzpudU7vQp5k7H26Kpve83ey7dLtC6zcO8MC3mRM71pwh/W7Fn2iVh6LR4Dl3Lupq1Yon86Waxpazv0JUn1p9eHP3m/xxuQpeWOtUF0ZsB59OsHYQRH0BBpi2KIQQQoiqQQKUMFn2vXwpSM8lbVflJ9017hKMl18TwpYvIC+neMKfo7WWGU82YcO4Tlibq3l22X7Grz3K9ZSscq2tKApdX2yImZmK8NWndTKkoizU9vZ4fbWY/Nu3SZg0maL8fIPUfRC1Ss0HHT7gidpP8Nbut9h0eZOxWyo/CzsY9B0EvA47PoYfX4IcwwwLEUIIIYRpkwAlTJbGyRKb9u6kRcRRkFq5S2sVRSFo5HjS79xm3y8//ONrTTzt+Xl0B2YNaMb+y3foOjOShTsvkpNf9idfFjYagob6kXA+mWOhhttSp/XxwfPLuWQcPEjSjE8NVvdB/h6ipu+ezsZLG43dUvmpVBD4ZnGQurQDlgfBncvG7koIIYQQRiYBSpg0u65eKGYqUkJjK72Wo7sH7Z56hsMbf+VG7D9/EFapFPq38mTH1ACea1uT2WHn6T4nip1nb5R5fc8GjrQM8ebghhiSYgy3pc66XTtc33mHu2vXcue77wxW90FUiooPOnxA39p9eXvP21UzRAE0fLx4S19BLiztAhfDjd2REEIIIYxIApQwaSorDXZB3mQeSSJXB/cttX7iKap7eBG2dD6Fhf9+wmRnoeGdx/3YMtEfdwdLhq4+xIivD3H1dmaZ1m/zhC9ONW0JXfEnudmG21JXbdBAHAe/RNKMT0nfvcdgdR9Epah4v8P7VT9EOTcoHi7h1Ra+GwC758i5KCGEEOIRJQFKmDzrtq6YOVmS8kflx5qrzTQEjxpP4uWLHN9a+tmcei62fDeiLYueb0n0tVSC5kQyO/QcWQ+470mtVhEy3I+s9Dyivj9fqV7Ly3naNKw7dSRh0iRyLl0yaO37+StE9avTr+pu5wOwdCgec95pMoS/Dz8Pg9wMY3clhBBCCAOTACVMnqJWYd+7FjmXU8iOrtikvL9zr9eQ5iG92P3DGlJvlb5FT1EUejVxI/zVAEb51+KryMsEzY5ky6nr9w1y9jWsCHi2PucOJHLuQGKl+y0rRa3GY9YsNG6uxI0eQ/7duwar/SAqRcV77d/jqbpPVe0QpVJDt3dhwNfFI85XhMDdWGN3JYQQQggDkgAlqgSL+tUwr+tAyuYYivIrdmfT33V6ZjDm1tZsX7H4gU+1rLRmTO1en9DJnanvasuY747y4oqDXLyRVup76rd1pV4bFyK/P0fKzfJN9asMtY0NnosXU5ieTsKEVyjKrdzwDV1SKSrebf/uvRC14dIGY7dUcY36wYgwyE0vPhd1OcLIDQkhhBDCUCRAiSpBURQcetci/0426fuuV3o9cysrug0bw+Wjhzi/v2xnhnycrFk5pDUrBj9G3N1MeszdxYzNZ0jPKfmsU8Cz9bG00RC28jQFFbyotyK0np54LlxA1okTXP/gg0pve9Slv4eot3e/ze8Xfzd2SxXn0ghG7gS35rDmKdi3SM5FCSGEEI8ACVCiytC4WmPdxpXU7VcpyMir9Hp1WrejbpsO7Fj1FdnpZR9Q0a2hC9smdWZSUF2+2RdL15kRrD+W8K+gorU0I3h4I25eSePQxphK91seVi1b4vbxR6T88it3Vq02aO0H+StE9a/Xn3f2vFO1Q5SVIzz/M7QfB9vehN9GQ57hnjgKIYQQwvAkQIkqxS7YG4qKSA3XzV1LgUNHkZ+by661q8v1PguNmvFd67L91S485lONSeuOM3DJPqKv/XN8uauvPW2e8OXItisknDPsmST7vn2pPmoUN774grQdOw1a+0FUiop32r1zL0Stv7je2C1VnNoMQj6C/isg+ndY2R2S44zdlRBCCCH0RAKUqFLUNlpsA73IOHCdvBtlGy1+P7aOTvg/N4ST27cSf+bPcr/fw8GSRc+34rsRbbmbmcfj83fx3u9/kpL5/0/IWoR441HXgbBV0WSnV/7JWXnUmDQR26BuXJs6lexz5wxa+0H+ClFP13uad/e8W7VDFECTp2H4Nsi8U3wu6speY3ckhBBCCD2QACWqHNuOHqjtzUnZrJttcc2CeuBeryFhSxeQn1exgNOxjhNbJvrzVq+G/HI0gcBZEfxw8CqFhUWoVApBQ/3Izytg57dnDXomSVGpcP/Pf9D4eBM3Zgz5t24ZrHZZqBQVb7d7+16I+u3Cb8ZuqXLcmsGoCHBuCF/3gUPL5VyUEEII8ZCRACWqHEWjwr6nL9ln75B9ofLb4hSViuBR40lOSuTg+h8rvI5GrWKEfy12vBpAl3o1eOPXUzy5aA/H45KxqWZB1xcbcvn4TU7vulbpnstDZWWF16JFkJdP/LjxFObkGLT+g/wVogbUG8B7e9+r+iHK2gle/A0eGw5/vAobX4F80/ozF0IIIUTFSYASVZJlEye0PnYkb7pMUUHlf8Pv5OVNm779OfDbT9yOr9z5FWc7C2YPas5Po9uTW1BEv4V7eP3nk9jXsaNRZw/2/HSBO9cMewGrxtUVz0ULyT57lutvv2NSk/mgOERNbzedgfUHPhwhSq2BXp9D34Vw4gdY/TikGe5OMCGEEELojwQoUSXdG2uelEnGYd38YNr2yUHYO7sQtmw+RYWVHzve2seRTRM68VHfRmw9nUjgzAiueGmwrW5B6IrT5OcV6KDrsrNs0gT3zz4ldeNGbi9ZYtDaZaFSVLzV9q2HJ0QBtHgBhm6BlDhYEgDxh43dkRBCCCEqSQKUqLK0XrZYtXAmNfQKhdkl38VUHmZaLcGjxpNwNpqT27fpoENQqxRebO/DjlcD6N3Ujfc3n2G9ZS53EjPY9+slndQoD7uePXGaMJ6bc78kdatuvkddeihDlOdjxeeiHGrCqp5w7FtjdySEEEKISpAAJao0ux4+FOUWkBahm7HRXn5NaBwYwq61q0m/e0cnawJUtzHn06easn5sR3Js1IRpczi5M54TBwx7HgrAaexY7Hr14tobb5D152mD13+QhzJE2brCkE3Q7Bn4fRxsngYFhp3IKIQQQgjdkAAlqjQze3NsOnuStjuB/DvZOlmz8wtDUWs07Fy9VCfr/V0zLwd+G9OBZ57146p5EWGrz7B023nyCiq/ZbCsFEXBbcYnmNerR/zYseQlJRmsdlk9lCHKzBz6zINeM+HwCljzJGTcNnZXQgghhCgngweotLQ0WrduTfPmzWnSpAnLli2797VNmzZRv3596taty/Llyw3dmqiibDt7orLUkLJVN2PNLW1s6TJ4JOf37+bSkQM6WfPvVCqFQW1qMmV6O7RaNRc2XqHn3Cj2XDTciHGVhQWeC+aDSkX82HEUZmUZrHZZPZQhSlGgzUh4aQPcOFN8X9T1k8buSgghhBDloBQZeBxXQUEBOTk5WFlZkZmZSePGjTl06BD29vb4+fmxc+dO7OzsaNmyJQcOHMDR0bFM66ampmJvb09KSgp2dnZ6/i6Eqck4nMTdn89TY0wzzL0r/++/qKiIXz97n9txVxkyayFaSysddPlvcdF32DDvOBfdzfgtM43eTdyY3rsh7g6Weqn3v7Kjo4l9/gVsOnfGY85sFJXpPZQuLCpkxoEZrDu3jg86fMBTdZ8ydku6kRwH656Hm+eh30Jo3N/YHQkhhBAPDX1mA4P/tKRWq7GyKv5hNDs7m4KCAoqKijh48CCNGjXCw8MDW1tbevXqxbZtpnfIXZgmq5bOaNyti8eaF1b+dwKKohA0fAxZ6ansWae/Q/9efo40D65JvaQCPu/agIOxd+g2K5KFOy+Sk6//KX0Wfn54fPE5adu2cXP+fL3XqwiVomJ62+kMqj+I9/a+x68XfjV2S7rh4AVDt0LDx+HnYRD+PhQadjKjEEIIIcqv3AEqKiqKPn364O7ujqIorF+//l+vWbRoEb6+vlhYWNCqVSt27dr1j68nJyfTrFkzPD09mTZtGk5OTly7dg0PD497r/H09CQhIaH835F4JCkqBfvetciLSyPr5E2drGnv7ErHAc9zdOtGrl88p5M1S9Kuby2qe9iQt+cm28Z34oV2NZkTdp7uc6LYefaG3ur+xTYoiBpTpnB78VekbNyk93oVoSjKwxmitFbw1DII+Rj2fAlrB0FWsrG7EkIIIcR9lDtAZWRk0KxZMxYsWFDi19etW8ekSZOYPn06x44dw9/fn549e3L16tV7r3FwcODEiRPExMSwdu1akpKSSrzYU1GU8rYnHmEWtR2w8KtOypZYinR0x1LLXn1x9q5F2NIFFORXflR6SdRmKoKH+ZF+N5vjG2KY3tuPLRP9cXewZOjqQ4z4+jBXb2fqpfZfqo8cgX3fvlyfPp2s48f1WquiHtoQpSjQYQI8/zPEH4Tl3Yq39QkhhBDCJJU7QPXs2ZOPP/6Yp54q+RzC7NmzGT58OCNGjKBhw4bMnTsXLy8vFi9e/K/Xuri40LRpU6KiovDw8PjHE6f4+Hjc3NxK7SMnJ4fU1NR/fAhh38uXgvRc0nbp5umlSq0m5OUJ3Lp6haObf9fJmiWp5mqN/6B6nNlznYtHblDXxZbvRrRl4XMtOX0thaA5kcwJO0+2ni7fVRQF148+xKJxY+LGTyDvmuHHq5fFQxuiAOp0g5E7QWVWHKLObTV2R0IIIYQogU7PQOXm5nLkyBFCQkL+8fmQkBD27t0LQFJS0r2wk5qaSlRUFPXr16dNmzb8+eefJCQkkJaWxubNm+nevXuptT799FPs7e3vfXh5eenyWxFVlMbJEpv27qRFxFGQlquTNV1q1aFlrz7s/WktyUmJOlmzJA07uFG7pTMR350l7U42iqLQu6kb218NYEQnXxZFXCRodiShpxNLfGJbWSqtFs8F81GZmxM3ZiyFGRk6r6ELD3WIql4bRoSDb2f4/hmI+gIMO+dHCCGEEA+g0wB169YtCgoKcHFx+cfnXVxcSEws/sEzPj6ezp0706xZMzp16sT48eNp2rQpZmZmzJo1i8DAQFq0aMFrr71G9erVS6315ptvkpKScu8jLk43F6mKqs+uqxeKmYrU0Cs6W7PDwBewtLMjfPlCvYQXKA4GXZ6vj8ZcTdjK0xT+dxiGldaMaT0asG1SZ2rXsGHUmiMMWXWImFu6Dzhmjo54Ll5EXnw8Ca9No6jANIcaPNQhytwWBq6BLm/Ajo/hp8GQk27sroQQQgjxX3qZwve/Z5eKiorufa5Vq1YcP36cEydOcPLkScaMGXPvdU888QTnz5/n4sWLjBo16r41zM3NsbOz+8eHEAAqKw12Qd5kHE4k95pufvDUWlgSNGIsV04e48zuCJ2sWRILaw3BwxqReCmFI1ti//G1WjVsWD20NUtfbMWlm+l0nxPFF9vOkpmr27NZFvXq4TF7FukREdycM0ena+vSQx2iVKriADXoW7i4HVZ2h7uxxu5KCCGEEOg4QDk5OaFWq+89bfrLjRs3/vVUSgh9sm7ripmTJSl/XNbZE6NaLVpTv70/EV8vIytNf2fu3Os60KqXD4f+iOX6pZR/fE1RFEIauRI+JYAxXWqzbFcM3WZF8sfJ6zp9MmYTEIDztNe4vXwFyb+a7gW2fw9R7+99/+G4bPfvGvaB4WGQmw5LA+FypLE7EkIIIR55Og1QWq2WVq1aERYW9o/Ph4WF0aFDB12WEuK+FLUK+961yLmUQvbZOzpbN3DIKAoLC4hcs1Jna5akdS8fXHzsCFtxmpysfz9hstComRxcj/DJATRyt2fc2qO8sOIAF2+k6awHx8GDcRgwgOvvvUfm4cM6W1fX/gpRA+sP5L297z18IcrFr3i4hFtTWPMkHFgi56KEEEIIIyp3gEpPT+f48eMc/++o45iYGI4fP35vTPmUKVNYvnw5K1eu5MyZM0yePJmrV68yevRonTYuxINY1K+GeR0HUjbHUFRQqJM1rR2q0fn5oZyODOfqnyd0smZJVOri0eY5mXlEfne21KdLNatbsXzwY6wa0pr4u1n0mLuLT/6IJj2n8tv6FEXB9Z23sWrRgvjxE8g14XOGD32IsnKE53+BtqNhyzTYMB7yc4zdlRBCCPFIUorKue8nIiKCwMDAf31+8ODBrF69Gii+SPfzzz/n+vXrNG7cmDlz5tC5c2edNFya1NRU7O3tSUlJkfNQ4p7c6xncmHcUh8drYdPR48FvKIOiwkLWffAmGcl3eOmLBWi05jpZtyQXDiURuuI03QY3pEH70sf6A2TnFbBidwzzd1zAzkLDW70a0re5e6XvU8u/e5fYZ55B0Wjw+eEH1DY2lVpPn4qKivjkwCf8eO5HPujwAU/WfdLYLene8e9h48TiJ1KDvgVbV2N3JIQQQpgcfWaDcgcoUyUBSpTm7i8XyDp9C9epj6Gy0uhkzdvxcax5fQKP9elPp2de1Mmapdm+OpqLx24yaHprHJytHvj6hOQsPt4UzZY/E2nj68iHfRvRwLVy/5/IuXyZ2EHPYNmiOV6LF6Oo1ZVaT58eiRAVfwTWPV/8vwd9B56tjNuPEEIIYWL0mQ30MoVPCFNiF+JNUX4RqTt0twWtuqcXbfoN5NCGn7l1NVZn65bE/5l6WNlpCVtxmoL8B29F9HCwZPELrVgzvA230nPoPW837284TUpWXoV7MK9VC4+5c8jYs5cbn39R4XUM4aHfzgfFgWlUBNh7waqexU+lhBBCCGEQEqDEQ09tq8U20JP0fdfIu5Wls3Xb9BuAg4sbocsWUFSomzNWJdFamBEyvBG34tI5uDGmzO/zr1uDrRM7M617fX48HEe3WRH8dDju3v1S5WXTsSMub73Jna+/5u6PP1ZoDUN5JEKUrSsM2QRNB8D60bBtOhTodqS9EEIIIf5NApR4JNh28kBtoyVlS9kDyIOYaTQEjxrP9fNnORG+VWfrlsTFx462fWtxNPQK8eWYKqg1U/FyQG12vNqFDrWdeO3nkzz91V7+TEh58JtL4Pj881R77lkSP/yIjP0HKrSGoTwSIcrMHJ5YAD0/h/2LYe0AyLpr7K6EEEKIh5oEKPFIUDRq7Hv6kH36NjmXk3W2rmfDxjTp1p1da1eTdueWztYtSYvgmnjUq0b4qmiy0nPL9V5XewvmPduC70e2Iz0nnycW7Oad9X+SnFm+dQBc3noL6zatiZ84kdzY2HK/35AUReGttm8xoN6AhzdEKQq0fRle/A2uHYNlXeHGWWN3JYQQQjy0JECJR4Zl0xpovGxJ/iOGogpuYytJ5+eGYqbVsnPVUp2tWRJFpRA0xI+C/CJ2ril9tPn9tK9dnT9e8Wd6bz/WH0ug66xIfjh4tVzb+hQzMzzmzMHM0ZG4MWMpSNXfpcK6oFJUTG83/eEOUQC1AorvizKzhOXd4OxmY3ckhBBCPJQkQIlHhqJScOjtS15COpnHbuhsXQsbG7oOfZkLB/dy8dB+na1bEptq5gS+2ICYE7c4HZVQoTU0ahXDO/myfWoAXerV4I1fT/Hkoj2ciEsu8xpqe3u8Fi8i/84dEiZNpijftM/e/BWinq73NO/tfY/1F9cbuyX9cPSF4aFQOxB+eA6ivpBLd4UQQggdkwAlHinmPvZYNnUiZVsshbkFOlu3XrtO+LZ4jO0rF5OTmamzdUtSq3kNGnf2YPfPF7lzLaPC6zjbWjB7UHN+Gt2e3IIi+i3aw5u/nuRORtm29Wl9fPD88ksyDh4k6dPPKtyHoagUFW+3e5un6z3Nu3vefXhDlLkNDPgGurwBOz6Gn4ZAbsX/ngghhBDinyRAiUeOfQ9fCjPySIuM19maiqIQNHws2Rnp7Fm3RmfrlqbD03Wwc7IkdMWf5OdVLgi29nFk4/iOvN+nEZtOXqfrrAi+3X+FgjJs67Nu1xbXt9/m7nffcWft2kr1YQh/haj+9fo/3CFKpSoOUAPXwIUwWNkdkq8auyshhBDioSABSjxyzBwtsOnkQXpUPAUpOTpb166GM50GvcixbZu4fvGcztYtiUarJmR4I5KTstj366VKr2emVjG4gw87p3YhxM+Ft9f/Sd+Fuzl69cET3ao9M4hqL71I0iczSN+zp9K96JtKUfFOu3fuhajfL/5u7Jb0x+8JGBEG2SmwNBBiTf/fjxBCCGHqJECJR5JdoBeKVkVK6BWdrtuiRx+cfWoRtmQ+BXo+F+TkaUOH/rU5uTOe2FO6mQDoZGPO508349exHQB4atFeXvvpBLfS7x80XaZNw7pjBxImTSbn8mWd9KJPf4Wop+o+xTt73nm4Q5RLIxgZAc4N4Zsn4NAKY3ckhBBCVGkSoMQjSWVhhl2wN5lHk8hNSNfdumo1IaMmcCvuKkf+WK+zdUvTpIsn3o2rs+ObM2To8Glay5rV+H1cJz7u15jQ6CS6zozg672x5BeUfGGwYmaGx6xZmLk4EzdmDAXJyTrrRV9Uiop32797L0RtuLTB2C3pj3X14jHnrYbCH1Ng02QoyDN2V0IIIUSVJAFKPLKsW7thVsOK5E2XKzQSvDQuterQstcT7Pv5e5ITr+ts3ZIoikLXlxqCorD96zM6Hc+uVim80M6bnVO70LupO+9vPE2fBXs4FFvyRb5qW1u8Fi+mMCWV+ImTKMoz/R/Q/x6i3t79NhsvbTR2S/qj1kDvmdDnSzi6Br7pBxm3jd2VEEIIUeVIgBKPLEVdPNY8NyaF7Gjd/iDZYeDzWNnbE75ikU7DWUms7LQEDW5IXPQdTuyI0/n6jtZaPn2qCevHdkSrVhjw1T6mrDvOjbTsf71W6+WF5/x5ZB49SuJHH+v9e9eFv0LUk3WfZPru6Q93iAJoNQQGb4CbZ2FZF0j809gdCSGEEFWKBCjxSLOo74h5vWqkbI6hKL/k7WkVobWwpNvwMVw5eYyzuyN0tm5pajaqTrMgL/b9dombV9P0UqOZlwO/je3IZ081Yee5G3SbGcmK3TH/2tZn1bo1bu+/R/KPP3J3jf4nEuqCSlHxXvv36FenH2/veZtNlzcZuyX98u4Ao3aChT2sCIEzD3loFEIIIXRIApR45Dn08iX/Tjbp+3W73a5Wi9bUb+/Pzq+XkZWWqtO1S9K+b20c3a0JXXGavBzd3XH1dyqVwjNtarJzahf6tnDn4z+i6T1vN/sv//MJnkP//jgOG0bSZ/8hfdcuvfSiaypFxfsd3ueJ2k8wfff0hz9EOdSEYdugbjCsewEi/gOFuvslghBCCPGwkgAlHnkaV2us27iSuv0qhZm6PbcTOGQUhYUFRK5ZqdN1S6LWqAgZ3oj0u9ns/vmCXms5WGn5uF8TNo7vhJW5mmeW7mfiD8dISv3/bX3Or07BpnNnEiZPIefiRb32oysqRcUHHT6gT60+TN89nT8u/2HslvRLaw0DVkPg2xAxA34aLJfuCiGEEA8gAUoIwC7IGwqLSN2u28tGrR2q0fn5oZyODOfqnyd0unZJqrla4z+wHtG7rnHp2A2912vsYc8vozvw+dNN2X3hFl1nRrAs6jJ5BYUoajXuM2eicXMjbsxY8u8++E4pU/BXiHq81uO8tfstNl/ebOyW9EtRIOA1GPQdXNwOK+TSXSGEEOJ+JEAJAahttdgGepG+7zp5NzN1unaTwBA8GjQifPlC8nNzdbp2SRp2dKN2ixrsXHOW9Lv/HvSgayqVwsDHvNgxtQsDHvPi0y1n6PnlLvZevIXaxhrPxYspzMggYcIrFBng+9cFtUrNhx0+5PFaj/Pm7jfZErPF2C3pX8PHiy/dzfnvpbtX9hm7IyGEEMIkSYAS4r9sO3qgttOSsiVWp+sqKhXBI8eTcuMGB35bp9O1S6ynKHR5oQEaczXhq6Ip1OFo8/uxt9Tw/hON2DTBn2pWGp5bfoBxa49y29YRz/nzyDpxgusffFAlJvPB/4eo3r69eWPXG2yN2WrslvTvr0t3azSAr/vA0W+M3ZEQQghhciRACfFfikaFfU8fsqNvk30pWadrV/f0ou2TAzj4+y/cirui07VLYmGtIWioHwkXkjkWqv96f+fnbsePL7dn9sBmHLh8h26zIvk6zQGn998n5ZdfubP6a4P2UxlqlZqPOn70/yEq9hEIUX9dutviBdgwAba8DgX5xu5KCCGEMBkSoIT4G8umNdDWtCVl02WdXkoL0KbfQOxdXAlbuoAiA0w786hXjVbdvTmwIYbEmBS91/s7RVF4qqUnO6YG8EzrmswMPcfAWEcy+z/Hjc8/J23nToP2Uxl/haievj15I+oNtsVuM3ZL+memhT5zofcsOLgMvusPmSVfoCyEEEI8aiRACfE3iqJg37sWedczyDyq2yEMZhoNwSPHce38GU5uN8wP4a37+FKjpi1hK06Tm234pwh2Fhre7ePHH690wsnGnKfzm3OpbkviX51K9rnzBu+notQqNR93/JjuPt15Per1RyNEAbQeAS+th+snYHk3uHnO2B0JIYQQRicBSoj/Ye5th2VTJ1K2xVKYq9v7lLz8mtA4MIRda1eTflf/v9FXq1WEDPcjKy2PqB+MF1gauNqxblQ75j7bkv+0fJYYjQPRw0aSmaT/SYG6olap+aTTJ/dCVNiVMGO3ZBi+nWHkTlBrYXkQXHhEvm8hhBCiFBKghCiBfQ9fCrPySIuM1/nanV8YilqjYefqpTpfuyT2NawIeLYe5/Yncv5gokFqlkRRFPo292DzGyGcGf8u2emZbB84jMjTCUbrqbzMVGZ80ukTQrxDmBY5jfAr4cZuyTAcfWF4GHh3gLUDYe98qCLDQIQQQghdkwAlRAnMHC2w7ehBelQ8BSk5Ol3b0saWLoNHcn7/bi4dOajTtUtTr60rdVu7ELn2HKm3sgxSszS2FhpefTGA6rPn4nPrCscnv8HL3xwi/q5ux8fri5nKjBn+MwjyDuK1yNfYfmW7sVsyDAs7eGYtdHgFQt+G38dBvm7/vyGEEEJUBRKghCiFbaAXilZNyrZYna/doENnfJq1ZPvKxeRm6z/QKIpCwHP1MbfWELbyNIUF+h9i8SD1u3XE69NPCLl6GLetvxA0O5L52y+QnafbbZP6YKYy41P/T+nm3Y2pkVPZcXWHsVsyDJUagj+AJ5fCqZ+LR52nV51tmEIIIYQuSIASohQqCzPsgr3JPHqD3Pg0na6tKApBI8aSlZrKnnXf6nTt0phbmhEyvBFJsWkc2hxrkJoP4vDEE1R/+WUGHdvA67Y3+HL7BXrMjWLnOdP/odxMZcZn/p/RtWZXXo18lZ1Xq85kwUprNgiGboa7scWX7l4/YeyOhBBCCIORACXEfVi3dsXM2YrkP2J0fgGsvbMrHQY8x7EtG0m6fFGna5fGtZY9rXv7cGRzLNcuJBuk5oPUmPgKtkHdaP/DPLb0ccXdwZKhqw4x8pvDxN0x7W19ZiozPuv8GYFegUyJnEJEXISxWzIcz8eKh0tYO8GK7hD9u7E7EkIIIQxCApQQ96GoFRx6+5Ibk0J29G2dr9+qdz+cvH0IXTKfwgLDbF1r1dMH19r2hK08TXZGnkFq3o+iUuH+n/+g9faG6VP5ul9tFjzXglPxKQTNjmSeiW/r06g0/Kfzf+ji2YXJEZOJjIs0dkuGY+8BQ7dA/Z7w40sQ8R8ZLiGEEOKhJwFKiAewqO+Ieb1qpGyOoShft2eHVGo1ISPHc/NKDEe3bNDp2qXWVCkEDfUjN7uAyLXndP5krUI9WVnhtWghRXl5JEx4hV71q7P91QCGdvRl3vYLdJ8bxY6zScZus1QalYbPAz4nwDOAyRGTiYqPMnZLhqO1gqdXQuB0iJgBPw+DXNN+ciiEEEJUhgQoIcrAoZcv+XeySd9/Xedru9apR/Mevdnz47ek3DBMSLCrbkmX5+tz8cgNzu7T/fdUERo3N7wWLiT7zBkS330XK62aN3o2YOukznhVs2LY6sOM+Np0t/VpVBq+6PwF/h7+TNo5id0Ju43dkuEoCgRMg4HfwPmtsKonpF4zdldCCCGEXkiAEqIMNK7WWLd2JXX7VQozdb/trdOgF7GwsWX7ysUGeyJU9zEXGnRwI2rdBZKTTCOUWDZtitsnn5Dy+wZuL1sOQB1nG9YMb8PC51py+lrxtr4vw01zW59GrWFmwEw6enRk4o6J7EnYY+yWDMuvLwzbChm3iodLJBwxdkdCCCGEzkmAEqKM7IK9obCI1O1Xdb621tKKbsPGEHPsMOf3G+7Jhf/AuljbawldcZoCHW9PrCj7x3vjNHYMN+fMIS28+KJaRVHo3dSN8CkBDOvky4KdFwiZY5rb+jRqDbMDZtPBvQOv7HiFvQl7jd2SYbk1g5E7wMELVvUqHncuhBBCPEQkQAlRRmpbLbZdvEjfd528m7p/YlPnsbbUbdOBHauWkJ2ervP1S6K1KB5tfjs+nQMbLhukZlk4jR+PbXAwCdNeJ/vs2XuftzY34/Uexdv6vKv/ta3vkMlt69OoNczqMot27u14Zecr7Lu2z9gtGZatCwzeBH794JfhsONjKDSNgC6EEEJUlgQoIcrBtpM7ajstKVti9bJ+4NBR5OfmsGvtar2sXxJnbzva9q3FsbCrxJ29Y7C696OoVLh/9inmPj7EjRlL/s2b//h67Ro2fDOsDYufb0n0tVSCZkcyN/y8SW3r06q1zOkyhzaubZiwYwL7r+83dkuGpbGAJ7+CoPchaib8NBhyM4zdlRBCCFFpEqCEKAdFo8a+hw/Z0bfJuZys8/VtHZ3wf3YIJ7dvJf7saZ2vX5oWwTXxqFeN7auiyUrPNVjd+1FZWeG5aCHk5xM/fgKFOTn/+LqiKPRs4kb4qwEM7+TLwp0XCZkTxfYzprOtT6vWMidwDo+5PsaE7RM4eP2gsVsyLEWBTpPhme/g4nZY2QNSEozdlRBCCFEpEqCEKCfLpjXQeNkWX65bqPuBD82Ce+JWtz5hSxeQn2eYe5oUlULQED8K8ovYueasSYw2B9C4uuK5cAHZZ89y/Z13SuzLSmvGtL9t6xv+dfG2vqu3TWNbn7nanC8Dv6SVSyvGbR/HocRDxm7J8Br0huHbIOsuLAuE+MPG7kgIIYSoMAlQQpSToiq+XDcvIZ3MYzf0sL6K4FETSE68xqENhjuAb1PNnMAXGxBz4hand5nOCGrLpk1xm/EJqRs2cnvpslJf969tfXNMZ1ufudqcuYFzaeHcgnHbx3E48REMEK5N/jtcwluGSwghhKjSJEAJUQHmPvZYNnEidVsshbm6/wG9Rk0fHnv8SQ78uo471+J1vn5pajWvQaPOHuz56QJ3rpnOeRX73r1xGjuWm3PmkBoWVurr/r6tb8R/t/UFz4k0iW19FmYWzOs6j6Y1mjJ2+1iOJh01dkuGZ+MMgzdCoydluIQQQogqSwKUEBVk38OHgow80nfp50xHu6efxbZ6DcKXLTTolrqOT9fBtroFoStPk28CT2/+4jR+HLbdu3Nt2utknzlz39f+fVufT3Vrk9nWZ2Fmwfyu82ni1IQx4WM4duOYUfsxir+GS3R7r3i4xM9DINc0tlsKIYQQZSEBSogKMqtuiU1Hd9Ii4ihIzXnwG8pJozUnaMQ44qJPcToiXOfrl15XTciIRtxNzGD/b6Yz2vzeZL5atYgbO+5fk/lK8vdtfadNZFufpZkl87vOx6+6H2PCx3D8xnGj9WI0igL+U2DQt3AhDFb1hFTT2TYqhBBC3I8EKCEqwS6wJopGRUroFb2s7920OQ39A4n8diWZqSl6qVESJ09bOjxZhxM74rjy522D1X0QlaXlvcl8cePH/2syX0n+2ta33YSm9VlprFjYbSH1q9VndPhoTtw8YbRejKrh4zBsK2TchGVd4doj+EROCCFElSMBSohKUFmaYRfkTeaRJHKv6efy2y4vjQAg4pvlelm/NE27elKzUXW2fx1NZqppjDYH0Li44LloITlnz3H97ZIn85XESvv/l/DWdPz/aX3GuoTXSmPF4qDFxSEqbDSnbp4ySh9G59aseLiEnTus7Amn1xu7IyGEEOK+JEAJUUnWbV0xc7Ik5Y/LejmrZGVnT8CLwzmzayexJw33G3pFUeg2uCEA278+YzKjzQEsmzTB/dMZpG7cyO0lS8v13to1bFgzvA2L/trWNzuSL8MvGGVbn5XGikVBi6jjUIeXw17m9C3D3f1lUmxdYcgf0KBX8YW7kV+ACf19E0IIIf5OApQQlaSoVdj38iXnUgrZZ+/opUajgG54NWpK+PKF5OVk66VGSazstHQb7MfV07c5udNw0wDLwq5Xr+LJfHPn3ncyX0kURaFXEzfCpwQwtKMvC3ZeoPvcKHae1f1Y+gex1lizOGgxvg6+jAwbSfTtaIP3YBI0ltB/BXR5C3Z+DL+OgjzD/V0XQgghykoClBA6YNHAEfPa9qRsjqGoQPdjmRVFIWjEONLv3Gb/Lz/ofP378W5cnaZdPdn36yVuxetnm2JFOY0fh22PHsWT+aLLHzyszc14o2cDtkzsjFc1K4auPsTIbw4bfFufjdaGr4K+wsfOh5GhIzl756xB65sMRYEur8PTq+DMBvjmCUh/8LAQIYQQwpAkQAmhA4qiYN+7Fvm3ssg4mKiXGo7uHrR9ciCHN/3GzSsxeqlRmvZP1sbBxYrQFafJ18O9VxWlqFS4fzqjXJP5SlLHuXhb38LnWnIqPoWg2ZHM327YbX22Wlu+Cv4KL1svRoaO5NydcwarbXIaPwVDNsOdGFjeFZIe0adyQgghTJIEKCF0ROtug1UrF1LDrlCYla+XGm36Po2DqzthSxdQWGi4H+7NNGqCh/uReiuLPb9cNFjdsrg3ma+goMyT+UqiKAq9mxZP6xvS0Ycvt1+gx9woIs4ZblufndaOJcFLcLN2Y2ToSC7cvWCw2ibHs1XxcAlzO1gRAhcMN8pfCCGEuB8JUELokH2IN0V5haTujNPL+mozDcGjxnP94jlOhG3RS43SVHe3oWP/OvwZmUDMyVsGrf0gFZ3MVxJrczPe7NmQrZP8cXewZMiqQ7y85jDxdw2zrc/e3J5lIctwsXZhROgILt41rcBqUA5exWPOfTrB2gFwYImxOxJCCCEkQAmhS2o7c2wDPEnfk0D+Hf0cgPds0Iim3Xqw+/uvSbtj2CDTOMADn6ZO7PjmDBkpur88uDIqM5mvJHWcbfluRFsWPNeC43HJBM2OZOHOi+Tk6//Jn725PcuCl+Fk6cTw0OFcTjadC40NztwWnvkO2o2FLdPgj1ehQD9PeIUQQoiykAAlhI7ZdPZEZa0hZav+zin5PzcEM605O1dVPiiUh6IodH2pASq1wvbV0RQVmtao6cpM5iuJoig83tSd7a92YXB7H+aEnafH3F1Endf/YAMHCweWhyynumV1hocOJybFsOfeTIpKDd0/gT7z4Mjq4qdR2Ya7WFoIIYT4OwlQQuiYSqvGvrsPWSdvkXMlVS81LGxsCBwyigsH93Lx8AG91CiNpY2WoMF+xJ25y/Ht+tmqWBlO48dh27178WS+M2d0sqaNuRlv9mrIlon+uNiZ89LKg4z59gjXkrN0sn5pqllUY1nwMuy19gzfNpwrqVf0Ws/ktRoML/wKCUeKz0XdjTV2R0IIIR5BEqCE0AOrFs5oPGxI2aSfy3UB6rf3x7d5K7avXExulmHHbnv5OdI8uCb711/i5tU0g9Z+EEWlwv2zTys9ma8kdV1s+X5kO758pjlHrtyl26xIFkdcIjdf96Pr/1LdsjrLuy/HRmvDsG3DuJp6VW+1qoRaATA8HPJzYFk3iDto7I6EEEI8YiRACaEHikrBvpcvuXFpZJ3Uz3YvRVHoNnws2elp7F63Ri817qdd31o4ulsTuuI0eTmmM9oc/jaZLz+f+PETKjyZrySKotC3uQfbXw3gubY1mRl6jp5fRrHnov7OozlZOrEiZAVWZlYM2zaMuDTTe/JnUDXqwYjt4FQXVj8Op342dkdCCCEeIRKghNATi9oOWPhVJ2VLLEV6uk/I3tmFjgOe59jWTSRePK+XGqVRm6kIGd6I9LvZ7P7J9MZt/zWZL/vs2UpP5iuJrYWGdx73449XOlHd2pznlx9g/NqjJKboZ3hIDasaLA9ZjrnanOHbhpOQnqCXOlWGdXV46Xdo9CT8Mhwi/gN6etorhBBC/J0EKCH0yL6nDwWpuaTtuaa3Gi179cXZuxahyxZQWGDYJ0HVXK3pNKAu0buvcemY4e5LKivLJk1wm/FJ8WS+pcv0UqOBqx3rXm7H7IHN2H/5Nt1mRbAs6jJ5Bbrf1udi7cKK7itQK2qGbxvO9fTrOq9RpZiZw5NfQeDbEDEDfh1VvLVPCCGE0CMJUELokaaGFTbt3EjbGUdBeq5eaqjUaoJHjefWlViObP5dLzXux6+TO7Va1GDnmrOk39XP05fKsO/dG6exY7g5Zw5p27frpYaiKDzV0pPtr3ZhwGNefLrlDL3n7WL/5ds6r+Vq7crK7isBGLZtGIkZiTqvUaUoCgS8Bk+vhOjf4Zu+kKH7P3chhBDiLxKghNAz2241QVFIDdPfBDXX2nVp0eNx9v70HSk3kvRWpySKohD4QgPMtGrCV0VTaGKjzQGcxo/HNiSEhNemkX32rN7q2FtqeP+JRmyc0AkbczOeWbqfST8c40aaboOlm40bK7qvoKCogOHbhnMj0/Se/hlc4/4wZBPcugDLu8GtR/gCYiGEEHolAUoIPVNba7Dr5kXGwUTykjL0VqfjoBewsLFl+4pFepv8VxoLaw1BQ/1IuJDMsVDTG7X912Q+rY83cWPHkn9LvxcQN3K35+fRHfi8f1OiLtyi28xIVu6OIV+H2/o8bDxY0X0FOQU5DN82nJuZ+r+byuR5tYER4aDWFIeo2N3G7kgIIcRDSAKUEAZg094dtaMFKZv1dxmq1tKKbsPGEHP8COf27dJbndJ41q9GyxBvDm6IISlWP/dfVYbKygqvRYsoyssjfsIrFObqZ0vlvXoqhYGtvdjxagBPNHfnoz+i6bNgD0eu3NFZDS9bL1Z2X0lmXiYjQkdwK0u/wbBKcPSF4WHg1hS+6QfHvzd2R0IIIR4yEqCEMADFTIVDT1+yz90l+/xdvdWp81hb6rbpwM7VS8lOT9dbndK0ecIXJy8bwlacJjc73+D1H0Tj6orXggVknz5N4jvvGuRJnYOVlk+ebMLv4zqiVSv0X7yP1346wa103Qw7qGlXkxXdV5Cam8rI0JHcydZdQKuyLB2KL9xt9gysHw07PpEJfUIIIXRGApQQBmLRqDpaHzuS/7hMkR7PCQUOHUV+bg671q7WW43SqNUqgoc3IiM1l13rDDtWvawsmzXD7ZNPSPn9d+6sWGGwuk09Hfh1bEc+ebIxodFJdJ0ZwZr9VyjQwd8FH3sfVnRfwZ3sO4wMHUlydnLlG67q1Bp4Yj4EvQ9Rn8MvIyDP9IacCCGEqHokQAlhIIqi4NC7FvlJmWQc1t/kNFtHJzo9O5iT27cSf/a03uqUxsHZis6D6nF2XyIXDht2oEVZ2fd5nOovv8yNWbNJ27HDYHXVKoXn23qz49UAejZ24531f/Lkoj2ciEuu9Nq17GuxImQFNzNvMjJsJCk5KZVvuKpTFOg0GQZ8DWc3wZp+MqFPCCFEpRk8QMXFxdGlSxf8/Pxo2rQpP/30072vxcTEEBgYiJ+fH02aNCEjQ38H7oUwBq2XLVbNa5AaeoXCHP1tcWsW3BO3OvUJX7aQgvw8vdUpTYP2rtRp5UzEd+dIvZ1l8PplUWPiK9gGdePa1NfIPmfYp2XVbcz5z9NN+WVMB/ILiui3aA9v/nqK5MzKncuqU60Oy0KWkZiRyKiwUaTmmt5ZNKNo1A8G/3dC34oguH3J2B0JIYSowgweoMzMzJg7dy7R0dGEh4czefLke0FpyJAhfPjhh0RHRxMZGYm5ubmh2xNC7+x6+FCYXUBaRLzeaqhUxXdD3b2ewKHff9FbndIoikLAc/XRWpruaPPiyXyfoalZk/gxY8i/bfgnE628q7FhfEfee9yPTSeu0XVWJD8eiqvUn1d9x/osC1lGfFo8Y8LGkJ5r+LNwJsmrdfGEPkUNy4Pgyj5jdySEEKKKMniAcnNzo3nz5gA4Ozvj6OjInTt3OH36NBqNBn9/fwAcHR0xMzMzdHtC6J2ZgwW2/h6k7UogP1k3gwRKUsPbl1aPP8n+39Zx51qC3uqUxsJaQ/DQRiReSuHIlliD1y8LlbU1XosWUpibS/wrE/U+ma8kZmoVQzr6sn1qAAH1ajDtl5MMWLKP6GsVf3rUwLEBS0OWEpMSw5jwMWTkydN84L8T+kLB2Q++eQJO/WzsjoQQQlRB5Q5QUVFR9OnTB3d3dxRFYf369f96zaJFi/D19cXCwoJWrVqxa1fJI5UPHz5MYWEhXl5eXLhwARsbG5544glatmzJjBkzyv3NCFFV2HbxRGWhJnVbrF7rtO//DDbVHAlfvtDgd0MBuNd1oFVPHw79EUviZdM8k6Nxd8dz/jyyT54k8f0PjPLnBOBsa8GcQc35fmQ7UrPyeHz+Lj7YeJrU7IptwWxUvRFLgpdwMfkiY8PHkpmXqeOOqygrR3jxV2j0FPwyHKJmyoQ+IYQQ5VLuAJWRkUGzZs1YsGBBiV9ft24dkyZNYvr06Rw7dgx/f3969uzJ1atX//G627dv89JLL7F06VIA8vLy2LVrFwsXLmTfvn2EhYURFhZWgW9JCNOnMjfDLtibzGM3yI1P01sdjbkFQSPGEXf6JNFRhhuW8Hete/vg7G1L2MrT5GaZ3mhzAKsWLXD7+CNSfv2VO6tWG7WX9rWrs3miP6/3aMC6Q3F0mxXJ78cTKhTsmtRowuKgxZy9c5YJOyaQlW+a59EMzswcnvwKAt6AHR/BhglQYPizgkIIIaqmcgeonj178vHHH/PUU0+V+PXZs2czfPhwRowYQcOGDZk7dy5eXl4sXrz43mtycnJ48sknefPNN+nQoQMAnp6etG7dGi8vL8zNzenVqxfHjx8vtY+cnBxSU1P/8SFEVWL9mCtmLlYkb7qs16cePs1a0qBjABFrVpCZavinQCq1iuBhjchKzyPyh3MGr19W9n37Un3kCG588QVpERFG7UWjVvFyQG3CpwTwmHc1Jv5wnOeWHeDijfKH7ebOzVkUtIhTt04xccdEcgr0t220SlEUCHwT+n0FJ76HtQMhW/47IoQQ4sF0egYqNzeXI0eOEBIS8o/Ph4SEsHfvXgCKiooYMmQIXbt25cUXX7z3mtatW5OUlMTdu3cpLCwkKiqKhg0bllrr008/xd7e/t6Hl5eXLr8VIfROURePNc+NTSX7tH4HGAQOHgmFhUSuMdy9R39nX8OSgGfrc/5AEucO6G+Ee2XVmDwZm8BArr06lZwLF4zdDu4Olix+oRWrh7bmWkoWPb/cxWdbzpKZW74nea1cWrGw20KO3TjGxJ0TyS0w/Fkvk9X82eJLd+OPwKqekGL484JCCCGqFp0GqFu3blFQUICLi8s/Pu/i4kJiYvEPTXv27GHdunWsX7+e5s2b07x5c06dOoWZmRkzZsygc+fONG3alLp16/L444+XWuvNN98kJSXl3kdcXJwuvxUhDMKiXjXM61UjZUsMRfmFeqtjZe9A5xeGER21g6t/ntBbnfup39aVem1ciPz+HKm3THMrmaJS4f7552g8PIgbM5b8u3eN3RIAXeo7s21SZ8YH1mXlnhiCZ0ex7XRiuZ5ctnZtzfxu8zmceJgpEVPIky1r/69WAAzfBlnJxRP6Ek8ZuyMhhBAmTC9T+BRF+cc/FxUV3ftcp06dKCws5Pjx4/c+mjRpAhRvDzx16hR//vkns2fPvm8Nc3Nz7Ozs/vEhRFXk0NuX/DvZpO+/rtc6jQOD8WzYmPDlC8k3wrQ5gM7P1sfCWkPYytMUFugvMFaG2sYar8WLKMzMJOGViRQZ6c/qf1lo1EwMqkvY5M7Uc7Hh5TVHGLb6EFdvl304RDu3dnwZ+CV7r+3ltajXyCuUEHWPc8PiMefWTrCyJ1zcbuyOhBBCmCidBignJyfUavW9p01/uXHjxr+eSgkhimlcrLFu40rq9qsUZurvB1pFUQgaOY6UGzc48Ns6vdW5H3NLM0KGNyIpNo3Dm2ON0kNZaDw88Jw/j8zjx0n86GOjTeYriXd1a1YOac2SF1txPimd4DmRzNt+gZz8gjK9v6NHR+Z0mUNkfCRv7nqT/ELTHOxhFHZuMHQLeLeH7wbA0TXG7kgIIYQJ0mmA0mq1tGrV6l/T88LCwu4NixBC/JtdkDcUFJG6/eqDX1wJ1T28aNNvAAd//4Xb8fqtVRrXWva07u3D4c2xXLuYbJQeysKqVSvcPviA5J9+4u6ab43dzj8oikL3Rq6ETenMsE6+zNt+gR5zd7Hrws0yvT/AK4CZATPZfmU7b+95m4LCsoWvR4K5DTzzPbR8CTaMhx0fy5hzIYQQ/1DuAJWenn5v6x1ATEwMx48fvzemfMqUKSxfvpyVK1dy5swZJk+ezNWrVxk9erROGxfiYaK21WIb6En6/uvk6fl8UNt+A7B3diF06QKKCo2zja5VD29ca9kTvjKaHD0+dassh6eexHHoUJI++4z03XuM3c6/WGnNeL1HA7ZM9MfFzpwXVxxk3NqjJKZkP/C93Wp247POn7ElZgvv7X2PwiLT3FJpFGozeHwOdHsPor6A9WMg3zS2cgohhDC+cgeow4cP06JFC1q0aAEUB6YWLVrw7rvvAjBo0CDmzp3Lhx9+SPPmzYmKimLz5s14e3vrtnMhHjK2nTxQ22hJ2RKj1zpmWi3BI8dx7Vw0p3aE6rVWaVRqFUFD/cjJzCNy7TmT2iL3v5ynvoq1fycSJk8m5/JlY7dToroutnw/sh1zBjXjwOXbdJsVwfJdl8l/wDmz7j7dmdFpBhsubeDDfR9KiPo7RQH/KfDUcjj1s4w5F0IIcY9SZMo/uZRDamoq9vb2pKSkyEAJUWVlHrvBnXXnqDGqKea17PVaa+viuVw8uI+hc77C2qGaXmuV5sKhJEJXnKbbkIY0aOdmlB7KoiA9ndhnnqEoLw/fdetQOzgYu6VSpWTlMSv0HGv2X6G+iy2fPNmYVt6O933P7xd/55097zCw/kCmt53+r0FAj7yYKPjheXDwhud/BDt3Y3ckhBDiAfSZDfQyhU8IUTGWzWqg8bQh+Y/LFBXq93cbAS8MQ6VWs3P1Ur3WuZ+6rV2o386VqO/Pk3Kz7NPkDE1tY4PXokUUJqcQP3kyRXmmu+3Q3lLDh30bs2FcJ7RmKvov3sfrP5/kbkbpW9D61unLe+3fY925dXx+6HOTfiJoFL6dYdg2yLoDy4PhxhljdySEEMKIJEAJYUIUlYLD47XIS0gn80TZBgJUlKWtHV0Gj+Tcvl3EHDus11r30/mZeljaaghbGU2BiY42B9DWrInHvHlkHjpM0qefGbudB2riac9vYzvycb/GbPnzOl1nRbDu0FUKSwnm/ev15+22b/PtmW+Zc3SOhKj/5eJXPObc0gFWdIeYXcbuSAghhJFIgBLCxJj72GPZqDqpW2MozNXvdLSGnbrg3bQF4SsWkZf94MED+qC1MCN4eCNuXEnj0Cb9nv+qLOu2bXB95x3url3L3e+/N3Y7D6RWKbzQzpvtr3YhsIEzr/9yiqe/2kv0tZLP8gxqMIhpraex6s9VLDy+0MDdVgF27sVjzj1awLdPFZ+NEkII8ciRACWECbLv6UtBeh7puxP0WkdRFIKGjyUzOZm9P6/Va637cfW1p83jvhzZeoVrF+4arY+yqDZoINVefJHEjz8hY/9+Y7dTJjVszZk9sDk/jGpHWnY+fRbs5qNN0aTn/PsOqBf9XmRyq8ksObmEJSeWGKFbE2dhB8/9BI2egl+Gw94Fxu5ICCGEgUmAEsIEmTlZYtPenbSIeArS9Ds+2cHVjXb9n+HIH+u5EWu8KXMte3jjXseBsJXRZGeY7hkjAJfXp2Hdti3xEyeRe+WKsdsps3a1qvPHK/5MDanP2gNXCZoVyeZT1/+1XW9Y42GMbz6eBccXsOrPVUbq1oSZaeHJr6DTFAidDlvfAiNdCSCEEMLwJEAJYaLsunqBWiE1TP8/oD/W5ymqe3gRtnQ+hUa6VFWlUgga6kdeToHJjzZXzMzwmDMbs2rViBs7joK0NGO3VGZaMxVjutQmbEpnmnjaM/a7owxZdYgrtzP+8bqXm73My01fZvaR2XwbbVoXCZsERYGg96DnF7B/EfwyDPJzjN2VEEIIA5AAJYSJUllpsOtWk4xDieQlZjz4DZWgNjMjeNR4Ei9d4Pi2zXqtdT+2jhYEPFefi0ducHZfotH6KAu1vT2eixeRf/MmCa++SlGBcYJnRXlWs2LZS4+x/KXHuHgjneA5UXwZfoGc/P//PsY1H8fQxkP5z6H/sO7sOiN2a8LajoKB38DZzfBtf8hKNnZHQggh9EwClBAmzKadG2aOFiRv1v9wBfd6DWkW3JPdP3xD2u1beq9XmrqPudCgvStR686TfMN0R5sDmPv64jFnNhl79nLji5nGbqdCgvxcCJvSmeGdfJm/4wI95+5iz8Xif/+KojC55WReaPgCHx/4mN8u/Gbkbk2U3xPw0u+QeApW9YQU/Z5dFEIIYVwSoIQwYYqZCvuevuScv0v2ef0PV+j07GC0FhbsWPWV3mvdj/+geljbaQlbcdqkR5sD2HTsiMsbb3Bn9WqSf/nF2O1UiJXWjNd7NGDLRH+cbM15fvkBXvn+GDfSslEUhWmtpzGo/iDe2/seGy9tNHa7psm7ffFdUdmpsELuihJCiIeZBCghTJxFo+pofeyKL9ct0O+5IAtrGwKHvMzFQ/u5cGifXmvdz1+jzW/FpXNwo2mPNgeo9sLzOAwcyPX3PyDzsPHu1Kqsui62rBvVjpkDmrH74i26zYrkm32xFBbBW23fol+dfry95222xW4zdqumybkBjAgDCwdY2QOuVo0pjUIIIcpHApQQJk5Rii/XzU/KJOOw/s8F1WvXkVotW7Nj5VfkZBpvC52Ljx1tnvDl6LYrJJwz7dHmiqLg+vZ0rJo3J/6VieTGV90tXIqi8HQrT3a8GsDjTd149/fTPLloD6cT0niv/Xv08u3FG1FvsOPqDmO3aprs3GHoZnBpBN/0LT4bJYQQ4qEiAUqIKkDraYtVC2dSw65QWMLdPbqkKArdho0hOyOdPevW6LXWg7QIKR5tHr7a9EebK1otHvO+RGVlRfzYsRRm6Hfwh745WGn59Kmm/DKmPbn5hfRduJuPNp3ltVbv0rVmV16NfJVd8buM3aZpsnSAF36FusGw7nk48rWxOxJCCKFDEqCEqCLsuvtQmF1AWkS8/mvVcKbjwBc4tm0TiRfP671eaf4+2jziu7MmPdocwKxaNbwWLyIvPp6Eaa9T9BDcDdTK25FNEzrxZs+G/Hg4jh5z9tC52kT8PfyZtHMS+6/LNrUSaSxgwNfQaihsfAUivwAT//srhBCibCRACVFFmDmYY+vvQdquBPKT9X/fTMueT+DsU4vQZQsoNOKIbltHC7o834BLR29yZu91o/VRVuZ16+I+aybpO3Zw88t5xm5HJ8zUKkZ2rkX4lABa1HRg4venuBM7iCbVWzFh+wQOJ1bdc196pVJD71kQ+Dbs/Bg2TwUj3bMmhBBCdyRACVGF2HbxRGWhJnVbrN5rqdRqQkZN4NaVWI5s/l3v9e6nTitnGnZwY9ePF0hOMu3R5gC2gYE4vzqF20uWkLJxk7Hb0Rl3B0uWvFh8d1TMjRz27Xuc6mb1GLd9HCdunjB2e6ZJUSDgNegzDw6vhJ+GQF62sbsSQghRCRKghKhCVOZm2AV7k3nsBrnxaXqv51KrDi16PM7en74j5UaS3uvdT6eBdbG21xK28jQF+aa/Nc5x+HDs+z7B9enTyTp50tjt6NRfd0cN7VCPi6cGkJflxshtLxN9O9rYrZmuVoNh0HdwIRTWDigedy6EEKJKkgAlRBVj/ZgrZi5WxWPNDXCmouOgF7CwsWX7ikVGPYOktTAjeFjVGW2uKAquH36IRcOGxI8bT16ScQOorllpzXijZwP+mNAN77wJpKc78sKm4RxKOG3s1kxXg17FwyWunYCvH4f0m8buSAghRAVIgBKiilHUCg69fMmNSSU7+rbe62ktreg2bAwxx49wfv9uvde7n3ujzUOvEG/io80BVObmeC6YD2o18ePGU5iVZeyWdK6+qy2/vNyVac1mkpdjz7BtI1i4ew+FhTIwoUQ+HWHoH5CWCCu7w90rxu5ICCFEOUmAEqIKsqjviHldB1K2xFJkgO1sdR5rS53W7dm5einZGel6r3c/LUK88ajrQPgq0x9tDmBWowZeixaSc+kS16dPN/lJghWhUikMae/H+v5fY2PmwKKz03hy2QbOJ+l/m2mV5NoEhm2DokJYEQJJsvVRCCGqEglQQlRRDr1rkX87i/T9hplM13XYy+TlZLNr7WqD1CvNX6PN83MLiPjW9EebA1j4+eH+6aekbt7C7SVLjN2O3tSu7sLGAWtws7MnVjOL3gs38PnWs2TlyuS5f3H0LQ5RNjVgVQ+4KuPghRCiqpAAJUQVpXG1xrq1K2k7rlKYqf8nMbaOTnR65iVOhm8l4axxf2NuU82CwBcacOlY1RhtDmDXoztO48dzc+6XpIaFGbsdvXGydOK73qtws7fGud5qlu87Tve5UUSel/M+/2LrAkP+AJcm8E0/OL/N2B0JIYQoAwlQQlRhdsHeFOUXkbojziD1moX0wrVOPcKWLaAg37jb52q3dKZhRzd2rTtfJUabAziNHYNt9+5ce/0Nss+dM3Y7euNi7cLK7iuwsoBaTdbgUi2PwSsPMuH7Y9xIkxHe/2BhDy/8AnW6wQ/PwcmfjN2REEKIB5AAJUQVprbVYtvFk/R918i/rf8BBSqVmuCR47lzLZ7DG3/Te70H6TSgLtYO5oSuqBqjzRWVCvdPZ6D18SZ+zFjyb+t/CIixuNu4syJkBbmFWRQ4f8Un/Wux5+Itus2K5Nv9V2TIxN9pLGDA19B0EPw6Eg4uM3ZHQggh7kMClBBVnE0nD9Q2GlK2GGa0t7NPLVr17se+X77nbuI1g9QsjdbCjJDhjbgdn87BjZeN2ktZqays8Fq4kMLcXOJfmUhRbq6xW9KbmnY1WR6ynNvZt9mQ9D4bXmlJ7yZuvL3+T57+ai9nE+UupHvUZvDEAmg3BjZPhcgvoAqc7xNCiEeRBCghqjiVVo1ddx+y/rxNTmyKQWp2ePo5rB2qEb5sodGHODh729G2by2Ohl6tEqPNATRubnjOn0f2yZNc/+ADo/8Z6lMth1osDV5KXFocb+6ZxLtP1OHHl9uTlp3P4/N289kWGTJxj0oF3WdA4Nuw82PYNh0KTf/JqhBCPGokQAnxELBq7ozGw4bkP2IoMsDWKI2FBUHDx3L1zxOc2bVT7/UepEVwTTzq/Xe0ebrpjzYHsGrRAtePPiTll1+5+803xm5Hr+o71mdp8FIuJF9gwo4JNPWy4o9X/JkUVJeVe2IImRtJxLkbxm7TNCgKBLwGvWbC/oWwYTwU5Bu7KyGEEH8jAUqIh4CiUnDo7UteXBpZJw0z7cy3xWPUb+9PxDfLyUoz7lYsRaUQNOS/o82/qxqjzQEc+vXDcfgwkv7zOem7jHtJsb41dmrMom6LOHXrFJMiJoGSz/iudQmd1JmajlYMWXVIhkz8XZuR8NQyOPED/DQY8uTPRQghTIUEKCEeEua1HLDwq07K1liK8gyzJSpwyCgKCwqI+m6VQerdT1UcbQ7gPGUKNv7+JEyZQs5lw5xjM5aWLi2Z13Ueh64f4rXI18grzMPHyZpvh7dl9sBm7Ll4i6BZkaw9cFWGTAA0HQjPrIWL4bB2IOQY9xJrIYQQxSRACfEQse/lS0FqLml7DDPcwdqhGv7PDeHPnWHERZ8ySM37qYqjzRW1GvdZMzFzdiZ+7FgKUgxzjs1Y2rm1Y07gHKISopi+azoFhQUoisJTLT3ZPiWA7o1ceeu3Uwxcso8LSWnGbtf46vcoHnOecBTWPAlZycbuSAghHnkSoIR4iGicLLFp50bazjgK0g0z3a1pt+6412tI2LKF5OcZ//xRVRttDqC2scFr0ULy794lYfIUivIf7jMvnT0780XnLwi9EsoH+z6gsKj431M1ay1fDGjG9yPbcScjl17zdjE79BzZBnqiarJ8OsHg3+HWefj6cUiXS4mFEMKYJEAJ8ZCx7VYTFIXU8KsGqaeoVASPHEdK0nUOrjf+JaBVcbQ5gNbbG88v55Jx4ABJn39u7Hb0Lsg7iI86fsT6i+v57OBn/zi31r52dTZP9GdMQG0WR16i15e72Hfp4b0zq0w8WsHQzZCWBKt7QUqCsTsSQohHlgQoIR4yamsNdt28yDh4nbwbhtnG5lTTh9ZP9Ofg+h+5nRBnkJr3UxVHmwNYt2uHy1tvcvebNST//LOx29G7PrX78E77d/j+7PfMPTr3HyHKQqNmSkh9Nr/ij6O1lmeX7WfazydIznx47816IJdGMGwr5GXBqh5wp+r8gkAIIR4mEqCEeAjZtHdH7WBBymbDDSVo+9QgbKvXIHy58e+Ggv8ZbZ5h/K2FZVXtuedwGDSI6x98SOaRI8ZuR+8G1BvAtNbTWPnnSpacXPKvr9d1seXHl9vzyZON2fJnIkGzI/n9eIJJ/B0ziuq1YegWUGlgZU+4ccbYHQkhxCNHApQQDyHFTIV9Tx+yz94h+4JhnsBotOYEjRhHfPSfnI4IN0jN+/nHaPNvq85oc0VRcH17OlbNmxM/4RXyEh7+rVov+r3IhBYTWHh8IV+f/vpfX1epFJ5v6832KQG08XVk4g/HGbr6EPF3q8agEJ1z8Cp+EmVVHVb1gmvHjN2REEI8UiRACfGQsmzshNbbjhQDXa4L4N20OQ39A4n8diWZqcafJldVR5srGg0e875EZWVF3NhxFGZkGLslvRvVdBQjmoxg5uGZ/HjuxxJf42xnwaLnW7Hspcc4l5hGyJwoVuyOoeBRHHlu4wxDNoGjL3zdF+IOGrsjIYR4ZEiAEuIhpSgK9r19yUvMIPNIksHqdnlxOACR3yw3WM37qYqjzQHMqlXDc9FC8uLiuPbGGxQVVo2JgpXxSotXeL7h83y8/2M2XtpY6uuC/VwIndyZAa08+fiPaJ5ctIfoa8a9zNkorBzhxfXg4lc84jz24b6MWQghTIUEKCEeYuY17bBsVoOU0CsU5hhmFLSVvQOdXxhK9K6dXDl13CA1H+Sv0eZhK6vOaHMAi3r1cJ/5BWnh27m1YKGx29E7RVGY1noaT9Z9krf3vE3YlbBSX2troeGDvo35ZUwHcvIK6bNgN59tOfvojTy3sCu+J8qjFXz7NFzcbuyOhBDioScBSoiHnH13Hwqz8kiLijdYzcZdgvH0a0z48oXk5eYYrG5ptBZmBA9rxK24dA5uNNxgDV2w7dqVGhMncmvRIlK3bjV2O3qnUlS82+5dunt3Z1rUNHbF77rv61vWrMbGCZ2YHFSXlXti6DE3ir2XbhmoWxOhtYbn1oGvP3z/DJx7+P+eCCGEMUmAEuIhZ+ZogU1HD9Kj4ilINUyYURSFoBHjSLt1k4O/lXyexdBcfOxo84QvR0OvkFCFRpsDVH95FHa9enHtjTfJjo42djt6p1ap+cT/Ezq5d2JyxGQOJR667+u1ZirGd63Llon+ONtZ8NyyA7z+80lSMqvO9MVK01jCoO+gbgisex5Orzd2R0II8dCSACXEI8Au0AtFqyJl2xWD1azu4UWbfgM4+Psv3I43zKW+D9IixBv3Og6Er65ao80VRcHtk48xr12buHHjyb/18D9h0ag0zOwyk+bOzRm/fTwnb5584Htq17Dhh5HtmPFkEzafuk632ZFsPnW9ykxgrDQzLQxYDX594eehcNI0fnkhhBAPGwlQQjwCVBZm2AV5k3k0idxr6Qar26bvAOydXQhbtsAkhiCoVApBQ/3Iyykg4ruqM9ocQGVpiefCBRTl5xE/4RUKcx/+C2XN1ebMC5xHfcf6jA4fzbk75x74HpVK4bm2NQl/NYCWNR0Y+91RRq05QmJKtgE6NgFqDTy1DJo9C7+OgqNrjN2REEI8dCRACfGIsG7jhpmTJSmbYwwWHMy0WoJHjiPhbDSndoYapOaD2Dpa0OX5Blw6epOz+6rOaHMAjasrXvPnk336NIkffFClAmBFWWmsWNhtIZ42nowKG0VMStnOsLnYWbD0pcf46oWWHI9LJnh2JGsPXKXwURh5rlLDEwug1WDYMB6OrDZ2R0II8VCRACXEI0JRK9j38iXnYjLZBjwD5NWoKY0Cgoj6bhUZyaZx9qhOK2cadHAjat2FKjXaHMCyeXNcP/yAlF9+5e433xi7HYOw1dqyJHgJ1cyrMSJ0BAnpZb9cuEdjN8InB9C7qRtv/XaKZ5ftJ+bWw3+vFioV9J4DrUfAxolwaIWxOxJCiIeGBCghHiEWDRwxr21Pyh+XKSow3Ja6gBeHoVKpiTCRu6EA/AfWxcpOWzza3IB/Frrg0K8fjsOGkfSfz0nfvcfY7RhENYtqLAtZhrnanBHbRnAj80aZ32tvpeGz/k35bkRbrqdk02NuFF9FXiK/iv17LzeVCnrNhLaj4Y8pcHCZsTsSQoiHggQoIR4hxZfr1iL/VhYZBxMNVtfS1o6AF4dzdk8kscePGKzu/WgtzAgZ1oibcekc2lS1RpsDOL86BetOHUmYMoXc2Fhjt2MQNaxqsCxkGbmFuYwKHcXd7PI90exYx4mtk/x5sZ03n289S79Fezh9LUVP3ZoIRYEen0G7cbB5KuxfbOyOhBCiypMAJcQjRutug1VLF1LDr1CYnW+wun6du1KzcVPCVywiL8c0DvS7+NrR5nFfjmy9wrULprG9sKwUtRqPWbMwq16duLHjKEhLM3ZLBuFh48GykGXczbnL6PDRpOeWbyiKldaMtx/349exHcnLL+KJBXv4YttDfgGvokD3T6DDK7D1Ddi7wNgdCSFElSYBSohHkH2IN0W5haTtjDNYzb/uhkq/e4f9v/xgsLoP0rKHN2617QlbGU1OFbs3SG1ri+eiheTfukXC1KkUFTzEIeBvatnXYknwEuJS4xi/YzxZ+VnlXqO5lwMbJ3Tila51WRp1md7zdnHkStUK0eWiKBD8IXSaAqHTYfdcY3ckhBBVlgQoIR5BantzbPw9SNuTQP4dwz0NqubmQbsnB3F402/cvBprsLr3o1IpBA9rRG52ARFrz1W5yXbmvr54zJ5Nxq7d3Jwzx9jtGEwDxwYsClpE9O1oJkdMJq+g/OFXa6ZiYlBdNk3wx8ZCw9Nf7eXDjdFk5hruyaxBKQp0exc6T4Pw9yRECSFEBUmAEuIRZRvghcrSjJRtsQat27pvfxxc3QlbOt8k7oaCv0ab1+fi4RucO2C4s2G6YtOpIy6vT+P28hWkbNhg7HYMprlzc74M/JKD1w/y+q7XyS+sWPCp72rLr2M68FbPhnx34Ao95u5i76WH9LJiRYHAt/4/RO2ZZ+yOhBCiypEAJcQjSmWuxj7Yh6wTN8mNM9z5GbWZhuCR47h+4RwnwrcarO6D1H3MhfrtXIn6/jwpN6vWaHOAai+9hP1TT3H97XfIOnnS2O0YTHv39swMmMmOqzt4f+/7FBZVLJSrVQojO9di66TOuNpb8NyyA7z56ynSsqvWts4y+StE+U+FsHfkTJQQQpSTBCghHmFWj7mgcbUiedNlg25d82zYmCZdQ9i1djXpd+8YrO6DdB5UD0tbDWEro6vcaHNFUXB9/z0s/PyIHzeevKSyj/mu6rrW7MonnT5hw6UNfH7o80r9XfZ1suaHke34qF9jNhxPIGROFBHnHsI/S0WBrm///5mofYuM3ZEQQlQZEqCEeIQpKgX7XrXIvZJK1p+3DVrb//mhmGm17PzadO6m0VqaETysETeupHF4c6yx2yk3lVaL5/x5oFYTP348hdmmMe3QEHrX6s3b7d7muzPfsfhE5UZ1q1QKL7bzZtvkztRxtmHIqkNM/ekEKVVsyMgD/XUmquMk2PYm7P/K2B0JIUSVIAFKiEecRb1qmNerRsqWGIryDffUxdLGli4vjeD8vl1cPnbIYHUfxLWWPa17+3BkcyzXLiYbu51yM6tRA88FC8g5f57r775b5YZiVMbA+gOZ1HISi08s5pvT31R6Pc9qVnwzrA3/6d+EbX8mEjwnkvDoJB10akIUBYLe/++I89fhwFJjdySEECZPApQQAofevhTczSZ933WD1m3QMQDvpi3YvmIxeSb0tKRVD29ca9kTvjKanKyqN5HNsnEj3GZ8QuqGjdxZucrY7RjU8CbDGd54OF8c/oJfL/xa6fUURWFQ65qETumMn7sdI745zKQfjnE3I1cH3ZqIv0actx8PW16Dg6bzVFgIIUyRBCghBBoXa6xbu5K64yqFBtympCgKQcPHkpmczN6f1xqs7oOo1CqChvqRk5lH1PfnjN1Ohdj37k31UaO4MXMm6VFRxm7HoCa2nMjAegP5YN8HbIvdppM13ewtWTWkNTMHNGPH2RsEz4li2+mqN7GxVIoCIR9Du3GweSoc+drYHQkhhMmSACWEAMAu2BsKikjdftWgdR1c3WjX/xmO/LGeG7GXDVr7fuycLOn8bH3OH0yqkqPNAWpMmohNly4kTHmVnMum82erb4qiML3ddHr49OCNXW+wO2G3ztZ9upUnYVMCaO5lz8trjjDph2MkZz4kT6MUBbp/Aq1HwMaJcGKdsTsSQgiTJAFKCAGA2laLbRdP0vdfJ/9WlkFrP9bnSRzdPQlbtoDCwgKD1r6f+m1dqdfGhajvz5Fq4D8TXVBUKty/+BwzVxfix46jIDXV2C0ZjEpR8XGnj+no3pHJOydzNOmoztZ2sbNg2UuPMetvT6PCHpazUYoCPb+AFs/D+tFw+jdjdySEECZHApQQ4h6bTh6obTSkbIkxaF21mYbgURNIvHieE6GbDVr7QTo/Wx9zKw3hq6IprGKjzQHUNjZ4LVxI/t27JEx5laIC0wmo+qZRaZgZMJMmNZowbvs4ztw+o7O1FUWh/3+fRjXxsGfkN4eZsu74wzGpT6WCPvOgcX/4ZQSc/cPYHQkhhEmRACWEuEelVWPX3Yes07fJiUkxaG2P+g1pGtSD3T98Q9qdWwatfT/mlmYED/Mj8XIKR7ddMXY7FaL19sZzzmwy9u3jxsxZxm7HoCzMLJjfdT7edt6MDh9NbEqsTtd3sbNgxeDH+OLppoSdSSJ4TiTbzzwET6NUauj3FdTvBT8NgQvhxu5ICCFMhgQoIcQ/WDV3RuNhQ/IflykqNOwIbP9nh2CmNWfnKtMapexWx4FWvXw4uCmWxMuGDZa6Yt2hAy6vv86dVatI/m29sdsxKGuNNYuDFmNvbs+osFEkZuj2TJuiKAx4zIuwyQH4udsx/OvDvPbTCVKzq/jTKLUZ9F8BtbvBuufhcqSxOxJCCJMgAUoI8Q+KSsGhty958elknbxp0NoWNjYEDhnFhYN7uXj4gEFrP0jrXj44e9sStvI0udlVb7Q5QLUXX8C+/1MkvvceWSdOGLsdg6pmUY2lwUtRUBgVNoo72Xd0XsPV3oJVQ1rzn/5N2PJnIj3mRLH7guk8Ta0QMy0MWA3eHeD7Z+DqfmN3JIQQRicBSgjxL+a1HLDwq07K1liK8gx77qd+e398mrdix8qvyM02ncENKrWK4GF+ZKXlseuH88Zup0IURcH1vfewaNSI+PETyEu6YeyWDMrV2pWlIUtJyUlhTPgY0nPTdV7jr3ujtk7yx8fJmhdWHOCd9X+SmVs1QzcAGgsY9B24t4TvBsC148buSAghjEoClBCiRPY9fShIzSVtT4JB6xbfDTWGrLRU9v74rUFrP4h9DSs6P1OPs/sTuXC4ap5zUWm1eM77EtRq4idMoDAnx9gtGZS3nTdLgpcQlxrHhB0TyM7XzwXOntWs+HZ4Wz7s24ifj8TT88tdHIrV/VMvg9FawXM/QPU68O1TcLNq/hJBCCF0weABKi4uji5duuDn50fTpk356aef7vt5IYRxaGpYYdPOjbSdcRSkG/aeG3tnV9o//SxHN28k6fJFg9Z+kPrtXKnTypnItedIu6OfH771zaxGDTznzyfn3DkS332PoiLDnnUztgaODVjQbQF/3vqT1yJfI69QP2eVVCqFl9r7sHmiP0425gxcso9P/ogmO6+KTkI0t4UXfgEbF/imL9ytmkNVhBCispQiA/+X8/r16yQlJdG8eXNu3LhBy5YtOXfuHKmpqSV+3traukzrpqamYm9vT0pKCnZ2dnr+LoR4NBRk5JH4xSGsmjtTrV8dw9bOz+fbNyehNjPjuU9moVKpDVr/frIz8lj38UHsnCzpO7kFKpVi7JYqJGXjJq699hrOr79O9aFDjN2Owe2K38UrO16hh28PPun0CSpFf79TLCgsYvmuy8wKPY+PkxWzBzansYe93urpVVoirOxR/L+HbQVbV+P2I4QQJdBnNjD4Eyg3NzeaN28OgLOzM46Ojty5c6fUzwshjEdtrcGua00yDl4n70amYWubmRE8chxJMZc4vnWTQWs/iIW1hqAhfly7mMzxsKvGbqfC7Ps8TvURw7nxxRek79pt7HYMzt/Tnxn+M/jj8h98cegLvT6JU6sUXg6ozcYJnVCrVDy5aA8Ld14kvwreLYatK7z0O+TnwJonIVP+Wy2EeLSUO0BFRUXRp08f3N3dURSF9evX/+s1ixYtwtfXFwsLC1q1asWuXbtKXOvw4cMUFhbi5eVVps8LIQzPpoM7agcLUjYb9nJdAPd6DWkW1JPd674l9ZZhJwI+iEf9arQM8ebA75e5cSXV2O1UWI3Jk7H270TCq6+SGxtr7HYMrqdvT6a3nc63Z75l6Un9j8+v72rL7+M6MtK/FrNCzzFwyT5i/6+9+4xvsmz7OP67knTvvSe7rJayl5Q9FEVRVASRoYiKiDi4cSKIWxzgQkCc4AAVEWWDbMres5RCS1uge7d5XqA8N7eMlqY5k/T4fj590Stp8m+vFnLkOs/jyMyv8ec1Oa8IGLoI8s7C1wOhOFd1IiGEMJsqF1D5+fk0b96cDz/88Iq3z58/n3HjxjFp0iR27NhBp06d6NOnD8nJl79Le+7cOYYOHcqnn35aqeNCCDU0gw6P3pEUHTxP0dEssz9/p3vvx97RkVVzPzH7c19P61ui8Al1Zdns/ZQWW+e+Fk2vJ+SttzD4+HBqzCOU59a+F8KDGg7i0dhH8RlkqQAAfQNJREFU+XDnh8w/OL/Gn8/eoOPp3g35fnQ7zuWX0Oe9dXy16aT17UXzawD3/QSZR+Dbe6DUOvcECiFEVVW5gOrTpw9Tpkzh9ttvv+Lt77zzDiNGjGDkyJE0atSI6dOnExYWxkcffXTpPsXFxQwYMICJEyfSvn376x6/kuLiYnJyci77EELUDKemvtiHu5G9xPzDdR2cXUgY9hBHt27iyNaNZn3u69EbLrY2z7tQxF8/HFEd54bp3dwInTmDsowMzjz1NMZy6ywGq+PBZg9yX6P7mLp5KktPLDXLc8ZHeLNkbCdubxHCc4v2MmzOVtJzrKwICY6FexdAyjb4YTiUW3G7diGEqCST7oEqKSkhMTGRnj17Xna8Z8+ebNiwAQCj0ciwYcPo2rUrQ4YMuXSfqx2/mmnTpuHh4XHpQ5b7CVFzNE3Do180pWfyKdhh/tlB9dt2ICqu5cXZUIXm3Yt1PV6BLnS8sx77153h+E7LWmZYFQ5RUYS8/RZ5a9aQ8f4HquOYnaZpPNXqKfpF92PiXxNZf3q9WZ7XxcHA1AFNmfNAK/an5tBr+lqW7k0zy3ObTEQ7uGseHF4Kix8Ha7uSJoQQVWTSAiozM5Py8nICAgIuOx4QEEBa2sX/ENavX8/8+fNZtGgRsbGxxMbGsmfPnqsev5qJEyeSnZ196ePUqVOm/FaEEP/DIcIdp2a+5PyRREWJea9QaJpGt+EPU5Sfx/r5ljUbCiCmYzBRzX1Z9eVB8rOsd66Sa+fO+E94knOffELOkiWq45idTtMxucNk2ge354nVT7ArY5fZnjuhgT9LH+9Eq0hvRn+VyNM/7CKv2Iqu5tTvCbfNhB1fwYrJqtMIIUSNMtTEg2ra5S19jUbjpWMdO3akouLKXYeudvxKHBwccHBwuPGQQogq8+gdRdrb28hbdxr3buHmfW7/ANrfOZh1X8+lUacEAuvUM+vzX4umaSQMach3r2xhxRf7ueWxWDQrbW3uPXw4RQcOcuY/k7CPisKxUSPVkczKTmfHWze9xehloxmzfAxf9P6Cul7maeHv4+rAJ0PiWbDtFC//up9Nx8/z7qBY4iO8zPL81db8bsjPhD8ngYsftBujOpEQQtQIk16B8vX1Ra/XX7ra9I/09PR/XZUSQlgfg7cjrh2CyV1zivIc8w7XBWjRpz++4REs++xDKixsn46Tqz3d7m/EqQMX2L0qRXWcG6ZpGkFTXsEhOppTjzxC2blzqiOZnZPBiQ+6fUCQSxAPLX+IM3lnzPbcmqYxqFU4vz/eCR9Xe+78eAPvLDtMqbW0O2//KHR4HP6YCLsXqE4jhBA1wqQFlL29PfHx8Sxbtuyy48uWLbtuUwghhHVw7xKGZtCRs+yk2Z/74myoR0lPOs4OC5sNBRAe40PzrmFsWHiUzJQ81XFumM7RkdAZH2IsLiHl8ccxlpi/WFbN3d6dj3t8jL3OnoeWPcT5IvPOOorwceH7h9rxeLf6zFh1lIEfb+TkOStpd979ZYi9DxY9DEeWq04jhBAmV+UCKi8vj507d7Jz504ATpw4wc6dOy+1KR8/fjyzZs1i9uzZHDhwgCeeeILk5GRGjx5t0uBCCDV0zna4dQsnf1sapWnmf0EXVK8BsT37sn7+lxY3Gwqg7YBovAKcWTZ7H2Vm3itmSnZBQYS+/x6Fu3aTNm2a6jhK+Dr58mmPT8ktyWXM8jHkl5r3992g1/F493r8MLodF/JL6PveOn5ITLH8dueaBre8B3V7wIIhFzv0CSGEDalyAbVt2zbi4uKIi4sDLhZMcXFxvPDCCwAMGjSI6dOnM3nyZGJjY1m7di1LliwhIiLCtMmFEMq4tgnC4ONE1m/HlTx/x7uHYu/szMo5ljcbymCnp8fwxmSnF7Jx4THVcarFOT6ewOefI+vb77jwXc3PR7JEYe5hfNT9I07mnOTxVY9TUm7+q3Fx4V4sebwTvZsEMeH7XYz9bifZhaVmz1ElegMMnA2BzS4O2s04rDqREEKYjGa0+LeyKicnJwcPDw+ys7Nxd3dXHUcIm1e4L5NzXx7A94HGODbwNvvzH968nl/fmUb/CZOo16qd2Z//enatPMVfC45w86PNiWjiozpOtaRNfoULCxYQMXcOzi1bqo6jxNa0rYxeNpouYV14o/Mb6HV6JTl+2XWGSQv34O5ox/S7Y2kVaf6/vSopvACz+0BJPoxcDm6yH1oIYR41WRuYdA+UEKL2cIzxwT7KnawlJzCWm/99mHqt2xPdopVFzoYCaJYQSnhjb1bMO0CBgoYbphQw8Vmc4+JIeXwcpampquMo0SqwFW90foPlycuZtmWasmV0/ZsH8/vjnQj2dGTQJxt5589DlFlygwknLxj8PVSUwjd3QrH17g0UQoh/SAElhLghmqbh2S+asrMF5Ceaf/Cnpc+G0jSNrkMbYawwsuqrg5a/b+UaNDs7Qt6bjuZgT8ojj1JRWKg6khLdIrrxQtsXmH9oPh/v+lhZjlAvZ74d1ZZx3eszY/UxBn26iZQLlvcmwiWeYReLqHPH4fthUG5F862EEOIKpIASQtww+1A3nOP8yfnzJBUKhn66+/nT4c7B7Fi6mLRjR8z+/Nfj4uFA16GNSNqdyb515muFXRMM3t6EzZhB8fHjpD7/glUXhNVxR/07eLzF48zcNZP5B9XtCzPodYztVo8FD7UlLbuIvu+tY+leC746GNgUBs2D46vgtyeglv7+CCFsgxRQQohqce8VQUVROblr1Mw+atH3VnwjIln2qeXNhgKIauZL484hrP/+COdTraQN9VU4NmpE8KtTyVm8mPOz56iOo8yIJiO4r9F9TN08lWUnl13/C2pQfIQ3S8Z2okNdX0Z/tZ1JC/dQVGp5fwcA1OkK/T+A7fNg7Zuq0wghxA2TAkoIUS0GT0fcOoaQt+40ZdnFZn9+nV5Pj1GPkH7yODuW/mr256+MDgPr4ubjyLLZ+ygvs+D9KpXg3rcvPqNGkf722+St+0t1HCU0TeOpVk/RO7I3z6x9hq1pW5Xm8XC2Y+bgFkwd0IQfElO49cP1HD6bqzTTVcXeCwnPwaqpsONr1WmEEOKGSAElhKg2ty6haPZ6cv5IUvL8QXUbENuzH+vnf0VOZrqSDNdiZ3+xtfn5M/ls/kVN63dT8hv3OC4dO3D6yScpOWn+gcqWQKfpmNJxCvEB8YxdOZZD5w8pzaNpGoPbRPDLox2pMBrp/+FffLsl2TKXWnaeAC2Gwq9j4egK1WmEEKLKpIASQlSbztGAe49wCnakU3JaTZetjncPxcHZmRWzP7bIF41+4W606R/NjmXJnD50QXWcatH0ekLeeguDtzenxjxCeV7t7Kxmr7dnesJ0wtzCeHj5w5zOO606Eg0C3fjl0Y4MiAtl4k97GPvdTnKLLGxmlKZBv3cvLulbcD+k7VWdSAghqkQKKCGESbi0CsLg50T2b8eVFDAOzs50fWA0xxO3cHTrRrM/f2XE9ggnpJ4ny+fupyjfwl7UVpHe3Z3QmTMoO3uWM08/g7HCupcm3igXOxdmdp+Jo8GR0ctGc77ovOpIONnrmXZ7Uz68N45VB9Pp/+F69p3JVh3rcnoDDJwD3pHwzSDIPas6kRBCVJoUUEIIk9D0Gh59oyk+nk3RATUvIuu2bkd0fGtWzvmE4gLLa+us02l0GxZDaXE5a745ZJFXyqrCITqa4DffIG/VKjJnzFQdRxlfJ18+6f4JOSU5PLriUQpKLeN37+ZmwSx+rCNOdnoGzNzA15tPWtbvnIMr3DMfKsrgu3ugtHa2xxdCWB8poIQQJuPYwAuHup5k/34Co4LhnhdnQ42mOD+f9Qu+NPvzV4abtyM33duAo4npHNps/vlZpuaWkIDf42PJnDGDnGVqO9KpFOYexsfdP+Z49nHGrxlPaYVlXGGM9HXhpzHtGdQyjEkL9/LYtzssa0mfRwjc+x2kH4CFo6GWXskUQlgXKaCEECajaRoefaMoyywkf4ua4sDd15/2d/09G+roYSUZrqdeywAatA1k7XeHyc6w/nfdfR56CLeePUl95lmKj1jePC5zaeTTiOkJ09mcupmXNrxkMVd7HO30vHJbEz68N47VhzK45YO/LGtJX3Ac3P4Z7P8ZVk1RnUYIIa5LCighhEnZB7vi3CKAnOUnqSgy/3BdgBZ9+uMXEcWyz2ZY5GwogM6D6uPkasfyOfuoUHC1zpQ0TSN42qvYhYZy6tFHKc+2oBfnZtY2qC2vdnyVX479wvs73lcd5zL/LOlzcTAwYOYGvrOkLn2NboYeL8O6t2HnN6rTCCHENUkBJYQwOY+eERhLKshddUrJ8+v0enqOetSiZ0PZOxno/kBjzp7IIXGp9bcC17m4EDrjQ8qzsjk9/kmMFlq4mkOfqD5MaDmBWXtm8c0ByyoGIn1d+PHh9gyMD+XZn/bw1A+7KSyxkHPVfuzF9ua/jIWk9arTCCHEVUkBJYQwOb2HA66dQ8ldf5qy80VKMgTWrU9cr5stdjYUQFAdD1r2jWTrb0mkHbf+qzb2YWGEvvsO+Rs3kvHuu6rjKHV/4/sZGjOU17a8xrKTlrU3zNFOz6sDmvLOXc1ZvPsMA2auJykzX3Wsv9ubvwMR7WD+YDh3THUiIYS4IimghBA1wq1zKDonA9l/JinL0GHQEBycnVk551NlGa6nZd9I/CPcWDZ7HyWKljyakkv79vg/9RTnZn1O9uLfVMdR6smWT9I7sjfPrn2WxLOJquP8y+0tQln0SAeKyyq45YO/+GOfBTQ10dvBXfPA2Re+uQsKs1QnEkKIf5ECSghRI3QOejx6RFK4M4OSU7lKMvwzG+rYtk0csdDZUDq9jh7DYyjMLWXdAttowOA97H7c+99C6nPPUbR/v+o4yug0HVM6TiHWP5bHVj7G0QtHVUf6l4aB7vzyaAc61vPloS8TmbbkAGWq9+Q5ecG98yE/E34cARUWssRQCCH+JgWUEKLGOLcMwBDgTJai4brw92yoFq1YOftjSgotYz7P//Lwc6bToHoc3JDKse2WudywKjRNI2jyZBzq1OHUo49Sdl79cFlV7PX2TE+YTpBLEKOXjyYt3wKu8vwPN0c7Zg5uwXP9GjHrrxPcO2szGbnFakP51IE758CxlbD8JbVZhBDif0gBJYSoMZpOw7NfNCVJORTtO6cmg6bRbfjDFOXnsX7+V0oyVEbDdkHUifNj1VcHybug+MWrCegcHQn98AOMRcWcfmI8xlILmj1kZm72bnzU/SN0mo6Hlz9MTkmO6kj/omkaIztF892DbTmRmc8tH/zFzlNZakPV6Qo9p8CG92H3ArVZhBDiv0gBJYSoUY71vXCo73VxuG6ZmqVB7n7+dLjz79lQxyxzmZymaXQZ3BCDnY4VX+zHWGEh7aWrwS4oiND3plOQmMjZN99UHUcpf2d/Pu7+MekF6YxbNY6S8hLVka6oVaQ3ix/rSLCnI3d9vJHvtiSrDdR2DDS/F355DE5vV5tFCCH+JgWUEKLGefaNoux8EXmbUpVlaNH3VnzDI1j22YcWOxvK0dWObsNiSDl4gV0r1bSANzXnVq0ImPgsF+Z9SdaiRarjKBXtGc0HXT9gV/ounlv/HBVGy5z/FeDuyHcPtuPOlhdbnU/8aQ/FZYr+ZjQNbn4XAprAd4Mh1/KWQAohah8poIQQNc4u0AWXVoHkrkymokDNUi6dXk+PBx8lPek4O5YuVpKhMsIaedO8exgbFx0jM0VN8w1T87r3Xjxuv520F16kcM9e1XGUahHQglc7vcrSE0t5b/t7quNclb1Bx9QBTXnjjmb8mJjC3Z9uIi1bzUgC7Bxh0FdgrID5Q6DM+pe4CiGsmxRQQgizcO8RgbGsghyFV1aC6jYgtmdf1s//kpzMDGU5rqfdrXXwCnBh2ez9lFnKkNNq0DSNwBdfwKFhQ1Iee4yyzEzVkZTqFdmLCS0nMHvvbL49+K3qONd0V6swFoxuR1p2ETd/8BdbkxQ1BHEPgru/gdRd8Nt4UNSURgghQAooIYSZ6N3scbspjLyNZyg7V6gsR8e7h2Lv7MzKOZ8oy3A9ejsdPUbEkJ1eyMaFtjFMVOfgQOgH72MsKyNl3Lha3VQCYGjjodzX6D5e2/IaK5NXqo5zTbFhnvz6WEfq+Llw72eb+FbVvqjQeLjlPdjxFWy23L9fIYTtkwJKCGE2rp1C0LvYkb00SVkGB2cXug570KJnQwH4BLvS7vY67F6VwklFHQxNzS4ggND336Nw127OTntNdRzlnmr1FN3Cu/HM2mfYlbFLdZxr8nV14KuRbRjUKoyJP+3hxZ/3UqpiXlTsPdD2EfhzEpy03L9fIYRtkwJKCGE2Ons97r0iKdyTSfFJda2c67XpcHE21JxPLHY2FECzLqGExXiz8osDFOZaZte2qnJu0YLASZO48M03ZP34o+o4Suk0HdM6TSPGJ4bHVjzGyZyTqiNdk51ex5TbmvLKbU34enMy98/ewoV8Bb+XPV6GsDbw/f3SVEIIoYQUUEIIs3KO88cuyIVshcN1NU2j6wOjKcrLZf2Cr5VkqAxNp9Ht/kZUlBtZ9dVBZT8vU/O6exCed95J2ksvU7h7t+o4SjnoHXi/6/t4Onry8PKHOV9k+UOHh7SN4MsRbTiQmsNtM9dz+KyZm53o7WDgHECD7x+A8tq9HFQIYX5SQAkhzErTaXj0i6YkOZfCPeqaCXj4B9B+4L3s+P1Xzh4/qizH9bh4OJAwpCEndmVyYL26NvCmFvD8czg2bkzKY2Mpy7Dchh7m4OHgwcxuM8kvzeexlY9RVKao210VtKvjwy+PdsTRoOf2mRtYvv+seQO4BcBdX0DKFlj2onmfWwhR60kBJYQwO8e6njg29CZ7aZKy4brw92yosPCLs6EqLLfbXXSsHzEdgli34DBZZy13yWFV6OztCXnvPYwV5aSMewJjiW0sUbxRoW6hzOg2g8PnD/Ofv/5jsTOi/luYtzM/jmlP+zo+jPpyGx+tPmbeq6ThbaHnVNg0A/b+ZL7nFULUelJACSGU8OgbRXlWEXkbzijLoDcY6D7qUc6eOMbOP35TlqMyOtxZDxcPB5bN2U+5is37NcAuwJ/Q996ncPduzr72uuo4yjXxbcLrnV9n+cnlvLPtHdVxKsXVwcDH98XzaEJdXl96kGd+3E2JOd8UafMQNBkIPz8K6QfN97xCiFpNCighhBJ2/s64tA4iZ+UpyvPV7WEIrt+Q5t378Nd3X5J7znLnE9k7Gug+PIaM5Fy2/ZakOo7JOLeI+6+mEnIVoWt4V55p/Qxf7P/C4mdE/UOn03iyZwPevrM5C3ec5v7ZW8g218BsTYP+74NnOMy/D4rUNacRQtQeUkAJIZRx7x4ORiO5KxXNlflbx3uGYu/oaNGzoQACozxo1S+SxN+TSD2WrTqOyfx/U4mXan1TCYDBjQYzJGYIr215jdWnVquOU2l3xIfy1Yg2HEjLYcDM9SRl5pvnie1dYNBXFzvy/fyIDNkVQtQ4KaCEEMroXe1x6xJG3sZUSjPVDdd1dHElYdiDHN26kaPbNivLURnxvSMIiPJg+Zx9lBSWqY5jMgHPP4djTMzFphKZlnsl0FwmtJxA17CuPL32afZl7lMdp9LaRPuwaEwHAG6buZ4tJ8zUVdC3Lgz4CA78Ahs/NM9zCiFqLSmghBBKuXUMRu9mT87vJ5TmqN+2I1Gx8ayc/TElReqKuevR6XV0fyCGwrxS1s0/rDqOyejs7Ql5//2/m0qMq/VNJXSajlc7vUo9z3o8suIRTuedVh2p0iJ9XfhpTHsaBbozeNYmftqeYp4nbnQLtH8Mlr8EKdvM85xCiFpJCighhFKanR733pEU7jtH8Ql1y9I0TaPbiIcpzM1hgwXPhgLw8HOi86D6HNyUxtHEdNVxTOZSU4ld0lQCwMngxPtd38fJ4MQjyx8hp8R69vd4OtvzxfDWDIgLYfyCXUxfftg8Hfq6vQjBcRfnQxVeqPnnE0LUSlJACSGUc27uh12oK1m/HcdYoW7/god/IO0G3sP2Jb9w9sQxZTkqo0HbQOq08GP11wfJu1CsOo7JXGwq8Z+LTSUWLlIdRzkfJx9mdJ9BemE6T65+ktIK6xkaa2/Q8fodzXiqVwOmLz/CxJ/2UFbTHST1dnDH51CcDb88JvuhhBA1QgooIYRymk7Ds28UpSl5FO5WO1Q1vt9t+ISGsdzCZ0NpmkaXextisNOx4ov9SgtPU/McNAiPgXeQ9uKLFO61nv0/NSXaI5r3Et5j29ltTN001byzlqpJ0zQeSajL23c254fEFEbN20Z+cQ3v3fOKgFtnwIFfYeusmn0uIUStJAWUEMIiOER74hjjc3G4bqm6OUf/zIZKO3aEXX8uUZajMhxd7eg2LIaUgxfYtfKU6jgmo2kagc8/j0ODBqQ89hhl583UiMCCtQpsxUvtXuLHIz8yd99c1XGq7I74UGYPa8WWE+e557NNZOTW8FXTRrdA64fgj/9A6q6afS4hRK0jBZQQwmJ49ImkPKeEvA1qN8yHNGhEs+69+eu7eeSdP6c0y/WENfKmebcwNi46xrnTearjmIzOwYHQ99/DWFLC6SfGYyyznY6DN+rWurcyquko3kl8h2Unl6mOU2Wd6/uxYHQ7UrOLuOOjDRzPqOHf156vgH8j+H4YFOfW7HMJIWoVKaCEEBbDzs8ZlzaByofrAnS6ZxgGewdWzf1UaY7KaHtbNJ7+ziybvY+yUstddlhVdkFBhLz7DgXbtpH+1tuq41iER+MepXdkbyaum8iejD2q41RZ42APFo5pj51e446PNrA9uQYbPRgcYOAcyMuAX8fJfighhMlIASWEsCju3SMAyFl+UmkOR1dXutw/isOb13N8+1alWa7HYKenx/DGXDhbwKafj6uOY1IurVsT8MwznJ87l+xfF6uOo5xO0zGl4xQaejfksZWPcSbvjOpIVRbq5cyPD7enrr8r9362iVUHa7CTpE8duGU67P0BdnxZc88jhKhVpIASQlgUvYsd7l3DyN+cRmlGgdIsDdt3JqJZHCtmf0RpUZHSLNfjG+pKu9vqsGv5KU4dsK09Q15D7sO9/y2kPv88RQcPqo6jnIPegfe7vo+jwZFHVjxCbon1LU/zdLbnyxFt6FTPj1HztvHzzhpcttt0ILS4H5Y8DekHau55hBC1hhRQQgiL49o+BL27Pdm/JynNoWka3UeMoSAri40/fqs0S2U07xpGaEMvVszdT5HiJZCmpGkaQS+/jH10FCmPPErZBZnv4+3ozcxuMzlbcJan1jxFWYX17RFztNPz0eAW3Bobwrj5O/lyY1LNPVmf18ErEn4cCWW20/ZfCKGGFFBCCIuj2enw6BNJ0f5zFB/PUprFMzCItnfczbbFC8k4eUJpluvRdBrd7m9EWWkFq78+aFXtrq9H5+RE6PsfUJGfz5mnnsZYbjt7vW5UtGc0b9/0NptSN/HG1jdUx7khBr2ONwc2Y3iHKJ7/eR/vrzhSM7+3dk5wx2eQeRhWvmL6xxdC1CpSQAkhLJJTMz/swtzI+u2E8hlHLW8ZgHdwKMs++xBjhboW65Xh6uVIl8ENObY9g0Ob01THMSn70BCC336L/A0byHj/A9VxLEK74Hb8p81/+Pbgt3x70PKvkl6JTqfxXL9GTOhZn3eWHWby4v1U1MTffGBT6Po8bPgQjq8x/eMLIWoNKaCEEBZJ0zQ8+0VRejqPwl1qh+vqDXZ0HzmG1COH2L1iqdIslVE33p8GbQNZ+91hcjILVccxKdcOHfB7YhznPvmEnGXW18q7JtzV4C7ua3Qfr295nQ2nN6iOc0M0TePRrvV45bYmzN2QxITvd1FaXgNvVrR7FCI7wqKHoVCWggohbowUUEIIi+UQ6YFT43+G66pdshXaqAlNEnqy7psvyM+y/BdenQbVx9HZjuVza+jdfIV8Ro7ErWdPUp+dSPFx2+o6eKMmtJxA++D2PLnmSY5lHVMd54YNaRvBe3fH8cuuMzz81XaKy0z8d6/TwYCPoTgPFo+X1uZCiBsiBZQQwqJ59ImiPLeE3L/Ut2vufN8D6AwGVn3xmeoo1+XgZKD7AzGkHstmx59qW8KbmqZpBL36KobAQFIefYzyPNsZIHyj9Do9b3R+g0CXQB5Z8Qjni6y3E2P/5sF8dn9L1h3JYNS8RIpM/eaJRyjc/A7s+wn2fG/axxZC1ApSQAkhLJrB1wnXdkHkrj5FeV6J0ixOrm50GTKCQxvWkrRru9IslRFcz5MWvSLY8ssJ0k/mqI5jUnpXF0I/+ICy9HRSJ060qYYZN8rV3pUPu31IYVkhT6x6gpJytX8v1ZHQwJ/Zw1qx9cR5HpizlYISE3cZbDoQmt4Fvz0JWcmmfWwhhM2TAkoIYfHcuoaDppGzXP0LnUadEghv0ozln8+ktMTy2yG3vjkKn1BXls3eT2mJbXWuc4iOIvj118hdtpxzn81SHccihLiG8F7Ce+zN3MvLG1+26sKyQ11fvhjemt0pWQybvZW8YhMXUf3eAkcPWDgaKmzrb0MIUbOkgBJCWLxLw3W3pFKarna4rqZpdBvxCHnnMtn80wKlWSpDb9DRY3gMeeeL2PjjUdVxTM6tWzd8Hh5NxvTp5P21XnUcixDrH8vkDpP55dgvzNk3R3Wcamkd5c28EW04kJrDkM83k11owvlmjh4w4BM4uQHWv2e6xxVC2DwpoIQQVsG1fTB6T0eyf1c/i8k7OITWt93F1l9+5FyK+qti1+MV6EL7O+qyZ81pkvZkqo5jcn6PPopLxw6cefJJSlJSVMexCP2i+zGq6SimJ05nzSnrbtkdH+HF16PacDwjn/tmbSarwIRLEyM7QMdxsGoqpO423eMKIWyaFFBCCKugGXR49I6k6MB5io5lqY5D69vuxMM/gGWfzbD42VAATW4KIbyxDyu/PEhhrvXujbkSTa8n5M030bm7kzJ2LBVFRaojWYRH4x4lISyBp9c+zZELR1THqZZmoZ58M6oNp7MKufvTTZzLM+Hy2S7/Ab+GsGgMlJvwCpcQwmZJASWEsBpOTX2xD3cj+7fjyofrGuzs6D7yEU4f3MfeNcuVZqkMTdPoOrQhxgojq746aNV7Y65E7+FB6PvvUXLsOGkvT7a57+9G6DQd0zpNI9QtlMdWPsaFIstvv38tjYM9+O7BtmTmlXDvZ5s5n2+iNwIM9nDrDEjfD+veMc1jCiFsmhRQQgiroWkaHv2iKT2TT8GOdNVxCG/SjJhOCaz9ag4FOdmq41yXi4cDCfc15MSuTA5sSFUdx+QcGzUiaPLLZC9cSNb8+arjWARnO2c+6PoBhWWFjF89nlIrv8JSP8CN7x5sw7n8YtMu5wuOhU7jYe0bkLbHNI8phLBZUkAJIayKQ4Q7Tk19yfkziQoL6Cp309CRAKz58nPFSSonOtaPRh2CWLfgCNkZahty1ASPW2/F6957SZv6KoU7d6qOYxGCXYN5t8u77MzYyatbXrX6q3N1/d34emRbUrMLGTp7CzlFJioKOz8FvvVlKZ8Q4rqkgBJCWB2P3pGU55WSt/606ig4u3vQefAD7F+7kuS91rEJveOd9XB2s2PZ7P1UlFv+/q2qCnj2GZyaNCHl8XGUZdpe04wb0SKgBc+3fZ4fDv/Atwe/VR2n2hoEuvHliDYkZeYzbPYW07Q4NzhcXMp3dh/8Nb36jyeEsFlSQAkhrI7BxwnXdsHkrkqh3AIaIjTp0p2QhjEsnzWDslLLf+fa3tFAj+GNSU/KIXHpSdVxTE6ztydk+nSM5eWcHv8kxjITzw+yUrfXu50hMUN4Y+sbbDyzUXWcamsS4sGXI9pw5Gwew+eaaNhuSIuLXfnWvH6xkBJCiCuQAkoIYZXcu4aBXiNnufoCQNPp6D7yEbLT09iy6HvVcSolMNqD+D6RbP0tibMnclTHMTm7AH9C332HgsRE0t+WxgD/GB8/nrbBbXlyzZMk51h+C/7raR7mydzhrdl3OpuRX2yjqNQEy3pvegZ86sCih2UpnxDiiqSAEkJYJZ2zHe5dw8nfkkbp2XzVcfANi6BV/zvYsmgB58+oX1pYGS37ReIX5sqyOfsoLVa/n8zUnFu1IuDppzg/Zw45v/+uOo5FMOgMvNH5DXwcfRi7ciz5per/dqorPsKL2cNasSM5i4e+TKS4rJq/ywYHuG3mxWYSMmBXCHEFUkAJIayWa7sg9F6OZP+epDoKAG1uH4Srjy8rPp9hFRv19XodPYY3Jj+rmPU/HlUdp0Z4DR2Ke79+nJn0HMVHbfN7rCp3e3fe6/oeZwvOMnHdRCqM1r8Prk20D5/f35JNx8/x2Dc7KKvu3r6QeOjwOKx+Dc7uN01IIYTNkAJKCGG1Lg3XPXieoqPqZ9zY2TvQffjDJO/dzYG/VquOUymeAc50GFiPfWtPk7TH9houaJpG0OSXsQ8JJuWxsZTn5amOZBGiPaJ5rdNrrD61mo93faw6jkm0r+vLR/e1YMXBdCYt3Fv9NzFueha8o+HnMVAu++iEEP9PCighhFX7/+G6J5QP1wWIjI2nQbtOrJ43i8K8XNVxKqVxp2Aimvqwct4BCnLUN+UwNZ2LCyHvv09Zejqp/5lkFVcHzeGmsJt4NO5RPtr1EctPWv4w6Mro2jCAt+5sxvxtp3h96aHqPZid48WlfGd2wtbPTJJPCGEbpIASQli1S8N1Uy1juC5Al/tHUV5ayrqv56iOUimaptF1SCOMRlj11UGbLDAcoqIIem0auX/+yfk5c1XHsRijmo6iR0QP/vPXfzhy4YjqOCYxIC6U52+O4eM1x/h07bHqPVhoS2g1AlZOgWzr2NsohKh5SgqoAQMG4OXlxcCBAy87/u6779K4cWNiYmIYO3asTf4nLoQwvUvDdf+wjOG6rl7edLrnfvas/JOUg9bRCtnZ3Z6E+xqStDuTA+tTVcepEe49euAzcgTpb79N/pYtquNYBE3TmNJhCmFuYYxdOZbs4mzVkUxiRMcoHkmow6tLDvL9tlPVe7BuL4C9C/z+tGnCCSGsnpICauzYscybN++yYxkZGXz44YckJiayZ88eEhMT2bRpk4p4Qggr5NE7kvL8UvLWWca7xM169Cawbn2WfzaD8jLraIUcHetHow5BrPv+CNkZBarj1Ai/ceNwbtmS00+Mp/TsWdVxLIKznTPvJbxHXmkeE9ZMoKzCNvb7TOjZgHtah/PsT3v4c1/ajT+Qowf0fg0OLoaDS0wXUAhhtZQUUAkJCbi5uf3reFlZGUVFRZSWllJaWoq/v7+CdEIIa3RpuO6aUxYxXFen09Nj1KOcP5PCtsWLVMeptI531sPZzY7lc/ZTUd1OZhZIMxgIeedtNIOB0+OewFii/nfFEoS6hfLWTW+xNW0r7ya+qzqOSWiaxpTbmtAzJoBHv93BpuPnbvzBGg+Auj1gyVNQLI1IhKjtqlxArV27lltuuYXg4GA0TWPRokX/us/MmTOJiorC0dGR+Ph41q1bd93H9fPzY8KECYSHhxMcHEz37t2pU6dOVeMJIWqxi8N1dRYxXBfAPzKaFn1vZdOP35GdXo13wM3I3tFA9wcac/ZEDtv/sIyfo6kZfHwImf4uhXv3cvbNt1THsRhtgtowoeUE5u2fx2/Hf1MdxyT0Oo3pd8fSMsKLUV9sY/+ZGxwarWnQ7y0oOAerp5k2pBDC6lS5gMrPz6d58+Z8+OGHV7x9/vz5jBs3jkmTJrFjxw46depEnz59SE6+9sTzCxcusHjxYpKSkjh9+jQbNmxg7dq1VY0nhKjFLG24LkD7O+/Fyc2dFZ9/ZDX7OoPqeNCidwRbFyeRfvIGX3BaOOe4OAKefYYLX35J9q+LVcexGIMbDaZfdD9e2vASh85Xs4udhXAw6Pl0aEsifJ0ZPncradlFN/ZAXpHQ5RnY9BGk7jJpRiGEdalyAdWnTx+mTJnC7bfffsXb33nnHUaMGMHIkSNp1KgR06dPJywsjI8++uiaj7t8+XLq1q2Lt7c3Tk5O9OvX75p7oIqLi8nJybnsQwghXNsFofd2JHvJCdVRALB3dKLr8NGc2JnI4U3rVceptFY3R+ET6sqy2fsptYDGHDXB6957ce9/C6kvvEDxEdvoQFddmqbxYrsXifSIZNyqcTbTVMLVwcDn97dC02D43K3kF9/gPq92j4JfA/h1HFTY5t+FEOL6TLoHqqSkhMTERHr27HnZ8Z49e7Jhw4Zrfm1YWBgbNmygqKiI8vJyVq9eTYMGDa56/2nTpuHh4XHpIywszCTfgxDCul0arnvoAkVH1A/XBajbsg11W7Vl1RefUlxgGVfGrkev19FjeAy554vY+ONR1XFqhKZpBL30EvahoTJk9784GZx4t8u75Jbm8sy6Zyi3kUIhwN2R2cNakXy+gMe+3UHZjezx09vBLe/Bme2wbbbpQwohrIJJC6jMzEzKy8sJCAi47HhAQABpaf+//r9Xr17ceeedLFmyhNDQULZu3Urbtm3p27cvcXFxNGvWjDp16tC/f/+rPtfEiRPJzs6+9HHqVDXblAohbIZTk7+H6y6xjOG6AAnDHqKksJC/vvtSdZRK8wp0of3tddmz5jQn91VjA74F0zk7E/L+e5RlZpI66TmrWWZZ00LdQnmj0xtsPLORGTtnqI5jMo2C3JkxuAVrDmcwefH+GzvfYa0h/gFY/jLk2GbLfyHEtdVIFz5N0y773Gg0Xnbsjz/+ICMjg4KCAlJSUmjVqhUAU6dO5cCBA+zbt4/333//X4/z3xwcHHB3d7/sQwgh4H+G6263jOG67r5+dLhrMDv//I20o4dVx6m0pl1CCI/xZuUXByjMs82OdQ5RUQRNe5XcP/7g/BdfqI5jMdqHtOexuMf4bM9nrEheoTqOydxU349Xbm3CvI0nmb0+6cYepPuLYOcES581aTYhhHUwaQHl6+uLXq+/7GoTQHp6+r+uSgkhRE1yiHDHqZkv2X9axnBdgLjet+AXEcWyz2ZQUW4Zma5H0zS6Dm1EeXkFa74+ZLNXaNx79MB7xHDS33yLgsRE1XEsxogmI+ge3p1Jf03iePZx1XFM5t424TzUOZopv+2/sRlRTl7QayrsXwQnpOGVELWNSQsoe3t74uPjWbZs2WXHly1bRvv27U35VEIIcV0evSKpsKDhujq9nh6jHiH95HF2/mE9nd9cPB3ocm9Dju3I4NBm62jHfiP8n3gC57g4To97grLMTNVxLIKmaUzpOIUA5wDGrRpHXont7BN7pndDejcO5PHvdrI7JavqD9D0TghrA78/C+W2MXxYCFE5VS6g8vLy2LlzJzt37gTgxIkT7Ny581Kb8vHjxzNr1ixmz57NgQMHeOKJJ0hOTmb06NEmDS6EENdjacN1AYLqNqB5j778Nf8rcs9Zz4v0uvH+NGgTyNrvDpOTWag6To3QDAZC3n0HI0ZOj38SY5m8KAZwsXNhesJ0MgoyeH798zZzFVKn03h3UCwNAt0YPncbZ7Kq+HutadDndUjfD4lzaiakEMIiVbmA2rZtG3FxccTFxQEXC6a4uDheeOEFAAYNGsT06dOZPHkysbGxrF27liVLlhAREWHa5EIIUQmWNlwXoNM9Q7F3dGTV3E9VR6mSTnfXx8HZwIovDlBhIc05TM3g50fou+9SkJhIxnvvqY5jMaI8opjScQrLk5czb/881XFMxtFOz6z7W+Jg0DH6q0SKSqu4tDY4DuLug1VToeB8zYQUQlicKhdQXbp0wWg0/utj7ty5l+4zZswYkpKSKC4uJjExkc6dO5sysxBCVJrO2Q73bpY1XNfB2YUu94/iyJYNHEvcojpOpTk4Geg+LIYzR7PYtdx2O586t2yJ/4QJnPtsFrnLl6uOYzG6hXfjgSYP8G7iu2xL26Y6jsn4ujrwyZB4DqXlMmnh3qpfYev24sWZUKum1kxAIYTFqZEufEIIYUlc21rWcF2ABu06Edm8BStmf0RpUZHqOJUWUt+L2O7hbPrlGJkptrMf5n95D7sft549OTPxP5T8vURdwNi4scT5x/HU2qfILLSeJajX0yTEg9fvaMaP21OYuyGpal/s6gc3PXNxLlTa3hrJJ4SwLFJACSFsniUO19U0jW4jxlCYnc2GH75RHadK2vaPxivAmeVz9lFW1SVPVkLTNIJenYrB25uUx8dRYUVFbk0y6Ay8edObaGhMWDOBsgrb2Sd2W1wIIztGMeW3A2w8VsW5Z60fBO86F9ua28geMSHE1UkBJYSoFZya+GIf4W5Rw3U9AwJpe8fdJP62iIyTlnN17Hr0djq6P9CYC2cL2PyL9eSuKr2rKyHvv0fJ8eOkTZmiOo7F8HXy5c2b3mRn+k7e3/6+6jgm9WyfhrSN9uaRb7aTcqGg8l9osIfer0HSOtj/c80FFEJYBCmghBC1wsXhulEXh+vusIzhugAtbxmAV1AIy2bNwFhRoTpOpfmGutK2fx12Lk/m9CHLuKpXExwbNCDwxRfJ/uFHsn78SXUcixEfEM8T8U8wZ98cVpy0nSG7Br2OD+9pgbO9noe+TKSwKjPk6nWH+r3hz+eh1DY7VQohLpICSghRaziEXxyum/OH5QzX1Rvs6DHyEVIPH2TPyj9Vx6mS5t3DCK7ryfIv9lNcaDtLuf6X5+0D8LxzIGmTJ1N08KDqOBZjaMxQekT04Ln1z3Eyx3K6XFaXl4s9nw5pyfGMfCb+tLtqTSV6vQq5qbDetq7MCSEuJwWUEKJW8egVSXl+KXl/WcZwXYDQmCY07tKdtd/MoSA7S3WcStPpNLoNa0RJQRnr5h9WHadGBUyahH10NCmPP055bq7qOBZB0zQmt5+Mj5MPT6x+gsIy27nqEhPszpt3NmPRzjPMWleFZao+daDdGPjrXciy3U6VQtR2UkAJIWqVS8N1V6dYzHBdgM6DH0DT6Vn95eeqo1SJu48TnQbV59CmNI5tt5ylkaamc3Qk9L3plJ+/QOp/JtnMMNnqcrV35d0u75KSm8LUTbbVxvvmZsGMvqkOry09yNakKsx46vwUOLrD8pdqLJsQQi0poIQQtc7F4bqaRQ3XdXb34KbBD3Bg3SqS9+5SHadKGrQNJDrWj9VfHyI/u1h1nBpjHx5O8LRXyV22jPNzv1Adx2LU86rHc22f4+djP7Po6CLVcUxqQs/6xEd48dg3OzifX8k3XBzcIGES7P0Bzuys0XxCCDWkgBJC1DqWOFwXoHGX7oQ0bMzyWTMpKy1VHafSNE2jy+AGaHqNVV8etOmrM27du+M9fDjpb71FwfbtquNYjP51+nNb3duYumkqRy8cVR3HZAx6He/fHUdJeQVPLthJRWU7eMYOBt/6chVKCBslBZQQola6NFz39yTVUS7RNI0eox4hOz2NrT//oDpOlTi52dN1SENO7j3HvnVnVMepUf5PjMMpNpbTT4yn7HwVlnbZuP+0+Q+hbqE8ueZJCkqr0ALcwgV6OPL2Xc1ZdSiDz9Ydr9wX6Q3Q7UU4vgqOrazZgEIIs5MCSghRK10arnvwPEVHs1THucQnNJyWt9zO5kULuJBqOY0uKiOyqS8xnYJZ/8MRstJt5wX0/9Ls7Ah5522MpaWceeppq2o/X5OcDE68fdPbpOanMnXzVJu6EpnQwJ+HbormzT8OkXiykm37G/aDsDaw7EWQ3xEhbIoUUEKIWsupiS/24W5kLzluMcN1AdrePghXL2+Wz5ppdS9CO9xRF2cPB5bP2U9Fue2+aLQLCCD4zTfI37CBzI8/Vh3HYkR7RvN82+f55dgvNrgfqgHNwzwZ++0OsgoqsR9K06DHZEjbDftkhpgQtkQKKCFErXVxuG40pWcsa7iunYMjXYePJnnvLg6uX6M6TpXYOxroPiyG9KQctv+RrDpOjXLt0AHfMWPI/OBD8jduVB3HYtxS5xZur3c7r25+lSMXjqiOYzJ2eh3v3xNHXnEZE76v5Hyo8LbQoB+smAxltttgRYjaRgooIUSt5hDhjlNTX3L+tJzhugDRca2o36YDq+fNoigvT3WcKgmq40GLXhFsXXyC9JM5quPUKN8xD+PSri2nJzxFabrlFOGqTWw9kTD3MJvbDxXi6cRbdzZn+YGzzF6fVLkv6vYCZJ+CbXNqNJsQwnykgBJC1HoevSMpzyslb71l7TlKGPYgZSXF/PWd9bXMbnVzFN4hLiyfs58yCypMTU3T6wl+8000nY4z45/EWFamOpJFcDQ48tZNb5GWn8Yrm16xuqWo19IjJoARHaN47fcD7DqVdf0v8G94sSvf2jegyLbfUBCitpACSghR610arrvKsobrunr70GHQEHYtX8qZwwdVx6kSvUFH9wdiyMksYtOiSnYus1IGHx9C3nmbgh07yHj/A9VxLEa0RzQvtnuRxccX29x+qGd6NyQmyJ3Hvt1BfnEliuaE/0BJPmx4v+bDCSFqnBRQQgjB38N1dRo5Kyxr305sr34ERNVh+awZVJRb15Ucn2BX2t4Wza6Vp0g5aNvtvp1btcJv3OOc+/RT8tZY1761mtQvuh8D6g5g2pZpHM+ynULa3qBj+t1xZOQWM3XJget/gXswtH0YNs6A3LSaDyiEqFFSQAkhBP8M1w0jf0sqpRbUglun09N95CNkJCexY+mvquNUWfOuYYTU92TFFwcoLrTt5W0+I0bg2qULZ55+htIztj0Lqyqebf0sgS6BPL32aYrLbaeRQpSvC//p14hvNiez6lAl9r91GAcGB1j9Wo1nE0LULCmghBDib67tgtF7OpL9+wnVUS4TWKcesT37sX7+V+RkZqiOUyWaTqPr/Y0oKSxj3fzDquPUKE2nI/i1aWguzpwe/yTG0lLVkSyCs50zb3Z+kxPZJ3hn2zuq45jUfW3C6Vzfj2d+2H391uZOntBpAmyfB5m2051QiNpICighhPjbpeG6B85TdCxLdZzLdLx7CPbOzqz+4jPVUarM3ceJToPqc2hTGscsqF18TdB7ehL6zjsU7t1L+rvTVcexGA28G/Bkyyf55uA3rEpepTqOyWiaxht3NKOotJznf953/S9oNRLcguQqlBBWTgooIYT4L05NfbEPcyN7yQmLGq7r4OxCwv2jOLJlA8cSt6iOU2UN2gYS1dyX1V8dIj/bdpZxXYlTbCz+Tz7J+dmzyV1pO8VCdd3T8B4SwhJ4fsPzpOXbzj6gQA9HXrmtCb/uOsMvu66zdNPOETo/CXt/hIxD5gkohDA5KaCEEOK/XByuG0Xp6TwKdlnWcrn6bTsS2bwFK+d8TGlRkeo4VaJpGgn3NUTTwaqvDtpUW+sr8R52P65du3Jm4kRKT1tWe3xVNE1jcvvJOOodmbhuIuUV1tUU5Vr6Nw+mX7Mgnl+0l7M51/nbjL0P3ENgzRvmCSeEMDkpoIQQ4n84RHrg1NiHnKVJGEst50Wepml0G/4wBVlZbPzpO9VxqszJzZ6EIY04ueccB9anqo5TozRNI/jVqehdXEgZPx5jieW0x1fJ09GT1zq9xvb07Xy651PVcUxG0zSm3NoEe4OOp3/Yfe03CAz20Gn831ehbHtfoBC2SgooIYS4Avc+UZTnlpC73rK6qXkGBtHm9kEkLl5IZnKS6jhVFtXMl0Ydgvjr+yNkZxSqjlOj9J6ehLz7DkX79st+qP/SMrAlDzV7iI93fUzi2UTVcUzGy8WeN+5oxprDGXy75dS17xz391WotXIVSghrJAWUEEJcgZ2vE65tg8hddYryPMu6etDyltvxDAhi2ayZGCsqVMepso531sPJzY4Vc/dTYUH7zGqCU/Pm+E94kvNz5pC7cqXqOBbjwWYPEusXy7PrniW7OFt1HJNJaOjPPa3DmPLbfk6ey7/6HQ0OF69C7flBrkIJYYWkgBJCiKtw6xYOGhY3XNdgZ0f3kWM4c2g/e9csVx2nyuwdDXS7vxGpx7PZudyyfrY1wfv++3Ht1o0zz06kJEX2QwEYdAZe7/w6+aX5vLLpFZvaEzepXww+rvbXX8onV6GEsFpSQAkhxFXoXexwTwgnf3MapRmWM1wXIKxxM2I6d2XtV3MoyLG+d/CD63kR2z2czb8c59zpPNVxatSl/VCurpx+UvZD/SPQJZAX2r3AH0l/8Otx6xsSfTWuDgamDWjG5hPn+X5bytXvaHCATk/IVSghrJAUUEIIcQ2u7YPRu9uT/XuS6ij/ctN9w8FoZO3Xc1RHuSFt+kfh6e/Msjn7KS+zvqWIVaH38CBk+rsX90NNf091HIvRO7I3/ev059XNr5KSe41iw8p0rOfLgLgQpi45QGbeNdr2xw0B92C5CiWElZECSgghrkGz+3u47v5zFB+3rCs9zh6edBo8jH2rl5Oyf6/qOFVmsNPTfVgMF87ks3XxCdVxapxTs2b/Px9q9WrVcSzGxNYT8XTwZOK6iZRVlKmOYzLP9WuEpsGUxfuvfqd/9kJJRz4hrIoUUEIIcR1OzfywC3Ula8lxixquC9A0oSdB9Ruy/POZlJeVqo5TZX7hbrS6OYrtf5wkzcIK1JrgPex+XLt0IfXZiZSm2c4w2epwtXdlWqdp7M7czaw9s1THMRkfVwcm9W3Eop1nWHfkGjPl4oaAWxCsfdN84YQQ1SIFlBBCXIem0/DsG0VpSh6Fuy1ruK6m09Fj5COcP5PCtsWLVMe5IS16heMf6c7yOfspLbacuVs1QdM0gqa9iuboyOkJEzCW2c4Vl+qI849jVNNRfLzrY3Zn7FYdx2QGxofSLtqHSQv3Ulhyld9tgwN0fAL2yl4oIayFFFBCCFEJDtGeOMb4kL00CWOpZe3X8YuIokXfW9n043dkp1vfVQ2dXkf3YTHkZxWz4aejquPUOIOXFyFvv0Xhjp1kzJihOo7FeKj5Q8T4xDBx3UQKSi2racuN0jSNqQOakJZTxPsrj1z9ji2GgmugXIUSwkpIASWEEJXk0SeS8pxi8jZY1nBdgPZ33oujmxsrZn9slS2hPQOcaX9HXfauOU3yvnOq49Q45/h4/B57jHMff0L+hg2q41gEO50dr3V6jYzCDF7f+rrqOCYT7efKowl1+XTtcQ6k5lz5Tpf2Qv0Ambb/JoIQ1k4KKCGEqCQ7P2dc2gSRsyqZ8nzL2m9k7+hE1wce4sSObRzdslF1nBvSpHMIoQ29WDnvAEUW9vOtCT4PjsKlXTtOP/0MZRmWtTRUlXD3cJ5t/Sw/HfmJFSdXqI5jMqNvqkOUrwsTf9pD+dX2UbYYCi5+sOF984YTQlSZFFBCCFEF7t3CwQi5Ky1vAGzdlm2Jjm/NyrmfUFJofUugNJ1G16GNKC2pYO13tr8XRNPpCH7j4pWW008/jbHctvd/VdaAugPoFt6NFze+SGZhpuo4JmFv0DHt9qbsPJXF15tPXvlOBgdo8xDs+g7y0s0bUAhRJVJACSFEFehd7XHrEkbexlTKMgtVx7mMpml0HfYQRXl5rF/wteo4N8TN25HOg+pxZOtZjiba/otIg68vIW++QcGmzZz79FPVcSyCpmm80O4F9Jqelza8ZJVLUq+kVaQ397QO442lh0jLLrrynVoOB70dbP7EvOGEEFUiBZQQQlSRW8dg9G52ZP+RpDrKv3j4B9Bu4D3s+P1X0pOOq45zQ+q3CSQ61o813xwiP/saQ0hthEu7dvg+PJqMD2dQkJioOo5F8Hb05qV2L7EmZQ2Lji5SHcdknu3dCEc7HdN+P3DlOzh5QYv7YessKM4zbzghRKVJASWEEFWk2elx7xVJ4Z5Mik9eZVO4QvH9bsM7JJTln83AWGFZHQMrQ9M0ugxugKaD1V8fspkrENfiO2YMTrGxnJ7wFOVZWarjWISE8ARurXMrr299nTN5lte45UZ4ONvxVK8G/LzzDIknL1z5Tm0fhuJc2PGlecMJISpNCighhLgBzrH+2AW7kP3bcYt7ga83GOg+cgypRw+xe8UfquPcECc3e7oMbkjS7kwObkxVHafGaQYDIW+9SUVBAWeee87ifqdUeab1M7jZu/HC+heoMFrfmwFXMjA+jMbB7kz+dR8VV2oo4RkGTe6AjTOg3PabqQhhjaSAEkKIG6DpNDz6RlOSnEvhHsvb6B7aqAmNu3Rn3bdzKcjOUh3nhkTH+tGwbSDrFhwh55xl7TerCXZBQQS/OpW85Su48M03quNYBDd7N17p8Aqb0zbz7cFvVccxCb1O44WbY9iVks2inaevfKcOYyH7FOxbZNZsQojKkQJKCCFukGNdTxwbel8crltmee+Odx78AJqmY82Xn6uOcsM6DqqPg5OBlfMOYLxa+2cb4tatG16DB5P++hsUHTyoOo5FaBvUlnsa3sP0xOkkZSepjmMSbaJ96Ns0kNeXHiS/uOzfdwhsCnW6wob3QK5GCmFxpIASQohq8OgTSfmFIvI2Wd4yM2d3DzoPfoD961aRvHe36jg3xMHJQNf7G3H6UBa7V6eojmMW/k8/hX10NKefGE9FgfW1o68J41qMw9/Zn0nrJ1FWcYWCwwpN7NOICwWlfLzm2JXv0H4spO2B46vNmksIcX1SQAkhRDXYBbjg0iqQnBXJVBRY3n6FJl26E9wghuWfz6Ss1PLyVUZYQ2+adgll48JjXEjLVx2nxukcHAh55x1K09JImzJVdRyL4GznzNSOU9mbuZe5++aqjmMSYd7OjOoUxadrj5Ny4QqFcnSXi1ei1r9n9mxCiGuTAkoIIarJvUcElFeQs/qU6ij/oul0dB85huyzqWz79SfVcW5Yu9vr4OrlwPK5B6got7zlkqbmEB1F4PPPk/3TT2T/ulh1HIsQ6x/LsMbDmLFzBofOH1IdxyTGdKmLu5Mdr/1+heWamgYdxsHxVZBqnVeQhbBVUkAJIUQ16d3scbspjLz1Zyg7f5UBmQr5hUfSou+tbP5pPlln01THuSF29nq6D4sh42QO2/9MVh3HLDwG3Ib7LbeQ9tJLlJw8qTqORXgk9hGiPKJ4bv1zlFZY5xXV/+biYODpXg1YvDuVrUnn/32HmNvAIxw2fGD2bEKIq5MCSgghTMC1Uwg6F8scrgvQfuC9OHl4sHL2R1bbIjsw2oO4XhFsXXyCzJRc1XFqnKZpBL74InofH04/OQFjSYnqSMrZ6+15pcMrHLlwhDl756iOYxJ3tAilWagHk3/d/++25noDtBsDe3+ErNrxxoEQ1kAKKCGEMAGdvR6PHhEU7sqg5JTlvbi3c3Sk67CHOLEzkSOb16uOc8Na94vCK9CZ5XMOUG6BnQ9NTe/qQsjbb1F08CAZ77+vOo5FaOzTmAeaPMDHuz7m6IWjquNUm+7vtuZ7Tmfz4/YrNEqJGwIObrDpI/OHE0JckRRQQghhIs7xAdgFOpNlgcN1Aeq2akudlm1Y9cVnlBRaZ3c3vZ2ObsNiuJCaz9bfTqiOYxZOTZviP+5xzs36nPwNG1THsQijm48mzC2MFza8YBNd+VpGenNL82De+OMQef/b1tzBFVqNhMQvoDBLST4hxOWkgBJCCBO5NFw3KYei/VfYz2ABug57iKL8PDZ8/7XqKDfML8yNVjdHsn3pSdJOZKuOYxbew4fj0r4dp595hrLzlvm7ZU4Oegcmd5jM3sy9fLX/K9VxTOLZPg3JLixl9l9XeGOg9SgoL4ZdtjFMWAhrJwWUEEKYkGN9LxzqeZL9+wmMFtgtzt3Pn3Z33MP2338lPem46jg3rEWvCPzC3Vgx9wBlJeWq49Q4Tacj6LXXoKyc1In/scgrnObW3K85Q2KG8OHOD21iwG6IpxP3tYngs7XHySr4n/1uboHQ6BbYOgsqLO/fFSFqGymghBDCxDz6RFF2rpD8LZbZ8S6+3614B4ey/POZGK30xZhOf3EpX+65Ijb9bL2FYFXY+fsT9OpU8tas4cJX1nsF0ZQejXsUf2d/XtzwIhVG6/xd/m9jEupQVmHkk7VX+J1uNQrOHYUTq82eSwhxOSmghBDCxOyDXXFuEUDO8mQqiixvf4beYEf3EWNIPXyQPav+VB3nhnkHudD2tmh2rTzF6cMXVMcxC7eEBLzuu4/0N9+k6JBtzEKqDieDEy+3f5nt6dv57uB3quNUm6+rAw90iGTu+iTSc/9nJEJEe/CPgS2z1IQTQlwiBZQQQtQA954RGEvKyV1zha5aFiA0pgmNb+rGuq/nUpBjvfuImnUNI6iOByvnHaDEAovVmuD/1ATso6I4Pf5JKgoLVcdRrlVgKwY1GMT07dNJybXMv7eqeKhzHQx6jZmrjl1+g6ZdbCZx+HfIsryh3ULUJlJACSFEDTB4OODaMYTcdacpyypWHeeKOt83HIC1X81WnOTG6XQa3e6PoSC3lPU/Wn9L68rQOTgQ8s7blJ4+zdnXXlcdxyI8Ef8Eng6evLTxJavfH+bhbMeDnaL5ZnMyZ7L+p0BuNgjsXWGb9f7NCmELpIASQoga4tYlFJ2jnpw/k1RHuSJndw86DR7GvjUrSNm/V3WcG+bh50SHO+qyf90ZTu47pzqOWTjUqUPAxIlkzZ9Pzp/WuwzTVFzsXHip3UtsTt3MT0d+Uh2n2h7oGIWro4EPVh65/AYHV2h+D2yfB2WW+caMELWBFFBCCFFDdA4G3LuHU7AjnZIzearjXFHThJ4E1W/I8s9nUl5WqjrODWvcKZiwRl6s+vIgxQXW+31Uheddd+LWowdpz79A6dmzquMo1z6kPbfWuZW3E98mszBTdZxqcXUwMKZLHRZsSyEpM//yG1uNhIJM2LdISTYhhBRQQghRo1xaBWLwdSJ7yQmLXFqk6XR0HzGG82dSSPztZ9VxbpimaSQMaURpURnrFhy5/hfYAE3TCJz8MpqDA2eefdZqOyqa0oSWEzBoBt7Y8obqKNV2X9sIfF3tmb788OU3+NWHqJtg62dqggkhpIASQoiapOl1ePSJovhoFkUW2inOPzKaFn1uYeMP35KTka46zg1z83ak4131ObQpjRO7MlTHMQuDlxfBr79GwcZNnJ8zV3Uc5TwdPXmq1VP8nvQ7f53+S3WcanG00/NY13r8vOsMh9JyL7+x9ShI2QpndirJJkRtJwWUEELUMMdG3thHeVy8ClVueVehANrfORhHV1dWzv1EdZRqadgukMimPqz6+hBFebVjKZ9Lu3Z4Dx9O+vTpFO3frzqOcjdH30yboDZM2TSFgtIC1XGq5a6WYYR4OvHOsv9pWV+/D7iHylUoIRSRAkoIIWqYpml49o2i7GwBBYmWuVfF3smZhPtHcWzbZo5u26w6zg3TNI0u9zWkoqyCNd/VnjlJfuMex6FeXU5PeKrWtzbXNI0X2r5AZmEmH+/6WHWcarE36BjXvT5/7DvL7pSs/79Bb4CWw2DPD1BwXlU8IWotKaCEEMIM7MPccGruR/ayk1SUlKuOc0X12nQgMjaeVXM/obSo6PpfYKFcPBzofE99jm5L52ii9S5JrAqdvT0hb75J6ZkznH1dWpuHu4fzULOHmLd/HgfPH1Qdp1oGxIVQx8+Ft//8n71QLe6HinLY+bWaYELUYlJACSGEmXj0iqSioJS8tZY57FPTNLo+8BD5WRfY9NN3quNUS72WAdSJ82PNN4coyClRHccsHOrUIeDZZ8j6bj65K1eqjqPcsMbDiPKI4uUNL1NeYZlvWlSGXqfxRI/6rDmcwc5TWf9/g6s/NL4Ntn4O0kBECLOSAkoIIczE4O2Ia4dgctemUJ5rmS/qvQKDaXPbXWxbvJBzKcmq49wwTdO46d4GaDpY/fVBi+yAWBM8Bw3CtWtXUic9R2l67bj6djV2ejtebPcie8/t5btD1v2GQJ8mQUT7uvDx6mOX39BqFFw4AcdWqAkmRC2lpIAaMGAAXl5eDBw48F+3FRQUEBERwYQJExQkE0KImuXeJQz0OnKWnVQd5apa9b8DD/8Aln8+06oLDyc3e7rc25ATuzI5vMUy956ZmqZpBE15BQx6Up+dWOtbm8f6x3JX/bt4f/v7pOWnqY5zw/Q6jQc7R/PH/jSOZfzXTLmw1hDYFLZIMwkhzElJATV27FjmzZt3xdumTp1KmzZtzJxICCHMQ+dsh3vXcPK3plF6Nv/6X6CAwd6ersMfJmX/Xg6sW6U6TrVEx/lRv3UA6+YfJj+rWHUcszB4exM87TXyN2zgwldfqY6j3OPxj+Ns58y0zdNUR6mWAS1C8HN14NM1x///oKZBy+FwdBnknFEXTohaRkkBlZCQgJub27+OHzlyhIMHD9K3b18FqYQQwjxc2wWh93Ik+/ck1VGuKrJZHA3adWL1l59TlJd3/S+wYJ0G1Udvp2NVLVrK59qxA15DhpD+1tsUH6kdg4Wvxt3enWdbP8vKUytZmWy9e8McDHpGdIzipx0ppGX/V5OXJneA3gF2fasunBC1TJULqLVr13LLLbcQHByMpmksWrToX/eZOXMmUVFRODo6Eh8fz7p16yr12BMmTGDaNOt+h0gIIa5HM+jw6B1J0cHzFB3LUh3nqroMHUl5aQl/ffeF6ijV4uhiR8Lghpzcc46DG613GVdV+T85HrvwME4//QwVJZa5585cekb0pGNIR17f8jqFZdbb5v3eNuE42un5/K//ugrl6AGNboEdX0MteYNACNWqXEDl5+fTvHlzPvzwwyvePn/+fMaNG8ekSZPYsWMHnTp1ok+fPiQnX3sz8s8//0z9+vWpX79+VSMJIYTVcWrqi32Y28XhuhWW+aLH1duHDnfdx67lS0k9at0zlSKb+dKwbSB/LThM3gXrbdFeFTpHR0LeeIPio0fJfP991XGU0jSNia0nklGYwed7Plcd54a5OdoxtF0E32xOJrvgvwZFxw2G88fglPXOcBPCmlS5gOrTpw9Tpkzh9ttvv+Lt77zzDiNGjGDkyJE0atSI6dOnExYWxkcffXTNx920aRPfffcdkZGRTJgwgc8++4zJkydf9f7FxcXk5ORc9iGEENZC0zQ8+kVRejqPwl0ZquNcVWyvm/GLiGL5ZzOpsOJW0AAd76qHnYOeVV/WnqV8jjEx+I19jHOfzyZ/yxbVcZQKdw/ngSYPMHvvbJJzrLfD5LD2UZRWGPlyU9L/H4zsDB7hsEP2vAlhDibdA1VSUkJiYiI9e/a87HjPnj3ZsGHDNb922rRpnDp1iqSkJN566y1GjRrFCy+8cM37e3h4XPoICwszyfcghBDm4hDpgWNjH7L/SMJYapnd0nR6Pd1HjCH95HF2/blEdZxqcXC2I2FII5L3n+fA+lTVcczGZ/hwnOJbcObZZynPzVUdR6mRTUfi5+THtC3TrLaI9nNz4K6WocxZn0RR6d9vauh0EHsP7FsIJZbZnEYIW2LSAiozM5Py8nICAgIuOx4QEEBa2v+vO+/Vqxd33nknS5YsITQ0lK1bt1b5uSZOnEh2dvalj1OnTlU7vxBCmJtH70jKc0rI22C5HbSC6zekWdde/PXdl+RdOK86TrVENPGhUYcg/vrhCDnnrHcvTFVoej3Br71ORXYOZ6dMUR1HKSeDE8+0foa/Tv/FylPW21DiwU51uFBQwvfb/uu1T+y9UJIH+39RF0yIWqJGuvBpmnbZ50aj8bJjf/zxBxkZGRQUFJCSkkKrVq0uu/+wYcN46623rvkcDg4OuLu7X/YhhBDWxs7PGZc2geSsSqY8v/T6X6BIx3uGojcYWPOl9e4f+UeHgfVwcDLUqqV89qEhBDz/HNk//0LO77+rjqNUQliC1TeUCPdxpl+zYD5Ze5yy8r+vXntFQmQn2Pm10mxC1AYmLaB8fX3R6/WXXW0CSE9P/9dVKSGEEBe5dwsHI+SutNx9GU5u7nQe/AAH168hee8u1XGqxcHJQMKQhqQcvMC+dZZ75c/UPG69FbfevUl96WVKz9aOwcJX8k9DiczCTGbtmaU6zg0bfVM0KRcK+W3Pfy1HjR0MSevg/Al1wYSoBUxaQNnb2xMfH8+yZcsuO75s2TLat29vyqcSQgiboXe1x61LKHmbUimz4GVljW/qRkjDGJZ//hHlZZZ7tawywmN8iOkUzPofj5KTabk/c1PSNI2gl15E5+BA6sSJGCssc9+dOYS7hzO8yXDm7J3DyZyTquPckMbBHnSu78dHq4/9/5XUmP5g7yYzoYSoYVUuoPLy8ti5cyc7d+4E4MSJE+zcufNSm/Lx48cza9YsZs+ezYEDB3jiiSdITk5m9OjRJg0uhBC2xLVDCHpXO7KXJqmOclWaTke3EWPISjvDtl8Xqo5TbR3uqIuTix0r5x2w2Fbypqb39CRo2qvkb9jIhW9q94vsEU1H4O/sz7TN1ttQ4uGb6nAwLZfVh//u5GnvAo1vg53fQi0ukIWoaVUuoLZt20ZcXBxxcXHAxYIpLi7uUse8QYMGMX36dCZPnkxsbCxr165lyZIlREREmDa5EELYEJ29HveekRTuyaQ42XLHMviFR9Ki761s+mk+2enWPZTW3tFAwtCGnD6cxd61p1XHMRvXDh3wuvde0t96i+LjtXepl5PBiadbPc36M+tZmWydDSXaRnsTG+bJx6uP/f/BuPsgO/niUj4hRI3QjNb6tsv/yMnJwcPDg+zsbGkoIYSwSsYKI+kf7ECz1+M3utm/GvJYipLCAuaMfxj/qDoMePrq4yasxepvDnFocxp3P9caDz8n1XHMoqKwkBMDbkfn7k7kN1+jGQyqIylhNBp5ZMUjHM06ys+3/YyTwfrO/2+7U3nkm+0sHdeJhoHuYDTChy0hJB5u/1R1PCGUqcnaoEa68AkhhKg6Tafh0TeKkpM5FO07pzrOVdk7OZMw7EGOJ27h6LbNquNUW/vb6+DkYseqL2vPUj6dkxPBr79G0d69nPvsM9VxlNE0jWdbP0tmYSZz985VHeeG9GwcQIC7A/M2/r2XS9MutjTf/wsUZasNJ4SNkgJKCCEsiGM9Lxzqe5G9NAljueXuYajXuj2RsfGsmvsJpUVFquNUS21dyufUvDk+Dz1IxoyZFO7bpzqOMuHu4dwXcx+z984mLd/6lqXa6XXc0zqcRTtOk1P0d3OX5vdAefHFwbpCCJOTAkoIISyMR58oys4Vkr/Fcl/MaZpG1wceIj/rApsWzlcdp9rCGnrTuHMIGxYeIzujdnTlA/B7+GEc6tfjzDPPUFFcrDqOMg82fRBnO2fe2/6e6ig35N7W4ZSUVfBjYsrFA+7BUKcr7JCZUELUBCmghBDCwtgHueDcIoCc5clUFJWpjnNVXoHBtL71Trb9upBzKadUx6m22riUT7O3J+T11ylNPkXGdOssHkzB1d6Vx+IeY/HxxezO2K06TpX5uzvSq0kgX246+f8dBWMHQ8oWyDisNpwQNkgKKCGEsEAePSMwlpSTuyZFdZRran3rQNx9/Vgx+yOrbQX9j9q6lM+hXj38xo3j/Ny55G/ZojqOMgPqDqCBVwNe3/q6Vf4uD20bwfGMfNYf/Xv/ZIO+4OgJO+UqlBCmJgWUEEJYIL2HA64dQ8hdd5qybMtdWmWwt6fr8NGc2rebg+vXqI5TbWENvWncKbjWLeXzvn8ozvHxpE78D+V5earjKKHX6Xm61dPsztjNkhNLVMepstZR3jQIcGPexqSLB+wcockdsOcHmQklhIlJASWEEBbKrUsoOgc9OX+eVB3lmqJi46nXpj1rvvyc4oJ81XGqrf3fA3Zr1VI+vZ6g16ZRfuECZ6dNUx1HmdZBrekW3o13E9+lsMy6CmhN0xjSLoLlB85yOuvv7E1uh5wUSNmqNpwQNkYKKCGEsFA6BwPu3cMp2H6WkjOWfVWgy9BRlBQWsn7BV6qjVFttXcpnHxqK/8Rnyf7xJ3JXr1YdR5kn45/kfNF55u6bqzpKlQ2IC8HF3sA3m/9+0yW8HbgGwr6f1AYTwsZIASWEEBbMpXUgBh8nsn8/oTrKNbn7+tHuznvZufQ30pOOq45Tbf+9lC8n07quRFSH58CBuHTqRNrzL1CeXTtnCIW5h3FfzH3M2TvH6tqauzgYuCM+lO+2nKK4rBx0emg84GI784py1fGEsBlSQAkhhAXT9Do8+kRSfCSLosMXVMe5phZ9+uMdEsryWTMw2sCei/a318XR2cCqrw5aZVOBG6FpGkGvTKaiqIi0qVNVx1HmwaYP4mRwssq25ve1jeBcfglL9qRePNDkdsg7Cyc3qA0mhA2RAkoIISycY4wP9hHuZC85YdF7cvQGA91HjCH1yCH2rl6uOk612TsZSLivISkHL7D/rzOq45iNXWAgAZP+Q84vv5K73PrP442w5rbmdf1d6VDXh3kb/17GF9oKPMJlGZ8QJiQFlBBCWDhN0/DoF0VpWj4FO9JVx7mm0JgmxHRKYO03cynMzVEdp9rCG/vQqEMQ6388Su75ItVxzMbj1ltxTUgg9cWXKLtg2Vc+a4o1tzUf0jaSHclZ7D2dDZoGjW+D/T9DueXOlRPCmkgBJYQQVsAh3B2npr7k/JmEsdSy9zJ0vm84xvJy1n37heooJtFhYD3sHWvhUr7JL0NZGWdfeUV1HCX0Oj1PtXqK3Rm7WZ5sXVfiujfyJ9jD8f9bmje5HQrOwQnrHzUghCWQAkoIIayER+9IyvNKybXw5WQunl50vHsoe1b8wZnDB1XHqTYHJwNdBjfg1P7zHNiQqjqO2Rj8/Ah4/nlylvxOztKlquMo0SaoDR1COvDe9vcorShVHafSDHod97YJ5+edZ8gqKIGgWPCOlmV8QpiIFFBCCGElDD5OuLYJInf1KcrzSlTHuaZmPXoTEF2X5Z/PpKLcsq+YVUZkU18atg1k/Q9HybtQe5byuffri1vPnqS99DJlmZmq4yjxRIsnSM5JZuGRhaqjVMmgVuFUGI18vy3l72V8t8OBX6HMsv/tEMIaSAElhBBWxK1bOAA5K5IVJ7k2nU5PtxEPk3HyBDv/XKI6jkl0uLMeBnsdq78+VKuW8gW+9CLodKS9/HKt+b7/WwPvBtwcfTMzd86koLRAdZxK83NzoE+TIL7bmnzxvDW5A4qy4dhK1dGEsHpSQAkhhBXRu9jhlhBG/uY0SjMs+8VcUN0GNOvWi/XzvyQ/y/obETi62NFlcENO7j3Hoc3WNR+oOgze3gS++CK5y5aTs3ix6jhKPBL3CDklOczbP091lCoZGB/KsYx8dqVkQ0AM+DWUZXxCmIAUUEIIYWXcOgSjd7MnZ2mS6ijX1fGe+9EbDKz5arbqKCYR1cyX+q0D+GvBEfKzi1XHMRv3Xj1x79uXs1OmUpaRoTqO2YW4hnBPw3uYs3cO54vOq45TaR3q+hLo7sgPiacuHmh8Oxz8DUprz3BoIWqCFFBCCGFlNDs97j0jKNx3juKTlt0q3MnVjU6Dh3Fg3SpO7d+jOo5JdLqrPjq9xppvas9SPoCA558DvZ60ya/Uqu/7H6OajkKn6fh096eqo1SaXqcxoEUIv+5Kpbis/GI3vpI8OLJMdTQhrJoUUEIIYYWc4/yxC3K5OFzXwl/MNrmpO0H1G7Li848oL7P+OTSOrnbcdE8DTuzK5GiiZc/lMiWDlxeBLzxP7rJl5P7xh+o4Zufp6MmIpiOYf2g+p3JPqY5TaXe0CCW7sJQVB9LBtx4ENpVlfEJUkxRQQghhhTSdhkffKEpO5lC075zqONek6XR0HzGG86dT2P77L6rjmESdFv7UaeHH2u8OU5hbe7qaufXqhVuPHqRNfoWy89azlM1UBjcajLeDNx/s+EB1lEqr6+9K8zBPfkxMuXig8e1waCkU56kNJoQVkwJKCCGslGM9Lxzqe5G9NAljeYXqONfkHxlNbO9+bPz+G3LP2UY77M53N8BoNLJu/mHVUcxG0zQCX3wByss5O2Wq6jhm52RwYkzsGH4/8Tv7zu1THafSBrYIYfXhDDJyiy8u4ysrhMO1c7aXEKYgBZQQQlgxjz5RlJ0rJH+L5XeF63DXfdg7ObH6i89URzEJZ3d7Ot1VnyPb0jm+s/Y0VjD4+hLw3CRyliwhd/ly1XHM7ta6txLtEc30xOmqo1TaLc2D0WsaP+88DV6REBIPe2UZnxA3SgooIYSwYvZBLji3CCBneTIVRZa9v8jB2YWb7hvO4c3rSdq1XXUck6jfOoCIpj6s+fYQRfmlquOYjfvNN+PapQupL79MeVaW6jhmZdAZeLzF42xK3cSGMxtUx6kUT2d7usf488M/y/ia3AFHl12cCyWEqDIpoIQQwsq594ygoric3DUpqqNcV8OOXQiLacrKOR9TVmr9BYemaXS5twFlxeWs//Go6jhmo2kagS+/hLGomLOvva46jtklhCUQ5x/H9MTpFt/E5R93tAjlYFou+85kQ8xtUF4CB21jyLUQ5iYFlBBCWDmDhwNuHUPI++s05RY+m0jTNLqNeJjs9LNs++VH1XFMwtXLkQ4D63FwQyrJFt7Qw5TsAgIIePZZshctIm/tWtVxzErTNB6Le4wD5w+wMnml6jiV0rm+H76u9vyYeBo8QiCsDRysnYORhaguKaCEEMIGuHUJRbPXkb3spOoo1+UTGk58v9vYvHAB2elnVccxiUYdgght6MWqrw9SYuFLKU3J4/YBuHTsSOrzL1Cem6s6jlm1CmxFm6A2zNg1gwqjZTdxAbDT67g1NoSfd56mtLwCGvSBYytlqK4QN0AKKCGEsAE6RwPuXcMpSDxLaVq+6jjX1faOu3F0d2fVF9YzlPRaNE0j4b6GFOWVsnHhMdVxzEbTNIImv0xFXh7pb76lOo7ZPRr7KEcuHGHZSesYTDswPpRz+SWsPpQBDfpBaQGcqF1XD4UwBSmghBDCRri0CcLg7UjWkhOqo1yXvaMTCUNHcmzbZo4lblEdxyTcfZ1oN6AOe9ec5vThC6rjmI1dcDB+T44na8EC8rfYxrmsrFj/WDqEdGDmzpmUV5SrjnNdjYLciQlyvzgTyrceeNeBg7+pjiWE1ZECSgghbIRm0OHeO4riwxcoOmL5L+DrtelARLM4Vs39hNISy967VVlNbwolqI4Hq748SFmJ5b+gNhWvu+/GKT6etOdfoKKoSHUcs3qk+SMczz7O0iTrmKt0R3woKw6e5UJB6cVlfIeXQoXlL0EUwpJIASWEEDbEqYkP9uFuZP9+AmOFZXcH0zSNrg88RO65c2z9+QfVcUxC02kkDGlI7oUitiy2/CuBpqLpdAS9MpnSM2fInDFTdRyzaurXlJtCb+LjXR9TVmH5+99ujQ3GaIRfd5+BBn0h7yyc2aE6lhBWRQooIYSwIZqm4dE3itIz+RTssvzhrt7BobTqfztbfv6BrLRU1XFMwivQhVb9oti5LJn0kzmq45iNQ3Q0vmMe5tzs2RTt3686jlmNiR1DUk4Svx23/OVwvq4OdGngd3EmVFgbcPKCQ9LOXIiqkAJKCCFsjEOkB46Nfcj5IwljqeUvzWlz2104e3iycu4nVjNT53rieobjE+rKynkHKS+3/HNgKj4jRuBQpw6pzz2Psczyr8aYSoxPDN3Cu/Hxro8prbD8+WYD40PZnZLNkcxCqN9bCighqkgKKCGEsEEevSMpzykmb+MZ1VGuy87RkYRhD3JixzaObdusOo5J6PU6ug5pxPnUfHb8kaw6jtlo9vYETZ1C0cGDnP/iC9VxzOrh5g+TkpfCL0d/UR3luhIa+uPpbMdPO05f3AeVvh/O154lp0JUlxRQQghhg+z8nHFpHUTOylNUFFj+O+J1W7YlKjaeVV98SmmxbTQh8At3I65HOFuXnOB8quW3ljcVp6ZN8R46lIz3P6DkpOXPJTOVBt4N6BnRk092f0JpuWX/zTkY9PSKCeT3PakYoxNAb3+xmYQQolKkgBJCCBvl3i0cKozkrDylOsp1aZpGwgMPkZ91gc0Lv1cdx2Ra9YvE3ceJVV8eoMLCm3qYkt/YxzD4+ZH6wos2syyzMsbEjiEtP42FRxeqjnJdfZsFkXSugAPngajOsoxPiCqQAkoIIWyU3s0et5tCydt4hrLzln9VxyswmFb9B7Lt1x85f+a06jgmYbDXk3BfQ9KO57BndYrqOGajc3YmaPLLFGzeTNYPttFhsTLqeNahT1QfPtn9CcXllt2av30dHzyc7FiyJ/ViN76k9VBo+eMPhLAEUkAJIYQNc+0Ugs7Zjuw/k1RHqZTWtw3E1duHlXM+tpkrF8H1PGlyUwibFh0jJ7NQdRyzcWnfHo8BA0h/401K09NVxzGb0c1Hk1mYyQ+HLbtwtNPr6BETwJI9qRjr9wJjORxZrjqWEFZBCighhLBhOns9Hj0iKNyZQUlKruo412Vn70DCsAc5uXsHR7dsVB3HZNrdVgdHFztWf33QZgrDygh45mk0e3vOvjpNdRSzifKIol9UP2bvnW3xe6H6Ng3keGY+hws9IChWlvEJUUlSQAkhhI1zjg/A4O9M9pITVvHivU58G6JbtGLVvM8oLbL8pYeVYe9koMvghpw6cIFDm9JUxzEbvacnAc8+S+7SpeSuXq06jtmMbDqSjIIMfj3+q+oo19Shri9ujgZ++2cZ39HlUFaiOpYQFk8KKCGEsHGaXsOjTyTFx7MpOmQdexwShj1EQXYWmxctUB3FZCKa+FC/dQB/fX+Egpza8yLV/eZ+uHTowNnJr1BRUKA6jllEe0bTLbwbn+/5nPKKctVxrsrBoKdHowB+35N6sZ15cQ6c/Et1LCEsnhRQQghRCzg29MY+yoPs309gtIJucJ4BgbS+dSBbf/nJZhpKAHS8sx6aprFuwWHVUcxG0zQCX3yBsnPnyPhwhuo4ZjOy6UiSc5P58+SfqqNcU5+mQRxJz+OIFgkeYXDod9WRhLB4UkAJIUQtoGkann2jKDtbQEHiWdVxKqXVrQNx87GthhJObvZ0vKseR7elc2J3puo4ZmMfHo7vmDGc/+ILig4cUB3HLBr7NqZ9cHs+2/OZRf/+dqrni6uDgd/3nb14FerQ72DBeYWwBFJACSFELWEf5oZTcz+yl52kosRylxX9w1YbStRvHUB4Yx/WfnuIksIy1XHMxmf4AzhER1+cDVVu+b9/pjCq6SiOXDjC2pS1qqNclaOdnm6N/P9uZ94Hsk/B2b2qYwlh0aSAEkKIWsSjZwQV+aXkrbeOZXGXGkp8YTsNJTRN46Z761NUUMbGRcdUxzEbzc6OwJdfpmjPHi58+53qOGYRHxBPnH8cn+751KKvQvVpEsTBtFyOucSCgzsclG58QlyLFFBCCFGLGHyccG0bRO7qFMrzrKORQcKwhyjIsa2GEu4+TrS7LZq9a06TejRLdRyzcW4Rh+fdg8h4911Kz1rHUtLq0DSNkU1HsjtjN9vOblMd56q6NPDD2V7P0gPnoW53aWcuxHVIASWEELWMW9dwAHJXnlKcpHIuNpS40+YaSjS5KZSAKHdWfXWQstLasaQNwH/8eDRnJ85Omao6ill0CulEA68GfLr7U9VRrsrRTk/Xhv78tvvvduapOyHbdv7WhDA1KaCEEKKW0bvY4ZYQRt6mVMoyC1XHqZRWt95hcw0ldDqNhCENyc4oJPH3k6rjmI3e3Z3A//yH3GXLyF25UnWcGqdpGiObjWRT6ib2ZOxRHeeq+jYNYn9qDsne7UHTwRHL7h4ohEpSQAkhRC3k1iEYvZsd2X8mqY5SKRcbSjzEyd07OLJlg+o4JuMT7Ep87wi2Lz3JudN5quOYjVvv3rh07kTaK1OoyM9XHafG9QjvQaR7JLP2zFId5aq6NPDD0U7Hb0eLIKQlHF+lOpIQFksKKCGEqIU0Oz3uPSIp3J1JcXKO6jiVUie+NdEtWrH6i1mUFttGQwmA+N6ReAQ4s+qrg1RYwYwuU9A0jcAXXqT8wgUyZs5UHafG6XV6hjcZzspTKzl64ajqOFfkbG+ga0N/ft+bCnUS4PgasOAhwEKoJAWUEELUUs4t/LELdL44XNdKlsVdaiix8HvVUUxGb6ej65CGnE3KYe+aFNVxzMY+NATf0aM5/8U8ig7b/mDhm6NvJtAlkM/3fq46ylX1aRLE7pRszvq1h6IsOLNTdSQhLJIUUEIIUUtpOg33PlGUnMih6MB51XEqxTMgkFb9B7Lt1x+5kGo7m9wDoz1o0jmETYuOk3vedq6uXY/38AewDwsjbfJkqynib5Sd3o5hjYfx+4nfOZVrmQ1cEhr642DQ8UtmINi7wTHb36MmxI2QAkoIIWoxx/peONTxIHvpCYzl1vECtvVtA3Hx8mHVXMuerVNVbW+rg72jnrXfHbap7+tadPb2BL7wPIXbEsn++WfVcWrc7fVux8PBgy/2faE6yhW5Ohi4qb4fv+07B1GdZR+UEFchBZQQQtRimqbh0SeKsvRC8hPTVMepFDt7BxLuH8WJnYkc27ZZdRyTcXAy0PmeBiTtzuTY9gzVcczGpV073Pv2Jf2NNynPzlYdp0Y5GZwY1GAQvxz7hexiy/xe+zULYuepLLKCO8KpzVCcqzqSEBZHCighhKjl7EPdcIr1I2dZMhUl1rFpvE7LNkTGxrPqi88oLSlWHcdkomP9iI71Y938wxTll6qOYzb+zzyDsbiY9OnTVUepcXc1uIvyinJ+OPyD6ihX1LWhP3Z6jRXFMVBRBknrVUcSwuJIASWEEAKPnpFUFJSSt8469hVpmkbXYQ+Sf+EcWxZZ5gvRG9VpUH3KSsrZuOiY6ihmYxfgj9/jY8n6bj6Fe/aqjlOjfJ18ubnOzXxz4BtKyy2vSHZztKN1lDe/pjiBZ7jsgxLiCqSAEkIIgcHbEdd2weSuSaE8r0R1nErxCgqh5S23s/WXH8hKS1Udx2RcvRxoN6AO+9ed4cyRC6rjmI3Xvffi0KABaS+/jLHcOq6E3qghjYaQXpjOHyf/UB3lihIa+LPx+HnKIrtIASXEFUgBJYQQAgC3hDDQQc6KZNVRKq3NbXfh7O7Jqi8+VR3FpBp3CiEw2oNVXx2ivLRCdRyz0AwGAl98gaK9e8lasEB1nBpV16suHYI7MG/fPItsGNKlgT/FZRUccGkJ545AlmV2DRRCFSmghBBCAKB3scOtSxj5m9MozSxUHadS7Bwd6XL/SI5v38qxxC2q45iMptNIuK8hOZmFbFuapDqO2TjHxeF550DS33mXssxM1XFq1NCYoRw4f4BtZ7epjvIvdfxcCPN24tfseqDppBufEP9DCighhBCXuHUIRu9mR84fSaqjVFq91u2JaBbHqi8+pazEOpYfVoZ3sAstekewfelJzp3JUx3HbPzGj0fT60l/803VUWpUu+B21PWsy7z981RH+RdN00ho4M+SY0UYg+PgmBRQQvw3KaCEEEJcotnpce8RSeGeTIqTc1THqRRN0+j6wEPkZmay9dcfVccxqZa9I3H3dWLN14cwVljeUq+aYPDywu/J8WT//AsF27erjlNjNE1jSMwQ1pxaQ1J2kuo4/5LQ0J+UC4VcCOx48QpUhW3vSxOiKqSAEkIIcRnnFv7YBTqT/fsJi9yfcSXewaHE97uVLQu/Jzv9rOo4JqO305FwXwNSj2Wzf/0Z1XHMxvOOO3Bs0oS0V6bYdEOJftH98HL04qsDX6mO8i/ton1wMOhYX9EUCi9A6i7VkYSwGFJACSGEuIym03DvE0XJiRyKDpxXHafS2t4+CEdXV9Z8+bnqKCYVXM+LRu2D2LjwGPnZtjPz6lo0nY7A55+j+MABsr7/XnWcGuOgd+DuBndb5GBdRzs97ev4sOBsINi7yj4oIf6LkgJqwIABeHl5MXDgwMuOL168mAYNGlCvXj1mzZqlIpoQQgjAsb4XDnU8yF6ahLHcOq5C2Ts503nICI5s2UDSLtta+tX+jrro9Brrvz+iOorZODVvjseAAWS8O52yC7bbzv2fwbrfH7a8QjGhoT8bk3IpC+8g+6CE+C9KCqixY8cyb97lmybLysoYP348K1euZPv27bz++uucP28973wKIYQt0TQNjz5RlKUXUJBoPUviGrbvTGijJqyc+ynlZZY3pPRGObrY0WFgPY5sS+fkvnOq45iN/5PjMZaXk/H++6qj1BgfJx9uqXML3x741uIG6yY08Keswshh15aQvAlK8lVHEsIiKCmgEhIScHNzu+zYli1baNy4MSEhIbi5udG3b1/++MMyB8wJIURtYB/qhlNzP7KXn6SixDr2ofzTUCIr7Qzbl/yiOo5J1W8dQGhDL9Z+e4hSKzkf1WXw9cX30UfImr+AogMHVMepMfc1uo/0wnSWJi1VHeUyYd7O1PV35bf8GKgohaT1qiMJYRGqXECtXbuWW265heDgYDRNY9GiRf+6z8yZM4mKisLR0ZH4+HjWrVt33cc9c+YMISEhlz4PDQ3l9OnTVY0nhBDChDx6RVKRX0reX9bz77FfRBSxvfqx8cfvyD1vO7OENE3jpnsbkJ9dwrbfTqiOYzbegwdjHx1F2pSpVtPUpKrqetWlQ0gHvtz/pcV9jwkN/Pj+hANG91A4tlJ1HCEsQpULqPz8fJo3b86HH354xdvnz5/PuHHjmDRpEjt27KBTp0706dOH5ORrT7a/0j8YmqZVNZ4QQggTMng74to2iNw1KZTnWc+MpfZ3DsZgb8/ar+aojmJSnv7OtOwbyY5lp8hMqR2zoTQ7OwInTaIwMZGcxYtVx6kxljpYN6GBP+l5JWQFdZRGEkL8zVDVL+jTpw99+vS56u3vvPMOI0aMYOTIkQBMnz6dP/74g48++ohp06Zd9etCQkIuu+KUkpJCmzZtrnr/4uJiiov/vxtRdvbF7jU5OdYxt0QIIayFsaUnuRuOU754P559o1XHqbQWt97JitkfEdW2I6ENG6uOYzJ12niya52RJZ9vo//jceh0teDNxsaNoUsXjr86jcj4luhdXVQnMrnGLo0JMYTw5fYvadCxgeo4l9T3NuBEMSuL6tMj5Vs4dRA8glXHEuK6/qkJauSqrrEaAOPChQsvfV5cXGzU6/XGn3766bL7jR071ti5c+fLjq1atcp4xx13XPq8tLTUWLduXWNKSooxJyfHWLduXWNmZuZVn/vFF180AvIhH/IhH/IhH/IhH/IhH/IhH1f8OHbsWHXKnSuq8hWoa8nMzKS8vJyAgIDLjgcEBJCWlnbp8169erF9+3by8/MJDQ1l4cKFtGrVirfffpuEhAQqKip4+umn8fHxuepzTZw4kfHjx1/6PCsri4iICJKTk/Hw8DDlt3VNrVq1YuvWrWZ/nMrc/3r3udrtVTn+38dycnIICwvj1KlTuLu7V+bbMAlTnIOa+PlX5n5yDm78MUxxDm7ktv89/r+fyzmo2v2qeltljsk5qNp95BxU7zHkHFzO1s6Btf1/fLVsNf0YlngOsrOzCQ8Px9vbuzLfQpWYtID6x//uXTIajZcdu1p3vf79+9O/f/9KPYeDgwMODg7/Ou7h4WHWX1S9Xm+S56vq41Tm/te7z9Vur8rxKx1zd3e3unNQEz//ytxPzsGNP4YpzsGN3Pa/x692PzkHlbtfVW+r7DGQc1DZ+8g5qN5jyDm4nK2dA2v7//hqOWr6MSz5HOh0pm86btJH9PX1Ra/XX3a1CSA9Pf1fV6VsxSOPPKLkcSpz/+vd52q3V+W4qb7/6jBFhpr4+VfmfnIObvwxTHEObuS2/z1uCT9/qD3nwFL/BsByz8GN/jt0tdvkHFT9/nIOavYx5DXR5eQc1DzNaLzxnVWaprFw4UJuu+22S8fatGlDfHw8M2fOvHQsJiaGW2+99ZpNJKorJycHDw8PsrOzzV7pi4vkHKgn50A9OQfqyTlQT86BenIO1JKfv3o1eQ6qvIQvLy+Po0ePXvr8xIkT7Ny5E29vb8LDwxk/fjxDhgyhZcuWtGvXjk8//ZTk5GRGjx5t0uD/y8HBgRdffPGKy/qEecg5UE/OgXpyDtSTc6CenAP15ByoJT9/9WryHFT5CtTq1atJSEj41/H777+fuXPnAhcH6b7xxhukpqbSpEkT3n33XTp37mySwEIIIYQQQgihSrWW8AkhhBBCCCFEbWL6thRCCCGEEEIIYaOkgBJCCCGEEEKISpICSgghhBBCCCEqqdYUUIsXL6ZBgwbUq1ePWbNmqY5TKw0YMAAvLy8GDhyoOkqtdOrUKbp06UJMTAzNmjXj+++/Vx2pVsnNzaVVq1bExsbStGlTPvvsM9WRaq2CggIiIiKYMGGC6ii1ksFgIDY2ltjYWEaOHKk6Tq104sQJEhISiImJoWnTpuTn56uOVKscOnTo0t9AbGwsTk5OLFq0SHWsWufdd9+lcePGxMTEMHbsWKrSFqJWNJEoKysjJiaGVatW4e7uTosWLdi8eTPe3t6qo9Uqq1atIi8vjy+++IIffvhBdZxaJzU1lbNnzxIbG0t6ejotWrTg0KFDuLi4qI5WK5SXl1NcXIyzszMFBQU0adKErVu34uPjozparTNp0iSOHDlCeHg4b731luo4tY6vry+ZmZmqY9RqN910E1OmTKFTp06cP38ed3d3DIYqT7YRJpCXl0dkZCQnT56U/4/NKCMjg7Zt27Jv3z7s7Ozo3Lkzb731Fu3atavU19eKK1BbtmyhcePGhISE4ObmRt++ffnjjz9Ux6p1EhIScHNzUx2j1goKCiI2NhYAf39/vL29OX/+vNpQtYher8fZ2RmAoqIiysvLq/RulzCNI0eOcPDgQfr27as6ihBK/POCsVOnTgB4e3tL8aTQL7/8Qrdu3aR4UqCsrIyioiJKS0spLS3F39+/0l9rFQXU2rVrueWWWwgODkbTtCte5pw5cyZRUVE4OjoSHx/PunXrLt125swZQkJCLn0eGhrK6dOnzRHdZlT3HIjqM+U52LZtGxUVFYSFhdVwatthip9/VlYWzZs3JzQ0lKeffhpfX18zpbcNpjgHEyZMYNq0aWZKbHtMcQ5ycnKIj4+nY8eOrFmzxkzJbUd1z8GRI0dwdXWlf//+tGjRgldffdWM6W2DKf8/XrBgAYMGDarhxLanuufAz8+PCRMmEB4eTnBwMN27d6dOnTqVfn6rKKDy8/Np3rw5H3744RVvnz9/PuPGjWPSpEns2LGDTp060adPH5KTkwGu+C6vpmk1mtnWVPcciOoz1Tk4d+4cQ4cO5dNPPzVHbJthip+/p6cnu3bt4sSJE3zzzTecPXvWXPFtQnXPwc8//0z9+vWpX7++OWPbFFP8HSQlJZGYmMjHH3/M0KFDycnJMVd8m1Ddc1BaWsq6deuYMWMGGzduZNmyZSxbtsyc34LVM9X/xzk5Oaxfv16uiN+A6p6DCxcusHjxYpKSkjh9+jQbNmxg7dq1lQ9gtDKAceHChZcda926tXH06NGXHWvYsKHx2WefNRqNRuP69euNt91226Xbxo4da/z6669rPKutupFz8I9Vq1YZ77jjjpqOaPNu9BwUFRUZO3XqZJw3b545Ytqs6vwN/GP06NHGBQsW1FREm3cj5+DZZ581hoaGGiMiIow+Pj5Gd3d348svv2yuyDbHFH8HvXv3Nm7durWmItq8GzkHGzZsMPbq1evSbW+88YbxjTfeqPGstqo6fwfz5s0zDh48uKYj2rwbOQcLFiwwjhkz5tJtb7zxhvH111+v9HNaxRWoaykpKSExMZGePXtedrxnz55s2LABgNatW7N3715Onz5Nbm4uS5YsoVevXiri2qTKnANRsypzDoxGI8OGDaNr164MGTJERUybVZmf/9mzZy+9056Tk8PatWtp0KCB2bPaqsqcg2nTpnHq1CmSkpJ46623GDVqFC+88IKKuDapMufgwoULFBcXA5CSksL+/fuJjo42e1ZbVZlz0KpVK86ePcuFCxeoqKhg7dq1NGrUSEVcm1SV10SyfK9mVOYchIWFsWHDhkt7klevXl2l/5OtftdgZmYm5eXlBAQEXHY8ICCAtLQ04GLL1LfffpuEhAQqKip4+umnpfOVCVXmHAD06tWL7du3k5+fT2hoKAsXLqRVq1bmjmuTKnMO1q9fz/z582nWrNmltcJffvklTZs2NXdcm1OZn39KSgojRozAaDRiNBp59NFHadasmYq4Nqmy/w6JmlOZc3DgwAEeeughdDodmqbx3nvvSUdcE6rsa6JXX32Vzp07YzQa6dmzJzfffLOKuDapsv8WZWdns2XLFn788UdzR7R5lTkHbdu2pW/fvsTFxaHT6ejWrRv9+/ev9HNYfQH1j//d02Q0Gi871r9//yr9YETVXe8cSOfDmnetc9CxY0cqKipUxKo1rvXzj4+PZ+fOnQpS1S7X+3foH8OGDTNTotrnWuegffv27NmzR0WsWuV6fwd9+vShT58+5o5Vq1zvHHh4eMg+2Bp2vXMwdepUpk6dekOPbfVL+Hx9fdHr9f96hzE9Pf1flaeoGXIO1JNzoJb8/NWTc6CenAP15ByoJ+dAPXOcA6svoOzt7YmPj/9XB5lly5bRvn17RalqFzkH6sk5UEt+/urJOVBPzoF6cg7Uk3OgnjnOgVUs4cvLy+Po0aOXPj9x4gQ7d+7E29ub8PBwxo8fz5AhQ2jZsiXt2rXj008/JTk5mdGjRytMbVvkHKgn50At+fmrJ+dAPTkH6sk5UE/OgXrKz0GV+gQqsmrVKiPwr4/777//0n1mzJhhjIiIMNrb2xtbtGhhXLNmjbrANkjOgXpyDtSSn796cg7Uk3OgnpwD9eQcqKf6HGhG4xWmzAohhBBCCCGE+Ber3wMlhBBCCCGEEOYiBZQQQgghhBBCVJIUUEIIIYQQQghRSVJACSGEEEIIIUQlSQElhBBCCCGEEJUkBZQQQgghhBBCVJIUUEIIIYQQQghRSVJACSGEEEIIIUQlSQElhBBCCCGEEJUkBZQQQgghhBBCVJIUUEIIIYQQQghRSVJACSGEEEIIIUQlSQElhBBCCCGEEJX0f8jTmN2dSzP7AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 9))\n", + "\n", + "for idx, key in enumerate(solutions):\n", + " label = (u.Quantity(key).to(\"s\"))*c.cgs\n", + " y = solutions[key]*R_x[idx]**2\n", + " print(y)\n", + " \n", + "\n", + " ax.loglog(\n", + " cc_solver_time.gamma,\n", + " y,\n", + " lw=1,\n", + " label=label,\n", + " )\n", + "\n", + "plt.legend(fontsize=6)\n", + "ax.set_xlim(1, 1e8)\n", + "ax.set_ylim(1e10, 1e46)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "841bd360", + "metadata": {}, + "outputs": [], + "source": [ + "N_e_tg_list = []\n", + "\n", + "for idx, key in enumerate(solutions):\n", + " values = solutions[key] * (R_x[idx]**2)\n", + " N_e_tg_list.append(values)\n", + "\n", + "N_e_tg = u.Quantity(N_e_tg_list)" + ] + }, + { + "cell_type": "markdown", + "id": "64509659", + "metadata": {}, + "source": [ + "# Spatial Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "5962229b", + "metadata": {}, + "outputs": [], + "source": [ + "x = np.logspace(np.log10(1), np.log10(1e21), 100) * u.cm" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "f9b6d51c", + "metadata": {}, + "outputs": [], + "source": [ + "def gamma_loss(gamma):\n", + " B = 0.363 * u.G\n", + " u_B = ((B_to_cgs(B)**2)/(8*np.pi)).to('erg cm-3')\n", + " prefactor = (4 * c.cgs * sigma_T.cgs) / (3 * m_e.cgs * c.cgs * c.cgs )\n", + " value = prefactor * (u_B) * np.power(gamma, 2)\n", + " return -value.to(\"s-1\")\n", + "\n", + "class ChangCooperSolver:\n", + " def __init__(\n", + " self,\n", + " gamma_min,\n", + " gamma_max,\n", + " n_gamma,\n", + " x,\n", + " n_e\n", + "\n", + " ):\n", + " \"\"\"class implementing the Chang and Cooper scheme in Chaiberge and Ghisellini (1998):\n", + "\n", + " Parameters\n", + " ----------\n", + " gamma_min : float\n", + " minimum Lorentz factor of the electorn distribution\n", + " gamma_max : float\n", + " maximum Lorentz factor of the electron distribution\n", + " n_gamma : int\n", + " number of steps in the Lorentz factor grid\n", + " t_max_ev : `~astropy.Units.Quantity`\n", + " maximum time of the evolution\n", + " n_t : int\n", + " number of time steps\n", + " t_max_inj : `~astropy.Units.Quantity`\n", + " maximum time of injection\n", + " t_esc : `~astropy.Units.Quantity`\n", + " escape time\n", + " injection_dict : dict\n", + " dictionary with injection specifications (spectrum and maximum injection time)\n", + " \"\"\"\n", + " self.gamma_min = gamma_min\n", + " self.gamma_max = gamma_max\n", + " self.n_gamma = n_gamma\n", + " self.n_e = n_e\n", + " _gamma = np.logspace(np.log10(gamma_min), np.log10(gamma_max), n_gamma)\n", + " # $\\gamma_{i \\pm 1/2}$ in Chiaberge et al. (1998)\n", + " self.gamma_midpts = _gamma[::2]\n", + " # $\\delta gamma_i$ in Chiaberge et al. (1998)\n", + " self.delta_gamma = self.gamma_midpts[:-1] - self.gamma_midpts[1:]\n", + " # $\\gamma_i$ in Chiaberge et al. (1998)\n", + " self.gamma = _gamma[1:-1:2]\n", + " self.x = x.to('cm')\n", + " self.t = x/c.cgs\n", + "\n", + " @property\n", + " def gamma_dot_midpts(self):\n", + " return gamma_loss(self.gamma_midpts)\n", + "\n", + " def run(self):\n", + " \"\"\"solve the temporal evolution, return the result at each step\"\"\"\n", + " print(\"solving Chang and Cooper equation iteratively!\")\n", + " solutions = dict()\n", + " N_prev = self.n_e(self.gamma) \n", + " for i in range(len(self.t)-1):\n", + " elapsed_time = self.t[i]\n", + " dt = (self.t[i+1] - self.t[i]).to('s')\n", + " loss_term = (dt * self.gamma_dot_midpts[:-1]).decompose().value / self.delta_gamma\n", + " V2 = 1 + loss_term\n", + " V3 = -(dt * self.gamma_dot_midpts[1:]).decompose().value / self.delta_gamma\n", + " cc_matrix = diags([V2, V3], offsets=[0, 1]).toarray()\n", + " N_next = np.linalg.solve(cc_matrix, N_prev) \n", + " solutions[f\"{elapsed_time}\"] = N_next * u.Unit(\"cm-3\")\n", + " N_prev = N_next\n", + " return solutions" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "5bd0f838", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "solving Chang and Cooper equation iteratively!\n" + ] + } + ], + "source": [ + "cc_solver = ChangCooperSolver(\n", + " gamma_min=1,\n", + " gamma_max=1e7,\n", + " n_gamma=200,\n", + " x = x ,\n", + " n_e = n_e_c\n", + ")\n", + "solutions = cc_solver.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "50920ea2", + "metadata": {}, + "outputs": [], + "source": [ + "distances = []\n", + "for idx, key in enumerate(solutions.keys()):\n", + " t = u.Quantity(key)\n", + " d = c.cgs * t\n", + " distances.append(d.value)\n", + "distances = np.array(distances) * u.cm\n", + "R_x = 7.32 * 1e15 * u.cm+ distances * np.tan(9.7 * u.deg)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "650d5bbf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.32 \\times 10^{15},~7.3200001 \\times 10^{15},~7.3200001 \\times 10^{15},~7.3200001 \\times 10^{15},~7.3200002 \\times 10^{15},~7.3200004 \\times 10^{15},~7.3200006 \\times 10^{15},~7.320001 \\times 10^{15},~7.3200016 \\times 10^{15},~7.3200026 \\times 10^{15},~7.3200042 \\times 10^{15},~7.3200069 \\times 10^{15},~7.3200112 \\times 10^{15},~7.3200183 \\times 10^{15},~7.3200299 \\times 10^{15},~7.3200487 \\times 10^{15},~7.3200793 \\times 10^{15},~7.3201293 \\times 10^{15},~7.3202107 \\times 10^{15},~7.3203434 \\times 10^{15},~7.3205597 \\times 10^{15},~7.3209122 \\times 10^{15},~7.3214867 \\times 10^{15},~7.3224229 \\times 10^{15},~7.3239488 \\times 10^{15},~7.3264355 \\times 10^{15},~7.3304883 \\times 10^{15},~7.3370933 \\times 10^{15},~7.3478578 \\times 10^{15},~7.3654013 \\times 10^{15},~7.3939929 \\times 10^{15},~7.4405899 \\times 10^{15},~7.5165316 \\times 10^{15},~7.6402975 \\times 10^{15},~7.8420051 \\times 10^{15},~8.1707382 \\times 10^{15},~8.7064913 \\times 10^{15},~9.5796354 \\times 10^{15},~1.1002643 \\times 10^{16},~1.332179 \\times 10^{16},~1.7101422 \\times 10^{16},~2.3261281 \\times 10^{16},~3.3300316 \\times 10^{16},~4.9661442 \\times 10^{16},~7.6326 \\times 10^{16},~1.1978259 \\times 10^{17},~1.9060599 \\times 10^{17},~3.060305 \\times 10^{17},~4.9414369 \\times 10^{17},~8.0072131 \\times 10^{17},~1.3003664 \\times 10^{18},~2.1146635 \\times 10^{18},~3.4417649 \\times 10^{18},~5.6046094 \\times 10^{18},~9.1295071 \\times 10^{18},~1.4874212 \\times 10^{19},~2.423665 \\times 10^{19},~3.949509 \\times 10^{19},~6.4362546 \\times 10^{19},~1.048903 \\times 10^{20}] \\; \\mathrm{cm}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "R_x" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "637b5dbf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999999999999 cm\n", + "1.6297508346206442 cm\n", + "2.6560877829466865 cm\n", + "4.328761281083058 cm\n", + "7.054802310718643 cm\n", + "11.497569953977356 cm\n", + "18.73817422860384 cm\n", + "30.538555088334157 cm\n", + "49.770235643321115 cm\n", + "81.11308307896873 cm\n", + "132.19411484660287 cm\n", + "215.44346900318845 cm\n", + "351.1191734215131 cm\n", + "572.236765935022 cm\n", + "932.60334688322 cm\n", + "1519.9110829529347 cm\n", + "2477.0763559917114 cm\n", + "4037.017258596554 cm\n", + "6579.332246575683 cm\n", + "10722.672220103232 cm\n", + "17475.28400007683 cm\n", + "28480.35868435805 cm\n", + "46415.88833612782 cm\n", + "75646.3327554629 cm\n", + "123284.67394420657 cm\n", + "200923.3002565046 cm\n", + "327454.9162877732 cm\n", + "533669.9231206313 cm\n", + "869749.0026177834 cm\n", + "1417474.1629268047 cm\n", + "2310129.7000831626 cm\n", + "3764935.806792471 cm\n", + "6135907.273413176 cm\n", + "10000000.0 cm\n", + "16297508.346206432 cm\n", + "26560877.829466894 cm\n", + "43287612.810830615 cm\n", + "70548023.10718645 cm\n", + "114975699.53977357 cm\n", + "187381742.2860387 cm\n", + "305385550.88334125 cm\n", + "497702356.4332114 cm\n", + "811130830.789689 cm\n", + "1321941148.4660287 cm\n", + "2154434690.0318866 cm\n", + "3511191734.2151275 cm\n", + "5722367659.35022 cm\n", + "9326033468.832218 cm\n", + "15199110829.52933 cm\n", + "24770763559.91714 cm\n", + "40370172585.9655 cm\n", + "65793322465.75682 cm\n", + "107226722201.03253 cm\n", + "174752840000.7683 cm\n", + "284803586843.5805 cm\n", + "464158883361.2792 cm\n", + "756463327554.629 cm\n", + "1232846739442.0684 cm\n", + "2009233002565.0461 cm\n", + "3274549162877.732 cm\n", + "5336699231206.323 cm\n", + "8697490026177.834 cm\n", + "14174741629268.076 cm\n", + "23101297000831.582 cm\n", + "37649358067924.71 cm\n", + "61359072734131.88 cm\n", + "100000000000000.0 cm\n", + "162975083462064.7 cm\n", + "265608778294668.4 cm\n", + "432876128108306.2 cm\n", + "705480231071866.0 cm\n", + "1149756995397735.8 cm\n", + "1873817422860386.8 cm\n", + "3053855508833412.5 cm\n", + "4977023564332114.0 cm\n", + "8111308307896889.0 cm\n", + "1.3219411484660288e+16 cm\n", + "2.154434690031878e+16 cm\n", + "3.5111917342151416e+16 cm\n", + "5.72236765935022e+16 cm\n", + "9.326033468832181e+16 cm\n", + "1.5199110829529395e+17 cm\n", + "2.477076355991714e+17 cm\n", + "4.03701725859655e+17 cm\n", + "6.57933224657571e+17 cm\n", + "1.0722672220103252e+18 cm\n", + "1.747528400007683e+18 cm\n", + "2.8480358684358164e+18 cm\n", + "4.641588833612792e+18 cm\n", + "7.56463327554629e+18 cm\n", + "1.2328467394420634e+19 cm\n", + "2.009233002565054e+19 cm\n", + "3.2745491628777312e+19 cm\n", + "5.336699231206302e+19 cm\n", + "8.69749002617787e+19 cm\n", + "1.4174741629268076e+20 cm\n", + "2.310129700083158e+20 cm\n", + "3.764935806792487e+20 cm\n", + "6.135907273413189e+20 cm\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 9))\n", + "\n", + "for idx, key in enumerate(solutions):\n", + " label = (u.Quantity(key).to(\"s\"))*c.cgs\n", + " y = solutions[key] * np.pi *R_x[idx]**2\n", + " print(label)\n", + " \n", + "\n", + " ax.loglog(\n", + " cc_solver.gamma,\n", + " y,\n", + " lw=1,\n", + " label=label,\n", + " )\n", + "\n", + "plt.legend(fontsize=6)\n", + "ax.set_xlim(1, 1e8)\n", + "ax.set_ylim(1, 1e46)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "c97f0bac", + "metadata": {}, + "outputs": [], + "source": [ + "N_e_tg_list = []\n", + "\n", + "for idx, key in enumerate(solutions):\n", + " values = solutions[key] * np.pi * R_x[idx]**2\n", + " N_e_tg_list.append(values)\n", + "\n", + "N_e_tg = u.Quantity(N_e_tg_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "aecd5145", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$2.9435665 \\times 10^{36} \\; \\mathrm{\\frac{1}{cm}}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.trapz(N_e_tg[0,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "f1ae7cc9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$2.9435665 \\times 10^{36} \\; \\mathrm{\\frac{1}{cm}}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.trapz(N_e_tg[10,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "1e47fec2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$2.943572 \\times 10^{36} \\; \\mathrm{\\frac{1}{cm}}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.trapz(N_e_tg[50,:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e106833", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}