From fe99e34948fe6fc51f87431006c0017dc8d1ec99 Mon Sep 17 00:00:00 2001 From: Udai Sharma Date: Wed, 18 Mar 2026 16:06:32 +0100 Subject: [PATCH 1/5] Extended Jets Implemented a conical Jet model; electron distribution is used instead of electron density to solve electron evolution equaiton. SSA implemented to modify the SED flux but not the electron evolution. --- agnpy/emission_regions/__init__.py | 1 + agnpy/emission_regions/mod.py | 280 ++++++++++ agnpy/synchrotron/sync_mod.py | 155 ++++++ electron_evolution.ipynb | 827 +++++++++++++++++++++++++++++ 4 files changed, 1263 insertions(+) create mode 100644 agnpy/emission_regions/mod.py create mode 100644 agnpy/synchrotron/sync_mod.py create mode 100644 electron_evolution.ipynb 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/mod.py b/agnpy/emission_regions/mod.py new file mode 100644 index 00000000..839c6bbb --- /dev/null +++ b/agnpy/emission_regions/mod.py @@ -0,0 +1,280 @@ +""" 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 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 ..spectra import PowerLaw +from ..utils.conversion import mec2, mpc2, B_to_cgs + + +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_OPEN : 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, + R_o =1e16 * u.cm, + L = 1e18 * u.cm, + theta = 5 * u.deg, + z=0.033, + delta_D=10, + Gamma=10, + B_o=1 * u.G, + 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.R_o = R_o.to("cm") + self.L = L.to("cm") + 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.B_o = B_to_cgs(B_o) + self._n_e : ParticleDistribution = n_e + self.xi = xi + self.gamma_e_size = gamma_e_size + self.x_size = x_size + +## 1. Jet Structure + @property + def V_c(self): + """Volume of the 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): + return self.R_o + self.x * np.tan(self.theta.value) + + #For a jet with a constant bulk Lorentz factor which conserves magnetic energy in each segment the magnetic field + # will change as a function of the radius of the jet so that the total magnetic energy is conserved in a segment. + + @property + def B_x(self): + return self.B_o * (self.R_o / self.R_x) + + @property + def x(self): + x = np.logspace( + np.log10(1e-3), # small value to avoid exactly 0, in cm + np.log10(self.L.to_value("cm")), + self.x_size) * u.cm + return x + + @property + def gamma_e(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_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.""" + return self._n_e(self.gamma_e) + + @property + def N_e_base(self): + """Number of electrons at the base in a width of 1 cm""" + return self.n_e_base * np.pi * self.R_o**2 * (1 * u.cm) + + @property + def norm_equi(self): + e_energy_initial = np.trapz(self.gamma_e * self.N_e_base, self.gamma_e) + K_dash = ( np.pi * self.R_o**2 * self.B_o ** 2 ) / (8 * np.pi * mec2 * e_energy_initial ) + return K_dash + + """ + def norm_equi(self): + e_energy_initial = np.trapz(self.gamma_e * self.N_e_xg, self.gamma_e) + K_dash = ( np.pi * self.R_x**2 * self.B_x ** 2 ) / (8 * np.pi * mec2 * e_energy_initial ) + return K_dash + """ + @property + def N_e_xg(self): + n0 = self.norm_equi * self.N_e_base[None,:] # (1, N_gamma) + int_B = cumulative_trapezoid((self.B_x)**2, self.x, initial=0) # (N_x, 1) + cooling = ( sigma_T.cgs * self.gamma_e[None,:] *int_B[:,None] ) / ( 6 * np.pi * mec2.cgs ) + N_e_xg = n0 * np.exp(-cooling.value) + return (N_e_xg).cgs + + @property + def N_e_gamma(self): + N_e_gamma = np.trapz( self.N_e_xg, self.x, axis=0) + return N_e_gamma + + @property + def N_e_x(self): + 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 P_jet_ke(self): + r"""Total jet power in kinetic energy of the particles + + .. math:: + P_{{\rm jet},\,{\rm ke}} = 2 \pi R_{\rm b}^2 \beta \Gamma^2 c (u_{\rm e} + u_{\rm p}). + """ + P_jet_ke = (1/self.L) * c.cgs * self.Beta * self.Gamma**2 * (np.trapz(self.U_e_x, self.x)) + return P_jet_ke.to("erg s-1") + + @property + def P_jet_B(self): + r"""Jet power in magnetic field as a function of distance + + .. math:: + P_{\mathrm{jet},\,B} = 2 \pi R_{\rm b}^2 \beta \Gamma^2 c \frac{B^2}{8\pi}. + """ + P_jet_B = (1/self.L) * c.cgs * self.Gamma**2 * (np.trapz(self.U_b_x, self.x)) + return P_jet_B.to("erg s-1") + + @property + def P_total_jet(self): + P_total_jet = self.P_jet_B + self.P_jet_ke + return P_total_jet + + @property + def A_eq_base(self): + return (self.U_e_x[0] / self.U_b_x[0]).to_value("") + + @property + def k_eq(self): + """Equipartition parameter: ratio between totoal particle energy density + and magnetic field energy density, Eq. 7.75 of [DermerMenon2009]_""" + return (self.P_jet_ke / self.P_jet_B).to_value("") + + @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/sync_mod.py b/agnpy/synchrotron/sync_mod.py new file mode 100644 index 00000000..2de42e1f --- /dev/null +++ b/agnpy/synchrotron/sync_mod.py @@ -0,0 +1,155 @@ +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 + +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, nu_obs, ssa=False, integrator=np.trapz): + self.emitter = emitter + self.nu_obs = nu_obs + self.ssa = ssa + self.integrator = integrator + + def nu_obs_to_nu_fluid(self): + self.nu_fluid = self.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) + mass=m_e, + 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] / (mass.cgs * c.cgs**2)).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/electron_evolution.ipynb b/electron_evolution.ipynb new file mode 100644 index 00000000..ce7963ec --- /dev/null +++ b/electron_evolution.ipynb @@ -0,0 +1,827 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "28e94ed1", + "metadata": {}, + "outputs": [], + "source": [ + "from agnpy.emission_regions.mod 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 synchrotron_cone\n", + "import numpy as np\n", + "from astropy.constants import c, sigma_T, m_e, e\n", + "#e = e.gauss\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", + "R_o = ( 7.32 * 1e13 * u.m ).to(u.cm)\n", + "L = (1e19 * u.m).to(u.cm)\n", + "theta_open = 9.7 * u.deg\n", + "Gamma = 12\n", + "theta_s = 2 * u.deg\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_maximum = (5.6 * 1e9 * u.eV / mec2.to(\"eV\")).value\n", + "\"\"\"The normalization parameter is left to default, eq (7) in C. & P. leads to norm = 0? since alpha = 2\"\"\"\n", + "n_e = ExpCutoffPowerLaw(k=10, p = p, gamma_min = 0.1*gamma_minimum, gamma_max= 100*gamma_maximum, gamma_c= gamma_maximum )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "07d692e6", + "metadata": {}, + "outputs": [], + "source": [ + "jet = Cone(B_o = B_o, R_o = R_o , L = L, theta = theta_open, Gamma=Gamma, n_e = n_e,x_size=500,gamma_e_size=500, z =z)\n", + "jet.set_delta_D(Gamma=Gamma,theta_s = theta_s)" + ] + }, + { + "cell_type": "markdown", + "id": "b4998849", + "metadata": {}, + "source": [ + "# Plots \n", + "- Electron energy density as a function of x\n", + "- Total electrons as a function of gamma\n", + "- \n", + "- Electron energy density vs Magnetic energy density: Proxy for Equipartition parameter\n", + "\n", + "*Things to note:*\n", + "- Electron density decays as 1/R(x)^2, as expected due to the geometrical dilution included in the evolution equation. \n", + "- Number of electrons stay constant as a function of x, due to the inclusion of geometrical dilution. This makes more physical sense, as the electrons only cool radiatively to shift to lower energies. Overall, should remain constant.\n", + "- Number of electrons drop linearly first, and then exponentially (@ γ>1e3) as a function of gamma, due to a exponential cut-off power law assumption of initial electron distribution\n", + "- Number of electrons vs energy at a particular x: Same distribution for any x above x=0?\n", + "- Equipartition: Starts at 1 and remains constant @ 1.2 throughout\n", + "- Magnetic and Electron energy density drop off as the inverse of radius squared, geometrical dilution" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0ebc6dc6", + "metadata": {}, + "outputs": [], + "source": [ + "# Data\n", + "data = [\n", + "(575439.9373371543, 7.692946554041625e+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", + "(46989410.860521704, 1.1534180805525196e+44),\n", + "(147231250.24327165, 3.8169973137017866e+43),\n", + "(831763771.1026742, 6.485157528062233e+42),\n", + "(3076096814.7407174, 1.1725707943387419e+42),\n", + "(10964781961.43192, 7.858944800779638e+40),\n", + "(28575905433.749672, 1.2244668158998756e+39),\n", + "(59703528658.38415, 2.0753248803736612e+36),\n", + "(89536476554.96011, 4.373153302721358e+33),\n", + "(129419584144.9997, 1.4766294411828247e+30),\n", + "(109647819614.31963, 7.740013565615246e+31),\n", + "(39084089579.24041, 1.164019524379192e+38),\n", + "(18030177408.59577, 1.2817831835790027e+40),\n", + "(5445026528.424242, 4.4349366153056454e+41),\n", + "(1614358556.8264935, 2.865619626947542e+42),\n", + "(325087297.38543606, 1.693846972334023e+43),\n", + "(23768402.866248783, 2.075324880373661e+44)\n", + "]\n", + "\n", + "# Split into x and y\n", + "x_ = [d[0] for d in data]\n", + "y_ = [d[1] for d in data]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "caaeb6f4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,5))\n", + "for i, _n_e_g in enumerate(jet.N_e_xg[::10]):\n", + " plt.loglog((mec2*jet.gamma_e).to('eV'), 3*1e10*_n_e_g, label=f\"x={i}\")\n", + "plt.loglog(x_, y_, marker='o')\n", + "#plt.plot((mec2*jet.gamma_e).to('eV'), jet.norm_equi*3*1e10*jet.N_e_base)\n", + "#plt.legend()\n", + "plt.xlim(1e5,1e12)\n", + "plt.ylim(1e30,1e50)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ecda3634", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6l/rfzttlkj3rgb82b10q8sd89m0000gn/T/ipykernel_47795/902684124.py:11: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Total number of electrons vs Lorentz factor \n", + "plt.figure(figsize=(8,5))\n", + "plt.loglog(jet.x, jet.N_e_x, color = 'red')\n", + "plt.xlabel(\"Distance along Jet axis\")\n", + "plt.ylabel(\"Number of electrons N_e at x)\")\n", + "plt.title(\"Electron Distribution vs Lorentz Factor\")\n", + "plt.grid(True, which='both', ls='--')\n", + "#plt.xlim(10,1e4)\n", + "#plt.ylim(130,1e40)\n", + "plt.tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c6406943", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6l/rfzttlkj3rgb82b10q8sd89m0000gn/T/ipykernel_47795/3900904298.py:10: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Total number of electrons vs Lorentz factor \n", + "plt.figure(figsize=(8,5))\n", + "plt.loglog(jet.gamma_e, jet.N_e_gamma, color = 'red')\n", + "plt.xlabel(\"Electron Lorentz factor γ\")\n", + "plt.ylabel(\"Number of electrons N_e(γ)\")\n", + "plt.title(\"Electron Distribution vs Lorentz Factor\")\n", + "plt.grid(True, which='both', ls='--')\n", + "#plt.xlim(10,1e4)\n", + "plt.tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2c43cb8c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Total number of electrons vs Lorentz factor \n", + "plt.figure(figsize=(8,5))\n", + "plt.plot(jet.x, (jet.U_b_x / jet.U_e_x), color='green', lw=2)\n", + "plt.xlabel(\"Distance along jet x [cm]\")\n", + "plt.ylabel(\"U_e(x) / U_B(x)\")\n", + "plt.title(\"Equipartition Ratio Along the Jet\")\n", + "plt.xscale('linear')\n", + "plt.yscale('linear')\n", + "plt.grid(True, which='both', ls='--')\n", + "plt.ylim(1,6)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f02c166c", + "metadata": {}, + "source": [ + "# Validating Dermer formula with Cotter and Potter's Formula\n", + "Integrating Dermer's equation for Synchrotron power across frequencies to check if it matches with Cotter and Potter's formula for Synchrotron power\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1d7a5cb4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/usharma/Documents/GitHub/agnpy/agnpy/synchrotron/sync_mod.py:65: SyntaxWarning: invalid escape sequence '\\k'\n", + " \"\"\"\n" + ] + } + ], + "source": [ + "from agnpy.synchrotron.sync_mod import Synchrotron" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "17ea534c", + "metadata": {}, + "outputs": [], + "source": [ + "nu_obs = np.logspace(3, 20, 1000) * u.Hz" + ] + }, + { + "cell_type": "markdown", + "id": "250662aa", + "metadata": {}, + "source": [ + "# Dermer's Appraoch vs Cotter's Approach\n", + "Comparison between Synchrotron Power integrated over all frequencies. P_total_cotter overestimates by a little due to the assumption of all frequencies emitted at a particular frequency making the edges a bit sharper, compared to Dermer's Approach" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "314bc1f0", + "metadata": {}, + "outputs": [], + "source": [ + "#Dermer's Method\n", + "syn = Synchrotron(jet,nu_obs, ssa=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "621e265b", + "metadata": {}, + "outputs": [], + "source": [ + "flux = syn.flux_obs(nu_obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4b9cfea9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[6.6400862 \\times 10^{-19},~7.0883889 \\times 10^{-19},~7.5669643 \\times 10^{-19},~\\dots,~1,~1,~1] \\; \\mathrm{}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "syn.evaluate_attenuation()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "18459362", + "metadata": {}, + "outputs": [], + "source": [ + "sed_no_ssa = syn.sed_flux(nu_obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "70358537", + "metadata": {}, + "outputs": [], + "source": [ + "sed_ssa = syn.sed_flux(nu_obs, ssa=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1c9c18f6", + "metadata": {}, + "outputs": [], + "source": [ + "#Cotter and Potter's Approach to Calculate P_sync over all frequencies\n", + "prefactor = (sigma_T.cgs * c.cgs) / (6*np.pi)\n", + "n = jet.N_e_xg\n", + "B = jet.B_x[:, None]\n", + "R = jet.R_x[:, None]\n", + "int_x = np.trapz(n * (B**2), jet.x,axis=0)\n", + "int_y = np.trapz(jet.gamma_e**2 * int_x, jet.gamma_e)\n", + "P_total_cotter = (prefactor * int_y)" + ] + }, + { + "cell_type": "markdown", + "id": "90435974", + "metadata": {}, + "source": [ + "# Total Jet Power\n", + "*Using the same parameters as used in Table 1 of Potter and Cotter; the total Jet power differs by 1 order of magnitude, why is this discrepancy?*" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8db56eac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$7.0411269 \\times 10^{35} \\; \\mathrm{W}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jet.P_total_jet.to('W')" + ] + }, + { + "cell_type": "markdown", + "id": "69caf6bd", + "metadata": {}, + "source": [ + "# SED" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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_no_ssa, color='blue', lw=1, label='Model SED w/o SSA')\n", + "#plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_cotter, color='green', lw=2, label='Model SED')\n", + "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_ssa, color='red', lw=1, label='Model SED w SSA')\n", + "# Overlay updated data points\n", + "plt.loglog(x_sorted, y_sorted, linestyle='dotted', 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-9)\n", + "plt.xlim(1e-8,1e6)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bf432d89", + "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_no_ssa, color='blue', lw=1, label='Model SED w/o SSA')\n", + "#plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_cotter, color='green', lw=2, label='Model SED')\n", + "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_ssa, color='red', lw=1, label='Model SED w SSA')\n", + "# Overlay updated data points\n", + "plt.loglog(x_sorted, y_sorted, linestyle='dotted', 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-9)\n", + "plt.xlim(1e-8,1e6)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "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 +} From f382fc7af6606674ff2c64e0600c667059234872 Mon Sep 17 00:00:00 2001 From: cosimoNigro Date: Thu, 19 Mar 2026 16:29:04 +0100 Subject: [PATCH 2/5] done some modifications to classes names --- agnpy/emission_regions/{mod.py => cone.py} | 0 agnpy/synchrotron/__init__.py | 1 + .../{sync_mod.py => synchrotron_cone.py} | 2 +- electron_evolution.ipynb | 468 +++--------------- 4 files changed, 71 insertions(+), 400 deletions(-) rename agnpy/emission_regions/{mod.py => cone.py} (100%) rename agnpy/synchrotron/{sync_mod.py => synchrotron_cone.py} (99%) diff --git a/agnpy/emission_regions/mod.py b/agnpy/emission_regions/cone.py similarity index 100% rename from agnpy/emission_regions/mod.py rename to agnpy/emission_regions/cone.py diff --git a/agnpy/synchrotron/__init__.py b/agnpy/synchrotron/__init__.py index 93b0629c..f04f09f4 100644 --- a/agnpy/synchrotron/__init__.py +++ b/agnpy/synchrotron/__init__.py @@ -1,2 +1,3 @@ from .synchrotron import * from .proton_synchrotron import * +from .synchrotron_cone import * diff --git a/agnpy/synchrotron/sync_mod.py b/agnpy/synchrotron/synchrotron_cone.py similarity index 99% rename from agnpy/synchrotron/sync_mod.py rename to agnpy/synchrotron/synchrotron_cone.py index 2de42e1f..35f51e26 100644 --- a/agnpy/synchrotron/sync_mod.py +++ b/agnpy/synchrotron/synchrotron_cone.py @@ -5,7 +5,7 @@ from ..utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2 from ..radiative_process import RadiativeProcess -class Synchrotron(RadiativeProcess): +class SynchrotronCone(RadiativeProcess): """Class for synchrotron radiation computation Parameters diff --git a/electron_evolution.ipynb b/electron_evolution.ipynb index ce7963ec..0be2cb59 100644 --- a/electron_evolution.ipynb +++ b/electron_evolution.ipynb @@ -5,9 +5,18 @@ "execution_count": 1, "id": "28e94ed1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/cosimo/work/agnpy/master/agnpy/agnpy/synchrotron/synchrotron_cone.py:87: SyntaxWarning: invalid escape sequence '\\k'\n", + " \\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" + ] + } + ], "source": [ - "from agnpy.emission_regions.mod import Cone\n", + "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", @@ -115,21 +124,20 @@ "\n", "# Split into x and y\n", "x_ = [d[0] for d in data]\n", - "y_ = [d[1] for d in data]\n", - "\n" + "y_ = [d[1] for d in data]" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "id": "caaeb6f4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -137,46 +145,46 @@ } ], "source": [ - "plt.figure(figsize=(8,5))\n", - "for i, _n_e_g in enumerate(jet.N_e_xg[::10]):\n", - " plt.loglog((mec2*jet.gamma_e).to('eV'), 3*1e10*_n_e_g, label=f\"x={i}\")\n", - "plt.loglog(x_, y_, marker='o')\n", - "#plt.plot((mec2*jet.gamma_e).to('eV'), jet.norm_equi*3*1e10*jet.N_e_base)\n", - "#plt.legend()\n", - "plt.xlim(1e5,1e12)\n", - "plt.ylim(1e30,1e50)\n", + "fig, ax = plt.subplots(1, 3, sharey=True, figsize=(10, 4))\n", + "factor = 2 * 3 * 1e10\n", + "#for i, _n_e_g in enumerate(jet.N_e_xg[0]):\n", + "ax[0].set_title(\"x = 0\")\n", + "ax[0].loglog((mec2 * jet.gamma_e).to('eV'), factor * jet.gamma_e * jet.N_e_xg[0], label=f\"x={0}\", ls=\"--\")\n", + "ax[0].loglog(x_, y_, ls=\"-\")\n", + "\n", + "ax[1].set_title(\"x = 1/2 L\")\n", + "ax[1].loglog((mec2 * jet.gamma_e).to('eV'), factor * jet.gamma_e * jet.N_e_xg[368], label=f\"x={1}\", ls=\"--\")\n", + "ax[1].loglog(x_, y_, ls=\"-\")\n", + "\n", + "ax[2].set_title(\"x = L\")\n", + "ax[2].loglog((mec2 * jet.gamma_e).to('eV'), factor * jet.gamma_e * jet.N_e_xg[-1], label=f\"x={2}\", ls=\"--\")\n", + "ax[2].loglog(x_, y_, ls=\"-\")\n", + "\n", + "ax[0].set_xlim(1e5,1e12)\n", + "ax[0].set_ylim(1e38, 1e50)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, + "id": "244bc577-6fb1-4835-9d64-3fe936743c97", + "metadata": {}, + "outputs": [], + "source": [ + "jet.N_e_xg[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "ecda3634", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/6l/rfzttlkj3rgb82b10q8sd89m0000gn/T/ipykernel_47795/902684124.py:11: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Total number of electrons vs Lorentz factor \n", "plt.figure(figsize=(8,5))\n", - "plt.loglog(jet.x, jet.N_e_x, color = 'red')\n", + "plt.semilogx(jet.x, jet.N_e_x, color = 'red')\n", "plt.xlabel(\"Distance along Jet axis\")\n", "plt.ylabel(\"Number of electrons N_e at x)\")\n", "plt.title(\"Electron Distribution vs Lorentz Factor\")\n", @@ -190,29 +198,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "c6406943", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/6l/rfzttlkj3rgb82b10q8sd89m0000gn/T/ipykernel_47795/3900904298.py:10: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Total number of electrons vs Lorentz factor \n", "plt.figure(figsize=(8,5))\n", @@ -229,21 +218,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "2c43cb8c", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Total number of electrons vs Lorentz factor \n", "plt.figure(figsize=(8,5))\n", @@ -270,26 +248,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "1d7a5cb4", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/usharma/Documents/GitHub/agnpy/agnpy/synchrotron/sync_mod.py:65: SyntaxWarning: invalid escape sequence '\\k'\n", - " \"\"\"\n" - ] - } - ], + "outputs": [], "source": [ - "from agnpy.synchrotron.sync_mod import Synchrotron" + "from agnpy.synchrotron import SynchrotronCone" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "17ea534c", "metadata": {}, "outputs": [], @@ -308,18 +277,18 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "314bc1f0", "metadata": {}, "outputs": [], "source": [ "#Dermer's Method\n", - "syn = Synchrotron(jet,nu_obs, ssa=True)" + "syn = SynchrotronCone(jet, nu_obs, ssa=True)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "621e265b", "metadata": {}, "outputs": [], @@ -329,280 +298,17 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "4b9cfea9", "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$[6.6400862 \\times 10^{-19},~7.0883889 \\times 10^{-19},~7.5669643 \\times 10^{-19},~\\dots,~1,~1,~1] \\; \\mathrm{}$" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "syn.evaluate_attenuation()" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "18459362", "metadata": {}, "outputs": [], @@ -612,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "70358537", "metadata": {}, "outputs": [], @@ -622,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "1c9c18f6", "metadata": {}, "outputs": [], @@ -648,24 +354,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "8db56eac", "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$7.0411269 \\times 10^{35} \\; \\mathrm{W}$" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "jet.P_total_jet.to('W')" ] @@ -680,21 +372,10 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "425ccfd5", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHpCAYAAACfnwg9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADgyUlEQVR4nOydd1yT1/fHP1lA2Btc4EBxgIpbceFAwbpbR62i1dZZZ+tov63VttraoR2uatXa1lbbqnUgEgUFRUVRHLgnqCiyCYTM+/uDXx7JABNIyLrv14uXcvKM8zn3Jrnc59xzWYQQAgqFQqFQKBRKtbBN7QCFQqFQKBSKJUAHTRQKhUKhUCg6QAdNFAqFQqFQKDpAB00UCoVCoVAoOkAHTRQKhUKhUCg6QAdNFAqFQqFQKDpAB00UCoVCoVAoOkAHTRQKhUKhUCg6QAdNFAqFQqFQKDpAB00Uio1y7tw5jBw5EgEBAbC3t4efnx+6d++ORYsWmdo17NixAywWCxcuXDD6vZ4+fYpPP/0U6enpRr9XTcjKysKsWbPQokUL8Pl8eHp6IjQ0FO+88w6ysrKY4z799FOwWKwqfx4+fMgcW9nO4XDg4eGBdu3aYfr06Th79qwJVFIolgHX1A5QKJS65/Dhwxg2bBj69u2LNWvWoF69esjOzsaFCxfw119/4dtvvzW1i3XG06dPsWLFCjRu3Bjt27c3tTsqPH78GB06dIC7uzsWLVqE4OBgFBUV4fr169izZw/u37+PRo0aqZwTFxcHNzc3jWvVq1dP5ffXX38dixYtAiEExcXFuHbtGnbu3Imff/4Zc+fOxffff29UbRSKJUIHTRSKDbJmzRo0adIER48eBZf78mNg3LhxWLNmjQk9MwwikQh8Pt8o1y4rK4Ojo6NRrq3Oli1bkJubi9TUVDRp0oSxjxgxAh9++CEUCoXGOR07doS3t/crr+3n54du3boxvw8aNAjz58/Hu+++ix9++AEtW7bEzJkzDSOEQrES6OM5CsUGycvLg7e3t8qASQmb/fJjYerUqfD09ERZWZnGcf369UObNm2Y31ksFubMmYPffvsNrVq1gqOjI9q1a4dDhw5pnHvz5k2MHz8efn5+sLe3R0BAACZNmgSxWKxyXElJCWbOnAlvb294eXlh1KhRePr0qcoxjRs3xmuvvYa9e/ciLCwMDg4OWLFiBQDg2rVrGD58ODw8PODg4ID27dvj119/Zc49ceIEOnfuDACYMmUK88jq008/BQBMnjwZzs7OuHr1KiIjI+Hi4oL+/fsDAPLz8zFr1iw0aNAAdnZ2aNq0KT766CMNDfrERZ28vDyw2Wz4+vpqfb1yWxkCDoeDn376Cd7e3vj6668Nem0KxSogFArF5pg2bRoBQN577z1y9uxZIpFItB53+fJlAoBs2bJFxZ6RkUEAkPXr1zM2AKRx48akS5cuZM+ePSQ2Npb07duXcLlccu/ePea49PR04uzsTBo3bkw2bdpEjh8/Tn7//XcyZswYUlxcTAghZPv27QQAadq0KXnvvffI0aNHydatW4mHhweJiIhQ8SUwMJDUq1ePNG3alGzbto0kJiaS1NRUcvPmTeLi4kKaNWtGdu7cSQ4fPkzGjx9PAJCvvvqKEEJIUVERc6///e9/5MyZM+TMmTMkKyuLEEJITEwM4fF4pHHjxmT16tXk+PHj5OjRo0QkEpG2bdsSJycn8s0335D4+Hjy8ccfEy6XS6Kjo1X80zUu2vj9998JABIZGUni4uJIUVFRlccuX76cACDPnj0jUqlU5Ucmk2n4NHv27CqvNW7cOAKAiQOFQqmADpooFBskNzeX9OzZkwAgAAiPxyM9evQgq1evJiUlJSrH9unTh7Rv317FNnPmTOLq6qpyLADi5+fHDHwIIeTZs2eEzWaT1atXM7Z+/foRd3d3kpOTU6V/yoHMrFmzVOxr1qwhAEh2djZjCwwMJBwOh9y6dUvl2HHjxhF7e3uSmZmpYo+KiiKOjo6ksLCQEELI+fPnCQCyfft2DT9iYmIIALJt2zYV+6ZNmwgAsmfPHhX7V199RQCQ+Ph4veOiDYVCQaZPn07YbDYBQFgsFmnVqhVZsGABefDggcqxykGTtp9mzZqpHPuqQdOSJUsIAHLu3Llq/aNQbA36eI5CsUG8vLyQnJyM8+fP48svv8Tw4cNx+/ZtLFu2DKGhocjNzWWOnTdvHtLT03H69GkAQHFxMX777TfExMTA2dlZ5boRERFwcXFhfvfz84Ovry8ePXoEoCIf6OTJkxgzZgx8fHxe6eewYcNUfm/bti0AMNerbG/RooWKLSEhAf3799dIlJ48eTLKyspw5syZV95fyejRozWu7eTkhNdff13j2gBw/PhxFfur4lIVLBYLmzZtwv3797FhwwZMmTIFUqkUa9euRZs2bXDy5EmNc44dO4bz58+r/Ozfv19nrQBACNHreArFVqCJ4BSKDdOpUyd06tQJACCVSrFkyRKsXbsWa9asYRLChw8fjsaNG2P9+vUIDw/Hjh07UFpaitmzZ2tcz8vLS8Nmb28PkUgEACgoKIBcLkfDhg118k/9evb29gDAXE+J+sowoCIfSJu9fv36zOu64OjoCFdXV41r+/v7g8Viqdh9fX3B5XI1rv2quLyKwMBAlaTsPXv2YPz48fjggw+Qmpqqcmy7du10SgSvDuVgThkrCoVSAZ1polAoAAAej4fly5cDqEigVsJmszF79mz8888/yM7OxoYNG9C/f38EBwfrfQ9PT09wOBw8fvzYYH4D0Bi8ABUDlezsbA27MpFc14FFVdd+/vy5xoxMTk4OZDJZrQctr2LMmDFo27atSjsZCpFIhGPHjqFZs2Y6D24pFFuBDpooFBtE22ACAG7cuAFAc4Zh2rRpsLOzw4QJE3Dr1i3MmTOnRvfl8/no06cP/v77b5VHgMagf//+SEhI0Fhtt3PnTjg6OjLL7auavXrVtYVCocZjr507dzKvG4Kq2kkoFCIrK8vgM0FyuRxz5sxBXl4elixZYtBrUyjWAH08R6HYIIMGDULDhg0xdOhQtGzZEgqFAunp6fj222/h7OyMefPmqRzv7u6OSZMmYePGjQgMDMTQoUNrfO/vvvsOPXv2RNeuXbF06VIEBQXh+fPnOHDgADZv3qyS+1Mbli9fjkOHDiEiIgKffPIJPD098ccff+Dw4cNYs2YNUwCyWbNm4PP5+OOPP9CqVSs4Ozujfv361Q5IJk2ahPXr1yMmJgYPHz5EaGgoTp06hVWrViE6OhoDBgwwiIYvvvgCp0+fxtixY9G+fXvw+Xw8ePAAP/30E/Ly8rSWBUhLS9Na3LJ169YqjxmfP3+Os2fPghCCkpISprjl5cuXsWDBArzzzjsG0UChWBUmTkSnUCgmYPfu3eTNN98kzZs3J87OzoTH45GAgAAyceJEcv36da3nnDhxggAgX375pdbXUcWKrMDAQBITE6Niu379OnnjjTeIl5cXsbOzIwEBAWTy5MmkvLycEPJy9dz58+dVzktMTCQASGJiosr1hwwZotWnq1evkqFDhxI3NzdiZ2dH2rVrp3WV3J9//klatmxJeDweAUCWL19OCKlYPefk5KT12nl5eWTGjBmkXr16hMvlksDAQLJs2TJGQ03ios7Zs2fJ7NmzSbt27YinpyfhcDjEx8eHDB48mMTGxqocW93qOQBEIBCo+KT8YbPZxNXVlYSGhpJ3332XnDlzplqfKBRbhkUIXSZBoVBezaJFi7Bx40ZkZWVpTWymUCgUa4c+nqNQKNVy9uxZ3L59Gxs2bMD06dPpgIlCodgsNj3T9M0332D79u1gsVhYunQp3nrrLVO7RKGYHSwWC46OjoiOjsb27ds1ajNRKBSKrWCzM01Xr17Frl27kJaWBqBitctrr70Gd3d30zpGoZgZNvx3FYVCoahgsyUHbty4gR49esDBwYHZyDMuLs7UblEoFAqFQjFTzHbQlJSUhKFDh6J+/fpgsVhatwHYsGEDmjRpAgcHB3Ts2BHJyck6Xz8kJASJiYkoLCxEYWEhEhIS8OTJEwMqoFAoFAqFYk2Y7eO50tJStGvXDlOmTNHY9wkAdu/ejfnz52PDhg0IDw/H5s2bERUVhevXryMgIAAA0LFjR4jFYo1z4+Pj0bp1a8ydOxf9+vWDm5sbOnfuDC636nCIxWKVaykUCuTn58PLy0trxWAKhUKhUCh1D/n/2mP169cHm23guSFT1jvQFQBk3759KrYuXbqQGTNmqNhatmxJli5dWqN7TJ06lRw6dKjK119VA4X+0B/6Q3/oD/2hP+bzk5WVVaPxQHWY7UxTdUgkEqSlpWHp0qUq9sjISKSkpOh8nZycHPj6+uLWrVtITU3Fpk2bqjx22bJlWLhwIfN7UVERAgICcPv2bXh6egKo2KOLw+FALpdDoVAwxyrtMplMJamWw+GAzWZXaZdKpSo+KGfCZDKZTnYejweFQgG5XM7YWCwWuFxulfaqfNdVk0KhwLFjx9CvXz+VmTtL1mSIdpJKpUhMTMTAgQM1ZiYtVVN1dl00KWPSr18/8Pl8q9Ckbq+JJolEgsTERERERMDBwcEqNBminUQiERMXHo9nFZoM0U5isRjHjh1j4mINmmrbToWFhQgKCjLY7gIqegx+xTogNzcXcrkcfn5+KnY/Pz88e/ZM5+uMGDEChYWFcHJywvbt26t9PGdvb8/sUVUZX19frVsW2CqEELz++uvgcrn0sWUlaFw0oTHRDo2LdlxdXWlctED7iybK73JjxMMiB01K1ANCCNErSPrMSlWFVCplRty2NJKvShObzYZIJAKfz1fxxZI1GaKdCCEQiURwcXGxGk3V2XXRRAiBUCiEi4sLeDyeVWhSt9dEk0KhgFAohLOzM7hcrlVoMkQ7SaVSJi5KXyxdk6HaqaSkhImLtWiqTTtVPtfQWOSgydvbGxwOR2NWKScnR2P2ydCsX78e69evZxpFIBDA0dERABAQEICwsDBcuXIFmZmZzDnBwcFo2bIlUlNT8eLFC8bevn17BAYGIikpCSUlJYy9e/fu8PX1RXx8vEpHi4iIAJ/PR2xsrIpP0dHRzNS1Ei6XiyFDhiA3Nxdnzpxh7C4uLujXrx+ysrKQnp7O2H18fNCjRw/cuXMHt27dYuz6agoNDcXVq1fh7OwMoVBoFZoM1U4A0KtXL5VVnpauyRDt5O3tjfDwcKvSZI3tZGpNR44csTpNhminR48e4erVq1alqbbt5O/vD2NhERXBWSwW9u3bhxEjRjC2rl27omPHjtiwYQNja926NYYPH47Vq1cb3afi4mK4ubkhOzub2VbClkby1eU0xcXFITIykuY0qeU0CQQCREVF0ZymSjlNAoEAkZGRNKdJLadJIBBg4MCBNKepku8ikYiJC81pUs1piouLY+JiDZpq204FBQXw8/NDUVERXF1dYUjMdqZJKBTi7t27zO8PHjxAeno6PD09ERAQgIULF2LixIno1KkTunfvjp9//hmZmZmYMWNGnfrJ4/HA4/FUbBwOBxwOR+PYqnKmqrKrX7cmdjabrXXJZVX2qnzXVZPyjcTlcrX6Y4maXmXXx3cWi2V1mqqy66pJ6YM1aVJSE03KLygej8dcszaaFAqF1tIrQNWPMdS/4KqzKwfA+tj18UVpl8vlzBcnm83W+zrmqKm2dplMBqlUqhIXpV0f381Nky52Ozs7Rq/6+0nbe8tQmO2g6cKFC4iIiGB+V65ci4mJwY4dOzB27Fjk5eVh5cqVyM7ORkhICGJjYxEYGFinftKcJs2ZJi6Xq+GLJWsy1EwTh8MBIUTjeEvVVJ1d15kmpW80p+mlJmVclP/WRpNEIkFWVhZzrvqDBRaLpXWbHHOyK2dmFQoF6tWrh8zMTCZ3x9I16WOv7tqV42Itml5lZ7PZCAwM1DpLbcycJot4PGdOVM5pun37Nnbt2qWR03Tp0iWtz4xTUlK0PjNOSEjQ+sz48OHDtX5mnJOTU+VzcG3PjG/evKn1mTHVRDVRTZanydPTEx4eHmjcuDFYLBZKS0tVtLq6ukIqlUIkEjE2NpsNZ2dnSCQSlJeXM3YOhwMnJyeUl5dDIpEwdh6PBz6fD5FIpDKIs7Ozg4ODA0pLS1W+xBwcHGBnZwehUKjyRcfn88Hj8VBcXKzio5OTE1gslkqOJAA4OzuDEEI12aAmQghevHgBiUSCsLAwpKenq7yfGjRogM6dOxvl8RwdNNUQZU5TTk4Os8mvrf5lXNl3FouF/Px8uLu7q+TuWLImQ7STQqFAYWEhvL29Ve5pyZqqs+uiSaFQIC8vD97e3rCzs7MKTer2mmiSy+XIy8uDl5cX84iuJppkMhkePHiA+vXrM2VR1D/u2Ww2CCEa72HlX/WmsKu/PyrPVMhkMkZjVTMYlqZJF/urNCkf0VmTplfZi4uL8fTpUzRv3hxsNlvFn+LiYnh7e9tWTpOlwGazaU5TJaRSKc6cOYPo6Gia01TJLpVKcfbs2SrjYomaXmV/lSapVIrz588jOjq6Wt8tSZM6Nc1pUsalNjlNcrkcLBYL9vb2Ko9t1Kn8qMsc7NriCFR86ZaVlcHV1VXlGHPyXV9N2o6tyl7VtauLi6Vq0sWu7NdyuRw8Hs+oeUyVMdsNeykUCoVSe6r6EqNQLBlT9Ws601RLaCK4ZiK4Nl8sWZOhEsEB0ERwtURw5bk0EVw1ERxArRPBpVIpCCFQKBRVJoJb4qMspSb6eE51NqZyXCxdky72yv26LhPB6aBJT9SLWyYmJtLilmrFLV1cXJCSkkKLW6ppcnZ2RmlpKZKSkqxGkyHa6eLFi7S4pRZNAoGgVpq4XC78/f0hFArh4OAAQojKNQDA3d0dMplMJUmXzWbD1dUVEolEJUmXy+XC2dkZ5eXlKiUM7Ozs4OjoCJFIpJJ4bG9vDz6fj9LSUhUf+Xw+7O3tUVJSovJF5+TkpDXB2MXFBSwWi/Fd+a+rq6vFa1K310STcuCsPMcaNOnSThKJhNGu/n6qV68ejAVNBK8hykTw3NxcJtHMVv8yppqoJqrJ/DSVl5cjKysLjRs3ZrY1svVZGaX9xIkT6N+/P/Lz8+Hh4aGTj02bNsW8efOwYMECs9RU13ZTayovL8fDhw/RtGlT5r2pRCgUwtPT0yiJ4CCUGlFUVEQAkIKCAlO7YlbI5XLy8OFDIpfLTe2KWUHjogmNiXYMFReRSESuX79ORCKRgTyrG2JiYggAMn36dBW7QqEg7777LgFAYmJianWPxMREvT+/AwMDydq1a6t8XSgUksWLF5MmTZoQe3t74u3tTfr06UMOHjzIHNOnTx8CQOOnstbKdkdHRxIUFERiYmLIhQsXtN5XoVCQ8vJyolAodNZSmeXLl5OxY8fW6FxCCElISCB9+/YlHh4ehM/nk6CgIDJp0iQilUqZYzZt2kTatm1LHB0diZubG2nfvj358ssvtV6vRYsWhMfjkcePH1d73+r6d0FBAQFAioqKaqyrKmgieC0x5rNTS0QulyM9PZ3GRQ0aF01oTLRD4wI0atQIf/31l8ojGpFIhN27dyMgIMCEnlXNjBkzsH//fvz000+4efMm4uLiMHr0aOTl5akc98477yA7O1vlZ82aNSrHbN++HdnZ2cjIyMD69eshFArRtWtX7Ny5U+O+hFRsBk5q+NDowIEDGD58eI3OzcjIQFRUFDp37oykpCRcvXoVP/74o8rMzy+//IKFCxdi7ty5uHz5Mk6fPo3Fixdr1HMCgFOnTqG8vBxvvPEGduzYUSOfAJrTZNbQRHCaCE4TwWkiOE0EN6w9LCwMDx48wD///IO33noLALB37140aNAAQUFBGo9pFi9ejN27d6O4uBidOnXCd999h06dOjHXPnLkCBYsWICsrCx069YNEydOVIkHIQSnT5/Ghx9+iPPnz8Pb2xsjR47EqlWrmJxV9ePVfT948CDWrVuHwYMHA6jIX+vQoYPGoyw+n89sLK/+2al8lOXq6gpfX1/mOpGRkYiJicGcOXMwZMgQeHh4aCSCL1q0CHfu3MHBgwfBYrGwdu1aLFy4EAcOHMCQIUPAYrHQsmVLLFiwAO+++y4AICsrC9euXUNUVBQIIXj06BHmzp2LhIQEsNlsDB48GD/88APjS+V2UigUiI+PR7169fDll18yvjRp0gSRkZGMpoMHD2LMmDGYMmUKc41WrVpp7Xu//PIL3nzzTfTu3Rtz5szB0qVLmfvRRHALhSaCV68pNDQUAGgiuBZNQMWz9uTkZKvRRBPBLSsR/PnzEty587KejYuLC2QyGUSil9WXWSzW/1dllqokEnM4HDg6OqK8XKwyWONyuf9fabpcxRcejwcHBweUlYnQtKkEyrHHqxKMpVIpZDIZxo0bx3yJslgsbN26FW+99RZOnTrFDAgJIViwYAEOHDiA9evXo1GjRti0aRMGDx6MtLQ0eHh44PHjxxg9ejRmzJiBqVOn4syZM1i2bBkAoLS0FB4eHrhw4QKioqLw4YcfYu3atSgqKsL777+PmTNn4scffwRQ8SWt1Kctadrf3x8HDhxA//794eLioqJJmRwtk1VsyKwcIGlLmgYqZtUqv+bu7o45c+Zg586dOHDgAEaOHKmRCN6lSxds27YNJSUlcHV1RWJiIry8vCAQCNCrVy/k5+fj9u3b6Nq1K3PtPXv2oGfPnnB3d0dJSQmGDx8OR0dHHDp0CBwOB/Pnz8cbb7yBgwcParRTcXExXF1dkZ2djSNHjmDw4MFaNfn5+SEpKQnXrl1TmSVUTwQvKSnB33//jXPnzqFJkyYQCoWIjY1Fr1699E4E9/f3h9Ew+AM/G0GZ0/Ts2TMikUiIRCIhMpmMEEKITCZjbJXtUqlUxa7MWajKXtkmkUiIQqEgCoVCZzshFfkRlW3K58xV2avyXVdNYrGYnD59mohEIqvRZIh2KisrI6dOndI41pI11badysrKSHJyMpOTYA2aDNFOyriUlZXVSlNxcTHJyMggpaWljP38eTkBSJ3/nD8vJ3J5xY8y90ahUDC2yvZJkyaRYcOGkefPnxN7e3ty//598uDBA+Lg4EAePHhAhg0bRiZNmkQUCgUpKSkhPB6P/Pbbb8x1JBIJqV+/Pvnqq6+IXC4nS5cuJa1atWJiIJfLyeLFiwkAkp+fTwghZOLEieSdd95R8SU5OZmw2WxSWlpK5HI5CQwMJN99912Vvp88eZI0bNiQ8Hg80qlTJzJv3jySnJzM9A+5XE769OlDeDwecXJyUvnZtm0bcx0A5N9//1W5PiGElJWVEQDkyy+/VImXXC4nxcXFJD8/n7DZbHL+/HmiUCiIl5cXWbVqFencuTORy+Xkjz/+IH5+fiq+DxgwgHz//feEEEKOHj1KOBwOk0+nUChIRkYGAUDOnj2r0U7KWCtz0Pz9/cmIESPIDz/8QAoKCpjjnzx5Qrp160YAkBYtWpBJkyaRP//8k7mW8rhNmzaR9u3bM/GdO3cuefPNN6vsM6WlpSQjI4OIRCKN91NOTo7RcproTFMtUe7DUxlbq2CsTo8ePbT6V5WP+totsXo2j8dDeHi41uMAy9T0KvurNPF4PPTs2fOVvluSJnVqoonL5arERWnX13f5/1cEZ7PZzKOT1q1ZSEvTeopRadmSDfXwqD9eUrf7+vpiyJAh2LlzJwghGDJkCLOHnvLn/v37kEql6NWrFxN/NpuNLl264ObNm2Cz2bh58ya6devG3IvFYjGfUUpbWloa7t69i127djF+kP9/tPno0SO0atVK5Xhtvvfu3Rv379/H2bNncfr0aSQkJKB3795YsWIFPv74Y+a4CRMm4KOPPlI519fXV6X/VNWftL3GZrOZma327dvj5MmTsLOzA5vNxowZM/Dpp5+itLQUJ0+eRJ8+fRjfi4uLkZSUhK1btwIAbt68iUaNGqlset+6dWu4u7vj1q1b6Nq1q1Y/duzYgS+++AIJCQk4e/YsVq1ahTVr1iA1NRX16tVD/fr1cebMGVy7dg0nT55ESkoKpkyZgm3btiEuLo7Rsn37duZRLIvFwsSJE9G7d28UFxczW5VVjnvlfq3+frK3t9caO0NAB021xJaTNbUhl8tx584dNG/evM7K2lsCNC6a0Jhox5hxcXQEOnQw6CWNyttvv405c+YAAH766SeVxHDgZU6Q+gCGEFLlUndtKBQKTJ8+HXPnztV4TZ/Ecx6Ph169eqFXr15YunQpPv/8c6xcuRJLliyBnZ0dAMDNzQ1BQUE6X1PJjRs3AFTkDFWGEILy8nI4ODigb9++OHHiBOzs7NCnTx94eHigTZs2OH36NE6cOIH58+cz5x05cgStWrViBkmVY6Z+fW32yjRo0AATJ07ExIkT8fnnn6NFixbYtGkTVqxYwRwTEhKCkJAQzJ49G6dOnUKvXr1w8uRJRERE4Pr16zh37hzOnz+PJUuWMOfI5XL8+eefmDlzpl6xMub3Ml09V0vUa1XYOgqFArdu3aJxUYPGRRMaE+3QuLxk8ODBkEgkkEgkiIyMhFgsVhkEBQUFwc7ODqdOnWJsUqkUFy5cYGaHWrdujbNnz6pcV/33Dh06ICMjA0FBQRo/ysFOTWjdujVTM6u2rFu3Dq6urhgwYICKnRDCxKVv375ITk5GQkIC+vbtCwDo06cP/vrrL9y+fRt9+vRhzvvvv/8wbNgwFV8zMzORlZXF2K5fv46ioiImlrrg4eGBevXqqRStVKd169YAwBzzyy+/oHfv3rh8+TLS09OZn8WLF+OXX37R+d5KjPneoTNNFAqFQjFLOBwOM8OibdbNyckJM2fOxAcffABPT08EBARgzZo1KCsrw9SpUwFUlAL49ttvsXDhQkyfPh1paWkay9mXLFmCbt26Yfbs2XjnnXfg5OSEGzduQCAQMIngr6Jv374YP348OnXqBC8vL1y/fh0ffvghIiIiVAoslpWV4dmzZyrn2tvbw8PDg/m9sLAQz549g1gsxu3bt7F582bs378fO3fuZB5VaaN3794oKSnBwYMH8fnnnzN+jR49Gj4+PsxgRSaT4ciRIzh27Bhz7oABA9C2bVtMmDAB69atg0wmw6xZs9CnTx+VlYiV2bx5M9LT0zFy5Eg0a9YM5eXl2LlzJzIyMpi4zZw5E/Xr10e/fv3QsGFDZGdn4/PPP4ePjw+6d+8OqVSK3377DStXrkRISIjK9adNm4Y1a9bg8uXLaNeunQ6tYHzooKmW0JIDtOQALTlASw7QkgOGtyvjo8zXqRyvyueuWrUKcrkcEydORElJCTp16oS4uDi4ublBoVCgYcOG+Oeff7Bw4UJs2LABXbp0weeff45p06Yx1wgNDUViYiL+97//oVevXiCEoFmzZhgzZozGfdXvr/R90KBB+PXXX/Hhhx+irKwM9evXx5AhQ7B8+XKVa2zZsgVbtmxRaYfIyEgcOXKEeQymXJ7v4OCABg0aoGfPnjh37hzCwsKYa6nnVRFC4OLigrCwMGRmZqJVq1ZQKBQIDw+HQqFgZpkIIUhMTISzszPCwsJUHr/t3bsXc+fORe/evVVKDlT2v3LJgU6dOiE5ORkzZszA06dP4ezsjDZt2mDv3r3o1asXFAoF+vfvj+3bt2Pjxo3Iy8uDt7c3unXrhuPHj8PT0xP//PMP8vLyMHz4cMYXZXybNWuG0NBQbN26FT/++KNZlByg26joSeWSA7dv38auXbs0Sg5cunRJ63LilJQUrUukExIStC4nPnz4cK2XSOfk5GhdIv3o0SOtS6Rv3rypdYm0rpratm2LwsJC5Ofnay05YImaDNVODRs2RLNmzXDy5Emr0WSN7WQtmpQlBxo1agRvb28Qon3/L6lUqnX/L7FYrHX/L5FIpHVPs7KyMq17mgmFQq17mhUXF2stOVBYWKjiY032NKOaqte0YMECyGQyfPvttxarSSKRIDs7G8HBwbhx44bG3nNdu3Y1yjYqdNBUQ+jec1QT1UQ1mbMmuvcc1VSVffPmzejevTtCQ0MtVpOp9p6jg6Yaohw0KTd8pFQgl8tx5coVtG3blq6IqgSNiyY0JtoxVFzKy8vx4MEDNGnSBA4ODgb00DQQUrFdCJ/Pf+VqLlvCVuNSXf8uKCgw2qCJrp6rJXSFiyoKhQKZmZk0LmrQuGhCY6IdGhftEEIgkUh0KiFgS9C4aGLM9w4dNFEoFAqFQqHoAB00USgUCoVCoegALTlQSyovnaaJqxUEBwdDoVCo+G/JmgzRTnK5HC1atACLxaIlB/7fLpfLERQUxPhrDZrU7TXRpIyLXC63yZIDVSUYAy+3x1D8/4a3lq7JEEnT2uJi6Zp0sVdXcsCYjyrpoElPKpccAIDjx49rlByw1V3ZlZpatmxZ5RJpS9VkqHYqKyuzOk21baeioiKr02SIdrp7926tNClLDgiFQjg4OFS57LvyTvPAy2XfEolE67LvyjvNAy+XsotEIq3L80tLS7UuZS8pKdG6lF19ybr6Unblvatbym5pmpTURJNUKoVYLGb8twZNurSTRCJh/mhQfz81aNAAxoKunqshytVzz549g6enJwDb/cu4su+EEFy4cAEdOnRQWfljyZoM0U4ymQwXL15Ely5doI6laqrOrosmmUyGtLQ0dOrUCQ4ODlahSd1e0+KWaWlp6NixI+zt7WnJgUozFaWlpXByctKwW7ImXezVaVIoFBpxsXRNutirKzlQWFgIX19fo6yeozNNtYTL5WrsNG5ru7JXRiqV4sWLF+BwOFr9sURNr7Lr6ntubm6Vx1uqpursumjKy8tj/LUWTZWpiSZCCPLy8sDlcplr1kSTXC4Hi8UCm/1yN3htS9IrP+YxB7u2OAIVX7rKgWnlY8zJd301aTu2KntV1wZQZVwsVZMu9sr9Wv39VJVvhoAmglMoFArFpjhx4gRYLJZGVevqaNy4MdatW2c0nyiWAR00USgUCsVsmDx5MlgsFmbMmKHx2qJFi8DhcDB58uS6d+wVlJaWYsmSJWjatCkcHBzg4+ODvn374tChQ8wxffv2ZWZLKv9U1lrZ7uTkhObNm2Py5MlIS0szuoZ///0XXbt2hZubG1xcXNCmTRssWrSIeV0ul2P16tVo2bIl+Hw+PD090a1bN2zfvl3jWiKRCB4eHvD09FTJT7J06OO5WkIrGavC4XDQvn17Ghc1aFw0oTHRDo0L0KhRI/z1119Yu3Ytk48lFouxd+9eBAQEmNg77cyYMQOpqan46aef0Lp1a+Tl5SElJQV5eXkqx73zzjtYuXKlik25mEjJ9u3bMXjwYJSXl+P27dv4+eef0bVrV2zbtg2TJk1SOZbFYhmkGvixY8cwbtw4rFq1CsOGDQOLxcL169dx/Phx5phPP/0UP//8M3766Sd06tQJxcXFuHDhAgoKCjSu9++//yIkJASEEOzduxcTJkyolX/6YNT3DqHUiKKiIgKAFBUVmdoVCoVC0UAkEpHr168TkUhkalf0IiYmhgwfPpyEhoaS33//nbH/8ccfJDQ0lAwfPpzExMQw9vLycvLee+8RHx8fYm9vT8LDw0lqaqrKNQ8fPkyaN29OHBwcSN++fcn27dsJAFJQUMAcc/r0adKrVy/i4OBAGjZsSN577z0iFAqZ1wMDA8natWur9NvNzY3s2LGjWm19+vQh8+bNq/YYAGTfvn0a9kmTJhEXFxeSn5+v9byFCxeS1157jfl97dq1BAA5dOgQY2vRogXZtGmT1vPnzZtH+vbtW61v7dq1I59++mm1xyjp27cv2bRpE9m4cSOJiIjQ6Rx9qK5/G/P7mT6eqyXqK2xsHZlMhoSEBBoXNWhcNKEx0Y5R41JWBly8WPc/ZWV6uzplyhSVxz7btm3Dm2++qXHc4sWL8e+//+LXX3/FxYsXERQUhEGDBiE/Px8AkJWVhVGjRiE6Ohrp6emYNm0ali5dqnKNq1evYtCgQRg1ahSuXLmC3bt349SpU5gzZ47O/vr7+yM2NlZjab2hWLBgAUpKSiAQCFTshBAUFxejT58+SE5OZlaRnTx5Et7e3jh58iQA4NmzZ7h9+zb69OlTpf8ZGRm4du1alT74+/sjISFBpdSHNu7du4czZ85gzJgxGDNmDFJSUnD//n195NYKo36mGHwYZiMoR7K5ubmmdsWskEgkZP/+/UQikZjaFbOCxkUTGhPtGCouWv8ST0sjBKj7n7Q0nf1WzjS9ePGC2NvbkwcPHpCHDx8SBwcHcvfuXTJs2DBmpkkoFBIej0f++OMPlfjVr1+frFmzhhBCyLJly0irVq2IQqFgjlmyZInKTNPEiRPJu+++q+JHcnIyYbPZTPxeNdN08uRJ0rBhQ8Lj8UinTp3I/PnzyalTp1SO6dOnD+HxeMTJyUnlp/IMFaqYaRKJRAQA+eqrr1TscrmcFBQUkPz8fMJms8mFCxeIQqEgXl5eZPXq1aRz586EEEJ27dpF/Pz8qvRfKBSS6OhoAoAEBgaSsWPHkl9++YWUl5czx2RkZJBWrVoRNptNQkNDyfTp00lsbKzGtT788EMyYsQI5vfhw4eTjz76qMp714TqZppyc3ONNtNEc5pqiVQqpRXBK/muPEbdF0vWZIh2Uh5DCKEVwf/frryHTCZjlshbuiZ1e03rNAEVfcbgFcFbtADOn1e5L6mL2kUtWgD/r1fX63h6eiI6Oho7duwAIQTR0dHw8vKq0PH/x9y9exdSqRTdu3dn4snj8dClSxdcv34dCoUC169fR9euXVWu3bVrV+Y6AJCWloa7d+/ijz/+YPxRxu7evXto1aqVyvHafO/duzczw5KSkoKEhAR8//33WLFiBT766CPm2DfffJP5XXkNX19flSrnCoVCo39U/r1y5W8lrq6uaN++PRITE8Hj8cBms/HOO+9g+fLlKCoqQmJiIvr06VNl3B0dHXHw4EHcu3cPiYmJOHfuHBYtWoTvv/8ep0+fhqOjI1q2bImrV6/i4sWLSE5ORlJSEoYOHYqYmBhs3bqV6Xu//vor1q5dy/g5YcIELFy4EMuXL2fyjYxZEbzye9HQ0EGTnqhXBE9MTKQVwStpCg0NBQCkpKRAKBRahSZDtRMACIVCJCcnW40mQ7TTxYsXER4eblWaDNFOAoHA8BXBZTIgKIg53t3dHTKpVHtVZrFYe1VmkUh7pemyMu2VpoXCCh//v1L0qypNS6VSyGQyFBcXY+zYscyjtK+++gqA6oBQ+TksFAqZStTu7u5M8dTi4mLmegCYStNKXaWlpfDw8IBcLsfkyZMxffp0ABUDLz6fD5FIBB8fHxQXF0OhUDDXqap6dnl5Odq1a4d27dph5syZ+P777/HZZ59h+vTpsLOzg0wmA5/PR9OmTcFiqVbPLi4uZgoxikQildfc3d2Zx2Z+fn4oLi5WqQgOACUlJejevTuOHz8Oe3t79OzZExwOBy1btoRAIMCJEyewYMGCV1YE9/HxwZgxYxATE4P//e9/aNGiBX799VcmkdvJyQmdO3dG8+bN8fbbb2P37t2YMWMGli1bhqZNm2Lfvn148uQJxo8fj8rI5XLs378fAwcOfNn3jFQR3N/fH8aCVgSvIcqK4Dk5OXB3dwdgu38Zq/9FkJ+fD3d3d5W/gixZkyHaSaFQoLCwEN7e3hqVdC1VU3V2XTQpFArk5eXB29sbdnZ2VqFJ3V7Tvefy8vLg5eXFzBjYUkXwmJgYFBYWYt++fZDL5WjcuDEA4OHDhyCE4I033oC7uzt27NiB0tJSeHl54ZdffmHyneRyOZo0aYJ58+Zh0aJF+Oijj/Dff//h+vXrzD0//PBDfPXVV8jPz4eHhwcmTJiAZ8+eMflC2nxs2rQp5s2bhwULFuisad++fXjjjTeQn58PV1dX9OvXD+3atWPqPam3h7IY6b///osRI0aotNOkSZPw33//4cGDB8znq/KeUqkUXC4XBw8eRExMDCIiItC/f3/MmjULCxcuREFBAXbu3ImMjAy0atVK5/YAKgY3n3/+OWbPnq1yvLL/Xrx4EZ07d8aVK1cQEhKC0aNHw87ODh9++KHKdb788kuUl5fj77//Nkjfq64ieHFxMby9vWlFcHPE3t6eVgRXw9fXV6t/Vfmor91Sq2f7+fkx91XHUjVVZ9dFU/369Rm7tWiqTE00cblclbgo7fr6bqkVwZV2ZUxv3LjBaKr8OovFgrOzM2bOnIklS5bA29sbAQEBWLNmDcrKyjBt2jSw2WzMnDkT3333HRYuXIjp06cjLS0Nv/76q0o8lixZgm7duuG9997DO++8AycnJ9y4cQMCgQA//vijim9V+d63b1+MHz8enTp1gpeXF65fv46PPvoIERERzB/WQMUs0vPnz1XOtbe3h4eHB/N7cXExcnJyIBaLcfv2bWzevBn79+/Hzp07mW27KvtkZ2fH+FBSUoKDBw/i888/B5vNRkREBEaPHg0fHx+0bt1aRUdlVqxYgbKyMkRHRyMwMBCFhYX44YcfIJVKERkZCTabjddffx3h4eHo0aMH/P398eDBAyxbtgwtWrRAq1atkJubi0OHDuHAgQNo27atyvUnT56MIUOGIC8vDz4+Pjr1gers1VUEr+p9YRB0ynyiaEATwbUjkUjIoUOHaHKvGjQumtCYaMdQcbH0kgPqKBOeKyeCE1Kh87333iPe3t5Vlhw4ePAgCQoKIvb29qRXr15k27ZtGiUHUlNTycCBA4mzszNxcnIibdu2JV988QXz+qsSwVetWkW6d+9OPD09iYODA2natCmZO3euyndEnz59CACNn0GDBjHHVLY7ODiQZs2akZiYGJJWRTK9Mi5yuZwQQkjHjh2Jj48Pk/iel5dHWCwWef3116v0nRBCEhISyOjRo0mjRo2InZ0d8fPzI4MHDybJycnMMT///DOJiIggPj4+xM7OjgQEBJDJkyeThw8fEkII+eabb4i7u7vWviuVSomnpyf59ttvq/VDV0yVCE4fz9UQ5eO53NxcJjmRUpG8Ghsbi+joaOOO9i0MGhdNaEy0Y6i4lJeX48GDB2jSpAkcHBwM6KFpUCgUTN6PMfcWszRsNS7V9W/lY39jPJ6znQhTKBQKhUKh1AI6aKJQKBQKhULRATpoqiVVJWjaKlwuFxERETQuatC4aEJjoh0aF+2wWCy4uLjUeo81a4PGRRNjvnfooIlicJTLmymq0LhoQmOiHRoX7dCBgXZoXOoOOmiqJXTfLFVkMhliY2NpXNSgcdGExkQ7NC7aIf+/xxpdu6QKjYsmxnzv0EEThUKhUCgUig7QQROFQqFQKBSKDtBBE4VCoVAoFIoO0OKWNURZ3LKwsBBubm6mdsdsIIRAJpOBy+XS5MRK0LhoQmOiHUPFxdqKW5L/33esqi02bBVbjUt1/buoqAju7u507zlzRCqVMptm2uoGo5V9Z7PZEIlEGqt/LFmTIdqJEAKRSAQXFxer0VSdXRdNhBAIhUK4uLgwe6VZuiZ1e000KRQKCIVCODs7g8vl1liTVCoFIQQKhYI5V/1vZHPcsFd9Q2vlQECpRelzZbsla9LFXp0mABpxsXRNutgr92v191Pl96KhoYMmPVm/fj3Wr1/PNIpAIICjoyMAICAgAGFhYbhy5QoyMzOZc4KDg9GyZUukpqbixYsXjL19+/YIDAxEUlISSkpKGHv37t3h6+uL+Ph4lQ/uiIgI8Pl8xMbGqvgUHR0NkUiExMRExsblcjFkyBDk5ubizJkzjN3FxQX9+vVDVlYW0tPTGbuPjw969OiBO3fu4NatW4xdX02hoaG4evUqnJ2dIRQKrUKTodoJAHr16oXk5GSr0WSIdvL29kZ4eLhVaTKHduJyufD394dQKISDgwMIISrXACp2sJfJZCgtLWVsbDYbrq6ukEgkEIlEKjFwdnZGeXk5xGIxY7ezs4OjoyNEIhEkEgljt7e3B5/PR2lpqYqPfD4f9vb2KCkpUfmic3JyAo/Hw1tvvYU///yTsXt6eqJTp074+OOPERISwtg9PDzw77//ol+/fjppatu2LebMmYNp06bVmSa5XI7vvvsOf//9NzIzM+Hm5oZWrVphzpw5GDlyJNMex44dw8qVK3Hnzh14enpi8ODB+PbbbzU0KTfmBQBnZ2cEBwfjgw8+wKBBg+q8nYqLi1XirqwVpW53dXU1St+TSCTMHw3q7yd/f38YC/p4roYoH89lZ2cze8/Z6l/GlX1XKBSIi4tDZGSkSoExS9ZkiHaSSqUQCASIiorSmEK3VE3V2XXRpIxJZGQk+Hy+VWhSt9dEk0QigUAgwMCBA+Hg4FBjTeXl5cjKykLjxo2ZmV9LmJWJiYnB8+fPsW3bNgDA8+fP8fHHH+PKlSu4cuUK8+XM4XCwd+9eDB8+XCdNTZo0wbx58zBv3rw60VRYWIjevXujqKgIK1euROfOncHlcnHy5El8/fXXOH/+PNzc3FBeXg5vb2+8/vrr+PjjjyEUCnHu3Dm8++67GprYbDZ++eUXDB48GEVFRfjmm2+wY8cOHDlyBP3792f8sIWZpvLycjx8+BBNmzZl3ptKCgoK4OfnRx/PmSM8Hk9jU00OhwMOh6NxbFVVSquyV7VZpz52NputdRPHquxV+a6rJuWHOJfL1eqPJWp6lV0f31ksltVpqsquqyalD9akSUlNNCm/FHg8HnPNmmiSy+VgsVhgs9nMFxeLxUKppOIve0eeI2OTKqSQyqXgsrmw59oz9jJpGQCAz+Mz15ApZJDIJeCwOXDgvswlqXwsm1Xht1QuBY/D05prU1UODovFgoODA+rXrw8AqF+/PpYsWYLevXsjNzdXZWNapT59rq3teIVCgXfffRcJCQl49uwZAgICMGvWLMybN0/lOtu2bcO3336Lu3fvwtPTE6NHj8ZPP/2k9b7/+9//8PDhQ9y+fZvRAgAtW7bEhAkTmAGxcsD81ltvoXnz5gCAsLAwrb4DFTNv9evXR/369bFp0yb89ddfOHLkCAYMGKCirboYGMJe1ebA2o6tyl4bXyr3a/X3k7b3lqGgq+coBodu/6AdGhdNaEy0Y8y4OK92hvNqZ+SW5TK2r09/DefVzpgTO0flWN9vfOG82hmZRS8ffaw/vx7Oq50x9cBUlWMbf98YzqudcePFDca2I31Hrf0VCoX4448/EBQUBE9Pz1pfTxsKhQINGzbEnj17cP36dXzyySf48MMPsWfPHuaYjRs3Yvbs2Xj33Xdx9epVHDhwAEFBQVVe76+//sKECRNUBkxKlPlqAODg4IBBgwZh8eLFyM/P18tvHo8HLpdLC6HWIfQTq5ZU9ZeercLj8TBkyBBTu2F20LhoQmOiHRoX4NChQ3B2dgYAlJaWol69ejh06JDRBk08Hg8rVqxgfm/SpAlSUlKwZ88ejBkzBgDw+eefY9GiRSqP9zp37qz1erm5uSgoKEDLli1fee8VK1bg0qVLGD9+PPr06YOjR48yA605c+bg0aNHOHjwoMZ5YrEYX3/9NYqLixEdHV3lzI8tYszvZTpoqiXqz3VtHYVCgdzcXHh7e9M3cSVoXDShMdGOseMiXFaxQEP5eA4APgj/APO7zQeXrfqVkPN+DoCKR25KZneejXc6vAMOW/URyMN5DzWOndx+co18jIiIwMaNGwEA+fn52LBhA6KionD69Gk0a9asykdAtWHTpk3YunUrHj16xCRLt2/fHgCQk5ODp0+fon///jpdS/mI9VV+FhQUYPXq1di7dy8z8AkPD0d8fDyaN2+Oa9euISoqSuWc8ePHg8PhQCQSwc3NDV9//TUGDBigsqLQ1jHm9zL9pKolxlzaaInI5XKcOXOGxkUNGhdNaEy0Y+y4ONk5wcnOSeUL1o5jByc7JyafSf1YZY4SAPA4PDjZOankM1V3bI18dHJCUFAQgoKC0KVLF/zyyy8oLS3Fpk2bjLLH2p49e7BgwQK8/fbbiI+PR3p6OqZMmcKsMtN3A2UfHx94eHjgxo0b1R5369YtiMViJodp5cqVGD58OHr27Ik///wTZ8+exVtvvaVyztq1a5Geno7s7Gzk5+dj4cKFKC0tNUpcLBVjfqbQQROFQqFQzBplAnd5eblRrp+cnIwePXpg1qxZCAsLQ1BQEO7du8e87uLigsaNG+P48eM6XY/NZmPs2LH4448/8PTpU43Xlcv7GzRoAABISkpiXlu7di2GDh2KN998E9OnT2eOUeLv74+goCD4+vrWRCqlltDHcxQKhUIxK8RiMZ49ewag4hHWTz/9BKFQiMGDB6sc9+DBA5X6WAAQFBTE5EOp8+TJE43jAwICEBQUhJ07d+Lo0aNo0qQJfvvtN5w/fx5NmjRhjvv0008xY8YM+Pr6IioqCiUlJTh9+jTee+89rfdatWoVTpw4ga5du+KLL75Ap06dwOPxkJycjNWrV+P8+fNo1KgRxo0bh9mzZ0MsFiM8PBz379/HlStX4OTkhAMHDuCjjz6iAyQzgg6aagl9hqwKi8Vi6qhQXkLjogmNiXZoXIC4uDjUq1cPQMUsT8uWLbFnzx707t1bJS4LFy7UODcxMRF9+/bVet1vvvkG33zzjYpt+/btmDFjBtLT0zF27FiwWCyMHz8es2bNwpEjR5jjYmJiUF5ejrVr1+L9999naitVhYeHB86ePYsvv/wSn3/+OR49egQPDw+Ehobi66+/Zrbf+vXXX/H111/jiy++wKNHj9CgQQO89dZbTO2lYcOGITExscpHhOplJSjG/V6mxS1riLK4pTGKZ1EoFEptsba95yiUylTXv435/UxzmmoJXT2nikKhwKNHj2hc1KBx0YTGRDs0LtohhEAsFtOEZzVoXDShq+fMGLryRxW5XI709HQaFzVoXDShMdEOjYt2lJte08GBKjQumtDVcxQKhUKhUCgmhg6aKBQKhUKhUHSADppqCV2xoAqLxYKPjw+Nixo0LprQmGjH0HGxlsc2LBYLXC6X9hc1bDUu1fVrunrODKGr5ygUijkjl8tx584dODo60sEpxaoghODFixcoKytD8+bNweGobuljzO9nWqepltBkTVWUH9TaOrItQ+OiCY2JdgwVFw6Hg4YNG+Lx48d4+PCh4Rw0EYQQyGQym5xVqQ5bjQuLxULDhg21vkeM+b1sE4OmkSNH4sSJE+jfvz/++ecfldcOHTqERYsWQaFQYMmSJZg2bZpe16bLglVRKBS4desWmjVrRr8IK0HjogmNiXYMGRdnZ2c0b94cUqnUQN6ZDqlUiqSkJPTu3duou9hbGrYaFx6PV+X7w5jfyzYxaJo7dy7efvtt/Prrryp2mUyGhQsXIjExEa6urujQoQNGjRoFT09PE3lKoVAohoXD4VjFoJTD4UAmk8HBwcGmBgevgsalbrGJRPCIiAi4uLho2FNTU9GmTRs0aNAALi4uiI6OxtGjR03gIYVCoVAoFHPH5IOmpKQkDB06FPXr1weLxcL+/fs1jtmwYQNTKr1jx45ITk42yL2fPn2qsoN0w4YN8eTJE72uwWabPIRmBZvNRkBAAI2LGjQumtCYaIfGRTs0LtqhcdHEmLEw+eO50tJStGvXDlOmTMHo0aM1Xt+9ezfmz5+PDRs2IDw8HJs3b0ZUVBSuX7+OgIAAAEDHjh0hFos1zo2Pj0f9+vWrvLe2hYP6JtJZw7S3IeFwOAgLCzO1G2YHjYsmNCbaoXHRDo2LdmhcNDHm97LJB01RUVGIioqq8vXvvvsOU6dOZRK0161bh6NHj2Ljxo1YvXo1ACAtLa1G927QoIHKzNLjx4/RtWtXrceKxWKVgVlxcTGAik0DlbtPs9lscDgcyOVylUQ0pV0mk6kM1DgcDthsdpV29eRNLreiuWQymU52Ho8HhUKhspJAWdOjKntVvuuqCQCuXbuG1q1bq4z2LVmTIdpJLpfj+vXraNu2rUa8LFVTdXZdNMnlcmRkZCAkJAT29vZWoUndXhNNMpkMGRkZaNOmDezs7KxCkyHaSSwWM3HhcDhWockQ7SSVSnHlyhUmLtagqbbtJJFIYCxMPmiqDolEgrS0NCxdulTFHhkZiZSUlFpfv0uXLrh27RqePHkCV1dXxMbG4pNPPtF67OrVq7FixQoN+/Hjx+Ho6AgACAgIQFhYGK5cuYLMzEzmmODgYLRs2RKpqal48eIFY2/fvj0CAwORlJSEkpISxt69e3f4+voiPj5epaNFRESAz+cjNjZWxYfo6GiIRCIkJiYyNi6XiyFDhiA3Nxdnzpxh7C4uLujXrx+ysrKQnp7O2H18fNCjRw/cuXMHt27dYuz6agoNDUVmZiby8/MhFAqtQpOh2gkAGjdurPJ42dI1GaKdysvLER4eblWaDNFOjx8/tjpNQM3bSZlv+vjxY6vRZKh2evz4MRMXa9FUm3by9/eHsTCr4pYsFgv79u3DiBEjALzMOTp9+jR69OjBHLdq1Sr8+uuvKsGrjkGDBuHixYsoLS2Fp6cn9u3bh86dOwMADhw4gPfffx8KhQKLFy/Gu+++q/Ua2maaGjVqhOzsbHh5eQGwrZF8VZoUCgXi4uIQGRnJ+GXpmgzRTlKpFAKBAFFRURqPgC1VU3V2XTQpYxIZGQk+n28VmtTtNdEkkUggEAgwcOBAODg4WIUmQ7STSCRi4sLj8axCkyHaSSwWIy4ujomLNWiqbTsVFBTAz8/Pdotbqn/JEEL0yj2qbkXcsGHDMGzYsFdew97eHvb29jrfk0KhUCgUinVh1oMmb29vcDgcPHv2TMWek5MDPz8/k/i0fv16rF+/nhkFJyYm0sdzlTS1bdsWwcHBSElJoY/n1DQFBQWhrKwMJ0+etBpNhminS5cuWZ0mQ7STQCCwOk1AzdtJIBAwcbEWTYZop6dPn6rExRo01bad6tWrB2Nh1o/nAKBr167o2LEjNmzYwNhat26N4cOHM4ngpkC5t01ubi4z/WdL059UE9VENVFNVBPVZI6ahEIhPD09jfJ4zuSDJqFQiLt37wIAwsLC8N133yEiIgKenp4ICAjA7t27MXHiRGzatAndu3fHzz//jC1btiAjIwOBgYEm81s5aMrLy6MVxCshk8mQmpqKLl26qOQ02To0LprQmGiHxkU7NC7aoXHRJD8/H15eXtaZ03ThwgVEREQwvy9cuBAAEBMTgx07dmDs2LHIy8vDypUrkZ2djZCQEMTGxpp0wFQZiUTCjLhtaSRfXSL4ixcvIJVKrUaToRLBX7x4AYVCoXG8pWqqzq5rIriyr1iLJnV7TRPBX7x4AYlEAjabbRWaDNFOleNCCLEKTYZoJ7lcrhIXa9BU23ZSv5chMflMk6VROafp9u3b2LVrl0ZO06VLl7Q+M05JSdH6zDghIUHrM+PDhw/X+plxTk6O1mfGjx490vrM+ObNm1qfGeuqKTQ0FFevXoWzs7PWnCZL1GSodgKAXr16aS05YKmaDNFO3t7eCA8PtypN1thOVJN5arp//z6uXr1qVZpq207+/v7o1q2bdT6es1SUj+doyQFacoCWHKAlB2jJAVpygJYcMJ++Z8ySA3TQVEOUg6aCggK4u7ub2h2zQaFQICsrC40aNQKbTfdCUkLjogmNiXZoXLRD46IdGhdNCgsL4eHhQQdN5oRy0GSMRqFQKBQKhVIzjPn9bPJEcEtHJBLRvecq+U4IwalTp9CjRw9wOC83TbRkTYZoJ5lMhpSUFPTu3RvqWKqm6uy6aFLGJDw8HA4ODlahSd1eE01SqRQpKSno0aMH7O3trUKTIdqpvLyciQuXy7UKTYZoJ4lEguTkZCYu1qCptu1UefcOQ0MHTXqiXtwyISGBFrdUSwQvKSnB6dOnaXFLLYngJSUldO85NU1paWl07zktmuLj461OE1DzdoqPj2fiYi2aDNFOjx8/hlAoZOJiDZro3nNWCE0Ep4ngNBGcJoLTRHCaCF4bTTQR3PISwelMUy3h8Xjg8XgqNg6Ho/JoSknlQYQudvXr1sTOZrO1JgdWZa/Kd101Kd9IXC5Xqz+WqOlVdn18Z7FYVqepKruumpQ+WJMmJTXRpPyC4vF4zDUtXZM2aqpJ/TPXGjTpYq9Ok/KcyudZuqbatJO2YwwFTbWvJcZsHEuEw+Gge/fuNC5q0LhoQmOiHRoX7dC4aIfGRRNjxoI+nqshdPUchUKhUCjmB109Z8aUlZXR1XNqOU3Hjh1Dv379aE6TWk5TQkICIiMjaU5TpZymhIQE9O/fn+Y0qeU0JSQkoF+/fjSnqZLvIpGIiQvNaVLNaRIIBExcrEFTbdupvLwcxoIOmvREffVcYmIiXT2ntnpOuZScrp7TXD0nFArp6jk1TRcvXqSr57RoEggEVqcJqHk7CQQCJi7WoskQ7fTkyRPI5XImLtagia6es0Lo6jm6eo6unqOr5+jqObp6rjaa6Oo5unrO5qCr5+jqObp6jq6eo6vn6Oq56ux09Zz1rJ6jM001RDnTVFhYCDc3N1O7YzYQQlBSUgIXFxeNGRVbhsZFExoT7dC4aIfGRTs0LpoUFRXB3d3dKDNNtOQAxeAoE+MpqtC4aEJjoh0aF+3QuGiHxqXuoI/naolIJGISwW3pmTHNaaI5TdXZaU4TzWmiOU11t/cczWmie8+ZLXT1XPWaQkNDAYCunqOr5+jqObp6jq6eq6PVc5XjYg2a6Oo5K4SunqMzTXSmic406dtO/978Fzuv7MTgZoMxs+NMxh6yKQRgAXFvxsHPwa/iCzAIOHD3AHoF9sJbIW8xmv6+/jdcHVwRGRQJlkK1L1nz+4nONNHVc3T1nBVAV8/R1XN09RxdPadulyvkmPLfFFx+dhkJMQlwd3AHADwueYwjd4/A2c4Zc7vNBVCRyHsn/w4ICPh2fOa+GXkZ2Ja+DQooMLn9ZObaM4/MRLG4GIfGH8KQFkPqTJMSU7cTXT2naVeeQ1fPvfzdWNCZphpCV89phxACmUwGLpdLV3JUgsZFE2uJybH7x/BNyjdo49MG3w76lrEHrgtEZlEmkiYnoVdgLwBARk4GkjOT0bVBV4TVCwNQEYf0Z+kQSoTo1rAbuGwuZDIZzmefx4lHJxDqG4qhwUOZ67626zUUi4txYvIJsFkVXyxJj5Lg7uCOtn5t61B53WIt/cXQ0LhoYszVc3SmiWJwRCIRXFxcTO2G2UHjoomlxWTekXk4+egkdozYgfb+7QEAQokQR+8dxfPS5yrHru6/Go48R4T4hjC2Nr5t0Ma3jcpxLBaLGUABFV+CIpEI3Rt1R4+AHho+HHrzkMrvhBDMjp2NaznXsGvULowPHV9bmWaLpfWXuoLGpe6gJQdqifpzWltHJpMhMTGRxkUNGhdNzD0mQokQKVkpKrarOVdx+fllXMq+xNi6N+yOTUM2YfNrm1WOfTP0TYxoOQIefA+97qtvXEokJWjl3Qpu9m6Iah7F2B8XP4ZQIqzmTMvC3PuLqaBx0cSYsaAzTRQKhaLG7bzbCNscBg6Lg2fvP4Mjr2KF7NKeSzG/23x0b9idOdbP2Q/TO003latwtXfFnjf2oFhcDFf7l48i5sfNx7H7x7B12Fa83vp1k/lHoVgTdNBUS6RSKZP8bEurE6pbPafNF0vWZKjVc0DFoxT14y1VU3V2XVfPKc/l8Xgm0ySVSpH+PB0FogL0a9IPXC4XzTyawdfRF1w2F7df3EYbnzbg8XgY0GQAo0kqlRqlnZR+SqVSvTTx2XzmmNLyUmTkZKBIXIQg9yDGXiYuA4/NY3JfLKnvVY5LZbu1fEbURlPluFiLptq0U+VzDQ0dNOkJrdNUvabQ0FBwuVxap0mLJg6HQ+s0mWGdpo92fYRvHn2DRg6N8EPwDxgyZAhEIhE+afgJPLgeeHT+EZ5wn1hUnabj8cexquEq3Pa8jUfnH6FNdBuIRCJM3TUV6cXpeKv+W+jk0cmi+h6t00TrNNE6TRaMcvVcbm4uk51vSyN5qolqskRNReVF2HdrH5p5NENE0wgAQJ4wD803NEf/xv2x9bWtcHN0syhNurQHl8uFXCFH4+8b40nJE+wZvQcjgkdYvCZtdqqJahIKhfD09DTK6jk6aKohykFTQUEB3N3dTe2O2aBQKJCbmwtvb2+tdTZsFRoXTUwRk2XHluHL019iePBw7B+3n7GXy8rhwHWoEx9ehTHj8qL0BX6/8jvmdp0LDruils2fV/9EwoMELOi+AK19Whv0foaEvoe0Q+OiSWFhITw8POiGveaIMZ+dWiJyuRxnzpyhcVGDxkUTY8fk8rPLeC/2PWTkZDC2CW0noJV3K/QK6KVyrLkMmADjxsXHyQcLui9gBkyEEKxJWYOtl7biwK0DBr+fIaHvIe3QuGhCc5ooFApFT94XvI9j94+Bz+NjzcA1AIAQ3xBkzMqgRQAr8WPUj1h/fj3e7fguY7uYfRGPCh9hZKuRJvSMQjE/6EwThUKxeAghOHb/GERSEWP7qNdHeKP1G4huHq1yLB0wvYTFYqFnQE/8OfpPePI9Gfua02swas8o/HjuRxN6R6GYH3TQVEvoB7AqLBYLLi4uNC5q0LhoYsiYjPlnDAb+NhDbLm1jbH0b98WeN/agb+O+tb5+XWIOfaWRayO42LmgX5N+JvNBHXOIizlC46KJMWNBE8FriDIR3BiJZhQKpXrkCjnYLDbz4bg+dT0+EHyAj3t/jGW9lpnYO+vgcfFjNHRtyPyuIApmrzsKxZwx5vczfQfUksrLHCkV8Xj06BGNixo0LprUNCa/pv+K4J+CcfLRScY2tcNUPJz/0CoGTObSVyoPmG7n3UbIhhCce3zOZP6YS1zMDRoXTYwZC5oIXkvKy8tpRXC1iuDp6enw9fVl/LJ0TYaqCJ6eno569eppTB1bqqbq7LpWBFf2FT6fr7Omc4/P4V7BPfx47keENwiv8BscePO9GV8s+f0kkUiQnp4OHx8fODg4mLydAGCpYClu5N7Ahwkf4uibR1V8qau+V15ezsSFx+OZvJ3M5f2kfB8p42INmmrbThKJBMaCDpr0hFYEr15TaGgoANCK4Fo0AaAVwWtQEXy9YD18ynzgyKl4n41uOBotBrVAqDRUxR9z0mTqiuCG1jTGbgwUDRTYPGoz7t69SyuCm9H7iVYEpxXBLQLlM9Ps7Gx4eXkBsK2RfHUzTXFxcYiMjKQzTWozTQKBAFFRUXSmqdJMk0AgQGRkZJUzTSuSVuCzpM8wqe0kbH1tq9lrUrfXdKZJIBBg4MCBZjPTpE2T4L4A3Rt2h6uDa530PZFIxMSFzjS99F0sFiMuLo6JizVoqm07FRQUwM/Pzyg5TXSmqZbY2dmBx+Op2DgcDjgcjsaxlQcRutjVr1sTO5vN1loltip7Vb7rqkkmk2lMn9fU96rsda3pVXZdfGexWPDx8QGbzdZ6HUvU9Cr7qzQpY6I8V5vvA5sOxOpTq+Hv7A8Ol6OSiGyOmtSpaTv5+PjAzs6Ouaa5aTqVdQrD9wxHG582ODn5JNw4bkbve3Z2dkxcKp9rLZ8Rr7JX57u2uFiyptq2U1U+GwI601RD6Oo5CsXwyBQy3Mu/h2DvYMb2qPARAt0DTegVRZ2zj89i+F/D0SewD7YM3QI3BzdTu0ShMNDVc2YMLV2vilwux82bN2lc1KBx0UQ9Jtkl2ei1vRf6/toXL0pf5lbY2oDJEvpKt4bdcHXmVex+fXedDZgsIS6mgMZFE2PGgg6aagld5qmKQqHArVu3aFzUoHHRRD0m7g7uKBYXQyQV4fqL6yb2znRYSl/xdfJVyc+rXI3dGFhKXOoaGhdNaMkBCoVilYjkL79o+Tw+/n7jbzjxnGxudsmSkcgl+PD4hzhy9whSp6XCyc7J1C5RKEaDzjRRKBSTEH8/HrNuzMJfGX8xttY+remAycIoKi/Crqu7cP3FdRy8fdDU7lAoRoUOmmqJtgx/W4bNZiMgIIDGRQ0aF03OPjmLAlkBNqRtAF2P8hJL6ys+Tj7YNXoX9o3dh3Eh44x2H0uLS11B46KJMWNBV8/VELp6jkLRH0IIkwcjlUux7uw6zO4yG448RxN7RqFQrAW6es6MoSsWVJHL5bh06RKNixo0LsC2S9vw+t+vM7NKbLAxwHEA7Nn2JvbMvLD0vlIiLsGnJz6FRG7YrSwsPS7GgsZFE7p6zoyhKxZUUSgUyMzMpHFRw9bj8qDgAWYcmoG9N/bi8J3DAGhMqsKS40IIwaDfB2HFyRVYdsywmydbclyMCY2LJiZfPVdcXKz3hekjKwqFoqSJRxNsfm0zHhY+xJDmQ0ztDsVIsFgsLOu5DLNjZ2Nkq5GmdodCMTg6DZrc3d019suqDhaLhdu3b6Np06Y1dsxSkEqlzB48trS3T3V7z2nzxZI1GWrvOaDiL3H14y1VU3V2Ho+HZyXPIJfL4evkCwCYGDqR0SSTyZh7yGQy8Hg8i9BUF+2k9FMqlVqkpsFNB+Pa9Gtwsndi7mmIdqocl7rWpG43t75XOS7Woqk27WTMx3M612n6559/4Onp+crjCCGIjo6ulVPmzPr167F+/XqmURITE+HoWJHEaku7SFelqW3btggODkZKSgqEQqFVaDJUOwUFBaGsrAwnT560Gk1VtVPTLk0x6LdB4Mv5+CzoM9iz7avUdOnSJYvQVNftJBAIrEJT/Kl4lBeWg8Pi1KqdBAIBExdTazKnvvf06VOVuFiDptq2U7169WAsdFo916RJE1y4cAFeXl46XTQkJARHjhxBo0aNau2guaLMzs/NzWUeRdrSSJ5qopqqsz8ofoBuW7vBk++JuDfjEOgWaPGarLGdjK3pZOZJTPh3AqaGTcXy3sutQpM1tpO1aRIKhfD09DTK6jlacqCGKAdNeXl5Os3A2QoymQypqano0qWLUXeatjRsMS7nn5xHE48m8Hb01vq6LcZEF6wpLn9e/RNv7n0Tob6hOP/Oedhza75S0priYkhoXDTJz8+Hl5eXUQZNNY5w5Xortgwdc6pCCMGLFy9oXNSw9rgoiAIrT67E6FajEeoXCgDo3KBztedYe0xqijXFZXzoeEgVUrze+vVaDZgA64qLIaFx0cSYsahxyYH+/fsb0g8KhWLBrE5ejRUnV+C1P19DqaTU1O5QzIhJ7SbR4qUUq0Hnmaa3336b+T8hBDdv3jSKQxQKxfKY2Xkm/sr4Cx/0+IBu2Eqpkt3XdiO3LBezu8w2tSsUSo3QedCUkZGBWbNmMb+fO3fOKA5ZGhwOx9QumBUcDgft27encVHDGuNSIi6Bi70LAMCT74lL0y+By9b9ib81xsQQWGtcTjw8gXH/jgOXzUWvwF5o69dWr/OtNS61hcZFE2PGQudPuA4dOiAmJob5vfJyQFuGbpKoCpvNRmAg3aVeHWuLy/H7xzH2n7HYOXInoptXlBjRZ8AEWF9MDIW1xqVPYB+MbTMWzT2bo7VPa73Pt9a41BYaF02M+b2s85U3btyo8vvatWsN7owlor6M0taRyWRISEigcVHD2uKyO2M38kR5+DH1xxonXVpbTAyFtcaFxWJh1+hd+KzfZ3oPsAHrjUttoXHRxJix0LvnPn/+HH5+fsbwxSKhKxZUIYSgpKSExkUNa4vLT9E/oalHU8zvNr/Gq2itLSaGwprjwma9/DudEILrL66jjW8bnc615rjUBhoXTcxq9dwHH3xgDD8oFIqZoyAvi8fZceywtOdSOHAdTOgRxVIplZRixO4R6P5Ld+SV5ZnaHQpFZ/QeNNHRLIViexBCMPTPofgk8RNI5dJXn0ChVAOfx8ejwkcQyURIepRkancoFJ3R+/EcLWipCl2xoAqHw0H37t1pXNSw9LgI7gsQeycWiQ8SMandJAR5BtX6mpYeE2NhC3Fhs9j4Zdgv8HL0QmP3xjqdYwtxqQk0LpqYxeo5inbo6jlV2Gw2fH19Te2G2WHpcYlsFondr+9GibjEIAMmwPJjYixsJS4d63fU63hbiYu+0LhoYhar55TQx3OqqG9aaOtIpVIcPnyYxkUNa4jLmDZjMLXDVINdzxpiYgxsMS7ZJdmvzG2yxbjoAo2LJsaMhd6DpgULFhjDD4oVQZe+ascS43L07lGIpCKjXd8SY1IX2FJcNpzfgKY/NMUXyV+88lhbios+0LjUHXoPmjp06KBhKywsNIQvFArFjLjw9AKG7BqCDj93QL4o39TuUKyUZh7NUC4rx+Xnl1VWaFIo5ojeg6avvvoKu3fvZn4fM2YMvLy80KBBA1y+fNmgzlEoFNNRIi6Bj5MP2vq1hYeDh6ndoVgpkc0icWrKKRybeEyljhOFYo6wiJ5JSk2bNsXvv/+OHj16QCAQYMyYMdi9ezf27NmDzMxMxMfHG8tXs6K4uBhubm4oLCyEm5ubqd0xG5SF1lxcXOhKy0pYalzyyvLAYrHgyfc0+LUtNSbGhsZFOzQu2qFx0aSoqAju7u4oKiqCq6urQa+t97A+OzsbjRo1AgAcOnQIY8aMQWRkJBYvXozz588b1DlDMXLkSHh4eOD111/X6zVKzeDz+aZ2wSyxxLh4OXoZZcCkxBJjUhfYalykcilOZ56u8nVbjcuroHGpO/QeNHl4eCArKwsAEBcXhwEDBgCoGO3K5XLDemcg5s6di507d+r9mi7QBDxVZDIZYmNjaVzUsJS4CCVC9NnRp04KDlpKTOoaW41LXlkegn8KRsSvEXhU+EjjdVuNy6ugcdHEmLHQe9A0atQovPnmmxg4cCDy8vIQFRUFAEhPT0dQkGHqtxiaiIgIuLi46P0ahWJr7MnYg6RHSZjy3xTIFPRDmFJ3eDl6oYlHE3jwPXAn/46p3aFQtKL3oGnt2rWYM2cOWrduDYFAAGdnZwAVj+1mzZqltwNJSUkYOnQo6tevDxaLhf3792scs2HDBjRp0gQODg7o2LEjkpOT9b4PhUJ5NX0b98X/ev0PS8OX1mgnegqlNmwfvh33597HgKYDTO0KhaIVvT8VeTwe3n//fQ37/Pnza+RAaWkp2rVrhylTpmD06NEar+/evRvz58/Hhg0bEB4ejs2bNyMqKgrXr19HQEAAAKBjx44Qi8Ua58bHx6N+/fo18ksdsVisco/i4mIAFUW0lIW02Gw2OBwO5HI5FIqXS2eVdplMplIclMPhgM1mV2lXL9DF5VY0l/rUY1V2Ho8HhUKh8tiUxWKBy+VWaa/Kd101KY9R98WSNRminZTHEEI0jjcnTY3dGuOzfp+p9OuqNFVn10WT8voymQw8Hs8s2qm2mtTtNdGk9FMqlVqNJl3bKcAtoMq+VzkulqSpLtqpclysRVNt2smYqUIm/1MyKiqKecSnje+++w5Tp07FtGnTAADr1q3D0aNHsXHjRqxevRoAkJaWZnQ/V69ejRUrVmjYExMT4ejoCAAICAhAWFgYrly5gszMTOaY4OBgtGzZEqmpqXjx4gVjb9++PQIDA5GUlISSkhLG3r17d/j6+iI+Pl6lo0VERIDP5yM2NlbFh+joaIhEIiQmJjI2LpeLIUOGIDc3F2fOnGHsLi4u6NevH7KyspCens7YfXx80KNHD9y5cwe3bt1i7PpqateuHaKjo5GcnGw1mgzVTgMHDoRIJMKJEyesRpMh2unSpUtWp8kQ7SQQCKxOE6B7O90qvQV3rjvGDR4HPp8PgUDAxMVSNRmjnbKzs1XiYg2aattOhpos0YbeJQeMCYvFwr59+zBixAgAgEQigaOjI/7++2+MHDmSOW7evHlIT0/HyZMndb72iRMn8NNPP+Gff/7R6zUl2maaGjVqhBcvXjAlB2xpJF+VJjabjdLSUo3VHJasyRDtRAiBSCSCi4uLxl9B5qCJEIIvTn2BYcHD0KF+B53bozbtRAiBUCiEi4sLnWmqpEmhUEAoFMLZ2RlcLtcqNOnbTl+c+gIrklZgQsgE/DbqNwAVMynKuCh9sSRNurRHTTTJ5XIUFRUxcbEGTbVtp5KSEnh5eRml5ACIGQGA7Nu3j/n9yZMnBAA5ffq0ynFffPEFadGihc7XjYyMJN7e3oTP55MGDRqQ1NRUnV6rjqKiIgKA5Obm6uyHLSCRSMj+/fuJRCIxtStmhbnHJSUzheBTEKcvnIhQLKyTe5p7TEwFjQshF55cINyVXPLOgXeIXCEnhNC4VAWNiya5ubkEACkqKjL4tU3+eE4X1At2EUL0KuJ19OjRGr2mCzSnieY0WUNOE4/Fw+iWo+HB94CTnVOdtBPNaaI5TVVpauvTFvfm3EM953pggaXyvqE5TZqaKsfFWjRZfE5TYWEhzp07h0GDBgEA9u7di1GjRhnNMQDw9vYGh8PBs2fPVOw5OTnw8/Mz6r2rYv369Vi/fj3TKDSnSVVTaGgoACAlJQVCodAqNBmqnQBAKBSqrP40J00THSaiW9duAFCn7XTx4kWEh4ebTTuZS9+z9ZwmALiES4wmmtOkXdOTJ09U4mINmmrbTv7+/jAWOuc0RUVFQSaTwdfXF7///jvCw8ORkpJiWGfUcpoAoGvXrujYsSM2bNjA2Fq3bo3hw4czieCmQLmNSnZ2Nry8vADY1ki+upmmY8eOoV+/foxflq7JUDNNCQkJiIyM1JgltVRN1dl1nWlKSEhA//79wefzrUKTur0mmiQSCRISEtCvXz84ODhYhabatFO+OB9xd+PwRos3mLjweDyL1mTIdhKLxRAIBExcrEFTbdupoKAAfn5+Rslp0nnQFBYWhkuXLmH79u24e/cuEhMTDTJoEgqFuHv3LnOP7777DhEREfD09ERAQAB2796NiRMnYtOmTejevTt+/vlnbNmyBRkZGQgMDKz1/WuKctBklEQzCqWOIIRgc9pmjGkzxqjbpVAoNSG3LBdNvm8CoUSIKzOuINQv1NQuUSwAY34/6/x4ztvbGwAwZcoUzJs3Dzdv3jSIAxcuXEBERATz+8KFCwEAMTEx2LFjB8aOHYu8vDysXLkS2dnZCAkJQWxsrEkHTJURi8U0p6mS7ywWC/n5+XB3d1eZUbFkTYZoJ4VCgcLCQnh7e6vc09Sa4u/GY+bhmVieuBz337sPvh2/ztpJoVAgLy8P3t7esLOzM4t2qq0mdXtNNMnlcuTl5cHLyws8Hs8qNNW0ndx4bogOisaDwgcoEZXg6dOn8PLyApvNtlhNgGHbSSaTIScnh4mLNWiqbTup+2ZIdB40jRkzBlKpFDweD998843BdlPu27cvXjXZNWvWrBpVGzcG6jlNx44dozlNajlNV69ehbOzM81p0pLT1KtXL7PKabp65SoaOzRGiGMIjh09ZpJ28vb2pjlNVFOVmtZGrIW3qzeOHDmCF3h5HUvWZMh2yszMxNWrV61Kk1XkNFFUoTlNVec0xcXFITIykuY0qeU0CQQCREVFmV1Ok0KhQLmsHHwev85zmgQCASIjI2lOk1pOk0AgwMCBA2lOUyXfRSIRExea06Sa0xQXF8fExRo0mXNOk94lB1auXIlPPvnEoE5YMjweDzweT8XG4XDA4XA0jq08iNDFrn7dmtjZbDbYbM0tBquyV+W7rpoqLwfW5o8lanqVXR/fWSyWWWqys7N7pe/62nXVpPTBnNqpKntdtJPyC0r5aE5pr63vVdlN3fd08REAWBwWEvITUC+vHro06lLt8ZaiyVDtpDyn8nmWrqk27aTtGEOh96BJmbRNqUAmk9Gcpkq+E0K0Vr22ZE2GaCeZTMZsbm0OdZqeCJ8gLTsNrwW9Bjbr5YdTXbaTMiZyudzm6zSV5ZQhJzULRbefQvQkF+Jrt5G08TrYhIClICAyKYiDA9jubuB4uMDe3xNeHZrAp3MD8D1fVt83J02GbqcPj3+IHzJ/wM0TN3Fo3CGr0GSIdiKEwNnZmTnHGjTVtp3U80YNiUUUtzQn1HOaEhISaE6TmqZ+/fohISHBqjRZWzvtF+/Hjhs7MNhvMGbUm2FSTRcvXrSZdvLl+8DprgIP9ibA7noG6hXcR31xJnxJDtwq+SAHG8VwhZzFBQEbcrBhT8rhimJwoPqF8Izlj0zHZnjqFwy3iHAEjOmBq6U3wWK/fAxsTn2vpu0ULAyGB9cD/iJ/HD58GEOGDLF4TYbae04oFCI+Pt5qNNW2nRo0aABjoXdO06RJk7Bz505j+WMxKHOacnJy4O7uDsC2RvJVaWKxWHjy5Anq1atHV8+prZ7Lzs5Go0aNzGL13NdnvsY3Z77Bn6P+RL/G/WqkqTq7rqvnnjx5goYNG1rt6rm8u7m4/UsyyuOT4H8jCS1E6eBAATHscJ8fgtx6bSBt1BS84KZwa98MLi184NTIDcUoQaPARhqr54iCoDSnFMJHhci/lIXCS3chv/sQDvevo8HzSwiU3QcAPOYE4n6TCLBfG4yQ9wfBrb6bwTSZqp0kEgkeZj1E40aNwWbT1XOVV89lZmaiQYMGYLPp6jmg4vvZ29vbtHWalEycOBG//fabQZ2wRJSDptzcXCYRnFLx6Ck2NhbR0dFVPtu2RcwxLkKJEE48J4OthNUXc4yJIXhw9DYe/XgAHsn/IaQ4BRwo8ITTCA8C+oD06gO/oV3QeHBL2DnbaT2/NnEpfFCA29tOQXToOOrfOIbm4gyUwhFXGkSDPXECOnw8BDxHy4y1tfaX2kLjoomylIlZJIJ36tTJoA5QKBTT4GznbGoXrIZHx+/iwWe/o9GZ3WgmuQl/OOCK30CcHr4JTaYNQMOejdGAbfzBqXsTD3T5bCjw2dCXfn3zL/xO7kGrL0fi2Zp6uNljKoK/m456nRsa3R9jQAjB1edX0citEdwd3E3tDsXG0ExPfwXz5s0zhh8UCqUOuJl7Ezde3DC1G1ZB0aNCJI3fiKsuPRA4oDk6nPwO2Y264tyy/SAv8tD12QH03vkOGvVuopJfVJcE9g9C3yNL0KosDbf+uoTbrUagw6nv4dWlKZJavoOHgjsm8as2jPx7JNpuaov/bv5nalcoNkiNE8FzcnKQk5OjkZ/Rtm3bWjtlSdDVc5qr53x8fOjqOTXfZTIZU1XflKvnPkn4BH/f+Btf9f8Ki3suNmnfk8lk8PLysrjVczf+uojclZvR+dYf6AEJLvkMwunJfyDkwyHo6u3IaAVQI03KuMhkMoNqajGmHZqO+h4lTz/HqZlb0OboOnhHbkNys4kI3LmcmXky5/eTl5cX2vLbIvFhIp6WPAUhxGo+I6qzv2r1nLK/WIsmq1o9l5aWhpiYGNy4cYMJJIvFAiEELBZL48vS2qCr516tqUePHnT1nBlqysnJwdPsp2CDjTaObQDALDRZwuo5lowF75NlcNr+I9oJU/CUXR+H274Dhzn9MPSd4Xj06BFOpJ4wSDspNcXHxxtP0/SWOBuzCe7/Pkbrf1bAKXwPDrSKAVncD54BXmb5flKuDguRhWBH6x0Y2W0kSkpKbP4zIjs7G3l5eXT1nLmunmvbti2CgoKwZMkS+Pn5aSSRmsuecMZGmQj+/PlzeHh4ALCtkXxVmgDg3r17aNKkiUpxMkvWZIh2ksvlePDgAZo3b64Rr7rW9Fz4HPXd6pu878nlcty7dw9BQUGwt7c3i3ZSt4vyRbj43k4E7f0GDeWPcMm9L8qmzETY8tfAc+QZpZ1kMhnu3buHZs2awc7OzujtVJhZiIvjvkL3M+uQz/FB1oc/odvKYWb3fhKLxUxcOByO1X1GVGevTpNUKsXt27eZuFiDptq2U1FREXx8fIySCA6iJ87OzuTOnTv6nmZ1FBUVEQAkNzfX1K6YFRKJhOzfv59IJBJTu2JW0LhoYs4xKcoqIolRX5HnbD8iA5ucDhhHbu5Or5N7myoumSfvk/NekYQA5HTAOPLiek6d3v9VaIuLXCE3oUfmgTm/j0xFbm4uAUCKiooMfm29E8H79++Py5cvG3bkRqFQjEpmUSaKyotM7YbZU5ZbhhNRX0Ee0Bg9jvwPN5sPRVb8TfR49CeCx7QztXtGpVHvJuiYE4fTM35DcJYAspB2uPj1cVO7pZU7eXcw+PfB6LKly6sPplAMiN45TVu3bkVMTAyuXbuGkJAQjboQw4YNM5hzFArFMLx78F0kZyZj69CtGB863tTumB3SMinOTPsFLXavRLjiBVJC3kWLbcvQ20KX5dcUFpuF8I1v4fn0/njabyLaLx6IE/uWIvzYCrOq7+Tt6A3BfQEURIHMokwEuAWY2iWKjaD3oCklJQWnTp3CkSNHNF6zhURwdeRyOV09p5ajExAQAIVCoeK/JWsyVE5To0aNwGKx6nz1nEguQnZJNsQyMTr6d4RUKjWLvieXy9GwYUPGX1O0E1EQpMz/C402fYKesvtICRyP8l9WoHe/ZiorY3XVpG6viSZlXORyucnaya99PXg9i8OJ19agt+ATXK1/BvVP/wm/Nv4mez9Vjosz1xm/jvgVYf5h8Of7m6SdzOWzHAATF2vRVNt2Uv9OMiR6D5rmzp2LiRMn4uOPP4afn58xfDJr1FfPHT9+nK6eU9MUFhZGV89VoamsrMwkmja03YDzWedxI+UGbuCGWfU9sVhsknZq9MILnEXL0LP4FJLdBiJ5+lK49PBB196BZrEq6/HjxyZtpyfZT1Ayuw3+bLwOg7euhKhdN9zefRCKNjyTvJ+OHj3KxAUAxkaPhUgkUvkD3ho+I/Rtp6dPn+Lx48dMXKxBk1WtnnNxcUF6ejqaNWtmLJ8sArp6ruqZpmvXrqF169Z09ZzaTNP169fRtm1bk6+eM5Sm6uy6zjRlZGQgJCSkTlfP5V7PwZ0xy9Hz9jbcs2+NwuXfov37L/ffM3Xfk8lkyMjIQJs2bepk9Zwump6kPEL54NfRsPwuMj75Ex3+N1gvTYboe2KxmIkLXT2nunruypUrTFysQZM5r57Te6Zp1KhRSExMtPlBkxIOh6OR18XhcMDhcDSOVXYeXe1V7SOkj53NZqsMXl5lr8p3XTVJpVJkZmZqzXfT1/eq7HWt6VV2XX3PyspCaGhonWpKe5qG9v7tzbbvPX78mCmIa+x2YslZODXuR4T99ynasthIHv09wn+fCa6D7jGoi75HCGHiorymqdupcZ8glD46jWvt3kSHlaOQ+mIHwjdM0FmTNvTVxOFwmLgoj0nJSsG/1//FyFYj0TOgp16adPHdEj7LAWjEBbBsTbVtJ2Pup6n3oKlFixZYtmwZTp06pfULYO7cuQZzjkKh1JynJU/RY1sPBLoF4szUM/BytN2Npa//eh7sme+il+gKTrd+F232foY+wd6mdsuicPJ1QscH/+JM23fRa+NbOPk8D33+Ne3n/Y70HdhycQukCqnKoIlCMRY1Wj3n7OyMkydP4uTJkyqvsVgsOmiiUMyEaznX4MRzgp+zn80OmITPhEiL/hg9L/2AO/y2uPXrOfSeRDcdrylcBy563vwFJ7p5o+/eeTgRKUTf+A9N5s8brd+AVCFFdPNok/lAsS30HjQ9ePDAGH5YLFVNl9oqbDYbwcHBNC5qmCIukc0ikbkgE8+Fz+vsnvpg7Jic//Qw6n8+E53luUge8hV6/jO/ykdx5oS5v4dYbBb6pq7BiX7O6Cv4CCeG8ND38AdGv6+2uAxsNhADmw00+r3NGXPvL6bAmLHQOxGcUoEyEdwoZdopFEqNKXxQgIx+7yH84R+44DUIfns3olHvJqZ2yyo50etj9D31OU6OXIc+e+eZ2h0KBYBxv5/1/rPr9ddfR6dOnbB06VIV+9dff43U1FT8/fffBnPOEhCJRODz+QBsa3VCVZoIIbhw4QI6dOigkphnyZoM0U4ymQwXL15Ely6aFYwNrUkoFuJewT2E+oaadd+TyWRIS0tDp06d4ODgYJB2Svv8KBqumIY2pAxJ7+xAtx/Hg8ur8NFS+p5UKkVaWho6duwIe3t7k7dTdZp6HPsYib3EiNg3H0kxjui+dbJWTYboe+Xl5UxcuFyuiqZsYTbSn6UjKijKYj8jqrNXp0kikSA1NZWJizVoqm07icViGAu9Z5p8fHyQkJCA0NBQFfvVq1cxYMAAPH9uno8CDEXlOk23b9/Grl27NOo0Xbp0SWsdjJSUFK11MKqqaXT48OFa18HIycnRWgfj0aNHWutg3Lx5U2sdDF01hYaG4urVq3B2doZQKLQKTYZqJwDo1asXkpOTjappY9pGbHmyBVHeUfiu/3dm3/e8vb0RHh5eq3aS5kvg+UUs+t3bgRS3/sj8eAr4Qc4m02Rufc+Ymho1bAThpC3ocX0L/hy/Bq5jm9Wppt1Hd+Pd6++Cy+JiV/tdeGPYGzbVTvfv38fVq1etSlNt28nf3x/dunUzykyT3oMmPp+P9PR0BAcHq9hv3ryJsLAwiEQigzporiin/7Kzs+HlVZFka0sj+ao0KRQKxMXFITIyUmWpqiVrMkQ7SaVSCAQCREVFaSyHNbSmhUcX4sfzP+LHwT9iRqcZZtv3lDGJjIwEn8+vcTtd+TEZvkumwkP2AhcnfIfu26YAlUJsaX1PIpFAIBBg4MCBcHBwMHk76aKJSAnSGo9Cm+cJeLDjOFq+2cHg7yeRSMTEhcfjqWhqs6kNXO1dsX3odoTWC7XIz4jq7NW1k1gsRlxcHBMXa9BU23YqKCiAn5+feTyeCwkJwe7du/HJJ5+o2P/66y+0bt3aYI5ZCjwej9ZpqoTyjcTlcmmdJi12FotldE3fR3+P2V1no5FrI+YYc+57Sh/0bSdFuQIp/T9G39Q1SHfrDbL/OHr3barVP319r8peV3WalPc3lzpNr/SdA4Rc+RMPmvaD39vD8TzoHBqGB1bre001qX/m8ng8XJ5xGXwe37CaqrGb2/tJeQ6t0/Tyd2Oh96Dp448/xujRo3Hv3j3061dRRff48eP4888/bS6fCTBu41giHA4H7du3p3FRo67j0sKrRZ3cpzbUJiaZJ+6j5LVxCC+9hBPRa9D7v0Vgc61j9ZClvoecfJ3gd+4gRO27oWzgCJRlnoajt6PBrl9dXCoPmGwNS+0vxsSYsajR6rnDhw9j1apVSE9PB5/PR9u2bbF8+XL06dPHGD6aJXT1HMXcuJV7C75OvvDge5jaFaOS8t6fCPlpOgq4Pijd+hdax3Q2tUuUStzacxmNxnbHpcaj0OPeb2CxjVedWR0FUUAsE9v0IIpi3O/nGv1pNmTIEJw+fRqlpaXIzc1FQkKCTQ2YKqP+nNbWkclkSEhIoHFRw9hxIYRg8n+TEbguEEfuHHn1CWaAvjERPhMiucXb6PHTm7gaOBQeDy5Z5YDJ0t9DwWPaIf29bQh/+AdOjlpnsOu+Ki4/nPsB/t/447sz3xnsnpaApfcXY2DMWFjHfLYJoWWuVCGEoKSkhMZFDWPHJV+UD6FECIlcgrB6YUa5h6HRJya3/7mCnMBOCLuzB6em7UCP+7/DtaF1zvBaw3uoxw/jcKLT++j53wdI//7kq0/QgVfFxYHrgBdlL5D4MFHr69aKNfQXQ2PMWJh/eVwKhfJKvBy9cGXGFWS8yIC/s7+p3TEop2b8hg6bpyPLoTlyYtPQMyr41SdRTE7P5NW45p8K30VvIT86HZ7NjbuVz8iWI9HCqwXCG4Ub9T4U24bONFEoVgKLxUKIb4ip3TAY4mIxktrMRM/Nk3Cx2Rg0yjqDpnTAZDFwHbjwE/wBB0UZ7vSeCqIw7kyIj5MP+jbuCx5H++otCsUQ0G1Uaogy0SwnJwfu7u4AbKsORlWaWCwW8vPz4e7urlKPyJI1GaKdFAoFCgsL4e3trXJPQ2hKfZKKLg27gMflWVTfUygUyMvLg7e3N+zs7FR8f3o2EyVRb6J5aTrOvvk9um97m0koNmdN6vaa9D25XI68vDx4eXkxZQcsWdOZpfvQ/atROPHGjwj/Y3qN20kikTBxYbPZJm8nc+l7MpkMOTk5TFysQVNt26m4uBje3t7mUafJ1qlcERwAjh07plER/MqVK1orrqampmqtuJqUlKS14mp8fHytK67m5uZqrbialZWlteLqnTt3tFZc1VdTVVVkLVmTIdqptLTUoJqyxdmYfWM2ApwDcPW9q7iTccfi+17xP/cR/ccXYLOdcO/X03AN5eBI3MvkdkvUpMQWPyPIMD8c/GsiBv79PvYEOaLn9P410hQXF/dKTTKWDPe87kFwR4CZ7jPBYXGsvp2ePHlidZpq204NGjSAsdB7pmnhwoXaL8RiwcHBAUFBQRg+fDg8PT0N4qC5QiuCV10R/NixY+jXrx+tCK5WETwhIQGRkZEGrQh+8PZBvH3wbfRo1AOxE2Itqu8pY9K/f3/w+XzIpDIkDV6NvgnLcdFrIAJP/Qaflr4WpUndXtOK4AkJCejXr5/FVAR/lSZRgQjPG3aFmOuE5i9Ow87RrkYVwZVxUa8IrkSmkKH+uvooLC9E0qQkdGvYzWiazKXvicViCAQCJi7WoMmqKoJfunQJFy9ehFwuR3BwMAghuHPnDjgcDlq2bIkNGzZg0aJFOHXqlE1UCKcVwTUrgstkMloRXItdLpcbvCL4qDajMCBoAApEBSp2XX03dd+Ty+XgcrkozSnFlY5T0O/x3zjR+xP0EnwCjh3HIjVVpqYVweVyuWVVBK/GzuVy4eLjgkcbtqPVtB5IHvUd+sYtrZEmZVzUK4Iz/wcPy3ougxPPCcG+wRrXMvfPiOrs1bWTtrhYuiZzrQiudyL48OHDMWDAADx9+hRpaWm4ePEinjx5goEDB2L8+PF48uQJevfujQULFhjDXwqFooarvSsC3QNN7UaNeXImE5mNeyH0cSzOLt6LvidXMAMmivUQMrUrkru8j+5Hl+PugetGu8/i8MWY3WU2fJ18jXYPiu2i96Dp66+/xmeffaYy5eXq6opPP/0Ua9asgaOjIz755BOkpaUZ1FEKhfKSwvJCZORkmNqNWlMU+wROfXvARZKPp3+noNtXI03tEsWIdDu6Ao/tmkL85mTIymkxRorlofegqaioCDk5ORr2Fy9eoLi4GADg7u4OiURSe+8sgKqmLm0VLpeLiIgIGhc1DB2X9anrEbIxBB/Ef2CQ65mClGk7Me7n+Xji2hL8a+fR4vW2pnbJLLDm95CDuwNE67ejVekFnH5zvV7n6hOXMmkZDt0+hNOZp2vqqsVgzf2lphgzFjV6PPf2229j3759ePz4MZ48eYJ9+/Zh6tSpGDFiBAAgNTUVLVqY/4ahFOPA59N9n7RhyLhkFmWCBRba+7c32DXrCqlIhsT289Fn5zScbTUFrR/Hw6ulj6ndMius+T0UMq0bTrWZgbB9H+N5erZe5+oal29SvsHQP4fi2zPf1sRFi8Oa+4u5ofegafPmzejfvz/GjRuHwMBABAQEYNy4cejfvz82bdoEAGjZsiW2bt1qcGfNEbrfjyoymQyxsbE0LmoYOi6bh27Gjdk3MDZkrEGuV1cUPSrElYbR6HX5J5wY8xMKVkeDZU9r7FbGFt5DbQ9+ATHLAXdHLNL5HH3iEt08GgFuAQjyDKqNmxaBLfQXfTFmLPSaw5LL5UhLS8NXX32FtWvX4v79+yCEoFmzZnB2dmaOa9++vaH9pFAoagR7W1Z17MenH6G8fzSaiZ/i6jfxCJ/bS6OmC8U2cG/igVNTv0bPrZNx8eup6PBBf4Nev2O9jng476FGeQ8Kpbbo9Sceh8PBoEGDUFRUBGdnZ7Rt2xbt2rVTGTBRKBTjcS3nGorKi0ztht5c33kBdr27gicvR+7BMwhb1M/ULlFMTPjmSbjs2gvu/5sNidCwObAsFosOmChGQe958dDQUNy/f98YvlAolGpQEAXG/TMOAesCcOLhCVO7ozNnl/2HxjG98dyxCfjpZxH0WktTu0QxA1hsFhx3bECg5A5S3tIvKVwfsoqyjHZtiu2hd0Xw+Ph4LFmyBJ999hk6duwIJycnldcNXX3TXFFWBC8sLISbm5up3TEbCCFMcUv6l95LDBGXpyVPMfC3gXhc/BiZ8zPh5mDe/Y4Q4OSo79F7/wKcazAa7a/sBN+TX+l12le0YWtxSWo9A6E39wB37sKjWdU7SegbF5lChrDNYbiWcw2PFzxGA1fjba1hSmytv+hCUVER3N3djVIRXO+ZpsGDB+Py5csYNmwYGjZsCA8PD3h4eMDd3R0eHh4GdY5imYhEIlO7YJbUNi71Xerj6syrODftnNkPmGRiOU62m4u+++cjqcsH6Ppwt8qASQntK9qxpbi02rMCXCLFlTc+e+Wx+sSFy+aCzar4ist4Yfk1zarDlvqLqdG7mEHlTfcoFZ1VuWGvLe3tU93ec4mJiYiMjKR7z6ntPZeYmIioqKha7z3X0rulWWiqyl6WW4abYRPR83ksTo5fj/Bf34GcyKGQKTT2nlP2FT6fb9aagLrdey4xMREDBw60mr3nqmsn92BPJPdfgp7HV+LR8dmo31u1un3lveeUcalq7zl1TX+M+AP+Tv5w57sDgFl/RlRnr66dKvcXuvdcBWKxGMZC70FTnz59jOGHxbB+/XqsX7+eadDExERm0GRLu0hXpSk0NBQAkJKSAqFQaBWaDNVOACAUCpGcnKy3pvtl99GY3xh+vn5mpUm9ncqfiBC86Fu0Kb+BU0v+QlF3HnNOVe108eJFhIeHm60mfdpJiSH6nkAgsDpNgPZ2kk1uidxEP2RPWoJrP7+tVZNAIGDioo+me7hnMZ8RNWmnJ0+eqMTFGjTVtp38/f1hLPTOaQKA5ORkbN68Gffv38fff/+NBg0a4LfffkOTJk3Qs2dPY/hpdihzmrKzs+Hl5QXAtkby1c00xcXF0ZkmaM40CQSCGs003c+/j+ANwWju2RwpU1Lg6eRpFprU7U/OZEI+8DW4SvOQsz0WrSZ2qLadlDGhM02aM00CgcBmZpqUnJ29C722TEb6hiS0mdZNw3eRSMTERdeZJlNrqot2EovFiIuLozNNlewFBQXw8/MzSk6T3jNN//77LyZOnIgJEybg4sWLzDRYSUkJVq1aZXN1V9R3lgZsYxdpJeq+S6VScLlccLlcrf5YoqZX2XX1XZmoqa+mG3k34GznjAauDeDp5Fmt76bqew8O3YbL64MgY/NQevQ02gxszvivTZPSruwr1flua+8nQgjz/qkcp9r6XpXdXN5P4Rsm4s7ObyD/30rwZgq0+q6MS2Udr9K08fxGJGcm47OIz9DMs5lZf0ZUZ6+unbTFxdI11aadtB1jKPSeaQoLC8OCBQswadIkuLi44PLly2jatCnS09MxePBgPHv2zFi+mhXKmSZjjGQpFHVKxCV4UfYCTT2amtoVDS79dBpN3nsNzx0C4XH2CHzb1TO1SxQL5ezivej29WikrzuB9vMMkwoSvi0cKVkp+G3kb3ir7VsGuSbFvDHm97Peq+du3bqF3r17a9hdXV1RWFhoCJ8sispTgpSKeOTk5NC4qFHbuLjYu5jlgCll2UG0fG8AHrq3Q73bJ/UaMNG+oh1bjkvXL0fiBj8MrE8+BlGo/j1f07hMDZuKzyM+R8d6HQ3pqtlgy/2lKowZC70HTfXq1cPdu3c17KdOnULTpub3oW5sKj93pVTE48yZMzQuatQkLgqiwL38e0b0qnYkvLUNXb4ciSsNh6DVwzi4NtKvDALtK9qx5biw2CwIF3+GdsXJuLjmmMprNY3L22Fv46PeH6GVTytDumo22HJ/qQpjxkLvQdP06dMxb948nDt3DiwWC0+fPsUff/yB999/H7NmzTKGjxSKTXL07lE0/7E5Ju6baGpXVCAEOD7wS/T7YyrOhb6Dzvd3w97NwdRuUayETp9E45pTV9h/rjnbRKGYGr0HTYsXL8aIESMQEREBoVCI3r17Y9q0aZg+fTrmzJljDB8pFJvk3JNzICDwc/IztSsMCjlBQpel6H9sGZL7LUeP9A1g84yXdEmxPVhsFsT/+wwhpedw8SvNhPCaUC4rx9nHZ/FMaBs5txTjofegCQC++OIL5ObmIjU1FWfPnsWLFy/w2WevruZqjdCy9aqwWCy4uLjQuKhRk7h82vdT3JpzC4u6LzKiZ7ojkyhwImQ2+l/4CqdGr0Wv45+Cxa55O9O+oh0aF6DD4gG47tgJ7DWrGVtt4jJy90h0/6U79t/cb0AvzQPaXzQxZixqVKeJQlfPUWwLcakMZ1u/jV6Zv+Pc1C3ovnWqqV2iWDnKlXTXtpxBSKW6TTXh44SPsTltMz7s9SHmd5tvGAcpZovJV8+NGjUKxcXFOl90woQJyMnJqbFTlgRdsaCKQqHAo0ePaFzU0CcuJeISCCXCVx5XV5Tmi3G+6Rj0yPwTF9//02ADJtpXtEPjUkGXVSNwz64lSj+umG2qTVw+7vMxnr//3CoHTLS/aGLy1XP//fcfXrx4geLi4lf+FBUV4eDBgypbaFgzdMWCKnK5HOnp6TQuaugTlx9Tf0TD7xrip9Sf6sCz6il8WoZrzYahU04srn+xH52+Hmuwa9O+oh0alwrYXDayJy5B12cHcGfftVrFxY5jZ7WPr2h/0cSYsdCpIjghBC1atDCaExQK5SWC+wIUiYvgZq/fEn5Dk3O3GI/bD0Gb0kt4sP4I2s2KMKk/FNujy7o38WTHJ3i+6Cs0fm2bqd2hUHQbNFXeaE9XGjRooPc5FAoFOD7pOOLuxmFA0wEm8yHrWhHyOg9CU/EtPP/9GFpNqF1OCYVSE+yc7XB3+PsI37sQj1OW1+pav1z8BZvTNmNC6ATM6zbPQB5SbA2dBk19+himnL01Yq1TvjWFxWLBx8eHxkUNfeLCZrER3Ty6DrzSzsP0QhR2HYTGsjso2XcMzYYbp5Iy7SvaoXFRpeP6t1G69xM8eH8zfL4fWeO45InycP7peQS6B1rVoIn2F03o6jkzhK6eoxiaYnExXOxMu3T4XlohSrpHorH8LsoPHoN/dAeT+UKhKDnR+QO0T9sK3rPHcPJ1qtE17uTdQVp2Gro17IbG7o0N6yDFrDD56jlK1dDkO1Xkcjlu3rxJ46KGLnGZdmAaQjeGIulRUh169pJbZwtQ0m0gGsvvQXrkuNEHTLSvaIfGRZOgdXPgQoqROOWnGseluVdzjAsZZ3UDJtpfNDGrbVQoqtBlnqooFArcunWLxkWNV8WlRFwCwX0BMl5kwMPBo469AzJOF0DUayAak/uQxx+HT2SY0e9J+4p2aFw0aRgeiNT6IxAcvw0yiczU7pgVtL9oYvKSAxQKxbi42Lvg4byH+Gv0Xwj1C63Te6cnFUPcZxACyUOQYwnw6t++Tu9PoeiC/eL30Fx2G+lqG/nqw5PiJ/jjyh84cueIAT2j2BI1GjQ9fvwYv/76K/bu3YsXL14Y2ieDM3LkSHh4eOD1119XsWdlZaFv375o3bo12rZti7///ttEHlIogJuDG8aGGK4Oki5cSCpDab+haI7b4BwXwKNvuzq9P4WiKyEzeuCaXTtwfvyhxtf479Z/eGvfW/ghtebXoNg2eg+apk+fjqZNm+KDDz7AxIkT0bRpU6xatcoYvhmMuXPnYufOnRp2LpeLdevW4fr16zh27BgWLFiA0tJSva7NZtPJusqw2WwEBATQuKhRXVzKZeUm8AhIOSFBfr/X0YFcAPtILFz7GP+RXGVoX9EOjYt2OFwO7r02CZ3y4vHg6O0aXaN7w+7o3rA7utTvYmDvTAftL5oYMxZ6X1mhUODGjRvIyclBUVERNm7ciA0bNmDQoEEoKioyho+1JiIiAi4uLhr2evXqoX379gAAX19feHp6Ij8/X69rczh0h/fKcDgchIWF0bioUVVcFESBDps7YOTukcgqyqozf04cl+PZgLfQV3Ec2LcfTgN71Nm9ldC+oh0aF+1wOBwM+mUW8lmeePS/LTW6Rli9MKRMTcGKiBUG9s500P6iiTFjofegacuWLWjWrBmAipmat956CxkZGVAoFDWq55SUlIShQ4eifv36YLFY2L9/v8YxGzZsQJMmTeDg4ICOHTsiOTlZ7/u8igsXLkChUKBRo0Z6nUdXLKgil8tx6dIlGhc1qorL+SfncSP3BhIfJMKDXzcJ4McEBPcHzcRwxV6QP3eDP2xgndxXHdpXtEPjoh25XI4bD27gSvtJCEnbAXGx2NQumQW0v2hi8m1UquL27duIjY3F4cOHkZSUVKP6MqWlpWjXrh2mTJmC0aNHa7y+e/duzJ8/Hxs2bEB4eDg2b96MqKgoXL9+HQEBAQCAjh07QizWfAPFx8ejfv36r/QhLy8PkyZNwtatW6s8RiwWq9xDuYGxWCyGVCoFUDElyOFwIJfLVbL3lXaZTIbKZbE4HA7YbHaVduV1lXC5Fc0lk8l0svN4PCgUCpUOxGKxwOVyq7RX5buumhQKBTIzM9GyZUvGL0vXZIh2kkqlyMzMRJs2bVTu2cGvAzJmZSAjJwP2LHvmWsbSJBCwcG7Yl1gh3wLJlh3gjH5Nxf+6bCdlTFq2bAk+n28W7VRbTer2mmiSSCTIzMxEcHAwHBwcrEKTIdpJLBYjMzMTzf8XA+/R63D6w3/R48fxNdJECEGRuAgefA+z+Yyozl6dJplMxvQXHo9n8nYyh76n7psh0XvQFB8fj8OHDyM2Nhb379+Hv78/Bg8ejF27diEyMlJvB6KiohAVFVXl69999x2mTp2KadOmAQDWrVuHo0ePYuPGjVi9umL367S0NL3vq0QsFmPkyJFYtmwZevSo+hHF6tWrsWKF5pRuYmIiHB0dAQABAQEICwvDlStXkJmZyRwTHByMli1bIjU1VSVxvn379ggMDERSUhJKSkoYe/fu3eHr64v4+HiVjhYREQE+n4/Y2FgVH6KjoyESiVS2u+FyuRgyZAhyc3Nx5swZxu7i4oJ+/fohKysL6enpjN3Hxwc9evTAnTt3cOvWLcaur6bQ0IqVXykpKSqbNluyJkO1EwAIhUKVmVKlJm/irXK8MTQJBMC9z+5jp/xj5L63AN7TYpCQkGDyvnfx4kWEh4ebTTuZS98TCARWpwmoeTsJBAIAwB3OI5Q69oDj7z+jZNVremv6NflXfPPwGzR0aIitPbaa1WdETdrpyZMnAMDEx9TtZA59z9/fH8ZC74rgPB4PXbp0QXR0NKKjoxEWZrjkURaLhX379mHEiBEAAIlEAkdHR/z9998YOXIkc9y8efOQnp6OkydP6nztEydO4KeffsI///zD2AghePPNNxEcHIxPP/202vO1zTQ1atQI2dnZ8PLyAmBbI/nqZpri4uIQGRlJZ5rUZpoEAgGioqKYGVm5Qg4Om1MnmuLj5Vgz9BSOSCOB8WPB2bkd7Gq01tVMk0AgQGRkJJ1pUptpEggEGDhwIJ1pquS7SCRi4pL2/l702jgR9w5dR0BkkF6aMp5noO3PbeHh4IFnC5/Bjmdn0X1PLBYjLi4OAwcOpDNN/09BQQH8/PyMs2MH0ZP8/Hydjtu1axcRCoV6XRsA2bdvH/P7kydPCABy+vRpleO++OIL0qJFC52vGxkZSby9vQmfzycNGjQgqamphBBCkpOTCYvFIu3atWN+rly5otM1i4qKCACd42EryGQycuPGDSKTyUztilmhHpfc0lzS4NsGZIlgCRHLxEa99/HjhDS3f0QKed5E1ieCELFx76crtK9oh8ZFO5XjUl5UTl6wvElihwV6X0eukJPUx6lGf9/VFbS/aJKfn08AkKKiIoNfW+/Hcx4euiWrTp8+HV27dkXTpk31vYUG6rlShBC98qeOHj2q1d6zZ89aVw5VKBQ0p0nN95YtW0Imk5ksV8YYmgzRTsHBwQAqZp12pu/Ek5IniL8Xj9X9VxtN08mTbLwxVIqz9q/Dxd0J8r92QcFigaNQmEXfa9asGXN/c2knc+h7zZo1g0KhAIvFshpN6r7rq0mhUDBxYfPZuNYxBm3TtkOYtxL2rvZ6aWrv2x5QADIiM6vPiJq0E4vFYuKi7DOWrqm2fc+Y1CoRvDoqB7mmeHt7g8Ph4NmzZyr2nJwc+Pn51fr6NWH9+vVYv34906Dx8fE0p0ktp+nZs2cQiUQ0p0lNk5eXF9q0aYOkpCQEkkB82ORD8Ll8sFgsvHjxwuCarl71whdf9MA/3vMQ9Pwykj5ZhaJz5wyqyRDt5O3tTXOaqCa9NbX6ZDI8h32L36f+CJcpra1CU03a6eHDh7h69apVaaptO9WrVw/GQu+cJl1xcXHB5cuX9ZppUs9pAoCuXbuiY8eO2LBhA2Nr3bo1hg8fziSCmwLlLso0p4nmNNU0p8mYmpKTWRg6lINlTXfjf9fGQ755MxRTphhUU3V2mtNEc5qMmdPE4/HA5XKR4dIdpU7e6PB4n16angmfYculLcgT5WH9kPUW3fdoTlPd5jQZbaZJV4RCIe7evcv8/uDBA6Snp8PT0xMBAQFYuHAhJk6ciE6dOqF79+74+eefkZmZiRkzZpjQ65fweDzweDwVG4fDAYejWVyr8iBCF7v6dWtiZ7PZYLM1y3FVZa/Kd101Kd9IXC5Xqz+WqOlVdn01KafUK2NITSkpHAwbBgzt8AQfZcwCxo4F5513wNHySNsc+p7SB3NrJ1P1PeUXFI/HY65p6Zq0UVNNlT9z84fGoMdf76HgVj58Ql4+fXilJjbwWfJn4LA4+DryazjyHC267ynPqXyeqdtJF7ux+p62YwyFyQdNFy5cQEREBPP7woULAQAxMTHYsWMHxo4di7y8PKxcuRLZ2dkICQlBbGwsAgMDTeWyClKplOY0qc00afPFkjUZaqYJAM48PoP3jr6Hhd0WYkLIBINrOnlSjiFD2OjSWYHfOG8DfD6wYQNkcrnZ9T3lPWQyGXg8nlm0U201qdtroknpp1QqtRpNhminynFR2kM+GwP5X/Nxbdlv6Ll3ns6a/Ph+mN5hOlp6t4SCKCy+71WOi6nbyRz6XuVzDY3JB019+/Z9Zf7TrFmzMGvWrDryqHrUc5ponSZVTW3btkX79u1pnSYtmkJDQ7Hs/DJczbmK30/9Do9MD4NqKisLQ3Q00KxZLtYEfQre1nhkbdmCRp6eSE1JMdu+d+nSJbNqJ3Ppe7ROk6omZR0i5b/R0dHg+vJwyisS9Y/uQGxsc700RSEKPsQHznbOuHnzpsX2vadPn6rExdTtZA59T5ei1jXFaDlNISEhOHLkiN7bklgKypym3Nxc5pmpLY3kqaaaaSoQFeDntJ8xqOkghPiGGEzT+fNsDB7MQYcOBP9teQrXLiEgI0eCbNlC24lqsmpN5z45iG6fD8e131MRPKa9VWiyxnaqS01CoRCenp5GyWnSedC0bds2TJgwAfb29q8+2AZQDpry8vLg6elpanfMBplMhqSkJPTu3bvKZ+G2iDHjcvEi0K8fEBoKxMUBTu+9DezfD9y+DXh7G/RehoT2Fe3QuGinqrjIymXId2qIG23Hoc+ldXpdM1+Uj6vPr6JP4z4G9rbuoP1Fk/z8fHh5eRll0KTzhr3vvPMOioqKmN/r16+Phw8fGtQZS8RIE3UWCyEEJSUlNC5qGCsu164BkZFAcDBw+DDgdO0csH07sGqVWQ+YANpXqoLGRTtVxYXrwMX1sAlofXkXpGW67zlWVF4E7zXe6PtrX+SL8g3sbd1B+4smxoyFzsNSdSdKSkrqrJiUOUMTwWkiuC6afrn4C357+Bu8n3ijS4MuBtF044YC/ftz0bAhcPiwAq6uHJBly4A2bSCbPBmQSs2679FEcJoIXttEcKUm73lj4TPpO5z7RoCun0TrpMmR44ggzyAQEDwqeAQXrkuda6KJ4DQR3OqhieDVa6Ib9mpqIoTgy1tf4lH5IyTeS0Tu5dxaa0pIeIjx4+vD0VGEhQtPIyvLH95XCsBKTMS5pUvx7P+r4FtC36Mb9tJEcF00aUsEV2oizgR8ThAKN+0APonWWdPm9psR0SsCN2/eROz5lzGzpL5HN+w10w17OZyKytw+Pj4AAFdXV1y+fBlNmjQxmnPmjDKnKScnB+7u7gBsayRflSYWi4X8/Hy4u7ur1CKyZE2GaKfLzy7jx7M/4rvo7+Bqp/qMXV9NT59y0bs3AY8HJCTI4O8PsFkscHr3BpFKITt9Gvj/2Jtz31MoFMjLy4O3tzfs7Cx701RD9j25XI68vDx4eXkxtZosXZMh2kkikTBxYbPZGpqS+3+Gjsnfw6EoBzxnnkVoMkQ7yWQy5OTkMHGxBk21bafi4mJ4e3ubNhGczWbDzc2N+SIsLCyEq6sr2GzVtKj8fMt9NqwPykGTUXZRplCq4OlToE8fQCYDkpIAZnHqiRNARARw5AgweLApXaRQTMK9QzfQbGhrnFu2H11XDTe1OxQTYszvZ50fz23fvt2gN7YW1Efbto5UKkV8fDwiIyOrrAxrixgiLjk5wIABQHm52oAJANatA9q0AQYNMoi/dQHtK9qhcdHOq+LS7LVWuOXQDvLf/wR0HDQVlhfi3YPvIrMoEylTU8Bm6bw2ymyg/UUTY34v6zxoiomJMZoTlgxNBNdMBJfJZDQR/P99//L0lyiTlmFau2nM+erH66IpPx8YOJCLggLg5EkWAgLkkEr/3/d798A9cACsn3+GXKGwmL4nlUqZvkITwVUTwZX/WosmQyWCV06U16bpSa8x6Cr4AiXPSuDg5fBKTQ5sB+y7uQ8yhQwP8x+ikWujOtVkqHaqHBdTt5M59D2aCG5G0ETw6jXRRPCXmv49+C++zPgSZYoycJ9x0cm1E4RCIZKTk/XSdPr0NSxf3gM5OY5Yv/46WrQIw82bLzWFbN2KQDc3cCdMsMi+RxPBaSK4LpqqSwRXUt4vEE6CMhz7398oHeqlk6ZNQzZBUiBB6slUXOVcrVNNNBHcihPBKaoon5lmZ2fDy6vizWlLI/nqZpri4uIQGRmpUmjNkjXVtJ3KJeU4cPsA/rv1H36O+hnHjx1HVFSUxma91WkqLlZg8GDgxg0Wjh6VoUMHNU3l5eA2agQyYwbYX35pUX1PKpVCIBAgMjISfD7fpv8yrqxJIpFAIBBg4MCBcHBwsApNhmgnkUjExIXH41Wp6ZZHLwhd/NEx82+z12SIdhKLxYiLi2PiYg2aattOBQUF8PPzM20iOEUV5aCpsLAQbm5upnbHbFAWWnNxcdEYHNgyNYmLSAQMGQJcuAAIBEDXrloO+vtvYMwY4NYtoEULwzptZGhf0Q6Ni3Z0jcvJkevQbf8SiLNewLWh9S/Sof1Fk6KiIri7u5u2IjiFoit8Pt/ULpgl+sRFIgFefx04d66i0rfWARMA/PYb0KWLxQ2YlNC+oh0aF+3oEpegxaNgDwmurYl95bEAUCIuQUpWCk48PFFL70wH7S91R40HTY8ePbKZ8gLVoT7laOvIZDLExsbafFw+iP8Av13+DWKZGIB+cZHLgUmTgGPHKraQ69WrigNfvKgoMTBxouEcr0NoX9EOjYt2dI1Lg+4BuO7YEax9e3W6bnJmMsK3hWNe3DxDuFnn0P6iiTFjofeg6a+//kJwcDCaNm0KHx8fdO7cWSWxlUKxde7k3cE3Z75BzP4YZBZlvvqEShACzJhR8dTtzz+BgQOrOXj37op/x46tubMUihWSEz4KoY9jUV5Y/spjm3s2R4BbAALdAuvAM4qlo/fquc8++wyLFy9G9+7dUVBQgO3bt6N///5Yvnw5PvroI2P4aNbQkgN07zl1TV58L3we8TnuF9xHY9fGKn2kupIDMpkcS5eysXUrB7/8IseoUZxqNbH27AEGDIDc3R1sudzi+h7de47uPWeovefUNTWcOwLOgo9wZk3c/7V35nFR1d//f83GDiIguLBo7ogK4oY7aihoLpVZmbnVT1vNJbOPfSr7fMxvpm2ftDJzbaOstAxRShQTzAVIxQ0QBBFENtlhZu79/THNxDADDDNz596ZOc/Hg4f6njv3nvN6H4cz977PeWPo+mmt+tTbuzduvHADDMNY7Wd5U134nichxJ6gWg6kp6drNdAaPXo0nnrqKcydOxfXr1/Hnj17zGqg0KCWA637RC0HVD6tiViDuLg4Hb9aazmwcmUpvvqqP5566gK6dy8B0LJP2efOodepU7iwdCluxsVZdexRywFqOWCIT4a0HFD75DHcB5nSPri362vEjRAJ1idqOWCHLQfS09Px66+/IjY2FhkZGZxmeEJCXT139+5dTfWcPWXyLfkkFou1jrMFn8wxT+r3qe1p7tNHHzFYvlyMN99U4l//Ytr0ifn6a4jnzYP8xg3A398qY49lWc1dJrrT9I9P6maFUqkUUqnUJnwyZ3NLqVSqsaU1n46PWYfQ09vhfO8WZM4yQfpkjnlSKpVoaGjQ6GILPpk6T1VVVfD29hZGy4Hq6mokJCRovkUXFhbivvvuQ3R0NKZNm4apdrLvFbUc0I89l78yLINVR1bh0ZBHMcJfu9ytNV327gUWLABWrQLefVez127rPPEEkJEBpKWZ0QPLYs+x0hqki37aq8uVL8+j//yhSNv8O8JWTWz12C9Sv8Cn5z/FQ/0fwtoxa81lskWgeNFFUC0HvL298fjjjyM3NxerV6/GlStXkJWVhf/97392kzA1hSoWtFEoFEhMTLRLXQ5nHsYHf36AKV9OQa28Vuu1lnT56Sdg0SLg6afbkTApFKqquenTzWi95bHnWGkN0kU/7dWl3+NDcEsSiMo9bVfRVdRX4Nztc0grsr4vIRQvunCpRbvXNH333XeYPHkyXF1dubCHIKyW+zrehwWDF6Cbeze4yFzaPD4hAXj0UWDOHOCTTwxMmADg9GmgrMzqkyaC4BKRWITsgbPR58L3YJn/QSRu+T/YzH4z0curFwb4DrCghYQ10u6kaeZMw3aPJgh7o3+n/tg9a7dBxyYnA7NmAZMnqx7PSSTtuNDRo4C3NzBsmDFmEoTd4PHEDHRZ/SGuxqaj32NhLR7Xy6sXenn1sqBlhLVCG/aaCLUc0G05IJVK7brlgD7b1eXjLMvi3Dk5YmKkCA9n8c03Sjg4tNOnpCSwY8dCoVSqOmHy5FNr44a2HFDbRgvBtVsOSCQSajnQzPamuhjqU5/FI3BvtQcKP/8Z/R4LE5xP5pqnprrYik8203LA3qGWA237NG3aNBw7dsymfGptnn6M+xEHiw4iyjsKHWUdW/Xp4sUGTJ4sRadO1XjmmWScPIl2+eTboQMiTp9G8cqVON3k/NYce2lpaXZfIk0tB8zbcqCpT27e4+CT8guAN1r16XDaYeTX5yPYLRjhvcKtJvaKioqgVCqp5UATn7p16wauoA17jURdPVdcXAxPT08A9pXJt+STSCRCWVkZPD09tSo5rNmntuZp0x+b8Mrvr2BI5yE4vfi0XtsZhsGlS5WYPdsHbm7AsWMKeHsb4dOpU5BGRkJ59iyYwYM588kS88QwDEpLS+Hj4wMHBwe7/mbc1CelUonS0lJ4e3tDJpPZhE/mmKfGxkaNLmKx2GCfUp75EuO+WIy7F4vgHdypRZ8m7Z2EE3knsGvGLswfNN9qYk+hUKC4uFijC9/zJITYq6yshI+PDyfVc3SnyUTEYrFWs09AFVQSPYtU1MFj6Hjz8xozLhaLIRbrFkm2NN6S7Yb6JJfLkZKSgpiYGL32WKNPbY0P8B2ACP8ILA5brGVv07/fuiXHjBnOcHQEfvtNhM6dtf0y2KdTpwAPD0jCwjj1yRLzJJfLcfbsWcTExLRquzX51BxjfGJZVqOL+pzW7pM+2uuTWCzW6NLS/zN9tgevmg7mCxGuvheHsTsXtehTREAERGIRvFy8NH5YQ+w1jZem76P/T9xASRNBmMi0PtMwrc80MKxuU08AuHcPmD5diro6JY4dU6BrV/0fKgaRlASMGdPOleMEYb/49O+Ei24jIT36K4BFLR63cfJGyxlFWC3t7tNEEIR+xCLd/0719cDMmcDNm8CbbybjvvtMuIBCobrTNG6cCSchCPujdOQ0hBQcQWN1I9+mEFYOJU0mQh1YtRGJRHbTmfZqyVV8c/EbNCr1fxArFKo+TGfOAAcPKhESYmK8pKcDNTXA2LHGn0NA2FOstAfSRT+m6NLl6elwRzUubUviwDJ+oXjRhUstaCG4kagXgnOx0IywDp7++WnsSNuBp8KewuczPtd6jWWBp55S9WD6+WcgOtoMF/z0U+CFF4CqKsDJyQwnJAj7gGVYFDoEInPgQxif9oHeY+RKOcbsGoOssixkv5gNTydPi9pImA8ufz/TnSYT0bc5rT3DMAxu3rxpF7r09u6Nzm6d8eTgJ3VeW7sW2LkT2L1blTCZRZdz54ABA2wmYbKnWGkPpIt+TNFFJBYhq+90dL90qMVjZBIZblbcRFldGbLLsk0x1aJQvOjCpRaUNJkIl020rBGlUon09HS70GXN6DW4+dJNjAkcozX+7rvApk3Ahx8C8+apxsyiy/nzwNChJlgsLOwpVtoD6aIfU3VxnDkVQYps3DzWckL07cPfIn1pOkJ8Q4w10+JQvOhCzS0FDHUE1+0Irs8Wa/aptXlykDho+bRnjwhr1kixbh2LZ55RQP2S+hiWZXU0MMin+npIL10Cs2QJJIBN9GBRX4M6gut2BAdAHcGb2d5UF2N86v9sJOQbpcjZfgRdxz6t16fR3UarbP+7qMNaYq+pLnzPkxBij5ImAUEdwVv3aeDAgQCA5ORkVFdX24RPzecpqzYLIojwxKQntHz688/OeOed4Vi0qBGvvy7S8QkAqqurcfLkyXb75Hn9OsYrFMhwcsIgwKa6/aampmL06NE25RN1BBdOR/CmPqW5jwCO/oK4uG6C8Mkc81RQUKCliy34ZGrsde7cGVxBC8GNRL3QrKioCF5eXgDsK5NvySfV3mrnMGTIEK1mY9bsU/N5ivoqCsdvHsfH0R/jueHPQS6XIylJhGnTJJg2jUVsrAgSibbtCoUCqampGD58OJpjiE/izz6DeMUKKMvLIXVzs4lvkQqFAufPn8fQoUPh5ORkEz41Hzf2TtP58+cRHh4OR0dHm/DJHPNUX1+v0UUqlRrlU+Kk/2DIsc2QVRRC5iLT8amktgS/5fyGRmUjloQvsYrYa2xsxJkzZzS68D1PQoi9iooK+Pr6crIQnJImI6HqOftErpRj0cFF+PHKj7j2/DUEdAhAWhowfjwwYgRw6BDg6MjBhZcsAVJTgbQ0Dk5OEPbB5T1nEbxwOC5s+wODnhmt8/q52+cw7PNh6OzWGYWrCnmwkDAHVD0nYGjxnTZKpRJXr161WV1kEhm+fPBLFK0uQkCHAGRmAlOnAv36AT/+2HLCZLIu588D4eHGGy5AbD1WjIV00Y85dOn72BCUibxQ9s0Rva/38uqFcUHjENMrBkrGOvSneNGFSy0oaTIRKvPUhmEYXLt2zeZ18XD0wO3bQFQU0LEjEBcHuLu3fLxJujQ0ABkZNpc02UustBfSRT/m0EXiIMFV/8nwST2q93VPJ0+cWHgCX8z8AhKxdWxVRPGiC7UcIAgBcPrWadytUS2ULC8HpkxRdf0+ehTw8eHwwteuqS709yJ7giCMRzlpCvrXnEV5dhnfphBWCCVNBGEASkaJx354DAHvB+DotSRMnw7cvq1KmAIDOb54RobqzwEDOL4QQdg+PZfdDwkYXN36e6vHWcvjOcKyUNJkImIxSdgUsViMwMBAm9OlqLoI3s7ecHVwxZaVw/DXX6pHcv37G/Z+k3S5dAno2lX1HNCGsNVYMRXSRT/m0qXriABkO/SHPE7/I7odqTvg+64vnvn1GZOuYykoXnThUgtS2USaltUTKj3CwsJsTpduHt3w55KzGH/5LyQmOOPHH1XVcoZiki6XLgEh1tOh2FBsNVZMhXTRjzl1uRUchfuyjoJldIvHnaROuFt7F1llWSZfxxJQvOjCpRaUNJkIVSxoo1QqkZaWZpO6rFkjwoG9/vjyS9UC8PZgki4ZGTaZNNlyrJgC6aIfc+riPH0S/JV5yE/K0Xltaq+pSP1/qTjw6AGTr2MJKF50oeo5AUMVC9owDIO8vDyb0iWtMA3vvKvAe+8BH30EPPJI+89htC61tcCNGza5nskWY8UckC76MacufZ8eByXEuLk7Uec1HxcfhHUJg4ejdfTfo3jRharnCIInyuvKMfLzMVhbeB9e+FcBnn/ewgZcuQKwrE3eaSIIvugQ2AHXXIZAfPwY36YQVgYlTQTRCrt+vYzGald0dPbEB//pankDLl1S/RkcbPlrE4QNUxwyET3zE/Wua0rITsCGpA1IK6QO/IQ2lDSZCFUsaCMWi9G3b1+b0OXsWeD1haMx9UoeTi3/AWKxyOhzGa3LpUtA9+6Am5vR1xYqthQr5oR00Y+5dXF7IBKdmULkHLmu89qOtB14LfE1JObqPr4TGhQvunCphZSzM9sJDMNoNi60pw0RW/OpX79+mo1HrdWn69dZTJsmRUgIi++/cYCbW2+T56lv374AoHN8az6xly6BDQ6G8u/32NpmnD179tRc31Z8ajpurE89e/YEwzAQiUQ241Nz29vrE8MwGl0YhjE99haMgPzfUtzaewxBUb20bJ8YNBEuMhf08eqjZY8QY08kEmnpwvc8CSH2uISSpnaydetWbN26VTOhR48ehYuLCwAgMDAQYWFhuHDhAvLy8jTv6du3L/r164czZ87g7t27mvHQ0FAEBQUhKSkJVVVVmvGIiAj4+vri6NGjWoEWGRkJZ2dnxMXFadkUExODuro6JCb+861IKpVi2rRpKCkpQUpKimbc3d0dEydORH5+PtLT0zXjnTp1wqhRo5CZmYlr165pxtvr08CBA1FUVIS6ujpUV1dbpU+HD6fh6aeDIfa+gueeK0BpaTDc3EyfJ29vbwwYMABJSUkG+6TIyEBueDgu/30uc82TkGLPx8cHo0ePtimfbHGebNGnIOchkP2RiMzMSC2fhgcOx9KZS5GWlqZ1XSH6lJubi4sXL2rGbXGe2utTly5dwBUitmkKSRiMehflwsJCeHt7A7CvTL4lnxiGQXx8PKKiojR2WZNPNTUSjB/P4lbDZZTMDUFkUCTin4iHg9TBpHmSy+VISEhAdHQ0RCLtx3wt+qRUgnVxgXLrVrBLlhjtk1BjT61JVFQUnJ2dbcKn5uPG+NTY2IiEhATcf//9cHJysgmfzDFPdXV1Gl1kMplZfPpjwpsYmLIdHepuay1WsabYa2hoQHx8vEYXvudJCLFXXl4OPz8/3Lt3Dx4e5q2CpDtNJiKTySCTybTGJBKJ3uZaTZMIQ8abn9eYcbFYrPf5bkvjLdluqE/q/0hSqVSvPUL2qaEBePBBICdHhOV7krHhLwk8nT3hIHXQ+GSq7SKRyHCfMjMhYhhI+/cHDIwxa4w9tQ225JMaY3xS/4KSyWSac1q7T/ow1qfmn7mm+NRh1kT4JL+N64euos9Duns7NjANcJI6QSzSPpfQYk/9nqbv43ueDBnnKvaouSVBcAzDAAsXAidPAgcPAutnPo2c5Tl4Z/I7/Bl1/e8Fqn368GcDQdgw/ZeMQgMcUPiVdusBlmUR8H4AXN92xc2KmzxZRwgRSppMhFrXayORSBAaGmpVurAssGoVEBsLfPUVMH68ajygQwB6e/c2yzWM0uX6dVXVXOfOZrFBaFhjrFgC0kU/XOji7OWMKx0i4JSiXSUnEongJHUCAOTdy9P3VsFA8aILl1rQ4zkToTJPbcRiMYKCgvg2o11s3gx88AGwdSswY3YjSmor4ePiY9ZrGKXL9euqu0wi41sdCBlrjBVLQLrohytdKkInYHDSR2AUDMTSfz7P4+fFw8vZC55Onma/pjmheNGFNuwVMM0Xt9k7CoUCx44dsxpd9u0D1qwBXnsNePZZIPZSLALfD8QbiW+Y9TpG6aJOmmwUa4sVS0G66IcrXTymjUVHthw3fr2iNd7Tqyc6OnfUKdwQGhQvunCpBSVNJkLFh9qwLIuqqiqr0CU+Hli8GFiyBHjrLdVYwo0E1CnqNLfmzYVRumRmAr3N83hQiFhTrFgS0kU/XOnSZ/4IKCDB7diTZj2vpaB40YVLLejxHGGXnD0LPPwwMHUq8Omn/zwB2zNrDxaHLcYgv0H8GlhVBRQW2vSdJoIQAm6d3ZDhOgSS5JMAlmnGb5TfwLeXvoWz1BkrIlbwZyAhKOhOE2F3XL8OxMQAgwapFn83ragViUSY0H0CvJy9+DMQUN1lAihpIggLcLffWHS/pX2nKe9eHtYdW4dt57bxZBUhRChpMhGqWNBGIpEgIiJCsLoUFQFTpgCdOgG//AL83cwdFfUVUDDcPQdvty7qdgM2/HhO6LHCF6SLfrjUxfn+seimzEdByj+Vcn28+2DB4AVYOHih2a9nTihedKE+TQKGque0EYvF8PX1FaQulZVAdDTQ2Khaz/R3I3cAwKojq9D7f70RlxnX8glMoN26ZGaqMruOHTmxRwgIOVb4hHTRD5e69HxyNAAgd98/d5u6unfF7lm7sW7cOrNfz5xQvOhC1XMCpnkreXtHLpfj119/FZwuDQ3A7NlATo4qYQoMbPKaogFHso8gtyIXHZ24SVLarYuNV84Bwo0VviFd9MOlLj79OyHboR+Ux61vMTjFiy5cakELwQmzI7TSV4YBnnwSOHUKOHoUGNhstwRHqSMyX8jEr5m/IiIggjM72t1uIDiYM1uEgtBiRSiQLvrhUpeC+8ai6w3dpKlWXguGZeDm4MbZtU2F4sVy0J0mwqZhWWDlSmD/fuDrr4Fx4/Qf5yxzxsPBD1vWuJZgWbu400QQQkI8fix6NVxGWWapZmzpL0vh+rYrPjn7CY+WEUKCkibCpnnvPeDDD4GPP1ZtxtucyoZKyxvVFiUlQEUFJU0EYUGCHh8DAMjcfUoz5u2iWvh4u+o2LzYRwkPEUkcso6isrESHDh1QUVGBDh068G2OYFA3WnN3d+e9k+633wKPPQa8+irw9tu6rzMsg/5b+yOwQyA+f+BzdPfszpkt7dLl9GkgIgJITwcGD+bMJr4RUqwICdJFP1zrwjIsimQBuDbkMUw4+y4AoKyuDCKI4OnkKdi5oHjR5d69e/D09MS9e/fg4eFh1nPTmibC7Dg7O/NtAo4fBxYsAObPBzZs0H/M+dvnkVWWheKaYrPvNacPg3W5cUP15333cWeMQBBCrAgR0kU/XOoiEouQ4z8W3lf/0Izx3q/NQCheLAc9njMRWoCnjUKhQFxcHK+6XLwIzJqlWr+0Y0fL+90O6zYM2S9m48vZX3K+yLNduty4oWo34O7OqU18I4RYESKki34soYt82Cj0qU5FQ2UDZ9cwNxQvutDecyYye/ZsdOzYEQ8/rL3Qt6qqCsOGDUNoaCgGDhyIzz//nCcLCXNx65aqF1OPHsAPPwAODq0f392zO6b1mWYZ4wzlxg27uMtEEEKj0wMj4YhGZH6XBkD16GvjyY1Y+stSYa5/JCyOXSRNL774Ivbu3asz7uLighMnTiA9PR1//vknNm7ciNLSUj1nIKyBigpVwiSRAL/+CrT2KLtOXmcxu9pNdjYlTQTBA70eGow6OKHkUAoA1bZK751+D9tTtyOnPIdn6wghYBdJU2RkJNz1POqQSCRw+Xsfjfr6eiiVStop2kpRN68sKFA1r+zateVjcyty0XlLZ7wQ9wKUjNJyRhoK3WkiCF5wcHNApns4HFJPa8aeHfos/j3u3+jobLvd+QnD4T1pSkpKwgMPPICuXbtCJBLhwIEDOsds27YNPXr0gJOTE8LDw3HypPm6tlZUVGDw4MHw9/fHmjVr4OPTvgXBUimtpW+KVCpFTEyMRXVhGGDhQiAlBfj5Z6B//9aP//bSt6hsqMTV0quQiC2zX5PButTXqzI/O0ia+IgVa4B00Y+ldCnrG4Gg2ymaf6+PXI+3It9CYIfAVt7FHxQvunCpBe8q19TUYPDgwVi0aBEeeughnddjY2Px0ksvYdu2bRg9ejQ+++wzREdH4/Llywj8ey+M8PBwNDToLtw7evQourZ2ywGAp6cn/vrrL9y5cwcPPvggHn74Yfj5+ekc19DQoHWNykrV8225XK5p2S4WiyGRSKBUKsEwjOZY9bhCodC6kyWRSCAWi1scb94KXh0IzRe5tTQuk8nAMAyUyn/upohEIkil0hbHW7LdUJ/EYjHq6up0qjm49GntWgliY8WIjWUwYoQS6ku05NPqkasxrOswuEhdtOzhcp5YlkVdXR3c3d1b9ykrCzKWhTIoCBKAs3kSQuyxLIvq6mq4u7tDJpPZhE/Nx43xiWEYVFdXw83NDVKp1CZ8Msc8yeVyjS5qW7jwSTZ2GLqd24zCcwXwDetsFbFXVVWl0YXveRJC7DV9r7nhPWmKjo5GdHR0i6+/9957WLJkCZ566ikAwAcffIAjR47gk08+wcaNGwEA58+fN9kOPz8/DBo0CElJSZgzZ47O6xs3bsT69et1xhMSEjSP+AIDAxEWFoYLFy4gL++f3bL79u2Lfv364cyZM7h7965mPDQ0FEFBQUhKSkJVVZVmPCIiAr6+vjh69KhWoEVGRsLZ2RlxcdqbysbExKCurg6JiYmaMalUimnTpqGkpAQpKf98a3J3d8fEiRORn5+P9PR0zXinTp0watQoZGZm4tq1a5rx9vo0cOBAXLx4EW5ubqiurubcp0OH7sOOHQPx4YfA8OH5iIszzKdJYZOQlpaGuLR/rsv1PAHA2LFjte6UNvfJ9/x5RAA4XVyM0QBn8ySk2PPx8cHo0aNtyidbnCe+fTp8+LBFfKrzV107N/Y0iiT3IS8vDw1MA2qUNYgIiRDcPN28eRMXL14UzDwJIfY6d+4MrhBUc0uRSISffvoJs2bNAgA0NjbCxcUF33//PWbPnq05bvny5UhPT8eJEycMPvfx48fx8ccfY//+/ZqxO3fuwNnZGR4eHqisrERERAS++eYbDBo0SOf9+u40BQQEoLCwEN7eqq6x9pTJt+QTwzCIj49HVFSU1i1SLnz68UcRHntMghUrWGzZIm7TJ/X6JZlUZvF5ksvlSEhIQHR0tE4DuqY+iT/5BOLVq6GsqoLU0VFw3/bNGXtqTaKiouDs7GwTPjUfN8anxsZGJCQk4P7774eTk5NN+GSOeaqrq9PoIpPJOPWp2LknMsPmYuzp/8Oh64cw67tZGNplKE4vOS242GtoaEB8fLxGF77nSQixV15eDj8/P06aW/K+pqk1SkpKoFQqdR6X+fn5oaioyODzTJkyBXPmzEFcXBz8/f1x9uxZAMCtW7cwbtw4DB48GGPGjMHzzz+vN2ECAEdHR3h4eGj9EPzxxx8iLFggwZw5LDZuZNp+A4DYy7EI+SwEX174kmPrTCAnBwgKUpUAEgTBCze7jITXNdUdkC5uXQAA5fXlfJpECATeH88ZQvNv5izLtqtd/JEjR/SOh4eHa90CNIStW7di69atmiw4MTGRHs81ezwnlUqRnJzM2eO55ORyzJjhjj59yjFnzmn88YerQT5tydqC7OpsnLl+BgvCFlh8niQSCaqrq1t9PDc8JQVid3dkJCUJ8hEJF7GXmppKj+f0+JSQkGBzPgHGz1NCQoJGF659Qs/+CDvxC1JPpyL/bj6+DPkSrhJXZGZmCi72CgoKtHThe56EEHv0eM4Mj+fMjXrvuZKSEs1dJ3u6/cmXT3fvyhARwcLdHUhMVMDT03CfahprsPfCXjwa8ih83X0F41PTeZKGh4MZPRrs//5n1fNki7FHPtmPT5d3nsHgZWNw8YsU9JsfbhM+2eI8teRTdXU1vLy8OHk8J+ikCQBGjBiB8PBwbNu2TTMWHByMmTNnahaC84E6aSovL4enpydvdggNhmFQUlICHx8fiMXmffpbWanaGqW0VNVewN/frKfnFIN0YVnV1inr1wOrVlnWQB7gMlasGdJFP5bUpaGyAejggdMPbcb4/S9wei1ToXjRpaKiAh07drTNNU3V1dVIT0/X3IrLyclBenq65lbbypUrsWPHDuzcuRNXrlzBihUrkJeXh2XLlvFo9T9wWdpojSiVSqSkpJhdl8ZG4KGHgNxc4PDh9iVMQmhgaZAud+8CNTV20aMJ4C5WrB3SRT+W1MXRwxHX3YZAek716Oj7jO+x7NAyxGfFc37t9kLxootNtxw4d+4cIiMjNf9euXIlAGDBggXYvXs35s6di9LSUrz11lsoLCxESEgI4uLiEBQUxJfJWlCfJt3qOX22mOITywKLF0uQlCTCkSMiBAczkMsN92nZoWXIu5eH/0z4D8I6h/EyT+pjWJbVOV49T8z165ACkAcEQKRQ2Pytd/U1FAoF9Wlq4pPaTrlcbjM+matPU9M/ufaprNcIdL90CHK5HL/f+B2fpX4GLycvTO01VXCx11QXvudJCLFn00nThAkT2ty65Nlnn8Wzzz5rIYtahxaCt+7TwIEDAcCsC8H37euPH37og5dfTsWECUNQXGy4TwPDB+KrC1+hTlmHCeIJKHQr5G2eALS6EDzvxx8xFMDRzEw4V1YKcjEuLQSnheD2sBA8MDAQ0ohhCEr/EN/v+hGdnDvhEb9H0M+hHwAIKvZoIbgdLwS3JtRrmoqKiuDl5QXAvjL5lnxiWRZ//PEHRo0aBUmTsnljfdq6lcELL0jwzjtKrFjBGOVTZkkmfrjyA1aOWAmRSMTLPCkUCiQnJ2PcuHFojton9j//gfjjj6G4fVuw3/bNGXtqTUaPHg0nJyeb8Kn5uLF3mpKTkzFq1Cg4OjrahE/mmKf6+nqNLlKplHOfbh7Nwn0x/XDmv4cRtmYSJz6ZY54aGxtx8uRJjS58z5MQYq+iogK+vr62vxDcmlAnTVxMCqHi4EHgwQeBF14A3n8faEeXCetk8WIgIwP480++LSEIu4dRMKiSdUTa/a9gwtF/8W0O0Q64/P3M++M5a6ehoYHWNDWxXSQSoaCgAF26dNHqpdVen86eleLRR4FZs1i8844S6pfb4xMLFg4yB0F842IYBoWFhQgICNC6ZlOfkJ0NdO8OpVwu2G/75ow9hmFQUFAAf39/ODgIY55M9an5uDE+KZVKFBQUoFu3bpDJZDbhkznmqbGxUaOLWCzm3iepBNme4XC8dBZyuRx18jrcqr6Fvj59wTKsYGJPoVAgLy9Powvf8ySE2GtumzmhpKmdNF/T9Ntvv9GaJj17z2VlZRm9pqmgwBWvvz4JYWFKPProYcTHM+32iWEZvHrjVUwNnoq5XeaiOLfYaJ/MuabJw8OjxTVNbpcv45avL67ExQl2XQkXsVdYWEhrmvT4dPHiRZvzCTB+nuLj4zW6WMqnQv9ghF4+gEO/HsLcC3MhZ+XIXZ6LgssFgom9vLw8XLx4UaML3/MkhNijNU0CRH37j/aeM+/ec0VFwPjxUjg5ASdPAh4exvn0W85viPkmBh0cOyD3xVy4ylyN9slc1XOt7j1XVweRqyuUn34KdtEiwX7bN3f1HO09p+sT7T3H/95zattPrYjF6A8eRcG5PIw/FYnimmIcW3AMob6hgok92nvOsnvP0Z0mE5HJZJDJZFpjEolEaxG0mqZJhCHjzc9rzLhYLIZYrNuOq6Xxlmw31Kem5cD67GnN9upqYPZsoL4eSEwEVLmocT5N7T0VR544goLKAni6eOq9Jh/zJBKJ9M9Tfj7AspD26gU0eZ2reWpr3JKxp7bBlnxSY4xP6l9Q6kdz6nFTbW9p3NKfEW2Nt2V7889cLn0KemgE8AFQcPAv/PXaX3CRubS6hRdf86R+T9P38T1PhoxzFXv6jjEXlDSZSHv2wLMHRCIROnXq1G5d5HJgzhzg+nUgKUm1Z62pdkT1jDLtJGakTV1yc1V/9uhhMZv4xthYsXVIF/3woUu3UUEoEfmgNukcXB2mW+y67YHiRRcutaDHc0ZC1XPmg2WBJUuAffuAuDjg/vtNPV/7NnQWBNu3A88+q7rN1sI3O4IgLM/ZTtGASIxhxb/ybQphIFQ9J2Dq6+vh7OwMwL6eGbfkEwBkZ2ejR48eWrdXW/PpzTeBXbtE2LlTgQkTWMjlxvuUU5aD6d9Ox3NDn8PS8KWC6TStVCqRk5OD3r176+glk8nA3rgB+PtDwbKAnVTPKZVKZGdno1evXnB0dLQJn5qPG+OTQqFAdnY2evbsCQcHB5vwyRzz1NDQoNFFIpFYzKeqvuEYmLwdqfmp+Cz9M/i4+GD9+PWCiT25XI7r169rdOF7noQQe42NjeAKSpraSfPqud9//52q55pVz127dg0FBQUGVc8VFEThrbecMW/eZXh5ZULtmrE+vRL3Cq6WXsX2U9sxhBkiqCoSAPDz89NbPddw7Rqq3dxw6u/3CLWCiYvYq6iooOo5PT5lZWXZnE+A8fN05MgRjS6W9KmgSwdMZO/io30/YLt8O/p498E052mCir2srCyNLnzPkxBij6rnBAhVz5lePZeQIMLMmRIsWgR8/LFCq3mlsT7dq7uHPX/tQYhvCCZ0nyCYb1xtVc+xERFge/eG8osvdHwS0rd9qp6j6jl7qp5TKpUoPH8L/iO645eVn+HPmDz09emLxwY8JpjYo+o5qp6zKqh6zrjqufR0YO5cICoK2LYNkErN41NH1454adRLZvWprXFzVM+JcnMhmjIF4mavCbWCyZBxqp6j6jnAuqvnJBIJ/IcHoVDcFe7JOfjvlo16bVND1XPCiD0uq+d0rSLahb6JtWfEYjECAwNb1SU/H5g2DejbF4iNtY91z63qUlenalDVvbvF7eITQ2LFHiFd9MOnLnm+w+B+/ZzFr2sIFC+6cKkFqWwiXGa01ohEIkFYWFiLulRUANHRqlZEhw4Bbm7mue73Gd9j+tfTcfLmybYP5oFWdVE/i7ejdgNA27Fir5Au+uFTl7p+YehenobahlpcK7mGO9V3LG5DS1C86EJ9mgQMVc/pVs9dunQJwcHBOtVzCoUYs2czuH1bhOPHFfD2BljWPD69f/p9pNxKQZhfGEZ2HWlWn8xVPXf58mUMGjRIt3ouJwcAIO/WTdWwCsJdV2Lu6rmMjAyEhIRQ9Vyz6rmMjAwMGDCAquea2N7Q0KDRxZLVcwzDwHHkIHgfL8Xs3Y/jQNFBvDPpHawYscJkn8xVPXfhwgWNLnzPkxBij6rnBARVz7Xu08CBA5GXl4eysjKt6rmRIyOwerUv/viDxfr1ycjJKUVOjvl82jNrDzb8tgG9yntpziW0KhIA6N69u271XH4+WIkEhy9cAJuRYZF5ElLs1dfXU/WcHp9u3bplcz4BplfP3bp1y+I+1XasQQQAhyw53L3ckZ2bjbjSfzTme55u3bql0YXveRJC7FH1nACh6rn2Vc+9+aYUb78twr59Csyd+8/x1uAT59Vz//432NhYKK5ftyqfWhun6jmqnrOV6jmGYcAyLKqcuyJt/LOYdGw9lEqlYGKPqueoes6qoOq5tqvnPv8cePttYNMm4IknTPfV2qp9mqK3ei43F6Lu3dvlq5B8ammcqueoeg6w/uo59XhuxzC4X72g+QWuD6qeE0bsUfWcgKGKBW3EYjH69u2r0eXwYeCZZ1Q7hKxebf7rvXXiLaw6sgr59/LNf3Iz0lwXLXJz7a5yDmhDEzuGdNEP37pU9QxDt7tpvFy7NfjWRYhQ9ZyAoYoFbSQSCfr16weJRILUVNUmvDExwEcfASIzbwdX1VCFLSlb8N7p93Cx+KJ5T25mmuqiQ26u3VXOAW1oYseQLvrhWxeHEWHowuRh0VcLEf1VNO7V3+PFjubwrYsQoTtNAqb5c1p7R6FQIDk5GVlZCkybBgQHA998A3ARw64OrvjmoW+wOHQxpvaaav4LmBG1LjrxUlsL3Lljl3eaWtTEziFd9MO3Lp2jwyBhgZ+yfkJ8VjxyK3J5saM5fOsiRLjUgtY0mQito9eGZVnk5FRgyRIJnJ1VvZhcXbm5llgkRkzvGMT0juHmAmaEZVncvXtXN15u3lT9aYdJU4ua2Dmki3741iVocm/UwAWLcidhwAsx6OLehRc7msO3LkKESy0oaTIRuVyuWfxsT9UJLflUV8dg48bhKC4GTpyQo2NHVesha/bJXNVzgOo/c9PjRVlZkAJgAgOhbDpuBT61Nm5o9Zz6vTKZzCZ8aj5ujE9qO+Vyuc34ZI55aqoLLz6JgBtug/FwojNGfL5Q6/8y3/PUVBe+50kIsdf0veaGkqZ20rxPU2JiIvVp+tsnhgF27pyE69c74t13zyM7uwDZ2dz49Hjs4+jj0gcTvCbAp4OPIPvK6OvTVF1drdWn6b6jRzFQKkWJgwNSmhwv1F45XMReamoq9WnS41NCQoLN+QQYP08JCQkaXfjyyblLMHreTBZU7BUUFGjpwvc8CSH2qE+TAFH3aSouLoanpycA+8rk9fn0r3+JsWWLGNu2lWDx4g5a/YjM6dOZW2cw4osRkIllyHwuE908ugnym3FT2xmGQWFhIQICArSv+eqrkPz4I5isLKv4tm/O2GMYBgUFBfD394eDg4NN+NR83BiflEolCgoK0K1bN03bAWv3yRzz1NjYqNFFLBbz4lPykl0Y+s0yXL14FlIPKYI7BZvkkznmSaFQIC8vT6ML3/MkhNirrKyEj48PJ32aKGkyEnXSxMWkWCOffKJqK/Dee8CKFW0fbwqVDZXYmbYTRdVF+L/J/8ftxbjmkUeA0lLg99/5toQgiDa48uV5pG4aiiceAib2mIjfn6T/t0KEy9/PVD1nIlSxAPzyC/D888Dy5cALLyhw7NgxTnXxcPTASyNfsqqESaFoQRc77dEEtKKJnUO66EcIutw3IwSdKyVwVjrCUeLImx1NEYIuQoNLLShpMhF7v1F39izw6KPAzJnAli0qPaqqquxel+a0qIsdJ00UK/ohXfQjBF0cPRzR7U4w4r9/EnHzdNcs8oEQdBEaXGpBSRNhNDduANOnA4MGAV99xU0vpqbUNNZg3o/zcCL3hG18QNTUAHfv2m3SRBDWSEnXMHjlX+DbDIInKGkijKK0VNXp28MD+PlnwNmZ+2vu/Wsvvr74NRb/vBgMy7T9BqFjxz2aCMJaUQQPQo+ai2AUNvAZRLQbSppMxB5b19fXqx7HlZaq9pbr1Omf1yQSCSIiIjjRZdJ9k7A0fCleGf0KJGLr0l2vLrm5qj/tNGniMlasGdJFP0LRxX30IHw4thaTt03EyZsn234DxwhFFyHBpRbUp8lE7G2TRIYBnnwSSE0Fjh0DevXSfl0sFsPX15eTa/fx7oNPp3/Kybm5Rq8uOTmATAZ07cqPUTzDZaxYM6SLfoSiS0DMQPz5F5BYfgJz717G2KCxvNojFF2EBJe/lylpMpHa2lo4//1syh76YLzyihj794uxfz+DkSN1fWIYBr/99hsmTpyosUvoPjUf56oj+LFjxxAVFaXpXyW+cQPiwECIJBKr9Km1cUM7gh87dgyTJk2Cs7OzTfjUfNwYnxobG3Hs2DFMnDgRTk5ONuGTOeaprq5Oo4tMJuPNp04hfpib6oHe7HiMWTqG987tDQ0NSEhI0OjC9zwJIfbq6+vBFZQ0tRN77gi+bZsEO3YMwlNPXUBwsAMAXZ8GDhyo2UCyurraLD7l1uXiRPkJzOg8AwtnL7SaDsZtdQQfevo0HN3c4ANYrU/UEZw6gttTR3C1T70KQ9GlRImsP7OQhSzeO4IrlUrqCE4dwYWNunlWYWEhvL29Adh2Jn/ggBIPPijG8uUMNm1iWvSJYRjEx8cjKirKbHeanjr0FPZe2Is5/efgu0e+s5pvxs3vNCUkJCA6Olpzp0kSEQEMGgTxzp1W6VNr44beaUpISEBUVBTdaWp2pykhIQH3338/3WmC9p0mtS583mmSSCQ4HvYSgjLi4F+TYZJP5rrTFB8fr9GF73kSQuyVl5fDz8+Pk+aWdKfJRGQyGWQymdaYRCLRuxCtaRJhyHjz8xozLhaL9T7fbWlcn+3nzwPz5knw4IPAli0SiJsswm5ue9PNNPXZY4xPc0PmIr8yHytHrTSbT62NczlPIpHon/GbN4FZs1q13Rp8amncUJ/UNtiST2qM8Un9C0q9hYp63FTbWxq3tthr/pnLh09s2ADU3foQJy6fwOTBkzXjfM2T+j1N38f3PBkyztU8cbkQnO40GYn6TlNFRQU6dOjAtzmckZcHjBgBBAYCiYnA308iW0TdaM3d3V1r7zl7R0eX6mrA3R348ktg3jy+zeMFihX9kC76EZIuh7/4CTG3HoSzyAk1/67l1R4h6SIU7t27B09PT9pGhbAslZWq5pVOTqpeTG0lTGqcLdG0yQrR0sXO2w2ooVjRD+miH6HoMnzaOHjUA34NXqiV1/JtjmB0sQcoaTIRW93vRy4H5sxR3Wn69VfAz8+w9ykUCsTFxZlFlwNXD+CL1C9Qr+CuEsJS6OhCSZNZY8WWIF30IyRdvDt7I31LH+yOmwNXB1debRGSLkKBSy1oTROhA8uqNuA9dgyIjweCg/mwgcW6Y+tw+e5lVDdWY/nI5ZY3gktyc1U9mrp04dsSgiCMoMh3EDxyaTsVe4PuNBE6bN4MbN+u+pk0iR8b5Iwci0IXIbhTMBaGLuTHCC7JzQWCggA7a45KELZCQ5+BCLx3ASxDy4LtCfrEJrTYvx9YswZYtw5YtIg/OxwkDlg9ajUuPXMJHZxscKF9bq5dP5ojCGvnREQ55j9eincO/h/fphAWhKrnjMQWq+dOnwYiI4HZs4GvvgKMKcRgWRYKhQJSqZQqOZqgo0t4uOpn+3a+TeMNihX9kC76EZouL+9Zhc257+EBURR+fv0Ib3YITRchQNVzBOfk5AAzZqh+j+/caVzCpKaurs4kWz4//zlO5Z2CreXzWrrQnSYApseKrUK66EdIujw++Ql8fNAB0y7149sUQeli61DSZCK2ULFQVaVKmNzdgQMHVC0GjEWhUCAxMdFoXUprS/Fi/IsYs2sMzheeN94QgaGlS2UlUFZm90mTqbFiq5Au+hGaLmHdwjAucwgGnC/n1Q6h6SIEqHqO4AyGAZ54QtWc+vRpwMeHX3salA2YN3AerpZcRXiXcH6N4YqbN1V/2nnSRBDWTkXXAfDJT+PbDMKCUNJkInK5XLN1iDXu7fPaa2L88osYBw8yCA5u2XZDfVIf09wWQ33q5NQJn0R/ArFErNG3vT41HxfCHkzqY1iWhSIrC1IA8m7dALncan1qbdzQvefU75XJZDbhU/NxY3xS2ymXy23GJ3PMU1NdhOLTjUHeuKe4BP+aKri7uvM2T0114XuehBB7Td9rbihpaidbt27F1q1bNZOSmJgIl79bZVvbLtIffliC998Px8KFl+DtXQnA9J2xBw4cCKlUiuTkZFRXV5vkU01djVXvyt7cJ4lEgurqatyKi8MAmQxxqamQXrpk1T6ZYwfz1NRUjB492qZ8Msc8JSQk2JxPgPHzlJCQoNFFKD491/9j1IQ04psfDuLRJ5/gZZ4KCgq0dOF7noQQe507dwZXUPWckair50pKSjSr860pk09JYRAZKcLcuSw+/1wJsZj/bydfXvwSkd0j0c29myC+RZrDJ33jzIoVEMfFQZGRYTM+2eI8kU/kU1s+jd42CjXXz2G112Ys+s8qm/Cpue3W6FN1dTW8vLw4qZ6jpMlI1ElTeXk5PD09+TanXdy6BQwbBvToodqE19HRfOdmGAYlJSXw8fHRu0t1S2SXZaP3/3pDKpbi1spb8HX1NZ9RAkBLl4cfBmpqgCP8lSkLAWNjxdYhXfQjRF1YhkWlxBNpU/+FCYdf4cUGIerCNxUVFejYsSO1HBAiXD475YLaWmDmTNUOHj/9ZN6ECVDpkZKS0m5dKhsqMSZwDCbfN9nmEiagmS7UbgCA8bFi65Au+hGiLiKxCHluwZBev8ybDULUhW9oTRNhFlgWWLYMuHIFSE42fBNeSxDWJQxJi5JsYnPeNsnNVe2GTBCE1VPRJRjeBX/xbQZhIShpsiO2bQP27VN1+w4N5dsa/ThJTWgSZQ3cuweUl9OdJoKwAVLyU/Dy9GSEXM/CdgUDsZQe3tg6NMMmYi1t65OTgZdeAl58EXj8ce6uIxKJ4O7ubrAuLMvi52s/o0HRwJ1RAkCji7rCg5KmdseKvUC66EeIutTKa/Fnh6tI7q5AQfJNXmwQoi58w6UWtBDcSNQLwblYaGZuioqAIUOAnj2BY8dU65mEwulbpxHxRQQCOwQi64UsyCQCMo4LDh4EZs0CCgsBDstiCYLgnrs1d7H38G4MeXkN3BYcwrA3p/FtEgFufz/TnSYTaVrmKETkcuCRR1Trmb77jvuEiWEY3Lx502Bd7lTfQTf3bpjYY6JNJ0waXXJyVPvUCGlBGU+0N1bsBdJFP0LUpZNrJ6x8cDWG5rqh5kwGLzYIURe+4VILSppMROgVC2vWACkpwP79QJcu3F9PqVQiPT3dYF1m9puJ3JdysSVqC8eW8YtaFzYnBwgKMm1HZBuhvbFiL5Au+hGqLiKxCDdd+augE6oufMKlFpQ02TA//QR88AGwZQswejTf1rSMVCyFl7MX32ZYBBG1GyAIm+JG+Q0kDOkIeRXtQWcPUNJko+TmAosXA7NnAy+8wLc1uigYBc7fPs+3GRZHdPMmJU0EYUM8H/c8Vk46gsvdroJR0CMyW4eSJhMRYsWCXA489hjQoQPwxReWfRIkEonQqVOnNnU5dP0Qhn4+FNO+to+Fk2pdqLHlPxgaK/YG6aIfoerS36c/7kMQPJSNuH06r+03mBmh6sInXGpBSZOJqPfVERKvvQacOwd8+y3QsaNlry2VSjFq1Kg2dckqy4KDxAEDfQdayDJ+kUqlGBUcDNG9e6r9awiDY8XeIF30I1RdtkzZghOTT2D+BaDwd8uvaxKqLnzCpRaUNJmI0BbfHT4MbNoEbNwIjBxp+esrlUpcvXq1TV1Wj1qNWytuYfWo1RayjF+USiVy1Lt8050mAIbHir1BuuhHyLp0iwhEFfipoBOyLnxBC8EFjJDKPAsKgCefBGJigJUr+bGBYRhcu3bNIF06uXaCj4uPBaziH4ZhUHzmjOoflDQBaF+s2BOki36ErItILEKea39IeKigE7IufEEtB4g2YRhVwuTgAOzZAwh1s+taeS3uVN/h2wxecCkuBuvkBPja3obEBGGv3Km+g+ivovHIwhx4Fl3j2xyCYwT6q5VoLx98oOr2vW8f4CPgmzf7/tqHgPcD8Opvr/JtisVxKS6mHk0EYWO4yFwQnxWPy51K4CG/ApahTTZsGUqaTEQsgFs6ly4Br76qeiQ3cSK/tojFYgQGBraoS8qtFMgZOXxd7etui1gshndVFT2aa0JbsWKvkC76Eaou7o7u2D1zNz6o/zc6KypQcuWuRa8vVF34hEst7GLvudmzZ+P48eOYNGkS9u/fr/N6bW0t+vfvjzlz5mDz5s0GnVMoe881NADDh6sez509q9qhQ+icv30ePb16wtPJk29TLMvgwaouo9u28W0JQRBmJutgBnrNCsFf/0vC4OfH8m2OXUN7z5nIiy++iL1797b4+oYNGzBixAijzs13xcLrrwNXrgBffimMhEmpVCItLa1VXcK7httdwqRUKKC8cQNMYCDfpggGQ2LFHiFd9CN0XQIie0EJMe6duWrR6wpdFz6g6jkTiYyMhLu7u97XMjMzcfXqVcTExBh1bj4rFk6cAN59F/jvf1U3MYQAwzDIy8vT0aWmsQZypZwnq/iHKSuDpLqakqYmtBQr9g7poh8h63K76jaS7ibhSLeuYC5bNmkSsi58YdPVc0lJSXjggQfQtWtXiEQiHDhwQOeYbdu2oUePHnByckJ4eDhOnjxptuuvXr0aGzduNNv5LMW9e6pqubFjgVWr+LambbakbEH3D7tj718t3/GzaXJzVX/SmiaCsDl2pO5A1JdR2D5KBJd8qqCzZXhvIVpTU4PBgwdj0aJFeOihh3Rej42NxUsvvYRt27Zh9OjR+OyzzxAdHY3Lly8j8O9v7eHh4WhoaNB579GjR9G1a9cWr33w4EH06dMHffr0QXJycqt2NjQ0aF3j3r17AICysjLNmFgshkQigVKp1Mp01eMKhQJNl5BJJBKIxeIWx+Vy7Tsz6i6nCoUCy5dLUFYmwoEDClRX/zPeFJlMBoZhtG5VikQiSKXSFsdbst1QnxiGQW1tLcrKyrS6sv6Y9iNu372Nuqo6lJaW6vWpJV/59smUedLocukSHAE0duwIURP/rdmn1sYN8Ukul2tixdnZ2SZ8aj5ujE+NjY2ora1FaWkpnJycbMInc8xTXV2dRheZTCYon7pIu6CfWz84whUupZc1n3GWmKeGhgYtXfieJyHEXkVFBQCAkyXbrIAAwP70009aY8OHD2eXLVumNdavXz927dq17Tp3YmIi+9BDD2mNrV27lvX392eDgoJYb29v1sPDg12/fr3e97/xxhssAPqhH/qhH/qhH/qxgp/s7Ox25QmGwPudptZobGzE+fPnsXbtWq3xqKioNu8MGcLGjRs1j+Z2796NS5cu4fXXX9d77KuvvoqVTdpsV1RUICgoCHl5eejQoYPJttgKlZWVCAgIQH5+Pq9VhUKDdNGFNNEP6aIf0kU/pIsu9+7dQ2BgILy8vMx+bkEnTSUlJVAqlfDz89Ma9/PzQ1FRkcHnmTJlClJTU1FTUwN/f3/89NNPGDZsWLtscXR0hKOjo854hw4dKFD14OHhQbrogXTRhTTRD+miH9JFP6SLLlz0axJ00qRG1KyDMsuyOmOtceTIkTaPWbhwYXvNIgiCIAjCjuC9eq41fHx8IJFIdO4qFRcX69x9IgiCIAiC4BJBJ00ODg4IDw9HQkKC1nhCQgJGjRrFk1UqHB0d8cYbb+h9ZGfPkC76IV10IU30Q7roh3TRD+miC5ea8L6NSnV1NbKysgAAYWFheO+99xAZGQkvLy8EBgYiNjYW8+fPx6effoqIiAhs374dn3/+OTIyMhAUFMSn6QRBEARB2BG8J03Hjx9HZGSkzviCBQuwe/duAKrmlps2bUJhYSFCQkLw/vvvY9y4cRa2lCAIgiAIe4b3pIkgCIIgCMIaEPSaJoIgCIIgCKFASRNBEARBEIQBUNJEEARBEARhAJQ0WYD3338fAwYMQHBwMF588UVuNhG0QnJychAZGYng4GAMHDgQNTU1fJskGGpraxEUFITVq1fzbYogyM/Px4QJExAcHIxBgwbh+++/59skXjh06BD69u2L3r17Y8eOHXybIwgoNlqHPkt0MeV3Dy0E55i7d+9i5MiRyMjIgEwmw7hx47B582ZERETwbRrvjB8/Hv/9738xduxYlJWVwcPDQ7Mjtr2zbt06ZGZmIjAwEJs3b+bbHN4pLCzEnTt3EBoaiuLiYgwZMgTXrl2Dq6sr36ZZDIVCgeDgYCQmJsLDwwNDhgzBn3/+ycn+WtYExUbr0GeJLqb87qE7TRZAoVCgvr4ecrkccrkcvr6+fJvEO+okcuzYsQAALy8vSpj+JjMzE1evXkVMTAzfpgiGLl26IDQ0FADg6+sLLy8vlJWV8WuUhTlz5gwGDBiAbt26wd3dHTExMQZtEWXrUGy0DH2W6GLq7x67T5qSkpLwwAMPoGvXrhCJRDhw4IDOMdu2bUOPHj3g5OSE8PBwnDx50uDzd+rUCatXr0ZgYCC6du2KyZMno2fPnmb0gBu41iUzMxNubm6YMWMGhgwZgrffftuM1nMH17oAwOrVq7Fx40YzWWwZLKGLmnPnzoFhGAQEBJhotWUxVaPbt2+jW7dumn/7+/ujoKDAEqZzijljx1pjQx/m0MUaP0vawlRdTP3dY/dJU01NDQYPHoyPP/5Y7+uxsbF46aWXsG7dOqSlpWHs2LGIjo5GXl6e5pjw8HCEhITo/Ny+fRvl5eU4dOgQcnNzUVBQgOTkZCQlJVnKPaPhWhe5XI6TJ09i69atSElJQUJCgs52OUKEa10OHjyIPn36oE+fPpZyySxwrYua0tJSPPnkk9i+fTvnPpkbUzXSt5KiPRuXCxVzxA5g3bGhD1N1sdbPkrYwVReTf/ewhAYA7E8//aQ1Nnz4cHbZsmVaY/369WPXrl1r0Dm/++479tlnn9X8e9OmTew777xjsq2WhAtdkpOT2SlTpmj+vWnTJnbTpk0m22pJuNBl7dq1rL+/PxsUFMR6e3uzHh4e7Pr1681lskXgQheWZdn6+np27Nix7N69e81hJq8Yo9GpU6fYWbNmaV578cUX2a+++opzWy2JsbFjS7GhD2N0sYXPkrYwRhdTf/fY/Z2m1mhsbMT58+cRFRWlNR4VFYXk5GSDzhEQEIDk5GTU19dDqVTi+PHj6Nu3LxfmWgxz6DJs2DDcuXMH5eXlYBgGSUlJ6N+/PxfmWgxz6LJx40bk5+cjNzcXmzdvxtNPP43XX3+dC3Mthjl0YVkWCxcuxMSJEzF//nwuzOQVQzQaPnw4Ll26hIKCAlRVVSEuLg5Tpkzhw1yLYYguth4b+jBEF1v8LGkLQ3Qx9XcPJU2tUFJSAqVSCT8/P61xPz8/FBUVGXSOkSNHIiYmBmFhYRg0aBB69uyJGTNmcGGuxTCHLlKpFG+//TbGjRuHQYMGoXfv3pg+fToX5loMc+hii5hDl1OnTiE2NhYHDhxAaGgoQkNDcfHiRS7M5QVDNJJKpdiyZQsiIyMRFhaGl19+Gd7e3nyYazEM0cXWY0Mf9FmjH0P/H5nyu4fKlQyg+boBlmXbtZZgw4YN2LBhg7nN4h1TdYmOjkZ0dLS5zeIdU3VRs3DhQjNZJAxM0WXMmDFgGIYLswRFWxrNmDHD6r90GUNruthLbOjD0P9TtvZZ0hZt6WLK7x6609QKPj4+kEgkOpl7cXGxTiZrT5Au+iFd9EO6tA1ppB/SRT+ki34soQslTa3g4OCA8PBwnZX1CQkJGDVqFE9W8Q/poh/SRT+kS9uQRvohXfRDuujHErrY/eO56upqZGVlaf6dk5OD9PR0eHl5ITAwECtXrsT8+fMxdOhQREREYPv27cjLy8OyZct4tJp7SBf9kC76IV3ahjTSD+miH9JFP7zr0t4SP1sjMTGRBaDzs2DBAs0xW7duZYOCglgHBwd2yJAh7IkTJ/gz2EKQLvohXfRDurQNaaQf0kU/pIt++NaF9p4jCIIgCIIwAFrTRBAEQRAEYQCUNBEEQRAEQRgAJU0EQRAEQRAGQEkTQRAEQRCEAVDSRBAEQRAEYQCUNBEEQRAEQRgAJU0EQRAEQRAGQEkTQRAEQRCEAVDSRBAEQRAEYQCUNBEEQRjJhAkTIBKJIBKJkJ6ebtZz5+bmas4dGhpq1nMTBGEclDQRBGERFi5cqEkCmv5MnTqVb9NM4umnn0ZhYSFCQkIMOv6BBx7A5MmT9b6WkpICkUiE1NRUBAQEoLCwEKtWrTKnuQRBmICUbwMIgrAfpk6dil27dmmNOTo6cnrNxsZGODg4cHZ+FxcXdO7c2eDjlyxZggcffBA3b95EUFCQ1ms7d+5EaGgohgwZAgDo3Lkz3NzczGovQRDGQ3eaCIKwGI6OjujcubPWT8eOHTWvi0Qi7NixA7Nnz4aLiwt69+6Nn3/+Wescly9fRkxMDNzc3ODn54f58+ejpKRE8/qECRPw/PPPY+XKlfDx8cH9998PAPj555/Ru3dvODs7IzIyEnv27IFIJEJFRQVqamrg4eGB/fv3a13rl19+gaurK6qqqtrlZ2s2Tp8+Hb6+vti9e7fWe2praxEbG4slS5a061oEQVgOSpoIghAU69evxyOPPIILFy4gJiYG8+bNQ1lZGQCgsLAQ48ePR2hoKM6dO4f4+HjcuXMHjzzyiNY59uzZA6lUilOnTuGzzz5Dbm4uHn74YcyaNQvp6elYunQp1q1bpzne1dUVjz76qM5dsF27duHhhx+Gu7u7wfa3ZaNUKsWTTz6J3bt3g2VZzfu+//57NDY2Yt68ee3WjCAIC8ESBEFYgAULFrASiYR1dXXV+nnrrbc0xwBgX3vtNc2/q6urWZFIxB4+fJhlWZb997//zUZFRWmdNz8/nwXAXrt2jWVZlh0/fjwbGhqqdcwrr7zChoSEaI2tW7eOBcCWl5ezLMuyf/75JyuRSNiCggKWZVn27t27rEwmY48fP96iT+PHj2eXL1+uNWaIjVeuXGEBsMeOHdMcM27cOPaxxx7TucYbb7zBDh48uEUbCIKwHLSmiSAIixEZGYlPPvlEa8zLy0vr34MGDdL83dXVFe7u7iguLgYAnD9/HomJiXrX+WRnZ6NPnz4AgKFDh2q9du3aNQwbNkxrbPjw4Tr/HjBgAPbu3Yu1a9di3759CAwMxLhx49rloyE29uvXD6NGjcLOnTsRGRmJ7OxsnDx5EkePHm3XtQiCsCyUNBEEYTFcXV3Rq1evVo+RyWRa/xaJRGAYBgDAMAweeOABvPPOOzrv69Kli9Z1msKyLEQikc5Yc5566il8/PHHWLt2LXbt2oVFixbpvK8tDLVxyZIleP7557F161bs2rULQUFBmDRpUruuRRCEZaGkiSAIq2HIkCH44Ycf0L17d0ilhn989evXD3FxcVpj586d0znuiSeewJo1a/DRRx8hIyMDCxYs4MzGRx55BMuXL8fXX3+NPXv24Omnn253gkYQhGWhheAEQViMhoYGFBUVaf00rXxri+eeew5lZWV47LHHcObMGdy4cQNHjx7F4sWLoVQqW3zf0qVLcfXqVbzyyiu4fv06vvvuO031WtNEpWPHjnjwwQfx8ssvIyoqCv7+/u320VAb3dzcMHfuXPzrX//C7du3sXDhwnZfiyAIy0JJE0EQFiM+Ph5dunTR+hkzZozB7+/atStOnToFpVKJKVOmICQkBMuXL0eHDh0gFrf8cdajRw/s378fP/74IwYNGoRPPvlEUz3XvE/UkiVL0NjYiMWLFxvlY3tsXLJkCcrLyzF58mQEBgYadT2CICyHiNX3YJ8gCMLG2bBhAz799FPk5+drjX/11VdYvnw5bt++3WZTzAkTJiA0NBQffPABZ3a++eabOHDggNm3aSEIov3QnSaCIOyCbdu24ezZs7hx4wb27duHd999V2vNUm1tLTIyMrBx40YsXbrU4C7i27Ztg5ubGy5evGhWe/Py8uDm5oa3337brOclCMJ46E4TQRB2wYoVKxAbG4uysjIEBgZi/vz5ePXVVzWLtd98801s2LAB48aNw8GDBw3avqSgoAB1dXUAgMDAQLNu16JQKJCbmwtA9QgxICDAbOcmCMI4KGkiCIIgCIIwAHo8RxAEQRAEYQCUNBEEQRAEQRgAJU0EQRAEQRAGQEkTQRAEQRCEAVDSRBAEQRAEYQCUNBEEQRAEQRgAJU0EQRAEQRAGQEkTQRAEQRCEAfx/DFQMugQ55Z8AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Data for the SED model of Synchrotron no-losses in Potter and Cotter in Figure 3 \n", "x = [\n", @@ -742,21 +423,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "bf432d89", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Data for the SED model of Synchrotron no-losses in Potter and Cotter in Figure 3 \n", "x = [\n", @@ -805,7 +475,7 @@ ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -819,7 +489,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.12.12" } }, "nbformat": 4, From f0df5181cbbddda95153e495c0c5765424db179c Mon Sep 17 00:00:00 2001 From: Udai Sharma Date: Thu, 26 Mar 2026 08:17:03 +0100 Subject: [PATCH 3/5] Extended Jet modelling Updates: - Implemented Jet power and Equiparition parameter as a parameter to cone model - Removed initial radius as a parameter to cone model (depends on jet power) - Merged synchrotron cone and synchrotron blob to make a base synchrotron class - the qualitative shape for the electron distribution plot works out although differs quantitatively with C&P Model - problems with synchrotron cooling; becomes significant at larger distances than expected? [ci skip] --- agnpy/emission_regions/cone.py | 98 ++-- agnpy/synchrotron/BaseSynchrotron.py | 429 ++++++++++++++++++ agnpy/synchrotron/__init__.py | 5 +- agnpy/synchrotron/proton_synchrotron.py | 2 +- .../{synchrotron.py => synchrotron_blob.py} | 8 +- agnpy/synchrotron/synchrotron_cone.py | 23 +- electron_evolution.ipynb | 393 +++++++++------- 7 files changed, 710 insertions(+), 248 deletions(-) create mode 100644 agnpy/synchrotron/BaseSynchrotron.py rename agnpy/synchrotron/{synchrotron.py => synchrotron_blob.py} (98%) diff --git a/agnpy/emission_regions/cone.py b/agnpy/emission_regions/cone.py index 839c6bbb..f9d7052d 100644 --- a/agnpy/emission_regions/cone.py +++ b/agnpy/emission_regions/cone.py @@ -49,7 +49,8 @@ class Cone: ## Keeping the default parameters same as defined in Blob (CΟNFIRM FOR NEW PARAMETERS!!!!) def __init__( self, - R_o =1e16 * u.cm, + W_j =(1e34 * u.W).to('erg s-1'), + A_equi = 1.0, L = 1e18 * u.cm, theta = 5 * u.deg, z=0.033, @@ -65,7 +66,8 @@ def __init__( if not isinstance(delta_D, numbers.Number) or delta_D <= 0: raise ValueError("delta_D must be a positive number") - self.R_o = R_o.to("cm") + self.W_j = W_j.to('erg s-1') + self.A_equi = A_equi self.L = L.to("cm") self.theta = theta.to("rad") self.z = z @@ -86,12 +88,16 @@ def V_c(self): 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_o(self): + """Radius at base derived from lab frame jet power and equipartition""" + u_B = ((self.B_o**2)/(8*np.pi)).to('erg cm-3') + R_o_squared = (self.W_j)/(2*u_B*np.pi*(self.Gamma**2)*c.cgs) + return np.sqrt(R_o_squared).to('cm') + @property def R_x(self): - return self.R_o + self.x * np.tan(self.theta.value) - - #For a jet with a constant bulk Lorentz factor which conserves magnetic energy in each segment the magnetic field - # will change as a function of the radius of the jet so that the total magnetic energy is conserved in a segment. + return self.R_o + self.x * np.tan(self.theta) @property def B_x(self): @@ -99,10 +105,7 @@ def B_x(self): @property def x(self): - x = np.logspace( - np.log10(1e-3), # small value to avoid exactly 0, in cm - np.log10(self.L.to_value("cm")), - self.x_size) * u.cm + x = np.logspace(np.log10(1), np.log10(self.L.to_value("cm")), self.x_size) * u.cm return x @property @@ -113,7 +116,7 @@ def gamma_e(self): 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_external_frame(self): """Array of electrons Lorentz factors, to be used for integration in the @@ -123,41 +126,45 @@ def gamma_e_external_frame(self): ## 3. Electron Properties: Number Density, Total Number, Energy Density, Total Energy @property def n_e_base(self): - """Electron distribution.""" - return self._n_e(self.gamma_e) + """Electron distribution as obtained by agnpy.spectra + units: cm-3 + """ + return self._n_e(self.gamma_e) @property def N_e_base(self): - """Number of electrons at the base in a width of 1 cm""" - return self.n_e_base * np.pi * self.R_o**2 * (1 * u.cm) + """Number of electrons at the base in a slice of width 1 cm""" + return self.n_e_base * np.pi * (self.R_o**2) @property def norm_equi(self): + """Modified normalization to convolve with input electron distribution + to impose equipartition. Obtained by equating Magnetic Energy at the base to + Electron Energy. + units: cm-3""" e_energy_initial = np.trapz(self.gamma_e * self.N_e_base, self.gamma_e) - K_dash = ( np.pi * self.R_o**2 * self.B_o ** 2 ) / (8 * np.pi * mec2 * e_energy_initial ) - return K_dash - - """ - def norm_equi(self): - e_energy_initial = np.trapz(self.gamma_e * self.N_e_xg, self.gamma_e) - K_dash = ( np.pi * self.R_x**2 * self.B_x ** 2 ) / (8 * np.pi * mec2 * e_energy_initial ) - return K_dash - """ + K_dash = ( np.pi * self.R_o**2 * (self.B_o ** 2) ) / (8 * np.pi * mec2 * e_energy_initial ) + return K_dash.cgs + @property def N_e_xg(self): + """Solution to the Electron Evolution Equation as described in Eq 11 in Cotter[2018] + Returns: the number of electrons per cm at position x along the jet axis""" n0 = self.norm_equi * self.N_e_base[None,:] # (1, N_gamma) - int_B = cumulative_trapezoid((self.B_x)**2, self.x, initial=0) # (N_x, 1) - cooling = ( sigma_T.cgs * self.gamma_e[None,:] *int_B[:,None] ) / ( 6 * np.pi * mec2.cgs ) - N_e_xg = n0 * np.exp(-cooling.value) + int_B = cumulative_trapezoid((self.B_x)**2, self.x, initial=0) # (N_x, 1) + cooling = ( sigma_T.cgs * self.gamma_e[None,:] *(int_B[:,None])) / ( 6 * np.pi * mec2.cgs ) + N_e_xg = n0 * np.exp(-cooling.value) return (N_e_xg).cgs @property def N_e_gamma(self): - N_e_gamma = np.trapz( self.N_e_xg, self.x, axis=0) + """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 @@ -192,41 +199,6 @@ def N_e(self): """ N_e = np.trapz(self.N_e_x, self.x) return N_e - - @property - def P_jet_ke(self): - r"""Total jet power in kinetic energy of the particles - - .. math:: - P_{{\rm jet},\,{\rm ke}} = 2 \pi R_{\rm b}^2 \beta \Gamma^2 c (u_{\rm e} + u_{\rm p}). - """ - P_jet_ke = (1/self.L) * c.cgs * self.Beta * self.Gamma**2 * (np.trapz(self.U_e_x, self.x)) - return P_jet_ke.to("erg s-1") - - @property - def P_jet_B(self): - r"""Jet power in magnetic field as a function of distance - - .. math:: - P_{\mathrm{jet},\,B} = 2 \pi R_{\rm b}^2 \beta \Gamma^2 c \frac{B^2}{8\pi}. - """ - P_jet_B = (1/self.L) * c.cgs * self.Gamma**2 * (np.trapz(self.U_b_x, self.x)) - return P_jet_B.to("erg s-1") - - @property - def P_total_jet(self): - P_total_jet = self.P_jet_B + self.P_jet_ke - return P_total_jet - - @property - def A_eq_base(self): - return (self.U_e_x[0] / self.U_b_x[0]).to_value("") - - @property - def k_eq(self): - """Equipartition parameter: ratio between totoal particle energy density - and magnetic field energy density, Eq. 7.75 of [DermerMenon2009]_""" - return (self.P_jet_ke / self.P_jet_B).to_value("") @property def Beta(self): diff --git a/agnpy/synchrotron/BaseSynchrotron.py b/agnpy/synchrotron/BaseSynchrotron.py new file mode 100644 index 00000000..321f9b57 --- /dev/null +++ b/agnpy/synchrotron/BaseSynchrotron.py @@ -0,0 +1,429 @@ +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 + +#Common Utility Functions +def nu_obs_to_nu_fluid(nu_obs, z, delta_D): + nu_fluid = nu_obs * (1+ z) / delta_D + return nu_fluid + +def nu_synch_peak(B, gamma, mass=m_e): + """observed peak frequency for monoenergetic electrons + Eq. 7.19 in [DermerMenon2009]_""" + 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): + """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) + +def tau_to_attenuation(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) + +#Utility Functions for Blob +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 + +#Utility Functions for Cone +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, + ): + """ + 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) + + Note: Input correctly shaped arrays (B_x, gamma_e, N_e_xg, nu_obs) as per emitter geometry + """ + # 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³ B / (m c²) --- + prefactor = (np.sqrt(3) * (e)**3 / (mec2.cgs)).cgs + emission = prefactor * gamma_integral + P_synch = integrator(emission, x, axis=0) + return Z_eta, P_synch.to("erg Hz-1 s-1") + +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) + +class SynchrotronCone(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.emitter = emitter + self.ssa = ssa + self.integrator = integrator + + def flux_obs(self, nu_obs): + 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) + 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)) + L_v_obs = L_v_fluid * self.emitter.delta_D**3 + self.F_v_obs = L_v_obs / (4 * np.pi * np.power(self.emitter.d_L, 2)) + return self.F_v_obs + + 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) + prefactor = 1 / (8 * np.pi * m_e.cgs* self.nu_fluid[None, :]**2) + integrand = np.gradient( n_e_xg_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)**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 = 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_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 f04f09f4..3035c043 100644 --- a/agnpy/synchrotron/__init__.py +++ b/agnpy/synchrotron/__init__.py @@ -1,3 +1,4 @@ -from .synchrotron import * +from .BaseSynchrotron import * from .proton_synchrotron import * -from .synchrotron_cone 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 index 35f51e26..16f2d53d 100644 --- a/agnpy/synchrotron/synchrotron_cone.py +++ b/agnpy/synchrotron/synchrotron_cone.py @@ -5,7 +5,17 @@ from ..utils.conversion import nu_to_epsilon_prime, B_to_cgs, lambda_c_e, mec2 from ..radiative_process import RadiativeProcess -class SynchrotronCone(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 @@ -22,14 +32,14 @@ class SynchrotronCone(RadiativeProcess): function to be used for integration (default = `np.trapz`) """ - def __init__(self, emitter, nu_obs, ssa=False, integrator=np.trapz): + def __init__(self, emitter, ssa=False, integrator=np.trapz): self.emitter = emitter - self.nu_obs = nu_obs self.ssa = ssa self.integrator = integrator - def nu_obs_to_nu_fluid(self): - self.nu_fluid = self.nu_obs * (1+ self.emitter.z) / self.emitter.delta_D + # 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): @@ -110,7 +120,6 @@ def P_sync( x, # spatial coordinate array (Quantity) gamma_e, # Electron Lorentz factor array (ndarray) N_e_xg, # electron distribution array shape (N_x, N_gamma) - mass=m_e, integrator=np.trapz, ): """ @@ -130,7 +139,7 @@ def P_sync( axis=1 ) # (N_x, N_nu) # --- prefactor √3 e³ B / (m c²) --- - prefactor = (np.sqrt(3) * (e.gauss)**3 * B_x[:, None] / (mass.cgs * c.cgs**2)).cgs + 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") diff --git a/electron_evolution.ipynb b/electron_evolution.ipynb index 0be2cb59..00fd53fb 100644 --- a/electron_evolution.ipynb +++ b/electron_evolution.ipynb @@ -5,25 +5,18 @@ "execution_count": 1, "id": "28e94ed1", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/cosimo/work/agnpy/master/agnpy/agnpy/synchrotron/synchrotron_cone.py:87: SyntaxWarning: invalid escape sequence '\\k'\n", - " \\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" - ] - } - ], + "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 synchrotron_cone\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\n", + "from astropy.constants import c, sigma_T, m_e, e, mu0\n", "#e = e.gauss\n", "import matplotlib.pyplot as plt" ] @@ -46,17 +39,18 @@ "# 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", - "R_o = ( 7.32 * 1e13 * u.m ).to(u.cm)\n", + "W_j = 7.63 * 1e36 * u.W\n", "L = (1e19 * u.m).to(u.cm)\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_maximum = (5.6 * 1e9 * u.eV / mec2.to(\"eV\")).value\n", "\"\"\"The normalization parameter is left to default, eq (7) in C. & P. leads to norm = 0? since alpha = 2\"\"\"\n", - "n_e = ExpCutoffPowerLaw(k=10, p = p, gamma_min = 0.1*gamma_minimum, gamma_max= 100*gamma_maximum, gamma_c= gamma_maximum )" + "n_e = ExpCutoffPowerLaw(k=100, p = p, gamma_min = 0.1*gamma_minimum, gamma_max= 100*gamma_maximum, gamma_c= gamma_maximum )" ] }, { @@ -66,78 +60,120 @@ "metadata": {}, "outputs": [], "source": [ - "jet = Cone(B_o = B_o, R_o = R_o , L = L, theta = theta_open, Gamma=Gamma, n_e = n_e,x_size=500,gamma_e_size=500, z =z)\n", + "jet = Cone(B_o = B_o, W_j = W_j, L = L, theta = theta_open, Gamma=Gamma, n_e = n_e,x_size=500,gamma_e_size=500, z =z)\n", "jet.set_delta_D(Gamma=Gamma,theta_s = theta_s)" ] }, { "cell_type": "markdown", - "id": "b4998849", + "id": "e66b35d3", "metadata": {}, "source": [ - "# Plots \n", - "- Electron energy density as a function of x\n", - "- Total electrons as a function of gamma\n", - "- \n", - "- Electron energy density vs Magnetic energy density: Proxy for Equipartition parameter\n", - "\n", - "*Things to note:*\n", - "- Electron density decays as 1/R(x)^2, as expected due to the geometrical dilution included in the evolution equation. \n", - "- Number of electrons stay constant as a function of x, due to the inclusion of geometrical dilution. This makes more physical sense, as the electrons only cool radiatively to shift to lower energies. Overall, should remain constant.\n", - "- Number of electrons drop linearly first, and then exponentially (@ γ>1e3) as a function of gamma, due to a exponential cut-off power law assumption of initial electron distribution\n", - "- Number of electrons vs energy at a particular x: Same distribution for any x above x=0?\n", - "- Equipartition: Starts at 1 and remains constant @ 1.2 throughout\n", - "- Magnetic and Electron energy density drop off as the inverse of radius squared, geometrical dilution" + "Formula used by Cotter and Potter (equation 8) yields the same R_o but in the Parameter table, R_o is mentioned as 7.32 * 1e13 m \n", + "which (coincidentally?) is compatible with our jet with W_j = 0.1* W_j" ] }, { "cell_type": "code", "execution_count": 4, - "id": "0ebc6dc6", + "id": "eed5ef62", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$2.3162959 \\times 10^{16} \\; \\mathrm{cm}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jet.R_o" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6278f724", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$2.3162959 \\times 10^{14} \\; \\mathrm{m}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Ro_using_cotter = (np.sqrt((2 *mu0 * 7.63 * 1e36 * u.W ) / (2 * c * 144 * np.pi * (3.63 * 1e-5 * u.T)**2 ))).to('m')\n", + "Ro_using_cotter" + ] + }, + { + "cell_type": "markdown", + "id": "b4998849", + "metadata": {}, + "source": [ + "# Plots " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "239e39d6", "metadata": {}, "outputs": [], "source": [ - "# Data\n", - "data = [\n", - "(575439.9373371543, 7.692946554041625e+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", - "(46989410.860521704, 1.1534180805525196e+44),\n", - "(147231250.24327165, 3.8169973137017866e+43),\n", - "(831763771.1026742, 6.485157528062233e+42),\n", - "(3076096814.7407174, 1.1725707943387419e+42),\n", - "(10964781961.43192, 7.858944800779638e+40),\n", - "(28575905433.749672, 1.2244668158998756e+39),\n", - "(59703528658.38415, 2.0753248803736612e+36),\n", - "(89536476554.96011, 4.373153302721358e+33),\n", - "(129419584144.9997, 1.4766294411828247e+30),\n", - "(109647819614.31963, 7.740013565615246e+31),\n", - "(39084089579.24041, 1.164019524379192e+38),\n", - "(18030177408.59577, 1.2817831835790027e+40),\n", - "(5445026528.424242, 4.4349366153056454e+41),\n", - "(1614358556.8264935, 2.865619626947542e+42),\n", - "(325087297.38543606, 1.693846972334023e+43),\n", - "(23768402.866248783, 2.075324880373661e+44)\n", + "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", - "\n", - "# Split into x and y\n", - "x_ = [d[0] for d in data]\n", - "y_ = [d[1] for d in data]" + "x_data, y_data = zip(*coordinates)" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "caaeb6f4", + "execution_count": 7, + "id": "e2f2b416", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -145,72 +181,98 @@ } ], "source": [ - "fig, ax = plt.subplots(1, 3, sharey=True, figsize=(10, 4))\n", - "factor = 2 * 3 * 1e10\n", - "#for i, _n_e_g in enumerate(jet.N_e_xg[0]):\n", - "ax[0].set_title(\"x = 0\")\n", - "ax[0].loglog((mec2 * jet.gamma_e).to('eV'), factor * jet.gamma_e * jet.N_e_xg[0], label=f\"x={0}\", ls=\"--\")\n", - "ax[0].loglog(x_, y_, ls=\"-\")\n", - "\n", - "ax[1].set_title(\"x = 1/2 L\")\n", - "ax[1].loglog((mec2 * jet.gamma_e).to('eV'), factor * jet.gamma_e * jet.N_e_xg[368], label=f\"x={1}\", ls=\"--\")\n", - "ax[1].loglog(x_, y_, ls=\"-\")\n", - "\n", - "ax[2].set_title(\"x = L\")\n", - "ax[2].loglog((mec2 * jet.gamma_e).to('eV'), factor * jet.gamma_e * jet.N_e_xg[-1], label=f\"x={2}\", ls=\"--\")\n", - "ax[2].loglog(x_, y_, ls=\"-\")\n", + "energy = (mec2.cgs * jet.gamma_e).to('eV')\n", + "linear_interp = interp1d(x_data, y_data, kind=\"linear\") # degree = number of points - 1\n", + "y_linear = linear_interp(energy.value[5:445])\n", "\n", - "ax[0].set_xlim(1e5,1e12)\n", - "ax[0].set_ylim(1e38, 1e50)\n", + "plt.scatter(x_data, y_data, color=\"black\")\n", + "plt.loglog(energy.value[5:445], y_linear, label=\"Linear\", color=\"red\")\n", + "plt.legend(); plt.title(\"Linear 1D Interpolation\")\n", + "plt.ylim(1e30,1e50)\n", "plt.show()" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "244bc577-6fb1-4835-9d64-3fe936743c97", + "cell_type": "markdown", + "id": "888db6b3", "metadata": {}, - "outputs": [], "source": [ - "jet.N_e_xg[0]" + "The following plot shows how energy is distributed among electrons, because high-energy electrons carry more energy. This is to show which energies dominate the total electron energy.\n" ] }, { "cell_type": "code", - "execution_count": null, - "id": "ecda3634", + "execution_count": 10, + "id": "ead512c1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAHMCAYAAADBOf6HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACXEklEQVR4nOzdd3yV9fn/8dc5J3svsjcQEkbYIqAoqCi4cFSsVtCiddQqInX8bGu1tbbWgaPSqrW01W/Fuqso4gI1ijLCDDtkLxKy9znn98dJAiEkJpDkPgnv5+NxHuTc5z7nXMdB3rly3Z+PyW632xERERERkeMyG12AiIiIiIgzU2AWEREREemCArOIiIiISBcUmEVEREREuqDALCIiIiLSBQVmEREREZEuKDCLiIiIiHRBgVlEREREpAsKzCIiIiIiXVBgFhERERHpggKziIiIiEgXBkVgdnFxYdy4cYwbN44bb7yx7fj777/PiBEjGD58OC+99JKBFYqIiIjIQGWy2+12o4s4WSEhIRw6dKjdsebmZkaOHMnnn3+On58fEyZMYP369QQFBRlUpYiIiIgMRIOiw3w83333HaNGjSIqKgpfX1/mzp3L6tWrjS5LRERERAYYwwPzunXruPjii4mMjMRkMvHOO+90OOf5558nISEBDw8PJk6cyJdfftnu8crKSiZOnMgZZ5zB2rVrAcjPzycqKqrtnOjoaPLy8vr0s4iIiIjI4ONidAE1NTWMHTuWG264gSuuuKLD4ytXrmTx4sU8//zzTJ8+nb/97W/MmTOHnTt3EhsbC8DBgweJjIxk+/btXHjhhWzbto3jTZqYTKZO62hoaKChoaHtvs1mo6ysjODg4C6fJyIiIiLGsNvtVFVVERkZidnch31guxMB7G+//Xa7Y6eddpr9lltuaXcsOTnZft999x33NS644AL7999/b//666/t8+bNazt+xx132F999dVO3/vBBx+0A7rppptuuummm266DbBbTk7OiQfQbjC8w9yVxsZGNm7cyH333dfu+OzZs0lLSwPg8OHDeHl54e7uTm5uLjt37iQxMRE/Pz+2b99OXl4efn5+rFq1it/85jedvtf999/PkiVL2u5XVFQQGxtLTk4Ofn5+ffMBRUREROSEVVZWEhMTg6+vb5++j1MH5kOHDmG1WgkLC2t3PCwsjMLCQgAyMjK4+eabMZvNmEwmnn766baVMJ544glmzpyJzWbjnnvuITg4uNP3cnd3x93dvcNxPz8/BWYRERERJ9bX47NOHZhbHfsPwW63tx2bNm0a27ZtO+7zLrnkEi655JI+r09EREREBi/DV8noSkhICBaLpa2b3Kq4uLhD11lEREREpC84dWB2c3Nj4sSJrFmzpt3xNWvWMG3aNIOqEhEREZFTieEjGdXV1ezbt6/tfmZmJunp6QQFBREbG8uSJUu47rrrmDRpElOnTuWFF14gOzubW265xcCqRUREBj6r1UpTU5PRZYh0ytXVFYvFYnQZxgfmDRs2MHPmzLb7rStVLFy4kBUrVjB//nxKS0t5+OGHKSgoYPTo0axatYq4uDijShYRERnQ7HY7hYWFlJeXG12KyA8KCAggPDzc0H0xTHb7cXb4ECorK/H396eiokKrZIiIyKBSUFBAeXk5oaGheHl5aYMucUp2u53a2lqKi4sJCAggIiKiwzn9ldcM7zCLiIhI/7FarW1huavlVkWcgaenJ+BY8CE0NNSw8QynvuhPREREelfrzLKXl5fBlYh0T+t/q0bO2yswi4iInII0hiEDhTP8t6rALCIiIiLSBQVmEREREZEuKDCLiIiIdKKhoYFf/OIXhISE4O3tzSWXXEJubq7RZUk/U2AWERER6cTixYt5++23ee211/jqq6+orq7moosuwmq1Gl2a9CMFZhEREXF6JSUlhIeH84c//KHt2Pr163Fzc+Pjjz/uk/esqKjg73//O0888QTnnnsu48eP55VXXmHbtm188sknffKe4py0DrOIiMipzm6H2lpj3tvLC7qxCsKQIUN4+eWXmTdvHrNnzyY5OZmf/OQn3HbbbcyePbvT540aNYqsrKxOH4+Li2PHjh3HfWzjxo00NTW1e/3IyEhGjx5NWloa559//g/WLYODArOIiMiprrYWfHyMee/qavD27tapc+fO5aabbuLaa69l8uTJeHh48Mc//rHL56xatarL9XtdXV07faywsBA3NzcCAwPbHQ8LC6OwsLBbNcvgoMAsIiIiA8bjjz/O6NGjef3119mwYQMeHh5dnh8XF9frNdjtdqdYG1j6jwKziIjIqc7Ly9HpNeq9e+DAgQPk5+djs9nIysoiNTW1y/NPZiQjPDycxsZGDh8+3K7LXFxczLRp03pUtwxsCswiIiKnOpOp22MRRmpsbOTaa69l/vz5JCcns2jRIrZt20ZYWFinzzmZkYyJEyfi6urKmjVruOqqqwAoKChg+/btPPbYYyf+QWTAUWAWERGRAeGBBx6goqKCZ555Bh8fHz788EMWLVrE+++/3+lzTmYkw9/fn0WLFnH33XcTHBxMUFAQS5cuZcyYMZx77rkn/Loy8GhZOREREXF6X3zxBcuWLePf//43fn5+mM1m/v3vf/PVV1+xfPnyPnvfp556innz5nHVVVcxffp0vLy8+N///ofFYumz9xTnY7Lb7Xaji3BGlZWV+Pv7U1FRgZ+fn9HliIiI9Ir6+noyMzNJSEj4wQvmRJxBV//N9ldeU4dZRERERKQLCswiIiIiIl1QYBYRERER6YICs4iIiIhIFxSYRURERES6oMAsIiIiItIFBWYRERERkS4oMIuIiIiIdEGBWURERESkCwrMIiIiIp0wmUy88847RpfRL+Lj41m2bFnb/VPps/8QBWYRERGRThQUFDBnzpxun79ixQoCAgL6rqB+1NPP/tvf/pZx48b1XUEGcjG6ABERERFnFR4ebsj7Wq1WTCYTZrNxvU2jPrszUodZREREnF5JSQnh4eH84Q9/aDu2fv163Nzc+Pjjj/vsfY8eSzh48CAmk4m33nqLmTNn4uXlxdixY/nmm28A+OKLL7jhhhuoqKjAZDJhMpn47W9/C0BjYyP33HMPUVFReHt7M2XKFL744ou292ntTL///vuMHDkSd3d3srKyiI+P5/e//z0LFizAx8eHuLg43n33XUpKSrj00kvx8fFhzJgxbNiwoV3daWlpzJgxA09PT2JiYrjjjjuoqalpe7y4uJiLL74YT09PEhISePXVV7v87AD33nsvSUlJeHl5kZiYyK9//Wuampra6n/ooYfYsmVL22dfsWIFABUVFfzsZz8jNDQUPz8/Zs2axZYtW07y30z/UmAWERE5xdntdhqtxtzsdnu3ahwyZAgvv/wyv/3tb9mwYQPV1dX85Cc/4bbbbmP27NmdPm/UqFH4+Ph0ehs1alSP/3k98MADLF26lPT0dJKSkvjxj39Mc3Mz06ZNY9myZfj5+VFQUEBBQQFLly4F4IYbbuDrr7/mtddeY+vWrfzoRz/iggsuYO/evW2vW1tby6OPPspLL73Ejh07CA0NBeCpp55i+vTpbN68mQsvvJDrrruOBQsW8JOf/IRNmzYxbNgwFixY0PbPctu2bZx//vlcfvnlbN26lZUrV/LVV19x++23t73X9ddfz8GDB/nss8944403eP755ykuLu7yc/v6+rJixQp27tzJ008/zYsvvshTTz0FwPz587n77rsZNWpU22efP38+drudCy+8kMLCQlatWsXGjRuZMGEC55xzDmVlZT3+Z28UjWSIiIic4pps8OTWUkPee0lqMG6W7p07d+5cbrrpJq699lomT56Mh4cHf/zjH7t8zqpVq9q6oMfj6urak3IBWLp0KRdeeCEADz30EKNGjWLfvn0kJyfj7++PyWRqN86wf/9+/vOf/5Cbm0tkZGTba3z00Uf84x//aOuaNzU18fzzzzN27NgOn/vmm28G4De/+Q3Lly9n8uTJ/OhHPwIcnd+pU6dSVFREeHg4f/7zn7nmmmtYvHgxAMOHD+eZZ57hrLPOYvny5WRnZ/Phhx/y7bffMmXKFAD+/ve/k5KS0uXn/tWvftX2dXx8PHfffTcrV67knnvuwdPTEx8fH1xcXNp99s8++4xt27ZRXFyMu7s7AI8//jjvvPMOb7zxBj/72c969g/fIArMIiIiMmA8/vjjjB49mtdff50NGzbg4eHR5flxcXG9XkNqamrb1xEREYBjxCE5Ofm452/atAm73U5SUlK74w0NDQQHB7fdd3Nza/fax3u/sLAwAMaMGdPhWHFxMeHh4WzcuJF9+/a1G7Ow2+3YbDYyMzPZs2cPLi4uTJo0qe3x5OTkH7xY8Y033mDZsmXs27eP6upqmpub8fPz6/I5GzdupLq6ut3nBKirq2P//v1dPteZKDCLiIic4lzNjk6vUe/dEwcOHCA/Px+bzUZWVtZxA+bRRo0aRVZWVqePx8XFsWPHjh7VcHRX2mQyAWCz2To932azYbFY2LhxIxZL+3a6j49P29eenp5tr/dD79dVDTabjZtvvpk77rijw2vFxsaye/fuds/rjm+//Zarr76ahx56iPPPPx9/f39ee+01nnjiiS6fZ7PZiIiIaDev3WogrSaiwCwiInKKM5lM3R6LMFJjYyPXXnst8+fPJzk5mUWLFrFt27a2Duvx9MVIRlfc3NywWq3tjo0fPx6r1UpxcTFnnnlmr77f8UyYMIEdO3YwbNiw4z6ekpJCc3MzGzZs4LTTTgNg9+7dlJeXd/qaX3/9NXFxcTzwwANtx479QeR4n33ChAkUFhbi4uJCfHz8iX0gJ6DALCIiIgPCAw88QEVFBc888ww+Pj58+OGHLFq0iPfff7/T5/TFSEZX4uPjqa6u5tNPP2Xs2LF4eXmRlJTEtddey4IFC3jiiScYP348hw4d4rPPPmPMmDHMnTu3V2u49957Of300/n5z3/OTTfdhLe3NxkZGaxZs4Znn32WESNGcMEFF3DTTTfxwgsv4OLiwuLFi/H09Oz0NYcNG0Z2djavvfYakydP5oMPPuDtt9/u8NkzMzNJT08nOjoaX19fzj33XKZOncq8efP405/+xIgRI8jPz2fVqlXMmzev3ViIM9MqGSIiIuL0vvjiC5YtW8a///1v/Pz8MJvN/Pvf/+arr75i+fLlRpfXZtq0adxyyy3Mnz+fIUOG8NhjjwHwj3/8gwULFnD33XczYsQILrnkEtavX09MTEyv15CamsratWvZu3cvZ555JuPHj+fXv/5127x1az0xMTGcddZZXH755W3LvnXm0ksv5a677uL2229n3LhxpKWl8etf/7rdOVdccQUXXHABM2fOZMiQIfznP//BZDKxatUqZsyYwU9/+lOSkpK4+uqrOXjwYJe/GXA2Jnt313M5xVRWVuLv709FRcUPDrSLiIgMFPX19WRmZpKQkPCDF8yJOIOu/pvtr7ymDrOIiIiISBcUmEVEREREuqDALCIiIiLSBQVmEREREZEuKDCLiIiIiHRBgVlEREREpAuDJjDX1tYSFxfH0qVLAceONePGjWu7eXp68s477xhbpIiIiIgMOINmp79HHnmEKVOmtN0fMWIE6enpAFRXVxMfH895551nUHUiIiIiMlANig7z3r172bVrV6dbS7733nucc845eHt793NlIiIiIjLQGR6Y161bx8UXX0xkZCQmk+m4YxPPP/982+4uEydO5Msvv2z3+NKlS3n00Uc7fY/XX3+d+fPn93bpIiIiInIKMDww19TUMHbsWJ577rnjPr5y5UoWL17MAw88wObNmznzzDOZM2cO2dnZALz77rskJSWRlJR03OdXVlby9ddfd9p9FhEREelMfHw8y5YtM7oMMZjhM8xz5sxhzpw5nT7+5JNPsmjRIm688UYAli1bxurVq1m+fDmPPvoo3377La+99hr//e9/qa6upqmpCT8/P37zm98AjkB9/vnnd9h7/FgNDQ00NDS03a+srOyFTyciIiIiA53hHeauNDY2snHjRmbPnt3u+OzZs0lLSwPg0UcfJScnh4MHD/L4449z0003tYVl6P44xqOPPoq/v3/bLSYmpnc/jIiIiJywkpISwsPD+cMf/tB2bP369bi5ufHxxx8bWJmcCgzvMHfl0KFDWK1WwsLC2h0PCwujsLDwB59fUVHBd999x5tvvvmD595///0sWbKk7X5lZaVCs4iInBLsdjvWujpD3tvi6YnJZPrB84YMGcLLL7/MvHnzmD17NsnJyfzkJz/htttu69BYO9qoUaPIysrq9PG4uDh27NhxQrXLqcOpA3OrY/9Hstvtx/2f6/rrr29339/fn6Kiom69h7u7O+7u7idco4iIyEBlravj9cmTDXnvq77/Hhcvr26dO3fuXG666SauvfZaJk+ejIeHB3/84x+7fM6qVatoamrq9HFXV9ce1SunJqcOzCEhIVgslg7d5OLi4g5dZxERERn8Hn/8cUaPHs3rr7/Ohg0bfvAapbi4uH6qTAYzpw7Mbm5uTJw4kTVr1nDZZZe1HV+zZg2XXnqpgZWJiIgMHhZPT676/nvD3rsnDhw4QH5+PjabjaysLFJTU7s8XyMZ0hsMD8zV1dXs27ev7X5mZibp6ekEBQURGxvLkiVLuO6665g0aRJTp07lhRdeIDs7m1tuucXAqkVERAYPk8nU7bEIIzU2NnLttdcyf/58kpOTWbRoEdu2bevyt84ayZDeYHhg3rBhAzNnzmy733rh3cKFC1mxYgXz58+ntLSUhx9+mIKCAkaPHs2qVav0K5Y+0lxfj9nVFbPFYnQpIiIi7TzwwANUVFTwzDPP4OPjw4cffsiiRYt4//33O31Ob+SFvLw80tPT2x2LjY0lKCjopF9bBgaT3W63G12EM6qsrMTf35+Kigr8/PyMLqffpP3hCQ68+yaWiBj8o6OJSh1N4oWz8Y2KMro0ERHpBfX19WRmZrbtoDtQfPHFF5x33nl8/vnnnHHGGQBkZ2eTmprKo48+yq233ton7xsfH3/ckY5//OMfHRYbkL7R1X+z/ZXXDO8wi3Mp3rsXc3UF9r0VlO/dTvnnH7H9mSewh0XhER5FcEICcdOmEHfu2Vjc3IwuV0REThFnn312h9GK2NhYysvL+/R9Dx482KevLwODArO0M+epP3HgwzXkbtjE4awsGgtzMR8+hKkwl8bCXArS11Pw9mukeXhhjozFNzKK8JRkhl1wLoHJx9+eXERERGQg00hGJ07VkYzjKd2ewf7Vn1KYkUF1fi62ghzMjQ0dzrOGhOMWHkVQbCyxkyeSMOdc3Hx9DahYREQ6M1BHMuTU5QwjGQrMnVBg7lxzfT3Zaz4nK209hzIzaSjMxVzScedFu6sbRMbiHR5JaNJwEmedRdik8ZjMTr0ju4jIoKbALAONArMTU2DumarsHPZ98DEFW7dRkZeLNT8bc11Nh/OsAcG4REQTGB1D1NhUhl54Hl6hoQZULCJyalJgloFGgdmJKTCfHFtzM/lffUPm2q8o2buPuoI8KMrDZLe1O89usWAPj8EzPIqQxAQSzphG9NnTMbtovF5EpC8oMMtA4wyBWalE+oTZxYXos88k+uwz247VlRziwKrV5G7aQnl2Fk0FuZiryjHlHaQh7yB5G78m77+vYPPxwxwRg19kNBGjUhh2wXn4D4037sOIiIjIKU0d5k6ow9z37HY7JZu2cOCTzynatZvq/FwozMHU3Nz+PJMJW2gUHuGRBMXFEztlEvHnzcTV2/l3pRIRcTbqMMtAow6znNJMJhOhE8cROnFc27GmmhoyP/yEnPXfU3bwoOOCwrISLEW5NBXlUrTlO4ree531v/PCFBmLT3gk4SOSSDxvJiFjRuqCQhEREel16jB3Qh1m51G+Zx/7P/yYgu0ZVOXnYC3IwdxQ3+E8a0gYruGOCwqjJ4xl6Jzz8AgKNKBiERHnpQ6zDDTO0GFWYO6EArPzsjY1kfvpWg5+lcah/QeoK8jFXFLQ4Ty7iyv2yDi8wiMJHZZI/IzpRE49TRcUisgpTYFZBhoFZiemwDyw1BQUsv/9j8hL30pFTjbNBTmYa6s7nGf1D8ISEYN/VDRRo0cydM55+MZEGVCxiIgxBnpgLiws5JFHHuGDDz4gLy+P0NBQxo0bx+LFiznnnHPaznvllVf4/e9/z8GDBwkPD2fRokX8+te/bvdaBw8eJCEhoe1+QEAAY8aM4Xe/+x1nnXVWv30m6ZozBGa12mRQ8I4IJ/Wm60ltuW+32yn45jsyP1tLye491BTkQlEelooyqCijYtcWKj79gB3PPoktIgaPsEhCEuKJm3oaceechcXNzdDPIyIiHR08eJDp06cTEBDAY489RmpqKk1NTaxevZqf//zn7Nq1q+28BQsWcM8993DzzTdTUlLCnj17On3dTz75hFGjRlFcXMz/+3//j7lz57J9+/Z2YVpObeowd0Id5mPY7ZBfAt6e4OMJA3CsoaGigswPVpPz/UYOZ2XRmJ+Duaq8w3k2b19MEbH4RkYRkZzE0NnnEJSS1P8Fi4j0gYHcYZ47dy5bt25l9+7deHt7t3usvLycgIAAALKyskhMTCQjI4OkpM7//m7tMG/evJlx48YBkJeXR3R0NH/961+5+eab++qjSA+owywDR10D7Ms+ct/DDby9HOHZxwt8vcHdubuy7v7+JF9zFcnXXAU4utCl2zM4sHoNRTt3UZWfi70gB3NNFezbQfW+Hexd9zF7X3gOa1gUbmFRBMXGEjNxPIkXnIObn6/Bn0hEpJdZrZ0/ZjLB0SsRdXUuJrB041yLpdullZWV8dFHH/HII490CMtAW1gGiIqKYtKkSdx+++289957PfrBwMvLsWRpU1NTt58jg58Cs3SP3Q5B/lBTCw1NUN/ouJWWOx6PjYCEllngpiY4VO4I1N6e7f/SdCImk4mQMSMJGTOy7VhzfT1ZH39Gdtq3lB44QH1BHuayYixFeViL8ijZ+h0l77/Bhj/9HiJi8Y6IInTYUIbOPJOwSeO1rJ2IDGxfbe78sSB/GDP8yP20LWCzHf9cfx8Yl3zk/vpt0NTc8byzJnW7tH379mG320lOTv7Bc2+66SbsdjuJiYlccMEFvPfee23dx4suuoiEhASeffbZDs+rqanh/vvvx2KxaIZZ2lFglu7x9jzyF2VTM1TXOsJzdZ3jT9+jftqvrIE9WUfue3kc6UZ7e4GfN7g65396Lh4eDL1kLkMvmdt2rCorm33vryZ/6zYqc7OxFuRirq+DzN3UZe4mK+0zsv71ItbgMFzCowiIjiEqdTRD55yLd1iogZ9GRGTwaJ0gNZlMXZ63c+dOVqxYwY4dO0hJSeGGG27g7LPP5qOPPiI0NJQdO3Zw3XXXtXvOtGnTMJvN1NbWEhERwYoVKxgzZkyffRYZeJwztYhzc3WBQD/H7XjMZsdj1bWOcF1b77iVtDyenABhwY6v6+odAdvb0xGsnbBD6xsXy/if38T4lvvWpiYKvvqGzM+/pGTfXuoK8qCkAEtpEfbSIg7v2MTh1e+y7anHsEXG4hUWSUhiAvHTTif6rGlYXF0N/TwiIp06Y3znjx0bVKeN7eKFjjl3ysmHz+HDh2MymcjIyGDevHmdnrd161bc3NwYOdLx28O///3vzJ8/n+nTp/PLX/6SqqoqLrnkknbPWblyJSNHjiQgIIDg4OCTrlUGHwVm6X2tYdpuh8YmqKlr6Ui3/OnteeTc0grYn+P42mQC79ZutBf4eoGPt9ONdFhcXYmeOYPomTPajtWVHOLAqtXkbthMeXYWTS2z0Jbs/TRk7yfv+y/JW/kvrH6BWCJj8YuIJGJkCsPOPwf/ofHGfRgRkaP1YKa4z87tRFBQEOeffz5/+ctfuOOOOzq96C8qKorGxkbWr1/PlClTsFgs/N///R+XXnopN998M08++SSenp7tnhsTE8PQoUNPukYZvLRKRie0SkY/KSqFghLHaMfxLgoZNwL8Wy6uq6mD5mZHmO6Fv3z7kt1up2RTOgc+/oyiXbuoyc/FXpiHydb+M9rNFmzh0biHRxEcG0vs5AnEnzcTV28vgyoXkcFuIK+SkZmZybRp0wgKCuLhhx8mNTWV5uZm1qxZw/Lly8nIyMBut3PGGWeQl5fHsmXLGDNmDNu2bePee+8lLy+PlJQU1q5di5eX13FXyRDno1UyRMKCHTe7HRoaHR3oo28+RwXHghLIK3Z87eXhmJtu60Q7V4g2mUyEThxP6MQjv95srK4m66NPyP7mO8oOZtJQkIu5ogxLfhbN+VkUbUqj6J3XWP8HX4iMxScsgvARSQw95yxCxozUBYUicspLSEhg06ZNPPLII9x9990UFBQwZMgQJk6cyPLlywHH378fffQRv/3tb1myZAl5eXkMGzaMW2+9lauuuoopU6Zw7bXX8uabbxr8aWQgUYe5E+owO6EDuY6OdGMnS/1MGwut88ENjeBicaoQfTzle/ex/4OPKdi+naq8XGwFOZiaGjuc1xwaiVt4FIHRMUSPH0vi+bPwDA4yoGIRGegGcodZTk3O0GFWYO6EArMTa+1EV9VAVUsnGmDqURegbNsDZZUtG614HelG+3g6dYi2NjSQ+8U6Dq77mkP79lNfkIuptLjDeTY3D+xRcXiFRxKamEDijOlETp2MyYk/m4g4BwVmGWgUmJ2YAvMA09zcfvfBDTscM8/H4+cD449ax9Nu73j1txOpyS9g//sfkbd5CxU5WVgLcjDVd/xs1qBQLBHR+EdGETV6FEPPPwffmEgDKhYRZ6bALAONArMTU2AeBBoaWzrQR3WiG5s6Lqj//XZHYD56ZQ4n7kTbbTYKv/2OzE+/oHj3Hmryc6G4AJO9/QYCdosLtsg4PMIjCYlPIH7qacSeNQ2Lh7tBlYuIM1BgloHGGQKzLvqTwcvdzXELCThyrKERmo9aqaLZ6lgjGhwd6aLSI495ecCQQIiP6pdyu8tkNhMx7XQipp3edqyhvJwDH6wm97uNHM46SFNBDqbqSiw5+2nK2U/B919S8N9/8VVgCKaWZe2ikpNJPPcsAobG64JCERGRLqjD3Al1mE8RrWtFH68TDRAeAiPiHV/bbLA545h1op1rdY5Wdrudsu072P/hJxTu2El1Xjb2ojxMx2xja3d1ozk6AY+wCIJjYomfPJHYGafj5utjUOUi0tdau3Xx8fEd1iMWcUZ1dXVtSwBqJMPJKDCf4lovLHR1dWzlDY4wvWlnx3O9PBzBOTQIggP6tcyeaKquJmv1J2R//Q1lBw7QkJeNqba6w3nNwWGYouLwDYsgImkYiWdOJWRkki4oFBkkrFYre/bsITQ0VLvayYBQWlpKcXExSUlJWI75XqTAbDAFZumg2QoVVUe60FU17Ze4S4iC2AjH1/UNkJnXfi7axbkCp91up3zXbvZ/8BGFW7dTlZOFraQA0zF/Jdjc3GmOHYp7aCTBUVHEjU8ldtpkPIfoG63IQFVQUEB5eTmhoaF4eXlhcuILn+XUZbfbqa2tpbi4mICAACIiIjqco8BsMAVm6ZbGJkdwrq6FoABHOAYoKYOdB9qf6+nuCM6+Xo65ak/nu9imqaaGnE8+I2vdV5Tt3Ud9fjamutqO54VGQXQ8vkNCCU9MIP70SYSPHYm5dR1sEXFqdrudwsJCysvLjS5F5AcFBAQQHh5+3B/sFJgNpsAsJ6W2DkoOt3Siax0jHkcbmQhDWjYeqa6Fw5VH1ot2ok603WajfO9eMld9TMHmzVRlHcRaWtyxC+3uSVN8Em6hEQRFRBA7OoXY08ZrWTsRJ2e1Wmlq6mQzKBEn4Orq2mEM42hOHZjLy8v57rvvKC4uxnbMRUQLFizoteKMpMAsvaqx6cgYR3UtDI2B1uXdsgsc4xutWrf99vN2/OntCU60ikVjZSX5674i6/O1lO7ZQ31eNjTUdzivKTwGW2wiPsGhhMXFkjAhlfBxI3H19jrOq4qIiPSc0wbm//3vf1x77bXU1NTg6+vbrj1uMpkoKyvr9SKNoMAs/ebQYSgqc4TpYzvRABNSHMEZoK7B8aeHm9NstmKzWqnYu5es1Z+Qv2EjlQczsZWVdDzP05vGxGRcQyMIDA0jJnk4seNGETBMy9qJiMiJcdrAnJSUxNy5c/nDH/6Al9fg7RQpMIshGpugsqZl2+8ax9rQU8Yc6TDvPgiFh8DVpX0X2tfbccxJNJSXU/jterI++ZxDGRmOLnRTxx8GGqMTsMYNd3ShY6OJTR5G5LgUPAID+r9oEREZcJw2MHt7e7Nt2zYSExP7qianoMAsTuHYbbszDjhmo4/3v62nB0waeSRcO9GW37bmZsr37CH3sy/IW/89lZn7sR4u7XCe1T+IhqQxuIRFEhgyhNiEOKKGxxIyKgmzi/P8QCAiIs7BaXf6O//889mwYcOgD8wiTuHYwJuSCCNsjjnoozvRdQ2Avf2s87a9jqXwju5Ce7obEqLNLi4EjRxJ0MiRpN7uOFZfWkrRd9+R/cnnlGzfTn1+LpaKMry+XwtADbDD3YPNQ1NoThiBT0Aw4RHhREcNIXJ0Ej6RYf3+OURE5NTU4w7z3//+dx5++GFuuOEGxowZg+sxy0hdcsklvVqgUdRhlgGlqdkx/+zTMiZlt8PXm8Ha/qJcXCyO4BzoBzHh/V9nF5rr6ynbvp28tV+S/+16Kg/sw15f1+4cu8lMU0wiDUmjsYRFExwYSPSQACJjwghLTcHFCZfqExGRvuO0IxnmLi7OMZlMWK3Wky7KGSgwy4Bmtzs2T6mqOaoTXXtklCPQD1KTjpy/N8sx0uHr3bLdt/EX4dltNioOHKD4++/JW/slh7Zvp+k4YxzNwaE0DB9N09AUfPwDCffzJTrIm8gRCfgnxuqCQhGRQcxpA/OpQoFZBh2bzXERYWUNuLtCSKDjeEMjfLv1yHkmk2MpO38fxziHvy+4uxlT8zHqSkoo2bSJwm++pWD9d9TkZIO9fRfd5uFFw/BRNCSNxhQRS4iXF1EeFiIjg4lITcbdX/8/i4gMFgrMBlNgllNGYxMUlDg60JXVjvGOo0UOgeFxjq9tLfPTPl5OsTZ0U00Npdu2UbJpEwVfp1GWkYHtmDWh7WYLjfHDaUgeS8OIVHx8/YhsrifS243IYTGEpAzD1MWi+CIi4rycOjCvXbuWxx9/nIyMDEwmEykpKfzyl7/kzDPP7IsaDaHALKcku93Rca6scYTnymqIDofQll0JK6ogfbejC926rJ2/D/j5gJvx22LbrFYq9uyhZPNmijdsoOj7DTSUtR/jsJtMNMUMpSE5lfrksRCdSFh1BZG2OiKH+BM5ZgReYSEGfQIREekJpw3Mr7zyCjfccAOXX34506dPx263k5aWxttvv82KFSu45ppr+qrWfqXALHIcJYdhTxY0N3d8zMMdhsVAcEC/l9WVmvx8ijdtovj77yn6dj3VuTkdzmmKjKV+xFhHFzp5LH6NDUSWFRLlYSIqMYohY5Ixuxr/A4GIiLTntIE5JSWFn/3sZ9x1113tjj/55JO8+OKLZGRk9GqBRlFgFumE3e5Yxq61A11RDbUtYxDjkh0dZ4CSMsgvcXSffb3A28spdihsnYMu3rCB4g0bKN+zp8M5zUMiqE8+EqBNPv5E5GcS1VRD1BB/IlOT8QofYkD1IiJyNKcNzO7u7uzYsYNhw4a1O75v3z5Gjx5NfX19J88cWBSYRXqgudkxxhHge2S2eW+WIzAfzWIBH0/HDHRMuFNcTNhQXu4I0Bs3Uvz995RlZDhmtY/SHDiEhuRUGpLHUp8yjuaIWAILcog6XESUp5moxChCRo9QF1pEpJ857cYlMTExfPrppx0C86effkpMTEyvFdZTtbW1pKSk8KMf/YjHH3/8B4+LSC9ycYEg//bHokIdq21UtmzxXVMHVqujI11RDbERR87NK3Ysfefj6ehE+3j121bf7gEBRM+aRfSsWQA0VVdTkp5O8YYNlGzYQOm2bbgcLsHlm0/x/uZTAJoDgmkYOYHMUePJGDkBK+G4rc8lIi+TKGstUUMCiExNxlOz0CIig0KPvyPdfffd3HHHHaSnpzNt2jRMJhNfffUVK1as4Omnn+6LGrvlkUceYcqUKd0+LiJ9zMvTcYtsuW+zOUY3qmsdIx1HXyRYWg6HK6HoqOe7ux0J0HER/bYqh6uPD5FnnEHkGWcAjg1VSrdsaetAH9qyBcpLcUlbg3faGsc5IWHUj5pEyagJ5Iwcjy0gGPIh6PuNRJUXEeVpIXJotKMLrS2+RUQGnB7/zX3rrbcSHh7OE088weuvvw445ppXrlzJpZde2usFdsfevXvZtWsXF198Mdu3b//B4yJiALPZ0Tlu3Y3waDHhjtnn6lqornNsutLQ6LiVV0N85JFzD+Y5tvz29moJ1J59GqZdPDwImzKFsJYfvK0NDRxKT6dw/XqK1q93dKAPFeGz9gN81n7gOCcsitrU06gbOYEdKePY5uMHdnD7NofIvEwirXVEhQUQlZqMx5DgPqtdRER6h+HrMK9bt44///nPbNy4kYKCAt5++23mzZvX7pznn3+eP//5zxQUFDBq1CiWLVvWbgm7Sy+9lD//+c+kpaWxffv2ttGLzo53h2aYRQzU3OwIzjW1ju29jx7f+G6bo0PdymQCLw9HEPfzhsjQfi21qabGsZnKt99StH49h3ftOrKjoqNAiIimZsxkasaeTkPyWOzuR7bwDs7NJKqihCgvF8e60COHY1IXWkSkW5x2hrm31dTUMHbsWG644QauuOKKDo+vXLmSxYsX8/zzzzN9+nT+9re/MWfOHHbu3ElsbCzvvvsuSUlJJCUlkZaW1va8zo6LyADg4uK4gDDAt+NjcZEtneiWW7P1yIx0TV37wJxd4Bj98PV2hOo+WKHD1dubyDPPJLLlh/iG8nKKv/++rQNdeeAAFOTgXZCD98dvYXJxwRyTSM3IiRw+4zxKoxMpjU5gK4AV3NOyiczPJNJeT1RYIJGpyXiEBPV63SIi0n3d6jAHBQWxZ88eQkJCCAwMxNTFN52ysrITL8Zk6tBhnjJlChMmTGD58uVtx1JSUpg3bx6PPvoo999/P6+88goWi4Xq6mqampq4++67qaurO+7x3/zmN8d974aGBhoajnStKisriYmJUYdZxJnZ7dDQdCQ8u7o4LjYEx8z0V5uPdHstZkdwbr35effLKh11JSUUrV9P4fr1FKalUVtY2O5xVz9/XOOHUTs8laLps2kIjWz/AjYbIflZRFaUEOXtStTwGIJThmt3QhERnGxZuX/+859cffXVuLu7s2LFii4D88KFC0+8mGMCc2NjI15eXvz3v//lsssuazvvzjvvJD09nbVr17Z7/ooVK447etHZ8aP99re/5aGHHupwXIFZZIBqanZ0mKtqHNt+H7NUHCGBMGqo42u7Hcqr+nx1DrvdTuWBAxR8/TUFaWkUf/891qOX4jSZ8I1PwC0mkdrYJIpGT6E8Or7D67hXVRCVf5BIWz1R4YFEjkvBPSiwz+oWEXFWTjWScXQIvv766/uqlg4OHTqE1WolLCys3fGwsDAKj+nSnKz777+fJUuWtN1v7TCLyADl6gJDW/4fttsd4xpVNUdu/t5Hzq1vgK0tG5h4urfvQvt49dpFhSaTCf+hQ/EfOpTkBQuwNjRQsmmTI0B//TXle/ZQlXkAMg8AnxDktYKk8RPwiEmgLiyewqBICqISaPD158CIsRxofd0DjQxZ9w3RVaVE+3sQNXIo/kPjDd8kRkRksOhxK8VisVBQUEBoaPsLa0pLSwkNDcVqtfZaca2O7Wjb7fbjdrk7C/PdCfnu7u64u7ufSHki4uxMpiMrdEQcZ4e+xmbH1t71DY4LCusaoLjsyHMToyG65Qf31l/K9UIYtbi7Ez51KuFTpzJ+6VLqSkooSEuj4OuvKfzmGxrKyij8+ivgKwCCR41i9Jln4hkVR6XVlfwmE3lBkVSERVIcN5xihrMJoAp81+wguiSXKFc70QmRhI5Nwexm/EYxIiIDUY8Dc2cTHA0NDbj18l/GISEhWCyWDt3k4uLiDl1nEZET5u8DU8Y4xjiqahybrbR2opua2886H66EnfvBp6UD3dqNdnc96RDtOWQIiZdeSuKll2K32TickUHeunXkr11L6bZtlO3YQdmOHW3nRs6YwYSzz8bbz4+ifTnkllWT6+FPUXQiVUPCyRgSTkbLa7t9n09kzgGirLVEhwcSOX6kxjhERLqp24H5mWeeARzd3pdeegkfH5+2x6xWK+vWrSM5OblXi3Nzc2PixImsWbOm3QzzmjVrDFvzWUQGMdeWHQtbdy202x1rQR8911xV41jqrqLKcWvl5gq+XhAX5fjzJJnMZoJGjSJo1CjG3HordSUl5H/1FflffEFBWhp1JSXsf/NN9r/5JmY3N8JOO424c85h+hmTsHh5U5C+k9zcQ+Sa3MmPiKfBx5eDI1I52Pr6rWMc1aVE+3kSNWoo/olxGuMQETmObq/DnJCQAEBWVhbR0dFYjrpC283Njfj4eB5++OEe76pXXV3Nvn37ABg/fjxPPvkkM2fOJCgoiNjYWFauXMl1113HX//6V6ZOncoLL7zAiy++yI4dO4iLi+vRe/WE1mEWkeNqNw9d6/izuvbI4xNHHtmcpbjMsYthL89DWxsbKd6wgby1a8n74gtqcnOPPGgyMWT8eGLOPZfoc8/FJyoKm9XKoYx95O7NJq/ORm5wBBXHrsYB+BUXEFWSS7SbnajEaEJTkzXGISJOzalWyTjazJkzeeuttwgM7J1f5X3xxRfMnDmzw/GFCxeyYsUKwLFxyWOPPUZBQQGjR4/mqaeeYsaMGb3y/p1RYBaRbrNaHRutVNU4lrVr7dLuyoSi0iPnmUyOnQlbA/SQQDjJ5eFaV97I/ewzcj/9lNJt29o9HjhyJLHnnUf0uefin5jYdrwqr5C8bXvIOVxDnmcARVEJ2I/ZMMWttprI3NYxjiDHGEdgwEnVKyLSm5w2MJ8qFJhF5KRVVDmWq6s8ah76aNPHOTZpAcdstN0Ofj7gcuIhuqaggNzPPiNnzRpKNm7EftRyen6JicScey5xc+cSMHx4u+c1VteQn55BXl4JubiTH5lAg0/7jWNMVithWXuJqSkjJtiHmHEpeEZFICJiFKcNzD/96U+7fPzll18+qYKchQKziPSq1nno1osKm5ohOeHI45t3QWW142tvT0cH2s/HcfN0P6HZ4vrSUnI//5ycTz6h6JtvsDUfCewBSUnEzZ1L3Jw5+ERHd3iuzWrl0M595O7LJrfeTm5QBJWhHcPxkOz9xFQUE+PvQfSYJHwTYjUHLSL9xmkD89EX3wE0NTWxfft2ysvLmTVrFm+99VavFmgUBWYR6Ve7D0J5JdQ3dnzMywMmjz5y32br8Sx0Y1UVeWvXkv3RRxR8+WW78Bw8dizxF15I7Pnn4xkS0ulrVOYVkrNtDznldeT4hlAa2fE6koCCHGJK84nxshCbkoh/8jBMvbSOtYjIsZw2MB+PzWbjtttuIzExkXvuuac36jKcArOIGKKxydFprqh2dKKrayDQD0a3jFDY7bB+m2Nsw8/nSCe6B13oxooKstesIWvVKoq++65tbWmT2UzYlCnEX3QRsbNn4+LV9WofNaWHyU3PIKekkhzPAIqjErAfM5PtW1JITFE2Me4QMzyG4DEpmFz6bjdFETm1DKjADLB7927OPvtsCgoKeuPlDKfALCJOwWaDZqtj2TpwjHV8u7Xjea4ujosJhwRCeOdd4mPVlZSQ9dFHZK1aRenWI6/r4uVF7AUXkDhvHkMmTDjuZlHHqq+sJi89g5yCMnJcvSmITsTm2n6VDc/yUmLyMomxNBMbH0HohNGYtGmUiJygAReYV61axcKFCykpKemNlzOcArOIOK2GRkf3ubLacauqPbIDYVQoDIt1fG21woHcI51oj6670FXZ2WStWsWBd96hOien7bhvXByJ8+aRcMkleIWHd7vMpvoG8tN3kpNTTI7Jg7yoRJo9PNud41FxmNicvcRZrMQNjyF4/Gh1oEWk25w2MC9ZsqTdfbvdTkFBAR988AELFy7kueee69UCjaLALCIDhs3mWAu6ssbRZfZv2ViqvBK27DlynqvLURcTtuxQeJxl7ex2OyWbNnHg7bfJ/ugjmuvqAMfIRvjUqQy76iqizj4bcw+DrbWpmcLtu8k5kE+2zYXcyEQavbzbneNdWkxc3gFi3e3EJScQMCYF00kuvScig5fTBuZj10w2m80MGTKEWbNm8dOf/hSXQdIZUGAWkQGvpg4KD3XsQrcaGgPRYY6vm5qhublDF7qppobsjz/mwNtvU7JxY9txz7Awhl15JUOvvBKv0NATKs9qtVK4Yy9Z+3LJtrmRG51Is7tHu3P8ivOJLcgizstM3Ohh+KUkaRUOEWnjtIH5VKHALCKDis3mCM2V1UfGOUYNc3SaAQoOwZ6DXXahq7KyHNtxv/UWDYcPA2BycSF61iyGz59P2JQp3Zp17kxzUzP5W3eRdbCALJMn+ceZgQ7IzyauJIc4XzfiUkfgPSxBAVrkFOb0gbm4uJjdu3djMplISkoi9AQ7DM5KgVlEBj27/UjYzCqArPyOXWgAH09ITnSsD41ja+7sjz9m32uvUbJ5c9tp/kOHkrxwIfEXXYSlFy7ka2poJDc9g+zsYrJcfSg4zm6EYQd2kVBRRHxYANFTx+MSFHTS7ysiA4fTBuaKigpuv/12/vOf/2Br2UHKYrEwf/58/vKXv+Dv798nhfY3BWYROeUc3YWuaulCNzQ5Hps2ztF9BsgpdOxi6OdDVXkZe957h/3vvkNzbS0A7kFBJP34xwyfPx+P4OBeK6+hpo6czTvIzi/joGcAxdGJ7R53raslZv9OEuy1JAyLIXjyOEyurr32/iLifJw2MF911VWkp6fz7LPPMnXqVEwmE2lpadx5552kpqby+uuv91Wt/UqBWUQEx4oc1bUQHHDk2Jbdji2/j2LzdKeiKJ8Dn65hz6cfY7dZMbu5kXDxxSQvXIj/0KG9XlpNeRUHN+0ks7SGzOAoagLbh3PfkgLic/eT4ONC/PiReA1P7OSVRGSgctrA7O3tzerVqznjjDPaHf/yyy+54IILqKmp6dUCjaLALCLSiaoaR4e58pguNGC3WMiqLGDXihWU7dhBVOp4murr8EyIJ+WmGwlKSemTkux2OyUH88jcsZ+DjWZyIhPaX0BosxGeuZvE8kKGRQcTccZpmHx8+qQWEek//ZXXerykRXBw8HHHLvz9/QkMDOyVokRExIn5tlwM2KqhsWV3whpMJog/Yzxxc+ZQsmkTfkWVeHj7YrPZKN+4k7y0DfiljsZ3dMoPrgvdEyaTidCEaEITopkCNDU1k7tlF5lZRWS6+1MSFU/h0BQKSSEN8FqfS+LBDIZ6mUk4LRWPoQm9UoeIDE497jC/8MIL/Pe//+Vf//oXERERABQWFrJw4UIuv/xybr755j4ptL+pwywicpJsNtiVia2sHLO147eaRgu4nTHpyIGjL0LsZdWHK8ncvJP9hxvIDIujwftId9nc1ETU3u0Mayhn6LBogk+fiMnNrYtXExFn4VQjGePHj2+3VNDevXtpaGggNtaxm1R2djbu7u4MHz6cTZs29Vmx/UmBWUSkFzU0Ursvk4oNm3GxQVBMHPvT1pKbs59xixc7RjW+2+5Yyi7QDwL8wLNvtsy22mzk7tzP/n157PcIoDQsut3j/vnZDMvfz/AgL2LPPh1zL164KCK9y6kC80MPPdTtF3zwwQdPqiBnocAsItI3qnNzyfj7y+R89BH1lRUAjLl2AWOmn9P+RA93R3gO9IMA3yOrdPSy8pLD7Nu0k/21drIjE7Ee1V32KC9j2N6tJPlYSDhzMq4x0V28koj0N6cKzKciBWYRkb5VnZvL1r/8hYP/+x8mk5mQxGGkXHYFESPHYKlrbH9yQhTEOsYAaVnSFLO512tqbGrm4OYM9uWVsTcoijq/gLbHXOtqSMhIJ8nSyLApqXikjOj19xeRnlFgNpgCs4hI/zi8ezdbnn6a/LVrAbB4ejLmZz9jxMXzsNTUw+FKx8Ypvl6OJxSVwp4s8Pc50oH29uz1+Web3U7uniz27M5mj3cIlUFHNugyNzURl7GZEY0VjJiQjOeEcdpxUMQAThWYg4KC2LNnDyEhIQQGBna59WlZWVmvFmgUBWYRkf5VvHEj6U8+yaH0dAC8o6IYv3QpMeed1/77zt4syC9p/2RXlyPhOSQQXCy9Wpvdbqcot4g9W/ayx8WXQ0fNPZubmojf9j0p1iqGTx2Hx5hRvfreItI5pwrM//znP7n66qtxd3fnn//8Z5fnLly4sNeKM5ICs4hI/7Pb7WStWkX6k09SW1gIQNhppzHx/vsJSEpqPQlq6+FwhaP7XF59ZEwDYOpYcGvZ4a+u3hGmXXp3/rmspJzdmzLYZXOnKDy27biloZ7Ebd8z0lzP0DMn4ZY0vFffV0Tac6rA3Kq5uZlXX32V888/n/Dw8D4ryhkoMIuIGKe5tpadf/87Gf/4B9aGBkxmMyMWLCD15z/Hxcur/ck2m2MTlcOVUN8AKUft6Ne6K6GfNwT5O3Ys7OXxjdKySjI2ZJCBJ6VDItuOu9bVMGzrd4x2ayZh9gzM0VG99p4i4uCUgRnAy8uLjIwM4uLi+qomp6DALCJivOq8PDY//jg5H38MgHdkJJN/8xsizzzzh59st8PGnVBT1/64uxsE+ztGNwJ77+93u91OSfFhMjbvJsPFj/LgsLbHvA8VMWrnBkbHBBE651zw9Oy19xU5lTltYJ45cyZ33nkn8+bN66OSnIMCs4iI88hbt47vH36Y2oICAOLmzmXCvffiGRLyw0+ub4CySigrd3ShbS3f9gL9IDXpyHlNzb22dJ3dbqcw/xDbt+5jp08odT5HdsgN272dMcWZjJyYgte0KbpYUOQkOG1g/u9//8t9993HXXfdxcSJE/H29m73eGpqaq8WaBQFZhER59JUU8PW555jzyuvYLfZcPPzY8J995FwySVdXozejtUKh6sc4dnPB8JbAndDI3y71TG6ERzguHl59EqYtdrs7N+Tzbb9hewfEovN1TFfbW5qZNimrxlvqiH+4vMxRUac9HuJnGqcNjCbj7Pupclkwm63YzKZsFqtvVackRSYRUScU+n27Xz34IMc3rULgOhzz+W0Bx/EIyjoxF+0uAwyDrQ/5uF2JDz7+/TKus+1jc3s3LCT7ZVWCsNi2o4H5GQyfs8mxoxLwmvWWX2yxrTIYOS0gTkrK6vLxwfLbLMCs4iI87I1N5Px8sts/ctfsDc34xEczGkPPUT0zJkn/qINjVBaDqUtq28c/e0xOQHCWrbIttt7pfNcXFrJlk272e4dSoOn47e1lsYGRqz/gvGeVqIvnYMpdMhJv4/IYOa0gXndunVMmzYNl2OW6GlubiYtLY0ZM2b0aoFGUWAWEXF+ZRkZfHPffVTs2wfA0CuuYOL99+NyshfVWa2O0FxaAWUVMGnUkfnmnEI4VN5y4WAAeJ7c6Eaj1U7GjgOkF1ZTMOTIShohB3YzcV86o2dMxHXq6Sf3eUQGKacNzBaLhYKCAkJDQ9sdLy0tJTQ0VCMZIiLSr6wNDWx99lkyVqwAux3/oUM548kn8R82rHfe4NiO8uYMxzJ2rTzdISgAQvzB3/ekwnNhaRWbN+1mp284Te4eAHiUlzH+20+YkBSJ76UX9fqa0iIDmdMGZrPZTFFREUOGtP810Z49e5g0aRKVlZW9WqBRFJhFRAaWovXr+fqee6g/dAiLhweTf/UrEi+7rPffqL7B0XkuLXes8Xz0t1FPd5g8+qRHNuqtNrZt2c+GShsV/o5REHNTIylffcxkbzvhV18O/v4/8Coig5/TBebLL78cgHfffZcLLrgAd3f3tsesVitbt25lxIgRfPTRR31TaT9TYBYRGXjqS0tJu+8+CtPSAEi45BIm/+Y3Jz+i0Znm1tGNcsct0A9GDj3yeHGZ49gJLldns9vZm1XM9/uKyA0+silK3MavmVZ6kNhrr8SkDVHkFNZfea3b/wf7t/wka7fb8fX1xfOov3zc3Nw4/fTTuemmm3q/QhERkW7yCA5m5t/+xs6XXmLrs8+S+d57lO/Zw5nPPINPVB8ESxcLDAl03Gw2R4BuVVvnWHnDZHLMO4eFQJBfj1bAMJtMjIgPY0R8GAWHa/h+014y/MPJmjidLKYT9en3TMtbSeKPL8eUEN/7n09EgBMYyXjooYdYunRph/WXBxt1mEVEBrbiDRv4askS6ktLcQ8M5IwnnyTstNP6r4CKKtiXDdVH7TTo6gKhQY4VN3y8Tmh0o6KhmfUb9rDFNQCrqxsAYRlbmLZ/M0k/uhhT8oje+gQiTs/pRjJa1dXVYbfb8fLyAhzLzL399tuMHDmS2bNn90mRRlBgFhEZ+GoKCvjyzjsp27EDk8XChHvvJemaa7q/0UlvqK6FolLHran5yPHRwxxrPJ/oyzbZ+G7TXjbjTZOb4wLBkH0ZnLn1S5J+fBmmkSknWbiI83PawDx79mwuv/xybrnlFsrLyxkxYgRubm4cOnSIJ598kltvvbWvau1XCswiIoNDc3093/32txz83/8AGPajHzHpV7/C3N+rTdjtjiXqikqhohqmjDkynlFcBtghOBAsPdu0pLbZxob0/WxscqfBw9HMiti+ibP2biB+0bUwSPZHEDkepw3MISEhrF27llGjRvHSSy/x7LPPsnnzZt58801+85vfkJGR0Ve19isFZhGRwcNut7Prn/9k8+OPg91O5IwZTH/8cVyNGi+02Y6EZbsdvtvuWH3D0jITHR7s2Lq7B53w+mYb3207yPeNbm0d57jvv+Tswt1E3PJTOGY5WJHBwGkDs5eXF7t27SI2NparrrqKUaNG8eCDD5KTk8OIESOora3tq1r7lQKziMjgk/vZZ3z9y19ira8ncORIzn7+eTyHGLybns0GWQWOznND45HjHu6OWeewYMdydd1U02QjLf0Am/HB1tJFT/7sfc62lhFw+y3QMlIpMhj0V17r8Wb1w4YN45133iEnJ4fVq1e3zS0XFxcrWIqIiFOLnjWLc/7xD9yDgji8cycfX3NN2y6BhjGbISHKMaIxNsnRXbaYHR3nrHzYn92jl/N2NXPe5GH8bEwIo+tLMdms7Jp1ES/OuIp1v3uGxtdeb792tIj8oB53mN944w2uueYarFYr55xzDh9//DEAjz76KOvWrePDDz/sk0L7mzrMIiKDV1V2Nl/ccgtVWVm4+fsz68UXCRo1yuiyjrBaHdtvF5VCYrRjRQ2ApibA1KN1nYtqm/h080GyvQIB8Cku4KyPVjL6mksxTZ7c+7WL9COnHckAKCwspKCggLFjx2JumcH67rvv8PPzIzk5udeLNIICs4jI4FZ/+DBrb72V0m3bcPXx4ezlyxkyYYLRZXVtT5bjAsGYcIgOdcw8d4PdbmdPSTWf7ymm3Nuxr0Lktg2cv20dYffcBUaPpYicIKcOzKcCBWYRkcGvqaaGtbfdRvGGDVg8PTnr2WcJnzrV6LKOz2aD9F1Q1XKtkJsrxEU6Rji6uRlKs83Ohn1FpB1uptHNA1NzM6e9+Q/OSInCdcF1J72lt0h/c6rAfPnll7NixQr8/PzatsjuzFtvvdVrxRlJgVlE5NTQXFfHl3feScHXX2N2c+OMJ58keuZMo8s6Prvd0WE+mAf1LRcIero7ZqBDArsdeKuarHyyJYfdFh8A/POyOP/9f5N4160wQhufyMDhVBf9+fv7ty3y7u/v3+VNRERkIHHx9GTGc88Rfc452Bob+XLxYnI//9zoso7PZHKsmjF5NAyNccwy1zXAzgOQW9Ttl/F1tXDZpHiujPXCr76aiqg4Xr/5V7z7zpfUPvonaGjoww8hMvBoJKMT6jCLiJxabE1NfHP//WR9+CFmV1fOev55IqZNM7qsrjVbIbcQCg7BpFFHLgY8ep3nH9BotfPl7gI21LlgN5vxKi3mgleeJemuW2Ds2D4sXuTkOdVIxrEOHTrEwYMHMZlMxMfHExwc3Be1GUqBWUTk1GNrauKrpUvJ/eQTLB4ezPzb3widNMnosn7YsRuhbN3jmHGOj+r2Gs6FNU18sC2PEnfHmMboD17nXNcaPO6+C/p7V0SRbnKqkYxWO3bsYMaMGYSFhTFlyhROO+00QkNDmTVrFrt27eqrGrultraWuLg4li5d2nbssssuIzAwkCuvvNLAykREZKAwu7oy/c9/JuLMM7HW1/PFrbdyaOtWo8v6YUd3k2vqoLzKMev8/XbYlw2NTT/4EuHeriw8LY7TfeyYbDa2X3gVf0+dzcGf3gq7d/dh8SLOr9uBubCwkLPOOouSkhKefPJJVq1axQcffMCf//xnCgoKmDFjBsXFxX1Za5ceeeQRpkyZ0u7YHXfcwb/+9S+DKhIRkYHI4ubGmcuWEXbaaTTX1vL5zTdzeCAFRh8vmJACgX6ObnNeMXy3DQ7mO9Z37oKL2cTZw4dw7YgAAhpqqAqP4rU7H2Hd8v/D9k99P5VTV7cD81NPPUVcXBybN2/mzjvv5Pzzz+eCCy5gyZIlbNq0iZiYGJ566qm+rLVTe/fuZdeuXcydO7fd8ZkzZ+Lr62tITSIiMnC5eHgw47nnCBk3jqbKSr649VZqCwuNLqv7fL0hNclx8/ECq82xa+D6bY4O9A+I9nHjp5NjGevRDGYzaQt/wf9Zg6i87Q6oru6HDyDiXLodmNesWcO9996Lh4dHh8c8PT355S9/yerVq3tcwLp167j44ouJjIzEZDLxzjvvdDjn+eefJyEhAQ8PDyZOnMiXX37Z7vGlS5fy6KOP9vi9RUREOuPq7c3Zzz+P/9Ch1BUV8cWtt9JYVWV0WT0T6OfoNqckOmaZXSzg1fH7+PG4WUzMSQnnklhv3JoayR1/Oi//6Hb23vgL2Ly5jwsXcS7dDswHDhxgQhc7IE2aNIkDBw70uICamhrGjh3Lc889d9zHV65cyeLFi3nggQfYvHkzZ555JnPmzCE7OxuAd999l6SkJJKSknr83kdraGigsrKy3U1ERE5tbv7+nP3Xv+IREkL5nj18uXgx1sZGo8vqGZMJQoMcq2iMGX5krWabDbbvg8Ndf78bGezJDWPDCLfWUR8QxJv3/pl1L7+J/Z//7IfiRZxDtwNzVVVVl1cf+vr6Un0Cv6aZM2cOv//97zvdEOXJJ59k0aJF3HjjjaSkpLBs2TJiYmJYvnw5AN9++y2vvfYa8fHxLF26lBdffJGHH364x3U8+uij7daTjomJ6fFriIjI4OMdGcnZy5fj4ulJ0bff8t2DDzIgV2Q1m8HzqO5yfgmUljtW1NiyG6pqOn1qoLuF6yZEM9GxgAZpP13MG+Uu1C9ZCk0/fEGhyEDXo1UyqqqqOnRhj7719l8gjY2NbNy4kdmzZ7c7Pnv2bNLS0gBH0M3JyeHgwYM8/vjj3HTTTfzmN7/p8Xvdf//9VFRUtN1ycnJ65TOIiMjAFzRyJGc89RQmi4XM995j21/+YnRJJy80CKJCHR3n8irYlOHYAKWp+binW8wmzhsewoUx3liszeyfcT7/OvNKDl2zAIq6v2mKyEDU7cBst9tJSkoiMDDwuLcRfbCV5qFDh7BarYSFhbU7HhYWRmE3Lr44//zz+dGPfsSqVauIjo7m+++/7/Rcd3d3/Pz82t1ERERaRZ55JpNbGjLbly8n++OPDa7oJLm5wrBYx66BoUGOYyVlsGknVNV2+rQxIZ5cNzIEv+YGyuKH8a87H2X/z+6ATZv6qXCR/tftlcg/N3Cb0NZtuVvZ7fYOxwCuv/76dvdP5CJEERGRzgy78koq9u9n97/+xbf/7//hGxdHYB80jPqVp7vjosDoMEeHub4BDuQ4Vtg4zvdagHAvF64fF8E7OwvJ9vbhjV89zfl//jXjfjIPLrywf+sX6QfdDsxnnXVWX9ZxXCEhIVgslg7d5OLi4g5dZxERkf4w/u67qdi7l8JvvmHdL37B+StX4hEYaHRZJ8/X27Gixv4cSIjqNCy38nI1M39MBB/tL2NbtQsf3fMoh//5LGdnZ2O69dZ+Klqkf/Rohrm/ubm5MXHiRNasWdPu+Jo1a5g2bZpBVYmIyKnM7OLC9Mcfxycmhpq8PL6++25sP7AhyIDh6gLJCeDuduRYQUmnOwVazCbmDgvizFDH9tvrF/6CdyvdaL73PscqHCKDhOGBubq6mvT0dNLT0wHIzMwkPT29bdm4JUuW8NJLL/Hyyy+TkZHBXXfdRXZ2NrfccouBVYuIyKnMPSCAGc8+61g5Y/16tj//vNEl9Y2Sw7AnCzbuhMrjr4RlMpmYHuXLRbE+mG1Wds2+lNeHnk7DDT/VChoyaJjsBq+N88UXXzBz5swOxxcuXMiKFSsAx8Yljz32GAUFBYwePZqnnnqKGTNm9GldlZWV+Pv7U1FRoQsARUTkuA6+/z5p994LJhMz//Y3IqZPN7qk3lVbDzv2Of40mRwXCUYO6fT0rKpG3txdRqPFhYhtG7nq/X/g+c9/gKdnPxYtp5L+ymuGB2ZnpcAsIiLd8d1DD7Hv9ddxDwxkzptv4jXYrrFptsLuTDhU7rgfHgLDYx3rOh9HQW0Tr2ccos7sypC9O5j/6jJ8XvkX+Pr2X81yyuivvNbjkYwVK1ZQW9v5cjMiIiKnkon33UdgcjINhw/z9dKl2JqPv47xgOVigZFDHRcCAhQegvTd0HD8HQ8jvFy5ZuQQfGxNlAwfxas/vZ+Kq34MZWX9WLRI7+pxYL7//vsJDw9n0aJFbZuHiIiInKos7u6c8eSTuPr4ULJpEzteeMHoknqfyQSxEY6ttV0sjl0BKzrf3XeIpwvXjg7F397E4dhEXr39YSqumA+lpf1YtEjv6XFgzs3N5ZVXXuHw4cPMnDmT5ORk/vSnP3VrIxEREZHByDcujsm//jUA2//6Vw5t2WJwRX0kyB8mjIShMUc2O+lEoLuFa0eHEkgzlZGx/OeuP1B11Y+hvLx/ahXpRT0OzBaLhUsuuYS33nqLnJwcfvazn/Hqq68SGxvLJZdcwrvvvotNS8mIiMgpJv6ii4ibOxe71UravffSVFNjdEl9w9PdsclJq4ZG2JcNx1laz8/Nwo9HDcEfK+UxCfzn5w9R86OrobKyHwsWOXkntaxcaGgo06dPZ+rUqZjNZrZt28b111/P0KFD+eKLL3qpRBERkYFh8q9/jVd4ONU5OWz605+MLqfv2e2QkQl5xbB5F9Q1dDjFz83Cj0eG4EczZQnDee2m/0ftVVdDdecjHSLO5oQCc1FREY8//jijRo3i7LPPprKykvfff5/MzEzy8/O5/PLLWbhwYW/XKiIi4tTc/PyY+sc/gsnE/jffJPezz4wuqW+ZTBAf6djwpKYONu2EsooOpwW4W/jxyCH42JspGT6SlQuWUn/VfKivN6BokZ7r8bJyF198MatXryYpKYkbb7yRBQsWEBTUfo4pPz+f6OjoAT2aoWXlRETkRG1+4gkyXn4ZzyFDuPDdd3Hz9ze6pL7V0Ag79jsuBgTHihox4R221y6tb+bVnYeoNbkQ9906rvp0JZb//B9YLAYULYOB0y4rFxoaytq1a9m+fTuLFy/uEJYBIiIiyMzM7JUCRUREBprU22/HLyGBupISNj32mNHl9D13Nxg3AiJCHPcz82Dn/g5zzcEeLlyVHIKb3UrWaTP4YOxM7Hfd5RjtEHFiPQ7Mf//735k6dWqX55hMJuLi4k64KBERkYHM4u7OlN/9DkwmDrzzDvlffml0SX3PbIakeEiKc3SWa+qgqeOFgOFeLlw2LBCz3cbOuVfyhSkAHn+838sV6Ykej2Q888wzx38hkwkPDw+GDRvGjBkzsAzwX69oJENERE7Wxj/+kd3//jde4eFc+O67uPr4GF1S/6isBg93cHPt9JRtpfV8kO248O/cP93PpEtmwjXX9FeFMkg47dbYCQkJlJSUUFtbS2BgIHa7nfLycry8vPDx8aG4uJjExEQ+//xzYmJi+qruPqfALCIiJ6u5ro5Vl11GdU4Ow6++um2t5lNOTR14e3Y4nFZYy7qCWrDZuPzeRSQ9sARmzjSgQBmonHaG+Q9/+AOTJ09m7969lJaWUlZWxp49e5gyZQpPP/002dnZhIeHc9ddd/VFvSIiIgOGi6cnUx56CIC9K1dSun27wRUZoOAQbNgBuR03OJsa5sn4YHcwm3n/t89S/Mv/B/v3G1CkSNd63GEeOnQob775JuPGjWt3fPPmzVxxxRUcOHCAtLQ0rrjiCgoKCnqz1n6lDrOIiPSWtPvu4+D//kfQqFHM/s9/MA/wscUeyS5wXAQIkJwAYcHtHrba7by+p5ysWiv+uQdZ+Ps78FrzEeh7r3SD03aYCwoKaG5u7nC8ubm5bXvsyMhIqqqqTr46ERGRQWD80qW4+vpStmMH+15/3ehy+ldMOESFOr7efbDDOs0Wk4l5Q/0JsNipiI7nnUX3YL1uwXF3DhQxSo8D88yZM7n55pvZvHlz27HNmzdz6623MmvWLAC2bdtGQkJC71UpIiIygHmGhDD2zjsB2PL009SVlBhcUT8ymWBoDAwJdCwft/Oo9ZpbeLqYuWJ4IG52G9mTz+CzEVPgVJ33Fqd0QsvKBQUFMXHiRNzd3XF3d2fSpEkEBQXx97//HQAfHx+eeOKJXi9WRERkoBp21VUEjRpFU1UVm0+175Emk2McI8AXrDbYthfq2u/yN8TThYuHOjZ42fjjm8jYmAH/+58R1Yp00KMZZrvdTnZ2NkOGDCEnJ4fdu3djt9tJTk5mxIgRfVlnv9MMs4iI9LbS7dtZffXVYLcz+z//ISQ11eiS+lezFbbshupaiIt0bKt9jLX5NXxTVIdbTTULb7uC4HffAP3WWjrhlMvK2Ww2PDw82LFjB8OHD++zopyBArOIiPSFbx94gAPvvEPw2LHMfvVVTMdsHz3oNTZBcZljrvk4n91mt/Pa3nKya6yE7MtgwZP34vb5Z+DhYUCx4uyc8qI/s9nM8OHDKS0t7at6REREBrXUO+/ExdOT0i1byFq1yuhy+p+bK0SHHQnLNpvj1sJsMnFJgj8+JhuHhqWweu61oKVqxWA9nmF+7LHH+OUvf8n2U3EtSRERkZPkFRrKyBtvBCD9ySdprq//gWcMYlYrbN/nWD3jqF94+7iauWRYICa7nR0XzWfHwWJ4+23j6pRTXo/XYQ4MDKS2tpbm5mbc3Nzw9Gy/c09ZWVmvFmgUjWSIiEhfaa6v5/0LL6S2sJDUX/yC0bfcYnRJxqiogi17HGE5KtSxmsZRYxpfFdTyVWEt7lWV3HDrZQR8vAqiogwsWJxNf+U1l54+YdmyZX1QhoiIyKnDxcODcUuWkHbPPex86SWGXnklniEhRpfV//x9YUQ87MqEvGLHuEZsRNvD08I9yaxoIA8/3r/7D1xz/fWYV68Gc49/QS5yUnrcYT5VqMMsIiJ9yW638/GPf0zptm0kXXstk/7f/zO6JOPkFMKBXMfXI+Ih/MgPD+UNVv6xs5QGzJyx/I+cMSwU7rnHmDrF6TjlRX+t9u/fz69+9St+/OMfU1xcDMBHH33Ejh07erU4ERGRwcpkMjF28WIA9q1cSXVenrEFGSkm3HEhIDjmmUuP7AYY4G5hdpwjCH1901IKXnkd0tP7v0Y5pfU4MK9du5YxY8awfv163nrrLaqrqwHYunUrDz74YK8XKCIiMliFn346Yaefjq25mW1/+YvR5RgrMRpCgxxf785stzX2qCAPUgLcsLu4sOpXT9J808+gqcmgQuVU1OPAfN999/H73/+eNWvW4Obm1nZ85syZfPPNN71anIiIyGDXumX2wf/9j4p9+wyuxkAmk2McIywYxgwHi6Xdw+fF+OBltlMyfCRpk8+BRx81pk45JfU4MG/bto3LLrusw/EhQ4ZofWYREZEeCklNJfrcc7HbbGx59lmjyzGW2ezYQtvXu8NDXi7mttGMb264k8L/vgtbtvR3hXKK6nFgDggIoKCgoMPxzZs3E6WlXkRERHps7C9+gclsJveTTyjVPgdHVFY7ttJu2dgkOcCd5JbRjA9+/RTNN96k0QzpFz0OzNdccw333nsvhYWFmEwmbDYbX3/9NUuXLmXBggV9UaOIiMig5j9sGHEXXQTA9r/+1eBqnITdDhmZUF4F2UcadbOjj4xmrB97Jjz+uIFFyqmix4H5kUceITY2lqioKKqrqxk5ciQzZsxg2rRp/OpXv+qLGkVERAa90T/7GZhM5H3+OYczMowux3gmEyS2/OY6uxBqHTsiermaOTfGMZqRduNdHP77v+DAAaOqlFNEjwOzq6srr776Knv27OH111/nlVdeYdeuXfz73//GcsyAvoiIiHSPX0ICcRdcAMD2v/3N4GqcREggBPo5us37stu2z04JdCPexxWruwcfL3kY++23t9taW6S3nfBWOUOHDuXKK6/kqquuYvjw4b1Zk4iIyClp1M03A5CzZg3le/caXI0TMJlgeKzjz8OVUHK45bCJ2TE+WLCTOXUmu6zu8MYbBhcrg1mPt8a2Wq2sWLGCTz/9lOLiYmwtg/itPvvss14rTkRE5FQSMHw4MeedR86aNez429+Yrvlc8PRwbJedlQ/7cyDIH1wsBHlYmBruzVeFtXxy9+9J+PnleJx/Pmh3XukDPe4w33nnndx5551YrVZGjx7N2LFj291ERETkxI1u6TJnffQRFZrNdYgNB093aGyCwkNth08P8yTIzUTNkDC+mrcAtIGa9BGT3d6zoZ+QkBD+9a9/MXfu3L6qySn0197kIiIix1r785+T98UXJF5+Oaf/7ndGl+McDlc6AnNokGNEo8XBykZe21+JuamJn157DiH/ewuSkw0sVPpTf+W1HneY3dzcGDZsWF/UIiIiIsDIG28EHLv/1ZWUGFyNkwj0c+wCeFRYBoj3c2OYvxs2V1c+u/NBWLLEoAJlMOtxYL777rt5+umn6WFjWkRERLppyPjxhIwbh62pid2vvmp0Oc6nuRkqqtruzor0xoydA9PPYX9lE6xaZWBxMhj1eCTjsssu4/PPPycoKIhRo0bh6ura7vG33nqrVws0ikYyRETESDmffMKXd96Jq58f8z75BFfvjttFn5Jq64/s/jd5NLg5csjneTWsL64jKHMvi359I5b0dDgmo8jg47QjGQEBAVx22WWcddZZhISE4O/v3+4mIiIiJy9q5kx84+JoqqzkwNtvG12O8/B0BzcXaLbCgdy2w9PCPfGyQFnCcDaNOxOee87AImWw6XGH+VShDrOIiBht78qVfP/ww3hHRXHxqlWYXXq8GuzgVFkNm3c5vh47AgJ8AdhyqJ4Pc6rxKC/jlgXn4rFtKwQEGFen9Dmn6zAXFxd3+XhzczPffffdSRckIiIiDgmXXop7YCA1eXnkrFljdDnOw88HIkIcX+/NcoxnAGOC3QlxN1MfEMT6S6+DP/3JwCJlMOl2YI6IiGgXmlNSUsjOzm67X1paytSpU3u3OhERkVOYi4cHSddcA8Cuf/3L4GqcTEI0uLo4ZppziwAwm0zMiHTMem+45mdUv/IfyM83skoZJLodmI+d3MjNzaW5ubnLc0REROTkDLvqKswuLpRu3Urp9u1Gl+M8XF0gMdrxdVYB1DcAMNzfjSgvF5o8vfn6J7fBQw8ZWKQMFj2+6K8rpmPWRhQREZGT4xkSQuwFFwCw9z//MbgaJxMWDP4+EBIAZkekMZlMnBXl6DJvuew6Dq/+FHbvNrBIGQx6NTAboaqqismTJzNu3DjGjBnDiy++2PbYU089xahRoxg5ciR33HGHOuAiIjIgtY5lHFy1ivrDhw2uxomYTJCaBCmJbcvLAcT6uDLUzxWbqyvrbrkXHnjAwCJlMOh2YDaZTFRVVVFZWUlFRQUmk4nq6moqKyvbbkbw8vJi7dq1pKens379eh599FFKS0spKSnhueeeY+PGjWzbto2NGzfy7bffGlKjiIjIyQhOTSVo1ChsjY0cePNNo8txLuZjokxLc2xGhKPLnHH+ZZSk74DNm/u7MhlEejTDnJSURGBgIEFBQVRXVzN+/HgCAwMJDAxkxIgRfVlnpywWC15eXgDU19djtVrbOsnNzc3U19fT1NREU1MToaGhhtQoIiJyMkwmE0k//jHgWGrOZrUaXJETqm+A7fsgMw+AMC8XRgS4AfD1TXfDww8bWZ0McN0OzJ9//jmfffZZ262z+z21bt06Lr74YiIjIzGZTLzzzjsdznn++edJSEjAw8ODiRMn8uWXX7Z7vLy8nLFjxxIdHc0999xDSEgIQ4YMYenSpcTGxhIZGcm5557L0KFDe1yfiIiIM4idMwf3gABq8vPJX7vW6HKcT3UtlJY7Vsyoc1wAOD3c0VDbde4lHNqyE7ZsMbBAGci6vQL6WWed1ScF1NTUMHbsWG644QauuOKKDo+vXLmSxYsX8/zzzzN9+nT+9re/MWfOHHbu3ElsbCzg2H1wy5YtFBUVcfnll3PllVfi5ubG+++/z8GDB/H09GTOnDmsW7eOGTNmHLeOhoYGGhoa2u4bNWIiIiJyPC4eHiRefjkZL7/Mnv/7P6JnzTK6JOcSHACBfnC4EnIKICmeUE8Xkvzd2FPRyNc33c2lDz8MGmmRE2D4RX9z5szh97//PZdffvlxH3/yySdZtGgRN954IykpKSxbtoyYmBiWL1/e4dywsDBSU1NZt24dn3zyCcOGDSMoKAhPT08uvPDCLmeYH3300XZbfMfExPTaZxQREekNw6++GkwmCr/5huqcHKPLcS4mE8RFOL4uLIWGRuBIlzlj9jwObd4GW7caVaEMYIYH5q40NjayceNGZs+e3e747NmzSUtLA6CoqKitG1xZWcm6desYMWIEMTExpKWltc01f/HFF13OWd9///1UVFS03XL0F5GIiDgZn6goIqZNA2D/W28ZXI0T8vd13Ox2yCkEHLPMw/3dwGwmbdES+N3vDC5SBiKnDsyHDh3CarUSFhbW7nhYWBiFhY7/EXJzc5kxYwZjx47ljDPO4Pbbbyc1NZXTTz+duXPnMn78eFJTUxk6dCiXXHJJp+/l7u6On59fu5uIiIizGdoyvnjgnXewHbOBmHCky1xQAo1NwFFd5vMvo2z9Jtixw6jqZIDq9gyzkY7dEMVut7cdmzhxIunp6cd93iOPPMIjjzzS1+WJiIj0m6iZM3EPDKSuuJiCr74i6uyzjS7JuQT4gq83VNVAXjEkRBHu5cJQP1f2V8J3193KBY8/Dv/4h9GVygDi1B3mkJAQLBZLWze5VXFxcYeus4iIyKnA4uZGQstvTPfrAraOTCZIiHJsmx0b3nb49DBHl3nbxVdT8+FqyM01qkIZgHocmGtqavj1r3/NtGnTGDZsGImJie1uvcnNzY2JEyeyZs2adsfXrFnDtJYZLhERkVPN0JYL5fPWrqWupMTgapxQoB/EhIPF0nYo2tuFSC8XrO4ebLzienj6aePqkwGnxyMZN954I2vXruW6664jIiKiw7hET1VXV7Nv3762+5mZmaSnpxMUFERsbCxLlizhuuuuY9KkSUydOpUXXniB7OxsbrnllpN6XxERkYHKf9gwQsaN41B6OgfeeYdRN91kdEnOy24Hux2T2cyUME/ezqxi41U/5fSrzsDtgQcgIMDoCmUA6HFg/vDDD/nggw+YPn16rxSwYcMGZs6c2XZ/yZIlACxcuJAVK1Ywf/58SktLefjhhykoKGD06NGsWrWKuLi4Xnl/ERGRgWjolVdyKD2d/W++ychFizAdu0W0QFkFHMiF0CCIjWC4vxtB7mbK/ALYcu48Jv/1r3DffUZXKQOAyd66j3Q3JSQksGrVKlJSUvqqJqdQWVmJv78/FRUVWjFDREScTnNtLW+dfTbNNTWc+69/ETpxotElOZ+iUtiVCa4uMGUMWCykH6rno5xq/ApyuflnF2PZtxc8PIyuVE5Qf+W1Hv84+rvf/Y7f/OY31NbW9kU9IiIi0g0uXl7EnnceAAf/9z+Dq3FSoUHg4Q5NzY5l5oDRQe54u5iojIhmV+oUePVVg4uUgaDHgfmJJ55g9erVhIWFMWbMGCZMmNDuJiIiIv0j/uKLAchavRprQ4PB1Tghk+nIShk5RWCz4WI2MWGIJwAbr74RnnnGMecs0oUezzDPmzevD8oQERGRngo77TS8wsOpLSwkf906Ylo6znKUsGDIyoeGJig8BJGhjAv2IK2glvwxk8i3Wohctw7OOsvoSsWJ9TgwP/jgg31Rh4iIiPSQyWwmbu5cMl5+mcz//U+B+XjMZscSc/tyILsQwkPwdjWTHOjOjsMNbLz6RiKffVaBWbp0wpfUbty4kVdeeYVXX32VzZs392ZNIiIi0k2tm5jkr11LQ3m5scU4q/Ahjgv/GhqhtByASUMcF/plzJ5HzbqvIDvbwALF2fU4MBcXFzNr1iwmT57MHXfcwe23387EiRM555xzKNHi6SIiIv0qYPhwAkaMwNbcTPbq1UaX45wsZhgWC6OHQUggABHerkR6uWBzdSP90mth+XKDixRn1uPA/Itf/ILKykp27NhBWVkZhw8fZvv27VRWVnLHHXf0RY0iIiLShdYuc+Z77xlciRMLDYLgAMeFgC0mtnSZN//oBqwv/wPq6gwqTpxdjwPzRx99xPLly9utwzxy5Ej+8pe/8OGHH/ZqcSIiIvLD4ubOxWQ2cyg9nSqNFvwwqxXsdpIDHEvMVQ8JZ/e4qfCf/xhdmTipHgdmm82Gq6trh+Ourq7YbLZeKUpERES6zys0lLApUwDI/ugjg6txcrlF8O1WKC3HYjYxPsSxxNzmK6/XWIZ0qseBedasWdx5553k5+e3HcvLy+Ouu+7inHPO6dXiREREpHtiL7gAgCwF5q41NUGzFbIKwG4nNdgdE5AzaTqlJYdBCxnIcfQ4MD/33HNUVVURHx/P0KFDGTZsGAkJCVRVVfHss8/2RY0iIiLyA2LOPReTxUL57t1UHjxodDnOKyrMsdRcdS0crsTPzUKin+M351su+wm8+KLBBYoz6nFgjomJYdOmTXzwwQcsXryYO+64g1WrVrFx40aio6P7okYRERH5Ae4BAYSffjqAVsvoipsrRA5xfJ2VD3Y740IcF/9tv2g+1pWvQ02NgQWKM+pRYG5ubsbFxYXt27dz3nnn8Ytf/II77riDc889t6/qExERkW6KPf98QIH5B0WHOVbLqKyBiiqG+rnh42KiNmgIeydMh9dfN7pCcTI9CswuLi7ExcVhtVr7qh4RERE5QdHnnIPJxcUxlpGZaXQ5zsvdDSJCHF9nFWA2mUgNdnSZ0y+/TmMZ0kGPRzJ+9atfcf/991NWVtYX9YiIiMgJ0lhGD8SEO7rM5VVQW98SmO0cPP1syrPzYft2oysUJ9LjwPzMM8/w5ZdfEhkZyYgRI5gwYUK7m4iIiBhHYxnd5OEOw+Ng8ijw8iDA3UKCrxsAW+Zdqy6ztOPS0ydceumlmI7aJUdEREScR/SsWXz30EOU79lDxYED+CcmGl2S82ody2gxNtiDzKomtl18NWdeOxPzY4+Bu7tBxYkz6XFg/u1vf9sHZYiIiEhvaB3LKPjqK7JXr2bMrbcaXdLA0NjEMH83PCwmqkMjyBo2moQPPoDLLze6MnECPR7JSExMpLS0tMPx8vJyEvVTrIiIiOFiZ88GIO/zzw2uZACw22FXJny7FZe6elICHR3l7RddBf/6l8HFibPocWA+ePDgcVfJaGhoIDc3t1eKEhERkRMXedZZYDJRtmMHNQUFRpfj3EwmsFodwTm7gNFBjsC8Z9aFNH72ORw6ZHCB4gy6PZLx3nvvtX29evVq/P392+5brVY+/fRTEhISerc6ERER6THPkBCGjBtHyebN5H3+OUnXXGN0Sc4tNgIOlUNxGZFxkQS6mzmMN7tnXMCY116D2283ukIxWLcD87x58wAwmUwsXLiw3WOurq7Ex8fzxBNP9GpxIiIicmKiZs2iZPNmchWYf5ivNwT5QVklppxCRgeF8mVBLdsvuooxL/9JgVm6P5Jhs9mw2WzExsZSXFzcdt9ms9HQ0MDu3bu56KKL+rJWERER6aboWbMAKPruOxorKw2uZgCIjXT8WVTKaC/HamBZk8+kMisXMjIMLEycQY9nmDMzMwkJCfnhE0VERMQwfvHx+CUmYm9uJv/LL40ux/n5+0CAL9jt+JeWEePjAmYzO+dcCf/+t9HVicF6HJjvuOMOnnnmmQ7Hn3vuORYvXtwbNYmIiEgvaO0y52q1jO4JC3b8WVbO6CDHVtnbL7oK+7//DTabgYWJ0XocmN98802mT5/e4fi0adN44403eqUoEREROXmtgbngyy+xNjYaXM0AEBwAI+JhTBIjAtywmODQ0GSKPf3hq6+Mrk4M1OPAXFpa2m6FjFZ+fn4c0tIrIiIiTiN4zBg8QkJoqq6m+PvvjS7H+bm6QHgIuLniYTEz1M+xVfau2ZfCypUGFydG6nFgHjZsGB999FGH4x9++KE2LhEREXEiJrOZ6JkzAcj99FODqxl4kls2McmYPQ/7G29Ac7PBFYlRerw19pIlS7j99tspKSlhVsuvej799FOeeOIJli1b1tv1iYiIyEmImjWLff/9L3lr1zLJbsdkMhldknOz2yG3CMoqGJY8FBcTlMckUBQcTvjatXDOOUZXKAbocWD+6U9/SkNDA4888gi/+93vAIiPj2f58uUsWLCg1wsUERGRExc2eTIWd3dqCwup2L+fgGHDjC7J+RWUQF0DbpVVDPN3Y1d5Ixmz5xG+cqUC8ymqxyMZALfeeiu5ubkUFRVRWVnJgQMHFJZFRESckIunJ6GTJwOOi//kB5hMjov/AErLj4xlnHcp9jffhKYm42oTw5xQYG5ubuaTTz7hrbfewm63A5Cfn091dXWvFiciIiInL/LMMwHIX7fO4EoGiOCWxQ3KKhjq64qbGSojY8mPSgDNgp+SehyYs7KyGDNmDJdeeik///nPKSkpAeCxxx5j6dKlvV6giIiInJzWwFyyaRNNNTUGVzMA+PmAiwWamnGtrmGY/5GL/7Raxqmpx4H5zjvvZNKkSRw+fBhPT8+245dddhmf6qcuERERp+MbF4dPbCy25mYKv/3W6HKcn9kMQS1d5tIKUgIdy8vtPvcS7O+8Aw0NxtUmhuhxYP7qq6/41a9+hZubW7vjcXFx5OXl9VphIiIi0ns0ltFDR80xJ/i64W6GqrBI8uKSYM0aQ0uT/tfjwGyz2bBarR2O5+bm4uvr2ytFiYiISO9qDcwFX33Vdv2RdCHIDywW8HTHxW5rG8vYM3MuvPOOsbVJv+txYD7vvPParbdsMpmorq7mwQcfZO7cub1Zm4iIiPSS0KOXl9u3z+hynJ+LC0wbC6OHg8XC8ADHb9b3zJyL/b334DjNQxm8ehyYn3rqKdauXcvIkSOpr6/nmmuuIT4+nry8PP70pz/1RY0iIiJyklw8PAg97TRAYxndZj4SkxJ93bC0bGJyyC8Y0tIMLEz6W48Dc2RkJOnp6SxdupSbb76Z8ePH88c//pHNmzcTGhraFzWKiIhIL2ibY9Z6zD1T34AbNuJ9XQGNZZyKTHYNMh1XZWUl/v7+VFRU4OfnZ3Q5IiIiJ60qO5v/zZmDycWFK9PScPX2Nrok57djPxw6DCkJbLF482F2NWEZW7jhVzfB/v2OjU7EMP2V17q1NfZ7773X7Re85JJLTrgYERER6Tu+sbF4R0dTk5tL8caNRM2YYXRJzs/TcbEfhyoYPjyQj4CilLFU1DXiv20bpKYaWp70j24F5nnz5nXrxUwm03FX0BARERHnEH766ex/4w0Kv/lGgbk7ggMgpxDKKvCyQJS3C7k1zew9ey6T3n5bgfkU0a0ZZpvN1q2bwrKIiIhzC586FYAibWDSPX7e4OriWBWjopqkgNbl5eZojvkU0uOL/pxNVVUVkydPZty4cYwZM4YXX3yx7TEXFxfGjRvHuHHjuPHGGw2sUkRExDmETZkCQPmePdQdOmRwNQOAyXTUrn/lJPk7lpfLGT+VuswsyMw0sDjpL90OzHPnzqWioqLt/iOPPEJ5eXnb/dLSUkaOHNmrxXWHl5cXa9euJT09nfXr1/Poo49SWloKQEBAAOnp6aSnp/PSSy/1e20iIiLOxiMwkMCUFACK1q83uJoBIiTA8WdpBQFuZoZ4WLC7uLDvzNnw7ruGlib9o9uBefXq1TQctXf6n/70J8rKytruNzc3s3v37t6trhssFgteXl4A1NfXY7VatYORiIhIF8JPPx2AQo1ldE+gn6PTXN8AtfVtm5jsP+M8eP99g4uT/tDtwHxsCO2tULpu3TouvvhiIiMjMZlMvHOceaDnn3+ehIQEPDw8mDhxIl8es35keXk5Y8eOJTo6mnvuuYeQkBDAsdTIxIkTOeOMM1i7dm2v1CsiIjLQhbUG5rQ0NZm6w2KBhCgYORQ83Bjq5wjMmVPPxvp1GlRVGVyg9DXDZ5hramoYO3Yszz333HEfX7lyJYsXL+aBBx5g8+bNnHnmmcyZM4fs7Oy2cwICAtiyZQuZmZn83//9H0VFRQAcPHiQjRs38te//pUFCxZQWVnZL59JRETEmYVOmIDZ1ZXawkKqjvp+Kl2ICYchgWCxEOHlgqeLiQZff/JGjodPPzW6Oulj3Q7MJpMJ0zGLcx97/0TMmTOH3//+91x++eXHffzJJ59k0aJF3HjjjaSkpLBs2TJiYmJYvnx5h3PDwsJITU1lXcuWn5GRkQCMHj2akSNHsmfPnk7raGhooLKyst1NRERkMHLx8iJk3DgAir75xthiBiCzyUSib+tYxjnwwQcGVyR9rVvrMINjBOP666/H3d2xnEp9fT233HIL3i27BB0939xbGhsb2bhxI/fdd1+747NnzyatZQ/3oqIiPD098fPzo7KyknXr1nHrrbdy+PBhvLy8cHd3Jzc3l507d5KYmNjpez366KM89NBDvf4ZREREnFH46adT/P33FH77LcOvvtrocgaGmjooOQy+Xgz182TH4QYOTD+XmXf9GOx27fo3iHU7MC9cuLDd/Z/85CcdzlmwYMHJV3SUQ4cOYbVaCQsLa3c8LCyMwsJCAHJzc1m0aBF2ux273c7tt99OamoqaWlp3HzzzZjNZkwmE08//TRBQUGdvtf999/PkiVL2u5XVlYSExPTq59HRETEWYRPncrWZ5+laP16bFYrZovF6JKcX0kZZBVASAAJIxIxASXDR1JhM+G/ZQu0dO1l8Ol2YP7HP/7Rl3V06djRD7vd3nZs4sSJpKend3jOtGnT2LZtW7ffw93dva17LiIiMtgFjRqFq48PjZWVHM7IIHj0aKNLcn7BAY7AXFaJp/nIrn8Hpp/L+FWrFJgHMcMv+utKSEgIFoulrZvcqri4uEPXWURERLrP7OLCkIkTASjesMHgagYIHy9wcwWbDQ5XkejXOsd8ruaYBzmnDsxubm5MnDiRNWvWtDu+Zs0apk2bZlBVIiIig0PopEmAAnO3mUyOLjNAWXnb8nJZp51J86bN0LJxmgw+hgfm6urqtt34ADIzM0lPT29bNm7JkiW89NJLvPzyy2RkZHDXXXeRnZ3NLbfcYmDVIiIiA19rYC7ZuBG7zWZwNQNE8JFtskM9zPi4mmny9CZ7/OmwerWxtUmf6fYMc1/ZsGEDM2fObLvfeuHdwoULWbFiBfPnz6e0tJSHH36YgoICRo8ezapVq4iLizOqZBERkUEhKCUFF09PGisrKd+7l8ARI4wuyfkF+oHZDA1NmGrqGernypbSBvafcR6JH3wA11xjdIXSBwwPzGefffYP7jJ02223cdttt/VTRSIiIqcGs6srIePHU5iWRvGGDQrM3WE2O0JzeRXU15Po582W0gYOnn4W3PKUY77ZbPgv8KWX6d+oiIjIKUxzzCcgKQ6mjYUhQcT5uGICShOSqDS5QA9W6JKBQ4FZRETkFNZujvkHfuMrLdxc27rIHi5mwr0cv7A/ePrZcMxCBTI4KDCLiIicwoLHjMHi7k59aSmVmZlGlzOw2O3QbCXB1xWAg6fNUGAepBSYRURETmEWNzeCU1MBjWX0SFkFfLcNMg4Q7+tYXu7glBnYv/wS6usNLk56mwKziIjIKS508mRAgblH3N2gvhEOVxLlYcLVDLXBoZREJ0BamtHVSS9TYBYRETnFhR6145/mmLvJywM83MBux1JRRYyPYywjc8pZGssYhBSYRURETnEhY8didnGhrqiI6pwco8sZGI7e9a+04shYhi78G5QUmEVERE5xLp6eBI8ZA0Dxxo0GVzOAtAXmchJ8HCtl5Iw/neZt27VN9iCjwCwiIiIMmTABgEObNxtcyQDi7wMWCzQ1E9JUj7eLiWZPL/JSJ8GnnxpdnfQiBWYREREhZNw4AA6lpxtax4BiNkOQHwCmsqPGMjTHPOgoMIuIiEhbYK7Yv5/GigpjixlIQoMhcggE+RPfuh6zAvOgo8AsIiIieAQF4RsXB8ChrVsNrmYACQmA4XHg79sWmAtTxlJfWgYHDxpamvQeBWYREREBNJZxsnzdLAS6m7FbLOSNnQJr1xpdkvQSBWYREREBjgTmEgXmnrHbobwK8kva1mPOnjQNvvjC2Lqk1ygwi4iICABDWgJz6dat2JqbjS1mIKlrgC27YV828Z6OaJU9QYF5MFFgFhEREQD8hg7F1ceH5tpaKvbuNbqcgcPLAzw9wG4nvqkOcMwxNxSXQFaWwcVJb1BgFhEREQDMFgvBqamAxjJ6LNgfAK+KSgLczNhdXMgbpznmwUKBWURERNoMGT8egENbthhcyQDTuutfWQWx3o5d/7InTldgHiQUmEVERKRNyNixgFbK6LHWXf+arQx3sQK68G8wUWAWERGRNsGpqWAyUZ2TQ11JidHlDBwmE/h5AxBtbQCgIGUcjQVFkJNjZGXSCxSYRUREpI2bry8Bw4cDGsvoMX8fADzr6vBrmWPOHXeaxjIGAQVmERERaUcbmJygsBCYOBJGxBPbsh5zzsRpCsyDgAKziIiItBPSslKGtsjuIQ838PECk6ktMGdP1BzzYKDALCIiIu0EjxkDQNnOndrA5AS1BuaCUeNpzM2HvDyDK5KTocAsIiIi7fgmJODi5YW1ro7KAweMLmdgqaiGXZn4Fxbh62rG5uJKwejx8PXXRlcmJ0GBWURERNoxWywEjRoFQOn27QZXM8A0NkJRKaZDh4luWY85d+wUBeYBToFZREREOggePRpQYO4xP8dKGVTXEePhiFl5YycrMA9wCswiIiLSQescc+m2bQZXMsC4uzku/gPiaQQgL3US9i1boLrayMrkJCgwi4iISAetgbl8zx6sDQ0GVzPAtHSZA+rrcDVDg18Ah2KHwnffGVyYnCgFZhEREenAKyICj+Bg7M3NHN61y+hyBpaWDUzMldVEeDlWy8gbdxqkpRlZlZwEBWYRERHpwGQyEaQ55hPTOsdcWUO0lwXQhX8DnQKziIiIHFfbhX+aY+4Zb09wsYCnO7GOcWbHhX/ffAM2m7G1yQlRYBYREZHjatvARB3mnjGZ4PRUmDSK8EAvAA7HJlJjcYMdOwwuTk6EArOIiIgcV+tIRmVmJo2VlQZXM8BYHKMYHi5mhng4vs5LnaQ55gFKgVlERESOyyMwEO/oaMCxTbacAJuNKK+WDUzGnaY55gFKgVlEREQ6pTnmE2S3w5bd8PVm4t3sAOSNVWAeqBSYRUREpFNtG5hojrlnTCawWsFmJ9rmWMe6MGUszbl5UFhocHHSUwrMIiIi0qnWDrMu/DsBLcvLedfU4uViwurmTmHKWHWZByAFZhEREelUYHIyALWFhdQfPmxwNQNMywYmpspqorwdG5jkj54A69cbWZWcAAVmERER6ZSrjw8+sbEAHM7IMLiaAaZ1A5OaOmLcTQAUjJ6gLbIHIAVmERER6VJQSgqgwNxj7m7g4di5JJZGAPJHjYcNGxzzzTJgKDCLiIhIlwJbAnOZAnPPtXSZQxrqAKiIjqfW1QP0z3JAUWAWERGRLgWqw3zigvwh2B8XHy+C3R0bmORrLGPAUWAWERGRLrWOZFRlZdFUU2NwNQNMWDCMHg6hQUR4OzYwKRg9Xhf+DTADPjBXVVUxefJkxo0bx5gxY3jxxRcByMnJ4eyzz2bkyJGkpqby3//+1+BKRUREBiaP4GA8w8LAbufwrl1GlzNgRbbs+FcwSh3mgcbF6AJOlpeXF2vXrsXLy4va2lpGjx7N5ZdfjouLC8uWLWPcuHEUFxczYcIE5s6di7e3t9Eli4iIDDiBycnUFRVxeNcuQidONLqcgae+gWiL40K//FHjsW/bhqm2Fry8DC5MumPAd5gtFgteLf+x1dfXY7VasdvtREREMG7cOABCQ0MJCgqirKzMwEpFREQGLq2UcRJyC2H9NkIKirCYoD4giPKIGNi82ejKpJsMD8zr1q3j4osvJjIyEpPJxDvvvNPhnOeff56EhAQ8PDyYOHEiX375ZbvHy8vLGTt2LNHR0dxzzz2EhIS0e3zDhg3YbDZiYmL68qOIiIgMWm0rZezcaXAlA5CPo7FnrqwmzMNx4V/BKM0xDySGB+aamhrGjh3Lc889d9zHV65cyeLFi3nggQfYvHkzZ555JnPmzCE7O7vtnICAALZs2UJmZib/93//R1FRUdtjpaWlLFiwgBdeeKHPP4uIiMhgFTRyJAAV+/djbWw0uJoBxtcbTCZobCLB3Q5opYyBxvDAPGfOHH7/+99z+eWXH/fxJ598kkWLFnHjjTeSkpLCsmXLiImJYfny5R3ODQsLIzU1lXXr1gHQ0NDAZZddxv3338+0adO6rKOhoYHKysp2NxEREXHwiojAzc8Pe3MzFfv2GV3OwGKxgI8nAAk2xw8b2vFvYDE8MHelsbGRjRs3Mnv27HbHZ8+eTVpaGgBFRUVt4bayspJ169YxYsQI7HY7119/PbNmzeK66677wfd69NFH8ff3b7tpfENEROQIk8mksYyT0bqBSWM9AIXJqVhzcqCkxMiqpJucOjAfOnQIq9VKWFhYu+NhYWEUFhYCkJuby4wZMxg7dixnnHEGt99+O6mpqXz99desXLmSd955h3HjxjFu3Di2bdvW6Xvdf//9VFRUtN1ycnL69LOJiIgMNK1jGbrw7wT4+wLgXlODu8WE1d2DkmEj1WUeIAbEsnImk6ndfbvd3nZs4sSJpKend3jOGWecgc1m6/Z7uLu74+7uflJ1ioiIDGaByckAWov5RPg6lrU11dQR7W9mf7WVglHjCV+/Hi680ODi5Ic4dYc5JCQEi8XS1k1uVVxc3KHrLCIiIn2rbYvs3buxWa0GVzPAuLtCbASkJBDu2bqByXjYtMngwqQ7nDowu7m5MXHiRNasWdPu+Jo1a37wIj4RERHpXb7x8Vg8PLDW1VF91GpV0g0mEyREQWgwoT5uABSNGAMbNxpcmHSH4SMZ1dXV7DvqatvMzEzS09MJCgoiNjaWJUuWcN111zFp0iSmTp3KCy+8QHZ2NrfccouBVYuIiJx6zBYL/kOHUrZjB+V79uCXkGB0SQNSeMsW2SXDkmkuLcOloAAiIgyuSrpieGDesGEDM2fObLu/ZMkSABYuXMiKFSuYP38+paWlPPzwwxQUFDB69GhWrVpFXFycUSWLiIicsgJGjGgLzLHnn290OQOL1QaV1fg1NOJhMVGPG4eGJhO+aZPmmJ2c4YH57LPPxm63d3nObbfdxm233dZPFYmIiEhnAoYPB6B8716DKxmAGhph6x5MZjMR4YlkVjdTlJyqwDwAOPUMs4iIiDiXgKQkAMr37DG4kgHI0x0sZrDZiLc4VvIqTB6jC/8GAAVmERER6bbWwFydk0NTTY3B1QwwJhN4ewEQjWPHv6KUVAXmAUCBWURERLrNIygIj5AQAG2RfSJ8HYE5uKkBgOLho7Dl5cGhQ0ZWJT9AgVlERER6RGMZJ8HHEZjd6+pwM5to9vCkNH44bN5scGHSFQVmERER6REF5pPQEphN1XWEeTpiWGGyxjKcnQKziIiI9EhbYNZKGT3n5eGYZbZaiXd1rBJWmDJWgdnJKTCLiIhIj7QF5t27f3BpWDmG2QwpCTA+hQBfD0AX/g0ECswiIiLSI/6JiZgsFhorK6krLja6nIFnSBD4eRPqfWSLbPv+/VBRYXBh0hkFZhEREekRi7s7vi077mqO+cQFe1hwMUGTlzdlsYmQnm50SdIJBWYRERHpsYARIwAF5hNitUJ+CeYDuYR6OjZdLtKFf05NgVlERER6rG2LbAXmE7M3C3KLiHVMZVCYkgobNxpbk3RKgVlERER6TEvLnQSLxbFaBhBLE6AOs7NTYBYREZEeaw3MlQcOYGtqMriaAahlPeYh1iM7/tn37IH6eiOrkk4oMIuIiEiPeUdG4uLtja25mcqDB40uZ+BpCcze9fWYgLrAYGoCQ2DnTmPrkuNSYBYREZEeM5lMmmM+GS2B2VxTR6C7BYDi4SNh61Yjq5JOKDCLiIjICfEfOhRwjGVID7UEZuobiHJ3fFmiwOy0FJhFRETkhLQG5or9+w2uZABydQEPxxIZsSYrAMVJoxSYnZQCs4iIiJwQPwXmkzNqGEwbh0ewL9AykrFlC2i7caejwCwiIiInpLXDXJWdjbWx0eBqBiAfL3B1adu8pDQhCWt5BRQWGlyYHEuBWURERE6IV3g4Ll5e2Jubqc7ONrqcAcvP1Yy72cT/b+/+Y6I48z+Av5cFAWEB+aWgKNAqulRFKFqNUClE0XqIba1NjGDFes155/WurfHSXHpprt5pNLWtrQ2xgNr2ij2r16DR0hYBxRSKGq2lfBWwKAJbKz8ECwL7fP/YMnFld1l2GfYH71eyifPMMzOf+fhk97PDM7NaVzf8EjGV0zLsEAtmIiIisohCoeA8ZmtotUDNdSgu/h8meCgA8EkZ9ooFMxEREVmMBbMVFAqg+Reg9Q4iXXQ3/vFJGfaJBTMRERFZTLrxj4+WGzqFQnq8XKjQ/VqiZmq07sY/sissmImIiMhi0rOYeYXZMr8VzP49up/E1kyNBqqqAN5EaVdYMBMREZHFpIK5rg7a3l4bR+OAVLqC2bNLVzB3Bo1Hp8oP+PFHGwZFD2LBTERERBbzCg2F0sMD2p4edNy4YetwHM99P5Ht76a78e/nqTM4j9nOsGAmIiIiiylcXOATGQmAN/5ZxMNd96t/Xp6YpPvhPz4pww6xYCYiIiKrcB6zFRQKYP5sIE4NlcoDAPAzb/yzOyyYiYiIyCp8tJyVFLqpGP2/+McrzPbH1dYB2Cvx2++4t7e32zgSIiIi++YyYQLu9vWh8ccf+blpBY+ePnR13MGN8aFo1WjgUlsLBAbaOiy71j/e+us2uSiE3EdwULW1tXjot2/MRERERGS/ampqEPnbXHo58AqzEf7+/gCA+vp6+Pr6yn68+Ph4VFRUyL6tOX1N9TG2zlD7g233L7e3tyMsLAzXr1+Hj4+PWbFbw5r8DnX7wfrKld8H2xwpx44yhh9sG8kcO+MYNtTOMTx4H47h4enLzzrrtreXz7q2tjZMnjxZqtvkwoLZCBcX3fRuX1/fERnkSqXS4uMMZVtz+prqY2ydofYH2wz18fHxsfv8DnX7wfrKlV9jbY6QY0cZw8baRiLHzjiGDbVzDA/eh2N4ePrys8667e3ts66/bpMLb/qzE5s2bRqRbc3pa6qPsXWG2h9ss+YcrWXtsYczx3Ll15xjy2k0jGFzjy8HZxzDhto5hgfvwzE8PH35WWfd9qPts45zmI1ob2+Hr68v2traRuRb4WjD/MqPOZYfcywv5ld+zLG8mF/5jVSOeYXZCHd3d7z++utwd3e3dShOifmVH3MsP+ZYXsyv/JhjeTG/8hupHPMKMxERERGRCbzCTERERERkAgtmIiIiIiITWDATEREREZnAgpmIiIiIyAQWzEREREREJrBgtoCrqytiYmIQExODDRs22Docp1RXV4ekpCSo1WrMnDkTnZ2dtg7JaVRXV0vjNyYmBp6enjh69Kitw3I6b731FqKjo6FWq7F582bwgUTDa+fOnYiOjsYjjzyCjz76yNbhOI2VK1di3LhxeOaZZ/TaCwoKEBUVhalTp2Lfvn02is45GMuxsXYaGkN5vH79OhYtWgS1Wo1Zs2bhs88+G/J++Vg5CwQGBuLWrVu2DsOpPf744/jnP/+JhIQE3L59Gz4+PnB15S+5D7eOjg6Eh4fjp59+gpeXl63DcRo///wzHnvsMVy+fBlubm5ITEzEzp07MX/+fFuH5hQuXbqEzMxMlJWVAQCSk5Nx7Ngx+Pn52TYwJ1BUVISOjg7s378f//3vfwEAvb29UKvVKCoqgo+PD2JjY/Htt9/C39/fxtE6JkM5NtVOQ2Moj42NjWhubkZMTAw0Gg1iY2NRXV09pM89XmEmu9NfZCQkJAAA/P39WSzL5IsvvkBycjKLZRn09vaiq6sLPT096OnpQXBwsK1DchpVVVVYsGABPDw84OHhgZiYGJw4ccLWYTmFpKQkqFQqvbby8nJER0dj4sSJUKlUWLZsGU6ePGmjCB2foRybaqehMZTHkJAQxMTEAACCg4Ph7++P27dvD2m/o65gLikpwe9+9zuEhoZCoVAY/FP0+++/j4iICHh4eCAuLg6lpaV669vb2xEXF4eFCxeiuLh4hCJ3HNbm+MqVK/D29kZaWhpiY2Oxbdu2EYze/g3HGO536NAhrF69WuaIHY+1OQ4KCsIrr7yCyZMnIzQ0FCkpKXjooYdG8Azsm7X5feSRR1BUVITW1la0trbim2++QUNDwwiegX0azveG+928eRMTJ06UlidNmjRq8y1XjklnJPL73XffQavVIiwsbEjbjbqCubOzE7Nnz8aePXsMrs/Pz8dLL72E1157DefPn0dCQgKWLl2K+vp6qc+1a9dQWVmJDz74ABkZGWhvbx+p8B2CtTnu6elBaWkp3nvvPZw9exaFhYUoLCwcyVOwa8MxhgHdF78zZ85g2bJlIxG2Q7E2xy0tLSgoKMC1a9fQ0NCAsrIylJSUjOQp2DVr89s/L/yJJ57AypUrER8fz79CYfjeGx5kaOamQqEYlpgdjVw5Jh258/vLL78gIyMD2dnZQw9OjGIAxJEjR/Ta5s6dK1588UW9tunTp4utW7ca3EdqaqqoqKiQK0SHZ0mOy8rKxJIlS6R1O3bsEDt27JA9VkdkzRg+cOCAWLNmjdwhOjxLcnzo0CHxhz/8QVq3Y8cOsX37dtljdUTD8T6clZUlCgoK5ArRIVmT16KiIvH0009Ly2fOnBHp6enS8ubNm8XHH388/EE7mOHM8WDto9Fw57erq0skJCSIAwcOWBTPqLvCbMq9e/dQWVmJxYsX67UvXrxYurmkpaUF3d3dAIAbN27ghx9+QGRk5IjH6qjMyXF8fDyam5vR0tICrVaLkpISzJgxwxbhOhxz8tuP0zEsY06Ow8LCUFZWhq6uLvT19eHUqVOIioqyRbgOx9wxrNFoAOie+lJeXo4lS5aMaJyOZijvDQ+aO3cuvv/+ezQ0NODOnTs4fvw4822ANTmmwVmTXyEE1q1bhyeeeAJr16616Pj8G9Z9bt26hb6+PowfP16vffz48WhqagKgu9nk97//PVxcXKBQKPD222/zTuEhMCfHrq6u2LZtGxITEyGEwOLFi7F8+XJbhOtwzMkvALS1taG8vByHDx8e6RAdnjk5fuyxx7Bs2TLMmTMHLi4uSE5ORlpami3CdTjmjuH09HS0trbCy8sLubm5nJIxCHPzumTJEpw7dw6dnZ2YNGkSjhw5gvj4eOzatQtJSUnQarXYsmULAgICRvoU7J61OTbWTjrW5Le7uxv5+fmYNWuWNC/64MGDmDlzptnH5zuMAQ/OzRJCSG0LFizApUuXbBGWUzGVYwBYunQpli5dOtJhOY3B8uvr64vm5uaRDsupDJbjN998E2+++eZIh+U0Bssvr9hZZrC8Gnv6RVpaGr/0mcnSHPPJI+axNL9ardaq43JKxn0CAwOhVCr1vqkAuj/9PfiNhizDHMuL+ZUfcywv5lcezKv8mGN52Tq/LJjvM2bMGMTFxQ14IkNhYSEWLFhgo6icC3MsL+ZXfsyxvJhfeTCv8mOO5WXr/I66KRkdHR24evWqtFxXV4cLFy7A398fkydPxl//+lesXbsWjz76KObPn4/s7GzU19fjxRdftGHUjoU5lhfzKz/mWF7MrzyYV/kxx/Ky6/xa9GwNB1ZUVCQADHhlZmZKfd577z0xZcoUMWbMGBEbGyuKi4ttF7ADYo7lxfzKjzmWF/MrD+ZVfsyxvOw5vwohDDyRnIiIiIiIAHAOMxERERGRSSyYiYiIiIhMYMFMRERERGQCC2YiIiIiIhNYMBMRERERmcCCmYiIiIjIBBbMREREREQmsGAmIiIiIjKBBTMRERERkQksmIloVFIoFDh69KitwyAzrF27Ftu2bRv2/cbHx+Pzzz8f9v0SkfNhwUxETmfdunVQKBQDXqmpqbId09YF+KlTpwyes0KhQFNTk83istbFixdx7Ngx/OlPfzKr/+HDh6FUKlFfX29w/fTp07F582YAwN///nds3boVWq122OIlIufEgpmInFJqaioaGxv1Xv/5z39sGlNPT4/sx6iurh5w3sHBwbIdr6+vT9aCc8+ePVi1ahVUKpVZ/dPS0hAQEID9+/cPWHfmzBlUV1cjKysLAPDkk0+ira0NJ0+eHNaYicj5sGAmIqfk7u6OCRMm6L3GjRtntH9DQwNWr16NcePGISAgACtWrMC1a9f0+uTk5CA6Ohru7u4ICQnBH//4RwBAeHg4AGDlypVQKBTS8j/+8Q/ExMQgJycHkZGRcHd3hxAC9fX1WLFiBby9veHj44Nnn30Wzc3N0nH6tzt48CDCw8Ph6+uL5557Dnfu3Bn0vIODgwect4uL7q1+3bp1SE9Px86dOxESEoKAgABs2rRJr5C/d+8etmzZgokTJ8LLywvz5s3DqVOnpPV5eXnw8/NDQUEB1Go13N3d8dNPP6GxsRFPPvkkPD09ERERgU8++QTh4eHYvXs3AGD9+vVYvny5Xqy9vb2YMGECcnJyDJ6LVqvFZ599hrS0NL12UzG6ublh7dq1yMvLgxBiwP9fXFwcZs+eDQBQKpVYtmyZzb9IEZH9Y8FMRKPe3bt3kZSUBG9vb5SUlOD06dPw9vZGamoq7t27BwDYu3cvNm3ahI0bN+LSpUv44osv8PDDDwMAKioqAAC5ublobGyUlgHg6tWrOHToEA4fPowLFy4AANLT03H79m0UFxejsLAQNTU1WL16tV5MNTU1OHr0KAoKClBQUIDi4mL8+9//tvpci4qKUFNTg6KiIuzfvx95eXnIy8uT1j///PM4c+YMPv30U1y8eBGrVq1Camoqrly5opevf/3rX9i3bx8uX76M4OBgZGRk4ObNmzh16hQOHz6M7OxsaDQaaZsNGzbgxIkTaGxslNqOHz+Ojo4OPPvsswZjvXjxIlpbW/Hoo4/qtQ8WY1ZWFmpra1FcXCxt09nZiUOHDklXl/vNnTsXpaWlQ08kEY0ugojIyWRmZgqlUim8vLz0Xm+88YbUB4A4cuSIEEKIDz/8UERFRQmtViut7+7uFp6enuLkyZNCCCFCQ0PFa6+9ZvSY9++v3+uvvy7c3NyERqOR2r788kuhVCpFfX291Hb58mUBQJSXl0vbjR07VrS3t0t9Xn31VTFv3jyjxy8qKhIABpzztGnT9PIyZcoU0dvbK7WtWrVKrF69WgghxNWrV4VCoRANDQ16+05OThZ/+9vfhBBC5ObmCgDiwoUL0vqqqioBQFRUVEhtV65cEQDEW2+9JbWp1Wqxfft2aTk9PV2sW7fO6DkdOXJEKJVKvf8Xc2IUQoh58+aJjIwMaTknJ0d4enqKlpYWve3+97//CRcXF9HX12c0DiIiVxvW6kREsklKSsLevXv12vz9/Q32raysxNWrVwfMk+3q6kJNTQ00Gg1u3ryJ5OTkIccxZcoUBAUFSctVVVUICwtDWFiY1KZWq+Hn54eqqirEx8cD0E3zuD+ekJAQvSu2xpSWlupt5+qq/zYfHR0NpVKpt99Lly4BAM6dOwchBKZNm6a3TXd3NwICAqTlMWPGYNasWdJydXU1XF1dERsbK7U9/PDDA6bAbNiwAdnZ2diyZQs0Gg2OHTuGr7/+2ui5/Prrr3B3d4dCoZDazI0xKysLL730Evbs2QOVSoWcnBw89dRT8PPz09vO09MTWq0W3d3d8PT0NBoLEY1uLJiJyCl5eXlJUyYGo9VqERcXh48//njAuqCgIGkOsKVx3E8IoVcAGmt3c3PTW69QKMy6uS4iImJAUXg/U/vVarVQKpWorKzUK6oBwNvbW/q3p6enXqzigbnCxtozMjKwdetWnD17FmfPnkV4eDgSEhKMxhoYGIi7d+/i3r17GDNmzJBifO655/CXv/wF+fn5WLRoEU6fPo033nhjwDFu376NsWPHslgmIpNYMBPRqBcbG4v8/HwEBwfDx8fHYJ/w8HB8/fXXSEpKMrjezc0NfX19gx5LrVajvr4e169fl64y//DDD2hra8OMGTMsP4lhMGfOHPT19UGj0ZgsZB80ffp09Pb24vz584iLiwOgm7vd2tqq1y8gIADp6enIzc3F2bNn8fzzz5vcb0xMDABdfvr/bW6MKpUKq1atQm5uLmpraxEZGYlFixYN6Pf999/rXRknIjKEN/0RkVPq7u5GU1OT3uvWrVsG+65ZswaBgYFYsWIFSktLUVdXh+LiYvz5z3/GjRs3AOieXLFr1y688847uHLlCs6dO4d3331X2kd/Qd3U1ISWlhajcaWkpGDWrFlYs2YNzp07h/LycmRkZODxxx8fcHObJTQazYDzNvdxdtOmTcOaNWuQkZGBzz//HHV1daioqMD27dtx/Phxo9tNnz4dKSkp2LhxI8rLy3H+/Hls3LhxwJVoQDctY//+/aiqqkJmZqbJeIKCghAbG4vTp09bFGNWVhbKysqwd+9erF+/3uCV/dLSUixevNic9BDRKMaCmYic0okTJxASEqL3WrhwocG+Y8eORUlJCSZPnoynnnoKM2bMwPr16/Hrr79KV5wzMzOxe/duvP/++4iOjsby5cv1nhyxa9cuFBYWIiwsDHPmzDEaV/8PnIwbNw6JiYlISUlBZGQk8vPzh+W8o6KiBpx3ZWWl2dvn5uYiIyMDL7/8MqKiopCWloZvv/1Wb861IQcOHMD48eORmJiIlStX4oUXXoBKpYKHh4dev5SUFISEhGDJkiUIDQ0dNJ6NGzcOmCpjbowLFy5EVFQU2tvbDRbnDQ0NKCsrG/RKNxGRQhibfEZERGShGzduICwsDF999ZXezZJ3795FaGiodBPeYLq6uhAVFYVPP/0U8+fPH9YYX331VbS1tSE7O3tY90tEzodzmImIyGrffPMNOjo6MHPmTDQ2NmLLli0IDw9HYmIiAN3Nek1NTdi1axd8fX0H/BiJMR4eHjhw4IDR6TTWCA4OxiuvvDLs+yUi58MrzEREZLWTJ0/i5ZdfRm1tLVQqFRYsWIDdu3djypQpAIBr164hIiICkyZNQl5enkWP6CMishUWzEREREREJvCmPyIiIiIiE1gwExERERGZwIKZiIiIiMgEFsxERERERCawYCYiIiIiMoEFMxERERGRCSyYiYiIiIhMYMFMRERERGTC/wN/uUUshouGiQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#Total number of electrons vs Lorentz factor \n", "plt.figure(figsize=(8,5))\n", - "plt.semilogx(jet.x, jet.N_e_x, color = 'red')\n", - "plt.xlabel(\"Distance along Jet axis\")\n", - "plt.ylabel(\"Number of electrons N_e at x)\")\n", - "plt.title(\"Electron Distribution vs Lorentz Factor\")\n", - "plt.grid(True, which='both', ls='--')\n", - "#plt.xlim(10,1e4)\n", - "#plt.ylim(130,1e40)\n", - "plt.tight_layout()\n", + "#for i, _n_e_g in enumerate(jet.N_e_xg[::20]):\n", + " #plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*3*1e10*_n_e_g, label=f\"x={i}\",linestyle='dashed')\n", + "plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*(c.cgs.value)* jet.N_e_xg[0,:] , label=\"x = 0 \",linestyle='-',color='red')\n", + "plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*(c.cgs.value)*jet.N_e_xg[349,:] , label=\"x = intermediate \",linestyle='-',color='skyblue')\n", + "plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*(c.cgs.value)* jet.N_e_xg[-1,:] , label=\"x = L \",linestyle='-',color='brown')\n", + "plt.loglog(x_data, y_data, label=f\"C&P \",linestyle='dashed',color='pink')\n", + "#plt.plot((mec2*jet.gamma_e).to('eV'), jet.norm_equi*3*1e10*jet.N_e_base)\n", + "plt.xlabel('Electron Energy (eV)')\n", + "plt.ylabel('Electron Energy Distribution')\n", "plt.legend()\n", + "plt.xlim(1e5,1e12)\n", + "plt.ylim(1e30,1e50)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, - "id": "c6406943", + "execution_count": 95, + "id": "c2ae9201", "metadata": {}, "outputs": [], "source": [ - "#Total number of electrons vs Lorentz factor \n", + "n0 = jet.norm_equi * jet.N_e_base[None,:] # (1, N_gamma)\n", + "int_B = cumulative_trapezoid((jet.B_x)**2, jet.x, initial=0) # (N_x, 1)\n", + "cooling = ( sigma_T.cgs * jet.gamma_e[None,:] *(int_B[:,None])) / ( 6 * np.pi * mec2.cgs )" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "a48e552e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ "plt.figure(figsize=(8,5))\n", - "plt.loglog(jet.gamma_e, jet.N_e_gamma, color = 'red')\n", - "plt.xlabel(\"Electron Lorentz factor γ\")\n", - "plt.ylabel(\"Number of electrons N_e(γ)\")\n", - "plt.title(\"Electron Distribution vs Lorentz Factor\")\n", + "# Select every 70th gamma column, then transpose so we can iterate over columns\n", + "for i, cooling_gamma in enumerate(np.exp(-cooling.value[:, ::50].T)):\n", + " plt.loglog(jet.x, cooling_gamma, label=f'gamma = {jet.gamma_e[50*i]}',linestyle='dashed')\n", + "plt.xlabel(\"Distance along Jet axis\")\n", + "plt.ylabel(\"Cooling Factor\")\n", + "plt.title(\"Cooling vs Distance\")\n", "plt.grid(True, which='both', ls='--')\n", - "#plt.xlim(10,1e4)\n", + "plt.ylim(1e-3, 10)\n", "plt.tight_layout()\n", "plt.legend()\n", "plt.show()" @@ -218,22 +280,34 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "2c43cb8c", + "execution_count": 133, + "id": "5fed4dc4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAHpCAYAAAD00hFBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC1a0lEQVR4nOzdeXwU5f0H8M/skWRz3yGBJIQrgBACqJgISETQBBFQW1tbRQUraiuHtlVbD6xKvZB6gP5KFY9WrQfWI0qiclgJlxApV+ROgITc9ybZ3ZnfH2HXbC6yyT6zRz7v1ysvyLO7M9/nM5Nkn52ZZyRFURQQERERERH1ksbVBRARERERkWfjoIKIiIiIiPqEgwoiIiIiIuoTDiqIiIiIiKhPOKggIiIiIqI+4aCCiIiIiIj6hIMKIiIiIiLqEw4qiIiIiIioTzioICIiIiKiPuGggvq9devWQZKkLr82bdpke+7gwYNxyy23CKtl9erVWLdunbDli9A+k02bNnXIrSd60/fO1nXLLbcgMDDQoeWcz9atW/Hoo4+iurq6w2PTpk3DtGnTnLq+ntqzZw8uu+wyhISEQJIkrFq1SvUaTpw4AUmS7Lbdo48+CkmS7J7X0tKCRYsWITY2FlqtFqmpqQCAyspK/OIXv0B0dDQkScLcuXPVK95B2dnZePTRRx1+3WeffYY5c+YgLi4OPj4+CAoKwvjx4/HII4+gsLDQ+YW6mWnTpgn9veks1t8n1i8fHx9ERUXh0ksvxZ/+9CecPHmyw2usfz9OnDjh0LqefPJJfPzxx84pnMhN6FxdAJG7eP311zFy5MgO7aNHj1athtWrVyMyMtIj/gB3ZcKECcjLy3M4t970vbfrctTWrVuxfPly3HLLLQgNDbV7bPXq1ULX3Z3bbrsNDQ0NePfddxEWFobBgwe7rJa2Fi5ciKuuusqubc2aNXj11Vfx4osvYuLEibaB31/+8hesX78er732GoYOHYrw8HBXlNwj2dnZePnll3s8sJBlGbfeeivefPNNZGZmYsWKFRg8eDCMRiN27tyJ119/Ha+99hqKiorEFk4OefLJJ5GRkQGLxYKKigps374dr732Gp5//nn8/e9/x69+9Svbc2fNmoW8vDzExsY6vI7rr7/erQfRRI7ioILonDFjxuDCCy90dRk9ZjKZIEkSdDr3+jEODg7GJZdcInQd1r6rsa7zUXPQ2d6+fftw++23IzMz0ynLc9Y+NWjQIAwaNMiubd++fTAYDPjtb3/boX3o0KF2b9T6ymg0wmAwOG15vfXUU0/hzTffxIoVK3D//ffbPXbVVVfhgQcewKuvvuqi6qgrw4cPt/u9cs011+Dee+/FFVdcgVtuuQUpKSkYO3YsACAqKgpRUVGuKpXIrfD0J6I+qq2txX333YekpCT4+Phg4MCBWLJkCRoaGuyeJ8syXnzxRaSmpsJgMCA0NBSXXHIJPvnkEwCtpxHt378fmzdvth1+t37ybD0s/9Zbb+Hee+/FwIED4evriyNHjgAAXnvtNYwbNw5+fn4IDw/HvHnzcPDgQbv1W08LOnLkCLKyshAYGIj4+Hjce++9aG5uPm8/TSYT/vCHP2DAgAHw9/fH5MmTsWPHjg7P6+yUpGPHjuEXv/gF4uLi4Ovri5iYGEyfPh35+fl96nt3p1rt378f06dPR0BAAKKiovDb3/4WjY2Ntsc7O23HSpIk26fRjz76KH7/+98DAJKSkjqcFtfZ6U+VlZW46667MHDgQPj4+GDIkCH405/+1CFnSZLw29/+Fm+99RZGjRoFf39/jBs3Dp999lnXGwI/nXJhNpuxZs0aW01W+/btw5w5cxAWFgY/Pz+kpqbijTfesFvG+fapzpw5cwY///nPERQUhJCQENxwww0oKSnp8Lz2pz9JkoS1a9fCaDTaarX24auvvsLBgwc75NrS0oLHH38cI0eOhK+vL6KionDrrbeirKzMbl2DBw/G1VdfjY8++gjjx4+Hn58fli9fDgAoKSnBHXfcgUGDBsHHxwdJSUlYvnw5zGaz7fXW/eDZZ5/FypUrkZSUhMDAQKSlpWHbtm22591yyy14+eWXbf2xfnV12ktLSwuefvppjBkzpsOAwkqn0+Huu++2a3vvvfcwc+ZMxMbGwmAwYNSoUbj//vs7/D6x/jwfOnQIV155JQICAhAbG4u//vWvAIBt27Zh8uTJCAgIwIgRIzpsf2v+33zzDW6//XZEREQgODgYN998MxoaGlBSUoKf//znCA0NRWxsLO677z6YTCa7ZSxfvhyTJk1CeHg4goODMWHCBPzjH/+Aoiid9tdKlmU8/vjjSE5Otv0uTElJwd/+9rcuX1NWVgYfHx889NBDHR47dOgQJEnCCy+8AABobGy0/U62/k688MIL8c4773RbV3fCw8Px6quvwmw24/nnn7e1d3b60549e3D11VcjOjoavr6+iIuLw6xZs3Dq1CkArftPQ0MD3njjDdt+ZP0dUlZWhrvuugujR49GYGAgoqOjcfnll+Pbb7+1q6en+63V9u3bMXv2bERERMDPzw9Dhw7FkiVL7J5z+PBh3Hjjjba6R40aZdvniXrCvT7iJHIhi8Vi92YDaP3lr9Vqu3xNY2MjLrvsMpw6dQoPPvggUlJSsH//fjz88MP43//+h6+++sr25uqWW27B22+/jQULFuCxxx6Dj48Pdu/ebftjtH79elx//fUICQmxnVLj6+trt74HHngAaWlpeOWVV6DRaBAdHY0VK1bgwQcfxC9/+UusWLECFRUVePTRR5GWloadO3di+PDhttebTCZcc801WLBgAe69915s2bIFf/nLXxASEoKHH36423xuv/12vPnmm7jvvvswY8YM7Nu3D9deey3q6urOm21WVhYsFguefvppJCQkoLy8HFu3brVdo9Dbvnf2htbaz6ysLNxxxx24//77sXXrVjz++OM4efIkPv300/PW29bChQtRWVmJF198ER999JHtNIeujlA0NTUhIyMDR48exfLly5GSkoJvv/0WK1asQH5+Pj7//HO753/++efYuXMnHnvsMQQGBuLpp5/GvHnzUFBQgCFDhnS6DuspF2lpabj++utx77332h4rKChAeno6oqOj8cILLyAiIgJvv/02brnlFpw9exZ/+MMf7JbVWa6dMRqNuOKKK3DmzBmsWLECI0aMwOeff44bbrjhvBnm5eXhL3/5CzZu3IhvvvkGQOsALS8vD3fddRdqamrwz3/+05arLMuYM2cOvv32W/zhD39Aeno6Tp48iUceeQTTpk3Drl277I5E7N69GwcPHsSf//xnJCUlISAgACUlJbj44ouh0Wjw8MMPY+jQocjLy8Pjjz+OEydO4PXXX7er8eWXX8bIkSNt16U89NBDyMrKwvHjxxESEoKHHnoIDQ0N+OCDD5CXl2d7XVenvezatQvV1dW48847z5tPW4cPH0ZWVhaWLFmCgIAAHDp0CE899RR27Nhhy87KZDLh2muvxaJFi/D73/8e//rXv/DAAw+gtrYWH374If74xz9i0KBBePHFF3HLLbdgzJgxmDhxot0yFi5ciGuvvRbvvvsu9uzZgwcffBBmsxkFBQW49tpr8Zvf/AZfffUVnnrqKcTFxWHZsmW21544cQJ33HEHEhISALQOZH73u9/h9OnTdr9P2g/6n376aTz66KP485//jKlTp8JkMuHQoUOdXrNkFRUVhauvvhpvvPEGli9fDo3mp89EX3/9dfj4+NiOdi1btgxvvfUWHn/8cYwfPx4NDQ3Yt28fKioqHNoW7V100UWIjY3Fli1bunxOQ0MDZsyYgaSkJLz88suIiYlBSUkJNm7caPtdmZeXh8svvxwZGRm2QVJwcDCA1g8kAOCRRx7BgAEDUF9fj/Xr12PatGn4+uuvO3yAcb79FgA2bNiA2bNnY9SoUVi5ciUSEhJw4sQJ5OTk2JZz4MABpKenIyEhAc899xwGDBiADRs24J577kF5eTkeeeSRPmVH/YRC1M+9/vrrCoBOv7Rard1zExMTlfnz59u+X7FihaLRaJSdO3faPe+DDz5QACjZ2dmKoijKli1bFADKn/70p25rueCCC5TLLrusQ/vGjRsVAMrUqVPt2quqqhSDwaBkZWXZtRcWFiq+vr7KjTfeaGubP3++AkD597//bffcrKwsJTk5udu6Dh48qABQli5datf+z3/+UwFgl4m11o0bNyqKoijl5eUKAGXVqlXdrsPRvne2rrb9/Nvf/mb33CeeeEIBoPz3v/9VFEVRjh8/rgBQXn/99Q7LBaA88sgjtu+feeYZBYBy/PjxDs+97LLL7Op+5ZVXOs35qaeeUgAoOTk5duuJiYlRamtrbW0lJSWKRqNRVqxY0WFdndV5991327X94he/UHx9fZXCwkK79szMTMXf31+prq5WFKX7XDuzZs0aBYDyn//8x6799ttv75DjI488orT/8zJ//nwlICCgw3Ivu+wy5YILLrBre+eddxQAyocffmjXvnPnTgWAsnr1altbYmKiotVqlYKCArvn3nHHHUpgYKBy8uRJu/Znn31WAaDs379fUZSf9oOxY8cqZrPZ9rwdO3YoAJR33nnH1nb33Xd36FdX3n33XQWA8sorr3R4zGQy2X11RZZlxWQyKZs3b1YAKD/88IPtMet+3jYjk8mkREVFKQCU3bt329orKioUrVarLFu2zNZm/b33u9/9zm6dc+fOVQAoK1eutGtPTU1VJkyY0GWtFotFMZlMymOPPaZEREQosix3+dyrr75aSU1N7fLxrnzyyScdfobMZrMSFxenXHfddba2MWPGKHPnznV4+dafiffff7/L50yaNEkxGAy27605Wn837Nq1SwGgfPzxx92uKyAgwO73ZlfMZrNiMpmU6dOnK/PmzbO1O7LfDh06VBk6dKhiNBq7XM+VV16pDBo0SKmpqbFr/+1vf6v4+fkplZWV562ViKc/EZ3z5ptvYufOnXZf27dv7/Y1n332GcaMGYPU1FSYzWbb15VXXml3KscXX3wBAB1OdXDUddddZ/d9Xl4ejEZjh4ub4+Pjcfnll+Prr7+2a5ckCbNnz7ZrS0lJ6XRWk7Y2btwIAB3Oe//5z39+3vPvw8PDMXToUDzzzDNYuXIl9uzZA1mWu31NZ9r3/Xza13rjjTcC+KkvonzzzTcICAjA9ddfb9du3Ubtt0lGRgaCgoJs38fExCA6Ovq826S79U+fPh3x8fEd1t/Y2Gj3KTvQ81w3btyIoKAgXHPNNXbt1lyd6bPPPkNoaChmz55t93OVmpqKAQMGdPjkOyUlBSNGjOiwjIyMDMTFxdktw3r9yebNm+2eP2vWLLujkikpKQDQ6+3Qlerqauj1eruvXbt22R4/duwYbrzxRgwYMABarRZ6vR6XXXYZAHQ4pVGSJGRlZdm+1+l0GDZsGGJjYzF+/Hhbe3h4eJf71NVXX233/ahRowC05tG+vf3rv/nmG1xxxRUICQmx1frwww+joqICpaWlXWZw8cUX44cffsBdd92FDRs2oLa2tsvntpWZmYkBAwbYHWXasGEDzpw5g9tuu81u+V988QXuv/9+bNq0CUajsUfL7wnlPKd2DRs2DGFhYfjjH/+IV155BQcOHHB4Ha+88gomTJgAPz8/6HQ66PV6fP311x22P3D+/fbHH3/E0aNHsWDBAvj5+XW6vqamJnz99deYN28e/P397X5esrKy0NTU1OkpVUTtcVBBdM6oUaNw4YUX2n21P1WgvbNnz2Lv3r0d3iQEBQVBURSUl5cDaD1PVqvVYsCAAX2qsf2pFtbD+Z2dghEXF9fhcL+/v3+HPyy+vr5oamrqdr3W5bSvX6fTISIiotvXSpKEr7/+GldeeSWefvppTJgwAVFRUbjnnnt6dOqUlSOzq3RWl7X2vp4CcT4VFRUYMGBAhylVo6OjodPpOqy/s/x8fX17/UaooqKiy/3B+nhbPc21oqICMTExHdr7uk935uzZs6iuroaPj0+Hn62SkhLbz5VVZ304e/YsPv300w6vv+CCCwCgwzLabwfr6Xe93Q7WU4LavxEPCgqyfWjR/pSS+vp6TJkyBdu3b8fjjz+OTZs2YefOnfjoo486raWzn2cfH59OZ9Dy8fHp9Oe8/XN9fHy6bG/7+h07dmDmzJkAgL///e/47rvvsHPnTvzpT3/qtNa2HnjgATz77LPYtm0bMjMzERERgenTp9sNrjqj0+lw0003Yf369bZTpdatW4fY2FhceeWVtue98MIL+OMf/4iPP/4YGRkZCA8Px9y5c3H48OFul98ThYWFtp+lzoSEhGDz5s1ITU3Fgw8+iAsuuABxcXF45JFHOlyT0pmVK1fizjvvxKRJk/Dhhx9i27Zt2LlzJ6666qpOMz3ffmu9Bqn9xAltVVRUwGw248UXX+zw82IdtLb/eSHqDK+pIOqDyMhIGAwGvPbaa10+DrSeD2yxWFBSUuLw1INttX+jav2DUlxc3OG5Z86csa2/r6zrKSkpwcCBA23tZrO5R2/SExMT8Y9//ANA6ydn//73v/Hoo4+ipaUFr7zySo9qaN/37ljravsH13r9hbXN+mas/cXTfR10REREYPv27VAUxa7m0tJSmM1mp22T7tbf1f4AoMP6e5prREREpxfmd3VdS19ERkYiIiICX375ZaePtz2yA3Teh8jISKSkpOCJJ57odBndvTF0hokTJyIsLAyffvopnnzySVu7Vqu1zTK3b98+u9d88803OHPmDDZt2mQ7OgGg22sNXOXdd9+FXq/HZ599Zjew6cm9F3Q6HZYtW4Zly5ahuroaX331FR588EFceeWVKCoqgr+/f5evvfXWW/HMM8/g3XffxQ033IBPPvkES5Yssfu0PiAgAMuXL8fy5ctx9uxZ21GL2bNn49ChQ73u844dO1BSUoIFCxZ0+7yxY8fi3XffhaIo2Lt3L9atW4fHHnsMBoOhy4v2rd5++21MmzYNa9assWt35AOYtqwzU1kvEu9MWFgYtFotbrrppi6PpiclJfVq/dS/8EgFUR9cffXVOHr0KCIiIjoc5bjwwgttMxhZT7lo/4eiPUc/oU5LS4PBYMDbb79t137q1CnbaTDOYL040HoxrdW///3vDhe3n8+IESPw5z//GWPHjsXu3btt7X35dL4z7Wv917/+BeCnvsTExMDPzw979+61e95//vOfDsty5FPr6dOno76+vsObqzfffNP2uEjTp0+3vTltv35/f/9eT8GbkZGBuro622xlVtZcnenqq69GRUUFLBZLpz9XycnJPVqGdbrazpbRm0GFI/uBj48Pfv/732Pfvn146qmnerR86+Co/SQF7jjtrHXq4bZv5o1GI9566y2HlhMaGorrr78ed999NyorK897E7lRo0Zh0qRJeP311/Gvf/0Lzc3NuPXWW7t8fkxMDG655Rb88pe/REFBgd0McI6orKzEokWLoNfrsXTp0h69RpIkjBs3Ds8//zxCQ0N79PtOkqQO23/v3r0dTlvsqREjRmDo0KF47bXXupzlz9/fHxkZGdizZw9SUlI6/Xk53xFpIoBHKohs9u3b1+kb5KFDh3Y5D/mSJUvw4YcfYurUqVi6dClSUlIgyzIKCwuRk5ODe++9F5MmTcKUKVNw00034fHHH8fZs2dx9dVXw9fXF3v27IG/vz9+97vfAfjpE6733nsPQ4YMgZ+fn20+9M6EhobioYcewoMPPoibb74Zv/zlL1FRUYHly5fDz8/PaTN2jBo1Cr/+9a+xatUq6PV6XHHFFdi3bx+effZZ26wlXdm7dy9++9vf4mc/+xmGDx8OHx8ffPPNN9i7d6/dp3aO9r07Pj4+eO6551BfX4+LLrrINvtTZmYmJk+eDKD1j/evf/1r203Xxo0bhx07dnT6Jtlax9/+9jfMnz8fer0eycnJHT4xB4Cbb74ZL7/8MubPn48TJ05g7Nix+O9//4snn3wSWVlZuOKKK3rVp5565JFHbNcTPPzwwwgPD8c///lPfP7553j66adtM8I46uabb8bzzz+Pm2++GU888QSGDx+O7OxsbNiwwck9AH7xi1/gn//8J7KysrB48WJcfPHF0Ov1OHXqFDZu3Ig5c+Zg3rx53S7jscceQ25uLtLT03HPPfcgOTkZTU1NOHHiBLKzs/HKK690e0pIZ6z7wVNPPYXMzExotVqkpKTYThlq749//CMOHTqE+++/H1u2bMENN9yAwYMHo7m5GceOHcPatWuh1Wptn8ynp6cjLCwMixYtwiOPPAK9Xo9//vOf+OGHHxyqUw2zZs3CypUrceONN+I3v/kNKioq8Oyzz3Z4Q9yZ2bNn2+4LFBUVhZMnT2LVqlVITEy0m62uK7fddhvuuOMOnDlzBunp6R0GmZMmTcLVV1+NlJQUhIWF4eDBg3jrrbeQlpbW7VEQq8OHD2Pbtm2QZdl287t//OMfqK2txZtvvmk7ha4zn332GVavXo25c+diyJAhUBQFH330EaqrqzFjxgzb88aOHYtNmzbh008/RWxsLIKCgpCcnIyrr74af/nLX/DII4/gsssuQ0FBAR577DEkJSU5/AGO1csvv4zZs2fjkksuwdKlS5GQkIDCwkJs2LDB9uHL3/72N0yePBlTpkzBnXfeicGDB6Ourg5HjhzBp59+2mHmMaJOufQycSI30N3sTwCUv//977bntp/9SVEUpb6+Xvnzn/+sJCcnKz4+PkpISIgyduxYZenSpUpJSYnteRaLRXn++eeVMWPG2J6XlpamfPrpp7bnnDhxQpk5c6YSFBSkAFASExMVRTn/rCRr165VUlJSbMudM2eObXYbq65m3+lspp7ONDc3K/fee68SHR2t+Pn5KZdccomSl5fXIZP2MzKdPXtWueWWW5SRI0cqAQEBSmBgoJKSkqI8//zzdrOW9KbvXc3+FBAQoOzdu1eZNm2aYjAYlPDwcOXOO+9U6uvr7V5fU1OjLFy4UImJiVECAgKU2bNnKydOnOgw+5OiKMoDDzygxMXFKRqNxm6d7Wd/UpTW2XYWLVqkxMbGKjqdTklMTFQeeOABpampye556GT2JkXpfD/rTFev/9///qfMnj1bCQkJUXx8fJRx48Z1mOWqJzPdtHfq1CnluuuuUwIDA5WgoCDluuuuU7Zu3er02Z8UpXUmo2effVYZN26c4ufnpwQGBiojR45U7rjjDuXw4cO25yUmJiqzZs3qtN6ysjLlnnvuUZKSkhS9Xq+Eh4crEydOVP70pz/Z9gXrLDrPPPNMh9e33w+am5uVhQsXKlFRUYokSV3OCNbeJ598osyePVuJiYlRdDqdEhQUpKSmpir33nuvcujQIbvnbt26VUlLS1P8/f2VqKgoZeHChcru3bs7ZOxonu1zsv7eaz9znXXblZWV2bV3tr7XXntNSU5OVnx9fZUhQ4YoK1asUP7xj3+cN5fnnntOSU9PVyIjIxUfHx8lISFBWbBggXLixIkuX9NWTU2NYjAYOvx+trr//vuVCy+8UAkLC7PVtnTpUqW8vLzb5Vp/JqxfOp1OiYiIUNLS0pQHH3yw0/raz/506NAh5Ze//KUydOhQxWAwKCEhIcrFF1+srFu3zu51+fn5yqWXXqr4+/srAGy/Q5qbm5X77rtPGThwoOLn56dMmDBB+fjjj5X58+fbficqimP7raIoSl5enpKZmamEhIQovr6+ytChQzvM5nf8+HHltttuUwYOHKjo9XolKipKSU9PVx5//PFucyOykhTlPFMZEBERERERdYPXVBARERERUZ9wUEFERERERH3CQQUREREREfUJBxVERERERNQnHFQQEREREVGf8D4VvSTLMs6cOYOgoCCH7vRLRERERKQ2RVFQV1eHuLg4aDTOP67AQUUvnTlzBvHx8a4ug4iIiIiox4qKihy++WdPcFDRS9Y76RYVFZ33jsLewmQyIScnBzNnzoRer3d1OV6JGYvHjMVjxupgzuIxY/GYsXjWjNPS0pCUlGR7D+tsvPldL9XW1iIkJAQ1NTX9ZlChKArMZjN0Oh1P+RKEGYvHjMVjxupgzuIxY/GYsXjWjBsbGxEaGirsvSsv1CaHGI1GV5fg9ZixeMxYPGasDuYsHjMWjxmLp0bGHFRQj5nNZmzcuBFms9nVpXgtZiweMxaPGauDOYvHjMVjxuKplTEHFURERERE1CccVBARERERUZ9wUEEO0ek4YZhozFg8ZiweM1YHcxaPGYvHjMVTI2PO/tRL/XH2JyIiIiLyTKLfu/JIBfWYLMsoLS2FLMuuLsVrMWPxmLF4zFgdzFk8ZiweMxZPrYw5qKAes1gsyMvLg8VicXUpXosZi8eMxWPG6mDO4jFj8ZixeGplzEEFERERERH1CQcVRERERETUJxxUUI9JkoSgoCBIkuTqUrwWMxaPGYvHjNXBnMVjxuIxY/HUypizP/USZ38iIiIiIk/B2Z/IbciyjJMnT3KGBoGYsXjMWDxmrA7mLB4zFo8Zi6dWxhxUUI9ZLBbk5+dzhgaBmLF4zFg8ZqwO5iweMxaPGYunVsYcVBARERERUZ9wUEFERERERH3CQQX1mCRJiIqK4gwNAjFj8ZixeMxYHcxZPGYsHjMWT62MOftTL3H2JyIiIiLyFJz9idyGxWLBoUOHeDGVQMxYPGYsHjNWB3MWjxmLx4zFUytjDiqox2RZRkFBAad9E4gZi8eMxWPG6mDO4jFj8ZixeGplzEEFERERERH1CQcVRERERETUJxxUUI9pNBokJCRAo+FuIwozFo8Zi8eM1cGcxWPG4jFj8dTKmLM/9RJnfyIiIiIiT8HZn8htWCwW7NmzhzM0CMSMxWPG4jFjdTBn8ZixeMxYPLUy5qCCekyWZRQWFnKGBoGYsXjMWDxmrA7mLB4zFo8Zi6dWxhxUEBERERFRn3BQQUREREREfcJBBfWYRqNBcnIyZ2gQiBmLx4zFY8bqYM7iMWPxmLF4amXM2Z96ibM/EREREZGn4OxP5DbMZjO2bt0Ks9ns6lK8FjMWjxmLx4zVwZzFY8biMWPx1MqYgwrqMUVRUFZWBh7cEocZi8eMxWPG6mDO4jFj8ZixeGplzEEFERERERH1CQcVRERERETUJxxUUI9ptVqkpqZCq9W6uhSvxYzFY8biMWN1MGfxmLF4zFg8tTLm7E+9xNmfiIiIiMhTcPYnchtmsxnffPMNZ2gQiBmLx4zFY8bqYM7iMWPxmLF4amXs9YOKuro6XHTRRUhNTcXYsWPx97//3fbY8ePHkZGRgdGjR2Ps2LFoaGhwYaXuT1EU1NXVcYYGgZixeMxYPGasDuYsHjMWjxmLp1bGOqFLdwP+/v7YvHkz/P390djYiDFjxuDaa69FREQEbrnlFjz++OOYMmUKKisr4evr6+pyiYiIiIg8jtcPKrRaLfz9/QEATU1NsFgsUBQF+/fvh16vx5QpUwAA4eHhriyzxxRFgdFkccm6TSYzmi1AY4sZekVySQ3ejhmLx4zFY8bqYM7iMWPx+mvGBr0WkuRd/XX7C7W3bNmCZ555Bt9//z2Ki4uxfv16zJ071+45q1evxjPPPIPi4mJccMEFWLVqlW2wAADV1dW47LLLcPjwYTzzzDO4++678fHHH2PdunWQZRmnTp3C9ddfjwcffLDHdbnqQu3GFjNGP7xBtfURERERkXMdeOxK+Puo89m+LMsoLy+Hj48PwsLC+u+F2g0NDRg3bhxeeumlTh9/7733sGTJEvzpT3/Cnj17MGXKFGRmZqKwsND2nNDQUPzwww84fvw4/vWvf+Hs2bMwmUz49ttv8fLLLyMvLw+5ubnIzc3tso7m5mbU1tbafQGAyWSyfVksrUcQLBZLp+1ms9muXZblbtvbtplMJiiKwnMOiYiIiDxcT97v9bQdaB04tG2zXpQtyzIsFgvCwsJs70dFcfvTnzIzM5GZmdnl4ytXrsSCBQuwcOFCAMCqVauwYcMGrFmzBitWrLB7bkxMDFJSUrBlyxYMGjQIF110EeLj4wEAWVlZyM/Px4wZMzpdz4oVK7B8+fIO7Tk5ObbTqxISEjB+/Hjs3bvXblCTnJyMkSNHYseOHSgrK7O1p6amIjExEVu2bEFdXZ2tPS0tDdHR0cjJybG7Uj8jIwN+fn54+mL7q/evvHImjMYmbNmyxdam0+lw1VVXoqysDNu377C1BwUG4rJpl6GwsAh79+61tUdGRuKSSybhx4If8ePhw7b2+PhBGDduHH744QcUFZ2ytY8YPhwjkkdg27btKC8vt7WnpKQgISEemzdtRl19va190qSLERUVhS+/3GDXp6lTp8Jg8MOGDTnsU5s+BQYGYNq0aV7VJ3fbTpempyMwKNCr+uRO20mSJMycOQPff7/ba/rkbtsp/dJ05OZ+ZXtj4g19crftpNPp8M0333hVn9xtO+XlbUNFRYVX9akn22ljbg7S07t+v2cwGJCdnW3Xp6ysLBiNRmzcuNGuT7NmzUJ5eTny8vJ+6lNQEC6//HIUFRUhPz8fANDY2AiR3P70p7YkSbI7/amlpQX+/v54//33MW/ePNvzFi9ejPz8fGzevBlnz56FwWBAcHAwamtrkZaWhnfeeQejR4/GRRddhG+++QYhISGYM2cO7rjjDlx99dWdrru5uRnNzc2272traxEfH4/y8nLbISSNRgOtVguLxWL3S97abjab7Y40aLVaaDSaLtuto08rna51DNh+SrCu2vV6vW2E2jZDnU7XZXtXtVssFjQ3NyM3NxczZsyAr6+vV/TJ3baTyWRCbm4uZs6cCYPB4BV9al+7q/tkzTgzMxN6vd4r+nS+2tXukzXjrKwsSJLkFX1q2+4u20lRFGRnZ2PGjBnQ6/Ve0Sd3204mkwlffPGFXcae3qfOandln4xGI3JycmwZe0Of3G07NTU1ITc3F5MmTUJsbKyw05/c/khFd8rLy2GxWBATE2PXHhMTg5KSEgDAqVOnsGDBAtsho9/+9rdISUkBADz55JOYOnUqFEXBzJkzuxxQAICvr2+ns0Pp9XrbLxorrVbb6V0LrTtDT9vbL7c37RqNBhpNx7PcumrvqnatVmtbvvWHvrvaPaVP7rqdrOvypj6dr13tPkmSBEmSvKpPvWlnnzy3T9Y3Io78HXL3PnXX7oo+WS+k7SxjT+2To+1q9al9xt7Qp562i+5T2/dvInn0oMKq/dXziqLY2iZOnGg77NPe+U6tIiIiIiKi8/PoQUVkZCS0Wq3tqIRVaWlph6MX1Hc6nQ4ZGRldjrSp75ixeMxYPGasDuYsHjMWjxmLZ81Y9BUPbj/7U3d8fHwwceLEDrM25ebmIj093UVVeTeDweDqErweMxaPGYvHjNXBnMVjxuIxY/HUyNjtBxX19fXIz8+3ncJ0/Phx5Ofn22ZXWrZsGdauXYvXXnsNBw8exNKlS1FYWIhFixa5sGrvZDabkZ2d3eECIXIeZiweMxaPGauDOYvHjMVjxuKplbHbH2vatWsXMjIybN8vW7YMADB//nysW7cON9xwAyoqKvDYY4+huLgYY8aMQXZ2NhITE11Vsnh7/w2YjKqvVrJYkFD+P0h7KoBOLkyivmPG4kkWCxIq9kHKr2TGgrRm/D9mLJhrc/auOwF3pTXjvZDyq7gvC9IvM44eBQy60NVVOJ1HTSnrTlx1R20AwLMjgPqz6q6TiIiIiPrukruBq55UbXUmkwnZ2dmYPHkyIiMjOaUstTH0csBYrfpqZUXG2bOliImJhkZy+zPnPBIzFo8Zi9f3jPlZV0/IsozS0lJER0d3OpUk9R0zFq9fZhyV7OoKhOCRil5y6ZEKF1EUBWazGTqdrsM0vuQczFg8ZiweM1YHcxaPGYvHjMWzZtzY2IjQ0FBh7137yZCQnMVoVP9ajv6GGYvHjMVjxupgzuIxY/GYsXhqZMxBBfWY2WzGxo0bOUODQMxYPGYsHjNWB3MWjxmLx4zFUytjDiqIiIiIiKhPOKggIiIiIqI+4aCCHKLTccIw0ZixeMxYPGasDuYsHjMWjxmLp0bGnP2pl1w5+1NJQwlkRVZ1nY6Q3PimSJxZone4TXuP2XkfbtPecevc3Lg2wL23qztz19x8ND7w0/mpvl7R7105NPRAv/z8lyg3lru6DCIiIiJy0E2jb8IfLvqDauuTZRnl5eXw8fERuh4OKjyQr9YXflr1R7gAYLFYoNVqu3xcceObVrnzQbm2ucmy7FY3AHLnbdrb0mRFVuXGd+6cnejaFEXp9aeEnvKzSkTkCSwWC/Ly8jB58mSh6+GgwgN9ed2XLlmv9TbvWVlZ0Ov1LqnB2zFj8ZixeMxYHZ6Us6cOFN0hY0/NrqdMJhO++OILZGZmOjVjd/4AwN1Pt+stDiqIiIhIKHc9tx3o/g2eRtLYfbmE+0bnFIpGgVbSQqfRQafh21JP5j7nWJDbkyQJQUFBbv3HwdMxY/GYsXjMWB3MWTxmLB4zFk+tjDn7Uy+5cvYnIiIiIiJHiH7vyiMV1GOyLOPkyZOQZfedztbTMWPxmLF4zFgdzFk8ZiweMxZPrYw5qKAes1gsyM/Ph8VicXUpXosZi8eMxWPG6mDO4jFj8ZixeGplzEEFERERERH1Ca+p6CVXXlNx8qabYamuctLSen7RjqIoqKuvQ1Bgu4t9nHXhj9cux4HnKgpqamoREhLcYf1Om4LO7fJRdzmKIqO6ugahoSGQOpvNxQnl9PdtpSgKqqoqERYW3vmFga742ep2MZ6bc0VFBSIiIgTn7JQfCqdw3oWmPVuOrCgoLy9HZGQkNKIzlqTWsiSpdZ+0Ltv2WOvjrRlIPW5vXUQXj0lSJ4910t6uxm5r6GJ5XZEtMo4cOYJhw4ZBoxX/Wbc7XBBuGD8egVOmqLY+69TIkydPRmRkJO+oTT9pPnEcljLX3FHbF0ALzrpk3f2FH4DmM2dcXYZXMwBoLipydRlezQCg6cRJV5fh9fwBGI8dc3UZXi0AgPHwYVeX4dUiAFR9842ry1BN+Pz5qg4qJElCVFSU8AEVBxUeaNCqVVBMpr4vyJkHqZy0LKceOHPWopx6MM/9Mndm/5y2/dxxP3Dmwrz+Z89ZOTlnMa3LcsOfYzfMnL+DHVmU8/YDRVFaS1OUc8tV2j3W5nEonbd3eKxNnZ091ml753X0aF2257Q+ZtfuLtykFsPECaquT6fTIT09HbW1tWLXI3TpJIT/xIkuWa/FYsHhw4cxfPhwaLVal9Tg7ZixeMxYPGasDuYsHjMWjxmLZ804JiZG6Hp4oTb1mCzLKCgo4LRvAjFj8ZixeMxYHcxZPGYsHjMWT62MOaggIiIiIqI+4aCCiIiIiIj6hIMK6jGNRoOEhARoNNxtRGHG4jFj8ZixOpizeMxYPGYsnloZ8z4VveTK+1QQERERETlC9HtXzv7kgQq2FcNsUv+CJllRcPrUKQwcNMjuJkBOmffY9feiseOcqZwdX4gsyzh1qgiDBsXbPlFwSi3uda8x590wqhdkWUZRUSHi41s/tXGvfN1tQ/WOLMsoLCxEQkKCW83movJ9086ziL4vRJZlnDh5AoMHD3aLT3mdl2/fF+SsX+GKouDEyeMYOmwIdDodJI0EjUaCpAE0WqnN9138q5Wg1UrQ6jSQNG72h85NWCwW7N27FykpKW71+8KbWDMePHiw0PVwUOGBtn50FI21LS5b/1H86LJ19xdHUODqErzeYRxydQle70ccdHUJ/UIB9ru6BK93AHv7vAyNRoJGr4FOp4FWJ0Gr10Cr0/z0b4f/S5236yTo9FpodRI059p0HV6n7fb1aty5uqesH0KMGTOGgwpB2n7QIxIHFR4oYUwEmhuccPM7B8mygrNnSxATMwCac5+4uNXJc866+ZMLFyLLMsrKyhAVFQWNRuOkLrnXjcic06XeL0VWFJSXlSMyKtJ5RwacwHk/S05YUB8XISsKKisqEB4eIfwOrj3lVmf6OqkUWVZQVVWFsLCwPuTsrJvmOWUxTuG0WhQFFouM2ppaBAYEQVFaM1fOfcmW1hu8yZZz38sKFPmn57QnywrkZgvMzRYnFdh7kgS7oyqS9ehL26MsUmtb++e1Pga7Iy+tu5/000Emydre7jm2b396rqIoKC83IPv4/1qPuLV/jnVZP63I5fpaxuCUSIy+NM45xbgRDio80PSbR7lkvSaTCdnZJ3Bl1mjo9XqX1ODtWjPORmbWGGYsiDXjrKyxzFiQnzJOYcYC/ZTzNOYsSG8zVhSl9ebSltaBicUsw2JSzv177vt2/zebZMhmGRazAnMXz7GYFVhMltZ/2z9ukn9qt3tN6/dtB1vW2mSLu4wGdThVUe3qIlQTHGlwdQlCcFBBPabRaJCcnOwW5+56K2YsHjMWjxmrgzmL19uMJencp+ya1tOc3IFske0GI22PtrQ9wvLT0ZjWwZEsK60DEKVNu6zYjv7ZBisKoFiPfCk/tdsdJbQ+x/ZY6xH6kpISxMTEtOZse61if9RJpfGPGkc1IwYGCl9HW2r9ruDsT73E2Z+IiIiIyFOIfu/qHsNn8ghmsxlbt26F2Wx2dSleixmLx4zFY8bqYM7iMWPxmLF4amXMQQX1mKIoKCsrc68LHr0MMxaPGYvHjNXBnMVjxuIxY/HUypiDCiIiIiIi6hMOKoiIiIiIqE84+5MHOnVoP+Q+nxfn+CTLiiIjLtAfZw7thyQ5607Ezrhzah+X4Ub9kBUZg0KDUHKkABqpF2N+Z9TR50U4owZxd2lXZAUJ4aEoO370vHe47fu+5SZZOIMDdSiyjMSoCFQUnoBkuzO8e/TDOfuWG9zxWZIgywqSBkSj6sxp272DHFuEm9xOvo+L0Gg00Gi1kDQaaDTan/6v1UKj0ULSaqHRaCBpNA73WavVIjU1lTdlE4gZi6dWxl4/qCgqKsJNN92E0tJS6HQ6PPTQQ/jZz34GAHj++eexdu1aKIqCK664An/729/c5g9fdz57/q9oqK5ydRlEREQepXXgoTk30NBCq9dD5+MDnd6n9V8fH+h8fDv8/7jBH77+/vD1D4RfQAB8AwLg63/uKyAQ/iGh0PFeIb2i0WiQmJjo6jK8mjXj2tpaoevx+kGFTqfDqlWrkJqaitLSUkyYMAFZWVlobGzESy+9hP3790Ov12Pq1KnYtm0b0tLSXF3yeYXHDYIhqPdTgfXlQp2GhgYEBAT0+vXOqqPNQvr28r5X4KTbt/4037fR2AiDwd/hD0Odk2dfX+76bXr+RShoamqCn58fuv+ItI/7lhtsj9ZFuGCbKEBzSzN8fXxbI3bGNu3zEuCkfcv1F5O2rcHU0gK9j09vFtL3Ovq8BPS9DsV6V2sLZNkCRZYhW7q+Y7Uiy7DIMmA92m/s2+rb8gsIhH9oGAJCQlv/DQ1DcGQUgiOjERwVjeDoGPgFBHrEh5dqMpvN2LJlC6ZOnQqdzuvflrqENePU1FSh6/H6rRcbG4vY2FgAQHR0NMLDw1FZWQk/Pz+YzWY0NTUBaL1rZnR0tCtL7bGfP7LCJev96c6iWbx7qyDMWDxmLB4zVgdz7lzr3axlyBYZimyBbJHtBhyyxXKu3QKLyQRzS8u5r2aYTD/939zSghajEQf27cPghHiYmoxobmhAc2MDmhvq0dzYiObGBjTV10G2WNDUUI+mhnpUni7qsjYfgwHBUTEIjRmA8LhBCB8Yj/CBgxAeNwi+/s75wM7TKIqCuro6txiweyu1Mnb7QcWWLVvwzDPP4Pvvv0dxcTHWr1+PuXPn2j1n9erVeOaZZ1BcXIwLLrgAq1atwpQpUzosa9euXZBlGfHx8QCA++67DwkJCdDpdFi0aBGGDh2qRpeIiIhIkNa7Wbee3gT0bbBlMplQIvlgcjcDN0VR0NRQj8bqKjRUV6OhpgqN1VWor6pEXXkZastKUVteiobqKrQYjSgvPIHywhMdlhMQFt460IgbhIhB8YgYlIiIQfHwDwnl0Q3yCG4/qGhoaMC4ceNw66234rrrruvw+HvvvYclS5Zg9erVuPTSS/Hqq68iMzMTBw4cQEJCgu15FRUVuPnmm7F27VoAQFVVFT777DOcOHECBoMBmZmZtsNvnWlubkZzc7Pte+t5aSaTCSaTCUDrOWtarRYWiwWyLNuea203m812o0TtuYvHumq3LtfKeliw/c1LumrX6/WQZRmWNoeCJUmCTqfrsr2r2i0Wi60ek8nkNX1yt+1kXZbZbO62r57Up/a1u7pP1n+Vc6dNeEOfzle72n1qW5e39Kltu7v0yart8j29T+62nazPa/tYZ33S+fohYlACwuIGddmnZmMj6srLUVN2FjVni1FdUozK00WoPHMKDVWVtq+i/Xvt6vALDETEoITW5cf+dHTDPzQMOp3OK7ZT24y57zm/T+3//oni9oOKzMxMZGZmdvn4ypUrsWDBAixcuBAAsGrVKmzYsAFr1qzBihWtpwk1Nzdj3rx5eOCBB5Ceng4A+OqrrzBs2DCEh4cDAGbNmoVt27Z1OahYsWIFli9f3qE9JycH/v7+AICEhASMHz8ee/fuRWFhoe05ycnJGDlyJHbs2IGysjJbe2pqKhITE7FlyxbU1dXZ2tPS0hAdHY2cnBy7HScjIwMGgwHZ2dl2NWRlZcFoNGLjxo22Np1Oh1mzZqG8vBx5eXm29qCgIFx++eUoKipCfn6+rT0qKgrp6ek4fPgwCgoKbO2d9Sk3N9fr+gS413baunUrpk+f7lV9crftZDQaIUmSV/XJnbbToEGDoNVqsW3bNq/pk7ttp2nTpmHIkCHIzc31mj6523by9fUFALuMndOnaFwxay4OHTqEgoICyKYWtNTWIEivRZBWwrH9+1BTcgam+lo01dfj9KEDOH3ogF22Gh9fhMUNRNzQ4ahsbIbiZ4BPSBi0Bn+kp6d7zHbas2ePXcbc98T1qe3rRJAUDzqJTZIku9OfWlpa4O/vj/fffx/z5s2zPW/x4sXIz8/H5s2boSgKbrzxRiQnJ+PRRx+1PWfbtm248847kZeXB71ej2uuuQa/+c1vMGfOnE7X3dmRivj4eJSXlyM4uPWiaU8buXrjaJx9Yp/YJ/aJfWKfvKVP5pZmVBWfQdWZU6g6cxrlRSdQcaoINWdLoCgyOuPj74+Iga1HNkIHxCIoMgpBEVEIiohEcEQkpHMZuKpP7du9YTt5Sp9qa2sRGRmJmpoa23tXZ/LoQcWZM2cwcOBAfPfdd7YjEADw5JNP4o033kBBQQH++9//YurUqUhJSbE9/tZbb2Hs2LH405/+hI8++ggajQbTp093aErZ2tpahISECNsw7shkMiEnJwczZ87kRYGCMGPxmLF4zFgdzFk8d83Y3NKCquLTqDhVeO6rCBWnClFVcgaK3PlgAwC0Op1tgGGbqcr2FQL/kFD4+geemz43ALrezCzmIHfN2JtYM77kkkuEDirc/vSnnmg/EFAUxdY2efJku1FkW0888QSeeOIJ4fV5k/ajY3I+ZiweMxaPGauDOYvnjhnrfHwQlZiEqMQku3azyYTq4tOoOF2E8qJCVJecQW15WeuF4pWVsJjNqD5bjOqzxT1aj1ang49/AHwN/vDx94ePwdB67w69Hjof33P3+bB+33q/D62PD7Q6fevNB7WaTm9K2LZNlmXUni7E6UMHfhpUSNK5adWl1vdz0rmbkUrST+/52v4f594LSuduWWp77Nxrz/2/9Z/zf3h83huf9mQZ3TzFx+Dfp1sD9IYa+7FHDyoiIyOh1WpRUlJi115aWoqYmBgXVUVERESkPp1ej8iEwYhMGIzkdrfdspjNqK+sQF15GeoqytBYW4OGmmo02r5q0FhbjeaGBrQYG22vMdbWwFhbI7z2D7/+XPg63MXEWXMw7ebbXV2G03n0oMLHxwcTJ05Ebm6u3TUVubm5XV4bQURERNTfaHU6hETHICT6/B+6KrKMliZj6z05zt2Po8XYiBaj0f7eHufu62Extfl/SwvMJlPrfUHkc/cKOXePEOXcNQiy3Ob/Fgtqa2rgbzBAks7d3FE5d+NORTl3f0SlQ7v1xomtDyu2axWUc49Z21v/f+61PTrjv/vn9GwR3T9Jo/PO07zc/pqK+vp6HDlyBAAwfvx4rFy5EhkZGQgPD0dCQgLee+893HTTTXjllVeQlpaG//u//8Pf//537N+/X+ht3/vjNRXWm6cEBQVxzmxBmLF4zFg8ZqwO5iweMxaPGYvX9uZ3oaGh/feail27diEjI8P2/bJlywAA8+fPx7p163DDDTegoqICjz32GIqLizFmzBhkZ2cLHVD0ZwaDwdUleD1mLB4zFo8Zq4M5i8eMxWPG4hkMBjQ2Ngpdh9sfqXBXrjxSYTxUCZi7nt1BFLPFgt3ff48JEydCp9P2cWl9/DTClR9m9HXd3XwSYzGbsXPXLlx04YXQ6gSN+V0dvYs/iTJbzNixYwcuvvhi2/R8qup7gC5e//lZLGZs27Ydl1wyCVqtfcZ93/wu7r+rP0htE6DZbEZeXh7S0tLU25f7Gr9GAjRSh3+h7dhme0zTcUIWtZhMJmRnZyOrmztqU98wY/GsGU+ePJmzP5G9qg9/hFwn9q6IXRmKINT8+KNL1t1fDEcQqg8VnP+J1GsjEIzqg4dcXYZXS0Ywqg4cdHUZXm8kglG1b7+ryxBPA0g6LSS95qcvn7bfayH5aKDx00Fj+OlLOve9NkgPbZAPJIOOp9gQCcJBhQfyiQ+G3NjLQUUfjkspioyqqiqEhYVBkjS9WUDvV95Xfel3n9br2KsVRUFNdQ1CQkP6/ofPlccg+7qtBdauKApqa2sRHBzcMeM+r7f3C3DpMeO+7eQdW5TW6+ECAwPPf2TCY/vdl/X2bcW2VysKGhoaERDg3/NDQK7+vSADiqwAsmL71/Z/SzfFyYDSYoHSYun6OT2hk6AN8oE22Be6MF9oIwzQRxqgjfCDLsIAbQA/KSfqLQ4qPFDkzaNdsl6TyYRt2dnIyprCQ5SCmEwmbM/ORlbWZGYsCDMWz2QyYUd2NrKyLmXGAnljzl0NOBSLAphkKGYZcosFiklu83Xu+xYLZKMZstEMpemn/8uNJljqTFCazIBZgaWqGZaqZrSc7Lh+TZAPfOICoB8YCJ+4QGgG+asfApGH4jUVvdRfZ38ym83Q6Xj4WBRmLB4zFo8Zq4M5O0YxWWCpM8FS1wJLTTPMlU2wVDTBVG6EpcIIS21Lp6/TRhngNyQEvsPC4DciDBrfvl5TSG1xPxbPmnFjY2P/nv2J3IvRaERQUJCry/BqzFg8ZiweM1YHc+45Sa+FLlwLXbhfp4/LzRaYShpgOlOPltP1aCmqg/lsIyxlRjSUGdGwvQTQSfAbFgbDBRHwGx3B06WchPuxeEajUfg6enFiPPVXZrMZGzduVOVW7/0VMxaPGYvHjNXBnJ1L46uFb2IwAtPiEH79CAxYOhFR90/E0RF1MFwyANoIP8CsoOlQJao+PIziJ7ej4p1DaDpa3cObqlFnuB+Lp1bGPFJBRERE1AlNgB7VESYEZw2GTqeD+WwjjPsrYPxfOUwlDTD+UAbjD2XQRRoQmB6HgItiIOl5ehT1TxxUEBEREZ2HJEnQDwiAfkAAgqcnoOVUHRp2lqBxTxnM5UZUf3IUtV8XInDKQASmx0Hjw8EF9S8cVJBDXHKzsH6GGYvHjMVjxupgzuJ1lbHPoCD4DApCSNYQNO4+i7otp2CpakbtlydQ/91pBF+RiIALYyBpeab5+XA/Fk+NjDn7Uy/1x9mfiIiIqHOKRUHjD6Wo/aoQlsomAIB+gD9C5w6D7+AQF1dHJP69K4fP1GOyLKO0tBSyLLu6FK/FjMVjxuIxY3UwZ/EcyVjSSgiYEIMByyYidPYQaPx1MJU0ouyVvaj84EfIRl6I3Bnux+KplTEHFdRjFosFeXl5sFj6eEdT6hIzFo8Zi8eM1cGcxetNxpJOg8BLByLm3gsRcNEAAEDjrrM4u2o3mo5WC6rUc3E/Fk+tjDmoICIiInIybYAeYdcNR9SiFGjD/WCpaUb52v+h+vNjUEz8VJ68DwcVRERERIL4Dg5BzOIJCLh4AKAA9d+eRunqfJgrxN+MjEhNHFRQj0mShKCgIEiS5OpSvBYzFo8Zi8eM1cGcxXNWxhpfLcKuHY6I+aOhCdDDVNyAsy/lo+nHKidV6rm4H4unVsac/amXOPsTEREROcpc04yKtw/CVFQHSEDwzMEImjaIb6pJOM7+RG5DlmWcPHmSMzQIxIzFY8biMWN1MGfxRGSsC/FF9B0prRdxK0DthhOofOdQv73OgvuxeGplzEEF9ZjFYkF+fj5naBCIGYvHjMVjxupgzuKJyljSaRB23XCEzhsGaCQY95aj7B//g6XB5NT1eALux+KplTEHFUREREQuEDgpFpG3XQDJV4uWE7UoW/MDL+Amj8VBBREREZGL+A0LQ/Sd46AN8YW53IjS1T+g5VSdq8sichgHFdRjkiQhKiqKF5MJxIzFY8biMWN1MGfx1MpYPyAA0XePgz42AHKDCWV//1+/uVEe92Px1MqYsz/1Emd/IiIiImeSm82oeOMAmo/VADoJETeOgmF0hKvLIi/B2Z/IbVgsFhw6dIgXUwnEjMVjxuIxY3UwZ/HUzljjq0PkrWPgNyocMCuoePsAGveUqrJuV+F+LJ5aGXNQQT0myzIKCgo47ZtAzFg8ZiweM1YHcxbPFRlLeg0ifj0a/uOjARmofK8A9XlnVFu/2rgfi6dWxhxUEBEREbkRSSsh7GcjEJgeBwCo/s9R1H5dCJ6xTu6MgwoiIiIiNyNpJITMHoLgKxIAALW5J1Hz+XEOLMhtcVBBPabRaJCQkACNhruNKMxYPGYsHjNWB3MWz9UZS5KE4CsSEXL1EABA/X9Po+qDw1As3jOwcHXG/YFaGTs8+5PRaISiKPD39wcAnDx5EuvXr8fo0aMxc+ZMIUW6I87+RERERGpp+P4sqj78EZABv1HhCP/lSGh8tK4uizyI283+NGfOHLz55psAgOrqakyaNAnPPfcc5syZgzVr1ji9QHIfFosFe/bs4QwNAjFj8ZixeMxYHcxZPHfKOGBiDCJ+PRrQadB0sBLl/9gHudHk6rL6zJ0y9lZqZezwoGL37t2YMmUKAOCDDz5ATEwMTp48iTfffBMvvPCC0wsk9yHLMgoLCzlDg0DMWDxmLB4zVgdzFs/dMjaMjkDUwjGQ/HRoOVmL0lf2wlzd7Oqy+sTdMvZGamXs8KCisbERQUFBAICcnBxce+210Gg0uOSSS3Dy5EmnF0hERERErXwHhyD6zhRog31gLm1E2Zp8mM42uLosIscHFcOGDcPHH3+MoqIibNiwwXYdRWlpKa8tICIiIhJMHxOAqLvGQRdlgKWmBaVr9qLpcJWry6J+zuFBxcMPP4z77rsPgwcPxqRJk5CWlgag9ajF+PHjnV4guQ+NRoPk5GTO0CAQMxaPGYvHjNXBnMVz54x1oX6IWjQOPonBUJrMKH99H+q/O+1xU866c8beQq2MHZ79CQBKSkpQXFyMcePG2QrcsWMHgoODMXLkSKcX6Y5cOftTWVmZS849lCSJ6/Sy9faXdbpqvf1lna5ab39ZpyvWK0kSNBqN3Zer+k7dU8wyqj46jMbdpQCAgIsHIPSaoZB0fJNO9kS/d+3VoIJcO6h49tlnUV9fr+o6iYiof+tsoKHRaKDVaju06fX6br98fX3h5+cHg8Fg+/Lz84O/vz98fHxc3VUbs9mMHTt24OKLL4ZOp3N1OV1SFAX1355GzRfHAQXwSQhC+C9HQhfm5+rSzstTMvZk1oxHjhyJiIgIYe9dHd56DQ0N+Otf/4qvv/4apaWlHT4xP3bsmNOKo875+/ureniz7bpaWlqE/8JXe5zrinF1d+s0m81O/8Xa3zNtz2KxQKvt2/zu3p5pX9enKIrDn2zzMy73pigKLBaL8GkpfX19ERwcjKCgIAQHByM4OBgRERGIjIxEZGQkfH19ha6/LUVRUFZW5vb7piRJCJo6CLooAyrfLUBLYR3O/m0Pwn82HIYLIl1dXrc8JWNPZs04OTlZ6HocfueycOFCbN68GTfddBNiY2N5ONQF7rrrLpes12QyITs7G1lZWdDr9S6pwdsxY/GYsXjennFv3/w4+02TyWTCF198gczMzC5z7kut1kGELMsOfVksFphMJrsvs9ls931TUxOamppgNBrtvmRZRnNzM8rKylBWVtZpbUFBQYiMjMTAgQMxcOBADBo0yDYrZX9nGBWBmHvGo+KdQzCdqkfFWwcRkBaL0KwkSHreKI/EcnhQ8cUXX+Dzzz/HpZdeKqIepysqKsJNN92E0tJS6HQ6PPTQQ/jZz34GAPjss89w7733QpZl/PGPf8TChQtdXC0REbm73n6Y5uwP4azXOVhPORJBzUGhoihobm5GXV0damtrbf/W1NSgvLwc5eXlaGhoQF1dHerq6nD8+HHba0NDQzFs2DAMHz4cSUlJbnUKldp0EQZELxqHmpwTqN9yGg15xWj+sQqh84bDb1ioq8sjL+bwNRVJSUnIzs7GqFGjRNXkVMXFxTh79ixSU1NRWlqKCRMmoKCgAL6+vhg9ejQ2btyI4OBgTJgwAdu3b0d4eHiPluvKaypcRZZlFBUVIT4+nrM0CMKMxWPG4jFjdfTHnI1GIyoqKnD27FmcPn0ap06d6nDqjFarxZAhQ5CSkoLk5OQ+DTA8PWNjQSWqPjwMubYFAOA/MQYhWUnQBrjPEURPz9gTWDMOCQlBWFiY+1yo/fbbb+M///kP3njjDfj7+zu9INFSUlLw+eefo6ioCM888wzWr18PAFi8eDEuueQS/PKXv+zRcvrjoIKIiMjdNDc348SJEzhy5AgOHz6M6upq22M+Pj4YP348Lr74YkRERLiuSBeSm8yo+fIEGrYXAwqgCdAh+IpEBFw8AJKWb+L7E9HvXR3em5577jls2LABMTExGDt2LCZMmGD35WxbtmzB7NmzERcXB0mS8PHHH3d4zurVq5GUlAQ/Pz9MnDgR3377bafL2rVrF2RZRnx8PM6cOYOBAwfaHhs0aBBOnz7t9Pq9idlsxjfffAOz2ezqUrwWMxaPGYvHjNXBnFv5+voiOTkZs2bNwuLFi3H33Xdj6tSpCA0NRUtLC7Zv344XX3wR7733HkpLSx1atjdkrPHTIWzuMEQtGgddjD/kBjOq/3MUZ5/fjcb8UigW114g7Q0Zuzu1Mnb4moq5c+cKKKNrDQ0NGDduHG699VZcd911HR5/7733sGTJEqxevRqXXnopXn31VWRmZuLAgQNISEiwPa+iogI333wz1q5dC6Dzi9e6O9+1ubkZzc3Ntu9ra2sBwHbRGQDb1HrWC9usrO1ms7nDIVqNRtNlu3W5VtYZgdrvFF216/V620Vzbfuo0+m6bO+qdovFgpaWFtTV1aGlpQWSJHlFn9xtO5lMJtTV1cFkMnlNn9rX7uo+WTOWZRmKonhFn85Xu9p9smZszdcb+tS23V36pCiK7Xeydb2e3idnbKfw8HBcfvnlmDJlCo4dO4YdO3bg6NGjOHjwIA4ePIgxY8YgIyPD9kltd32SZblDxp6672niDIj+XSoadp5F3VeFMJcbUfluATRfnkDQlIHwvzAGssb+vZEafbL+vrBm7Mn7nrv+PLV9/yaSw4OKRx55REQdXcrMzERmZmaXj69cuRILFiywXWS9atUqbNiwAWvWrMGKFSsAtA4I5s2bhwceeADp6ekAgIEDB9odmTh16hQmTZrU5XpWrFiB5cuXd2jPycmxnQaWkJCA8ePHY+/evSgsLLQ9Jzk5GSNHjsSOHTvsZrNITU1FYmIitmzZgrq6Olt7WloaoqOjkZOTY7fjZGRkwGAwIDs7266GrKwsGI1GbNy40dam0+kwa9YslJeXIy8vz9YeFBSEyy+/HEVFRcjPz7e1R0VFIT09HYcPH0ZBQYGtvbM+5ebmel2fAPfaTlu3bsX06dO9qk/utp3q6+sRFBTkVX1yp+1k5U19crftNGXKFACtv5O9pU/O3E47d+5EWVmZ7ca8TU1NOHHiBPbt24cDBw4gLi4OkZGRSE9P77JP1jdxbTP2+H3vwihsKt6J6GI/RBf7QV/djJpPj6H2q5MoCW1ARVQzjAEW1fq0e/duu4y9Yd9z15+ntq8Todc3v/v+++9x8OBBSJKE0aNHY/z48c6urQNJkrB+/Xrb0ZKWlhb4+/vj/fffx7x582zPW7x4MfLz87F582YoioIbb7wRycnJePTRR23PMZvNGDVqFDZt2mS7UHvbtm1dnnPZ2ZGK+Ph4lJeX2z7t8LSRq6Oj8ebmZuTm5mLGjBnw9fX1ij6523YymUzIzc3FzJkzYTAYvKJP7Wt3dZ+sGVun4fSGPp2vdlccqcjNzUVWVpbtE3VP71PbdnfZToqiIDs7GzNmzLDN0uTpfRK9nUpKSvD555/bPlQcNGgQrrvuOoSFhXXaJ+u0vW0zdrc+9WU7KSYZxt2laPyuGJaqn97j6OIC4DcuEoFjoqAJ8xXaJ6PRiJycHFvG3rrvubJPTU1NyM3NxaRJkxAbG+s+F2qXlpbiF7/4BTZt2oTQ0FAoioKamhpkZGTg3XffRVRUlNOLtGo/qLBeF/Hdd9/ZjkAAwJNPPok33ngDBQUF+O9//4upU6ciJSXF9vhbb72FsWPH4pNPPsF9990HWZbxhz/8Ab/5zW96XEt/vFBblmWUl5cjMjKSMzQIwozFY8biMWN1MOfekWUZ33//Pb766is0NzfDYDBg7ty5nd4YrL9krFgUNBVUonH3WRgPVgJtrrPQRfvDb2Q4/EaEwic+GBpf597vor9k7ErWjH18fNxr9qcbbrgBR48exVtvvWWbVvbAgQOYP38+hg0bhnfeecfpRVp1NajYunUr0tLSbM974okn8NZbb+HQoUPCaumPgwoiIiJvUVlZiQ8++ABnzpwBAEyfPh2TJ0/u9zf1tTSYYMwvhXF/BZpP1ABymwc1gD42EL6JwdAPDIQ+NgD6aH9IOg4GPIHbzf705ZdfYs2aNXb3qRg9ejRefvllfPHFF04t7nwiIyNthzPbKi0tRUxMjKq19Acmkwmff/55h8N05DzMWDxmLB4zVgdz7pvw8HDcdtttuPjiiwEAX3/9Nb744gu701n6Y8baAD0CLx2IqN+kIO6hNIT/ciT8x0dDG+oLyIDpdD3qt55B1fs/ovSFPTj98HcoWfk9yt/Yj+pPj6L+u9MwHqqE6WwDLA0mKHL3n133x4zVplbGDl+oLctyp3fYtJ7PpSYfHx9MnDgRubm5dtdU5ObmYs6cOarW0l9wyjfxmLF4zFg8ZqwO5tw3Op0OWVlZCA8Px5dffokdO3agoaEB1157LbTa1tN8+nPGGoMO/uOi4D+u9dR2c3UzWk7WoOVkHVqKG2AqaYBiNMNc2ghzaWMXC5GgCdBDG6iHJlAPbaAPJD8tNH46SL5aKDoguFiDpoOVsPj7tp5epZUg6TTnviRAq4Gk10DSaiBp+/eRpN5SYz92eFBx+eWXY/HixXjnnXcQFxcHADh9+jSWLl2K6dOnO73A+vp6HDlyxPb98ePHkZ+fj/DwcCQkJGDZsmW46aabcOGFFyItLQ3/93//h8LCQixatMjptRAREZH3ueSSSxAYGIiPPvoI+/fvh16vxzXXXOPqstyOLtQXutBo+I+LBtA6Pb+ltgXms40wVxphrmyCpaIJ5qommKuaoRjNgKxArmuBXNf1dKZJCETNkR97VoSE1tOttBIkjQRIACQJ0Eitp65JaP1/m8ckzU/PgYSfnmdbptRhHR2/lzp9qm393b5esvuv3+gIBE6K7Vl/PYjDg4qXXnoJc+bMweDBgxEfHw9JklBYWIixY8fi7bffdnqBu3btQkZGhu37ZcuWAQDmz5+PdevW4YYbbkBFRQUee+wxFBcXY8yYMcjOzkZiYqLTayEiIiLvNGbMGGi1Wvz73/9Gfn4+fH19hXxY6k0kSYIuxBe6EF8AYR0eV8wy5AYTLPUmyPUt5/41QW4yQ2m2QG62wGI0oez0WUQEh0FplqG0WKBYZChmBTDLUMwy0PYMKqV11iqY7Js9iS7K39UlCNHrKWVzc3Nx6NAhKIqC0aNH44orrnB2bW6tP16obb3RUlBQUL+/kE0UZiweMxaPGauDOYuRn5+Pjz/+GAAwc+ZMjBkzhhkL1JP9WLEoUCzyuUGGAsUst36vAFAUKDIAWTn3f8XWDvncY0prmyIr555nW7LdPzj31K4es/++68d/ekrnz9FH+8MnPqjTvopgzVhRFISGhgp77+rQkQqz2Qw/Pz/k5+djxowZmDFjhtMLIvdmMBhcXYLXY8biMWPxmLE6mLPzpaamwmg0YsOGDcjNzUVUVBSCgtR7A9gfnW8/lrQSJK0W8HHudLb9icFgQGNjF9e9OIlDsz/pdDokJiba3VyD+g+z2Yzs7Ox+fdGaaMxYPGYsHjNWB3MW55JLLsG4ceOgKAree+89VFRUuLokr8X9WDy1MnZ4Stk///nPeOCBB1BZWSmiHiIiIiKXkiQJV199NQYMGACz2YyPPvqIH6gSnYfDF2q/8MILOHLkCOLi4pCYmIiAgAC7x3fv3u204oiIiIhcQa/X4/rrr8eaNWtw5swZfPfdd5g6daqryyJyWw4PKubMmcOLlYiIiMjrhYSEYNCgQTh58iQ2bdqE5ORk3lyXqAu9nv2pv+uvsz+ZzWbodDoOLAVhxuIxY/GYsTqYs3iKosBkMuHDDz9EQUEBBgwYgNtvv912YzzqO+7H4lkzbmxsFDr7k8PXVAwZMqTTC5aqq6sxZMgQpxRF7stoNLq6BK/HjMVjxuIxY3UwZ/Gamppw9dVXw2AwoKSkBNu2bXN1SV6H+7F4amTs8KDixIkTnV6s1NzcjFOnTjmlKHJPZrMZGzdu5AwNAjFj8ZixeMxYHcxZPGvGfn5+mDlzJgBg8+bNqK+vd3Fl3oP7sXhqZdzjayo++eQT2/83bNiAkJAQ2/cWiwVff/01kpKSnFsdERERkRsYN24cdu7ciTNnzuCbb77BNddc4+qSiNxKjwcVc+fOBdA6zdr8+fPtHtPr9Rg8eDCee+45pxZHRERE5A40Gg2uuuoqvPbaa9i9ezcuuugixMbGurosIrfR49OfZFmGLMtISEhAaWmp7XtZltHc3IyCggJcffXVImslN6DTOTxhGDmIGYvHjMVjxupgzuK1zTghIQFjxowB0HrWBjkH92Px1MiYsz/1Un+c/YmIiKi/q66uxosvvgiLxYJbbrkFgwcPdnVJRD0i+r2rwxdq33PPPXjhhRc6tL/00ktYsmSJM2oiNyXLsu0oFYnBjMVjxuIxY3UwZ/E6yzg0NBQTJkwA0HrRNvUN92Px1MrY4UHFhx9+iEsvvbRDe3p6Oj744AOnFEXuyWKxIC8vr9PZv8g5mLF4zFg8ZqwO5ixeVxlfeuml0Gg0OH78OAoLC11UnXfgfiyeWhk7PKioqKiwm/nJKjg4GOXl5U4pioiIiMhdhYaGIjU1FQCPVhBZOTyoGDZsGL788ssO7V988QVvfkdERET9wpQpUyBJEo4ePcr7dBHBgSllrZYtW4bf/va3KCsrw+WXXw4A+Prrr/Hcc89h1apVzq6P3IgkSQgKCoIkSa4uxWsxY/GYsXjMWB3MWbzuMg4LC0NKSgp++OEHbNu2Dddff70LKvR83I/FUyvjXs3+tGbNGjzxxBM4c+YMAGDw4MF49NFHcfPNNzu9QHfF2Z+IiIj6t+LiYrz66qvQaDRYsmQJ3w+QW3O72Z8A4M4778SpU6dw9uxZ1NbW4tixY/1qQNFfybKMkydPcoYGgZixeMxYPGasDuYs3vkyjo2NRUJCAmRZxvfff69ydd6B+7F4amXcq0GF2WzGV199hY8++gjWAx1nzpxBfX29U4sj92KxWJCfn88ZGgRixuIxY/GYsTqYs3g9yfjiiy8GAOzatQtms1mt0rwG92Px1MrY4WsqTp48iauuugqFhYVobm7GjBkzEBQUhKeffhpNTU145ZVXRNRJRERE5HZGjRqFoKAg1NXV4cCBA0hJSXF1SUQu4fCRisWLF+PCCy9EVVUVDAaDrX3evHn4+uuvnVocERERkTvTarW48MILAQA7duxwcTVEruPwoOK///0v/vznP8PHx8euPTExEadPn3ZaYeR+JElCVFQUZ2gQiBmLx4zFY8bqYM7i9TTjiRMnQqPR4NSpUygrK1OpOu/A/Vg8tTJ2eFAhy3Kn52SdOnUKQUFBTimK3JNOp0N6ejp0OofPmqMeYsbiMWPxmLE6mLN4Pc04MDAQw4YNAwDk5+erUJn34H4snloZOzyomDFjht39KCRJQn19PR555BFkZWU5szZyMxaLBYcOHeLFVAIxY/GYsXjMWB3MWTxHMrbeYXvv3r2cycgB3I/FUytjhwcVzz//PDZv3ozRo0ejqakJN954IwYPHozTp0/jqaeeElEjuQlZllFQUMBflgIxY/GYsXjMWB3MWTxHMh4xYgT8/PxQV1eHY8eOqVCdd+B+LJ5aGTt8HCQuLg75+fl45513sHv3bsiyjAULFuBXv/qV3YXbRERERP2FTqfD2LFjsXPnTvzwww+206GI+otenVxlMBhw22234bbbbnN2PUREREQeady4cdi5cycOHjyIpqYm+Pn5ubokItX0aFDxySef9HiB11xzTa+LIfem0WiQkJAAjaZX90ykHmDG4jFj8ZixOpizeI5mPHDgQERGRqK8vBwHDhzAhAkTBFfo+bgfi6dWxpJivSX2eYrp0cIkqd9caFNbW4uQkBDU1NQgODjY1eUQERGRG9i8eTM2btyIYcOG4de//rWryyGyEf3etUejBVmWe/TVXwYU/ZXFYsGePXu4nQVixuIxY/GYsTqYs3i9yXj06NEAgGPHjsFoNIoqzWtwPxZPrYx5rIl6TJZlFBYWcoYGgZixeMxYPGasDuYsXm8yjoqKQlRUFGRZxo8//iiwOu/A/Vg8tTLu8aAiKysLNTU1tu+feOIJVFdX276vqKiwjc6JiIiI+ivr+6EDBw64uBIi9fR4ULFhwwY0Nzfbvn/qqadQWVlp+95sNqOgoMC51RERERF5GOug4siRI3bvnYi8WY8HFe2v5+7B9d3kZTQaDZKTkzlDg0DMWDxmLB4zVgdzFq+3GUdHRyMiIgIWi4WnQJ0H92Px1MqYW5B6TKvVYuTIkdBqta4uxWsxY/GYsXjMWB3MWbzeZixJEkaNGgWAp0CdD/dj8dTKuMeDCkmSIElShzbqP8xmM7Zu3Qqz2ezqUrwWMxaPGYvHjNXBnMXrS8ZtT4EymUzOLs1rcD8WT62Me3xHbUVRcMstt8DX1xcA0NTUhEWLFiEgIAAA3PqcwXnz5mHTpk2YPn06PvjgAwBAUVERbrrpJpSWlkKn0+Ghhx7Cz372MxdX6t4URUFZWRlPfROIGYvHjMVjxupgzuL1JePY2FgEBQWhrq4OJ0+exLBhwwRU6Pm4H4tnzTg5OVnoenp8pGL+/PmIjo5GSEgIQkJC8Otf/xpxcXG276Ojo3HzzTeLrLXX7rnnHrz55pt2bTqdDqtWrcKBAwfw1VdfYenSpWhoaHBRhURERORNJEnC8OHDAYDXVVC/0OMjFa+//rrIOoTKyMjApk2b7NpiY2MRGxsLoPWCqvDwcFRWVtqOvBARERH1xfDhw7F7924cPnwYiqLwtHHyam5/ofaWLVswe/ZsxMXFQZIkfPzxxx2es3r1aiQlJcHPzw8TJ07Et99+69A6du3aBVmWER8f76SqvZNWq0VqaiovphKIGYvHjMVjxupgzuL1NeMhQ4ZAq9WiqqoKFRUVTq7OO3A/Fk+tjHt8pMJVGhoaMG7cONx666247rrrOjz+3nvvYcmSJVi9ejUuvfRSvPrqq8jMzMSBAweQkJBw3uVXVFTg5ptvxtq1a7t9XnNzs911I7W1tQAAk8lkuwBLo9FAq9XCYrHY3bXQ2m42m+3OGdRqtdBoNF22t7+wS6dr3VztL7Tpql2v10OWZbvbskuSBJ1O12V7V7Vb2+Pi4mCxWKAoitf0qX27q/sUFxcHWZah0Wi8pk9ta3eHPlk/pFAUxWv61F3trujToEGDuq3dE/vkjtspPj4eFovF9pg39MmdtpMkSba/e9aaHOmTVqtFYmIijh07hkOHDmHSpEku71NntbtyO7V9b2GxWLyiT+64neLi4mzvXUVx+0FFZmYmMjMzu3x85cqVWLBgARYuXAgAWLVqFTZs2IA1a9ZgxYoV3S67ubkZ8+bNwwMPPID09PRun7tixQosX768Q3tOTg78/f0BAAkJCRg/fjz27t2LwsJC23OSk5MxcuRI7NixA2VlZbb21NRUJCYmYsuWLairq7O1p6WlITo6Gjk5OXY7TkZGBgwGA7Kzs+1qyMrKgtFoxMaNG21tOp0Os2bNQnl5OfLy8mztQUFBuPzyy1FUVIT8/Hxbe1RUFNLT03H48GG7mxiyT67pU2BgIKZPn+5VfXK37TR16lQEBgZ6VZ/caTv5+PhgxowZXtUnd9tOU6dOxVdffWX3gZen98ndtpNer0dOTk6f+jR8+HAcO3YM27Ztsx2t4Hb6qU/bt29HeXm5V/XJXbdTY2MjRJIUD7rcXpIkrF+/HnPnzgUAtLS0wN/fH++//z7mzZtne97ixYuRn5+PzZs329o2bdqEl156yTb7k6IouPHGG5GcnIxHH330vOvu7EhFfHw8ysvLERwcDMAzR67t27sbjTc3NyM3NxczZsyAr6+vV/TJ3baTyWRCbm4uZs6cCYPB4BV9al+7q/tkzTgzMxN6vd4r+nS+2tXukzXjrKws2xEhT+9T23Z32U6KoiA7OxszZsyAXq/3ij6523YymUz44osv7DJ2tE81NTV48cUXodFosGzZMvj6+nI7tWk3Go3IycmxZewNfXK37dTU1ITc3FxMmjQJsbGxqKmpsb13daYeHamYMGECvv76a4SFheGxxx7DfffdZ/t03pXKy8thsVgQExNj1x4TE4OSkhLb91deeSV2796NhoYGDBo0COvXr0dzczPee+89pKSk2K7TeOuttzB27NhO1+Xr62ubTrctvV5v+0VjpdVqOz1vzboz9LS9/XJ7067RaDq9g2JX7V3VrtVqbcu3/tB3V7un9Mldt5N1Xd7Up/O1q90n6713vKlPvWlnnzy3T9Y3Io78HXL3PnXX7oo+WS+s7izjnvYpIiLCNhlMUVGR7aZ43dXeH7dT+4y9oU89bRfdp7bv30Tq0aDi4MGDaGhoQFhYGJYvX45Fixa5xaDCqv1sCu1nWNiwYUOnr2s7uiQiIiISYfjw4di+fTuOHj1qN6gg8iY9GlSkpqbi1ltvxeTJk6EoCp599lkEBgZ2+tyHH37YqQV2JzIyElqt1u6oBACUlpZ2OHpBfafVapGWltbpqJycgxmLx4zFY8bqYM7iOSvjpKQkbN++HceOHXNSZd6D+7F4amXco0HFunXr8Mgjj+Czzz6DJEn44osvOj2EI0mSqoMKHx8fTJw4Ebm5uXbXVOTm5mLOnDmq1dFfaDQaREdHu7oMr8aMxWPG4jFjdTBn8ZyV8eDBgyFJEiorK1FdXY3Q0NC+F+cluB+LZ81Y9OxPPbpPRXJyMt59913s3LkTiqLg66+/xp49ezp87d692+kF1tfXIz8/33bl+vHjx5Gfn2+72n7ZsmVYu3YtXnvtNRw8eBBLly5FYWEhFi1a5PRa+juTyYTPP/+8wwVF5DzMWDxmLB4zVgdzFs9ZGfv5+WHgwIEAWt/H0E+4H4unVsYOTymr9nUIu3btQkZGhu37ZcuWAQDmz5+PdevW4YYbbkBFRQUee+wxFBcXY8yYMcjOzkZiYqKqdfYX7WccIOdjxuIxY/GYsTqYs3jOyjgpKQmnTp3CsWPHMH78eKcs01twPxZPjYx7dZ+Ko0ePYtWqVTh48CAkScKoUaOwePFiDB061Nn1Ydq0aTjfrLd33XUX7rrrLqevm4iIiMgZhgwZgm+//RbHjx/vMKEMkTfo0elPbW3YsAGjR4/Gjh07kJKSgjFjxmD79u244IILkJubK6JGIiIiIo8WHx8PnU6H+vp6uxujEXkLh29+N378eFx55ZX461//atd+//33IycnR8h1Fe6otrYWISEhwm4g4o4URUFdXR2CgoL4CYsgzFg8ZiweM1YHcxbP2Rm/9dZbOHr0KK666ipccsklTqjQ83E/Fs+asaIoCA0NFfbe1eEjFQcPHsSCBQs6tN922204cOCAU4oi92UwGFxdgtdjxuIxY/GYsTqYs3jOzDgpKQkAOLVsO9yPxVMjY4cHFVFRUbaZmNrKz8/nlGBezmw2Izs7mxdUCcSMxWPG4jFjdTBn8Zyd8ZAhQwAAJ0+e5A14z+F+LJ5aGTt8ofbtt9+O3/zmNzh27BjS09MhSRL++9//4qmnnsK9994rokYiIiIijzdgwAD4+vqiubkZJSUliIuLc3VJRE7j8KDioYceQlBQEJ577jk88MADAIC4uDg8+uijuOeee5xeIBEREZE30Gg0SEhIwOHDh1FYWMhBBXkVh09/kiQJS5cuxalTp1BTU4OamhqcOnUKixcv5gU2RERERN1ISEgA0HoKFJE3cXj2J2rVX2d/MpvN0Ol0HEAKwozFY8biMWN1MGfxRGRcWFiI1157Df7+/vj973/f77cd92PxrBk3Nja61+xP1L8ZjUZXl+D1mLF4zFg8ZqwO5iyeszOOi4uDTqdDY2MjysvLnbpsT8X9WDw1MuaggnrMbDZj48aNnKFBIGYsHjMWjxmrgzmLJyJjnU6HQYMGAeApUAD3YzWolTEHFUREREQqSkxMBMBBBXkXhwYVJpMJGRkZ+PHHH0XVQ0REROTV2g4qeGkreQuHBhV6vR779u3jhTT9mE7n8CzE5CBmLB4zFo8Zq4M5iyci40GDBkGj0aC2thbV1dVOX76n4X4snhoZOzz707333gu9Xo+//vWvomryCP1x9iciIiJyjr///e84ffo05s6di9TUVFeXQ/2A6PeuDg9bWlpasHbtWuTm5uLCCy9EQECA3eMrV650WnHkXmRZRnl5OSIjI6HR8HIcEZixeMxYPGasDuYsnsiMExIScPr0aRQVFfXrQQX3Y/GsGfv4+Ahdj8Nbb9++fZgwYQKCg4Px448/Ys+ePbav/Px8ASWSu7BYLMjLy4PFYnF1KV6LGYvHjMVjxupgzuKJzDg+Ph4AcOrUKacv25NwPxZPrYwdPlKxceNGEXUQERER9RvWQcXZs2fR1NQEPz8/F1dE1De9Ps505MgRbNiwwXYzDc5eQERERNQzQUFBCA0NBQCcPn3atcUQOYHDg4qKigpMnz4dI0aMQFZWFoqLiwEACxcuxL333uv0Asl9SJKEoKAgzv4lEDMWjxmLx4zVwZzFE52x9SZ4/fkUKO7H4qmVscOzP918880oLS3F2rVrMWrUKPzwww8YMmQIcnJysHTpUuzfv19UrW6Fsz8RERFRX2zfvh1ffPEFhg0bhl//+teuLoe8nOj3rg4fqcjJycFTTz1lG11bDR8+nHeG9HKyLOPkyZOQZdnVpXgtZiweMxaPGauDOYsnOuO2F2v31+3I/Vg8tTJ2eFDR0NAAf3//Du3l5eXw9fV1SlHkniwWC/Lz8zlDg0DMWDxmLB4zVgdzFk90xjExMdDpdGhqakJ5ebmQdbg77sfiqZWxw4OKqVOn4s0337R9L0kSZFnGM888g4yMDKcWR0REROSttFotBg4cCKB/X1dB3sHhKWWfeeYZTJs2Dbt27UJLSwv+8Ic/YP/+/aisrMR3330nokYiIiIirxQfH4+TJ0+iqKgIEyZMcHU5RL3m8JGK0aNHY+/evbj44osxY8YMNDQ04Nprr8WePXswdOhQETWSm5AkCVFRUZyhQSBmLB4zFo8Zq4M5i6dGxtbrKoqKioStw51xPxZPrYwdnv2JWnH2JyIiIuqrhoYGPPPMMwCA+++/nzfBI2HcbvYnAKiqqsKzzz6LBQsWYOHChXjuuedQWVnp7NrIzVgsFhw6dIgXUwnEjMVjxuIxY3UwZ/HUyDggIMB2E7wzZ84IW4+74n4snloZOzyo2Lx5M5KSkvDCCy+gqqoKlZWVeOGFF5CUlITNmzeLqJHchCzLKCgo4LRvAjFj8ZixeMxYHcxZPLUytl6s3R/vrM39WDy1Mnb4Qu27774bP//5z7FmzRpotVoArSOgu+66C3fffTf27dvn9CKJiIiIvNXAgQOxf//+fjmoIO/h8JGKo0eP4t5777UNKIDWKdGWLVuGo0ePOrU4IiIiIm/Xn49UkPdweFAxYcIEHDx4sEP7wYMHkZqa6oyayE1pNBokJCRAo+nVpTjUA8xYPGYsHjNWB3MWT62MY2NjIUkS6urqUFtbK3Rd7ob7sXhqZdyj2Z/27t1r+//Bgwfxhz/8Ab/73e9wySWXAAC2bduGl19+GX/9619xww03iKvWjXD2JyIiInKW1atXo7S0FL/4xS8wcuRIV5dDXkj0e9ceDSo0Gg0kScL5nipJUr+5er8/DiosFgv27t2LlJQUu9PfyHmYsXjMWDxmrA7mLJ6aGf/nP//Bnj17MGXKFEyfPl3outwJ92PxrBkPHjwY4eHhrp1S9vjx4zh27BiOHz/e7dexY8ecXiC5D1mWUVhYyBkaBGLG4jFj8ZixOpizeGpm3F+vq+B+LJ5aGfdo9qfExEShRRARERH1Z20HFbIs8xoD8jgOTykLtO7w3333HUpLSzuMeu655x6nFEZERETUX0RHR0On06G5uRmVlZWIjIx0dUlEDnF4UPH6669j0aJF8PHxQUREBCRJsj0mSRIHFV5Mo9EgOTmZn54IxIzFY8biMWN1MGfx1MxYq9UiNjYWRUVFOH36dL8ZVHA/Fk+tjHt0oXZb8fHxWLRoER544AGv2AEaGxsxatQo/OxnP8Ozzz7b49f1xwu1iYiISJwvv/wS27Ztw8UXX4ysrCxXl0NeRvR7V4dHBY2NjfjFL37hFQMKAHjiiScwadIkV5fhEcxmM7Zu3Qqz2ezqUrwWMxaPGYvHjNXBnMVTO+O4uDgA/etibe7H4qmVscMjgwULFuD9998XUYvqDh8+jEOHDvHTgB5SFAVlZWXnnVqYeo8Zi8eMxWPG6mDO4qmdsfVi7ZKSkn7zJpv7sXhqZezwoGLFihXYvHkzpk2bht/97ndYtmyZ3ZdatmzZgtmzZyMuLg6SJOHjjz/u8JzVq1cjKSkJfn5+mDhxIr799lu7x++77z6sWLFCpYqJiIiIuhYeHg4/Pz9YLBacPXvW1eUQOcThC7WffPJJbNiwAcnJyQDQ4UJttTQ0NGDcuHG49dZbcd1113V4/L333sOSJUuwevVqXHrppXj11VeRmZmJAwcOICEhAf/5z38wYsQIjBgxAlu3bj3v+pqbm9Hc3Gz7vra2FgBgMplgMpkAtF4Io9VqYbFY7GbFsrabzWa7UaJWq4VGo+my3bpcK52udXO1//Siq3a9Xg9Zlu1uSChJEnQ6XZftXdVusVhs9ZhMJq/pk7ttJ+uyzGZzt331pD61r93VfbL+qygKFEXxij6dr3a1+9S2Lm/pU9t2d+mTVdvle3qf3G07WZ/X9jHRfRo4cCCOHj2KoqIiREdHO71PndXu6u0E/JSxt/TJnbZT+79/ojg8qFi5ciVee+013HLLLQLK6bnMzExkZmZ2+fjKlSuxYMECLFy4EACwatUqbNiwAWvWrMGKFSuwbds2vPvuu3j//fdRX18Pk8mE4OBgPPzww50ub8WKFVi+fHmH9pycHPj7+wMAEhISMH78eOzduxeFhYW25yQnJ2PkyJHYsWMHysrKbO2pqalITEzEli1bUFdXZ2tPS0tDdHQ0cnJy7HacjIwMGAwGZGdn29WQlZUFo9GIjRs32tp0Oh1mzZqF8vJy5OXl2dqDgoJw+eWXo6ioCPn5+bb2qKgopKen4/DhwygoKLC1d9an3Nxcr+sT4F7baevWrZg+fbpX9cndtpPRaIQkSV7VJ3faTjExMdBqtdi2bZvX9MndttO0adMQHx+P3Nxcr+mTu20nX19fALDLWHSfrIOKHTt22I5WePN22rNnj13G3tAnd91ObV8ngsOzPw0YMADffvsthg8fLqomh0mShPXr12Pu3LkAgJaWFvj7++P999/HvHnzbM9bvHgx8vPzsXnzZrvXr1u3Dvv27et29qfOjlTEx8ejvLzcdgW9p41cvXE0zj6xT+wT+8Q+sU+e3KfDhw/j3XffRVRUFH7zm994RZ+8cTt5Yp9qa2sRGRkpbPYnh49ULF68GC+++CJeeOEFpxfjLOXl5bBYLIiJibFrj4mJQUlJSa+W6evra/vEoi29Xg+9Xm/XptVqodVqOzzXujP0tL39cnvTrtFoOp2pq6v2rmrXarVQFAVbtmzB1KlTbc/x9D6523Yym822jNu297R2d+xTT9vV6lPbjHU6nVf0qS/tIvpkNpuxefNmW8ad8bQ+teUufWq/L/ekdnfvU3ftruiT2WzGt99+22nGovpknQGqvLwcsizbvffwxu0EoNOMPblP7radZFnGli1bkJqa2unynMXhQcWOHTvwzTff4LPPPsMFF1zQoWMfffSR04rrq/bXeCiK0ul1H64+lctTKIqCuro6ztAgEDMWjxmLx4zVwZzFc0XGwcHBCAoKQl1dHUpKSpCYmKjaul2B+7F4amXs8KAiNDQU1157rYhanCYyMhJarbbDUYnS0tIORy+IiIiI3ElcXBwKCgpw5swZrx9UkPdweFDx+uuvi6jDqXx8fDBx4kTk5ubaXVORm5uLOXPmuLAyIiIiou61HVQQeQqHBxXuor6+HkeOHLF9f/z4ceTn5yM8PBwJCQlYtmwZbrrpJlx44YVIS0vD//3f/6GwsBCLFi1yYdWeTavVIi0trctzIqnvmLF4zFg8ZqwO5iyeqzK2XlfRHwYV3I/FUytjhwcVSUlJ3d6P4tixY30qqKd27dqFjIwM2/fWG+/Nnz8f69atww033ICKigo89thjKC4uxpgxY5Cdnc3DiH2g0Whsc2aTGMxYPGYsHjNWB3MWz1UZx8bGAgAqKirQ1NQEPz8/1WtQC/dj8awZW++xJmw9jr5gyZIlWLx4se3rrrvuQlpaGmpqamxTn6lh2rRptptXtf1at26d7Tl33XUXTpw4gebmZnz//fe2GXWod0wmEz7//HPhN0/pz5ixeMxYPGasDuYsnqsyDgwMREhICACguLhY1XWrjfuxeGpl3KspZTvz8ssvY9euXX0uiNxb+7mRyfmYsXjMWDxmrA7mLJ6rMo6Li0NNTQ3OnDmDpKQkl9SgFu7H4qmRscNHKrqSmZmJDz/80FmLIyIiIuq3+tN1FeQdnDao+OCDDxAeHu6sxRERERH1WxxUkKdx+PSn8ePH212orSgKSkpKUFZWhtWrVzu1OHIvOp0OGRkZXd4RkvqOGYvHjMVjxupgzuK5MmProKKqqgqNjY3w9/dXvQY1cD8Wz5qx2938bu7cuXbfazQaREVFYdq0aRg5cqSz6iI3ZTAYXF2C12PG4jFj8ZixOpizeK7K2GAwICwsDFVVVSguLsbQoUNdUocauB+LZzAY0NjYKHQdDg8qHnnkERF1kAcwm83Izs5GVlYW9Hq9q8vxSsxYPGYsHjNWB3MWz9UZx8XFoaqqCmfOnPHaQYWrM+4PrBlPnjxZ6Hqcdk0FERERETkPr6sgT9LjIxUajabbm94BgCRJnBaMiIiIyAkGDhwIADh9+rSLKyE6vx4PKtavX9/lY1u3bsWLL74o/AIQIiIiov5iwIABAIDa2lrU19cjMDDQxRURdU1S+jASOHToEB544AF8+umn+NWvfoW//OUvSEhIcGZ9bqu2thYhISGoqalBcHCwq8tRhaIoMJvN0Ol05z1qRb3DjMVjxuIxY3UwZ/HcIeOXXnoJ5eXluPHGGzFixAiX1CCSO2Ts7awZNzY2IjQ0VNh7115dU3HmzBncfvvtSElJgdlsRn5+Pt54441+M6Doz4xGo6tL8HrMWDxmLB4zVgdzFs/VGfeH6ypcnXF/oEbGDg0qampq8Mc//hHDhg3D/v378fXXX+PTTz/FmDFjRNVHbsRsNmPjxo28bkYgZiweMxaPGauDOYvnDhl7+6DCHTL2dmpl3ONrKp5++mk89dRTGDBgAN555x3MmTNHZF1ERERE/Z63DyrIe/R4UHH//ffDYDBg2LBheOONN/DGG290+ryPPvrIacURERER9WcDBgyAJEmor69HbW1tv7mOkzxPjwcVN998My+gIeh0Dt8vkRzEjMVjxuIxY3UwZ/FcnbGPjw+ioqJQWlqKM2fOeOWgwtUZ9wdqZNyn2Z/6s/44+xMRERGp7+OPP0Z+fj6mTp2Kyy+/3NXlkIcS/d6Vd9SmHpNlGaWlpZBl2dWleC1mLB4zFo8Zq4M5i+cuGXvzdRXukrE3UytjDiqoxywWC/Ly8mCxWFxditdixuIxY/GYsTqYs3juknHbQYW3nWDiLhl7M7Uy5qCCiIiIyI3FxMRAo9GgsbERNTU1ri6HqFMcVBARERG5Mb1ej+joaADeeQoUeQcOKqjHJElCUFAQZwETiBmLx4zFY8bqYM7iuVPG3npdhTtl7K3UypizP/USZ38iIiIitezatQufffYZhgwZgptvvtnV5ZAHEv3elRMDe6DTp9+BxWLs/QJ6OVJVFAXVVdUIDQt1eLQroS+j4z68tk+j8t6/trf9VRQFVVVVCAsLgyT14kCiiz7pccn27e1+LJ/LODwcml4tw1X7cl9eqm7NiqKgorISEeERvf9krA/7sst+3/R6lb3flysrqxAZGQONVg9J0kKSdJCgaf1Xc+57qc2/0Nq+12h8oNX6QaPxg0ajd3KnvIMsyygqKkJ8fDw0Gtee3NH+Ym1v+WTfnTL2VtaMQ0JChK6HgwoPdOz439DSUuay9ZdXuGzV/UZZuasr8H6lrvsR6jdKS11dQf9Qcrbvy5Ak7bnBhZ9toKHV+kGnDYJOHwKdLhh6XTB0umDo9CHw8YmAr080fHyi4OsbDa3W0Pci3JDFYkF+fj7i4uJc/oY3OjoaWq0WTU1NqKqqQnh4uEvrcRZ3ythbWTOePHmy0PVwUOGBoqOugtlc26vXKujt2W4KZFnGmTNnHP/B78MZdr2vt/XVLtGH/sqyBSUlJRgwYAAkh3+5uigrl23f3pFlC0pLSxEdHe34HzCP3JfV37ayoqCsrBRRUVHqf5rapzN6e/daV21bWZZRWVGOsPAQADIUxQxFsbT519LJ99b/myDLLT9VoVhgsTTAYmmAyeR4LTpdEPz8BsHfMBgG/8HwNwyGv/9gBASMgF7PU4SdQafTYcCAATh9+jROnz7tNYMK8h4cVHig5ORHXbJek8mE48eyMWpkFvR6HioXwWQy4cSJbIwezYxFMZlMyD6ZjTEXMGNRTCYTsrOzMXYMMxbJmnPGuN7lrCgKZLkFstwEi2yEbGmCLDfDIjdBthhhsRhhNted+6qByVwLs6n135aWcrS0lKK5uRSy3ASzuQ719QdRX3+ww3oMhsEIDh6L4KCxCAu7BIGBo3p3eichLi4Op0+fxpkzZzB27FhXl0Nkh4MK6jFJklzzyWM/wozFY8biMWN19DVnSZKg1fpCq/WFHr0711pRFFgs9WhuPgujsQiNjcfRaDwBY+MJNDQeQ3NzMYzGEzAaT+Ds2U8BAHp9OMLDL0VE+BRERl4BvV7sed594W77sjfOAOVuGXsjtTLm7E+9xNmfiIiIutfSUom6un2orfsfamr2oLp6OyyWRtvjkqRHRMRliB0wD5GRV0Cj4Wed3Tl79izWrFkDHx8f3H///bwGgRwi+r0r90bqMYvFgkOHDgm/zXt/xozFY8biMWN1eELOPj7hiIiYiqTBdyN13FpMnfI9Jox/B4MT70JAwAgoignl5V/hf/vuxta8y3D8+EswmdznjtHulnFkZCR0Oh1aWlpQUeEds6a4W8beSK2MOaigHpNlGQUFBZBl2dWleC1mLB4zFo8Zq8MTc9ZofBAWdjGGDr0Xl0z6ApMu/gKJiXdCr49Ac3MJjh1/HlvzLsOx4y/AbK5zdblul7FWq0VsbCwA7zkFyt0y9kZqZcxBBREREblEYOAIDBt6HyZf+i1Gj34OAQEjYDbX4fjxvyFv2xUoKfkPeJa2PW+8roK8AwcVRERE5FIajS9iB8zFpIs/x5gLXoC/fxJaWsqx/8Ay7Mm/CUbjaVeX6DY4qCB3xUEF9ZhGo0FCQgIvDBOIGYvHjMVjxurwxpwlSYOYmFmYdHE2hg65FxqNL6qq8rBj52yUleWqXo87ZmwdVBQXF3vFdQjumLG3UStjzv7US5z9iYiISKzGxpPYf2Apamt/AAAkJCzEsKF/7Nf3uZBlGX/961/R0tKCO++8EzExMa4uiTwEZ38it2GxWLBnzx6v+GTEXTFj8ZixeMxYHf0hZ3//REyc8C4S4hcAAAoL12L//qWQ5WZV1u+OGWs0Gq+6WNsdM/Y2amXMQQX1mCzLKCws5AwNAjFj8ZixeMxYHf0lZ43GB8OHP4gLRq+EJOlwtvQz5P+wEGZzg/B1u2vG3nRdhbtm7E3UypiDCiIiInJ7AwbMwbiUtdBqA1BVtRX/23c3ZLnF1WW5hDcNKsh79PtBRWNjIxITE3Hfffe5uhQiIiLqRkTEFIxPfRNarT8qK7/F/gP3QVH632kz1kFFSUkJzGazi6shatXvBxVPPPEEJk2a5OoyPIJGo0FycjJnaBCIGYvHjMVjxurorzmHhKRi7Ng1kCQ9Sks/x4+HHxe2LnfNODw8HH5+frBYLCgrK3N1OX3irhl7E7Uy7tdb8PDhwzh06BCysrJcXYpH0Gq1GDlyJLRaratL8VrMWDxmLB4zVkd/zjkifDIuGP0cAAmnTr2JkpL/CFmPu2YsSZLXnALlrhl7E7UydttBxZYtWzB79mzExcVBkiR8/PHHHZ6zevVqJCUlwc/PDxMnTsS3337r0Druu+8+rFixwkkVez+z2YytW7fyUKtAzFg8ZiweM1ZHf885JmYWkgb/FgBwqODPaGg44vR1uHPG1kHF6dOefWNAd87YW6iVsU7o0vugoaEB48aNw6233orrrruuw+PvvfcelixZgtWrV+PSSy/Fq6++iszMTBw4cAAJCQkAgIkTJ6K5ueO0czk5Odi5cydGjBiBESNGYOvWreetp7m52W5ZtbW1AACTyQSTyQSg9fCSVquFxWKxu8Le2m42m9H2tiBarRYajabLdutyrXS61s3Vfqfoql2v10OWZbspxCRJgk6n67K9q9otFgtaWlpQVlaGlpYWSJLkFX1yt+1kMplQVlYGk8nkNX1qX7ur+2TNWJZlKIriFX06X+1q98masTVfb+hT23Z36ZOiKLbfydb1enqfHN1OSUm/Q1X1LlRX52Hv/+7G+NR/Q68PdFqfZFnukLG77HvW+1OcOXPG7bdTd32y/r6wZuwp+54n/TxZ378NGTIEIrntoCIzMxOZmZldPr5y5UosWLAACxcuBACsWrUKGzZswJo1a2xHH77//vsuX79t2za8++67eP/991FfXw+TyYTg4GA8/PDDnT5/xYoVWL58eYf2nJwc+Pv7AwASEhIwfvx47N27F4WFhbbnJCcnY+TIkdixY4fduY+pqalITEzEli1bUFdXZ2tPS0tDdHQ0cnJy7HacjIwMGAwGZGdn29WQlZUFo9GIjRs32tp0Oh1mzZqF8vJy5OXl2dqDgoJw+eWXo6ioCPn5+bb2qKgopKen4/DhwygoKLC1d9an3Nxcr+sT4F7baevWrZg+fbpX9cndtlN9fT2CgoK8qk/utJ2svKlP7radpkyZAqD1d7K39Kk32wnKAsjyfjQ2HsHGTUuQNPiPTuuT9U1c24zdZd9raWmd+aq0tBSbNm1CQ8NPU+y643bqqk+7d++2y9iT9j1P+3lq+zoRPOKO2pIkYf369Zg7dy6A1h8kf39/vP/++5g3b57teYsXL0Z+fj42b97s0PLXrVuHffv24dlnn+3yOZ0dqYiPj0d5ebntroSeNnJ1dDTe3NyM3NxczJgxA76+vl7RJ3fbTiaTCbm5uZg5cyYMBoNX9Kl97a7ukzXjzMxM6PV6r+jT+Wp3xZGK3NxcZGVl2T5R9/Q+tW13l+2kKAqys7MxY8YM6PV6r+hTb7dTecVm7Nt3OwANJk74AKGh45zSJ5PJhC+++MIuY3fZ9xRFwapVq9DY2Ihbb73VdjrU+frUWe2u7JPRaEROTo4tY0/b9zzh56mpqQm5ubmYNGkSYmNjhd1R222PVHSnvLwcFoulw63pY2JiUFJSImSdvr6+8PX17dCu1+ttv2istFptpxfDWHeGnra3X25v2jUaTadX+3fV3lXtWq0Wfn5+SE1NhZ+fn+21nt4nd9tOWq0Wqamptn3NG/rU03a1+mTNWKfTQZIkr+hTX9pF9MmasfUPZmc8rU9tuct2kmW5w+/k89Xu7n3qrr27PsVEX46ymNk4e/ZT/Hj4IVw48SOn9Emn03WZsTvse3FxcThy5AjOnj2LxMTEHvXJ0XbRffL19e00Y0/Z9zzh56nt+zeRPHJQYSVJkt33iqJ0aOuJW265xUkVeTeNRtPpLy1yHmYsHjMWjxmrgznbGz78z6io2Iy6uv04depNJCTc1udlunvG1kGFJ88A5e4ZewNrxtbrgYWtR+jSBYmMjIRWq+1wVKK0tLTD0QtyHrPZjG+++YYzNAjEjMVjxuIxY3UwZ3u+PpEYNvSPAIBjx/8Gk6mqz8t094y9YVpZd8/YG6iVsUcOKnx8fDBx4kS7C6eA1ot80tPTXVSV91MUBXV1dfCAy3A8FjMWjxmLx4zVwZw7iov7OQIDR8NiqcfJk//X5+W5e8bWQUVZWVmns116AnfP2BuolbHbDirq6+uRn59vu2L9+PHjyM/Pt11lv2zZMqxduxavvfYaDh48iKVLl6KwsBCLFi1yYdVERETkKpKkwdAhywAARafeRHNzqYsrEis4OBghISFQFMXj71dBns9tr6nYtWsXMjIybN8vW9b6S2L+/PlYt24dbrjhBlRUVOCxxx5DcXExxowZg+zsbJ6XR0RE1I9FRExDSMgE1NTsxokTq5Gc/KirSxJq0KBBqKmpwalTp4Tfh4CoOx4xpaw7qq2tRUhIiLBpudyRLMsoLy9HZGRklzO6UN8wY/GYsXjMWB3MuWtVVduwe8+vIEl6pF3yFQyGQb1ajidkvG3bNnz55ZcYPnw4fvWrX7m6HId5Qsaezpqxj48PwsLChL135dajHtNoNIiOjuYPvUDMWDxmLB4zVgdz7lpY2CUID7sUimJCUdHrvV6OJ2Q8aFDrgOnUqVMeeV2CJ2Ts6dTKmFuQesxkMuHzzz/vcJMWch5mLB4zFo8Zq4M5dy8h4XYAwJniD2A2153n2Z3zhIwHDBgAnU4Ho9GIiooKV5fjME/I2NOplTEHFeQQTvkmHjMWjxmLx4zVwZy7Fh4+Gf7+w2Cx1KO4+MNeL8fdM9bpdIiNjQUAFBUVubia3nH3jL2BGhlzUEFEREReR5IkxMfPB9A6E5SiyC6uSJz4+HgAradAEbkKBxVERETklWIHzIVOFwyj8SQqKja5uhxhrNdVeOqRCvIOHFRQj+l0OmRkZECnc9uZiD0eMxaPGYvHjNXBnM9Pq/VHXNzPAQBFRW84/HpPydh6pKK0tBRNTU0ursYxnpKxJ1MrYw4qyCEGg8HVJXg9ZiweMxaPGauDOZ/foIE3AZBQWfVfGI2Onx7kCRkHBQUhJCQEADzyJniekLGnUyNjDiqox8xmM7Kzs3lBlUDMWDxmLB4zVgdz7hmDYRDCwtIAAMUlHzn0Wk/K2Hq0wtNOgfKkjD2VWhlzUEFEREReLS72egBAcfFHXnvBdkJCAgCgsLDQxZVQf8VBBREREXm1qKiZ0GoD0dRUhOqa711djhCJiYkAWo9UWCwWF1dD/REHFUREROTVtFoDoqNmAgBKz37u4mrEiIqKgp+fH0wmE4qLi11dDvVDkuKJ93R3A7W1tQgJCUFNTQ2Cg4NdXY4qFEWB2WyGTqeDJEmuLscrMWPxmLF4zFgdzNkxFRWbkf/DbdDrIzD50q3QaM4/E46nZfyvf/0LP/74I2bOnIn09HRXl9MjnpaxJ7Jm3NjYiNDQUGHvXXmkghxiNBpdXYLXY8biMWPxmLE6mHPPhYWlQ68Pg8lUgarqbT1+nSdlbD0F6uTJky6uxDGelLGnUiNjDiqox8xmMzZu3MgZGgRixuIxY/GYsTqYs2M0Gj2izp0CVVa2oUev8bSM216sLcuecUG6p2XsidTKmIMKIiIi6hd+GlR85ZWzQMXGxkKn08FoNKK8vNzV5VA/w0EFERER9QvhYWnQagPR0lKK2tofXF2O0+l0OgwaNAgAp5Yl9XFQQQ4RfYt3YsZqYMbiMWN1MGfHaDS+iIi4DABQVpbTo9d4WsaeeF2Fp2XsidTImLM/9VJ/nP2JiIjI05Wc/RT79y9BQMBwXDLpS1eX43THjh3Dm2++ieDgYCxdupQzKpGN6PeuPFJBPSbLMkpLSz3m4i9PxIzFY8biMWN1MOfeiQifAkCDhobDaGo60+1zPTHjQYMGQaPRoLa2FlVVVa4u57w8MWNPo1bGHFRQj1ksFuTl5fFOnQIxY/GYsXjMWB3MuXf0+lCEBI8D0Hrviu54YsY+Pj626yqOHTvm4mrOzxMz9jRqZcxBBREREfUrERHTAADlFZtcWocoQ4YMAQAcP37cxZVQf8JBBREREfUr1ou1q6ryIMsmF1fjfElJSQBaBxU8rYjUwkEF9ZgkSQgKCuJFXwIxY/GYsXjMWB3MufeCgi6AThcKi6UBtXV7u3yep2Y8cOBA6PV6NDY2orS01NXldMtTM/YkamXM2Z96ibM/ERERea69/7sbZWVfYkjSEiQl/c7V5Tjd22+/jSNHjuDKK69EWlqaq8shN8DZn8htyLKMkydP8lCqQMxYPGYsHjNWB3Pum/DwSwEAlVV5XT7HkzNuewqUO/PkjD2FWhlzUEE9ZrFYkJ+fzxkaBGLG4jFj8ZixOphz34SHtX56X1OzBxaLsdPneHLG1kHFiRMn3Lp+T87YU6iVMQcVRERE1O8YDIPh6zsAitKCmpo9ri7H6QYMGACDwYCWlhacOdP9/TiInIGDCiIiIup3JElCaOjFAIDq6p0ursb5NBoNBg8eDAA4evSoa4uhfoGDCuoxSZIQFRXFGRoEYsbiMWPxmLE6mHPfhYZeBACorul8UOHpGQ8bNgwAcOTIERdX0jVPz9gTqJUxZ3/qJc7+RERE5NnqGw5j+/aroNH44bKpe6DR+Li6JKeqqanB888/DwD4/e9/j4CAABdXRK7E2Z/IbVgsFhw6dIgXUwnEjMVjxuIxY3Uw574L8B8GvT4MstyEurr9HR739IxDQkIQExMDwH1PgfL0jD2BWhlzUEE9JssyCgoKOO2bQMxYPGYsHjNWB3PuO0mSEBIyEQBQXbOrw+PekPHw4cMBAIcPH3ZxJZ3zhozdnVoZc1BBRERE/VZIyAQAQE1NvmsLEcQ6qDhy5AjfuJNQHFQQERFRvxUSPB4AUFub79pCBBk0aBB8fX1hNBo5tSwJxUEF9ZhGo0FCQgI0Gu42ojBj8ZixeMxYHczZOYKDx0CStGhuLkFTU7HdY96QsVarxdChQwG45ylQ3pCxu1MrY87+1Euc/YmIiMg77NhxDerq92PMmJcQE53p6nKcbs+ePfjPf/6D2NhY3HHHHa4uh1yEsz+R27BYLNizZw9naBCIGYvHjMVjxupgzs4THJIKAKhtd2dtb8nYel1FcXExampqXFyNPW/J2J2plXG/GFTMmzcPYWFhuP766+3ai4qKMG3aNIwePRopKSl4//33XVShZ5BlGYWFhbzQSyBmLB4zFo8Zq4M5O09I8DgAQG3tXrt2b8k4MDAQ8fHxAIBDhw65uBp73pKxO1Mr434xqLjnnnvw5ptvdmjX6XRYtWoVDhw4gK+++gpLly5FQ0ODCyokIiIiVwkKGgsAqKs/AEXxzk/MR48eDQA4cOCAiyshb9UvBhUZGRkICgrq0B4bG4vU1FQAQHR0NMLDw1FZWalydURERORKAQFDodEYYLE0oLHxuKvLEWLkyJEAgMLCQtTX17u4GvJGLh9UbNmyBbNnz0ZcXBwkScLHH3/c4TmrV69GUlIS/Pz8MHHiRHz77bdOr2PXrl2QZdl2eJA60mg0SE5O5gwNAjFj8ZixeMxYHczZeSRJi6Cg1k/ya+v22dq9KeOwsDDExsZCURQUFBS4uhwbb8rYXamVsU7o0nugoaEB48aNw6233orrrruuw+PvvfcelixZgtWrV+PSSy/Fq6++iszMTBw4cAAJCQkAgIkTJ6K5ubnDa3NychAXF3feGioqKnDzzTdj7dq1XT6nubnZbh21tbUAAJPJBJPJBKB1o2m1WlgsFrvz1qztZrMZbSfb0mq10Gg0XbZbl2ul07VuLrPZ3KN2vV4PWZbtLsyRJAk6na7L9q5qt7YPHTrU9ri39Kl9u6v7NHToUNt6vKVPbWt3hz4NHToUGo0GiqJ4TZ+6q90VfRo+fLjX9ckdt9OIESPs6vSGPrlqOwUGXICamu9RU/0DIiNmQafTQaPR2P7uWdfhSX1qv51GjRqF4uJi7N+/HykpKbZ2V/ZJURS7jPvjvie6T9b3b9b3rqK4fFCRmZmJzMyup29buXIlFixYgIULFwIAVq1ahQ0bNmDNmjVYsWIFAOD777/v9fqbm5sxb948PPDAA0hPT+/yeStWrMDy5cs7tOfk5MDf3x8AkJCQgPHjx2Pv3r0oLCy0PSc5ORkjR47Ejh07UFZWZmtPTU1FYmIitmzZgrq6Olt7WloaoqOjkZOTY7fjZGRkwGAwIDs7266GrKwsGI1GbNy40dam0+kwa9YslJeXIy8vz9YeFBSEyy+/HEVFRcjPz7e1R0VFIT09HYcPH7b7BIN9ck2fAgMDMX36dK/qk7ttp6lTpyIwMNCr+uRO28nf3x8ZGRle1Sd3205Tp07F5s2b7U5l8fQ+uXI7HT8hw8cHKCz8FgUF2cjIyIBer0dOTo7H9qn9dho3rvWC9GPHjuGTTz6xvUl1ZZ+2b9+O8vLyXvfJG/Y9tfrU2NgIkdzqPhWSJGH9+vWYO3cuAKClpQX+/v54//33MW/ePNvzFi9ejPz8fGzevLnHy960aRNeeuklfPDBB7Y2RVFw4403Ijk5GY8++mi3r+/sSEV8fDzKy8ttc/162sjV0dF4c3MzcnNzMWPGDPj6+npFn9xtO5lMJuTm5mLmzJkwGAxe0af2tbu6T9aMMzMzodfrvaJP56td7T5ZM87KyoIkSV7Rp7bt7rKdFEVBdnY2ZsyYAb1e7xV9cuV2qq4+iO93Xw2Nxh+Xpu+CXu8Dk8mEL774wi5jT+pTZ9tp9erVKCsrw+zZs21HK1zZJ6PRiJycHFvG/XHfE92npqYm5ObmYtKkSYiNjRV2nwqXH6noTnl5OSwWC2JiYuzaY2JiUFJS0uPlXHnlldi9ezcaGhowaNAgrF+/HhdddBG+++47vPfee0hJSbFdy/HWW29h7NixHZbh6+sLX1/fDu16vd72i8ZKq9VCq9V2eK51Z+hpe/vl9qZdo9F0eg5dV+1d1a7Vam3Lt/7Qd1e7p/TJXbeTdV3e1KfztavdJ0mSIEmSV/WpN+3sk+f2yfpGxJG/Q+7ep+7aRfcpOHg4JMkHstwIi+UsfHwSIEmSrf72ffCEPnVW4+jRo7F582YcOHAAEydOPO/z1epT+4z7074nuk9t37+J5NaDCivrD7WVoigd2rqzYcOGTtsnT57MeZGJiIgIGo0OAQHDUF9/APX1BTAYElxdkhDjxo3D5s2bcezYMdTW1gr5xJr6J7e+1D4yMhJarbbDUYnS0tIORy9IPK1Wi9TU1E5H5eQczFg8ZiweM1YHc3a+wMARAID6+tbz570x4/DwcMTHx0NRFPzvf/9zdTlembG7UStjtx5U+Pj4YOLEicjNzbVrz83N7faiahJDo9EgMTGx08Nr5BzMWDxmLB4zVgdzdr7AgGQAQH1D66DCWzO2XrC9d+/e8zxTPG/N2J2olbHLt2B9fT3y8/NtV6YfP34c+fn5tqvply1bhrVr1+K1117DwYMHsXTpUhQWFmLRokUurLp/MpvN+OabbzpcIETOw4zFY8biMWN1MGfnCww8N6g4d6TCWzO+4IILoNVqcfbsWYeuURXBWzN2J2pl7PJrKnbt2oWMjAzb98uWLQMAzJ8/H+vWrcMNN9yAiooKPPbYYyguLsaYMWOQnZ2NxMREV5XcbymKgrq6OrjRhGFehxmLx4zFY8bqYM7OF3BuUGE0noDF0gxF0XhlxgaDASNGjMDBgwfxww8/YMCAAS6rhfuxeGpl7PJBxbRp087bybvuugt33XWXShURERFRf+TrEwOdLgRmcw0aG4/Az2+Eq0sSZty4cTh48CD27t2LK664gtc0UJ+5/PQnIiIiIncgSVKHU6C81fDhwxEYGIiGhgYcPHjQ1eWQF+CggnpMq9UiLS2Nn2YIxIzFY8biMWN1MGcxbIOKhgKvzlir1druU7Fz506X1uGtGbsLtTLmoIJ6TKPRIDo6+v/bu/e4KOr9f+CvgQV2QRbkjqDgybyAAoKUWGpgiVJ5KcuUUMrLgzpmd48PO97OKe2Yds+8fRM1O6mZZpoXLEx+pOINMkM0RSVErnK/7u78/iD2iCy6CLPDwuv5eMzj0c4OM+95Ma37Zj4zwzs0SIgZS48ZS48ZmwZzlob+DlDlGR0+45CQEAiCgCtXriA3N1eWGjp6xu2BqTLmb5CMVldXhz179jR5nDy1HWYsPWYsPWZsGsxZGjcPf+roGavVavTr1w8AkJKSIksNHT3j9sBUGbOpoBbhLd+kx4ylx4ylx4xNgzm3PTu7+ouza2vzUFd3o8NnHBoaCqD+mRXV1dWy1NDRM24PTJExmwoiIiKivygUXaBUegMAKirOy1yN9Hx9feHq6oq6ujqcOnVK7nLIjLGpICIiIrpJwxCoisoLMlciPUEQMHjwYADAkSNHOAyJ7hqbCjKaQqFAeHg4FArZH2/SYTFj6TFj6TFj02DO0rG1/RsAoKYmq1NkHBgYCLVajbKyMqSmppp02zyOpWeqjNlUUIuoVCq5S+jwmLH0mLH0mLFpMGdp2Nr2BABUVl7qFBkrFAo88MADAIDk5GRotVqTbr8zZCw3U2TMpoKMptFo8MMPP/CCKgkxY+kxY+kxY9NgztKxVTU0FZmdJuPg4GDY2dmhuLgYZ86cMdl2eRxLz1QZs6kgIiIiuknDmYrq6mwAnePLrpWVFcLCwgAAhw8fNvnZCjJ/bCqIiIiIbmJt7QJLyy4ARAgWBXKXYzKhoaGwtbVFUVERTp48KXc5ZGbYVBARERHdRBAE2Nr6AgAsLPLlLcaEbGxsEB4eDgBITExEVVWVzBWRORFEURTlLsIclZaWwsHBASUlJVCr1XKXYxKiKEKj0UChUEAQBLnL6ZCYsfSYsfSYsWkwZ2n9dvYV5OZ+j56+b6Bnz7hOk7FWq8Xnn3+OgoICDBkyBCNHjpR0ezyOpdeQcWVlJRwdHSX77sozFdQi/KuF9Jix9Jix9JixaTBn6TTcVras/A+ZKzEtS0tLREZGAgCOHj2KoqIiybfJ41h6psiYTQUZTaPRIDExkXdokBAzlh4zlh4zNg3mLC1blS8AIPf6r50u4169euGee+6BTqfD7t27IeWgFh7H0jNVxmwqiIiIiG7RcAcooRNdU9FAEARERUVBoVDg0qVLOHXqlNwlkRlgU0FERER0i/9dqF0GjaZM3mJk4OzsjIiICADAgQMHUFJSInNF1N6xqaAWkfoR78SMTYEZS48ZmwZzlo5CYQ9rK1cAQFXVZXmLkcngwYPh7e2Nmpoa7Nq1CzqdTpLt8DiWniky5t2f7lJnvPsTERFRZ3Ly1CQUF6fA3+8DeHiMkbscWeTn52PVqlXQarWIiIjAsGHD5C6J7pLU3115poKMptPpkJeXJ9lfKogZmwIzlh4zNg3mLD3VXxdrV1RckrcQGbm6uuLRRx8FUP/siosXL7bp+nkcS89UGbOpIKNptVocOXIEWq1W7lI6LGYsPWYsPWZsGsxZekqlDwCgorLzNhUAEBwcjIEDB0IURWzfvh3FxcVttm4ex9IzVcZsKoiIiIgMsFXV3wGqqipT5krkFxUVBU9PT1RWVuLLL79ERUWF3CVRO8OmgoiIiMgAlar+TEVV1VVJn9VgDqysrPDMM89ArVajoKAAmzdvRk1NjdxlUTvCpoKMJggC7O3tIQiC3KV0WMxYesxYeszYNJiz9JRKbwCAVlsOjaZU5mrk5+DggJiYGKhUKly7dg3//e9/W91Y8DiWnqky5t2f7hLv/kRERNTxJf2/+1FbW4D7QnfB3t5f7nLahezsbGzYsAG1tbXo1q0boqOjYWdnJ3dZdAe8+xO1GzqdDleuXOEdGiTEjKXHjKXHjE2DOUtPp9NBEBqeVfGnzNW0H15eXpg6dar+jMUXX3yBoqKiu1oXj2PpmSpjNhVkNK1Wi9TUVN6hQULMWHrMWHrM2DSYs/S0Wi3Ky20AANXVbCpu5uXlheeffx4ODg4oLCzE6tWrkZ6e3uL18DiWnqkyZlNBRERE1AxR5wQAqGJT0YSrqyumTZumf+r2li1bsG/fPtTW1spdGsmATQURERFRM3RifVNRzeFPBqnVajz33HMYPHgwAODo0aP4/PPPcelS5362R2fEpoKMJggCXF1deYcGCTFj6TFj6TFj02DO0hMEAWr7v55VwTMVzbK0tMSoUaMwadIkqNVq3LhxAxs3bsTXX3+N/Pz82/4sj2PpmSpj3v3pLvHuT0RERB1fRcUlHD32CCwt7TB8WBq//N5BdXU1fvzxR5w4cQKiKEIQBAQEBCAsLAweHh5yl9ep8e5P1G5otVqcO3eOF1NJiBlLjxlLjxmbBnOWnlarxdWr5X/9dwXq6m7IXFH7p1Qq8eijj+KFF15Anz59IIoi0tLSsGrVKmzYsAG//fYb6urq9MvzOJaeqTJmU0FG0+l0yMjI4G3fJMSMpceMpceMTYM5S0+n0+H8+UxYW9ffVpZ3gDKem5sbJk2ahOnTp8Pf3x+CICAzMxPffPMNli9fjh07duDs2bOorKzkcSwxU31WKCRdOxEREZGZU9p4obY2H1XV2VCrA+Qux6x4e3vjqaeeQnFxMU6ePIlff/0VJSUlSEtLQ1paGiwsLGBra4vDhw/Dx8cHXl5eUKlUcpdNd4FNBREREdFt2Ci9gbJUVFdlyV2K2XJ0dMSIESMQHh6Oq1evIiMjA+fPn0dhYSHKy8uRlJSEpKQkAICLiwvc3d3h6uoKV1dXuLi4wNHRETY2NjLvBd0OmwoymoWFBXr06AELC46akwozlh4zlh4zNg3mLL2GjFUqbwBAVXW2zBWZPwsLC/j6+sLX1xeRkZHIz89HUlISdDodsrOzcePGDRQUFKCgoKDJzyqVSjg4OMDBwQFqtRq2trZNJpVKBRsbG1hZWUGhUPDCepjus6LD3/0pKysLMTExyMvLg0KhwPz58/HUU0/p39+9ezdef/116HQ6/OMf/8D06dONWi/v/kRERNQ5ZGd/jXMZb8HZ+SEEBf6f3OV0aOXl5bh27Rry8/P1U2FhIaqrq1u8LkEQYG1t3WhSKBSwtLRsdrKwsGj0WhCEZqeGbRgz3VyTq6srvL292ywzY0n93bXDNxU5OTnIzc1FUFAQ8vLyEBwcjIyMDNjZ2UGj0cDPzw+JiYlQq9UIDg7GsWPH4OTkdMf1dsamQqvV4tdff0VAQAAsLS3lLqdDYsbSY8bSY8amwZyl15Cxt3cZfj3zHGxteyFs8H65y+pQjD2Oa2pqUFJSop9KS0tRVVWFysrKRlNVVRU0Go0J96DlBg8ejFGjRplsew0Z+/r6wsnJSbLvrh1++JOnpyc8PT0B1N+JwMnJCUVFRbCzs0NKSgr8/f3h5eUFAIiKisL+/fsxadIkOUtut3Q6Ha5evYr+/fvzHzCJMGPpMWPpMWPTYM7Sa8j4nnv8AdTf/anh2QvUNow9jm1sbODm5gY3N7c7rlOr1aKurg61tbVNJo1GA61WC51OB61W2+zU8L4oiq2eAODmv+G7urq2PrgWaMi4R48ekm5H9qbi8OHDeO+993Dy5Enk5ORgx44dGDduXKNlVq5ciffeew85OTnw9/fHhx9+iKFDh7Z4WydOnIBOp0P37t0BANeuXdM3FED9HQqyszlekoiIiP7HxsYTgACdrhp1dYWwtnaRuyS6jYahS0qlUu5SOhXZm4qKigoEBgbiueeew5NPPtnk/S1btuCVV17BypUr8cADD2D16tUYPXo0fv/9d33HFRISgpqamiY/e+DAAXTr1g0AUFhYiClTpmDdunX69w2N/Grurw81NTWNtlFSUgIAKCoq0j/EpWEcXkOH26BhvkajabTNhrF7zc2/+eEwAKBQ1P+6bj2t19x8Kysrfad98/4pFIpm5zdXu1arRU1NDSorK1FYWAgbG5sOsU/t7fdUV1eHyspKFBUVQaVSdYh9urV2ufepIeOSkhJYWVl1iH26U+2m3qeGjEtLSyEIQofYp5vnt5ffkyiK+s9kKyurDrFP7e331HAs37hRhro6J9TW5uP69XQ4OASY7T4B7ev31DCEqeE47gj71N5+T9XV1frvFoDh779tQmxHAIg7duxoNO++++4T4+LiGs3r27evOHfuXKPXW11dLQ4dOlTcuHFjo/nJycniuHHj9K9nz54tbt682eA6Fi5cKALgxIkTJ06cOHHixMlsp6ysLKO/Q7dEu7pQWxCERsOfamtrYWtri23btmH8+PH65V5++WWkpqbi559/vuM6RVHE5MmT0adPHyxatKjRexqNBv369cOhQ4f0F2ofPXoUzs7OTdZz65kKnU6HoqIiODs7d5qxlaWlpejevTuysrI6zcXppsaMpceMpceMTYM5S48ZS48ZS68h46tXr0IQBHTr1k2S28vKPvzpdgoKCqDVauHu7t5ovru7O65fv27UOpKTk7FlyxYEBARg586dAIBNmzZhwIABUCgUWLFiBcLDw6HT6TBnzhyDDQVQf4HQrQ9dcXR0bPE+dQRqtZr/40uMGUuPGUuPGZsGc5YeM5YeM5Zew/M9pNKum4oGt54JEFtw54UHH3yw0Xi3W40ZMwZjxoxpVX1ERERERJ1Zu34Mp4uLCywtLZuclcjLy2ty9oKIiIiIiOTRrpsKa2trhISEICEhodH8hIQEDBkyRKaqOi8bGxssXLiwyTAwajvMWHrMWHrM2DSYs/SYsfSYsfRMlbHsF2qXl5fjjz/+AAAMHDgQ77//PsLDw+Hk5IQePXpgy5YtiImJwapVqxAWFoY1a9Zg7dq1OHv2LHx8fOQsnYiIiIiI0A6aikOHDiE8PLzJ/KlTpyI+Ph5A/cPvli1bhpycHPTv3x8ffPABhg0bZuJKiYiIiIjIENmbCiIiIiIiMm/t+poKIiIiIiJq/9hUEBERERFRq7CpICIiIiKiVmFTQW1i/Pjx6Nq1KyZMmCB3KR1aZWUlfHx88MYbb8hdSoeUkZGBoKAg/aRSqbBz5065y+oQmvuM2L17N/r06YN7770X69atk6m6jsFQxmVlZQgNDUVQUBAGDBiAtWvXylih+WvuOM7MzER4eDj8/PwwYMAAVFRUyFSh+Wsu4+XLl8Pf3x/9+/fHl19+KVN1HUNWVhYeeugh+Pn5ISAgANu2bbvtfGPxQm1qE4mJiSgvL8eGDRvwzTffyF1Oh/XWW2/hwoUL6NGjB5YvXy53OR1aeXk5fH19ceXKFdjZ2cldjtkz9Bmh0Wjg5+eHxMREqNVqBAcH49ixY3BycpK5WvNkKGOtVouamhrY2tqisrIS/fv3x/Hjx+Hs7CxzteapuX/rhg8fjrfffhtDhw5FUVER1Go1FAqFjJWaL0MZnzlzBlOnTsUvv/wCABgxYgT27NkDR0dHGSs1Xzk5OcjNzUVQUBDy8vIQHByMjIwMlJaWGpxv7L+BPFNBbSI8PBz29vZyl9GhXbhwAefOnUNUVJTcpXQKu3btwogRI9hQtBFDnxEpKSnw9/eHl5cX7O3tERUVhf3798tUofkzlLGlpSVsbW0BANXV1dBqteDfEu+eoYzPnj0LKysrDB06FADg5OTEhqIVDGWcnp6OIUOGQKlUQqlUIigoCPv27ZOpQvPn6emJoKAgAICbmxucnJxQVFTU7HxjsakgHD58GI8//ji6desGQRAMDvdYuXIlevbsCaVSiZCQECQlJZm+UDPWFhm/8cYbWLp0qYkqNk9teSxv3boVEydOlLhi8yDVZ8S1a9fg5eWlf+3t7Y3s7Oy2LN1sSPk5XFxcjMDAQHh7e2POnDlwcXFp4+rNg1QZX7hwAV26dMGYMWMQHByMJUuWSFC9eZAq4/79+yMxMRHFxcUoLi7GTz/91Gk/K4C2zfnEiRPQ6XTo3r27UfNvh00FoaKiAoGBgfj0008Nvr9lyxa88soreOutt3D69GkMHToUo0ePxtWrV01cqflqbcbfffcdevfujd69e5uybLPTVsdyaWkpkpOTeVboL1J9Rhj6i7kgCG1Ss7mR8nPY0dERaWlpyMzMxFdffYXc3Ny2Lt8sSJVxXV0dkpKS8Nlnn+HIkSNISEhAQkKCFLvQ7kmVsZ+fH2bPno2IiAiMHz8eoaGhnfpsUFvlXFhYiClTpmDNmjVGzb8jkegmAMQdO3Y0mnffffeJcXFxjeb17dtXnDt3bqN5iYmJ4pNPPil1iWbvbjKeO3eu6O3tLfr4+IjOzs6iWq0WFy9ebKqSzVJrjuWNGzeK0dHRUpdoltryMyI5OVkcN26c/vXs2bPFzZs3t33RZkbKz+G4uDhx69atbVaruWrLjH/55RcxMjJS/3rZsmXismXL2r5oMyPlcTxt2jRx9+7dbVarObvbnKurq8WhQ4eKGzdubLRcc/ONwTMVdFu1tbU4efIkRo4c2Wj+yJEj9RdMUesYk/HSpUuRlZWFy5cvY/ny5ZgxYwYWLFggR7lmqyXHMoc+Ga81nxH33XcffvvtN2RnZ6OsrAw//PADIiMjpSzXLLUm49zcXJSWlgKoPwN3+PBh9OnTR7JazVVrMg4NDUVubi5u3LgBnU6Hw4cPo1+/flKWa5Za+30iLy8PQP1d+lJSUvhZ0QxjchZFEbGxsYiIiEBMTIx+mebmG6vznjsioxQUFECr1cLd3b3RfHd3d1y/fl3/OjIyEqdOnUJFRQW8vb2xY8cOhIaGmrpcs2RsxtQ6xuZcUlKClJQUbN++3dQlmqXWfkasWLEC4eHh0Ol0mDNnDu9KZEBrMrawsMC0adMgiiJEUcSsWbMQEBBg6l1o91p7HC9ZsgTDhg2DKIoYOXIkHnvsMVPvQrvX2ozHjRuH4uJi2NnZYf369Z16+NPtGJNzcnIytmzZgoCAAP31GJs2bUJJSYnB+QMGDDBq2/yNkFFuHecsimKjebxjS+vdKeMGsbGxJqqoY7pTzg4ODp12zHlr3O1nxJgxYzBmzBhJa+so7jbj1NRUKcvqUO4249GjR2P06NGS1tZR3G3GHB3RMrfL+cEHH4ROpzP4c83NNwaHP9Ftubi4wNLSsslfzPPy8pp0wXR3mLFpMGdpMFfpMWPpMWPpMWPTkDNnNhV0W9bW1ggJCWlyJ4uEhAQMGTJEpqo6FmZsGsxZGsxVesxYesxYeszYNOTMmcOfCOXl5fjjjz/0rzMzM5GamgonJyf06NEDr732GmJiYjBo0CCEhYVhzZo1uHr1KuLi4mSs2rwwY9NgztJgrtJjxtJjxtJjxqbRbnNu8f2iqMNJTEwUATSZpk6dql/ms88+E318fERra2sxODhY/Pnnn+Ur2AwxY9NgztJgrtJjxtJjxtJjxqbRXnMWRNHA04eIiIiIiIiMxGsqiIiIiIioVdhUEBERERFRq7CpICIiIiKiVmFTQURERERErcKmgoiIiIiIWoVNBRERERERtQqbCiIiIiIiahU2FURERERE1CpsKoiIiIiIqFXYVBARtQOCIGDnzp1ylyGLzrzvxoqPj4ejo6PcZRARNYtNBRGRRGJjYyEIAgRBgJWVFdzd3fHII4/giy++gE6na7RsTk4ORo8ebdR6+SVcGosWLUJQUJDRy1++fBmCICA1NVWymhpMnDgR58+fl3w7RER3i00FEZGERo0ahZycHFy+fBl79+5FeHg4Xn75ZTz22GPQaDT65Tw8PGBjYyNjpdSeqVQquLm5yV0GEVGz2FQQEUnIxsYGHh4e8PLyQnBwMObNm4fvvvsOe/fuRXx8vH65m88+1NbWYtasWfD09IRSqYSvry+WLl0KAPD19QUAjB8/HoIg6F9fvHgRY8eOhbu7O7p06YLQ0FAcPHiwUS2+vr5YsmQJnn/+edjb26NHjx5Ys2ZNo2X+/PNPPPPMM3BycoKdnR0GDRqEY8eO6d///vvvERISAqVSib/97W9YvHhxo+boVsePH8cjjzwCFxcXODg4YPjw4Th16tRtMztz5gwiIiKgUqng7OyMmTNnory8XP9+bGwsxo0bh+XLl8PT0xPOzs74+9//jrq6Ov0yOTk5ePTRR6FSqdCzZ0989dVX8PX1xYcffnjbbd9q/fr16NevH5RKJfr27YuVK1fq3+vZsycAYODAgRAEAQ899JDBdWi1WkybNg09e/aESqVCnz598NFHH+nfr66uhr+/P2bOnKmfl5mZCQcHB6xduxZA0+FPaWlpCA8Ph729PdRqNUJCQnDixIkW7RsRUVtiU0FEZGIREREIDAzEt99+a/D9jz/+GLt27cLWrVuRkZGBL7/8Ut88HD9+HED9l92cnBz96/LyckRFReHgwYM4ffo0IiMj8fjjj+Pq1auN1r1ixQoMGjQIp0+fxosvvogXXngB586d069j+PDhuHbtGnbt2oW0tDTMmTNHP1Rr//79ePbZZzF79mz8/vvvWL16NeLj4/HOO+80u69lZWWYOnUqkpKScPToUdx7772IiopCWVmZweUrKysxatQodO3aFcePH8e2bdtw8OBBzJo1q9FyiYmJuHjxIhITE7FhwwbEx8c3atKmTJmCa9eu4dChQ9i+fTvWrFmDvLy8Zus0ZO3atXjrrbfwzjvvID09HUuWLMH8+fOxYcMGAEBKSgoA4ODBg8jJyWn296nT6eDt7Y2tW7fi999/x4IFCzBv3jxs3boVAKBUKrF582Zs2LABO3fuhFarRUxMDMLDwzFjxgyD64yOjoa3tzeOHz+OkydPYu7cubCysmrR/hERtSmRiIgkMXXqVHHs2LEG35s4caLYr18//WsA4o4dO0RRFMWXXnpJjIiIEHU6ncGfvXnZ2/Hz8xM/+eQT/WsfHx/x2Wef1b/W6XSim5ub+Pnnn4uiKIqrV68W7e3txcLCQoPrGzp0qLhkyZJG8zZt2iR6enresZYGGo1GtLe3F7///nuD+7NmzRqxa9euYnl5uf79PXv2iBYWFuL169dFUazP1cfHR9RoNPplnnrqKXHixImiKIpienq6CEA8fvy4/v0LFy6IAMQPPvig2doWLlwoBgYG6l93795d/Oqrrxot8+9//1sMCwsTRVEUMzMzRQDi6dOnjd7/Bi+++KL45JNPNpq3bNky0cXFRXzppZdEDw8PMT8/X//e+vXrRQcHB/1re3t7MT4+vsXbJSKSCs9UEBHJQBRFCIJg8L3Y2FikpqaiT58+mD17Ng4cOHDH9VVUVGDOnDnw8/ODo6MjunTpgnPnzjU5UxEQEKD/b0EQ4OHhof8LfmpqKgYOHAgnJyeD2zh58iT+9a9/oUuXLvppxowZyMnJQWVlpcGfycvLQ1xcHHr37g0HBwc4ODigvLy8SV0N0tPTERgYCDs7O/28Bx54ADqdDhkZGfp5/v7+sLS01L/29PTU70dGRgYUCgWCg4P17/fq1Qtdu3Y1uE1D8vPzkZWVhWnTpjXa37fffhsXL140ej0NVq1ahUGDBsHV1RVdunTB2rVrm2Tw+uuvo0+fPvjkk0+wfv16uLi4NLu+1157DdOnT8fDDz+Md999965qIiJqSwq5CyAi6ozS09P1Y/JvFRwcjMzMTOzduxcHDx7E008/jYcffhjffPNNs+t78803sX//fixfvhy9evWCSqXChAkTUFtb22i5W4fICIKgH96kUqluW7NOp8PixYvxxBNPNHlPqVQa/JnY2Fjk5+fjww8/hI+PD2xsbBAWFtakrga3a7Zunn+7/RBFsdl1G6thXWvXrsX999/f6L2bmxljbN26Fa+++ipWrFiBsLAw2Nvb47333mt0rQpQ34BlZGTA0tISFy5cwKhRo5pd56JFizB58mTs2bMHe/fuxcKFC/H1119j/PjxLaqNiKitsKkgIjKxn376CWfOnMGrr77a7DJqtRoTJ07ExIkTMWHCBIwaNQpFRUVwcnKClZUVtFpto+WTkpIQGxur/1JZXl6Oy5cvt6iugIAArFu3Tr+dWwUHByMjIwO9evUyep1JSUlYuXIloqKiAABZWVkoKChodnk/Pz9s2LABFRUV+rMVycnJsLCwQO/evY3aZt++faHRaHD69GmEhIQAAP744w8UFxcbXbe7uzu8vLxw6dIlREdHG1zG2toaAJr8Lm6VlJSEIUOG4MUXX9TPM3Rm4fnnn0f//v0xY8YMTJs2DSNGjICfn1+z6+3duzd69+6NV199FZMmTcL69evZVBCRbDj8iYhIQjU1Nbh+/Tqys7Nx6tQpLFmyBGPHjsVjjz2GKVOmGPyZDz74AF9//TXOnTuH8+fPY9u2bfDw8NDf/cfX1xc//vgjrl+/jhs3bgCoH97z7bffIjU1FWlpaZg8eXKTZ2HcyaRJk+Dh4YFx48YhOTkZly5dwvbt23HkyBEAwIIFC7Bx40YsWrQIZ8+eRXp6OrZs2YJ//vOfza6zV69e2LRpE9LT03Hs2DFER0ff9oxIdHQ0lEolpk6dit9++w2JiYl46aWXEBMTA3d3d6P2o2/fvnj44Ycxc+ZMpKSk4PTp05g5cyZUKlWzZ0EMWbRoEZYuXYqPPvoI58+fx5kzZ7B+/Xq8//77AAA3NzeoVCrs27cPubm5KCkpaTaDEydOYP/+/Th//jzmz5+vv8C+wWeffYYjR45g48aNmDx5MiZMmIDo6GiDZ3Sqqqowa9YsHDp0CFeuXEFycjKOHz+Ofv36Gb1vRERtjU0FEZGE9u3bB09PT/j6+mLUqFFITEzExx9/jO+++67ZYTRdunTBf/7zHwwaNAihoaG4fPkyfvjhB1hY1H9kr1ixAgkJCejevTsGDhwIoL4R6dq1K4YMGYLHH38ckZGRja4pMIa1tTUOHDgANzc3REVFYcCAAXj33Xf1dUZGRmL37t1ISEhAaGgoBg8ejPfffx8+Pj7NrvOLL77AjRs3MHDgQMTExGD27Nm3fd6Cra0t9u/fj6KiIoSGhmLChAkYMWIEPv300xbty8aNG+Hu7o5hw4Zh/PjxmDFjBuzt7ZsdpgXUD3lSKP53An/69OlYt24d4uPjMWDAAAwfPhzx8fH6YWsKhQIff/wxVq9ejW7dumHs2LEG1xsXF4cnnngCEydOxP3334/CwsJGZy3OnTuHN998EytXrkT37t0B1DcZxcXFmD9/fpP1WVpaorCwEFOmTEHv3r3x9NNPY/To0Vi8eHGLMiIiakuC2JJBpkRERGbozz//RPfu3XHw4EGMGDHC4DJxcXH4888/sXv3bhNXR0Rk/nhNBRERdTg//fQTysvLMWDAAOTk5GDOnDnw9fXFsGHDmixbVlaG06dP49tvv8W8efNkqJaIyPyxqSAiog6nrq4O8+bNw6VLl2Bvb48hQ4Zg8+bNBh8Qt2DBAmzevBnjx49HXFycDNUSEZk/Dn8iIiIiIqJW4YXaRERERETUKmwqiIiIiIioVdhUEBERERFRq7CpICIiIiKiVmFTQURERERErcKmgoiIiIiIWoVNBRERERERtQqbCiIiIiIiapX/D/4WQteddOraAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "#Total number of electrons vs Lorentz factor \n", "plt.figure(figsize=(8,5))\n", - "plt.plot(jet.x, (jet.U_b_x / jet.U_e_x), color='green', lw=2)\n", - "plt.xlabel(\"Distance along jet x [cm]\")\n", - "plt.ylabel(\"U_e(x) / U_B(x)\")\n", - "plt.title(\"Equipartition Ratio Along the Jet\")\n", - "plt.xscale('linear')\n", - "plt.yscale('linear')\n", + "for i, N_e_gamma in enumerate((n0[:,::60].T)*np.exp((-cooling[:,::60].T).value)):\n", + " plt.loglog(jet.x, N_e_gamma, label =f'gamma = {jet.gamma_e[60*i]}' )\n", + "plt.xlabel(\"Distance along Jet axis\")\n", + "plt.ylabel(\"Number of Electrons\")\n", + "plt.title(\"Electron distribution for different Gamma's vs Distance\")\n", "plt.grid(True, which='both', ls='--')\n", - "plt.ylim(1,6)\n", + "#plt.xlim(10,1e4)#\n", + "plt.ylim(1e-20,1e43)\n", "plt.tight_layout()\n", + "#plt.legend()\n", "plt.show()" ] }, @@ -248,17 +322,7 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "1d7a5cb4", - "metadata": {}, - "outputs": [], - "source": [ - "from agnpy.synchrotron import SynchrotronCone" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "17ea534c", "metadata": {}, "outputs": [], @@ -277,13 +341,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "314bc1f0", "metadata": {}, "outputs": [], "source": [ "#Dermer's Method\n", - "syn = SynchrotronCone(jet, nu_obs, ssa=True)" + "syn = Synchrotron(jet)" ] }, { @@ -293,29 +357,10 @@ "metadata": {}, "outputs": [], "source": [ - "flux = syn.flux_obs(nu_obs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4b9cfea9", - "metadata": {}, - "outputs": [], - "source": [ + "flux = syn.flux_obs(nu_obs)\n", "syn.evaluate_attenuation()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "18459362", - "metadata": {}, - "outputs": [], - "source": [ - "sed_no_ssa = syn.sed_flux(nu_obs)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -323,12 +368,13 @@ "metadata": {}, "outputs": [], "source": [ - "sed_ssa = syn.sed_flux(nu_obs, ssa=True)" + "sed_ssa = syn.sed_flux(nu_obs, ssa=True)\n", + "sed_nossa = syn.sed_flux(nu_obs, ssa=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "1c9c18f6", "metadata": {}, "outputs": [], @@ -343,25 +389,6 @@ "P_total_cotter = (prefactor * int_y)" ] }, - { - "cell_type": "markdown", - "id": "90435974", - "metadata": {}, - "source": [ - "# Total Jet Power\n", - "*Using the same parameters as used in Table 1 of Potter and Cotter; the total Jet power differs by 1 order of magnitude, why is this discrepancy?*" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8db56eac", - "metadata": {}, - "outputs": [], - "source": [ - "jet.P_total_jet.to('W')" - ] - }, { "cell_type": "markdown", "id": "69caf6bd", @@ -372,10 +399,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "425ccfd5", "metadata": {}, - "outputs": [], + "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", @@ -423,10 +461,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "bf432d89", "metadata": {}, - "outputs": [], + "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", @@ -475,7 +524,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "base", "language": "python", "name": "python3" }, @@ -489,7 +538,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.12.2" } }, "nbformat": 4, From 7e863bf3ab6e3dcb0265f750dea9f89c7df8d72d Mon Sep 17 00:00:00 2001 From: Udai Sharma Date: Thu, 2 Apr 2026 13:11:09 +0200 Subject: [PATCH 4/5] Update cone.py Implemented class method which uses jet power to set the radius and initialise the cone. [ci skip] --- agnpy/emission_regions/cone.py | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/agnpy/emission_regions/cone.py b/agnpy/emission_regions/cone.py index f9d7052d..fd6dce3f 100644 --- a/agnpy/emission_regions/cone.py +++ b/agnpy/emission_regions/cone.py @@ -49,14 +49,13 @@ class Cone: ## Keeping the default parameters same as defined in Blob (CΟNFIRM FOR NEW PARAMETERS!!!!) def __init__( self, - W_j =(1e34 * u.W).to('erg s-1'), - A_equi = 1.0, 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, - B_o=1 * u.G, n_e : ParticleDistribution = PowerLaw(mass=m_e), xi=1.0, gamma_e_size=200, @@ -66,21 +65,36 @@ def __init__( if not isinstance(delta_D, numbers.Number) or delta_D <= 0: raise ValueError("delta_D must be a positive number") - self.W_j = W_j.to('erg s-1') - self.A_equi = A_equi self.L = L.to("cm") + self.R_o = R_o + self.B_o = 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.B_o = B_to_cgs(B_o) 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) + + #@property + #def R_o(self): + # """Radius at base derived from lab frame jet power and equipartition""" + # u_B = ((self.B_o**2)/(8*np.pi)).to('erg cm-3') + # R_o_squared = (self.W_j)/(2*u_B*np.pi*(self.Gamma**2)*c.cgs) + # return np.sqrt(R_o_squared).to('cm') + ## 1. Jet Structure @property def V_c(self): @@ -88,12 +102,6 @@ def V_c(self): 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_o(self): - """Radius at base derived from lab frame jet power and equipartition""" - u_B = ((self.B_o**2)/(8*np.pi)).to('erg cm-3') - R_o_squared = (self.W_j)/(2*u_B*np.pi*(self.Gamma**2)*c.cgs) - return np.sqrt(R_o_squared).to('cm') @property def R_x(self): From 3109a1f162daab8d843ea41b469168d29f93f1fb Mon Sep 17 00:00:00 2001 From: Udai Sharma Date: Mon, 4 May 2026 14:05:47 +0200 Subject: [PATCH 5/5] implemented Chang and Cooper Solver to model electron distribution Changes implemented: 1. The electron distribution evolves using the chang and cooper solver. 2. SED can be plotted for particular x using sed_spatial Problems: 1. Electron distribution is affected significantly by cooling even for low gammas 2. SED remains flat for broad frequencies 3. SED from particular slices have same peak frequency even for high x --- agnpy/emission_regions/cone.py | 85 +- agnpy/synchrotron/BaseSynchrotron.py | 121 ++- agnpy/synchrotron/synchrotron_cone.py | 2 +- agnpy/utils/numerical_methods.py | 86 ++ electron_evolution.ipynb | 1189 ++++++++++++++++++++----- numerical_evolution.ipynb | 1001 +++++++++++++++++++++ 6 files changed, 2186 insertions(+), 298 deletions(-) create mode 100644 agnpy/utils/numerical_methods.py create mode 100644 numerical_evolution.ipynb diff --git a/agnpy/emission_regions/cone.py b/agnpy/emission_regions/cone.py index fd6dce3f..f7b50db2 100644 --- a/agnpy/emission_regions/cone.py +++ b/agnpy/emission_regions/cone.py @@ -6,6 +6,11 @@ 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 @@ -13,8 +18,11 @@ 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: @@ -30,7 +38,7 @@ class Cone: Initial radius at the base of the cone L : :class:`~astropy.units.Quantity` Length of the Jet - theta_OPEN : class:`~astropy.units.Quantity` + theta : class:`~astropy.units.Quantity` Opening angle of the cone z : float redshift of the source @@ -67,7 +75,7 @@ def __init__( self.L = L.to("cm") self.R_o = R_o - self.B_o = B_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 @@ -87,37 +95,41 @@ def from_jet_power(cls, W_j, **kwargs ): 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) - - #@property - #def R_o(self): - # """Radius at base derived from lab frame jet power and equipartition""" - # u_B = ((self.B_o**2)/(8*np.pi)).to('erg cm-3') - # R_o_squared = (self.W_j)/(2*u_B*np.pi*(self.Gamma**2)*c.cgs) - # return np.sqrt(R_o_squared).to('cm') ## 1. Jet Structure @property def V_c(self): - """Volume of the cone.""" + """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): - x = np.logspace(np.log10(1), np.log10(self.L.to_value("cm")), self.x_size) * u.cm - return x + """Spatial grid modified for Chang and Cooper numerical scheme""" + return self.x_cc[1:] @property - def gamma_e(self): + 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( @@ -125,6 +137,12 @@ def gamma_e(self): #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 @@ -134,35 +152,35 @@ def gamma_e_external_frame(self): ## 3. Electron Properties: Number Density, Total Number, Energy Density, Total Energy @property def n_e_base(self): - """Electron distribution as obtained by agnpy.spectra + """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) - - @property - def N_e_base(self): - """Number of electrons at the base in a slice of width 1 cm""" - return self.n_e_base * np.pi * (self.R_o**2) + 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 at the base to - Electron Energy. + to impose equipartition. Obtained by equating magnetic energy density at the base to + electron energy density. units: cm-3""" - e_energy_initial = np.trapz(self.gamma_e * self.N_e_base, self.gamma_e) - K_dash = ( np.pi * self.R_o**2 * (self.B_o ** 2) ) / (8 * np.pi * mec2 * e_energy_initial ) + 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 as described in Eq 11 in Cotter[2018] - Returns: the number of electrons per cm at position x along the jet axis""" - n0 = self.norm_equi * self.N_e_base[None,:] # (1, N_gamma) - int_B = cumulative_trapezoid((self.B_x)**2, self.x, initial=0) # (N_x, 1) - cooling = ( sigma_T.cgs * self.gamma_e[None,:] *(int_B[:,None])) / ( 6 * np.pi * mec2.cgs ) - N_e_xg = n0 * np.exp(-cooling.value) - return (N_e_xg).cgs + """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): @@ -223,7 +241,6 @@ 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. diff --git a/agnpy/synchrotron/BaseSynchrotron.py b/agnpy/synchrotron/BaseSynchrotron.py index 321f9b57..f66915b8 100644 --- a/agnpy/synchrotron/BaseSynchrotron.py +++ b/agnpy/synchrotron/BaseSynchrotron.py @@ -7,22 +7,23 @@ from ..radiative_process import RadiativeProcess e = e.gauss -#Common Utility Functions +# ============================================================ +# 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): - """observed peak frequency for monoenergetic electrons - Eq. 7.19 in [DermerMenon2009]_""" + """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): - """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. - """ + """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) @@ -30,12 +31,11 @@ def Z(eta): return term_1_num / term_1_denom * term_2_num / term_2_denom * np.exp(-eta) def tau_to_attenuation(tau): - """Converts the synchrotron self-absorption optical depth to an attenuation + """Convert SSA optical depth → attenuation factor. Eq. 7.122 in [DermerMenon2009]_.""" - u = 1 / 2 + np.exp(-tau) / tau - (1 - np.exp(-tau)) / np.power(tau, 2) + 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) -#Utility Functions for Blob def epsilon_B(B): r""":math:`\epsilon_B`, Eq. 7.21 [DermerMenon2009]_""" return (B / B_cr).to_value("") @@ -62,7 +62,6 @@ def calc_eta(B_cgs, epsilon, gamma, mass=m_e): ) return eta.value -#Utility Functions for Cone def eta(nu_fluid, nu_peak): """Calculates ration of frequency to critical synchrotron frequency for Conical Jet Model""" @@ -77,14 +76,39 @@ def P_sync( 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). + Compute synchrotron emission for a conical jet. - Implements: + 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) + """ - Note: Input correctly shaped arrays (B_x, gamma_e, N_e_xg, nu_obs) as per emitter geometry - """ # Calculate Synchrotron Peak nu_peak = nu_synch_peak(B_x, gamma_e) #Calculate Eta @@ -96,11 +120,16 @@ def P_sync( gamma_e, axis=1 ) - # --- prefactor √3 e³ B / (m c²) --- + # --- 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 Z_eta, P_synch.to("erg Hz-1 s-1") + 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 @@ -128,22 +157,19 @@ def __init__(self, emitter, ssa=False, integrator=np.trapz): def __getattr__(self, name): return getattr(self._model, name) - + +# ============================================================ +# 🔹 Synchrotron Cone Model +# ============================================================ + class SynchrotronCone(RadiativeProcess): - """Class for synchrotron radiation computation + """ + Synchrotron emission from a conical jet. - 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`) + Produces: + - F_nu → observed flux density + - F_nu(x) → spatially resolved flux + - nuF_nu → SED """ def __init__(self, emitter, ssa=False, integrator=np.trapz): @@ -152,20 +178,36 @@ def __init__(self, emitter, ssa=False, integrator=np.trapz): 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) - self.Z_eta, L_v_fluid = P_sync(nu_fluid_reshaped, + 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""" @@ -193,13 +235,14 @@ def evaluate_attenuation(self): 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) - integrand = np.gradient( n_e_xg_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)**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 - 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.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) @@ -209,6 +252,12 @@ def sed_flux(self, nu_obs, ssa=False): 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 """ diff --git a/agnpy/synchrotron/synchrotron_cone.py b/agnpy/synchrotron/synchrotron_cone.py index 16f2d53d..568a8367 100644 --- a/agnpy/synchrotron/synchrotron_cone.py +++ b/agnpy/synchrotron/synchrotron_cone.py @@ -1,4 +1,4 @@ -import numpy as np + 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 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 index 00fd53fb..452e5086 100644 --- a/electron_evolution.ipynb +++ b/electron_evolution.ipynb @@ -15,9 +15,11 @@ "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" ] }, @@ -38,9 +40,11 @@ "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", - "W_j = 7.63 * 1e36 * u.W\n", - "L = (1e19 * u.m).to(u.cm)\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", @@ -48,78 +52,68 @@ "# Electron Distribution imposed by Potter and Cotter\n", "p = 2\n", "gamma_minimum = (5.11 * 1e6 * u.eV / mec2.to(\"eV\")).value\n", - "gamma_maximum = (5.6 * 1e9 * u.eV / mec2.to(\"eV\")).value\n", - "\"\"\"The normalization parameter is left to default, eq (7) in C. & P. leads to norm = 0? since alpha = 2\"\"\"\n", - "n_e = ExpCutoffPowerLaw(k=100, p = p, gamma_min = 0.1*gamma_minimum, gamma_max= 100*gamma_maximum, gamma_c= gamma_maximum )" + "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": "07d692e6", + "id": "26db094b", "metadata": {}, "outputs": [], "source": [ - "jet = Cone(B_o = B_o, W_j = W_j, L = L, theta = theta_open, Gamma=Gamma, n_e = n_e,x_size=500,gamma_e_size=500, z =z)\n", - "jet.set_delta_D(Gamma=Gamma,theta_s = theta_s)" - ] - }, - { - "cell_type": "markdown", - "id": "e66b35d3", - "metadata": {}, - "source": [ - "Formula used by Cotter and Potter (equation 8) yields the same R_o but in the Parameter table, R_o is mentioned as 7.32 * 1e13 m \n", - "which (coincidentally?) is compatible with our jet with W_j = 0.1* W_j" + "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": "eed5ef62", + "id": "19607d77", "metadata": {}, "outputs": [ { "data": { - "text/latex": [ - "$2.3162959 \\times 10^{16} \\; \\mathrm{cm}$" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 4, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "jet.R_o" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "6278f724", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$2.3162959 \\times 10^{14} \\; \\mathrm{m}$" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "Ro_using_cotter = (np.sqrt((2 *mu0 * 7.63 * 1e36 * u.W ) / (2 * c * 144 * np.pi * (3.63 * 1e-5 * u.T)**2 ))).to('m')\n", - "Ro_using_cotter" + "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" ] }, { @@ -132,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "239e39d6", "metadata": {}, "outputs": [], @@ -165,52 +159,57 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "e2f2b416", + "execution_count": 6, + "id": "c04e7deb", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "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": "display_data" + "output_type": "execute_result" } ], "source": [ - "energy = (mec2.cgs * jet.gamma_e).to('eV')\n", - "linear_interp = interp1d(x_data, y_data, kind=\"linear\") # degree = number of points - 1\n", - "y_linear = linear_interp(energy.value[5:445])\n", - "\n", - "plt.scatter(x_data, y_data, color=\"black\")\n", - "plt.loglog(energy.value[5:445], y_linear, label=\"Linear\", color=\"red\")\n", - "plt.legend(); plt.title(\"Linear 1D Interpolation\")\n", - "plt.ylim(1e30,1e50)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "888db6b3", - "metadata": {}, - "source": [ - "The following plot shows how energy is distributed among electrons, because high-energy electrons carry more energy. This is to show which energies dominate the total electron energy.\n" + "jet.N_e_xg" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "ead512c1", + "execution_count": 7, + "id": "6db0cb8b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -218,175 +217,515 @@ } ], "source": [ - "plt.figure(figsize=(8,5))\n", - "#for i, _n_e_g in enumerate(jet.N_e_xg[::20]):\n", - " #plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*3*1e10*_n_e_g, label=f\"x={i}\",linestyle='dashed')\n", - "plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*(c.cgs.value)* jet.N_e_xg[0,:] , label=\"x = 0 \",linestyle='-',color='red')\n", - "plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*(c.cgs.value)*jet.N_e_xg[349,:] , label=\"x = intermediate \",linestyle='-',color='skyblue')\n", - "plt.loglog((mec2*jet.gamma_e).to('eV'), jet.gamma_e*(c.cgs.value)* jet.N_e_xg[-1,:] , label=\"x = L \",linestyle='-',color='brown')\n", - "plt.loglog(x_data, y_data, label=f\"C&P \",linestyle='dashed',color='pink')\n", - "#plt.plot((mec2*jet.gamma_e).to('eV'), jet.norm_equi*3*1e10*jet.N_e_base)\n", - "plt.xlabel('Electron Energy (eV)')\n", + "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()\n", - "plt.xlim(1e5,1e12)\n", - "plt.ylim(1e30,1e50)\n", + "plt.legend(fontsize=4)\n", + "plt.ylim(1e-10,1e50)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 95, - "id": "c2ae9201", - "metadata": {}, - "outputs": [], - "source": [ - "n0 = jet.norm_equi * jet.N_e_base[None,:] # (1, N_gamma)\n", - "int_B = cumulative_trapezoid((jet.B_x)**2, jet.x, initial=0) # (N_x, 1)\n", - "cooling = ( sigma_T.cgs * jet.gamma_e[None,:] *(int_B[:,None])) / ( 6 * np.pi * mec2.cgs )" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "a48e552e", + "execution_count": 8, + "id": "b4fa2e2d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "text/latex": [ + "$1.0792528 \\times 10^{21} \\; \\mathrm{cm}$" + ], "text/plain": [ - "
" + "" ] }, + "execution_count": 8, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "plt.figure(figsize=(8,5))\n", - "# Select every 70th gamma column, then transpose so we can iterate over columns\n", - "for i, cooling_gamma in enumerate(np.exp(-cooling.value[:, ::50].T)):\n", - " plt.loglog(jet.x, cooling_gamma, label=f'gamma = {jet.gamma_e[50*i]}',linestyle='dashed')\n", - "plt.xlabel(\"Distance along Jet axis\")\n", - "plt.ylabel(\"Cooling Factor\")\n", - "plt.title(\"Cooling vs Distance\")\n", - "plt.grid(True, which='both', ls='--')\n", - "plt.ylim(1e-3, 10)\n", - "plt.tight_layout()\n", - "plt.legend()\n", - "plt.show()" + "(10000000*u.h).cgs*c.cgs" ] }, { "cell_type": "code", - "execution_count": 133, - "id": "5fed4dc4", + "execution_count": null, + "id": "314bc1f0", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "#Total number of electrons vs Lorentz factor \n", - "plt.figure(figsize=(8,5))\n", - "for i, N_e_gamma in enumerate((n0[:,::60].T)*np.exp((-cooling[:,::60].T).value)):\n", - " plt.loglog(jet.x, N_e_gamma, label =f'gamma = {jet.gamma_e[60*i]}' )\n", - "plt.xlabel(\"Distance along Jet axis\")\n", - "plt.ylabel(\"Number of Electrons\")\n", - "plt.title(\"Electron distribution for different Gamma's vs Distance\")\n", - "plt.grid(True, which='both', ls='--')\n", - "#plt.xlim(10,1e4)#\n", - "plt.ylim(1e-20,1e43)\n", - "plt.tight_layout()\n", - "#plt.legend()\n", - "plt.show()" + "nu_obs = np.logspace(3, 25, 1000) * u.Hz\n", + "syn= Synchrotron(jet)\n", + "flux = syn.flux_obs(nu_obs)" ] }, { - "cell_type": "markdown", - "id": "f02c166c", + "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": [ - "# Validating Dermer formula with Cotter and Potter's Formula\n", - "Integrating Dermer's equation for Synchrotron power across frequencies to check if it matches with Cotter and Potter's formula for Synchrotron power\n" + "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": 12, - "id": "17ea534c", + "execution_count": 10, + "id": "70358537", "metadata": {}, "outputs": [], "source": [ - "nu_obs = np.logspace(3, 20, 1000) * u.Hz" + "sed_nossa= syn.sed_flux(nu_obs, ssa=False)" ] }, { - "cell_type": "markdown", - "id": "250662aa", + "cell_type": "code", + "execution_count": 11, + "id": "6f2b1cfe", "metadata": {}, + "outputs": [], "source": [ - "# Dermer's Appraoch vs Cotter's Approach\n", - "Comparison between Synchrotron Power integrated over all frequencies. P_total_cotter overestimates by a little due to the assumption of all frequencies emitted at a particular frequency making the edges a bit sharper, compared to Dermer's Approach" + "syn.evaluate_attenuation()\n", + "sed_ssa= syn.sed_flux(nu_obs, ssa=True)" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "314bc1f0", + "execution_count": 12, + "id": "7a8de071", "metadata": {}, "outputs": [], "source": [ - "#Dermer's Method\n", - "syn = Synchrotron(jet)" + "nu_peak= syn.nu_peak()" ] }, { "cell_type": "code", - "execution_count": null, - "id": "621e265b", + "execution_count": 13, + "id": "e0c57665", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "flux = syn.flux_obs(nu_obs)\n", - "syn.evaluate_attenuation()" + "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": null, - "id": "70358537", + "execution_count": 30, + "id": "774e044e", "metadata": {}, "outputs": [], "source": [ - "sed_ssa = syn.sed_flux(nu_obs, ssa=True)\n", - "sed_nossa = syn.sed_flux(nu_obs, ssa=False)" + "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": 19, - "id": "1c9c18f6", + "execution_count": 12, + "id": "2b2df5ae", "metadata": {}, - "outputs": [], + "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": [ - "#Cotter and Potter's Approach to Calculate P_sync over all frequencies\n", - "prefactor = (sigma_T.cgs * c.cgs) / (6*np.pi)\n", - "n = jet.N_e_xg\n", - "B = jet.B_x[:, None]\n", - "R = jet.R_x[:, None]\n", - "int_x = np.trapz(n * (B**2), jet.x,axis=0)\n", - "int_y = np.trapz(jet.gamma_e**2 * int_x, jet.gamma_e)\n", - "P_total_cotter = (prefactor * int_y)" + "Z_eta[0,0,:]" ] }, { @@ -399,13 +738,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "id": "425ccfd5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -442,18 +781,18 @@ "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_no_ssa, color='blue', lw=1, label='Model SED w/o SSA')\n", - "#plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_cotter, color='green', lw=2, label='Model SED')\n", - "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_ssa, color='red', lw=1, label='Model SED w SSA')\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='dotted', color='green',label='BL Lac C&P')\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-9)\n", - "plt.xlim(1e-8,1e6)\n", + "plt.ylim(1e-14, 1e-8)\n", + "#plt.xlim(1e-8,1e6)\n", "plt.legend()\n", "plt.tight_layout()\n", "plt.show()" @@ -461,13 +800,161 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "bf432d89", + "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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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkwAAAHpCAYAAABwXWMDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC31klEQVR4nOydeVgUV/b3v1W9giAuIIoC7mhcQHEJGBfcEEyiZl/GmEx2k8k+k2Qyv6yTccZkTDJvNNFkJmabxJhEZyaSQCsoGjQaCS4QNyAREBU0ytpbdb1/dKrsprvpauitbt3P8/ggh+qq8+Vcbt++99xzGZ7neVAoFAqFQqFQPMKG2gEKhUKhUCiUcIcOmCgUCoVCoVC8QAdMFAqFQqFQKF6gAyYKhUKhUCgUL9ABE4VCoVAoFIoX6ICJQqFQKBQKxQt0wEShUCgUCoXiBTpgolAoFAqFQvECHTBRKBQKhUKheIEOmCgUihPfffcdlixZgqSkJOh0OsTHxyMjIwOPP/54qF3D+vXrwTAMvv/++4A/69SpU3j++edRVlYW8Gd1hZqaGixfvhwjR45EREQE+vTpg3HjxuHuu+9GTU2NeN3zzz8PhmE8/vvpp5/Eax3tKpUKvXv3RmpqKu69917s2bMnBCoplPBBHWoHKBRK+LBlyxZcffXVmDVrFlauXIkBAwagvr4e33//PT799FP8/e9/D7WLQePUqVN44YUXMHjwYKSlpYXaHSdqa2sxceJE9OrVC48//jhSUlJw8eJFVFRU4LPPPkNVVRUSExOdXvPNN98gJibG5V4DBgxw+v66667D448/Dp7n0dTUhMOHD+ODDz7AunXr8NBDD+GNN94IqDYKJVyhAyYKhSKycuVKDBkyBPn5+VCrL3UPN910E1auXBlCz/xDe3s7IiIiAnLvtrY2REZGBuTeHXnnnXfQ2NiIvXv3YsiQIaJ98eLF+OMf/wibzebymvT0dMTGxnq9d3x8PC6//HLx++zsbDzyyCO455578I9//AOjRo3C/fff7x8hFIqMoEtyFApF5Ny5c4iNjXUaLAmw7KXu4s4770SfPn3Q1tbmct3s2bMxZswY8XuGYfDggw/iww8/xOjRoxEZGYnU1FR89dVXLq89cuQIbr75ZsTHx0On0yEpKQm33XYbTCaT03XNzc24//77ERsbi759++Kaa67BqVOnnK4ZPHgwrrzySnz55ZeYMGEC9Ho9XnjhBQDA4cOHsWjRIvTu3Rt6vR5paWl4//33xddu374dkydPBgDccccd4jLV888/DwC4/fbbERUVhUOHDmH+/PmIjo7GnDlzAADnz5/H8uXLMXDgQGi1WgwdOhTPPPOMiwZffi8dOXfuHFiWRb9+/dz+3DFW/kClUuHNN99EbGwsXnnlFb/em0KRDTyFQqH8yl133cUD4H/3u9/xe/bs4c1ms9vrDhw4wAPg33nnHSd7eXk5D4BfvXq1aAPADx48mJ8yZQr/2Wef8Xl5efysWbN4tVrNV1ZWiteVlZXxUVFR/ODBg/m3336b37ZtG//RRx/xN9xwA9/U1MTzPM+/9957PAB+6NCh/O9+9zs+Pz+ff/fdd/nevXvzWVlZTr4kJyfzAwYM4IcOHcr/61//4ouKivi9e/fyR44c4aOjo/lhw4bxH3zwAb9lyxb+5ptv5gHwf/vb33ie5/mLFy+Kz/rTn/7E7969m9+9ezdfU1PD8zzPL1u2jNdoNPzgwYP5FStW8Nu2bePz8/P59vZ2fvz48XyPHj34V199lS8oKOD/7//+j1er1Xxubq6Tf1J/L+746KOPeAD8/Pnz+W+++Ya/ePGix2ufe+45HgB/+vRp3mKxOP2zWq0uPj3wwAMe73XTTTfxAMTfA4WiJOiAiUKhiDQ2NvJXXHEFD4AHwGs0Gj4zM5NfsWIF39zc7HTtzJkz+bS0NCfb/fffz/fs2dPpWgB8fHy8OOjheZ4/ffo0z7Isv2LFCtE2e/ZsvlevXvzZs2c9+icMYpYvX+5kX7lyJQ+Ar6+vF23Jycm8SqXijx496nTtTTfdxOt0Ov7kyZNO9pycHD4yMpK/cOECz/M8v2/fPh4A/95777n4sWzZMh4A/69//cvJ/vbbb/MA+M8++8zJ/re//Y0HwBcUFPj8e3GHzWbj7733Xp5lWR4AzzAMP3r0aP7RRx/lq6urna4VBkzu/g0bNszpWm8DpieffJIHwH/33Xed+kehkAhdkqNQKCJ9+/bFzp07sW/fPvz1r3/FokWLcOzYMTz99NMYN24cGhsbxWsffvhhlJWV4dtvvwUANDU14cMPP8SyZcsQFRXldN+srCxER0eL38fHx6Nfv374+eefAdjzf3bs2IEbbrgBcXFxXv28+uqrnb4fP348AIj3c7SPHDnSyVZYWIg5c+a4JEXffvvtaGtrw+7du70+X+Daa691uXePHj1w3XXXudwbALZt2+Zk9/Z78QTDMHj77bdRVVWFNWvW4I477oDFYsFrr72GMWPGYMeOHS6v2bp1K/bt2+f0b/PmzZK1AgDP8z5dT6GQBE36plAoLkyaNAmTJk0CAFgsFjz55JN47bXXsHLlSjH5e9GiRRg8eDBWr16NadOmYf369WhtbcUDDzzgcr++ffu62HQ6Hdrb2wEAv/zyCziOw6BBgyT51/F+Op0OAMT7CXTcAQbY83/c2RMSEsSfSyEyMhI9e/Z0uXf//v3BMIyTvV+/flCr1S739vZ78UZycrJTAvZnn32Gm2++Gb///e+xd+9ep2tTU1MlJX13hjCQE35XFIqSoDNMFAqlUzQaDZ577jkA9mRpAZZl8cADD+Dzzz9HfX091qxZgzlz5iAlJcXnZ/Tp0wcqlQq1tbV+8xuAy8AFsA9S6uvrXexC0rjUQYWne585c8ZlJubs2bOwWq3dHrB444YbbsD48eOd4uQv2tvbsXXrVgwbNkzywJZCIQk6YKJQKCLuBhIA8OOPPwJwnVm46667oNVqceutt+Lo0aN48MEHu/TciIgIzJw5Exs3bnRa9gsEc+bMQWFhocuuug8++ACRkZHilnpPs1be7t3S0uKy1PXBBx+IP/cHnuLU0tKCmpoav88AcRyHBx98EOfOncOTTz7p13tTKHKBLslRKBSR7OxsDBo0CFdddRVGjRoFm82GsrIy/P3vf0dUVBQefvhhp+t79eqF2267DW+99RaSk5Nx1VVXdfnZq1atwhVXXIGpU6fiqaeewvDhw3HmzBn897//xdq1a51yfbrDc889h6+++gpZWVl49tln0adPH3z88cfYsmULVq5cKRZ3HDZsGCIiIvDxxx9j9OjRiIqKQkJCQqeDkdtuuw2rV6/GsmXL8NNPP2HcuHHYtWsX/vKXvyA3Nxdz5871i4aXX34Z3377LW688UakpaUhIiIC1dXVePPNN3Hu3Dm3W//379/vtnDlZZdd5rS0eObMGezZswc8z6O5uVksXHngwAE8+uijuPvuu/2igUKRHSFOOqdQKGHEhg0b+FtuuYUfMWIEHxUVxWs0Gj4pKYlfunQpX1FR4fY127dv5wHwf/3rX93+HB52XiUnJ/PLli1zslVUVPDXX38937dvX16r1fJJSUn87bffzhuNRp7nL+2S27dvn9PrioqKeAB8UVGR0/0XLlzo1qdDhw7xV111FR8TE8NrtVo+NTXV7W64Tz75hB81ahSv0Wh4APxzzz3H87x9l1yPHj3c3vvcuXP8fffdxw8YMIBXq9V8cnIy//TTT4sauvJ76ciePXv4Bx54gE9NTeX79OnDq1QqPi4ujl+wYAGfl5fndG1nu+QA8AaDwckn4R/LsnzPnj35cePG8ffccw+/e/fuTn2iUEiH4Xm67YFCoXSdxx9/HG+99RZqamrcJjFTKBQKCdAlOQqF0iX27NmDY8eOYc2aNbj33nvpYIlCoRCNomeYXnvtNbz77rvgeR5z587FG2+84XbnC4VCcYVhGERGRiI3NxfvvfeeS+0lCoVCIQnFzjA1NDTgzTffRHl5OTQaDWbMmIE9e/YgIyMj1K5RKLJAwZ+1KBSKAlHsgAkArFYrjEYjAHtxPk8HWVIoFAqFQlE2YVuHqbi4GFdddRUSEhLAMIzbEv5r1qzBkCFDoNfrkZ6ejp07d0q+f1xcHJ544gkkJSUhISEBc+fOxbBhw/yogEKhUCgUCimE7QxTa2srUlNTcccdd7ic1wQAGzZswCOPPII1a9Zg2rRpWLt2LXJyclBRUYGkpCQAQHp6Okwmk8trCwoKEBERga+++go//fQTIiIikJOTg+LiYsyYMcOtPyaTyeleNpsN58+fR9++fWneE4VCoVAoMoT/td5YQkICWNbLHFIISxpIBgC/adMmJ9uUKVP4++67z8k2atQo/qmnnpJ0z88++8zpxPOVK1fyf/vb3zxe762WCf1H/9F/9B/9R//Rf/L8V1NT43XcELYzTJ1hNpuxf/9+PPXUU072+fPno6SkRNI9EhMTUVJSAqPRCI1Gg+3bt+Oee+7xeP3TTz+Nxx57TPz+4sWLSEpKQnV1tViBmGVZqFQqcBwHm80mXivYrVarU6KsSqUCy7Ie7RaLxckHtdoeLqvVKsmu0Whgs9nAcZxoYxgGarXayW6xWFBUVIT58+eDZVm3vstNk6Pdk+9GoxHbtm1DVlYWNBoNEZqkxMkx3gzDEKHJ0XdP9ra2NhQVFYnxJkGTlDgJ8Z43b57LbLhcNXW03zW+FJtPTcVfryzG/R/PgM1mg9FoFOOt1Wplp8kRX+JktVpRWFiIOXPmQKVSEaEpkH15c3MzhgwZIukkAVkOmBobG8FxHOLj453s8fHxOH36tKR7XH755cjNzcWECRPAsizmzJmDq6++2uP1Op1OPFvKkejoaPFYAbk2SJ7nsXjxYuj1ethsNmI6Dm9/ZJGRkVi0aBHUajUYhiFCk5Q48TyPa665BlqtFhzHEaHJ0XdPdr1e7xRvEjRJiRPP87j22mtFf0jQ1NEerdcD6AlwkejZsydsNpvT3zfLsrLT5IgvcQKA6667zuXDkJw1BbovF57hDVkOmAQ6CuR53qd8opdffhkvv/yyT89cvXo1Vq9eLQazoKAAkZGRAICkpCRMmDABBw8exMmTJ8XXpKSkYNSoUdi7dy8aGhpEe1paGpKTk1FcXIzm5mbRnpGRgX79+qGgoMCpkWVlZSEiIgJ5eXlOPuXm5qK9vR1FRUWiTa1WY+HChWhsbMTu3btFe3R0NGbPno2amhqUlZWJ9t69e2P69Ok4fvw4jh49KtrlrCkuLg6ZmZkeNR06dIg4TVLjlJKSgpSUFKI0eYuTwWAgTpPUOE2fPh0qlQrbt28nRpNjnKxm+1tZXd15ACBCk0BX4jR27FjU1dXh2LFjxGgKVF/e1tYGqciicCXDMNi0aRMWL14MwL4kFxkZiY0bN2LJkiXidQ8//DDKysqwY8eOgPvU1NSEmJgYNDY2yn6GyWKxwGAwIDc3V3FLcvn5+Zg3b57iluSEeCttSc5gMIjxJkGT1CU5g8GAnJwcYpfknpj8Lf5xYBaevLwQf909W1ySE+KttCW5goICZGdnK2pJrqt9eVNTE2JjY3Hx4kWnQ6jdEbZlBTpDq9UiPT0dBoPByW4wGJCZmRkirygUCoUSCnQ6+5uo0STLtzSKTAjbJbmWlhacOHFC/L66uhplZWXo06cPkpKS8Nhjj2Hp0qWYNGkSMjIysG7dOpw8eRL33XdfQP0idUlOgLSp6c6mccvLywFAHHiToElqnARI0uQtToKPQrxJ0CQ1ToC9T3WsVSd3TY5xamu1z3Y0Nrb++vWSJoPBIEtNAr7GKTY2FgBQWVnp9B4qZ02B7MuJWJLbvn07srKyXOzLli3D+vXrAdgLV65cuRL19fUYO3YsXnvtNY91lPwNaUtyhYWFyM7OVtyS3NatWzF79mzFLckJ8VbaklxhYaEYbxI0SV2SKywsFHdFkqCpo/3Vq3bij/mzsWzYTqw/MV1ckhPirbQlOSXukutqX+7LklzYzjDNmjXL61lVy5cvx/Lly4PkEbloNBosWLDA7S4aktFoNMjOzg61G0FHo9GI+WodOzGSUXK8Fy5cCMD1TYsU9Hr7QNBovrQkp/R4dxxckEywYh22A6ZwhdQluZiYGMyYMYOoqWkSp9v9pWno0KEYM2YMUZpIjJO/NE2ePBk9evQgdpfcuV/sS3EXW+yvI0GTQFfiNHz4cJw7d04xu+S6o4mIJblwh7QlObpLTllLcnSXnLKW5EjfJffhvSW4872ZmN/3e+Q3TqK75OguOWUtyckFjUYDjUbjZFOpVE4NVUBoOFLtHe/bFTvLsmBZ150jnuyefCdVk/AMx+fIXROJcfKnpo7xJkGTFDvDMMRpEuxRMfafmaxq0XfHeAvPkpOmjnQlTu7uI3dN/u7LPfnr9nWSr6S4xWKxiCNtuY7gHZ9D0ictKZ8eHfWToknKDJMAKZocffemSfhKkqbOfBeu4Xne5Xq5aupo1wg5TL8OmGw2m1O85ajJEV9nmAC45KPKWVMg+/KOOjqDDph8hNQcJpVKBYZhiFvL72zdu6KiAoAyywrodDowDEOUJlpWwLOmqKgotLa2ori4mBhNjnH6qbYJQAZazfaZBqWXFYiOjkZVVRWOHz9OhKZA9uU0hykIkJTD5Ggn6ZMW1UQ1UU3K0PTtmkPIemQiRmqqcNQ8lAhNjpASp3DU5EsOEx0wdRFhwCTllxzu2Gw21NTUIDEx0e26MalQ3VS3ElCC7n3vV2DK7ZchSVWLn62DAChDtzuUqLs7mn15L1fGb5PSKRzHoaysTFE1mACqm+pWBkrQrY+yz2IYbTrRpgTd7lCi7mBppjlM3YQmfYenJkc7TfqmSd806ZvspG91D/tn/3bePmCiSd806ZsmfYcBpCZ9C5CU/EjPkqNnyTlqUnLSN0D2WXLNx9oADIcRegA06RugZ8nRpO8wgqSkb6vVitLSUkydOhUMwxDzScvbpxKTyYR9+/YhPT0darWaCE1S4uQYbwBEaHL03ZO9vb0d+/fvF+NNgiYpcRLiPWXKFHRErpo62huPnkPCuP72700cGDUDk8kkxluoxSQnTY74EieO41BaWor09HSnfB45awpkX06TvoMASUnfFAqFImdaTrcgekCU/f9nWtGjX48Qe0SRCzTpm+ITHMfhyJEjikoSBKhuqlsZKEG3vpde/L/xogmAMnS7Q4m6g6WZ5jB1E1KSvo8ePYphw4YBADFT096mcQXdSUlJijtLTog3z/NEaHL03ZPdZDI5xZsETVKTvo8ePYqhQ4c6PVPOmlzsKkANC6zQwHjRBJvN5hRvpZ0ld/ToUQwePJgYTYHsy2nSdwChSd/y0USTvmnSt6MmmvRNbtI3AOgxGy3QwNhkpknfoEnfNOk7jCAp6dvx9HqWZRXzqaQ7J1yHqyapM0xCvBmGIUKTo++e7G1tbeLp9UqbYTIYDMjJyQHDMERocmcfqLuABj4Oh748jssWDYPRaBTjrbQZpoKCAmRnZ0OlunRQrZw1BbIv9yXpm84wdZOOpyMD8jsNmmVZJCUliY3Mne9y0+SIJ981Gg2SkpKg0+mcfi5nTVLi1DHe3fXdkz2YmqTYdTqd23jLWZMU34V4e3qmHDW5s+tZM8ABxmYLWJZ1G2+5aXJEapyEeGs0GmI0CQSiL/fkrzvoDFMXobvkKBQKJXwYqa3GccsQ7Fx9EFcsHx9qdygyge6So/gEx3H44YcfFLWrAqC6qW5loBTdESozAKC9yb5UpBTdHVGi7mBppgMmCmw2G06ePOmyg4Z0qG6qWwkoRbdeZR8oGVvtb5pK0d0RJeoOlmaaw9RNSCkrIEBS8iM9S46eJedOEz1LTv6a3Nn1KvtXY6vdD3qWHD1LjpYVCDG0rIB8NNGyArSsgKMmWlaA7LICLB8HADC2cbSsAGhZAVpWIIwgqawAx3GoqqpCSkoKAOUUrjSbzTh+/DiGDRsm+id3TVLixHEcqqurMXLkSEUVrjQajaisrBTjTYImKXES4j1ixAh07O7lqsmd/brE/fjvmcux9tZi3PXBFTCbzWK81Wq1LDUJ+BInm82G6upqDB061KmMhJw1BbIvp2fJBQG6S45CoVDCh5uSSrChJhNvXLMDD30xM9TuUGQC3SVH8Qmr1YqSkhKXTwCkQ3VT3UpAKbr1WvvMg7HdPgegFN0dUaLuYGmmAyYKeJ5HQ0ODy3Q96VDdVLcSUIruCJ19wNTebv9eKbo7okTdwdJMB0wUCoVCkT16nf3NUhgwUSj+hg6YKBQKhSJ7hAGTycx4uZJC6Rp0wESBSqVCWlqax3PFSIXqprqVgFJ063T2r8KASSm6O6JE3cHSTOswUcCyLJKTk0PtRtChupUF1U02er39q/HXAZNSdHdEibqDpZkOmLoJCZW+hR0GM2fOBMMwxNQj8Va7w2QyYdeuXcjMzIRarSZCk5Q4OcYbABGaHH33ZG9vb0dJSYkYbxI0SYmTEO8ZM2agI3LV5M6u/XVJzmhmYbPZYDKZxHhrNBpZahLwJU4cx6GkpATTpk0Dy15aRJKzpkD25bTSdwAhudI3z/M4ceIEMRVvvVWHPXz4MFpaWlBQUECMJl8qffM8j507dxKjyVucCgsLYbVaxXiToMmXSt/Nzc1EV/o+d74VAGCyqJw0FRQUyFYT0LVK383NzThx4oRiKn13py+nlb6DAEmVvi0WCwwGA3Jzc8GyLDGftLx9KjEajcjPz8e8efOg0WiI0CT1LDkh3gzDEKHJ0XdP9ra2NhgMBjHeJGiSepacwWBATk6OU+VnOWtyZ3//nhLcvX4mcuP24X+n02E0GsV4a7VaWWoS8PUsuYKCAmRnZzvl9MhZUyD7cl8qfdMZpm6i0Wig0WicbCqVym3ymdBwpNo73rcrdpZlnaZlvdk9+U6qJuEZjs+RuyYS4+RPTR3jTYImKXaGYYjT5GjvEWX/arLa3xQd4y08S26aHOlKnNzdR+6a/N2Xe/LXHXSXHAUqlQoZGRmK2lUBUN1UtzJQim5dhP3tzGi1vxkqRXdHlKg7WJrpDBMFLMuiX79+oXYj6FDdyoLqJht9D/ubpZG7NJukBN0dUaLuYGmmM0wUWCwWbNmyxafdAiRAdVPdSkApuvVR9oGSibMvsShFd0eUqDtYmumAiQLANSFPKVDdyoLqJhdd5K8zTLZLOSlK0O0OJeoOhmY6YKJQKBSK7NFH2wdKRps2xJ5QSIUOmCgUCoUie4QBk8kmfdcTheILtA5TFxHqMEmp3RDu8DyP5uZmREdHu9RpIRmqm+pWAkrRfWLbzxgxNxnRaEIT31MxujuiRN3d0ezLezmdYaIAACIiIkLtQkigupUF1U0u+p72pTgj9KJNCbrdoUTdwdBMB0wUWK1W5OXlKS5RkOqmupWAUnTrfi1caYEWNqtNMbo7okTdwdJMB0wUCoVCkT36GJ34f1OTKYSeUEhF0QOmV199FWPGjMHYsWPx0UcfhdodCoVCoXQRfa9LS3HGi3TARPE/iq30fejQIfz73//G/v37AQBz5szBlVdeiV69eoXWMQqFQqH4jFqvBgMbeLAwNZsRhR6hdolCGIrdJffZZ5+huLgYb775JgDggQcewPTp03HTTTdJej1pu+SsVivUarVidlUAVDfVrQyUpDuSaUM7IlG9sxbJ0wYqRrcjSoq3QHc0E7FLrri4GFdddRUSEhLAMAw2b97scs2aNWswZMgQ6PV6pKenY+fOnZLvP3bsWBQVFeHChQu4cOECCgsLUVdX50cF8qK9vT3ULoQEqltZUN1ko2fsS3HGJjMA5ejuiBJ1B0Nz2C7Jtba2IjU1FXfccQeuvfZal59v2LABjzzyCNasWYNp06Zh7dq1yMnJQUVFBZKSkgAA6enpMJlc17ILCgpw2WWX4aGHHsLs2bMRExODyZMnQ632/OswmUxO92pqagJgP8NGOL+GZVmoVCpwHAebzSZeK9itViscJ/RUKhVYlvVo73gujuBfx50AnuwajQY2mw0cx4k2hmGgVqud7BaLBUVFRcjNzQXLsm59l5smR7sn300mE4qKijBv3jxoNBoiNEmJk2O8GYYhQpOj757s7e3tTvEmQZOUOAnxzsnJcfn0LVdNnuw6xgzwQHuz2SneWq1WtpoA3+JktVpRVFSE7OxsqFQqIjQFsi/35fy5sB0w5eTkICcnx+PPV61ahTvvvBN33XUXAOD1119Hfn4+3nrrLaxYsQIAxPwkT9x777249957AQB33XUXhg8f7vHaFStW4IUXXnCxFxQUIDIyEgCQlJSECRMm4ODBgzh58qR4TUpKCkaNGoW9e/eioaFBtKelpSE5ORnFxcVobm4W7RkZGejXrx8KCgqcGllWVhYiIiKQl5fn5ENubq7YOQio1WosXLgQjY2N2L17t2iPjo7G7NmzUVNTg7KyMhc9x48fx9GjR8Xv5awpLi4OmZmZHjWVl5cDAAwGAzGapMZJgCRN3uIk+CjEmwRNUuMEAC0tLU6z8HLX5C5OOkwAADScOo+TBruPBoNB1pp8jVNsbCwAoLKyEidOnCBCUyD78ra2NkhFFjlMDMNg06ZNWLx4MQDAbDYjMjISGzduxJIlS8TrHn74YZSVlWHHjh2S7nv27Fn069cPR48exfXXX4/S0lKPs0zuZpgSExNRX18vrnuq1WpotVqYzWanhiTYjUaj0+hY+NTjyd4xkHq9fReI0WiUZI+MjITVaoXZbBZtLMtCr9c72YVPJLm5ueJacEff5abJ0e7J99bWVmzduhVZWVlQq9VEaJISJ8d4d/zEJldNjr57sjc1NaGoqEiMNwmapMRJiPeCBQucPrXLWZMne3rvehwxD8O2VaWYdOdwMd5arVa2mgDf4sRxHAoLCzFv3jyne8hZUyD78qamJgwYMEBSDlPYzjB1RmNjIziOQ3x8vJM9Pj4ep0+flnyfxYsX48KFC+jRowfee++9TpfkdDoddDodVq9ejdWrV4sdT1FRkcsMU3l5udsRfGlpqdvRbklJicdPxO5G8MIoWqCzEfz58+fdjuDr6uqcRvDCVH1VVZXHEbzcNAmfSjxpOnLkCACIzyBBk9Q4saw9fZEkTd7iJMyuCL6SoElqnFQqFVpbW93OMMlVk9s4YQQA4EJjs2gvKiqStyYf4xQbGwu1Wo3q6mq3M0xy1BTIvpz4GaZTp05h4MCBKCkpQUZGhnjdyy+/jA8//FD85QUSIbO+sbFRHJWSvEZMNVFNVBPVFO6apvc+iu9ax2LT03uw8IV0IjQB5MUpnDQ1NTUhNjZW3rvkOiM2NhYqlcplNuns2bMus04U79hsNjQ0NDg1OCWgZN1nz55VpG4ab7LRq+1v4sZWjsZbQbqDFWtZLslptVqkp6fDYDA45TAZDAYsWrQooM/uuCRHUtJ3bm4uKisriUl+lJLQWVtbS5wmqUnfubm52LlzJzGavMVp69atxGnyJel7+vTpxCd9M7Z+AICmC2345ptviNDUlaTvxsZGDB8+XDFJ393py4lYkmtpaRGDPWHCBKxatQpZWVno06cPkpKSsGHDBixduhRvv/02MjIysG7dOrzzzjsoLy9HcnJywP0jaUnOYrHAYDAorqyA0WhEfn6+IssKCPFWUlmBtrY2GAwGRZYVMBgMiigrcG3ifvzvzOV4+9YdWLpushhvpZUVKCgoUFRZge705b4syYXtDNP333+PrKws8fvHHnsMALBs2TKsX78eN954I86dO4cXX3wR9fX1GDt2LPLy8oIyWHJEo9FAo9E42VQqlVNDFfCUVO7J3vG+XbGzLCsm+Eqxe/KdVE3CMxyfI3dNJMbJn5o6xpsETVLsDMMQp6mjPUJrfzO1mJzjLTxLjpoEuhInd/eRuyZ/9+We/HX7OslXBplZs2bB2+TX8uXLsXz58iB55B4SCldarVZERUWBYRiiPml5+1Ris9kQFRUlPoMETVLi5BhvUjQ5+t6Z3THeJGiSEidBN+BapE+umjzZtWq7v+3tvFO85awJ8C1OHMchOjoaNpvN6bly1hTIvpyIwpXhCqk5THFxcVCr1Thy5Agxa/ne1r0rKirQ0tKCgoICYjT5Eie1Wo3CwkKiNHUWp8LCQnG5ghRNJMapO5o4i322oLnJLMa5oKBA1pq6EqfZs2fTvlxJOUzhDkk5TDabDXV1dRg8eDB4nifmk5a3TyUWiwU1NTUYOHCgOAUsd01S4mSz2XDq1CkkJyfDZrMRocnRd092k8mEuro6Md4kaJISJ5vNhvr6eiQmJrrsIpKrJk/2x9K/xZuHZuGZaUX4v22ZYrxVKpVsNQG+xYnnedTX1yMhIcHpHnLWFMi+nPiyAhT/wnEcDh065NRAlYCSdR88eFCRupUa7wMHDihCt1ZrfxM0mhhFx7usrExRuoMVa7ok5yOkLskJkDY1Tc+So2fJ0bPk7CjhLDlju71fbm3lxDjTs+Tkr4meJSdzSFqSo2UFaFkBuWty9N2TnZYVIL+swF8X7MSzhbNxV0ox3iidRMsKOOwok7MmWlaAEEgoK8AwDOLi4sAwDLHbaz35HhcXJ3am3nyXgyYpcXKMNymapNi1Wq3beMtZkxTfhXg75m1J8T2cNXmyR0TY/TVZWLfxlqMmAalxEuKtVqvd+iNHTQKB6Mt9KStAZ5i6iDDDJGVUSqFQKJTA8+b1O/C7z2fi+kG78VlNhvcXUBSPL+/ldIapm5BQh4njOFRVVSElJQUAiJma9jaNazabcfz4cQwbNkz0T+6apMSJ4zhUV1dj5MiR4HmeCE2OvnuyG41GVFZWivEmQZOUOAnxHjFihEttO7lq8mTX6O1fTRbneAuzLXLUBPgWJ5vNhurqagwdOtRpCVbOmgLZl9M6TAGE5KTvESNGKOosuUOHDqG2tlZMjCRBky9J38OHD1fUWXLbtm2D1WoV402CJl+SvuPj44lP+m5obAUAtJlZ5OfnAwBOnDgha01dSfpubGwEx3GKSfruTl9Ok76DAE36Dm9Njnaa9E2TvmnStzKSvr944jvc/I8rMCOmDF+fGkmTvmnSN036DidISPp2hKTkR4HONAnPoGfJeffRV3u4aqJnyTkjZ00d7ZFR9v+brGp6lpyKniXn76RvWriSApZlkZSU5LaBkgzVTXUrASXp1kfZ3wiNnEZRuh1Rou5gaaZLcl2E7pKjUCiU8KL4/x3AzIdSkaKtwhHT0FC7Q5EBdJdcECFll1x5eTnS0tIAKGuX3KFDhzBmzBjF7ZKrqKhAamqq4nbJlZeXi/EmQZPUXXIVFRUYP3488bvkVDr7V5NN4xRvpe2Sq6iowJgxYxS1S66rfTndJRdASN4lN378eEXukqutrSVGky+75MaNG6fIXXJCvEnQ5MsuucGDBxO/S+5cVRuAVBhtWnGXXG1traw1dXWXnFarVdwuua705XSXXBCgu+TCW5Ojne6So7vk6C45ZeySO/pNNcZdPRK9mAuoa9HSXXJ0lxzdJRdO0F1y8tYkPIPukvPuo6/2cNVEd8k5I2dNHe1Rve2z/SZeS3fJ0V1ydJccxf+wLIuUlBRF7aoAqG6qWxkoSbe+pxYAYIQeDBjF6HZESfEWCJZmuiTXReguOQqFQgkvLvx8Eb0HxwAATM1maKO0IfaIEu748l6unCEoxSNWqxUlJSUua8ykQ3VT3UpASbp10ZcGSK3nWxWj2xElxVsgWJppDlM3IaGsgMViQUNDA3ieJyr50VuioNVqRUNDA8xmM3ieJ0KT1KRvId6kaHL03ZPdbDY7xZsETVKTvhsaGmCz2Vyul6smT3Y24tIcQFNjixhv4Xo5agJ8T/puaGhw8UXOmgLZl9OyAgGE5LICAIjaXuttK2p5eTkAwGAwEKPJl7ICAIjS5C1Ogo9CvEnQ5EtZgZaWFuLLCqjVamgxF2bosHPbLkSPjITBYJC9Jl/LCgBAZWWlYsoKdKcvp2UFggAtKxDemhzttKwALStAywooo6wAAPTVtqMZPXHoq6OotB6hZQUI0BQuZQXogKmLkJT0bbPZUFNTg8TEREXtrKC6qW4loDTd/dgGNPBxOPD5UcRM0itGt4DS4g10TzM9GoXiEyzLIjk5OdRuBB2qW1lQ3cpAz5oBDrC02xSlW0Bp8QaCp1kZw09Kp1itVhQWFipqVwVAdVPdykBpunWsfamo5YJRUboFlBZvIHia6QwTBTzPo7m52eVgTtKhuqluJaA03fpfB0ymFivaFaRbQGnxBoKnmc4wUSgUCoUY9KpfB0xtnJcrKRTfoAMmCoVCoRCDTmVfljG20gETxb/QARMFKpUKGRkZbg81JBmqm+pWAkrTrVfbB0ymdl5RugWUFm8geJppDlM3IaHSNwD06dMHLMsSVY/EW+0OnufRu3dvcBwHjuOI0CQ1TrGxscRp8hYnjuOc4k2CJqlxiouLA+Ba1VjOmjzZ9ZpfZ5jaL8XbZrPJWpOvcerXrx84jnN6rtw1Baovp5W+Awiplb4ZhkFOTg4qKyuJqXjrrTpsWVkZamtridIkNU4sy2LBggXYuXMnMZpIjJO/NKlUKmRmZiqi0rdO3RcAUH2iTnyN3DX5Wun7woULGDx4sGIqfXenL6eVvoMArfQd3poc7bTSN630TSt9K6fS9+0j9uLfP0/DyoXbMPLuFlrpmwBN4VLpm84wdRONRgONRuNkU6lUbtdShYYj1d7xvl2xsyzrtvKpJ7sn30nVJDzD8Tly10RinPypqWO8SdAkxc4wDHGa3Nn1WvsbqsXMiD8XniVXTUDX4uTuPnLX5O++3JO/7qBJ3xQKhUIhBp3WPnNgNIbYEQpx0AETBWq1GllZWR5H46RCdVPdSkBpuvU6+wyTycwoSreA0uINBE8zHTBRAAARERGhdiEkUN3KguomH53W/tVkYhSl2xEl6g6GZjpgosBqtSIvL09RZw8BVDfVrQyUpluvt381mhhF6RZQWryB4GmmAyYKhUKhEIM4YDLTtzeKf6EtikKhUCjEoNPbd8eZLPTtjeJfaIuiUCgUCjHoI+wDJiMdMFH8DC1c2UWEwpVSil2FOzzPw2q1Qq1WuxS2Ixmqm+pWAkrTvf6uXbjjn1cgJ24f/lOXphjdAkqLN9A9zb68l9MhOAUA0N7eHmoXQgLVrSyobvLRRdjf1kxWlaJ0O6JE3cHQrIgB05IlS9C7d29cd911Lj/76quvkJKSghEjRuDdd98NgXehx2q1oqioSFG7KgCqm+pWBkrTrY+0v60ZrWpF6RZQWryB4GlWxIDpoYcewgcffOBit1qteOyxx1BYWIjS0lL87W9/w/nz50PgIYVCoVD8gS7SfkyG0Sr9yAsKRQqKGDBlZWUhOjraxb53716MGTMGAwcORHR0NHJzc5Gfnx8CDykUCoXiD/RR9mrPJptyKl1TgkPIB0zFxcW46qqrkJCQAIZhsHnzZpdr1qxZgyFDhkCv1yM9PR07d+70y7NPnTqFgQMHit8PGjQIdXV1frm33FBSGX1HqG5lQXWTjzDDZLJpFKXbESXqDobmkP9WW1tbkZqaijvuuAPXXnuty883bNiARx55BGvWrMG0adOwdu1a5OTkoKKiAklJSQCA9PR0mEwml9cWFBQgISHB47PdbRD0lGFvMpmcntHU1AQAsFgssFgsAOwnLKtUKnAcB5vNJl4r2K1Wq9MzVSoVWJb1aBfuKyA0iI7rtJ7sGo0GNpsNHMc56VOr1S727OxsqNVqj77LUZNg9+Q7y7KYP38+AHscSdAkNU45OTnEafIWJwBO8SZBk9Q45ebmirpJ0eTJrushzDBpxHgLO6jkqsnXOC1cuBAcxzk9V+6aAtWXd9TRGSEfMOXk5CAnJ8fjz1etWoU777wTd911FwDg9ddfR35+Pt566y2sWLECALB///4uPXvgwIFOM0q1tbWYOnWq22tXrFiBF154wcVeUFCAyMhIAEBSUhImTJiAgwcP4uTJk+I1KSkpGDVqFPbu3YuGhgbRnpaWhuTkZBQXF6O5uVm0Z2RkoF+/figoKHBqZFlZWYiIiEBeXp6TD7m5uWhvb0dRUZFoU6vVWLhwIRobG7F7927RHh0djdmzZ6OmpgZlZWWiPSYmBjNmzMDx48dx9OhR0S5nTXFxccjMzKSa3GgaOnQoxowZQ5QmEuPkL02TJ09Gjx49sH37dmI0eYpTUo8RAOwDJuE1ctfka5yGDx+Oc+fO4dixY8RoClSc2traIJWwqsPEMAw2bdqExYsXAwDMZjMiIyOxceNGLFmyRLzu4YcfRllZGXbs2CH53tu3b8ebb76Jzz//XLRZrVaMHj0a27dvR8+ePTFx4kTs2bMHffv2dXm9uxmmxMRENDY2irUb5DqCt1gsMBgMyM3NBcuyRH3S6uxTidFoRH5+PubNmweNRkOEJilxcow3wzBEaHL03ZO9ra0NBoNBjDcJmqTESYh3Tk6Oywy6XDV1Zq8urEXKgiGIwUW8v3k75s2bB61WK2tNvsTJarWioKAA2dnZUKlURGgKZF/e1NSE2NhYSXWYQj7D1BmNjY3gOA7x8fFO9vj4eJw+fVryfbKzs1FaWorW1lYMGjQImzZtwuTJk6FWq/H3v/8dWVlZsNls+MMf/uB2sAQAOp0OOp2uW3ooFAqFElh0UfbdcSZoQ+wJhTTCesAk0PFTEc/zPlXz7Gzn29VXX42rr75a8r1Wr16N1atXi6NfUpbkBEibmu5sGre8vBwAYDAYiNEkNU4CJGnyFifBRyHeJGiSGicAaGlpcdowI3dNnuKUnjgZAGCCDryNh8FgkL0mX+IUGxsLAKisrMSJEyeI0BTIvpwuyQUBoZw6CUtyVqsVJSUlmDlzJhiGIWZq2ts0rslkwq5du5CZmQm1Wk2EJilxcow3ACI0Ofruyd7e3o6SkhIx3iRokhInId4zZsxAR+SqqTN7S20r+gztBQDI/6oA02dPF5dg5arJlzhxHIeSkhJMmzZN3Owgd02B7Mt9WZILeVmBztBqtUhPTxdHjQIGgwGZmZkh8oo81Go1Zs6cqbitqGq1GjNmzFCk7qysLEXqVmq8Z8+erRjduuhLS3GTx09WjG4BpcUbCN7fdsh/oy0tLU7ThtXV1SgrK0OfPn2QlJSExx57DEuXLsWkSZOQkZGBdevW4eTJk7jvvvtC4i+pS3LR0dGYNWsWUVPTJE63+0tTYmIi0tLSiNJEYpz8pWncuHHo27evInbJLZi3QPw+/38FiBiol70mX+M0cOBAtLW10V1ypC3Jbd++HVlZWS72ZcuWYf369QDshStXrlyJ+vp6jB07Fq+99prb6eVgQtKSHN0lR3fJyV2To+90l5yyd8lpNBqoGSs4qPHx3z/F4vuuprvkZK6J7pL7lVmzZrktIOnI8uXLsXz58iB5RKFQKBQ5o4MJbVDDagybFF0KAYR8wCQ3SF2SEyBtaprukqO75OguOTtK2SW3cOFC6Bgz2vgesLbZ6C45AjTRXXIyh6QlOavVitLSUkydOlVxu+T27duH9PR0xe2SE+INKGuX3P79+8V4k6BJ6i650tJSTJkyBR2Rq6bO7BqNBgNUZ3DaFo9Pnv8PFv1hvuJ2yZWWliI9PV1Ru+S62pf7siRHB0xdRBgwSfklUygUCiV4DFbX4mduEPa8exhT7xwbancoYYwv7+V0Sa6bkHD4LsdxqKqqQkpKCgAQ80nL26cSs9mM48ePY9iwYaJ/ctckJU4cx6G6uhojR44Ez/NEaHL03ZPdaDSisrJSjDcJmqTESYj3iBEjXPJF5aqpM7tGo4GOtQAc8FNlLVKNw8UZRTlrkhonm82G6upqDB061CnJX86aAtmXy+rwXblBcg7TiBEjUFlZScxavrd170OHDqG2tlZc5ydBky85TMOHD8fOnTuJ0eQtTtu2bYPVahXjTYImX3KY4uPjFZPDpGXNAID62gbk5+cTocmXHCbhWDGl5DB1py+nOUxBgKQcJlpWgJYVkLsmR9892WlZAeWUFZjcowLft12GV274EMvfu5aWFZC5JlpWgBA0Gg00Go2TTaVSOTVUAaHhSLV3vG9X7CzLOiX+ebN78p1UTcIzHJ8jd00kxsmfmjrGmwRNUuwMwxCnyZNdp7K/OVtNcBocy1lTV+Lk7j5y1+TvvtyTv25fJ/lKiltIyWEaNGgQWJYl6pOWt08lPM9j0KBB4mtI0CQ1hykxMZEoTY6+e7IL7Vx4NgmapOYwJSYmgmEYl+vlqqkzu0ajgV5tt+m10eA4jghNvuQwJSUlged5p+fKWVMg+3KawxRASM1hiouLg0qlwpEjR4hZy5dSu6O2tha1tbXEaPIlTiqVCoWFhURpkpLDJMTbV025ubmoOFmBsv1liFRFQsWoQq7Jlzi1tbXJIk7+aHsa1v4meOF8q+JymARNtC+nOUxhA0k5TBzHoby8HGlpaQCUtUvu0KFDGDNmjM87K8JVk9QZpoqKCqSmpipul1x5ebkYb2+aLrRdwP76/fiu7jt8d+o77K3bizOtZ8TrIjWRiNHFoKeup/i1p64n+kX2w50T7sSkQZPCYuZCiPf48eMVs0vumoQ92FR/Of6cvQmPb86BWq2sXXIVFRUYM2aMonbJdbUvpzlMQYSUHKba2lqMHz8eGo2GyLV8d74zDOOk25vvctAkNU41NTUYN26cX3z3ZA+33BiVSuU23hqNBjbehmPnjmFP7R7x36Gzh2DjbU73YMCAh72jbbO0oc3ShvqWepdnvV36Nm4aexNeynoJw/sMD5gmqfHoLN7hFie/5DBp7HFrumB0GhzLWZPUOFksFpw8eRJjx45VTA5Td/pyv+cwNTU1Sb6hAC3mSKFQwplzbefwXtl72Fq1Fd/VfYcLxgsu1yT2TMTlgy4X/03oPwEqVoUmUxMuGi/av5ou4qLxIi6a7N/vOrkLG8o34NPDn+Lzis9x54Q78ezMZ5EQnRB8kQpFGDBZLa5vuhRKV5E0YOrVq5fLdtTOYBgGx44dw9ChQ7vsGIVCoQSCHxt/xJr9a/DBgQ/Qbm0X7RHqCExKmCQOjqYOnIqBPQe6vUdsZCxiI2Pd/uzBKQ/iyWlP4pnCZ/D1ia+xdv9avH/gfTw05SE8ecWT6BPRJyC6KJcQBkwWOmCi+BHJS3Kff/45+vTx/ofO8zxyc3O75ZScIGWX3IgRIxS5S2748OGK3CU3cuRIojQ5+u7ODgb4+vjXeKX+FXy77lvxZ2n907Bs3DJkJmZibNxYaFTO9Zkcfw++aBoXNw55t+ahqKoIzxQ9g921u7GyZCXW7l+LP0z7Ax6c9CAi1BHd0uRLDtPIkSMVtUtOq7X9ek0PRe6SS0lJUdwuua725X7fJZecnIwZM2agb9++km46dOhQn9YF5QTdJScvTd52Vpw8eVKRlb6VskvOyBlxsvdJ/KviXzjSeASAPQ9pSswUPDv/WcwdPhdff/016hvqUY96v2saYB6AP/T9A77XfI+P6z/GT8af8EzhM1j17SpcE3sN5vedDw2robvkuqjJU5xUrP31Tc1mukuOIE2B6MvpLrkgQNIuOav10un1DMMQ80krkCdch6smKXFyjDcAIjQ5+m61WnHy4km8tf8t/POHf+IX4y8AgGhtNHLic/BcznMYETsi6JpsvA0bf9yI53Y8h6pfqgAAQ3oNwf9N/z/cOu5WaDXagLQ9Id5TpkxBR0Idp0C1vWemFeEvJVn47bA8vHkoSyxeKWdNUuPEcRxKS0uRnp7ulDgtZ02B7MuDskuO53mf8ppIhZRdco2NjeB5Hmq1mpjdIgKefGdZFufOnYNarVbcLjkh3qTtkjt05hBe3vkyPq/4HBxv73CH9R6Gh6Y+hFvH3Ipd23ZhROyIkFX6/k3qb3DD2Bvwz9J/4sXiF1F9oRq//d9vseq7VXh59su4auRVbvvV7ra9xsbGgGnyZg/F35Neb/8dtpt4saQAIG9NvsSpoaEBLMsqZpdcd/pyX1bDupwRN2fOnK6+lEKhUPxKY1sjlm9ZjrS1adhQvgEczyFrcBb+c9N/cPTBo3ho6kPoqQuPnbtalRb3T74fJ353AivmrEAvfS8cPnsYiz5dhKs/vRpGqzHULsoenc7+1WJ1fXOlULqK5Bmm3/72t+L/eZ7HkSNHAuIQhUKhSMXCWfDW92/hue3PiWUBrrvsOvxp+p+Q2j81tM55oYe2B5664incm34vVn67Eq9/9zq+OvYVFn+6GJtv2gy9Wh9qF2WL7tcZJjNHSw1S/Ifk1lReXo7ly5eL33/33XcBcYgSfFQqlZgErCSobnnrLqgswCPfPIIfG38EAKTGp+KNBW9g5uCZbq8PV929I3pjxdwVWDB8AXL/nYv8yny/DprCVXcgEQZMPBOhKN2AMuMdLM2SB0wTJ07EsmXLxO8dM9iVDAllBQBg4MCBiiwrkJCQAI7jwHEcEZqkxknOh+9WXajCH7b9Af89+l8AQGxELF6c9SLumngXNGqNR00cxznFO5w0sSyLmYNn4n83/g9XbbgK+ZX5WPTJImy6cRMitZHdjlNSUhIA1y3UpCZ9a4QlOZtW9EvumnyJU3JyMjiOU1RZga725QE5fPett95y+v61116T/BCSILWsgEqlwoIFC3DixAnFbEU9cOAAampqiNIkNU46nQ5z586VlSae5/G/hv/hw9MfwmKzQMWosDB2IW6IvwFR9VE4VXdK9nHSn9Hj6aSn8efqP6OgqgC5H+Tim9u/QUlxSbc0RUVFYeLEiSguLg66plD8PfGMGQDQ2m5DXl4eEZqkxik2NhYmkwn9+/fH8ePHidAUyL48oGUFzpw5g/j4eF9eQiQklRWwWCwwGAzIzc0Fy7JEfdLq7FOJ0WhEfn4+5s2bB41GQ4QmKXFyjDfDMLLQZLKY8GjBo1j3wzoAwILhC/DKnFeQ0jfFxXdPcWpra4PBYBDjHWpNncVpx887sOizRWiztGHB8AXYeO1G6FQ6F01S4iTEOycnx2UHHqkzTBsfL8ENqzIxNWI/ChtHQ6vVyl6T1DhZrVYUFBQgOzvbaYlKzpoC2ZcHtKzA73//e3zwwQe+voxYSCkrIEDa9lqgc03CM5RWVsCbPZw0tVhacMPnN6CgsgAMGLw6/1U8evmjHsuaeNPUMd7hGKe5w+diyy1bkPtxLr458Q1eKH4Br8x/RZKPnuwMwyim7UX0sN/bbNM4DY7lrKkrcVJKWYHu9OUBLStA61xSKJRgUf1LNTL/lYmCygJEaiKx+abNeCzjMUXUgJs1eBY+ufYTAMDr372Ow2cPh9gj+aCLtL+BmmxknjhBCQ0+D5iU0FEpDZVKhYyMDEXtqgCo7nDXvbtmN6a+OxUVDRVIiE7Azjt24uqUq7t8P7nodmTRqEVYMmoJrDYrlm9Z3qUPrHLU3V10v84wWaFTlG5AmfEOlmZ6lDMFLMuiX79+bqdASYbqDl/dnx7+FFnvZ6GhrQET+k/A3rv2YuKAid26pxx0u+P1Ba8jUhOJnSd34oMDvqdDyFV3d9BH2QdMJptWUboBZcY7WJrpkhwFFosFW7Zs8Wl7JQlQ3eGnm+d5vLTjJdz8xc0wcSZcnXI1iu8oxsCeA7t973DW3RlJMUl4buZzAIDfG36P8+3nfXq9XHV3B2GGyWRTK0o3oMx4B0uzzwOmRx99NBB+UEJMxx0MSoHqDh84G4ff/ve3eHb7swCAxzMex5c3fIkobZTfnhGOuqXwyOWP4LK4y9DQ1oBntj3j8+vlqrur6KLsuUsmXhtiT0KD0uINBEezzwOmiRNdp8UvXLjgD18oFIpCsfE23PO/e7C+bD1UjApvL3wbr85/FSpWOXkYnaFVabEmdw0AYO3+tdhbtzfEHoU34oAJOi9XUijS8bmswN/+9jcMHjwYN954IwDghhtuwBdffIH+/fsjLy8PqanhfX6TvyGh0rfjc0iqRyKlxoqjflI0SanDJBAOmgDgkYJH8K+yf4FlWHy0+CNcO/pacBwXkLYnfA33OHXUlDkwE7eOvRUfH/4Y9391P/bevRc27tI9PPku6OV5XjmVvoVdctDBYjETocmXOkwAXP7G5KwpkH15QCp9C6xduxYfffQRAMBgMMBgMODrr7/GZ599ht///vcoKCjw9ZaygtRK371794ZarcbRo0eJqXjrrTrsjz/azyAzGAzEaJIap5SUFKjVahQVFYVUE8/z2PDLBnx68lMwYPBw4sOIqI5AXnWe39ue4KMQbznEqaOmefw8bFZtRunpUrz9/dsY3DBYUpymT5+O9vZ2bN++Pew0Cfiz7bVaWgAAHNT4Zst/0atvL9lr8iVOWVlZqK6uxrFjx4jRFKi+PKCVviMiInDs2DEkJibi4YcfhtFoxNq1a3Hs2DFMnToVv/zyiy+3ky0kVfrmeR4cx0Gv18NmsxHzScvbpxKr1Qqz2Qy1Wg2GYYjQJCVOPM+D53lotfZztkKp6dntz+KvJX8FAKxbuA63p97eJU2Ovnuym81mWK1WMd7hHidPmtbuX4vf5f8OMboYHLr3EPpH9e/Ud+F1gj/hqMnR7o+213SqCTED7f3yL3UXENUvSvaafJmxFX7u6IucNQWyL/el0jd4HxkwYAD/7bff8jzP8yNHjuQ/++wznud5/siRI3x0dLSvt5MtFy9e5AHwFy9eDLUr3cZsNvObN2/mzWZzqF0JKlR3aHX/ecefeTwPHs+Df/O7NwP+vHDR3V2snJWftG4Sj+fB3/rFrV6vJ0W3L5hbzTzA8wDPnzl6NtTuBBVFxrsbmn15L/c56fuaa67BLbfcgnnz5uHcuXPIyckBAJSVlWH48OG+3o5CoSiQv5f8HX8q+hMA4NV5r+KBKQ+E2CP5oGJVeGvhW2DA4ONDH6Oousj7ixSGWq8GA/tMhKnZHGJvKKTg84Dptddew4MPPojLLrsMBoMBUVH2Lb/19fVYvny53x2kUChksXrvajxheAIA8FLWS3g88/EQeyQ/JiVMwv2T7gcALM9bDjNHBwWOMCwDHUwAAFOLcuoRUQKLz0nfGo0GTzzxhIv9kUce8Yc/FAqFYP5Z+k88+PWDAIA/XvFH/GnGn0LskXz58+w/4/MfP8eRxiNYtXsVnrriqVC7FFboYIYREXTARPEbPid9U+wISd+SEsXCHJ7nnZJhlQLVHVzdGw5vwM1f3AwePB69/FH8ff7fg/p8EuP94YEPcdvm2xChjsCPD/yI5F7JLteQqFsK8WwDzvJxOPD5MYy/dmSo3QkaSox3dzT78l6unMNmKJ3S3t4eahdCAtUdHBrbGnHflvvAg8f9k+4P+mBJgLR4/2b8bzAzeSbare14cuuTHq8jTbcUdKx9mdLYrLwZJiXGOxia6YCJAqvViqKiIsWV06e6g6f7uaLncMF4Aanxqfh/Of8vJIMlEuPNMAzeWPAGAODzis9R21Trcg2JuqWgY+0DpTaFJX0rMd7B0kwHTBQKJaAcPnsYb+9/GwDw+oLX6XEnfia1fypmJs8Ex3NY+/3aULsTNggDJnOrcgYOlMAiecB04cIF5Ofni99/+eWXAXGIQqGQA8/zeCz/Mdh4G64ZfQ1mDZ4VapeI5MEp9kT6daXrYLKaQuxNeKBj7QMlU5trUUcKpStIHjDdfPPNePXVV3HrrbeC53m8+uqrgfSLEmSEaqxKg+oOLFuOb4GhygCtSotX5r0SlGd2BqnxXpSyCAnRCTjbehZf/PiFy89J1d0ZOtWvA6Z25Q2YlBjvYGiWPGA6ffo0DAYD5s6diz/9SV5bgZcsWYLevXvjuuuu8+lnSkGj0WDhwoXQaDShdiWoUN2B1W3mzHgs/zEAwKOXP4qhvYcG9HneIDneGpUG96XfBwB4c++bzj8jWHdn6NT2AZPVpIydYgJKjHewNEseMMXGxgIA7rjjDrS0tODIkSMBc8rfPPTQQ/jggw98/plSsNlsOHv2rNMZPUqA6g6s7tV7V+P4+ePo16Mf/jj9jwF9lhRIj/fd6XdDw2qwu3Y3SutLRTvpuj2h/3XA1K6wJTklxjtYmiUPmG644QbxsL1XX30Vt912W8Cc8jdZWVmIjo72+WdKgeM47N692+0BjiRDdQdOd2NbI17Y8QIA4OXZL6OnLvS1ykiPd/+o/rjuMvtM+eq9q0U76bo9oVXZ9RoVtiSnxHgHS7PkAdPdd98tTndpNBq8/vrrfnGguLgYV111FRISEsAwDDZv3uxyzZo1azBkyBDo9Xqkp6dj586dfnk2hUIJDO+WvouLpotIjU/FHWl3hNodxSAkf//78L9xru1ciL0JLTqNfbbB3E5rM1P8g89lBV588UW/OtDa2orU1FS8+eabbn++YcMGPPLII3jmmWfwww8/YPr06cjJycHJkyfFa9LT0zF27FiXf6dOnfKrrxQKRRr/OfofAMD9k+6nZQSCSMagDKT1T4PRasR7Ze+F2p2QotPYZxtMdNMgxU/4nFZ+4sQJvzqQk5ODnJwcjz9ftWoV7rzzTtx1110AgNdffx35+fl46623sGLFCgDA/v37/eqTO0wmE0wOf3lNTU0AAIvFIi5VsiwLlUoFjuOc1lIFu9VqheNJNCqVCizLerQL9xUQdgF0LM7lya7RaGCz2ZymKRmGgVqtdrJbrVZERUWBYRiPvstNk6Pdk+82mw1RUVHiM0jQJCVOjvEOhKbTLafxXe13AIDsodnivQKpydH3zuyO8Q73OEnR5C5OD0x+AHf/726s2bcGD6Y/CN7Gi4ekd7xeLpoA3+OkVdt9MbbbxGMz5K5JSpw4jkN0dDRsNpvTc+WsKZB9eUcdnRHWew/NZjP279+Pp55yPlRy/vz5KCkpCaovK1aswAsvvOBiLygoQGRkJAAgKSkJEyZMwMGDB51mwFJSUjBq1Cjs3bsXDQ0Noj0tLQ3JyckoLi5Gc3OzaM/IyEC/fv1QUFDg1MiysrIQERGBvLw8Jx9yc3PR3t6OoqIi0aZWq7Fw4UI0NjZi9+7doj06OhqzZ89GTU0NysrKRHtcXBzUajWOHDmCo0ePina5a8rMzMTx48fdaqqoqEBLSwsKCgqI0eRLnNRqNQoLC/2uqfCXQvDgkRaXhgM7D+AADgRNU2dxKiwshNVqFeMtlzj52vauH3U9Hs17FNUXqvHyhpcxKWaS7DV1JU4Ws/1D7Zkzv6C4uJgITVLjNHv2bNqXS9TU1tYGqfh8+O5tt90WsF1lDMNg06ZNWLx4MQDg1KlTGDhwIL799ltkZmaK1/3lL3/B+++/7/SL64zs7GyUlpaitbUVffr0waZNmzB58mSvP3PE3QxTYmIi6uvrxQP71Go1tFotzGazU0MS7Eaj0Wl0rNVqoVarPdo7BlKv1wMAjEajJHtkZCSsVivM5ktHA7AsC71e72TneR719fUYOnQorFarW9/lpsnR3pnvNTU1Yv4cCZqkxInneZw+fRpDhgyB2Wz2u6YbNt2ALSe24IWZL+CJKU8ERZOj757sra2tOHXqlBjvcI+TFE2e4vTo14/iH9//A/OGzMOmazfh7NmzSExMdPJRbpp8jdPvJxfj9bLZeHxSIf68M5MITVLiBAANDQ2Ij4938kXOmgLZlzc1NWHAgAGSDt/1eYbJx/GVX+h47hTP8z6dReVYodyXnzmi0+mg0+mwevVqrF69WpwuLCoqcplhKi8vdzuCLy0tdTvaLSkpcTuC73g2jjCCNxgMTr51NoI/f/682xF8XV2d0wgeAJKTk1FVVeV2BC9HTcKnks401dbWoqKigihNUuIkvMbfmkw2E7ZWbQUATI+f7nR9oDV5i9P27dthtVrFeMshTl1te6NbR4MBA0O1AR9s+QAJugTExMQ4bZiRmyZf49TefgEAcO5cM0pKSojQJCVOsbGxaGxsxPDhw51SaOSsKZB9eUBnmN544w08/PDDvrxEujMdZpjMZjMiIyOxceNGLFmyRLzu4YcfRllZGXbs2BEQP6TQ1NSEmJgYNDY2iqNSua4RWywWGAwG5ObmgmVZYtbyva17G41G5OfnY968edBoNERokhInx3gzDONXTZuObMKNX96I5JhkVP6u0smXUOfGtLW1wWAwiPEO9zhJ0dRZnBZ/thh5J/LwYPqDmMvNRU5OjssHTblpkmIXND0/qwgv7ZyDe0Ztx+pDVxChSUqchGXn7OxsqFSXNlzIWVMg+/KmpibExsZKmmHyeZdcoAZL7tBqtUhPT3cZsRoMBqclOgqFEh68f/B9AMDNY2/2aRaY4n+Eyt8fHv4QRs7o5Wry0OnsX00WesY8xT90Oen77Nmzbitrjh8/3qf7tLS0OE0bVldXo6ysDH369EFSUhIee+wxLF26FJMmTUJGRgbWrVuHkydP4r777uuq692i45IcKUnfGo0GDMMQl/zoLVEQgDggJ0GT1DgJu+T8qem85Ty+OfENAOCOCXeEXTKx8HsX4i2HOHWn7dl4G/pr++O06TT2W/Zjfut8FBcXy1qTL3G62GR/5sUmk6KSvmNjYxEXF4eqqiocP36cCE2B7MsDuiS3f/9+LFu2DD/++KM4pSVM6wvb0n1h+/btyMrKcrEvW7YM69evB2AvXLly5UrU19dj7NixeO211zBjxgyfnuNvSFqSc7STNDVNNQVX0yu7X8EzRc8gc1Amvr3zWyI0OSLHOL2x9w38fuvvMT5+PH645weX/lmOmrzZBU1rbirG7zbOwjUJu7Hh58lEaCIxTqHWFNAluTvuuAMjR45ESUkJqqqqUF1d7fTVV2bNmgWe513+CYMlAFi+fDl++uknmEwm7N+/P+SDJdLgOA7Hjh1TVCl9QNm6jx496lfdPM/j/QP25bjbU2/32339iRLjfdu42xChjsDBMwdR/FOx9xcQhPbXJTmjRVmFUzmOw5EjRxTVzoP1t+3zklx1dTW+/PJLDB8+PBD+hD2kLskBwIgRI1BZWUnM1LS3adxDhw6htrZWXBImQZPUOAHA8OHDsXPnTr9oeuurt3Ds/DHoWB16neoFAGG31LNt2zZYrVYx3nKIkz/a3hUxV8BwzoB136/DxUMXidAEeI/TmYZaAEBLu01xS3KNjY3gOM7tLjk5agpkXx7QJbnFixdj6dKluPbaa315GXGQtCRHd8nRXXLd1XTPf+/Bu2Xv4rbxt+HdK98Nm+l2R7vSdskJfH3sayz6fBGSY5Jx/IHjTtfLVVNndkHTpw/vwq1vzsAVPctQdG4sEZroLrnQ7pLzeYbp3XffxbJly3D48GGMHTtWPJBX4Oqrr/b1lrJGo9G4/A5UKpVTQxUQGo5Ue8f7dsXOsixY1nXl1ZPdk++kahKe4fgcuWsKdpysNis2H9sMAFiaulS8Jlw1dYw36XG6IvkKsGDx88WfcbrtNBJjEiX5Hs6avNlZlkVElN1u5tTis+Suydc4ubuP3DX5uy/35K/b10m+8ldKSkqwa9cufP311y4/60rSt9wh4Sw5juMwaNAgsCxL1Cctb59KeJ7HoEGDxNeQoElKnDiOQ2Jiot80FVUXobGtEbERsZg2cBosFktYzlwI7Vx4drjHSYomKXGKVEdidK/RKL9QjqLqItw85mbZa+rMLmjS6O1lLUycGlarcs6Ss9lsSEpKAs/zijlLrjt9eUDPknvooYewdOlS/N///R/i4+N9fbnsITWHKS4uDiqVSlHnDwnVYWtra4nR5EucVCqVX86S+7jsYwDAxMiJKPimIGxzY4QcJiHecomTP9revJHzUL63HP/e9W/E/BxDhCZvcao+eRzA5Wi3qhSVwyRoon15GOQwRUdHo6ysDMOGDfPlZcRBUg4Tx3EoLy9HWloaABDzScvbpxKz2YxDhw5hzJgxon9y1yR1hqmiogKpqanirtSuagILJKxKQGNbI76++WvMGTInJJocffdkNxqNKC8vF+Md7nGSoklKnDiOw5rCNXh83+MYHTsaB+45IHtNndkFTTvfKsOsBydiiPokjrUnEKFJ6gxTRUUFxowZ41Q8Vs6aAtmXBzSH6ZprrkFRUZHiB0wCpOQw1dbWYvz48dBoNESu5bvznWEYJ93efJeDJqlxqqmpwbhx47rt+9aqrfbluMhYzB0+F2r20nPCLTdGpVK5jXc4x8mbXarvce1xAIAfG3/EBfMFxPWI8+p7uGvqzM6yLCJ6agEAJtulBH+5a5ISJ4vFgpMnT7rNMQbkqUkgEH15QHOYRo4ciaeffhq7du1y2+E+9NBDvt6SQqHIlA8PfggAuGbUNU6DJUp40VPdE5fFXoaKxgrsOrkLS0Yv8f4imaPrYW+PJl4bYk8opNClXXJRUVHYsWOHy+G3DMMobsBEQtK343NImpqWMt3uqJ8UTVLKCgh0R9MF4wVsLN8IAFg6bqnTa8J5qUf4Gu5x8kVTZ74L11yReAUqGiuw46cduHL4lbLW1Jld0KSOsM9QmHitopK+hdd23IAlZ02B7MsDmvRdXV3t60uIgtSk78jISLAsS2TyIz1LzlVTfHw8WJbFjh07uqzp68av0W5tx+i+o9FY1oi8A3kh1UTPkvOsafjw4ZjcMhnrsA5fHfoKWeYs2WvyFqcfDu8HMBIm6BSX9J2SkkLPkguHpG+KHZKSvh3tJH3SopoCq+nyf12O0tOl+Pv8v+N3k35HhKbO7HLXVNtUi6TXk8AyLM4+dhY9dT1lr8mdXdB0uvwsBo7vDwAwtZuh1Wtlr4nEOIVaky9J3z4PmK677jpMmjQJTz31lJP9lVdewd69e7Fx40ZfbidbhAGTlF9yuGO1WrF3715MmTLFY5IciVDdXdf9Q/0PmLhuIjSsBqceP4XYyFg/e+l/aLynIGVNCqp+qcI3t36D7OHZoXYtoJz/6Tz6DukDAGj/xQh9L32IPQoOSmzn3dHsy3u5z4fv7tixAwsXLnSxL1iwAMXFyjrckRR4nkdDQwOUNtlIdXdd9z9/+CcAYMnoJbIYLAE03jzPY3rSdABA8c/k99Xa6EvJ3qYmUwg9CS5KbOfB0uzz8LOlpQVareuuA41Gg6amJr84JSdo0nd4anK006Rv/yZ9t1va8fEhe7HK36b9FjzPh1yTo+806dt90jfP85g2aBreP/A+dvy0I2wrsvvr74nRXapB1HqhHTFJMbLXRJO+ZZb0PXbsWGzYsAHPPvusk/3TTz/FZZdd5uvtZAepSd8CpCU/eqsOCygz6VugK5p2nN+BC8YLiNPEYVbSLDQ3N4eFJpr07VkTYP+wa62yX/td3Xf46puvsOSqJbLVJCVOGuTAAi2+27UXS8ZfTYQmAU9xio21z/hWVlbixIkTRGgKZF8e0KTv//73v7j22mtxyy23YPbs2QCAbdu24ZNPPsHGjRuxePFiX24nW0hK+rbZbKirq8PgwYPB8zwxn7S8fSqxWCyoqanBwIEDxUJpctckJU42mw2nTp1CcnIybDabz5rmfTQPO07uwLPTn8XzWc+HhSZH3z3ZTSYT6urqxHiHe5ykaJLS9mw2G+rr65GYmAiO45D8j2Scbj2Nbb/ZhtnDZstSU2d2IU4WiwWxejNaEI0jBVVImTdU9pqkxInnedTX1yMhIcHpHnLWFMi+PKBJ3wCwZcsW/OUvf0FZWRkiIiIwfvx4PPfcc5g5c6avt5ItJCV9UyhSOXH+BEb8vxFgwOCnR35CUkxSqF2i+MiNn9+Iz8o/w5+z/oxnZjwTancCSl/2PM7zfVDxv0qMvpKeTkFxJaBJ3wCwcOFCfPvtt2htbUVjYyMKCwsVNVgiDavVisLCQpdPAKRDdfuu+18//AsAkD08W3aDJRpvu24x8fsk2YnfVqsVOpgBAKZW5cRcie08WJq7NGCikAXP82hublbUrgqA6vZVt9Vmxfqy9QCAOyfcGQDPAguNt133jOQZAICSmhJYbeS+qfI8Dw1jHzCZ28jV2REltvNgaaYDJgqFIomvj3+N+pZ6xEbG4uqUq0PtDqWLjO03Fr30vdBibkHZ6bJQuxNQtIw9z0ZJM0yUwEEHTBQKRRLv/vAuAGBZ6jJoVfRAU7nCMiyuSLoCAPn1mLSsfcBkbue8XEmheEcZZUADCAl1mGw2G6ZMmdKp73LT5Gj35DsATJ48WdxRQ4Imqbvkpk6d2qnWjpoa2huw5dgWAMBt427zWssoHHeU2Ww2p3iHe5ykaJK6S+7yyy93un7aoGn46thXKP65GI9MfUR2mjqzC3Gy2WzQqznAArS1WMTfhZw1Sd0ll5GRAcC5xpCcNQWyLw9oHSalQ2odpri4OAwYMABHjhwhph6Jt9odhw8fJk6TL3FiWRbbt2+XpOmHHj+A4zmM6jEK1XurUY3qsNTUWZy2bt0qyzj5q+21traKmthW++LCrpO7cLbhLL7b850sNXmLk4q3b0yoPPYTgKlEaBLwFifal4dBHabHHnvM/Y0YBnq9HsOHD8eiRYvQp08fX24rO0iqw2SxWFBYWIjs7Gzxk3hH3+WmydHuyXej0YitW7di9uzZ0Gg0RGiSWulbiDfDMF418TyPy96+DJW/VOKdhe9gWeqysNPk6Lsne1tbGwoLC8V4h3ucpGiSWum7sLAQ8+fPB8PYq1+bOTP6reqHNksbDt57EKP6jpKVps7sQpyMRiPm9zuMb1un4N8P7sLN/+8K2WuSWum7sLAQc+bMEWdf5K4pkH25L3WYfJ5h+uGHH1BaWgqO45CSkgKe53H8+HGoVCqMGjUKa9asweOPP45du3YpovK3RqOBRqNxsqlUKqeGKiA0HKn2jvftil0o4uXNLjROT77LUZNAZ5o4jnOJodw1SYmTEG8pmrb/tB2Vv1QiShuFm8bf5Nb/cNDkza7RaNzGO5zj5M0u1XeO48AwjGjXaDTIGJSBbdXbsKtmF8b1H+dyj3DX1JmdZVl7nFn7m7TVcskuZ01S257VaoVKpXJ7H7lqAgLTl3vy1x0+J30vWrQIc+fOxalTp7B//36Ulpairq4O8+bNw80334y6ujrMmDEDjz76qK+3plAoYYhw0O7NY29GlDYqxN5Q/IVQj2nnyZ0h9iRwaFT2AZPZqJwt9pTA4fOA6ZVXXsFLL73kNHXVs2dPPP/881i5ciUiIyPx7LPPYv/+/X51lEKhBJ9f2n/B5xWfAwDumnhXiL2h+BOhHlPxz8XE1uzRsPaZVJPR5uVKCsU7Pg+YLl68iLNnz7rYGxoa0NTUBADo1asXzGZz972jBAW1Wo2srCyP05ekQnV71/3vQ/+G0WrE2H5jMTlhchC8Cxw03s66pw6aCg2rQV1zHaovVIfIu8ChVqvRM8qu2WwKsTNBRIntPFiau7Qk99vf/habNm1CbW0t6urqsGnTJtx5553iwbt79+7FyJEj/e0rJYBERESE2oWQQHV3jrAcd9eEu8SEYTlD432JSE0kJiVMAgDs/JnMZTndr+kpJoUtySmxnQdDs88DprVr12LOnDm46aabkJycjKSkJNx0002YM2cO3n77bQDAqFGj8O677/rdWUpgsFqtyMvLU9TZQwDV7U13aX0pfjj9A7QqLX4z/jdB8i5w0Hi76hbymHad3BVstwKO1WqF2WRf9VDSgocS23mwNPs0f8VxHPbv34+//e1veO2111BVVQWe5zFs2DBERV1KBk1LS/O3nxQKJci8W2r/0LNk1BL0jewbYm8ogSA9IR0AcOjsoRB7Ehg06l9zmBS0JEcJHD4NmFQqFbKzs/Hjjz9iyJAhGD9+fKD8kg0kVPp2fA5J9Uik1Fhx1E+KJil1mAQ8aWppb8Gnhz8FYK/sLVwTrpocffcWJ29VyuWoqTPfhWt4nne5fmy/sQCA8oZymMwmsAwrC02d2YU4WSwWaFR2f0ymS1Xu5axJah0mAE42uWsKZF8e0Erf48aNQ1VVFYYMGeLrS4mA1ErfAiRWvPWkqby8HABgMBiI0SQ1TgKeNK34YgV+Mf6CPpo+MP5oRPOA5rDX5C1Ogo9CvOUQJ3+1PQBoaWnBzp2XcpXUajXmL5gPLatFi7kF729+H/G6eNlokhInjcb+5nrul1YAIEKTgKc4xcbGAgAqKytx4sQJIjQFsi8PaKXvgoICPPnkk3jppZeQnp6OHj16OP3cW6VMUiCp0jfP8+A4Dnq9XjyDqaPvctPkaO/Md7PZDLVaDYZhiNAkJU48z4PneWi1WnAc51bT4k8W4z/H/oPHpj6Gv875a9hrcvTdk91sNsNqtYrxJkGTlLYnvE7wp6Om1LdScfDsQXx5/Ze4csSVstDUmV2Ik9VqxZ/n7sRLO+fg3tE78HbFTNlrktL2HH/u6IucNQWyLw9ope8FCxYAAK6++mqnXTM8z4NhGLeBIxkSKn3zPA+j0Qi9Xk9cxVug8+qwVqsVERERTm1Z7pq8xYnneTQ3N0Or1brVdL79PL6u/BoAsGzCMqKqYhuNRpd4y12TN7sQ7+joaLfXj40fi4NnD+LHcz9iyWVLRHs4a/JmFyt9a+1vimYrK9rlrElK23OMt7udrXLUJBCIvjyglb6LiorEf4WFheI/4XuK/LBarSgqKlLUrgqA6vake2P5Rpg5M8bHj8f4eHLyFGm83ese189+LMrhs4eD6VbAsVqtaGpqBACYLT6/1ckWJbbzYGn2eYZp5syZgfCDQqGECR8e/BAA8Jtx8i8lQPGOkPhN2oAJgDjDZFLQgIkSOLrUinbu3Inf/OY3yMzMRF1dHQDgww8/xK5d5NXyoFCURNUvVfi25lswYHDLuFtC7Q4lCAgzTEcaj8DCSd8xJAfUvyZ9mzk6YKJ0H59b0RdffIHs7GxERESgtLQUpl8LXDQ3N+Mvf/mL3x2kBAclldF3hOp25uODHwMA5gydg4E9BwbTpaBA4+1KUkwSorXRsNgsOHbuWBC9CjwanT2fxWRxzXshGSW282Bo9nnA9Oc//xlvv/023nnnHadkqczMTJSWlvrVOUpw0Gg0WLhwoU/JbyRAdTvr5nme6OU4Gm/3uhmGEZflSCpgqdFoMGLkYACAmVPOgEmJ7TxYmn0eMB09ehQzZsxwsffs2RMXLlzwh0+UIGOz2XD27Fmn7ZpKgOp21r3v1D4cP38cEeoIXDP6mhB5FzhovD3rJjGPyWazwcobAQAmBQ2YlNjOg6XZ5wHTgAEDnIphCezatQtDhw71i1OU4MJxHHbv3q24khBUt7PuDw/YZ5eWjF6CaF10KFwLKDTennWTOGDiOA5nGuw5tmZOOUtUSmznwdLs84Dp3nvvxcMPP4zvvvsODMPg1KlT+Pjjj/HEE09g+fLlgfCRQqEEGAtnwafl9qNQSFyOo3SOkPhN0pIcAKh19q8mm3IGTJTA4XMr+sMf/oCLFy8iKysLRqMRM2bMgE6nwxNPPIEHH3wwED5SKJQAk1+Zj8a2RsT3iMe8YfNC7Q4lyAgzTFW/VKHV3Ioe2h5eXiEPVFr7VzMdMFH8QJf2Wr788stobGzE3r17sWfPHjQ0NOCll17yt29+Y8mSJejduzeuu+46J3tNTQ1mzZqFyy67DOPHj8fGjRtD5GFoYRjGY1VYkqG6L+kWkr1vHnsz1CyZby403p51x/WIQ3yPeAD2g3hJgGEYRPWKAACYbMpJgFZiOw+WZp/PkpMjRUVFaGlpwfvvv4/PP/9ctNfX1+PMmTNIS0vD2bNnMXHiRBw9etTlfDx3CGfJSTl/hkIJZy4aLyL+1XiYOBP237MfEwdMDLVLlBAw94O52Fa9Df+8+p/47YTfhtodv/DDJ0cw8ZZRSGDrUccNCLU7lDDEl/dySTNM11xzDZqamiQ7cOutt+Ls2bOSrw80WVlZiI52TWIdMGAA0tLSAAD9+vVDnz59cP78+SB7F3psNht+/vlnRe2qAKhuQfcXP34BE2fC6NjRmNB/Qoi9Cxw03p3rJu2IFJvNhottvwAATLw2xN4EDyW282BpljRg+s9//oOGhgY0NTV5/Xfx4kX873//Q0tLiyQHiouLcdVVVyEhIQEMw2Dz5s0u16xZswZDhgyBXq9Heno6du7c6ZNIKXz//few2WxITEz0+73DHY7jUFZWpqhdFQDVLegWluOWjl9K9DQ+jXfnukmrxcRxHH6uqwYAmHnlLMkpsZ0HS7OkZAWe5zFy5MiAONDa2orU1FTccccduPbaa11+vmHDBjzyyCNYs2YNpk2bhrVr1yInJwcVFRVISkoCAKSnp4sVxx0pKChAQkKCVx/OnTuH2267De+++67Ha0wmk9MzhBk3i8UCi8V+nADLslCpVOA4zmmkK9itViscV0BVKhVYlvVoF+4rIFQy7XjAoCe7RqOBzWZzakQMw0CtVjvZHZ/jyXe5aXK0d6bJUT8pmrzFydHfqnNV2P7TdgDADaNvgM1mk6UmQHqchK8kaerMd+EanuddrnfUNKrPKADA4TP2GaZw1tSZXdBksVig0ts/AJihJUKTlLYnvLbj4EHOmgLZl3fU0RmSBkxFRUWSbygwcKC0YxVycnKQk5Pj8eerVq3CnXfeibvuugsA8PrrryM/Px9vvfUWVqxYAQDYv3+/z/4JmEwmLFmyBE8//TQyMzM9XrdixQq88MILLvaCggJERkYCAJKSkjBhwgQcPHgQJ0+eFK9JSUnBqFGjsHfvXjQ0NIj2tLQ0JCcno7i4GM3NzaI9IyMD/fr1Q0FBgVMjy8rKQkREBPLy8px8yM3NRXt7u1Oc1Go1Fi5ciMbGRuzevVu0R0dHY/bs2aipqUFZWZmLnuPHj+Po0aPi93LWFBcXh8zMTI+aysvtya0Gg4EYTVLjJLDiK/vf0JgeY3D428OIzoiWrSZvcRJ8FOJNgiapcQKAlpYWp9n5jprauXYAwOnW02hsa0RrQ2tYa5ISJ5Xevohigh68jQ/7OPmj7cXGxgIAKisrnWomyllTIPvytrY2SCWskr4ZhsGmTZuwePFiAIDZbEZkZCQ2btyIJUuWiNc9/PDDKCsrw44dOyTfe/v27XjzzTedkr55nsctt9yClJQUPP/8852+3t0MU2JiIhobG8VEMbmO4K1WK0pLSzF16lQwDEPMJy1vn0pMJhP27duH9PR0qNVqIjRJiZMQ7ylTpiBtXRoqGiuwNnct7ki7Q7aaAO9xam9vx/79+8V4k6BJSpwc492RjppS1qSg+kI1ipYVYUbSjLDV1Jld0GQymbDzq13IvsFeJsPcaoFKr5K1Jiltj+M4lJaWIj09HSx7KetGzpoC2Zc3NTUhNjbWf0nfoaKxsREcxyE+Pt7JHh8fj9OnT0u+T3Z2Nq6//nrk5eVh0KBB2LdvHwDg22+/xYYNG7B582akpaUhLS0Nhw65X7/X6XTo2bOn0z9SUKvVmDp1quIObFSy7oyMDBxqPISKxgro1XpcM4q8o1A6ouR4Z2ZmStI9Jm4MADISv9VqNaZecWmQaGpyTdsgEV/iTQrB+tuWxW+0YyIqz/M+Jafm5+e7tV9xxRU+Z9WvXr0aq1evFke/pCzJRUZGYvbs2URNTXubxj1w4ABqamqI0iQ1TvHx8fjkl08AAOlR6fi28FvZayIxTv7SNHz4cAwcONBpVt6dJn2THgBw6MyhsNckJU6cmQNg/zBgbrXgHAGaBDpre3369IHNZsPx48eJ0RSovpwuyQUBoXZDfX29ONukVquh1WphNpudGpJgNxqNTgM0rVYLtVrt0d4xkHq9vTMzGo2S7JGRkbBarTCbzaKNZVno9Xonu9VqRVFREXJzc8HzvFvf5abJ0e7J99bWVmzduhVZWVniEo3cNUmJk9VqxdbCrVh+YjnOtJ7BxiUbkTs8V9aaHH33ZG9qakJRUZEYbxI0SYmT8Pe9YMECl0Tgjpo2/rgRt391OzITM7Hjth1hq6kzu6Cpra0NRUVFuGbxlbBBhVM/nEHc2L6y1iSl7XEch8LCQsyb51yxX86aAtmXNzU1YcCAAZKW5MJ6hkmr1SI9PR0Gg8FpwGQwGLBo0aKQ+NRxhqmoqMhlhqm8vNztCL60tNTtaLekpMRjkqq7EbyQ2CbQ2Qj+/PnzbkfwdXV1bpO+q6qqPCbVyU2T8KnEk6YjR44AuLSpgQRNUuN0oPkAzrSeQYw6BkwVA0O1QfaavMVJSHgWfCVBk9Q4AfYdye6Svh01XWy/CMC+JFdbW4sDBw6ErSapcdLCDCMiYG61hH2c/NH2hKTv6upqt0nfctQUyL484DNMtbW12LZtG6KjozF9+nTExcX5eguRlpYWMagTJkzAqlWrkJWVhT59+iApKQkbNmzA0qVL8fbbbyMjIwPr1q3DO++8g/LyciQnJ3f5ud1FmGEiIenbYrHAYDAgNzcXLMsSk/zoLVHQaDQiPz8f8+bNg0ajIUKT1LICue/mYscvO3B/+v14I/sN2Wty9N2Tva2tDQaDQYw3CZqklhUwGAzIyclxSWXoqMnMmdHrlV6w2qyofqgaA6Mu7XYOJ02d2QVNRqMRBoMByxbPwkXE4Og31Rg+Lzls4yRFk9SyAgUFBcjOzoZKpSJCUyD7cl+Svn2eYbr33nvx3nvvoVevXmhtbQXLsnj66afxxz/+0ddbAbAXjMzKyhK/f+yxxwAAy5Ytw/r163HjjTfi3LlzePHFF1FfX4+xY8ciLy8vpIMlRzQaDTQa56JoKpXKqaEKeEpI82TveN+u2FmWddop4c7OsiySkpLERubOd7lpcsST7xqNBklJSdDpdE4/l7MmKXFqs7bhu6bvAADL0pa59UdumqTYdTqd23jLWZMU34W/b0/PdPRdo9FgVOwoHD57GBWNFRjce3BYavJmZ1lWjLeWMQM8YG6zhnWcvNmltj0h3hqNhhhNAoHoyz356/Z1kq/8FZvNhh9//BHDhg2D1WrFp59+iqeeego7duzAZ599hpiYGJ/uN2vWLHib5Fq+fDmWL1/uq6tBgYTClQAwbty4Tn2XoyZvn0oAYOzYsbDZbGLBRrlrkhKnzUc2w8gZMaz3MEyMn+jkv1w1OfruyW6z2ZziTYImqXESjoDqrHClwJjYMTh89jAOnj6IeYMv5cGEmyZvcRLirWMbAA4wtVrDPk7+ansTJkwAx3FOz5W7pkD15X4vXOnIO++8c+nFajV+85vf4KqrrsJ1112HmTNnus2LIQlSd8np9XrMnTuXuN0idJecq6Z/VP4DAHDz2Juxc+dOIjQB5MXJn5oGDRqEYcOGed0lBwA9Wu2Hj3/303fIO3/pPuGmSWqcNEgFYJ9hCvc4+avtRUREQKfT0V1y4bRL7tixY8jLy8OWLVtQXFwMhmFcMuFJheYwhbcmRzvNYbqk6WzrWST/Ixkcz+HwvYeREpsie00dfac5TF3PYQKAzUc344YvbsDlAy9H8bLisNTUmb1jDtPTN4zBj+bhKHqtDDMeGh+2cZKiieYwySyHqaCgAFu2bEFeXh6qqqrQv39/LFiwAP/+978xf/58X28ne0jIYXKEpLV8gc40Cc9wfI7cNXUWpy+PfgmO5zAicgRG9h1JhCapdsHHjvEmQZMUO8MwkjQN6TMEAHCy6aTb68NJkyc7y7KiXcva36jN7Zws4uTJ3pW250v85KLJ3315QHOYFi5ciClTpuD2229Hbm4uJkyY4OstiIKEHCZ6+K5yDt/98OCHAICZvWeKvshdU0ffvWmih+92rimhh/3A8vrmerQaW6FVacNOU2d2x8N3AUCrsv/c1MaFdZykaJI6wwTQw3fDIofp7Nmz6N27t9frPvnkE1x99dXo0aOHr48Ia0jNYYqMjATLssSt5Xe27l1RUQFAOYfvHqg9gH2n9oEFiyUjloBlWezYsUPWmujhu9Irfbe1tUnKYYqKioJOpYOJM+Hj/36MeF18WGqSGieVzX4kitnIhX2c/NX2UlJSUFVVpZgcpu705WFR6btnz54oKyvD0KFDA3H7kENSDpOjnaRPWlSTs6YXi1/ESztfwvyh8/H1rV8ToYnEOIWDptFvjcaJ8yew7TfbMD1puqw15cQfxLZf0vHx8m9x0//LICpOJLa9YGsKaA6TVMLoxJWAQkIOk9Vqxd69ezFlyhSo1Woi1/Ld+c7zPPbt2yfq9ua7HDR1Zv+k3H523C1jb8GePXtcdHfVd0/2cMv3YRjGqZ135rsne7hpkuK71WrF7t27MWXKFMmakmKScOL8CZxqPSW5fwu3PsJms2Hv3r3QqOw/N5v4sI6TN7vUtme1WlFSUuIx3nLUJBCIvjygOUwUZ0jJYWpoaADP84r6VGK1WtHQ0ACz2Qye54nQ5Mm+++RunDh/ApGaSOQMycHuHbvFcwPlqsnXOJnNZqd4k6BJag5TQ0ODU16PN01JMUkAgOrz1eJrwklTZ3ZBkxBvnbofAMDUbgvrOEnRJDWHqaGhwcUXOWsKZF8e0BwmpUNqDpMAaWv5na17l5eXA1BGDtNr214DAKT3SMfuHZeeI2dNNIdJepwA+zFUO92cJedOU2LPRADAt4e/Rd7FvLDUJDVONos9R8Vs4sM+Tv5oe8JZcpWVlW7PkpOjpkD25WGRwxQdHY0DBw7QHCaE/wie1mEiuw4Tz/AYuGogzraexX9u+A/mJs8V480wjCw1dSVOtA6TtDpMDMNg/cH1uPt/dyNnWA7+c+N/wk5TZ/aOdZg2PtIHH/80Ha8s3I7H/jsjbOMkRZPUGSZah0lmOUxKgYQcJpVKhbS0NLExkbKWL+DJd61Wi7S0NOj1eqfXyVmTO/s3J77B2daziI2MRc7IHKgY53jLURPge5z0er3beMtZkxTfhb9vtVot2XdhSa6muUa2OUxCvP+r/RkAYDaHd5y82aW2PSHeWq3WJ63hrEkgEH15WOQwJScn++QIJXSwLBs2hxkHE6Xo/ujgRwCAm8bcJCbAKkF3R5QS7450RbewJHfy4kkvV4Yvgm699icA9gGTElBiOw+WZvcfL93wr3/9CyaTSfKNDx8+jMTExC45RQkuVqsVhYWFLlOmpKME3S3mFmw6sgkAcOv4WwEoQ7c7qG7puhNj7H13k6kJF40XA+VaQBF0a9T2pRcf3r5kjRLbebA0S55huvvuu3HllVeiXz/7joOEhASUlJRg8ODBgfJNFpCyS665uVmRu+Sam5uJ3iW3qWIT2ixtGNZ7GCb2myi2VyHectTUnV1yjvEmQZPUHKbm5mafdslFaaPQJ6IPzrefR9W5KoztNzasNHVmd9wl19zcDI0mGgBgtiCs4yRFk9QcpubmZsXtkutqXx6QXXIdc8OFP0ClQXfJyUcT3SUHvHPmHQDAjN4z8PXXX6MjctREd8kFfpfc7Nmz0T+iP863n8eXhV/iZM+TYadJapzaWs8DAExmJuzjRHfJEbJLjmVZnD59WpxhIn0XnDfoLrnw1uRoV+ouubOtZ5H8j2RwPIfy+8oxos8IAM7xprvk5K0pULvk1Go1rvr3Vfjq+Fd4c8GbuGfiPWGlqTN7x11yB96IwnNFc3D3qGK8XX5F2MZJiia6S04mu+QYhnH6Y+v4vVIhZZdcRkaGInfJZWRkELtL7sujX4LjOUxOmIzL4i9zusYx3nLS5EhXdsm5i7ecNUndJZeRkeHTLjkASO5lT6Kta6lzuV+oNXmzC7vkMjIycHSd/Zwxk5kN6zh5s/uySy4jI0Nxu+S62pcHZJccz/MYOXKkOEhqaWnBhAkTXESdP39e8sMp4QHLsuLMoZIgXffHhz4GANw67lYnO+m6PUF1+4ZYWqCpxt8uBQVBt17/IwDAbJW8x0nWKLGdB0uz5AHTe++9F0g/KCHEYrGgoKAA8+fPV1QpCJJ1nzh/At/VfQeWYXHj2Budfkay7s6gun3TLffSAoJutaYHAMBkUcaASYntPFiaJQ+Yli1bFjAnKKFHSVtQHSFV978P/RsAMHfoXPSP6u/yc1J1e4Pqlo4wwyTXARNg163R2VdFzJwyBkyAMtt5MDTTSt/dhJSyAgIkJT9KSeh01E+KJo7jxGKVN4+5WXymu220ctHkz7YnfCVJU2e+C9fwPC+5rIBarcag6EEAgNqmWhhNRqhV6rDR1Jld0CTcR6P7tQ6TVRXWcZKiSWrSNwAnm9w1BbIvp4fvBhBaVkA+mpRaVqDwSCGOnz8OLaPFOPU4AHDRJCAXTbSsQPDLClgvWMGChdVmxSf/+wQpCSlhpUlqnOrP2HOwzJwq7ONEywoQUlaA4gxJZQV4nkdrayt69eoFm81GzCctKcXOmpqaEBUVBYZhiNDEcRweL3gcb+x9A9eNvg6fXvupiyae59HW1oaYmBhwHCcLTf4qXNnS0iLGmwRNUuLE8zza29sRHR3tMuvgTdPgNwajpqkGO5ftxOWDLg8bTZ3ZBU1WqxUtLS3YvvIIrv1bJqb2OIySpsvCNk5SNElpewDQ3t6OyMhIRRWu7GpfTg/fDSIklBXgeR5RUVGd+i43TY50pik6OhpqtdqpRIacNYEBPqv4DACwNHWpeI2j7zzPo0ePHi72rvruyR6OW/DdxVvumrzZeZ4Xy8D4qikpJgk1TTU41XpK9CEcNHmzsywrxjuih/3nZpsqrOPkzS617fE8j4iICKhUKrelf+SoSSAQfbkvSeJdzoL7+eefaQkBQrBarcjLy1NcoiCJurf/tB31LfXore+NBcMXuL2GRN1SoLq7nvhdc1F+pQUE3Rq9/Q3UZFPGjjEltvNgafZ5wPTpp58iJSUFQ4cORVxcHCZPnuy0Lk6hUEKHUHvp+suuh1alDbE3FLlDwk45TYR9RsJsowsqlO7h84DppZdewh/+8AccOnQIxcXFSE1NxZw5c/Dyyy8Hwj8KhSIRo9WIL378AgBw6/hbvVxNoXhHrMXUJN8Bk66HfaCklBkmSuDwechdVlbmtOY3bdo03HXXXbjxxhtx7NgxvP/++351kEKhSGPLsS1oMjUhsWcirki6ItTuUAiAqBkmng6YKN2j27vkysrKsGXLFmzYsAHl5eUu2fqkIuySk5JZH+7wPA+r1eqSMEc6pOm+ZsM12HRkE56c9iT+OvevHq8jTbdUqG7fdR84fQBpa9MQFxmHs78/GyAPA4Ogu3JrDUbnDkUv5gJ+sfUKtVsBR4ntvDuafXkv93lJrqWlBZs2bcLdd9+NgQMHYuLEiXjvvfcwc+ZMbNmyxdfbUcKE9vb2ULsQEkjR/Uv7L9hy3P73d8u4W7xeT4puX6G6fSMxxr4k19DWgHaL/H537e3t0EbaF1KUNMOkxHYeDM0+L8n17dsXLMviiiuuwBNPPIHc3FykpKQEwjdZQEql76KiIuTm5oJlWWLqkXir3WEymVBUVIR58+ZBo9HIWtPG8o0wc2aMjRuL0X1Gd1rx1jHeDMOErSZ/tz2heJ4QbxI0Sa30XVRUhJycHJdP3940Rami0EPTA62WVlSfr8Zl8ZeFhabO7IImo9GIoqIijI1LBQCYoAvrOEnRJLXSd1FREbKzs5224MtZUyD78oBW+v7ss88wd+5csY6L0qCVvuWjSUmVvt+pfcf+7Ngsp+d60iQQzppope/QVvoWNPVme6MVrTDsNeCyqy4LG01S47SvbC+AweCgxk+VVThUcShs40QrfdNK30RCUqVvi8UCg8GguBkmo9GI/Px82c8w1TXXYej/GwoePCofrBR3Njlq7fiJSoi3kmaY2traYDAYFDnDZDAYujTDxHEcrvz0ShRUFWDdwnW4e9LdYaGpM7vjDJPBYMDlYzPQf3g/AEBLQyu0MZfKbYRTnKRokjrDVFBQoKgZpu705bTSdxAhodK3ow8kVbwV6EyTWq12iaHcNH1+5HPw4HFF0hUY2neoJN+F78NVkxR7V+LkLt5y1yTFLiTDdkWTkMd0uvV0p76HWx8hxLtHr0jRbm2zokes6+qIXDRJbXtqtRoqlcrtfeSqCQhMX+5LpW86YKJAo9Fg4cKFoXYj6JCgm+d5fHDgAwDAreOk1V4iQXdXoLq7RkJ0AgDgVPMpf7kUFATdvO3SDIO5VXq+ilxRYjsPluYuH41CIQebzYazZ886TXUqARJ0l50uw6Gzh6BT6XDjmBslvYYE3V2B6u6a7gFRAwAA9S31/nQr4Ai6efDQwAwAMLWQP2BSYjsPlmY6YKKA4zjs3r1bMTW0BEjQ/f4Be6HYRaMWoXdEb0mvIUF3V6C6u6ZbrjNMjrp1MAFQxgyTEtt5sDTTAROFIlPMnFk8O25Z6rIQe0MhFbkOmBzRMvaBkhJmmCiBgw6YKBSZ8vXxr9HY1oj+Uf0xf9j8ULtDIZQB0fYludMtp2Hj5bnMo2PsS3LmtsCeZk8hGzpgooBhGERHRyumjL6A3HULy3G3jrsValb6/g256+4qVHfXdMf3iAcDBhzPoaHVtZZXuOKoW8vYB0qmVvIHTEps58HSTOswdRGSzpKjyI9zbecw4O8DYLFZcPC+gxgXPy7ULlEIpv+r/XGm9QxK7ynFhAETQu2Oz6Roq3HMMgQ7Vx/EFcvHh9odShgR0LPkKORhs9nw888/K2pXBSBv3Z8c/gQWmwUTB0z0ebAkZ93dgeruum4hj0lOO+UcdWtZ5cwwKbGdB0szHTBRwHEcysrKFLWrApC37vVl6wF0Ldlbzrq7A9Xddd1CHpOcEr8ddQsDJnM7+bFXYjsPlmZFDJiWLFmC3r1747rrrnOyNzc3Y/LkyUhLS8O4cePwzjvvhMhDCkU65WfLsb9+P9SsGjePvTnU7lAUQEKUvHfK6VS/zjC1K2fWheJ/FDFgeuihh/DBBx+42CMjI7Fjxw6UlZXhu+++w4oVK3Du3LkQeEihSEdI9r5y5JWI6xEXYm8oSkBckmuWz5KcI1qVfebB1KacWReK/1HEgCkrKwvR0dEudpVKhchI+zlDRqMRHMdBiTnwDMMgLi5OUbsqAHnqttqs+OjgRwC6XntJjrr9AdXddd3iklyLfGaYHHXr1PYZJouZ/P5die08WJpDPmAqLi7GVVddhYSEBDAMg82bN7tcs2bNGgwZMgR6vR7p6enYuXOn355/4cIFpKamYtCgQfjDH/6A2NhYv91bLqjVamRmZno8qJBU5KjbUGlAfUs9+kb0Re6I3C7dQ466/QHV3XXdcixe6ahbq7IvxZmN5C/JKbGdB0tzyH+jra2tSE1NxR133IFrr73W5ecbNmzAI488gjVr1mDatGlYu3YtcnJyUFFRgaSkJABAeno6TCaTy2sLCgqQkJDQ6fN79eqFAwcO4MyZM7jmmmtw3XXXIT4+3uU6k8nk9IympiYAgMVigcVirx7LsixUKhU4jnPK1hfsVqvVaQZLpVKBZVmPduG+AkJjsFqtkuwajQY2m80pEY5hGKjVaic7x3GoqqpCSkoKALj1XW6aHO2efDebzTh+/DiGDRsm+hfumoRk75vH3gzGxsBi873tcRyH6upqjBw5EjzPh1yTtzj5q+0ZjUZUVlaK8SZBk5Q4CfEeMWKEywy6VE39IvoBsC/JhYOmzuyCJrPZLMZbo7brMBptTvcPpzhJ0SSl7dlsNlRXV2Po0KFOMy5y1hTIvryjjs4I+YApJycHOTk5Hn++atUq3HnnnbjrrrsAAK+//jry8/Px1ltvYcWKFQCA/fv3d9uP+Ph4jB8/HsXFxbj++utdfr5ixQq88MILLvaCggJxWS8pKQkTJkzAwYMHcfLkSfGalJQUjBo1Cnv37kVDw6XCb2lpaUhOTkZxcTGam5tFe0ZGBvr164eCggKnRpaVlYWIiAjk5eU5+ZCbm4v29nYUFRWJNrVajYULF6KxsRG7d+8W7dHR0Zg9ezZqampQVlbmdJ8RI0agsrISR48eFW1y1hQXF4fMzEwcP37craZDhw6htrYWJ06ckIWmFmsLNh/ZDACY1WuW0/19jRMADB8+HDt37gz7OPmr7W3btg1Wq1WMNwmapMYJsPdxjrPzvmg6Z7bndp5uOY0jR4/gxPETIdckNU4nTpwAb7WnZFy80OZ0n3CLkz/aXmxsLBobG8FxnNjW5a4pkH15W1sbpBJWhSsZhsGmTZuwePFiAIDZbEZkZCQ2btyIJUuWiNc9/PDDKCsrw44dOyTfe/v27XjzzTfx+eefi7YzZ84gIiICPXv2RFNTEzIyMvDJJ59g/HjXwmbuZpgSExPR2NgoFruS6wjeYrHAYDAgNzcXLMsS80nL26cSo9GI/Px8zJs3DxqNJuw1vfvDu1j+9XKM7TcWP9z9g5MvvsTJMd4Mw4R9nPzV9tra2mAwGMR4k6BJSpyEeOfk5LjkeEjVZLVZ0eOvPcCDR+0jtegX2S+kmjqzC5qMRqMY7/vG7ceHVdOxcuF2PLJpmovWcIiTFE1S2p7VakVBQQGys7OhUqmI0BTIvrypqQmxsbGSCleGfIapM4RRcsclsvj4eJw+fVryfbKzs1FaWorW1lYMGjQImzZtwuTJk1FbW4s777xTXJZ48MEH3Q6WAECn00Gn03VLD4XSHT44aN/puSx1mctAh0IJJGpWjfge8Tjdehr1LfVOAyY5oFXb/1bMJvo3Q+k6YT1gEuj4qYjneZ+y4fPz893a09PTXZalvLF69WqsXr1aHP2SsiSn1+vBsixRU9PepnErKioAAAaDIew11RnrsKduD1iwuHXcrd2OU58+fcCyLHbs2BH2cfJX2xN8FOJNgiapcRo0aBDa2tqcZuV91dST7YnTOI3vj36Puu/rQq5JapwMBgMsZg0AoLnZRPySXFxcHJKSklBVVYXjx48ToylQfTldkgsCwvkzJCzJOdpJmpomSdOz25/FX0v+ipxhOcj7TR4Rmjraqabw1rT4s8XIO5GHt3Pfxm/TfisrTU9M/hb/ODALT2UU4cUdV7hoJSlOVJNvmnxZkgt5WYHO0Gq1SE9PF0eNAgaDAZmZmSHyijw4jsOBAwcUVUofsOs+ePBg2Ou28TZ8fPhjAMDS8Uu7fT8lHp0AyCfe/objOPzwww/d1j0gyl6LSS7nyTnGW6v5dUnOTH5tIn/FW04E62875EtyLS0tTpn81dXVKCsrQ58+fZCUlITHHnsMS5cuxaRJk5CRkYF169bh5MmTuO+++0LiL6lLcgAwfvx4Re6Sq62tDWtN7+98HzVNNeih6oH+F/sDQLeXEABg3LhxitwlJ8SbBE2+7JIbPHhwl3fJAYCtyf4J/kjdkW7t0Az231NtbS3a2+0DptY2C/FLcsIuOa1Wq7hdcl3py2W1JLd9+3ZkZWW52JctW4b169cDsBeuXLlyJerr6zF27Fi89tprmDFjRpA9dYakJTm6Sy68d8ndtuk2fHz4Y9w94W6syV3T7alpukuO7pLriqZ3fngHD3z9AK4ccSW+vP7LkGrqzO5ul9zKhd/hhe1ZuGf0Drx54NLqRDjFSYomuktO4bvkZs2a5XW3z/Lly7F8+fIgeUShhA/NpmZsOroJAHDb+NtC7A1FyQgH8J5ukb5DOVzQau1fzZawzkKhhDkhHzDJDVKX5CIjI+kuuTDU9M6376DN0oYEXQIayxqx99RevywhxMfH011yBGiSGqfhw4d3e5fcOa29eOXJCydltSRnMBjQ3GyfDWk32ohfkouLi0NKSgrdJUfikpxcIWlJztFO0tQ0CZpmrZ+FHT/vwIszX8RT054iQhOJcVKCpvqWeiT/Ixksw6L1yVaoWJVsNL118y48/EUWrh9Ugo+rJrtoJSlOVFPgdsnRGaZuotFooNFonGwqlcpp7VhAaDhS7R3v2xU7y7JgWddpaEe71WrF3r17MWXKFKjVare+y02TI55853ke+/btE3V78z3Ymqp/qcaOn3eAAYPbJ9zu9DpPmqTEyWq1Ys+ePS66g6GpM3t3NEmxMwzj1M47892TPdw0SfHdarVi9+7dmDJlSrc0JcQkgGVY2HgbLlguoH9U/5Bp8mYXcjGFeOv1dr/MVpXb68MhTt7sUuNktVpRUlLiMd5y1CQQiL7ck79uXyf5SopbSDh812KxoKGhATzPK+pTidVqRUNDA8xmM3ieDztNHx78EACQNTgL/SP7w2Kx+OWTlmO85RAnf7U9s9nsFG8SNElN+m5oaIDNZnO53ldN8T3iUd9Sj5O/nERfXd+QaerM7nj4rhBv9a85TBaOIf7wXaFf6+iLnDUFsi+X1eG7coPUHCYB0tbyO1v3Li8vBxCeOUxRUVF4v/x9AMB423jxXv7KuRCQQ5xoDpN/ygq0tLR0q6xAXFwcBkQPQH1LPf5b9F/Ux9SHVJMvOUyN540AAKOFIT6HKTY2FgBQWVmpmLIC3enLaQ5TECAph4mWFQi/sgLf1nyLrA+zEKWNQs1DNeih7SFJEy0rQMsKdPTdX2UFGIbBko1L8NWxr/BWzlu4c8KdIdPUmd1dWYGvnvkBN74+DTNiyrC1YYyL1nCIkxRNtKyAwssKyB0ScphUKhXS0tLExkTKWr6AJ9+1Wi3S0tLEc/S8+R5MTR8d/ggAcP1l16NXj14u13cn56JjvLvruyd7uOX76PV6t/GWsyYpvgvxVqvVPvnuzi6UFjjTdibs+z3HeOsj7c8yc+TnMAnx1mq1PrXJcNYkEIi+nOYwUXyCZVkkJyeH2o2gE6662y3t2FixEQCwLHWZ3+8frroDDdXdfQZE249HOdV8yi/3CySOurURvyZ9c+S/5SmxnQdLM/mtJ8CQkPQt7KqYOXMmGIYhZmra2zSuyWTCrl27kJmZKX76DgdNX1Z8iSZTE5JjkjEtcZrfk1Qd4w0g7OPkr7bX3t6OkpISMd4kaJISJyHe7k5H8FVTQrR9hqmuuS7s+z2TySTGWyUUrrSpiU/65jgOJSUlmDZtmtNsi5w1BbIvp0nfAYTkpG+e53HixAlikh+9JQoePnwYLS0tKCgoCCtNr1W9BsB+0G5dbV1AkokBe7yVdJZcYWGhmN9BiiZfkr6bm5u7nfSdEGsfMB2pvXSeXLj3EQUFBWisMwOYBJNNpYik7+bmZpw4cUIxSd/d6ctp0ncQoEnf4a3J0S6npO8zLWcw+P8NBsdzOPrgUQzvPdzvMxc06ZsmfXdV04GzBzDpnUkYEDUAPz/0c8g0dWZ3l/Rd9u8TmHb3eAxW1+BY26X6UeEUJymaaNI3TfqWNSQkfTtCUvKjQGeahGc4PieUmj4/+jk4nsPUgVMxsu9I8WfufFdSnPypqWO8SdAkxc4wTLc1CUtyZ1rPgFWxYrVvIPzanmO8I6N1AOxLcqQnfQuoVL4luMtFk7/7cl+SvulJhBSoVCpkZGS4bYgkE466PzjwAQDgttTAHbQbjrqDAdXdfd39evQTq32fbT3rB+8Ch6NuMembl/7mKFeU2M6DpZnOMHUTEpK+AaBPnz5gWZaoqWlv07g8z6N3797gOA4cx4Vc04H6A/jh9A/QsBpcm3ItAARsqSc2NlY2cfJX2+M4zineJGiSGqe4uDgArgmuXdEkVPuuuVCDWH1sWPcRQrxZnX0p0sxriE/6ZhgG/fr1A8dxTs+Vu6ZA9eU06TuAkJr0zTAMcnJyUFlZSUzyo7dEwbKyMtTW1oaNppf++xIAYGL0RJR/X4742fEBSyZmWRYLFixQVNK3kjWpVCpkZmZ2O+k7MzMTvdS9UI96fLX9K9T3rJdFnKwnAWAYzNAqIun7woULGDx4sGKSvrvTl9Ok7yBAk77DW5OjXQ5J3xarBYPfGIxTLafw2bWfYcmoJQGbuaBJ3zTpuzuaFny0APmV+Xhn4TtYlrosbPsIx6Tv80cuIDE9ASw4GM2XfAynOEnRRJO+adK3rKFJ3/LWJDwj1Enf23/ejlMtp9Anog+uHnW1+CwaJ5r03Zk92EnfANA/yr7LrNHY6FJRPJzanlPSd0wEAMAGFVgeUGmd/QynOHmy06RvmvRNoVAAfHDQnux945gboVPrQuwNheKZ+B7xAIDTLadD7Il0tD0uvSmaW8wh9IQiZ+iAiQK1Wo2srCyPo3FSCRfdLeYWfPnjlwACuztOIFx0Bxuq2z+6hRmmM61n/HK/QOGoWxulFe2kD5iU2M6DpZkOmCgAgIiIiFC7EBLCQfeXP36JNksbRvQZgakDpwblmeGgOxRQ3d0nPso+w3SmJbwHTMAl3ZpIhxmmVum7ouSKEtt5MDQrZwgaIEgoK6DUpG+TyRQWSd9C7aVbxt4i/iyQycRKTfpub2+nSd9+SPqOi7CXKKhvrofFYgnbPsIx6Vur1UINHlZo0HqxHb1+fUY4xUmKJpr07f++nJYVCCCklhUQIGl7rbetqOXl5QAAg8EQMk0XbBdQWF0IAEhoSBBfE+jt6gJyiJO/2p7goxBvEjT5cpZcS0uLX8oKGM8ZAQB1F+qQl5cX9n2EwWBAdHQ0tJgKKzQoLtyFmDORYRknf5UVAIDKykrFlBXoTl9OywoEAVpWILw1OdrDuazAK7tfwTNFz2BG0gxs/c3WbmuiM0y0rEBH3/09w3Sm+Qz6r7LnMbU82QK9Rh+WfUTHGaY4bQsu8L1w6L/HkLJgiJOmcIiTFE10homWFZA1tKyAvDUJzwhFWQGe5/Hx4Y8BAEtTl/qkVWlxomUFwqesQFxUHNSsGlabFb+Yf8Eg/SAA4df2HOOtVquhhf0Nnje7viac4uTJTssKhL6sAJ1h6iLCDJOUUWm4w/M8rFYr1Gq1yydQkgm17tL6UqSvS4dOpcOZJ84gRh8TlOeGWneooLr9p3vgqoE41XwK++7eh0kJk/xyT3/TUXei+hRquQR8/+GPSP/N6FC7FzCU2M67o9mX93K6S44CAGhvbw+1CyEhlLqFZO/FoxYHbbAkQOOtLPytWywtEOY75Rx1axn7DJO5zerpcmJQYjsPhmY6YKLAarWiqKjIZY2ZdEKp28JZ8O9D/wYALB2/NKjPpvGmuruLULwynGsxddStZe1fze1cZy+TPUps58HSTAdMFEoIyK/MR0NbA/r16If5w+aH2h0KxSeEGSZZVfv+dcBkMdm8XEmhuIcOmCiUEPDhwQ8B2GsvaVTSkw4plHBAnGEK8yU5R7SsfWaJ9BkmSuCgAyYKAM+7CUgnFLovGi/iP0f+AyA4R6G4g8ZbWfhbt1Dt+3RreM8wOerWqn5dkjOSP8OkxHYeDM3K+636GRIqfQNAdnY2cfVIvNXuYFkW8+fbl8McKxYHWtPn5Z/DxJkwOnY0xvQdAwBBr++Tk5Mjmzj5q+0BcIo3CZqkxik3N1fU7Q9NsXp7ccTTzafBcVxY9hHApXhbrVZoVXYt7a2X+uxwi5O/2t7ChQvBcZzTc+WuKVB9Oa30HUBIrfQdExODGTNmEFXxNlyr+L65400AwAT1BBgMhpBoGjp0KMaMGUPjpBBNkydPRo8ePbB9+3a/aPrp8E8AgKozVTh48KAs4qRV2beMnzj2E/LyzrloCoc4+avtDR8+HOfOncOxY8eI0RSoONFK30GAVvoOb02O9nCq9H229SwGrhoIjudQcV8FhvcZHvSZC1rpm1b67q6m8rPlSF2Xil76Xmh8ojEs+4iOlb6XDCzFV2enYN1tO3D7u5kumkIdJymaaKVvWulb1tBK3/LWJDwjWJW+v/jxC3A8h0kJkzA6/lLxPBonWum7M9/DqdK3SqXCoF726t4XjBdg5a1QQRV2bc+l0rfa/kbLWVx/D+EUJ092Wuk79JW+adI3hRJEPjn8CQDgpjE3hdgTCqXr9Nb3hoa1v9GEcy0mR4QBk9lEF1UoXYMOmChgGAbR0dGKKaMvEGzdNRdrsOvkLjBgcOPYG4PyTHfQeFPd/rinsFMuXEsLdNStlAGTEtt5sDTTJTkK1Go1Zs+eHWo3gk6wdW8o3wAAmJ48HYN6DgracztC460sAqU7vkc8aptqw3aGqaNurebXAZM5VB4FByW282BppjNMFNhsNvz8889OyXRKINi6Pz38KYDQL8fReFPd/iDcq3131K3V2GeWSB8wKbGdB0szHTBRwHEcysrKnHYlKIFg6j5+7jj21++HilHhusuuC/jzOoPGm+r2B+Fe7bujbu2vub2kD5iU2M6DpZkOmCiUICAke88dOhdxPeJC7A2F0n3CfYapI0qZYaIEDjpgolACDM/z4oDp5rE3h9gbCsU/iEnfYZrD1BGt1v7VbFFOMjTFv9ABEwUMwyAuLk5RuyqA4Ok+eOYgjjQegU6lw+JRiwP6LCnQeFPd/iDcZ5g66lbKgEmJ7TxYmukuOQrUajUyMzND7UbQCZZuIdk7d0QuYvQxAX+eN2i8lUWgdIs5TGE6w9RRtzhgspI9kFBiOw+WZjrDRAHHcThy5IiikgSB4OjmeR6fltsHTOGyHEfjTXX7g3Cvw9RRt0acYSL7bU+J7TxYmsluOb+yZMkS9O7dG9dd5353UltbG5KTk/HEE08E2bPwwGaz4ejRo4rahgoER/ee2j346cJPiNJGYeHIhQF7ji/QeFPd/kBYkrtougij1ejXe/uDjrq1WvvMktlK9tueEtt5sDST3XJ+5aGHHsIHH3zg8ecvv/wypk6dGkSPKEpBWI5blLIIkZrIEHtDofiPGF0MtCr7tE24zjI5otUpY8BECRyKaDlZWVmIjo52+7Pjx4/jyJEjyM3NDbJXFNLhbBw+q/gMQPgsx1Eo/oJhmLBP/HZEq7e/3Zk5RbztUQJAyFtOcXExrrrqKiQkJIBhGGzevNnlmjVr1mDIkCHQ6/VIT0/Hzp07/fb8J554AitWrPDb/eQIy7JISkpyezo0yQRa946fd+B0y2n01vfGvGHzAvKMrkDjTXX7i3BO/O6o+9IMk+tp9yShxHYeLM0h3yXX2tqK1NRU3HHHHbj22mtdfr5hwwY88sgjWLNmDaZNm4a1a9ciJycHFRUVSEpKAgCkp6fDZDK5vLagoAAJCQken/2f//wHI0eOxMiRI1FSUtKpnyaTyekZTU1NAACLxQKLxQLAHjSVSgWO45zWUgW71WoFz186+FGlUoFlWY924b4CarU9XFarVZJdo9HAZrM5JcIxDAO1Wu1iHzduXKe+y1GTYPfkOwCMHTsWNpsNNpvN75o+PvgxAOCaUdeAsTHgWT7gmqTGKTU1VTZx8lfbs9lsTvEmQZPUOKWlpQGAy/Xd1RQXaS/CeqblTNj1EY7x5nneaYZJeEa4xclfbW/ChAngOM7puXLXFKi+vKOOzgj5gCknJwc5OTkef75q1SrceeeduOuuuwAAr7/+OvLz8/HWW2+JM0P79+/v0rP37NmDTz/9FBs3bkRLSwssFgt69uyJZ5991uXaFStW4IUXXnCxFxQUIDLSnpuSlJSECRMm4ODBgzh58qR4TUpKCkaNGoW9e/eioaFBtKelpSE5ORnFxcVobm4W7RkZGejXrx8KCgqcGllWVhYiIiKQl5fn5ENubi7a29tRVFQk2tRqNRYuXIjGxkbs3r1btEdHR2P27NmoqalBWVmZaNfr9Zg7dy6OHz+Oo0ePinY5a4qLi0NmZqZHTQcOHEBNTU3ANNnO2jBAOwDJzcnIy8sLiiapcerTpw8yMzNlEScS216wNQ0aNAjDhg3Djh07/KopqjkKE/pMQO+I3mEfJ62+BwCgzQzxXuEWJ3+1vYiICOh0Ohw/fpwYTYHqy9va2iAVhnccfoUYhmGwadMmLF68GABgNpsRGRmJjRs3YsmSJeJ1Dz/8MMrKypz++L2xfft2vPnmm/j888/d/nz9+vU4fPgwXn31Vbc/dzfDlJiYiPr6evTs2ROAvRFotVqYzWanhiTYjUaj0+hYq9VCrVZ7tHcMpF6vBwAYjUZJ9sjISFitVpgdzgJgWRZ6vd7JbrVaUVRUhNzcXPA879Z3uWlytHvyvbW1FVu3bkVWVhbUanVANAl/XgzDBEWTlDg5xrvjJ7ZwjJO/2l5TUxOKiorEeJOgSUqchHgvWLDAZdu1XDV1Zhc0tbW1ifHWarXY/uph5PzfJEyI+BG7GpNlqUlKnDiOQ2FhIebNc04DkLOmQPblTU1NGDBgAC5evCi+l3si5DNMndHY2AiO4xAfH+9kj4+Px+nT0pMMs7OzUVpaitbWVgwaNAibNm3C5MmTffJFp9NBp9Nh9erVWL16tdjxFBUVucwwlZeXux3Bl5aWuh3tlpSUuB3BFxUVuR3BGwwGJ986G8GfP3/e7Qi+rq7OaQQvUFVV5XYEL0dNwqcST5qOHDkCAOIzSNAkNU4CJGnyFich91HwlQRNUuME2NMfHPM/5a5JapyKiorsM0wRvQEAJisj3kuumgDPcYqNjQUAVFdX48SJE0RoCmRfTswM06lTpzBw4ECUlJQgIyNDvO7ll1/Ghx9+KP6SQkFTUxNiYmLQ2NgojkrlukZssVhgMBiQm5sr5np09F1umhztnnw3Go3Iz8/HvHnzoNFoiNAkJU6O8WYYhghNjr57sre1tcFgMIjxJkGTlDgJ8c7JyXE5OkKumjqzC5qMRqMYb61Wiz3rKjD9gfEYqanC4dZEWWqSEier1YqCggJkZ2eL+T1y1xTIvrypqQmxsbGSZpjCOo0+NjYWKpXKZTbp7NmzLrNOlK7DsixGjBihqF0VgF338OHDFal75MiRitRN460cOsZbG2EfPJh5TSjdCjgsyyIlJUVR8Q7W33ZYL8lptVqkp6fDYDA45TAZDAYsWrQoJD51XJIjJek7Li4OKpUKR44cISr5sbNEQWFqWpi2JkGTL3FSqVQoLCwkSlNncdq2bRusVqsYbxI0+RInIaeHJE1S4nTixAlER0ejT+RAAICJUxOf9J2ZmUn7chKTvltaWkSREyZMwKpVq5CVlYU+ffogKSkJGzZswNKlS/H2228jIyMD69atwzvvvIPy8nIkJyeHzG+SluSsVitKS0sxdepUMAxDzNS0t2lck8mEffv2IT09HWq1mghNUuLkGG8ARGhy9N2Tvb29Hfv37xfjTYImKXES4j1lyhR0RK6aOrMLmkwmkxhvjUaDY3k/Ycyi4YhlGnHKFCNLTVLixHEcSktLkZ6e7jTjImdNgezLfVmSC/kM0/fff4+srCzx+8ceewwAsGzZMqxfvx433ngjzp07hxdffBH19fUYO3Ys8vLyQjpYckSj0UCjcZ7iValUTmvHAkLDkWrveN+u2FmWdTtN2dHe2NgInuehVqvd+i5HTQKefGdZFufOnYNarXZ6jpw1SY2TEG9/+O7JHmxNUuzu4i1nTVJ9b2xs9Hi9XDV1ZmdZ1inearUa2h7268y89D473DRJjVNDQwNYlnV7H7lqAgLTl3vy1+3rJF8ZIGbNmgVvk1zLly/H8uXLg+SRb5BQuNLxOSR90pLy6dFRPymapCR9C5CiydF3b5qEryRp6sx34Rqe5/1euDJUmjqzC5oc480wDLSR9uvN0BJduFJ4bccSEnLWFMi+XFaFK+UGqTlMAiSu5Xe27g1A3AZLgiapcRIgSZO3OAk+CvEmQZPUOAH29Ad3ZQXkqklqnAwGA6Kjo3FZ7FgA9gFTXt5XstYEeI6TUFagsrLSbVkBOWoKZF8uqxwmuUJSDpPNZkNdXR0GDx4MnueJ+aTl7VOJxWJBTU0NBg4cKE4By12TlDjZbDacOnUKycnJsNlsRGhy9N2T3WQyoa6uTow3CZqkxMlms6G+vh6JiYlOz5Szps7sjjNMQrxVKhWafm5G3+H2WkztLUaotCrZaZISJ57nUV9f73IsmJw1BbIvJ6asACU4sKzyDmsE7LoTExMVqTs5OVmRumm8lUPHeAs5TABgbjF7epnsUWK8g/W3TZfkfITUJTmVSoUFCxbgxIkTxExNh/osuXBe6tHpdJg7dy5RmkiMk780RUVFYeLEiSguLiZGk69xumLKFeL33/wvH7o4rew1eVqSM5lM6N+/Pz1Lji7JhQckLcnRSt+00rfcNTn67slOK30ru9K3ilWBVdn11x08jbhRfWWnSWrSN630TWhZAblDSlkBAdK21wKdaxKeobSyAt7sJGvqGG8SNEmxMwxDnCZPdpZlneItPEsDMyzQgjc5l9SQiyZf46SUsgLd6ct9KSugnEVOCoVCoSgaLey5S+Y2q5crKRRX6AxTNyGhDpPNZsOUKVM69V1umhztnnwHgMmTJ4s7akjQJHWX3NSpUzvVKjdNjr57sttsNqd4k6BJ6i65yy+/3O31ctXUmV3Q5Bhvq9UKtVoNLWNBKw+0XmwX6zPJSZPUXXLCYfWOz5WzpkD25bQOUwAhNek7Li4OAwYMUNT5Q4cPHyZOky9xYlkW27dvJ0pTZ3HaunUrcZp8iVNraytxmnyNkxb2N8c9u/ai0vYjEZroWXLd68tp0ncQIC3pu7CwENnZ2YpL+t66dStmz56tuKRvId5KS/ouLCwU402CJqlJ34WFhZg/f77ikr6FeGu1WqjVaiSqT6GWS8Ce9Ycw8ZZRstMkNem7sLAQc+bMUVTSd1f7cpr0HURISfoWGiepyY+eNHEcp8ikbyHeJGnyZtdoNG7jLXdNUuwcxyky6VuIt/AsLWN/k7eZnF8nF01S42S1WhWX9N3VvpwmfVMoFAqF0gEta5/lMLdzXq6kUFyhAyYKhUKhKAI6YKJ0B7ok101I2CXH8zxmzJhB3Fq+t3VvhmEwffp08RR3EjRJiRPP85g5cybUajUxmhx992Tned4p3iRokhInnucxa9YsqFQqRe2Sc4y3uEuOtetpb7UQu0sOsCdgMwyjmF1y3enL6S65AELqLrnY2Fhid4t40nTo0CHiNEmN07hx4xATE0OUJm9xMhgMxGmSGqd58+ahubkZ27dvJ0ZTV+Kk/jWH6Uj5cfB5Z4jQ5C5OkydPxvHjx3Hs2DFiNAWqL6e75IIAabvk6NEoytolR49GUdYuOXo0in2XXFbvH7D9wgR8/OAuXL9qquw0Sd0lR49GobvkwhJSdskJkLZbBKBHowBUk6OPStwlB9CjUQBAq7K/CXMWsnfJAfRolM58p7vkKBQKhULpBK3KPjthMdGFFYrv0AEThUKhUBSBVm0fMJnpgInSBWgOUxcRcpikrHuGO467SDrmOJAM1U11KwGq+5Lum5NL8OnJTLxxzQ489MXMEHsYGJQY7+5o9uW9nOYwdRNSygq0traiV69eRCU/SknobG5uRlRUFBjm/7d370FV1vkfwN/nAoiAGBcJ5GaRmqhxMTZNENRVw9RSy9l1FEKbnNqf+nOsbBq33Z2aJhfXbqvmVl6atnRzcHccK5jiFm4pKC2IsuJKAqKGsHI5XM45z/f3Bz+OHA9wDnIu8Dzv18yZ4nsenvN5P9/zHL4+l+9RySaTLdMK6HQ6+Pr6yiZT79oHytTa2mrqb7lksla7EALt7e3w8fGRTaaB2nsyGQwGU3+r1eruaQX+/whTR4ck62kF2tvbMXr0aLNaRnImR36Wc1oBB5LrtAI967l06ZKsbq8d6FbUH3/8EbW1tbLKZGs/9dRTWFgom0ycVqD/TACQmJiIwsJC2WS6m35SoQsAcLXuZ5w4cUIWmfqaIqahoQFRUVGoqqqSRSZHfpZzWgEn4LQCwztT73ZOK8BpBTitAKcV0Gq1eH5qPvacm4Ptid9i+zeJIy4TpxXgtAIjGqcVGNmZel6D0wpYr3Gw7cM1E6cVMDeSM/XX3t+0Ah7u3c8bDGqz3xspmTitAKcVoGGgvzeW3DG3sjC3styZ292t+6hCV5crqnEeJfa3MzLzlNxdktNdckRESrA9MQ+vf5eM/5mej3d/lOddcjQ4g/lbziNMBEmScOPGDbNzw0rA3MytBMx9O7f7/5+S69LL93Z7Jfa3szJzwEQwGo345z//aXFrqtwxN3MrAXPfzt1zuUqnjAdMSuxvZ2XmgImIiBTB3aP7v3oD//TR4PFdQ0REiuDu3n1kSW+U7xEmchzlXUpvZ3KY6dtgMJhmSJXTfCTW5u6QJAne3t6m15BDJlv6qXd/yyVT79oHau/d33LIZEs/9eQGLGc1HqmZBmrvPdN3T3/31K4xnZJTy3amb6PRCB8fH0iSZPa6IzmTIz/LOdO3A8l1pu/AwEBotVpcuHBBNjPeWpsdtqKiAq2trcjOzpZNpsH0k1arxbfffiurTAP107fffmua1E8umeTYT/bOlJ2dbcqkN3TP6tzWrpftTN+BgYGYO3cuP8s50/fwIaeZviVJQl1dHSIjIyGEkM2/tKz9q0Sv16Ompgbjx483TZQ20jPZ0k+SJOHq1auIiIiAJEmyyNS79v7aOzs7UVdXZ+pvOWSypZ8kSUJ9fT3CwsIs7iIaqZkGau/JpNfrTf2t0Wig1Wpx6LlCpO1LxHy/Epy4Nn3EZbKln4QQqK+vR0hIiNk6RnImR36Wc6ZvJ5LDTN96vR5lZWUICwuDm5ubLGe87at2AGa5rdU+EjLZ0k96vR7/+te/EBoaapfa+2sfbjNIq9XqPvt7JGeypXa9Xo8ff/wR48ePl00ma+09tff0d89rjRrdXZ9Bku9M33q9HqWlpQgJCVHMTN/A3X+Wc6ZvIiKiO7i5d//J6zL2/UeXaCAcMBERkSK4e3YPlPQSB0w0eBwwEVQqFQIDAy2+yVzumJu5lYC5b+d28+g5wiTfq1GU2N/OysyLvu8Sv0uOiGhkyXu7FCn/G4MH3S+hovN+V5dDwwC/S44GxWg04sKFC4qaSh9gbuZWBua+ndt0Sk7I95ScEvvbWZk5YCJIkoTKykpFfVkjwNzMrQzMfTu326jugVKXJN9Tckrsb2dl5oCJiIgU4fYRJvkOmMhxOGAiIiJFMB1hErbPvUPUgwMmglqtRnh4eJ8ThckZczO3EjD37dzuXt0DJTkfYVJifzsrsyLuknvyySeRl5eHefPm4YsvvjB7TqvVYurUqQCAGTNm4MMPP7RpnbxLjohoZPmpqBaRs0MxCu1oF56uLoeGAd4ld4eNGzfi0KFDfT43duxYlJaWorS01ObBktwYjUacPXtWUXdVAMzN3MrA3L3ukus5wgT5npJTYn87K7MiBkwpKSnw8fFxdRnDliRJuHLliqLuqgCYm7mVgbl73SXn2X0qzggtJIM8t4cS+9tZmV0+YCooKMCSJUsQEhIClUqFY8eOWSyze/duTJgwAaNGjUJ8fDwKCwvt9vrNzc2Ij4/H7NmzkZ+fb7f1EhHR8NJzhAkA9Dq9CyuhkcjlV761tbXhoYcewjPPPIMVK1ZYPH/48GFs3rwZu3fvxqOPPooPPvgAjz32GCoqKhAeHg4AiI+PR2dnp8XvZmdnIyQkZMDXr66uRkhICMrLy7F48WKUlZX1eR6zs7PT7DVu3boFAGhsbIRe373jqdVqaDQaGI1Gs5FuT7vBYEDvS8Y0Gg3UanW/7T3r7dHzDcsGg8Gmdjc3N0iSZHaYUqVSQavVmrXr9XrodDo0NzdDrVb3WftIy9S7vb/aOzo6oNPpcPPmTbi5uckiky391Lu/VSqVLDL1rr2/dp1OZ9bfcshkSz/19PetW7csvjpipGYaqL0nU+/9293dHVqtFjqDzrRc/ZVGjAkZM6Iy2dJPBoMBOp0OTU1N0GhuT9A5kjM58rO8paUFAGDT5dxiGAEgsrKyzNoSEhLEhg0bzNomT54stm3bNqh15+bmihUrVgy4zKJFi8Tp06f7fO61114TAPjggw8++OCDD5k9ampqrI4jXH6EaSBdXV0oKSnBtm3bzNoXLFiAkydPDnn9TU1NGD16NDw8PFBbW4uKigrcd999fS77yiuvYMuWLaafJUlCY2Mj/P39R/yXHDY3NyMsLAw1NTWKuuOPuZlbCZibueVuKJmFEGhpabF6NgoYBqfkBtLQ0ACj0YigoCCz9qCgIFy7ds3m9SxcuBBnzpxBW1sbQkNDkZWVhYcffhjnz5/Hc889B7VaDZVKhXfeeQd+fn59rsPDwwMeHh5mbWPHjh10puFszJgxitnBemNuZWFuZWFu5bjbzL6+vjYtN6wHTD3uPIIjhBjUUZ2vv/66z/ZZs2ahrKxsSLURERGR/Ln8LrmBBAQEQKPRWBxNunHjhsVRJyIiIiJHGdYDJnd3d8THxyMnJ8esPScnB7NmzXJRVfLj4eGB1157zeKUo9wxN3MrAXMzt9w5K7PLvxqltbUVVVVVAIDY2Fj86U9/QkpKCvz8/BAeHo7Dhw9jzZo12Lt3L2bOnIl9+/bhL3/5C86dO4eIiAhXlk5EREQK4fIBU15eHlJSUiza09LScODAAQDdE1fu2LED9fX1mDp1Knbt2oWkpCQnV0pERERK5fIBExEREdFwN6yvYSIiIiIaDjhgIiIiIrKCAyYiIiIiKzhgIps8+eSTuOeee7By5UqL544fP45JkybhgQcewIcffuiC6hyvsrISMTExpoenpyeOHTvm6rKcQqfTISIiAlu3bnV1KU4z0PtdLmpqapCcnIwpU6Zg+vTp+Nvf/ubqkpxGq9Wa9uX169e7uhyn2bVrF6KjozFlyhRs3LjRti+cHaH624eHsm/zom+ySW5uLlpbW3Hw4EF88cUXpnaDwYApU6YgNzcXY8aMQVxcHH744Yd+v2JGDlpbWxEZGYmffvoJXl5eri7H4V599VVcvHgR4eHhyMzMdHU5TtHf+11O6uvrcf36dcTExODGjRuIi4tDZWWlIt7TAQEBaGhocHUZTvXzzz/jkUcewblz5+Dm5oakpCRkZmZi5syZri7NIfrbh4eyb/MIE9kkJSUFPj4+Fu2nTp1CdHQ0xo8fDx8fH6Smpvb7VTRy8Y9//APz5s1TxB+Wixcv4sKFC0hNTXV1KU7V3/tdToKDgxETEwMAGDduHPz8/NDY2OjaosihDAYDOjo6oNfrodfrMW7cOFeX5DD97cND2bc5YJKBgoICLFmyBCEhIVCpVH2eKtq9ezcmTJiAUaNGIT4+HoWFhXZ57atXr2L8+PGmn0NDQ1FXV2eXdQ+GM7fBkSNHsGrVqiFWPHTOyLx161a8+eabdqrYPlz5fh9O7LkdiouLIUkSwsLCHFz10Nkjd3NzM+Lj4zF79mzk5+c7qfKhGWruwMBAbN26FeHh4QgJCcH8+fNx//33OzGB7YbrPs4Bkwy0tbXhoYcewvvvv9/n84cPH8bmzZvx6quv4uzZs0hMTMRjjz2GK1eumJaJj4/H1KlTLR5Xr14d8LX7OqM7mC9GthdnbYPm5mYUFRUNiyMujs7897//HRMnTsTEiROdFckmrny/Dyf22A4AcPPmTaxduxb79u1zRtlDZo/c1dXVKCkpwd69e7F27Vo0Nzc7q/y7NtTcTU1NOH78OKqrq1FXV4eTJ0+ioKDAmRFsZq/3tt0JkhUAIisry6wtISFBbNiwwaxt8uTJYtu2bYNad25urlixYoVZW1FRkXjiiSdMP2/cuFF8+umngyvazhy5DQ4dOiRWr1491BLtzhGZt23bJkJDQ0VERITw9/cXY8aMEb///e/tVbJdOPv9Plzd7Xbo6OgQiYmJ4tChQ84o0+7s0f+LFi0Sp0+fdlSJDnE3uY8cOSKef/5503M7duwQb731lsNrHaqh9HF/+/Dd7ts8wiRzXV1dKCkpwYIFC8zaFyxYgJMnTw55/QkJCSgvL0ddXR1aWlpw4sQJLFy4cMjrtSd7boPhcjrOGntkfvPNN1FTU4Pq6mpkZmbi2WefxW9/+1tHlGs3jn6/jxS2bAchBNLT0zF37lysWbPGFWXanS25m5qa0NnZCQCora1FRUUF7rvvPqfXak+25A4LC8PJkyfR0dEBo9GIvLw8TJo0yRXlDokr93GtQ9dOLtfQ0ACj0YigoCCz9qCgIFy7ds3m9SxcuBBnzpxBW1sbQkNDkZWVhYcffhharRY7d+5ESkoKJEnCSy+9BH9/f3vHGBJ7bYNbt27h1KlTOHr0qL1LtDt7ZR5pHP1+Hyls2Q5FRUU4fPgwpk+fbrpG5JNPPsG0adOcXa7d2JL7/PnzeO6556BWq6FSqfDOO++M+Lt6bcn9yCOPIDU1FbGxsVCr1Zg3bx6WLl3qinKHxNZ9vL99eCj7NgdMCnHndUVCiEFdazTQnW9Lly4dETveULeBr68vrl+/bu+yHGqomXukp6fbqSLncOT7fSQZaDvMnj0bkiS5oiyHGyj3rFmzUFZW5oqyHM7a+/6NN97AG2+84eyyHMJa1v724aHs2zwlJ3MBAQHQaDQW/7q+ceOGxQhdrpS4DZSYGVBu7jspdTswt/xzuzIrB0wy5+7ujvj4eOTk5Ji15+TkYNasWS6qyrmUuA2UmBlQbu47KXU7MLf8c7syK0/JyUBrayuqqqpMP1++fBmlpaXw8/NDeHg4tmzZgjVr1mDGjBmYOXMm9u3bhytXrmDDhg0urNq+lLgNlJgZUG7uOyl1OzB3NznnHrZZB31fHQ07ubm5AoDFIy0tzbTMn//8ZxERESHc3d1FXFycyM/Pd13BDqDEbaDEzEIoN/edlLodmFv+uYdrVn6XHBEREZEVvIaJiIiIyAoOmIiIiIis4ICJiIiIyAoOmIiIiIis4ICJiIiIyAoOmIiIiIis4ICJiIiIyAoOmIiIiIis4ICJiIiIyAoOmIiIXKSrqwtRUVEoKiqy63qPHz+O2NhYSJJk1h4ZGQmVSgWVSoX//ve/dn1NIrnjgImI7CI9Pd30x7j3o/eXaJK5ffv2ISIiAo8++qipTaVS4dixYxbLpqen44knnrBpvY8//jhUKhX++te/mrWfPn0aR48eHUrJRIrFARMR2c2iRYtQX19v9pgwYYLFcl1dXS6obvh57733sH79eoes+5lnnsF7771n1hYYGAg/Pz+HvB6R3HHARER24+HhgXvvvdfsodFokJycjN/85jfYsmULAgIC8Mtf/hIAUFFRgdTUVHh7eyMoKAhr1qxBQ0ODaX1tbW1Yu3YtvL29ERwcjJ07dyI5ORmbN282LdPXEZmxY8fiwIEDpp/r6uqwatUq3HPPPfD398eyZctQXV1ter7n6E1mZiaCg4Ph7++PF154AXq93rRMZ2cnXnrpJYSFhcHDwwMPPPAAPvroIwghEBUVhczMTLMaysvLoVarcenSpT631ZkzZ1BVVYXFixcPcisD1dXVfR7NS05ONi2zdOlSnDp1Cv/5z38GvX4issQBExE5xcGDB6HValFUVIQPPvgA9fX1mDNnDmJiYlBcXIyvvvoK169fx9NPP236nRdffBG5ubnIyspCdnY28vLyUFJSMqjX1el0SElJgbe3NwoKCvDdd9/B29sbixYtMjvSlZubi0uXLiE3NxcHDx7EgQMHzAZda9euxeeff453330X58+fx969e+Ht7Q2VSoWMjAzs37/f7HU//vhjJCYm4v777++zroKCAkycOBFjxowZVB4ACAsLMzuKd/bsWfj7+yMpKcm0TEREBMaNG4fCwsJBr5+I+iCIiOwgLS1NaDQa4eXlZXqsXLlSCCHEnDlzRExMjNny27dvFwsWLDBrq6mpEQBEZWWlaGlpEe7u7uLzzz83PX/z5k3h6ekpNm3aZGoDILKysszW4+vrK/bv3y+EEOKjjz4SkyZNEpIkmZ7v7OwUnp6e4uuvvzbVHhERIQwGg2mZp556SqxatUoIIURlZaUAIHJycvrMfvXqVaHRaMQPP/wghBCiq6tLBAYGigMHDvS7vTZt2iTmzp1r0Q5AjBo1ymw7enl5Ca1WK5YtW2axfHt7u/jFL34hHn/8cWE0Gs2ei42NFb/73e/M2nJzcwUA0dTU1G9tRGRJ69LRGhHJSkpKCvbs2WP62cvLy/T/M2bMMFu2pKQEubm58Pb2tljPpUuX0N7ejq6uLsycOdPU7ufnh0mTJg2qppKSElRVVcHHx8esvaOjw+x0WXR0NDQajenn4OBglJWVAQBKS0uh0WgwZ86cPl8jODgYixcvxscff4yEhAQcP34cHR0deOqpp/qtq729HaNGjerzuV27dmH+/PlmbS+//DKMRqPFsuvWrUNLSwtycnKgVpufNPD09IROp+u3BiKyHQdMRGQ3Xl5eiIqK6ve53iRJwpIlS/DWW29ZLBscHIyLFy/a9JoqlQpCCLO23tceSZKE+Ph4fPrppxa/GxgYaPp/Nzc3i/X23Jbv6elptY7169djzZo12LVrF/bv349Vq1Zh9OjR/S4fEBBgGpDd6d5777XYjj4+PhZTAbz++uv46quvcOrUKYsBIQA0NjaaZSSiu8cBExG5RFxcHI4ePYrIyEhotZYfRVFRUXBzc8P333+P8PBwAEBTUxP+/e9/mx3pCQwMRH19vennixcvmh1ViYuLw+HDhzFu3Li7ul4IAKZNmwZJkpCfn29x5KdHamoqvLy8sGfPHnz55ZcoKCgYcJ2xsbHYs2cPhBBQqVSDruno0aP4wx/+gC+//LLP66R6jqDFxsYOet1EZIkXfRORS7zwwgtobGzEr371K9PdXNnZ2cjIyIDRaIS3tzfWrVuHF198Ed988w3Ky8uRnp5ucdpp7ty5eP/993HmzBkUFxdjw4YNZkeLVq9ejYCAACxbtgyFhYW4fPky8vPzsWnTJtTW1tpUa2RkJNLS0pCRkYFjx47h8uXLyMvLw5EjR0zLaDQapKen45VXXkFUVJTZqcS+pKSkoK2tDefOnRvEVutWXl6OtWvX4uWXX0Z0dDSuXbuGa9euobGx0bTM999/Dw8PD6t1EJFtOGAiIpcICQlBUVERjEYjFi5ciKlTp2LTpk3w9fU1DYr++Mc/IikpCUuXLsX8+fMxe/ZsxMfHm61n586dCAsLQ1JSEn79619j69atZqfCRo8ejYKCAoSHh2P58uV48MEHkZGRgfb29kEdcdqzZw9WrlyJ559/HpMnT8azzz6LtrY2s2XWrVuHrq4uZGRkWF2fv78/li9f3uepQmuKi4uh0+nw+uuvIzg42PRYvny5aZnPPvsMq1evHvC0IBHZTiXuPPlPRDSMJScnIyYmBm+//barS7FQVFSE5ORk1NbWIigoyOryZWVlmD9/fp8XpQ/Fzz//jMmTJ6O4uNhi4tC8vDykpKSgqakJY8eOtdtrEskdr2EiIhqizs5O1NTUYPv27Xj66adtGiwB3ddG7dixA9XV1Zg2bZrd6rl8+TJ2795tMViKjo7mRJZEd4kDJiKiIfrss8+wbt06xMTE4JNPPhnU76alpdm9noSEBCQkJFi0nzhxwnQH4d1eAE+kVDwlR0RERGQFL/omIiIisoIDJiIiIiIrOGAiIiIisoIDJiIiIiIrOGAiIiIisoIDJiIiIiIrOGAiIiIisoIDJiIiIiIr/g/erCl4W4pQJAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -477,49 +964,297 @@ } ], "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_no_ssa, color='blue', lw=1, label='Model SED w/o SSA')\n", - "#plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_cotter, color='green', lw=2, label='Model SED')\n", - "plt.loglog((nu_obs).to(u.eV, equivalencies=u.spectral()), sed_ssa, color='red', lw=1, label='Model SED w SSA')\n", - "# Overlay updated data points\n", - "plt.loglog(x_sorted, y_sorted, linestyle='dotted', color='green',label='BL Lac C&P')\n", - "\n", - "plt.xlabel(\"Energy [eV]\")\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-14, 1e-9)\n", - "plt.xlim(1e-8,1e6)\n", - "plt.legend()\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": { 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": "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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]*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 +}